What are Linux kernel modules?

The Linux kernel, the core of the Linux operating system, is a monolithic kernel However, the kernel’s size and complexity necessitate a modular approach to accommodate various hardware and software configurations.

What are Linux modules?

Linux kernel modules (LKMs) are pieces of code that can be dynamically loaded and unloaded into the kernel at runtime. Unlike traditional monolithic kernels, LKMs allow the addition or removal of functionality without rebooting the system. This provides flexibility in adapting the kernel to different hardware and software environments.

Uses of kernel modules

Kernel modules can be used for a variety of purposes in the Linux operating system:

Device drivers: Kernel modules are commonly used to implement device drivers. This allows the kernel to communicate efficiently with hardware peripherals like keyboards, network cards, and storage devices. Using modules makes it easier to add support for new hardware without rebuilding the entire kernel.
File systems: Some file systems, such as ext4 and XFS, can be implemented as kernel modules. This means they can be loaded or unloaded dynamically, providing flexibility in managing file system support without needing a system reboot.
System calls: Kernel modules can extend the functionality of the kernel by introducing new system calls or modifying existing ones. This allows developers to add custom features to the operating system.
Security modules: Kernel modules are also used to enhance system security. They can implement additional access control mechanisms and enforce security policies, as seen in systems like SELinux or AppArmor.

How to write a kernel module

Now that we understand kernel modules and why they are used, let's look at how to create them.

Install kernel development packages: We ensure that the kernel headers and development tools are installed on our system.
Create the module code: We write the C code for our module, including necessary headers and functions.
Compile the module: We use the kernel build system to compile our module into a loadable object file.
Load the module: We use the insmod command to load the module into the kernel.
Unload the module: When the module is no longer required, we use the rmmod command to remove the module from the kernel.

Implementation of kernel modules

Kernel modules interact with the kernel through a well-defined set of APIs. Key components include:

Module initialization and cleanup: Implement the module_init and module_exit functions to initialize and clean up resources.
Dynamic memory allocation: Use kernel-specific memory allocation functions like kmalloc and kfree.
Error handling: Properly handle errors using kernel-specific error codes and logging mechanisms.

Code examples

Here is an example demonstrating a basic "Hello World" kernel module:

#include <linux/init.h>
#include <linux/module.h>
#include <linux/timer.h>
static int interval = 500; // Default timer interval in milliseconds
module_param(interval, int, S_IRUGO);
MODULE_PARM_DESC(interval, "Timer interval in milliseconds");
static struct timer_list my_timer;
static void my_timer_callback(struct timer_list *timer) {
    printk(KERN_INFO "Timer callback executed!\n");
    // Reschedule the timer
    mod_timer(timer, jiffies + msecs_to_jiffies(interval));
}
static int __init timer_init(void) {
    printk(KERN_INFO "Timer module initialized. Interval: %d milliseconds.\n", interval);
    // Initialize the timer
    timer_setup(&my_timer, my_timer_callback, 0);
    // Set the initial expiration time
    my_timer.expires = jiffies + msecs_to_jiffies(interval);
    // Add the timer to the system
    add_timer(&my_timer);
    return 0;
}
static void __exit timer_exit(void) {
    printk(KERN_INFO "Timer module exited.\n");
    // Delete the timer
    del_timer(&my_timer);
}
module_init(timer_init);
module_exit(timer_exit);

Let’s go through the code:

Lines 1–3: Includes the necessary header files.
Line 5: Declares a static integer variable named interval and initializes it with 500, representing the default timer interval in milliseconds.
Line 6: Declares module parameter interval of type int, readable by all (S_IRUGO).
Line 7: Describes the module parameter interval as "Timer interval in milliseconds".
Line 9: Declares a static struct timer_list named my_timer.
Line 11: Defines a callback function my_timer_callback which takes a pointer to a timer_list structure as its argument. This function is called when the timer expires.
Lines 12–15: Implements the logic of the timer callback function. It prints a message indicating the execution of the timer callback and reschedules the timer.
Line 18: Defines the initialization function timer_init.
Line 19: Prints a message indicating the initialization of the timer module with the specified interval.
Line 22: Initializes my_timer using the timer_setup function with the provided callback function.
Line 25: Sets the initial expiration time of the timer.
Line 28: Adds the timer to the system.
Line 33: Defines the exit function timer_exit.
Line 34: Prints a message indicating the exit of the timer module.
Line 37: Deletes the timer.
Lines 40–41: Specifies the initialization function timer_init to be called when the module is loaded, and the exit function timer_exit to be called when the module is unloaded.

In this example, the module introduces a kernel parameter interval that determines the interval at which the timer callback function is executed. The module uses a kernel timer to schedule periodic execution of the my_timer_callback function. The timer is initialized during module initialization and deleted during module cleanup.

Test yourself

Before moving on to the conclusion, test your understanding.