Linux Module编程

一前言：

1. 什么是内核模块

1> 内核模块是具有独立功能的程序。它可以被单独编译，但是不能单独运行，它的运行必须被链接到内核作为内核的一部分在内核空间中运行。

2> 模块编程和内核版本密切相连，因为不同的内核版本中某些函数的函数名会有变化。因此模块编程也可以说是内核编程。

3> 特点：

模块本身不被编译进内核映像，从而控制了内核的大小；

模块一旦被加载，就和内核中的其他部分完全一样。

2 . 用户层编程和内核模块编程的区别

应用程序	内核模块程序
使用函数	libc库	内核函数
运行空间	用户空间	内核空间
运行权限	普通用户	超级用户
入口函数	main()	module_init
出口函数	exit()	module_exit
编译	gcc	makefile
链接		insmod
运行	直接运行
调试	gdb	kdbug、kdb、kgdb

二 . 说了这么多，那么怎么编写一个内核模块的程序呢？

1. 我们先来看两个最简单的函数实例，也是几乎所有程序员在学习一门新语言时都会编写的程序：输出 hello world!

现在我们分别用模块编程输出 hello world! ，和在用户层编程输出 hello wrold ！。通过这两个程序我们来分析下如何来编写一个内核模块程序。

用户层编程： hello.c

#include<stdio.h>

int main(void)

{

printf("hello world/n");

}

内核编程 : module.c

#include <linux/init.h>

#include <linux/module.h>

#include <linux/kernel.h>

MODULE_LICENSE("Dual BSD/GPL");

static int hello_init(void)

printk(KERN_ALERT "hello,I am edsionte/n");

return 0;

static void hello_exit(void)

printk(KERN_ALERT "goodbye,kernel/n");

module_init(hello_init);

module_exit(hello_exit);

// 可选

MODULE_AUTHOR("Tiger-John");

MODULE_DESCRIPTION("This is a simple example!/n");

MODULE_ALIAS("A simplest example");

2. 内核模块编程的具体实现

第一步：首先我们来看一下程序的头文件

#include<linux/kernel.h>

#include<linux/module.h>

#include<linux/init.h>

这三个头文件是编写内核模块程序所必须的 3 个头文件 。

Tiger-John 说明：

1> 由于内核编程和用户层编程所用的库函数不一样，所以它的头文件也和我们在用户层编写程序时所用的头文件也不一样。

2> 我们在来看看在 L inux 中又是在那块存放它们的头文件

a. 内核头文件的位置 ： /usr/src/linux-2.6.x/include/

b. 用户层头文件的位置 : /usr/include/

现在我们就明白了。其实我们在编写内核模块程序时所用的头文件和系统函数都和用层 编程时所用的头文件和系统函数是 不同的。

第二步： 编写内核模块时必须要有的两个函数 :

1> 加载函数：

static int init_fun(void)

// 初始化代码

函数实例：

static int hello_init(void)// 不加 void 在调试时会出现报警

printk("hello world!/n");

2> 卸载函数 无返回值

static void cleaup_fun(void)

// 释放代码

static void hello_exit(void)// 不加 void 会出现报警 , 若改为 static int 也会报错 , 因为出口函数是不能返会值的

printk("bye,bye/n");

在模块编程中必须要有上面这两个函数；

Tiger-John补充：

注册函数和卸载函数还有另一中写法：

1> 模块加载函数

static int __init init_fun(void)

static int __init hello_init(void)

printk("hello tiger/n");

static void __exit cleaup_fun(void)

static void __exit exit(void)

printk("bye bye!/n");

通过比较我们可以发现第二中函数的写法与第一中函数的写法主要不同就是加了 __init 和 __exit 前缀。 (init 和 exit 前面都是两个下划线 )

那么第二种方法比第一种有什么好处呢：

_init 和__exit 是Linux 内核的一个宏定义，使系统在初始化完成后释放该函数，并释放其所占内存。因此它的优点是显而易见的。所以建议大家啊在编写入口函数和出口函数时采用第二中方法。

(1)在linux内核中，所有标示为__init的函数在连接的时候都放在.init.text这个区段内，此外，所有的__init函数在区段.initcall.init 中还保存了一份函数指针，在初始化时内核会通过这些函数指针调用这些__init函数，并在初始化完成后释放init区段（包括.init.text,.initcall.init等）。

(2)和__init一样，__exit也可以使对应函数在运行完成后自动回收内存。

3 > 现在我们来看一下 printk() 函数

a. 上面已经说了，我们在内核 编程时所用的库函数和在用户态下的是不一样的。 printk是内核态信息打印函数，功能和比准 C 库的 printf 类似。 printk 还有信息打印级别。

b. 现在我们来看一下 printk() 函数的原型：

int printk(const char *fmt, ...)

消息打印级别：

fmt---- 消息级别：

#define KERN_EMERG "<0>" /* 紧急事件消息，系统崩溃之前提示，表示系统不可用 */

#define KERN_ALERT "<1>" /* 报告消息，表示必须立即采取措施 */

#define KERN_CRIT "<2>" /* 临界条件，通常涉及严重的硬件或软件操作失败 */

#define KERN_ERR "<3>" /* 错误条件，驱动程序常用 KERN_ERR 来报告硬件的错误 */

#define KERN_WARNING "<4>" /* 警告条件，对可能出现问题的情况进行警告 */

#define KERN_NOTICE "<5>" /* 正常但又重要的条件，用于提醒。常用于与安全相关的消息 */

#define KERN_INFO "<6>" /* 提示信息，如驱动程序启动时，打印硬件信息 */

#define KERN_DEBUG "<7>" /* 调试级别的消息 */

c.为什么内核态使用 printk() 函数，而在用户态使用 printf() 函数。

printk() 函数是直接使用了向终端写函数 tty_write() 。而 printf() 函数是调用 write() 系统调用函数向标准输出设备写。所以在用户态（如进程 0 ）不能够直接使用 printk() 函数，而在内核态由于它已是特权级，所以无需系统调用来改变特权级，因而能够直接使用 printk() 函数。 printk 是内核输出，在终端是看不见的。我们可以看一下系统日志。

但是我们可以使用命令： cat /var/log/messages ，或者使用 dmesg 命令看一下输出的信息。

第三步： 加载模块和卸载模块

1>module_init(hello_init)

a. 告诉内核你编写模块程序从那里开始执行。

b.module_init() 函数中的参数就是注册函数的函数名。

2>module_exit(hello_exit)

a. 告诉内核你编写模块程序从那里离开。

b.module_exit() 中的参数名就是卸载函数的函数名。

我们一般在注册函数里进行一些初始化比如申请内存空间注册设备号等 。那么我们就要在卸载函数进行释放我们所占有的资源。

(1)若模块加载函数注册了XXX,则模块卸载函数应该注销XXX

(2)若模块加载函数动态申请了内存，则模块卸载函数应该注销XXX

(3)若模块加载函数申请了硬件资源（中断，DMA通道）的占用，则模块卸载函数应该释放这些硬件资源。

(4) 若模块加载函数开启了硬件，则卸载函数中一般要关闭硬件。

第四步 : 许可权限的声明

1> 函数实例：

MODULE_LICENSE("Dual BSD/GPL") ；

2> 此处可有可无，可以不加系统默认 ( 但是会报警 )

模块声明描述内核模块的许可权限，如果不声明 LICENSE ，模块被加载时，将收到内核的警告。

在 Linux2.6 内核中，可接受的 LICENSE 包括＂ GPL","GPL v2","GPL and additional rights","Dual BSD/GPL","Dual MPL/GPL","Proprietary" 。

第五部：模块的声明与描述（可加可不加）

MODULE_AUTHOR(“author”);// 作者

MODULE_DESCRIPTION(“description”);// 描述

MODULE_VERSION(”version_string“);// 版本

MODULE_DEVICE_TABLE(“table_info”);// 设备表

对于USB，PCI等设备驱动，通常会创建一个MODULE_DEVICE_TABLE

MODULE_ALIAS(”alternate_name“);// 别名

Tiger-John:总结

经过以上五步（其实只要前四步）一个完整的模块编程就完成了。

第六步:常用的模块编程命令：

1>在Linux系统中，使用lsmod命令可以获得系统中加载了的所有模块以及模块间的依赖关系

2>也可以用cat /proc/modules 来查看加载模块信息

3>内核中已加载模块的信息也存在于/sys/module目录下，加载hello.ko后，内核中将包含/sys/module/hello目录，该目录下又包含一个refcnt文件和一个sections目录，在/sys/module/hello 目录下运行tree -a可以看到他们之间的关系。

4>使用modinfo <模块名>命令可以获得模块的信息，包括模块的作者，模块的说明，某块所支持的参数以及vermagic.

但是，前面我们已经说过了。内核编程和用户层编程它们之间的编译

链接也不相同。那么我们 如何对模块程序进行编译，链接，运行呢？

现在我么继续深入来学习 Makefile 文件的编写：

三 .make 的使用以及 Makefile 的编写

1. 什么是 Makefile ， make

1>Makefile 是一种脚本，这种脚本主要是用于多文件的编译

2> make 程序可以维护具有相互依赖性的源文件，但某些文件发生改变时，它能自动识别出，

并只对相应 文件进行自动编译

2.Makefile 的写法

Makefile 文件由五部分组成：显示规则 含规则 变量定义 makefile 指示符和注释

一条 Make 的规则原型为：

目标 ... ：依赖 ..

命令

...

…

makefile 中可以使用 Shell 命令，例如 pwd ， uname

简单的 makefile 文件：

obj-m := hello.o

kernel_path=/usr/src/linux-headers-$(shell uname -r)

all:

make -C $(kernel_path) M=$(PWD) modules

clean:

make -C $(kernel_path) M=$(PWD) clean

obj-m:= hello.o // 产生 hello 模块的目标

kernel_path // 定义内核源文件目录

all ：

// 生成内核模块参数为内核源代码目录以及模块所在目录

// 清除生成的模块文件以及中间文件

Tiger-John说明：

1>在 all和 clean下面的一行，即 make之前必须用 Table符隔开，不能用空 格隔开，否则编译错误 。

2>其中 -C后指定的是 Linux内核源代码的目录，而 M=后指定的是 hello.c和 Makefile所在的目录

3.Makefile实例：

1 obj-m:=module.o

2

3

4 CURRENT_PATH :=$(shell pwd)

5 VERSION_NUM :=$(shell uname -r)

6 LINUX_PATH :=/usr/src/linux-headers-$(VERSION_NUM)

7

8 all :

9 make -C $(LINUX_PATH) M=$(CURRENT_PATH) modules

10 clean :

11 make -C $(LINUX_PATH) M=$(CURRENT_PATH) clean

----------------------------------------------------------------------

经过上面的模块编程和 Makefile 的编程，我们就可以对我们的程序进行编译链接和运行了

四 . 内核模块的操作过程

1> 在控制台输入 make 进行编译链接

2> 正确后在控制台输入 sudo insmod module.ko （加载模块）

3> 在控制台输入 dmesg 查看结果

4> 在控制台输入 rmmod tiger( 卸载模块 )

5> 输入 dmesg 查看结果

( 或者用 cat /var/log/messages 查看系统日志文件）

6>make clean( 去除中间生成的文件）

现在我们就总体来实践一下 , 来体验一下。编写内核模块程序的乐趣

module.c

1 #include<linux/kernel.h>

2 #include<linux/init.h>

3 #include<linux/module.h>

4 MODULE_LICENSE("Dual BSD/GPL");

5

6 static int __init hello_init(void)

7 {

8 printk("Hello world/n");

9 return 0;

10 }

11

12 static void __exit hello_exit(void)

13 {

14 printk("Bye Corne/n");

15

16 }

17 module_init(hello_init);

18 module_exit(hello_exit);

Makefile

在终端输入 make

think@ubuntu:~/work/moudule/mokua_biancheng$ make

make -C /usr/src/linux-headers-2.6.32-25-generic M=/home/think/work/moudule/mokua_biancheng modules

make[1]: 正在进入目录 `/usr/src/linux-headers-2.6.32-25-generic'

Building modules, stage 2.

MODPOST 1 modules

make[1]: 正在离开目录 `/usr/src/linux-headers-2.6.32-25-generic'

think@ubuntu:~/work/moudule/mokua_biancheng$

think@ubuntu:~/work/moudule/mokua_biancheng$ sudo insmod module.ko

think@ubuntu:~/work/moudule/mokua_biancheng$ dmesg

[19011.002597] Hello world