背景

Read the fucking source code! --By 魯迅
A picture is worth a thousand words. --By 高爾基

說明：

Kernel版本：4.14
ARM64處理器，Contex-A53，雙核
使用工具：Source Insight 3.5， Visio

1. 概述

Workqueue作業佇列是利用內核執行緒來異步執行作業任務的通用機制；
Workqueue作業佇列可以用作中斷處理的Bottom-half機制，利用行程背景關系來執行中斷處理中耗時的任務，因此它允許睡眠，而Softirq和Tasklet在處理任務時不能睡眠；

來一張概述圖：

在中斷處理程序中，或者其他子系統中，呼叫workqueue的調度或入隊介面后，通過建立好的鏈接關系圖逐級找到合適的worker，最終完成作業任務的執行；

2. 資料結構

2.1 總覽

此處應有圖：

先看看關鍵的資料結構：
1. work_struct：作業佇列調度的最小單位，work item；
2. workqueue_struct：作業佇列，work item都掛入到作業佇列中；
3. worker：work item的處理者，每個worker對應一個內核執行緒；
4. worker_pool：worker池（內核執行緒池），是一個共享資源池，提供不同的worker來對work item進行處理；
5. pool_workqueue：充當橋梁紐帶的作用，用于連接workqueue和worker_pool，建立鏈接關系；

下邊看看細節吧：

2.2 work

struct work_struct用來描述work，初始化一個work并添加到作業佇列后，將會將其傳遞到合適的內核執行緒來進行處理，它是用于調度的最小單位，

關鍵欄位描述如下：

struct work_struct {
	atomic_long_t data;     //低位元存放狀態位，高位元存放worker_pool的ID或者pool_workqueue的指標
	struct list_head entry; //用于添加到其他佇列上
	work_func_t func;       //作業任務的處理函式，在內核執行緒中回呼
#ifdef CONFIG_LOCKDEP
	struct lockdep_map lockdep_map;
#endif
};

圖片說明下data欄位：

2.3 workqueue

內核中作業佇列分為兩種：
1. bound：系結處理器的作業佇列，每個worker創建的內核執行緒系結到特定的CPU上運行；
2. unbound：不系結處理器的作業佇列，創建的時候需要指定WQ_UNBOUND標志，內核執行緒可以在處理器間遷移；
內核默認創建了一些作業佇列（用戶也可以創建）：
1. system_mq：如果work item執行時間較短，使用本佇列，呼叫schedule[_delayed]_work[_on]()介面就是添加到本佇列中；
2. system_highpri_mq：高優先級作業佇列，以nice值-20來運行；
3. system_long_wq：如果work item執行時間較長，使用本佇列；
4. system_unbound_wq：該作業佇列的內核執行緒不系結到特定的處理器上；
5. system_freezable_wq：該作業佇列用于在Suspend時可凍結的work item；
6. system_power_efficient_wq：該作業佇列用于節能目的而選擇犧牲性能的work item；
7. system_freezable_power_efficient_wq：該作業佇列用于節能或Suspend時可凍結目的的work item；

struct workqueue_struct關鍵欄位介紹如下：

struct workqueue_struct {
	struct list_head	pwqs;		/* WR: all pwqs of this wq */   //所有的pool_workqueue都添加到本鏈表中
	struct list_head	list;		/* PR: list of all workqueues */    //用于將作業佇列添加到全域鏈表workqueues中

	struct list_head	maydays;	/* MD: pwqs requesting rescue */    //rescue狀態下的pool_workqueue添加到本鏈表中
	struct worker		*rescuer;	/* I: rescue worker */  //rescuer內核執行緒，用于處理記憶體緊張時創建作業執行緒失敗的情況

	struct pool_workqueue	*dfl_pwq;	/* PW: only for unbound wqs */

	char			name[WQ_NAME_LEN]; /* I: workqueue name */

	/* hot fields used during command issue, aligned to cacheline */
	unsigned int		flags ____cacheline_aligned; /* WQ: WQ_* flags */
	struct pool_workqueue __percpu *cpu_pwqs; /* I: per-cpu pwqs */     //Per-CPU都創建pool_workqueue
	struct pool_workqueue __rcu *numa_pwq_tbl[]; /* PWR: unbound pwqs indexed by node */    //Per-Node創建pool_workqueue
    ...
};

2.4 worker

每個worker對應一個內核執行緒，用于對work item的處理；
worker根據作業狀態，可以添加到worker_pool的空閑鏈表或忙碌串列中；
worker處于空閑狀態時并接收到作業處理請求，將喚醒內核執行緒來處理；
內核執行緒是在每個worker_pool中由一個初始的空閑作業執行緒創建的，并根據需要動態創建和銷毀；

關鍵欄位描述如下：

struct worker {
	/* on idle list while idle, on busy hash table while busy */
	union {
		struct list_head	entry;	/* L: while idle */     //用于添加到worker_pool的空閑鏈表中
		struct hlist_node	hentry;	/* L: while busy */ //用于添加到worker_pool的忙碌串列中
	};

	struct work_struct	*current_work;	/* L: work being processed */   //當前正在處理的work
	work_func_t		current_func;	/* L: current_work's fn */                  //當前正在執行的work回呼函式
	struct pool_workqueue	*current_pwq; /* L: current_work's pwq */   //指向當前work所屬的pool_workqueue

	struct list_head	scheduled;	/* L: scheduled works */    //所有被調度執行的work都將添加到該鏈表中

	/* 64 bytes boundary on 64bit, 32 on 32bit */

	struct task_struct	*task;		/* I: worker task */    //指向內核執行緒
	struct worker_pool	*pool;		/* I: the associated pool */    //該worker所屬的worker_pool
						/* L: for rescuers */
	struct list_head	node;		/* A: anchored at pool->workers */  //添加到worker_pool->workers鏈表中
						/* A: runs through worker->node */
    ...
};

2.5 worker_pool

worker_pool是一個資源池，管理多個worker，也就是管理多個內核執行緒；
針對系結型別的作業佇列，worker_pool是Per-CPU創建，每個CPU都有兩個worker_pool，對應不同的優先級，nice值分別為0和-20；
針對非系結型別的作業佇列，worker_pool創建后會添加到unbound_pool_hash哈希表中；
worker_pool管理一個空閑鏈表和一個忙碌串列，其中忙碌串列由哈希管理；

關鍵欄位描述如下：

struct worker_pool {
	spinlock_t		lock;		/* the pool lock */
	int			cpu;		/* I: the associated cpu */     //系結到CPU的workqueue，代表CPU ID
	int			node;		/* I: the associated node ID */ //非系結型別的workqueue，代表記憶體Node ID
	int			id;		/* I: pool ID */
	unsigned int		flags;		/* X: flags */

	unsigned long		watchdog_ts;	/* L: watchdog timestamp */

	struct list_head	worklist;	/* L: list of pending works */  //pending狀態的work添加到本鏈表
	int			nr_workers;	/* L: total number of workers */    //worker的數量

	/* nr_idle includes the ones off idle_list for rebinding */
	int			nr_idle;	/* L: currently idle ones */

	struct list_head	idle_list;	/* X: list of idle workers */   //處于IDLE狀態的worker添加到本鏈表
	struct timer_list	idle_timer;	/* L: worker idle timeout */
	struct timer_list	mayday_timer;	/* L: SOS timer for workers */

	/* a workers is either on busy_hash or idle_list, or the manager */
	DECLARE_HASHTABLE(busy_hash, BUSY_WORKER_HASH_ORDER);   //作業狀態的worker添加到本哈希表中
						/* L: hash of busy workers */

	/* see manage_workers() for details on the two manager mutexes */
	struct worker		*manager;	/* L: purely informational */
	struct mutex		attach_mutex;	/* attach/detach exclusion */
	struct list_head	workers;	/* A: attached workers */   //worker_pool管理的worker添加到本鏈表中
	struct completion	*detach_completion; /* all workers detached */

	struct ida		worker_ida;	/* worker IDs for task name */

	struct workqueue_attrs	*attrs;		/* I: worker attributes */
	struct hlist_node	hash_node;	/* PL: unbound_pool_hash node */    //用于添加到unbound_pool_hash中
    ...
} ____cacheline_aligned_in_smp;

2.6 pool_workqueue

pool_workqueue充當紐帶的作用，用于將workqueue和worker_pool關聯起來；

關鍵欄位描述如下：

struct pool_workqueue {
	struct worker_pool	*pool;		/* I: the associated pool */    //指向worker_pool
	struct workqueue_struct *wq;		/* I: the owning workqueue */   //指向所屬的workqueue

	int			nr_active;	/* L: nr of active works */     //活躍的work數量
	int			max_active;	/* L: max active works */   //活躍的最大work數量
	struct list_head	delayed_works;	/* L: delayed works */      //延遲執行的work掛入本鏈表
	struct list_head	pwqs_node;	/* WR: node on wq->pwqs */      //用于添加到workqueue鏈表中
	struct list_head	mayday_node;	/* MD: node on wq->maydays */   //用于添加到workqueue鏈表中
    ...
} __aligned(1 << WORK_STRUCT_FLAG_BITS);

2.7 小結

再來張圖，首尾呼應一下：

3. 流程分析

3.1 workqueue子系統初始化

workqueue子系統的初始化分成兩步來完成的：workqueue_init_early和workqueue_init，

3.1.1 workqueue_init_early

workqueue子系統早期初始化函式完成的主要作業包括：
1. 創建pool_workqueue的SLAB快取，用于動態分配struct pool_workqueue結構；
2. 為每個CPU都分配兩個worker_pool，其中的nice值分別為0和HIGHPRI_NICE_LEVEL，并且為每個worker_pool從worker_pool_idr中分配一個ID號；
3. 為unbound作業佇列創建默認屬性，struct workqueue_attrs屬性，主要描述內核執行緒的nice值，以及cpumask值，分別針對優先級以及允許在哪些CPU上執行；
4. 為系統默認創建幾個作業佇列，這幾個作業佇列的描述在上文的資料結構部分提及過，不再贅述；

從圖中可以看出創建作業佇列的介面為：alloc_workqueue，如下圖：

alloc_workqueue完成的主要作業包括：
1. 首先當然是要分配一個struct workqueue_struct的資料結構，并且對該結構中的欄位進行初始化操作；
2. 前文提到過workqueue最終需要和worker_pool關聯起來，而這個紐帶就是pool_workqueue，alloc_and_link_pwqs函式就是完成這個功能：1）如果作業佇列是系結到CPU上的，則為每個CPU都分配pool_workqueue并且初始化，通過link_pwq將作業佇列與pool_workqueue建立連接；2）如果作業佇列不系結到CPU上，則按記憶體節點（NUMA，參考之前記憶體管理的文章）來分配pool_workqueue，呼叫get_unbound_pool來實作，它會根據wq屬性先去查找，如果沒有找到相同的就創建一個新的pool_workqueue，并且添加到unbound_pool_hash哈希表中，最后也會呼叫link_pwq來建立連接；
3. 創建作業佇列時，如果設定了WQ_MEM_RECLAIM標志，則會新建rescuer worker，對應rescuer_thread內核執行緒，當記憶體緊張時，新創建worker可能會失敗，這時候由rescuer來處理這種情況；
4. 最終將新建好的作業佇列添加到全域鏈表workqueues中；

3.1.2 workqueue_init

workqueue子系統第二階段的初始化：

主要完成的作業是給之前創建好的worker_pool，添加一個初始的worker；
create_worker函式中，創建的內核執行緒名字為kworker/XX:YY或者kworker/uXX:YY，其中XX表示worker_pool的編號，YY表示worker的編號，u表示unbound；

workqueue子系統初始化完成后，基本就已經將資料結構的關聯建立好了，當有work來進行調度的時候，就可以進行處理了，

3.2 work調度

3.2.1 schedule_work

以schedule_work介面為例進行分析：

schedule_work默認是將work添加到系統的system_work作業佇列中；
queue_work_on介面中的操作判斷要添加work的標志位，如果已經置位了WORK_STRUCT_PENDING_BIT，表明已經添加到了佇列中等待執行了，否則，需要呼叫__queue_work來進行添加，注意了，這個操作是在關中斷的情況下進行的，因為作業佇列使用WORK_STRUCT_PENDING_BIT位來同步work的插入和洗掉操作，設定了這個位元后，然后才能執行work，這個程序可能被中斷或搶占打斷；
workqueue的標志位設定了__WQ_DRAINING，表明作業佇列正在銷毀，所有的work都要處理完，此時不允許再將work添加到佇列中，有一種特殊情況：銷毀程序中，執行work時又觸發了新的work，也就是所謂的chained work；
判斷workqueue的型別，如果是bound型別，根據CPU來獲取pool_workqueue，如果是unbound型別，通過node號來獲取pool_workqueue；
get_work_pool獲取上一次執行work的worker_pool，如果本次執行的worker_pool與上次執行的worker_pool不一致，且通過find_worker_executing_work判斷work正在某個worker_pool中的worker中執行，考慮到快取熱度，放到該worker執行是更合理的選擇，進而根據該worker獲取到pool_workqueue；
判斷pool_workqueue活躍的work數量，少于最大限值則將work加入到pool->worklist中，否則加入到pwq->delayed_works鏈表中，如果__need_more_worker判斷沒有worker在執行，則喚醒worker內核執行緒執行；
總結：
1. schedule_work完成的作業是將work添加到對應的鏈表中，而在添加的程序中，首先是需要確定pool_workqueue；
2. pool_workqueue對應一個worker_pool，因此確定了pool_workqueue也就確定了worker_pool，進而可以將work添加到作業鏈表中；
3. pool_workqueue的確定分為三種情況：1）bound型別的作業佇列，直接根據CPU號獲取；2）unbound型別的作業佇列，根據node號獲取，針對unbound型別作業佇列，pool_workqueue的釋放是異步執行的，需要判斷refcnt的計數值，因此在獲取pool_workqueue時可能要多次retry；3）根據快取熱度，優先選擇正在被執行的worker_pool；

3.2.2 worker_thread

work添加到作業佇列后，最終的執行在worker_thread函式中：

在創建worker時，創建內核執行緒，執行函式為worker_thread；
worker_thread在開始執行時，設定標志位PF_WQ_WORKER，調度器在進行調度處理時會對task進行判斷，針對workerqueue worker有特殊處理；
worker對應的內核執行緒，在沒有處理work的時候是睡眠狀態，當被喚醒的時候，跳轉到woke_up開始執行；
woke_up之后，如果此時worker是需要銷毀的，那就進行清理作業并回傳，否則，離開IDLE狀態，并進入recheck模塊執行；
recheck部分，首先判斷是否需要更多的worker來處理，如果沒有任務處理，跳轉到sleep地方進行睡眠，有任務需要處理時，會判斷是否有空閑內核執行緒以及是否需要動態創建，再清除掉worker的標志位，然后遍歷作業鏈表，對鏈表中的每個節點呼叫process_one_worker來處理；
sleep部分比較好理解，沒有任務處理時，worker進入空閑狀態，并將當前的內核執行緒設定成睡眠狀態，讓出CPU；
總結：
1. 管理worker_pool的內核執行緒池時，如果有PENDING狀態的work，并且發現沒有正在運行的作業執行緒(worker_pool->nr_running == 0)，喚醒空閑狀態的內核執行緒，或者動態創建內核執行緒；
2. 如果work已經在同一個worker_pool的其他worker中執行，不再對該work進行處理；

work的執行函式為process_one_worker：

work可能在同一個CPU上不同的worker中運行，直接退出；
呼叫worker->current_func()，完成最終work的回呼函式執行；

3.3 worker動態管理

3.3.1 worker狀態機變換

worker_pool通過nr_running欄位來在不同的狀態機之間進行切換；
worker_pool中有work需要處理時，需要至少保證有一個運行狀態的worker，當nr_running大于1時，將多余的worker進入IDLE狀態，沒有work需要處理時，所有的worker都會進入IDLE狀態；
執行work時，如果回呼函式阻塞運行，那么會讓worker進入睡眠狀態，此時調度器會進行判斷是否需要喚醒另一個worker；
IDLE狀態的worker都存放在idle_list鏈表中，如果空閑時間超過了300秒，則會將其進行銷毀；