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