2. 程式人生 > >Linux中斷（interrupt）子系統之五：軟體中斷（softIRQ）

Linux中斷（interrupt）子系統之五：軟體中斷（softIRQ）

阿新 • • 發佈：2019-02-05

軟體中斷（softIRQ）是核心提供的一種延遲執行機制，它完全由軟體觸發，雖然說是延遲機制，實際上，在大多數情況下，它與普通程序相比，能得到更快的響應時間。軟中斷也是其他一些核心機制的基礎，比如tasklet，高解析度timer等。

/*****************************************************************************************************/
宣告：本博內容均由http://blog.csdn.net/droidphone原創，轉載請註明出處，謝謝！
/*****************************************************************************************************/

1.  軟體中斷的資料結構 1.1  struct softirq_action         核心用softirq_action結構管理軟體中斷的註冊和啟用等操作，它的定義如下：

點選(此處)摺疊或開啟

  1. struct softirq_action
  2. {
  3.     void    (*action)(struct softirq_action *);
  4. };

非常簡單，只有一個用於回撥的函式指標。軟體中斷的資源是有限的，核心目前只實現了10種類型的軟體中斷，它們是：

點選(此處)摺疊或開啟

  1. enum
  2. {
  3.     HI_SOFTIRQ=0,
  4.     TIMER_SOFTIRQ,

  5.     NET_TX_SOFTIRQ,
  6.     NET_RX_SOFTIRQ,
  7.     BLOCK_SOFTIRQ,
  8.     BLOCK_IOPOLL_SOFTIRQ,
  9.     TASKLET_SOFTIRQ,
  10.     SCHED_SOFTIRQ,
  11.     HRTIMER_SOFTIRQ,
  12.     RCU_SOFTIRQ, /* Preferable RCU should always be the last softirq */
  13.     NR_SOFTIRQS
  14. };

核心的開發者們不建議我們擅自增加軟體中斷的數量，如果需要新的軟體中斷，儘可能把它們實現為基於軟體中斷的tasklet形式。與上面的列舉值相對應，核心定義了一個softirq_action的結構陣列，每種軟中斷對應陣列中的一項：

點選(此處)摺疊或開啟

  1. static struct softirq_action softirq_vec[NR_SOFTIRQS] __cacheline_aligned_in_smp;

1.2  irq_cpustat_t         多個軟中斷可以同時在多個cpu執行，就算是同一種軟中斷，也有可能同時在多個cpu上執行。核心為每個cpu都管理著一個待決軟中斷變數（pending），它就是irq_cpustat_t：

點選(此處)摺疊或開啟

  1. typedef struct {
  2.     unsigned int __softirq_pending;
  3. } ____cacheline_aligned irq_cpustat_t;

點選(此處)摺疊或開啟

  1. irq_cpustat_t irq_stat[NR_CPUS] ____cacheline_aligned;

__softirq_pending欄位中的每一個bit，對應著某一個軟中斷，某個bit被置位，說明有相應的軟中斷等待處理。
1.3  軟中斷的守護程序ksoftirqd         在cpu的熱插拔階段，核心為每個cpu建立了一個用於執行軟體中斷的守護程序ksoftirqd，同時定義了一個per_cpu變數用於儲存每個守護程序的task_struct結構指標：

點選(此處)摺疊或開啟

  1. DEFINE_PER_CPU(struct task_struct *, ksoftirqd);

大多數情況下，軟中斷都會在irq_exit階段被執行，在irq_exit階段沒有處理完的軟中斷才有可能會在守護程序中執行。
2.  觸發軟中斷         要觸發一個軟中斷，只要呼叫api：raise_softirq即可，它的實現很簡單，先是關閉本地cpu中斷，然後呼叫：raise_softirq_irqoff

點選(此處)摺疊或開啟

  1. void raise_softirq(unsigned int nr)
  2. {
  3.     unsigned long flags;
  4.     local_irq_save(flags);
  5.     raise_softirq_irqoff(nr);
  6.     local_irq_restore(flags);
  7. }

再看看raise_softirq_irqoff：

點選(此處)摺疊或開啟

  1. inline void raise_softirq_irqoff(unsigned int nr)
  2. {
  3.     __raise_softirq_irqoff(nr);
  4.         ......
  5.     if (!in_interrupt())
  6.         wakeup_softirqd();
  7. }

先是通過__raise_softirq_irqoff設定cpu的軟中斷pending標誌位（irq_stat[NR_CPUS] ），然後通過in_interrupt判斷現在是否在中斷上下文中，或者軟中斷是否被禁止，如果都不成立，則喚醒軟中斷的守護程序，在守護程序中執行軟中斷的回撥函式。否則什麼也不做，軟中斷將會在中斷的退出階段被執行。

3.  軟中斷的執行         基於上面所說，軟中斷的執行既可以守護程序中執行，也可以在中斷的退出階段執行。實際上，軟中斷更多的是在中斷的退出階段執行（irq_exit），以便達到更快的響應，加入守護程序機制，只是擔心一旦有大量的軟中斷等待執行，會使得核心過長地留在中斷上下文中。
3.1  在irq_exit中執行         看看irq_exit的部分：

點選(此處)摺疊或開啟

  1. void irq_exit(void)
  2. {
  3.         ......
  4.     sub_preempt_count(IRQ_EXIT_OFFSET);
  5.     if (!in_interrupt() && local_softirq_pending())
  6.         invoke_softirq();
  7.         ......
  8. }

如果中斷髮生巢狀，in_interrupt()保證了只有在最外層的中斷的irq_exit階段，invoke_interrupt才會被呼叫，當然，local_softirq_pending也會實現判斷當前cpu有無待決的軟中斷。程式碼最終會進入__do_softirq中，核心會保證呼叫__do_softirq時，本地cpu的中斷處於關閉狀態，進入__do_softirq：

點選(此處)摺疊或開啟

  1. asmlinkage void __do_softirq(void)
  2. {
  3.         ......
  4.     pending = local_softirq_pending();
  5.     __local_bh_disable((unsigned long)__builtin_return_address(0),
  6.                 SOFTIRQ_OFFSET);
  7. restart:
  8.     /* Reset the pending bitmask before enabling irqs */
  9.     set_softirq_pending(0);
  10.     local_irq_enable();
  11.     h = softirq_vec;
  12.     do {
  13.         if (pending & 1) {
  14.      ......
  15.             trace_softirq_entry(vec_nr);
  16.             h->action(h);
  17.             trace_softirq_exit(vec_nr);
  18.                         ......
  19.         }
  20.         h++;
  21.         pending >>= 1;
  22.     } while (pending);
  23.     local_irq_disable();
  24.     pending = local_softirq_pending();
  25.     if (pending && --max_restart)
  26.         goto restart;
  27.     if (pending)
  28.         wakeup_softirqd();
  29.     lockdep_softirq_exit();
  30.     __local_bh_enable(SOFTIRQ_OFFSET);
  31. }

  • 首先取出pending的狀態；
  • 禁止軟中斷，主要是為了防止和軟中斷守護程序發生競爭；
  • 清除所有的軟中斷待決標誌；
  • 開啟本地cpu中斷；
  • 迴圈執行待決軟中斷的回撥函式；
  • 如果迴圈完畢，發現新的軟中斷被觸發，則重新啟動迴圈，直到以下條件滿足，才退出：
    • 沒有新的軟中斷等待執行；
    • 迴圈已經達到最大的迴圈次數MAX_SOFTIRQ_RESTART，目前的設定值時10次；
  • 如果經過MAX_SOFTIRQ_RESTART次迴圈後還未處理完，則啟用守護程序，處理剩下的軟中斷；
  • 推出前恢復軟中斷；

3.2  在ksoftirqd程序中執行         從前面幾節的討論我們可以看出，軟中斷也可能由ksoftirqd守護程序執行，這要發生在以下兩種情況下：
  • 在irq_exit中執行軟中斷，但是在經過MAX_SOFTIRQ_RESTART次迴圈後，軟中斷還未處理完，這種情況雖然極少發生，但畢竟有可能；
  • 核心的其它程式碼主動呼叫raise_softirq，而這時正好不是在中斷上下文中，守護程序將被喚醒；
守護程序最終也會呼叫__do_softirq執行軟中斷的回撥，具體的程式碼位於run_ksoftirqd函式中，核心會關閉搶佔的情況下執行__do_softirq，具體的過程這裡不做討論。
4.  tasklet        因為核心已經定義好了10種軟中斷型別，並且不建議我們自行新增額外的軟中斷，所以對軟中斷的實現方式，我們主要是做一個簡單的瞭解，對於驅動程式的開發者來說，無需實現自己的軟中斷。但是，對於某些情況下，我們不希望一些操作直接在中斷的handler中執行，但是又希望在稍後的時間裡得到快速地處理，這就需要使用tasklet機制。 tasklet是建立在軟中斷上的一種延遲執行機制，它的實現基於TASKLET_SOFTIRQ和HI_SOFTIRQ這兩個軟中斷型別。 4.1  tasklet_struct         在軟中斷的初始化函式softirq_init的最後，核心註冊了TASKLET_SOFTIRQ和HI_SOFTIRQ這兩個軟中斷：

點選(此處)摺疊或開啟

  1. void __init softirq_init(void)
  2. {
  3.         ......
  4.     open_softirq(TASKLET_SOFTIRQ, tasklet_action);
  5.     open_softirq(HI_SOFTIRQ, tasklet_hi_action);
  6. }

核心用一個tasklet_struct來表示一個tasklet，它的定義如下：

點選(此處)摺疊或開啟

  1. struct tasklet_struct
  2. {
  3.     struct tasklet_struct *next;
  4.     unsigned long state;
  5.     atomic_t count;
  6.     void (*func)(unsigned long);
  7.     unsigned long data;
  8. };

next用於把同一個cpu的tasklet連結成一個連結串列，state用於表示該tasklet的當前狀態，目前只是用了最低的兩個bit，分別用於表示已經準備被排程執行和已經在另一個cpu上執行：

點選(此處)摺疊或開啟

  1. enum
  2. {
  3.     TASKLET_STATE_SCHED,    /* Tasklet is scheduled for execution */
  4.     TASKLET_STATE_RUN    /* Tasklet is running (SMP only) */
  5. };

原子變數count用於tasklet對tasklet_disable和tasklet_enable的計數，count為0時表示允許tasklet執行，否則不允許執行，每次tasklet_disable時，該值加1，tasklet_enable時該值減1。func是tasklet被執行時的回撥函式指標，data則用作回撥函式func的引數。 4.2  初始化一個tasklet 有兩種辦法初始化一個tasklet，第一種是靜態初始化，使用以下兩個巨集，這兩個巨集定義一個tasklet_struct結構，並用相應的引數對結構中的欄位進行初始化：
  • DECLARE_TASKLET(name, func, data)；定義名字為name的tasklet，預設為enable狀態，也就是count欄位等於0。
  • DECLARE_TASKLET_DISABLED(name, func, data)；定義名字為name的tasklet，預設為enable狀態，也就是count欄位等於1。
第二個是動態初始化方法：先定義一個tasklet_struct，然後用tasklet_init函式進行初始化，該方法預設tasklet處於enable狀態：

點選(此處)摺疊或開啟

  1. struct tasklet_struct tasklet_xxx;
  2. ......
  3. tasklet_init(&tasklet_xxx, func, data);

4.3  tasklet的使用方法 使能和禁止tasklet，使用以下函式：
  • tasklet_disable()  通過給count欄位加1來禁止一個tasklet，如果tasklet正在執行中，則等待執行完畢才返回（通過TASKLET_STATE_RUN標誌）。
  • tasklet_disable_nosync()  tasklet_disable的非同步版本，它不會等待tasklet執行完畢。
  • tasklet_enable()  使能tasklet，只是簡單地給count欄位減1。
排程tasklet的執行，使用以下函式：
  • tasklet_schedule(struct tasklet_struct *t)  如果TASKLET_STATE_SCHED標誌為0，則置位TASKLET_STATE_SCHED，然後把tasklet掛到該cpu等待執行的tasklet連結串列上，接著發出TASKLET_SOFTIRQ軟體中斷請求。
  • tasklet_hi_schedule(struct tasklet_struct *t)  效果同上，區別是它發出的是HI_SOFTIRQ軟體中斷請求。
銷燬tasklet，使用以下函式：
  • tasklet_kill(struct tasklet_struct *t)  如果tasklet處於TASKLET_STATE_SCHED狀態，或者tasklet正在執行，則會等待tasklet執行完畢，然後清除TASKLET_STATE_SCHED狀態。

4.4  tasklet的內部執行機制 核心為每個cpu用定義了一個tasklet_head結構，用於管理每個cpu上的tasklet的排程和執行：

點選(此處)摺疊或開啟

  1. struct tasklet_head
  2. {
  3.     struct tasklet_struct *head;
  4.     struct tasklet_struct **tail;
  5. };
  6. static DEFINE_PER_CPU(struct tasklet_head, tasklet_vec);
  7. static DEFINE_PER_CPU(struct tasklet_head, tasklet_hi_vec);

回到4.1節，我們知道，tasklet是利用TASKLET_SOFTIRQ和HI_SOFTIRQ這兩個軟中斷來實現的，兩個軟中斷只是有優先順序的差別，所以我們只討論TASKLET_SOFTIRQ的實現，TASKLET_SOFTIRQ的中斷回撥函式是tasklet_action，我們看看它的程式碼：

點選(此處)摺疊或開啟

  1. static void tasklet_action(struct softirq_action *a)
  2. {
  3.     struct tasklet_struct *list;
  4.     local_irq_disable();
  5.     list = __this_cpu_read(tasklet_vec.head);
  6.     __this_cpu_write(tasklet_vec.head, NULL);
  7.     __this_cpu_write(tasklet_vec.tail, &__get_cpu_var(tasklet_vec).head);
  8.     local_irq_enable();
  9.     while (list) {
  10.         struct tasklet_struct *t = list;
  11.         list = list->next;
  12.         if (tasklet_trylock(t)) {
  13.             if (!atomic_read(&t->count)) {
  14.                 if (!test_and_clear_bit(TASKLET_STATE_SCHED, &t->state))
  15.                     BUG();
  16.                 t->func(t->data);
  17.                 tasklet_unlock(t);
  18.                 continue;
  19.             }
  20.             tasklet_unlock(t);
  21.         }
  22.         local_irq_disable();
  23.         t->next = NULL;
  24.         *__this_cpu_read(tasklet_vec.tail) = t;
  25.         __this_cpu_write(tasklet_vec.tail, &(t->next));
  26.         __raise_softirq_irqoff(TASKLET_SOFTIRQ);
  27.         local_irq_enable();
  28.     }
  29. }

解析如下：
  • 關閉本地中斷的前提下，移出當前cpu的待處理tasklet連結串列到一個臨時連結串列後，清除當前cpu的tasklet連結串列，之所以這樣處理，是為了處理當前tasklet連結串列的時候，允許新的tasklet被排程進待處理連結串列中。
  • 遍歷臨時連結串列，用tasklet_trylock判斷當前tasklet是否已經在其他cpu上執行，而且tasklet沒有被禁止：
    • 如果沒有執行，也沒有禁止，則清除TASKLET_STATE_SCHED狀態位，執行tasklet的回撥函式。
    • 如果已經在執行，或者被禁止，則把該tasklet重新新增會當前cpu的待處理tasklet連結串列上，然後觸發TASKLET_SOFTIRQ軟中斷，等待下一次軟中斷時再次執行。
分析到這了我有個疑問，看了上面的程式碼，如果一個tasklet被tasklet_schedule後，在沒有被執行前被tasklet_disable了，豈不是會無窮無盡地引發TASKLET_SOFTIRQ軟中斷？ 通過以上的分析，我們需要注意的是，tasklet有以下幾個特徵：
  • 同一個tasklet只能同時在一個cpu上執行，但不同的tasklet可以同時在不同的cpu上執行；
  • 一旦tasklet_schedule被呼叫，核心會保證tasklet一定會在某個cpu上執行一次；
  • 如果tasklet_schedule被呼叫時，tasklet不是出於正在執行狀態，則它只會執行一次；
  • 如果tasklet_schedule被呼叫時，tasklet已經正在執行，則它會在稍後被排程再次被執行；
  • 兩個tasklet之間如果有資源衝突，應該要用自旋鎖進行同步保護；

相關推薦

Linux中斷（interrupt）子系統之五：軟體中斷（softIRQ）

軟體中斷（softIRQ）是核心提供的一種延遲執行機制，它完全由軟體觸發，雖然說是延遲機制，實際上，在大多數情況下，它與普通程序相比，能得到更快的響應時間。軟中斷也是其他一些核心機制的基礎，比如tasklet，高解析度timer等。 /*****************

Linux中斷（interrupt）子系統之四：驅動程式介面層 & 中斷通用邏輯層

轉載地址：https://blog.csdn.net/DroidPhone/article/details/7497787 在本系列文章的第一篇：Linux中斷（interrupt）子系統之一：中斷系統基本原理，我把通用中斷子系統分為了4個層次，其中的驅動程式介面層和中斷通用邏輯層的界限實際上不

Linux中斷（interrupt）子系統之三：中斷流控處理層

1.  中斷流控層簡介 早期的核心版本中，幾乎所有的中斷都是由__do_IRQ函式進行處理，但是，因為各種中斷請求的電氣特性會有所不同，又或者中斷控制器的特性也不同，這會導致以下這些處理也會有所不同：   何時對中斷控制器發出ack迴應； mask_irq

Linux中斷（interrupt）子系統之二：arch相關的硬體封裝層

Linux的通用中斷子系統的一個設計原則就是把底層的硬體實現儘可能地隱藏起來，使得驅動程式的開發人員不用關注底層的實現，要實現這個目標，核心的開發者們必須把硬體相關的內容剝離出來，然後定義一些列標準的介面供上層訪問，上層的開發人員只要知道這些介面即可完成對中斷的進一步處理和控制。對底層的封裝主要包括

敏捷外包工程之五：報價管理（一）

若工時是報價的基礎，則甲方總是希望壓縮工時（而非成本本身，其差別日後會提到），工時壓縮自然會造成進度提前（即使甲方不要求，乙方也不能承受延期造成的額外工時），進而導致質量下降（甲方和乙方都很難在早期意識到質量問題）；在此過程中會不斷發生需求蔓延（這不僅僅是個技術問題，若成本由早期商定的工時確定而非實際交付的需

Linux系統Oracle12.2 RAC集群實施維護_Oracle數據庫12cR2（項目實戰之五）

oracle教程 oracle培訓 oracle數據庫教程 oracle工程師培訓 oracle數據庫培訓 課程目標風哥Oracle數據庫教程12cR2（項目實戰系列）之五：Linux系統上Oracle 12.2 RAC實施與基本維護，包括系統安裝與環境配置、ASM存儲配置、Oracle

Linux時間子系統之八：動態時鐘框架（CONFIG_NO_HZ、tickless）

sleep file rup linux時間 load 曾經 大致 獲取 conf 在前面章節的討論中，我們一直基於一個假設：Linux中的時鐘事件都是由一個周期時鐘提供，不管系統中的clock_event_device是工作於周期觸發模式，還是工作於單觸發模式，也不管定時

Linux時間子系統之六：高精度定時器（HRTIMER）的原理和實現

3.4 size 屬於 running return repr 而是 復雜度 ctu 上一篇文章，我介紹了傳統的低分辨率定時器的實現原理。而隨著內核的不斷演進，大牛們已經對這種低分辨率定時器的精度不再滿足，而且，硬件也在不斷地發展，系統中的定時器硬件的精度也越來越高，這也給

Linux ALSA音效卡驅動之五：移動裝置中的ALSA（ASoC）

1.  ASoC的由來 ASoC--ALSA System on Chip ，是建立在標準ALSA驅動層上，為了更好地支援嵌入式處理器和移動裝置中的音訊Codec的一套軟體體系。在ASoc出現之前，核心對於SoC中的音訊已經有部分的支援，不過會有一些侷限性：    C

LIVE555研究之五：RTPServer（二）

tpch live555 循環調用 family 每一個 函數 計算 ack close LIVE555研究之五：RTPServer（二） 接上文，main函數的幾行代碼創建了RTSPSe

轉： 【Java並發編程】之五：volatile變量修飾符—意料之外的問題（含代碼）

功能 模式 aik 執行 方法 end bold 有變 目的 轉載請註明出處： volatile用處說明 在JDK1.2之前，Java的內存模型實現總是從主存（即共享內存）讀取變量，是不需要進行特別的註意的。而隨著JVM的成熟和優化，現在在多線程環境下vo

白話空間統計之五：空間關系的概念化（中）

能夠 每一個 corners 計算 感覺 行政區劃 -a -s sim 空間關系的概念化（中） 上文說的兩種空間關系概念化盡管是最經常使用，可是總給人一種簡單粗暴的感覺，所以業界和學術界由搞出了各種各樣的空間關系概念化的模型。 首先，就是把兩種最簡單的概念化給組

關於linux的進階命令用法之來自noob的小結（1）

linux命令 寫的很雜，先這樣，下午再來細細排版與貼圖umask 查詢當前shell的mask值umask xxx 可以設置當前目錄的mask值vim .bashrc 可以編輯當前用戶shell的mask值並且永久保存，source 後生效-S 可以用rwx顯示出當前的去掉的

UVM暫存器篇之五：暫存器模型的整合（下）

本文轉自：http://www.eetop.cn/blog/html/28/1561828-6266222.html 前門訪問 利用暫存器模型，我們可以更方便地對暫存器做操作。接下來我們分別兩種訪問暫存器的方式，即前門訪問（front-door）和後門訪問（back-door）。前門訪問，顧

Godot3遊戲引擎入門之五：上下左右移動動畫（下）

一、前言 本篇是上一節文章：Godot3遊戲引擎入門之五：上下左右移動動畫（上）的繼續。上一篇使用動畫和程式碼實現了玩家的上下左右移動功能，接下來我們解決一個問題：給遊戲新增碰撞體，讓玩家在有限的地圖中移動。 注意：我目前使用的是 Godot 3.1 預覽版，與

STM32（暫存器）學習筆記——實驗五：外部中斷

儲備知識： （1）STM32F103ZET6（CM3核心）共有256箇中斷，需要進行管理 首先，要對STM32進行分組，組0~4，同時要對每個中斷設定一個搶佔優先順序和響應優先順序 （搶佔優先順序：是指打斷其它中斷的級別，高的搶佔優先順序可以打斷低的搶佔優先順序的工作

linux中的系統排錯 之三 檔案引導階段（核心檔案丟失）

核心檔案丟失引起的系統崩潰： 模擬問題：      rm -fr   /boot/vmlinuz-3.10.0-123.el7.x86_64 沒有刪除之前在/boot目錄下可以看到vm..檔案： 刪除它： reboot重啟系統： 可以看到系統報錯資訊：

敏捷開發績效管理之五：敏捷開發生產率（上）（故事點估算）

這是敏捷開發績效管理的第五篇。（之一，之二，之三，之四，之五，之六，之七）度量敏捷開發的生產率一直是個難題，確切說度量任何開發方法的生產率都是一個難題，但它實際上有答案，這個答案是本文的主要內容。度量敏捷生產率的目的真正難以回答的是度量生產率的目的是什麼？很多人都認為是考核績

vue的原始碼學習之五——7.資料驅動（update）

1. 介紹         版本：2.5.17。         我們使用vue-vli建立基於Runtime+Compiler的vue腳手架。  &nb

vue的原始碼學習之五——6.資料驅動（createElement）

1. 介紹       版本：2.5.17。         我們使用vue-vli建立基於Runtime+Compiler的vue腳手架。   &nbs