Bug fixes.

1 files changed, 55 insertions, 32 deletions

diff --git a/litmus/sched_psn_edf.c b/litmus/sched_psn_edf.c
index c76c0412f80..9da32a773db 100644
--- a/litmus/sched_psn_edf.c
+++ b/litmus/sched_psn_edf.c
@@ -78,31 +78,31 @@ static void preempt(psnedf_domain_t *pedf)
 
 static void boost_priority(struct task_struct* t)
 {
-        unsigned long           flags;
-        psnedf_domain_t*        pedf = task_pedf(t);
-        lt_t                    now;
+    unsigned long               flags;
+    psnedf_domain_t*    pedf = task_pedf(t);
+    lt_t                        now;
 
-        raw_spin_lock_irqsave(&pedf->slock, flags);
-        now = litmus_clock();
+    raw_spin_lock_irqsave(&pedf->slock, flags);
+    now = litmus_clock();
 
-        TRACE_TASK(t, "priority boosted at %llu\n", now);
+    TRACE_TASK(t, "priority boosted at %llu\n", now);
 
-        tsk_rt(t)->priority_boosted = 1;
-        tsk_rt(t)->boost_start_time = now;
+    tsk_rt(t)->priority_boosted = 1;
+    tsk_rt(t)->boost_start_time = now;
 
-        if (pedf->scheduled != t) {
-                /* holder may be queued: first stop queue changes */
-                raw_spin_lock(&pedf->domain.release_lock);
-                if (is_queued(t) &&
-                    /* If it is queued, then we need to re-order. */
-                    bheap_decrease(edf_ready_order, tsk_rt(t)->heap_node) &&
-                    /* If we bubbled to the top, then we need to check for preemptions. */
-                    edf_preemption_needed(&pedf->domain, pedf->scheduled))
-                                preempt(pedf);
-                raw_spin_unlock(&pedf->domain.release_lock);
-        } /* else: nothing to do since the job is not queued while scheduled */
+    if (pedf->scheduled != t) {
+        /* holder may be queued: first stop queue changes */
+        raw_spin_lock(&pedf->domain.release_lock);
+        if (is_queued(t) &&
+                /* If it is queued, then we need to re-order. */
+                bheap_decrease(edf_ready_order, tsk_rt(t)->heap_node) &&
+                /* If we bubbled to the top, then we need to check for preemptions. */
+                edf_preemption_needed(&pedf->domain, pedf->scheduled))
+            preempt(pedf);
+        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_spin_unlock_irqrestore(&pedf->slock, flags);
 }
 
 static void unboost_priority(struct task_struct* t)
@@ -580,7 +580,7 @@ int psnedf_dgl_lock(struct litmus_lock* l)
     return l->ops->dynamic_group_lock(l, dgl_from_lock(l)->dgl_resources);
 }
 
-/* for compatibility, assume unlock releasess the whole group. */
+/* for compatibility, assume unlock releases the whole group. */
 int psnedf_dgl_unlock(struct litmus_lock* l)
 {
     return l->ops->dynamic_group_unlock(l, dgl_from_lock(l)->dgl_resources);
@@ -686,12 +686,24 @@ int psnedf_dgl_dynamic_group_lock(struct litmus_lock* l, resource_mask_t resourc
     return 0;
 }
 
+inline int num_boosted(struct dgl_semaphore *sem)
+{
+    int ret = 0;
+    int i;
+    for(i = 0; i < NR_CPUS; i++){
+        ret += sem->boosted[i];
+    }
+    return ret;
+}
+
 int psnedf_dgl_dynamic_group_unlock(struct litmus_lock* l, resource_mask_t resources)
 {
-    struct task_struct *t = current, *next;
+    struct task_struct *t = current, *tsk;
     struct dgl_semaphore *sem = dgl_from_lock(l);
     unsigned long flags;
     int err = 0;
+    resource_mask_t logically_locked;
+    struct list_head *pos, *tmp;
 
     TRACE("Trying to unlock a DGL\n");
 
@@ -707,6 +719,8 @@ int psnedf_dgl_dynamic_group_unlock(struct litmus_lock* l, resource_mask_t resou
         TRACE("Trying to lock unowned resources: %d\t%d\n", resources, t->resources);
         err = -EINVAL;
         goto out;
+    } else {
+        sem->locked -= resources;
     }
 
     // if the job released all of the resources it owned, then unboost.
@@ -717,21 +731,30 @@ int psnedf_dgl_dynamic_group_unlock(struct litmus_lock* l, resource_mask_t resou
         t->resources = t->resources & ~resources;
     }
 
-    next = __waitqueue_peek_first(&sem->wait);
-    while( next && ~(next->resources & sem->locked) == -1 &&
-           !sem->boosted[task_cpu(next)] ){
+    logically_locked = sem->locked;
+
+        list_for_each_safe(pos, tmp, &sem->wait.task_list) {
+                tsk  = (struct task_struct*) list_entry(pos, wait_queue_t,
+                                                           task_list)->private;
 
-        //next should not change, it should just be removed
-        //from the head of the queue.
-        next = __waitqueue_remove_first(&sem->wait);
 
-        boost_priority(next);
+        if ( (logically_locked == -1) && (num_boosted(sem) == NR_CPUS) ){
+            break;
+        }
+
+        // the resources requested are unlocked
+        if( !(tsk->resources & logically_locked) && !sem->boosted[task_cpu(tsk)]) {
 
-        sem->locked = sem->locked | next->resources;
+            list_del_init(pos);
 
-        wake_up_process(next);
+            sem->locked = sem->locked | tsk->resources;
+            sem->boosted[task_cpu(t)] = true;
+
+            boost_priority(tsk);
+            wake_up_process(tsk);
+        }
 
-        next = __waitqueue_peek_first(&sem->wait);
+        logically_locked = logically_locked | tsk->resources;
     }
 
 out: