You can boot either from a floppy or from the hard disk. The installation section in the Getting Started guide tells you how to install so you can boot it the way you want to.
When the computer is booted, the BIOS will do various tests to
check that everything looks all-right, and
will then start the actual booting. It will choose a disk
drive (typically the first floppy drive, if there is a floppy
inserted, otherwise the first hard disk, if one is installed
in the computer) and read its very first sector. This is
called the boot sector; for a hard disk, it is also
called the master boot record (since a hard disk can
contain several partitions, each with their own boot sectors).
The boot sector contains a small program (small enough to fit into one sector) whose responsibility it is to read the actual operating system from the disk and start it. When booting from a floppy disk, the boot sector contains code that just reads the first 512 kB (
When booting from the hard disk, the code in the master boot record will examine the partition table, identify the active partition (the partition that is marked to be bootable), read the boot sector from that partition, and then start the code in that boot sector. The code in the partition's boot sector does what a floppy disk's boot sector does: it will read in the kernel from the partition and start it. The details vary, however, since it is generally not useful to have a separate partition for just the kernel image, so the code in the partition's boot sector can't just read the disk in sequential order, it has to find the sectors whereever the filesystem has put them. There are several ways around this problem, but the most common way is to use LILO. (The details about how to do this are irrelevant for this discussion, however; see the LILO documentation for more information.)
When booting with LILO, it will normally go right ahead and read in and boot the default kernel. It is also possible to configure LILO to be able to boot one of several kernels, or even other operating systems than , and it is possible for the user to choose which kernel or operating system is to be booted at boot time. LILO can be configured so that if one holds down the alt, shift, or ctrl key at boot time (i.e. when LILO is loaded), LILO will ask what is to be booted and not boot the default right away. Alternatively, LILO can be configured so that it will always ask, with an optional timeout that will cause the default kernel to be booted.
The are other boot loaders than LILO. However, since LILO has
been written especially for , it has some features
that are useful and that only it provides, for example the
ability to pass arguments to the kernel at boot time, or
overriding some configuration options built into the kernel.
Hence, it is usually the best choice. Among the alternatives
are bootlin and bootactv
Booting from floppy and booting hard disk have both their advantages, but generally booting from the hard disk is easier, since it avoids the hassle of playing around with floppies. It is also faster. However, it can be more troublesome to install the system so it can boot from the hard disk, so many people will first boot from floppy, then, when the system is otherwise installed and working well, will install LILO and start booting from the hard disk.
After the kernel has been read into the memory, by whatever means, and is started for real, roughly the following things happen:
If the kernel was installed compressed, it will first uncompress itself. (The beginning of the compressed kernel contains a small program that does this.)
If you have a super-VGA card that thinks it
recognizes and that has some special text modes (such as 100
columns by 40 rows), asks you which mode
you want to use. (During the kernel compilation, it is
possible to preset a video mode, so that this is never asked.
This can also be done with LILO.)
After this the kernel checks what other hardware there is (hard disks, floppies, network adapters...), and configures some of its device drivers appropriately; while it does this, it outputs messages about its findings. For example, when I boot, I it looks like this:
(The exact texts are different on different systems, depending on the hardware, the version of being used, and how it has been configured.)
After all this configration business is complete, switches the processor into protected mode. The switch is not visible to the user, but is an important step for the kernel. A big leap for the kernel, a small step for the userkind.
Then the kernel will try to mount the root filesystem. The place---which floppy or partition---is configurable at compilation time, with rdev (see man page), or with LILO (see LILO documentation). The filesystem type is detected automatically. If the mounting of the root filesystem fails, the kernel panics and halts the system (there isn't much one can do, anyway).
After this, the kernel starts the program /etc/init in the background (this will always become process number 1), which does various startup chores. The exact things it does depends on the version of init being used; see the section on init for more information.
The init program then starts a getty for virtual consoles and serial lines as configured in /etc/gettytabs . getty is the program which lets people log in via virtual consoles and serial terminals.
After this, the boot is complete, and the system is up and running normally.