This source file includes following definitions.
- hrtimer_set_expires
- hrtimer_set_expires_range
- hrtimer_set_expires_range_ns
- hrtimer_set_expires_tv64
- hrtimer_add_expires
- hrtimer_add_expires_ns
- hrtimer_get_expires
- hrtimer_get_softexpires
- hrtimer_get_expires_tv64
- hrtimer_get_softexpires_tv64
- hrtimer_get_expires_ns
- hrtimer_expires_remaining
- hrtimer_cb_get_time
- hrtimer_is_hres_active
- clock_was_set_delayed
- __hrtimer_expires_remaining_adjusted
- hrtimer_expires_remaining_adjusted
- timerfd_clock_was_set
- hrtimer_cancel_wait_running
- hrtimer_init_on_stack
- hrtimer_init_sleeper_on_stack
- destroy_hrtimer_on_stack
- hrtimer_start
- hrtimer_start_expires
- hrtimer_restart
- hrtimer_get_remaining
- hrtimer_is_queued
- hrtimer_callback_running
- hrtimer_forward_now
1
2
3
4
5
6
7
8
9
10
11
12 #ifndef _LINUX_HRTIMER_H
13 #define _LINUX_HRTIMER_H
14
15 #include <linux/hrtimer_defs.h>
16 #include <linux/rbtree.h>
17 #include <linux/init.h>
18 #include <linux/list.h>
19 #include <linux/percpu.h>
20 #include <linux/timer.h>
21 #include <linux/timerqueue.h>
22
23 struct hrtimer_clock_base;
24 struct hrtimer_cpu_base;
25
26
27
28
29
30
31
32
33
34
35
36
37
38 enum hrtimer_mode {
39 HRTIMER_MODE_ABS = 0x00,
40 HRTIMER_MODE_REL = 0x01,
41 HRTIMER_MODE_PINNED = 0x02,
42 HRTIMER_MODE_SOFT = 0x04,
43 HRTIMER_MODE_HARD = 0x08,
44
45 HRTIMER_MODE_ABS_PINNED = HRTIMER_MODE_ABS | HRTIMER_MODE_PINNED,
46 HRTIMER_MODE_REL_PINNED = HRTIMER_MODE_REL | HRTIMER_MODE_PINNED,
47
48 HRTIMER_MODE_ABS_SOFT = HRTIMER_MODE_ABS | HRTIMER_MODE_SOFT,
49 HRTIMER_MODE_REL_SOFT = HRTIMER_MODE_REL | HRTIMER_MODE_SOFT,
50
51 HRTIMER_MODE_ABS_PINNED_SOFT = HRTIMER_MODE_ABS_PINNED | HRTIMER_MODE_SOFT,
52 HRTIMER_MODE_REL_PINNED_SOFT = HRTIMER_MODE_REL_PINNED | HRTIMER_MODE_SOFT,
53
54 HRTIMER_MODE_ABS_HARD = HRTIMER_MODE_ABS | HRTIMER_MODE_HARD,
55 HRTIMER_MODE_REL_HARD = HRTIMER_MODE_REL | HRTIMER_MODE_HARD,
56
57 HRTIMER_MODE_ABS_PINNED_HARD = HRTIMER_MODE_ABS_PINNED | HRTIMER_MODE_HARD,
58 HRTIMER_MODE_REL_PINNED_HARD = HRTIMER_MODE_REL_PINNED | HRTIMER_MODE_HARD,
59 };
60
61
62
63
64 enum hrtimer_restart {
65 HRTIMER_NORESTART,
66 HRTIMER_RESTART,
67 };
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93 #define HRTIMER_STATE_INACTIVE 0x00
94 #define HRTIMER_STATE_ENQUEUED 0x01
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117 struct hrtimer {
118 struct timerqueue_node node;
119 ktime_t _softexpires;
120 enum hrtimer_restart (*function)(struct hrtimer *);
121 struct hrtimer_clock_base *base;
122 u8 state;
123 u8 is_rel;
124 u8 is_soft;
125 u8 is_hard;
126 };
127
128
129
130
131
132
133
134
135 struct hrtimer_sleeper {
136 struct hrtimer timer;
137 struct task_struct *task;
138 };
139
140 #ifdef CONFIG_64BIT
141 # define __hrtimer_clock_base_align ____cacheline_aligned
142 #else
143 # define __hrtimer_clock_base_align
144 #endif
145
146
147
148
149
150
151
152
153
154
155
156
157
158 struct hrtimer_clock_base {
159 struct hrtimer_cpu_base *cpu_base;
160 unsigned int index;
161 clockid_t clockid;
162 seqcount_t seq;
163 struct hrtimer *running;
164 struct timerqueue_head active;
165 ktime_t (*get_time)(void);
166 ktime_t offset;
167 } __hrtimer_clock_base_align;
168
169 enum hrtimer_base_type {
170 HRTIMER_BASE_MONOTONIC,
171 HRTIMER_BASE_REALTIME,
172 HRTIMER_BASE_BOOTTIME,
173 HRTIMER_BASE_TAI,
174 HRTIMER_BASE_MONOTONIC_SOFT,
175 HRTIMER_BASE_REALTIME_SOFT,
176 HRTIMER_BASE_BOOTTIME_SOFT,
177 HRTIMER_BASE_TAI_SOFT,
178 HRTIMER_MAX_CLOCK_BASES,
179 };
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213 struct hrtimer_cpu_base {
214 raw_spinlock_t lock;
215 unsigned int cpu;
216 unsigned int active_bases;
217 unsigned int clock_was_set_seq;
218 unsigned int hres_active : 1,
219 in_hrtirq : 1,
220 hang_detected : 1,
221 softirq_activated : 1;
222 #ifdef CONFIG_HIGH_RES_TIMERS
223 unsigned int nr_events;
224 unsigned short nr_retries;
225 unsigned short nr_hangs;
226 unsigned int max_hang_time;
227 #endif
228 #ifdef CONFIG_PREEMPT_RT
229 spinlock_t softirq_expiry_lock;
230 atomic_t timer_waiters;
231 #endif
232 ktime_t expires_next;
233 struct hrtimer *next_timer;
234 ktime_t softirq_expires_next;
235 struct hrtimer *softirq_next_timer;
236 struct hrtimer_clock_base clock_base[HRTIMER_MAX_CLOCK_BASES];
237 } ____cacheline_aligned;
238
239 static inline void hrtimer_set_expires(struct hrtimer *timer, ktime_t time)
240 {
241 timer->node.expires = time;
242 timer->_softexpires = time;
243 }
244
245 static inline void hrtimer_set_expires_range(struct hrtimer *timer, ktime_t time, ktime_t delta)
246 {
247 timer->_softexpires = time;
248 timer->node.expires = ktime_add_safe(time, delta);
249 }
250
251 static inline void hrtimer_set_expires_range_ns(struct hrtimer *timer, ktime_t time, u64 delta)
252 {
253 timer->_softexpires = time;
254 timer->node.expires = ktime_add_safe(time, ns_to_ktime(delta));
255 }
256
257 static inline void hrtimer_set_expires_tv64(struct hrtimer *timer, s64 tv64)
258 {
259 timer->node.expires = tv64;
260 timer->_softexpires = tv64;
261 }
262
263 static inline void hrtimer_add_expires(struct hrtimer *timer, ktime_t time)
264 {
265 timer->node.expires = ktime_add_safe(timer->node.expires, time);
266 timer->_softexpires = ktime_add_safe(timer->_softexpires, time);
267 }
268
269 static inline void hrtimer_add_expires_ns(struct hrtimer *timer, u64 ns)
270 {
271 timer->node.expires = ktime_add_ns(timer->node.expires, ns);
272 timer->_softexpires = ktime_add_ns(timer->_softexpires, ns);
273 }
274
275 static inline ktime_t hrtimer_get_expires(const struct hrtimer *timer)
276 {
277 return timer->node.expires;
278 }
279
280 static inline ktime_t hrtimer_get_softexpires(const struct hrtimer *timer)
281 {
282 return timer->_softexpires;
283 }
284
285 static inline s64 hrtimer_get_expires_tv64(const struct hrtimer *timer)
286 {
287 return timer->node.expires;
288 }
289 static inline s64 hrtimer_get_softexpires_tv64(const struct hrtimer *timer)
290 {
291 return timer->_softexpires;
292 }
293
294 static inline s64 hrtimer_get_expires_ns(const struct hrtimer *timer)
295 {
296 return ktime_to_ns(timer->node.expires);
297 }
298
299 static inline ktime_t hrtimer_expires_remaining(const struct hrtimer *timer)
300 {
301 return ktime_sub(timer->node.expires, timer->base->get_time());
302 }
303
304 static inline ktime_t hrtimer_cb_get_time(struct hrtimer *timer)
305 {
306 return timer->base->get_time();
307 }
308
309 static inline int hrtimer_is_hres_active(struct hrtimer *timer)
310 {
311 return IS_ENABLED(CONFIG_HIGH_RES_TIMERS) ?
312 timer->base->cpu_base->hres_active : 0;
313 }
314
315 #ifdef CONFIG_HIGH_RES_TIMERS
316 struct clock_event_device;
317
318 extern void hrtimer_interrupt(struct clock_event_device *dev);
319
320 extern void clock_was_set_delayed(void);
321
322 extern unsigned int hrtimer_resolution;
323
324 #else
325
326 #define hrtimer_resolution (unsigned int)LOW_RES_NSEC
327
328 static inline void clock_was_set_delayed(void) { }
329
330 #endif
331
332 static inline ktime_t
333 __hrtimer_expires_remaining_adjusted(const struct hrtimer *timer, ktime_t now)
334 {
335 ktime_t rem = ktime_sub(timer->node.expires, now);
336
337
338
339
340
341 if (IS_ENABLED(CONFIG_TIME_LOW_RES) && timer->is_rel)
342 rem -= hrtimer_resolution;
343 return rem;
344 }
345
346 static inline ktime_t
347 hrtimer_expires_remaining_adjusted(const struct hrtimer *timer)
348 {
349 return __hrtimer_expires_remaining_adjusted(timer,
350 timer->base->get_time());
351 }
352
353 extern void clock_was_set(void);
354 #ifdef CONFIG_TIMERFD
355 extern void timerfd_clock_was_set(void);
356 #else
357 static inline void timerfd_clock_was_set(void) { }
358 #endif
359 extern void hrtimers_resume(void);
360
361 DECLARE_PER_CPU(struct tick_device, tick_cpu_device);
362
363 #ifdef CONFIG_PREEMPT_RT
364 void hrtimer_cancel_wait_running(const struct hrtimer *timer);
365 #else
366 static inline void hrtimer_cancel_wait_running(struct hrtimer *timer)
367 {
368 cpu_relax();
369 }
370 #endif
371
372
373
374
375 extern void hrtimer_init(struct hrtimer *timer, clockid_t which_clock,
376 enum hrtimer_mode mode);
377 extern void hrtimer_init_sleeper(struct hrtimer_sleeper *sl, clockid_t clock_id,
378 enum hrtimer_mode mode);
379
380 #ifdef CONFIG_DEBUG_OBJECTS_TIMERS
381 extern void hrtimer_init_on_stack(struct hrtimer *timer, clockid_t which_clock,
382 enum hrtimer_mode mode);
383 extern void hrtimer_init_sleeper_on_stack(struct hrtimer_sleeper *sl,
384 clockid_t clock_id,
385 enum hrtimer_mode mode);
386
387 extern void destroy_hrtimer_on_stack(struct hrtimer *timer);
388 #else
389 static inline void hrtimer_init_on_stack(struct hrtimer *timer,
390 clockid_t which_clock,
391 enum hrtimer_mode mode)
392 {
393 hrtimer_init(timer, which_clock, mode);
394 }
395
396 static inline void hrtimer_init_sleeper_on_stack(struct hrtimer_sleeper *sl,
397 clockid_t clock_id,
398 enum hrtimer_mode mode)
399 {
400 hrtimer_init_sleeper(sl, clock_id, mode);
401 }
402
403 static inline void destroy_hrtimer_on_stack(struct hrtimer *timer) { }
404 #endif
405
406
407 extern void hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim,
408 u64 range_ns, const enum hrtimer_mode mode);
409
410
411
412
413
414
415
416
417
418 static inline void hrtimer_start(struct hrtimer *timer, ktime_t tim,
419 const enum hrtimer_mode mode)
420 {
421 hrtimer_start_range_ns(timer, tim, 0, mode);
422 }
423
424 extern int hrtimer_cancel(struct hrtimer *timer);
425 extern int hrtimer_try_to_cancel(struct hrtimer *timer);
426
427 static inline void hrtimer_start_expires(struct hrtimer *timer,
428 enum hrtimer_mode mode)
429 {
430 u64 delta;
431 ktime_t soft, hard;
432 soft = hrtimer_get_softexpires(timer);
433 hard = hrtimer_get_expires(timer);
434 delta = ktime_to_ns(ktime_sub(hard, soft));
435 hrtimer_start_range_ns(timer, soft, delta, mode);
436 }
437
438 void hrtimer_sleeper_start_expires(struct hrtimer_sleeper *sl,
439 enum hrtimer_mode mode);
440
441 static inline void hrtimer_restart(struct hrtimer *timer)
442 {
443 hrtimer_start_expires(timer, HRTIMER_MODE_ABS);
444 }
445
446
447 extern ktime_t __hrtimer_get_remaining(const struct hrtimer *timer, bool adjust);
448
449 static inline ktime_t hrtimer_get_remaining(const struct hrtimer *timer)
450 {
451 return __hrtimer_get_remaining(timer, false);
452 }
453
454 extern u64 hrtimer_get_next_event(void);
455 extern u64 hrtimer_next_event_without(const struct hrtimer *exclude);
456
457 extern bool hrtimer_active(const struct hrtimer *timer);
458
459
460
461
462
463
464
465
466
467 static inline bool hrtimer_is_queued(struct hrtimer *timer)
468 {
469
470 return !!(READ_ONCE(timer->state) & HRTIMER_STATE_ENQUEUED);
471 }
472
473
474
475
476
477 static inline int hrtimer_callback_running(struct hrtimer *timer)
478 {
479 return timer->base->running == timer;
480 }
481
482
483 extern u64
484 hrtimer_forward(struct hrtimer *timer, ktime_t now, ktime_t interval);
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502 static inline u64 hrtimer_forward_now(struct hrtimer *timer,
503 ktime_t interval)
504 {
505 return hrtimer_forward(timer, timer->base->get_time(), interval);
506 }
507
508
509
510 extern int nanosleep_copyout(struct restart_block *, struct timespec64 *);
511 extern long hrtimer_nanosleep(const struct timespec64 *rqtp,
512 const enum hrtimer_mode mode,
513 const clockid_t clockid);
514
515 extern int schedule_hrtimeout_range(ktime_t *expires, u64 delta,
516 const enum hrtimer_mode mode);
517 extern int schedule_hrtimeout_range_clock(ktime_t *expires,
518 u64 delta,
519 const enum hrtimer_mode mode,
520 clockid_t clock_id);
521 extern int schedule_hrtimeout(ktime_t *expires, const enum hrtimer_mode mode);
522
523
524 extern void hrtimer_run_queues(void);
525
526
527 extern void __init hrtimers_init(void);
528
529
530 extern void sysrq_timer_list_show(void);
531
532 int hrtimers_prepare_cpu(unsigned int cpu);
533 #ifdef CONFIG_HOTPLUG_CPU
534 int hrtimers_dead_cpu(unsigned int cpu);
535 #else
536 #define hrtimers_dead_cpu NULL
537 #endif
538
539 #endif