内核随记(一)——理解中断(3)

矫情吗；* 2022-01-10 16:53 159阅读 0赞

4、下半部  
在中断处理过程中，不能睡眠。另外，它运行的时候，会把当前中断线在所有处理器上都屏蔽(在ack中完成屏蔽)；更糟糕的情况是，如果一个处理程序是SA\_INTERRUPT类型，它执行的时候会禁上所有本地中断(通过cli指令完成)，所以，中断处理应该尽可能快的完成。所以Linux把中断处理分为上半部和下半部。  
上半部由中断处理程序完成，它通常完成一些和硬件相关的操作，比如对中断的到达的确认。有时它还会从硬件拷贝数据，这些工作对时间非常敏感，只能靠中断处理程序自己完成。而把其它工作放到下半部实现。  
下半部的执行不需要一个确切的时间，它会在稍后系统不太繁忙时执行。下半部执行的关键在于运行的时候允许响应所有的中断。最早，Linux用”bottom half”实现下半部，这种机制简称BH，但是即使属于不同的处理器，也不允许任何两个bottom half同时执行，这种机制简单，但是却有性能瓶颈。不久，又引入任务队列(task queue)机制来实现下半部，但该机制仍不够灵活，没法代替整个BH接口。  
从2.3开始，内核引入软中断(softirqs)和tasklet，并完全取代了BH。2.5中，BH最终舍去，在2.6中，内核用有三种机制实现下半部：软中断，tasklet和工作队列。Tasklet是基于软中断实现的。 软中断可以在多个CPU上同时执行，即使它们是同一类型的，所以，软中断处理程序必须是可重入的，或者显示的用自旋锁保护相应的数据结构。而相同的tasklet不能同时在多个CPU上执行，所以tasklet不必是可重入的；但是，不同类型的tasklet可以在多个CPU上同时执行。一般来说，tasklet比较常用，它可以处理绝大部分的问题；而软中断用得比较少，但是对于时间要求较高的地方，比如网络子系统，常用软中断处理下半部工作。  
  
4.1、软中断  
内核2.6中定义了6种软中断：  
![kernel_1_7.JPG][]  
下标越低，优先级越高。  
  
4.1.1、数据结构  
(1)软中断向量

// linux/interrupt.h   
 struct  softirq\_action  
\{  
 void  ( \* action)( struct  softirq\_action  \* );  // 待执行的函数   
  void  \* data;  // 传给函数的参数   
 \};  
 // kernel/softirq.c  
 // 软中断向量数组   
 static  struct  softirq\_action softirq\_vec\[ 32 \] \_\_cacheline\_aligned\_in\_smp;

内核定义了一个包含32个软中断向量的数组，所以最多可有32个软中断，实际上，内核目前只使用了6个软中断。  
(2) preempt\_count字段  
位于任务描述符的preempt\_count是用来跟踪内核抢占和内核控制路径嵌套关键数据。其各个位的含义如下：  
位 描述  
0——7 preemption counter，内核抢占计数器(最大值255)  
8——15 softirq counter，软中断计数器(最大值255)  
16——27 hardirq counter，硬件中断计数器(最大值4096)  
28 PREEMPT\_ACTIVE标志  
  
第一个计数用来表示内核抢占被关闭的次数，0表示可以抢占。第二个计数器表示推迟函数(下半部)被关闭的次数，0表示推迟函数打开。第三个计数器表示本地CPU中断嵌套的层数，irq\_enter()增加该值，irq\_exit减该值。  
宏in\_interrupt()检查current\_thread\_info->preempt\_count的hardirq和softirq来断定是否处于中断上下文。如果这两个计数器之一为正，则返回非零。  
(3) 软中断控制／状态结构  
softirq\_vec是个全局量，系统中每个CPU所看到的是同一个数组。但是，每个CPU各有其自己的“软中断控制／状态”结构，这些数据结构形成一个以CPU编号为下标的数组irq\_stat\[\]（定义在include/asm-i386/hardirq.h中）

typedef  struct  \{  
unsigned  int  \_\_softirq\_pending;  
unsigned  long  idle\_timestamp;  
unsigned  int  \_\_nmi\_count;  /\*  arch dependent  \*/   
unsigned  int  apic\_timer\_irqs;  /\*  arch dependent  \*/   
\} \_\_\_\_cacheline\_aligned irq\_cpustat\_t;  
 // 位于kernel/softirq.c   
 irq\_cpustat\_t irq\_stat\[NR\_CPUS\] \_\_\_\_cacheline\_aligned;

4.1.2、软中断初始化  
可以通过open\_softirq注册软中断处理程序：

// 位于kernel/softirq.c  
 // nr：软中断的索引号  
 //  softirq\_action：处理函数  
 // data：传递给处理函数的参数值   
 void  open\_softirq( int  nr,  void  ( \* action)( struct  softirq\_action \* ),  void  \* data)  
\{  
softirq\_vec\[nr\].data  =  data;  
softirq\_vec\[nr\].action  =  action;  
\}  
 // 软中断初始化   
 void  \_\_init softirq\_init( void )  
\{  
open\_softirq(TASKLET\_SOFTIRQ, tasklet\_action, NULL);  
open\_softirq(HI\_SOFTIRQ, tasklet\_hi\_action, NULL);  
\}

软中断执行时，允许响应中断，但它自己不能睡眠，  
4.1.3、触发软中断  
raise\_softirq会将软中断设置为挂起状态，并在下一次运行do\_softirq中投入运行。

// 位于kernel/softirq.c   
 void  fastcall raise\_softirq(unsigned  int  nr)  
\{  
unsigned  long  flags;  
 // 保存IF值,并关中断   
  local\_irq\_save(flags);  
  
 // 调用wakeup\_softirqd()   
  raise\_softirq\_irqoff(nr);  
 // 恢复IF值   
  local\_irq\_restore(flags);  
\}  
  
inline fastcall  void  raise\_softirq\_irqoff(unsigned  int  nr)  
\{  
 // 把软中断设置为挂起状态   
  \_\_raise\_softirq\_irqoff(nr);  
  
  
 // 唤醒内核线程   
  if  ( ! in\_interrupt())  
wakeup\_softirqd();  
\}

该函数触发软中断前，先要关闭中断，之后再恢复；如果之前中断已经关闭，可以直接调用raise\_softirq\_irqoff()触发软中断。  
在中断服务例程中触发软中断是最常见的形式。而中断服务例程通常作为设备驱动的一部分。例如，对于网络设备，当接口收到数据时，会产生一个中断，在中断服务例程中，最终会调用netif\_rx函数处理接到的数据，而netif\_rx作相应处理，最终以触发一个软中断结束处理。之后，内核在执行中断处理任务后，会调用do\_softirq()。于是软中断就通过软中断处理函数去处理留给它的任务。  
4.1.4、软中断执行  
(1) do\_softirq()函数

// 处理软中断，位于arch/i386/kernel/irq.c   
 asmlinkage  void  do\_softirq( void )  
\{  
 // 处于中断上下文,表明软中断是在中断上下文中触发的,或者软中断被关闭   
  /\* 这个宏限制了软中断服务例程既不能在一个硬中断服务例程内部执行，  
\*也不能在一个软中断服务例程内部执行（即嵌套）。但这个函数并没有对中断服务例程的执行  
\*进行“串行化”限制。这也就是说，不同的CPU可以同时进入对软中断服务例程的执行，每个CPU  
\*分别执行各自所请求的软中断服务。从这个意义上说，软中断服务例程的执行是“并发的”、多序的。  
\*但是，这些软中断服务例程的设计和实现必须十分小心，不能让它们相互干扰（例如通过共享的全局变量）。  
 \*/   
 if  (in\_interrupt())  
 return ;  
 // 保存IF值,并关中断   
  local\_irq\_save(flags);  
 // 调用\_\_do\_softirq   
  asm  volatile (  
 "  xchgl %%ebx,%%esp \\n "   
 "  call \_\_do\_softirq \\n "   
 "  movl %%ebx,%%esp \\n "   
:  " =b " (isp)  
:  " 0 " (isp)  
:  " memory " ,  " cc " ,  " edx " ,  " ecx " ,  " eax "   
);  
 // 恢复IF值   
  local\_irq\_restore(flags);

（2）\_\_do\_softirq()函数

// 执行软中断,位于kernel/softirq.c   
 asmlinkage  void  \_\_do\_softirq( void )  
\{  
 struct  softirq\_action  \* h;  
\_\_u32 pending;  
 /\* 最多迭代执行10次.在执行软中断的过程中,由于允许中断,所以新的软中断可能产生.为了使推迟函数能够在  
\*较短的时间延迟内执行,\_\_do\_softirq会执行所有挂起的软中断,这可能会执行太长的时间而大大延迟返回用户  
\*空间的时间.所以,\_\_do\_softirq最多允许10次迭代.剩下的软中断在软中断内核线程ksoftirqd中处理.  
 \*/   
 int  max\_restart  =  MAX\_SOFTIRQ\_RESTART;  
 int  cpu;  
  
 // 用局部变量保存软件中断位图   
  pending  =  local\_softirq\_pending();  
 /\* 增加softirq计数器的值.由于执行软中断时允许中断,当do\_IRQ调用irq\_exit时,另一个\_\_do\_softirq实例可能  
\*开始执行.这是不允许的,推迟函数必须在CPU上串行执行.  
 \*/   
local\_bh\_disable();  
cpu  =  smp\_processor\_id();  
restart:  
 /\*  Reset the pending bitmask before enabling irqs  \*/   
 // 重置软中断位图,使得新的软中断可以发生   
  local\_softirq\_pending()  =  0 ;  
 // 开启本地中断,执行软中断时,允许中断的发生   
  local\_irq\_enable();  
  
h  =  softirq\_vec;  
  
 do  \{  
 if  (pending  &  1 ) \{  
 // 执行软中断处理函数   
  h \-> action(h);  
rcu\_bh\_qsctr\_inc(cpu);  
\}  
h \++ ;  
pending  >>=  1 ;  
\}  while  (pending);  
 // 关闭中断   
  local\_irq\_disable();  
 // 再一次检查软中断位图,因为在执行软中断处理函数时,新的软中断可能产生.   
  pending  =  local\_softirq\_pending();  
 if  (pending  &&  \-- max\_restart)  
 goto  restart;  
 /\* 如果还有多的软中断没有处理,通过wakeup\_softirqd唤醒内核线程处理本地CPU余下的软中断.  
 \*/   
 if  (pending)  
wakeup\_softirqd();  
 // 减softirq counter的值   
  \_\_local\_bh\_enable();  
\}

(3)软中断执行点  
内核会周期性的检查是否有挂起的软中断，它们位于内核代码的以下几个点：  
(1)内核调用local\_bh\_enable()函数打开本地CPU的软中断：

// 位于kernel/softirq.c   
 void  local\_bh\_enable( void )  
\{  
preempt\_count()  \-=  SOFTIRQ\_OFFSET  \-  1 ;  
  
 if  (unlikely( ! in\_interrupt()  &&  local\_softirq\_pending()))  
do\_softirq();  // 软中断处理  
 // ……   
 \}

(2)do\_IRQ函数完成I/O中断处理，调用irq\_exit()时。  
(3)内核线程ksoftirqd被唤醒。  
(4) smp\_apic\_timer\_interrupt()完成处理本地时钟中断。

转载于:https://www.cnblogs.com/hustcat/archive/2009/08/15/1546601.html

[kernel_1_7.JPG]: /images/20220110/bb81b61d11074463a1e74680753b1c4b.png