工作队列(workqueue)

工作队列(workqueue) 2011-05-07 19:53:31

分类： LINUX

项目需要，在驱动模块里用内核计时器timer_list实现了一个状态机。
郁闷的是，运行时总报错“Scheduling while atomic”，网上搜了一下：

"Scheduling while atomic" indicates that you've tried to sleep somewhere that you shouldn't - like within a spinlock-protected critical section or an interrupt handler.

改进程序，在计时器里使用了workqueue，搞定问题。顺便把workqueue的实现代码总结了一下


一、workqueue简介

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

workqueue与tasklet的区别：
1.tasklet是通过软中断实现的，在软中断上下文中运行，tasklet代码必须是原子的
workqueue是通过内核进程实现的，就没有上述限制的，最爽的是，工作队列函数可以休眠

PS: 我的驱动模块就是印在计时器中调用了可休眠函数，所以出现了cheduling while atomic告警
内核计时器也是通过软中断实现的

2.tasklet始终运行在被初始提交的同一处理器上，workqueue不一定
3.tasklet不能确定延时时间（即使很短），workqueue可以设定延迟时间


二、workqueue的API


workqueue的API自2.6.20后发生了变化

1. #include <linux/workqueue.h>
   
2. struct workqueue_struct;
   
3. struct work_struct;
   
4. 
   
5. struct workqueue_struct *create_workqueue(const char *name);
   
6. void destroy_workqueue(struct workqueue_struct *queue);
   
7. 
   
8. INIT_WORK(_work, _func);
   
9. INIT_DELAYED_WORK(_work, _func);
   
10. 
    
11. int queue_work(struct workqueue_struct *wq, struct work_struct *work);
    
12. int queue_delayed_work(struct workqueue_struct *wq,struct delayed_work *dwork, unsigned long delay);
    
13. 
    
14. int queue_delayed_work_on(int cpu, struct workqueue_struct *wq,
    
15. struct delayed_work *dwork, unsigned long delay);
    
16. 
    
17. int cancel_work_sync(struct work_struct *work);
    
18. int cancel_delayed_work_sync(struct delayed_work *dwork);
    
19. 
    
20. void flush_workqueue(struct workqueue_struct *wq);

Workqueue编程接口

序号	接口函数	说明
1	create_workqueue	用于创建一个workqueue队列，为系统中的每个CPU都创建一个内核线程。输入参数： @name：workqueue的名称
2	create_singlethread_workqueue	用于创建workqueue，只创建一个内核线程。输入参数： @name：workqueue名称
3	destroy_workqueue	释放workqueue队列。输入参数： @ workqueue_struct：需要释放的workqueue队列指针
4	schedule_work	调度执行一个具体的任务，执行的任务将会被挂入Linux系统提供的workqueue——keventd_wq输入参数： @ work_struct：具体任务对象指针
5	schedule_delayed_work	延迟一定时间去执行一个具体的任务，功能与schedule_work类似，多了一个延迟时间，输入参数： @work_struct：具体任务对象指针 @delay：延迟时间
6	queue_work	调度执行一个指定workqueue中的任务。输入参数： @ workqueue_struct：指定的workqueue指针 @work_struct：具体任务对象指针
7	queue_delayed_work	延迟调度执行一个指定workqueue中的任务，功能与queue_work类似，输入参数多了一个delay。

下面实例是不指定delay时间的workqueue
(代码基于2.6.24)

1. struct my_work_stuct{
   
2. int test;
   
3. struct work_stuct save;
   
4. };
   
5. 
   
6. struct my_work_stuct test_work;
   
7. struct workqueue_struct *test_workqueue;
   
8. 
   
9. void do_save(struct work_struct *p_work)
   
10. {
    
11. struct my_work_struct *p_test_work = container_of(p_work, struct my_work_stuct, save);
    
12. printk("%d\n",p_test_work->test);
    
13. }
    
14. 
    
15. void test_init()
    
16. {
    
17. test_workqueue = create_workqueue("test_workqueue");
    
18. if (!test_workqueue)
    
19. panic("Failed to create test_workqueue\n");
    
20. 
    
21. INIT_WORK(&(test_work.save), do_save);
    
22. 
    
23. queue_work(test_workqueue, &(test_work.save));
24. }
    
25. 
    
26. void test_destory(void)
    
27. {
    
28. if(test_workqueue)
    
29. destroy_workqueue(test_workqueue);
    
30. }

三、workqueue的实现


工作队列workqueue不是通过软中断实现的，它是通过内核进程实现的



首先，创建一个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 cpu_workqueue_struct);
   
6. wq->name = name;
   
7. wq->singlethread = singlethread;
   
8. wq->freezeable = freezeable;
   
9. INIT_LIST_HEAD(&wq->list);
   
10. 
    
11. for_each_possible_cpu(cpu) {
    
12. cwq = init_cpu_workqueue(wq, cpu);
    
13. err = create_workqueue_thread(cwq, cpu);
    
14. start_workqueue_thread(cwq, cpu);
    
15. }
    
16. }

create_workqueue_thread 建立了一个内核进程 worker_thread（linux_2_6_24/kernel/workqueue.c）

1. create_workqueue_thread(struct cpu_workqueue_struct *cwq, int cpu)
   
2. {
   
3. struct workqueue_struct *wq = cwq->wq;
   
4. 
   
5. const char *fmt = is_single_threaded(wq) ? "%s" : "%s/%d";
   
6. struct task_struct *p;
   
7. 
   
8. p = kthread_create(worker_thread, cwq, fmt, wq->name, cpu);
   
9. 
   
10. if (IS_ERR(p))
    
11. return PTR_ERR(p);
    
12. 
    
13. cwq->thread = p;
    
14. 
    
15. return 0;
    
16. }

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

1. int worker_thread (void *__cwq)
   
2. {
   
3. struct cpu_workqueue_struct *cwq = __cwq;
   
4. /*下面定义等待队列项*/
   
5. DEFINE_WAIT(wait);
   
6. 
   
7. /*下面freezeable一般为0*/
   
8. if (cwq->wq->freezeable)
   
9. set_freezable();
   
10. 
    
11. /*提高优先级别*/
    
12. set_user_nice(current, -5);
    
13. 
    
14. for (;;) {
    
15. /*在cwq->more_work上等待, 若有人调用queue_work,该函数将调用wake_up(&cwq->more_work) 激活本进程*/
    
16. prepare_to_wait(&cwq->more_work, &wait, TASK_INTERRUPTIBLE);
    
17. 
    
18. /*work队列空则切换出去*/
    
19. if (!freezing(current) && !kthread_should_stop() && list_empty(&cwq->worklist))
    
20. schedule();
    
21. 
    
22. 
    
23. /*切换回来则结束等待 说明有人唤醒cwq->more_work上的等待 有work需要处理*/
    
24. finish_wait(&cwq->more_work, &wait);
    
25. 
    
26. /*下面空，因为没有定义电源管理*/
    
27. try_to_freeze();
    
28. 
    
29. if (kthread_should_stop())
    
30. break;
    
31. 
    
32. /*run_workqueue依次处理工作队列上所有的work*/
    
33. run_workqueue(cwq);
    
34. }
    
35. return 0;
    
36. }
    
37. 
    
38. 
    
39. /*run_workqueue依次处理工作队列上所有的work*/
    
40. static void run_workqueue(struct cpu_workqueue_struct *cwq)
    
41. {
    
42. spin_lock_irq(&cwq->lock);
    
43. cwq->run_depth++;
    
44. if (cwq->run_depth > 3) {
    
45. /* morton gets to eat his hat */
    
46. printk("%s: recursion depth exceeded: %d\n",
    
47. __FUNCTION__, cwq->run_depth);
    
48. dump_stack();
    
49. }
    
50. 
    
51. while (!list_empty(&cwq->worklist)) {
    
52. struct work_struct *work = list_entry(cwq->worklist.next,
    
53. struct work_struct, entry);
    
54. work_func_t f = work->func;
    
55. #ifdef CONFIG_LOCKDEP
    
56. /*
    
57. * It is permissible to free the struct work_struct
    
58. * from inside the function that is called from it,
    
59. * this we need to take into account for lockdep too.
    
60. * To avoid bogus "held lock freed" warnings as well
    
61. * as problems when looking into work->lockdep_map,
    
62. * make a copy and use that here.
    
63. */
    
64. struct lockdep_map lockdep_map = work->lockdep_map;
    
65. #endif
    
66. 
    
67. cwq->current_work = work;
    
68. list_del_init(cwq->worklist.next);
    
69. spin_unlock_irq(&cwq->lock);
    
70. 
    
71. BUG_ON(get_wq_data(work) != cwq);
    
72. work_clear_pending(work);
    
73. lock_acquire(&cwq->wq->lockdep_map, 0, 0, 0, 2, _THIS_IP_);
    
74. lock_acquire(&lockdep_map, 0, 0, 0, 2, _THIS_IP_);
    
75. 
    
76. f(work); /*执行work项中的func*/
    
77. 
    
78. lock_release(&lockdep_map, 1, _THIS_IP_);
    
79. lock_release(&cwq->wq->lockdep_map, 1, _THIS_IP_);
    
80. 
    
81. if (unlikely(in_atomic() || lockdep_depth(current) > 0)) {
    
82. printk(KERN_ERR "BUG: workqueue leaked lock or atomic: "
    
83. "%s/0x%08x/%d\n",
    
84. current->comm, preempt_count(),
    
85. task_pid_nr(current));
    
86. printk(KERN_ERR " last function: ");
    
87. print_symbol("%s\n", (unsigned long)f);
    
88. debug_show_held_locks(current);
    
89. dump_stack();
    
90. }
    
91. 
    
92. spin_lock_irq(&cwq->lock);
    
93. cwq->current_work = NULL;
    
94. }
    
95. cwq->run_depth--;
    
96. spin_unlock_irq(&cwq->lock);
    
97. }

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

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

1. {
   
2. int ret = 0;
   
3. 
   
4. if (!test_and_set_bit(WORK_STRUCT_PENDING, work_data_bits(work))) {
   
5. BUG_ON(!list_empty(&work->entry));
   
6. __queue_work(wq_per_cpu(wq, get_cpu()), work);
   
7. put_cpu();
   
8. ret = 1;
   
9. }
   
10. return ret;
    
11. }
    
12. 
    
13. 
    
14. /* Preempt must be disabled. */
    
15. static void __queue_work(struct cpu_workqueue_struct *cwq, struct work_struct *work)
    
16. {
    
17. unsigned long flags;
    
18. 
    
19. spin_lock_irqsave(&cwq->lock, flags);
    
20. insert_work(cwq, work, 1);
    
21. spin_unlock_irqrestore(&cwq->lock, flags);
    
22. }
    
23. 
    
24. static void insert_work(struct cpu_workqueue_struct *cwq,
    
25. struct work_struct *work, int tail)
    
26. {
    
27. set_wq_data(work, cwq);
    
28. /*
    
29. * Ensure that we get the right work->data if we see the
    
30. * result of list_add() below, see try_to_grab_pending().
    
31. */
    
32. smp_wmb();
    
33. if (tail)
    
34. list_add_tail(&work->entry, &cwq->worklist);
    
35. else
    
36. list_add(&work->entry, &cwq->worklist);
    
37. wake_up(&cwq->more_work);
    
38. }

四、共享队列

其实内核有自己的一个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. }