Next Previous Contents

## 2. Background Information and Standard Installation

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.

## 2.1 Where Should I Install 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.

## 2.2 How Should I Configure my IDE Hard Drives?

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.

## 2.3 How Can I Interact at Boot Time?

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).
- A number: by specifying a number on the kernel command line, you instruct init to enter a specific run-level (the default is usually 3 or 2, according to the distribution you chose). Refer to the init documentation, to `/etc/inittab` and to `/etc/rc*.d` to probe further.

## 2.4 How Can I Uninstall Lilo?

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.

## 2.5 How to make a ram disk?

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:

- make a ram disk image with /mkinitrd
- modify `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`.

Next Previous Contents