The principle of the kernel module and its module writing

HelloWorld kernel

I started to learn the kernel intermittently. It took about half a year. I started to feel a little bit of the kernel. But I am very small for this monster. There seems to be no success in the boring kernel source. So I chose to learn kernel module programming. Write some kernel modules to experience a little bit of accomplishment!

What is a kernel module?

A kernel module is a program with independent functions. It can be compiled separately, but it cannot be run separately. Its operation must be linked to the kernel as part of the kernel to run in kernel space.

The simplest kernel module

#include / / All modules must contain the header file #include // Some macro definitions, such as KERN_INFOint init_module(void) { printk(KERN_INFO "Hello world 1."); /* * Returning non-zero means that the module failed to initialize, unable to load */ return 0; }void cleanup_module(void { printk(KERN_INFO "Goodbye world 1."); } //A module needs at least two functions. An initialization function is here called init_module when loading the kernel, // an end function, here is cleannup_module in the slave kernel. Called when logging out

A Makefile to compile this kernel module

Obj-m += hello-1.oall: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: make -C /lib/modules/$(shell uname - r)/build M=$(PWD) clean

Note: All the links in this article are based on the test OK under Centos6.5. You may see that the Makefile is written in some books.

Make -C /usr/src/linux-headers-$(shell uname -r) M=$(PWD) modules Actually /lib/modules/$(shell uname -r)/build This path is a soft link to the path above [root@localhost 2.6.32-431.el6.x86_64]# ls -al build lrwxrwxrwx. 1 root root 44 Mar 16 05:26 build -> /usr/src/kernels/2.6.32-504.12.2.el6. X86_64/

After writing the makefile, use make to compile. After compiling, a .ko file appears. This is the kernel module, which needs to be loaded and run.

Load the kernel module to run

There are many ways to load kernel modules. For example: modprobe and insmod will analyze the module's dependencies, and will go to the specified path to find the kernel module load, while the latter needs to specify the absolute path of the kernel module to load and does not solve the module's dependencies. relationship. Here we use insmod to load the kernel module, use rmmod to uninstall the kernel module [root@localhost kernel_module]# insmod hello-1.ko use dmes to view the output of the kernel module Hello world 1. Unload the kernel module [root@localhost kernel_module]# rmmod Hello-1 dmesg view output Goodbye world 1.

Similarities and differences between kernel module programming and application programming

Kernel module programming is not able to use standard libraries (such as malloc free, etc.) and some third-party libraries

Kernel module programming is not memory protected, if the memory access error, there will be oops error

Kernel module programming is no main function, only one initialization function, and a proposed function

Kernel module programming requires the use of kernel-provided header files and APIs

The standard output of kernel module programming is output to a file instead of output to the screen.

The debug of kernel module programming cannot be debugged using gdb.

Advanced kernel module

The programming of the kernel module is not only a HelloWorld above, but also some more advanced writing methods for kernel module programming.

Remove init_module/cleanup_module

In the HelloWorld module above, you will find that the initialization function and the exit function seem to be fixed names. So is there any way to customize the name yourself? It is ok, you can customize the name yourself and then register it (registration actually Just do a function pointer assignment. Here is the way to write a custom name:

/ / Does not need to fix the name and end of the initialization function of the kernel module #include #include #include Static int hello_2_init(void) { printk(KERN_INFO "Hello,world 2"); return 0; }static void hello_2_exit(void) { printk(KERN_INFO "Goodbye,world 2"); } //These two functions to register the module Initialization and module end module_init(hello_2_init); module_exit(hello_2_exit);

__init/__initdata/__exit

In some books on kernel module programming or blogs that introduce kernel module programming, you may find some special keywords like __init, _initdata, __exit, etc. These are actually extended attributes of gcc: __init macros are most commonly used. The place is the definition of the driver module initialization function, the purpose is to put the initialization function of the driver module into the input section named .init.text. When the kernel is booted, the memory in this section will be freed for other uses. The __initdata macro is used for data definitions to put data into an input section called .init.data. Several other macros are similar.

Module description information

You can use modinfo to view the module information of a module. The following is a comparison of the two modules of the module that you have written and the module that comes with the system.

[root@localhost kernel_module]# modinfo hello-1.kofilename: hello-1.kosrcversion: 0D3956C127A907CC9E7114Fdepends: vermagic: 2.6.32-504.12.2.el6.x86_64 SMP mod_unload modversions [root@localhost kernel_module]# modinfo/lib/modules /2.6.32-431.el6.x86_64/kernel/fs/ext4/ext4.ko filename: /lib/modules/2.6.32-431.el6.x86_64/kernel/fs/ext4/ext4.kolicense: GPLdescription: Fourth Extended Filesystemauthor: Remy Card, Stephen Tweedie, Andrew Morton, Andreas Dilger, Theodore Ts'o and others srcversion: 345EBDA2AEFF60FFED78864 depends: mbcache,jbd2 vermagic: 2.6.32-431.el6.x86_64 SMP mod_unload modversions

From the above comparison, the module information of the module I wrote is very small, there is no author information, no license information, etc. In fact, these can be set.

#include #include #include #define DRIVER_AUTHOR "zyf"#define DRIVER_DESC "A sample driver"static int __init init_hello_4(void) { printk(KERN_INFO "Hello, world 4"); return 0; } static void __exit cleanup_hello_4(void) { printk(KERN_INFO "Goodbye , world 4"); } module_init(init_hello_4); module_exit(cleanup_hello_4); //module MODULE_LICENSE("GPL"); //module author MODULE_AUTHOR(DRIVER_AUTHOR); //module description MODULE_DESCRIPTION(DRIVER_DESC);

Module parameter

We should all be clear when writing programs in user mode. It is possible to pass parameters to the program. The same kernel module also has such requirements. The following example shows how to pass parameters to the kernel module:

#include #include #include #include #include MODULE_LICENSE("GPL"); MODULE_AUTHOR("ZYF");static short int myshort = 1;static int myint = 420;static long int mylong = 9999;static char *mystring = "blah";static int myintArray[2] = {-1,-1};static int arr_argc = 0;//You need to use module_param to explain the parameters, indicate the type of this parameter, permissions, etc. charp is a character pointer // define array parameters need to use module_param_arraymodule_param(myshort,short, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP); MODULE_PARM_DESC(myshort,"A short integer"); module_param(myint,int,S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH); MODULE_PARM_DESC(myint,"A integer"); module_param(mylong,long , S_IRUSR); MODULE_PARM_DESC(mylong, "A long integer"); module_param(mystring,charp,0000); MODULE_PARM_DESC(mystring,"A character string"); module_param_array(myintArray,int,&arr_argc,0000); MODULE_PARM_DESC(myintArray, "An array of integer");static int __init hello_5_init(void) { int i; printk(KERN_INFO "Hello, world 5============="); printk(KERN_INFO "myshort is a Short integer: %hd", mysho Rt); printk(KERN_INFO "myint is an integer: %d", myint); printk(KERN_INFO "mylong is a long integer: %ld", mylong); printk(KERN_INFO "mystring is a string: %s", mystring ); for (i = 0; i < (sizeof myintArray / sizeof (int)); i++) { printk(KERN_INFO "myintArray[%d] = %d", i, myintArray[i]); } printk(KERN_INFO " Got %d arguments for myintArray.", arr_argc); return 0; }static void __exit hello_5_exit(void) { printk(KERN_INFO "Goodbye,world 5"); } module_init(hello_5_init); module_exit(hello_5_exit);/* When the module is not specified, the default value is the above. If you want to specify the parameter, you can specify the parameter as follows. Insmod hello-5.ko mystring="superc" myint=444 */

Module file segmentation

When you write a program in user mode, you will split a large program into several files, so that the program context is very clear. Here we write the initialization function and the exit function separately in two files.

#include in start.c /* We're doing kernel work */#include /* specific, a module */int init_module(void) { printk(KERN_INFO "Hello, world - this is the kernel speaking"); return 0; } stop.c#include /* We're doing kernel work */#include /* specific, a module */void cleanup_module() { printk(KERN_INFO "Short is the life of a kernel module"); } Then the Makefile needs to be set to compile when it compiles: obj-m += startstop.o startstop-objs := start.o stop.o all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: make -C /lib/modules/$(shell uname -r )/build M=$(PWD) clean

Vertical Dip Centronic Connector

Vertical Dip Centronic Connector.

Current Rating:5A
Dielectric Withstanding Voltage:1000V for one minute
Insulation Resistance:1000MΩ Min.(at 500V DC)
Contact Resistance:35mΩ Max.
Temperature:-55°C to +105°C

Vertical Dip Centronic Connector

ShenZhen Antenk Electronics Co,Ltd , https://www.antenksocket.com