clockevents: Remove the per cpu tick skew
[linux-2.6.git] / kernel / time / tick-sched.c
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/tick.h>
23 #include <linux/module.h>
24
25 #include <asm/irq_regs.h>
26
27 #include "tick-internal.h"
28
29 /*
30  * Per cpu nohz control structure
31  */
32 static DEFINE_PER_CPU(struct tick_sched, tick_cpu_sched);
33
34 /*
35  * The time, when the last jiffy update happened. Protected by xtime_lock.
36  */
37 static ktime_t last_jiffies_update;
38
39 struct tick_sched *tick_get_tick_sched(int cpu)
40 {
41         return &per_cpu(tick_cpu_sched, cpu);
42 }
43
44 /*
45  * Must be called with interrupts disabled !
46  */
47 static void tick_do_update_jiffies64(ktime_t now)
48 {
49         unsigned long ticks = 0;
50         ktime_t delta;
51
52         /*
53          * Do a quick check without holding xtime_lock:
54          */
55         delta = ktime_sub(now, last_jiffies_update);
56         if (delta.tv64 < tick_period.tv64)
57                 return;
58
59         /* Reevalute with xtime_lock held */
60         write_seqlock(&xtime_lock);
61
62         delta = ktime_sub(now, last_jiffies_update);
63         if (delta.tv64 >= tick_period.tv64) {
64
65                 delta = ktime_sub(delta, tick_period);
66                 last_jiffies_update = ktime_add(last_jiffies_update,
67                                                 tick_period);
68
69                 /* Slow path for long timeouts */
70                 if (unlikely(delta.tv64 >= tick_period.tv64)) {
71                         s64 incr = ktime_to_ns(tick_period);
72
73                         ticks = ktime_divns(delta, incr);
74
75                         last_jiffies_update = ktime_add_ns(last_jiffies_update,
76                                                            incr * ticks);
77                 }
78                 do_timer(++ticks);
79
80                 /* Keep the tick_next_period variable up to date */
81                 tick_next_period = ktime_add(last_jiffies_update, tick_period);
82         }
83         write_sequnlock(&xtime_lock);
84 }
85
86 /*
87  * Initialize and return retrieve the jiffies update.
88  */
89 static ktime_t tick_init_jiffy_update(void)
90 {
91         ktime_t period;
92
93         write_seqlock(&xtime_lock);
94         /* Did we start the jiffies update yet ? */
95         if (last_jiffies_update.tv64 == 0)
96                 last_jiffies_update = tick_next_period;
97         period = last_jiffies_update;
98         write_sequnlock(&xtime_lock);
99         return period;
100 }
101
102 /*
103  * NOHZ - aka dynamic tick functionality
104  */
105 #ifdef CONFIG_NO_HZ
106 /*
107  * NO HZ enabled ?
108  */
109 static int tick_nohz_enabled __read_mostly  = 1;
110
111 /*
112  * Enable / Disable tickless mode
113  */
114 static int __init setup_tick_nohz(char *str)
115 {
116         if (!strcmp(str, "off"))
117                 tick_nohz_enabled = 0;
118         else if (!strcmp(str, "on"))
119                 tick_nohz_enabled = 1;
120         else
121                 return 0;
122         return 1;
123 }
124
125 __setup("nohz=", setup_tick_nohz);
126
127 /**
128  * tick_nohz_update_jiffies - update jiffies when idle was interrupted
129  *
130  * Called from interrupt entry when the CPU was idle
131  *
132  * In case the sched_tick was stopped on this CPU, we have to check if jiffies
133  * must be updated. Otherwise an interrupt handler could use a stale jiffy
134  * value. We do this unconditionally on any cpu, as we don't know whether the
135  * cpu, which has the update task assigned is in a long sleep.
136  */
137 static void tick_nohz_update_jiffies(ktime_t now)
138 {
139         int cpu = smp_processor_id();
140         struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
141         unsigned long flags;
142
143         cpumask_clear_cpu(cpu, nohz_cpu_mask);
144         ts->idle_waketime = now;
145
146         local_irq_save(flags);
147         tick_do_update_jiffies64(now);
148         local_irq_restore(flags);
149
150         touch_softlockup_watchdog();
151 }
152
153 /*
154  * Updates the per cpu time idle statistics counters
155  */
156 static void
157 update_ts_time_stats(int cpu, struct tick_sched *ts, ktime_t now, u64 *last_update_time)
158 {
159         ktime_t delta;
160
161         if (ts->idle_active) {
162                 delta = ktime_sub(now, ts->idle_entrytime);
163                 ts->idle_sleeptime = ktime_add(ts->idle_sleeptime, delta);
164                 if (nr_iowait_cpu(cpu) > 0)
165                         ts->iowait_sleeptime = ktime_add(ts->iowait_sleeptime, delta);
166                 ts->idle_entrytime = now;
167         }
168
169         if (last_update_time)
170                 *last_update_time = ktime_to_us(now);
171
172 }
173
174 static void tick_nohz_stop_idle(int cpu, ktime_t now)
175 {
176         struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
177
178         update_ts_time_stats(cpu, ts, now, NULL);
179         ts->idle_active = 0;
180
181         sched_clock_idle_wakeup_event(0);
182 }
183
184 static ktime_t tick_nohz_start_idle(int cpu, struct tick_sched *ts)
185 {
186         ktime_t now;
187
188         now = ktime_get();
189
190         update_ts_time_stats(cpu, ts, now, NULL);
191
192         ts->idle_entrytime = now;
193         ts->idle_active = 1;
194         sched_clock_idle_sleep_event();
195         return now;
196 }
197
198 /**
199  * get_cpu_idle_time_us - get the total idle time of a cpu
200  * @cpu: CPU number to query
201  * @last_update_time: variable to store update time in
202  *
203  * Return the cummulative idle time (since boot) for a given
204  * CPU, in microseconds. The idle time returned includes
205  * the iowait time (unlike what "top" and co report).
206  *
207  * This time is measured via accounting rather than sampling,
208  * and is as accurate as ktime_get() is.
209  *
210  * This function returns -1 if NOHZ is not enabled.
211  */
212 u64 get_cpu_idle_time_us(int cpu, u64 *last_update_time)
213 {
214         struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
215
216         if (!tick_nohz_enabled)
217                 return -1;
218
219         update_ts_time_stats(cpu, ts, ktime_get(), last_update_time);
220
221         return ktime_to_us(ts->idle_sleeptime);
222 }
223 EXPORT_SYMBOL_GPL(get_cpu_idle_time_us);
224
225 /*
226  * get_cpu_iowait_time_us - get the total iowait time of a cpu
227  * @cpu: CPU number to query
228  * @last_update_time: variable to store update time in
229  *
230  * Return the cummulative iowait time (since boot) for a given
231  * CPU, in microseconds.
232  *
233  * This time is measured via accounting rather than sampling,
234  * and is as accurate as ktime_get() is.
235  *
236  * This function returns -1 if NOHZ is not enabled.
237  */
238 u64 get_cpu_iowait_time_us(int cpu, u64 *last_update_time)
239 {
240         struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
241
242         if (!tick_nohz_enabled)
243                 return -1;
244
245         update_ts_time_stats(cpu, ts, ktime_get(), last_update_time);
246
247         return ktime_to_us(ts->iowait_sleeptime);
248 }
249 EXPORT_SYMBOL_GPL(get_cpu_iowait_time_us);
250
251 /**
252  * tick_nohz_stop_sched_tick - stop the idle tick from the idle task
253  *
254  * When the next event is more than a tick into the future, stop the idle tick
255  * Called either from the idle loop or from irq_exit() when an idle period was
256  * just interrupted by an interrupt which did not cause a reschedule.
257  */
258 void tick_nohz_stop_sched_tick(int inidle)
259 {
260         unsigned long seq, last_jiffies, next_jiffies, delta_jiffies, flags;
261         struct tick_sched *ts;
262         ktime_t last_update, expires, now;
263         struct clock_event_device *dev = __get_cpu_var(tick_cpu_device).evtdev;
264         u64 time_delta;
265         int cpu;
266
267         local_irq_save(flags);
268
269         cpu = smp_processor_id();
270         ts = &per_cpu(tick_cpu_sched, cpu);
271
272         /*
273          * Call to tick_nohz_start_idle stops the last_update_time from being
274          * updated. Thus, it must not be called in the event we are called from
275          * irq_exit() with the prior state different than idle.
276          */
277         if (!inidle && !ts->inidle)
278                 goto end;
279
280         /*
281          * Set ts->inidle unconditionally. Even if the system did not
282          * switch to NOHZ mode the cpu frequency governers rely on the
283          * update of the idle time accounting in tick_nohz_start_idle().
284          */
285         ts->inidle = 1;
286
287         now = tick_nohz_start_idle(cpu, ts);
288
289         /*
290          * If this cpu is offline and it is the one which updates
291          * jiffies, then give up the assignment and let it be taken by
292          * the cpu which runs the tick timer next. If we don't drop
293          * this here the jiffies might be stale and do_timer() never
294          * invoked.
295          */
296         if (unlikely(!cpu_online(cpu))) {
297                 if (cpu == tick_do_timer_cpu)
298                         tick_do_timer_cpu = TICK_DO_TIMER_NONE;
299         }
300
301         if (unlikely(ts->nohz_mode == NOHZ_MODE_INACTIVE))
302                 goto end;
303
304         if (need_resched())
305                 goto end;
306
307         if (unlikely(local_softirq_pending() && cpu_online(cpu))) {
308                 static int ratelimit;
309
310                 if (ratelimit < 10) {
311                         printk(KERN_ERR "NOHZ: local_softirq_pending %02x\n",
312                                (unsigned int) local_softirq_pending());
313                         ratelimit++;
314                 }
315                 goto end;
316         }
317
318         ts->idle_calls++;
319         /* Read jiffies and the time when jiffies were updated last */
320         do {
321                 seq = read_seqbegin(&xtime_lock);
322                 last_update = last_jiffies_update;
323                 last_jiffies = jiffies;
324                 time_delta = timekeeping_max_deferment();
325         } while (read_seqretry(&xtime_lock, seq));
326
327         if (rcu_needs_cpu(cpu) || printk_needs_cpu(cpu) ||
328             arch_needs_cpu(cpu) || nohz_ratelimit(cpu)) {
329                 next_jiffies = last_jiffies + 1;
330                 delta_jiffies = 1;
331         } else {
332                 /* Get the next timer wheel timer */
333                 next_jiffies = get_next_timer_interrupt(last_jiffies);
334                 delta_jiffies = next_jiffies - last_jiffies;
335         }
336         /*
337          * Do not stop the tick, if we are only one off
338          * or if the cpu is required for rcu
339          */
340         if (!ts->tick_stopped && delta_jiffies == 1)
341                 goto out;
342
343         /* Schedule the tick, if we are at least one jiffie off */
344         if ((long)delta_jiffies >= 1) {
345
346                 /*
347                  * If this cpu is the one which updates jiffies, then
348                  * give up the assignment and let it be taken by the
349                  * cpu which runs the tick timer next, which might be
350                  * this cpu as well. If we don't drop this here the
351                  * jiffies might be stale and do_timer() never
352                  * invoked. Keep track of the fact that it was the one
353                  * which had the do_timer() duty last. If this cpu is
354                  * the one which had the do_timer() duty last, we
355                  * limit the sleep time to the timekeeping
356                  * max_deferement value which we retrieved
357                  * above. Otherwise we can sleep as long as we want.
358                  */
359                 if (cpu == tick_do_timer_cpu) {
360                         tick_do_timer_cpu = TICK_DO_TIMER_NONE;
361                         ts->do_timer_last = 1;
362                 } else if (tick_do_timer_cpu != TICK_DO_TIMER_NONE) {
363                         time_delta = KTIME_MAX;
364                         ts->do_timer_last = 0;
365                 } else if (!ts->do_timer_last) {
366                         time_delta = KTIME_MAX;
367                 }
368
369                 /*
370                  * calculate the expiry time for the next timer wheel
371                  * timer. delta_jiffies >= NEXT_TIMER_MAX_DELTA signals
372                  * that there is no timer pending or at least extremely
373                  * far into the future (12 days for HZ=1000). In this
374                  * case we set the expiry to the end of time.
375                  */
376                 if (likely(delta_jiffies < NEXT_TIMER_MAX_DELTA)) {
377                         /*
378                          * Calculate the time delta for the next timer event.
379                          * If the time delta exceeds the maximum time delta
380                          * permitted by the current clocksource then adjust
381                          * the time delta accordingly to ensure the
382                          * clocksource does not wrap.
383                          */
384                         time_delta = min_t(u64, time_delta,
385                                            tick_period.tv64 * delta_jiffies);
386                 }
387
388                 if (time_delta < KTIME_MAX)
389                         expires = ktime_add_ns(last_update, time_delta);
390                 else
391                         expires.tv64 = KTIME_MAX;
392
393                 if (delta_jiffies > 1)
394                         cpumask_set_cpu(cpu, nohz_cpu_mask);
395
396                 /* Skip reprogram of event if its not changed */
397                 if (ts->tick_stopped && ktime_equal(expires, dev->next_event))
398                         goto out;
399
400                 /*
401                  * nohz_stop_sched_tick can be called several times before
402                  * the nohz_restart_sched_tick is called. This happens when
403                  * interrupts arrive which do not cause a reschedule. In the
404                  * first call we save the current tick time, so we can restart
405                  * the scheduler tick in nohz_restart_sched_tick.
406                  */
407                 if (!ts->tick_stopped) {
408                         if (select_nohz_load_balancer(1)) {
409                                 /*
410                                  * sched tick not stopped!
411                                  */
412                                 cpumask_clear_cpu(cpu, nohz_cpu_mask);
413                                 goto out;
414                         }
415
416                         ts->idle_tick = hrtimer_get_expires(&ts->sched_timer);
417                         ts->tick_stopped = 1;
418                         ts->idle_jiffies = last_jiffies;
419                         rcu_enter_nohz();
420                 }
421
422                 ts->idle_sleeps++;
423
424                 /* Mark expires */
425                 ts->idle_expires = expires;
426
427                 /*
428                  * If the expiration time == KTIME_MAX, then
429                  * in this case we simply stop the tick timer.
430                  */
431                  if (unlikely(expires.tv64 == KTIME_MAX)) {
432                         if (ts->nohz_mode == NOHZ_MODE_HIGHRES)
433                                 hrtimer_cancel(&ts->sched_timer);
434                         goto out;
435                 }
436
437                 if (ts->nohz_mode == NOHZ_MODE_HIGHRES) {
438                         hrtimer_start(&ts->sched_timer, expires,
439                                       HRTIMER_MODE_ABS_PINNED);
440                         /* Check, if the timer was already in the past */
441                         if (hrtimer_active(&ts->sched_timer))
442                                 goto out;
443                 } else if (!tick_program_event(expires, 0))
444                                 goto out;
445                 /*
446                  * We are past the event already. So we crossed a
447                  * jiffie boundary. Update jiffies and raise the
448                  * softirq.
449                  */
450                 tick_do_update_jiffies64(ktime_get());
451                 cpumask_clear_cpu(cpu, nohz_cpu_mask);
452         }
453         raise_softirq_irqoff(TIMER_SOFTIRQ);
454 out:
455         ts->next_jiffies = next_jiffies;
456         ts->last_jiffies = last_jiffies;
457         ts->sleep_length = ktime_sub(dev->next_event, now);
458 end:
459         local_irq_restore(flags);
460 }
461
462 /**
463  * tick_nohz_get_sleep_length - return the length of the current sleep
464  *
465  * Called from power state control code with interrupts disabled
466  */
467 ktime_t tick_nohz_get_sleep_length(void)
468 {
469         struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
470
471         return ts->sleep_length;
472 }
473
474 static void tick_nohz_restart(struct tick_sched *ts, ktime_t now)
475 {
476         hrtimer_cancel(&ts->sched_timer);
477         hrtimer_set_expires(&ts->sched_timer, ts->idle_tick);
478
479         while (1) {
480                 /* Forward the time to expire in the future */
481                 hrtimer_forward(&ts->sched_timer, now, tick_period);
482
483                 if (ts->nohz_mode == NOHZ_MODE_HIGHRES) {
484                         hrtimer_start_expires(&ts->sched_timer,
485                                               HRTIMER_MODE_ABS_PINNED);
486                         /* Check, if the timer was already in the past */
487                         if (hrtimer_active(&ts->sched_timer))
488                                 break;
489                 } else {
490                         if (!tick_program_event(
491                                 hrtimer_get_expires(&ts->sched_timer), 0))
492                                 break;
493                 }
494                 /* Update jiffies and reread time */
495                 tick_do_update_jiffies64(now);
496                 now = ktime_get();
497         }
498 }
499
500 /**
501  * tick_nohz_restart_sched_tick - restart the idle tick from the idle task
502  *
503  * Restart the idle tick when the CPU is woken up from idle
504  */
505 void tick_nohz_restart_sched_tick(void)
506 {
507         int cpu = smp_processor_id();
508         struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
509 #ifndef CONFIG_VIRT_CPU_ACCOUNTING
510         unsigned long ticks;
511 #endif
512         ktime_t now;
513
514         local_irq_disable();
515         if (ts->idle_active || (ts->inidle && ts->tick_stopped))
516                 now = ktime_get();
517
518         if (ts->idle_active)
519                 tick_nohz_stop_idle(cpu, now);
520
521         if (!ts->inidle || !ts->tick_stopped) {
522                 ts->inidle = 0;
523                 local_irq_enable();
524                 return;
525         }
526
527         ts->inidle = 0;
528
529         rcu_exit_nohz();
530
531         /* Update jiffies first */
532         select_nohz_load_balancer(0);
533         tick_do_update_jiffies64(now);
534         cpumask_clear_cpu(cpu, nohz_cpu_mask);
535
536 #ifndef CONFIG_VIRT_CPU_ACCOUNTING
537         /*
538          * We stopped the tick in idle. Update process times would miss the
539          * time we slept as update_process_times does only a 1 tick
540          * accounting. Enforce that this is accounted to idle !
541          */
542         ticks = jiffies - ts->idle_jiffies;
543         /*
544          * We might be one off. Do not randomly account a huge number of ticks!
545          */
546         if (ticks && ticks < LONG_MAX)
547                 account_idle_ticks(ticks);
548 #endif
549
550         touch_softlockup_watchdog();
551         /*
552          * Cancel the scheduled timer and restore the tick
553          */
554         ts->tick_stopped  = 0;
555         ts->idle_exittime = now;
556
557         tick_nohz_restart(ts, now);
558
559         local_irq_enable();
560 }
561
562 static int tick_nohz_reprogram(struct tick_sched *ts, ktime_t now)
563 {
564         hrtimer_forward(&ts->sched_timer, now, tick_period);
565         return tick_program_event(hrtimer_get_expires(&ts->sched_timer), 0);
566 }
567
568 /*
569  * The nohz low res interrupt handler
570  */
571 static void tick_nohz_handler(struct clock_event_device *dev)
572 {
573         struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
574         struct pt_regs *regs = get_irq_regs();
575         int cpu = smp_processor_id();
576         ktime_t now = ktime_get();
577
578         dev->next_event.tv64 = KTIME_MAX;
579
580         /*
581          * Check if the do_timer duty was dropped. We don't care about
582          * concurrency: This happens only when the cpu in charge went
583          * into a long sleep. If two cpus happen to assign themself to
584          * this duty, then the jiffies update is still serialized by
585          * xtime_lock.
586          */
587         if (unlikely(tick_do_timer_cpu == TICK_DO_TIMER_NONE))
588                 tick_do_timer_cpu = cpu;
589
590         /* Check, if the jiffies need an update */
591         if (tick_do_timer_cpu == cpu)
592                 tick_do_update_jiffies64(now);
593
594         /*
595          * When we are idle and the tick is stopped, we have to touch
596          * the watchdog as we might not schedule for a really long
597          * time. This happens on complete idle SMP systems while
598          * waiting on the login prompt. We also increment the "start
599          * of idle" jiffy stamp so the idle accounting adjustment we
600          * do when we go busy again does not account too much ticks.
601          */
602         if (ts->tick_stopped) {
603                 touch_softlockup_watchdog();
604                 ts->idle_jiffies++;
605         }
606
607         update_process_times(user_mode(regs));
608         profile_tick(CPU_PROFILING);
609
610         while (tick_nohz_reprogram(ts, now)) {
611                 now = ktime_get();
612                 tick_do_update_jiffies64(now);
613         }
614 }
615
616 /**
617  * tick_nohz_switch_to_nohz - switch to nohz mode
618  */
619 static void tick_nohz_switch_to_nohz(void)
620 {
621         struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
622         ktime_t next;
623
624         if (!tick_nohz_enabled)
625                 return;
626
627         local_irq_disable();
628         if (tick_switch_to_oneshot(tick_nohz_handler)) {
629                 local_irq_enable();
630                 return;
631         }
632
633         ts->nohz_mode = NOHZ_MODE_LOWRES;
634
635         /*
636          * Recycle the hrtimer in ts, so we can share the
637          * hrtimer_forward with the highres code.
638          */
639         hrtimer_init(&ts->sched_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
640         /* Get the next period */
641         next = tick_init_jiffy_update();
642
643         for (;;) {
644                 hrtimer_set_expires(&ts->sched_timer, next);
645                 if (!tick_program_event(next, 0))
646                         break;
647                 next = ktime_add(next, tick_period);
648         }
649         local_irq_enable();
650
651         printk(KERN_INFO "Switched to NOHz mode on CPU #%d\n",
652                smp_processor_id());
653 }
654
655 /*
656  * When NOHZ is enabled and the tick is stopped, we need to kick the
657  * tick timer from irq_enter() so that the jiffies update is kept
658  * alive during long running softirqs. That's ugly as hell, but
659  * correctness is key even if we need to fix the offending softirq in
660  * the first place.
661  *
662  * Note, this is different to tick_nohz_restart. We just kick the
663  * timer and do not touch the other magic bits which need to be done
664  * when idle is left.
665  */
666 static void tick_nohz_kick_tick(int cpu, ktime_t now)
667 {
668 #if 0
669         /* Switch back to 2.6.27 behaviour */
670
671         struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
672         ktime_t delta;
673
674         /*
675          * Do not touch the tick device, when the next expiry is either
676          * already reached or less/equal than the tick period.
677          */
678         delta = ktime_sub(hrtimer_get_expires(&ts->sched_timer), now);
679         if (delta.tv64 <= tick_period.tv64)
680                 return;
681
682         tick_nohz_restart(ts, now);
683 #endif
684 }
685
686 static inline void tick_check_nohz(int cpu)
687 {
688         struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
689         ktime_t now;
690
691         if (!ts->idle_active && !ts->tick_stopped)
692                 return;
693         now = ktime_get();
694         if (ts->idle_active)
695                 tick_nohz_stop_idle(cpu, now);
696         if (ts->tick_stopped) {
697                 tick_nohz_update_jiffies(now);
698                 tick_nohz_kick_tick(cpu, now);
699         }
700 }
701
702 #else
703
704 static inline void tick_nohz_switch_to_nohz(void) { }
705 static inline void tick_check_nohz(int cpu) { }
706
707 #endif /* NO_HZ */
708
709 /*
710  * Called from irq_enter to notify about the possible interruption of idle()
711  */
712 void tick_check_idle(int cpu)
713 {
714         tick_check_oneshot_broadcast(cpu);
715         tick_check_nohz(cpu);
716 }
717
718 /*
719  * High resolution timer specific code
720  */
721 #ifdef CONFIG_HIGH_RES_TIMERS
722 /*
723  * We rearm the timer until we get disabled by the idle code.
724  * Called with interrupts disabled and timer->base->cpu_base->lock held.
725  */
726 static enum hrtimer_restart tick_sched_timer(struct hrtimer *timer)
727 {
728         struct tick_sched *ts =
729                 container_of(timer, struct tick_sched, sched_timer);
730         struct pt_regs *regs = get_irq_regs();
731         ktime_t now = ktime_get();
732         int cpu = smp_processor_id();
733
734 #ifdef CONFIG_NO_HZ
735         /*
736          * Check if the do_timer duty was dropped. We don't care about
737          * concurrency: This happens only when the cpu in charge went
738          * into a long sleep. If two cpus happen to assign themself to
739          * this duty, then the jiffies update is still serialized by
740          * xtime_lock.
741          */
742         if (unlikely(tick_do_timer_cpu == TICK_DO_TIMER_NONE))
743                 tick_do_timer_cpu = cpu;
744 #endif
745
746         /* Check, if the jiffies need an update */
747         if (tick_do_timer_cpu == cpu)
748                 tick_do_update_jiffies64(now);
749
750         /*
751          * Do not call, when we are not in irq context and have
752          * no valid regs pointer
753          */
754         if (regs) {
755                 /*
756                  * When we are idle and the tick is stopped, we have to touch
757                  * the watchdog as we might not schedule for a really long
758                  * time. This happens on complete idle SMP systems while
759                  * waiting on the login prompt. We also increment the "start of
760                  * idle" jiffy stamp so the idle accounting adjustment we do
761                  * when we go busy again does not account too much ticks.
762                  */
763                 if (ts->tick_stopped) {
764                         touch_softlockup_watchdog();
765                         ts->idle_jiffies++;
766                 }
767                 update_process_times(user_mode(regs));
768                 profile_tick(CPU_PROFILING);
769         }
770
771         hrtimer_forward(timer, now, tick_period);
772
773         return HRTIMER_RESTART;
774 }
775
776 /**
777  * tick_setup_sched_timer - setup the tick emulation timer
778  */
779 void tick_setup_sched_timer(void)
780 {
781         struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
782         ktime_t now = ktime_get();
783
784         /*
785          * Emulate tick processing via per-CPU hrtimers:
786          */
787         hrtimer_init(&ts->sched_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
788         ts->sched_timer.function = tick_sched_timer;
789
790         /* Get the next period (per cpu) */
791         hrtimer_set_expires(&ts->sched_timer, tick_init_jiffy_update());
792
793         for (;;) {
794                 hrtimer_forward(&ts->sched_timer, now, tick_period);
795                 hrtimer_start_expires(&ts->sched_timer,
796                                       HRTIMER_MODE_ABS_PINNED);
797                 /* Check, if the timer was already in the past */
798                 if (hrtimer_active(&ts->sched_timer))
799                         break;
800                 now = ktime_get();
801         }
802
803 #ifdef CONFIG_NO_HZ
804         if (tick_nohz_enabled)
805                 ts->nohz_mode = NOHZ_MODE_HIGHRES;
806 #endif
807 }
808 #endif /* HIGH_RES_TIMERS */
809
810 #if defined CONFIG_NO_HZ || defined CONFIG_HIGH_RES_TIMERS
811 void tick_cancel_sched_timer(int cpu)
812 {
813         struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
814
815 # ifdef CONFIG_HIGH_RES_TIMERS
816         if (ts->sched_timer.base)
817                 hrtimer_cancel(&ts->sched_timer);
818 # endif
819
820         ts->nohz_mode = NOHZ_MODE_INACTIVE;
821 }
822 #endif
823
824 /**
825  * Async notification about clocksource changes
826  */
827 void tick_clock_notify(void)
828 {
829         int cpu;
830
831         for_each_possible_cpu(cpu)
832                 set_bit(0, &per_cpu(tick_cpu_sched, cpu).check_clocks);
833 }
834
835 /*
836  * Async notification about clock event changes
837  */
838 void tick_oneshot_notify(void)
839 {
840         struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
841
842         set_bit(0, &ts->check_clocks);
843 }
844
845 /**
846  * Check, if a change happened, which makes oneshot possible.
847  *
848  * Called cyclic from the hrtimer softirq (driven by the timer
849  * softirq) allow_nohz signals, that we can switch into low-res nohz
850  * mode, because high resolution timers are disabled (either compile
851  * or runtime).
852  */
853 int tick_check_oneshot_change(int allow_nohz)
854 {
855         struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
856
857         if (!test_and_clear_bit(0, &ts->check_clocks))
858                 return 0;
859
860         if (ts->nohz_mode != NOHZ_MODE_INACTIVE)
861                 return 0;
862
863         if (!timekeeping_valid_for_hres() || !tick_is_oneshot_available())
864                 return 0;
865
866         if (!allow_nohz)
867                 return 1;
868
869         tick_nohz_switch_to_nohz();
870         return 0;
871 }