《Linux设备驱动开发详解（第3版）》 第9章 Linux内核定时器与工作队列

9.1 内核定时器

内核定时器用于在指定的延迟时间后执行特定的函数。它在内核中常用于实现周期性任务或延迟执行的任务。

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

// 定义一个内核定时器
struct timer_list my_timer;

// 定时器到期时执行的函数
void my_timer_function(unsigned long data) {
    // data 是传递给定时器处理函数的参数
    printk(KERN_INFO "My timer function called with data %ld\n", data);
    // 这里可以添加具体的任务逻辑，例如执行一些周期性的操作
    // 重新设置定时器，让其再次到期执行
    mod_timer(&my_timer, jiffies + msecs_to_jiffies(5000));
    // jiffies 是系统启动以来的节拍数，msecs_to_jiffies 将毫秒转换为节拍数，这里设置5秒后再次触发
}

// 模块初始化函数
static int __init timer_init(void) {
    // 初始化定时器
    init_timer(&my_timer);
    // 设置定时器到期时执行的函数
    my_timer.function = my_timer_function;
    // 设置传递给定时器处理函数的参数
    my_timer.data = 42;
    // 设置定时器首次到期的时间，这里设置为5秒后
    my_timer.expires = jiffies + msecs_to_jiffies(5000);
    // 添加定时器到内核定时器队列
    add_timer(&my_timer);
    printk(KERN_INFO "Timer initialized and added\n");
    return 0;
}

// 模块退出函数
static void __exit timer_exit(void) {
    // 从内核定时器队列中删除定时器
    del_timer_sync(&my_timer);
    printk(KERN_INFO "Timer removed\n");
}

module_init(timer_init);
module_exit(timer_exit);
MODULE_LICENSE("GPL");

9.2 工作队列

工作队列允许内核在进程上下文中执行延迟的任务。这意味着任务可以睡眠，并且可以访问用户空间的资源（在适当的情况下）。

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

// 定义工作结构体
struct my_work_struct {
    struct work_struct work;
    int data;
};

// 工作处理函数
void my_work_handler(struct work_struct *work) {
    // 通过 container_of 宏从 work_struct 结构体获取包含它的 my_work_struct 结构体
    struct my_work_struct *my_work = container_of(work, struct my_work_struct, work);
    printk(KERN_INFO "My work handler called with data %d\n", my_work->data);
    // 这里可以添加具体的工作任务逻辑
}

// 模块初始化函数
static int __init workqueue_init(void) {
    struct workqueue_struct *my_wq;
    struct my_work_struct *my_work;

    // 创建一个工作队列
    my_wq = create_workqueue("my_workqueue");
    if (!my_wq) {
        printk(KERN_ERR "Failed to create workqueue\n");
        return -ENOMEM;
    }

    // 分配内存用于工作结构体
    my_work = kmalloc(sizeof(struct my_work_struct), GFP_KERNEL);
    if (!my_work) {
        destroy_workqueue(my_wq);
        printk(KERN_ERR "Failed to allocate memory for work\n");
        return -ENOMEM;
    }

    // 初始化工作结构体中的数据
    my_work->data = 10;
    // 初始化工作结构体中的 work 成员
    INIT_WORK(&my_work->work, my_work_handler);

    // 将工作提交到工作队列
    queue_work(my_wq, &my_work->work);
    printk(KERN_INFO "Work submitted to workqueue\n");
    return 0;
}

// 模块退出函数
static void __exit workqueue_exit(void) {
    // 销毁工作队列
    destroy_workqueue(my_wq);
    printk(KERN_INFO "Workqueue destroyed\n");
}

module_init(workqueue_init);
module_exit(workqueue_exit);
MODULE_LICENSE("GPL");

上述代码分别展示了内核定时器和工作队列的基本使用方法。内核定时器适合执行一些周期性或延迟的轻量级任务，而工作队列则更适合执行需要在进程上下文中完成的任务，特别是那些可能会睡眠的任务。在实际应用中，可根据具体需求选择合适的机制。