~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/irq/handle.c

Version: ~ [ linux-5.9-rc6 ] ~ [ linux-5.8.10 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.66 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.146 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.198 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.236 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.236 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * linux/kernel/irq/handle.c
  3  *
  4  * Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
  5  * Copyright (C) 2005-2006, Thomas Gleixner, Russell King
  6  *
  7  * This file contains the core interrupt handling code.
  8  *
  9  * Detailed information is available in Documentation/DocBook/genericirq
 10  *
 11  */
 12 
 13 #include <linux/irq.h>
 14 #include <linux/random.h>
 15 #include <linux/sched.h>
 16 #include <linux/interrupt.h>
 17 #include <linux/kernel_stat.h>
 18 
 19 #include <trace/events/irq.h>
 20 
 21 #include "internals.h"
 22 
 23 /**
 24  * handle_bad_irq - handle spurious and unhandled irqs
 25  * @desc:      description of the interrupt
 26  *
 27  * Handles spurious and unhandled IRQ's. It also prints a debugmessage.
 28  */
 29 void handle_bad_irq(struct irq_desc *desc)
 30 {
 31         unsigned int irq = irq_desc_get_irq(desc);
 32 
 33         print_irq_desc(irq, desc);
 34         kstat_incr_irqs_this_cpu(desc);
 35         ack_bad_irq(irq);
 36 }
 37 EXPORT_SYMBOL_GPL(handle_bad_irq);
 38 
 39 /*
 40  * Special, empty irq handler:
 41  */
 42 irqreturn_t no_action(int cpl, void *dev_id)
 43 {
 44         return IRQ_NONE;
 45 }
 46 EXPORT_SYMBOL_GPL(no_action);
 47 
 48 static void warn_no_thread(unsigned int irq, struct irqaction *action)
 49 {
 50         if (test_and_set_bit(IRQTF_WARNED, &action->thread_flags))
 51                 return;
 52 
 53         printk(KERN_WARNING "IRQ %d device %s returned IRQ_WAKE_THREAD "
 54                "but no thread function available.", irq, action->name);
 55 }
 56 
 57 void __irq_wake_thread(struct irq_desc *desc, struct irqaction *action)
 58 {
 59         /*
 60          * In case the thread crashed and was killed we just pretend that
 61          * we handled the interrupt. The hardirq handler has disabled the
 62          * device interrupt, so no irq storm is lurking.
 63          */
 64         if (action->thread->flags & PF_EXITING)
 65                 return;
 66 
 67         /*
 68          * Wake up the handler thread for this action. If the
 69          * RUNTHREAD bit is already set, nothing to do.
 70          */
 71         if (test_and_set_bit(IRQTF_RUNTHREAD, &action->thread_flags))
 72                 return;
 73 
 74         /*
 75          * It's safe to OR the mask lockless here. We have only two
 76          * places which write to threads_oneshot: This code and the
 77          * irq thread.
 78          *
 79          * This code is the hard irq context and can never run on two
 80          * cpus in parallel. If it ever does we have more serious
 81          * problems than this bitmask.
 82          *
 83          * The irq threads of this irq which clear their "running" bit
 84          * in threads_oneshot are serialized via desc->lock against
 85          * each other and they are serialized against this code by
 86          * IRQS_INPROGRESS.
 87          *
 88          * Hard irq handler:
 89          *
 90          *      spin_lock(desc->lock);
 91          *      desc->state |= IRQS_INPROGRESS;
 92          *      spin_unlock(desc->lock);
 93          *      set_bit(IRQTF_RUNTHREAD, &action->thread_flags);
 94          *      desc->threads_oneshot |= mask;
 95          *      spin_lock(desc->lock);
 96          *      desc->state &= ~IRQS_INPROGRESS;
 97          *      spin_unlock(desc->lock);
 98          *
 99          * irq thread:
100          *
101          * again:
102          *      spin_lock(desc->lock);
103          *      if (desc->state & IRQS_INPROGRESS) {
104          *              spin_unlock(desc->lock);
105          *              while(desc->state & IRQS_INPROGRESS)
106          *                      cpu_relax();
107          *              goto again;
108          *      }
109          *      if (!test_bit(IRQTF_RUNTHREAD, &action->thread_flags))
110          *              desc->threads_oneshot &= ~mask;
111          *      spin_unlock(desc->lock);
112          *
113          * So either the thread waits for us to clear IRQS_INPROGRESS
114          * or we are waiting in the flow handler for desc->lock to be
115          * released before we reach this point. The thread also checks
116          * IRQTF_RUNTHREAD under desc->lock. If set it leaves
117          * threads_oneshot untouched and runs the thread another time.
118          */
119         desc->threads_oneshot |= action->thread_mask;
120 
121         /*
122          * We increment the threads_active counter in case we wake up
123          * the irq thread. The irq thread decrements the counter when
124          * it returns from the handler or in the exit path and wakes
125          * up waiters which are stuck in synchronize_irq() when the
126          * active count becomes zero. synchronize_irq() is serialized
127          * against this code (hard irq handler) via IRQS_INPROGRESS
128          * like the finalize_oneshot() code. See comment above.
129          */
130         atomic_inc(&desc->threads_active);
131 
132         wake_up_process(action->thread);
133 }
134 
135 irqreturn_t __handle_irq_event_percpu(struct irq_desc *desc, unsigned int *flags)
136 {
137         irqreturn_t retval = IRQ_NONE;
138         unsigned int irq = desc->irq_data.irq;
139         struct irqaction *action;
140 
141         for_each_action_of_desc(desc, action) {
142                 irqreturn_t res;
143 
144                 trace_irq_handler_entry(irq, action);
145                 res = action->handler(irq, action->dev_id);
146                 trace_irq_handler_exit(irq, action, res);
147 
148                 if (WARN_ONCE(!irqs_disabled(),"irq %u handler %pF enabled interrupts\n",
149                               irq, action->handler))
150                         local_irq_disable();
151 
152                 switch (res) {
153                 case IRQ_WAKE_THREAD:
154                         /*
155                          * Catch drivers which return WAKE_THREAD but
156                          * did not set up a thread function
157                          */
158                         if (unlikely(!action->thread_fn)) {
159                                 warn_no_thread(irq, action);
160                                 break;
161                         }
162 
163                         __irq_wake_thread(desc, action);
164 
165                         /* Fall through to add to randomness */
166                 case IRQ_HANDLED:
167                         *flags |= action->flags;
168                         break;
169 
170                 default:
171                         break;
172                 }
173 
174                 retval |= res;
175         }
176 
177         return retval;
178 }
179 
180 irqreturn_t handle_irq_event_percpu(struct irq_desc *desc)
181 {
182         irqreturn_t retval;
183         unsigned int flags = 0;
184 
185         retval = __handle_irq_event_percpu(desc, &flags);
186 
187         add_interrupt_randomness(desc->irq_data.irq, flags);
188 
189         if (!noirqdebug)
190                 note_interrupt(desc, retval);
191         return retval;
192 }
193 
194 irqreturn_t handle_irq_event(struct irq_desc *desc)
195 {
196         irqreturn_t ret;
197 
198         desc->istate &= ~IRQS_PENDING;
199         irqd_set(&desc->irq_data, IRQD_IRQ_INPROGRESS);
200         raw_spin_unlock(&desc->lock);
201 
202         ret = handle_irq_event_percpu(desc);
203 
204         raw_spin_lock(&desc->lock);
205         irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);
206         return ret;
207 }
208 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp