Fix a bunch of bugs that crept in while porting.

* Our old clone flag is already taken in 2.6.20.
* Fix wrong is_running() macro.
* Remove double ->finish_switch() call.
* Move sched_trace_scheduled to non-preemtible section.
* Allow next = idle task in RT mode.

3 files changed, 16 insertions, 23 deletions

diff --git a/kernel/litmus.c b/kernel/litmus.c
index faf82931f5..04a28159e1 100644
--- a/kernel/litmus.c
+++ b/kernel/litmus.c
@@ -82,6 +82,8 @@ asmlinkage long sys_set_rt_task_param(pid_t pid, rt_param_t __user * param)
         struct task_struct *target;
         int retval = -EINVAL;
 
+        printk("Setting up rt task parameters for process %d.\n", pid);
+
         if (pid < 0 || param == 0) {
                 goto out;
         }
@@ -253,7 +255,7 @@ reschedule_check_t  __sched rt_scheduler_tick(void)
 
                         /*  update rt start time */
                         rt_start_time = jiffies;
-                        TRACE("Real-Time mode enabled\n");
+                        printk(KERN_INFO "Real-Time mode enabled\n");
                         if (curr_sched_plugin->mode_change)
                                 curr_sched_plugin->
                                     mode_change(atomic_read(&new_mode));
diff --git a/kernel/sched.c b/kernel/sched.c
index 784a97fe33..308e624b43 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -1679,10 +1679,10 @@ void fastcall wake_up_new_task(struct task_struct *p, unsigned long clone_flags)
         unsigned long flags;
         int this_cpu, cpu;
 
-        if(clone_flags & CLONE_REALTIME) {
+        if (clone_flags & CLONE_REALTIME) {
                 /* just mark the task as stopped */
                 /* CLEANUP: Do we have to remove the task from the rq? */
-                p->state=TASK_STOPPED;
+                p->state = TASK_STOPPED;
                 return;
         }
 
@@ -1848,6 +1848,7 @@ static inline void finish_task_switch(struct rq *rq, struct task_struct *prev)
          */
         if (is_realtime(prev) && is_running(prev))
                 curr_sched_plugin->finish_switch(prev);
+        sched_trace_task_scheduled(current);
         finish_lock_switch(rq, prev);
         if (mm)
                 mmdrop(mm);
@@ -1870,9 +1871,6 @@ asmlinkage void schedule_tail(struct task_struct *prev)
 {
         struct rq *rq = this_rq();
 
-        if (is_realtime(prev) && is_running(prev))
-                curr_sched_plugin->finish_switch(prev);
- 
         finish_task_switch(rq, prev);
 #ifdef __ARCH_WANT_UNLOCKED_CTXSW
         /* In this case, finish_task_switch does not reenable preemption */
@@ -1880,8 +1878,6 @@ asmlinkage void schedule_tail(struct task_struct *prev)
 #endif
         if (current->set_child_tid)
                 put_user(current->pid, current->set_child_tid);
-
-        sched_trace_task_scheduled(current);
 }
 
 /*
@@ -3591,12 +3587,13 @@ need_resched_nonpreemptible:
                 goto switch_tasks;
 
         cpu = smp_processor_id();
-        /* only load-balance if we are not in RT mode 
-         * TODO: Maybe this can be relaxed by modifiying the load-balancing
-         *       routines in such a way that they never touch real-time tasks.
-         */
-        if (unlikely(!rq->nr_running) && get_rt_mode() == MODE_NON_RT) {
-                idle_balance(cpu, rq);
+        if (unlikely(!rq->nr_running)) {
+                /* only load-balance if we are not in RT mode 
+                 * TODO: Maybe this can be relaxed by modifiying the load-balancing
+                 *       routines in such a way that they never touch real-time tasks.
+                 */
+                if (get_rt_mode() == MODE_NON_RT)
+                        idle_balance(cpu, rq);
                 if (!rq->nr_running) {
                         next = rq->idle;
                         rq->expired_timestamp = 0;
@@ -3684,8 +3681,6 @@ switch_tasks:
         preempt_enable_no_resched();
         if (unlikely(test_thread_flag(TIF_NEED_RESCHED)))
                 goto need_resched;
-        
-        sched_trace_task_scheduled(current);
 }
 EXPORT_SYMBOL(schedule);
 
diff --git a/kernel/sched_global_edf.c b/kernel/sched_global_edf.c
index 0b761c4230..a37709a561 100644
--- a/kernel/sched_global_edf.c
+++ b/kernel/sched_global_edf.c
@@ -197,10 +197,6 @@ static int gedf_schedule(struct task_struct * prev,
         if (get_rt_mode() == MODE_RT_RUN) {
                 write_lock_irqsave(&gedf.ready_lock, flags);
 
-                if (is_realtime(prev))
-                        DUMP(" [%d] is_realtime(prev) = %d\n", 
-                             smp_processor_id(), is_realtime(prev));
-
                 clear_will_schedule();
 
                 if (is_realtime(prev) && is_released(prev) && is_running(prev)
@@ -260,7 +256,7 @@ static int gedf_schedule(struct task_struct * prev,
  */
 static void gedf_finish_switch(struct task_struct *prev) 
 {
-        DUMP("finish switch for %d\n", prev->pid);
+        printk(KERN_INFO "gedf finish switch for %d\n", prev->pid);
         if (get_rt_flags(prev) == RT_F_SLEEP || 
             get_rt_mode() != MODE_RT_RUN) {
                 /* this task has expired
@@ -386,7 +382,7 @@ static int gedf_mode_change(int new_mode)
         int cpu;
         cpu_entry_t *entry;
 
-        TRACE("[%d] global edf: mode changed to %d\n", smp_processor_id(), 
+        printk(KERN_INFO "[%d] global edf: mode changed to %d\n", smp_processor_id(), 
               new_mode);
         if (new_mode == MODE_RT_RUN) {
                 prepare_new_releases(&gedf, jiffies + 10);
@@ -413,7 +409,7 @@ static int gedf_mode_change(int new_mode)
                 }               
                 spin_unlock(&gedf_cpu_lock);
         }
-        TRACE("[%d] global edf: mode change done\n", smp_processor_id());
+        printk(KERN_INFO "[%d] global edf: mode change done\n", smp_processor_id());
         return 0;
 }