"深入浅出的Linux内核模块编程指南"

linux

kernel

需积分: 10 73 浏览量更新于2024-02-01 收藏 1.11MB DOC 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

The Linux Kernel Module Programming Guide是一本非常详细的Linux内核开发指导书，由Peter Jay Salzman，Michael Burian，Ori Pomerantz合著。本书的版权归Peter Jay Salzman所有，最新版本为2007-05-18 ver 2.6.4。这本书是免费发布的，读者可以在Open Software License 1.1的许可协议下进行复制和/或修改。你可以在http://opensource.org/licenses/osl.php获取这一许可协议的拷贝。这本书的发行是希望它能够对读者有所帮助，但不提供任何保证，甚至不具备适销性和特定用途的暗示保证。相比中文翻译的一些资料，这本书更为详细，表达清晰，重点突出。是一本非常适合内核进阶和入门者的好书。书中内容包含了Linux内核模块的编程指导，对于想要深入理解Linux内核开发的人们是一份宝贵的参考资料。这本书通过系统地介绍了Linux内核模块的编程，包括了基本概念、实践应用、常见问题和解决方案等内容。它从最基本的概念出发，逐步引导读者学习如何编写和调试内核模块。通过对实际案例的解析，读者可以更直观地了解到内核模块的工作原理和应用场景。不仅如此，书中还深入讲解了内核模块的调试技巧和性能优化方法，帮助读者更好地理解和运用所学知识。此外，书中还介绍了Linux内核开发的一些高级主题，例如多线程编程、设备驱动开发等，为读者拓宽了技术视野，提供了更多的学习资源。通过学习本书，读者可以逐步掌握Linux内核开发的核心技术，成为一名具备深厚理论基础和丰富实践经验的内核开发工程师。综上所述，The Linux Kernel Module Programming Guide是一本非常优秀的Linux内核开发入门指导书。它通过详细的讲解和丰富的案例，帮助读者全面系统地理解和掌握Linux内核模块的编程技术。无论是对于内核开发初学者还是资深工程师来说，这本书都是一份非常宝贵的学习资料，弥足珍贵。希望更多的人能够通过学习这本书，深入理解Linux内核开发的精髓，为软件行业的发展贡献自己的力量。

资源详情

资源推荐

and module_exit() macros. These macros are defined in linux/init.h. The only caveat is that your

init and cleanup functions must be defined before calling the macros, otherwise you'll get compilation errors.

Here's an example of this technique:

Example 2−3. hello−2.c

* hello−2.c − Demonstrating the module_init() and module_exit() macros.

* This is preferred over using init_module() and cleanup_module().

#include <linux/module.h> /* Needed by all modules */

#include <linux/kernel.h> /* Needed for KERN_INFO */

#include <linux/init.h> /* Needed for the macros */

static int init hello_2_init(void)

{

printk(KERN_INFO "Hello, world 2\n");

return 0;

}

static void exit hello_2_exit(void)

{

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

}

module_init(hello_2_init);

module_exit(hello_2_exit);

So now we have two real kernel modules under our belt. Adding another module is as simple as this:

Example 2−4. Makefile for both our modules

obj−m += hello−1.o

obj−m += hello−2.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

Now have a look at linux/drivers/char/Makefile for a real world example. As you can see, some

things get hardwired into the kernel (obj−y) but where are all those obj−m gone? Those familiar with shell

scripts will easily be able to spot them. For those not, the obj−$(CONFIG_FOO) entries you see everywhere

expand into obj−y or obj−m, depending on whether the CONFIG_FOO variable has been set to y or m. While

we are at it, those were exactly the kind of variables that you have set in the linux/.config file, the last

time when you said make menuconfig or something like that.

2.4. Hello World (part 3): The init and exit Macros

This demonstrates a feature of kernel 2.2 and later. Notice the change in the definitions of the init and cleanup

functions. The init macro causes the init function to be discarded and its memory freed once the init

function finishes for built−in drivers, but not loadable modules. If you think about when the init function is

invoked, this makes perfect sense.

There is also an initdata which works similarly to init but for init variables rather than functions.

The exit macro causes the omission of the function when the module is built into the kernel, and like

exit, has no effect for loadable modules. Again, if you consider when the cleanup function runs, this

makes complete sense; built−in drivers don't need a cleanup function, while loadable modules do.

These macros are defined in linux/init.h and serve to free up kernel memory. When you boot your

kernel and see something like Freeing unused kernel memory: 236k freed, this is precisely

what the kernel is freeing.

Example 2−5. hello−3.c

* hello−3.c − Illustrating the init, initdata and exit macros.

#include <linux/module.h> /* Needed by all modules */

#include <linux/kernel.h> /* Needed for KERN_INFO */

#include <linux/init.h> /* Needed for the macros */

static int hello3_data initdata = 3;

static int init hello_3_init(void)

{

printk(KERN_INFO "Hello, world %d\n", hello3_data);

return 0;

}

static void exit hello_3_exit(void)

{

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

}

module_init(hello_3_init);

module_exit(hello_3_exit);

2.5. Hello World (part 4): Licensing and Module

Documentation

If you're running kernel 2.4 or later, you might have noticed something like this when you loaded proprietary

modules:

# insmod xxxxxx.o

Warning: loading xxxxxx.ko will taint the kernel: no license

See http://www.tux.org/lkml/#export−tainted for information about tainted modules

Module xxxxxx loaded, with warnings

In kernel 2.4 and later, a mechanism was devised to identify code licensed under the GPL (and friends) so

people can be warned that the code is non open−source. This is accomplished by the MODULE_LICENSE()

macro which is demonstrated in the next piece of code. By setting the license to GPL, you can keep the

warning from being printed. This license mechanism is defined and documented in linux/module.h:

* The following license idents are currently accepted as indicating free

* software modules

* "GPL" [GNU Public License v2 or later]

* "GPL v2" [GNU Public License v2]

* "GPL and additional rights" [GNU Public License v2 rights and more]

* "Dual BSD/GPL" [GNU Public License v2

* or BSD license choice]

* "Dual MIT/GPL" [GNU Public License v2

* or MIT license choice]

* "Dual MPL/GPL" [GNU Public License v2

* or Mozilla license choice]

* The following other idents are available

* "Proprietary" [Non free products]

* There are dual licensed components, but when running with Linux it is the

* GPL that is relevant so this is a non issue. Similarly LGPL linked with GPL

* is a GPL combined work.

* This exists for several reasons

* 1. So modinfo can show license info for users wanting to vet their setup

* is free

* 2. So the community can ignore bug reports including proprietary modules

* 3. So vendors can do likewise based on their own policies

Similarly, MODULE_DESCRIPTION() is used to describe what the module does,

MODULE_AUTHOR() declares the module's author, and MODULE_SUPPORTED_DEVICE() declares

what types of devices the module supports.

These macros are all defined in linux/module.h and aren't used by the kernel itself. They're simply for

documentation and can be viewed by a tool like objdump. As an exercise to the reader, try and search fo these

macros in linux/drivers to see how module authors use these macros to document their modules.

I'd recommend to use something like grep −inr MODULE_AUTHOR * in /usr/src/linux−2.6.x/ .

People unfamiliar with command line tools will probably like some web base solution, search for sites that

offer kernel trees that got indexed with LXR. (or setup it up on your local machine).

Users of traditional Unix editors, like emacs or vi will also find tag files useful. They can be generated by

make tags or make TAGS in /usr/src/linux−2.6.x/ . Once you've got such a tagfile in your

kerneltree you can put the cursor on some function call and use some key combination to directly jump to the

definition function.

Example 2−6. hello−4.c

* hello−4.c − Demonstrates module documentation.

#include <linux/module.h> /* Needed by all modules */

#include <linux/kernel.h> /* Needed for KERN_INFO */

#include <linux/init.h> /* Needed for the macros */

#define DRIVER_AUTHOR "Peter Jay Salzman <p@dirac.org>"

#define DRIVER_DESC "A sample driver"

static int init init_hello_4(void)

{

剩余63页未读，继续阅读

mmsql

粉丝: 2
资源: 15

会员权益专享

"深入浅出的Linux内核模块编程指南"

Linux内核模块编程指南

linux内核模块编程

linux 内核模块编程

编写linux内核模块

arm Linux内核模块编程入门——Hello World

linux内核网络编程

linux 内核模块开发 pdf

linux内核模块编写

linux内核编程 王利涛

Linux内核的编译过程和方法;Linux内核模块的编写方法；Linux内核模块的加载、卸载方法； Boot Loader的工作过程；U-Boot的第一阶段工作原理和程序。

linux内核编程指南(第三版)

linux内核编程指南(第3版) pdf

linux内核编程指南(第三版)pdf

Linux 系统内核模块的编程

Linux 内核模块的编译方法

linux内核分析与编程

vmwarelinux内核编程

深入探索linux内核

《linux内核的分析及编程》pdf

会员权益专享

最新资源

linux内核编程王利涛