add FDSO support.

8 files changed, 372 insertions, 0 deletions

diff --git a/fs/exec.c b/fs/exec.c
index 282240afe99e..6f47786702a9 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -56,6 +56,8 @@
 #include <asm/mmu_context.h>
 #include <asm/tlb.h>
 
+#include <litmus/litmus.h>
+
 #ifdef CONFIG_KMOD
 #include <linux/kmod.h>
 #endif
@@ -1309,6 +1311,7 @@ int do_execve(char * filename,
                 goto out_kfree;
 
         sched_exec();
+        litmus_exec();
 
         bprm->file = file;
         bprm->filename = filename;
diff --git a/fs/inode.c b/fs/inode.c
index ed35383d0b6c..ef71ea06c65d 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -220,6 +220,8 @@ void inode_init_once(struct inode *inode)
         INIT_LIST_HEAD(&inode->inotify_watches);
         mutex_init(&inode->inotify_mutex);
 #endif
+        INIT_LIST_HEAD(&inode->i_obj_list);
+        mutex_init(&inode->i_obj_mutex);
 }
 
 EXPORT_SYMBOL(inode_init_once);
diff --git a/include/linux/fs.h b/include/linux/fs.h
index b3ec4a496d64..22f856c14e76 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -588,6 +588,8 @@ static inline int mapping_writably_mapped(struct address_space *mapping)
 #define i_size_ordered_init(inode) do { } while (0)
 #endif
 
+struct inode_obj_id_table;
+
 struct inode {
         struct hlist_node       i_hash;
         struct list_head        i_list;
@@ -653,6 +655,9 @@ struct inode {
         void                    *i_security;
 #endif
         void                    *i_private; /* fs or device private pointer */
+
+        struct list_head        i_obj_list;
+        struct mutex            i_obj_mutex;
 };
 
 /*
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 3bf424c433ce..76e28f19e9a0 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -917,6 +917,8 @@ struct sched_entity {
 #endif
 };
 
+struct od_table_entry;
+
 struct task_struct {
         volatile long state;    /* -1 unrunnable, 0 runnable, >0 stopped */
         void *stack;
@@ -1184,6 +1186,9 @@ struct task_struct {
 
         /* litmus parameters and state */
         struct rt_param rt_param;
+
+        /* references to PI semaphores, etc. */
+        struct od_table_entry* od_table;
 };
 
 /*
diff --git a/include/litmus/fdso.h b/include/litmus/fdso.h
new file mode 100644
index 000000000000..286e10f86de0
--- /dev/null
+++ b/include/litmus/fdso.h
@@ -0,0 +1,69 @@
+/* fdso.h - file descriptor attached shared objects
+ *
+ * (c) 2007 B. Brandenburg, LITMUS^RT project
+ */
+
+#ifndef _LINUX_FDSO_H_
+#define _LINUX_FDSO_H_
+
+#include <linux/list.h>
+#include <asm/atomic.h>
+
+#include <linux/fs.h>
+
+#define MAX_OBJECT_DESCRIPTORS 32
+
+typedef enum  {
+        MIN_OBJ_TYPE    = 0,
+
+        FMLP_SEM        = 0,
+        SRP_SEM         = 1,
+
+        MAX_OBJ_TYPE    = 1
+} obj_type_t;
+
+struct inode_obj_id {
+        struct list_head        list;
+        atomic_t                count;
+        struct inode*           inode;
+
+        obj_type_t              type;
+        void*                   obj;
+        unsigned int            id;
+};
+
+
+struct od_table_entry {
+        unsigned int            used;
+
+        struct inode_obj_id*    obj;
+        void*                   extra;
+};
+
+struct fdso_ops {
+        void* (*create) (void);
+        void  (*destroy)(void*);
+        int   (*open)   (struct od_table_entry*, void* __user);
+        int   (*close)  (struct od_table_entry*);
+};
+
+/* translate a userspace supplied od into the raw table entry
+ * returns NULL if od is invalid
+ */
+struct od_table_entry* __od_lookup(int od);
+
+/* translate a userspace supplied od into the associated object
+ * returns NULL if od is invalid
+ */
+static inline void* od_lookup(int od, obj_type_t type)
+{
+        struct od_table_entry* e = __od_lookup(od);
+        return e && e->obj->type == type ? e->obj->obj : NULL;
+}
+
+#define lookup_fmlp_sem(od)((struct pi_semaphore*)  od_lookup(od, FMLP_SEM))
+#define lookup_srp_sem(od) ((struct srp_semaphore*) od_lookup(od, SRP_SEM))
+#define lookup_ics(od)     ((struct ics*)           od_lookup(od, ICS_ID))
+
+
+#endif
diff --git a/kernel/exit.c b/kernel/exit.c
index 549c0558ba68..bc313b74a15c 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -52,6 +52,8 @@
 
 extern void sem_exit (void);
 
+extern void exit_od_table(struct task_struct* t);
+
 static void exit_mm(struct task_struct * tsk);
 
 static void __unhash_process(struct task_struct *p)
@@ -987,6 +989,8 @@ fastcall NORET_TYPE void do_exit(long code)
         if (unlikely(tsk->audit_context))
                 audit_free(tsk);
 
+        exit_od_table(tsk);
+
         tsk->exit_code = code;
         taskstats_exit(tsk, group_dead);
 
diff --git a/litmus/Makefile b/litmus/Makefile
index 59f61cbc7f10..3d18cff62cee 100644
--- a/litmus/Makefile
+++ b/litmus/Makefile
@@ -7,6 +7,7 @@ obj-y     = sched_plugin.o litmus.o \
             sync.o \
             rt_domain.o \
             edf_common.o \
+            fdso.o \
             heap.o
 
 obj-$(CONFIG_FEATHER_TRACE) += ft_event.o ftdev.o
diff --git a/litmus/fdso.c b/litmus/fdso.c
new file mode 100644
index 000000000000..323efac17a47
--- /dev/null
+++ b/litmus/fdso.c
@@ -0,0 +1,283 @@
+/* fdso.c - file descriptor attached shared objects
+ *
+ * (c) 2007 B. Brandenburg, LITMUS^RT project
+ *
+ * Notes:
+ *   - objects descriptor (OD) tables are not cloned during a fork.
+ *   - objects are created on-demand, and freed after the last reference
+ *     is dropped.
+ *   - for now, object types are hard coded.
+ *   - As long as we have live objects, we keep a reference to the inode.
+ */
+
+#include <linux/errno.h>
+#include <linux/sched.h>
+#include <linux/mutex.h>
+#include <linux/file.h>
+#include <asm/uaccess.h>
+
+#include <litmus/fdso.h>
+
+
+static struct fdso_ops dummy_ops = {
+        .create  = NULL
+};
+
+static const struct fdso_ops* fdso_ops[] = {
+        &dummy_ops,
+        &dummy_ops,
+};
+
+static void* fdso_create(obj_type_t type)
+{
+        if (fdso_ops[type]->create)
+                return fdso_ops[type]->create();
+        else
+                return NULL;
+}
+
+static void fdso_destroy(obj_type_t type, void* obj)
+{
+        fdso_ops[type]->destroy(obj);
+}
+
+static int fdso_open(struct od_table_entry* entry, void* __user config)
+{
+        if (fdso_ops[entry->obj->type]->open)
+                return fdso_ops[entry->obj->type]->open(entry, config);
+        else
+                return 0;
+}
+
+static int fdso_close(struct od_table_entry* entry)
+{
+        if (fdso_ops[entry->obj->type]->close)
+                return fdso_ops[entry->obj->type]->close(entry);
+        else
+                return 0;
+}
+
+/* inode must be locked already */
+static struct inode_obj_id* alloc_inode_obj(struct inode* inode,
+                                            obj_type_t type,
+                                            unsigned int id)
+{
+        struct inode_obj_id* obj;
+        void* raw_obj;
+
+        raw_obj = fdso_create(type);
+        if (!raw_obj)
+                return NULL;
+
+        obj = kmalloc(sizeof(*obj), GFP_KERNEL);
+        if (!obj)
+                return NULL;
+        INIT_LIST_HEAD(&obj->list);
+        atomic_set(&obj->count, 1);
+        obj->type  = type;
+        obj->id    = id;
+        obj->obj   = raw_obj;
+        obj->inode = inode;
+
+        list_add(&obj->list, &inode->i_obj_list);
+        atomic_inc(&inode->i_count);
+
+        printk(KERN_DEBUG "alloc_inode_obj(%p, %d, %d): object created\n", inode, type, id);
+        return obj;
+}
+
+/* inode must be locked already */
+static struct inode_obj_id* get_inode_obj(struct inode* inode,
+                                          obj_type_t type,
+                                          unsigned int id)
+{
+        struct list_head* pos;
+        struct inode_obj_id* obj = NULL;
+
+        list_for_each(pos, &inode->i_obj_list) {
+                obj = list_entry(pos, struct inode_obj_id, list);
+                if (obj->id == id && obj->type == type) {
+                        atomic_inc(&obj->count);
+                        return obj;
+                }
+        }
+        printk(KERN_DEBUG "get_inode_obj(%p, %d, %d): couldn't find object\n", inode, type, id);
+        return NULL;
+}
+
+
+static void put_inode_obj(struct inode_obj_id* obj)
+{
+        struct inode* inode;
+        int let_go = 0;
+
+        inode = obj->inode;
+        if (atomic_dec_and_test(&obj->count)) {
+
+                mutex_lock(&inode->i_obj_mutex);
+                /* no new references can be obtained */
+                if (!atomic_read(&obj->count)) {
+                        list_del(&obj->list);
+                        fdso_destroy(obj->type, obj->obj);
+                        kfree(obj);
+                        let_go = 1;
+                }
+                mutex_unlock(&inode->i_obj_mutex);
+                if (let_go)
+                        iput(inode);
+        }
+}
+
+static struct od_table_entry*  get_od_entry(struct task_struct* t)
+{
+        struct od_table_entry* table;
+        int i;
+
+
+        table = t->od_table;
+        if (!table) {
+                table = kzalloc(sizeof(*table) * MAX_OBJECT_DESCRIPTORS,
+                                GFP_KERNEL);
+                t->od_table = table;
+        }
+
+        for (i = 0; table &&  i < MAX_OBJECT_DESCRIPTORS; i++)
+                if (!table[i].used) {
+                        table[i].used = 1;
+                        return table + i;
+                }
+        return NULL;
+}
+
+static int put_od_entry(struct od_table_entry* od)
+{
+        put_inode_obj(od->obj);
+        od->used = 0;
+        return 0;
+}
+
+void exit_od_table(struct task_struct* t)
+{
+        int i;
+
+        if (t->od_table) {
+                for (i = 0; i < MAX_OBJECT_DESCRIPTORS; i++)
+                        if (t->od_table[i].used)
+                                put_od_entry(t->od_table + i);
+                kfree(t->od_table);
+                t->od_table = NULL;
+        }
+}
+
+static int do_sys_od_open(struct file* file, obj_type_t type, int id,
+                          void* __user config)
+{
+        int idx = 0, err;
+        struct inode* inode;
+        struct inode_obj_id* obj = NULL;
+        struct od_table_entry* entry;
+
+        inode = file->f_dentry->d_inode;
+
+        entry = get_od_entry(current);
+        if (!entry)
+                return -ENOMEM;
+
+        mutex_lock(&inode->i_obj_mutex);
+        obj = get_inode_obj(inode, type, id);
+        if (!obj)
+                obj = alloc_inode_obj(inode, type, id);
+        if (!obj) {
+                idx = -ENOMEM;
+                entry->used = 0;
+        } else {
+                entry->obj   = obj;
+                entry->extra = NULL;
+                idx = entry - current->od_table;
+        }
+
+        mutex_unlock(&inode->i_obj_mutex);
+
+        err = fdso_open(entry, config);
+        if (err < 0) {
+                /* The class rejected the open call.
+                 * We need to clean up and tell user space.
+                 */
+                put_od_entry(entry);
+                idx = err;
+        }
+
+        return idx;
+}
+
+
+struct od_table_entry* __od_lookup(int od)
+{
+        struct task_struct *t = current;
+
+        if (!t->od_table)
+                return NULL;
+        if (od < 0 || od >= MAX_OBJECT_DESCRIPTORS)
+                return NULL;
+        if (!t->od_table[od].used)
+                return NULL;
+        return t->od_table + od;
+}
+
+
+asmlinkage int sys_od_open(int fd, int type, int obj_id, void* __user config)
+{
+        int ret = 0;
+        struct file*  file;
+
+        /*
+           1) get file from fd, get inode from file
+           2) lock inode
+           3) try to lookup object
+           4) if not present create and enqueue object, inc inode refcnt
+           5) increment refcnt of object
+           6) alloc od_table_entry, setup ptrs
+           7) unlock inode
+           8) return offset in od_table as OD
+         */
+
+        if (type < MIN_OBJ_TYPE || type > MAX_OBJ_TYPE) {
+                ret = -EINVAL;
+                goto out;
+        }
+
+        file = fget(fd);
+        if (!file) {
+                ret = -EBADF;
+                goto out;
+        }
+
+        ret = do_sys_od_open(file, type, obj_id, config);
+
+        fput(file);
+
+out:
+        return ret;
+}
+
+
+asmlinkage int sys_od_close(int od)
+{
+        int ret = -EINVAL;
+        struct task_struct *t = current;
+
+        if (od < 0 || od >= MAX_OBJECT_DESCRIPTORS)
+                return ret;
+
+        if (!t->od_table || !t->od_table[od].used)
+                return ret;
+
+
+        /* give the class a chance to reject the close
+         */
+        ret = fdso_close(t->od_table + od);
+        if (ret == 0)
+                ret = put_od_entry(t->od_table + od);
+
+        return ret;
+}