DGLock and DGUnlock implementation.

These methods haven't been fully tested, but they compile and pass a few
simple tests.

6 files changed, 126 insertions, 27 deletions

diff --git a/include/linux/sched.h b/include/linux/sched.h
index 9c990d13ae35..2b094bdaafa3 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -96,6 +96,7 @@ struct sched_param {
 
 #include <litmus/rt_param.h>
 #include <litmus/preempt.h>
+#include <litmus/fdso.h>
 
 struct exec_domain;
 struct futex_pi_state;
@@ -1538,6 +1539,8 @@ struct task_struct {
         /* references to PI semaphores, etc. */
         struct od_table_entry *od_table;
 
+    resource_mask_t resources;
+
 #ifdef CONFIG_LATENCYTOP
         int latency_record_count;
         struct latency_record latency_record[LT_SAVECOUNT];
diff --git a/include/litmus/litmus.h b/include/litmus/litmus.h
index c9206adb3493..9282f3a8f28f 100644
--- a/include/litmus/litmus.h
+++ b/include/litmus/litmus.h
@@ -27,6 +27,7 @@ static inline int in_list(struct list_head* list)
 }
 
 struct task_struct* __waitqueue_remove_first(wait_queue_head_t *wq);
+struct task_struct* __waitqueue_peek_first(wait_queue_head_t *wq);
 
 #define NO_CPU                  0xffffffff
 
diff --git a/include/litmus/locking.h b/include/litmus/locking.h
index 8e501c326b8b..968ba6fa828c 100644
--- a/include/litmus/locking.h
+++ b/include/litmus/locking.h
@@ -21,10 +21,6 @@ struct litmus_lock_ops {
         int (*open)(struct litmus_lock*, void* __user);
         int (*close)(struct litmus_lock*);
     
-    /* add or remove a resource from control by the dynamic group lock */
-    int (*add)(struct litmus_lock*, int);
-    int (*remove)(struct litmus_lock*, int);
-
         /* Current tries to lock/unlock this lock (mandatory methods). */
         int (*lock)(struct litmus_lock*);
         int (*unlock)(struct litmus_lock*);
diff --git a/include/litmus/wait.h b/include/litmus/wait.h
index ce1347c355f8..7e20c0a4a1f4 100644
--- a/include/litmus/wait.h
+++ b/include/litmus/wait.h
@@ -2,6 +2,7 @@
 #define _LITMUS_WAIT_H_
 
 struct task_struct* __waitqueue_remove_first(wait_queue_head_t *wq);
+struct task_struct* __waitqueue_peek_first(wait_queue_head_t *wq);
 
 /* wrap regular wait_queue_t head */
 struct __prio_wait_queue {
diff --git a/litmus/locking.c b/litmus/locking.c
index 55529064f7ca..65fd51f2c80a 100644
--- a/litmus/locking.c
+++ b/litmus/locking.c
@@ -169,6 +169,19 @@ struct task_struct* __waitqueue_remove_first(wait_queue_head_t *wq)
         return(t);
 }
 
+struct task_struct* __waitqueue_peek_first(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;
+        }
+        return(t);
+}
+
 unsigned int __add_wait_queue_prio_exclusive(
         wait_queue_head_t* head,
         prio_wait_queue_t *new)
diff --git a/litmus/sched_psn_edf.c b/litmus/sched_psn_edf.c
index 8745682b409f..c76c0412f809 100644
--- a/litmus/sched_psn_edf.c
+++ b/litmus/sched_psn_edf.c
@@ -421,7 +421,7 @@ struct dgl_semaphore {
      * partitioned scheduling, the resource holders are priority boosted, and
      * it is impossible to have $>m$ boosted jobs.
      */
-    unsigned int resource_holders;
+    bool boosted[NR_CPUS];
     
     /* FIFO queue of waiting tasks */
     wait_queue_head_t wait;
@@ -574,24 +574,16 @@ int psnedf_dgl_close(struct litmus_lock* l)
     return 0;
 }
 
-int psnedf_dgl_add(struct litmus_lock* l, int od)
-{
-    return 0;
-}
-
-int psnedf_dgl_remove(struct litmus_lock* l, int od)
-{
-    return 0;
-}
-
+/* for compatibility, assume lock requests the whole group. */
 int psnedf_dgl_lock(struct litmus_lock* l)
 {
-    return 0;
+    return l->ops->dynamic_group_lock(l, dgl_from_lock(l)->dgl_resources);
 }
 
+/* for compatibility, assume unlock releasess the whole group. */
 int psnedf_dgl_unlock(struct litmus_lock* l)
 {
-    return 0;
+    return l->ops->dynamic_group_unlock(l, dgl_from_lock(l)->dgl_resources);
 }
 
 /**
@@ -606,7 +598,7 @@ int psnedf_dgl_unlock(struct litmus_lock* l)
  * is requested, the cache is updated (in the while loop). This is done by
  * checking that two fdso point to the same lock object.
  */
-bool check_mask_valid(struct litmus_lock* l, resource_mask_t mask)
+bool is_mask_valid(struct litmus_lock* l, resource_mask_t mask)
 {
     struct dgl_semaphore* d;
     struct od_table_entry* entry;
@@ -642,20 +634,109 @@ bool check_mask_valid(struct litmus_lock* l, resource_mask_t mask)
 
 }
 
-int psnedf_dgl_dynamic_group_lock(struct litmus_lock* l, resource_mask_t lock_ods)
+int psnedf_dgl_dynamic_group_lock(struct litmus_lock* l, resource_mask_t resources)
 {
-    //struct task_struct* t = current;
-    //struct dgl_semaphore *sem = dgl_from_lock(l);
+    struct task_struct* t = current;
+    struct dgl_semaphore *sem = dgl_from_lock(l);
+    wait_queue_t wait;
+    unsigned long flags;
+    
     TRACE("Trying to lock a DGL\n");
 
-    check_mask_valid(l, lock_ods);
+    if (!is_realtime(t))
+        return -EPERM;
+
+    if ( !is_mask_valid(l, resources) )
+        return -EINVAL;
+
+    t->resources = resources;
+
+    spin_lock_irqsave(&sem->wait.lock, flags);
+
+    // if sem->locked & resources == 0, then all resources are available,
+    // otherwise we must suspend.
+    if (sem->locked & resources){
+        init_waitqueue_entry(&wait, t);
+
+        set_task_state(t, TASK_UNINTERRUPTIBLE);
+
+        __add_wait_queue_tail_exclusive(&sem->wait, &wait);
+
+        TS_LOCK_SUSPEND;
+
+        spin_unlock_irqrestore(&sem->wait.lock, flags);
+
+        schedule();
+
+        TS_LOCK_RESUME;
+    } else {
+        sem->locked = sem->locked | resources;
+
+        // if a job requests a resource, then it was scheduled, and therefore
+        // there was not another boosted job, so this is safe.
+        BUG_ON(sem->boosted[task_cpu(t)]);
+
+        boost_priority(t);
+
+        sem->boosted[task_cpu(t)] = true;
+
+        spin_unlock_irqrestore(&sem->wait.lock, flags);
+    }
+
     return 0;
 }
 
-int psnedf_dgl_dynamic_group_unlock(struct litmus_lock* l, resource_mask_t lock_ods)
+int psnedf_dgl_dynamic_group_unlock(struct litmus_lock* l, resource_mask_t resources)
 {
+    struct task_struct *t = current, *next;
+    struct dgl_semaphore *sem = dgl_from_lock(l);
+    unsigned long flags;
+    int err = 0;
+
     TRACE("Trying to unlock a DGL\n");
-    return 0;
+
+    spin_lock_irqsave(&sem->wait.lock, flags);
+
+    // ~resources | t->resources checks that t owns the resources being released
+    // note that a job can release a subset of the resources it has acquired.
+    if ( !is_mask_valid(l, resources)){
+        TRACE("Invalid mask %d\n", resources);
+        err = -EINVAL;
+        goto out;
+    } else if ( (~resources | t->resources) != -1){
+        TRACE("Trying to lock unowned resources: %d\t%d\n", resources, t->resources);
+        err = -EINVAL;
+        goto out;
+    }
+
+    // if the job released all of the resources it owned, then unboost.
+    if (resources == t->resources){
+        unboost_priority(t);
+    } else {
+        // update t->resources to reflect the resources currently owned.
+        t->resources = t->resources & ~resources;
+    }
+
+    next = __waitqueue_peek_first(&sem->wait);
+    while( next && ~(next->resources & sem->locked) == -1 &&
+           !sem->boosted[task_cpu(next)] ){
+
+        //next should not change, it should just be removed
+        //from the head of the queue.
+        next = __waitqueue_remove_first(&sem->wait);
+
+        boost_priority(next);
+
+        sem->locked = sem->locked | next->resources;
+
+        wake_up_process(next);
+
+        next = __waitqueue_peek_first(&sem->wait);
+    }
+
+out:
+    spin_unlock_irqrestore(&sem->wait.lock, flags);
+    return err;
 }
 
 void psnedf_dgl_free(struct litmus_lock* l)
@@ -667,8 +748,6 @@ void psnedf_dgl_free(struct litmus_lock* l)
 
 static struct litmus_lock_ops psnedf_dgl_lock_ops = {
     .close      = psnedf_dgl_close,
-    .add        = psnedf_dgl_add,
-    .remove     = psnedf_dgl_remove,
     .lock       = psnedf_dgl_lock,
     .unlock     = psnedf_dgl_unlock,
     .dynamic_group_lock = psnedf_dgl_dynamic_group_lock,
@@ -694,6 +773,7 @@ static struct litmus_lock* psnedf_new_fmlp(void)
 static struct litmus_lock* psnedf_new_dgl(void)
 {
     struct dgl_semaphore* sem;
+    int i;
 
     TRACE("Creating another DGL\n");
 
@@ -701,8 +781,13 @@ static struct litmus_lock* psnedf_new_dgl(void)
     if (!sem)
         return NULL;
 
-    sem->resource_holders = 0;
+    sem->locked = 0;
     sem->dgl_resources = 0;
+
+    // This doesn't feel like the preferred way to do it, but it should work.
+    for(i = 0; i < NR_CPUS; i++)
+        sem->boosted[i] = false;
+
     init_waitqueue_head(&sem->wait);
     sem->litmus_lock.ops = &psnedf_dgl_lock_ops;
     sem->litmus_lock.type = DGL_SEM;