Annotation of embedaddon/ntp/ports/winnt/ntpd/nt_clockstuff.c, revision 1.1
1.1 ! misho 1: /* Windows NT Clock Routines
! 2: *
! 3: * Created by Sven Dietrich sven@inter-yacht.com
! 4: *
! 5: * New interpolation scheme by Dave Hart <davehart@davehart.com> February 2009
! 6: * overcomes 500us-1ms inherent jitter with the older scheme, first identified
! 7: * by Peter Rosin (nee Ekberg) <peda@lysator.liu.se> in 2003 [Bug 216].
! 8: */
! 9:
! 10:
! 11: #ifdef HAVE_CONFIG_H
! 12: #include "config.h"
! 13: #endif
! 14:
! 15: #include <sys/resource.h> /* our private version */
! 16:
! 17: #if defined(_MSC_VER) && _MSC_VER >= 1400 /* VS 2005 */
! 18: #include <intrin.h> /* for __rdtsc() */
! 19: #endif
! 20:
! 21: #ifdef HAVE_PPSAPI
! 22: #include <timepps.h>
! 23: /*
! 24: * ports/winnt/include/timepps.h defines EOPNOTSUPP for compatibility
! 25: * with PPSAPI on other platforms. ports/winnt/include/isc/net.h has
! 26: * #define EOPNOTSUPP WSAEOPNOTSUPP, so to avoid a macro redefinition
! 27: * warning undefine it.
! 28: */
! 29: #undef EOPNOTSUPP
! 30: #endif /* HAVE_PPSAPI */
! 31:
! 32: #include "ntp_stdlib.h"
! 33: #include "ntp_unixtime.h"
! 34: #include "ntp_timer.h"
! 35: #include "ntp_assert.h"
! 36: #include "clockstuff.h"
! 37: #include "ntservice.h"
! 38: #include "ntpd.h"
! 39: #include "../../../ntpd/ntpd-opts.h"
! 40:
! 41: extern double sys_residual; /* residual from previous adjustment */
! 42:
! 43: /*
! 44: * Include code to possibly modify the MM timer while the service is active.
! 45: */
! 46:
! 47: /*
! 48: * Whether or not MM timer modifications takes place is still controlled
! 49: * by the variable below which is initialized by a default value but
! 50: * might be changed depending on a command line switch.
! 51: */
! 52: static int modify_mm_timer = MM_TIMER_LORES;
! 53:
! 54: #define MM_TIMER_INTV 1 /* the interval we'd want to set the MM timer to [ms] */
! 55:
! 56: static UINT wTimerRes;
! 57:
! 58: BOOL init_randfile();
! 59:
! 60: static long last_Adj = 0;
! 61:
! 62: #define LS_CORR_INTV_SECS 2 /* seconds to apply leap second correction */
! 63: #define LS_CORR_INTV ( (LONGLONG) HECTONANOSECONDS * LS_CORR_INTV_SECS )
! 64: #define LS_CORR_LIMIT ( (LONGLONG) HECTONANOSECONDS / 2 ) // half a second
! 65:
! 66: typedef union ft_ull {
! 67: FILETIME ft;
! 68: ULONGLONG ull;
! 69: LONGLONG ll;
! 70: LARGE_INTEGER li;
! 71: } FT_ULL;
! 72:
! 73: /* leap second stuff */
! 74: static FT_ULL ls_ft;
! 75: static DWORD ls_time_adjustment;
! 76: static ULONGLONG ls_ref_perf_cnt;
! 77: static LONGLONG ls_elapsed;
! 78:
! 79: static BOOL winnt_time_initialized = FALSE;
! 80: static BOOL winnt_use_interpolation = FALSE;
! 81: static ULONGLONG last_interp_time;
! 82: static unsigned clock_thread_id;
! 83:
! 84:
! 85: void WINAPI GetInterpTimeAsFileTime(LPFILETIME pft);
! 86: static void StartClockThread(void);
! 87: static void tune_ctr_freq(LONGLONG, LONGLONG);
! 88: void StopClockThread(void);
! 89: void atexit_revert_mm_timer(void);
! 90: void time_stepped(void);
! 91:
! 92: static HANDLE clock_thread = NULL;
! 93: static HANDLE TimerThreadExitRequest = NULL;
! 94:
! 95: /*
! 96: * interp_time estimates time in 100ns units
! 97: * based on a performance counter value given.
! 98: * The 2nd parameter indicates if this is
! 99: * part of a current time-of-day calculation.
! 100: */
! 101: ULONGLONG interp_time(ULONGLONG, BOOL);
! 102:
! 103: /*
! 104: * add_counter_time_pair is called by the
! 105: * high priority clock thread with a new
! 106: * sample.
! 107: */
! 108: void add_counter_time_pair(ULONGLONG, LONGLONG);
! 109:
! 110: /*
! 111: * globals used by the above two functions to
! 112: * implement the counter/time history
! 113: */
! 114: #define BASELINES_TOT 256
! 115: #define BASELINES_USED 64
! 116:
! 117: static volatile int newest_baseline = 0;
! 118: static volatile int newest_baseline_gen = 0;
! 119: static ULONGLONG baseline_counts[BASELINES_TOT] = {0};
! 120: static LONGLONG baseline_times[BASELINES_TOT] = {0};
! 121:
! 122: static int clock_backward_count;
! 123: static ULONGLONG clock_backward_max;
! 124:
! 125:
! 126: /*
! 127: * clockperiod is the period used for SetSystemTimeAdjustment
! 128: * slewing calculations but does not necessarily correspond
! 129: * to the precision of the OS clock. Prior to Windows Vista
! 130: * (6.0) the two were identical. In 100ns units.
! 131: */
! 132: static DWORD clockperiod;
! 133:
! 134: /*
! 135: * os_clock_precision is the observed precision of the OS
! 136: * clock, meaning the increment between discrete values. This
! 137: * is currently calculated once at startup. 100ns units.
! 138: */
! 139: static ULONGLONG os_clock_precision;
! 140:
! 141: /*
! 142: * NomPerfCtrFreq is from QueryPerformanceFrequency and is the
! 143: * number of performance counter beats per second. PerfCtrFreq
! 144: * starts from NomPerfCtrFreq but is maintained using a sliding
! 145: * window average based on actual performance counter behavior,
! 146: * to allow us to better tolerate powersaving measures that
! 147: * alter the effective frequency of the processor cycle counter
! 148: * (TSC) which sometimes underlies QueryPerformanceCounter.
! 149: *
! 150: * Note that the OS is unlikely to be so subtle in its internal
! 151: * scheduling of waitable timers, presumably done using the
! 152: * performance counter. Therefore our calculations for
! 153: * interpolated time should be based on PerfCtrFreq but our
! 154: * calculations for SetWaitableTimer should assume the OS will
! 155: * convert from FILETIME 100ns units to performance counter
! 156: * beats using the nominal frequency.
! 157: */
! 158:
! 159: volatile ULONGLONG PerfCtrFreq = 0;
! 160: ULONGLONG NomPerfCtrFreq = 0;
! 161:
! 162: /*
! 163: * If we're using RDTSC beating at the same rate as
! 164: * QueryPerformanceCounter, there is a systemic
! 165: * offset we need to account for when using
! 166: * counterstamps from serialpps.sys, which are
! 167: * always from QPC (actually KeQueryPerformanceCounter).
! 168: */
! 169: static LONGLONG QPC_offset = 0;
! 170:
! 171: /*
! 172: * Substitute RDTSC for QueryPerformanceCounter()?
! 173: */
! 174: static int use_pcc = -1;
! 175:
! 176: /*
! 177: * Restrict threads that call QPC/RDTSC to one CPU?
! 178: */
! 179: static int lock_interp_threads = -1;
! 180:
! 181: static void choose_interp_counter(void);
! 182: static int is_qpc_built_on_pcc(void);
! 183:
! 184: /*
! 185: * ppm_per_adjust_unit is parts per million effect on the OS
! 186: * clock per slewing adjustment unit per second. Per haps.
! 187: */
! 188: static DOUBLE ppm_per_adjust_unit = 0.0;
! 189:
! 190: /*
! 191: * wintickadj emulates the functionality provided by unix tickadj,
! 192: * providing a baseline clock correction if needed to get the
! 193: * clock within a few hundred PPM of correct frequency.
! 194: */
! 195: static long wintickadj;
! 196:
! 197: /*
! 198: * performance counter frequency observations
! 199: */
! 200: #define TUNE_CTR_DEPTH 3 /* running avg depth */
! 201:
! 202: static HANDLE ctr_freq_timer = INVALID_HANDLE_VALUE;
! 203: static ULONGLONG tune_ctr_freq_max_interval;
! 204: static unsigned tune_ctr_period;
! 205: void start_ctr_freq_timer(ULONGLONG now_time);
! 206: void reset_ctr_freq_timer(ULONGLONG when, ULONGLONG now);
! 207: void reset_ctr_freq_timer_abs(ULONGLONG when);
! 208:
! 209: /* round a Windows time to the next bottom of the second */
! 210:
! 211: #define ROUND_TO_NEXT_SEC_BOTTOM(t) \
! 212: do { \
! 213: (t) += 3 * HECTONANOSECONDS / 2 - 1; \
! 214: (t) /= HECTONANOSECONDS; \
! 215: (t) *= HECTONANOSECONDS; \
! 216: (t) -= HECTONANOSECONDS / 2; \
! 217: } while (0)
! 218:
! 219: /*
! 220: * workaround for VC6 inability to convert unsigned __int64 to double
! 221: */
! 222: #define LL_HNS ((LONGLONG)HECTONANOSECONDS)
! 223:
! 224: /*
! 225: * NT native time format is 100's of nanoseconds since 1601-01-01.
! 226: * Helpers for converting between "hectonanoseconds" and the
! 227: * performance counter scale from which interpolated time is
! 228: * derived.
! 229: *
! 230: * Once support for VC6 is dropped, the cast of PerfCtrFreq to
! 231: * LONGLONG can come out of PERF2HNS(). It avoids the VC6 error
! 232: * message:
! 233: *
! 234: * conversion from unsigned __int64 to double not implemented, use
! 235: * signed __int64
! 236: */
! 237: #define HNS2PERF(hns) ((hns) * PerfCtrFreq / LL_HNS)
! 238: #define PERF2HNS(ctr) ((ctr) * LL_HNS / (LONGLONG)PerfCtrFreq)
! 239:
! 240:
! 241: #if defined(_MSC_VER) && _MSC_VER >= 1400 /* VS 2005 */
! 242: #define get_pcc() __rdtsc()
! 243: #else
! 244: /*
! 245: * something like this can be used for a compiler without __rdtsc()
! 246: */
! 247: ULONGLONG __forceinline
! 248: get_pcc(void)
! 249: {
! 250: /* RDTSC returns in EDX:EAX, same as C compiler */
! 251: __asm {
! 252: RDTSC
! 253: }
! 254: }
! 255: #endif
! 256:
! 257:
! 258: /*
! 259: * perf_ctr() returns the current performance counter value,
! 260: * from QueryPerformanceCounter or RDTSC.
! 261: */
! 262: ULONGLONG WINAPI
! 263: perf_ctr(void)
! 264: {
! 265: FT_ULL ft;
! 266:
! 267: if (use_pcc)
! 268: return get_pcc();
! 269: else {
! 270: QueryPerformanceCounter(&ft.li);
! 271: return ft.ull;
! 272: }
! 273: }
! 274:
! 275:
! 276: /*
! 277: * choose_interp_counter - select between QueryPerformanceCounter and
! 278: * the x86 processor cycle counter (TSC).
! 279: */
! 280: static void
! 281: choose_interp_counter(void)
! 282: {
! 283: const char * ntpd_pcc_freq_text;
! 284: int qpc_built_on_pcc;
! 285:
! 286: /*
! 287: * Regardless of whether we actually use RDTSC, first determine
! 288: * if QueryPerformanceCounter is built on it, so that we can
! 289: * decide whether it's prudent to lock QPC-consuming threads to
! 290: * a particular CPU.
! 291: */
! 292: qpc_built_on_pcc = is_qpc_built_on_pcc();
! 293: lock_interp_threads = qpc_built_on_pcc;
! 294:
! 295: /*
! 296: * It's time to make some more permanent knobs,
! 297: * but for right now the RDTSC aka PCC dance on x86 is:
! 298: *
! 299: * 1. With none of these variables defined, only QPC
! 300: * is used because there is no reliable way to
! 301: * detect counter frequency variation after ntpd
! 302: * startup implemented.
! 303: * 2. We need a better knob, but for now if you know
! 304: * your RDTSC / CPU frequency is invariant, set
! 305: * NTPD_PCC and assuming your QPC is based on the
! 306: * PCC as well, RDTSC will be substituted.
! 307: * 3. More forcefully, you can jam in a desired exact
! 308: * processor frequency, expressed in cycles per
! 309: * second by setting NTPD_PCC_FREQ=398125000, for
! 310: * example, if yor actual known CPU frequency is
! 311: * 398.125 MHz, and NTPD_PCC doesn't work because
! 312: * QueryPerformanceCounter is implemented using
! 313: * another counter. It is very easy to make ntpd
! 314: * fall down if the NTPD_PCC_FREQ value isn't very
! 315: * close to the observed RDTSC units per second.
! 316: *
! 317: * Items 2 and 3 could probably best be combined into one
! 318: * new windows-specific command line switch such as
! 319: * ntpd --pcc
! 320: * or
! 321: * ntpd --pcc=398125000
! 322: *
! 323: * They are currently tied to Windows because that is
! 324: * the only ntpd port with its own interpolation, and
! 325: * to x86/x64 because no one has ported the Windows
! 326: * ntpd port to the sole remaining alternative, Intel
! 327: * Itanium.
! 328: */
! 329: if (HAVE_OPT(PCCFREQ))
! 330: ntpd_pcc_freq_text = OPT_ARG(PCCFREQ);
! 331: else
! 332: ntpd_pcc_freq_text = getenv("NTPD_PCC_FREQ");
! 333:
! 334: if (!HAVE_OPT(USEPCC)
! 335: && NULL == ntpd_pcc_freq_text
! 336: && NULL == getenv("NTPD_PCC")) {
! 337: use_pcc = 0;
! 338: return;
! 339: }
! 340:
! 341: if (!qpc_built_on_pcc && NULL == ntpd_pcc_freq_text) {
! 342: use_pcc = 0;
! 343: return;
! 344: }
! 345:
! 346: use_pcc = 1;
! 347: if (ntpd_pcc_freq_text != NULL)
! 348: sscanf(ntpd_pcc_freq_text,
! 349: "%I64u",
! 350: &NomPerfCtrFreq);
! 351:
! 352: NLOG(NLOG_CLOCKINFO)
! 353: msyslog(LOG_INFO,
! 354: "using processor cycle counter "
! 355: "%.3f MHz",
! 356: (LONGLONG)NomPerfCtrFreq / 1e6);
! 357: return;
! 358: }
! 359:
! 360:
! 361: /*
! 362: * is_qpc_built_on_pcc - test if QueryPerformanceCounter runs at the
! 363: * same rate as the processor cycle counter (TSC).
! 364: */
! 365: static int
! 366: is_qpc_built_on_pcc(void)
! 367: {
! 368: LONGLONG offset;
! 369: FT_ULL ft1;
! 370: FT_ULL ft2;
! 371: FT_ULL ft3;
! 372: FT_ULL ft4;
! 373: FT_ULL ft5;
! 374:
! 375: NTP_REQUIRE(NomPerfCtrFreq != 0);
! 376:
! 377: QueryPerformanceCounter(&ft1.li);
! 378: ft2.ull = get_pcc();
! 379: Sleep(1);
! 380: QueryPerformanceCounter(&ft3.li);
! 381: Sleep(1);
! 382: ft4.ull = get_pcc();
! 383: Sleep(1);
! 384: QueryPerformanceCounter(&ft5.li);
! 385:
! 386: offset = ft2.ull - ft1.ull;
! 387: ft3.ull += offset;
! 388: ft5.ull += offset;
! 389:
! 390: if (ft2.ull <= ft3.ull &&
! 391: ft3.ull <= ft4.ull &&
! 392: ft4.ull <= ft5.ull) {
! 393:
! 394: QPC_offset = offset;
! 395: return TRUE;
! 396: }
! 397:
! 398: return FALSE;
! 399: }
! 400:
! 401:
! 402: /*
! 403: * Request Multimedia Timer
! 404: */
! 405: void
! 406: set_mm_timer(
! 407: int timerres
! 408: )
! 409: {
! 410: modify_mm_timer = timerres;
! 411: }
! 412:
! 413: /*
! 414: * adj_systime - called once every second to make system time adjustments.
! 415: * Returns 1 if okay, 0 if trouble.
! 416: */
! 417: int
! 418: adj_systime(
! 419: double now
! 420: )
! 421: {
! 422: double dtemp;
! 423: u_char isneg = 0;
! 424: int rc;
! 425: long TimeAdjustment;
! 426:
! 427: /*
! 428: * Add the residual from the previous adjustment to the new
! 429: * adjustment, bound and round.
! 430: */
! 431: dtemp = sys_residual + now;
! 432: sys_residual = 0;
! 433: if (dtemp < 0)
! 434: {
! 435: isneg = 1;
! 436: dtemp = -dtemp;
! 437: }
! 438:
! 439: if (dtemp > NTP_MAXFREQ)
! 440: dtemp = NTP_MAXFREQ;
! 441:
! 442: dtemp = dtemp * 1e6;
! 443:
! 444: if (isneg)
! 445: dtemp = -dtemp;
! 446:
! 447: /*
! 448: * dtemp is in micro seconds. NT uses 100 ns units,
! 449: * so a unit change in TimeAdjustment corresponds
! 450: * to slewing 10 ppm on a 100 Hz system. Calculate
! 451: * the number of 100ns units to add, using OS tick
! 452: * frequency as per suggestion from Harry Pyle,
! 453: * and leave the remainder in dtemp
! 454: */
! 455: TimeAdjustment = (long) (dtemp / ppm_per_adjust_unit + (isneg ? -0.5 : 0.5));
! 456: dtemp -= (double) TimeAdjustment * ppm_per_adjust_unit;
! 457:
! 458:
! 459: /*
! 460: * If a leap second is pending then determine the UTC time stamp
! 461: * of when the insertion must take place
! 462: */
! 463: if (leapsec > 0)
! 464: {
! 465: if ( ls_ft.ull == 0 ) /* time stamp has not yet been computed */
! 466: {
! 467: SYSTEMTIME st;
! 468:
! 469: GetSystemTime(&st);
! 470:
! 471: /*
! 472: * Accept leap announcement only 1 month in advance,
! 473: * for end of March, June, September, or December.
! 474: */
! 475: if ( ( st.wMonth % 3 ) == 0 )
! 476: {
! 477: /*
! 478: * The comparison time stamp is computed according
! 479: * to 0:00h UTC of the following day
! 480: */
! 481: if ( ++st.wMonth > 12 )
! 482: {
! 483: st.wMonth -= 12;
! 484: st.wYear++;
! 485: }
! 486:
! 487: st.wDay = 1;
! 488: st.wHour = 0;
! 489: st.wMinute = 0;
! 490: st.wSecond = 0;
! 491: st.wMilliseconds = 0;
! 492:
! 493: SystemTimeToFileTime(&st, &ls_ft.ft);
! 494: msyslog(LOG_NOTICE,
! 495: "Detected positive leap second announcement "
! 496: "for %04d-%02d-%02d %02d:%02d:%02d UTC",
! 497: st.wYear, st.wMonth, st.wDay,
! 498: st.wHour, st.wMinute, st.wSecond);
! 499: }
! 500: }
! 501: }
! 502: else
! 503: {
! 504: if ( ls_ft.ull ) /* Leap second has been armed before */
! 505: {
! 506: /*
! 507: * Disarm leap second only if the leap second
! 508: * is not already in progress.
! 509: */
! 510: if ( !ls_time_adjustment )
! 511: {
! 512: ls_ft.ull = 0;
! 513: msyslog( LOG_NOTICE, "Leap second announcement disarmed" );
! 514: }
! 515: }
! 516: }
! 517:
! 518:
! 519: /*
! 520: * If the time stamp for the next leap second has been set
! 521: * then check if the leap second must be handled
! 522: */
! 523: if ( ls_ft.ull )
! 524: {
! 525: ULONGLONG this_perf_count;
! 526:
! 527: this_perf_count = perf_ctr();
! 528:
! 529: if ( ls_time_adjustment == 0 ) /* has not yet been scheduled */
! 530: {
! 531: FT_ULL curr_ft;
! 532:
! 533: GetSystemTimeAsFileTime(&curr_ft.ft);
! 534: if ( curr_ft.ull >= ls_ft.ull )
! 535: {
! 536: ls_time_adjustment = clockperiod / LS_CORR_INTV_SECS;
! 537: ls_ref_perf_cnt = this_perf_count;
! 538: ls_elapsed = 0;
! 539: msyslog(LOG_NOTICE, "Inserting positive leap second.");
! 540: }
! 541: }
! 542: else /* leap sec adjustment has been scheduled previously */
! 543: {
! 544: ls_elapsed = ( this_perf_count - ls_ref_perf_cnt )
! 545: * HECTONANOSECONDS / PerfCtrFreq;
! 546: }
! 547:
! 548: if ( ls_time_adjustment ) /* leap second adjustment is currently active */
! 549: {
! 550: if ( ls_elapsed > ( LS_CORR_INTV - LS_CORR_LIMIT ) )
! 551: {
! 552: ls_time_adjustment = 0; /* leap second adjustment done */
! 553: ls_ft.ull = 0;
! 554: }
! 555:
! 556: /*
! 557: * NOTE: While the system time is slewed during the leap second
! 558: * the interpolation function which is based on the performance
! 559: * counter does not account for the slew.
! 560: */
! 561: TimeAdjustment -= ls_time_adjustment;
! 562: }
! 563: }
! 564:
! 565:
! 566: /* only adjust the clock if adjustment changes */
! 567: TimeAdjustment += wintickadj;
! 568: if (last_Adj != TimeAdjustment) {
! 569: last_Adj = TimeAdjustment;
! 570: DPRINTF(1, ("SetSystemTimeAdjustment(%+ld)\n", TimeAdjustment));
! 571: rc = !SetSystemTimeAdjustment(clockperiod + TimeAdjustment, FALSE);
! 572: }
! 573: else rc = 0;
! 574: if (rc)
! 575: {
! 576: msyslog(LOG_ERR, "Can't adjust time: %m");
! 577: return 0;
! 578: }
! 579: else {
! 580: sys_residual = dtemp / 1e6;
! 581: }
! 582:
! 583: DPRINTF(6, ("adj_systime: adj %.9f -> remaining residual %.9f\n",
! 584: now, sys_residual));
! 585:
! 586: return 1;
! 587: }
! 588:
! 589:
! 590: void
! 591: init_winnt_time(void)
! 592: {
! 593: static const char settod[] = "settimeofday=\"SetSystemTime\"";
! 594: char szMsgPath[MAX_PATH+1];
! 595: HANDLE hToken = INVALID_HANDLE_VALUE;
! 596: TOKEN_PRIVILEGES tkp;
! 597: TIMECAPS tc;
! 598: BOOL noslew;
! 599: DWORD adjclockperiod;
! 600: LARGE_INTEGER Freq;
! 601: FT_ULL initial_hectonanosecs;
! 602: FT_ULL next_hectonanosecs;
! 603: double adjppm;
! 604: double rawadj;
! 605: char * pch;
! 606:
! 607: if (winnt_time_initialized)
! 608: return;
! 609:
! 610: /*
! 611: * Make sure the service is initialized
! 612: * before we do anything else
! 613: */
! 614: ntservice_init();
! 615:
! 616: /* Set up the Console Handler */
! 617: if (!SetConsoleCtrlHandler(OnConsoleEvent, TRUE))
! 618: {
! 619: msyslog(LOG_ERR, "Can't set console control handler: %m");
! 620: }
! 621:
! 622: /* Set the Event-ID message-file name. */
! 623: if (!GetModuleFileName(NULL, szMsgPath, sizeof(szMsgPath)))
! 624: {
! 625: msyslog(LOG_ERR, "GetModuleFileName(PGM_EXE_FILE) failed: %m\n");
! 626: exit(1);
! 627: }
! 628:
! 629: /* Initialize random file before OpenSSL checks */
! 630: if (!init_randfile())
! 631: msyslog(LOG_ERR, "Unable to initialize .rnd file\n");
! 632:
! 633: #pragma warning(push)
! 634: #pragma warning(disable: 4127) /* conditional expression is constant */
! 635:
! 636: #ifdef DEBUG
! 637: if (SIZEOF_TIME_T != sizeof(time_t)
! 638: || SIZEOF_INT != sizeof(int)
! 639: || SIZEOF_SIGNED_CHAR != sizeof(char)) {
! 640:
! 641: msyslog(LOG_ERR, "config.h SIZEOF_* macros wrong, fatal");
! 642: exit(1);
! 643: }
! 644: #endif
! 645:
! 646: #pragma warning(pop)
! 647:
! 648: /*
! 649: * Get privileges needed for fiddling with the clock
! 650: */
! 651:
! 652: /* get the current process token handle */
! 653: if (!OpenProcessToken(GetCurrentProcess(),
! 654: TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
! 655: {
! 656: msyslog(LOG_ERR, "OpenProcessToken failed: %m");
! 657: exit(-1);
! 658: }
! 659: /* get the LUID for system-time privilege. */
! 660: LookupPrivilegeValue(NULL, SE_SYSTEMTIME_NAME, &tkp.Privileges[0].Luid);
! 661: tkp.PrivilegeCount = 1; /* one privilege to set */
! 662: tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
! 663:
! 664: /* get set-time privilege for this process. */
! 665: AdjustTokenPrivileges(hToken, FALSE, &tkp, 0,
! 666: (PTOKEN_PRIVILEGES) NULL, 0);
! 667:
! 668: /* cannot use return value of AdjustTokenPrivileges. */
! 669: /* (success does not indicate all privileges were set) */
! 670: if (GetLastError() != ERROR_SUCCESS)
! 671: {
! 672: msyslog(LOG_ERR, "AdjustTokenPrivileges failed: %m");
! 673: /* later set time call will probably fail */
! 674: }
! 675:
! 676: CloseHandle(hToken);
! 677: hToken = INVALID_HANDLE_VALUE;
! 678:
! 679: /*
! 680: * Say how we're setting the time of day
! 681: */
! 682: set_sys_var(settod, sizeof(settod), RO);
! 683:
! 684: /*
! 685: * ntpd on Windows has always raised its priority, without
! 686: * requiring -N as on Unix. Since Windows ntpd doesn't share
! 687: * the history of unix ntpd of once having no -N and therefore
! 688: * needing to be invoked under nice, there is no reason to
! 689: * bring it in line with the Unix version in this regard.
! 690: * Instsrv assumes ntpd is invoked with no arguments, and
! 691: * upgrading users would be negatively surprised by the
! 692: * poor timekeeping if they failed to add -N as part of
! 693: * upgrading were we to correct this platform difference.
! 694: */
! 695: if (-1 == setpriority(PRIO_PROCESS, 0, NTP_PRIO))
! 696: exit(-1);
! 697:
! 698: /*
! 699: * register with libntp ntp_set_tod() to call us back
! 700: * when time is stepped.
! 701: */
! 702: step_callback = time_stepped;
! 703:
! 704: /*
! 705: * before we start looking at clock period, do any multimedia
! 706: * timer manipulation requested via -M option.
! 707: */
! 708: if (modify_mm_timer) {
! 709:
! 710: if (timeGetDevCaps(&tc, sizeof(tc)) == TIMERR_NOERROR) {
! 711:
! 712: wTimerRes = min(max(tc.wPeriodMin, MM_TIMER_INTV), tc.wPeriodMax);
! 713: timeBeginPeriod(wTimerRes);
! 714: atexit(atexit_revert_mm_timer);
! 715:
! 716: msyslog(LOG_INFO, "MM timer resolution: %u..%u msec, set to %u msec",
! 717: tc.wPeriodMin, tc.wPeriodMax, wTimerRes );
! 718: } else
! 719: msyslog(LOG_ERR, "Multimedia timer unavailable");
! 720: }
! 721:
! 722: /* get the performance counter ticks per second */
! 723: if (!QueryPerformanceFrequency(&Freq) || !Freq.QuadPart)
! 724: {
! 725: msyslog(LOG_ERR, "QueryPerformanceFrequency failed: %m\n");
! 726: exit(-1);
! 727: }
! 728:
! 729: NomPerfCtrFreq = PerfCtrFreq = Freq.QuadPart;
! 730: /*
! 731: * the cast to LONGLONG is for VC6 compatibility:
! 732: * nt_clockstuff.c(586) : error C2520: conversion from
! 733: * unsigned __int64 to double not implemented, use signed
! 734: * __int64
! 735: */
! 736: msyslog(LOG_INFO,
! 737: "Performance counter frequency %.3f MHz",
! 738: (LONGLONG)PerfCtrFreq / 1e6);
! 739:
! 740: /* Determine the existing system time slewing */
! 741: if (!GetSystemTimeAdjustment(&adjclockperiod, &clockperiod, &noslew))
! 742: {
! 743: msyslog(LOG_ERR, "GetSystemTimeAdjustment failed: %m\n");
! 744: exit(-1);
! 745: }
! 746:
! 747: /*
! 748: * If there is no slewing before ntpd, adjclockperiod and clockperiod
! 749: * will be equal. Any difference is carried into adj_systime's first
! 750: * pass as the previous adjustment.
! 751: */
! 752: last_Adj = adjclockperiod - clockperiod;
! 753:
! 754: if (last_Adj)
! 755: msyslog(LOG_INFO,
! 756: "Clock interrupt period %.3f msec "
! 757: "(startup slew %.1f usec/period)",
! 758: clockperiod / 1e4,
! 759: last_Adj / 10.);
! 760: else
! 761: msyslog(LOG_INFO,
! 762: "Clock interrupt period %.3f msec",
! 763: clockperiod / 1e4);
! 764:
! 765: /*
! 766: * Calculate the time adjustment resulting from incrementing
! 767: * units per tick by 1 unit for 1 second
! 768: */
! 769: ppm_per_adjust_unit = 1e6 / clockperiod;
! 770:
! 771: /*
! 772: * Spin on GetSystemTimeAsFileTime to determine its
! 773: * granularity. Prior to Windows Vista this is
! 774: * typically the same as the clock period.
! 775: */
! 776: GetSystemTimeAsFileTime(&initial_hectonanosecs.ft);
! 777: do {
! 778: GetSystemTimeAsFileTime(&next_hectonanosecs.ft);
! 779: } while (initial_hectonanosecs.ull == next_hectonanosecs.ull);
! 780:
! 781: os_clock_precision = next_hectonanosecs.ull -
! 782: initial_hectonanosecs.ull;
! 783:
! 784: msyslog(LOG_INFO,
! 785: "Windows clock precision %.3f msec, min. slew %.3f ppm/s",
! 786: (LONGLONG)os_clock_precision / 1e4,
! 787: ppm_per_adjust_unit);
! 788:
! 789: pch = getenv("NTPD_TICKADJ_PPM");
! 790: if (pch != NULL && 1 == sscanf(pch, "%lf", &adjppm)) {
! 791: rawadj = adjppm / ppm_per_adjust_unit;
! 792: rawadj += (rawadj < 0)
! 793: ? -0.5
! 794: : 0.5;
! 795: wintickadj = (long)rawadj;
! 796: msyslog(LOG_INFO,
! 797: "Using NTPD_TICKADJ_PPM %+g ppm (%+ld)",
! 798: adjppm, wintickadj);
! 799: }
! 800:
! 801: winnt_time_initialized = TRUE;
! 802:
! 803: choose_interp_counter();
! 804:
! 805: if (getenv("NTPD_USE_SYSTEM_CLOCK") ||
! 806: (os_clock_precision < 4 * 10000 &&
! 807: !getenv("NTPD_USE_INTERP_DANGEROUS"))) {
! 808: msyslog(LOG_INFO, "using Windows clock directly");
! 809: } else {
! 810: winnt_use_interpolation = TRUE;
! 811: get_sys_time_as_filetime = GetInterpTimeAsFileTime;
! 812: StartClockThread();
! 813: }
! 814: }
! 815:
! 816:
! 817: void
! 818: atexit_revert_mm_timer(void)
! 819: {
! 820: timeEndPeriod(wTimerRes);
! 821: DPRINTF(1, ("MM timer resolution reset\n"));
! 822: }
! 823:
! 824:
! 825: void
! 826: reset_winnt_time(void)
! 827: {
! 828: SYSTEMTIME st;
! 829:
! 830: /*
! 831: * If we're in the 2-second slew right after a leap second,
! 832: * we don't want to continue that extreme slew, in that case
! 833: * disable our slewing and return clock discipline to the
! 834: * kernel. Similarly if we are not yet synchronized,
! 835: * our current slew may not be a good ongoing trim.
! 836: * Otherwise, our leave in place the last SetSystemTimeAdjustment
! 837: * as an ongoing frequency correction, better than nothing.
! 838: * TODO:
! 839: * Verify this will not call SetSystemTimeAdjustment if
! 840: * ntpd is running in ntpdate mode.
! 841: */
! 842: if (sys_leap == LEAP_NOTINSYNC || ls_time_adjustment)
! 843: SetSystemTimeAdjustment(0, TRUE);
! 844:
! 845: /*
! 846: * Read the current system time, and write it back to
! 847: * force CMOS update, only if we are exiting because
! 848: * the computer is shutting down and we are already
! 849: * synchronized.
! 850: */
! 851: if (ntservice_systemisshuttingdown() && sys_leap != LEAP_NOTINSYNC) {
! 852: GetSystemTime(&st);
! 853: SetSystemTime(&st);
! 854: NLOG(NLOG_SYSEVENT | NLOG_CLOCKINFO)
! 855: msyslog(LOG_NOTICE, "system is shutting down, CMOS time reset.");
! 856: }
! 857: }
! 858:
! 859:
! 860: /*
! 861: * GetSystemTimeAsFileTime() interface clone is used by getclock() in ntpd.
! 862: */
! 863:
! 864: void WINAPI
! 865: GetInterpTimeAsFileTime(
! 866: LPFILETIME pft
! 867: )
! 868: {
! 869: FT_ULL now_time;
! 870: FT_ULL now_count;
! 871:
! 872: /* Mark a mark ASAP. The latency to here should
! 873: * be reasonably deterministic
! 874: */
! 875:
! 876: now_count.ull = perf_ctr();
! 877: now_time.ull = interp_time(now_count.ull, TRUE);
! 878:
! 879: if (last_interp_time > now_time.ull) {
! 880:
! 881: clock_backward_count++;
! 882: if (last_interp_time - now_time.ull > clock_backward_max)
! 883: clock_backward_max = last_interp_time - now_time.ull;
! 884: now_time.ull = last_interp_time;
! 885: } else
! 886: last_interp_time = now_time.ull;
! 887:
! 888: *pft = now_time.ft;
! 889: return;
! 890: }
! 891:
! 892:
! 893: /*
! 894: * TimerApcFunction is invoked on the high-priority clock
! 895: * thread to capture a new baseline system time and
! 896: * performance counter correlation every 43 msec (64Hz
! 897: * OS clock precision).
! 898: */
! 899: static void CALLBACK
! 900: TimerApcFunction(
! 901: LPVOID lpArgToCompletionRoutine,
! 902: DWORD dwTimerLowValue,
! 903: DWORD dwTimerHighValue
! 904: )
! 905: {
! 906: static BOOL ctr_freq_timer_started = FALSE;
! 907: static ULONGLONG prev_count;
! 908: ULONGLONG now_time;
! 909: FT_ULL now_count;
! 910:
! 911: /* Grab the counter first of all */
! 912: now_count.ull = perf_ctr();
! 913:
! 914: now_time = (((ULONGLONG)dwTimerHighValue << 32) |
! 915: dwTimerLowValue);
! 916:
! 917: /*
! 918: * Save this correlation in the history.
! 919: */
! 920: add_counter_time_pair(now_count.ull, now_time);
! 921:
! 922: /*
! 923: * Once we're synchronized start the counter frequency
! 924: * tuning timer.
! 925: */
! 926: if (INVALID_HANDLE_VALUE == ctr_freq_timer &&
! 927: LEAP_NOTINSYNC != sys_leap)
! 928:
! 929: start_ctr_freq_timer(now_time);
! 930: }
! 931:
! 932:
! 933: unsigned WINAPI
! 934: ClockThread(
! 935: void *arg
! 936: )
! 937: {
! 938: LARGE_INTEGER DueTime;
! 939: HANDLE timer;
! 940: double HZ;
! 941: double TimerHz;
! 942: DWORD timer_period_msec;
! 943: DWORD res;
! 944: char *ntpd_int_int_text;
! 945:
! 946: UNUSED_ARG(arg);
! 947:
! 948: timer = CreateWaitableTimer(NULL, FALSE, NULL);
! 949:
! 950: ntpd_int_int_text = getenv("NTPD_INT_INT");
! 951:
! 952: HZ = (double)HECTONANOSECONDS / clockperiod;
! 953:
! 954: if (HZ > 63 && HZ < 65) {
! 955: timer_period_msec = 43;
! 956: } else if (HZ > 98 && HZ < 102) {
! 957: timer_period_msec = 27;
! 958: if (!ntpd_int_int_text)
! 959: msyslog(LOG_WARNING,
! 960: "%.3f Hz system clock may benefit from "
! 961: "custom NTPD_INT_INT env var timer interval "
! 962: "override between approx. 20 and 50 msecs.",
! 963: HZ);
! 964: } else {
! 965: timer_period_msec = (DWORD)(0.5 + (2.752 * clockperiod / 10000));
! 966: if (!ntpd_int_int_text)
! 967: msyslog(LOG_WARNING,
! 968: "unfamiliar %.3f Hz system clock may benefit "
! 969: "from custom NTPD_INT_INT env var timer "
! 970: "interval override between approx. 20 and 50 "
! 971: "msecs.",
! 972: HZ);
! 973: }
! 974:
! 975: if (ntpd_int_int_text) {
! 976: timer_period_msec = atoi(ntpd_int_int_text);
! 977: timer_period_msec = max(9, timer_period_msec);
! 978: msyslog(LOG_NOTICE,
! 979: "using NTPD_INT_INT env var override %u",
! 980: timer_period_msec);
! 981: }
! 982:
! 983: TimerHz = 1e3 / timer_period_msec;
! 984: msyslog(LOG_NOTICE, "HZ %.3f using %u msec timer %.3f Hz %d deep",
! 985: HZ,
! 986: timer_period_msec,
! 987: TimerHz,
! 988: BASELINES_USED);
! 989:
! 990: /* negative DueTime means relative to now */
! 991: DueTime.QuadPart = -(int)timer_period_msec;
! 992:
! 993: SetWaitableTimer(
! 994: timer,
! 995: &DueTime, /* first fire */
! 996: timer_period_msec, /* period thereafter */
! 997: TimerApcFunction, /* callback routine */
! 998: &timer, /* context for callback */
! 999: FALSE); /* do not interfere with power saving */
! 1000:
! 1001: /*
! 1002: * The clock thread spends the rest of its life in the TimerApcFunction
! 1003: * and ctr_freq_timer_fired timer APC callbacks, which can only occur
! 1004: * while this thread is in an alertable wait. Note the Ex on
! 1005: * WaitForSingleObjectEx and TRUE for fAlertable. The wait will return
! 1006: * after each APC callback in which case we simply wait again. We will
! 1007: * break out of the loop when StopClockThread signals our exit event.
! 1008: */
! 1009: do res = WaitForSingleObjectEx(
! 1010: TimerThreadExitRequest,
! 1011: INFINITE,
! 1012: TRUE);
! 1013: while (WAIT_OBJECT_0 != res);
! 1014:
! 1015: CloseHandle(timer);
! 1016:
! 1017: if (ctr_freq_timer != INVALID_HANDLE_VALUE) {
! 1018: CloseHandle(ctr_freq_timer);
! 1019: ctr_freq_timer = INVALID_HANDLE_VALUE;
! 1020: }
! 1021:
! 1022: return 0;
! 1023: }
! 1024:
! 1025:
! 1026: static void
! 1027: StartClockThread(void)
! 1028: {
! 1029: static BOOL done_once = FALSE;
! 1030: FT_ULL StartTime;
! 1031:
! 1032: /* init variables with the time now */
! 1033: GetSystemTimeAsFileTime(&StartTime.ft);
! 1034: baseline_times[0] = StartTime.ull;
! 1035: baseline_counts[0] = perf_ctr();
! 1036:
! 1037: /* init sync objects */
! 1038: TimerThreadExitRequest = CreateEvent(NULL, FALSE, FALSE, NULL);
! 1039:
! 1040: clock_thread =
! 1041: (HANDLE)_beginthreadex(
! 1042: NULL,
! 1043: 0,
! 1044: ClockThread,
! 1045: NULL,
! 1046: CREATE_SUSPENDED,
! 1047: &clock_thread_id);
! 1048:
! 1049: if (clock_thread != NULL) {
! 1050: /* remember the thread priority is only within the process class */
! 1051: if (!SetThreadPriority(clock_thread, THREAD_PRIORITY_TIME_CRITICAL)) {
! 1052: DPRINTF(1, ("Error setting thread priority\n"));
! 1053: }
! 1054:
! 1055: lock_thread_to_processor(clock_thread);
! 1056: ResumeThread(clock_thread);
! 1057:
! 1058: if (FALSE == done_once) {
! 1059: done_once = TRUE;
! 1060: lock_thread_to_processor(GetCurrentThread());
! 1061: atexit( StopClockThread );
! 1062: }
! 1063:
! 1064: /*
! 1065: * Give the clock thread time to fill its counter/time
! 1066: * sample buffer. This will underfill the buffer a
! 1067: * bit for sample periods over 43 msec.
! 1068: */
! 1069: Sleep(BASELINES_USED * 43);
! 1070: }
! 1071: }
! 1072:
! 1073:
! 1074: void
! 1075: StopClockThread(void)
! 1076: {
! 1077: /*
! 1078: * if the clock thread exit()s this routine
! 1079: * will be called on the clock thread and
! 1080: * we need not (and can't) use the normal
! 1081: * TimerThreadExitRequest event.
! 1082: */
! 1083: if (GetCurrentThreadId() != clock_thread_id) {
! 1084:
! 1085: if (!SetEvent(TimerThreadExitRequest) ||
! 1086: WaitForSingleObject(clock_thread, 2 * 1000) !=
! 1087: WAIT_OBJECT_0) {
! 1088: msyslog(LOG_ERR, "Failed to stop clock thread.");
! 1089: }
! 1090: }
! 1091: CloseHandle(TimerThreadExitRequest);
! 1092: TimerThreadExitRequest = NULL;
! 1093: CloseHandle(clock_thread);
! 1094: clock_thread = NULL;
! 1095: }
! 1096:
! 1097:
! 1098: void
! 1099: lock_thread_to_processor(HANDLE thread)
! 1100: {
! 1101: static DWORD_PTR ProcessAffinityMask;
! 1102: static DWORD_PTR ThreadAffinityMask;
! 1103: DWORD_PTR SystemAffinityMask;
! 1104: char *cputext;
! 1105: unsigned int cpu;
! 1106:
! 1107: if ( ! winnt_time_initialized) {
! 1108: DPRINTF(1, ("init_winnt_time() must be called before "
! 1109: "lock_thread_to_processor(), exiting\n"));
! 1110: exit(-1);
! 1111: }
! 1112:
! 1113: if ( ! winnt_use_interpolation)
! 1114: return;
! 1115:
! 1116: if (-1 == lock_interp_threads) {
! 1117: DPRINTF(1, ("choose_interp_counter() is not called "
! 1118: "before lock_thread_to_processor()\n"));
! 1119: exit(-1);
! 1120: } else if (!lock_interp_threads)
! 1121: return;
! 1122:
! 1123: /*
! 1124: * Calculate the ThreadAffinityMask we'll use once on the
! 1125: * first invocation.
! 1126: */
! 1127: if ( ! ProcessAffinityMask) {
! 1128:
! 1129: /*
! 1130: * Choose which processor to nail the main and clock threads to.
! 1131: * If we have more than one, we simply choose the 2nd.
! 1132: * Randomly choosing from 2 to n would be better, but in
! 1133: * either case with clock and network interrupts more likely
! 1134: * to be serviced by the first procecssor, let's stay away
! 1135: * from it. QueryPerformanceCounter is not necessarily
! 1136: * consistent across CPUs, hence the need to nail the two
! 1137: * threads involved in QPC-based interpolation to the same
! 1138: * CPU.
! 1139: */
! 1140:
! 1141: GetProcessAffinityMask(
! 1142: GetCurrentProcess(),
! 1143: &ProcessAffinityMask,
! 1144: &SystemAffinityMask);
! 1145:
! 1146: /*
! 1147: * respect NTPD_CPU environment variable if present
! 1148: * for testing. NTPD_CPU=0 means use all CPUs, 1-64
! 1149: * means lock threads involved in interpolation to
! 1150: * that CPU. Default to 2nd if more than 1.
! 1151: */
! 1152:
! 1153: cpu = 2;
! 1154: cputext = getenv("NTPD_CPU");
! 1155: if (cputext) {
! 1156: cpu = (unsigned int) atoi(cputext);
! 1157: cpu = min((8 * sizeof(DWORD_PTR)), cpu);
! 1158: }
! 1159:
! 1160: /*
! 1161: * Clear all bits except the 2nd. If we have only one proc
! 1162: * that leaves ThreadAffinityMask zeroed and we won't bother
! 1163: * with SetThreadAffinityMask.
! 1164: */
! 1165:
! 1166: ThreadAffinityMask = (0 == cpu) ? 0 : (1 << (cpu - 1));
! 1167:
! 1168: if (ThreadAffinityMask &&
! 1169: !(ThreadAffinityMask & ProcessAffinityMask))
! 1170:
! 1171: DPRINTF(1, ("Selected CPU %u (mask %x) is outside "
! 1172: "process mask %x, using all CPUs.\n",
! 1173: cpu, ThreadAffinityMask,
! 1174: ProcessAffinityMask));
! 1175: else
! 1176: DPRINTF(1, ("Wiring to processor %u (0 means all) "
! 1177: "affinity mask %x\n",
! 1178: cpu, ThreadAffinityMask));
! 1179:
! 1180: ThreadAffinityMask &= ProcessAffinityMask;
! 1181: }
! 1182:
! 1183: if (ThreadAffinityMask &&
! 1184: !SetThreadAffinityMask(thread, ThreadAffinityMask))
! 1185:
! 1186: msyslog(LOG_ERR,
! 1187: "Unable to wire thread to mask %x: %m\n",
! 1188: ThreadAffinityMask);
! 1189: }
! 1190:
! 1191:
! 1192: #ifdef HAVE_PPSAPI
! 1193: /*
! 1194: * helper routine for serial PPS which returns QueryPerformanceCounter
! 1195: * timestamp and needs to interpolate it to an NTP timestamp.
! 1196: */
! 1197: void
! 1198: pps_ntp_timestamp_from_counter(
! 1199: ntp_fp_t *result,
! 1200: ULONGLONG Timestamp,
! 1201: ULONGLONG Counterstamp
! 1202: )
! 1203: {
! 1204: /*
! 1205: * convert between equivalent l_fp and PPSAPI ntp_fp_t
! 1206: */
! 1207: ntp_timestamp_from_counter(
! 1208: (l_fp *)result,
! 1209: Timestamp,
! 1210: Counterstamp);
! 1211: }
! 1212:
! 1213:
! 1214: void
! 1215: ntp_timestamp_from_counter(
! 1216: l_fp *result,
! 1217: ULONGLONG Timestamp,
! 1218: ULONGLONG Counterstamp
! 1219: )
! 1220: {
! 1221: #ifdef DEBUG
! 1222: FT_ULL Now;
! 1223: #endif
! 1224: ULONGLONG InterpTimestamp;
! 1225:
! 1226: if (winnt_use_interpolation) {
! 1227: InterpTimestamp = interp_time(Counterstamp + QPC_offset, FALSE);
! 1228:
! 1229: #ifdef DEBUG
! 1230: /* sanity check timestamp is within 1 minute of now */
! 1231: GetSystemTimeAsFileTime(&Now.ft);
! 1232: Now.ll -= InterpTimestamp;
! 1233: if (debug &&
! 1234: Now.ll > 60 * HECTONANOSECONDS ||
! 1235: Now.ll < -60 * (LONGLONG) HECTONANOSECONDS) {
! 1236: DPRINTF(1, ("ntp_timestamp_from_counter interpolated time %.6fs from current\n",
! 1237: Now.ll / (double)LL_HNS));
! 1238: DPRINTF(1, ("interpol time %llx from %llx\n",
! 1239: InterpTimestamp,
! 1240: Counterstamp));
! 1241: msyslog(LOG_ERR,
! 1242: "ntp_timestamp_from_counter interpolated time %.6fs from current\n",
! 1243: Now.ll / (double)LL_HNS);
! 1244: exit(-1);
! 1245: }
! 1246: #endif
! 1247: } else { /* ! winnt_use_interpolation */
! 1248: /* have to simply use the driver's system time timestamp */
! 1249: InterpTimestamp = Timestamp;
! 1250: #ifdef DEBUG
! 1251: /* sanity check timestamp is within 1 minute of now */
! 1252: GetSystemTimeAsFileTime(&Now.ft);
! 1253: Now.ll -= InterpTimestamp;
! 1254: if (Now.ll > 60 * HECTONANOSECONDS ||
! 1255: Now.ll < -60 * (LONGLONG) HECTONANOSECONDS) {
! 1256: DPRINTF(1, ("ntp_timestamp_from_counter serial driver system time %.6fs from current\n",
! 1257: Now.ll / (double)LL_HNS));
! 1258: msyslog(LOG_ERR,
! 1259: "ntp_timestamp_from_counter serial driver system time %.6fs from current\n",
! 1260: Now.ll / (double)LL_HNS);
! 1261: exit(-1);
! 1262: }
! 1263: #endif
! 1264: }
! 1265:
! 1266: /* convert from 100ns units to NTP fixed point format */
! 1267:
! 1268: InterpTimestamp -= FILETIME_1970;
! 1269: result->l_ui = JAN_1970 + (u_int32)(InterpTimestamp / HECTONANOSECONDS);
! 1270: result->l_uf = (u_int32)((InterpTimestamp % HECTONANOSECONDS) *
! 1271: (ULONGLONG)FRAC / HECTONANOSECONDS);
! 1272: }
! 1273: #endif /* HAVE_PPSAPI */
! 1274:
! 1275:
! 1276: void
! 1277: time_stepped(void)
! 1278: {
! 1279: /*
! 1280: * called back by ntp_set_tod after the system
! 1281: * time has been stepped (set).
! 1282: *
! 1283: * We normally prevent the reported time from going backwards
! 1284: * but need to allow it in this case.
! 1285: */
! 1286: if (FALSE == winnt_use_interpolation)
! 1287: return;
! 1288:
! 1289:
! 1290: /*
! 1291: * Restart the clock thread to get a new baseline
! 1292: * time/counter correlation.
! 1293: */
! 1294: StopClockThread();
! 1295:
! 1296: /*
! 1297: * newest_baseline_gen is a generation counter
! 1298: * incremented once each time newest_baseline
! 1299: * is reset.
! 1300: */
! 1301: newest_baseline_gen++;
! 1302:
! 1303: last_interp_time =
! 1304: clock_backward_max =
! 1305: clock_backward_count =
! 1306: newest_baseline = 0;
! 1307:
! 1308: memset(baseline_counts, 0, sizeof(baseline_counts));
! 1309: memset(baseline_times, 0, sizeof(baseline_times));
! 1310:
! 1311: StartClockThread();
! 1312: }
! 1313:
! 1314:
! 1315: /*
! 1316: * log2ull - log base 2 of a unsigned 64-bit number
! 1317: */
! 1318: int
! 1319: log2ull(
! 1320: ULONGLONG n
! 1321: )
! 1322: {
! 1323: const ULONGLONG one = 1;
! 1324: int log = 0;
! 1325:
! 1326: if (n >= one<<32) { n >>= 32; log += 32; }
! 1327: if (n >= one<<16) { n >>= 16; log += 16; }
! 1328: if (n >= one<< 8) { n >>= 8; log += 8; }
! 1329: if (n >= one<< 4) { n >>= 4; log += 4; }
! 1330: if (n >= one<< 2) { n >>= 2; log += 2; }
! 1331: if (n >= one<< 1) { log += 1; }
! 1332:
! 1333: return (n) ? log : (-1);
! 1334: }
! 1335:
! 1336:
! 1337: /*
! 1338: * ctr_freq_timer_fired is called once a few seconds before
! 1339: * tune_ctr_period seconds have elapsed, to reset the timer
! 1340: * and hopefully minimize error due to the system using the
! 1341: * nominal performance counter frequency to set the timer
! 1342: * internally, which is typically dozens of PPM from the
! 1343: * actual performance counter rate. A few seconds later
! 1344: * it is called again to observe the counter and estimate the
! 1345: * counter frequency.
! 1346: */
! 1347: static void CALLBACK
! 1348: ctr_freq_timer_fired(
! 1349: LPVOID arg,
! 1350: DWORD dwTimeLow,
! 1351: DWORD dwTimeHigh
! 1352: )
! 1353: {
! 1354: static FT_ULL begin_time = {0};
! 1355: static FT_ULL begin_count = {0};
! 1356: static ULONGLONG next_period_time = 0;
! 1357: static ULONGLONG report_systemtime = 0;
! 1358: const ULONGLONG five_minutes = 5ui64 * 60 * HECTONANOSECONDS;
! 1359: FT_ULL now_time;
! 1360: FT_ULL now_count;
! 1361:
! 1362: if (!begin_time.ull) {
! 1363: begin_count.ull = perf_ctr();
! 1364: begin_time.ft.dwLowDateTime = dwTimeLow;
! 1365: begin_time.ft.dwHighDateTime = dwTimeHigh;
! 1366:
! 1367: /*
! 1368: * adapt perf ctr observation interval to the
! 1369: * counter frequency
! 1370: */
! 1371: tune_ctr_period = 22680 / log2ull(NomPerfCtrFreq);
! 1372:
! 1373: /*
! 1374: * reset timer 2s before period ends to minimize
! 1375: * error from OS timer routines using nominal
! 1376: * performance frequency internally.
! 1377: */
! 1378: tune_ctr_freq_max_interval = tune_ctr_period - 2;
! 1379:
! 1380: next_period_time = begin_time.ull +
! 1381: (ULONGLONG)tune_ctr_period * HECTONANOSECONDS;
! 1382:
! 1383: ROUND_TO_NEXT_SEC_BOTTOM(next_period_time);
! 1384:
! 1385: reset_ctr_freq_timer(next_period_time, begin_time.ull);
! 1386:
! 1387: return;
! 1388: }
! 1389:
! 1390: now_time.ft.dwLowDateTime = dwTimeLow;
! 1391: now_time.ft.dwHighDateTime = dwTimeHigh;
! 1392:
! 1393: if (now_time.ull >= next_period_time) {
! 1394:
! 1395: now_count.ull = perf_ctr();
! 1396: tune_ctr_freq(
! 1397: now_count.ull - begin_count.ull,
! 1398: now_time.ull - begin_time.ull);
! 1399:
! 1400: next_period_time += (ULONGLONG)tune_ctr_period * HECTONANOSECONDS;
! 1401: begin_count.ull = now_count.ull;
! 1402: begin_time.ull = now_time.ull;
! 1403: }
! 1404:
! 1405: /*
! 1406: * Log clock backward events no more often than 5 minutes.
! 1407: */
! 1408: if (!report_systemtime)
! 1409:
! 1410: report_systemtime = now_time.ull + five_minutes;
! 1411:
! 1412: else if (report_systemtime <= now_time.ull) {
! 1413:
! 1414: report_systemtime += five_minutes;
! 1415:
! 1416: if (clock_backward_count) {
! 1417: msyslog(LOG_WARNING,
! 1418: "clock would have gone backward %d times, "
! 1419: "max %.1f usec",
! 1420: clock_backward_count,
! 1421: (LONGLONG)clock_backward_max / 10.);
! 1422:
! 1423: clock_backward_max = clock_backward_count = 0;
! 1424: }
! 1425: }
! 1426:
! 1427: reset_ctr_freq_timer(next_period_time, now_time.ull);
! 1428: }
! 1429:
! 1430:
! 1431: void
! 1432: reset_ctr_freq_timer_abs(
! 1433: ULONGLONG when
! 1434: )
! 1435: {
! 1436: FT_ULL fire_time;
! 1437:
! 1438: fire_time.ull = when;
! 1439:
! 1440: SetWaitableTimer(
! 1441: ctr_freq_timer,
! 1442: &fire_time.li, /* first fire */
! 1443: 0, /* not periodic */
! 1444: ctr_freq_timer_fired, /* callback routine */
! 1445: NULL, /* context for callback */
! 1446: FALSE); /* do not interfere with power saving */
! 1447: }
! 1448:
! 1449:
! 1450: void
! 1451: reset_ctr_freq_timer(
! 1452: ULONGLONG when,
! 1453: ULONGLONG now
! 1454: )
! 1455: {
! 1456: if (when - now >
! 1457: (tune_ctr_freq_max_interval * HECTONANOSECONDS + HECTONANOSECONDS))
! 1458:
! 1459: when = now + tune_ctr_freq_max_interval * HECTONANOSECONDS;
! 1460:
! 1461: reset_ctr_freq_timer_abs(when);
! 1462: }
! 1463:
! 1464:
! 1465: void
! 1466: start_ctr_freq_timer(
! 1467: ULONGLONG now_time
! 1468: )
! 1469: {
! 1470: ULONGLONG when;
! 1471:
! 1472: ctr_freq_timer = CreateWaitableTimer(NULL, FALSE, NULL);
! 1473:
! 1474: when = now_time;
! 1475: ROUND_TO_NEXT_SEC_BOTTOM(when);
! 1476:
! 1477: reset_ctr_freq_timer_abs(when);
! 1478: }
! 1479:
! 1480:
! 1481: /*
! 1482: * tune_ctr_freq is called once per tune_ctr_period seconds
! 1483: * with a counter difference and time difference.
! 1484: */
! 1485: void
! 1486: tune_ctr_freq(
! 1487: LONGLONG ctr_delta,
! 1488: LONGLONG time_delta
! 1489: )
! 1490: {
! 1491: static unsigned count = 0;
! 1492: static unsigned dispcount = 0;
! 1493: static unsigned report_at_count = 0;
! 1494: static int disbelieved = 0;
! 1495: static int i = 0;
! 1496: static double nom_freq = 0;
! 1497: static LONGLONG diffs[TUNE_CTR_DEPTH] = {0};
! 1498: static LONGLONG sum = 0;
! 1499:
! 1500: LONGLONG delta;
! 1501: LONGLONG deltadiff;
! 1502: ULONGLONG ObsPerfCtrFreq;
! 1503: double obs_freq;
! 1504: double this_freq;
! 1505: int isneg;
! 1506:
! 1507: /* one-time initialization */
! 1508: if (!report_at_count) {
! 1509: report_at_count = 24 * 60 * 60 / tune_ctr_period;
! 1510: nom_freq = (LONGLONG)NomPerfCtrFreq / 1e6;
! 1511: }
! 1512:
! 1513: /* delta is the per-second observed frequency this time */
! 1514: delta = (LONGLONG)((double)ctr_delta * HECTONANOSECONDS /
! 1515: time_delta);
! 1516:
! 1517: /* disbelieve any delta more than +/- 976 PPM from nominal */
! 1518: deltadiff = delta - NomPerfCtrFreq;
! 1519: if (0 > deltadiff) {
! 1520: isneg = 1;
! 1521: deltadiff = -deltadiff;
! 1522: } else
! 1523: isneg = 0;
! 1524:
! 1525: if ((ULONGLONG)deltadiff > (NomPerfCtrFreq / 1024)) {
! 1526: disbelieved++;
! 1527: dispcount++;
! 1528: #ifdef DEBUG
! 1529: msyslog(LOG_DEBUG, "ctr delta %s%lld exceeds limit %llu",
! 1530: (isneg) ? "-" : "",
! 1531: deltadiff,
! 1532: NomPerfCtrFreq / 1024);
! 1533: #endif
! 1534: } else {
! 1535:
! 1536: /*
! 1537: * collect average over TUNE_CTR_DEPTH samples
! 1538: * for our PerfCtrFreq trimming.
! 1539: */
! 1540:
! 1541: if (isneg)
! 1542: deltadiff = -deltadiff;
! 1543: sum -= diffs[i];
! 1544: diffs[i] = deltadiff;
! 1545: sum += deltadiff;
! 1546: i = (i + 1) % COUNTOF(diffs);
! 1547: count++;
! 1548: dispcount++;
! 1549: }
! 1550:
! 1551: this_freq = delta / 1e6;
! 1552:
! 1553: ObsPerfCtrFreq = NomPerfCtrFreq + (sum / COUNTOF(diffs));
! 1554:
! 1555: #if 1 /* #if 0 to disable changing freq used */
! 1556: /* get rid of ObsPerfCtrFreq when removing the #ifdef */
! 1557: PerfCtrFreq = ObsPerfCtrFreq;
! 1558: #endif
! 1559: obs_freq = (LONGLONG)ObsPerfCtrFreq / 1e6;
! 1560:
! 1561: /*
! 1562: * report observed ctr freq each time the estimate used during
! 1563: * startup moves toward the observed freq from the nominal,
! 1564: * and once a day afterward.
! 1565: */
! 1566:
! 1567: if (count > COUNTOF(diffs) &&
! 1568: /* (count % COUNTOF(diffs)) && */ /* enables reporting each */
! 1569: dispcount < report_at_count) /* TUNE_CTR_DEPTH samples */
! 1570: return;
! 1571:
! 1572: NLOG(NLOG_CLOCKINFO)
! 1573: if (count <= COUNTOF(diffs))
! 1574: /* moving to observed freq. from nominal (startup) */
! 1575: msyslog(LOG_INFO,
! 1576: (obs_freq > 100)
! 1577: ? "ctr %.3f MHz %+6.2f PPM using "
! 1578: "%.3f MHz %+6.2f PPM"
! 1579: : "ctr %.6f MHz %+6.2f PPM using "
! 1580: "%.6f MHz %+6.2f PPM",
! 1581: this_freq,
! 1582: 1e6 * (this_freq - nom_freq) / nom_freq,
! 1583: obs_freq,
! 1584: 1e6 * (obs_freq - nom_freq) / nom_freq);
! 1585: else
! 1586: /* steady state */
! 1587: msyslog(LOG_INFO,
! 1588: (obs_freq > 100)
! 1589: ? "ctr %.3f MHz %+.2f PPM"
! 1590: : "ctr %.6f MHz %+.2f PPM",
! 1591: obs_freq,
! 1592: 1e6 * (obs_freq - nom_freq) / nom_freq);
! 1593:
! 1594: if (disbelieved) {
! 1595: msyslog(LOG_ERR,
! 1596: "%d ctr samples exceed +/- 976 PPM range gate",
! 1597: disbelieved);
! 1598: disbelieved = 0;
! 1599: }
! 1600:
! 1601: dispcount = 0;
! 1602: }
! 1603:
! 1604:
! 1605: /*
! 1606: * add_counter_time_pair is called by the
! 1607: * high priority clock thread with each new
! 1608: * baseline counter/time correlation.
! 1609: */
! 1610: void
! 1611: add_counter_time_pair(
! 1612: ULONGLONG ctr,
! 1613: LONGLONG time
! 1614: )
! 1615: {
! 1616: int i;
! 1617:
! 1618: i = (newest_baseline + 1) % BASELINES_TOT;
! 1619:
! 1620: baseline_counts[i] = ctr;
! 1621: baseline_times[i] = time;
! 1622:
! 1623: newest_baseline = i;
! 1624: }
! 1625:
! 1626:
! 1627: /*
! 1628: * interp_time estimates NT time in 100ns units
! 1629: * based on a performance counter value given.
! 1630: * This must tolerate recent historical counters
! 1631: * as well as current. When current is FALSE
! 1632: * we can't assume ctr is the latest/highest
! 1633: * seen.
! 1634: */
! 1635: ULONGLONG
! 1636: interp_time(
! 1637: ULONGLONG ctr,
! 1638: BOOL current
! 1639: )
! 1640: {
! 1641: static __declspec(thread) int last_newest = -1;
! 1642: static __declspec(thread) int last_newest_gen;
! 1643: static __declspec(thread) int best_index;
! 1644: ULONGLONG this_ctr;
! 1645: LONGLONG this_time;
! 1646: LONGLONG latest_time;
! 1647: LONGLONG ctr_diff;
! 1648: int i;
! 1649: int i_gen;
! 1650: int c;
! 1651:
! 1652: /*
! 1653: * Use the system time (roughly synchronised to the tick, and
! 1654: * extrapolated using the system performance counter.
! 1655: *
! 1656: * Cache the results per thread and only repeat the
! 1657: * calculation when new data has arrived.
! 1658: */
! 1659: i = newest_baseline;
! 1660: i_gen = newest_baseline_gen;
! 1661:
! 1662: if (last_newest == i && last_newest_gen == i_gen) {
! 1663: this_time = baseline_times[best_index];
! 1664: ctr_diff = ctr - baseline_counts[best_index];
! 1665: this_time += (LONGLONG)PERF2HNS((double)ctr_diff);
! 1666:
! 1667: return this_time;
! 1668: }
! 1669:
! 1670: last_newest = i;
! 1671: last_newest_gen = i_gen;
! 1672:
! 1673: latest_time = 0;
! 1674:
! 1675: /*
! 1676: * Run through the history calculating the interpolated
! 1677: * time based on each counter/time correlation in turn,
! 1678: * and believe the latest one. This is akin to the NTP
! 1679: * protocol minimum delay clock filter. Errors due to
! 1680: * counter/time correlations with stale time are all
! 1681: * negative.
! 1682: */
! 1683: for (c = 0; c < BASELINES_USED; c++) {
! 1684: if (baseline_times[i]) {
! 1685: this_time = baseline_times[i];
! 1686: this_ctr = baseline_counts[i];
! 1687:
! 1688: ctr_diff = ctr - this_ctr;
! 1689:
! 1690: if (current && ctr_diff < 0) {
! 1691: /*
! 1692: * The performance counter apparently went
! 1693: * backwards without rolling over. It might
! 1694: * be nice to complain but we don't want
! 1695: * to do it repeatedly.
! 1696: */
! 1697: ctr_diff = 0;
! 1698: }
! 1699:
! 1700: this_time += (LONGLONG)PERF2HNS((double)ctr_diff);
! 1701:
! 1702: if (this_time > latest_time) {
! 1703: latest_time = this_time;
! 1704: best_index = i;
! 1705: }
! 1706: }
! 1707: i = i ? (i - 1) : (BASELINES_TOT - 1);
! 1708: }
! 1709:
! 1710: return latest_time;
! 1711: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to nt_clockstuff.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ports / winnt / ntpd