~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/linux/tick.h

Version: ~ [ linux-5.13-rc5 ] ~ [ linux-5.12.9 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.42 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.124 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.193 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.235 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.271 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.271 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /* SPDX-License-Identifier: GPL-2.0 */
  2 /*
  3  * Tick related global functions
  4  */
  5 #ifndef _LINUX_TICK_H
  6 #define _LINUX_TICK_H
  7 
  8 #include <linux/clockchips.h>
  9 #include <linux/irqflags.h>
 10 #include <linux/percpu.h>
 11 #include <linux/context_tracking_state.h>
 12 #include <linux/cpumask.h>
 13 #include <linux/sched.h>
 14 
 15 #ifdef CONFIG_GENERIC_CLOCKEVENTS
 16 extern void __init tick_init(void);
 17 /* Should be core only, but ARM BL switcher requires it */
 18 extern void tick_suspend_local(void);
 19 /* Should be core only, but XEN resume magic and ARM BL switcher require it */
 20 extern void tick_resume_local(void);
 21 extern void tick_handover_do_timer(void);
 22 extern void tick_cleanup_dead_cpu(int cpu);
 23 #else /* CONFIG_GENERIC_CLOCKEVENTS */
 24 static inline void tick_init(void) { }
 25 static inline void tick_suspend_local(void) { }
 26 static inline void tick_resume_local(void) { }
 27 static inline void tick_handover_do_timer(void) { }
 28 static inline void tick_cleanup_dead_cpu(int cpu) { }
 29 #endif /* !CONFIG_GENERIC_CLOCKEVENTS */
 30 
 31 #if defined(CONFIG_GENERIC_CLOCKEVENTS) && defined(CONFIG_SUSPEND)
 32 extern void tick_freeze(void);
 33 extern void tick_unfreeze(void);
 34 #else
 35 static inline void tick_freeze(void) { }
 36 static inline void tick_unfreeze(void) { }
 37 #endif
 38 
 39 #ifdef CONFIG_TICK_ONESHOT
 40 extern void tick_irq_enter(void);
 41 #  ifndef arch_needs_cpu
 42 #   define arch_needs_cpu() (0)
 43 #  endif
 44 # else
 45 static inline void tick_irq_enter(void) { }
 46 #endif
 47 
 48 #if defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST) && defined(CONFIG_TICK_ONESHOT)
 49 extern void hotplug_cpu__broadcast_tick_pull(int dead_cpu);
 50 #else
 51 static inline void hotplug_cpu__broadcast_tick_pull(int dead_cpu) { }
 52 #endif
 53 
 54 enum tick_broadcast_mode {
 55         TICK_BROADCAST_OFF,
 56         TICK_BROADCAST_ON,
 57         TICK_BROADCAST_FORCE,
 58 };
 59 
 60 enum tick_broadcast_state {
 61         TICK_BROADCAST_EXIT,
 62         TICK_BROADCAST_ENTER,
 63 };
 64 
 65 #ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
 66 extern void tick_broadcast_control(enum tick_broadcast_mode mode);
 67 #else
 68 static inline void tick_broadcast_control(enum tick_broadcast_mode mode) { }
 69 #endif /* BROADCAST */
 70 
 71 #if defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST) && defined(CONFIG_HOTPLUG_CPU)
 72 extern void tick_offline_cpu(unsigned int cpu);
 73 #else
 74 static inline void tick_offline_cpu(unsigned int cpu) { }
 75 #endif
 76 
 77 #ifdef CONFIG_GENERIC_CLOCKEVENTS
 78 extern int tick_broadcast_oneshot_control(enum tick_broadcast_state state);
 79 #else
 80 static inline int tick_broadcast_oneshot_control(enum tick_broadcast_state state)
 81 {
 82         return 0;
 83 }
 84 #endif
 85 
 86 static inline void tick_broadcast_enable(void)
 87 {
 88         tick_broadcast_control(TICK_BROADCAST_ON);
 89 }
 90 static inline void tick_broadcast_disable(void)
 91 {
 92         tick_broadcast_control(TICK_BROADCAST_OFF);
 93 }
 94 static inline void tick_broadcast_force(void)
 95 {
 96         tick_broadcast_control(TICK_BROADCAST_FORCE);
 97 }
 98 static inline int tick_broadcast_enter(void)
 99 {
100         return tick_broadcast_oneshot_control(TICK_BROADCAST_ENTER);
101 }
102 static inline void tick_broadcast_exit(void)
103 {
104         tick_broadcast_oneshot_control(TICK_BROADCAST_EXIT);
105 }
106 
107 enum tick_dep_bits {
108         TICK_DEP_BIT_POSIX_TIMER        = 0,
109         TICK_DEP_BIT_PERF_EVENTS        = 1,
110         TICK_DEP_BIT_SCHED              = 2,
111         TICK_DEP_BIT_CLOCK_UNSTABLE     = 3,
112         TICK_DEP_BIT_RCU                = 4,
113         TICK_DEP_BIT_RCU_EXP            = 5
114 };
115 #define TICK_DEP_BIT_MAX TICK_DEP_BIT_RCU_EXP
116 
117 #define TICK_DEP_MASK_NONE              0
118 #define TICK_DEP_MASK_POSIX_TIMER       (1 << TICK_DEP_BIT_POSIX_TIMER)
119 #define TICK_DEP_MASK_PERF_EVENTS       (1 << TICK_DEP_BIT_PERF_EVENTS)
120 #define TICK_DEP_MASK_SCHED             (1 << TICK_DEP_BIT_SCHED)
121 #define TICK_DEP_MASK_CLOCK_UNSTABLE    (1 << TICK_DEP_BIT_CLOCK_UNSTABLE)
122 #define TICK_DEP_MASK_RCU               (1 << TICK_DEP_BIT_RCU)
123 #define TICK_DEP_MASK_RCU_EXP           (1 << TICK_DEP_BIT_RCU_EXP)
124 
125 #ifdef CONFIG_NO_HZ_COMMON
126 extern bool tick_nohz_enabled;
127 extern bool tick_nohz_tick_stopped(void);
128 extern bool tick_nohz_tick_stopped_cpu(int cpu);
129 extern void tick_nohz_idle_stop_tick(void);
130 extern void tick_nohz_idle_retain_tick(void);
131 extern void tick_nohz_idle_restart_tick(void);
132 extern void tick_nohz_idle_enter(void);
133 extern void tick_nohz_idle_exit(void);
134 extern void tick_nohz_irq_exit(void);
135 extern bool tick_nohz_idle_got_tick(void);
136 extern ktime_t tick_nohz_get_next_hrtimer(void);
137 extern ktime_t tick_nohz_get_sleep_length(ktime_t *delta_next);
138 extern unsigned long tick_nohz_get_idle_calls(void);
139 extern unsigned long tick_nohz_get_idle_calls_cpu(int cpu);
140 extern u64 get_cpu_idle_time_us(int cpu, u64 *last_update_time);
141 extern u64 get_cpu_iowait_time_us(int cpu, u64 *last_update_time);
142 
143 static inline void tick_nohz_idle_stop_tick_protected(void)
144 {
145         local_irq_disable();
146         tick_nohz_idle_stop_tick();
147         local_irq_enable();
148 }
149 
150 #else /* !CONFIG_NO_HZ_COMMON */
151 #define tick_nohz_enabled (0)
152 static inline int tick_nohz_tick_stopped(void) { return 0; }
153 static inline int tick_nohz_tick_stopped_cpu(int cpu) { return 0; }
154 static inline void tick_nohz_idle_stop_tick(void) { }
155 static inline void tick_nohz_idle_retain_tick(void) { }
156 static inline void tick_nohz_idle_restart_tick(void) { }
157 static inline void tick_nohz_idle_enter(void) { }
158 static inline void tick_nohz_idle_exit(void) { }
159 static inline bool tick_nohz_idle_got_tick(void) { return false; }
160 static inline ktime_t tick_nohz_get_next_hrtimer(void)
161 {
162         /* Next wake up is the tick period, assume it starts now */
163         return ktime_add(ktime_get(), TICK_NSEC);
164 }
165 static inline ktime_t tick_nohz_get_sleep_length(ktime_t *delta_next)
166 {
167         *delta_next = TICK_NSEC;
168         return *delta_next;
169 }
170 static inline u64 get_cpu_idle_time_us(int cpu, u64 *unused) { return -1; }
171 static inline u64 get_cpu_iowait_time_us(int cpu, u64 *unused) { return -1; }
172 
173 static inline void tick_nohz_idle_stop_tick_protected(void) { }
174 #endif /* !CONFIG_NO_HZ_COMMON */
175 
176 #ifdef CONFIG_NO_HZ_FULL
177 extern bool tick_nohz_full_running;
178 extern cpumask_var_t tick_nohz_full_mask;
179 
180 static inline bool tick_nohz_full_enabled(void)
181 {
182         if (!context_tracking_enabled())
183                 return false;
184 
185         return tick_nohz_full_running;
186 }
187 
188 static inline bool tick_nohz_full_cpu(int cpu)
189 {
190         if (!tick_nohz_full_enabled())
191                 return false;
192 
193         return cpumask_test_cpu(cpu, tick_nohz_full_mask);
194 }
195 
196 static inline void tick_nohz_full_add_cpus_to(struct cpumask *mask)
197 {
198         if (tick_nohz_full_enabled())
199                 cpumask_or(mask, mask, tick_nohz_full_mask);
200 }
201 
202 extern void tick_nohz_dep_set(enum tick_dep_bits bit);
203 extern void tick_nohz_dep_clear(enum tick_dep_bits bit);
204 extern void tick_nohz_dep_set_cpu(int cpu, enum tick_dep_bits bit);
205 extern void tick_nohz_dep_clear_cpu(int cpu, enum tick_dep_bits bit);
206 extern void tick_nohz_dep_set_task(struct task_struct *tsk,
207                                    enum tick_dep_bits bit);
208 extern void tick_nohz_dep_clear_task(struct task_struct *tsk,
209                                      enum tick_dep_bits bit);
210 extern void tick_nohz_dep_set_signal(struct signal_struct *signal,
211                                      enum tick_dep_bits bit);
212 extern void tick_nohz_dep_clear_signal(struct signal_struct *signal,
213                                        enum tick_dep_bits bit);
214 
215 /*
216  * The below are tick_nohz_[set,clear]_dep() wrappers that optimize off-cases
217  * on top of static keys.
218  */
219 static inline void tick_dep_set(enum tick_dep_bits bit)
220 {
221         if (tick_nohz_full_enabled())
222                 tick_nohz_dep_set(bit);
223 }
224 
225 static inline void tick_dep_clear(enum tick_dep_bits bit)
226 {
227         if (tick_nohz_full_enabled())
228                 tick_nohz_dep_clear(bit);
229 }
230 
231 static inline void tick_dep_set_cpu(int cpu, enum tick_dep_bits bit)
232 {
233         if (tick_nohz_full_cpu(cpu))
234                 tick_nohz_dep_set_cpu(cpu, bit);
235 }
236 
237 static inline void tick_dep_clear_cpu(int cpu, enum tick_dep_bits bit)
238 {
239         if (tick_nohz_full_cpu(cpu))
240                 tick_nohz_dep_clear_cpu(cpu, bit);
241 }
242 
243 static inline void tick_dep_set_task(struct task_struct *tsk,
244                                      enum tick_dep_bits bit)
245 {
246         if (tick_nohz_full_enabled())
247                 tick_nohz_dep_set_task(tsk, bit);
248 }
249 static inline void tick_dep_clear_task(struct task_struct *tsk,
250                                        enum tick_dep_bits bit)
251 {
252         if (tick_nohz_full_enabled())
253                 tick_nohz_dep_clear_task(tsk, bit);
254 }
255 static inline void tick_dep_set_signal(struct signal_struct *signal,
256                                        enum tick_dep_bits bit)
257 {
258         if (tick_nohz_full_enabled())
259                 tick_nohz_dep_set_signal(signal, bit);
260 }
261 static inline void tick_dep_clear_signal(struct signal_struct *signal,
262                                          enum tick_dep_bits bit)
263 {
264         if (tick_nohz_full_enabled())
265                 tick_nohz_dep_clear_signal(signal, bit);
266 }
267 
268 extern void tick_nohz_full_kick_cpu(int cpu);
269 extern void __tick_nohz_task_switch(void);
270 extern void __init tick_nohz_full_setup(cpumask_var_t cpumask);
271 #else
272 static inline bool tick_nohz_full_enabled(void) { return false; }
273 static inline bool tick_nohz_full_cpu(int cpu) { return false; }
274 static inline void tick_nohz_full_add_cpus_to(struct cpumask *mask) { }
275 
276 static inline void tick_nohz_dep_set_cpu(int cpu, enum tick_dep_bits bit) { }
277 static inline void tick_nohz_dep_clear_cpu(int cpu, enum tick_dep_bits bit) { }
278 
279 static inline void tick_dep_set(enum tick_dep_bits bit) { }
280 static inline void tick_dep_clear(enum tick_dep_bits bit) { }
281 static inline void tick_dep_set_cpu(int cpu, enum tick_dep_bits bit) { }
282 static inline void tick_dep_clear_cpu(int cpu, enum tick_dep_bits bit) { }
283 static inline void tick_dep_set_task(struct task_struct *tsk,
284                                      enum tick_dep_bits bit) { }
285 static inline void tick_dep_clear_task(struct task_struct *tsk,
286                                        enum tick_dep_bits bit) { }
287 static inline void tick_dep_set_signal(struct signal_struct *signal,
288                                        enum tick_dep_bits bit) { }
289 static inline void tick_dep_clear_signal(struct signal_struct *signal,
290                                          enum tick_dep_bits bit) { }
291 
292 static inline void tick_nohz_full_kick_cpu(int cpu) { }
293 static inline void __tick_nohz_task_switch(void) { }
294 static inline void tick_nohz_full_setup(cpumask_var_t cpumask) { }
295 #endif
296 
297 static inline void tick_nohz_task_switch(void)
298 {
299         if (tick_nohz_full_enabled())
300                 __tick_nohz_task_switch();
301 }
302 
303 #endif
304 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp