Kernel module

Related articles
Boot debugging
Compile kernel module
Kernel
Kernel parameters
Kernel modules
are pieces of code that can be loaded and unloaded into the kernel upon demand. They extend the functionality of the kernel without the need to reboot the system.
To create a kernel module, you can read
The Linux Kernel Module Programming Guide
. A module can be configured as built-in or loadable. To dynamically load or remove a module, it has to be configured as a loadable module in the kernel configuration (the line related to the module will therefore display the letter
M
).
To rebuild a kernel module automatically when a new kernel is installed, see
Dynamic Kernel Module Support
(DKMS).
Obtaining information
Usually modules depend on the kernel release and are stored in the
/usr/lib/modules/
kernel_release
/
directory.
Tip
Run
uname -r
(or
uname --kernel-release
) to get your current kernel release.
Note
Module and
alias
names often use underscores (
_
) or dashes (
-
); however, those symbols are interchangeable when using the
modprobe
command and in configuration files in
/etc/modprobe.d/
(automatic conversion to underscores is performed, see
modprobe(8) § DESCRIPTION
and
modprobe.d(5) § DESCRIPTION
).
To show what kernel modules are currently loaded:
$ lsmod
To show information about a module:
$ modinfo
module_name
To list the options that are set for a loaded module use
systool(1)
from
sysfsutils
:
$ systool -v -m
module_name
To display the comprehensive configuration of all the modules:
$ modprobe -c | less
To display the configuration of a particular module:
$ modprobe -c | grep
module_name
List the dependencies of a module (or alias), including the module itself:
$ modprobe --show-depends
module_name
Automatic module loading
Today, all necessary modules loading is handled automatically by
udev
, so if you do not need to use any out-of-tree kernel modules, there is no need to put modules that should be loaded at boot in any configuration file. However, there are cases where you might want to load an extra module during the boot process, or blacklist another one for your computer to function properly.
Early module loading
Early module loading depends on the
initramfs
generator used:
Booster#Early module loading
Dracut#Early kernel module loading
Mkinitcpio#MODULES
Note
The
initramfs
image may not contain the kernel modules asked for in
/etc/modules-load.d/
, it also may lack the files that have been set in that folder (see
#systemd
).
systemd
Kernel modules can be explicitly listed in files under
/etc/modules-load.d/
for systemd to load them during boot. Each configuration file is named in the style of
/etc/modules-load.d/
program
.conf
. Configuration files simply contain a list of kernel modules names to load, separated by newlines. Empty lines and lines whose first non-whitespace character is
#
or
;
are ignored.
/etc/modules-load.d/virtio-net.conf
# Load virtio_net.ko at boot
virtio_net
See
modules-load.d(5)
for more details.
Manual module handling
Kernel modules are handled by tools provided by the
kmod
package, which is installed as a dependency of a kernel package. You can use these tools manually. To load a module:
# modprobe
module_name
Note
If you have upgraded your kernel but have not yet rebooted,
modprobe
will fail with no error message and exit with code
1
, because the path
/usr/lib/modules/
kernel_release
/
no longer exists. Check manually if this path exists when
modprobe
failed to determine if this is the case.
To load a module by a file name—i.e. one that is not installed in the
/usr/lib/modules/
kernel_release
/
directory—use any of:
# insmod
file_name
module_options
# modprobe
file_name
To unload—
remove
—a module, use any of:
# rmmod
module_name
# modprobe -r
module_name
# modprobe --remove
module_name
Setting module options
To pass a parameter to a kernel module, you can pass them manually with
modprobe
or assure certain parameters are always applied using a
modprobe
configuration file or by using the
kernel command line
. If the module is built into the kernel, the kernel command line must be used and other methods will not work.
Using modprobe
The basic way to pass parameters to a module is using the
modprobe
command. Parameters are specified on command line using simple
key
=
value
assignments:
# modprobe
module_name
parameter_name
=
parameter_value
Using modprobe.d
Configuration files in the
/etc/modprobe.d/
directory can be used to pass module settings to
udev
, which will use
modprobe
to manage the loading of the modules during system boot. Files in this directory can have any name, given that they end with the
.conf
extension. The file name matters, see
modprobe.d(5) § CONFIGURATION DIRECTORIES AND PRECEDENCE
. To show the effective configuration:
$ systemd-analyze cat-config modprobe.d
The syntax is:
/etc/modprobe.d/
file_name
.conf
options
module_name parameter_name=parameter_value
Note
All options for a given module
must
be defined in a single line. New
options
line with the same module name replaces the previous one.
Multiple module parameters are separated by spaces, in turn a parameter can receive a list of values which is separated by commas:
/etc/modprobe.d/
file_name
.conf
options
module_name param1=value1 param2=value2a,value2b …
For example:
/etc/modprobe.d/thinkfan.conf
# On ThinkPads, this lets the 'thinkfan' daemon control fan speed
options thinkpad_acpi fan_control=1
Note
If any of the affected modules is loaded from the
initramfs
, then you will need to add the appropriate
.conf
file to
FILES
in
mkinitcpio.conf
or use the
modconf
hook
, then
regenerate the initramfs
to include the
.conf
file. To see the contents of the default initramfs use
lsinitcpio
.
Using kernel command line
You can also pass options to the module using the kernel command line. This is the only working option for modules built into the kernel. For all common
boot loaders
, the following syntax is correct:
module_name.parameter_name=parameter_value
For example:
thinkpad_acpi.fan_control=1
Simply add this to the appropriate line in your boot loader configuration, as described in
Kernel parameters#Boot loader configuration
.
Aliasing
Aliases are alternate names for a module. For example:
alias my-mod really_long_modulename
means you can use
modprobe my-mod
instead of
modprobe really_long_modulename
. You can also use shell-style wildcards, so
alias my-mod* really_long_modulename
means that
modprobe my-mod-something
has the same effect. Create an alias:
/etc/modprobe.d/myalias.conf
alias my-mod really_long_module_name
Aliases can be internal—contained in the module itself. Internal aliases are usually used for
#Automatic module loading
when it is needed by an application, e.g. when the kernel detects a new device. To see the module internal aliases:
$ modinfo --field=alias
module_name
To see both configured and internal aliases:
$ modprobe --showconfig | grep '\<
module_name
$'
Blacklisting
Blacklisting, in the context of kernel modules, is a mechanism to prevent the kernel module from loading. This could be useful if, for example, the associated hardware is not needed, or if loading that module causes problems: for instance there may be two kernel modules that try to control the same piece of hardware, and loading them together would result in a conflict.
Tip
Do not confuse the
blacklisting
as a generic term with using the
blacklist
keyword as a blacklisting
particular case
.
Some modules are loaded as part of the
initramfs
.
mkinitcpio -M
will print out all automatically detected modules: to prevent the initramfs from loading some of those modules, blacklist them in a
.conf
file under
/etc/modprobe.d
and it shall be added in by the
modconf
hook during image generation. Running
mkinitcpio -v
will list all modules pulled in by the various hooks (e.g.
filesystems
hook,
block
hook, etc.). Remember to add that
.conf
file to the
FILES
array in
/etc/mkinitcpio.conf
if you do not have the
modconf
hook in your
HOOKS
array (e.g. you have deviated from the default configuration), and once you have blacklisted the modules
regenerate the initramfs
, and reboot afterwards.
Using modprobe.d
alias
Disable an
alias
by overriding. For example, to prevent Bluetooth module autoloading (assuming a module named
off
does not exist):
/etc/modprobe.d/modprobe.conf
alias net-pf-31 off
Note
Alias overriding can prevent automatic module loading, but will still allow the module to be loaded—both automatically and manually—by another alias or the module name.
blacklist
To disable all internal aliases for a given module use the
blacklist
keyword. For example, to prevent the
pcspkr
module from loading on boot to avoid sounds through the
PC speaker
:
/etc/modprobe.d/nobeep.conf
blacklist pcspkr
Note
The
blacklist
configuration command—as it deals with aliases—has the same drawback as the
alias
one does: automatic loading can be prevented, but the module still may be loaded manually, or automatically if another module depends on it.
install
There is a workaround for the behaviour described in the
#alias
and
#blacklist
notes. The
install
configuration command instructs
modprobe
to run a custom command instead of inserting the module in the kernel as normal, so you can simulate the successful module loading with:
/etc/modprobe.d/blacklist.conf
install
module_name
/bin/true
You can force the module to always fail loading with
/bin/false
: this will effectively prevent the module—and any other that depends on it—from loading by any means, and a log error message may be produced.
Using kernel command line
Tip
This can be very useful if a broken module makes it impossible to boot your system.
You can also blacklist modules from the
boot loader
boot entry configuration.
Simply add
module_blacklist=
module_name_1
,
module_name_2
,
module_name_3
to your kernel command line, as described in
Kernel parameters#Boot loader configuration
.
Note
When you are blacklisting more than one module, note that they are separated by commas only. Spaces or anything else might presumably break the syntax.
module_blacklist
will make the kernel completely refuse to load the module.
If you only want to prevent implicit loading, but maybe load the module manually later, the correct parameter is
modprobe.blacklist=
module_name_1
,
module_name_2
,
module_name_3
. This will however not prevent explicit loads during the boot, e.g. by
systemd
or other modules.
Another use case for a command line option is to disable hardware-specific components of a module without disabling the module entirely. For example, disabling a microphone while retaining other sound out options. See
BBS#303475
for a few examples.
Troubleshooting
Module does not load
In case a specific module does not load and the boot log (accessible by running
journalctl -b
as root) says that the module is blacklisted, but the directory
/etc/modprobe.d/
does not show a corresponding entry, check another
modprobe
source directory at
/usr/lib/modprobe.d/
for blacklisting entries.
A module will not be loaded if the "vermagic" string contained within the kernel module does not match the value of the currently running kernel. If it is known that the module is compatible with the current running kernel the "vermagic" check can be ignored with
modprobe --force-vermagic
.
Warning
Ignoring the version checks for a kernel module can cause a kernel to crash or a system to exhibit undefined behavior due to incompatibility. Use
--force-vermagic
only with the utmost caution.
See also
Disable PC speaker beep
Writing a WMI driver
- an LWM introduction