1 files changed, 83 insertions, 75 deletions

diff --git a/litmus/litmus_softirq.c b/litmus/litmus_softirq.c
index d1ea833dc8c4..dbefcb560063 100644
--- a/litmus/litmus_softirq.c
+++ b/litmus/litmus_softirq.c
@@ -1,27 +1,14 @@
 /* much copied shamelessly from Linux's softirq.c 
    as well as PREEMPT_RT's softirq.c */
 
-#include <linux/module.h>
-#include <linux/kernel_stat.h>
 #include <linux/interrupt.h>
-#include <linux/init.h>
-#include <linux/mm.h>
-#include <linux/notifier.h>
 #include <linux/percpu.h>
 #include <linux/cpu.h>
-#include <linux/freezer.h>
 #include <linux/kthread.h>
-#include <linux/rcupdate.h>
 #include <linux/ftrace.h>
 #include <linux/smp.h>
-#include <linux/tick.h>
 #include <linux/slab.h>
 
-#define CREATE_TRACE_POINTS
-#include <trace/events/irq.h>
-
-#include <asm/irq.h>
-
 #include <litmus/litmus.h>
 #include <litmus/jobs.h>
 #include <litmus/sched_plugin.h>
@@ -44,13 +31,12 @@ struct tasklet_head
         struct tasklet_struct **tail;
 };
 
-// sys_sched_setscheduler(current->pid, SCHED_FIFO, &param);
-// TODO: current->extra_flags |= PFE_SOFTIRQ;
-
 struct klitirqd_info
 {
         struct task_struct*             klitirqd;
         raw_spinlock_t                  lock;
+        
+        u32                                             pending;
         struct tasklet_head             pending_tasklets;
         struct tasklet_head             pending_tasklets_hi;
 };
@@ -79,41 +65,22 @@ inline unsigned int klitirqd_id(struct task_struct* tsk)
 
 inline static u32 litirq_pending_hi_irqoff(struct klitirqd_info* which)
 {
-    u32 pending = 0;
-    
-    if(which->pending_tasklets_hi.head != NULL)
-    {
-        pending = LIT_TASKLET_HI;
-    }
-    
-    return pending;
+    return (which->pending & LIT_TASKLET_HI);
 };
 
 inline static u32 litirq_pending_low_irqoff(struct klitirqd_info* which)
 {
-    u32 pending = 0;
-    
-    if(which->pending_tasklets.head != NULL)
-    {
-        pending = LIT_TASKLET_LOW;
-    }
-    
-    return pending;
+    return (which->pending & LIT_TASKLET_LOW);
 };
 
 
-static u32 litirq_pending_irqoff(struct klitirqd_info* which)
+inline static u32 litirq_pending_irqoff(struct klitirqd_info* which)
 {
-    u32 pending = 0;
-
-    pending |= litirq_pending_hi_irqoff(which);
-    pending |= litirq_pending_low_irqoff(which);
-    
-    return pending;
+    return(which->pending);
 };
 
 
-static u32 litirq_pending(struct klitirqd_info* which)
+inline static u32 litirq_pending(struct klitirqd_info* which)
 {
     unsigned long flags;
     u32 pending;
@@ -276,6 +243,13 @@ void trigger_litirqs(struct task_struct* tsk)
 }
 #endif
 
+/* forward declarations */
+static void ___litmus_tasklet_schedule(struct tasklet_struct *t,
+                                                                                  struct klitirqd_info *which,
+                                                                                  int wakeup);
+static void ___litmus_tasklet_hi_schedule(struct tasklet_struct *t,
+                                                                                  struct klitirqd_info *which,
+                                                                                  int wakeup);
 
 static void do_lit_tasklet(struct klitirqd_info* which,
                                                    struct tasklet_head* pending_tasklets)
@@ -285,11 +259,14 @@ static void do_lit_tasklet(struct klitirqd_info* which,
 
     raw_spin_lock_irqsave(&which->lock, flags);
     
-    /* copy out the tasklets for our private use. */
-    list = pending_tasklets->head;
-    pending_tasklets->head = NULL;
-    pending_tasklets->tail = &pending_tasklets->head;
-    
+        /* copy out the tasklets for our private use. */
+        list = pending_tasklets->head;
+        pending_tasklets->head = NULL;
+        pending_tasklets->tail = &pending_tasklets->head;
+        which->pending &= (pending_tasklets == &which->pending_tasklets) ?
+                ~LIT_TASKLET_LOW :
+                ~LIT_TASKLET_HI;
+
     raw_spin_unlock_irqrestore(&which->lock, flags);
     
     while(list)
@@ -314,17 +291,13 @@ static void do_lit_tasklet(struct klitirqd_info* which,
                         tasklet_unlock(t);
                 }
         
-        /* couldn't process tasklet.  put it back at the end of the main queue. */
         TRACE_CUR("%s: Could not invoke tasklet. Requeuing.\n", __FUNCTION__);
         
-        t->next = NULL;
-        
-                raw_spin_lock_irqsave(&which->lock, flags);
-        
-        *(pending_tasklets->tail) = t;
-        pending_tasklets->tail = &t->next;
-        
-                raw_spin_unlock_irqrestore(&which->lock, flags);
+                /* couldn't process tasklet.  put it back at the end of the queue. */
+                if(pending_tasklets == &which->pending_tasklets)
+                        ___litmus_tasklet_schedule(t, which, 0);
+                else
+                        ___litmus_tasklet_hi_schedule(t, which, 0);
     }
 }
 
@@ -519,6 +492,8 @@ void spawn_klitirqd(void)
     /* init the tasklet queues */
     for(i = 0; i < NR_LITMUS_SOFTIRQD; ++i)
     {
+                klitirqds[i].pending = 0;
+                
         klitirqds[i].pending_tasklets.head = NULL;
         klitirqds[i].pending_tasklets.tail = &klitirqds[i].pending_tasklets.head;
 
@@ -561,12 +536,38 @@ int klitirqd_is_ready(void)
         return(atomic_read(&num_ready_klitirqds) == NR_LITMUS_SOFTIRQD);
 }
 
+int klitirqd_is_dead(void)
+{
+        return(atomic_read(&num_ready_klitirqds) == 0);
+}
 
 
-void __litmus_tasklet_schedule(struct tasklet_struct *t, unsigned int k_id)
+
+static void ___litmus_tasklet_schedule(struct tasklet_struct *t,
+                                                                           struct klitirqd_info *which,
+                                                                           int wakeup)
 {
         unsigned long flags;
+        
+        t->next = NULL;
+        
+    raw_spin_lock_irqsave(&which->lock, flags);
     
+    *(which->pending_tasklets.tail) = t;
+    which->pending_tasklets.tail = &t->next;
+    
+        which->pending |= LIT_TASKLET_LOW;
+        
+        if(wakeup)
+        {
+                wakeup_litirqd_locked(which); /* wake up the klitirqd */
+        }
+        
+    raw_spin_unlock_irqrestore(&which->lock, flags);    
+}
+
+void __litmus_tasklet_schedule(struct tasklet_struct *t, unsigned int k_id)
+{
     if(unlikely((t->owner == NULL) || !is_realtime(t->owner)))
     {
         TRACE("%s: No owner associated with this tasklet!\n", __FUNCTION__);
@@ -579,24 +580,37 @@ void __litmus_tasklet_schedule(struct tasklet_struct *t, unsigned int k_id)
         BUG();        
     }
 
-    raw_spin_lock_irqsave(&klitirqds[k_id].lock, flags);
-    
-        t->next = NULL;
-    *klitirqds[k_id].pending_tasklets.tail = t;
-    klitirqds[k_id].pending_tasklets.tail = &t->next;
-    
-    wakeup_litirqd_locked(&klitirqds[k_id]); /* wake up the klitirqd */
-        
-    raw_spin_unlock_irqrestore(&klitirqds[k_id].lock, flags);
+        ___litmus_tasklet_schedule(t, &klitirqds[k_id], 1);
 }
 
 EXPORT_SYMBOL(__litmus_tasklet_schedule);
 
 
-void __litmus_tasklet_hi_schedule(struct tasklet_struct *t, unsigned int k_id)
+static void ___litmus_tasklet_hi_schedule(struct tasklet_struct *t,
+                                                                           struct klitirqd_info *which,
+                                                                           int wakeup)
 {
         unsigned long flags;
+        
+        t->next = NULL;
+        
+    raw_spin_lock_irqsave(&which->lock, flags);
+
+    *(which->pending_tasklets_hi.tail) = t;
+    which->pending_tasklets_hi.tail = &t->next;
     
+        which->pending |= LIT_TASKLET_HI;
+        
+        if(wakeup)
+        {
+                wakeup_litirqd_locked(which); /* wake up the klitirqd */
+        }
+        
+    raw_spin_unlock_irqrestore(&which->lock, flags);    
+}
+
+void __litmus_tasklet_hi_schedule(struct tasklet_struct *t, unsigned int k_id)
+{
     if(unlikely((t->owner == NULL) || !is_realtime(t->owner)))
     {
         TRACE("%s: No owner associated with this tasklet!\n", __FUNCTION__);
@@ -609,15 +623,7 @@ void __litmus_tasklet_hi_schedule(struct tasklet_struct *t, unsigned int k_id)
         BUG();        
     }
     
-        raw_spin_lock_irqsave(&klitirqds[k_id].lock, flags);
-    
-        t->next = NULL;
-    *klitirqds[k_id].pending_tasklets_hi.tail = t;
-    klitirqds[k_id].pending_tasklets_hi.tail = &t->next;
-    
-        wakeup_litirqd_locked(&klitirqds[k_id]); /* wake up the klitirqd */
-    
-        raw_spin_unlock_irqrestore(&klitirqds[k_id].lock, flags);
+        ___litmus_tasklet_hi_schedule(t, &klitirqds[k_id], 1);
 }
 
 EXPORT_SYMBOL(__litmus_tasklet_hi_schedule);
@@ -642,7 +648,9 @@ void __litmus_tasklet_hi_schedule_first(struct tasklet_struct *t, unsigned int k
     raw_spin_lock(&klitirqds[k_id].lock);
     
         t->next = klitirqds[k_id].pending_tasklets_hi.head;
-    klitirqds[k_id].pending_tasklets_hi.head = t;    
+    klitirqds[k_id].pending_tasklets_hi.head = t;
+        
+        klitirqds[k_id].pending |= LIT_TASKLET_HI;
     
     wakeup_litirqd_locked(&klitirqds[k_id]); /* wake up the klitirqd */