No entraremos en detalles de cómo manejar este paquete, para eso están las instrucciones dentro del archivo descargado. Supongamos que tras seguir las instrucciones del programa obtenemos un archivo parche de nombre lvm-1.0.6-2.4.20.patch. Cualquier otro parche que nos bajemos de Internet o que generemos a partir de ciertos archivos será similar al anterior, o como mucho vendrá comprimido, como sucedía con el parche aplicado en párrafos previos. Para aplicar el parche obtenido en el caso de LVM deberíamos ejecutar los siguientes comandos:
usuario@cliente:/tmp$ cd /usr/src/linux-2.4.19/
usuario@cliente:/usr/src/linux-2.4.19$ cat /tmp/lvm-1.0.6-2.4.20.patch | patch -s -p1 --dry-run
usuario@cliente:/usr/src/linux-2.4.19$ cat /tmp/lvm-1.0.6-2.4.20.patch | patch -p1
usuario@cliente:/usr/src/linux-2.4.19$
Sólo un par de apuntes: aunque ahora la versión de las fuentes ya es 2.4.20 el nombre del directorio donde se encuentran sigue siendo como al principio. Si queremos ser coherentes deberíamos cambiar el nombre para reflejar la nueva versión, aunque no es necesario. Segundo, que como en el parche anterior primero comprobamos que aplica limpiamente, y sólo si es así aplicamos el parche. Puesto que los parches están creados con respecto a una versión estándar concreta (no parcheada) de las fuentes del núcleo, si parcheamos un núcleo ya parcheado (aunque los parches proporcionen características diferentes) es posible que obtengamos FAILED durante el proceso, lo que indicará que el parche no aplicó completamente.
Un último cambio que puede llevar a cabo antes de configurar las fuentes del núcleo consiste en cambiar el identificador de versión para así diferenciar los archivos de este núcleo compilado de los de otros núcleos ya instalados de la misma versión. Si edita el archivo /usr/src/linux/Makefile y modifica la línea que comienza por EXTRAVERSION, por ejemplo dejándola con el contenido EXTRAVERSION = -compilado, el núcleo compilado tendrá como versión la cadena 2.4.20-compilado y los módulos se instalán en directorio aparte, como veremos luego.
A continuación deberá configurar las fuentes del núcleo, que consiste en seleccionar todas las opciones que quiere incluir en el núcleo que compilar. Este proceso es el más largo, tedioso y propenso a fallos, sobre todo las primeras veces, y lo peor del caso es que resulta prácticamente imposible evitar estos problemas salvo leyendo la ayuda de todas las opciones de compilación (más de mil) y equivocándose muchas veces. Por suerte una vez que encuentre una configuración que funcione puede guardarla (puesto que está contenida en un archivo de texto) para usarla en futuras compilaciones, incluso de versiones distintas a la actual.
Existen tres interfaces de usuario para la configuración de las opciones del núcleo: una en línea de comandos, donde se nos preguntan una por una y de manera secuencial todas las opciones del núcleo, una en consola con menús basados en ncurses y otra gráfica usando Tcl/Tk. Estas tres interfaces de configuración se pueden lanzar con los comandos make config, make menuconfig y make xconfig, respectivamente.
La primera de ellas la podemos olvidar, porque al preguntarnos las opciones de manera secuencial sin posibilidad de marcha atrás es tremendamente improductiva y propensa a fallos. La configuración gráfica requiere el intérprete del lenguaje Tcl/Tk, y un servidor X-Window: nos presenta las opciones agrupadas en categorías, y podemos navegar por ellas y seleccionar opciones a nuestra voluntad, usando el ratón.
Por último, la opción make menuconfig nos presenta una interfaz de menús en modo texto navegable con las teclas de cursor, que por lo demás es funcionalmente idéntica a la interfaz gráfica, y será la que usemos en este artículo. Para poder ejecutar esta interfaz de menús es necesario tener instalada en la máquina el paquete libncurses-dev, para generar los menús. A continuación puede ver el aspecto de las tres interfaces de configuración mencionadas.
make config
make config
make menuconfig
make menuconfig
make xconfig
make xconfig
En principio puede moverse libremente por todos los menús y opciones de la interfaz mostrada, aunque la organización de las opciones es tal que lo más lógico es visitarlas en sentido descendente, comenzando por Code maturity level options. Tenga en cuenta que algunas opciones dependen de la presencia o ausencia de otras opciones en lugares distintos de los menús, de manera que es posible que no vea una opción concreta que debería estar ahí simplemente porque ha activado o desactivado otra opción que la oculta. Por ejemplo, si en el primer menú mencionado no selecciona la opción de mostrar las opciones en desarrollo o incompletas habrá ciertas otras opciones que no se le mostrarán.
A este respecto hay que advertir que aunque cierta opción se muestre como EXPERIMENTAL habitualmente puede seleccionarla sin miedo a problemas, puesto que estamos compilando un núcleo de la serie estable. Lo mismo se puede decir de las opciones marcadas como NEW, pero no de las marcadas como DANGEROUS, cuyo uso puede causar graves problemas de funcionamiento, especialmente la pérdida de datos en sus discos duros. En cualquier caso lo mejor siempre es leer la ayuda asociada a cada opción, y la documentación de referencia que allí se indique.
Además en la ayuda de la mayoría de las opciones, al final de la misma, indica la respuesta que debería dar a la pregunta en caso de que no haya entendido nada. La mayor parte de las veces responder así es lo correcto, y habitualmente lo peor que puede pasar es que deje de incluir alguna opción que sí necesitaba. Por lo demás la operativa para seleccionar las opciones de configuración no necesita de muchas explicaciones, aunque es recomendable hacer un par de indicaciones.
Primero, que las opciones pueden aparecer en tres formas de selección: como listas, opciones binarias sí-no, u opciones ternarias sí-no-mó. Cuando accede a una opción de tipo lista (por ejemplo (lista)) se desplegará una nueva ventana donde seleccionar el valor concreto para la opción. Las opciones binarias son de la forma [ ], y de estar activada ([*]) la opción correspondiente se compilará dentro del núcleo de Linux.
Las opciones ternarias son de la forma < >, y pueden estar desactivadas, activadas para compilar en el núcleo (<*>) o compiladas para compilar como módulo (<M>). El soporte para las opciones marcadas para compilar en forma de módulo podrá entonces cargarse en memoria automáticamente cuando dicho soporte sea necesario, sin ocupar espacio en memoria mientras tanto (aparte de otras ventajas, como el paso de opciones nuevas a los módulos sin necesidad de reiniciar).
Segundo, tenga mucho cuidado en guardar los cambios realizados en la configuración del núcleo al salir, puesto que de lo contrario todo su esfuerzo habrá sido en vano. Cuando seleccione Exit se le preguntará Do you wish to save your new kernel configuration?. Responda No sólo si efectuó cambios que no quiere guardar en el archivo de configuración.
Cuando salga de la interfaz de configuración guardando los cambios se generará un archivo de texto con las opciones de configuración seleccionadas, en concreto el archivo /usr/src/linux/.config. Guarde dicho archivo en lugar seguro, porque le servirá para compilar esta y otras versiones del núcleo con las opciones seleccionadas, que tantas horas de leer le puede haber supuesto. De hecho, si alguna vez instala las fuentes de una versión posterior del núcleo para configurarlas igual que el actual bastará copiar este archivo a /usr/src/linux/.config y ejecutar el comando make oldconfig, y responder únicamente a las opciones que no estaban presentes en la versión antigua.
El siguiente paso consiste en generar las dependencias para el proceso de compilación, de hecho al salir de la interfaz de configuración ya nos suele indicar cuál es el siguiente paso que debemos dar. Debemos ejecutar el comando make dep, que descenderá por todo el árbol de fuentes generando las dependencias mutuas entre los archivos, en función de las opciones seleccionadas, almacenadas en el archivo /usr/src/linux/.config. Este proceso debería ser razonablemente rápido, aunque depende mucho de la velocidad del disco y de la CPU: en cualquier caso verá por pantalla lo que está sucediendo, y comprobará que el proceso sigue adelante, y no se ha parado.
En este punto las fuentes del núcleo ya están preparadas para ser compiladas incluyendo las opciones seleccionadas previamente. Para iniciar el proceso de compilación del núcleo ejecute el comando siguiente. El proceso podrá tardar desde un par de minutos en máquinas con CPU muy potentes y núcleos con pocas opciones, a varias horas en equipos menos rápidos con núcleos llenos de opciones.
usuario@cliente/usr/src/linux-2.4.20$ make bzImage
...varios minutos u horas después....
Root device is (3, 2)
Boot sector 512 bytes.
Setup is 2522 bytes.
System is 1032 kB
warning: kernel is too big for standalone boot from floppy
make[1]: Leaving directory `/usr/src/linux-2.4.20/arch/i386/boot'
Varias cosas interesantes: se nos dice que el sistema de ficheros raíz que el núcleo montará durante el arranque corresponde con el dispositivo (major, minor) = (3, 2), que se corresonde con el dispositivo /dev/hda2. También se nos informa que la imagen del núcleo recién compilado tiene un tamaño de 1032 KiB, y que por lo tanto no "cabe" en un disquete (en realidad sí que cabe). Esta imagen del núcleo (el núcleo propiamente dicho), se encuentra en el directorio /usr/src/linux-2.4.19/arch/i386/boot como archivo de nombre bzImage. Este es el archivo que deberá referenciar desde su gestor de inicio para arrancar la máquina con esta versión del núcleo.
Usuarios que han visto este tema también han visto...
- Cómo escoger un proveedor de hosting
- Usabilidad en enlaces
- Usabilidad y los correos electrónicos de confirmación
- Lo que no se puede decir en Internet
- Cómo sabotear su posicionamiento en buscadores
- Versión imprimible de este documento
- Enviar por e-mail este documento
