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