Fixed a timer bug and implemented finish switch.

The logic for cancelling a remote timer allowed timers to be
enqueued twice in the pull list. A method hrtimer_pull_cancel() was
added to hrtimer.c to cancel the timers properly.

Finish-switch was added to fix a stack bug. This required a change
to the global_preempt check in update_crit_levels

4 files changed, 53 insertions, 15 deletions

diff --git a/include/linux/hrtimer.h b/include/linux/hrtimer.h
index 76da541c1f66..573cb3419625 100644
--- a/include/linux/hrtimer.h
+++ b/include/linux/hrtimer.h
@@ -378,6 +378,8 @@ extern void hrtimer_start_on_info_init(struct hrtimer_start_on_info *info);
 extern int hrtimer_start_on(int cpu, struct hrtimer_start_on_info *info,
                         struct hrtimer *timer, ktime_t time,
                         const enum hrtimer_mode mode);
+extern void hrtimer_pull_cancel(int cpu, struct hrtimer *timer,
+                                struct hrtimer_start_on_info *info);
 #endif
 
 extern int hrtimer_cancel(struct hrtimer *timer);
diff --git a/kernel/hrtimer.c b/kernel/hrtimer.c
index 94cf1c0e44c3..a8c3135dfed5 100644
--- a/kernel/hrtimer.c
+++ b/kernel/hrtimer.c
@@ -1053,6 +1053,7 @@ void hrtimer_start_on_info_init(struct hrtimer_start_on_info *info)
 {
         memset(info, 0, sizeof(struct hrtimer_start_on_info));
         atomic_set(&info->state, HRTIMER_START_ON_INACTIVE);
+        INIT_LIST_HEAD(&info->list);
 }
 
 /**
@@ -1071,7 +1072,7 @@ void hrtimer_pull(void)
         list_for_each_safe(pos, safe, &list) {
                 info = list_entry(pos, struct hrtimer_start_on_info, list);
                 TRACE("pulled timer 0x%x\n", info->timer);
-                list_del(pos);
+                list_del_init(pos);
                 if (atomic_read(&info->state) != HRTIMER_START_ON_INACTIVE)
                         hrtimer_start(info->timer, info->time, info->mode);
                 if (atomic_read(&info->state) == HRTIMER_START_ON_INACTIVE)
@@ -1080,6 +1081,22 @@ void hrtimer_pull(void)
 }
 
 /**
+ * hrtimer_pull_cancel - Cancel a remote timer pull
+ */
+void hrtimer_pull_cancel(int cpu, struct hrtimer *timer,
+                         struct hrtimer_start_on_info *info)
+{
+        struct hrtimer_cpu_base *base = &per_cpu(hrtimer_bases, cpu);
+
+        raw_spin_lock(&base->lock);
+        list_del_init(&info->list);
+        raw_spin_unlock(&base->lock);
+
+        atomic_set(&info->state, HRTIMER_START_ON_INACTIVE);
+        hrtimer_try_to_cancel(timer);
+}
+
+/**
  *  hrtimer_start_on - trigger timer arming on remote cpu
  *  @cpu:       remote cpu
  *  @info:      save timer information for enqueuing on remote cpu
@@ -1088,8 +1105,8 @@ void hrtimer_pull(void)
  *  @mode:      timer mode
  */
 int hrtimer_start_on(int cpu, struct hrtimer_start_on_info* info,
-                struct hrtimer *timer, ktime_t time,
-                const enum hrtimer_mode mode)
+                     struct hrtimer *timer, ktime_t time,
+                     const enum hrtimer_mode mode)
 {
         unsigned long flags;
         struct hrtimer_cpu_base* base;
diff --git a/litmus/event_group.c b/litmus/event_group.c
index 0535f9f9bf96..518ccb459137 100644
--- a/litmus/event_group.c
+++ b/litmus/event_group.c
@@ -233,8 +233,9 @@ void cancel_event(struct rt_event *e)
                 }
 
                 /* Disable the event_list */
-                atomic_set(&e->event_list->info.state, HRTIMER_START_ON_INACTIVE);
-                hrtimer_try_to_cancel(&e->event_list->timer);
+                hrtimer_pull_cancel(group->cpu,
+                                    &e->event_list->timer,
+                                    &e->event_list->info);
                 list_del_init(&e->event_list->queue_node);
         } else {
                 VTRACE("List 0x%p is empty\n", e->event_list);
@@ -253,6 +254,7 @@ struct event_list* event_list_alloc(int gfp_flags)
                 hrtimer_init(&el->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
                 INIT_LIST_HEAD(&el->queue_node);
                 el->timer.function = on_timer;
+                hrtimer_start_on_info_init(&el->info);
         } else {
                 VTRACE("Failed to allocate event list!\n");
                 printk(KERN_CRIT "Failed to allocate event list.\n");
diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index 100470d302a1..277762709d3d 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -440,9 +440,14 @@ static void update_crit_levels(struct cpu_entry *entry)
         for (i = level + 1; i < NUM_CRIT_LEVELS; i++) {
                 ce = &entry->crit_entries[i];
 
-                global_preempted = entry->scheduled == ce->linked &&
-                        ce->linked && entry->linked &&
+                global_preempted = ce->linked &&
+                        /* This task is running */
+                        ce->linked->rt_param.scheduled_on == entry->cpu &&
+                        /* But it was preempted */
+                        ce->linked != entry->linked &&
+                        /* And it is an eligible global task */
                         !is_ghost(ce->linked) && is_global(ce->domain);
+
                 /* Do not readmit global tasks which are preempted! These can't
                  * ever be re-admitted until they are descheduled for reasons
                  * explained in job_arrival.
@@ -857,7 +862,7 @@ out:
 /**
  * mc_schedule() - Return next task which should be scheduled.
  */
-static struct task_struct* mc_schedule(struct task_struct * prev)
+static struct task_struct* mc_schedule(struct task_struct* prev)
 {
         unsigned long flags;
         struct domain *dom;
@@ -867,6 +872,11 @@ static struct task_struct* mc_schedule(struct task_struct * prev)
         struct task_struct *dtask = NULL, *ready_task = NULL, *next = NULL;
 
         local_irq_save(flags);
+        raw_spin_lock(&entry->lock);
+
+        if (entry->scheduled) {
+                TRACE_TASK(entry->scheduled, " and prev is %d\n", prev->pid);
+        }
 
         /* Sanity checking */
         BUG_ON(entry->scheduled && entry->scheduled != prev);
@@ -874,7 +884,6 @@ static struct task_struct* mc_schedule(struct task_struct * prev)
         BUG_ON(is_realtime(prev) && !entry->scheduled);
 
         /* Determine state */
-        raw_spin_lock(&entry->lock);
         exists      = entry->scheduled != NULL;
         blocks      = exists && !is_running(entry->scheduled);
         out_of_time = exists && budget_enforced(entry->scheduled) &&
@@ -885,11 +894,12 @@ static struct task_struct* mc_schedule(struct task_struct * prev)
         lower       = exists && preempt && entry->linked &&
                 tsk_mc_crit(entry->scheduled) > tsk_mc_crit(entry->linked);
 
-        if (exists) {
-                entry->scheduled->rt_param.scheduled_on = NO_CPU;
-        }
         TRACE(TS " blocks:%d out_of_time:%d sleep:%d preempt:%d\n",
               TA(prev), blocks, out_of_time, sleep, preempt);
+
+        if (exists)
+                prev->rt_param.scheduled_on = NO_CPU;
+
         raw_spin_unlock(&entry->lock);
 
 
@@ -953,9 +963,8 @@ static struct task_struct* mc_schedule(struct task_struct * prev)
 
         /* Schedule next task */
         next = entry->linked;
-        entry->scheduled = next;
-        if (entry->scheduled)
-                entry->scheduled->rt_param.scheduled_on = entry->cpu;
+        if (entry->linked)
+                entry->linked->rt_param.scheduled_on = entry->cpu;
         sched_state_task_picked();
 
         raw_spin_unlock(&entry->lock);
@@ -967,6 +976,13 @@ static struct task_struct* mc_schedule(struct task_struct * prev)
         return next;
 }
 
+void mc_finish_switch(struct task_struct *prev)
+{
+        struct cpu_entry* entry = &__get_cpu_var(cpus);
+        entry->scheduled = is_realtime(current) ? current : NULL;
+        TRACE_TASK(prev, "Switched away from\n");
+}
+
 /*
  * This is the plugin's release at function, called by the release task-set
  * system call. Other places in the file use the generic LITMUS release_at(),
@@ -1060,6 +1076,7 @@ static struct sched_plugin mc_plugin __cacheline_aligned_in_smp = {
         .activate_plugin        = mc_activate_plugin,
         .release_at             = mc_release_at,
         .deactivate_plugin      = mc_deactivate_plugin,
+        .finish_switch          = mc_finish_switch,
 };
 
 static void init_crit_entry(struct crit_entry *ce, enum crit_level level,