¿Qué es LILO (Linux Loader)? Arquitectura, Configuración y Comparación con GRUB

LILO (Linux Loader) es un gestor de arranque heredado para Linux y sistemas operativos similares a Unix que carga el kernel directamente desde una dirección de disco almacenada en el momento de la instalación, sin requerir soporte de controlador de sistema de archivos durante la secuencia de arranque. Opera en la etapa previa al sistema operativo — ya sea desde el Master Boot Record (MBR) o un sector de arranque de partición — y transfiere el control de la CPU al kernel de Linux después de cargarlo en memoria.

Para la mayoría de los sistemas en producción hoy en día, LILO ha sido reemplazado por GRUB2. Sin embargo, comprender su funcionamiento interno sigue siendo esencial para los ingenieros que mantienen infraestructura heredada, sistemas embebidos o servidores aislados donde un gestor de arranque mínimo y determinista es una elección arquitectónica deliberada.

Cómo funciona el proceso de arranque de LILO a bajo nivel

Cuando una máquina se enciende, el BIOS ejecuta el POST (Power-On Self-Test), luego lee los primeros 512 bytes del disco de arranque — el MBR. Si LILO está instalado allí, esos 512 bytes contienen el cargador de primera etapa de LILO. La secuencia se desarrolla de la siguiente manera:

1. Etapa 1 (código MBR): El BIOS carga 512 bytes del MBR en memoria en la dirección `0x7C00` y transfiere la ejecución a él. Este pequeño fragmento conoce solo una tarea: localizar y cargar la Etapa 2.
2. Etapa 2 (archivo de mapa): LILO lee su archivo de mapa (`/boot/map`), que fue escrito en el momento de la instalación por el comando `lilo`. Este mapa contiene las direcciones absolutas de bloques de disco de cada imagen del kernel y entrada de cargador en cadena. Aquí no se realiza ningún análisis del sistema de archivos — LILO utiliza direcciones de sector LBA/CHS sin procesar.
3. Presentación del menú de arranque: Si `prompt` está configurado en `lilo.conf`, LILO muestra un menú de texto. La directiva `timeout` controla cuánto tiempo espera antes de usar el valor predeterminado.
4. Carga del kernel: LILO lee la imagen del kernel desde las direcciones de disco precomputadas en la memoria baja, luego la descomprime y reubica.
5. Transferencia de control: LILO pasa los parámetros de línea de comandos del kernel y la ubicación del disco RAM inicial (`initrd`) al kernel, que se encarga de la inicialización del hardware.

Implicación arquitectónica crítica: Debido a que LILO codifica las direcciones absolutas de bloques de disco en el momento de la instalación, cualquier cambio en el archivo del kernel, el diseño de particiones o `lilo.conf` requiere volver a ejecutar `/sbin/lilo` para regenerar el mapa. Olvidar este paso después de una actualización del kernel es la causa más común de fallos de arranque de LILO.

Configuración de LILO: Un análisis profundo de `/etc/lilo.conf`

LILO se configura completamente a través de `/etc/lilo.conf`. A continuación se muestra un ejemplo representativo de producción con anotaciones que cubren opciones que la documentación original frecuentemente omite:

“`ini

Global section

boot=/dev/sda # Install LILO to the MBR of /dev/sda

map=/boot/map # Path to the map file (must be on a non-LVM, non-RAID partition)

install=/boot/boot.b # Second-stage boot loader binary

prompt # Always show the boot menu

timeout=100 # Wait 10 seconds (units are 1/10th of a second)

default=linux-stable # Default entry label

lba32 # Enable LBA32 addressing — critical for disks > 8 GB

compact # Merge adjacent read requests; speeds up boot on HDD

Linux kernel entry

image=/boot/vmlinuz-5.4.0

label=linux-stable

initrd=/boot/initrd.img-5.4.0

root=/dev/sda1

read-only # Mount root read-only initially; fsck runs before remount rw

append="quiet splash"

Fallback kernel entry

image=/boot/vmlinuz-4.19.0

label=linux-fallback

initrd=/boot/initrd.img-4.19.0

root=/dev/sda1

read-only

Chain-load Windows from a second partition

other=/dev/sda2

label=windows

table=/dev/sda # Partition table to pass to the Windows bootloader

“`

Después de cada edición, aplique los cambios con:

“`bash

sudo /sbin/lilo -v

“`

El indicador `-v` habilita la salida detallada, mostrando cada entrada de kernel y cargador en cadena que se está mapeando. Verifique siempre el código de salida — un retorno distinto de cero significa que el mapa no se escribió correctamente.

Parámetros de configuración frecuentemente omitidos

• `lba32`: Sin esta directiva en discos de más de 8 GB, LILO recurre al direccionamiento CHS y no podrá localizar kernels más allá del límite de 8 GB. Este es un modo de fallo silencioso que ha causado innumerables interrupciones en producción en hardware heredado.
• `compact`: Reduce el tiempo de arranque en discos giratorios al combinar lecturas de sectores adyacentes. Incompatible con algunos escenarios de arranque por disquete.
• `vga=`: Pasa un parámetro de modo de video al kernel. Útil para servidores sin cabeza donde se desea una resolución de framebuffer específica en la consola.
• `append=`: Pasa parámetros arbitrarios de línea de comandos del kernel. Equivalente a los argumentos de línea `linux` de GRUB.
• `password=`: Restringe el arranque de una entrada específica con una contraseña. Tenga en cuenta que esta contraseña se almacena en texto plano en `lilo.conf`, por lo que los permisos de archivo (`chmod 600`) son obligatorios.

Escenarios de instalación de LILO

Instalación en el MBR

“`bash

Verify the target device

lsblk -o NAME,SIZE,TYPE,MOUNTPOINT

Install LILO to MBR of /dev/sda

sudo /sbin/lilo -b /dev/sda

“`

Instalación en un sector de arranque de partición

Al usar un gestor de arranque como System Commander, es posible que desee LILO en el sector de arranque de una partición en lugar del MBR:

“`ini

boot=/dev/sda1 # Install to partition boot sector, not MBR

“`

Este es también el enfoque correcto cuando LILO está siendo cargado en cadena por otro gestor de arranque.

Eliminación de LILO

Para restaurar el MBR original (por ejemplo, antes de reemplazarlo con GRUB):

“`bash

Overwrite MBR with a generic boot sector, preserving the partition table

sudo dd if=/usr/lib/syslinux/mbr/mbr.bin of=/dev/sda bs=440 count=1

“`

Nunca use `dd if=/dev/zero` en el MBR completo — destruirá la tabla de particiones.

LILO vs. GRUB: Comparación técnica

La siguiente tabla cubre las dimensiones más importantes para un administrador de sistemas que elige entre los dos, incluyendo varios matices ausentes en la mayoría de las comparaciones:

Veredicto para sistemas en producción: GRUB2 es la elección correcta para cualquier sistema que ejecute un kernel más reciente que aproximadamente la versión 3.x, que use GPT, UEFI, LVM o software RAID. La propuesta de valor de LILO hoy en día se limita a entornos embebidos o heredados donde su modelo de carga determinista e independiente del sistema de archivos es una ventaja en lugar de una limitación.

Cuándo LILO sigue siendo la herramienta adecuada

A pesar de su antigüedad, LILO sigue siendo apropiado en escenarios específicos:

• Sistemas Linux embebidos donde la huella del gestor de arranque debe ser inferior a 32 KB y la ubicación del kernel nunca cambia.
• Hardware heredado (anterior al año 2000) donde los módulos de GRUB2 superan la memoria disponible o el BIOS tiene problemas de compatibilidad con la carga por etapas de GRUB.
• Entornos forenses y de recuperación donde se prefiere un gestor de arranque mínimo y conocido como bueno sobre uno complejo con capacidades de scripting.
• Sistemas aislados donde la simplicidad y auditabilidad del modelo de configuración plana de LILO reduce la superficie de ataque.
• Propósitos educativos — el código fuente y la secuencia de arranque de LILO son significativamente más simples que los de GRUB2, lo que lo convierte en un excelente tema para cursos de fundamentos de sistemas operativos.

Para cualquier implementación moderna — ya sea que esté aprovisionando un entorno de Hosting VPS, configurando un Servidor Dedicado, o configurando un stack de desarrollo en Hosting Web Compartido — GRUB2 es la elección predeterminada y correcta para el gestor de arranque.

Modos de fallo comunes de LILO y diagnósticos

Comprender los códigos de error de LILO es fundamental para la recuperación. LILO imprime una cadena parcial de `LILO` durante el arranque para indicar el progreso:

Procedimiento de recuperación

Si LILO no arranca después de una actualización del kernel:

1. Arranque desde un CD en vivo o entorno de rescate.
2. Monte la partición raíz: `mount /dev/sda1 /mnt`
3. Chroot: `chroot /mnt`
4. Verifique que `/etc/lilo.conf` apunte a la ruta correcta del kernel.
5. Vuelva a ejecutar: `/sbin/lilo -v`
6. Reinicie.

Si el archivo de mapa en sí está corrupto, es posible que necesite reinstalar el paquete `lilo` para restaurar `/boot/boot.b` antes de volver a ejecutar el comando.

Consideraciones de seguridad

LILO es anterior a los modelos de seguridad de firmware modernos y tiene varias limitaciones importantes:

• Sin soporte de Secure Boot: LILO no puede participar en la cadena de confianza de UEFI Secure Boot. En sistemas donde se requiere verificación de integridad del firmware, GRUB2 con un shim firmado es obligatorio.
• Debilidades en la protección por contraseña: La directiva `password=` en `lilo.conf` almacena las credenciales en texto plano. Restrinja estrictamente los permisos de archivo (`chmod 600 /etc/lilo.conf`, propiedad de root).
• Vulnerabilidad de acceso físico: Sin una contraseña de BIOS/UEFI, un atacante con acceso físico puede arrancar desde medios externos y eludir LILO por completo.
• Sin integración con TPM: LILO no puede realizar arranque medido ni interactuar con un TPM para atestación, a diferencia de GRUB2 con los módulos apropiados.

Para servidores donde el cifrado de disco, el arranque medido o la atestación remota forman parte de la arquitectura de seguridad — como un VPS con cPanel o un Servidor Dedicado reforzado — estas limitaciones hacen que LILO sea inadecuado.

Migración de LILO a GRUB2

Si está manteniendo un sistema heredado que aún ejecuta LILO y necesita migrar:

“`bash

1. Install GRUB2

sudo apt-get install grub2 # Debian/Ubuntu

sudo yum install grub2-tools # RHEL/CentOS

2. Install GRUB2 to MBR

sudo grub-install /dev/sda

3. Generate GRUB configuration

sudo update-grub # Debian/Ubuntu

sudo grub2-mkconfig -o /boot/grub2/grub.cfg # RHEL/CentOS

4. Verify the new configuration

sudo grep -i menuentry /boot/grub/grub.cfg

5. Reboot and confirm GRUB2 loads

sudo reboot

“`

No elimine el paquete `lilo` hasta que haya confirmado que GRUB2 arranca correctamente. Mantenga un USB de rescate en vivo disponible durante la migración.

Si su servidor utiliza Paneles de Control VPS que interactúan con el gestor de arranque (por ejemplo, para cambio de kernel o modo de rescate), verifique la compatibilidad del panel con GRUB2 antes de migrar.

Conclusiones técnicas clave: Matriz de decisión

Use esta lista de verificación para determinar si LILO es apropiado para su entorno:

Use LILO si:

• El sistema utiliza firmware BIOS (no UEFI)
• El disco utiliza tabla de particiones MBR (no GPT)
• El kernel y el diseño de particiones son estáticos y raramente cambian
• La huella del gestor de arranque debe minimizarse (sistemas embebidos)
• Está estudiando los fundamentos de la secuencia de arranque con fines educativos

No use LILO si:

• El sistema utiliza firmware UEFI (LILO es incompatible)
• El disco utiliza particionamiento GPT
• Los kernels se actualizan regularmente mediante el gestor de paquetes
• Requiere Secure Boot, atestación TPM o arranque medido
• El sistema utiliza LVM, software RAID o Btrfs para el sistema de archivos raíz
• Necesita edición interactiva de parámetros de arranque para solución de problemas
• El sistema está conectado a Internet o sujeto a requisitos de cumplimiento de seguridad

Regla operativa: Cada vez que edite `/etc/lilo.conf` o actualice un kernel en un sistema gestionado por LILO, ejecutar `/sbin/lilo -v` no es opcional — es tan obligatorio como la propia edición. Automatice esto con un hook de post-instalación del kernel si su gestor de paquetes lo admite.

Preguntas frecuentes

¿Qué sucede si actualizo el kernel de Linux en un sistema LILO sin ejecutar `/sbin/lilo`?

El archivo de mapa de LILO sigue apuntando a las direcciones de bloques de disco del kernel anterior. El sistema arrancará el kernel anterior como si la actualización nunca hubiera ocurrido — o, si la imagen del kernel anterior fue sobreescrita en su lugar, cargará datos corruptos y entrará en pánico. Ejecute siempre `/sbin/lilo -v` inmediatamente después de cualquier actualización del kernel.

¿Puede LILO arrancar desde un disco con particionamiento GPT?

No de forma confiable. LILO fue diseñado para tablas de particiones MBR. Los discos GPT utilizan un MBR protector que técnicamente permite la instalación de LILO, pero LILO no tiene conocimiento de las entradas de partición GPT y no puede localizar de forma confiable particiones más allá de las primeras cuatro. Use GRUB2 para cualquier disco GPT.

¿Es LILO compatible con sistemas UEFI?

No. LILO es un gestor de arranque de la era BIOS sin soporte para aplicaciones EFI. En sistemas UEFI, el firmware espera un binario `.efi` en formato PE en la Partición del Sistema EFI. LILO no puede proporcionar esto. GRUB2, systemd-boot o rEFInd son las opciones correctas para UEFI.

¿Cuál es la diferencia entre el valor `timeout` de LILO y los segundos reales?

La directiva `timeout` se mide en décimas de segundo. Un valor de `50` equivale a 5 segundos, `100` equivale a 10 segundos. Esta es una configuración incorrecta común — los administradores que esperan un tiempo de espera de 50 segundos y establecen `timeout=50` obtendrán una ventana de 5 segundos en su lugar.

¿Puede LILO arrancar desde volúmenes LVM o software RAID?

No. Debido a que LILO resuelve las ubicaciones del kernel a direcciones absolutas de bloques de disco en el momento de la instalación, no puede manejar las capas de abstracción introducidas por LVM o MD RAID. La partición `/boot` debe residir en una partición plana directamente accesible por el BIOS. Esta es una de las principales razones arquitectónicas por las que GRUB2 reemplazó a LILO en las distribuciones modernas de Linux.