Merge remote branch 'origin/wip-fmlp-dequeue' into wip-k-fmlp

Conflicts:
	include/litmus/litmus.h

4 files changed, 28 insertions, 60 deletions

diff --git a/include/litmus/litmus.h b/include/litmus/litmus.h
index befdf6381693..3df242bf272f 100644
--- a/include/litmus/litmus.h
+++ b/include/litmus/litmus.h
@@ -26,8 +26,8 @@ static inline int in_list(struct list_head* list)
                 );
 }
 
-struct task_struct* waitqueue_first(wait_queue_head_t *wq);
-struct task_struct* waitqueue_first_and_remove(wait_queue_head_t *wq);
+
+struct task_struct* __waitqueue_remove_first(wait_queue_head_t *wq);
 
 #define NO_CPU                  0xffffffff
 
diff --git a/litmus/locking.c b/litmus/locking.c
index e9e682adc2c9..cfce98e7480d 100644
--- a/litmus/locking.c
+++ b/litmus/locking.c
@@ -107,27 +107,14 @@ asmlinkage long sys_litmus_unlock(int lock_od)
         return err;
 }
 
-struct task_struct* waitqueue_first(wait_queue_head_t *wq)
+struct task_struct* __waitqueue_remove_first(wait_queue_head_t *wq)
 {
-        wait_queue_t *q;
+        wait_queue_t* q;
+        struct task_struct* t = NULL;
 
         if (waitqueue_active(wq)) {
                 q = list_entry(wq->task_list.next,
                                wait_queue_t, task_list);
-                return (struct task_struct*) q->private;
-        } else
-                return NULL;
-}
-
-struct task_struct* waitqueue_first_and_remove(wait_queue_head_t *wq)
-{
-        wait_queue_t *q;
-        struct task_struct* t = NULL;
-
-        if(waitqueue_active(wq))
-        {
-                q = list_entry(wq->task_list.next,
-                                                wait_queue_t, task_list);
                 t = (struct task_struct*) q->private;
                 __remove_wait_queue(wq, q);
         }
diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index ec641a094a08..bf8d989f1c4a 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -797,8 +797,6 @@ int gsnedf_fmlp_lock(struct litmus_lock* l)
                  * ->owner. We can thus check it without acquiring the spin
                  * lock. */
                 BUG_ON(sem->owner != t);
-
-                remove_wait_queue(&sem->wait, &wait);
         } else {
                 /* it's ours now */
                 sem->owner = t;
@@ -824,7 +822,7 @@ int gsnedf_fmlp_unlock(struct litmus_lock* l)
         }
 
         /* check if there are jobs waiting for this resource */
-        next = waitqueue_first(&sem->wait);
+        next = __waitqueue_remove_first(&sem->wait);
         if (next) {
                 /* next becomes the resouce holder */
                 sem->owner = next;
@@ -1040,6 +1038,7 @@ struct task_struct* kfmlp_remove_hp_waiter(struct kfmlp_semaphore* sem)
                 
                 my_queue->hp_waiter = kfmlp_find_hp_waiter(my_queue, max_hp);
                 
+                /*
                 if(my_queue->hp_waiter)
                         TRACE_CUR("queue %d: new hp_waiter is %s/%d\n",
                                           kfmlp_get_idx(sem, my_queue),
@@ -1048,9 +1047,11 @@ struct task_struct* kfmlp_remove_hp_waiter(struct kfmlp_semaphore* sem)
                 else
                         TRACE_CUR("queue %d: new hp_waiter is %p\n",
                                           kfmlp_get_idx(sem, my_queue), NULL);
+                 */
                 
                 raw_spin_lock(&gsnedf_lock);
                 
+                /*
                 if(my_queue->owner)
                         TRACE_CUR("queue %d: owner is %s/%d\n",
                                           kfmlp_get_idx(sem, my_queue),
@@ -1060,19 +1061,13 @@ struct task_struct* kfmlp_remove_hp_waiter(struct kfmlp_semaphore* sem)
                         TRACE_CUR("queue %d: owner is %p\n",
                                           kfmlp_get_idx(sem, my_queue),
                                           NULL);
+                 */
                 
                 if(tsk_rt(my_queue->owner)->inh_task == max_hp)
                 {
-                        TRACE_CUR("queue %d: CRAZY: clearing the inheritance of %s/%d\n",
-                                          kfmlp_get_idx(sem, my_queue), my_queue->owner->comm, my_queue->owner->pid);
-                        
                         __clear_priority_inheritance(my_queue->owner);
                         if(my_queue->hp_waiter != NULL)
                         {
-                                TRACE_CUR("queue %d: CRAZY: setting the inheritance of %s/%d to %s/%d\n",
-                                                  kfmlp_get_idx(sem, my_queue),
-                                                  my_queue->owner->comm, my_queue->owner->pid,
-                                                  my_queue->hp_waiter->comm, my_queue->hp_waiter->pid);
                                 __set_priority_inheritance(my_queue->owner, my_queue->hp_waiter);
                         }
                 }
@@ -1085,9 +1080,10 @@ struct task_struct* kfmlp_remove_hp_waiter(struct kfmlp_semaphore* sem)
                         /* Compare task prios, find high prio task. */
                         if (queued == max_hp)
                         {
+                                /*
                                 TRACE_CUR("queue %d: found entry in wait queue.  REMOVING!\n",
                                                   kfmlp_get_idx(sem, my_queue));
-                                
+                                */
                                 __remove_wait_queue(&my_queue->wait,
                                                                         list_entry(pos, wait_queue_t, task_list));
                                 break;
@@ -1144,42 +1140,30 @@ int gsnedf_kfmlp_lock(struct litmus_lock* l)
                 
                 /* We depend on the FIFO order.  Thus, we don't need to recheck
                  * when we wake up; we are guaranteed to have the lock since
-                 * there is only one wake up per release.
+                 * there is only one wake up per release (or steal).
                  */
-                
                 schedule();
 
-                spin_lock_irqsave(&sem->lock, flags);
+
                 if(my_queue->owner == t)
                 {
                         TRACE_CUR("queue %d: acquired through waiting\n",
-                                          kfmlp_get_idx(sem, my_queue));                        
-                        //__remove_wait_queue(&my_queue->wait, &wait);
+                                          kfmlp_get_idx(sem, my_queue));
                 }
                 else
                 {
                         /* this case may happen if our wait entry was stolen
-                         between queues. */
-                        
-                        struct kfmlp_queue* my_new_queue;
-                        
-                        my_new_queue = kfmlp_get_queue(sem, t);
-                        BUG_ON(!my_new_queue);
+                           between queues. */
+                        BUG_ON(!kfmlp_get_queue(sem, t));
                         TRACE_CUR("queue %d: acquired through stealing\n",
-                                          kfmlp_get_idx(sem, my_new_queue));
+                                          kfmlp_get_idx(sem, kfmlp_get_queue(sem, t)));
                 }
-                spin_unlock_irqrestore(&sem->lock, flags);
         }
         else
         {
-                TRACE_CUR("queue %d: acquired immediatly\n",
+                TRACE_CUR("queue %d: acquired immediately\n",
                                   kfmlp_get_idx(sem, my_queue));
-                
-                /* it's ours now */
-                TRACE_CUR("queue %d: ASSIGNING %s/%d as owner - immediate\n",
-                                        kfmlp_get_idx(sem, my_queue),
-                                        t->comm, t->pid);
-                
+
                 my_queue->owner = t;
                 
                 ++(my_queue->count);
@@ -1209,14 +1193,13 @@ int gsnedf_kfmlp_unlock(struct litmus_lock* l)
         }
         
         /* check if there are jobs waiting for this resource */
-        //next = waitqueue_first(&my_queue->wait);
-        next = waitqueue_first_and_remove(&my_queue->wait);
+        next = __waitqueue_remove_first(&my_queue->wait);
         if (next) {
-                
+                /*
                 TRACE_CUR("queue %d: ASSIGNING %s/%d as owner - next\n",
                                   kfmlp_get_idx(sem, my_queue),
                                   next->comm, next->pid);
-                
+                */
                 /* next becomes the resouce holder */
                 my_queue->owner = next;
                 
@@ -1257,16 +1240,18 @@ int gsnedf_kfmlp_unlock(struct litmus_lock* l)
                 
                 next = kfmlp_remove_hp_waiter(sem); /* returns NULL if nothing to steal */
 
+                /*
                 if(next)
                         TRACE_CUR("queue %d: ASSIGNING %s/%d as owner - steal\n",
                                           kfmlp_get_idx(sem, my_queue),
                                           next->comm, next->pid);
+                */
                 
                 my_queue->owner = next;
                 
                 if(next)
                 {
-                        TRACE_CUR("queue %d: lock ownership passed to %s/%d\n",
+                        TRACE_CUR("queue %d: lock ownership passed to %s/%d (which was stolen)\n",
                                           kfmlp_get_idx(sem, my_queue),
                                           next->comm, next->pid);
                         
@@ -1275,7 +1260,7 @@ int gsnedf_kfmlp_unlock(struct litmus_lock* l)
                 }
                 else
                 {
-                        TRACE_CUR("queue %d: lock ownership passed to %p\n", kfmlp_get_idx(sem, my_queue), NULL);
+                        TRACE_CUR("queue %d: no one to steal.\n", kfmlp_get_idx(sem, my_queue));
                         
                         --(my_queue->count);
                         if(my_queue->count < sem->shortest_queue->count)
diff --git a/litmus/sched_psn_edf.c b/litmus/sched_psn_edf.c
index abb06fa53e3a..71c02409efa2 100644
--- a/litmus/sched_psn_edf.c
+++ b/litmus/sched_psn_edf.c
@@ -442,10 +442,6 @@ int psnedf_fmlp_lock(struct litmus_lock* l)
                  * ->owner. We can thus check it without acquiring the spin
                  * lock. */
                 BUG_ON(sem->owner != t);
-
-                /* FIXME: could we punt the dequeuing to the previous job,
-                 * which is holding the spinlock anyway? */
-                remove_wait_queue(&sem->wait, &wait);
         } else {
                 /* it's ours now */
                 sem->owner = t;
@@ -478,7 +474,7 @@ int psnedf_fmlp_unlock(struct litmus_lock* l)
         unboost_priority(t);
 
         /* check if there are jobs waiting for this resource */
-        next = waitqueue_first(&sem->wait);
+        next = __waitqueue_remove_first(&sem->wait);
         if (next) {
                 /* boost next job */
                 boost_priority(next);