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