modifications for easier debugging

1 files changed, 17 insertions, 11 deletions

diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index 457bd2a94a29..eb5728c97c87 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -127,6 +127,10 @@ cpu_entry_t* mc_cpus[NR_CPUS];
 
 #define tsk_mc_data(t) (tsk_rt(t)->mc_data)
 #define tsk_mc_crit(t) (tsk_mc_data(t)->mc_task.crit)
+#define TRACE_TASK(t, fmt, args...)                     \
+        TRACE("(%s/%d:%d:%d) " fmt, (t)->comm, (t)->pid,        \
+              (t)->rt_param.job_params.job_no, \
+              (tsk_mc_data(t)) ? tsk_mc_crit(t) : -1, ##args)
 
 /* need to do a short-circuit null check on mc_data before checking is_ghost */
 static inline int is_ghost(struct task_struct *t)
@@ -328,15 +332,14 @@ static void update_ghost_time(struct task_struct *p)
                 TRACE_TASK(p, "WARNING: negative time delta.\n");
         }
         if (tsk_mc_data(p)->mc_job.ghost_budget <= delta) {
-                /*Currently will just set ghost budget to zero since
+                /* Currently will just set ghost budget to zero since
                  * task has already been queued.  Could probably do
                  * more efficiently with significant reworking.
                  */
                 TRACE_TASK(p, "Ghost job could have ended\n");
                 tsk_mc_data(p)->mc_job.ghost_budget = 0;
                 p->se.exec_start = clock;
-        }
-        else{
+        } else {
                 TRACE_TASK(p, "Ghost jub updated, but didn't finish\n");
                 tsk_mc_data(p)->mc_job.ghost_budget -= delta;
                 p->se.exec_start = clock;
@@ -397,6 +400,7 @@ static noinline void link_task_to_cpu(struct task_struct* linked,
                                 entry->cpu);
                 BUG_ON(entry->linked &&
                         tsk_mc_crit(entry->linked) < tsk_mc_crit(linked));
+
                 tmp = entry->ghost_tasks[tsk_mc_crit(linked)];
                 if (tmp) {
                         unlink(tmp);
@@ -578,9 +582,7 @@ static void preempt(cpu_entry_t *entry)
  */
 static noinline void requeue(struct task_struct* task)
 {
-/*      BUG_ON(!task || !is_realtime(task));*/
-        BUG_ON(!task);
-        BUG_ON(!is_realtime(task));
+        BUG_ON(!task || !is_realtime(task));
         /* sanity check before insertion */
         BUG_ON(is_queued(task));
 
@@ -623,8 +625,9 @@ static void prepare_preemption(rt_domain_t *dom, cpu_entry_t *cpu,
 }
 
 /* Callers always have global lock for functions in this section*/
-static void check_for_c_preemptions(rt_domain_t *dom) {
+static noinline void check_for_c_preemptions(rt_domain_t *dom) {
         cpu_entry_t* last;
+        TRACE("Checking for c preempt");
         for (last = lowest_prio_cpu_c();
                         mc_edf_preemption_needed(dom, CRIT_LEVEL_C, 
                                         last);
@@ -633,8 +636,9 @@ static void check_for_c_preemptions(rt_domain_t *dom) {
         }
 }
 
-static void check_for_d_preemptions(rt_domain_t *dom) {
+static noinline void check_for_d_preemptions(rt_domain_t *dom) {
         cpu_entry_t* last;
+        TRACE("Checking for d preempt");
         for (last = lowest_prio_cpu_d();
                         mc_edf_preemption_needed(dom, CRIT_LEVEL_D, 
                                         last);
@@ -643,13 +647,15 @@ static void check_for_d_preemptions(rt_domain_t *dom) {
         }
 }
 
-static void check_for_a_preemption(rt_domain_t *dom, cpu_entry_t *cpu) {
+static noinline void check_for_a_preemption(rt_domain_t *dom, cpu_entry_t *cpu) {
+        TRACE("Checking for a preempt");
         if (mc_edf_preemption_needed(dom, CRIT_LEVEL_A, cpu)) {
                 prepare_preemption(dom, cpu, CRIT_LEVEL_A);
         }
 }
 
-static void check_for_b_preemption(rt_domain_t *dom, cpu_entry_t *cpu) {
+static noinline void check_for_b_preemption(rt_domain_t *dom, cpu_entry_t *cpu) {
+        TRACE("Checking for b preempt");
         if (mc_edf_preemption_needed(dom, CRIT_LEVEL_B, cpu)) {
                 prepare_preemption(dom, cpu, CRIT_LEVEL_B);
         }
@@ -733,7 +739,7 @@ static noinline void job_completion(struct task_struct *t, int forced)
          * needed.
          */
         if (!is_ghost(t)) {
-                TRACE_TASK(t, "Converting to ghost.\n");
+                TRACE_TASK(t, "Converting to ghost from %d.\n", t->rt_param.scheduled_on);
                 cpu = remote_cpu_entry(t->rt_param.scheduled_on);
                 /*Unlink first while it's not a ghost job.*/
                 unlink(t);