kernel/time.c

   1 /*
   2  *  linux/kernel/time.c
   3  *
   4  *  Copyright (C) 1991, 1992  Linus Torvalds
   5  *
   6  *  This file contains the interface functions for the various
   7  *  time related system calls: time, stime, gettimeofday, settimeofday,
   8  *                             adjtime
   9  */
  10 /*
  11  * Modification history kernel/time.c
  12  *
  13  * 1993-09-02    Philip Gladstone
  14  *      Created file with time related functions from sched.c and adjtimex()
  15  * 1993-10-08    Torsten Duwe
  16  *      adjtime interface update and CMOS clock write code
  17  * 1995-08-13    Torsten Duwe
  18  *      kernel PLL updated to 1994-12-13 specs (rfc-1589)
  19  * 1999-01-16    Ulrich Windl
  20  *      Introduced error checking for many cases in adjtimex().
  21  *      Updated NTP code according to technical memorandum Jan '96
  22  *      "A Kernel Model for Precision Timekeeping" by Dave Mills
  23  *      Allow time_constant larger than MAXTC(6) for NTP v4 (MAXTC == 10)
  24  *      (Even though the technical memorandum forbids it)
  25  * 2004-07-14    Christoph Lameter
  26  *      Added getnstimeofday to allow the posix timer functions to return
  27  *      with nanosecond accuracy
  28  */
  29
  30 #include <linux/module.h>
  31 #include <linux/timex.h>
  32 #include <linux/capability.h>
  33 #include <linux/errno.h>
  34 #include <linux/smp_lock.h>
  35 #include <linux/syscalls.h>
  36 #include <linux/security.h>
  37 #include <linux/fs.h>
  38 #include <linux/module.h>
  39
  40 #include <asm/uaccess.h>
  41 #include <asm/unistd.h>
  42
  43 /*
  44  * The timezone where the local system is located.  Used as a default by some
  45  * programs who obtain this value by using gettimeofday.
  46  */
  47 struct timezone sys_tz;
  48
  49 EXPORT_SYMBOL(sys_tz);
  50
  51 #ifdef __ARCH_WANT_SYS_TIME
  52
  53 /*
  54  * sys_time() can be implemented in user-level using
  55  * sys_gettimeofday().  Is this for backwards compatibility?  If so,
  56  * why not move it into the appropriate arch directory (for those
  57  * architectures that need it).
  58  */
  59 asmlinkage long sys_time(time_t __user * tloc)
  60 {
  61         time_t i;
  62         struct timeval tv;
  63
  64         do_gettimeofday(&tv);
  65         i = tv.tv_sec;
  66
  67         if (tloc) {
  68                 if (put_user(i,tloc))
  69                         i = -EFAULT;
  70         }
  71         return i;
  72 }
  73
  74 /*
  75  * sys_stime() can be implemented in user-level using
  76  * sys_settimeofday().  Is this for backwards compatibility?  If so,
  77  * why not move it into the appropriate arch directory (for those
  78  * architectures that need it).
  79  */
  80
  81 asmlinkage long sys_stime(time_t __user *tptr)
  82 {
  83         struct timespec tv;
  84         int err;
  85
  86         if (get_user(tv.tv_sec, tptr))
  87                 return -EFAULT;
  88
  89         tv.tv_nsec = 0;
  90
  91         err = security_settime(&tv, NULL);
  92         if (err)
  93                 return err;
  94
  95         do_settimeofday(&tv);
  96         return 0;
  97 }
  98
  99 #endif /* __ARCH_WANT_SYS_TIME */
 100
 101 asmlinkage long sys_gettimeofday(struct timeval __user *tv, struct timezone __user *tz)
 102 {
 103         if (likely(tv != NULL)) {
 104                 struct timeval ktv;
 105                 do_gettimeofday(&ktv);
 106                 if (copy_to_user(tv, &ktv, sizeof(ktv)))
 107                         return -EFAULT;
 108         }
 109         if (unlikely(tz != NULL)) {
 110                 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
 111                         return -EFAULT;
 112         }
 113         return 0;
 114 }
 115
 116 /*
 117  * Adjust the time obtained from the CMOS to be UTC time instead of
 118  * local time.
 119  *
 120  * This is ugly, but preferable to the alternatives.  Otherwise we
 121  * would either need to write a program to do it in /etc/rc (and risk
 122  * confusion if the program gets run more than once; it would also be
 123  * hard to make the program warp the clock precisely n hours)  or
 124  * compile in the timezone information into the kernel.  Bad, bad....
 125  *
 126  *                                              - TYT, 1992-01-01
 127  *
 128  * The best thing to do is to keep the CMOS clock in universal time (UTC)
 129  * as real UNIX machines always do it. This avoids all headaches about
 130  * daylight saving times and warping kernel clocks.
 131  */
 132 static inline void warp_clock(void)
 133 {
 134         write_seqlock_irq(&xtime_lock);
 135         wall_to_monotonic.tv_sec -= sys_tz.tz_minuteswest * 60;
 136         xtime.tv_sec += sys_tz.tz_minuteswest * 60;
 137         time_interpolator_reset();
 138         write_sequnlock_irq(&xtime_lock);
 139         clock_was_set();
 140 }
 141
 142 /*
 143  * In case for some reason the CMOS clock has not already been running
 144  * in UTC, but in some local time: The first time we set the timezone,
 145  * we will warp the clock so that it is ticking UTC time instead of
 146  * local time. Presumably, if someone is setting the timezone then we
 147  * are running in an environment where the programs understand about
 148  * timezones. This should be done at boot time in the /etc/rc script,
 149  * as soon as possible, so that the clock can be set right. Otherwise,
 150  * various programs will get confused when the clock gets warped.
 151  */
 152
 153 int do_sys_settimeofday(struct timespec *tv, struct timezone *tz)
 154 {
 155         static int firsttime = 1;
 156         int error = 0;
 157
 158         if (tv && !timespec_valid(tv))
 159                 return -EINVAL;
 160
 161         error = security_settime(tv, tz);
 162         if (error)
 163                 return error;
 164
 165         if (tz) {
 166                 /* SMP safe, global irq locking makes it work. */
 167                 sys_tz = *tz;
 168                 if (firsttime) {
 169                         firsttime = 0;
 170                         if (!tv)
 171                                 warp_clock();
 172                 }
 173         }
 174         if (tv)
 175         {
 176                 /* SMP safe, again the code in arch/foo/time.c should
 177                  * globally block out interrupts when it runs.
 178                  */
 179                 return do_settimeofday(tv);
 180         }
 181         return 0;
 182 }
 183
 184 asmlinkage long sys_settimeofday(struct timeval __user *tv,
 185                                 struct timezone __user *tz)
 186 {
 187         struct timeval user_tv;
 188         struct timespec new_ts;
 189         struct timezone new_tz;
 190
 191         if (tv) {
 192                 if (copy_from_user(&user_tv, tv, sizeof(*tv)))
 193                         return -EFAULT;
 194                 new_ts.tv_sec = user_tv.tv_sec;
 195                 new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC;
 196         }
 197         if (tz) {
 198                 if (copy_from_user(&new_tz, tz, sizeof(*tz)))
 199                         return -EFAULT;
 200         }
 201
 202         return do_sys_settimeofday(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
 203 }
 204
 205 /* we call this to notify the arch when the clock is being
 206  * controlled.  If no such arch routine, do nothing.
 207  */
 208 void __attribute__ ((weak)) notify_arch_cmos_timer(void)
 209 {
 210         return;
 211 }
 212
 213 /* adjtimex mainly allows reading (and writing, if superuser) of
 214  * kernel time-keeping variables. used by xntpd.
 215  */
 216 int do_adjtimex(struct timex *txc)
 217 {
 218         long ltemp, mtemp, save_adjust;
 219         int result;
 220
 221         /* In order to modify anything, you gotta be super-user! */
 222         if (txc->modes && !capable(CAP_SYS_TIME))
 223                 return -EPERM;
 224
 225         /* Now we validate the data before disabling interrupts */
 226
 227         if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT)
 228           /* singleshot must not be used with any other mode bits */
 229                 if (txc->modes != ADJ_OFFSET_SINGLESHOT)
 230                         return -EINVAL;
 231
 232         if (txc->modes != ADJ_OFFSET_SINGLESHOT && (txc->modes & ADJ_OFFSET))
 233           /* adjustment Offset limited to +- .512 seconds */
 234                 if (txc->offset <= - MAXPHASE || txc->offset >= MAXPHASE )
 235                         return -EINVAL;
 236
 237         /* if the quartz is off by more than 10% something is VERY wrong ! */
 238         if (txc->modes & ADJ_TICK)
 239                 if (txc->tick <  900000/USER_HZ ||
 240                     txc->tick > 1100000/USER_HZ)
 241                         return -EINVAL;
 242
 243         write_seqlock_irq(&xtime_lock);
 244         result = time_state;    /* mostly `TIME_OK' */
 245
 246         /* Save for later - semantics of adjtime is to return old value */
 247         save_adjust = time_next_adjust ? time_next_adjust : time_adjust;
 248
 249 #if 0   /* STA_CLOCKERR is never set yet */
 250         time_status &= ~STA_CLOCKERR;           /* reset STA_CLOCKERR */
 251 #endif
 252         /* If there are input parameters, then process them */
 253         if (txc->modes)
 254         {
 255             if (txc->modes & ADJ_STATUS)        /* only set allowed bits */
 256                 time_status =  (txc->status & ~STA_RONLY) |
 257                               (time_status & STA_RONLY);
 258
 259             if (txc->modes & ADJ_FREQUENCY) {   /* p. 22 */
 260                 if (txc->freq > MAXFREQ || txc->freq < -MAXFREQ) {
 261                     result = -EINVAL;
 262                     goto leave;
 263                 }
 264                 time_freq = txc->freq;
 265             }
 266
 267             if (txc->modes & ADJ_MAXERROR) {
 268                 if (txc->maxerror < 0 || txc->maxerror >= NTP_PHASE_LIMIT) {
 269                     result = -EINVAL;
 270                     goto leave;
 271                 }
 272                 time_maxerror = txc->maxerror;
 273             }
 274
 275             if (txc->modes & ADJ_ESTERROR) {
 276                 if (txc->esterror < 0 || txc->esterror >= NTP_PHASE_LIMIT) {
 277                     result = -EINVAL;
 278                     goto leave;
 279                 }
 280                 time_esterror = txc->esterror;
 281             }
 282
 283             if (txc->modes & ADJ_TIMECONST) {   /* p. 24 */
 284                 if (txc->constant < 0) {        /* NTP v4 uses values > 6 */
 285                     result = -EINVAL;
 286                     goto leave;
 287                 }
 288                 time_constant = txc->constant;
 289             }
 290
 291             if (txc->modes & ADJ_OFFSET) {      /* values checked earlier */
 292                 if (txc->modes == ADJ_OFFSET_SINGLESHOT) {
 293                     /* adjtime() is independent from ntp_adjtime() */
 294                     if ((time_next_adjust = txc->offset) == 0)
 295                          time_adjust = 0;
 296                 }
 297                 else if (time_status & STA_PLL) {
 298                     ltemp = txc->offset;
 299
 300                     /*
 301                      * Scale the phase adjustment and
 302                      * clamp to the operating range.
 303                      */
 304                     if (ltemp > MAXPHASE)
 305                         time_offset = MAXPHASE << SHIFT_UPDATE;
 306                     else if (ltemp < -MAXPHASE)
 307                         time_offset = -(MAXPHASE << SHIFT_UPDATE);
 308                     else
 309                         time_offset = ltemp << SHIFT_UPDATE;
 310
 311                     /*
 312                      * Select whether the frequency is to be controlled
 313                      * and in which mode (PLL or FLL). Clamp to the operating
 314                      * range. Ugly multiply/divide should be replaced someday.
 315                      */
 316
 317                     if (time_status & STA_FREQHOLD || time_reftime == 0)
 318                         time_reftime = xtime.tv_sec;
 319                     mtemp = xtime.tv_sec - time_reftime;
 320                     time_reftime = xtime.tv_sec;
 321                     if (time_status & STA_FLL) {
 322                         if (mtemp >= MINSEC) {
 323                             ltemp = (time_offset / mtemp) << (SHIFT_USEC -
 324                                                               SHIFT_UPDATE);
 325                             time_freq += shift_right(ltemp, SHIFT_KH);
 326                         } else /* calibration interval too short (p. 12) */
 327                                 result = TIME_ERROR;
 328                     } else {    /* PLL mode */
 329                         if (mtemp < MAXSEC) {
 330                             ltemp *= mtemp;
 331                             time_freq += shift_right(ltemp,(time_constant +
 332                                                        time_constant +
 333                                                        SHIFT_KF - SHIFT_USEC));
 334                         } else /* calibration interval too long (p. 12) */
 335                                 result = TIME_ERROR;
 336                     }
 337                     time_freq = min(time_freq, time_tolerance);
 338                     time_freq = max(time_freq, -time_tolerance);
 339                 } /* STA_PLL */
 340             } /* txc->modes & ADJ_OFFSET */
 341             if (txc->modes & ADJ_TICK) {
 342                 tick_usec = txc->tick;
 343                 tick_nsec = TICK_USEC_TO_NSEC(tick_usec);
 344             }
 345         } /* txc->modes */
 346 leave:  if ((time_status & (STA_UNSYNC|STA_CLOCKERR)) != 0)
 347                 result = TIME_ERROR;
 348
 349         if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT)
 350             txc->offset    = save_adjust;
 351         else {
 352             txc->offset = shift_right(time_offset, SHIFT_UPDATE);
 353         }
 354         txc->freq          = time_freq;
 355         txc->maxerror      = time_maxerror;
 356         txc->esterror      = time_esterror;
 357         txc->status        = time_status;
 358         txc->constant      = time_constant;
 359         txc->precision     = time_precision;
 360         txc->tolerance     = time_tolerance;
 361         txc->tick          = tick_usec;
 362
 363         /* PPS is not implemented, so these are zero */
 364         txc->ppsfreq       = 0;
 365         txc->jitter        = 0;
 366         txc->shift         = 0;
 367         txc->stabil        = 0;
 368         txc->jitcnt        = 0;
 369         txc->calcnt        = 0;
 370         txc->errcnt        = 0;
 371         txc->stbcnt        = 0;
 372         write_sequnlock_irq(&xtime_lock);
 373         do_gettimeofday(&txc->time);
 374         notify_arch_cmos_timer();
 375         return(result);
 376 }
 377
 378 asmlinkage long sys_adjtimex(struct timex __user *txc_p)
 379 {
 380         struct timex txc;               /* Local copy of parameter */
 381         int ret;
 382
 383         /* Copy the user data space into the kernel copy
 384          * structure. But bear in mind that the structures
 385          * may change
 386          */
 387         if(copy_from_user(&txc, txc_p, sizeof(struct timex)))
 388                 return -EFAULT;
 389         ret = do_adjtimex(&txc);
 390         return copy_to_user(txc_p, &txc, sizeof(struct timex)) ? -EFAULT : ret;
 391 }
 392
 393 inline struct timespec current_kernel_time(void)
 394 {
 395         struct timespec now;
 396         unsigned long seq;
 397
 398         do {
 399                 seq = read_seqbegin(&xtime_lock);
 400
 401                 now = xtime;
 402         } while (read_seqretry(&xtime_lock, seq));
 403
 404         return now;
 405 }
 406
 407 EXPORT_SYMBOL(current_kernel_time);
 408
 409 /**
 410  * current_fs_time - Return FS time
 411  * @sb: Superblock.
 412  *
 413  * Return the current time truncated to the time granuality supported by
 414  * the fs.
 415  */
 416 struct timespec current_fs_time(struct super_block *sb)
 417 {
 418         struct timespec now = current_kernel_time();
 419         return timespec_trunc(now, sb->s_time_gran);
 420 }
 421 EXPORT_SYMBOL(current_fs_time);
 422
 423 /**
 424  * timespec_trunc - Truncate timespec to a granuality
 425  * @t: Timespec
 426  * @gran: Granuality in ns.
 427  *
 428  * Truncate a timespec to a granuality. gran must be smaller than a second.
 429  * Always rounds down.
 430  *
 431  * This function should be only used for timestamps returned by
 432  * current_kernel_time() or CURRENT_TIME, not with do_gettimeofday() because
 433  * it doesn't handle the better resolution of the later.
 434  */
 435 struct timespec timespec_trunc(struct timespec t, unsigned gran)
 436 {
 437         /*
 438          * Division is pretty slow so avoid it for common cases.
 439          * Currently current_kernel_time() never returns better than
 440          * jiffies resolution. Exploit that.
 441          */
 442         if (gran <= jiffies_to_usecs(1) * 1000) {
 443                 /* nothing */
 444         } else if (gran == 1000000000) {
 445                 t.tv_nsec = 0;
 446         } else {
 447                 t.tv_nsec -= t.tv_nsec % gran;
 448         }
 449         return t;
 450 }
 451 EXPORT_SYMBOL(timespec_trunc);
 452
 453 #ifdef CONFIG_TIME_INTERPOLATION
 454 void getnstimeofday (struct timespec *tv)
 455 {
 456         unsigned long seq,sec,nsec;
 457
 458         do {
 459                 seq = read_seqbegin(&xtime_lock);
 460                 sec = xtime.tv_sec;
 461                 nsec = xtime.tv_nsec+time_interpolator_get_offset();
 462         } while (unlikely(read_seqretry(&xtime_lock, seq)));
 463
 464         while (unlikely(nsec >= NSEC_PER_SEC)) {
 465                 nsec -= NSEC_PER_SEC;
 466                 ++sec;
 467         }
 468         tv->tv_sec = sec;
 469         tv->tv_nsec = nsec;
 470 }
 471 EXPORT_SYMBOL_GPL(getnstimeofday);
 472
 473 int do_settimeofday (struct timespec *tv)
 474 {
 475         time_t wtm_sec, sec = tv->tv_sec;
 476         long wtm_nsec, nsec = tv->tv_nsec;
 477
 478         if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
 479                 return -EINVAL;
 480
 481         write_seqlock_irq(&xtime_lock);
 482         {
 483                 wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
 484                 wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
 485
 486                 set_normalized_timespec(&xtime, sec, nsec);
 487                 set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
 488
 489                 time_adjust = 0;                /* stop active adjtime() */
 490                 time_status |= STA_UNSYNC;
 491                 time_maxerror = NTP_PHASE_LIMIT;
 492                 time_esterror = NTP_PHASE_LIMIT;
 493                 time_interpolator_reset();
 494         }
 495         write_sequnlock_irq(&xtime_lock);
 496         clock_was_set();
 497         return 0;
 498 }
 499 EXPORT_SYMBOL(do_settimeofday);
 500
 501 void do_gettimeofday (struct timeval *tv)
 502 {
 503         unsigned long seq, nsec, usec, sec, offset;
 504         do {
 505                 seq = read_seqbegin(&xtime_lock);
 506                 offset = time_interpolator_get_offset();
 507                 sec = xtime.tv_sec;
 508                 nsec = xtime.tv_nsec;
 509         } while (unlikely(read_seqretry(&xtime_lock, seq)));
 510
 511         usec = (nsec + offset) / 1000;
 512
 513         while (unlikely(usec >= USEC_PER_SEC)) {
 514                 usec -= USEC_PER_SEC;
 515                 ++sec;
 516         }
 517
 518         tv->tv_sec = sec;
 519         tv->tv_usec = usec;
 520 }
 521
 522 EXPORT_SYMBOL(do_gettimeofday);
 523
 524
 525 #else
 526 /*
 527  * Simulate gettimeofday using do_gettimeofday which only allows a timeval
 528  * and therefore only yields usec accuracy
 529  */
 530 void getnstimeofday(struct timespec *tv)
 531 {
 532         struct timeval x;
 533
 534         do_gettimeofday(&x);
 535         tv->tv_sec = x.tv_sec;
 536         tv->tv_nsec = x.tv_usec * NSEC_PER_USEC;
 537 }
 538 EXPORT_SYMBOL_GPL(getnstimeofday);
 539 #endif
 540
 541 /* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
 542  * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
 543  * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
 544  *
 545  * [For the Julian calendar (which was used in Russia before 1917,
 546  * Britain & colonies before 1752, anywhere else before 1582,
 547  * and is still in use by some communities) leave out the
 548  * -year/100+year/400 terms, and add 10.]
 549  *
 550  * This algorithm was first published by Gauss (I think).
 551  *
 552  * WARNING: this function will overflow on 2106-02-07 06:28:16 on
 553  * machines were long is 32-bit! (However, as time_t is signed, we
 554  * will already get problems at other places on 2038-01-19 03:14:08)
 555  */
 556 unsigned long
 557 mktime(const unsigned int year0, const unsigned int mon0,
 558        const unsigned int day, const unsigned int hour,
 559        const unsigned int min, const unsigned int sec)
 560 {
 561         unsigned int mon = mon0, year = year0;
 562
 563         /* 1..12 -> 11,12,1..10 */
 564         if (0 >= (int) (mon -= 2)) {
 565                 mon += 12;      /* Puts Feb last since it has leap day */
 566                 year -= 1;
 567         }
 568
 569         return ((((unsigned long)
 570                   (year/4 - year/100 + year/400 + 367*mon/12 + day) +
 571                   year*365 - 719499
 572             )*24 + hour /* now have hours */
 573           )*60 + min /* now have minutes */
 574         )*60 + sec; /* finally seconds */
 575 }
 576
 577 EXPORT_SYMBOL(mktime);
 578
 579 /**
 580  * set_normalized_timespec - set timespec sec and nsec parts and normalize
 581  *
 582  * @ts:         pointer to timespec variable to be set
 583  * @sec:        seconds to set
 584  * @nsec:       nanoseconds to set
 585  *
 586  * Set seconds and nanoseconds field of a timespec variable and
 587  * normalize to the timespec storage format
 588  *
 589  * Note: The tv_nsec part is always in the range of
 590  *      0 <= tv_nsec < NSEC_PER_SEC
 591  * For negative values only the tv_sec field is negative !
 592  */
 593 void set_normalized_timespec(struct timespec *ts, time_t sec, long nsec)
 594 {
 595         while (nsec >= NSEC_PER_SEC) {
 596                 nsec -= NSEC_PER_SEC;
 597                 ++sec;
 598         }
 599         while (nsec < 0) {
 600                 nsec += NSEC_PER_SEC;
 601                 --sec;
 602         }
 603         ts->tv_sec = sec;
 604         ts->tv_nsec = nsec;
 605 }
 606
 607 /**
 608  * ns_to_timespec - Convert nanoseconds to timespec
 609  * @nsec:       the nanoseconds value to be converted
 610  *
 611  * Returns the timespec representation of the nsec parameter.
 612  */
 613 struct timespec ns_to_timespec(const s64 nsec)
 614 {
 615         struct timespec ts;
 616
 617         if (!nsec)
 618                 return (struct timespec) {0, 0};
 619
 620         ts.tv_sec = div_long_long_rem_signed(nsec, NSEC_PER_SEC, &ts.tv_nsec);
 621         if (unlikely(nsec < 0))
 622                 set_normalized_timespec(&ts, ts.tv_sec, ts.tv_nsec);
 623
 624         return ts;
 625 }
 626
 627 /**
 628  * ns_to_timeval - Convert nanoseconds to timeval
 629  * @nsec:       the nanoseconds value to be converted
 630  *
 631  * Returns the timeval representation of the nsec parameter.
 632  */
 633 struct timeval ns_to_timeval(const s64 nsec)
 634 {
 635         struct timespec ts = ns_to_timespec(nsec);
 636         struct timeval tv;
 637
 638         tv.tv_sec = ts.tv_sec;
 639         tv.tv_usec = (suseconds_t) ts.tv_nsec / 1000;
 640
 641         return tv;
 642 }
 643
 644 #if (BITS_PER_LONG < 64)
 645 u64 get_jiffies_64(void)
 646 {
 647         unsigned long seq;
 648         u64 ret;
 649
 650         do {
 651                 seq = read_seqbegin(&xtime_lock);
 652                 ret = jiffies_64;
 653         } while (read_seqretry(&xtime_lock, seq));
 654         return ret;
 655 }
 656
 657 EXPORT_SYMBOL(get_jiffies_64);
 658 #endif
 659
 660 EXPORT_SYMBOL(jiffies);