5.4. Kernel Module Architecture

Each kernel module must include an initialization function, which is executed when the module is loaded into the kernel. This function typically registers the module’s functionality, such as registering a new device driver or enabling a specific feature. Example:

static int __init mymodule_init(void)
{
    printk(KERN_INFO "Module loaded\n");
    return 0;
}

The initialization function is crucial for every kernel module because it sets up the module’s operations once the module is loaded into the Linux kernel. When a module is inserted, this function runs automatically, which usually involves notifying the kernel of the module's presence and what it can do. For example, when a new device driver is loaded, the initialization function registers this driver with the kernel, allowing the driver to begin managing the associated hardware. In the provided example, the function mymodule_init uses printk to display a message, indicating successful loading of the module.

Think of the module initialization function like opening a new store. When a store opens, the manager must set up all the operations, such as arranging the inventory and informing the customers about the services available. Similarly, the initialization function prepares everything for the kernel to understand how to interact with the new module.

Every kernel module must also define an exit function, which is executed when the module is unloaded from the kernel. This function usually deregisters the module’s functionality (e.g., removing a device driver, freeing allocated resources). Example:

static void __exit mymodule_exit(void)
{
    printk(KERN_INFO "Module unloaded\n");
}

The exit function plays a critical role when a kernel module is no longer needed. It is executed when the module is removed from the kernel’s memory. This function typically includes cleanup activities, such as deregistering any drivers or devices that were registered during initialization and releasing any resources (like memory) that were allocated. In the example given, mymodule_exit uses printk to inform that the module has been successfully unloaded.

Imagine closing a store at the end of the day; the manager has to ensure that everything is tidied up - inventory checked, lights turned off, and the doors locked. In the same way, the exit function helps tidy up the kernel by properly removing the module and releasing any held resources.

Kernel modules include metadata, which describes the module and its functions. The MODULE_LICENSE, MODULE_AUTHOR, and MODULE_DESCRIPTION macros are used to define this metadata. Example:

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("A simple Linux kernel module");

Module metadata provides important information about the module, primarily for clarity and licensing. The MODULE_LICENSE macro defines the license under which the module is released, which is crucial for legality and transparency. The MODULE_AUTHOR macro specifies who created the module, while MODULE_DESCRIPTION gives a brief overview of what the module does. This information is useful for users and for the system to provide documentation and maintain proper dependencies.

Think of module metadata like a product label on a can of food. The label tells you what you’re buying (description), who made it (author), and if it’s safe to consume (license). This helps users make informed choices and ensures transparency in usage.

--