time: Convert CONFIG_GENERIC_TIME_VSYSCALL to CONFIG_GENERIC_TIME_VSYSCALL_OLD
[linux-3.10.git] / kernel / time / timekeeping.c
1 /*
2  *  linux/kernel/time/timekeeping.c
3  *
4  *  Kernel timekeeping code and accessor functions
5  *
6  *  This code was moved from linux/kernel/timer.c.
7  *  Please see that file for copyright and history logs.
8  *
9  */
10
11 #include <linux/timekeeper_internal.h>
12 #include <linux/module.h>
13 #include <linux/interrupt.h>
14 #include <linux/percpu.h>
15 #include <linux/init.h>
16 #include <linux/mm.h>
17 #include <linux/sched.h>
18 #include <linux/syscore_ops.h>
19 #include <linux/clocksource.h>
20 #include <linux/jiffies.h>
21 #include <linux/time.h>
22 #include <linux/tick.h>
23 #include <linux/stop_machine.h>
24
25
26 static struct timekeeper timekeeper;
27
28 /*
29  * This read-write spinlock protects us from races in SMP while
30  * playing with xtime.
31  */
32 __cacheline_aligned_in_smp DEFINE_SEQLOCK(xtime_lock);
33
34 /* flag for if timekeeping is suspended */
35 int __read_mostly timekeeping_suspended;
36
37 static inline void tk_normalize_xtime(struct timekeeper *tk)
38 {
39         while (tk->xtime_nsec >= ((u64)NSEC_PER_SEC << tk->shift)) {
40                 tk->xtime_nsec -= (u64)NSEC_PER_SEC << tk->shift;
41                 tk->xtime_sec++;
42         }
43 }
44
45 static struct timespec tk_xtime(struct timekeeper *tk)
46 {
47         struct timespec ts;
48
49         ts.tv_sec = tk->xtime_sec;
50         ts.tv_nsec = (long)(tk->xtime_nsec >> tk->shift);
51         return ts;
52 }
53
54 static void tk_set_xtime(struct timekeeper *tk, const struct timespec *ts)
55 {
56         tk->xtime_sec = ts->tv_sec;
57         tk->xtime_nsec = (u64)ts->tv_nsec << tk->shift;
58 }
59
60 static void tk_xtime_add(struct timekeeper *tk, const struct timespec *ts)
61 {
62         tk->xtime_sec += ts->tv_sec;
63         tk->xtime_nsec += (u64)ts->tv_nsec << tk->shift;
64         tk_normalize_xtime(tk);
65 }
66
67 static void tk_set_wall_to_mono(struct timekeeper *tk, struct timespec wtm)
68 {
69         struct timespec tmp;
70
71         /*
72          * Verify consistency of: offset_real = -wall_to_monotonic
73          * before modifying anything
74          */
75         set_normalized_timespec(&tmp, -tk->wall_to_monotonic.tv_sec,
76                                         -tk->wall_to_monotonic.tv_nsec);
77         WARN_ON_ONCE(tk->offs_real.tv64 != timespec_to_ktime(tmp).tv64);
78         tk->wall_to_monotonic = wtm;
79         set_normalized_timespec(&tmp, -wtm.tv_sec, -wtm.tv_nsec);
80         tk->offs_real = timespec_to_ktime(tmp);
81 }
82
83 static void tk_set_sleep_time(struct timekeeper *tk, struct timespec t)
84 {
85         /* Verify consistency before modifying */
86         WARN_ON_ONCE(tk->offs_boot.tv64 != timespec_to_ktime(tk->total_sleep_time).tv64);
87
88         tk->total_sleep_time    = t;
89         tk->offs_boot           = timespec_to_ktime(t);
90 }
91
92 /**
93  * timekeeper_setup_internals - Set up internals to use clocksource clock.
94  *
95  * @clock:              Pointer to clocksource.
96  *
97  * Calculates a fixed cycle/nsec interval for a given clocksource/adjustment
98  * pair and interval request.
99  *
100  * Unless you're the timekeeping code, you should not be using this!
101  */
102 static void tk_setup_internals(struct timekeeper *tk, struct clocksource *clock)
103 {
104         cycle_t interval;
105         u64 tmp, ntpinterval;
106         struct clocksource *old_clock;
107
108         old_clock = tk->clock;
109         tk->clock = clock;
110         clock->cycle_last = clock->read(clock);
111
112         /* Do the ns -> cycle conversion first, using original mult */
113         tmp = NTP_INTERVAL_LENGTH;
114         tmp <<= clock->shift;
115         ntpinterval = tmp;
116         tmp += clock->mult/2;
117         do_div(tmp, clock->mult);
118         if (tmp == 0)
119                 tmp = 1;
120
121         interval = (cycle_t) tmp;
122         tk->cycle_interval = interval;
123
124         /* Go back from cycles -> shifted ns */
125         tk->xtime_interval = (u64) interval * clock->mult;
126         tk->xtime_remainder = ntpinterval - tk->xtime_interval;
127         tk->raw_interval =
128                 ((u64) interval * clock->mult) >> clock->shift;
129
130          /* if changing clocks, convert xtime_nsec shift units */
131         if (old_clock) {
132                 int shift_change = clock->shift - old_clock->shift;
133                 if (shift_change < 0)
134                         tk->xtime_nsec >>= -shift_change;
135                 else
136                         tk->xtime_nsec <<= shift_change;
137         }
138         tk->shift = clock->shift;
139
140         tk->ntp_error = 0;
141         tk->ntp_error_shift = NTP_SCALE_SHIFT - clock->shift;
142
143         /*
144          * The timekeeper keeps its own mult values for the currently
145          * active clocksource. These value will be adjusted via NTP
146          * to counteract clock drifting.
147          */
148         tk->mult = clock->mult;
149 }
150
151 /* Timekeeper helper functions. */
152 static inline s64 timekeeping_get_ns(struct timekeeper *tk)
153 {
154         cycle_t cycle_now, cycle_delta;
155         struct clocksource *clock;
156         s64 nsec;
157
158         /* read clocksource: */
159         clock = tk->clock;
160         cycle_now = clock->read(clock);
161
162         /* calculate the delta since the last update_wall_time: */
163         cycle_delta = (cycle_now - clock->cycle_last) & clock->mask;
164
165         nsec = cycle_delta * tk->mult + tk->xtime_nsec;
166         nsec >>= tk->shift;
167
168         /* If arch requires, add in gettimeoffset() */
169         return nsec + arch_gettimeoffset();
170 }
171
172 static inline s64 timekeeping_get_ns_raw(struct timekeeper *tk)
173 {
174         cycle_t cycle_now, cycle_delta;
175         struct clocksource *clock;
176         s64 nsec;
177
178         /* read clocksource: */
179         clock = tk->clock;
180         cycle_now = clock->read(clock);
181
182         /* calculate the delta since the last update_wall_time: */
183         cycle_delta = (cycle_now - clock->cycle_last) & clock->mask;
184
185         /* convert delta to nanoseconds. */
186         nsec = clocksource_cyc2ns(cycle_delta, clock->mult, clock->shift);
187
188         /* If arch requires, add in gettimeoffset() */
189         return nsec + arch_gettimeoffset();
190 }
191
192 /* must hold write on timekeeper.lock */
193 static void timekeeping_update(struct timekeeper *tk, bool clearntp)
194 {
195         struct timespec xt;
196
197         if (clearntp) {
198                 tk->ntp_error = 0;
199                 ntp_clear();
200         }
201         xt = tk_xtime(tk);
202         update_vsyscall_old(&xt, &tk->wall_to_monotonic, tk->clock, tk->mult);
203 }
204
205 /**
206  * timekeeping_forward_now - update clock to the current time
207  *
208  * Forward the current clock to update its state since the last call to
209  * update_wall_time(). This is useful before significant clock changes,
210  * as it avoids having to deal with this time offset explicitly.
211  */
212 static void timekeeping_forward_now(struct timekeeper *tk)
213 {
214         cycle_t cycle_now, cycle_delta;
215         struct clocksource *clock;
216         s64 nsec;
217
218         clock = tk->clock;
219         cycle_now = clock->read(clock);
220         cycle_delta = (cycle_now - clock->cycle_last) & clock->mask;
221         clock->cycle_last = cycle_now;
222
223         tk->xtime_nsec += cycle_delta * tk->mult;
224
225         /* If arch requires, add in gettimeoffset() */
226         tk->xtime_nsec += (u64)arch_gettimeoffset() << tk->shift;
227
228         tk_normalize_xtime(tk);
229
230         nsec = clocksource_cyc2ns(cycle_delta, clock->mult, clock->shift);
231         timespec_add_ns(&tk->raw_time, nsec);
232 }
233
234 /**
235  * getnstimeofday - Returns the time of day in a timespec
236  * @ts:         pointer to the timespec to be set
237  *
238  * Returns the time of day in a timespec.
239  */
240 void getnstimeofday(struct timespec *ts)
241 {
242         struct timekeeper *tk = &timekeeper;
243         unsigned long seq;
244         s64 nsecs = 0;
245
246         WARN_ON(timekeeping_suspended);
247
248         do {
249                 seq = read_seqbegin(&tk->lock);
250
251                 ts->tv_sec = tk->xtime_sec;
252                 nsecs = timekeeping_get_ns(tk);
253
254         } while (read_seqretry(&tk->lock, seq));
255
256         ts->tv_nsec = 0;
257         timespec_add_ns(ts, nsecs);
258 }
259 EXPORT_SYMBOL(getnstimeofday);
260
261 ktime_t ktime_get(void)
262 {
263         struct timekeeper *tk = &timekeeper;
264         unsigned int seq;
265         s64 secs, nsecs;
266
267         WARN_ON(timekeeping_suspended);
268
269         do {
270                 seq = read_seqbegin(&tk->lock);
271                 secs = tk->xtime_sec + tk->wall_to_monotonic.tv_sec;
272                 nsecs = timekeeping_get_ns(tk) + tk->wall_to_monotonic.tv_nsec;
273
274         } while (read_seqretry(&tk->lock, seq));
275         /*
276          * Use ktime_set/ktime_add_ns to create a proper ktime on
277          * 32-bit architectures without CONFIG_KTIME_SCALAR.
278          */
279         return ktime_add_ns(ktime_set(secs, 0), nsecs);
280 }
281 EXPORT_SYMBOL_GPL(ktime_get);
282
283 /**
284  * ktime_get_ts - get the monotonic clock in timespec format
285  * @ts:         pointer to timespec variable
286  *
287  * The function calculates the monotonic clock from the realtime
288  * clock and the wall_to_monotonic offset and stores the result
289  * in normalized timespec format in the variable pointed to by @ts.
290  */
291 void ktime_get_ts(struct timespec *ts)
292 {
293         struct timekeeper *tk = &timekeeper;
294         struct timespec tomono;
295         s64 nsec;
296         unsigned int seq;
297
298         WARN_ON(timekeeping_suspended);
299
300         do {
301                 seq = read_seqbegin(&tk->lock);
302                 ts->tv_sec = tk->xtime_sec;
303                 nsec = timekeeping_get_ns(tk);
304                 tomono = tk->wall_to_monotonic;
305
306         } while (read_seqretry(&tk->lock, seq));
307
308         ts->tv_sec += tomono.tv_sec;
309         ts->tv_nsec = 0;
310         timespec_add_ns(ts, nsec + tomono.tv_nsec);
311 }
312 EXPORT_SYMBOL_GPL(ktime_get_ts);
313
314 #ifdef CONFIG_NTP_PPS
315
316 /**
317  * getnstime_raw_and_real - get day and raw monotonic time in timespec format
318  * @ts_raw:     pointer to the timespec to be set to raw monotonic time
319  * @ts_real:    pointer to the timespec to be set to the time of day
320  *
321  * This function reads both the time of day and raw monotonic time at the
322  * same time atomically and stores the resulting timestamps in timespec
323  * format.
324  */
325 void getnstime_raw_and_real(struct timespec *ts_raw, struct timespec *ts_real)
326 {
327         struct timekeeper *tk = &timekeeper;
328         unsigned long seq;
329         s64 nsecs_raw, nsecs_real;
330
331         WARN_ON_ONCE(timekeeping_suspended);
332
333         do {
334                 seq = read_seqbegin(&tk->lock);
335
336                 *ts_raw = tk->raw_time;
337                 ts_real->tv_sec = tk->xtime_sec;
338                 ts_real->tv_nsec = 0;
339
340                 nsecs_raw = timekeeping_get_ns_raw(tk);
341                 nsecs_real = timekeeping_get_ns(tk);
342
343         } while (read_seqretry(&tk->lock, seq));
344
345         timespec_add_ns(ts_raw, nsecs_raw);
346         timespec_add_ns(ts_real, nsecs_real);
347 }
348 EXPORT_SYMBOL(getnstime_raw_and_real);
349
350 #endif /* CONFIG_NTP_PPS */
351
352 /**
353  * do_gettimeofday - Returns the time of day in a timeval
354  * @tv:         pointer to the timeval to be set
355  *
356  * NOTE: Users should be converted to using getnstimeofday()
357  */
358 void do_gettimeofday(struct timeval *tv)
359 {
360         struct timespec now;
361
362         getnstimeofday(&now);
363         tv->tv_sec = now.tv_sec;
364         tv->tv_usec = now.tv_nsec/1000;
365 }
366 EXPORT_SYMBOL(do_gettimeofday);
367
368 /**
369  * do_settimeofday - Sets the time of day
370  * @tv:         pointer to the timespec variable containing the new time
371  *
372  * Sets the time of day to the new time and update NTP and notify hrtimers
373  */
374 int do_settimeofday(const struct timespec *tv)
375 {
376         struct timekeeper *tk = &timekeeper;
377         struct timespec ts_delta, xt;
378         unsigned long flags;
379
380         if (!timespec_valid_strict(tv))
381                 return -EINVAL;
382
383         write_seqlock_irqsave(&tk->lock, flags);
384
385         timekeeping_forward_now(tk);
386
387         xt = tk_xtime(tk);
388         ts_delta.tv_sec = tv->tv_sec - xt.tv_sec;
389         ts_delta.tv_nsec = tv->tv_nsec - xt.tv_nsec;
390
391         tk_set_wall_to_mono(tk, timespec_sub(tk->wall_to_monotonic, ts_delta));
392
393         tk_set_xtime(tk, tv);
394
395         timekeeping_update(tk, true);
396
397         write_sequnlock_irqrestore(&tk->lock, flags);
398
399         /* signal hrtimers about time change */
400         clock_was_set();
401
402         return 0;
403 }
404 EXPORT_SYMBOL(do_settimeofday);
405
406 /**
407  * timekeeping_inject_offset - Adds or subtracts from the current time.
408  * @tv:         pointer to the timespec variable containing the offset
409  *
410  * Adds or subtracts an offset value from the current time.
411  */
412 int timekeeping_inject_offset(struct timespec *ts)
413 {
414         struct timekeeper *tk = &timekeeper;
415         unsigned long flags;
416         struct timespec tmp;
417         int ret = 0;
418
419         if ((unsigned long)ts->tv_nsec >= NSEC_PER_SEC)
420                 return -EINVAL;
421
422         write_seqlock_irqsave(&tk->lock, flags);
423
424         timekeeping_forward_now(tk);
425
426         /* Make sure the proposed value is valid */
427         tmp = timespec_add(tk_xtime(tk),  *ts);
428         if (!timespec_valid_strict(&tmp)) {
429                 ret = -EINVAL;
430                 goto error;
431         }
432
433         tk_xtime_add(tk, ts);
434         tk_set_wall_to_mono(tk, timespec_sub(tk->wall_to_monotonic, *ts));
435
436 error: /* even if we error out, we forwarded the time, so call update */
437         timekeeping_update(tk, true);
438
439         write_sequnlock_irqrestore(&tk->lock, flags);
440
441         /* signal hrtimers about time change */
442         clock_was_set();
443
444         return ret;
445 }
446 EXPORT_SYMBOL(timekeeping_inject_offset);
447
448 /**
449  * change_clocksource - Swaps clocksources if a new one is available
450  *
451  * Accumulates current time interval and initializes new clocksource
452  */
453 static int change_clocksource(void *data)
454 {
455         struct timekeeper *tk = &timekeeper;
456         struct clocksource *new, *old;
457         unsigned long flags;
458
459         new = (struct clocksource *) data;
460
461         write_seqlock_irqsave(&tk->lock, flags);
462
463         timekeeping_forward_now(tk);
464         if (!new->enable || new->enable(new) == 0) {
465                 old = tk->clock;
466                 tk_setup_internals(tk, new);
467                 if (old->disable)
468                         old->disable(old);
469         }
470         timekeeping_update(tk, true);
471
472         write_sequnlock_irqrestore(&tk->lock, flags);
473
474         return 0;
475 }
476
477 /**
478  * timekeeping_notify - Install a new clock source
479  * @clock:              pointer to the clock source
480  *
481  * This function is called from clocksource.c after a new, better clock
482  * source has been registered. The caller holds the clocksource_mutex.
483  */
484 void timekeeping_notify(struct clocksource *clock)
485 {
486         struct timekeeper *tk = &timekeeper;
487
488         if (tk->clock == clock)
489                 return;
490         stop_machine(change_clocksource, clock, NULL);
491         tick_clock_notify();
492 }
493
494 /**
495  * ktime_get_real - get the real (wall-) time in ktime_t format
496  *
497  * returns the time in ktime_t format
498  */
499 ktime_t ktime_get_real(void)
500 {
501         struct timespec now;
502
503         getnstimeofday(&now);
504
505         return timespec_to_ktime(now);
506 }
507 EXPORT_SYMBOL_GPL(ktime_get_real);
508
509 /**
510  * getrawmonotonic - Returns the raw monotonic time in a timespec
511  * @ts:         pointer to the timespec to be set
512  *
513  * Returns the raw monotonic time (completely un-modified by ntp)
514  */
515 void getrawmonotonic(struct timespec *ts)
516 {
517         struct timekeeper *tk = &timekeeper;
518         unsigned long seq;
519         s64 nsecs;
520
521         do {
522                 seq = read_seqbegin(&tk->lock);
523                 nsecs = timekeeping_get_ns_raw(tk);
524                 *ts = tk->raw_time;
525
526         } while (read_seqretry(&tk->lock, seq));
527
528         timespec_add_ns(ts, nsecs);
529 }
530 EXPORT_SYMBOL(getrawmonotonic);
531
532 /**
533  * timekeeping_valid_for_hres - Check if timekeeping is suitable for hres
534  */
535 int timekeeping_valid_for_hres(void)
536 {
537         struct timekeeper *tk = &timekeeper;
538         unsigned long seq;
539         int ret;
540
541         do {
542                 seq = read_seqbegin(&tk->lock);
543
544                 ret = tk->clock->flags & CLOCK_SOURCE_VALID_FOR_HRES;
545
546         } while (read_seqretry(&tk->lock, seq));
547
548         return ret;
549 }
550
551 /**
552  * timekeeping_max_deferment - Returns max time the clocksource can be deferred
553  */
554 u64 timekeeping_max_deferment(void)
555 {
556         struct timekeeper *tk = &timekeeper;
557         unsigned long seq;
558         u64 ret;
559
560         do {
561                 seq = read_seqbegin(&tk->lock);
562
563                 ret = tk->clock->max_idle_ns;
564
565         } while (read_seqretry(&tk->lock, seq));
566
567         return ret;
568 }
569
570 /**
571  * read_persistent_clock -  Return time from the persistent clock.
572  *
573  * Weak dummy function for arches that do not yet support it.
574  * Reads the time from the battery backed persistent clock.
575  * Returns a timespec with tv_sec=0 and tv_nsec=0 if unsupported.
576  *
577  *  XXX - Do be sure to remove it once all arches implement it.
578  */
579 void __attribute__((weak)) read_persistent_clock(struct timespec *ts)
580 {
581         ts->tv_sec = 0;
582         ts->tv_nsec = 0;
583 }
584
585 /**
586  * read_boot_clock -  Return time of the system start.
587  *
588  * Weak dummy function for arches that do not yet support it.
589  * Function to read the exact time the system has been started.
590  * Returns a timespec with tv_sec=0 and tv_nsec=0 if unsupported.
591  *
592  *  XXX - Do be sure to remove it once all arches implement it.
593  */
594 void __attribute__((weak)) read_boot_clock(struct timespec *ts)
595 {
596         ts->tv_sec = 0;
597         ts->tv_nsec = 0;
598 }
599
600 /*
601  * timekeeping_init - Initializes the clocksource and common timekeeping values
602  */
603 void __init timekeeping_init(void)
604 {
605         struct timekeeper *tk = &timekeeper;
606         struct clocksource *clock;
607         unsigned long flags;
608         struct timespec now, boot, tmp;
609
610         read_persistent_clock(&now);
611         if (!timespec_valid_strict(&now)) {
612                 pr_warn("WARNING: Persistent clock returned invalid value!\n"
613                         "         Check your CMOS/BIOS settings.\n");
614                 now.tv_sec = 0;
615                 now.tv_nsec = 0;
616         }
617
618         read_boot_clock(&boot);
619         if (!timespec_valid_strict(&boot)) {
620                 pr_warn("WARNING: Boot clock returned invalid value!\n"
621                         "         Check your CMOS/BIOS settings.\n");
622                 boot.tv_sec = 0;
623                 boot.tv_nsec = 0;
624         }
625
626         seqlock_init(&tk->lock);
627
628         ntp_init();
629
630         write_seqlock_irqsave(&tk->lock, flags);
631         clock = clocksource_default_clock();
632         if (clock->enable)
633                 clock->enable(clock);
634         tk_setup_internals(tk, clock);
635
636         tk_set_xtime(tk, &now);
637         tk->raw_time.tv_sec = 0;
638         tk->raw_time.tv_nsec = 0;
639         if (boot.tv_sec == 0 && boot.tv_nsec == 0)
640                 boot = tk_xtime(tk);
641
642         set_normalized_timespec(&tmp, -boot.tv_sec, -boot.tv_nsec);
643         tk_set_wall_to_mono(tk, tmp);
644
645         tmp.tv_sec = 0;
646         tmp.tv_nsec = 0;
647         tk_set_sleep_time(tk, tmp);
648
649         write_sequnlock_irqrestore(&tk->lock, flags);
650 }
651
652 /* time in seconds when suspend began */
653 static struct timespec timekeeping_suspend_time;
654
655 /**
656  * __timekeeping_inject_sleeptime - Internal function to add sleep interval
657  * @delta: pointer to a timespec delta value
658  *
659  * Takes a timespec offset measuring a suspend interval and properly
660  * adds the sleep offset to the timekeeping variables.
661  */
662 static void __timekeeping_inject_sleeptime(struct timekeeper *tk,
663                                                         struct timespec *delta)
664 {
665         if (!timespec_valid_strict(delta)) {
666                 printk(KERN_WARNING "__timekeeping_inject_sleeptime: Invalid "
667                                         "sleep delta value!\n");
668                 return;
669         }
670         tk_xtime_add(tk, delta);
671         tk_set_wall_to_mono(tk, timespec_sub(tk->wall_to_monotonic, *delta));
672         tk_set_sleep_time(tk, timespec_add(tk->total_sleep_time, *delta));
673 }
674
675 /**
676  * timekeeping_inject_sleeptime - Adds suspend interval to timeekeeping values
677  * @delta: pointer to a timespec delta value
678  *
679  * This hook is for architectures that cannot support read_persistent_clock
680  * because their RTC/persistent clock is only accessible when irqs are enabled.
681  *
682  * This function should only be called by rtc_resume(), and allows
683  * a suspend offset to be injected into the timekeeping values.
684  */
685 void timekeeping_inject_sleeptime(struct timespec *delta)
686 {
687         struct timekeeper *tk = &timekeeper;
688         unsigned long flags;
689         struct timespec ts;
690
691         /* Make sure we don't set the clock twice */
692         read_persistent_clock(&ts);
693         if (!(ts.tv_sec == 0 && ts.tv_nsec == 0))
694                 return;
695
696         write_seqlock_irqsave(&tk->lock, flags);
697
698         timekeeping_forward_now(tk);
699
700         __timekeeping_inject_sleeptime(tk, delta);
701
702         timekeeping_update(tk, true);
703
704         write_sequnlock_irqrestore(&tk->lock, flags);
705
706         /* signal hrtimers about time change */
707         clock_was_set();
708 }
709
710 /**
711  * timekeeping_resume - Resumes the generic timekeeping subsystem.
712  *
713  * This is for the generic clocksource timekeeping.
714  * xtime/wall_to_monotonic/jiffies/etc are
715  * still managed by arch specific suspend/resume code.
716  */
717 static void timekeeping_resume(void)
718 {
719         struct timekeeper *tk = &timekeeper;
720         unsigned long flags;
721         struct timespec ts;
722
723         read_persistent_clock(&ts);
724
725         clocksource_resume();
726
727         write_seqlock_irqsave(&tk->lock, flags);
728
729         if (timespec_compare(&ts, &timekeeping_suspend_time) > 0) {
730                 ts = timespec_sub(ts, timekeeping_suspend_time);
731                 __timekeeping_inject_sleeptime(tk, &ts);
732         }
733         /* re-base the last cycle value */
734         tk->clock->cycle_last = tk->clock->read(tk->clock);
735         tk->ntp_error = 0;
736         timekeeping_suspended = 0;
737         timekeeping_update(tk, false);
738         write_sequnlock_irqrestore(&tk->lock, flags);
739
740         touch_softlockup_watchdog();
741
742         clockevents_notify(CLOCK_EVT_NOTIFY_RESUME, NULL);
743
744         /* Resume hrtimers */
745         hrtimers_resume();
746 }
747
748 static int timekeeping_suspend(void)
749 {
750         struct timekeeper *tk = &timekeeper;
751         unsigned long flags;
752         struct timespec         delta, delta_delta;
753         static struct timespec  old_delta;
754
755         read_persistent_clock(&timekeeping_suspend_time);
756
757         write_seqlock_irqsave(&tk->lock, flags);
758         timekeeping_forward_now(tk);
759         timekeeping_suspended = 1;
760
761         /*
762          * To avoid drift caused by repeated suspend/resumes,
763          * which each can add ~1 second drift error,
764          * try to compensate so the difference in system time
765          * and persistent_clock time stays close to constant.
766          */
767         delta = timespec_sub(tk_xtime(tk), timekeeping_suspend_time);
768         delta_delta = timespec_sub(delta, old_delta);
769         if (abs(delta_delta.tv_sec)  >= 2) {
770                 /*
771                  * if delta_delta is too large, assume time correction
772                  * has occured and set old_delta to the current delta.
773                  */
774                 old_delta = delta;
775         } else {
776                 /* Otherwise try to adjust old_system to compensate */
777                 timekeeping_suspend_time =
778                         timespec_add(timekeeping_suspend_time, delta_delta);
779         }
780         write_sequnlock_irqrestore(&tk->lock, flags);
781
782         clockevents_notify(CLOCK_EVT_NOTIFY_SUSPEND, NULL);
783         clocksource_suspend();
784
785         return 0;
786 }
787
788 /* sysfs resume/suspend bits for timekeeping */
789 static struct syscore_ops timekeeping_syscore_ops = {
790         .resume         = timekeeping_resume,
791         .suspend        = timekeeping_suspend,
792 };
793
794 static int __init timekeeping_init_ops(void)
795 {
796         register_syscore_ops(&timekeeping_syscore_ops);
797         return 0;
798 }
799
800 device_initcall(timekeeping_init_ops);
801
802 /*
803  * If the error is already larger, we look ahead even further
804  * to compensate for late or lost adjustments.
805  */
806 static __always_inline int timekeeping_bigadjust(struct timekeeper *tk,
807                                                  s64 error, s64 *interval,
808                                                  s64 *offset)
809 {
810         s64 tick_error, i;
811         u32 look_ahead, adj;
812         s32 error2, mult;
813
814         /*
815          * Use the current error value to determine how much to look ahead.
816          * The larger the error the slower we adjust for it to avoid problems
817          * with losing too many ticks, otherwise we would overadjust and
818          * produce an even larger error.  The smaller the adjustment the
819          * faster we try to adjust for it, as lost ticks can do less harm
820          * here.  This is tuned so that an error of about 1 msec is adjusted
821          * within about 1 sec (or 2^20 nsec in 2^SHIFT_HZ ticks).
822          */
823         error2 = tk->ntp_error >> (NTP_SCALE_SHIFT + 22 - 2 * SHIFT_HZ);
824         error2 = abs(error2);
825         for (look_ahead = 0; error2 > 0; look_ahead++)
826                 error2 >>= 2;
827
828         /*
829          * Now calculate the error in (1 << look_ahead) ticks, but first
830          * remove the single look ahead already included in the error.
831          */
832         tick_error = ntp_tick_length() >> (tk->ntp_error_shift + 1);
833         tick_error -= tk->xtime_interval >> 1;
834         error = ((error - tick_error) >> look_ahead) + tick_error;
835
836         /* Finally calculate the adjustment shift value.  */
837         i = *interval;
838         mult = 1;
839         if (error < 0) {
840                 error = -error;
841                 *interval = -*interval;
842                 *offset = -*offset;
843                 mult = -1;
844         }
845         for (adj = 0; error > i; adj++)
846                 error >>= 1;
847
848         *interval <<= adj;
849         *offset <<= adj;
850         return mult << adj;
851 }
852
853 /*
854  * Adjust the multiplier to reduce the error value,
855  * this is optimized for the most common adjustments of -1,0,1,
856  * for other values we can do a bit more work.
857  */
858 static void timekeeping_adjust(struct timekeeper *tk, s64 offset)
859 {
860         s64 error, interval = tk->cycle_interval;
861         int adj;
862
863         /*
864          * The point of this is to check if the error is greater than half
865          * an interval.
866          *
867          * First we shift it down from NTP_SHIFT to clocksource->shifted nsecs.
868          *
869          * Note we subtract one in the shift, so that error is really error*2.
870          * This "saves" dividing(shifting) interval twice, but keeps the
871          * (error > interval) comparison as still measuring if error is
872          * larger than half an interval.
873          *
874          * Note: It does not "save" on aggravation when reading the code.
875          */
876         error = tk->ntp_error >> (tk->ntp_error_shift - 1);
877         if (error > interval) {
878                 /*
879                  * We now divide error by 4(via shift), which checks if
880                  * the error is greater than twice the interval.
881                  * If it is greater, we need a bigadjust, if its smaller,
882                  * we can adjust by 1.
883                  */
884                 error >>= 2;
885                 /*
886                  * XXX - In update_wall_time, we round up to the next
887                  * nanosecond, and store the amount rounded up into
888                  * the error. This causes the likely below to be unlikely.
889                  *
890                  * The proper fix is to avoid rounding up by using
891                  * the high precision tk->xtime_nsec instead of
892                  * xtime.tv_nsec everywhere. Fixing this will take some
893                  * time.
894                  */
895                 if (likely(error <= interval))
896                         adj = 1;
897                 else
898                         adj = timekeeping_bigadjust(tk, error, &interval, &offset);
899         } else {
900                 if (error < -interval) {
901                         /* See comment above, this is just switched for the negative */
902                         error >>= 2;
903                         if (likely(error >= -interval)) {
904                                 adj = -1;
905                                 interval = -interval;
906                                 offset = -offset;
907                         } else {
908                                 adj = timekeeping_bigadjust(tk, error, &interval, &offset);
909                         }
910                 } else {
911                         goto out_adjust;
912                 }
913         }
914
915         if (unlikely(tk->clock->maxadj &&
916                 (tk->mult + adj > tk->clock->mult + tk->clock->maxadj))) {
917                 printk_once(KERN_WARNING
918                         "Adjusting %s more than 11%% (%ld vs %ld)\n",
919                         tk->clock->name, (long)tk->mult + adj,
920                         (long)tk->clock->mult + tk->clock->maxadj);
921         }
922         /*
923          * So the following can be confusing.
924          *
925          * To keep things simple, lets assume adj == 1 for now.
926          *
927          * When adj != 1, remember that the interval and offset values
928          * have been appropriately scaled so the math is the same.
929          *
930          * The basic idea here is that we're increasing the multiplier
931          * by one, this causes the xtime_interval to be incremented by
932          * one cycle_interval. This is because:
933          *      xtime_interval = cycle_interval * mult
934          * So if mult is being incremented by one:
935          *      xtime_interval = cycle_interval * (mult + 1)
936          * Its the same as:
937          *      xtime_interval = (cycle_interval * mult) + cycle_interval
938          * Which can be shortened to:
939          *      xtime_interval += cycle_interval
940          *
941          * So offset stores the non-accumulated cycles. Thus the current
942          * time (in shifted nanoseconds) is:
943          *      now = (offset * adj) + xtime_nsec
944          * Now, even though we're adjusting the clock frequency, we have
945          * to keep time consistent. In other words, we can't jump back
946          * in time, and we also want to avoid jumping forward in time.
947          *
948          * So given the same offset value, we need the time to be the same
949          * both before and after the freq adjustment.
950          *      now = (offset * adj_1) + xtime_nsec_1
951          *      now = (offset * adj_2) + xtime_nsec_2
952          * So:
953          *      (offset * adj_1) + xtime_nsec_1 =
954          *              (offset * adj_2) + xtime_nsec_2
955          * And we know:
956          *      adj_2 = adj_1 + 1
957          * So:
958          *      (offset * adj_1) + xtime_nsec_1 =
959          *              (offset * (adj_1+1)) + xtime_nsec_2
960          *      (offset * adj_1) + xtime_nsec_1 =
961          *              (offset * adj_1) + offset + xtime_nsec_2
962          * Canceling the sides:
963          *      xtime_nsec_1 = offset + xtime_nsec_2
964          * Which gives us:
965          *      xtime_nsec_2 = xtime_nsec_1 - offset
966          * Which simplfies to:
967          *      xtime_nsec -= offset
968          *
969          * XXX - TODO: Doc ntp_error calculation.
970          */
971         tk->mult += adj;
972         tk->xtime_interval += interval;
973         tk->xtime_nsec -= offset;
974         tk->ntp_error -= (interval - offset) << tk->ntp_error_shift;
975
976 out_adjust:
977         /*
978          * It may be possible that when we entered this function, xtime_nsec
979          * was very small.  Further, if we're slightly speeding the clocksource
980          * in the code above, its possible the required corrective factor to
981          * xtime_nsec could cause it to underflow.
982          *
983          * Now, since we already accumulated the second, cannot simply roll
984          * the accumulated second back, since the NTP subsystem has been
985          * notified via second_overflow. So instead we push xtime_nsec forward
986          * by the amount we underflowed, and add that amount into the error.
987          *
988          * We'll correct this error next time through this function, when
989          * xtime_nsec is not as small.
990          */
991         if (unlikely((s64)tk->xtime_nsec < 0)) {
992                 s64 neg = -(s64)tk->xtime_nsec;
993                 tk->xtime_nsec = 0;
994                 tk->ntp_error += neg << tk->ntp_error_shift;
995         }
996
997 }
998
999 /**
1000  * accumulate_nsecs_to_secs - Accumulates nsecs into secs
1001  *
1002  * Helper function that accumulates a the nsecs greater then a second
1003  * from the xtime_nsec field to the xtime_secs field.
1004  * It also calls into the NTP code to handle leapsecond processing.
1005  *
1006  */
1007 static inline void accumulate_nsecs_to_secs(struct timekeeper *tk)
1008 {
1009         u64 nsecps = (u64)NSEC_PER_SEC << tk->shift;
1010
1011         while (tk->xtime_nsec >= nsecps) {
1012                 int leap;
1013
1014                 tk->xtime_nsec -= nsecps;
1015                 tk->xtime_sec++;
1016
1017                 /* Figure out if its a leap sec and apply if needed */
1018                 leap = second_overflow(tk->xtime_sec);
1019                 if (unlikely(leap)) {
1020                         struct timespec ts;
1021
1022                         tk->xtime_sec += leap;
1023
1024                         ts.tv_sec = leap;
1025                         ts.tv_nsec = 0;
1026                         tk_set_wall_to_mono(tk,
1027                                 timespec_sub(tk->wall_to_monotonic, ts));
1028
1029                         clock_was_set_delayed();
1030                 }
1031         }
1032 }
1033
1034 /**
1035  * logarithmic_accumulation - shifted accumulation of cycles
1036  *
1037  * This functions accumulates a shifted interval of cycles into
1038  * into a shifted interval nanoseconds. Allows for O(log) accumulation
1039  * loop.
1040  *
1041  * Returns the unconsumed cycles.
1042  */
1043 static cycle_t logarithmic_accumulation(struct timekeeper *tk, cycle_t offset,
1044                                                 u32 shift)
1045 {
1046         u64 raw_nsecs;
1047
1048         /* If the offset is smaller then a shifted interval, do nothing */
1049         if (offset < tk->cycle_interval<<shift)
1050                 return offset;
1051
1052         /* Accumulate one shifted interval */
1053         offset -= tk->cycle_interval << shift;
1054         tk->clock->cycle_last += tk->cycle_interval << shift;
1055
1056         tk->xtime_nsec += tk->xtime_interval << shift;
1057         accumulate_nsecs_to_secs(tk);
1058
1059         /* Accumulate raw time */
1060         raw_nsecs = tk->raw_interval << shift;
1061         raw_nsecs += tk->raw_time.tv_nsec;
1062         if (raw_nsecs >= NSEC_PER_SEC) {
1063                 u64 raw_secs = raw_nsecs;
1064                 raw_nsecs = do_div(raw_secs, NSEC_PER_SEC);
1065                 tk->raw_time.tv_sec += raw_secs;
1066         }
1067         tk->raw_time.tv_nsec = raw_nsecs;
1068
1069         /* Accumulate error between NTP and clock interval */
1070         tk->ntp_error += ntp_tick_length() << shift;
1071         tk->ntp_error -= (tk->xtime_interval + tk->xtime_remainder) <<
1072                                                 (tk->ntp_error_shift + shift);
1073
1074         return offset;
1075 }
1076
1077 /**
1078  * update_wall_time - Uses the current clocksource to increment the wall time
1079  *
1080  */
1081 static void update_wall_time(void)
1082 {
1083         struct clocksource *clock;
1084         struct timekeeper *tk = &timekeeper;
1085         cycle_t offset;
1086         int shift = 0, maxshift;
1087         unsigned long flags;
1088         s64 remainder;
1089
1090         write_seqlock_irqsave(&tk->lock, flags);
1091
1092         /* Make sure we're fully resumed: */
1093         if (unlikely(timekeeping_suspended))
1094                 goto out;
1095
1096         clock = tk->clock;
1097
1098 #ifdef CONFIG_ARCH_USES_GETTIMEOFFSET
1099         offset = tk->cycle_interval;
1100 #else
1101         offset = (clock->read(clock) - clock->cycle_last) & clock->mask;
1102 #endif
1103
1104         /* Check if there's really nothing to do */
1105         if (offset < tk->cycle_interval)
1106                 goto out;
1107
1108         /*
1109          * With NO_HZ we may have to accumulate many cycle_intervals
1110          * (think "ticks") worth of time at once. To do this efficiently,
1111          * we calculate the largest doubling multiple of cycle_intervals
1112          * that is smaller than the offset.  We then accumulate that
1113          * chunk in one go, and then try to consume the next smaller
1114          * doubled multiple.
1115          */
1116         shift = ilog2(offset) - ilog2(tk->cycle_interval);
1117         shift = max(0, shift);
1118         /* Bound shift to one less than what overflows tick_length */
1119         maxshift = (64 - (ilog2(ntp_tick_length())+1)) - 1;
1120         shift = min(shift, maxshift);
1121         while (offset >= tk->cycle_interval) {
1122                 offset = logarithmic_accumulation(tk, offset, shift);
1123                 if (offset < tk->cycle_interval<<shift)
1124                         shift--;
1125         }
1126
1127         /* correct the clock when NTP error is too big */
1128         timekeeping_adjust(tk, offset);
1129
1130
1131         /*
1132         * Store only full nanoseconds into xtime_nsec after rounding
1133         * it up and add the remainder to the error difference.
1134         * XXX - This is necessary to avoid small 1ns inconsistnecies caused
1135         * by truncating the remainder in vsyscalls. However, it causes
1136         * additional work to be done in timekeeping_adjust(). Once
1137         * the vsyscall implementations are converted to use xtime_nsec
1138         * (shifted nanoseconds), this can be killed.
1139         */
1140         remainder = tk->xtime_nsec & ((1ULL << tk->shift) - 1);
1141         tk->xtime_nsec -= remainder;
1142         tk->xtime_nsec += 1ULL << tk->shift;
1143         tk->ntp_error += remainder << tk->ntp_error_shift;
1144
1145         /*
1146          * Finally, make sure that after the rounding
1147          * xtime_nsec isn't larger than NSEC_PER_SEC
1148          */
1149         accumulate_nsecs_to_secs(tk);
1150
1151         timekeeping_update(tk, false);
1152
1153 out:
1154         write_sequnlock_irqrestore(&tk->lock, flags);
1155
1156 }
1157
1158 /**
1159  * getboottime - Return the real time of system boot.
1160  * @ts:         pointer to the timespec to be set
1161  *
1162  * Returns the wall-time of boot in a timespec.
1163  *
1164  * This is based on the wall_to_monotonic offset and the total suspend
1165  * time. Calls to settimeofday will affect the value returned (which
1166  * basically means that however wrong your real time clock is at boot time,
1167  * you get the right time here).
1168  */
1169 void getboottime(struct timespec *ts)
1170 {
1171         struct timekeeper *tk = &timekeeper;
1172         struct timespec boottime = {
1173                 .tv_sec = tk->wall_to_monotonic.tv_sec +
1174                                 tk->total_sleep_time.tv_sec,
1175                 .tv_nsec = tk->wall_to_monotonic.tv_nsec +
1176                                 tk->total_sleep_time.tv_nsec
1177         };
1178
1179         set_normalized_timespec(ts, -boottime.tv_sec, -boottime.tv_nsec);
1180 }
1181 EXPORT_SYMBOL_GPL(getboottime);
1182
1183 /**
1184  * get_monotonic_boottime - Returns monotonic time since boot
1185  * @ts:         pointer to the timespec to be set
1186  *
1187  * Returns the monotonic time since boot in a timespec.
1188  *
1189  * This is similar to CLOCK_MONTONIC/ktime_get_ts, but also
1190  * includes the time spent in suspend.
1191  */
1192 void get_monotonic_boottime(struct timespec *ts)
1193 {
1194         struct timekeeper *tk = &timekeeper;
1195         struct timespec tomono, sleep;
1196         s64 nsec;
1197         unsigned int seq;
1198
1199         WARN_ON(timekeeping_suspended);
1200
1201         do {
1202                 seq = read_seqbegin(&tk->lock);
1203                 ts->tv_sec = tk->xtime_sec;
1204                 nsec = timekeeping_get_ns(tk);
1205                 tomono = tk->wall_to_monotonic;
1206                 sleep = tk->total_sleep_time;
1207
1208         } while (read_seqretry(&tk->lock, seq));
1209
1210         ts->tv_sec += tomono.tv_sec + sleep.tv_sec;
1211         ts->tv_nsec = 0;
1212         timespec_add_ns(ts, nsec + tomono.tv_nsec + sleep.tv_nsec);
1213 }
1214 EXPORT_SYMBOL_GPL(get_monotonic_boottime);
1215
1216 /**
1217  * ktime_get_boottime - Returns monotonic time since boot in a ktime
1218  *
1219  * Returns the monotonic time since boot in a ktime
1220  *
1221  * This is similar to CLOCK_MONTONIC/ktime_get, but also
1222  * includes the time spent in suspend.
1223  */
1224 ktime_t ktime_get_boottime(void)
1225 {
1226         struct timespec ts;
1227
1228         get_monotonic_boottime(&ts);
1229         return timespec_to_ktime(ts);
1230 }
1231 EXPORT_SYMBOL_GPL(ktime_get_boottime);
1232
1233 /**
1234  * monotonic_to_bootbased - Convert the monotonic time to boot based.
1235  * @ts:         pointer to the timespec to be converted
1236  */
1237 void monotonic_to_bootbased(struct timespec *ts)
1238 {
1239         struct timekeeper *tk = &timekeeper;
1240
1241         *ts = timespec_add(*ts, tk->total_sleep_time);
1242 }
1243 EXPORT_SYMBOL_GPL(monotonic_to_bootbased);
1244
1245 unsigned long get_seconds(void)
1246 {
1247         struct timekeeper *tk = &timekeeper;
1248
1249         return tk->xtime_sec;
1250 }
1251 EXPORT_SYMBOL(get_seconds);
1252
1253 struct timespec __current_kernel_time(void)
1254 {
1255         struct timekeeper *tk = &timekeeper;
1256
1257         return tk_xtime(tk);
1258 }
1259
1260 struct timespec current_kernel_time(void)
1261 {
1262         struct timekeeper *tk = &timekeeper;
1263         struct timespec now;
1264         unsigned long seq;
1265
1266         do {
1267                 seq = read_seqbegin(&tk->lock);
1268
1269                 now = tk_xtime(tk);
1270         } while (read_seqretry(&tk->lock, seq));
1271
1272         return now;
1273 }
1274 EXPORT_SYMBOL(current_kernel_time);
1275
1276 struct timespec get_monotonic_coarse(void)
1277 {
1278         struct timekeeper *tk = &timekeeper;
1279         struct timespec now, mono;
1280         unsigned long seq;
1281
1282         do {
1283                 seq = read_seqbegin(&tk->lock);
1284
1285                 now = tk_xtime(tk);
1286                 mono = tk->wall_to_monotonic;
1287         } while (read_seqretry(&tk->lock, seq));
1288
1289         set_normalized_timespec(&now, now.tv_sec + mono.tv_sec,
1290                                 now.tv_nsec + mono.tv_nsec);
1291         return now;
1292 }
1293
1294 /*
1295  * The 64-bit jiffies value is not atomic - you MUST NOT read it
1296  * without sampling the sequence number in xtime_lock.
1297  * jiffies is defined in the linker script...
1298  */
1299 void do_timer(unsigned long ticks)
1300 {
1301         jiffies_64 += ticks;
1302         update_wall_time();
1303         calc_global_load(ticks);
1304 }
1305
1306 /**
1307  * get_xtime_and_monotonic_and_sleep_offset() - get xtime, wall_to_monotonic,
1308  *    and sleep offsets.
1309  * @xtim:       pointer to timespec to be set with xtime
1310  * @wtom:       pointer to timespec to be set with wall_to_monotonic
1311  * @sleep:      pointer to timespec to be set with time in suspend
1312  */
1313 void get_xtime_and_monotonic_and_sleep_offset(struct timespec *xtim,
1314                                 struct timespec *wtom, struct timespec *sleep)
1315 {
1316         struct timekeeper *tk = &timekeeper;
1317         unsigned long seq;
1318
1319         do {
1320                 seq = read_seqbegin(&tk->lock);
1321                 *xtim = tk_xtime(tk);
1322                 *wtom = tk->wall_to_monotonic;
1323                 *sleep = tk->total_sleep_time;
1324         } while (read_seqretry(&tk->lock, seq));
1325 }
1326
1327 #ifdef CONFIG_HIGH_RES_TIMERS
1328 /**
1329  * ktime_get_update_offsets - hrtimer helper
1330  * @offs_real:  pointer to storage for monotonic -> realtime offset
1331  * @offs_boot:  pointer to storage for monotonic -> boottime offset
1332  *
1333  * Returns current monotonic time and updates the offsets
1334  * Called from hrtimer_interupt() or retrigger_next_event()
1335  */
1336 ktime_t ktime_get_update_offsets(ktime_t *offs_real, ktime_t *offs_boot)
1337 {
1338         struct timekeeper *tk = &timekeeper;
1339         ktime_t now;
1340         unsigned int seq;
1341         u64 secs, nsecs;
1342
1343         do {
1344                 seq = read_seqbegin(&tk->lock);
1345
1346                 secs = tk->xtime_sec;
1347                 nsecs = timekeeping_get_ns(tk);
1348
1349                 *offs_real = tk->offs_real;
1350                 *offs_boot = tk->offs_boot;
1351         } while (read_seqretry(&tk->lock, seq));
1352
1353         now = ktime_add_ns(ktime_set(secs, 0), nsecs);
1354         now = ktime_sub(now, *offs_real);
1355         return now;
1356 }
1357 #endif
1358
1359 /**
1360  * ktime_get_monotonic_offset() - get wall_to_monotonic in ktime_t format
1361  */
1362 ktime_t ktime_get_monotonic_offset(void)
1363 {
1364         struct timekeeper *tk = &timekeeper;
1365         unsigned long seq;
1366         struct timespec wtom;
1367
1368         do {
1369                 seq = read_seqbegin(&tk->lock);
1370                 wtom = tk->wall_to_monotonic;
1371         } while (read_seqretry(&tk->lock, seq));
1372
1373         return timespec_to_ktime(wtom);
1374 }
1375 EXPORT_SYMBOL_GPL(ktime_get_monotonic_offset);
1376
1377 /**
1378  * xtime_update() - advances the timekeeping infrastructure
1379  * @ticks:      number of ticks, that have elapsed since the last call.
1380  *
1381  * Must be called with interrupts disabled.
1382  */
1383 void xtime_update(unsigned long ticks)
1384 {
1385         write_seqlock(&xtime_lock);
1386         do_timer(ticks);
1387         write_sequnlock(&xtime_lock);
1388 }