linux 内核中的软中断处理

Linux内核定义的软中断如下：

static struct softirq_actionsoftirq_vec[NR_SOFTIRQS] __cacheline_aligned_in_smp;

char *softirq_to_name[NR_SOFTIRQS] = {

       "HI","TIMER", "NET_TX", "NET_RX", "BLOCK",

       "TASKLET","SCHED", "HRTIMER",       "RCU"

};

内核启动时注册的软中断有以下。

其注册函数为：

void open_softirq(int nr, void(*action)(struct softirq_action *))

{

       softirq_vec[nr].action= action;

}

其实就是对全局定义的数组变量softirq_actionsoftirq_vec[NR_SOFTIRQS]进行初始化。

enum

{

       HI_SOFTIRQ=0,

       TIMER_SOFTIRQ,

       NET_TX_SOFTIRQ,

       NET_RX_SOFTIRQ,

       BLOCK_SOFTIRQ,

       TASKLET_SOFTIRQ,

       SCHED_SOFTIRQ,

       HRTIMER_SOFTIRQ,

       RCU_SOFTIRQ,    /* Preferable RCU should always be the lastsoftirq */

       NR_SOFTIRQS

}; 注册函数如下：

       open_softirq(HI_SOFTIRQ,tasklet_hi_action);

       open_softirq(TIMER_SOFTIRQ,run_timer_softirq);

       open_softirq(NET_TX_SOFTIRQ,net_tx_action);

       open_softirq(NET_RX_SOFTIRQ,net_rx_action);

       open_softirq(BLOCK_SOFTIRQ,blk_done_softirq);

open_softirq(TASKLET_SOFTIRQ,tasklet_action);

open_softirq(SCHED_SOFTIRQ,run_rebalance_domains);

open_softirq(HRTIMER_SOFTIRQ, run_hrtimer_softirq);

在irq中每一个CPU都有个结构体

typedef struct {

       unsignedlong __softirq_pending;

} ____cacheline_aligned irq_cpustat_t; 用来保存当前CPU是否有等待的中断处理函数。

在之前的文章可以知道，系统每一次执行do_irq()结束之后，都会调用函数irq_exit(void)。在这个函数中将处理软件中断，

/*

 *Exit an interrupt context. Process softirqs if needed and possible:

 */

void irq_exit(void)

{

       account_system_vtime(current);

       trace_hardirq_exit();

       sub_preempt_count(IRQ_EXIT_OFFSET);

       if(!in_interrupt() && local_softirq_pending())//表示不在中断环境下，处理软件中断，

              invoke_softirq();//同时有软件中断存在，则执行。

 

#ifdef CONFIG_NO_HZ

       /*Make sure that timer wheel updates are propagated */

       rcu_irq_exit();

       if(idle_cpu(smp_processor_id()) && !in_interrupt() &&!need_resched())

              tick_nohz_stop_sched_tick(0);

#endif

       preempt_enable_no_resched();

}

#ifdef __ARCH_IRQ_EXIT_IRQS_DISABLED

# define invoke_softirq()       __do_softirq()

#else

# define invoke_softirq()      do_softirq()

#endif

其do_softirq()函数定义如下：函数中有类似的逻辑。

asmlinkage void do_softirq(void)

{

       __u32pending;

       unsignedlong flags;

       if(in_interrupt())

              return;

       local_irq_save(flags);

       pending= local_softirq_pending();//有软件中断挂起，对挂起的断进行执行。

       if(pending)

              __do_softirq();

       local_irq_restore(flags);

}

#endif

 

在处理软件中，内核定义了一个内核线程来处理不能及时处理的软中断请求。其函数为：

static int ksoftirqd(void * __bind_cpu)；

#define MAX_SOFTIRQ_RESTART 10

asmlinkage void __do_softirq(void)

{

---------------

       h = softirq_vec;

       do{

              if(pending & 1) {

                     intprev_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);

                     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_qsctr_inc(cpu);

              }

              h++;

              pending >>= 1;

       }while (pending);

       local_irq_disable();

       pending =local_softirq_pending();

       if (pending && --max_restart)

              goto restart;

       if (pending)

              wakeup_softirqd();

       lockdep_softirq_exit();

       account_system_vtime(current);

       _local_bh_enable();

}

在__do_softirq()函数中，处理挂起的软中断，同来pending位来判断的是否有中断挂起。

入中达到了(max_restart==0)的时候，pending不为0。调用了函数wakeup_softirqd();

内核线程的创建可参考其他文章。

       switch(action) {

       caseCPU_UP_PREPARE:

       caseCPU_UP_PREPARE_FROZEN:

              p = kthread_create(ksoftirqd, hcpu,"ksoftirqd/%d", hotcpu);

 

tasklet

struct tasklet_struct

{

       structtasklet_struct *next;

       unsignedlong state;

       atomic_tcount;

       void(*func)(unsigned long);

       unsignedlong data;

};

在linux内核中有俩种类型的tasklet,

其tasklet初始化如下：

void tasklet_init(struct tasklet_struct*t,void (*func)(unsigned long), unsigned long data)

{

       t->next= NULL;

       t->state= 0;

       atomic_set(&t->count,0);

       t->func= func;

       t->data= data;

}

初始化完tasklet之后，将其加入到tasklet队列中。

低优先级tasklet的调度函数如下：

static inline void tasklet_schedule(structtasklet_struct *t)

{

       if(!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))

              __tasklet_schedule(t);

}

void __tasklet_schedule(structtasklet_struct *t)

{

       unsignedlong flags;

 

       local_irq_save(flags);

       t->next= NULL;

       *__get_cpu_var(tasklet_vec).tail= t;

       __get_cpu_var(tasklet_vec).tail= &(t->next);

       raise_softirq_irqoff(TASKLET_SOFTIRQ);//请求软中断。

       local_irq_restore(flags);

}

高优先级tasklet的调度函数如下：

static inline voidtasklet_hi_schedule(struct tasklet_struct *t)

{

       if(!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))

              __tasklet_hi_schedule(t);

}

void __tasklet_hi_schedule(structtasklet_struct *t)

{

       unsignedlong flags;

 

       local_irq_save(flags);

       t->next= NULL;

       *__get_cpu_var(tasklet_hi_vec).tail= t;

       __get_cpu_var(tasklet_hi_vec).tail= &(t->next);

       raise_softirq_irqoff(HI_SOFTIRQ);//请求软中断。

       local_irq_restore(flags);

}

有上面的俩组函数可知，将tasklet放入到不同的tasklet_vec和tasklet_hi_vec队列中。