LPI Linux Certification in a Nutshell (8 page)

The boot loader

This is a two-stage program intended to find and
load a kernel. It’s a two-stage operation because the boot sector
of the disk is too small to hold the entire boot loader program.
The code located in the boot sector is compact because its only
function is to launch the second stage, which is the interactive
portion. The first stage resides in the MBR or first boot
partition of the hard disk. This is the code that is started at
boot time by the system BIOS. It locates and launches a second,
larger stage of the boot loader that resides elsewhere on disk.
The second stage offers a user prompt to allow boot-time and
kernel image selection options, finds the kernel, loads it into
memory, and launches it.

The lilo command

Also called the
map installer
, the
lilo
command is used to install and configure
the LILO boot loader. The command reads a
configuration file that describes where to find
kernel images, video information, the default boot disk, and so
on. It encodes this information along with physical disk
information and writes it in files for use by the boot
loader.

When the system BIOS launches, LILO presents you with the
following prompt:

LILO:

The
LILO
prompt is designed
to allow you to select from multiple kernels or operating systems
installed on the computer and to pass parameters to the kernel when it
is loaded. Pressing the Tab key at the LILO prompt yields a list of
available kernel images. One of the listed images will be the default
as designated by an asterisk next to the name:

LILO:

linux*    linux_586_smp   experimental

Under many circumstances, you won’t need to select a kernel at
boot time because LILO will boot the kernel configured as the default
during the install process. However, if you later create a new kernel,
have special hardware issues, or are operating your system in a
dual-boot configuration, you may need to use some of LILO’s options to
load the kernel or operating system you desire.

Before any boot sequence can complete from your hard disk, the
boot loader and associated information must be installed by the LILO
map installer utility. The
lilo
command writes
the portion of LILO that resides to the MBR, customized for your
particular system. Your installation program creates a correct MBR,
but you’ll have to repeat the command manually if you build a new
kernel yourself.

During installation, LILO can be placed either in the
boot sector of the disk or in your root partition. If the system is
intended as a Linux-only system, you won’t need to worry about other
boot loaders, and LILO can safely be placed into the boot sector.
However, if you’re running another operating system you should place
its boot loader in the boot sector. Multiple-boot and multiple-OS
configurations are beyond the scope of the LPIC Level 1 exams.

GRUB refers to disk devices as follows:

(
x
d
n
[,
m
])

The
x
d
in this example will be either
fd
or
hd
—
floppy disk
or
hard
disk
, respectively. The
n
refers
to the number of the disk as seen by the BIOS, starting at
0
. The optional
,
m
denotes the
partition number, also starting at
0
.

The following are examples of valid GRUB device names:

Note that GRUB does not distinguish between IDE and SCSI/SATA
disks. It refers only to the order of the disks as seen by the BIOS,
which means that the device number that GRUB uses for a given disk
will change on a system with both IDE and SCSI/SATA if the boot order
is changed in the BIOS.

The simplest way to install GRUB is to use the
grub-install
script.

For example, to install GRUB on the master boot record of the
first hard drive in a system, invoke
grub-install
as follows:

#
grub-install '(hd0)'

grub-install
looks for a device map file
(
/boot/grub/device.map
by default) to determine
the mapping from BIOS drives to Linux devices. If this file does not
exist, it will attempt to guess what devices exist on the system and
how they should be mapped to BIOS drives. If
grub-install
guesses incorrectly, just edit
/boot/grub/device.map
and rerun
grub-install
.

The device map file contains any number of lines in this
format:

(
disk
) /dev/
device

So, for example, on a system with a floppy and a single SCSI
disk, the file would look like this:

(fd0)   /dev/fd0
(hd0)   /dev/sda

GRUB can also be installed using the
grub
command. The
grub-install
example shown earlier
could also have been done as follows, assuming
/boot
is on the first partition of the first hard
disk:

#
grub
grub>
root (hd0,0)
grub>
setup (hd0)

If there is no configuration file (or the configuration file
does not specify a kernel to load), when GRUB loads it will display a
prompt that looks like this:

grub>

GRUB expects a certain sequence of commands to boot a Linux
kernel. They are as follows:

For example, the following sequence would boot a stock Red Hat
8.0 system with
/boot
on
/dev/hda1
and
/
on
/dev/hda2
:

grub>
root (hd0,0)
grub>
kernel /vmlinuz-2.4.18-14 ro root=/dev/hda2
grub>
initrd /initrd-2.4.18-14.img
grub>
boot

GRUB can be configured to boot into a graphical menu, allowing
the user to bypass the GRUB shell entirely. To display this menu, GRUB
needs a specific configuration file,
/boot/grub/menu.lst
.

The configuration file defines various menu options along with
the commands required to boot each option. The earlier example of
booting a stock Red Hat Fedora 8.0 system could have been accomplished
with the following configuration file:

default=0
timeout=3
title Red Hat Linux (2.4.18-14)
root (hd0,0)
kernel /vmlinuz-2.4.18-14 ro root=/dev/hda2
initrd /initrd-2.4.18-14.img

-C config _ file

Read the
config _ file
file
instead of the default
/etc/lilo.conf
.

-m map _ file

Write
map _ file
in place of the
default as specified in the configuration file.

-q

Query the current configuration.

-v

Increase verbosity.

Example 5-1. Sample /etc/lilo.conf file

boot = /dev/hda
timeout = 50
prompt
read-only
map = /boot/map
install = /boot/boot.b
image=/boot/bzImage-2.6.0
label=test-2.6.0
root=/dev/hda1

boot


Sets the name of the hard disk partition device that
contains the boot sector. For PCs with IDE disk drives, the
devices will be
/dev/hda
,
/dev/hdb
, and so on.

timeout


Sets the timeout in tenths of a second (deciseconds)
for any user input from the keyboard. To enable an
unattended reboot, this parameter is required if the
prompt
directive is
used.

prompt


Sets the boot loader to prompt the user. This behavior
can be stimulated without the prompt directive if the user
holds down the Shift, Ctrl, or Alt key when LILO
starts.

read-only


Sets the root filesystem to initially be mounted
read-only. Typically, the system startup procedure will
remount it later as read/write.

map


Sets the location of the map file, which defaults to
/boot/map
.

install


Sets the file to install as the new boot sector, which
defaults to
/boot/boot.b
.

image


Sets the kernel image to offer for boot. It points to
a specific kernel file. Multiple image lines may be used to
configure LILO to boot multiple kernels and operating
systems.

label


Sets the optional label parameter to be used after an
image line and offers a label for that image. This label can
be anything you choose and generally describes the kernel
image. Examples include
linux
and
smp
for a multiprocessing
kernel.

root


Sets the devices to be mounted as root for the
specified image (used after each image line).