mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-26 02:39:48 +00:00
![Thomas Gleixner](/assets/img/avatar_default.png)
When interrupts are shutdown, they are immediately deactivated in the
irqdomain hierarchy. While this looks obviously correct there is a subtle
issue:
There might be an interrupt in flight when free_irq() is invoking the
shutdown. This is properly handled at the irq descriptor / primary handler
level, but the deactivation might completely disable resources which are
required to acknowledge the interrupt.
Split the shutdown code and deactivate the interrupt after synchronization
in free_irq(). Fixup all other usage sites where this is not an issue to
invoke the combined shutdown_and_deactivate() function instead.
This still might be an issue if the interrupt in flight servicing is
delayed on a remote CPU beyond the invocation of synchronize_irq(), but
that cannot be handled at that level and needs to be handled in the
synchronize_irq() context.
Fixes: f8264e3496
("irqdomain: Introduce new interfaces to support hierarchy irqdomains")
Reported-by: Robert Hodaszi <Robert.Hodaszi@digi.com>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Reviewed-by: Marc Zyngier <marc.zyngier@arm.com>
Link: https://lkml.kernel.org/r/20190628111440.098196390@linutronix.de
184 lines
4.6 KiB
C
184 lines
4.6 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Copyright (C) 1992, 1998-2004 Linus Torvalds, Ingo Molnar
|
|
*
|
|
* This file contains the interrupt probing code and driver APIs.
|
|
*/
|
|
|
|
#include <linux/irq.h>
|
|
#include <linux/module.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/async.h>
|
|
|
|
#include "internals.h"
|
|
|
|
/*
|
|
* Autodetection depends on the fact that any interrupt that
|
|
* comes in on to an unassigned handler will get stuck with
|
|
* "IRQS_WAITING" cleared and the interrupt disabled.
|
|
*/
|
|
static DEFINE_MUTEX(probing_active);
|
|
|
|
/**
|
|
* probe_irq_on - begin an interrupt autodetect
|
|
*
|
|
* Commence probing for an interrupt. The interrupts are scanned
|
|
* and a mask of potential interrupt lines is returned.
|
|
*
|
|
*/
|
|
unsigned long probe_irq_on(void)
|
|
{
|
|
struct irq_desc *desc;
|
|
unsigned long mask = 0;
|
|
int i;
|
|
|
|
/*
|
|
* quiesce the kernel, or at least the asynchronous portion
|
|
*/
|
|
async_synchronize_full();
|
|
mutex_lock(&probing_active);
|
|
/*
|
|
* something may have generated an irq long ago and we want to
|
|
* flush such a longstanding irq before considering it as spurious.
|
|
*/
|
|
for_each_irq_desc_reverse(i, desc) {
|
|
raw_spin_lock_irq(&desc->lock);
|
|
if (!desc->action && irq_settings_can_probe(desc)) {
|
|
/*
|
|
* Some chips need to know about probing in
|
|
* progress:
|
|
*/
|
|
if (desc->irq_data.chip->irq_set_type)
|
|
desc->irq_data.chip->irq_set_type(&desc->irq_data,
|
|
IRQ_TYPE_PROBE);
|
|
irq_activate_and_startup(desc, IRQ_NORESEND);
|
|
}
|
|
raw_spin_unlock_irq(&desc->lock);
|
|
}
|
|
|
|
/* Wait for longstanding interrupts to trigger. */
|
|
msleep(20);
|
|
|
|
/*
|
|
* enable any unassigned irqs
|
|
* (we must startup again here because if a longstanding irq
|
|
* happened in the previous stage, it may have masked itself)
|
|
*/
|
|
for_each_irq_desc_reverse(i, desc) {
|
|
raw_spin_lock_irq(&desc->lock);
|
|
if (!desc->action && irq_settings_can_probe(desc)) {
|
|
desc->istate |= IRQS_AUTODETECT | IRQS_WAITING;
|
|
if (irq_activate_and_startup(desc, IRQ_NORESEND))
|
|
desc->istate |= IRQS_PENDING;
|
|
}
|
|
raw_spin_unlock_irq(&desc->lock);
|
|
}
|
|
|
|
/*
|
|
* Wait for spurious interrupts to trigger
|
|
*/
|
|
msleep(100);
|
|
|
|
/*
|
|
* Now filter out any obviously spurious interrupts
|
|
*/
|
|
for_each_irq_desc(i, desc) {
|
|
raw_spin_lock_irq(&desc->lock);
|
|
|
|
if (desc->istate & IRQS_AUTODETECT) {
|
|
/* It triggered already - consider it spurious. */
|
|
if (!(desc->istate & IRQS_WAITING)) {
|
|
desc->istate &= ~IRQS_AUTODETECT;
|
|
irq_shutdown_and_deactivate(desc);
|
|
} else
|
|
if (i < 32)
|
|
mask |= 1 << i;
|
|
}
|
|
raw_spin_unlock_irq(&desc->lock);
|
|
}
|
|
|
|
return mask;
|
|
}
|
|
EXPORT_SYMBOL(probe_irq_on);
|
|
|
|
/**
|
|
* probe_irq_mask - scan a bitmap of interrupt lines
|
|
* @val: mask of interrupts to consider
|
|
*
|
|
* Scan the interrupt lines and return a bitmap of active
|
|
* autodetect interrupts. The interrupt probe logic state
|
|
* is then returned to its previous value.
|
|
*
|
|
* Note: we need to scan all the irq's even though we will
|
|
* only return autodetect irq numbers - just so that we reset
|
|
* them all to a known state.
|
|
*/
|
|
unsigned int probe_irq_mask(unsigned long val)
|
|
{
|
|
unsigned int mask = 0;
|
|
struct irq_desc *desc;
|
|
int i;
|
|
|
|
for_each_irq_desc(i, desc) {
|
|
raw_spin_lock_irq(&desc->lock);
|
|
if (desc->istate & IRQS_AUTODETECT) {
|
|
if (i < 16 && !(desc->istate & IRQS_WAITING))
|
|
mask |= 1 << i;
|
|
|
|
desc->istate &= ~IRQS_AUTODETECT;
|
|
irq_shutdown_and_deactivate(desc);
|
|
}
|
|
raw_spin_unlock_irq(&desc->lock);
|
|
}
|
|
mutex_unlock(&probing_active);
|
|
|
|
return mask & val;
|
|
}
|
|
EXPORT_SYMBOL(probe_irq_mask);
|
|
|
|
/**
|
|
* probe_irq_off - end an interrupt autodetect
|
|
* @val: mask of potential interrupts (unused)
|
|
*
|
|
* Scans the unused interrupt lines and returns the line which
|
|
* appears to have triggered the interrupt. If no interrupt was
|
|
* found then zero is returned. If more than one interrupt is
|
|
* found then minus the first candidate is returned to indicate
|
|
* their is doubt.
|
|
*
|
|
* The interrupt probe logic state is returned to its previous
|
|
* value.
|
|
*
|
|
* BUGS: When used in a module (which arguably shouldn't happen)
|
|
* nothing prevents two IRQ probe callers from overlapping. The
|
|
* results of this are non-optimal.
|
|
*/
|
|
int probe_irq_off(unsigned long val)
|
|
{
|
|
int i, irq_found = 0, nr_of_irqs = 0;
|
|
struct irq_desc *desc;
|
|
|
|
for_each_irq_desc(i, desc) {
|
|
raw_spin_lock_irq(&desc->lock);
|
|
|
|
if (desc->istate & IRQS_AUTODETECT) {
|
|
if (!(desc->istate & IRQS_WAITING)) {
|
|
if (!nr_of_irqs)
|
|
irq_found = i;
|
|
nr_of_irqs++;
|
|
}
|
|
desc->istate &= ~IRQS_AUTODETECT;
|
|
irq_shutdown_and_deactivate(desc);
|
|
}
|
|
raw_spin_unlock_irq(&desc->lock);
|
|
}
|
|
mutex_unlock(&probing_active);
|
|
|
|
if (nr_of_irqs > 1)
|
|
irq_found = -irq_found;
|
|
|
|
return irq_found;
|
|
}
|
|
EXPORT_SYMBOL(probe_irq_off);
|
|
|