Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * Copyright(C) 2005-2006, Thomas Gleixner <tglx@linutronix.de>
4 : : * Copyright(C) 2005-2007, Red Hat, Inc., Ingo Molnar
5 : : * Copyright(C) 2006-2007 Timesys Corp., Thomas Gleixner
6 : : *
7 : : * No idle tick implementation for low and high resolution timers
8 : : *
9 : : * Started by: Thomas Gleixner and Ingo Molnar
10 : : */
11 : : #include <linux/cpu.h>
12 : : #include <linux/err.h>
13 : : #include <linux/hrtimer.h>
14 : : #include <linux/interrupt.h>
15 : : #include <linux/kernel_stat.h>
16 : : #include <linux/percpu.h>
17 : : #include <linux/nmi.h>
18 : : #include <linux/profile.h>
19 : : #include <linux/sched/signal.h>
20 : : #include <linux/sched/clock.h>
21 : : #include <linux/sched/stat.h>
22 : : #include <linux/sched/nohz.h>
23 : : #include <linux/module.h>
24 : : #include <linux/irq_work.h>
25 : : #include <linux/posix-timers.h>
26 : : #include <linux/context_tracking.h>
27 : : #include <linux/mm.h>
28 : :
29 : : #include <asm/irq_regs.h>
30 : :
31 : : #include "tick-internal.h"
32 : :
33 : : #include <trace/events/timer.h>
34 : :
35 : : /*
36 : : * Per-CPU nohz control structure
37 : : */
38 : : static DEFINE_PER_CPU(struct tick_sched, tick_cpu_sched);
39 : :
40 : 0 : struct tick_sched *tick_get_tick_sched(int cpu)
41 : : {
42 : 0 : return &per_cpu(tick_cpu_sched, cpu);
43 : : }
44 : :
45 : : #if defined(CONFIG_NO_HZ_COMMON) || defined(CONFIG_HIGH_RES_TIMERS)
46 : : /*
47 : : * The time, when the last jiffy update happened. Protected by jiffies_lock.
48 : : */
49 : : static ktime_t last_jiffies_update;
50 : :
51 : : /*
52 : : * Must be called with interrupts disabled !
53 : : */
54 : 47129 : static void tick_do_update_jiffies64(ktime_t now)
55 : : {
56 : 47129 : unsigned long ticks = 0;
57 : 47129 : ktime_t delta;
58 : :
59 : : /*
60 : : * Do a quick check without holding jiffies_lock:
61 : : * The READ_ONCE() pairs with two updates done later in this function.
62 : : */
63 [ + + ]: 47129 : delta = ktime_sub(now, READ_ONCE(last_jiffies_update));
64 [ + + ]: 47129 : if (delta < tick_period)
65 : : return;
66 : :
67 : : /* Reevaluate with jiffies_lock held */
68 : 46434 : write_seqlock(&jiffies_lock);
69 : :
70 : 46434 : delta = ktime_sub(now, last_jiffies_update);
71 [ + - ]: 46434 : if (delta >= tick_period) {
72 : :
73 : 46434 : delta = ktime_sub(delta, tick_period);
74 : : /* Pairs with the lockless read in this function. */
75 [ + + ]: 46434 : WRITE_ONCE(last_jiffies_update,
76 : : ktime_add(last_jiffies_update, tick_period));
77 : :
78 : : /* Slow path for long timeouts */
79 [ + + ]: 46434 : if (unlikely(delta >= tick_period)) {
80 [ - + ]: 578 : s64 incr = ktime_to_ns(tick_period);
81 : :
82 [ - + ]: 578 : ticks = ktime_divns(delta, incr);
83 : :
84 : : /* Pairs with the lockless read in this function. */
85 : 578 : WRITE_ONCE(last_jiffies_update,
86 : : ktime_add_ns(last_jiffies_update,
87 : : incr * ticks));
88 : : }
89 : 46434 : do_timer(++ticks);
90 : :
91 : : /* Keep the tick_next_period variable up to date */
92 : 46434 : tick_next_period = ktime_add(last_jiffies_update, tick_period);
93 : : } else {
94 : 0 : write_sequnlock(&jiffies_lock);
95 : 0 : return;
96 : : }
97 : 46434 : write_sequnlock(&jiffies_lock);
98 : 46434 : update_wall_time();
99 : : }
100 : :
101 : : /*
102 : : * Initialize and return retrieve the jiffies update.
103 : : */
104 : 21 : static ktime_t tick_init_jiffy_update(void)
105 : : {
106 : 21 : ktime_t period;
107 : :
108 : 21 : write_seqlock(&jiffies_lock);
109 : : /* Did we start the jiffies update yet ? */
110 [ + - ]: 21 : if (last_jiffies_update == 0)
111 : 21 : last_jiffies_update = tick_next_period;
112 : 21 : period = last_jiffies_update;
113 : 21 : write_sequnlock(&jiffies_lock);
114 : 21 : return period;
115 : : }
116 : :
117 : 46293 : static void tick_sched_do_timer(struct tick_sched *ts, ktime_t now)
118 : : {
119 [ + + ]: 46293 : int cpu = smp_processor_id();
120 : :
121 : : #ifdef CONFIG_NO_HZ_COMMON
122 : : /*
123 : : * Check if the do_timer duty was dropped. We don't care about
124 : : * concurrency: This happens only when the CPU in charge went
125 : : * into a long sleep. If two CPUs happen to assign themselves to
126 : : * this duty, then the jiffies update is still serialized by
127 : : * jiffies_lock.
128 : : *
129 : : * If nohz_full is enabled, this should not happen because the
130 : : * tick_do_timer_cpu never relinquishes.
131 : : */
132 [ + + ]: 46293 : if (unlikely(tick_do_timer_cpu == TICK_DO_TIMER_NONE)) {
133 : : #ifdef CONFIG_NO_HZ_FULL
134 : : WARN_ON(tick_nohz_full_running);
135 : : #endif
136 : 365 : tick_do_timer_cpu = cpu;
137 : : }
138 : : #endif
139 : :
140 : : /* Check, if the jiffies need an update */
141 [ + - ]: 46293 : if (tick_do_timer_cpu == cpu)
142 : 46293 : tick_do_update_jiffies64(now);
143 : :
144 [ + + ]: 46293 : if (ts->inidle)
145 : 1903 : ts->got_idle_tick = 1;
146 : 46293 : }
147 : :
148 : 46293 : static void tick_sched_handle(struct tick_sched *ts, struct pt_regs *regs)
149 : : {
150 : : #ifdef CONFIG_NO_HZ_COMMON
151 : : /*
152 : : * When we are idle and the tick is stopped, we have to touch
153 : : * the watchdog as we might not schedule for a really long
154 : : * time. This happens on complete idle SMP systems while
155 : : * waiting on the login prompt. We also increment the "start of
156 : : * idle" jiffy stamp so the idle accounting adjustment we do
157 : : * when we go busy again does not account too much ticks.
158 : : */
159 [ + + ]: 46293 : if (ts->tick_stopped) {
160 [ + - ]: 231 : touch_softlockup_watchdog_sched();
161 [ + - ]: 231 : if (is_idle_task(current))
162 : 231 : ts->idle_jiffies++;
163 : : /*
164 : : * In case the current tick fired too early past its expected
165 : : * expiration, make sure we don't bypass the next clock reprogramming
166 : : * to the same deadline.
167 : : */
168 : 231 : ts->next_tick = 0;
169 : : }
170 : : #endif
171 : 46293 : update_process_times(user_mode(regs));
172 : 46293 : profile_tick(CPU_PROFILING);
173 : 46293 : }
174 : : #endif
175 : :
176 : : #ifdef CONFIG_NO_HZ_FULL
177 : : cpumask_var_t tick_nohz_full_mask;
178 : : bool tick_nohz_full_running;
179 : : EXPORT_SYMBOL_GPL(tick_nohz_full_running);
180 : : static atomic_t tick_dep_mask;
181 : :
182 : : static bool check_tick_dependency(atomic_t *dep)
183 : : {
184 : : int val = atomic_read(dep);
185 : :
186 : : if (val & TICK_DEP_MASK_POSIX_TIMER) {
187 : : trace_tick_stop(0, TICK_DEP_MASK_POSIX_TIMER);
188 : : return true;
189 : : }
190 : :
191 : : if (val & TICK_DEP_MASK_PERF_EVENTS) {
192 : : trace_tick_stop(0, TICK_DEP_MASK_PERF_EVENTS);
193 : : return true;
194 : : }
195 : :
196 : : if (val & TICK_DEP_MASK_SCHED) {
197 : : trace_tick_stop(0, TICK_DEP_MASK_SCHED);
198 : : return true;
199 : : }
200 : :
201 : : if (val & TICK_DEP_MASK_CLOCK_UNSTABLE) {
202 : : trace_tick_stop(0, TICK_DEP_MASK_CLOCK_UNSTABLE);
203 : : return true;
204 : : }
205 : :
206 : : if (val & TICK_DEP_MASK_RCU) {
207 : : trace_tick_stop(0, TICK_DEP_MASK_RCU);
208 : : return true;
209 : : }
210 : :
211 : : return false;
212 : : }
213 : :
214 : : static bool can_stop_full_tick(int cpu, struct tick_sched *ts)
215 : : {
216 : : lockdep_assert_irqs_disabled();
217 : :
218 : : if (unlikely(!cpu_online(cpu)))
219 : : return false;
220 : :
221 : : if (check_tick_dependency(&tick_dep_mask))
222 : : return false;
223 : :
224 : : if (check_tick_dependency(&ts->tick_dep_mask))
225 : : return false;
226 : :
227 : : if (check_tick_dependency(¤t->tick_dep_mask))
228 : : return false;
229 : :
230 : : if (check_tick_dependency(¤t->signal->tick_dep_mask))
231 : : return false;
232 : :
233 : : return true;
234 : : }
235 : :
236 : : static void nohz_full_kick_func(struct irq_work *work)
237 : : {
238 : : /* Empty, the tick restart happens on tick_nohz_irq_exit() */
239 : : }
240 : :
241 : : static DEFINE_PER_CPU(struct irq_work, nohz_full_kick_work) = {
242 : : .func = nohz_full_kick_func,
243 : : };
244 : :
245 : : /*
246 : : * Kick this CPU if it's full dynticks in order to force it to
247 : : * re-evaluate its dependency on the tick and restart it if necessary.
248 : : * This kick, unlike tick_nohz_full_kick_cpu() and tick_nohz_full_kick_all(),
249 : : * is NMI safe.
250 : : */
251 : : static void tick_nohz_full_kick(void)
252 : : {
253 : : if (!tick_nohz_full_cpu(smp_processor_id()))
254 : : return;
255 : :
256 : : irq_work_queue(this_cpu_ptr(&nohz_full_kick_work));
257 : : }
258 : :
259 : : /*
260 : : * Kick the CPU if it's full dynticks in order to force it to
261 : : * re-evaluate its dependency on the tick and restart it if necessary.
262 : : */
263 : : void tick_nohz_full_kick_cpu(int cpu)
264 : : {
265 : : if (!tick_nohz_full_cpu(cpu))
266 : : return;
267 : :
268 : : irq_work_queue_on(&per_cpu(nohz_full_kick_work, cpu), cpu);
269 : : }
270 : :
271 : : /*
272 : : * Kick all full dynticks CPUs in order to force these to re-evaluate
273 : : * their dependency on the tick and restart it if necessary.
274 : : */
275 : : static void tick_nohz_full_kick_all(void)
276 : : {
277 : : int cpu;
278 : :
279 : : if (!tick_nohz_full_running)
280 : : return;
281 : :
282 : : preempt_disable();
283 : : for_each_cpu_and(cpu, tick_nohz_full_mask, cpu_online_mask)
284 : : tick_nohz_full_kick_cpu(cpu);
285 : : preempt_enable();
286 : : }
287 : :
288 : : static void tick_nohz_dep_set_all(atomic_t *dep,
289 : : enum tick_dep_bits bit)
290 : : {
291 : : int prev;
292 : :
293 : : prev = atomic_fetch_or(BIT(bit), dep);
294 : : if (!prev)
295 : : tick_nohz_full_kick_all();
296 : : }
297 : :
298 : : /*
299 : : * Set a global tick dependency. Used by perf events that rely on freq and
300 : : * by unstable clock.
301 : : */
302 : : void tick_nohz_dep_set(enum tick_dep_bits bit)
303 : : {
304 : : tick_nohz_dep_set_all(&tick_dep_mask, bit);
305 : : }
306 : :
307 : : void tick_nohz_dep_clear(enum tick_dep_bits bit)
308 : : {
309 : : atomic_andnot(BIT(bit), &tick_dep_mask);
310 : : }
311 : :
312 : : /*
313 : : * Set per-CPU tick dependency. Used by scheduler and perf events in order to
314 : : * manage events throttling.
315 : : */
316 : : void tick_nohz_dep_set_cpu(int cpu, enum tick_dep_bits bit)
317 : : {
318 : : int prev;
319 : : struct tick_sched *ts;
320 : :
321 : : ts = per_cpu_ptr(&tick_cpu_sched, cpu);
322 : :
323 : : prev = atomic_fetch_or(BIT(bit), &ts->tick_dep_mask);
324 : : if (!prev) {
325 : : preempt_disable();
326 : : /* Perf needs local kick that is NMI safe */
327 : : if (cpu == smp_processor_id()) {
328 : : tick_nohz_full_kick();
329 : : } else {
330 : : /* Remote irq work not NMI-safe */
331 : : if (!WARN_ON_ONCE(in_nmi()))
332 : : tick_nohz_full_kick_cpu(cpu);
333 : : }
334 : : preempt_enable();
335 : : }
336 : : }
337 : : EXPORT_SYMBOL_GPL(tick_nohz_dep_set_cpu);
338 : :
339 : : void tick_nohz_dep_clear_cpu(int cpu, enum tick_dep_bits bit)
340 : : {
341 : : struct tick_sched *ts = per_cpu_ptr(&tick_cpu_sched, cpu);
342 : :
343 : : atomic_andnot(BIT(bit), &ts->tick_dep_mask);
344 : : }
345 : : EXPORT_SYMBOL_GPL(tick_nohz_dep_clear_cpu);
346 : :
347 : : /*
348 : : * Set a per-task tick dependency. Posix CPU timers need this in order to elapse
349 : : * per task timers.
350 : : */
351 : : void tick_nohz_dep_set_task(struct task_struct *tsk, enum tick_dep_bits bit)
352 : : {
353 : : /*
354 : : * We could optimize this with just kicking the target running the task
355 : : * if that noise matters for nohz full users.
356 : : */
357 : : tick_nohz_dep_set_all(&tsk->tick_dep_mask, bit);
358 : : }
359 : : EXPORT_SYMBOL_GPL(tick_nohz_dep_set_task);
360 : :
361 : : void tick_nohz_dep_clear_task(struct task_struct *tsk, enum tick_dep_bits bit)
362 : : {
363 : : atomic_andnot(BIT(bit), &tsk->tick_dep_mask);
364 : : }
365 : : EXPORT_SYMBOL_GPL(tick_nohz_dep_clear_task);
366 : :
367 : : /*
368 : : * Set a per-taskgroup tick dependency. Posix CPU timers need this in order to elapse
369 : : * per process timers.
370 : : */
371 : : void tick_nohz_dep_set_signal(struct signal_struct *sig, enum tick_dep_bits bit)
372 : : {
373 : : tick_nohz_dep_set_all(&sig->tick_dep_mask, bit);
374 : : }
375 : :
376 : : void tick_nohz_dep_clear_signal(struct signal_struct *sig, enum tick_dep_bits bit)
377 : : {
378 : : atomic_andnot(BIT(bit), &sig->tick_dep_mask);
379 : : }
380 : :
381 : : /*
382 : : * Re-evaluate the need for the tick as we switch the current task.
383 : : * It might need the tick due to per task/process properties:
384 : : * perf events, posix CPU timers, ...
385 : : */
386 : : void __tick_nohz_task_switch(void)
387 : : {
388 : : unsigned long flags;
389 : : struct tick_sched *ts;
390 : :
391 : : local_irq_save(flags);
392 : :
393 : : if (!tick_nohz_full_cpu(smp_processor_id()))
394 : : goto out;
395 : :
396 : : ts = this_cpu_ptr(&tick_cpu_sched);
397 : :
398 : : if (ts->tick_stopped) {
399 : : if (atomic_read(¤t->tick_dep_mask) ||
400 : : atomic_read(¤t->signal->tick_dep_mask))
401 : : tick_nohz_full_kick();
402 : : }
403 : : out:
404 : : local_irq_restore(flags);
405 : : }
406 : :
407 : : /* Get the boot-time nohz CPU list from the kernel parameters. */
408 : : void __init tick_nohz_full_setup(cpumask_var_t cpumask)
409 : : {
410 : : alloc_bootmem_cpumask_var(&tick_nohz_full_mask);
411 : : cpumask_copy(tick_nohz_full_mask, cpumask);
412 : : tick_nohz_full_running = true;
413 : : }
414 : : EXPORT_SYMBOL_GPL(tick_nohz_full_setup);
415 : :
416 : : static int tick_nohz_cpu_down(unsigned int cpu)
417 : : {
418 : : /*
419 : : * The tick_do_timer_cpu CPU handles housekeeping duty (unbound
420 : : * timers, workqueues, timekeeping, ...) on behalf of full dynticks
421 : : * CPUs. It must remain online when nohz full is enabled.
422 : : */
423 : : if (tick_nohz_full_running && tick_do_timer_cpu == cpu)
424 : : return -EBUSY;
425 : : return 0;
426 : : }
427 : :
428 : : void __init tick_nohz_init(void)
429 : : {
430 : : int cpu, ret;
431 : :
432 : : if (!tick_nohz_full_running)
433 : : return;
434 : :
435 : : /*
436 : : * Full dynticks uses irq work to drive the tick rescheduling on safe
437 : : * locking contexts. But then we need irq work to raise its own
438 : : * interrupts to avoid circular dependency on the tick
439 : : */
440 : : if (!arch_irq_work_has_interrupt()) {
441 : : pr_warn("NO_HZ: Can't run full dynticks because arch doesn't support irq work self-IPIs\n");
442 : : cpumask_clear(tick_nohz_full_mask);
443 : : tick_nohz_full_running = false;
444 : : return;
445 : : }
446 : :
447 : : if (IS_ENABLED(CONFIG_PM_SLEEP_SMP) &&
448 : : !IS_ENABLED(CONFIG_PM_SLEEP_SMP_NONZERO_CPU)) {
449 : : cpu = smp_processor_id();
450 : :
451 : : if (cpumask_test_cpu(cpu, tick_nohz_full_mask)) {
452 : : pr_warn("NO_HZ: Clearing %d from nohz_full range "
453 : : "for timekeeping\n", cpu);
454 : : cpumask_clear_cpu(cpu, tick_nohz_full_mask);
455 : : }
456 : : }
457 : :
458 : : for_each_cpu(cpu, tick_nohz_full_mask)
459 : : context_tracking_cpu_set(cpu);
460 : :
461 : : ret = cpuhp_setup_state_nocalls(CPUHP_AP_ONLINE_DYN,
462 : : "kernel/nohz:predown", NULL,
463 : : tick_nohz_cpu_down);
464 : : WARN_ON(ret < 0);
465 : : pr_info("NO_HZ: Full dynticks CPUs: %*pbl.\n",
466 : : cpumask_pr_args(tick_nohz_full_mask));
467 : : }
468 : : #endif
469 : :
470 : : /*
471 : : * NOHZ - aka dynamic tick functionality
472 : : */
473 : : #ifdef CONFIG_NO_HZ_COMMON
474 : : /*
475 : : * NO HZ enabled ?
476 : : */
477 : : bool tick_nohz_enabled __read_mostly = true;
478 : : unsigned long tick_nohz_active __read_mostly;
479 : : /*
480 : : * Enable / Disable tickless mode
481 : : */
482 : 0 : static int __init setup_tick_nohz(char *str)
483 : : {
484 : 0 : return (kstrtobool(str, &tick_nohz_enabled) == 0);
485 : : }
486 : :
487 : : __setup("nohz=", setup_tick_nohz);
488 : :
489 : 1061 : bool tick_nohz_tick_stopped(void)
490 : : {
491 : 1061 : struct tick_sched *ts = this_cpu_ptr(&tick_cpu_sched);
492 : :
493 : 1061 : return ts->tick_stopped;
494 : : }
495 : :
496 : 0 : bool tick_nohz_tick_stopped_cpu(int cpu)
497 : : {
498 : 0 : struct tick_sched *ts = per_cpu_ptr(&tick_cpu_sched, cpu);
499 : :
500 : 0 : return ts->tick_stopped;
501 : : }
502 : :
503 : : /**
504 : : * tick_nohz_update_jiffies - update jiffies when idle was interrupted
505 : : *
506 : : * Called from interrupt entry when the CPU was idle
507 : : *
508 : : * In case the sched_tick was stopped on this CPU, we have to check if jiffies
509 : : * must be updated. Otherwise an interrupt handler could use a stale jiffy
510 : : * value. We do this unconditionally on any CPU, as we don't know whether the
511 : : * CPU, which has the update task assigned is in a long sleep.
512 : : */
513 : 436 : static void tick_nohz_update_jiffies(ktime_t now)
514 : : {
515 : 436 : unsigned long flags;
516 : :
517 : 436 : __this_cpu_write(tick_cpu_sched.idle_waketime, now);
518 : :
519 : 436 : local_irq_save(flags);
520 : 436 : tick_do_update_jiffies64(now);
521 : 436 : local_irq_restore(flags);
522 : :
523 : 436 : touch_softlockup_watchdog_sched();
524 : 436 : }
525 : :
526 : : /*
527 : : * Updates the per-CPU time idle statistics counters
528 : : */
529 : : static void
530 : 11011 : update_ts_time_stats(int cpu, struct tick_sched *ts, ktime_t now, u64 *last_update_time)
531 : : {
532 : 11011 : ktime_t delta;
533 : :
534 [ + - ]: 11011 : if (ts->idle_active) {
535 : 11011 : delta = ktime_sub(now, ts->idle_entrytime);
536 [ + + ]: 11011 : if (nr_iowait_cpu(cpu) > 0)
537 : 7667 : ts->iowait_sleeptime = ktime_add(ts->iowait_sleeptime, delta);
538 : : else
539 : 3344 : ts->idle_sleeptime = ktime_add(ts->idle_sleeptime, delta);
540 : 11011 : ts->idle_entrytime = now;
541 : : }
542 : :
543 [ - + ]: 11011 : if (last_update_time)
544 : 0 : *last_update_time = ktime_to_us(now);
545 : :
546 : 11011 : }
547 : :
548 : 11011 : static void tick_nohz_stop_idle(struct tick_sched *ts, ktime_t now)
549 : : {
550 : 11011 : update_ts_time_stats(smp_processor_id(), ts, now, NULL);
551 : 11011 : ts->idle_active = 0;
552 : :
553 : 11011 : sched_clock_idle_wakeup_event();
554 : 11011 : }
555 : :
556 : 11012 : static void tick_nohz_start_idle(struct tick_sched *ts)
557 : : {
558 : 22024 : ts->idle_entrytime = ktime_get();
559 : 11012 : ts->idle_active = 1;
560 : 11012 : sched_clock_idle_sleep_event();
561 : 830 : }
562 : :
563 : : /**
564 : : * get_cpu_idle_time_us - get the total idle time of a CPU
565 : : * @cpu: CPU number to query
566 : : * @last_update_time: variable to store update time in. Do not update
567 : : * counters if NULL.
568 : : *
569 : : * Return the cumulative idle time (since boot) for a given
570 : : * CPU, in microseconds.
571 : : *
572 : : * This time is measured via accounting rather than sampling,
573 : : * and is as accurate as ktime_get() is.
574 : : *
575 : : * This function returns -1 if NOHZ is not enabled.
576 : : */
577 : 0 : u64 get_cpu_idle_time_us(int cpu, u64 *last_update_time)
578 : : {
579 : 0 : struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
580 : 0 : ktime_t now, idle;
581 : :
582 [ # # ]: 0 : if (!tick_nohz_active)
583 : : return -1;
584 : :
585 : 0 : now = ktime_get();
586 [ # # ]: 0 : if (last_update_time) {
587 : 0 : update_ts_time_stats(cpu, ts, now, last_update_time);
588 : 0 : idle = ts->idle_sleeptime;
589 : : } else {
590 [ # # # # ]: 0 : if (ts->idle_active && !nr_iowait_cpu(cpu)) {
591 : 0 : ktime_t delta = ktime_sub(now, ts->idle_entrytime);
592 : :
593 : 0 : idle = ktime_add(ts->idle_sleeptime, delta);
594 : : } else {
595 : 0 : idle = ts->idle_sleeptime;
596 : : }
597 : : }
598 : :
599 : 0 : return ktime_to_us(idle);
600 : :
601 : : }
602 : : EXPORT_SYMBOL_GPL(get_cpu_idle_time_us);
603 : :
604 : : /**
605 : : * get_cpu_iowait_time_us - get the total iowait time of a CPU
606 : : * @cpu: CPU number to query
607 : : * @last_update_time: variable to store update time in. Do not update
608 : : * counters if NULL.
609 : : *
610 : : * Return the cumulative iowait time (since boot) for a given
611 : : * CPU, in microseconds.
612 : : *
613 : : * This time is measured via accounting rather than sampling,
614 : : * and is as accurate as ktime_get() is.
615 : : *
616 : : * This function returns -1 if NOHZ is not enabled.
617 : : */
618 : 0 : u64 get_cpu_iowait_time_us(int cpu, u64 *last_update_time)
619 : : {
620 : 0 : struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
621 : 0 : ktime_t now, iowait;
622 : :
623 [ # # ]: 0 : if (!tick_nohz_active)
624 : : return -1;
625 : :
626 : 0 : now = ktime_get();
627 [ # # ]: 0 : if (last_update_time) {
628 : 0 : update_ts_time_stats(cpu, ts, now, last_update_time);
629 : 0 : iowait = ts->iowait_sleeptime;
630 : : } else {
631 [ # # # # ]: 0 : if (ts->idle_active && nr_iowait_cpu(cpu) > 0) {
632 : 0 : ktime_t delta = ktime_sub(now, ts->idle_entrytime);
633 : :
634 : 0 : iowait = ktime_add(ts->iowait_sleeptime, delta);
635 : : } else {
636 : 0 : iowait = ts->iowait_sleeptime;
637 : : }
638 : : }
639 : :
640 : 0 : return ktime_to_us(iowait);
641 : : }
642 : : EXPORT_SYMBOL_GPL(get_cpu_iowait_time_us);
643 : :
644 : 400 : static void tick_nohz_restart(struct tick_sched *ts, ktime_t now)
645 : : {
646 : 400 : hrtimer_cancel(&ts->sched_timer);
647 : 400 : hrtimer_set_expires(&ts->sched_timer, ts->last_tick);
648 : :
649 : : /* Forward the time to expire in the future */
650 : 400 : hrtimer_forward(&ts->sched_timer, now, tick_period);
651 : :
652 [ + - ]: 400 : if (ts->nohz_mode == NOHZ_MODE_HIGHRES) {
653 : 400 : hrtimer_start_expires(&ts->sched_timer,
654 : : HRTIMER_MODE_ABS_PINNED_HARD);
655 : : } else {
656 : 0 : tick_program_event(hrtimer_get_expires(&ts->sched_timer), 1);
657 : : }
658 : :
659 : : /*
660 : : * Reset to make sure next tick stop doesn't get fooled by past
661 : : * cached clock deadline.
662 : : */
663 : 400 : ts->next_tick = 0;
664 : 400 : }
665 : :
666 : 438 : static inline bool local_timer_softirq_pending(void)
667 : : {
668 [ - + ]: 438 : return local_softirq_pending() & BIT(TIMER_SOFTIRQ);
669 : : }
670 : :
671 : 10171 : static ktime_t tick_nohz_next_event(struct tick_sched *ts, int cpu)
672 : : {
673 : 10171 : u64 basemono, next_tick, next_tmr, next_rcu, delta, expires;
674 : 10171 : unsigned long basejiff;
675 : 10171 : unsigned int seq;
676 : :
677 : : /* Read jiffies and the time when jiffies were updated last */
678 : 10171 : do {
679 : 10171 : seq = read_seqbegin(&jiffies_lock);
680 : 10171 : basemono = last_jiffies_update;
681 : 10171 : basejiff = jiffies;
682 [ - + ]: 10171 : } while (read_seqretry(&jiffies_lock, seq));
683 : 10171 : ts->last_jiffies = basejiff;
684 : 10171 : ts->timer_expires_base = basemono;
685 : :
686 : : /*
687 : : * Keep the periodic tick, when RCU, architecture or irq_work
688 : : * requests it.
689 : : * Aside of that check whether the local timer softirq is
690 : : * pending. If so its a bad idea to call get_next_timer_interrupt()
691 : : * because there is an already expired timer, so it will request
692 : : * immeditate expiry, which rearms the hardware timer with a
693 : : * minimal delta which brings us back to this place
694 : : * immediately. Lather, rinse and repeat...
695 : : */
696 [ + + + - ]: 10609 : if (rcu_needs_cpu(basemono, &next_rcu) || arch_needs_cpu() ||
697 [ - + ]: 876 : irq_work_needs_cpu() || local_timer_softirq_pending()) {
698 : 9733 : next_tick = basemono + TICK_NSEC;
699 : : } else {
700 : : /*
701 : : * Get the next pending timer. If high resolution
702 : : * timers are enabled this only takes the timer wheel
703 : : * timers into account. If high resolution timers are
704 : : * disabled this also looks at the next expiring
705 : : * hrtimer.
706 : : */
707 : 438 : next_tmr = get_next_timer_interrupt(basejiff, basemono);
708 : 438 : ts->next_timer = next_tmr;
709 : : /* Take the next rcu event into account */
710 : 438 : next_tick = next_rcu < next_tmr ? next_rcu : next_tmr;
711 : : }
712 : :
713 : : /*
714 : : * If the tick is due in the next period, keep it ticking or
715 : : * force prod the timer.
716 : : */
717 : 10171 : delta = next_tick - basemono;
718 [ + + ]: 10171 : if (delta <= (u64)TICK_NSEC) {
719 : : /*
720 : : * Tell the timer code that the base is not idle, i.e. undo
721 : : * the effect of get_next_timer_interrupt():
722 : : */
723 : 9738 : timer_clear_idle();
724 : : /*
725 : : * We've not stopped the tick yet, and there's a timer in the
726 : : * next period, so no point in stopping it either, bail.
727 : : */
728 [ + - ]: 9738 : if (!ts->tick_stopped) {
729 : 9738 : ts->timer_expires = 0;
730 : 9738 : goto out;
731 : : }
732 : : }
733 : :
734 : : /*
735 : : * If this CPU is the one which had the do_timer() duty last, we limit
736 : : * the sleep time to the timekeeping max_deferment value.
737 : : * Otherwise we can sleep as long as we want.
738 : : */
739 : 433 : delta = timekeeping_max_deferment();
740 [ + + + - ]: 433 : if (cpu != tick_do_timer_cpu &&
741 [ - + ]: 68 : (tick_do_timer_cpu != TICK_DO_TIMER_NONE || !ts->do_timer_last))
742 : 0 : delta = KTIME_MAX;
743 : :
744 : : /* Calculate the next expiry time */
745 [ + - ]: 433 : if (delta < (KTIME_MAX - basemono))
746 : 433 : expires = basemono + delta;
747 : : else
748 : : expires = KTIME_MAX;
749 : :
750 : 433 : ts->timer_expires = min_t(u64, expires, next_tick);
751 : :
752 : 10171 : out:
753 : 10171 : return ts->timer_expires;
754 : : }
755 : :
756 : 433 : static void tick_nohz_stop_tick(struct tick_sched *ts, int cpu)
757 : : {
758 [ + + ]: 433 : struct clock_event_device *dev = __this_cpu_read(tick_cpu_device.evtdev);
759 : 433 : u64 basemono = ts->timer_expires_base;
760 : 433 : u64 expires = ts->timer_expires;
761 : 433 : ktime_t tick = expires;
762 : :
763 : : /* Make sure we won't be trying to stop it twice in a row. */
764 : 433 : ts->timer_expires_base = 0;
765 : :
766 : : /*
767 : : * If this CPU is the one which updates jiffies, then give up
768 : : * the assignment and let it be taken by the CPU which runs
769 : : * the tick timer next, which might be this CPU as well. If we
770 : : * don't drop this here the jiffies might be stale and
771 : : * do_timer() never invoked. Keep track of the fact that it
772 : : * was the one which had the do_timer() duty last.
773 : : */
774 [ + + ]: 433 : if (cpu == tick_do_timer_cpu) {
775 : 365 : tick_do_timer_cpu = TICK_DO_TIMER_NONE;
776 : 365 : ts->do_timer_last = 1;
777 [ - + ]: 68 : } else if (tick_do_timer_cpu != TICK_DO_TIMER_NONE) {
778 : 0 : ts->do_timer_last = 0;
779 : : }
780 : :
781 : : /* Skip reprogram of event if its not changed */
782 [ + + + + ]: 433 : if (ts->tick_stopped && (expires == ts->next_tick)) {
783 : : /* Sanity check: make sure clockevent is actually programmed */
784 [ + - - + ]: 10 : if (tick == KTIME_MAX || ts->next_tick == hrtimer_get_expires(&ts->sched_timer))
785 : : return;
786 : :
787 : 0 : WARN_ON_ONCE(1);
788 [ # # ]: 0 : printk_once("basemono: %llu ts->next_tick: %llu dev->next_event: %llu timer->active: %d timer->expires: %llu\n",
789 : : basemono, ts->next_tick, dev->next_event,
790 : : hrtimer_active(&ts->sched_timer), hrtimer_get_expires(&ts->sched_timer));
791 : : }
792 : :
793 : : /*
794 : : * nohz_stop_sched_tick can be called several times before
795 : : * the nohz_restart_sched_tick is called. This happens when
796 : : * interrupts arrive which do not cause a reschedule. In the
797 : : * first call we save the current tick time, so we can restart
798 : : * the scheduler tick in nohz_restart_sched_tick.
799 : : */
800 [ + + ]: 423 : if (!ts->tick_stopped) {
801 : 400 : calc_load_nohz_start();
802 : 400 : quiet_vmstat();
803 : :
804 : 400 : ts->last_tick = hrtimer_get_expires(&ts->sched_timer);
805 : 400 : ts->tick_stopped = 1;
806 : 400 : trace_tick_stop(1, TICK_DEP_MASK_NONE);
807 : : }
808 : :
809 : 423 : ts->next_tick = tick;
810 : :
811 : : /*
812 : : * If the expiration time == KTIME_MAX, then we simply stop
813 : : * the tick timer.
814 : : */
815 [ - + ]: 423 : if (unlikely(expires == KTIME_MAX)) {
816 [ # # ]: 0 : if (ts->nohz_mode == NOHZ_MODE_HIGHRES)
817 : 0 : hrtimer_cancel(&ts->sched_timer);
818 : 0 : return;
819 : : }
820 : :
821 [ + - ]: 423 : if (ts->nohz_mode == NOHZ_MODE_HIGHRES) {
822 : 423 : hrtimer_start(&ts->sched_timer, tick,
823 : : HRTIMER_MODE_ABS_PINNED_HARD);
824 : : } else {
825 : 0 : hrtimer_set_expires(&ts->sched_timer, tick);
826 : 0 : tick_program_event(tick, 1);
827 : : }
828 : : }
829 : :
830 : 9738 : static void tick_nohz_retain_tick(struct tick_sched *ts)
831 : : {
832 : 9738 : ts->timer_expires_base = 0;
833 : 9738 : }
834 : :
835 : : #ifdef CONFIG_NO_HZ_FULL
836 : : static void tick_nohz_stop_sched_tick(struct tick_sched *ts, int cpu)
837 : : {
838 : : if (tick_nohz_next_event(ts, cpu))
839 : : tick_nohz_stop_tick(ts, cpu);
840 : : else
841 : : tick_nohz_retain_tick(ts);
842 : : }
843 : : #endif /* CONFIG_NO_HZ_FULL */
844 : :
845 : 400 : static void tick_nohz_restart_sched_tick(struct tick_sched *ts, ktime_t now)
846 : : {
847 : : /* Update jiffies first */
848 : 400 : tick_do_update_jiffies64(now);
849 : :
850 : : /*
851 : : * Clear the timer idle flag, so we avoid IPIs on remote queueing and
852 : : * the clock forward checks in the enqueue path:
853 : : */
854 : 400 : timer_clear_idle();
855 : :
856 : 400 : calc_load_nohz_stop();
857 : 400 : touch_softlockup_watchdog_sched();
858 : : /*
859 : : * Cancel the scheduled timer and restore the tick
860 : : */
861 : 400 : ts->tick_stopped = 0;
862 : 400 : ts->idle_exittime = now;
863 : :
864 : 400 : tick_nohz_restart(ts, now);
865 : 400 : }
866 : :
867 : : static void tick_nohz_full_update_tick(struct tick_sched *ts)
868 : : {
869 : : #ifdef CONFIG_NO_HZ_FULL
870 : : int cpu = smp_processor_id();
871 : :
872 : : if (!tick_nohz_full_cpu(cpu))
873 : : return;
874 : :
875 : : if (!ts->tick_stopped && ts->nohz_mode == NOHZ_MODE_INACTIVE)
876 : : return;
877 : :
878 : : if (can_stop_full_tick(cpu, ts))
879 : : tick_nohz_stop_sched_tick(ts, cpu);
880 : : else if (ts->tick_stopped)
881 : : tick_nohz_restart_sched_tick(ts, ktime_get());
882 : : #endif
883 : : }
884 : :
885 : : static bool can_stop_idle_tick(int cpu, struct tick_sched *ts)
886 : : {
887 : : /*
888 : : * If this CPU is offline and it is the one which updates
889 : : * jiffies, then give up the assignment and let it be taken by
890 : : * the CPU which runs the tick timer next. If we don't drop
891 : : * this here the jiffies might be stale and do_timer() never
892 : : * invoked.
893 : : */
894 : : if (unlikely(!cpu_online(cpu))) {
895 : : if (cpu == tick_do_timer_cpu)
896 : : tick_do_timer_cpu = TICK_DO_TIMER_NONE;
897 : : /*
898 : : * Make sure the CPU doesn't get fooled by obsolete tick
899 : : * deadline if it comes back online later.
900 : : */
901 : : ts->next_tick = 0;
902 : : return false;
903 : : }
904 : :
905 : : if (unlikely(ts->nohz_mode == NOHZ_MODE_INACTIVE))
906 : : return false;
907 : :
908 : : if (need_resched())
909 : : return false;
910 : :
911 : : if (unlikely(local_softirq_pending())) {
912 : : static int ratelimit;
913 : :
914 : : if (ratelimit < 10 &&
915 : : (local_softirq_pending() & SOFTIRQ_STOP_IDLE_MASK)) {
916 : : pr_warn("NOHZ: local_softirq_pending %02x\n",
917 : : (unsigned int) local_softirq_pending());
918 : : ratelimit++;
919 : : }
920 : : return false;
921 : : }
922 : :
923 : : if (tick_nohz_full_enabled()) {
924 : : /*
925 : : * Keep the tick alive to guarantee timekeeping progression
926 : : * if there are full dynticks CPUs around
927 : : */
928 : : if (tick_do_timer_cpu == cpu)
929 : : return false;
930 : : /*
931 : : * Boot safety: make sure the timekeeping duty has been
932 : : * assigned before entering dyntick-idle mode,
933 : : * tick_do_timer_cpu is TICK_DO_TIMER_BOOT
934 : : */
935 : : if (unlikely(tick_do_timer_cpu == TICK_DO_TIMER_BOOT))
936 : : return false;
937 : :
938 : : /* Should not happen for nohz-full */
939 : : if (WARN_ON_ONCE(tick_do_timer_cpu == TICK_DO_TIMER_NONE))
940 : : return false;
941 : : }
942 : :
943 : : return true;
944 : : }
945 : :
946 : 10171 : static void __tick_nohz_idle_stop_tick(struct tick_sched *ts)
947 : : {
948 : 10171 : ktime_t expires;
949 [ - + ]: 10171 : int cpu = smp_processor_id();
950 : :
951 : : /*
952 : : * If tick_nohz_get_sleep_length() ran tick_nohz_next_event(), the
953 : : * tick timer expiration time is known already.
954 : : */
955 [ - + ]: 10171 : if (ts->timer_expires_base)
956 : 0 : expires = ts->timer_expires;
957 [ + - ]: 10171 : else if (can_stop_idle_tick(cpu, ts))
958 : 10171 : expires = tick_nohz_next_event(ts, cpu);
959 : : else
960 : : return;
961 : :
962 : 10171 : ts->idle_calls++;
963 : :
964 [ + + ]: 10171 : if (expires > 0LL) {
965 : 433 : int was_stopped = ts->tick_stopped;
966 : :
967 : 433 : tick_nohz_stop_tick(ts, cpu);
968 : :
969 : 433 : ts->idle_sleeps++;
970 : 433 : ts->idle_expires = expires;
971 : :
972 [ + + + - ]: 433 : if (!was_stopped && ts->tick_stopped) {
973 : 400 : ts->idle_jiffies = ts->last_jiffies;
974 : 400 : nohz_balance_enter_idle(cpu);
975 : : }
976 : : } else {
977 : 9738 : tick_nohz_retain_tick(ts);
978 : : }
979 : : }
980 : :
981 : : /**
982 : : * tick_nohz_idle_stop_tick - stop the idle tick from the idle task
983 : : *
984 : : * When the next event is more than a tick into the future, stop the idle tick
985 : : */
986 : 10171 : void tick_nohz_idle_stop_tick(void)
987 : : {
988 : 10171 : __tick_nohz_idle_stop_tick(this_cpu_ptr(&tick_cpu_sched));
989 : 10171 : }
990 : :
991 : 0 : void tick_nohz_idle_retain_tick(void)
992 : : {
993 : 0 : tick_nohz_retain_tick(this_cpu_ptr(&tick_cpu_sched));
994 : : /*
995 : : * Undo the effect of get_next_timer_interrupt() called from
996 : : * tick_nohz_next_event().
997 : : */
998 : 0 : timer_clear_idle();
999 : 0 : }
1000 : :
1001 : : /**
1002 : : * tick_nohz_idle_enter - prepare for entering idle on the current CPU
1003 : : *
1004 : : * Called when we start the idle loop.
1005 : : */
1006 : 10182 : void tick_nohz_idle_enter(void)
1007 : : {
1008 : 10182 : struct tick_sched *ts;
1009 : :
1010 : 10182 : lockdep_assert_irqs_enabled();
1011 : :
1012 : 10182 : local_irq_disable();
1013 : :
1014 : 10182 : ts = this_cpu_ptr(&tick_cpu_sched);
1015 : :
1016 [ - + ]: 10182 : WARN_ON_ONCE(ts->timer_expires_base);
1017 : :
1018 : 10182 : ts->inidle = 1;
1019 : 10182 : tick_nohz_start_idle(ts);
1020 : :
1021 : 10182 : local_irq_enable();
1022 : 10182 : }
1023 : :
1024 : : /**
1025 : : * tick_nohz_irq_exit - update next tick event from interrupt exit
1026 : : *
1027 : : * When an interrupt fires while we are idle and it doesn't cause
1028 : : * a reschedule, it may still add, modify or delete a timer, enqueue
1029 : : * an RCU callback, etc...
1030 : : * So we need to re-calculate and reprogram the next tick event.
1031 : : */
1032 : 1087 : void tick_nohz_irq_exit(void)
1033 : : {
1034 : 1087 : struct tick_sched *ts = this_cpu_ptr(&tick_cpu_sched);
1035 : :
1036 [ + + ]: 1087 : if (ts->inidle)
1037 : 830 : tick_nohz_start_idle(ts);
1038 : : else
1039 : : tick_nohz_full_update_tick(ts);
1040 : 1087 : }
1041 : :
1042 : : /**
1043 : : * tick_nohz_idle_got_tick - Check whether or not the tick handler has run
1044 : : */
1045 : 0 : bool tick_nohz_idle_got_tick(void)
1046 : : {
1047 : 0 : struct tick_sched *ts = this_cpu_ptr(&tick_cpu_sched);
1048 : :
1049 [ # # ]: 0 : if (ts->got_idle_tick) {
1050 : 0 : ts->got_idle_tick = 0;
1051 : 0 : return true;
1052 : : }
1053 : : return false;
1054 : : }
1055 : :
1056 : : /**
1057 : : * tick_nohz_get_next_hrtimer - return the next expiration time for the hrtimer
1058 : : * or the tick, whatever that expires first. Note that, if the tick has been
1059 : : * stopped, it returns the next hrtimer.
1060 : : *
1061 : : * Called from power state control code with interrupts disabled
1062 : : */
1063 : 0 : ktime_t tick_nohz_get_next_hrtimer(void)
1064 : : {
1065 : 0 : return __this_cpu_read(tick_cpu_device.evtdev)->next_event;
1066 : : }
1067 : :
1068 : : /**
1069 : : * tick_nohz_get_sleep_length - return the expected length of the current sleep
1070 : : * @delta_next: duration until the next event if the tick cannot be stopped
1071 : : *
1072 : : * Called from power state control code with interrupts disabled
1073 : : */
1074 : 0 : ktime_t tick_nohz_get_sleep_length(ktime_t *delta_next)
1075 : : {
1076 : 0 : struct clock_event_device *dev = __this_cpu_read(tick_cpu_device.evtdev);
1077 : 0 : struct tick_sched *ts = this_cpu_ptr(&tick_cpu_sched);
1078 [ # # ]: 0 : int cpu = smp_processor_id();
1079 : : /*
1080 : : * The idle entry time is expected to be a sufficient approximation of
1081 : : * the current time at this point.
1082 : : */
1083 : 0 : ktime_t now = ts->idle_entrytime;
1084 : 0 : ktime_t next_event;
1085 : :
1086 [ # # ]: 0 : WARN_ON_ONCE(!ts->inidle);
1087 : :
1088 : 0 : *delta_next = ktime_sub(dev->next_event, now);
1089 : :
1090 [ # # ]: 0 : if (!can_stop_idle_tick(cpu, ts))
1091 : 0 : return *delta_next;
1092 : :
1093 : 0 : next_event = tick_nohz_next_event(ts, cpu);
1094 [ # # ]: 0 : if (!next_event)
1095 : 0 : return *delta_next;
1096 : :
1097 : : /*
1098 : : * If the next highres timer to expire is earlier than next_event, the
1099 : : * idle governor needs to know that.
1100 : : */
1101 : 0 : next_event = min_t(u64, next_event,
1102 : : hrtimer_next_event_without(&ts->sched_timer));
1103 : :
1104 : 0 : return ktime_sub(next_event, now);
1105 : : }
1106 : :
1107 : : /**
1108 : : * tick_nohz_get_idle_calls_cpu - return the current idle calls counter value
1109 : : * for a particular CPU.
1110 : : *
1111 : : * Called from the schedutil frequency scaling governor in scheduler context.
1112 : : */
1113 : 0 : unsigned long tick_nohz_get_idle_calls_cpu(int cpu)
1114 : : {
1115 : 0 : struct tick_sched *ts = tick_get_tick_sched(cpu);
1116 : :
1117 : 0 : return ts->idle_calls;
1118 : : }
1119 : :
1120 : : /**
1121 : : * tick_nohz_get_idle_calls - return the current idle calls counter value
1122 : : *
1123 : : * Called from the schedutil frequency scaling governor in scheduler context.
1124 : : */
1125 : 0 : unsigned long tick_nohz_get_idle_calls(void)
1126 : : {
1127 : 0 : struct tick_sched *ts = this_cpu_ptr(&tick_cpu_sched);
1128 : :
1129 : 0 : return ts->idle_calls;
1130 : : }
1131 : :
1132 : 400 : static void tick_nohz_account_idle_ticks(struct tick_sched *ts)
1133 : : {
1134 : : #ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
1135 : 400 : unsigned long ticks;
1136 : :
1137 : 400 : if (vtime_accounting_enabled_this_cpu())
1138 : : return;
1139 : : /*
1140 : : * We stopped the tick in idle. Update process times would miss the
1141 : : * time we slept as update_process_times does only a 1 tick
1142 : : * accounting. Enforce that this is accounted to idle !
1143 : : */
1144 : 400 : ticks = jiffies - ts->idle_jiffies;
1145 : : /*
1146 : : * We might be one off. Do not randomly account a huge number of ticks!
1147 : : */
1148 [ + + ]: 400 : if (ticks && ticks < LONG_MAX)
1149 : 354 : account_idle_ticks(ticks);
1150 : : #endif
1151 : : }
1152 : :
1153 : 400 : static void __tick_nohz_idle_restart_tick(struct tick_sched *ts, ktime_t now)
1154 : : {
1155 : 400 : tick_nohz_restart_sched_tick(ts, now);
1156 [ + + ]: 400 : tick_nohz_account_idle_ticks(ts);
1157 : 400 : }
1158 : :
1159 : 0 : void tick_nohz_idle_restart_tick(void)
1160 : : {
1161 : 0 : struct tick_sched *ts = this_cpu_ptr(&tick_cpu_sched);
1162 : :
1163 [ # # ]: 0 : if (ts->tick_stopped)
1164 : 0 : __tick_nohz_idle_restart_tick(ts, ktime_get());
1165 : 0 : }
1166 : :
1167 : : /**
1168 : : * tick_nohz_idle_exit - restart the idle tick from the idle task
1169 : : *
1170 : : * Restart the idle tick when the CPU is woken up from idle
1171 : : * This also exit the RCU extended quiescent state. The CPU
1172 : : * can use RCU again after this function is called.
1173 : : */
1174 : 10182 : void tick_nohz_idle_exit(void)
1175 : : {
1176 : 10182 : struct tick_sched *ts = this_cpu_ptr(&tick_cpu_sched);
1177 : 10182 : bool idle_active, tick_stopped;
1178 : 10182 : ktime_t now;
1179 : :
1180 : 10182 : local_irq_disable();
1181 : :
1182 [ - + ]: 10182 : WARN_ON_ONCE(!ts->inidle);
1183 [ - + ]: 10182 : WARN_ON_ONCE(ts->timer_expires_base);
1184 : :
1185 : 10182 : ts->inidle = 0;
1186 : 10182 : idle_active = ts->idle_active;
1187 : 10182 : tick_stopped = ts->tick_stopped;
1188 : :
1189 [ + + ]: 10182 : if (idle_active || tick_stopped)
1190 : 1213 : now = ktime_get();
1191 : :
1192 [ + + ]: 10182 : if (idle_active)
1193 : 813 : tick_nohz_stop_idle(ts, now);
1194 : :
1195 [ + + ]: 10182 : if (tick_stopped)
1196 : 400 : __tick_nohz_idle_restart_tick(ts, now);
1197 : :
1198 : 10182 : local_irq_enable();
1199 : 10182 : }
1200 : :
1201 : : /*
1202 : : * The nohz low res interrupt handler
1203 : : */
1204 : 0 : static void tick_nohz_handler(struct clock_event_device *dev)
1205 : : {
1206 : 0 : struct tick_sched *ts = this_cpu_ptr(&tick_cpu_sched);
1207 : 0 : struct pt_regs *regs = get_irq_regs();
1208 : 0 : ktime_t now = ktime_get();
1209 : :
1210 : 0 : dev->next_event = KTIME_MAX;
1211 : :
1212 : 0 : tick_sched_do_timer(ts, now);
1213 : 0 : tick_sched_handle(ts, regs);
1214 : :
1215 : : /* No need to reprogram if we are running tickless */
1216 [ # # ]: 0 : if (unlikely(ts->tick_stopped))
1217 : : return;
1218 : :
1219 : 0 : hrtimer_forward(&ts->sched_timer, now, tick_period);
1220 : 0 : tick_program_event(hrtimer_get_expires(&ts->sched_timer), 1);
1221 : : }
1222 : :
1223 : : static inline void tick_nohz_activate(struct tick_sched *ts, int mode)
1224 : : {
1225 : : if (!tick_nohz_enabled)
1226 : : return;
1227 : : ts->nohz_mode = mode;
1228 : : /* One update is enough */
1229 : : if (!test_and_set_bit(0, &tick_nohz_active))
1230 : : timers_update_nohz();
1231 : : }
1232 : :
1233 : : /**
1234 : : * tick_nohz_switch_to_nohz - switch to nohz mode
1235 : : */
1236 : 0 : static void tick_nohz_switch_to_nohz(void)
1237 : : {
1238 : 0 : struct tick_sched *ts = this_cpu_ptr(&tick_cpu_sched);
1239 : 0 : ktime_t next;
1240 : :
1241 [ # # ]: 0 : if (!tick_nohz_enabled)
1242 : : return;
1243 : :
1244 [ # # ]: 0 : if (tick_switch_to_oneshot(tick_nohz_handler))
1245 : : return;
1246 : :
1247 : : /*
1248 : : * Recycle the hrtimer in ts, so we can share the
1249 : : * hrtimer_forward with the highres code.
1250 : : */
1251 : 0 : hrtimer_init(&ts->sched_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS_HARD);
1252 : : /* Get the next period */
1253 : 0 : next = tick_init_jiffy_update();
1254 : :
1255 : 0 : hrtimer_set_expires(&ts->sched_timer, next);
1256 : 0 : hrtimer_forward_now(&ts->sched_timer, tick_period);
1257 : 0 : tick_program_event(hrtimer_get_expires(&ts->sched_timer), 1);
1258 : 0 : tick_nohz_activate(ts, NOHZ_MODE_LOWRES);
1259 : : }
1260 : :
1261 : 10691 : static inline void tick_nohz_irq_enter(void)
1262 : : {
1263 : 10691 : struct tick_sched *ts = this_cpu_ptr(&tick_cpu_sched);
1264 : 10691 : ktime_t now;
1265 : :
1266 [ + + ]: 10691 : if (!ts->idle_active && !ts->tick_stopped)
1267 : : return;
1268 : 10198 : now = ktime_get();
1269 [ + - ]: 10198 : if (ts->idle_active)
1270 : 10198 : tick_nohz_stop_idle(ts, now);
1271 [ + + ]: 10198 : if (ts->tick_stopped)
1272 : 436 : tick_nohz_update_jiffies(now);
1273 : : }
1274 : :
1275 : : #else
1276 : :
1277 : : static inline void tick_nohz_switch_to_nohz(void) { }
1278 : : static inline void tick_nohz_irq_enter(void) { }
1279 : : static inline void tick_nohz_activate(struct tick_sched *ts, int mode) { }
1280 : :
1281 : : #endif /* CONFIG_NO_HZ_COMMON */
1282 : :
1283 : : /*
1284 : : * Called from irq_enter to notify about the possible interruption of idle()
1285 : : */
1286 : 10691 : void tick_irq_enter(void)
1287 : : {
1288 : 10691 : tick_check_oneshot_broadcast_this_cpu();
1289 : 10691 : tick_nohz_irq_enter();
1290 : 10691 : }
1291 : :
1292 : : /*
1293 : : * High resolution timer specific code
1294 : : */
1295 : : #ifdef CONFIG_HIGH_RES_TIMERS
1296 : : /*
1297 : : * We rearm the timer until we get disabled by the idle code.
1298 : : * Called with interrupts disabled.
1299 : : */
1300 : 46293 : static enum hrtimer_restart tick_sched_timer(struct hrtimer *timer)
1301 : : {
1302 : 46293 : struct tick_sched *ts =
1303 : 46293 : container_of(timer, struct tick_sched, sched_timer);
1304 : 46293 : struct pt_regs *regs = get_irq_regs();
1305 : 46293 : ktime_t now = ktime_get();
1306 : :
1307 : 46293 : tick_sched_do_timer(ts, now);
1308 : :
1309 : : /*
1310 : : * Do not call, when we are not in irq context and have
1311 : : * no valid regs pointer
1312 : : */
1313 [ + - ]: 46293 : if (regs)
1314 : 46293 : tick_sched_handle(ts, regs);
1315 : : else
1316 : 0 : ts->next_tick = 0;
1317 : :
1318 : : /* No need to reprogram if we are in idle or full dynticks mode */
1319 [ + + ]: 46293 : if (unlikely(ts->tick_stopped))
1320 : : return HRTIMER_NORESTART;
1321 : :
1322 : 46062 : hrtimer_forward(timer, now, tick_period);
1323 : :
1324 : 46062 : return HRTIMER_RESTART;
1325 : : }
1326 : :
1327 : : static int sched_skew_tick;
1328 : :
1329 : 0 : static int __init skew_tick(char *str)
1330 : : {
1331 : 0 : get_option(&str, &sched_skew_tick);
1332 : :
1333 : 0 : return 0;
1334 : : }
1335 : : early_param("skew_tick", skew_tick);
1336 : :
1337 : : /**
1338 : : * tick_setup_sched_timer - setup the tick emulation timer
1339 : : */
1340 : 21 : void tick_setup_sched_timer(void)
1341 : : {
1342 : 21 : struct tick_sched *ts = this_cpu_ptr(&tick_cpu_sched);
1343 : 21 : ktime_t now = ktime_get();
1344 : :
1345 : : /*
1346 : : * Emulate tick processing via per-CPU hrtimers:
1347 : : */
1348 : 21 : hrtimer_init(&ts->sched_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS_HARD);
1349 : 21 : ts->sched_timer.function = tick_sched_timer;
1350 : :
1351 : : /* Get the next period (per-CPU) */
1352 : 21 : hrtimer_set_expires(&ts->sched_timer, tick_init_jiffy_update());
1353 : :
1354 : : /* Offset the tick to avert jiffies_lock contention. */
1355 [ - + ]: 21 : if (sched_skew_tick) {
1356 : 0 : u64 offset = ktime_to_ns(tick_period) >> 1;
1357 : 0 : do_div(offset, num_possible_cpus());
1358 : 0 : offset *= smp_processor_id();
1359 : 0 : hrtimer_add_expires_ns(&ts->sched_timer, offset);
1360 : : }
1361 : :
1362 : 21 : hrtimer_forward(&ts->sched_timer, now, tick_period);
1363 : 21 : hrtimer_start_expires(&ts->sched_timer, HRTIMER_MODE_ABS_PINNED_HARD);
1364 : 21 : tick_nohz_activate(ts, NOHZ_MODE_HIGHRES);
1365 : 21 : }
1366 : : #endif /* HIGH_RES_TIMERS */
1367 : :
1368 : : #if defined CONFIG_NO_HZ_COMMON || defined CONFIG_HIGH_RES_TIMERS
1369 : 0 : void tick_cancel_sched_timer(int cpu)
1370 : : {
1371 : 0 : struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
1372 : :
1373 : : # ifdef CONFIG_HIGH_RES_TIMERS
1374 [ # # ]: 0 : if (ts->sched_timer.base)
1375 : 0 : hrtimer_cancel(&ts->sched_timer);
1376 : : # endif
1377 : :
1378 : 0 : memset(ts, 0, sizeof(*ts));
1379 : 0 : }
1380 : : #endif
1381 : :
1382 : : /**
1383 : : * Async notification about clocksource changes
1384 : : */
1385 : 42 : void tick_clock_notify(void)
1386 : : {
1387 : 42 : int cpu;
1388 : :
1389 [ + + ]: 84 : for_each_possible_cpu(cpu)
1390 : 42 : set_bit(0, &per_cpu(tick_cpu_sched, cpu).check_clocks);
1391 : 42 : }
1392 : :
1393 : : /*
1394 : : * Async notification about clock event changes
1395 : : */
1396 : 42 : void tick_oneshot_notify(void)
1397 : : {
1398 : 42 : struct tick_sched *ts = this_cpu_ptr(&tick_cpu_sched);
1399 : :
1400 : 42 : set_bit(0, &ts->check_clocks);
1401 : 42 : }
1402 : :
1403 : : /**
1404 : : * Check, if a change happened, which makes oneshot possible.
1405 : : *
1406 : : * Called cyclic from the hrtimer softirq (driven by the timer
1407 : : * softirq) allow_nohz signals, that we can switch into low-res nohz
1408 : : * mode, because high resolution timers are disabled (either compile
1409 : : * or runtime). Called with interrupts disabled.
1410 : : */
1411 : 4029 : int tick_check_oneshot_change(int allow_nohz)
1412 : : {
1413 : 4029 : struct tick_sched *ts = this_cpu_ptr(&tick_cpu_sched);
1414 : :
1415 [ + + ]: 4029 : if (!test_and_clear_bit(0, &ts->check_clocks))
1416 : : return 0;
1417 : :
1418 [ + - ]: 63 : if (ts->nohz_mode != NOHZ_MODE_INACTIVE)
1419 : : return 0;
1420 : :
1421 [ + + - + ]: 63 : if (!timekeeping_valid_for_hres() || !tick_is_oneshot_available())
1422 : 42 : return 0;
1423 : :
1424 [ - + ]: 21 : if (!allow_nohz)
1425 : : return 1;
1426 : :
1427 : 0 : tick_nohz_switch_to_nohz();
1428 : 0 : return 0;
1429 : : }
|
