linux驱动学习之kthread_work和kthread_worker机制

本文详细介绍了Linux Kernel中的kthread_work和kthread_worker机制,包括它们的数据结构定义、初始化过程、工作队列的添加及处理流程。特别强调了如何通过内核线程处理多个kthread_work,以及如何确保所有任务执行完毕。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

转载 :http://blog.youkuaiyun.com/cq062364/article/details/39647907

kthread_work和kthread_worker机制

Kernel中提供的kthread_work和kthread_worker机制和经典的work_struct和workqueue_struct的关系有点类似.通过一个kthread_worker可以处理多个kthread_work,
##数据结构

struct kthread_worker {
    spinlock_t        lock;//保护work_list链表的自旋锁
    struct list_head    work_list;//kthread_work链表,相当于流水线
    struct task_struct    *task;//为该kthread_worker执行任务的线程对应的task_struct结构
    struct kthread_work    *current_work;//当前正在处理的kthread_work
};

struct kthread_work {
    struct list_head    node;//kthread_work链表的链表元素
    kthread_work_func_t    func;//执行函数,该kthread_work所要做的事情
    wait_queue_head_t    done;//没有找到相关用法
    struct kthread_worker    *worker;//处理该kthread_work的kthread_worker
};

kthread_worker处理kthread_work是通过创建一个内核线程来执行kthread_worker_fn函数来实现的.

调用

struct kthread_worker worker;//声明一个kthread_worker
init_kthread_worker(&worker);//初始化kthread_worker
struct task_struct *kworker_task = kthread_run(kthread_worker_fn, &worker, "nvme%d", dev->instance);//为kthread_worker创建一个内核线程来处理work.

struct kthread_work work;//声明一个kthread_work
init_kthread_work(&work, work_fn);初始化kthread_work,设置work执行函数.
queue_kthread_work(&worker, &work);//将kthread_work添加到kthread_worker的work_list.

具体实现

初始化函数

 init_kthread_worker和init_kthread_work其实是两个宏.
  #define init_kthread_worker(worker)                    \
    do {                                \
        static struct lock_class_key __key;            \
        __init_kthread_worker((worker), "("#worker")->lock", &__key); \
    } while (0)

void __init_kthread_worker(struct kthread_worker *worker,
                const char *name,
                struct lock_class_key *key)
{
    spin_lock_init(&worker->lock);
    lockdep_set_class_and_name(&worker->lock, key, name);
    INIT_LIST_HEAD(&worker->work_list);
    worker->task = NULL;
}
#define init_kthread_work(work, fn)                    \
    do {                                \
        memset((work), 0, sizeof(struct kthread_work));        \
        INIT_LIST_HEAD(&(work)->node);                \
        (work)->func = (fn);                    \
        init_waitqueue_head(&(work)->done);            \
    } while (0)

执行函数:
bool queue_kthread_work(struct kthread_worker *worker,
            struct kthread_work *work)
{
    bool ret = false;
    unsigned long flags;

    spin_lock_irqsave(&worker->lock, flags);
    if (list_empty(&work->node)) {
        insert_kthread_work(worker, work, &worker->work_list);
        ret = true;
    }
    spin_unlock_irqrestore(&worker->lock, flags);
    return ret;
}
static void insert_kthread_work(struct kthread_worker *worker,
                   struct kthread_work *work,
                   struct list_head *pos)
{
    lockdep_assert_held(&worker->lock);

    list_add_tail(&work->node, pos);//pos = &worker->work_list,这里就是将kthread_work添加到kthread_worker的work_list链表末尾.
    work->worker = worker;//设置处理该work的worker

    //如果此时指定了worker->task,将会唤醒worker->task表示的内核线程.在初始化kthread_worker的时候worker->task = NULL,但是在上面创建内核线程时所指定的线程的执行函数kthread_worker_fn中会将worker->task赋值,详情见下文kthread_worker_fn的介绍.
    if (likely(worker->task))
        wake_up_process(worker->task);
}

线程唤醒执行函数

int kthread_worker_fn(void *worker_ptr)
{
    struct kthread_worker *worker = worker_ptr;
    struct kthread_work *work;

    WARN_ON(worker->task);
    worker->task = current;//将worker->task设置为当前线程
repeat:
    set_current_state(TASK_INTERRUPTIBLE);    /* mb paired w/ kthread_stop */

    if (kthread_should_stop()) {//如果该work处理线程在别的地方被停止了,则该线程会退出.
        __set_current_state(TASK_RUNNING);
        spin_lock_irq(&worker->lock);
        worker->task = NULL;
        spin_unlock_irq(&worker->lock);
        return 0;
    }

    work = NULL;
    spin_lock_irq(&worker->lock);
    if (!list_empty(&worker->work_list)) {
        //如果worker的work_list上有work,则获取其上的第一个work,然后将其从链表中删除.
        work = list_first_entry(&worker->work_list, struct kthread_work, node);
        list_del_init(&work->node);
    }
    worker->current_work = work;//将刚才获取的work设置为worker当前处理的work
    spin_unlock_irq(&worker->lock);

    if (work) {//如果刚才获取到了work,则修改当前线程的状态为TASK_RUNNING,这样在发生调度的时候,该线程就不会被从就绪队列中移除.然后执行该work的执行函数.
        __set_current_state(TASK_RUNNING);
        work->func(work);
    } else if (!freezing(current))
        schedule();//如果没有获取到work,则说明该worker当前无事可做,则调用schedule交出cpu,该线程会被从就绪队列中移除,而进入睡眠状态,直到有work被添加到worker的work_list时,被唤醒.

    try_to_freeze();
    goto repeat;//继续处理work_list中的work或者刚被唤醒,去检查work_list上是否有work可处理.
}

线程执行完成调用函数

用来在最后要停止worker的处理线程之前,保证所有的work都已经处理了.
void flush_kthread_worker(struct kthread_worker *worker)
{
    struct kthread_flush_work fwork = {
        KTHREAD_WORK_INIT(fwork.work, kthread_flush_work_fn),
        COMPLETION_INITIALIZER_ONSTACK(fwork.done),
    };

    queue_kthread_work(worker, &fwork.work);
    wait_for_completion(&fwork.done);
}
    该函数会首先创建并初始化一个kthread_flush_work,该结构体包含了一个kthread_work和一个completion,然后将kthread_work添加到worker的work_list上,最后调用wait_for_completion等待该work被处理,这个最后一个提交的work被称作flash_work,的执行函数为kthread_flush_work_fn,如下所示,该函数仅仅是调用complete唤醒调用flush_kthread_worker的线程而已,该线程被唤醒之后,它就知道work_list上所有的work都已经处理完了,flush函数也就返回了.
static void kthread_flush_work_fn(struct kthread_work *work)
{
    struct kthread_flush_work *fwork =
        container_of(work, struct kthread_flush_work, work);
    complete(&fwork->done);
}
<think>我们正在讨论Linux内核中的kthread工作队列机制。用户询问kthread_queue_workkthread_init_work的用法区别。根据提供的引用,我们可以总结如下:1.kthread_init_work:用于初始化一个已经定义好的kthread_work结构体。它设置工作项的结构,包括初始化链表头(用于将工作项链接到工作队列)指定工作函数(当工作项被执行时调用的函数)。引用[1]引用[3]展示了它的用法。2.kthread_queue_work:用于将一个已经初始化的工作项(kthread_work)添加到工作线程的工作队列中,以便工作线程在适当的时候执行该工作项。引用[2]引用[4]提到了它的使用。因此,两者的区别在于:-kthread_init_work是初始化工作项(设置工作项的内部状态,包括工作函数)。-kthread_queue_work是将已经初始化的工作项提交到工作队列中,等待执行。使用步骤通常为:a.定义一个structkthread_work变量(通常在某个结构体中或作为全局变量)。b.使用kthread_init_work初始化这个工作项,指定当工作项被执行时调用的函数。c.使用kthread_queue_work将这个工作项提交给一个kthread_worker(工作线程的工作队列)。注意:kthread_worker需要提前创建(例如通过kthread_create_workerkthread_create_worker_on_cpu等函数创建)。下面我们详细说明这两个函数的使用方法,并给出示例代码(伪代码形式)。</think>### kthread_init_workkthread_queue_work 详解 在 Linux 内核的 kthread 工作队列机制中,`kthread_init_work` `kthread_queue_work` 是两个关键函数,分别用于**初始化工作项****提交工作项**: #### 1. `kthread_init_work` - 初始化工作项 ```c #define kthread_init_work(work, fn) \ do { \ memset((work), 0, sizeof(struct kthread_work)); \ INIT_LIST_HEAD(&(work)->node); // 初始化链表指针 (work)->func = (fn); // 绑定工作函数 } while (0) ``` **功能**: - 初始化 `struct kthread_work` 结构体 - 清空内存区域(`memset`) - 初始化链表节点(`INIT_LIST_HEAD`) - 绑定工作处理函数(`func` 指针) **使用示例**: ```c struct kthread_work my_work; kthread_init_work(&my_work, my_work_handler); // 初始化并绑定处理函数 ``` #### 2. `kthread_queue_work` - 提交工作项 ```c bool kthread_queue_work(struct kthread_worker *worker, struct kthread_work *work); ``` **功能**: - 将已初始化的 `kthread_work` 加入工作队列 - 唤醒关联的 kthread 工作线程执行任务 - 返回 `true` 表示成功加入队列 **使用示例**: ```c kthread_queue_work(&my_worker, &my_work); // 提交工作到工作线程 ``` --- ### 核心区别总结 | **特性** | `kthread_init_work` | `kthread_queue_work` | |------------------|--------------------------------------|-------------------------------------| | **操作对象** | `struct kthread_work` | `struct kthread_worker` + `work` | | **阶段** | 初始化阶段 (一次性) | 运行时调度 (可多次调用) | | **主要作用** | 配置工作项属性 | 触发工作项执行 | | **线程唤醒** | ❌ 不唤醒线程 | ✅ 唤醒工作线程执行任务 | | **调用依赖** | 需在 `kthread_queue_work` 前调用 | 依赖已初始化的 `work` `worker` | --- ### 完整工作流示例 ```c // 1. 创建工作线程 struct kthread_worker *worker = kthread_create_worker(0, "my_worker"); // 2. 定义并初始化工作项 struct kthread_work work; kthread_init_work(&work, work_handler); // 绑定处理函数 // 3. 提交工作项到队列 kthread_queue_work(worker, &work); // 4. 工作处理函数实现 void work_handler(struct kthread_work *work) { printk(KERN_INFO "Work executed!\n"); } ``` > **关键机制**: > kthread 工作线程在后台运行 `kthread_worker_fn()` 循环[^4],持续检测工作队列。当通过 `kthread_queue_work()` 提交工作项时,该函数将工作项加入队列并唤醒休眠的工作线程执行绑定的 `work->func`[^2][^3]。 --- ### 典型应用场景 1. **中断下半部处理**:将耗时操作从中断上下文转移到 kthread 2. **异步任务执行**:如驱动中的硬件状态轮询 3. **延迟任务调度**:通过 `kthread_delayed_work` 实现延时队列
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值