Initial implementation of inherit and return priority for PSN-EDF.

1 files changed, 37 insertions, 40 deletions

diff --git a/kernel/sched_psn_edf.c b/kernel/sched_psn_edf.c
index 804c1298c7..9bee6256f2 100644
--- a/kernel/sched_psn_edf.c
+++ b/kernel/sched_psn_edf.c
@@ -398,8 +398,7 @@ static long psnedf_handle_priority_change(struct task_struct *t)
         return ret;
 }
 
-#if 0
-
+/* XXX: Do we need to call handle_priority_change here ourselves? */
 static long psnedf_inherit_priority(struct pi_semaphore *sem,
                                     struct task_struct *new_waiter)
 {
@@ -409,53 +408,54 @@ static long psnedf_inherit_priority(struct pi_semaphore *sem,
 
         spin_lock_irqsave(&pedf->lock, flags);
 
-        /* If no inherited task, need to fix that. This occurs when
-         * the semaphore has been claimed, but the inherited task has
-         * not yet been determined. Need to also compare against your
-         * own task priority!
-         */     
-        if (sem->holder && sem->holder == current &&
-            !sem->holder->rt_param.inh_task) {
-                TRACE("LOCK %d\n", current->pid);
-                sem->holder->rt_param.inh_task = sem->holder;
+        /* inherit_priority(xxx, NULL) is called if the current just 
+         * became the owner of the semaphore. In this case we must check
+         * whether current should inherit the priority of a waiter, but only
+         * if doesn't already has an inherityed priority. (Why? That's how John
+         * did in GSN-EDF... -BBB)
+         */
+        if (sem->holder == current && !current->rt_param.inh_task) {
+                /* we "inherit" our own priority by default */
+                current->rt_param.inh_task = current;
+
                 if (sem->hp_sem_task &&
-                    edf_higher_prio(sem->hp_sem_task, sem->holder)) {         
-                        sem->holder->rt_param.inh_task = sem->hp_sem_task;
-                        unlink(sem->holder);
-                        gsnedf_job_arrival(sem->holder); /* requeue/link */
-                } else {
-                        sem->hp_sem_task = sem->holder;
-                }
+                    edf_higher_prio(sem->hp_sem_task, sem->holder))
+                        /* there is a higher-priority job waiting */
+                        current->rt_param.inh_task = sem->hp_sem_task;
+                        /* handle priority change? */
+                else
+                        /* well then set the highest-priority field accordingly */
+                        sem->hp_sem_task = current;             
         }
 
         /* Check if new waiting task increases priority of
          * holder, and if so, respond appropriately.
          */
-        if (new_waiter && edf_higher_prio(new_waiter, sem->hp_sem_task)) {      
+        if (new_waiter && 
+            edf_higher_prio(new_waiter, sem->hp_sem_task)) {
                 sem->hp_sem_task = new_waiter;
-                
-                /* Holder priority changed... make sure to
-                 * update system as a result.
-                 */     
-                if (sem->holder) {              
+                if (sem->holder)                
                         sem->holder->rt_param.inh_task = new_waiter;
-                }
+                /* call handle_priority_change? */
         }
 
         spin_unlock_irqrestore(&pedf->lock, flags);     
         return ret;
 }
 
+
 /* This function is called on a semaphore release, and assumes that
  * the current task is also the semaphore holder.
  */
-static long gsnedf_return_priority(struct pi_semaphore *sem)
+static long psnedf_return_priority(struct pi_semaphore *sem)
 {
         struct list_head        *tmp, *next;
         unsigned long           flags;
-        int ret = 0;
+        psnedf_domain_t*        pedf = task_pedf(current);
+        int                     ret = 0;
+        struct task_struct *    curr;
 
-        queue_lock_irqsave(&gsnedf_lock, flags);
+        spin_lock_irqsave(&pedf->lock, flags);
 
         /* Find new highest-priority semaphore task
          * if holder task is the current hp_sem_task.
@@ -464,16 +464,13 @@ static long gsnedf_return_priority(struct pi_semaphore *sem)
                 sem->hp_sem_task = NULL;
                 if (waitqueue_active(&sem->wait)) {
                         list_for_each_safe(tmp, next, &sem->wait.task_list) {
-                                wait_queue_t *curr = list_entry(tmp,
-                                                      wait_queue_t, task_list);
-        
+                                curr = (struct task_struct*) 
+                                        list_entry(tmp, wait_queue_t, 
+                                                   task_list)->private;
+
                                 /* Compare task prios, find high prio task. */
-                                if (edf_higher_prio(
-                                    (struct task_struct*)curr->private,
-                                    sem->hp_sem_task)) {        
-                                        sem->hp_sem_task =
-                                           (struct task_struct *)curr->private;
-                                }
+                                if (edf_higher_prio(curr, sem->hp_sem_task))
+                                        sem->hp_sem_task = curr;
                         }
                 }
         }
@@ -484,12 +481,12 @@ static long gsnedf_return_priority(struct pi_semaphore *sem)
         /* Remove current task as holder. */
         sem->holder = NULL;
 
-        TRACE("UNLOCK %d\n", current->pid);
+        TRACE_TASK(current, "priority returned.\n");
 
-        queue_unlock_irqrestore(&gsnedf_lock, flags);
+        spin_unlock_irqrestore(&pedf->lock, flags);
         return ret;
 }
-#endif
+
 
 static int psnedf_mode_change(int new_mode)
 {