Manual:AMD64/Bloques/CargadorDeArranque

Seleccionar un gestor de arranque

Una vez se haya configurado el núcleo Linux configurado, instalado las herramientas del sistema y editado los ficheros de configuración, es el momento de instalar la última pieza importante de una instalación Linux: cargador de arranque.

El cargador de arranque es el responsable de arrancar el núcleo Linux en el momento del inicio. Sin él, el sistema no sabría cómo proceder cuando se pulsa el botón de encendido.

Para amd64, documentamos cómo configurar bien GRUB o LILO para sistemas basados en DOS/BIOS obsoleto y GRUB o efibootmgr para sistemas UEFI.

En esta sección del Manual se realizó una delimitación entre realizar un emerge del paquete del gestor de arranque e instalar un gestor de arranque en un disco del sistema. Aquí el término emerge será utilizado para pedirle a Portage que instale el paquete para que esté disponible en el sistema. El término install significará la copia de los ficheros del gestor de arranque o la modificación física de las secciones del disco apropiadas para dejar al gestor de arranque activado y listo para operar en el próximo reinicio.

Predeterminado: GRUB

De manera predeterminada, la mayoría de los sistemas Gentoo utilizan GRUB (disponible en el paquete sys-boot/grub), que es el sucesor directo de GRUB Legacy. Sin ninguna configuración adicional, GRUB soporta antiguos sistemas BIOS ("pc"). Con una pequeña configuración, necesaria antes de construir, GRUB puede soportar más de media docena de plataformas adicionales. Para obtener más información, consulte la sección de prerequisitos del artículo sobre GRUB.

Emerge

Cuando se utilice un antiguo sistema con BIOS que soporte solo tablas de particiones MBR, no son necesarias configuraciones extra para realizar un emerge de GRUB:

root #emerge --ask --verbose sys-boot/grub

Una nota para los usuarios de UEFI: Al lanzar la orden de arriba, se mostrarán los valores habilitados de GRUB_PLATFORMS antes de hacer emerge. Cuando se utilicen sistemas con UEFI, los usuarios necesitarán asegurarse de que GRUB_PLATFORMS="efi-64" está habilitado (ya que es el caso por defecto). Si ese no es el caso para la configuración, se necesitará añadir GRUB_PLATFORMS="efi-64" al fichero /etc/portage/make.conf antes de hacer emerge de GRUB de modo que el paquete se construya con funcionalidad EFI:

root #echo 'GRUB_PLATFORMS="efi-64"' >> /etc/portage/make.conf

root #emerge --ask sys-boot/grub

Si se realizó emerge de GRUB sin habilitar previamente GRUB_PLATFORMS="efi-64", se puede añadir esta línea la línea (tal y como se muestra arriba) a make.conf y se pueden recalcular las dependencias para el conjunto de paquetes world pasando las opciones --update --newuse a emerge:

root #emerge --ask --update --newuse --verbose sys-boot/grub

El software GRUB ahora se ha instalado en el sistema, pero aún no se ha instalado como un gestor de arranque secundario.

Instalación

A continuación, instalar los archivos necesarios de GRUB en el directorio /boot/grub/ mediante la orden grub-install. Se supone que el primer disco (desde el que se inicia el sistema) es /dev/sda alguna de las órdenes siguientes lo hará:

Sistemas DOS/BIOS obsoleto

Para sistemas DOS/BIOS obsoleto:

root #grub-install /dev/sda

Sistemas UEFI

Importante
Asegúrese de que la partición EFI de sistema está montada antes de lanzar grub-install. Es posible que grub-install instale el fichero GRUB para EFI (grubx64.efi) en el directorio incorrecto sin ofrecer ningún tipo de indicación de que se ha utilizado el directorio incorrecto.

Para sistemas UEFI:

root #grub-install --efi-directory=/efi

Installing for x86_64-efi platform.
Installation finished. No error reported.

Tras una instalación exitosa, el resultado debe coincidir con el resultado del comando anterior. Si la salida no coincide exactamente, entonces siga con Depurar GRUB, en caso contrario siga con el paso Configurar.

Opcional: Arranque Seguro

El paquete sys-boot/grub no reconoce el indicador USE secureboot, esto se debe a que el ejecutable GRUB EFI no se instala con el paquete, sino que lo compila e instala Template:Comando c. Por lo tanto, GRUB debe firmarse manualmente después de la instalación en la partición de arranque. Además, GRUB es un gestor de arranque modular, pero la carga de módulos está prohibida cuando Secure Boot está habilitado. Por lo tanto, todos los módulos necesarios deben compilarse en el ejecutable de GRUB EFI. A continuación se muestra un ejemplo que incluye algunos módulos básicos; es posible que esto deba ajustarse para configuraciones más avanzadas:

root #emerge --noreplace sbsigntools

root #export GRUB_MODULES="all_video boot btrfs cat chain configfile echo efifwsetup efinet ext2 fat font gettext gfxmenu gfxterm gfxterm_background gzio halt help hfsplus iso9660 jpeg keystatus loadenv loopback linux ls lsefi lsefimmap lsefisystab lssal memdisk minicmd normal ntfs part_apple part_msdos part_gpt password_pbkdf2 png probe reboot regexp search search_fs_uuid search_fs_file search_label sleep smbios squash4 test true video xfs zfs zfscrypt zfsinfo"

root #grub-install --target=x86_64-efi --efi-directory=/efi --modules=${GRUB_MODULES} --sbat /usr/share/grub/sbat.csv

root #sbsign /efi/EFI/GRUB/grubx64.efi --key /path/to/kernel_key.pem --cert /path/to/kernel_key.pem --out /efi/EFI/GRUB/grubx64.efi

Para iniciar correctamente con el arranque seguro habilitado, el certificado utilizado debe ser aceptado por el firmware UEFI o se debe utilizar shim como precargador. Shim está prefirmado con el certificado Microsoft de terceros, aceptado de forma predeterminada por la mayoría de las placas base UEFI.

La forma de configurar el firmware UEFI para aceptar claves personalizadas depende del proveedor del firmware, lo cual está fuera del alcance de este manual. A continuación se muestra cómo configurar shim:

root #emerge sys-boot/shim sys-boot/mokutil sys-boot/efibootmgr

root #cp /usr/share/shim/BOOTX64.EFI /efi/EFI/GRUB/shimx64.efi

root #cp /usr/share/shim/mmx64.efi /efi/EFI/GRUB/mmx64.efi

La MOKlist Shim requiere claves en el formato DER, dado que la clave OpenSSL generada en el ejemplo actual está en el formato PEM, la clave debe convertirse primero:

root #openssl x509 -in /rura/a/kernel_key.pem -inform PEM -out /ruta/a/kernel_key.der -outform DER

Nota
La ruta utilizada aquí debe ser la ruta al archivo pem que contiene el certificado que pertenece a la clave generada. En este ejemplo, tanto la clave como el certificado están en el mismo archivo pem.

Después, el certificado convertido se puede importar a la MOKlist Shim:

root #mokutil --import /ruta/a/kernel_key.der

Y finalmente registramos Shim en el firmware UEFI. En el siguiente comando, boot-disk y boot-partition-id deben reemplazarse con el disco y el identificador de partición de la partición del sistema EFI:

root #efibootmgr --create --disk /dev/boot-disk --part boot-partition-id --loader '\EFI\GRUB\shimx64.efi' --label 'shim' --unicode

Depurar GRUB

Al depurar GRUB, hay un par de correcciones rápidas que pueden funcionar en una instalación de arranque sin tener que reiniciar en un nuevo entorno de imagen live.

En el caso de que se muestre "EFI variables are not supported on this system" en algún lugar de la pantalla, es probable que la imagen live no se haya iniciado en modo EFI y se encuentre actualmente en modo de inicio BIOS obsoleto. La solución es probar la opción removible de GRUB que se menciona a continuación. Esto sobrescribirá el archivo EFI ejecutable ubicado en /EFI/BOOT/BOOTX64.EFI. Al reiniciar en modo EFI, el firmware de la placa base puede ejecutar esta entrada de inicio predeterminada y ejecutar GRUB.

Si grub-install devuelve un error que dice "Could not prepare Boot variable: Read-only file system" y el entorno live se inició correctamente en modo UEFI, entonces debería ser posible volver a montar el sistema especial efivar como lectura-escritura y luego vuelva a ejecutar el comando antes mencionado grub-install:

root #mount -o remount,rw,nosuid,nodev,noexec --types efivarfs efivarfs /sys/firmware/efi/efivars

Esto se debe a que ciertos entornos Gentoo no oficiales no montan el sistema de archivos especial EFI de forma predeterminada. Si el comando anterior no se ejecuta, reinicie usando un entorno de imagen live oficial de Gentoo en modo EFI.

Algunos fabricantes de placas base con implementaciones UEFI deficientes parecen admitir sólo la ubicación del directorio /EFI/BOOT para el archivo .EFI en la partición del sistema EFI (ESP). El instalador de GRUB puede crear el archivo .EFI en esta ubicación automáticamente agregando la opción --removable al comando de instalación. Asegúrese de que el ESP haya sido montado antes de ejecutar el siguiente comando; suponiendo que está montado en /efi (como se definió anteriormente), ejecute:

root #grub-install --target=x86_64-efi --efi-directory=/efi --removable

Esto crea el directorio 'predeterminado' definido por la especificación UEFI y luego crea un archivo con el nombre predeterminado: BOOTX64.EFI.

Configuración

A continuación, generar la configuración de GRUB basada en la configuración de usuario especificado en el archivo /etc/default/grub y en los guiones /etc/grub.d. En la mayoría de los casos, no se necesita ninguna configuración por parte de los usuarios ya que GRUB detectará automáticamente el núcleo que debe iniciar (la versión más alta disponible en /boot/) y cuál es el sistema de ficheros raíz. También es posible añadir argumentos del núcleo en /etc/default/grub mediante la variable GRUB_CMDLINE_LINUX.

Para generar la configuración final de GRUB, lance la orden grub-mkconfig:

root #grub-mkconfig -o /boot/grub/grub.cfg

Generating grub.cfg ...
Found linux image: /boot/vmlinuz-6.6.21-gentoo
Found initrd image: /boot/initramfs-genkernel-amd64-6.6.21-gentoo
done

La salida de la orden debe mostrar que se ha encontrado al menos una imagen de Linux, como las que son necesarias para arrancar el sistema. Si se utiliza un initramfs o se utilizó genkernel para construir el núcleo, la imagen correcta initrd debería poder detectarse de esta forma. Si no es el caso, hay que ir a /boot/ y comprobar los contenidos mediante la orden ls. Si los archivos no están, se debe regresar a la configuración del núcleo y a las instrucciones de instalación.

Consejo
La utilidad os-prober en conjunto con GRUB para detectar otros sistemas operativos en los discos conectados. Windows 7, 8.1, 10 y otras distribuciones de Linux son detectables. Para esto escenarios de doble booteo debes hacer un emerge del paquete sys-boot/os-prober y luego volver a ejecutar grub-mkconfig (como se muestra arriba). Si se encuentran problemas en la detección, asegúrate de leer el artículo de GRUB entero antes de pedir soporte a la comunidad de Gentoo.

Alternativa 1: LILO

Emerge

LILO, el LInuxLOader (Cargador de Linux), está de sobra probado y es el verdadero caballo de batalla de los cargadores de arranque de Linux. Sin embargo, carece de algunas características que posee GRUB. La razón por la que LILO aún se utiliza es que, en algunos sistemas, GRUB no funciona y LILO sí. Por supuesto, también se sigue utilizando debido a que algunas personas lo conocen bien y quieren seguir utilizándolo. De cualquier formar, Gentoo ofrece soporte a ambos.

Instalar LILO es muy fácil, sencillamente utilice emerge.

root #emerge --ask sys-boot/lilo

Configurar

Para configurar LILO, en primer lugar se debe crear /etc/lilo.conf:

root #nano -w /etc/lilo.conf

En el archivo de configuración, las secciones se utilizan para referirse al núcleo arrancable. Asegúrese de que conoce los archivos del núcleo (incluyendo su versión) y los archivos initramfs, ya que se necesita hacer referencia a ellos es el fichero de configuración.

Nota
Si el sistema de fichero raíz es JFS, agregue una línea append="ro" después de cada elemento de arranque ya que JFS necesita reproducir su registro antes de permitir el montaje en modo lectura y escritura.

ARCHIVO /etc/lilo.confEjemplo de archivo de configuración de LILO

boot=/dev/sda             # Instalar LILO en el MBR
prompt                    # Dar al usuario la posibilidad de seleccionar otra sección
timeout=50                # Esperar 5 (cinco) segundos antes de iniciar la sección por defecto
default=gentoo            # Cuando venza el plazo arrancar la sección "gentoo"
compact                   # Esta opción reduce drásticamente el tiempo de carga y hace que el fichero map sea más pequeño
  
image=/boot/vmlinuz-6.6.21-gentoo
  label=gentoo            # El nombre que se le da a esta sección
  read-only               # Comenzar con un raíz en modo solo lectura. ¡No modificar esta parte!
  root=/dev/sda3          # Localización del sistema de ficheros raíz
  
image=/boot/vmlinuz-6.6.21-gentoo
  label=gentoo.rescue     # El nombre que se le da a esta sección
  read-only               # Comenzar con un raíz en modo solo lectura. ¡No modificar esta parte!
  root=/dev/sda3         # Localización del sistema de ficheros raíz
  append="init=/bin/bb"   # Lanzar el intérprete de comandos estático de rescate de Gentoo
  
# Las dos líneas siguientes se necesitan únicamente si se realiza arranque dual con un sistema Windows.
# En este ejemplo Windows se aloja en /dev/sda6.
other=/dev/sda6
  label=windows

Nota
Si se utiliza un esquema de particionamiento diferente o se utiliza una imagen del núcleo, se deberá ajustar adecuadamente..

Si se necesita un initramfs, se debe cambiar la configuración haciendo referencia al fichero initramfs e indicar al initramfs donde se encuentra el dispositivo raíz:

ARCHIVO /etc/lilo.confAñadir información de initramfs a una entrada del menú de inicio

image=/boot/vmlinuz-6.6.21-gentoo
  label=gentoo
  read-only
  append="root=/dev/sda3"
  initrd=/boot/initramfs-genkernel-amd64-6.6.21-gentoo

Si se necesitan pasar opciones adicionales al núcleo, utilice una sentencia append. Por ejemplo, añada la sentencia video para habilitar el framebuffer:

ARCHIVO /etc/lilo.confAñadir el parámetro video a las opciones de inicio

image=/boot/vmlinuz-6.6.21-gentoo
  label=gentoo
  read-only
  root=/dev/sda3
  append="video=uvesafb:mtrr,ywrap,1024x768-32@85"

Los usuarios que utilizan genkernel deberían saber que sus núcleos utilizan las mismas opciones de arranque que el CD de instalación. Por ejemplo, si se necesita ofrecer soporte para dispositivos SCSI añada doscsi como opción del núcleo.

Ahora, guarde el archivo y salga.

Instalación

Para terminar, lance /sbin/lilo de modo que LILO pueda aplicar los ajustes definidos en /etc/lilo.conf al sistema (esto es, instalarse a sí mismo en el disco). Recuerde que se necesita lanzar /sbin/lilo cada vez que se ha instalado un nuevo núcleo o se ha realizado un cambio al fichero lilo.conf para reiniciar el sistema si se ha cambiado el nombre del fichero que contiene el núcleo.

root #/sbin/lilo

Alternativa 2: efibootmgr

Los sistemas informáticos con firmware basado en UEFI técnicamente no necesitan cargadores de arranque secundarios (como por ejemplo, GRUB) para arrancar los núcleos. Los cargadores de arranque secundarios existen para extender la funcionalidad del firmware UEFI durante el proceso de arranque. Usar GRUB (consulte la sección anterior) suele ser más fácil y seguro porque ofrece una manera más flexible para modificar rápidamente los parámetros del kernel en el momento del arranque.

Los administradores de sistemas que deseen adoptar un enfoque minimalista, aunque más rígido, para iniciar el sistema pueden evitar los cargadores de arranque secundarios e iniciar el núcleo Linux como un código auxiliar EFI.

La aplicación sys-boot/efibootmgr es una herramienta que se utiliza para interactuar con el firmware UEFI - gestor de arranque principal del sistema. Normalmente, se usa para agregar o eliminar entradas de inicio a la lista de entradas de inicio del firmware. También puede actualizar la configuración del firmware para que los núcleos Linux que se agregaron previamente como entradas de arranque puedan ejecutarse con opciones adicionales. Estas interacciones se realizan a través de estructuras de datos especiales llamadas variables EFI (de ahí la necesidad de soporte en ele núcleo para las variables EFI).

Asegúrese de revisar el artículo del EFI stub del núcleo antes de continuar. El núcleo debe tener opciones específicas habilitadas para que el firmware UEFI pueda iniciarlo directamente. Puede que sea necesario recompilar el kernel para poder incorporar este soporte.

También es una buena idea consultar el artículo efibootmgr para obtener información adicional.

Nota
Para reiterar, efibootmgr no es un requisito para iniciar un sistema UEFI; simplemente es necesario agregar una entrada para un EFI stub para el núcleo en el firmware UEFI. Cuando se construye apropiadamente con soporte EFI stub, el propio núcleo Linux se puede iniciar directamente. Se pueden incorporar opciones adicionales para la línea de comandos del núcleo Linux (hay una opción de configuración del núcleo llamada CONFIG_CMDLINE. De manera similar, el soporte para initramfs también se puede 'integrar' en el núcleo. Estas decisiones deben tomarse antes de la compilación del kernel, lo que da como resultado una configuración de arranque más estática.

Instale el software efibootmgr:

root #emerge --ask sys-boot/efibootmgr

Cree la ubicación /efi/EFI/Gentoo y copie el núcleo en esa ubicación, llamándolo bzImage.efi:

root #mkdir -p /efi/EFI/Gentoo

root #cp /boot/vmlinuz-* /efi/EFI/Gentoo/bzImage.efi

Nota
El uso de una barra invertida (\) como separador de ruta de directorio es obligatorio cuando se utilizan definiciones UEFI.

Cree una entrada de inicio llamada "gentoo" para el EFI stub para el núcleo recién compilado dentro del firmware UEFI:

root #efibootmgr --create --disk /dev/sda --part 1 --label "gentoo" --loader "\EFI\Gentoo\bzImage.efi"

Si se utiliza un sistema de ficheros de inicio en RAM (initramfs), entonces añadir la opción de arranque apropiada:

root #efibootmgr --create --disk /dev/sda --part 1 --label "gentoo" --loader "\EFI\Gentoo\bzImage.efi" --unicode "initrd=\efi\initramfs-genkernel-amd64-6.6.21-gentoo"

Tenga en cuenta que el comando anterior supone que se copió un archivo initramfs en el ESP dentro del mismo directorio que el archivo bzImage.efi.

Una vez realizados estos cambios, cuando el sistema se reinicie, aparecerá una entrada en el menú de inicio llamada "gentoo".

Imagen del Núcleo Unificada

Si installkernel se configuró para crear e instalar imágenes del núcleo unificadas. La imagen del núcleo unificada ya debería estar instalada en el directorio EFI/Linux en la partición del sistema EFI; si este no es el caso, asegúrese de que el directorio exista y luego ejecute la instalación del núcleo nuevamente como se describe anteriormente en el manual.

Para agregar una entrada de inicio directo para la imagen del núcleo unificado instalada:

root #efibootmgr --create --disk /dev/sda --part 1 --label "gentoo" --loader /efi/EFI/Linux/gentoo-x.y.z.efi

Alternativa 3: Syslinux

Syslinux es otro cargador de arranque alternativo para la arquitectura amd64. Ofrece soporte para MBR y en su versión 6.00 también ofrece soporte para arranque EFI. El arranque PXE (a través de la red) y otras opciones menos conocidas también están soportadas. Aunque Syslinux es un cargador de arranque popular para muchos, en el manual no se ofrece soporte para él. Los lectores pueden encontrar información acerca de cómo hacer emerge del paquete e instalarlo a continuación en el artículo de Syslinux.

Alternativa 4: systemd-boot

Otra opción es systemd-boot, que funciona tanto en equipos OpenRC como systemd. Es un cargador en cadena ligero y funciona bien con el arranque seguro.

Para instalar system-boot:

root #bootctl install

Importante
Asegúrese de que la partición del sistema EFI se haya montado antes de ejecutar bootctl install.

Cuando utilice este gestor de arranque, antes de reiniciar, verifique que exista una nueva entrada de arranque usando:

root #bootctl list

Si no existe ninguna entrada nueva, asegúrese de que el paquete sys-kernel/installkernel se haya instalado con el indicador USE systemd-boot habilitado y vuelva a ejecutar la instalación del núcleo.

Para núcleos de distribución:

root #emerge --ask --config sys-kernel/gentoo-kernel

Para un núcleo configurado y compilado de forma manual:

root #make install

Importante
Al instalar núcleos para systemd-boot, no se agrega ningún argumento de línea de comandos del núcleo root= de forma predeterminada. En los sistemas systemd que utilizan initramfs, los usuarios pueden confiar en systemd-gpt-auto-generator para encontrar automáticamente la partición raíz en el arranque. De lo contrario, los usuarios deben especificar manualmente la ubicación de la partición raíz configurando root= en /etc/kernel/cmdline así como cualquier otro argumento de la línea de comandos del núcleo que deba ser usado. Y luego reinstalar el núcleo como se describe arriba.

Opcional: Arranque Seguro

Cuando el indicador USE secureboot está habilitado, el ejecutable EFI systemd-boot se firmará automáticamente. bootctl install instalará automáticamente la versión firmada.

Para iniciar correctamente con el arranque seguro habilitado, el certificado utilizado debe ser aceptado por el firmware UEFI o se debe utilizar shim como precargador. Shim está prefirmado con el certificado Microsoft de terceros, aceptado de forma predeterminada por la mayoría de las placas base UEFI.

La forma de configurar el firmware UEFI para aceptar claves personalizadas depende del proveedor del firmware, lo cual está fuera del alcance de este manual. En la página wiki systemd-boot se proporciona un hook postinst para actualizar automáticamente systemd-boot y configurarlo con shim. Sin embargo, la primera vez esto debe hacerse manualmente siguiendo los pasos a continuación:

root #emerge --ask sys-boot/shim sys-boot/mokutil sys-boot/efibootmgr

root #cp /usr/share/shim/BOOTX64.EFI /efi/EFI/BOOT/BOOTX64.EFI

root #cp /usr/share/shim/mmx64.efi /efi/EFI/BOOT/mmx64.efi

root #cp /efi/EFI/systemd/systemd-bootx64.efi /efi/EFI/BOOT/grubx64.efi

Nota
Shim está codificado internamente para cargar grubx64.efi. Como tal, el gestor de arranque systemd-boot debe tener el nombre como si fuera GRUB.

La MOKlist de Shim requiere claves en formato DER, dado que la clave OpenSSL generada en el ejemplo está en formato PEM, la clave debe convertirse antes:

root #openssl x509 -in /ruta/a/kernel_key.pem -inform PEM -out /ruta/a/kernel_key.der -outform DER

Nota
La ruta utilizada aquí debe ser la ruta al archivo pem que contiene el certificado que pertenece a la clave generada. En este ejemplo, tanto la clave como el certificado están en el mismo archivo pem.

Luego, el certificado convertido se puede importar a la MOKlist de Shim:

root #mokutil --import /ruta/a/kernel_key.der

Y finalmente registramos Shim con el firmware UEFI. En el siguiente comando, boot-disk y boot-partition-id deben reemplazarse con el disco y el identificador de partición de la partición del sistema EFI:

root #efibootmgr --create --disk /dev/boot-disk --part boot-partition-id --loader '\EFI\BOOT\BOOTX64.EFI' --label 'shim' --unicode