Linux下软中断过程(详细)源码总结

enum {   HI_SOFTIRQ=0, //处理高优先级的tasklet   TIMER_SOFTIRQ, //时钟中断相关的tasklet   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 };

struct softirq_action{    void (*action)(struct softirq_action *); //软中断发生时执行软中断的处理函数。    void *data; //软中断的处理函数的参数指针。};

void open_softirq(int nr, void (*action)(struct softirq_action*),void *data){    softirq_vec[nr].data = data;    softirq_vec[nr].action = action;} 

voidraise_softirq(unsignedint nr){    unsigned long flags;    local_irq_save(flags);    raise_softirq_irqoff(nr);    local_irq_restore(flags);}

inlinevoidraise_softirq_irqoff(unsignedint nr){    __raise_softirq_irqoff(nr);    /*     * schedule the softirq soon.     */     /*如果我们没有在中断上下文中(硬中断或者软中断)，就唤醒软中断守护进程，否则之能等到从中断返回的过程中*/    if (!in_interrupt())        wakeup_softirqd();}

#define in_interrupt() (irq_count())#define irq_count() (preempt_count() & (HARDIRQ_MASK | SOFTIRQ_MASK | NMI_MASK))

unsignedint __irq_entry do_IRQ(struct pt_regs *regs){    ......    irq_exit();}voidirq_exit(void){        ......        invoke_softirq();  //调用软irq处理}   #ifdef __ARCH_IRQ_EXIT_IRQS_DISABLED#define invoke_softirq()   __do_softirq()#else#define invoke_softirq()   do_softirq()#endif

asmlinkage void do_softirq(void){    __u32 pending;    unsigned long flags;    if (in_interrupt())//如果当前处于硬中断中，在硬中断处理函数退出时会调用irq_exit()函数来处理软中断，      或当前软中断被禁用.所以in_interrupt()返回不为1 就没必要处理软中断，直接返回        return;       local_irq_save(flags);/*保存中断寄存器的状态并禁用本地CPU的中断*/    pending = local_softirq_pending();    if (pending)        __do_softirq();        local_irq_restore(flags);/*开启所有中断，恢复eflagS寄存器的内容*/}

asmlinkage void __do_softirq(void){    struct softirq_action *h;    __u32 pending;    unsigned long end = jiffies + MAX_SOFTIRQ_TIME;    int cpu;    unsigned long old_flags = current->flags;    int max_restart = MAX_SOFTIRQ_RESTART;//重启次数最大限制    /*     * Mask out PF_MEMALLOC s current task context is borrowed for the     * softirq. A softirq handled such as network RX might set PF_MEMALLOC     * again if the socket is related to swap     */    current->flags &= ~PF_MEMALLOC;    pending = local_softirq_pending();//获取当前CPU软中断位图    account_irq_enter_time(current);    __local_bh_disable(_RET_IP_, SOFTIRQ_OFFSET);//禁止本地cpu的软中断,现在本地cpu上挂起的软中断已经存入pending临时变量中了    lockdep_softirq_enter();//标记进入softirq context    cpu = smp_processor_id();//*取本地cpu id 号restart://处理位图中的软中断    /* Reset the pending bitmask before enabling irqs */    set_softirq_pending(0);//操作对位图清零    local_irq_enable();//开启本地cpu的硬中断    h = softirq_vec;//获取软中断描述符表的起始地址    do {        if (pending & 1) {            unsigned int vec_nr = h - softirq_vec;            int prev_count = preempt_count();            kstat_incr_softirqs_this_cpu(vec_nr);            trace_softirq_entry(vec_nr);//标记进入softirq context            h->action(h);            trace_softirq_exit(vec_nr);            if (unlikely(prev_count != preempt_count())) {                printk(KERN_ERR "huh, entered softirq %u %s %p"                       "with preempt_count %08x,"                       " exited with %08x?\n", vec_nr,                       softirq_to_name[vec_nr], h->action,                       prev_count, preempt_count());                preempt_count() = prev_count;            }            rcu_bh_qs(cpu);        }        h++;        pending >>= 1;//每次pending右移1位，从代码里能看出按位右移操作，表明一次循环只处理 32 个软中断的回调函数    } while (pending);    local_irq_disable();//禁止本地CPU的硬中断    pending = local_softirq_pending();//取本地CPU的__softirq_pending，查看是否还有新的被挂起的软中断并且检查被挂起软中断的次数小于10次,如果条件满足，继续处理新的被挂起的软中断    if (pending) {        if (time_before(jiffies, end) && !need_resched() &&            --max_restart)            goto restart;        wakeup_softirqd();//如果有新的挂起的软中断并且处理循环次数已经够了10次，唤醒ksoftirq内核线程来处理软中断    }    lockdep_softirq_exit();//退出softirq context    account_irq_exit_time(current);    __local_bh_enable(SOFTIRQ_OFFSET);//使能本地CPU的软中断    tsk_restore_flags(current, old_flags, PF_MEMALLOC);}//唤醒ksoftirq内核线程来处理软中断void wakeup_softirqd(void){    /* Interrupts are disabled: no need to stop preemption */    struct task_struct *tsk = __get_cpu_var(ksoftirqd); //ksoftirqd 线程     if (tsk && tsk->state != TASK_RUNNING)        wake_up_process(tsk); //唤醒ksoftirqd线程                                                                                       }static int ksoftirqd(void * __bind_cpu){    // 设置当前进程状态为可中断的状态，     set_current_state(TASK_INTERRUPTIBLE);                                           current->flags |= PF_KSOFTIRQD; // 设置当前进程不允许被挂起       while (!kthread_should_stop()) { //循环判断当前进程是否会停止        preempt_disable();// 禁止当前进程被抢占。         if (!local_softirq_pending()) {  // 首先判断系统当前没有需要处理的 pending 状态的软中断           // 没有的话在主动放弃 CPU 前先要允许抢占，因为一直是在不允许抢占状态下执行的代码。               preempt_enable_no_resched();            // 主动放弃 CPU 将当前进程放入睡眠队列，并转换新的进程执行（调度器相关不记录在此），但此进程再次被唤醒时，直接执行下一语句。            schedule();            preempt_disable(); // 当进程再度被调度时，在以下处理期间内禁止当前进程被抢占。           }         __set_current_state(TASK_RUNNING); // 设置当前进程为运行状态。               /*         * 循环判断是否有 pending 的软中断，如果有则调用 do_softirq()来做具体处理。         * 注意：这里又是个 do_softirq() 的入口点，         * 那么在 __do_softirq() 当中循环处理 10 次软中断的回调函数后，         * 如果更有 pending 的话，会又调用到这里         * 那么在这里则又会有可能去调用 __do_softirq() 来处理软中断回调函数。         * 在__do_softirq()中，处理 10 次还处理不完的话说明系统正处于繁忙状态。         * 综上，在系统非常繁忙时，这个进程将会和 do_softirq() 相互交替执行，         * 这时此进程占用 CPU 应该会非常高，         */        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))// 如果当前被关联的 CPU 无法继续处理则跳转                 goto wait_to_die;  // 到 wait_to_die 标记出，等待结束并退出。              // 执行 do_softirq() 来处理具体的软中断回调函数。             //如果此时有一个正在处理的软中断的话，则会马上返回 注意in_interrupt()            do_softirq();            preempt_enable_no_resched();// 允许当前进程被抢占。            // 这个函数有可能间接的调用 schedule() 来转换当前进程，而且上面已允许当前进程可被抢占。            //也就是说在处理完一轮软中断回调函数时，有可能会转换到其他进程。            cond_resched();            preempt_disable(); // 禁止当前进程被抢占。            rcu_sched_qs((long)__bind_cpu);        }// 处理完所有软中断了吗？没有的话继续循环以上步骤           preempt_enable();// 允许当前进程被抢占        set_current_state(TASK_INTERRUPTIBLE); // 设置当前进程状态为可中断的状态，    }    __set_current_state(TASK_RUNNING);// 设置当前进程为运行状态    return 0;wait_to_die:// 一直等待到当前进程被停止    preempt_enable();    /* Wait for kthread_stop */    set_current_state(TASK_INTERRUPTIBLE);    // 判断当前进程是否会被停止，如果不是的话则设置进程状态为可中断状态并放弃当前 CPU 主动转换。    // 也就是说这里将一直等待当前进程将被停止时候才结束。       while (!kthread_should_stop()) {        schedule();        set_current_state(TASK_INTERRUPTIBLE);    }   // 如果将会停止则设置当前进程为运行状态后直接返回。调度器会根据优先级来使当前进程运行。    __set_current_state(TASK_RUNNING);    return 0;}

local_irq_save和local_irq_restorelocal_bh_disable和local_bh_enablelocal_irq_enable和local_irq_disable

typedef struct {unsigned int __softirq_pending;} ____cacheline_aligned irq_cpustat_t;