7 files changed, 180 insertions, 77 deletions

diff --git a/include/litmus/litmus_softirq.h b/include/litmus/litmus_softirq.h
index 6d1f85c2e093..712c8119ae15 100644
--- a/include/litmus/litmus_softirq.h
+++ b/include/litmus/litmus_softirq.h
@@ -1,3 +1,6 @@
+#ifndef __LITMUS_SOFTIRQ_H
+#define __LITMUS_SOFTIRQ_H
+
 #include <linux/interrupt.h>
 
 /*
@@ -57,8 +60,12 @@ void kill_klitirqd(void);
    to handle tasklets. 0, otherwise.*/
 int klitirqd_is_ready(void);
 
+/* Returns 1 if no NR_LITMUS_SOFTIRQD klitirqs are ready
+ to handle tasklets. 0, otherwise.*/
+int klitirqd_is_dead(void);
+
 
-void __litmus_tasklet_schedule(
+extern void __litmus_tasklet_schedule(
         struct tasklet_struct *t,
         unsigned int k_id);
 
@@ -96,4 +103,6 @@ static inline void litmus_tasklet_hi_schedule_first(
 {
         if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
                 __litmus_tasklet_hi_schedule_first(t, k_id);
-}
\ No newline at end of file
+}
+
+#endif
\ No newline at end of file
diff --git a/include/litmus/nvidia_info.h b/include/litmus/nvidia_info.h
new file mode 100644
index 000000000000..f28d8f0a7f40
--- /dev/null
+++ b/include/litmus/nvidia_info.h
@@ -0,0 +1,13 @@
+#ifndef __LITMUS_NVIDIA_H
+#define __LITMUS_NVIDIA_H
+
+#include <litmus/litmus_softirq.h>
+
+int init_nvidia_info(void);
+
+int is_nvidia_func(void *func);
+
+int is_nvidia_in_callstack(void);
+
+
+#endif
diff --git a/litmus/Kconfig b/litmus/Kconfig
index 58137f3e374e..42c5ff67c8c1 100644
--- a/litmus/Kconfig
+++ b/litmus/Kconfig
@@ -205,6 +205,15 @@ config NR_LITMUS_SOFTIRQD
            help
              Should be <= to the number of CPUs in your system.
 
+config LITMUS_NVIDIA
+          bool "Litmus handling of NVIDIA interrupts."
+          depends on LITMUS_SOFTIRQD
+          default n
+          help
+            Direct tasklets from NVIDIA devices to Litmus's klitirqd.
+
+                If unsure, say No.
+
 endmenu
 
 endmenu
diff --git a/litmus/Makefile b/litmus/Makefile
index 0d0214c54896..3d3139609878 100644
--- a/litmus/Makefile
+++ b/litmus/Makefile
@@ -28,3 +28,4 @@ obj-$(CONFIG_SCHED_DEBUG_TRACE) += sched_trace.o
 obj-$(CONFIG_SCHED_OVERHEAD_TRACE) += trace.o
 
 obj-$(CONFIG_LITMUS_SOFTIRQD) += litmus_softirq.o
+obj-$(CONFIG_LITMUS_NVIDIA) += nvidia_info.o
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 */
         
diff --git a/litmus/nvidia_info.c b/litmus/nvidia_info.c
new file mode 100644
index 000000000000..05f8356a8117
--- /dev/null
+++ b/litmus/nvidia_info.c
@@ -0,0 +1,55 @@
+
+#include <linux/module.h>
+
+#include <litmus/sched_trace.h>
+#include <litmus/nvidia_info.h>
+
+static struct module* nvidia_mod = NULL;
+
+int init_nvidia_info(void)
+{
+        mutex_lock(&module_mutex);
+        nvidia_mod = find_module("nvidia");
+        mutex_unlock(&module_mutex);
+        
+        if(nvidia_mod != NULL)
+        {
+                TRACE("%s : Found NVIDIA module. Core Code: %x to %x\n", __FUNCTION__,
+                          (void*)(nvidia_mod->module_core),
+                          (void*)(nvidia_mod->module_core) + nvidia_mod->core_size);
+                return(0);
+        }
+        else
+        {
+                TRACE("%s : Could not find NVIDIA module!  Loaded?\n", __FUNCTION__);
+                return(-1);
+        }
+}
+
+
+/* works with pointers to static data inside the module too. */
+int is_nvidia_func(void *func_addr)
+{
+        int ret = 0;
+        if(nvidia_mod)
+        {
+                ret = within_module_core((long unsigned int)func_addr, nvidia_mod);
+                
+                TRACE("%s : %x is in NVIDIA module : %d\n",
+                          __FUNCTION__, func_addr, ret);
+        }
+        else
+        {
+                TRACE("%s : No NVIDIA module info loaded!\n", __FUNCTION__);
+        }
+
+        return(ret);
+}
+
+int is_nvidia_in_callstack(void)
+{
+        /* TODO -- Walk back through the callstack, running each called
+           function through is_nvidia_func() */
+        TRACE("%s : NOT IMPLEMENTED!\n", __FUNCTION__);
+        return(1);
+}
diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index 586b7c3f7de1..99813698ee17 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -29,6 +29,10 @@
 #include <litmus/litmus_softirq.h>
 #endif
 
+#ifdef CONFIG_LITMUS_NVIDIA
+#include <litmus/nvidia_info.h>
+#endif
+
 /* Overview of GSN-EDF operations.
  *
  * For a detailed explanation of GSN-EDF have a look at the FMLP paper. This
@@ -967,6 +971,10 @@ static long gsnedf_activate_plugin(void)
     spawn_klitirqd();
 #endif
 
+#ifdef CONFIG_LITMUS_NVIDIA
+        init_nvidia_info();
+#endif
+        
         return 0;
 }