33 #include "tick-internal.h"
167 		 * Ensure that the tick is aligned to a multiple of  in tick_init_jiffy_update()
256 	 * When we are idle and the tick is stopped, we have to touch  in tick_sched_handle()
269 		 * In case the current tick fired too early past its expected  in tick_sched_handle()
302 	 * In dynticks mode, tick reprogram is deferred:  in tick_nohz_handler()
390 	/* Empty, the tick restart happens on tick_nohz_irq_exit() */  in nohz_full_kick_func()
398  * re-evaluate its dependency on the tick and restart it if necessary.
412  * re-evaluate its dependency on the tick and restart it if necessary.
449 	 * we guarantee it sees the new tick dependency upon  in tick_nohz_kick_task()
470  * their dependency on the tick and restart it if necessary.
496  * Set a global tick dependency. Used by perf events that rely on freq and
510  * Set per-CPU tick dependency. Used by scheduler and perf events in order to
545  * Set a per-task tick dependency. RCU needs this. Also posix CPU timers
562  * Set a per-taskgroup tick dependency. Posix CPU timers need this in order to elapse
587  * Re-evaluate the need for the tick as we switch the current task.
588  * It might need the tick due to per task/process properties:
640 	 * Full dynticks uses IRQ work to drive the tick rescheduling on safe  in tick_nohz_init()
642 	 * interrupts to avoid circular dependency on the tick.  in tick_nohz_init()
675  * NOHZ - aka dynamic tick functionality
860 	 * Reset to make sure the next tick stop doesn't get fooled by past  in tick_nohz_restart()
896  *		  and the tick is not stopped yet
910 	 * Keep the periodic tick, when RCU, architecture or irq_work  in tick_nohz_next_event()
939 	 * If the tick is due in the next period, keep it ticking or  in tick_nohz_next_event()
945 		 * We've not stopped the tick yet, and there's a timer in the  in tick_nohz_next_event()
990 	 * Now the tick should be stopped definitely - so the timer base needs  in tick_nohz_stop_tick()
1002 		 * not stop the tick for too long with a shallow C-state (which  in tick_nohz_stop_tick()
1009 	/* If the timer base is not idle, retain the not yet stopped tick. */  in tick_nohz_stop_tick()
1016 	 * the tick timer next, which might be this CPU as well. If we  in tick_nohz_stop_tick()
1045 	 * call we save the current tick time, so we can restart the  in tick_nohz_stop_tick()
1046 	 * scheduler tick in tick_nohz_restart_sched_tick().  in tick_nohz_stop_tick()
1061 	 * the tick timer.  in tick_nohz_stop_tick()
1106 	/* Cancel the scheduled timer and restore the tick: */  in tick_nohz_restart_sched_tick()
1167 	pr_warn("NOHZ tick-stop error: local softirq work is pending, handler #%02x!!!\n",  in report_idle_softirq()
1191 		 * Keep the tick alive to guarantee timekeeping progression  in can_stop_idle_tick()
1206  * tick_nohz_idle_stop_tick - stop the idle tick from the idle task
1208  * When the next event is more than a tick into the future, stop the idle tick
1218 	 * tick timer expiration time is known already.  in tick_nohz_idle_stop_tick()
1275  * tick_nohz_irq_exit - Notify the tick about IRQ exit
1280  * re-evaluation of the next tick. Depending on the context:
1283  *    time accounting. The next tick will be re-evaluated on the next idle
1288  *    2.1) If there is any tick dependency, restart the tick if stopped.
1290  *    2.2) If there is no tick dependency, (re-)evaluate the next tick and
1304  * tick_nohz_idle_got_tick - Check whether or not the tick handler has run
1306  * Return: %true if the tick handler has run, otherwise %false
1321  * or the tick, whichever expires first. Note that, if the tick has been
1335  * @delta_next: duration until the next event if the tick cannot be stopped
1404 	 * We stopped the tick in idle. update_process_times() would miss the  in tick_nohz_account_idle_time()
1405 	 * time we slept, as it does only a 1 tick accounting.  in tick_nohz_account_idle_time()
1438  * tick_nohz_idle_exit - Update the tick upon idle task exit
1440  * When the idle task exits, update the tick depending on the
1444  *    restart the tick.
1447  *   2.1) If the tick can be kept stopped (no tick dependencies)
1448  *        then re-evaluate the next tick and try to keep it stopped
1450  *   2.2) If the tick has dependencies, restart the tick.
1481  * In low-resolution mode, the tick handler must be implemented directly
1483  * infrastructure actually relies on the tick itself as a backend in
1573  * tick_setup_sched_timer - setup the tick emulation timer
1580 	/* Emulate tick processing via per-CPU hrtimers: */  in tick_setup_sched_timer()
1591 	/* Offset the tick to avert 'jiffies_lock' contention. */  in tick_setup_sched_timer()
1608  * Shut down the tick and make sure the CPU won't try to retake the timekeeping
1624 	 * make sure not to call low-res tick handler.  in tick_sched_timer_dying()