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