Enrol to start learning
Reading is open to everyone. Enrolling is free, and it is what unlocks the audio lessons, practice tests and progress tracking.
5.6.1. Basic Kernel Module Code (example.c)
Learn content
Interactive Audio Lesson
Unlock the classroom podcast
The transcript is free to read. A free account plays the conversation back.
Today, we're going to learn about the basic structure of a kernel module using a simple example. Let's start by looking at the code we will be using.
What exactly is a kernel module?
Great question! A kernel module is a piece of code that can extend the functionality of the kernel. It allows us to add features without rebooting the system, which is crucial for maintaining uptime in production environments.
What does the initialization function do?
The initialization function, like example_init in our code, is executed when the module is loaded into the kernel. It typically registers the module's functionalities or resources.
So what does the code printk(KERN_INFO "Hello, Kernel!\n"); do?
This line logs a message to the kernel log, which is crucial for debugging and understanding what happens when the module is loaded. Remember, printk is similar to printf but used for logging in the kernel space.
Is there an exit function too?
Yes! The exit function, like example_exit, is called when the module is removed. It can be used to clean up resources that were allocated when the module was loaded.
To summarize, the initialization function handles setup, while the exit function manages cleanup. Together, they form the backbone of a kernel module.
Unlock the classroom podcast
The transcript is free to read. A free account plays the conversation back.
Now, let’s look at the metadata within our module. This includes important details such as license, author, and description information.
What are those macros you mentioned?
The macros MODULE_LICENSE, MODULE_AUTHOR, and MODULE_DESCRIPTION provide essential information about the module. They ensure compatibility with the kernel and inform users about the module's author and purpose.
Why is the license important?
The license is crucial for legal reasons. It defines the terms under which code can be shared and used. In this case, using GPL indicates that the code is released under the GNU General Public License.
How do we compile this code?
To compile the module, you need to create a Makefile that directs the build process. The command make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules will compile your module into a .ko file.
So, once compiled, I can load it into the kernel?
Exactly! After compiling, you can use insmod to load your module into the kernel and rmmod to remove it when you're done. Always check kernel logs with dmesg for any messages from your module!
Overall, we've covered the basic structure, compiled it, and discussed the importance of metadata in kernel modules.
Overview
Short Summary
This section introduces the basic code structure for a Linux kernel module, demonstrating its initialization and exit functions.
Medium Summary
The section provides a foundational understanding of writing basic kernel modules in Linux by showcasing a sample code in C. It explains the purpose of module initialization and exit functions and highlights key metadata associated with kernel modules.
Detailed Summary
Basic Kernel Module Code
Kernel modules are essential for enhancing the functionality of the Linux kernel without requiring a system reboot. This section specifically focuses on writing a basic kernel module in C, showcasing the necessary components to set up a functioning module.
Key Components of the Module:
- Initialization Function: This function is executed when the module is loaded. In our example,
example_initis where the module logs a message to the kernel log stating that it has loaded. - Exit Function: Conversely, this function is called when the module is unloaded. The
example_exitfunction logs a message indicating the module has been removed. - Metadata: Using macros such as
MODULE_LICENSE,MODULE_AUTHOR, andMODULE_DESCRIPTION, one can define important information regarding the module's license, authorship, and a brief description, which is critical for proper handling of kernel modules by the system.
The example code serves as a starting point for developing kernel modules, providing a basic structure for future expansions.
Reference YouTube Videos
Audio Book
Unlock the audio lesson
The script is above and free to read. A free account plays it back, in the voice you pick.
Create a free account#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");
Detailed Explanation
This chunk introduces the basic structure of a kernel module written in C. It includes necessary headers, defines initialization and exit functions, and registers them using macros. The example_init function is called when the module is loaded and prints a message to the kernel log, while the example_exit function is called when the module is unloaded, printing a farewell message.
Examples & Analogies
Think of the kernel module like a plugin for a software application. When you install a plugin (load the module), the application (kernel) gains new features, like the ability to manage new hardware. When you remove the plugin (unload the module), the application goes back to its original state.
Unlock the audio lesson
The script is above and free to read. A free account plays it back, in the voice you pick.
Create a free accountstatic 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"); }
Detailed Explanation
Here, we focus on the example_init and example_exit functions. The example_init function is marked with __init, which indicates it's meant for initialization. It does some setup tasks, like printing a message that the module has been loaded. The example_exit function is marked with __exit, signaling it will clean up before the module is removed, in this case, by printing a goodbye message.
Examples & Analogies
Imagine starting a car (initialization) where the engine kicks in and the lights come on, you check the dashboard for any warnings. When you stop the car (exit), you turn off the engine and check that everything is okay before leaving it.
Unlock the audio lesson
The script is above and free to read. A free account plays it back, in the voice you pick.
Create a free accountmodule_init(example_init); module_exit(example_exit);
Detailed Explanation
The module_init and module_exit macros are crucial for registering the initialization and exit functions with the kernel. When the module is loaded, the kernel calls the function provided to module_init, and when it is unloaded, the function provided to module_exit is called. This registration is essential for the kernel to know what to do during loading and unloading the module.
Examples & Analogies
It's like registering for a class at school. You fill out a form (registering) to attend the class (loading the module), and when you're done, you inform the school that you’re leaving the class (unloading the module).
Unlock the audio lesson
The script is above and free to read. A free account plays it back, in the voice you pick.
Create a free accountMODULE_LICENSE("GPL"); MODULE_AUTHOR("Your Name"); MODULE_DESCRIPTION("A simple kernel module");
Detailed Explanation
This chunk deals with the metadata of the kernel module. The MODULE_LICENSE macro declares the license of the module, which is important for compliance and ensuring the correct usage of the kernel's APIs. The MODULE_AUTHOR and MODULE_DESCRIPTION macros provide information about the module's authorship and its purpose. This aids users and developers in understanding the context of the module.
Examples & Analogies
Think of the module metadata like the label on a product. It tells you who made it, what it is, and any special instructions or licenses that come with it, helping consumers understand how to use the product correctly.
--
Key concepts
Core takeaways and short definitions to help you quickly recall the key ideas from this section.
- Kernel Module:
Core logic allowing dynamic expansion of kernel functionality.
- Initialization Function:
The entry point for logic executed when the module loads.
- Exit Function:
A crucial cleanup routine executed when the information is unloaded.
- Metadata:
Essential module details including license, authorship, and descriptions.
Examples
Memory aids
Imagine a teacher (initialization) who welcomes students (resources) at the start of the day, and at the end of the day, the teacher helps everyone pack up (exit function) before they leave.
Flash Cards
Glossary
Kernel Module
A piece of code that extends the functionality of the Linux kernel at runtime.
Initialization Function
Function executed when the kernel module is loaded, typically used for registering functionalities.
Exit Function
Function executed when the kernel module is unloaded, used for cleanup operations.
MODULE_LICENSE
Macro that defines the licensing terms of the module.
MODULE_AUTHOR
Macro that defines the author of the module.
MODULE_DESCRIPTION
Macro that provides a brief description of the module.
printk
A logging function used within kernel modules to write messages to the kernel log.