The LInux LOader has been the standard bootloader for Linux. It is well-documented and widely used, so why even bother with another bootloader?

The GRUB bootloader is interactive and supports a BASH-like command line which features autocomplete making the use of a "universal" boot floppy possible. GRUB understand filesystems and can search them for files, helping you find file names and boot unfamiliar systems. GRUB reads its configuration from a text file at each boot, so it doesn't have to be re-run with each configuration change. How often have you forgotten to do that with LILO? GRUB is network-aware and can be compiled to run with network support like bootp, rarp, DHCP and tftp. GRUB can hide and unhide partitions, allowing multi-booting of normally conflicting operating systems. Unlike most bootloaders that know the kernel location only from a map, GRUB can load a kernel from anywhere it can 'see' on the disk without knowing where the kernel is beforehand

GRUB device names are not like the Linux device names with which you are familiar. This is the biggest hurdle in understanding GRUB, so we'll address this first.

All the device names are enclosed in parentheses.

There are two device names: (fd) for floppy drives and (hd) for hard drives (yes, both IDE and SCSI).

Drives are numbered beginning with 0. The developers of GRUB claim a desire to "fix" this in future releases so that the first device is numbered 1 instead of 0, but we won't be holding our breath. Hard drives are numbered sequentially in the order that the are detected by the BIOS. Changing the BIOS boot order will change the GRUB device name, so be careful.

Partitions within a drive are numbered sequentially beginning with 0. BSD slices are handled in a slightly different manner and you should consult the GRUB docs for BSD specifics. Partition numbers of extended partitions are always counted from 4.

Let's look at an example system that has a single floppy drive, an IDE drive connected as the primary master (three partitions - VFAT, EXT2 and Linux swap), an IDE drive at the secondary master (two partitions - vfat and ext2), as well as a SCSI drive that is not configured to be bootable (with a BSD installation).

Here's a table of how each partition would be named in LILO and in GRUB

LILO           GRUB

/dev/fd0       (fd0)
/dev/hda1      (hd0,0)
/dev/hda2      (hd0,1)
/dev/hda3      (hd0,2)
/dev/hdc1      (hd1,0)
/dev/hdc2      (hd1,1)
/dev/scd0      (hd2,0)

Let's edit Entry 6 first. On our example system, Windows98 is installed on the first partition of the first disk. Mounting the floppy and using our favorite text editor, we now have the following:

title Windows 98ME

root (hd0,0)

makeactive

# Chainload from the first sector
chainloader +1

# If you want DOS, but Windows NT is installed, then use:
# chainloader /bootsect.dos

root (hd0,1)

kernel /boot/vmlinuz-2.4.3-20mdk root=/dev/hda2 read-only

# Don't forget that some distributions rely on an initial ramdisk:
initrd /boot/ initrd-2.4.3-20mdk.img

title RedHat 7.1
root (hd1,1)
kernel /boot/vmlinuz root=/dev/hdc2 read-only

# Note that we used the Linux name for the root partition.

# Don't forget that some distributions rely on an initial ramdisk:
#initrd /boot/initrd

 # Let's fool DOS into thinking it's alone in the world by hiding Windows.
 hide (hd0,0)
 unhide (hd1,0)

 # Now we make DOS think it's on the first drive so it's happy.
 map (hd0) (hd1)
 map (hd1) (hd0)

 # Now we can begin to mount the root partition and
 # load the chainloader that loads the Windows OS.

 # Our root is the first partition of the first drive (since we switched them).
 root (hd1,0)

 # Here, we could use the rootnoverify which will set the root partition, but not
 # mount it. This is especially useful if the kernel is somewhere on the disk
 # that GRUB can't see, but it can see the chainloader.
 # DOS and Windows seem to work well both ways.

 # And we make it the active partition.
 makeactive

 # The "+1" tells GRUB to boot the chainloader from the first sector,
 # rather than attempt to load Windows by GRUB itself.
 chainloader +1

 title FreeBSD 4.3

 # Remember, we are using the SCSI drive and BSD does "slices", so the root
 # partition will be "a".
 root (hd2,a) 2

 # We don't call the kernel, but do call the BSD bootloader.
 kernel /boot/loader

You don't need a GRUB menu, but if you want one, it is a simple text file created with any editor (even a Windows/DOS editor if you insist). It's named menu.lst (as in "el"-s-t, not 'one'-s-t — some fonts make this impossible to distinguish) and is kept in /boot/grub. Use the example shown here or in the GRUB docs to create one. If it fails to work, your computer won't crash and your data won't be lost, you'll just have to boot manually and try again.

We have assumed that you are experimenting with GRUB from a boot floppy, but GRUB can happily live in your MBR just as LILO did. Installing is incredibly easy:

# grub-install

does the trick.

If you don't like GRUB and want to return to LILO,

# lilo

If you don't like GRUB and want to return to the Windows bootloader (we can't imagine why, but it's your computer), boot from the Emergency Boot Floppy and run:

a:\fdisk /mbr

grub-install INSTALL_DEVICE

The device name INSTALL_DEVICE is an OS device name or a GRUB device name, e.g, '(hd0)' or /dev/fd0

For the paranoid among us ( and who shouldn't be a little paranoid about computer security), GRUB offers password protection of individual menu items.

To use passwords, first add a line at the beginning of the menu.lst file:

password <mypassword>

where <mypassword> is your password.

For each boot option you wish to password protect, add the command lock to the beginning of that section. Obviously, you want to have lock in the section that boots to the partition that hold menu.lst. However, don't consider password protection to be any kind of real security since anyone could easily bypass this by using their own GRUB boot floppy.

We need to congratulate the developers of GRUB on one thing that sets them apart from many other Open Source projects — the availability of excellent documentation. You access it using info (as in info grub at a shell prompt) instead of using the man page system. The documentation contains detailed explanations of the workings of GRUB including a surfeit of excellent examples as well as a tutorial.

If you're curious as to what is in the initrd (initial ramdisk) file, it's a gzipped filesystem image! Copy it to another location and rename it with a .gz extension. Then, gunzip it and it loses the .gz extension. Mount this file (on /mnt/image in our example) with

# mount -o loop initrd /mnt/image

and you can browse it like any filesystem. For more details, read The Loopback Root Filesystem HOWTO at http://www.linuxdoc.org/HOWTO/mini/Loopback-Root-FS.html#toc2r .

Create a boot floppy from the boot floppy image as described previously and boot your computer from it.

Because the boot floppy has a /boot/grub/menu.lst on it, you will see the supplied boot menu which will not likely be set to any useful defaults for you.

Here we see the menu options. If you highlight the one for GNU/Linux and press Enter, you'll see:

The "e" command allow us to edit each line individually and the "o" command adds a line for us to include our initrd.

Finally, we use the "b" command to boot into our Mandrake 8.0 installation.

Let's try doing the same thing using the GRUB command line, using the "c" command to get there. After seeing a message, we are greeted by the GRUB prompt:

grub>

We set the root partition first, but let's see what command completion will do for us, so type:

grub> root (

and then press the TAB key. We are told:

grub> root ( Possible disks are: fd0 hd0 hd1 hd2

Remember that these are our floppy drive, the primary master IDE drive, the secondary master IDE drive and the SCSI drive, detected by GRUB in their BIOS boot order.

We now type some more:

grub> root (hd0,

and press TAB to see a list of all partitions on the drive.

grub> root (hd0,

Possible Partitions are: Partition num: 0, Filesystem type is fat, partition type 0xc Partition num: 1, Filesystem type is ext2, partition type 0x83 Partition num: 2, Filesystem type is unknown, partition type 0x82

We will complete the entry for partition 1, our GNU/Linux installation and press Enter.

Second, we want to tell GRUB what kernel to boot, but we're not certain of the full name, so we use the find command (since we have mounted the partition using the root command). We'll use the autocomplete function to help us, so type:

grub > kernel /

and press the TAB. It will display the possible completions like the Bash shell. Continue until the full path and name of the kernel are displayed. If you want to add kernel arguments, they follow at the end of this line. Then press Enter.

grub> kernel /boot/vmlinuz-2.4.3-20mdk root=/dev/hda2

Third, we need to load the initrd image so the Linux kernel has the reiserfs module available to it. We do so with the initrd command and use the autocomplete function as before.

grub> initrd /boot/initrd-2.4.3-20mdk.img

And finally, since we are working at the GRUB shell prompt, we give the boot command.

grub> boot

and we soon see . . .

login:

Success!!!

GRUB is a nice bit of kit not only for booting your favorite OS, but also for rescue and recovery work. Simple to use, but uutterly complex in the depth of ssophisticationit offers, you owe it to yourself to check it out.

GNU GRUB http://www.gnu.org/software/grub/grub.html

GRUB HOWTO by Fabio Fracassi http://archive.linuxfromscratch.org/lfs-hints/html/GRUB-Howto.html

This one is good for keyboard key translation examples.

Multiboot with GRUB Mini-HOWTO http://www.linuxdoc.org/HOWTO/mini/Multiboot-with-GRUB.html

We have explored the more common GRUB commands. Here are some others that you may find useful