/* * 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 cpu = smp_processor_id(); irq_desc_t *desc = irq_desc + irq; struct irqaction * action; unsigned int status;  
unsigned int handle_irq (int 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 cpu = smp_processor_id();	irq_desc_t *desc = irq_desc + irq;	struct irqaction * action;	unsigned int status;	irq_enter();	kstat_cpu(cpu).irqs[irq]++;	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 (likely(!(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 (unlikely(!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 handle_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 (;;) {		spin_unlock(&desc->lock);		handle_IRQ_event(irq, regs, action);		spin_lock(&desc->lock);				if (likely(!(desc->status & IRQ_PENDING)))			break;		desc->status &= ~IRQ_PENDING;	}	desc->status &= ~IRQ_INPROGRESS;out:	/*	 * The ->end() handler has to deal with interrupts which got	 * disabled while the handler was running.	 */	desc->handler->end(irq);	spin_unlock(&desc->lock);	irq_exit();	return 1;}
10457	/local/tlutelli/issta_data/temp/c/2005_temp/2005/10457/0c53508980a95b84c296c4336a831776cc22cf58/irq.c/buggy/arch/v850/kernel/irq.c