[ported from 2008.3] Add rt_domain_t support

Still to be merged:
- arm_release_timer() with no rq locking

1 files changed, 158 insertions, 0 deletions

diff --git a/include/litmus/rt_domain.h b/include/litmus/rt_domain.h
new file mode 100644
index 000000000000..bde1e5a54812
--- /dev/null
+++ b/include/litmus/rt_domain.h
@@ -0,0 +1,158 @@
+/* CLEANUP: Add comments and make it less messy.
+ *
+ */
+
+#ifndef __UNC_RT_DOMAIN_H__
+#define __UNC_RT_DOMAIN_H__
+
+#include <litmus/heap.h>
+
+#define RELEASE_QUEUE_SLOTS 127 /* prime */
+
+struct _rt_domain;
+
+typedef int (*check_resched_needed_t)(struct _rt_domain *rt);
+typedef void (*release_jobs_t)(struct _rt_domain *rt, struct heap* tasks);
+
+struct release_queue {
+        /* each slot maintains a list of release heaps sorted
+         * by release time */
+        struct list_head                slot[RELEASE_QUEUE_SLOTS];
+};
+
+typedef struct _rt_domain {
+        /* runnable rt tasks are in here */
+        spinlock_t                      ready_lock;
+        struct heap                     ready_queue;
+
+        /* real-time tasks waiting for release are in here */
+        spinlock_t                      release_lock;
+        struct release_queue            release_queue;
+
+        /* for moving tasks to the release queue */
+        spinlock_t                      tobe_lock;
+        struct list_head                tobe_released;
+
+        /* how do we check if we need to kick another CPU? */
+        check_resched_needed_t          check_resched;
+
+        /* how do we release jobs? */
+        release_jobs_t                  release_jobs;
+
+        /* how are tasks ordered in the ready queue? */
+        heap_prio_t                     order;
+} rt_domain_t;
+
+struct release_heap {
+        /* list_head for per-time-slot list */
+        struct list_head                list;
+        lt_t                            release_time;
+        /* all tasks to be released at release_time */
+        struct heap                     heap;
+        /* used to trigger the release */
+        struct hrtimer                  timer;
+        /* required for the timer callback */
+        rt_domain_t*                    dom;
+};
+
+
+static inline struct task_struct* __next_ready(rt_domain_t* rt)
+{
+        struct heap_node *hn = heap_peek(rt->order, &rt->ready_queue);
+        if (hn)
+                return heap2task(hn);
+        else
+                return NULL;
+}
+
+void rt_domain_init(rt_domain_t *rt, heap_prio_t order,
+                    check_resched_needed_t check,
+                    release_jobs_t relase);
+
+void __add_ready(rt_domain_t* rt, struct task_struct *new);
+void __merge_ready(rt_domain_t* rt, struct heap *tasks);
+void __add_release(rt_domain_t* rt, struct task_struct *task);
+
+static inline struct task_struct* __take_ready(rt_domain_t* rt)
+{
+        struct heap_node* hn = heap_take(rt->order, &rt->ready_queue);
+        if (hn)
+                return heap2task(hn);
+        else
+                return NULL;
+}
+
+static inline struct task_struct* __peek_ready(rt_domain_t* rt)
+{
+        struct heap_node* hn = heap_peek(rt->order, &rt->ready_queue);
+        if (hn)
+                return heap2task(hn);
+        else
+                return NULL;
+}
+
+static inline int  is_queued(struct task_struct *t)
+{
+        return heap_node_in_heap(tsk_rt(t)->heap_node);
+}
+
+static inline void remove(rt_domain_t* rt, struct task_struct *t)
+{
+        heap_delete(rt->order, &rt->ready_queue, tsk_rt(t)->heap_node);
+}
+
+static inline void add_ready(rt_domain_t* rt, struct task_struct *new)
+{
+        unsigned long flags;
+        /* first we need the write lock for rt_ready_queue */
+        spin_lock_irqsave(&rt->ready_lock, flags);
+        __add_ready(rt, new);
+        spin_unlock_irqrestore(&rt->ready_lock, flags);
+}
+
+static inline void merge_ready(rt_domain_t* rt, struct heap* tasks)
+{
+        unsigned long flags;
+        spin_lock_irqsave(&rt->ready_lock, flags);
+        __merge_ready(rt, tasks);
+        spin_unlock_irqrestore(&rt->ready_lock, flags);
+}
+
+static inline struct task_struct* take_ready(rt_domain_t* rt)
+{
+        unsigned long flags;
+        struct task_struct* ret;
+        /* first we need the write lock for rt_ready_queue */
+        spin_lock_irqsave(&rt->ready_lock, flags);
+        ret = __take_ready(rt);
+        spin_unlock_irqrestore(&rt->ready_lock, flags);
+        return ret;
+}
+
+
+static inline void add_release(rt_domain_t* rt, struct task_struct *task)
+{
+        unsigned long flags;
+        /* first we need the write lock for rt_ready_queue */
+        spin_lock_irqsave(&rt->tobe_lock, flags);
+        __add_release(rt, task);
+        spin_unlock_irqrestore(&rt->tobe_lock, flags);
+}
+
+static inline int __jobs_pending(rt_domain_t* rt)
+{
+        return !heap_empty(&rt->ready_queue);
+}
+
+static inline int jobs_pending(rt_domain_t* rt)
+{
+        unsigned long flags;
+        int ret;
+        /* first we need the write lock for rt_ready_queue */
+        spin_lock_irqsave(&rt->ready_lock, flags);
+        ret = !heap_empty(&rt->ready_queue);
+        spin_unlock_irqrestore(&rt->ready_lock, flags);
+        return ret;
+}
+
+#endif