Litmus core: replace FMLP & SRP system calls with generic syscalls

This renders the FMLP and SRP unfunctional until they are ported to
the new locking API.

5 files changed, 5 insertions, 131 deletions

diff --git a/litmus/fmlp.c b/litmus/fmlp.c
index 1e4d544a9230..6e3ddadbc429 100644
--- a/litmus/fmlp.c
+++ b/litmus/fmlp.c
@@ -207,62 +207,8 @@ static void do_fmlp_up(struct pi_semaphore* sem)
         spin_unlock_irqrestore(&sem->wait.lock, flags);
 }
 
-asmlinkage long sys_fmlp_down(int sem_od)
-{
-        long ret = 0;
-        struct pi_semaphore * sem;
-        int suspended = 0;
-
-        preempt_disable();
-        TS_PI_DOWN_START;
-
-        sem = lookup_fmlp_sem(sem_od);
-        if (sem)
-                suspended = do_fmlp_down(sem);
-        else
-                ret = -EINVAL;
-
-        if (!suspended) {
-                TS_PI_DOWN_END;
-                preempt_enable();
-        }
-
-        return ret;
-}
-
-asmlinkage long sys_fmlp_up(int sem_od)
-{
-        long ret = 0;
-        struct pi_semaphore * sem;
-
-        preempt_disable();
-        TS_PI_UP_START;
-
-        sem = lookup_fmlp_sem(sem_od);
-        if (sem)
-                do_fmlp_up(sem);
-        else
-                ret = -EINVAL;
-
-
-        TS_PI_UP_END;
-        preempt_enable();
-
-        return ret;
-}
-
 #else
 
 struct fdso_ops fmlp_sem_ops = {};
 
-asmlinkage long sys_fmlp_down(int sem_od)
-{
-        return -ENOSYS;
-}
-
-asmlinkage long sys_fmlp_up(int sem_od)
-{
-        return -ENOSYS;
-}
-
 #endif
diff --git a/litmus/locking.c b/litmus/locking.c
index 848407b79b4f..ab643475093f 100644
--- a/litmus/locking.c
+++ b/litmus/locking.c
@@ -75,6 +75,7 @@ asmlinkage long sys_litmus_lock(int lock_od)
         entry = get_entry_for_od(lock_od);
         if (entry && is_lock(entry)) {
                 l = get_lock(entry);
+                TRACE_CUR("attempts to lock 0x%p\n", l);
                 err = l->ops->lock(l);
         }
 
@@ -96,7 +97,8 @@ asmlinkage long sys_litmus_unlock(int lock_od)
         entry = get_entry_for_od(lock_od);
         if (entry && is_lock(entry)) {
                 l = get_lock(entry);
-                err = l->ops->lock(l);
+                TRACE_CUR("attempts to unlock 0x%p\n", l);
+                err = l->ops->unlock(l);
         }
 
         /* Note: task my have been preempted in between!  Take this into
diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index e9c5e531b1ae..4ad95dba4a04 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -594,7 +594,7 @@ static void gsnedf_task_exit(struct task_struct * t)
         TRACE_TASK(t, "RIP\n");
 }
 
-#ifdef CONFIG_FMLP
+#if 0
 
 /* Update the queue position of a task that got it's priority boosted via
  * priority inheritance. */
@@ -795,12 +795,6 @@ static struct sched_plugin gsn_edf_plugin __cacheline_aligned_in_smp = {
         .schedule               = gsnedf_schedule,
         .task_wake_up           = gsnedf_task_wake_up,
         .task_block             = gsnedf_task_block,
-#ifdef CONFIG_FMLP
-        .fmlp_active            = 1,
-        .pi_block               = gsnedf_pi_block,
-        .inherit_priority       = gsnedf_inherit_priority,
-        .return_priority        = gsnedf_return_priority,
-#endif
         .admit_task             = gsnedf_admit_task,
         .activate_plugin        = gsnedf_activate_plugin,
 };
diff --git a/litmus/sched_psn_edf.c b/litmus/sched_psn_edf.c
index b89823d5c026..01f31e407082 100644
--- a/litmus/sched_psn_edf.c
+++ b/litmus/sched_psn_edf.c
@@ -309,7 +309,7 @@ static void psnedf_task_exit(struct task_struct * t)
         raw_spin_unlock_irqrestore(&pedf->slock, flags);
 }
 
-#ifdef CONFIG_FMLP
+#if 0
 static long psnedf_pi_block(struct pi_semaphore *sem,
                             struct task_struct *new_waiter)
 {
@@ -443,9 +443,6 @@ static long psnedf_admit_task(struct task_struct* tsk)
 /*      Plugin object   */
 static struct sched_plugin psn_edf_plugin __cacheline_aligned_in_smp = {
         .plugin_name            = "PSN-EDF",
-#ifdef CONFIG_SRP
-        .srp_active             = 1,
-#endif
         .tick                   = psnedf_tick,
         .task_new               = psnedf_task_new,
         .complete_job           = complete_job,
@@ -453,12 +450,6 @@ static struct sched_plugin psn_edf_plugin __cacheline_aligned_in_smp = {
         .schedule               = psnedf_schedule,
         .task_wake_up           = psnedf_task_wake_up,
         .task_block             = psnedf_task_block,
-#ifdef CONFIG_FMLP
-        .fmlp_active            = 1,
-        .pi_block               = psnedf_pi_block,
-        .inherit_priority       = psnedf_inherit_priority,
-        .return_priority        = psnedf_return_priority,
-#endif
         .admit_task             = psnedf_admit_task
 };
 
diff --git a/litmus/srp.c b/litmus/srp.c
index 4601b7dba812..b4c171e79fd4 100644
--- a/litmus/srp.c
+++ b/litmus/srp.c
@@ -189,55 +189,6 @@ static void do_srp_up(struct srp_semaphore* sem)
         wake_up_all(&__get_cpu_var(srp).ceiling_blocked);
 }
 
-/* Adjust the system-wide priority ceiling if resource is claimed. */
-asmlinkage long sys_srp_down(int sem_od)
-{
-        int cpu;
-        int ret = -EINVAL;
-        struct srp_semaphore* sem;
-
-        /* disabling preemptions is sufficient protection since
-         * SRP is strictly per CPU and we don't interfere with any
-         * interrupt handlers
-         */
-        preempt_disable();
-        TS_SRP_DOWN_START;
-
-        cpu = smp_processor_id();
-        sem = lookup_srp_sem(sem_od);
-        if (sem && sem->cpu == cpu) {
-                do_srp_down(sem);
-                ret = 0;
-        }
-
-        TS_SRP_DOWN_END;
-        preempt_enable();
-        return ret;
-}
-
-/* Adjust the system-wide priority ceiling if resource is freed. */
-asmlinkage long sys_srp_up(int sem_od)
-{
-        int cpu;
-        int ret = -EINVAL;
-        struct srp_semaphore* sem;
-
-        preempt_disable();
-        TS_SRP_UP_START;
-
-        cpu = smp_processor_id();
-        sem = lookup_srp_sem(sem_od);
-
-        if (sem && sem->cpu == cpu) {
-                do_srp_up(sem);
-                ret = 0;
-        }
-
-        TS_SRP_UP_END;
-        preempt_enable();
-        return ret;
-}
-
 static int srp_wake_up(wait_queue_t *wait, unsigned mode, int sync,
                        void *key)
 {
@@ -303,16 +254,6 @@ void srp_ceiling_block(void)
 
 #else
 
-asmlinkage long sys_srp_down(int sem_od)
-{
-        return -ENOSYS;
-}
-
-asmlinkage long sys_srp_up(int sem_od)
-{
-        return -ENOSYS;
-}
-
 struct fdso_ops srp_sem_ops = {};
 
 #endif