Fix of blocking while being run by slack

1 files changed, 35 insertions, 14 deletions

diff --git a/litmus/sched_edf_hsb.c b/litmus/sched_edf_hsb.c
index d4869773875d..6d370340bcf9 100644
--- a/litmus/sched_edf_hsb.c
+++ b/litmus/sched_edf_hsb.c
@@ -812,18 +812,23 @@ static noinline void unlink(struct task_struct* t)
                 /* Unlink */
                 entry = task_linked_entry(t);
                 link_task_to_cpu(entry, NULL, NULL, 0);
-        } else if (is_queued(t) && is_released(t, litmus_clock())) {
-                /* This is an interesting situation: t is scheduled,
-                 * but has already been unlinked. It was re-added to
-                 * a ready queue of some sort but now needs to
-                 * be removed. This usually happens when a job has
-                 * been preempted but completes before it is
-                 * descheduled.
-                 */
-                TRACE_TASK_SUB(t, "removing from domain");
-                entry = task_sched_entry(t);
-                remove(get_rt_domain(entry, t), t);
-                BUG_ON(is_queued(t));
+        } else if (is_queued(t)) {
+
+                if (is_released(t, litmus_clock())) {
+                        /* This is an interesting situation: t is scheduled,
+                         * but has already been unlinked. It was re-added to
+                         * a ready queue of some sort but now needs to
+                         * be removed. This usually happens when a job has
+                         * been preempted but completes before it is
+                         * descheduled.
+                         */
+                        TRACE_TASK_SUB(t, "removing from domain");
+                        entry = task_sched_entry(t);
+                        remove(get_rt_domain(entry, t), t);
+                        BUG_ON(is_queued(t));
+                }/*  else { */
+
+                /* } */
         }
 }
 
@@ -957,6 +962,15 @@ static struct task_struct* next_eligible_srt(void)
         struct task_struct *next_srt = __peek_ready(&srt_domain);
         server_t *srt_server;
 
+        /* A blocking task might pollute the SRT domain if the
+         * task blocked while it was being run by a slack server.
+         * Remove and ignore this task.
+         */
+        while (next_srt && !is_running(next_srt)) {
+                remove(&srt_domain, next_srt);
+                next_srt = __peek_ready(&srt_domain);
+        }
+
         /* Catch up srt server. This happens when the job is tardy due
          * to overutilization of the system.
          */
@@ -2125,11 +2139,18 @@ static void edf_hsb_task_wake_up(struct task_struct *task)
         unsigned long flags;
         cpu_entry_t *entry = task_sched_entry(task);
 
-        BUG_ON(is_queued(task));
 
         TRACE_TASK(task, "wake_up at %llu on %d, %d\n", TIME(litmus_clock()),
                    task_cpu(task), task->rt_param.task_params.cpu);
 
+        set_rt_flags(task, RT_F_RUNNING);
+
+        /* The job blocked while it was being run by a slack server */
+        if (is_queued(task)) {
+                check_slack_candidate(task);
+                return;
+        }
+
         //BUG_ON(entry->scheduled == task);
 
         raw_spin_lock_irqsave(global_lock, flags);
@@ -2143,7 +2164,7 @@ static void edf_hsb_task_wake_up(struct task_struct *task)
          * switched from the sporadic to the periodic task model. See
          * sched_gsn_edf.c for the sporadic version.
          */
-        set_rt_flags(task, RT_F_RUNNING);
+
         job_arrival(task, entry);
 
         raw_spin_unlock_irqrestore(global_lock, flags);