Bug fix for cancel events

2 files changed, 24 insertions, 23 deletions

diff --git a/litmus/event_group.c b/litmus/event_group.c
index a130a68c731a..daf964fbb8cc 100644
--- a/litmus/event_group.c
+++ b/litmus/event_group.c
@@ -203,39 +203,39 @@ void add_event(struct event_group *group, struct rt_event *e, lt_t fire)
  */
 void cancel_event(struct rt_event *e)
 {
-        struct list_head *swap = NULL;
-        struct rt_event *swappy;
+        struct rt_event *swap;
         struct event_list *tmp;
         struct event_group *group = e->_event_group;
 
-        if (e->list.next != &e->list) {
-                raw_spin_lock(&group->queue_lock);
-                VTRACE("Canceling event 0x%p with priority %d\n", e, e->prio);
+        VTRACE("Canceling event 0x%p with priority %d\n", e, e->prio);
+        if (!group) return;
+
+        /* If our event_list contains any events, it is in use */
+        raw_spin_lock(&group->queue_lock);
+        if (!list_empty(&e->event_list->events)) {
 
-                /* If somebody else is hooked up to our event list, swap
-                 * with their event list and leave our old event list
-                 * to execute.
+                /* 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_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;
+                if (!list_is_singular(&e->list)) {
+                        swap = list_entry(e->list.next, struct rt_event, list);
+                        VTRACE("Swapping with event 0x%p of priority %d\n",
+                               swap, swap->prio);
+
+                        tmp = swap->event_list;
+                        swap->event_list = e->event_list;
                         e->event_list = tmp;
-                        VTRACE("Swapping with event 0x%p", swappy);
                 }
 
+                /* Disable the event_list */
                 hrtimer_try_to_cancel(&e->event_list->timer);
                 list_del_init(&e->event_list->list);
-                e->_event_group = NULL;
-
-                raw_spin_unlock(&group->queue_lock);
         }
+        list_del_init(&e->list);
+        raw_spin_unlock(&group->queue_lock);
+        e->_event_group = NULL;
 }
 
 struct kmem_cache *event_list_cache;
@@ -261,6 +261,7 @@ void init_event(struct rt_event *e, int prio, fire_event_t function,
         e->prio = prio;
         e->function = function;
         e->event_list = el;
+        e->_event_group = NULL;
         INIT_LIST_HEAD(&e->list);
 }
 
diff --git a/litmus/sched_mc_ce.c b/litmus/sched_mc_ce.c
index 5125df9572ba..ffcc25873581 100644
--- a/litmus/sched_mc_ce.c
+++ b/litmus/sched_mc_ce.c
@@ -577,7 +577,7 @@ static int cancel_all_timers(void)
                 cancel_res = hrtimer_cancel(&ce_data->timer);
                 atomic_set(&ce_data->timer_info.state,
                                 HRTIMER_START_ON_INACTIVE);
-                ret = ret || cancel_res; 
+                ret = ret || cancel_res;
 #endif
         }
         return ret;