mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-06 02:50:43 +00:00
![Thomas Gleixner](/assets/img/avatar_default.png)
The whole call to note_interrupt() can be avoided or return early when interrupts would be marked accordingly. For IPI handlers which always return HANDLED the whole procedure is pretty pointless to begin with. Add a IRQF_NO_DEBUG flag and mark the interrupt accordingly if supplied when the interrupt is requested. When noirqdebug is set on the kernel commandline, then the interrupt is marked unconditionally so that there is only one condition in the hotpath to evaluate. [ clg: Add changelog ] Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Signed-off-by: Cédric Le Goater <clg@kaod.org> Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Link: https://lore.kernel.org/r/7a8ad02f-63a8-c1aa-fdd1-39d973593d02@kaod.org
229 lines
5.8 KiB
C
229 lines
5.8 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* 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/core-api/genericirq.rst
|
|
*
|
|
*/
|
|
|
|
#include <linux/irq.h>
|
|
#include <linux/random.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/kernel_stat.h>
|
|
|
|
#include <trace/events/irq.h>
|
|
|
|
#include "internals.h"
|
|
|
|
#ifdef CONFIG_GENERIC_IRQ_MULTI_HANDLER
|
|
void (*handle_arch_irq)(struct pt_regs *) __ro_after_init;
|
|
#endif
|
|
|
|
/**
|
|
* handle_bad_irq - handle spurious and unhandled irqs
|
|
* @desc: description of the interrupt
|
|
*
|
|
* Handles spurious and unhandled IRQ's. It also prints a debugmessage.
|
|
*/
|
|
void handle_bad_irq(struct irq_desc *desc)
|
|
{
|
|
unsigned int irq = irq_desc_get_irq(desc);
|
|
|
|
print_irq_desc(irq, desc);
|
|
kstat_incr_irqs_this_cpu(desc);
|
|
ack_bad_irq(irq);
|
|
}
|
|
EXPORT_SYMBOL_GPL(handle_bad_irq);
|
|
|
|
/*
|
|
* Special, empty irq handler:
|
|
*/
|
|
irqreturn_t no_action(int cpl, void *dev_id)
|
|
{
|
|
return IRQ_NONE;
|
|
}
|
|
EXPORT_SYMBOL_GPL(no_action);
|
|
|
|
static void warn_no_thread(unsigned int irq, struct irqaction *action)
|
|
{
|
|
if (test_and_set_bit(IRQTF_WARNED, &action->thread_flags))
|
|
return;
|
|
|
|
printk(KERN_WARNING "IRQ %d device %s returned IRQ_WAKE_THREAD "
|
|
"but no thread function available.", irq, action->name);
|
|
}
|
|
|
|
void __irq_wake_thread(struct irq_desc *desc, struct irqaction *action)
|
|
{
|
|
/*
|
|
* In case the thread crashed and was killed we just pretend that
|
|
* we handled the interrupt. The hardirq handler has disabled the
|
|
* device interrupt, so no irq storm is lurking.
|
|
*/
|
|
if (action->thread->flags & PF_EXITING)
|
|
return;
|
|
|
|
/*
|
|
* Wake up the handler thread for this action. If the
|
|
* RUNTHREAD bit is already set, nothing to do.
|
|
*/
|
|
if (test_and_set_bit(IRQTF_RUNTHREAD, &action->thread_flags))
|
|
return;
|
|
|
|
/*
|
|
* It's safe to OR the mask lockless here. We have only two
|
|
* places which write to threads_oneshot: This code and the
|
|
* irq thread.
|
|
*
|
|
* This code is the hard irq context and can never run on two
|
|
* cpus in parallel. If it ever does we have more serious
|
|
* problems than this bitmask.
|
|
*
|
|
* The irq threads of this irq which clear their "running" bit
|
|
* in threads_oneshot are serialized via desc->lock against
|
|
* each other and they are serialized against this code by
|
|
* IRQS_INPROGRESS.
|
|
*
|
|
* Hard irq handler:
|
|
*
|
|
* spin_lock(desc->lock);
|
|
* desc->state |= IRQS_INPROGRESS;
|
|
* spin_unlock(desc->lock);
|
|
* set_bit(IRQTF_RUNTHREAD, &action->thread_flags);
|
|
* desc->threads_oneshot |= mask;
|
|
* spin_lock(desc->lock);
|
|
* desc->state &= ~IRQS_INPROGRESS;
|
|
* spin_unlock(desc->lock);
|
|
*
|
|
* irq thread:
|
|
*
|
|
* again:
|
|
* spin_lock(desc->lock);
|
|
* if (desc->state & IRQS_INPROGRESS) {
|
|
* spin_unlock(desc->lock);
|
|
* while(desc->state & IRQS_INPROGRESS)
|
|
* cpu_relax();
|
|
* goto again;
|
|
* }
|
|
* if (!test_bit(IRQTF_RUNTHREAD, &action->thread_flags))
|
|
* desc->threads_oneshot &= ~mask;
|
|
* spin_unlock(desc->lock);
|
|
*
|
|
* So either the thread waits for us to clear IRQS_INPROGRESS
|
|
* or we are waiting in the flow handler for desc->lock to be
|
|
* released before we reach this point. The thread also checks
|
|
* IRQTF_RUNTHREAD under desc->lock. If set it leaves
|
|
* threads_oneshot untouched and runs the thread another time.
|
|
*/
|
|
desc->threads_oneshot |= action->thread_mask;
|
|
|
|
/*
|
|
* We increment the threads_active counter in case we wake up
|
|
* the irq thread. The irq thread decrements the counter when
|
|
* it returns from the handler or in the exit path and wakes
|
|
* up waiters which are stuck in synchronize_irq() when the
|
|
* active count becomes zero. synchronize_irq() is serialized
|
|
* against this code (hard irq handler) via IRQS_INPROGRESS
|
|
* like the finalize_oneshot() code. See comment above.
|
|
*/
|
|
atomic_inc(&desc->threads_active);
|
|
|
|
wake_up_process(action->thread);
|
|
}
|
|
|
|
irqreturn_t __handle_irq_event_percpu(struct irq_desc *desc, unsigned int *flags)
|
|
{
|
|
irqreturn_t retval = IRQ_NONE;
|
|
unsigned int irq = desc->irq_data.irq;
|
|
struct irqaction *action;
|
|
|
|
record_irq_time(desc);
|
|
|
|
for_each_action_of_desc(desc, action) {
|
|
irqreturn_t res;
|
|
|
|
/*
|
|
* If this IRQ would be threaded under force_irqthreads, mark it so.
|
|
*/
|
|
if (irq_settings_can_thread(desc) &&
|
|
!(action->flags & (IRQF_NO_THREAD | IRQF_PERCPU | IRQF_ONESHOT)))
|
|
lockdep_hardirq_threaded();
|
|
|
|
trace_irq_handler_entry(irq, action);
|
|
res = action->handler(irq, action->dev_id);
|
|
trace_irq_handler_exit(irq, action, res);
|
|
|
|
if (WARN_ONCE(!irqs_disabled(),"irq %u handler %pS enabled interrupts\n",
|
|
irq, action->handler))
|
|
local_irq_disable();
|
|
|
|
switch (res) {
|
|
case IRQ_WAKE_THREAD:
|
|
/*
|
|
* Catch drivers which return WAKE_THREAD but
|
|
* did not set up a thread function
|
|
*/
|
|
if (unlikely(!action->thread_fn)) {
|
|
warn_no_thread(irq, action);
|
|
break;
|
|
}
|
|
|
|
__irq_wake_thread(desc, action);
|
|
|
|
fallthrough; /* to add to randomness */
|
|
case IRQ_HANDLED:
|
|
*flags |= action->flags;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
retval |= res;
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
irqreturn_t handle_irq_event_percpu(struct irq_desc *desc)
|
|
{
|
|
irqreturn_t retval;
|
|
unsigned int flags = 0;
|
|
|
|
retval = __handle_irq_event_percpu(desc, &flags);
|
|
|
|
add_interrupt_randomness(desc->irq_data.irq, flags);
|
|
|
|
if (!irq_settings_no_debug(desc))
|
|
note_interrupt(desc, retval);
|
|
return retval;
|
|
}
|
|
|
|
irqreturn_t handle_irq_event(struct irq_desc *desc)
|
|
{
|
|
irqreturn_t ret;
|
|
|
|
desc->istate &= ~IRQS_PENDING;
|
|
irqd_set(&desc->irq_data, IRQD_IRQ_INPROGRESS);
|
|
raw_spin_unlock(&desc->lock);
|
|
|
|
ret = handle_irq_event_percpu(desc);
|
|
|
|
raw_spin_lock(&desc->lock);
|
|
irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);
|
|
return ret;
|
|
}
|
|
|
|
#ifdef CONFIG_GENERIC_IRQ_MULTI_HANDLER
|
|
int __init set_handle_irq(void (*handle_irq)(struct pt_regs *))
|
|
{
|
|
if (handle_arch_irq)
|
|
return -EBUSY;
|
|
|
|
handle_arch_irq = handle_irq;
|
|
return 0;
|
|
}
|
|
#endif
|