7  *  No idle tick implementation for low and high resolution timers
32 #include "tick-internal.h"
224 	 * When we are idle and the tick is stopped, we have to touch  in tick_sched_handle()
236 		 * In case the current tick fired too early past its expected  in tick_sched_handle()
311 	/* Empty, the tick restart happens on tick_nohz_irq_exit() */  in nohz_full_kick_func()
319  * re-evaluate its dependency on the tick and restart it if necessary.
333  * re-evaluate its dependency on the tick and restart it if necessary.
364 	 * we guarantee it sees the new tick dependency upon  in tick_nohz_kick_task()
385  * their dependency on the tick and restart it if necessary.
411  * Set a global tick dependency. Used by perf events that rely on freq and
425  * Set per-CPU tick dependency. Used by scheduler and perf events in order to
460  * Set a per-task tick dependency. RCU need this. Also posix CPU timers
477  * Set a per-taskgroup tick dependency. Posix CPU timers need this in order to elapse
502  * Re-evaluate the need for the tick as we switch the current task.
503  * It might need the tick due to per task/process properties:
550 	 * Full dynticks uses irq work to drive the tick rescheduling on safe  in tick_nohz_init()
552 	 * interrupts to avoid circular dependency on the tick  in tick_nohz_init()
585  * NOHZ - aka dynamic tick functionality
774 	 * Reset to make sure next tick stop doesn't get fooled by past  in tick_nohz_restart()
801 	 * Keep the periodic tick, when RCU, architecture or irq_work  in tick_nohz_next_event()
826 	 * If the tick is due in the next period, keep it ticking or  in tick_nohz_next_event()
837 		 * We've not stopped the tick yet, and there's a timer in the  in tick_nohz_next_event()
873 	ktime_t tick = expires;  in tick_nohz_stop_tick()  local
881 	 * the tick timer next, which might be this CPU as well. If we  in tick_nohz_stop_tick()
896 		if (tick == KTIME_MAX || ts->next_tick == hrtimer_get_expires(&ts->sched_timer))  in tick_nohz_stop_tick()
909 	 * first call we save the current tick time, so we can restart  in tick_nohz_stop_tick()
910 	 * the scheduler tick in nohz_restart_sched_tick.  in tick_nohz_stop_tick()
921 	ts->next_tick = tick;  in tick_nohz_stop_tick()
925 	 * the tick timer.  in tick_nohz_stop_tick()
936 		hrtimer_start(&ts->sched_timer, tick,  in tick_nohz_stop_tick()
939 		hrtimer_set_expires(&ts->sched_timer, tick);  in tick_nohz_stop_tick()
940 		tick_program_event(tick, 1);  in tick_nohz_stop_tick()
973 	 * Cancel the scheduled timer and restore the tick  in tick_nohz_restart_sched_tick()
1035 	pr_warn("NOHZ tick-stop error: local softirq work is pending, handler #%02x!!!\n",  in report_idle_softirq()
1047 	 * the CPU which runs the tick timer next. If we don't drop  in can_stop_idle_tick()
1055 		 * Make sure the CPU doesn't get fooled by obsolete tick  in can_stop_idle_tick()
1073 		 * Keep the tick alive to guarantee timekeeping progression  in can_stop_idle_tick()
1094 	 * tick timer expiration time is known already.  in __tick_nohz_idle_stop_tick()
1123  * tick_nohz_idle_stop_tick - stop the idle tick from the idle task
1125  * When the next event is more than a tick into the future, stop the idle tick
1166  * tick_nohz_irq_exit - update next tick event from interrupt exit
1171  * So we need to re-calculate and reprogram the next tick event.
1184  * tick_nohz_idle_got_tick - Check whether or not the tick handler has run
1199  * or the tick, whatever that expires first. Note that, if the tick has been
1211  * @delta_next: duration until the next event if the tick cannot be stopped
1287 	 * We stopped the tick in idle. Update process times would miss the  in tick_nohz_account_idle_time()
1288 	 * time we slept as update_process_times does only a 1 tick  in tick_nohz_account_idle_time()
1321  * tick_nohz_idle_exit - restart the idle tick from the idle task
1323  * Restart the idle tick when the CPU is woken up from idle
1504  * tick_setup_sched_timer - setup the tick emulation timer
1512 	 * Emulate tick processing via per-CPU hrtimers:  in tick_setup_sched_timer()
1520 	/* Offset the tick to avert jiffies_lock contention. */  in tick_setup_sched_timer()