中断服务程序队列未加锁 并发访问？

魔血染青天

内核版本 2.4.28-8 或者 2.4.0
文件：irq.c

do_IRQ() 中

1. 
   
2. for (;;) {
   
3.                 /* 这里解开了IRQ descriptor 的锁，其它cpu便可以竞争这个锁啦*/
   
4.                 spin_unlock(&desc->lock);
   
5.                 /* 这里运行IRQ descriptor 中的每一个中断服务程序*/
   
6.                 handle_IRQ_event(irq, &regs, action);
   
7.                 spin_lock(&desc->lock);
   
8. 
   
9.                 if (!(desc->status & IRQ_PENDING))
   
10.                         break;
    
11.                 desc->status &= ~IRQ_PENDING;
    
12.         }
    
13.         desc->status &= ~IRQ_INPROGRESS;
    

复制代码

do_IRQ()->handle_IRQ_event() 中

1. 
   
2. /* 这里取出每一个中断服务程序，没有什么保护措施？*/
   
3. do {
   
4.                 status |= action->flags;
   
5.                 action->handler(irq, action->dev_id, regs);
   
6.                 action = action->next;
   
7.         } while (action);
   

复制代码

如果有另外一个cpu通过
request_irq()->setup_irq()

1. 
   
2. /* 此处等待IRQ descriptor解锁*/
   
3. spin_lock_irqsave(&desc->lock,flags);
   
4. 
   
5.         /* 向IRQ descriptor上增加中断服务程序*/
   
6.         p = &desc->action;
   
7.         if ((old = *p) != NULL) {
   
8.                 /* Can't share interrupts unless both agree to */
   
9.                 if (!(old->flags & new->flags & SA_SHIRQ)) {
   
10.                         spin_unlock_irqrestore(&desc->lock,flags);
    
11.                         return -EBUSY;
    
12.                 }
    
13. 
    
14.                 /* add new interrupt at end of irq queue */
    
15.                 do {
    
16.                         p = &old->next;
    
17.                         old = *p;
    
18.                 } while (old);
    
19.                 shared = 1;
    
20.         }
    
21. 
    
22.         *p = new;
    
23. 
    
24.         if (!shared) {
    
25.                 desc->depth = 0;
    
26.                 desc->status &= ~(IRQ_DISABLED | IRQ_AUTODETECT | IRQ_WAITING);
    
27.                 desc->handler->startup(irq);
    
28.         }
    
29. spin_unlock_irqrestore(&desc->lock,flags);
    

复制代码

问题是：一个cpu正在handle_IRQ_event()调用每一个中断服务程序，而另一个cpu在setup_irq()增加中断服务程序，这是否存在并发问题？还是在哪儿做了互斥保护的？求指教！

smalloc

感觉这段确实有问题。估计是一个不严密的折中设计吧。
假设handle_IRQ_event之前有任何自旋锁上锁，那么就决定了同一个中断不能在多处理器间同时处理。这可能带来效率的损失。而定时器中断却是这样一个典型。

setup_irq的时候即使没上锁也不会产生多大问题，有顺序添加一个结构并不会导致访问空指针。倒是free-irq的时候会产生问题，一般系统free出问题是小概率概率事件，一般情况下也不会调用FREE

我只能勉强这样解释了。希望懂中断和锁的朋友给出解释

kouu

free_irq貌似也不会有问题，一个结点从单链表里面删除，也就只需要一次赋值，不会有中间状态。

可能有问题的是：结点从链表中删除之后，要将对应的对象析构（释放空间、停处理线程、什么的）。如果一边析构，action一边又正在另一个CPU上被运行着，那么就可能有问题。

我看了2.6.35的代码，free_irq在删除一个结点之后，会调用synchronize_irq(irq)，确保其他CPU上的action结束，之后都会开始析构动作。2.4的代码我没看，应该也有类似的操作。

魔血染青天

回复 2# smalloc
”假设handle_IRQ_event之前有任何自旋锁上锁，那么就决定了同一个中断不能在多处理器间同时处理。这可能带来效率的损失。而定时器中断却是这样一个典型“

handle_IRQ_event()里面一般是在开中断的条件下运行的，如果在handle_IRQ_event()之前未将desc->lock解开，那么如果当前cpu响应了发生的一个同一中断，那么将再次请求加锁desc->lock，而desc->lock这个锁又没有解开，因此死锁。

在setup_irq()中，使用的是
spin_lock_irqsave(&desc->lock,flags);
这将防止当前cpu响应中断，和互斥其他cpu响应中断，从而并发访问IRQ descriptor。
既然这里考虑了”中断服务程序队列“的并发访问，为什么在handle_IRQ_event()中不考虑呢？

smalloc

回复 4# 魔血染青天


    自嵌可能是一个理由。不过，同级别的LEVEL中断是通过MASK保证不能嵌套的。至于能保证到哪段，就没细看了。
至于这个是是不是用来保证EDGE中断正常嵌套可以再看看。

kouu

回复  smalloc
既然这里考虑了”中断服务程序队列“的并发访问，为什么在handle_IRQ_event()中不考虑呢？

魔血染青天 发表于 2011-08-11 13:47

setup_irq要同步的是写写并发，如果两个上下文同时写一个链表，肯定是有问题的。
而handle_IRQ_event对链表是只读的，只要操作小心，不需要与写者进行同步。

smalloc

回复 4# 魔血染青天


    2。4中EDGE中断同级也是被MASK方式保护的。不可自嵌套。

魔血染青天

这个问题，我自己找到了一个解释：

do_IRQ()->handle_IRQ_event() 中

/* 这里取出每一个中断服务程序，没有什么保护措施？*/
do {
                status |= action->flags;
                action->handler(irq, action->dev_id, regs);

               /* 这里对“action->next”读取的汇编指令应该是MOV，MOV的执行只要一个时
                * 钟周期，因此是原子性操作
                */

                action = action->next;
        } while (action);


request_irq()->setup_irq()


/* 此处等待IRQ descriptor解锁*/

/* 1 这里关中断是为了防止在获得desc->lock锁后，本cpu响应中断，从而再次请求对IRQ descriptor加
* 锁，从而死锁了
*/

spin_lock_irqsave(&desc->lock,flags);

        /* 向IRQ descriptor上增加中断服务程序*/
        p = &desc->action;
        if ((old = *p) != NULL) {
                /* 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;
        }

/* 1 这里对“old->next”的写操作应该也是一条MOV指令，是原子性操作。因此，在写的时候是没有人在读
* 的。
* 2 另外，上面的desc->lock锁，除了保护IRQ descriptor外，还应该起到了防止写并发的作用！
*/

        *p = new;

        if (!shared) {
                desc->depth = 0;
                desc->status &= ~(IRQ_DISABLED | IRQ_AUTODETECT | IRQ_WAITING);
                desc->handler->startup(irq);
        }
spin_unlock_irqrestore(&desc->lock,flags);

chishanmingshen

回复 8# 魔血染青天


    并发写要加锁, 是肯定的.
    增/删和读之间还是感觉是由于没有中间态, 所以不需要加锁啊.