VirtualBox

source: vbox/trunk/src/VBox/VMM/TM.cpp@ 24332

Last change on this file since 24332 was 23794, checked in by vboxsync, 15 years ago

More synthetic cpu work
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 116.0 KB
Line 
1/* $Id: TM.cpp 23794 2009-10-15 11:50:03Z vboxsync $ */
2/** @file
3 * TM - Time Manager.
4 */
5
6/*
7 * Copyright (C) 2006-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/** @page pg_tm TM - The Time Manager
23 *
24 * The Time Manager abstracts the CPU clocks and manages timers used by the VMM,
25 * device and drivers.
26 *
27 * @see grp_tm
28 *
29 *
30 * @section sec_tm_clocks Clocks
31 *
32 * There are currently 4 clocks:
33 * - Virtual (guest).
34 * - Synchronous virtual (guest).
35 * - CPU Tick (TSC) (guest). Only current use is rdtsc emulation. Usually a
36 * function of the virtual clock.
37 * - Real (host). This is only used for display updates atm.
38 *
39 * The most important clocks are the three first ones and of these the second is
40 * the most interesting.
41 *
42 *
43 * The synchronous virtual clock is tied to the virtual clock except that it
44 * will take into account timer delivery lag caused by host scheduling. It will
45 * normally never advance beyond the head timer, and when lagging too far behind
46 * it will gradually speed up to catch up with the virtual clock. All devices
47 * implementing time sources accessible to and used by the guest is using this
48 * clock (for timers and other things). This ensures consistency between the
49 * time sources.
50 *
51 * The virtual clock is implemented as an offset to a monotonic, high
52 * resolution, wall clock. The current time source is using the RTTimeNanoTS()
53 * machinery based upon the Global Info Pages (GIP), that is, we're using TSC
54 * deltas (usually 10 ms) to fill the gaps between GIP updates. The result is
55 * a fairly high res clock that works in all contexts and on all hosts. The
56 * virtual clock is paused when the VM isn't in the running state.
57 *
58 * The CPU tick (TSC) is normally virtualized as a function of the synchronous
59 * virtual clock, where the frequency defaults to the host cpu frequency (as we
60 * measure it). In this mode it is possible to configure the frequency. Another
61 * (non-default) option is to use the raw unmodified host TSC values. And yet
62 * another, to tie it to time spent executing guest code. All these things are
63 * configurable should non-default behavior be desirable.
64 *
65 * The real clock is a monotonic clock (when available) with relatively low
66 * resolution, though this a bit host specific. Note that we're currently not
67 * servicing timers using the real clock when the VM is not running, this is
68 * simply because it has not been needed yet therefore not implemented.
69 *
70 *
71 * @subsection subsec_tm_timesync Guest Time Sync / UTC time
72 *
73 * Guest time syncing is primarily taken care of by the VMM device. The
74 * principle is very simple, the guest additions periodically asks the VMM
75 * device what the current UTC time is and makes adjustments accordingly.
76 *
77 * A complicating factor is that the synchronous virtual clock might be doing
78 * catchups and the guest perception is currently a little bit behind the world
79 * but it will (hopefully) be catching up soon as we're feeding timer interrupts
80 * at a slightly higher rate. Adjusting the guest clock to the current wall
81 * time in the real world would be a bad idea then because the guest will be
82 * advancing too fast and run ahead of world time (if the catchup works out).
83 * To solve this problem TM provides the VMM device with an UTC time source that
84 * gets adjusted with the current lag, so that when the guest eventually catches
85 * up the lag it will be showing correct real world time.
86 *
87 *
88 * @section sec_tm_timers Timers
89 *
90 * The timers can use any of the TM clocks described in the previous section.
91 * Each clock has its own scheduling facility, or timer queue if you like.
92 * There are a few factors which makes it a bit complex. First, there is the
93 * usual R0 vs R3 vs. RC thing. Then there are multiple threads, and then there
94 * is the timer thread that periodically checks whether any timers has expired
95 * without EMT noticing. On the API level, all but the create and save APIs
96 * must be mulithreaded. EMT will always run the timers.
97 *
98 * The design is using a doubly linked list of active timers which is ordered
99 * by expire date. This list is only modified by the EMT thread. Updates to
100 * the list are batched in a singly linked list, which is then processed by the
101 * EMT thread at the first opportunity (immediately, next time EMT modifies a
102 * timer on that clock, or next timer timeout). Both lists are offset based and
103 * all the elements are therefore allocated from the hyper heap.
104 *
105 * For figuring out when there is need to schedule and run timers TM will:
106 * - Poll whenever somebody queries the virtual clock.
107 * - Poll the virtual clocks from the EM and REM loops.
108 * - Poll the virtual clocks from trap exit path.
109 * - Poll the virtual clocks and calculate first timeout from the halt loop.
110 * - Employ a thread which periodically (100Hz) polls all the timer queues.
111 *
112 *
113 * @image html TMTIMER-Statechart-Diagram.gif
114 *
115 * @section sec_tm_timer Logging
116 *
117 * Level 2: Logs a most of the timer state transitions and queue servicing.
118 * Level 3: Logs a few oddments.
119 * Level 4: Logs TMCLOCK_VIRTUAL_SYNC catch-up events.
120 *
121 */
122
123/*******************************************************************************
124* Header Files *
125*******************************************************************************/
126#define LOG_GROUP LOG_GROUP_TM
127#include <VBox/tm.h>
128#include <VBox/vmm.h>
129#include <VBox/mm.h>
130#include <VBox/ssm.h>
131#include <VBox/dbgf.h>
132#include <VBox/rem.h>
133#include <VBox/pdm.h>
134#include "TMInternal.h"
135#include <VBox/vm.h>
136
137#include <VBox/param.h>
138#include <VBox/err.h>
139
140#include <VBox/log.h>
141#include <iprt/asm.h>
142#include <iprt/assert.h>
143#include <iprt/thread.h>
144#include <iprt/time.h>
145#include <iprt/timer.h>
146#include <iprt/semaphore.h>
147#include <iprt/string.h>
148#include <iprt/env.h>
149
150
151/*******************************************************************************
152* Defined Constants And Macros *
153*******************************************************************************/
154/** The current saved state version.*/
155#define TM_SAVED_STATE_VERSION 3
156
157
158/*******************************************************************************
159* Internal Functions *
160*******************************************************************************/
161static bool tmR3HasFixedTSC(PVM pVM);
162static uint64_t tmR3CalibrateTSC(PVM pVM);
163static DECLCALLBACK(int) tmR3Save(PVM pVM, PSSMHANDLE pSSM);
164static DECLCALLBACK(int) tmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
165static DECLCALLBACK(void) tmR3TimerCallback(PRTTIMER pTimer, void *pvUser, uint64_t iTick);
166static void tmR3TimerQueueRun(PVM pVM, PTMTIMERQUEUE pQueue);
167static void tmR3TimerQueueRunVirtualSync(PVM pVM);
168static DECLCALLBACK(int) tmR3SetWarpDrive(PVM pVM, uint32_t u32Percent);
169static DECLCALLBACK(void) tmR3TimerInfo(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
170static DECLCALLBACK(void) tmR3TimerInfoActive(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
171static DECLCALLBACK(void) tmR3InfoClocks(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
172
173
174/**
175 * Initializes the TM.
176 *
177 * @returns VBox status code.
178 * @param pVM The VM to operate on.
179 */
180VMM_INT_DECL(int) TMR3Init(PVM pVM)
181{
182 LogFlow(("TMR3Init:\n"));
183
184 /*
185 * Assert alignment and sizes.
186 */
187 AssertCompileMemberAlignment(VM, tm.s, 32);
188 AssertCompile(sizeof(pVM->tm.s) <= sizeof(pVM->tm.padding));
189 AssertCompileMemberAlignment(TM, TimerCritSect, 8);
190 AssertCompileMemberAlignment(TM, VirtualSyncLock, 8);
191
192 /*
193 * Init the structure.
194 */
195 void *pv;
196 int rc = MMHyperAlloc(pVM, sizeof(pVM->tm.s.paTimerQueuesR3[0]) * TMCLOCK_MAX, 0, MM_TAG_TM, &pv);
197 AssertRCReturn(rc, rc);
198 pVM->tm.s.paTimerQueuesR3 = (PTMTIMERQUEUE)pv;
199 pVM->tm.s.paTimerQueuesR0 = MMHyperR3ToR0(pVM, pv);
200 pVM->tm.s.paTimerQueuesRC = MMHyperR3ToRC(pVM, pv);
201
202 pVM->tm.s.offVM = RT_OFFSETOF(VM, tm.s);
203 pVM->tm.s.idTimerCpu = pVM->cCpus - 1; /* The last CPU. */
204 pVM->tm.s.paTimerQueuesR3[TMCLOCK_VIRTUAL].enmClock = TMCLOCK_VIRTUAL;
205 pVM->tm.s.paTimerQueuesR3[TMCLOCK_VIRTUAL].u64Expire = INT64_MAX;
206 pVM->tm.s.paTimerQueuesR3[TMCLOCK_VIRTUAL_SYNC].enmClock = TMCLOCK_VIRTUAL_SYNC;
207 pVM->tm.s.paTimerQueuesR3[TMCLOCK_VIRTUAL_SYNC].u64Expire = INT64_MAX;
208 pVM->tm.s.paTimerQueuesR3[TMCLOCK_REAL].enmClock = TMCLOCK_REAL;
209 pVM->tm.s.paTimerQueuesR3[TMCLOCK_REAL].u64Expire = INT64_MAX;
210 pVM->tm.s.paTimerQueuesR3[TMCLOCK_TSC].enmClock = TMCLOCK_TSC;
211 pVM->tm.s.paTimerQueuesR3[TMCLOCK_TSC].u64Expire = INT64_MAX;
212
213
214 /*
215 * We directly use the GIP to calculate the virtual time. We map the
216 * the GIP into the guest context so we can do this calculation there
217 * as well and save costly world switches.
218 */
219 pVM->tm.s.pvGIPR3 = (void *)g_pSUPGlobalInfoPage;
220 AssertMsgReturn(pVM->tm.s.pvGIPR3, ("GIP support is now required!\n"), VERR_INTERNAL_ERROR);
221 RTHCPHYS HCPhysGIP;
222 rc = SUPR3GipGetPhys(&HCPhysGIP);
223 AssertMsgRCReturn(rc, ("Failed to get GIP physical address!\n"), rc);
224
225 RTGCPTR GCPtr;
226 rc = MMR3HyperMapHCPhys(pVM, pVM->tm.s.pvGIPR3, NIL_RTR0PTR, HCPhysGIP, PAGE_SIZE, "GIP", &GCPtr);
227 if (RT_FAILURE(rc))
228 {
229 AssertMsgFailed(("Failed to map GIP into GC, rc=%Rrc!\n", rc));
230 return rc;
231 }
232 pVM->tm.s.pvGIPRC = GCPtr;
233 LogFlow(("TMR3Init: HCPhysGIP=%RHp at %RRv\n", HCPhysGIP, pVM->tm.s.pvGIPRC));
234 MMR3HyperReserve(pVM, PAGE_SIZE, "fence", NULL);
235
236 /* Check assumptions made in TMAllVirtual.cpp about the GIP update interval. */
237 if ( g_pSUPGlobalInfoPage->u32Magic == SUPGLOBALINFOPAGE_MAGIC
238 && g_pSUPGlobalInfoPage->u32UpdateIntervalNS >= 250000000 /* 0.25s */)
239 return VMSetError(pVM, VERR_INTERNAL_ERROR, RT_SRC_POS,
240 N_("The GIP update interval is too big. u32UpdateIntervalNS=%RU32 (u32UpdateHz=%RU32)"),
241 g_pSUPGlobalInfoPage->u32UpdateIntervalNS, g_pSUPGlobalInfoPage->u32UpdateHz);
242 LogRel(("TM: GIP - u32Mode=%d (%s) u32UpdateHz=%u\n", g_pSUPGlobalInfoPage->u32Mode,
243 g_pSUPGlobalInfoPage->u32Mode == SUPGIPMODE_SYNC_TSC ? "SyncTSC"
244 : g_pSUPGlobalInfoPage->u32Mode == SUPGIPMODE_ASYNC_TSC ? "AsyncTSC" : "Unknown",
245 g_pSUPGlobalInfoPage->u32UpdateHz));
246
247 /*
248 * Setup the VirtualGetRaw backend.
249 */
250 pVM->tm.s.VirtualGetRawDataR3.pu64Prev = &pVM->tm.s.u64VirtualRawPrev;
251 pVM->tm.s.VirtualGetRawDataR3.pfnBad = tmVirtualNanoTSBad;
252 pVM->tm.s.VirtualGetRawDataR3.pfnRediscover = tmVirtualNanoTSRediscover;
253 if (ASMCpuId_EDX(1) & X86_CPUID_FEATURE_EDX_SSE2)
254 {
255 if (g_pSUPGlobalInfoPage->u32Mode == SUPGIPMODE_SYNC_TSC)
256 pVM->tm.s.pfnVirtualGetRawR3 = RTTimeNanoTSLFenceSync;
257 else
258 pVM->tm.s.pfnVirtualGetRawR3 = RTTimeNanoTSLFenceAsync;
259 }
260 else
261 {
262 if (g_pSUPGlobalInfoPage->u32Mode == SUPGIPMODE_SYNC_TSC)
263 pVM->tm.s.pfnVirtualGetRawR3 = RTTimeNanoTSLegacySync;
264 else
265 pVM->tm.s.pfnVirtualGetRawR3 = RTTimeNanoTSLegacyAsync;
266 }
267
268 pVM->tm.s.VirtualGetRawDataRC.pu64Prev = MMHyperR3ToRC(pVM, (void *)&pVM->tm.s.u64VirtualRawPrev);
269 pVM->tm.s.VirtualGetRawDataR0.pu64Prev = MMHyperR3ToR0(pVM, (void *)&pVM->tm.s.u64VirtualRawPrev);
270 AssertReturn(pVM->tm.s.VirtualGetRawDataR0.pu64Prev, VERR_INTERNAL_ERROR);
271 /* The rest is done in TMR3InitFinalize since it's too early to call PDM. */
272
273 /*
274 * Init the locks.
275 */
276 rc = PDMR3CritSectInit(pVM, &pVM->tm.s.TimerCritSect, "TM Timer Lock");
277 if (RT_FAILURE(rc))
278 return rc;
279 rc = PDMR3CritSectInit(pVM, &pVM->tm.s.VirtualSyncLock, "TM VirtualSync Lock");
280 if (RT_FAILURE(rc))
281 return rc;
282
283 /*
284 * Get our CFGM node, create it if necessary.
285 */
286 PCFGMNODE pCfgHandle = CFGMR3GetChild(CFGMR3GetRoot(pVM), "TM");
287 if (!pCfgHandle)
288 {
289 rc = CFGMR3InsertNode(CFGMR3GetRoot(pVM), "TM", &pCfgHandle);
290 AssertRCReturn(rc, rc);
291 }
292
293 /*
294 * Determin the TSC configuration and frequency.
295 */
296 /* mode */
297 /** @cfgm{/TM/TSCVirtualized,bool,true}
298 * Use a virtualize TSC, i.e. trap all TSC access. */
299 rc = CFGMR3QueryBool(pCfgHandle, "TSCVirtualized", &pVM->tm.s.fTSCVirtualized);
300 if (rc == VERR_CFGM_VALUE_NOT_FOUND)
301 pVM->tm.s.fTSCVirtualized = true; /* trap rdtsc */
302 else if (RT_FAILURE(rc))
303 return VMSetError(pVM, rc, RT_SRC_POS,
304 N_("Configuration error: Failed to querying bool value \"UseRealTSC\""));
305
306 /* source */
307 /** @cfgm{/TM/UseRealTSC,bool,false}
308 * Use the real TSC as time source for the TSC instead of the synchronous
309 * virtual clock (false, default). */
310 rc = CFGMR3QueryBool(pCfgHandle, "UseRealTSC", &pVM->tm.s.fTSCUseRealTSC);
311 if (rc == VERR_CFGM_VALUE_NOT_FOUND)
312 pVM->tm.s.fTSCUseRealTSC = false; /* use virtual time */
313 else if (RT_FAILURE(rc))
314 return VMSetError(pVM, rc, RT_SRC_POS,
315 N_("Configuration error: Failed to querying bool value \"UseRealTSC\""));
316 if (!pVM->tm.s.fTSCUseRealTSC)
317 pVM->tm.s.fTSCVirtualized = true;
318
319 /* TSC reliability */
320 /** @cfgm{/TM/MaybeUseOffsettedHostTSC,bool,detect}
321 * Whether the CPU has a fixed TSC rate and may be used in offsetted mode with
322 * VT-x/AMD-V execution. This is autodetected in a very restrictive way by
323 * default. */
324 rc = CFGMR3QueryBool(pCfgHandle, "MaybeUseOffsettedHostTSC", &pVM->tm.s.fMaybeUseOffsettedHostTSC);
325 if (rc == VERR_CFGM_VALUE_NOT_FOUND)
326 {
327 if (!pVM->tm.s.fTSCUseRealTSC)
328 pVM->tm.s.fMaybeUseOffsettedHostTSC = tmR3HasFixedTSC(pVM);
329 else
330 pVM->tm.s.fMaybeUseOffsettedHostTSC = true;
331 }
332
333 /** @cfgm{TM/TSCTicksPerSecond, uint32_t, Current TSC frequency from GIP}
334 * The number of TSC ticks per second (i.e. the TSC frequency). This will
335 * override TSCUseRealTSC, TSCVirtualized and MaybeUseOffsettedHostTSC.
336 */
337 rc = CFGMR3QueryU64(pCfgHandle, "TSCTicksPerSecond", &pVM->tm.s.cTSCTicksPerSecond);
338 if (rc == VERR_CFGM_VALUE_NOT_FOUND)
339 {
340 pVM->tm.s.cTSCTicksPerSecond = tmR3CalibrateTSC(pVM);
341 if ( !pVM->tm.s.fTSCUseRealTSC
342 && pVM->tm.s.cTSCTicksPerSecond >= _4G)
343 {
344 pVM->tm.s.cTSCTicksPerSecond = _4G - 1; /* (A limitation of our math code) */
345 pVM->tm.s.fMaybeUseOffsettedHostTSC = false;
346 }
347 }
348 else if (RT_FAILURE(rc))
349 return VMSetError(pVM, rc, RT_SRC_POS,
350 N_("Configuration error: Failed to querying uint64_t value \"TSCTicksPerSecond\""));
351 else if ( pVM->tm.s.cTSCTicksPerSecond < _1M
352 || pVM->tm.s.cTSCTicksPerSecond >= _4G)
353 return VMSetError(pVM, VERR_INVALID_PARAMETER, RT_SRC_POS,
354 N_("Configuration error: \"TSCTicksPerSecond\" = %RI64 is not in the range 1MHz..4GHz-1"),
355 pVM->tm.s.cTSCTicksPerSecond);
356 else
357 {
358 pVM->tm.s.fTSCUseRealTSC = pVM->tm.s.fMaybeUseOffsettedHostTSC = false;
359 pVM->tm.s.fTSCVirtualized = true;
360 }
361
362 /** @cfgm{TM/TSCTiedToExecution, bool, false}
363 * Whether the TSC should be tied to execution. This will exclude most of the
364 * virtualization overhead, but will by default include the time spent in the
365 * halt state (see TM/TSCNotTiedToHalt). This setting will override all other
366 * TSC settings except for TSCTicksPerSecond and TSCNotTiedToHalt, which should
367 * be used avoided or used with great care. Note that this will only work right
368 * together with VT-x or AMD-V, and with a single virtual CPU. */
369 rc = CFGMR3QueryBoolDef(pCfgHandle, "TSCTiedToExecution", &pVM->tm.s.fTSCTiedToExecution, false);
370 if (RT_FAILURE(rc))
371 return VMSetError(pVM, rc, RT_SRC_POS,
372 N_("Configuration error: Failed to querying bool value \"TSCTiedToExecution\""));
373 if (pVM->tm.s.fTSCTiedToExecution)
374 {
375 /* tied to execution, override all other settings. */
376 pVM->tm.s.fTSCVirtualized = true;
377 pVM->tm.s.fTSCUseRealTSC = true;
378 pVM->tm.s.fMaybeUseOffsettedHostTSC = false;
379 }
380
381 /** @cfgm{TM/TSCNotTiedToHalt, bool, true}
382 * For overriding the default of TM/TSCTiedToExecution, i.e. set this to false
383 * to make the TSC freeze during HLT. */
384 rc = CFGMR3QueryBoolDef(pCfgHandle, "TSCNotTiedToHalt", &pVM->tm.s.fTSCNotTiedToHalt, false);
385 if (RT_FAILURE(rc))
386 return VMSetError(pVM, rc, RT_SRC_POS,
387 N_("Configuration error: Failed to querying bool value \"TSCNotTiedToHalt\""));
388
389 /* setup and report */
390 if (pVM->tm.s.fTSCVirtualized)
391 CPUMR3SetCR4Feature(pVM, X86_CR4_TSD, ~X86_CR4_TSD);
392 else
393 CPUMR3SetCR4Feature(pVM, 0, ~X86_CR4_TSD);
394 LogRel(("TM: cTSCTicksPerSecond=%#RX64 (%'RU64) fTSCVirtualized=%RTbool fTSCUseRealTSC=%RTbool\n"
395 "TM: fMaybeUseOffsettedHostTSC=%RTbool TSCTiedToExecution=%RTbool TSCNotTiedToHalt=%RTbool\n",
396 pVM->tm.s.cTSCTicksPerSecond, pVM->tm.s.cTSCTicksPerSecond, pVM->tm.s.fTSCVirtualized, pVM->tm.s.fTSCUseRealTSC,
397 pVM->tm.s.fMaybeUseOffsettedHostTSC, pVM->tm.s.fTSCTiedToExecution, pVM->tm.s.fTSCNotTiedToHalt));
398
399 /*
400 * Configure the timer synchronous virtual time.
401 */
402 /** @cfgm{TM/ScheduleSlack, uint32_t, ns, 0, UINT32_MAX, 100000}
403 * Scheduling slack when processing timers. */
404 rc = CFGMR3QueryU32(pCfgHandle, "ScheduleSlack", &pVM->tm.s.u32VirtualSyncScheduleSlack);
405 if (rc == VERR_CFGM_VALUE_NOT_FOUND)
406 pVM->tm.s.u32VirtualSyncScheduleSlack = 100000; /* 0.100ms (ASSUMES virtual time is nanoseconds) */
407 else if (RT_FAILURE(rc))
408 return VMSetError(pVM, rc, RT_SRC_POS,
409 N_("Configuration error: Failed to querying 32-bit integer value \"ScheduleSlack\""));
410
411 /** @cfgm{TM/CatchUpStopThreshold, uint64_t, ns, 0, UINT64_MAX, 500000}
412 * When to stop a catch-up, considering it successful. */
413 rc = CFGMR3QueryU64(pCfgHandle, "CatchUpStopThreshold", &pVM->tm.s.u64VirtualSyncCatchUpStopThreshold);
414 if (rc == VERR_CFGM_VALUE_NOT_FOUND)
415 pVM->tm.s.u64VirtualSyncCatchUpStopThreshold = 500000; /* 0.5ms */
416 else if (RT_FAILURE(rc))
417 return VMSetError(pVM, rc, RT_SRC_POS,
418 N_("Configuration error: Failed to querying 64-bit integer value \"CatchUpStopThreshold\""));
419
420 /** @cfgm{TM/CatchUpGiveUpThreshold, uint64_t, ns, 0, UINT64_MAX, 60000000000}
421 * When to give up a catch-up attempt. */
422 rc = CFGMR3QueryU64(pCfgHandle, "CatchUpGiveUpThreshold", &pVM->tm.s.u64VirtualSyncCatchUpGiveUpThreshold);
423 if (rc == VERR_CFGM_VALUE_NOT_FOUND)
424 pVM->tm.s.u64VirtualSyncCatchUpGiveUpThreshold = UINT64_C(60000000000); /* 60 sec */
425 else if (RT_FAILURE(rc))
426 return VMSetError(pVM, rc, RT_SRC_POS,
427 N_("Configuration error: Failed to querying 64-bit integer value \"CatchUpGiveUpThreshold\""));
428
429
430 /** @cfgm{TM/CatchUpPrecentage[0..9], uint32_t, %, 1, 2000, various}
431 * The catch-up percent for a given period. */
432 /** @cfgm{TM/CatchUpStartThreshold[0..9], uint64_t, ns, 0, UINT64_MAX,
433 * The catch-up period threshold, or if you like, when a period starts. */
434#define TM_CFG_PERIOD(iPeriod, DefStart, DefPct) \
435 do \
436 { \
437 uint64_t u64; \
438 rc = CFGMR3QueryU64(pCfgHandle, "CatchUpStartThreshold" #iPeriod, &u64); \
439 if (rc == VERR_CFGM_VALUE_NOT_FOUND) \
440 u64 = UINT64_C(DefStart); \
441 else if (RT_FAILURE(rc)) \
442 return VMSetError(pVM, rc, RT_SRC_POS, N_("Configuration error: Failed to querying 64-bit integer value \"CatchUpThreshold" #iPeriod "\"")); \
443 if ( (iPeriod > 0 && u64 <= pVM->tm.s.aVirtualSyncCatchUpPeriods[iPeriod - 1].u64Start) \
444 || u64 >= pVM->tm.s.u64VirtualSyncCatchUpGiveUpThreshold) \
445 return VMSetError(pVM, VERR_INVALID_PARAMETER, RT_SRC_POS, N_("Configuration error: Invalid start of period #" #iPeriod ": %'RU64"), u64); \
446 pVM->tm.s.aVirtualSyncCatchUpPeriods[iPeriod].u64Start = u64; \
447 rc = CFGMR3QueryU32(pCfgHandle, "CatchUpPrecentage" #iPeriod, &pVM->tm.s.aVirtualSyncCatchUpPeriods[iPeriod].u32Percentage); \
448 if (rc == VERR_CFGM_VALUE_NOT_FOUND) \
449 pVM->tm.s.aVirtualSyncCatchUpPeriods[iPeriod].u32Percentage = (DefPct); \
450 else if (RT_FAILURE(rc)) \
451 return VMSetError(pVM, rc, RT_SRC_POS, N_("Configuration error: Failed to querying 32-bit integer value \"CatchUpPrecentage" #iPeriod "\"")); \
452 } while (0)
453 /* This needs more tuning. Not sure if we really need so many period and be so gentle. */
454 TM_CFG_PERIOD(0, 750000, 5); /* 0.75ms at 1.05x */
455 TM_CFG_PERIOD(1, 1500000, 10); /* 1.50ms at 1.10x */
456 TM_CFG_PERIOD(2, 8000000, 25); /* 8ms at 1.25x */
457 TM_CFG_PERIOD(3, 30000000, 50); /* 30ms at 1.50x */
458 TM_CFG_PERIOD(4, 75000000, 75); /* 75ms at 1.75x */
459 TM_CFG_PERIOD(5, 175000000, 100); /* 175ms at 2x */
460 TM_CFG_PERIOD(6, 500000000, 200); /* 500ms at 3x */
461 TM_CFG_PERIOD(7, 3000000000, 300); /* 3s at 4x */
462 TM_CFG_PERIOD(8,30000000000, 400); /* 30s at 5x */
463 TM_CFG_PERIOD(9,55000000000, 500); /* 55s at 6x */
464 AssertCompile(RT_ELEMENTS(pVM->tm.s.aVirtualSyncCatchUpPeriods) == 10);
465#undef TM_CFG_PERIOD
466
467 /*
468 * Configure real world time (UTC).
469 */
470 /** @cfgm{TM/UTCOffset, int64_t, ns, INT64_MIN, INT64_MAX, 0}
471 * The UTC offset. This is used to put the guest back or forwards in time. */
472 rc = CFGMR3QueryS64(pCfgHandle, "UTCOffset", &pVM->tm.s.offUTC);
473 if (rc == VERR_CFGM_VALUE_NOT_FOUND)
474 pVM->tm.s.offUTC = 0; /* ns */
475 else if (RT_FAILURE(rc))
476 return VMSetError(pVM, rc, RT_SRC_POS,
477 N_("Configuration error: Failed to querying 64-bit integer value \"UTCOffset\""));
478
479 /*
480 * Setup the warp drive.
481 */
482 /** @cfgm{TM/WarpDrivePercentage, uint32_t, %, 0, 20000, 100}
483 * The warp drive percentage, 100% is normal speed. This is used to speed up
484 * or slow down the virtual clock, which can be useful for fast forwarding
485 * borring periods during tests. */
486 rc = CFGMR3QueryU32(pCfgHandle, "WarpDrivePercentage", &pVM->tm.s.u32VirtualWarpDrivePercentage);
487 if (rc == VERR_CFGM_VALUE_NOT_FOUND)
488 rc = CFGMR3QueryU32(CFGMR3GetRoot(pVM), "WarpDrivePercentage", &pVM->tm.s.u32VirtualWarpDrivePercentage); /* legacy */
489 if (rc == VERR_CFGM_VALUE_NOT_FOUND)
490 pVM->tm.s.u32VirtualWarpDrivePercentage = 100;
491 else if (RT_FAILURE(rc))
492 return VMSetError(pVM, rc, RT_SRC_POS,
493 N_("Configuration error: Failed to querying uint32_t value \"WarpDrivePercent\""));
494 else if ( pVM->tm.s.u32VirtualWarpDrivePercentage < 2
495 || pVM->tm.s.u32VirtualWarpDrivePercentage > 20000)
496 return VMSetError(pVM, VERR_INVALID_PARAMETER, RT_SRC_POS,
497 N_("Configuration error: \"WarpDrivePercent\" = %RI32 is not in the range 2..20000"),
498 pVM->tm.s.u32VirtualWarpDrivePercentage);
499 pVM->tm.s.fVirtualWarpDrive = pVM->tm.s.u32VirtualWarpDrivePercentage != 100;
500 if (pVM->tm.s.fVirtualWarpDrive)
501 LogRel(("TM: u32VirtualWarpDrivePercentage=%RI32\n", pVM->tm.s.u32VirtualWarpDrivePercentage));
502
503 /*
504 * Start the timer (guard against REM not yielding).
505 */
506 /** @cfgm{TM/TimerMillies, uint32_t, ms, 1, 1000, 10}
507 * The watchdog timer interval. */
508 uint32_t u32Millies;
509 rc = CFGMR3QueryU32(pCfgHandle, "TimerMillies", &u32Millies);
510 if (rc == VERR_CFGM_VALUE_NOT_FOUND)
511 u32Millies = 10;
512 else if (RT_FAILURE(rc))
513 return VMSetError(pVM, rc, RT_SRC_POS,
514 N_("Configuration error: Failed to query uint32_t value \"TimerMillies\""));
515 rc = RTTimerCreate(&pVM->tm.s.pTimer, u32Millies, tmR3TimerCallback, pVM);
516 if (RT_FAILURE(rc))
517 {
518 AssertMsgFailed(("Failed to create timer, u32Millies=%d rc=%Rrc.\n", u32Millies, rc));
519 return rc;
520 }
521 Log(("TM: Created timer %p firing every %d millieseconds\n", pVM->tm.s.pTimer, u32Millies));
522 pVM->tm.s.u32TimerMillies = u32Millies;
523
524 /*
525 * Register saved state.
526 */
527 rc = SSMR3RegisterInternal(pVM, "tm", 1, TM_SAVED_STATE_VERSION, sizeof(uint64_t) * 8,
528 NULL, NULL, NULL,
529 NULL, tmR3Save, NULL,
530 NULL, tmR3Load, NULL);
531 if (RT_FAILURE(rc))
532 return rc;
533
534 /*
535 * Register statistics.
536 */
537 STAM_REL_REG_USED(pVM,(void*)&pVM->tm.s.VirtualGetRawDataR3.c1nsSteps,STAMTYPE_U32, "/TM/R3/1nsSteps", STAMUNIT_OCCURENCES, "Virtual time 1ns steps (due to TSC / GIP variations).");
538 STAM_REL_REG_USED(pVM,(void*)&pVM->tm.s.VirtualGetRawDataR3.cBadPrev, STAMTYPE_U32, "/TM/R3/cBadPrev", STAMUNIT_OCCURENCES, "Times the previous virtual time was considered erratic (shouldn't ever happen).");
539 STAM_REL_REG_USED(pVM,(void*)&pVM->tm.s.VirtualGetRawDataR0.c1nsSteps,STAMTYPE_U32, "/TM/R0/1nsSteps", STAMUNIT_OCCURENCES, "Virtual time 1ns steps (due to TSC / GIP variations).");
540 STAM_REL_REG_USED(pVM,(void*)&pVM->tm.s.VirtualGetRawDataR0.cBadPrev, STAMTYPE_U32, "/TM/R0/cBadPrev", STAMUNIT_OCCURENCES, "Times the previous virtual time was considered erratic (shouldn't ever happen).");
541 STAM_REL_REG_USED(pVM,(void*)&pVM->tm.s.VirtualGetRawDataRC.c1nsSteps,STAMTYPE_U32, "/TM/RC/1nsSteps", STAMUNIT_OCCURENCES, "Virtual time 1ns steps (due to TSC / GIP variations).");
542 STAM_REL_REG_USED(pVM,(void*)&pVM->tm.s.VirtualGetRawDataRC.cBadPrev, STAMTYPE_U32, "/TM/RC/cBadPrev", STAMUNIT_OCCURENCES, "Times the previous virtual time was considered erratic (shouldn't ever happen).");
543 STAM_REL_REG( pVM,(void*)&pVM->tm.s.offVirtualSync, STAMTYPE_U64, "/TM/VirtualSync/CurrentOffset", STAMUNIT_NS, "The current offset. (subtract GivenUp to get the lag)");
544 STAM_REL_REG_USED(pVM,(void*)&pVM->tm.s.offVirtualSyncGivenUp, STAMTYPE_U64, "/TM/VirtualSync/GivenUp", STAMUNIT_NS, "Nanoseconds of the 'CurrentOffset' that's been given up and won't ever be attemted caught up with.");
545
546#ifdef VBOX_WITH_STATISTICS
547 STAM_REG_USED(pVM,(void *)&pVM->tm.s.VirtualGetRawDataR3.cExpired, STAMTYPE_U32, "/TM/R3/cExpired", STAMUNIT_OCCURENCES, "Times the TSC interval expired (overlaps 1ns steps).");
548 STAM_REG_USED(pVM,(void *)&pVM->tm.s.VirtualGetRawDataR3.cUpdateRaces,STAMTYPE_U32, "/TM/R3/cUpdateRaces", STAMUNIT_OCCURENCES, "Thread races when updating the previous timestamp.");
549 STAM_REG_USED(pVM,(void *)&pVM->tm.s.VirtualGetRawDataR0.cExpired, STAMTYPE_U32, "/TM/R0/cExpired", STAMUNIT_OCCURENCES, "Times the TSC interval expired (overlaps 1ns steps).");
550 STAM_REG_USED(pVM,(void *)&pVM->tm.s.VirtualGetRawDataR0.cUpdateRaces,STAMTYPE_U32, "/TM/R0/cUpdateRaces", STAMUNIT_OCCURENCES, "Thread races when updating the previous timestamp.");
551 STAM_REG_USED(pVM,(void *)&pVM->tm.s.VirtualGetRawDataRC.cExpired, STAMTYPE_U32, "/TM/RC/cExpired", STAMUNIT_OCCURENCES, "Times the TSC interval expired (overlaps 1ns steps).");
552 STAM_REG_USED(pVM,(void *)&pVM->tm.s.VirtualGetRawDataRC.cUpdateRaces,STAMTYPE_U32, "/TM/RC/cUpdateRaces", STAMUNIT_OCCURENCES, "Thread races when updating the previous timestamp.");
553 STAM_REG(pVM, &pVM->tm.s.StatDoQueues, STAMTYPE_PROFILE, "/TM/DoQueues", STAMUNIT_TICKS_PER_CALL, "Profiling timer TMR3TimerQueuesDo.");
554 STAM_REG(pVM, &pVM->tm.s.aStatDoQueues[TMCLOCK_VIRTUAL], STAMTYPE_PROFILE_ADV, "/TM/DoQueues/Virtual", STAMUNIT_TICKS_PER_CALL, "Time spent on the virtual clock queue.");
555 STAM_REG(pVM, &pVM->tm.s.aStatDoQueues[TMCLOCK_VIRTUAL_SYNC], STAMTYPE_PROFILE_ADV, "/TM/DoQueues/VirtualSync", STAMUNIT_TICKS_PER_CALL, "Time spent on the virtual sync clock queue.");
556 STAM_REG(pVM, &pVM->tm.s.aStatDoQueues[TMCLOCK_REAL], STAMTYPE_PROFILE_ADV, "/TM/DoQueues/Real", STAMUNIT_TICKS_PER_CALL, "Time spent on the real clock queue.");
557
558 STAM_REG(pVM, &pVM->tm.s.StatPoll, STAMTYPE_COUNTER, "/TM/Poll", STAMUNIT_OCCURENCES, "TMTimerPoll calls.");
559 STAM_REG(pVM, &pVM->tm.s.StatPollAlreadySet, STAMTYPE_COUNTER, "/TM/Poll/AlreadySet", STAMUNIT_OCCURENCES, "TMTimerPoll calls where the FF was already set.");
560 STAM_REG(pVM, &pVM->tm.s.StatPollELoop, STAMTYPE_COUNTER, "/TM/Poll/ELoop", STAMUNIT_OCCURENCES, "Times TMTimerPoll has given up getting a consistent virtual sync data set.");
561 STAM_REG(pVM, &pVM->tm.s.StatPollMiss, STAMTYPE_COUNTER, "/TM/Poll/Miss", STAMUNIT_OCCURENCES, "TMTimerPoll calls where nothing had expired.");
562 STAM_REG(pVM, &pVM->tm.s.StatPollRunning, STAMTYPE_COUNTER, "/TM/Poll/Running", STAMUNIT_OCCURENCES, "TMTimerPoll calls where the queues were being run.");
563 STAM_REG(pVM, &pVM->tm.s.StatPollSimple, STAMTYPE_COUNTER, "/TM/Poll/Simple", STAMUNIT_OCCURENCES, "TMTimerPoll calls where we could take the simple path.");
564 STAM_REG(pVM, &pVM->tm.s.StatPollVirtual, STAMTYPE_COUNTER, "/TM/Poll/HitsVirtual", STAMUNIT_OCCURENCES, "The number of times TMTimerPoll found an expired TMCLOCK_VIRTUAL queue.");
565 STAM_REG(pVM, &pVM->tm.s.StatPollVirtualSync, STAMTYPE_COUNTER, "/TM/Poll/HitsVirtualSync", STAMUNIT_OCCURENCES, "The number of times TMTimerPoll found an expired TMCLOCK_VIRTUAL_SYNC queue.");
566
567 STAM_REG(pVM, &pVM->tm.s.StatPostponedR3, STAMTYPE_COUNTER, "/TM/PostponedR3", STAMUNIT_OCCURENCES, "Postponed due to unschedulable state, in ring-3.");
568 STAM_REG(pVM, &pVM->tm.s.StatPostponedRZ, STAMTYPE_COUNTER, "/TM/PostponedRZ", STAMUNIT_OCCURENCES, "Postponed due to unschedulable state, in ring-0 / RC.");
569
570 STAM_REG(pVM, &pVM->tm.s.StatScheduleOneR3, STAMTYPE_PROFILE, "/TM/ScheduleOneR3", STAMUNIT_TICKS_PER_CALL, "Profiling the scheduling of one queue during a TMTimer* call in EMT.");
571 STAM_REG(pVM, &pVM->tm.s.StatScheduleOneRZ, STAMTYPE_PROFILE, "/TM/ScheduleOneRZ", STAMUNIT_TICKS_PER_CALL, "Profiling the scheduling of one queue during a TMTimer* call in EMT.");
572 STAM_REG(pVM, &pVM->tm.s.StatScheduleSetFF, STAMTYPE_COUNTER, "/TM/ScheduleSetFF", STAMUNIT_OCCURENCES, "The number of times the timer FF was set instead of doing scheduling.");
573
574 STAM_REG(pVM, &pVM->tm.s.StatTimerSet, STAMTYPE_COUNTER, "/TM/TimerSet", STAMUNIT_OCCURENCES, "Calls");
575 STAM_REG(pVM, &pVM->tm.s.StatTimerSetOpt, STAMTYPE_COUNTER, "/TM/TimerSet/Opt", STAMUNIT_OCCURENCES, "Optimized path taken.");
576 STAM_REG(pVM, &pVM->tm.s.StatTimerSetR3, STAMTYPE_PROFILE, "/TM/TimerSet/R3", STAMUNIT_TICKS_PER_CALL, "Profiling TMTimerSet calls made in ring-3.");
577 STAM_REG(pVM, &pVM->tm.s.StatTimerSetRZ, STAMTYPE_PROFILE, "/TM/TimerSet/RZ", STAMUNIT_TICKS_PER_CALL, "Profiling TMTimerSet calls made in ring-0 / RC.");
578 STAM_REG(pVM, &pVM->tm.s.StatTimerSetStActive, STAMTYPE_COUNTER, "/TM/TimerSet/StActive", STAMUNIT_OCCURENCES, "ACTIVE");
579 STAM_REG(pVM, &pVM->tm.s.StatTimerSetStExpDeliver, STAMTYPE_COUNTER, "/TM/TimerSet/StExpDeliver", STAMUNIT_OCCURENCES, "EXPIRED_DELIVER");
580 STAM_REG(pVM, &pVM->tm.s.StatTimerSetStOther, STAMTYPE_COUNTER, "/TM/TimerSet/StOther", STAMUNIT_OCCURENCES, "Other states");
581 STAM_REG(pVM, &pVM->tm.s.StatTimerSetStPendStop, STAMTYPE_COUNTER, "/TM/TimerSet/StPendStop", STAMUNIT_OCCURENCES, "PENDING_STOP");
582 STAM_REG(pVM, &pVM->tm.s.StatTimerSetStPendStopSched, STAMTYPE_COUNTER, "/TM/TimerSet/StPendStopSched", STAMUNIT_OCCURENCES, "PENDING_STOP_SCHEDULE");
583 STAM_REG(pVM, &pVM->tm.s.StatTimerSetStPendSched, STAMTYPE_COUNTER, "/TM/TimerSet/StPendSched", STAMUNIT_OCCURENCES, "PENDING_SCHEDULE");
584 STAM_REG(pVM, &pVM->tm.s.StatTimerSetStPendResched, STAMTYPE_COUNTER, "/TM/TimerSet/StPendResched", STAMUNIT_OCCURENCES, "PENDING_RESCHEDULE");
585 STAM_REG(pVM, &pVM->tm.s.StatTimerSetStStopped, STAMTYPE_COUNTER, "/TM/TimerSet/StStopped", STAMUNIT_OCCURENCES, "STOPPED");
586
587 STAM_REG(pVM, &pVM->tm.s.StatTimerSetRelative, STAMTYPE_COUNTER, "/TM/TimerSetRelative", STAMUNIT_OCCURENCES, "Calls");
588 STAM_REG(pVM, &pVM->tm.s.StatTimerSetRelativeOpt, STAMTYPE_COUNTER, "/TM/TimerSetRelative/Opt", STAMUNIT_OCCURENCES, "Optimized path taken.");
589 STAM_REG(pVM, &pVM->tm.s.StatTimerSetRelativeR3, STAMTYPE_PROFILE, "/TM/TimerSetRelative/R3", STAMUNIT_TICKS_PER_CALL, "Profiling TMTimerSetRelative calls made in ring-3.");
590 STAM_REG(pVM, &pVM->tm.s.StatTimerSetRelativeRZ, STAMTYPE_PROFILE, "/TM/TimerSetRelative/RZ", STAMUNIT_TICKS_PER_CALL, "Profiling TMTimerSetReltaive calls made in ring-0 / RC.");
591 STAM_REG(pVM, &pVM->tm.s.StatTimerSetRelativeRacyVirtSync, STAMTYPE_COUNTER, "/TM/TimerSetRelative/RacyVirtSync", STAMUNIT_OCCURENCES, "Potentially racy virtual sync timer update.");
592 STAM_REG(pVM, &pVM->tm.s.StatTimerSetRelativeStActive, STAMTYPE_COUNTER, "/TM/TimerSetRelative/StActive", STAMUNIT_OCCURENCES, "ACTIVE");
593 STAM_REG(pVM, &pVM->tm.s.StatTimerSetRelativeStExpDeliver, STAMTYPE_COUNTER, "/TM/TimerSetRelative/StExpDeliver", STAMUNIT_OCCURENCES, "EXPIRED_DELIVER");
594 STAM_REG(pVM, &pVM->tm.s.StatTimerSetRelativeStOther, STAMTYPE_COUNTER, "/TM/TimerSetRelative/StOther", STAMUNIT_OCCURENCES, "Other states");
595 STAM_REG(pVM, &pVM->tm.s.StatTimerSetRelativeStPendStop, STAMTYPE_COUNTER, "/TM/TimerSetRelative/StPendStop", STAMUNIT_OCCURENCES, "PENDING_STOP");
596 STAM_REG(pVM, &pVM->tm.s.StatTimerSetRelativeStPendStopSched, STAMTYPE_COUNTER, "/TM/TimerSetRelative/StPendStopSched",STAMUNIT_OCCURENCES, "PENDING_STOP_SCHEDULE");
597 STAM_REG(pVM, &pVM->tm.s.StatTimerSetRelativeStPendSched, STAMTYPE_COUNTER, "/TM/TimerSetRelative/StPendSched", STAMUNIT_OCCURENCES, "PENDING_SCHEDULE");
598 STAM_REG(pVM, &pVM->tm.s.StatTimerSetRelativeStPendResched, STAMTYPE_COUNTER, "/TM/TimerSetRelative/StPendResched", STAMUNIT_OCCURENCES, "PENDING_RESCHEDULE");
599 STAM_REG(pVM, &pVM->tm.s.StatTimerSetRelativeStStopped, STAMTYPE_COUNTER, "/TM/TimerSetRelative/StStopped", STAMUNIT_OCCURENCES, "STOPPED");
600
601 STAM_REG(pVM, &pVM->tm.s.StatTimerStopR3, STAMTYPE_PROFILE, "/TM/TimerStopR3", STAMUNIT_TICKS_PER_CALL, "Profiling TMTimerStop calls made in ring-3.");
602 STAM_REG(pVM, &pVM->tm.s.StatTimerStopRZ, STAMTYPE_PROFILE, "/TM/TimerStopRZ", STAMUNIT_TICKS_PER_CALL, "Profiling TMTimerStop calls made in ring-0 / RC.");
603
604 STAM_REG(pVM, &pVM->tm.s.StatVirtualGet, STAMTYPE_COUNTER, "/TM/VirtualGet", STAMUNIT_OCCURENCES, "The number of times TMTimerGet was called when the clock was running.");
605 STAM_REG(pVM, &pVM->tm.s.StatVirtualGetSetFF, STAMTYPE_COUNTER, "/TM/VirtualGetSetFF", STAMUNIT_OCCURENCES, "Times we set the FF when calling TMTimerGet.");
606 STAM_REG(pVM, &pVM->tm.s.StatVirtualSyncGet, STAMTYPE_COUNTER, "/TM/VirtualSyncGet", STAMUNIT_OCCURENCES, "The number of times tmVirtualSyncGetEx was called.");
607 STAM_REG(pVM, &pVM->tm.s.StatVirtualSyncGetELoop, STAMTYPE_COUNTER, "/TM/VirtualSyncGet/ELoop", STAMUNIT_OCCURENCES, "Times tmVirtualSyncGetEx has given up getting a consistent virtual sync data set.");
608 STAM_REG(pVM, &pVM->tm.s.StatVirtualSyncGetExpired, STAMTYPE_COUNTER, "/TM/VirtualSyncGet/Expired", STAMUNIT_OCCURENCES, "Times tmVirtualSyncGetEx encountered an expired timer stopping the clock.");
609 STAM_REG(pVM, &pVM->tm.s.StatVirtualSyncGetLocked, STAMTYPE_COUNTER, "/TM/VirtualSyncGet/Locked", STAMUNIT_OCCURENCES, "Times we successfully acquired the lock in tmVirtualSyncGetEx.");
610 STAM_REG(pVM, &pVM->tm.s.StatVirtualSyncGetLockless, STAMTYPE_COUNTER, "/TM/VirtualSyncGet/Lockless", STAMUNIT_OCCURENCES, "Times tmVirtualSyncGetEx returned without needing to take the lock.");
611 STAM_REG(pVM, &pVM->tm.s.StatVirtualSyncGetSetFF, STAMTYPE_COUNTER, "/TM/VirtualSyncGet/SetFF", STAMUNIT_OCCURENCES, "Times we set the FF when calling tmVirtualSyncGetEx.");
612 STAM_REG(pVM, &pVM->tm.s.StatVirtualPause, STAMTYPE_COUNTER, "/TM/VirtualPause", STAMUNIT_OCCURENCES, "The number of times TMR3TimerPause was called.");
613 STAM_REG(pVM, &pVM->tm.s.StatVirtualResume, STAMTYPE_COUNTER, "/TM/VirtualResume", STAMUNIT_OCCURENCES, "The number of times TMR3TimerResume was called.");
614
615 STAM_REG(pVM, &pVM->tm.s.StatTimerCallbackSetFF, STAMTYPE_COUNTER, "/TM/CallbackSetFF", STAMUNIT_OCCURENCES, "The number of times the timer callback set FF.");
616
617 STAM_REG(pVM, &pVM->tm.s.StatTSCCatchupLE010, STAMTYPE_COUNTER, "/TM/TSC/Intercept/CatchupLE010", STAMUNIT_OCCURENCES, "In catch-up mode, 10% or lower.");
618 STAM_REG(pVM, &pVM->tm.s.StatTSCCatchupLE025, STAMTYPE_COUNTER, "/TM/TSC/Intercept/CatchupLE025", STAMUNIT_OCCURENCES, "In catch-up mode, 25%-11%.");
619 STAM_REG(pVM, &pVM->tm.s.StatTSCCatchupLE100, STAMTYPE_COUNTER, "/TM/TSC/Intercept/CatchupLE100", STAMUNIT_OCCURENCES, "In catch-up mode, 100%-26%.");
620 STAM_REG(pVM, &pVM->tm.s.StatTSCCatchupOther, STAMTYPE_COUNTER, "/TM/TSC/Intercept/CatchupOther", STAMUNIT_OCCURENCES, "In catch-up mode, > 100%.");
621 STAM_REG(pVM, &pVM->tm.s.StatTSCNotFixed, STAMTYPE_COUNTER, "/TM/TSC/Intercept/NotFixed", STAMUNIT_OCCURENCES, "TSC is not fixed, it may run at variable speed.");
622 STAM_REG(pVM, &pVM->tm.s.StatTSCNotTicking, STAMTYPE_COUNTER, "/TM/TSC/Intercept/NotTicking", STAMUNIT_OCCURENCES, "TSC is not ticking.");
623 STAM_REG(pVM, &pVM->tm.s.StatTSCSyncNotTicking, STAMTYPE_COUNTER, "/TM/TSC/Intercept/SyncNotTicking", STAMUNIT_OCCURENCES, "VirtualSync isn't ticking.");
624 STAM_REG(pVM, &pVM->tm.s.StatTSCWarp, STAMTYPE_COUNTER, "/TM/TSC/Intercept/Warp", STAMUNIT_OCCURENCES, "Warpdrive is active.");
625 STAM_REG(pVM, &pVM->tm.s.StatTSCSet, STAMTYPE_COUNTER, "/TM/TSC/Sets", STAMUNIT_OCCURENCES, "Calls to TMCpuTickSet.");
626 STAM_REG(pVM, &pVM->tm.s.StatTSCUnderflow, STAMTYPE_COUNTER, "/TM/TSC/Underflow", STAMUNIT_OCCURENCES, "TSC underflow; corrected with last seen value .");
627#endif /* VBOX_WITH_STATISTICS */
628
629 for (VMCPUID i = 0; i < pVM->cCpus; i++)
630 STAMR3RegisterF(pVM, &pVM->aCpus[i].tm.s.offTSCRawSrc, STAMTYPE_U64, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS, "TSC offset relative the raw source", "/TM/TSC/offCPU%u", i);
631
632#ifdef VBOX_WITH_STATISTICS
633 STAM_REG(pVM, &pVM->tm.s.StatVirtualSyncCatchup, STAMTYPE_PROFILE_ADV, "/TM/VirtualSync/CatchUp", STAMUNIT_TICKS_PER_OCCURENCE, "Counting and measuring the times spent catching up.");
634 STAM_REG(pVM, (void *)&pVM->tm.s.fVirtualSyncCatchUp, STAMTYPE_U8, "/TM/VirtualSync/CatchUpActive", STAMUNIT_NONE, "Catch-Up active indicator.");
635 STAM_REG(pVM, (void *)&pVM->tm.s.u32VirtualSyncCatchUpPercentage, STAMTYPE_U32, "/TM/VirtualSync/CatchUpPercentage", STAMUNIT_PCT, "The catch-up percentage. (+100/100 to get clock multiplier)");
636 STAM_REG(pVM, &pVM->tm.s.StatVirtualSyncFF, STAMTYPE_PROFILE, "/TM/VirtualSync/FF", STAMUNIT_TICKS_PER_OCCURENCE, "Time spent in TMR3VirtualSyncFF by all but the dedicate timer EMT.");
637 STAM_REG(pVM, &pVM->tm.s.StatVirtualSyncGiveUp, STAMTYPE_COUNTER, "/TM/VirtualSync/GiveUp", STAMUNIT_OCCURENCES, "Times the catch-up was abandoned.");
638 STAM_REG(pVM, &pVM->tm.s.StatVirtualSyncGiveUpBeforeStarting, STAMTYPE_COUNTER, "/TM/VirtualSync/GiveUpBeforeStarting",STAMUNIT_OCCURENCES, "Times the catch-up was abandoned before even starting. (Typically debugging++.)");
639 STAM_REG(pVM, &pVM->tm.s.StatVirtualSyncRun, STAMTYPE_COUNTER, "/TM/VirtualSync/Run", STAMUNIT_OCCURENCES, "Times the virtual sync timer queue was considered.");
640 STAM_REG(pVM, &pVM->tm.s.StatVirtualSyncRunRestart, STAMTYPE_COUNTER, "/TM/VirtualSync/Run/Restarts", STAMUNIT_OCCURENCES, "Times the clock was restarted after a run.");
641 STAM_REG(pVM, &pVM->tm.s.StatVirtualSyncRunStop, STAMTYPE_COUNTER, "/TM/VirtualSync/Run/Stop", STAMUNIT_OCCURENCES, "Times the clock was stopped when calculating the current time before examining the timers.");
642 STAM_REG(pVM, &pVM->tm.s.StatVirtualSyncRunStoppedAlready, STAMTYPE_COUNTER, "/TM/VirtualSync/Run/StoppedAlready", STAMUNIT_OCCURENCES, "Times the clock was already stopped elsewhere (TMVirtualSyncGet).");
643 STAM_REG(pVM, &pVM->tm.s.StatVirtualSyncRunSlack, STAMTYPE_PROFILE, "/TM/VirtualSync/Run/Slack", STAMUNIT_NS_PER_OCCURENCE, "The scheduling slack. (Catch-up handed out when running timers.)");
644 for (unsigned i = 0; i < RT_ELEMENTS(pVM->tm.s.aVirtualSyncCatchUpPeriods); i++)
645 {
646 STAMR3RegisterF(pVM, &pVM->tm.s.aVirtualSyncCatchUpPeriods[i].u32Percentage, STAMTYPE_U32, STAMVISIBILITY_ALWAYS, STAMUNIT_PCT, "The catch-up percentage.", "/TM/VirtualSync/Periods/%u", i);
647 STAMR3RegisterF(pVM, &pVM->tm.s.aStatVirtualSyncCatchupAdjust[i], STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, "Times adjusted to this period.", "/TM/VirtualSync/Periods/%u/Adjust", i);
648 STAMR3RegisterF(pVM, &pVM->tm.s.aStatVirtualSyncCatchupInitial[i], STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, "Times started in this period.", "/TM/VirtualSync/Periods/%u/Initial", i);
649 STAMR3RegisterF(pVM, &pVM->tm.s.aVirtualSyncCatchUpPeriods[i].u64Start, STAMTYPE_U64, STAMVISIBILITY_ALWAYS, STAMUNIT_NS, "Start of this period (lag).", "/TM/VirtualSync/Periods/%u/Start", i);
650 }
651#endif /* VBOX_WITH_STATISTICS */
652
653 /*
654 * Register info handlers.
655 */
656 DBGFR3InfoRegisterInternalEx(pVM, "timers", "Dumps all timers. No arguments.", tmR3TimerInfo, DBGFINFO_FLAGS_RUN_ON_EMT);
657 DBGFR3InfoRegisterInternalEx(pVM, "activetimers", "Dumps active all timers. No arguments.", tmR3TimerInfoActive, DBGFINFO_FLAGS_RUN_ON_EMT);
658 DBGFR3InfoRegisterInternalEx(pVM, "clocks", "Display the time of the various clocks.", tmR3InfoClocks, DBGFINFO_FLAGS_RUN_ON_EMT);
659
660 return VINF_SUCCESS;
661}
662
663
664/**
665 * Initializes the per-VCPU TM.
666 *
667 * @returns VBox status code.
668 * @param pVM The VM to operate on.
669 */
670VMM_INT_DECL(int) TMR3InitCPU(PVM pVM)
671{
672 LogFlow(("TMR3InitCPU\n"));
673 return VINF_SUCCESS;
674}
675
676
677/**
678 * Checks if the host CPU has a fixed TSC frequency.
679 *
680 * @returns true if it has, false if it hasn't.
681 *
682 * @remark This test doesn't bother with very old CPUs that don't do power
683 * management or any other stuff that might influence the TSC rate.
684 * This isn't currently relevant.
685 */
686static bool tmR3HasFixedTSC(PVM pVM)
687{
688 if (ASMHasCpuId())
689 {
690 uint32_t uEAX, uEBX, uECX, uEDX;
691
692 if (CPUMGetHostCpuVendor(pVM) == CPUMCPUVENDOR_AMD)
693 {
694 /*
695 * AuthenticAMD - Check for APM support and that TscInvariant is set.
696 *
697 * This test isn't correct with respect to fixed/non-fixed TSC and
698 * older models, but this isn't relevant since the result is currently
699 * only used for making a descision on AMD-V models.
700 */
701 ASMCpuId(0x80000000, &uEAX, &uEBX, &uECX, &uEDX);
702 if (uEAX >= 0x80000007)
703 {
704 PSUPGLOBALINFOPAGE pGip = g_pSUPGlobalInfoPage;
705
706 ASMCpuId(0x80000007, &uEAX, &uEBX, &uECX, &uEDX);
707 if ( (uEDX & X86_CPUID_AMD_ADVPOWER_EDX_TSCINVAR) /* TscInvariant */
708 && pGip->u32Mode == SUPGIPMODE_SYNC_TSC /* no fixed tsc if the gip timer is in async mode */)
709 return true;
710 }
711 }
712 else if (CPUMGetHostCpuVendor(pVM) == CPUMCPUVENDOR_INTEL)
713 {
714 /*
715 * GenuineIntel - Check the model number.
716 *
717 * This test is lacking in the same way and for the same reasons
718 * as the AMD test above.
719 */
720 ASMCpuId(1, &uEAX, &uEBX, &uECX, &uEDX);
721 unsigned uModel = (uEAX >> 4) & 0x0f;
722 unsigned uFamily = (uEAX >> 8) & 0x0f;
723 if (uFamily == 0x0f)
724 uFamily += (uEAX >> 20) & 0xff;
725 if (uFamily >= 0x06)
726 uModel += ((uEAX >> 16) & 0x0f) << 4;
727 if ( (uFamily == 0x0f /*P4*/ && uModel >= 0x03)
728 || (uFamily == 0x06 /*P2/P3*/ && uModel >= 0x0e))
729 return true;
730 }
731 }
732 return false;
733}
734
735
736/**
737 * Calibrate the CPU tick.
738 *
739 * @returns Number of ticks per second.
740 */
741static uint64_t tmR3CalibrateTSC(PVM pVM)
742{
743 /*
744 * Use GIP when available present.
745 */
746 uint64_t u64Hz;
747 PSUPGLOBALINFOPAGE pGip = g_pSUPGlobalInfoPage;
748 if ( pGip
749 && pGip->u32Magic == SUPGLOBALINFOPAGE_MAGIC)
750 {
751 unsigned iCpu = pGip->u32Mode != SUPGIPMODE_ASYNC_TSC ? 0 : ASMGetApicId();
752 if (iCpu >= RT_ELEMENTS(pGip->aCPUs))
753 AssertReleaseMsgFailed(("iCpu=%d - the ApicId is too high. send VBox.log and hardware specs!\n", iCpu));
754 else
755 {
756 if (tmR3HasFixedTSC(pVM))
757 /* Sleep a bit to get a more reliable CpuHz value. */
758 RTThreadSleep(32);
759 else
760 {
761 /* Spin for 40ms to try push up the CPU frequency and get a more reliable CpuHz value. */
762 const uint64_t u64 = RTTimeMilliTS();
763 while ((RTTimeMilliTS() - u64) < 40 /*ms*/)
764 /* nothing */;
765 }
766
767 pGip = g_pSUPGlobalInfoPage;
768 if ( pGip
769 && pGip->u32Magic == SUPGLOBALINFOPAGE_MAGIC
770 && (u64Hz = pGip->aCPUs[iCpu].u64CpuHz)
771 && u64Hz != ~(uint64_t)0)
772 return u64Hz;
773 }
774 }
775
776 /* call this once first to make sure it's initialized. */
777 RTTimeNanoTS();
778
779 /*
780 * Yield the CPU to increase our chances of getting
781 * a correct value.
782 */
783 RTThreadYield(); /* Try avoid interruptions between TSC and NanoTS samplings. */
784 static const unsigned s_auSleep[5] = { 50, 30, 30, 40, 40 };
785 uint64_t au64Samples[5];
786 unsigned i;
787 for (i = 0; i < RT_ELEMENTS(au64Samples); i++)
788 {
789 unsigned cMillies;
790 int cTries = 5;
791 uint64_t u64Start = ASMReadTSC();
792 uint64_t u64End;
793 uint64_t StartTS = RTTimeNanoTS();
794 uint64_t EndTS;
795 do
796 {
797 RTThreadSleep(s_auSleep[i]);
798 u64End = ASMReadTSC();
799 EndTS = RTTimeNanoTS();
800 cMillies = (unsigned)((EndTS - StartTS + 500000) / 1000000);
801 } while ( cMillies == 0 /* the sleep may be interrupted... */
802 || (cMillies < 20 && --cTries > 0));
803 uint64_t u64Diff = u64End - u64Start;
804
805 au64Samples[i] = (u64Diff * 1000) / cMillies;
806 AssertMsg(cTries > 0, ("cMillies=%d i=%d\n", cMillies, i));
807 }
808
809 /*
810 * Discard the highest and lowest results and calculate the average.
811 */
812 unsigned iHigh = 0;
813 unsigned iLow = 0;
814 for (i = 1; i < RT_ELEMENTS(au64Samples); i++)
815 {
816 if (au64Samples[i] < au64Samples[iLow])
817 iLow = i;
818 if (au64Samples[i] > au64Samples[iHigh])
819 iHigh = i;
820 }
821 au64Samples[iLow] = 0;
822 au64Samples[iHigh] = 0;
823
824 u64Hz = au64Samples[0];
825 for (i = 1; i < RT_ELEMENTS(au64Samples); i++)
826 u64Hz += au64Samples[i];
827 u64Hz /= RT_ELEMENTS(au64Samples) - 2;
828
829 return u64Hz;
830}
831
832
833/**
834 * Finalizes the TM initialization.
835 *
836 * @returns VBox status code.
837 * @param pVM The VM to operate on.
838 */
839VMM_INT_DECL(int) TMR3InitFinalize(PVM pVM)
840{
841 int rc;
842
843 rc = PDMR3LdrGetSymbolRCLazy(pVM, NULL, "tmVirtualNanoTSBad", &pVM->tm.s.VirtualGetRawDataRC.pfnBad);
844 AssertRCReturn(rc, rc);
845 rc = PDMR3LdrGetSymbolRCLazy(pVM, NULL, "tmVirtualNanoTSRediscover", &pVM->tm.s.VirtualGetRawDataRC.pfnRediscover);
846 AssertRCReturn(rc, rc);
847 if (pVM->tm.s.pfnVirtualGetRawR3 == RTTimeNanoTSLFenceSync)
848 rc = PDMR3LdrGetSymbolRCLazy(pVM, NULL, "RTTimeNanoTSLFenceSync", &pVM->tm.s.pfnVirtualGetRawRC);
849 else if (pVM->tm.s.pfnVirtualGetRawR3 == RTTimeNanoTSLFenceAsync)
850 rc = PDMR3LdrGetSymbolRCLazy(pVM, NULL, "RTTimeNanoTSLFenceAsync", &pVM->tm.s.pfnVirtualGetRawRC);
851 else if (pVM->tm.s.pfnVirtualGetRawR3 == RTTimeNanoTSLegacySync)
852 rc = PDMR3LdrGetSymbolRCLazy(pVM, NULL, "RTTimeNanoTSLegacySync", &pVM->tm.s.pfnVirtualGetRawRC);
853 else if (pVM->tm.s.pfnVirtualGetRawR3 == RTTimeNanoTSLegacyAsync)
854 rc = PDMR3LdrGetSymbolRCLazy(pVM, NULL, "RTTimeNanoTSLegacyAsync", &pVM->tm.s.pfnVirtualGetRawRC);
855 else
856 AssertFatalFailed();
857 AssertRCReturn(rc, rc);
858
859 rc = PDMR3LdrGetSymbolR0Lazy(pVM, NULL, "tmVirtualNanoTSBad", &pVM->tm.s.VirtualGetRawDataR0.pfnBad);
860 AssertRCReturn(rc, rc);
861 rc = PDMR3LdrGetSymbolR0Lazy(pVM, NULL, "tmVirtualNanoTSRediscover", &pVM->tm.s.VirtualGetRawDataR0.pfnRediscover);
862 AssertRCReturn(rc, rc);
863 if (pVM->tm.s.pfnVirtualGetRawR3 == RTTimeNanoTSLFenceSync)
864 rc = PDMR3LdrGetSymbolR0Lazy(pVM, NULL, "RTTimeNanoTSLFenceSync", &pVM->tm.s.pfnVirtualGetRawR0);
865 else if (pVM->tm.s.pfnVirtualGetRawR3 == RTTimeNanoTSLFenceAsync)
866 rc = PDMR3LdrGetSymbolR0Lazy(pVM, NULL, "RTTimeNanoTSLFenceAsync", &pVM->tm.s.pfnVirtualGetRawR0);
867 else if (pVM->tm.s.pfnVirtualGetRawR3 == RTTimeNanoTSLegacySync)
868 rc = PDMR3LdrGetSymbolR0Lazy(pVM, NULL, "RTTimeNanoTSLegacySync", &pVM->tm.s.pfnVirtualGetRawR0);
869 else if (pVM->tm.s.pfnVirtualGetRawR3 == RTTimeNanoTSLegacyAsync)
870 rc = PDMR3LdrGetSymbolR0Lazy(pVM, NULL, "RTTimeNanoTSLegacyAsync", &pVM->tm.s.pfnVirtualGetRawR0);
871 else
872 AssertFatalFailed();
873 AssertRCReturn(rc, rc);
874
875 return VINF_SUCCESS;
876}
877
878
879/**
880 * Applies relocations to data and code managed by this
881 * component. This function will be called at init and
882 * whenever the VMM need to relocate it self inside the GC.
883 *
884 * @param pVM The VM.
885 * @param offDelta Relocation delta relative to old location.
886 */
887VMM_INT_DECL(void) TMR3Relocate(PVM pVM, RTGCINTPTR offDelta)
888{
889 int rc;
890 LogFlow(("TMR3Relocate\n"));
891
892 pVM->tm.s.pvGIPRC = MMHyperR3ToRC(pVM, pVM->tm.s.pvGIPR3);
893 pVM->tm.s.paTimerQueuesRC = MMHyperR3ToRC(pVM, pVM->tm.s.paTimerQueuesR3);
894 pVM->tm.s.paTimerQueuesR0 = MMHyperR3ToR0(pVM, pVM->tm.s.paTimerQueuesR3);
895
896 pVM->tm.s.VirtualGetRawDataRC.pu64Prev = MMHyperR3ToRC(pVM, (void *)&pVM->tm.s.u64VirtualRawPrev);
897 AssertFatal(pVM->tm.s.VirtualGetRawDataRC.pu64Prev);
898 rc = PDMR3LdrGetSymbolRCLazy(pVM, NULL, "tmVirtualNanoTSBad", &pVM->tm.s.VirtualGetRawDataRC.pfnBad);
899 AssertFatalRC(rc);
900 rc = PDMR3LdrGetSymbolRCLazy(pVM, NULL, "tmVirtualNanoTSRediscover", &pVM->tm.s.VirtualGetRawDataRC.pfnRediscover);
901 AssertFatalRC(rc);
902
903 if (pVM->tm.s.pfnVirtualGetRawR3 == RTTimeNanoTSLFenceSync)
904 rc = PDMR3LdrGetSymbolRCLazy(pVM, NULL, "RTTimeNanoTSLFenceSync", &pVM->tm.s.pfnVirtualGetRawRC);
905 else if (pVM->tm.s.pfnVirtualGetRawR3 == RTTimeNanoTSLFenceAsync)
906 rc = PDMR3LdrGetSymbolRCLazy(pVM, NULL, "RTTimeNanoTSLFenceAsync", &pVM->tm.s.pfnVirtualGetRawRC);
907 else if (pVM->tm.s.pfnVirtualGetRawR3 == RTTimeNanoTSLegacySync)
908 rc = PDMR3LdrGetSymbolRCLazy(pVM, NULL, "RTTimeNanoTSLegacySync", &pVM->tm.s.pfnVirtualGetRawRC);
909 else if (pVM->tm.s.pfnVirtualGetRawR3 == RTTimeNanoTSLegacyAsync)
910 rc = PDMR3LdrGetSymbolRCLazy(pVM, NULL, "RTTimeNanoTSLegacyAsync", &pVM->tm.s.pfnVirtualGetRawRC);
911 else
912 AssertFatalFailed();
913 AssertFatalRC(rc);
914
915 /*
916 * Iterate the timers updating the pVMRC pointers.
917 */
918 for (PTMTIMER pTimer = pVM->tm.s.pCreated; pTimer; pTimer = pTimer->pBigNext)
919 {
920 pTimer->pVMRC = pVM->pVMRC;
921 pTimer->pVMR0 = pVM->pVMR0;
922 }
923}
924
925
926/**
927 * Terminates the TM.
928 *
929 * Termination means cleaning up and freeing all resources,
930 * the VM it self is at this point powered off or suspended.
931 *
932 * @returns VBox status code.
933 * @param pVM The VM to operate on.
934 */
935VMM_INT_DECL(int) TMR3Term(PVM pVM)
936{
937 AssertMsg(pVM->tm.s.offVM, ("bad init order!\n"));
938 if (pVM->tm.s.pTimer)
939 {
940 int rc = RTTimerDestroy(pVM->tm.s.pTimer);
941 AssertRC(rc);
942 pVM->tm.s.pTimer = NULL;
943 }
944
945 return VINF_SUCCESS;
946}
947
948
949/**
950 * Terminates the per-VCPU TM.
951 *
952 * Termination means cleaning up and freeing all resources,
953 * the VM it self is at this point powered off or suspended.
954 *
955 * @returns VBox status code.
956 * @param pVM The VM to operate on.
957 */
958VMM_INT_DECL(int) TMR3TermCPU(PVM pVM)
959{
960 return VINF_SUCCESS;
961}
962
963
964/**
965 * The VM is being reset.
966 *
967 * For the TM component this means that a rescheduling is preformed,
968 * the FF is cleared and but without running the queues. We'll have to
969 * check if this makes sense or not, but it seems like a good idea now....
970 *
971 * @param pVM VM handle.
972 */
973VMM_INT_DECL(void) TMR3Reset(PVM pVM)
974{
975 LogFlow(("TMR3Reset:\n"));
976 VM_ASSERT_EMT(pVM);
977 tmTimerLock(pVM);
978
979 /*
980 * Abort any pending catch up.
981 * This isn't perfect...
982 */
983 if (pVM->tm.s.fVirtualSyncCatchUp)
984 {
985 const uint64_t offVirtualNow = TMVirtualGetNoCheck(pVM);
986 const uint64_t offVirtualSyncNow = TMVirtualSyncGetNoCheck(pVM);
987 if (pVM->tm.s.fVirtualSyncCatchUp)
988 {
989 STAM_PROFILE_ADV_STOP(&pVM->tm.s.StatVirtualSyncCatchup, c);
990
991 const uint64_t offOld = pVM->tm.s.offVirtualSyncGivenUp;
992 const uint64_t offNew = offVirtualNow - offVirtualSyncNow;
993 Assert(offOld <= offNew);
994 ASMAtomicWriteU64((uint64_t volatile *)&pVM->tm.s.offVirtualSyncGivenUp, offNew);
995 ASMAtomicWriteU64((uint64_t volatile *)&pVM->tm.s.offVirtualSync, offNew);
996 ASMAtomicWriteBool(&pVM->tm.s.fVirtualSyncCatchUp, false);
997 LogRel(("TM: Aborting catch-up attempt on reset with a %'RU64 ns lag on reset; new total: %'RU64 ns\n", offNew - offOld, offNew));
998 }
999 }
1000
1001 /*
1002 * Process the queues.
1003 */
1004 for (int i = 0; i < TMCLOCK_MAX; i++)
1005 tmTimerQueueSchedule(pVM, &pVM->tm.s.paTimerQueuesR3[i]);
1006#ifdef VBOX_STRICT
1007 tmTimerQueuesSanityChecks(pVM, "TMR3Reset");
1008#endif
1009
1010 PVMCPU pVCpuDst = &pVM->aCpus[pVM->tm.s.idTimerCpu];
1011 VMCPU_FF_CLEAR(pVCpuDst, VMCPU_FF_TIMER); /** @todo FIXME: this isn't right. */
1012 tmTimerUnlock(pVM);
1013}
1014
1015
1016/**
1017 * Resolve a builtin RC symbol.
1018 * Called by PDM when loading or relocating GC modules.
1019 *
1020 * @returns VBox status
1021 * @param pVM VM Handle.
1022 * @param pszSymbol Symbol to resolve.
1023 * @param pRCPtrValue Where to store the symbol value.
1024 * @remark This has to work before TMR3Relocate() is called.
1025 */
1026VMM_INT_DECL(int) TMR3GetImportRC(PVM pVM, const char *pszSymbol, PRTRCPTR pRCPtrValue)
1027{
1028 if (!strcmp(pszSymbol, "g_pSUPGlobalInfoPage"))
1029 *pRCPtrValue = MMHyperR3ToRC(pVM, &pVM->tm.s.pvGIPRC);
1030 //else if (..)
1031 else
1032 return VERR_SYMBOL_NOT_FOUND;
1033 return VINF_SUCCESS;
1034}
1035
1036
1037/**
1038 * Execute state save operation.
1039 *
1040 * @returns VBox status code.
1041 * @param pVM VM Handle.
1042 * @param pSSM SSM operation handle.
1043 */
1044static DECLCALLBACK(int) tmR3Save(PVM pVM, PSSMHANDLE pSSM)
1045{
1046 LogFlow(("tmR3Save:\n"));
1047#ifdef VBOX_STRICT
1048 for (VMCPUID i = 0; i < pVM->cCpus; i++)
1049 {
1050 PVMCPU pVCpu = &pVM->aCpus[i];
1051 Assert(!pVCpu->tm.s.fTSCTicking);
1052 }
1053 Assert(!pVM->tm.s.cVirtualTicking);
1054 Assert(!pVM->tm.s.fVirtualSyncTicking);
1055#endif
1056
1057 /*
1058 * Save the virtual clocks.
1059 */
1060 /* the virtual clock. */
1061 SSMR3PutU64(pSSM, TMCLOCK_FREQ_VIRTUAL);
1062 SSMR3PutU64(pSSM, pVM->tm.s.u64Virtual);
1063
1064 /* the virtual timer synchronous clock. */
1065 SSMR3PutU64(pSSM, pVM->tm.s.u64VirtualSync);
1066 SSMR3PutU64(pSSM, pVM->tm.s.offVirtualSync);
1067 SSMR3PutU64(pSSM, pVM->tm.s.offVirtualSyncGivenUp);
1068 SSMR3PutU64(pSSM, pVM->tm.s.u64VirtualSyncCatchUpPrev);
1069 SSMR3PutBool(pSSM, pVM->tm.s.fVirtualSyncCatchUp);
1070
1071 /* real time clock */
1072 SSMR3PutU64(pSSM, TMCLOCK_FREQ_REAL);
1073
1074 /* the cpu tick clock. */
1075 for (VMCPUID i = 0; i < pVM->cCpus; i++)
1076 {
1077 PVMCPU pVCpu = &pVM->aCpus[i];
1078 SSMR3PutU64(pSSM, TMCpuTickGet(pVCpu));
1079 }
1080 return SSMR3PutU64(pSSM, pVM->tm.s.cTSCTicksPerSecond);
1081}
1082
1083
1084/**
1085 * Execute state load operation.
1086 *
1087 * @returns VBox status code.
1088 * @param pVM VM Handle.
1089 * @param pSSM SSM operation handle.
1090 * @param uVersion Data layout version.
1091 * @param uPass The data pass.
1092 */
1093static DECLCALLBACK(int) tmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
1094{
1095 LogFlow(("tmR3Load:\n"));
1096
1097 Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
1098#ifdef VBOX_STRICT
1099 for (VMCPUID i = 0; i < pVM->cCpus; i++)
1100 {
1101 PVMCPU pVCpu = &pVM->aCpus[i];
1102 Assert(!pVCpu->tm.s.fTSCTicking);
1103 }
1104 Assert(!pVM->tm.s.cVirtualTicking);
1105 Assert(!pVM->tm.s.fVirtualSyncTicking);
1106#endif
1107
1108 /*
1109 * Validate version.
1110 */
1111 if (uVersion != TM_SAVED_STATE_VERSION)
1112 {
1113 AssertMsgFailed(("tmR3Load: Invalid version uVersion=%d!\n", uVersion));
1114 return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
1115 }
1116
1117 /*
1118 * Load the virtual clock.
1119 */
1120 pVM->tm.s.cVirtualTicking = 0;
1121 /* the virtual clock. */
1122 uint64_t u64Hz;
1123 int rc = SSMR3GetU64(pSSM, &u64Hz);
1124 if (RT_FAILURE(rc))
1125 return rc;
1126 if (u64Hz != TMCLOCK_FREQ_VIRTUAL)
1127 {
1128 AssertMsgFailed(("The virtual clock frequency differs! Saved: %'RU64 Binary: %'RU64\n",
1129 u64Hz, TMCLOCK_FREQ_VIRTUAL));
1130 return VERR_SSM_VIRTUAL_CLOCK_HZ;
1131 }
1132 SSMR3GetU64(pSSM, &pVM->tm.s.u64Virtual);
1133 pVM->tm.s.u64VirtualOffset = 0;
1134
1135 /* the virtual timer synchronous clock. */
1136 pVM->tm.s.fVirtualSyncTicking = false;
1137 uint64_t u64;
1138 SSMR3GetU64(pSSM, &u64);
1139 pVM->tm.s.u64VirtualSync = u64;
1140 SSMR3GetU64(pSSM, &u64);
1141 pVM->tm.s.offVirtualSync = u64;
1142 SSMR3GetU64(pSSM, &u64);
1143 pVM->tm.s.offVirtualSyncGivenUp = u64;
1144 SSMR3GetU64(pSSM, &u64);
1145 pVM->tm.s.u64VirtualSyncCatchUpPrev = u64;
1146 bool f;
1147 SSMR3GetBool(pSSM, &f);
1148 pVM->tm.s.fVirtualSyncCatchUp = f;
1149
1150 /* the real clock */
1151 rc = SSMR3GetU64(pSSM, &u64Hz);
1152 if (RT_FAILURE(rc))
1153 return rc;
1154 if (u64Hz != TMCLOCK_FREQ_REAL)
1155 {
1156 AssertMsgFailed(("The real clock frequency differs! Saved: %'RU64 Binary: %'RU64\n",
1157 u64Hz, TMCLOCK_FREQ_REAL));
1158 return VERR_SSM_VIRTUAL_CLOCK_HZ; /* missleading... */
1159 }
1160
1161 /* the cpu tick clock. */
1162 for (VMCPUID i = 0; i < pVM->cCpus; i++)
1163 {
1164 PVMCPU pVCpu = &pVM->aCpus[i];
1165
1166 pVCpu->tm.s.fTSCTicking = false;
1167 SSMR3GetU64(pSSM, &pVCpu->tm.s.u64TSC);
1168
1169 if (pVM->tm.s.fTSCUseRealTSC)
1170 pVCpu->tm.s.offTSCRawSrc = 0; /** @todo TSC restore stuff and HWACC. */
1171 }
1172
1173 rc = SSMR3GetU64(pSSM, &u64Hz);
1174 if (RT_FAILURE(rc))
1175 return rc;
1176 if (!pVM->tm.s.fTSCUseRealTSC)
1177 pVM->tm.s.cTSCTicksPerSecond = u64Hz;
1178
1179 LogRel(("TM: cTSCTicksPerSecond=%#RX64 (%'RU64) fTSCVirtualized=%RTbool fTSCUseRealTSC=%RTbool (state load)\n",
1180 pVM->tm.s.cTSCTicksPerSecond, pVM->tm.s.cTSCTicksPerSecond, pVM->tm.s.fTSCVirtualized, pVM->tm.s.fTSCUseRealTSC));
1181
1182 /*
1183 * Make sure timers get rescheduled immediately.
1184 */
1185 PVMCPU pVCpuDst = &pVM->aCpus[pVM->tm.s.idTimerCpu];
1186 VMCPU_FF_SET(pVCpuDst, VMCPU_FF_TIMER);
1187
1188 return VINF_SUCCESS;
1189}
1190
1191
1192/**
1193 * Internal TMR3TimerCreate worker.
1194 *
1195 * @returns VBox status code.
1196 * @param pVM The VM handle.
1197 * @param enmClock The timer clock.
1198 * @param pszDesc The timer description.
1199 * @param ppTimer Where to store the timer pointer on success.
1200 */
1201static int tmr3TimerCreate(PVM pVM, TMCLOCK enmClock, const char *pszDesc, PPTMTIMERR3 ppTimer)
1202{
1203 VM_ASSERT_EMT(pVM);
1204
1205 /*
1206 * Allocate the timer.
1207 */
1208 PTMTIMERR3 pTimer = NULL;
1209 if (pVM->tm.s.pFree && VM_IS_EMT(pVM))
1210 {
1211 pTimer = pVM->tm.s.pFree;
1212 pVM->tm.s.pFree = pTimer->pBigNext;
1213 Log3(("TM: Recycling timer %p, new free head %p.\n", pTimer, pTimer->pBigNext));
1214 }
1215
1216 if (!pTimer)
1217 {
1218 int rc = MMHyperAlloc(pVM, sizeof(*pTimer), 0, MM_TAG_TM, (void **)&pTimer);
1219 if (RT_FAILURE(rc))
1220 return rc;
1221 Log3(("TM: Allocated new timer %p\n", pTimer));
1222 }
1223
1224 /*
1225 * Initialize it.
1226 */
1227 pTimer->u64Expire = 0;
1228 pTimer->enmClock = enmClock;
1229 pTimer->pVMR3 = pVM;
1230 pTimer->pVMR0 = pVM->pVMR0;
1231 pTimer->pVMRC = pVM->pVMRC;
1232 pTimer->enmState = TMTIMERSTATE_STOPPED;
1233 pTimer->offScheduleNext = 0;
1234 pTimer->offNext = 0;
1235 pTimer->offPrev = 0;
1236 pTimer->pvUser = NULL;
1237 pTimer->pCritSect = NULL;
1238 pTimer->pszDesc = pszDesc;
1239
1240 /* insert into the list of created timers. */
1241 tmTimerLock(pVM);
1242 pTimer->pBigPrev = NULL;
1243 pTimer->pBigNext = pVM->tm.s.pCreated;
1244 pVM->tm.s.pCreated = pTimer;
1245 if (pTimer->pBigNext)
1246 pTimer->pBigNext->pBigPrev = pTimer;
1247#ifdef VBOX_STRICT
1248 tmTimerQueuesSanityChecks(pVM, "tmR3TimerCreate");
1249#endif
1250 tmTimerUnlock(pVM);
1251
1252 *ppTimer = pTimer;
1253 return VINF_SUCCESS;
1254}
1255
1256
1257/**
1258 * Creates a device timer.
1259 *
1260 * @returns VBox status.
1261 * @param pVM The VM to create the timer in.
1262 * @param pDevIns Device instance.
1263 * @param enmClock The clock to use on this timer.
1264 * @param pfnCallback Callback function.
1265 * @param pvUser The user argument to the callback.
1266 * @param fFlags Timer creation flags, see grp_tm_timer_flags.
1267 * @param pszDesc Pointer to description string which must stay around
1268 * until the timer is fully destroyed (i.e. a bit after TMTimerDestroy()).
1269 * @param ppTimer Where to store the timer on success.
1270 */
1271VMM_INT_DECL(int) TMR3TimerCreateDevice(PVM pVM, PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback, void *pvUser, uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer)
1272{
1273 AssertReturn(!(fFlags & ~(TMTIMER_FLAGS_NO_CRIT_SECT)), VERR_INVALID_PARAMETER);
1274
1275 /*
1276 * Allocate and init stuff.
1277 */
1278 int rc = tmr3TimerCreate(pVM, enmClock, pszDesc, ppTimer);
1279 if (RT_SUCCESS(rc))
1280 {
1281 (*ppTimer)->enmType = TMTIMERTYPE_DEV;
1282 (*ppTimer)->u.Dev.pfnTimer = pfnCallback;
1283 (*ppTimer)->u.Dev.pDevIns = pDevIns;
1284 (*ppTimer)->pvUser = pvUser;
1285 if (fFlags & TMTIMER_FLAGS_DEFAULT_CRIT_SECT)
1286 (*ppTimer)->pCritSect = IOMR3GetCritSect(pVM);
1287 Log(("TM: Created device timer %p clock %d callback %p '%s'\n", (*ppTimer), enmClock, pfnCallback, pszDesc));
1288 }
1289
1290 return rc;
1291}
1292
1293
1294/**
1295 * Creates a driver timer.
1296 *
1297 * @returns VBox status.
1298 * @param pVM The VM to create the timer in.
1299 * @param pDrvIns Driver instance.
1300 * @param enmClock The clock to use on this timer.
1301 * @param pfnCallback Callback function.
1302 * @param pvUser The user argument to the callback.
1303 * @param fFlags Timer creation flags, see grp_tm_timer_flags.
1304 * @param pszDesc Pointer to description string which must stay around
1305 * until the timer is fully destroyed (i.e. a bit after TMTimerDestroy()).
1306 * @param ppTimer Where to store the timer on success.
1307 */
1308VMM_INT_DECL(int) TMR3TimerCreateDriver(PVM pVM, PPDMDRVINS pDrvIns, TMCLOCK enmClock, PFNTMTIMERDRV pfnCallback, void *pvUser,
1309 uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer)
1310{
1311 AssertReturn(!(fFlags & ~(TMTIMER_FLAGS_NO_CRIT_SECT)), VERR_INVALID_PARAMETER);
1312
1313 /*
1314 * Allocate and init stuff.
1315 */
1316 int rc = tmr3TimerCreate(pVM, enmClock, pszDesc, ppTimer);
1317 if (RT_SUCCESS(rc))
1318 {
1319 (*ppTimer)->enmType = TMTIMERTYPE_DRV;
1320 (*ppTimer)->u.Drv.pfnTimer = pfnCallback;
1321 (*ppTimer)->u.Drv.pDrvIns = pDrvIns;
1322 (*ppTimer)->pvUser = pvUser;
1323 Log(("TM: Created device timer %p clock %d callback %p '%s'\n", (*ppTimer), enmClock, pfnCallback, pszDesc));
1324 }
1325
1326 return rc;
1327}
1328
1329
1330/**
1331 * Creates an internal timer.
1332 *
1333 * @returns VBox status.
1334 * @param pVM The VM to create the timer in.
1335 * @param enmClock The clock to use on this timer.
1336 * @param pfnCallback Callback function.
1337 * @param pvUser User argument to be passed to the callback.
1338 * @param pszDesc Pointer to description string which must stay around
1339 * until the timer is fully destroyed (i.e. a bit after TMTimerDestroy()).
1340 * @param ppTimer Where to store the timer on success.
1341 */
1342VMMR3DECL(int) TMR3TimerCreateInternal(PVM pVM, TMCLOCK enmClock, PFNTMTIMERINT pfnCallback, void *pvUser, const char *pszDesc, PPTMTIMERR3 ppTimer)
1343{
1344 /*
1345 * Allocate and init stuff.
1346 */
1347 PTMTIMER pTimer;
1348 int rc = tmr3TimerCreate(pVM, enmClock, pszDesc, &pTimer);
1349 if (RT_SUCCESS(rc))
1350 {
1351 pTimer->enmType = TMTIMERTYPE_INTERNAL;
1352 pTimer->u.Internal.pfnTimer = pfnCallback;
1353 pTimer->pvUser = pvUser;
1354 *ppTimer = pTimer;
1355 Log(("TM: Created internal timer %p clock %d callback %p '%s'\n", pTimer, enmClock, pfnCallback, pszDesc));
1356 }
1357
1358 return rc;
1359}
1360
1361/**
1362 * Creates an external timer.
1363 *
1364 * @returns Timer handle on success.
1365 * @returns NULL on failure.
1366 * @param pVM The VM to create the timer in.
1367 * @param enmClock The clock to use on this timer.
1368 * @param pfnCallback Callback function.
1369 * @param pvUser User argument.
1370 * @param pszDesc Pointer to description string which must stay around
1371 * until the timer is fully destroyed (i.e. a bit after TMTimerDestroy()).
1372 */
1373VMMR3DECL(PTMTIMERR3) TMR3TimerCreateExternal(PVM pVM, TMCLOCK enmClock, PFNTMTIMEREXT pfnCallback, void *pvUser, const char *pszDesc)
1374{
1375 /*
1376 * Allocate and init stuff.
1377 */
1378 PTMTIMERR3 pTimer;
1379 int rc = tmr3TimerCreate(pVM, enmClock, pszDesc, &pTimer);
1380 if (RT_SUCCESS(rc))
1381 {
1382 pTimer->enmType = TMTIMERTYPE_EXTERNAL;
1383 pTimer->u.External.pfnTimer = pfnCallback;
1384 pTimer->pvUser = pvUser;
1385 Log(("TM: Created external timer %p clock %d callback %p '%s'\n", pTimer, enmClock, pfnCallback, pszDesc));
1386 return pTimer;
1387 }
1388
1389 return NULL;
1390}
1391
1392
1393/**
1394 * Destroy a timer
1395 *
1396 * @returns VBox status.
1397 * @param pTimer Timer handle as returned by one of the create functions.
1398 */
1399VMMR3DECL(int) TMR3TimerDestroy(PTMTIMER pTimer)
1400{
1401 /*
1402 * Be extra careful here.
1403 */
1404 if (!pTimer)
1405 return VINF_SUCCESS;
1406 AssertPtr(pTimer);
1407 Assert((unsigned)pTimer->enmClock < (unsigned)TMCLOCK_MAX);
1408
1409 PVM pVM = pTimer->CTX_SUFF(pVM);
1410 PTMTIMERQUEUE pQueue = &pVM->tm.s.CTX_SUFF(paTimerQueues)[pTimer->enmClock];
1411 bool fActive = false;
1412 bool fPending = false;
1413
1414 AssertMsg( !pTimer->pCritSect
1415 || VMR3GetState(pVM) != VMSTATE_RUNNING
1416 || PDMCritSectIsOwner(pTimer->pCritSect), ("%s\n", pTimer->pszDesc));
1417
1418 /*
1419 * The rest of the game happens behind the lock, just
1420 * like create does. All the work is done here.
1421 */
1422 tmTimerLock(pVM);
1423 for (int cRetries = 1000;; cRetries--)
1424 {
1425 /*
1426 * Change to the DESTROY state.
1427 */
1428 TMTIMERSTATE enmState = pTimer->enmState;
1429 TMTIMERSTATE enmNewState = enmState;
1430 Log2(("TMTimerDestroy: %p:{.enmState=%s, .pszDesc='%s'} cRetries=%d\n",
1431 pTimer, tmTimerState(enmState), R3STRING(pTimer->pszDesc), cRetries));
1432 switch (enmState)
1433 {
1434 case TMTIMERSTATE_STOPPED:
1435 case TMTIMERSTATE_EXPIRED_DELIVER:
1436 break;
1437
1438 case TMTIMERSTATE_ACTIVE:
1439 fActive = true;
1440 break;
1441
1442 case TMTIMERSTATE_PENDING_STOP:
1443 case TMTIMERSTATE_PENDING_STOP_SCHEDULE:
1444 case TMTIMERSTATE_PENDING_RESCHEDULE:
1445 fActive = true;
1446 fPending = true;
1447 break;
1448
1449 case TMTIMERSTATE_PENDING_SCHEDULE:
1450 fPending = true;
1451 break;
1452
1453 /*
1454 * This shouldn't happen as the caller should make sure there are no races.
1455 */
1456 case TMTIMERSTATE_EXPIRED_GET_UNLINK:
1457 case TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE:
1458 case TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE:
1459 AssertMsgFailed(("%p:.enmState=%s %s\n", pTimer, tmTimerState(enmState), pTimer->pszDesc));
1460 tmTimerUnlock(pVM);
1461 if (!RTThreadYield())
1462 RTThreadSleep(1);
1463 AssertMsgReturn(cRetries > 0, ("Failed waiting for stable state. state=%d (%s)\n", pTimer->enmState, pTimer->pszDesc),
1464 VERR_TM_UNSTABLE_STATE);
1465 tmTimerLock(pVM);
1466 continue;
1467
1468 /*
1469 * Invalid states.
1470 */
1471 case TMTIMERSTATE_FREE:
1472 case TMTIMERSTATE_DESTROY:
1473 tmTimerUnlock(pVM);
1474 AssertLogRelMsgFailedReturn(("pTimer=%p %s\n", pTimer, tmTimerState(enmState)), VERR_TM_INVALID_STATE);
1475
1476 default:
1477 AssertMsgFailed(("Unknown timer state %d (%s)\n", enmState, R3STRING(pTimer->pszDesc)));
1478 tmTimerUnlock(pVM);
1479 return VERR_TM_UNKNOWN_STATE;
1480 }
1481
1482 /*
1483 * Try switch to the destroy state.
1484 * This should always succeed as the caller should make sure there are no race.
1485 */
1486 bool fRc;
1487 TM_TRY_SET_STATE(pTimer, TMTIMERSTATE_DESTROY, enmState, fRc);
1488 if (fRc)
1489 break;
1490 AssertMsgFailed(("%p:.enmState=%s %s\n", pTimer, tmTimerState(enmState), pTimer->pszDesc));
1491 tmTimerUnlock(pVM);
1492 AssertMsgReturn(cRetries > 0, ("Failed waiting for stable state. state=%d (%s)\n", pTimer->enmState, pTimer->pszDesc),
1493 VERR_TM_UNSTABLE_STATE);
1494 tmTimerLock(pVM);
1495 }
1496
1497 /*
1498 * Unlink from the active list.
1499 */
1500 if (fActive)
1501 {
1502 const PTMTIMER pPrev = TMTIMER_GET_PREV(pTimer);
1503 const PTMTIMER pNext = TMTIMER_GET_NEXT(pTimer);
1504 if (pPrev)
1505 TMTIMER_SET_NEXT(pPrev, pNext);
1506 else
1507 {
1508 TMTIMER_SET_HEAD(pQueue, pNext);
1509 pQueue->u64Expire = pNext ? pNext->u64Expire : INT64_MAX;
1510 }
1511 if (pNext)
1512 TMTIMER_SET_PREV(pNext, pPrev);
1513 pTimer->offNext = 0;
1514 pTimer->offPrev = 0;
1515 }
1516
1517 /*
1518 * Unlink from the schedule list by running it.
1519 */
1520 if (fPending)
1521 {
1522 Log3(("TMR3TimerDestroy: tmTimerQueueSchedule\n"));
1523 STAM_PROFILE_START(&pVM->tm.s.CTX_SUFF_Z(StatScheduleOne), a);
1524 Assert(pQueue->offSchedule);
1525 tmTimerQueueSchedule(pVM, pQueue);
1526 }
1527
1528 /*
1529 * Read to move the timer from the created list and onto the free list.
1530 */
1531 Assert(!pTimer->offNext); Assert(!pTimer->offPrev); Assert(!pTimer->offScheduleNext);
1532
1533 /* unlink from created list */
1534 if (pTimer->pBigPrev)
1535 pTimer->pBigPrev->pBigNext = pTimer->pBigNext;
1536 else
1537 pVM->tm.s.pCreated = pTimer->pBigNext;
1538 if (pTimer->pBigNext)
1539 pTimer->pBigNext->pBigPrev = pTimer->pBigPrev;
1540 pTimer->pBigNext = 0;
1541 pTimer->pBigPrev = 0;
1542
1543 /* free */
1544 Log2(("TM: Inserting %p into the free list ahead of %p!\n", pTimer, pVM->tm.s.pFree));
1545 TM_SET_STATE(pTimer, TMTIMERSTATE_FREE);
1546 pTimer->pBigNext = pVM->tm.s.pFree;
1547 pVM->tm.s.pFree = pTimer;
1548
1549#ifdef VBOX_STRICT
1550 tmTimerQueuesSanityChecks(pVM, "TMR3TimerDestroy");
1551#endif
1552 tmTimerUnlock(pVM);
1553 return VINF_SUCCESS;
1554}
1555
1556
1557/**
1558 * Destroy all timers owned by a device.
1559 *
1560 * @returns VBox status.
1561 * @param pVM VM handle.
1562 * @param pDevIns Device which timers should be destroyed.
1563 */
1564VMM_INT_DECL(int) TMR3TimerDestroyDevice(PVM pVM, PPDMDEVINS pDevIns)
1565{
1566 LogFlow(("TMR3TimerDestroyDevice: pDevIns=%p\n", pDevIns));
1567 if (!pDevIns)
1568 return VERR_INVALID_PARAMETER;
1569
1570 tmTimerLock(pVM);
1571 PTMTIMER pCur = pVM->tm.s.pCreated;
1572 while (pCur)
1573 {
1574 PTMTIMER pDestroy = pCur;
1575 pCur = pDestroy->pBigNext;
1576 if ( pDestroy->enmType == TMTIMERTYPE_DEV
1577 && pDestroy->u.Dev.pDevIns == pDevIns)
1578 {
1579 int rc = TMR3TimerDestroy(pDestroy);
1580 AssertRC(rc);
1581 }
1582 }
1583 tmTimerUnlock(pVM);
1584
1585 LogFlow(("TMR3TimerDestroyDevice: returns VINF_SUCCESS\n"));
1586 return VINF_SUCCESS;
1587}
1588
1589
1590/**
1591 * Destroy all timers owned by a driver.
1592 *
1593 * @returns VBox status.
1594 * @param pVM VM handle.
1595 * @param pDrvIns Driver which timers should be destroyed.
1596 */
1597VMM_INT_DECL(int) TMR3TimerDestroyDriver(PVM pVM, PPDMDRVINS pDrvIns)
1598{
1599 LogFlow(("TMR3TimerDestroyDriver: pDrvIns=%p\n", pDrvIns));
1600 if (!pDrvIns)
1601 return VERR_INVALID_PARAMETER;
1602
1603 tmTimerLock(pVM);
1604 PTMTIMER pCur = pVM->tm.s.pCreated;
1605 while (pCur)
1606 {
1607 PTMTIMER pDestroy = pCur;
1608 pCur = pDestroy->pBigNext;
1609 if ( pDestroy->enmType == TMTIMERTYPE_DRV
1610 && pDestroy->u.Drv.pDrvIns == pDrvIns)
1611 {
1612 int rc = TMR3TimerDestroy(pDestroy);
1613 AssertRC(rc);
1614 }
1615 }
1616 tmTimerUnlock(pVM);
1617
1618 LogFlow(("TMR3TimerDestroyDriver: returns VINF_SUCCESS\n"));
1619 return VINF_SUCCESS;
1620}
1621
1622
1623/**
1624 * Internal function for getting the clock time.
1625 *
1626 * @returns clock time.
1627 * @param pVM The VM handle.
1628 * @param enmClock The clock.
1629 */
1630DECLINLINE(uint64_t) tmClock(PVM pVM, TMCLOCK enmClock)
1631{
1632 switch (enmClock)
1633 {
1634 case TMCLOCK_VIRTUAL: return TMVirtualGet(pVM);
1635 case TMCLOCK_VIRTUAL_SYNC: return TMVirtualSyncGet(pVM);
1636 case TMCLOCK_REAL: return TMRealGet(pVM);
1637 case TMCLOCK_TSC: return TMCpuTickGet(&pVM->aCpus[0] /* just take VCPU 0 */);
1638 default:
1639 AssertMsgFailed(("enmClock=%d\n", enmClock));
1640 return ~(uint64_t)0;
1641 }
1642}
1643
1644
1645/**
1646 * Checks if the sync queue has one or more expired timers.
1647 *
1648 * @returns true / false.
1649 *
1650 * @param pVM The VM handle.
1651 * @param enmClock The queue.
1652 */
1653DECLINLINE(bool) tmR3HasExpiredTimer(PVM pVM, TMCLOCK enmClock)
1654{
1655 const uint64_t u64Expire = pVM->tm.s.CTX_SUFF(paTimerQueues)[enmClock].u64Expire;
1656 return u64Expire != INT64_MAX && u64Expire <= tmClock(pVM, enmClock);
1657}
1658
1659
1660/**
1661 * Checks for expired timers in all the queues.
1662 *
1663 * @returns true / false.
1664 * @param pVM The VM handle.
1665 */
1666DECLINLINE(bool) tmR3AnyExpiredTimers(PVM pVM)
1667{
1668 /*
1669 * Combine the time calculation for the first two since we're not on EMT
1670 * TMVirtualSyncGet only permits EMT.
1671 */
1672 uint64_t u64Now = TMVirtualGetNoCheck(pVM);
1673 if (pVM->tm.s.CTX_SUFF(paTimerQueues)[TMCLOCK_VIRTUAL].u64Expire <= u64Now)
1674 return true;
1675 u64Now = pVM->tm.s.fVirtualSyncTicking
1676 ? u64Now - pVM->tm.s.offVirtualSync
1677 : pVM->tm.s.u64VirtualSync;
1678 if (pVM->tm.s.CTX_SUFF(paTimerQueues)[TMCLOCK_VIRTUAL_SYNC].u64Expire <= u64Now)
1679 return true;
1680
1681 /*
1682 * The remaining timers.
1683 */
1684 if (tmR3HasExpiredTimer(pVM, TMCLOCK_REAL))
1685 return true;
1686 if (tmR3HasExpiredTimer(pVM, TMCLOCK_TSC))
1687 return true;
1688 return false;
1689}
1690
1691
1692/**
1693 * Schedulation timer callback.
1694 *
1695 * @param pTimer Timer handle.
1696 * @param pvUser VM handle.
1697 * @thread Timer thread.
1698 *
1699 * @remark We cannot do the scheduling and queues running from a timer handler
1700 * since it's not executing in EMT, and even if it was it would be async
1701 * and we wouldn't know the state of the affairs.
1702 * So, we'll just raise the timer FF and force any REM execution to exit.
1703 */
1704static DECLCALLBACK(void) tmR3TimerCallback(PRTTIMER pTimer, void *pvUser, uint64_t /*iTick*/)
1705{
1706 PVM pVM = (PVM)pvUser;
1707 PVMCPU pVCpuDst = &pVM->aCpus[pVM->tm.s.idTimerCpu];
1708
1709 AssertCompile(TMCLOCK_MAX == 4);
1710#ifdef DEBUG_Sander /* very annoying, keep it private. */
1711 if (VMCPU_FF_ISSET(pVCpuDst, VMCPU_FF_TIMER))
1712 Log(("tmR3TimerCallback: timer event still pending!!\n"));
1713#endif
1714 if ( !VMCPU_FF_ISSET(pVCpuDst, VMCPU_FF_TIMER)
1715 && ( pVM->tm.s.paTimerQueuesR3[TMCLOCK_VIRTUAL_SYNC].offSchedule /** @todo FIXME - reconsider offSchedule as a reason for running the timer queues. */
1716 || pVM->tm.s.paTimerQueuesR3[TMCLOCK_VIRTUAL].offSchedule
1717 || pVM->tm.s.paTimerQueuesR3[TMCLOCK_REAL].offSchedule
1718 || pVM->tm.s.paTimerQueuesR3[TMCLOCK_TSC].offSchedule
1719 || tmR3AnyExpiredTimers(pVM)
1720 )
1721 && !VMCPU_FF_ISSET(pVCpuDst, VMCPU_FF_TIMER)
1722 && !pVM->tm.s.fRunningQueues
1723 )
1724 {
1725 Log5(("TM(%u): FF: 0 -> 1\n", __LINE__));
1726 VMCPU_FF_SET(pVCpuDst, VMCPU_FF_TIMER);
1727 REMR3NotifyTimerPending(pVM, pVCpuDst);
1728 VMR3NotifyCpuFFU(pVCpuDst->pUVCpu, VMNOTIFYFF_FLAGS_DONE_REM /** @todo | VMNOTIFYFF_FLAGS_POKE ?*/);
1729 STAM_COUNTER_INC(&pVM->tm.s.StatTimerCallbackSetFF);
1730 }
1731}
1732
1733
1734/**
1735 * Schedules and runs any pending timers.
1736 *
1737 * This is normally called from a forced action handler in EMT.
1738 *
1739 * @param pVM The VM to run the timers for.
1740 *
1741 * @thread EMT (actually EMT0, but we fend off the others)
1742 */
1743VMMR3DECL(void) TMR3TimerQueuesDo(PVM pVM)
1744{
1745 /*
1746 * Only the dedicated timer EMT should do stuff here.
1747 * (fRunningQueues is only used as an indicator.)
1748 */
1749 Assert(pVM->tm.s.idTimerCpu < pVM->cCpus);
1750 PVMCPU pVCpuDst = &pVM->aCpus[pVM->tm.s.idTimerCpu];
1751 if (VMMGetCpu(pVM) != pVCpuDst)
1752 {
1753 Assert(pVM->cCpus > 1);
1754 return;
1755 }
1756 STAM_PROFILE_START(&pVM->tm.s.StatDoQueues, a);
1757 Log2(("TMR3TimerQueuesDo:\n"));
1758 Assert(!pVM->tm.s.fRunningQueues);
1759 ASMAtomicWriteBool(&pVM->tm.s.fRunningQueues, true);
1760 tmTimerLock(pVM);
1761
1762 /*
1763 * Process the queues.
1764 */
1765 AssertCompile(TMCLOCK_MAX == 4);
1766
1767 /* TMCLOCK_VIRTUAL_SYNC (see also TMR3VirtualSyncFF) */
1768 STAM_PROFILE_ADV_START(&pVM->tm.s.aStatDoQueues[TMCLOCK_VIRTUAL_SYNC], s1);
1769 tmVirtualSyncLock(pVM);
1770 ASMAtomicWriteBool(&pVM->tm.s.fRunningVirtualSyncQueue, true);
1771 VMCPU_FF_CLEAR(pVCpuDst, VMCPU_FF_TIMER); /* Clear the FF once we started working for real. */
1772
1773 if (pVM->tm.s.paTimerQueuesR3[TMCLOCK_VIRTUAL_SYNC].offSchedule)
1774 tmTimerQueueSchedule(pVM, &pVM->tm.s.paTimerQueuesR3[TMCLOCK_VIRTUAL_SYNC]);
1775 tmR3TimerQueueRunVirtualSync(pVM);
1776 if (pVM->tm.s.fVirtualSyncTicking) /** @todo move into tmR3TimerQueueRunVirtualSync - FIXME */
1777 VM_FF_CLEAR(pVM, VM_FF_TM_VIRTUAL_SYNC);
1778
1779 ASMAtomicWriteBool(&pVM->tm.s.fRunningVirtualSyncQueue, false);
1780 tmVirtualSyncUnlock(pVM);
1781 STAM_PROFILE_ADV_STOP(&pVM->tm.s.aStatDoQueues[TMCLOCK_VIRTUAL_SYNC], s1);
1782
1783 /* TMCLOCK_VIRTUAL */
1784 STAM_PROFILE_ADV_START(&pVM->tm.s.aStatDoQueues[TMCLOCK_VIRTUAL], s2);
1785 if (pVM->tm.s.paTimerQueuesR3[TMCLOCK_VIRTUAL].offSchedule)
1786 tmTimerQueueSchedule(pVM, &pVM->tm.s.paTimerQueuesR3[TMCLOCK_VIRTUAL]);
1787 tmR3TimerQueueRun(pVM, &pVM->tm.s.paTimerQueuesR3[TMCLOCK_VIRTUAL]);
1788 STAM_PROFILE_ADV_STOP(&pVM->tm.s.aStatDoQueues[TMCLOCK_VIRTUAL], s2);
1789
1790 /* TMCLOCK_TSC */
1791 Assert(!pVM->tm.s.paTimerQueuesR3[TMCLOCK_TSC].offActive); /* not used */
1792
1793 /* TMCLOCK_REAL */
1794 STAM_PROFILE_ADV_START(&pVM->tm.s.aStatDoQueues[TMCLOCK_REAL], s3);
1795 if (pVM->tm.s.paTimerQueuesR3[TMCLOCK_REAL].offSchedule)
1796 tmTimerQueueSchedule(pVM, &pVM->tm.s.paTimerQueuesR3[TMCLOCK_REAL]);
1797 tmR3TimerQueueRun(pVM, &pVM->tm.s.paTimerQueuesR3[TMCLOCK_REAL]);
1798 STAM_PROFILE_ADV_STOP(&pVM->tm.s.aStatDoQueues[TMCLOCK_REAL], s3);
1799
1800#ifdef VBOX_STRICT
1801 /* check that we didn't screwup. */
1802 tmTimerQueuesSanityChecks(pVM, "TMR3TimerQueuesDo");
1803#endif
1804
1805 /* done */
1806 Log2(("TMR3TimerQueuesDo: returns void\n"));
1807 ASMAtomicWriteBool(&pVM->tm.s.fRunningQueues, false);
1808 tmTimerUnlock(pVM);
1809 STAM_PROFILE_STOP(&pVM->tm.s.StatDoQueues, a);
1810}
1811
1812//RT_C_DECLS_BEGIN
1813//int iomLock(PVM pVM);
1814//void iomUnlock(PVM pVM);
1815//RT_C_DECLS_END
1816
1817
1818/**
1819 * Schedules and runs any pending times in the specified queue.
1820 *
1821 * This is normally called from a forced action handler in EMT.
1822 *
1823 * @param pVM The VM to run the timers for.
1824 * @param pQueue The queue to run.
1825 */
1826static void tmR3TimerQueueRun(PVM pVM, PTMTIMERQUEUE pQueue)
1827{
1828 VM_ASSERT_EMT(pVM);
1829
1830 /*
1831 * Run timers.
1832 *
1833 * We check the clock once and run all timers which are ACTIVE
1834 * and have an expire time less or equal to the time we read.
1835 *
1836 * N.B. A generic unlink must be applied since other threads
1837 * are allowed to mess with any active timer at any time.
1838 * However, we only allow EMT to handle EXPIRED_PENDING
1839 * timers, thus enabling the timer handler function to
1840 * arm the timer again.
1841 */
1842 PTMTIMER pNext = TMTIMER_GET_HEAD(pQueue);
1843 if (!pNext)
1844 return;
1845 const uint64_t u64Now = tmClock(pVM, pQueue->enmClock);
1846 while (pNext && pNext->u64Expire <= u64Now)
1847 {
1848 PTMTIMER pTimer = pNext;
1849 pNext = TMTIMER_GET_NEXT(pTimer);
1850 PPDMCRITSECT pCritSect = pTimer->pCritSect;
1851 if (pCritSect)
1852 PDMCritSectEnter(pCritSect, VERR_INTERNAL_ERROR);
1853 Log2(("tmR3TimerQueueRun: %p:{.enmState=%s, .enmClock=%d, .enmType=%d, u64Expire=%llx (now=%llx) .pszDesc=%s}\n",
1854 pTimer, tmTimerState(pTimer->enmState), pTimer->enmClock, pTimer->enmType, pTimer->u64Expire, u64Now, pTimer->pszDesc));
1855 bool fRc;
1856 TM_TRY_SET_STATE(pTimer, TMTIMERSTATE_EXPIRED_GET_UNLINK, TMTIMERSTATE_ACTIVE, fRc);
1857 if (fRc)
1858 {
1859 Assert(!pTimer->offScheduleNext); /* this can trigger falsely */
1860
1861 /* unlink */
1862 const PTMTIMER pPrev = TMTIMER_GET_PREV(pTimer);
1863 if (pPrev)
1864 TMTIMER_SET_NEXT(pPrev, pNext);
1865 else
1866 {
1867 TMTIMER_SET_HEAD(pQueue, pNext);
1868 pQueue->u64Expire = pNext ? pNext->u64Expire : INT64_MAX;
1869 }
1870 if (pNext)
1871 TMTIMER_SET_PREV(pNext, pPrev);
1872 pTimer->offNext = 0;
1873 pTimer->offPrev = 0;
1874
1875 /* fire */
1876 TM_SET_STATE(pTimer, TMTIMERSTATE_EXPIRED_DELIVER);
1877 switch (pTimer->enmType)
1878 {
1879 case TMTIMERTYPE_DEV: pTimer->u.Dev.pfnTimer(pTimer->u.Dev.pDevIns, pTimer, pTimer->pvUser); break;
1880 case TMTIMERTYPE_DRV: pTimer->u.Drv.pfnTimer(pTimer->u.Drv.pDrvIns, pTimer, pTimer->pvUser); break;
1881 case TMTIMERTYPE_INTERNAL: pTimer->u.Internal.pfnTimer(pVM, pTimer, pTimer->pvUser); break;
1882 case TMTIMERTYPE_EXTERNAL: pTimer->u.External.pfnTimer(pTimer->pvUser); break;
1883 default:
1884 AssertMsgFailed(("Invalid timer type %d (%s)\n", pTimer->enmType, pTimer->pszDesc));
1885 break;
1886 }
1887
1888 /* change the state if it wasn't changed already in the handler. */
1889 TM_TRY_SET_STATE(pTimer, TMTIMERSTATE_STOPPED, TMTIMERSTATE_EXPIRED_DELIVER, fRc);
1890 Log2(("tmR3TimerQueueRun: new state %s\n", tmTimerState(pTimer->enmState)));
1891 }
1892 if (pCritSect)
1893 PDMCritSectLeave(pCritSect);
1894 } /* run loop */
1895}
1896
1897
1898/**
1899 * Schedules and runs any pending times in the timer queue for the
1900 * synchronous virtual clock.
1901 *
1902 * This scheduling is a bit different from the other queues as it need
1903 * to implement the special requirements of the timer synchronous virtual
1904 * clock, thus this 2nd queue run funcion.
1905 *
1906 * @param pVM The VM to run the timers for.
1907 *
1908 * @remarks The caller must own both the TM/EMT and the Virtual Sync locks.
1909 */
1910static void tmR3TimerQueueRunVirtualSync(PVM pVM)
1911{
1912 PTMTIMERQUEUE const pQueue = &pVM->tm.s.paTimerQueuesR3[TMCLOCK_VIRTUAL_SYNC];
1913 VM_ASSERT_EMT(pVM);
1914
1915 /*
1916 * Any timers?
1917 */
1918 PTMTIMER pNext = TMTIMER_GET_HEAD(pQueue);
1919 if (RT_UNLIKELY(!pNext))
1920 {
1921 Assert(pVM->tm.s.fVirtualSyncTicking || !pVM->tm.s.cVirtualTicking);
1922 return;
1923 }
1924 STAM_COUNTER_INC(&pVM->tm.s.StatVirtualSyncRun);
1925
1926 /*
1927 * Calculate the time frame for which we will dispatch timers.
1928 *
1929 * We use a time frame ranging from the current sync time (which is most likely the
1930 * same as the head timer) and some configurable period (100000ns) up towards the
1931 * current virtual time. This period might also need to be restricted by the catch-up
1932 * rate so frequent calls to this function won't accelerate the time too much, however
1933 * this will be implemented at a later point if neccessary.
1934 *
1935 * Without this frame we would 1) having to run timers much more frequently
1936 * and 2) lag behind at a steady rate.
1937 */
1938 const uint64_t u64VirtualNow = TMVirtualGetNoCheck(pVM);
1939 uint64_t const offSyncGivenUp = pVM->tm.s.offVirtualSyncGivenUp;
1940 uint64_t u64Now;
1941 if (!pVM->tm.s.fVirtualSyncTicking)
1942 {
1943 STAM_COUNTER_INC(&pVM->tm.s.StatVirtualSyncRunStoppedAlready);
1944 u64Now = pVM->tm.s.u64VirtualSync;
1945#ifdef DEBUG_bird
1946 Assert(u64Now <= pNext->u64Expire);
1947#endif
1948 }
1949 else
1950 {
1951 /* Calc 'now'. */
1952 bool fStopCatchup = false;
1953 bool fUpdateStuff = false;
1954 uint64_t off = pVM->tm.s.offVirtualSync;
1955 if (pVM->tm.s.fVirtualSyncCatchUp)
1956 {
1957 uint64_t u64Delta = u64VirtualNow - pVM->tm.s.u64VirtualSyncCatchUpPrev;
1958 if (RT_LIKELY(!(u64Delta >> 32)))
1959 {
1960 uint64_t u64Sub = ASMMultU64ByU32DivByU32(u64Delta, pVM->tm.s.u32VirtualSyncCatchUpPercentage, 100);
1961 if (off > u64Sub + offSyncGivenUp)
1962 {
1963 off -= u64Sub;
1964 Log4(("TM: %'RU64/-%'8RU64: sub %'RU64 [tmR3TimerQueueRunVirtualSync]\n", u64VirtualNow - off, off - offSyncGivenUp, u64Sub));
1965 }
1966 else
1967 {
1968 STAM_PROFILE_ADV_STOP(&pVM->tm.s.StatVirtualSyncCatchup, c);
1969 fStopCatchup = true;
1970 off = offSyncGivenUp;
1971 }
1972 }
1973 }
1974 u64Now = u64VirtualNow - off;
1975
1976 /* Check if stopped by expired timer. */
1977 uint64_t u64Expire = pNext->u64Expire;
1978 if (u64Now >= pNext->u64Expire)
1979 {
1980 STAM_COUNTER_INC(&pVM->tm.s.StatVirtualSyncRunStop);
1981 u64Now = pNext->u64Expire;
1982 ASMAtomicWriteU64(&pVM->tm.s.u64VirtualSync, u64Now);
1983 ASMAtomicWriteBool(&pVM->tm.s.fVirtualSyncTicking, false);
1984 Log4(("TM: %'RU64/-%'8RU64: exp tmr [tmR3TimerQueueRunVirtualSync]\n", u64Now, u64VirtualNow - u64Now - offSyncGivenUp));
1985 }
1986 else if (fUpdateStuff)
1987 {
1988 ASMAtomicWriteU64(&pVM->tm.s.offVirtualSync, off);
1989 ASMAtomicWriteU64(&pVM->tm.s.u64VirtualSyncCatchUpPrev, u64VirtualNow);
1990 if (fStopCatchup)
1991 {
1992 ASMAtomicWriteBool(&pVM->tm.s.fVirtualSyncCatchUp, false);
1993 Log4(("TM: %'RU64/0: caught up [tmR3TimerQueueRunVirtualSync]\n", u64VirtualNow));
1994 }
1995 }
1996 }
1997
1998 /* calc end of frame. */
1999 uint64_t u64Max = u64Now + pVM->tm.s.u32VirtualSyncScheduleSlack;
2000 if (u64Max > u64VirtualNow - offSyncGivenUp)
2001 u64Max = u64VirtualNow - offSyncGivenUp;
2002
2003 /* assert sanity */
2004#ifdef DEBUG_bird
2005 Assert(u64Now <= u64VirtualNow - offSyncGivenUp);
2006 Assert(u64Max <= u64VirtualNow - offSyncGivenUp);
2007 Assert(u64Now <= u64Max);
2008 Assert(offSyncGivenUp == pVM->tm.s.offVirtualSyncGivenUp);
2009#endif
2010
2011 /*
2012 * Process the expired timers moving the clock along as we progress.
2013 */
2014#ifdef DEBUG_bird
2015#ifdef VBOX_STRICT
2016 uint64_t u64Prev = u64Now; NOREF(u64Prev);
2017#endif
2018#endif
2019 while (pNext && pNext->u64Expire <= u64Max)
2020 {
2021 PTMTIMER pTimer = pNext;
2022 pNext = TMTIMER_GET_NEXT(pTimer);
2023 PPDMCRITSECT pCritSect = pTimer->pCritSect;
2024 if (pCritSect)
2025 PDMCritSectEnter(pCritSect, VERR_INTERNAL_ERROR);
2026 Log2(("tmR3TimerQueueRun: %p:{.enmState=%s, .enmClock=%d, .enmType=%d, u64Expire=%llx (now=%llx) .pszDesc=%s}\n",
2027 pTimer, tmTimerState(pTimer->enmState), pTimer->enmClock, pTimer->enmType, pTimer->u64Expire, u64Now, pTimer->pszDesc));
2028 bool fRc;
2029 TM_TRY_SET_STATE(pTimer, TMTIMERSTATE_EXPIRED_GET_UNLINK, TMTIMERSTATE_ACTIVE, fRc);
2030 if (fRc)
2031 {
2032 /* unlink */
2033 const PTMTIMER pPrev = TMTIMER_GET_PREV(pTimer);
2034 if (pPrev)
2035 TMTIMER_SET_NEXT(pPrev, pNext);
2036 else
2037 {
2038 TMTIMER_SET_HEAD(pQueue, pNext);
2039 pQueue->u64Expire = pNext ? pNext->u64Expire : INT64_MAX;
2040 }
2041 if (pNext)
2042 TMTIMER_SET_PREV(pNext, pPrev);
2043 pTimer->offNext = 0;
2044 pTimer->offPrev = 0;
2045
2046 /* advance the clock - don't permit timers to be out of order or armed in the 'past'. */
2047#ifdef DEBUG_bird
2048#ifdef VBOX_STRICT
2049 AssertMsg(pTimer->u64Expire >= u64Prev, ("%'RU64 < %'RU64 %s\n", pTimer->u64Expire, u64Prev, pTimer->pszDesc));
2050 u64Prev = pTimer->u64Expire;
2051#endif
2052#endif
2053 ASMAtomicWriteU64(&pVM->tm.s.u64VirtualSync, pTimer->u64Expire);
2054 ASMAtomicWriteBool(&pVM->tm.s.fVirtualSyncTicking, false);
2055
2056 /* fire */
2057 TM_SET_STATE(pTimer, TMTIMERSTATE_EXPIRED_DELIVER);
2058 switch (pTimer->enmType)
2059 {
2060 case TMTIMERTYPE_DEV: pTimer->u.Dev.pfnTimer(pTimer->u.Dev.pDevIns, pTimer, pTimer->pvUser); break;
2061 case TMTIMERTYPE_DRV: pTimer->u.Drv.pfnTimer(pTimer->u.Drv.pDrvIns, pTimer, pTimer->pvUser); break;
2062 case TMTIMERTYPE_INTERNAL: pTimer->u.Internal.pfnTimer(pVM, pTimer, pTimer->pvUser); break;
2063 case TMTIMERTYPE_EXTERNAL: pTimer->u.External.pfnTimer(pTimer->pvUser); break;
2064 default:
2065 AssertMsgFailed(("Invalid timer type %d (%s)\n", pTimer->enmType, pTimer->pszDesc));
2066 break;
2067 }
2068
2069 /* change the state if it wasn't changed already in the handler. */
2070 TM_TRY_SET_STATE(pTimer, TMTIMERSTATE_STOPPED, TMTIMERSTATE_EXPIRED_DELIVER, fRc);
2071 Log2(("tmR3TimerQueueRun: new state %s\n", tmTimerState(pTimer->enmState)));
2072 }
2073 if (pCritSect)
2074 PDMCritSectLeave(pCritSect);
2075 } /* run loop */
2076
2077 /*
2078 * Restart the clock if it was stopped to serve any timers,
2079 * and start/adjust catch-up if necessary.
2080 */
2081 if ( !pVM->tm.s.fVirtualSyncTicking
2082 && pVM->tm.s.cVirtualTicking)
2083 {
2084 STAM_COUNTER_INC(&pVM->tm.s.StatVirtualSyncRunRestart);
2085
2086 /* calc the slack we've handed out. */
2087 const uint64_t u64VirtualNow2 = TMVirtualGetNoCheck(pVM);
2088 Assert(u64VirtualNow2 >= u64VirtualNow);
2089#ifdef DEBUG_bird
2090 AssertMsg(pVM->tm.s.u64VirtualSync >= u64Now, ("%'RU64 < %'RU64\n", pVM->tm.s.u64VirtualSync, u64Now));
2091#endif
2092 const uint64_t offSlack = pVM->tm.s.u64VirtualSync - u64Now;
2093 STAM_STATS({
2094 if (offSlack)
2095 {
2096 PSTAMPROFILE p = &pVM->tm.s.StatVirtualSyncRunSlack;
2097 p->cPeriods++;
2098 p->cTicks += offSlack;
2099 if (p->cTicksMax < offSlack) p->cTicksMax = offSlack;
2100 if (p->cTicksMin > offSlack) p->cTicksMin = offSlack;
2101 }
2102 });
2103
2104 /* Let the time run a little bit while we were busy running timers(?). */
2105 uint64_t u64Elapsed;
2106#define MAX_ELAPSED 30000U /* ns */
2107 if (offSlack > MAX_ELAPSED)
2108 u64Elapsed = 0;
2109 else
2110 {
2111 u64Elapsed = u64VirtualNow2 - u64VirtualNow;
2112 if (u64Elapsed > MAX_ELAPSED)
2113 u64Elapsed = MAX_ELAPSED;
2114 u64Elapsed = u64Elapsed > offSlack ? u64Elapsed - offSlack : 0;
2115 }
2116#undef MAX_ELAPSED
2117
2118 /* Calc the current offset. */
2119 uint64_t offNew = u64VirtualNow2 - pVM->tm.s.u64VirtualSync - u64Elapsed;
2120 Assert(!(offNew & RT_BIT_64(63)));
2121 uint64_t offLag = offNew - pVM->tm.s.offVirtualSyncGivenUp;
2122 Assert(!(offLag & RT_BIT_64(63)));
2123
2124 /*
2125 * Deal with starting, adjusting and stopping catchup.
2126 */
2127 if (pVM->tm.s.fVirtualSyncCatchUp)
2128 {
2129 if (offLag <= pVM->tm.s.u64VirtualSyncCatchUpStopThreshold)
2130 {
2131 /* stop */
2132 STAM_PROFILE_ADV_STOP(&pVM->tm.s.StatVirtualSyncCatchup, c);
2133 ASMAtomicWriteBool(&pVM->tm.s.fVirtualSyncCatchUp, false);
2134 Log4(("TM: %'RU64/-%'8RU64: caught up [pt]\n", u64VirtualNow2 - offNew, offLag));
2135 }
2136 else if (offLag <= pVM->tm.s.u64VirtualSyncCatchUpGiveUpThreshold)
2137 {
2138 /* adjust */
2139 unsigned i = 0;
2140 while ( i + 1 < RT_ELEMENTS(pVM->tm.s.aVirtualSyncCatchUpPeriods)
2141 && offLag >= pVM->tm.s.aVirtualSyncCatchUpPeriods[i + 1].u64Start)
2142 i++;
2143 if (pVM->tm.s.u32VirtualSyncCatchUpPercentage < pVM->tm.s.aVirtualSyncCatchUpPeriods[i].u32Percentage)
2144 {
2145 STAM_COUNTER_INC(&pVM->tm.s.aStatVirtualSyncCatchupAdjust[i]);
2146 ASMAtomicWriteU32(&pVM->tm.s.u32VirtualSyncCatchUpPercentage, pVM->tm.s.aVirtualSyncCatchUpPeriods[i].u32Percentage);
2147 Log4(("TM: %'RU64/%'8RU64: adj %u%%\n", u64VirtualNow2 - offNew, offLag, pVM->tm.s.u32VirtualSyncCatchUpPercentage));
2148 }
2149 pVM->tm.s.u64VirtualSyncCatchUpPrev = u64VirtualNow2;
2150 }
2151 else
2152 {
2153 /* give up */
2154 STAM_COUNTER_INC(&pVM->tm.s.StatVirtualSyncGiveUp);
2155 STAM_PROFILE_ADV_STOP(&pVM->tm.s.StatVirtualSyncCatchup, c);
2156 ASMAtomicWriteU64((uint64_t volatile *)&pVM->tm.s.offVirtualSyncGivenUp, offNew);
2157 ASMAtomicWriteBool(&pVM->tm.s.fVirtualSyncCatchUp, false);
2158 Log4(("TM: %'RU64/%'8RU64: give up %u%%\n", u64VirtualNow2 - offNew, offLag, pVM->tm.s.u32VirtualSyncCatchUpPercentage));
2159 LogRel(("TM: Giving up catch-up attempt at a %'RU64 ns lag; new total: %'RU64 ns\n", offLag, offNew));
2160 }
2161 }
2162 else if (offLag >= pVM->tm.s.aVirtualSyncCatchUpPeriods[0].u64Start)
2163 {
2164 if (offLag <= pVM->tm.s.u64VirtualSyncCatchUpGiveUpThreshold)
2165 {
2166 /* start */
2167 STAM_PROFILE_ADV_START(&pVM->tm.s.StatVirtualSyncCatchup, c);
2168 unsigned i = 0;
2169 while ( i + 1 < RT_ELEMENTS(pVM->tm.s.aVirtualSyncCatchUpPeriods)
2170 && offLag >= pVM->tm.s.aVirtualSyncCatchUpPeriods[i + 1].u64Start)
2171 i++;
2172 STAM_COUNTER_INC(&pVM->tm.s.aStatVirtualSyncCatchupInitial[i]);
2173 ASMAtomicWriteU32(&pVM->tm.s.u32VirtualSyncCatchUpPercentage, pVM->tm.s.aVirtualSyncCatchUpPeriods[i].u32Percentage);
2174 ASMAtomicWriteBool(&pVM->tm.s.fVirtualSyncCatchUp, true);
2175 Log4(("TM: %'RU64/%'8RU64: catch-up %u%%\n", u64VirtualNow2 - offNew, offLag, pVM->tm.s.u32VirtualSyncCatchUpPercentage));
2176 }
2177 else
2178 {
2179 /* don't bother */
2180 STAM_COUNTER_INC(&pVM->tm.s.StatVirtualSyncGiveUpBeforeStarting);
2181 ASMAtomicWriteU64((uint64_t volatile *)&pVM->tm.s.offVirtualSyncGivenUp, offNew);
2182 Log4(("TM: %'RU64/%'8RU64: give up\n", u64VirtualNow2 - offNew, offLag));
2183 LogRel(("TM: Not bothering to attempt catching up a %'RU64 ns lag; new total: %'RU64\n", offLag, offNew));
2184 }
2185 }
2186
2187 /*
2188 * Update the offset and restart the clock.
2189 */
2190 Assert(!(offNew & RT_BIT_64(63)));
2191 ASMAtomicWriteU64(&pVM->tm.s.offVirtualSync, offNew);
2192 ASMAtomicWriteBool(&pVM->tm.s.fVirtualSyncTicking, true);
2193 }
2194}
2195
2196
2197/**
2198 * Deals with stopped Virtual Sync clock.
2199 *
2200 * This is called by the forced action flag handling code in EM when it
2201 * encounters the VM_FF_TM_VIRTUAL_SYNC flag. It is called by all VCPUs and they
2202 * will block on the VirtualSyncLock until the pending timers has been executed
2203 * and the clock restarted.
2204 *
2205 * @param pVM The VM to run the timers for.
2206 * @param pVCpu The virtual CPU we're running at.
2207 *
2208 * @thread EMTs
2209 */
2210VMM_INT_DECL(void) TMR3VirtualSyncFF(PVM pVM, PVMCPU pVCpu)
2211{
2212 Log2(("TMR3VirtualSyncFF:\n"));
2213
2214 /*
2215 * The EMT doing the timers is diverted to them.
2216 */
2217 if (pVCpu->idCpu == pVM->tm.s.idTimerCpu)
2218 TMR3TimerQueuesDo(pVM);
2219 /*
2220 * The other EMTs will block on the virtual sync lock and the first owner
2221 * will run the queue and thus restarting the clock.
2222 *
2223 * Note! This is very suboptimal code wrt to resuming execution when there
2224 * are more than two Virtual CPUs, since they will all have to enter
2225 * the critical section one by one. But it's a very simple solution
2226 * which will have to do the job for now.
2227 */
2228 else
2229 {
2230 STAM_PROFILE_START(&pVM->tm.s.StatVirtualSyncFF, a);
2231 tmVirtualSyncLock(pVM);
2232 if (pVM->tm.s.fVirtualSyncTicking)
2233 {
2234 STAM_PROFILE_STOP(&pVM->tm.s.StatVirtualSyncFF, a); /* before the unlock! */
2235 tmVirtualSyncUnlock(pVM);
2236 Log2(("TMR3VirtualSyncFF: ticking\n"));
2237 }
2238 else
2239 {
2240 tmVirtualSyncUnlock(pVM);
2241
2242 /* try run it. */
2243 tmTimerLock(pVM);
2244 tmVirtualSyncLock(pVM);
2245 if (pVM->tm.s.fVirtualSyncTicking)
2246 Log2(("TMR3VirtualSyncFF: ticking (2)\n"));
2247 else
2248 {
2249 ASMAtomicWriteBool(&pVM->tm.s.fRunningVirtualSyncQueue, true);
2250 Log2(("TMR3VirtualSyncFF: running queue\n"));
2251
2252 if (pVM->tm.s.paTimerQueuesR3[TMCLOCK_VIRTUAL_SYNC].offSchedule)
2253 tmTimerQueueSchedule(pVM, &pVM->tm.s.paTimerQueuesR3[TMCLOCK_VIRTUAL_SYNC]);
2254 tmR3TimerQueueRunVirtualSync(pVM);
2255 if (pVM->tm.s.fVirtualSyncTicking) /** @todo move into tmR3TimerQueueRunVirtualSync - FIXME */
2256 VM_FF_CLEAR(pVM, VM_FF_TM_VIRTUAL_SYNC);
2257
2258 ASMAtomicWriteBool(&pVM->tm.s.fRunningVirtualSyncQueue, false);
2259 }
2260 STAM_PROFILE_STOP(&pVM->tm.s.StatVirtualSyncFF, a); /* before the unlock! */
2261 tmVirtualSyncUnlock(pVM);
2262 tmTimerUnlock(pVM);
2263 }
2264 }
2265}
2266
2267
2268/** @name Saved state values
2269 * @{ */
2270#define TMTIMERSTATE_SAVED_PENDING_STOP 4
2271#define TMTIMERSTATE_SAVED_PENDING_SCHEDULE 7
2272/** @} */
2273
2274
2275/**
2276 * Saves the state of a timer to a saved state.
2277 *
2278 * @returns VBox status.
2279 * @param pTimer Timer to save.
2280 * @param pSSM Save State Manager handle.
2281 */
2282VMMR3DECL(int) TMR3TimerSave(PTMTIMERR3 pTimer, PSSMHANDLE pSSM)
2283{
2284 LogFlow(("TMR3TimerSave: %p:{enmState=%s, .pszDesc={%s}} pSSM=%p\n", pTimer, tmTimerState(pTimer->enmState), pTimer->pszDesc, pSSM));
2285 switch (pTimer->enmState)
2286 {
2287 case TMTIMERSTATE_STOPPED:
2288 case TMTIMERSTATE_PENDING_STOP:
2289 case TMTIMERSTATE_PENDING_STOP_SCHEDULE:
2290 return SSMR3PutU8(pSSM, TMTIMERSTATE_SAVED_PENDING_STOP);
2291
2292 case TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE:
2293 case TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE:
2294 AssertMsgFailed(("u64Expire is being updated! (%s)\n", pTimer->pszDesc));
2295 if (!RTThreadYield())
2296 RTThreadSleep(1);
2297 /* fall thru */
2298 case TMTIMERSTATE_ACTIVE:
2299 case TMTIMERSTATE_PENDING_SCHEDULE:
2300 case TMTIMERSTATE_PENDING_RESCHEDULE:
2301 SSMR3PutU8(pSSM, TMTIMERSTATE_SAVED_PENDING_SCHEDULE);
2302 return SSMR3PutU64(pSSM, pTimer->u64Expire);
2303
2304 case TMTIMERSTATE_EXPIRED_GET_UNLINK:
2305 case TMTIMERSTATE_EXPIRED_DELIVER:
2306 case TMTIMERSTATE_DESTROY:
2307 case TMTIMERSTATE_FREE:
2308 AssertMsgFailed(("Invalid timer state %d %s (%s)\n", pTimer->enmState, tmTimerState(pTimer->enmState), pTimer->pszDesc));
2309 return SSMR3HandleSetStatus(pSSM, VERR_TM_INVALID_STATE);
2310 }
2311
2312 AssertMsgFailed(("Unknown timer state %d (%s)\n", pTimer->enmState, pTimer->pszDesc));
2313 return SSMR3HandleSetStatus(pSSM, VERR_TM_UNKNOWN_STATE);
2314}
2315
2316
2317/**
2318 * Loads the state of a timer from a saved state.
2319 *
2320 * @returns VBox status.
2321 * @param pTimer Timer to restore.
2322 * @param pSSM Save State Manager handle.
2323 */
2324VMMR3DECL(int) TMR3TimerLoad(PTMTIMERR3 pTimer, PSSMHANDLE pSSM)
2325{
2326 Assert(pTimer); Assert(pSSM); VM_ASSERT_EMT(pTimer->pVMR3);
2327 LogFlow(("TMR3TimerLoad: %p:{enmState=%s, .pszDesc={%s}} pSSM=%p\n", pTimer, tmTimerState(pTimer->enmState), pTimer->pszDesc, pSSM));
2328
2329 /*
2330 * Load the state and validate it.
2331 */
2332 uint8_t u8State;
2333 int rc = SSMR3GetU8(pSSM, &u8State);
2334 if (RT_FAILURE(rc))
2335 return rc;
2336#if 1 /* Workaround for accidental state shift in r47786 (2009-05-26 19:12:12). */ /** @todo remove this in a few weeks! */
2337 if ( u8State == TMTIMERSTATE_SAVED_PENDING_STOP + 1
2338 || u8State == TMTIMERSTATE_SAVED_PENDING_SCHEDULE + 1)
2339 u8State--;
2340#endif
2341 if ( u8State != TMTIMERSTATE_SAVED_PENDING_STOP
2342 && u8State != TMTIMERSTATE_SAVED_PENDING_SCHEDULE)
2343 {
2344 AssertLogRelMsgFailed(("u8State=%d\n", u8State));
2345 return SSMR3HandleSetStatus(pSSM, VERR_TM_LOAD_STATE);
2346 }
2347
2348 /* Enter the critical section to make TMTimerSet/Stop happy. */
2349 PPDMCRITSECT pCritSect = pTimer->pCritSect;
2350 if (pCritSect)
2351 PDMCritSectEnter(pCritSect, VERR_INTERNAL_ERROR);
2352
2353 if (u8State == TMTIMERSTATE_SAVED_PENDING_SCHEDULE)
2354 {
2355 /*
2356 * Load the expire time.
2357 */
2358 uint64_t u64Expire;
2359 rc = SSMR3GetU64(pSSM, &u64Expire);
2360 if (RT_FAILURE(rc))
2361 return rc;
2362
2363 /*
2364 * Set it.
2365 */
2366 Log(("u8State=%d u64Expire=%llu\n", u8State, u64Expire));
2367 rc = TMTimerSet(pTimer, u64Expire);
2368 }
2369 else
2370 {
2371 /*
2372 * Stop it.
2373 */
2374 Log(("u8State=%d\n", u8State));
2375 rc = TMTimerStop(pTimer);
2376 }
2377
2378 if (pCritSect)
2379 PDMCritSectLeave(pCritSect);
2380
2381 /*
2382 * On failure set SSM status.
2383 */
2384 if (RT_FAILURE(rc))
2385 rc = SSMR3HandleSetStatus(pSSM, rc);
2386 return rc;
2387}
2388
2389
2390/**
2391 * Associates a critical section with a timer.
2392 *
2393 * The critical section will be entered prior to doing the timer call back, thus
2394 * avoiding potential races between the timer thread and other threads trying to
2395 * stop or adjust the timer expiration while it's being delivered. The timer
2396 * thread will leave the critical section when the timer callback returns.
2397 *
2398 * In strict builds, ownership of the critical section will be asserted by
2399 * TMTimerSet, TMTimerStop, TMTimerGetExpire and TMTimerDestroy (when called at
2400 * runtime).
2401 *
2402 * @retval VINF_SUCCESS on success.
2403 * @retval VERR_INVALID_HANDLE if the timer handle is NULL or invalid
2404 * (asserted).
2405 * @retval VERR_INVALID_PARAMETER if pCritSect is NULL or has an invalid magic
2406 * (asserted).
2407 * @retval VERR_ALREADY_EXISTS if a critical section was already associated
2408 * with the timer (asserted).
2409 * @retval VERR_INVALID_STATE if the timer isn't stopped.
2410 *
2411 * @param pTimer The timer handle.
2412 * @param pCritSect The critical section. The caller must make sure this
2413 * is around for the life time of the timer.
2414 *
2415 * @thread Any, but the caller is responsible for making sure the timer is not
2416 * active.
2417 */
2418VMMR3DECL(int) TMR3TimerSetCritSect(PTMTIMERR3 pTimer, PPDMCRITSECT pCritSect)
2419{
2420 AssertPtrReturn(pTimer, VERR_INVALID_HANDLE);
2421 AssertPtrReturn(pCritSect, VERR_INVALID_PARAMETER);
2422 const char *pszName = PDMR3CritSectName(pCritSect); /* exploited for validation */
2423 AssertReturn(pszName, VERR_INVALID_PARAMETER);
2424 AssertReturn(!pTimer->pCritSect, VERR_ALREADY_EXISTS);
2425 AssertReturn(pTimer->enmState == TMTIMERSTATE_STOPPED, VERR_INVALID_STATE);
2426 LogFlow(("pTimer=%p (%s) pCritSect=%p (%s)\n", pTimer, pTimer->pszDesc, pCritSect, pszName));
2427
2428 pTimer->pCritSect = pCritSect;
2429 return VINF_SUCCESS;
2430}
2431
2432
2433/**
2434 * Get the real world UTC time adjusted for VM lag.
2435 *
2436 * @returns pTime.
2437 * @param pVM The VM instance.
2438 * @param pTime Where to store the time.
2439 */
2440VMM_INT_DECL(PRTTIMESPEC) TMR3UTCNow(PVM pVM, PRTTIMESPEC pTime)
2441{
2442 RTTimeNow(pTime);
2443 RTTimeSpecSubNano(pTime, ASMAtomicReadU64(&pVM->tm.s.offVirtualSync) - ASMAtomicReadU64((uint64_t volatile *)&pVM->tm.s.offVirtualSyncGivenUp));
2444 RTTimeSpecAddNano(pTime, pVM->tm.s.offUTC);
2445 return pTime;
2446}
2447
2448
2449/**
2450 * Pauses all clocks except TMCLOCK_REAL.
2451 *
2452 * @returns VBox status code, all errors are asserted.
2453 * @param pVM The VM handle.
2454 * @param pVCpu The virtual CPU handle.
2455 * @thread EMT corrsponding to the virtual CPU handle.
2456 */
2457VMMR3DECL(int) TMR3NotifySuspend(PVM pVM, PVMCPU pVCpu)
2458{
2459 VMCPU_ASSERT_EMT(pVCpu);
2460
2461 /*
2462 * The shared virtual clock (includes virtual sync which is tied to it).
2463 */
2464 tmTimerLock(pVM); /* Paranoia: Exploiting the timer lock here. */
2465 int rc = tmVirtualPauseLocked(pVM);
2466 tmTimerUnlock(pVM);
2467 if (RT_FAILURE(rc))
2468 return rc;
2469
2470 /*
2471 * Pause the TSC last since it is normally linked to the virtual
2472 * sync clock, so the above code may actually stop both clock.
2473 */
2474 return tmCpuTickPause(pVM, pVCpu);
2475}
2476
2477
2478/**
2479 * Resumes all clocks except TMCLOCK_REAL.
2480 *
2481 * @returns VBox status code, all errors are asserted.
2482 * @param pVM The VM handle.
2483 * @param pVCpu The virtual CPU handle.
2484 * @thread EMT corrsponding to the virtual CPU handle.
2485 */
2486VMMR3DECL(int) TMR3NotifyResume(PVM pVM, PVMCPU pVCpu)
2487{
2488 VMCPU_ASSERT_EMT(pVCpu);
2489 int rc;
2490
2491 /*
2492 * Resume the TSC first since it is normally linked to the virtual sync
2493 * clock, so it may actually not be resumed until we've executed the code
2494 * below.
2495 */
2496 if (!pVM->tm.s.fTSCTiedToExecution)
2497 {
2498 rc = tmCpuTickResume(pVM, pVCpu);
2499 if (RT_FAILURE(rc))
2500 return rc;
2501 }
2502
2503 /*
2504 * The shared virtual clock (includes virtual sync which is tied to it).
2505 */
2506 tmTimerLock(pVM); /* Paranoia: Exploiting the timer lock here. */
2507 rc = tmVirtualResumeLocked(pVM);
2508 tmTimerUnlock(pVM);
2509
2510 return rc;
2511}
2512
2513
2514/**
2515 * Sets the warp drive percent of the virtual time.
2516 *
2517 * @returns VBox status code.
2518 * @param pVM The VM handle.
2519 * @param u32Percent The new percentage. 100 means normal operation.
2520 *
2521 * @todo Move to Ring-3!
2522 */
2523VMMDECL(int) TMR3SetWarpDrive(PVM pVM, uint32_t u32Percent)
2524{
2525 return VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)tmR3SetWarpDrive, 2, pVM, u32Percent);
2526}
2527
2528
2529/**
2530 * EMT worker for TMR3SetWarpDrive.
2531 *
2532 * @returns VBox status code.
2533 * @param pVM The VM handle.
2534 * @param u32Percent See TMR3SetWarpDrive().
2535 * @internal
2536 */
2537static DECLCALLBACK(int) tmR3SetWarpDrive(PVM pVM, uint32_t u32Percent)
2538{
2539 PVMCPU pVCpu = VMMGetCpu(pVM);
2540
2541 /*
2542 * Validate it.
2543 */
2544 AssertMsgReturn(u32Percent >= 2 && u32Percent <= 20000,
2545 ("%RX32 is not between 2 and 20000 (inclusive).\n", u32Percent),
2546 VERR_INVALID_PARAMETER);
2547
2548/** @todo This isn't a feature specific to virtual time, move the variables to
2549 * TM level and make it affect TMR3UCTNow as well! */
2550
2551 /*
2552 * If the time is running we'll have to pause it before we can change
2553 * the warp drive settings.
2554 */
2555 tmTimerLock(pVM); /* Paranoia: Exploiting the timer lock here. */
2556 bool fPaused = !!pVM->tm.s.cVirtualTicking;
2557 if (fPaused) /** @todo this isn't really working, but wtf. */
2558 TMR3NotifySuspend(pVM, pVCpu);
2559
2560 pVM->tm.s.u32VirtualWarpDrivePercentage = u32Percent;
2561 pVM->tm.s.fVirtualWarpDrive = u32Percent != 100;
2562 LogRel(("TM: u32VirtualWarpDrivePercentage=%RI32 fVirtualWarpDrive=%RTbool\n",
2563 pVM->tm.s.u32VirtualWarpDrivePercentage, pVM->tm.s.fVirtualWarpDrive));
2564
2565 if (fPaused)
2566 TMR3NotifyResume(pVM, pVCpu);
2567 tmTimerUnlock(pVM);
2568 return VINF_SUCCESS;
2569}
2570
2571
2572/**
2573 * Display all timers.
2574 *
2575 * @param pVM VM Handle.
2576 * @param pHlp The info helpers.
2577 * @param pszArgs Arguments, ignored.
2578 */
2579static DECLCALLBACK(void) tmR3TimerInfo(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs)
2580{
2581 NOREF(pszArgs);
2582 pHlp->pfnPrintf(pHlp,
2583 "Timers (pVM=%p)\n"
2584 "%.*s %.*s %.*s %.*s Clock %-18s %-18s %-25s Description\n",
2585 pVM,
2586 sizeof(RTR3PTR) * 2, "pTimerR3 ",
2587 sizeof(int32_t) * 2, "offNext ",
2588 sizeof(int32_t) * 2, "offPrev ",
2589 sizeof(int32_t) * 2, "offSched ",
2590 "Time",
2591 "Expire",
2592 "State");
2593 tmTimerLock(pVM);
2594 for (PTMTIMERR3 pTimer = pVM->tm.s.pCreated; pTimer; pTimer = pTimer->pBigNext)
2595 {
2596 pHlp->pfnPrintf(pHlp,
2597 "%p %08RX32 %08RX32 %08RX32 %s %18RU64 %18RU64 %-25s %s\n",
2598 pTimer,
2599 pTimer->offNext,
2600 pTimer->offPrev,
2601 pTimer->offScheduleNext,
2602 pTimer->enmClock == TMCLOCK_REAL ? "Real " : "Virt ",
2603 TMTimerGet(pTimer),
2604 pTimer->u64Expire,
2605 tmTimerState(pTimer->enmState),
2606 pTimer->pszDesc);
2607 }
2608 tmTimerUnlock(pVM);
2609}
2610
2611
2612/**
2613 * Display all active timers.
2614 *
2615 * @param pVM VM Handle.
2616 * @param pHlp The info helpers.
2617 * @param pszArgs Arguments, ignored.
2618 */
2619static DECLCALLBACK(void) tmR3TimerInfoActive(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs)
2620{
2621 NOREF(pszArgs);
2622 pHlp->pfnPrintf(pHlp,
2623 "Active Timers (pVM=%p)\n"
2624 "%.*s %.*s %.*s %.*s Clock %-18s %-18s %-25s Description\n",
2625 pVM,
2626 sizeof(RTR3PTR) * 2, "pTimerR3 ",
2627 sizeof(int32_t) * 2, "offNext ",
2628 sizeof(int32_t) * 2, "offPrev ",
2629 sizeof(int32_t) * 2, "offSched ",
2630 "Time",
2631 "Expire",
2632 "State");
2633 for (unsigned iQueue = 0; iQueue < TMCLOCK_MAX; iQueue++)
2634 {
2635 tmTimerLock(pVM);
2636 for (PTMTIMERR3 pTimer = TMTIMER_GET_HEAD(&pVM->tm.s.paTimerQueuesR3[iQueue]);
2637 pTimer;
2638 pTimer = TMTIMER_GET_NEXT(pTimer))
2639 {
2640 pHlp->pfnPrintf(pHlp,
2641 "%p %08RX32 %08RX32 %08RX32 %s %18RU64 %18RU64 %-25s %s\n",
2642 pTimer,
2643 pTimer->offNext,
2644 pTimer->offPrev,
2645 pTimer->offScheduleNext,
2646 pTimer->enmClock == TMCLOCK_REAL
2647 ? "Real "
2648 : pTimer->enmClock == TMCLOCK_VIRTUAL
2649 ? "Virt "
2650 : pTimer->enmClock == TMCLOCK_VIRTUAL_SYNC
2651 ? "VrSy "
2652 : "TSC ",
2653 TMTimerGet(pTimer),
2654 pTimer->u64Expire,
2655 tmTimerState(pTimer->enmState),
2656 pTimer->pszDesc);
2657 }
2658 tmTimerUnlock(pVM);
2659 }
2660}
2661
2662
2663/**
2664 * Display all clocks.
2665 *
2666 * @param pVM VM Handle.
2667 * @param pHlp The info helpers.
2668 * @param pszArgs Arguments, ignored.
2669 */
2670static DECLCALLBACK(void) tmR3InfoClocks(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs)
2671{
2672 NOREF(pszArgs);
2673
2674 /*
2675 * Read the times first to avoid more than necessary time variation.
2676 */
2677 const uint64_t u64Virtual = TMVirtualGet(pVM);
2678 const uint64_t u64VirtualSync = TMVirtualSyncGet(pVM);
2679 const uint64_t u64Real = TMRealGet(pVM);
2680
2681 for (VMCPUID i = 0; i < pVM->cCpus; i++)
2682 {
2683 PVMCPU pVCpu = &pVM->aCpus[i];
2684 uint64_t u64TSC = TMCpuTickGet(pVCpu);
2685
2686 /*
2687 * TSC
2688 */
2689 pHlp->pfnPrintf(pHlp,
2690 "Cpu Tick: %18RU64 (%#016RX64) %RU64Hz %s%s",
2691 u64TSC, u64TSC, TMCpuTicksPerSecond(pVM),
2692 pVCpu->tm.s.fTSCTicking ? "ticking" : "paused",
2693 pVM->tm.s.fTSCVirtualized ? " - virtualized" : "");
2694 if (pVM->tm.s.fTSCUseRealTSC)
2695 {
2696 pHlp->pfnPrintf(pHlp, " - real tsc");
2697 if (pVCpu->tm.s.offTSCRawSrc)
2698 pHlp->pfnPrintf(pHlp, "\n offset %RU64", pVCpu->tm.s.offTSCRawSrc);
2699 }
2700 else
2701 pHlp->pfnPrintf(pHlp, " - virtual clock");
2702 pHlp->pfnPrintf(pHlp, "\n");
2703 }
2704
2705 /*
2706 * virtual
2707 */
2708 pHlp->pfnPrintf(pHlp,
2709 " Virtual: %18RU64 (%#016RX64) %RU64Hz %s",
2710 u64Virtual, u64Virtual, TMVirtualGetFreq(pVM),
2711 pVM->tm.s.cVirtualTicking ? "ticking" : "paused");
2712 if (pVM->tm.s.fVirtualWarpDrive)
2713 pHlp->pfnPrintf(pHlp, " WarpDrive %RU32 %%", pVM->tm.s.u32VirtualWarpDrivePercentage);
2714 pHlp->pfnPrintf(pHlp, "\n");
2715
2716 /*
2717 * virtual sync
2718 */
2719 pHlp->pfnPrintf(pHlp,
2720 "VirtSync: %18RU64 (%#016RX64) %s%s",
2721 u64VirtualSync, u64VirtualSync,
2722 pVM->tm.s.fVirtualSyncTicking ? "ticking" : "paused",
2723 pVM->tm.s.fVirtualSyncCatchUp ? " - catchup" : "");
2724 if (pVM->tm.s.offVirtualSync)
2725 {
2726 pHlp->pfnPrintf(pHlp, "\n offset %RU64", pVM->tm.s.offVirtualSync);
2727 if (pVM->tm.s.u32VirtualSyncCatchUpPercentage)
2728 pHlp->pfnPrintf(pHlp, " catch-up rate %u %%", pVM->tm.s.u32VirtualSyncCatchUpPercentage);
2729 }
2730 pHlp->pfnPrintf(pHlp, "\n");
2731
2732 /*
2733 * real
2734 */
2735 pHlp->pfnPrintf(pHlp,
2736 " Real: %18RU64 (%#016RX64) %RU64Hz\n",
2737 u64Real, u64Real, TMRealGetFreq(pVM));
2738}
2739
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette