Fixed timer issue and atomic remove issue in level A domain.

Timers had an issue where they couldn't be cancelled before they migrated.
Now when you set the start_on_info to inactive, it will prevent a timer
from being armed.

When a task is being blocked and preempted concurrently, the blocking code
needs to be able to prevent the task from being scheduled on another CPU.
This did not work for CE domains. Added a per-domain remove function
which, for ce domains, will prevent a task from being returned by the domain.

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);