This section gives some examples of software that can be used to pass kernel boot-time arguments to the kernel itself. It also gives you an idea of how the arguments are processed, what limitations there are on the boot args, and how they filter down to each appropriate device that they are intended for.
It is important to note that spaces should not be used in a boot argument, but only between separate arguments. A list of values that are for a single argument are to be separated with a comma between the values, and again without any spaces. See the following examples below.
ether=9,0x300,0xd0000,0xd4000,eth0 root=/dev/hda1 *RIGHT*
ether = 9, 0x300, 0xd0000, 0xd4000, eth0 root = /dev/hda1 *WRONG*
The LILO program (LInux LOader) written by Werner Almesberger is the most commonly used. It has the ability to boot various kernels, and stores the configuration information in a plain text file. Most distributions ship with LILO as the default boot-loader. LILO can boot DOS, OS/2, Linux, FreeBSD, etc. without any difficulties, and is quite flexible.
A typical configuration will have LILO stop and print LILO:
shortly after you turn on your computer. It will then wait for
a few seconds for any optional input from the user, and failing
that it will then boot the default system. Typical system labels
that people use in the LILO configuration files are linux
and backup and msdos. If you want to type in a boot
argument, you type it in here, after typing in the system label
that you want LILO to boot from, as shown in the example below.
LILO: linux root=/dev/hda1
LILO comes with excellent documentation, and for the purposes
of boot args discussed here, the LILO append= command
is of significant importance when one wants to add a boot time
argument as a permanent addition to the LILO config file.
You simply add something like append = "foo=bar" to the
/etc/lilo.conf file. It can either be added at the top
of the config file, making it apply to all sections, or to a
single system section by adding it inside an image= section.
Please see the LILO documentation for a more complete description.
The other commonly used Linux loader is `LoadLin' which is a DOS program that has the capability to launch a Linux kernel from the DOS prompt (with boot-args) assuming that certain resources are available. This is good for people that use DOS and want to launch into Linux from DOS.
It is also very useful if you have certain hardware which relies
on the supplied DOS driver to put the hardware into a known
state. A common example is `SoundBlaster Compatible' sound
cards that require the DOS driver to set a few proprietary
registers to put the card into a SB compatible mode. Booting
DOS with the supplied driver, and then loading Linux from
the DOS prompt with LOADLIN.EXE avoids the reset of
the card that
happens if one rebooted instead. Thus the card is left in a
SB compatible mode and hence is useable under Linux.
There are also other programs that can be used to boot Linux.
For a complete list, please look at the programs available
on your local Linux ftp mirror, under system/Linux-boot/.
There are a few of the kernel boot parameters that have their
default values stored in various bytes in the kernel image itself.
There is a utility called rdev that is installed on most
systems that knows where these values are, and how to change them.
It can also change things that have no kernel boot argument
equivalent, such as the default video mode used.
The rdev utility is usually also aliased to swapdev, ramsize, vidmode and rootflags. These are the five things that rdev can change, those being the root device, the swap device, the RAM disk parameters, the default video mode, and the readonly/readwrite setting of root device.
More information on rdev can be found by typing
rdev -h or by reading the supplied man page (man rdev).
Most of the boot args take the form of:
name[=value_1][,value_2]...[,value_11]
where `name' is a unique keyword that is used to identify what part of the kernel the associated values (if any) are to be given to. Multiple boot args are just a space separated list of the above format. Note the limit of 11 is real, as the present code only handles 11 comma separated parameters per keyword. (However, you can re-use the same keyword with up to an additional 11 parameters in unusually complicated situations, assuming the setup function supports it.) Also note that the kernel splits the list into a maximum of ten integer arguments, and a following string, so you can't really supply 11 integers unless you convert the 11th arg from a string to an int in the driver itself.
Most of the sorting goes on in linux/init/main.c.
First, the kernel checks to see if the argument is any of
the special arguments `root=', `ro', `rw', or `debug'.
The meaning of these special arguments is described further
on in the document.
Then it walks a list of setup functions (contained in the
bootsetups array) to see if the specified
argument string (such as `foo') has been associated with a
setup function (foo_setup()) for a particular
device or part of the kernel. If you
passed the kernel the line foo=3,4,5,6,bar then the
kernel would search the bootsetups array to see if
`foo' was registered. If it was, then it would call the
setup function associated with `foo' (foo_setup())
and hand it the integer arguments
3, 4, 5 and 6 as given on the kernel command line, and
also hand it the string argument bar.
Anything of the form `foo=bar' that is not accepted as a setup function as described above is then interpreted as an environment variable to be set. A (useless?) example would be to use `TERM=vt100' as a boot argument.
Any remaining arguments that were not picked up by the
kernel and were not interpreted as environment variables
are then passed onto process one, which is usually the
init program. The most common argument that is passed to
the init process is the word single which instructs
init to boot the computer in single user mode, and not
launch all the usual daemons. Check the manual page for the
version of init installed on your system to see what
arguments it accepts.