Commit eaad084b authored by Thomas Gleixner's avatar Thomas Gleixner Committed by Linus Torvalds
Browse files

NOHZ: prevent multiplication overflow - stop timer for huge timeouts 



get_next_timer_interrupt() returns a delta of (LONG_MAX > 1) in case
there is no timer pending. On 64 bit machines this results in a
multiplication overflow in tick_nohz_stop_sched_tick().

Reported by: Dave Miller <davem@davemloft.net>

Make the return value a constant and limit the return value to a 32 bit
value.

When the max timeout value is returned, we can safely stop the tick
timer device. The max jiffies delta results in a 12 days timeout for
HZ=1000.

In the long term the get_next_timer_interrupt() code needs to be
reworked to return ktime instead of jiffies, but we have to wait until
the last users of the original NO_IDLE_HZ code are converted.

Signed-off-by: default avatarThomas Gleixner <tglx@linutronix.de>
Acked-off-by: default avatarDavid S. Miller <davem@davemloft.net>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 6e98ee75

include/linux/timer.h

+6 −0
Original line number Diff line number Diff line
@@ -68,6 +68,12 @@ extern int del_timer(struct timer_list * timer); 
extern int __mod_timer(struct timer_list *timer, unsigned long expires);

extern int mod_timer(struct timer_list *timer, unsigned long expires);



/*

 * The jiffies value which is added to now, when there is no timer

 * in the timer wheel:

 */

#define NEXT_TIMER_MAX_DELTA	((1UL << 30) - 1)



/*

 * Return when the next timer-wheel timeout occurs (in absolute jiffies),

 * locks the timer base:

kernel/time/tick-sched.c

+15 −1
Original line number Diff line number Diff line
@@ -247,6 +247,21 @@ void tick_nohz_stop_sched_tick(void) 
		if (cpu == tick_do_timer_cpu)

			tick_do_timer_cpu = -1;



		ts->idle_sleeps++;



		/*

		 * delta_jiffies >= NEXT_TIMER_MAX_DELTA signals that

		 * there is no timer pending or at least extremly far

		 * into the future (12 days for HZ=1000). In this case

		 * we simply stop the tick timer:

		 */

		if (unlikely(delta_jiffies >= NEXT_TIMER_MAX_DELTA)) {

			ts->idle_expires.tv64 = KTIME_MAX;

			if (ts->nohz_mode == NOHZ_MODE_HIGHRES)

				hrtimer_cancel(&ts->sched_timer);

			goto out;

		}



		/*

		 * calculate the expiry time for the next timer wheel

		 * timer
@@ -254,7 +269,6 @@ void tick_nohz_stop_sched_tick(void) 
		expires = ktime_add_ns(last_update, tick_period.tv64 *

				       delta_jiffies);

		ts->idle_expires = expires;

		ts->idle_sleeps++;



		if (ts->nohz_mode == NOHZ_MODE_HIGHRES) {

			hrtimer_start(&ts->sched_timer, expires,

kernel/timer.c

+9 −1
Original line number Diff line number Diff line
@@ -666,7 +666,7 @@ static inline void __run_timers(tvec_base_t *base) 
static unsigned long __next_timer_interrupt(tvec_base_t *base)

{

	unsigned long timer_jiffies = base->timer_jiffies;

	unsigned long expires = timer_jiffies + (LONG_MAX >> 1);

	unsigned long expires = timer_jiffies + NEXT_TIMER_MAX_DELTA;

	int index, slot, array, found = 0;

	struct timer_list *nte;

	tvec_t *varray[4];
@@ -752,6 +752,14 @@ static unsigned long cmp_next_hrtimer_event(unsigned long now, 


	tsdelta = ktime_to_timespec(hr_delta);

	delta = timespec_to_jiffies(&tsdelta);



	/*

	 * Limit the delta to the max value, which is checked in

	 * tick_nohz_stop_sched_tick():

	 */

	if (delta > NEXT_TIMER_MAX_DELTA)

		delta = NEXT_TIMER_MAX_DELTA;



	/*

	 * Take rounding errors in to account and make sure, that it

	 * expires in the next tick. Otherwise we go into an endless

CRA Git | Maintained and supported by SUSTech CRA and CCSE