Linux中断（interrupt）子系统之五：软件中断（softIRQ）【转】

悠悠 2022-02-02 15:13 272阅读 0赞

转自：[http://blog.csdn.net/droidphone/article/details/7518428][http_blog.csdn.net_droidphone_article_details_7518428]

目录[(?)][http_blog.csdn.net_droidphone_article_details_7518428][\[-\]][http_blog.csdn.net_droidphone_article_details_7518428]

1.  [软件中断的数据结构][Link 1]
    
    1.  [1 struct softirq\_action][1 struct softirq_action]
    2.  
    3.  [2 irq\_cpustat\_t][2 irq_cpustat_t]
    4.  
    5.  [3 软中断的守护进程ksoftirqd][3 _ksoftirqd]
2.  
3.  [触发软中断][Link 2]
4.  
5.  [软中断的执行][Link 3]
    
    1.  
    2.  [1 在irq\_exit中执行][1 _irq_exit]
    3.  
    4.  [2 在ksoftirqd进程中执行][2 _ksoftirqd]
6.  
7.  [tasklet][]
    
    1.  
    2.  [1 tasklet\_struct ][1 tasklet_struct]
    3.  
    4.  [2 初始化一个tasklet][2 _tasklet]
    5.  
    6.  [3 tasklet的使用方法][3 tasklet]
    7.  
    8.  [4 tasklet的内部执行机制][4 tasklet]

软件中断（softIRQ）是内核提供的一种延迟执行机制，它完全由软件触发，虽然说是延迟机制，实际上，在大多数情况下，它与普通进程相比，能得到更快的响应时间。软中断也是其他一些内核机制的基础，比如tasklet，高分辨率timer等。

/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/  
声明：本博内容均由http://blog.csdn.net/droidphone原创，转载请注明出处，谢谢！  
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/

# 1. 软件中断的数据结构 #

## 1.1 struct softirq\_action ##

内核用softirq\_action结构管理软件中断的注册和激活等操作，它的定义如下：

**\[cpp\]** [view plain][http_blog.csdn.net_droidphone_article_details_7518428] [copy][http_blog.csdn.net_droidphone_article_details_7518428]

1.  struct softirq\_action 
2.  \{
3.  void (\*action)(struct softirq\_action \*); 
4.  \};

非常简单，只有一个用于回调的函数指针。软件中断的资源是有限的，内核目前只实现了10种类型的软件中断，它们是：

**\[cpp\]** [view plain][http_blog.csdn.net_droidphone_article_details_7518428] [copy][http_blog.csdn.net_droidphone_article_details_7518428]

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. 
14. NR\_SOFTIRQS
15. \};

内核的开发者们不建议我们擅自增加软件中断的数量，如果需要新的软件中断，尽可能把它们实现为基于软件中断的tasklet形式。与上面的枚举值相对应，内核定义了一个softirq\_action的结构数组，每种软中断对应数组中的一项：

**\[cpp\]** [view plain][http_blog.csdn.net_droidphone_article_details_7518428] [copy][http_blog.csdn.net_droidphone_article_details_7518428]

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：

**\[cpp\]** [view plain][http_blog.csdn.net_droidphone_article_details_7518428] [copy][http_blog.csdn.net_droidphone_article_details_7518428]

1.  typedef struct \{ 
2.  unsigned int \_\_softirq\_pending; 
3.  \} \_\_\_\_cacheline\_aligned irq\_cpustat\_t;

**\[cpp\]** [view plain][http_blog.csdn.net_droidphone_article_details_7518428] [copy][http_blog.csdn.net_droidphone_article_details_7518428]

1.  irq\_cpustat\_t irq\_stat\[NR\_CPUS\] \_\_\_\_cacheline\_aligned;

\_\_softirq\_pending字段中的每一个bit，对应着某一个软中断，某个bit被置位，说明有相应的软中断等待处理。

##  ##

## 1.3 软中断的守护进程ksoftirqd ##

在cpu的热插拔阶段，内核为每个cpu创建了一个用于执行软件中断的守护进程ksoftirqd，同时定义了一个per\_cpu变量用于保存每个守护进程的task\_struct结构指针：

**\[cpp\]** [view plain][http_blog.csdn.net_droidphone_article_details_7518428] [copy][http_blog.csdn.net_droidphone_article_details_7518428]

1.  DEFINE\_PER\_CPU(struct task\_struct \*, ksoftirqd);

大多数情况下，软中断都会在irq\_exit阶段被执行，在irq\_exit阶段没有处理完的软中断才有可能会在守护进程中执行。

#  #

# 2. 触发软中断 #

要触发一个软中断，只要调用api：raise\_softirq即可，它的实现很简单，先是关闭本地cpu中断，然后调用：raise\_softirq\_irqoff

**\[cpp\]** [view plain][http_blog.csdn.net_droidphone_article_details_7518428] [copy][http_blog.csdn.net_droidphone_article_details_7518428]

1.  void raise\_softirq(unsigned int nr) 
2.  \{
3.  unsigned long flags; 
4.  
5.  local\_irq\_save(flags);
6.  raise\_softirq\_irqoff(nr);
7.  local\_irq\_restore(flags);
8.  \}

再看看raise\_softirq\_irqoff：

**\[cpp\]** [view plain][http_blog.csdn.net_droidphone_article_details_7518428] [copy][http_blog.csdn.net_droidphone_article_details_7518428]

1.  inline void raise\_softirq\_irqoff(unsigned int nr) 
2.  \{
3.  \_\_raise\_softirq\_irqoff(nr);
4.  
5.  ......
6.  if (!in\_interrupt()) 
7.  wakeup\_softirqd();
8.  \}

先是通过\_\_raise\_softirq\_irqoff设置cpu的软中断pending标志位（irq\_stat\[NR\_CPUS\] ），然后通过in\_interrupt判断现在是否在中断上下文中，或者软中断是否被禁止，如果都不成立，则唤醒软中断的守护进程，在守护进程中执行软中断的回调函数。否则什么也不做，软中断将会在中断的退出阶段被执行。

#  #

# 3. 软中断的执行 #

基于上面所说，软中断的执行既可以守护进程中执行，也可以在中断的退出阶段执行。实际上，软中断更多的是在中断的退出阶段执行（irq\_exit），以便达到更快的响应，加入守护进程机制，只是担心一旦有大量的软中断等待执行，会使得内核过长地留在中断上下文中。

##  ##

## 3.1 在irq\_exit中执行 ##

看看irq\_exit的部分：

**\[cpp\]** [view plain][http_blog.csdn.net_droidphone_article_details_7518428] [copy][http_blog.csdn.net_droidphone_article_details_7518428]

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：

**\[cpp\]** [view plain][http_blog.csdn.net_droidphone_article_details_7518428] [copy][http_blog.csdn.net_droidphone_article_details_7518428]

1.  asmlinkage void \_\_do\_softirq(void) 
2.  \{
3.  ......
4.  pending = local\_softirq\_pending();
5.  
6.  \_\_local\_bh\_disable((unsigned long)\_\_builtin\_return\_address(0), 
7.  SOFTIRQ\_OFFSET);
8.  restart:
9.  /\* Reset the pending bitmask before enabling irqs \*/ 
10. set\_softirq\_pending(0);
11. 
12. local\_irq\_enable();
13. 
14. h = softirq\_vec;
15. 
16. do \{ 
17. if (pending & 1) \{ 
18. ......
19. trace\_softirq\_entry(vec\_nr);
20. h->action(h);
21. trace\_softirq\_exit(vec\_nr);
22. ......
23. \}
24. h++;
25. pending >>= 1;
26. \} while (pending); 
27. 
28. local\_irq\_disable();
29. 
30. pending = local\_softirq\_pending();
31. if (pending && --max\_restart) 
32. goto restart; 
33. 
34. if (pending) 
35. wakeup\_softirqd();
36. 
37. lockdep\_softirq\_exit();
38. 
39. \_\_local\_bh\_enable(SOFTIRQ\_OFFSET);
40. \}

*  首先取出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这两个软中断：

**\[cpp\]** [view plain][http_blog.csdn.net_droidphone_article_details_7518428] [copy][http_blog.csdn.net_droidphone_article_details_7518428]

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，它的定义如下：

**\[cpp\]** [view plain][http_blog.csdn.net_droidphone_article_details_7518428] [copy][http_blog.csdn.net_droidphone_article_details_7518428]

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上执行：

**\[cpp\]** [view plain][http_blog.csdn.net_droidphone_article_details_7518428] [copy][http_blog.csdn.net_droidphone_article_details_7518428]

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状态：

**\[cpp\]** [view plain][http_blog.csdn.net_droidphone_article_details_7518428] [copy][http_blog.csdn.net_droidphone_article_details_7518428]

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的调度和执行：

**\[cpp\]** [view plain][http_blog.csdn.net_droidphone_article_details_7518428] [copy][http_blog.csdn.net_droidphone_article_details_7518428]

1.  struct tasklet\_head 
2.  \{
3.  struct tasklet\_struct \*head; 
4.  struct tasklet\_struct \*\*tail; 
5.  \};
6.  
7.  static DEFINE\_PER\_CPU(struct tasklet\_head, tasklet\_vec); 
8.  static DEFINE\_PER\_CPU(struct tasklet\_head, tasklet\_hi\_vec);

回到4.1节，我们知道，tasklet是利用TASKLET\_SOFTIRQ和HI\_SOFTIRQ这两个软中断来实现的，两个软中断只是有优先级的差别，所以我们只讨论TASKLET\_SOFTIRQ的实现，TASKLET\_SOFTIRQ的中断回调函数是tasklet\_action，我们看看它的代码：

**\[cpp\]** [view plain][http_blog.csdn.net_droidphone_article_details_7518428] [copy][http_blog.csdn.net_droidphone_article_details_7518428]

1.  static void tasklet\_action(struct softirq\_action \*a) 
2.  \{
3.  struct tasklet\_struct \*list; 
4.  
5.  local\_irq\_disable();
6.  list = \_\_this\_cpu\_read(tasklet\_vec.head);
7.  \_\_this\_cpu\_write(tasklet\_vec.head, NULL);
8.  \_\_this\_cpu\_write(tasklet\_vec.tail, &\_\_get\_cpu\_var(tasklet\_vec).head);
9.  local\_irq\_enable();
10. 
11. while (list) \{ 
12. struct tasklet\_struct \*t = list; 
13. 
14. list = list->next;
15. 
16. if (tasklet\_trylock(t)) \{ 
17. if (!atomic\_read(&t->count)) \{ 
18. if (!test\_and\_clear\_bit(TASKLET\_STATE\_SCHED, &t->state)) 
19. BUG();
20. t->func(t->data);
21. tasklet\_unlock(t);
22. continue; 
23. \}
24. tasklet\_unlock(t);
25. \}
26. 
27. local\_irq\_disable();
28. t->next = NULL;
29. \*\_\_this\_cpu\_read(tasklet\_vec.tail) = t;
30. \_\_this\_cpu\_write(tasklet\_vec.tail, &(t->next));
31. \_\_raise\_softirq\_irqoff(TASKLET\_SOFTIRQ);
32. local\_irq\_enable();
33. \}
34. \}

解析如下：

*  关闭本地中断的前提下，移出当前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之间如果有资源冲突，应该要用自旋锁进行同步保护；

【作者】 [张昺华][Link 4]

【出处】 [http://www.cnblogs.com/sky-heaven/][Link 4]

【博客园】 [http://www.cnblogs.com/sky-heaven/][Link 4]

【新浪博客】 [http://blog.sina.com.cn/u/2049150530][http_blog.sina.com.cn_u_2049150530]

【知乎】 [http://www.zhihu.com/people/zhang-bing-hua][http_www.zhihu.com_people_zhang-bing-hua]

【我的作品---旋转倒立摆】 [http://v.youku.com/v\_show/id\_XODM5NDAzNjQw.html?spm=a2hzp.8253869.0.0&from=y1.7-2][http_v.youku.com_v_show_id_XODM5NDAzNjQw.html_spm_a2hzp.8253869.0.0_from_y1.7-2]

【我的作品---自平衡自动循迹车】 [http://v.youku.com/v\_show/id\_XODM5MzYyNTIw.html?spm=a2hzp.8253869.0.0&from=y1.7-2][http_v.youku.com_v_show_id_XODM5MzYyNTIw.html_spm_a2hzp.8253869.0.0_from_y1.7-2]

【新浪微博】 张昺华--sky

【twitter】 @sky2030\_

【facebook】 张昺华 zhangbinghua

本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利.

[http_blog.csdn.net_droidphone_article_details_7518428]: http://blog.csdn.net/droidphone/article/details/7518428
[Link 1]: http://blog.csdn.net/droidphone/article/details/7518428#t0
[1 struct softirq_action]: http://blog.csdn.net/droidphone/article/details/7518428#t1
[2 irq_cpustat_t]: http://blog.csdn.net/droidphone/article/details/7518428#t3
[3 _ksoftirqd]: http://blog.csdn.net/droidphone/article/details/7518428#t5
[Link 2]: http://blog.csdn.net/droidphone/article/details/7518428#t7
[Link 3]: http://blog.csdn.net/droidphone/article/details/7518428#t9
[1 _irq_exit]: http://blog.csdn.net/droidphone/article/details/7518428#t11
[2 _ksoftirqd]: http://blog.csdn.net/droidphone/article/details/7518428#t13
[tasklet]: http://blog.csdn.net/droidphone/article/details/7518428#t15
[1 tasklet_struct]: http://blog.csdn.net/droidphone/article/details/7518428#t17
[2 _tasklet]: http://blog.csdn.net/droidphone/article/details/7518428#t19
[3 tasklet]: http://blog.csdn.net/droidphone/article/details/7518428#t21
[4 tasklet]: http://blog.csdn.net/droidphone/article/details/7518428#t23
[Link 4]: http://www.cnblogs.com/sky-heaven/
[http_blog.sina.com.cn_u_2049150530]: http://blog.sina.com.cn/u/2049150530
[http_www.zhihu.com_people_zhang-bing-hua]: http://www.zhihu.com/people/zhang-bing-hua
[http_v.youku.com_v_show_id_XODM5NDAzNjQw.html_spm_a2hzp.8253869.0.0_from_y1.7-2]: http://v.youku.com/v_show/id_XODM5NDAzNjQw.html?spm=a2hzp.8253869.0.0&from=y1.7-2
[http_v.youku.com_v_show_id_XODM5MzYyNTIw.html_spm_a2hzp.8253869.0.0_from_y1.7-2]: http://v.youku.com/v_show/id_XODM5MzYyNTIw.html?spm=a2hzp.8253869.0.0&from=y1.7-2