【Linux】内核驱动模块

Linux内核模块是一种特殊的内核组件，它们可以被动态地加载到正在运行的内核中以扩展其功能，或者在不需要时从内核中卸载。这种动态特性使得Linux内核能够保持精简，同时又可以根据需要加载不同的功能模块。本文将详细介绍Linux内核模块的相关知识。

1. 引言

Linux内核模块为开发者提供了一种灵活的方式来扩展内核的功能，而无需重新编译整个内核。模块可以用来实现各种硬件驱动、网络协议、文件系统以及其他内核功能。理解内核模块的编写和使用是Linux系统编程中的一个重要方面。

2. Linux内核模块基础

2.1 模块的概念

Linux内核模块是独立于内核主体的代码段，它们可以被动态加载到内核中，并且在不需要时可以从内核中卸载。模块可以提供新的功能或增强现有的功能，例如新的设备驱动程序、文件系统支持或网络协议。

2.2 模块的生命周期

模块在其生命周期中有几个重要的阶段：

编译：模块首先需要被编译成一个独立的文件（通常以.ko作为扩展名）。
加载：模块被加载到内核中，此时会调用模块的初始化函数。
运行：模块在内核中运行，提供其定义的功能。
卸载：当不再需要该模块时，可以将其从内核中卸载，此时会调用模块的退出函数。

2.3 模块的接口

为了能够被内核正确加载和卸载，模块必须实现两个特殊的函数：module_init和module_exit。

2.3.1 `module_init`函数

这是模块初始化函数，在模块加载时被调用。在这个函数中，模块应该初始化它所使用的任何数据结构，并注册任何需要的服务。

c 复制代码

// 定义模块初始化函数
static int __init mod_init(void)
{
    // 输出初始化信息
    printk(KERN_INFO "Module initialized.\n");

    // 其他初始化代码
    // ...

    // 返回0表示成功
    return 0;
}

2.3.2 `module_exit`函数

这是模块退出函数，在模块卸载时被调用。在这个函数中，模块应该释放它所使用的任何资源，并注销之前注册的服务。

c 复制代码

// 定义模块退出函数
static void __exit mod_exit(void)
{
    // 输出退出信息
    printk(KERN_INFO "Module exited.\n");

    // 清理和释放资源
    // ...
}

2.4 模块的编译

模块可以单独编译，也可以作为内核的一部分编译。通常，模块是作为一个单独的目标文件编译的，这样可以在不重新编译整个内核的情况下更新模块。

2.4.1 编译命令

编译模块通常使用gcc命令，并且需要包含内核的头文件路径。

bash 复制代码

gcc -Wall -Wstrict-prototypes -O2 -fno-strict-aliasing -I /usr/src/linux/include -D__KERNEL__ -c -o mymodule.o mymodule.c

然后使用ld链接器将模块对象文件链接成模块文件。

bash 复制代码

ld -r -m elf_i386 -o mymodule.ko mymodule.o

2.4.2 使用Makefile

更常见的是使用Makefile来编译模块，这样可以更容易地管理和构建多个模块。

Makefile 复制代码

# Makefile for building a simple kernel module

# Define the list of object files
obj-m += mymodule.o

# Define the directory where the kernel headers are installed
KERNELDIR := /lib/modules/$(shell uname -r)/build

# Define the default target
default:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules

# Define the clean target
clean:
	rm -rf *.o *.ko *.mod.c .*.cmd

3. Linux内核模块编写

3.1 模块编写流程

编写内核模块通常遵循以下步骤：

定义模块：定义模块的数据结构和函数。
实现初始化函数 ：实现module_init函数。
实现退出函数 ：实现module_exit函数。
导出符号 ：如果模块需要导出符号供其他模块使用，需要使用EXPORT_SYMBOL宏。
指定许可证 ：指定模块的许可证类型，通常使用MODULE_LICENSE宏。

3.1.1 示例代码

下面是一个简单的内核模块示例：

c 复制代码

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>

// 定义一个全局变量，用于存储模块参数
static int my_param = 1;

// 模块参数宏
module_param(my_param, int, S_IRUGO);

// 描述模块参数的作用
MODULE_PARAM_DESC(my_param, "A sample parameter.");

// 模块初始化函数
static int __init mod_init(void)
{
    // 输出模块参数的值
    printk(KERN_INFO "Parameter value: %d\n", my_param);

    // 其他初始化代码
    // ...

    // 返回0表示成功
    return 0;
}

// 模块退出函数
static void __exit mod_exit(void)
{
    // 输出退出信息
    printk(KERN_INFO "Module exited.\n");

    // 清理和释放资源
    // ...
}

// 模块初始化函数声明
module_init(mod_init);

// 模块退出函数声明
module_exit(mod_exit);

// 指定模块的许可证
MODULE_LICENSE("GPL");

3.2 模块的加载与卸载

模块可以通过insmod或modprobe命令加载到内核中，通过rmmod命令从内核中卸载。

3.2.1 加载模块

bash 复制代码

sudo insmod mymodule.ko

或者使用modprobe：

bash 复制代码

sudo modprobe mymodule

3.2.2 卸载模块

bash 复制代码

sudo rmmod mymodule

3.3 模块参数

模块可以接受参数，在模块加载时通过命令行传递给模块。这些参数可以用来配置模块的行为。

3.3.1 模块参数示例

c 复制代码

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>

// 定义一个全局变量，用于存储模块参数
static int my_param = 1;

// 模块参数宏
module_param(my_param, int, S_IRUGO);

// 描述模块参数的作用
MODULE_PARAM_DESC(my_param, "A sample parameter.");

// 模块初始化函数
static int __init mod_init(void)
{
    // 输出模块参数的值
    printk(KERN_INFO "Parameter value: %d\n", my_param);

    // 其他初始化代码
    // ...

    // 返回0表示成功
    return 0;
}

// 模块退出函数
static void __exit mod_exit(void)
{
    // 输出退出信息
    printk(KERN_INFO "Module exited.\n");

    // 清理和释放资源
    // ...
}

// 模块初始化函数声明
module_init(mod_init);

// 模块退出函数声明
module_exit(mod_exit);

// 指定模块的许可证
MODULE_LICENSE("GPL");

加载模块时传递参数：

bash 复制代码

sudo insmod mymodule.ko my_param=5

3.4 模块依赖

模块之间可以有依赖关系，一个模块可能依赖于另一个模块提供的功能。这种依赖关系可以通过depends_on宏指定。

3.4.1 模块依赖示例

c 复制代码

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>

// 定义模块依赖
MODULE_DEPENDS("other_module");

// 模块初始化函数
static int __init mod_init(void)
{
    // 输出初始化信息
    printk(KERN_INFO "Module initialized.\n");

    // 其他初始化代码
    // ...

    // 返回0表示成功
    return 0;
}

// 模块退出函数
static void __exit mod_exit(void)
{
    // 输出退出信息
    printk(KERN_INFO "Module exited.\n");

    // 清理和释放资源
    // ...
}

// 模块初始化函数声明
module_init(mod_init);

// 模块退出函数声明
module_exit(mod_exit);

// 指定模块的许可证
MODULE_LICENSE("GPL");

4. Linux内核模块的内部机制

4.1 模块的加载过程

模块加载的过程包括以下几个步骤：

加载模块 ：通过insmod或modprobe命令加载模块到内核中。
解析模块：内核解析模块文件，提取符号表和其他信息。
初始化模块 ：调用模块的module_init函数来初始化模块。

4.1.1 加载模块的命令

bash 复制代码

sudo insmod mymodule.ko

4.1.2 解析模块

内核会解析模块文件，提取模块的符号表、依赖关系和其他元数据。

4.1.3 初始化模块

内核调用模块的module_init函数，让模块进行初始化。

c 复制代码

static int __init mod_init(void)
{
    // 模块初始化代码
    return 0;
}

4.2 模块的卸载过程

模块卸载的过程包括以下几个步骤：

卸载模块 ：通过rmmod命令卸载模块。
清理模块 ：调用模块的module_exit函数来释放资源。

4.2.1 卸载模块的命令

bash 复制代码

sudo rmmod mymodule

4.2.2 清理模块

内核调用模块的module_exit函数，让模块进行清理。

c 复制代码

static void __exit mod_exit(void)
{
    // 模块清理代码
}

4.3 模块间的通信

模块间可以通过导出符号的方式进行通信。一个模块可以导出符号供其他模块使用，而其他模块则可以通过request_module函数获取这些符号。

4.3.1 导出符号

c 复制代码

EXPORT_SYMBOL(my_function);

4.3.2 获取符号

c 复制代码

extern void (*my_function)(int);

5. Linux内核模块的高级特性

5.1 模块的调试

模块的调试可以通过内核的日志机制来进行，使用printk函数输出调试信息。

5.1.1 使用`printk`

c 复制代码

printk(KERN_DEBUG "Debug message: %s\n", str);

5.2 模块的版本兼容性

模块需要与内核版本兼容，否则可能会导致加载失败。可以通过检查内核版本来确保兼容性。

5.2.1 检查内核版本

c 复制代码

if (!capable(CAP_SYS_ADMIN)) {
    printk(KERN_ERR "Module requires CAP_SYS_ADMIN capability.\n");
    return -EPERM;
}

if (kernel_version < KERNEL_VERSION(2, 6, 32)) {
    printk(KERN_ERR "Module requires kernel version 2.6.32 or later.\n");
    return -EINVAL;
}

5.3 模块的动态加载

模块可以被动态加载，这意味着模块的加载时机可以在运行时决定。

5.3.1 使用`modprobe`

bash 复制代码

modprobe mymodule

5.4 模块的静态链接

模块也可以被静态链接到内核中，这种方式通常用于那些频繁加载和卸载的模块。

5.4.1 静态链接模块

在内核配置过程中选择将模块静态链接到内核。

5.5 模块的热插拔支持

模块可以支持热插拔设备，即在系统运行时插入或拔出设备而不需重启系统。

5.5.1 支持热插拔设备

c 复制代码

static int __init mod_init(void)
{
    register_hotplug_notifier(&my_notifier);
    return 0;
}

static void __exit mod_exit(void)
{
    unregister_hotplug_notifier(&my_notifier);
}

6. Linux内核模块示例：字符设备驱动

下面是一个字符设备驱动模块的例子，展示了如何创建一个简单的字符设备，并实现基本的读写操作。

6.1 设备初始化

c 复制代码

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include <linux/interrupt.h>

// 定义设备号
static dev_t dev_num = MKDEV(240, 0);
static struct cdev c_dev;
static struct class *class;
static struct device *device;
static char buf[PAGE_SIZE] = {0};

// 设备打开操作
static int dev_open(struct inode *inode, struct file *file)
{
    printk(KERN_INFO "Device opened.\n");
    return 0;
}

// 设备关闭操作
static int dev_release(struct inode *inode, struct file *file)
{
    printk(KERN_INFO "Device closed.\n");
    return 0;
}

// 设备读操作
static ssize_t dev_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
    if (*ppos >= PAGE_SIZE)
        return 0;
    if (copy_to_user(buf, &buf[*ppos], count))
        return -EFAULT;
    *ppos += count;
    return count;
}

// 设备写操作
static ssize_t dev_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
    if (*ppos >= PAGE_SIZE)
        return -ENOSPC;
    if (copy_from_user(&buf[*ppos], buf, count))
        return -EFAULT;
    *ppos += count;
    return count;
}

// 设备文件操作结构
static const struct file_operations fops = {
    .owner          = THIS_MODULE,
    .read           = dev_read,
    .write          = dev_write,
    .open           = dev_open,
    .release        = dev_release,
};

// 模块初始化函数
static int __init dev_init(void)
{
    // 注册字符设备
    register_chrdev_region(dev_num, 1, "my_char_dev");

    // 初始化字符设备结构
    cdev_init(&c_dev, &fops);

    // 添加字符设备到设备类
    class = class_create(THIS_MODULE, "my_char_class");
    device = device_create(class, NULL, dev_num, NULL, "my_char_dev");

    // 注册字符设备
    cdev_add(&c_dev, dev_num, 1);

    return 0;
}

// 模块退出函数
static void __exit dev_exit(void)
{
    // 删除字符设备
    cdev_del(&c_dev);

    // 移除设备
    device_destroy(class, dev_num);

    // 销毁设备类
    class_unregister(class);

    // 注销字符设备区域
    unregister_chrdev_region(dev_num, 1);
}

// 模块初始化函数声明
module_init(dev_init);

// 模块退出函数声明
module_exit(dev_exit);

// 指定模块的许可证
MODULE_LICENSE("GPL");

6.2 测试字符设备

测试字符设备可以通过用户空间程序来读写设备节点。

bash 复制代码

echo "Hello, World!" > /dev/my_char_dev
cat /dev/my_char_dev

7. 总结

Linux内核模块是内核编程中的重要组成部分，它们允许在不重启系统的情况下扩展内核的功能。通过理解模块的编写、加载和卸载流程，以及如何在模块间传递参数和建立依赖关系，可以更好地利用Linux内核模块来满足各种需求。希望本文能帮助读者更好地掌握Linux内核模块的相关知识。

【Linux】内核驱动模块

1. 引言

2. Linux内核模块基础

2.1 模块的概念

2.2 模块的生命周期

2.3 模块的接口

2.3.1 module_init函数

2.3.2 module_exit函数

2.4 模块的编译

2.4.1 编译命令

2.4.2 使用Makefile

3. Linux内核模块编写

3.1 模块编写流程

3.1.1 示例代码

3.2 模块的加载与卸载

3.2.1 加载模块

3.2.2 卸载模块

3.3 模块参数

3.3.1 模块参数示例

3.4 模块依赖

3.4.1 模块依赖示例

4. Linux内核模块的内部机制

4.1 模块的加载过程

4.1.1 加载模块的命令

4.1.2 解析模块

4.1.3 初始化模块

4.2 模块的卸载过程

4.2.1 卸载模块的命令

4.2.2 清理模块

4.3 模块间的通信

4.3.1 导出符号

4.3.2 获取符号

5. Linux内核模块的高级特性

5.1 模块的调试

5.1.1 使用printk

5.2 模块的版本兼容性

5.2.1 检查内核版本

5.3 模块的动态加载

5.3.1 使用modprobe

5.4 模块的静态链接

5.4.1 静态链接模块

5.5 模块的热插拔支持

5.5.1 支持热插拔设备

6. Linux内核模块示例：字符设备驱动

6.1 设备初始化

6.2 测试字符设备

7. 总结

2.3.1 `module_init`函数

2.3.2 `module_exit`函数

5.1.1 使用`printk`

5.3.1 使用`modprobe`