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