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.

8 files changed, 78 insertions, 75 deletions

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 e43596a5104c..99714d06eed5 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);
 
@@ -323,7 +323,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);
@@ -350,7 +350,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;
 }
@@ -396,7 +396,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) {
@@ -414,7 +414,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 da44b451c9ad..118fbd14fe25 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -24,6 +24,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>
@@ -281,12 +282,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 */
@@ -367,7 +368,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 */
@@ -448,7 +449,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);
@@ -490,7 +491,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());
@@ -507,7 +508,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)
@@ -520,7 +521,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.
@@ -543,7 +544,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)
@@ -556,9 +557,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));
 }
@@ -570,13 +571,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 b9310dd6f75c..7424c183d8b2 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 */
@@ -469,7 +469,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);
@@ -507,7 +507,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());
@@ -530,7 +530,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)
@@ -540,7 +540,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.
@@ -563,7 +563,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)
@@ -573,9 +573,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));
 }
@@ -586,13 +586,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");
@@ -628,7 +628,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__);
@@ -646,7 +646,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
@@ -680,7 +680,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) {
@@ -692,7 +692,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;
@@ -738,7 +738,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;
@@ -746,7 +746,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 7f71ecfaaaae..7a548bf5162e 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)
@@ -201,7 +201,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;
 }
@@ -224,7 +224,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);
@@ -234,7 +234,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)
@@ -245,7 +245,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
@@ -270,7 +270,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");
 }
 
@@ -289,7 +289,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);
@@ -301,7 +301,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
@@ -321,7 +321,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;
@@ -346,7 +346,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;
@@ -413,7 +413,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;
@@ -422,7 +422,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;