1 files changed, 198 insertions, 0 deletions

diff --git a/litmus/event_group.c b/litmus/event_group.c
new file mode 100644
index 000000000000..11a690d5b2cd
--- /dev/null
+++ b/litmus/event_group.c
@@ -0,0 +1,198 @@
+#include <litmus/event_group.h>
+#include <litmus/trace.h>
+#include <linux/sched.h>
+
+/*
+ * Return event_queue slot for the given time.
+ */
+static unsigned int time2slot(lt_t time)
+{
+        return (unsigned int) time2quanta(time, FLOOR) % EVENT_QUEUE_SLOTS;
+}
+
+/*
+ * Executes events from an event_list in priority order.
+ * Events can requeue themselves when they are called.
+ */
+static enum hrtimer_restart on_timer(struct hrtimer *timer)
+{
+        unsigned long flags;
+        event_list_t *el;
+        rt_event_t *e;
+        struct list_head *pos, *safe, list;
+
+        el = container_of(timer, event_list_t, timer);
+
+        raw_spin_lock_irqsave(&el->group->queue_lock, flags);
+        list_del_init(&el->list);
+        raw_spin_unlock_irqrestore(&el->group->queue_lock, flags);
+
+        /* Empty event list so this event can be requeued */
+        list_del_init(&el->events, list);
+
+        /* Fire events */
+        list_for_each_safe(pos, safe, &el->events) {
+                e = list_entry(pos, rt_event_t, list);
+                TRACE("Dequeueing event with prio %d\n", e->prio);
+                list_del_init(pos);
+                e->fire(e->data);
+        }
+}
+
+/*
+ * Insert event in event-list, respecting priority order.
+ */
+void insert_event(event_list_t *el, rt_event_t *e)
+{
+        struct list_head *pos;
+        event_list_t *queued;
+        list_for_each_prev(pos, &el->events) {
+                queued = list_entry(pos, event_list_t, list);
+                if (e->prio < queued->prio) {
+                        __list_add(&e->list, pos, pos->next);
+                        return;
+                }
+        }
+        list_add(&e->list, &el->events);
+}
+
+/*
+ * Return event_list for the given event and time. If no event_list
+ * is being used yet and use_event_heap is 1, will create the list
+ * and return it. Otherwise it will return NULL.
+ */
+static event_list_t* get_event_list(event_group_t *group,
+                                    rt_event_t *e,
+                                    lt_t fire,
+                                    int use_event_heap)
+{
+        struct list_head* pos;
+        event_list_t *el = NULL, *tmp;
+        unsigned int slot = time2slot(release_time);
+
+        /* initialize pos for the case that the list is empty */
+        pos = group->event_queue[slot].next;
+        list_for_each(pos, &group->event_queue[slot]) {
+                tmp = list_entry(pos, event_list_t, list);
+                if (lt_after_eq(fire, tmp->fire_time) &&
+                    lt_before(tmp->fire_time, fire)) {
+                        /* perfect match -- this happens on hyperperiod
+                         * boundaries
+                         */
+                        el = tmp;
+                        break;
+                } else if (lt_before(fire, tmp->fire_time)) {
+                        /* we need to insert a new node since rh is
+                         * already in the future
+                         */
+                        break;
+                }
+        }
+        if (!el && use_event_heap) {
+                /* use pre-allocated release heap */
+                tmp = e->event_list;
+                tmp->fire_time = fire;
+                tmp->group = group;
+                /* add to queue */
+                list_add(&tmp->list, pos->prev);
+                el = tmp;
+        }
+        return el;
+}
+
+/*
+ * Prepare a release heap for a new set of events.
+ */
+static void reinit_release_heap(rt_event_t *e)
+{
+        event_list_t *el = e->event_list;
+        BUG_ON(hrtimer_cancel(&el->timer));
+        INIT_LIST_HEAD(&el->events);
+        atomic_set(&el->info.state, HRTIMER_START_ON_INACTIVE);
+}
+
+/**
+ * add_event() - Add timer to event group.
+ */
+void add_event(event_group_t *group, rt_event_t *e, lt_t fire)
+{
+        event_list_t *el;
+
+        TRACE("Adding event with prio %d @ %llu\n", event->prio, fire);
+
+        raw_spin_lock(&group->queue_lock);
+        el = get_event_list(group, e, fire, 0);
+        if (!el) {
+                /* Use our own, but drop lock first */
+                raw_spin_unlock(&group->queue_lock);
+                reinit_event_list(e);
+                raw_spin_lock(&group->queue_lock);
+                el = get_event_list(group, e, fire, 1);
+        }
+
+        /* Add event to sorted list */
+        insert_event(el, e);
+        raw_spin_unlock(&group->queue_lock);
+
+        /* Arm timer if we are the owner */
+        if (el == e->event_list) {
+                TRACE("Arming timer for %llu\n", fire);
+                if (group->cpu == smp_processor_id()) {
+                        __hrtimer_start_range_ns(&el->timer,
+                                                 ns_to_ktime(el->fire_time),
+                                                 0, HRTIMER_MODE_ABS_PINNED, 0);
+                } else {
+                        hrtimer_start_on(group->cpu, &el->info,
+                                         &el->timer, ns_to_ktime(el->fire_time),
+                                         HRTIMER_MODE_ABS_PINNED);
+                }
+        } else {
+                TRACE("Not my timer @%llu", fire);
+        }
+}
+
+/**
+ * cancel_event() - Remove event from the group.
+ */
+void cancel_event(event_group_t *group, rt_event_t *e)
+{
+        raw_spin_lock(&group->queue_lock);
+        list_del_init(&e->list);
+        raw_spin_unlock(&group->queue_lock);
+}
+
+/**
+ * init_event_group() - Prepare group for events.
+ */
+void init_event_group(event_group_t *group, lt_t res)
+{
+        int i;
+        group->res = res;
+        group->cpu = cpu;
+
+        INIT_LIST_HEAD(group->tobe_queued);
+        for (i = 0; i < EVENT_QUEUE_SLOTS; i++) {
+                INIT_LIST_HEAD(&group->event_queue[i]);
+        }
+
+        raw_spin_lock_init(&group->queue_lock);
+        raw_spin_lock_init(&group->tobe_lock);
+}
+
+struct kmem_cache *event_list_cache;
+event_list_t* event_list_alloc(int gfp_flags)
+{
+        event_list_t *el = kmem_cache_alloc(event_list_cache, gfp_flags);
+        if (el) {
+                hrtimer_init(&el->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
+                INIT_LIST_HEAD(&el->list);
+                el->timer.function = on_timer;
+        }
+        return el;
+}
+
+void event_list_free(event_list_t *el)
+{
+        hrtimer_cancel(&el->timer);
+        kmem_cache_free(event_list_cache, el);
+}