5 files changed, 428 insertions, 0 deletions

diff --git a/include/litmus/litmus_softirq.h b/include/litmus/litmus_softirq.h
new file mode 100644
index 000000000000..37804fcfe8a3
--- /dev/null
+++ b/include/litmus/litmus_softirq.h
@@ -0,0 +1,11 @@
+
+#include <linux/interrupt.h>
+
+#define NR_LITMUS_SOFTIRQD CONFIG_NR_LITMUS_SOFTIRQD
+
+void trigger_litirqs(struct task_struct*);
+
+void spawn_klitirqd(void);
+
+void kill_klitirqd(void);
+
diff --git a/litmus/Kconfig b/litmus/Kconfig
index ad8dc8308cf0..a354e3dce19f 100644
--- a/litmus/Kconfig
+++ b/litmus/Kconfig
@@ -182,4 +182,29 @@ config SCHED_DEBUG_TRACE_CALLER
 
 endmenu
 
+menu "Interrupt Handling"
+
+config LITMUS_SOFTIRQD
+       bool "Spawn ksoftirqlitmusd interrupt handling threads."
+           depends on LITMUS_LOCKING
+           default n
+           help
+             Create ksoftirqlitmusd interrupt handling threads.  Work must be
+                 specifically dispatched to these workers.  (Softirqs for
+                 Litmus tasks are not magically redirected to ksoftirqlitmusd.)
+
+                 G-EDF ONLY for now!
+
+             If unsure, say No.
+
+config NR_LITMUS_SOFTIRQD
+           int "Number of klitirqd."
+           depends on LITMUS_SOFTIRQD
+           range 1 4096
+           default "1"
+           help
+             Should be <= to the number of CPUs in your system.
+
+endmenu
+
 endmenu
diff --git a/litmus/Makefile b/litmus/Makefile
index ad9936e07b83..0d0214c54896 100644
--- a/litmus/Makefile
+++ b/litmus/Makefile
@@ -26,3 +26,5 @@ obj-$(CONFIG_FEATHER_TRACE) += ft_event.o ftdev.o
 obj-$(CONFIG_SCHED_TASK_TRACE) += sched_task_trace.o
 obj-$(CONFIG_SCHED_DEBUG_TRACE) += sched_trace.o
 obj-$(CONFIG_SCHED_OVERHEAD_TRACE) += trace.o
+
+obj-$(CONFIG_LITMUS_SOFTIRQD) += litmus_softirq.o
diff --git a/litmus/litmus_softirq.c b/litmus/litmus_softirq.c
new file mode 100644
index 000000000000..4517a94823e7
--- /dev/null
+++ b/litmus/litmus_softirq.c
@@ -0,0 +1,389 @@
+/* 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>
+
+#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>
+#include <litmus/litmus_softirq.h>
+
+/* only support tasklet processing for now. */
+struct tasklet_head
+{
+        struct tasklet_struct *head;
+        struct tasklet_struct **tail;
+};
+
+struct tasklet_owner
+{
+    struct tasklet_owner* next;
+    struct task_struct* job;
+};
+
+/* used to create a parallel list to lit_tasklet_*_vec to
+   associate a litmus priority with the tasklet */
+struct tasklet_owner_head
+{
+    struct tasklet_owner *head;
+    struct tasklet_owner **tail;
+};
+
+static struct task_struct* klitirqd[NR_LITMUS_SOFTIRQD];
+
+/* one list for each klitirqd */
+static raw_spinlock_t litirq_locks[NR_LITMUS_SOFTIRQD];
+
+static struct tasklet_head lit_tasklet_vec[NR_LITMUS_SOFTIRQD];
+static struct tasklet_owner_head lit_tasklet_owner_vec[NR_LITMUS_SOFTIRQD];
+
+static struct tasklet_head lit_tasklet_hi_vec[NR_LITMUS_SOFTIRQD];
+static struct tasklet_owner_head lit_tasklet_hi_owner_vec[NR_LITMUS_SOFTIRQD];
+
+
+inline int klitirqd_id(struct task_struct* tsk)
+{
+    int i;
+    for(i = 0; i < NR_LITMUS_SOFTIRQD; ++i)
+    {
+        if(klitirqd[i] == tsk)
+        {
+            return i;
+        }
+    }
+    
+    BUG();
+    
+    return -1;
+}
+
+enum pending_flags
+{
+    LIT_TASKLET_LOW = 0x1,
+    LIT_TASKLET_HI  = 0x2
+};
+
+
+inline static u32 litirq_pending_hi_irqoff(struct task_struct* which)
+{
+    u32 pending = 0;
+    
+    int offset = klitirqd_id(which);
+    
+    if(lit_tasklet_hi_vec[offset].tail != &lit_tasklet_hi_vec[offset].head)
+    {
+        pending = LIT_TASKLET_HI;
+    }
+    
+    return pending;
+};
+
+inline static u32 litirq_pending_low_irqoff(struct task_struct* which)
+{
+    u32 pending = 0;
+    
+    int offset = klitirqd_id(which);
+    
+    if(lit_tasklet_vec[offset].tail != &lit_tasklet_vec[offset].head)
+    {
+        pending = LIT_TASKLET_LOW;
+    }
+    
+    return pending;
+};
+
+
+static u32 litirq_pending_irqoff(struct task_struct* which)
+{
+    u32 pending = 0;
+
+    pending |= litirq_pending_hi_irqoff(which);
+    pending |= litirq_pending_low_irqoff(which);
+    
+    return pending;
+};
+
+
+static u32 litirq_pending(struct task_struct* which)
+{
+    unsigned long flags;
+    u32 pending;
+    
+    int offset = klitirqd_id(which);
+    
+    raw_spin_lock_irqsave(&litirq_locks[offset], flags);
+    pending = litirq_pending_irqoff(which);
+    raw_spin_unlock_irqrestore(&litirq_locks[offset], flags);
+    
+    return pending;
+};
+
+
+static int needs_prio_change(struct task_struct* tsk,
+                             struct tasklet_head* tasklet_vec)
+{
+    unsigned long flags;
+    int ret = 0;
+    
+    int offset = klitirqd_id(tsk);
+    raw_spin_lock_irqsave(&litirq_locks[offset], flags);
+    
+    if((tasklet_vec == lit_tasklet_hi_vec) && litirq_pending_hi_irqoff(tsk))
+    {
+        if(lit_tasklet_hi_owner_vec[offset].head->job != tsk_rt(current)->inh_task)
+        {
+            ret = 1;
+        }
+    }
+    else if((tasklet_vec == lit_tasklet_vec) && litirq_pending_irqoff(tsk))
+    {
+        if(lit_tasklet_owner_vec[offset].head->job != tsk_rt(current)->inh_task)
+        {
+            ret = 1;
+        }        
+    }
+    
+    raw_spin_unlock_irqrestore(&litirq_locks[offset], flags);
+    
+    return ret;
+}
+
+
+static void reeval_prio(struct task_struct* tsk)
+{
+    unsigned long flags;
+    u32 pending = 0;
+    struct task_struct* new_prio = tsk_rt(tsk)->inh_task;
+    
+    int offset = klitirqd_id(tsk);
+    
+    raw_spin_lock_irqsave(&litirq_locks[offset], flags);
+    
+    if(pending |= litirq_pending_irqoff(tsk))
+    {
+        if(lit_tasklet_owner_vec[offset].head->job != tsk_rt(current)->inh_task)
+        {
+            new_prio = lit_tasklet_owner_vec[offset].head->job;
+        }        
+    }    
+    
+    if(pending |= litirq_pending_hi_irqoff(tsk))
+    {
+        if(lit_tasklet_hi_owner_vec[offset].head->job != tsk_rt(current)->inh_task)
+        {
+            new_prio = lit_tasklet_hi_owner_vec[offset].head->job;
+        }
+    }
+    
+    if(!pending)
+    {
+        new_prio = NULL;
+    }
+    
+    if(new_prio != tsk_rt(tsk)->inh_task)
+    {
+        /* Change priority!! */
+    }
+    
+    raw_spin_unlock_irqrestore(&litirq_locks[offset], flags);
+}
+
+
+static void wakeup_litirqd(struct task_struct* which)
+{
+        /* Interrupts are disabled: no need to stop preemption */
+    
+        if (which && which->state != TASK_RUNNING)
+    {
+        reeval_prio(which); /* configure the proper priority */
+                wake_up_process(which);
+    }
+}
+
+
+static void do_lit_tasklet(struct tasklet_head* tasklet_vec,
+                           struct tasklet_owner_head* owner_vec)
+{
+    unsigned long flags;
+        struct tasklet_struct *list;
+    struct tasklet_owner *owner;
+    int id = klitirqd_id(current);
+    
+    raw_spin_lock_irqsave(&litirq_locks[id], flags);
+    
+    /* copy out the tasklets for our private use. */
+    list = tasklet_vec[id].head;
+    tasklet_vec[id].head = NULL;
+    tasklet_vec[id].tail = &tasklet_vec[id].head;
+    
+    owner = owner_vec[id].head;
+    owner_vec[id].head = NULL;
+    owner_vec[id].tail = &owner_vec[id].head;
+    
+    raw_spin_unlock_irqrestore(&litirq_locks[id], flags);
+    
+    while(list)
+    {
+        struct tasklet_struct *t = list;
+        struct tasklet_owner *t_owner = owner;
+        
+        /* advance, lest we forget */
+                list = list->next;
+        owner = owner->next;
+        
+        /* execute tasklet if it has my priority and is free */
+                if ((t_owner->job == tsk_rt(current)->inh_task) && tasklet_trylock(t)) {
+                        if (!atomic_read(&t->count)) {
+                                if (!test_and_clear_bit(TASKLET_STATE_SCHED, &t->state))
+                                        BUG();
+                                t->func(t->data);
+                                tasklet_unlock(t);
+                                continue;  /* process more tasklets */
+                        }
+                        tasklet_unlock(t);
+                }
+        
+        /* couldn't process tasklet.  put it back at the end of the main queue. */
+        t->next = NULL;
+        t_owner->next = NULL;
+        
+                raw_spin_lock_irqsave(&litirq_locks[id], flags);
+        
+        *(tasklet_vec[id].tail) = t;
+        tasklet_vec[id].tail = &(t->next);
+        
+        *(owner_vec[id].tail) = t_owner;
+        owner_vec[id].tail = &(t_owner->next);
+        
+                raw_spin_unlock_irqrestore(&litirq_locks[id], flags);
+    }
+}
+
+static void do_litirq(void)
+{
+    u32 pending;
+    int resched = 0;
+    
+    if (in_interrupt() || !is_realtime(current))
+    {
+        return;
+    }
+    
+    /* since we only handle tasklets, no need for RCU triggers? */
+    
+    pending = litirq_pending(current);
+    if(pending)
+    {
+        /* extract the work to do and do it! */
+        if(pending & LIT_TASKLET_HI)
+        {
+            do_lit_tasklet(lit_tasklet_hi_vec, lit_tasklet_hi_owner_vec);
+            resched = needs_prio_change(current, lit_tasklet_hi_vec);
+        }
+        
+        if(!resched && (pending & LIT_TASKLET_LOW))
+        {
+            do_lit_tasklet(lit_tasklet_vec, lit_tasklet_owner_vec);
+            resched = needs_prio_change(current, lit_tasklet_vec);
+        }
+    }
+}
+
+
+/* TODO: WHAT'S THE DEAL WITH BOTTOM HALVES? */
+
+/* main loop for klitsoftirqd */
+static int run_klitirqd(void* dummy)
+{    
+    /* TODO: Set as best-effort Litmus thread. */
+    
+        set_current_state(TASK_INTERRUPTIBLE);
+    
+        while (!kthread_should_stop()) {
+                preempt_disable();
+                if (!litirq_pending(current)) {
+            /* sleep for work */
+                        preempt_enable_no_resched();
+            schedule();
+                        preempt_disable();
+                }
+        
+                __set_current_state(TASK_RUNNING);
+        
+                while (litirq_pending(current)) {        
+            
+                        do_litirq();
+            
+            reeval_prio(current); /* check if we need to change priority here */
+            
+                        preempt_enable_no_resched();
+                        cond_resched();
+            
+                        preempt_disable();
+                }
+                preempt_enable();
+                set_current_state(TASK_INTERRUPTIBLE);
+        }
+        __set_current_state(TASK_RUNNING);
+        return 0;
+}
+
+
+void trigger_litirqs(struct task_struct* which)
+{
+        while (litirq_pending(which))
+    {
+        wakeup_litirqd(which);
+        }
+}
+
+
+void spawn_klitirqd(void)
+{
+    int i;
+    for(i = 0; i < NR_LITMUS_SOFTIRQD; ++i)
+    {
+        klitirqd[i] = kthread_create(run_klitirqd, NULL, "klitirqd_th%d", i);
+    }
+    
+    for(i = 0; i < NR_LITMUS_SOFTIRQD; ++i)
+    {
+        wake_up_process(klitirqd[i]);
+    }    
+}
+
+void kill_klitirqd(void)
+{
+    int i;
+    
+    /* TODO: Put pending tasklets SOMEWHERE-- back to the OS? */
+    for(i = 0; i < NR_LITMUS_SOFTIRQD; ++i)
+    {
+        kthread_stop(klitirqd[i]);
+    }
+}
+
+
+
+
+
+
+
diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index c5c9600c33d8..d5d834cc411b 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -946,6 +946,7 @@ static long gsnedf_activate_plugin(void)
                 }
 #endif
         }
+
         return 0;
 }