Added litmus.c, made it compile.

2 files changed, 589 insertions, 1 deletions

diff --git a/kernel/Makefile b/kernel/Makefile
index f67634070a..103c1b1050 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -9,7 +9,7 @@ obj-y     = sched.o fork.o exec_domain.o panic.o printk.o profile.o \
             rcupdate.o extable.o params.o posix-timers.o \
             kthread.o wait.o kfifo.o sys_ni.o posix-cpu-timers.o mutex.o \
             hrtimer.o rwsem.o latency.o nsproxy.o srcu.o \
-            sched_plugin.o
+            sched_plugin.o litmus.o
 
 obj-$(CONFIG_STACKTRACE) += stacktrace.o
 obj-y += time/
diff --git a/kernel/litmus.c b/kernel/litmus.c
new file mode 100644
index 0000000000..7e97df948a
--- /dev/null
+++ b/kernel/litmus.c
@@ -0,0 +1,588 @@
+/*
+ * Variable and function definitions
+ * that help alter the underlying scheduler
+ * on the fly.
+ *
+ */
+
+
+#include <asm/uaccess.h>
+#include <linux/sysrq.h>
+
+#include <linux/queuelock.h> 
+#include <linux/litmus.h>
+#include <linux/sched.h>
+#include <linux/sched_plugin.h>
+
+/*CLEANUP: Include when ported.
+ #include <linux/plugin_trace.h> 
+*/
+
+
+/*      External variables declared in plugin driver */
+extern sched_plugin_t *curr_sched_plugin;
+extern sched_plugin_t linux_sched_plugin;
+
+/*      Variables that govern the scheduling process */
+spolicy sched_policy = SCHED_DEFAULT;
+int sched_options = 0;
+unsigned long slot_size = DEFAULT_SLOT_SIZE;
+unsigned long stagger_offset = DEFAULT_STAGGER; /*       TODO: get rid of software stagger */
+
+spinlock_t litmus_task_set_lock = SPIN_LOCK_UNLOCKED;
+
+/* Use linux runqueues to store currently running CPU task by default */
+int sched_type = INDIRECT_SWITCH;
+
+
+/* This is a flag for switching the system into RT mode when it is booted up 
+*       In RT-mode non-realtime tasks are shut down and scheduled as spare  time available
+*       Even though the system may switch scheduling plugin on the fly 
+*       it must continue to mimic linux scheduler until rt_mode is explicitly 
+*       enabled. 
+*/
+
+/*      The system is booting in non-realtime mode */
+atomic_t rt_mode  = ATOMIC_INIT(MODE_NON_RT);
+/*      Here we specify a mode change to be made */
+atomic_t new_mode = ATOMIC_INIT(MODE_NON_RT);
+/*      Number of RT tasks that exist in the system */
+atomic_t n_rt_tasks = ATOMIC_INIT(0);
+atomic_t *n_rt_tasks_ptr = &n_rt_tasks;
+/*      Only one process can perform mode change */
+static queuelock_t mode_change_lock;
+/*      A time instant when we switched to RT mode */
+volatile unsigned long rt_start_time = 0;
+/**
+* sys_set_rt_mode
+* @newmode: new mode the scheduler must be switched to 
+*       External syscall for setting the RT mode flag 
+*       Returns EINVAL if mode is not recognized or mode transition is not permitted
+*       On success 0 is returned
+*       TODO: implement transition table
+*/
+asmlinkage long sys_set_rt_mode(int newmode)
+{
+
+        if ((newmode == MODE_NON_RT) || (newmode == MODE_RT_RUN)) {
+                unsigned long flags;
+                local_irq_save(flags);
+                printk(KERN_INFO "real-time mode switch to %s\n",
+                      (newmode == MODE_RT_RUN ? "rt" : "non-rt"));
+                local_irq_restore(flags);
+                atomic_set(&new_mode, newmode);
+                return 0;
+        }
+        return -EINVAL;
+}
+
+/**
+* sys_set_task_rt_param
+* @pid: Pid of the task which scheduling parameters must be changed
+* @param: New real-time extension parameters such as the execution cost and period
+*       Syscall for manipulating with task rt extension params 
+*       Returns EFAULT if param is NULL. 
+*       ESRCH if pid is not corrsponding
+*       to a valid task. 
+*       EINVAL if either period or execution cost is <=0
+*       0 if success
+*
+*
+*  FIXME: This code is racy during real-time mode.
+*/
+asmlinkage long sys_set_rt_task_param(pid_t pid, rt_param_t __user * param)
+{
+        rt_param_t tp;
+        struct task_struct *target;
+        int retval = -EINVAL;
+
+        if (pid < 0 || param == 0) {
+                goto out;
+        }
+        if (copy_from_user(&tp, param, sizeof(tp))) {
+                retval = -EFAULT;
+                goto out;
+        }
+        /*      Task search and manipulation must be protected */
+
+        
+        read_lock_irq(&tasklist_lock);
+        if (!(target = find_task_by_pid(pid))) {
+                retval = -ESRCH;
+                goto out_unlock;
+        }
+        if (tp.exec_cost <= 0)
+                goto out_unlock;
+        if (tp.period <= 0)
+                goto out_unlock;
+        if (!cpu_online(tp.cpu))
+                goto out_unlock;
+        if (tp.period < tp.exec_cost)
+        {
+                printk(KERN_INFO "litmus: real-time task %d rejected "
+                       "because wcet > period\n", pid);
+                goto out_unlock;
+        }
+
+        /*      Assign params */
+        target->rt_param.basic_params = tp;
+
+        retval = 0;
+      out_unlock:
+        read_unlock_irq(&tasklist_lock);
+      out:
+        return retval;
+}
+
+/**     Getter of task's RT params
+*       returns EINVAL if param or pid is NULL
+*       returns ESRCH if pid does not correspond to a valid task
+*       returns EFAULT  if copying of parameters has failed.
+*/
+asmlinkage long sys_get_rt_task_param(pid_t pid, rt_param_t __user * param)
+{
+        int retval = -EINVAL;
+        struct task_struct *source;
+        rt_param_t lp;
+        if (param == 0 || pid < 0)
+                goto out;
+        read_lock(&tasklist_lock);
+        if (!(source = find_task_by_pid(pid))) {
+                retval = -ESRCH;
+                goto out_unlock;
+        }
+        lp = source->rt_param.basic_params;
+        read_unlock(&tasklist_lock);
+        /* Do copying outside the lock */
+        retval =
+            copy_to_user(param, &lp, sizeof(lp)) ? -EFAULT : 0;
+        return retval;
+      out_unlock:
+        read_unlock(&tasklist_lock);
+      out:
+        return retval;
+
+}
+
+/*static inline int get_ok_sched(int cpu)
+{
+        return atomic_read(cpu_okay_to_sched(cpu));
+}
+static inline void set_ok_sched(int cpu, int val)
+{
+        atomic_set(cpu_okay_to_sched(cpu), val);
+}
+*/
+
+/*      Returns true if okay_to_sched for current CPU is set to 1 */
+
+/*inline int get_this_ok_sched(void)
+{
+        return atomic_dec_and_test(thisoksched());
+}
+inline void set_this_ok_sched(int val)
+{
+        atomic_set(thisoksched(), val);
+}
+*/
+/**
+* sys_prepare_rt_task
+* @pid: Pid of the task we want to prepare for RT mode
+*       Syscall for adding a task to RT queue, plugin dependent.
+*       Must be called before RT tasks are going to start up.
+*       Returns EPERM if current plugin does not define prepare operation
+*       or scheduling policy does not allow the operation.
+*       ESRCH if pid does not correspond to a valid task.
+*       EINVAL if a task is non-realtime or in invalid state
+*       from underlying plugin function
+*       EAGAIN if a task is not in the right state
+*       ENOMEM if there is no memory space to handle this task
+*       0 if success
+*
+*
+* FIXME:The cpu parameter is currently ignored. It s hould be removed 
+*       altogether
+*/
+asmlinkage long sys_prepare_rt_task(pid_t pid, int dummy)
+{
+        int retval = -EINVAL;
+        struct task_struct *target = 0;
+        /*      If a plugin does not define preparation mode then nothing to do */
+        if (curr_sched_plugin->prepare_task == 0
+            || sched_policy == SCHED_DEFAULT) {
+                retval = -EPERM;
+                goto out_prepare;
+        }
+        read_lock_irq(&tasklist_lock);
+        if (!(target = find_task_by_pid(pid))) {
+                retval = -ESRCH;
+                goto out_prepare_unlock;
+        }
+        if (!cpu_online(get_partition(target)))
+        {
+                printk(KERN_WARNING "litmus prepare: cpu %d is not online\n", 
+                       get_partition(target));
+                goto out_prepare_unlock;
+        }       
+        retval = curr_sched_plugin->prepare_task(target);
+        if (!retval) {
+                atomic_inc(&n_rt_tasks);
+                target->rt_param.is_realtime = 1;
+        }
+      out_prepare_unlock:
+        read_unlock_irq(&tasklist_lock);
+      out_prepare:
+        return retval;
+}
+
+/* External reference to kill, probably need to move at the header */
+extern long sys_kill(pid_t, int);
+/**
+*       Task tear down, removes a task from plugin structures, sets its
+*       properties to non-realtime and sends a signal (SIGKILL suggested, so that the task shuts down  immediately)
+*       returns EINVAL if the task is not a realtime task
+*       returns EPERM if the task is current, or current kernel policy does not permit 
+*       realtime operations
+*       returns ESRCH if the pid does not correspond to a valid task
+*       Otherwise the result of sys_kill is returned
+*/
+asmlinkage long sys_tear_down_task(pid_t pid, int sig)
+{
+        int retval = -EINVAL;
+        struct task_struct *target = 0;
+        if (curr_sched_plugin->tear_down == 0
+            || sched_policy == SCHED_DEFAULT) {
+                retval = -EPERM;
+                goto out;
+        }
+        read_lock_irq(&tasklist_lock);
+        if (!(target = find_task_by_pid(pid))) {
+                retval = -ESRCH;
+                goto out_unlock;
+        }
+        if (target == current) {
+                retval = -EPERM;
+                goto out_unlock;
+        }
+        printk(KERN_WARNING "task %d: use of sys_tear_down_task is deprecated! "
+               "Just use kill instead.\n", current->pid);
+/*      if (is_realtime(target)) {
+                // the task is not realtime now, there is no harm 
+                // because it is going to be killed
+                retval = curr_sched_plugin->tear_down(target);
+                // drop all the RT params of the task
+                clear_task(target);
+                target->state = TASK_STOPPED;
+        }
+*/
+        read_unlock_irq(&tasklist_lock);
+
+        // call syskill 
+        return sys_kill(pid, sig);
+      out_unlock:
+        read_unlock_irq(&tasklist_lock);
+      out:
+        return retval;
+}
+
+/**     
+*       This is the crucial function for periodic task implementation,
+*       It checks if a task is periodic, checks if such kind of sleep is permitted
+*       and calls plugin-specific sleep, which puts the task into a wait array.
+*       returns 0 on successful wakeup
+*       returns EPERM if current conditions do not permit such sleep
+*       returns EINVAL if current task is not able to go to sleep
+*/
+asmlinkage long sys_sleep_next_period(void)
+{
+        int retval = -EPERM;
+        // Periodic sleep is not permitted for linux scheduler
+        // because quantum runqueues are not merged
+        if (curr_sched_plugin->sleep_next_period == 0
+            || sched_policy == SCHED_DEFAULT) {
+                goto out;
+        }
+        if (!is_realtime(current)) {
+                retval = -EINVAL;
+                goto out;
+        }
+        // Task with negative or zero period cannot sleep
+        if (get_rt_period(current) <= 0) {
+                retval = -EINVAL;
+                goto out;
+        }
+        /*      Basically the plugin have to put the task into 
+         *      appropriate quantum queue and call schedule
+         */
+        retval = curr_sched_plugin->sleep_next_period();
+      out:
+        return retval;
+}
+
+/* Set scheduling options for all cpus. */
+void set_sched_options(int options)
+{
+        sched_options = options;
+}
+
+
+/* Wrapper code for tick function - called by all schedulers before 
+   entering their own code. 
+*/
+
+int rt_scheduler_tick(void)
+{
+        /*      Check for mode change */
+        if ((get_rt_mode() != atomic_read(&new_mode))) {
+                queue_lock(&mode_change_lock);
+                // If the mode is already changed, proceed
+                if (get_rt_mode() == atomic_read(&new_mode)) {
+                        queue_unlock(&mode_change_lock);
+                        goto proceed;
+                }
+                // change the mode
+                if ((atomic_read(&new_mode) == MODE_RT_RUN)) {
+                        /* The deferral of entering real-time mode should be 
+                         * handled by deferring task releases in the plugin.
+                         * The plugin interface does not really need to know
+                         * about quanta, that is the plugin's job.
+                         */
+
+                        /*  update rt start time */
+                        rt_start_time = jiffies;
+                        TRACE("Real-Time mode enabled\n");
+                        if (curr_sched_plugin->mode_change)
+                                curr_sched_plugin->
+                                    mode_change(atomic_read(&new_mode));
+                }
+                set_rt_mode(atomic_read(&new_mode));
+                queue_unlock(&mode_change_lock);
+        }
+
+ proceed:
+        /*      Call plugin-defined tick handler        
+         *
+         *      It is the plugin's tick handler' job to detect quantum
+         *      boundaries in pfair.
+         */
+        return curr_sched_plugin->algo_scheduler_tick();
+}
+
+inline int get_sched_options(void)
+{
+        return sched_options;
+}
+
+/* This code must be non-preemptable */
+asmlinkage spolicy sys_sched_setpolicy(spolicy newpolicy)
+{
+        /*      Dynamic policy change is disabled at the moment */
+        /*
+           spolicy cpolicy = sched_policy;
+
+           if (newpolicy >= SCHED_BEG && newpolicy <= SCHED_END) {
+           sched_policy = newpolicy;
+           switch (sched_policy) {
+           case SCHED_GLOBAL_EDF:
+           initialize_global_edf();
+           break;
+           case SCHED_PART_EDF:
+           initialize_part_edf();
+           break;
+           case SCHED_PFAIR:
+           initialize_scheduler_pfair();
+           break;
+           case SCHED_PFAIR_STAGGER:
+           initialize_scheduler_pfair_stagger();
+           break;
+           default:
+           initialize_scheduler_linux();
+           break;
+           }
+           return cpolicy;
+           } else
+         */
+        return SCHED_INVALID;
+}
+
+asmlinkage spolicy sys_sched_getpolicy(void)
+{
+        return sched_policy;
+}
+
+
+asmlinkage int sys_scheduler_setup(int cmd, void __user *parameter) 
+{
+        return curr_sched_plugin->scheduler_setup(cmd, parameter);
+}
+
+
+#ifdef CONFIG_MAGIC_SYSRQ
+/* We offer the possibility to change the real-time mode of the system
+ * with a magic sys request. This helps in debugging in case the system fails
+ * to perform its planned switch back to normal mode. This may happen if we have
+ * total system utilization and the task that is supposed to do the switch is 
+ * always preempted (if it is not a real-time task).
+ */
+
+static void sysrq_handle_toGgle_rt_mode(int key, struct tty_struct *tty) 
+{
+        sys_set_rt_mode(get_rt_mode() == MODE_NON_RT);
+}
+
+static struct sysrq_key_op sysrq_toGgle_rt_mode_op = {
+        .handler        = sysrq_handle_toGgle_rt_mode,
+        .help_msg       = "toGgle-rt-mode",
+        .action_msg     = "real-time mode changed",
+};
+
+static void sysrq_handle_kill_rt_tasks(int key, struct tty_struct *tty) 
+{       
+        struct task_struct *t;
+        read_lock(&tasklist_lock);
+        for_each_process(t) {
+                if (is_realtime(t)) {
+                        sys_kill(t->pid, SIGKILL);
+                }
+        }
+        read_unlock(&tasklist_lock);
+}
+
+static struct sysrq_key_op sysrq_kill_rt_tasks_op = {
+        .handler        = sysrq_handle_kill_rt_tasks,
+        .help_msg       = "f:kill-rt-tasks",
+        .action_msg     = "sent SIGKILL to all real-time tasks",
+};
+#endif
+
+/* 
+ * Scheduler initialization so that customized scheduler is
+ * enabled at boot time
+ * by setting boot option "rtsched=plugin_name", e.g. "rtsched=pfair"
+ */
+
+/* All we need to know about other plugins is their initialization 
+ * functions. These functions initialize internal data structures of a 
+ * scheduler and return a pointer to initialized sched_plugin data 
+ * structure with pointers to scheduling function implementations.
+ * If called repeatedly these init functions just return an existing 
+ * plugin pointer.
+ */
+/*
+CLEANUP: Add init function when the plugin has been ported.
+sched_plugin_t *init_pfair_plugin(void);
+sched_plugin_t *init_global_edf_plugin(void);
+sched_plugin_t *init_part_edf_plugin(void);
+sched_plugin_t *init_desync_pfair_plugin(void);
+sched_plugin_t *init_global_edf_np_plugin(void);
+sched_plugin_t *init_edf_hsb_plugin(void);
+*/
+
+
+
+
+/* keep everything needed to setup plugins in one place */
+
+/* we are lazy, so we use a convention for function naming to fill
+ * a table
+ */
+#define PLUGIN(caps, small) \
+        {PLUGIN_ ## caps, SCHED_ ## caps, init_ ## small ## _plugin}
+
+#define init_nosetup_plugin 0
+
+static struct {
+        const char *name;
+        const spolicy policy_id;
+        sched_plugin_t *(*init) (void);
+} available_plugins[] = {
+        PLUGIN(LINUX, nosetup),
+/* CLEANUP: Add when ported.
+        PLUGIN(PFAIR, pfair),
+        PLUGIN(PART_EDF, part_edf),
+        PLUGIN(GLOBAL_EDF, global_edf),
+        PLUGIN(PFAIR_DESYNC, desync_pfair),
+        PLUGIN(GLOBAL_EDF_NP, global_edf_np),
+        PLUGIN(GLOBAL_EDF, global_edf),
+        PLUGIN(EDF_HSB, edf_hsb)
+*/
+
+        /*********************************************
+        *       Add your custom plugin here                             
+        **********************************************/
+};
+
+/* Some plugins may leave important functions  unused. We define dummies
+ * so that we don't have to check for null pointers all over the place.
+ */
+void litmus_dummy_finish_switch(struct task_struct * prev);
+int  litmus_dummy_schedule(struct task_struct * prev, struct task_struct** next,
+                           runqueue_t* q);
+reschedule_check_t  litmus_dummy_scheduler_tick(void);
+long litmus_dummy_prepare_task(struct task_struct *t);
+void litmus_dummy_wake_up_task(struct task_struct *task);
+void litmus_dummy_task_blocks(struct task_struct *task);
+long litmus_dummy_tear_down(struct task_struct *task);
+int  litmus_dummy_scheduler_setup(int cmd, void __user *parameter);
+
+#define CHECK(func) {\
+        if (!curr_sched_plugin->func) \
+                curr_sched_plugin->func = litmus_dummy_ ## func;}
+
+static int boot_sched_setup(char *plugin_name)
+{
+        int i = 0;
+
+        /*      Common initializers,
+         *      mode change lock is used to enforce single mode change 
+         *      operation.
+         */
+        queue_lock_init(&mode_change_lock, NR_CPUS);
+
+        printk("Starting LITMUS kernel\n");
+
+        /* Look for a matching plugin.
+         */
+        for (i = 0; i < ARRAY_SIZE(available_plugins); i++) {
+                if (!strcmp(plugin_name, available_plugins[i].name)) {
+                        printk("Using %s scheduler plugin\n", plugin_name);
+                        sched_policy = available_plugins[i].policy_id;
+                        if (available_plugins[i].init)
+                                curr_sched_plugin = available_plugins[i].init();
+                        goto out;
+                }
+        }
+
+        
+        /*      Otherwise we have default linux scheduler */
+        printk("Plugin name %s is unknown, using default %s\n", plugin_name,
+               curr_sched_plugin->plugin_name);
+
+out:
+        /* make sure we don't trip over null pointers later */
+        CHECK(finish_switch);
+        CHECK(schedule);
+        CHECK(scheduler_tick);
+        CHECK(wake_up_task);
+        CHECK(tear_down);
+        CHECK(task_blocks);
+        CHECK(prepare_task);
+        CHECK(scheduler_setup);
+
+#ifdef CONFIG_MAGIC_SYSRQ
+        /* offer some debugging help */
+        if (!register_sysrq_key('g', &sysrq_toGgle_rt_mode_op)) 
+                printk("Registered eXit real-time mode magic sysrq.\n");
+        else
+                printk("Could not register eXit real-time mode magic sysrq.\n");
+        if (!register_sysrq_key('f', &sysrq_kill_rt_tasks_op)) 
+                printk("Registered kill rt tasks magic sysrq.\n");
+        else
+                printk("Could not register kill rt tasks magic sysrq.\n");
+#endif
+        printk("Litmus setup complete.");
+        return 1;
+}
+
+/*      Register for boot option */
+__setup("rtsched=", boot_sched_setup);