Update FMLP to use revised fmlp_semaphore.

7ef1e106db5a061682028fdc4d8ffd131729868a refactored pi_semaphore into two
structs: pi_semaphore and fmlp_semaphore.  fmlp_semaphore encapsulates
pi_semaphore as its first field, pi.  This patch updates the FMLP-Long
implementation to use the refactored structs.

1 files changed, 42 insertions, 38 deletions

diff --git a/litmus/fmlp.c b/litmus/fmlp.c
index 03fa7358d5eb..de46e626f43f 100644
--- a/litmus/fmlp.c
+++ b/litmus/fmlp.c
@@ -22,19 +22,23 @@
 
 static  void* create_fmlp_semaphore(void)
 {
-        struct pi_semaphore* sem;
+        struct fmlp_semaphore* sem;
         int i;
 
         sem = kmalloc(sizeof(*sem), GFP_KERNEL);
         if (!sem)
                 return NULL;
-        atomic_set(&sem->count, 1);
-        sem->sleepers = 0;
-        init_waitqueue_head(&sem->wait);
-        sem->hp.task = NULL;
+        atomic_set(&sem->pi.count, 1);
+        sem->pi.sleepers = 0;
+        init_waitqueue_head(&sem->pi.wait);
+        sem->pi.hp.task = NULL;
         sem->holder = NULL;
         for (i = 0; i < NR_CPUS; i++)
-                sem->hp.cpu_task[i] = NULL;
+                sem->pi.hp.cpu_task[i] = NULL;
+
+        sem->pi.stack_node.inh_task = NULL;
+        INIT_LIST_HEAD(&sem->pi.stack_node.list);
+
         return sem;
 }
 
@@ -59,7 +63,7 @@ struct fdso_ops fmlp_sem_ops = {
 
 struct wq_pair {
         struct task_struct*  tsk;
-        struct pi_semaphore* sem;
+        struct fmlp_semaphore* sem;
 };
 
 static int rt_pi_wake_up(wait_queue_t *wait, unsigned mode, int sync,
@@ -67,7 +71,7 @@ static int rt_pi_wake_up(wait_queue_t *wait, unsigned mode, int sync,
 {
         struct wq_pair* wqp   = (struct wq_pair*) wait->private;
         set_rt_flags(wqp->tsk, RT_F_EXIT_SEM);
-        litmus->inherit_priority(wqp->sem, wqp->tsk);
+        litmus->fmlp_inherit_priority(to_pi(wqp->sem), wqp->tsk);
         TRACE_TASK(wqp->tsk,
                    "woken up by rt_pi_wake_up() (RT_F_SEM_EXIT, PI)\n");
         /* point to task for default_wake_function() */
@@ -84,21 +88,21 @@ static int rt_pi_wake_up(wait_queue_t *wait, unsigned mode, int sync,
 }
 
 /* caller is responsible for locking */
-int edf_set_hp_task(struct pi_semaphore *sem)
+int edf_set_hp_task(struct fmlp_semaphore *sem)
 {
         struct list_head        *tmp, *next;
         struct task_struct      *queued;
         int ret = 0;
 
-        sem->hp.task = NULL;
-        list_for_each_safe(tmp, next, &sem->wait.task_list) {
+        sem->pi.hp.task = NULL;
+        list_for_each_safe(tmp, next, &sem->pi.wait.task_list) {
                 queued  = ((struct wq_pair*)
                         list_entry(tmp, wait_queue_t,
                                    task_list)->private)->tsk;
 
                 /* Compare task prios, find high prio task. */
-                if (edf_higher_prio(queued, sem->hp.task)) {
-                        sem->hp.task = queued;
+                if (edf_higher_prio(queued, sem->pi.hp.task)) {
+                        sem->pi.hp.task = queued;
                         ret = 1;
                 }
         }
@@ -106,29 +110,29 @@ int edf_set_hp_task(struct pi_semaphore *sem)
 }
 
 /* caller is responsible for locking */
-int edf_set_hp_cpu_task(struct pi_semaphore *sem, int cpu)
+int edf_set_hp_cpu_task(struct fmlp_semaphore *sem, int cpu)
 {
         struct list_head        *tmp, *next;
         struct task_struct      *queued;
         int ret = 0;
 
-        sem->hp.cpu_task[cpu] = NULL;
-        list_for_each_safe(tmp, next, &sem->wait.task_list) {
+        sem->pi.hp.cpu_task[cpu] = NULL;
+        list_for_each_safe(tmp, next, &sem->pi.wait.task_list) {
                 queued  = ((struct wq_pair*)
                         list_entry(tmp, wait_queue_t,
                                    task_list)->private)->tsk;
 
                 /* Compare task prios, find high prio task. */
                 if (get_partition(queued) == cpu &&
-                    edf_higher_prio(queued, sem->hp.cpu_task[cpu])) {
-                        sem->hp.cpu_task[cpu] = queued;
+                    edf_higher_prio(queued, sem->pi.hp.cpu_task[cpu])) {
+                        sem->pi.hp.cpu_task[cpu] = queued;
                         ret = 1;
                 }
         }
         return ret;
 }
 
-static int do_fmlp_down(struct pi_semaphore* sem)
+static int do_fmlp_down(struct fmlp_semaphore* sem)
 {
         unsigned long flags;
         struct task_struct *tsk = current;
@@ -142,19 +146,19 @@ static int do_fmlp_down(struct pi_semaphore* sem)
 
         pair.tsk = tsk;
         pair.sem = sem;
-        spin_lock_irqsave(&sem->wait.lock, flags);
+        spin_lock_irqsave(&sem->pi.wait.lock, flags);
 
-        if (atomic_dec_return(&sem->count) < 0 ||
-            waitqueue_active(&sem->wait)) {
+        if (atomic_dec_return(&sem->pi.count) < 0 ||
+            waitqueue_active(&sem->pi.wait)) {
                 /* we need to suspend */
                 tsk->state = TASK_UNINTERRUPTIBLE;
-                add_wait_queue_exclusive_locked(&sem->wait, &wait);
+                add_wait_queue_exclusive_locked(&sem->pi.wait, &wait);
 
                 TRACE_CUR("suspends on PI lock %p\n", sem);
-                litmus->pi_block(sem, tsk);
+                litmus->fmlp_pi_block(to_pi(sem), tsk);
 
                 /* release lock before sleeping */
-                spin_unlock_irqrestore(&sem->wait.lock, flags);
+                spin_unlock_irqrestore(&sem->pi.wait.lock, flags);
 
                 TS_PI_DOWN_END;
                 preempt_enable_no_resched();
@@ -172,7 +176,7 @@ static int do_fmlp_down(struct pi_semaphore* sem)
                 /* try_to_wake_up() set our state to TASK_RUNNING,
                  * all we need to do is to remove our wait queue entry
                  */
-                remove_wait_queue(&sem->wait, &wait);
+                remove_wait_queue(&sem->pi.wait, &wait);
         } else {
                 /* no priority inheritance necessary, since there are no queued
                  * tasks.
@@ -182,35 +186,35 @@ static int do_fmlp_down(struct pi_semaphore* sem)
                 sem->holder  = tsk;
 
                 /* don't know if we're global or partitioned. */
-                sem->hp.task = tsk;
-                sem->hp.cpu_task[get_partition(tsk)] = tsk;
+                sem->pi.hp.task = tsk;
+                sem->pi.hp.cpu_task[get_partition(tsk)] = tsk;
 
-                litmus->inherit_priority(sem, tsk);
-                spin_unlock_irqrestore(&sem->wait.lock, flags);
+                litmus->fmlp_inherit_priority(to_pi(sem), tsk);
+                spin_unlock_irqrestore(&sem->pi.wait.lock, flags);
         }
         return suspended;
 }
 
-static void do_fmlp_up(struct pi_semaphore* sem)
+static void do_fmlp_up(struct fmlp_semaphore* sem)
 {
         unsigned long flags;
 
-        spin_lock_irqsave(&sem->wait.lock, flags);
+        spin_lock_irqsave(&sem->pi.wait.lock, flags);
 
         TRACE_CUR("releases PI lock %p\n", sem);
-        litmus->return_priority(sem);
+        litmus->fmlp_return_priority(to_pi(sem));
         sem->holder = NULL;
-        if (atomic_inc_return(&sem->count) < 1)
+        if (atomic_inc_return(&sem->pi.count) < 1)
                 /* there is a task queued */
-                wake_up_locked(&sem->wait);
+                wake_up_locked(&sem->pi.wait);
 
-        spin_unlock_irqrestore(&sem->wait.lock, flags);
+        spin_unlock_irqrestore(&sem->pi.wait.lock, flags);
 }
 
 asmlinkage long sys_fmlp_down(int sem_od)
 {
         long ret = 0;
-        struct pi_semaphore * sem;
+        struct fmlp_semaphore * sem;
         int suspended = 0;
 
         preempt_disable();
@@ -233,7 +237,7 @@ asmlinkage long sys_fmlp_down(int sem_od)
 asmlinkage long sys_fmlp_up(int sem_od)
 {
         long ret = 0;
-        struct pi_semaphore * sem;
+        struct fmlp_semaphore * sem;
 
         preempt_disable();
         TS_PI_UP_START;