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/smp_lock.h>
  35 #include <linux/syscalls.h>
  36 #include <linux/security.h>
  37 #include <linux/fs.h>
  38 #include <linux/module.h>
  39
  40 #include <asm/uaccess.h>
  41 #include <asm/unistd.h>
  42
  43 /*
  44  * The timezone where the local system is located.  Used as a default by some
  45  * programs who obtain this value by using gettimeofday.
  46  */
  47 struct timezone sys_tz;
  48
  49 EXPORT_SYMBOL(sys_tz);
  50
  51 #ifdef __ARCH_WANT_SYS_TIME
  52
  53 /*
  54  * sys_time() can be implemented in user-level using
  55  * sys_gettimeofday().  Is this for backwards compatibility?  If so,
  56  * why not move it into the appropriate arch directory (for those
  57  * architectures that need it).
  58  */
  59 asmlinkage long sys_time(time_t __user * tloc)
  60 {
  61         time_t i;
  62         struct timeval tv;
  63
  64         do_gettimeofday(&tv);
  65         i = tv.tv_sec;
  66
  67         if (tloc) {
  68                 if (put_user(i,tloc))
  69                         i = -EFAULT;
  70         }
  71         return i;
  72 }
  73
  74 /*
  75  * sys_stime() can be implemented in user-level using
  76  * sys_settimeofday().  Is this for backwards compatibility?  If so,
  77  * why not move it into the appropriate arch directory (for those
  78  * architectures that need it).
  79  */
  80
  81 asmlinkage long sys_stime(time_t __user *tptr)
  82 {
  83         struct timespec tv;
  84         int err;
  85
  86         if (get_user(tv.tv_sec, tptr))
  87                 return -EFAULT;
  88
  89         tv.tv_nsec = 0;
  90
  91         err = security_settime(&tv, NULL);
  92         if (err)
  93                 return err;
  94
  95         do_settimeofday(&tv);
  96         return 0;
  97 }
  98
  99 #endif /* __ARCH_WANT_SYS_TIME */
 100
 101 asmlinkage long sys_gettimeofday(struct timeval __user *tv, struct timezone __user *tz)
 102 {
 103         if (likely(tv != NULL)) {
 104                 struct timeval ktv;
 105                 do_gettimeofday(&ktv);
 106                 if (copy_to_user(tv, &ktv, sizeof(ktv)))
 107                         return -EFAULT;
 108         }
 109         if (unlikely(tz != NULL)) {
 110                 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
 111                         return -EFAULT;
 112         }
 113         return 0;
 114 }
 115
 116 /*
 117  * Adjust the time obtained from the CMOS to be UTC time instead of
 118  * local time.
 119  *
 120  * This is ugly, but preferable to the alternatives.  Otherwise we
 121  * would either need to write a program to do it in /etc/rc (and risk
 122  * confusion if the program gets run more than once; it would also be
 123  * hard to make the program warp the clock precisely n hours)  or
 124  * compile in the timezone information into the kernel.  Bad, bad....
 125  *
 126  *                                              - TYT, 1992-01-01
 127  *
 128  * The best thing to do is to keep the CMOS clock in universal time (UTC)
 129  * as real UNIX machines always do it. This avoids all headaches about
 130  * daylight saving times and warping kernel clocks.
 131  */
 132 static inline void warp_clock(void)
 133 {
 134         write_seqlock_irq(&xtime_lock);
 135         wall_to_monotonic.tv_sec -= sys_tz.tz_minuteswest * 60;
 136         xtime.tv_sec += sys_tz.tz_minuteswest * 60;
 137         time_interpolator_reset();
 138         write_sequnlock_irq(&xtime_lock);
 139         clock_was_set();
 140 }
 141
 142 /*
 143  * In case for some reason the CMOS clock has not already been running
 144  * in UTC, but in some local time: The first time we set the timezone,
 145  * we will warp the clock so that it is ticking UTC time instead of
 146  * local time. Presumably, if someone is setting the timezone then we
 147  * are running in an environment where the programs understand about
 148  * timezones. This should be done at boot time in the /etc/rc script,
 149  * as soon as possible, so that the clock can be set right. Otherwise,
 150  * various programs will get confused when the clock gets warped.
 151  */
 152
 153 int do_sys_settimeofday(struct timespec *tv, struct timezone *tz)
 154 {
 155         static int firsttime = 1;
 156         int error = 0;
 157
 158         if (!timespec_valid(tv))
 159                 return -EINVAL;
 160
 161         error = security_settime(tv, tz);
 162         if (error)
 163                 return error;
 164
 165         if (tz) {
 166                 /* SMP safe, global irq locking makes it work. */
 167                 sys_tz = *tz;
 168                 if (firsttime) {
 169                         firsttime = 0;
 170                         if (!tv)
 171                                 warp_clock();
 172                 }
 173         }
 174         if (tv)
 175         {
 176                 /* SMP safe, again the code in arch/foo/time.c should
 177                  * globally block out interrupts when it runs.
 178                  */
 179                 return do_settimeofday(tv);
 180         }
 181         return 0;
 182 }
 183
 184 asmlinkage long sys_settimeofday(struct timeval __user *tv,
 185                                 struct timezone __user *tz)
 186 {
 187         struct timeval user_tv;
 188         struct timespec new_ts;
 189         struct timezone new_tz;
 190
 191         if (tv) {
 192                 if (copy_from_user(&user_tv, tv, sizeof(*tv)))
 193                         return -EFAULT;
 194                 new_ts.tv_sec = user_tv.tv_sec;
 195                 new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC;
 196         }
 197         if (tz) {
 198                 if (copy_from_user(&new_tz, tz, sizeof(*tz)))
 199                         return -EFAULT;
 200         }
 201
 202         return do_sys_settimeofday(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
 203 }
 204
 205 long pps_offset;                /* pps time offset (us) */
 206 long pps_jitter = MAXTIME;      /* time dispersion (jitter) (us) */
 207
 208 long pps_freq;                  /* frequency offset (scaled ppm) */
 209 long pps_stabil = MAXFREQ;      /* frequency dispersion (scaled ppm) */
 210
 211 long pps_valid = PPS_VALID;     /* pps signal watchdog counter */
 212
 213 int pps_shift = PPS_SHIFT;      /* interval duration (s) (shift) */
 214
 215 long pps_jitcnt;                /* jitter limit exceeded */
 216 long pps_calcnt;                /* calibration intervals */
 217 long pps_errcnt;                /* calibration errors */
 218 long pps_stbcnt;                /* stability limit exceeded */
 219
 220 /* hook for a loadable hardpps kernel module */
 221 void (*hardpps_ptr)(struct timeval *);
 222
 223 /* we call this to notify the arch when the clock is being
 224  * controlled.  If no such arch routine, do nothing.
 225  */
 226 void __attribute__ ((weak)) notify_arch_cmos_timer(void)
 227 {
 228         return;
 229 }
 230
 231 /* adjtimex mainly allows reading (and writing, if superuser) of
 232  * kernel time-keeping variables. used by xntpd.
 233  */
 234 int do_adjtimex(struct timex *txc)
 235 {
 236         long ltemp, mtemp, save_adjust;
 237         int result;
 238
 239         /* In order to modify anything, you gotta be super-user! */
 240         if (txc->modes && !capable(CAP_SYS_TIME))
 241                 return -EPERM;
 242
 243         /* Now we validate the data before disabling interrupts */
 244
 245         if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT)
 246           /* singleshot must not be used with any other mode bits */
 247                 if (txc->modes != ADJ_OFFSET_SINGLESHOT)
 248                         return -EINVAL;
 249
 250         if (txc->modes != ADJ_OFFSET_SINGLESHOT && (txc->modes & ADJ_OFFSET))
 251           /* adjustment Offset limited to +- .512 seconds */
 252                 if (txc->offset <= - MAXPHASE || txc->offset >= MAXPHASE )
 253                         return -EINVAL;
 254
 255         /* if the quartz is off by more than 10% something is VERY wrong ! */
 256         if (txc->modes & ADJ_TICK)
 257                 if (txc->tick <  900000/USER_HZ ||
 258                     txc->tick > 1100000/USER_HZ)
 259                         return -EINVAL;
 260
 261         write_seqlock_irq(&xtime_lock);
 262         result = time_state;    /* mostly `TIME_OK' */
 263
 264         /* Save for later - semantics of adjtime is to return old value */
 265         save_adjust = time_next_adjust ? time_next_adjust : time_adjust;
 266
 267 #if 0   /* STA_CLOCKERR is never set yet */
 268         time_status &= ~STA_CLOCKERR;           /* reset STA_CLOCKERR */
 269 #endif
 270         /* If there are input parameters, then process them */
 271         if (txc->modes)
 272         {
 273             if (txc->modes & ADJ_STATUS)        /* only set allowed bits */
 274                 time_status =  (txc->status & ~STA_RONLY) |
 275                               (time_status & STA_RONLY);
 276
 277             if (txc->modes & ADJ_FREQUENCY) {   /* p. 22 */
 278                 if (txc->freq > MAXFREQ || txc->freq < -MAXFREQ) {
 279                     result = -EINVAL;
 280                     goto leave;
 281                 }
 282                 time_freq = txc->freq - pps_freq;
 283             }
 284
 285             if (txc->modes & ADJ_MAXERROR) {
 286                 if (txc->maxerror < 0 || txc->maxerror >= NTP_PHASE_LIMIT) {
 287                     result = -EINVAL;
 288                     goto leave;
 289                 }
 290                 time_maxerror = txc->maxerror;
 291             }
 292
 293             if (txc->modes & ADJ_ESTERROR) {
 294                 if (txc->esterror < 0 || txc->esterror >= NTP_PHASE_LIMIT) {
 295                     result = -EINVAL;
 296                     goto leave;
 297                 }
 298                 time_esterror = txc->esterror;
 299             }
 300
 301             if (txc->modes & ADJ_TIMECONST) {   /* p. 24 */
 302                 if (txc->constant < 0) {        /* NTP v4 uses values > 6 */
 303                     result = -EINVAL;
 304                     goto leave;
 305                 }
 306                 time_constant = txc->constant;
 307             }
 308
 309             if (txc->modes & ADJ_OFFSET) {      /* values checked earlier */
 310                 if (txc->modes == ADJ_OFFSET_SINGLESHOT) {
 311                     /* adjtime() is independent from ntp_adjtime() */
 312                     if ((time_next_adjust = txc->offset) == 0)
 313                          time_adjust = 0;
 314                 }
 315                 else if ( time_status & (STA_PLL | STA_PPSTIME) ) {
 316                     ltemp = (time_status & (STA_PPSTIME | STA_PPSSIGNAL)) ==
 317                             (STA_PPSTIME | STA_PPSSIGNAL) ?
 318                             pps_offset : txc->offset;
 319
 320                     /*
 321                      * Scale the phase adjustment and
 322                      * clamp to the operating range.
 323                      */
 324                     if (ltemp > MAXPHASE)
 325                         time_offset = MAXPHASE << SHIFT_UPDATE;
 326                     else if (ltemp < -MAXPHASE)
 327                         time_offset = -(MAXPHASE << SHIFT_UPDATE);
 328                     else
 329                         time_offset = ltemp << SHIFT_UPDATE;
 330
 331                     /*
 332                      * Select whether the frequency is to be controlled
 333                      * and in which mode (PLL or FLL). Clamp to the operating
 334                      * range. Ugly multiply/divide should be replaced someday.
 335                      */
 336
 337                     if (time_status & STA_FREQHOLD || time_reftime == 0)
 338                         time_reftime = xtime.tv_sec;
 339                     mtemp = xtime.tv_sec - time_reftime;
 340                     time_reftime = xtime.tv_sec;
 341                     if (time_status & STA_FLL) {
 342                         if (mtemp >= MINSEC) {
 343                             ltemp = (time_offset / mtemp) << (SHIFT_USEC -
 344                                                               SHIFT_UPDATE);
 345                             time_freq += shift_right(ltemp, SHIFT_KH);
 346                         } else /* calibration interval too short (p. 12) */
 347                                 result = TIME_ERROR;
 348                     } else {    /* PLL mode */
 349                         if (mtemp < MAXSEC) {
 350                             ltemp *= mtemp;
 351                             time_freq += shift_right(ltemp,(time_constant +
 352                                                        time_constant +
 353                                                        SHIFT_KF - SHIFT_USEC));
 354                         } else /* calibration interval too long (p. 12) */
 355                                 result = TIME_ERROR;
 356                     }
 357                     time_freq = min(time_freq, time_tolerance);
 358                     time_freq = max(time_freq, -time_tolerance);
 359                 } /* STA_PLL || STA_PPSTIME */
 360             } /* txc->modes & ADJ_OFFSET */
 361             if (txc->modes & ADJ_TICK) {
 362                 tick_usec = txc->tick;
 363                 tick_nsec = TICK_USEC_TO_NSEC(tick_usec);
 364             }
 365         } /* txc->modes */
 366 leave:  if ((time_status & (STA_UNSYNC|STA_CLOCKERR)) != 0
 367             || ((time_status & (STA_PPSFREQ|STA_PPSTIME)) != 0
 368                 && (time_status & STA_PPSSIGNAL) == 0)
 369             /* p. 24, (b) */
 370             || ((time_status & (STA_PPSTIME|STA_PPSJITTER))
 371                 == (STA_PPSTIME|STA_PPSJITTER))
 372             /* p. 24, (c) */
 373             || ((time_status & STA_PPSFREQ) != 0
 374                 && (time_status & (STA_PPSWANDER|STA_PPSERROR)) != 0))
 375             /* p. 24, (d) */
 376                 result = TIME_ERROR;
 377
 378         if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT)
 379             txc->offset    = save_adjust;
 380         else {
 381             txc->offset = shift_right(time_offset, SHIFT_UPDATE);
 382         }
 383         txc->freq          = time_freq + pps_freq;
 384         txc->maxerror      = time_maxerror;
 385         txc->esterror      = time_esterror;
 386         txc->status        = time_status;
 387         txc->constant      = time_constant;
 388         txc->precision     = time_precision;
 389         txc->tolerance     = time_tolerance;
 390         txc->tick          = tick_usec;
 391         txc->ppsfreq       = pps_freq;
 392         txc->jitter        = pps_jitter >> PPS_AVG;
 393         txc->shift         = pps_shift;
 394         txc->stabil        = pps_stabil;
 395         txc->jitcnt        = pps_jitcnt;
 396         txc->calcnt        = pps_calcnt;
 397         txc->errcnt        = pps_errcnt;
 398         txc->stbcnt        = pps_stbcnt;
 399         write_sequnlock_irq(&xtime_lock);
 400         do_gettimeofday(&txc->time);
 401         notify_arch_cmos_timer();
 402         return(result);
 403 }
 404
 405 asmlinkage long sys_adjtimex(struct timex __user *txc_p)
 406 {
 407         struct timex txc;               /* Local copy of parameter */
 408         int ret;
 409
 410         /* Copy the user data space into the kernel copy
 411          * structure. But bear in mind that the structures
 412          * may change
 413          */
 414         if(copy_from_user(&txc, txc_p, sizeof(struct timex)))
 415                 return -EFAULT;
 416         ret = do_adjtimex(&txc);
 417         return copy_to_user(txc_p, &txc, sizeof(struct timex)) ? -EFAULT : ret;
 418 }
 419
 420 inline struct timespec current_kernel_time(void)
 421 {
 422         struct timespec now;
 423         unsigned long seq;
 424
 425         do {
 426                 seq = read_seqbegin(&xtime_lock);
 427
 428                 now = xtime;
 429         } while (read_seqretry(&xtime_lock, seq));
 430
 431         return now;
 432 }
 433
 434 EXPORT_SYMBOL(current_kernel_time);
 435
 436 /**
 437  * current_fs_time - Return FS time
 438  * @sb: Superblock.
 439  *
 440  * Return the current time truncated to the time granuality supported by
 441  * the fs.
 442  */
 443 struct timespec current_fs_time(struct super_block *sb)
 444 {
 445         struct timespec now = current_kernel_time();
 446         return timespec_trunc(now, sb->s_time_gran);
 447 }
 448 EXPORT_SYMBOL(current_fs_time);
 449
 450 /**
 451  * timespec_trunc - Truncate timespec to a granuality
 452  * @t: Timespec
 453  * @gran: Granuality in ns.
 454  *
 455  * Truncate a timespec to a granuality. gran must be smaller than a second.
 456  * Always rounds down.
 457  *
 458  * This function should be only used for timestamps returned by
 459  * current_kernel_time() or CURRENT_TIME, not with do_gettimeofday() because
 460  * it doesn't handle the better resolution of the later.
 461  */
 462 struct timespec timespec_trunc(struct timespec t, unsigned gran)
 463 {
 464         /*
 465          * Division is pretty slow so avoid it for common cases.
 466          * Currently current_kernel_time() never returns better than
 467          * jiffies resolution. Exploit that.
 468          */
 469         if (gran <= jiffies_to_usecs(1) * 1000) {
 470                 /* nothing */
 471         } else if (gran == 1000000000) {
 472                 t.tv_nsec = 0;
 473         } else {
 474                 t.tv_nsec -= t.tv_nsec % gran;
 475         }
 476         return t;
 477 }
 478 EXPORT_SYMBOL(timespec_trunc);
 479
 480 #ifdef CONFIG_TIME_INTERPOLATION
 481 void getnstimeofday (struct timespec *tv)
 482 {
 483         unsigned long seq,sec,nsec;
 484
 485         do {
 486                 seq = read_seqbegin(&xtime_lock);
 487                 sec = xtime.tv_sec;
 488                 nsec = xtime.tv_nsec+time_interpolator_get_offset();
 489         } while (unlikely(read_seqretry(&xtime_lock, seq)));
 490
 491         while (unlikely(nsec >= NSEC_PER_SEC)) {
 492                 nsec -= NSEC_PER_SEC;
 493                 ++sec;
 494         }
 495         tv->tv_sec = sec;
 496         tv->tv_nsec = nsec;
 497 }
 498 EXPORT_SYMBOL_GPL(getnstimeofday);
 499
 500 int do_settimeofday (struct timespec *tv)
 501 {
 502         time_t wtm_sec, sec = tv->tv_sec;
 503         long wtm_nsec, nsec = tv->tv_nsec;
 504
 505         if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
 506                 return -EINVAL;
 507
 508         write_seqlock_irq(&xtime_lock);
 509         {
 510                 wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
 511                 wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
 512
 513                 set_normalized_timespec(&xtime, sec, nsec);
 514                 set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
 515
 516                 time_adjust = 0;                /* stop active adjtime() */
 517                 time_status |= STA_UNSYNC;
 518                 time_maxerror = NTP_PHASE_LIMIT;
 519                 time_esterror = NTP_PHASE_LIMIT;
 520                 time_interpolator_reset();
 521         }
 522         write_sequnlock_irq(&xtime_lock);
 523         clock_was_set();
 524         return 0;
 525 }
 526 EXPORT_SYMBOL(do_settimeofday);
 527
 528 void do_gettimeofday (struct timeval *tv)
 529 {
 530         unsigned long seq, nsec, usec, sec, offset;
 531         do {
 532                 seq = read_seqbegin(&xtime_lock);
 533                 offset = time_interpolator_get_offset();
 534                 sec = xtime.tv_sec;
 535                 nsec = xtime.tv_nsec;
 536         } while (unlikely(read_seqretry(&xtime_lock, seq)));
 537
 538         usec = (nsec + offset) / 1000;
 539
 540         while (unlikely(usec >= USEC_PER_SEC)) {
 541                 usec -= USEC_PER_SEC;
 542                 ++sec;
 543         }
 544
 545         tv->tv_sec = sec;
 546         tv->tv_usec = usec;
 547 }
 548
 549 EXPORT_SYMBOL(do_gettimeofday);
 550
 551
 552 #else
 553 /*
 554  * Simulate gettimeofday using do_gettimeofday which only allows a timeval
 555  * and therefore only yields usec accuracy
 556  */
 557 void getnstimeofday(struct timespec *tv)
 558 {
 559         struct timeval x;
 560
 561         do_gettimeofday(&x);
 562         tv->tv_sec = x.tv_sec;
 563         tv->tv_nsec = x.tv_usec * NSEC_PER_USEC;
 564 }
 565 EXPORT_SYMBOL_GPL(getnstimeofday);
 566 #endif
 567
 568 /* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
 569  * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
 570  * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
 571  *
 572  * [For the Julian calendar (which was used in Russia before 1917,
 573  * Britain & colonies before 1752, anywhere else before 1582,
 574  * and is still in use by some communities) leave out the
 575  * -year/100+year/400 terms, and add 10.]
 576  *
 577  * This algorithm was first published by Gauss (I think).
 578  *
 579  * WARNING: this function will overflow on 2106-02-07 06:28:16 on
 580  * machines were long is 32-bit! (However, as time_t is signed, we
 581  * will already get problems at other places on 2038-01-19 03:14:08)
 582  */
 583 unsigned long
 584 mktime(const unsigned int year0, const unsigned int mon0,
 585        const unsigned int day, const unsigned int hour,
 586        const unsigned int min, const unsigned int sec)
 587 {
 588         unsigned int mon = mon0, year = year0;
 589
 590         /* 1..12 -> 11,12,1..10 */
 591         if (0 >= (int) (mon -= 2)) {
 592                 mon += 12;      /* Puts Feb last since it has leap day */
 593                 year -= 1;
 594         }
 595
 596         return ((((unsigned long)
 597                   (year/4 - year/100 + year/400 + 367*mon/12 + day) +
 598                   year*365 - 719499
 599             )*24 + hour /* now have hours */
 600           )*60 + min /* now have minutes */
 601         )*60 + sec; /* finally seconds */
 602 }
 603
 604 EXPORT_SYMBOL(mktime);
 605
 606 /**
 607  * set_normalized_timespec - set timespec sec and nsec parts and normalize
 608  *
 609  * @ts:         pointer to timespec variable to be set
 610  * @sec:        seconds to set
 611  * @nsec:       nanoseconds to set
 612  *
 613  * Set seconds and nanoseconds field of a timespec variable and
 614  * normalize to the timespec storage format
 615  *
 616  * Note: The tv_nsec part is always in the range of
 617  *      0 <= tv_nsec < NSEC_PER_SEC
 618  * For negative values only the tv_sec field is negative !
 619  */
 620 void set_normalized_timespec(struct timespec *ts, time_t sec, long nsec)
 621 {
 622         while (nsec >= NSEC_PER_SEC) {
 623                 nsec -= NSEC_PER_SEC;
 624                 ++sec;
 625         }
 626         while (nsec < 0) {
 627                 nsec += NSEC_PER_SEC;
 628                 --sec;
 629         }
 630         ts->tv_sec = sec;
 631         ts->tv_nsec = nsec;
 632 }
 633
 634 /**
 635  * ns_to_timespec - Convert nanoseconds to timespec
 636  * @nsec:       the nanoseconds value to be converted
 637  *
 638  * Returns the timespec representation of the nsec parameter.
 639  */
 640 inline struct timespec ns_to_timespec(const nsec_t nsec)
 641 {
 642         struct timespec ts;
 643
 644         if (nsec)
 645                 ts.tv_sec = div_long_long_rem_signed(nsec, NSEC_PER_SEC,
 646                                                      &ts.tv_nsec);
 647         else
 648                 ts.tv_sec = ts.tv_nsec = 0;
 649
 650         return ts;
 651 }
 652
 653 /**
 654  * ns_to_timeval - Convert nanoseconds to timeval
 655  * @nsec:       the nanoseconds value to be converted
 656  *
 657  * Returns the timeval representation of the nsec parameter.
 658  */
 659 struct timeval ns_to_timeval(const nsec_t nsec)
 660 {
 661         struct timespec ts = ns_to_timespec(nsec);
 662         struct timeval tv;
 663
 664         tv.tv_sec = ts.tv_sec;
 665         tv.tv_usec = (suseconds_t) ts.tv_nsec / 1000;
 666
 667         return tv;
 668 }
 669
 670 #if (BITS_PER_LONG < 64)
 671 u64 get_jiffies_64(void)
 672 {
 673         unsigned long seq;
 674         u64 ret;
 675
 676         do {
 677                 seq = read_seqbegin(&xtime_lock);
 678                 ret = jiffies_64;
 679         } while (read_seqretry(&xtime_lock, seq));
 680         return ret;
 681 }
 682
 683 EXPORT_SYMBOL(get_jiffies_64);
 684 #endif
 685
 686 EXPORT_SYMBOL(jiffies);