Redes en Linux (XI)
por Narciso Cerro, de Piensa en Linux.

Compilar el núcleo.-

El núcleo (o kernel, se usarán los dos términos indistintamente) es en realidad lo más importante del sistema; Es el encargado de interactuar con el hardware de nuestro equipo. Cuando un usuario ejecuta programas, es el kernel el responsable de manejar la información para que el hardware se ponga a trabajar, ya sea comunicarse con la tarjeta de red o modem, gestionar el tiempo de uso de la CPU por cada programa (multitarea), la administración de memoria, etc. Todas estas funciones definen el funcionamiento de la máquina y es muy interesante conocer la posibilidades que nos permiten «afinar» la manera en que se va a comportar.

Las versiones.-

El núcleo está en continuo desarrollo y se actualiza con bastante frecuencia, por lo que es imprescindible saber que versión tenemos en nuestro equipo, que hardware soporta, y si realmente necesitaremos actualizarlo o simplemente re-compilar el que ya tenemos para optimizar sus prestaciones.

El comando uname -a muestra información de nuestro equipo, entre la cual se encuentra el número de la versión que estamos utilizando.

Los números de versión del núcleo se representa siguiendo un patrón que aporta bastante información, es más o menos así: 2.2.16.

El primer número indica la versión, una nueva versión solo se realiza cuando el kernel ha experimentado grandes cambios.

El segundo número indica la actualización, a mayor valor, más reciente es el núcleo, ademas si este número es par, indica que esa versión es estable, (y estable en el núcleo quiere decir exactamente eso, estable.) Sin embargo un número impar indica que es una versión de desarrollo y puede ser inestable. No quiere decir que vaya a ir mal necesaria-mente, pero se recomienda únicamente si se quiere experimentar o sí se necesita soporte urgente para algún tipo de dispositivo que se incluya en esta versión.

El último número es el de la revisión, indica el nivel de actualización que ha alcanzado esa versión.

Desde la llegada de la versión 2.x.x se trabaja con dos partes del núcleo diferentes, en primer lugar tenemos el núcleo en sí, (lo podemos llamar parte monolítica del núcleo) y en segundo lugar están los módulos.

La parte monolítica del núcleo es la que se carga en cada arranque y está activa en todo momento, sin embargo los módulos únicamente se activan cuando se requiere utilizar ese dispositivo en concreto. Esto significa que podemos tener una serie de dispositivos soportados, pero que no están cargados en memoria durante todo el tiempo, si no que se incorporan cuando se hace una llamada a ese hardware.

Tenga en cuenta el uso de módulos en todas las opciones crea que pueden ayudarle a optimizar el núcleo, y por consiguiente el rendimiento del sistema. Pero preste también atención a determinadas opciones que obligatoriamente deberán ir en la parte monolítica, como puede ser el soporte del sistema de archivos ext2fs, que se requiere desde al momento de arrancar.

El código fuente.-

Para compilar el núcleo necesariamente debe tener en el sistema el código fuente. En el caso de no haberlo instalado, hágalo desde el CD-ROM del sistema o descargelo del sitio oficial del núcleo:

http://www.kernel.org

Normalmente las fuentes se instalan en el directorio /usr/scr/linux.

Si va a actualizar y quiere mantener el código anterior, mantenga cada versión en directorios diferentes (por ejemplo: /usr/src/2.2.16 para la versión anterior y /usr/src/2.4.0 para la nueva) y simplemente haga un enlace simbólico del directorio que tenga el código que desee compilar al directorio /usr/src/linux.

Una vez instalado podemos ver un conjunto de directorios con todo el código necesario para hacer un nuevo núcleo «a medida», incluye abundante información en el directorio /usr/scr/linux/Documentation, no es mala idea dar un repaso a su contenido. Por ejemplo encontraremos en el fichero Changes una lista del software mínimo necesario para la correcta ejecución de ese kernel (esto es importante), además de pequeñas instrucciones concretas referentes a cualquier problema que pueda aparecer.

Preparándose para compilar.-

El proceso en sí es bastante sencillo, hay una serie de comandos que se repetirán cada vez que compilemos. Esta parte es puramente mecánica y la única complicación es elegir correctamente entre la gran cantidad de opciones de hardware disponibles.

Si es la primera vez que compila, la recomendación es: hágalo cuando tenga tiempo, las primeras veces debería leer cada menú e incluso las ayudas, después los recorrerá más rápidamente, aparte del tiempo que lleva la compilación en sí.

usr/src/linux-1.2.10-includes/include/asm-i386/
usr/src/linux-1.2.10-includes/include/asm-mips/
usr/src/linux-1.2.10-includes/include/asm-alpha/

Configurar el núcleo:

Elegir «que» va a componer nuestro nuevo núcleo. Aquí seleccionaremos que se cargará como módulo y que en la parte monolítica.

Existen tres modos de hacer esta tarea:

• La más peliaguda y tediosa es en modo texto,
• En formato «menús», por los que iremos seleccionando nuestra configuración
• En modo gráfico, más agradable pero requiere el conjunto TCL/TK (es un lenguaje de programación en entorno gráfico.)

Cualquiera de estas tres opciones son equivalentes en lo que referente al resultado, la diferencia está en el interface de usuario.

Siempre nos deberemos situar en el directorio /usr/src/linux para lanzar el programa de configuración que elija. La orden:

[Crispin@Globus /linux]$ make config

Lanzará el programa en modo texto. No es recomendable, por lo menos las primeras veces que intente la compilación, más que nada por el formato que usa. Le irá preguntando una a una por todas las opciones. Más cómoda es la orden:

[Crispin@Globus /linux]$ make menuconfig

Veremos un menú mucho más manejable que el anterior. La opción gráfica la veremos ejecutando (desde una sesión X) la orden make xconfig

Recorrer los menús:

Recorreremos todas las opciones de cada submenú, decidiendo si se incluyen o no en el núcleo y en que modo lo hacen. Desde cada submenú podemos pasar al siguiente o volver al principal. Es buena idea recorrerlos todos ordenadamente (empezando por el principio), así nos aseguramos de no dejar una opción sin revisar. Cuando tengamos más experiencia, lo usual es ir directamente a las partes que deseamos modificar. Dentro de cada submenú marcaremos No para no incluir esa opción, Si para incluirla en la parte monolítica o M para que se cargue como módulo. Si la opción M aparece apagada significa que ese dispositivo no admite ser cargado como módulo, hay que optar por incluirlo o no.

Se encontrará en alguna (o en muchas...) ocasión un dispositivo u opciones que no sabe exactamente para que sirven. podremos recurrir a la Ayuda e incluye una pequeña descripción y recomendaciones generales del tipo: «...si no está seguro, marque «Si» en esta opción...», cosa que se agradece.

Cada opción que seleccione para ser compilada en la parte monolítica hará un núcleo un poco más grande, exigiendo así más memoria, de manera que sea cuidadoso.

Al acabar la configuración nos permiten guardar la configuración seleccionada, cosa que tendremos que hacer para compilar, no guardar y salir del programa de configuración, podremos también guardar la información de esta configuración en un fichero y cargar una configuración desde un fichero. Esto último es interesante ya que si por algún motivo cometemos un error en la compilación y es necesario rectificar un paso, no será necesario pasar por todas las opciones, si no que, cargando el fichero guardado, podremos realizar cambios únicamente en la zona afectada.

Observará también que hay opciones que dependen de que otras estén seleccionadas, por ejemplo, no seleccionar Soporte SCSI implica desactivar automáticamente todas las opciones de ese menú y del siguiente: Controladores SCSI de bajo nivel, téngalo también en cuenta.

Últimos consejos:

Como ya se ha comentado, las primeras veces que se compila, puede obtener resultados no esperados, tenga en cuenta que hay opciones que dependen de otras y quizá requiera varios intentos antes de tener su propio kernel. Recuerde guardar su configuración al terminar y si además lo hace en un fichero aparte, podrá recuperarla en ocasiones posteriores, ahorrando tiempo en la siguiente compilación.

Órdenes de compilación.-

Una vez seleccionadas las opciones de configuración del nuevo kernel, el proceso de compilación es significativamente más sencillo.

En primer lugar debe ejecutar (desde el directorio /usr/src/linux):

[Crispin@Globus /linux]$ make dep

Esta orden lee el archivo de configuración y genera el árbol de dependencias correspondiente, seleccionando los elementos que serán compilados y los que no. A continuación debe teclear la orden:

[Crispin@Globus /linux]$ make clean

Para eliminar residuos de anteriores compilaciones, para evitar errores entre versiones. Lo siguiente es el proceso de compilación en si:

[Crispin@Globus /linux]$ make zImage

También se puede emplear, alternativamente, la orden: make bzImage, que creará una imagen del núcleo más comprimida. El tamaño de la imagen es importante ya que no debe superar los 500 ó 600 kb. Esto es debido a la naturaleza de la arquitectura Intel, el kernel debe ser capaz de descomprimirse dentro del primer MB de memoria o dará un fallo en el arranque.

La ejecución de estas tres ordenes generan una imagen nueva del núcleo en el directorio /usr/src/linux/arch/i386/boot/

El nombre de la imagen será: zImage o bzImage dependiendo de la orden utilizada. Lo siguiente es copiar la imagen al directorio /boot:

cp /usr/src/linux/arch/i386/boot/bzImage /boot

Normalmente las imágenes usan un nombre que comienza con la cadena vmlinuz. Si quiere seguir este patrón, agregue un identificador propio que le permita distinguir las diferentes imágenes. Por ejemplo:

cp /usr/src/linux/arch/i386/boot/ bzImage /boot/vmlinuz.2.2.16-test

No elimine imágenes anteriores antes de haber comprobado el funcionamiento correcto del nuevo núcleo, mantenerlas no tiene efectos secundarios y le permitirá seguir entrando en el sistema en caso de errores graves.

Para tener opción en el arranque de utilizar la nueva imagen es necesario modificar la información que lilo tiene guardada en el mbr. Modifique el contenido del fichero /etc/lilo.conf, agregando una nueva entrada para la nueva imagen. (lo más practico es copiar integra la entrada de la imagen existente y modificar los campos label e image, con los nombres correspondientes. ¡No elimine la entrada original o no podrá entrar en el sistema en caso de algún fallo!.

Ejemplo de fichero /etc/lilo.conf con la imagen original.

boot=/dev/hda
map=/boot/map
install=/boot/boot.b
prompt
timeout=10
compact
image=/boot/vmlinuz-2.2.16-5.0 #Esta es la imagen original
label=linux
read-only
root=/dev/hda8
Ejemplo de fichero /etc/lilo.conf con las dos imagenes.
boot=/dev/hda
map=/boot/map
install=/boot/boot.b
prompt
timeout=10
compact
image=/boot/vmlinuz-2.2.16-5.0 #Esta es la imagen original
label=linux
read-only
root=/dev/hda8
image=/boot/vmlinuz-2.2.16-test #Esta es la imagen nueva
label=test
read-only
root=/dev/hda8

Después de esto es necesario ejecutar /sbin/lilo. No olvide este paso o no se agregará su imagen al menú de arranque.

Compilar los módulos.-

Antes de que poder arrancar con el nuevo kernel, necesitará compilar las opciones que configuró como módulo. Sencillamente ejecute la siguiente orden:

make modules

Ya solo queda una cosa por hacer, instalar los módulos. Un núcleo nuevo creará sus propios módulos, mientras que recompilar un kernel modificará los ya existentes, mi consejo es que haga copia de seguridad previamente.

Si la compilación falla y los módulos han sido sustituidos, es posible que pierda funcionalidad. Los módulos se almacenan en /lib/modules/X.X.X, siendo las X el número de versión del núcleo, en el ejemplo: 2.2.16. Para asegurarse de que mantiene los módulos originales ejecute:

mv /lib/modules/2.2.16 /lib/modules/2.2.16-originales

Así en caso de necesitar recuperarlos, simplemente volviendo a renombralos volverá a dejarlo todo como estaba.

Después de haber hecho la copia de seguridad de los módulos puede ejecutar la orden para instalar los módulos:

make modules_install

En este momento puede reiniciar el ordenador y en el prompt de Lilo seleccionar el núcleo nuevo. En caso de error, y si siguio las indicaciones de copias de seguridad, podrá arrancar con el antiguo y realizar las modificaciones necesarias.

Si arranca con el kernel recien compilado, dé un repaso por el sistema para comprobar que todo funciona como debería, disquetera, lector de CD-Rom, soporte de red, sistemas de archivos, puertos serie y paralelo, etc.

Continuará...