When Lilo boots the system, it uses BIOS calls to load the Linux kernel off the disk (IDE drive, floppy or whatever). Therefore, the kernel must live in some place that can be accessed by the bios.
At boot time, Lilo is not able to read filesystem data, and any
pathname you put in /etc/lilo.conf is resolved at
installation time (when you invoke /sbin/lilo). Installation
time is when the program builds the tables that list which sectors are
used by the files used to load the operating system. As a consequence,
all of these files must live in a partition that can be accessed by
the BIOS (the files are usually located in the /boot
directory, this means that only the root partition of your Linux
system needs to be accessed via the BIOS).
Another consequence of being BIOS-based is that you must reinstall the loader (i.e., you must reinvoke /sbin/lilo) any time you modify the Lilo setup. Whenever you recompile your kernel and overwrite your old image you must reinstall Lilo.
The boot= directive in /etc/lilo.conf tells Lilo where
it should place its primary boot loader. In general, you can either
specify the master boot record (/dev/hda) or the root
partition of your Linux installation (is usually is /dev/hda1
or /dev/hda2).
If you have another operating system installed in your hard drive, you'd better install Lilo to the root partition instead of the MBR. In this case, you must mark the partition as ``bootable'' using the ``a'' command of fdisk or the ``b'' command of cfdisk. If you don't overwrite the master boot sector you'll find it easier to uninstall Linux and Lilo if needed.
Of course, you always have a way to avoid some "rules" like above. Well,
you may install Lilo to the MBR even if you already have another operating
system installed there. For example, if you installed Windows NT 4.0 as the
first operating system on your machine, then NT's boot loader was placed into
the MBR so you were able to boot NT without problems. After you installed
Linux and chose to install Lilo to the MBR, Lilo rewrote NT's boot loader.
Next time you boot your machine, you won't be able to boot NT. But, that
is no problem. You should edit your /etc/lilo.conf and add a new
entry for NT. Next time you re-boot your system, there will be the new
added NT entry under Lilo menu. The same thing happened when I installed
Windows 2000 instead of Windows NT.
I personally don't use LBA or LARGE settings in the BIOS (but I only run Linux); they are horrible kludges forced on by design deficiencies in the PC world. This requires that the kernel lives in the first 1024 cylinders, but this is not a problem as long as you partition your hard drives and keep root small (as you should do anyways).
If your hard disk already carries another operating system, you won't be able to modify the BIOS settings, or the old system won't work any more. All recent Lilo distribution are able to deal with LBA and LARGE disk settings.
Note that the "linear" keyword in /etc/lilo.conf can
help in dealing with geometry problems. The keyword instructs Lilo to
use linear sector addresses instead of sector/head/cylinder tuples.
Conversion to 3D addresses is delayed to run-time, therefore making
the setup more immune to geometry problems.
If you have more than one hard disk and some of them are only used by Linux and are not involved in the boot process, you can tell your BIOS that they are not installed. Your system will boot more quickly and Linux will autodetect all the disks in no time. I often switch disks in my computers, but I never touch the BIOS configuration.
When you see the Lilo prompt, you can hit the <Tab> key to show the list of possible choices. If Lilo is not configured to be interactive, press and hold the <Alt> or <Shift> key before the ``LILO'' message appears.
If you choose to boot a Linux kernel, you can add command-line arguments after the name of the system you choose. The kernel accepts many command-line arguments. All the arguments are listed in the ``BootPrompt-HOWTO'' by Paul Gortmaker, and I won't replicate it here. A few command line arguments, however, are particularly important and worth describing here:
root=: you can tell the Linux kernel to mount as root
a different partition than the one appearing in /lilo.conf.
For example, my system has a tiny partition hosting a minimal Linux
installation, and I've been able to boot the system after
destroying my root partition by mistake.
init=: version 1.3.43 and newer of the Linux kernel can
execute another command instead of /sbin/init,
as specified on the command line. If you experience bad problems
during the boot process, you can access the bare system by
specifying init=/bin/sh (when you are at the shell
prompt you most likely will need to mount your disks: try
``mount -w -n -o remount /; mount -a'',
and remember to ``umount -a'' before turning off
the computer).
/etc/inittab
and to /etc/rc*.d to probe further.
When Lilo overwrites a boot sector, it saves a backup copy in
/boot/boot.xxyy, where xxyy are the major and minor
numbers of the device, in hex. You can see the major and minor numbers
of your disk or partition by running ``ls -l
/dev//device''. For example, the first sector of
/dev/hda (major 3, minor 0) will be saved in
/boot/boot.0300, installing Lilo on /dev/fd0 creates
/boot/boot.0200 and installing on /dev/sdb3 (major
8, minor 19) creates /boot/boot.0813. Note that Lilo won't
create the file if there is already one so you don't need to care about
the backup copy whenever you reinstall Lilo (for example, after
recompiling your kernel). The backup copies found in /boot/
are always the snapshot of the situation before installing any Lilo.
If you ever need to uninstall Lilo (for example, in the unfortunate
case you need to uninstall Linux), you just need to restore the
original boot sector. If Lilo is installed in /dev/hda, just
do ``dd if=/boot/boot.0300 of=/dev/hda bs=446 count=1''
(I personally just do ``cat /boot/boot.0300 > /dev/hda'',
but this is not safe, as this will restore the original partition table as
well, which you might have modified in the meanwhile). This command is
much easier to run than trying ``fdisk /mbr'' from a DOS
shell: it allows you to cleanly remove Linux from a disk without ever
booting anything but Linux. After removing Lilo remember to run Linux'
fdisk to destroy any Linux partition (DOS' fdisk is unable to remove non-dos partitions).
If you installed Lilo on your root partition (e.g., /dev/hda2),
nothing special needs to be done to uninstall Lilo. Just run Linux'
fdisk to remove Linux partitions from the partition
table. You must also mark the DOS partition as bootable.
Notice: If you find the next section difficult to read, you may
also look for the web page:
http://surfer.nmr.mgh.harvard.edu/partition/ramdisk.html
where you would find the "original" of this contribution ...
by Tony Harris
16 Oct 2000
ram disk eenie-weenie HOWTO
If your root file system is on a device for which your kernel has no
compiled-in driver, you will need to use lilo to load that driver
as a module very early in the boot cycle.
There are only two easy steps:
lilo.conf to point to the image
First, I cd over to /boot:
System.map chain.b module-info-2.2.16-3ext3 System.map-2.2.16-3 initrd-2.2.16-3.img vmlinux-2.2.16-3 System.map-2.2.16-3ext3 vmlinux-2.2.16-3ext3 vmlinuz kernel.h boot.b map vmlinuz-2.2.16-3 bz.2.2.15.juke.Image module-info vmlinuz-2.2.16-3ext3 bzImage-2.2.14 module-info-2.2.16-3
Here you can see that I have a 2.2.16-3 kernel and I have added a
second kernel with ext3 support (vmlinuz-2.2.16-3ext3). There is
already a ram disk image for my first kernel (initrd-2.2.16-3.img)
To make a new image for the second kernel, I type the following (stuff I type is in bold):
boot# mkinitrd initrd-2.2-16-3ext3.img 2.2.16-3ext3
mkinitrd is a shellscript that looks at the modules needed by my
kernel, then makes an ext2 filesystem containing them.
If we look inside the image we see this is the case:
boot# cat initrd-2.2.16-3ext3.img | gunzip > /tmp/myimage
boot# file /tmp/myimage
/tmp/myimage: Linux/i386 ext2 filesystem/
You do not have to look inside your image. Only making the image and
modifying lilo.conf are necessary steps. However, discussion of
the ramdisk image is provided for pedagogic purposes.
In order to look inside, I need to mount the image as though it were a filesystem:
boot# mount /tmp/myimage /mnt/tmp -t ext2 -o loop=/dev/loop3
boot# ls /mnt/tmp
bin dev etc lib linuxrc
boot# find /mnt/tmp
mnt/tmp/
mnt/tmp/lib/
mnt/tmp/lib/aic7xxx.o/
mnt/tmp/bin/
mnt/tmp/bin/sh/
mnt/tmp/bin/insmod/
mnt/tmp/etc/
mnt/tmp/dev/
mnt/tmp/dev/console/
mnt/tmp/dev/null/
mnt/tmp/dev/ram/
mnt/tmp/dev/systty/
mnt/tmp/dev/tty1/
mnt/tmp/dev/tty2/
mnt/tmp/dev/tty3/
mnt/tmp/dev/tty4/
mnt/tmp/linuxrc/
The most important part of this ram disk image is aic7xxx.o,
which is my scsi module.
Finally, I move on to the last step, modifying /etc/lilo.conf:
Here is my entry in lilo.conf that corresponds to the kernel and
image I just created:
image=boot/vmlinuz-2.2.16-3ext3/
label=linux.ext3
initrd=boot/initrd-2.2.16-3ext3.img/
read-only
root=dev/hdb3/
That's it. Run /lilo as root and reboot.
If you have problems, check out the kernel HOWTO. There are a
couple things you need to have covered: you need your kernel modules
compiled and living in /etc/conf.modules.