VBoxServiceTimeSync.cpp@ 69206

Last change on this file since 69206 was 68557, checked in by vboxsync, 7 years ago
merging vbglioc r117709: VBoxServiceTimeSync.cpp: Don't destroy the semaphore in vgsvcTimeSyncWorker, the Term method shall do that, otherwise the stop method will try signal an invalid handle.
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 68557 2017-08-31 12:10:02Z 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_cMsTimeSyncMinAdjust - 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_cMsTimeSyncMaxLatency - 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). */
109	static uint32_t g_TimeSyncInterval = 0;
110	/**
111	* @see pg_vgsvc_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
118	static uint32_t g_cMsTimeSyncMinAdjust = 1000;
119	#else
120	static uint32_t g_cMsTimeSyncMinAdjust = 100;
121	#endif
122	/** @see pg_vgsvc_timesync */
123	static uint32_t g_TimeSyncLatencyFactor = 8;
124	/** @see pg_vgsvc_timesync */
125	static uint32_t g_cMsTimeSyncMaxLatency = 250;
126	/** @see pg_vgsvc_timesync */
127	static uint32_t g_TimeSyncSetThreshold = 20601000;
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. */
130	static bool volatile g_fTimeSyncSetNext = false;
131	/** Whether to set the time when the VM was restored. */
132	static bool g_fTimeSyncSetOnRestore = true;
133
134	/** Current error count. Used to knowing when to bitch and when not to. */
135	static uint32_t g_cTimeSyncErrors = 0;
136
137	/** The semaphore we're blocking on. */
138	static RTSEMEVENTMULTI g_TimeSyncEvent = NIL_RTSEMEVENTMULTI;
139
140	/** The VM session ID. Changes whenever the VM is restored or reset. */
141	static uint64_t g_idTimeSyncSession;
142
143	#ifdef RT_OS_WINDOWS
144	/** Process token. */
145	static HANDLE g_hTokenProcess = NULL;
146	/** Old token privileges. */
147	static TOKEN_PRIVILEGES g_TkOldPrivileges;
148	/** Backup values for time adjustment. */
149	static DWORD g_dwWinTimeAdjustment;
150	static DWORD g_dwWinTimeIncrement;
151	static BOOL g_bWinTimeAdjustmentDisabled;
152	#endif
153
154
155	/**
156	* @interface_method_impl{VBOXSERVICE,pfnPreInit}
157	*/
158	static 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_cMsTimeSyncMinAdjust, 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_cMsTimeSyncMaxLatency, 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, 72460601000 /* 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	*/
238	static 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_cMsTimeSyncMinAdjust, 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_cMsTimeSyncMaxLatency, 1, 3600000);
252	else if (!strcmp(argv[*pi], "--timesync-set-threshold"))
253	rc = VGSvcArgUInt32(argc, argv, "", pi, &g_TimeSyncSetThreshold, 0, 72460601000); /* 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	*/
273	static 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	*/
359	static 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	*/
439	static 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	*/
461	static 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	*/
493	DECLCALLBACK(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_cMsTimeSyncMaxLatency)
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_cMsTimeSyncMinAdjust)
554	MinAdjust = g_cMsTimeSyncMinAdjust;
555
556	RTTIMESPEC Drift = HostNow;
557	RTTimeSpecSub(&Drift, &GuestNow);
558	if (RTTimeSpecGetMilli(&Drift) < 0)
559	MinAdjust += g_cMsTimeSyncMinAdjust; /* 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, max %ums) sleeping 1s\n",
594	&GuestNow, &GuestElapsed, g_cMsTimeSyncMaxLatency);
595	RTThreadSleep(1000);
596	} while (--cTries > 0);
597
598	/* Clear the set-next/set-start flag. */
599	g_fTimeSyncSetNext = false;
600
601	/*
602	* Block for a while.
603	*
604	* The event semaphore takes care of ignoring interruptions and it
605	* allows us to implement service wakeup later.
606	*/
607	if (*pfShutdown)
608	break;
609	int rc2 = RTSemEventMultiWait(g_TimeSyncEvent, g_TimeSyncInterval);
610	if (*pfShutdown)
611	break;
612	if (rc2 != VERR_TIMEOUT && RT_FAILURE(rc2))
613	{
614	VGSvcError("vgsvcTimeSyncWorker: RTSemEventMultiWait failed; rc2=%Rrc\n", rc2);
615	rc = rc2;
616	break;
617	}
618	}
619
620	vgsvcTimeSyncCancelAdjust();
621	return rc;
622	}
623
624
625	/**
626	* @interface_method_impl{VBOXSERVICE,pfnStop}
627	*/
628	static DECLCALLBACK(void) vgsvcTimeSyncStop(void)
629	{
630	if (g_TimeSyncEvent != NIL_RTSEMEVENTMULTI)
631	RTSemEventMultiSignal(g_TimeSyncEvent);
632	}
633
634
635	/**
636	* @interface_method_impl{VBOXSERVICE,pfnTerm}
637	*/
638	static 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	*/
667	VBOXSERVICE 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.

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

Download in other formats: