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
  38 #include <asm/uaccess.h>
  39 #include <asm/unistd.h>
  40
  41 /*
  42  * The timezone where the local system is located.  Used as a default by some
  43  * programs who obtain this value by using gettimeofday.
  44  */
  45 struct timezone sys_tz;
  46
  47 EXPORT_SYMBOL(sys_tz);
  48
  49 #ifdef __ARCH_WANT_SYS_TIME
  50
  51 /*
  52  * sys_time() can be implemented in user-level using
  53  * sys_gettimeofday().  Is this for backwards compatibility?  If so,
  54  * why not move it into the appropriate arch directory (for those
  55  * architectures that need it).
  56  */
  57 asmlinkage long sys_time(time_t __user * tloc)
  58 {
  59         time_t i;
  60         struct timeval tv;
  61
  62         do_gettimeofday(&tv);
  63         i = tv.tv_sec;
  64
  65         if (tloc) {
  66                 if (put_user(i,tloc))
  67                         i = -EFAULT;
  68         }
  69         return i;
  70 }
  71
  72 /*
  73  * sys_stime() can be implemented in user-level using
  74  * sys_settimeofday().  Is this for backwards compatibility?  If so,
  75  * why not move it into the appropriate arch directory (for those
  76  * architectures that need it).
  77  */
  78
  79 asmlinkage long sys_stime(time_t __user *tptr)
  80 {
  81         struct timespec tv;
  82         int err;
  83
  84         if (get_user(tv.tv_sec, tptr))
  85                 return -EFAULT;
  86
  87         tv.tv_nsec = 0;
  88
  89         err = security_settime(&tv, NULL);
  90         if (err)
  91                 return err;
  92
  93         do_settimeofday(&tv);
  94         return 0;
  95 }
  96
  97 #endif /* __ARCH_WANT_SYS_TIME */
  98
  99 asmlinkage long sys_gettimeofday(struct timeval __user *tv, struct timezone __user *tz)
 100 {
 101         if (likely(tv != NULL)) {
 102                 struct timeval ktv;
 103                 do_gettimeofday(&ktv);
 104                 if (copy_to_user(tv, &ktv, sizeof(ktv)))
 105                         return -EFAULT;
 106         }
 107         if (unlikely(tz != NULL)) {
 108                 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
 109                         return -EFAULT;
 110         }
 111         return 0;
 112 }
 113
 114 /*
 115  * Adjust the time obtained from the CMOS to be UTC time instead of
 116  * local time.
 117  *
 118  * This is ugly, but preferable to the alternatives.  Otherwise we
 119  * would either need to write a program to do it in /etc/rc (and risk
 120  * confusion if the program gets run more than once; it would also be
 121  * hard to make the program warp the clock precisely n hours)  or
 122  * compile in the timezone information into the kernel.  Bad, bad....
 123  *
 124  *                                              - TYT, 1992-01-01
 125  *
 126  * The best thing to do is to keep the CMOS clock in universal time (UTC)
 127  * as real UNIX machines always do it. This avoids all headaches about
 128  * daylight saving times and warping kernel clocks.
 129  */
 130 inline static void warp_clock(void)
 131 {
 132         write_seqlock_irq(&xtime_lock);
 133         wall_to_monotonic.tv_sec -= sys_tz.tz_minuteswest * 60;
 134         xtime.tv_sec += sys_tz.tz_minuteswest * 60;
 135         time_interpolator_reset();
 136         write_sequnlock_irq(&xtime_lock);
 137         clock_was_set();
 138 }
 139
 140 /*
 141  * In case for some reason the CMOS clock has not already been running
 142  * in UTC, but in some local time: The first time we set the timezone,
 143  * we will warp the clock so that it is ticking UTC time instead of
 144  * local time. Presumably, if someone is setting the timezone then we
 145  * are running in an environment where the programs understand about
 146  * timezones. This should be done at boot time in the /etc/rc script,
 147  * as soon as possible, so that the clock can be set right. Otherwise,
 148  * various programs will get confused when the clock gets warped.
 149  */
 150
 151 int do_sys_settimeofday(struct timespec *tv, struct timezone *tz)
 152 {
 153         static int firsttime = 1;
 154         int error = 0;
 155
 156         error = security_settime(tv, tz);
 157         if (error)
 158                 return error;
 159
 160         if (tz) {
 161                 /* SMP safe, global irq locking makes it work. */
 162                 sys_tz = *tz;
 163                 if (firsttime) {
 164                         firsttime = 0;
 165                         if (!tv)
 166                                 warp_clock();
 167                 }
 168         }
 169         if (tv)
 170         {
 171                 /* SMP safe, again the code in arch/foo/time.c should
 172                  * globally block out interrupts when it runs.
 173                  */
 174                 return do_settimeofday(tv);
 175         }
 176         return 0;
 177 }
 178
 179 asmlinkage long sys_settimeofday(struct timeval __user *tv,
 180                                 struct timezone __user *tz)
 181 {
 182         struct timeval user_tv;
 183         struct timespec new_ts;
 184         struct timezone new_tz;
 185
 186         if (tv) {
 187                 if (copy_from_user(&user_tv, tv, sizeof(*tv)))
 188                         return -EFAULT;
 189                 new_ts.tv_sec = user_tv.tv_sec;
 190                 new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC;
 191         }
 192         if (tz) {
 193                 if (copy_from_user(&new_tz, tz, sizeof(*tz)))
 194                         return -EFAULT;
 195         }
 196
 197         return do_sys_settimeofday(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
 198 }
 199
 200 long pps_offset;                /* pps time offset (us) */
 201 long pps_jitter = MAXTIME;      /* time dispersion (jitter) (us) */
 202
 203 long pps_freq;                  /* frequency offset (scaled ppm) */
 204 long pps_stabil = MAXFREQ;      /* frequency dispersion (scaled ppm) */
 205
 206 long pps_valid = PPS_VALID;     /* pps signal watchdog counter */
 207
 208 int pps_shift = PPS_SHIFT;      /* interval duration (s) (shift) */
 209
 210 long pps_jitcnt;                /* jitter limit exceeded */
 211 long pps_calcnt;                /* calibration intervals */
 212 long pps_errcnt;                /* calibration errors */
 213 long pps_stbcnt;                /* stability limit exceeded */
 214
 215 /* hook for a loadable hardpps kernel module */
 216 void (*hardpps_ptr)(struct timeval *);
 217
 218 /* adjtimex mainly allows reading (and writing, if superuser) of
 219  * kernel time-keeping variables. used by xntpd.
 220  */
 221 int do_adjtimex(struct timex *txc)
 222 {
 223         long ltemp, mtemp, save_adjust;
 224         int result;
 225
 226         /* In order to modify anything, you gotta be super-user! */
 227         if (txc->modes && !capable(CAP_SYS_TIME))
 228                 return -EPERM;
 229
 230         /* Now we validate the data before disabling interrupts */
 231
 232         if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT)
 233           /* singleshot must not be used with any other mode bits */
 234                 if (txc->modes != ADJ_OFFSET_SINGLESHOT)
 235                         return -EINVAL;
 236
 237         if (txc->modes != ADJ_OFFSET_SINGLESHOT && (txc->modes & ADJ_OFFSET))
 238           /* adjustment Offset limited to +- .512 seconds */
 239                 if (txc->offset <= - MAXPHASE || txc->offset >= MAXPHASE )
 240                         return -EINVAL;
 241
 242         /* if the quartz is off by more than 10% something is VERY wrong ! */
 243         if (txc->modes & ADJ_TICK)
 244                 if (txc->tick <  900000/USER_HZ ||
 245                     txc->tick > 1100000/USER_HZ)
 246                         return -EINVAL;
 247
 248         write_seqlock_irq(&xtime_lock);
 249         result = time_state;    /* mostly `TIME_OK' */
 250
 251         /* Save for later - semantics of adjtime is to return old value */
 252         save_adjust = time_next_adjust ? time_next_adjust : time_adjust;
 253
 254 #if 0   /* STA_CLOCKERR is never set yet */
 255         time_status &= ~STA_CLOCKERR;           /* reset STA_CLOCKERR */
 256 #endif
 257         /* If there are input parameters, then process them */
 258         if (txc->modes)
 259         {
 260             if (txc->modes & ADJ_STATUS)        /* only set allowed bits */
 261                 time_status =  (txc->status & ~STA_RONLY) |
 262                               (time_status & STA_RONLY);
 263
 264             if (txc->modes & ADJ_FREQUENCY) {   /* p. 22 */
 265                 if (txc->freq > MAXFREQ || txc->freq < -MAXFREQ) {
 266                     result = -EINVAL;
 267                     goto leave;
 268                 }
 269                 time_freq = txc->freq - pps_freq;
 270             }
 271
 272             if (txc->modes & ADJ_MAXERROR) {
 273                 if (txc->maxerror < 0 || txc->maxerror >= NTP_PHASE_LIMIT) {
 274                     result = -EINVAL;
 275                     goto leave;
 276                 }
 277                 time_maxerror = txc->maxerror;
 278             }
 279
 280             if (txc->modes & ADJ_ESTERROR) {
 281                 if (txc->esterror < 0 || txc->esterror >= NTP_PHASE_LIMIT) {
 282                     result = -EINVAL;
 283                     goto leave;
 284                 }
 285                 time_esterror = txc->esterror;
 286             }
 287
 288             if (txc->modes & ADJ_TIMECONST) {   /* p. 24 */
 289                 if (txc->constant < 0) {        /* NTP v4 uses values > 6 */
 290                     result = -EINVAL;
 291                     goto leave;
 292                 }
 293                 time_constant = txc->constant;
 294             }
 295
 296             if (txc->modes & ADJ_OFFSET) {      /* values checked earlier */
 297                 if (txc->modes == ADJ_OFFSET_SINGLESHOT) {
 298                     /* adjtime() is independent from ntp_adjtime() */
 299                     if ((time_next_adjust = txc->offset) == 0)
 300                          time_adjust = 0;
 301                 }
 302                 else if ( time_status & (STA_PLL | STA_PPSTIME) ) {
 303                     ltemp = (time_status & (STA_PPSTIME | STA_PPSSIGNAL)) ==
 304                             (STA_PPSTIME | STA_PPSSIGNAL) ?
 305                             pps_offset : txc->offset;
 306
 307                     /*
 308                      * Scale the phase adjustment and
 309                      * clamp to the operating range.
 310                      */
 311                     if (ltemp > MAXPHASE)
 312                         time_offset = MAXPHASE << SHIFT_UPDATE;
 313                     else if (ltemp < -MAXPHASE)
 314                         time_offset = -(MAXPHASE << SHIFT_UPDATE);
 315                     else
 316                         time_offset = ltemp << SHIFT_UPDATE;
 317
 318                     /*
 319                      * Select whether the frequency is to be controlled
 320                      * and in which mode (PLL or FLL). Clamp to the operating
 321                      * range. Ugly multiply/divide should be replaced someday.
 322                      */
 323
 324                     if (time_status & STA_FREQHOLD || time_reftime == 0)
 325                         time_reftime = xtime.tv_sec;
 326                     mtemp = xtime.tv_sec - time_reftime;
 327                     time_reftime = xtime.tv_sec;
 328                     if (time_status & STA_FLL) {
 329                         if (mtemp >= MINSEC) {
 330                             ltemp = (time_offset / mtemp) << (SHIFT_USEC -
 331                                                               SHIFT_UPDATE);
 332                             if (ltemp < 0)
 333                                 time_freq -= -ltemp >> SHIFT_KH;
 334                             else
 335                                 time_freq += ltemp >> SHIFT_KH;
 336                         } else /* calibration interval too short (p. 12) */
 337                                 result = TIME_ERROR;
 338                     } else {    /* PLL mode */
 339                         if (mtemp < MAXSEC) {
 340                             ltemp *= mtemp;
 341                             if (ltemp < 0)
 342                                 time_freq -= -ltemp >> (time_constant +
 343                                                         time_constant +
 344                                                         SHIFT_KF - SHIFT_USEC);
 345                             else
 346                                 time_freq += ltemp >> (time_constant +
 347                                                        time_constant +
 348                                                        SHIFT_KF - SHIFT_USEC);
 349                         } else /* calibration interval too long (p. 12) */
 350                                 result = TIME_ERROR;
 351                     }
 352                     if (time_freq > time_tolerance)
 353                         time_freq = time_tolerance;
 354                     else if (time_freq < -time_tolerance)
 355                         time_freq = -time_tolerance;
 356                 } /* STA_PLL || STA_PPSTIME */
 357             } /* txc->modes & ADJ_OFFSET */
 358             if (txc->modes & ADJ_TICK) {
 359                 tick_usec = txc->tick;
 360                 tick_nsec = TICK_USEC_TO_NSEC(tick_usec);
 361             }
 362         } /* txc->modes */
 363 leave:  if ((time_status & (STA_UNSYNC|STA_CLOCKERR)) != 0
 364             || ((time_status & (STA_PPSFREQ|STA_PPSTIME)) != 0
 365                 && (time_status & STA_PPSSIGNAL) == 0)
 366             /* p. 24, (b) */
 367             || ((time_status & (STA_PPSTIME|STA_PPSJITTER))
 368                 == (STA_PPSTIME|STA_PPSJITTER))
 369             /* p. 24, (c) */
 370             || ((time_status & STA_PPSFREQ) != 0
 371                 && (time_status & (STA_PPSWANDER|STA_PPSERROR)) != 0))
 372             /* p. 24, (d) */
 373                 result = TIME_ERROR;
 374
 375         if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT)
 376             txc->offset    = save_adjust;
 377         else {
 378             if (time_offset < 0)
 379                 txc->offset = -(-time_offset >> SHIFT_UPDATE);
 380             else
 381                 txc->offset = 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         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
 498 int do_settimeofday (struct timespec *tv)
 499 {
 500         time_t wtm_sec, sec = tv->tv_sec;
 501         long wtm_nsec, nsec = tv->tv_nsec;
 502
 503         if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
 504                 return -EINVAL;
 505
 506         write_seqlock_irq(&xtime_lock);
 507         {
 508                 /*
 509                  * This is revolting. We need to set "xtime" correctly. However, the value
 510                  * in this location is the value at the most recent update of wall time.
 511                  * Discover what correction gettimeofday would have done, and then undo
 512                  * it!
 513                  */
 514                 nsec -= time_interpolator_get_offset();
 515
 516                 wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
 517                 wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
 518
 519                 set_normalized_timespec(&xtime, sec, nsec);
 520                 set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
 521
 522                 time_adjust = 0;                /* stop active adjtime() */
 523                 time_status |= STA_UNSYNC;
 524                 time_maxerror = NTP_PHASE_LIMIT;
 525                 time_esterror = NTP_PHASE_LIMIT;
 526                 time_interpolator_reset();
 527         }
 528         write_sequnlock_irq(&xtime_lock);
 529         clock_was_set();
 530         return 0;
 531 }
 532
 533 void do_gettimeofday (struct timeval *tv)
 534 {
 535         unsigned long seq, nsec, usec, sec, offset;
 536         do {
 537                 seq = read_seqbegin(&xtime_lock);
 538                 offset = time_interpolator_get_offset();
 539                 sec = xtime.tv_sec;
 540                 nsec = xtime.tv_nsec;
 541         } while (unlikely(read_seqretry(&xtime_lock, seq)));
 542
 543         usec = (nsec + offset) / 1000;
 544
 545         while (unlikely(usec >= USEC_PER_SEC)) {
 546                 usec -= USEC_PER_SEC;
 547                 ++sec;
 548         }
 549
 550         tv->tv_sec = sec;
 551         tv->tv_usec = usec;
 552 }
 553
 554 EXPORT_SYMBOL(do_gettimeofday);
 555
 556
 557 #else
 558 /*
 559  * Simulate gettimeofday using do_gettimeofday which only allows a timeval
 560  * and therefore only yields usec accuracy
 561  */
 562 void getnstimeofday(struct timespec *tv)
 563 {
 564         struct timeval x;
 565
 566         do_gettimeofday(&x);
 567         tv->tv_sec = x.tv_sec;
 568         tv->tv_nsec = x.tv_usec * NSEC_PER_USEC;
 569 }
 570 #endif
 571
 572 #if (BITS_PER_LONG < 64)
 573 u64 get_jiffies_64(void)
 574 {
 575         unsigned long seq;
 576         u64 ret;
 577
 578         do {
 579                 seq = read_seqbegin(&xtime_lock);
 580                 ret = jiffies_64;
 581         } while (read_seqretry(&xtime_lock, seq));
 582         return ret;
 583 }
 584
 585 EXPORT_SYMBOL(get_jiffies_64);
 586 #endif
 587
 588 EXPORT_SYMBOL(jiffies);