Linux kernel boot params

Kernel parameters

There are three ways to pass options to the kernel and thus control its behaviour:

1. When building the kernel—in the kernel’s config file. See Kernel#Compilation for details.
2. When starting the kernel—using command line parameters (usually through a boot loader).
3. At runtime—through the files in /proc/sys/ (see sysctl) and /sys/ .

Between the three methods, the configurable options differ in availability, their name and the method in which they are specified. This page only explains the second method (kernel command line parameters) and shows a list of the most used kernel parameters in Arch Linux.

Most parameters are associated with subsystems and work only if the kernel is configured with those subsystems built in. They also depend on the presence of the hardware they are associated with.

Kernel command line parameters either have the format parameter or parameter=value .

Contents

Configuration

Kernel parameters can be set either temporarily by editing the boot entry in the boot loader’s boot selection menu, or permanently by modifying the boot loader’s configuration file.

The following examples add the quiet and splash parameters to Syslinux, systemd-boot, GRUB, GRUB Legacy, LILO, and rEFInd.

Syslinux

• Press Tab when the menu shows up and add them at the end of the string:

Press Enter to boot with these parameters.

• To make the change persistent after reboot, edit /boot/syslinux/syslinux.cfg and add them to the APPEND line:

For more information on configuring Syslinux, see the Syslinux article.

systemd-boot

• Press e when the menu appears and add the parameters to the end of the string:

Press Enter to boot with these parameters.

• To make the change persistent after reboot, edit /boot/loader/entries/arch.conf (assuming you set up your EFI system partition) and add them to the options line:

For more information on configuring systemd-boot, see the systemd-boot article.

• Press e when the menu shows up and add them on the linux line:

Press Ctrl+x to boot with these parameters.

• To make the change persistent after reboot, you could manually edit /boot/grub/grub.cfg with the exact line from above, or if using grub-mkconfig:

Edit /etc/default/grub and append your kernel options between the quotes in the GRUB_CMDLINE_LINUX_DEFAULT line: And then automatically re-generate the grub.cfg file with:

For more information on configuring GRUB, see the GRUB article.

GRUB Legacy

• Press e when the menu shows up and add them on the kernel line:

Press b to boot with these parameters.

• To make the change persistent after reboot, edit /boot/grub/menu.lst and add them to the kernel line, exactly like above.

For more information on configuring GRUB Legacy, see the GRUB Legacy article.

For more information on configuring LILO, see the LILO article.

rEFInd

• Press + , F2 , or Insert on the desired menu entry and press it again on the submenu entry. Add kernel parameters at the end of the string:

Press Enter to boot with these parameters.

• To make the change persistent after reboot, edit /boot/refind_linux.conf and append them between the quotes in all required lines, for example

• If you have disabled auto-detection of OSes in rEFInd and are defining OS stanzas instead in esp/EFI/refind/refind.conf to load your OSes, you can edit it like:

For more information on configuring rEFInd, see the rEFInd article.

EFISTUB

dracut

dracut is capable of embedding the kernel parameters in the initramfs, thus allowing to omit them from the boot loader configuration. See dracut#Kernel command line options.

Hijacking cmdline

Even without access to your bootloader it is possible to change your kernel parameters to enable debugging (if you have root access). This can be accomplished by overwriting /proc/cmdline which stores the kernel parameters. However /proc/cmdline is not writable even as root, so this hack is accomplished by using a bind mount to mask the path.

First create a file containing the desired kernel parameters

Then use a bind mount to overwrite the parameters

The -n option skips adding the mount to /etc/mtab , so it will work even if root is mounted read-only. You can cat /proc/cmdline to confirm that your change was successful.

Parameter list

This list is not comprehensive. For a complete list of all options, please see the kernel documentation.

parameter	Description
init	Run specified binary instead of /sbin/init as init process. The systemd-sysvcompat package symlinks /sbin/init to /usr/lib/systemd/systemd to use systemd. Set it to /bin/sh to boot to the shell.
initrd	Specify the location of the initial ramdisk. For UEFI boot managers and EFISTUB, the path must be specified using backslashes ( \ ) as path separators.
debug	Enable kernel debugging (events log level).
lsm	Set the initialisation order of the Linux security modules, used to enable AppArmor, SELinux or TOMOYO.
maxcpus	Maximum number of processors that an SMP kernel will bring up during bootup.
mem	Force usage of a specific amount of memory to be used.
netdev	Network devices parameters.
nomodeset	Disable Kernel mode setting.
panic	Time before automatic reboot on kernel panic.
resume	Specify a swap device to use when waking from hibernation.
ro	Mount root device read-only on boot (default 1 ).
root	Root filesystem. See init/do_mounts.c for kernel’s supported device name formats. Note that an initramfs with udev supports more name formats.
rootflags	Root filesystem mount options. Useful for setting options that cannot be applied by remounting (i.e. by systemd-remount-fs.service(8) ). For example, the discard option of an XFS root volume.
rw	Mount root device read-write on boot.
systemd.unit	Boot to a specified target.
video	Override framebuffer video defaults.

1 mkinitcpio uses ro as default value when neither rw or ro is set by the boot loader. Boot loaders may set the value to use, for example GRUB uses rw by default (see FS#36275 as a reference).

Источник

The kernel’s command-line parametersВ¶

The following is a consolidated list of the kernel parameters as implemented by the __setup(), core_param() and module_param() macros and sorted into English Dictionary order (defined as ignoring all punctuation and sorting digits before letters in a case insensitive manner), and with descriptions where known.

The kernel parses parameters from the kernel command line up to “–”; if it doesn’t recognize a parameter and it doesn’t contain a ‘.’, the parameter gets passed to init: parameters with ‘=’ go into init’s environment, others are passed as command line arguments to init. Everything after “–” is passed as an argument to init.

Module parameters can be specified in two ways: via the kernel command line with a module name prefix, or via modprobe, e.g.:

Parameters for modules which are built into the kernel need to be specified on the kernel command line. modprobe looks through the kernel command line (/proc/cmdline) and collects module parameters when it loads a module, so the kernel command line can be used for loadable modules too.

Hyphens (dashes) and underscores are equivalent in parameter names, so:

can also be entered as:

Double-quotes can be used to protect spaces in values, e.g.:

cpu lists:В¶

Some kernel parameters take a list of CPUs as a value, e.g. isolcpus, nohz_full, irqaffinity, rcu_nocbs. The format of this list is:

Note that for the special case of a range one can split the range into equal sized groups and for each group use some amount from the beginning of that group:

For example one can add to the command line following parameter:

where the final item represents CPUs 100,101,125,126,150,151.

This document may not be entirely up to date and comprehensive. The command “modinfo -p $” shows a current list of all parameters of a loadable module. Loadable modules, after being loaded into the running kernel, also reveal their parameters in /sys/module/$/parameters/. Some of these parameters may be changed at runtime by the command echo -n $ > /sys/module/$/parameters/$ .

The parameters listed below are only valid if certain kernel build options were enabled and if respective hardware is present. The text in square brackets at the beginning of each description states the restrictions within which a parameter is applicable:

In addition, the following text indicates that the option:

Parameters denoted with BOOT are actually interpreted by the boot loader, and have no meaning to the kernel directly. Do not modify the syntax of boot loader parameters without extreme need or coordination with .

There are also arch-specific kernel-parameters not documented here. See for example .

Note that ALL kernel parameters listed below are CASE SENSITIVE, and that a trailing = on the name of any parameter states that that parameter will be entered as an environment variable, whereas its absence indicates that it will appear as a kernel argument readable via /proc/cmdline by programs running once the system is up.

The number of kernel parameters is not limited, but the length of the complete command line (parameters including spaces etc.) is limited to a fixed number of characters. This limit depends on the architecture and is between 256 and 4096 characters. It is defined in the file ./include/asm/setup.h as COMMAND_LINE_SIZE.

Finally, the [KMG] suffix is commonly described after a number of kernel parameter values. These ‘K’, ‘M’, and ‘G’ letters represent the _binary_ multipliers ‘Kilo’, ‘Mega’, and ‘Giga’, equaling 2^10, 2^20, and 2^30 bytes respectively. Such letter suffixes can also be entirely omitted:

Источник

Boot Configuration¶

Overview¶

The boot configuration expands the current kernel command line to support additional key-value data when booting the kernel in an efficient way. This allows administrators to pass a structured-Key config file.

Config File Syntax¶

The boot config syntax is a simple structured key-value. Each key consists of dot-connected-words, and key and value are connected by = . The value has to be terminated by semi-colon ( ; ) or newline ( \n ). For array value, array entries are separated by comma ( , ).

Unlike the kernel command line syntax, spaces are OK around the comma and = .

Each key word must contain only alphabets, numbers, dash ( — ) or underscore ( _ ). And each value only contains printable characters or spaces except for delimiters such as semi-colon ( ; ), new-line ( \n ), comma ( , ), hash ( # ) and closing brace ( > ).

If you want to use those delimiters in a value, you can use either double- quotes ( «VALUE» ) or single-quotes ( ‘VALUE’ ) to quote it. Note that you can not escape these quotes.

There can be a key which doesn’t have value or has an empty value. Those keys are used for checking if the key exists or not (like a boolean).

Key-Value Syntax¶

The boot config file syntax allows user to merge partially same word keys by brace. For example:

These can be written also in:

Or more shorter, written as following:

In both styles, same key words are automatically merged when parsing it at boot time. So you can append similar trees or key-values.

Same-key Values¶

It is prohibited that two or more values or arrays share a same-key. For example,:

If you want to update the value, you must use the override operator := explicitly. For example:

then, the qux is assigned to foo key. This is useful for overriding the default value by adding (partial) custom bootconfigs without parsing the default bootconfig.

If you want to append the value to existing key as an array member, you can use += operator. For example:

In this case, the key foo has bar , baz and qux .

Moreover, sub-keys and a value can coexist under a parent key. For example, following config is allowed.:

Note, since there is no syntax to put a raw value directly under a structured key, you have to define it outside of the brace. For example:

Also, the order of the value node under a key is fixed. If there are a value and subkeys, the value is always the first child node of the key. Thus if user specifies subkeys first, e.g.:

In the program (and /proc/bootconfig), it will be shown as below:

Comments¶

The config syntax accepts shell-script style comments. The comments starting with hash (“#”) until newline (“n”) will be ignored.

This is parsed as below:

Note that you can not put a comment between value and delimiter( , or ; ). This means following config has a syntax error

/proc/bootconfig¶

/proc/bootconfig is a user-space interface of the boot config. Unlike /proc/cmdline, this file shows the key-value style list. Each key-value pair is shown in each line with following style:

Boot Kernel With a Boot Config¶

Since the boot configuration file is loaded with initrd, it will be added to the end of the initrd (initramfs) image file with padding, size, checksum and 12-byte magic word as below.

The size and checksum fields are unsigned 32bit little endian value.

When the boot configuration is added to the initrd image, the total file size is aligned to 4 bytes. To fill the gap, null characters ( \0 ) will be added. Thus the size is the length of the bootconfig file + padding bytes.

The Linux kernel decodes the last part of the initrd image in memory to get the boot configuration data. Because of this “piggyback” method, there is no need to change or update the boot loader and the kernel image itself as long as the boot loader passes the correct initrd file size. If by any chance, the boot loader passes a longer size, the kernel fails to find the bootconfig data.

To do this operation, Linux kernel provides bootconfig command under tools/bootconfig, which allows admin to apply or delete the config file to/from initrd image. You can build it by the following command:

To add your boot config file to initrd image, run bootconfig as below (Old data is removed automatically if exists):

To remove the config from the image, you can use -d option as below:

Then add “bootconfig” on the normal kernel command line to tell the kernel to look for the bootconfig at the end of the initrd file.

Kernel parameters via Boot Config¶

In addition to the kernel command line, the boot config can be used for passing the kernel parameters. All the key-value pairs under kernel key will be passed to kernel cmdline directly. Moreover, the key-value pairs under init will be passed to init process via the cmdline. The parameters are concatinated with user-given kernel cmdline string as the following order, so that the command line parameter can override bootconfig parameters (this depends on how the subsystem handles parameters but in general, earlier parameter will be overwritten by later one.):

Here is an example of the bootconfig file for kernel/init parameters.:

This will be copied into the kernel cmdline string as the following:

If user gives some other command line like,:

The final kernel cmdline will be the following:

Источник