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