Prepare k-FMLP for integration with Linux 3.0

Also added k-fmlp support to CEDF.

2 files changed, 590 insertions, 49 deletions

diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index 73fe1c442a0d..5e977dd2fef0 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -29,6 +29,7 @@
 #include <linux/percpu.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
+#include <linux/uaccess.h>
 
 #include <linux/module.h>
 
@@ -45,7 +46,6 @@
 
 /* to configure the cluster size */
 #include <litmus/litmus_proc.h>
-#include <linux/uaccess.h>
 
 /* Reference configuration variable. Determines which cache level is used to
  * group CPUs into clusters.  GLOBAL_CLUSTER, which is the default, means that
@@ -95,7 +95,7 @@ typedef struct clusterdomain {
         struct bheap_node *heap_node;
         struct bheap      cpu_heap;
         /* lock for this cluster */
-#define lock domain.ready_lock
+#define cedf_lock domain.ready_lock
 } cedf_domain_t;
 
 /* a cedf_domain per cluster; allocation is done at init/activation time */
@@ -292,12 +292,12 @@ static void cedf_release_jobs(rt_domain_t* rt, struct bheap* tasks)
         cedf_domain_t* cluster = container_of(rt, cedf_domain_t, domain);
         unsigned long flags;
 
-        raw_spin_lock_irqsave(&cluster->lock, flags);
+        raw_spin_lock_irqsave(&cluster->cedf_lock, flags);
 
         __merge_ready(&cluster->domain, tasks);
         check_for_preemptions(cluster);
 
-        raw_spin_unlock_irqrestore(&cluster->lock, flags);
+        raw_spin_unlock_irqrestore(&cluster->cedf_lock, flags);
 }
 
 /* caller holds cedf_lock */
@@ -378,7 +378,7 @@ static struct task_struct* cedf_schedule(struct task_struct * prev)
         int out_of_time, sleep, preempt, np, exists, blocks;
         struct task_struct* next = NULL;
 
-        raw_spin_lock(&cluster->lock);
+        raw_spin_lock(&cluster->cedf_lock);
         clear_will_schedule();
 
         /* sanity checking */
@@ -462,7 +462,7 @@ static struct task_struct* cedf_schedule(struct task_struct * prev)
                         next = prev;
 
         sched_state_task_picked();
-        raw_spin_unlock(&cluster->lock);
+        raw_spin_unlock(&cluster->cedf_lock);
 
 #ifdef WANT_ALL_SCHED_EVENTS
         TRACE("cedf_lock released, next=0x%p\n", next);
@@ -504,7 +504,7 @@ static void cedf_task_new(struct task_struct * t, int on_rq, int running)
         /* the cluster doesn't change even if t is running */
         cluster = task_cpu_cluster(t);
 
-        raw_spin_lock_irqsave(&cluster->domain.ready_lock, flags);
+        raw_spin_lock_irqsave(&cluster->cedf_lock, flags);
 
         /* setup job params */
         release_at(t, litmus_clock());
@@ -521,7 +521,7 @@ static void cedf_task_new(struct task_struct * t, int on_rq, int running)
         t->rt_param.linked_on          = NO_CPU;
 
         cedf_job_arrival(t);
-        raw_spin_unlock_irqrestore(&(cluster->domain.ready_lock), flags);
+        raw_spin_unlock_irqrestore(&(cluster->cedf_lock), flags);
 }
 
 static void cedf_task_wake_up(struct task_struct *task)
@@ -534,7 +534,7 @@ static void cedf_task_wake_up(struct task_struct *task)
 
         cluster = task_cpu_cluster(task);
 
-        raw_spin_lock_irqsave(&cluster->lock, flags);
+        raw_spin_lock_irqsave(&cluster->cedf_lock, flags);
         /* We need to take suspensions because of semaphores into
          * account! If a job resumes after being suspended due to acquiring
          * a semaphore, it should never be treated as a new job release.
@@ -557,7 +557,7 @@ static void cedf_task_wake_up(struct task_struct *task)
                 }
         }
         cedf_job_arrival(task);
-        raw_spin_unlock_irqrestore(&cluster->lock, flags);
+        raw_spin_unlock_irqrestore(&cluster->cedf_lock, flags);
 }
 
 static void cedf_task_block(struct task_struct *t)
@@ -570,9 +570,9 @@ static void cedf_task_block(struct task_struct *t)
         cluster = task_cpu_cluster(t);
 
         /* unlink if necessary */
-        raw_spin_lock_irqsave(&cluster->lock, flags);
+        raw_spin_lock_irqsave(&cluster->cedf_lock, flags);
         unlink(t);
-        raw_spin_unlock_irqrestore(&cluster->lock, flags);
+        raw_spin_unlock_irqrestore(&cluster->cedf_lock, flags);
 
         BUG_ON(!is_realtime(t));
 }
@@ -584,7 +584,7 @@ static void cedf_task_exit(struct task_struct * t)
         cedf_domain_t *cluster = task_cpu_cluster(t);
 
         /* unlink if necessary */
-        raw_spin_lock_irqsave(&cluster->lock, flags);
+        raw_spin_lock_irqsave(&cluster->cedf_lock, flags);
         unlink(t);
         if (tsk_rt(t)->scheduled_on != NO_CPU) {
                 cpu_entry_t *cpu;
@@ -592,7 +592,7 @@ static void cedf_task_exit(struct task_struct * t)
                 cpu->scheduled = NULL;
                 tsk_rt(t)->scheduled_on = NO_CPU;
         }
-        raw_spin_unlock_irqrestore(&cluster->lock, flags);
+        raw_spin_unlock_irqrestore(&cluster->cedf_lock, flags);
 
         BUG_ON(!is_realtime(t));
         TRACE_TASK(t, "RIP\n");
@@ -603,6 +603,578 @@ static long cedf_admit_task(struct task_struct* tsk)
         return task_cpu(tsk) == tsk->rt_param.task_params.cpu ? 0 : -EINVAL;
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+#ifdef CONFIG_LITMUS_LOCKING
+
+#include <litmus/fdso.h>
+
+
+static void __set_priority_inheritance(struct task_struct* t, struct task_struct* prio_inh)
+{
+        int linked_on;
+        int check_preempt = 0;  
+        
+        cedf_domain_t* cluster = task_cpu_cluster(t);
+        
+        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 %p\n", prio_inh);
+        
+        //sched_trace_eff_prio_change(t, prio_inh);
+        
+        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);