Changed completion flag use to remove race condition in Cedf,Gedf.

5 files changed, 14 insertions, 8 deletions

diff --git a/include/litmus/budget.h b/include/litmus/budget.h
index 33344ee8d5f9..c4e9e40a828e 100644
--- a/include/litmus/budget.h
+++ b/include/litmus/budget.h
@@ -29,7 +29,7 @@ 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));
+        return t && !is_completed(t) && (!budget_exhausted(t) || !budget_enforced(t));
 }
 
 #endif
diff --git a/litmus/jobs.c b/litmus/jobs.c
index 13a4ed4c9e93..3edb7ab4af60 100644
--- a/litmus/jobs.c
+++ b/litmus/jobs.c
@@ -28,7 +28,7 @@ void prepare_for_next_period(struct task_struct *t)
          * release and deadline. Lateness may be negative.
          */
         t->rt_param.job_params.lateness =
-                (long long)litmus_clock() - 
+                (long long)litmus_clock() -
                 (long long)t->rt_param.job_params.deadline;
 
         setup_release(t, get_release(t) + get_rt_period(t));
diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index 6e1327bbf504..91f7c6f91dc4 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -171,7 +171,6 @@ static noinline void link_task_to_cpu(struct task_struct* linked,
 
         /* Link new task to CPU. */
         if (linked) {
-                tsk_rt(linked)->completed = 0;
                 /* handle task is already scheduled somewhere! */
                 on_cpu = linked->rt_param.scheduled_on;
                 if (on_cpu != NO_CPU) {
@@ -350,7 +349,7 @@ static noinline void job_completion(struct task_struct *t, int forced)
         TRACE_TASK(t, "job_completion().\n");
 
         /* set flags */
-        tsk_rt(t)->completed = 1;
+        tsk_rt(t)->completed = 0;
         /* prepare for next period */
         prepare_for_next_period(t);
         if (is_early_releasing(t) || is_released(t, litmus_clock()))
diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index 5956978ccdbe..04454e8ce51e 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -173,7 +173,6 @@ static noinline void link_task_to_cpu(struct task_struct* linked,
 
         /* Link new task to CPU. */
         if (linked) {
-                tsk_rt(linked)->completed = 0;
                 /* handle task is already scheduled somewhere! */
                 on_cpu = linked->rt_param.scheduled_on;
                 if (on_cpu != NO_CPU) {
@@ -341,7 +340,7 @@ static noinline void job_completion(struct task_struct *t, int forced)
         TRACE_TASK(t, "job_completion().\n");
 
         /* set flags */
-        tsk_rt(t)->completed = 1;
+        tsk_rt(t)->completed = 0;
         /* prepare for next period */
         prepare_for_next_period(t);
         if (is_early_releasing(t) || is_released(t, litmus_clock()))
diff --git a/litmus/sync.c b/litmus/sync.c
index 3e79e0a12a5a..88a050e10ee7 100644
--- a/litmus/sync.c
+++ b/litmus/sync.c
@@ -50,12 +50,20 @@ static long do_wait_for_ts_release(void)
         ret = wait_for_completion_interruptible(&wait.completion);
 
         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.
+                 */
+                tsk_rt(current)->completed = 1;
+                mb();
+
                 /* Completion succeeded, setup release. */
                 litmus->release_at(current, wait.ts_release_time
                                    + current->rt_param.task_params.phase
                                    - current->rt_param.task_params.period);
-                /* trigger advance to next job release at the programmed time */
-                ret = complete_job();
+
+                schedule();
+                ret = 0;
         } else {
                 /* We were interrupted, must cleanup list. */
                 mutex_lock(&task_release_lock);