Linux内核是一个整体是结构，因此向内核添加任何东西，或者删除某些功能，都十分困难。为了解决这个问题引入了内核机制。从而可以动态的想向核中添加或者删除模块。

模块不被编译在内核中，因而控制了内核的大小.然而模块一旦被插入内核，他就和内核其他部分一样.这样一来就会曾家一部分系统开销。同时，如果模块出现问题，也许会带来系统的崩溃。

模块的实现机制：

启动时，由函数 void inti_modules() 来初始化模块，因为启动事很多时候没有模块.这个函数往往把内核自身当作一个虚模块。

如由系统需要，则调用一系列以sys 开头的函数，对模块进行操作. 如:

sys_creat_modules()，sys_inti_modules() ， 

sys_deldte_modules()等等.

这里会用到一些模块的数据就结构，在/usr/scr/Linux/include/Linux/module.h 中，有兴趣的朋友可以找出来一看块的加入有两种方法:一是手动加入:如:insmod modulename.另一种是根据需要，动态的加载模块：如你执行命令:

$mount -t msdos /dev/hdd /mnt/d 时.系统便自动加载 FAT模块，以支持MSDOS的文件系统。

模块编程

写一个模块，必须有一定的多进程编程基础，因为你变得程序不是以一个独立的程序的来运行的。另外，因为，模块需要在内核模式下运行，会遇到在内和空间和用户空间数据交换的问题.一般的数据复制函数无法完成这一个过程。因此系统已入了一些特殊的函数以用来完成内核空间和用户空间数据的交换/

这些函数有:void put _user (type valude，type *u_addr)

memcpy_tofs()

等等，有兴趣的朋友可以仔细的看看所有的函数，以及他们的用法.需要说明的是.模块编程河内核的版本有很大的关系。如果版本不通可能造成，内核模块不能编译，或者.在运行这个模块时，出现不可测结果。如:系统崩溃等。

明白了这些以后，你就可以尝试着编写内核模块了。对于每一个内核模块来说，必定包含两个函数int init_module() 这个函数在插入内核时启动，在内核中注册一定的功能函数，或者用他的代码代替内和中某些函数的内容(估计这些函数是空的)。因此，内和可以安全的卸载。

int cleanup_module() 当内核模块谢载时，调用.将模块从内核中清除.

同其他的程序设计教程一样 ，我们给出一个hello world 的例子

1. /*hello.c a module programm*/ 
2. /* the program runing under kernel mod and it is a module*/ 
3. #include" Linux/kernerl.h" 
4. #include"lLinux/module.h" 
5. /* pross the CONFIG_MODVERSIONS*/ 
6. #if CONFIG_MODVERSIONS==1 
7. #define MODVERSIONS 
8. #include""Linux/modversions.h" 
9. #end if 
10. /* the init function*/ 
11. int init_module() 
12. { 
13. printk(" hello world !n'); 
14. printd(" I have runing in a kerner mod@!!n"); 
15. return 1; 
16. } 
17. /* the distory function*/ 
18. int cleanup_module() 
19. { 
20. printk(" I will shut down myself in kernerl mod /n)"; 
21. retutn 0; 
22. } 

这样一个例子就完成了.我们也写一个makefile 的例子,以适于我们在大程序重的应用。一下是makfile 文件的内容 。

1. # a makefile for a module 
2. CC=gcc 
3. MODCFLAGS:= -Wall _DMODULE -D_KERNEL_ -DLinux 
4. hello.o hello.c /usr/inculde?Linux/version.h 
5. CC $(MODCFLAGS) 0c hello.c 
6. echo the module is complie completely 

然后你运行make 命令 得到hello.o 这个模块,运行hello.o 这个模块,运行

1. $insmod hello.o 
2. hello world! 
3. I will shut down myself in kernerl mod 
4. $lsmod 
5. hello (unused) 
6. …. 
7. $remmod 
8. I will shut down myself in kernerl mod 

这样你的模块就可以随意的插入和删除了。

Linux中的大部分驱动程序，是以模块的形式编写的，这些驱动程序源码可以修改到内核中，也可以把他们编译成模块形势，在需要的时候动态加载。

一个典型的驱动程序，大体上可以分为这么几个部分:

1．注册设备

在系统初启，或者模块加载时候，必须将设备登记到相应的设备数组，并返回设备的主驱动号，例如:对快设备来说调用 refister_blkdec()将设备添加到数组blkdev中，并且获得该设备号，并利用这些设备号对此数组进行索引。对于字符驱动设备来说，要使用 module_register_chrdev()来获得祝设备的驱动号，然后对这个设备的所有调用都用这个设备号来实现。

2．定义功能函数

对于每一个驱动函数来说，都有一些和此设备密切相关的功能函数，那最常用的块设备或者字符设备来说，都存在着诸如 open() read() write() ioctrol()这一类的操作。当系统社用这些调用时，将自动的使用驱动函数中特定的模块，来实现具体的操作。而对于特定的设备，上面的系统调用对应的函数是一定的。

如:在块驱动设备中.当系统试图读取这个设备(即调用read()时)，就会运行驱动程序中的block_read() 这个函数。

打开新设备时会调用这个设备驱动程序的device_open() 这个函数.

3．卸载模块

在不用这个设备时，可以将他卸载，主要是从/proc 中取消这个设备的特殊文件，可用特定的函数实现。

下面我们列举一个字符设备驱动程序的框架.来说明这个过程.

1. /* a module of a character device */ 
2. /* some include files*/ 
3. #include"param.h" 
4. #include"user.h" 
5. #include"tty.h" 
6. #include"dir.h" 
7. #include”fs.h" 
8. /* the include files modules need*/ 
9. #include"Linux/kernel.h" 
10. #include"Linux/module.h" 
11. #if CONFIG_MODBERSIONS==1 
12. degine MODBERSIONS 
13. #include" Linux.modversions.h" 
14. #endif 
15. #difine devicename mydevice 
16. /* the init funcion*/ 
17. int init_module() 
18. { 
19. int tag=module_register_chrdev(0，mydevice，&Fops); 
20. if (tag<0) 
21. { 
22. printk("the device init is erro!n"); 
23. return 1; 
24. } 
25. return 0; 
26. } 
27. /*the funcion which the device will be used */ 
28. int device_open () 
29. { 
30. ……. 
31. } 
32. int device_read () 
33. { 
34. ……. 
35. } 
36. int device_write () 
37. { 
38. ……. 
39. } 
40. int device_ioctl () 
41. { 
42. ……. 
43. } 
44. …… 
45. /* the deltter function of this module*/ 
46. int cleanup_module() 
47. { 
48. int re=module_unregister_chrdev(tag，mydevice); 
49. if( re<0) 
50. { 
51. printk("erro unregister the module !!n"); 
52. return 1; 
53. } 
54. return 0; 
55. } 

Tags: Linux操作系统 内核模块

分享到：