Various changes that I don't want to lose, but the code does not work.

5 files changed, 143 insertions, 45 deletions

diff --git a/kernel/edf_common.c b/kernel/edf_common.c
index 20d990e30f..e41d9b2250 100644
--- a/kernel/edf_common.c
+++ b/kernel/edf_common.c
@@ -54,9 +54,11 @@ int edf_higher_prio(struct task_struct* first,
                 second_task = second->rt_param.inh_task;
 
         return !second_task || !is_realtime(second_task)  ||
-                earlier_deadline(first_task, second_task) ||
-                (get_deadline(first_task) == get_deadline(second_task) && 
-                 first_task->pid < second_task->pid);
+               earlier_deadline(first_task, second_task) ||
+               (get_deadline(first_task) == get_deadline(second_task) && 
+                (first_task->pid < second_task->pid ||
+                 (first_task->pid == second_task->pid &&
+                  !second->rt_param.inh_task)));
 }
 
 
diff --git a/kernel/litmus.c b/kernel/litmus.c
index a437d603fc..91984777fa 100644
--- a/kernel/litmus.c
+++ b/kernel/litmus.c
@@ -431,7 +431,7 @@ long litmus_dummy_exit_np(struct task_struct *task);
 long litmus_dummy_inherit_priority(struct pi_semaphore *sem,
                                    struct task_struct *new_waiter);
 long litmus_dummy_return_priority(struct pi_semaphore *sem);
-
+long litmus_dummy_handle_priority_change(struct task_struct *t);
 
 #define CHECK(func) {\
         if (!curr_sched_plugin->func) \
@@ -481,6 +481,7 @@ out:
         CHECK(exit_np);
         CHECK(inherit_priority);
         CHECK(return_priority);
+        CHECK(handle_priority_change);
 
 #ifdef CONFIG_MAGIC_SYSRQ
         /* offer some debugging help */
diff --git a/kernel/sched.c b/kernel/sched.c
index 8a2599f705..9ee6d0df53 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -3574,6 +3574,9 @@ need_resched_nonpreemptible:
                 }
         }
 
+        /* debug */
+        TRACE("in schedule, calling plugin, %d %d\n", prev?prev->pid:0, prev?prev->state:0); 
+
         next = NULL;
         /* consult the real-time plugin */
         curr_sched_plugin->schedule(prev, &next, rq);
@@ -3850,7 +3853,7 @@ static void __pi_wake_up_common(struct pi_semaphore *s, unsigned int mode,
         /* Holder releases lock, restores priority, and finds
          * new semaphore priority.
          */
-        curr_sched_plugin->return_priority(s);
+//      curr_sched_plugin->return_priority(s);
 }
 
 /**
@@ -3907,6 +3910,7 @@ void fastcall __pi_wake_up(struct pi_semaphore *s, unsigned int mode,
         spin_lock_irqsave(&s->wait.lock, flags);
         __pi_wake_up_common(s, mode, nr_exclusive, 0, key);
         spin_unlock_irqrestore(&s->wait.lock, flags);
+//      curr_sched_plugin->handle_priority_change(current);
 }
 
 /*
diff --git a/kernel/sched_gsn_edf.c b/kernel/sched_gsn_edf.c
index 29ec018149..2717ce60d6 100644
--- a/kernel/sched_gsn_edf.c
+++ b/kernel/sched_gsn_edf.c
@@ -14,12 +14,25 @@
 #include <linux/sched.h>
 #include <linux/list.h>
 
+//#include <linux/spinlock.h>
 #include <linux/queuelock.h>
 #include <linux/litmus.h>
 #include <linux/sched_plugin.h>
 #include <linux/edf_common.h>
 #include <linux/sched_trace.h>
 
+/* temp... */
+//#define queue_lock(a) spin_lock(a)
+//#define queue_unlock(a) spin_unlock(a)
+//#define queue_lock_irq(a) spin_lock_irq(a)
+//#define queue_unlock_irq(a) spin_unlock_irq(a)
+//#define queue_lock_irqsave(a,b) spin_lock_irqsave(a,b)
+//#define queue_unlock_irqrestore(a,b) spin_unlock_irqrestore(a,b)
+//#define queue_lock_init(a) spin_lock_init(a)
+//typedef spinlock_t queuelock_t;
+int in_gsnedf_schedule[NR_CPUS] = {0, 0, 0, 0};
+int in_gsnedf_scheduler_tick[NR_CPUS] = {0, 0, 0, 0};
+int in_gsnedf_finish_switch[NR_CPUS] = {0, 0, 0, 0};
 
 /* cpu_entry_t - maintain the linked and scheduled state
  */
@@ -92,7 +105,7 @@ static void update_cpu_position(cpu_entry_t *entry)
 
 /* link_task_to_cpu - Update the link of a CPU.
  *                    Handles the case where the to-be-linked task is already
- *                    scheduled on a differenty CPU.
+ *                    scheduled on a different CPU.
  */
 static noinline void link_task_to_cpu(struct task_struct* linked,
                              cpu_entry_t *entry)
@@ -104,12 +117,20 @@ static noinline void link_task_to_cpu(struct task_struct* linked,
 
         BUG_ON(linked && !is_realtime(linked));
 
+        /* Currently linked task is set to be unlinked. */
+        if (entry->linked) {
+                entry->linked->rt_param.linked_on = NO_CPU;
+                TRACE("unlinked %d from CPU%d\n", entry->linked->pid, entry->cpu);
+        }
+
+        /* Link new task to CPU. */
         if (linked) {           
                 set_rt_flags(linked, RT_F_RUNNING);
                 /* handle task is already scheduled somewhere! */
                 on_cpu = linked->rt_param.scheduled_on;
                 if (on_cpu != NO_CPU) {
                         TRACE("to be linked task is already running!\n");
+                        TRACE("to be linked = %d, sched = %d\n", entry->cpu, on_cpu)
                         sched = &per_cpu(gsnedf_cpu_entries, on_cpu);
                         /* this should only happen if it is not linked already */
                         BUG_ON(sched->linked == linked);
@@ -124,6 +145,8 @@ static noinline void link_task_to_cpu(struct task_struct* linked,
                                 linked->rt_param.linked_on = sched->cpu;
                                 sched->linked = linked;
                                 update_cpu_position(sched);
+                                TRACE("task %d linked to CPU%d\n", linked->pid, linked->rt_param.linked_on);
+                                TRACE("CPU%d linked to task %d\n", sched->cpu, sched->linked->pid);
                                 linked = tmp;
                         }
                 }
@@ -132,18 +155,27 @@ static noinline void link_task_to_cpu(struct task_struct* linked,
         }
         entry->linked = linked;
         update_cpu_position(entry);
+        
+        if (linked) {
+                TRACE("task %d linked to CPU%d\n", linked?linked->pid:0, linked?linked->rt_param.linked_on:0);
+                TRACE("CPU%d linked to task %d\n", entry->cpu, entry->linked?entry->linked->pid:0);
+        }
 }
 
 /* unlink - Make sure a task is not linked any longer to an entry
  *          where it was linked before. Must hold gsnedf_lock.
  */
-static noinline void unlink(struct task_struct* t, cpu_entry_t *entry)
+static noinline void unlink(struct task_struct* t)
 {
-        if (entry && entry->linked == t) {
+        cpu_entry_t *entry;
+
+        BUG_ON(!t);
+
+        if (t->rt_param.linked_on != NO_CPU) {
                 /* unlink */
+                entry = &per_cpu(gsnedf_cpu_entries, t->rt_param.linked_on);
                 t->rt_param.linked_on = NO_CPU;
                 link_task_to_cpu(NULL, entry);
-                
         } else if (in_list(&t->rt_list)) {
                 /* This is an interesting situation: t is scheduled,
                  * but was just recently unlinked.  It cannot be
@@ -153,8 +185,8 @@ static noinline void unlink(struct task_struct* t, cpu_entry_t *entry)
                  * case.
                  */
                 list_del(&t->rt_list);
-        }       
-}
+        }
+} 
 
 
 /* preempt - force a CPU to reschedule
@@ -188,9 +220,12 @@ static noinline void requeue(struct task_struct* task)
                  */
                 if (is_released(task) && get_rt_mode() == MODE_RT_RUN)
                         __add_ready(&gsnedf, task);
-                else 
+                else { 
+                        TRACE("release added due to sleeping task\n");
                         /* it has got to wait */
                         __add_release(&gsnedf, task);
+                }
+
         } else 
                 /* this is a forced preemption 
                  * thus the task stays in the ready_queue
@@ -218,6 +253,8 @@ static noinline void gsnedf_job_arrival(struct task_struct* task)
                 TRACE("job_arrival: task %d linked to %d\n", task->pid, last->cpu);
                 if (last->linked)
                         requeue(last->linked);
+                
+                TRACE("GSNEDF_JA: LINK %d to %d\n", task?task->pid:0, last->cpu);
                 link_task_to_cpu(task, last);
                 preempt(last);
         }
@@ -258,6 +295,10 @@ static reschedule_check_t gsnedf_scheduler_tick(void)
         reschedule_check_t      want_resched = NO_RESCHED;
         cpu_entry_t*            entry = &__get_cpu_var(gsnedf_cpu_entries);
 
+        /* debug */
+//      queue_lock_irqsave(&gsnedf_lock, flags);
+        in_gsnedf_scheduler_tick[smp_processor_id()] = 1;
+
         /* expire tasks even if not in real-time mode
          * this makes sure that at the end of real-time mode
          * no task  "runs away forever".
@@ -277,13 +318,16 @@ static reschedule_check_t gsnedf_scheduler_tick(void)
                         prepare_for_next_period(t);     
                         queue_lock_irqsave(&gsnedf_lock, flags);
                         /* unlink */
-                        unlink(t, entry);
+                        TRACE("UNLINKING FROM GSNEDF_SCHEDULER_TICK\n");
+                        unlink(t);
                         /* requeue */
                         gsnedf_job_arrival(t);
                         queue_unlock_irqrestore(&gsnedf_lock, flags);
                 }
         } 
         if (get_rt_mode() == MODE_RT_RUN) {
+                in_gsnedf_scheduler_tick[smp_processor_id()] = 666;
+
                 queue_lock_irqsave(&gsnedf_lock, flags);
                 
                 /* (1) try to release pending jobs */
@@ -296,7 +340,12 @@ static reschedule_check_t gsnedf_scheduler_tick(void)
                         set_will_schedule(); 
                 }
                 queue_unlock_irqrestore(&gsnedf_lock, flags);           
-        }       
+        }
+
+        /* debug */
+//      queue_unlock_irqrestore(&gsnedf_lock, flags);
+        in_gsnedf_scheduler_tick[smp_processor_id()] = 0;
+
         return want_resched;
 }
 
@@ -310,6 +359,8 @@ static int gsnedf_schedule(struct task_struct * prev,
 {
         cpu_entry_t*    entry = &__get_cpu_var(gsnedf_cpu_entries);
 
+        in_gsnedf_schedule[smp_processor_id()] = 1;
+
         /* will be released in finish_switch */
         queue_lock(&gsnedf_lock);
         clear_will_schedule();
@@ -318,12 +369,16 @@ static int gsnedf_schedule(struct task_struct * prev,
 
         /* (1) check for blocking jobs */
         if (prev == entry->linked && 
-            (get_rt_mode() != MODE_RT_RUN || !is_running(prev)))
+            (get_rt_mode() != MODE_RT_RUN || !is_running(prev))) {
+                TRACE("UNLINK (NULL) FROM GSNEDF_SCHEDULE prev=%x entry->linked=%x prev->state=%d\n", prev, entry->linked, prev?prev->state:-666);
                 link_task_to_cpu(NULL, entry);
+        }
 
         /* (2) if not linked then get rt task */        
-        if (get_rt_mode() == MODE_RT_RUN && !entry->linked)
+        if (get_rt_mode() == MODE_RT_RUN && !entry->linked) {
+                TRACE("GSNEDF_SCHED: LINK TO %d\n", entry->cpu);
                 link_task_to_cpu(__take_ready(&gsnedf), entry);
+        }
 
         /* (3) if linked different from scheduled 
          *     select linked as next
@@ -354,6 +409,10 @@ static int gsnedf_schedule(struct task_struct * prev,
          */
         if (prev == *next || (!is_realtime(prev) && !*next))
                 queue_unlock(&gsnedf_lock);
+//      if (prev == *next)
+//              queue_unlock(&gsnedf_lock);
+
+        in_gsnedf_schedule[smp_processor_id()] = 0;
 
         return 0;
 }
@@ -365,6 +424,8 @@ static void gsnedf_finish_switch(struct task_struct *prev)
 {
         cpu_entry_t*    entry = &__get_cpu_var(gsnedf_cpu_entries);
 
+        in_gsnedf_finish_switch[smp_processor_id()] = 1;
+
         if (is_realtime(current))
                 entry->scheduled = current;             
         else
@@ -374,8 +435,18 @@ static void gsnedf_finish_switch(struct task_struct *prev)
         current->rt_param.scheduled_on = smp_processor_id();
 
         /* unlock in case schedule() left it locked */
-        if (is_realtime(current) || is_realtime(prev))
-                queue_unlock(&gsnedf_lock);
+        if (is_realtime(current) || is_realtime(prev)) {
+//              /* spinlock stuff to change ownership... */
+//              if (gsnedf_lock.owner != current) {
+//                      gsnedf_lock.owner = current;
+//                      spin_acquire(&gsnedf_lock.dep_map, 0, 0, _THIS_IP_);
+//                      queue_unlock(&gsnedf_lock);
+//              } else
+                        /* unlock... */
+                        queue_unlock(&gsnedf_lock);
+        }
+
+        in_gsnedf_finish_switch[smp_processor_id()] = 0;
 }
 
 
@@ -455,12 +526,11 @@ static void gsnedf_wake_up_task(struct task_struct *task)
 static void gsnedf_task_blocks(struct task_struct *t)
 {
         unsigned long flags;
-        cpu_entry_t*    entry;
 
         /* unlink if necessary */
         queue_lock_irqsave(&gsnedf_lock, flags);
-        entry = &__get_cpu_var(gsnedf_cpu_entries);
-        unlink(t, entry);
+        TRACE("UNLINK FROM GSNEDF_TASK_BLOCKS\n");
+        unlink(t);
         queue_unlock_irqrestore(&gsnedf_lock, flags);
 
         BUG_ON(!is_realtime(t));
@@ -515,16 +585,24 @@ static long gsnedf_exit_np(struct task_struct * t)
         return ret;
 }
 
-static noinline void handle_priority_change(struct task_struct *t)
+static noinline long gsnedf_handle_priority_change(struct task_struct *t)
 {
-        int link_cpu;
-        
-        link_cpu = t->rt_param.linked_on;
+        unsigned long flags;
+        int ret = 0;
 
-        unlink(t, link_cpu != NO_CPU ? &per_cpu(gsnedf_cpu_entries, link_cpu) :
-                                                                NULL);
+        queue_lock_irqsave(&gsnedf_lock, flags);
+
+        /* debug: a task can only unlink and reschedule itself! */
+        if (t && t == current) {
+                TRACE("HPC: UL %d %d\n", current->pid, t->pid);
+                unlink(t);
+                TRACE("HPC: JA %d %d\n", current->pid, t->pid);
+                gsnedf_job_arrival(t); /* requeue/link as appropriate */
+        }
+
+        queue_unlock_irqrestore(&gsnedf_lock, flags);
         
-        gsnedf_job_arrival(t); /* requeue/link as appropriate */
+        return ret;
 }
 
 static long gsnedf_inherit_priority(struct pi_semaphore *sem,
@@ -540,14 +618,21 @@ static long gsnedf_inherit_priority(struct pi_semaphore *sem,
          * not yet been determined. Need to also compare against your
          * own task priority!
          */     
-        if (sem->holder && !sem->holder->rt_param.inh_task) {
-                sem->holder->rt_param.inh_task = sem->holder;
+        if (sem->holder && sem->holder == current &&
+            !sem->holder->rt_param.inh_task) {
+                TRACE("IP: INH %d %d\n", current->pid, sem->holder->pid);
+                sem->holder->rt_param.inh_task = sem->holder;
                 if (sem->hp_sem_task &&
-                    edf_higher_prio(sem->hp_sem_task, sem->holder)) {           
+                    edf_higher_prio(sem->hp_sem_task, sem->holder)) {         
                         sem->holder->rt_param.inh_task = sem->hp_sem_task;
-                        handle_priority_change(sem->holder);
-                } else
+                        TRACE("IP: INH %d %d UL\n", sem->holder->rt_param.inh_task->pid, sem->hp_sem_task->pid);
+                        unlink(sem->holder);
+                        TRACE("IP: JA %d %d\n", current->pid, sem->holder->pid);
+                        gsnedf_job_arrival(sem->holder); /* requeue/link */
+                } else {
                         sem->hp_sem_task = sem->holder;
+                        TRACE("IP: NO %d %d\n", sem->holder->pid, sem->hp_sem_task->pid);
+                }
         }
 
         /* Check if new waiting task increases priority of
@@ -559,12 +644,12 @@ static long gsnedf_inherit_priority(struct pi_semaphore *sem,
                 /* Holder priority changed... make sure to
                  * update system as a result.
                  */     
-                if (sem->holder) {                      
-                        sem->holder->rt_param.inh_task = new_waiter;            
-                        handle_priority_change(sem->holder);
+                if (sem->holder) {              
+                        sem->holder->rt_param.inh_task = new_waiter;
+                        TRACE("IP: PR %d %d %d\n", new_waiter->pid, sem->holder->pid, sem->holder->rt_param.inh_task->pid);
                 }
         }
-        
+
         queue_unlock_irqrestore(&gsnedf_lock, flags);   
         return ret;
 }
@@ -577,9 +662,11 @@ static long gsnedf_return_priority(struct pi_semaphore *sem)
         struct list_head        *tmp, *next;
         unsigned long           flags;
         int ret = 0;
-        
+
         queue_lock_irqsave(&gsnedf_lock, flags);
 
+        TRACE("RP: %d %d %d\n", current->pid, sem->hp_sem_task->pid, current->rt_param.inh_task->pid);
+
         /* Find new highest-priority semaphore task
          * if holder task is the current hp_sem_task.
          */
@@ -607,12 +694,9 @@ static long gsnedf_return_priority(struct pi_semaphore *sem)
         /* Remove current task as holder. */
         sem->holder = NULL;
 
-        /* Holder priority changed... make sure to update system
-         * as a result.
-         */
-        handle_priority_change(current);
+        TRACE("RP: %d %d %d *\n", current->pid, sem->hp_sem_task?sem->hp_sem_task->pid:0, current->rt_param.inh_task?current->rt_param.inh_task->pid:0);
 
-        queue_unlock_irqrestore(&gsnedf_lock, flags);   
+        queue_unlock_irqrestore(&gsnedf_lock, flags);
         return ret;
 }
 
@@ -673,7 +757,8 @@ static sched_plugin_t s_plugin __cacheline_aligned_in_smp = {
         .enter_np               = gsnedf_enter_np,              \
         .exit_np                = gsnedf_exit_np,               \
         .inherit_priority       = gsnedf_inherit_priority,      \
-        .return_priority        = gsnedf_return_priority        \
+        .return_priority        = gsnedf_return_priority,       \
+        .handle_priority_change = gsnedf_handle_priority_change \
 }
 
 
diff --git a/kernel/sched_plugin.c b/kernel/sched_plugin.c
index 8170d6e1df..82ee3f9458 100644
--- a/kernel/sched_plugin.c
+++ b/kernel/sched_plugin.c
@@ -89,6 +89,11 @@ long litmus_dummy_return_priority(struct pi_semaphore *sem)
         return -EPERM;
 }
 
+long litmus_dummy_handle_priority_change(struct task_struct *t)
+{
+        return -EPERM;
+}
+
 
 /* The default scheduler plugin. It doesn't do anything and lets Linux do its
  * job.
@@ -109,7 +114,8 @@ sched_plugin_t linux_sched_plugin = {
         .finish_switch = litmus_dummy_finish_switch,
         .scheduler_setup = litmus_dummy_scheduler_setup,
         .inherit_priority = litmus_dummy_inherit_priority,
-        .return_priority = litmus_dummy_return_priority
+        .return_priority = litmus_dummy_return_priority,
+        .handle_priority_change = litmus_dummy_handle_priority_change
 };
 
 /*