Linux內核分析之工作隊列

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

涉及數據結構

1. /* 
2.  * The per-CPU workqueue (if single thread, we always use the first 
3.  * possible cpu). 
4.  */  
5. struct cpu_workqueue_struct {  
6.   
7.     spinlock_t lock;/*保護該數據結構的自旋鎖*/  
8.   
9.     struct list_head worklist;/*掛起鏈表的頭結點*/  
10.     /*等待隊列，其中的工作者線程因等待跟多 
11.     的工作而處於睡眠狀態*/  
12.     wait_queue_head_t more_work;  
13.     /*等待隊列，其中的進程由於等待工作隊列 
14.     被刷新而處於睡眠狀態*/  
15.     struct work_struct *current_work;  
16.       
17.     struct workqueue_struct *wq;  
18.     struct task_struct *thread;/*指向結構中工作者線程的進程描述符指針*/  
19. } ____cacheline_aligned;  
20.   
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.     }  
21.   
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);  
28.   
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.     }  
62.   
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);  
5.   
6.     if (cwq->wq->freezeable)  
7.         set_freezable();  
8.   
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);  
16.   
17.         try_to_freeze();  
18.   
19.         if (kthread_should_stop())  
20.             break;  
21.         /*執行工作隊列*/  
22.         run_workqueue(cwq);  
23.     }  
24.   
25.     return 0;  
26. }