【原創】Linux中斷子系統（四）-Workqueue

背景

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

說明：

1. Kernel版本：4.14
2. ARM64處理器，Contex-A53，雙核
3. 使用工具：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秒，則會將其進行銷燬；

1. Running->Suspend
   

• 當worker進入睡眠狀態時，若是該worker_pool沒有其餘的worker處於運行狀態，那麼是須要喚醒一個空閒的worker來維持併發處理的能力；

2. Suspend->Running
   

• 睡眠狀態能夠經過wake_up_worker來進行喚醒處理，最終判斷若是該worker不在運行狀態，則增長worker_pool的nr_running值；

3.3.2 worker的動態添加和刪除

1. 動態刪除
   

• worker_pool初始化時，註冊了timer的回調函數，用於定時對空閒鏈表上的worker進行處理，若是worker太多，且空閒時間太長，超過了5分鐘，那麼就直接進行銷燬處理了；

2. 動態添加
   

• 內核線程執行worker_thread函數時，若是沒有空閒的worker，會調用manage_workers接口來建立更多的worker來處理工做；

參考

Documentation/core-api/workqueue.rst
http://kernel.meizu.com/linux-workqueue.html

洗洗睡了，收工！

歡迎關注公衆號，不按期分享Linux內核機制文章