ARM Linux中断源码分析（3）——软中断softirq

转载请注明出处：wloveg.blog.chinaunix.net

6.软中断

前面小节介绍了中断处理流程，确切地说是硬中断处理流程。内核出于性能等方面的考虑，将中断分为两部分：上半部处理中断中需要及时响应且处理时间较短的部分，下半部用于处理对响应时间要求不高且处理时间可能较长的部分。本节将主要介绍中断下半部的三种实现方式之一：软中断。

首先介绍一下软中断及其相关的数据结构。软中断是在编译期间静态分配的，由数据结构softirq_action表示：

<include/linux/interrupt.h>
struct softirq_action
{
    void    (*action)(struct softirq_action *);
};

softirq_action结构体非常简单，仅包含一个指向软中断处理函数的指针。为了管理软中断，内核维护着一个softirq_action结构体数组softirq_vec[NR_SOFTIRQS]，称之为软中断向量表：

<kernel/softirq.c>
static struct softirq_action softirq_vec[NR_SOFTIRQS];

其中NR_SOFTIRQS是一个枚举类型内核支持的最大软中断数。

< include/linux/interrupt.h >
enum
{
    HI_SOFTIRQ=0,
    TIMER_SOFTIRQ,
    NET_TX_SOFTIRQ,
    NET_RX_SOFTIRQ,
    BLOCK_SOFTIRQ,
    BLOCK_IOPOLL_SOFTIRQ,
    TASKLET_SOFTIRQ,
    SCHED_SOFTIRQ,
    HRTIMER_SOFTIRQ,
    RCU_SOFTIRQ,    /* Preferable RCU should always be the last softirq */
    NR_SOFTIRQS
};

通过上面的枚举类型可知当前内核版本支持10种软中断，其中HI_SOFTIRQ和TASKLET_SOFTIRQ用于实现tasklet，TIMER_SOFTIRQ和HRTIMER_SOFTIRQ用于实现定时器，NET_TX_SOFTIRQ和NET_RX_SOFTIRQ用于实现网络设备的发送和接受操作，BLOCK_SOFTIRQ和BLOCK_IOPOLL_SOFTIRQ用于实现块设备操作，SCHED_SOFTIRQ用于调度器。

内核中通过调用open_softirq函数注册软中断处理程序，该函数接收两个参数：软中断索引号（枚举类型）和处理程序。根据索引号寻址到软中断向量表softirq_vec的指定元素，使其action成员指向处理程序。

<kernel/softirq.c>
void open_softirq(int nr, void (*action)(struct softirq_action *))
{
    softirq_vec[nr].action = action;
}

例如，网络系统中注册接收和发送数据包的软中断：

<net/core/dev.c>
open_softirq(NET_TX_SOFTIRQ, net_tx_action);
open_softirq(NET_RX_SOFTIRQ, net_rx_action);

一个已经注册的软中断必须“触发”后才能在“适当的时机”被执行，raise_softirq函数和__raise_softirq_irqoff宏用于触发软中断，将一个软中断设置为挂起状态（pending）。raise_softirq最终也是通过调用__raise_softirq_irqoff来实现的：

<kernel/softirq.c>
inline void raise_softirq_irqoff(unsigned int nr)
{
    __raise_softirq_irqoff(nr); //触发nr号软中断

    /*
     * 如果当前不处在中断上下文中，则唤醒内核线程ksoftirqd来处理软中断。
     * 否则什么都不做，函数正常返回，等待“适当的时机”来处理软中断。
     */
    if (!in_interrupt())
        wakeup_softirqd();
}
void raise_softirq(unsigned int nr)
{
    unsigned long flags;

    local_irq_save(flags); //禁止中断
    raise_softirq_irqoff(nr); //触发软中断之前先要禁止中断
    local_irq_restore(flags); //开启中断
}

__raise_softirq_irqoff被定义为宏，以上述的枚举类型作为参数：

typedef struct {
    unsigned int __softirq_pending; //软中断挂起位图，每bit代表一种软中断
    unsigned int local_timer_irqs;
} ____cacheline_aligned irq_cpustat_t;

irq_cpustat_t irq_stat[NR_CPUS] ____cacheline_aligned; //每个cpu拥有一个软中断状态结构体，所以即使是相同类型的软中断也可以在其他cpu上同时执行。

#define __IRQ_STAT(cpu, member)    (irq_stat[cpu].member)

#define local_softirq_pending() \
    __IRQ_STAT(smp_processor_id(), __softirq_pending)

#define or_softirq_pending(x) (local_softirq_pending() |= (x))//将本地cpu的软中断挂起位图与x做或运算

#define __raise_softirq_irqoff(nr) do { or_softirq_pending(1UL << (nr)); } while (0)//将指定的nr号软中断设置为挂起状态

软中断并不是一旦触发就被执行，而是在之后的某个“适当的时机”执行，在Linux内核中共有三个“时机”：

1）从一个硬中断返回时，即在irq_exit中有机会执行软中断（详见前一节中的分析）。

2）在ksoftirqd内核线程中被执行，稍后分析。

3）在那些显式检查或执行待处理软中断的代码中。如网络系统中的netif_rx_ni函数，local_bh_enable以及local_bh_enable_ip等函数。

最终软中断都是通过do_softirq或__do_softirq函数被执行的，其中do_softirq也是通过调用__do_softirq来实现的。在内核需要执行软中断时，先通过local_softirq_pending函数检查是否有软中断挂起，如果有则调用do_softirq来执行软中断。

<kernel/softirq.c>
asmlinkage void do_softirq(void)
{
    __u32 pending;
    unsigned long flags;
/*如果in_interrupt()返回值为非0，
*则表示在中断上下文中调用了do_softirq，或者是在禁止了软中断后调用了do_softirq。
*这两种情况都不允许执行软中断，所以直接返回。
*/
    if (in_interrupt())
        return;

    local_irq_save(flags); //禁止本地CPU中断，并保存中断状态到flags临时变量中。

    pending = local_softirq_pending(); //将本地软中断挂起状态位图存入局部变量pending

    if (pending) //如果有软中断挂起等待处理
        __do_softirq(); //执行软中断

    local_irq_restore(flags); //将前面保存的中断状态恢复，执行后中断是否禁止取决于第5节中断处理流程中所说的注册中断时是否设置了IRQF_DISABLED 标志。当然，在2.6.36版本以后，此处执行后中断仍是禁止的。
}
asmlinkage void __do_softirq(void)
{
    struct softirq_action *h;
    __u32 pending;
/*为了尽快地响应软中断，__do_softirq会一直处理完所有挂起的软中断，但由于软中
*断执行过程中是开启硬件中断的，如果某些中断处理程序上半部再次触发软中断（例
*如网络收发包中断处理程序），可能会造成大量软中断不停的被触发，导致
*__do_softirq会执行很长时间，从而大大延时了用户态进程的执行。为了避免这种情
*况，内核强制__do_softirq只做MAX_SOFTIRQ_RESTART次循环后就返回。
*/
    int max_restart = MAX_SOFTIRQ_RESTART;
    int cpu;

    pending = local_softirq_pending();//将本地软中断挂起状态位图存入局部变量pending
    account_system_vtime(current);

/*在真正执行软中断处理函数之前，先调用__local_bh_disable禁止下半部。因为执行软
*中断时，硬中断是开启的，如果此时产生新中断，当从新中断返回进入irq_exit函数
*时，可能有另外一个__do_softirq函数的实例开始执行。这种情况应该避免，因为软
*中断不能抢占另一个软中断。因此调用__local_bh_disable禁止下半部后，irq_exit函
*数中的!in_interrupt() && local_softirq_pending()条件就不会成立，也就不会调用
*invoke_softirq函数执行新的软中断。
*/
    __local_bh_disable((unsigned long)__builtin_return_address(0));
    lockdep_softirq_enter();

    cpu = smp_processor_id();
restart:
    /*由于前面已近将软中断挂起状态位图保存到局部变量中，此处将其清0，以便激活新
*的软中断
*/
    set_softirq_pending(0);

    local_irq_enable(); //开启本地CPU中断

    h = softirq_vec; //指向软中断向量表

    do {
        /*根据pending每一位配置，执行对应的软中断处理函数。这些中断处理函数由
*open_softirq注册的.
*/
if (pending & 1) {
            int prev_count = preempt_count();
            kstat_incr_softirqs_this_cpu(h - softirq_vec);

            trace_softirq_entry(h, softirq_vec);
            h->action(h); //执行软中断处理函数
            trace_softirq_exit(h, softirq_vec);

/*检查软中断处理函数前后的preempt计数器的值是否发生变化，如果改变了
*则打印错误提示信息并将preempt的恢复原值。对这部分代码没有完全理解，
*个人觉得各类型软中断应该彼此独立互不影响，不应该修改其他类型软中断
*的运行环境。至于修改了会引起什么副作用，暂时还不了解，以后再深入分
*析吧。
*/
            if (unlikely(prev_count != preempt_count())) {
                printk(KERN_ERR "huh, entered softirq %td %s %p"
                 "with preempt_count %08x,"
                 " exited with %08x?\n", h - softirq_vec,
                       softirq_to_name[h - softirq_vec],
                       h->action, prev_count, preempt_count());
                preempt_count() = prev_count;
            }

            rcu_bh_qs(cpu);
        }
        h++; //指向软中断向量表的下一项
        pending >>= 1; //软中断挂起状态位图右移1位
    } while (pending); //遍历所有类型的软中断

    local_irq_disable(); //禁止本地CPU中断

    pending = local_softirq_pending();//再次获取软中断挂起状态位图存入pending

/*如果pending不为0，表示有软中断等待处理，并且循环计数器max_restart不为0时，
*回到restart 标号处运行，遍历并处理挂起的软中断.
*/
if (pending && --max_restart)
        goto restart;
/*如果完成了max_restart次循环处理软中断后，仍有待处理的软中断（pending为非0），
*那么调用wakeup_softirqd唤醒软中断处理内核线程处理本地CPU上的软中断，稍后
*分析。
*/
    if (pending)
        wakeup_softirqd();

    lockdep_softirq_exit();

    account_system_vtime(current);
    _local_bh_enable(); //最后开启中断下半部
}

最后，我们再分析一下处理软中断的内核线程（ksoftirqd）。这实际上是内核为了解决大量软中断重复触发“霸占”CPU导致用户进程处于饥饿状态的一种折中方案。借助内核线程，可以保证在软中断负担很重的时候用户进程不会因为得不到处理时间而处于饥饿状态；同时也保证过量的软中断终究会得到处理。即使在空闲系统上，这种方案也表现良好，软中断处理得非常迅速，因为仅存的内核线程肯定会马上调度。

内核中有两个地方调用wakeup_softirqd唤醒ksoftirqd内核线程：

1）在__do_softirq函数中。

2）在raise_softirq_irqoff函数中。

<kernel/softirq.c>
static int ksoftirqd(void * __bind_cpu)
{
    set_current_state(TASK_INTERRUPTIBLE);//将当前进程状态设置为TASK_INTERRUPTIBLE

    while (!kthread_should_stop()) {
        preempt_disable(); //禁止内核抢占
        if (!local_softirq_pending()) { //检查是否有待处理的软中断
            preempt_enable_no_resched(); //开启内核抢占但不调度
            schedule(); //挂起内核线程，调度其他进程执行
            preempt_disable();
        }

        __set_current_state(TASK_RUNNING); //将内核线程状态设置为运行状态

        while (local_softirq_pending()) {//如果有待处理的软中断就进入循环
            /* Preempt disable stops cpu going offline.
             If already offline, we'll be on wrong CPU:
               don't process */
            if (cpu_is_offline((long)__bind_cpu))
                goto wait_to_die;
            do_softirq(); //执行软中断
            preempt_enable_no_resched();//开启内核抢占
            cond_resched(); //如果当前进程设置了TIF_NEED_RESCHED标志则调用调度器
            preempt_disable();//再次禁止内核抢占，进入下一次循环处理软中断。
            rcu_sched_qs((long)__bind_cpu);
        }//如果没有待处理的软中断，退出循环
        preempt_enable(); //开启内核抢占
        set_current_state(TASK_INTERRUPTIBLE);//将当前进程状态设置为TASK_INTERRUPTIBLE
    }
    __set_current_state(TASK_RUNNING);
    return 0;

wait_to_die://在多处理器系统中，如果发生处理器切换执行的情况，则跳到此处继续执行。
    preempt_enable();
    /* Wait for kthread_stop */
    set_current_state(TASK_INTERRUPTIBLE);
    while (!kthread_should_stop()) {
        schedule();
        set_current_state(TASK_INTERRUPTIBLE);
    }
    __set_current_state(TASK_RUNNING);
    return 0;
}

参考资料：

[1] Andrew N.Sloss, Dominic Symes, Chris Wright. ARM嵌入式系统开发——软件设计与优化. 沈建华, 译.

[2] Daniel P.Bovet, Marco Cesati. 深入理解Linux内核（第三版）. 陈莉君, 张琼声, 张宏伟, 译.

[3] Pobert Love. Linux内核设计与实现. 陈莉君, 康华, 张波, 译.

[4] Wolfgang Mauerer. 深入Linux内核架构. 郭旭, 译.

[5] 陈学松. 深入Linux设备驱动程序内核机制.

[6] ARM Architecture Reference Manual

[7] The ARM-THUMB Procedure Call Standard