Setup DGL system calls.

7 files changed, 128 insertions, 6 deletions

diff --git a/include/litmus/fdso.h b/include/litmus/fdso.h
index f2115b83f1e4..82f88221f4f0 100644
--- a/include/litmus/fdso.h
+++ b/include/litmus/fdso.h
@@ -12,7 +12,9 @@
 #include <linux/fs.h>
 #include <linux/slab.h>
 
-#define MAX_OBJECT_DESCRIPTORS 85
+#define MAX_OBJECT_DESCRIPTORS 32
+
+typedef unsigned int resource_mask_t;
 
 typedef enum  {
         MIN_OBJ_TYPE    = 0,
@@ -25,8 +27,10 @@ typedef enum  {
         DPCP_SEM        = 4,
 
         PCP_SEM         = 5,
+        
+    DGL_SEM         = 6,
 
-        MAX_OBJ_TYPE    = 5
+        MAX_OBJ_TYPE    = 6
 } obj_type_t;
 
 struct inode_obj_id {
diff --git a/include/litmus/locking.h b/include/litmus/locking.h
index 4d7b870cb443..e9998946e7de 100644
--- a/include/litmus/locking.h
+++ b/include/litmus/locking.h
@@ -3,6 +3,8 @@
 
 struct litmus_lock_ops;
 
+struct dynamic_group_lock_ops;
+
 /* Generic base struct for LITMUS^RT userspace semaphores.
  * This structure should be embedded in protocol-specific semaphores.
  */
@@ -25,4 +27,20 @@ struct litmus_lock_ops {
         void (*deallocate)(struct litmus_lock*);
 };
 
+struct dynamic_group_lock {
+    struct dynamic_group_lock_ops *ops;
+
+    /* Probably useful for different RNLP variants. */
+    int type;
+};
+
+struct dynamic_group_lock_ops {
+    // Do we need open and close?
+
+    int (*lock)(struct dynamic_group_lock*);
+    int (*unlock)(struct dynamic_group_lock*);
+
+    void (*deallocate)(struct dynamic_group_lock*);
+};
+
 #endif
diff --git a/include/litmus/unistd_32.h b/include/litmus/unistd_32.h
index 94264c27d9ac..1c59c92547c5 100644
--- a/include/litmus/unistd_32.h
+++ b/include/litmus/unistd_32.h
@@ -17,5 +17,8 @@
 #define __NR_wait_for_ts_release __LSC(9)
 #define __NR_release_ts         __LSC(10)
 #define __NR_null_call          __LSC(11)
+#define __NR_dynamic_group_lock     __LSC(12)
+#define __NR_dynamic_group_unlock   __LSC(13)
+#define __NR_dynamic_group_add      __LSC(14)
 
-#define NR_litmus_syscalls 12
+#define NR_litmus_syscalls 15
diff --git a/include/litmus/unistd_64.h b/include/litmus/unistd_64.h
index d5ced0d2642c..93ea10363b46 100644
--- a/include/litmus/unistd_64.h
+++ b/include/litmus/unistd_64.h
@@ -29,5 +29,11 @@ __SYSCALL(__NR_wait_for_ts_release, sys_wait_for_ts_release)
 __SYSCALL(__NR_release_ts, sys_release_ts)
 #define __NR_null_call                          __LSC(11)
 __SYSCALL(__NR_null_call, sys_null_call)
+#define __NR_dynamic_group_lock     __LSC(12)
+__SYSCALL(__NR_dynamic_group_lock, sys_dynamic_group_lock)
+#define __NR_dynamic_group_unlock   __LSC(13)
+__SYSCALL(__NR_dynamic_group_lock, sys_dynamic_group_unlock)
+#define __NR_dynamic_group_add      __LSC(14)
+__SYSCALL(__NR_dynamic_group_add, sys_dynamic_group_add)
 
-#define NR_litmus_syscalls 12
+#define NR_litmus_syscalls 15
diff --git a/litmus/fdso.c b/litmus/fdso.c
index c4b450be4509..fdd9a6e805c7 100644
--- a/litmus/fdso.c
+++ b/litmus/fdso.c
@@ -27,6 +27,7 @@ static const struct fdso_ops* fdso_ops[] = {
         &generic_lock_ops, /* MPCP_VS_SEM */
         &generic_lock_ops, /* DPCP_SEM */
         &generic_lock_ops, /* PCP_SEM */
+        &generic_lock_ops, /* RNLP_SEM */
 };
 
 static int fdso_create(void** obj_ref, obj_type_t type, void* __user config)
@@ -238,7 +239,6 @@ static int do_sys_od_open(struct file* file, obj_type_t type, int id,
         return idx;
 }
 
-
 struct od_table_entry* get_entry_for_od(int od)
 {
         struct task_struct *t = current;
@@ -252,7 +252,6 @@ struct od_table_entry* get_entry_for_od(int od)
         return t->od_table + od;
 }
 
-
 asmlinkage long sys_od_open(int fd, int type, int obj_id, void* __user config)
 {
         int ret = 0;
diff --git a/litmus/locking.c b/litmus/locking.c
index 43d9aece2e74..6ddc22b7de11 100644
--- a/litmus/locking.c
+++ b/litmus/locking.c
@@ -68,6 +68,45 @@ static void destroy_generic_lock(obj_type_t type, void* obj)
         lock->ops->deallocate(lock);
 }
 
+bool check_mask_valid(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 mask)
+{
+    //long err = -EINVAL;
+
+    //TS_LOCK_START;
+
+    //TS_LOCK_END;
+
+    //return err;
+
+    TRACE("Successfully called the dynamic group lock system call");
+    printk("printk: Successfully called the dynamic group lock system call");
+    return -EINVAL;
+}
+
+asmlinkage long sys_dynamic_group_unlock(resource_mask_t lock_ods)
+{
+    return 0;
+}
+
+/*
+ * Point the new_od to the existing dynamic_group_lock pointed to in the entry
+ * for dgl_od. In so doing, update the metadata for the dgl so the masks are
+ * correct.
+ */
+asmlinkage long sys_dynamic_group_add(int dgl_od, int new_od)
+{
+//    long err = -EINVAL;
+    return 0;
+}
+
 asmlinkage long sys_litmus_lock(int lock_od)
 {
         long err = -EINVAL;
diff --git a/litmus/sched_psn_edf.c b/litmus/sched_psn_edf.c
index 65c85a3a4c64..ce97b73829bf 100644
--- a/litmus/sched_psn_edf.c
+++ b/litmus/sched_psn_edf.c
@@ -405,10 +405,37 @@ struct fmlp_semaphore {
         wait_queue_head_t wait;
 };
 
+struct dgl_semaphore {
+    struct dynamic_group_lock dynamic_group_lock;
+
+    /* bitmask of resources that are currently locked. */
+    resource_mask_t locked;
+
+    /* bitmask of resources in the file descriptor table that are controlled by
+     * this dgl_semaphore.
+     */
+    resource_mask_t dgl_resources;
+
+    /* There can be no more than $m$ resource holders, because under
+     * partitioned scheduling, the resource holders are priority boosted, and
+     * it is impossible to have $>m$ boosted jobs.
+     */
+    unsigned int resource_holders;
+    
+    /* FIFO queue of waiting tasks */
+    wait_queue_head_t wait;
+};
+
 static inline struct fmlp_semaphore* fmlp_from_lock(struct litmus_lock* lock)
 {
         return container_of(lock, struct fmlp_semaphore, litmus_lock);
 }
+
+static inline struct dgl_semaphore* dgl_from_lock(struct dynamic_group_lock* dgl)
+{
+    return container_of(dgl, struct dgl_semaphore, dynamic_group_lock);
+}
+
 int psnedf_fmlp_lock(struct litmus_lock* l)
 {
         struct task_struct* t = current;
@@ -534,6 +561,11 @@ void psnedf_fmlp_free(struct litmus_lock* lock)
         kfree(fmlp_from_lock(lock));
 }
 
+void psnedf_dgl_free(struct dynamic_group_lock* dgl)
+{
+    kfree(dgl_from_lock(dgl));
+}
+
 static struct litmus_lock_ops psnedf_fmlp_lock_ops = {
         .close  = psnedf_fmlp_close,
         .lock   = psnedf_fmlp_lock,
@@ -541,6 +573,12 @@ static struct litmus_lock_ops psnedf_fmlp_lock_ops = {
         .deallocate = psnedf_fmlp_free,
 };
 
+//static struct dynamic_group_lock_ops psnedf_dgl_lock_ops = {
+//    .lock   = psnedf_dgl_lock,
+//    .unlock = psnedf_dgl_unlock,
+//    .deallocate = psnedf_dgl_free,
+//}
+
 static struct litmus_lock* psnedf_new_fmlp(void)
 {
         struct fmlp_semaphore* sem;
@@ -556,6 +594,21 @@ static struct litmus_lock* psnedf_new_fmlp(void)
         return &sem->litmus_lock;
 }
 
+static struct dynamic_group_lock* psnedf_new_dgl(void)
+{
+    struct dgl_semaphore* sem;
+
+    sem = kmalloc(sizeof(*sem), GFP_KERNEL);
+    if (!sem)
+        return NULL;
+
+    sem->resource_holders = 0;
+    sem->dgl_resources = 0;
+    init_waitqueue_head(&sem->wait);
+    //sem->dynamic_group_lock.ops = &psnedf_dgl_lock_ops;
+    return &sem->dynamic_group_lock;
+}
+
 /* **** lock constructor **** */