32 #include "tick-internal.h"
167 		 * Ensure that the tick is aligned to a multiple of  in tick_init_jiffy_update()
236 	 * When we are idle and the tick is stopped, we have to touch  in tick_sched_handle()
248 		 * In case the current tick fired too early past its expected  in tick_sched_handle()
328 	/* Empty, the tick restart happens on tick_nohz_irq_exit() */  in nohz_full_kick_func()
336  * re-evaluate its dependency on the tick and restart it if necessary.
350  * re-evaluate its dependency on the tick and restart it if necessary.
381 	 * we guarantee it sees the new tick dependency upon  in tick_nohz_kick_task()
402  * their dependency on the tick and restart it if necessary.
428  * Set a global tick dependency. Used by perf events that rely on freq and
442  * Set per-CPU tick dependency. Used by scheduler and perf events in order to
477  * Set a per-task tick dependency. RCU needs this. Also posix CPU timers
494  * Set a per-taskgroup tick dependency. Posix CPU timers need this in order to elapse
519  * Re-evaluate the need for the tick as we switch the current task.
520  * It might need the tick due to per task/process properties:
572 	 * Full dynticks uses IRQ work to drive the tick rescheduling on safe  in tick_nohz_init()
574 	 * interrupts to avoid circular dependency on the tick.  in tick_nohz_init()
607  * NOHZ - aka dynamic tick functionality
791 	 * Reset to make sure the next tick stop doesn't get fooled by past  in tick_nohz_restart()
818 	 * Keep the periodic tick, when RCU, architecture or irq_work  in tick_nohz_next_event()
847 	 * If the tick is due in the next period, keep it ticking or  in tick_nohz_next_event()
858 		 * We've not stopped the tick yet, and there's a timer in the  in tick_nohz_next_event()
901 	 * the tick timer next, which might be this CPU as well. If we  in tick_nohz_stop_tick()
929 	 * call we save the current tick time, so we can restart the  in tick_nohz_stop_tick()
930 	 * scheduler tick in tick_nohz_restart_sched_tick().  in tick_nohz_stop_tick()
945 	 * the tick timer.  in tick_nohz_stop_tick()
993 	/* Cancel the scheduled timer and restore the tick: */  in tick_nohz_restart_sched_tick()
1054 	pr_warn("NOHZ tick-stop error: local softirq work is pending, handler #%02x!!!\n",  in report_idle_softirq()
1066 	 * the CPU which runs the tick timer next. If we don't drop  in can_stop_idle_tick()
1074 		 * Make sure the CPU doesn't get fooled by obsolete tick  in can_stop_idle_tick()
1092 		 * Keep the tick alive to guarantee timekeeping progression  in can_stop_idle_tick()
1107  * tick_nohz_idle_stop_tick - stop the idle tick from the idle task
1109  * When the next event is more than a tick into the future, stop the idle tick
1119 	 * tick timer expiration time is known already.  in tick_nohz_idle_stop_tick()
1181  * tick_nohz_irq_exit - Notify the tick about IRQ exit
1186  * re-evaluation of the next tick. Depending on the context:
1189  *    time accounting. The next tick will be re-evaluated on the next idle
1194  *    2.1) If there is any tick dependency, restart the tick if stopped.
1196  *    2.2) If there is no tick dependency, (re-)evaluate the next tick and
1210  * tick_nohz_idle_got_tick - Check whether or not the tick handler has run
1225  * or the tick, whichever expires first. Note that, if the tick has been
1237  * @delta_next: duration until the next event if the tick cannot be stopped
1313 	 * We stopped the tick in idle. update_process_times() would miss the  in tick_nohz_account_idle_time()
1314 	 * time we slept, as it does only a 1 tick accounting.  in tick_nohz_account_idle_time()
1347  * tick_nohz_idle_exit - Update the tick upon idle task exit
1349  * When the idle task exits, update the tick depending on the
1353  *    restart the tick.
1356  *   2.1) If the tick can be kept stopped (no tick dependencies)
1357  *        then re-evaluate the next tick and try to keep it stopped
1359  *   2.2) If the tick has dependencies, restart the tick.
1390  * In low-resolution mode, the tick handler must be implemented directly
1392  * infrastructure actually relies on the tick itself as a backend in
1410 	 * In dynticks mode, tick reprogram is deferred:  in tick_nohz_lowres_handler()
1524 	 * In dynticks mode, tick reprogram is deferred:  in tick_nohz_highres_handler()
1547  * tick_setup_sched_timer - setup the tick emulation timer
1554 	/* Emulate tick processing via per-CPU hrtimers: */  in tick_setup_sched_timer()
1561 	/* Offset the tick to avert 'jiffies_lock' contention. */  in tick_setup_sched_timer()