Branch data Line data Source code
1 : : /*
2 : : * linux/kernel/hrtimer.c
3 : : *
4 : : * Copyright(C) 2005-2006, Thomas Gleixner <tglx@linutronix.de>
5 : : * Copyright(C) 2005-2007, Red Hat, Inc., Ingo Molnar
6 : : * Copyright(C) 2006-2007 Timesys Corp., Thomas Gleixner
7 : : *
8 : : * High-resolution kernel timers
9 : : *
10 : : * In contrast to the low-resolution timeout API implemented in
11 : : * kernel/timer.c, hrtimers provide finer resolution and accuracy
12 : : * depending on system configuration and capabilities.
13 : : *
14 : : * These timers are currently used for:
15 : : * - itimers
16 : : * - POSIX timers
17 : : * - nanosleep
18 : : * - precise in-kernel timing
19 : : *
20 : : * Started by: Thomas Gleixner and Ingo Molnar
21 : : *
22 : : * Credits:
23 : : * based on kernel/timer.c
24 : : *
25 : : * Help, testing, suggestions, bugfixes, improvements were
26 : : * provided by:
27 : : *
28 : : * George Anzinger, Andrew Morton, Steven Rostedt, Roman Zippel
29 : : * et. al.
30 : : *
31 : : * For licencing details see kernel-base/COPYING
32 : : */
33 : :
34 : : #include <linux/cpu.h>
35 : : #include <linux/export.h>
36 : : #include <linux/percpu.h>
37 : : #include <linux/hrtimer.h>
38 : : #include <linux/notifier.h>
39 : : #include <linux/syscalls.h>
40 : : #include <linux/kallsyms.h>
41 : : #include <linux/interrupt.h>
42 : : #include <linux/tick.h>
43 : : #include <linux/seq_file.h>
44 : : #include <linux/err.h>
45 : : #include <linux/debugobjects.h>
46 : : #include <linux/sched.h>
47 : : #include <linux/sched/sysctl.h>
48 : : #include <linux/sched/rt.h>
49 : : #include <linux/sched/deadline.h>
50 : : #include <linux/timer.h>
51 : : #include <linux/freezer.h>
52 : :
53 : : #include <asm/uaccess.h>
54 : :
55 : : #include <trace/events/timer.h>
56 : :
57 : : /*
58 : : * The timer bases:
59 : : *
60 : : * There are more clockids then hrtimer bases. Thus, we index
61 : : * into the timer bases by the hrtimer_base_type enum. When trying
62 : : * to reach a base using a clockid, hrtimer_clockid_to_base()
63 : : * is used to convert from clockid to the proper hrtimer_base_type.
64 : : */
65 : : DEFINE_PER_CPU(struct hrtimer_cpu_base, hrtimer_bases) =
66 : : {
67 : :
68 : : .lock = __RAW_SPIN_LOCK_UNLOCKED(hrtimer_bases.lock),
69 : : .clock_base =
70 : : {
71 : : {
72 : : .index = HRTIMER_BASE_MONOTONIC,
73 : : .clockid = CLOCK_MONOTONIC,
74 : : .get_time = &ktime_get,
75 : : .resolution = KTIME_LOW_RES,
76 : : },
77 : : {
78 : : .index = HRTIMER_BASE_REALTIME,
79 : : .clockid = CLOCK_REALTIME,
80 : : .get_time = &ktime_get_real,
81 : : .resolution = KTIME_LOW_RES,
82 : : },
83 : : {
84 : : .index = HRTIMER_BASE_BOOTTIME,
85 : : .clockid = CLOCK_BOOTTIME,
86 : : .get_time = &ktime_get_boottime,
87 : : .resolution = KTIME_LOW_RES,
88 : : },
89 : : {
90 : : .index = HRTIMER_BASE_TAI,
91 : : .clockid = CLOCK_TAI,
92 : : .get_time = &ktime_get_clocktai,
93 : : .resolution = KTIME_LOW_RES,
94 : : },
95 : : }
96 : : };
97 : :
98 : : static const int hrtimer_clock_to_base_table[MAX_CLOCKS] = {
99 : : [CLOCK_REALTIME] = HRTIMER_BASE_REALTIME,
100 : : [CLOCK_MONOTONIC] = HRTIMER_BASE_MONOTONIC,
101 : : [CLOCK_BOOTTIME] = HRTIMER_BASE_BOOTTIME,
102 : : [CLOCK_TAI] = HRTIMER_BASE_TAI,
103 : : };
104 : :
105 : : static inline int hrtimer_clockid_to_base(clockid_t clock_id)
106 : : {
107 : 0 : return hrtimer_clock_to_base_table[clock_id];
108 : : }
109 : :
110 : :
111 : : /*
112 : : * Get the coarse grained time at the softirq based on xtime and
113 : : * wall_to_monotonic.
114 : : */
115 : 0 : static void hrtimer_get_softirq_time(struct hrtimer_cpu_base *base)
116 : : {
117 : : ktime_t xtim, mono, boot;
118 : : struct timespec xts, tom, slp;
119 : : s32 tai_offset;
120 : :
121 : 0 : get_xtime_and_monotonic_and_sleep_offset(&xts, &tom, &slp);
122 : 0 : tai_offset = timekeeping_get_tai_offset();
123 : :
124 : : xtim = timespec_to_ktime(xts);
125 : 0 : mono = ktime_add(xtim, timespec_to_ktime(tom));
126 : 0 : boot = ktime_add(mono, timespec_to_ktime(slp));
127 : 0 : base->clock_base[HRTIMER_BASE_REALTIME].softirq_time = xtim;
128 : 0 : base->clock_base[HRTIMER_BASE_MONOTONIC].softirq_time = mono;
129 : 0 : base->clock_base[HRTIMER_BASE_BOOTTIME].softirq_time = boot;
130 : 0 : base->clock_base[HRTIMER_BASE_TAI].softirq_time =
131 : 0 : ktime_add(xtim, ktime_set(tai_offset, 0));
132 : 0 : }
133 : :
134 : : /*
135 : : * Functions and macros which are different for UP/SMP systems are kept in a
136 : : * single place
137 : : */
138 : : #ifdef CONFIG_SMP
139 : :
140 : : /*
141 : : * We are using hashed locking: holding per_cpu(hrtimer_bases)[n].lock
142 : : * means that all timers which are tied to this base via timer->base are
143 : : * locked, and the base itself is locked too.
144 : : *
145 : : * So __run_timers/migrate_timers can safely modify all timers which could
146 : : * be found on the lists/queues.
147 : : *
148 : : * When the timer's base is locked, and the timer removed from list, it is
149 : : * possible to set timer->base = NULL and drop the lock: the timer remains
150 : : * locked.
151 : : */
152 : : static
153 : 12180939 : struct hrtimer_clock_base *lock_hrtimer_base(const struct hrtimer *timer,
154 : : unsigned long *flags)
155 : : {
156 : : struct hrtimer_clock_base *base;
157 : :
158 : : for (;;) {
159 : 12180939 : base = timer->base;
160 [ + + ]: 12180939 : if (likely(base != NULL)) {
161 : 12179284 : raw_spin_lock_irqsave(&base->cpu_base->lock, *flags);
162 [ + - ]: 12205889 : if (likely(base == timer->base))
163 : 12205889 : return base;
164 : : /* The timer has migrated to another CPU: */
165 : 0 : raw_spin_unlock_irqrestore(&base->cpu_base->lock, *flags);
166 : : }
167 : 0 : cpu_relax();
168 : : }
169 : : }
170 : :
171 : :
172 : : /*
173 : : * Get the preferred target CPU for NOHZ
174 : : */
175 : 0 : static int hrtimer_get_target(int this_cpu, int pinned)
176 : : {
177 : : #ifdef CONFIG_NO_HZ_COMMON
178 [ + + ][ + ]: 5990583 : if (!pinned && get_sysctl_timer_migration() && idle_cpu(this_cpu))
[ - + ]
179 : 0 : return get_nohz_timer_target();
180 : : #endif
181 : 5990739 : return this_cpu;
182 : : }
183 : :
184 : : /*
185 : : * With HIGHRES=y we do not migrate the timer when it is expiring
186 : : * before the next event on the target cpu because we cannot reprogram
187 : : * the target cpu hardware and we would cause it to fire late.
188 : : *
189 : : * Called with cpu_base->lock of target cpu held.
190 : : */
191 : : static int
192 : 0 : hrtimer_check_target(struct hrtimer *timer, struct hrtimer_clock_base *new_base)
193 : : {
194 : : #ifdef CONFIG_HIGH_RES_TIMERS
195 : : ktime_t expires;
196 : :
197 [ # # ]: 0 : if (!new_base->cpu_base->hres_active)
198 : : return 0;
199 : :
200 : 0 : expires = ktime_sub(hrtimer_get_expires(timer), new_base->offset);
201 : 0 : return expires.tv64 <= new_base->cpu_base->expires_next.tv64;
202 : : #else
203 : : return 0;
204 : : #endif
205 : : }
206 : :
207 : : /*
208 : : * Switch the timer base to the current CPU when possible.
209 : : */
210 : : static inline struct hrtimer_clock_base *
211 : 1000 : switch_hrtimer_base(struct hrtimer *timer, struct hrtimer_clock_base *base,
212 : : int pinned)
213 : : {
214 : 0 : struct hrtimer_clock_base *new_base;
215 : : struct hrtimer_cpu_base *new_cpu_base;
216 : 5990754 : int this_cpu = smp_processor_id();
217 : 5990754 : int cpu = hrtimer_get_target(this_cpu, pinned);
218 : 5979035 : int basenum = base->index;
219 : :
220 : : again:
221 : 5979035 : new_cpu_base = &per_cpu(hrtimer_bases, cpu);
222 : 5979035 : new_base = &new_cpu_base->clock_base[basenum];
223 : :
224 [ + + ]: 5979035 : if (base != new_base) {
225 : : /*
226 : : * We are trying to move timer to new_base.
227 : : * However we can't change timer's base while it is running,
228 : : * so we keep it on the same CPU. No hassle vs. reprogramming
229 : : * the event source in the high resolution case. The softirq
230 : : * code will take care of this when the timer function has
231 : : * completed. There is no conflict as we hold the lock until
232 : : * the timer is enqueued.
233 : : */
234 [ + - ]: 1000 : if (unlikely(hrtimer_callback_running(timer)))
235 : : return base;
236 : :
237 : : /* See the comment in lock_timer_base() */
238 : 1000 : timer->base = NULL;
239 : 1000 : raw_spin_unlock(&base->cpu_base->lock);
240 : 1000 : raw_spin_lock(&new_base->cpu_base->lock);
241 : :
242 [ - + ][ # # ]: 1000 : if (cpu != this_cpu && hrtimer_check_target(timer, new_base)) {
243 : : cpu = this_cpu;
244 : : raw_spin_unlock(&new_base->cpu_base->lock);
245 : 0 : raw_spin_lock(&base->cpu_base->lock);
246 : 0 : timer->base = base;
247 : : goto again;
248 : : }
249 : 1000 : timer->base = new_base;
250 : : }
251 : : return new_base;
252 : : }
253 : :
254 : : #else /* CONFIG_SMP */
255 : :
256 : : static inline struct hrtimer_clock_base *
257 : : lock_hrtimer_base(const struct hrtimer *timer, unsigned long *flags)
258 : : {
259 : : struct hrtimer_clock_base *base = timer->base;
260 : :
261 : : raw_spin_lock_irqsave(&base->cpu_base->lock, *flags);
262 : :
263 : : return base;
264 : : }
265 : :
266 : : # define switch_hrtimer_base(t, b, p) (b)
267 : :
268 : : #endif /* !CONFIG_SMP */
269 : :
270 : : /*
271 : : * Functions for the union type storage format of ktime_t which are
272 : : * too large for inlining:
273 : : */
274 : : #if BITS_PER_LONG < 64
275 : : # ifndef CONFIG_KTIME_SCALAR
276 : : /**
277 : : * ktime_add_ns - Add a scalar nanoseconds value to a ktime_t variable
278 : : * @kt: addend
279 : : * @nsec: the scalar nsec value to add
280 : : *
281 : : * Returns the sum of kt and nsec in ktime_t format
282 : : */
283 : : ktime_t ktime_add_ns(const ktime_t kt, u64 nsec)
284 : : {
285 : : ktime_t tmp;
286 : :
287 : : if (likely(nsec < NSEC_PER_SEC)) {
288 : : tmp.tv64 = nsec;
289 : : } else {
290 : : unsigned long rem = do_div(nsec, NSEC_PER_SEC);
291 : :
292 : : /* Make sure nsec fits into long */
293 : : if (unlikely(nsec > KTIME_SEC_MAX))
294 : : return (ktime_t){ .tv64 = KTIME_MAX };
295 : :
296 : : tmp = ktime_set((long)nsec, rem);
297 : : }
298 : :
299 : : return ktime_add(kt, tmp);
300 : : }
301 : :
302 : : EXPORT_SYMBOL_GPL(ktime_add_ns);
303 : :
304 : : /**
305 : : * ktime_sub_ns - Subtract a scalar nanoseconds value from a ktime_t variable
306 : : * @kt: minuend
307 : : * @nsec: the scalar nsec value to subtract
308 : : *
309 : : * Returns the subtraction of @nsec from @kt in ktime_t format
310 : : */
311 : : ktime_t ktime_sub_ns(const ktime_t kt, u64 nsec)
312 : : {
313 : : ktime_t tmp;
314 : :
315 : : if (likely(nsec < NSEC_PER_SEC)) {
316 : : tmp.tv64 = nsec;
317 : : } else {
318 : : unsigned long rem = do_div(nsec, NSEC_PER_SEC);
319 : :
320 : : tmp = ktime_set((long)nsec, rem);
321 : : }
322 : :
323 : : return ktime_sub(kt, tmp);
324 : : }
325 : :
326 : : EXPORT_SYMBOL_GPL(ktime_sub_ns);
327 : : # endif /* !CONFIG_KTIME_SCALAR */
328 : :
329 : : /*
330 : : * Divide a ktime value by a nanosecond value
331 : : */
332 : 0 : u64 ktime_divns(const ktime_t kt, s64 div)
333 : : {
334 : : u64 dclc;
335 : : int sft = 0;
336 : :
337 : 515621 : dclc = ktime_to_ns(kt);
338 : : /* Make sure the divisor is less than 2^32: */
339 [ - + ]: 515621 : while (div >> 32) {
340 : 0 : sft++;
341 : 0 : div >>= 1;
342 : : }
343 : 515621 : dclc >>= sft;
344 [ - + ][ # # ]: 515621 : do_div(dclc, (unsigned long) div);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
345 : :
346 : 515621 : return dclc;
347 : : }
348 : : #endif /* BITS_PER_LONG >= 64 */
349 : :
350 : : /*
351 : : * Add two ktime values and do a safety check for overflow:
352 : : */
353 : 0 : ktime_t ktime_add_safe(const ktime_t lhs, const ktime_t rhs)
354 : : {
355 : 14004530 : ktime_t res = ktime_add(lhs, rhs);
356 : :
357 : : /*
358 : : * We use KTIME_SEC_MAX here, the maximum timeout which we can
359 : : * return to user space in a timespec:
360 : : */
361 [ + ][ + ]: 14004530 : if (res.tv64 < 0 || res.tv64 < lhs.tv64 || res.tv64 < rhs.tv64)
[ + + ][ + ]
[ + ][ + + ]
362 : : res = ktime_set(KTIME_SEC_MAX, 0);
363 : :
364 : 0 : return res;
365 : : }
366 : :
367 : : EXPORT_SYMBOL_GPL(ktime_add_safe);
368 : :
369 : : #ifdef CONFIG_DEBUG_OBJECTS_TIMERS
370 : :
371 : : static struct debug_obj_descr hrtimer_debug_descr;
372 : :
373 : : static void *hrtimer_debug_hint(void *addr)
374 : : {
375 : : return ((struct hrtimer *) addr)->function;
376 : : }
377 : :
378 : : /*
379 : : * fixup_init is called when:
380 : : * - an active object is initialized
381 : : */
382 : : static int hrtimer_fixup_init(void *addr, enum debug_obj_state state)
383 : : {
384 : : struct hrtimer *timer = addr;
385 : :
386 : : switch (state) {
387 : : case ODEBUG_STATE_ACTIVE:
388 : : hrtimer_cancel(timer);
389 : : debug_object_init(timer, &hrtimer_debug_descr);
390 : : return 1;
391 : : default:
392 : : return 0;
393 : : }
394 : : }
395 : :
396 : : /*
397 : : * fixup_activate is called when:
398 : : * - an active object is activated
399 : : * - an unknown object is activated (might be a statically initialized object)
400 : : */
401 : : static int hrtimer_fixup_activate(void *addr, enum debug_obj_state state)
402 : : {
403 : : switch (state) {
404 : :
405 : : case ODEBUG_STATE_NOTAVAILABLE:
406 : : WARN_ON_ONCE(1);
407 : : return 0;
408 : :
409 : : case ODEBUG_STATE_ACTIVE:
410 : : WARN_ON(1);
411 : :
412 : : default:
413 : : return 0;
414 : : }
415 : : }
416 : :
417 : : /*
418 : : * fixup_free is called when:
419 : : * - an active object is freed
420 : : */
421 : : static int hrtimer_fixup_free(void *addr, enum debug_obj_state state)
422 : : {
423 : : struct hrtimer *timer = addr;
424 : :
425 : : switch (state) {
426 : : case ODEBUG_STATE_ACTIVE:
427 : : hrtimer_cancel(timer);
428 : : debug_object_free(timer, &hrtimer_debug_descr);
429 : : return 1;
430 : : default:
431 : : return 0;
432 : : }
433 : : }
434 : :
435 : : static struct debug_obj_descr hrtimer_debug_descr = {
436 : : .name = "hrtimer",
437 : : .debug_hint = hrtimer_debug_hint,
438 : : .fixup_init = hrtimer_fixup_init,
439 : : .fixup_activate = hrtimer_fixup_activate,
440 : : .fixup_free = hrtimer_fixup_free,
441 : : };
442 : :
443 : : static inline void debug_hrtimer_init(struct hrtimer *timer)
444 : : {
445 : : debug_object_init(timer, &hrtimer_debug_descr);
446 : : }
447 : :
448 : : static inline void debug_hrtimer_activate(struct hrtimer *timer)
449 : : {
450 : : debug_object_activate(timer, &hrtimer_debug_descr);
451 : : }
452 : :
453 : : static inline void debug_hrtimer_deactivate(struct hrtimer *timer)
454 : : {
455 : : debug_object_deactivate(timer, &hrtimer_debug_descr);
456 : : }
457 : :
458 : : static inline void debug_hrtimer_free(struct hrtimer *timer)
459 : : {
460 : : debug_object_free(timer, &hrtimer_debug_descr);
461 : : }
462 : :
463 : : static void __hrtimer_init(struct hrtimer *timer, clockid_t clock_id,
464 : : enum hrtimer_mode mode);
465 : :
466 : : void hrtimer_init_on_stack(struct hrtimer *timer, clockid_t clock_id,
467 : : enum hrtimer_mode mode)
468 : : {
469 : : debug_object_init_on_stack(timer, &hrtimer_debug_descr);
470 : : __hrtimer_init(timer, clock_id, mode);
471 : : }
472 : : EXPORT_SYMBOL_GPL(hrtimer_init_on_stack);
473 : :
474 : : void destroy_hrtimer_on_stack(struct hrtimer *timer)
475 : : {
476 : : debug_object_free(timer, &hrtimer_debug_descr);
477 : : }
478 : :
479 : : #else
480 : : static inline void debug_hrtimer_init(struct hrtimer *timer) { }
481 : : static inline void debug_hrtimer_activate(struct hrtimer *timer) { }
482 : : static inline void debug_hrtimer_deactivate(struct hrtimer *timer) { }
483 : : #endif
484 : :
485 : : static inline void
486 : : debug_init(struct hrtimer *timer, clockid_t clockid,
487 : : enum hrtimer_mode mode)
488 : : {
489 : : debug_hrtimer_init(timer);
490 : : trace_hrtimer_init(timer, clockid, mode);
491 : : }
492 : :
493 : : static inline void debug_activate(struct hrtimer *timer)
494 : : {
495 : : debug_hrtimer_activate(timer);
496 : : trace_hrtimer_start(timer);
497 : : }
498 : :
499 : : static inline void debug_deactivate(struct hrtimer *timer)
500 : : {
501 : : debug_hrtimer_deactivate(timer);
502 : : trace_hrtimer_cancel(timer);
503 : : }
504 : :
505 : : /* High resolution timer related functions */
506 : : #ifdef CONFIG_HIGH_RES_TIMERS
507 : :
508 : : /*
509 : : * High resolution timer enabled ?
510 : : */
511 : : static int hrtimer_hres_enabled __read_mostly = 1;
512 : :
513 : : /*
514 : : * Enable / Disable high resolution mode
515 : : */
516 : 0 : static int __init setup_hrtimer_hres(char *str)
517 : : {
518 [ # # ]: 0 : if (!strcmp(str, "off"))
519 : 0 : hrtimer_hres_enabled = 0;
520 [ # # ]: 0 : else if (!strcmp(str, "on"))
521 : 0 : hrtimer_hres_enabled = 1;
522 : : else
523 : : return 0;
524 : : return 1;
525 : : }
526 : :
527 : : __setup("highres=", setup_hrtimer_hres);
528 : :
529 : : /*
530 : : * hrtimer_high_res_enabled - query, if the highres mode is enabled
531 : : */
532 : : static inline int hrtimer_is_hres_enabled(void)
533 : : {
534 : 81 : return hrtimer_hres_enabled;
535 : : }
536 : :
537 : : /*
538 : : * Is the high resolution mode active ?
539 : : */
540 : : static inline int hrtimer_hres_active(void)
541 : : {
542 : 30818536 : return __this_cpu_read(hrtimer_bases.hres_active);
543 : : }
544 : :
545 : : /*
546 : : * Reprogram the event source with checking both queues for the
547 : : * next event
548 : : * Called with interrupts disabled and base->lock held
549 : : */
550 : : static void
551 : 0 : hrtimer_force_reprogram(struct hrtimer_cpu_base *cpu_base, int skip_equal)
552 : : {
553 : : int i;
554 : 4741302 : struct hrtimer_clock_base *base = cpu_base->clock_base;
555 : : ktime_t expires, expires_next;
556 : :
557 : : expires_next.tv64 = KTIME_MAX;
558 : :
559 [ + + ]: 23696268 : for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++, base++) {
560 : : struct hrtimer *timer;
561 : : struct timerqueue_node *next;
562 : :
563 : 18954966 : next = timerqueue_getnext(&base->active);
564 [ + + ]: 18954966 : if (!next)
565 : 15874594 : continue;
566 : : timer = container_of(next, struct hrtimer, node);
567 : :
568 : 3080372 : expires = ktime_sub(hrtimer_get_expires(timer), base->offset);
569 : : /*
570 : : * clock_was_set() has changed base->offset so the
571 : : * result might be negative. Fix it up to prevent a
572 : : * false positive in clockevents_program_event()
573 : : */
574 [ - + ]: 3080372 : if (expires.tv64 < 0)
575 : : expires.tv64 = 0;
576 [ + + ]: 3080372 : if (expires.tv64 < expires_next.tv64)
577 : : expires_next = expires;
578 : : }
579 : :
580 [ + + ][ + ]: 4741302 : if (skip_equal && expires_next.tv64 == cpu_base->expires_next.tv64)
581 : 433 : return;
582 : :
583 : 4746341 : cpu_base->expires_next.tv64 = expires_next.tv64;
584 : :
585 [ + + ]: 4746341 : if (cpu_base->expires_next.tv64 != KTIME_MAX)
586 : 2795939 : tick_program_event(cpu_base->expires_next, 1);
587 : : }
588 : :
589 : : /*
590 : : * Shared reprogramming for clock_realtime and clock_monotonic
591 : : *
592 : : * When a timer is enqueued and expires earlier than the already enqueued
593 : : * timers, we have to check, whether it expires earlier than the timer for
594 : : * which the clock event device was armed.
595 : : *
596 : : * Called with interrupts disabled and base->cpu_base.lock held
597 : : */
598 : 0 : static int hrtimer_reprogram(struct hrtimer *timer,
599 : : struct hrtimer_clock_base *base)
600 : : {
601 : 11327382 : struct hrtimer_cpu_base *cpu_base = &__get_cpu_var(hrtimer_bases);
602 : 5663691 : ktime_t expires = ktime_sub(hrtimer_get_expires(timer), base->offset);
603 : : int res;
604 : :
605 [ - + ][ # # ]: 5663691 : WARN_ON_ONCE(hrtimer_get_expires_tv64(timer) < 0);
[ - + ]
606 : :
607 : : /*
608 : : * When the callback is running, we do not reprogram the clock event
609 : : * device. The timer callback is either running on a different CPU or
610 : : * the callback is executed in the hrtimer_interrupt context. The
611 : : * reprogramming is handled either by the softirq, which called the
612 : : * callback or at the end of the hrtimer_interrupt.
613 : : */
614 [ + - ]: 5681733 : if (hrtimer_callback_running(timer))
615 : : return 0;
616 : :
617 : : /*
618 : : * CLOCK_REALTIME timer might be requested with an absolute
619 : : * expiry time which is less than base->offset. Nothing wrong
620 : : * about that, just avoid to call into the tick code, which
621 : : * has now objections against negative expiry values.
622 : : */
623 [ + + ]: 5681733 : if (expires.tv64 < 0)
624 : : return -ETIME;
625 : :
626 [ + + ]: 5680817 : if (expires.tv64 >= cpu_base->expires_next.tv64)
627 : : return 0;
628 : :
629 : : /*
630 : : * If a hang was detected in the last timer interrupt then we
631 : : * do not schedule a timer which is earlier than the expiry
632 : : * which we enforced in the hang detection. We want the system
633 : : * to make progress.
634 : : */
635 [ + + ]: 5112083 : if (cpu_base->hang_detected)
636 : : return 0;
637 : :
638 : : /*
639 : : * Clockevents returns -ETIME, when the event was in the past.
640 : : */
641 : 5110950 : res = tick_program_event(expires, 0);
642 [ + + ]: 10766549 : if (!IS_ERR_VALUE(res))
643 : 5102858 : cpu_base->expires_next = expires;
644 : : return res;
645 : : }
646 : :
647 : : /*
648 : : * Initialize the high resolution related parts of cpu_base
649 : : */
650 : : static inline void hrtimer_init_hres(struct hrtimer_cpu_base *base)
651 : : {
652 : 81 : base->expires_next.tv64 = KTIME_MAX;
653 : 81 : base->hres_active = 0;
654 : : }
655 : :
656 : : /*
657 : : * When High resolution timers are active, try to reprogram. Note, that in case
658 : : * the state has HRTIMER_STATE_CALLBACK set, no reprogramming and no expiry
659 : : * check happens. The timer gets enqueued into the rbtree. The reprogramming
660 : : * and expiry check is done in the hrtimer_interrupt or in the softirq.
661 : : */
662 : : static inline int hrtimer_enqueue_reprogram(struct hrtimer *timer,
663 : : struct hrtimer_clock_base *base)
664 : : {
665 [ + ][ + + ]: 5666773 : return base->cpu_base->hres_active && hrtimer_reprogram(timer, base);
666 : : }
667 : :
668 : : static inline ktime_t hrtimer_update_base(struct hrtimer_cpu_base *base)
669 : : {
670 : 3219439 : ktime_t *offs_real = &base->clock_base[HRTIMER_BASE_REALTIME].offset;
671 : 3219439 : ktime_t *offs_boot = &base->clock_base[HRTIMER_BASE_BOOTTIME].offset;
672 : 3219439 : ktime_t *offs_tai = &base->clock_base[HRTIMER_BASE_TAI].offset;
673 : :
674 : 3219667 : return ktime_get_update_offsets(offs_real, offs_boot, offs_tai);
675 : : }
676 : :
677 : : /*
678 : : * Retrigger next event is called after clock was set
679 : : *
680 : : * Called with interrupts disabled via on_each_cpu()
681 : : */
682 : 0 : static void retrigger_next_event(void *arg)
683 : : {
684 : 264 : struct hrtimer_cpu_base *base = &__get_cpu_var(hrtimer_bases);
685 : :
686 [ + ]: 132 : if (!hrtimer_hres_active())
687 : 3 : return;
688 : :
689 : 133 : raw_spin_lock(&base->lock);
690 : : hrtimer_update_base(base);
691 : 131 : hrtimer_force_reprogram(base, 0);
692 : : raw_spin_unlock(&base->lock);
693 : : }
694 : :
695 : : /*
696 : : * Switch to high resolution mode
697 : : */
698 : 0 : static int hrtimer_switch_to_hres(void)
699 : : {
700 : 81 : int i, cpu = smp_processor_id();
701 : 81 : struct hrtimer_cpu_base *base = &per_cpu(hrtimer_bases, cpu);
702 : : unsigned long flags;
703 : :
704 [ + - ]: 81 : if (base->hres_active)
705 : : return 1;
706 : :
707 : : local_irq_save(flags);
708 : :
709 [ - + ]: 81 : if (tick_init_highres()) {
710 [ # # ]: 0 : local_irq_restore(flags);
711 : 0 : printk(KERN_WARNING "Could not switch to high resolution "
712 : : "mode on CPU %d\n", cpu);
713 : 0 : return 0;
714 : : }
715 : 81 : base->hres_active = 1;
716 [ + + ]: 405 : for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++)
717 : 324 : base->clock_base[i].resolution = KTIME_HIGH_RES;
718 : :
719 : 81 : tick_setup_sched_timer();
720 : : /* "Retrigger" the interrupt to get things going */
721 : 81 : retrigger_next_event(NULL);
722 [ - + ]: 81 : local_irq_restore(flags);
723 : : return 1;
724 : : }
725 : :
726 : 0 : static void clock_was_set_work(struct work_struct *work)
727 : : {
728 : 1 : clock_was_set();
729 : 1 : }
730 : :
731 : : static DECLARE_WORK(hrtimer_work, clock_was_set_work);
732 : :
733 : : /*
734 : : * Called from timekeeping and resume code to reprogramm the hrtimer
735 : : * interrupt device on all cpus.
736 : : */
737 : 0 : void clock_was_set_delayed(void)
738 : : {
739 : : schedule_work(&hrtimer_work);
740 : 1 : }
741 : :
742 : : #else
743 : :
744 : : static inline int hrtimer_hres_active(void) { return 0; }
745 : : static inline int hrtimer_is_hres_enabled(void) { return 0; }
746 : : static inline int hrtimer_switch_to_hres(void) { return 0; }
747 : : static inline void
748 : : hrtimer_force_reprogram(struct hrtimer_cpu_base *base, int skip_equal) { }
749 : : static inline int hrtimer_enqueue_reprogram(struct hrtimer *timer,
750 : : struct hrtimer_clock_base *base)
751 : : {
752 : : return 0;
753 : : }
754 : : static inline void hrtimer_init_hres(struct hrtimer_cpu_base *base) { }
755 : : static inline void retrigger_next_event(void *arg) { }
756 : :
757 : : #endif /* CONFIG_HIGH_RES_TIMERS */
758 : :
759 : : /*
760 : : * Clock realtime was set
761 : : *
762 : : * Change the offset of the realtime clock vs. the monotonic
763 : : * clock.
764 : : *
765 : : * We might have to reprogram the high resolution timer interrupt. On
766 : : * SMP we call the architecture specific code to retrigger _all_ high
767 : : * resolution timer interrupts. On UP we just disable interrupts and
768 : : * call the high resolution interrupt code.
769 : : */
770 : 0 : void clock_was_set(void)
771 : : {
772 : : #ifdef CONFIG_HIGH_RES_TIMERS
773 : : /* Retrigger the CPU local events everywhere */
774 : 11 : on_each_cpu(retrigger_next_event, NULL, 1);
775 : : #endif
776 : 11 : timerfd_clock_was_set();
777 : 11 : }
778 : :
779 : : /*
780 : : * During resume we might have to reprogram the high resolution timer
781 : : * interrupt on all online CPUs. However, all other CPUs will be
782 : : * stopped with IRQs interrupts disabled so the clock_was_set() call
783 : : * must be deferred.
784 : : */
785 : 0 : void hrtimers_resume(void)
786 : : {
787 [ # # ][ # # ]: 0 : WARN_ONCE(!irqs_disabled(),
[ # # ]
788 : : KERN_INFO "hrtimers_resume() called with IRQs enabled!");
789 : :
790 : : /* Retrigger on the local CPU */
791 : 0 : retrigger_next_event(NULL);
792 : : /* And schedule a retrigger for all others */
793 : : clock_was_set_delayed();
794 : 0 : }
795 : :
796 : : static inline void timer_stats_hrtimer_set_start_info(struct hrtimer *timer)
797 : : {
798 : : #ifdef CONFIG_TIMER_STATS
799 [ + + ]: 5988297 : if (timer->start_site)
800 : : return;
801 : 5963656 : timer->start_site = __builtin_return_address(0);
802 : 11923078 : memcpy(timer->start_comm, current->comm, TASK_COMM_LEN);
803 : 5961539 : timer->start_pid = current->pid;
804 : : #endif
805 : : }
806 : :
807 : : static inline void timer_stats_hrtimer_clear_start_info(struct hrtimer *timer)
808 : : {
809 : : #ifdef CONFIG_TIMER_STATS
810 : 0 : timer->start_site = NULL;
811 : : #endif
812 : : }
813 : :
814 : : static inline void timer_stats_account_hrtimer(struct hrtimer *timer)
815 : : {
816 : : #ifdef CONFIG_TIMER_STATS
817 [ - + ]: 2938094 : if (likely(!timer_stats_active))
818 : : return;
819 : 0 : timer_stats_update_stats(timer, timer->start_pid, timer->start_site,
820 : 0 : timer->function, timer->start_comm, 0);
821 : : #endif
822 : : }
823 : :
824 : : /*
825 : : * Counterpart to lock_hrtimer_base above:
826 : : */
827 : : static inline
828 : : void unlock_hrtimer_base(const struct hrtimer *timer, unsigned long *flags)
829 : : {
830 : 12198913 : raw_spin_unlock_irqrestore(&timer->base->cpu_base->lock, *flags);
831 : : }
832 : :
833 : : /**
834 : : * hrtimer_forward - forward the timer expiry
835 : : * @timer: hrtimer to forward
836 : : * @now: forward past this time
837 : : * @interval: the interval to forward
838 : : *
839 : : * Forward the timer expiry so it will expire in the future.
840 : : * Returns the number of overruns.
841 : : */
842 : 0 : u64 hrtimer_forward(struct hrtimer *timer, ktime_t now, ktime_t interval)
843 : : {
844 : : u64 orun = 1;
845 : : ktime_t delta;
846 : :
847 : 5684529 : delta = ktime_sub(now, hrtimer_get_expires(timer));
848 : :
849 [ + + ]: 5684529 : if (delta.tv64 < 0)
850 : : return 0;
851 : :
852 [ - + ]: 3539333 : if (interval.tv64 < timer->base->resolution.tv64)
853 : : interval.tv64 = timer->base->resolution.tv64;
854 : :
855 [ + + ]: 3539333 : if (unlikely(delta.tv64 >= interval.tv64)) {
856 : : s64 incr = ktime_to_ns(interval);
857 : :
858 : 296136 : orun = ktime_divns(delta, incr);
859 : 289577 : hrtimer_add_expires_ns(timer, incr * orun);
860 [ + ]: 289577 : if (hrtimer_get_expires_tv64(timer) > now.tv64)
861 : : return orun;
862 : : /*
863 : : * This (and the ktime_add() below) is the
864 : : * correction for exact:
865 : : */
866 : 291032 : orun++;
867 : : }
868 : : hrtimer_add_expires(timer, interval);
869 : :
870 : 3549428 : return orun;
871 : : }
872 : : EXPORT_SYMBOL_GPL(hrtimer_forward);
873 : :
874 : : /*
875 : : * enqueue_hrtimer - internal function to (re)start a timer
876 : : *
877 : : * The timer is inserted in expiry order. Insertion into the
878 : : * red black tree is O(log(n)). Must hold the base lock.
879 : : *
880 : : * Returns 1 when the new timer is the leftmost timer in the tree.
881 : : */
882 : 0 : static int enqueue_hrtimer(struct hrtimer *timer,
883 : : struct hrtimer_clock_base *base)
884 : : {
885 : : debug_activate(timer);
886 : :
887 : 8560429 : timerqueue_add(&base->active, &timer->node);
888 : 8577502 : base->cpu_base->active_bases |= 1 << base->index;
889 : :
890 : : /*
891 : : * HRTIMER_STATE_ENQUEUED is or'ed to the current state to preserve the
892 : : * state of a possibly running callback.
893 : : */
894 : 8577502 : timer->state |= HRTIMER_STATE_ENQUEUED;
895 : :
896 : 8577502 : return (&timer->node == base->active.next);
897 : : }
898 : :
899 : : /*
900 : : * __remove_hrtimer - internal function to remove a timer
901 : : *
902 : : * Caller must hold the base lock.
903 : : *
904 : : * High resolution timer mode reprograms the clock event device when the
905 : : * timer is the one which expires next. The caller can disable this by setting
906 : : * reprogram to zero. This is useful, when the context does a reprogramming
907 : : * anyway (e.g. timer interrupt)
908 : : */
909 : 0 : static void __remove_hrtimer(struct hrtimer *timer,
910 : : struct hrtimer_clock_base *base,
911 : : unsigned long newstate, int reprogram)
912 : : {
913 : : struct timerqueue_node *next_timer;
914 [ + ]: 8551287 : if (!(timer->state & HRTIMER_STATE_ENQUEUED))
915 : : goto out;
916 : :
917 : 17144057 : next_timer = timerqueue_getnext(&base->active);
918 : 8551555 : timerqueue_del(&base->active, &timer->node);
919 [ + + ]: 8546665 : if (&timer->node == next_timer) {
920 : : #ifdef CONFIG_HIGH_RES_TIMERS
921 : : /* Reprogram the clock event device. if enabled */
922 [ + + ][ + + ]: 8314172 : if (reprogram && hrtimer_hres_active()) {
923 : : ktime_t expires;
924 : :
925 : 5353908 : expires = ktime_sub(hrtimer_get_expires(timer),
926 : : base->offset);
927 [ + + ]: 5353908 : if (base->cpu_base->expires_next.tv64 == expires.tv64)
928 : 4739162 : hrtimer_force_reprogram(base->cpu_base, 1);
929 : : }
930 : : #endif
931 : : }
932 [ + + ]: 17143789 : if (!timerqueue_getnext(&base->active))
933 : 4299131 : base->cpu_base->active_bases &= ~(1 << base->index);
934 : : out:
935 : 8592234 : timer->state = newstate;
936 : 8592234 : }
937 : :
938 : : /*
939 : : * remove hrtimer, called with base lock held
940 : : */
941 : : static inline int
942 : 5990223 : remove_hrtimer(struct hrtimer *timer, struct hrtimer_clock_base *base)
943 : : {
944 [ + + + + ]: 12205546 : if (hrtimer_is_queued(timer)) {
945 : : unsigned long state;
946 : : int reprogram;
947 : :
948 : : /*
949 : : * Remove the timer and force reprogramming when high
950 : : * resolution mode is active and the timer is on the current
951 : : * CPU. If we remove a timer on another CPU, reprogramming is
952 : : * skipped. The interrupt event on this CPU is fired and
953 : : * reprogramming happens in the interrupt handler. This is a
954 : : * rare case and less expensive than a smp call.
955 : : */
956 : : debug_deactivate(timer);
957 : : timer_stats_hrtimer_clear_start_info(timer);
958 : 0 : reprogram = base->cpu_base == &__get_cpu_var(hrtimer_bases);
959 : : /*
960 : : * We must preserve the CALLBACK state flag here,
961 : : * otherwise we could move the timer base in
962 : : * switch_hrtimer_base.
963 : : */
964 : 0 : state = timer->state & HRTIMER_STATE_CALLBACK;
965 : 8318388 : __remove_hrtimer(timer, base, state, reprogram);
966 : : return 1;
967 : : }
968 : : return 0;
969 : : }
970 : :
971 : 0 : int __hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim,
972 : : unsigned long delta_ns, const enum hrtimer_mode mode,
973 : : int wakeup)
974 : : {
975 : : struct hrtimer_clock_base *base, *new_base;
976 : : unsigned long flags;
977 : : int ret, leftmost;
978 : :
979 : 5976497 : base = lock_hrtimer_base(timer, &flags);
980 : :
981 : : /* Remove an active timer from the queue: */
982 : : ret = remove_hrtimer(timer, base);
983 : :
984 : : /* Switch the timer base, if necessary: */
985 : 5990754 : new_base = switch_hrtimer_base(timer, base, mode & HRTIMER_MODE_PINNED);
986 : :
987 [ + + ]: 5979035 : if (mode & HRTIMER_MODE_REL) {
988 : 276300 : tim = ktime_add_safe(tim, new_base->get_time());
989 : : /*
990 : : * CONFIG_TIME_LOW_RES is a temporary way for architectures
991 : : * to signal that they simply return xtime in
992 : : * do_gettimeoffset(). In this case we want to round up by
993 : : * resolution when starting a relative timer, to avoid short
994 : : * timeouts. This will go away with the GTOD framework.
995 : : */
996 : : #ifdef CONFIG_TIME_LOW_RES
997 : : tim = ktime_add_safe(tim, base->resolution);
998 : : #endif
999 : : }
1000 : :
1001 : : hrtimer_set_expires_range_ns(timer, tim, delta_ns);
1002 : :
1003 : : timer_stats_hrtimer_set_start_info(timer);
1004 : :
1005 : 5986180 : leftmost = enqueue_hrtimer(timer, new_base);
1006 : :
1007 : : /*
1008 : : * Only allow reprogramming if the new base is on this CPU.
1009 : : * (it might still be on another CPU if the timer was pending)
1010 : : *
1011 : : * XXX send_remote_softirq() ?
1012 : : */
1013 [ + + ][ + + ]: 5976847 : if (leftmost && new_base->cpu_base == &__get_cpu_var(hrtimer_bases)
1014 [ + + ]: 5672783 : && hrtimer_enqueue_reprogram(timer, new_base)) {
1015 [ + - ]: 5246 : if (wakeup) {
1016 : : /*
1017 : : * We need to drop cpu_base->lock to avoid a
1018 : : * lock ordering issue vs. rq->lock.
1019 : : */
1020 : 5246 : raw_spin_unlock(&new_base->cpu_base->lock);
1021 : 5250 : raise_softirq_irqoff(HRTIMER_SOFTIRQ);
1022 [ + + ]: 5250 : local_irq_restore(flags);
1023 : : return ret;
1024 : : } else {
1025 : 0 : __raise_softirq_irqoff(HRTIMER_SOFTIRQ);
1026 : : }
1027 : : }
1028 : :
1029 : 5977611 : unlock_hrtimer_base(timer, &flags);
1030 : :
1031 : 5984633 : return ret;
1032 : : }
1033 : :
1034 : : /**
1035 : : * hrtimer_start_range_ns - (re)start an hrtimer on the current CPU
1036 : : * @timer: the timer to be added
1037 : : * @tim: expiry time
1038 : : * @delta_ns: "slack" range for the timer
1039 : : * @mode: expiry mode: absolute (HRTIMER_MODE_ABS) or
1040 : : * relative (HRTIMER_MODE_REL)
1041 : : *
1042 : : * Returns:
1043 : : * 0 on success
1044 : : * 1 when the timer was active
1045 : : */
1046 : 0 : int hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim,
1047 : : unsigned long delta_ns, const enum hrtimer_mode mode)
1048 : : {
1049 : 3860776 : return __hrtimer_start_range_ns(timer, tim, delta_ns, mode, 1);
1050 : : }
1051 : : EXPORT_SYMBOL_GPL(hrtimer_start_range_ns);
1052 : :
1053 : : /**
1054 : : * hrtimer_start - (re)start an hrtimer on the current CPU
1055 : : * @timer: the timer to be added
1056 : : * @tim: expiry time
1057 : : * @mode: expiry mode: absolute (HRTIMER_MODE_ABS) or
1058 : : * relative (HRTIMER_MODE_REL)
1059 : : *
1060 : : * Returns:
1061 : : * 0 on success
1062 : : * 1 when the timer was active
1063 : : */
1064 : : int
1065 : 0 : hrtimer_start(struct hrtimer *timer, ktime_t tim, const enum hrtimer_mode mode)
1066 : : {
1067 : 2113071 : return __hrtimer_start_range_ns(timer, tim, 0, mode, 1);
1068 : : }
1069 : : EXPORT_SYMBOL_GPL(hrtimer_start);
1070 : :
1071 : :
1072 : : /**
1073 : : * hrtimer_try_to_cancel - try to deactivate a timer
1074 : : * @timer: hrtimer to stop
1075 : : *
1076 : : * Returns:
1077 : : * 0 when the timer was not active
1078 : : * 1 when the timer was active
1079 : : * -1 when the timer is currently excuting the callback function and
1080 : : * cannot be stopped
1081 : : */
1082 : 0 : int hrtimer_try_to_cancel(struct hrtimer *timer)
1083 : : {
1084 : : struct hrtimer_clock_base *base;
1085 : : unsigned long flags;
1086 : : int ret = -1;
1087 : :
1088 : 6211146 : base = lock_hrtimer_base(timer, &flags);
1089 : :
1090 [ + + ]: 6215794 : if (!hrtimer_callback_running(timer))
1091 : : ret = remove_hrtimer(timer, base);
1092 : :
1093 : 6215990 : unlock_hrtimer_base(timer, &flags);
1094 : :
1095 : 6219414 : return ret;
1096 : :
1097 : : }
1098 : : EXPORT_SYMBOL_GPL(hrtimer_try_to_cancel);
1099 : :
1100 : : /**
1101 : : * hrtimer_cancel - cancel a timer and wait for the handler to finish.
1102 : : * @timer: the timer to be cancelled
1103 : : *
1104 : : * Returns:
1105 : : * 0 when the timer was not active
1106 : : * 1 when the timer was active
1107 : : */
1108 : 5932496 : int hrtimer_cancel(struct hrtimer *timer)
1109 : : {
1110 : : for (;;) {
1111 : 6198545 : int ret = hrtimer_try_to_cancel(timer);
1112 : :
1113 [ + - + - : 6242717 : if (ret >= 0)
+ - ]
1114 : 5935504 : return ret;
1115 : 758 : cpu_relax();
1116 : 0 : }
1117 : : }
1118 : : EXPORT_SYMBOL_GPL(hrtimer_cancel);
1119 : :
1120 : : /**
1121 : : * hrtimer_get_remaining - get remaining time for the timer
1122 : : * @timer: the timer to read
1123 : : */
1124 : 0 : ktime_t hrtimer_get_remaining(const struct hrtimer *timer)
1125 : : {
1126 : : unsigned long flags;
1127 : : ktime_t rem;
1128 : :
1129 : 5312 : lock_hrtimer_base(timer, &flags);
1130 : : rem = hrtimer_expires_remaining(timer);
1131 : 5312 : unlock_hrtimer_base(timer, &flags);
1132 : :
1133 : 5312 : return rem;
1134 : : }
1135 : : EXPORT_SYMBOL_GPL(hrtimer_get_remaining);
1136 : :
1137 : : #ifdef CONFIG_NO_HZ_COMMON
1138 : : /**
1139 : : * hrtimer_get_next_event - get the time until next expiry event
1140 : : *
1141 : : * Returns the delta to the next expiry event or KTIME_MAX if no timer
1142 : : * is pending.
1143 : : */
1144 : 0 : ktime_t hrtimer_get_next_event(void)
1145 : : {
1146 : 9896916 : struct hrtimer_cpu_base *cpu_base = &__get_cpu_var(hrtimer_bases);
1147 : 4948458 : struct hrtimer_clock_base *base = cpu_base->clock_base;
1148 : : ktime_t delta, mindelta = { .tv64 = KTIME_MAX };
1149 : : unsigned long flags;
1150 : : int i;
1151 : :
1152 : 4948458 : raw_spin_lock_irqsave(&cpu_base->lock, flags);
1153 : :
1154 [ - + ]: 4948526 : if (!hrtimer_hres_active()) {
1155 [ # # ]: 0 : for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++, base++) {
1156 : 0 : struct hrtimer *timer;
1157 : : struct timerqueue_node *next;
1158 : :
1159 : 0 : next = timerqueue_getnext(&base->active);
1160 [ # # ]: 0 : if (!next)
1161 : 0 : continue;
1162 : :
1163 : : timer = container_of(next, struct hrtimer, node);
1164 : : delta.tv64 = hrtimer_get_expires_tv64(timer);
1165 : 0 : delta = ktime_sub(delta, base->get_time());
1166 [ # # ]: 0 : if (delta.tv64 < mindelta.tv64)
1167 : : mindelta.tv64 = delta.tv64;
1168 : : }
1169 : : }
1170 : :
1171 : 4948526 : raw_spin_unlock_irqrestore(&cpu_base->lock, flags);
1172 : :
1173 [ - + ]: 4948138 : if (mindelta.tv64 < 0)
1174 : : mindelta.tv64 = 0;
1175 : 4948138 : return mindelta;
1176 : : }
1177 : : #endif
1178 : :
1179 : 0 : static void __hrtimer_init(struct hrtimer *timer, clockid_t clock_id,
1180 : : enum hrtimer_mode mode)
1181 : : {
1182 : : struct hrtimer_cpu_base *cpu_base;
1183 : : int base;
1184 : :
1185 : 2967886 : memset(timer, 0, sizeof(struct hrtimer));
1186 : :
1187 : 5935226 : cpu_base = &__raw_get_cpu_var(hrtimer_bases);
1188 : :
1189 [ + + ]: 2967613 : if (clock_id == CLOCK_REALTIME && mode != HRTIMER_MODE_ABS)
1190 : : clock_id = CLOCK_MONOTONIC;
1191 : :
1192 : : base = hrtimer_clockid_to_base(clock_id);
1193 : 0 : timer->base = &cpu_base->clock_base[base];
1194 : : timerqueue_init(&timer->node);
1195 : :
1196 : : #ifdef CONFIG_TIMER_STATS
1197 : 0 : timer->start_site = NULL;
1198 : 0 : timer->start_pid = -1;
1199 : 2967613 : memset(timer->start_comm, 0, TASK_COMM_LEN);
1200 : : #endif
1201 : 2967381 : }
1202 : :
1203 : : /**
1204 : : * hrtimer_init - initialize a timer to the given clock
1205 : : * @timer: the timer to be initialized
1206 : : * @clock_id: the clock to be used
1207 : : * @mode: timer mode abs/rel
1208 : : */
1209 : 0 : void hrtimer_init(struct hrtimer *timer, clockid_t clock_id,
1210 : : enum hrtimer_mode mode)
1211 : : {
1212 : : debug_init(timer, clock_id, mode);
1213 : 2967238 : __hrtimer_init(timer, clock_id, mode);
1214 : 2967396 : }
1215 : : EXPORT_SYMBOL_GPL(hrtimer_init);
1216 : :
1217 : : /**
1218 : : * hrtimer_get_res - get the timer resolution for a clock
1219 : : * @which_clock: which clock to query
1220 : : * @tp: pointer to timespec variable to store the resolution
1221 : : *
1222 : : * Store the resolution of the clock selected by @which_clock in the
1223 : : * variable pointed to by @tp.
1224 : : */
1225 : 0 : int hrtimer_get_res(const clockid_t which_clock, struct timespec *tp)
1226 : : {
1227 : : struct hrtimer_cpu_base *cpu_base;
1228 : : int base = hrtimer_clockid_to_base(which_clock);
1229 : :
1230 : 14 : cpu_base = &__raw_get_cpu_var(hrtimer_bases);
1231 : 7 : *tp = ktime_to_timespec(cpu_base->clock_base[base].resolution);
1232 : :
1233 : 7 : return 0;
1234 : : }
1235 : : EXPORT_SYMBOL_GPL(hrtimer_get_res);
1236 : :
1237 : 0 : static void __run_hrtimer(struct hrtimer *timer, ktime_t *now)
1238 : : {
1239 : 2955697 : struct hrtimer_clock_base *base = timer->base;
1240 : 2955697 : struct hrtimer_cpu_base *cpu_base = base->cpu_base;
1241 : : enum hrtimer_restart (*fn)(struct hrtimer *);
1242 : : int restart;
1243 : :
1244 [ - + ]: 2953530 : WARN_ON(!irqs_disabled());
1245 : :
1246 : : debug_deactivate(timer);
1247 : 2964195 : __remove_hrtimer(timer, base, HRTIMER_STATE_CALLBACK, 0);
1248 : : timer_stats_account_hrtimer(timer);
1249 : 2938094 : fn = timer->function;
1250 : :
1251 : : /*
1252 : : * Because we run timers from hardirq context, there is no chance
1253 : : * they get migrated to another cpu, therefore its safe to unlock
1254 : : * the timer base.
1255 : : */
1256 : : raw_spin_unlock(&cpu_base->lock);
1257 : : trace_hrtimer_expire_entry(timer, now);
1258 : 2962801 : restart = fn(timer);
1259 : : trace_hrtimer_expire_exit(timer);
1260 : 2968643 : raw_spin_lock(&cpu_base->lock);
1261 : :
1262 : : /*
1263 : : * Note: We clear the CALLBACK bit after enqueue_hrtimer and
1264 : : * we do not reprogramm the event hardware. Happens either in
1265 : : * hrtimer_start_range_ns() or in hrtimer_interrupt()
1266 : : */
1267 [ + + ]: 2964853 : if (restart != HRTIMER_NORESTART) {
1268 [ - + ]: 2607092 : BUG_ON(timer->state != HRTIMER_STATE_CALLBACK);
1269 : 2607092 : enqueue_hrtimer(timer, base);
1270 : : }
1271 : :
1272 [ - + ][ # # ]: 2970470 : WARN_ON_ONCE(!(timer->state & HRTIMER_STATE_CALLBACK));
[ # # ]
1273 : :
1274 : 2970470 : timer->state &= ~HRTIMER_STATE_CALLBACK;
1275 : 2970470 : }
1276 : :
1277 : : #ifdef CONFIG_HIGH_RES_TIMERS
1278 : :
1279 : : /*
1280 : : * High resolution timer interrupt
1281 : : * Called with interrupts disabled
1282 : : */
1283 : 0 : void hrtimer_interrupt(struct clock_event_device *dev)
1284 : : {
1285 : 6415602 : struct hrtimer_cpu_base *cpu_base = &__get_cpu_var(hrtimer_bases);
1286 : : ktime_t expires_next, now, entry_time, delta;
1287 : : int i, retries = 0;
1288 : :
1289 [ - + ]: 3207801 : BUG_ON(!cpu_base->hres_active);
1290 : 3207801 : cpu_base->nr_events++;
1291 : 3207801 : dev->next_event.tv64 = KTIME_MAX;
1292 : :
1293 : 3207801 : raw_spin_lock(&cpu_base->lock);
1294 : : entry_time = now = hrtimer_update_base(cpu_base);
1295 : : retry:
1296 : : expires_next.tv64 = KTIME_MAX;
1297 : : /*
1298 : : * We set expires_next to KTIME_MAX here with cpu_base->lock
1299 : : * held to prevent that a timer is enqueued in our queue via
1300 : : * the migration code. This does not affect enqueueing of
1301 : : * timers which run their callback and need to be requeued on
1302 : : * this CPU.
1303 : : */
1304 : 3212879 : cpu_base->expires_next.tv64 = KTIME_MAX;
1305 : :
1306 [ + + ]: 16149547 : for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++) {
1307 : : struct hrtimer_clock_base *base;
1308 : : struct timerqueue_node *node;
1309 : : ktime_t basenow;
1310 : :
1311 [ + + ]: 12897371 : if (!(cpu_base->active_bases & (1 << i)))
1312 : 9922442 : continue;
1313 : :
1314 : 2974929 : base = cpu_base->clock_base + i;
1315 : 2974929 : basenow = ktime_add(now, base->offset);
1316 : :
1317 [ + + ]: 12035968 : while ((node = timerqueue_getnext(&base->active))) {
1318 : 5813941 : struct hrtimer *timer;
1319 : :
1320 : : timer = container_of(node, struct hrtimer, node);
1321 : :
1322 : : /*
1323 : : * The immediate goal for using the softexpires is
1324 : : * minimizing wakeups, not running timers at the
1325 : : * earliest interrupt after their soft expiration.
1326 : : * This allows us to avoid using a Priority Search
1327 : : * Tree, which can answer a stabbing querry for
1328 : : * overlapping intervals and instead use the simple
1329 : : * BST we already have.
1330 : : * We don't add extra wakeups by delaying timers that
1331 : : * are right-of a not yet expired timer, because that
1332 : : * timer will have to trigger a wakeup anyway.
1333 : : */
1334 : :
1335 [ + + ]: 5813941 : if (basenow.tv64 < hrtimer_get_softexpires_tv64(timer)) {
1336 : : ktime_t expires;
1337 : :
1338 : 2830860 : expires = ktime_sub(hrtimer_get_expires(timer),
1339 : : base->offset);
1340 [ - + ]: 2830860 : if (expires.tv64 < 0)
1341 : : expires.tv64 = KTIME_MAX;
1342 [ + ]: 2830860 : if (expires.tv64 < expires_next.tv64)
1343 : : expires_next = expires;
1344 : : break;
1345 : : }
1346 : :
1347 : 2983081 : __run_hrtimer(timer, &basenow);
1348 : : }
1349 : : }
1350 : :
1351 : : /*
1352 : : * Store the new expiry value so the migration code can verify
1353 : : * against it.
1354 : : */
1355 : 3252176 : cpu_base->expires_next = expires_next;
1356 : : raw_spin_unlock(&cpu_base->lock);
1357 : :
1358 : : /* Reprogramming necessary ? */
1359 [ + + + + ]: 6148165 : if (expires_next.tv64 == KTIME_MAX ||
1360 : 2881294 : !tick_program_event(expires_next, 0)) {
1361 : 3266649 : cpu_base->hang_detected = 0;
1362 : 3266649 : return;
1363 : : }
1364 : :
1365 : : /*
1366 : : * The next timer was already expired due to:
1367 : : * - tracing
1368 : : * - long lasting callbacks
1369 : : * - being scheduled away when running in a VM
1370 : : *
1371 : : * We need to prevent that we loop forever in the hrtimer
1372 : : * interrupt routine. We give it 3 attempts to avoid
1373 : : * overreacting on some spurious event.
1374 : : *
1375 : : * Acquire base lock for updating the offsets and retrieving
1376 : : * the current time.
1377 : : */
1378 : 222 : raw_spin_lock(&cpu_base->lock);
1379 : 223 : now = hrtimer_update_base(cpu_base);
1380 : 223 : cpu_base->nr_retries++;
1381 [ + - ]: 223 : if (++retries < 3)
1382 : : goto retry;
1383 : : /*
1384 : : * Give the system a chance to do something else than looping
1385 : : * here. We stored the entry time, so we know exactly how long
1386 : : * we spent here. We schedule the next event this amount of
1387 : : * time away.
1388 : : */
1389 : 0 : cpu_base->nr_hangs++;
1390 : 0 : cpu_base->hang_detected = 1;
1391 : : raw_spin_unlock(&cpu_base->lock);
1392 : 0 : delta = ktime_sub(now, entry_time);
1393 [ # # ]: 0 : if (delta.tv64 > cpu_base->max_hang_time.tv64)
1394 : 0 : cpu_base->max_hang_time = delta;
1395 : : /*
1396 : : * Limit it to a sensible value as we enforce a longer
1397 : : * delay. Give the CPU at least 100ms to catch up.
1398 : : */
1399 [ # # ]: 0 : if (delta.tv64 > 100 * NSEC_PER_MSEC)
1400 : 0 : expires_next = ktime_add_ns(now, 100 * NSEC_PER_MSEC);
1401 : : else
1402 : 0 : expires_next = ktime_add(now, delta);
1403 : 0 : tick_program_event(expires_next, 1);
1404 [ # # ]: 0 : printk_once(KERN_WARNING "hrtimer: interrupt took %llu ns\n",
1405 : : ktime_to_ns(delta));
1406 : : }
1407 : :
1408 : : /*
1409 : : * local version of hrtimer_peek_ahead_timers() called with interrupts
1410 : : * disabled.
1411 : : */
1412 : 0 : static void __hrtimer_peek_ahead_timers(void)
1413 : : {
1414 : : struct tick_device *td;
1415 : :
1416 [ + + ]: 5328 : if (!hrtimer_hres_active())
1417 : 1 : return;
1418 : :
1419 : 10650 : td = &__get_cpu_var(tick_cpu_device);
1420 [ + ][ + - ]: 5325 : if (td && td->evtdev)
1421 : 5327 : hrtimer_interrupt(td->evtdev);
1422 : : }
1423 : :
1424 : : /**
1425 : : * hrtimer_peek_ahead_timers -- run soft-expired timers now
1426 : : *
1427 : : * hrtimer_peek_ahead_timers will peek at the timer queue of
1428 : : * the current cpu and check if there are any timers for which
1429 : : * the soft expires time has passed. If any such timers exist,
1430 : : * they are run immediately and then removed from the timer queue.
1431 : : *
1432 : : */
1433 : 0 : void hrtimer_peek_ahead_timers(void)
1434 : : {
1435 : : unsigned long flags;
1436 : :
1437 : : local_irq_save(flags);
1438 : 5246 : __hrtimer_peek_ahead_timers();
1439 [ - + ]: 5250 : local_irq_restore(flags);
1440 : 5249 : }
1441 : :
1442 : 0 : static void run_hrtimer_softirq(struct softirq_action *h)
1443 : : {
1444 : 5247 : hrtimer_peek_ahead_timers();
1445 : 5249 : }
1446 : :
1447 : : #else /* CONFIG_HIGH_RES_TIMERS */
1448 : :
1449 : : static inline void __hrtimer_peek_ahead_timers(void) { }
1450 : :
1451 : : #endif /* !CONFIG_HIGH_RES_TIMERS */
1452 : :
1453 : : /*
1454 : : * Called from timer softirq every jiffy, expire hrtimers:
1455 : : *
1456 : : * For HRT its the fall back code to run the softirq in the timer
1457 : : * softirq context in case the hrtimer initialization failed or has
1458 : : * not been done yet.
1459 : : */
1460 : 0 : void hrtimer_run_pending(void)
1461 : : {
1462 [ + + ]: 2546933 : if (hrtimer_hres_active())
1463 : 0 : return;
1464 : :
1465 : : /*
1466 : : * This _is_ ugly: We have to check in the softirq context,
1467 : : * whether we can switch to highres and / or nohz mode. The
1468 : : * clocksource switch happens in the timer interrupt with
1469 : : * xtime_lock held. Notification from there only sets the
1470 : : * check bit in the tick_oneshot code, otherwise we might
1471 : : * deadlock vs. xtime_lock.
1472 : : */
1473 [ + - ]: 81 : if (tick_check_oneshot_change(!hrtimer_is_hres_enabled()))
1474 : 81 : hrtimer_switch_to_hres();
1475 : : }
1476 : :
1477 : : /*
1478 : : * Called from hardirq context every jiffy
1479 : : */
1480 : 0 : void hrtimer_run_queues(void)
1481 : : {
1482 : : struct timerqueue_node *node;
1483 : 5093848 : struct hrtimer_cpu_base *cpu_base = &__get_cpu_var(hrtimer_bases);
1484 : : struct hrtimer_clock_base *base;
1485 : : int index, gettime = 1;
1486 : :
1487 [ + + ]: 2546924 : if (hrtimer_hres_active())
1488 : 2546924 : return;
1489 : :
1490 [ + + ]: 410 : for (index = 0; index < HRTIMER_MAX_CLOCK_BASES; index++) {
1491 : 328 : base = &cpu_base->clock_base[index];
1492 [ + - ]: 328 : if (!timerqueue_getnext(&base->active))
1493 : 328 : continue;
1494 : :
1495 [ # # ]: 0 : if (gettime) {
1496 : 0 : hrtimer_get_softirq_time(cpu_base);
1497 : : gettime = 0;
1498 : : }
1499 : :
1500 : 0 : raw_spin_lock(&cpu_base->lock);
1501 : :
1502 [ # # ]: 0 : while ((node = timerqueue_getnext(&base->active))) {
1503 : 0 : struct hrtimer *timer;
1504 : :
1505 : : timer = container_of(node, struct hrtimer, node);
1506 [ # # ]: 0 : if (base->softirq_time.tv64 <=
1507 : : hrtimer_get_expires_tv64(timer))
1508 : : break;
1509 : :
1510 : 0 : __run_hrtimer(timer, &base->softirq_time);
1511 : : }
1512 : : raw_spin_unlock(&cpu_base->lock);
1513 : : }
1514 : : }
1515 : :
1516 : : /*
1517 : : * Sleep related functions:
1518 : : */
1519 : 0 : static enum hrtimer_restart hrtimer_wakeup(struct hrtimer *timer)
1520 : : {
1521 : : struct hrtimer_sleeper *t =
1522 : : container_of(timer, struct hrtimer_sleeper, timer);
1523 : 367285 : struct task_struct *task = t->task;
1524 : :
1525 : 367285 : t->task = NULL;
1526 [ + + ]: 367285 : if (task)
1527 : 367276 : wake_up_process(task);
1528 : :
1529 : 0 : return HRTIMER_NORESTART;
1530 : : }
1531 : :
1532 : 0 : void hrtimer_init_sleeper(struct hrtimer_sleeper *sl, struct task_struct *task)
1533 : : {
1534 : 760658 : sl->timer.function = hrtimer_wakeup;
1535 : 265530 : sl->task = task;
1536 : 493259 : }
1537 : : EXPORT_SYMBOL_GPL(hrtimer_init_sleeper);
1538 : :
1539 : 0 : static int __sched do_nanosleep(struct hrtimer_sleeper *t, enum hrtimer_mode mode)
1540 : : {
1541 : 265530 : hrtimer_init_sleeper(t, current);
1542 : :
1543 : : do {
1544 : 265530 : set_current_state(TASK_INTERRUPTIBLE);
1545 : 531755 : hrtimer_start_expires(&t->timer, mode);
1546 [ + + ]: 266534 : if (!hrtimer_active(&t->timer))
1547 : 5073 : t->task = NULL;
1548 : :
1549 [ + + ]: 266534 : if (likely(t->task))
1550 : : freezable_schedule();
1551 : :
1552 : : hrtimer_cancel(&t->timer);
1553 : : mode = HRTIMER_MODE_ABS;
1554 : :
1555 [ + + ][ - + ]: 266415 : } while (t->task && !signal_pending(current));
1556 : :
1557 : 266415 : __set_current_state(TASK_RUNNING);
1558 : :
1559 : 266415 : return t->task == NULL;
1560 : : }
1561 : :
1562 : 0 : static int update_rmtp(struct hrtimer *timer, struct timespec __user *rmtp)
1563 : : {
1564 : : struct timespec rmt;
1565 : : ktime_t rem;
1566 : :
1567 : : rem = hrtimer_expires_remaining(timer);
1568 [ + - ]: 245 : if (rem.tv64 <= 0)
1569 : : return 0;
1570 : 245 : rmt = ktime_to_timespec(rem);
1571 : :
1572 [ + - ]: 490 : if (copy_to_user(rmtp, &rmt, sizeof(*rmtp)))
1573 : : return -EFAULT;
1574 : :
1575 : 245 : return 1;
1576 : : }
1577 : :
1578 : 0 : long __sched hrtimer_nanosleep_restart(struct restart_block *restart)
1579 : : {
1580 : : struct hrtimer_sleeper t;
1581 : : struct timespec __user *rmtp;
1582 : : int ret = 0;
1583 : :
1584 : 1 : hrtimer_init_on_stack(&t.timer, restart->nanosleep.clockid,
1585 : : HRTIMER_MODE_ABS);
1586 : 1 : hrtimer_set_expires_tv64(&t.timer, restart->nanosleep.expires);
1587 : :
1588 [ - + ]: 1 : if (do_nanosleep(&t, HRTIMER_MODE_ABS))
1589 : : goto out;
1590 : :
1591 : 0 : rmtp = restart->nanosleep.rmtp;
1592 [ # # ]: 0 : if (rmtp) {
1593 : 0 : ret = update_rmtp(&t.timer, rmtp);
1594 [ # # ]: 0 : if (ret <= 0)
1595 : : goto out;
1596 : : }
1597 : :
1598 : : /* The other values in restart are already filled in */
1599 : : ret = -ERESTART_RESTARTBLOCK;
1600 : : out:
1601 : : destroy_hrtimer_on_stack(&t.timer);
1602 : 0 : return ret;
1603 : : }
1604 : :
1605 : 0 : long hrtimer_nanosleep(struct timespec *rqtp, struct timespec __user *rmtp,
1606 : : const enum hrtimer_mode mode, const clockid_t clockid)
1607 : : {
1608 : : struct restart_block *restart;
1609 : : struct hrtimer_sleeper t;
1610 : : int ret = 0;
1611 : : unsigned long slack;
1612 : :
1613 : 265450 : slack = current->timer_slack_ns;
1614 [ + ][ + + ]: 530919 : if (dl_task(current) || rt_task(current))
1615 : : slack = 0;
1616 : :
1617 : : hrtimer_init_on_stack(&t.timer, clockid, mode);
1618 : : hrtimer_set_expires_range_ns(&t.timer, timespec_to_ktime(*rqtp), slack);
1619 [ + + ]: 265991 : if (do_nanosleep(&t, mode))
1620 : : goto out;
1621 : :
1622 : : /* Absolute timers do not update the rmtp value and restart: */
1623 [ + - ]: 260 : if (mode == HRTIMER_MODE_ABS) {
1624 : : ret = -ERESTARTNOHAND;
1625 : : goto out;
1626 : : }
1627 : :
1628 [ + + ]: 260 : if (rmtp) {
1629 : 245 : ret = update_rmtp(&t.timer, rmtp);
1630 [ + - ]: 245 : if (ret <= 0)
1631 : : goto out;
1632 : : }
1633 : :
1634 : : restart = ¤t_thread_info()->restart_block;
1635 : 260 : restart->fn = hrtimer_nanosleep_restart;
1636 : 260 : restart->nanosleep.clockid = t.timer.base->clockid;
1637 : 260 : restart->nanosleep.rmtp = rmtp;
1638 : 260 : restart->nanosleep.expires = hrtimer_get_expires_tv64(&t.timer);
1639 : :
1640 : : ret = -ERESTART_RESTARTBLOCK;
1641 : : out:
1642 : : destroy_hrtimer_on_stack(&t.timer);
1643 : 266127 : return ret;
1644 : : }
1645 : :
1646 : 0 : SYSCALL_DEFINE2(nanosleep, struct timespec __user *, rqtp,
1647 : : struct timespec __user *, rmtp)
1648 : : {
1649 : : struct timespec tu;
1650 : :
1651 [ + - ]: 265396 : if (copy_from_user(&tu, rqtp, sizeof(tu)))
1652 : : return -EFAULT;
1653 : :
1654 [ + ]: 265396 : if (!timespec_valid(&tu))
1655 : : return -EINVAL;
1656 : :
1657 : 265497 : return hrtimer_nanosleep(&tu, rmtp, HRTIMER_MODE_REL, CLOCK_MONOTONIC);
1658 : : }
1659 : :
1660 : : /*
1661 : : * Functions related to boot-time initialization:
1662 : : */
1663 : : static void init_hrtimers_cpu(int cpu)
1664 : : {
1665 : 81 : struct hrtimer_cpu_base *cpu_base = &per_cpu(hrtimer_bases, cpu);
1666 : : int i;
1667 : :
1668 [ + + ]: 405 : for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++) {
1669 : 324 : cpu_base->clock_base[i].cpu_base = cpu_base;
1670 : 324 : timerqueue_init_head(&cpu_base->clock_base[i].active);
1671 : : }
1672 : :
1673 : : hrtimer_init_hres(cpu_base);
1674 : : }
1675 : :
1676 : : #ifdef CONFIG_HOTPLUG_CPU
1677 : :
1678 : 0 : static void migrate_hrtimer_list(struct hrtimer_clock_base *old_base,
1679 : : struct hrtimer_clock_base *new_base)
1680 : : {
1681 : 0 : struct hrtimer *timer;
1682 : : struct timerqueue_node *node;
1683 : :
1684 [ - + ]: 312 : while ((node = timerqueue_getnext(&old_base->active))) {
1685 : : timer = container_of(node, struct hrtimer, node);
1686 [ # # ]: 0 : BUG_ON(hrtimer_callback_running(timer));
1687 : : debug_deactivate(timer);
1688 : :
1689 : : /*
1690 : : * Mark it as STATE_MIGRATE not INACTIVE otherwise the
1691 : : * timer could be seen as !active and just vanish away
1692 : : * under us on another CPU
1693 : : */
1694 : 0 : __remove_hrtimer(timer, old_base, HRTIMER_STATE_MIGRATE, 0);
1695 : 0 : timer->base = new_base;
1696 : : /*
1697 : : * Enqueue the timers on the new cpu. This does not
1698 : : * reprogram the event device in case the timer
1699 : : * expires before the earliest on this CPU, but we run
1700 : : * hrtimer_interrupt after we migrated everything to
1701 : : * sort out already expired timers and reprogram the
1702 : : * event device.
1703 : : */
1704 : 0 : enqueue_hrtimer(timer, new_base);
1705 : :
1706 : : /* Clear the migration state bit */
1707 : 0 : timer->state &= ~HRTIMER_STATE_MIGRATE;
1708 : : }
1709 : 312 : }
1710 : :
1711 : 0 : static void migrate_hrtimers(int scpu)
1712 : : {
1713 : : struct hrtimer_cpu_base *old_base, *new_base;
1714 : : int i;
1715 : :
1716 [ - + ]: 78 : BUG_ON(cpu_online(scpu));
1717 : 78 : tick_cancel_sched_timer(scpu);
1718 : :
1719 : : local_irq_disable();
1720 : 78 : old_base = &per_cpu(hrtimer_bases, scpu);
1721 : 156 : new_base = &__get_cpu_var(hrtimer_bases);
1722 : : /*
1723 : : * The caller is globally serialized and nobody else
1724 : : * takes two locks at once, deadlock is not possible.
1725 : : */
1726 : 78 : raw_spin_lock(&new_base->lock);
1727 : 78 : raw_spin_lock_nested(&old_base->lock, SINGLE_DEPTH_NESTING);
1728 : :
1729 [ + + ]: 468 : for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++) {
1730 : 312 : migrate_hrtimer_list(&old_base->clock_base[i],
1731 : : &new_base->clock_base[i]);
1732 : : }
1733 : :
1734 : : raw_spin_unlock(&old_base->lock);
1735 : : raw_spin_unlock(&new_base->lock);
1736 : :
1737 : : /* Check, if we got expired work to do */
1738 : 78 : __hrtimer_peek_ahead_timers();
1739 : : local_irq_enable();
1740 : 78 : }
1741 : :
1742 : : #endif /* CONFIG_HOTPLUG_CPU */
1743 : :
1744 : 0 : static int hrtimer_cpu_notify(struct notifier_block *self,
1745 : : unsigned long action, void *hcpu)
1746 : : {
1747 [ + + ][ + + ]: 555 : int scpu = (long)hcpu;
[ + + ][ + + ]
1748 : :
1749 : : switch (action) {
1750 : :
1751 : : case CPU_UP_PREPARE:
1752 : : case CPU_UP_PREPARE_FROZEN:
1753 : : init_hrtimers_cpu(scpu);
1754 : : break;
1755 : :
1756 : : #ifdef CONFIG_HOTPLUG_CPU
1757 : : case CPU_DYING:
1758 : : case CPU_DYING_FROZEN:
1759 : 78 : clockevents_notify(CLOCK_EVT_NOTIFY_CPU_DYING, &scpu);
1760 : 78 : break;
1761 : : case CPU_DEAD:
1762 : : case CPU_DEAD_FROZEN:
1763 : : {
1764 : 78 : clockevents_notify(CLOCK_EVT_NOTIFY_CPU_DEAD, &scpu);
1765 : 78 : migrate_hrtimers(scpu);
1766 : 78 : break;
1767 : : }
1768 : : #endif
1769 : :
1770 : : default:
1771 : : break;
1772 : : }
1773 : :
1774 : 555 : return NOTIFY_OK;
1775 : : }
1776 : :
1777 : : static struct notifier_block hrtimers_nb = {
1778 : : .notifier_call = hrtimer_cpu_notify,
1779 : : };
1780 : :
1781 : 0 : void __init hrtimers_init(void)
1782 : : {
1783 : 0 : hrtimer_cpu_notify(&hrtimers_nb, (unsigned long)CPU_UP_PREPARE,
1784 : 0 : (void *)(long)smp_processor_id());
1785 : 0 : register_cpu_notifier(&hrtimers_nb);
1786 : : #ifdef CONFIG_HIGH_RES_TIMERS
1787 : 0 : open_softirq(HRTIMER_SOFTIRQ, run_hrtimer_softirq);
1788 : : #endif
1789 : 0 : }
1790 : :
1791 : : /**
1792 : : * schedule_hrtimeout_range_clock - sleep until timeout
1793 : : * @expires: timeout value (ktime_t)
1794 : : * @delta: slack in expires timeout (ktime_t)
1795 : : * @mode: timer mode, HRTIMER_MODE_ABS or HRTIMER_MODE_REL
1796 : : * @clock: timer clock, CLOCK_MONOTONIC or CLOCK_REALTIME
1797 : : */
1798 : : int __sched
1799 : 0 : schedule_hrtimeout_range_clock(ktime_t *expires, unsigned long delta,
1800 : : const enum hrtimer_mode mode, int clock)
1801 : : {
1802 : : struct hrtimer_sleeper t;
1803 : :
1804 : : /*
1805 : : * Optimize when a zero timeout value is given. It does not
1806 : : * matter whether this is an absolute or a relative time.
1807 : : */
1808 [ + + ][ - + ]: 38929 : if (expires && !expires->tv64) {
1809 : 0 : __set_current_state(TASK_RUNNING);
1810 : 0 : return 0;
1811 : : }
1812 : :
1813 : : /*
1814 : : * A NULL parameter means "infinite"
1815 : : */
1816 [ + + ]: 38929 : if (!expires) {
1817 : 37060 : schedule();
1818 : 37057 : __set_current_state(TASK_RUNNING);
1819 : 37057 : return -EINTR;
1820 : : }
1821 : :
1822 : : hrtimer_init_on_stack(&t.timer, clock, mode);
1823 : : hrtimer_set_expires_range_ns(&t.timer, *expires, delta);
1824 : :
1825 : 1869 : hrtimer_init_sleeper(&t, current);
1826 : :
1827 : : hrtimer_start_expires(&t.timer, mode);
1828 [ - + ]: 1869 : if (!hrtimer_active(&t.timer))
1829 : 0 : t.task = NULL;
1830 : :
1831 [ + - ]: 1869 : if (likely(t.task))
1832 : 1869 : schedule();
1833 : :
1834 : : hrtimer_cancel(&t.timer);
1835 : : destroy_hrtimer_on_stack(&t.timer);
1836 : :
1837 : 1869 : __set_current_state(TASK_RUNNING);
1838 : :
1839 [ + + ]: 2627 : return !t.task ? 0 : -EINTR;
1840 : : }
1841 : :
1842 : : /**
1843 : : * schedule_hrtimeout_range - sleep until timeout
1844 : : * @expires: timeout value (ktime_t)
1845 : : * @delta: slack in expires timeout (ktime_t)
1846 : : * @mode: timer mode, HRTIMER_MODE_ABS or HRTIMER_MODE_REL
1847 : : *
1848 : : * Make the current task sleep until the given expiry time has
1849 : : * elapsed. The routine will return immediately unless
1850 : : * the current task state has been set (see set_current_state()).
1851 : : *
1852 : : * The @delta argument gives the kernel the freedom to schedule the
1853 : : * actual wakeup to a time that is both power and performance friendly.
1854 : : * The kernel give the normal best effort behavior for "@expires+@delta",
1855 : : * but may decide to fire the timer earlier, but no earlier than @expires.
1856 : : *
1857 : : * You can set the task state as follows -
1858 : : *
1859 : : * %TASK_UNINTERRUPTIBLE - at least @timeout time is guaranteed to
1860 : : * pass before the routine returns.
1861 : : *
1862 : : * %TASK_INTERRUPTIBLE - the routine may return early if a signal is
1863 : : * delivered to the current task.
1864 : : *
1865 : : * The current task state is guaranteed to be TASK_RUNNING when this
1866 : : * routine returns.
1867 : : *
1868 : : * Returns 0 when the timer has expired otherwise -EINTR
1869 : : */
1870 : 0 : int __sched schedule_hrtimeout_range(ktime_t *expires, unsigned long delta,
1871 : : const enum hrtimer_mode mode)
1872 : : {
1873 : 38925 : return schedule_hrtimeout_range_clock(expires, delta, mode,
1874 : : CLOCK_MONOTONIC);
1875 : : }
1876 : : EXPORT_SYMBOL_GPL(schedule_hrtimeout_range);
1877 : :
1878 : : /**
1879 : : * schedule_hrtimeout - sleep until timeout
1880 : : * @expires: timeout value (ktime_t)
1881 : : * @mode: timer mode, HRTIMER_MODE_ABS or HRTIMER_MODE_REL
1882 : : *
1883 : : * Make the current task sleep until the given expiry time has
1884 : : * elapsed. The routine will return immediately unless
1885 : : * the current task state has been set (see set_current_state()).
1886 : : *
1887 : : * You can set the task state as follows -
1888 : : *
1889 : : * %TASK_UNINTERRUPTIBLE - at least @timeout time is guaranteed to
1890 : : * pass before the routine returns.
1891 : : *
1892 : : * %TASK_INTERRUPTIBLE - the routine may return early if a signal is
1893 : : * delivered to the current task.
1894 : : *
1895 : : * The current task state is guaranteed to be TASK_RUNNING when this
1896 : : * routine returns.
1897 : : *
1898 : : * Returns 0 when the timer has expired otherwise -EINTR
1899 : : */
1900 : 0 : int __sched schedule_hrtimeout(ktime_t *expires,
1901 : : const enum hrtimer_mode mode)
1902 : : {
1903 : 0 : return schedule_hrtimeout_range(expires, 0, mode);
1904 : : }
1905 : : EXPORT_SYMBOL_GPL(schedule_hrtimeout);
|
