GRUB2

From Gentoo Wiki
Jump to: navigation, search
This page contains changes which are not marked for translation.

Other languages:
English • ‎日本語 • ‎русский
External resources

GRUB2 is a boot loader with support for modern day computer systems. It is meant to replace the older GRUB boot loader (now referred to as "GRUB Legacy"). GRUB2 has an entirely separate code base from GRUB Legacy and boasts features such as a new shell-like syntax which permits advanced scripting capabilities. Current GRUB Legacy users are encouraged to migrate their systems to GRUB2.

For a shotgun approach, see GRUB2 Quick Start.

Installation

The sys-boot/grub package is slotted. Both grub-0.97 (GRUB Legacy) and grub-2.00 may be installed at the same time, however only one version of GRUB may be installed in a MBR at a time. In this article, we focus on GRUB2.

By default, GRUB2 will guess a default platform target at build time. This may be overridden by setting the GRUB_PLATFORMS variable in make.conf.

FILE /etc/portage/make.conf Example of setting GRUB_PLATFORMS variable for EMU, EFI, and PC support
GRUB_PLATFORMS="emu efi-32 efi-64 pc"

The following platforms are supported depending on the target CPU:

Target
Platform i386 ia64 mips mipsel powerpc spac64 x86_64
arc No No No Yes No No No
coreboot Yes No No No No No 32-bit
efi Yes Yes No No No No Yes
emu Yes Yes Yes Yes Yes Yes Yes
ieee1275 Yes No No No Yes Yes 32-bit
loongson No No No Yes No No No
multiboot Yes No No No No No 32-bit
qemu Yes No No No No No 32-bit
qemu-mips No No Yes No No No No
pc Yes No No No No No 32-bit

To install GRUB2 use the normal emerge syntax:

root #emerge --ask --newuse sys-boot/grub:2

Optionally, install the os-prober utility (provided through the sys-boot/os-prober package) to have GRUB2 probe for other operating systems when running the grub2-mkconfig command. In most instances, this will enable GRUB2 to automatically detect other operating systems (Windows 7, Windows 8.1, etc.).

root #emerge --ask --newuse sys-boot/os-prober

The GRUB2 (and optionally sys-boot/os-prober) installations do not automatically enable the boot loader. These only install the software on the operating system, but to install the boot loader to the system itself (so that it is used when booting the system), additional steps need to be taken, which are covered in the Configuration section.

Configuration

There are two important aspects to the configuration of GRUB2:

  1. installation of GRUB2 software as the boot loader of the system
  2. configuration of the GRUB2 boot loader itself

The installation of GRUB2 software is specific to the type of system, and is covered in Installing the boot loader. First we cover the configuration of the boot loader itself.

Main configuration file

GRUB2 does not require the administrator to manually maintain a boot option configuration (as is the case with boot loaders such as GRUB Legacy and LILO). Instead it can generate its configuration file (/boot/grub/grub.cfg) using the grub2-mkconfig command. This utility will use the scripts in /etc/grub.d/ and the settings in /etc/default/grub.

Warning
The grub2-mkconfig utility does not work properly when using software RAID. Manual configuration of the scripts in /etc/grub.d/ is necessary, as otherwise after installation the system will be left in a non-bootable state.

After modifying one or more settings, run the grub2-mkconfig utility with the -o option pointing to the output file located at /boot/grub/grub.cfg (this is GRUB2's default output location):

root #grub2-mkconfig -o /boot/grub/grub.cfg
Generating grub.cfg ...
Found linux image: /boot/vmlinuz-3.3.0-gentoo
done

Each time the grub2-mkconfig utility is called a new configuration will be generated.

Warning
If grub2-mkconfig does not report any found entries then no entries were found. In this case GRUB2 will offer no boot selections when upon system restart which may be a tricky, time consuming situation to resolve. Make sure the output is satisfactory before restarting the system.

Setting configuration parameters

GRUB2 uses /boot/grub/grub.cfg as its configuration file. However, it is advised to automatically generate this file based on the configuration entries in /etc/default/grub. The file uses key/value pairs which are used by the scripts in /etc/grub.d to generate a working configuration file.

The following variables are the most common ones to set to control how GRUB2 will function:

Variable Explanation Default value
GRUB_DEFAULT Defines the default menu entry selected on boot. May be a numeric index, a menu title, or "saved". Defaults to first detected entry.
GRUB_TIMEOUT Delay (in seconds) before booting default menu entry. Set to 0 to wait indefinitely. The default is 5 seconds.
GRUB_CMDLINE_LINUX Parameters to be passed on the kernel command line for all Linux menu entries. For instance, to support hibernation, users will need to add GRUB_CMDLINE_LINUX="resume=/dev/sdXY" with /dev/sdXY being the swap partition.
GRUB_CMDLINE_LINUX_DEFAULT Parameters to be passed on the kernel command line for non-recovery Linux menu entries.
GRUB_DEVICE The initial root device (i.e. the kernel's root= parameter). Set this to override the grub2-mkconfig command's root device auto-detection. For example, GRUB_DEVICE=/dev/ram0 will force root=/dev/ram0 to be used in the kernel command line.

For a more complete list, please refer to the GRUB2 configuration variables sub-page.

After modifying the parameters, regenerate the GRUB2 configuration file with grub2-mkconfig.

Enabling or disabling configuration scripts

The directory /etc/grub.d/ contains the scripts that grub2-mkconfig uses to generate a grub.cfg file. By default the contents of this directory should be similar to the following:

user $ls /etc/grub.d/
00_header  10_linux  20_linux_xen  30_os-prober  40_custom  41_custom README

GRUB2 will use all installed scripts that are marked as executable (which by default, they all are). To disable any of the scripts simply remove the executable bit from the script's file permissions using the chmod command. In the following example every script but 00_header and 10_linux are disabled:

root #chmod -x /etc/grub.d/{20_linux_xen,30_os-prober,40_custom,41_custom}

After modifying the scripts (or removing the executable bit), regenerate the GRUB2 configuration file using grub2-mkconfig.

Manipulating configuration scripts

Some features or GRUB2 functionalities are only possible to be exploited by modifying the configuration scripts. For instance, to support dual-booting with FreeBSD, the following manipulation needs to be done.

Change the /etc/grub.d/40_custom script to:

FILE /etc/grub.d/40_custom Adding DualBoot
menuentry "FreeBSD" --class freebsd --class bsd --class os {
 insmod ufs2
 insmod bsd
 set root=(hd0,1)
 kfreebsd /boot/kernel/kernel
 kfreebsd_loadenv /boot/device.hints
 set kFreeBSD.vfs.root.mountfrom=ufs:/dev/ada0s1a
 set kFreeBSD.vfs.root.mountfrom.options=rw
 set kFreeBSD.hw.psm.synaptics_support=1
}

/dev/sda1 or (hd0,1) is the partition in which FreeBSD resides. If the normal UFS install was used for the FreeBSD partition then /dev/sda1 is a container (something like a logical partition). It consists of the swap and root partition. Verify the 40_custom script is executable by running ls -la /etc/grub.d/40_custom. If the executable bit is not set then set it using the chmod u+x 40_custom command.

Next install GRUB2 using the grub2-install command and update GRUB2's configuration file:

root #grub2-install /dev/sda
root #grub2-mkconfig -o /boot/grub/grub.cfg


Installing the boot loader

Installing GRUB2 as the system's boot loader depends on how the system is meant to boot (through BIOS or UEFI) and how the disk on which the boot loader should be installed is partitioned (using MBR or GPT partition layout).

This article covers the following situations:

Select the installation instructions appropriate for the system.

BIOS with MBR

Note
When the system is meant to dual-boot with Microsoft Windows, make sure that the system itself does not have an EFI firmware. Even when such systems are booted in 'legacy BIOS' mode, Microsoft Windows will refuse to boot.

Make sure that the /boot location is available - if this uses a separate partition, make sure that it is mounted:

root #mount /boot

Run the grub2-install command to copy the relevant files to /boot/grub. On the PC platform, this also installs a boot image to the Master Boot Record (MBR) or a partition's boot sector. If all goes well, after running the grub2-install command an output such as the one below is to be expected:

root #grub2-install /dev/sda
Installation finished. No error reported.

grub2-install accepts a --target option to set the CPU architecture and system platform. If unspecified, grub2-install will attempt to guess the proper values; on an AMD64/x86 system it will use i386-pc by default. grub2-install also accepts a --boot-directory option to tell the GRUB2 installer which directory to look for GRUB2's boot files. This defaults to the current /boot but is useful when trying to move a root partition.

Partitioning for BIOS with MBR

Be sure to leave enough free space before the first partition. Starting the first partition at sector 2048 leaves at least 1 MiB of disk space for the master boot record. It is recommended (but not mandatory) to create an additional partition for GRUB called the BIOS boot partition. This partition just needs to be defined, but not formatted.

If the Gentoo installation instructions were followed, this BIOS boot partition will already be available.

BIOS with GPT

Note
When the system is meant to dual-boot with Microsoft Windows, make sure that the system itself does not have an EFI firmware. Even when such systems are booted in 'legacy BIOS' mode, Microsoft Windows will refuse to boot. Also, older Microsoft Windows systems might not support GPT. It is possible to use a hybrid MBR-GPT approach, see Hybrid partition table.

If a /boot partition is needed, start by mounting the /boot partition:

root #mount /boot

If all goes well, after running the grub2-install command an output such as the one below is to be expected:

root #grub2-install /dev/sda
Installation finished. No error reported.

grub2-install accepts a --target option to set the CPU architecture and system platform. If unspecified, grub2-install will attempt to guess the correct at the correct values; on an AMD64/x86 system it will use i386-pc by default. grub2-install also accepts a --boot-directory option to tell the GRUB2 installer which directly to look for GRUB2's boot files. This defaults to the current /boot but is useful when trying to move a root partition.

Partitioning for BIOS with GPT

When a GPT partition table is present on the system, a small BIOS boot partition (with type EF02, which is different from the EFI System Partition (ESP) which has type EF00) will need to be available. 1 MiB will be enough to work but 2-4 MiB is a more safe option. This BIOS boot partition will hold the stage 2 of the bootloader. BIOS boot partitions do not need formatted with a filesystem; the grub2-install command will overwrite any pre-existing filesystem with one of it's own.

To set a partition as a BIOS partition use the command line tool parted (sys-block/parted) by typing (change 1 to the number of the partition to mark as a BIOS Boot partition!):

(parted)set 1 bios_grub on

With sys-apps/gptfdisk's cgdisk utility, this is accomplished by setting the partition type to 0xEF02 and give it a label of gptbios.

An EFI System Partition is not required, but it would be sensible to make sure that the BIOS boot partition is large enough to be converted to one, should the system motherboard later be upgraded to an EFI board.

The following is the output of pressing the p key using the gdisk utility on a GPT partitioned disk with both a BIOS boot [0xEF02] partition and an EFI [0xEF00] partition:

root #gdisk /dev/sdc
GPT fdisk (gdisk) version 0.8.1
 
Partition table scan:
  MBR: protective
  BSD: not present
  APM: not present
  GPT: present
 
Found valid GPT with protective MBR; using GPT.
 
Command (? for help): p
Disk /dev/sdc: 976773168 sectors, 465.8 GiB
Logical sector size: 512 bytes
Disk identifier (GUID): AA369F4D-37A4-4C0D-A357-DC24B99A6337
Partition table holds up to 128 entries
First usable sector is 34, last usable sector is 976773134
Partitions will be aligned on 2048-sector boundaries
Total free space is 2014 sectors (1007.0 KiB)
 
Number  Start (sector)    End (sector)  Size       Code  Name
   1            2048       828377087   395.0 GiB   8E00  Linux LVM
   2       828377088       891291647   30.0 GiB    0700  Microsoft basic data
   3       891291648       975177727   40.0 GiB    0700  Microsoft basic data
   4       975177728       976754687   770.0 MiB   8300  Linux filesystem
   5       976754688       976756735   1024.0 KiB  EF02  BIOS boot partition
   6       976756736       976773134   8.0 MiB     EF00  EFI System
 
Command (? for help): 
Note
The 0x hexadecimal prefix does not need to be entered for GPT when using fdisk.

Using the same setup, the parted utility gives an output with slightly different syntax:

root #parted /dev/sdc
GNU Parted 3.0
Using /dev/sdc
(parted) print
...
Sector size (logical/physical): 512B/512B
Partition Table: gpt
  
Number  Start   End    Size    File system  Name                  Flags
 1      1049kB  424GB  424GB                Linux LVM             lvm
 2      424GB   456GB  32.2GB               Microsoft basic data
 3      456GB   499GB  42.9GB               Microsoft basic data
 4      499GB   500GB  807MB   ext2         Linux filesystem
 5      500GB   500GB  1049kB               BIOS boot partition   bios_grub
 6      500GB   500GB  8396kB               EFI System            boot
  
(parted)

Creating partitions in gdisk is straight forward for users already familiar with the fdisk partitioning utility. After starting gdisk, type n (for new) in the main menu, provide beginning and end sectors (if needed), then set the partition type EF00 for an EFI system partition.

Users who have followed the Gentoo installation instructions will already have the proper partitioning layout set up.

UEFI with GPT

Make sure that the /boot location is available - if this uses a separate partition, make sure that it is mounted:

root #mount /boot

Run the grub2-install command to copy the relevant files to /boot/grub. This should install Grub2 in /boot/grub, copy the core image to /boot/efi/EFI/gentoo/grubx64.efi, and call efibootmgr to add a boot entry.

root #grub2-install --target=x86_64 /dev/sda
Installation finished. No error reported.

grub2-install accepts a --target option to set the CPU architecture and system platform. If unspecified, grub2-install will attempt to guess the proper values; on an AMD64/x86 system it will use i386-pc by default. grub2-install also accepts a --boot-directory option to tell the GRUB2 installer which directory to look for GRUB2's boot files. This defaults to the current /boot but is useful when trying to move a root partition.

Partitioning for UEFI with GPT

For UEFI GPT boot using GRUB2, the system must have a dedicated EFI partition containing a FAT filesystem.

The EFI partition can replace having a /boot partition on /dev/sda1 by having a /boot/efi partition on /dev/sda1. This is to say a successful EFI boot scenario using GRUB2 can operate with two partitions total (three total if a swap partition is needed): a root partition and an EFI partition. Using this configuration, the /boot folder will be located in the root / partition (at /boot) and the EFI partition will mount in the boot folder (at /boot/efi). For further clarification, see the example /etc/fstab file below.

FILE /etc/fstab Example of an UEFI capable /etc/fstab file with a swap partition:
/dev/sda1		/boot/efi	vfat		noauto,noatime	1 2
/dev/sda2		none		swap		sw		0 0
/dev/sda3		/		ext4		noatime		0 1

Generating a 100MB partition for /boot/efi should provide plenty of space for holding multiple *.efi files (multiple entries will most likely not be needed; most systems will only use one).

Create the partition using the partitioning tool of choice. The gdisk (sys-apps/gptfdisk) and parted (sys-block/parted) tools fit nicely for this purpose. When using the gdisk utility, be sure to use type EF00.

Proceed to create a FAT filesystem on the EFI system partition using mkdosfs and add it to /etc/fstab by following the example below:

root #mkdosfs -F 32 -n efi-boot /dev/sda1
root #mkdir /boot/efi
FILE /etc/fstab Adding the /boot/efi mount entry
/dev/sda1		/boot/efi	vfat		noauto,noatime	1 2
root #mount /boot/efi
Note
It is helpful to set the GRUB_PLATFORMS variable in /etc/portage/make.conf. This will assist GRUB2 in determining what options to use when detecting the proper EFI target. For 32-bit EFI systems use efi-32. For 64-bit use efi-64.
Important
In order for GRUB2 to install properly, the EFI directory must be mounted and the efivars kernel module must be loaded before the grub2-install command will complete successfully.

Alternative: using the default UEFI firmware location

If the system's UEFI firmware fails to find GRUB2's EFI bootloader file, using the default boot loader location should provide a working solution. This circumvents the boot menu managed by efibootmgr and thus offers reduced functionality, but is less error prone. Do do this, verify the EFI partition is mounted at /boot/efi then copy the file grubx64.efi located at /boot/efi/EFI/gentoo/grubx64.efi to /boot/efi/EFI/BOOT/BOOTX64.EFI. This example assumes a 64-bit EFI system, adjust accordingly for 32-bit EFI systems.

Extended features

GRUB2 has many features that make it a very powerful boot loader. It supports:

  • booting from UEFI platforms.
  • booting from GPT partitioned drives without needing a hybrid MBR (hybrid MBR can enabled as needed for compatibility or portability).
  • booting from a btrfs formatted /boot partition.
  • booting directly from a btrfs raid set without needing an initramfs for early mount setup.
  • booting directly from logical volume management (such as LVM2).
  • booting with support for DM-RAID (RAID 0, 1, 4, 5, 6, 9 and 10).
  • booting from encrypted devices (LUKS).

Some specific features are explained in more detail next.

Chainloading

GRUB2 was built with a truly improved chainload mode when compared to GRUB Legacy. To chainload another boot loader, use the chainloader option.

FILE /boot/grub/grub.cfg Chainloading another bootloader
menuentry "Custom Super Bootloader Example" {
     insmod part_msdos
     insmod chain
     chainloader (hd1,1)+1
}

For more information on chainloading, please see the Chainloading sub-page.

Using framebuffer display

To have GRUB2 use a framebuffer graphical display, re-emerge GRUB with the truetype USE flag enabled. This will install a default True Type font as well as a font conversion utility.

root #emerge --ask --newuse sys-boot/grub:2

Proceed to configure the default GRUB2 configuration file located at /etc/default/grub. For example:

FILE /etc/default/grub Framebuffer related settings
# Set resolution and color depth
GRUB_GFXMODE=1366x768x32
 
# Keep resolution when loading the kernel
GRUB_GFXPAYLOAD_LINUX=keep
 
# Set a background image
GRUB_BACKGROUND="/boot/grub/bg.png"
 
# Use a custom font, converted using grub2-mkfont utility
GRUB_FONT="/boot/grub/fonts/roboto.pf2"

In order to find out what display modes the system's graphics card supports, use the following commands on the GRUB2 shell:

(grub)insmod all_video
(grub)videoinfo

Troubleshooting

Most of the issues can be resolved by ensuring that the partition layout is correct. Make sure enough space is available before the first partition of the disk, or optionally make sure that a BIOS boot partition is available. Also verify that /boot/grub/grub.cfg was correctly generated with grub2-mkconfig, or generate one with a custom menu entry.

For more GRUB2 troubleshooting, please refer to the Troubleshooting sub-page.

See also

There are a few specific GRUB2 resources available:

  • In Chainloading the use of GRUB2 to boot other boot loaders is described. This is important to read when dual-booting systems, or when GRUB2 needs to be configured to boot ISO files.
  • In Advanced storage the necessary steps are documented on how to install and use GRUB2 on more advanced storage situations, such as software RAID, logical volumes or encrypted file systems.
  • In Configuration variables an exhaustive list of GRUB2 configuration variables, as used by /etc/default/grub, is documented.
  • In Troubleshooting a list of common GRUB2 errors (with their solutions) is presented.
  • In Hybrid partition table the use of a mixed MBR/GPT setup is documented, as well as how to use such hybrid partition layout with GRUB2.

External resources

For more information, please see: