got some cruft out of litmus.c

2 files changed, 96 insertions, 211 deletions

diff --git a/kernel/litmus.c b/kernel/litmus.c
index 7e97df948a..26471c3e31 100644
--- a/kernel/litmus.c
+++ b/kernel/litmus.c
@@ -1,11 +1,6 @@
-/*
- * Variable and function definitions
- * that help alter the underlying scheduler
- * on the fly.
- *
+/* litmus.c -- Implementation of the LITMUS syscalls, the LITMUS intialization,
+ *             and the common tick function.
  */
-
-
 #include <asm/uaccess.h>
 #include <linux/sysrq.h>
 
@@ -19,77 +14,72 @@
 */
 
 
-/*      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 */
+spolicy sched_policy            = SCHED_DEFAULT;
+int     sched_options           = 0;
 
+/*      avoid races with multiple task wake-ups */
 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;
+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. 
-*/
+ * In RT-mode non-realtime tasks are shut down and scheduled as spare  
+ * time available
+ */
 
 /*      The system is booting in non-realtime mode */
-atomic_t rt_mode  = ATOMIC_INIT(MODE_NON_RT);
+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);
+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;
+atomic_t n_rt_tasks             = ATOMIC_INIT(0);
+
 /*      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;
+volatile jiffie_t 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
-*/
+ * 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
+ *
+ *      FIXME: In a "real" OS we cannot just let any user switch the mode...
+ */
 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.
-*/
+/*
+ * 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;
@@ -103,9 +93,8 @@ asmlinkage long sys_set_rt_task_param(pid_t pid, rt_param_t __user * param)
                 retval = -EFAULT;
                 goto out;
         }
-        /*      Task search and manipulation must be protected */
 
-        
+        /*      Task search and manipulation must be protected */       
         read_lock_irq(&tasklist_lock);
         if (!(target = find_task_by_pid(pid))) {
                 retval = -ESRCH;
@@ -134,11 +123,11 @@ asmlinkage long sys_set_rt_task_param(pid_t pid, rt_param_t __user * param)
         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.
-*/
+/*      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;
@@ -164,50 +153,25 @@ asmlinkage long sys_get_rt_task_param(pid_t pid, rt_param_t __user * param)
 
 }
 
-/*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)
+/*
+ * 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
+ */
+asmlinkage long sys_prepare_rt_task(pid_t pid)
 {
         int retval = -EINVAL;
         struct task_struct *target = 0;
-        /*      If a plugin does not define preparation mode then nothing to do */
+        /* 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;
@@ -229,90 +193,35 @@ asmlinkage long sys_prepare_rt_task(pid_t pid, int dummy)
                 atomic_inc(&n_rt_tasks);
                 target->rt_param.is_realtime = 1;
         }
-      out_prepare_unlock:
+ out_prepare_unlock:
         read_unlock_irq(&tasklist_lock);
-      out_prepare:
+ 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
-*/
+/*      
+ *      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
+        /* 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
+        /* The plugin has to put the task into an
+         * appropriate queue and call schedule
          */
         retval = curr_sched_plugin->sleep_next_period();
       out:
@@ -325,12 +234,10 @@ 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)
+/* The LITMUS tick function. It manages the change to and from real-time mode
+ * and then calls the plugin's tick function.
+ */
+int __sched rt_scheduler_tick(void)
 {
         /*      Check for mode change */
         if ((get_rt_mode() != atomic_read(&new_mode))) {
@@ -368,40 +275,9 @@ int rt_scheduler_tick(void)
         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;
 }
 
@@ -425,6 +301,8 @@ asmlinkage int sys_scheduler_setup(int cmd, void __user *parameter)
  * always preempted (if it is not a real-time task).
  */
 
+int sys_kill(int pid, int sig);
+
 static void sysrq_handle_toGgle_rt_mode(int key, struct tty_struct *tty) 
 {
         sys_set_rt_mode(get_rt_mode() == MODE_NON_RT);
@@ -524,6 +402,7 @@ 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);
+long litmus_dummy_sleep_next_period(void);
 
 #define CHECK(func) {\
         if (!curr_sched_plugin->func) \
@@ -568,6 +447,7 @@ out:
         CHECK(task_blocks);
         CHECK(prepare_task);
         CHECK(scheduler_setup);
+        CHECK(sleep_next_period);
 
 #ifdef CONFIG_MAGIC_SYSRQ
         /* offer some debugging help */
diff --git a/kernel/sched_plugin.c b/kernel/sched_plugin.c
index 3e7e90b767..31771f7c51 100644
--- a/kernel/sched_plugin.c
+++ b/kernel/sched_plugin.c
@@ -20,7 +20,7 @@
  */
 void linux_sched_init(void);
 void linux_sched_init_smp(void);
-int linux_migration_init(void);
+int  linux_migration_init(void);
 
 /*************************************************************
  *                   Dummy plugin functions                  *
@@ -69,6 +69,11 @@ int litmus_dummy_scheduler_setup(int cmd, void __user *parameter)
         return -EPERM;
 }
 
+long litmus_dummy_sleep_next_period(void) 
+{
+        return -EPERM;
+}
+
 
 /* The default scheduler plugin. It doesn't do anything and lets Linux do its
  * job.
@@ -83,7 +88,7 @@ sched_plugin_t linux_sched_plugin = {
         .tear_down = litmus_dummy_tear_down,    
         .wake_up_task = litmus_dummy_wake_up_task,
         .task_blocks = litmus_dummy_task_blocks,
-        .sleep_next_period = 0, /*   Linux does not have periodic tasks */
+        .sleep_next_period = litmus_dummy_sleep_next_period,
         .shutdown_hook = 0,
         .schedule = litmus_dummy_schedule,
         .finish_switch = litmus_dummy_finish_switch,
@@ -91,10 +96,10 @@ sched_plugin_t linux_sched_plugin = {
 };
 
 /*      
-*       The reference to current plugin that is used to schedule tasks within
-*       the system. It stores references to actual function implementations
-*       Should be initialized by calling "init_***_plugin()"
-*/
+ *      The reference to current plugin that is used to schedule tasks within
+ *      the system. It stores references to actual function implementations
+ *      Should be initialized by calling "init_***_plugin()"
+ */
 sched_plugin_t *curr_sched_plugin = &linux_sched_plugin;