1 files changed, 22 insertions, 32 deletions

diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index 1feb2fbe42bc..dd64211a1402 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -240,26 +240,6 @@ static noinline void link_task_to_cpu(struct task_struct* linked,
                         sched = &per_cpu(cedf_cpu_entries, on_cpu);
 
                         BUG_ON(sched->linked == linked);
-#if 0
-                        /* this should only happen if not linked already */
-                        if (sched->linked == linked) {
-                                printk(KERN_EMERG "%s/%d hit sched bug. is_aux = %d; has_aux = %d\n",
-                                                linked->comm, linked->pid, tsk_rt(linked)->is_aux_task, tsk_rt(linked)->has_aux_tasks);
-                                printk(KERN_EMERG "eCPU: %d, eLinked: %s/%d, sCPU: %d, sched: %s/%d\n",
-                                                entry->cpu,
-                                                (entry->linked) ?
-                                                        entry->linked->comm : "nil",
-                                                (entry->linked) ?
-                                                        entry->linked->pid : -1,
-                                                sched->cpu,
-                                                (sched->linked) ?
-                                                        sched->linked->comm : "nil",
-                                                (sched->linked) ?
-                                                        sched->linked->pid : -1);
-                                TRACE_TASK(linked, "LINK BUG!\n");
-                                unlink(linked);
-                        }
-#endif
 
                         /* If we are already scheduled on the CPU to which we
                          * wanted to link, we don't need to do the swap --
@@ -295,11 +275,9 @@ static noinline void link_task_to_cpu(struct task_struct* linked,
  */
 static noinline void unlink(struct task_struct* t)
 {
-        cpu_entry_t *entry;
-
         if (t->rt_param.linked_on != NO_CPU) {
                 /* unlink */
-                entry = &per_cpu(cedf_cpu_entries, t->rt_param.linked_on);
+                cpu_entry_t *entry = &per_cpu(cedf_cpu_entries, t->rt_param.linked_on);
                 t->rt_param.linked_on = NO_CPU;
                 link_task_to_cpu(NULL, entry);
         } else if (is_queued(t)) {
@@ -338,7 +316,7 @@ static noinline void requeue(struct task_struct* task)
 
         if (is_released(task, litmus_clock()))
 #ifdef CONFIG_REALTIME_AUX_TASKS
-                if (unlikely(tsk_rt(task)->is_aux_task && !is_running(task))) {
+                if (unlikely(tsk_rt(task)->is_aux_task && task->state != TASK_RUNNING)) {
                         /* aux_task probably transitioned to real-time while it was blocked */
                         TRACE_CUR("aux task %s/%d is not ready!\n", task->comm, task->pid);
                         unlink(task); /* really needed? */
@@ -874,6 +852,15 @@ static struct task_struct* cedf_schedule(struct task_struct * prev)
                 TRACE_TASK(prev, "will be preempted by %s/%d\n",
                            entry->linked->comm, entry->linked->pid);
 
+        if (tsk_rt(prev)->is_aux_task &&
+                (prev->state == TASK_INTERRUPTIBLE) &&
+                !blocks) {
+                TRACE_TASK(prev, "Deferring descheduling of aux task %s/%d.\n",
+                                                prev->comm, prev->pid);
+                next = prev; /* allow prev to continue. */
+                goto out_set_state;
+        }
+
         /* Send the signal that the budget has been exhausted */
         if (signal_budget)
                 send_sigbudget(entry->scheduled);
@@ -934,12 +921,17 @@ static struct task_struct* cedf_schedule(struct task_struct * prev)
                         entry->scheduled->rt_param.scheduled_on = NO_CPU;
                         TRACE_TASK(entry->scheduled, "scheduled_on = NO_CPU\n");
                 }
-        } else
+        }
+        else {
                 /* Only override Linux scheduler if we have a real-time task
                  * scheduled that needs to continue.
                  */
-                if (exists)
+                if (exists) {
                         next = prev;
+                }
+        }
+
+out_set_state:
 
         sched_state_task_picked();
         raw_spin_unlock(&cluster->cluster_lock);
@@ -988,6 +980,8 @@ static void cedf_task_new(struct task_struct * t, int on_rq, int running)
         /* setup job params */
         release_at(t, litmus_clock());
 
+        t->rt_param.linked_on = NO_CPU;
+
         if (running) {
                 entry = &per_cpu(cedf_cpu_entries, task_cpu(t));
                 BUG_ON(entry->scheduled);
@@ -1007,15 +1001,11 @@ static void cedf_task_new(struct task_struct * t, int on_rq, int running)
         } else {
                 t->rt_param.scheduled_on = NO_CPU;
         }
-        t->rt_param.linked_on = NO_CPU;
 
         if (is_running(t)) {
                 cedf_job_arrival(t);
         }
-        else {
-                TRACE("Deferred job arrival because %d is blocked.\n", t->pid);
-                unlink(t); /* needed?? */
-        }
+
         raw_spin_unlock_irqrestore(&(cluster->cluster_lock), flags);
 }
 
@@ -1188,7 +1178,7 @@ static int __increase_priority_inheritance(struct task_struct* t,
 
                 /* 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",
+                        TRACE_TASK(t, "%s: linked on %d\n",
                                            __FUNCTION__, linked_on);
                         /* Holder is scheduled; need to re-order CPUs.
                          * We can't use heap_decrease() here since