linux驱动学习之kthread_work和kthread_worker机制

转载 ：http://blog.csdn.net/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);
}