![Linus Torvalds](/assets/img/avatar_default.png)
This reverts commit f72fa70760
, and solves
the problem that it tried to fix by simply making "__do_IRQ()" call the
note_interrupt() function without the lock held, the way everybody else
does.
It should be noted that all interrupt handling code must never allow the
descriptor actors to be entered "recursively" (that's why we do all the
magic IRQ_PENDING stuff in the first place), so there actually is
exclusion at that much higher level, even in the absense of locking.
Acked-by: Vivek Goyal <vgoyal@in.ibm.com>
Acked-by:Pavel Emelianov <xemul@openvz.org>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
272 lines
6.2 KiB
C
272 lines
6.2 KiB
C
/*
|
|
* linux/kernel/irq/handle.c
|
|
*
|
|
* Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
|
|
* Copyright (C) 2005-2006, Thomas Gleixner, Russell King
|
|
*
|
|
* This file contains the core interrupt handling code.
|
|
*
|
|
* Detailed information is available in Documentation/DocBook/genericirq
|
|
*
|
|
*/
|
|
|
|
#include <linux/irq.h>
|
|
#include <linux/module.h>
|
|
#include <linux/random.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/kernel_stat.h>
|
|
|
|
#include "internals.h"
|
|
|
|
/**
|
|
* handle_bad_irq - handle spurious and unhandled irqs
|
|
* @irq: the interrupt number
|
|
* @desc: description of the interrupt
|
|
* @regs: pointer to a register structure
|
|
*
|
|
* Handles spurious and unhandled IRQ's. It also prints a debugmessage.
|
|
*/
|
|
void fastcall
|
|
handle_bad_irq(unsigned int irq, struct irq_desc *desc)
|
|
{
|
|
print_irq_desc(irq, desc);
|
|
kstat_this_cpu.irqs[irq]++;
|
|
ack_bad_irq(irq);
|
|
}
|
|
|
|
/*
|
|
* Linux has a controller-independent interrupt architecture.
|
|
* Every controller has a 'controller-template', that is used
|
|
* by the main code to do the right thing. Each driver-visible
|
|
* interrupt source is transparently wired to the appropriate
|
|
* controller. Thus drivers need not be aware of the
|
|
* interrupt-controller.
|
|
*
|
|
* The code is designed to be easily extended with new/different
|
|
* interrupt controllers, without having to do assembly magic or
|
|
* having to touch the generic code.
|
|
*
|
|
* Controller mappings for all interrupt sources:
|
|
*/
|
|
struct irq_desc irq_desc[NR_IRQS] __cacheline_aligned = {
|
|
[0 ... NR_IRQS-1] = {
|
|
.status = IRQ_DISABLED,
|
|
.chip = &no_irq_chip,
|
|
.handle_irq = handle_bad_irq,
|
|
.depth = 1,
|
|
.lock = SPIN_LOCK_UNLOCKED,
|
|
#ifdef CONFIG_SMP
|
|
.affinity = CPU_MASK_ALL
|
|
#endif
|
|
}
|
|
};
|
|
|
|
/*
|
|
* What should we do if we get a hw irq event on an illegal vector?
|
|
* Each architecture has to answer this themself.
|
|
*/
|
|
static void ack_bad(unsigned int irq)
|
|
{
|
|
print_irq_desc(irq, irq_desc + irq);
|
|
ack_bad_irq(irq);
|
|
}
|
|
|
|
/*
|
|
* NOP functions
|
|
*/
|
|
static void noop(unsigned int irq)
|
|
{
|
|
}
|
|
|
|
static unsigned int noop_ret(unsigned int irq)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Generic no controller implementation
|
|
*/
|
|
struct irq_chip no_irq_chip = {
|
|
.name = "none",
|
|
.startup = noop_ret,
|
|
.shutdown = noop,
|
|
.enable = noop,
|
|
.disable = noop,
|
|
.ack = ack_bad,
|
|
.end = noop,
|
|
};
|
|
|
|
/*
|
|
* Generic dummy implementation which can be used for
|
|
* real dumb interrupt sources
|
|
*/
|
|
struct irq_chip dummy_irq_chip = {
|
|
.name = "dummy",
|
|
.startup = noop_ret,
|
|
.shutdown = noop,
|
|
.enable = noop,
|
|
.disable = noop,
|
|
.ack = noop,
|
|
.mask = noop,
|
|
.unmask = noop,
|
|
.end = noop,
|
|
};
|
|
|
|
/*
|
|
* Special, empty irq handler:
|
|
*/
|
|
irqreturn_t no_action(int cpl, void *dev_id)
|
|
{
|
|
return IRQ_NONE;
|
|
}
|
|
|
|
/**
|
|
* handle_IRQ_event - irq action chain handler
|
|
* @irq: the interrupt number
|
|
* @action: the interrupt action chain for this irq
|
|
*
|
|
* Handles the action chain of an irq event
|
|
*/
|
|
irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action)
|
|
{
|
|
irqreturn_t ret, retval = IRQ_NONE;
|
|
unsigned int status = 0;
|
|
|
|
handle_dynamic_tick(action);
|
|
|
|
if (!(action->flags & IRQF_DISABLED))
|
|
local_irq_enable_in_hardirq();
|
|
|
|
do {
|
|
ret = action->handler(irq, action->dev_id);
|
|
if (ret == IRQ_HANDLED)
|
|
status |= action->flags;
|
|
retval |= ret;
|
|
action = action->next;
|
|
} while (action);
|
|
|
|
if (status & IRQF_SAMPLE_RANDOM)
|
|
add_interrupt_randomness(irq);
|
|
local_irq_disable();
|
|
|
|
return retval;
|
|
}
|
|
|
|
#ifndef CONFIG_GENERIC_HARDIRQS_NO__DO_IRQ
|
|
/**
|
|
* __do_IRQ - original all in one highlevel IRQ handler
|
|
* @irq: the interrupt number
|
|
*
|
|
* __do_IRQ handles all normal device IRQ's (the special
|
|
* SMP cross-CPU interrupts have their own specific
|
|
* handlers).
|
|
*
|
|
* This is the original x86 implementation which is used for every
|
|
* interrupt type.
|
|
*/
|
|
fastcall unsigned int __do_IRQ(unsigned int irq)
|
|
{
|
|
struct irq_desc *desc = irq_desc + irq;
|
|
struct irqaction *action;
|
|
unsigned int status;
|
|
|
|
kstat_this_cpu.irqs[irq]++;
|
|
if (CHECK_IRQ_PER_CPU(desc->status)) {
|
|
irqreturn_t action_ret;
|
|
|
|
/*
|
|
* No locking required for CPU-local interrupts:
|
|
*/
|
|
if (desc->chip->ack)
|
|
desc->chip->ack(irq);
|
|
action_ret = handle_IRQ_event(irq, desc->action);
|
|
desc->chip->end(irq);
|
|
return 1;
|
|
}
|
|
|
|
spin_lock(&desc->lock);
|
|
if (desc->chip->ack)
|
|
desc->chip->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 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 (;;) {
|
|
irqreturn_t action_ret;
|
|
|
|
spin_unlock(&desc->lock);
|
|
|
|
action_ret = handle_IRQ_event(irq, action);
|
|
if (!noirqdebug)
|
|
note_interrupt(irq, desc, action_ret);
|
|
|
|
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->chip->end(irq);
|
|
spin_unlock(&desc->lock);
|
|
|
|
return 1;
|
|
}
|
|
#endif
|
|
|
|
#ifdef CONFIG_TRACE_IRQFLAGS
|
|
|
|
/*
|
|
* lockdep: we want to handle all irq_desc locks as a single lock-class:
|
|
*/
|
|
static struct lock_class_key irq_desc_lock_class;
|
|
|
|
void early_init_irq_lock_class(void)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < NR_IRQS; i++)
|
|
lockdep_set_class(&irq_desc[i].lock, &irq_desc_lock_class);
|
|
}
|
|
|
|
#endif
|