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 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 /* 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                             if (ltemp < 0)
 342                                 time_freq -= -ltemp >> SHIFT_KH;
 343                             else
 344                                 time_freq += 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                             if (ltemp < 0)
 351                                 time_freq -= -ltemp >> (time_constant +
 352                                                         time_constant +
 353                                                         SHIFT_KF - SHIFT_USEC);
 354                             else
 355                                 time_freq += ltemp >> (time_constant +
 356                                                        time_constant +
 357                                                        SHIFT_KF - SHIFT_USEC);
 358                         } else /* calibration interval too long (p. 12) */
 359                                 result = TIME_ERROR;
 360                     }
 361                     if (time_freq > time_tolerance)
 362                         time_freq = time_tolerance;
 363                     else if (time_freq < -time_tolerance)
 364                         time_freq = -time_tolerance;
 365                 } /* STA_PLL || STA_PPSTIME */
 366             } /* txc->modes & ADJ_OFFSET */
 367             if (txc->modes & ADJ_TICK) {
 368                 tick_usec = txc->tick;
 369                 tick_nsec = TICK_USEC_TO_NSEC(tick_usec);
 370             }
 371         } /* txc->modes */
 372 leave:  if ((time_status & (STA_UNSYNC|STA_CLOCKERR)) != 0
 373             || ((time_status & (STA_PPSFREQ|STA_PPSTIME)) != 0
 374                 && (time_status & STA_PPSSIGNAL) == 0)
 375             /* p. 24, (b) */
 376             || ((time_status & (STA_PPSTIME|STA_PPSJITTER))
 377                 == (STA_PPSTIME|STA_PPSJITTER))
 378             /* p. 24, (c) */
 379             || ((time_status & STA_PPSFREQ) != 0
 380                 && (time_status & (STA_PPSWANDER|STA_PPSERROR)) != 0))
 381             /* p. 24, (d) */
 382                 result = TIME_ERROR;
 383
 384         if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT)
 385             txc->offset    = save_adjust;
 386         else {
 387             if (time_offset < 0)
 388                 txc->offset = -(-time_offset >> SHIFT_UPDATE);
 389             else
 390                 txc->offset = time_offset >> SHIFT_UPDATE;
 391         }
 392         txc->freq          = time_freq + pps_freq;
 393         txc->maxerror      = time_maxerror;
 394         txc->esterror      = time_esterror;
 395         txc->status        = time_status;
 396         txc->constant      = time_constant;
 397         txc->precision     = time_precision;
 398         txc->tolerance     = time_tolerance;
 399         txc->tick          = tick_usec;
 400         txc->ppsfreq       = pps_freq;
 401         txc->jitter        = pps_jitter >> PPS_AVG;
 402         txc->shift         = pps_shift;
 403         txc->stabil        = pps_stabil;
 404         txc->jitcnt        = pps_jitcnt;
 405         txc->calcnt        = pps_calcnt;
 406         txc->errcnt        = pps_errcnt;
 407         txc->stbcnt        = pps_stbcnt;
 408         write_sequnlock_irq(&xtime_lock);
 409         do_gettimeofday(&txc->time);
 410         notify_arch_cmos_timer();
 411         return(result);
 412 }
 413
 414 asmlinkage long sys_adjtimex(struct timex __user *txc_p)
 415 {
 416         struct timex txc;               /* Local copy of parameter */
 417         int ret;
 418
 419         /* Copy the user data space into the kernel copy
 420          * structure. But bear in mind that the structures
 421          * may change
 422          */
 423         if(copy_from_user(&txc, txc_p, sizeof(struct timex)))
 424                 return -EFAULT;
 425         ret = do_adjtimex(&txc);
 426         return copy_to_user(txc_p, &txc, sizeof(struct timex)) ? -EFAULT : ret;
 427 }
 428
 429 inline struct timespec current_kernel_time(void)
 430 {
 431         struct timespec now;
 432         unsigned long seq;
 433
 434         do {
 435                 seq = read_seqbegin(&xtime_lock);
 436
 437                 now = xtime;
 438         } while (read_seqretry(&xtime_lock, seq));
 439
 440         return now;
 441 }
 442
 443 EXPORT_SYMBOL(current_kernel_time);
 444
 445 /**
 446  * current_fs_time - Return FS time
 447  * @sb: Superblock.
 448  *
 449  * Return the current time truncated to the time granuality supported by
 450  * the fs.
 451  */
 452 struct timespec current_fs_time(struct super_block *sb)
 453 {
 454         struct timespec now = current_kernel_time();
 455         return timespec_trunc(now, sb->s_time_gran);
 456 }
 457 EXPORT_SYMBOL(current_fs_time);
 458
 459 /**
 460  * timespec_trunc - Truncate timespec to a granuality
 461  * @t: Timespec
 462  * @gran: Granuality in ns.
 463  *
 464  * Truncate a timespec to a granuality. gran must be smaller than a second.
 465  * Always rounds down.
 466  *
 467  * This function should be only used for timestamps returned by
 468  * current_kernel_time() or CURRENT_TIME, not with do_gettimeofday() because
 469  * it doesn't handle the better resolution of the later.
 470  */
 471 struct timespec timespec_trunc(struct timespec t, unsigned gran)
 472 {
 473         /*
 474          * Division is pretty slow so avoid it for common cases.
 475          * Currently current_kernel_time() never returns better than
 476          * jiffies resolution. Exploit that.
 477          */
 478         if (gran <= jiffies_to_usecs(1) * 1000) {
 479                 /* nothing */
 480         } else if (gran == 1000000000) {
 481                 t.tv_nsec = 0;
 482         } else {
 483                 t.tv_nsec -= t.tv_nsec % gran;
 484         }
 485         return t;
 486 }
 487 EXPORT_SYMBOL(timespec_trunc);
 488
 489 #ifdef CONFIG_TIME_INTERPOLATION
 490 void getnstimeofday (struct timespec *tv)
 491 {
 492         unsigned long seq,sec,nsec;
 493
 494         do {
 495                 seq = read_seqbegin(&xtime_lock);
 496                 sec = xtime.tv_sec;
 497                 nsec = xtime.tv_nsec+time_interpolator_get_offset();
 498         } while (unlikely(read_seqretry(&xtime_lock, seq)));
 499
 500         while (unlikely(nsec >= NSEC_PER_SEC)) {
 501                 nsec -= NSEC_PER_SEC;
 502                 ++sec;
 503         }
 504         tv->tv_sec = sec;
 505         tv->tv_nsec = nsec;
 506 }
 507 EXPORT_SYMBOL_GPL(getnstimeofday);
 508
 509 int do_settimeofday (struct timespec *tv)
 510 {
 511         time_t wtm_sec, sec = tv->tv_sec;
 512         long wtm_nsec, nsec = tv->tv_nsec;
 513
 514         if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
 515                 return -EINVAL;
 516
 517         write_seqlock_irq(&xtime_lock);
 518         {
 519                 wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
 520                 wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
 521
 522                 set_normalized_timespec(&xtime, sec, nsec);
 523                 set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
 524
 525                 time_adjust = 0;                /* stop active adjtime() */
 526                 time_status |= STA_UNSYNC;
 527                 time_maxerror = NTP_PHASE_LIMIT;
 528                 time_esterror = NTP_PHASE_LIMIT;
 529                 time_interpolator_reset();
 530         }
 531         write_sequnlock_irq(&xtime_lock);
 532         clock_was_set();
 533         return 0;
 534 }
 535
 536 void do_gettimeofday (struct timeval *tv)
 537 {
 538         unsigned long seq, nsec, usec, sec, offset;
 539         do {
 540                 seq = read_seqbegin(&xtime_lock);
 541                 offset = time_interpolator_get_offset();
 542                 sec = xtime.tv_sec;
 543                 nsec = xtime.tv_nsec;
 544         } while (unlikely(read_seqretry(&xtime_lock, seq)));
 545
 546         usec = (nsec + offset) / 1000;
 547
 548         while (unlikely(usec >= USEC_PER_SEC)) {
 549                 usec -= USEC_PER_SEC;
 550                 ++sec;
 551         }
 552
 553         tv->tv_sec = sec;
 554         tv->tv_usec = usec;
 555 }
 556
 557 EXPORT_SYMBOL(do_gettimeofday);
 558
 559
 560 #else
 561 /*
 562  * Simulate gettimeofday using do_gettimeofday which only allows a timeval
 563  * and therefore only yields usec accuracy
 564  */
 565 void getnstimeofday(struct timespec *tv)
 566 {
 567         struct timeval x;
 568
 569         do_gettimeofday(&x);
 570         tv->tv_sec = x.tv_sec;
 571         tv->tv_nsec = x.tv_usec * NSEC_PER_USEC;
 572 }
 573 #endif
 574
 575 #if (BITS_PER_LONG < 64)
 576 u64 get_jiffies_64(void)
 577 {
 578         unsigned long seq;
 579         u64 ret;
 580
 581         do {
 582                 seq = read_seqbegin(&xtime_lock);
 583                 ret = jiffies_64;
 584         } while (read_seqretry(&xtime_lock, seq));
 585         return ret;
 586 }
 587
 588 EXPORT_SYMBOL(get_jiffies_64);
 589 #endif
 590
 591 EXPORT_SYMBOL(jiffies);