工作队列(workqueue) create_workqueue/schedule_work/queue_work

原文地址：http://blog.csdn.net/angle_birds/article/details/8448070

项目需要，在驱动模块里用内核计时器timer_list实现了一个状态机。
郁闷的是，运行时总报错“Scheduling>一、workqueue简介

workqueue与tasklet类似，都是允许内核代码请求某个函数在将来的时间被调用（抄《ldd3》上的）
每个workqueue就是一个内核进程。

workqueue与tasklet的区别：
   1.tasklet是通过软中断实现的，在软中断上下文中运行，tasklet代码必须是原子的
    >二、workqueue的API

 
workqueue的API自2.6.20后发生了变化

1. #include <linux/workqueue.h>
   
2. struct> container_of(p_work, struct> create_workqueue("test_workqueue");
   
3.     if (!test_workqueue)
   
4.         panic("Failed>
   
   
   首先，创建一个workqueue，实际上就是建立一个内核进程
   
   
   1. create_workqueue("tap_workqueue")
      
   2. --> __create_workqueue(“tap_workqueue”, 0, 0)
      
   3. --> __create_workqueue_key((name), (singlethread), (freezeable), NULL, NULL){
      
   4.          wq = kzalloc(sizeof(*wq), GFP_KERNEL);
      
   5.          wq->cpu_wq = alloc_percpu(struct> name;
      
   6.          wq->singlethread = singlethread;
      
   7.          wq->freezeable = freezeable;
      
   8.          INIT_LIST_HEAD(&wq->list);
      
   9. 
      
   10.          for_each_possible_cpu(cpu) {
       
   11.              cwq = init_cpu_workqueue(wq, cpu);
       
   12.              err = create_workqueue_thread(cwq, cpu);
       
   13.              start_workqueue_thread(cwq, cpu);
       
   14.          }
       
   15.     }
   
   create_workqueue_thread 建立了一个内核进程> cwq->wq;
   
5. 
   
6.     const char *fmt = is_single_threaded(wq) ? "%s" : "%s/%d";
   
7.     struct> kthread_create(worker_thread, cwq, fmt, wq->name, cpu);
   
8. 
   
9.     if (IS_ERR(p))
   
10.         return PTR_ERR(p);
    
11. 
    
12.     cwq->thread = p;
    
13. 
    
14.     return 0;
    
15. }

内核进程worker_thread做的事情很简单，死循环而已，不停的执行workqueue上的work_list
（linux_2_6_24/kernel/workqueue.c）

1. int> __cwq;
   
2.     /*下面定义等待队列项*/
   
3.     DEFINE_WAIT(wait);
   
4. 
   
5.     /*下面freezeable一般为0*/
   
6.     if (cwq->wq->freezeable)
   
7.         set_freezable();
   
8. 
   
9.     /*提高优先级别*/
   
10.     set_user_nice(current, -5);
    
11. 
    
12.     for (;;) {
    
13.         /*在cwq->more_work上等待, 若有人调用queue_work,该函数将调用wake_up(&cwq->more_work) 激活本进程*/
    
14.         prepare_to_wait(&cwq->more_work, &wait, TASK_INTERRUPTIBLE);
    
15. 
    
16.         /*work队列空则切换出去*/
    
17.         if (!freezing(current) && !kthread_should_stop() && list_empty(&cwq->worklist))
    
18.             schedule();
    
19. 
    
20. 
    
21.         /*切换回来则结束等待 说明有人唤醒cwq->more_work上的等待 有work需要处理*/
    
22.         finish_wait(&cwq->more_work, &wait);
    
23. 
    
24.         /*下面空，因为没有定义电源管理*/
    
25.         try_to_freeze();
    
26. 
    
27.         if (kthread_should_stop())
    
28.             break;
    
29. 
    
30.         /*run_workqueue依次处理工作队列上所有的work*/
    
31.         run_workqueue(cwq);
    
32.     }
    
33.     return 0;
    
34. }
    
35. 
    
36. 
    
37. /*run_workqueue依次处理工作队列上所有的work*/
    
38. static> list_entry(cwq->worklist.next,
    
39.                         struct> work->func;
    
40. #ifdef CONFIG_LOCKDEP
    
41.         /*
    
42.          * It is permissible to free> work->lockdep_map;
    
43. #endif
    
44. 
    
45.         cwq->current_work = work;
    
46.         list_del_init(cwq->worklist.next);
    
47.         spin_unlock_irq(&cwq->lock);
    
48. 
    
49.         BUG_ON(get_wq_data(work) != cwq);
    
50.         work_clear_pending(work);
    
51.         lock_acquire(&cwq->wq->lockdep_map, 0, 0, 0, 2, _THIS_IP_);
    
52.         lock_acquire(&lockdep_map, 0, 0, 0, 2, _THIS_IP_);
    
53. 
    
54.         f(work); /*执行work项中的func*/
    
55.        
    
56.         lock_release(&lockdep_map, 1, _THIS_IP_);
    
57.         lock_release(&cwq->wq->lockdep_map, 1, _THIS_IP_);
    
58. 
    
59.         if (unlikely(in_atomic() || lockdep_depth(current) > 0)) {
    
60.             printk(KERN_ERR "BUG:> NULL;
    
61.     }
    
62.     cwq->run_depth--;
    
63.     spin_unlock_irq(&cwq->lock);
    
64. }

将一个work加入到指定workqueue的work_list中（文件linux_2_6_24/kernel/workqueue.c）

  int fastcall queue_work(struct> 0;

    if (!test_and_set_bit(WORK_STRUCT_PENDING, work_data_bits(work))) {

        BUG_ON(!list_empty(&work->entry));

        __queue_work(wq_per_cpu(wq, get_cpu()), work);

        put_cpu();

        ret = 1;

    }

    return ret;

} 

/* 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);

    insert_work(cwq, work, 1);

    spin_unlock_irqrestore(&cwq->lock, flags);

}

static void insert_work(struct cpu_workqueue_struct *cwq,

                struct work_struct *work, int tail)

{

    set_wq_data(work, cwq);

    /*

     * Ensure that we get the right work->data if we see the

     * result of list_add() below, see try_to_grab_pending().

     */

    smp_wmb();

    if (tail)

        list_add_tail(&work->entry, &cwq->worklist);

    else

        list_add(&work->entry, &cwq->worklist);

    wake_up(&cwq->more_work);

}

四、共享队列

其实内核有自己的一个workqueue，叫keventd_wq，这个工作队列也叫做“共享队列”。
do_basic_setup --> init_workqueues --> create_workqueue("events"); 

若驱动模块使用的workqueue功能很简单的话，可以使用“共享队列”，不用自己再建一个队列
使用共享队列，有这样一套API

1. int schedule_work(struct work_struct *work)
   
2. {
   
3.     queue_work(keventd_wq, work);
   
4. }
   
5. 
   
6. int schedule_delayed_work(struct delayed_work *dwork,unsigned long delay)
   
7. {
   
8.     timer_stats_timer_set_start_info(&dwork->timer);
   
9.     return queue_delayed_work(keventd_wq, dwork, delay);
   
10. }
    
11. 
    
12. void flush_scheduled_work(void)
    
13. {
    
14.     flush_workqueue(keventd_wq);
    
15. }