1 files changed, 41 insertions, 11 deletions

diff --git a/litmus/sched_psn_edf.c b/litmus/sched_psn_edf.c
index 3a93124e24f6..4829653b8f76 100644
--- a/litmus/sched_psn_edf.c
+++ b/litmus/sched_psn_edf.c
@@ -26,6 +26,13 @@ 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
  */
@@ -51,6 +58,7 @@ 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)
@@ -140,22 +148,36 @@ static struct task_struct* psnedf_schedule(struct task_struct * prev)
 
         /* (0) Determine state */
         exists      = pedf->scheduled != NULL;
-        blocks      = exists && !is_running(pedf->scheduled);
+        /* 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));
         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.
@@ -266,6 +288,7 @@ 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);
@@ -273,12 +296,18 @@ static void psnedf_task_block(struct task_struct *t)
         BUG_ON(!is_realtime(t));
         BUG_ON(is_queued(t));
 
-        /* if this task is dead, then we need to reset pedf->schedule now
-         * as we might get rescheduled before task_exit executes
+        /* 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(unlikely(t->state == TASK_DEAD)) {
-                TRACE_TASK(t, "Dead, setting scheduled = NULL\n");
+        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;
                 pedf->scheduled = NULL;
+                spin_unlock_irqrestore(&pedf->slock, flags);
         }
 }
 
@@ -347,6 +376,7 @@ static long psnedf_pi_block(struct pi_semaphore *sem,
 
                 spin_unlock(&pedf->slock);
         }
+        TRACE_TASK(sem->holder, "psnedf_pi_block\n");
 
         return 0;
 }