5.6. Building Kernel Modules

To build a kernel module, you typically need to write the module’s source code, create a Makefile, and use make to compile the module. Here’s an overview of how to build a kernel module.

Basic Kernel Module Code (example.c):

#include <linux/module.h>
#include <linux/kernel.h>
static int __init example_init(void)
{
    printk(KERN_INFO "Hello, Kernel!\n");
    return 0;
}
static void __exit example_exit(void)
{
    printk(KERN_INFO "Goodbye, Kernel!\n");
}
module_init(example_init);
module_exit(example_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("A simple kernel module");

To create a kernel module, you start by writing the code that defines the module's behavior and functionality. The provided example shows two key functions: example_init for module initialization and example_exit for cleanup upon removal. These functions use printk to log messages, which can be seen in the kernel logs. Additionally, the module's metadata is defined at the end, which is essential for the kernel to recognize details about your module.

Think of this code as the recipe for a cake. The example_init function is like the step where you preheat the oven and prepare the ingredients, while example_exit is when you clean up the kitchen after baking. The metadata acts like a label on the cake, telling everyone who made it and what type it is.

Makefile to Build the Module:

obj-m += example.o
all:
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
clean:
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

The Makefile is a crucial file that automates the build process of the kernel module. The line obj-m += example.o indicates that you want to compile example.o into a kernel module. The all target specifies the command to compile the module using the kernel's build system, while the clean target removes any compiled files, allowing for a fresh build.

Consider the Makefile as a set of instructions for putting together furniture. Just like assembly instructions tell you what parts to use and how to put them together, the Makefile guides the build system on how to compile your module. The clean command is like clearing your workspace after you're done assembling to keep everything tidy.

Steps to Build the Module:

1. Save the kernel module code into a file (e.g., example.c).
2. Create a Makefile with the contents provided above.
3. Run the following commands to build the kernel module:

   make

4. Once the module is compiled, you will get a .ko file, which can be loaded using insmod.

To build your kernel module, you first save your code into a file named example.c. Then, you create a Makefile with the necessary instructions for building it. Running the make command compiles your module, generating a .ko file, which is the final output ready to be loaded into the kernel using the insmod command. This process allows the kernel to use your custom functionality defined in the module.

Building a kernel module can be likened to cooking a dish. First, you write down your recipe (code) on a notepad (file), prepare your cooking tools (Makefile), and then follow the cooking steps (commands) to finish the dish. The result is like having your meal ready on the table (the .ko file) that you can serve (load into the kernel) whenever you're ready to eat.

--