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*
Once the Linux kernel is up and running, one can view the command line arguments that were in place at boot by simply typing
cat /proc/cmdline at a shell prompt.
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
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
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 (
Most of the boot args take the form of:
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
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. An example would be to use
BOOT_IMAGE=vmlinuz.bak as a boot argument. These environment variables are typically tested for in the initialization scripts to enable or disable a wide range of things.
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.