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         /* Workaround http://gcc.gnu.org/PR27781 */
 211         asm volatile ("");
 212         return;
 213 }
 214
 215 /* adjtimex mainly allows reading (and writing, if superuser) of
 216  * kernel time-keeping variables. used by xntpd.
 217  */
 218 int do_adjtimex(struct timex *txc)
 219 {
 220         long ltemp, mtemp, save_adjust;
 221         int result;
 222
 223         /* In order to modify anything, you gotta be super-user! */
 224         if (txc->modes && !capable(CAP_SYS_TIME))
 225                 return -EPERM;
 226
 227         /* Now we validate the data before disabling interrupts */
 228
 229         if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT)
 230           /* singleshot must not be used with any other mode bits */
 231                 if (txc->modes != ADJ_OFFSET_SINGLESHOT)
 232                         return -EINVAL;
 233
 234         if (txc->modes != ADJ_OFFSET_SINGLESHOT && (txc->modes & ADJ_OFFSET))
 235           /* adjustment Offset limited to +- .512 seconds */
 236                 if (txc->offset <= - MAXPHASE || txc->offset >= MAXPHASE )
 237                         return -EINVAL;
 238
 239         /* if the quartz is off by more than 10% something is VERY wrong ! */
 240         if (txc->modes & ADJ_TICK)
 241                 if (txc->tick <  900000/USER_HZ ||
 242                     txc->tick > 1100000/USER_HZ)
 243                         return -EINVAL;
 244
 245         write_seqlock_irq(&xtime_lock);
 246         result = time_state;    /* mostly `TIME_OK' */
 247
 248         /* Save for later - semantics of adjtime is to return old value */
 249         save_adjust = time_next_adjust ? time_next_adjust : time_adjust;
 250
 251 #if 0   /* STA_CLOCKERR is never set yet */
 252         time_status &= ~STA_CLOCKERR;           /* reset STA_CLOCKERR */
 253 #endif
 254         /* If there are input parameters, then process them */
 255         if (txc->modes)
 256         {
 257             if (txc->modes & ADJ_STATUS)        /* only set allowed bits */
 258                 time_status =  (txc->status & ~STA_RONLY) |
 259                               (time_status & STA_RONLY);
 260
 261             if (txc->modes & ADJ_FREQUENCY) {   /* p. 22 */
 262                 if (txc->freq > MAXFREQ || txc->freq < -MAXFREQ) {
 263                     result = -EINVAL;
 264                     goto leave;
 265                 }
 266                 time_freq = txc->freq;
 267             }
 268
 269             if (txc->modes & ADJ_MAXERROR) {
 270                 if (txc->maxerror < 0 || txc->maxerror >= NTP_PHASE_LIMIT) {
 271                     result = -EINVAL;
 272                     goto leave;
 273                 }
 274                 time_maxerror = txc->maxerror;
 275             }
 276
 277             if (txc->modes & ADJ_ESTERROR) {
 278                 if (txc->esterror < 0 || txc->esterror >= NTP_PHASE_LIMIT) {
 279                     result = -EINVAL;
 280                     goto leave;
 281                 }
 282                 time_esterror = txc->esterror;
 283             }
 284
 285             if (txc->modes & ADJ_TIMECONST) {   /* p. 24 */
 286                 if (txc->constant < 0) {        /* NTP v4 uses values > 6 */
 287                     result = -EINVAL;
 288                     goto leave;
 289                 }
 290                 time_constant = txc->constant;
 291             }
 292
 293             if (txc->modes & ADJ_OFFSET) {      /* values checked earlier */
 294                 if (txc->modes == ADJ_OFFSET_SINGLESHOT) {
 295                     /* adjtime() is independent from ntp_adjtime() */
 296                     if ((time_next_adjust = txc->offset) == 0)
 297                          time_adjust = 0;
 298                 }
 299                 else if (time_status & STA_PLL) {
 300                     ltemp = txc->offset;
 301
 302                     /*
 303                      * Scale the phase adjustment and
 304                      * clamp to the operating range.
 305                      */
 306                     if (ltemp > MAXPHASE)
 307                         time_offset = MAXPHASE << SHIFT_UPDATE;
 308                     else if (ltemp < -MAXPHASE)
 309                         time_offset = -(MAXPHASE << SHIFT_UPDATE);
 310                     else
 311                         time_offset = ltemp << SHIFT_UPDATE;
 312
 313                     /*
 314                      * Select whether the frequency is to be controlled
 315                      * and in which mode (PLL or FLL). Clamp to the operating
 316                      * range. Ugly multiply/divide should be replaced someday.
 317                      */
 318
 319                     if (time_status & STA_FREQHOLD || time_reftime == 0)
 320                         time_reftime = xtime.tv_sec;
 321                     mtemp = xtime.tv_sec - time_reftime;
 322                     time_reftime = xtime.tv_sec;
 323                     if (time_status & STA_FLL) {
 324                         if (mtemp >= MINSEC) {
 325                             ltemp = (time_offset / mtemp) << (SHIFT_USEC -
 326                                                               SHIFT_UPDATE);
 327                             time_freq += shift_right(ltemp, SHIFT_KH);
 328                         } else /* calibration interval too short (p. 12) */
 329                                 result = TIME_ERROR;
 330                     } else {    /* PLL mode */
 331                         if (mtemp < MAXSEC) {
 332                             ltemp *= mtemp;
 333                             time_freq += shift_right(ltemp,(time_constant +
 334                                                        time_constant +
 335                                                        SHIFT_KF - SHIFT_USEC));
 336                         } else /* calibration interval too long (p. 12) */
 337                                 result = TIME_ERROR;
 338                     }
 339                     time_freq = min(time_freq, time_tolerance);
 340                     time_freq = max(time_freq, -time_tolerance);
 341                 } /* STA_PLL */
 342             } /* txc->modes & ADJ_OFFSET */
 343             if (txc->modes & ADJ_TICK) {
 344                 tick_usec = txc->tick;
 345                 tick_nsec = TICK_USEC_TO_NSEC(tick_usec);
 346             }
 347         } /* txc->modes */
 348 leave:  if ((time_status & (STA_UNSYNC|STA_CLOCKERR)) != 0)
 349                 result = TIME_ERROR;
 350
 351         if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT)
 352             txc->offset    = save_adjust;
 353         else {
 354             txc->offset = shift_right(time_offset, SHIFT_UPDATE);
 355         }
 356         txc->freq          = time_freq;
 357         txc->maxerror      = time_maxerror;
 358         txc->esterror      = time_esterror;
 359         txc->status        = time_status;
 360         txc->constant      = time_constant;
 361         txc->precision     = time_precision;
 362         txc->tolerance     = time_tolerance;
 363         txc->tick          = tick_usec;
 364
 365         /* PPS is not implemented, so these are zero */
 366         txc->ppsfreq       = 0;
 367         txc->jitter        = 0;
 368         txc->shift         = 0;
 369         txc->stabil        = 0;
 370         txc->jitcnt        = 0;
 371         txc->calcnt        = 0;
 372         txc->errcnt        = 0;
 373         txc->stbcnt        = 0;
 374         write_sequnlock_irq(&xtime_lock);
 375         do_gettimeofday(&txc->time);
 376         notify_arch_cmos_timer();
 377         return(result);
 378 }
 379
 380 asmlinkage long sys_adjtimex(struct timex __user *txc_p)
 381 {
 382         struct timex txc;               /* Local copy of parameter */
 383         int ret;
 384
 385         /* Copy the user data space into the kernel copy
 386          * structure. But bear in mind that the structures
 387          * may change
 388          */
 389         if(copy_from_user(&txc, txc_p, sizeof(struct timex)))
 390                 return -EFAULT;
 391         ret = do_adjtimex(&txc);
 392         return copy_to_user(txc_p, &txc, sizeof(struct timex)) ? -EFAULT : ret;
 393 }
 394
 395 inline struct timespec current_kernel_time(void)
 396 {
 397         struct timespec now;
 398         unsigned long seq;
 399
 400         do {
 401                 seq = read_seqbegin(&xtime_lock);
 402
 403                 now = xtime;
 404         } while (read_seqretry(&xtime_lock, seq));
 405
 406         return now;
 407 }
 408
 409 EXPORT_SYMBOL(current_kernel_time);
 410
 411 /**
 412  * current_fs_time - Return FS time
 413  * @sb: Superblock.
 414  *
 415  * Return the current time truncated to the time granularity supported by
 416  * the fs.
 417  */
 418 struct timespec current_fs_time(struct super_block *sb)
 419 {
 420         struct timespec now = current_kernel_time();
 421         return timespec_trunc(now, sb->s_time_gran);
 422 }
 423 EXPORT_SYMBOL(current_fs_time);
 424
 425 /**
 426  * timespec_trunc - Truncate timespec to a granularity
 427  * @t: Timespec
 428  * @gran: Granularity in ns.
 429  *
 430  * Truncate a timespec to a granularity. gran must be smaller than a second.
 431  * Always rounds down.
 432  *
 433  * This function should be only used for timestamps returned by
 434  * current_kernel_time() or CURRENT_TIME, not with do_gettimeofday() because
 435  * it doesn't handle the better resolution of the later.
 436  */
 437 struct timespec timespec_trunc(struct timespec t, unsigned gran)
 438 {
 439         /*
 440          * Division is pretty slow so avoid it for common cases.
 441          * Currently current_kernel_time() never returns better than
 442          * jiffies resolution. Exploit that.
 443          */
 444         if (gran <= jiffies_to_usecs(1) * 1000) {
 445                 /* nothing */
 446         } else if (gran == 1000000000) {
 447                 t.tv_nsec = 0;
 448         } else {
 449                 t.tv_nsec -= t.tv_nsec % gran;
 450         }
 451         return t;
 452 }
 453 EXPORT_SYMBOL(timespec_trunc);
 454
 455 #ifdef CONFIG_TIME_INTERPOLATION
 456 void getnstimeofday (struct timespec *tv)
 457 {
 458         unsigned long seq,sec,nsec;
 459
 460         do {
 461                 seq = read_seqbegin(&xtime_lock);
 462                 sec = xtime.tv_sec;
 463                 nsec = xtime.tv_nsec+time_interpolator_get_offset();
 464         } while (unlikely(read_seqretry(&xtime_lock, seq)));
 465
 466         while (unlikely(nsec >= NSEC_PER_SEC)) {
 467                 nsec -= NSEC_PER_SEC;
 468                 ++sec;
 469         }
 470         tv->tv_sec = sec;
 471         tv->tv_nsec = nsec;
 472 }
 473 EXPORT_SYMBOL_GPL(getnstimeofday);
 474
 475 int do_settimeofday (struct timespec *tv)
 476 {
 477         time_t wtm_sec, sec = tv->tv_sec;
 478         long wtm_nsec, nsec = tv->tv_nsec;
 479
 480         if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
 481                 return -EINVAL;
 482
 483         write_seqlock_irq(&xtime_lock);
 484         {
 485                 wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
 486                 wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
 487
 488                 set_normalized_timespec(&xtime, sec, nsec);
 489                 set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
 490
 491                 time_adjust = 0;                /* stop active adjtime() */
 492                 time_status |= STA_UNSYNC;
 493                 time_maxerror = NTP_PHASE_LIMIT;
 494                 time_esterror = NTP_PHASE_LIMIT;
 495                 time_interpolator_reset();
 496         }
 497         write_sequnlock_irq(&xtime_lock);
 498         clock_was_set();
 499         return 0;
 500 }
 501 EXPORT_SYMBOL(do_settimeofday);
 502
 503 void do_gettimeofday (struct timeval *tv)
 504 {
 505         unsigned long seq, nsec, usec, sec, offset;
 506         do {
 507                 seq = read_seqbegin(&xtime_lock);
 508                 offset = time_interpolator_get_offset();
 509                 sec = xtime.tv_sec;
 510                 nsec = xtime.tv_nsec;
 511         } while (unlikely(read_seqretry(&xtime_lock, seq)));
 512
 513         usec = (nsec + offset) / 1000;
 514
 515         while (unlikely(usec >= USEC_PER_SEC)) {
 516                 usec -= USEC_PER_SEC;
 517                 ++sec;
 518         }
 519
 520         tv->tv_sec = sec;
 521         tv->tv_usec = usec;
 522 }
 523
 524 EXPORT_SYMBOL(do_gettimeofday);
 525
 526
 527 #else
 528 #ifndef CONFIG_GENERIC_TIME
 529 /*
 530  * Simulate gettimeofday using do_gettimeofday which only allows a timeval
 531  * and therefore only yields usec accuracy
 532  */
 533 void getnstimeofday(struct timespec *tv)
 534 {
 535         struct timeval x;
 536
 537         do_gettimeofday(&x);
 538         tv->tv_sec = x.tv_sec;
 539         tv->tv_nsec = x.tv_usec * NSEC_PER_USEC;
 540 }
 541 EXPORT_SYMBOL_GPL(getnstimeofday);
 542 #endif
 543 #endif
 544
 545 /* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
 546  * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
 547  * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
 548  *
 549  * [For the Julian calendar (which was used in Russia before 1917,
 550  * Britain & colonies before 1752, anywhere else before 1582,
 551  * and is still in use by some communities) leave out the
 552  * -year/100+year/400 terms, and add 10.]
 553  *
 554  * This algorithm was first published by Gauss (I think).
 555  *
 556  * WARNING: this function will overflow on 2106-02-07 06:28:16 on
 557  * machines were long is 32-bit! (However, as time_t is signed, we
 558  * will already get problems at other places on 2038-01-19 03:14:08)
 559  */
 560 unsigned long
 561 mktime(const unsigned int year0, const unsigned int mon0,
 562        const unsigned int day, const unsigned int hour,
 563        const unsigned int min, const unsigned int sec)
 564 {
 565         unsigned int mon = mon0, year = year0;
 566
 567         /* 1..12 -> 11,12,1..10 */
 568         if (0 >= (int) (mon -= 2)) {
 569                 mon += 12;      /* Puts Feb last since it has leap day */
 570                 year -= 1;
 571         }
 572
 573         return ((((unsigned long)
 574                   (year/4 - year/100 + year/400 + 367*mon/12 + day) +
 575                   year*365 - 719499
 576             )*24 + hour /* now have hours */
 577           )*60 + min /* now have minutes */
 578         )*60 + sec; /* finally seconds */
 579 }
 580
 581 EXPORT_SYMBOL(mktime);
 582
 583 /**
 584  * set_normalized_timespec - set timespec sec and nsec parts and normalize
 585  *
 586  * @ts:         pointer to timespec variable to be set
 587  * @sec:        seconds to set
 588  * @nsec:       nanoseconds to set
 589  *
 590  * Set seconds and nanoseconds field of a timespec variable and
 591  * normalize to the timespec storage format
 592  *
 593  * Note: The tv_nsec part is always in the range of
 594  *      0 <= tv_nsec < NSEC_PER_SEC
 595  * For negative values only the tv_sec field is negative !
 596  */
 597 void set_normalized_timespec(struct timespec *ts, time_t sec, long nsec)
 598 {
 599         while (nsec >= NSEC_PER_SEC) {
 600                 nsec -= NSEC_PER_SEC;
 601                 ++sec;
 602         }
 603         while (nsec < 0) {
 604                 nsec += NSEC_PER_SEC;
 605                 --sec;
 606         }
 607         ts->tv_sec = sec;
 608         ts->tv_nsec = nsec;
 609 }
 610
 611 /**
 612  * ns_to_timespec - Convert nanoseconds to timespec
 613  * @nsec:       the nanoseconds value to be converted
 614  *
 615  * Returns the timespec representation of the nsec parameter.
 616  */
 617 struct timespec ns_to_timespec(const s64 nsec)
 618 {
 619         struct timespec ts;
 620
 621         if (!nsec)
 622                 return (struct timespec) {0, 0};
 623
 624         ts.tv_sec = div_long_long_rem_signed(nsec, NSEC_PER_SEC, &ts.tv_nsec);
 625         if (unlikely(nsec < 0))
 626                 set_normalized_timespec(&ts, ts.tv_sec, ts.tv_nsec);
 627
 628         return ts;
 629 }
 630
 631 /**
 632  * ns_to_timeval - Convert nanoseconds to timeval
 633  * @nsec:       the nanoseconds value to be converted
 634  *
 635  * Returns the timeval representation of the nsec parameter.
 636  */
 637 struct timeval ns_to_timeval(const s64 nsec)
 638 {
 639         struct timespec ts = ns_to_timespec(nsec);
 640         struct timeval tv;
 641
 642         tv.tv_sec = ts.tv_sec;
 643         tv.tv_usec = (suseconds_t) ts.tv_nsec / 1000;
 644
 645         return tv;
 646 }
 647
 648 #if (BITS_PER_LONG < 64)
 649 u64 get_jiffies_64(void)
 650 {
 651         unsigned long seq;
 652         u64 ret;
 653
 654         do {
 655                 seq = read_seqbegin(&xtime_lock);
 656                 ret = jiffies_64;
 657         } while (read_seqretry(&xtime_lock, seq));
 658         return ret;
 659 }
 660
 661 EXPORT_SYMBOL(get_jiffies_64);
 662 #endif
 663
 664 EXPORT_SYMBOL(jiffies);