GSN-EDF: do not requeue jobs without budget

This patch changes how preemptions of jobs without
budget work. Instead of requeuing them, they are now
only added if they are not subject to budget enforcement
or if they have non-zero budget. This allows us to process
job completions that race with preemptions.

This appears to fix a BUG in budget.c:65 reported by Giovani Gracioli.

2 files changed, 14 insertions, 7 deletions

diff --git a/include/litmus/budget.h b/include/litmus/budget.h
index 96da960adccc..33344ee8d5f9 100644
--- a/include/litmus/budget.h
+++ b/include/litmus/budget.h
@@ -24,4 +24,12 @@ inline static lt_t budget_remaining(struct task_struct* t)
 #define budget_precisely_enforced(t) (tsk_rt(t)->task_params.budget_policy \
                                       == PRECISE_ENFORCEMENT)
 
+static inline int requeue_preempted_job(struct task_struct* t)
+{
+        /* Add task to ready queue only if not subject to budget enforcement or
+         * if the job has budget remaining. t may be NULL.
+         */
+        return t && (!budget_exhausted(t) || !budget_enforced(t));
+}
+
 #endif
diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index ea96a48b4185..c3344b9d288f 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -297,11 +297,11 @@ static void check_for_preemptions(void)
                                                 &per_cpu(gsnedf_cpu_entries, task_cpu(task)));
                         if (affinity)
                                 last = affinity;
-                        else if (last->linked)
+                        else if (requeue_preempted_job(last->linked))
                                 requeue(last->linked);
                 }
 #else
-                if (last->linked)
+                if (requeue_preempted_job(last->linked))
                         requeue(last->linked);
 #endif
 
@@ -427,9 +427,8 @@ static struct task_struct* gsnedf_schedule(struct task_struct * prev)
         /* (0) Determine state */
         exists      = entry->scheduled != NULL;
         blocks      = exists && !is_running(entry->scheduled);
-        out_of_time = exists &&
-                                  budget_enforced(entry->scheduled) &&
-                                  budget_exhausted(entry->scheduled);
+        out_of_time = exists && budget_enforced(entry->scheduled)
+                && budget_exhausted(entry->scheduled);
         np          = exists && is_np(entry->scheduled);
         sleep       = exists && get_rt_flags(entry->scheduled) == RT_F_SLEEP;
         preempt     = entry->scheduled != entry->linked;
@@ -467,9 +466,9 @@ static struct task_struct* gsnedf_schedule(struct task_struct * prev)
         /* Any task that is preemptable and either exhausts its execution
          * budget or wants to sleep completes. We may have to reschedule after
          * this. Don't do a job completion if we block (can't have timers running
-         * for blocked jobs). Preemption go first for the same reason.
+         * for blocked jobs).
          */
-        if (!np && (out_of_time || sleep) && !blocks && !preempt)
+        if (!np && (out_of_time || sleep) && !blocks)
                 job_completion(entry->scheduled, !sleep);
 
         /* Link pending task if we became unlinked.