Linux驱动篇之内核模块

Linux驱动篇之内核模块

1.基本概念

模块与驱动：

Linux中，将设备分为三种基本的类型。

• 字符设备
• 块设备
• 网络接口

Linux中还有一个很重要的概念，模块。可在运行时添加到内核中的代码被称为模块。一般来说一个设备驱动总是被写成一个模块。

1. 作用：解决内核可拓展性和可维护性相对较差的缺陷
2. 现代内核派系：
   • 宏内核：关键功能和服务均在内核空间提供
     • 运行效率高
     • 可拓展性差
   • 微内核：内核空间只提供关键功能 服务功能在用户空间
     • 运行效率低
     • 安全性 拓展性较高

3. 内核空间与用户空间

对 32 位操作系统而言，它的寻址空间（虚拟地址空间，或叫线性地址空间）为 4G（2的32次方）。也就是说一个进程的最大地址空间为 4G。操作系统的核心是内核(kernel)，它独立于普通的应用程序，可以访问受保护的内存空间，也有访问底层硬件设备的所有权限。为了保证内核的安全，现在的操作系统一般都强制用户进程不能直接操作内核。具体的实现方式基本都是由操作系统将虚拟地址空间划分为两部分，一部分为内核空间，另一部分为用户空间。针对 Linux 操作系统而言，最高的 1G 字节(从虚拟地址 0xC0000000 到 0xFFFFFFFF)由内核使用，称为内核空间。而较低的 3G 字节(从虚拟地址 0x00000000 到 0xBFFFFFFF)由各个进程使用，称为用户空间。
对上面这段内容我们可以这样理解：
每个进程的 4G 地址空间中，最高 1G 都是一样的，即内核空间。只有剩余的 3G 才归进程自己使用。
换句话说就是， 最高 1G 的内核空间是被所有进程共享的！
下图描述了每个进程 4G 地址空间的分配情况：

为什么需要区分内核空间与用户空间:
 在 CPU 的所有指令中，有些指令是非常危险的，如果错用，将导致系统崩溃，比如清内存、设置时钟等。如果允许所有的程序都可以使用这些指令，那么系统崩溃的概率将大大增加。
 所以，CPU 将指令分为特权指令和非特权指令，对于那些危险的指令，只允许操作系统及其相关模块使用，普通应用程序只能使用那些不会造成灾难的指令。比如 Intel 的 CPU 将特权等级分为 4 个级别：Ring0~Ring3。
 其实 Linux 系统只使用了 Ring0 和 Ring3 两个运行级别(Windows 系统也是一样的)。当进程运行在 Ring3 级别时被称为运行在用户态，而运行在 Ring0 级别时被称为运行在内核态。
内核态与用户态
 我们现在需要再解释一下什么是内核态、用户态：
当进程运行在内核空间时就处于内核态，而进程运行在用户空间时则处于用户态。
 在内核态下，进程运行在内核地址空间中，此时 CPU 可以执行任何指令。运行的代码也不受任何的限制，可以自由地访问任何有效地址，也可以直接进行端口的访问。
 在用户态下，进程运行在用户地址空间中，被执行的代码要受到 CPU 的诸多检查，它们只能访问映射其地址空间的页表项中规定的在用户态下可访问页面的虚拟地址，且只能对任务状态段(TSS)中 I/O 许可位图(I/O Permission Bitmap)中规定的可访问端口进行直接访问。
 对于以前的 DOS 操作系统来说，是没有内核空间、用户空间以及内核态、用户态这些概念的。可以认为所有的代码都是运行在内核态的，因而用户编写的应用程序代码可以很容易的让操作系统崩溃掉。
 对于 Linux 来说，通过区分内核空间和用户空间的设计，隔离了操作系统代码(操作系统的代码要比应用程序的代码健壮很多)与应用程序代码。即便是单个应用程序出现错误也不会影响到操作系统的稳定性，这样其它的程序还可以正常的运行(Linux 可是个多任务系统啊！)。
 所以，区分内核空间和用户空间本质上是要提高操作系统的稳定性及可用性。
     其实所有的系统资源管理都是在内核空间中完成的。比如读写磁盘文件，分配回收内存，从网络接口读写数据等等。我们的应用程序是无法直接进行这样的操作的。但是我们可以通过内核提供的接口来完成这样的任务。
 比如应用程序要读取磁盘上的一个文件，它可以向内核发起一个 “系统调用” 告诉内核：“我要读取磁盘上的某某文件”。其实就是通过一个特殊的指令让进程从用户态进入到内核态(到了内核空间)，在内核空间中，CPU 可以执行任何的指令，当然也包括从磁盘上读取数据。具体过程是先把数据读取到内核空间中，然后再把数据拷贝到用户空间并从内核态切换到用户态。此时应用程序已经从系统调用中返回并且拿到了想要的数据，可以开开心心的往下执行了。
 简单说就是应用程序把高科技的事情(从磁盘读取文件)外包给了系统内核，系统内核做这些事情既专业又高效。
 对于一个进程来讲，从用户空间进入内核空间并最终返回到用户空间，这个过程是十分复杂的。举个例子，比如我们经常接触的概念 “堆栈”，其实进程在内核态和用户态各有一个堆栈。运行在用户空间时进程使用的是用户空间中的堆栈，而运行在内核空间时，进程使用的是内核空间中的堆栈。所以说，Linux 中每个进程有两个栈，分别用于用户态和内核态。
下图简明的描述了用户态与内核态之间的转换:

既然用户态的进程必须切换成内核态才能使用系统的资源，那么我们接下来就看看进程一共有多少种方式可以从用户态进入到内核态。概括的说，有三种方式：系统调用、软中断和硬件中断。这三种方式每一种都涉及到大量的操作系统知识，所以这里不做展开。

2.内核模块的相关操作

1. 内核模块的加载与卸载：

   • module_init():加载内核 该函数自动执行 进行初始化操作
   • module_exit():卸载该模块 进行清理卸载内核模块

2. 内核模块信息声明

   • MODULE_LICENSE():表示内核模块接受的软件许可协议 Linux遵循GPL2 v2开源协议
   • MODULE_AUTHOR():描述模块作者信息
   • MODULE_DESCRIPTION():对模块简单介绍
   • MODULE_ALIAS():给模块其一个别名

3. #include <linux/init.h>		/*包含了moudule_init以及exit()函数的声明*/
   #include <linux/kernel.h>	/*包含内核提供的各种函数*/
   #include <linux/module.h>	/*包含了模块信息的声明相关函数*/
   

4. 内核模块打印函数：

   • printf:工作与用户空间 gilbc函数实现

   • printk:内核模块无法使用gilbc函数 内核自身实现的一个类printff函数 但是需要指定的打印等级。 不设置的时候 会使用默认打印等级 只有小于设置的打印等级才可以打印

   • #define KERN_EMERG		<0>通常是系统崩溃前的信息
     #define KERN ALERT		<1>需要立即处理的消息
     #define KERN_CRIT		<2>严重情况
     #define KERN ERR		<3>错误情况
     #define KERN WARNING	<4>有问题的情况
     #define KERN_NOTICE		<5>注意信息
     #define KERN INFO		<6>普通消息
     #define KERN DEBUG		<7>调试信息
     

   • 查看当前的打印等级：cat /proc/sys/kernel/printk 打印内核所有信息 : dmesg

   • 

   • 当前控制台日志级别		默认消息日志的级别		最小的控制台级别		默认控制台级别
     		4					4						1					7
     

5. Linux数据段

   • 进程（执行的程序）会占用一定数量的内存，它或是用来存放从磁盘载入的程序代码，或是存放取自用户输入的数据等等。不过进程对这些内存的管理方式因内存用途 不一而不尽相同，有些内存是事先静态分配和统一回收的，而有些却是按需要动态分配和回收的。对任何一个普通进程来讲，它都会涉及到5种不同的数据段

   • 

   • BSS段：BSS段（bss segment）通常是指用来存放程序中未初始化的全局变量的一块内存区域。BSS是英文Block Started by Symbol的简称。BSS段属于静态内存分配。

     数据段：数据段（data segment）通常是指用来存放程序中已初始化的全局变量的一块内存区域。数据段属于静态内存分配。

     代码段：代码段（code segment/text segment）通常是指用来存放程序执行代码的一块内存区域。这部分区域的大小在程序运行前就已经确定，并且内存区域通常属于只读, 某些架构也允许代码段为可写，即允许修改程序。在代码段中，也有可能包含一些只读的常数变量，例如字符串常量等。

     堆（heap）：堆是用于存放进程运行中被动态分配的内存段，它的大小并不固定，可动态扩张或缩减。当进程调用malloc等函数分配内存时，新分配的内存就被动态添加到堆上（堆被扩张）；当利用free等函数释放内存时，被释放的内存从堆中被剔除（堆被缩减）

     栈(stack)：栈又称堆栈， 是用户存放程序临时创建的局部变量，也就是说我们函数括弧“{}”中定义的变量（但不包括static声明的变量，static意味着在数据段中存放变量）。除此以外，在函数被调用时，其参数也会被压入发起调用的进程栈中，并且待到调用结束后，函数的返回值也会被存放回栈中。由于栈的后进先出特点，所以栈特别方便用来保存/恢复调用现场。从这个意义上讲，我们可以把堆栈看成一个寄存、交换临时数据的内存区。

     它是由操作系统分配的，内存的申请与回收都由OS管理

   • 在驱动开发中：有____init以及 ____exit :

     __init将函数放在".init.text"这个代码区中，__initdata将数据放在".init.data"这个数据区中。

     eixt同理

6. 模块参数：module_param(name,type,perm)

   • 参数：

     • name:参数名
     • type:参数类型 eg:int byte,bool,charp
     • perm:读写权限
       • 不允许设置可执行权限
       • 在/sys/module/模块名/parameters 目录下会生成该参数对应的文件名
         • 如果是0 则不会生成相应的文件名

   • 模块参数可以在运行insmod或modprobe命令装载模块时赋值，modprobe可以从配置文件（/etc/modprobe.conf）中读取参数值。

     在insmod改变模块参数之前，模块必须让参数对insmod命令可见。参数使用 module_param(变量名，类型，访问许可值) 宏来声明，在源文件头部声明参数

     所有的模块参数都应该在源文件中给定一个默认值

   • #include <linux/fs.h>
     #include <linux/init.h>					/*包含了moudule_init以及exit()函数的声明*/
     #include <linux/kernel.h>			/*包含内核提供的各种函数*/
     #include <linux/module.h>		/*包含了模块信息的声明相关函数*/
     
     /*******************定义变量与宏******************/
     
     static int itype=0;
     module_param(itype,int,0);//不会生成相应的文件名
     
     static bool btype=0;
     module_param(btype,bool,0644);
     
     static char ctype=0;
     module_param(ctype,byte,0);
     
     static char *stype=0;
     module_param(stype,charp,0644);
     
     /*
     内核模块入口
     */
     static int __init param_init(void) {//__init表示将param_init函数存放在 __init段里存放所有的内核模块入口
     
     	printk(KERN_ALERT"param init!\r\n");
     	printk(KERN_ALERT"itype=%d !\r\n",itype);
     	printk(KERN_ALERT"btype=%d !\r\n",btype);
     	printk(KERN_ALERT"ctype=%d !\r\n",ctype);
     	printk(KERN_ALERT"stype=%s !\r\n",stype);
     
         return 0;
     }
     
     /*
     内核模块出口
     */
     static void __exit param_exit(void) {
         printk(KERN_ALERT "退出喽。。。。\r\n");
     }
     /******************************************************************************************************************/
     
     module_init(param_init);
     module_exit(param_exit);
     

   • 

   • 

   • 通过终端向内核参数赋值了

7. 符号共享

   内核模块可以共享导出的符号表

   • 变量共享
   • 函数共享

   API:EXPORT_SYMBOL(sym)

   ​ 作用：EXPORT_SYMBOL标签内定义的函数或者符号对全部内核代码公开，不用修改内核代码就可以在您的内核模块中直接调用，即使 用EXPORT_SYMBOL可以将一个函数以符号的方式导出给其他模块使用。

​ 参数：变量名或函数名

​ 查看符号表： cat /proc/kallsys | grep xxx

​

查看共享符号表：ca proc/kallsyms | xxx

所有依赖模块一起编译

clean伪目标证据清除共享文件夹指令

模块加载时先加载依赖

卸载时相反

相关命令：depmod -a 建立模块依赖关系

​ 查看模块依赖关系 cat /lib/modules/内核版本/modules.dep

​ 卸载模块极其依赖：modprob -r xx

/*******test_export_symbol.c部分代码******/
#include "test_export_symbol.h"

/*
内核模块入口
*/
static int __init test_export_init(void) {  //__init  表示将chrdevbase函数存放在  __init段里  存放所有的内核模块入口
    
	printk(KERN_ALERT "param init!\r\n");
	printk(KERN_ALERT "itype+1=%d,itype-1=%d !\r\n",my_add(itype,1),my_sub(itype,1));

    return 0;
}

/*******test_export_symbol.h部分代码******/

#ifndef  __TEST_EXPORT_SYMBOL_H__
#define __TEST_EXPORT_SYMBOL_H__

	extern int itype;

	int my_add(int a ,int b );
	int my_sub(int a ,int b );

#endif
/*******test_param.c部分代码******/
int my_add(int a, int b)
{

	return  a+b;

}
int my_sub(int a, int b)
{

	return  a-b;

}
EXPORT_SYMBOL(itype);//共享变量
EXPORT_SYMBOL(my_add);//恭享函数
EXPORT_SYMBOL(my_sub);

t b );

#endif
/*test_param.c部分代码/
int my_add(int a, int b)
{

return  a+b;

}
int my_sub(int a, int b)
{

return  a-b;

}
EXPORT_SYMBOL(itype);//共享变量
EXPORT_SYMBOL(my_add);//恭享函数
EXPORT_SYMBOL(my_sub);

[外链图片转存中...(img-POA2cG0t-1651577791828)]