Before You Begin

Writing a kernel module is very different from writing a normal C program. Before you write even one line, make sure you understand what you’re getting into.

On your development machine (Ubuntu 22.04 or 24.04 is ideal), you need two things installed before you can compile any kernel module:

# Install kernel headers matching your running kernel
sudo apt update
sudo apt install linux-headers-$(uname -r) build-essential

The linux-headers-$(uname -r) package gives you the header files and Kbuild infrastructure for your running kernel. Without them, you simply cannot compile any module.

The Hello World Kernel Module

Here is a minimal, working Hello World kernel module. This is your own code — not copied from any book. Write it fresh in a file called hello_lkm.c:

/*
 * hello_lkm.c
 * A minimal Hello World Linux Kernel Module.
 * Works on Linux Kernel 5.x and 6.x.
 *
 * Author: Your Name
 * License: GPL v2
 */

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

MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("EmbeddedPathashala: Hello World Kernel Module");
MODULE_LICENSE("GPL");
MODULE_VERSION("1.0");

static int __init hello_lkm_init(void)
{
    pr_info("hello_lkm: module loaded – Hello from kernel space!\n");
    return 0;
}

static void __exit hello_lkm_exit(void)
{
    pr_info("hello_lkm: module unloaded – Goodbye from kernel space!\n");
}

module_init(hello_lkm_init);
module_exit(hello_lkm_exit);

That’s the complete code. Small, but every single line has a specific purpose. Let’s go through each one.

Line by Line – Understanding Every Part

The Header Files

The Module Metadata Macros

The four MODULE_* macros don’t generate executable code. They embed metadata strings directly into the .ko file’s special section called .modinfo. This is exactly what modinfo reads when you inspect a module.

The Init Function – What Runs on insmod

static int __init hello_lkm_init(void)
{
    pr_info("hello_lkm: module loaded – Hello from kernel space!\n");
    return 0;
}

The Exit Function – What Runs on rmmod

static void __exit hello_lkm_exit(void)
{
    pr_info("hello_lkm: module unloaded – Goodbye from kernel space!\n");
}

The exit function must be void — it cannot fail. By the time the kernel calls this function, it has already decided to unload the module. There is no way to abort the unloading from inside module_exit(). This is why your cleanup code must be reliable.

The __exit macro is the counterpart to __init. It places the function in a section that is discarded if the module is compiled directly into the kernel (built-in modules can never be unloaded, so the exit code would be wasted memory).

The Registration Macros

module_init(hello_lkm_init);
module_exit(hello_lkm_exit);

These two macros are how you tell the LKM framework which function to call when loading and unloading. Internally, they store pointers to your functions inside the kernel module’s struct module. When insmod loads your .ko, the kernel finds these pointers and calls the init function through them.

The Makefile – Compiling with Kbuild

You cannot compile a kernel module with a plain gcc command. The kernel has its own build system called Kbuild. You must go through Kbuild so your module gets the correct compiler flags, header search paths, and linker settings for the running kernel. Here is the Makefile you need:

# Makefile for hello_lkm
# Place this in the same directory as hello_lkm.c

obj-m += hello_lkm.o

KDIR := /lib/modules/$(shell uname -r)/build
PWD  := $(shell pwd)

all:
	$(MAKE) -C $(KDIR) M=$(PWD) modules

clean:
	$(MAKE) -C $(KDIR) M=$(PWD) clean

Build, Load, and Test Your Module

With your source file and Makefile both in the same directory, follow these steps:

$ make
make -C /lib/modules/6.8.0-xx-generic/build M=/home/ravi/hello_lkm modules
  CC [M]  /home/ravi/hello_lkm/hello_lkm.o
  MODPOST /home/ravi/hello_lkm/Module.symvers
  CC [M]  /home/ravi/hello_lkm/hello_lkm.mod.o
  LD [M]  /home/ravi/hello_lkm/hello_lkm.ko
make[1]: Leaving directory '/usr/src/linux-headers-6.8.0-xx-generic'

$ modinfo hello_lkm.ko
filename:       /home/ravi/hello_lkm/hello_lkm.ko
version:        1.0
description:    EmbeddedPathashala: Hello World Kernel Module
author:         Your Name
license:        GPL
srcversion:     ...
vermagic:       6.8.0-xx-generic SMP preempt mod_unload

$ sudo insmod hello_lkm.ko

$ dmesg | tail -5
[12345.678901] hello_lkm: loading out-of-tree module taints kernel.
[12345.678950] hello_lkm: module loaded – Hello from kernel space!

$ lsmod | grep hello_lkm
hello_lkm              16384  0

$ sudo rmmod hello_lkm
$ dmesg | tail -3
[12367.123456] hello_lkm: module unloaded – Goodbye from kernel space!

Kernel Logging – printk, pr_info, and Log Levels

In user space you use printf(). In the kernel there is no standard C library, so you use printk() (kernel printf). However, since Linux 3.x, the recommended approach is to use the pr_* family of macros, which are wrappers around printk() that automatically prepend the calling module’s name and the log level.

For your learning modules, always use pr_info(). For error handling paths, use pr_err(). The printk(KERN_INFO "...") style still works in kernel 6.x, but the pr_info() form is cleaner and preferred in modern kernel code.

A Note on Kernel Headers vs glibc Headers

This trips up almost every beginner. You must never mix kernel headers with glibc (standard C library) headers in a kernel module.

#include <stdio.h>      /* glibc - WRONG */
#include <stdlib.h>     /* glibc - WRONG */
#include <string.h>     /* glibc - WRONG */

printf("hello\n");      /* WRONG – no stdio in kernel */
malloc(100);            /* WRONG – no heap allocator */

#include <linux/kernel.h>   /* kernel logging */
#include <linux/slab.h>     /* kernel memory */
#include <linux/string.h>   /* kernel strings */

pr_info("hello\n");     /* kernel logging */
kmalloc(100, GFP_KERNEL); /* kernel memory */

The reason is simple: glibc assumes it’s running in user space with virtual memory, system calls, and a C runtime. The kernel doesn’t have any of that when a module is executing. Mixing them leads to compile errors at best, and bizarre runtime crashes at worst.

Bonus: What Does __init Actually Do Under the Hood?

This is something most tutorials skip over, but it’s worth knowing for interviews.

The __init macro expands to __attribute__((__section__(".init.text"))). This is a GCC compiler directive that places the marked function into a special ELF section of the .ko file called .init.text instead of the regular .text section.

For a tiny Hello World module, this memory saving is negligible. But for large drivers with complex initialization routines, the __init annotation can save several kilobytes of kernel memory per module — and at scale across hundreds of loaded modules, this adds up.