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