resolve rebase issues

4 files changed, 83 insertions, 178 deletions

diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index f6fa8a339d48..2837f12953ea 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -87,11 +87,6 @@
 #include <litmus/gpu_affinity.h>
 #endif
 
-
-/* TODO: Move this to litmus/Kconfig */
-#define RECURSIVE_READY_QUEUE_LOCK
-
-
 /* Reference configuration variable. Determines which cache level is used to
  * group CPUs into clusters.  GLOBAL_CLUSTER, which is the default, means that
  * all CPUs form a single cluster (just like GSN-EDF).
@@ -138,10 +133,8 @@ typedef struct clusterdomain {
         cpumask_var_t   cpu_map;
         /* the cpus queue themselves according to priority in here */
         struct binheap cpu_heap;
-#ifdef RECURSIVE_READY_QUEUE_LOCK
-        int                     recursive_depth;
-        atomic_t        owner_cpu;
-#endif
+
+#define cluster_lock domain.ready_lock
 
 #ifdef CONFIG_LITMUS_PAI_SOFTIRQD
         struct tasklet_head pending_tasklets;
@@ -158,81 +151,6 @@ typedef struct clusterdomain {
 } cedf_domain_t;
 
 
-#ifdef RECURSIVE_READY_QUEUE_LOCK
-#define lock_readyq_irqsave(cluster, flags) \
-do { \
-        if (unlikely(irqs_disabled() && atomic_read(&cluster->owner_cpu) == smp_processor_id())) { \
-                local_irq_save(flags); /* useless. makes compiler happy though */ \
-                ++cluster->recursive_depth; \
-        } \
-        else { \
-                raw_spin_lock_irqsave(&cluster->domain.ready_lock, flags); \
-                atomic_set(&cluster->owner_cpu, smp_processor_id()); \
-                BUG_ON(cluster->recursive_depth != 0); \
-        } \
-}while(0)
-
-#define lock_readyq(cluster) \
-do { \
-        if (unlikely(irqs_disabled() && atomic_read(&cluster->owner_cpu) == smp_processor_id())) \
-                ++cluster->recursive_depth; \
-        else { \
-                raw_spin_lock(&cluster->domain.ready_lock); \
-                atomic_set(&cluster->owner_cpu, smp_processor_id()); \
-                BUG_ON(cluster->recursive_depth != 0); \
-        } \
-}while(0)
-
-#define unlock_readyq_irqrestore(cluster, flags) \
-do { \
-        BUG_ON(!raw_spin_is_locked(&cluster->domain.ready_lock)); \
-        BUG_ON(atomic_read(&cluster->owner_cpu) != smp_processor_id()); \
-        if (unlikely(cluster->recursive_depth > 0)) { \
-                --cluster->recursive_depth; \
-                local_irq_restore(flags); /* useless. makes compiler happy though */ \
-        } \
-        else { \
-                atomic_set(&cluster->owner_cpu, NO_CPU); \
-                raw_spin_unlock_irqrestore(&cluster->domain.ready_lock, flags); \
-        } \
-}while(0)
-
-#define unlock_readyq(cluster) \
-do { \
-        BUG_ON(!raw_spin_is_locked(&cluster->domain.ready_lock)); \
-        if (unlikely(cluster->recursive_depth > 0)) { \
-                BUG_ON(atomic_read(&cluster->owner_cpu) != smp_processor_id()); \
-                --cluster->recursive_depth; \
-        } \
-        else { \
-                atomic_set(&cluster->owner_cpu, NO_CPU); \
-                raw_spin_unlock(&cluster->domain.ready_lock); \
-        } \
-}while(0)
-
-#else
-#define lock_readyq_irqsave(cluster, flags) \
-do {\
-        raw_spin_lock_irqsave(&cluster->domain.ready_lock, flags); \
-}while(0)
-
-#define lock_readyq(cluster) \
-do {\
-        raw_spin_lock(&cluster->domain.ready_lock); \
-}while(0)
-
-#define unlock_readyq_irqrestore(cluster, flags) \
-do {\
-        raw_spin_unlock_irqrestore(&cluster->domain.ready_lock, flags); \
-}while(0)
-
-#define unlock_readyq(cluster) \
-do {\
-        raw_spin_unlock(&cluster->domain.ready_lock); \
-}while(0)
-#endif
-
-
 /* a cedf_domain per cluster; allocation is done at init/activation time */
 cedf_domain_t *cedf;
 
@@ -644,14 +562,14 @@ 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;
 
-        lock_readyq_irqsave(cluster, flags);
+        raw_readyq_lock_irqsave(&cluster->cluster_lock, flags);
 
         bheap_for_each(tasks, cedf_track_on_release, NULL);
 
         __merge_ready(&cluster->domain, tasks);
         check_for_preemptions(cluster);
 
-        unlock_readyq_irqrestore(cluster, flags);
+        raw_readyq_unlock_irqrestore(&cluster->cluster_lock, flags);
 }
 
 /* caller holds cluster_lock */
@@ -803,7 +721,6 @@ static enum hrtimer_restart cedf_sobliv_on_exhausted(struct task_struct *t)
         if (budget_enforced(t) && !bt_flag_is_set(t, BTF_BUDGET_EXHAUSTED)) {
                 if (is_np(t) && is_user_np(t)) {
                         TRACE_TASK(t, "is non-preemptable, preemption delayed.\n");
-
                         bt_flag_set(t, BTF_BUDGET_EXHAUSTED);
                         request_exit_np(t);
                 }
@@ -846,9 +763,9 @@ static enum hrtimer_restart cedf_sobliv_on_exhausted(struct task_struct *t)
                                  * must grab it every time since it must be take before the
                                  * cluster lock. */
                                 raw_spin_lock_irqsave(&cluster->dgl_lock, flags);
-                                lock_readyq(cluster);
+                                raw_readyq_lock(&cluster->cluster_lock);
 #else
-                                lock_readyq_irqsave(cluster, flags);
+                                raw_readyq_lock_irqsave(&cluster->cluster_lock, flags);
 #endif
 
                                 job_completion(t, 1); /* refreshes budget and pushes out deadline */
@@ -887,7 +804,6 @@ static enum hrtimer_restart cedf_sobliv_on_exhausted(struct task_struct *t)
                                         }
                                 }
 #endif
-//                              unlock_readyq_irqrestore(cluster, flags);
 
 #ifdef CONFIG_LITMUS_LOCKING
                                 /* Check our inheritance and propagate any changes forward. */
@@ -905,17 +821,15 @@ static enum hrtimer_restart cedf_sobliv_on_exhausted(struct task_struct *t)
 
 #ifdef CONFIG_LITMUS_LOCKING
                                 /* double-check that everything is okay */
-//                              lock_readyq_irqsave(cluster, flags);
                                 check_for_preemptions(cluster);
-//                              unlock_readyq_irqrestore(cluster, flags);
 #endif
 
                                 /* should be the outermost unlock call */
 #ifdef CONFIG_LITMUS_DGL_SUPPORT
-                                unlock_readyq(cluster);
+                                raw_readyq_unlock(&cluster->cluster_lock);
                                 raw_spin_unlock_irqrestore(&cluster->dgl_lock, flags);
 #else
-                                unlock_readyq_irqrestore(cluster, flags);
+                                raw_readyq_unlock_irqrestore(&cluster->cluster_lock, flags);
 #endif
 
                                 /* we need to set up the budget timer since we're within the callback. */
@@ -993,7 +907,7 @@ static void do_lit_tasklets(cedf_domain_t* cluster, struct task_struct* sched_ta
 
                 TS_NV_SCHED_BOTISR_START;
 
-                lock_readyq_irqsave(cluster, flags);
+                raw_readyq_lock_irqsave(&cluster->cluster_lock, flags);
 
                 if(cluster->pending_tasklets.head != NULL) {
                         // remove tasklet at head.
@@ -1035,7 +949,7 @@ static void do_lit_tasklets(cedf_domain_t* cluster, struct task_struct* sched_ta
                         TRACE("%s: Tasklet queue is empty.\n", __FUNCTION__);
                 }
 
-                unlock_readyq_irqrestore(cluster, flags);
+                raw_readyq_unlock_irqrestore(&cluster->cluster_lock, flags);
 
                 if(tasklet) {
                         __do_lit_tasklet(tasklet, 0ul);
@@ -1143,7 +1057,7 @@ static int cedf_enqueue_pai_tasklet(struct tasklet_struct* tasklet)
 
         cluster = task_cpu_cluster(tasklet->owner);
 
-        lock_readyq_irqsave(cluster, flags);
+        raw_readyq_lock_irqsave(&cluster->cluster_lock, flags);
 
         thisCPU = smp_processor_id();
 
@@ -1194,7 +1108,7 @@ static int cedf_enqueue_pai_tasklet(struct tasklet_struct* tasklet)
                 __add_pai_tasklet(tasklet, cluster);
         }
 
-        unlock_readyq_irqrestore(cluster, flags);
+        raw_readyq_unlock_irqrestore(&cluster->cluster_lock, flags);
 
 
         if (runLocal /*&& runNow */) {  // runNow == 1 is implied
@@ -1231,14 +1145,14 @@ static void cedf_change_prio_pai_tasklet(struct task_struct *old_prio,
                 cluster = task_cpu_cluster(probe);
 
                 if(cluster->pending_tasklets.head != NULL) {
-                        lock_readyq_irqsave(cluster, flags);
+                        raw_readyq_lock_irqsave(&cluster->cluster_lock, flags);
                         for(step = cluster->pending_tasklets.head; step != NULL; step = step->next) {
                                 if(step->owner == old_prio) {
                                         TRACE("%s: Found tasklet to change: %d\n", __FUNCTION__, step->owner->pid);
                                         step->owner = new_prio;
                                 }
                         }
-                        unlock_readyq_irqrestore(cluster, flags);
+                        raw_readyq_unlock_irqrestore(&cluster->cluster_lock, flags);
                 }
         }
         else {
@@ -1287,7 +1201,7 @@ static struct task_struct* cedf_schedule(struct task_struct * prev)
         }
 #endif
 
-        lock_readyq(cluster);
+        raw_readyq_lock(&cluster->cluster_lock);
         clear_will_schedule();
 
         /* sanity checking */
@@ -1411,7 +1325,7 @@ out_set_state:
 #endif
 
         sched_state_task_picked();
-        unlock_readyq(cluster);
+        raw_readyq_unlock(&cluster->cluster_lock);
 
 #ifdef WANT_ALL_SCHED_EVENTS
         TRACE("cluster_lock released, next=0x%p\n", next);
@@ -1452,7 +1366,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);
 
-        lock_readyq_irqsave(cluster, flags);
+        raw_readyq_lock_irqsave(&cluster->cluster_lock, flags);
 
         /* setup job params */
         release_at(t, litmus_clock());
@@ -1484,7 +1398,7 @@ static void cedf_task_new(struct task_struct * t, int on_rq, int running)
                 cedf_job_arrival(t);
         }
 
-        unlock_readyq_irqrestore(cluster, flags);
+        raw_readyq_unlock_irqrestore(&cluster->cluster_lock, flags);
 }
 
 static void cedf_task_wake_up(struct task_struct *t)
@@ -1495,7 +1409,7 @@ static void cedf_task_wake_up(struct task_struct *t)
 
         cluster = task_cpu_cluster(t);
 
-        lock_readyq_irqsave(cluster, flags);
+        raw_readyq_lock_irqsave(&cluster->cluster_lock, flags);
 
         now = litmus_clock();
         TRACE_TASK(t, "wake_up at %llu\n", now);
@@ -1527,7 +1441,7 @@ static void cedf_task_wake_up(struct task_struct *t)
         budget_state_machine(t,on_wakeup);
         cedf_job_arrival(t);
 
-        unlock_readyq_irqrestore(cluster, flags);
+        raw_readyq_unlock_irqrestore(&cluster->cluster_lock, flags);
 }
 
 static void cedf_task_block(struct task_struct *t)
@@ -1540,7 +1454,7 @@ static void cedf_task_block(struct task_struct *t)
         cluster = task_cpu_cluster(t);
 
         /* unlink if necessary */
-        lock_readyq_irqsave(cluster, flags);
+        raw_readyq_lock_irqsave(&cluster->cluster_lock, flags);
 
         unlink(t);
 
@@ -1560,7 +1474,7 @@ static void cedf_task_block(struct task_struct *t)
         }
 #endif
 
-        unlock_readyq_irqrestore(cluster, flags);
+        raw_readyq_unlock_irqrestore(&cluster->cluster_lock, flags);
 
         BUG_ON(!is_realtime(t));
 }
@@ -1576,7 +1490,7 @@ static void cedf_task_exit(struct task_struct * t)
 #endif
 
         /* unlink if necessary */
-        lock_readyq_irqsave(cluster, flags);
+        raw_readyq_lock_irqsave(&cluster->cluster_lock, flags);
 
         if (tsk_rt(t)->inh_task) {
                 WARN_ON(1);
@@ -1612,7 +1526,7 @@ static void cedf_task_exit(struct task_struct * t)
                 cpu->scheduled = NULL;
                 tsk_rt(t)->scheduled_on = NO_CPU;
         }
-        unlock_readyq_irqrestore(cluster, flags);
+        raw_readyq_unlock_irqrestore(&cluster->cluster_lock, flags);
 
         BUG_ON(!is_realtime(t));
         TRACE_TASK(t, "RIP\n");
@@ -1702,8 +1616,6 @@ static long cedf_admit_task(struct task_struct* tsk)
 
 #include <litmus/fdso.h>
 
-
-
 /* called with IRQs off */
 static int __increase_priority_inheritance(struct task_struct* t,
                                                                                     struct task_struct* prio_inh)
@@ -1876,13 +1788,13 @@ static void increase_priority_inheritance(struct task_struct* t, struct task_str
 {
         cedf_domain_t* cluster = task_cpu_cluster(t);
 
-        lock_readyq(cluster);
+        raw_readyq_lock(&cluster->cluster_lock);
 
         TRACE_TASK(t, "to inherit from %s/%d\n", prio_inh->comm, prio_inh->pid);
 
         __increase_priority_inheritance(t, prio_inh);
 
-        unlock_readyq(cluster);
+        raw_readyq_unlock(&cluster->cluster_lock);
 
 #if defined(CONFIG_LITMUS_PAI_SOFTIRQD) && defined(CONFIG_LITMUS_NVIDIA)
         if(tsk_rt(t)->held_gpus) {
@@ -2046,7 +1958,7 @@ static void decrease_priority_inheritance(struct task_struct* t,
 {
         cedf_domain_t* cluster = task_cpu_cluster(t);
 
-        lock_readyq(cluster);
+        raw_readyq_lock(&cluster->cluster_lock);
 
         TRACE_TASK(t, "to inherit from %s/%d (decrease)\n",
                         (prio_inh) ? prio_inh->comm : "null",
@@ -2054,7 +1966,7 @@ static void decrease_priority_inheritance(struct task_struct* t,
 
         __decrease_priority_inheritance(t, prio_inh, budget_tiggered);
 
-        unlock_readyq(cluster);
+        raw_readyq_unlock(&cluster->cluster_lock);
 
 #if defined(CONFIG_LITMUS_PAI_SOFTIRQD) && defined(CONFIG_LITMUS_NVIDIA)
         if(tsk_rt(t)->held_gpus) {
@@ -2093,7 +2005,6 @@ static void nested_increase_priority_inheritance(struct task_struct* t,
 
         raw_spin_unlock(&tsk_rt(t)->hp_blocked_tasks_lock);  // unlock the t's heap.
 
-
         if(blocked_lock) {
                 if(blocked_lock->ops->supports_nesting) {
                         TRACE_TASK(t, "Inheritor is blocked (...perhaps).  Checking lock %d.\n",
@@ -2136,7 +2047,6 @@ static void nested_decrease_priority_inheritance(struct task_struct* t,
                 if(blocked_lock->ops->supports_nesting) {
                         TRACE_TASK(t, "Inheritor is blocked (...perhaps).  Checking lock %d.\n",
                                            blocked_lock->ident);
-
                         // beware: recursion
                         blocked_lock->ops->propagate_decrease_inheritance(blocked_lock, t,
                                                                                                                           to_unlock,
@@ -2254,10 +2164,6 @@ static struct litmus_lock* cedf_new_ikglp(void* __user arg)
         return ikglp_new(cluster_size, &cedf_ikglp_lock_ops, arg);
 }
 
-#endif  /* CONFIG_LITMUS_NESTED_LOCKING */
-
-
-
 
 /* ******************** KFMLP support ********************** */
 
@@ -2382,8 +2288,7 @@ UNSUPPORTED_AFF_OBS:
         return err;
 }
 #endif
-
-
+#endif // CONFIG_LITMUS_AFFINITY_LOCKING
 
 
 #ifdef VERBOSE_INIT
diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index ab97d59c9587..3084f377a5f1 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -389,13 +389,13 @@ static void gsnedf_release_jobs(rt_domain_t* rt, struct bheap* tasks)
 {
         unsigned long flags;
 
-        raw_spin_lock_irqsave(&gsnedf_lock, flags);
+        raw_readyq_lock_irqsave(&gsnedf_lock, flags);
 
         __merge_ready(rt, tasks);
 
         check_for_preemptions();
 
-        raw_spin_unlock_irqrestore(&gsnedf_lock, flags);
+        raw_readyq_unlock_irqrestore(&gsnedf_lock, flags);
 }
 
 /* caller holds gsnedf_lock */
@@ -509,7 +509,7 @@ static void do_lit_tasklets(struct task_struct* sched_task)
                 TS_NV_SCHED_BOTISR_START;
 
                 // execute one tasklet that has higher priority
-                raw_spin_lock_irqsave(&gsnedf_lock, flags);
+                raw_readyq_lock_irqsave(&gsnedf_lock, flags);
 
                 if(gsnedf_pending_tasklets.head != NULL) {
                         struct tasklet_struct *prev = NULL;
@@ -540,7 +540,7 @@ static void do_lit_tasklets(struct task_struct* sched_task)
                         TRACE("%s: Tasklet queue is empty.\n", __FUNCTION__);
                 }
 
-                raw_spin_unlock_irqrestore(&gsnedf_lock, flags);
+                raw_readyq_unlock_irqrestore(&gsnedf_lock, flags);
 
                 if(tasklet) {
                         __do_lit_tasklet(tasklet, 0ul);
@@ -683,7 +683,7 @@ static int gsnedf_enqueue_pai_tasklet(struct tasklet_struct* tasklet)
     }
 
 
-        raw_spin_lock_irqsave(&gsnedf_lock, flags);
+        raw_readyq_lock_irqsave(&gsnedf_lock, flags);
 
         thisCPU = smp_processor_id();
 
@@ -738,7 +738,7 @@ static int gsnedf_enqueue_pai_tasklet(struct tasklet_struct* tasklet)
                 __add_pai_tasklet(tasklet);
         }
 
-        raw_spin_unlock_irqrestore(&gsnedf_lock, flags);
+        raw_readyq_unlock_irqrestore(&gsnedf_lock, flags);
 
 
         if (runLocal /*&& runNow */) {  // runNow == 1 is implied
@@ -763,14 +763,14 @@ static void gsnedf_change_prio_pai_tasklet(struct task_struct *old_prio,
         unsigned long flags;
 
         if(gsnedf_pending_tasklets.head != NULL) {
-                raw_spin_lock_irqsave(&gsnedf_lock, flags);
+                raw_readyq_lock_irqsave(&gsnedf_lock, flags);
                 for(step = gsnedf_pending_tasklets.head; step != NULL; step = step->next) {
                         if(step->owner == old_prio) {
                                 TRACE("%s: Found tasklet to change: %d\n", __FUNCTION__, step->owner->pid);
                                 step->owner = new_prio;
                         }
                 }
-                raw_spin_unlock_irqrestore(&gsnedf_lock, flags);
+                raw_readyq_unlock_irqrestore(&gsnedf_lock, flags);
         }
 }
 
@@ -814,7 +814,7 @@ static struct task_struct* gsnedf_schedule(struct task_struct * prev)
         }
 #endif
 
-        raw_spin_lock(&gsnedf_lock);
+        raw_readyq_lock(&gsnedf_lock);
 
         /* sanity checking */
         BUG_ON(entry->scheduled && entry->scheduled != prev);
@@ -930,7 +930,7 @@ static struct task_struct* gsnedf_schedule(struct task_struct * prev)
 
         sched_state_task_picked();
 
-        raw_spin_unlock(&gsnedf_lock);
+        raw_readyq_unlock(&gsnedf_lock);
 
 #ifdef WANT_ALL_SCHED_EVENTS
         TRACE("gsnedf_lock released, next=0x%p\n", next);
@@ -968,7 +968,7 @@ static void gsnedf_task_new(struct task_struct * t, int on_rq, int running)
 
         TRACE("gsn edf: task new = %d on_rq = %d running = %d\n", t->pid, on_rq, running);
 
-        raw_spin_lock_irqsave(&gsnedf_lock, flags);
+        raw_readyq_lock_irqsave(&gsnedf_lock, flags);
 
         /* setup job params */
         release_at(t, litmus_clock());
@@ -995,7 +995,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);
-        raw_spin_unlock_irqrestore(&gsnedf_lock, flags);
+        raw_readyq_unlock_irqrestore(&gsnedf_lock, flags);
 }
 
 static void gsnedf_task_wake_up(struct task_struct *task)
@@ -1005,7 +1005,7 @@ static void gsnedf_task_wake_up(struct task_struct *task)
 
         TRACE_TASK(task, "wake_up at %llu\n", litmus_clock());
 
-        raw_spin_lock_irqsave(&gsnedf_lock, flags);
+        raw_readyq_lock_irqsave(&gsnedf_lock, flags);
 
 #if 0
         /* sporadic task model. will increment job numbers automatically */
@@ -1042,7 +1042,7 @@ static void gsnedf_task_wake_up(struct task_struct *task)
 #endif
 
         gsnedf_job_arrival(task);
-        raw_spin_unlock_irqrestore(&gsnedf_lock, flags);
+        raw_readyq_unlock_irqrestore(&gsnedf_lock, flags);
 }
 
 static void gsnedf_task_block(struct task_struct *t)
@@ -1052,7 +1052,7 @@ static void gsnedf_task_block(struct task_struct *t)
         TRACE_TASK(t, "block at %llu\n", litmus_clock());
 
         /* unlink if necessary */
-        raw_spin_lock_irqsave(&gsnedf_lock, flags);
+        raw_readyq_lock_irqsave(&gsnedf_lock, flags);
 
         unlink(t);
 
@@ -1072,7 +1072,7 @@ static void gsnedf_task_block(struct task_struct *t)
         }
 #endif
 
-        raw_spin_unlock_irqrestore(&gsnedf_lock, flags);
+        raw_readyq_unlock_irqrestore(&gsnedf_lock, flags);
 
         BUG_ON(!is_realtime(t));
 }
@@ -1087,7 +1087,7 @@ static void gsnedf_task_exit(struct task_struct * t)
 #endif
 
         /* unlink if necessary */
-        raw_spin_lock_irqsave(&gsnedf_lock, flags);
+        raw_readyq_lock_irqsave(&gsnedf_lock, flags);
 
         /* disable budget enforcement */
         if (tsk_rt(t)->budget.ops)
@@ -1115,7 +1115,7 @@ static void gsnedf_task_exit(struct task_struct * t)
                 gsnedf_cpus[tsk_rt(t)->scheduled_on]->scheduled = NULL;
                 tsk_rt(t)->scheduled_on = NO_CPU;
         }
-        raw_spin_unlock_irqrestore(&gsnedf_lock, flags);
+        raw_readyq_unlock_irqrestore(&gsnedf_lock, flags);
 
         BUG_ON(!is_realtime(t));
         TRACE_TASK(t, "RIP\n");
@@ -1275,11 +1275,11 @@ static void increase_priority_inheritance(struct task_struct* t, struct task_str
 {
         int success;
 
-        raw_spin_lock(&gsnedf_lock);
+        raw_readyq_lock(&gsnedf_lock);
 
         success = __increase_priority_inheritance(t, prio_inh);
 
-        raw_spin_unlock(&gsnedf_lock);
+        raw_readyq_unlock(&gsnedf_lock);
 
 #if defined(CONFIG_LITMUS_PAI_SOFTIRQD) && defined(CONFIG_LITMUS_NVIDIA)
         if(tsk_rt(t)->held_gpus) {
@@ -1385,11 +1385,11 @@ static void decrease_priority_inheritance(struct task_struct* t,
 {
         int success;
 
-        raw_spin_lock(&gsnedf_lock);
+        raw_readyq_lock(&gsnedf_lock);
 
         success = __decrease_priority_inheritance(t, prio_inh, budget_triggered);
 
-        raw_spin_unlock(&gsnedf_lock);
+        raw_readyq_unlock(&gsnedf_lock);
 
 #if defined(CONFIG_LITMUS_PAI_SOFTIRQD) && defined(CONFIG_LITMUS_NVIDIA)
         if(tsk_rt(t)->held_gpus) {
diff --git a/litmus/sched_pfp.c b/litmus/sched_pfp.c
index 3ff131e58553..ad2b8d81f29f 100644
--- a/litmus/sched_pfp.c
+++ b/litmus/sched_pfp.c
@@ -76,7 +76,7 @@ static void pfp_release_jobs(rt_domain_t* rt, struct bheap* tasks)
         struct task_struct* t;
         struct bheap_node* hn;
 
-        raw_spin_lock_irqsave(&pfp->slock, flags);
+        raw_readyq_lock_irqsave(&pfp->slock, flags);
 
         while (!bheap_empty(tasks)) {
                 hn = bheap_take(fp_ready_order, tasks);
@@ -92,7 +92,7 @@ static void pfp_release_jobs(rt_domain_t* rt, struct bheap* tasks)
                 preempt(pfp);
         }
 
-        raw_spin_unlock_irqrestore(&pfp->slock, flags);
+        raw_readyq_unlock_irqrestore(&pfp->slock, flags);
 }
 
 static void pfp_preempt_check(pfp_domain_t *pfp)
@@ -186,7 +186,7 @@ static struct task_struct* pfp_schedule(struct task_struct * prev)
 
         int out_of_time, sleep, preempt, np, exists, blocks, resched, migrate;
 
-        raw_spin_lock(&pfp->slock);
+        raw_readyq_lock(&pfp->slock);
 
         /* sanity checking
          * differently from gedf, when a task exits (dead)
@@ -292,7 +292,7 @@ static struct task_struct* pfp_schedule(struct task_struct * prev)
 
         pfp->scheduled = next;
         sched_state_task_picked();
-        raw_spin_unlock(&pfp->slock);
+        raw_readyq_unlock(&pfp->slock);
 
         return next;
 }
@@ -312,14 +312,14 @@ static void pfp_finish_switch(struct task_struct *prev)
 
                 to = task_pfp(prev);
 
-                raw_spin_lock(&to->slock);
+                raw_readyq_lock(&to->slock);
 
                 TRACE_TASK(prev, "adding to queue on P%d\n", to->cpu);
                 requeue(prev, to);
                 if (fp_preemption_needed(&to->ready_queue, to->scheduled))
                         preempt(to);
 
-                raw_spin_unlock(&to->slock);
+                raw_readyq_unlock(&to->slock);
 
         }
 }
@@ -342,7 +342,7 @@ static void pfp_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.
          */
-        raw_spin_lock_irqsave(&pfp->slock, flags);
+        raw_readyq_lock_irqsave(&pfp->slock, flags);
         if (running) {
                 /* there shouldn't be anything else running at the time */
                 BUG_ON(pfp->scheduled);
@@ -352,7 +352,7 @@ static void pfp_task_new(struct task_struct * t, int on_rq, int running)
                 /* maybe we have to reschedule */
                 pfp_preempt_check(pfp);
         }
-        raw_spin_unlock_irqrestore(&pfp->slock, flags);
+        raw_readyq_unlock_irqrestore(&pfp->slock, flags);
 }
 
 static void pfp_task_wake_up(struct task_struct *task)
@@ -362,7 +362,7 @@ static void pfp_task_wake_up(struct task_struct *task)
         lt_t                    now;
 
         TRACE_TASK(task, "wake_up at %llu\n", litmus_clock());
-        raw_spin_lock_irqsave(&pfp->slock, flags);
+        raw_readyq_lock_irqsave(&pfp->slock, flags);
 
 #ifdef CONFIG_LITMUS_LOCKING
         /* Should only be queued when processing a fake-wake up due to a
@@ -404,7 +404,7 @@ static void pfp_task_wake_up(struct task_struct *task)
 #ifdef CONFIG_LITMUS_LOCKING
 out_unlock:
 #endif
-        raw_spin_unlock_irqrestore(&pfp->slock, flags);
+        raw_readyq_unlock_irqrestore(&pfp->slock, flags);
         TRACE_TASK(task, "wake up done\n");
 }
 
@@ -433,7 +433,7 @@ static void pfp_task_exit(struct task_struct * t)
         pfp_domain_t*   pfp = task_pfp(t);
         rt_domain_t*            dom;
 
-        raw_spin_lock_irqsave(&pfp->slock, flags);
+        raw_readyq_lock_irqsave(&pfp->slock, flags);
 
         /* disable budget enforcement */
         if (tsk_rt(t)->budget.ops)
@@ -451,7 +451,7 @@ static void pfp_task_exit(struct task_struct * t)
         }
         TRACE_TASK(t, "RIP, now reschedule\n");
 
-        raw_spin_unlock_irqrestore(&pfp->slock, flags);
+        raw_readyq_unlock_irqrestore(&pfp->slock, flags);
 }
 
 #ifdef CONFIG_LITMUS_LOCKING
@@ -514,7 +514,7 @@ static void boost_priority(struct task_struct* t, lt_t priority_point)
         unsigned long           flags;
         pfp_domain_t*   pfp = task_pfp(t);
 
-        raw_spin_lock_irqsave(&pfp->slock, flags);
+        raw_readyq_lock_irqsave(&pfp->slock, flags);
 
 
         TRACE_TASK(t, "priority boosted at %llu\n", litmus_clock());
@@ -528,7 +528,7 @@ static void boost_priority(struct task_struct* t, lt_t priority_point)
          * part of lock acquisitions. */
         BUG_ON(pfp->scheduled != t);
 
-        raw_spin_unlock_irqrestore(&pfp->slock, flags);
+        raw_readyq_unlock_irqrestore(&pfp->slock, flags);
 }
 
 static void unboost_priority(struct task_struct* t)
@@ -537,7 +537,7 @@ static void unboost_priority(struct task_struct* t)
         pfp_domain_t*   pfp = task_pfp(t);
         lt_t                    now;
 
-        raw_spin_lock_irqsave(&pfp->slock, flags);
+        raw_readyq_lock_irqsave(&pfp->slock, flags);
         now = litmus_clock();
 
         /* assumption: this only happens when the job is scheduled */
@@ -555,7 +555,7 @@ static void unboost_priority(struct task_struct* t)
         if (fp_preemption_needed(&pfp->ready_queue, pfp->scheduled))
                 preempt(pfp);
 
-        raw_spin_unlock_irqrestore(&pfp->slock, flags);
+        raw_readyq_unlock_irqrestore(&pfp->slock, flags);
 }
 
 /* ******************** SRP support ************************ */
@@ -1127,7 +1127,7 @@ static void pcp_priority_inheritance(void)
         blocker = ceiling ?  ceiling->owner : NULL;
         blocked = __get_cpu_var(pcp_state).hp_waiter;
 
-        raw_spin_lock_irqsave(&pfp->slock, flags);
+        raw_readyq_lock_irqsave(&pfp->slock, flags);
 
         /* Current is no longer inheriting anything by default.  This should be
          * the currently scheduled job, and hence not currently queued. */
@@ -1153,7 +1153,7 @@ static void pcp_priority_inheritance(void)
             fp_higher_prio(fp_prio_peek(&pfp->ready_queue), pfp->scheduled))
                 preempt(pfp);
 
-        raw_spin_unlock_irqrestore(&pfp->slock, flags);
+        raw_readyq_unlock_irqrestore(&pfp->slock, flags);
 }
 
 /* called with preemptions off */
@@ -1457,12 +1457,12 @@ static void pfp_migrate_to(int target_cpu)
         /* lock both pfp domains in order of address */
         from = task_pfp(t);
 
-        raw_spin_lock(&from->slock);
+        raw_readyq_lock(&from->slock);
 
         /* switch partitions */
         tsk_rt(t)->task_params.cpu = target_cpu;
 
-        raw_spin_unlock(&from->slock);
+        raw_readyq_unlock(&from->slock);
 
         /* Don't trace scheduler costs as part of
          * locking overhead. Scheduling costs are accounted for
diff --git a/litmus/sched_psn_edf.c b/litmus/sched_psn_edf.c
index 720a733aff9e..dffaeb425abf 100644
--- a/litmus/sched_psn_edf.c
+++ b/litmus/sched_psn_edf.c
@@ -81,7 +81,7 @@ static void boost_priority(struct task_struct* t)
         psnedf_domain_t*        pedf = task_pedf(t);
         lt_t                    now;
 
-        raw_spin_lock_irqsave(&pedf->slock, flags);
+        raw_readyq_lock_irqsave(&pedf->slock, flags);
         now = litmus_clock();
 
         TRACE_TASK(t, "priority boosted at %llu\n", now);
@@ -101,7 +101,7 @@ static void boost_priority(struct task_struct* t)
                 raw_spin_unlock(&pedf->domain.release_lock);
         } /* else: nothing to do since the job is not queued while scheduled */
 
-        raw_spin_unlock_irqrestore(&pedf->slock, flags);
+        raw_readyq_unlock_irqrestore(&pedf->slock, flags);
 }
 
 static void unboost_priority(struct task_struct* t)
@@ -110,7 +110,7 @@ static void unboost_priority(struct task_struct* t)
         psnedf_domain_t*        pedf = task_pedf(t);
         lt_t                    now;
 
-        raw_spin_lock_irqsave(&pedf->slock, flags);
+        raw_readyq_lock_irqsave(&pedf->slock, flags);
         now = litmus_clock();
 
         /* assumption: this only happens when the job is scheduled */
@@ -128,7 +128,7 @@ static void unboost_priority(struct task_struct* t)
         if (edf_preemption_needed(&pedf->domain, pedf->scheduled))
                 preempt(pedf);
 
-        raw_spin_unlock_irqrestore(&pedf->slock, flags);
+        raw_readyq_unlock_irqrestore(&pedf->slock, flags);
 }
 
 #endif
@@ -219,7 +219,7 @@ static struct task_struct* psnedf_schedule(struct task_struct * prev)
 
         int out_of_time, sleep, preempt, np, exists, blocks, resched;
 
-        raw_spin_lock(&pedf->slock);
+        raw_readyq_lock(&pedf->slock);
 
         /* sanity checking
          * differently from gedf, when a task exits (dead)
@@ -304,7 +304,7 @@ static struct task_struct* psnedf_schedule(struct task_struct * prev)
 
         pedf->scheduled = next;
         sched_state_task_picked();
-        raw_spin_unlock(&pedf->slock);
+        raw_readyq_unlock(&pedf->slock);
 
         return next;
 }
@@ -327,7 +327,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.
          */
-        raw_spin_lock_irqsave(&pedf->slock, flags);
+        raw_readyq_lock_irqsave(&pedf->slock, flags);
         if (running) {
                 /* there shouldn't be anything else running at the time */
                 BUG_ON(pedf->scheduled);
@@ -337,7 +337,7 @@ static void psnedf_task_new(struct task_struct * t, int on_rq, int running)
                 /* maybe we have to reschedule */
                 psnedf_preempt_check(pedf);
         }
-        raw_spin_unlock_irqrestore(&pedf->slock, flags);
+        raw_readyq_unlock_irqrestore(&pedf->slock, flags);
 }
 
 static void psnedf_task_wake_up(struct task_struct *task)
@@ -348,7 +348,7 @@ static void psnedf_task_wake_up(struct task_struct *task)
         lt_t                    now;
 
         TRACE_TASK(task, "wake_up at %llu\n", litmus_clock());
-        raw_spin_lock_irqsave(&pedf->slock, flags);
+        raw_readyq_lock_irqsave(&pedf->slock, flags);
         BUG_ON(is_queued(task));
         now = litmus_clock();
         if (is_sporadic(task) && is_tardy(task, now)
@@ -376,7 +376,7 @@ static void psnedf_task_wake_up(struct task_struct *task)
                 psnedf_preempt_check(pedf);
         }
 
-        raw_spin_unlock_irqrestore(&pedf->slock, flags);
+        raw_readyq_unlock_irqrestore(&pedf->slock, flags);
         TRACE_TASK(task, "wake up done\n");
 }
 
@@ -395,7 +395,7 @@ static void psnedf_task_exit(struct task_struct * t)
         psnedf_domain_t*        pedf = task_pedf(t);
         rt_domain_t*            edf;
 
-        raw_spin_lock_irqsave(&pedf->slock, flags);
+        raw_readyq_lock_irqsave(&pedf->slock, flags);
 
         /* disable budget enforcement */
         if (tsk_rt(t)->budget.ops)
@@ -412,7 +412,7 @@ static void psnedf_task_exit(struct task_struct * t)
         TRACE_TASK(t, "RIP, now reschedule\n");
 
         preempt(pedf);
-        raw_spin_unlock_irqrestore(&pedf->slock, flags);
+        raw_readyq_unlock_irqrestore(&pedf->slock, flags);
 }
 
 #ifdef CONFIG_LITMUS_LOCKING