The understanding of the Makefile in the Linux driver development module & hello kernel module example

Please ask the students to think about two questions: Why do we have to write a main() function? Does the kernel C program need main?

here #include <stdio.h> is for us to use printf(), in fact they are all functions of the C language library, can they be used in the kernel program?

We first answer these two questions. The C language application must have a main() function because it is the entry point of the application. As for why it is such an entry, we only have one answer: , mandatory. C applications have application specifications, as kernel modules have kernel modules, so when we write the kernel module framework, remember that this is the rule.

As for the second question, it is more important: the application can call the function of the C standard library, and the kernel program is absolutely impossible. If you remember that we said fopen, it is dependent on the open system call. And if the system call is exported by the kernel, then if we can use the standard function library in the kernel program, then we will go to the "circle of the chicken" or the egg chicken.

The following program is the standard framework for the Linux kernel module (please see how the teacher wrote this code when I first learned).
C++ code#include <linux/module.h>

This is a hello Kernel module framework, if we want to print out hello, kernel, we only need to modify hello_init to: static int __init hello_init(void){ printk(“hello,kernel/n”); return 0;} module framework Contains the following four parts:

(1) The module_init(function) that the module needs to execute when it is loaded, and the module_init The function specified in (), module_exit(function) executed when the module is unloaded, and the function defined in module_exit(). If module_exit() is declared, the module will not have dynamic unloading.

(2) Need to define the initialization function called by module_init() and the cleanup function used in module_exit(). Only when the initialization function returns a non-negative value (because in the kernel, a negative value indicates that the operation failed), the kernel module can be loaded correctly, otherwise the module fails to load. The cleanup function returns a void type. In general, the initialization function is used to apply for resources when the module is loaded, and the cleanup function is used to release resources when the module is unloaded, which is similar to the constructor and deconstructor in C++.

(3) Header files, for kernel modules, you must use <linux/module.h> and <linux/init.h>. It's important to note that <> is used to include header files, but it's obvious that neither of these header files will be the header of a standard function, because, as mentioned earlier, kernel modules cannot reference standard libraries. The function. The header file here actually comes from the $(KERNELSRC)/include directory in the Linux kernel source path.

(4) Related content represented by MODULE_XXX, these are descriptions of the current kernel module, although not required, but in general, please fill in a few items, especially the license problem of the module. . Of course, it also gives you the opportunity to make a name for yourself, and you should also be responsible. Your more detailed description of the module will help you debug errors later. Modinfo allows you to identify modules faster. If necessary, please refer to the LDD (<<<Linux Device Drivers>>, hereinafter referred to as LDD) macro description for more MODULE_XXX.