Clockevent device can now be stopped by switching to ONESHOT_STOPPED state, to avoid getting spurious interrupts on a tickless CPU.
Switch state to ONESHOT_STOPPED at following places:
1.) NOHZ_MODE_LOWRES Mode
Timers & hrtimers are dependent on tick for their working in this mode and the only place from where clockevent device is programmed is the tick-code.
In LOWRES mode we skip reprogramming the clockevent device in tick_nohz_stop_sched_tick() if expires == KTIME_MAX. In addition to that we must also switch the clockevent device to ONESHOT_STOPPED state to avoid all spurious interrupts that may follow.
2.) NOHZ_MODE_HIGHRES Mode
Tick & timers are dependent on hrtimers for their working in this mode and the only place from where clockevent device is programmed is the hrtimer-code.
There are two places here from which we reprogram the clockevent device or skip reprogramming it on expires == KTIME_MAX.
Signed-off-by: Viresh Kumar viresh.kumar@linaro.org --- kernel/time/hrtimer.c | 46 ++++++++++++++++++++++++++++++++++++++++++---- kernel/time/tick-sched.c | 3 +++ 2 files changed, 45 insertions(+), 4 deletions(-)
diff --git a/kernel/time/hrtimer.c b/kernel/time/hrtimer.c index 045ba7e2be6c..89d4b593dfc0 100644 --- a/kernel/time/hrtimer.c +++ b/kernel/time/hrtimer.c @@ -543,8 +543,19 @@ hrtimer_force_reprogram(struct hrtimer_cpu_base *cpu_base, int skip_equal) if (cpu_base->hang_detected) return;
- if (cpu_base->expires_next.tv64 != KTIME_MAX) + if (cpu_base->expires_next.tv64 != KTIME_MAX) { tick_program_event(cpu_base->expires_next, 1); + } else { + struct clock_event_device *dev = + __this_cpu_read(tick_cpu_device.evtdev); + /* + * Don't need clockevent device anymore, stop it. + * + * We reach here only for NOHZ_MODE_HIGHRES mode and we are + * guaranteed that no timers/hrtimers are enqueued on this cpu. + */ + clockevents_set_state(dev, CLOCK_EVT_STATE_ONESHOT_STOPPED); + } }
/* @@ -1312,9 +1323,36 @@ void hrtimer_interrupt(struct clock_event_device *dev) cpu_base->in_hrtirq = 0; raw_spin_unlock(&cpu_base->lock);
- /* Reprogramming necessary ? */ - if (expires_next.tv64 == KTIME_MAX || - !tick_program_event(expires_next, 0)) { + if (expires_next.tv64 == KTIME_MAX) { + struct clock_event_device *dev = + __this_cpu_read(tick_cpu_device.evtdev); + + cpu_base->hang_detected = 0; + + /* + * Don't need clockevent device anymore, stop it. + * + * We reach here only for NOHZ_MODE_HIGHRES mode and we are + * guaranteed that no timers/hrtimers are enqueued on this cpu. + * + * Most of the scenarios will be covered by similar code + * present in hrtimer_force_reprogram(), as we always try to + * evaluate tick requirement on idle/irq exit and cancel + * tick-sched hrtimer when tick isn't required anymore. + * + * It is required here as well as a special case. + * + * Last hrtimer fires on a tickless CPU and doesn't rearm + * itself. tick_nohz_irq_exit() reevaluates next event and it + * gets expires == KTIME_MAX. Because tick was already stopped, + * and last expires == new_expires, we return early. And the + * clockevent device is never stopped. + */ + clockevents_set_state(dev, CLOCK_EVT_STATE_ONESHOT_STOPPED); + return; + } + + if (!tick_program_event(expires_next, 0)) { cpu_base->hang_detected = 0; return; } diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c index 47c04edd07df..ff271a26fa4d 100644 --- a/kernel/time/tick-sched.c +++ b/kernel/time/tick-sched.c @@ -685,6 +685,9 @@ static ktime_t tick_nohz_stop_sched_tick(struct tick_sched *ts, if (unlikely(expires.tv64 == KTIME_MAX)) { if (ts->nohz_mode == NOHZ_MODE_HIGHRES) hrtimer_cancel(&ts->sched_timer); + else + /* stop clock event device */ + clockevents_set_state(dev, CLOCK_EVT_STATE_ONESHOT_STOPPED); goto out; }