Debug commit.

Some things are working, but the kernel panics when you try and
deallocate an event group.

Committed so Jonathan can look at it.

5 files changed, 61 insertions, 23 deletions

diff --git a/litmus/event_group.c b/litmus/event_group.c
index 3b50e15bd354..a130a68c731a 100644
--- a/litmus/event_group.c
+++ b/litmus/event_group.c
@@ -30,7 +30,7 @@ static unsigned int time2slot(lt_t time)
 static enum hrtimer_restart on_timer(struct hrtimer *timer)
 {
         unsigned long flags;
-        int num = 0;
+        unsigned long num = 0;
         struct event_list *el;
         struct rt_event *e;
         struct list_head *pos, *safe, list;
@@ -50,7 +50,7 @@ static enum hrtimer_restart on_timer(struct hrtimer *timer)
         list_for_each_safe(pos, safe, &list) {
                 num++;
                 e = list_entry(pos, struct rt_event, list);
-                TRACE("Dequeueing event 0x%p with prio %d from 0x%p\n",
+                VTRACE("Dequeueing event 0x%p with prio %d from 0x%p\n",
                       e, e->prio, el);
                 list_del_init(pos);
                 e->function(e);
@@ -238,7 +238,7 @@ void cancel_event(struct rt_event *e)
         }
 }
 
-struct kmem_cache *event_list_cache, *event_cache;
+struct kmem_cache *event_list_cache;
 
 struct event_list* event_list_alloc(int gfp_flags)
 {
@@ -249,6 +249,8 @@ struct event_list* event_list_alloc(int gfp_flags)
                 el->timer.function = on_timer;
         } else {
                 VTRACE("Failed to allocate event list!");
+                printk(KERN_CRIT "Failed to allocate event list.\n");
+                BUG();
         }
         return el;
 }
diff --git a/litmus/litmus.c b/litmus/litmus.c
index deaaee3b3f20..f4d676c17d5f 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -46,6 +46,7 @@ extern struct kmem_cache *release_heap_cache;
 #ifdef CONFIG_MERGE_TIMERS
 extern struct kmem_cache *event_list_cache;
 #endif
+
 #ifdef CONFIG_PLUGIN_MC
 static struct kmem_cache *mc_data_cache;
 #endif
@@ -574,7 +575,7 @@ void exit_litmus(struct task_struct *dead_tsk)
          *  Check and free it here.
          */
         if (tsk_rt(dead_tsk)->mc_data)
-                kfree(tsk_rt(dead_tsk)->mc_data);
+                kmem_cache_free(mc_data_cache, tsk_rt(dead_tsk)->mc_data);
 #endif
 
         /* main cleanup only for RT tasks */
diff --git a/litmus/rt_domain.c b/litmus/rt_domain.c
index fbd91c829619..ffb3cab9cffd 100644
--- a/litmus/rt_domain.c
+++ b/litmus/rt_domain.c
@@ -100,12 +100,18 @@ struct release_heap* release_heap_alloc(int gfp_flags)
         return rh;
 }
 
+#ifdef CONFIG_MERGE_TIMERS
+extern struct kmem_cache *event_list_cache;
+#endif
+
 void release_heap_free(struct release_heap* rh)
 {
         /* make sure timer is no longer in use */
 #ifdef CONFIG_MERGE_TIMERS
-        /* if (rh->dom) */
-        /*      cancel_event(&rh->event); */
+        if (rh->dom) {
+                cancel_event(&rh->event);
+                kmem_cache_free(event_list_cache, rh->event.event_list);
+        }
 #else
         hrtimer_cancel(&rh->timer);
 #endif
diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index 17f84c9eba79..e20e97810847 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -27,8 +27,6 @@
 #include <litmus/sched_mc.h>
 #include <litmus/ce_domain.h>
 
-/* XXX TODO Do we ever want to move level-A timers? */
-
 /**
  * struct cpu_entry - State of a CPU for the entire MC system
  * @cpu           CPU id
@@ -50,6 +48,9 @@ struct cpu_entry {
         struct list_head        redir;
         raw_spinlock_t          redir_lock;
 #endif
+#ifdef CONFIG_MERGE_TIMERS
+        struct event_group *event_group;
+#endif
 };
 
 DEFINE_PER_CPU(struct cpu_entry, cpus);
@@ -141,7 +142,7 @@ static inline void cancel_ghost(struct crit_entry *ce)
 static inline void arm_ghost(struct crit_entry *ce, lt_t fire)
 {
 #ifdef CONFIG_MERGE_TIMERS
-        add_event(get_event_group_for(crit_cpu(ce)->cpu), &ce->event, fire);
+        add_event(crit_cpu(ce)->event_group, &ce->event, fire);
 #else
         __hrtimer_start_range_ns(&ce->timer,
                                  ns_to_ktime(fire),
@@ -298,7 +299,7 @@ static void fix_global_levels(void)
         struct list_head *pos, *safe;
         struct task_struct *t;
 
-        STRACE("Fixing global levels");
+        STRACE("Fixing global levels\n");
         for_each_online_cpu(c) {
                 e = &per_cpu(cpus, c);
                 raw_spin_lock(&e->redir_lock);
@@ -621,13 +622,12 @@ static void ce_timer_function(struct rt_event *e)
 {
         struct ce_dom_data *ce_data =
                 container_of(e, struct ce_dom_data, event);
-        struct event_group *event_group = get_event_group_for(ce_data->cpu);
         unsigned long flags;
         lt_t next_timer_abs;
 
         local_irq_save(flags);
         next_timer_abs = __ce_timer_function(ce_data);
-        add_event(event_group, e, next_timer_abs);
+        add_event(per_cpu(cpus, ce_data->cpu).event_group, e, next_timer_abs);
         local_irq_restore(flags);
 }
 #else /* else to CONFIG_MERGE_TIMERS */
@@ -945,13 +945,13 @@ static long mc_activate_plugin(void)
         struct domain_data *dom_data;
         struct domain *dom;
         struct domain_data *our_domains[NR_CPUS];
+        struct event_group *event_group;
         int cpu, n = 0;
         long ret;
 
 #ifdef CONFIG_RELEASE_MASTER
         interrupt_cpu = atomic_read(&release_master_cpu);
-#if defined(CONFIG_PLUGIN_MC_REDIRECT) || \
-    (defined(CONFIG_PLUGIN_MC_RELEASE_MASTER) && defined(CONFIG_MERGE_TIMERS))
+#if defined(CONFIG_PLUGIN_MC_REDIRECT) || defined(CONFIG_PLUGIN_MC_RELEASE_MASTER)
         if (NO_CPU == interrupt_cpu) {
                 printk(KERN_ERR "LITMUS-MC: need a release master\n");
                 ret = -EINVAL;
@@ -965,6 +965,12 @@ static long mc_activate_plugin(void)
                 dom = per_cpu(cpus, cpu).crit_entries[CRIT_LEVEL_A].domain;
                 dom_data = domain_data(dom);
                 our_domains[cpu] = dom_data;
+#if defined(CONFIG_MERGE_TIMERS) && defined(CONFIG_PLUGIN_MC_RELEASE_MASTER)
+                event_group = get_event_group_for(interrupt_cpu);
+#elif defined(CONFIG_MERGE_TIMERS) && !defined(CONFIG_PLUGIN_MC_RELEASE_MASTER)
+                event_group = get_event_group_for(cpu);
+#endif
+                per_cpu(cpus, cpu).event_group = event_group;
                 n++;
         }
         ret = mc_ce_set_domains(n, our_domains);
diff --git a/litmus/sched_mc_ce.c b/litmus/sched_mc_ce.c
index c5066918f282..5125df9572ba 100644
--- a/litmus/sched_mc_ce.c
+++ b/litmus/sched_mc_ce.c
@@ -79,6 +79,10 @@ DEFINE_PER_CPU(struct domain_data, _mc_ce_doms);
 DEFINE_PER_CPU(struct ce_dom_data, _mc_ce_dom_data);
 DEFINE_PER_CPU(raw_spinlock_t, _mc_ce_dom_locks);
 
+#ifdef CONFIG_PLUGIN_MC_RELEASE_MASTER
+static int interrupt_cpu;
+#endif
+
 long mc_ce_set_domains(const int n, struct domain_data *domains_in[])
 {
         const int max = (NR_CPUS < n) ? NR_CPUS : n;
@@ -520,8 +524,9 @@ static enum hrtimer_restart mc_ce_timer_callback(struct hrtimer *timer)
 #ifdef CONFIG_MERGE_TIMERS
         struct event_group *event_group;
         ce_data = container_of(e, struct ce_dom_data, event);
-        event_group = get_event_group_for(ce_data->cpu);
-#else
+        /* use the same CPU the callbacking is executing on by passing NO_CPU */
+        event_group = get_event_group_for(NO_CPU);
+#else /* CONFIG_MERGE_TIMERS */
         ce_data = container_of(timer, struct ce_dom_data, timer);
 #endif
         dom = get_domain_for(ce_data->cpu);
@@ -588,7 +593,7 @@ static void arm_all_timers(void)
         struct domain *dom;
         struct ce_dom_data *ce_data;
         struct ce_pid_table *pid_table;
-        int cpu, idx;
+        int cpu, idx, cpu_for_timer;
         const lt_t start = atomic64_read(&start_time);
 
         TRACE("arm all timers\n");
@@ -602,13 +607,19 @@ static void arm_all_timers(void)
                 for (idx = 0; idx < pid_table->num_pid_entries; idx++) {
                         pid_table->entries[idx].expected_job = 0;
                 }
+#ifdef CONFIG_PLUGIN_MC_RELEASE_MASTER
+                cpu_for_timer = interrupt_cpu;
+#else
+                cpu_for_timer = cpu;
+#endif
+
 #ifdef CONFIG_MERGE_TIMERS
-                TRACE("adding event for CPU %d\n", cpu);
-                add_event(get_event_group_for(cpu), &ce_data->event, start);
+                add_event(get_event_group_for(cpu_for_timer),
+                                &ce_data->event, start);
 #else
-                TRACE("arming timer for CPU %d\n", cpu);
-                hrtimer_start_on(cpu, &ce_data->timer_info, &ce_data->timer,
-                                ns_to_ktime(start), HRTIMER_MODE_ABS_PINNED);
+                hrtimer_start_on(cpu_for_timer, &ce_data->timer_info,
+                                &ce_data->timer, ns_to_ktime(start),
+                                HRTIMER_MODE_ABS_PINNED);
 #endif
         }
 }
@@ -634,8 +645,18 @@ long mc_ce_activate_plugin_common(void)
 {
         struct ce_dom_data *ce_data;
         struct domain *dom;
+        long ret;
         int cpu;
 
+#ifdef CONFIG_PLUGIN_MC_RELEASE_MASTER
+        interrupt_cpu = atomic_read(&release_master_cpu);
+        if (NO_CPU == interrupt_cpu) {
+                printk(KERN_ERR "LITMUS: MC-CE needs a release master\n");
+                ret = -EINVAL;
+                goto out;
+        }
+#endif
+
         for_each_online_cpu(cpu) {
                 dom = get_domain_for(cpu);
                 ce_data = dom->data;
@@ -647,7 +668,9 @@ long mc_ce_activate_plugin_common(void)
         atomic64_set(&start_time, litmus_clock());
         /* may not want to arm timers on activation, just after release */
         arm_all_timers();
-        return 0;
+        ret = 0;
+out:
+        return ret;
 }
 
 static long mc_ce_activate_plugin(void)