关于do_irq的疑问

木叉叉木大

2.4情景内核分析里面do_irq这部分216页提到对同一通道的中断处理会串行化，问一下会丢失中断么？因为它只靠一个irq_pending标志位来表示，而且没处理一次就会清一次这个标志，如果同一通道有多个中断，怎么办？

chishanmingshen

1.不会丢,即使此轮没有处理,下轮也会处理,因为已经将irq_pending位置上了.
2.同一通道的多个中断,会在循环中处理,直到irq_pending位不为1退出.

amarant

2.6.10的__do_irq:

1. /*
   
2. * do_IRQ handles all normal device IRQ's (the special
   
3. * SMP cross-CPU interrupts have their own specific
   
4. * handlers).
   
5. */
   
6. fastcall unsigned int __do_IRQ(unsigned int irq, struct pt_regs *regs)
   
7. {
   
8.         irq_desc_t *desc = irq_desc + irq;
   
9.         struct irqaction * action;
   
10.         unsigned int status;
    
11. 
    
12.         kstat_this_cpu.irqs[irq]++;
    
13.         if (desc->status & IRQ_PER_CPU) {  
    
14.                 irqreturn_t action_ret;
    
15. 
    
16.                 /*
    
17.                  * No locking required for CPU-local interrupts:
    
18.                  */
    
19.                 desc->handler->ack(irq);
    
20.                 action_ret = handle_IRQ_event(irq, regs, desc->action);
    
21.                 if (!noirqdebug)
    
22.                         note_interrupt(irq, desc, action_ret);
    
23.                 desc->handler->end(irq);
    
24.                 return 1;
    
25.         }
    
26. 
    
27.         spin_lock(&desc->lock);
    
28.         desc->handler->ack(irq);
    
29.         /*
    
30.          * REPLAY is when Linux resends an IRQ that was dropped earlier
    
31.          * WAITING is used by probe to mark irqs that are being tested
    
32.          */
    
33.         status = desc->status & ~(IRQ_REPLAY | IRQ_WAITING);
    
34.         status |= IRQ_PENDING; /* we _want_ to handle it */
    
35. 
    
36.         /*
    
37.          * If the IRQ is disabled for whatever reason, we cannot
    
38.          * use the action we have.
    
39.          */
    
40.         action = NULL;
    
41.         if (likely(!(status & (IRQ_DISABLED | IRQ_INPROGRESS)))) {
    
42.                 action = desc->action;
    
43.                 status &= ~IRQ_PENDING; /* we commit to handling */
    
44.                 status |= IRQ_INPROGRESS; /* we are handling it */
    
45.         }
    
46.         desc->status = status;
    
47. 
    
48.         /*
    
49.          * If there is no IRQ handler or it was disabled, exit early.
    
50.          * Since we set PENDING, if another processor is handling
    
51.          * a different instance of this same irq, the other processor
    
52.          * will take care of it.
    
53.          */
    
54.         if (unlikely(!action))
    
55.                 goto out;
    
56. 
    
57.         /*
    
58.          * Edge triggered interrupts need to remember
    
59.          * pending events.
    
60.          * This applies to any hw interrupts that allow a second
    
61.          * instance of the same irq to arrive while we are in do_IRQ
    
62.          * or in the handler. But the code here only handles the _second_
    
63.          * instance of the irq, not the third or fourth. So it is mostly
    
64.          * useful for irq hardware that does not mask cleanly in an
    
65.          * SMP environment.
    
66.          */
    
67.         for (;;) {
    
68.                 irqreturn_t action_ret;
    
69. 
    
70.                 spin_unlock(&desc->lock);
    
71. 
    
72.                 action_ret = handle_IRQ_event(irq, regs, action);
    
73. 
    
74.                 spin_lock(&desc->lock);
    
75.                 if (!noirqdebug)
    
76.                         note_interrupt(irq, desc, action_ret);
    
77.                 if (likely(!(desc->status & IRQ_PENDING)))
    
78.                         break;
    
79.                 desc->status &= ~IRQ_PENDING;
    
80.         }
    
81.         desc->status &= ~IRQ_INPROGRESS;
    
82. 
    
83. out:
    
84.         /*
    
85.          * The ->end() handler has to deal with interrupts which got
    
86.          * disabled while the handler was running.
    
87.          */
    
88.         desc->handler->end(irq);
    
89.         spin_unlock(&desc->lock);
    
90. 
    
91.         return 1;
    
92. }

复制代码

注意到设置irq_pending标志位是有锁保护的，也就是说就算有中断发生也不会马上设置这个标志。也是顺序等待响应过之后才设置。

木叉叉木大

2.6.10的__do_irq:注意到设置irq_pending标志位是有锁保护的，也就是说就算有中断发生也不会马上设置这个标 ...
amarant 发表于 2011-05-04 08:37

如果在handle_irq_event的时候发生了不只一次的中断 怎么搞 这个函数执行前是解锁的 如果此时触发多个同通道中断 都是置为pending

木叉叉木大

回复 2# chishanmingshen


    http://www.linuxforum.net/forum/ ... 260&type=thread 网上看到了这个

amarant

回复 4# 木叉叉木大


    我的理解，如果不同CPU在这期间发生中断，那么就好几个CPU同时执行这里的代码，由于锁的保护，仍旧实现串形执行。
    如果同一个CPU在这期间两个中断源同时发生中断，我就不知道了

木叉叉木大

回复  木叉叉木大


    我的理解，如果不同CPU在这期间发生中断，那么就好几个CPU同时执行这里的代码， ...
amarant 发表于 2011-05-04 13:19

    多个cpu 如果一个cpu在handle_irq_event 那么这时是不持有锁得，如果cpu2发生同一通道的中断，只会简单的把irq_desc[irq]->status的pending位置1，然后返回，这期间也是spin_lock spin_unlock对吧 如果之后cpu3来个同一通道的中断，怎么搞？ 第一个中断还没有退出handle_irq_event

amarant

回复 7# 木叉叉木大


    发生中断到设置irq_pending还是要一步一步来，通过do_irq --> __do_irq，那么在设置irq_pending之前还是要上锁吧

chishanmingshen

我的理解也是这样的:
通过自旋锁来保护pending标志位(多核之间共享), 目的是将所有cpu的同一通道的中断都在第一个处理程序中
串行处理.

lengyuex

这个现在已经基本不用了