Difference between revisions of "GRUB2 (Español)"

Revision as of 11:46, 26 June 2013

zh-CN:GRUB2 zh-TW:GRUB2 Template:Article summary start Template:Article summary text Template:Article summary heading Template:Article summary text Template:Article summary heading Template:Article summary wiki - Burg es un gestor de arranque de nueva concepción basado en GRUB2. Es un nuevo formato de objeto que permite ser compilado por numerosos sistemas operativos, incluyendo Linux, Windows, OSX, Solaris, FreeBSD, etc. También dispone de un sistema de menú altamente configurable que funciona tanto en modalidad gráfica, como textual Template:Article summary heading Template:Article summary wiki Template:Article summary link Template:Article summary end GRUB2 es la nueva versión de GRand Unified Bootloader (GRUB). GRUB2 derivada de PUPA, un proyecto de investigación destinado a mejorar el GRUB: ha sido totalmente reescrito a fin de proporcionar una mayor modularidad y portabilidad [1].

En resumen, el bootloader es el primer programa que se ejecuta cuando se inicia el equipo. Es responsable de cargar y transferir el control al kernel de Linux, que, a su vez, inicializa el resto del sistema operativo.

Prefacio

Antes de comenzar, he aquí algunas aclaraciones útiles:

• El nombre de GRUB oficialmente se refiere a la versión 2 del software, consulte [2]. Si se está buscando el artículo para la versión Legacy, consulte GRUB Legacy.

• Desde la versión 1.99-6 en adelante, el sistema de archivos Btrfs es compatible con la raíz / (lo que elimina la necesidad de una partición /boot separada con un sistema de archivos diferente). También son compatibles los algoritmos de compresión zlib o LZO.

• Para más información sobre UEFI GRUB2, es recomendable consultar las páginas UEFI, GPT y UEFI_Bootloaders antes de leer este artículo.

Nota para los usuarios de GRUB Legacy

• La actualización de GRUB Legacy a GRUB(2) es un proceso muy similar al de una instalación limpia de GRUB2, argumento tratado aquí.

• Hay diferencias en las órdenes de GRUB y GRUB2. Le recomendamos que se familiarice con los órdenes de GRUB2 antes de continuar. (Por ejemplo, «find» (encontrar) ha sido reemplazado por «search» (buscar)).

• GRUB2 es ahora modular, y ya no requiere «stage 1.5». En consecuencia, el gestor de arranque tiene una capacidad limitada y los módulos son cargados desde el disco duro en caso de necesidad (por ejemplo, si necesita soporte de LVM o RAID).

• Las reglas de la nomenclatura de los dispositivos cambian de GRUB a GRUB2: Los discos duros están siendo ahora numerados a partir de 0, mientras que las particiones comienzan en 1 y son seguidos por el nombre del sistema de particionamiento usado. Por ejemplo, /dev/sda1 hace referencia a (hd0,msdos1) (para sistemas que usan MBR), o a (hd0,gpt1) (para los sistemas que usan GPT).

Requisitos previos para GRUB2

Sistemas BIOS

Instrucciones específicas para GUID Partition Table (GPT)

Para acloparse a la BIOS-GPT, GRUB2 requiere una partición propia (BIOS Boot Partition), en la que se ubica su core.img, ante la carencia de espacio (31KiB) después de MBR en los sistemas que utilizan el método de particionado GPT (en dicho lugar se ubica la GPT Primary Header y la Primary Partition Table). Esta partición se utiliza por GRUB2 solo en las configuraciones de BIOS-GPT, y no es necesario cuando se utiliza el método clásico de particionado (MBR) o si está en un sistema UEFI. Syslinux tampoco requiere esta partición.

Para las configuraciones de BIOS-GPT, cree una partición de aproximadamente 2MiB usando cgdisk o GNU Parted sin asignarle un sistema de archivos. La localización de la partición no es importante, pero es aconsejable colocarla cerca del inicio del disco, y antes de la partición /boot. Se le asigna a la partición el tipo EF02 si se está usando cgdisk, o set <BOOT_PART_NUM> bios_grub on si se usa GNU Parted.

Instrucciones específicas para Master Boot Record (MBR)

Por lo general, el espacio usable después de MBR (después de los 512 bytes dedicados a ella, y antes de la primera partición), es de 31 Kb, si hay algún problema de alineación de cilindros se resuelven en la tabla de particiones. Sin embargo, se recomienda mantener una distancia de aproximadamente 1 MiB para proporcionar el espacio suficiente para contener core.img de GRUB2. (FS#24103). Es recomendable utilizar una herramienta de particionado que permita la alineación de una partición de 1 MiB después de MBR para obtener el espacio necesario, y resolver otros problemas fuera de los primeros 512 bytes (que son ajenos a la incrustación de core.img).

El particionamiento MBR tiene un mejor soporte en otros sistemas operativos, como Microsoft Windows (hasta Windows 7) y el Haiku, que el particionamiento GPT. Si tiene un arranque dual con otro sistema operativo, considere el uso de particionados MBR.

Es posible convertir un disco MBR a GPT si se dispone de un pequeño espacio libre. Véase Convertir MBR a GPT

Sistemas UEFI

Crear y montar UEFI SYSTEM PARTITION

Siga las instrucciones sobre crear una partición UEFI del sistema para crear una UEFI SYSTEM PARTITION. A continuación, proceda a montar la partición la UEFI SYSTEM PARTITION en /boot/efi. Si la partición UEFISYS está montada en algún otro punto de montaje, sustituir /boot/efi en consecuencia en las órdenes siguientes:

# mkdir -p /boot/efi
# mount -t vfat <UEFISYS_PART_DEVICE> /boot/efi

Cree una carpeta <PARTICIÓN_UEFI_DEL_SISTEMA>/EFI, si no existe:

# mkdir -p /boot/efi/EFI

Instalación

Sistemas BIOS

Realizar una copia de seguridad de los datos importantes

En general, la instalación de GRUB(2) debería ser un éxito, pero es recomendable conservar los archivos de GRUB-legacy antes de instalar el paquete grub-bios.

# mv /boot/grub /boot/grub-legacy

Haga una copia de seguridad del MBR dado que contiene el código de arranque y la tabla de particiones (sustituya /dev/sdX con el identificativo de su disco):

# dd if=/dev/sdX of=/path/to/backup/mbr_backup bs=512 count=1

Solo los primeros 446 bytes del MBR contiene el código de arranque, mientras que los 64 restantes están dedicados a la tabla de particiones. Si no desea sobrescribirla, durante una eventual recuperación, se recomienda hacer copia de seguridad solo el código de arranque:

# dd if=/dev/sdX of=/path/to/backup/bootcode_backup bs=446 count=1

Si no ha sido capaz de instalar con éxito GRUB2, consulte Restaurar GRUP Legacy.

Instalar el paquete grub-bios

GRUB(2) se puede instalar con pacman, y reemplazar grub-legacy o grub, si está instalado.

# pacman -S grub-bios

Instalar los archivos de arranque de grub2

Hay tres formas de instalar los archivos de arranque GRUB(2) en el sistema BIOS :

• #Instalación en la «BIOS Boot Partition» con el esquema de particionado GPT (recomendado con GPT),
• #Instalación en la región de 440 bytes del MBR (recomendado con MBR),
• #Instalación en una partición o disco sin particiones (no recomendado),
• #Generar únicamente core.img (el método más seguro, pero requiere de un gestor de arranque diferente, como grub-legacy o syslinux, que permitirá el cambio de /boot/grub/i386-pc/core.img).

Instalación en la región de 440 bytes del MBR

Para instalar grub-bios en la región de 440 bytes relativa al código de arranque, también llamada Master Boot Record, ubicado en la carpeta /boot/grub, cree /boot/grub/i386-pc/core.img, e insértelo en el sector de 31KiB (el tamaño varía dependiendo de la alineación de las particiones) post-MBR, y genere el archivo de configuración, ejecutando:

# modprobe dm-mod
# grub-install --recheck /dev/sda
# grub-mkconfig -o /boot/grub/grub.cfg

donde /dev/sda es la partición de destino (En el caso de particiones MBR, se refiere a la primera unidad de disco SATA). Si utiliza LVM para la partición /boot, puede instalar GRUB2 en todos los discos físicos.

Instalación en la «BIOS Boot Partition» con el esquema de particionado GPT

Los discos GUID Partition Table no tienen reservado un «espacio de arranque». Por lo tanto, es necesario crear una partición de arranque de la BIOS (0xEF02) para contener la imagen principal de GRUB.

Usando GNU Parted, se puede hacer esta operación (crear una partición y asignarle el tipo de código -0xEF02-) usando una orden como la siguiente:

# parted /dev/disk set partition-number bios_grub on

Si está utilizando gdisk, establezca el tipo de partición a Template:Keypress. Con los programas de particionado que requieren establecer la GUID directamente, esta última debe mostrar el valor ‘21686148-6449-6e6f-744e656564454649’ (guardado en el disco como "Hah!IdontNeedEFI" si es interpretado como ASCII).

Para configurar grub-bios en un disco GPT, hay que darle contenido al directorio /boot/grub, generar el archivo /boot/grub/i386-pc/core.img, e incrustarlo en la BIOS Boot Partition, para todo lo cual ejecutaremos:

# modprobe dm-mod
# grub-install --target=i386-pc --recheck --debug /dev/sda
# mkdir -p /boot/grub/locale
# cp /usr/share/locale/en\@quot/LC_MESSAGES/grub.mo /boot/grub/locale/en.mo

donde /dev/sda es el destino de la instalación.

Instalación en una partición o disco sin particiones

Para instalar grub2 en el sector de arranque de una partición o disco sin particiones (por ejemplo, superfloppy), hay que ejecutar (suponiendo que el dispositivo es /dev/sdaX y que corresponde a la partición /boot):

# modprobe dm-mod 
# chattr -i /boot/grub/i386-pc/core.img
# grub-install --target=i386-pc --recheck --debug --force /dev/sdaX
# mkdir -p /boot/grub/locale
# cp /usr/share/locale/en@quot/LC_MESSAGES/grub.mo /boot/grub/locale/en.mo
# chattr +i /boot/grub/i386-pc/core.img

Necesitará la opción --force para permitir el uso de blocklists, pero no se debe usar --grub-setup=/bin/true, lo que equivale a generar únicamente core.img).

Se recibirán los mensajes de advertencia que sirven para explicar los riesgos de este enfoque:

/sbin/grub-setup: warn: Attempting to install GRUB to a partitionless disk or to a partition. This is a BAD idea.
/sbin/grub-setup: warn: Embedding is not possible. GRUB can only be installed in this setup by using blocklists. 
                        However, blocklists are UNRELIABLE and their use is discouraged.

Sin la opción --force, recibirá el siguiente error y, consiguientemente, grub-setup no podrá instalar su propio código en el MBR.

/sbin/grub-setup: error: will not proceed with blocklists

Especificando --force, sin embargo, debe obtener:

Installation finished. No error reported.

grub-setup no lo hace automáticamente al instalar el gestor de arranque en una partición, o en un disco sin particiones, ya que se basa en el mismo blocklists integrado en el sector de arranque de la partición para localizar /boot/grub/i386-pc/core.img y la ruta al directorio /boot/grub. Las áreas que contienen los archivos de arriba pueden cambiar en caso de alteración de la partición (al copiar o borrar archivos, etc.) Para obtener más información, consulte https://bugzilla.redhat.com/show_bug.cgi?id=728742 y https://bugzilla.redhat.com/show_bug.cgi?id=730915.

La solución propuesta consiste en establecer la etiqueta de inmutable a /boot/grub/i386-pc/core.img, de modo que la posición de core.img en el disco no se vea alterada. Esta opción debe ser establecida solo si grub-bios se encuentra instalado en una partición o disco sin particiones, y NO en el caso de una instalación sencilla en el MBR o la generación de core.img sin incorporarla en ningún sector de arranque (mencionado anteriormente).

Generar únicamente core.img

Para completar la carpeta /boot/grub y generar un /boot/grub/i386-pc/core.img SIN instalar GRUB2 en el MBR, añada --grub-setup=/bin/true a grub-install:

# modprobe dm-mod
# grub-install --target=i386-pc --grub-setup=/bin/true --recheck --debug /dev/sda
# mkdir -p /boot/grub/locale
# cp /usr/share/locale/en@quot/LC_MESSAGES/grub.mo /boot/grub/locale/en.mo

A continuación, puede realizar el traslado del core.img a GRUB2 desde GRUB Legacy o syslinux.

Crear un archivo de configuración de GRUB2 BIOS

A continuación, generar un archivo de configuración de GRUB2 (puede encontrar más información en la sección «Configuración»):

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

Si grub2 muestra el error «no suitable mode found» durante el arranque, consulte Corregir el error GRUB2 «no suitable mode found».

Si grub-mkconfig no llegara a prosperar, convierta su /boot/grub/menu.lst a /boot/grub/grub.cfg con :

# grub-menulst2cfg /boot/grub/menu.lst /boot/grub/grub.cfg

Por ejemplo:

/boot/grub/menu.lst

default=0
timeout=5

title  Arch Linux Stock Kernel
root   (hd0,0)
kernel /vmlinuz-linux root=/dev/sda2 ro
initrd /initramfs-linux.img

title  Arch Linux Stock Kernel Fallback
root   (hd0,0)
kernel /vmlinuz-linux root=/dev/sda2 ro
initrd /initramfs-linux-fallback.img

/boot/grub/grub.cfg

set default='0'; if [ x"$default" = xsaved ]; then load_env; set default="$saved_entry"; fi
set timeout=5

menuentry 'Arch Linux Stock Kernel' {
  set root='(hd0,1)'; set legacy_hdbias='0'
  legacy_kernel   '/vmlinuz-linux' '/vmlinuz-linux' 'root=/dev/sda2' 'ro'
  legacy_initrd '/initramfs-linux.img' '/initramfs-linux.img'
  
}

menuentry 'Arch Linux Stock Kernel Fallback' {
  set root='(hd0,1)'; set legacy_hdbias='0'
  legacy_kernel   '/vmlinuz-linux' '/vmlinuz-linux' 'root=/dev/sda2' 'ro'
  legacy_initrd '/initramfs-linux-fallback.img' '/initramfs-linux-fallback.img'
}

Si se ha reiniciado el sistema, olvidándose de crear /boot/grub/grub.cfg ejecute el arranque en la shell de comandos de GRUB2 y escriba:

sh:grub> insmod legacycfg
sh:grub> legacy_configfile ${prefix}/menu.lst

Ellos hacen de arranque en Arch Linux y vuelve a crear /boot/grub/grub.cfg de manera adecuada.

Multiboot para sistemas de BIOS

Inicio de Microsoft Windows en sistemas BIOS-MBR

Encontrar el UUID del sistema de archivos NTFS de la partición SYSTEM PARTITION de Windows, donde bootmgr y sus archivos residen. Por ejemplo, si bootmgr se encuentra en /media/Windows/bootmgr:

Para Windows Vista/7/8:

# grub-probe --target=fs_uuid /media/SYSTEM_RESERVED/bootmgr
69B235F6749E84CE

# grub-probe --target=hints_string /media/SYSTEM_RESERVED/bootmgr
--hint-bios=hd0,msdos1 --hint-efi=hd0,msdos1 --hint-baremetal=ahci0,msdos1

A continuación, agregue el anterior código en el archivo /etc/grub.d/40-custom o /boot/grub/custom.cfg y regenere grub.cfg con grub-mkconfig como se explicó anteriormente para cargar Windows (XP, Vista, 7 o 8) instalado en la modalidad BIOS-MBR:

Para Windows Vista/7/8:

menuentry "Microsoft Windows Vista/7/8 BIOS-MBR" {
    insmod part_msdos
    insmod ntfs
    insmod search_fs_uuid
    insmod ntldr     
    search --fs-uuid --no-floppy --set=root --hint-bios=hd0,msdos1 --hint-efi=hd0,msdos1 --hint-baremetal=ahci0,msdos1 69B235F6749E84CE
    ntldr /bootmgr
}

Para Windows XP:

menuentry "Microsoft Windows XP" {
    insmod part_msdos
    insmod ntfs
    insmod search_fs_uuid
    insmod ntldr     
    search --fs-uuid --no-floppy --set=root --hint-bios=hd0,msdos1 --hint-efi=hd0,msdos1 --hint-baremetal=ahci0,msdos1 69B235F6749E84CE
}

/etc/grub.d/40_custom se puede utilizar como una plantilla para crear /etc/grub.d/nn_custom. Donde nn define la prioridad, indicando el orden en que los scripts son ejecutados. El orden de ejecución de los scripts determina la posición de las entradas en el menú de arranque de grub.

Sistemas UEFI

Ejemplos UEFI para hardware específico

Es bien sabido que los fabricantes de placas base implementan UEFI de modo diferente. Los usuarios que experimenten para hacer que funcione correctamente Grub/EFI se les anima a compartir los pasos seguidos durante la instalación para determinar las diferencias en cuanto a lo que se describe a continuación. En un esfuerzo por mantener el artículo sobre GRUB lo más limpio y ordenado posibles, consulte la página ejemplos para GRUB EFI para estos casos especiales.

Instalar el paquete grub-uefi

El gestor de arranque EFI para GRUB(2) está disponible en Arch y solo en la versión 1.99~rc1 en adelante. Para instalarlo, observe primeramente la arquitectura de su firmware UEFI (i386 o x86_64).

Teniendo en cuenta esta información, instale el paquete adecuado.

Para firmware UEFI de 64-bit :

# pacman -S grub-efi-x86_64

Para firmware UEFI 32-bit:

# pacman -S grub-efi-i386

Instalar los archivos de arranque de grub-uefi

Instalación en UEFI System Partition

La partición UEFI del sistema se debe instalar en /boot/efi para que el script de instalación de GRUB la reconozca:

# mkdir -p /boot/efi
# mount -t vfat /dev/sdXY /boot/efi

A continuación, instalar el aplicación UEFI de GRUB y sus módulos en /boot/grub/x86_64-efi (recomendado) usando:

# modprobe dm-mod
# grub-install --target=x86_64-efi --efi-directory=/boot/efi --bootloader-id=arch_grub --recheck --debug
# mkdir -p /boot/grub/locale
# cp /usr/share/locale/en\@quot/LC_MESSAGES/grub.mo /boot/grub/locale/en.mo

Si desea instalar los módulos de grub2 y grub.cfg en la carpeta /boot/efi/EFI/grub y la aplicación grubx64.efi en /boot/efi/EFI/arch_grub (es decir, todos los archivos uefi de grub(2) dentro de la misma partición UEFISYS), utilice:

# modprobe dm-mod 
# grub-install --target=x86_64-efi --efi-directory=/boot/efi --bootloader-id=arch_grub --boot-directory=/boot/efi/EFI --recheck --debug
# mkdir -p /boot/efi/EFI/grub/locale
# cp /usr/share/locale/en\@quot/LC_MESSAGES/grub.mo /boot/efi/EFI/grub/locale/en.mo

La opción --efi-directory indica el punto de montaje de la partición UEFI del sistema, --bootloader-id indica el nombre del directorio donde se instalará la aplicación grubx64.efi, y --boot-directory contiente la ruta de acceso al directorio de instalación de los módulos (y será la sede del archivo de configuración grub.cfg).

La ruta actual es la siguiente:

<efi-directory>/<efi o EFI>/<bootloader-id>/grubx64.efi

<boot-directory>/grub/x86_64-efi/<tutti i moduli, grub.efi, core.efi, grub.cfg>

Si --efi-directory=/boot/efi --boot-directory=/boot/efi/EFI --bootloader-id=grub:

<efi-directory>/<EFI or efi>/<bootloader-id> == <boot-directory>/grub == /boot/efi/EFI/grub

Si --efi-directory=/boot/efi --boot-directory=/boot/efi/EFI --bootloader-id=arch_grub:

<efi-directory>/<EFI or efi>/<bootloader-id> == /boot/efi/EFI/arch_grub
<boot-directory>/grub == /boot/efi/EFI/grub

Si --efi-directory=/boot/efi --boot-directory=/boot --bootloader-id=arch_grub:

<efi-directory>/<EFI or efi>/<bootloader-id> == /boot/efi/EFI/arch_grub
<boot-directory>/grub == /boot/grub

Si --efi-directory=/boot/efi --boot-directory=/boot --bootloader-id=grub:

<efi-directory>/<EFI or efi>/<bootloader-id> == /boot/efi/EFI/grub
<boot-directory>/grub == /boot/grub

El archivo <efi-directory>/<EFI or efi>/<bootloader-id>/grubx64.efi es una copia exacta de <boot-directory>/grub/x86_64-efi/core.efi.

En todos los casos, la partición UEFI del sistema debe montarse como grub-install para instalar grubx64.efi, que será lanzado por el firmware (con el elemento creado con efibootmgr, en los sistemas que no son Mac).

Si mira de cerca, se dará cuenta de la ausencia de una opción que especifica el dispositivo en el que instalar el gestor de arranque (por ejemplo, /dev/sda). Estas opciones son ignoradas por el script de instalación, ya que los gestores de arranque UEFI no utilizan el MBR de la partición.

Ahora será capaz de arrancar a través de UEFI creando un grub.cfg siguiendo Crear un archivo de configuración para GRUB2 UEFI y Crear una entrada para GRUB2 en el Firmware Boot Manager.

Crear un archivo de configuración para GRUB2 UEFI

Se genera un archivo de configuración de GRUB2 usando la siguiente orden:

# grub-mkconfig -o <boot-directory>/grub/grub.cfg

Si ha utilizado --boot-directory=/boot:

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

Si, en cambio, utiliza --boot-directory=/boot/efi/EFI:

# grub-mkconfig -o /boot/efi/EFI/grub/grub.cfg

Las rutas anteriores son independientes del valor de la opción --bootloader-id.

Si GRUB2 muestra el error «no suitable mode found», consulte #Corregir el error de GRUB2 «no suitable mode found»

Crear entrada de GRUB2 en el gestor de arranque del firmware

A partir de la versión 2.00 de grub-efi-x86_64, grub-install automáticamente intentará crear una entrada de menú en el gestor de arranque. Si no es así, véase Beginners'_Guide (Español)#GRUB_2 para obtener instrucciones sobre cómo usar efibootmgr a fin de crear una entrada en el menú. De todas formas, el problema probablemente sea que no se ha arrancado el CD/USB en la modalidad UEFI, como se indica en Unified_Extensible_Firmware_Interface_(Español)#Crear_un_USB_booteable_de_UEFI_desde_la_ISO

Construir una aplicación UEFI Standalone para GRUB2

Es posible crear una aplicación UEFI standalone (grubx64_standalone.efi), que incluye todos los módulos necesarios en el interior de un memdisk, eliminando virtualmente la necesidad de contar con un directorio separado que contenga todos los módulos UEFI de GRUB2 y otros archivos relacionados. Para lograr el objetivo, vamos a utilizar la orden grub-mkstandalone, incluido en el paquete grub-common >=1:1.99-6.

La forma más sencilla de hacerlo es a través de la orden de instalación que se mencionó anteriormente, sin embargo, teniendo cuidado de especificar los módulos que desea incluir. Por ejemplo:

# grub-mkstandalone --directory="/usr/lib/grub/x86_64-efi/" --format="x86_64-efi" --compression="xz" \
--output="/boot/efi/EFI/arch_grub/grubx64_standalone.efi" <archivos adicionales que se desea incluir>

El archivo grubx64_standalone.efi asume que grub.cfg se encuentra en su $prefix, es decir, (memdisk)/boot/grub. El memdisk se incluye a continuación en la aplicación EFI. El script grub-mkstandlone le permite especificar los archivos a incluir en la imagen memdisk como argumentos del script (en <archivos adicionales que se desea incluir>).

Si, por ejemplo, el archivo grub.cfg se encuentra en /home/usuario/Desktop/grub.cfg, se creará un directorio temporal /home/usuario/Desktop/boot/grub y se copiará el archivo /home/usuario/Desktop/grub.cfg en /home/usuario/Desktop/boot/grub/grub.cfg y, finalmente, se colocará en /home/usuario/Desktop/boot/grub/grub.cfg con la orden cd y, a continuación, ejecute:

# grub-mkstandalone --directory="/usr/lib/grub/x86_64-efi/" --format="x86_64-efi" --compression="xz" \
--output="/boot/efi/EFI/arch_grub/grubx64_standalone.efi" "boot/grub/grub.cfg"

La razón de usar cd en /home/user/Desktop/boot/grub/ es que hace pasar la ruta del archivo como boot/grub/grub.cfg (nótese la ausencia de una barra - boot/ vs /boot/) y ello por que dir1/dir2/file se incluye como (memdisk)/dir1/dir2/file por el script grub-mkstandalone.

Si pasa /home/user/Desktop/grub.cfg en el archivo se incluirá como (memdisk)/home/user/Desktop/grub.cfg. Si pasa /home/user/Desktop/boot/grub/grub.cfg en el archivo se incluirá como (memdisk)/home/user/Desktop/boot/grub/grub.cfg. Esa es la razón para ejecutar cd en /home/user/Desktop/boot/grub/ que pasa a boot/grub/grub.cfg, para incluir el archivo como (memdisk)/boot/grub/grub.cfg, que es lo que grub.efi espera que el archivo sea.

Ahora tendrá que crear una entrada en UEFI Boot Manager para /boot/efi/EFI/arch_grub/grubx64_standalone.efi usando efibootmgr. Consulte #Crear entrada de GRUB2 en el gestor de arranque del firmware.

Multiboot en sistemas UEFI

Ejecutar la carga de Microsoft Windows en sistemas de UEFI-GPTx86_64

Se puede encontrar el UUID del sistema de archivos FAT32 en la partición UEFI del sistema, donde residen los archivos del gestor de arranque UEFI de Windows. Por ejemplo, si el archivo bootmgfw.efi se encuentra en /boot/efi/EFI/Microsoft/Boot/bootmgfw.efi (se ignora la diferencia entre letras mayúsculas y minúsculas, dado que no son irrelevantes en un sistema de archivos FAT), ejecute:

# grub-probe --target=fs_uuid /boot/efi/EFI/Microsoft/Boot/bootmgfw.efi
1ce5-7f28

# grub-probe --target=hints_string /boot/efi/EFI/Microsoft/Boot/bootmgfw.efi
--hint-bios=hd0,gpt1 --hint-efi=hd0,gpt1 --hint-baremetal=ahci0,gpt

A continuación, agregue el siguiente código a /etc/grub.d/40_custom para ejecutar la carga de Windows x86_64 (Vista SP1+, 7 o 8) en el sistema UEFI-GPT:

menuentry "Microsoft Windows Vista/7/8 x86_64 UEFI-GPT" {
    insmod part_gpt
    insmod fat
    insmod search_fs_uuid
    insmod chain
    search --fs-uuid --set=root --hint-bios=hd0,gpt1 --hint-efi=hd0,gpt1 --hint-baremetal=ahci0,gpt1 1ce5-7f28
    chainloader /efi/Microsoft/Boot/bootmgfw.efi
}

Por último, regenere /boot/grub/grub.cfg

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

Configuración

Es posible generar grub.cfg de forma automática o modificarlo manualmente.

Generación automática utilizando grub-mkconfig (recomendado)

El equivalente del viejo menu.lst está representado por los archivos /etc/default/grub y /etc/grub.d/*. Estos archivos son utilizados generalmente por grub-mkconfig para generar /boot/grub/grub.cfg. Para generar un grub.cfg use la siguiente orden:

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

/etc/grub.d/10_linux se establece para agregar automáticamente los elementos de menú para Arch Linux que funcionan ut-of-the-box, en cualquier configuración. Para otros sistemas operativos puede ser necesario añadir entradas a /etc/grub.d/40_custom o /boot/grub/custom.cfg.

Argumentos adicionales

Si necesita pasar parámetros especiales a la imagen del kernel, es necesario colocarlos en la variable GRUB_CMDLINE_LINUX contenida en el archivo /etc/default/grub. Esto es análogo a colocar los parámetros directamente en la línea del kernel, como ocurría con el antiguo GRUB Legacy.

Por ejemplo, para permitir restaurar el resumen después de la hibernación, se utilizará GRUB_CMDLINE_LINUX="resume=/dev/sdaX", donde sdaX muestra la partición swap.

También es posible usar GRUB_CMDLINE_LINUX="resume=/dev/disk/by-uuid/${swap_uuid}", donde ${swap_uuid} se refiere a UUID de la propia partición swap.

Si necesita pasar más de un parámetro, se separa con un espacio entre las opciones: por ejemplo, si desea utilizar la función de resume y systemd, tendremos: GRUB_CMDLINE_LINUX="resume=/dev/sdaX init=/bin/systemd"

Creación manual de grub.cfg

Un grub.cfg de base contiene las siguientes opciones:

• (hdX,Y) indica la partición Y en el disco X. La numeración de partición comienza en 1, mientras que la del disco desde 0
• set default=N le permite elegir qué entrada se inicie por defecto
• set timeout=N indica el límite de tiempo en segundos antes que la elección predefinida se inicia
• menuentry "title" {opciones} es un nombre de entrada de arranque title
• set root=(hdX,Y) establece la partición de arranque, es decir, el que contiene el kernel y los módulos de GRUB (no es necesario una partición separada: /boot puede estar contenido dentro de la partición raíz).

Un ejemplo de configuración:

/boot/grub/grub.cfg

# Config file for GRUB2 - The GNU GRand Unified Bootloader
# /boot/grub/grub.cfg

# DEVICE NAME CONVERSIONS
#
#  Linux           Grub
# -------------------------
#  /dev/fd0        (fd0)
#  /dev/sda        (hd0)
#  /dev/sdb2       (hd1,2)
#  /dev/sda3       (hd0,3)
#

# Timeout for menu
set timeout=5

# Set default boot entry as Entry 0
set default=0

# (0) Arch Linux
menuentry "Arch Linux" {
    set root=(hd0,1)
    linux /vmlinuz-linux root=/dev/sda3 ro
    initrd /initramfs-linux.img
}

## (1) Windows
#menuentry "Windows" {
#set root=(hd0,3)
#chainloader +1
#}

Arranque dual

Utilizar grub-mkconfig

La mejor manera de agregar más entradas es modificar el archivo /etc/grub.d/40_custom o /boot/grub/custom.cfg, de modo que se agregan automáticamente al grub.cfg cuando se lanza grub-mkconfig. Después de hacer los cambios, ejecute:

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

para generar un grub.cfg actualizado.

Con GNU/Linux

Si la otra distribución está en /dev/sda2:

menuentry "Other Linux" {
set root=(hd0,2)
linux /boot/vmlinuz (si aggiungano altre opzioni da passare al kernel, se richieste)
initrd /boot/initrd.img (se il kernel lo richiede)
}

Con FreeBSD

Requiere que FreeBSD está instalado en una partición formateada con UFS. Si FreeBSD está en sda4:

menuentry "FreeBSD" {
set root=(hd0,4)
chainloader +1
}

Con Windows

Partimos de la base de que la partición de windows es sda3. Recuerde que es necesario señalar la orden set root y chainloader a la partición reservada del sistema, es decir, la que crea Windows durante la instalación, y no a la partición en la que Windows en realidad reside. En el ejemplo tratado solo funciona si su partición reservada es sda3

# (2) Windows XP
menuentry "Windows XP" {
    set root=(hd0,3)
    chainloader (hd0,3)+1
}

Si el bootloader de Windows está en otro disco duro diferente que el de GRUB, puede que tenga que engañar a Windows haciéndole creer que reside en la primera unidad. Esto fue posible en el antiguo GRUB Legacy con drivemap. Suponiendo que GRUB se encuentra en hd0 y Windows en hd2,, debe agregar la siguiente línea después de set root:

drivemap -s hd0 hd2

Con Windows usando EasyBCD y NeoGRUB

Puede que NeoGRUB no entienda el nuevo formato del menú de GRUB2, será necesario efectuar la carga de GRUB2, reemplazando el contenido de su C:\NST\menu.lst con:

default 0
timeout 1

title       Chainload into GRUB v2
root        (hd0,7)
kernel      /boot/grub/i386-pc/core.img

Configuración del aspecto

En GRUB2 puede cambiar el aspecto del menú. Asegúrese de haber inicializado el terminal gráfico de grub2 (gfxterm), utilizando una modalidad de vídeo adecuado (gfxmode). Para más información se puede encontrar en la sección #Correct_GRUB2_No_Suitable_Mode_Found_Error. La modalidad de vídeo establecida a continuación, se pasará al kernel a través de gfxpayload; por lo tanto, esta solicitud asegurará que cada configuración del aspecto tenga efecto.

Ajustar la resolución del framebuffer

GRUB2 puede establecer el uso de este dispositivo tanto para él como para el kernel. El antiguo parámetro vga= está en desuso. El método recomendado es modificar /etc/default/grub de la siguiente manera:

GRUB_GFXMODE=1024x768x32
GRUB_GFXPAYLOAD_LINUX=keep

Para que los cambios tengan efecto, ejecute:

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

La opción gfxpayload se asegurará de que la resolución se mantendrá y pasará al kernel.

Si este método falla, la antigua opción vga= sigue siendo válida. Añadimos vga= a la opción GRUB_CMDLINE_LINUX_DEFAULT en /etc/default/grub. Por ejemplo: "GRUB_CMDLINE_LINUX_DEFAULT="quiet splash vga=792" establece una resolución 1024x768

Puede elegir entre las siguientes resoluciones: 640×480, 800×600, 1024×768, 1280×1024, 1600×1200, 1920×1200

Introducir 915resolution

Si está usando tarjeta de vídeo de Intel, puede ocurrir que ni # hwinfo --framebuffer ni vbeinfo muestre la resolución deseada. En este caso, puedes utilizar este arreglo, para cambiar temporalmente el BIOS de la tarjeta de vídeo mediante la adición de la resolución requerida. Consulte la página 915resolution.

Lo que sigue es válido para mi sistema: por lo utilícelo según sus necesidades. En primer lugar debe elegir un modo de vídeo para editar más tarde. Comenzamos entonces 915resolution en el shell de grub:

915resolution -l

La salida será similar a la siguiente:

Intel 800/900 Series VBIOS Hack : version 0.5.3
...
Mode 30 : 640x480, 8 bits/pixel
...

El objetivo es sobreescribir la modalidad 30 (por supuesto, puede optar por modificar a cualquier otra modalidad). En el archivo /etc/grub.d/00_header, inserte la línea siguiente antes de set gfxmode=${GRUB_GFXMODE}:

915resolution 30 1440 900

La orden antes descrita sobreescribirá la modalidad 30 con la resolución de 1440x900. Ahora tendrá que establecer el valor de GRUB_GFXMODE, como se explicó anteriormente y reconstruir el archivo de configuración de GRUB2:

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

Imagen de fondo y fuentes bitmap

GRUB2 es compatible con imágenes de fondo y fuentes de mapa de bits en el formato pf2. la fuente uifont está incluido en el paquete grub-common con nombre unicode.pf2 o, solo para carácteres ASCII con nombre ascii.pf2.

Los formatos de imagen soportados incluyen tga, png e jpeg siempre que los respectivos módulos se cargan. La resolución máxima aplicable depende del hardware en uso.

Antes de continuar, siga las disposiciones indicadas en#Establezca la resolución del framebuffer.

A continuación, editar el archivo /etc/default/grub como sigue:

GRUB_BACKGROUND="/boot/grub/miaimmagine"
#GRUB_THEME="/path/to/gfxtheme"
GRUB_FONT="/path/to/font.pf2"

Para aplicar los cambios a grub.cfg, ejecute:

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

Si la inserción de la imagen se realiza correctamente, debería ver el mensaje Found background image..., al ejecutar la orden anterior. Si no, quiere decir que la imagen no se ha incorporado en grub.cfg.

En este caso, se comprueba que:

• La ruta y el nombre de la imagen en /etc/default/grub es correcta
• La imagen tiene un tamaño y formato adecuado (tga, png, png a 8 bits)
• La imagen se guarda en modo RGB y no indexado
• La modalidad consola no está habilitada en el archivo /etc/default/grub
• La orden de grub-mkconfig se ha hecho para poner la información relativa a un segundo plano en el archivo /boot/grub/grub.cfg.

Temas

A continuación se muestra un ejemplo para la configuración propuesta con el tema GRUB2 Starfield, incluido en el paquete suministrado con Arch.

Modificar /etc/default/grub:

GRUB_THEME="/boot/grub/themes/starfield/theme.txt"

Aplicar los cambios:

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

Si el tema se ha configurado correctamente, aparecerá en el terminal el mensaje Found theme: /boot/grub/themes/starfield/theme.txt. La imagen de fondo, por lo general, no se visualiza cuando se utiliza un tema.

Colores del menú

Como sucedía con GRUB Legacy, se pueden cambiar los colores del menú de GRUB2. La lista de colores disponibles se pueden encontrar aquí. A continuación, un ejemplo:

Modificar /etc/default/grub de la siguiente manera:

GRUB_COLOR_NORMAL="light-blue/black"
GRUB_COLOR_HIGHLIGHT="light-cyan/blue"

Para hacer efectivos los los cambios, ejecute:

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

Menú oculto

Una de las características de GRUB2 es la capacidad de ocultar el menú y hacer que sea visible pulsando la tecla Template:Keypress, si es necesario. También puede decidir si se debe mostrar la cuenta atrás.

Modificar /etc/default/grub.. En el siguiente ejemplo, la cuenta atrás se establece en 5 segundos y se hace visible para el usuario:

GRUB_HIDDEN_TIMEOUT=5
GRUB_HIDDEN_TIMEOUT_QUIET=false

Ejecutar:

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

Desactivar el framebuffer

Si utiliza el controlador propietario de NVIDIA, puede que tenga que desactivar el framebuffer de GRUB2, ya que podría interferir con el controlador.

Para desactivarlo, edite /etc/default/grub y descomente la siguiente línea:

GRUB_TERMINAL_OUTPUT=console

A continuación, ejecute:

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

Otra opción, si desea conservar el framebuffer para GRUB2, es revertir al modo de texto justo antes de iniciarse el kernel. Para conseguir esto, modifique la variable en /etc/default/grub:

GRUB_GFXPAYLOAD_LINUX=text

y reconstruya el archivo de configuración como se indicó antes.

Otras opciones

LVM

Si utiliza LVM para su /boot, añada la siguiente línea antes de las diversas entradas:

insmod lvm

y especificar su root en menuentry de este modo:

set root=(nome_gruppo_lvm-nome_partizione_logica_di_boot_lvm)

Ejemplo:

# (0) Arch Linux
menuentry "Arch Linux" {
insmod lvm
set root=(VolumeGroup-lv_boot)
# you can only set following two lines
linux /vmlinuz-linux root=/dev/mapper/VolumeGroup-root ro
initrd /initramfs-linux.img
}

RAID

GRUB2 permite tratar los volúmenes en una configuración RAID de una manera sencilla. Añadimos insmod raid a grub.cfg que hará referencia al volumen de forma nativa. Por ejemplo, /dev/md0 se convierte en:

set root=(md0)

mientras que un volumen RAID particionado (por ejemplo, /dev/md0p1) se convierte en:

set root=(md0,1)

Nomenclatura permanente de dispositivos de bloque

Un esquema de nomenclatura de nombres persistentes para dispositivos de bloque es usar UUID, que son únicos y globales, para detectar particiones, en lugar de la «vieja» nomenclatura /dev/sd*. Las ventajas de este método están tratadas en el artículo anteriormente enlazado.

La nomenclatura persistente a través de las UUID del sistema de archivos se utiliza por defecto en GRUB2.

Cuando se usan las UUID son controladas por una opción en /etc/default/grub:

# GRUB_DISABLE_LINUX_UUID=true

En cualquier caso, no se olvide de aplicar los cambios:

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

Utilizar etiquetas

Puede utilizar las etiquetas (cadenas que identifican particiones de una manera legible por el usuario), usando la opción --label de la orden search. En primer lugar, colocar una etiqueta a las particiones:

# tune2fs -L a <ETIQUETA><PARTICIÓN>

A continuación, se agrega una entrada usando las etiquetas:

menuentry "Arch Linux, session texte" {
    search --label --no-floppy --set=root archroot
    linux /boot/vmlinuz-linux root=/dev/disk/by-label/archroot ro
    initrd /boot/initramfs-linux.img
}

Recordar el último sistema arrancado

GRUB2 puede recordar el último sistema arrancado y utilizarlo por defecto la próxima vez que ejecute el arranque. Esta característica es útil si tienes varios kernels (por ejemplo, le kernel actual de Arch y el LTS como fallback) o más sistemas operativos. Modificar /etc/default/grub y cambiar el valor de GRUB_DEFAULT:

GRUB_DEFAULT=saved

Esto permitirá que GRUB arranque el sistema operativo guardado. Para habilitar el rescate, añadir la siguiente línea a /etc/default/grub:

GRUB_SAVEDEFAULT=true

Por favor, recuerde volver a generar el archivo de configuración de GRUB.

Seguridad

Si desea hacer GRUB2 seguro y que nadie pueda cambiar los parámetros de arranque o utilizar la línea de órdenes, puede agregar un nombre de usuario y contraseña para los archivos de configuración de GRUB. Para ello, ejecute grub-mkpasswd_pbkdf2. Es necesario introducir una contraseña y confirmarla. La salida tendrá este aspecto:

Your PBKDF2 is grub.pbkdf2.sha512.10000.C8ABD3E93C4DFC83138B0C7A3D719BC650E6234310DA069E6FDB0DD4156313DA3D0D9BFFC2846C21D5A2DDA515114CF6378F8A064C94198D0618E70D23717E82.509BFA8A4217EAD0B33C87432524C0B6B64B34FBAD22D3E6E6874D9B101996C5F98AB1746FE7C7199147ECF4ABD8661C222EEEDB7D14A843261FFF2C07B1269A

Añadir las siguientes cadenas a /etc/grub.d/0_header:

cat << EOF

set superusers="username"
password_pbkdf2 username <password>

EOF

Donde <password> corresponde a la cadena generada por grub-mkpasswd_pbkdf2.

Hay que regenerar el archivo de configuración. La línea de órdenes y los parámetros de arranque de grub2 ahora están protegidos.

Los ajustes anteriores se pueden hacer menos restrictivos y personalizar mediante la adición de más usuarios, como se explica en el capítulo «Seguridad» en el de seguridad de GRUB .

Partición root cifrada

Para asegurarse de que grub2 pasa automáticamente los parámetros al kernel necesarios para cifrar la partición root, agregue cryptdevice=/dev/device:etichetta a GRUB_CMDLINE_LINUX en /etc/default/grub.

Un ejemplo con la raíz mapeada en /dev/mapper/root:

GRUB_CMDLINE_LINUX="cryptdevice=/dev/sda2:root"

También desactive el uso de la UUID para el sistema de archivos de la raiz:

GRUB_DISABLE_LINUX_UUID=true

A continuación, tiene que volver a generar el archivo de configuración de grub.

Efectuar el arranque de una entrada no predeterminada por una sola vez

La orden grub-reboot es muy útil para arrancar otra entrada distinta de la predeterminada solo por una vez. GRUB2 carga la entrada especificada como primer argumento de la orden, de modo que la próxima vez, cuando el sistema reinicie, arrancará el sistema operativo indicado. Lo más importante es que GRUB2 vuelve a cargar la entrada por defecto para todos los sucesivos arranques. Por tanto, no es necesario cambiar el archivo de configuración o seleccionar una entrada en el menú de GRUB2.

Comenzar una imagen ISO directamente desde GRUB2

Modificar /etc/grub.d/40_custom o /boot/grub/custom.cfg mediante la adición de una entrada para arrancar la ISO que desea iniciar. Una vez hecho esto, se actualiza el menú de GRUB con el habitual grub-mkconfig -o /boot/grub/grub.cfg (hecho como root).

ISO de Arch Linux

Ejemplo usando x86_64

menuentry "Archlinux-2013.01.04-dual.iso" --class iso {
  set isofile="/archives/archlinux-2013.01.04-dual.iso"
  loopback loop (hd0,6)$isofile
  linux (loop)/arch/boot/x86_64/vmlinuz archisolabel=ARCH_201301 img_dev=/dev/sda6 img_loop=$isofile earlymodules=loop
  initrd (loop)/arch/boot/x86_64/archiso.img
}

Ejemplo usando i686

menuentry "Archlinux-2013.01.04-dual.iso" --class iso {
  set isofile="/archives/archlinux-2013.01.04-dual.iso"
  loopback loop (hd0,6)$isofile
  linux (loop)/arch/boot/i686/vmlinuz archisolabel=ARCH_201301 img_dev=/dev/sda6 img_loop=$isofile earlymodules=loop
  initrd (loop)/arch/boot/i686/archiso.img
}

ISO de Ubuntu

menuentry "ubuntu-12.04-desktop-amd64.iso" {
    set isofile="/archives/ubuntu-12.04-desktop-amd64.iso"
    loopback loop (hd0,6)$isofile
    linux (loop)/casper/vmlinuz boot=casper iso-scan/filename=$isofile quiet noeject noprompt splash --
    initrd (loop)/casper/initrd.lz
}

Otras ISO

Otras configuraciones funcionales están disponibles desde link Source.

Utilizar la shell

Dado que el MBR es demasiado pequeño para contener todas las formas de GRUB2, solo el menú y los comanos básicos residen allí. La mayor parte de la funcionalidad de GRUB2 está contenida en los módulos en /boot/grub, que se cargan cuando sea necesario. En caso de errores (por ejemplo, si la tabla de particiones se altera), GRUB2 puede fallar al arrancar, e iniciar un shell en lugar del clásico menú.

GRUB2 ofrece diferentes tipos de shell. Si tiene problemas para leer el menú, pero el gestor de arranque es todavía capaz de encontrar el disco donde el GRUB2 reside, es probable que lance una shell «normal»:

sh:grub>

En caso de problemas más serios (GRUB no puede encontrar los archivos necesarios), puede aparecer la shell de emergencia:

grub rescue>

La shell de emergencia es una versión reducida de la normal, y ofrece, por lo tanto, un número reducido de funcionalidades. Trate de cargar el módulo normal, e iniciar el shell clásico:

grub rescue> set prefix=(hdX,Y)/boot/grub
grub rescue> insmod (hdX,Y)/boot/grub/normal.mod
rescue:grub> normal

Soporte para Pager

GRUB2 apoya el pager (paginador o localizador) para que sea fácil leer el «output» largo. Tenga en cuenta que esta característica solo está disponible en la consola normal, y no en una de emergencia. Para activarlo, escriba:

sh:grub> set pager=1

Herramientas GUI de configuración

Los siguientes paquetes pueden ser instalados desde AUR

• grub-customizer^AUR (requiere gettext, gksu, gtkmm, hicolor-icon-theme, openssl)

  Utilidad para personalizar el gestor de arranque (GRUB2 o BURG)

• grub2-editor^AUR (requiere kdelibs)

  Un módulo KCM para KDE4 para configurar GRUB2.

• kcm-grub2^AUR (requiere kdelibs python2-qt kdebindings-python)

  Este módulo KCM gestiona los ajustes de GRUB2 más comunes.

• startupmanager^AUR (requiere gnome-python imagemagick yelp python2 xorg-xrandr)

  Una interfaz gráfica de usuario para cambiar la configuración de GRUB, GRUB2, Usplash y Splashy.

parttool para mostrar/ocultar particiones

Si tiene instalado Windows 9x con el disco C:\ oculto, GRUB dispone de las opciones hide/unhide usando parttool. Por ejemplo, para efectuar el arranque del tercer disco C:\ de tres sistema Windows 9x instalados, se inicia la shell y:

parttool hd0,1 hidden+ boot-
parttool hd0,2 hidden+ boot-
parttool hd0,3 hidden- boot+
set root=hd0,3
chainloader +1
boot

Utilizar la consola de emergencia

Véase más arriba #Usando la shell. Si no es capaz de iniciar la shell estándar, una posible solución es arrancar LiveCD o algún otro disco de reparación para corregir los errores de configuración y reinstalar GRUB. Sin embargo, un disco de recuperación no siempre es posible (ni necesario), y la consola de emergencia es sorprendentemente robusta.

Las órdenes disponibles en esta modalidad incluyen insmod, ls, set e unset. Este ejemplo utiliza set y insmod. set cambia el valor de las variables, mientras que insmod añade nuevos módulos para ampliar la funcionalidad básica.

Antes de comenzar, es necesario que conozca la ubicación de la partición de /boot (ya sea por separado o en un subdirectorio de la partición de root):

grub rescue> set prefix=(hdX,Y)/boot/grub

Donde X es el número de la unidad y la Y de la partición. Para ampliar las capacidades de la consola, insertar el módulo linux.

grub rescue> insmod (hdX,Y)/boot/grub/linux.mod

Esto proporciona órdenes de linux y initrd, con las que debe estar familiarizado (ver #Configuración).

Un ejemplo de inicio de Arch Linux:

set root=(hd0,5)
linux /boot/vmlinuz-linux root=/dev/sda5
initrd /boot/initramfs-linux.img
boot

De nuevo, en el caso de partición de arranque separada, cambie las órdenes en consecuencia:

set root=(hd0,5)
linux /vmlinuz-linux root=/dev/sda6
initrd /initramfs-linux.img
boot

Tras el lanzamiento de una instalación correcta de Arch Linux, puede arreglar grub.cfg y proceder a la reinstalación de GRUB2.

Para reinstalar GRUB2 en el MBR, cambie /dev/sda conforme a las propias necesidades. Consulte #Instalación del gestor de arranque para más detalles.

Combinar UUID y scripting

Si desea utilizar la asignación de UUID para superar los mapeados poco fiables de los dispositivos realizadas por la BIOS, o si está teniendo dificultades con la sintaxis de GRUB, aquí hay un ejemplo que utiliza el UUID, y un pequeño script para GRUB para que apunte a las particiones correspondientes. Todo lo que uno debe hacer, es sustituir el ejemplo con el UUID correcto para su sistema (el ejemplo se aplica a sistemas con una partición de arranque separada y debe modificarse en consecuencia en caso de particiones adicionales).

 menuentry "Arch Linux 64" {
     # Set the UUIDs for your boot and root partition respectively
     set the_boot_uuid=ece0448f-bb08-486d-9864-ac3271bd8d07
     set the_root_uuid=c55da16f-e2af-4603-9e0b-03f5f565ec4a
   
     # (Note: This may be the same as your boot partition)
   
     # Get the boot/root devices and set them in the root and grub_boot variables
     search --fs-uuid --no-floppy --set=root $the_root_uuid
     search --fs-uuid --no-floppy --set=grub_boot $the_boot_uuid
   
     # Check to see if boot and root are equal.
     # If they are, then append /boot to $grub_boot (Since $grub_boot is actually the root partition)
     if [ $the_boot_uuid == $the_root_uuid] ; then
         set grub_boot=$grub_boot/boot
     fi
   
     # $grub_boot now points to the correct location, so the following will properly find the kernel and initrd
     linux ($grub_boot)/vmlinuz-linux root=/dev/disk/by-uuid/$uuid_os_root ro
     initrd ($grub_boot)/initramfs-linux.img
 }

Solución de problemas

Algunas Bios de Intel no efectúan el arranque de la partición GPT

Algunas BIOS de Intel requieren, al menos, una partición MBR marcada como booteable en el arranque, cosa no habitual en las configuraciones basadas en GPT, que causan que la partición GPT no se inicie.

Es posible solucionar el problema mediante el uso de (por ejemplo) fdisk para marcar como bootable en el MBR una de las particiones GPT (preferiblemente la partición de 1007KiB que ya se ha creado para GRUB2). Esto se puede lograr, utilizando fdisk, mediante las siguientes órdenes: Inicie fdisk sobre el disco donde va a realizar la instalación, por ejemplo «fdisk /dev/sda», y seleccione la partición que desea marcar como booteable (seguramente #1) pulsando el número correspondiente, para terminar pulse «w» para escribir los cambios en el MBR.

Debemos tener en cuanta que para marcar como booteable una partición hay que hacerlo con la utilidad fdisk o similar, no se puede hacer con GParted o equivalentes, ya que estos últimos no establecen el indicador de booteable en el MBR.

Para más información consulte aquí

Activar mensajes de depuración en GRUB2

Se añade:

set pager=1
set debug=all

en grub.cfg.

Corregir el error de GRUB2 «no suitable mode found»

Si recibe este error en la elección de una opción de arranque:

error: no suitable mode found
Booting however

A continuación, se debe inicializar el terminal gráfico GRUB2 (gfxterm), utilizando un modo de vídeo adecuado (gfxmode). Este se transmite de GRUB2 al kernel de Linux usando la opción gfxpayload. En sistemas UEFI, si la modalidad de video del GRUB2 no está inicializada, se mostrarán los mensajes de arranque del kernel (al menos hasta la activación de KMS).

Ahora, copie /usr/share/grub/unicode.pf2 en ${GRUB2_PREFIX_DIR} (/boot/grub de los sistema BIOS y UEFI. Si GRUB2 UEFI se instala con la opción --boot-directory habilitada, entonces la ruta es /boot/efi/EFI/grub).

# cp /usr/share/grub/unicode.pf2 ${GRUB2_PREFIX_DIR}

Si el archivo /usr/share/grub/unicode.pf2 no existe, instalar el paquete bdf-unifont y proceda a la creación y copia del mismo en ${GRUB2_PREFIX_DIR}.

# grub-mkfont -o unicode.pf2 /usr/share/fonts/misc/unifont.bdf

En el archivo grub.cfg, agregue las líneas siguientes para habilitar GRUB2 para que pase correctamente la modalidad de video al kernel, de lo contrario obtendrá una pantalla en negro, aunque el arranque se haga periódicamente, sin que el sistema se bloquee:

Sistemas BIOS

insmod vbe

Sistemas UEFI

insmod efi_gop
insmod efi_uga

A continuación, agregue el siguiente código (común a los sistemas BIOS y UEFI)

insmod font

if loadfont ${prefix}/fonts/unicode.pf2
then
    insmod gfxterm
    set gfxmode=auto
    set gfxpayload=keep
    terminal_output gfxterm
fi

Como puede ver, para que gfxterm funcione correctamente, la fuente unicode.pf2 debe existir en ${GRUB2_PREFIX_DIR}.

Mensaje de error msdos-style

grub-setup: warn: This msdos-style partition label has no post-MBR gap; embedding won't be possible!
grub-setup: warn: Embedding is not possible. GRUB can only be installed in this setup by using blocklists.
            However, blocklists are UNRELIABLE and its use is discouraged.
grub-setup: error: If you really want blocklists, use --force.

Este problema se produce cuando se intenta instalar GRUB2 en VMWare. Más información aquí. Se espera una solución pronto.

También puede ocurrir cuando la partición comienza justo después del MBR (bloque 63), sin dejar un espacio de alrededor de 1 MB (2048 bloques) antes de la primera partición.

GRUB2 UEFI vuelve a la shell

Si GRUB se carga, pero vuelve a regresar a shell, sin error, el archivo grub.cfg pueden estar en una posición incorrecta o no existir en absoluto. Este problema puede producirse si GRUB2 UEFI se ha instalado con la opción de --boot-directory habilitada, y el archivo no existe, o si el número identificativo de la partición de arranque ha cambiado (este valor es, de hecho, «codificado» en el archivo grubx64.efi).

GRUB2 UEFI no se carga

En algunos casos, EFI puede no arrancar correctamente GRUB. Suponiendo que todo ha sido instalado de la manera correcta, la salida de:

efibootmgr -v

se parecerá a esto:

BootCurrent: 0000
Timeout: 3 seconds
BootOrder: 0000,0001,0002
Boot0000* Grub HD(1,800,32000,23532fbb-1bfa-4e46-851a-b494bfe9478c)File(\efi\grub\grub.efi)
Boot0001* Shell HD(1,800,32000,23532fbb-1bfa-4e46-851a-b494bfe9478c)File(\EfiShell.efi)
Boot0002* Festplatte BIOS(2,0,00)P0: SAMSUNG HD204UI

EFI ahora debe cargar GRUB correctamente. Si la pantalla deviene en negro durante unos segundos y GRUB pasa a la opción siguiente del boot, como está escrito en este post, mover GRUB a la partición raíz podría ayudar.

La opción de arranque debería ser eliminada y recreada después de la operación. El campo relativo a grub debería ahora ser similar a esto:

 Boot0000* Grub HD(1,800,32000,23532fbb-1bfa-4e46-851a-b494bfe9478c)File(\grub.efi)

Invalid signature

Si recibe el error «invalid signature» al intentar iniciar Windows, por ejemplo, si han alterado la tabla de particiones después de agregar otras particiones o discos duros, trate de eliminar la configuración de los dispositivos de GRUB y deje que la regenere él mismo:

# mv /boot/grub/device.map /boot/grub/device.map-old
# grub-mkconfig -o /boot/grub/grub.cfg

grub-mkconfig debería ahora mostrar todas las opciones de arranque, incluyendo Windows. Si el problema está resuelto, elimine /boot/grub/device.map-old.

Bloqueos al arrancar

Si el arranque se bloquea sin ningún mensaje de error después deque grub2 cargue el kernel y el ramdisk inicial, prueble eliminado add_efi_memmap de los parámetros del kernel.

Restaurar GRUB Legacy

• Mueva los archivos de GRUB Legacy o GRUB2:

# mv /boot/grub /boot/grub.nonfunctional

• Restaurar la copia de seguridad de GRUB Legacy en /boot:

# cp -af /boot/grub-legacy /boot/grub

• Restaurar el MBR y los siguientes 62 sectores del disco sda:

# dd if=/path/to/backup/first-sectors of=/dev/sdX bs=512 count=1

Una solución más segura es restaurar solo el MBR:

 # dd if=/path/to/backup/mbr-boot-code of=/dev/sdX bs=446 count=1

Referencias

1. Manual Oficial de GRUB2 - http://www.gnu.org/software/grub/manual/grub.html
2. Página wiki de Ubuntu sobre GRUB2 - https://help.ubuntu.com/community/Grub2
3. Página wiki de GRUB2 donde explica cómo compilarlo para sistemas UEFI - http://help.ubuntu.com/community/UEFIBooting
4. Página de Wikipedia sobre la partición de inicio del BIOS.

Enlaces externos

1. A Linux Bash Shell script to compile and install GRUB(2) for BIOS from BZR Source
2. A Linux Bash Shell script to compile and install GRUB(2) for UEFI from BZR Source