1 files changed, 34 insertions, 29 deletions

diff --git a/litmus/sched_mc_ce.c b/litmus/sched_mc_ce.c
index c799738c0090..9f6929e55ab2 100644
--- a/litmus/sched_mc_ce.c
+++ b/litmus/sched_mc_ce.c
@@ -118,9 +118,9 @@ unsigned int mc_ce_get_expected_job(const int cpu, const int idx)
 static inline lt_t get_cycle_offset(const lt_t when, const lt_t cycle_time)
 {
         long long st = atomic64_read(&start_time);
-        //lt_t offset = (when - st) % cycle_time;
-        lt_t offset = 0;
-        TRACE("when: %llu  cycle_time: %llu start_time: %lld  offset %llu\n",
+        lt_t offset = (when - st) % cycle_time;
+        /* lt_t offset = 0; */
+        STRACE("when: %llu  cycle_time: %llu start_time: %lld  offset %llu\n",
                         when, cycle_time, st, offset);
         return offset;
 }
@@ -138,7 +138,7 @@ void mc_ce_job_completion(struct domain *dom, struct task_struct *ts)
         const struct ce_pid_entry *pid_entry = get_pid_entry(cpu, idx);
         unsigned int just_finished;
 
-        TRACE_TASK(ts, "Completed\n");
+        TRACE_MC_TASK(ts, "Completed\n");
 
         /* sched_trace_task_completion(ts, 0); */
         /* post-increment is important here */
@@ -152,13 +152,13 @@ void mc_ce_job_completion(struct domain *dom, struct task_struct *ts)
         if (just_finished < pid_entry->expected_job) {
                 /* this job is already released because it's running behind */
                 set_rt_flags(ts, RT_F_RUNNING);
-                TRACE_TASK(ts, "appears behind: the expected job is %u but "
+                TRACE_MC_TASK(ts, "appears behind: the expected job is %u but "
                                 "job %u just completed\n",
                                 pid_entry->expected_job, just_finished);
         } else if (pid_entry->expected_job < just_finished) {
-                printk(KERN_CRIT "job %u completed in expected job %u which "
-                                "seems too early\n", just_finished,
-                                pid_entry->expected_job);
+                TRACE_MC_TASK(ts, "job %u completed in expected job %u which "
+                              "seems too early\n", just_finished,
+                              pid_entry->expected_job);
         }
 }
 
@@ -189,7 +189,7 @@ static int mc_ce_schedule_at(const struct domain *dom, lt_t offset)
         }
         /* can only happen if cycle_time is not right */
         BUG_ON(pid_entry->acc_time > pid_table->cycle_time);
-        TRACE("schedule at returning task %d for CPU %d\n", idx, ce_data->cpu);
+        STRACE("schedule at returning task %d for CPU %d\n", idx, ce_data->cpu);
         return idx;
 }
 
@@ -211,7 +211,7 @@ static struct task_struct *mc_ce_schedule(struct task_struct *prev)
         exists = NULL != ce_data->scheduled;
         sleep = exists && RT_F_SLEEP == get_rt_flags(ce_data->scheduled);
 
-        TRACE("exists: %d, sleep: %d\n", exists, sleep);
+        STRACE("exists: %d, sleep: %d\n", exists, sleep);
 
         if (sleep)
                 mc_ce_job_completion(dom, ce_data->scheduled);
@@ -226,7 +226,7 @@ static struct task_struct *mc_ce_schedule(struct task_struct *prev)
         should_sched_asleep = should_sched_exists &&
                 RT_F_SLEEP == get_rt_flags(ce_data->should_schedule);
 
-        TRACE("should_sched_exists: %d, should_sched_blocked: %d, "
+        STRACE("should_sched_exists: %d, should_sched_blocked: %d, "
                         "should_sched_asleep: %d\n", should_sched_exists,
                         should_sched_blocked, should_sched_asleep);
 
@@ -248,7 +248,7 @@ static void mc_ce_finish_switch(struct task_struct *prev)
         struct domain *dom = get_domain_for(smp_processor_id());
         struct ce_dom_data *ce_data = dom->data;
 
-        TRACE("finish switch\n");
+        STRACE("finish switch\n");
 
         if (is_realtime(current) && CRIT_LEVEL_A == tsk_mc_crit(current))
                 ce_data->scheduled = current;
@@ -495,19 +495,19 @@ lt_t mc_ce_timer_callback_common(struct domain *dom)
                 }
         }
 
-        if (ce_data->should_schedule) {
-                get_deadline(should_schedule) =
-                        cycle_start_abs + pid_entry->acc_time;
-                get_release(should_schedule) = tsk_rt(should_schedule)->job_params.deadline -
-                        pid_entry->budget;
-                tsk_rt(should_schedule)->job_params.exec_time = 0;
-
-                TRACE_MC_TASK(should_schedule, "Released!\n");
-                set_rt_flags(ce_data->should_schedule, RT_F_RUNNING);
-                sched_trace_task_release(should_schedule);
-                sched_trace_server_release(-should_schedule->pid, get_rt_job(should_schedule),
-                                           tsk_rt(should_schedule)->job_params);
-        }
+        /* if (ce_data->should_schedule) { */
+        /*      get_deadline(should_schedule) = */
+        /*              cycle_start_abs + pid_entry->acc_time; */
+        /*      get_release(should_schedule) = tsk_rt(should_schedule)->job_params.deadline - */
+        /*              pid_entry->budget; */
+        /*      tsk_rt(should_schedule)->job_params.exec_time = 0; */
+
+        /*      TRACE_MC_TASK(should_schedule, "Released!\n"); */
+        /*      set_rt_flags(ce_data->should_schedule, RT_F_RUNNING); */
+        /*         sched_trace_task_release(should_schedule); */
+        /*         sched_trace_server_release(-should_schedule->pid, get_rt_job(should_schedule), */
+        /*                                 tsk_rt(should_schedule)->job_params); */
+        /* } */
         return next_timer_abs;
 }
 
@@ -535,7 +535,7 @@ static enum hrtimer_restart mc_ce_timer_callback(struct hrtimer *timer)
 #endif
         dom = get_domain_for(ce_data->cpu);
 
-        TRACE("timer callback on CPU %d (before lock)\n", ce_data->cpu);
+        STRACE("timer callback on CPU %d (before lock)\n", ce_data->cpu);
 
         raw_spin_lock_irqsave(dom->lock, flags);
         next_timer_abs = mc_ce_timer_callback_common(dom);
@@ -569,7 +569,7 @@ static int cancel_all_timers(void)
         int cancel_res;
 #endif
 
-        TRACE("cancel all timers\n");
+        STRACE("cancel all timers\n");
 
         for_each_online_cpu(cpu) {
                 dom = get_domain_for(cpu);
@@ -579,6 +579,8 @@ static int cancel_all_timers(void)
                 cancel_event(&ce_data->event);
 #else
                 cancel_res = hrtimer_cancel(&ce_data->timer);
+                atomic_set(&ce_data->timer_info.state,
+                           HRTIMER_START_ON_INACTIVE);
                 ret = ret || cancel_res;
 #endif
         }
@@ -598,7 +600,7 @@ static void arm_all_timers(void)
         int cpu, idx, cpu_for_timer;
         const lt_t start = atomic64_read(&start_time);
 
-        TRACE("arm all timers\n");
+        STRACE("arm all timers\n");
 
         for_each_online_cpu(cpu) {
                 dom = get_domain_for(cpu);
@@ -619,6 +621,9 @@ static void arm_all_timers(void)
                 add_event(get_event_group_for(cpu_for_timer),
                                 &ce_data->event, start);
 #else
+                hrtimer_start_on(cpu_for_timer, &ce_data->timer_info,
+                                 &ce_data->timer, ns_to_ktime(start),
+                                 HRTIMER_MODE_ABS_PINNED);
 #endif
         }
 }
@@ -630,7 +635,7 @@ static void arm_all_timers(void)
  */
 void mc_ce_release_at_common(struct task_struct *ts, lt_t start)
 {
-        TRACE("release CE at %llu\n", start);
+        STRACE("release CE at %llu\n", start);
         if (atomic_inc_and_test(&start_time_set)) {
                 /* in this case, we won the race */
                 cancel_all_timers();