3. Linux内核模块实验

3.1. hellomodule实验

3.1.1. 实验说明

3.1.1.1. 硬件介绍

本节实验使用Lubancat_RK系列板卡。

3.1.2. 实验代码讲解

本章的示例代码目录为：linux_driver/module/hellomodule

从前面我们已经知道了内核模块的工作原理，这一小节就开始写代码了，下面就展示一个最简单hellomodule框架。

hellomodule框架
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/kernel.h>

 static int __init hello_init(void)
 {
     printk(KERN_EMERG "[ KERN_EMERG ]  Hello  Module Init\n");
     printk( "[ default ]  Hello  Module Init\n");
     return 0;
 }

 static void __exit hello_exit(void)
 {
     printk("[ default ]   Hello  Module Exit\n");
 }

 module_init(hello_init);
 module_exit(hello_exit);

 MODULE_LICENSE("GPL2");
 MODULE_AUTHOR("embedfire ");
 MODULE_DESCRIPTION("hello module");
 MODULE_ALIAS("test_module");

接来下理解每一行代码的含义，并最终在Linux上运行这个模组，验证我们前面的理论，也为下一章驱动打下基础。

3.1.2.1. 代码框架分析

Linux内核模块的代码框架通常由下面几个部分组成：

  • 模块加载函数(必须)： 当通过insmod或modprobe命令加载内核模块时，模块的加载函数就会自动被内核执行，完成本模块相关的初始化工作。

  • 模块卸载函数(必须)： 当执行rmmod命令卸载模块时，模块卸载函数就会自动被内核自动执行，完成相关清理工作。

  • 模块许可证声明(必须)： 许可证声明描述内核模块的许可权限，如果模块不声明，模块被加载时，将会有内核被污染的警告。

  • 模块参数： 模块参数是模块被加载时，可以传值给模块中的参数。

  • 模块导出符号： 模块可以导出准备好的变量或函数作为符号，以便其他内核模块调用。

  • 模块的其他相关信息： 可以声明模块作者等信息。

上面示例的hello module程序只包含上面三个必要部分以及模块的其他信息声明(模块参数和导出符号将在下一节实验出现)。

头文件包含了<linux/init.h>和<linux/module.h>，这两个头文件是写内核模块必须要包含的。 模块初始化函数hello_init调用了printk函数，在内核模块运行的过程中，他不能依赖于C库函数， 因此用不了printf函数，需要使用单独的打印输出函数printk。该函数的用法与printf函数类似。 完成模块初始化函数之后，还需要调用宏module_init来告诉内核，使用hello_init函数来进行初始化。 模块卸载函数也用printk函数打印字符串，并用宏module_exit在内核注册该模块的卸载函数。 最后，必须声明该模块使用遵循的许可证，这里我们设置为GPL2协议。

3.1.2.2. 头文件

前面我们已经接触过了Linux的应用编程，了解到Linux的头文件都存放在/usr/include中。 编写内核模块所需要的头文件，并不在上述说到的目录，而是在Linux内核源码中的include文件夹。

  • #include <linux/module.h>： 包含内核模块信息声明的相关函数

  • #include <linux/init.h>： 包含了 module_init()和 module_exit()函数的声明

  • #include <linux/kernel.h>： 包含内核提供的各种函数，如printk

编写内核模块中经常要使用到的头文件有以下两个：<linux/init.h>和<linux/module.h>。 我们可以看到在头文件前面也带有一个文件夹的名字linux，对应了include下的linux文件夹，我们到该文件夹下，查看这两个头文件都有什么内容。

init.h头文件(位于内核源码 /include/linux/init.h)
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
#define pure_initcall(fn)            __define_initcall(fn, 0)

#define core_initcall(fn)            __define_initcall(fn, 1)
#define core_initcall_sync(fn)               __define_initcall(fn, 1s)
#define postcore_initcall(fn)                __define_initcall(fn, 2)
#define postcore_initcall_sync(fn)   __define_initcall(fn, 2s)
#define arch_initcall(fn)            __define_initcall(fn, 3)
#define arch_initcall_sync(fn)               __define_initcall(fn, 3s)
#define subsys_initcall(fn)          __define_initcall(fn, 4)
#define subsys_initcall_sync(fn)     __define_initcall(fn, 4s)
#define fs_initcall(fn)                      __define_initcall(fn, 5)
#define fs_initcall_sync(fn)         __define_initcall(fn, 5s)
#define rootfs_initcall(fn)          __define_initcall(fn, rootfs)
#define device_initcall(fn)          __define_initcall(fn, 6)
#define device_initcall_sync(fn)     __define_initcall(fn, 6s)
#define late_initcall(fn)            __define_initcall(fn, 7)
#define late_initcall_sync(fn)               __define_initcall(fn, 7s)

#define __initcall(fn) device_initcall(fn)

#define __exitcall(fn)                                               \
   static exitcall_t __exitcall_##fn __exit_call = fn

Init.h头文件主要包含了一些宏定义，还有内核的initcall机制。

module.h头文件(位于内核源码/include/linux/module.h)
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
   /* Generic info of form tag = "info" */
   #define MODULE_INFO(tag, info) __MODULE_INFO(tag, tag, info)

   #define MODULE_ALIAS(_alias) MODULE_INFO(alias, _alias)
   #define MODULE_LICENSE(_license) MODULE_INFO(license, _license)

   #define MODULE_AUTHOR(_author) MODULE_INFO(author, _author)

   #define module_init(x)    __initcall(x);

   #define module_exit(x)    __exitcall(x);

以上代码中，列举了module.h文件中有内核模块的加载、卸载函数的声明，还有一部分宏定义，有的是可有可无的，但是MODULE_LICENSE这个是指定该内核模块的许可证，是必须要有的。

3.1.2.3. 模块加载/卸载函数

module_init

回忆我们使用单片机时，假设我们要使用串口等外设时，是不是都需要调用一个初始化函数， 在这个函数里面，我们初始化了串口的GPIO，配置了串口的相关参数，如波特率，数据位，停止位等等参数。 func_init函数在内核模块中也是做与初始化相关的工作。

内核模块加载函数(位于内核源码/linux/init.h)
static int __init func_init(void)
{
}
module_init(func_init);

返回值：

  • 0： 表示模块初始化成功，并会在/sys/module下新建一个以模块名为名的目录，如下图中的红框处

  • 非0： 表示模块初始化失败

加载模块成功

在C语言中，static关键字的作用如下：

  1. static修饰的静态局部变量直到程序运行结束以后才释放，延长了局部变量的生命周期。

  2. static的修饰全局变量只能在本文件中访问，不能在其它文件中访问。

  3. static修饰的函数只能在本文件中调用，不能被其他文件调用。

内核模块的代码，实际上是内核代码的一部分， 假如内核模块定义的函数和内核源代码中的某个函数重复了， 编译器就会报错，导致编译失败，因此我们给内核模块的代码加上static修饰符的话， 那么就可以避免这种错误。

__init、__initdata宏定义(位于内核源码/linux/init.h)
1
2
#define __init __section(.init.text) __cold notrace
#define __initdata __section(.init.data)

以上代码 __init、__initdata宏定义(位于内核源码/linux/init.h)中的__init用于修饰函数，__initdata用于修饰变量。 带有__init的修饰符，表示将该函数放到可执行文件的__init节区中，该节区的内容只能用于模块的初始化阶段， 初始化阶段执行完毕之后，这部分的内容就会被释放掉，真可谓是“针尖也要削点铁”。

module_init宏定义
1
#define module_init(x) __initcall(x);

宏定义module_init用于通知内核初始化模块的时候， 要使用哪个函数进行初始化。它会将函数地址加入到相应的节区section中， 这样的话，开机的时候就可以自动加载模块了。

module_exit

理解了模块加载的内容之后，来学习模块卸载函数应该会比较简单。 与内核加载函数相反，内核模块卸载函数func_exit主要是用于释放初始化阶段分配的内存， 分配的设备号等，是初始化过程的逆过程。

内核模块卸载函数
1
2
3
4
static void __exit func_exit(void)
{
}
module_exit(func_exit);

与函数func_init区别在于，该函数的返回值是void类型，且修饰符也不一样， 这里使用的使用__exit，表示将该函数放在可执行文件的__exit节区， 当执行完模块卸载阶段之后，就会自动释放该区域的空间。

__exit、__exitdata宏定义
1
2
#define __exit __section(.exit.text) __exitused __cold notrace
#define __exitdata __section(.exit.data)

类比于模块加载函数，__exit用于修饰函数，__exitdata用于修饰变量。 宏定义module_exit用于告诉内核，当卸载模块时，需要调用哪个函数。

printk函数

  • printf：glibc实现的打印函数，工作于用户空间

  • printk：内核模块无法使用glibc库函数，内核自身实现的一个类printf函数，但是需要指定打印等级。

    • #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>” 调试信息

查看当前系统printk打印等级：cat /proc/sys/kernel/printk， 从左到右依次对应当前控制台日志级别、默认消息日志级别、 最小的控制台级别、默认控制台日志级别。

printk打印等级

打印内核所有打印信息：dmesg，注意内核log缓冲区大小有限制，缓冲区数据可能被覆盖掉。

3.1.2.4. 许可证

Linux是一款免费的操作系统，采用了GPL协议，允许用户可以任意修改其源代码。 GPL协议的主要内容是软件产品中即使使用了某个GPL协议产品提供的库， 衍生出一个新产品，该软件产品都必须采用GPL协议，即必须是开源和免费使用的， 可见GPL协议具有传染性。因此，我们可以在Linux使用各种各样的免费软件。 在以后学习Linux的过程中，可能会发现我们安装任何一款软件，从来没有30天试用期或者是要求输入激活码的。

许可证
1
#define MODULE_LICENSE(_license) MODULE_INFO(license, _license)

内核模块许可证有 “GPL”，“GPL v2”，“GPL and additional rights”，“Dual SD/GPL”，“Dual MPL/GPL”，“Proprietary”。

3.1.2.5. 相关信息声明

下面，我们介绍一下关于内核模块程序结构的最后一部分内容。 这部分内容只是为了给使用该模块的读者一本“说明书”，属于可有可无的部分， 有则锦上添花，没有也无伤大雅。

内核模块信息声明函数：

函数

作用

MODULE_LICENSE()

表示模块代码接受的软件许可协议，Linux内核遵循GPL V2开源协议，内核模块与linux内核保持一致即可。

MODULE_AUTHOR()

描述模块的作者信息

MODULE_DESCRIPTION()

对模块的简单介绍

MODULE_ALIAS()

给模块设置一个别名

作者信息

内核模块作者宏定义(位于内核源码/linux/module.h)
1
#define MODULE_AUTHOR(_author) MODULE_INFO(author, _author)

我们前面使用modinfo中打印出的模块信息中“author”信息便是来自于宏定义MODULE_AUTHOR。 该宏定义用于声明该模块的作者。

模块描述信息

模块描述信息(位于内核源码/linux/module.h)
1
#define MODULE_DESCRIPTION(_description) MODULE_INFO(description, _description)

模块信息中“description”信息则来自宏MODULE_DESCRIPTION，该宏用于描述该模块的功能作用。

模块别名

内核模块别名宏定义(位于内核源码/linux/module.h)
1
#define MODULE_ALIAS(_alias) MODULE_INFO(alias, _alias)

模块信息中“alias”信息来自于宏定义MODULE_ALIAS。该宏定义用于给内核模块起别名。 注意，在使用该模块的别名时，需要将该模块复制到/lib/modules/内核源码/下， 使用命令depmod更新模块的依赖关系，否则的话，Linux内核怎么知道这个模块还有另一个名字。

3.1.3. 实验准备

获取内核模块源码，将配套代码linux_driver解压到内核代码同级目录，然后进入linux_driver/module/hellomodule文件夹。

放置例程源码

3.1.3.1. makefile说明

对于内核模块而言，它是属于内核的一段代码，只不过它并不在内核源码中。 为此，我们在编译时需要到内核源码目录下进行编译。 编译内核模块使用的Makefile文件，和我们前面编译C代码使用的Makefile大致相同， 这得益于编译Linux内核所采用的Kbuild系统，因此在编译内核模块时，我们也需要指定环境变量ARCH和CROSS_COMPILE的值。

Makefile (位于 linux_driver/module/hellomodule/Makefile)
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
KERNEL_DIR=../../../kernel/

ARCH=arm64
CROSS_COMPILE=aarch64-linux-gnu-
export  ARCH  CROSS_COMPILE

obj-m := hellomodule.o
all:
   $(MAKE) -C $(KERNEL_DIR) M=$(CURDIR) modules

.PHONE:clean

clean:
   $(MAKE) -C $(KERNEL_DIR) M=$(CURDIR) clean

以上代码中提供了一个关于编译内核模块的Makefile。

  • 第1行：该Makefile定义了变量KERNEL_DIR，来保存内核源码的目录,需要指定到内核编译输出目录下。

  • 第3-5行： 指定了工具链并导出环境变量

  • 第6行：变量obj-m保存着需要编译成模块的目标文件名。

  • 第8行：’$(MAKE)modules’实际上是执行Linux顶层Makefile的伪目标modules。通过选项’-C’，可以让make工具跳转到源码目录下读取顶层Makefile。 ‘M=$(CURDIR)’表明返回到当前目录，读取并执行当前目录的Makefile，开始编译内核模块。CURDIR是make的内嵌变量，自动设置为当前目录。

3.1.3.2. 编译命令说明

在实验目录linux_driver/module/hellomodule下输入如下命令来编译驱动模块：

make

编译成功后，实验目录下会生成名为“hellomodule.ko”的驱动模块文件

3.1.4. 程序运行结果

3.1.4.1. 如何加载内核模块

我们如愿编译了自己的内核模块，接下来就该了解如何使用这个内核模块了。 将hellomodule.ko通过scp或NFS拷贝到开发板中，我们来逐一讲解这些工具。

lsmod

lsmod列出当前内核中加载的模块，格式化显示在终端，其原理就是将/proc/modules中的信息调整一下格式输出。 lsmod输出列表有一列 Used by， 它表明此模块正在被其他模块使用，显示了模块之间的依赖关系。

insmod

如果要将一个模块加载到内核中，insmod是最简单的办法， insmod+模块完整路径就能达到目的，前提是你的模块不依赖其他模块，还要注意需要sudo权限。 如果你不确定是否使用到其他模块的符号，你也可以尝试modprobe，后面会有它的详细用法。

通过insmod命令加载hellomodule.ko内存模块加载该内存模块的时候， 该内存模块会自动执行module_init()函数，进行初始化操作，该函数打印了 ‘hello module init’。 再次查看已载入系统的内核模块，我们就会在列表中发现hellomodule.ko的身影。

加载hellomodule.ko的内核模块

但是有些内核模块有依赖关系，不能直接用insmod加载，需要“前置”依赖模块加载后才能加载，在我们后续实验——内核模块传参与符号共享实验这一小节中，calculation.ko和parametermodule.ko有依赖关系。 其中calculation.ko依赖parametermodule.ko中的参数和函数， 所以先手动加载parametermodule.ko，然后再加载calculation.ko。

模块参数

同样卸载的时，parametermodule.ko中的参数和函数被calculation.ko调用，必须先卸载calculation.ko 再卸载parametermodule.ko，否则会报错”ERROR: Module parametermodule is in use by: calculation”

模块卸载报错

modprobe

modprobe和insmod具备同样的功能，同样可以将模块加载到内核中，除此以外modprobe还能检查模块之间的依赖关系， 并且按照顺序加载这些依赖，可以理解为按照顺序多次执行insmod。

在我们后续实验——内核模块传参与符号共享实验中，calculation.ko和parametermodule.ko需要按照先后次序依次加载，而使用modprobe工具， 可以直接加载parametermodule.ko，当然modprobe之前需要先用depmod -a建立模块之间的依赖关系，但值得注意的是使用depmod -a必须要将驱动模块放入系统驱动模块存放和配置的文件夹，否者无法管理依赖关系。

depmod

modprobe是怎么知道一个给定模块所依赖的其他的模块呢？在这个过程中，depend起到了决定性作用，当执行modprobe时， 它会在模块的安装目录下搜索module.dep文件，这是depmod创建的模块依赖关系的文件。

在Linux系统中，/lib/modules目录通常包含内核相关的模块和配置文件，该文件夹包含了与内核版本号相关文件夹，用来存放的模块和配置信息。

内核配置和模块存放目录

以上配置文件或者目录说明如下：

配置文件或文件夹

作用

build

指向当前正在运行的内核源代码的符号链接

kernel

包含编译后的内核模块文件（.ko）

modules.alias

定义模块别名的文件

modules.alias.bin

模块别名文件的二进制缓存版本

modules.builtin

列出了由内核构建的模块（静态连接在内核中）

modules.builtin.bin

由内核构建的模块列表的二进制缓存版本

modules.dep

列出了模块之间的依赖关系

modules.dep.bin

模块依赖关系文件的二进制缓存版本

modules.devname

包含了每个模块设备的名称

modules.order

定义模块加载顺序的文件

modules.symbols

保存导出的符号信息

modules.symbols.bin

导出的符号信息的二进制缓存版本

modules.softdep

包含模块软依赖关系的文件

我们最关心的配置文件是modules.dep，该文件列出了模块之间的依赖关系，当我们执行depmod -a建立模块之间的依赖关系时，就会把依赖关系写入到modules.dep当中。

rmmod

rmod工具仅仅是将内核中运行的模块删除，只需要传给它路径就能实现。

rmmod命令卸载某个内存模块时，内存模块会自动执行*_exit()函数，进行清理操作， 我们的hellomodule中的*_exit()函数打印了一行内容，但是控制台并没有显示，可以使用dmesg查看， 之所以没有显示是与printk的打印等级有关，前面有关于printk函数有详细讲解。 rmmod不会卸载一个模块所依赖的模块，需要依次卸载，当然是用modprobe -r 可以一键卸载。

卸载hellomodule.ko的内核模块

modinfo

modinfo用来显示我们在内核模块中定义的几个宏。 我们可以通过modinfo来查看hellomodule，我们从打印的输出信息中，可以了解到，该模块遵循的是GPL协议， 该模块的作者是embedfire，该模块的vermagic等等。而这些信息在模块代码中由相关内核模块信息声明函数声明

内核模块信息

3.1.4.2. 系统自动加载模块

我们自己编写了一个模块，或者说怎样让它在板子开机自动加载呢？ 这里就需要用到上述的depmod和modprobe工具了。

首先需要将我们想要自动加载的模块统一放到“/lib/modules/内核版本”目录下，内核版本使用’uname -r’查询,测试使用的是4.19.232； 其次使用depmod建立模块之间的依赖关系，命令’ depmod -a’； 这个时候我们就可以在modules.dep中看到模块依赖关系，可以使用如下命令查看；

cat /lib/modules/4.19.232/modules.dep | grep hellomodule
自动加载模块配置文件

最后在/etc/modules或者/etc/modules-load.d/<filename>.conf中加上我们自己的模块，注意在该配置文件中，模块 不写成.ko形式 代表该模块与内核紧耦合，有些是系统必须要跟内核紧耦合，比如mm子系统， 一般写成.ko形式比较好，如果出现错误不会导致内核出现panic错误，如果集成到内核，出错了就会出现panic。

自动加载模块配置文件

然后重启开发板，lsmod就能查看到我们的模块开机就被加载到内核里面了。

3.2. 内核模块传参与符号共享实验

3.2.1. 实验说明

3.2.1.1. 硬件介绍

本节实验使用到Lubancat_RK系列板卡。

3.2.2. 实验代码讲解

本章的示例代码目录为：linux_driver/module/parametermodule

本节实验验证内核模块传参和符号共享。

3.2.2.1. 内核模块传参代码讲解

内核模块作为一个可拓展的动态模块，为Linux内核提供了灵活性，但是有时我们需要根据不同的应用场景给内核传递不同的参数， 例如在程序中开启调试模式、设置详细输出模式以及制定与具体模块相关的选项，都可以通过参数的形式来改变模块的行为。

Linux内核提供一个宏来实现模块的参数传递

module_param函数 (内核源码/include/linux/moduleparam.h)
1
2
3
4
#define module_param(name, type, perm) \\
module_param_named(name, name, type, perm)
#define module_param_array(name, type, nump, perm) \\
module_param_array_named(name, name, type, nump, perm)

以上代码中的module_param函数需要传入三个参数：

  • name： 我们定义的变量名；

  • type： 参数的类型，目前内核支持的参数类型有byte，short，ushort，int，uint，long，ulong，charp，bool，invbool。其中charp表示的是字符指针，bool是布尔类型，其值只能为0或者是1；invbool是反布尔类型，其值也是只能取0或者是1，但是true值表示0，false表示1。变量是char类型时，传参只能是byte，char * 时只能是charp。

  • perm： 表示的是该文件的权限，具体参数值见下表。

表文件权限

文件权限 :header: “用户组”, “标志位”,”解释” :widths: 10, 10,30

当前用户

S_IRUSR

用户拥有读权限

S_IWUSR

用户拥有写权限

当前用户组

S_IRGRP

当前用户组的其他用户拥有读权限

S_IWUSR

当前用户组的其他用户拥有写权限

其他用户

S_IROTH

其他用户拥有读权限

S_IWOTH

其他用户拥有写权限

上述文件权限唯独没有关于可执行权限的设置，请注意， 该文件不允许它具有可执行权限。如果强行给该参数赋予表示可执行权限的参数值S_IXUGO， 那么最终生成的内核模块在加载时会提示错误，见下图。

参数不可赋予可执行权限

下面是我们一个实验代码：

示例程序
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
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)
{
   printk(KERN_ALERT "param init!\n");
   printk(KERN_ALERT "itype=%d\n",itype);
   printk(KERN_ALERT "btype=%d\n",btype);
   printk(KERN_ALERT "ctype=%d\n",ctype);
   printk(KERN_ALERT "stype=%s\n",stype);
   return 0;
}

  • 第1-11行：定义了四个常见变量然后使用module_param宏来声明这四个参数

  • 第13-21行：并在param_init中输出上面声明的四个参数。

我们定义的四个模块参数，会在 ‘/sys/module/模块名/parameters’ 下会存在以模块参数为名的文件。 由于itype和ctype的权限是0，所以我们没有权限查看该参数。

模块参数

3.2.2.2. 符号共享代码讲解

在前面我们已经详细的分析了关于导出符号的内核源码，符号指的就是在内核模块中导出函数和变量， 在加载模块时被记录在公共内核符号表中，以供其他模块调用。 这个机制，允许我们使用分层的思想解决一些复杂的模块设计。我们在编写一个驱动的时候， 可以把驱动按照功能分成几个内核模块，借助符号共享去实现模块与模块之间的接口调用，变量共享。

导出符号
1
2
#define EXPORT_SYMBOL(sym) \\
__EXPORT_SYMBOL(sym, "")

EXPORT_SYMBOL宏用于向内核导出符号，这样的话，其他模块也可以使用我们导出的符号了。 下面通过一段代码，介绍如何使用某个模块导出符号。

parametermodule.c
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
//...省略代码...
static int itype=0;
module_param(itype,int,0);

EXPORT_SYMBOL(itype);

int my_add(int a, int b)
{
   return a+b;
}

EXPORT_SYMBOL(my_add);

int my_sub(int a, int b)
{
   return a-b;
}

EXPORT_SYMBOL(my_sub);
//...省略代码...

  • 第2-3行：定义了参数itype，并通过EXPORT_SYMBOL宏导出

  • 第7-12行：和my_add，并通过EXPORT_SYMBOL宏导出

  • 第14-21行：my_sub函数，并通过EXPORT_SYMBOL宏导出

以上代码中，省略了内核模块程序的其他内容，如头文件，加载/卸载函数等。

calculation.h
1
2
3
4
5
6
7
8
9
#ifndef __CALCULATION_H__
#define __CALCULATION_H__

extern int itype;

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

#endif

声明额外的变量itype，my_add和my_sub函数。

calculation.c
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
//...省略代码...
#include "calculation.h"

//...省略代码...
static int __init calculation_init(void)
{
   printk(KERN_ALERT "calculation  init!\n");
   printk(KERN_ALERT "itype+1 = %d, itype-1 = %d\n", my_add(itype,1), my_sub(itype,1));
   return 0;
}
//...省略代码...

calculation.c中使用extern关键字声明的参数itype，调用my_add()、my_sub()函数进行计算。

3.2.3. 实验准备

获取内核模块源码，将配套代码linux_driver/放到内核代码同级目录，然后进入linux_driver/module/parametermoudule目录中。

3.2.3.1. makefile说明

Makefile (位于linux_driver/module/hellomodule/Makefile)
1
2
3
...省略代码...
obj-m := parametermodule.o calculation.o
...省略代码...

以上Makefile与上一个实验，只有目标文件不同。

3.2.3.2. 编译命令说明

在实验目录下输入如下命令来编译驱动模块：

make
编译内核模块

编译成功后，实验目录下会生成名为“parametermodule.ko”和“calculation.ko”的驱动模块文件

3.2.4. 程序运行结果

通过NFS将编译好的module_param.ko拷贝到开发板中，加载module_param.ko并传参， 这时我们声明的四个变量的值，就是变成了我们赋的值。

sudo insmod parametermodule.ko itype=123 btype=1 ctype=200 stype=abc

查看向内核导出的符号表 ‘cat /proc/kallsyms’

查看符号表

将内核模块存放板卡到/lib/modules/4.19.232/kernel目录，然后执行depmod -a后，再查看modules.dep配置文件可以发现calculation.ko依赖parametermodule.ko，并且modules.dep还记录了模块的存放位置。如下图所示：

modprobe加载

执行modprobe calculation命令自动将会parametermodule.ko模块加载，然后再加载calculation.ko模块。

modprobe加载