Configuring GRUB Legacy

When you use the GRUB Legacy interactive menu, you need to tell it what options to show using special GRUB menu commands.

The GRUB Legacy system stores the menu commands in a standard text configuration file, called menu.lst. This file is stored in the /boot/grub folder (while not a requirement, some Linux distributions create a separate /boot partition on the hard drive). Red Hat–derived Linux distributions (such as CentOS and Fedora) use grub.conf instead of menu.lst for the configuration file.

The GRUB Legacy configuration file consists of two sections:

• Global definitions
• Operating system boot definitions

The global definitions section defines commands that control the overall operation of the GRUB Legacy boot menu. The global definitions must appear first in the configuration file. There are only a handful of global settings that you can make; Table 5.1 shows these settings.

For GRUB Legacy, to define a value for a command, you list the value as a command-line parameter:

default 0
timeout 10
color white/blue yellow/blue

The color command defines the color scheme for the menu. The first pair defines the foreground/background pair for normal menu entries, while the second pair defines the foreground/background pair for the selected menu entry.

After the global definitions, you place definitions for the individual operating systems that are installed on the system. Each operating system should have its own definition section. There are a lot of boot definition settings that you can use to customize how the bootloader finds the operating system kernel file. Fortunately, only a few commands are required to define the operating system. The ones to remember are listed here:

• title – The first line for each boot definition section; this is what appears in the boot menu.
• root – Defines the disk and partition where the GRUB /boot folder partition is on the system.
• kernel – Defines the kernel image file stored in the /boot folder to load.
• initrd – Defines the initial RAM disk file, which contains drivers necessary for the kernel to interact with the system hardware.
• rootnoverify – Defines non-Linux boot partitions, such as Windows.

The root command defines the hard drive and partition that contains the /boot folder for GRUB Legacy. Unfortunately, GRUB Legacy uses a somewhat odd way of referencing those values:

(hddrive, partition)

Also, unfortunately, GRUB Legacy doesn’t refer to hard drives the way Linux does; it uses a number system to reference both disks and partitions, starting at 0 instead of 1. For example, to reference the first partition on the first hard drive on the system, you’d use (hd0,0). To reference the second partition on the first hard drive, you’d use (hd0,1).

The initrd command is another important feature in GRUB Legacy. It helps solve a problem that arises when using specialized hardware or filesystems as the root drive. The initrd command defines a file that’s mounted by the kernel at boot time as a RAM disk, also called the initrd. The kernel can then load modules from the initrd RAM disk, which then allows it to access hardware or filesystems not compiled into the kernel itself.

Listing 5.2 shows a sample GRUB configuration file that defines both a Windows and a Linux partition for booting.

Listing 5.2: Sample GRUB Legacy configuration file

default 0
timeout 10
color white/blue yellow/blue

title CentOS Linux
root (hd1,0)
kernel (hd1,0)/boot/vmlinuz
initrd /boot/initrd

title Windows
rootnoverify (hd0,0)

This example shows two boot options—one for a CentOS Linux system and one for a Windows system. The CentOS system is installed on the first partition of the second hard drive, while the Windows system is installed on the first partition of the first hard drive. The Linux boot selection specifies the kernel file to load as well as the initrd image file to load into memory.

Installing GRUB Legacy

Once you build the GRUB Legacy configuration file, you must install the GRUB Legacy program in the MBR. The command to do this is grub-install.

The grub-install command uses a single parameter—the partition on which to install GRUB. You can specify the partition using either Linux or GRUB Legacy format. For example, to use Linux format you’d use

# grub-install /dev/sda

to install GRUB on the MBR of the first hard drive. To use GRUB Legacy format, you must enclose the hard drive format in quotes:

# grub-install '(hd0)'

If you’re using the chainloading method and prefer to install a copy of GRUB Legacy on the boot sector of a partition instead of to the MBR of a hard drive, you must specify the partition, again using either Linux or GRUB format:

# grub-install /dev/sda1
# grub-install 'hd(0,0)'

You don’t need to reinstall GRUB Legacy in the MBR after making changes to the configuration file. GRUB Legacy reads the configuration file each time it runs.

Interacting with GRUB Legacy

When you boot a system that uses the GRUB Legacy bootloader, you’ll see a menu that shows the boot options you defined in the configuration file. If you wait for the time-out to expire, the default boot option will process. Alternatively, you can use the arrow keys to select one of the boot options and then press the Enter key to select it.

You can also edit boot options on the fly from the GRUB menu. First, arrow to the boot option you want to modify and then press the E key. Use the arrow key to move the cursor to the line you need to modify and then press the E key to edit it. Press the B key to boot the system using the new values. You can also press the C key at any time to enter an interactive shell mode, allowing you to submit commands on the fly.

Configuring GRUB2

There are also a few changes to the commands used in GRUB2. For example, instead of the title command, GRUB2 uses the menuentry command, and you must also enclose each individual boot section with braces immediately following the menuentry command. Here’s an example of a sample GRUB2 configuration file:

menuentry "CentOS Linux" {
   set root=(hd1,1)
   linux /boot/vmlinuz
   initrd /initrd
}
menuentry"Windows" {
   set root=(hd0,1)
}

Notice that GRUB2 uses the set command to assign values to the root keyword and an equal sign to assign the device. GRUB2 utilizes environment variables to configure settings instead of commands.

GRUB2 also changes the numbering system for partitions. While it still uses 0 for the first hard drive, the first partition is set to 1. So to define the /boot folder on the first partition of the first hard drive, you now need to use

set root=hd(0,1)

In addition, notice that the rootnoverify and kernel commands are not used in GRUB2. Non-Linux boot options are now defined the same as Linux boot options using the root environment variable, and you define the kernel location using the linux command.

The configuration process for GRUB2 is also different. While the /boot/grub/grub.cfg file is the configuration file that GRUB2 uses, you should never modify that file. Instead, there are separate configuration files stored in the /etc/grub.d folder. This allows you (or the system) to create individual configuration files for each boot option installed on your system (for example, one configuration file for booting Linux and another for booting Windows).

For global commands, use the /etc/default/grub configuration file. The format for some of the global commands has changed from the GRUB Legacy commands, such as GRUB_TIMEOUT instead of just timeout.

Most Linux distributions generate the new grub.cfg configuration file automatically after certain events, such as upgrading the kernel. Usually the distribution will keep a boot option pointing to the old kernel file just in case the new one fails.

Installing GRUB2

Unlike GRUB Legacy, you don’t need to install GRUB2; you simply rebuild the main installation file by running the grub-mkconfig program.

The grub-mkconfig program reads configuration files stored in the /etc/grub.d folder and assembles the commands into the single grub.cfg configuration file.

You can update the configuration file manually by running the grub-mkconfig command:

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

Notice that you must redirect the output of the grub-mkconfig program to the grub.cfg configuration file. By default the grub-mkconfig program just outputs the new configuration file commands to standard output.

Interacting with GRUB2

The GRUB2 bootloader produces a boot menu similar to the GRUB Legacy method. You can use arrow keys to switch between boot options, the E key to edit a boot entry, or the C key to bring up the GRUB2 command line to submit interactive boot commands. Figure 5.1 shows editing an entry in the GRUB2 boot menu on a CentOS system.

Selecting Previous Kernels at Boot

One of the biggest culprits to a failed boot is when you upgrade the Linux kernel, either on your own or from a packaged distribution upgrade. When you install a new kernel file, it’s always a good idea to leave the old kernel file in place and create an additional entry in the GRUB boot menu to point to the new kernel.

By creating multiple kernel entries in the GRUB boot menu, you can select which kernel version to boot. If the new kernel fails to boot properly, you can reboot and select the older kernel version.

Most Linux distributions do this automatically when adding a new kernel, keeping the most recent older kernel available in the boot menu, as shown in Figure 5.2.

Single-User Mode

At times you may need to perform some type of system maintenance, such as add a new hardware module or library file to get the system to boot properly. In these situations, you want the system to boot up without allowing multiple users to connect, especially in a server environment. This is called single-user mode.

The GRUB menu allows you to start the system in single-user mode by adding the single command to the linux line in the boot menu commands. To get there, press the E key on the boot option in the GRUB boot menu.

When you add the single command, the system will boot into runlevel 1, which creates a single login for the root user account. Once you log in as the root user account, you can modify the appropriate modules, init scripts, or GRUB boot menu options necessary to get your system started correctly.

Passing Kernel Parameters

Besides the single-user mode trick, you can add other kernel parameters to the linux command in the GRUB boot menu. The kernel accepts parameters that alter the hardware modules it activates or the hardware settings it looks for with specific devices (this is especially true for sound and network cards). You can specify the different hardware settings as additional parameters to the kernel in the linux command and then boot from that entry in the GRUB menu.

Using a Rescue Disk

Many Linux distributions provide a rescue disk for when fatal disk errors occur. The rescue disk usually boots either from the CD drive or as a USB stick and loads a small Linux system into memory. Since the Linux system runs entirely in memory, it can leave all of the workstation hard drives free for examination and repair. From the system command-line prompt, you can perform some diagnostic and repair tasks on your system hard drives.

The tool of choice for checking and fixing hard drive errors is the fsck command. The fsck command isn’t a program; it’s an alias for a family of commands specific to different types of filesystems (such as ext2, ext3, and ext4). You need to run the fsck command against the device name of the partition that contains the root directory of your Linux system. For example, if the root directory is on the /dev/sda1 partition, you’d run the following command:

# fsck /dev/sda1

The fsck command will examine the inode table along with the file blocks stored on the hard drive and attempt to reconcile them. If any errors occur, you will be prompted on whether to repair them or not. If there are a lot of errors on the partition, you can add the -y parameter to automatically answer yes to all the repair questions. After a successful repair, it’s a good idea to run the fsck command once more to ensure that all errors have been found and corrected. Continue running the fsck command until you get a clean run with no errors.

Mounting a Root Drive

When the fsck repair is complete, you can test the repaired partition by mounting it into the virtual directory created in memory. Just use the mount command to mount it to an available mount directory:

# mount /dev/sda1 /media

You can examine the filesystem stored in the partition to ensure that it’s not corrupt. Before rebooting, you should unmount the partition using the umount command:

# umount /dev/sda1

After successfully unmounting the partition, you can reboot your Linux system using the standard bootloader and attempt to boot using the standard kernel and runlevels.