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