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