contrib/ntp/libntp/systime.c

   1 /*
   2  * systime -- routines to fiddle a UNIX clock.
   3  *
   4  * ATTENTION: Get approval from Dave Mills on all changes to this file!
   5  *
   6  */
   7 #include <config.h>
   8
   9 #include "ntp.h"
  10 #include "ntp_syslog.h"
  11 #include "ntp_stdlib.h"
  12 #include "ntp_random.h"
  13 #include "iosignal.h"
  14 #include "timevalops.h"
  15 #include "timespecops.h"
  16 #include "ntp_calendar.h"
  17
  18 #ifdef HAVE_SYS_PARAM_H
  19 # include <sys/param.h>
  20 #endif
  21 #ifdef HAVE_UTMP_H
  22 # include <utmp.h>
  23 #endif /* HAVE_UTMP_H */
  24 #ifdef HAVE_UTMPX_H
  25 # include <utmpx.h>
  26 #endif /* HAVE_UTMPX_H */
  27
  28 int     allow_panic = FALSE;            /* allow panic correction (-g) */
  29 int     enable_panic_check = TRUE;      /* Can we check allow_panic's state? */
  30
  31 #ifndef USE_COMPILETIME_PIVOT
  32 # define USE_COMPILETIME_PIVOT 1
  33 #endif
  34
  35 /*
  36  * These routines (get_systime, step_systime, adj_systime) implement an
  37  * interface between the system independent NTP clock and the Unix
  38  * system clock in various architectures and operating systems. Time is
  39  * a precious quantity in these routines and every effort is made to
  40  * minimize errors by unbiased rounding and amortizing adjustment
  41  * residues.
  42  *
  43  * In order to improve the apparent resolution, provide unbiased
  44  * rounding and most importantly ensure that the readings cannot be
  45  * predicted, the low-order unused portion of the time below the minimum
  46  * time to read the clock is filled with an unbiased random fuzz.
  47  *
  48  * The sys_tick variable specifies the system clock tick interval in
  49  * seconds, for stepping clocks, defined as those which return times
  50  * less than MINSTEP greater than the previous reading. For systems that
  51  * use a high-resolution counter such that each clock reading is always
  52  * at least MINSTEP greater than the prior, sys_tick is the time to read
  53  * the system clock.
  54  *
  55  * The sys_fuzz variable measures the minimum time to read the system
  56  * clock, regardless of its precision.  When reading the system clock
  57  * using get_systime() after sys_tick and sys_fuzz have been determined,
  58  * ntpd ensures each unprocessed clock reading is no less than sys_fuzz
  59  * later than the prior unprocessed reading, and then fuzzes the bits
  60  * below sys_fuzz in the timestamp returned, ensuring each of its
  61  * resulting readings is strictly later than the previous.
  62  *
  63  * When slewing the system clock using adj_systime() (with the kernel
  64  * loop discipline unavailable or disabled), adjtime() offsets are
  65  * quantized to sys_tick, if sys_tick is greater than sys_fuzz, which
  66  * is to say if the OS presents a stepping clock.  Otherwise, offsets
  67  * are quantized to the microsecond resolution of adjtime()'s timeval
  68  * input.  The remaining correction sys_residual is carried into the
  69  * next adjtime() and meanwhile is also factored into get_systime()
  70  * readings.
  71  */
  72 double  sys_tick = 0;           /* tick size or time to read (s) */
  73 double  sys_fuzz = 0;           /* min. time to read the clock (s) */
  74 long    sys_fuzz_nsec = 0;      /* min. time to read the clock (ns) */
  75 double  measured_tick;          /* non-overridable sys_tick (s) */
  76 double  sys_residual = 0;       /* adjustment residue (s) */
  77 int     trunc_os_clock;         /* sys_tick > measured_tick */
  78 time_stepped_callback   step_callback;
  79
  80 #ifndef SIM
  81 /* perlinger@ntp.org: As 'get_sysime()' does it's own check for clock
  82  * backstepping, this could probably become a local variable in
  83  * 'get_systime()' and the cruft associated with communicating via a
  84  * static value could be removed after the v4.2.8 release.
  85  */
  86 static int lamport_violated;    /* clock was stepped back */
  87 #endif  /* !SIM */
  88
  89 #ifdef DEBUG
  90 static int systime_init_done;
  91 # define DONE_SYSTIME_INIT()    systime_init_done = TRUE
  92 #else
  93 # define DONE_SYSTIME_INIT()    do {} while (FALSE)
  94 #endif
  95
  96 #ifdef HAVE_SIGNALED_IO
  97 int using_sigio;
  98 #endif
  99
 100 #ifdef SYS_WINNT
 101 CRITICAL_SECTION get_systime_cs;
 102 #endif
 103
 104
 105 void
 106 set_sys_fuzz(
 107         double  fuzz_val
 108         )
 109 {
 110         sys_fuzz = fuzz_val;
 111         INSIST(sys_fuzz >= 0);
 112         INSIST(sys_fuzz <= 1.0);
 113         sys_fuzz_nsec = (long)(sys_fuzz * 1e9 + 0.5);
 114 }
 115
 116
 117 void
 118 init_systime(void)
 119 {
 120         INIT_GET_SYSTIME_CRITSEC();
 121         INIT_WIN_PRECISE_TIME();
 122         DONE_SYSTIME_INIT();
 123 }
 124
 125
 126 #ifndef SIM     /* ntpsim.c has get_systime() and friends for sim */
 127
 128 static inline void
 129 get_ostime(
 130         struct timespec *       tsp
 131         )
 132 {
 133         int     rc;
 134         long    ticks;
 135
 136 #if defined(HAVE_CLOCK_GETTIME)
 137         rc = clock_gettime(CLOCK_REALTIME, tsp);
 138 #elif defined(HAVE_GETCLOCK)
 139         rc = getclock(TIMEOFDAY, tsp);
 140 #else
 141         struct timeval          tv;
 142
 143         rc = GETTIMEOFDAY(&tv, NULL);
 144         tsp->tv_sec = tv.tv_sec;
 145         tsp->tv_nsec = tv.tv_usec * 1000;
 146 #endif
 147         if (rc < 0) {
 148                 msyslog(LOG_ERR, "read system clock failed: %m (%d)",
 149                         errno);
 150                 exit(1);
 151         }
 152
 153         if (trunc_os_clock) {
 154                 ticks = (long)((tsp->tv_nsec * 1e-9) / sys_tick);
 155                 tsp->tv_nsec = (long)(ticks * 1e9 * sys_tick);
 156         }
 157 }
 158
 159
 160 /*
 161  * get_systime - return system time in NTP timestamp format.
 162  */
 163 void
 164 get_systime(
 165         l_fp *now               /* system time */
 166         )
 167 {
 168         static struct timespec  ts_last;        /* last sampled os time */
 169         static struct timespec  ts_prev;        /* prior os time */
 170         static l_fp             lfp_prev;       /* prior result */
 171         static double           dfuzz_prev;     /* prior fuzz */
 172         struct timespec ts;     /* seconds and nanoseconds */
 173         struct timespec ts_min; /* earliest permissible */
 174         struct timespec ts_lam; /* lamport fictional increment */
 175         struct timespec ts_prev_log;    /* for msyslog only */
 176         double  dfuzz;
 177         double  ddelta;
 178         l_fp    result;
 179         l_fp    lfpfuzz;
 180         l_fp    lfpdelta;
 181
 182         get_ostime(&ts);
 183         DEBUG_REQUIRE(systime_init_done);
 184         ENTER_GET_SYSTIME_CRITSEC();
 185
 186         /* First check if here was a Lamport violation, that is, two
 187          * successive calls to 'get_ostime()' resulted in negative
 188          * time difference. Use a few milliseconds of permissible
 189          * tolerance -- being too sharp can hurt here. (This is intented
 190          * for the Win32 target, where the HPC interpolation might
 191          * introduce small steps backward. It should not be an issue on
 192          * systems where get_ostime() results in a true syscall.)
 193          */
 194         if (cmp_tspec(add_tspec_ns(ts, 50000000), ts_last) < 0)
 195                 lamport_violated = 1;
 196         ts_last = ts;
 197
 198         /*
 199          * After default_get_precision() has set a nonzero sys_fuzz,
 200          * ensure every reading of the OS clock advances by at least
 201          * sys_fuzz over the prior reading, thereby assuring each
 202          * fuzzed result is strictly later than the prior.  Limit the
 203          * necessary fiction to 1 second.
 204          */
 205         if (!USING_SIGIO()) {
 206                 ts_min = add_tspec_ns(ts_prev, sys_fuzz_nsec);
 207                 if (cmp_tspec(ts, ts_min) < 0) {
 208                         ts_lam = sub_tspec(ts_min, ts);
 209                         if (ts_lam.tv_sec > 0 && !lamport_violated) {
 210                                 msyslog(LOG_ERR,
 211                                         "get_systime Lamport advance exceeds one second (%.9f)",
 212                                         ts_lam.tv_sec +
 213                                             1e-9 * ts_lam.tv_nsec);
 214                                 exit(1);
 215                         }
 216                         if (!lamport_violated)
 217                                 ts = ts_min;
 218                 }
 219                 ts_prev_log = ts_prev;
 220                 ts_prev = ts;
 221         } else {
 222                 /*
 223                  * Quiet "ts_prev_log.tv_sec may be used uninitialized"
 224                  * warning from x86 gcc 4.5.2.
 225                  */
 226                 ZERO(ts_prev_log);
 227         }
 228
 229         /* convert from timespec to l_fp fixed-point */
 230         result = tspec_stamp_to_lfp(ts);
 231
 232         /*
 233          * Add in the fuzz.
 234          */
 235         dfuzz = ntp_random() * 2. / FRAC * sys_fuzz;
 236         DTOLFP(dfuzz, &lfpfuzz);
 237         L_ADD(&result, &lfpfuzz);
 238
 239         /*
 240          * Ensure result is strictly greater than prior result (ignoring
 241          * sys_residual's effect for now) once sys_fuzz has been
 242          * determined.
 243          */
 244         if (!USING_SIGIO()) {
 245                 if (!L_ISZERO(&lfp_prev) && !lamport_violated) {
 246                         if (!L_ISGTU(&result, &lfp_prev) &&
 247                             sys_fuzz > 0.) {
 248                                 msyslog(LOG_ERR, "ts_prev %s ts_min %s",
 249                                         tspectoa(ts_prev_log),
 250                                         tspectoa(ts_min));
 251                                 msyslog(LOG_ERR, "ts %s", tspectoa(ts));
 252                                 msyslog(LOG_ERR, "sys_fuzz %ld nsec, prior fuzz %.9f",
 253                                         sys_fuzz_nsec, dfuzz_prev);
 254                                 msyslog(LOG_ERR, "this fuzz %.9f",
 255                                         dfuzz);
 256                                 lfpdelta = lfp_prev;
 257                                 L_SUB(&lfpdelta, &result);
 258                                 LFPTOD(&lfpdelta, ddelta);
 259                                 msyslog(LOG_ERR,
 260                                         "prev get_systime 0x%x.%08x is %.9f later than 0x%x.%08x",
 261                                         lfp_prev.l_ui, lfp_prev.l_uf,
 262                                         ddelta, result.l_ui, result.l_uf);
 263                         }
 264                 }
 265                 lfp_prev = result;
 266                 dfuzz_prev = dfuzz;
 267                 if (lamport_violated)
 268                         lamport_violated = FALSE;
 269         }
 270         LEAVE_GET_SYSTIME_CRITSEC();
 271         *now = result;
 272 }
 273
 274
 275 /*
 276  * adj_systime - adjust system time by the argument.
 277  */
 278 #if !defined SYS_WINNT
 279 int                             /* 0 okay, 1 error */
 280 adj_systime(
 281         double now              /* adjustment (s) */
 282         )
 283 {
 284         struct timeval adjtv;   /* new adjustment */
 285         struct timeval oadjtv;  /* residual adjustment */
 286         double  quant;          /* quantize to multiples of */
 287         double  dtemp;
 288         long    ticks;
 289         int     isneg = 0;
 290
 291         /*
 292          * The Windows port adj_systime() depends on being called each
 293          * second even when there's no additional correction, to allow
 294          * emulation of adjtime() behavior on top of an API that simply
 295          * sets the current rate.  This POSIX implementation needs to
 296          * ignore invocations with zero correction, otherwise ongoing
 297          * EVNT_NSET adjtime() can be aborted by a tiny adjtime()
 298          * triggered by sys_residual.
 299          */
 300         if (0. == now) {
 301                 if (enable_panic_check && allow_panic) {
 302                         msyslog(LOG_ERR, "adj_systime: allow_panic is TRUE!");
 303                         INSIST(!allow_panic);
 304                 }
 305                 return TRUE;
 306         }
 307
 308         /*
 309          * Most Unix adjtime() implementations adjust the system clock
 310          * in microsecond quanta, but some adjust in 10-ms quanta. We
 311          * carefully round the adjustment to the nearest quantum, then
 312          * adjust in quanta and keep the residue for later.
 313          */
 314         dtemp = now + sys_residual;
 315         if (dtemp < 0) {
 316                 isneg = 1;
 317                 dtemp = -dtemp;
 318         }
 319         adjtv.tv_sec = (long)dtemp;
 320         dtemp -= adjtv.tv_sec;
 321         if (sys_tick > sys_fuzz)
 322                 quant = sys_tick;
 323         else
 324                 quant = 1e-6;
 325         ticks = (long)(dtemp / quant + .5);
 326         adjtv.tv_usec = (long)(ticks * quant * 1e6);
 327         dtemp -= adjtv.tv_usec / 1e6;
 328         sys_residual = dtemp;
 329
 330         /*
 331          * Convert to signed seconds and microseconds for the Unix
 332          * adjtime() system call. Note we purposely lose the adjtime()
 333          * leftover.
 334          */
 335         if (isneg) {
 336                 adjtv.tv_sec = -adjtv.tv_sec;
 337                 adjtv.tv_usec = -adjtv.tv_usec;
 338                 sys_residual = -sys_residual;
 339         }
 340         if (adjtv.tv_sec != 0 || adjtv.tv_usec != 0) {
 341                 if (adjtime(&adjtv, &oadjtv) < 0) {
 342                         msyslog(LOG_ERR, "adj_systime: %m");
 343                         if (enable_panic_check && allow_panic) {
 344                                 msyslog(LOG_ERR, "adj_systime: allow_panic is TRUE!");
 345                         }
 346                         return FALSE;
 347                 }
 348         }
 349         if (enable_panic_check && allow_panic) {
 350                 msyslog(LOG_ERR, "adj_systime: allow_panic is TRUE!");
 351         }
 352         return TRUE;
 353 }
 354 #endif
 355
 356
 357 /*
 358  * step_systime - step the system clock.
 359  */
 360
 361 int
 362 step_systime(
 363         double step
 364         )
 365 {
 366         time_t pivot; /* for ntp era unfolding */
 367         struct timeval timetv, tvlast, tvdiff;
 368         struct timespec timets;
 369         struct calendar jd;
 370         l_fp fp_ofs, fp_sys; /* offset and target system time in FP */
 371
 372         /*
 373          * Get pivot time for NTP era unfolding. Since we don't step
 374          * very often, we can afford to do the whole calculation from
 375          * scratch. And we're not in the time-critical path yet.
 376          */
 377 #if SIZEOF_TIME_T > 4
 378         /*
 379          * This code makes sure the resulting time stamp for the new
 380          * system time is in the 2^32 seconds starting at 1970-01-01,
 381          * 00:00:00 UTC.
 382          */
 383         pivot = 0x80000000;
 384 #if USE_COMPILETIME_PIVOT
 385         /*
 386          * Add the compile time minus 10 years to get a possible target
 387          * area of (compile time - 10 years) to (compile time + 126
 388          * years).  This should be sufficient for a given binary of
 389          * NTPD.
 390          */
 391         if (ntpcal_get_build_date(&jd)) {
 392                 jd.year -= 10;
 393                 pivot += ntpcal_date_to_time(&jd);
 394         } else {
 395                 msyslog(LOG_ERR,
 396                         "step-systime: assume 1970-01-01 as build date");
 397         }
 398 #else
 399         UNUSED_LOCAL(jd);
 400 #endif /* USE_COMPILETIME_PIVOT */
 401 #else
 402         UNUSED_LOCAL(jd);
 403         /* This makes sure the resulting time stamp is on or after
 404          * 1969-12-31/23:59:59 UTC and gives us additional two years,
 405          * from the change of NTP era in 2036 to the UNIX rollover in
 406          * 2038. (Minus one second, but that won't hurt.) We *really*
 407          * need a longer 'time_t' after that!  Or a different baseline,
 408          * but that would cause other serious trouble, too.
 409          */
 410         pivot = 0x7FFFFFFF;
 411 #endif
 412
 413         /* get the complete jump distance as l_fp */
 414         DTOLFP(sys_residual, &fp_sys);
 415         DTOLFP(step,         &fp_ofs);
 416         L_ADD(&fp_ofs, &fp_sys);
 417
 418         /* ---> time-critical path starts ---> */
 419
 420         /* get the current time as l_fp (without fuzz) and as struct timeval */
 421         get_ostime(&timets);
 422         fp_sys = tspec_stamp_to_lfp(timets);
 423         tvlast.tv_sec = timets.tv_sec;
 424         tvlast.tv_usec = (timets.tv_nsec + 500) / 1000;
 425
 426         /* get the target time as l_fp */
 427         L_ADD(&fp_sys, &fp_ofs);
 428
 429         /* unfold the new system time */
 430         timetv = lfp_stamp_to_tval(fp_sys, &pivot);
 431
 432         /* now set new system time */
 433         if (ntp_set_tod(&timetv, NULL) != 0) {
 434                 msyslog(LOG_ERR, "step-systime: %m");
 435                 if (enable_panic_check && allow_panic) {
 436                         msyslog(LOG_ERR, "step_systime: allow_panic is TRUE!");
 437                 }
 438                 return FALSE;
 439         }
 440
 441         /* <--- time-critical path ended with 'ntp_set_tod()' <--- */
 442
 443         sys_residual = 0;
 444         lamport_violated = (step < 0);
 445         if (step_callback)
 446                 (*step_callback)();
 447
 448 #ifdef NEED_HPUX_ADJTIME
 449         /*
 450          * CHECKME: is this correct when called by ntpdate?????
 451          */
 452         _clear_adjtime();
 453 #endif
 454
 455         /*
 456          * FreeBSD, for example, has:
 457          * struct utmp {
 458          *         char    ut_line[UT_LINESIZE];
 459          *         char    ut_name[UT_NAMESIZE];
 460          *         char    ut_host[UT_HOSTSIZE];
 461          *         long    ut_time;
 462          * };
 463          * and appends line="|", name="date", host="", time for the OLD
 464          * and appends line="{", name="date", host="", time for the NEW // }
 465          * to _PATH_WTMP .
 466          *
 467          * Some OSes have utmp, some have utmpx.
 468          */
 469
 470         /*
 471          * Write old and new time entries in utmp and wtmp if step
 472          * adjustment is greater than one second.
 473          *
 474          * This might become even Uglier...
 475          */
 476         tvdiff = abs_tval(sub_tval(timetv, tvlast));
 477         if (tvdiff.tv_sec > 0) {
 478 #ifdef HAVE_UTMP_H
 479                 struct utmp ut;
 480 #endif
 481 #ifdef HAVE_UTMPX_H
 482                 struct utmpx utx;
 483 #endif
 484
 485 #ifdef HAVE_UTMP_H
 486                 ZERO(ut);
 487 #endif
 488 #ifdef HAVE_UTMPX_H
 489                 ZERO(utx);
 490 #endif
 491
 492                 /* UTMP */
 493
 494 #ifdef UPDATE_UTMP
 495 # ifdef HAVE_PUTUTLINE
 496 #  ifndef _PATH_UTMP
 497 #   define _PATH_UTMP UTMP_FILE
 498 #  endif
 499                 utmpname(_PATH_UTMP);
 500                 ut.ut_type = OLD_TIME;
 501                 strlcpy(ut.ut_line, OTIME_MSG, sizeof(ut.ut_line));
 502                 ut.ut_time = tvlast.tv_sec;
 503                 setutent();
 504                 pututline(&ut);
 505                 ut.ut_type = NEW_TIME;
 506                 strlcpy(ut.ut_line, NTIME_MSG, sizeof(ut.ut_line));
 507                 ut.ut_time = timetv.tv_sec;
 508                 setutent();
 509                 pututline(&ut);
 510                 endutent();
 511 # else /* not HAVE_PUTUTLINE */
 512 # endif /* not HAVE_PUTUTLINE */
 513 #endif /* UPDATE_UTMP */
 514
 515                 /* UTMPX */
 516
 517 #ifdef UPDATE_UTMPX
 518 # ifdef HAVE_PUTUTXLINE
 519                 utx.ut_type = OLD_TIME;
 520                 strlcpy(utx.ut_line, OTIME_MSG, sizeof(utx.ut_line));
 521                 utx.ut_tv = tvlast;
 522                 setutxent();
 523                 pututxline(&utx);
 524                 utx.ut_type = NEW_TIME;
 525                 strlcpy(utx.ut_line, NTIME_MSG, sizeof(utx.ut_line));
 526                 utx.ut_tv = timetv;
 527                 setutxent();
 528                 pututxline(&utx);
 529                 endutxent();
 530 # else /* not HAVE_PUTUTXLINE */
 531 # endif /* not HAVE_PUTUTXLINE */
 532 #endif /* UPDATE_UTMPX */
 533
 534                 /* WTMP */
 535
 536 #ifdef UPDATE_WTMP
 537 # ifdef HAVE_PUTUTLINE
 538 #  ifndef _PATH_WTMP
 539 #   define _PATH_WTMP WTMP_FILE
 540 #  endif
 541                 utmpname(_PATH_WTMP);
 542                 ut.ut_type = OLD_TIME;
 543                 strlcpy(ut.ut_line, OTIME_MSG, sizeof(ut.ut_line));
 544                 ut.ut_time = tvlast.tv_sec;
 545                 setutent();
 546                 pututline(&ut);
 547                 ut.ut_type = NEW_TIME;
 548                 strlcpy(ut.ut_line, NTIME_MSG, sizeof(ut.ut_line));
 549                 ut.ut_time = timetv.tv_sec;
 550                 setutent();
 551                 pututline(&ut);
 552                 endutent();
 553 # else /* not HAVE_PUTUTLINE */
 554 # endif /* not HAVE_PUTUTLINE */
 555 #endif /* UPDATE_WTMP */
 556
 557                 /* WTMPX */
 558
 559 #ifdef UPDATE_WTMPX
 560 # ifdef HAVE_PUTUTXLINE
 561                 utx.ut_type = OLD_TIME;
 562                 utx.ut_tv = tvlast;
 563                 strlcpy(utx.ut_line, OTIME_MSG, sizeof(utx.ut_line));
 564 #  ifdef HAVE_UPDWTMPX
 565                 updwtmpx(WTMPX_FILE, &utx);
 566 #  else /* not HAVE_UPDWTMPX */
 567 #  endif /* not HAVE_UPDWTMPX */
 568 # else /* not HAVE_PUTUTXLINE */
 569 # endif /* not HAVE_PUTUTXLINE */
 570 # ifdef HAVE_PUTUTXLINE
 571                 utx.ut_type = NEW_TIME;
 572                 utx.ut_tv = timetv;
 573                 strlcpy(utx.ut_line, NTIME_MSG, sizeof(utx.ut_line));
 574 #  ifdef HAVE_UPDWTMPX
 575                 updwtmpx(WTMPX_FILE, &utx);
 576 #  else /* not HAVE_UPDWTMPX */
 577 #  endif /* not HAVE_UPDWTMPX */
 578 # else /* not HAVE_PUTUTXLINE */
 579 # endif /* not HAVE_PUTUTXLINE */
 580 #endif /* UPDATE_WTMPX */
 581
 582         }
 583         if (enable_panic_check && allow_panic) {
 584                 msyslog(LOG_ERR, "step_systime: allow_panic is TRUE!");
 585                 INSIST(!allow_panic);
 586         }
 587         return TRUE;
 588 }
 589
 590 #endif  /* !SIM */