spurious.c

  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Copyright (C) 1992, 1998-2004 Linus Torvalds, Ingo Molnar
  4 *
  5 * This file contains spurious interrupt handling.
  6 */
  7
  8#include <linux/jiffies.h>
  9#include <linux/irq.h>
 10#include <linux/module.h>
 11#include <linux/interrupt.h>
 12#include <linux/moduleparam.h>
 13#include <linux/timer.h>
 14
 15#include "internals.h"
 16
 17static int irqfixup __read_mostly;
 18
 19#define POLL_SPURIOUS_IRQ_INTERVAL (HZ/10)
 20static void poll_spurious_irqs(struct timer_list *unused);
 21static DEFINE_TIMER(poll_spurious_irq_timer, poll_spurious_irqs);
 22int irq_poll_cpu;
 23static atomic_t irq_poll_active;
 24
 25/*
 26 * Recovery handler for misrouted interrupts.
 27 */
 28static bool try_one_irq(struct irq_desc *desc, bool force)
 29{
 30	struct irqaction *action;
 31	bool ret = false;
 32
 33	guard(raw_spinlock)(&desc->lock);
 34
 35	/*
 36	 * PER_CPU, nested thread interrupts and interrupts explicitly
 37	 * marked polled are excluded from polling.
 38	 */
 39	if (irq_settings_is_per_cpu(desc) || irq_settings_is_nested_thread(desc) ||
 40	    irq_settings_is_polled(desc))
 41		return false;
 42
 43	/*
 44	 * Do not poll disabled interrupts unless the spurious
 45	 * disabled poller asks explicitly.
 46	 */
 47	if (irqd_irq_disabled(&desc->irq_data) && !force)
 48		return false;
 49
 50	/*
 51	 * All handlers must agree on IRQF_SHARED, so we test just the
 52	 * first.
 53	 */
 54	action = desc->action;
 55	if (!action || !(action->flags & IRQF_SHARED) || (action->flags & __IRQF_TIMER))
 56		return false;
 57
 58	/* Already running on another processor */
 59	if (irqd_irq_inprogress(&desc->irq_data)) {
 60		/*
 61		 * Already running: If it is shared get the other
 62		 * CPU to go looking for our mystery interrupt too
 63		 */
 64		desc->istate |= IRQS_PENDING;
 65		return false;
 66	}
 67
 68	/* Mark it poll in progress */
 69	desc->istate |= IRQS_POLL_INPROGRESS;
 70	do {
 71		if (handle_irq_event(desc) == IRQ_HANDLED)
 72			ret = true;
 73		/* Make sure that there is still a valid action */
 74		action = desc->action;
 75	} while ((desc->istate & IRQS_PENDING) && action);
 76	desc->istate &= ~IRQS_POLL_INPROGRESS;
 77	return ret;
 78}
 79
 80static int misrouted_irq(int irq)
 81{
 82	struct irq_desc *desc;
 83	int i, ok = 0;
 84
 85	if (atomic_inc_return(&irq_poll_active) != 1)
 86		goto out;
 87
 88	irq_poll_cpu = smp_processor_id();
 89
 90	for_each_irq_desc(i, desc) {
 91		if (!i)
 92			 continue;
 93
 94		if (i == irq)	/* Already tried */
 95			continue;
 96
 97		if (try_one_irq(desc, false))
 98			ok = 1;
 99	}
100out:
101	atomic_dec(&irq_poll_active);
102	/* So the caller can adjust the irq error counts */
103	return ok;
104}
105
106static void poll_spurious_irqs(struct timer_list *unused)
107{
108	struct irq_desc *desc;
109	int i;
110
111	if (atomic_inc_return(&irq_poll_active) != 1)
112		goto out;
113	irq_poll_cpu = smp_processor_id();
114
115	for_each_irq_desc(i, desc) {
116		unsigned int state;
117
118		if (!i)
119			 continue;
120
121		/* Racy but it doesn't matter */
122		state = READ_ONCE(desc->istate);
123		if (!(state & IRQS_SPURIOUS_DISABLED))
124			continue;
125
126		local_irq_disable();
127		try_one_irq(desc, true);
128		local_irq_enable();
129	}
130out:
131	atomic_dec(&irq_poll_active);
132	mod_timer(&poll_spurious_irq_timer, jiffies + POLL_SPURIOUS_IRQ_INTERVAL);
133}
134
135static inline int bad_action_ret(irqreturn_t action_ret)
136{
137	unsigned int r = action_ret;
138
139	if (likely(r <= (IRQ_HANDLED | IRQ_WAKE_THREAD)))
140		return 0;
141	return 1;
142}
143
144/*
145 * If 99,900 of the previous 100,000 interrupts have not been handled
146 * then assume that the IRQ is stuck in some manner. Drop a diagnostic
147 * and try to turn the IRQ off.
148 *
149 * (The other 100-of-100,000 interrupts may have been a correctly
150 *  functioning device sharing an IRQ with the failing one)
151 */
152static void __report_bad_irq(struct irq_desc *desc, irqreturn_t action_ret)
153{
154	unsigned int irq = irq_desc_get_irq(desc);
155	struct irqaction *action;
156
157	if (bad_action_ret(action_ret))
158		pr_err("irq event %d: bogus return value %x\n", irq, action_ret);
159	else
160		pr_err("irq %d: nobody cared (try booting with the \"irqpoll\" option)\n", irq);
161	dump_stack();
162	pr_err("handlers:\n");
163
164	/*
165	 * We need to take desc->lock here. note_interrupt() is called
166	 * w/o desc->lock held, but IRQ_PROGRESS set. We might race
167	 * with something else removing an action. It's ok to take
168	 * desc->lock here. See synchronize_irq().
169	 */
170	guard(raw_spinlock_irqsave)(&desc->lock);
171	for_each_action_of_desc(desc, action) {
172		pr_err("[<%p>] %ps", action->handler, action->handler);
173		if (action->thread_fn)
174			pr_cont(" threaded [<%p>] %ps", action->thread_fn, action->thread_fn);
175		pr_cont("\n");
176	}
177}
178
179static void report_bad_irq(struct irq_desc *desc, irqreturn_t action_ret)
180{
181	static int count = 100;
182
183	if (count > 0) {
184		count--;
185		__report_bad_irq(desc, action_ret);
186	}
187}
188
189static inline bool try_misrouted_irq(unsigned int irq, struct irq_desc *desc,
190				     irqreturn_t action_ret)
191{
192	struct irqaction *action;
193
194	if (!irqfixup)
195		return false;
196
197	/* We didn't actually handle the IRQ - see if it was misrouted? */
198	if (action_ret == IRQ_NONE)
199		return true;
200
201	/*
202	 * But for 'irqfixup == 2' we also do it for handled interrupts if
203	 * they are marked as IRQF_IRQPOLL (or for irq zero, which is the
204	 * traditional PC timer interrupt.. Legacy)
205	 */
206	if (irqfixup < 2)
207		return false;
208
209	if (!irq)
210		return true;
211
212	/*
213	 * Since we don't get the descriptor lock, "action" can
214	 * change under us.
215	 */
216	action = READ_ONCE(desc->action);
217	return action && (action->flags & IRQF_IRQPOLL);
218}
219
220#define SPURIOUS_DEFERRED	0x80000000
221
222void note_interrupt(struct irq_desc *desc, irqreturn_t action_ret)
223{
224	unsigned int irq;
225
226	if (desc->istate & IRQS_POLL_INPROGRESS || irq_settings_is_polled(desc))
227		return;
228
229	if (bad_action_ret(action_ret)) {
230		report_bad_irq(desc, action_ret);
231		return;
232	}
233
234	/*
235	 * We cannot call note_interrupt from the threaded handler
236	 * because we need to look at the compound of all handlers
237	 * (primary and threaded). Aside of that in the threaded
238	 * shared case we have no serialization against an incoming
239	 * hardware interrupt while we are dealing with a threaded
240	 * result.
241	 *
242	 * So in case a thread is woken, we just note the fact and
243	 * defer the analysis to the next hardware interrupt.
244	 *
245	 * The threaded handlers store whether they successfully
246	 * handled an interrupt and we check whether that number
247	 * changed versus the last invocation.
248	 *
249	 * We could handle all interrupts with the delayed by one
250	 * mechanism, but for the non forced threaded case we'd just
251	 * add pointless overhead to the straight hardirq interrupts
252	 * for the sake of a few lines less code.
253	 */
254	if (action_ret & IRQ_WAKE_THREAD) {
255		/*
256		 * There is a thread woken. Check whether one of the
257		 * shared primary handlers returned IRQ_HANDLED. If
258		 * not we defer the spurious detection to the next
259		 * interrupt.
260		 */
261		if (action_ret == IRQ_WAKE_THREAD) {
262			int handled;
263			/*
264			 * We use bit 31 of thread_handled_last to
265			 * denote the deferred spurious detection
266			 * active. No locking necessary as
267			 * thread_handled_last is only accessed here
268			 * and we have the guarantee that hard
269			 * interrupts are not reentrant.
270			 */
271			if (!(desc->threads_handled_last & SPURIOUS_DEFERRED)) {
272				desc->threads_handled_last |= SPURIOUS_DEFERRED;
273				return;
274			}
275			/*
276			 * Check whether one of the threaded handlers
277			 * returned IRQ_HANDLED since the last
278			 * interrupt happened.
279			 *
280			 * For simplicity we just set bit 31, as it is
281			 * set in threads_handled_last as well. So we
282			 * avoid extra masking. And we really do not
283			 * care about the high bits of the handled
284			 * count. We just care about the count being
285			 * different than the one we saw before.
286			 */
287			handled = atomic_read(&desc->threads_handled);
288			handled |= SPURIOUS_DEFERRED;
289			if (handled != desc->threads_handled_last) {
290				action_ret = IRQ_HANDLED;
291				/*
292				 * Note: We keep the SPURIOUS_DEFERRED
293				 * bit set. We are handling the
294				 * previous invocation right now.
295				 * Keep it for the current one, so the
296				 * next hardware interrupt will
297				 * account for it.
298				 */
299				desc->threads_handled_last = handled;
300			} else {
301				/*
302				 * None of the threaded handlers felt
303				 * responsible for the last interrupt
304				 *
305				 * We keep the SPURIOUS_DEFERRED bit
306				 * set in threads_handled_last as we
307				 * need to account for the current
308				 * interrupt as well.
309				 */
310				action_ret = IRQ_NONE;
311			}
312		} else {
313			/*
314			 * One of the primary handlers returned
315			 * IRQ_HANDLED. So we don't care about the
316			 * threaded handlers on the same line. Clear
317			 * the deferred detection bit.
318			 *
319			 * In theory we could/should check whether the
320			 * deferred bit is set and take the result of
321			 * the previous run into account here as
322			 * well. But it's really not worth the
323			 * trouble. If every other interrupt is
324			 * handled we never trigger the spurious
325			 * detector. And if this is just the one out
326			 * of 100k unhandled ones which is handled
327			 * then we merily delay the spurious detection
328			 * by one hard interrupt. Not a real problem.
329			 */
330			desc->threads_handled_last &= ~SPURIOUS_DEFERRED;
331		}
332	}
333
334	if (unlikely(action_ret == IRQ_NONE)) {
335		/*
336		 * If we are seeing only the odd spurious IRQ caused by
337		 * bus asynchronicity then don't eventually trigger an error,
338		 * otherwise the counter becomes a doomsday timer for otherwise
339		 * working systems
340		 */
341		if (time_after(jiffies, desc->last_unhandled + HZ/10))
342			desc->irqs_unhandled = 1;
343		else
344			desc->irqs_unhandled++;
345		desc->last_unhandled = jiffies;
346	}
347
348	irq = irq_desc_get_irq(desc);
349	if (unlikely(try_misrouted_irq(irq, desc, action_ret))) {
350		int ok = misrouted_irq(irq);
351		if (action_ret == IRQ_NONE)
352			desc->irqs_unhandled -= ok;
353	}
354
355	if (likely(!desc->irqs_unhandled))
356		return;
357
358	/* Now getting into unhandled irq detection */
359	desc->irq_count++;
360	if (likely(desc->irq_count < 100000))
361		return;
362
363	desc->irq_count = 0;
364	if (unlikely(desc->irqs_unhandled > 99900)) {
365		/*
366		 * The interrupt is stuck
367		 */
368		__report_bad_irq(desc, action_ret);
369		/*
370		 * Now kill the IRQ
371		 */
372		pr_emerg("Disabling IRQ #%d\n", irq);
373		desc->istate |= IRQS_SPURIOUS_DISABLED;
374		desc->depth++;
375		irq_disable(desc);
376
377		mod_timer(&poll_spurious_irq_timer, jiffies + POLL_SPURIOUS_IRQ_INTERVAL);
378	}
379	desc->irqs_unhandled = 0;
380}
381
382bool noirqdebug __read_mostly;
383
384int noirqdebug_setup(char *str)
385{
386	noirqdebug = 1;
387	pr_info("IRQ lockup detection disabled\n");
388	return 1;
389}
390__setup("noirqdebug", noirqdebug_setup);
391module_param(noirqdebug, bool, 0644);
392MODULE_PARM_DESC(noirqdebug, "Disable irq lockup detection when true");
393
394static int __init irqfixup_setup(char *str)
395{
396	if (IS_ENABLED(CONFIG_PREEMPT_RT)) {
397		pr_warn("irqfixup boot option not supported with PREEMPT_RT\n");
398		return 1;
399	}
400	irqfixup = 1;
401	pr_warn("Misrouted IRQ fixup support enabled.\n");
402	pr_warn("This may impact system performance.\n");
403	return 1;
404}
405__setup("irqfixup", irqfixup_setup);
406module_param(irqfixup, int, 0644);
407
408static int __init irqpoll_setup(char *str)
409{
410	if (IS_ENABLED(CONFIG_PREEMPT_RT)) {
411		pr_warn("irqpoll boot option not supported with PREEMPT_RT\n");
412		return 1;
413	}
414	irqfixup = 2;
415	pr_warn("Misrouted IRQ fixup and polling support enabled\n");
416	pr_warn("This may significantly impact system performance\n");
417	return 1;
418}
419__setup("irqpoll", irqpoll_setup);