中断部分 - 内核中的互斥

举一个例子。在中断部分中有一个irq_desc_t类型的结构数组变量irq_desc[]，

　　该数组每个成员对应一个irq的描述结构，里面有该irq的响应函数等。
　　在irq_desc_t结构中有一个spinlock，用来保证存取(修改)的互斥。
　　对于具体一个irq成员，irq_desc[irq]，对其存取的内核执行路径有两个，一是
　　在设置该irq的响应函数时(setup_irq)，这通常发生在module的初始化阶段，或
　　系统的初始化阶段；二是在中断响应函数中(do_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;
　　/*
　　* Some drivers like serial.c use request_irq() heavily,
　　* so we have to be careful not to interfere with a
　　* running system.
　　*/
　　if (new->flags & SA_SAMPLE_RANDOM) {
　　/*
　　* This function might sleep, we want to call it first,
　　* outside of the atomic block.
　　* Yes, this might clear the entropy pool if the wrong
　　* driver is attempted to be loaded, without actually
　　* installing a new handler, but is this really a problem,
　　* only the sysadmin is able to do this.
　　*/
　　rand_initialize_irq(irq);
　　}
　　/*
　　* The following block of code has to be executed atomically
　　*/
　　[1] spin_lock_irqsave(&desc->lock,flags);
　　p = &desc->action;
　　if ((old = *p) != NULL) {
　　/* Can't share interrupts unless both agree to */
　　if (!(old->flags & new->flags & SA_SHIRQ)) {
　　[2] 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;
　　if (!shared) {
　　desc->depth = 0;
　　desc->status &= ~(IRQ_DISABLED | IRQ_AUTODETECT | IRQ_WAITING);
　　desc->handler->startup(irq);
　　}
　　[3] spin_unlock_irqrestore(&desc->lock,flags);
　　register_irq_proc(irq);
　　return 0;
　　}
　　asmlinkage unsigned int do_IRQ(struct pt_regs regs)
　　{
　　/*
　　* We ack quickly, we don't want the irq controller
　　* thinking we're snobs just because some other CPU has
　　* disabled global interrupts (we have already done the
　　* INT_ACK cycles, it's too late to try to pretend to the
　　* controller that we aren't taking the interrupt).
　　*
　　* 0 return value means that this irq is already being
　　* handled by some other CPU. (or is disabled)
　　*/
　　int irq = regs.orig_eax & 0xff; /* high bits used in ret_from_ code */
　　int cpu = smp_processor_id();
　　irq_desc_t *desc = irq_desc + irq;
　　struct irqaction * action;
　　unsigned int status;
　　kstat.irqs[cpu][irq]++;
　　[4] spin_lock(&desc->lock);
　　desc->handler->ack(irq);
　　/*
　　REPLAY is when Linux resends an IRQ that was dropped earlier
　　WAITING is used by probe to mark irqs that are being tested
　　*/
　　status = desc->status & ~(IRQ_REPLAY | IRQ_WAITING);
　　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;
　　if (!(status & (IRQ_DISABLED | IRQ_INPROGRESS))) {
　　action = desc->action;
　　status &= ~IRQ_PENDING; /* we commit to handling */
　　status |= IRQ_INPROGRESS; /* we are handling it */
　　}
　　desc->status = status;
　　/*
　　* If there is no IRQ handler or it was disabled, exit early.
　　Since we set PENDING, if another processor is handling
　　a different instance of this same irq, the other processor
　　will take care of it.
　　*/
　　if (!action)
　　goto out;
　　/*
　　* Edge triggered interrupts need to remember
　　* pending events.
　　* This applies to any hw interrupts that allow a second
　　* instance of the same irq to arrive while we are in do_IRQ
　　* or in the handler. But the code here only handles the _second_
　　* instance of the irq, not the third or fourth. So it is mostly
　　* useful for irq hardware that does not mask cleanly in an
　　* SMP environment.
　　*/
　　for (;;) {
　　[5] spin_unlock(&desc->lock);
　　handle_IRQ_event(irq, ®s, action);
　　[6] spin_lock(&desc->lock)