Prevent tasks from linking to one CPU when they are scheduled on another

2 files changed, 84 insertions, 38 deletions

diff --git a/litmus/sched_edf_hsb.c b/litmus/sched_edf_hsb.c
index ec4d6b0b27c2..66e870fa7ad1 100644
--- a/litmus/sched_edf_hsb.c
+++ b/litmus/sched_edf_hsb.c
@@ -570,8 +570,8 @@ static void requeue_server(server_t *server, lt_t now)
         int added = 0;
         hrt_server_t *hrt_server;
 
-        BUG_ON(server->type == S_SRT ||
-               server->type == S_SLACK);
+        if (server->type == S_SRT || server->type == S_SLACK)
+                return;
 
         if (lt_before(now, server->release)) {
                 added = add_server_release(server, &server_domain);
@@ -694,6 +694,9 @@ static noinline void unlink_server(cpu_entry_t *entry, int requeue)
                 BUG_ON(head_in_list(&server_slack(server)->list));
 }
 
+static void requeue(struct task_struct *task, rt_domain_t *domain);
+static inline rt_domain_t* get_rt_domain(cpu_entry_t *entry, struct task_struct *task);
+
 /* Update the link of a CPU.
  * Handles the case where the to-be-linked task is already
  * scheduled on a different CPU. The last argument is only needed
@@ -733,10 +736,25 @@ static noinline void link_to_cpu(cpu_entry_t *entry,
                         /* This should only happen if not linked already */
                         BUG_ON(sched->linked == linked);
 
-                        /* Swap link with entry on which linked is scheduled */
-                        if (entry != sched && !is_hrt(linked) &&
-                            (!sched->linked || !is_hrt(sched->linked))) {
-                                TRACE_TASK_SUB(linked, "already scheduled on P%d",
+                        if (entry != sched &&
+                            sched->linked && is_hrt(sched->linked)) {
+                                /* We are already scheduled on a CPU with an HRT */
+                                TRACE_TASK_SUB(linked,
+                                               "cannot move to scheduled CPU P%d",
+                                               sched->cpu);
+
+                                requeue_server(next_server, litmus_clock());
+                                requeue(linked, get_rt_domain(entry, linked));
+
+                                linked = NULL;
+                                next_server = NULL;
+                        } else if (entry != sched) {
+                                /* Link to the CPU we are scheduled on by swapping
+                                 * with that CPU's linked task.
+                                 */
+                                BUG_ON(is_hrt(linked));
+
+                                TRACE_TASK_SUB(linked,"already scheduled on P%d",
                                                sched->cpu);
 
                                 tmp_task   = sched->linked;
@@ -1023,7 +1041,9 @@ static struct task_struct* next_eligible_hrt(hrt_server_t *hrt_server)
                 if (!hrt_server->server.budget &&
                     !head_in_list(&hrt_server->server.release_list)) {
                         TRACE_SERVER_SUB(&hrt_server->server, "requeing");
+                        catchup_server(&hrt_server->server, now);
                         requeue_server(&hrt_server->server, now);
+                        slack_timer_arm(hrt_server);
                 }
 
                 if (task) {
@@ -1108,7 +1128,6 @@ static server_t* next_eligible_be_server(void)
         }
 
         if (be_server && lt_before(now, be_server->release)) {
-                TRACE_SERVER_SUB(be_server, "SHOULD BUG");
                 be_server = NULL;
         }
 
@@ -1120,6 +1139,7 @@ static server_t* next_eligible_be_server(void)
  */
 static noinline void requeue(struct task_struct *task, rt_domain_t *domain)
 {
+        lt_t now = litmus_clock();
         int was_added;
 
         BUG_ON(!is_realtime(task));
@@ -1128,8 +1148,10 @@ static noinline void requeue(struct task_struct *task, rt_domain_t *domain)
         if (is_queued(task)) {
                 TRACE_TASK_SUB(task, "not requeueing, already queued");
                 check_slack_candidate(task);
-        } else if (is_released(task, litmus_clock())) {
-                TRACE_TASK_SUB(task, "requeuing on ready");
+        } else if (is_released(task, now)) {
+                TRACE_TASK_SUB(task, "requeuing on ready %llu %llu %llu %llu",
+                               get_release(task), get_deadline(task),
+                               get_rt_period(task), now);
                 __add_ready(domain, task);
         } else {
                 /* Task needs to wait until it is released */
@@ -1408,8 +1430,9 @@ static void check_for_slack_preempt(struct task_struct *task,
  */
 static void check_for_global_preempt(void)
 {
-        cpu_entry_t *entry, *pref;
+        cpu_entry_t *entry, *sched;
         server_t *next_server;
+        int on_cpu;
         struct task_struct *next_task = (struct task_struct*)1; /* Not NULL */
 
         for (entry = lowest_prio_cpu(); entry; entry = lowest_prio_cpu()) {
@@ -1421,17 +1444,6 @@ static void check_for_global_preempt(void)
                 if (!next_server)
                         break;
 
-                /* Prevent migrations when possible */
-                if (!entry->linked) {
-                        pref = &per_cpu(cpu_entries, task_cpu(next_task));
-#ifdef CONFIG_RELEASE_MASTER
-                        if (!pref->linked && pref->cpu!=edf_hsb_release_master)
-#else
-                                if (!pref->linked)
-#endif
-                                        entry = pref;
-                }
-
                 /* Preempt only if we have an earlier deadline */
                 if (entry->linked &&
                     !lt_before(next_server->deadline,
@@ -1439,6 +1451,35 @@ static void check_for_global_preempt(void)
                         break;
                 }
 
+                /* If we are scheduled on another CPU, the link code
+                 * will force us to link to that CPU and try and link
+                 * that CPU's task to this CPU. This is impossible
+                 * if that CPU has linked HRT tasks which cannot
+                 * migrate.
+                 */
+                on_cpu = next_task->rt_param.scheduled_on;
+                if (on_cpu != NO_CPU) {
+                        sched = &per_cpu(cpu_entries, on_cpu);
+
+                        if (sched != entry && sched->linked &&
+                            is_hrt(sched->linked)) {
+
+                                TRACE_TASK_SUB(next_task,
+                                               "Already on P%d",
+                                               sched->cpu);
+
+                                if (entry->linked) {
+                                        requeue(entry->linked,
+                                                get_rt_domain(entry,
+                                                              entry->linked));
+                                        unlink(entry->linked);
+                                }
+                                preempt_if_preemptable(entry->scheduled,
+                                                       entry->cpu);
+                                break;
+                        }
+                }
+
                 /* We do not reschedule if this causes a slack preemption
                  * because we will detect if we should reschedule on the
                  * next iteration of the loop.
@@ -1718,6 +1759,8 @@ static void server_completed(server_t *server, struct task_struct *task)
         edf_hsb_pick_next(entry);
 
         BUG_ON(!is_hrt(task) && entry->linked && is_hrt(entry->linked));
+        /* if (!is_hrt(task) && entry->linked && is_hrt(entry->linked)) */
+        /*      check_for_global_preempt(); ;1*/
 
         /* Only cause a reschedule if something new was scheduled. A task
          * could merely have swapped servers.
@@ -2041,6 +2084,9 @@ static long edf_hsb_deactivate_plugin(void)
                 cpu_entry  = &per_cpu(cpu_entries, cpu);
                 hrt_server = &cpu_entry->hrt_server;
                 slack_timer_cancel(hrt_server);
+
+                if (likely(bheap_node_in_heap(cpu_entry->hn)))
+                        bheap_delete(server_order, &cpu_heap, cpu_entry->hn);
         }
 
         local_irq_restore(flags);
@@ -2292,8 +2338,11 @@ static void edf_hsb_task_wake_up(struct task_struct *task)
         } else {
                 /* Re-release all BE tasks on wake-up */
                 now = litmus_clock();
-                release_at(task, now);
-                sched_trace_task_release(task);
+
+                if (is_tardy(task, now)) {
+                        release_at(task, now);
+                        sched_trace_task_release(task);
+                }
         }
 
         job_arrival(task, entry);
diff --git a/litmus/servers.c b/litmus/servers.c
index 7c47e5fdc125..6e622f3bd5a3 100644
--- a/litmus/servers.c
+++ b/litmus/servers.c
@@ -81,17 +81,18 @@ static int completion_timer_arm(server_domain_t* domain, int cpu)
         lt_t now = domain->start_times[cpu];
         server_t *server = domain->linked_servers[cpu];
         lt_t budget_exhausted = now + server->budget;
+        completion_timer_t *timer = &domain->completion_timers[cpu];
 
         /* This happens when someone attempts to call server_run when
          * the server completes. When this happens, we can ignore the request
          * here because completion_timer_fire will re-arm the timer if
          * the server is still running / was run again.
          */
-        if (hrtimer_active(&domain->completion_timers[cpu].timer)) {
+        if (hrtimer_active(&timer->timer)) {
                 TRACE_SUB(server, "cannot arm completion, already active");
                 return 0;
         }
-        if (domain->completion_timers[cpu].armed) {
+        if (timer->armed) {
                 TRACE_SUB(server, "cannot arm completion, waiting for arm");
                 return 0;
         }
@@ -108,10 +109,9 @@ static int completion_timer_arm(server_domain_t* domain, int cpu)
 #endif
                 on_cpu = cpu;
 
+        err = 1;
         if (cpu != smp_processor_id()) {
-                err = hrtimer_start_on(on_cpu,
-                                       &domain->completion_timers[cpu].info,
-                                       &domain->completion_timers[cpu].timer,
+                err = hrtimer_start_on(on_cpu, &timer->info, &timer->timer,
                                        ns_to_ktime(budget_exhausted),
                                        HRTIMER_MODE_ABS_PINNED);
                 if (err) {
@@ -119,23 +119,20 @@ static int completion_timer_arm(server_domain_t* domain, int cpu)
                 } else {
                         TRACE_SUB(server, "success on P%d!", on_cpu);
                 }
-        } else {
-                err = __hrtimer_start_range_ns(&domain->completion_timers[cpu].timer,
+        } else if (atomic_read(&timer->info.state)!= HRTIMER_START_ON_INACTIVE){
+                err = __hrtimer_start_range_ns(&timer->timer,
                                          ns_to_ktime(budget_exhausted),
                                          0 /* delta */,
                                          HRTIMER_MODE_ABS_PINNED,
                                          0 /* no wakeup */);
         }
 
-        if (!err)
-                domain->completion_timers[cpu].armed = 1;
-        else
-                domain->completion_timers[cpu].armed = 0;
+        timer->armed = (err) ? 0 : 1;
 
-        TRACE_SUB(server, "completion 0x%x and %p armed to fire at %llu",
-                  &domain->completion_timers[cpu].timer,
-                  &domain->completion_timers[cpu].timer,
-                  TIME(budget_exhausted));
+        TRACE_SUB(server, "completion 0x%x and %p armed to fire at %llu, err: %d",
+                  &timer->timer,
+                  &timer->timer,
+                  TIME(budget_exhausted), err);
 
         return !err;
 }