Una vez completada la fase de compilación de un nuevo kernel Linux y sus módulos asociados, el siguiente paso indispensable es integrar estos componentes en el sistema y asegurar que el gestor de arranque pueda iniciar la nueva versión. Este documento detalla los pasos necesarios para llevar a cabo estas operaciones. Es crucial recalcar que todas las acciones descritas a continuación deben ejecutarse con privilegios de superusuario (root).
Método de Instalación Automatizado de la Distribución
La mayoría de las distribuciones Linux incluyen herramientas o scripts diseñados para automatizar la instalación de kernels compilados. Un script común es installkernel, que a menudo forma parte del paquete mkinitrd. Este se encarga de posicionar los archivos del kernel en sus ubicaciones apropiadas y, frecuentemente, de actualizar la configuración del gestor de arranque.
Para proceder con la instalación de los módulos del kernel que se compilaron, utilice el siguiente comando:
# make modules_install
Este comando se encargará de copiar todos los módulos compilados al sistema de archivos, generalmente en una subestructura dentro de /lib/modules/<versión_del_kernel>, donde <versión_del_kernel> es el identificador de la versión de kernel que acaba de generar.
Tras asegurar que los módulos estén en su lugar, el siguiente paso es instalar la imagen principal del kernel:
# make install
La ejecución de make install lleva a cabo las siguientes operaciones clave:
- Verifica la correcta compilación del kernel.
- Copia la imagen binaria del kernel (comúnmente
vmlinuzobzImage) al directorio/boot, asignándole un nombre basado en la versión del kernel. - Genera automáticamente cualquier imagen de disco RAM inicial (
initramfsoinitrd) que pueda ser requerida, utilizando los módulos previamente instalados. - Notifica al gestor de arranque sobre la disponibilidad del nuevo kernel, añadiéndolo a las opciones de arranque para que el usuario pueda seleccionarlo en el siguiente inicio del sistema.
- Es importante señalar que este procedimiento no sobrescribe ninguna versión de kernel existente, lo que proporciona una red de seguridad, permitiendo regresar a un kernel anterior en caso de cualquier problema con la nueva versión.
Instalación Manual del Kernel
En situaciones donde la distribución carezca del comando installkernel, o si se desea un control más granular sobre el proceso de instalación para comprender cada paso, se puede optar por la instalación manual.
El primer paso es instalar los módulos del kernel, de la misma forma que en el método automatizado:
# make modules_install
A continuación, es fundamental conocer la versión exacta del kernel recién compilado. Esto se puede determinar ejecutando:
# make kernelversion
Asumiendo que la versión obtenida es X.Y.Z-custom, utilizaremos <VERSION_KERNEL> como un marcador de posición. Proceda a copiar la imagen del kernel y el archivo System.map al directorio /boot. Para una arquitectura x86_64, los comandos serían:
# cp arch/x86_64/boot/bzImage /boot/vmlinuz-<VERSION_KERNEL>
# cp System.map /boot/System.map-<VERSION_KERNEL>
Asegúrese de sustituir x86_64 por la arquitectura específica de su sistema y <VERSION_KERNEL> por la versión real de su kernel.
A menudo, un kernel requiere una imagen initramfs para inicializarse correctamente, especialmente si los controladores de hardware críticos (como los de disco o sistema de archivos) están compilados como módulos. Herramientas como mkinitcpio (Arch Linux), dracut (Fedora/RHEL) o update-initramfs (Debian/Ubuntu) pueden usarse para generar esta imagen, dependiendo de su distribución.
Para facilitar la copia manual de archivos y la obtención de la versión, el siguiente script puede ser de utilidad:
#!/bin/bash
# Script para la instalación manual de archivos base del kernel Linux
# Requiere ejecución como root
echo "Realizando instalación de módulos del kernel..."
make modules_install
# Extraer componentes de la versión del kernel desde el Makefile
VERSION_PRINCIPAL=$(grep ^VERSION Makefile | awk '{print $2}')
VERSION_PARCHE=$(grep ^PATCHLEVEL Makefile | awk '{print $2}')
VERSION_SUB=$(grep ^SUBLEVEL Makefile | awk '{print $2}')
VERSION_EXTRA=$(grep ^EXTRAVERSION Makefile | awk '{print $2}')
NOMBRE_COMPLETO_KERNEL="${VERSION_PRINCIPAL}.${VERSION_PARCHE}.${VERSION_SUB}${VERSION_EXTRA}"
# Determinar la arquitectura del sistema
ARQUITECTURA_ACT=$(grep "CONFIG_ARCH" include/linux/autoconf.h | cut -d'"' -f2)
echo "Copiando imagen del kernel ${NOMBRE_COMPLETO_KERNEL} para arquitectura ${ARQUITECTURA_ACT}..."
# Copiar la imagen bzImage (binario del kernel)
cp "arch/${ARQUITECTURA_ACT}/boot/bzImage" "/boot/vmlinuz-${NOMBRE_COMPLETO_KERNEL}"
# Copiar el archivo System.map, esencial para depuración
cp System.map "/boot/System.map-${NOMBRE_COMPLETO_KERNEL}"
echo "Archivos base del kernel ${NOMBRE_COMPLETO_KERNEL} (${ARQUITECTURA_ACT}) instalados."
echo "IMPORTANTE: Genere el initramfs y actualice su gestor de arranque (GRUB/LILO) manualmente."
Configuración del Gestor de Arranque para el Nuevo Kernel
Para que el sistema operativo pueda iniciar con el kernel recién instalado, es imprescindible actualizar la configuración del gestor de arranque. Los gestores más comunes en entornos Linux son GRUB (GRand Unified Bootloader) y LILO (LInux LOader).
Para identificar cuál de estos gestores utiliza su sistema, puede buscar el directorio /boot/grub o el archivo /etc/lilo.conf:
$ ls -F /boot | grep grub
grub/ # Presencia de este directorio indica GRUB
$ ls /etc/lilo.conf
/etc/lilo.conf # La existencia de este archivo indica LILO
Una vez que haya determinado el gestor de arranque, consulte la sección correspondiente para aplicar los cambios.
Configuración con GRUB
GRUB es el gestor de arranque dominante en la mayoría de las distribuciones Linux actuales. Para integrar un nuevo kernel, el procedimiento recomendado implica modificar los archivos de configuración ubicados en /etc/grub.d/ y luego generar el archivo principal /boot/grub/grub.cfg. No se aconseja editar grub.cfg directamente, ya que las actualizaciones del sistema pueden sobrescribirlo. Para una referencia detallada, consulte info grub o man grub-mkconfig.
Una forma efectiva de añadir una nueva entrada de kernel es crear o modificar un archivo en /etc/grub.d/ (por ejemplo, /etc/grub.d/40_custom). A continuación, se presenta un ejemplo de cómo se podría estructurar una entrada para un kernel compilado dentro de 40_custom:
#!/bin/sh
exec tail -n +3 $0
# Este archivo contiene entradas de menú personalizadas que se añadirán a grub.cfg
menuentry 'Mi Kernel Personalizado (Version 6.5.0)' --class gnu-linux --class gnu --class os {
insmod gzio
insmod part_msdos # o part_gpt si su disco usa tabla de particiones GPT
insmod ext2 # o el módulo de su sistema de archivos raíz (ej. ext4, btrfs)
set root='hd0,msdos1' # Ajusta esto a la ubicación de su partición raíz
# Opcional: use el UUID de su partición raíz para mayor robustez
# search --no-floppy --fs-uuid --set=root <UUID_DE_SU_PARTICION_ROOT>
echo 'Cargando Linux 6.5.0-custom...'
linux /vmlinuz-6.5.0-custom root=/dev/sda1 ro quiet # Reemplace /dev/sda1 con su partición raíz real
echo 'Cargando disco RAM inicial para 6.5.0-custom...'
initrd /initrd.img-6.5.0-custom # Si ha generado una imagen initramfs para este kernel
}
Es vital sustituir <UUID_DE_SU_PARTICION_ROOT> por el UUID real de su partición raíz (que puede obtenerse con blkid) o ajustar root=/dev/sda1 según la configuración de su sistema. Confirme que las rutas /vmlinuz-6.5.0-custom y /initrd.img-6.5.0-custom coinciden con los nombres de archivo que ha copiado a /boot.
Una vez que haya guardado el archivo modificado en /etc/grub.d/, proceda a ejecutar el comando para actualizar la configuración principal de GRUB:
# update-grub
Este comando (o, alternativamente, grub-mkconfig -o /boot/grub/grub.cfg) regenerará /boot/grub/grub.cfg, incorporando su nueva entrada de kernel. Después de reiniciar el sistema, la opción "Mi Kernel Personalizado (Version 6.5.0)" estará disponible en el menú de arranque de GRUB.
Configuración con LILO
Aunque LILO (LInux LOader) es menos frecuente en instalaciones modernas, aún se encuentra en algunos sistemas. Para que LILO reconozca un nuevo kernel, es necesario editar el archivo de configuración /etc/lilo.conf y, posteriormente, ejecutar el comando lilo para que los cambios se apliquen al sector de arranque. Para detalles sobre la estructura de configuración de LILO, puede consultar su página del manual (man lilo).
El método más sencillo para añadir una nueva entrada es duplicar una sección image ya existente y adaptarla. Considere el siguiente ejemplo de un archivo lilo.conf:
boot=/dev/sda
prompt
timeout=50
default=linux-5.15
image=/boot/vmlinuz-5.15.0
label=linux-5.15
read-only
root=/dev/sda1
image=/boot/vmlinuz-6.1.0
label=linux-6.1
read-only
root=/dev/sda1
Para añadir una nueva entrada para un kernel denominado 6.5.0-custom, copiaría y adaptaría una sección image de la siguiente manera:
# ... entradas existentes ...
image=/boot/vmlinuz-6.5.0-custom
label=linux-6.5-custom
read-only
root=/dev/sda1
# initrd=/boot/initrd-6.5.0-custom.img # Descomente si usa un initramfs
Una vez que haya guardado los cambios en /etc/lilo.conf, es imperativo ejecutar el programa lilo para que la nueva configuración se escriba en el disco:
# /sbin/lilo
Tras la ejecución exitosa de este comando, puede reiniciar su sistema con la seguridad de que el nuevo kernel estará disponible para su selección durante el proceso de arranque.