Making your Choice
Introduction
Now that your kernel is configured and compiled and the necessary system
configuration files are filled in correctly, it is time to install a
program that will fire up your kernel when you start the system. Such a
program is called a bootloader.
For , Gentoo Linux provides GRUB and LILO.
Using LILO on the AMD64 architecture is not recommended.
But before we install the bootloader, we inform you how to configure
framebuffer (assuming you want it of course). With framebuffer you can run the
Linux command line with (limited) graphical features (such as using the nice
bootsplash image Gentoo provides).
Optional: Framebuffer
If you have configured your kernel with framebuffer support (or you used
genkernel default kernel configuration), you can activate it by adding a
vga and/or a video statement to your bootloader configuration
file.
First of all, you need to know what type of framebuffer device you're using. If
you use a Gentoo patched kernel tree (such as gentoo-sources) you will
have had the possibility of selecting uvesafb as the VESA driver.
If this is the case, you are using uvesafb and do not need to set
a vga statement. Otherwise you are using the vesafb driver and
need to set the vga statement.
The vga statement controls the resolution and color depth of your
framebuffer screen for vesafb. As stated in
/usr/src/linux/Documentation/fb/vesafb.txt (which gets installed
when you install a kernel source package), you need to pass the VESA number
corresponding to the requested resolution and color depth to it.
The following table lists the available resolutions and color depths and
matches those against the value that you need to pass on to the vga
statement.
| 640x480 |
800x600 |
1024x768 |
1280x1024 |
| 256 |
0x301
0x303
0x305
0x307
| 32k |
0x310
0x313
0x316
0x319
| 64k |
0x311
0x314
0x317
0x31A
| 16M |
0x312
0x315
0x318
0x31B
The video statement controls framebuffer display options. It needs to be
given the framebuffer driver followed by the control statements you wish to
enable. All variables are listed in
/usr/src/linux/Documentation/fb/vesafb.txt. The most-used options
are:
| Control |
Description |
ywrap
Assume that the graphical card can wrap around its memory (i.e. continue at
the beginning when it has approached the end)
mtrr:n
Setup MTRR registers. n can be:
0 - disabled
1 - uncachable
2 - write-back
3 - write-combining
4 - write-through
mode
(uvesafb only)
Set up the resolution, color depth and refresh rate. For instance,
1024x768-32@85 for a resolution of 1024x768, 32 bit color depth and a
refresh rate of 85 Hz.
The result of those two statements could be something like vga=0x318
video=vesafb:mtrr:3,ywrap or
video=uvesafb:mtrr:3,ywrap,1024x768-32@85. Write this setting down; you
will need it shortly.
Now, you should install the elilo bootloader.
Now continue by installing GRUB or LILO.
Default: Using GRUB
Understanding GRUB's terminology
The most critical part of understanding GRUB is getting comfortable with how
GRUB refers to hard drives and partitions. Your Linux partition
/dev/hda1 (for IDE drives) or /dev/sda1 (for
SATA/SCSI drives) will most likely be called (hd0,0) under GRUB.
Notice the parentheses around the hd0,0 - they are required.
Hard drives count from zero rather than "a" and partitions start at zero
rather than one. Be aware too that with the hd devices, only hard drives are
counted, not atapi-ide devices such as cdrom players and burners. Also, the
same construct is used with SCSI drives. (Normally they get higher numbers
than IDE drives except when the BIOS is configured to boot from SCSI devices.)
When you ask the BIOS to boot from a different hard disk (for instance your
primary slave), that harddisk is seen as hd0.
Assuming you have a hard drive on /dev/hda, a cdrom player on
/dev/hdb, a burner on /dev/hdc, a second hard drive
on /dev/hdd and no SCSI hard drive, /dev/hdd7 gets
translated to (hd1,6). It might sound tricky and tricky it is
indeed, but as we will see, GRUB offers a tab completion mechanism
that comes handy for those of you having a lot of hard drives and
partitions and who are a little lost in the GRUB numbering scheme.
Having gotten the feel for that, it is time to install GRUB.
Installing GRUB
To install GRUB, let's first emerge it:
If you are using a non-multilib profile, you should not emerge
grub, but instead you should emerge grub-static.
# emerge grub
Although GRUB is now installed, we still need to write up a
configuration file for it and place GRUB in our MBR so that GRUB automatically
boots your newly created kernel. Create /boot/grub/grub.conf with
nano (or, if applicable, another editor):
# nano -w /boot/grub/grub.conf
Now we are going to write up a grub.conf. Below you'll find two
possible grub.conf for the partitioning example we use in this
guide. We've only extensively commented the first grub.conf. Make
sure you use your kernel image filename and, if appropriate, your
initrd image filename.
-
The first grub.conf is for people who have not used
genkernel to build their kernel
-
The second grub.conf is for people who have used
genkernel to build their kernel
If your root filesystem is JFS, you must add " ro" to the kernel
line since JFS needs to replay its log before it allows read-write mounting.
# Which listing to boot as default. 0 is the first, 1 the second etc.
default 0
# How many seconds to wait before the default listing is booted.
timeout 30
# Nice, fat splash-image to spice things up :)
# Comment out if you don't have a graphics card installed
splashimage=(hd0,0)/boot/grub/splash.xpm.gz
title Gentoo Linux
# Partition where the kernel image (or operating system) is located
root (hd0,0)
kernel /boot/ root=/dev/hda3
title Gentoo Linux (rescue)
# Partition where the kernel image (or operating system) is located
root (hd0,0)
kernel /boot/ root=/dev/hda3 init=/bin/bb
# The next four lines are only if you dualboot with a Windows system.
# In this case, Windows is hosted on /dev/hda6.
title Windows XP
rootnoverify (hd0,5)
makeactive
chainloader +1
default 0
timeout 30
splashimage=(hd0,0)/boot/grub/splash.xpm.gz
title Gentoo Linux
root (hd0,0)
kernel /boot/ root=/dev/ram0 init=/linuxrc ramdisk=8192 real_root=/dev/hda3 udev
initrd /boot/
# Only in case you want to dual-boot
title Windows XP
rootnoverify (hd0,5)
makeactive
chainloader +1
The udev mentioned at the end of the kernel line is needed to work around
a bug in some genkernel versions if you use udev in the first place
(which is the default behaviour).
If you used a different partitioning scheme and/or kernel image, adjust
accordingly. However, make sure that anything that follows a GRUB-device (such
as (hd0,0)) is relative to the mountpoint, not the root. In other
words, (hd0,0)/grub/splash.xpm.gz is in reality
/boot/grub/splash.xpm.gz since (hd0,0) is
/boot.
Besides, if you chose to use a different partitioning scheme and did not put
/boot in a separate partition, the /boot prefix used
in the above code samples is really required. If you followed our
suggested partitioning plan, the /boot prefix it not required, but
a boot symlink makes it work. In short, the above examples should
work whether you defined a separate /boot partition or not.
If you need to pass any additional options to the kernel, simply add
them to the end of the kernel command. We're already passing one option
(root=/dev/hda3 or real_root=/dev/hda3), but you can pass others
as well, such as the video and/or vga statements for framebuffer
as we discussed previously.
If you're using a 2.6.7 or higher kernel and you jumpered your harddrive
because the BIOS can't handle large harddrives you'll need to append
hdx=stroke.
genkernel users should know that their kernels use the same boot options
as is used for the Installation CD. For instance, if you have SCSI devices, you
should add doscsi as kernel option.
Now save the grub.conf file and exit. You still need to install
GRUB in the MBR (Master Boot Record) so that GRUB is automatically executed when
you boot your system.
The GRUB developers recommend the use of grub-install. However, if for
some reason grub-install fails to work correctly you still have the
option to manually install GRUB.
Continue with Default: Setting up GRUB using
grub-install or Alternative: Setting up
GRUB using manual instructions.
Default: Setting up GRUB using grub-install
To install GRUB you will need to issue the grub-install command.
However, grub-install won't work off-the-shelf since we are inside a
chrooted environment. We need to create /etc/mtab which lists all
mounted filesystems. Fortunately, there is an easy way to accomplish this -
just copy over /proc/mounts to /etc/mtab, excluding
the rootfs line if you haven't created a separate boot partition. The
following command will work in both cases:
# grep -v rootfs /proc/mounts > /etc/mtab
Now we can install GRUB using grub-install:
# grub-install --no-floppy /dev/hda
If you have more questions regarding GRUB, please consult the GRUB FAQ or the
GRUB Manual.
Continue with Rebooting the System.
Alternative: Setting up GRUB using manual instructions
To start configuring GRUB, you type in grub. You'll be presented
with the grub> grub command-line prompt. Now, you need to type
in the right commands to install the GRUB boot record onto your hard drive.
# grub --no-floppy
If your system does not have any floppy drives, add the --no-floppy
option to the above command to prevent grub from probing the (non-existing)
floppy drives.
In the example configuration we want to install GRUB so that it reads its
information from the boot partition , and
installs the GRUB boot record on the hard drive's MBR (master boot record) so
that the first thing we see when we turn on the computer is the GRUB prompt. Of
course, if you haven't followed the example configuration during the
installation, change the commands accordingly.
The tab completion mechanism of GRUB can be used from within GRUB.
For instance, if you type in "root (" followed by a TAB, you will
be presented with a list of devices (such as hd0). If you
type in "root (hd0," followed by a TAB, you will receive a list
of available partitions to choose from (such as hd0,0).
By using the tab completion, setting up GRUB should be not that hard.
Now go on, configure GRUB, shall we? :-)
grub> root (hd0,0) (Specify where your /boot partition resides)
grub> setup (hd0) (Install GRUB in the MBR)
grub> quit (Exit the GRUB shell)
If you want to install GRUB in a certain partition instead of the MBR,
you have to alter the setup command so it points to the right
partition. For instance, if you want GRUB installed in
/dev/hda3, then the command becomes setup (hd0,2).
Few users however want to do this.
If you have more questions regarding GRUB, please consult the GRUB FAQ or the GRUB Manual.
Continue with Rebooting the System.
Alternative: Using LILO
Installing LILO
Using LILO on the AMD64 architecture is not recommended.
LILO, the LInuxLOader, is the tried and true workhorse of Linux
bootloaders. However, it lacks some features that GRUB has (which is
also the reason why GRUB is currently gaining popularity). The reason
why LILO is still used is that, on some systems, GRUB doesn't work and
LILO does. Of course, it is also used because some people know LILO and
want to stick with it. Either way, Gentoo supports both, and apparently
you have chosen to use LILO.
Installing LILO is a breeze; just use emerge.
# emerge lilo
Configuring LILO
To configure LILO, you must create /etc/lilo.conf. Fire up
your favorite editor (in this handbook we use nano for
consistency) and create the file.
# nano -w /etc/lilo.conf
Some sections ago we have asked you to remember the kernel-image name
you have created. In the next example lilo.conf we use the
example partitioning scheme. There are two separate parts:
-
One for those who have not used genkernel to build their kernel
-
One for those who have used genkernel to build their kernel
Make sure you use your kernel image filename and, if appropriate,
your initrd image filename.
If your root filesystem is JFS, you must add a append="ro"
line after each boot item since JFS needs to replay its log before it allows
read-write mounting.
boot=/dev/hda # Install LILO in the MBR
prompt # Give the user the chance to select another section
timeout=50 # Wait 5 (five) seconds before booting the default section
default=gentoo # When the timeout has passed, boot the "gentoo" section
# For non-genkernel users
image=/boot/
label=gentoo # Name we give to this section
read-only # Start with a read-only root. Do not alter!
root=/dev/hda3 # Location of the root filesystem
image=/boot/
label=gentoo.rescue # Name we give to this section
read-only # Start with a read-only root. Do not alter!
root=/dev/hda3 # Location of the root filesystem
append="init=/bin/bb" # Launch the Gentoo static rescue shell
# For genkernel users
image=/boot/
label=gentoo
read-only
root=/dev/ram0
append="init=/linuxrc ramdisk=8192 real_root=/dev/hda3 udev"
initrd=/boot/
# The next two lines are only if you dualboot with a Windows system.
# In this case, Windows is hosted on /dev/hda6.
other=/dev/hda6
label=windows
The udev mentioned at the end of the append line is needed to work around
a bug in some genkernel versions if you use udev in the first place
(which is the default behaviour).
If you use a different partitioning scheme and/or kernel image, adjust
accordingly.
If you need to pass any additional options to the kernel, add an
append statement to the section. As an example, we add the
video statement to enable framebuffer:
image=/boot/
label=gentoo
read-only
root=/dev/hda3
append="video=vesafb:mtrr,ywrap,1024x768-32@85"
If you're using a 2.6.7 or higher kernel and you jumpered your harddrive
because the BIOS can't handle large harddrives you'll need to append
hdx=stroke.
genkernel users should know that their kernels use the same boot options
as is used for the Installation CD. For instance, if you have SCSI devices, you
should add doscsi as kernel option.
Now save the file and exit. To finish up, you have to run /sbin/lilo so
LILO can apply the /etc/lilo.conf to your system (i.e. install
itself on the disk). Keep in mind that you'll also have to run
/sbin/lilo every time you install a new kernel or make any changes to
the menu.
# /sbin/lilo
If you have more questions regarding LILO, please consult its wikipedia page.
You can now continue with Rebooting the System.
Default: Installing elilo
On the IA64 platform, the boot loader is called elilo. You may need to emerge
it on your machine first.
# emerge elilo
You can find the configuration file at /etc/elilo.conf and a
sample file in the typical docs dir
/usr/share/doc/elilo-<ver>/. Here is another sample
configuration:
boot=/dev/sda1
delay=30
timeout=50
default=Gentoo
append="console=ttyS0,9600"
prompt
image=/vmlinuz
label=Gentoo
root=/dev/sda2
read-only
image=/vmlinuz.old
label=Gentoo.old
root=/dev/sda2
read-only
The boot line tells elilo the location of the boot partition (in this
case, /dev/sda1). The delay line sets the number of
10th of seconds before automatically booting the default when in
non-interactive mode. The timeout line is just like the delay line but
for interactive mode. The default line sets the default kernel entry
(which is defined below). The append line adds extra options to the
kernel command line. The prompt sets the default elilo behavior to
interactive.
The sections that start with image define different bootable images.
Each image has a nice label, a root filesystem, and will only
mount the root filesystem read-only.
When configuration is done, just run elilo --efiboot. The
--efiboot option adds a menu entry for Gentoo Linux to the EFI Boot
Manager.
# elilo --efiboot
Now continue with Rebooting the System.