Linux內核分析之工作隊列

可延遲函數和工作隊列非常相似，但是他們的區別還是很大的。主要區別在於：可延遲函數運行在中斷上下文中，而工作隊列中的函數運行在進程上下文中。在中斷上下文中不可能發生進程切換。可延遲函數和工作隊列中的函數都不能訪問進程的用戶態地址空間。

涉及數據結構

1. /*
2. * The per-CPU workqueue (if single thread, we always use the first
3. * possible cpu).
4. */
5. struct cpu_workqueue_struct {
7. spinlock_t lock;/*保護該數據結構的自旋鎖*/
9. struct list_head worklist;/*掛起鏈表的頭結點*/
10. /*等待隊列，其中的工作者線程因等待跟多
11. 的工作而處於睡眠狀態*/
12. wait_queue_head_t more_work;
13. /*等待隊列，其中的進程由於等待工作隊列
14. 被刷新而處於睡眠狀態*/
15. struct work_struct *current_work;
17. struct workqueue_struct *wq;
18. struct task_struct *thread;/*指向結構中工作者線程的進程描述符指針*/
19. } ____cacheline_aligned;
21. /*
22. * The externally visible workqueue abstraction is an array of
23. * per-CPU workqueues:
24. */
25. struct workqueue_struct {
26. struct cpu_workqueue_struct *cpu_wq;
27. struct list_head list;
28. const char *name;
29. int singlethread;
30. int freezeable; /* Freeze threads during suspend */
31. int rt;
32. #ifdef CONFIG_LOCKDEP
33. struct lockdep_map lockdep_map;
34. #endif
35. };

工作隊列操作

創建

最終都會調用如下函數執行

1. struct workqueue_struct *__create_workqueue_key(const char *name,
2. int singlethread,
3. int freezeable,
4. int rt,
5. struct lock_class_key *key,
6. const char *lock_name)
7. {
8. struct workqueue_struct *wq;
9. struct cpu_workqueue_struct *cwq;
10. int err = 0, cpu;
11. /*分配wq結構*/
12. wq = kzalloc(sizeof(*wq), GFP_KERNEL);
13. if (!wq)
14. return NULL;
15. /*分配cwq結構*/
16. wq->cpu_wq = alloc_percpu(struct cpu_workqueue_struct);
17. if (!wq->cpu_wq) {
18. kfree(wq);
19. return NULL;
20. }
22. wq->name = name;
23. lockdep_init_map(&wq->lockdep_map, lock_name, key, 0);
24. wq->singlethread = singlethread;
25. wq->freezeable = freezeable;
26. wq->rt = rt;
27. INIT_LIST_HEAD(&wq->list);
29. if (singlethread) {/*如果設置了單線程，只創建一個*/
30. /*初始化cwq*/
31. cwq = init_cpu_workqueue(wq, singlethread_cpu);
32. /*創建內核線程*/
33. err = create_workqueue_thread(cwq, singlethread_cpu);
34. /*喚醒剛創建的內核線程*/
35. start_workqueue_thread(cwq, -1);
36. } else {/*反之，每個cpu創建一個線程*/
37. cpu_maps_update_begin();
38. /*
39. * We must place this wq on list even if the code below fails.
40. * cpu_down(cpu) can remove cpu from cpu_populated_map before
41. * destroy_workqueue() takes the lock, in that case we leak
42. * cwq[cpu]->thread.
43. */
44. spin_lock(&workqueue_lock);
45. list_add(&wq->list, &workqueues);
46. spin_unlock(&workqueue_lock);
47. /*
48. * We must initialize cwqs for each possible cpu even if we
49. * are going to call destroy_workqueue() finally. Otherwise
50. * cpu_up() can hit the uninitialized cwq once we drop the
51. * lock.
52. */
53. for_each_possible_cpu(cpu) {/*對每個cpu*/
54. cwq = init_cpu_workqueue(wq, cpu);
55. if (err || !cpu_online(cpu))
56. continue;
57. err = create_workqueue_thread(cwq, cpu);
58. start_workqueue_thread(cwq, cpu);
59. }
60. cpu_maps_update_done();
61. }
63. if (err) {
64. destroy_workqueue(wq);
65. wq = NULL;
66. }
67. return wq;
68. }

可見，工作隊列在創建時就喚醒創建的內核線程，下面我們看看他創建的內核線程

1. static int worker_thread(void *__cwq)
2. {
3. struct cpu_workqueue_struct *cwq = __cwq;
4. DEFINE_WAIT(wait);
6. if (cwq->wq->freezeable)
7. set_freezable();
9. for (;;) {
10. prepare_to_wait(&cwq->more_work, &wait, TASK_INTERRUPTIBLE);
11. if (!freezing(current) &&
12. !kthread_should_stop() &&
13. list_empty(&cwq->worklist))
14. schedule();
15. finish_wait(&cwq->more_work, &wait);
17. try_to_freeze();
19. if (kthread_should_stop())
20. break;
21. /*執行工作隊列*/
22. run_workqueue(cwq);
23. }
25. return 0;
26. }