Revert "Bugfix: PSN-EDF task_block flow-path may race with schedule()"

This reverts commit 851baec36d80e7ee279c69677b113428d20562c8.

1 files changed, 11 insertions, 40 deletions

diff --git a/litmus/sched_psn_edf.c b/litmus/sched_psn_edf.c
index 7b0740b1c58a..3a93124e24f6 100644
--- a/litmus/sched_psn_edf.c
+++ b/litmus/sched_psn_edf.c
@@ -26,13 +26,6 @@ typedef struct {
         int                     cpu;
         struct task_struct*     scheduled; /* only RT tasks */
 /*
- * A block event (mainly during synchronous release) may race
- * with other releases or with triggering of the schedule() function.
- * We need to trace a previous blocking event in the first execution of
- * schedule()
- */
-        int                     block;
-/*
  * scheduling lock slock
  * protects the domain and serializes scheduling decisions
  */
@@ -58,7 +51,6 @@ static void psnedf_domain_init(psnedf_domain_t* pedf,
         edf_domain_init(&pedf->domain, check, release);
         pedf->cpu               = cpu;
         pedf->scheduled         = NULL;
-        pedf->block             = 0;
 }
 
 static void requeue(struct task_struct* t, rt_domain_t *edf)
@@ -148,36 +140,22 @@ static struct task_struct* psnedf_schedule(struct task_struct * prev)
 
         /* (0) Determine state */
         exists      = pedf->scheduled != NULL;
-        /* a task may block if 1) the task exists but is no more running
-         * 2) the task blocked and this schedule is racing with it while
-         * it is going to sleep. In this case pedf->schedule != prev (and we
-         * already reset pedf->schedule to NULL), but nonetheless we want to
-         * pick a real-time task as next (if such a task exists in the ready
-         * queue).
-         */
-        blocks      = pedf->block || (exists && !is_running(pedf->scheduled));
+        blocks      = exists && !is_running(pedf->scheduled);
         out_of_time = exists && budget_exhausted(pedf->scheduled);
         np          = exists && is_np(pedf->scheduled);
         sleep       = exists && get_rt_flags(pedf->scheduled) == RT_F_SLEEP;
         preempt     = edf_preemption_needed(edf, prev);
 
+        /* If we need to preempt do so.
+         * The following checks set resched to 1 in case of special
+         * circumstances.
+         */
+        resched = preempt;
 
         /* If a task blocks we have no choice but to reschedule.
          */
-        if (blocks) {
-
+        if (blocks)
                 resched = 1;
-                /* reset the block flag, we are about to reschedule */
-                pedf->block = 0;
-        } else {
-
-                /* If we need to preempt do so.
-                 * The following checks set resched to 1 in case of special
-                 * circumstances.
-                 */
-                resched = preempt;
-        }
-
 
         /* Request a sys_exit_np() call if we would like to preempt but cannot.
          * Multiple calls to request_exit_np() don't hurt.
@@ -288,7 +266,6 @@ static void psnedf_task_wake_up(struct task_struct *task)
 static void psnedf_task_block(struct task_struct *t)
 {
         psnedf_domain_t *pedf = task_pedf(t);
-        unsigned long flags;
 
         /* only running tasks can block, thus t is in no queue */
         TRACE_TASK(t, "block at %llu, state=%d\n", litmus_clock(), t->state);
@@ -296,18 +273,12 @@ static void psnedf_task_block(struct task_struct *t)
         BUG_ON(!is_realtime(t));
         BUG_ON(is_queued(t));
 
-        /* if this task is no more runnable, then we need to reset pedf->schedule
-         * and set the block flag as another schedule() may race wotj is while
-         * we are going to sleep
+        /* if this task is dead, then we need to reset pedf->schedule now
+         * as we might get rescheduled before task_exit executes
          */
-        if(likely(t->state != TASK_RUNNING)) {
-
-                TRACE_TASK(t, "psnedf_task_block, setting block flag\n");
-
-                spin_lock_irqsave(&pedf->slock, flags);
-                pedf->block = 1;
+        if(unlikely(t->state == TASK_DEAD)) {
+                TRACE_TASK(t, "Dead, setting scheduled = NULL\n");
                 pedf->scheduled = NULL;
-                spin_unlock_irqrestore(&pedf->slock, flags);
         }
 }