工作队列

参考：1、http://blog.csdn.net/droidphone/article/details/7518428

          2、http://blog.csdn.net/lizhiguo0532/article/details/6533443

          3、《内核设计与实现》

          4、2.6.34

首先，看下默认工作队列keventd_wq和管理调度其它内核线程（当然也包含工作线程）时需要的kthreadd线程的创建过程；

start_kernel()---->rest_init()

                  |---->kernel_thread(kernel_init, NULL, CLONE_FS | \
                  |                   CLONE_SIGHAND);

                  |       

                  |---->pid = kernel_thread(kthreadd, NULL, CLONE_FS | \
                  |                   CLONE_FILES);

                  |----kthreadd_task = find_task_by_pid_ns(pid, &init_pid_ns);

                  |    kthreadd_task保存线程kthreadd的task_struct结构体地址

                  |    kthreadd线程根据kthread_create_list上链入的kthread_create_info结构体来创建特定线程. 


kthreadd的工作流程，从kthread_create_list上取下信息，来创建新的内核线程。

kthreadd()---->struct kthread_create_info *create;

         |     create = list_entry(kthread_create_list.next,

         |                         struct kthread_create_info, list);

         |----create_kthread(create);

              |----pid = kernel_thread(kthread, create, CLONE_FS | \
              |                        CLONE_FILES | SIGCHLD);

static int kthread(void *_create)

    |----int (*threadfn)(void *data) = create->threadfn;

    |----void *data = create->data;

    |----create->result = current; //kthread_create_info的result保存新创建内核线程的task_struct结构体指针

    |----complete(&create->done);

    |----ret = threadfn(data); //根据kthread_create_info的信息执行相应的函数

    |----do_exit(ret);

 

kernel_init()---->do_basic_setup()
                  |---->init_workqueues()

init_workqueues()---->keventd_wq = create_workqueue("events"); //创建kevent_wq工作队列

 

如何创建kevent_wq工作队列，如下：

create_workqueue("events")

    |---- __create_workqueue_key("event", 0, 0, 0, NULL, NUL)； //非signle，每个核上都创建

__create_workqueue_key("event", 0, 0, 0, NULL, NULL)

   |---->struct workqueue_struct *wq;

   |     struct cpu_workqueue_struct *cwq;

   |     wq = kzalloc(sizeof(*wq), GFP_KERNEL);

   |     wq->cpu_wq = alloc_percpu(struct cpu_workqueue_struct);

   |

   |----list_add(&wq->list, &workqueues);所有的workqueue都链入workqueues

   |

   |对于该类型的工作队列

   |在每个核上都建立一个对应的工作线程

   |for_each_possible_cpu(cpu)

   |---->cwq = init_cpu_workqueue(wq, cpu);

   |---->err = create_workqueue_thread(cwq, cpu);


在每个核上如何创建工作线程，如下：

int create_workqueue_thread(struct cpu_workqueue_struct *cwq, int cpu)

   |---->struct task_struct *p;

   |     p = kthread_create(worker_thread, cwq, fmt, wq->name, cpu);

         |---->struct kthread_create_info create;

         |     create.threadfn = threadfn;

         |     create.data = data;

         |---->init_completion(&create.done); //初始化完成量

         |

         |---->list_add_tail(&create.list, &kthread_create_list);

         |         将新建的create链接到全局的线程链表kthread_create_list中

         |

         |---->wake_up_process(kthreadd_task); //唤起threadd线程来创建新的内核线程

         |    kthread_task保存内核线程kthreadd的task_struct地址

         | 直接效果就是worker_thread(cwq);

         |

         |---->wait_for_completion(&create.done);

         |.......

  |cwq->thread = p;

对于每一种类型的工作队列，除了signlethread情形外，在各个核上都创建了相应类型的工作线程。无论时哪种类型的工作队列，各个工作线程最终都会调用worke_thread线程函数。

static int worker_thread(void* __cwq)

    |----DEFINE_WAIT(wait);

    |

    |循环forever

    |---->prepare_to_wait(&cwq->more_work, &wait, TASK_INTERRUPTIBLE);

    |

    |         if (!freezing(current) &&

    |             !kthread_should_stop() &&

    |             list_empty(&cwq->worklist))

    |                   schedule();//队列上没有工作，睡眠

    |

    |       finish_wait(&cwq->more_work, &wait);

    |        

    |       try_to_freeze();

    |       

    |       if (kthread_should_stop())

    |              break;

    |       

    |       run_workqueue(cwq);//执行对列上的工作

    |.....never_exit

run_workqueue(cwq)

    |----struct work_struct *work = 

    |    list_entry(cwq->worklist.next, struct work_struct, entry)

    |----work_func_t f = work->func;

    |----cwq->current_work = work;

    |    list_del_init(cwq->worklist.next);

    |    work_clear_pending(work);

    |    f(work); //执行相应的工作函数

    |----cwq->current_work = NULL;                                                                                

我们看到，在worker_thread中，工作线程将睡眠，那么何时将其唤醒，构建完工作后，将schedule_work，此函数中将唤醒默认的工作线程。

将工作提交给默认队列时所进行的业务：

int schedule_work(struct work_struct *work)

    |---->queue_work(keventd_wq, work); 

    |     keventd_wq工作队列是在函数init_workqueues()中创建的


queue_work()

int queue_work(struct workqueue_struct *wq, struct work_struct *work)

    |---->queue_work_on(get_cpu(), wq, work);

         |---->__queue_work(wq_per_cpu(wq, cpu), work);


__queue_work()

static void __queue_work(struct cpu_workqueue_struct *cwq,

                         struct work_struct *work)

    |----insert_work(cwq, work, &cwq->worklist);

         |---->set_wq_data(work, cwq); //注意work_struct结构体中data域的用法

               |----new = (unsigned long) cwq | 

               |           (1UL << WORK_STRUCT_PENDING);

               |----new |= WORK_STRUCT_FLAG_MASK & 

               |           *work_data_bits(work);

               |----atomic_long_set(&work->data, new);

         |---->list_add_tail(&work->entry, head);

         |     将工作项加入等待队列

         |---->wake_up(&cwq->more_work);

         |     唤醒等待在该等待队列头上的所有等待队列项

至于创建新的工作队列（相应的创建工作线程），由于以上流程从kevetd_wq工作队列的创建开始分析，因此很容易。