How to Create a Simple Kernel Module for Linux Kernel (Beginner Guide 2024)

The Linux kernel, the heart of the operating system, is a powerful and flexible beast. While its complexity can seem daunting, mastering it unlocks a world of possibilities. One key to unlocking this power is through kernel modules – small, self-contained programs that extend the kernel's functionality without requiring modifications to the core code. Think of them as "plug-ins" for the kernel, allowing you to add features, drivers, or new file systems.

This guide provides a step-by-step journey to create, compile, test, and remove a basic kernel module, perfect for those taking their first steps into the kernel development world.

Setting the Stage: Essential Tools and Knowledge

Before embarking on this journey, make sure you have the following:

• A Linux system (with root access): The kernel's home is Linux, so you'll need a Linux distribution (Ubuntu, Fedora, Debian, etc.) to work with.

• Basic C programming skills: Kernel modules are written in C, so a grasp of the language is essential.

• Kernel headers and development tools: These tools provide the building blocks and environment needed to compile and interact with your kernel module. To install these on Ubuntu/Debian systems, use the following commands:

  sudo apt-get update
  sudo apt-get install gcc-12 build-essential linux-headers-$(uname -r)
      

  
  

Step 1: Crafting a "Hello, World!" Module

Start by creating a simple kernel module. This initial module will be a classic "Hello, World!" program, demonstrating the fundamental structure of a kernel module.

Create a file named hello.c with the following code:

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>

// Initialization function (called when the module is loaded)
static int __init hello_init(void)
{
  printk(KERN_INFO "Hello, world!\n");
  return 0;  // Return 0 means success
}

// Exit function (called when the module is removed)
static void __exit hello_exit(void)
{
  printk(KERN_INFO "Goodbye, world!\n");
}

// Register the functions
module_init(hello_init);
module_exit(hello_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Simple Hello World Module");
MODULE_AUTHOR("Tecadmin.net");
    

Step 2: The Makefile: Orchestrating Compilation

To compile our kernel module, we need a Makefile. This Makefile acts as a set of instructions, guiding the system's build tools to correctly compile our module.

Create a file named Makefile in the same directory as your hello.c file:

obj-m += hello.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
    

Step 3: Building Your Module

With our code and build instructions in place, we can compile the kernel module.

1. Open a terminal: Navigate to the directory where your files are located.

2. Compile the module: Run the following command to compile the module:

         make
       

   If everything is set up correctly, this will create a file named hello.ko. This is your compiled kernel module, ready to be loaded into the kernel.

Step 4: Testing and Interacting with the Kernel

Now that your module is built, let's put it to the test. We'll load it into the kernel, observe its output, and then remove it.

1. Load the module: Use the insmod command to insert the module into the kernel:

         sudo insmod hello.ko
       

   This will load the module, and the hello_init() function within it will run.

2. Check the output: Use the dmesg command to view the messages logged by the module:

         dmesg | tail
       

   You should see the message "Hello, world!" printed in the output.

3. Remove the module: Use the rmmod command to remove the module:

         sudo rmmod hello
       

   This will unload the module and trigger the hello_exit() function.

4. Verify removal: Run dmesg | tail again. You should now see the message "Goodbye, world!" printed as the module is unloaded.

Step 5: Cleaning Up

If you no longer need the kernel module, clean up the generated files using the make clean command:

      make clean
    

This will remove the generated files, including the hello.ko module, leaving only your source code (hello.c and Makefile).

Beyond Hello, World!: Exploring the Kernel's Potential

This simple "Hello, World!" example is just the beginning of your kernel module journey. By understanding the fundamental structure and principles, you can now start creating more sophisticated modules. You can explore adding device drivers to control hardware, implementing new file systems for managing data, or even creating entirely new system calls.

Remember, the kernel is a vast and complex system, but with persistence and exploration, you can become a skilled kernel module developer, unlocking the full potential of Linux.