Merge branch 'edfsc-wip' of rtsrv.cs.unc.edu:/public/litmus-rt-edfsc into edfsc-wip

1 files changed, 57 insertions, 37 deletions

diff --git a/litmus/sched_edfsc.c b/litmus/sched_edfsc.c
index 14a775453a78..ea1b308667c7 100644
--- a/litmus/sched_edfsc.c
+++ b/litmus/sched_edfsc.c
@@ -1001,52 +1001,72 @@ static void edfsc_task_block(struct task_struct *t)
         // TODO
 }
 
+/**
+ * This is called by LITMUS before our task is switched to another scheduler
+ * During task termination (do_exit()), LITMUS first switches the scheduler
+ * to SCHED_FIFO before running the normal Linux task termination proceedure.
+ * After we return from this, `t` may or may not still exist. So we should have
+ * no outstanding handles to any part of the task struct afer this point.
+ */
 static void edfsc_task_exit(struct task_struct* t)
 {
         unsigned long flags;
-        lt_t now;
-        raw_spin_lock_irqsave(&g_lock, flags);
-        now = litmus_clock();
+        lt_t now, unaccount_time = 0;
+        cpu_entry_t* entry;
+
 
+        BUG_ON(is_container(t));
+        raw_spin_lock_irqsave(&g_lock, flags);
+        // XXX: Superfluous. We never see `t` as one of our tasks again.
         tsk_rt(t)->edfsc_params.will_remove = 1;
 
-        // If the task has no pending job
-        if (!is_released(t, now)) {
-                // If the deadline of its last job is in the future, reserve the
-                // utilization until its deadline
-                if (lt_after(tsk_rt(t)->edfsc_params.prev_deadline, now)) {
-                        if (is_queued(t))
-                                remove(tsk_rt(t)->domain, t);
-                        //hrtimer_start(&(tsk_rt(t)->edfsc_params.deadline_timer),
-                        //              ns_to_ktime(tsk_rt(t)->edfsc_params.prev_deadline),
-                        //              HRTIMER_MODE_ABS_PINNED);
-                        hrtimer_start(&t->edfsc_deadline_timer,
-                                        ns_to_ktime(tsk_rt(t)->edfsc_params.prev_deadline),
-                                        HRTIMER_MODE_ABS_PINNED);
-                // Else remove it and we're done
-                } else {
-                        if (is_queued(t))
-                                remove(tsk_rt(t)->domain, t);
-                        // XXX not sure if this needs an additional condition guarding it
-                        remove_task(t);
-                }
-        // If the task has a pending job, we can immediatly stop LITMUS from
-        // scheduling it but still have to reserve its utilization until the deadline
+
+        // Remove this task from all members of its scheduling domain
+        unlink(t);
+        if (is_queued(t)) {
+                remove(tsk_rt(t)->domain, t);
+        } else if (is_fixed(t)) {
+                // If we're fixed and not on the ready queues, we should be currently running
+                BUG_ON(((cont_domain_t*)tsk_rt(t)->domain)->scheduled != t);
+                BUG_ON(t != current);
+                ((cont_domain_t*)tsk_rt(t)->domain)->scheduled = NULL;
         } else {
-                //reserve the utilization, but remove it from being scheduled by litmus
-                unlink(t);
-                if (tsk_rt(t)->scheduled_on != NO_CPU) {
-                        (&per_cpu(edfsc_cpu_entries, tsk_rt(t)->scheduled_on))->scheduled = NULL;
-                        tsk_rt(t)->scheduled_on = NO_CPU;
-                }
-                //hrtimer_start(&(tsk_rt(t)->edfsc_params.deadline_timer),
-                //                      ns_to_ktime(get_deadline(t)),
-                //                      HRTIMER_MODE_ABS_PINNED);
-                hrtimer_start(&t->edfsc_deadline_timer,
-                                        ns_to_ktime(get_deadline(t)),
-                                        HRTIMER_MODE_ABS_PINNED);
+                // We're in the global domain and not on the ready queues, so we must be running
+                BUG_ON(t != current);
+                BUG_ON(tsk_rt(t)->scheduled_on == NO_CPU);
+                entry = &per_cpu(edfsc_cpu_entries, tsk_rt(t)->scheduled_on);
+                BUG_ON(entry->scheduled != t);
+                entry->scheduled = NULL;
+        }
+
+        /* To preserve EDF-sc scheduling invariants, we can only release a task's
+         * utilization at the greater of the period or deadline boundry. Thus, here
+         * we schedule a timer to handle this unaccounting of utilization.
+         */
+        now = litmus_clock();
+        if (is_released(t, now)) {
+                /* If a task has already been released, no future jobs are pending and we can
+                 * just unaccount at the current deadline.
+                 */
+                unaccount_time = get_deadline(t);
+        } else {
+                /* If the task has yet to be released, but we still haven't reached the
+                 * deadline of its last-finished job, wait for that deadline. Otherwise
+                 * we're after a deadline and before a release, so just remove now.
+                 */
+                if (lt_after(tsk_rt(t)->edfsc_params.prev_deadline, now))
+                        unaccount_time = tsk_rt(t)->edfsc_params.prev_deadline;
+                else
+                        unaccount_time = 0;
         }
 
+        if (unaccount_time == 0)
+                remove_task(t);
+        else
+                // FIXME: This timer uses task struct data that may or may not exist at expiration
+                hrtimer_start(&t->edfsc_deadline_timer, ns_to_ktime(unaccount_time),
+                                        HRTIMER_MODE_ABS_PINNED);
+
         raw_spin_unlock_irqrestore(&g_lock, flags);
 }