1 files changed, 93 insertions, 38 deletions

diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c
index cb02324bdb88..342fc9ccab46 100644
--- a/kernel/time/tick-sched.c
+++ b/kernel/time/tick-sched.c
@@ -20,6 +20,7 @@
 #include <linux/profile.h>
 #include <linux/sched.h>
 #include <linux/tick.h>
+#include <linux/module.h>
 
 #include <asm/irq_regs.h>
 
@@ -154,7 +155,7 @@ void tick_nohz_update_jiffies(void)
         touch_softlockup_watchdog();
 }
 
-void tick_nohz_stop_idle(int cpu)
+static void tick_nohz_stop_idle(int cpu)
 {
         struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
 
@@ -190,9 +191,17 @@ u64 get_cpu_idle_time_us(int cpu, u64 *last_update_time)
 {
         struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
 
-        *last_update_time = ktime_to_us(ts->idle_lastupdate);
+        if (!tick_nohz_enabled)
+                return -1;
+
+        if (ts->idle_active)
+                *last_update_time = ktime_to_us(ts->idle_lastupdate);
+        else
+                *last_update_time = ktime_to_us(ktime_get());
+
         return ktime_to_us(ts->idle_sleeptime);
 }
+EXPORT_SYMBOL_GPL(get_cpu_idle_time_us);
 
 /**
  * tick_nohz_stop_sched_tick - stop the idle tick from the idle task
@@ -261,7 +270,7 @@ void tick_nohz_stop_sched_tick(int inidle)
         next_jiffies = get_next_timer_interrupt(last_jiffies);
         delta_jiffies = next_jiffies - last_jiffies;
 
-        if (rcu_needs_cpu(cpu))
+        if (rcu_needs_cpu(cpu) || printk_needs_cpu(cpu))
                 delta_jiffies = 1;
         /*
          * Do not stop the tick, if we are only one off
@@ -291,7 +300,7 @@ void tick_nohz_stop_sched_tick(int inidle)
                                 goto out;
                         }
 
-                        ts->idle_tick = ts->sched_timer.expires;
+                        ts->idle_tick = hrtimer_get_expires(&ts->sched_timer);
                         ts->tick_stopped = 1;
                         ts->idle_jiffies = last_jiffies;
                         rcu_enter_nohz();
@@ -368,6 +377,32 @@ ktime_t tick_nohz_get_sleep_length(void)
         return ts->sleep_length;
 }
 
+static void tick_nohz_restart(struct tick_sched *ts, ktime_t now)
+{
+        hrtimer_cancel(&ts->sched_timer);
+        hrtimer_set_expires(&ts->sched_timer, ts->idle_tick);
+
+        while (1) {
+                /* Forward the time to expire in the future */
+                hrtimer_forward(&ts->sched_timer, now, tick_period);
+
+                if (ts->nohz_mode == NOHZ_MODE_HIGHRES) {
+                        hrtimer_start_expires(&ts->sched_timer,
+                                      HRTIMER_MODE_ABS);
+                        /* Check, if the timer was already in the past */
+                        if (hrtimer_active(&ts->sched_timer))
+                                break;
+                } else {
+                        if (!tick_program_event(
+                                hrtimer_get_expires(&ts->sched_timer), 0))
+                                break;
+                }
+                /* Update jiffies and reread time */
+                tick_do_update_jiffies64(now);
+                now = ktime_get();
+        }
+}
+
 /**
  * tick_nohz_restart_sched_tick - restart the idle tick from the idle task
  *
@@ -421,35 +456,16 @@ void tick_nohz_restart_sched_tick(void)
          */
         ts->tick_stopped  = 0;
         ts->idle_exittime = now;
-        hrtimer_cancel(&ts->sched_timer);
-        ts->sched_timer.expires = ts->idle_tick;
 
-        while (1) {
-                /* Forward the time to expire in the future */
-                hrtimer_forward(&ts->sched_timer, now, tick_period);
+        tick_nohz_restart(ts, now);
 
-                if (ts->nohz_mode == NOHZ_MODE_HIGHRES) {
-                        hrtimer_start(&ts->sched_timer,
-                                      ts->sched_timer.expires,
-                                      HRTIMER_MODE_ABS);
-                        /* Check, if the timer was already in the past */
-                        if (hrtimer_active(&ts->sched_timer))
-                                break;
-                } else {
-                        if (!tick_program_event(ts->sched_timer.expires, 0))
-                                break;
-                }
-                /* Update jiffies and reread time */
-                tick_do_update_jiffies64(now);
-                now = ktime_get();
-        }
         local_irq_enable();
 }
 
 static int tick_nohz_reprogram(struct tick_sched *ts, ktime_t now)
 {
         hrtimer_forward(&ts->sched_timer, now, tick_period);
-        return tick_program_event(ts->sched_timer.expires, 0);
+        return tick_program_event(hrtimer_get_expires(&ts->sched_timer), 0);
 }
 
 /*
@@ -494,10 +510,6 @@ static void tick_nohz_handler(struct clock_event_device *dev)
         update_process_times(user_mode(regs));
         profile_tick(CPU_PROFILING);
 
-        /* Do not restart, when we are in the idle loop */
-        if (ts->tick_stopped)
-                return;
-
         while (tick_nohz_reprogram(ts, now)) {
                 now = ktime_get();
                 tick_do_update_jiffies64(now);
@@ -532,7 +544,7 @@ static void tick_nohz_switch_to_nohz(void)
         next = tick_init_jiffy_update();
 
         for (;;) {
-                ts->sched_timer.expires = next;
+                hrtimer_set_expires(&ts->sched_timer, next);
                 if (!tick_program_event(next, 0))
                         break;
                 next = ktime_add(next, tick_period);
@@ -543,6 +555,41 @@ static void tick_nohz_switch_to_nohz(void)
                smp_processor_id());
 }
 
+/*
+ * When NOHZ is enabled and the tick is stopped, we need to kick the
+ * tick timer from irq_enter() so that the jiffies update is kept
+ * alive during long running softirqs. That's ugly as hell, but
+ * correctness is key even if we need to fix the offending softirq in
+ * the first place.
+ *
+ * Note, this is different to tick_nohz_restart. We just kick the
+ * timer and do not touch the other magic bits which need to be done
+ * when idle is left.
+ */
+static void tick_nohz_kick_tick(int cpu)
+{
+#if 0
+        /* Switch back to 2.6.27 behaviour */
+
+        struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
+        ktime_t delta, now;
+
+        if (!ts->tick_stopped)
+                return;
+
+        /*
+         * Do not touch the tick device, when the next expiry is either
+         * already reached or less/equal than the tick period.
+         */
+        now = ktime_get();
+        delta = ktime_sub(hrtimer_get_expires(&ts->sched_timer), now);
+        if (delta.tv64 <= tick_period.tv64)
+                return;
+
+        tick_nohz_restart(ts, now);
+#endif
+}
+
 #else
 
 static inline void tick_nohz_switch_to_nohz(void) { }
@@ -550,6 +597,19 @@ static inline void tick_nohz_switch_to_nohz(void) { }
 #endif /* NO_HZ */
 
 /*
+ * Called from irq_enter to notify about the possible interruption of idle()
+ */
+void tick_check_idle(int cpu)
+{
+        tick_check_oneshot_broadcast(cpu);
+#ifdef CONFIG_NO_HZ
+        tick_nohz_stop_idle(cpu);
+        tick_nohz_update_jiffies();
+        tick_nohz_kick_tick(cpu);
+#endif
+}
+
+/*
  * High resolution timer specific code
  */
 #ifdef CONFIG_HIGH_RES_TIMERS
@@ -602,10 +662,6 @@ static enum hrtimer_restart tick_sched_timer(struct hrtimer *timer)
                 profile_tick(CPU_PROFILING);
         }
 
-        /* Do not restart, when we are in the idle loop */
-        if (ts->tick_stopped)
-                return HRTIMER_NORESTART;
-
         hrtimer_forward(timer, now, tick_period);
 
         return HRTIMER_RESTART;
@@ -628,16 +684,15 @@ void tick_setup_sched_timer(void)
         ts->sched_timer.cb_mode = HRTIMER_CB_IRQSAFE_PERCPU;
 
         /* Get the next period (per cpu) */
-        ts->sched_timer.expires = tick_init_jiffy_update();
+        hrtimer_set_expires(&ts->sched_timer, tick_init_jiffy_update());
         offset = ktime_to_ns(tick_period) >> 1;
         do_div(offset, num_possible_cpus());
         offset *= smp_processor_id();
-        ts->sched_timer.expires = ktime_add_ns(ts->sched_timer.expires, offset);
+        hrtimer_add_expires_ns(&ts->sched_timer, offset);
 
         for (;;) {
                 hrtimer_forward(&ts->sched_timer, now, tick_period);
-                hrtimer_start(&ts->sched_timer, ts->sched_timer.expires,
-                              HRTIMER_MODE_ABS);
+                hrtimer_start_expires(&ts->sched_timer, HRTIMER_MODE_ABS);
                 /* Check, if the timer was already in the past */
                 if (hrtimer_active(&ts->sched_timer))
                         break;