resend.c

  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
  4 * Copyright (C) 2005-2006, Thomas Gleixner
  5 *
  6 * This file contains the IRQ-resend code
  7 *
  8 * If the interrupt is waiting to be processed, we try to re-run it.
  9 * We can't directly run it from here since the caller might be in an
 10 * interrupt-protected region. Not all irq controller chips can
 11 * retrigger interrupts at the hardware level, so in those cases
 12 * we allow the resending of IRQs via a tasklet.
 13 */
 14
 15#include <linux/irq.h>
 16#include <linux/module.h>
 17#include <linux/random.h>
 18#include <linux/interrupt.h>
 19
 20#include "internals.h"
 21
 22#ifdef CONFIG_HARDIRQS_SW_RESEND
 23
 24/* hlist_head to handle software resend of interrupts: */
 25static HLIST_HEAD(irq_resend_list);
 26static DEFINE_RAW_SPINLOCK(irq_resend_lock);
 27
 28/*
 29 * Run software resends of IRQ's
 30 */
 31static void resend_irqs(struct tasklet_struct *unused)
 32{
 33	guard(raw_spinlock_irq)(&irq_resend_lock);
 34	while (!hlist_empty(&irq_resend_list)) {
 35		struct irq_desc *desc;
 36
 37		desc = hlist_entry(irq_resend_list.first, struct irq_desc,  resend_node);
 38		hlist_del_init(&desc->resend_node);
 39
 40		raw_spin_unlock(&irq_resend_lock);
 41		desc->handle_irq(desc);
 42		raw_spin_lock(&irq_resend_lock);
 43	}
 44}
 45
 46/* Tasklet to handle resend: */
 47static DECLARE_TASKLET(resend_tasklet, resend_irqs);
 48
 49static int irq_sw_resend(struct irq_desc *desc)
 50{
 51	/*
 52	 * Validate whether this interrupt can be safely injected from
 53	 * non interrupt context
 54	 */
 55	if (irqd_is_handle_enforce_irqctx(&desc->irq_data))
 56		return -EINVAL;
 57
 58	/*
 59	 * If the interrupt is running in the thread context of the parent
 60	 * irq we need to be careful, because we cannot trigger it
 61	 * directly.
 62	 */
 63	if (irq_settings_is_nested_thread(desc)) {
 64		/*
 65		 * If the parent_irq is valid, we retrigger the parent,
 66		 * otherwise we do nothing.
 67		 */
 68		if (!desc->parent_irq)
 69			return -EINVAL;
 70
 71		desc = irq_to_desc(desc->parent_irq);
 72		if (!desc)
 73			return -EINVAL;
 74	}
 75
 76	/* Add to resend_list and activate the softirq: */
 77	scoped_guard(raw_spinlock, &irq_resend_lock) {
 78		if (hlist_unhashed(&desc->resend_node))
 79			hlist_add_head(&desc->resend_node, &irq_resend_list);
 80	}
 81	tasklet_schedule(&resend_tasklet);
 82	return 0;
 83}
 84
 85void clear_irq_resend(struct irq_desc *desc)
 86{
 87	guard(raw_spinlock)(&irq_resend_lock);
 88	hlist_del_init(&desc->resend_node);
 89}
 90
 91void irq_resend_init(struct irq_desc *desc)
 92{
 93	INIT_HLIST_NODE(&desc->resend_node);
 94}
 95#else
 96void clear_irq_resend(struct irq_desc *desc) {}
 97void irq_resend_init(struct irq_desc *desc) {}
 98
 99static int irq_sw_resend(struct irq_desc *desc)
100{
101	return -EINVAL;
102}
103#endif
104
105static int try_retrigger(struct irq_desc *desc)
106{
107	if (desc->irq_data.chip->irq_retrigger)
108		return desc->irq_data.chip->irq_retrigger(&desc->irq_data);
109
110#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
111	return irq_chip_retrigger_hierarchy(&desc->irq_data);
112#else
113	return 0;
114#endif
115}
116
117/*
118 * IRQ resend
119 *
120 * Is called with interrupts disabled and desc->lock held.
121 */
122int check_irq_resend(struct irq_desc *desc, bool inject)
123{
124	int err = 0;
125
126	/*
127	 * We do not resend level type interrupts. Level type interrupts
128	 * are resent by hardware when they are still active. Clear the
129	 * pending bit so suspend/resume does not get confused.
130	 */
131	if (irq_settings_is_level(desc)) {
132		desc->istate &= ~IRQS_PENDING;
133		return -EINVAL;
134	}
135
136	if (desc->istate & IRQS_REPLAY)
137		return -EBUSY;
138
139	if (!(desc->istate & IRQS_PENDING) && !inject)
140		return 0;
141
142	desc->istate &= ~IRQS_PENDING;
143
144	if (!try_retrigger(desc))
145		err = irq_sw_resend(desc);
146
147	/* If the retrigger was successful, mark it with the REPLAY bit */
148	if (!err)
149		desc->istate |= IRQS_REPLAY;
150	return err;
151}
152
153#ifdef CONFIG_GENERIC_IRQ_INJECTION
154/**
155 * irq_inject_interrupt - Inject an interrupt for testing/error injection
156 * @irq:	The interrupt number
157 *
158 * This function must only be used for debug and testing purposes!
159 *
160 * Especially on x86 this can cause a premature completion of an interrupt
161 * affinity change causing the interrupt line to become stale. Very
162 * unlikely, but possible.
163 *
164 * The injection can fail for various reasons:
165 * - Interrupt is not activated
166 * - Interrupt is NMI type or currently replaying
167 * - Interrupt is level type
168 * - Interrupt does not support hardware retrigger and software resend is
169 *   either not enabled or not possible for the interrupt.
170 */
171int irq_inject_interrupt(unsigned int irq)
172{
173	int err = -EINVAL;
174
175	/* Try the state injection hardware interface first */
176	if (!irq_set_irqchip_state(irq, IRQCHIP_STATE_PENDING, true))
177		return 0;
178
179	/* That failed, try via the resend mechanism */
180	scoped_irqdesc_get_and_buslock(irq, 0) {
181		struct irq_desc *desc = scoped_irqdesc;
182
183		/*
184		 * Only try to inject when the interrupt is:
185		 *  - not NMI type
186		 *  - activated
187		 */
188		if (!irq_is_nmi(desc) && irqd_is_activated(&desc->irq_data))
189			err = check_irq_resend(desc, true);
190	}
191	return err;
192}
193EXPORT_SYMBOL_GPL(irq_inject_interrupt);
194#endif