1 files changed, 83 insertions, 0 deletions

diff --git a/litmus/litmus.c b/litmus/litmus.c
index 11ccaafd50de..16b3aeda5615 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -17,6 +17,12 @@
 #include <litmus/litmus_proc.h>
 #include <litmus/sched_trace.h>
 
+#ifdef CONFIG_PLUGIN_MC
+#include <litmus/sched_mc.h>
+#else
+struct mc_task;
+#endif
+
 /* Number of RT tasks that exist in the system */
 atomic_t rt_task_count          = ATOMIC_INIT(0);
 static DEFINE_RAW_SPINLOCK(task_transition_lock);
@@ -274,6 +280,74 @@ asmlinkage long sys_null_call(cycles_t __user *ts)
         return ret;
 }
 
+#ifdef CONFIG_PLUGIN_MC
+asmlinkage long sys_set_rt_task_mc_param(pid_t pid, struct mc_task __user *param)
+{
+        struct mc_task mc;
+        struct mc_data *mc_data;
+        struct task_struct *target;
+        int retval = -EINVAL;
+
+        printk("Setting up mixed-criicality task parameters for process %d.\n",
+                pid);
+
+        if (pid < 0 || param == 0) {
+                goto out;
+        }
+        if (copy_from_user(&mc, param, sizeof(mc))) {
+                retval = -EFAULT;
+                goto out;
+        }
+
+        /* Task search and manipulation must be protected */
+        read_lock_irq(&tasklist_lock);
+        if (!(target = find_task_by_vpid(pid))) {
+                retval = -ESRCH;
+                goto out_unlock;
+        }
+
+        if (is_realtime(target)) {
+                /* The task is already a real-time task.
+                 * We cannot not allow parameter changes at this point.
+                 */
+                retval = -EBUSY;
+                goto out_unlock;
+        }
+
+        if (mc.crit < CRIT_LEVEL_A || mc.crit > CRIT_LEVEL_D)
+        {
+                printk(KERN_WARNING "litmus: real-time task %d rejected because "
+                        "of invalid criticality level\n", pid);
+                goto out_unlock;
+        }
+
+        mc_data = tsk_rt(target)->mc_data;
+        if (!mc_data)
+        {
+                mc_data = kmalloc(sizeof(*mc_data), GFP_ATOMIC);
+                if (!mc_data)
+                {
+                        retval = -ENOMEM;
+                        goto out_unlock;
+                }
+                tsk_rt(target)->mc_data = mc_data;
+        }
+        mc_data->mc_task.crit = mc.crit;
+
+        retval = 0;
+out_unlock:
+        read_unlock_irq(&tasklist_lock);
+out:
+        return retval;
+}
+#else
+asmlinkage long sys_set_rt_task_mc_param(pid_t pid, struct mc_task __user *param)
+{
+        /* don't allow this syscall if the plugin is not enabled */
+        return -EINVAL;
+}
+#endif
+
 /* p is a real-time task. Re-init its state as a best-effort task. */
 static void reinit_litmus_state(struct task_struct* p, int restore)
 {
@@ -479,6 +553,15 @@ void exit_litmus(struct task_struct *dead_tsk)
                 free_page((unsigned long) tsk_rt(dead_tsk)->ctrl_page);
         }
 
+#ifdef CONFIG_PLUGIN_MC
+        /* The MC-setup syscall might succeed and allocate mc_data, but the
+           task may not exit in real-time mode, and that memory will leak.
+           Check and free it here.
+        */
+        if (tsk_rt(dead_tsk)->mc_data)
+                kfree(tsk_rt(dead_tsk)->mc_data);
+#endif
+
         /* main cleanup only for RT tasks */
         if (is_realtime(dead_tsk))
                 litmus_exit_task(dead_tsk);