Linux内核模块使用计数机制解析与实践-代码聚汇网

Linux内核模块使用计数机制解析与实践

小仙元

1. Linux内核模块使用计数机制解析

在Linux内核开发中，模块使用计数是一个至关重要的安全机制。想象一下图书馆的管理系统：当一本书被借出时，系统会记录借阅数量；只有当所有借阅者都归还书籍后，这本书才能被下架。内核模块的使用计数原理与此完全相同，它确保了模块在被使用时不会被意外卸载，从而避免系统崩溃。

1.1 基础概念与工作原理

内核模块使用计数本质上是一个原子计数器（atomic_t类型），存储在模块结构体（struct module）中。这个计数器记录了当前有多少个其他模块或进程正在使用该模块。其工作流程可以概括为：

模块加载时，计数器初始化为1（表示模块自身占用）
当有其他模块或进程使用该模块时，计数器递增
使用结束后，计数器递减
只有当计数器归零时，模块才能被安全卸载

这种机制的核心价值在于：

防止模块在被使用时被意外卸载
确保模块资源的正确释放
维护内核的稳定性和安全性

1.2 关键数据结构解析

在内核源码中，模块使用计数主要通过以下数据结构实现：

c复制// include/linux/module.h
struct module {
    // ...
    atomic_t refcnt;          // 使用计数
    enum module_state state;  // 模块状态
    // ...
};

其中：

refcnt：原子计数器，记录当前使用计数
state：模块状态（LIVE, COMING, GOING等），与计数协同工作

2. 使用计数的核心操作接口

2.1 增加使用计数：try_module_get()

当模块A需要使用模块B时，必须首先调用try_module_get()函数：

c复制int try_module_get(struct module *mod) {
    if (mod->state != MODULE_STATE_LIVE)
        return 0;  // 模块不处于活动状态
    
    if (atomic_inc_not_zero(&mod->refcnt))
        return 1;  // 计数成功增加
    
    return 0;  // 模块状态在检查后发生变化
}

典型使用模式：

c复制if (!try_module_get(module_ptr)) {
    // 获取失败，模块不可用
    return -ENODEV;
}
// 获取成功，可以安全使用模块

重要提示：try_module_get()是原子操作，确保在多核环境下也能正确工作。它首先检查模块状态，只有在模块处于LIVE状态时才会增加计数。

2.2 减少使用计数：module_put()

当模块使用完毕后，必须调用module_put()减少计数：

c复制void module_put(struct module *mod) {
    if (atomic_dec_and_test(&mod->refcnt)) {
        // 计数变为0，且模块已标记为卸载
        synchronize_sched();  // 等待所有CPU上的任务完成
        free_module(mod);     // 实际执行卸载操作
    }
}

使用示例：

c复制// 使用模块功能...
module_put(module_ptr);  // 使用完毕，减少计数

2.3 查看当前计数

开发者可以通过多种方式查看模块的当前使用计数：

用户空间命令：

bash复制$ lsmod | grep usbcore
usbcore               311296  14 usb_storage,usbhid,btusb,...

输出中的数字14表示当前有14个模块依赖usbcore。

内核空间API：

c复制int module_refcount(struct module *mod);

3. 使用计数的典型应用场景

3.1 驱动模块的依赖管理

以USB子系统为例：

当插入U盘时，usb-storage驱动加载，usbcore计数+1
插入USB鼠标时，usbhid驱动加载，usbcore计数再+1
拔出设备时，对应驱动卸载，usbcore计数-1
只有当所有USB设备都移除后，usbcore计数归零，才能被卸载

这种依赖管理确保了核心模块在被依赖时不会被意外卸载。

3.2 导出符号的安全使用

当模块A使用模块B导出的函数时，必须确保在使用期间模块B不会被卸载：

c复制// 使用前增加计数
if (!try_module_get(module_b)) {
    return -EFAULT;
}

// 安全使用模块B的导出函数
result = module_b_function();

// 使用完毕后减少计数
module_put(module_b);

3.3 字符设备驱动中的计数管理

在字符设备驱动中，通常会在文件操作接口中管理使用计数：

c复制static int mydev_open(struct inode *inode, struct file *file) {
    if (!try_module_get(THIS_MODULE))
        return -EBUSY;
    // 设备初始化...
    return 0;
}

static int mydev_release(struct inode *inode, struct file *file) {
    // 设备清理...
    module_put(THIS_MODULE);
    return 0;
}

这种模式确保：

设备被打开时，模块计数+1
设备关闭时，计数-1
只有当所有设备文件都关闭后，模块才能被卸载

4. 实战：实现一个计数管理模块

4.1 示例模块代码

下面是一个完整的使用计数演示模块：

c复制#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>

#define DEVICE_NAME "count_demo"
#define DEVICE_MAJOR 240

static int demo_open(struct inode *inode, struct file *file) {
    printk(KERN_INFO "设备打开，当前计数: %d\n", 
           module_refcount(THIS_MODULE));
    
    if (!try_module_get(THIS_MODULE)) {
        printk(KERN_ERR "获取模块失败\n");
        return -EBUSY;
    }
    
    printk(KERN_INFO "计数增加后: %d\n", 
           module_refcount(THIS_MODULE));
    return 0;
}

static int demo_release(struct inode *inode, struct file *file) {
    printk(KERN_INFO "设备关闭，当前计数: %d\n", 
           module_refcount(THIS_MODULE));
    
    module_put(THIS_MODULE);
    
    printk(KERN_INFO "计数减少后: %d\n", 
           module_refcount(THIS_MODULE));
    return 0;
}

static struct file_operations fops = {
    .owner = THIS_MODULE,
    .open = demo_open,
    .release = demo_release,
};

static int __init demo_init(void) {
    int ret = register_chrdev(DEVICE_MAJOR, DEVICE_NAME, &fops);
    if (ret < 0) {
        printk(KERN_ERR "注册设备失败\n");
        return ret;
    }
    printk(KERN_INFO "模块加载，初始计数: %d\n", 
           module_refcount(THIS_MODULE));
    return 0;
}

static void __exit demo_exit(void) {
    unregister_chrdev(DEVICE_MAJOR, DEVICE_NAME);
    printk(KERN_INFO "模块卸载\n");
}

module_init(demo_init);
module_exit(demo_exit);
MODULE_LICENSE("GPL");

4.2 测试步骤与结果分析

编译并加载模块：

bash复制make
sudo insmod count_demo.ko

创建设备节点：

bash复制sudo mknod /dev/count_demo c 240 0

测试设备打开/关闭：

bash复制# 在终端1中保持设备打开
cat /dev/count_demo &

# 在终端2中尝试卸载
sudo rmmod count_demo  # 应该失败

# 关闭设备
kill %1

# 再次尝试卸载
sudo rmmod count_demo  # 应该成功

查看内核日志：

bash复制dmesg | tail -n 10

预期输出会显示计数从1增加到2，再减少回1的过程。

5. 常见问题与解决方案

5.1 模块无法卸载："Resource busy"

典型表现：

bash复制$ sudo rmmod mymodule
rmmod: ERROR: Module mymodule is in use

可能原因：

其他模块仍依赖当前模块
设备文件仍被用户程序打开
内核线程仍在运行模块代码

排查步骤：

查看模块依赖关系：

bash复制lsmod | grep mymodule

检查打开的文件句柄：

bash复制lsof | grep /dev/mymodule

终止相关进程：

bash复制kill -9 <PID>

5.2 计数不匹配问题

症状：

模块使用计数异常增加或减少
模块无法卸载，但lsmod显示计数为0

常见原因：

try_module_get()和module_put()调用不配对
异常路径未正确释放计数
竞态条件导致计数操作不同步

解决方案：

使用goto确保异常路径也能释放计数：

c复制int my_func(void) {
    if (!try_module_get(module))
        return -ENODEV;
    
    // 操作1
    if (error1)
        goto out;
    
    // 操作2
    if (error2)
        goto out;
    
    // 正常流程
    ...
out:
    module_put(module);
    return ret;
}

使用原子操作确保计数同步：

c复制atomic_inc(&mod->refcnt);  // 替代直接mod->refcnt++

5.3 卸载后系统崩溃

危险场景：

模块卸载后，仍有代码在执行模块中的函数
其他CPU上仍有任务在使用模块资源

预防措施：

确保所有使用点都有正确的计数管理
在卸载函数中添加同步机制：

c复制static void __exit my_exit(void) {
    // 标记模块为GOING状态
    mod->state = MODULE_STATE_GOING;
    
    // 等待所有CPU完成
    synchronize_sched();
    
    // 释放资源
    ...
}

6. 高级主题与最佳实践

6.1 自动计数管理技巧

对于常见的内核API，可以使用以下自动计数管理方法：

使用THIS_MODULE宏：

c复制static struct file_operations fops = {
    .owner = THIS_MODULE,  // 内核会自动管理计数
    ...
};

网络设备驱动中的计数：

c复制struct net_device *dev;
dev_hold(dev);  // 增加计数
dev_put(dev);   // 减少计数

6.2 调试计数问题

当计数管理出现问题时，可以使用以下调试技巧：

添加调试打印：

c复制printk(KERN_DEBUG "%s: count=%d\n", __func__, module_refcount(THIS_MODULE));

使用内核跟踪点：

bash复制echo 1 > /sys/kernel/debug/tracing/events/module/enable
cat /sys/kernel/debug/tracing/trace_pipe

检查模块状态：

bash复制cat /proc/modules

6.3 性能考量

在高性能场景下，计数操作可能成为瓶颈。优化建议：

减少不必要的计数操作
使用atomic_inc_not_zero()替代先检查后增加
对于高频操作，考虑引用计数批处理

7. 内核源码深度解析

7.1 计数操作的原子性实现

内核使用原子操作指令确保计数在多核环境下的正确性。以x86架构为例：

c复制static __always_inline void atomic_inc(atomic_t *v) {
    asm volatile(LOCK_PREFIX "incl %0"
                 : "+m" (v->counter));
}

LOCK_PREFIX宏在x86上扩展为lock指令前缀，确保操作的原子性。

7.2 模块卸载的完整流程

当计数归零时，内核执行以下卸载流程：

设置模块状态为MODULE_STATE_GOING
调用synchronize_sched()等待所有CPU退出模块代码
执行模块的exit函数
释放模块占用的内存
从模块列表中移除

7.3 引用计数与RCU的协同

在现代内核中，引用计数常与RCU（Read-Copy-Update）机制配合使用：

c复制// 读者侧
rcu_read_lock();
module = rcu_dereference(module_ptr);
if (module && try_module_get(module)) {
    // 安全使用模块
    ...
    module_put(module);
}
rcu_read_unlock();

// 写者侧
rcu_assign_pointer(module_ptr, NULL);
synchronize_rcu();
// 现在可以安全释放模块

这种模式在保证性能的同时，确保了内存访问的安全性。

8. 实际项目经验分享

在多年的内核开发中，我总结了以下计数管理的最佳实践：

配对检查：为每个try_module_get()添加对应的module_put()，并在代码审查时特别检查这一点。
状态验证：在增加计数前，不仅要检查模块指针非空，还要验证模块状态：

c复制if (!mod || mod->state != MODULE_STATE_LIVE)
    return -ENODEV;

异常处理：在可能失败的操作路径上，使用goto统一处理计数释放：

c复制int err = 0;
if (!try_module_get(mod)) {
    err = -ENODEV;
    goto out;
}

// 操作1
if (cond1) {
    err = -EINVAL;
    goto put_module;
}

// 操作2
...

put_module:
module_put(mod);
out:
return err;

调试辅助：在开发阶段，可以添加计数断言：

c复制WARN_ON(module_refcount(mod) < 0);

一个常见的陷阱是在中断处理程序中使用模块计数。由于中断上下文不能睡眠，必须使用try_module_get()的原子版本：

c复制// 正确的中断处理程序做法
if (!try_module_get(THIS_MODULE)) {
    // 快速失败处理
    return IRQ_NONE;
}
// 处理中断
module_put(THIS_MODULE);

另一个实际项目中的经验是：当设计可卸载的内核服务时，可以考虑使用"服务不可用"标记配合计数管理。当准备卸载时，先设置服务不可用标志，等待所有现有操作完成（计数归零），再执行实际卸载。这样可以实现优雅的停机。