Fix synchronous task system release support

...and also finally fix the requeue() race (hopefully).

Commit 4ffefb822b9d65d4efbedb60e3c9a0e76895cc5b broke the synchronous
task system release code. The problem is that release_at() clears the
tsk_rt(t)->completed flag. The patch thus only made the race window
smaller, but didn't close it entirely. Further, it broke the
synchronous task set release, which relies on schedule() being called
with completed == 1.

This patch fixes both problems by introducing a new flag dont_requeue,
which indicates unambiguously that a task should not be requeued by
other processors. This flag is cleared only when the job completion is
being processed, which always happens while holding the appropriate
scheduler locks, which closes the race window.

4 files changed, 17 insertions, 7 deletions

diff --git a/include/litmus/budget.h b/include/litmus/budget.h
index c4e9e40a828e..a766781b87d4 100644
--- a/include/litmus/budget.h
+++ b/include/litmus/budget.h
@@ -29,7 +29,8 @@ 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 && !is_completed(t) && (!budget_exhausted(t) || !budget_enforced(t));
+        return t && !is_completed(t) && !tsk_rt(t)->dont_requeue
+                && (!budget_exhausted(t) || !budget_enforced(t));
 }
 
 #endif
diff --git a/include/litmus/rt_param.h b/include/litmus/rt_param.h
index 0b40b23a8589..bd2baf1e306c 100644
--- a/include/litmus/rt_param.h
+++ b/include/litmus/rt_param.h
@@ -182,6 +182,10 @@ struct rt_param {
         /* has the task completed? */
         unsigned int            completed:1;
 
+        /* prevent this task from being requeued on another processor (used to
+         * coordinate GSN-EDF, C-EDF, and sync.c) */
+        unsigned int            dont_requeue:1;
+
 #ifdef CONFIG_LITMUS_LOCKING
         /* Is the task being priority-boosted by a locking protocol? */
         unsigned int            priority_boosted:1;
diff --git a/litmus/jobs.c b/litmus/jobs.c
index 3edb7ab4af60..32685012503b 100644
--- a/litmus/jobs.c
+++ b/litmus/jobs.c
@@ -32,6 +32,7 @@ void prepare_for_next_period(struct task_struct *t)
                 (long long)t->rt_param.job_params.deadline;
 
         setup_release(t, get_release(t) + get_rt_period(t));
+        tsk_rt(t)->dont_requeue = 0;
 }
 
 void release_at(struct task_struct *t, lt_t start)
diff --git a/litmus/sync.c b/litmus/sync.c
index 8ff5b9e298eb..61a95463e4d2 100644
--- a/litmus/sync.c
+++ b/litmus/sync.c
@@ -52,18 +52,22 @@ static long do_wait_for_ts_release(void)
         if (!ret) {
                 /* Setting this flag before releasing ensures that this CPU
                  * will be the next CPU to requeue the task on a ready or
-                 * release queue.
+                 * release queue. Cleared by prepare_for_next_period()
                  */
-                tsk_rt(current)->completed = 1;
-                mb();
+                tsk_rt(current)->dont_requeue = 1;
 
-                /* Completion succeeded, setup release. */
+                /* Completion succeeded, setup release time. complete_job()
+                 * will indirectly cause the period to be added to the next
+                 * release time, so subtract it here. */
                 litmus->release_at(current, wait.ts_release_time
                                    + current->rt_param.task_params.phase
                                    - current->rt_param.task_params.period);
 
-                schedule();
-                ret = 0;
+                /* Advance to next job --- when complete_job() returns, the
+                 * first job has been released. Since we patched up the release
+                 * time, this occurs when all tasks synchronously release their
+                 * first job.*/
+                ret = complete_job();
         } else {
                 /* We were interrupted, must cleanup list. */
                 mutex_lock(&task_release_lock);