1 files changed, 123 insertions, 28 deletions

diff --git a/litmus/litmus_softirq.c b/litmus/litmus_softirq.c
index dbefcb560063..734a7dcdc9ca 100644
--- a/litmus/litmus_softirq.c
+++ b/litmus/litmus_softirq.c
@@ -21,7 +21,8 @@ static atomic_t num_ready_klitirqds = ATOMIC_INIT(0);
 enum pending_flags
 {
     LIT_TASKLET_LOW = 0x1,
-    LIT_TASKLET_HI  = LIT_TASKLET_LOW<<1
+    LIT_TASKLET_HI  = LIT_TASKLET_LOW<<1,
+        LIT_WORK = LIT_TASKLET_HI<<1
 };
 
 /* only support tasklet processing for now. */
@@ -37,8 +38,11 @@ struct klitirqd_info
         raw_spinlock_t                  lock;
         
         u32                                             pending;
+
+        /* in order of priority */
+        struct tasklet_head     pending_tasklets_hi;
         struct tasklet_head             pending_tasklets;
-        struct tasklet_head             pending_tasklets_hi;
+        struct list_head                worklist;
 };
 
 /* one list for each klitirqd */
@@ -66,18 +70,22 @@ inline unsigned int klitirqd_id(struct task_struct* tsk)
 inline static u32 litirq_pending_hi_irqoff(struct klitirqd_info* which)
 {
     return (which->pending & LIT_TASKLET_HI);
-};
+}
 
 inline static u32 litirq_pending_low_irqoff(struct klitirqd_info* which)
 {
     return (which->pending & LIT_TASKLET_LOW);
-};
+}
 
+inline static u32 litirq_pending_work_irqoff(struct klitirqd_info* which)
+{
+        return (which->pending & LIT_WORK);
+}
 
 inline static u32 litirq_pending_irqoff(struct klitirqd_info* which)
 {
     return(which->pending);
-};
+}
 
 
 inline static u32 litirq_pending(struct klitirqd_info* which)
@@ -93,9 +101,15 @@ inline static u32 litirq_pending(struct klitirqd_info* which)
 };
 
 
+/* returns true if thread needs to change priority to continue processing
+   pending tasklets.
+ */
 static int needs_prio_change(struct klitirqd_info* which,
                              struct tasklet_head* pending_tasklets)
 {
+        /* this function doesn't have to look at work objects since they have
+           priority below tasklets. */
+
     unsigned long flags;
     int ret = 0;
 
@@ -126,33 +140,41 @@ static int needs_prio_change(struct klitirqd_info* which,
 
 static void __reeval_prio(struct klitirqd_info* which)
 {
-    u32 pending = 0;
         struct task_struct* tsk = which->klitirqd;
     struct task_struct* new_prio = tsk_rt(tsk)->inh_task;
-    
-    if(litirq_pending_irqoff(which))
-    {
-        pending = 1;
-        if(which->pending_tasklets.head->owner != tsk_rt(tsk)->inh_task)
-        {
-            new_prio = which->pending_tasklets.head->owner;
-        }        
-    }    
-    
-    if(litirq_pending_hi_irqoff(which))
-    {
-        pending = 1;
-        if(which->pending_tasklets_hi.head->owner != tsk_rt(tsk)->inh_task)
-        {
-            new_prio = which->pending_tasklets_hi.head->owner;
-        }
-    }
-    
-    if(!pending)
+   
+        /* Check in prio-order */
+        u32 pending = litirq_pending_irqoff(which);
+        if(pending & LIT_TASKLET_HI)
+        {
+                if(which->pending_tasklets_hi.head->owner != tsk_rt(tsk)->inh_task)
+                {
+                        new_prio = which->pending_tasklets_hi.head->owner;
+                }
+        }
+        else if(pending & LIT_TASKLET_LOW)
+        {
+                if(which->pending_tasklets.head->owner != tsk_rt(tsk)->inh_task)
+                {
+                        new_prio = which->pending_tasklets.head->owner;
+                }
+        }
+        else if(pending & LIT_WORK)
+        {
+                struct work_struct* work =
+                        list_entry(&which->worklist, struct work_struct, entry);
+                if(work->owner != tsk_rt(tsk)->inh_task)
+                {
+                        new_prio = work->owner;
+                }
+        }
+        else
     {
         new_prio = NULL;
     }
-    
+   
+
+        /* inherit the proper priority */
     if(new_prio != tsk_rt(tsk)->inh_task)
     {
         if(new_prio != NULL)
@@ -301,6 +323,30 @@ static void do_lit_tasklet(struct klitirqd_info* which,
     }
 }
 
+static void do_lit_work(struct klitirqd_info* which)
+{
+        unsigned long flags;
+        work_func_t f;
+        struct work_struct* work;
+
+        // only execute one work-queue item to yield to tasklets.
+        // ...is this a good idea?
+
+        raw_spin_lock_irqsave(&which->lock, flags);
+
+        work = list_entry(&which->worklist, struct work_struct, entry);
+        list_del_init(&work->entry);
+
+        raw_spin_unlock_irqrestore(&which->lock, flags);
+
+        // do the work!
+        work_clear_pending(work);
+        f = work->func;
+        f(work);  /* can't touch 'work' after this point,
+                                 the user may have free'd it. */
+}
+
+
 static void do_litirq(struct klitirqd_info* which)
 {
     u32 pending;
@@ -351,6 +397,15 @@ static void do_litirq(struct klitirqd_info* which)
                         do_lit_tasklet(which, &which->pending_tasklets);
                         resched = needs_prio_change(which, &which->pending_tasklets);
         }
+
+                if(!resched && (pending & LIT_WORK))
+                {
+                        TRACE_CUR("%s: Invoking work object.\n", __FUNCTION__);
+                        /* Let's pray this doesn't take a long time to execute and
+                           block tasklets.  TODO: TEST THIS POSSIBILITY
+                         */
+                        do_lit_work(which);
+                }
     }
 }
 
@@ -641,7 +696,7 @@ void __litmus_tasklet_hi_schedule_first(struct tasklet_struct *t, unsigned int k
     
     if(unlikely(k_id >= NR_LITMUS_SOFTIRQD))
     {
-        TRACE("%s: No klitirqd_th%d!\n", __FUNCTION__, k_id);
+        TRACE("%s: No klitirqd_th%u!\n", __FUNCTION__, k_id);
         BUG();        
     }  
     
@@ -659,3 +714,43 @@ void __litmus_tasklet_hi_schedule_first(struct tasklet_struct *t, unsigned int k
 
 EXPORT_SYMBOL(__litmus_tasklet_hi_schedule_first);
 
+
+static void ___litmus_schedule_work(struct work_struct *w,
+                                struct klitirqd_info *which,
+                                int wakeup)
+{
+        unsigned long flags;
+
+        raw_spin_lock_irqsave(&which->lock, flags);
+
+        work_pending(w);
+        list_add_tail(&w->entry, &which->worklist);
+
+        which->pending |= LIT_WORK;
+
+        if(wakeup)
+        {
+                wakeup_litirqd_locked(which); /* wakeup the klitirqd */
+        }
+
+        raw_spin_unlock_irqrestore(&which->lock, flags);
+}
+
+void __litmus_schedule_work(struct work_struct *w, unsigned int k_id)
+{
+        if(unlikely(w->owner == NULL) || !is_realtime(w->owner))
+        {
+                TRACE("%s: No owner associated with this work object!\n", __FUNCTION__);
+                BUG();
+        }
+
+        if(unlikely(k_id >= NR_LITMUS_SOFTIRQD))
+        {
+                TRACE("%s: No klitirqd_th%u!\n", k_id);
+                BUG();
+        }
+
+        ___litmus_schedule_work(w, &klitirqds[k_id], 1);
+}
+
+EXPORT_SYMBOL(__litmus_schedule_work);