Change API: spinlock_t -> 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

----

Planning for future porting on PreemptRT, probably all of the
spinlock changed in this patch should true spinning lock (raw_spinlock).

There are a couple of spinlock that the kernel still defines as
spinlock_t (therefore no changes reported in this commit) that might cause
problems to us:
- 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.

11 files changed, 96 insertions, 92 deletions

diff --git a/include/litmus/fdso.h b/include/litmus/fdso.h
index 286e10f86de0..61f1b5baf42c 100644
--- a/include/litmus/fdso.h
+++ b/include/litmus/fdso.h
@@ -10,6 +10,7 @@
 #include <asm/atomic.h>
 
 #include <linux/fs.h>
+#include <linux/slab.h>
 
 #define MAX_OBJECT_DESCRIPTORS 32
 
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;
 }
 
diff --git a/kernel/hrtimer.c b/kernel/hrtimer.c
index c0b440b1f6ee..02e5097bf319 100644
--- a/kernel/hrtimer.c
+++ b/kernel/hrtimer.c
@@ -1052,9 +1052,9 @@ void hrtimer_pull(void)
         struct hrtimer_start_on_info *info;
         struct list_head *pos, *safe, list;
 
-        spin_lock(&base->lock);
+        raw_spin_lock(&base->lock);
         list_replace_init(&base->to_pull, &list);
-        spin_unlock(&base->lock);
+        raw_spin_unlock(&base->lock);
 
         list_for_each_safe(pos, safe, &list) {
                 info = list_entry(pos, struct hrtimer_start_on_info, list);
@@ -1108,10 +1108,10 @@ int hrtimer_start_on(int cpu, struct hrtimer_start_on_info* info,
                 } else {
                         TRACE("hrtimer_start_on: pulling to remote CPU\n");
                         base = &per_cpu(hrtimer_bases, cpu);
-                        spin_lock_irqsave(&base->lock, flags);
+                        raw_spin_lock_irqsave(&base->lock, flags);
                         was_empty = list_empty(&base->to_pull);
                         list_add(&info->list, &base->to_pull);
-                        spin_unlock_irqrestore(&base->lock, flags);
+                        raw_spin_unlock_irqrestore(&base->lock, flags);
                         if (was_empty)
                                 /* only send IPI if other no else
                                  * has done so already
diff --git a/litmus/ftdev.c b/litmus/ftdev.c
index 8b2d74d816a2..51dafaebf8a6 100644
--- a/litmus/ftdev.c
+++ b/litmus/ftdev.c
@@ -1,5 +1,6 @@
 #include <linux/sched.h>
 #include <linux/fs.h>
+#include <linux/slab.h>
 #include <linux/cdev.h>
 #include <asm/uaccess.h>
 #include <linux/module.h>
diff --git a/litmus/litmus.c b/litmus/litmus.c
index 5bf848386e1c..b71fc819eb51 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -23,7 +23,7 @@
 
 /* Number of RT tasks that exist in the system */
 atomic_t rt_task_count          = ATOMIC_INIT(0);
-static DEFINE_SPINLOCK(task_transition_lock);
+static DEFINE_RAW_SPINLOCK(task_transition_lock);
 /* synchronize plugin switching */
 atomic_t cannot_use_plugin      = ATOMIC_INIT(0);
 
@@ -330,7 +330,7 @@ long litmus_admit_task(struct task_struct* tsk)
         INIT_LIST_HEAD(&tsk_rt(tsk)->list);
 
         /* avoid scheduler plugin changing underneath us */
-        spin_lock_irqsave(&task_transition_lock, flags);
+        raw_spin_lock_irqsave(&task_transition_lock, flags);
 
         /* allocate heap node for this task */
         tsk_rt(tsk)->heap_node = bheap_node_alloc(GFP_ATOMIC);
@@ -357,7 +357,7 @@ long litmus_admit_task(struct task_struct* tsk)
         }
 
 out_unlock:
-        spin_unlock_irqrestore(&task_transition_lock, flags);
+        raw_spin_unlock_irqrestore(&task_transition_lock, flags);
 out:
         return retval;
 }
@@ -403,7 +403,7 @@ int switch_sched_plugin(struct sched_plugin* plugin)
         smp_call_function(synch_on_plugin_switch, NULL, 0);
 
         /* stop task transitions */
-        spin_lock_irqsave(&task_transition_lock, flags);
+        raw_spin_lock_irqsave(&task_transition_lock, flags);
 
         /* don't switch if there are active real-time tasks */
         if (atomic_read(&rt_task_count) == 0) {
@@ -421,7 +421,7 @@ int switch_sched_plugin(struct sched_plugin* plugin)
         } else
                 ret = -EBUSY;
 out:
-        spin_unlock_irqrestore(&task_transition_lock, flags);
+        raw_spin_unlock_irqrestore(&task_transition_lock, flags);
         atomic_set(&cannot_use_plugin, 0);
         return ret;
 }
diff --git a/litmus/rt_domain.c b/litmus/rt_domain.c
index 609ff0f82abb..8d5db6050723 100644
--- a/litmus/rt_domain.c
+++ b/litmus/rt_domain.c
@@ -53,11 +53,11 @@ static enum hrtimer_restart on_release_timer(struct hrtimer *timer)
 
         rh = container_of(timer, struct release_heap, timer);
 
-        spin_lock_irqsave(&rh->dom->release_lock, flags);
+        raw_spin_lock_irqsave(&rh->dom->release_lock, flags);
         TRACE("CB has the release_lock 0x%p\n", &rh->dom->release_lock);
         /* remove from release queue */
         list_del(&rh->list);
-        spin_unlock_irqrestore(&rh->dom->release_lock, flags);
+        raw_spin_unlock_irqrestore(&rh->dom->release_lock, flags);
         TRACE("CB returned release_lock 0x%p\n", &rh->dom->release_lock);
 
         /* call release callback */
@@ -185,20 +185,20 @@ static void arm_release_timer(rt_domain_t *_rt)
                 list_del(pos);
 
                 /* put into release heap while holding release_lock */
-                spin_lock(&rt->release_lock);
+                raw_spin_lock(&rt->release_lock);
                 TRACE_TASK(t, "I have the release_lock 0x%p\n", &rt->release_lock);
 
                 rh = get_release_heap(rt, t, 0);
                 if (!rh) {
                         /* need to use our own, but drop lock first */
-                        spin_unlock(&rt->release_lock);
+                        raw_spin_unlock(&rt->release_lock);
                         TRACE_TASK(t, "Dropped release_lock 0x%p\n",
                                    &rt->release_lock);
 
                         reinit_release_heap(t);
                         TRACE_TASK(t, "release_heap ready\n");
 
-                        spin_lock(&rt->release_lock);
+                        raw_spin_lock(&rt->release_lock);
                         TRACE_TASK(t, "Re-acquired release_lock 0x%p\n",
                                    &rt->release_lock);
 
@@ -207,7 +207,7 @@ static void arm_release_timer(rt_domain_t *_rt)
                 bheap_insert(rt->order, &rh->heap, tsk_rt(t)->heap_node);
                 TRACE_TASK(t, "arm_release_timer(): added to release heap\n");
 
-                spin_unlock(&rt->release_lock);
+                raw_spin_unlock(&rt->release_lock);
                 TRACE_TASK(t, "Returned the release_lock 0x%p\n", &rt->release_lock);
 
                 /* To avoid arming the timer multiple times, we only let the
@@ -258,9 +258,9 @@ void rt_domain_init(rt_domain_t *rt,
         for (i = 0; i < RELEASE_QUEUE_SLOTS; i++)
                 INIT_LIST_HEAD(&rt->release_queue.slot[i]);
 
-        spin_lock_init(&rt->ready_lock);
-        spin_lock_init(&rt->release_lock);
-        spin_lock_init(&rt->tobe_lock);
+        raw_spin_lock_init(&rt->ready_lock);
+        raw_spin_lock_init(&rt->release_lock);
+        raw_spin_lock_init(&rt->tobe_lock);
 
         rt->check_resched       = check;
         rt->release_jobs        = release;
diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index e57a11afda16..f5b77080cc4f 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -28,6 +28,7 @@
 #include <linux/spinlock.h>
 #include <linux/percpu.h>
 #include <linux/sched.h>
+#include <linux/slab.h>
 
 #include <litmus/litmus.h>
 #include <litmus/jobs.h>
@@ -285,12 +286,12 @@ static void cedf_release_jobs(rt_domain_t* rt, struct bheap* tasks)
         cedf_domain_t* cluster = container_of(rt, cedf_domain_t, domain);
         unsigned long flags;
 
-        spin_lock_irqsave(&cluster->lock, flags);
+        raw_spin_lock_irqsave(&cluster->lock, flags);
 
         __merge_ready(&cluster->domain, tasks);
         check_for_preemptions(cluster);
 
-        spin_unlock_irqrestore(&cluster->lock, flags);
+        raw_spin_unlock_irqrestore(&cluster->lock, flags);
 }
 
 /* caller holds cedf_lock */
@@ -371,7 +372,7 @@ static struct task_struct* cedf_schedule(struct task_struct * prev)
         int out_of_time, sleep, preempt, np, exists, blocks;
         struct task_struct* next = NULL;
 
-        spin_lock(&cluster->lock);
+        raw_spin_lock(&cluster->lock);
         clear_will_schedule();
 
         /* sanity checking */
@@ -454,7 +455,7 @@ static struct task_struct* cedf_schedule(struct task_struct * prev)
                 if (exists)
                         next = prev;
 
-        spin_unlock(&cluster->lock);
+        raw_spin_unlock(&cluster->lock);
 
 #ifdef WANT_ALL_SCHED_EVENTS
         TRACE("cedf_lock released, next=0x%p\n", next);
@@ -496,7 +497,7 @@ static void cedf_task_new(struct task_struct * t, int on_rq, int running)
         /* the cluster doesn't change even if t is running */
         cluster = task_cpu_cluster(t);
 
-        spin_lock_irqsave(&cluster->domain.ready_lock, flags);
+        raw_spin_lock_irqsave(&cluster->domain.ready_lock, flags);
 
         /* setup job params */
         release_at(t, litmus_clock());
@@ -513,7 +514,7 @@ static void cedf_task_new(struct task_struct * t, int on_rq, int running)
         t->rt_param.linked_on          = NO_CPU;
 
         cedf_job_arrival(t);
-        spin_unlock_irqrestore(&(cluster->domain.ready_lock), flags);
+        raw_spin_unlock_irqrestore(&(cluster->domain.ready_lock), flags);
 }
 
 static void cedf_task_wake_up(struct task_struct *task)
@@ -526,7 +527,7 @@ static void cedf_task_wake_up(struct task_struct *task)
 
         cluster = task_cpu_cluster(task);
 
-        spin_lock_irqsave(&cluster->lock, flags);
+        raw_spin_lock_irqsave(&cluster->lock, flags);
         /* We need to take suspensions because of semaphores into
          * account! If a job resumes after being suspended due to acquiring
          * a semaphore, it should never be treated as a new job release.
@@ -549,7 +550,7 @@ static void cedf_task_wake_up(struct task_struct *task)
                 }
         }
         cedf_job_arrival(task);
-        spin_unlock_irqrestore(&cluster->lock, flags);
+        raw_spin_unlock_irqrestore(&cluster->lock, flags);
 }
 
 static void cedf_task_block(struct task_struct *t)
@@ -562,9 +563,9 @@ static void cedf_task_block(struct task_struct *t)
         cluster = task_cpu_cluster(t);
 
         /* unlink if necessary */
-        spin_lock_irqsave(&cluster->lock, flags);
+        raw_spin_lock_irqsave(&cluster->lock, flags);
         unlink(t);
-        spin_unlock_irqrestore(&cluster->lock, flags);
+        raw_spin_unlock_irqrestore(&cluster->lock, flags);
 
         BUG_ON(!is_realtime(t));
 }
@@ -576,13 +577,13 @@ static void cedf_task_exit(struct task_struct * t)
         cedf_domain_t *cluster = task_cpu_cluster(t);
 
         /* unlink if necessary */
-        spin_lock_irqsave(&cluster->lock, flags);
+        raw_spin_lock_irqsave(&cluster->lock, flags);
         unlink(t);
         if (tsk_rt(t)->scheduled_on != NO_CPU) {
                 cluster->cpus[tsk_rt(t)->scheduled_on]->scheduled = NULL;
                 tsk_rt(t)->scheduled_on = NO_CPU;
         }
-        spin_unlock_irqrestore(&cluster->lock, flags);
+        raw_spin_unlock_irqrestore(&cluster->lock, flags);
 
         BUG_ON(!is_realtime(t));
         TRACE_TASK(t, "RIP\n");
diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index 6137c74729cb..c0c63eba70ce 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -297,12 +297,12 @@ static void gsnedf_release_jobs(rt_domain_t* rt, struct bheap* tasks)
 {
         unsigned long flags;
 
-        spin_lock_irqsave(&gsnedf_lock, flags);
+        raw_spin_lock_irqsave(&gsnedf_lock, flags);
 
         __merge_ready(rt, tasks);
         check_for_preemptions();
 
-        spin_unlock_irqrestore(&gsnedf_lock, flags);
+        raw_spin_unlock_irqrestore(&gsnedf_lock, flags);
 }
 
 /* caller holds gsnedf_lock */
@@ -388,7 +388,7 @@ static struct task_struct* gsnedf_schedule(struct task_struct * prev)
         if (gsnedf.release_master == entry->cpu)
                 return NULL;
 
-        spin_lock(&gsnedf_lock);
+        raw_spin_lock(&gsnedf_lock);
         clear_will_schedule();
 
         /* sanity checking */
@@ -471,7 +471,7 @@ static struct task_struct* gsnedf_schedule(struct task_struct * prev)
                 if (exists)
                         next = prev;
 
-        spin_unlock(&gsnedf_lock);
+        raw_spin_unlock(&gsnedf_lock);
 
 #ifdef WANT_ALL_SCHED_EVENTS
         TRACE("gsnedf_lock released, next=0x%p\n", next);
@@ -509,7 +509,7 @@ static void gsnedf_task_new(struct task_struct * t, int on_rq, int running)
 
         TRACE("gsn edf: task new %d\n", t->pid);
 
-        spin_lock_irqsave(&gsnedf_lock, flags);
+        raw_spin_lock_irqsave(&gsnedf_lock, flags);
 
         /* setup job params */
         release_at(t, litmus_clock());
@@ -532,7 +532,7 @@ static void gsnedf_task_new(struct task_struct * t, int on_rq, int running)
         t->rt_param.linked_on          = NO_CPU;
 
         gsnedf_job_arrival(t);
-        spin_unlock_irqrestore(&gsnedf_lock, flags);
+        raw_spin_unlock_irqrestore(&gsnedf_lock, flags);
 }
 
 static void gsnedf_task_wake_up(struct task_struct *task)
@@ -542,7 +542,7 @@ static void gsnedf_task_wake_up(struct task_struct *task)
 
         TRACE_TASK(task, "wake_up at %llu\n", litmus_clock());
 
-        spin_lock_irqsave(&gsnedf_lock, flags);
+        raw_spin_lock_irqsave(&gsnedf_lock, flags);
         /* We need to take suspensions because of semaphores into
          * account! If a job resumes after being suspended due to acquiring
          * a semaphore, it should never be treated as a new job release.
@@ -565,7 +565,7 @@ static void gsnedf_task_wake_up(struct task_struct *task)
                 }
         }
         gsnedf_job_arrival(task);
-        spin_unlock_irqrestore(&gsnedf_lock, flags);
+        raw_spin_unlock_irqrestore(&gsnedf_lock, flags);
 }
 
 static void gsnedf_task_block(struct task_struct *t)
@@ -575,9 +575,9 @@ static void gsnedf_task_block(struct task_struct *t)
         TRACE_TASK(t, "block at %llu\n", litmus_clock());
 
         /* unlink if necessary */
-        spin_lock_irqsave(&gsnedf_lock, flags);
+        raw_spin_lock_irqsave(&gsnedf_lock, flags);
         unlink(t);
-        spin_unlock_irqrestore(&gsnedf_lock, flags);
+        raw_spin_unlock_irqrestore(&gsnedf_lock, flags);
 
         BUG_ON(!is_realtime(t));
 }
@@ -588,13 +588,13 @@ static void gsnedf_task_exit(struct task_struct * t)
         unsigned long flags;
 
         /* unlink if necessary */
-        spin_lock_irqsave(&gsnedf_lock, flags);
+        raw_spin_lock_irqsave(&gsnedf_lock, flags);
         unlink(t);
         if (tsk_rt(t)->scheduled_on != NO_CPU) {
                 gsnedf_cpus[tsk_rt(t)->scheduled_on]->scheduled = NULL;
                 tsk_rt(t)->scheduled_on = NO_CPU;
         }
-        spin_unlock_irqrestore(&gsnedf_lock, flags);
+        raw_spin_unlock_irqrestore(&gsnedf_lock, flags);
 
         BUG_ON(!is_realtime(t));
         TRACE_TASK(t, "RIP\n");
@@ -630,7 +630,7 @@ static void update_queue_position(struct task_struct *holder)
                             gsnedf_cpus[tsk_rt(holder)->linked_on]->hn);
         } else {
                 /* holder may be queued: first stop queue changes */
-                spin_lock(&gsnedf.release_lock);
+                raw_spin_lock(&gsnedf.release_lock);
                 if (is_queued(holder)) {
                         TRACE_TASK(holder, "%s: is queued\n",
                                    __FUNCTION__);
@@ -648,7 +648,7 @@ static void update_queue_position(struct task_struct *holder)
                         TRACE_TASK(holder, "%s: is NOT queued => Done.\n",
                                    __FUNCTION__);
                 }
-                spin_unlock(&gsnedf.release_lock);
+                raw_spin_unlock(&gsnedf.release_lock);
 
                 /* If holder was enqueued in a release heap, then the following
                  * preemption check is pointless, but we can't easily detect
@@ -682,7 +682,7 @@ static long gsnedf_pi_block(struct pi_semaphore *sem,
         if (edf_higher_prio(new_waiter, sem->hp.task)) {
                 TRACE_TASK(new_waiter, " boosts priority via %p\n", sem);
                 /* called with IRQs disabled */
-                spin_lock(&gsnedf_lock);
+                raw_spin_lock(&gsnedf_lock);
                 /* store new highest-priority task */
                 sem->hp.task = new_waiter;
                 if (sem->holder) {
@@ -694,7 +694,7 @@ static long gsnedf_pi_block(struct pi_semaphore *sem,
                         sem->holder->rt_param.inh_task = new_waiter;
                         update_queue_position(sem->holder);
                 }
-                spin_unlock(&gsnedf_lock);
+                raw_spin_unlock(&gsnedf_lock);
         }
 
         return 0;
@@ -740,7 +740,7 @@ static long gsnedf_return_priority(struct pi_semaphore *sem)
 
         if (t->rt_param.inh_task) {
                 /* interrupts already disabled by PI code */
-                spin_lock(&gsnedf_lock);
+                raw_spin_lock(&gsnedf_lock);
 
                 /* Reset inh_task to NULL. */
                 t->rt_param.inh_task = NULL;
@@ -748,7 +748,7 @@ static long gsnedf_return_priority(struct pi_semaphore *sem)
                 /* Check if rescheduling is necessary */
                 unlink(t);
                 gsnedf_job_arrival(t);
-                spin_unlock(&gsnedf_lock);
+                raw_spin_unlock(&gsnedf_lock);
         }
 
         return ret;
diff --git a/litmus/sched_pfair.c b/litmus/sched_pfair.c
index 2ea39223e7f0..ea77d3295290 100644
--- a/litmus/sched_pfair.c
+++ b/litmus/sched_pfair.c
@@ -12,6 +12,7 @@
 #include <linux/percpu.h>
 #include <linux/sched.h>
 #include <linux/list.h>
+#include <linux/slab.h>
 
 #include <litmus/litmus.h>
 #include <litmus/jobs.h>
@@ -415,7 +416,7 @@ static void schedule_next_quantum(quanta_t time)
         /* called with interrupts disabled */
         PTRACE("--- Q %lu at %llu PRE-SPIN\n",
                time, litmus_clock());
-        spin_lock(&pfair_lock);
+        raw_spin_lock(&pfair_lock);
         PTRACE("<<< Q %lu at %llu\n",
                time, litmus_clock());
 
@@ -448,7 +449,7 @@ static void schedule_next_quantum(quanta_t time)
         }
         PTRACE(">>> Q %lu at %llu\n",
                time, litmus_clock());
-        spin_unlock(&pfair_lock);
+        raw_spin_unlock(&pfair_lock);
 }
 
 static noinline void wait_for_quantum(quanta_t q, struct pfair_state* state)
@@ -564,7 +565,7 @@ static struct task_struct* pfair_schedule(struct task_struct * prev)
         int blocks;
         struct task_struct* next = NULL;
 
-        spin_lock(&pfair_lock);
+        raw_spin_lock(&pfair_lock);
 
         blocks  = is_realtime(prev) && !is_running(prev);
 
@@ -577,7 +578,7 @@ static struct task_struct* pfair_schedule(struct task_struct * prev)
                         tsk_rt(next)->scheduled_on = state->cpu;
         }
 
-        spin_unlock(&pfair_lock);
+        raw_spin_unlock(&pfair_lock);
 
         if (next)
                 TRACE_TASK(next, "scheduled rel=%lu at %lu (%llu)\n",
@@ -594,7 +595,7 @@ static void pfair_task_new(struct task_struct * t, int on_rq, int running)
 
         TRACE("pfair: task new %d state:%d\n", t->pid, t->state);
 
-        spin_lock_irqsave(&pfair_lock, flags);
+        raw_spin_lock_irqsave(&pfair_lock, flags);
         if (running)
                 t->rt_param.scheduled_on = task_cpu(t);
         else
@@ -605,7 +606,7 @@ static void pfair_task_new(struct task_struct * t, int on_rq, int running)
         pfair_add_release(t);
         check_preempt(t);
 
-        spin_unlock_irqrestore(&pfair_lock, flags);
+        raw_spin_unlock_irqrestore(&pfair_lock, flags);
 }
 
 static void pfair_task_wake_up(struct task_struct *t)
@@ -616,7 +617,7 @@ static void pfair_task_wake_up(struct task_struct *t)
         TRACE_TASK(t, "wakes at %llu, release=%lu, pfair_time:%lu\n",
                    litmus_clock(), cur_release(t), pfair_time);
 
-        spin_lock_irqsave(&pfair_lock, flags);
+        raw_spin_lock_irqsave(&pfair_lock, flags);
 
         /* It is a little unclear how to deal with Pfair
          * tasks that block for a while and then wake. For now,
@@ -637,7 +638,7 @@ static void pfair_task_wake_up(struct task_struct *t)
 
         check_preempt(t);
 
-        spin_unlock_irqrestore(&pfair_lock, flags);
+        raw_spin_unlock_irqrestore(&pfair_lock, flags);
         TRACE_TASK(t, "wake up done at %llu\n", litmus_clock());
 }
 
@@ -661,12 +662,12 @@ static void pfair_task_exit(struct task_struct * t)
          * might not be the same as the CPU that the PFAIR scheduler
          * has chosen for it.
          */
-        spin_lock_irqsave(&pfair_lock, flags);
+        raw_spin_lock_irqsave(&pfair_lock, flags);
 
         TRACE_TASK(t, "RIP, state:%d\n", t->state);
         drop_all_references(t);
 
-        spin_unlock_irqrestore(&pfair_lock, flags);
+        raw_spin_unlock_irqrestore(&pfair_lock, flags);
 
         kfree(t->rt_param.pfair);
         t->rt_param.pfair = NULL;
@@ -680,7 +681,7 @@ static void pfair_release_at(struct task_struct* task, lt_t start)
 
         BUG_ON(!is_realtime(task));
 
-        spin_lock_irqsave(&pfair_lock, flags);
+        raw_spin_lock_irqsave(&pfair_lock, flags);
         release_at(task, start);
         release = time2quanta(start, CEIL);
 
@@ -698,7 +699,7 @@ static void pfair_release_at(struct task_struct* task, lt_t start)
          */
         tsk_pfair(task)->sporadic_release = 0;
 
-        spin_unlock_irqrestore(&pfair_lock, flags);
+        raw_spin_unlock_irqrestore(&pfair_lock, flags);
 }
 
 static void init_subtask(struct subtask* sub, unsigned long i,
diff --git a/litmus/sched_plugin.c b/litmus/sched_plugin.c
index 3767b30e610a..3543b7baff53 100644
--- a/litmus/sched_plugin.c
+++ b/litmus/sched_plugin.c
@@ -187,7 +187,7 @@ struct sched_plugin *litmus = &linux_sched_plugin;
 
 /* the list of registered scheduling plugins */
 static LIST_HEAD(sched_plugins);
-static DEFINE_SPINLOCK(sched_plugins_lock);
+static DEFINE_RAW_SPINLOCK(sched_plugins_lock);
 
 #define CHECK(func) {\
         if (!plugin->func) \
@@ -220,9 +220,9 @@ int register_sched_plugin(struct sched_plugin* plugin)
         if (!plugin->release_at)
                 plugin->release_at = release_at;
 
-        spin_lock(&sched_plugins_lock);
+        raw_spin_lock(&sched_plugins_lock);
         list_add(&plugin->list, &sched_plugins);
-        spin_unlock(&sched_plugins_lock);
+        raw_spin_unlock(&sched_plugins_lock);
 
         return 0;
 }
@@ -234,7 +234,7 @@ struct sched_plugin* find_sched_plugin(const char* name)
         struct list_head *pos;
         struct sched_plugin *plugin;
 
-        spin_lock(&sched_plugins_lock);
+        raw_spin_lock(&sched_plugins_lock);
         list_for_each(pos, &sched_plugins) {
                 plugin = list_entry(pos, struct sched_plugin, list);
                 if (!strcmp(plugin->plugin_name, name))
@@ -243,7 +243,7 @@ struct sched_plugin* find_sched_plugin(const char* name)
         plugin = NULL;
 
 out_unlock:
-        spin_unlock(&sched_plugins_lock);
+        raw_spin_unlock(&sched_plugins_lock);
         return plugin;
 }
 
@@ -253,13 +253,13 @@ int print_sched_plugins(char* buf, int max)
         struct list_head *pos;
         struct sched_plugin *plugin;
 
-        spin_lock(&sched_plugins_lock);
+        raw_spin_lock(&sched_plugins_lock);
         list_for_each(pos, &sched_plugins) {
                 plugin = list_entry(pos, struct sched_plugin, list);
                 count += snprintf(buf + count, max - count, "%s\n", plugin->plugin_name);
                 if (max - count <= 0)
                         break;
         }
-        spin_unlock(&sched_plugins_lock);
+        raw_spin_unlock(&sched_plugins_lock);
         return  count;
 }
diff --git a/litmus/sched_psn_edf.c b/litmus/sched_psn_edf.c
index af0b30cb8b89..e50b27391d21 100644
--- a/litmus/sched_psn_edf.c
+++ b/litmus/sched_psn_edf.c
@@ -131,7 +131,7 @@ static struct task_struct* psnedf_schedule(struct task_struct * prev)
         int                     out_of_time, sleep, preempt,
                                 np, exists, blocks, resched;
 
-        spin_lock(&pedf->slock);
+        raw_spin_lock(&pedf->slock);
 
         /* sanity checking
          * differently from gedf, when a task exits (dead)
@@ -203,7 +203,7 @@ static struct task_struct* psnedf_schedule(struct task_struct * prev)
         }
 
         pedf->scheduled = next;
-        spin_unlock(&pedf->slock);
+        raw_spin_unlock(&pedf->slock);
 
         return next;
 }
@@ -226,7 +226,7 @@ static void psnedf_task_new(struct task_struct * t, int on_rq, int running)
         /* The task should be running in the queue, otherwise signal
          * code will try to wake it up with fatal consequences.
          */
-        spin_lock_irqsave(&pedf->slock, flags);
+        raw_spin_lock_irqsave(&pedf->slock, flags);
         if (running) {
                 /* there shouldn't be anything else running at the time */
                 BUG_ON(pedf->scheduled);
@@ -236,7 +236,7 @@ static void psnedf_task_new(struct task_struct * t, int on_rq, int running)
                 /* maybe we have to reschedule */
                 preempt(pedf);
         }
-        spin_unlock_irqrestore(&pedf->slock, flags);
+        raw_spin_unlock_irqrestore(&pedf->slock, flags);
 }
 
 static void psnedf_task_wake_up(struct task_struct *task)
@@ -247,7 +247,7 @@ static void psnedf_task_wake_up(struct task_struct *task)
         lt_t                    now;
 
         TRACE_TASK(task, "wake_up at %llu\n", litmus_clock());
-        spin_lock_irqsave(&pedf->slock, flags);
+        raw_spin_lock_irqsave(&pedf->slock, flags);
         BUG_ON(is_queued(task));
         /* We need to take suspensions because of semaphores into
          * account! If a job resumes after being suspended due to acquiring
@@ -272,7 +272,7 @@ static void psnedf_task_wake_up(struct task_struct *task)
         if (pedf->scheduled != task)
                 requeue(task, edf);
 
-        spin_unlock_irqrestore(&pedf->slock, flags);
+        raw_spin_unlock_irqrestore(&pedf->slock, flags);
         TRACE_TASK(task, "wake up done\n");
 }
 
@@ -291,7 +291,7 @@ static void psnedf_task_exit(struct task_struct * t)
         psnedf_domain_t*        pedf = task_pedf(t);
         rt_domain_t*            edf;
 
-        spin_lock_irqsave(&pedf->slock, flags);
+        raw_spin_lock_irqsave(&pedf->slock, flags);
         if (is_queued(t)) {
                 /* dequeue */
                 edf  = task_edf(t);
@@ -303,7 +303,7 @@ static void psnedf_task_exit(struct task_struct * t)
         TRACE_TASK(t, "RIP, now reschedule\n");
 
         preempt(pedf);
-        spin_unlock_irqrestore(&pedf->slock, flags);
+        raw_spin_unlock_irqrestore(&pedf->slock, flags);
 }
 
 #ifdef CONFIG_FMLP
@@ -323,7 +323,7 @@ static long psnedf_pi_block(struct pi_semaphore *sem,
                 edf  = task_edf(new_waiter);
 
                 /* interrupts already disabled */
-                spin_lock(&pedf->slock);
+                raw_spin_lock(&pedf->slock);
 
                 /* store new highest-priority task */
                 sem->hp.cpu_task[cpu] = new_waiter;
@@ -348,7 +348,7 @@ static long psnedf_pi_block(struct pi_semaphore *sem,
                 if (edf_preemption_needed(edf, current))
                         preempt(pedf);
 
-                spin_unlock(&pedf->slock);
+                raw_spin_unlock(&pedf->slock);
         }
 
         return 0;
@@ -415,7 +415,7 @@ static long psnedf_return_priority(struct pi_semaphore *sem)
         /* Always check for delayed preemptions that might have become
          * necessary due to non-preemptive execution.
          */
-        spin_lock(&pedf->slock);
+        raw_spin_lock(&pedf->slock);
 
         /* Reset inh_task to NULL. */
         current->rt_param.inh_task = NULL;
@@ -424,7 +424,7 @@ static long psnedf_return_priority(struct pi_semaphore *sem)
         if (edf_preemption_needed(edf, current))
                 preempt(pedf);
 
-        spin_unlock(&pedf->slock);
+        raw_spin_unlock(&pedf->slock);
 
 
         return ret;