Linux内核模块编程指南

需积分: 9 60 浏览量更新于2024-07-15 收藏 605KB PDF 举报

"The Linux Kernel Module Programming Guide.pdf 是一本由Peter Jay Salzman、Michael Burian和Ori Pomerantz编写的指南，旨在教导读者如何编写Linux内核模块。这本书基于Open Software License 1.1版发布，并鼓励无限制地广泛传播和修改，但需保留原始的版权信息。" 在Linux系统中，内核模块（Kernel Modules）是可插入和可移除的代码片段，它们扩展了内核的功能，使得用户可以根据需要加载或卸载特定功能。《Linux Kernel Module Programming Guide》这本指南详细介绍了如何开发和维护这些模块，是Linux开发者的重要参考资料。本书的核心内容可能包括以下几个关键知识点： 1. **内核模块的基本结构**：书中会介绍内核模块的基本组成元素，如模块头文件（`<linux/module.h>`）、初始化函数（`init_module()`）和退出函数（`cleanup_module()`），以及如何通过`module_init()`和`module_exit()`宏将它们链接到内核生命周期。 2. **模块的编译与加载**：讲解如何使用`make`命令编译模块，以及使用`insmod`、`rmmod`和`modprobe`等工具来管理模块的加载和卸载。 3. **内核调用与数据结构**：详细介绍如何使用内核提供的API和数据结构来访问硬件、管理系统资源、处理中断、调度任务等。 4. **内存管理**：涵盖内核中的内存分配和释放机制，如`kmalloc()`和`kfree()`，以及内核地址空间和用户空间的交互。 5. **中断处理和设备驱动**：讨论如何编写设备驱动程序，包括中断处理函数、设备注册和注销、I/O操作等。 6. **同步与并发控制**：深入讲解内核中的锁机制，如自旋锁（spinlock）、读写锁（rwlock）、信号量（semaphore）等，以及原子操作（atomic operations），用于保证多线程环境下的数据一致性。 7. **调试技术**：介绍内核模块的调试方法，如使用`printk()`进行日志输出，以及使用`syslogd`、`kdb`和`gdb`进行更复杂的调试。 8. **模块参数**：讲解如何定义和使用模块参数，以便在加载模块时传递配置信息。 9. **错误处理和模块回滚**：讨论如何优雅地处理内核模块运行时的错误，以及如何设计回滚机制以在出现问题时恢复系统状态。通过学习这本指南，开发者可以了解Linux内核的工作原理，并具备编写内核模块的能力，从而能够为Linux系统添加定制化的功能或驱动，提升系统的灵活性和扩展性。对于希望深入理解Linux内核并从事相关开发工作的人员来说，这本书是一份宝贵的资源。

2020/8/19 The Linux Kernel Module Programming Guide

tldp.org/LDP/lkmpg/2.6/html/lkmpg.html 14/81

2.6. Passing Command Line Arguments to

a Module

Modules can take command line arguments, but not with the argc/argv you might be used

to.

To allow arguments to be passed to your module, declare the variables that will take the

values of the command line arguments as global and then use the module_param() macro,

(defined in linux/moduleparam.h) to set the mechanism up. At runtime, insmod will fill the

variables with any command line arguments that are given, like ./insmod mymodule.ko

myvariable=5. The variable declarations and macros should be placed at the beginning of

the module for clarity. The example code should clear up my admittedly lousy explanation.

The module_param() macro takes 3 arguments: the name of the variable, its type and

permissions for the corresponding file in sysfs. Integer types can be signed as usual or

unsigned. If you'd like to use arrays of integers or strings see module_param_array() and

module_param_string().

int myint = 3;

module_param(myint, int, 0);

Arrays are supported too, but things are a bit different now than they were in the 2.4. days.

To keep track of the number of parameters you need to pass a pointer to a count variable

as third parameter. At your option, you could also ignore the count and pass NULL instead.

We show both possibilities here:

int myintarray[2];

module_param_array(myintarray, int, NULL, 0); /* not interested in count */

int myshortarray[4];

int count;

module_parm_array(myshortarray, short, , 0); /* put count into "count" variable */

A good use for this is to have the module variable's default values set, like an port or IO

address. If the variables contain the default values, then perform autodetection (explained

elsewhere). Otherwise, keep the current value. This will be made clear later on.

Lastly, there's a macro function, MODULE_PARM_DESC(), that is used to document arguments that

the module can take. It takes two parameters: a variable name and a free form string

describing that variable.

Example 2-7. hello-5.c

* hello-5.c - Demonstrates command line argument passing to a module.

#include <linux/module.h>

#include <linux/moduleparam.h>

#include <linux/kernel.h>

#include <linux/init.h>

#include <linux/stat.h>

MODULE_LICENSE("GPL");

2020/8/19 The Linux Kernel Module Programming Guide

tldp.org/LDP/lkmpg/2.6/html/lkmpg.html 15/81

MODULE_AUTHOR("Peter Jay Salzman");

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;

* module_param(foo, int, 0000)

* The first param is the parameters name

* The second param is it's data type

* The final argument is the permissions bits,

* for exposing parameters in sysfs (if non-zero) at a later stage.

module_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, "An 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(name, type, num, perm);

* The first param is the parameter's (in this case the array's) name

* The second param is the data type of the elements of the array

* The third argument is a pointer to the variable that will store the number

* of elements of the array initialized by the user at module loading time

* The fourth argument is the permission bits

module_param_array(myintArray, int, &arr_argc, 0000);

MODULE_PARM_DESC(myintArray, "An array of integers");

static int __init hello_5_init(void)

{

int i;

printk(KERN_INFO "Hello, world 5\n=============\n");

printk(KERN_INFO "myshort is a short integer: %hd\n", myshort);

printk(KERN_INFO "myint is an integer: %d\n", myint);

printk(KERN_INFO "mylong is a long integer: %ld\n", mylong);

printk(KERN_INFO "mystring is a string: %s\n", mystring);

for (i = 0; i < (sizeof myintArray / sizeof (int)); i++)

{

printk(KERN_INFO "myintArray[%d] = %d\n", i, myintArray[i]);

}

printk(KERN_INFO "got %d arguments for myintArray.\n", arr_argc);

return 0;

}

static void __exit hello_5_exit(void)

{

printk(KERN_INFO "Goodbye, world 5\n");

}

module_init(hello_5_init);

module_exit(hello_5_exit);

I would recommend playing around with this code:

satan# insmod hello-5.ko mystring="bebop" mybyte=255 myintArray=-1

mybyte is an 8 bit integer: 255

myshort is a short integer: 1

myint is an integer: 20

mylong is a long integer: 9999

2020/8/19 The Linux Kernel Module Programming Guide

tldp.org/LDP/lkmpg/2.6/html/lkmpg.html 17/81

obj-m += hello-1.o

obj-m += hello-2.o

obj-m += hello-3.o

obj-m += hello-4.o

obj-m += hello-5.o

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

This is the complete makefile for all the examples we've seen so far. The first five lines are

nothing special, but for the last example we'll need two lines. First we invent an object

name for our combined module, second we tell make what object files are part of that

module.

2.8. Building modules for a precompiled

kernel

Obviously, we strongly suggest you to recompile your kernel, so that you can enable a

number of useful debugging features, such as forced module unloading

(MODULE_FORCE_UNLOAD): when this option is enabled, you can force the kernel to unload a

module even when it believes it is unsafe, via a rmmod -f module command. This option

can save you a lot of time and a number of reboots during the development of a module.

Nevertheless, there is a number of cases in which you may want to load your module into a

precompiled running kernel, such as the ones shipped with common Linux distributions, or

a kernel you have compiled in the past. In certain circumstances you could require to

compile and insert a module into a running kernel which you are not allowed to recompile,

or on a machine that you prefer not to reboot. If you can't think of a case that will force

you to use modules for a precompiled kernel you might want to skip this and treat the rest

of this chapter as a big footnote.

Now, if you just install a kernel source tree, use it to compile your kernel module and you

try to insert your module into the kernel, in most cases you would obtain an error as

follows:

insmod: error inserting 'poet_atkm.ko': -1 Invalid module format

Less cryptical information are logged to /var/log/messages:

Jun 4 22:07:54 localhost kernel: poet_atkm: version magic '2.6.5-1.358custom 686

REGPARM 4KSTACKS gcc-3.3' should be '2.6.5-1.358 686 REGPARM 4KSTACKS gcc-3.3'

In other words, your kernel refuses to accept your module because version strings (more

precisely, version magics) do not match. Incidentally, version magics are stored in the

module object in the form of a static string, starting with vermagic:. Version data are

剩余80页未读，继续阅读

lc970972279

粉丝: 1
资源: 3

Linux内核模块编程指南

LINUX内核的三本经典书籍+linux内核API+linux设备模型资料

中文The Linux Kernel Module Programming Guide.pdf

Linux内核编程（pdf）

The linux kernel module programming guide.pdf

Linux Kernel Module Programming Guide.chm

The Linux Kernel Module Programming Guide2.6.pdf

The Linux Kernel Module Programming Guide 2.6.pdf

The Linux Kernel Module Programming Guide_2.4.pdf

The Linux Kernel Module Programming Guide 2.6 pdf版

Linux Kernel Programming Guide.pdf

最新资源