1 files changed, 56 insertions, 24 deletions

diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
index 75f3f00ac1e5..9f6580a184c9 100644
--- a/include/linux/interrupt.h
+++ b/include/linux/interrupt.h
@@ -52,16 +52,20 @@
  * IRQF_ONESHOT - Interrupt is not reenabled after the hardirq handler finished.
  *                Used by threaded interrupts which need to keep the
  *                irq line disabled until the threaded handler has been run.
+ * IRQF_NODELAY - Interrupt is not force threaded on -rt
  */
 #define IRQF_DISABLED           0x00000020
 #define IRQF_SAMPLE_RANDOM      0x00000040
 #define IRQF_SHARED             0x00000080
 #define IRQF_PROBE_SHARED       0x00000100
-#define IRQF_TIMER              0x00000200
+#define __IRQF_TIMER            0x00000200
 #define IRQF_PERCPU             0x00000400
 #define IRQF_NOBALANCING        0x00000800
 #define IRQF_IRQPOLL            0x00001000
 #define IRQF_ONESHOT            0x00002000
+#define IRQF_NODELAY            0x00004000
+
+#define IRQF_TIMER              (__IRQF_TIMER | IRQF_NODELAY)
 
 /*
  * Bits used by threaded handlers:
@@ -91,6 +95,7 @@ typedef irqreturn_t (*irq_handler_t)(int, void *);
  * @thread_fn:  interupt handler function for threaded interrupts
  * @thread:     thread pointer for threaded interrupts
  * @thread_flags:       flags related to @thread
+ * @thread_mask:        bit mask to account for forced threads
  */
 struct irqaction {
         irq_handler_t handler;
@@ -103,6 +108,7 @@ struct irqaction {
         irq_handler_t thread_fn;
         struct task_struct *thread;
         unsigned long thread_flags;
+        unsigned long thread_mask;
 };
 
 extern irqreturn_t no_action(int cpl, void *dev_id);
@@ -179,7 +185,7 @@ extern void devm_free_irq(struct device *dev, unsigned int irq, void *dev_id);
 #ifdef CONFIG_LOCKDEP
 # define local_irq_enable_in_hardirq()  do { } while (0)
 #else
-# define local_irq_enable_in_hardirq()  local_irq_enable()
+# define local_irq_enable_in_hardirq()  local_irq_enable_nort()
 #endif
 
 extern void disable_irq_nosync(unsigned int irq);
@@ -319,6 +325,7 @@ static inline int disable_irq_wake(unsigned int irq)
 
 #ifndef __ARCH_SET_SOFTIRQ_PENDING
 #define set_softirq_pending(x) (local_softirq_pending() = (x))
+// FIXME: PREEMPT_RT: set_bit()?
 #define or_softirq_pending(x)  (local_softirq_pending() |= (x))
 #endif
 
@@ -350,7 +357,6 @@ enum
         SCHED_SOFTIRQ,
         HRTIMER_SOFTIRQ,
         RCU_SOFTIRQ,    /* Preferable RCU should always be the last softirq */
-
         NR_SOFTIRQS
 };
 
@@ -368,14 +374,23 @@ struct softirq_action
         void    (*action)(struct softirq_action *);
 };
 
+#ifdef CONFIG_PREEMPT_HARDIRQS
+# define __raise_softirq_irqoff(nr) raise_softirq_irqoff(nr)
+# define __do_raise_softirq_irqoff(nr) \
+        do { or_softirq_pending(1UL << (nr)); } while (0)
+#else
+# define __raise_softirq_irqoff(nr) \
+        do { or_softirq_pending(1UL << (nr)); } while (0)
+# define __do_raise_softirq_irqoff(nr) __raise_softirq_irqoff(nr)
+#endif
+
 asmlinkage void do_softirq(void);
 asmlinkage void __do_softirq(void);
 extern void open_softirq(int nr, void (*action)(struct softirq_action *));
 extern void softirq_init(void);
-#define __raise_softirq_irqoff(nr) do { or_softirq_pending(1UL << (nr)); } while (0)
 extern void raise_softirq_irqoff(unsigned int nr);
 extern void raise_softirq(unsigned int nr);
-extern void wakeup_softirqd(void);
+extern void softirq_check_pending_idle(void);
 
 /* This is the worklist that queues up per-cpu softirq work.
  *
@@ -410,8 +425,9 @@ extern void __send_remote_softirq(struct call_single_data *cp, int cpu,
      to be executed on some cpu at least once after this.
    * If the tasklet is already scheduled, but its excecution is still not
      started, it will be executed only once.
-   * If this tasklet is already running on another CPU (or schedule is called
-     from tasklet itself), it is rescheduled for later.
+   * If this tasklet is already running on another CPU, it is rescheduled
+     for later.
+   * Schedule must not be called from the tasklet itself (a lockup occurs)
    * Tasklet is strictly serialized wrt itself, but not
      wrt another tasklets. If client needs some intertask synchronization,
      he makes it with spinlocks.
@@ -436,27 +452,36 @@ struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(1), func, data }
 enum
 {
         TASKLET_STATE_SCHED,    /* Tasklet is scheduled for execution */
-        TASKLET_STATE_RUN       /* Tasklet is running (SMP only) */
+        TASKLET_STATE_RUN,      /* Tasklet is running (SMP only) */
+        TASKLET_STATE_PENDING   /* Tasklet is pending */
 };
 
-#ifdef CONFIG_SMP
+#define TASKLET_STATEF_SCHED    (1 << TASKLET_STATE_SCHED)
+#define TASKLET_STATEF_RUN      (1 << TASKLET_STATE_RUN)
+#define TASKLET_STATEF_PENDING  (1 << TASKLET_STATE_PENDING)
+
+#if defined(CONFIG_SMP) || defined(CONFIG_PREEMPT_RT)
 static inline int tasklet_trylock(struct tasklet_struct *t)
 {
         return !test_and_set_bit(TASKLET_STATE_RUN, &(t)->state);
 }
 
+static inline int tasklet_tryunlock(struct tasklet_struct *t)
+{
+        return cmpxchg(&t->state, TASKLET_STATEF_RUN, 0) == TASKLET_STATEF_RUN;
+}
+
 static inline void tasklet_unlock(struct tasklet_struct *t)
 {
         smp_mb__before_clear_bit(); 
         clear_bit(TASKLET_STATE_RUN, &(t)->state);
 }
 
-static inline void tasklet_unlock_wait(struct tasklet_struct *t)
-{
-        while (test_bit(TASKLET_STATE_RUN, &(t)->state)) { barrier(); }
-}
+extern void tasklet_unlock_wait(struct tasklet_struct *t);
+
 #else
 #define tasklet_trylock(t) 1
+#define tasklet_tryunlock(t)    1
 #define tasklet_unlock_wait(t) do { } while (0)
 #define tasklet_unlock(t) do { } while (0)
 #endif
@@ -505,22 +530,14 @@ static inline void tasklet_disable(struct tasklet_struct *t)
         smp_mb();
 }
 
-static inline void tasklet_enable(struct tasklet_struct *t)
-{
-        smp_mb__before_atomic_dec();
-        atomic_dec(&t->count);
-}
-
-static inline void tasklet_hi_enable(struct tasklet_struct *t)
-{
-        smp_mb__before_atomic_dec();
-        atomic_dec(&t->count);
-}
+extern  void tasklet_enable(struct tasklet_struct *t);
+extern  void tasklet_hi_enable(struct tasklet_struct *t);
 
 extern void tasklet_kill(struct tasklet_struct *t);
 extern void tasklet_kill_immediate(struct tasklet_struct *t, unsigned int cpu);
 extern void tasklet_init(struct tasklet_struct *t,
                          void (*func)(unsigned long), unsigned long data);
+extern void takeover_tasklets(unsigned int cpu);
 
 struct tasklet_hrtimer {
         struct hrtimer          timer;
@@ -613,4 +630,19 @@ extern int arch_probe_nr_irqs(void);
 extern int arch_early_irq_init(void);
 extern int arch_init_chip_data(struct irq_desc *desc, int node);
 
+/*
+ * local_irq* variants depending on RT/!RT
+ */
+#ifdef CONFIG_PREEMPT_RT
+# define local_irq_disable_nort()       do { } while (0)
+# define local_irq_enable_nort()        do { } while (0)
+# define local_irq_save_nort(flags)     do { local_save_flags(flags); } while (0)
+# define local_irq_restore_nort(flags)  do { (void)(flags); } while (0)
+#else
+# define local_irq_disable_nort()       local_irq_disable()
+# define local_irq_enable_nort()        local_irq_enable()
+# define local_irq_save_nort(flags)     local_irq_save(flags)
+# define local_irq_restore_nort(flags)  local_irq_restore(flags)
+#endif
+
 #endif