软中断机制

一、软中断描述
1.中断服务程序往往都是在CPU关中断的条件下执行的，以避免中断嵌套而使控制复杂化。但是CPU关中断的时间不能太长，否则容易丢失中断信号。为此， Linux将中断服务程序一分为二，各称作“Top Half”和“Bottom Half”。前者通常对时间要求较为严格，必须在中断请求发生后立即或至少在一定的时间限制内完成。因此为了保证这种处理能原子地完成，Top Half通常是在CPU关中断的条件下执行的。
//软中断本身是一种机制，同时也是一种框架。在这个框架里有bh机制(tasklet)，即是一种特殊的软中断
enum//四种软中断机制
{
    HI_SOFTIRQ=0, //实现高优先级的软中断
    NET_TX_SOFTIRQ,
    NET_RX_SOFTIRQ,
    TASKLET_SOFTIRQ //tasklet机制
};
具体地说，Top Half的范围包括：从在IDT中登记的中断入口函数一直到驱动程序注册在中断服务队列中的ISR。而Bottom Half则是Top Half根据需要来调度执行的，这些操作允许延迟到稍后执行，它的时间要求并不严格，因此它通常是在CPU开中断的条件下执行的。但是， Linux的这种Bottom Half（以下简称BH）机制有两个缺点，也即：
（1）在任意一时刻，系统只能有一个CPU可以执行Bottom Half代码，以防止两个或多个CPU同时来执行Bottom Half函数而相互干扰。因此BH代码的执行是严格“串行化”的。
（2）BH函数不允许嵌套。
这两个缺点在单CPU系统中是无关紧要的，但在SMP系统中却是非常致命的。因为BH机制的严格串行化执行显然没有充分利用SMP系统的多CPU特点。为此，Linux2.4内核在BH机制的基础上进行了扩展，这就是所谓的“软中断请求”（softirq）机制。

2.Linux 的softirq机制是与SMP紧密不可分的。为此，整个softirq机制的设计与实现中自始自终都贯彻了一个思想：“谁触发，谁执行”（Who marks，Who runs），也即触发软中断的那个CPU负责执行它所触发的软中断，而且每个CPU都由它自己的软中断触发与控制机制。这个设计思想也使得softirq 机制充分利用了SMP系统的性能和特点。
Linux在include/linux/interrupt.h头文件中定义了数据结构softirq_action，来描述一个软中断请求，如下所示：
struct softirq_action
{
    void (*action)(struct softirq_action *);//指向软中断请求的服务函数
    void *data;//由服务函数自行解释的数据
}
static struct softirq_action softirq_vec[32] __cacheline_aligned;
在这里系统一共定义了32个软中断请求描述符。软中断向量i（0≤i≤31）所对应的软中断请求描述符就是softirq_vec［i］。这个数组是个系统全局数组，也即它被所有的CPU所共享。这里需要注意的一点是：每个CPU虽然都由它自己的触发和控制机制，并且只执行他自己所触发的软中断请求，但是各个CPU所执行的软中断服务例程却是相同的，也即都是执行softirq_vec［］数组中定义的软中断服务函数。

3.要实现“谁触发，谁执行”的思想，就必须为每个CPU都定义它自己的触发和控制变量。为此，Linux在include/asm-i386/hardirq.h头文件中定义了数据结构irq_cpustat_t来描述一个CPU的中断统计信息，其中就有用于触发和控制软中断的成员变量。数据结构irq_cpustat_t 的定义如下：
typedef struct {
    unsigned int __softirq_active;//表示软中断向量0～31的状态。如果bit［i］（0≤i≤31）为1，则表示软中断向量i在某个CPU上已经被触发而处于active状态；为0表示处于非活跃状态。
    unsigned int __softirq_mask; //32位的无符号整数，软中断向量的屏蔽掩码。如果bit［i］（0≤i≤31）为1，则表示使能（enable）软中断向量i，为0表示该软中断向量被禁止（disabled）。
    unsigned int __local_irq_count;
    unsigned int __local_bh_count;
    unsigned int __syscall_count;
    unsigned int __nmi_count; /* arch dependent */
} ____cacheline_aligned irq_cpustat_t;

根据系统中当前的CPU个数（由宏NR_CPUS表示），Linux在kernel/softirq.c文件中为每个CPU都定义了它自己的中断统计信息结构，如下所示：
irq_cpustat_t irq_stat[NR_CPUS];
这样，每个CPU都只操作它自己的中断统计信息结构。假设有一个编号为id的CPU，那么它只能操作它自己的中断统计信息结构irq_stat［id］（0≤id≤NR_CPUS-1），从而使各CPU之间互不影响。

二、软中断初始化
1.
void __init softirq_init()
{
    int i;

    //初始化tasklet机制
    for (i=0; i<32; i++)//对bh的32个tasklet_struct结构初始化
        tasklet_init(bh_task_vec+i, bh_action, i);//tasklet机制func函数全部指向bh_action()

    //初始化软中断机制，软中断服务函数指针分别指向 tasklet_action()函数和tasklet_hi_action（）函数
    open_softirq(TASKLET_SOFTIRQ, tasklet_action, NULL);//对TASKLET_SOFTIRQ软中断进行初始化
    open_softirq(HI_SOFTIRQ, tasklet_hi_action, NULL);//对HI_SOFTIRQ软中断进行初始化
}

2.tasklet结构
//原有的32个BH函数指针被保留
static void (*bh_base[32])(void);
//但是，每个BH函数都对应有一个tasklet，并由tasklet的可执行函数func来负责调用相应的bh函数（func函数的参数指定调用哪一个BH函数）。与32个BH函数指针相对应的tasklet的定义如下所示：
struct tasklet_struct bh_task_vec[32];
//Linux用数据结构tasklet_struct来描述一个tasklet，尽管tasklet机制是特定于软中断向量HI_SOFTIRQ和TASKLET_SOFTIRQ的一种实现，但是tasklet机制仍然属于 softirq机制的整体框架范围内的。
struct tasklet_struct
{
    struct tasklet_struct *next;
    unsigned long state;
    atomic_t count;
    void (*func)(unsigned long); //指向服务程序，最终执行的程序是bh_base[n]中定义的函数
    unsigned long data;
};

//多个tasklet可以通过tasklet描述符中的next成员指针链接成一个单向对列。为此，Linux专门定义了数据结构tasklet_head来描述一个tasklet对列的头部指针。
struct tasklet_head tasklet_hi_vec[NR_CPUS] __cacheline_aligned;
struct tasklet_head
{
    struct tasklet_struct *list;
} __attribute__ ((__aligned__(SMP_CACHE_BYTES)));

3.tasklet初始化
//bh_base[]数组中每个元素用来指向一个bh函数
//init_bh()将具体的软中断服务程序挂入软中断服务队列
//init_bh(TIMER_BH, timer_bh);
//init_bh(TQUEUE_BH, tqueue_bh);
//init_bh(IMMEDIATE_BH, immediate_bh);
/*
enum {
    TIMER_BH = 0,
    TQUEUE_BH,
    DIGI_BH,
    SERIAL_BH,
    RISCOM8_BH,
    SPECIALIX_BH,
    AURORA_BH,
    ESP_BH,
    SCSI_BH,
    IMMEDIATE_BH,
    CYCLADES_BH,
    CM206_BH,
    JS_BH,
    MACSERIAL_BH,
    ISICOM_BH
};
*/

void init_bh(int nr, void (*routine)(void))
{
    bh_base[nr] = routine;//tasklet最终要去执行的函数
    mb();//内存屏障
}

//初始化bh_task_vec[]
void tasklet_init(struct tasklet_struct *t,void (*func)(unsigned long), unsigned long data)
{
    t->func = func;//全部指向bh_action()
    t->data = data;
    t->state = 0;
    atomic_set(&t->count, 0);//使用计数设为0
}

4.软中断初始化
void open_softirq(int nr, void (*action)(struct softirq_action*), void *data)
{
    unsigned long flags;
    int i;

    spin_lock_irqsave(&softirq_mask_lock, flags);
    softirq_vec[nr].data = data;
    softirq_vec[nr].action = action;//若是TASKLET_SOFTIRQ，则指向tasklet_action()
    //将所有CPU的软中断屏蔽掩码变量softirq_mask中的对应位设置为1，以使能该软中断向量
    for (i=0; i<NR_CPUS; i++)//NR_CPUS是系统cpu个数
        softirq_mask(i) |= (1<<nr);
    spin_unlock_irqrestore(&softirq_mask_lock, flags);
}

三、tasklet机制的软中断执行
/*bottom half通过发送软中断信号HI_SOFTIRQ，linux通过do_softirq处理，这时的过程是
do_softirq-> tasklet_hi_action-> bh_task_vec->bh_action->bh_base。最终处理工作由bh_base函数指针数组指向的函数完成。
init_bh(TIMER_BH, timer_bh);
init_bh(TQUEUE_BH, tqueue_bh);
init_bh(IMMEDIATE_BH, immediate_bh);
所以计时器bottom half的最终处理函数是timer_bh。
*/
//mark_bh()提出执行保护函数的请求
static inline void mark_bh(int nr)
{
    tasklet_hi_schedule(bh_task_vec+nr);
}

//tasklet_vec［］数组用于软中断向量TASKLET_SOFTIRQ，而tasklet_hi_vec［］数组则用于软中断向量 HI_SOFTIRQ。
static inline void tasklet_hi_schedule(struct tasklet_struct *t)
{
    if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state)) {//是否已经挂在别的队列上
        int cpu = smp_processor_id();
        unsigned long flags;

        local_irq_save(flags);
        t->next = tasklet_hi_vec[cpu].list;
        tasklet_hi_vec[cpu].list = t;//将tasklet挂入bh请求队列，即将bh_task_vec[nr]挂入头部指针tasklet_hi_vec中
        __cpu_raise_softirq(cpu, HI_SOFTIRQ);//发出软中断请求
        local_irq_restore(flags);
    }
}

static inline void __cpu_raise_softirq(int cpu, int nr)
{
    softirq_active(cpu) |= (1<<nr);//软中断请求寄存器相应位置1
}

//在do_IRQ()执行完服务程序时，都会检查是否有软中断在等待
//if (softirq_active(cpu) & softirq_mask(cpu))
// do_softirq();
//do_softirq-> tasklet_hi_action-> bh_task_vec->bh_action->bh_base。最终处理工作由bh_base函数指针数组指向的函数完成
asmlinkage void do_softirq()
{
52 int cpu = smp_processor_id();
53 __u32 active, mask;
54
55 if (in_interrupt())//不允许在硬中断服务程序和软中断服务程序中运行
56      return;
57 /*#define cpu_bh_disable(cpu) do { local_bh_count(cpu)++; barrier(); } while (0)
    #define cpu_bh_enable(cpu) do { barrier(); local_bh_count(cpu)--;} while (0)
    #define local_bh_disable() cpu_bh_disable(smp_processor_id())
    #define local_bh_enable() cpu_bh_enable(smp_processor_id())
   */
58 local_bh_disable();//把当前CPU的中断统计信息结构中的__local_bh_count成员变量加1，表示当前CPU已经处在软中断服务状态。
60 local_irq_disable();//关中断
61 mask = softirq_mask(cpu);//
62 active = softirq_active(cpu) & mask;//与mask相与看是否有软中断服务被触发
63
64 if (active) {
65      struct softirq_action *h;
restart:
69      softirq_active(cpu) &= ~active;//先将当前CPU的__softirq_active中的相应位清零
71      local_irq_enable();//打开当前CPU的中断
72 //若是tasklet，则softirq_vec->action指向tasklet_action()
        //若是HI_SOFTIRQ, 则softirq_vec->action指向tasklet_hi_action()
73      h = softirq_vec;
74      mask &= ~active;
75
76 do {
77 if (active & 1)
78              h->action(h);//循环来根据active的值去执行相应的软中断服务函数
79          h++; //若是tasklet，去执行tasklet_action()
80          active >>= 1;
81 } while (active);
82
83      local_irq_disable();//关中断，是为了下面再一次检查active的值
84
85      active = softirq_active(cpu);//读取当前CPU的 __softirq_active变量的值，
86 if ((active &= mask) != 0)//并将它与局部变量mask进行与操作，以看看是否又有其他软中断服务被触发了
87          goto retry;
88 }
90 local_bh_enable();//表示当前CPU已经离开软中断服务状态
96 return;
97
retry:
99 goto restart;
}

static void tasklet_action(struct softirq_action *a)
{
126 int cpu = smp_processor_id();
127 struct tasklet_struct *list;
128
129 local_irq_disable();
130 list = tasklet_vec[cpu].list;//从tasklet_vec数组中取出队列头
131 tasklet_vec[cpu].list = NULL;
132 local_irq_enable();
133
134 while (list != NULL) {//遍历由list所指向的tasklet队列，队列中的各个元素就是将在当前CPU上执行的tasklet
135     struct tasklet_struct *t = list;
137     list = list->next;
138 //依次取出队列中的bh_task_vec[nr]
139 if (tasklet_trylock(t)) {
140 if (atomic_read(&t->count) == 0) {//如果count为0，说明这个tasklet是允许执行的
141             clear_bit(TASKLET_STATE_SCHED, &t->state);//清TASKLET_STATE_SCHED标志
143             t->func(t->data);//执行bh_task_vec[nr]->func，都指向bh_action()
#ifdef CONFIG_SMP
150             smp_mb__before_clear_bit();
#endif
152             tasklet_unlock(t);
153             continue;
154 }
155         tasklet_unlock(t);
156 }
157     local_irq_disable();
158     t->next = tasklet_vec[cpu].list;
159     tasklet_vec[cpu].list = t;//把这个tasklet重新放回到当前CPU的tasklet队列的首部
160     __cpu_raise_softirq(cpu, TASKLET_SOFTIRQ);//再触发一次软中断请求TASKLET_SOFTIRQ
161     local_irq_enable();
162 }
}

static void bh_action(unsigned long nr)
{
248 int cpu = smp_processor_id();//当前cpu的逻辑号
249 //试图对自旋锁global_bh_lock进行加锁，同时该函数还将返回自旋锁global_bh_lock 的原有值的非
250 if (!spin_trylock(&global_bh_lock))
251     goto resched;
252 //锁定当前CPU，确保当前CPU不是处于硬件中断请求服务中
253 if (!hardirq_trylock(cpu))
254     goto resched_unlock;
255 //当前CPU上执行BH函数
256 if (bh_base[nr])//若是TIMER_BH, timer_bh
257     bh_base[nr]();//这里会去执行timer_bh()函数
258
259 hardirq_endlock(cpu);
260 spin_unlock(&global_bh_lock);
261 return;
262
resched_unlock:
264 spin_unlock(&global_bh_lock);
resched:
266 mark_bh(nr);
}

四、实现原理
1.软中断实现原理图
2.Tasklet机制的实现原理如下图所示