# 背景 - `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`並新增到工作佇列後，將會將其傳遞到合適的核心執行緒來進行處理，它是用於排程的最小單位。 關鍵欄位描述如下： ```c 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`關鍵欄位介紹如下： ```c 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`中由一個初始的空閒工作執行緒建立的，並根據需要動態建立和銷燬； 關鍵欄位描述如下： ```c 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`管理一個空閒連結串列和一個忙碌列表，其中忙碌列表由雜湊管理； 關鍵欄位描述如下： ```c 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`關聯起來； 關鍵欄位描述如下： ```c 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核心機制文章 ![](https://img2020.cnblogs.com/blog/1771657/202006/1771657-20200623234659953-1188996