litmus: get rid of WANT_RESCHED and make dummy functions static

5 files changed, 28 insertions, 61 deletions

diff --git a/include/linux/sched_plugin.h b/include/linux/sched_plugin.h
index 6bc2fc3788..1fcc9d558b 100644
--- a/include/linux/sched_plugin.h
+++ b/include/linux/sched_plugin.h
@@ -34,14 +34,8 @@ typedef void runqueue_t;
 
 /********************* scheduler invocation ******************/
 
-typedef enum {
-        NO_RESCHED    = 0,
-        FORCE_RESCHED = 1
-} reschedule_check_t;
-
-
 /*  Plugin-specific realtime tick handler */
-typedef reschedule_check_t (*scheduler_tick_t) (void);
+typedef void (*scheduler_tick_t) (void);
 /* Novell make sched decision function */
 typedef int (*schedule_t) (struct task_struct * prev,
                            struct task_struct ** next,
@@ -114,11 +108,6 @@ struct sched_plugin {
 
 extern struct sched_plugin *curr_sched_plugin;
 
-
-/* common scheduler tick */
-reschedule_check_t rt_scheduler_tick(void);
-
-
 /* Don't pull in our definitions on top of the real ones
  * in sched.c!
  */
diff --git a/kernel/sched.c b/kernel/sched.c
index ec59d583b3..dd38df5d88 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -3321,8 +3321,7 @@ void scheduler_tick(void)
          * schedule
          */
         TS_PLUGIN_TICK_START;
-        if (curr_sched_plugin->scheduler_tick() == FORCE_RESCHED)
-                set_tsk_need_resched(p);
+        curr_sched_plugin->scheduler_tick();
         TS_PLUGIN_TICK_END;
 
         send_scheduler_signals();
diff --git a/kernel/sched_gsn_edf.c b/kernel/sched_gsn_edf.c
index 423c5468a0..3958cb2f37 100644
--- a/kernel/sched_gsn_edf.c
+++ b/kernel/sched_gsn_edf.c
@@ -333,26 +333,17 @@ static noinline  void gsnedf_release_jobs(void)
  *                   checks whether the current task has expired and checks
  *                   whether we need to preempt it if it has not expired
  */
-static reschedule_check_t gsnedf_scheduler_tick(void)
+static void gsnedf_scheduler_tick(void)
 {
         unsigned long           flags;
         struct task_struct*     t = current;
-        reschedule_check_t      want_resched = NO_RESCHED;
-
-        /* expire tasks even if not in real-time mode
-         * this makes sure that at the end of real-time mode
-         * no task  "runs away forever".
-         */
-        if (is_realtime(t)) {
-                TRACE_CUR("before dec: time_slice == %u\n", t->time_slice);
-        }
 
         if (is_realtime(t) && get_exec_time(t) > get_exec_cost(t)) {
                 if (!is_np(t)) { 
                         /* np tasks will be preempted when they become
                          * preemptable again 
                          */
-                        want_resched = FORCE_RESCHED;
+                        set_tsk_need_resched(t);
                         set_will_schedule();
                         TRACE("gsnedf_scheduler_tick: "
                               "%d is preemptable "
@@ -369,17 +360,15 @@ static reschedule_check_t gsnedf_scheduler_tick(void)
         if (smp_processor_id() == 0) {
                 spin_lock_irqsave(&gsnedf_lock, flags);
 
-                /* (1) try to release pending jobs */
+                /* Try to release pending jobs */
                 gsnedf_release_jobs();
 
-                /* we don't need to check linked != scheduled since
-                 * set_tsk_need_resched has been set by preempt() if necessary
+                /* We don't need to check linked != scheduled since
+                 * set_tsk_need_resched has been set by preempt() if necessary.
                  */
 
                 spin_unlock_irqrestore(&gsnedf_lock, flags);
         }
-
-        return want_resched;
 }
 
 /* caller holds gsnedf_lock */
diff --git a/kernel/sched_plugin.c b/kernel/sched_plugin.c
index 10abdb5df7..eb236b3a3e 100644
--- a/kernel/sched_plugin.c
+++ b/kernel/sched_plugin.c
@@ -15,63 +15,61 @@
  *                   Dummy plugin functions                  *
  *************************************************************/
 
-void litmus_dummy_finish_switch(struct task_struct * prev)
+static void litmus_dummy_finish_switch(struct task_struct * prev)
 {
 }
 
-int litmus_dummy_schedule(struct task_struct * prev,
+static int litmus_dummy_schedule(struct task_struct * prev,
                           struct task_struct** next,
                           runqueue_t* q)
 {
         return 0;
 }
 
-reschedule_check_t litmus_dummy_scheduler_tick(void)
+static void litmus_dummy_scheduler_tick(void)
 {
-        return NO_RESCHED;
 }
 
-
-long litmus_dummy_prepare_task(struct task_struct *t)
+static long litmus_dummy_prepare_task(struct task_struct *t)
 {
         return 0;
 }
 
-void litmus_dummy_wake_up_task(struct task_struct *task)
+static void litmus_dummy_wake_up_task(struct task_struct *task)
 {
         printk(KERN_WARNING "task %d: unhandled real-time wake up!\n",
           task->pid);
 }
 
-void litmus_dummy_task_blocks(struct task_struct *task)
+static void litmus_dummy_task_blocks(struct task_struct *task)
 {
 }
 
-long litmus_dummy_tear_down(struct task_struct *task)
+static long litmus_dummy_tear_down(struct task_struct *task)
 {
         return 0;
 }
 
-long litmus_dummy_sleep_next_period(void)
+static long litmus_dummy_sleep_next_period(void)
 {
-        return -EPERM;
+        return -ENOSYS;
 }
 
-long litmus_dummy_inherit_priority(struct pi_semaphore *sem,
+static long litmus_dummy_inherit_priority(struct pi_semaphore *sem,
                                    struct task_struct *new_owner)
 {
-        return -EPERM;
+        return -ENOSYS;
 }
 
-long litmus_dummy_return_priority(struct pi_semaphore *sem)
+static long litmus_dummy_return_priority(struct pi_semaphore *sem)
 {
-        return -EPERM;
+        return -ENOSYS;
 }
 
-long litmus_dummy_pi_block(struct pi_semaphore *sem,
+static long litmus_dummy_pi_block(struct pi_semaphore *sem,
                            struct task_struct *new_waiter)
 {
-        return -EPERM;
+        return -ENOSYS;
 }
 
 
diff --git a/kernel/sched_psn_edf.c b/kernel/sched_psn_edf.c
index 8689c53d98..cfe329506e 100644
--- a/kernel/sched_psn_edf.c
+++ b/kernel/sched_psn_edf.c
@@ -99,11 +99,10 @@ static int psnedf_check_resched(rt_domain_t *edf)
 }
 
 
-static reschedule_check_t psnedf_scheduler_tick(void)
+static void psnedf_scheduler_tick(void)
 {
         unsigned long       flags;
         struct task_struct *t            = current;
-        reschedule_check_t  want_resched = NO_RESCHED;
         rt_domain_t        *edf          = local_edf;
         psnedf_domain_t    *pedf         = local_pedf;
 
@@ -113,13 +112,10 @@ static reschedule_check_t psnedf_scheduler_tick(void)
          */
         BUG_ON(is_realtime(t) && t != pedf->scheduled);
 
-        if (is_realtime(t))
-                TRACE("%s/%d was hit by scheduler tick\n", t->comm, t->pid);
-
         if (is_realtime(t) && get_exec_time(t) > get_exec_cost(t)) {
-                if (!is_np(t)) {
-                        want_resched = FORCE_RESCHED;
-                } else {
+                if (!is_np(t))
+                        set_tsk_need_resched(t);
+                else {
                         TRACE("psnedf_scheduler_tick: "
                               "%d is non-preemptable, "
                               "preemption delayed.\n", t->pid);
@@ -129,13 +125,9 @@ static reschedule_check_t psnedf_scheduler_tick(void)
 
         spin_lock_irqsave(&pedf->lock, flags);
         __release_pending(edf);
-        if (want_resched != FORCE_RESCHED &&
-                edf_preemption_needed(edf, t))
-                want_resched = FORCE_RESCHED;
-
+        if (edf_preemption_needed(edf, t))
+                set_tsk_need_resched(t);
         spin_unlock_irqrestore(&pedf->lock, flags);
-
-        return want_resched;
 }
 
 static void job_completion(struct task_struct* t)