ldd3学习之二：构造和运行模块

Myth丶恋晨 2022-06-18 03:21 170阅读 0赞

1.设置测试系统：

①设置一套内核源码树，比如/usr/src/linux-2.6.x,参考 [http://www.kernel.org/][http_www.kernel.org]

eg:uname -r  --->2.6.32-27-generic

wget [http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.32.27.tar.gz][http_www.kernel.org_pub_linux_kernel_v2.6_linux-2.6.32.27.tar.gz]

②直接用发行版的内核源码包，比如 /lib/modules/$(shell uname -r),包含内核目标链接文件。

2.hello world模块

1.  \#include <linux/init.h>  
    
2.  \#include <linux/module.h>  
    
3.  MODULE\_LICENSE("Dual BSD/GPL");  
    
4.    
    
5.  static int hello\_init(void)  
    
6.  \{   
    
7.      printk(KERN\_ALERT"hello,world.\\n");  
    
8.      return 0;  
    
9.  \}  
    
10. static void hello\_exit(void)  
    
11. \{   
    
12.     printk(KERN\_ALERT"Goodbye,cruel world.\\n");  
    
13. \}  
    
14. module\_init(hello\_init);  
    
15. module\_exit(hello\_exit);

Makefile文件

1.  \#如果已定义KERNELRELEASE，则说明是从内核构造系统调用的
2.  \#因此可利用其内建语句
3.  ifneq ($(KERNELRELEASE),)  
    
4.      obj\-m := hello.o  
    
5.  \#否则，是直接从命令行调用的，这是要调用内核构造系统
6.  else  
    
7.      KERNELDIR ?= /lib/modules/$(shell uname \-r)/build  
    
8.      PWD := $(shell pwd)  
    
9.  default:  
    
10.     $(MAKE) \-C $(KERNELDIR) M=$(PWD) modules  
    
11. endif

make编译，然后用insmod安装，用dmesg可以在终端看到输出信息，或者输出到某个日志文件里比如/var/log/messages.

linux的模块并不复杂， 真正的困难在于理解设备并最大化其性能

3.内核模块的特点。

①模块仅仅被链接到内核，因此能调用的函数仅仅是由内核导出的那些函数，不存在任何可链接的函数库。

②内核函数不支持浮点运算。

③Unix使用两个级别，内核态和用户态。当处理器有多个级别时，使用最高级别和最低级别。

④每当应用程序执行系统调用或者被硬件中断挂起时，Unix从用户空间切换到内核空间。

⑤系统调用的代码运行在进程上下文，可以访问进程所有数据。而处理硬件中断的内核代码和进程是异步的，与任一个特定进程无关。

⑥一个驱动程序要执行两类任务：模块中的某些函数作为系统调用的一部分执行（实现用户API），而其他函数则负责中断处理。

⑦内核具有非常小的栈，可能只有4K大小页。我们自己的函数必须和整个内核空间调用链一同共享这个栈，如果需要大的结构，应该在调用时动态分配。

4.内核中的并发

linux2.6中内核代码已经是可抢占的。

①编写内核代码时，时刻铭记：同一时刻，可能会有许多事情正在发生。

②linux内核代码（包括驱动代码）必须是可重入的。

5.当前进程current

内核代码可通过访问全局项current来获得当前进程，current在 中定义，是一个指向struct task\_struct的指针。

在2.6中，current不再是一个全局变量，指向task\_stuct结构的指针隐藏在内核栈中，current是一个可以获得这个结构的宏，包含 即可引用。

1.  \#include <linux/sched.h>  
    
2.    
    
3.  printk(KERN\_INFO"The process is \\"%s\\" (pid %i)\\n",current\->comm,current\->pid);

6.编译和装载

对hello world模块，Makefile只要一行就可以了：obj-m := hello.o

如果要构造的模块名module.ko由两个源文件生成，file1.c,file2.c，则：

1.  obj\-m := module.o  
    
2.  module.o\-objs := file1.o file2.o

装载：sudo insmod hello.ko

查看：lsmod

卸载：sudo rmmod hello

7.内核符号表

公共内核符号表中包含了所有的全局内核项（函数和变量）的地址，模块被装载后，它所导出的任何符号都会变成内核符号表的一部分。

模块层叠技术在复杂项目中非常有用，modprobe是处理层叠技术的一个使用工具，功能类似insmod.通过层叠技术，可以将模块划分为多个层，通过简化每个层，可缩短开发时间。

8 .hello world模块代码分析

1.  \#include <linux/init.h>    //指定初始化和清除函数
2.  \#include <linux/module.h>  //包含可装载模块需要的大量符号和函数的定义
3.  //所有模块代码中都包含这两行
4.    
    
5.  MODULE\_LICENSE("Dual BSD/GPL");//制定许可证，一般用"GPL"或者"Dual BSD/GPL"
6.    
    
7.  static int \_\_init hello\_init(void)     //\_\_init表示初始化函数执行完之后就释放内存  
    
8.  \{   
    
9.      printk(KERN\_ALERT"hello,world.\\n");  
    
10.     return 0;  
    
11. \}  
    
12. static void \_\_exit hello\_exit(void) //\_\_exit表示在卸载是执行，编译器把这类函数放在特殊的ELF段中  
    
13. \{   
    
14.     printk(KERN\_ALERT"Goodbye,cruel world.\\n");  
    
15. \}  
    
16. module\_init(hello\_init);  
    
17. module\_exit(hello\_exit);//

1.  9.初始化过程中的错误处理
2.  如果注册设施时遇到任何错误，首先判断模块是否可以继续初始化，通常，在某个注册失败后可以通过降低功能来继续运行。因此，只要可能，模块应该继续向前并尽可能提供功能。
3.  若发生的特定类型错误之后无法继续装载模块，则出错之前的任何注册工作都要撤销（未撤销，内核可能不稳定）。
4.  一个典型的错误处理模板
5.  1.  int \_\_init my\_init\_function(void)  
        
    2.  \{   
        
    3.      int err;  
        
    4.    
        
    5.      err = register\_this(ptr1,"skull");  
        
    6.      if (err)  
        
    7.          goto fail\_this;  
        
    8.      err = register\_that(ptr2,"skull");  
        
    9.      if (err)  
        
    10.         goto fail\_that;  
        
    11.     err = register\_those(ptr3,"skull");  
        
    12.     if (err)  
        
    13.         goto fail\_those  
        
    14.   
        
    15.     return 0; // success  
        
    16.   
        
    17. fail\_those: unregister\_that(ptr2,"skull");  
        
    18. fail\_that:unreister\_this(ptr1,"skull");  
        
    19. fail\_this: return err;  
        
    20. \}
6.  清除函数撤销所有设施
7.  1.  void \_\_exit my\_cleanup\_function(void)  
        
    2.  \{   
        
    3.      unregister\_those(ptr3,"skull");  
        
    4.      unregister\_that(ptr2,"skull");  
        
    5.      unregister\_this(ptr1"skull");  
        
    6.      return;  
        
    7.  \}
8.  一个典型的清除函数模板
9.  1.  struct something \* item1;  
        
    2.  struct something \* item2;  
        
    3.    
        
    4.  void my\_cleanup(void)  
        
    5.  \{   
        
    6.      if (item1)  
        
    7.          release\_thing(item1);  
        
    8.      if (item2)  
        
    9.          release\_thing2(item2);  
        
    10.     if (stuff\_ok)  
        
    11.         unregister\_stuff();  
        
    12.     return;  
        
    13. \}  
        
    14.   
        
    15. int \_\_init my\_init(void)  
        
    16. \{   
        
    17.     int err = \-ENOMEM;  
        
    18.   
        
    19.     item1 = allocate\_thing(arg);  
        
    20.     item2 = allocate\_thing2(arg2);  
        
    21.     if (!item1||!item2)  
        
    22.         goto fail;  
        
    23.     err = register\_stuff(item1,item2);  
        
    24.     if (!err)  
        
    25.         stuff\_ok = 1;  
        
    26.     else goto fail;  
        
    27.     retrun 0;  
        
    28. fail:  
        
    29.     my\_cleanup();  
        
    30.     return err;  
        
    31. \}
10. 这种方式的初始化能够很好地扩展到对大量设施的支持。
11. 模块装载竞争：在用来支持某个设施的所有内部初始化完成之前，不要注册任何设施。
12. 10.模块参数
13. 内核允许对驱动程序指定参数，而这些参数可在装载驱动程序模块时改变。
    
    1.  static char \*whom = "world";  
        
    2.  static int howmany = 10;  
        
    3.  module\_param(howmany,int ,S\_IRUGO);  
        
    4.  module\_param(whom,charp,S\_IRUGO);  
        
    5.  module\_param(name,type,num,perm);  
        
    6.  name\-\-数组名字  
        
    7.  type\-\-数组元素类型  
        
    8.  num\-\-数组个数  
        
    9.  perm\-\-访问许可值
    10. insmod hello.ko whom=yuyunbo howmany=5
14. 模块装载器会拒绝接受超过数组大小的值
15.   
    
16. 本章新符号总结（函数，变量，宏等）

1.  insmod，modprobe，rmmod，lsmod，dmesg

1.  用来装载模块到正运行的内核和移除模块的用户空间工具

1.  \#include

module\_init(init\_function);

module\_exit(cleanup\_function);

用于指定模块的初始化和清除函数的宏。

\_\_init,\_\_initdata,\_\_exit,\_\_exitdata

仅用于模块初始化或清除阶段的函数(\_\_init和\_exit)和数据(\_\_initdta和\_\_exitdata)标记。

\#include

最重要的头文件之一，该文件包含驱动程序使用的大部分内核API的定义，包括睡眠函数以及各种变量声明。

struct task\_struct \*current;

当前进程