LITMUS^RT core: add next_became_invalid() callback

3 files changed, 22 insertions, 33 deletions

diff --git a/include/litmus/sched_plugin.h b/include/litmus/sched_plugin.h
index 1906a139e6e9..2021e817b243 100644
--- a/include/litmus/sched_plugin.h
+++ b/include/litmus/sched_plugin.h
@@ -35,6 +35,11 @@ typedef void (*finish_switch_t)(struct task_struct *prev);
  * the scheduler is invoked again. */
 typedef bool (*should_wait_for_stack_t)(struct task_struct *next);
 
+/* After dropping the lock to facilitate a pull migration, the task
+ * state may have changed. In this case, the core notifies the plugin
+ * with this callback and then invokes the scheduler again. */
+typedef void (*next_became_invalid_t)(struct task_struct *next);
+
 /********************* task state changes ********************/
 
 /* Called to setup a new real-time task.
@@ -109,7 +114,10 @@ struct sched_plugin {
         /*      scheduler invocation    */
         schedule_t              schedule;
         finish_switch_t         finish_switch;
+
+        /* control over pull migrations */
         should_wait_for_stack_t should_wait_for_stack;
+        next_became_invalid_t next_became_invalid;
 
         /*      syscall backend         */
         complete_job_t          complete_job;
diff --git a/kernel/sched/litmus.c b/kernel/sched/litmus.c
index 4fa5a941a284..8eb9df31ea01 100644
--- a/kernel/sched/litmus.c
+++ b/kernel/sched/litmus.c
@@ -121,45 +121,21 @@ litmus_schedule(struct rq *rq, struct task_struct *prev)
                 }
 #endif
                 double_rq_lock(rq, other_rq);
-                mb();
-                if (is_realtime(current) && is_current_running() != was_running) {
-                        TRACE_TASK(prev,
-                                   "state changed while we dropped"
-                                   " the lock: is_running=%d, was_running=%d\n",
-                                   is_current_running(), was_running);
-                        if (is_current_running() && !was_running) {
-                                /* prev task became unblocked
-                                 * we need to simulate normal sequence of events
-                                 * to scheduler plugins.
-                                 */
-                                litmus->task_block(prev);
-                                litmus->task_wake_up(prev);
-                        }
-                }
-
                 set_task_cpu(next, smp_processor_id());
-
-                /* DEBUG: now that we have the lock we need to make sure a
-                 *  couple of things still hold:
-                 *  - it is still a real-time task
-                 *  - it is still runnable (could have been stopped)
-                 * If either is violated, then the active plugin is
-                 * doing something wrong.
-                 */
-                if (!is_realtime(next) || !tsk_rt(next)->present) {
-                        /* BAD BAD BAD */
-                        TRACE_TASK(next,"BAD: migration invariant FAILED: "
-                                   "rt=%d present=%d\n",
-                                   is_realtime(next),
-                                   tsk_rt(next)->present);
-                        /* drop the task */
-                        next = NULL;
-                }
                 /* release the other CPU's runqueue, but keep ours */
                 raw_spin_unlock(&other_rq->lock);
         }
 #endif
 
+        /* check if the task became invalid while we dropped the lock */
+        if (next && (!is_realtime(next) || !tsk_rt(next)->present)) {
+                TRACE_TASK(next,
+                        "BAD: next (no longer?) valid\n");
+                litmus->next_became_invalid(next);
+                litmus_reschedule_local();
+                next = NULL;
+        }
+
         if (next) {
 #ifdef CONFIG_SMP
                 next->rt_param.stack_in_use = rq->cpu;
diff --git a/litmus/sched_plugin.c b/litmus/sched_plugin.c
index 4007e5129e80..1ff9516cbbfc 100644
--- a/litmus/sched_plugin.c
+++ b/litmus/sched_plugin.c
@@ -75,6 +75,10 @@ static bool litmus_dummy_should_wait_for_stack(struct task_struct *next)
         return true; /* by default, wait indefinitely */
 }
 
+static void litmus_dummy_next_became_invalid(struct task_struct *next)
+{
+}
+
 static long litmus_dummy_admit_task(struct task_struct* tsk)
 {
         printk(KERN_CRIT "LITMUS^RT: Linux plugin rejects %s/%d.\n",
@@ -192,6 +196,7 @@ int register_sched_plugin(struct sched_plugin* plugin)
         CHECK(finish_switch);
         CHECK(schedule);
         CHECK(should_wait_for_stack);
+        CHECK(next_became_invalid);
         CHECK(task_wake_up);
         CHECK(task_exit);
         CHECK(task_cleanup);