1 files changed, 68 insertions, 34 deletions

diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index d5d834cc411b..586b7c3f7de1 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -25,6 +25,10 @@
 
 #include <linux/module.h>
 
+#ifdef CONFIG_LITMUS_SOFTIRQD
+#include <litmus/litmus_softirq.h>
+#endif
+
 /* Overview of GSN-EDF operations.
  *
  * For a detailed explanation of GSN-EDF have a look at the FMLP paper. This
@@ -277,7 +281,7 @@ static void check_for_preemptions(void)
 static noinline void gsnedf_job_arrival(struct task_struct* task)
 {
         BUG_ON(!task);
-
+    
         requeue(task);
         check_for_preemptions();
 }
@@ -298,7 +302,7 @@ static void gsnedf_release_jobs(rt_domain_t* rt, struct bheap* tasks)
 static noinline void job_completion(struct task_struct *t, int forced)
 {
         BUG_ON(!t);
-
+        
         sched_trace_task_completion(t, forced);
 
         TRACE_TASK(t, "job_completion().\n");
@@ -534,8 +538,8 @@ static void gsnedf_task_new(struct task_struct * t, int on_rq, int running)
 static void gsnedf_task_wake_up(struct task_struct *task)
 {
         unsigned long flags;
-        lt_t now;
-
+        lt_t now;       
+        
         TRACE_TASK(task, "wake_up at %llu\n", litmus_clock());
 
         raw_spin_lock_irqsave(&gsnedf_lock, flags);
@@ -606,43 +610,44 @@ static long gsnedf_admit_task(struct task_struct* tsk)
 
 #include <litmus/fdso.h>
 
-/* called with IRQs off */
-static void set_priority_inheritance(struct task_struct* t, struct task_struct* prio_inh)
+inline static void __set_priority_inheritance(struct task_struct* t, struct task_struct* prio_inh)
 {
         int linked_on;
         int check_preempt = 0;
-
-        raw_spin_lock(&gsnedf_lock);
-
-        TRACE_TASK(t, "inherits priority from %s/%d\n", prio_inh->comm, prio_inh->pid);
+    
+    if(prio_inh != NULL)
+        TRACE_TASK(t, "inherits priority from %s/%d\n", prio_inh->comm, prio_inh->pid);
+    else
+        TRACE_TASK(t, "inherits priority from NULL\n");
+    
         tsk_rt(t)->inh_task = prio_inh;
-
+    
         linked_on  = tsk_rt(t)->linked_on;
-
+    
         /* If it is scheduled, then we need to reorder the CPU heap. */
         if (linked_on != NO_CPU) {
                 TRACE_TASK(t, "%s: linked  on %d\n",
-                           __FUNCTION__, linked_on);
+                   __FUNCTION__, linked_on);
                 /* Holder is scheduled; need to re-order CPUs.
                  * We can't use heap_decrease() here since
                  * the cpu_heap is ordered in reverse direction, so
                  * it is actually an increase. */
                 bheap_delete(cpu_lower_prio, &gsnedf_cpu_heap,
-                            gsnedf_cpus[linked_on]->hn);
+                     gsnedf_cpus[linked_on]->hn);
                 bheap_insert(cpu_lower_prio, &gsnedf_cpu_heap,
-                            gsnedf_cpus[linked_on]->hn);
+                     gsnedf_cpus[linked_on]->hn);
         } else {
                 /* holder may be queued: first stop queue changes */
                 raw_spin_lock(&gsnedf.release_lock);
                 if (is_queued(t)) {
                         TRACE_TASK(t, "%s: is queued\n",
-                                   __FUNCTION__);
+                       __FUNCTION__);
                         /* We need to update the position of holder in some
                          * heap. Note that this could be a release heap if we
                          * budget enforcement is used and this job overran. */
                         check_preempt =
-                                !bheap_decrease(edf_ready_order,
-                                               tsk_rt(t)->heap_node);
+            !bheap_decrease(edf_ready_order,
+                            tsk_rt(t)->heap_node);
                 } else {
                         /* Nothing to do: if it is not queued and not linked
                          * then it is either sleeping or currently being moved
@@ -650,10 +655,10 @@ static void set_priority_inheritance(struct task_struct* t, struct task_struct*
                          * will use the correct priority when enqueuing the
                          * task. */
                         TRACE_TASK(t, "%s: is NOT queued => Done.\n",
-                                   __FUNCTION__);
+                       __FUNCTION__);
                 }
                 raw_spin_unlock(&gsnedf.release_lock);
-
+        
                 /* If holder was enqueued in a release heap, then the following
                  * preemption check is pointless, but we can't easily detect
                  * that case. If you want to fix this, then consider that
@@ -665,30 +670,42 @@ static void set_priority_inheritance(struct task_struct* t, struct task_struct*
                          * sure preemption checks get the right task, not the
                          * potentially stale cache. */
                         bheap_uncache_min(edf_ready_order,
-                                         &gsnedf.ready_queue);
+                              &gsnedf.ready_queue);
                         check_for_preemptions();
                 }
         }
-
-        raw_spin_unlock(&gsnedf_lock);
 }
 
 /* called with IRQs off */
-static void clear_priority_inheritance(struct task_struct* t)
+static void set_priority_inheritance(struct task_struct* t, struct task_struct* prio_inh)
 {
         raw_spin_lock(&gsnedf_lock);
 
-        /* A job only stops inheriting a priority when it releases a
-         * resource. Thus we can make the following assumption.*/
-        BUG_ON(tsk_rt(t)->scheduled_on == NO_CPU);
+        __set_priority_inheritance(t, prio_inh);
 
-        TRACE_TASK(t, "priority restored\n");
-        tsk_rt(t)->inh_task = NULL;
+        raw_spin_unlock(&gsnedf_lock);
+}
 
-        /* Check if rescheduling is necessary. We can't use heap_decrease()
-         * since the priority was effectively lowered. */
-        unlink(t);
-        gsnedf_job_arrival(t);
+/* called with IRQs off */
+static void clear_priority_inheritance(struct task_struct* t)
+{
+        raw_spin_lock(&gsnedf_lock);
+    
+    TRACE_TASK(t, "priority restored\n");
+   
+    if(tsk_rt(t)->scheduled_on != NO_CPU)
+    {
+        tsk_rt(t)->inh_task = NULL;
+        
+        /* Check if rescheduling is necessary. We can't use heap_decrease()
+         * since the priority was effectively lowered. */
+        unlink(t);
+        gsnedf_job_arrival(t);
+    }
+    else
+    {
+        __set_priority_inheritance(t, NULL);
+    }
 
         raw_spin_unlock(&gsnedf_lock);
 }
@@ -919,7 +936,6 @@ static long gsnedf_allocate_lock(struct litmus_lock **lock, int type,
 
 #endif
 
-
 static long gsnedf_activate_plugin(void)
 {
         int cpu;
@@ -946,10 +962,22 @@ static long gsnedf_activate_plugin(void)
                 }
 #endif
         }
+    
+#ifdef CONFIG_LITMUS_SOFTIRQD
+    spawn_klitirqd();
+#endif
 
         return 0;
 }
 
+static long gsnedf_deactivate_plugin(void)
+{
+#ifdef CONFIG_LITMUS_SOFTIRQD
+    kill_klitirqd();
+#endif
+    return 0;
+}
+
 /*      Plugin object   */
 static struct sched_plugin gsn_edf_plugin __cacheline_aligned_in_smp = {
         .plugin_name            = "GSN-EDF",
@@ -966,6 +994,12 @@ static struct sched_plugin gsn_edf_plugin __cacheline_aligned_in_smp = {
 #ifdef CONFIG_LITMUS_LOCKING
         .allocate_lock          = gsnedf_allocate_lock,
 #endif
+#ifdef CONFIG_LITMUS_SOFTIRQD
+    .set_prio_inh   = set_priority_inheritance,
+    .clear_prio_inh = clear_priority_inheritance,
+    
+    .deactivate_plugin = gsnedf_deactivate_plugin,
+#endif
 };