Thomas Gleixner | c1797ba | 2015-03-25 13:07:37 +0100 | [diff] [blame] | 1 | /* |
| 2 | * Tick related global functions |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 3 | */ |
| 4 | #ifndef _LINUX_TICK_H |
| 5 | #define _LINUX_TICK_H |
| 6 | |
| 7 | #include <linux/clockchips.h> |
Frederic Weisbecker | 2bbb681 | 2011-10-08 16:01:00 +0200 | [diff] [blame] | 8 | #include <linux/irqflags.h> |
Frederic Weisbecker | 33a5f62 | 2012-10-11 17:52:56 +0200 | [diff] [blame] | 9 | #include <linux/percpu.h> |
Frederic Weisbecker | 460775d | 2013-07-24 23:52:27 +0200 | [diff] [blame] | 10 | #include <linux/context_tracking_state.h> |
| 11 | #include <linux/cpumask.h> |
Paul E. McKenney | c0f489d | 2014-06-04 13:46:03 -0700 | [diff] [blame] | 12 | #include <linux/sched.h> |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 13 | |
Thomas Gleixner | c1797ba | 2015-03-25 13:07:37 +0100 | [diff] [blame] | 14 | #ifdef CONFIG_GENERIC_CLOCKEVENTS |
| 15 | extern void __init tick_init(void); |
Thomas Gleixner | 7270d11 | 2015-03-25 13:11:52 +0100 | [diff] [blame] | 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 */ |
Thomas Gleixner | f46481d | 2015-03-25 13:11:04 +0100 | [diff] [blame] | 19 | extern void tick_resume_local(void); |
Thomas Gleixner | 52c063d | 2015-04-03 02:37:24 +0200 | [diff] [blame] | 20 | extern void tick_handover_do_timer(void); |
Thomas Gleixner | a49b116 | 2015-04-03 02:38:05 +0200 | [diff] [blame] | 21 | extern void tick_cleanup_dead_cpu(int cpu); |
Thomas Gleixner | 79bf2bb | 2007-02-16 01:28:03 -0800 | [diff] [blame] | 22 | #else /* CONFIG_GENERIC_CLOCKEVENTS */ |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 23 | static inline void tick_init(void) { } |
Thomas Gleixner | 7270d11 | 2015-03-25 13:11:52 +0100 | [diff] [blame] | 24 | static inline void tick_suspend_local(void) { } |
Thomas Gleixner | f46481d | 2015-03-25 13:11:04 +0100 | [diff] [blame] | 25 | static inline void tick_resume_local(void) { } |
Thomas Gleixner | 52c063d | 2015-04-03 02:37:24 +0200 | [diff] [blame] | 26 | static inline void tick_handover_do_timer(void) { } |
Thomas Gleixner | a49b116 | 2015-04-03 02:38:05 +0200 | [diff] [blame] | 27 | static inline void tick_cleanup_dead_cpu(int cpu) { } |
Thomas Gleixner | 79bf2bb | 2007-02-16 01:28:03 -0800 | [diff] [blame] | 28 | #endif /* !CONFIG_GENERIC_CLOCKEVENTS */ |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 29 | |
Syed Rameez Mustafa | dddcab7 | 2016-09-07 16:18:27 -0700 | [diff] [blame] | 30 | extern u64 jiffy_to_ktime_ns(u64 *now, u64 *jiffy_ktime_ns); |
| 31 | |
Rafael J. Wysocki | 87e9b9f | 2015-05-16 01:38:15 +0200 | [diff] [blame] | 32 | #if defined(CONFIG_GENERIC_CLOCKEVENTS) && defined(CONFIG_SUSPEND) |
| 33 | extern void tick_freeze(void); |
| 34 | extern void tick_unfreeze(void); |
| 35 | #else |
| 36 | static inline void tick_freeze(void) { } |
| 37 | static inline void tick_unfreeze(void) { } |
| 38 | #endif |
| 39 | |
Thomas Gleixner | c1797ba | 2015-03-25 13:07:37 +0100 | [diff] [blame] | 40 | #ifdef CONFIG_TICK_ONESHOT |
| 41 | extern void tick_irq_enter(void); |
| 42 | # ifndef arch_needs_cpu |
| 43 | # define arch_needs_cpu() (0) |
| 44 | # endif |
| 45 | # else |
| 46 | static inline void tick_irq_enter(void) { } |
| 47 | #endif |
Frederic Weisbecker | 33a5f62 | 2012-10-11 17:52:56 +0200 | [diff] [blame] | 48 | |
Preeti U Murthy | 345527b | 2015-03-30 14:59:19 +0530 | [diff] [blame] | 49 | #if defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST) && defined(CONFIG_TICK_ONESHOT) |
| 50 | extern void hotplug_cpu__broadcast_tick_pull(int dead_cpu); |
| 51 | #else |
| 52 | static inline void hotplug_cpu__broadcast_tick_pull(int dead_cpu) { } |
| 53 | #endif |
| 54 | |
Thomas Gleixner | 592a438 | 2015-04-03 02:01:10 +0200 | [diff] [blame] | 55 | enum tick_broadcast_mode { |
| 56 | TICK_BROADCAST_OFF, |
| 57 | TICK_BROADCAST_ON, |
| 58 | TICK_BROADCAST_FORCE, |
| 59 | }; |
| 60 | |
Thomas Gleixner | 1fe5d5c | 2015-04-03 02:05:15 +0200 | [diff] [blame] | 61 | enum tick_broadcast_state { |
| 62 | TICK_BROADCAST_EXIT, |
| 63 | TICK_BROADCAST_ENTER, |
| 64 | }; |
| 65 | |
Thomas Gleixner | 592a438 | 2015-04-03 02:01:10 +0200 | [diff] [blame] | 66 | #ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST |
| 67 | extern void tick_broadcast_control(enum tick_broadcast_mode mode); |
| 68 | #else |
| 69 | static inline void tick_broadcast_control(enum tick_broadcast_mode mode) { } |
| 70 | #endif /* BROADCAST */ |
| 71 | |
Thomas Gleixner | 37b64a4 | 2015-07-07 21:56:34 +0200 | [diff] [blame] | 72 | #ifdef CONFIG_GENERIC_CLOCKEVENTS |
Thomas Gleixner | 1fe5d5c | 2015-04-03 02:05:15 +0200 | [diff] [blame] | 73 | extern int tick_broadcast_oneshot_control(enum tick_broadcast_state state); |
Thomas Gleixner | 37b64a4 | 2015-07-07 21:56:34 +0200 | [diff] [blame] | 74 | #else |
| 75 | static inline int tick_broadcast_oneshot_control(enum tick_broadcast_state state) |
| 76 | { |
| 77 | return 0; |
| 78 | } |
| 79 | #endif |
Thomas Gleixner | 1fe5d5c | 2015-04-03 02:05:15 +0200 | [diff] [blame] | 80 | |
Thomas Gleixner | 592a438 | 2015-04-03 02:01:10 +0200 | [diff] [blame] | 81 | static inline void tick_broadcast_enable(void) |
| 82 | { |
| 83 | tick_broadcast_control(TICK_BROADCAST_ON); |
| 84 | } |
| 85 | static inline void tick_broadcast_disable(void) |
| 86 | { |
| 87 | tick_broadcast_control(TICK_BROADCAST_OFF); |
| 88 | } |
| 89 | static inline void tick_broadcast_force(void) |
| 90 | { |
| 91 | tick_broadcast_control(TICK_BROADCAST_FORCE); |
| 92 | } |
Thomas Gleixner | 1fe5d5c | 2015-04-03 02:05:15 +0200 | [diff] [blame] | 93 | static inline int tick_broadcast_enter(void) |
| 94 | { |
| 95 | return tick_broadcast_oneshot_control(TICK_BROADCAST_ENTER); |
| 96 | } |
| 97 | static inline void tick_broadcast_exit(void) |
| 98 | { |
| 99 | tick_broadcast_oneshot_control(TICK_BROADCAST_EXIT); |
| 100 | } |
Thomas Gleixner | 592a438 | 2015-04-03 02:01:10 +0200 | [diff] [blame] | 101 | |
Frederic Weisbecker | d027d45 | 2015-06-07 15:54:30 +0200 | [diff] [blame] | 102 | enum tick_dep_bits { |
| 103 | TICK_DEP_BIT_POSIX_TIMER = 0, |
| 104 | TICK_DEP_BIT_PERF_EVENTS = 1, |
| 105 | TICK_DEP_BIT_SCHED = 2, |
| 106 | TICK_DEP_BIT_CLOCK_UNSTABLE = 3 |
| 107 | }; |
| 108 | |
Frederic Weisbecker | e6e6cc2 | 2015-12-11 03:27:25 +0100 | [diff] [blame] | 109 | #define TICK_DEP_MASK_NONE 0 |
Frederic Weisbecker | d027d45 | 2015-06-07 15:54:30 +0200 | [diff] [blame] | 110 | #define TICK_DEP_MASK_POSIX_TIMER (1 << TICK_DEP_BIT_POSIX_TIMER) |
| 111 | #define TICK_DEP_MASK_PERF_EVENTS (1 << TICK_DEP_BIT_PERF_EVENTS) |
| 112 | #define TICK_DEP_MASK_SCHED (1 << TICK_DEP_BIT_SCHED) |
| 113 | #define TICK_DEP_MASK_CLOCK_UNSTABLE (1 << TICK_DEP_BIT_CLOCK_UNSTABLE) |
| 114 | |
Thomas Gleixner | c1797ba | 2015-03-25 13:07:37 +0100 | [diff] [blame] | 115 | #ifdef CONFIG_NO_HZ_COMMON |
Kees Cook | 4cc7ecb7 | 2016-03-17 14:23:00 -0700 | [diff] [blame] | 116 | extern bool tick_nohz_enabled; |
Thomas Gleixner | c1797ba | 2015-03-25 13:07:37 +0100 | [diff] [blame] | 117 | extern int tick_nohz_tick_stopped(void); |
Frederic Weisbecker | 1268fbc | 2011-11-17 18:48:14 +0100 | [diff] [blame] | 118 | extern void tick_nohz_idle_enter(void); |
Frederic Weisbecker | 280f067 | 2011-10-07 18:22:06 +0200 | [diff] [blame] | 119 | extern void tick_nohz_idle_exit(void); |
| 120 | extern void tick_nohz_irq_exit(void); |
Len Brown | 4f86d3a | 2007-10-03 18:58:00 -0400 | [diff] [blame] | 121 | extern ktime_t tick_nohz_get_sleep_length(void); |
Venki Pallipadi | 6378ddb | 2008-01-30 13:30:04 +0100 | [diff] [blame] | 122 | extern u64 get_cpu_idle_time_us(int cpu, u64 *last_update_time); |
Arjan van de Ven | 0224cf4 | 2010-05-09 08:25:23 -0700 | [diff] [blame] | 123 | extern u64 get_cpu_iowait_time_us(int cpu, u64 *last_update_time); |
Thomas Gleixner | c1797ba | 2015-03-25 13:07:37 +0100 | [diff] [blame] | 124 | #else /* !CONFIG_NO_HZ_COMMON */ |
Jean Delvare | 46373a1 | 2016-01-11 17:40:31 +0100 | [diff] [blame] | 125 | #define tick_nohz_enabled (0) |
Thomas Gleixner | c1797ba | 2015-03-25 13:07:37 +0100 | [diff] [blame] | 126 | static inline int tick_nohz_tick_stopped(void) { return 0; } |
Frederic Weisbecker | 2bbb681 | 2011-10-08 16:01:00 +0200 | [diff] [blame] | 127 | static inline void tick_nohz_idle_enter(void) { } |
| 128 | static inline void tick_nohz_idle_exit(void) { } |
Frederic Weisbecker | 280f067 | 2011-10-07 18:22:06 +0200 | [diff] [blame] | 129 | |
Len Brown | 4f86d3a | 2007-10-03 18:58:00 -0400 | [diff] [blame] | 130 | static inline ktime_t tick_nohz_get_sleep_length(void) |
| 131 | { |
| 132 | ktime_t len = { .tv64 = NSEC_PER_SEC/HZ }; |
| 133 | |
| 134 | return len; |
| 135 | } |
venkatesh.pallipadi@intel.com | 8083e4a | 2008-08-04 11:59:11 -0700 | [diff] [blame] | 136 | static inline u64 get_cpu_idle_time_us(int cpu, u64 *unused) { return -1; } |
Arjan van de Ven | 0224cf4 | 2010-05-09 08:25:23 -0700 | [diff] [blame] | 137 | static inline u64 get_cpu_iowait_time_us(int cpu, u64 *unused) { return -1; } |
Thomas Gleixner | c1797ba | 2015-03-25 13:07:37 +0100 | [diff] [blame] | 138 | #endif /* !CONFIG_NO_HZ_COMMON */ |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 139 | |
Frederic Weisbecker | c5bfece | 2013-04-12 16:45:34 +0200 | [diff] [blame] | 140 | #ifdef CONFIG_NO_HZ_FULL |
Frederic Weisbecker | 460775d | 2013-07-24 23:52:27 +0200 | [diff] [blame] | 141 | extern bool tick_nohz_full_running; |
| 142 | extern cpumask_var_t tick_nohz_full_mask; |
Paul E. McKenney | c0f489d | 2014-06-04 13:46:03 -0700 | [diff] [blame] | 143 | extern cpumask_var_t housekeeping_mask; |
Frederic Weisbecker | 460775d | 2013-07-24 23:52:27 +0200 | [diff] [blame] | 144 | |
| 145 | static inline bool tick_nohz_full_enabled(void) |
| 146 | { |
Frederic Weisbecker | 58135f5 | 2013-11-06 14:45:57 +0100 | [diff] [blame] | 147 | if (!context_tracking_is_enabled()) |
Frederic Weisbecker | 460775d | 2013-07-24 23:52:27 +0200 | [diff] [blame] | 148 | return false; |
| 149 | |
| 150 | return tick_nohz_full_running; |
| 151 | } |
| 152 | |
| 153 | static inline bool tick_nohz_full_cpu(int cpu) |
| 154 | { |
| 155 | if (!tick_nohz_full_enabled()) |
| 156 | return false; |
| 157 | |
| 158 | return cpumask_test_cpu(cpu, tick_nohz_full_mask); |
| 159 | } |
| 160 | |
Chris Metcalf | 83dedea | 2015-05-06 18:04:25 +0200 | [diff] [blame] | 161 | static inline void tick_nohz_full_add_cpus_to(struct cpumask *mask) |
| 162 | { |
| 163 | if (tick_nohz_full_enabled()) |
| 164 | cpumask_or(mask, mask, tick_nohz_full_mask); |
| 165 | } |
| 166 | |
Vatika Harlalka | 9642d18 | 2015-09-01 16:50:59 +0200 | [diff] [blame] | 167 | static inline int housekeeping_any_cpu(void) |
| 168 | { |
| 169 | return cpumask_any_and(housekeeping_mask, cpu_online_mask); |
| 170 | } |
| 171 | |
Frederic Weisbecker | d027d45 | 2015-06-07 15:54:30 +0200 | [diff] [blame] | 172 | extern void tick_nohz_dep_set(enum tick_dep_bits bit); |
| 173 | extern void tick_nohz_dep_clear(enum tick_dep_bits bit); |
| 174 | extern void tick_nohz_dep_set_cpu(int cpu, enum tick_dep_bits bit); |
| 175 | extern void tick_nohz_dep_clear_cpu(int cpu, enum tick_dep_bits bit); |
| 176 | extern void tick_nohz_dep_set_task(struct task_struct *tsk, |
| 177 | enum tick_dep_bits bit); |
| 178 | extern void tick_nohz_dep_clear_task(struct task_struct *tsk, |
| 179 | enum tick_dep_bits bit); |
| 180 | extern void tick_nohz_dep_set_signal(struct signal_struct *signal, |
| 181 | enum tick_dep_bits bit); |
| 182 | extern void tick_nohz_dep_clear_signal(struct signal_struct *signal, |
| 183 | enum tick_dep_bits bit); |
| 184 | |
| 185 | /* |
| 186 | * The below are tick_nohz_[set,clear]_dep() wrappers that optimize off-cases |
| 187 | * on top of static keys. |
| 188 | */ |
| 189 | static inline void tick_dep_set(enum tick_dep_bits bit) |
| 190 | { |
| 191 | if (tick_nohz_full_enabled()) |
| 192 | tick_nohz_dep_set(bit); |
| 193 | } |
| 194 | |
| 195 | static inline void tick_dep_clear(enum tick_dep_bits bit) |
| 196 | { |
| 197 | if (tick_nohz_full_enabled()) |
| 198 | tick_nohz_dep_clear(bit); |
| 199 | } |
| 200 | |
| 201 | static inline void tick_dep_set_cpu(int cpu, enum tick_dep_bits bit) |
| 202 | { |
| 203 | if (tick_nohz_full_cpu(cpu)) |
| 204 | tick_nohz_dep_set_cpu(cpu, bit); |
| 205 | } |
| 206 | |
| 207 | static inline void tick_dep_clear_cpu(int cpu, enum tick_dep_bits bit) |
| 208 | { |
| 209 | if (tick_nohz_full_cpu(cpu)) |
| 210 | tick_nohz_dep_clear_cpu(cpu, bit); |
| 211 | } |
| 212 | |
| 213 | static inline void tick_dep_set_task(struct task_struct *tsk, |
| 214 | enum tick_dep_bits bit) |
| 215 | { |
| 216 | if (tick_nohz_full_enabled()) |
| 217 | tick_nohz_dep_set_task(tsk, bit); |
| 218 | } |
| 219 | static inline void tick_dep_clear_task(struct task_struct *tsk, |
| 220 | enum tick_dep_bits bit) |
| 221 | { |
| 222 | if (tick_nohz_full_enabled()) |
| 223 | tick_nohz_dep_clear_task(tsk, bit); |
| 224 | } |
| 225 | static inline void tick_dep_set_signal(struct signal_struct *signal, |
| 226 | enum tick_dep_bits bit) |
| 227 | { |
| 228 | if (tick_nohz_full_enabled()) |
| 229 | tick_nohz_dep_set_signal(signal, bit); |
| 230 | } |
| 231 | static inline void tick_dep_clear_signal(struct signal_struct *signal, |
| 232 | enum tick_dep_bits bit) |
| 233 | { |
| 234 | if (tick_nohz_full_enabled()) |
| 235 | tick_nohz_dep_clear_signal(signal, bit); |
| 236 | } |
| 237 | |
Frederic Weisbecker | 3d36aeb | 2014-06-04 16:17:33 +0200 | [diff] [blame] | 238 | extern void tick_nohz_full_kick_cpu(int cpu); |
Frederic Weisbecker | de734f8 | 2015-06-11 18:07:12 +0200 | [diff] [blame] | 239 | extern void __tick_nohz_task_switch(void); |
Frederic Weisbecker | a831881 | 2012-12-18 17:32:19 +0100 | [diff] [blame] | 240 | #else |
Vatika Harlalka | 9642d18 | 2015-09-01 16:50:59 +0200 | [diff] [blame] | 241 | static inline int housekeeping_any_cpu(void) |
| 242 | { |
Olav Haugan | 095302a | 2016-06-02 16:29:27 -0700 | [diff] [blame^] | 243 | cpumask_t available; |
| 244 | int cpu; |
| 245 | |
| 246 | cpumask_andnot(&available, cpu_online_mask, cpu_isolated_mask); |
| 247 | cpu = cpumask_any(&available); |
| 248 | if (cpu >= nr_cpu_ids) |
| 249 | cpu = smp_processor_id(); |
| 250 | |
| 251 | return cpu; |
Vatika Harlalka | 9642d18 | 2015-09-01 16:50:59 +0200 | [diff] [blame] | 252 | } |
Frederic Weisbecker | 460775d | 2013-07-24 23:52:27 +0200 | [diff] [blame] | 253 | static inline bool tick_nohz_full_enabled(void) { return false; } |
| 254 | static inline bool tick_nohz_full_cpu(int cpu) { return false; } |
Chris Metcalf | 83dedea | 2015-05-06 18:04:25 +0200 | [diff] [blame] | 255 | static inline void tick_nohz_full_add_cpus_to(struct cpumask *mask) { } |
Frederic Weisbecker | d027d45 | 2015-06-07 15:54:30 +0200 | [diff] [blame] | 256 | |
| 257 | static inline void tick_dep_set(enum tick_dep_bits bit) { } |
| 258 | static inline void tick_dep_clear(enum tick_dep_bits bit) { } |
| 259 | static inline void tick_dep_set_cpu(int cpu, enum tick_dep_bits bit) { } |
| 260 | static inline void tick_dep_clear_cpu(int cpu, enum tick_dep_bits bit) { } |
| 261 | static inline void tick_dep_set_task(struct task_struct *tsk, |
| 262 | enum tick_dep_bits bit) { } |
| 263 | static inline void tick_dep_clear_task(struct task_struct *tsk, |
| 264 | enum tick_dep_bits bit) { } |
| 265 | static inline void tick_dep_set_signal(struct signal_struct *signal, |
| 266 | enum tick_dep_bits bit) { } |
| 267 | static inline void tick_dep_clear_signal(struct signal_struct *signal, |
| 268 | enum tick_dep_bits bit) { } |
| 269 | |
Frederic Weisbecker | 3d36aeb | 2014-06-04 16:17:33 +0200 | [diff] [blame] | 270 | static inline void tick_nohz_full_kick_cpu(int cpu) { } |
Frederic Weisbecker | de734f8 | 2015-06-11 18:07:12 +0200 | [diff] [blame] | 271 | static inline void __tick_nohz_task_switch(void) { } |
Frederic Weisbecker | a831881 | 2012-12-18 17:32:19 +0100 | [diff] [blame] | 272 | #endif |
| 273 | |
Chris Metcalf | 03f6199 | 2015-07-10 15:37:25 -0400 | [diff] [blame] | 274 | static inline const struct cpumask *housekeeping_cpumask(void) |
| 275 | { |
| 276 | #ifdef CONFIG_NO_HZ_FULL |
| 277 | if (tick_nohz_full_enabled()) |
| 278 | return housekeeping_mask; |
| 279 | #endif |
| 280 | return cpu_possible_mask; |
| 281 | } |
| 282 | |
Paul E. McKenney | c0f489d | 2014-06-04 13:46:03 -0700 | [diff] [blame] | 283 | static inline bool is_housekeeping_cpu(int cpu) |
| 284 | { |
| 285 | #ifdef CONFIG_NO_HZ_FULL |
| 286 | if (tick_nohz_full_enabled()) |
| 287 | return cpumask_test_cpu(cpu, housekeeping_mask); |
| 288 | #endif |
Olav Haugan | 095302a | 2016-06-02 16:29:27 -0700 | [diff] [blame^] | 289 | return !cpu_isolated(cpu); |
Paul E. McKenney | c0f489d | 2014-06-04 13:46:03 -0700 | [diff] [blame] | 290 | } |
| 291 | |
| 292 | static inline void housekeeping_affine(struct task_struct *t) |
| 293 | { |
| 294 | #ifdef CONFIG_NO_HZ_FULL |
| 295 | if (tick_nohz_full_enabled()) |
| 296 | set_cpus_allowed_ptr(t, housekeeping_mask); |
| 297 | |
| 298 | #endif |
| 299 | } |
| 300 | |
Frederic Weisbecker | de734f8 | 2015-06-11 18:07:12 +0200 | [diff] [blame] | 301 | static inline void tick_nohz_task_switch(void) |
Frederic Weisbecker | d13508f | 2013-07-24 23:52:27 +0200 | [diff] [blame] | 302 | { |
| 303 | if (tick_nohz_full_enabled()) |
Frederic Weisbecker | de734f8 | 2015-06-11 18:07:12 +0200 | [diff] [blame] | 304 | __tick_nohz_task_switch(); |
Frederic Weisbecker | d13508f | 2013-07-24 23:52:27 +0200 | [diff] [blame] | 305 | } |
| 306 | |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 307 | #endif |