How do you use kernel parameters and sysfs to interact with a kernel module?

1 Loading and unloading modules

To load a kernel module, you can use the

modprobe        

or

insmod        

commands. The

modprobe        

command is preferred, as it resolves dependencies and loads any required modules automatically. The

insmod        

command requires you to specify the full path to the module file and does not handle dependencies. To unload a kernel module, you can use the

modprobe -r        

or

rmmod        

commands. The

modprobe -r        

command is preferred, as it unloads any dependent modules as well. The

rmmod        

command requires you to specify the module name and does not handle dependencies.

2 Passing parameters to modules

To pass parameters to a kernel module, you can use the

modprobe        

command with the syntax

modprobe module_name parameter=value        

. For example, if you want to load a module called

foo        

with a parameter called

bar        

set to

42        

, you can run

modprobe foo bar=42        

. You can also specify multiple parameters by separating them with spaces. To see the available parameters and their descriptions for a module, you can use the

modinfo        

command with the syntax

modinfo module_name        

.

3 Using sysfs to interact with modules

Sysfs is a virtual filesystem that provides a view of the kernel's device model and module attributes. It is mounted at

/sys        

by default. To interact with a kernel module through sysfs, you can use the

echo        

and

cat        

commands to write and read values to and from files under

/sys/module/module_name        

. For example, if you want to write

1        

to a file called

enable        

under

/sys/module/foo        

, you can run

echo 1 > /sys/module/foo/enable        

. To read the value of a file called

status        

under

/sys/module/foo        

, you can run

cat /sys/module/foo/status        

. The files and their meanings depend on the implementation of the module.

4 Writing a simple kernel module

To write a simple kernel module, you need to create a source file with the extension

.c        

and a Makefile. The source file should include the header files

<linux/module.h>        

and

<linux/kernel.h>        

, and define two functions:

init_module        

and

cleanup_module        

. The

init_module        

function is executed when the module is loaded, and the

cleanup_module        

function is executed when the module is unloaded. You can use the macros

MODULE_LICENSE        

,

MODULE_AUTHOR        

,

MODULE_DESCRIPTION        

, and

MODULE_VERSION        

to provide metadata about the module. You can also use the macro

module_param        

to declare parameters for the module. The Makefile should contain the rules to compile the module using the kernel build system.

5 Testing and debugging modules

To test and debug a kernel module, you need to load and unload it using the commands mentioned above, and check the output of the commands and the kernel log messages. You can use the

dmesg        

command to view the kernel log messages, or use the

tail -f /var/log/kern.log        

command to follow the log file. You can also use the

printk        

function in your module code to print messages to the kernel log with different levels of severity. You can use the

KERN_DEBUG        

,

KERN_INFO        

,

KERN_WARNING        

,

KERN_ERR        

, and

KERN_CRIT        

constants to indicate the level of your message. For example, to print a debug message, you can use

printk(KERN_DEBUG "This is a debug message\n");        

.

6 Here’s what else to consider

This is a space to share examples, stories, or insights that don’t fit into any of the previous sections. What else would you like to add?