Merged with ce domains

1 files changed, 46 insertions, 16 deletions

diff --git a/litmus/event_group.c b/litmus/event_group.c
index b4521ab370d1..276ba5dd242d 100644
--- a/litmus/event_group.c
+++ b/litmus/event_group.c
@@ -6,7 +6,9 @@
 #include <litmus/event_group.h>
 
 #if 1
-#define VTRACE TRACE
+#define VTRACE(fmt, args...)                                    \
+sched_trace_log_message("%d P%d        [%s@%s:%d]: " fmt,       \
+                                TRACE_ARGS,  ## args)
 #else
 #define VTRACE(fmt, args...)
 #endif
@@ -46,8 +48,8 @@ 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 with prio %d from 0x%p\n",
-                      e->prio, el);
+                TRACE("Dequeueing event 0x%p with prio %d from 0x%p\n",
+                      e, e->prio, el);
                 list_del_init(pos);
                 e->function(e);
         }
@@ -69,12 +71,14 @@ void insert_event(struct event_list *el, struct rt_event *e)
                         VTRACE("Inserting priority %d 0x%p before %d 0x%p "
                                "in 0x%p, pos 0x%p\n", e->prio, &e->list,
                                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);
+        BUG_ON(!list_empty(&e->list));
         list_add(&e->list, (last) ? last : pos);
 }
 
@@ -91,12 +95,14 @@ static struct event_list* get_event_list(struct event_group *group,
         struct list_head* pos;
         struct event_list *el = NULL, *tmp;
         unsigned int slot = time2slot(fire);
+        int remaining = 300;
 
-        VTRACE("Getting list for %llu\n", fire);
+        VTRACE("Getting list for %llu, event 0x%p\n", fire, e);
 
         /* Initialize pos for the case that the list is empty */
         pos = group->event_queue[slot].next;
         list_for_each(pos, &group->event_queue[slot]) {
+                BUG_ON(remaining-- < 0);
                 tmp = list_entry(pos, struct event_list, list);
                 if (lt_after_eq(fire, tmp->fire_time) &&
                     lt_before(fire, tmp->fire_time + group->res)) {
@@ -121,10 +127,11 @@ static struct event_list* get_event_list(struct event_group *group,
                 tmp->fire_time = fire;
                 tmp->group = group;
                 /* Add to queue */
-                list_add(&tmp->list, pos->prev);
-                el = tmp;
                 VTRACE("Using list for priority %d and time %llu\n",
                        e->prio, fire);
+                BUG_ON(!list_empty(&tmp->list));
+                list_add(&tmp->list, pos->prev);
+                el = tmp;
         }
         return el;
 }
@@ -135,8 +142,8 @@ 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;
-        BUG_ON(hrtimer_cancel(&el->timer));
-        VTRACE("Reinitting 0x%p\n", el);
+        VTRACE("Reinitting 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);
 }
@@ -148,8 +155,8 @@ void add_event(struct event_group *group, struct rt_event *e, lt_t fire)
 {
         struct event_list *el;
 
-        VTRACE("Adding event with priority %d for time %llu\n",
-               e->prio, fire);
+        VTRACE("Adding event 0x%p with priority %d for time %llu\n",
+               e, e->prio, fire);
 
         raw_spin_lock(&group->queue_lock);
         el = get_event_list(group, e, fire, 0);
@@ -167,7 +174,7 @@ void add_event(struct event_group *group, struct rt_event *e, lt_t fire)
 
         /* Arm timer if we are the owner */
         if (el == e->event_list) {
-                VTRACE("Arming timer for %llu\n", fire);
+                VTRACE("Arming timer on event 0x%p for %llu\n", e, fire);
                 if (group->cpu == smp_processor_id()) {
                         __hrtimer_start_range_ns(&el->timer,
                                                  ns_to_ktime(el->fire_time),
@@ -185,14 +192,37 @@ void add_event(struct event_group *group, struct rt_event *e, lt_t fire)
 /**
  * cancel_event() - Remove event from the group.
  */
-void cancel_event(struct rt_event *e)
+void cancel_event(struct event_group *group, struct rt_event *e)
 {
-        struct event_group *group;
+        struct list_head *swap = NULL;
+        struct rt_event *swappy;
+        struct event_list *tmp;
+
         if (e->list.next != &e->list) {
-                group = e->event_list->group;
                 raw_spin_lock(&group->queue_lock);
-                VTRACE("Canceling event with priority %d\n", e->prio);
-                list_del_init(&e->list);
+                VTRACE("Canceling event 0x%p with priority %d\n", e, e->prio);
+
+                /* If somebody else is hooked up to our event list, swap
+                 * with their event list and leave our old event list
+                 * to execute.
+                 */
+                if (!list_empty(&e->list)) {
+                        swap = (e->list.next == &e->event_list->events) ?
+                               (e->list.prev == &e->event_list->events) ?
+                                NULL : e->list.prev : e->list.next;
+                        list_del_init(&e->list);
+                }
+                if (swap) {
+                        swappy = list_entry(swap, struct rt_event, list);
+                        tmp = swappy->event_list;
+                        swappy->event_list = e->event_list;
+                        e->event_list = tmp;
+                        VTRACE("Swapping with event 0x%p", swappy);
+                }
+
+                hrtimer_try_to_cancel(&e->event_list->timer);
+                list_del_init(&e->event_list->list);
+
                 raw_spin_unlock(&group->queue_lock);
         }
 }