2.6.24.5

 kernel

diff --git a/kernel/sched.c b/kernel/sched.c
index e76b11c..f8dc213 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -727,6 +727,49 @@ static void resched_cpu(int cpu)
    resched_task(cpu_curr(cpu));
    spin_unlock_irqrestore(&rq->lock, flags);
 }
+
+#ifdef CONFIG_NO_HZ
+/*
+ * When add_timer_on() enqueues a timer into the timer wheel of an
+ * idle CPU then this timer might expire before the next timer event
+ * which is scheduled to wake up that CPU. In case of a completely
+ * idle system the next event might even be infinite time into the
+ * future. wake_up_idle_cpu() ensures that the CPU is woken up and
+ * leaves the inner idle loop so the newly added timer is taken into
+ * account when the CPU goes back to idle and evaluates the timer
+ * wheel for the next timer event.
+ */
+void wake_up_idle_cpu(int cpu)
+{
+   struct rq *rq = cpu_rq(cpu);
+
+   if (cpu == smp_processor_id())
+      return;
+
+   /*
+    * This is safe, as this function is called with the timer
+    * wheel base lock of (cpu) held. When the CPU is on the way
+    * to idle and has not yet set rq->curr to idle then it will
+    * be serialized on the timer wheel base lock and take the new
+    * timer into account automatically.
+    */
+   if (rq->curr != rq->idle)
+      return;
+
+   /*
+    * We can set TIF_RESCHED on the idle task of the other CPU
+    * lockless. The worst case is that the other CPU runs the
+    * idle task through an additional NOOP schedule()
+    */
+   set_tsk_thread_flag(rq->idle, TIF_NEED_RESCHED);
+
+   /* NEED_RESCHED must be visible before we test polling */
+   smp_mb();
+   if (!tsk_is_polling(rq->idle))
+      smp_send_reschedule(cpu);
+}
+#endif
+
 #else
 static inline void resched_task(struct task_struct *p)
 {
@@ -4028,11 +4071,10 @@ void rt_mutex_setprio(struct task_struct *p, int prio)
    oldprio = p->prio;
    on_rq = p->se.on_rq;
    running = task_current(rq, p);
-   if (on_rq) {
+   if (on_rq)
       dequeue_task(rq, p, 0);
-      if (running)
-         p->sched_class->put_prev_task(rq, p);
-   }
+   if (running)
+      p->sched_class->put_prev_task(rq, p);
 
    if (rt_prio(prio))
       p->sched_class = &rt_sched_class;
@@ -4041,9 +4083,9 @@ void rt_mutex_setprio(struct task_struct *p, int prio)
 
    p->prio = prio;
 
+   if (running)
+      p->sched_class->set_curr_task(rq);
    if (on_rq) {
-      if (running)
-         p->sched_class->set_curr_task(rq);
       enqueue_task(rq, p, 0);
       /*
        * Reschedule if we are currently running on this runqueue and
@@ -4339,18 +4381,17 @@ recheck:
    update_rq_clock(rq);
    on_rq = p->se.on_rq;
    running = task_current(rq, p);
-   if (on_rq) {
+   if (on_rq)
       deactivate_task(rq, p, 0);
-      if (running)
-         p->sched_class->put_prev_task(rq, p);
-   }
+   if (running)
+      p->sched_class->put_prev_task(rq, p);
 
    oldprio = p->prio;
    __setscheduler(rq, p, policy, param->sched_priority);
 
+   if (running)
+      p->sched_class->set_curr_task(rq);
    if (on_rq) {
-      if (running)
-         p->sched_class->set_curr_task(rq);
       activate_task(rq, p, 0);
       /*
        * Reschedule if we are currently running on this runqueue and
@@ -7110,19 +7151,17 @@ void sched_move_task(struct task_struct *tsk)
    running = task_current(rq, tsk);
    on_rq = tsk->se.on_rq;
 
-   if (on_rq) {
+   if (on_rq)
       dequeue_task(rq, tsk, 0);
-      if (unlikely(running))
-         tsk->sched_class->put_prev_task(rq, tsk);
-   }
+   if (unlikely(running))
+      tsk->sched_class->put_prev_task(rq, tsk);
 
    set_task_cfs_rq(tsk, task_cpu(tsk));
 
-   if (on_rq) {
-      if (unlikely(running))
-         tsk->sched_class->set_curr_task(rq);
+   if (unlikely(running))
+      tsk->sched_class->set_curr_task(rq);
+   if (on_rq)
       enqueue_task(rq, tsk, 0);
-   }
 
 done:
    task_rq_unlock(rq, &flags);