tick: Nohz: Rework next timer evaluation

The evaluation of the next timer in the nohz code is based on jiffies
while all the tick internals are nano seconds based. We have also to
convert hrtimer nanoseconds to jiffies in the !highres case. That's
just wrong and introduces interesting corner cases.

Turn it around and convert the next timer wheel timer expiry and the
rcu event to clock monotonic and base all calculations on
nanoseconds. That identifies the case where no timer is pending
clearly with an absolute expiry value of KTIME_MAX.

Makes the code more readable and gets rid of the jiffies magic in the
nohz code.

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Reviewed-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Acked-by: Peter Zijlstra <peterz@infradead.org>
Cc: Preeti U Murthy <preeti@linux.vnet.ibm.com>
Cc: Viresh Kumar <viresh.kumar@linaro.org>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Josh Triplett <josh@joshtriplett.org>
Cc: Lai Jiangshan <laijs@cn.fujitsu.com>
Cc: John Stultz <john.stultz@linaro.org>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Link: http://lkml.kernel.org/r/20150414203502.184198593@linutronix.de
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>

1 files changed, 34 insertions, 37 deletions

diff --git a/kernel/time/timer.c b/kernel/time/timer.c
index b31f13f4fe41..172b83cd2f8e 100644
--- a/kernel/time/timer.c
+++ b/kernel/time/timer.c
@@ -49,6 +49,8 @@
 #include <asm/timex.h>
 #include <asm/io.h>
 
+#include "tick-internal.h"
+
 #define CREATE_TRACE_POINTS
 #include <trace/events/timer.h>
 
@@ -1311,54 +1313,48 @@ cascade:
  * Check, if the next hrtimer event is before the next timer wheel
  * event:
  */
-static unsigned long cmp_next_hrtimer_event(unsigned long now,
-                                            unsigned long expires)
+static u64 cmp_next_hrtimer_event(u64 basem, u64 expires)
 {
-        ktime_t hr_delta = hrtimer_get_next_event();
-        struct timespec tsdelta;
-        unsigned long delta;
-
-        if (hr_delta.tv64 == KTIME_MAX)
-                return expires;
+        u64 nextevt = hrtimer_get_next_event();
 
         /*
-         * Expired timer available, let it expire in the next tick
+         * If high resolution timers are enabled
+         * hrtimer_get_next_event() returns KTIME_MAX.
          */
-        if (hr_delta.tv64 <= 0)
-                return now + 1;
-
-        tsdelta = ktime_to_timespec(hr_delta);
-        delta = timespec_to_jiffies(&tsdelta);
+        if (expires <= nextevt)
+                return expires;
 
         /*
-         * Limit the delta to the max value, which is checked in
-         * tick_nohz_stop_sched_tick():
+         * If the next timer is already expired, return the tick base
+         * time so the tick is fired immediately.
          */
-        if (delta > NEXT_TIMER_MAX_DELTA)
-                delta = NEXT_TIMER_MAX_DELTA;
+        if (nextevt <= basem)
+                return basem;
 
         /*
-         * Take rounding errors in to account and make sure, that it
-         * expires in the next tick. Otherwise we go into an endless
-         * ping pong due to tick_nohz_stop_sched_tick() retriggering
-         * the timer softirq
+         * Round up to the next jiffie. High resolution timers are
+         * off, so the hrtimers are expired in the tick and we need to
+         * make sure that this tick really expires the timer to avoid
+         * a ping pong of the nohz stop code.
+         *
+         * Use DIV_ROUND_UP_ULL to prevent gcc calling __divdi3
          */
-        if (delta < 1)
-                delta = 1;
-        now += delta;
-        if (time_before(now, expires))
-                return now;
-        return expires;
+        return DIV_ROUND_UP_ULL(nextevt, TICK_NSEC) * TICK_NSEC;
 }
 
 /**
- * get_next_timer_interrupt - return the jiffy of the next pending timer
- * @now: current time (in jiffies)
+ * get_next_timer_interrupt - return the time (clock mono) of the next timer
+ * @basej:      base time jiffies
+ * @basem:      base time clock monotonic
+ *
+ * Returns the tick aligned clock monotonic time of the next pending
+ * timer or KTIME_MAX if no timer is pending.
  */
-unsigned long get_next_timer_interrupt(unsigned long now)
+u64 get_next_timer_interrupt(unsigned long basej, u64 basem)
 {
         struct tvec_base *base = __this_cpu_read(tvec_bases);
-        unsigned long expires = now + NEXT_TIMER_MAX_DELTA;
+        u64 expires = KTIME_MAX;
+        unsigned long nextevt;
 
         /*
          * Pretend that there is no timer pending if the cpu is offline.
@@ -1371,14 +1367,15 @@ unsigned long get_next_timer_interrupt(unsigned long now)
         if (base->active_timers) {
                 if (time_before_eq(base->next_timer, base->timer_jiffies))
                         base->next_timer = __next_timer_interrupt(base);
-                expires = base->next_timer;
+                nextevt = base->next_timer;
+                if (time_before_eq(nextevt, basej))
+                        expires = basem;
+                else
+                        expires = basem + (nextevt - basej) * TICK_NSEC;
         }
         spin_unlock(&base->lock);
 
-        if (time_before_eq(expires, now))
-                return now;
-
-        return cmp_next_hrtimer_event(now, expires);
+        return cmp_next_hrtimer_event(basem, expires);
 }
 #endif