Change most LitmusRT spinlock_t in raw_spinlock_t

Adapt to new schema for spinlock:
(tglx 20091217)
spinlock - the weakest one, which might sleep in RT
raw_spinlock - spinlock which always spins even on RT
arch_spinlock - the hardware level architecture dependent implementation

----

Most probably, all the spinlocks changed by this commit will be true
spinning lock (raw_spinlock) in PreemptRT (so hopefully we'll need few
changes when porting Litmmus to PreemptRT).

There are a couple of spinlock that the kernel still defines as
spinlock_t (therefore no changes reported in this commit) that might cause
us troubles:

- wait_queue_t lock is defined as spinlock_t; it is used in:
  * fmlp.c -- sem->wait.lock
  * sync.c -- ts_release.wait.lock

- rwlock_t used in fifo implementation in sched_trace.c
  * this need probably to be changed to something always spinning in RT
    at the expense of increased locking time.

----

This commit also fixes warnings and errors due to the need to include
slab.h when using kmalloc() and friends.

----

This commit does not compile.

1 files changed, 13 insertions, 13 deletions

diff --git a/include/litmus/rt_domain.h b/include/litmus/rt_domain.h
index b452be1d2256..9bf980713474 100644
--- a/include/litmus/rt_domain.h
+++ b/include/litmus/rt_domain.h
@@ -22,16 +22,16 @@ struct release_queue {
 
 typedef struct _rt_domain {
         /* runnable rt tasks are in here */
-        spinlock_t                      ready_lock;
+        raw_spinlock_t                  ready_lock;
         struct bheap                    ready_queue;
 
         /* real-time tasks waiting for release are in here */
-        spinlock_t                      release_lock;
+        raw_spinlock_t                  release_lock;
         struct release_queue            release_queue;
         int                             release_master;
 
         /* for moving tasks to the release queue */
-        spinlock_t                      tobe_lock;
+        raw_spinlock_t                  tobe_lock;
         struct list_head                tobe_released;
 
         /* how do we check if we need to kick another CPU? */
@@ -109,17 +109,17 @@ 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);
+        raw_spin_lock_irqsave(&rt->ready_lock, flags);
         __add_ready(rt, new);
-        spin_unlock_irqrestore(&rt->ready_lock, flags);
+        raw_spin_unlock_irqrestore(&rt->ready_lock, flags);
 }
 
 static inline void merge_ready(rt_domain_t* rt, struct bheap* tasks)
 {
         unsigned long flags;
-        spin_lock_irqsave(&rt->ready_lock, flags);
+        raw_spin_lock_irqsave(&rt->ready_lock, flags);
         __merge_ready(rt, tasks);
-        spin_unlock_irqrestore(&rt->ready_lock, flags);
+        raw_spin_unlock_irqrestore(&rt->ready_lock, flags);
 }
 
 static inline struct task_struct* take_ready(rt_domain_t* rt)
@@ -127,9 +127,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 */
-        spin_lock_irqsave(&rt->ready_lock, flags);
+        raw_spin_lock_irqsave(&rt->ready_lock, flags);
         ret = __take_ready(rt);
-        spin_unlock_irqrestore(&rt->ready_lock, flags);
+        raw_spin_unlock_irqrestore(&rt->ready_lock, flags);
         return ret;
 }
 
@@ -138,9 +138,9 @@ 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);
+        raw_spin_lock_irqsave(&rt->tobe_lock, flags);
         __add_release(rt, task);
-        spin_unlock_irqrestore(&rt->tobe_lock, flags);
+        raw_spin_unlock_irqrestore(&rt->tobe_lock, flags);
 }
 
 static inline int __jobs_pending(rt_domain_t* rt)
@@ -153,9 +153,9 @@ 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);
+        raw_spin_lock_irqsave(&rt->ready_lock, flags);
         ret = !bheap_empty(&rt->ready_queue);
-        spin_unlock_irqrestore(&rt->ready_lock, flags);
+        raw_spin_unlock_irqrestore(&rt->ready_lock, flags);
         return ret;
 }