Fixed GSN-EDF job_arrival() function.

Now the correct job is linked in case that a linked job lowers its
priority. This could happen if a tardy job's successor is immediately
released in the scheduler_tick() function.

The preemption_needed() function was made more robust to handle NULL
pointers correctly (needed for GSN-EDF).

2 files changed, 32 insertions, 18 deletions

diff --git a/kernel/edf_common.c b/kernel/edf_common.c
index 6a232a8f01..9aa4f39d1e 100644
--- a/kernel/edf_common.c
+++ b/kernel/edf_common.c
@@ -82,17 +82,23 @@ void __add_ready(edf_domain_t* edf, struct task_struct *new)
 
 struct task_struct* __take_ready(edf_domain_t* edf) 
 {
+        struct task_struct *t = __peek_ready(edf);
+
+        /* kick it out of the ready list */
+        if (t)
+                list_del(&t->rt_list);  
+        return t;
+}
+
+
+struct task_struct* __peek_ready(edf_domain_t* edf)
+{
         struct task_struct *t = NULL;
         /* either not yet released, preempted, or non-rt */
-        if (!list_empty(&edf->ready_queue)) {
-
+        if (!list_empty(&edf->ready_queue))
                 /* take next rt task */
                 t = list_entry(edf->ready_queue.next, struct task_struct, 
                                rt_list);
-
-                /* kick it out of the ready list */
-                list_del(&t->rt_list);
-        }
         return t;
 }
 
@@ -225,13 +231,16 @@ void __prepare_new_releases(edf_domain_t *edf, jiffie_t start)
 int preemption_needed(edf_domain_t* edf, struct task_struct *t)
 {
         /* we need the read lock for edf_ready_queue */ 
-        if (!list_empty(&edf->ready_queue) || is_np(t))
-        {
-                if (is_realtime(t))
-                        return edf_higher_prio(next_ready(edf), t);
-                else
-                        return 1;
-        }
+        /* no need to preempt if there is nothing pending */
+        if (list_empty(&edf->ready_queue))
+                return 0;
+        /* we need to reschedule if t doesn't exist */
+        if (!t)
+                return 1;
+        /* don't preempt if t is non-preemptable */
+        if (!is_np(t)) 
+                /* make sure to get non-rt stuff out of the way */
+                return !is_realtime(t) || edf_higher_prio(next_ready(edf), t);
         return 0;
 }
 
diff --git a/kernel/sched_gsn_edf.c b/kernel/sched_gsn_edf.c
index dcf976930c..54f3ddc539 100644
--- a/kernel/sched_gsn_edf.c
+++ b/kernel/sched_gsn_edf.c
@@ -196,16 +196,21 @@ static noinline void gsnedf_job_arrival(struct task_struct* task)
 
         BUG_ON(list_empty(&gsnedf_cpu_queue));
         BUG_ON(!task);
-        last = list_entry(gsnedf_cpu_queue.prev, cpu_entry_t, list);
 
-        if (is_released(task) && edf_higher_prio(task, last->linked)) {
-                TRACE("arriving task %d linked to %d\n", task->pid, last->cpu);
+        /* first queue arriving job */
+        requeue(task);
+
+        /* then check for any necessary preemptions */
+        last = list_entry(gsnedf_cpu_queue.prev, cpu_entry_t, list);
+        if (preemption_needed(&gsnedf, last->linked)) {
+                /* preemption necessary */
+                task = __take_ready(&gsnedf);
+                TRACE("job_arrival: task %d linked to %d\n", task->pid, last->cpu);
                 if (last->linked)
                         requeue(last->linked);
                 link_task_to_cpu(task, last);
                 preempt(last);
-        } else
-                requeue(task);  
+        }
 }
 
 /* check for current job releases */