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

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

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

~ [ 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