1 files changed, 27 insertions, 5 deletions

diff --git a/litmus/preempt.c b/litmus/preempt.c
index 6be2f26728b8..86ad2efb591a 100644
--- a/litmus/preempt.c
+++ b/litmus/preempt.c
@@ -27,10 +27,12 @@ void sched_state_will_schedule(struct task_struct* tsk)
                         set_sched_state(PICKED_WRONG_TASK);
                 else
                         set_sched_state(WILL_SCHEDULE);
-        } else
+        } else {
                 /* Litmus tasks should never be subject to a remote
                  * set_tsk_need_resched(). */
-                BUG_ON(is_realtime(tsk));
+                //BUG_ON(is_realtime(tsk));
+        }
+
 #ifdef CONFIG_PREEMPT_STATE_TRACE
         TRACE_TASK(tsk, "set_tsk_need_resched() ret:%p\n",
                    __builtin_return_address(0));
@@ -46,14 +48,18 @@ void sched_state_ipi(void)
                 /* Cause scheduler to be invoked.
                  * This will cause a transition to WILL_SCHEDULE. */
                 set_tsk_need_resched(current);
+                /*
                 TRACE_STATE("IPI -> set_tsk_need_resched(%s/%d)\n",
                             current->comm, current->pid);
+                */
                 TS_SEND_RESCHED_END;
         } else {
                 /* ignore */
+                /*
                 TRACE_STATE("ignoring IPI in state %x (%s)\n",
                             get_sched_state(),
                             sched_state_name(get_sched_state()));
+                */
         }
 }
 
@@ -70,23 +76,34 @@ void litmus_reschedule(int cpu)
          * is not aware of the need to reschedule at this point. */
 
         /* is a context switch in progress? */
-        if (cpu_is_in_sched_state(cpu, TASK_PICKED))
+        if (cpu_is_in_sched_state(cpu, TASK_PICKED)) {
                 picked_transition_ok = sched_state_transition_on(
                         cpu, TASK_PICKED, PICKED_WRONG_TASK);
 
+                TRACE_CUR("cpu %d: picked_transition_ok = %d\n", cpu, picked_transition_ok);
+        }
+        else {
+                TRACE_CUR("cpu %d: picked_transition_ok = 0 (static)\n", cpu);
+        }
+
         if (!picked_transition_ok &&
             cpu_is_in_sched_state(cpu, TASK_SCHEDULED)) {
                 /* We either raced with the end of the context switch, or the
                  * CPU was in TASK_SCHEDULED anyway. */
                 scheduled_transition_ok = sched_state_transition_on(
                         cpu, TASK_SCHEDULED, SHOULD_SCHEDULE);
+                TRACE_CUR("cpu %d: scheduled_transition_ok = %d\n", cpu, scheduled_transition_ok);
+        }
+        else {
+                TRACE_CUR("cpu %d: scheduled_transition_ok = 0 (static)\n", cpu);
         }
 
         /* If the CPU was in state TASK_SCHEDULED, then we need to cause the
          * scheduler to be invoked. */
         if (scheduled_transition_ok) {
-                if (smp_processor_id() == cpu)
+                if (smp_processor_id() == cpu) {
                         set_tsk_need_resched(current);
+                }
                 else {
                         TS_SEND_RESCHED_START(cpu);
                         smp_send_reschedule(cpu);
@@ -101,11 +118,16 @@ void litmus_reschedule(int cpu)
 
 void litmus_reschedule_local(void)
 {
-        if (is_in_sched_state(TASK_PICKED))
+        if (is_in_sched_state(TASK_PICKED)) {
                 set_sched_state(PICKED_WRONG_TASK);
+
+                TRACE_CUR("cpu %d: transitioned to PICKED_WRONG_TASK\n", smp_processor_id());
+        }
         else if (is_in_sched_state(TASK_SCHEDULED | SHOULD_SCHEDULE)) {
                 set_sched_state(WILL_SCHEDULE);
                 set_tsk_need_resched(current);
+
+                TRACE_CUR("cpu %d: transitioned to WILL_SCHEDULE\n", smp_processor_id());
         }
 }