Expose LITMUS^RT system calls via control page ioctl()

Rationale: make LITMUS^RT ops available in a way that does not create
merge conflicts each time we rebase LITMUS^RT on top of a new kernel
version. This also helps with portability to different architectures,
as we no longer need to patch each architecture's syscall table.

4 files changed, 198 insertions, 55 deletions

diff --git a/include/litmus/ctrlpage.h b/include/litmus/ctrlpage.h
new file mode 100644
index 000000000000..d86857605ace
--- /dev/null
+++ b/include/litmus/ctrlpage.h
@@ -0,0 +1,99 @@
+#ifndef _LITMUS_CTRLPAGE_H_
+#define _LITMUS_CTRLPAGE_H_
+
+#include <litmus/rt_param.h>
+
+union np_flag {
+        uint32_t raw;
+        struct {
+                /* Is the task currently in a non-preemptive section? */
+                uint32_t flag:31;
+                /* Should the task call into the scheduler? */
+                uint32_t preempt:1;
+        } np;
+};
+
+/* The definition of the data that is shared between the kernel and real-time
+ * tasks via a shared page (see litmus/ctrldev.c).
+ *
+ * WARNING: User space can write to this, so don't trust
+ * the correctness of the fields!
+ *
+ * This servees two purposes: to enable efficient signaling
+ * of non-preemptive sections (user->kernel) and
+ * delayed preemptions (kernel->user), and to export
+ * some real-time relevant statistics such as preemption and
+ * migration data to user space. We can't use a device to export
+ * statistics because we want to avoid system call overhead when
+ * determining preemption/migration overheads).
+ */
+struct control_page {
+        /* This flag is used by userspace to communicate non-preempive
+         * sections. */
+        volatile __attribute__ ((aligned (8))) union np_flag sched;
+
+        /* Incremented by the kernel each time an IRQ is handled. */
+        volatile __attribute__ ((aligned (8))) uint64_t irq_count;
+
+        /* Locking overhead tracing: userspace records here the time stamp
+         * and IRQ counter prior to starting the system call. */
+        uint64_t ts_syscall_start;  /* Feather-Trace cycles */
+        uint64_t irq_syscall_start; /* Snapshot of irq_count when the syscall
+                                     * started. */
+
+        lt_t deadline; /* Deadline for the currently executing job */
+        lt_t release;  /* Release time of current job */
+        uint64_t job_index; /* Job sequence number of current job */
+
+        /* to be extended */
+};
+
+/* Expected offsets within the control page. */
+
+#define LITMUS_CP_OFFSET_SCHED          0
+#define LITMUS_CP_OFFSET_IRQ_COUNT      8
+#define LITMUS_CP_OFFSET_TS_SC_START    16
+#define LITMUS_CP_OFFSET_IRQ_SC_START   24
+#define LITMUS_CP_OFFSET_DEADLINE       32
+#define LITMUS_CP_OFFSET_RELEASE        40
+#define LITMUS_CP_OFFSET_JOB_INDEX      48
+
+/* System call emulation via ioctl() */
+
+typedef enum {
+        LRT_null_call,
+        LRT_set_rt_task_param,
+        LRT_get_rt_task_param,
+        LRT_complete_job,
+        LRT_od_open,
+        LRT_od_close,
+        LRT_litmus_lock,
+        LRT_litmus_unlock,
+        LRT_wait_for_job_release,
+        LRT_wait_for_ts_release,
+        LRT_release_ts,
+        LRT_get_current_budget,
+} litmus_syscall_id_t;
+
+union litmus_syscall_args {
+        struct {
+                pid_t pid;
+                struct rt_task __user *param;
+        } get_set_task_param;
+
+        struct {
+                uint32_t fd;
+                uint32_t obj_type;
+                uint32_t obj_id;
+                void __user *config;
+        } od_open;
+
+        struct {
+                lt_t __user *expended;
+                lt_t __user *remaining;
+        } get_current_budget;
+};
+
+
+#endif
+
diff --git a/include/litmus/litmus.h b/include/litmus/litmus.h
index c3a52aea60fb..787bc2e2a6d8 100644
--- a/include/litmus/litmus.h
+++ b/include/litmus/litmus.h
@@ -6,6 +6,8 @@
 #ifndef _LINUX_LITMUS_H_
 #define _LINUX_LITMUS_H_
 
+#include <litmus/ctrlpage.h>
+
 #include <litmus/debug_trace.h>
 
 #ifdef CONFIG_RELEASE_MASTER
diff --git a/include/litmus/rt_param.h b/include/litmus/rt_param.h
index db133ac0e237..3f29d8c25d94 100644
--- a/include/litmus/rt_param.h
+++ b/include/litmus/rt_param.h
@@ -83,61 +83,6 @@ struct rt_task {
         release_policy_t release_policy;
 };
 
-union np_flag {
-        uint32_t raw;
-        struct {
-                /* Is the task currently in a non-preemptive section? */
-                uint32_t flag:31;
-                /* Should the task call into the scheduler? */
-                uint32_t preempt:1;
-        } np;
-};
-
-/* The definition of the data that is shared between the kernel and real-time
- * tasks via a shared page (see litmus/ctrldev.c).
- *
- * WARNING: User space can write to this, so don't trust
- * the correctness of the fields!
- *
- * This servees two purposes: to enable efficient signaling
- * of non-preemptive sections (user->kernel) and
- * delayed preemptions (kernel->user), and to export
- * some real-time relevant statistics such as preemption and
- * migration data to user space. We can't use a device to export
- * statistics because we want to avoid system call overhead when
- * determining preemption/migration overheads).
- */
-struct control_page {
-        /* This flag is used by userspace to communicate non-preempive
-         * sections. */
-        volatile __attribute__ ((aligned (8))) union np_flag sched;
-
-        /* Incremented by the kernel each time an IRQ is handled. */
-        volatile __attribute__ ((aligned (8))) uint64_t irq_count;
-
-        /* Locking overhead tracing: userspace records here the time stamp
-         * and IRQ counter prior to starting the system call. */
-        uint64_t ts_syscall_start;  /* Feather-Trace cycles */
-        uint64_t irq_syscall_start; /* Snapshot of irq_count when the syscall
-                                     * started. */
-
-        lt_t deadline; /* Deadline for the currently executing job */
-        lt_t release;  /* Release time of current job */
-        uint64_t job_index; /* Job sequence number of current job */
-
-        /* to be extended */
-};
-
-/* Expected offsets within the control page. */
-
-#define LITMUS_CP_OFFSET_SCHED          0
-#define LITMUS_CP_OFFSET_IRQ_COUNT      8
-#define LITMUS_CP_OFFSET_TS_SC_START    16
-#define LITMUS_CP_OFFSET_IRQ_SC_START   24
-#define LITMUS_CP_OFFSET_DEADLINE       32
-#define LITMUS_CP_OFFSET_RELEASE        40
-#define LITMUS_CP_OFFSET_JOB_INDEX      48
-
 /* don't export internal data structures to user space (liblitmus) */
 #ifdef __KERNEL__
 
diff --git a/litmus/ctrldev.c b/litmus/ctrldev.c
index 877f2786b4c8..3c8bbdb7c782 100644
--- a/litmus/ctrldev.c
+++ b/litmus/ctrldev.c
@@ -3,6 +3,8 @@
 #include <linux/fs.h>
 #include <linux/miscdevice.h>
 #include <linux/module.h>
+#include <linux/uaccess.h>
+
 
 #include <litmus/litmus.h>
 
@@ -116,9 +118,104 @@ static int litmus_ctrl_mmap(struct file* filp, struct vm_area_struct* vma)
         return err;
 }
 
+/* LITMUS^RT system calls */
+
+asmlinkage long sys_set_rt_task_param(pid_t pid, struct rt_task __user * param);
+asmlinkage long sys_get_rt_task_param(pid_t pid, struct rt_task __user * param);
+asmlinkage long sys_get_current_budget(lt_t __user * _expended, lt_t __user *_remaining);
+asmlinkage long sys_null_call(cycles_t __user *ts);
+asmlinkage long sys_od_open(int fd, int type, int obj_id, void* __user config);
+asmlinkage long sys_od_close(int od);
+asmlinkage long sys_complete_job(void);
+asmlinkage long sys_litmus_lock(int lock_od);
+asmlinkage long sys_litmus_unlock(int lock_od);
+asmlinkage long sys_wait_for_job_release(unsigned int job);
+asmlinkage long sys_wait_for_ts_release(void);
+asmlinkage long sys_release_ts(lt_t __user *__delay);
+
+static long litmus_ctrl_ioctl(struct file *filp,
+        unsigned int cmd, unsigned long arg)
+{
+        long err = -ENOIOCTLCMD;
+
+        /* LITMUS^RT syscall emulation: we expose LITMUS^RT-specific operations
+         * via ioctl() to avoid merge conflicts with the syscall tables when
+         * rebasing LITMUS^RT. Whi this is not the most elegant way to expose
+         * syscall-like functionality, it helps with reducing the effort
+         * required to maintain LITMUS^RT out of tree.
+         */
+
+        union litmus_syscall_args syscall_args;
+
+        switch (cmd) {
+        case LRT_set_rt_task_param:
+        case LRT_get_rt_task_param:
+        case LRT_get_current_budget:
+        case LRT_od_open:
+                /* multiple arguments => need to get args via pointer */
+                /* get syscall parameters */
+                if (copy_from_user(&syscall_args, (void*) arg,
+                                   sizeof(syscall_args))) {
+                        return -EFAULT;
+                }
+
+                switch (cmd) {
+                case LRT_set_rt_task_param:
+                        return sys_set_rt_task_param(
+                                syscall_args.get_set_task_param.pid,
+                                syscall_args.get_set_task_param.param);
+                case LRT_get_rt_task_param:
+                        return sys_get_rt_task_param(
+                                syscall_args.get_set_task_param.pid,
+                                syscall_args.get_set_task_param.param);
+                case LRT_get_current_budget:
+                        return sys_get_current_budget(
+                                syscall_args.get_current_budget.expended,
+                                syscall_args.get_current_budget.remaining);
+                case LRT_od_open:
+                        return sys_od_open(
+                                syscall_args.od_open.fd,
+                                syscall_args.od_open.obj_type,
+                                syscall_args.od_open.obj_id,
+                                syscall_args.od_open.config);
+                }
+
+
+        case LRT_null_call:
+                return sys_null_call((cycles_t __user *) arg);
+
+        case LRT_od_close:
+                return sys_od_close(arg);
+
+        case LRT_complete_job:
+                return sys_complete_job();
+
+        case LRT_litmus_lock:
+                return sys_litmus_lock(arg);
+
+        case LRT_litmus_unlock:
+                return sys_litmus_unlock(arg);
+
+        case LRT_wait_for_job_release:
+                return sys_wait_for_job_release(arg);
+
+        case LRT_wait_for_ts_release:
+                return sys_wait_for_ts_release();
+
+        case LRT_release_ts:
+                return sys_release_ts((lt_t __user *) arg);
+
+        default:
+                printk(KERN_DEBUG "ctrldev: strange ioctl (%u, %lu)\n", cmd, arg);
+        };
+
+        return err;
+}
+
 static struct file_operations litmus_ctrl_fops = {
         .owner = THIS_MODULE,
         .mmap  = litmus_ctrl_mmap,
+        .unlocked_ioctl = litmus_ctrl_ioctl,
 };
 
 static struct miscdevice litmus_ctrl_dev = {