1 files changed, 63 insertions, 13 deletions
diff --git a/kernel/irq/handle.c b/kernel/irq/handle.c
index b110c835e070..517561fc7317 100644
--- a/kernel/irq/handle.c
+++ b/kernel/irq/handle.c
@@ -51,6 +51,68 @@ static void warn_no_thread(unsigned int irq, struct irqaction *action)
               "but no thread function available.", irq, action->name);
 }
+static void irq_wake_thread(struct irq_desc *desc, struct irqaction *action)
+{
+        /*
+         * Wake up the handler thread for this 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 the
+         * RUNTHREAD bit is already set, nothing to do.
+         */
+        if (test_bit(IRQTF_DIED, &action->thread_flags) ||
+            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;
+        wake_up_process(action->thread);
+}
 irqreturn_t
 handle_irq_event_percpu(struct irq_desc *desc, struct irqaction *action)
 {
@@ -85,19 +147,7 @@ handle_irq_event_percpu(struct irq_desc *desc, struct irqaction *action)
                                break;
                        }
-                        /*
+                        irq_wake_thread(desc, action);
-                         * Wake up the handler thread for this
-                         * action. In case the thread crashed and was
-                         * killed we just pretend that we handled the
-                         * interrupt. The hardirq handler above has
-                         * disabled the device interrupt, so no irq
-                         * storm is lurking.
-                         */
-                        if (likely(!test_bit(IRQTF_DIED,
-                                             &action->thread_flags))) {
-                                set_bit(IRQTF_RUNTHREAD, &action->thread_flags);
-                                wake_up_process(action->thread);
-                        }
                        /* Fall through to add to randomness */
                case IRQ_HANDLED:

diff --git a/kernel/irq/handle.c b/kernel/irq/handle.c index b110c835e070..517561fc7317 100644 --- a/kernel/irq/handle.c +++ b/kernel/irq/handle.c
@@ -51,6 +51,68 @@ static void warn_no_thread(unsigned int irq, struct irqaction *action)
51	"but no thread function available.", irq, action->name);	51	"but no thread function available.", irq, action->name);
52	}	52	}
53		53
		54	static void irq_wake_thread(struct irq_desc desc, struct irqaction action)
		55	{
		56	/*
		57	* Wake up the handler thread for this action. In case the
		58	* thread crashed and was killed we just pretend that we
		59	* handled the interrupt. The hardirq handler has disabled the
		60	* device interrupt, so no irq storm is lurking. If the
		61	* RUNTHREAD bit is already set, nothing to do.
		62	*/
		63	if (test_bit(IRQTF_DIED, &action->thread_flags) \|\|
		64	test_and_set_bit(IRQTF_RUNTHREAD, &action->thread_flags))
		65	return;
		66
		67	/*
		68	* It's safe to OR the mask lockless here. We have only two
		69	* places which write to threads_oneshot: This code and the
		70	* irq thread.
		71	*
		72	* This code is the hard irq context and can never run on two
		73	* cpus in parallel. If it ever does we have more serious
		74	* problems than this bitmask.
		75	*
		76	* The irq threads of this irq which clear their "running" bit
		77	* in threads_oneshot are serialized via desc->lock against
		78	* each other and they are serialized against this code by
		79	* IRQS_INPROGRESS.
		80	*
		81	* Hard irq handler:
		82	*
		83	* spin_lock(desc->lock);
		84	* desc->state \|= IRQS_INPROGRESS;
		85	* spin_unlock(desc->lock);
		86	* set_bit(IRQTF_RUNTHREAD, &action->thread_flags);
		87	* desc->threads_oneshot \|= mask;
		88	* spin_lock(desc->lock);
		89	* desc->state &= ~IRQS_INPROGRESS;
		90	* spin_unlock(desc->lock);
		91	*
		92	* irq thread:
		93	*
		94	* again:
		95	* spin_lock(desc->lock);
		96	* if (desc->state & IRQS_INPROGRESS) {
		97	* spin_unlock(desc->lock);
		98	* while(desc->state & IRQS_INPROGRESS)
		99	* cpu_relax();
		100	* goto again;
		101	* }
		102	* if (!test_bit(IRQTF_RUNTHREAD, &action->thread_flags))
		103	* desc->threads_oneshot &= ~mask;
		104	* spin_unlock(desc->lock);
		105	*
		106	* So either the thread waits for us to clear IRQS_INPROGRESS
		107	* or we are waiting in the flow handler for desc->lock to be
		108	* released before we reach this point. The thread also checks
		109	* IRQTF_RUNTHREAD under desc->lock. If set it leaves
		110	* threads_oneshot untouched and runs the thread another time.
		111	*/
		112	desc->threads_oneshot \|= action->thread_mask;
		113	wake_up_process(action->thread);
		114	}
		115
54	irqreturn_t	116	irqreturn_t
55	handle_irq_event_percpu(struct irq_desc desc, struct irqaction action)	117	handle_irq_event_percpu(struct irq_desc desc, struct irqaction action)
56	{	118	{
@@ -85,19 +147,7 @@ handle_irq_event_percpu(struct irq_desc desc, struct irqaction action)
85	break;	147	break;
86	}	148	}
87		149
88	/*	150	irq_wake_thread(desc, action);
89	* Wake up the handler thread for this
90	* action. In case the thread crashed and was
91	* killed we just pretend that we handled the
92	* interrupt. The hardirq handler above has
93	* disabled the device interrupt, so no irq
94	* storm is lurking.
95	*/
96	if (likely(!test_bit(IRQTF_DIED,
97	&action->thread_flags))) {
98	set_bit(IRQTF_RUNTHREAD, &action->thread_flags);
99	wake_up_process(action->thread);
100	}
101		151
102	/* Fall through to add to randomness */	152	/* Fall through to add to randomness */
103	case IRQ_HANDLED:	153	case IRQ_HANDLED: