1 files changed, 68 insertions, 4 deletions

diff --git a/litmus/litmus.c b/litmus/litmus.c
index 301390148d02..ea3ffade6490 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -21,6 +21,10 @@
 #include <litmus/affinity.h>
 #endif
 
+#ifdef CONFIG_LITMUS_NVIDIA
+#include <litmus/nvidia_info.h>
+#endif
+
 /* Number of RT tasks that exist in the system */
 atomic_t rt_task_count          = ATOMIC_INIT(0);
 static DEFINE_RAW_SPINLOCK(task_transition_lock);
@@ -51,6 +55,28 @@ void bheap_node_free(struct bheap_node* hn)
 struct release_heap* release_heap_alloc(int gfp_flags);
 void release_heap_free(struct release_heap* rh);
 
+#ifdef CONFIG_LITMUS_NVIDIA
+/*
+ * sys_register_nv_device
+ * @nv_device_id: The Nvidia device id that the task want to register
+ * @reg_action: set to '1' to register the specified device. zero otherwise.
+ * Syscall for register task's designated nvidia device into NV_DEVICE_REG array
+ * Returns EFAULT  if nv_device_id is out of range.
+ *         0       if success
+ */
+asmlinkage long sys_register_nv_device(int nv_device_id, int reg_action)
+{
+        /* register the device to caller (aka 'current') */
+        return(reg_nv_device(nv_device_id, reg_action));
+}
+#else
+asmlinkage long sys_register_nv_device(int nv_device_id, int reg_action)
+{
+        return(-EINVAL);
+}
+#endif
+
+
 /*
  * sys_set_task_rt_param
  * @pid: Pid of the task which scheduling parameters must be changed
@@ -135,6 +161,22 @@ asmlinkage long sys_set_rt_task_param(pid_t pid, struct rt_task __user * param)
 
         target->rt_param.task_params = tp;
 
+#ifdef CONFIG_LITMUS_SOFTIRQD
+        /* proxy thread off by default */
+        target->rt_param.is_proxy_thread = 0;
+    target->rt_param.cur_klitirqd = NULL;
+        //init_MUTEX(&target->rt_param.klitirqd_sem);
+        mutex_init(&target->rt_param.klitirqd_sem);
+        //init_completion(&target->rt_param.klitirqd_sem);
+        //target->rt_param.klitirqd_sem_stat = NOT_HELD;
+        atomic_set(&target->rt_param.klitirqd_sem_stat, NOT_HELD);
+#endif
+
+#ifdef CONFIG_LITMUS_NVIDIA
+        atomic_set(&target->rt_param.nv_int_count, 0);
+#endif
+
+
         retval = 0;
       out_unlock:
         read_unlock_irq(&tasklist_lock);
@@ -269,6 +311,7 @@ asmlinkage long sys_query_job_no(unsigned int __user *job)
         return retval;
 }
 
+
 /* sys_null_call() is only used for determining raw system call
  * overheads (kernel entry, kernel exit). It has no useful side effects.
  * If ts is non-NULL, then the current Feather-Trace time is recorded.
@@ -282,7 +325,7 @@ asmlinkage long sys_null_call(cycles_t __user *ts)
                 now = get_cycles();
                 ret = put_user(now, ts);
         }
-
+        
         return ret;
 }
 
@@ -303,6 +346,20 @@ static void reinit_litmus_state(struct task_struct* p, int restore)
          * at this point in time.
          */
         WARN_ON(p->rt_param.inh_task);
+   
+#ifdef CONFIG_LITMUS_SOFTIRQD
+        /* We probably should not have any tasklets executing for
+     * us at this time.
+         */    
+    WARN_ON(p->rt_param.cur_klitirqd);
+        WARN_ON(atomic_read(&p->rt_param.klitirqd_sem_stat) == HELD);
+
+        if(p->rt_param.cur_klitirqd)
+                flush_pending(p->rt_param.cur_klitirqd, p);
+
+        if(atomic_read(&p->rt_param.klitirqd_sem_stat) == HELD)
+                up_and_set_stat(p, NOT_HELD, &p->rt_param.klitirqd_sem);
+#endif
 
         /* Cleanup everything else. */
         memset(&p->rt_param, 0, sizeof(p->rt_param));
@@ -403,7 +460,7 @@ static void synch_on_plugin_switch(void* info)
  */
 int switch_sched_plugin(struct sched_plugin* plugin)
 {
-        unsigned long flags;
+        //unsigned long flags;
         int ret = 0;
 
         BUG_ON(!plugin);
@@ -417,8 +474,15 @@ int switch_sched_plugin(struct sched_plugin* plugin)
         while (atomic_read(&cannot_use_plugin) < num_online_cpus())
                 cpu_relax();
 
+#ifdef CONFIG_LITMUS_SOFTIRQD
+        if(!klitirqd_is_dead())
+        {
+                kill_klitirqd();
+        }
+#endif
+
         /* stop task transitions */
-        raw_spin_lock_irqsave(&task_transition_lock, flags);
+        //raw_spin_lock_irqsave(&task_transition_lock, flags);
 
         /* don't switch if there are active real-time tasks */
         if (atomic_read(&rt_task_count) == 0) {
@@ -436,7 +500,7 @@ int switch_sched_plugin(struct sched_plugin* plugin)
         } else
                 ret = -EBUSY;
 out:
-        raw_spin_unlock_irqrestore(&task_transition_lock, flags);
+        //raw_spin_unlock_irqrestore(&task_transition_lock, flags);
         atomic_set(&cannot_use_plugin, 0);
         return ret;
 }