【Linux开发】linux设备驱动归纳总结（二）：模块的相关基础概念

linux设备驱动归纳总结（二）：模块的相关基础概念

系统平台：Ubuntu 10.04

开发平台：S3C2440开发板

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

一。初探linux内核模块

内核模块：内核本身是很庞大的一个结构，需要的组件很多。编译内核时，用户 可以把所有的代码编译进内核，但是这样会引起两个问题：一是内核过大；二是 当需要添加或者删除内核时，需要重新再编译内核。所以有了内核模块的概念。 模块并不编译到内核中，编译后存放在指定的目录，当需要使用时动态加载。

1.1下面是一个非常经典的hello world代码： 目录：1st

/*2nd_module/1st*/

1 #include //包含了很多装载模块需要的符号和函数的定义

2 #include //用于指定初始化函数和清除函数

3

4 static int __init test_init(void) //内核初始化函数

5 {

6         printk("hello world!\n"); //打印函数，和prinft类似

7         return 0;

8 }

9

10 static void __exit test_exit(void)//内核清除函数

11 {

12         printk("good bye!\n");

13 }

14

15 module_init(test_init); //指定初始化函数

16 module_exit(test_exit); //指定清除函数

17

18 MODULE_LICENSE("GPL"); //指定代码使用的许可证

19 MODULE_AUTHOR("xiao bai"); //指定作者

20 MODULE_VERSION("1.0"); //指定代码修订号

1.2再来一个Makefile：

(注：如果不知道“make -C $(KDIR) M=`pwd` modules ”语句的意思，可以查看linux内核驱动归纳总结（一）：内核的相关基础概念的第六小节)

obj-m += test.o

KDIR:=/root/Desktop/drives/nfsroot-29/linux-2.6.29

all:

make -C $(KDIR) M=`pwd` modules

clean:

make -C $(KDIR) M=`pwd` modules clean

rm -f modules.order

1.3编写完毕后在代码目录下执行“make”命令，就会产生test.ko文件，在开发板
上通过命令“insmod test.ko”,插入模块，通过命令“lsmod”查看当前的所有 装载上的模块，通过命令“rmmod
test”卸载该模块。并且，加载时会输出 “hello world!”，卸载时会输出“good bye!”。

[root: 1st]# rmmod test

good bye!

[root: 1st]# insmod test.ko

hello world!

[root: 1st]# lsmod

test 1060 0 - Live 0xbf00c000

[root: 1st]# rmmod test

good bye!

[root: 1st]#

1.4上面的程序包含了三个知识点：

1.4.1内核初始化函数：

static int __init test_init(void) //内核初始化函数

{

}

module_init(test_init); //指定初始化函数

1)初始化函数是在模块加载时自动被调用，执行相关的初始化工作。

2)static和__init都是可以不加的，因为初始化函数除了加载时执行外没有别的 用处，加上static只是声明一下，该函数只能在模块内部使用。而加上__init后，它暗
示内核该函数仅在初始化时使用，所以在模块被装载后，模块装载器就会把该函 数扔掉，释放占用的内存空间。

3)但是moudle_init()是必须要的，因为这样才能让模块加载器知道这是个初始化 函数，没有这一步，函数就不会得到调用。

4)初始化函数成功返回0，失败返回对应的错误码。

1.4.2内核清除函数：

static void __exit test_exit(void)//内核清除函数

{

}

module_exit(test_exit); //指定清除函数

1)内核清除函数是在模块卸载是自动被调用，执行相关的清除工作。

2)同上，static和__exit都是可以不加的，但如果加上__exit，模块直接编
译进内核或者不允许卸载，被标志为__exit的函数会被自动丢弃掉。

3)module_exit是必须的，因为这样内核才能找到清除函数。

4)清除函数的没有返回值。

5)一个没有定义清除函数的模块，是不允许被加载的。

1.4.3模块的描述性定义：

MODULE_LICENSE("GPL"); //指定代码使用的许可证

MODULE_AUTHOR("xiao bai"); //指定作者

MODULE_VERSION("1.0"); //指定代码修订号

1)以上的都是一些都该模块的描述，除了上面的还有MODULE_ALIAS(模块的别名)
MODULE_DESCRIPTION(描述用途)等。

2)MODULE_LICENSE一般都是要写的，告诉内核该程序使用的许可证，不然在加载 时它会提示该模块污染内核。

3)MODULE_声明可以声明在源代码任意位置，但习惯放在代码的最后。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

二。内核中的printk

printk与printf的用法是差不多的，最大的区别就是printk可以指定打印的优先
级。另外一个区别就是，printf只用在用户态，printk用于内核态。

下面由程序讲解 目录：2nd

/*2nd_module/2nd*/

1 #include

2 #include

3

4 static int __init test_init(void)

5 {

6         printk("hello world!\n");

7         printk("<0>" "hello world! 0\n");

8         printk("<1>" "hello world! 1\n");

9         printk("<2>" "hello world! 2\n");

10       printk("<3>" "hello world! 3\n");

11       printk("<4>" "hello world! 4\n");

12       printk("<5>" "hello world! 5\n");

13       printk("<6>" "hello world! 6\n");

14       printk("<7>" "hello world! 7\n");

15       return 0;

16 }

17

18 static void __exit test_exit(void)

19 {

20         printk("good bye!\n");

21 }

22

23 module_init(test_init);

24 module_exit(test_exit);

25

26 MODULE_LICENSE("GPL");

27 MODULE_AUTHOR("xiao bai");

28 MODULE_VERSION("1.0");

编译后加载模块，发现输出内容为：

[root: 2nd]# insmod test.ko

hello world!

hello world! 0

hello world! 1

hello world! 2

hello world! 3

hello world! 4

hello world! 5

hello world! 6

输出唯独缺少了最后一个"hello world! 7"，这是因为printk输出优先级的导致 的。printk的优先级如下,在内核目录下inxlude/linux/kernel.h下有记录：

91 #define KERN_EMERG "<0>" /* system is unusable */

92 #define KERN_ALERT "<1>" /* action must be taken immediately */

93 #define KERN_CRIT "<2>" /* critical conditions */

94 #define KERN_ERR "<3>" /* error conditions */

95 #define KERN_WARNING "<4>" /* warning conditions */

96 #define KERN_NOTICE "<5>" /* normal but significant condition */

97 #define KERN_INFO "<6>" /* informational */

98 #define KERN_DEBUG "<7>" /* debug-level messages */

其中<0>的优先级最高，<7>优先级最低。上面的printk语句的优先级都可以用字符
串代替，如下面两句是同等作用的：

p { margin-bottom: 0.21cm; }

printk("<3>" "hello world! 3\n");

printk(KERN_ERR "hello world! 3\n")

如果调用printk使用的优先级低于或等于控制台的默认优先级，就不能被输出到 控制台终端上显示，所以在minicom界面中看不到最后一句的输出。

按照以上的推测，可以得到两个结论：

一、如果不指定prinfk的优先级，prinfk的默认优先级比控制台的优先级高，所 以才能显示在控制台上。

二、控制台的优先级是6，因为低于6优先级的语句不能打印出来。

printk的默认优先级在内核目录kernel/printk.c定义：

47 /* printk's without a loglevel use this.. */

48 #define DEFAULT_MESSAGE_LOGLEVEL 4 /* KERN_WARNING */

49

50 /* We show everything that is MORE important than this.. */

51 #define MINIMUM_CONSOLE_LOGLEVEL 1 /* Minimum loglevel we let people use */

52 #define DEFAULT_CONSOLE_LOGLEVEL 7 /* anything MORE serious than KERN_DEBUG*/

文件中定义了printk的默认输出优先级为4，并定义了一般使用的最大和最小优先 级1和7。

而终端控制台的输出优先级配置在文件/proc/sys/kernel/printk中：

[root: /]# cat /proc/sys/kernel/printk

7 4 1 7

7 4 1 7分别是：

7：console_loglevel //这个就是控制台的默认优先级

4：default_message_loglevel // 这个是printk的默认输出优先级

1：minimum_console_level

7：default_console_loglevel

可以通过修改该文件使所有优先级的消息都显示出来。

[root: /]# echo 8 > /proc/sys/kernel/printk

注意的是，即使没有显示在控制台的内核消息，也会追加到/var/log/messages，通过查看/var/log/messages就能看到。

小技巧：可以通过printk的优先级定义是否输出调试信息：目录：3rd

1 #include

2 #include

3

4 #define DEBUG_SWITCH 0

5 #if DEBUG_SWITCH

6         #define P_DEBUG(fmt, args...) printk("<1>" "[%s]"fmt, __FUNCTION__, ##args)

7 #else

8         #define P_DEBUG(fmt, args...) printk("<7>"
"[%s]"fmt, __FUNCTION__, ##args)

9 #endif

10

11

12 static int __init test_init(void)

13 {

14         printk("hello world!\n");

15         P_DEBUG("debug!\n");

16         return 0;

17 }

18

19 static void __exit test_exit(void)

20 {

21         printk("good bye!\n");

22 }

23

24 module_init(test_init);

25 module_exit(test_exit);

26

27 MODULE_LICENSE("GPL");

28 MODULE_AUTHOR("xiao bai");

29 MODULE_VERSION("1.0");

当#define DEBUG_SWITCH 0时，P_DEBUG语句并不输出到控制台。

相反，当#define DEBUG_SWITCH 1时，P_DEBUG语句输出到控制台。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

三。内核传参————module_param

在用户态的C语言中，函数的传参使用main(int argc, char* argv)，内核的传参使用了另外一种方法：

步骤一、在内核函数中用module_param指定模块参数。

步骤二、加载内核时传递参数给模块。

module_param函数使用方法：

module_param(name, type, perm)

name：内核参数的名称，自己定义；

type：内核参数的类型，常见的类型byte、short、int、long、ulong、bool 、charp(字符指针);

perm：内核参数的权限S_IRUGO(对模块参数具有读权限)。其实权限和文件的
权限差不多，具体可以查看"include/linux/stat.h"。

所以，要定义一个int模块参数，权限是0644，在函数中需要定义：

int a=0;

module_paaram(a, int, 0644);

内核加载模块时传递参数的方法：

使用命令：insmod xxx.ko a=1

如果加载模块时不指定参数，模块会使用默认值0，否则会使用1。

模块加载后，并且他的权限不为0，就可以在/sys/module/xxx/parameter目录下 找到对应的模块参数。

模块参数使用例子：目录 4th

/*2nd_module/4th*/

1 #include

2 #include

3

4 int num = 123;

5 char *name = "xiao bai";

6

7 static int __init test_init(void)

8 {

9         printk("hello world!\n");

10        printk("num = %d, name:[%s]\n",
num, name);

11        return 0;

12 }

13

14 static void __exit test_exit(void)

15 {

16        printk("good bye!\n");

17 }

18

19 module_init(test_init);

20 module_exit(test_exit);

21 module_param(num, int, 0644);

22 module_param(name, charp, 0644);

23

24 MODULE_LICENSE("GPL");

25 MODULE_AUTHOR("xiao bai");

26 MODULE_VERSION("1.0");

几种指定模块参数时的效果：

[root: 4th]# insmod test.ko

hello world!

num = 123, name:[xiao bai]

[root: 4th]# rmmod test

good bye!

[root: 4th]# insmod test.ko num=321 name='haha'

hello world!

num = 321, name:[haha]

[root: 4th]# rmmod test

good bye!

[root: 4th]# insmod test.ko name='haha'

hello world!

num = 123, name:[haha]

查看/sys/module/test/parameter目录，出现了模块参数：

[root: 4th]# ls /sys/module/test/parameters/

name num

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

四、内核函数间的调用

内核函数间的调用有两种方法：

1)、把需要调用的函数编译进模块，与C语言的静态库类似。

2)、把许压迫被调用的函数导出到符号表，方便模块使用，与C语言的动态库类似

先说第一个方法：多文件编译 目录 5th

1)编写被调用的函数文件haha.c

1 #include

2 #include "haha.h"

3

4 void haha(void)

5 {

6         printk("haha!\n");

7 }

2)编写头文件haha.h

1 #ifndef __HAHA_H__

2 #define __HAHA_H__

3

4 void haha(void);

5

6 #endif

3)编写模块文件test.c

1 #include

2 #include

3 #include "haha.h"

4

5 static int __init test_init(void)

6 {

7         printk("hello world!\n");

8         haha();

9         return 0;

10 }

11

12 static void __exit test_exit(void)

13 {

14         printk("good bye!\n");

15 }

16

17 module_init(test_init);

18 module_exit(test_exit);

19

20 MODULE_LICENSE("GPL");

21 MODULE_AUTHOR("xiao bai");

22 MODULE_VERSION("1.0");

4)编写Makefile，与之前的Makefile不一样，因为涉及到多文件编译

1 obj-m += test_haha.o //生成test_haha.ko

2 test_haha-objs += haha.o test.o //test_haha.ko有haha.o和test.o组成

3

4 KDIR:=/root/Desktop/drives/nfsroot-29/linux-2.6.29

5 all:

6         make -C $(KDIR) M=`pwd` modules

7 clean:

8         make -C $(KDIR) M=`pwd` modules
clean

9         rm -f modules.order

编译完毕后生成test_haha,ko，看一下效果

[root: 5th]# insmod test_haha.ko

hello world!

haha!

值得指出的是，上面的方法一般不用。应该使用下面的方法。

第二种方法：导出符号表EXPORT_SYMBOL ：目录 6th

导出符号表是指，在定义一个函数后，在模块中使用语句"EXPORT_SYMBOL(xxxxx)" 将函数导出。通过这样，内核就知道了该函数和在内存中对应的地址，这样模块 就可以调用导出的函数了。在"/proc/kallsyms"文件中对应这符号表，它记录了函数的符号和函数在内存所在的地址。

看看方法：

1)在6th/core目录下编写被调用的函数的文件haha.c

1 #include

2 #include

3 #include "../include/haha.h"

4

5 int haha(void)

6 {

7         printk("haha!\n");

8         return 0;

9 }

10

11 EXPORT_SYMBOL(haha); //导出函数

12 MODULE_LICENSE("GPL");

2）在6th/core目录下编写Makefile，用于编译haha.c成haha.ko

1 obj-m += haha.o

2

3 KDIR:=/root/Desktop/drives/nfsroot-29/linux-2.6.29

4 all:

5         make -C $(KDIR) M=`pwd` modules

6 clean:

7         make -C $(KDIR) M=`pwd` modules
clean

8         rm -f modules.order

3)在6th/include目录下编写头文件haha.h

1 #ifndef __HAHA_H__

2 #define __HAHA_H__

3

4 int haha(void);

5

6 #endif

4)在6th/driver目录下编写文件test.c

1 #include

2 #include

3 #include "../include/haha.h"

4

5 static int __init test_init(void)

6 {

7         printk("hello world!\n");

8         haha();

9         return 0;

10 }

11

12 static void __exit test_exit(void)

13 {

14         printk("good bye!\n");

15 }

16

17 module_init(test_init);

18 module_exit(test_exit);

19

20 MODULE_LICENSE("GPL");

21 MODULE_AUTHOR("xiao bai");

22 MODULE_VERSION("1.0");

5)在6th/driver目录下编写Makefile，用于编译test.c

1 obj-m += test.o

2

3 KDIR:=/root/Desktop/drives/nfsroot-29/linux-2.6.29

4 all:

5         make -C $(KDIR) M=`pwd` modules

6 clean:

7         make -C $(KDIR) M=`pwd` modules
clean

8         rm -f modules.order

最终会生成两个文件，一个是core目录下的haha.ko，一个是driver目录下的 test.ko。这两个文件的加载也要讲究顺序。

如果先加载test.ko的话会出错：

[root: driver]# insmod test.ko

test: Unknown symbol haha

insmod: cannot insert 'test.ko': unknown symbol in module or invalid parameter

这是因为内核不能找到函数haha：

[root: core]# cat /proc/kallsyms | grep haha //没有显示任何东西

所以需要先加载模块haha.ko，这样就可以在/proc/kallsyms中找到

[root: /]# cd review_driver/2nd_module/6th/core/

[root: core]# insmod haha.ko

[root: core]# cat /proc/kallsyms | grep haha

00000000 a haha.c [haha]

bf000000 t $a [haha]

bf00001c t $d [haha]

bf000044 r __kstrtab_haha [haha]

c4827080 ? __mod_license12 [haha]

bf000054 r __ksymtab_haha [haha]

bf000054 r $d [haha]

00000000 a haha.mod.c [haha]

c482708c ? __module_depends [haha]

c4827098 ? __mod_vermagic5 [haha]

bf000280 d __this_module [haha]

bf000000 T haha [haha]

c0225c10 u printk [haha]

[root: core]#

到出符号表之后就可以加载模块test.ko了

[root: core]# cd ../driver/

[root: driver]# insmod test.ko

hello world!

haha!

随便提一下两个小问题：

1)、函数是必须有"#include "

原因一：printk的调用需要

原因二：如果不加上面的命令就不会显示"bf000000 T haha [haha]", 而显示"bf000000 t haha [haha]"，小写t表示该符号未定义。

2）、模块的引用技术：

[root: 6th]# insmod core/haha.ko

[root: 6th]# lsmod

haha 904 0 - Live 0xbf000000 //0 无引用

[root: 6th]# insmod driver/test.ko

hello world!

haha!

[root: 6th]# lsmod

test 1084 0 - Live 0xbf003000

haha 904 1 test, Live 0xbf000000 //被引用一次，test模块引用

可以看到，加载了test.ko时，haha模块产生了变化，如果卸载的时候先卸载haha 是不可以的，因为它还被人引用，必须先卸载test。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

源代码：

 2nd_module.rar