VirtualBox

source: vbox/trunk/src/VBox/Additions/common/VBoxService/VBoxServiceTimeSync.cpp@ 63206

Last change on this file since 63206 was 62679, checked in by vboxsync, 8 years ago

Use the iprt/win/windows.h wrapper for Windows.h
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 27.0 KB
Line 
1/* $Id: VBoxServiceTimeSync.cpp 62679 2016-07-29 12:52:10Z vboxsync $ */
2/** @file
3 * VBoxService - Guest Additions TimeSync Service.
4 */
5
6/*
7 * Copyright (C) 2007-2016 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18
19/** @page pg_vgsvc_timesync VBoxService - The Time Sync Service
20 *
21 * The time sync subservice synchronizes the guest OS walltime with the host.
22 *
23 * The time sync service plays along with the Time Manager (TM) in the VMM
24 * to keep the guest time accurate using the host machine as reference.
25 * Communication is facilitated by VMMDev. TM will try its best to make sure
26 * all timer ticks gets delivered so that there isn't normally any need to
27 * adjust the guest time.
28 *
29 * There are three normal (= acceptable) cases:
30 * -# When the service starts up. This is because ticks and such might
31 * be lost during VM and OS startup. (Need to figure out exactly why!)
32 * -# When the TM is unable to deliver all the ticks and swallows a
33 * backlog of ticks. The threshold for this is configurable with
34 * a default of 60 seconds.
35 * -# The time is adjusted on the host. This can be caused manually by
36 * the user or by some time sync daemon (NTP, LAN server, etc.).
37 *
38 * There are a number of very odd case where adjusting is needed. Here
39 * are some of them:
40 * -# Timer device emulation inaccuracies (like rounding).
41 * -# Inaccuracies in time source VirtualBox uses.
42 * -# The Guest and/or Host OS doesn't perform proper time keeping. This
43 * come about as a result of OS and/or hardware issues.
44 *
45 * The TM is our source for the host time and will make adjustments for
46 * current timer delivery lag. The simplistic approach taken by TM is to
47 * adjust the host time by the current guest timer delivery lag, meaning that
48 * if the guest is behind 1 second with PIT/RTC/++ ticks this should be reflected
49 * in the guest wall time as well.
50 *
51 * Now, there is any amount of trouble we can cause by changing the time.
52 * Most applications probably uses the wall time when they need to measure
53 * things. A walltime that is being juggled about every so often, even if just
54 * a little bit, could occasionally upset these measurements by for instance
55 * yielding negative results.
56 *
57 * This bottom line here is that the time sync service isn't really supposed
58 * to do anything and will try avoid having to do anything when possible.
59 *
60 * The implementation uses the latency it takes to query host time as the
61 * absolute maximum precision to avoid messing up under timer tick catchup
62 * and/or heavy host/guest load. (Rational is that a *lot* of stuff may happen
63 * on our way back from ring-3 and TM/VMMDev since we're taking the route
64 * thru the inner EM loop with it's force action processing.)
65 *
66 * But this latency has to be measured from our perspective, which means it
67 * could just as easily come out as 0. (OS/2 and Windows guest only updates
68 * the current time when the timer ticks for instance.) The good thing is
69 * that this isn't really a problem since we won't ever do anything unless
70 * the drift is noticeable.
71 *
72 * It now boils down to these three (configuration) factors:
73 * -# g_TimeSyncMinAdjust - The minimum drift we will ever bother with.
74 * -# g_TimeSyncLatencyFactor - The factor we multiply the latency by to
75 * calculate the dynamic minimum adjust factor.
76 * -# g_TimeSyncMaxLatency - When to start discarding the data as utterly
77 * useless and take a rest (someone is too busy to give us good data).
78 * -# g_TimeSyncSetThreshold - The threshold at which we will just set the time
79 * instead of trying to adjust it (milliseconds).
80 */
81
82
83/*********************************************************************************************************************************
84* Header Files *
85*********************************************************************************************************************************/
86#ifdef RT_OS_WINDOWS
87# include <iprt/win/windows.h>
88#else
89# include <unistd.h>
90# include <errno.h>
91# include <time.h>
92# include <sys/time.h>
93#endif
94
95#include <iprt/thread.h>
96#include <iprt/string.h>
97#include <iprt/semaphore.h>
98#include <iprt/time.h>
99#include <iprt/assert.h>
100#include <VBox/VBoxGuestLib.h>
101#include "VBoxServiceInternal.h"
102#include "VBoxServiceUtils.h"
103
104
105/*********************************************************************************************************************************
106* Global Variables *
107*********************************************************************************************************************************/
108/** The timesync interval (milliseconds). */
109static uint32_t g_TimeSyncInterval = 0;
110/**
111 * @see pg_vboxservice_timesync
112 *
113 * @remark OS/2: There is either a 1 second resolution on the DosSetDateTime
114 * API or a bug in my settimeofday implementation. Thus, don't
115 * bother unless there is at least a 1 second drift.
116 */
117#ifdef RT_OS_OS2
118static uint32_t g_TimeSyncMinAdjust = 1000;
119#else
120static uint32_t g_TimeSyncMinAdjust = 100;
121#endif
122/** @see pg_vboxservice_timesync */
123static uint32_t g_TimeSyncLatencyFactor = 8;
124/** @see pg_vboxservice_timesync */
125static uint32_t g_TimeSyncMaxLatency = 250;
126/** @see pg_vboxservice_timesync */
127static uint32_t g_TimeSyncSetThreshold = 20*60*1000;
128/** Whether the next adjustment should just set the time instead of trying to
129 * adjust it. This is used to implement --timesync-set-start. */
130static bool volatile g_fTimeSyncSetNext = false;
131/** Whether to set the time when the VM was restored. */
132static bool g_fTimeSyncSetOnRestore = true;
133
134/** Current error count. Used to knowing when to bitch and when not to. */
135static uint32_t g_cTimeSyncErrors = 0;
136
137/** The semaphore we're blocking on. */
138static RTSEMEVENTMULTI g_TimeSyncEvent = NIL_RTSEMEVENTMULTI;
139
140/** The VM session ID. Changes whenever the VM is restored or reset. */
141static uint64_t g_idTimeSyncSession;
142
143#ifdef RT_OS_WINDOWS
144/** Process token. */
145static HANDLE g_hTokenProcess = NULL;
146/** Old token privileges. */
147static TOKEN_PRIVILEGES g_TkOldPrivileges;
148/** Backup values for time adjustment. */
149static DWORD g_dwWinTimeAdjustment;
150static DWORD g_dwWinTimeIncrement;
151static BOOL g_bWinTimeAdjustmentDisabled;
152#endif
153
154
155/**
156 * @interface_method_impl{VBOXSERVICE,pfnPreInit}
157 */
158static DECLCALLBACK(int) vgsvcTimeSyncPreInit(void)
159{
160#ifdef VBOX_WITH_GUEST_PROPS
161 /** @todo Merge this function with vgsvcTimeSyncOption() to generalize
162 * the "command line args override guest property values" behavior. */
163
164 /*
165 * Read the service options from the VM's guest properties.
166 * Note that these options can be overridden by the command line options later.
167 */
168 uint32_t uGuestPropSvcClientID;
169 int rc = VbglR3GuestPropConnect(&uGuestPropSvcClientID);
170 if (RT_FAILURE(rc))
171 {
172 if (rc == VERR_HGCM_SERVICE_NOT_FOUND) /* Host service is not available. */
173 {
174 VGSvcVerbose(0, "VMInfo: Guest property service is not available, skipping\n");
175 rc = VINF_SUCCESS;
176 }
177 else
178 VGSvcError("Failed to connect to the guest property service! Error: %Rrc\n", rc);
179 }
180 else
181 {
182 rc = VGSvcReadPropUInt32(uGuestPropSvcClientID, "/VirtualBox/GuestAdd/VBoxService/--timesync-interval",
183 &g_TimeSyncInterval, 50, UINT32_MAX - 1);
184 if ( RT_SUCCESS(rc)
185 || rc == VERR_NOT_FOUND)
186 rc = VGSvcReadPropUInt32(uGuestPropSvcClientID, "/VirtualBox/GuestAdd/VBoxService/--timesync-min-adjust",
187 &g_TimeSyncMinAdjust, 0, 3600000);
188 if ( RT_SUCCESS(rc)
189 || rc == VERR_NOT_FOUND)
190 rc = VGSvcReadPropUInt32(uGuestPropSvcClientID, "/VirtualBox/GuestAdd/VBoxService/--timesync-latency-factor",
191 &g_TimeSyncLatencyFactor, 1, 1024);
192 if ( RT_SUCCESS(rc)
193 || rc == VERR_NOT_FOUND)
194 rc = VGSvcReadPropUInt32(uGuestPropSvcClientID, "/VirtualBox/GuestAdd/VBoxService/--timesync-max-latency",
195 &g_TimeSyncMaxLatency, 1, 3600000);
196 if ( RT_SUCCESS(rc)
197 || rc == VERR_NOT_FOUND)
198 rc = VGSvcReadPropUInt32(uGuestPropSvcClientID, "/VirtualBox/GuestAdd/VBoxService/--timesync-set-threshold",
199 &g_TimeSyncSetThreshold, 0, 7*24*60*60*1000 /* a week */);
200 if ( RT_SUCCESS(rc)
201 || rc == VERR_NOT_FOUND)
202 {
203 char *pszValue;
204 rc = VGSvcReadProp(uGuestPropSvcClientID, "/VirtualBox/GuestAdd/VBoxService/--timesync-set-start",
205 &pszValue, NULL /* ppszFlags */, NULL /* puTimestamp */);
206 if (RT_SUCCESS(rc))
207 {
208 g_fTimeSyncSetNext = true;
209 RTStrFree(pszValue);
210 }
211 }
212 if ( RT_SUCCESS(rc)
213 || rc == VERR_NOT_FOUND)
214 {
215 uint32_t value;
216 rc = VGSvcReadPropUInt32(uGuestPropSvcClientID, "/VirtualBox/GuestAdd/VBoxService/--timesync-set-on-restore",
217 &value, 1, 1);
218 if (RT_SUCCESS(rc))
219 g_fTimeSyncSetOnRestore = !!value;
220 }
221
222 VbglR3GuestPropDisconnect(uGuestPropSvcClientID);
223 }
224
225 if (rc == VERR_NOT_FOUND) /* If a value is not found, don't be sad! */
226 rc = VINF_SUCCESS;
227 return rc;
228#else
229 /* Nothing to do here yet. */
230 return VINF_SUCCESS;
231#endif
232}
233
234
235/**
236 * @interface_method_impl{VBOXSERVICE,pfnOption}
237 */
238static DECLCALLBACK(int) vgsvcTimeSyncOption(const char **ppszShort, int argc, char **argv, int *pi)
239{
240 int rc = -1;
241 uint32_t value;
242 if (ppszShort)
243 /* no short options */;
244 else if (!strcmp(argv[*pi], "--timesync-interval"))
245 rc = VGSvcArgUInt32(argc, argv, "", pi, &g_TimeSyncInterval, 50, UINT32_MAX - 1);
246 else if (!strcmp(argv[*pi], "--timesync-min-adjust"))
247 rc = VGSvcArgUInt32(argc, argv, "", pi, &g_TimeSyncMinAdjust, 0, 3600000);
248 else if (!strcmp(argv[*pi], "--timesync-latency-factor"))
249 rc = VGSvcArgUInt32(argc, argv, "", pi, &g_TimeSyncLatencyFactor, 1, 1024);
250 else if (!strcmp(argv[*pi], "--timesync-max-latency"))
251 rc = VGSvcArgUInt32(argc, argv, "", pi, &g_TimeSyncMaxLatency, 1, 3600000);
252 else if (!strcmp(argv[*pi], "--timesync-set-threshold"))
253 rc = VGSvcArgUInt32(argc, argv, "", pi, &g_TimeSyncSetThreshold, 0, 7*24*60*60*1000); /* a week */
254 else if (!strcmp(argv[*pi], "--timesync-set-start"))
255 {
256 g_fTimeSyncSetNext = true;
257 rc = VINF_SUCCESS;
258 }
259 else if (!strcmp(argv[*pi], "--timesync-set-on-restore"))
260 {
261 rc = VGSvcArgUInt32(argc, argv, "", pi, &value, 1, 1);
262 if (RT_SUCCESS(rc))
263 g_fTimeSyncSetOnRestore = !!value;
264 }
265
266 return rc;
267}
268
269
270/**
271 * @interface_method_impl{VBOXSERVICE,pfnInit}
272 */
273static DECLCALLBACK(int) vgsvcTimeSyncInit(void)
274{
275 /*
276 * If not specified, find the right interval default.
277 * Then create the event sem to block on.
278 */
279 if (!g_TimeSyncInterval)
280 g_TimeSyncInterval = g_DefaultInterval * 1000;
281 if (!g_TimeSyncInterval)
282 g_TimeSyncInterval = 10 * 1000;
283
284 VbglR3GetSessionId(&g_idTimeSyncSession);
285 /* The status code is ignored as this information is not available with VBox < 3.2.10. */
286
287 int rc = RTSemEventMultiCreate(&g_TimeSyncEvent);
288 AssertRC(rc);
289#ifdef RT_OS_WINDOWS
290 if (RT_SUCCESS(rc))
291 {
292 /*
293 * Adjust privileges of this process so we can make system time adjustments.
294 */
295 if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &g_hTokenProcess))
296 {
297 TOKEN_PRIVILEGES tkPriv;
298 RT_ZERO(tkPriv);
299 tkPriv.PrivilegeCount = 1;
300 tkPriv.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
301 if (LookupPrivilegeValue(NULL, SE_SYSTEMTIME_NAME, &tkPriv.Privileges[0].Luid))
302 {
303 DWORD cbRet = sizeof(g_TkOldPrivileges);
304 if (AdjustTokenPrivileges(g_hTokenProcess, FALSE, &tkPriv, sizeof(TOKEN_PRIVILEGES), &g_TkOldPrivileges, &cbRet))
305 rc = VINF_SUCCESS;
306 else
307 {
308 DWORD dwErr = GetLastError();
309 rc = RTErrConvertFromWin32(dwErr);
310 VGSvcError("vgsvcTimeSyncInit: Adjusting token privileges (SE_SYSTEMTIME_NAME) failed with status code %u/%Rrc!\n",
311 dwErr, rc);
312 }
313 }
314 else
315 {
316 DWORD dwErr = GetLastError();
317 rc = RTErrConvertFromWin32(dwErr);
318 VGSvcError("vgsvcTimeSyncInit: Looking up token privileges (SE_SYSTEMTIME_NAME) failed with status code %u/%Rrc!\n",
319 dwErr, rc);
320 }
321 if (RT_FAILURE(rc))
322 {
323 CloseHandle(g_hTokenProcess);
324 g_hTokenProcess = NULL;
325 }
326 }
327 else
328 {
329 DWORD dwErr = GetLastError();
330 rc = RTErrConvertFromWin32(dwErr);
331 VGSvcError("vgsvcTimeSyncInit: Opening process token (SE_SYSTEMTIME_NAME) failed with status code %u/%Rrc!\n",
332 dwErr, rc);
333 g_hTokenProcess = NULL;
334 }
335 }
336
337 if (GetSystemTimeAdjustment(&g_dwWinTimeAdjustment, &g_dwWinTimeIncrement, &g_bWinTimeAdjustmentDisabled))
338 VGSvcVerbose(3, "vgsvcTimeSyncInit: Initially %ld (100ns) units per %ld (100 ns) units interval, disabled=%d\n",
339 g_dwWinTimeAdjustment, g_dwWinTimeIncrement, g_bWinTimeAdjustmentDisabled ? 1 : 0);
340 else
341 {
342 DWORD dwErr = GetLastError();
343 rc = RTErrConvertFromWin32(dwErr);
344 VGSvcError("vgsvcTimeSyncInit: Could not get time adjustment values! Last error: %ld!\n", dwErr);
345 }
346#endif /* RT_OS_WINDOWS */
347
348 return rc;
349}
350
351
352/**
353 * Try adjust the time using adjtime or similar.
354 *
355 * @returns true on success, false on failure.
356 *
357 * @param pDrift The time adjustment.
358 */
359static bool vgsvcTimeSyncAdjust(PCRTTIMESPEC pDrift)
360{
361#ifdef RT_OS_WINDOWS
362/** @todo r=bird: g_hTokenProcess cannot be NULL here.
363 * vgsvcTimeSyncInit will fail and the service will not be started with
364 * it being NULL. vgsvcTimeSyncInit OTOH will *NOT* be called until the
365 * service thread has terminated. If anything
366 * else is the case, there is buggy code somewhere.*/
367 if (g_hTokenProcess == NULL) /* Is the token already closed when shutting down? */
368 return false;
369
370 DWORD dwWinTimeAdjustment, dwWinNewTimeAdjustment, dwWinTimeIncrement;
371 BOOL fWinTimeAdjustmentDisabled;
372 if (GetSystemTimeAdjustment(&dwWinTimeAdjustment, &dwWinTimeIncrement, &fWinTimeAdjustmentDisabled))
373 {
374 DWORD dwDiffMax = g_dwWinTimeAdjustment * 0.50;
375 DWORD dwDiffNew = dwWinTimeAdjustment * 0.10;
376
377 if (RTTimeSpecGetMilli(pDrift) > 0)
378 {
379 dwWinNewTimeAdjustment = dwWinTimeAdjustment + dwDiffNew;
380 if (dwWinNewTimeAdjustment > (g_dwWinTimeAdjustment + dwDiffMax))
381 {
382 dwWinNewTimeAdjustment = g_dwWinTimeAdjustment + dwDiffMax;
383 dwDiffNew = dwDiffMax;
384 }
385 }
386 else
387 {
388 dwWinNewTimeAdjustment = dwWinTimeAdjustment - dwDiffNew;
389 if (dwWinNewTimeAdjustment < (g_dwWinTimeAdjustment - dwDiffMax))
390 {
391 dwWinNewTimeAdjustment = g_dwWinTimeAdjustment - dwDiffMax;
392 dwDiffNew = dwDiffMax;
393 }
394 }
395
396 VGSvcVerbose(3, "vgsvcTimeSyncAdjust: Drift=%lldms\n", RTTimeSpecGetMilli(pDrift));
397 VGSvcVerbose(3, "vgsvcTimeSyncAdjust: OrgTA=%ld, CurTA=%ld, NewTA=%ld, DiffNew=%ld, DiffMax=%ld\n",
398 g_dwWinTimeAdjustment, dwWinTimeAdjustment, dwWinNewTimeAdjustment, dwDiffNew, dwDiffMax);
399 if (SetSystemTimeAdjustment(dwWinNewTimeAdjustment, FALSE /* Periodic adjustments enabled. */))
400 {
401 g_cTimeSyncErrors = 0;
402 return true;
403 }
404
405 if (g_cTimeSyncErrors++ < 10)
406 VGSvcError("vgsvcTimeSyncAdjust: SetSystemTimeAdjustment failed, error=%u\n", GetLastError());
407 }
408 else if (g_cTimeSyncErrors++ < 10)
409 VGSvcError("vgsvcTimeSyncAdjust: GetSystemTimeAdjustment failed, error=%ld\n", GetLastError());
410
411#elif defined(RT_OS_OS2) || defined(RT_OS_HAIKU)
412 /* No API for doing gradual time adjustments. */
413
414#else /* PORTME */
415 /*
416 * Try use adjtime(), most unix-like systems have this.
417 */
418 struct timeval tv;
419 RTTimeSpecGetTimeval(pDrift, &tv);
420 if (adjtime(&tv, NULL) == 0)
421 {
422 if (g_cVerbosity >= 1)
423 VGSvcVerbose(1, "vgsvcTimeSyncAdjust: adjtime by %RDtimespec\n", pDrift);
424 g_cTimeSyncErrors = 0;
425 return true;
426 }
427#endif
428
429 /* failed */
430 return false;
431}
432
433
434/**
435 * Cancels any pending time adjustment.
436 *
437 * Called when we've caught up and before calls to vgsvcTimeSyncSet.
438 */
439static void vgsvcTimeSyncCancelAdjust(void)
440{
441#ifdef RT_OS_WINDOWS
442/** @todo r=bird: g_hTokenProcess cannot be NULL here. See argumentation in
443 * vgsvcTimeSyncAdjust. */
444 if (g_hTokenProcess == NULL) /* No process token (anymore)? */
445 return;
446 if (SetSystemTimeAdjustment(0, TRUE /* Periodic adjustments disabled. */))
447 VGSvcVerbose(3, "vgsvcTimeSyncCancelAdjust: Windows Time Adjustment is now disabled.\n");
448 else if (g_cTimeSyncErrors++ < 10)
449 VGSvcError("vgsvcTimeSyncCancelAdjust: SetSystemTimeAdjustment(,disable) failed, error=%u\n", GetLastError());
450#endif /* !RT_OS_WINDOWS */
451}
452
453
454/**
455 * Try adjust the time using adjtime or similar.
456 *
457 * @returns true on success, false on failure.
458 *
459 * @param pDrift The time adjustment.
460 */
461static void vgsvcTimeSyncSet(PCRTTIMESPEC pDrift)
462{
463 /*
464 * Query the current time, adjust it by adding the drift and set it.
465 */
466 RTTIMESPEC NewGuestTime;
467 int rc = RTTimeSet(RTTimeSpecAdd(RTTimeNow(&NewGuestTime), pDrift));
468 if (RT_SUCCESS(rc))
469 {
470 /* Succeeded - reset the error count and log the change. */
471 g_cTimeSyncErrors = 0;
472
473 if (g_cVerbosity >= 1)
474 {
475 char sz[64];
476 RTTIME Time;
477 VGSvcVerbose(1, "time set to %s\n", RTTimeToString(RTTimeExplode(&Time, &NewGuestTime), sz, sizeof(sz)));
478#ifdef DEBUG
479 RTTIMESPEC Tmp;
480 if (g_cVerbosity >= 3)
481 VGSvcVerbose(3, " now %s\n", RTTimeToString(RTTimeExplode(&Time, RTTimeNow(&Tmp)), sz, sizeof(sz)));
482#endif
483 }
484 }
485 else if (g_cTimeSyncErrors++ < 10)
486 VGSvcError("vgsvcTimeSyncSet: RTTimeSet(%RDtimespec) failed: %Rrc\n", &NewGuestTime, rc);
487}
488
489
490/**
491 * @interface_method_impl{VBOXSERVICE,pfnWorker}
492 */
493DECLCALLBACK(int) vgsvcTimeSyncWorker(bool volatile *pfShutdown)
494{
495 RTTIME Time;
496 char sz[64];
497 int rc = VINF_SUCCESS;
498
499 /*
500 * Tell the control thread that it can continue spawning services.
501 */
502 RTThreadUserSignal(RTThreadSelf());
503
504 /*
505 * The Work Loop.
506 */
507 for (;;)
508 {
509 /*
510 * Try get a reliable time reading.
511 */
512 int cTries = 3;
513 do
514 {
515 /* query it. */
516 RTTIMESPEC GuestNow0, GuestNow, HostNow;
517 RTTimeNow(&GuestNow0);
518 int rc2 = VbglR3GetHostTime(&HostNow);
519 if (RT_FAILURE(rc2))
520 {
521 if (g_cTimeSyncErrors++ < 10)
522 VGSvcError("vgsvcTimeSyncWorker: VbglR3GetHostTime failed; rc2=%Rrc\n", rc2);
523 break;
524 }
525 RTTimeNow(&GuestNow);
526
527 /* calc latency and check if it's ok. */
528 RTTIMESPEC GuestElapsed = GuestNow;
529 RTTimeSpecSub(&GuestElapsed, &GuestNow0);
530 if ((uint32_t)RTTimeSpecGetMilli(&GuestElapsed) < g_TimeSyncMaxLatency)
531 {
532 /*
533 * Set the time once after we were restored.
534 * (Of course only if the drift is bigger than MinAdjust)
535 */
536 uint32_t TimeSyncSetThreshold = g_TimeSyncSetThreshold;
537 if (g_fTimeSyncSetOnRestore)
538 {
539 uint64_t idNewSession = g_idTimeSyncSession;
540 VbglR3GetSessionId(&idNewSession);
541 if (idNewSession != g_idTimeSyncSession)
542 {
543 VGSvcVerbose(3, "vgsvcTimeSyncWorker: The VM session ID changed, forcing resync.\n");
544 TimeSyncSetThreshold = 0;
545 g_idTimeSyncSession = idNewSession;
546 }
547 }
548
549 /*
550 * Calculate the adjustment threshold and the current drift.
551 */
552 uint32_t MinAdjust = RTTimeSpecGetMilli(&GuestElapsed) * g_TimeSyncLatencyFactor;
553 if (MinAdjust < g_TimeSyncMinAdjust)
554 MinAdjust = g_TimeSyncMinAdjust;
555
556 RTTIMESPEC Drift = HostNow;
557 RTTimeSpecSub(&Drift, &GuestNow);
558 if (RTTimeSpecGetMilli(&Drift) < 0)
559 MinAdjust += g_TimeSyncMinAdjust; /* extra buffer against moving time backwards. */
560
561 RTTIMESPEC AbsDrift = Drift;
562 RTTimeSpecAbsolute(&AbsDrift);
563 if (g_cVerbosity >= 3)
564 {
565 VGSvcVerbose(3, "vgsvcTimeSyncWorker: Host: %s (MinAdjust: %RU32 ms)\n",
566 RTTimeToString(RTTimeExplode(&Time, &HostNow), sz, sizeof(sz)), MinAdjust);
567 VGSvcVerbose(3, "vgsvcTimeSyncWorker: Guest: - %s => %RDtimespec drift\n",
568 RTTimeToString(RTTimeExplode(&Time, &GuestNow), sz, sizeof(sz)), &Drift);
569 }
570
571 uint32_t AbsDriftMilli = RTTimeSpecGetMilli(&AbsDrift);
572 if (AbsDriftMilli > MinAdjust)
573 {
574 /*
575 * Ok, the drift is above the threshold.
576 *
577 * Try a gradual adjustment first, if that fails or the drift is
578 * too big, fall back on just setting the time.
579 */
580
581 if ( AbsDriftMilli > TimeSyncSetThreshold
582 || g_fTimeSyncSetNext
583 || !vgsvcTimeSyncAdjust(&Drift))
584 {
585 vgsvcTimeSyncCancelAdjust();
586 vgsvcTimeSyncSet(&Drift);
587 }
588 }
589 else
590 vgsvcTimeSyncCancelAdjust();
591 break;
592 }
593 VGSvcVerbose(3, "vgsvcTimeSyncWorker: %RDtimespec: latency too high (%RDtimespec) sleeping 1s\n", GuestElapsed);
594 RTThreadSleep(1000);
595 } while (--cTries > 0);
596
597 /* Clear the set-next/set-start flag. */
598 g_fTimeSyncSetNext = false;
599
600 /*
601 * Block for a while.
602 *
603 * The event semaphore takes care of ignoring interruptions and it
604 * allows us to implement service wakeup later.
605 */
606 if (*pfShutdown)
607 break;
608 int rc2 = RTSemEventMultiWait(g_TimeSyncEvent, g_TimeSyncInterval);
609 if (*pfShutdown)
610 break;
611 if (rc2 != VERR_TIMEOUT && RT_FAILURE(rc2))
612 {
613 VGSvcError("vgsvcTimeSyncWorker: RTSemEventMultiWait failed; rc2=%Rrc\n", rc2);
614 rc = rc2;
615 break;
616 }
617 }
618
619 vgsvcTimeSyncCancelAdjust();
620 RTSemEventMultiDestroy(g_TimeSyncEvent);
621 g_TimeSyncEvent = NIL_RTSEMEVENTMULTI;
622 return rc;
623}
624
625
626/**
627 * @interface_method_impl{VBOXSERVICE,pfnStop}
628 */
629static DECLCALLBACK(void) vgsvcTimeSyncStop(void)
630{
631 RTSemEventMultiSignal(g_TimeSyncEvent);
632}
633
634
635/**
636 * @interface_method_impl{VBOXSERVICE,pfnTerm}
637 */
638static DECLCALLBACK(void) vgsvcTimeSyncTerm(void)
639{
640#ifdef RT_OS_WINDOWS
641 /*
642 * Restore the SE_SYSTEMTIME_NAME token privileges (if init succeeded).
643 */
644 if (g_hTokenProcess)
645 {
646 if (!AdjustTokenPrivileges(g_hTokenProcess, FALSE, &g_TkOldPrivileges, sizeof(TOKEN_PRIVILEGES), NULL, NULL))
647 {
648 DWORD dwErr = GetLastError();
649 VGSvcError("vgsvcTimeSyncTerm: Restoring token privileges (SE_SYSTEMTIME_NAME) failed with code %u!\n", dwErr);
650 }
651 CloseHandle(g_hTokenProcess);
652 g_hTokenProcess = NULL;
653 }
654#endif /* !RT_OS_WINDOWS */
655
656 if (g_TimeSyncEvent != NIL_RTSEMEVENTMULTI)
657 {
658 RTSemEventMultiDestroy(g_TimeSyncEvent);
659 g_TimeSyncEvent = NIL_RTSEMEVENTMULTI;
660 }
661}
662
663
664/**
665 * The 'timesync' service description.
666 */
667VBOXSERVICE g_TimeSync =
668{
669 /* pszName. */
670 "timesync",
671 /* pszDescription. */
672 "Time synchronization",
673 /* pszUsage. */
674 " [--timesync-interval <ms>] [--timesync-min-adjust <ms>]\n"
675 " [--timesync-latency-factor <x>] [--timesync-max-latency <ms>]\n"
676 " [--timesync-set-threshold <ms>] [--timesync-set-start]\n"
677 " [--timesync-set-on-restore 0|1]"
678 ,
679 /* pszOptions. */
680 " --timesync-interval Specifies the interval at which to synchronize the\n"
681 " time with the host. The default is 10000 ms.\n"
682 " --timesync-min-adjust The minimum absolute drift value measured in\n"
683 " milliseconds to make adjustments for.\n"
684 " The default is 1000 ms on OS/2 and 100 ms elsewhere.\n"
685 " --timesync-latency-factor\n"
686 " The factor to multiply the time query latency with\n"
687 " to calculate the dynamic minimum adjust time.\n"
688 " The default is 8 times.\n"
689 " --timesync-max-latency The max host timer query latency to accept.\n"
690 " The default is 250 ms.\n"
691 " --timesync-set-threshold\n"
692 " The absolute drift threshold, given as milliseconds,\n"
693 " where to start setting the time instead of trying to\n"
694 " adjust it. The default is 20 min.\n"
695 " --timesync-set-start Set the time when starting the time sync service.\n"
696 " --timesync-set-on-restore 0|1\n"
697 " Immediately set the time when the VM was restored.\n"
698 " 1 = set (default), 0 = don't set.\n"
699 ,
700 /* methods */
701 vgsvcTimeSyncPreInit,
702 vgsvcTimeSyncOption,
703 vgsvcTimeSyncInit,
704 vgsvcTimeSyncWorker,
705 vgsvcTimeSyncStop,
706 vgsvcTimeSyncTerm
707};
708
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use