HOWTO Compilar el kernel manualmente

De Gentoo Linux Wiki

[editar] Introducción

El kernel es el núcleo del sistema operativo GNU/Linux, actualizándolo lograremos mejorar el soporte para nuevo hardware [usb, firewire, video, audio, ...], gestión de memoria, despachadores (schedulers), políticas de seguridad, etc. Es uno de los únicos procesos que requieren reiniciar el sistema, y aunque hay un proyecto para cambiar de kernel en caliente es desaconsejable usarlo.

En este manual se contempla la instalación de un kernel 2.6, ¡ojo porque la instalación de un kernel antiguo de la rama 2.4 es ligeramente diferente!

[editar] Obtención del código fuente del Kernel

Para obtener las fuentes del kernel y proceder a su compilación e instalación hay dos formas:

[editar] A través de Portage

Gentoo tiene varias versiones del kernel en portage, así que puedes obtenerlas fácilmente con el comando emerge:

1. vanilla-sources (versión "original" de kernel.org)
2. gentoo-sources (rama 2.6.x del kernel con parches gentoo)
3. Etc...

Instalar vanilla-sources sería lo mismo que descargar el código manualmente y descomprimirlo (aunque al hacer el emerge y si no usas --oneshot cada vez que salga una versión nueva bajará e instalará el código fuente para que puedas compilarlo).

emerge vanilla-sources

Nota: Portage nos instalará el código fuente del kernel en /usr/src/linux-2.6.10-r1

Hay varios más incluidos en portage aunque ya son específicos de otras arquitecturas, kernels optimizados, kernels seguros, etc. Puedes ver los disponibles escribiendo:

emerge -s sources 

[editar] Manualmente

Hay varias versiones disponibles, pero lo recomendable es instalar la última versión estable. A fecha de hoy, sería la 2.6.10-r1

Nota: Si haces los pasos manualmente (sin usar portage), no es necesario ser root hasta el momento de instalar la imagen del kernel, por lo que es aconsejable hacer todo el proceso como usuario normal e identificarse como root al final del proceso (sección 5). Gracias a ArsDangor por la observación.

wget http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.8.1.tar.bz2

Una vez bajado el código fuente, procederemos a descomprimirlo (normalmente se hace en /usr/src aunque puede ser en cualquier otro directorio. Por seguridad lo haremos en la home de nuestro usuario)

tar xjf linux-2.6.10-r1.tar.bz2

[editar] Parcheando el Kernel

Muchas veces puede interesarnos parchear el kernel para mejorar, optimizar o añadir funciones al kernel. Para ilustrarlo en este manual, pondremos el ejemplo del bootsplash (splashutils), que nos permite usar imagenes de fondo en nuestras consolas con framebuffer.

Nota: Las versiones del kernel de gentoo ya disponen de este parche.

Lo primero es hacerse con el parche. Esto ya dependerá de cada parche, podemos buscar en google o en páginas relacionadas con el kernel. En el caso del bootsplash, el parche en cuestión esta en una web relacionada al proyecto.

wget http://www.bootsplash.de/files/bootsplash-3.1.4-sp3-2.6.8.1.diff

Una vez tengamos el parche (y lo descomprimamos en caso de ser necesario) ya podemos instalarlo mediante patch:

 cat bootsplash-3.1.4-sp3-2.6.8.1.diff | patch -p1

Nota: en este ejemplo se supone que el patch está en el mismo directorio que el kernel, en caso de no ser así simplemente especificas la ruta completa al patch, situándote en el directorio del kernel.

Una vez hecho esto, el código fuente del kernel habrá quedado parcheado, y en la configuración ya gozaremos de la nueva funcionalidad del bootsplash.

[editar] Configuración del kernel

Bueno, ya tenemos nuestro código fuente bajado y descomprimido, vamos a proceder a su configuración:

cd linux-2.6.10-r1 && make menuconfig

Una vez ejecutado este comando, se nos abre un menú basado en ncurses en el que podremos seleccionar todos los soportes que queramos incluir en nuestro kernel.

Cada una de las opciones podemos integrarla en el kernel [*] o bien compilarla como módulo [M]. La recomendación más extendida es la de integrar en el kernel los soportes que vamos a utilizar siempre, y dejar como módulos los soportes que usaremos ocasionalmente (usb, wireless, ntfs, nfs, etc.. dependerá de cada uno). Si queremos cargar alguno de estos módulos al inicio, bastará con añadirlos al fichero /etc/modules.autoload/kernel-2.6

Podemos cargar un módulo con la instrucción modprobe y también listar todos los módulos disponibles:

modprobe -l
#/lib/modules/2.6.10-r1/kernel/misc/svgalib_helper.ko

Vemos que tenemos disponible el módulo svgalib_helper (en este caso proporcionado por el paquete svgalib, que nos permite usar links en consola en modo gráfico entre otras cosas), procedemos a cargarlo en memoria:

modprobe svgalib_helper

[se omite el proceso de configuración ya que es diferente en cada máquina y sería difícil detallar todas las opciones.]

[editar] /usr/src/linux

Este enlace simbólico debe apuntar al kernel que vamos a usar, para que luego los paquetes que generen módulos (Como nvidia-kernel) se compilen sin problemas (puedan encontrar include/*):

rm /usr/src/linux && cd /usr/src && ln -s linux-2.6.10-r1 linux

[editar] Compilación del kernel

Procedemos a compilar el kernel:

La opción rápida y que compilará el kernel y los módulos es escribir simplemente make o make all en la carpeta linux. Si hacéis un make help veréis todas las opciones, y cómo make crea el kernel vmlinux, los módulos y la bzImage comprimida, básicamente. También ejecutaremos make modules_install para instalar los módulos que hayamos compilado, en el caso de que hayamos configurado alguna de las opciones como módulos.

make && make modules_install

[editar] Instalación del nuevo kernel

Una vez configurado y compilado nuestro kernel, procederemos a su instalación. Es el momento de identificarse como root si hemos realizado la instalación del código fuente via portage.

Primero montamos la partición boot en caso de que sea necesario (ya que por defecto siguiendo la instalación de gentoo la partición de boot no se monta cada vez que iniciamos el sistema):

mount /boot

Ahora copiamos el System.map a la partición de boot, añadiendo el distintivo de la versión de kernel que estamos usando:

cp System.map /boot/System.map-2.6.10-r1

Y copiamos también la imagen del kernel a la partición de boot:

cp arch/i386/boot/bzImage /boot/bzImage-2.6.10-r1

[editar] Modificando el bootloader

Hay muchas opciones a la hora de elegir un bootloader pero aquí sólo vamos a tratar dos:

[editar] Grub

Ya que tenemos /boot montado únicamente necesitaremos modificar el fichero de configuración grub.conf

nano -w /boot/grub/grub.conf

Ahora vamos a escribir el grub.conf. Esto sólo es un ejemplo, puede que el tuyo sea ligeramente diferente. Asegúrate de utilizar el nombre de tu archivo de imagen del kernel y, si es necesario, el nombre de tu imagen initrd.

 default 0
 timeout 30
 
 # Imagen de fondo. Debe tener máximo 14 colores (indexado) y formato xpm comprimido en gzip.
 # (hd0,0) en notación de grub se refiere a /dev/hda1
 splashimage=(hd0,0)/grub/splash.xpm.gz
 
 # Especificación de una entrada al menú. Suponemos que la partición que contiene a "/" es /dev/hda3
 title=Gentoo Linux
 root (hd0,0)
 kernel /bzImage-2.6.10-r1 root=/dev/hda3
 boot

Por último guarda la configuración y desmonta la partición boot.

umount /boot

[editar] Lilo

Lo primero que tenemos que hacer es editar nuestra configuración de Lilo:

nano -w /etc/lilo.conf

Ahora vamos a escribir el lilo.conf. Esto sólo es un ejemplo, puede que el tuyo sea ligeramente diferente. Asegúrate de utilizar el nombre de tu archivo de imagen del kernel y, si es necesario, el nombre de tu imagen initrd.

 boot=/dev/hda
 prompt
 timeout=50
 default=gentoo
 vga=788
 image=/boot/bzImage-2.6.10-r1
 label=gentoo
 read-only
 root=/dev/hda3

Ahora, guarda el archivo y sal del editor. Para terminar, debemos ejecutar el comando /sbin/lilo para aplicar los cambios y desmontar /boot. Acuérdate de que debes volver a ejecutar /sbin/lilo cada vez que instales un nuevo kernel o hagas cambios en el menú.

/sbin/lilo
umount /boot

[editar] Finalizando

En este momento te puede interesar recompilar los paquetes que hacen módulos para el kernel, como nvidia-kernel, ati-drivers o alsa, para ello haz:

# emerge -av `grep -l /lib/modules /var/db/pkg/*/*/CONTENTS | sed -e 's/\/var\/db\/pkg\//=/' -e 's/\/CONTENTS//'`

Este proceso puede ser automatizado utilizando el paquete sys-kernel/module-rebuild, que reconstruye los módulos que se han instalado utilizando emerge y que, por lo tanto, son gestionados por Portage. Su funcionamiento es sencillo, una vez instalado debe obtener información sobre qué módulos deberá actualizar:

# module-rebuild populate

A partir de entonces, el programa ya sabe qué deberá recompilar cuando el superusuario se lo indique, después de compilar el núcleo:

# module-rebuild -X rebuild

Por último, reinicia y disfruta ;)

[editar] Créditos

• Post Original por mvila
• Portado al wiki y pequeños agregados por Franco Gotusso
• Pequeñas correcciones ortográficas por DvD