1 files changed, 21 insertions, 5 deletions

diff --git a/litmus/sched_edfsc.c b/litmus/sched_edfsc.c
index 812feabb6417..17a7d1f5bca0 100644
--- a/litmus/sched_edfsc.c
+++ b/litmus/sched_edfsc.c
@@ -1013,28 +1013,44 @@ static enum hrtimer_restart container_boundary(struct hrtimer *timer)
                         prepare_for_next_period(t);
                         if (is_early_releasing(t) || is_released(t, now))
                                 sched_trace_task_release(t);
+                        /* If this container is fully provisioned, remove it from gsched_domain,
+                         * edfsc_cpu_heap, and disable the idle enforcement timer. If not, restore.
+                         */
                         if (get_rt_utilization(t) == to_fp(1)) {
-                                tsk_rt(t)->task_params.exec_cost = from_fp(get_rt_utilization(t) * get_rt_period(t));
                                 cpu_entry_t* entry = &per_cpu(edfsc_cpu_entries, tsk_rt(t)->edfsc_params.id);
+                                // Update execution cost to reflect a utilization of 1
+                                tsk_rt(t)->task_params.exec_cost = get_rt_period(t);
+                                // Make this cpu unavailable to the global scheduler
                                 if (bheap_node_in_heap(entry->hn))
                                         remove_cpu_from_global(entry);
-                                entry->linked = t;
-                                tsk_rt(t)->linked_on = entry->cpu;
+                                // Fully provisioned containers always run, so just set this here
+                                if (entry->linked != t)
+                                        link_task_to_cpu(t, entry);
+                                // Note that we no longer need the global scheduler to schedule us
                                 if (is_queued(t))
                                         remove(&gsched_domain, t);
+                                // Fully provisioned containers always run, so idle enforcement is superfluous
                                 cancel_idle_enforcement_timer(t);
                                 tsk_rt(t)->edfsc_params.domain->scheduled_last_exec_time = litmus_clock();
+                                // Run schedule again to make sure that we're run
                                 preempt(entry);
                         }
                         else {
                                 cpu_entry_t* entry = &per_cpu(edfsc_cpu_entries, tsk_rt(t)->edfsc_params.id);
-                                add_cpu_to_global(entry);
+                                // Make our cpu available again
+                                if (!bheap_node_in_heap(entry->hn))
+                                        add_cpu_to_global(entry);
                                 if (is_current_running()) { //since we don't support blocking, this should always be true
                                         if (tsk_rt(t)->edfsc_params.domain->scheduled) {
                                                 requeue(tsk_rt(t)->edfsc_params.domain->scheduled);
                                                 tsk_rt(t)->edfsc_params.domain->scheduled = NULL;
                                         }
-                                        requeue(t);
+                                        // Let g_preempt_check() decide what to run, don't impose
+                                        unlink(t);
+                                        // Request to be scheduled globally again
+                                        if (!is_queued(t))
+                                                requeue(t);
+                                        // Re-run our EDF scheduling to adjust for the added core
                                         g_preempt_check();
                                 }
                         }