linux中断处理之IRQ中断

时间：2010-05-26 来源：garyybl

------------------------------------------ 一:前言在前一个专题里曾分析过所有IRQ中断处理流程,经过SAVE_ALL保存硬件环境后,都会进入do_IRQ()进行处理,今天接着分析do_IRQ()处理的相关东西.分为两部中断处理程序与软中断两个大的部份进行介绍. 二:中断处理程序在驱动程序中,通常使用request_irq()来注册中断处理程序.我们先从注册中断处理程序的实现说起. /* irq:可断号 handler:中断处理程序 irqflags:中断处理标志.SA_SHIRQ:共享中断线 SA_INTERRUPT:快速处理中断必须在关中断的情况下运行.SA_SAMPLE_RANDOM:该中断可能用于产生一个随机数 devname dev_id:设备名称与ID */ int request_irq(unsigned int irq, irqreturn_t (*handler)(int, void *, struct pt_regs *), unsigned long irqflags, const char * devname, void *dev_id) { int retval; struct irqaction * action; #if 1 if (irqflags & SA_SHIRQ) { if (!dev_id) printk("Bad boy: %s (at 0x%x) called us without a dev_id!\n", devname, (&irq)[-1]); } #endif //参数有效性判断 if (irq >= NR_IRQS) return -EINVAL; if (!handler) return -EINVAL; // 分配一个irqaction action = (struct irqaction *) kmalloc(sizeof(struct irqaction), GFP_ATOMIC); if (!action) return -ENOMEM; action->handler = handler; action->flags = irqflags; cpus_clear(action->mask); action->name = devname; action->next = NULL; action->dev_id = dev_id; //将创建并初始化完在的action加入irq_desc[NR_IRQS] retval = setup_irq(irq, action); if (retval) kfree(action); return retval; } 上面涉及到的irqaction结构与irq_desc[]的关系我们在上一节我们已经详细分析过了,这里不再赘述. 转进setup_irq(): int setup_irq(unsigned int irq, struct irqaction * new) { int shared = 0; unsigned long flags; struct irqaction *old, **p; irq_desc_t *desc = irq_desc + irq; //如果hander == no_irq_type:说明中断控制器不支持该IRQ线 if (desc->handler == &no_irq_type) return -ENOSYS; sif (new->flags & SA_SAMPLE_RANDOM) { rand_initialize_irq(irq); } /* * The following block of code has to be executed atomically */ spin_lock_irqsave(&desc->lock,flags); p = &desc->action; if ((old = *p) != NULL) { //判断这条中断线上的中断处理程序是否允许SHARE /* Can't share interrupts unless both agree to */ if (!(old->flags & new->flags & SA_SHIRQ)) { spin_unlock_irqrestore(&desc->lock,flags); return -EBUSY; } /* add new interrupt at end of irq queue */ do { p = &old->next; old = *p; } while (old); shared = 1; } //将其添加到中断处理函数链的末尾 *p = new; //如果这一条线还没有被占用,初始化这条中断线 //包含清标志,在8259A上启用这条中断线 if (!shared) { desc->depth = 0; desc->status &= ~(IRQ_DISABLED | IRQ_AUTODETECT | IRQ_WAITING | IRQ_INPROGRESS); desc->handler->startup(irq); } spin_unlock_irqrestore(&desc->lock,flags); //在proc下建立相关的文件 register_irq_proc(irq); return 0; } 现在知道怎么打一个中断处理程序挂到irq_desc[NR_IRQS]数组上了,继续分析中断处理中如何调用中断处理函数.从我们开篇时说到的do_IRQ()说起. asmlinkage unsigned int do_IRQ(struct pt_regs regs) { //屏蔽高位,取得中断号 int irq = regs.orig_eax & 0xff; /* high bits used in ret_from_ code */ //取得中断号对应的desc结构 irq_desc_t *desc = irq_desc + irq; struct irqaction * action; unsigned int status; irq_enter(); // 调试用,忽略 #ifdef CONFIG_DEBUG_STACKOVERFLOW /* Debugging check for stack overflow: is there less than 1KB free? */ { long esp; __asm__ __volatile__("andl %%esp,%0" : "=r" (esp) : "0" (THREAD_SIZE - 1)); if (unlikely(esp < (sizeof(struct thread_info) + STACK_WARN))) { printk("do_IRQ: stack overflow: %ld\n", esp - sizeof(struct thread_info)); dump_stack(); } } #endif //更新统计计数 kstat_this_cpu.irqs[irq]++; spin_lock(&desc->lock); //给8259 回一个ack.回ack之后,通常中断控制会屏蔽掉此条IRQ线 desc->handler->ack(irq); //清除IRQ_REPLAY IRQ_WAITING标志 status = desc->status & ~(IRQ_REPLAY | IRQ_WAITING); //设置IRQ_PENDING:表示中断被应答,但没有真正被处理 status |= IRQ_PENDING; /* we _want_ to handle it */ /* * If the IRQ is disabled for whatever reason, we cannot * use the action we have. */ action = NULL; //中断被屏蔽或者正在处理 //IRQ_DIASBLED:中断被禁用 //IRQ_INPROGRESS:这个类型的中断已经在被另一个CPU处理了 if (likely(!(status & (IRQ_DISABLED | IRQ_INPROGRESS)))) { action = desc->action; status &= ~IRQ_PENDING; /* we commit to handling */ //置位,表示正在处理中... status |= c; /* we are handling it */ } desc->status = status; //没有挂上相应的中断处理例程或者不满足条件 if (unlikely(!action)) goto out; for (;;) { irqreturn_t action_ret; u32 *isp; union irq_ctx * curctx; union irq_ctx * irqctx; curctx = (union irq_ctx *) current_thread_info(); irqctx = hardirq_ctx[smp_processor_id()]; spin_unlock(&desc->lock); //通常curctx == irqctx.除非中断程序使用独立的4K堆栈. if (curctx == irqctx) action_ret = handle_IRQ_event(irq, &regs, action); else { /* build the stack frame on the IRQ stack */ isp = (u32*) ((char*)irqctx + sizeof(*irqctx)); irqctx->tinfo.task = curctx->tinfo.task; irqctx->tinfo.real_stack = curctx->tinfo.real_stack; irqctx->tinfo.virtual_stack = curctx->tinfo.virtual_stack; irqctx->tinfo.previous_esp = current_stack_pointer(); *--isp = (u32) action; *--isp = (u32) &regs; *--isp = (u32) irq; asm volatile( " xchgl %%ebx,%%esp \n" " call handle_IRQ_event \n" " xchgl %%ebx,%%esp \n" : "=a"(action_ret) : "b"(isp) : "memory", "cc", "edx", "ecx" ); } spin_lock(&desc->lock); //调试用,忽略 if (!noirqdebug) note_interrupt(irq, desc, action_ret, &regs); if (curctx != irqctx) irqctx->tinfo.task = NULL; //如果没有要处理的中断了,退出 if (likely(!(desc->status & IRQ_c))) break; //又有中断到来了,继续处理 desc->status &= ~c; } //处理完了,清除IRQ_INPROGRESS标志 desc->status &= ~IRQ_INPROGRESS; out: /* * The ->end() handler has to deal with interrupts which got * disabled while the handler was running. */ //处理完了,调用中断控制器的end.通常此函数会使中断控制器恢复IRQ线中断 desc->handler->end(irq); spin_unlock(&desc->lock); //irq_exit():理论上中断处理完了,可以处理它的下半部了 irq_exit(); return 1; } 这段代码比较简单,但里面几个标志让人觉的很迷糊,列举如下: IRQ_DISABLED:相应的IRQ被禁用.既然中断线被禁用了,也就不会产生中断,进入do_IRQ()了?因为电子器件的各种原因可能会产生 “伪中断”上报给CPU. IRQ_PENDING:CPU收到这个中断信号了,已经给出了应答,但并末对其进行处理.回顾上面的代码,进入do_IRQ后,发送ack,再设置此标志. IRQ_ INPROGRESS:表示这条IRQ线的中断正在被处理.为了不弄脏CPU的高速缓存.把相同IRQ线的中断放在一起处理可以提高效率,且使中断处理程序不必重入举例说明:如果CPU A接收到一个中断信号.回一个ACK,设置c,假设此时末有这个中断线的中断处理程序在处理,继而会将标志位设为IRQ_ INPROGRESS.转去中断处理函数执行.如果此时,CPU B检测到了这条IRQ线的中断信号.它会回一个ACK.设置 IRQ_PENDING.但时此时这条IRQ线的标志为IRQ_ INPROGRESS.所以,它会进经过goto out退出.如果cpu A执行完了中断处理程序,判断它的标志线是否为IRQ_PENDING.因为CPU B已将其设为了IRQ_PENDING.所以继续循环一次.直到循环完后,清除IRQ_INPROGRESS标志注意上述读写标志都是加锁的.linux采用的这个方法,不能不赞一个 *^_^* 继续看代码: asmlinkage int handle_IRQ_event(unsigned int irq, struct pt_regs *regs, struct irqaction *action) { int status = 1; /* Force the "do bottom halves" bit */ int ret, retval = 0; //如果没有设置SA_INTERRUPT.将CPU 中断打开 //应该尽量的避免CPU关中断的情况,因为CPU屏弊本地中断,会使 //中断丢失 if (!(action->flags & SA_INTERRUPT)) local_irq_enable(); //遍历运行中断处理程序 do { ret = action->handler(irq, action->dev_id, regs); if (ret == IRQ_HANDLED) status |= action->flags; retval |= ret; action = action->next; } while (action); if (status & SA_SAMPLE_RANDOM) add_interrupt_randomness(irq); //关中断 local_irq_disable(); return retval; } 可能会有这样的疑问.如果在一根中断线上挂上了很多个中断处理程序,会不会使这一段程序的效率变得很低下呢?事实上,我们在写驱动程序的过程中,都会首先在中断处理程序里判断设备名字与设备ID,只有条件符合的设备中断才会变处理. 三:软中断为了提高中断的响应速度,很多操作系统都把中断分成了两个部份,上半部份与下半部份.上半部份通常是响应中断,并把中断所得到的数据保存进下半部.耗时的操作一般都会留到下半部去处理. 接下来,我们看一下软中断的处理模型: Start_kernel() à softirq_init(); 在softirq_init()中会注册两个常用类型的软中断,看具体代码: void __init softirq_init(void) { open_softirq(TASKLET_SOFTIRQ, tasklet_action, NULL); open_softirq(HI_SOFTIRQ, tasklet_hi_action, NULL); } //参数含义:nr:软中断类型 action:软中断处理函数 data:软中断处理函数参数 void open_softirq(int nr, void (*action)(struct softirq_action*), void *data) { softirq_vec[nr].data = data; softirq_vec[nr].action = action; } static struct softirq_action softirq_vec[32] __cacheline_aligned_in_smp; struct softirq_action { void (*action)(struct softirq_action *); void *data; }; 在上面的代码中,我们可以看到:open_softirq()中.其实就是对softirq_vec数组的nr项赋值.softirq_vec是一个32元素的数组,实际上linux内核只使用了六项. 如下示: enum { HI_SOFTIRQ=0, TIMER_SOFTIRQ, NET_TX_SOFTIRQ, NET_RX_SOFTIRQ, SCSI_SOFTIRQ, TASKLET_SOFTIRQ } 另外.如果使软中断能被CPU调度,还得要让它激活才可以.激活所使用的函数为__raise_softirq_irqoff() 代码如下: #define __raise_softirq_irqoff(nr) do { local_softirq_pending() |= 1UL << (nr); } while (0) 这个宏使local_softirq_pending的nr位置1 好了,经过open_softirq()à local_softirq_pending()后,我们来看下软中断怎么被CPU调度. 继续上面中断处理的代码.在处理完硬件中断后,会调用irq_exit().这就是软中断的入口点了,我们来看下 #define irq_exit() \ do { \ preempt_count() -= IRQ_EXIT_OFFSET; \ //注意了,软中断不可以在硬件中断上下文或者是在软中断环境中使用哦 ^_^ //softirq_pending()的判断,注意我们上面分析过的_raise_softirqoff().它判断当前cpu有没有激活软中断 if (!in_interrupt() && softirq_pending(smp_processor_id())) \ do_softirq(); \ preempt_enable_no_resched(); \ } while (0) 跟踪进do_softirq() asmlinkage void do_softirq(void) { __u32 pending; unsigned long flags; //在硬件中断环境中,退出 if (in_interrupt()) return; //禁止本地中断,不要让其受中断的影响 local_irq_save(flags); pending = local_softirq_pending(); //是否有软中断要处理? if (pending) __do_softirq(); //恢复CPU中断 local_irq_restore(flags); } 转入__do_softirq() asmlinkage void __do_softirq(void) { struct softirq_action *h; __u32 pending; int max_restart = MAX_SOFTIRQ_RESTART; int cpu; pending = local_softirq_pending(); //禁止软中断,不允许软中断嵌套 local_bh_disable(); cpu = smp_processor_id(); restart: /* Reset the pending bitmask before enabling irqs */ //把挂上去的软中断清除掉,因为我们在这里会全部处理完 local_softirq_pending() = 0; //开CPU中断 local_irq_enable(); //softirq_vec:32元素数组 h = softirq_vec; //依次处理挂上去的软中断 do { if (pending & 1) { //调用软中断函数 h->action(h); rcu_bh_qsctr_inc(cpu); } h++; pending >>= 1; } while (pending); //关CPU 中断 local_irq_disable(); pending = local_softirq_pending(); //在规定次数内，如果有新的软中断了，可以继续在这里处理完 if (pending && --max_restart) goto restart; //依然有没有处理完的软中断,为了提高系统响应效率，唤醒softirqd进行处理 if (pending) wakeup_softirqd(); //恢复软中断 __local_bh_enable(); } 从上面的处理流程可以看到，软中断处理就是调用open_ softirq()的action参数.这个函数对应的参数是软中断本身（h->action(h)），采用这样的形式，可以在改变softirq_action结构的时候，不会重写软中断处理函数在进入了软中断的时候，使用了in_interrupt()来防止软中断嵌套，和抢占硬中断环境。然后软中断以开中断的形式运行，软中断的处理随时都会被硬件中断抢占，由于在软中断运行之前调用了local_bh_disable()，所以in_interrupt（）为真，不会执行软中断. 来看下in_interrupt() local_bh_disable() __local_bh_enable()的具体代码： #define in_interrupt() (irq_count()) #define irq_count() (preempt_count() & (HARDIRQ_MASK | SOFTIRQ_MASK)) #define local_bh_disable() \ do { preempt_count() += SOFTIRQ_OFFSET; barrier(); } while (0) #define __local_bh_enable() \ do { barrier(); preempt_count() -= SOFTIRQ_OFFSET; } while (0) 相当于local_bh_disable设置了preempt_count的SOFTIRQ_OFFSET。In_interrupt判断就会返回一个真值相应的__local_bh_enable()清除了SOFTIRQ_OFFSET标志还有几个常用的判断，列举如下： in_softirq()：判断是否在一个软中断环境 hardirq_count()：判断是否在一个硬中断环境 local_bh_enable()与__local_bh_enable()作用是不相同的：前者不仅会清除SOFTIRQ_OFFSET，还会调用do_softirq()，进行软中断的处理上述几个判断的代码都很简单，可自行对照分析四：几种常用的软中断分析经过上面的分析，看到了linux的软中断处理模式，我们具体分析一下2.6kernel中常用的几种软中断 1:tasklet分析 Tasklet也是俗称的小任务机制，它使用比较方法，另外，还分为了高优先级tasklet与一般tasklet。还记得我们刚开始分析过的softirq_init()这个函数吗 void __init softirq_init(void) { //普通优先级 open_softirq(TASKLET_SOFTIRQ, tasklet_action, NULL); //高优先级 open_softirq(HI_SOFTIRQ, tasklet_hi_action, NULL); } 它们的软中断处理函数其实是tasklet_action与tasklet_hi_action. static void tasklet_action(struct softirq_action *a) { struct tasklet_struct *list; //禁止本地中断 local_irq_disable(); //per_cpu变量 list = __get_cpu_var(tasklet_vec).list; //链表置空 __get_cpu_var(tasklet_vec).list = NULL; //恢复本地中断 local_irq_enable(); //接下来要遍历链表了 while (list) { struct tasklet_struct *t = list; list = list->next; //为了避免竞争，下列操作都是在加锁情况下进行的 if (tasklet_trylock(t)) { //t->count为零才会调用task_struct里的函数 if (!atomic_read(&t->count)) { //t->count 为1。但又没有置调度标志。系统BUG if (!test_and_clear_bit(TASKLET_STATE_SCHED, &t->state)) BUG(); //调用tasklet函数 t->func(t->data); tasklet_unlock(t); continue; } tasklet_unlock(t); } //注意 :所有运行过的tasklet全被continue过去了,只有没有运行的tasklet才会重新加入到链表里面 //禁本地中断 local_irq_disable(); //把t放入队列头，准备下一次接收调度 t->next = __get_cpu_var(tasklet_vec).list; __get_cpu_var(tasklet_vec).list = t; //置软中断调用标志。下次运行到do_softirq的时候，可以继续被调用 __raise_softirq_irqoff(TASKLET_SOFTIRQ); //启用本地中断 local_irq_enable(); } } 高优先级tasklet的处理其实与上面分析的函数是一样的，只是per_cpu变量不同而已。另外，有几个问题值得考虑： 1) cpu怎么计算软中断优先级的在do_softirq()à__do_softirq()有： { pending = local_softirq_pending(); ...... do { if (pending & 1) { h->action(h); rcu_bh_qsctr_inc(cpu); } h++; pending >>= 1; } while (pending); ...... } 从上面看到，从softirq_vec[]中取项是由pending右移位计算的。另外，在激活软中断的操作中： #define __raise_softirq_irqoff(nr) do { local_softirq_pending() |= 1UL << (nr); } while (0) 可以看到 nr越小的就会越早被do_softirq遍历到 2) 在什么条件下才会运行tasklet 链表上的任务我们在上面的代码里看到只有在t->count为零，且设置了TASKLET_STATE_SCHED标志才会被遍历到链表上对应的函数那在我们自己的代码里该如何使用tasklet呢？举个例子: #include <linux/config.h> #include <linux/kernel.h> #include <linux/module.h> #include <linux/interrupt.h> static void tasklet_test_handle(unsigned long arg) { printk("in tasklet test\n"); } //声明一个tasklet DECLARE_TASKLET(tasklet_test,tasklet_test_handle,0); MODULE_LICENSE("GPL [email protected]"); int kernel_test_init() { printk("test_init\n"); //调度这个tasklet tasklet_schedule(&tasklet_test); } int kernel_test_exit() { printk("test_exit\n"); //禁用这个tasklet tasklet_kill(&tasklet_test); return 0; } module_init(kernel_test_init); module_exit(kernel_test_exit); 示例模块里涉及到tasklet通用的三个API.分别是DECLARE_TASKLET(), tasklet_schedule(),tasklet_kill() 跟踪一下内核代码: #define DECLARE_TASKLET(name, func, data) \ struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(0), func, data } struct tasklet_struct { struct tasklet_struct *next; unsigned long state; atomic_t count; void (*func)(unsigned long); unsigned long data; }; 实际上,DECLARE_TASKLET就是定义了一个tasklet_struct的变量.相应的tasklet调用函数为func().函数参数为data static inline void tasklet_schedule(struct tasklet_struct *t) { //如果tasklet没有置调度标置,也就是说该tasklet没有被调度 if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state)) __tasklet_schedule(t); } void fastcall __tasklet_schedule(struct tasklet_struct *t) { unsigned long flags; //把tasklet加到__get_cpu_var(tasklet_vec).list链表头 local_irq_save(flags); t->next = __get_cpu_var(tasklet_vec).list; __get_cpu_var(tasklet_vec).list = t; //激活相应的软中断 raise_softirq_irqoff(TASKLET_SOFTIRQ); local_irq_restore(flags); } 这个函数比较简单,不详细分析了 void tasklet_kill(struct tasklet_struct *t) { //不允许在中断环境中进行此操作 if (in_interrupt()) printk("Attempt to kill tasklet from interrupt\n"); //一直等待tasklet被调度完 while (test_and_set_bit(TASKLET_STATE_SCHED, &t->state)) { do yield(); while (test_bit(TASKLET_STATE_SCHED, &t->state)); } //一直等待tasklet被运行完 tasklet_unlock_wait(t); //清除调度标志 clear_bit(TASKLET_STATE_SCHED, &t->state); } 该函数会一直等待该tasklet调度并运行完,可能会睡眠,所以不能在中断环境中使用它 2:网络协议栈里专用软中断在前面分析网络协议协的时候分析过,网卡有两种模式,一种是中断,即数据到来时给CPU上传中断,等到CPU处理中断.第二种是轮询,即在接收到第一个数据包之后,关闭中断,CPU每隔一定时间就去网卡DMA缓冲区取数据.其实,所谓的轮询就是软中断.接下来就来研究一下网络协议栈的软中断 static int __init net_dev_init(void) { …… open_softirq(NET_TX_SOFTIRQ, net_tx_action, NULL); open_softirq(NET_RX_SOFTIRQ, net_rx_action, NULL); …… } 在这里注册了两个软中断,一个用于接收一个用于发送,函数大体差不多,我们以接收为例.从前面的分析可以知道,软中断的处理函数时就是它调用open_softirq的action参数.在这里即是net_rx_action.代码如下: static void net_rx_action(struct softirq_action *h) { //per_cpu链表.所有网卡的轮询处理函数都通过napi_struct结构存放在这链表里面 struct list_head *list = &__get_cpu_var(softnet_data).poll_list; unsigned long start_time = jiffies; int budget = netdev_budget; void *have; //关中断 local_irq_disable(); //遍历链表 while (!list_empty(list)) { struct napi_struct *n; int work, weight; if (unlikely(budget <= 0 || jiffies != start_time)) goto softnet_break; local_irq_enable(); // 取链表里的相应数据 n = list_entry(list->next, struct napi_struct, poll_list); have = netpoll_poll_lock(n); weight = n->weight; work = 0; //如果允许调度,则运行接口的poll函数 if (test_bit(NAPI_STATE_SCHED, &n->state)) work = n->poll(n, weight); WARN_ON_ONCE(work > weight); budget -= work; //关中断 local_irq_disable(); if (unlikely(work == weight)) { //如果被禁用了,就从链表中删除 if (unlikely(napi_disable_pending(n))) __napi_complete(n); Else //否则加入链表尾,等待下一次调度 list_move_tail(&n->poll_list, list); } netpoll_poll_unlock(have); } out: //启用中断 local_irq_enable(); //选择编译部份,忽略 #ifdef CONFIG_NET_DMA /* * There may not be any more sk_buffs coming right now, so push * any pending DMA copies to hardware */ if (!cpus_empty(net_dma.channel_mask)) { int chan_idx; for_each_cpu_mask(chan_idx, net_dma.channel_mask) { struct dma_chan *chan = net_dma.channels[chan_idx]; if (chan) dma_async_memcpy_issue_pending(chan); } } #endif return; softnet_break: __get_cpu_var(netdev_rx_stat).time_squeeze++; __raise_softirq_irqoff(NET_RX_SOFTIRQ); goto out; } 一般在接口驱动中,会调用__napi_schedule.将其添加进遍历链表.代码如下示: void fastcall __napi_schedule(struct napi_struct *n) { unsigned long flags; local_irq_save(flags); //加至链表末尾 list_add_tail(&n->poll_list, &__get_cpu_var(softnet_data).poll_list); //激活软中断 __raise_softirq_irqoff(NET_RX_SOFTIRQ); local_irq_restore(flags); } 关于网卡选择哪一种模式最为合适,我们在前面已经讲述过,这里不再赘述. 五:小结本节主要分析了中断程序的处理过程与软中断的实现.虽然软中断实现有很多种类,究其模型都是一样的,就是把中断的一些费时操作在响应完中断之后再进行.另外,中断与软中断处理中有很多临界区,需要关闭CPU中断和打开CPU中断.其中的奥妙还需要慢慢的体会