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/syscalls.h>
  35 #include <linux/security.h>
  36 #include <linux/fs.h>
  37 #include <linux/module.h>
  38
  39 #include <asm/uaccess.h>
  40 #include <asm/unistd.h>
  41
  42 /*
  43  * The timezone where the local system is located.  Used as a default by some
  44  * programs who obtain this value by using gettimeofday.
  45  */
  46 struct timezone sys_tz;
  47
  48 EXPORT_SYMBOL(sys_tz);
  49
  50 #ifdef __ARCH_WANT_SYS_TIME
  51
  52 /*
  53  * sys_time() can be implemented in user-level using
  54  * sys_gettimeofday().  Is this for backwards compatibility?  If so,
  55  * why not move it into the appropriate arch directory (for those
  56  * architectures that need it).
  57  */
  58 asmlinkage long sys_time(time_t __user * tloc)
  59 {
  60         time_t i = get_seconds();
  61
  62         if (tloc) {
  63                 if (put_user(i,tloc))
  64                         i = -EFAULT;
  65         }
  66         return i;
  67 }
  68
  69 /*
  70  * sys_stime() can be implemented in user-level using
  71  * sys_settimeofday().  Is this for backwards compatibility?  If so,
  72  * why not move it into the appropriate arch directory (for those
  73  * architectures that need it).
  74  */
  75
  76 asmlinkage long sys_stime(time_t __user *tptr)
  77 {
  78         struct timespec tv;
  79         int err;
  80
  81         if (get_user(tv.tv_sec, tptr))
  82                 return -EFAULT;
  83
  84         tv.tv_nsec = 0;
  85
  86         err = security_settime(&tv, NULL);
  87         if (err)
  88                 return err;
  89
  90         do_settimeofday(&tv);
  91         return 0;
  92 }
  93
  94 #endif /* __ARCH_WANT_SYS_TIME */
  95
  96 asmlinkage long sys_gettimeofday(struct timeval __user *tv, struct timezone __user *tz)
  97 {
  98         if (likely(tv != NULL)) {
  99                 struct timeval ktv;
 100                 do_gettimeofday(&ktv);
 101                 if (copy_to_user(tv, &ktv, sizeof(ktv)))
 102                         return -EFAULT;
 103         }
 104         if (unlikely(tz != NULL)) {
 105                 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
 106                         return -EFAULT;
 107         }
 108         return 0;
 109 }
 110
 111 /*
 112  * Adjust the time obtained from the CMOS to be UTC time instead of
 113  * local time.
 114  *
 115  * This is ugly, but preferable to the alternatives.  Otherwise we
 116  * would either need to write a program to do it in /etc/rc (and risk
 117  * confusion if the program gets run more than once; it would also be
 118  * hard to make the program warp the clock precisely n hours)  or
 119  * compile in the timezone information into the kernel.  Bad, bad....
 120  *
 121  *                                              - TYT, 1992-01-01
 122  *
 123  * The best thing to do is to keep the CMOS clock in universal time (UTC)
 124  * as real UNIX machines always do it. This avoids all headaches about
 125  * daylight saving times and warping kernel clocks.
 126  */
 127 static inline void warp_clock(void)
 128 {
 129         write_seqlock_irq(&xtime_lock);
 130         wall_to_monotonic.tv_sec -= sys_tz.tz_minuteswest * 60;
 131         xtime.tv_sec += sys_tz.tz_minuteswest * 60;
 132         write_sequnlock_irq(&xtime_lock);
 133         clock_was_set();
 134 }
 135
 136 /*
 137  * In case for some reason the CMOS clock has not already been running
 138  * in UTC, but in some local time: The first time we set the timezone,
 139  * we will warp the clock so that it is ticking UTC time instead of
 140  * local time. Presumably, if someone is setting the timezone then we
 141  * are running in an environment where the programs understand about
 142  * timezones. This should be done at boot time in the /etc/rc script,
 143  * as soon as possible, so that the clock can be set right. Otherwise,
 144  * various programs will get confused when the clock gets warped.
 145  */
 146
 147 int do_sys_settimeofday(struct timespec *tv, struct timezone *tz)
 148 {
 149         static int firsttime = 1;
 150         int error = 0;
 151
 152         if (tv && !timespec_valid(tv))
 153                 return -EINVAL;
 154
 155         error = security_settime(tv, tz);
 156         if (error)
 157                 return error;
 158
 159         if (tz) {
 160                 /* SMP safe, global irq locking makes it work. */
 161                 sys_tz = *tz;
 162                 if (firsttime) {
 163                         firsttime = 0;
 164                         if (!tv)
 165                                 warp_clock();
 166                 }
 167         }
 168         if (tv)
 169         {
 170                 /* SMP safe, again the code in arch/foo/time.c should
 171                  * globally block out interrupts when it runs.
 172                  */
 173                 return do_settimeofday(tv);
 174         }
 175         return 0;
 176 }
 177
 178 asmlinkage long sys_settimeofday(struct timeval __user *tv,
 179                                 struct timezone __user *tz)
 180 {
 181         struct timeval user_tv;
 182         struct timespec new_ts;
 183         struct timezone new_tz;
 184
 185         if (tv) {
 186                 if (copy_from_user(&user_tv, tv, sizeof(*tv)))
 187                         return -EFAULT;
 188                 new_ts.tv_sec = user_tv.tv_sec;
 189                 new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC;
 190         }
 191         if (tz) {
 192                 if (copy_from_user(&new_tz, tz, sizeof(*tz)))
 193                         return -EFAULT;
 194         }
 195
 196         return do_sys_settimeofday(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
 197 }
 198
 199 asmlinkage long sys_adjtimex(struct timex __user *txc_p)
 200 {
 201         struct timex txc;               /* Local copy of parameter */
 202         int ret;
 203
 204         /* Copy the user data space into the kernel copy
 205          * structure. But bear in mind that the structures
 206          * may change
 207          */
 208         if(copy_from_user(&txc, txc_p, sizeof(struct timex)))
 209                 return -EFAULT;
 210         ret = do_adjtimex(&txc);
 211         return copy_to_user(txc_p, &txc, sizeof(struct timex)) ? -EFAULT : ret;
 212 }
 213
 214 /**
 215  * current_fs_time - Return FS time
 216  * @sb: Superblock.
 217  *
 218  * Return the current time truncated to the time granularity supported by
 219  * the fs.
 220  */
 221 struct timespec current_fs_time(struct super_block *sb)
 222 {
 223         struct timespec now = current_kernel_time();
 224         return timespec_trunc(now, sb->s_time_gran);
 225 }
 226 EXPORT_SYMBOL(current_fs_time);
 227
 228 /*
 229  * Convert jiffies to milliseconds and back.
 230  *
 231  * Avoid unnecessary multiplications/divisions in the
 232  * two most common HZ cases:
 233  */
 234 unsigned int inline jiffies_to_msecs(const unsigned long j)
 235 {
 236 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
 237         return (MSEC_PER_SEC / HZ) * j;
 238 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
 239         return (j + (HZ / MSEC_PER_SEC) - 1)/(HZ / MSEC_PER_SEC);
 240 #else
 241         return (j * MSEC_PER_SEC) / HZ;
 242 #endif
 243 }
 244 EXPORT_SYMBOL(jiffies_to_msecs);
 245
 246 unsigned int inline jiffies_to_usecs(const unsigned long j)
 247 {
 248 #if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
 249         return (USEC_PER_SEC / HZ) * j;
 250 #elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
 251         return (j + (HZ / USEC_PER_SEC) - 1)/(HZ / USEC_PER_SEC);
 252 #else
 253         return (j * USEC_PER_SEC) / HZ;
 254 #endif
 255 }
 256 EXPORT_SYMBOL(jiffies_to_usecs);
 257
 258 /**
 259  * timespec_trunc - Truncate timespec to a granularity
 260  * @t: Timespec
 261  * @gran: Granularity in ns.
 262  *
 263  * Truncate a timespec to a granularity. gran must be smaller than a second.
 264  * Always rounds down.
 265  *
 266  * This function should be only used for timestamps returned by
 267  * current_kernel_time() or CURRENT_TIME, not with do_gettimeofday() because
 268  * it doesn't handle the better resolution of the later.
 269  */
 270 struct timespec timespec_trunc(struct timespec t, unsigned gran)
 271 {
 272         /*
 273          * Division is pretty slow so avoid it for common cases.
 274          * Currently current_kernel_time() never returns better than
 275          * jiffies resolution. Exploit that.
 276          */
 277         if (gran <= jiffies_to_usecs(1) * 1000) {
 278                 /* nothing */
 279         } else if (gran == 1000000000) {
 280                 t.tv_nsec = 0;
 281         } else {
 282                 t.tv_nsec -= t.tv_nsec % gran;
 283         }
 284         return t;
 285 }
 286 EXPORT_SYMBOL(timespec_trunc);
 287
 288 #ifndef CONFIG_GENERIC_TIME
 289 /*
 290  * Simulate gettimeofday using do_gettimeofday which only allows a timeval
 291  * and therefore only yields usec accuracy
 292  */
 293 void getnstimeofday(struct timespec *tv)
 294 {
 295         struct timeval x;
 296
 297         do_gettimeofday(&x);
 298         tv->tv_sec = x.tv_sec;
 299         tv->tv_nsec = x.tv_usec * NSEC_PER_USEC;
 300 }
 301 EXPORT_SYMBOL_GPL(getnstimeofday);
 302 #endif
 303
 304 /* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
 305  * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
 306  * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
 307  *
 308  * [For the Julian calendar (which was used in Russia before 1917,
 309  * Britain & colonies before 1752, anywhere else before 1582,
 310  * and is still in use by some communities) leave out the
 311  * -year/100+year/400 terms, and add 10.]
 312  *
 313  * This algorithm was first published by Gauss (I think).
 314  *
 315  * WARNING: this function will overflow on 2106-02-07 06:28:16 on
 316  * machines were long is 32-bit! (However, as time_t is signed, we
 317  * will already get problems at other places on 2038-01-19 03:14:08)
 318  */
 319 unsigned long
 320 mktime(const unsigned int year0, const unsigned int mon0,
 321        const unsigned int day, const unsigned int hour,
 322        const unsigned int min, const unsigned int sec)
 323 {
 324         unsigned int mon = mon0, year = year0;
 325
 326         /* 1..12 -> 11,12,1..10 */
 327         if (0 >= (int) (mon -= 2)) {
 328                 mon += 12;      /* Puts Feb last since it has leap day */
 329                 year -= 1;
 330         }
 331
 332         return ((((unsigned long)
 333                   (year/4 - year/100 + year/400 + 367*mon/12 + day) +
 334                   year*365 - 719499
 335             )*24 + hour /* now have hours */
 336           )*60 + min /* now have minutes */
 337         )*60 + sec; /* finally seconds */
 338 }
 339
 340 EXPORT_SYMBOL(mktime);
 341
 342 /**
 343  * set_normalized_timespec - set timespec sec and nsec parts and normalize
 344  *
 345  * @ts:         pointer to timespec variable to be set
 346  * @sec:        seconds to set
 347  * @nsec:       nanoseconds to set
 348  *
 349  * Set seconds and nanoseconds field of a timespec variable and
 350  * normalize to the timespec storage format
 351  *
 352  * Note: The tv_nsec part is always in the range of
 353  *      0 <= tv_nsec < NSEC_PER_SEC
 354  * For negative values only the tv_sec field is negative !
 355  */
 356 void set_normalized_timespec(struct timespec *ts, time_t sec, long nsec)
 357 {
 358         while (nsec >= NSEC_PER_SEC) {
 359                 nsec -= NSEC_PER_SEC;
 360                 ++sec;
 361         }
 362         while (nsec < 0) {
 363                 nsec += NSEC_PER_SEC;
 364                 --sec;
 365         }
 366         ts->tv_sec = sec;
 367         ts->tv_nsec = nsec;
 368 }
 369
 370 /**
 371  * ns_to_timespec - Convert nanoseconds to timespec
 372  * @nsec:       the nanoseconds value to be converted
 373  *
 374  * Returns the timespec representation of the nsec parameter.
 375  */
 376 struct timespec ns_to_timespec(const s64 nsec)
 377 {
 378         struct timespec ts;
 379
 380         if (!nsec)
 381                 return (struct timespec) {0, 0};
 382
 383         ts.tv_sec = div_long_long_rem_signed(nsec, NSEC_PER_SEC, &ts.tv_nsec);
 384         if (unlikely(nsec < 0))
 385                 set_normalized_timespec(&ts, ts.tv_sec, ts.tv_nsec);
 386
 387         return ts;
 388 }
 389 EXPORT_SYMBOL(ns_to_timespec);
 390
 391 /**
 392  * ns_to_timeval - Convert nanoseconds to timeval
 393  * @nsec:       the nanoseconds value to be converted
 394  *
 395  * Returns the timeval representation of the nsec parameter.
 396  */
 397 struct timeval ns_to_timeval(const s64 nsec)
 398 {
 399         struct timespec ts = ns_to_timespec(nsec);
 400         struct timeval tv;
 401
 402         tv.tv_sec = ts.tv_sec;
 403         tv.tv_usec = (suseconds_t) ts.tv_nsec / 1000;
 404
 405         return tv;
 406 }
 407 EXPORT_SYMBOL(ns_to_timeval);
 408
 409 /*
 410  * When we convert to jiffies then we interpret incoming values
 411  * the following way:
 412  *
 413  * - negative values mean 'infinite timeout' (MAX_JIFFY_OFFSET)
 414  *
 415  * - 'too large' values [that would result in larger than
 416  *   MAX_JIFFY_OFFSET values] mean 'infinite timeout' too.
 417  *
 418  * - all other values are converted to jiffies by either multiplying
 419  *   the input value by a factor or dividing it with a factor
 420  *
 421  * We must also be careful about 32-bit overflows.
 422  */
 423 unsigned long msecs_to_jiffies(const unsigned int m)
 424 {
 425         /*
 426          * Negative value, means infinite timeout:
 427          */
 428         if ((int)m < 0)
 429                 return MAX_JIFFY_OFFSET;
 430
 431 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
 432         /*
 433          * HZ is equal to or smaller than 1000, and 1000 is a nice
 434          * round multiple of HZ, divide with the factor between them,
 435          * but round upwards:
 436          */
 437         return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ);
 438 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
 439         /*
 440          * HZ is larger than 1000, and HZ is a nice round multiple of
 441          * 1000 - simply multiply with the factor between them.
 442          *
 443          * But first make sure the multiplication result cannot
 444          * overflow:
 445          */
 446         if (m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
 447                 return MAX_JIFFY_OFFSET;
 448
 449         return m * (HZ / MSEC_PER_SEC);
 450 #else
 451         /*
 452          * Generic case - multiply, round and divide. But first
 453          * check that if we are doing a net multiplication, that
 454          * we wouldnt overflow:
 455          */
 456         if (HZ > MSEC_PER_SEC && m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
 457                 return MAX_JIFFY_OFFSET;
 458
 459         return (m * HZ + MSEC_PER_SEC - 1) / MSEC_PER_SEC;
 460 #endif
 461 }
 462 EXPORT_SYMBOL(msecs_to_jiffies);
 463
 464 unsigned long usecs_to_jiffies(const unsigned int u)
 465 {
 466         if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
 467                 return MAX_JIFFY_OFFSET;
 468 #if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
 469         return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ);
 470 #elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
 471         return u * (HZ / USEC_PER_SEC);
 472 #else
 473         return (u * HZ + USEC_PER_SEC - 1) / USEC_PER_SEC;
 474 #endif
 475 }
 476 EXPORT_SYMBOL(usecs_to_jiffies);
 477
 478 /*
 479  * The TICK_NSEC - 1 rounds up the value to the next resolution.  Note
 480  * that a remainder subtract here would not do the right thing as the
 481  * resolution values don't fall on second boundries.  I.e. the line:
 482  * nsec -= nsec % TICK_NSEC; is NOT a correct resolution rounding.
 483  *
 484  * Rather, we just shift the bits off the right.
 485  *
 486  * The >> (NSEC_JIFFIE_SC - SEC_JIFFIE_SC) converts the scaled nsec
 487  * value to a scaled second value.
 488  */
 489 unsigned long
 490 timespec_to_jiffies(const struct timespec *value)
 491 {
 492         unsigned long sec = value->tv_sec;
 493         long nsec = value->tv_nsec + TICK_NSEC - 1;
 494
 495         if (sec >= MAX_SEC_IN_JIFFIES){
 496                 sec = MAX_SEC_IN_JIFFIES;
 497                 nsec = 0;
 498         }
 499         return (((u64)sec * SEC_CONVERSION) +
 500                 (((u64)nsec * NSEC_CONVERSION) >>
 501                  (NSEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
 502
 503 }
 504 EXPORT_SYMBOL(timespec_to_jiffies);
 505
 506 void
 507 jiffies_to_timespec(const unsigned long jiffies, struct timespec *value)
 508 {
 509         /*
 510          * Convert jiffies to nanoseconds and separate with
 511          * one divide.
 512          */
 513         u64 nsec = (u64)jiffies * TICK_NSEC;
 514         value->tv_sec = div_long_long_rem(nsec, NSEC_PER_SEC, &value->tv_nsec);
 515 }
 516 EXPORT_SYMBOL(jiffies_to_timespec);
 517
 518 /* Same for "timeval"
 519  *
 520  * Well, almost.  The problem here is that the real system resolution is
 521  * in nanoseconds and the value being converted is in micro seconds.
 522  * Also for some machines (those that use HZ = 1024, in-particular),
 523  * there is a LARGE error in the tick size in microseconds.
 524
 525  * The solution we use is to do the rounding AFTER we convert the
 526  * microsecond part.  Thus the USEC_ROUND, the bits to be shifted off.
 527  * Instruction wise, this should cost only an additional add with carry
 528  * instruction above the way it was done above.
 529  */
 530 unsigned long
 531 timeval_to_jiffies(const struct timeval *value)
 532 {
 533         unsigned long sec = value->tv_sec;
 534         long usec = value->tv_usec;
 535
 536         if (sec >= MAX_SEC_IN_JIFFIES){
 537                 sec = MAX_SEC_IN_JIFFIES;
 538                 usec = 0;
 539         }
 540         return (((u64)sec * SEC_CONVERSION) +
 541                 (((u64)usec * USEC_CONVERSION + USEC_ROUND) >>
 542                  (USEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
 543 }
 544 EXPORT_SYMBOL(timeval_to_jiffies);
 545
 546 void jiffies_to_timeval(const unsigned long jiffies, struct timeval *value)
 547 {
 548         /*
 549          * Convert jiffies to nanoseconds and separate with
 550          * one divide.
 551          */
 552         u64 nsec = (u64)jiffies * TICK_NSEC;
 553         long tv_usec;
 554
 555         value->tv_sec = div_long_long_rem(nsec, NSEC_PER_SEC, &tv_usec);
 556         tv_usec /= NSEC_PER_USEC;
 557         value->tv_usec = tv_usec;
 558 }
 559 EXPORT_SYMBOL(jiffies_to_timeval);
 560
 561 /*
 562  * Convert jiffies/jiffies_64 to clock_t and back.
 563  */
 564 clock_t jiffies_to_clock_t(long x)
 565 {
 566 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
 567         return x / (HZ / USER_HZ);
 568 #else
 569         u64 tmp = (u64)x * TICK_NSEC;
 570         do_div(tmp, (NSEC_PER_SEC / USER_HZ));
 571         return (long)tmp;
 572 #endif
 573 }
 574 EXPORT_SYMBOL(jiffies_to_clock_t);
 575
 576 unsigned long clock_t_to_jiffies(unsigned long x)
 577 {
 578 #if (HZ % USER_HZ)==0
 579         if (x >= ~0UL / (HZ / USER_HZ))
 580                 return ~0UL;
 581         return x * (HZ / USER_HZ);
 582 #else
 583         u64 jif;
 584
 585         /* Don't worry about loss of precision here .. */
 586         if (x >= ~0UL / HZ * USER_HZ)
 587                 return ~0UL;
 588
 589         /* .. but do try to contain it here */
 590         jif = x * (u64) HZ;
 591         do_div(jif, USER_HZ);
 592         return jif;
 593 #endif
 594 }
 595 EXPORT_SYMBOL(clock_t_to_jiffies);
 596
 597 u64 jiffies_64_to_clock_t(u64 x)
 598 {
 599 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
 600         do_div(x, HZ / USER_HZ);
 601 #else
 602         /*
 603          * There are better ways that don't overflow early,
 604          * but even this doesn't overflow in hundreds of years
 605          * in 64 bits, so..
 606          */
 607         x *= TICK_NSEC;
 608         do_div(x, (NSEC_PER_SEC / USER_HZ));
 609 #endif
 610         return x;
 611 }
 612
 613 EXPORT_SYMBOL(jiffies_64_to_clock_t);
 614
 615 u64 nsec_to_clock_t(u64 x)
 616 {
 617 #if (NSEC_PER_SEC % USER_HZ) == 0
 618         do_div(x, (NSEC_PER_SEC / USER_HZ));
 619 #elif (USER_HZ % 512) == 0
 620         x *= USER_HZ/512;
 621         do_div(x, (NSEC_PER_SEC / 512));
 622 #else
 623         /*
 624          * max relative error 5.7e-8 (1.8s per year) for USER_HZ <= 1024,
 625          * overflow after 64.99 years.
 626          * exact for HZ=60, 72, 90, 120, 144, 180, 300, 600, 900, ...
 627          */
 628         x *= 9;
 629         do_div(x, (unsigned long)((9ull * NSEC_PER_SEC + (USER_HZ/2)) /
 630                                   USER_HZ));
 631 #endif
 632         return x;
 633 }
 634
 635 #if (BITS_PER_LONG < 64)
 636 u64 get_jiffies_64(void)
 637 {
 638         unsigned long seq;
 639         u64 ret;
 640
 641         do {
 642                 seq = read_seqbegin(&xtime_lock);
 643                 ret = jiffies_64;
 644         } while (read_seqretry(&xtime_lock, seq));
 645         return ret;
 646 }
 647
 648 EXPORT_SYMBOL(get_jiffies_64);
 649 #endif
 650
 651 EXPORT_SYMBOL(jiffies);