Branch data Line data Source code
1 : : /*
2 : : * linux/kernel/time/tick-sched.c
3 : : *
4 : : * Copyright(C) 2005-2006, Thomas Gleixner <tglx@linutronix.de>
5 : : * Copyright(C) 2005-2007, Red Hat, Inc., Ingo Molnar
6 : : * Copyright(C) 2006-2007 Timesys Corp., Thomas Gleixner
7 : : *
8 : : * No idle tick implementation for low and high resolution timers
9 : : *
10 : : * Started by: Thomas Gleixner and Ingo Molnar
11 : : *
12 : : * Distribute under GPLv2.
13 : : */
14 : : #include <linux/cpu.h>
15 : : #include <linux/err.h>
16 : : #include <linux/hrtimer.h>
17 : : #include <linux/interrupt.h>
18 : : #include <linux/kernel_stat.h>
19 : : #include <linux/percpu.h>
20 : : #include <linux/profile.h>
21 : : #include <linux/sched.h>
22 : : #include <linux/module.h>
23 : : #include <linux/irq_work.h>
24 : : #include <linux/posix-timers.h>
25 : : #include <linux/perf_event.h>
26 : : #include <linux/context_tracking.h>
27 : :
28 : : #include <asm/irq_regs.h>
29 : :
30 : : #include "tick-internal.h"
31 : :
32 : : #include <trace/events/timer.h>
33 : :
34 : : /*
35 : : * Per cpu nohz control structure
36 : : */
37 : : DEFINE_PER_CPU(struct tick_sched, tick_cpu_sched);
38 : :
39 : : /*
40 : : * The time, when the last jiffy update happened. Protected by jiffies_lock.
41 : : */
42 : : static ktime_t last_jiffies_update;
43 : :
44 : 0 : struct tick_sched *tick_get_tick_sched(int cpu)
45 : : {
46 : 2 : return &per_cpu(tick_cpu_sched, cpu);
47 : : }
48 : :
49 : : /*
50 : : * Must be called with interrupts disabled !
51 : : */
52 : 0 : static void tick_do_update_jiffies64(ktime_t now)
53 : : {
54 : : unsigned long ticks = 0;
55 : : ktime_t delta;
56 : :
57 : : /*
58 : : * Do a quick check without holding jiffies_lock:
59 : : */
60 : 10590512 : delta = ktime_sub(now, last_jiffies_update);
61 [ + + ]: 10590512 : if (delta.tv64 < tick_period.tv64)
62 : 10590844 : return;
63 : :
64 : : /* Reevalute with jiffies_lock held */
65 : : write_seqlock(&jiffies_lock);
66 : :
67 : 7270404 : delta = ktime_sub(now, last_jiffies_update);
68 [ + + ]: 7270404 : if (delta.tv64 >= tick_period.tv64) {
69 : :
70 : 7264410 : delta = ktime_sub(delta, tick_period);
71 : 7264410 : last_jiffies_update = ktime_add(last_jiffies_update,
72 : : tick_period);
73 : :
74 : : /* Slow path for long timeouts */
75 [ + + ]: 7264410 : if (unlikely(delta.tv64 >= tick_period.tv64)) {
76 : : s64 incr = ktime_to_ns(tick_period);
77 : :
78 : 178115 : ticks = ktime_divns(delta, incr);
79 : :
80 : 178115 : last_jiffies_update = ktime_add_ns(last_jiffies_update,
81 : : incr * ticks);
82 : : }
83 : 7264410 : do_timer(++ticks);
84 : :
85 : : /* Keep the tick_next_period variable up to date */
86 : 7264410 : tick_next_period = ktime_add(last_jiffies_update, tick_period);
87 : : }
88 : : write_sequnlock(&jiffies_lock);
89 : : }
90 : :
91 : : /*
92 : : * Initialize and return retrieve the jiffies update.
93 : : */
94 : 0 : static ktime_t tick_init_jiffy_update(void)
95 : : {
96 : : ktime_t period;
97 : :
98 : : write_seqlock(&jiffies_lock);
99 : : /* Did we start the jiffies update yet ? */
100 [ # # ]: 0 : if (last_jiffies_update.tv64 == 0)
101 : 0 : last_jiffies_update = tick_next_period;
102 : 0 : period = last_jiffies_update;
103 : : write_sequnlock(&jiffies_lock);
104 : 0 : return period;
105 : : }
106 : :
107 : :
108 : 0 : static void tick_sched_do_timer(ktime_t now)
109 : : {
110 : : int cpu = smp_processor_id();
111 : :
112 : : #ifdef CONFIG_NO_HZ_COMMON
113 : : /*
114 : : * Check if the do_timer duty was dropped. We don't care about
115 : : * concurrency: This happens only when the cpu in charge went
116 : : * into a long sleep. If two cpus happen to assign themself to
117 : : * this duty, then the jiffies update is still serialized by
118 : : * jiffies_lock.
119 : : */
120 [ + + ]: 7845093 : if (unlikely(tick_do_timer_cpu == TICK_DO_TIMER_NONE)
121 : : && !tick_nohz_full_cpu(cpu))
122 : 293324 : tick_do_timer_cpu = cpu;
123 : : #endif
124 : :
125 : : /* Check, if the jiffies need an update */
126 [ + + ]: 7845093 : if (tick_do_timer_cpu == cpu)
127 : 7207368 : tick_do_update_jiffies64(now);
128 : 2575 : }
129 : :
130 : 7853060 : static void tick_sched_handle(struct tick_sched *ts, struct pt_regs *regs)
131 : : {
132 : : #ifdef CONFIG_NO_HZ_COMMON
133 : : /*
134 : : * When we are idle and the tick is stopped, we have to touch
135 : : * the watchdog as we might not schedule for a really long
136 : : * time. This happens on complete idle SMP systems while
137 : : * waiting on the login prompt. We also increment the "start of
138 : : * idle" jiffy stamp so the idle accounting adjustment we do
139 : : * when we go busy again does not account too much ticks.
140 : : */
141 [ + + ]: 7853060 : if (ts->tick_stopped) {
142 : : touch_softlockup_watchdog();
143 [ + - ]: 335850 : if (is_idle_task(current))
144 : 335850 : ts->idle_jiffies++;
145 : : }
146 : : #endif
147 : 7853060 : update_process_times(user_mode(regs));
148 : 7840075 : profile_tick(CPU_PROFILING);
149 : 7836310 : }
150 : :
151 : : #ifdef CONFIG_NO_HZ_FULL
152 : : cpumask_var_t tick_nohz_full_mask;
153 : : bool tick_nohz_full_running;
154 : :
155 : : static bool can_stop_full_tick(void)
156 : : {
157 : : WARN_ON_ONCE(!irqs_disabled());
158 : :
159 : : if (!sched_can_stop_tick()) {
160 : : trace_tick_stop(0, "more than 1 task in runqueue\n");
161 : : return false;
162 : : }
163 : :
164 : : if (!posix_cpu_timers_can_stop_tick(current)) {
165 : : trace_tick_stop(0, "posix timers running\n");
166 : : return false;
167 : : }
168 : :
169 : : if (!perf_event_can_stop_tick()) {
170 : : trace_tick_stop(0, "perf events running\n");
171 : : return false;
172 : : }
173 : :
174 : : /* sched_clock_tick() needs us? */
175 : : #ifdef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK
176 : : /*
177 : : * TODO: kick full dynticks CPUs when
178 : : * sched_clock_stable is set.
179 : : */
180 : : if (!sched_clock_stable) {
181 : : trace_tick_stop(0, "unstable sched clock\n");
182 : : /*
183 : : * Don't allow the user to think they can get
184 : : * full NO_HZ with this machine.
185 : : */
186 : : WARN_ONCE(tick_nohz_full_running,
187 : : "NO_HZ FULL will not work with unstable sched clock");
188 : : return false;
189 : : }
190 : : #endif
191 : :
192 : : return true;
193 : : }
194 : :
195 : : static void tick_nohz_restart_sched_tick(struct tick_sched *ts, ktime_t now);
196 : :
197 : : /*
198 : : * Re-evaluate the need for the tick on the current CPU
199 : : * and restart it if necessary.
200 : : */
201 : : void __tick_nohz_full_check(void)
202 : : {
203 : : struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
204 : :
205 : : if (tick_nohz_full_cpu(smp_processor_id())) {
206 : : if (ts->tick_stopped && !is_idle_task(current)) {
207 : : if (!can_stop_full_tick())
208 : : tick_nohz_restart_sched_tick(ts, ktime_get());
209 : : }
210 : : }
211 : : }
212 : :
213 : : static void nohz_full_kick_work_func(struct irq_work *work)
214 : : {
215 : : __tick_nohz_full_check();
216 : : }
217 : :
218 : : static DEFINE_PER_CPU(struct irq_work, nohz_full_kick_work) = {
219 : : .func = nohz_full_kick_work_func,
220 : : };
221 : :
222 : : /*
223 : : * Kick the current CPU if it's full dynticks in order to force it to
224 : : * re-evaluate its dependency on the tick and restart it if necessary.
225 : : */
226 : : void tick_nohz_full_kick(void)
227 : : {
228 : : if (tick_nohz_full_cpu(smp_processor_id()))
229 : : irq_work_queue(&__get_cpu_var(nohz_full_kick_work));
230 : : }
231 : :
232 : : static void nohz_full_kick_ipi(void *info)
233 : : {
234 : : __tick_nohz_full_check();
235 : : }
236 : :
237 : : /*
238 : : * Kick all full dynticks CPUs in order to force these to re-evaluate
239 : : * their dependency on the tick and restart it if necessary.
240 : : */
241 : : void tick_nohz_full_kick_all(void)
242 : : {
243 : : if (!tick_nohz_full_running)
244 : : return;
245 : :
246 : : preempt_disable();
247 : : smp_call_function_many(tick_nohz_full_mask,
248 : : nohz_full_kick_ipi, NULL, false);
249 : : tick_nohz_full_kick();
250 : : preempt_enable();
251 : : }
252 : :
253 : : /*
254 : : * Re-evaluate the need for the tick as we switch the current task.
255 : : * It might need the tick due to per task/process properties:
256 : : * perf events, posix cpu timers, ...
257 : : */
258 : : void __tick_nohz_task_switch(struct task_struct *tsk)
259 : : {
260 : : unsigned long flags;
261 : :
262 : : local_irq_save(flags);
263 : :
264 : : if (!tick_nohz_full_cpu(smp_processor_id()))
265 : : goto out;
266 : :
267 : : if (tick_nohz_tick_stopped() && !can_stop_full_tick())
268 : : tick_nohz_full_kick();
269 : :
270 : : out:
271 : : local_irq_restore(flags);
272 : : }
273 : :
274 : : /* Parse the boot-time nohz CPU list from the kernel parameters. */
275 : : static int __init tick_nohz_full_setup(char *str)
276 : : {
277 : : int cpu;
278 : :
279 : : alloc_bootmem_cpumask_var(&tick_nohz_full_mask);
280 : : if (cpulist_parse(str, tick_nohz_full_mask) < 0) {
281 : : pr_warning("NOHZ: Incorrect nohz_full cpumask\n");
282 : : return 1;
283 : : }
284 : :
285 : : cpu = smp_processor_id();
286 : : if (cpumask_test_cpu(cpu, tick_nohz_full_mask)) {
287 : : pr_warning("NO_HZ: Clearing %d from nohz_full range for timekeeping\n", cpu);
288 : : cpumask_clear_cpu(cpu, tick_nohz_full_mask);
289 : : }
290 : : tick_nohz_full_running = true;
291 : :
292 : : return 1;
293 : : }
294 : : __setup("nohz_full=", tick_nohz_full_setup);
295 : :
296 : : static int tick_nohz_cpu_down_callback(struct notifier_block *nfb,
297 : : unsigned long action,
298 : : void *hcpu)
299 : : {
300 : : unsigned int cpu = (unsigned long)hcpu;
301 : :
302 : : switch (action & ~CPU_TASKS_FROZEN) {
303 : : case CPU_DOWN_PREPARE:
304 : : /*
305 : : * If we handle the timekeeping duty for full dynticks CPUs,
306 : : * we can't safely shutdown that CPU.
307 : : */
308 : : if (tick_nohz_full_running && tick_do_timer_cpu == cpu)
309 : : return NOTIFY_BAD;
310 : : break;
311 : : }
312 : : return NOTIFY_OK;
313 : : }
314 : :
315 : : /*
316 : : * Worst case string length in chunks of CPU range seems 2 steps
317 : : * separations: 0,2,4,6,...
318 : : * This is NR_CPUS + sizeof('\0')
319 : : */
320 : : static char __initdata nohz_full_buf[NR_CPUS + 1];
321 : :
322 : : static int tick_nohz_init_all(void)
323 : : {
324 : : int err = -1;
325 : :
326 : : #ifdef CONFIG_NO_HZ_FULL_ALL
327 : : if (!alloc_cpumask_var(&tick_nohz_full_mask, GFP_KERNEL)) {
328 : : pr_err("NO_HZ: Can't allocate full dynticks cpumask\n");
329 : : return err;
330 : : }
331 : : err = 0;
332 : : cpumask_setall(tick_nohz_full_mask);
333 : : cpumask_clear_cpu(smp_processor_id(), tick_nohz_full_mask);
334 : : tick_nohz_full_running = true;
335 : : #endif
336 : : return err;
337 : : }
338 : :
339 : : void __init tick_nohz_init(void)
340 : : {
341 : : int cpu;
342 : :
343 : : if (!tick_nohz_full_running) {
344 : : if (tick_nohz_init_all() < 0)
345 : : return;
346 : : }
347 : :
348 : : for_each_cpu(cpu, tick_nohz_full_mask)
349 : : context_tracking_cpu_set(cpu);
350 : :
351 : : cpu_notifier(tick_nohz_cpu_down_callback, 0);
352 : : cpulist_scnprintf(nohz_full_buf, sizeof(nohz_full_buf), tick_nohz_full_mask);
353 : : pr_info("NO_HZ: Full dynticks CPUs: %s.\n", nohz_full_buf);
354 : : }
355 : : #endif
356 : :
357 : : /*
358 : : * NOHZ - aka dynamic tick functionality
359 : : */
360 : : #ifdef CONFIG_NO_HZ_COMMON
361 : : /*
362 : : * NO HZ enabled ?
363 : : */
364 : : static int tick_nohz_enabled __read_mostly = 1;
365 : : int tick_nohz_active __read_mostly;
366 : : /*
367 : : * Enable / Disable tickless mode
368 : : */
369 : 0 : static int __init setup_tick_nohz(char *str)
370 : : {
371 [ # # ]: 0 : if (!strcmp(str, "off"))
372 : 0 : tick_nohz_enabled = 0;
373 [ # # ]: 0 : else if (!strcmp(str, "on"))
374 : 0 : tick_nohz_enabled = 1;
375 : : else
376 : : return 0;
377 : : return 1;
378 : : }
379 : :
380 : : __setup("nohz=", setup_tick_nohz);
381 : :
382 : : /**
383 : : * tick_nohz_update_jiffies - update jiffies when idle was interrupted
384 : : *
385 : : * Called from interrupt entry when the CPU was idle
386 : : *
387 : : * In case the sched_tick was stopped on this CPU, we have to check if jiffies
388 : : * must be updated. Otherwise an interrupt handler could use a stale jiffy
389 : : * value. We do this unconditionally on any cpu, as we don't know whether the
390 : : * cpu, which has the update task assigned is in a long sleep.
391 : : */
392 : 0 : static void tick_nohz_update_jiffies(ktime_t now)
393 : : {
394 : 1393223 : int cpu = smp_processor_id();
395 : 1393223 : struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
396 : : unsigned long flags;
397 : :
398 : 1393223 : ts->idle_waketime = now;
399 : :
400 : : local_irq_save(flags);
401 : 1393228 : tick_do_update_jiffies64(now);
402 [ + - ]: 1393230 : local_irq_restore(flags);
403 : :
404 : : touch_softlockup_watchdog();
405 : 1393230 : }
406 : :
407 : : /*
408 : : * Updates the per cpu time idle statistics counters
409 : : */
410 : : static void
411 : 0 : update_ts_time_stats(int cpu, struct tick_sched *ts, ktime_t now, u64 *last_update_time)
412 : : {
413 : : ktime_t delta;
414 : :
415 [ + + ]: 6371494 : if (ts->idle_active) {
416 : 6210596 : delta = ktime_sub(now, ts->idle_entrytime);
417 [ + + ]: 6210596 : if (nr_iowait_cpu(cpu) > 0)
418 : 876771 : ts->iowait_sleeptime = ktime_add(ts->iowait_sleeptime, delta);
419 : : else
420 : 5334288 : ts->idle_sleeptime = ktime_add(ts->idle_sleeptime, delta);
421 : 6211059 : ts->idle_entrytime = now;
422 : : }
423 : :
424 [ + + ]: 6371957 : if (last_update_time)
425 : 160409 : *last_update_time = ktime_to_us(now);
426 : :
427 : 6371960 : }
428 : :
429 : 0 : static void tick_nohz_stop_idle(int cpu, ktime_t now)
430 : : {
431 : 6210643 : struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
432 : :
433 : 6210643 : update_ts_time_stats(cpu, ts, now, NULL);
434 : 3989083 : ts->idle_active = 0;
435 : :
436 : : sched_clock_idle_wakeup_event(0);
437 : 2221827 : }
438 : :
439 : 6211119 : static ktime_t tick_nohz_start_idle(int cpu, struct tick_sched *ts)
440 : : {
441 : 6211119 : ktime_t now = ktime_get();
442 : :
443 : 6211169 : ts->idle_entrytime = now;
444 : 6211169 : ts->idle_active = 1;
445 : : sched_clock_idle_sleep_event();
446 : 6211169 : return now;
447 : : }
448 : :
449 : : /**
450 : : * get_cpu_idle_time_us - get the total idle time of a cpu
451 : : * @cpu: CPU number to query
452 : : * @last_update_time: variable to store update time in. Do not update
453 : : * counters if NULL.
454 : : *
455 : : * Return the cummulative idle time (since boot) for a given
456 : : * CPU, in microseconds.
457 : : *
458 : : * This time is measured via accounting rather than sampling,
459 : : * and is as accurate as ktime_get() is.
460 : : *
461 : : * This function returns -1 if NOHZ is not enabled.
462 : : */
463 : 0 : u64 get_cpu_idle_time_us(int cpu, u64 *last_update_time)
464 : : {
465 : 160442 : struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
466 : : ktime_t now, idle;
467 : :
468 [ + + ]: 160442 : if (!tick_nohz_active)
469 : : return -1;
470 : :
471 : 160441 : now = ktime_get();
472 [ - + ]: 320879 : if (last_update_time) {
473 : 0 : update_ts_time_stats(cpu, ts, now, last_update_time);
474 : 0 : idle = ts->idle_sleeptime;
475 : : } else {
476 [ + + ][ + - ]: 160437 : if (ts->idle_active && !nr_iowait_cpu(cpu)) {
477 : 8 : ktime_t delta = ktime_sub(now, ts->idle_entrytime);
478 : :
479 : 8 : idle = ktime_add(ts->idle_sleeptime, delta);
480 : : } else {
481 : 160429 : idle = ts->idle_sleeptime;
482 : : }
483 : : }
484 : :
485 : 160436 : return ktime_to_us(idle);
486 : :
487 : : }
488 : : EXPORT_SYMBOL_GPL(get_cpu_idle_time_us);
489 : :
490 : : /**
491 : : * get_cpu_iowait_time_us - get the total iowait time of a cpu
492 : : * @cpu: CPU number to query
493 : : * @last_update_time: variable to store update time in. Do not update
494 : : * counters if NULL.
495 : : *
496 : : * Return the cummulative iowait time (since boot) for a given
497 : : * CPU, in microseconds.
498 : : *
499 : : * This time is measured via accounting rather than sampling,
500 : : * and is as accurate as ktime_get() is.
501 : : *
502 : : * This function returns -1 if NOHZ is not enabled.
503 : : */
504 : 0 : u64 get_cpu_iowait_time_us(int cpu, u64 *last_update_time)
505 : : {
506 : 160440 : struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
507 : : ktime_t now, iowait;
508 : :
509 [ + + ]: 160440 : if (!tick_nohz_active)
510 : : return -1;
511 : :
512 : 160434 : now = ktime_get();
513 [ + + ]: 320870 : if (last_update_time) {
514 : 160402 : update_ts_time_stats(cpu, ts, now, last_update_time);
515 : 160412 : iowait = ts->iowait_sleeptime;
516 : : } else {
517 [ + + ][ - + ]: 28 : if (ts->idle_active && nr_iowait_cpu(cpu) > 0) {
518 : 0 : ktime_t delta = ktime_sub(now, ts->idle_entrytime);
519 : :
520 : 0 : iowait = ktime_add(ts->iowait_sleeptime, delta);
521 : : } else {
522 : 28 : iowait = ts->iowait_sleeptime;
523 : : }
524 : : }
525 : :
526 : 160442 : return ktime_to_us(iowait);
527 : : }
528 : : EXPORT_SYMBOL_GPL(get_cpu_iowait_time_us);
529 : :
530 : 0 : static ktime_t tick_nohz_stop_sched_tick(struct tick_sched *ts,
531 : : ktime_t now, int cpu)
532 : : {
533 : : unsigned long seq, last_jiffies, next_jiffies, delta_jiffies;
534 : : ktime_t last_update, expires, ret = { .tv64 = 0 };
535 : : unsigned long rcu_delta_jiffies;
536 : 6470839 : struct clock_event_device *dev = __get_cpu_var(tick_cpu_device).evtdev;
537 : : u64 time_delta;
538 : :
539 : : /* Read jiffies and the time when jiffies were updated last */
540 : : do {
541 : : seq = read_seqbegin(&jiffies_lock);
542 : 6166751 : last_update = last_jiffies_update;
543 : 6166751 : last_jiffies = jiffies;
544 : 6166751 : time_delta = timekeeping_max_deferment();
545 [ + + ]: 6166785 : } while (read_seqretry(&jiffies_lock, seq));
546 : :
547 [ + + ]: 6166698 : if (rcu_needs_cpu(cpu, &rcu_delta_jiffies) ||
548 [ + ]: 3595157 : arch_needs_cpu(cpu) || irq_work_needs_cpu()) {
549 : 2571521 : next_jiffies = last_jiffies + 1;
550 : 2571521 : delta_jiffies = 1;
551 : : } else {
552 : : /* Get the next timer wheel timer */
553 : 3595190 : next_jiffies = get_next_timer_interrupt(last_jiffies);
554 : 3595181 : delta_jiffies = next_jiffies - last_jiffies;
555 [ - + ]: 3595181 : if (rcu_delta_jiffies < delta_jiffies) {
556 : 0 : next_jiffies = last_jiffies + rcu_delta_jiffies;
557 : : delta_jiffies = rcu_delta_jiffies;
558 : : }
559 : : }
560 : :
561 : : /*
562 : : * Do not stop the tick, if we are only one off (or less)
563 : : * or if the cpu is required for RCU:
564 : : */
565 [ + + ][ + + ]: 6166702 : if (!ts->tick_stopped && delta_jiffies <= 1)
566 : : goto out;
567 : :
568 : : /* Schedule the tick, if we are at least one jiffie off */
569 [ + + ]: 2660830 : if ((long)delta_jiffies >= 1) {
570 : :
571 : : /*
572 : : * If this cpu is the one which updates jiffies, then
573 : : * give up the assignment and let it be taken by the
574 : : * cpu which runs the tick timer next, which might be
575 : : * this cpu as well. If we don't drop this here the
576 : : * jiffies might be stale and do_timer() never
577 : : * invoked. Keep track of the fact that it was the one
578 : : * which had the do_timer() duty last. If this cpu is
579 : : * the one which had the do_timer() duty last, we
580 : : * limit the sleep time to the timekeeping
581 : : * max_deferement value which we retrieved
582 : : * above. Otherwise we can sleep as long as we want.
583 : : */
584 [ + + ]: 2660813 : if (cpu == tick_do_timer_cpu) {
585 : 288809 : tick_do_timer_cpu = TICK_DO_TIMER_NONE;
586 : 288809 : ts->do_timer_last = 1;
587 [ + + ]: 2372004 : } else if (tick_do_timer_cpu != TICK_DO_TIMER_NONE) {
588 : : time_delta = KTIME_MAX;
589 : 844328 : ts->do_timer_last = 0;
590 [ + + ]: 1527676 : } else if (!ts->do_timer_last) {
591 : : time_delta = KTIME_MAX;
592 : : }
593 : :
594 : : #ifdef CONFIG_NO_HZ_FULL
595 : : if (!ts->inidle) {
596 : : time_delta = min(time_delta,
597 : : scheduler_tick_max_deferment());
598 : : }
599 : : #endif
600 : :
601 : : /*
602 : : * calculate the expiry time for the next timer wheel
603 : : * timer. delta_jiffies >= NEXT_TIMER_MAX_DELTA signals
604 : : * that there is no timer pending or at least extremely
605 : : * far into the future (12 days for HZ=1000). In this
606 : : * case we set the expiry to the end of time.
607 : : */
608 [ + ]: 2660813 : if (likely(delta_jiffies < NEXT_TIMER_MAX_DELTA)) {
609 : : /*
610 : : * Calculate the time delta for the next timer event.
611 : : * If the time delta exceeds the maximum time delta
612 : : * permitted by the current clocksource then adjust
613 : : * the time delta accordingly to ensure the
614 : : * clocksource does not wrap.
615 : : */
616 : 2660818 : time_delta = min_t(u64, time_delta,
617 : : tick_period.tv64 * delta_jiffies);
618 : : }
619 : :
620 [ + - ]: 2660813 : if (time_delta < KTIME_MAX)
621 : 2660813 : expires = ktime_add_ns(last_update, time_delta);
622 : : else
623 : : expires.tv64 = KTIME_MAX;
624 : :
625 : : /* Skip reprogram of event if its not changed */
626 [ + ][ + ]: 2660813 : if (ts->tick_stopped && ktime_equal(expires, dev->next_event))
627 : : goto out;
628 : :
629 : : ret = expires;
630 : :
631 : : /*
632 : : * nohz_stop_sched_tick can be called several times before
633 : : * the nohz_restart_sched_tick is called. This happens when
634 : : * interrupts arrive which do not cause a reschedule. In the
635 : : * first call we save the current tick time, so we can restart
636 : : * the scheduler tick in nohz_restart_sched_tick.
637 : : */
638 [ + + ]: 2178977 : if (!ts->tick_stopped) {
639 : 1989992 : nohz_balance_enter_idle(cpu);
640 : 1990019 : calc_load_enter_idle();
641 : :
642 : 4168909 : ts->last_tick = hrtimer_get_expires(&ts->sched_timer);
643 : 1989962 : ts->tick_stopped = 1;
644 : : trace_tick_stop(1, " ");
645 : : }
646 : :
647 : : /*
648 : : * If the expiration time == KTIME_MAX, then
649 : : * in this case we simply stop the tick timer.
650 : : */
651 [ - + ]: 2178947 : if (unlikely(expires.tv64 == KTIME_MAX)) {
652 [ # # ]: 0 : if (ts->nohz_mode == NOHZ_MODE_HIGHRES)
653 : 0 : hrtimer_cancel(&ts->sched_timer);
654 : : goto out;
655 : : }
656 : :
657 [ + - ]: 2178947 : if (ts->nohz_mode == NOHZ_MODE_HIGHRES) {
658 : 2178947 : hrtimer_start(&ts->sched_timer, expires,
659 : : HRTIMER_MODE_ABS_PINNED);
660 : : /* Check, if the timer was already in the past */
661 [ - + ]: 2178947 : if (hrtimer_active(&ts->sched_timer))
662 : : goto out;
663 [ # # ]: 0 : } else if (!tick_program_event(expires, 0))
664 : : goto out;
665 : : /*
666 : : * We are past the event already. So we crossed a
667 : : * jiffie boundary. Update jiffies and raise the
668 : : * softirq.
669 : : */
670 : 0 : tick_do_update_jiffies64(ktime_get());
671 : : }
672 : 17 : raise_softirq_irqoff(TIMER_SOFTIRQ);
673 : : out:
674 : 0 : ts->next_jiffies = next_jiffies;
675 : 0 : ts->last_jiffies = last_jiffies;
676 : 0 : ts->sleep_length = ktime_sub(dev->next_event, now);
677 : :
678 : 0 : return ret;
679 : : }
680 : :
681 : : static void tick_nohz_full_stop_tick(struct tick_sched *ts)
682 : : {
683 : : #ifdef CONFIG_NO_HZ_FULL
684 : : int cpu = smp_processor_id();
685 : :
686 : : if (!tick_nohz_full_cpu(cpu) || is_idle_task(current))
687 : : return;
688 : :
689 : : if (!ts->tick_stopped && ts->nohz_mode == NOHZ_MODE_INACTIVE)
690 : : return;
691 : :
692 : : if (!can_stop_full_tick())
693 : : return;
694 : :
695 : : tick_nohz_stop_sched_tick(ts, ktime_get(), cpu);
696 : : #endif
697 : : }
698 : :
699 : 0 : static bool can_stop_idle_tick(int cpu, struct tick_sched *ts)
700 : : {
701 : : /*
702 : : * If this cpu is offline and it is the one which updates
703 : : * jiffies, then give up the assignment and let it be taken by
704 : : * the cpu which runs the tick timer next. If we don't drop
705 : : * this here the jiffies might be stale and do_timer() never
706 : : * invoked.
707 : : */
708 [ - + ]: 6211168 : if (unlikely(!cpu_online(cpu))) {
709 [ # # ]: 0 : if (cpu == tick_do_timer_cpu)
710 : 0 : tick_do_timer_cpu = TICK_DO_TIMER_NONE;
711 : : return false;
712 : : }
713 : :
714 [ - + ]: 6211168 : if (unlikely(ts->nohz_mode == NOHZ_MODE_INACTIVE)) {
715 : 0 : ts->sleep_length = (ktime_t) { .tv64 = NSEC_PER_SEC/HZ };
716 : : return false;
717 : : }
718 : :
719 [ + + ]: 6211168 : if (need_resched())
720 : : return false;
721 : :
722 [ - + ][ # # ]: 6166660 : if (unlikely(local_softirq_pending() && cpu_online(cpu))) {
723 : : static int ratelimit;
724 : :
725 [ # # ][ # # ]: 0 : if (ratelimit < 10 &&
726 : 0 : (local_softirq_pending() & SOFTIRQ_STOP_IDLE_MASK)) {
727 : 0 : pr_warn("NOHZ: local_softirq_pending %02x\n",
728 : : (unsigned int) local_softirq_pending());
729 : 0 : ratelimit++;
730 : : }
731 : : return false;
732 : : }
733 : :
734 : : if (tick_nohz_full_enabled()) {
735 : : /*
736 : : * Keep the tick alive to guarantee timekeeping progression
737 : : * if there are full dynticks CPUs around
738 : : */
739 : : if (tick_do_timer_cpu == cpu)
740 : : return false;
741 : : /*
742 : : * Boot safety: make sure the timekeeping duty has been
743 : : * assigned before entering dyntick-idle mode,
744 : : */
745 : : if (tick_do_timer_cpu == TICK_DO_TIMER_NONE)
746 : : return false;
747 : : }
748 : :
749 : : return true;
750 : : }
751 : :
752 : 0 : static void __tick_nohz_idle_enter(struct tick_sched *ts)
753 : : {
754 : : ktime_t now, expires;
755 : 6211099 : int cpu = smp_processor_id();
756 : :
757 : 6211099 : now = tick_nohz_start_idle(cpu, ts);
758 : :
759 [ + + ]: 6211098 : if (can_stop_idle_tick(cpu, ts)) {
760 : 6166626 : int was_stopped = ts->tick_stopped;
761 : :
762 : 6166626 : ts->idle_calls++;
763 : :
764 : 6166626 : expires = tick_nohz_stop_sched_tick(ts, now, cpu);
765 [ + + ]: 6166518 : if (expires.tv64 > 0LL) {
766 : 2178844 : ts->idle_sleeps++;
767 : 2178844 : ts->idle_expires = expires;
768 : : }
769 : :
770 [ + ][ + + ]: 6166518 : if (!was_stopped && ts->tick_stopped)
771 : 1990002 : ts->idle_jiffies = ts->last_jiffies;
772 : : }
773 : 0 : }
774 : :
775 : : /**
776 : : * tick_nohz_idle_enter - stop the idle tick from the idle task
777 : : *
778 : : * When the next event is more than a tick into the future, stop the idle tick
779 : : * Called when we start the idle loop.
780 : : *
781 : : * The arch is responsible of calling:
782 : : *
783 : : * - rcu_idle_enter() after its last use of RCU before the CPU is put
784 : : * to sleep.
785 : : * - rcu_idle_exit() before the first use of RCU after the CPU is woken up.
786 : : */
787 : 0 : void tick_nohz_idle_enter(void)
788 : : {
789 : : struct tick_sched *ts;
790 : :
791 [ - + ][ # # ]: 5356876 : WARN_ON_ONCE(irqs_disabled());
[ # # ]
792 : :
793 : : /*
794 : : * Update the idle state in the scheduler domain hierarchy
795 : : * when tick_nohz_stop_sched_tick() is called from the idle loop.
796 : : * State will be updated to busy during the first busy tick after
797 : : * exiting idle.
798 : : */
799 : 5356876 : set_cpu_sd_state_idle();
800 : :
801 : : local_irq_disable();
802 : :
803 : 10713748 : ts = &__get_cpu_var(tick_cpu_sched);
804 : 5356874 : ts->inidle = 1;
805 : 5356874 : __tick_nohz_idle_enter(ts);
806 : :
807 : : local_irq_enable();
808 : 5356648 : }
809 : : EXPORT_SYMBOL_GPL(tick_nohz_idle_enter);
810 : :
811 : : /**
812 : : * tick_nohz_irq_exit - update next tick event from interrupt exit
813 : : *
814 : : * When an interrupt fires while we are idle and it doesn't cause
815 : : * a reschedule, it may still add, modify or delete a timer, enqueue
816 : : * an RCU callback, etc...
817 : : * So we need to re-calculate and reprogram the next tick event.
818 : : */
819 : 0 : void tick_nohz_irq_exit(void)
820 : : {
821 : 1722654 : struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
822 : :
823 [ + + ]: 861327 : if (ts->inidle)
824 : 854307 : __tick_nohz_idle_enter(ts);
825 : : else
826 : : tick_nohz_full_stop_tick(ts);
827 : 0 : }
828 : :
829 : : /**
830 : : * tick_nohz_get_sleep_length - return the length of the current sleep
831 : : *
832 : : * Called from power state control code with interrupts disabled
833 : : */
834 : 0 : ktime_t tick_nohz_get_sleep_length(void)
835 : : {
836 : 11274668 : struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
837 : :
838 : 5637334 : return ts->sleep_length;
839 : : }
840 : :
841 : 0 : static void tick_nohz_restart(struct tick_sched *ts, ktime_t now)
842 : : {
843 : 1990048 : hrtimer_cancel(&ts->sched_timer);
844 : : hrtimer_set_expires(&ts->sched_timer, ts->last_tick);
845 : :
846 : : while (1) {
847 : : /* Forward the time to expire in the future */
848 : 1990051 : hrtimer_forward(&ts->sched_timer, now, tick_period);
849 : :
850 [ + - ]: 1990050 : if (ts->nohz_mode == NOHZ_MODE_HIGHRES) {
851 : : hrtimer_start_expires(&ts->sched_timer,
852 : : HRTIMER_MODE_ABS_PINNED);
853 : : /* Check, if the timer was already in the past */
854 [ - + ]: 1990052 : if (hrtimer_active(&ts->sched_timer))
855 : : break;
856 : : } else {
857 [ # # ]: 0 : if (!tick_program_event(
858 : : hrtimer_get_expires(&ts->sched_timer), 0))
859 : : break;
860 : : }
861 : : /* Reread time and update jiffies */
862 : 0 : now = ktime_get();
863 : 0 : tick_do_update_jiffies64(now);
864 : 0 : }
865 : 4 : }
866 : :
867 : 0 : static void tick_nohz_restart_sched_tick(struct tick_sched *ts, ktime_t now)
868 : : {
869 : : /* Update jiffies first */
870 : 1990051 : tick_do_update_jiffies64(now);
871 : 1990052 : update_cpu_load_nohz();
872 : :
873 : 1990051 : calc_load_exit_idle();
874 : : touch_softlockup_watchdog();
875 : : /*
876 : : * Cancel the scheduled timer and restore the tick
877 : : */
878 : 1990048 : ts->tick_stopped = 0;
879 : 1990048 : ts->idle_exittime = now;
880 : :
881 : 1990048 : tick_nohz_restart(ts, now);
882 : 1990051 : }
883 : :
884 : : static void tick_nohz_account_idle_ticks(struct tick_sched *ts)
885 : : {
886 : : #ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
887 : : unsigned long ticks;
888 : :
889 : : if (vtime_accounting_enabled())
890 : : return;
891 : : /*
892 : : * We stopped the tick in idle. Update process times would miss the
893 : : * time we slept as update_process_times does only a 1 tick
894 : : * accounting. Enforce that this is accounted to idle !
895 : : */
896 : 1990051 : ticks = jiffies - ts->idle_jiffies;
897 : : /*
898 : : * We might be one off. Do not randomly account a huge number of ticks!
899 : : */
900 [ + + ]: 1990051 : if (ticks && ticks < LONG_MAX)
901 : 432502 : account_idle_ticks(ticks);
902 : : #endif
903 : : }
904 : :
905 : : /**
906 : : * tick_nohz_idle_exit - restart the idle tick from the idle task
907 : : *
908 : : * Restart the idle tick when the CPU is woken up from idle
909 : : * This also exit the RCU extended quiescent state. The CPU
910 : : * can use RCU again after this function is called.
911 : : */
912 : 0 : void tick_nohz_idle_exit(void)
913 : : {
914 : 5356933 : int cpu = smp_processor_id();
915 : 7346984 : struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
916 : : ktime_t now;
917 : :
918 : : local_irq_disable();
919 : :
920 [ - + ][ # # ]: 5356934 : WARN_ON_ONCE(!ts->inidle);
[ - + ]
921 : :
922 : 5356940 : ts->inidle = 0;
923 : :
924 [ + + ][ + + ]: 5356940 : if (ts->idle_active || ts->tick_stopped)
925 : 4704678 : now = ktime_get();
926 : :
927 [ + + ]: 5356937 : if (ts->idle_active)
928 : : tick_nohz_stop_idle(cpu, now);
929 : :
930 [ + + ]: 5356937 : if (ts->tick_stopped) {
931 : 1990051 : tick_nohz_restart_sched_tick(ts, now);
932 : : tick_nohz_account_idle_ticks(ts);
933 : : }
934 : :
935 : : local_irq_enable();
936 : 5356929 : }
937 : : EXPORT_SYMBOL_GPL(tick_nohz_idle_exit);
938 : :
939 : 0 : static int tick_nohz_reprogram(struct tick_sched *ts, ktime_t now)
940 : : {
941 : 0 : hrtimer_forward(&ts->sched_timer, now, tick_period);
942 : 0 : return tick_program_event(hrtimer_get_expires(&ts->sched_timer), 0);
943 : : }
944 : :
945 : : /*
946 : : * The nohz low res interrupt handler
947 : : */
948 : 0 : static void tick_nohz_handler(struct clock_event_device *dev)
949 : : {
950 : 0 : struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
951 : : struct pt_regs *regs = get_irq_regs();
952 : 0 : ktime_t now = ktime_get();
953 : :
954 : 0 : dev->next_event.tv64 = KTIME_MAX;
955 : :
956 : 0 : tick_sched_do_timer(now);
957 : 0 : tick_sched_handle(ts, regs);
958 : :
959 [ # # ]: 0 : while (tick_nohz_reprogram(ts, now)) {
960 : 0 : now = ktime_get();
961 : 0 : tick_do_update_jiffies64(now);
962 : : }
963 : 0 : }
964 : :
965 : : /**
966 : : * tick_nohz_switch_to_nohz - switch to nohz mode
967 : : */
968 : 0 : static void tick_nohz_switch_to_nohz(void)
969 : : {
970 : 0 : struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
971 : : ktime_t next;
972 : :
973 [ # # ]: 0 : if (!tick_nohz_active)
974 : : return;
975 : :
976 : : local_irq_disable();
977 [ # # ]: 0 : if (tick_switch_to_oneshot(tick_nohz_handler)) {
978 : : local_irq_enable();
979 : : return;
980 : : }
981 : 0 : tick_nohz_active = 1;
982 : 0 : ts->nohz_mode = NOHZ_MODE_LOWRES;
983 : :
984 : : /*
985 : : * Recycle the hrtimer in ts, so we can share the
986 : : * hrtimer_forward with the highres code.
987 : : */
988 : 0 : hrtimer_init(&ts->sched_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
989 : : /* Get the next period */
990 : 0 : next = tick_init_jiffy_update();
991 : :
992 : : for (;;) {
993 : : hrtimer_set_expires(&ts->sched_timer, next);
994 [ # # ]: 0 : if (!tick_program_event(next, 0))
995 : : break;
996 : 0 : next = ktime_add(next, tick_period);
997 : 0 : }
998 : : local_irq_enable();
999 : : }
1000 : :
1001 : : /*
1002 : : * When NOHZ is enabled and the tick is stopped, we need to kick the
1003 : : * tick timer from irq_enter() so that the jiffies update is kept
1004 : : * alive during long running softirqs. That's ugly as hell, but
1005 : : * correctness is key even if we need to fix the offending softirq in
1006 : : * the first place.
1007 : : *
1008 : : * Note, this is different to tick_nohz_restart. We just kick the
1009 : : * timer and do not touch the other magic bits which need to be done
1010 : : * when idle is left.
1011 : : */
1012 : : static void tick_nohz_kick_tick(int cpu, ktime_t now)
1013 : : {
1014 : : #if 0
1015 : : /* Switch back to 2.6.27 behaviour */
1016 : :
1017 : : struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
1018 : : ktime_t delta;
1019 : :
1020 : : /*
1021 : : * Do not touch the tick device, when the next expiry is either
1022 : : * already reached or less/equal than the tick period.
1023 : : */
1024 : : delta = ktime_sub(hrtimer_get_expires(&ts->sched_timer), now);
1025 : : if (delta.tv64 <= tick_period.tv64)
1026 : : return;
1027 : :
1028 : : tick_nohz_restart(ts, now);
1029 : : #endif
1030 : : }
1031 : :
1032 : : static inline void tick_check_nohz(int cpu)
1033 : : {
1034 : 2560001 : struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
1035 : : ktime_t now;
1036 : :
1037 [ + + ][ + + ]: 2560001 : if (!ts->idle_active && !ts->tick_stopped)
1038 : 331295 : return;
1039 : 2228706 : now = ktime_get();
1040 [ + + ]: 2228679 : if (ts->idle_active)
1041 : 2221007 : tick_nohz_stop_idle(cpu, now);
1042 [ + + ]: 2228676 : if (ts->tick_stopped) {
1043 : 2228676 : tick_nohz_update_jiffies(now);
1044 : : tick_nohz_kick_tick(cpu, now);
1045 : : }
1046 : : }
1047 : :
1048 : : #else
1049 : :
1050 : : static inline void tick_nohz_switch_to_nohz(void) { }
1051 : : static inline void tick_check_nohz(int cpu) { }
1052 : :
1053 : : #endif /* CONFIG_NO_HZ_COMMON */
1054 : :
1055 : : /*
1056 : : * Called from irq_enter to notify about the possible interruption of idle()
1057 : : */
1058 : 0 : void tick_check_idle(int cpu)
1059 : : {
1060 : 2560130 : tick_check_oneshot_broadcast(cpu);
1061 : : tick_check_nohz(cpu);
1062 : 2559976 : }
1063 : :
1064 : : /*
1065 : : * High resolution timer specific code
1066 : : */
1067 : : #ifdef CONFIG_HIGH_RES_TIMERS
1068 : : /*
1069 : : * We rearm the timer until we get disabled by the idle code.
1070 : : * Called with interrupts disabled.
1071 : : */
1072 : 0 : static enum hrtimer_restart tick_sched_timer(struct hrtimer *timer)
1073 : : {
1074 : 7852593 : struct tick_sched *ts =
1075 : : container_of(timer, struct tick_sched, sched_timer);
1076 : : struct pt_regs *regs = get_irq_regs();
1077 : 7853055 : ktime_t now = ktime_get();
1078 : :
1079 : 7830306 : tick_sched_do_timer(now);
1080 : :
1081 : : /*
1082 : : * Do not call, when we are not in irq context and have
1083 : : * no valid regs pointer
1084 : : */
1085 [ + + ]: 7854098 : if (regs)
1086 : 7852593 : tick_sched_handle(ts, regs);
1087 : :
1088 : 7838835 : hrtimer_forward(timer, now, tick_period);
1089 : :
1090 : 7844691 : return HRTIMER_RESTART;
1091 : : }
1092 : :
1093 : : static int sched_skew_tick;
1094 : :
1095 : 0 : static int __init skew_tick(char *str)
1096 : : {
1097 : 0 : get_option(&str, &sched_skew_tick);
1098 : :
1099 : 0 : return 0;
1100 : : }
1101 : : early_param("skew_tick", skew_tick);
1102 : :
1103 : : /**
1104 : : * tick_setup_sched_timer - setup the tick emulation timer
1105 : : */
1106 : 0 : void tick_setup_sched_timer(void)
1107 : : {
1108 : 0 : struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
1109 : 0 : ktime_t now = ktime_get();
1110 : :
1111 : : /*
1112 : : * Emulate tick processing via per-CPU hrtimers:
1113 : : */
1114 : 0 : hrtimer_init(&ts->sched_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
1115 : 0 : ts->sched_timer.function = tick_sched_timer;
1116 : :
1117 : : /* Get the next period (per cpu) */
1118 : 0 : hrtimer_set_expires(&ts->sched_timer, tick_init_jiffy_update());
1119 : :
1120 : : /* Offset the tick to avert jiffies_lock contention. */
1121 [ # # ]: 0 : if (sched_skew_tick) {
1122 : 0 : u64 offset = ktime_to_ns(tick_period) >> 1;
1123 [ # # ][ # # ]: 0 : do_div(offset, num_possible_cpus());
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
1124 : 0 : offset *= smp_processor_id();
1125 : : hrtimer_add_expires_ns(&ts->sched_timer, offset);
1126 : : }
1127 : :
1128 : : for (;;) {
1129 : 0 : hrtimer_forward(&ts->sched_timer, now, tick_period);
1130 : : hrtimer_start_expires(&ts->sched_timer,
1131 : : HRTIMER_MODE_ABS_PINNED);
1132 : : /* Check, if the timer was already in the past */
1133 [ # # ]: 0 : if (hrtimer_active(&ts->sched_timer))
1134 : : break;
1135 : 0 : now = ktime_get();
1136 : 0 : }
1137 : :
1138 : : #ifdef CONFIG_NO_HZ_COMMON
1139 [ # # ]: 0 : if (tick_nohz_enabled) {
1140 : 0 : ts->nohz_mode = NOHZ_MODE_HIGHRES;
1141 : 0 : tick_nohz_active = 1;
1142 : : }
1143 : : #endif
1144 : 0 : }
1145 : : #endif /* HIGH_RES_TIMERS */
1146 : :
1147 : : #if defined CONFIG_NO_HZ_COMMON || defined CONFIG_HIGH_RES_TIMERS
1148 : 0 : void tick_cancel_sched_timer(int cpu)
1149 : : {
1150 : 0 : struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
1151 : :
1152 : : # ifdef CONFIG_HIGH_RES_TIMERS
1153 [ # # ]: 0 : if (ts->sched_timer.base)
1154 : 0 : hrtimer_cancel(&ts->sched_timer);
1155 : : # endif
1156 : :
1157 : 0 : memset(ts, 0, sizeof(*ts));
1158 : 0 : }
1159 : : #endif
1160 : :
1161 : : /**
1162 : : * Async notification about clocksource changes
1163 : : */
1164 : 0 : void tick_clock_notify(void)
1165 : : {
1166 : : int cpu;
1167 : :
1168 [ # # ]: 0 : for_each_possible_cpu(cpu)
1169 : 0 : set_bit(0, &per_cpu(tick_cpu_sched, cpu).check_clocks);
1170 : 0 : }
1171 : :
1172 : : /*
1173 : : * Async notification about clock event changes
1174 : : */
1175 : 0 : void tick_oneshot_notify(void)
1176 : : {
1177 : 0 : struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
1178 : :
1179 : 0 : set_bit(0, &ts->check_clocks);
1180 : 0 : }
1181 : :
1182 : : /**
1183 : : * Check, if a change happened, which makes oneshot possible.
1184 : : *
1185 : : * Called cyclic from the hrtimer softirq (driven by the timer
1186 : : * softirq) allow_nohz signals, that we can switch into low-res nohz
1187 : : * mode, because high resolution timers are disabled (either compile
1188 : : * or runtime).
1189 : : */
1190 : 0 : int tick_check_oneshot_change(int allow_nohz)
1191 : : {
1192 : 0 : struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
1193 : :
1194 [ # # ]: 0 : if (!test_and_clear_bit(0, &ts->check_clocks))
1195 : : return 0;
1196 : :
1197 [ # # ]: 0 : if (ts->nohz_mode != NOHZ_MODE_INACTIVE)
1198 : : return 0;
1199 : :
1200 [ # # ][ # # ]: 0 : if (!timekeeping_valid_for_hres() || !tick_is_oneshot_available())
1201 : : return 0;
1202 : :
1203 [ # # ]: 0 : if (!allow_nohz)
1204 : : return 1;
1205 : :
1206 : 0 : tick_nohz_switch_to_nohz();
1207 : 0 : return 0;
1208 : : }
|
