1 files changed, 163 insertions, 4 deletions

diff --git a/litmus/sched_plugin.c b/litmus/sched_plugin.c
index 00a1900d6457..76ff892122aa 100644
--- a/litmus/sched_plugin.c
+++ b/litmus/sched_plugin.c
@@ -13,6 +13,10 @@
 #include <litmus/preempt.h>
 #include <litmus/jobs.h>
 
+#ifdef CONFIG_LITMUS_NVIDIA
+#include <litmus/nvidia_info.h>
+#endif
+
 /*
  * Generic function to trigger preemption on either local or remote cpu
  * from scheduler plugins. The key feature is that this function is
@@ -27,11 +31,19 @@ void preempt_if_preemptable(struct task_struct* t, int cpu)
 
         int reschedule = 0;
 
-        if (!t)
+        TRACE_CUR("preempt_if_preemptable: %s/%d\n",
+                                (t) ? t->comm : "(nil)",
+                                (t) ? t->pid : 0);
+
+        if (!t) {
+                TRACE_CUR("unconditionally reshcedule\n");
                 /* move non-real-time task out of the way */
                 reschedule = 1;
+        }
         else {
                 if (smp_processor_id() == cpu) {
+                        TRACE_CUR("preempt local cpu.\n");
+
                         /* local CPU case */
                         /* check if we need to poke userspace */
                         if (is_user_np(t))
@@ -43,14 +55,22 @@ void preempt_if_preemptable(struct task_struct* t, int cpu)
                                  * currently-executing task */
                                 reschedule = 1;
                 } else {
+                        int is_knp = is_kernel_np(t);
+                        int reqexit = request_exit_np_atomic(t);
+                        TRACE_CUR("preempt remote cpu: isknp = %d  reqexit = %d\n", is_knp, reqexit);
+
                         /* Remote CPU case.  Only notify if it's not a kernel
                          * NP section and if we didn't set the userspace
                          * flag. */
-                        reschedule = !(is_kernel_np(t) || request_exit_np_atomic(t));
+                        //reschedule = !(is_kernel_np(t) || request_exit_np_atomic(t));
+                        reschedule = !(is_knp || reqexit);
                 }
         }
-        if (likely(reschedule))
+
+        if (likely(reschedule)) {
+                TRACE_CUR("calling litmus_reschedule()\n");
                 litmus_reschedule(cpu);
+        }
 }
 
 
@@ -102,6 +122,9 @@ static long litmus_dummy_complete_job(void)
 
 static long litmus_dummy_activate_plugin(void)
 {
+#ifdef CONFIG_LITMUS_NVIDIA
+        shutdown_nvidia_info();
+#endif
         return 0;
 }
 
@@ -110,14 +133,100 @@ static long litmus_dummy_deactivate_plugin(void)
         return 0;
 }
 
-#ifdef CONFIG_LITMUS_LOCKING
+static int litmus_dummy_compare(struct task_struct* a, struct task_struct* b)
+{
+        TRACE_CUR("WARNING: Dummy compare function called!\n");
+        return 0;
+}
 
+#ifdef CONFIG_LITMUS_LOCKING
 static long litmus_dummy_allocate_lock(struct litmus_lock **lock, int type,
                                        void* __user config)
 {
         return -ENXIO;
 }
 
+static void litmus_dummy_increase_prio(struct task_struct* t, struct task_struct* prio_inh)
+{
+}
+
+static void litmus_dummy_decrease_prio(struct task_struct* t, struct task_struct* prio_inh)
+{
+}
+
+static int litmus_dummy___increase_prio(struct task_struct* t, struct task_struct* prio_inh)
+{
+        TRACE_CUR("WARNING: Dummy litmus_dummy___increase_prio called!\n");
+        return 0;
+}
+
+static int litmus_dummy___decrease_prio(struct task_struct* t, struct task_struct* prio_inh)
+{
+        TRACE_CUR("WARNING: Dummy litmus_dummy___decrease_prio called!\n");
+        return 0;
+}
+#endif
+
+
+#ifdef CONFIG_LITMUS_PAI_SOFTIRQD
+static int litmus_dummy_enqueue_pai_tasklet(struct tasklet_struct* t)
+{
+        TRACE("%s: PAI Tasklet unsupported in this plugin!!!!!!\n", __FUNCTION__);
+        return(0); // failure.
+}
+
+static void litmus_dummy_change_prio_pai_tasklet(struct task_struct *old_prio,
+                                                                                                 struct task_struct *new_prio)
+{
+        TRACE("%s: PAI Tasklet unsupported in this plugin!!!!!!\n", __FUNCTION__);
+}
+
+static void litmus_dummy_run_tasklets(struct task_struct* t)
+{
+        //TRACE("%s: PAI Tasklet unsupported in this plugin!!!!!!\n", __FUNCTION__);
+}
+#endif
+
+#ifdef CONFIG_LITMUS_NESTED_LOCKING
+static void litmus_dummy_nested_increase_prio(struct task_struct* t, struct task_struct* prio_inh,
+                                                                                        raw_spinlock_t *to_unlock, unsigned long irqflags)
+{
+}
+
+static void litmus_dummy_nested_decrease_prio(struct task_struct* t, struct task_struct* prio_inh,
+                                                                                        raw_spinlock_t *to_unlock, unsigned long irqflags)
+{
+}
+
+static int litmus_dummy___compare(struct task_struct* a, comparison_mode_t a_mod,
+                                                                  struct task_struct* b, comparison_mode_t b_mode)
+{
+        TRACE_CUR("WARNING: Dummy compare function called!\n");
+        return 0;
+}
+#endif
+
+#ifdef CONFIG_LITMUS_DGL_SUPPORT
+static raw_spinlock_t* litmus_dummy_get_dgl_spinlock(struct task_struct *t)
+{
+        return NULL;
+}
+#endif
+
+#ifdef CONFIG_LITMUS_AFFINITY_LOCKING
+static long litmus_dummy_allocate_aff_obs(struct affinity_observer **aff_obs,
+                                                                           int type,
+                                                                           void* __user config)
+{
+        return -ENXIO;
+}
+#endif
+
+#if defined(CONFIG_LITMUS_NVIDIA) && defined(CONFIG_LITMUS_SOFTIRQD)
+static int litmus_dummy_map_gpu_to_cpu(int gpu)
+{
+        return 0;
+}
 #endif
 
 
@@ -136,9 +245,34 @@ struct sched_plugin linux_sched_plugin = {
         .finish_switch = litmus_dummy_finish_switch,
         .activate_plugin = litmus_dummy_activate_plugin,
         .deactivate_plugin = litmus_dummy_deactivate_plugin,
+        .compare = litmus_dummy_compare,
 #ifdef CONFIG_LITMUS_LOCKING
         .allocate_lock = litmus_dummy_allocate_lock,
+        .increase_prio = litmus_dummy_increase_prio,
+        .decrease_prio = litmus_dummy_decrease_prio,
+        .__increase_prio = litmus_dummy___increase_prio,
+        .__decrease_prio = litmus_dummy___decrease_prio,
+#endif
+#ifdef CONFIG_LITMUS_NESTED_LOCKING
+        .nested_increase_prio = litmus_dummy_nested_increase_prio,
+        .nested_decrease_prio = litmus_dummy_nested_decrease_prio,
+        .__compare = litmus_dummy___compare,
+#endif
+#ifdef CONFIG_LITMUS_PAI_SOFTIRQD
+        .enqueue_pai_tasklet = litmus_dummy_enqueue_pai_tasklet,
+        .change_prio_pai_tasklet = litmus_dummy_change_prio_pai_tasklet,
+        .run_tasklets = litmus_dummy_run_tasklets,
+#endif
+#ifdef CONFIG_LITMUS_DGL_SUPPORT
+        .get_dgl_spinlock = litmus_dummy_get_dgl_spinlock,
 #endif
+#ifdef CONFIG_LITMUS_AFFINITY_LOCKING
+        .allocate_aff_obs = litmus_dummy_allocate_aff_obs,
+#endif
+#if defined(CONFIG_LITMUS_NVIDIA) && defined(CONFIG_LITMUS_SOFTIRQD)
+        .map_gpu_to_cpu = litmus_dummy_map_gpu_to_cpu,
+#endif
+
         .admit_task = litmus_dummy_admit_task
 };
 
@@ -174,9 +308,34 @@ int register_sched_plugin(struct sched_plugin* plugin)
         CHECK(complete_job);
         CHECK(activate_plugin);
         CHECK(deactivate_plugin);
+        CHECK(compare);
 #ifdef CONFIG_LITMUS_LOCKING
         CHECK(allocate_lock);
+        CHECK(increase_prio);
+        CHECK(decrease_prio);
+        CHECK(__increase_prio);
+        CHECK(__decrease_prio);
+#endif
+#ifdef CONFIG_LITMUS_NESTED_LOCKING
+        CHECK(nested_increase_prio);
+        CHECK(nested_decrease_prio);
+        CHECK(__compare);
+#endif
+#ifdef CONFIG_LITMUS_PAI_SOFTIRQD
+        CHECK(enqueue_pai_tasklet);
+        CHECK(change_prio_pai_tasklet);
+        CHECK(run_tasklets);
 #endif
+#ifdef CONFIG_LITMUS_DGL_SUPPORT
+        CHECK(get_dgl_spinlock);
+#endif
+#ifdef CONFIG_LITMUS_AFFINITY_LOCKING
+        CHECK(allocate_aff_obs);
+#endif
+#if defined(CONFIG_LITMUS_NVIDIA) && defined(CONFIG_LITMUS_SOFTIRQD)
+        CHECK(map_gpu_to_cpu);
+#endif
+
         CHECK(admit_task);
 
         if (!plugin->release_at)