Kludge work-queue processing into klitirqd.wip-kernthreads

NEEDS TESTING!

3 files changed, 163 insertions, 29 deletions

diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h
index 25e02c941bac..a5c6cd3210be 100644
--- a/include/linux/workqueue.h
+++ b/include/linux/workqueue.h
@@ -83,6 +83,9 @@ struct work_struct {
 #ifdef CONFIG_LOCKDEP
         struct lockdep_map lockdep_map;
 #endif
+#ifdef CONFIG_LITMUS_SOFTIRQD
+        struct task_struct *owner;
+#endif
 };
 
 #define WORK_DATA_INIT()        ATOMIC_LONG_INIT(WORK_STRUCT_NO_CPU)
@@ -115,11 +118,25 @@ struct execute_work {
 #define __WORK_INIT_LOCKDEP_MAP(n, k)
 #endif
 
+#ifdef CONFIG_LITMUS_SOFTIRQD
+#define __WORK_INIT_OWNER() \
+        .owner = NULL,
+
+#define PREPARE_OWNER(_work, _owner) \
+        do { \
+                (_work)->owner = (_owner); \
+        } while(0)
+#else
+#define __WORK_INIT_OWNER()
+#define PREPARE_OWNER(_work, _owner)
+#endif
+
 #define __WORK_INITIALIZER(n, f) {                              \
         .data = WORK_DATA_STATIC_INIT(),                        \
         .entry  = { &(n).entry, &(n).entry },                   \
         .func = (f),                                            \
         __WORK_INIT_LOCKDEP_MAP(#n, &(n))                       \
+        __WORK_INIT_OWNER() \
         }
 
 #define __DELAYED_WORK_INITIALIZER(n, f) {                      \
diff --git a/include/litmus/litmus_softirq.h b/include/litmus/litmus_softirq.h
index 712c8119ae15..e130a26685a2 100644
--- a/include/litmus/litmus_softirq.h
+++ b/include/litmus/litmus_softirq.h
@@ -2,6 +2,7 @@
 #define __LITMUS_SOFTIRQ_H
 
 #include <linux/interrupt.h>
+#include <linux/workqueue.h>
 
 /*
    Threaded tasklet handling for Litmus.  Tasklets
@@ -105,4 +106,25 @@ static inline void litmus_tasklet_hi_schedule_first(
                 __litmus_tasklet_hi_schedule_first(t, k_id);
 }
 
-#endif
\ No newline at end of file
+//////////////
+
+extern void __litmus_schedule_work(
+        struct work_struct* w,
+        unsigned int k_id);
+
+static inline void litmus_schedule_work(
+        struct work_struct* w,
+        unsigned int k_id)
+{
+        __litmus_schedule_work(w, k_id);
+}
+
+#endif
+
+
+
+
+
+
+
+
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);