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