Don't unlink np tasks that block preemptions.

This patch prevents non-preemptive tasks from
being unlinked up a blocked preemption. Apparently
was leading to lost tasks (they would suspend and
never be heard from again).

1 files changed, 33 insertions, 12 deletions

diff --git a/litmus/sched_cfl_split.c b/litmus/sched_cfl_split.c
index b6dde71cdf84..6fd1591aec5a 100644
--- a/litmus/sched_cfl_split.c
+++ b/litmus/sched_cfl_split.c
@@ -394,11 +394,16 @@ static cpu_entry_t* cflsplit_get_nearest_available_cpu(
 #endif
                 );
 
-        /* make sure CPU is in our cluster */
-        if (affinity && cpu_isset(affinity->cpu, *cluster->cpu_map))
-                return(affinity);
-        else
-                return(NULL);
+        if (affinity) {
+                /* make sure CPU is in our cluster */
+                if(cpu_isset(affinity->cpu, *cluster->cpu_map)) {
+                        return(affinity);
+                }
+                else {
+                        TRACE("CPU %d is not in our cluster.\n", affinity->cpu);
+                }
+        }
+        return(NULL);
 }
 #endif
 
@@ -414,8 +419,8 @@ static void check_for_preemptions(cflsplit_domain_t *cluster)
             last = lowest_prio_cpu(cluster)) {
                 /* preemption necessary */
                 task = __take_ready(&cluster->domain);
-                TRACE("check_for_preemptions: attempting to link task %d to %d\n",
-                      task->pid, last->cpu);
+                TRACE("check_for_preemptions: attempting to link task %s/%d to %d\n",
+                      task->comm, task->pid, last->cpu);
 #ifdef CONFIG_SCHED_CPU_AFFINITY
                 {
                         cpu_entry_t *affinity =
@@ -584,9 +589,11 @@ static struct task_struct* cflsplit_schedule(struct task_struct * prev)
         if (exists)
                 TRACE_TASK(prev,
                            "blocks:%d out_of_time:%d needs_move: %d np:%d"
-                           " sleep:%d preempt:%d state:%d sig:%d\n",
+                           " sleep:%d preempt:%d state:%d sig:%d boosted:%d\n",
                            blocks, out_of_time, needs_move, np, sleep, preempt,
-                           prev->state, signal_pending(prev));
+                           prev->state, signal_pending(prev),
+                           is_priority_boosted(entry->scheduled));
+
         if (entry->linked && preempt)
                 TRACE_TASK(prev, "will be preempted by %s/%d\n",
                            entry->linked->comm, entry->linked->pid);
@@ -612,6 +619,13 @@ static struct task_struct* cflsplit_schedule(struct task_struct * prev)
                                         if (likely(!blocks)) {
                                                 unlink(entry->scheduled);
                                                 cflsplit_job_arrival(entry->scheduled);
+                                                /* we may regain the processor */
+                                                if (preempt) {
+                                                        preempt = entry->scheduled != entry->linked;
+                                                        if (!preempt) {
+                                                                TRACE_TASK(entry->scheduled, "blocked preemption by lazy boosting.\n");
+                                                        }
+                                                }
                                         }
                                 }
                         }
@@ -628,6 +642,13 @@ static struct task_struct* cflsplit_schedule(struct task_struct * prev)
                                                 /* recheck priority */
                                                 unlink(entry->scheduled);
                                                 cflsplit_job_arrival(entry->scheduled);
+                                                /* we may lose the processor */
+                                                if (!preempt) {
+                                                        preempt = entry->scheduled != entry->linked;
+                                                        if (preempt) {
+                                                                TRACE_TASK(entry->scheduled, "preempted by lazy unboosting.\n");
+                                                        }
+                                                }
                                         }
                                 }
                         }
@@ -647,11 +668,12 @@ static struct task_struct* cflsplit_schedule(struct task_struct * prev)
          *
          * Job deadline moves handled similarly
          */
-        if (np && (out_of_time || preempt || sleep)) {
+//      if (np && (out_of_time || preempt || sleep)) {
+        if (np && (out_of_time || sleep)) {
                 unlink(entry->scheduled);
                 request_exit_np(entry->scheduled);
         }
-        else if (np && needs_move) {
+        else if (np && (needs_move || preempt)) {
                 request_exit_np(entry->scheduled);
         }
 
@@ -713,7 +735,6 @@ static struct task_struct* cflsplit_schedule(struct task_struct * prev)
                 TRACE("becomes idle at %llu.\n", litmus_clock());
 #endif
 
-
         return next;
 }