MLK-14859 nohz: Fix buggy tick delay on IRQ storms

When the tick is stopped and we reach the dynticks evaluation code on
IRQ exit, we perform a soft tick restart if we observe an expired timer
from there. It means we program the nearest possible tick but we stay in
dynticks mode (ts->tick_stopped = 1) because we may need to stop the tick
again after that expired timer is handled.

Now this solution works most of the time but if we suffer an IRQ storm
and those interrupts trigger faster than the hardware clockevents min
delay, our tick won't fire until that IRQ storm is finished.

Here is the problem: on IRQ exit we reprog the timer to at least
NOW() + min_clockevents_delay. Another IRQ fires before the tick so we
reschedule again to NOW() + min_clockevents_delay, etc... The tick
is eternally rescheduled min_clockevents_delay ahead.

A solution is to simply remove this soft tick restart. After all
the normal dynticks evaluation path can handle 0 delay just fine. And
by doing that we benefit from the optimization branch which avoids
clock reprogramming if the clockevents deadline hasn't changed since
the last reprog. This fixes our issue because we don't do repetitive
clock reprog that always add hardware min delay.

As a side effect it should even optimize the 0 delay path in general.

Reported-and-tested-by: Octavian Purdila <octavian.purdila@nxp.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Rik van Riel <riel@redhat.com>
Cc: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Frederic Weisbecker <fweisbec@gmail.com>

diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c
index dae1a45..08333d1 100644 (file)
--- a/kernel/time/tick-sched.c
+++ b/kernel/time/tick-sched.c
@@ -717,8 +717,6 @@ static ktime_t tick_nohz_stop_sched_tick(struct tick_sched *ts,
         */
        delta = next_tick - basemono;
        if (delta <= (u64)TICK_NSEC) {
-               tick.tv64 = 0;
-
                /*
                 * Tell the timer code that the base is not idle, i.e. undo
                 * the effect of get_next_timer_interrupt():
@@ -728,23 +726,8 @@ static ktime_t tick_nohz_stop_sched_tick(struct tick_sched *ts,
                 * We've not stopped the tick yet, and there's a timer in the
                 * next period, so no point in stopping it either, bail.
                 */
-               if (!ts->tick_stopped)
-                       goto out;
-
-               /*
-                * If, OTOH, we did stop it, but there's a pending (expired)
-                * timer reprogram the timer hardware to fire now.
-                *
-                * We will not restart the tick proper, just prod the timer
-                * hardware into firing an interrupt to process the pending
-                * timers. Just like tick_irq_exit() will not restart the tick
-                * for 'normal' interrupts.
-                *
-                * Only once we exit the idle loop will we re-enable the tick,
-                * see tick_nohz_idle_exit().
-                */
-               if (delta == 0) {
-                       tick_nohz_restart(ts, now);
+               if (!ts->tick_stopped) {
+                       tick.tv64 = 0;
                        goto out;
                }
        }