Linux内核模块编程
Linux内核模块编程是一个很重要的知识点。尤其是编写底层驱动程序时，一定会涉及到它。内核模块编程也是Tiger哥学习Linux时第一节课所接触的知识。由此可以看出它的important,也可以看出其实它很easy。
一前言：
1.什么是内核模块
1>内核模块是具有独立功能的程序。它可以被单独编译，但是不能单独运行，它的运行必须被链接到内核作为内核的一部分在内核空间中运行。
2>模块编程和内核版本密切相连，因为不同的内核版本中某些函数的函数名会有变化。因此模块编程也可以说是内核编程。
3>特点：
模块本身不被编译进内核映像，从而控制了内核的大小；
模块一旦被加载，就和内核中的其他部分完全一样。
2.用户层编程和内核模块编程的区别
|
应用程序 |
内核模块程序 |
使用函数 |
libc库 |
内核函数 |
运行空间 |
用户空间 |
内核空间 |
运行权限 |
普通用户 |
超级用户 |
入口函数 |
main() |
module_init |
出口函数 |
exit() |
module_exit |
编译 |
gcc |
makefile |
链接 |
gcc |
insmod |
运行 |
直接运行 |
insmod |
调试 |
gdb |
kdbug、kdb、kgdb |
二.说了这么多，那么怎么编写一个内核模块的程序呢？
1.我们先来看两个最简单的函数实例，也是几乎所有程序员在学习一门新语言时都会编写的程序：输出helloworld!
现在我们分别用模块编程输出helloworld!，和在用户层编程输出hellowrold！。通过这两个程序我们来分析下如何来编写一个内核模块程序。
用户层编程：hello.c
#include<stdio.h>
intmain(void)
{
printf("helloworld/n");
}
内核编程:module.c
#include<linux/init.h>
#include <linux/module.h>
#include<linux/kernel.h>
MODULE_LICENSE("DualBSD/GPL");
static inthello_init(void)
{
printk(KERN_ALERT "hello,I amedsionte/n");
return 0;
}
static voidhello_exit(void)
{
printk(KERN_ALERT"goodbye,kernel/n");
}
module_init(hello_init);
module_exit(hello_exit);
//可选
MODULE_AUTHOR("Tiger-John");
MODULE_DESCRIPTION("Thisis a simple example!/n");
MODULE_ALIAS("A simplestexample");
Tiger-John说明：
1.>相信只要是学过C语言的同学对第一个程序都是没有问题的。但是也许大家看了第二个程序就有些不明白了。
可能有人会说：Tiger哥你没疯吧，怎么会把printf()这么简单的函数错写成了printk()呢。
也有的人突然想起当年在大学学C编程时，老师告诉我们“一个C程序必须要有main()函数，并且系统会首先进入main()函数执行"，那么你的程序怎么没有main()函数呢？没有main()函数程序是怎么执行的呢？
可能也会有更仔细的人会发现：怎么两个程序头文件不一样呢？不是要用到输入和输出函数时，一定要用到<stdio.h>这个头文件，你怎么没有呢？
--------------------------------------------------------------------------------------------
Tiger哥很淡定的告诉大家其实第二个程序是正确的，现在我们就来看看到底如何来编写一个内核模块程序。
2.内核模块编程的具体实现
第一步：首先我们来看一下程序的头文件
#include<linux/kernel.h>
#include<linux/module.h>
#include<linux/init.h>
这三个头文件是编写内核模块程序所必须的3个头文件 。
Tiger-John说明：
1>由于内核编程和用户层编程所用的库函数不一样，所以它的头文件也和我们在用户层编写程序时所用的头文件也不一样。
2>我们在来看看在Linux中又是在那块存放它们的头文件
a.内核头文件的位置：/usr/src/linux-2.6.x/include/
b.用户层头文件的位置:/usr/include/
现在我们就明白了。其实我们在编写内核模块程序时所用的头文件和系统函数都和用层编程时所用的头文件和系统函数是 不同的。
第二步：编写内核模块时必须要有的两个函数:
1>加载函数：
staticint init_fun(void)
{
//初始化代码
}
函数实例：
staticint hello_init(void)// 不加void在调试时会出现报警
{
printk("helloworld!/n");
return0;
}
2>卸载函数无返回值
staticvoid cleaup_fun(void)
{
//释放代码
}
函数实例：
staticvoid hello_exit(void)// 不加void会出现报警,若改为staticint也会报错,因为出口函数是不能返会值的
{
printk("bye,bye/n");
}
在模块编程中必须要有上面这两个函数；
Tiger-John补充：
注册函数和卸载函数还有另一中写法：
1>模块加载函数
staticint __init init_fun(void)
{
//初始化代码
}
函数实例：
staticint __init hello_init(void)
{
printk("hellotiger/n");
return0;
}
2>卸载函数无返回值
staticvoid __exit cleaup_fun(void)
{
//释放代码
}
函数实例：
staticvoid __exit exit(void)
{
printk("byebye!/n");
}
Tiger-John补充：
通过比较我们可以发现第二中函数的写法与第一中函数的写法主要不同就是加了__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()函数的原型：
intprintk(const char *fmt, ...)
消息打印级别：
fmt----消息级别：
#defineKERN_EMERG "<0>" /*紧急事件消息，系统崩溃之前提示，表示系统不可用*/
#defineKERN_ALERT "<1>" /*报告消息，表示必须立即采取措施*/
#defineKERN_CRIT "<2>" /*临界条件，通常涉及严重的硬件或软件操作失败*/
#defineKERN_ERR "<3>" /*错误条件，驱动程序常用 KERN_ERR来报告硬件的错误*/
#defineKERN_WARNING "<4>" /*警告条件，对可能出现问题的情况进行警告*/
#defineKERN_NOTICE "<5>" /*正常但又重要的条件，用于提醒。常用于与安全相关的消息*/
#defineKERN_INFO "<6>" /*提示信息，如驱动程序启动时，打印硬件信息 */
#defineKERN_DEBUG "<7>" /*调试级别的消息*/
Tiger-John说明：
不同级别使用不同字符串表示，数字越小，级别越高。
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()中的参数名就是卸载函数的函数名。
Tiger-John说明：
我们一般在注册函数里进行一些初始化比如申请内存空间注册设备号等。那么我们就要在卸载函数进行释放我们所占有的资源。
(1)若模块加载函数注册了XXX,则模块卸载函数应该注销XXX
(2)若模块加载函数动态申请了内存，则模块卸载函数应该注销XXX
(3)若模块加载函数申请了硬件资源（中断，DMA通道）的占用，则模块卸载函数应该释放这些硬件资源。
(4)若模块加载函数开启了硬件，则卸载函数中一般要关闭硬件。
第四步:许可权限的声明
1>函数实例：
MODULE_LICENSE("DualBSD/GPL")；
2>此处可有可无，可以不加系统默认(但是会报警 )
模块声明描述内核模块的许可权限，如果不声明LICENSE，模块被加载时，将收到内核的警告。
在Linux2.6内核中，可接受的LICENSE包括＂GPL","GPLv2","GPL and additional rights","DualBSD/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-$(shelluname -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：
make-C $(kernel_path) M=$(PWD) modules
//生成内核模块参数为内核源代码目录以及模块所在目录
clean:
make-C $(kernel_path) M=$(PWD) clean
//清除生成的模块文件以及中间文件
Tiger-John说明：
1>在all和clean下面的一行，即make之前必须用Table符隔开，不能用空格隔开，否则编译错误。
2>其中-C后指定的是Linux内核源代码的目录，而M=后指定的是hello.c和Makefile所在的目录
3.Makefile实例：
1obj-m:=module.o
2
3
4 CURRENT_PATH :=$(shell pwd)
5VERSION_NUM :=$(shell uname -r)
6 LINUX_PATH:=/usr/src/linux-headers-$(VERSION_NUM)
7
8 all :
9make -C $(LINUX_PATH) M=$(CURRENT_PATH) modules
10 clean :
11make -C $(LINUX_PATH) M=$(CURRENT_PATH) clean
----------------------------------------------------------------------
经过上面的模块编程和Makefile的编程，我们就可以对我们的程序进行编译链接和运行了
四.内核模块的操作过程
1>在控制台输入make进行编译链接
2>正确后在控制台输入sudoinsmod module.ko（加载模块）
3>在控制台输入dmesg查看结果
4>在控制台输入rmmodtiger(卸载模块)
5>输入dmesg查看结果
(或者用cat/var/log/messages查看系统日志文件）
6>makeclean(去除中间生成的文件）
----------------------------------------------------------------------
现在我们就总体来实践一下,来体验一下。编写内核模块程序的乐趣
module.c
1#include<linux/kernel.h>
2 #include<linux/init.h>
3#include<linux/module.h>
4 MODULE_LICENSE("DualBSD/GPL");
5
6 static int __init hello_init(void)
7 {
8 printk("Hello world/n");
9return 0;
10}
11
12 static void __exit hello_exit(void)
13 {
14 printk("Bye Corne/n");
15
16 }
17module_init(hello_init);
18 module_exit(hello_exit);
Makefile
1obj-m:=module.o
2
3
4 CURRENT_PATH :=$(shell pwd)
5VERSION_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
在终端输入make
think@ubuntu:~/work/moudule/mokua_biancheng$ make
make-C /usr/src/linux-headers-2.6.32-25-genericM=/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
Tiger-John：当程序没有错误时，当我们输入dmesg时就可以看到程序运行的结果了。