SAFE public projects git trees. - safe/jmp/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/errno.h>
  33 #include <linux/smp_lock.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         error = security_settime(tv, tz);
 158         if (error)
 159                 return error;
 160
 161         if (tz) {
 162                 /* SMP safe, global irq locking makes it work. */
 163                 sys_tz = *tz;
 164                 if (firsttime) {
 165                         firsttime = 0;
 166                         if (!tv)
 167                                 warp_clock();
 168                 }
 169         }
 170         if (tv)
 171         {
 172                 /* SMP safe, again the code in arch/foo/time.c should
 173                  * globally block out interrupts when it runs.
 174                  */
 175                 return do_settimeofday(tv);
 176         }
 177         return 0;
 178 }
 179
 180 asmlinkage long sys_settimeofday(struct timeval __user *tv,
 181                                 struct timezone __user *tz)
 182 {
 183         struct timeval user_tv;
 184         struct timespec new_ts;
 185         struct timezone new_tz;
 186
 187         if (tv) {
 188                 if (copy_from_user(&user_tv, tv, sizeof(*tv)))
 189                         return -EFAULT;
 190                 new_ts.tv_sec = user_tv.tv_sec;
 191                 new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC;
 192         }
 193         if (tz) {
 194                 if (copy_from_user(&new_tz, tz, sizeof(*tz)))
 195                         return -EFAULT;
 196         }
 197
 198         return do_sys_settimeofday(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
 199 }
 200
 201 long pps_offset;                /* pps time offset (us) */
 202 long pps_jitter = MAXTIME;      /* time dispersion (jitter) (us) */
 203
 204 long pps_freq;                  /* frequency offset (scaled ppm) */
 205 long pps_stabil = MAXFREQ;      /* frequency dispersion (scaled ppm) */
 206
 207 long pps_valid = PPS_VALID;     /* pps signal watchdog counter */
 208
 209 int pps_shift = PPS_SHIFT;      /* interval duration (s) (shift) */
 210
 211 long pps_jitcnt;                /* jitter limit exceeded */
 212 long pps_calcnt;                /* calibration intervals */
 213 long pps_errcnt;                /* calibration errors */
 214 long pps_stbcnt;                /* stability limit exceeded */
 215
 216 /* hook for a loadable hardpps kernel module */
 217 void (*hardpps_ptr)(struct timeval *);
 218
 219 /* we call this to notify the arch when the clock is being
 220  * controlled.  If no such arch routine, do nothing.
 221  */
 222 void __attribute__ ((weak)) notify_arch_cmos_timer(void)
 223 {
 224         return;
 225 }
 226
 227 /* adjtimex mainly allows reading (and writing, if superuser) of
 228  * kernel time-keeping variables. used by xntpd.
 229  */
 230 int do_adjtimex(struct timex *txc)
 231 {
 232         long ltemp, mtemp, save_adjust;
 233         int result;
 234
 235         /* In order to modify anything, you gotta be super-user! */
 236         if (txc->modes && !capable(CAP_SYS_TIME))
 237                 return -EPERM;
 238
 239         /* Now we validate the data before disabling interrupts */
 240
 241         if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT)
 242           /* singleshot must not be used with any other mode bits */
 243                 if (txc->modes != ADJ_OFFSET_SINGLESHOT)
 244                         return -EINVAL;
 245
 246         if (txc->modes != ADJ_OFFSET_SINGLESHOT && (txc->modes & ADJ_OFFSET))
 247           /* adjustment Offset limited to +- .512 seconds */
 248                 if (txc->offset <= - MAXPHASE || txc->offset >= MAXPHASE )
 249                         return -EINVAL;
 250
 251         /* if the quartz is off by more than 10% something is VERY wrong ! */
 252         if (txc->modes & ADJ_TICK)
 253                 if (txc->tick <  900000/USER_HZ ||
 254                     txc->tick > 1100000/USER_HZ)
 255                         return -EINVAL;
 256
 257         write_seqlock_irq(&xtime_lock);
 258         result = time_state;    /* mostly `TIME_OK' */
 259
 260         /* Save for later - semantics of adjtime is to return old value */
 261         save_adjust = time_next_adjust ? time_next_adjust : time_adjust;
 262
 263 #if 0   /* STA_CLOCKERR is never set yet */
 264         time_status &= ~STA_CLOCKERR;           /* reset STA_CLOCKERR */
 265 #endif
 266         /* If there are input parameters, then process them */
 267         if (txc->modes)
 268         {
 269             if (txc->modes & ADJ_STATUS)        /* only set allowed bits */
 270                 time_status =  (txc->status & ~STA_RONLY) |
 271                               (time_status & STA_RONLY);
 272
 273             if (txc->modes & ADJ_FREQUENCY) {   /* p. 22 */
 274                 if (txc->freq > MAXFREQ || txc->freq < -MAXFREQ) {
 275                     result = -EINVAL;
 276                     goto leave;
 277                 }
 278                 time_freq = txc->freq - pps_freq;
 279             }
 280
 281             if (txc->modes & ADJ_MAXERROR) {
 282                 if (txc->maxerror < 0 || txc->maxerror >= NTP_PHASE_LIMIT) {
 283                     result = -EINVAL;
 284                     goto leave;
 285                 }
 286                 time_maxerror = txc->maxerror;
 287             }
 288
 289             if (txc->modes & ADJ_ESTERROR) {
 290                 if (txc->esterror < 0 || txc->esterror >= NTP_PHASE_LIMIT) {
 291                     result = -EINVAL;
 292                     goto leave;
 293                 }
 294                 time_esterror = txc->esterror;
 295             }
 296
 297             if (txc->modes & ADJ_TIMECONST) {   /* p. 24 */
 298                 if (txc->constant < 0) {        /* NTP v4 uses values > 6 */
 299                     result = -EINVAL;
 300                     goto leave;
 301                 }
 302                 time_constant = txc->constant;
 303             }
 304
 305             if (txc->modes & ADJ_OFFSET) {      /* values checked earlier */
 306                 if (txc->modes == ADJ_OFFSET_SINGLESHOT) {
 307                     /* adjtime() is independent from ntp_adjtime() */
 308                     if ((time_next_adjust = txc->offset) == 0)
 309                          time_adjust = 0;
 310                 }
 311                 else if ( time_status & (STA_PLL | STA_PPSTIME) ) {
 312                     ltemp = (time_status & (STA_PPSTIME | STA_PPSSIGNAL)) ==
 313                             (STA_PPSTIME | STA_PPSSIGNAL) ?
 314                             pps_offset : txc->offset;
 315
 316                     /*
 317                      * Scale the phase adjustment and
 318                      * clamp to the operating range.
 319                      */
 320                     if (ltemp > MAXPHASE)
 321                         time_offset = MAXPHASE << SHIFT_UPDATE;
 322                     else if (ltemp < -MAXPHASE)
 323                         time_offset = -(MAXPHASE << SHIFT_UPDATE);
 324                     else
 325                         time_offset = ltemp << SHIFT_UPDATE;
 326
 327                     /*
 328                      * Select whether the frequency is to be controlled
 329                      * and in which mode (PLL or FLL). Clamp to the operating
 330                      * range. Ugly multiply/divide should be replaced someday.
 331                      */
 332
 333                     if (time_status & STA_FREQHOLD || time_reftime == 0)
 334                         time_reftime = xtime.tv_sec;
 335                     mtemp = xtime.tv_sec - time_reftime;
 336                     time_reftime = xtime.tv_sec;
 337                     if (time_status & STA_FLL) {
 338                         if (mtemp >= MINSEC) {
 339                             ltemp = (time_offset / mtemp) << (SHIFT_USEC -
 340                                                               SHIFT_UPDATE);
 341                             time_freq += shift_right(ltemp, SHIFT_KH);
 342                         } else /* calibration interval too short (p. 12) */
 343                                 result = TIME_ERROR;
 344                     } else {    /* PLL mode */
 345                         if (mtemp < MAXSEC) {
 346                             ltemp *= mtemp;
 347                             time_freq += shift_right(ltemp,(time_constant +
 348                                                        time_constant +
 349                                                        SHIFT_KF - SHIFT_USEC));
 350                         } else /* calibration interval too long (p. 12) */
 351                                 result = TIME_ERROR;
 352                     }
 353                     time_freq = min(time_freq, time_tolerance);
 354                     time_freq = max(time_freq, -time_tolerance);
 355                 } /* STA_PLL || STA_PPSTIME */
 356             } /* txc->modes & ADJ_OFFSET */
 357             if (txc->modes & ADJ_TICK) {
 358                 tick_usec = txc->tick;
 359                 tick_nsec = TICK_USEC_TO_NSEC(tick_usec);
 360             }
 361         } /* txc->modes */
 362 leave:  if ((time_status & (STA_UNSYNC|STA_CLOCKERR)) != 0
 363             || ((time_status & (STA_PPSFREQ|STA_PPSTIME)) != 0
 364                 && (time_status & STA_PPSSIGNAL) == 0)
 365             /* p. 24, (b) */
 366             || ((time_status & (STA_PPSTIME|STA_PPSJITTER))
 367                 == (STA_PPSTIME|STA_PPSJITTER))
 368             /* p. 24, (c) */
 369             || ((time_status & STA_PPSFREQ) != 0
 370                 && (time_status & (STA_PPSWANDER|STA_PPSERROR)) != 0))
 371             /* p. 24, (d) */
 372                 result = TIME_ERROR;
 373
 374         if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT)
 375             txc->offset    = save_adjust;
 376         else {
 377             txc->offset = shift_right(time_offset, SHIFT_UPDATE);
 378         }
 379         txc->freq          = time_freq + pps_freq;
 380         txc->maxerror      = time_maxerror;
 381         txc->esterror      = time_esterror;
 382         txc->status        = time_status;
 383         txc->constant      = time_constant;
 384         txc->precision     = time_precision;
 385         txc->tolerance     = time_tolerance;
 386         txc->tick          = tick_usec;
 387         txc->ppsfreq       = pps_freq;
 388         txc->jitter        = pps_jitter >> PPS_AVG;
 389         txc->shift         = pps_shift;
 390         txc->stabil        = pps_stabil;
 391         txc->jitcnt        = pps_jitcnt;
 392         txc->calcnt        = pps_calcnt;
 393         txc->errcnt        = pps_errcnt;
 394         txc->stbcnt        = pps_stbcnt;
 395         write_sequnlock_irq(&xtime_lock);
 396         do_gettimeofday(&txc->time);
 397         notify_arch_cmos_timer();
 398         return(result);
 399 }
 400
 401 asmlinkage long sys_adjtimex(struct timex __user *txc_p)
 402 {
 403         struct timex txc;               /* Local copy of parameter */
 404         int ret;
 405
 406         /* Copy the user data space into the kernel copy
 407          * structure. But bear in mind that the structures
 408          * may change
 409          */
 410         if(copy_from_user(&txc, txc_p, sizeof(struct timex)))
 411                 return -EFAULT;
 412         ret = do_adjtimex(&txc);
 413         return copy_to_user(txc_p, &txc, sizeof(struct timex)) ? -EFAULT : ret;
 414 }
 415
 416 inline struct timespec current_kernel_time(void)
 417 {
 418         struct timespec now;
 419         unsigned long seq;
 420
 421         do {
 422                 seq = read_seqbegin(&xtime_lock);
 423
 424                 now = xtime;
 425         } while (read_seqretry(&xtime_lock, seq));
 426
 427         return now;
 428 }
 429
 430 EXPORT_SYMBOL(current_kernel_time);
 431
 432 /**
 433  * current_fs_time - Return FS time
 434  * @sb: Superblock.
 435  *
 436  * Return the current time truncated to the time granuality supported by
 437  * the fs.
 438  */
 439 struct timespec current_fs_time(struct super_block *sb)
 440 {
 441         struct timespec now = current_kernel_time();
 442         return timespec_trunc(now, sb->s_time_gran);
 443 }
 444 EXPORT_SYMBOL(current_fs_time);
 445
 446 /**
 447  * timespec_trunc - Truncate timespec to a granuality
 448  * @t: Timespec
 449  * @gran: Granuality in ns.
 450  *
 451  * Truncate a timespec to a granuality. gran must be smaller than a second.
 452  * Always rounds down.
 453  *
 454  * This function should be only used for timestamps returned by
 455  * current_kernel_time() or CURRENT_TIME, not with do_gettimeofday() because
 456  * it doesn't handle the better resolution of the later.
 457  */
 458 struct timespec timespec_trunc(struct timespec t, unsigned gran)
 459 {
 460         /*
 461          * Division is pretty slow so avoid it for common cases.
 462          * Currently current_kernel_time() never returns better than
 463          * jiffies resolution. Exploit that.
 464          */
 465         if (gran <= jiffies_to_usecs(1) * 1000) {
 466                 /* nothing */
 467         } else if (gran == 1000000000) {
 468                 t.tv_nsec = 0;
 469         } else {
 470                 t.tv_nsec -= t.tv_nsec % gran;
 471         }
 472         return t;
 473 }
 474 EXPORT_SYMBOL(timespec_trunc);
 475
 476 #ifdef CONFIG_TIME_INTERPOLATION
 477 void getnstimeofday (struct timespec *tv)
 478 {
 479         unsigned long seq,sec,nsec;
 480
 481         do {
 482                 seq = read_seqbegin(&xtime_lock);
 483                 sec = xtime.tv_sec;
 484                 nsec = xtime.tv_nsec+time_interpolator_get_offset();
 485         } while (unlikely(read_seqretry(&xtime_lock, seq)));
 486
 487         while (unlikely(nsec >= NSEC_PER_SEC)) {
 488                 nsec -= NSEC_PER_SEC;
 489                 ++sec;
 490         }
 491         tv->tv_sec = sec;
 492         tv->tv_nsec = nsec;
 493 }
 494 EXPORT_SYMBOL_GPL(getnstimeofday);
 495
 496 int do_settimeofday (struct timespec *tv)
 497 {
 498         time_t wtm_sec, sec = tv->tv_sec;
 499         long wtm_nsec, nsec = tv->tv_nsec;
 500
 501         if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
 502                 return -EINVAL;
 503
 504         write_seqlock_irq(&xtime_lock);
 505         {
 506                 wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
 507                 wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
 508
 509                 set_normalized_timespec(&xtime, sec, nsec);
 510                 set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
 511
 512                 time_adjust = 0;                /* stop active adjtime() */
 513                 time_status |= STA_UNSYNC;
 514                 time_maxerror = NTP_PHASE_LIMIT;
 515                 time_esterror = NTP_PHASE_LIMIT;
 516                 time_interpolator_reset();
 517         }
 518         write_sequnlock_irq(&xtime_lock);
 519         clock_was_set();
 520         return 0;
 521 }
 522 EXPORT_SYMBOL(do_settimeofday);
 523
 524 void do_gettimeofday (struct timeval *tv)
 525 {
 526         unsigned long seq, nsec, usec, sec, offset;
 527         do {
 528                 seq = read_seqbegin(&xtime_lock);
 529                 offset = time_interpolator_get_offset();
 530                 sec = xtime.tv_sec;
 531                 nsec = xtime.tv_nsec;
 532         } while (unlikely(read_seqretry(&xtime_lock, seq)));
 533
 534         usec = (nsec + offset) / 1000;
 535
 536         while (unlikely(usec >= USEC_PER_SEC)) {
 537                 usec -= USEC_PER_SEC;
 538                 ++sec;
 539         }
 540
 541         tv->tv_sec = sec;
 542         tv->tv_usec = usec;
 543 }
 544
 545 EXPORT_SYMBOL(do_gettimeofday);
 546
 547
 548 #else
 549 /*
 550  * Simulate gettimeofday using do_gettimeofday which only allows a timeval
 551  * and therefore only yields usec accuracy
 552  */
 553 void getnstimeofday(struct timespec *tv)
 554 {
 555         struct timeval x;
 556
 557         do_gettimeofday(&x);
 558         tv->tv_sec = x.tv_sec;
 559         tv->tv_nsec = x.tv_usec * NSEC_PER_USEC;
 560 }
 561 EXPORT_SYMBOL_GPL(getnstimeofday);
 562 #endif
 563
 564 void getnstimestamp(struct timespec *ts)
 565 {
 566         unsigned int seq;
 567         struct timespec wall2mono;
 568
 569         /* synchronize with settimeofday() changes */
 570         do {
 571                 seq = read_seqbegin(&xtime_lock);
 572                 getnstimeofday(ts);
 573                 wall2mono = wall_to_monotonic;
 574         } while(unlikely(read_seqretry(&xtime_lock, seq)));
 575
 576         /* adjust to monotonicaly-increasing values */
 577         ts->tv_sec += wall2mono.tv_sec;
 578         ts->tv_nsec += wall2mono.tv_nsec;
 579         while (unlikely(ts->tv_nsec >= NSEC_PER_SEC)) {
 580                 ts->tv_nsec -= NSEC_PER_SEC;
 581                 ts->tv_sec++;
 582         }
 583 }
 584 EXPORT_SYMBOL_GPL(getnstimestamp);
 585
 586 /* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
 587  * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
 588  * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
 589  *
 590  * [For the Julian calendar (which was used in Russia before 1917,
 591  * Britain & colonies before 1752, anywhere else before 1582,
 592  * and is still in use by some communities) leave out the
 593  * -year/100+year/400 terms, and add 10.]
 594  *
 595  * This algorithm was first published by Gauss (I think).
 596  *
 597  * WARNING: this function will overflow on 2106-02-07 06:28:16 on
 598  * machines were long is 32-bit! (However, as time_t is signed, we
 599  * will already get problems at other places on 2038-01-19 03:14:08)
 600  */
 601 unsigned long
 602 mktime(const unsigned int year0, const unsigned int mon0,
 603        const unsigned int day, const unsigned int hour,
 604        const unsigned int min, const unsigned int sec)
 605 {
 606         unsigned int mon = mon0, year = year0;
 607
 608         /* 1..12 -> 11,12,1..10 */
 609         if (0 >= (int) (mon -= 2)) {
 610                 mon += 12;      /* Puts Feb last since it has leap day */
 611                 year -= 1;
 612         }
 613
 614         return ((((unsigned long)
 615                   (year/4 - year/100 + year/400 + 367*mon/12 + day) +
 616                   year*365 - 719499
 617             )*24 + hour /* now have hours */
 618           )*60 + min /* now have minutes */
 619         )*60 + sec; /* finally seconds */
 620 }
 621
 622 EXPORT_SYMBOL(mktime);
 623
 624 /**
 625  * set_normalized_timespec - set timespec sec and nsec parts and normalize
 626  *
 627  * @ts:         pointer to timespec variable to be set
 628  * @sec:        seconds to set
 629  * @nsec:       nanoseconds to set
 630  *
 631  * Set seconds and nanoseconds field of a timespec variable and
 632  * normalize to the timespec storage format
 633  *
 634  * Note: The tv_nsec part is always in the range of
 635  *      0 <= tv_nsec < NSEC_PER_SEC
 636  * For negative values only the tv_sec field is negative !
 637  */
 638 void set_normalized_timespec(struct timespec *ts, time_t sec, long nsec)
 639 {
 640         while (nsec >= NSEC_PER_SEC) {
 641                 nsec -= NSEC_PER_SEC;
 642                 ++sec;
 643         }
 644         while (nsec < 0) {
 645                 nsec += NSEC_PER_SEC;
 646                 --sec;
 647         }
 648         ts->tv_sec = sec;
 649         ts->tv_nsec = nsec;
 650 }
 651
 652 #if (BITS_PER_LONG < 64)
 653 u64 get_jiffies_64(void)
 654 {
 655         unsigned long seq;
 656         u64 ret;
 657
 658         do {
 659                 seq = read_seqbegin(&xtime_lock);
 660                 ret = jiffies_64;
 661         } while (read_seqretry(&xtime_lock, seq));
 662         return ret;
 663 }
 664
 665 EXPORT_SYMBOL(get_jiffies_64);
 666 #endif
 667
 668 EXPORT_SYMBOL(jiffies);