Merge branch 'timers-nohz-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip (59b60185) · Commits · 戴 / test

kernel/time/tick-sched.c

+40 −23

Original line number	Diff line number	Diff line
		@@ -150,6 +150,12 @@ static void tick_sched_handle(struct tick_sched ts, struct pt_regs regs)
		touch_softlockup_watchdog_sched();
		if (is_idle_task(current))
		ts->idle_jiffies++;
		/*
		* In case the current tick fired too early past its expected
		* expiration, make sure we don't bypass the next clock reprogramming
		* to the same deadline.
		*/
		ts->next_tick = 0;
		}
		#endif
		update_process_times(user_mode(regs));
		@@ -660,6 +666,12 @@ static void tick_nohz_restart(struct tick_sched *ts, ktime_t now)
		hrtimer_start_expires(&ts->sched_timer, HRTIMER_MODE_ABS_PINNED);
		else
		tick_program_event(hrtimer_get_expires(&ts->sched_timer), 1);

		/*
		* Reset to make sure next tick stop doesn't get fooled by past
		* cached clock deadline.
		*/
		ts->next_tick = 0;
		}

		static ktime_t tick_nohz_stop_sched_tick(struct tick_sched *ts,
		@@ -701,8 +713,6 @@ static ktime_t tick_nohz_stop_sched_tick(struct tick_sched *ts,
		*/
		delta = next_tick - basemono;
		if (delta <= (u64)TICK_NSEC) {
		tick = 0;

		/*
		* Tell the timer code that the base is not idle, i.e. undo
		* the effect of get_next_timer_interrupt():
		@@ -712,23 +722,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 = 0;
		goto out;
		}
		}
		@@ -771,9 +766,17 @@ static ktime_t tick_nohz_stop_sched_tick(struct tick_sched *ts,
		tick = expires;

		/* Skip reprogram of event if its not changed */
		if (ts->tick_stopped && (expires == dev->next_event))
		if (ts->tick_stopped && (expires == ts->next_tick)) {
		/* Sanity check: make sure clockevent is actually programmed */
		if (tick == KTIME_MAX \|\| ts->next_tick == hrtimer_get_expires(&ts->sched_timer))
		goto out;

		WARN_ON_ONCE(1);
		printk_once("basemono: %llu ts->next_tick: %llu dev->next_event: %llu timer->active: %d timer->expires: %llu\n",
		basemono, ts->next_tick, dev->next_event,
		hrtimer_active(&ts->sched_timer), hrtimer_get_expires(&ts->sched_timer));
		}

		/*
		* nohz_stop_sched_tick can be called several times before
		* the nohz_restart_sched_tick is called. This happens when
		@@ -790,6 +793,8 @@ static ktime_t tick_nohz_stop_sched_tick(struct tick_sched *ts,
		trace_tick_stop(1, TICK_DEP_MASK_NONE);
		}

		ts->next_tick = tick;

		/*
		* If the expiration time == KTIME_MAX, then we simply stop
		* the tick timer.
		@@ -800,12 +805,17 @@ static ktime_t tick_nohz_stop_sched_tick(struct tick_sched *ts,
		goto out;
		}

		hrtimer_set_expires(&ts->sched_timer, tick);

		if (ts->nohz_mode == NOHZ_MODE_HIGHRES)
		hrtimer_start(&ts->sched_timer, tick, HRTIMER_MODE_ABS_PINNED);
		hrtimer_start_expires(&ts->sched_timer, HRTIMER_MODE_ABS_PINNED);
		else
		tick_program_event(tick, 1);
		out:
		/* Update the estimated sleep length */
		/*
		* Update the estimated sleep length until the next timer
		* (not only the tick).
		*/
		ts->sleep_length = ktime_sub(dev->next_event, now);
		return tick;
		}
		@@ -863,6 +873,11 @@ static bool can_stop_idle_tick(int cpu, struct tick_sched *ts)
		if (unlikely(!cpu_online(cpu))) {
		if (cpu == tick_do_timer_cpu)
		tick_do_timer_cpu = TICK_DO_TIMER_NONE;
		/*
		* Make sure the CPU doesn't get fooled by obsolete tick
		* deadline if it comes back online later.
		*/
		ts->next_tick = 0;
		return false;
		}

		@@ -1173,6 +1188,8 @@ static enum hrtimer_restart tick_sched_timer(struct hrtimer *timer)
		*/
		if (regs)
		tick_sched_handle(ts, regs);
		else
		ts->next_tick = 0;

		/* No need to reprogram if we are in idle or full dynticks mode */
		if (unlikely(ts->tick_stopped))

kernel/time/tick-sched.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -27,6 +27,7 @@ enum tick_nohz_mode {
		* timer is modified for nohz sleeps. This is necessary
		* to resume the tick timer operation in the timeline
		* when the CPU returns from nohz sleep.
		* @next_tick: Next tick to be fired when in dynticks mode.
		* @tick_stopped: Indicator that the idle tick has been stopped
		* @idle_jiffies: jiffies at the entry to idle for idle time accounting
		* @idle_calls: Total number of idle calls
		@@ -44,6 +45,7 @@ struct tick_sched {
		unsigned long check_clocks;
		enum tick_nohz_mode nohz_mode;
		ktime_t last_tick;
		ktime_t next_tick;
		int inidle;
		int tick_stopped;
		unsigned long idle_jiffies;

Admin message