VBoxServiceTimeSync.cpp@ 25166

Last change on this file since 25166 was 25159, checked in by vboxsync, 15 years ago

VBoxService: Various fixes and improvements for NT4 and up:

Shuts down correctly on NT4.
SCM gets notified if shutting down takes a bit longer than expected.

Property svn:eol-style set to native
Property svn:keywords set to Author Date Id Revision

File size: 22.4 KB

Line
1	/* $Id: VBoxServiceTimeSync.cpp 25159 2009-12-03 10:49:02Z vboxsync $ */
2	/** @file
3	* VBoxService - Guest Additions TimeSync Service.
4	*/
5
6	/*
7	* Copyright (C) 2007 Sun Microsystems, Inc.
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	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18	* Clara, CA 95054 USA or visit http://www.sun.com if you need
19	* additional information or have any questions.
20	*/
21
22
23	/** @page pg_vboxservice_timesync The Time Sync Service
24	*
25	* The time sync service plays along with the Time Manager (TM) in the VMM
26	* to keep the guest time accurate using the host machine as reference.
27	* TM will try its best to make sure all timer ticks gets delivered so that
28	* there isn't normally any need to adjust the guest time.
29	*
30	* There are three normal (= acceptable) cases:
31	* -# When the service starts up. This is because ticks and such might
32	* be lost during VM and OS startup. (Need to figure out exactly why!)
33	* -# When the TM is unable to deliver all the ticks and swallows a
34	* backlog of ticks. The threshold for this is configurable with
35	* a default of 60 seconds.
36	* -# The time is adjusted on the host. This can be caused manually by
37	* the user or by some time sync daemon (NTP, LAN server, etc.).
38	*
39	* There are a number of very odd case where adjusting is needed. Here
40	* are some of them:
41	* -# Timer device emulation inaccurancies (like rounding).
42	* -# Inaccurancies in time source VirtualBox uses.
43	* -# The Guest and/or Host OS doesn't perform proper time keeping. This
44	* come about as a result of OS and/or hardware issues.
45	*
46	* The TM is our source for the host time and will make adjustments for
47	* current timer delivery lag. The simplistic approach taken by TM is to
48	* adjust the host time by the current guest timer delivery lag, meaning that
49	* if the guest is behind 1 second with PIT/RTC/++ ticks this should be reflected
50	* in the guest wall time as well.
51	*
52	* Now, there is any amount of trouble we can cause by changing the time.
53	* Most applications probably uses the wall time when they need to measure
54	* things. A walltime that is being juggled about every so often, even if just
55	* a little bit, could occationally upset these measurements by for instance
56	* yielding negative results.
57	*
58	* This bottom line here is that the time sync service isn't really supposed
59	* to do anything and will try avoid having to do anything when possible.
60	*
61	* The implementation uses the latency it takes to query host time as the
62	* absolute maximum precision to avoid messing up under timer tick catchup
63	* and/or heavy host/guest load. (Rational is that a lot of stuff may happen
64	* on our way back from ring-3 and TM/VMMDev since we're taking the route
65	* thru the inner EM loop with it's force action processing.)
66	*
67	* But this latency has to be measured from our perspective, which means it
68	* could just as easily come out as 0. (OS/2 and Windows guest only updates
69	* the current time when the timer ticks for instance.) The good thing is
70	* that this isn't really a problem since we won't ever do anything unless
71	* the drift is noticable.
72	*
73	* It now boils down to these three (configuration) factors:
74	* -# g_TimesyncMinAdjust - The minimum drift we will ever bother with.
75	* -# g_TimesyncLatencyFactor - The factor we multiply the latency by to
76	* calculate the dynamic minimum adjust factor.
77	* -# g_TimesyncMaxLatency - When to start discarding the data as utterly
78	* useless and take a rest (someone is too busy to give us good data).
79	* -# g_TimeSyncSetThreshold - The threshold at which we will just set the time
80	* instead of trying to adjust it (milliseconds).
81	*/
82
83	/*******************************************************************************
84	* Header Files *
85	*******************************************************************************/
86	#ifdef RT_OS_WINDOWS
87	# include <Windows.h>
88	# include <winbase.h> /** @todo r=bird: Why is this here? Windows.h should include winbase.h... */
89	#else
90	# include <unistd.h>
91	# include <errno.h>
92	# include <time.h>
93	# include <sys/time.h>
94	#endif
95
96	#include <iprt/thread.h>
97	#include <iprt/string.h>
98	#include <iprt/semaphore.h>
99	#include <iprt/time.h>
100	#include <iprt/assert.h>
101	#include <VBox/VBoxGuestLib.h>
102	#include "VBoxServiceInternal.h"
103
104
105	/*******************************************************************************
106	* Global Variables *
107	*******************************************************************************/
108	/** The timesync interval (millseconds). */
109	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 but in the 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_TimeSyncMinAdjust = 1000;
119	#else
120	static uint32_t g_TimeSyncMinAdjust = 100;
121	#endif
122	/** @see pg_vboxservice_timesync */
123	static uint32_t g_TimeSyncLatencyFactor = 8;
124	/** @see pg_vboxservice_timesync */
125	static uint32_t g_TimeSyncMaxLatency = 250;
126	/** @see pg_vboxservice_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
132	/** Current error count. Used to knowing when to bitch and when not to. */
133	static uint32_t g_cTimeSyncErrors = 0;
134
135	/** The semaphore we're blocking on. */
136	static RTSEMEVENTMULTI g_TimeSyncEvent = NIL_RTSEMEVENTMULTI;
137
138	#ifdef RT_OS_WINDOWS
139	/** Process token. */
140	static HANDLE g_hTokenProcess = NULL;
141	/** Old token privileges. */
142	static TOKEN_PRIVILEGES g_TkOldPrivileges;
143	/** Backup values for time adjustment. */
144	static DWORD g_dwWinTimeAdjustment;
145	static DWORD g_dwWinTimeIncrement;
146	static BOOL g_bWinTimeAdjustmentDisabled;
147	#endif
148
149
150	/** @copydoc VBOXSERVICE::pfnPreInit */
151	static DECLCALLBACK(int) VBoxServiceTimeSyncPreInit(void)
152	{
153	return VINF_SUCCESS;
154	}
155
156
157	/** @copydoc VBOXSERVICE::pfnOption */
158	static DECLCALLBACK(int) VBoxServiceTimeSyncOption(const char ppszShort, int argc, char argv, int *pi)
159	{
160	int rc = -1;
161	if (ppszShort)
162	/* no short options */;
163	else if (!strcmp(argv[*pi], "--timesync-interval"))
164	rc = VBoxServiceArgUInt32(argc, argv, "", pi,
165	&g_TimeSyncInterval, 1, UINT32_MAX - 1);
166	else if (!strcmp(argv[*pi], "--timesync-min-adjust"))
167	rc = VBoxServiceArgUInt32(argc, argv, "", pi,
168	&g_TimeSyncMinAdjust, 0, 3600000);
169	else if (!strcmp(argv[*pi], "--timesync-latency-factor"))
170	rc = VBoxServiceArgUInt32(argc, argv, "", pi,
171	&g_TimeSyncLatencyFactor, 1, 1024);
172	else if (!strcmp(argv[*pi], "--timesync-max-latency"))
173	rc = VBoxServiceArgUInt32(argc, argv, "", pi,
174	&g_TimeSyncMaxLatency, 1, 3600000);
175	else if (!strcmp(argv[*pi], "--timesync-set-threshold"))
176	rc = VBoxServiceArgUInt32(argc, argv, "", pi,
177	&g_TimeSyncSetThreshold, 0, 724601000); / a week */
178	else if (!strcmp(argv[*pi], "--timesync-set-start"))
179	{
180	g_fTimeSyncSetNext = true;
181	rc = VINF_SUCCESS;
182	}
183
184	return rc;
185	}
186
187
188	/** @copydoc VBOXSERVICE::pfnInit */
189	static DECLCALLBACK(int) VBoxServiceTimeSyncInit(void)
190	{
191	/*
192	* If not specified, find the right interval default.
193	* Then create the event sem to block on.
194	*/
195	if (!g_TimeSyncInterval)
196	g_TimeSyncInterval = g_DefaultInterval * 1000;
197	if (!g_TimeSyncInterval)
198	g_TimeSyncInterval = 10 * 1000;
199
200	int rc = RTSemEventMultiCreate(&g_TimeSyncEvent);
201	AssertRC(rc);
202	#ifdef RT_OS_WINDOWS
203	if (RT_SUCCESS(rc))
204	{
205	/*
206	* Adjust priviledges of this process so we can make system time adjustments.
207	*/
208	if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES \| TOKEN_QUERY, &g_hTokenProcess))
209	{
210	TOKEN_PRIVILEGES tkPriv;
211	RT_ZERO(tkPriv);
212	tkPriv.PrivilegeCount = 1;
213	tkPriv.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
214	if (LookupPrivilegeValue(NULL, SE_SYSTEMTIME_NAME, &tkPriv.Privileges[0].Luid))
215	{
216	DWORD cbRet = sizeof(g_TkOldPrivileges);
217	if (AdjustTokenPrivileges(g_hTokenProcess, FALSE, &tkPriv, sizeof(TOKEN_PRIVILEGES), &g_TkOldPrivileges, &cbRet))
218	rc = VINF_SUCCESS;
219	else
220	{
221	DWORD dwErr = GetLastError();
222	rc = RTErrConvertFromWin32(dwErr);
223	VBoxServiceError("Adjusting token privileges (SE_SYSTEMTIME_NAME) failed with status code %u/%Rrc!\n", dwErr, rc);
224	}
225	}
226	else
227	{
228	DWORD dwErr = GetLastError();
229	rc = RTErrConvertFromWin32(dwErr);
230	VBoxServiceError("Looking up token privileges (SE_SYSTEMTIME_NAME) failed with status code %u/%Rrc!\n", dwErr, rc);
231	}
232	if (RT_FAILURE(rc))
233	{
234	CloseHandle(g_hTokenProcess);
235	g_hTokenProcess = NULL;
236	}
237	}
238	else
239	{
240	DWORD dwErr = GetLastError();
241	rc = RTErrConvertFromWin32(dwErr);
242	VBoxServiceError("Opening process token (SE_SYSTEMTIME_NAME) failed with status code %u/%Rrc!\n", dwErr, rc);
243	g_hTokenProcess = NULL;
244	}
245	}
246
247	if (GetSystemTimeAdjustment(&g_dwWinTimeAdjustment, &g_dwWinTimeIncrement, &g_bWinTimeAdjustmentDisabled))
248	VBoxServiceVerbose(3, "Windows time adjustment: Initially %ld (100ns) units per %ld (100 ns) units interval, disabled=%d\n",
249	g_dwWinTimeAdjustment, g_dwWinTimeIncrement, g_bWinTimeAdjustmentDisabled ? 1 : 0);
250	else
251	{
252	DWORD dwErr = GetLastError();
253	rc = RTErrConvertFromWin32(dwErr);
254	VBoxServiceError("Could not get time adjustment values! Last error: %ld!\n", dwErr);
255	}
256	#endif /* RT_OS_WINDOWS */
257
258	return rc;
259	}
260
261
262	/**
263	* Try adjust the time using adjtime or similar.
264	*
265	* @returns true on success, false on failure.
266	*
267	* @param pDrift The time adjustment.
268	*/
269	static bool VBoxServiceTimeSyncAdjust(PCRTTIMESPEC pDrift)
270	{
271	#ifdef RT_OS_WINDOWS
272	/** @todo r=bird: NT4 doesn't have GetSystemTimeAdjustment. */
273	if (g_hTokenProcess == NULL) /* Is the token already closed when shutting down? */
274	return false;
275
276	DWORD dwWinTimeAdjustment, dwWinNewTimeAdjustment, dwWinTimeIncrement;
277	BOOL fWinTimeAdjustmentDisabled;
278	if (GetSystemTimeAdjustment(&dwWinTimeAdjustment, &dwWinTimeIncrement, &fWinTimeAdjustmentDisabled))
279	{
280	DWORD dwDiffMax = g_dwWinTimeAdjustment * 0.50;
281	DWORD dwDiffNew = dwWinTimeAdjustment * 0.10;
282
283	if (RTTimeSpecGetMilli(pDrift) > 0)
284	{
285	dwWinNewTimeAdjustment = dwWinTimeAdjustment + dwDiffNew;
286	if (dwWinNewTimeAdjustment > (g_dwWinTimeAdjustment + dwDiffMax))
287	{
288	dwWinNewTimeAdjustment = g_dwWinTimeAdjustment + dwDiffMax;
289	dwDiffNew = dwDiffMax;
290	}
291	}
292	else
293	{
294	dwWinNewTimeAdjustment = dwWinTimeAdjustment - dwDiffNew;
295	if (dwWinNewTimeAdjustment < (g_dwWinTimeAdjustment - dwDiffMax))
296	{
297	dwWinNewTimeAdjustment = g_dwWinTimeAdjustment - dwDiffMax;
298	dwDiffNew = dwDiffMax;
299	}
300	}
301
302	VBoxServiceVerbose(3, "Windows time adjustment: Drift=%lldms\n", RTTimeSpecGetMilli(pDrift));
303	VBoxServiceVerbose(3, "Windows time adjustment: OrgTA=%ld, CurTA=%ld, NewTA=%ld, DiffNew=%ld, DiffMax=%ld\n",
304	g_dwWinTimeAdjustment, dwWinTimeAdjustment, dwWinNewTimeAdjustment, dwDiffNew, dwDiffMax);
305	if (SetSystemTimeAdjustment(dwWinNewTimeAdjustment, FALSE /* Periodic adjustments enabled. */))
306	{
307	g_cTimeSyncErrors = 0;
308	return true;
309	}
310
311	if (g_cTimeSyncErrors++ < 10)
312	VBoxServiceError("SetSystemTimeAdjustment failed, error=%u\n", GetLastError());
313	}
314	else if (g_cTimeSyncErrors++ < 10)
315	VBoxServiceError("GetSystemTimeAdjustment failed, error=%ld\n", GetLastError());
316
317	#elif defined(RT_OS_OS2)
318	/* No API for doing gradual time adjustments. */
319
320	#else /* PORTME */
321	/*
322	* Try use adjtime(), most unix-like systems have this.
323	*/
324	struct timeval tv;
325	RTTimeSpecGetTimeval(pDrift, &tv);
326	if (adjtime(&tv, NULL) == 0)
327	{
328	if (g_cVerbosity >= 1)
329	VBoxServiceVerbose(1, "adjtime by %RDtimespec\n", pDrift);
330	g_cTimeSyncErrors = 0;
331	return true;
332	}
333	#endif
334
335	/* failed */
336	return false;
337	}
338
339
340	/**
341	* Cancels any pending time adjustment.
342	*
343	* Called when we've caught up and before calls to VBoxServiceTimeSyncSet.
344	*/
345	static void VBoxServiceTimeSyncCancelAdjust(void)
346	{
347	#ifdef RT_OS_WINDOWS
348	if (SetSystemTimeAdjustment(0, TRUE /* Periodic adjustments disabled. */))
349	VBoxServiceVerbose(3, "Windows Time Adjustment is now disabled.\n");
350	else if (g_cTimeSyncErrors++ < 10)
351	VBoxServiceError("SetSystemTimeAdjustment(,disable) failed, error=%u\n", GetLastError());
352	#endif /* !RT_OS_WINDOWS */
353	}
354
355
356	/**
357	* Try adjust the time using adjtime or similar.
358	*
359	* @returns true on success, false on failure.
360	*
361	* @param pDrift The time adjustment.
362	* @param pHostNow The host time at the time of the host query.
363	* REMOVE THIS ARGUMENT!
364	*/
365	static void VBoxServiceTimeSyncSet(PCRTTIMESPEC pDrift, PCRTTIMESPEC pHostNow)
366	{
367	/*
368	* Query the current time, add the adjustment, then try it.
369	*/
370	#ifdef RT_OS_WINDOWS
371	/** @todo r=bird: Get current time and add the adjustment, the host time is
372	* stale by now. */
373	FILETIME ft;
374	RTTimeSpecGetNtFileTime(pHostNow, &ft);
375	SYSTEMTIME st;
376	if (FileTimeToSystemTime(&ft, &st))
377	{
378	if (!SetSystemTime(&st))
379	VBoxServiceError("SetSystemTime failed, error=%u\n", GetLastError());
380	}
381	else
382	VBoxServiceError("Cannot convert system times, error=%u\n", GetLastError());
383
384	#else /* !RT_OS_WINDOWS */
385	struct timeval tv;
386	errno = 0;
387	if (!gettimeofday(&tv, NULL))
388	{
389	RTTIMESPEC Tmp;
390	RTTimeSpecAdd(RTTimeSpecSetTimeval(&Tmp, &tv), pDrift);
391	if (!settimeofday(RTTimeSpecGetTimeval(&Tmp, &tv), NULL))
392	{
393	char sz[64];
394	RTTIME Time;
395	if (g_cVerbosity >= 1)
396	VBoxServiceVerbose(1, "settimeofday to %s\n",
397	RTTimeToString(RTTimeExplode(&Time, &Tmp), sz, sizeof(sz)));
398	# ifdef DEBUG
399	if (g_cVerbosity >= 3)
400	VBoxServiceVerbose(2, " new time %s\n",
401	RTTimeToString(RTTimeExplode(&Time, RTTimeNow(&Tmp)), sz, sizeof(sz)));
402	# endif
403	g_cTimeSyncErrors = 0;
404	}
405	else if (g_cTimeSyncErrors++ < 10)
406	VBoxServiceError("settimeofday failed; errno=%d: %s\n", errno, strerror(errno));
407	}
408	else if (g_cTimeSyncErrors++ < 10)
409	VBoxServiceError("gettimeofday failed; errno=%d: %s\n", errno, strerror(errno));
410	#endif /* !RT_OS_WINDOWS */
411	}
412
413
414	/** @copydoc VBOXSERVICE::pfnWorker */
415	DECLCALLBACK(int) VBoxServiceTimeSyncWorker(bool volatile *pfShutdown)
416	{
417	RTTIME Time;
418	char sz[64];
419	int rc = VINF_SUCCESS;
420
421	/*
422	* Tell the control thread that it can continue spawning services.
423	*/
424	RTThreadUserSignal(RTThreadSelf());
425
426	/*
427	* The Work Loop.
428	*/
429	for (;;)
430	{
431	/*
432	* Try get a reliable time reading.
433	*/
434	int cTries = 3;
435	do
436	{
437	/* query it. */
438	RTTIMESPEC GuestNow0, GuestNow, HostNow;
439	RTTimeNow(&GuestNow0);
440	int rc2 = VbglR3GetHostTime(&HostNow);
441	if (RT_FAILURE(rc2))
442	{
443	if (g_cTimeSyncErrors++ < 10)
444	VBoxServiceError("VbglR3GetHostTime failed; rc2=%Rrc\n", rc2);
445	break;
446	}
447	RTTimeNow(&GuestNow);
448
449	/* calc latency and check if it's ok. */
450	RTTIMESPEC GuestElapsed = GuestNow;
451	RTTimeSpecSub(&GuestElapsed, &GuestNow0);
452	if ((uint32_t)RTTimeSpecGetMilli(&GuestElapsed) < g_TimeSyncMaxLatency)
453	{
454	/*
455	* Calculate the adjustment threshold and the current drift.
456	*/
457	uint32_t MinAdjust = RTTimeSpecGetMilli(&GuestElapsed) * g_TimeSyncLatencyFactor;
458	if (MinAdjust < g_TimeSyncMinAdjust)
459	MinAdjust = g_TimeSyncMinAdjust;
460
461	RTTIMESPEC Drift = HostNow;
462	RTTimeSpecSub(&Drift, &GuestNow);
463	if (RTTimeSpecGetMilli(&Drift) < 0)
464	MinAdjust += g_TimeSyncMinAdjust; /* extra buffer against moving time backwards. */
465
466	RTTIMESPEC AbsDrift = Drift;
467	RTTimeSpecAbsolute(&AbsDrift);
468	if (g_cVerbosity >= 3)
469	{
470	VBoxServiceVerbose(3, "Host: %s (MinAdjust: %RU32 ms)\n",
471	RTTimeToString(RTTimeExplode(&Time, &HostNow), sz, sizeof(sz)), MinAdjust);
472	VBoxServiceVerbose(3, "Guest: - %s => %RDtimespec drift\n",
473	RTTimeToString(RTTimeExplode(&Time, &GuestNow), sz, sizeof(sz)),
474	&Drift);
475	}
476
477	uint32_t AbsDriftMilli = RTTimeSpecGetMilli(&AbsDrift);
478	if (AbsDriftMilli > MinAdjust)
479	{
480	/*
481	* Ok, the drift is above the threshold.
482	*
483	* Try a gradual adjustment first, if that fails or the drift is
484	* too big, fall back on just setting the time.
485	*/
486
487	if ( AbsDriftMilli > g_TimeSyncSetThreshold
488	\|\| g_fTimeSyncSetNext
489	\|\| !VBoxServiceTimeSyncAdjust(&Drift))
490	{
491	VBoxServiceTimeSyncCancelAdjust();
492	VBoxServiceTimeSyncSet(&Drift, &HostNow);
493	}
494	}
495	else
496	VBoxServiceTimeSyncCancelAdjust();
497	break;
498	}
499	VBoxServiceVerbose(3, "%RDtimespec: latency too high (%RDtimespec) sleeping 1s\n", GuestElapsed);
500	RTThreadSleep(1000);
501	} while (--cTries > 0);
502
503	/* Clear the set-next/set-start flag. */
504	g_fTimeSyncSetNext = false;
505
506	/*
507	* Block for a while.
508	*
509	* The event semaphore takes care of ignoring interruptions and it
510	* allows us to implement service wakeup later.
511	*/
512	if (*pfShutdown)
513	break;
514	int rc2 = RTSemEventMultiWait(g_TimeSyncEvent, g_TimeSyncInterval);
515	if (*pfShutdown)
516	break;
517	if (rc2 != VERR_TIMEOUT && RT_FAILURE(rc2))
518	{
519	VBoxServiceError("RTSemEventMultiWait failed; rc2=%Rrc\n", rc2);
520	rc = rc2;
521	break;
522	}
523	}
524
525	RTSemEventMultiDestroy(g_TimeSyncEvent);
526	g_TimeSyncEvent = NIL_RTSEMEVENTMULTI;
527	return rc;
528	}
529
530
531	/** @copydoc VBOXSERVICE::pfnStop */
532	static DECLCALLBACK(void) VBoxServiceTimeSyncStop(void)
533	{
534	RTSemEventMultiSignal(g_TimeSyncEvent);
535	}
536
537
538	/** @copydoc VBOXSERVICE::pfnTerm */
539	static DECLCALLBACK(void) VBoxServiceTimeSyncTerm(void)
540	{
541	#ifdef RT_OS_WINDOWS
542	/*
543	* Restore the SE_SYSTEMTIME_NAME token privileges (if init succeeded).
544	*/
545	if (g_hTokenProcess)
546	{
547	if (!AdjustTokenPrivileges(g_hTokenProcess, FALSE, &g_TkOldPrivileges, sizeof(TOKEN_PRIVILEGES), NULL, NULL))
548	{
549	DWORD dwErr = GetLastError();
550	VBoxServiceError("Restoring token privileges (SE_SYSTEMTIME_NAME) failed with code %u!\n", dwErr);
551	}
552	CloseHandle(g_hTokenProcess);
553	g_hTokenProcess = NULL;
554	}
555	#endif /* !RT_OS_WINDOWS */
556
557	if (g_TimeSyncEvent != NIL_RTSEMEVENTMULTI)
558	{
559	RTSemEventMultiDestroy(g_TimeSyncEvent);
560	g_TimeSyncEvent = NIL_RTSEMEVENTMULTI;
561	}
562	}
563
564
565	/**
566	* The 'timesync' service description.
567	*/
568	VBOXSERVICE g_TimeSync =
569	{
570	/* pszName. */
571	"timesync",
572	/* pszDescription. */
573	"Time synchronization",
574	/* pszUsage. */
575	"[--timesync-interval <ms>] [--timesync-min-adjust <ms>] "
576	"[--timesync-latency-factor <x>] [--timesync-max-latency <ms>]"
577	"[--timesync-set-threshold <ms>] [--timesync-set-start]"
578	,
579	/* pszOptions. */
580	" --timesync-interval Specifies the interval at which to synchronize the\n"
581	" time with the host. The default is 10000 ms.\n"
582	" --timesync-min-adjust\n"
583	" The minimum absolute drift value measured in\n"
584	" milliseconds to make adjustments for.\n"
585	" The default is 1000 ms on OS/2 and 100 ms elsewhere.\n"
586	" --timesync-latency-factor\n"
587	" The factor to multiply the time query latency with to\n"
588	" calculate the dynamic minimum adjust time.\n"
589	" The default is 8 times.\n"
590	" --timesync-max-latency\n"
591	" The max host timer query latency to accept.\n"
592	" The default is 250 ms.\n"
593	" --timesync-set-threshold\n"
594	" The absolute drift threshold, given as milliseconds,\n"
595	" where to start setting the time instead of trying to\n"
596	" adjust it. The default is 20 min.\n"
597	" --timesync-set-start\n"
598	" Set the time when starting the time sync service.\n"
599	,
600	/* methods */
601	VBoxServiceTimeSyncPreInit,
602	VBoxServiceTimeSyncOption,
603	VBoxServiceTimeSyncInit,
604	VBoxServiceTimeSyncWorker,
605	VBoxServiceTimeSyncStop,
606	VBoxServiceTimeSyncTerm
607	};
608

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: