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, s64 nsec)
 374 {
 375         while (nsec >= NSEC_PER_SEC) {
 376                 /*
 377                  * The following asm() prevents the compiler from
 378                  * optimising this loop into a modulo operation. See
 379                  * also __iter_div_u64_rem() in include/linux/time.h
 380                  */
 381                 asm("" : "+rm"(nsec));
 382                 nsec -= NSEC_PER_SEC;
 383                 ++sec;
 384         }
 385         while (nsec < 0) {
 386                 asm("" : "+rm"(nsec));
 387                 nsec += NSEC_PER_SEC;
 388                 --sec;
 389         }
 390         ts->tv_sec = sec;
 391         ts->tv_nsec = nsec;
 392 }
 393 EXPORT_SYMBOL(set_normalized_timespec);
 394
 395 /**
 396  * ns_to_timespec - Convert nanoseconds to timespec
 397  * @nsec:       the nanoseconds value to be converted
 398  *
 399  * Returns the timespec representation of the nsec parameter.
 400  */
 401 struct timespec ns_to_timespec(const s64 nsec)
 402 {
 403         struct timespec ts;
 404         s32 rem;
 405
 406         if (!nsec)
 407                 return (struct timespec) {0, 0};
 408
 409         ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem);
 410         if (unlikely(rem < 0)) {
 411                 ts.tv_sec--;
 412                 rem += NSEC_PER_SEC;
 413         }
 414         ts.tv_nsec = rem;
 415
 416         return ts;
 417 }
 418 EXPORT_SYMBOL(ns_to_timespec);
 419
 420 /**
 421  * ns_to_timeval - Convert nanoseconds to timeval
 422  * @nsec:       the nanoseconds value to be converted
 423  *
 424  * Returns the timeval representation of the nsec parameter.
 425  */
 426 struct timeval ns_to_timeval(const s64 nsec)
 427 {
 428         struct timespec ts = ns_to_timespec(nsec);
 429         struct timeval tv;
 430
 431         tv.tv_sec = ts.tv_sec;
 432         tv.tv_usec = (suseconds_t) ts.tv_nsec / 1000;
 433
 434         return tv;
 435 }
 436 EXPORT_SYMBOL(ns_to_timeval);
 437
 438 /*
 439  * When we convert to jiffies then we interpret incoming values
 440  * the following way:
 441  *
 442  * - negative values mean 'infinite timeout' (MAX_JIFFY_OFFSET)
 443  *
 444  * - 'too large' values [that would result in larger than
 445  *   MAX_JIFFY_OFFSET values] mean 'infinite timeout' too.
 446  *
 447  * - all other values are converted to jiffies by either multiplying
 448  *   the input value by a factor or dividing it with a factor
 449  *
 450  * We must also be careful about 32-bit overflows.
 451  */
 452 unsigned long msecs_to_jiffies(const unsigned int m)
 453 {
 454         /*
 455          * Negative value, means infinite timeout:
 456          */
 457         if ((int)m < 0)
 458                 return MAX_JIFFY_OFFSET;
 459
 460 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
 461         /*
 462          * HZ is equal to or smaller than 1000, and 1000 is a nice
 463          * round multiple of HZ, divide with the factor between them,
 464          * but round upwards:
 465          */
 466         return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ);
 467 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
 468         /*
 469          * HZ is larger than 1000, and HZ is a nice round multiple of
 470          * 1000 - simply multiply with the factor between them.
 471          *
 472          * But first make sure the multiplication result cannot
 473          * overflow:
 474          */
 475         if (m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
 476                 return MAX_JIFFY_OFFSET;
 477
 478         return m * (HZ / MSEC_PER_SEC);
 479 #else
 480         /*
 481          * Generic case - multiply, round and divide. But first
 482          * check that if we are doing a net multiplication, that
 483          * we wouldn't overflow:
 484          */
 485         if (HZ > MSEC_PER_SEC && m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
 486                 return MAX_JIFFY_OFFSET;
 487
 488         return (MSEC_TO_HZ_MUL32 * m + MSEC_TO_HZ_ADJ32)
 489                 >> MSEC_TO_HZ_SHR32;
 490 #endif
 491 }
 492 EXPORT_SYMBOL(msecs_to_jiffies);
 493
 494 unsigned long usecs_to_jiffies(const unsigned int u)
 495 {
 496         if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
 497                 return MAX_JIFFY_OFFSET;
 498 #if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
 499         return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ);
 500 #elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
 501         return u * (HZ / USEC_PER_SEC);
 502 #else
 503         return (USEC_TO_HZ_MUL32 * u + USEC_TO_HZ_ADJ32)
 504                 >> USEC_TO_HZ_SHR32;
 505 #endif
 506 }
 507 EXPORT_SYMBOL(usecs_to_jiffies);
 508
 509 /*
 510  * The TICK_NSEC - 1 rounds up the value to the next resolution.  Note
 511  * that a remainder subtract here would not do the right thing as the
 512  * resolution values don't fall on second boundries.  I.e. the line:
 513  * nsec -= nsec % TICK_NSEC; is NOT a correct resolution rounding.
 514  *
 515  * Rather, we just shift the bits off the right.
 516  *
 517  * The >> (NSEC_JIFFIE_SC - SEC_JIFFIE_SC) converts the scaled nsec
 518  * value to a scaled second value.
 519  */
 520 unsigned long
 521 timespec_to_jiffies(const struct timespec *value)
 522 {
 523         unsigned long sec = value->tv_sec;
 524         long nsec = value->tv_nsec + TICK_NSEC - 1;
 525
 526         if (sec >= MAX_SEC_IN_JIFFIES){
 527                 sec = MAX_SEC_IN_JIFFIES;
 528                 nsec = 0;
 529         }
 530         return (((u64)sec * SEC_CONVERSION) +
 531                 (((u64)nsec * NSEC_CONVERSION) >>
 532                  (NSEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
 533
 534 }
 535 EXPORT_SYMBOL(timespec_to_jiffies);
 536
 537 void
 538 jiffies_to_timespec(const unsigned long jiffies, struct timespec *value)
 539 {
 540         /*
 541          * Convert jiffies to nanoseconds and separate with
 542          * one divide.
 543          */
 544         u32 rem;
 545         value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC,
 546                                     NSEC_PER_SEC, &rem);
 547         value->tv_nsec = rem;
 548 }
 549 EXPORT_SYMBOL(jiffies_to_timespec);
 550
 551 /* Same for "timeval"
 552  *
 553  * Well, almost.  The problem here is that the real system resolution is
 554  * in nanoseconds and the value being converted is in micro seconds.
 555  * Also for some machines (those that use HZ = 1024, in-particular),
 556  * there is a LARGE error in the tick size in microseconds.
 557
 558  * The solution we use is to do the rounding AFTER we convert the
 559  * microsecond part.  Thus the USEC_ROUND, the bits to be shifted off.
 560  * Instruction wise, this should cost only an additional add with carry
 561  * instruction above the way it was done above.
 562  */
 563 unsigned long
 564 timeval_to_jiffies(const struct timeval *value)
 565 {
 566         unsigned long sec = value->tv_sec;
 567         long usec = value->tv_usec;
 568
 569         if (sec >= MAX_SEC_IN_JIFFIES){
 570                 sec = MAX_SEC_IN_JIFFIES;
 571                 usec = 0;
 572         }
 573         return (((u64)sec * SEC_CONVERSION) +
 574                 (((u64)usec * USEC_CONVERSION + USEC_ROUND) >>
 575                  (USEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
 576 }
 577 EXPORT_SYMBOL(timeval_to_jiffies);
 578
 579 void jiffies_to_timeval(const unsigned long jiffies, struct timeval *value)
 580 {
 581         /*
 582          * Convert jiffies to nanoseconds and separate with
 583          * one divide.
 584          */
 585         u32 rem;
 586
 587         value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC,
 588                                     NSEC_PER_SEC, &rem);
 589         value->tv_usec = rem / NSEC_PER_USEC;
 590 }
 591 EXPORT_SYMBOL(jiffies_to_timeval);
 592
 593 /*
 594  * Convert jiffies/jiffies_64 to clock_t and back.
 595  */
 596 clock_t jiffies_to_clock_t(long x)
 597 {
 598 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
 599 # if HZ < USER_HZ
 600         return x * (USER_HZ / HZ);
 601 # else
 602         return x / (HZ / USER_HZ);
 603 # endif
 604 #else
 605         return div_u64((u64)x * TICK_NSEC, NSEC_PER_SEC / USER_HZ);
 606 #endif
 607 }
 608 EXPORT_SYMBOL(jiffies_to_clock_t);
 609
 610 unsigned long clock_t_to_jiffies(unsigned long x)
 611 {
 612 #if (HZ % USER_HZ)==0
 613         if (x >= ~0UL / (HZ / USER_HZ))
 614                 return ~0UL;
 615         return x * (HZ / USER_HZ);
 616 #else
 617         /* Don't worry about loss of precision here .. */
 618         if (x >= ~0UL / HZ * USER_HZ)
 619                 return ~0UL;
 620
 621         /* .. but do try to contain it here */
 622         return div_u64((u64)x * HZ, USER_HZ);
 623 #endif
 624 }
 625 EXPORT_SYMBOL(clock_t_to_jiffies);
 626
 627 u64 jiffies_64_to_clock_t(u64 x)
 628 {
 629 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
 630 # if HZ < USER_HZ
 631         x = div_u64(x * USER_HZ, HZ);
 632 # elif HZ > USER_HZ
 633         x = div_u64(x, HZ / USER_HZ);
 634 # else
 635         /* Nothing to do */
 636 # endif
 637 #else
 638         /*
 639          * There are better ways that don't overflow early,
 640          * but even this doesn't overflow in hundreds of years
 641          * in 64 bits, so..
 642          */
 643         x = div_u64(x * TICK_NSEC, (NSEC_PER_SEC / USER_HZ));
 644 #endif
 645         return x;
 646 }
 647 EXPORT_SYMBOL(jiffies_64_to_clock_t);
 648
 649 u64 nsec_to_clock_t(u64 x)
 650 {
 651 #if (NSEC_PER_SEC % USER_HZ) == 0
 652         return div_u64(x, NSEC_PER_SEC / USER_HZ);
 653 #elif (USER_HZ % 512) == 0
 654         return div_u64(x * USER_HZ / 512, NSEC_PER_SEC / 512);
 655 #else
 656         /*
 657          * max relative error 5.7e-8 (1.8s per year) for USER_HZ <= 1024,
 658          * overflow after 64.99 years.
 659          * exact for HZ=60, 72, 90, 120, 144, 180, 300, 600, 900, ...
 660          */
 661         return div_u64(x * 9, (9ull * NSEC_PER_SEC + (USER_HZ / 2)) / USER_HZ);
 662 #endif
 663 }
 664
 665 /**
 666  * nsecs_to_jiffies - Convert nsecs in u64 to jiffies
 667  *
 668  * @n:  nsecs in u64
 669  *
 670  * Unlike {m,u}secs_to_jiffies, type of input is not unsigned int but u64.
 671  * And this doesn't return MAX_JIFFY_OFFSET since this function is designed
 672  * for scheduler, not for use in device drivers to calculate timeout value.
 673  *
 674  * note:
 675  *   NSEC_PER_SEC = 10^9 = (5^9 * 2^9) = (1953125 * 512)
 676  *   ULLONG_MAX ns = 18446744073.709551615 secs = about 584 years
 677  */
 678 unsigned long nsecs_to_jiffies(u64 n)
 679 {
 680 #if (NSEC_PER_SEC % HZ) == 0
 681         /* Common case, HZ = 100, 128, 200, 250, 256, 500, 512, 1000 etc. */
 682         return div_u64(n, NSEC_PER_SEC / HZ);
 683 #elif (HZ % 512) == 0
 684         /* overflow after 292 years if HZ = 1024 */
 685         return div_u64(n * HZ / 512, NSEC_PER_SEC / 512);
 686 #else
 687         /*
 688          * Generic case - optimized for cases where HZ is a multiple of 3.
 689          * overflow after 64.99 years, exact for HZ = 60, 72, 90, 120 etc.
 690          */
 691         return div_u64(n * 9, (9ull * NSEC_PER_SEC + HZ / 2) / HZ);
 692 #endif
 693 }
 694
 695 #if (BITS_PER_LONG < 64)
 696 u64 get_jiffies_64(void)
 697 {
 698         unsigned long seq;
 699         u64 ret;
 700
 701         do {
 702                 seq = read_seqbegin(&xtime_lock);
 703                 ret = jiffies_64;
 704         } while (read_seqretry(&xtime_lock, seq));
 705         return ret;
 706 }
 707 EXPORT_SYMBOL(get_jiffies_64);
 708 #endif
 709
 710 EXPORT_SYMBOL(jiffies);
 711
 712 /*
 713  * Add two timespec values and do a safety check for overflow.
 714  * It's assumed that both values are valid (>= 0)
 715  */
 716 struct timespec timespec_add_safe(const struct timespec lhs,
 717                                   const struct timespec rhs)
 718 {
 719         struct timespec res;
 720
 721         set_normalized_timespec(&res, lhs.tv_sec + rhs.tv_sec,
 722                                 lhs.tv_nsec + rhs.tv_nsec);
 723
 724         if (res.tv_sec < lhs.tv_sec || res.tv_sec < rhs.tv_sec)
 725                 res.tv_sec = TIME_T_MAX;
 726
 727         return res;
 728 }