7  *  No idle tick implementation for low and high resolution timers
32 #include "tick-internal.h"
168 		 * Ensure that the tick is aligned to a multiple of  in tick_init_jiffy_update()
235 	 * When we are idle and the tick is stopped, we have to touch  in tick_sched_handle()
247 		 * In case the current tick fired too early past its expected  in tick_sched_handle()
327 	/* Empty, the tick restart happens on tick_nohz_irq_exit() */  in nohz_full_kick_func()
335  * re-evaluate its dependency on the tick and restart it if necessary.
349  * re-evaluate its dependency on the tick and restart it if necessary.
380 	 * we guarantee it sees the new tick dependency upon  in tick_nohz_kick_task()
401  * their dependency on the tick and restart it if necessary.
427  * Set a global tick dependency. Used by perf events that rely on freq and
441  * Set per-CPU tick dependency. Used by scheduler and perf events in order to
476  * Set a per-task tick dependency. RCU need this. Also posix CPU timers
493  * Set a per-taskgroup tick dependency. Posix CPU timers need this in order to elapse
518  * Re-evaluate the need for the tick as we switch the current task.
519  * It might need the tick due to per task/process properties:
571 	 * Full dynticks uses irq work to drive the tick rescheduling on safe  in tick_nohz_init()
573 	 * interrupts to avoid circular dependency on the tick  in tick_nohz_init()
606  * NOHZ - aka dynamic tick functionality
790 	 * Reset to make sure next tick stop doesn't get fooled by past  in tick_nohz_restart()
817 	 * Keep the periodic tick, when RCU, architecture or irq_work  in tick_nohz_next_event()
842 	 * If the tick is due in the next period, keep it ticking or  in tick_nohz_next_event()
853 		 * We've not stopped the tick yet, and there's a timer in the  in tick_nohz_next_event()
889 	ktime_t tick = expires;  in tick_nohz_stop_tick()  local
897 	 * the tick timer next, which might be this CPU as well. If we  in tick_nohz_stop_tick()
912 		if (tick == KTIME_MAX || ts->next_tick == hrtimer_get_expires(&ts->sched_timer))  in tick_nohz_stop_tick()
925 	 * first call we save the current tick time, so we can restart  in tick_nohz_stop_tick()
926 	 * the scheduler tick in nohz_restart_sched_tick.  in tick_nohz_stop_tick()
937 	ts->next_tick = tick;  in tick_nohz_stop_tick()
941 	 * the tick timer.  in tick_nohz_stop_tick()
952 		hrtimer_start(&ts->sched_timer, tick,  in tick_nohz_stop_tick()
955 		hrtimer_set_expires(&ts->sched_timer, tick);  in tick_nohz_stop_tick()
956 		tick_program_event(tick, 1);  in tick_nohz_stop_tick()
989 	 * Cancel the scheduled timer and restore the tick  in tick_nohz_restart_sched_tick()
1051 	pr_warn("NOHZ tick-stop error: local softirq work is pending, handler #%02x!!!\n",  in report_idle_softirq()
1063 	 * the CPU which runs the tick timer next. If we don't drop  in can_stop_idle_tick()
1071 		 * Make sure the CPU doesn't get fooled by obsolete tick  in can_stop_idle_tick()
1089 		 * Keep the tick alive to guarantee timekeeping progression  in can_stop_idle_tick()
1104  * tick_nohz_idle_stop_tick - stop the idle tick from the idle task
1106  * When the next event is more than a tick into the future, stop the idle tick
1116 	 * tick timer expiration time is known already.  in tick_nohz_idle_stop_tick()
1178  * tick_nohz_irq_exit - update next tick event from interrupt exit
1183  * So we need to re-calculate and reprogram the next tick event.
1196  * tick_nohz_idle_got_tick - Check whether or not the tick handler has run
1211  * or the tick, whatever that expires first. Note that, if the tick has been
1223  * @delta_next: duration until the next event if the tick cannot be stopped
1299 	 * We stopped the tick in idle. Update process times would miss the  in tick_nohz_account_idle_time()
1300 	 * time we slept as update_process_times does only a 1 tick  in tick_nohz_account_idle_time()
1333  * tick_nohz_idle_exit - restart the idle tick from the idle task
1335  * Restart the idle tick when the CPU is woken up from idle
1516  * tick_setup_sched_timer - setup the tick emulation timer
1524 	 * Emulate tick processing via per-CPU hrtimers:  in tick_setup_sched_timer()
1532 	/* Offset the tick to avert jiffies_lock contention. */  in tick_setup_sched_timer()