LITMUS: rework rt_domain to not cause circular lockig dependencies

2 files changed, 19 insertions, 18 deletions

diff --git a/include/litmus/edf_common.h b/include/litmus/edf_common.h
index f79bd76e17..37630e5c26 100644
--- a/include/litmus/edf_common.h
+++ b/include/litmus/edf_common.h
@@ -12,8 +12,8 @@
 #include <litmus/rt_domain.h>
 
 
-void edf_domain_init(rt_domain_t* rt, check_resched_needed_t resched,
-                     release_at_t release);
+void edf_domain_init(rt_domain_t* rt, check_resched_needed_t resched, 
+                     release_job_t release);
 
 int edf_higher_prio(struct task_struct* first,
                     struct task_struct* second);
diff --git a/include/litmus/rt_domain.h b/include/litmus/rt_domain.h
index fd3c205bcc..7b2a11c0f2 100644
--- a/include/litmus/rt_domain.h
+++ b/include/litmus/rt_domain.h
@@ -5,14 +5,18 @@
 #ifndef __UNC_RT_DOMAIN_H__
 #define __UNC_RT_DOMAIN_H__
 
+#include <linux/interrupt.h>
+
 struct _rt_domain;
 
 typedef int (*check_resched_needed_t)(struct _rt_domain *rt);
-typedef void (*release_at_t)(struct task_struct *t);
+typedef void (*release_job_t)(struct task_struct *t, struct _rt_domain *rt);
 
 typedef struct _rt_domain {
+        struct tasklet_struct           release_tasklet;
+
         /* runnable rt tasks are in here */
-        rwlock_t                        ready_lock;
+        spinlock_t                      ready_lock;
         struct list_head                ready_queue;
 
         /* real-time tasks waiting for release are in here */
@@ -22,8 +26,8 @@ typedef struct _rt_domain {
         /* how do we check if we need to kick another CPU? */
         check_resched_needed_t          check_resched;
 
-        /* how do we setup a job release? */
-        release_at_t                    setup_release;
+        /* how do we release a job? */
+        release_job_t                   release_job;
 
         /* how are tasks ordered in the ready queue? */
         list_cmp_t                      order;
@@ -35,8 +39,9 @@ typedef struct _rt_domain {
 #define ready_jobs_pending(rt) \
         (!list_empty(&(rt)->ready_queue))
 
-void rt_domain_init(rt_domain_t *rt, check_resched_needed_t f,
-                    release_at_t g, list_cmp_t order);
+void rt_domain_init(rt_domain_t *rt, list_cmp_t order, 
+                    check_resched_needed_t check,
+                    release_job_t relase);
 
 void __add_ready(rt_domain_t* rt, struct task_struct *new);
 void __add_release(rt_domain_t* rt, struct task_struct *task);
@@ -44,16 +49,13 @@ void __add_release(rt_domain_t* rt, struct task_struct *task);
 struct task_struct* __take_ready(rt_domain_t* rt);
 struct task_struct* __peek_ready(rt_domain_t* rt);
 
-void try_release_pending(rt_domain_t* rt);
-void __release_pending(rt_domain_t* rt);
-
 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 */
-        write_lock_irqsave(&rt->ready_lock, flags);
+        spin_lock_irqsave(&rt->ready_lock, flags);
         __add_ready(rt, new);
-        write_unlock_irqrestore(&rt->ready_lock, flags);
+        spin_unlock_irqrestore(&rt->ready_lock, flags);
 }
 
 static inline struct task_struct* take_ready(rt_domain_t* rt)
@@ -61,9 +63,9 @@ 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 */
-        write_lock_irqsave(&rt->ready_lock, flags);
+        spin_lock_irqsave(&rt->ready_lock, flags);
         ret = __take_ready(rt);
-        write_unlock_irqrestore(&rt->ready_lock, flags);
+        spin_unlock_irqrestore(&rt->ready_lock, flags);
         return ret;
 }
 
@@ -87,11 +89,10 @@ static inline int jobs_pending(rt_domain_t* rt)
         unsigned long flags;
         int ret;
         /* first we need the write lock for rt_ready_queue */
-        read_lock_irqsave(&rt->ready_lock, flags);
+        spin_lock_irqsave(&rt->ready_lock, flags);
         ret = __jobs_pending(rt);
-        read_unlock_irqrestore(&rt->ready_lock, flags);
+        spin_unlock_irqrestore(&rt->ready_lock, flags);
         return ret;
 }
 
-
 #endif