4 files changed, 57 insertions, 35 deletions

diff --git a/litmus/ce_domain.c b/litmus/ce_domain.c
index c3ddc9dd63ad..5e1f7ccc000c 100644
--- a/litmus/ce_domain.c
+++ b/litmus/ce_domain.c
@@ -30,6 +30,8 @@ void ce_requeue(domain_t *dom, struct task_struct *ts)
                         "expected_job: %3u\n",
                         asleep, just_finished, expected_job);
 
+        tsk_mc_data(ts)->mc_task.lvl_a_eligible = 1;
+
         /* When coming from job completion, the task will be asleep. */
         if (asleep && just_finished < expected_job) {
                 TRACE_MC_TASK(ts, "appears behind\n");
@@ -41,18 +43,27 @@ void ce_requeue(domain_t *dom, struct task_struct *ts)
 }
 
 /*
+ *
+ */
+void ce_remove(domain_t *dom, struct task_struct *ts)
+{
+        tsk_mc_data(ts)->mc_task.lvl_a_eligible = 0;
+}
+
+/*
  * ce_take_ready and ce_peek_ready
  */
 struct task_struct* ce_peek_and_take_ready(domain_t *dom)
 {
-        struct task_struct *ret = NULL;
         const struct ce_dom_data *ce_data = dom->data;
-        const int exists = NULL != ce_data->should_schedule;
-        const int blocked = exists && !is_running(ce_data->should_schedule);
+        struct task_struct *ret = NULL, *sched = ce_data->should_schedule;
+        const int exists = NULL != sched;
+        const int blocked = exists && !is_running(sched);
+        const int elig = exists && tsk_mc_data(sched)->mc_task.lvl_a_eligible;
 
         /* Return the task we should schedule if it is not blocked or sleeping. */
-        if (exists && !blocked)
-                ret = ce_data->should_schedule;
+        if (exists && !blocked && elig)
+                ret = sched;
         return ret;
 }
 
@@ -78,6 +89,7 @@ void ce_domain_init(domain_t *dom,
         domain_init(dom, lock, requeue, peek_ready, take_ready, preempt_needed,
                         task_prio);
         dom->data = dom_data;
+        dom->remove = ce_remove;
         dom_data->cpu = cpu;
 #ifdef CONFIG_MERGE_TIMERS
         init_event(&dom_data->event, CRIT_LEVEL_A, ce_timer_callback,
diff --git a/litmus/event_group.c b/litmus/event_group.c
index daf964fbb8cc..40c2f9bf2d18 100644
--- a/litmus/event_group.c
+++ b/litmus/event_group.c
@@ -71,18 +71,19 @@ void insert_event(struct event_list *el, struct rt_event *e)
                 queued = list_entry(pos, struct rt_event, list);
                 last = pos;
                 if (e->prio < queued->prio) {
-                        VTRACE("Inserting priority %d 0x%p before %d 0x%p "
-                               "in 0x%p, pos 0x%p\n", e->prio, &e->list,
+                        VTRACE("Inserting priority %d event 0x%p before %d 0x%p "
+                               "in 0x%p, pos 0x%p\n", e->prio, e,
                                queued->prio, &queued->list, el, pos);
                         BUG_ON(!list_empty(&e->list));
                         list_add_tail(&e->list, pos);
                         return;
                 }
         }
-        VTRACE("Inserting priority %d 0x%p at end of 0x%p, last 0x%p\n",
-               e->prio, &el->list, el, last);
+        VTRACE("Inserting  priority %d event 0x%p at end of 0x%p, last 0x%p\n",
+               e->prio, e, el, last);
         BUG_ON(!list_empty(&e->list));
         list_add(&e->list, (last) ? last : pos);
+        VTRACE("Singular? %d\n", list_is_singular(&el->events));
 }
 
 /*
@@ -100,7 +101,7 @@ static struct event_list* get_event_list(struct event_group *group,
         unsigned int slot = time2slot(fire);
         int remaining = 300;
 
-        VTRACE("Getting list for %llu, event 0x%p\n", fire, e);
+        VTRACE("Getting list for time %llu, event 0x%p\n", fire, e);
 
         /* Initialize pos for the case that the list is empty */
         pos = group->event_queue[slot].next;
@@ -145,7 +146,7 @@ static struct event_list* get_event_list(struct event_group *group,
 static void reinit_event_list(struct rt_event *e)
 {
         struct event_list *el = e->event_list;
-        VTRACE("Reinitting 0x%p for event 0x%p\n", el, e);
+        VTRACE("Reinitting list 0x%p for event 0x%p\n", el, e);
         BUG_ON(hrtimer_try_to_cancel(&el->timer) == 1);
         INIT_LIST_HEAD(&el->events);
         atomic_set(&el->info.state, HRTIMER_START_ON_INACTIVE);
@@ -213,13 +214,14 @@ void cancel_event(struct rt_event *e)
         /* If our event_list contains any events, it is in use */
         raw_spin_lock(&group->queue_lock);
         if (!list_empty(&e->event_list->events)) {
+                VTRACE("List 0x%p is not empty\n", e->event_list);
 
                 /* If our event_list contains events, we are the first element
                  * in that list. If there is anyone after us in the list, then
                  * swap our list with theirs to that the event_list can still
                  * trigger the queued events.
                  */
-                if (!list_is_singular(&e->list)) {
+                if (!list_is_singular(&e->event_list->events)) {
                         swap = list_entry(e->list.next, struct rt_event, list);
                         VTRACE("Swapping with event 0x%p of priority %d\n",
                                swap, swap->prio);
@@ -230,8 +232,11 @@ 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);
                 list_del_init(&e->event_list->list);
+        } else {
+                VTRACE("List 0x%p is empty\n", e->event_list);
         }
         list_del_init(&e->list);
         raw_spin_unlock(&group->queue_lock);
@@ -248,7 +253,7 @@ struct event_list* event_list_alloc(int gfp_flags)
                 INIT_LIST_HEAD(&el->list);
                 el->timer.function = on_timer;
         } else {
-                VTRACE("Failed to allocate event list!");
+                VTRACE("Failed to allocate event list!\n");
                 printk(KERN_CRIT "Failed to allocate event list.\n");
                 BUG();
         }
diff --git a/litmus/rt_domain.c b/litmus/rt_domain.c
index ffb3cab9cffd..93f2a35fb29d 100644
--- a/litmus/rt_domain.c
+++ b/litmus/rt_domain.c
@@ -20,7 +20,7 @@
 #include <litmus/bheap.h>
 
 /* Uncomment when debugging timer races... */
-#if 0
+#if 1
 #define VTRACE_TASK TRACE_TASK
 #define VTRACE TRACE
 #else
@@ -293,8 +293,7 @@ static void setup_release(rt_domain_t *_rt)
 #else
                         arm_release_timer(rh);
 #endif
-                } else
-                        VTRACE_TASK(t, "0x%p is not my timer\n", &rh->timer);
+                }
         }
 }
 
@@ -439,6 +438,13 @@ static struct task_struct* pd_peek_ready(domain_t *dom)
         return __next_ready((rt_domain_t*)dom->data);
 }
 
+static void pd_remove(domain_t *dom, struct task_struct *task)
+{
+        if (is_queued(task)) {
+                remove((rt_domain_t*)dom->data, task);
+        }
+}
+
 /* pd_domain_init - create a generic domain wrapper for an rt_domain
  */
 void pd_domain_init(domain_t *dom,
@@ -453,5 +459,6 @@ void pd_domain_init(domain_t *dom,
         domain_init(dom, &domain->ready_lock,
                     pd_requeue, pd_peek_ready, pd_take_ready,
                     preempt_needed, priority);
+        dom->remove = pd_remove;
         dom->data = domain;
 }
diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index b2a9ca205be4..f360abf34035 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -183,7 +183,7 @@ static void update_ghost_time(struct task_struct *p)
 static inline void update_crit_position(struct crit_entry *ce)
 {
         struct bheap *heap;
-        if (is_global(ce->domain)) {
+        if (is_global(ce->domain) && ce->usable) {
                 heap = domain_data(ce->domain)->heap;
                 BUG_ON(!heap);
                 BUG_ON(!bheap_node_in_heap(ce->node));
@@ -451,9 +451,18 @@ static void check_for_preempt(struct domain *dom)
                         entry = crit_cpu(ce);
                         preempted = 0;
                         raw_spin_lock(&entry->lock);
-                        if (ce->usable && dom->preempt_needed(dom, ce->linked)){
+
+                        if (!ce->usable) {
+                                TRACE_CRIT_ENTRY(ce, "Removing");
+                                bheap_delete(cpu_lower_prio,
+                                             domain_data(dom)->heap, ce->node);
+                                continue;
+                        }
+                        if (dom->preempt_needed(dom, ce->linked)){
                                 preempted = 1;
                                 preempt(dom, ce);
+                        } else {
+                                TRACE_CRIT_ENTRY(ce, "Stopped global check\n");
                         }
                         raw_spin_unlock(&entry->lock);
                 }
@@ -486,10 +495,10 @@ static void remove_from_all(struct task_struct* task)
 
         raw_spin_lock(dom->lock);
 
+        /* Remove the task from any CPU state */
         if (task->rt_param.linked_on != NO_CPU) {
                 entry = &per_cpu(cpus, task->rt_param.linked_on);
                 raw_spin_lock(&entry->lock);
-
                 /* Unlink only if task is still linked post lock */
                 ce = &entry->crit_entries[tsk_mc_crit(task)];
                 if (task->rt_param.linked_on != NO_CPU) {
@@ -501,23 +510,15 @@ static void remove_from_all(struct task_struct* task)
                                 link_task_to_cpu(entry, NULL);
                         }
                 }
-
                 if (update)
                         update_crit_levels(entry);
                 else
                         raw_spin_unlock(&entry->lock);
         }
 
-        if (is_queued(task)) {
-                /* This is an interesting situation: t is scheduled,
-                 * but was just recently unlinked. It cannot be
-                 * linked anywhere else (because then it would have
-                 * been relinked to this CPU), thus it must be in some
-                 * queue. We must remove it from the list in this
-                 * case.
-                 */
-                remove((rt_domain_t*)get_task_domain(task)->data, task);
-        }
+        /* Ensure the task isn't returned by its domain */
+        dom->remove(dom, task);
+
         BUG_ON(is_queued(task));
         raw_spin_unlock(dom->lock);
 }
@@ -853,12 +854,9 @@ static struct task_struct* mc_schedule(struct task_struct * prev)
 
         if (exists) {
                 entry->scheduled->rt_param.scheduled_on = NO_CPU;
-                TRACE(TS
-                      " blocks:%d out_of_time:%d sleep:%d preempt:%d "
-                      "state:%d sig:%d global:%d\n", TA(prev),
-                      blocks, out_of_time, sleep, preempt,
-                      prev->state, signal_pending(prev), global);
         }
+        TRACE(TS " blocks:%d out_of_time:%d sleep:%d preempt:%d\n",
+              TA(prev), blocks, out_of_time, sleep, preempt);
         raw_spin_unlock(&entry->lock);