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