Check for valid fdsos in a dgl request.

Apply bitwise operations to quickly check if the set of resources
requested are contained within one group.

3 files changed, 72 insertions, 23 deletions

diff --git a/include/litmus/locking.h b/include/litmus/locking.h
index 203466933f3c..8e501c326b8b 100644
--- a/include/litmus/locking.h
+++ b/include/litmus/locking.h
@@ -5,6 +5,8 @@
 
 struct litmus_lock_ops;
 
+extern struct fdso_ops generic_lock_ops;
+
 /* Generic base struct for LITMUS^RT userspace semaphores.
  * This structure should be embedded in protocol-specific semaphores.
  */
@@ -34,4 +36,15 @@ struct litmus_lock_ops {
         void (*deallocate)(struct litmus_lock*);
 };
 
+static inline bool is_lock(struct od_table_entry* entry)
+{
+        return entry->class == &generic_lock_ops;
+}
+
+static inline struct litmus_lock* get_lock(struct od_table_entry* entry)
+{
+        BUG_ON(!is_lock(entry));
+        return (struct litmus_lock*) entry->obj->obj;
+}
+
 #endif
diff --git a/litmus/locking.c b/litmus/locking.c
index 348a4be97cf9..55529064f7ca 100644
--- a/litmus/locking.c
+++ b/litmus/locking.c
@@ -22,17 +22,6 @@ struct fdso_ops generic_lock_ops = {
         .destroy = destroy_generic_lock
 };
 
-static inline bool is_lock(struct od_table_entry* entry)
-{
-        return entry->class == &generic_lock_ops;
-}
-
-static inline struct litmus_lock* get_lock(struct od_table_entry* entry)
-{
-        BUG_ON(!is_lock(entry));
-        return (struct litmus_lock*) entry->obj->obj;
-}
-
 static  int create_generic_lock(void** obj_ref, obj_type_t type, void* __user arg)
 {
         struct litmus_lock* lock;
@@ -68,14 +57,6 @@ static void destroy_generic_lock(obj_type_t type, void* obj)
         lock->ops->deallocate(lock);
 }
 
-bool check_mask_valid(struct litmus_lock* l, resource_mask_t mask)
-{
-    // this should really check if all of the resources requested are
-    // controlled by the dynamic group lock. this can be done with bitwise
-    // magic, by observing that A->B <-> ~A|B
-    return true;
-}
-
 asmlinkage long sys_dynamic_group_lock(resource_mask_t lock_ods)
 {
     long err = -EINVAL;
@@ -87,7 +68,7 @@ asmlinkage long sys_dynamic_group_lock(resource_mask_t lock_ods)
     entry = get_entry_for_od(ffs(lock_ods)-1);
     if (entry && is_lock(entry)) {
         l = get_lock(entry);
-        if (check_mask_valid(l, mask)){
+        if (l->type == DGL_SEM){
             TRACE_CUR("attempts to lock %d\n", lock_ods);
             err = l->ops->dynamic_group_lock(l, lock_ods);
         }
@@ -109,9 +90,11 @@ asmlinkage long sys_dynamic_group_unlock(resource_mask_t lock_ods)
     entry = get_entry_for_od(ffs(lock_ods)-1);
     if (entry && is_lock(entry)) {
         l = get_lock(entry);
-        if (check_mask_valid(l, mask)){
+        if (l->type == DGL_SEM){
             TRACE_CUR("attempts to unlock all resources in 0x%p\n",l);
             err = l->ops->dynamic_group_unlock(l, lock_ods);
+        } else{
+            TRACE_CUR("Wrong Type: %d\n", l->type);
         }
     }
 
diff --git a/litmus/sched_psn_edf.c b/litmus/sched_psn_edf.c
index 7d81f8a245a1..8745682b409f 100644
--- a/litmus/sched_psn_edf.c
+++ b/litmus/sched_psn_edf.c
@@ -594,11 +594,61 @@ int psnedf_dgl_unlock(struct litmus_lock* l)
     return 0;
 }
 
+/**
+ * This function checks to ensure that all resources requested in the mask are
+ * controlled by the dgl in l. This is validated in one of two ways.
+ *
+ * The dgl struct maintains a cache of resources known to be controlled by that
+ * particular dgl. If the requested resources are in that cache, return true.
+ *
+ * Note that this cache is not immediately updated when a resource is added to
+ * a group (because I didn't see an easy way to do it). The first time a resource
+ * 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)
+{
+    struct dgl_semaphore* d;
+    struct od_table_entry* entry;
+    resource_mask_t tmp;
+    int prev = -1;
+
+    if (l->type != DGL_SEM)
+        return false;
+
+    d = dgl_from_lock(l);
+
+    // mask -> d->dgl_resources (bitwise logical implication)
+    tmp = ~mask | d->dgl_resources;
+
+    //n.b. if tmp is 0xffffffff, ffs(~tmp) - 1 = -1, and -1 >= prev always, so stop.
+    while (prev < ffs(~tmp) - 1)
+    {
+        prev = ffs(~tmp) - 1;
+        entry = get_entry_for_od( ffs(~tmp) - 1);
+        if (entry && is_lock(entry) && get_lock(entry) == l){
+            d->dgl_resources = d->dgl_resources | ( 1 << (ffs(~tmp) -1) );
+        }
+        tmp = ~mask|d->dgl_resources;
+    }
+
+    // 2's complement: -1 is 0xffffffff
+
+    if ( tmp == -1){
+        return true;
+    } else {
+        return false;
+    }
+
+}
+
 int psnedf_dgl_dynamic_group_lock(struct litmus_lock* l, resource_mask_t lock_ods)
 {
-    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);
     TRACE("Trying to lock a DGL\n");
+
+    check_mask_valid(l, lock_ods);
     return 0;
 }
 
@@ -645,6 +695,8 @@ static struct litmus_lock* psnedf_new_dgl(void)
 {
     struct dgl_semaphore* sem;
 
+    TRACE("Creating another DGL\n");
+
     sem = kmalloc(sizeof(*sem), GFP_KERNEL);
     if (!sem)
         return NULL;
@@ -653,6 +705,7 @@ static struct litmus_lock* psnedf_new_dgl(void)
     sem->dgl_resources = 0;
     init_waitqueue_head(&sem->wait);
     sem->litmus_lock.ops = &psnedf_dgl_lock_ops;
+    sem->litmus_lock.type = DGL_SEM;
     return &sem->litmus_lock;
 }