The concepts of kernel space and user space are a bit abstract. It is all about memory and access rights. One may consider the kernel to be privileged, whereas the user apps are restricted. It is a feature of a modern CPU, allowing it to operate either in privileged or unprivileged mode. This concept will be clearer to you in Chapter 11, Kernel Memory Management:

The preceding diagram introduces the separation between kernel and user space, and highlights the fact that system calls represent the bridge between them (we discuss this later in this chapter). We can describe each space as follows:

• Kernel space: This is a set of addresses where the kernel is hosted and where it runs. Kernel memory (or kernel space) is a memory range, owned by the kernel, protected by access flags, preventing any user apps from messing with the...

Let's consider the following helloworld module. It will be the basis for our work during the rest of this chapter:

helloworld.c

#include <linux/init.h> 
#include <linux/module.h> 
#include <linux/kernel.h> 
 
static int __init helloworld_init(void) { 
    pr_info("Hello world!\n"); 
    return 0; 
} 
 
static void __exit helloworld_exit(void) { 
    pr_info("End of the world\n"); 
} 
 
module_init(helloworld_init); 
module_exit(helloworld_exit); 
MODULE_AUTHOR("John Madieu <john.madieu@gmail.com>"); 
MODULE_LICENSE("GPL"); 

Kernel drivers all have entry and exit points: the former corresponds to the function called...

Error codes are interpreted either by the kernel or by the user space application (through the errno variable). Error handling is very important in software development, more than it is in kernel development. Fortunately, the kernel provides a couple of errors that cover almost every error you'll encounter, and sometimes you will need to print them out in order to help you debug.

Return the wrong error code for a given error and it will result in either the kernel or user space app producing unwanted behavior and making a wrong decision. To keep things clear, there are predefined errors in the kernel tree that cover almost every case you may face. Some of the errors (with their...

As a user program does, a kernel module can accept arguments from the command line. This allows dynamically changing the behavior of the module according to given parameters, and can help the developer not having to indefinitely change/compile the module during a test/debug session. In order to set this up, you should first declare the variables that will hold the values of command line arguments, and use the module_param() macro on each of these. The macro is defined in include/linux/moduleparam.h (this should be included in the code too: #include <linux/moduleparam.h>), shown as follows:

module_param(name, type, perm); 

This macro contains the following elements:

• name: The name of the variable used as the parameter
• type: The parameter's type (bool, charp, byte, short, ushort, int, uint, long, ulong), where charp stands for char pointer
• perm: This...

There are two places to build a module. It depends on whether you want people to enable the module by themselves or not using the kernel config interface.

A makefile is a special file used to execute a set of actions, among which the most important is the compilation of programs. There is a dedicated tool to parse makefiles, called make. Prior to jumping to the description of the whole make file, let's introduce the obj-<X> kbuild variable.

In almost every kernel makefile, you will see at least one instance of an obj<-X> variable. This actually corresponds to the obj-<X> pattern, where <X> should be either y, m, left blank, or n. This is used...

This chapter showed you the basics of driver development and explained the concept of modules/built-in devices, as well as their loading and unloading. Even if you are not able to interact with the user space, you are ready to write a complete driver, print a formatted message, and understand the concept of init/exit. The next chapter will deal with character devices, with which you will be able to target enhanced features, write code accessible from the user space, and have a significant impact on the system.