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
  37 #include <asm/uaccess.h>
  38 #include <asm/unistd.h>
  39
  40 /*
  41  * The timezone where the local system is located.  Used as a default by some
  42  * programs who obtain this value by using gettimeofday.
  43  */
  44 struct timezone sys_tz;
  45
  46 EXPORT_SYMBOL(sys_tz);
  47
  48 #ifdef __ARCH_WANT_SYS_TIME
  49
  50 /*
  51  * sys_time() can be implemented in user-level using
  52  * sys_gettimeofday().  Is this for backwards compatibility?  If so,
  53  * why not move it into the appropriate arch directory (for those
  54  * architectures that need it).
  55  *
  56  * XXX This function is NOT 64-bit clean!
  57  */
  58 asmlinkage long sys_time(int __user * tloc)
  59 {
  60         int 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 inline static 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 /* adjtimex mainly allows reading (and writing, if superuser) of
 220  * kernel time-keeping variables. used by xntpd.
 221  */
 222 int do_adjtimex(struct timex *txc)
 223 {
 224         long ltemp, mtemp, save_adjust;
 225         int result;
 226
 227         /* In order to modify anything, you gotta be super-user! */
 228         if (txc->modes && !capable(CAP_SYS_TIME))
 229                 return -EPERM;
 230
 231         /* Now we validate the data before disabling interrupts */
 232
 233         if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT)
 234           /* singleshot must not be used with any other mode bits */
 235                 if (txc->modes != ADJ_OFFSET_SINGLESHOT)
 236                         return -EINVAL;
 237
 238         if (txc->modes != ADJ_OFFSET_SINGLESHOT && (txc->modes & ADJ_OFFSET))
 239           /* adjustment Offset limited to +- .512 seconds */
 240                 if (txc->offset <= - MAXPHASE || txc->offset >= MAXPHASE )
 241                         return -EINVAL;
 242
 243         /* if the quartz is off by more than 10% something is VERY wrong ! */
 244         if (txc->modes & ADJ_TICK)
 245                 if (txc->tick <  900000/USER_HZ ||
 246                     txc->tick > 1100000/USER_HZ)
 247                         return -EINVAL;
 248
 249         write_seqlock_irq(&xtime_lock);
 250         result = time_state;    /* mostly `TIME_OK' */
 251
 252         /* Save for later - semantics of adjtime is to return old value */
 253         save_adjust = time_next_adjust ? time_next_adjust : time_adjust;
 254
 255 #if 0   /* STA_CLOCKERR is never set yet */
 256         time_status &= ~STA_CLOCKERR;           /* reset STA_CLOCKERR */
 257 #endif
 258         /* If there are input parameters, then process them */
 259         if (txc->modes)
 260         {
 261             if (txc->modes & ADJ_STATUS)        /* only set allowed bits */
 262                 time_status =  (txc->status & ~STA_RONLY) |
 263                               (time_status & STA_RONLY);
 264
 265             if (txc->modes & ADJ_FREQUENCY) {   /* p. 22 */
 266                 if (txc->freq > MAXFREQ || txc->freq < -MAXFREQ) {
 267                     result = -EINVAL;
 268                     goto leave;
 269                 }
 270                 time_freq = txc->freq - pps_freq;
 271             }
 272
 273             if (txc->modes & ADJ_MAXERROR) {
 274                 if (txc->maxerror < 0 || txc->maxerror >= NTP_PHASE_LIMIT) {
 275                     result = -EINVAL;
 276                     goto leave;
 277                 }
 278                 time_maxerror = txc->maxerror;
 279             }
 280
 281             if (txc->modes & ADJ_ESTERROR) {
 282                 if (txc->esterror < 0 || txc->esterror >= NTP_PHASE_LIMIT) {
 283                     result = -EINVAL;
 284                     goto leave;
 285                 }
 286                 time_esterror = txc->esterror;
 287             }
 288
 289             if (txc->modes & ADJ_TIMECONST) {   /* p. 24 */
 290                 if (txc->constant < 0) {        /* NTP v4 uses values > 6 */
 291                     result = -EINVAL;
 292                     goto leave;
 293                 }
 294                 time_constant = txc->constant;
 295             }
 296
 297             if (txc->modes & ADJ_OFFSET) {      /* values checked earlier */
 298                 if (txc->modes == ADJ_OFFSET_SINGLESHOT) {
 299                     /* adjtime() is independent from ntp_adjtime() */
 300                     if ((time_next_adjust = txc->offset) == 0)
 301                          time_adjust = 0;
 302                 }
 303                 else if ( time_status & (STA_PLL | STA_PPSTIME) ) {
 304                     ltemp = (time_status & (STA_PPSTIME | STA_PPSSIGNAL)) ==
 305                             (STA_PPSTIME | STA_PPSSIGNAL) ?
 306                             pps_offset : txc->offset;
 307
 308                     /*
 309                      * Scale the phase adjustment and
 310                      * clamp to the operating range.
 311                      */
 312                     if (ltemp > MAXPHASE)
 313                         time_offset = MAXPHASE << SHIFT_UPDATE;
 314                     else if (ltemp < -MAXPHASE)
 315                         time_offset = -(MAXPHASE << SHIFT_UPDATE);
 316                     else
 317                         time_offset = ltemp << SHIFT_UPDATE;
 318
 319                     /*
 320                      * Select whether the frequency is to be controlled
 321                      * and in which mode (PLL or FLL). Clamp to the operating
 322                      * range. Ugly multiply/divide should be replaced someday.
 323                      */
 324
 325                     if (time_status & STA_FREQHOLD || time_reftime == 0)
 326                         time_reftime = xtime.tv_sec;
 327                     mtemp = xtime.tv_sec - time_reftime;
 328                     time_reftime = xtime.tv_sec;
 329                     if (time_status & STA_FLL) {
 330                         if (mtemp >= MINSEC) {
 331                             ltemp = (time_offset / mtemp) << (SHIFT_USEC -
 332                                                               SHIFT_UPDATE);
 333                             if (ltemp < 0)
 334                                 time_freq -= -ltemp >> SHIFT_KH;
 335                             else
 336                                 time_freq += ltemp >> SHIFT_KH;
 337                         } else /* calibration interval too short (p. 12) */
 338                                 result = TIME_ERROR;
 339                     } else {    /* PLL mode */
 340                         if (mtemp < MAXSEC) {
 341                             ltemp *= mtemp;
 342                             if (ltemp < 0)
 343                                 time_freq -= -ltemp >> (time_constant +
 344                                                         time_constant +
 345                                                         SHIFT_KF - SHIFT_USEC);
 346                             else
 347                                 time_freq += 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                     if (time_freq > time_tolerance)
 354                         time_freq = time_tolerance;
 355                     else if (time_freq < -time_tolerance)
 356                         time_freq = -time_tolerance;
 357                 } /* STA_PLL || STA_PPSTIME */
 358             } /* txc->modes & ADJ_OFFSET */
 359             if (txc->modes & ADJ_TICK) {
 360                 tick_usec = txc->tick;
 361                 tick_nsec = TICK_USEC_TO_NSEC(tick_usec);
 362             }
 363         } /* txc->modes */
 364 leave:  if ((time_status & (STA_UNSYNC|STA_CLOCKERR)) != 0
 365             || ((time_status & (STA_PPSFREQ|STA_PPSTIME)) != 0
 366                 && (time_status & STA_PPSSIGNAL) == 0)
 367             /* p. 24, (b) */
 368             || ((time_status & (STA_PPSTIME|STA_PPSJITTER))
 369                 == (STA_PPSTIME|STA_PPSJITTER))
 370             /* p. 24, (c) */
 371             || ((time_status & STA_PPSFREQ) != 0
 372                 && (time_status & (STA_PPSWANDER|STA_PPSERROR)) != 0))
 373             /* p. 24, (d) */
 374                 result = TIME_ERROR;
 375
 376         if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT)
 377             txc->offset    = save_adjust;
 378         else {
 379             if (time_offset < 0)
 380                 txc->offset = -(-time_offset >> SHIFT_UPDATE);
 381             else
 382                 txc->offset = time_offset >> SHIFT_UPDATE;
 383         }
 384         txc->freq          = time_freq + pps_freq;
 385         txc->maxerror      = time_maxerror;
 386         txc->esterror      = time_esterror;
 387         txc->status        = time_status;
 388         txc->constant      = time_constant;
 389         txc->precision     = time_precision;
 390         txc->tolerance     = time_tolerance;
 391         txc->tick          = tick_usec;
 392         txc->ppsfreq       = pps_freq;
 393         txc->jitter        = pps_jitter >> PPS_AVG;
 394         txc->shift         = pps_shift;
 395         txc->stabil        = pps_stabil;
 396         txc->jitcnt        = pps_jitcnt;
 397         txc->calcnt        = pps_calcnt;
 398         txc->errcnt        = pps_errcnt;
 399         txc->stbcnt        = pps_stbcnt;
 400         write_sequnlock_irq(&xtime_lock);
 401         do_gettimeofday(&txc->time);
 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 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 #ifdef CONFIG_TIME_INTERPOLATION
 437 void getnstimeofday (struct timespec *tv)
 438 {
 439         unsigned long seq,sec,nsec;
 440
 441         do {
 442                 seq = read_seqbegin(&xtime_lock);
 443                 sec = xtime.tv_sec;
 444                 nsec = xtime.tv_nsec+time_interpolator_get_offset();
 445         } while (unlikely(read_seqretry(&xtime_lock, seq)));
 446
 447         while (unlikely(nsec >= NSEC_PER_SEC)) {
 448                 nsec -= NSEC_PER_SEC;
 449                 ++sec;
 450         }
 451         tv->tv_sec = sec;
 452         tv->tv_nsec = nsec;
 453 }
 454
 455 int do_settimeofday (struct timespec *tv)
 456 {
 457         time_t wtm_sec, sec = tv->tv_sec;
 458         long wtm_nsec, nsec = tv->tv_nsec;
 459
 460         if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
 461                 return -EINVAL;
 462
 463         write_seqlock_irq(&xtime_lock);
 464         {
 465                 /*
 466                  * This is revolting. We need to set "xtime" correctly. However, the value
 467                  * in this location is the value at the most recent update of wall time.
 468                  * Discover what correction gettimeofday would have done, and then undo
 469                  * it!
 470                  */
 471                 nsec -= time_interpolator_get_offset();
 472
 473                 wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
 474                 wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
 475
 476                 set_normalized_timespec(&xtime, sec, nsec);
 477                 set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
 478
 479                 time_adjust = 0;                /* stop active adjtime() */
 480                 time_status |= STA_UNSYNC;
 481                 time_maxerror = NTP_PHASE_LIMIT;
 482                 time_esterror = NTP_PHASE_LIMIT;
 483                 time_interpolator_reset();
 484         }
 485         write_sequnlock_irq(&xtime_lock);
 486         clock_was_set();
 487         return 0;
 488 }
 489
 490 void do_gettimeofday (struct timeval *tv)
 491 {
 492         unsigned long seq, nsec, usec, sec, offset;
 493         do {
 494                 seq = read_seqbegin(&xtime_lock);
 495                 offset = time_interpolator_get_offset();
 496                 sec = xtime.tv_sec;
 497                 nsec = xtime.tv_nsec;
 498         } while (unlikely(read_seqretry(&xtime_lock, seq)));
 499
 500         usec = (nsec + offset) / 1000;
 501
 502         while (unlikely(usec >= USEC_PER_SEC)) {
 503                 usec -= USEC_PER_SEC;
 504                 ++sec;
 505         }
 506
 507         tv->tv_sec = sec;
 508         tv->tv_usec = usec;
 509 }
 510
 511 EXPORT_SYMBOL(do_gettimeofday);
 512
 513
 514 #else
 515 /*
 516  * Simulate gettimeofday using do_gettimeofday which only allows a timeval
 517  * and therefore only yields usec accuracy
 518  */
 519 void getnstimeofday(struct timespec *tv)
 520 {
 521         struct timeval x;
 522
 523         do_gettimeofday(&x);
 524         tv->tv_sec = x.tv_sec;
 525         tv->tv_nsec = x.tv_usec * NSEC_PER_USEC;
 526 }
 527 #endif
 528
 529 #if (BITS_PER_LONG < 64)
 530 u64 get_jiffies_64(void)
 531 {
 532         unsigned long seq;
 533         u64 ret;
 534
 535         do {
 536                 seq = read_seqbegin(&xtime_lock);
 537                 ret = jiffies_64;
 538         } while (read_seqretry(&xtime_lock, seq));
 539         return ret;
 540 }
 541
 542 EXPORT_SYMBOL(get_jiffies_64);
 543 #endif
 544
 545 EXPORT_SYMBOL(jiffies);