工作队列分析

 一、用法
struct cpu_workqueue_struct {

    spinlock_t lock;

    long remove_sequence;    /* Least-recently added (next to run) */
    long insert_sequence;    /* Next to add */

    struct list_head worklist;
    wait_queue_head_t more_work;
    wait_queue_head_t work_done;

    struct workqueue_struct *wq;
    struct task_struct *thread;

    int run_depth;        /* Detect run_workqueue() recursion depth */
} ____cacheline_aligned;

/*
* The externally visible workqueue abstraction is an array of
* per-CPU workqueues:
*/
struct workqueue_struct {
    struct cpu_workqueue_struct *cpu_wq;
    const char *name;
    struct list_head list;     /* Empty if single thread */
};

工作队列的使用很简单。
1.首先是建立一个工作队列：
    struct workqueue_struct *keventd_wq;
    keventd_wq = create_workqueue("events");
2.然后就是在这个队列中insert你所要做的“工作”：
    DECLARE_WORK(work, func, data)   
    queue_work(keventd_wq, work);

struct work_struct {
    unsigned long pending;
    struct list_head entry;
    void (*func)(void *);
    void *data;
    void *wq_data;
    struct timer_list timer;
};

初始化有两种方法。
一种为静态方法：
#define __WORK_INITIALIZER(n, f, d) {                /
        .entry    = { &(n).entry, &(n).entry },            /
    .func = (f),                        /
    .data = (d),                        /
    .timer = TIMER_INITIALIZER(NULL, 0, 0),            /
    }

#define DECLARE_WORK(n, f, d)                    /
    struct work_struct n = __WORK_INITIALIZER(n, f, d)

另一种为动态方法：
/*
* initialize all of a work-struct:
*/
#define INIT_WORK(_work, _func, _data)                /
    do {                            /
        INIT_LIST_HEAD(&(_work)->entry);        /
        (_work)->pending = 0;                /
        PREPARE_WORK((_work), (_func), (_data));    /
        init_timer(&(_work)->timer);            /
    } while (0)


二、执行过程
create_workqueue() -> __create_workqueue()

struct workqueue_struct *__create_workqueue(const char *name,
                        int singlethread)
{
    int cpu, destroy = 0;
    struct workqueue_struct *wq;
    struct task_struct *p;

    wq = kzalloc(sizeof(*wq), GFP_KERNEL);
    //为每个CPU建立一个结构
    wq->cpu_wq = alloc_percpu(struct cpu_workqueue_struct);
    ...
    wq->name = name;
    mutex_lock(&workqueue_mutex);
    if (singlethread) {
        ...
    } else {
        list_add(&wq->list, &workqueues);
        for_each_online_cpu(cpu) {
            //为每个CPU创建一个线程
            p = create_workqueue_thread(wq, cpu);
            if (p) {
                kthread_bind(p, cpu);
                //唤醒这个线程执行工作
                wake_up_process(p);
            } else
                destroy = 1;
        }
    }
    mutex_unlock(&workqueue_mutex);
    ...
    return wq;
}

create_workqueue() -> __create_workqueue() -> create_workqueue_thread()

static struct task_struct *create_workqueue_thread(struct workqueue_struct *wq,
                           int cpu)
{
    struct cpu_workqueue_struct *cwq = per_cpu_ptr(wq->cpu_wq, cpu);
    struct task_struct *p;

    spin_lock_init(&cwq->lock);
    cwq->wq = wq;
    cwq->thread = NULL;
    cwq->insert_sequence = 0;
    cwq->remove_sequence = 0;
    INIT_LIST_HEAD(&cwq->worklist);
    init_waitqueue_head(&cwq->more_work);
    init_waitqueue_head(&cwq->work_done);

    if (is_single_threaded(wq))
        p = kthread_create(worker_thread, cwq, "%s", wq->name);
    else
        //创建一个线程，这个线程以cwq为数据执行worker_thread这个函数
        p = kthread_create(worker_thread, cwq, "%s/%d", wq->name, cpu);
    if (IS_ERR(p))
        return NULL;
    cwq->thread = p; //
    return p;
}


create_workqueue() -> __create_workqueue() -> create_workqueue_thread() -> worker_thread()

//本函数在一个死循环等待工作的到来，这一般在睡眠状态中，等待被唤醒执行工作
//当有工作到来时queue_work()会将这个线程唤醒
static int worker_thread(void *__cwq)
{
    struct cpu_workqueue_struct *cwq = __cwq;
    DECLARE_WAITQUEUE(wait, current);
    ...

    current->flags |= PF_NOFREEZE;

    //设置优先级
    set_user_nice(current, -5);
    ...
    set_current_state(TASK_INTERRUPTIBLE);
    while (!kthread_should_stop()) {
        //将本线程加入睡眠队列，用于睡眠后可以被唤醒
        add_wait_queue(&cwq->more_work, &wait);

        //如果没用被执行的“工作”，则将自己切换出去，进入睡眠状态
        if (list_empty(&cwq->worklist))
            schedule();
        else //否则或是被唤醒
            __set_current_state(TASK_RUNNING);
        remove_wait_queue(&cwq->more_work, &wait);
       
        //工作队列非空，执行工作
        if (!list_empty(&cwq->worklist))
            run_workqueue(cwq);
        set_current_state(TASK_INTERRUPTIBLE);
    }
    __set_current_state(TASK_RUNNING);
    return 0;
}


    create_workqueue() -> __create_workqueue() -> create_workqueue_thread() -> worker_thread()
-> run_workqueue()
//该函数执行真正的工作
static void run_workqueue(struct cpu_workqueue_struct *cwq)
{
    unsigned long flags;

    spin_lock_irqsave(&cwq->lock, flags);
    ...
    //顺次执行队列中的所有工作
    while (!list_empty(&cwq->worklist)) {
        struct work_struct *work = list_entry(cwq->worklist.next,
                        struct work_struct, entry);
        void (*f) (void *) = work->func;
        void *data = work->data;

        //从队列中删除待执行的任务
        list_del_init(cwq->worklist.next);
        spin_unlock_irqrestore(&cwq->lock, flags);

        BUG_ON(work->wq_data != cwq);
        clear_bit(0, &work->pending);

        //执行“工作”
        f(data);

        spin_lock_irqsave(&cwq->lock, flags);
        cwq->remove_sequence++;
        wake_up(&cwq->work_done); //
    }
    cwq->run_depth--;
    spin_unlock_irqrestore(&cwq->lock, flags);
}

三、工作线程创建的详细过程
create_workqueue() -> __create_workqueue() -> create_workqueue_thread() -> kthread_create()

struct task_struct *kthread_create(int (*threadfn)(void *data),
                   void *data,
                   const char namefmt[],
                   ...)
{
    //初始化用于创建线程的辅助结构
    struct kthread_create_info create;
    DECLARE_WORK(work, keventd_create_kthread, &create);
    create.threadfn = threadfn;
    create.data = data;
    init_completion(&create.started);
    init_completion(&create.done);

    if (!helper_wq) //首先创建辅助工作队列
        work.func(work.data);
    else {
        //注意，“创建一个工作队列”这个工作本身又是属于helper_wq工作队列
        //的一项工作，所以，将这个工作加入的辅助工作队列中等待执行。
        queue_work(helper_wq, &work);
        wait_for_completion(&create.done);
    }
    ...
    return create.result;
}


    create_workqueue() -> __create_workqueue() -> create_workqueue_thread() -> kthread_create()
-> keventd_create_kthread()
//最终会调用kernel_thread为每个工作队列创建一个线程
//这样，被创建的线程会以create为数据执行kthread(如下),而kthread中则执行create中的threadfn(data)，
//即为create_workqueue_thread中的worker_thread(cwq)，即为我们工作队列要执行的函数了。

static void keventd_create_kthread(void *_create)
{
    struct kthread_create_info *create = _create;
    int pid;

    /* We want our own signal handler (we take no signals by default). */
    pid = kernel_thread(kthread, create, CLONE_FS | CLONE_FILES | SIGCHLD);
    if (pid < 0) {
        create->result = ERR_PTR(pid);
    } else {
        wait_for_completion(&create->started);
        read_lock(&tasklist_lock);
        create->result = find_task_by_pid(pid);
        read_unlock(&tasklist_lock);
    }
    complete(&create->done);
}

static int kthread(void *_create)
{
    struct kthread_create_info *create = _create;
    int (*threadfn)(void *data);
    void *data;
    ...
    threadfn = create->threadfn;
    data = create->data;
    ...
    if (!kthread_should_stop())
        ret = threadfn(data);
    ...
    return 0;
}

四、插入“工作”
/* Preempt must be disabled. */
static void __queue_work(struct cpu_workqueue_struct *cwq,
            struct work_struct *work)
{
    unsigned long flags;

    spin_lock_irqsave(&cwq->lock, flags);
    work->wq_data = cwq;
    //将当前工作插入到工作队列中待待执行
    list_add_tail(&work->entry, &cwq->worklist);
    cwq->insert_sequence++;
    wake_up(&cwq->more_work); //唤醒相应线程
    spin_unlock_irqrestore(&cwq->lock, flags);
}


int fastcall queue_work(struct workqueue_struct *wq, struct work_struct *work)
{
    int ret = 0, cpu = get_cpu();

    //如里当前工作未在队列中才插入
    if (!test_and_set_bit(0, &work->pending)) {
        ...
        __queue_work(per_cpu_ptr(wq->cpu_wq, cpu), work);
        ret = 1;
    }
    put_cpu();
    return ret;
}