TMAll.cpp@ 98122

Last change on this file since 98122 was 98103, checked in by vboxsync, 22 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 106.9 KB

Line
1	/* $Id: TMAll.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* TM - Timeout Manager, all contexts.
4	*/
5
6	/*
7	* Copyright (C) 2006-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#define LOG_GROUP LOG_GROUP_TM
33	#ifdef DEBUG_bird
34	# define DBGFTRACE_DISABLED /* annoying */
35	#endif
36	#include <VBox/vmm/tm.h>
37	#include <VBox/vmm/mm.h>
38	#include <VBox/vmm/dbgftrace.h>
39	#ifdef IN_RING3
40	#endif
41	#include <VBox/vmm/pdmdev.h> /* (for TMTIMER_GET_CRITSECT implementation) */
42	#include "TMInternal.h"
43	#include <VBox/vmm/vmcc.h>
44
45	#include <VBox/param.h>
46	#include <VBox/err.h>
47	#include <VBox/log.h>
48	#include <VBox/sup.h>
49	#include <iprt/time.h>
50	#include <iprt/assert.h>
51	#include <iprt/asm.h>
52	#include <iprt/asm-math.h>
53	#include <iprt/string.h>
54	#ifdef IN_RING3
55	# include <iprt/thread.h>
56	#endif
57
58	#include "TMInline.h"
59
60
61	/*********************************************************************************************************************************
62	* Defined Constants And Macros *
63	*********************************************************************************************************************************/
64	#ifdef VBOX_STRICT
65	/** @def TMTIMER_GET_CRITSECT
66	* Helper for safely resolving the critical section for a timer belonging to a
67	* device instance.
68	* @todo needs reworking later as it uses PDMDEVINSR0::pDevInsR0RemoveMe. */
69	# ifdef IN_RING3
70	# define TMTIMER_GET_CRITSECT(a_pVM, a_pTimer) ((a_pTimer)->pCritSect)
71	# else
72	# define TMTIMER_GET_CRITSECT(a_pVM, a_pTimer) tmRZTimerGetCritSect(a_pVM, a_pTimer)
73	# endif
74	#endif
75
76	/** @def TMTIMER_ASSERT_CRITSECT
77	* Checks that the caller owns the critical section if one is associated with
78	* the timer. */
79	#ifdef VBOX_STRICT
80	# define TMTIMER_ASSERT_CRITSECT(a_pVM, a_pTimer) \
81	do { \
82	if ((a_pTimer)->pCritSect) \
83	{ \
84	VMSTATE enmState; \
85	PPDMCRITSECT pCritSect = TMTIMER_GET_CRITSECT(a_pVM, a_pTimer); \
86	AssertMsg( pCritSect \
87	&& ( PDMCritSectIsOwner((a_pVM), pCritSect) \
88	\|\| (enmState = (a_pVM)->enmVMState) == VMSTATE_CREATING \
89	\|\| enmState == VMSTATE_RESETTING \
90	\|\| enmState == VMSTATE_RESETTING_LS ),\
91	("pTimer=%p (%s) pCritSect=%p (%s)\n", a_pTimer, (a_pTimer)->szName, \
92	(a_pTimer)->pCritSect, R3STRING(PDMR3CritSectName((a_pTimer)->pCritSect)) )); \
93	} \
94	} while (0)
95	#else
96	# define TMTIMER_ASSERT_CRITSECT(pVM, pTimer) do { } while (0)
97	#endif
98
99	/** @def TMTIMER_ASSERT_SYNC_CRITSECT_ORDER
100	* Checks for lock order trouble between the timer critsect and the critical
101	* section critsect. The virtual sync critsect must always be entered before
102	* the one associated with the timer (see TMR3TimerQueuesDo). It is OK if there
103	* isn't any critical section associated with the timer or if the calling thread
104	* doesn't own it, ASSUMING of course that the thread using this macro is going
105	* to enter the virtual sync critical section anyway.
106	*
107	* @remarks This is a sligtly relaxed timer locking attitude compared to
108	* TMTIMER_ASSERT_CRITSECT, however, the calling device/whatever code
109	* should know what it's doing if it's stopping or starting a timer
110	* without taking the device lock.
111	*/
112	#ifdef VBOX_STRICT
113	# define TMTIMER_ASSERT_SYNC_CRITSECT_ORDER(pVM, pTimer) \
114	do { \
115	if ((pTimer)->pCritSect) \
116	{ \
117	VMSTATE enmState; \
118	PPDMCRITSECT pCritSect = TMTIMER_GET_CRITSECT(pVM, pTimer); \
119	AssertMsg( pCritSect \
120	&& ( !PDMCritSectIsOwner((pVM), pCritSect) \
121	\|\| PDMCritSectIsOwner((pVM), &(pVM)->tm.s.VirtualSyncLock) \
122	\|\| (enmState = (pVM)->enmVMState) == VMSTATE_CREATING \
123	\|\| enmState == VMSTATE_RESETTING \
124	\|\| enmState == VMSTATE_RESETTING_LS ),\
125	("pTimer=%p (%s) pCritSect=%p (%s)\n", pTimer, pTimer->szName, \
126	(pTimer)->pCritSect, R3STRING(PDMR3CritSectName((pTimer)->pCritSect)) )); \
127	} \
128	} while (0)
129	#else
130	# define TMTIMER_ASSERT_SYNC_CRITSECT_ORDER(pVM, pTimer) do { } while (0)
131	#endif
132
133
134	#if defined(VBOX_STRICT) && defined(IN_RING0)
135	/**
136	* Helper for TMTIMER_GET_CRITSECT
137	* @todo This needs a redo!
138	*/
139	DECLINLINE(PPDMCRITSECT) tmRZTimerGetCritSect(PVMCC pVM, PTMTIMER pTimer)
140	{
141	if (pTimer->enmType == TMTIMERTYPE_DEV)
142	{
143	RTCCUINTREG fSavedFlags = ASMAddFlags(X86_EFL_AC); /** @todo fix ring-3 pointer use */
144	PPDMDEVINSR0 pDevInsR0 = ((struct PDMDEVINSR3 )pTimer->u.Dev.pDevIns)->pDevInsR0RemoveMe; / !ring-3 read! */
145	ASMSetFlags(fSavedFlags);
146	struct PDMDEVINSR3 *pDevInsR3 = pDevInsR0->pDevInsForR3R0;
147	if (pTimer->pCritSect == pDevInsR3->pCritSectRoR3)
148	return pDevInsR0->pCritSectRoR0;
149	uintptr_t offCritSect = (uintptr_t)pTimer->pCritSect - (uintptr_t)pDevInsR3->pvInstanceDataR3;
150	if (offCritSect < pDevInsR0->pReg->cbInstanceShared)
151	return (PPDMCRITSECT)((uintptr_t)pDevInsR0->pvInstanceDataR0 + offCritSect);
152	}
153	RT_NOREF(pVM);
154	Assert(pTimer->pCritSect == NULL);
155	return NULL;
156	}
157	#endif /* VBOX_STRICT && IN_RING0 */
158
159
160	/**
161	* Notification that execution is about to start.
162	*
163	* This call must always be paired with a TMNotifyEndOfExecution call.
164	*
165	* The function may, depending on the configuration, resume the TSC and future
166	* clocks that only ticks when we're executing guest code.
167	*
168	* @param pVM The cross context VM structure.
169	* @param pVCpu The cross context virtual CPU structure.
170	*/
171	VMMDECL(void) TMNotifyStartOfExecution(PVMCC pVM, PVMCPUCC pVCpu)
172	{
173	#ifndef VBOX_WITHOUT_NS_ACCOUNTING
174	pVCpu->tm.s.uTscStartExecuting = SUPReadTsc();
175	pVCpu->tm.s.fExecuting = true;
176	#endif
177	if (pVM->tm.s.fTSCTiedToExecution)
178	tmCpuTickResume(pVM, pVCpu);
179	}
180
181
182	/**
183	* Notification that execution has ended.
184	*
185	* This call must always be paired with a TMNotifyStartOfExecution call.
186	*
187	* The function may, depending on the configuration, suspend the TSC and future
188	* clocks that only ticks when we're executing guest code.
189	*
190	* @param pVM The cross context VM structure.
191	* @param pVCpu The cross context virtual CPU structure.
192	* @param uTsc TSC value when exiting guest context.
193	*/
194	VMMDECL(void) TMNotifyEndOfExecution(PVMCC pVM, PVMCPUCC pVCpu, uint64_t uTsc)
195	{
196	if (pVM->tm.s.fTSCTiedToExecution)
197	tmCpuTickPause(pVCpu); /** @todo use uTsc here if we can. */
198
199	#ifndef VBOX_WITHOUT_NS_ACCOUNTING
200	/*
201	* Calculate the elapsed tick count and convert it to nanoseconds.
202	*/
203	# ifdef IN_RING3
204	PSUPGLOBALINFOPAGE const pGip = g_pSUPGlobalInfoPage;
205	uint64_t cTicks = uTsc - pVCpu->tm.s.uTscStartExecuting - SUPGetTscDelta(pGip);
206	uint64_t const uCpuHz = pGip ? SUPGetCpuHzFromGip(pGip) : pVM->tm.s.cTSCTicksPerSecondHost;
207	# else
208	uint64_t cTicks = uTsc - pVCpu->tm.s.uTscStartExecuting - SUPGetTscDeltaByCpuSetIndex(pVCpu->iHostCpuSet);
209	uint64_t const uCpuHz = SUPGetCpuHzFromGipBySetIndex(g_pSUPGlobalInfoPage, pVCpu->iHostCpuSet);
210	# endif
211	AssertStmt(cTicks <= uCpuHz << 2, cTicks = uCpuHz << 2); /* max 4 sec */
212
213	uint64_t cNsExecutingDelta;
214	if (uCpuHz < _4G)
215	cNsExecutingDelta = ASMMultU64ByU32DivByU32(cTicks, RT_NS_1SEC, uCpuHz);
216	else if (uCpuHz < 16*_1G64)
217	cNsExecutingDelta = ASMMultU64ByU32DivByU32(cTicks >> 2, RT_NS_1SEC, uCpuHz >> 2);
218	else
219	{
220	Assert(uCpuHz < 64 * _1G64);
221	cNsExecutingDelta = ASMMultU64ByU32DivByU32(cTicks >> 4, RT_NS_1SEC, uCpuHz >> 4);
222	}
223
224	/*
225	* Update the data.
226	*
227	* Note! We're not using strict memory ordering here to speed things us.
228	* The data is in a single cache line and this thread is the only
229	* one writing to that line, so I cannot quite imagine why we would
230	* need any strict ordering here.
231	*/
232	uint64_t const cNsExecutingNew = pVCpu->tm.s.cNsExecuting + cNsExecutingDelta;
233	uint32_t uGen = ASMAtomicUoIncU32(&pVCpu->tm.s.uTimesGen); Assert(uGen & 1);
234	ASMCompilerBarrier();
235	pVCpu->tm.s.fExecuting = false;
236	pVCpu->tm.s.cNsExecuting = cNsExecutingNew;
237	pVCpu->tm.s.cPeriodsExecuting++;
238	ASMCompilerBarrier();
239	ASMAtomicUoWriteU32(&pVCpu->tm.s.uTimesGen, (uGen \| 1) + 1);
240
241	/*
242	* Update stats.
243	*/
244	# if defined(VBOX_WITH_STATISTICS) \|\| defined(VBOX_WITH_NS_ACCOUNTING_STATS)
245	STAM_REL_PROFILE_ADD_PERIOD(&pVCpu->tm.s.StatNsExecuting, cNsExecutingDelta);
246	if (cNsExecutingDelta < 5000)
247	STAM_REL_PROFILE_ADD_PERIOD(&pVCpu->tm.s.StatNsExecTiny, cNsExecutingDelta);
248	else if (cNsExecutingDelta < 50000)
249	STAM_REL_PROFILE_ADD_PERIOD(&pVCpu->tm.s.StatNsExecShort, cNsExecutingDelta);
250	else
251	STAM_REL_PROFILE_ADD_PERIOD(&pVCpu->tm.s.StatNsExecLong, cNsExecutingDelta);
252	# endif
253
254	/* The timer triggers occational updating of the others and total stats: */
255	if (RT_LIKELY(!pVCpu->tm.s.fUpdateStats))
256	{ /likely/ }
257	else
258	{
259	pVCpu->tm.s.fUpdateStats = false;
260
261	uint64_t const cNsTotalNew = RTTimeNanoTS() - pVCpu->tm.s.nsStartTotal;
262	uint64_t const cNsOtherNew = cNsTotalNew - cNsExecutingNew - pVCpu->tm.s.cNsHalted;
263
264	# if defined(VBOX_WITH_STATISTICS) \|\| defined(VBOX_WITH_NS_ACCOUNTING_STATS)
265	STAM_REL_COUNTER_ADD(&pVCpu->tm.s.StatNsTotal, cNsTotalNew - pVCpu->tm.s.cNsTotalStat);
266	int64_t const cNsOtherNewDelta = cNsOtherNew - pVCpu->tm.s.cNsOtherStat;
267	if (cNsOtherNewDelta > 0)
268	STAM_REL_COUNTER_ADD(&pVCpu->tm.s.StatNsOther, (uint64_t)cNsOtherNewDelta);
269	# endif
270
271	pVCpu->tm.s.cNsTotalStat = cNsTotalNew;
272	pVCpu->tm.s.cNsOtherStat = cNsOtherNew;
273	}
274
275	#endif
276	}
277
278
279	/**
280	* Notification that the cpu is entering the halt state
281	*
282	* This call must always be paired with a TMNotifyEndOfExecution call.
283	*
284	* The function may, depending on the configuration, resume the TSC and future
285	* clocks that only ticks when we're halted.
286	*
287	* @param pVCpu The cross context virtual CPU structure.
288	*/
289	VMM_INT_DECL(void) TMNotifyStartOfHalt(PVMCPUCC pVCpu)
290	{
291	PVMCC pVM = pVCpu->CTX_SUFF(pVM);
292
293	#ifndef VBOX_WITHOUT_NS_ACCOUNTING
294	pVCpu->tm.s.nsStartHalting = RTTimeNanoTS();
295	pVCpu->tm.s.fHalting = true;
296	#endif
297
298	if ( pVM->tm.s.fTSCTiedToExecution
299	&& !pVM->tm.s.fTSCNotTiedToHalt)
300	tmCpuTickResume(pVM, pVCpu);
301	}
302
303
304	/**
305	* Notification that the cpu is leaving the halt state
306	*
307	* This call must always be paired with a TMNotifyStartOfHalt call.
308	*
309	* The function may, depending on the configuration, suspend the TSC and future
310	* clocks that only ticks when we're halted.
311	*
312	* @param pVCpu The cross context virtual CPU structure.
313	*/
314	VMM_INT_DECL(void) TMNotifyEndOfHalt(PVMCPUCC pVCpu)
315	{
316	PVM pVM = pVCpu->CTX_SUFF(pVM);
317
318	if ( pVM->tm.s.fTSCTiedToExecution
319	&& !pVM->tm.s.fTSCNotTiedToHalt)
320	tmCpuTickPause(pVCpu);
321
322	#ifndef VBOX_WITHOUT_NS_ACCOUNTING
323	uint64_t const u64NsTs = RTTimeNanoTS();
324	uint64_t const cNsTotalNew = u64NsTs - pVCpu->tm.s.nsStartTotal;
325	uint64_t const cNsHaltedDelta = u64NsTs - pVCpu->tm.s.nsStartHalting;
326	uint64_t const cNsHaltedNew = pVCpu->tm.s.cNsHalted + cNsHaltedDelta;
327	uint64_t const cNsOtherNew = cNsTotalNew - pVCpu->tm.s.cNsExecuting - cNsHaltedNew;
328
329	uint32_t uGen = ASMAtomicUoIncU32(&pVCpu->tm.s.uTimesGen); Assert(uGen & 1);
330	ASMCompilerBarrier();
331	pVCpu->tm.s.fHalting = false;
332	pVCpu->tm.s.fUpdateStats = false;
333	pVCpu->tm.s.cNsHalted = cNsHaltedNew;
334	pVCpu->tm.s.cPeriodsHalted++;
335	ASMCompilerBarrier();
336	ASMAtomicUoWriteU32(&pVCpu->tm.s.uTimesGen, (uGen \| 1) + 1);
337
338	# if defined(VBOX_WITH_STATISTICS) \|\| defined(VBOX_WITH_NS_ACCOUNTING_STATS)
339	STAM_REL_PROFILE_ADD_PERIOD(&pVCpu->tm.s.StatNsHalted, cNsHaltedDelta);
340	STAM_REL_COUNTER_ADD(&pVCpu->tm.s.StatNsTotal, cNsTotalNew - pVCpu->tm.s.cNsTotalStat);
341	int64_t const cNsOtherNewDelta = cNsOtherNew - pVCpu->tm.s.cNsOtherStat;
342	if (cNsOtherNewDelta > 0)
343	STAM_REL_COUNTER_ADD(&pVCpu->tm.s.StatNsOther, (uint64_t)cNsOtherNewDelta);
344	# endif
345	pVCpu->tm.s.cNsTotalStat = cNsTotalNew;
346	pVCpu->tm.s.cNsOtherStat = cNsOtherNew;
347	#endif
348	}
349
350
351	/**
352	* Raise the timer force action flag and notify the dedicated timer EMT.
353	*
354	* @param pVM The cross context VM structure.
355	*/
356	DECLINLINE(void) tmScheduleNotify(PVMCC pVM)
357	{
358	VMCPUID idCpu = pVM->tm.s.idTimerCpu;
359	AssertReturnVoid(idCpu < pVM->cCpus);
360	PVMCPUCC pVCpuDst = VMCC_GET_CPU(pVM, idCpu);
361
362	if (!VMCPU_FF_IS_SET(pVCpuDst, VMCPU_FF_TIMER))
363	{
364	Log5(("TMAll(%u): FF: 0 -> 1\n", __LINE__));
365	VMCPU_FF_SET(pVCpuDst, VMCPU_FF_TIMER);
366	#ifdef IN_RING3
367	VMR3NotifyCpuFFU(pVCpuDst->pUVCpu, VMNOTIFYFF_FLAGS_DONE_REM);
368	#endif
369	STAM_COUNTER_INC(&pVM->tm.s.StatScheduleSetFF);
370	}
371	}
372
373
374	/**
375	* Schedule the queue which was changed.
376	*/
377	DECLINLINE(void) tmSchedule(PVMCC pVM, PTMTIMERQUEUECC pQueueCC, PTMTIMERQUEUE pQueue, PTMTIMER pTimer)
378	{
379	int rc = PDMCritSectTryEnter(pVM, &pQueue->TimerLock);
380	if (RT_SUCCESS_NP(rc))
381	{
382	STAM_PROFILE_START(&pVM->tm.s.CTX_SUFF_Z(StatScheduleOne), a);
383	Log3(("tmSchedule: tmTimerQueueSchedule\n"));
384	tmTimerQueueSchedule(pVM, pQueueCC, pQueue);
385	#ifdef VBOX_STRICT
386	tmTimerQueuesSanityChecks(pVM, "tmSchedule");
387	#endif
388	STAM_PROFILE_STOP(&pVM->tm.s.CTX_SUFF_Z(StatScheduleOne), a);
389	PDMCritSectLeave(pVM, &pQueue->TimerLock);
390	return;
391	}
392
393	TMTIMERSTATE enmState = pTimer->enmState;
394	if (TMTIMERSTATE_IS_PENDING_SCHEDULING(enmState))
395	tmScheduleNotify(pVM);
396	}
397
398
399	/**
400	* Try change the state to enmStateNew from enmStateOld
401	* and link the timer into the scheduling queue.
402	*
403	* @returns Success indicator.
404	* @param pTimer Timer in question.
405	* @param enmStateNew The new timer state.
406	* @param enmStateOld The old timer state.
407	*/
408	DECLINLINE(bool) tmTimerTry(PTMTIMER pTimer, TMTIMERSTATE enmStateNew, TMTIMERSTATE enmStateOld)
409	{
410	/*
411	* Attempt state change.
412	*/
413	bool fRc;
414	TM_TRY_SET_STATE(pTimer, enmStateNew, enmStateOld, fRc);
415	return fRc;
416	}
417
418
419	/**
420	* Links the timer onto the scheduling queue.
421	*
422	* @param pQueueCC The current context queue (same as @a pQueue for
423	* ring-3).
424	* @param pQueue The shared queue data.
425	* @param pTimer The timer.
426	*
427	* @todo FIXME: Look into potential race with the thread running the queues
428	* and stuff.
429	*/
430	DECLINLINE(void) tmTimerLinkSchedule(PTMTIMERQUEUECC pQueueCC, PTMTIMERQUEUE pQueue, PTMTIMER pTimer)
431	{
432	Assert(pTimer->idxScheduleNext == UINT32_MAX);
433	const uint32_t idxHeadNew = pTimer - &pQueueCC->paTimers[0];
434	AssertReturnVoid(idxHeadNew < pQueueCC->cTimersAlloc);
435
436	uint32_t idxHead;
437	do
438	{
439	idxHead = pQueue->idxSchedule;
440	Assert(idxHead == UINT32_MAX \|\| idxHead < pQueueCC->cTimersAlloc);
441	pTimer->idxScheduleNext = idxHead;
442	} while (!ASMAtomicCmpXchgU32(&pQueue->idxSchedule, idxHeadNew, idxHead));
443	}
444
445
446	/**
447	* Try change the state to enmStateNew from enmStateOld
448	* and link the timer into the scheduling queue.
449	*
450	* @returns Success indicator.
451	* @param pQueueCC The current context queue (same as @a pQueue for
452	* ring-3).
453	* @param pQueue The shared queue data.
454	* @param pTimer Timer in question.
455	* @param enmStateNew The new timer state.
456	* @param enmStateOld The old timer state.
457	*/
458	DECLINLINE(bool) tmTimerTryWithLink(PTMTIMERQUEUECC pQueueCC, PTMTIMERQUEUE pQueue, PTMTIMER pTimer,
459	TMTIMERSTATE enmStateNew, TMTIMERSTATE enmStateOld)
460	{
461	if (tmTimerTry(pTimer, enmStateNew, enmStateOld))
462	{
463	tmTimerLinkSchedule(pQueueCC, pQueue, pTimer);
464	return true;
465	}
466	return false;
467	}
468
469
470	/**
471	* Links a timer into the active list of a timer queue.
472	*
473	* @param pVM The cross context VM structure.
474	* @param pQueueCC The current context queue (same as @a pQueue for
475	* ring-3).
476	* @param pQueue The shared queue data.
477	* @param pTimer The timer.
478	* @param u64Expire The timer expiration time.
479	*
480	* @remarks Called while owning the relevant queue lock.
481	*/
482	DECL_FORCE_INLINE(void) tmTimerQueueLinkActive(PVMCC pVM, PTMTIMERQUEUECC pQueueCC, PTMTIMERQUEUE pQueue,
483	PTMTIMER pTimer, uint64_t u64Expire)
484	{
485	Assert(pTimer->idxNext == UINT32_MAX);
486	Assert(pTimer->idxPrev == UINT32_MAX);
487	Assert(pTimer->enmState == TMTIMERSTATE_ACTIVE \|\| pQueue->enmClock != TMCLOCK_VIRTUAL_SYNC); /* (active is not a stable state) */
488	RT_NOREF(pVM);
489
490	PTMTIMER pCur = tmTimerQueueGetHead(pQueueCC, pQueue);
491	if (pCur)
492	{
493	for (;; pCur = tmTimerGetNext(pQueueCC, pCur))
494	{
495	if (pCur->u64Expire > u64Expire)
496	{
497	const PTMTIMER pPrev = tmTimerGetPrev(pQueueCC, pCur);
498	tmTimerSetNext(pQueueCC, pTimer, pCur);
499	tmTimerSetPrev(pQueueCC, pTimer, pPrev);
500	if (pPrev)
501	tmTimerSetNext(pQueueCC, pPrev, pTimer);
502	else
503	{
504	tmTimerQueueSetHead(pQueueCC, pQueue, pTimer);
505	ASMAtomicWriteU64(&pQueue->u64Expire, u64Expire);
506	DBGFTRACE_U64_TAG2(pVM, u64Expire, "tmTimerQueueLinkActive head", pTimer->szName);
507	}
508	tmTimerSetPrev(pQueueCC, pCur, pTimer);
509	return;
510	}
511	if (pCur->idxNext == UINT32_MAX)
512	{
513	tmTimerSetNext(pQueueCC, pCur, pTimer);
514	tmTimerSetPrev(pQueueCC, pTimer, pCur);
515	DBGFTRACE_U64_TAG2(pVM, u64Expire, "tmTimerQueueLinkActive tail", pTimer->szName);
516	return;
517	}
518	}
519	}
520	else
521	{
522	tmTimerQueueSetHead(pQueueCC, pQueue, pTimer);
523	ASMAtomicWriteU64(&pQueue->u64Expire, u64Expire);
524	DBGFTRACE_U64_TAG2(pVM, u64Expire, "tmTimerQueueLinkActive empty", pTimer->szName);
525	}
526	}
527
528
529
530	/**
531	* Schedules the given timer on the given queue.
532	*
533	* @param pVM The cross context VM structure.
534	* @param pQueueCC The current context queue (same as @a pQueue for
535	* ring-3).
536	* @param pQueue The shared queue data.
537	* @param pTimer The timer that needs scheduling.
538	*
539	* @remarks Called while owning the lock.
540	*/
541	DECLINLINE(void) tmTimerQueueScheduleOne(PVMCC pVM, PTMTIMERQUEUECC pQueueCC, PTMTIMERQUEUE pQueue, PTMTIMER pTimer)
542	{
543	Assert(pQueue->enmClock != TMCLOCK_VIRTUAL_SYNC);
544	RT_NOREF(pVM);
545
546	/*
547	* Processing.
548	*/
549	unsigned cRetries = 2;
550	do
551	{
552	TMTIMERSTATE enmState = pTimer->enmState;
553	switch (enmState)
554	{
555	/*
556	* Reschedule timer (in the active list).
557	*/
558	case TMTIMERSTATE_PENDING_RESCHEDULE:
559	if (RT_UNLIKELY(!tmTimerTry(pTimer, TMTIMERSTATE_PENDING_SCHEDULE, TMTIMERSTATE_PENDING_RESCHEDULE)))
560	break; /* retry */
561	tmTimerQueueUnlinkActive(pVM, pQueueCC, pQueue, pTimer);
562	RT_FALL_THRU();
563
564	/*
565	* Schedule timer (insert into the active list).
566	*/
567	case TMTIMERSTATE_PENDING_SCHEDULE:
568	Assert(pTimer->idxNext == UINT32_MAX); Assert(pTimer->idxPrev == UINT32_MAX);
569	if (RT_UNLIKELY(!tmTimerTry(pTimer, TMTIMERSTATE_ACTIVE, TMTIMERSTATE_PENDING_SCHEDULE)))
570	break; /* retry */
571	tmTimerQueueLinkActive(pVM, pQueueCC, pQueue, pTimer, pTimer->u64Expire);
572	return;
573
574	/*
575	* Stop the timer in active list.
576	*/
577	case TMTIMERSTATE_PENDING_STOP:
578	if (RT_UNLIKELY(!tmTimerTry(pTimer, TMTIMERSTATE_PENDING_STOP_SCHEDULE, TMTIMERSTATE_PENDING_STOP)))
579	break; /* retry */
580	tmTimerQueueUnlinkActive(pVM, pQueueCC, pQueue, pTimer);
581	RT_FALL_THRU();
582
583	/*
584	* Stop the timer (not on the active list).
585	*/
586	case TMTIMERSTATE_PENDING_STOP_SCHEDULE:
587	Assert(pTimer->idxNext == UINT32_MAX); Assert(pTimer->idxPrev == UINT32_MAX);
588	if (RT_UNLIKELY(!tmTimerTry(pTimer, TMTIMERSTATE_STOPPED, TMTIMERSTATE_PENDING_STOP_SCHEDULE)))
589	break;
590	return;
591
592	/*
593	* The timer is pending destruction by TMR3TimerDestroy, our caller.
594	* Nothing to do here.
595	*/
596	case TMTIMERSTATE_DESTROY:
597	break;
598
599	/*
600	* Postpone these until they get into the right state.
601	*/
602	case TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE:
603	case TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE:
604	tmTimerLinkSchedule(pQueueCC, pQueue, pTimer);
605	STAM_COUNTER_INC(&pVM->tm.s.CTX_SUFF_Z(StatPostponed));
606	return;
607
608	/*
609	* None of these can be in the schedule.
610	*/
611	case TMTIMERSTATE_FREE:
612	case TMTIMERSTATE_STOPPED:
613	case TMTIMERSTATE_ACTIVE:
614	case TMTIMERSTATE_EXPIRED_GET_UNLINK:
615	case TMTIMERSTATE_EXPIRED_DELIVER:
616	default:
617	AssertMsgFailed(("Timer (%p) in the scheduling list has an invalid state %s (%d)!",
618	pTimer, tmTimerState(pTimer->enmState), pTimer->enmState));
619	return;
620	}
621	} while (cRetries-- > 0);
622	}
623
624
625	/**
626	* Schedules the specified timer queue.
627	*
628	* @param pVM The cross context VM structure.
629	* @param pQueueCC The current context queue (same as @a pQueue for
630	* ring-3) data of the queue to schedule.
631	* @param pQueue The shared queue data of the queue to schedule.
632	*
633	* @remarks Called while owning the lock.
634	*/
635	void tmTimerQueueSchedule(PVMCC pVM, PTMTIMERQUEUECC pQueueCC, PTMTIMERQUEUE pQueue)
636	{
637	Assert(PDMCritSectIsOwner(pVM, &pQueue->TimerLock));
638
639	/*
640	* Dequeue the scheduling list and iterate it.
641	*/
642	uint32_t idxNext = ASMAtomicXchgU32(&pQueue->idxSchedule, UINT32_MAX);
643	Log2(("tmTimerQueueSchedule: pQueue=%p:{.enmClock=%d, idxNext=%RI32, .u64Expired=%'RU64}\n", pQueue, pQueue->enmClock, idxNext, pQueue->u64Expire));
644	while (idxNext != UINT32_MAX)
645	{
646	AssertBreak(idxNext < pQueueCC->cTimersAlloc);
647
648	/*
649	* Unlink the head timer and take down the index of the next one.
650	*/
651	PTMTIMER pTimer = &pQueueCC->paTimers[idxNext];
652	idxNext = pTimer->idxScheduleNext;
653	pTimer->idxScheduleNext = UINT32_MAX;
654
655	/*
656	* Do the scheduling.
657	*/
658	Log2(("tmTimerQueueSchedule: %p:{.enmState=%s, .enmClock=%d, .enmType=%d, .szName=%s}\n",
659	pTimer, tmTimerState(pTimer->enmState), pQueue->enmClock, pTimer->enmType, pTimer->szName));
660	tmTimerQueueScheduleOne(pVM, pQueueCC, pQueue, pTimer);
661	Log2(("tmTimerQueueSchedule: %p: new %s\n", pTimer, tmTimerState(pTimer->enmState)));
662	}
663	Log2(("tmTimerQueueSchedule: u64Expired=%'RU64\n", pQueue->u64Expire));
664	}
665
666
667	#ifdef VBOX_STRICT
668	/**
669	* Checks that the timer queues are sane.
670	*
671	* @param pVM The cross context VM structure.
672	* @param pszWhere Caller location clue.
673	*/
674	void tmTimerQueuesSanityChecks(PVMCC pVM, const char *pszWhere)
675	{
676	for (uint32_t idxQueue = 0; idxQueue < RT_ELEMENTS(pVM->tm.s.aTimerQueues); idxQueue++)
677	{
678	PTMTIMERQUEUE const pQueue = &pVM->tm.s.aTimerQueues[idxQueue];
679	PTMTIMERQUEUECC const pQueueCC = TM_GET_TIMER_QUEUE_CC(pVM, idxQueue, pQueue);
680	Assert(pQueue->enmClock == (TMCLOCK)idxQueue);
681
682	int rc = PDMCritSectTryEnter(pVM, &pQueue->TimerLock);
683	if (RT_SUCCESS(rc))
684	{
685	if ( pQueue->enmClock != TMCLOCK_VIRTUAL_SYNC
686	\|\| PDMCritSectTryEnter(pVM, &pVM->tm.s.VirtualSyncLock) == VINF_SUCCESS)
687	{
688	/* Check the linking of the active lists. */
689	PTMTIMER pPrev = NULL;
690	for (PTMTIMER pCur = tmTimerQueueGetHead(pQueueCC, pQueue);
691	pCur;
692	pPrev = pCur, pCur = tmTimerGetNext(pQueueCC, pCur))
693	{
694	AssertMsg(tmTimerGetPrev(pQueueCC, pCur) == pPrev, ("%s: %p != %p\n", pszWhere, tmTimerGetPrev(pQueueCC, pCur), pPrev));
695	TMTIMERSTATE enmState = pCur->enmState;
696	switch (enmState)
697	{
698	case TMTIMERSTATE_ACTIVE:
699	AssertMsg( pCur->idxScheduleNext == UINT32_MAX
700	\|\| pCur->enmState != TMTIMERSTATE_ACTIVE,
701	("%s: %RI32\n", pszWhere, pCur->idxScheduleNext));
702	break;
703	case TMTIMERSTATE_PENDING_STOP:
704	case TMTIMERSTATE_PENDING_RESCHEDULE:
705	case TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE:
706	break;
707	default:
708	AssertMsgFailed(("%s: Invalid state enmState=%d %s\n", pszWhere, enmState, tmTimerState(enmState)));
709	break;
710	}
711	}
712
713	# ifdef IN_RING3
714	/* Go thru all the timers and check that the active ones all are in the active lists. */
715	uint32_t idxTimer = pQueue->cTimersAlloc;
716	uint32_t cFree = 0;
717	while (idxTimer-- > 0)
718	{
719	PTMTIMER const pTimer = &pQueue->paTimers[idxTimer];
720	TMTIMERSTATE const enmState = pTimer->enmState;
721	switch (enmState)
722	{
723	case TMTIMERSTATE_FREE:
724	cFree++;
725	break;
726
727	case TMTIMERSTATE_ACTIVE:
728	case TMTIMERSTATE_PENDING_STOP:
729	case TMTIMERSTATE_PENDING_RESCHEDULE:
730	case TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE:
731	{
732	PTMTIMERR3 pCurAct = tmTimerQueueGetHead(pQueueCC, pQueue);
733	Assert(pTimer->idxPrev != UINT32_MAX \|\| pTimer == pCurAct);
734	while (pCurAct && pCurAct != pTimer)
735	pCurAct = tmTimerGetNext(pQueueCC, pCurAct);
736	Assert(pCurAct == pTimer);
737	break;
738	}
739
740	case TMTIMERSTATE_PENDING_SCHEDULE:
741	case TMTIMERSTATE_PENDING_STOP_SCHEDULE:
742	case TMTIMERSTATE_STOPPED:
743	case TMTIMERSTATE_EXPIRED_DELIVER:
744	{
745	Assert(pTimer->idxNext == UINT32_MAX);
746	Assert(pTimer->idxPrev == UINT32_MAX);
747	for (PTMTIMERR3 pCurAct = tmTimerQueueGetHead(pQueueCC, pQueue);
748	pCurAct;
749	pCurAct = tmTimerGetNext(pQueueCC, pCurAct))
750	{
751	Assert(pCurAct != pTimer);
752	Assert(tmTimerGetNext(pQueueCC, pCurAct) != pTimer);
753	Assert(tmTimerGetPrev(pQueueCC, pCurAct) != pTimer);
754	}
755	break;
756	}
757
758	/* ignore */
759	case TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE:
760	break;
761
762	case TMTIMERSTATE_INVALID:
763	Assert(idxTimer == 0);
764	break;
765
766	/* shouldn't get here! */
767	case TMTIMERSTATE_EXPIRED_GET_UNLINK:
768	case TMTIMERSTATE_DESTROY:
769	default:
770	AssertMsgFailed(("Invalid state enmState=%d %s\n", enmState, tmTimerState(enmState)));
771	break;
772	}
773
774	/* Check the handle value. */
775	if (enmState > TMTIMERSTATE_INVALID && enmState < TMTIMERSTATE_DESTROY)
776	{
777	Assert((pTimer->hSelf & TMTIMERHANDLE_TIMER_IDX_MASK) == idxTimer);
778	Assert(((pTimer->hSelf >> TMTIMERHANDLE_QUEUE_IDX_SHIFT) & TMTIMERHANDLE_QUEUE_IDX_SMASK) == idxQueue);
779	}
780	}
781	Assert(cFree == pQueue->cTimersFree);
782	# endif /* IN_RING3 */
783
784	if (pQueue->enmClock == TMCLOCK_VIRTUAL_SYNC)
785	PDMCritSectLeave(pVM, &pVM->tm.s.VirtualSyncLock);
786	}
787	PDMCritSectLeave(pVM, &pQueue->TimerLock);
788	}
789	}
790	}
791	#endif /* !VBOX_STRICT */
792
793	#ifdef VBOX_HIGH_RES_TIMERS_HACK
794
795	/**
796	* Worker for tmTimerPollInternal that handles misses when the dedicated timer
797	* EMT is polling.
798	*
799	* @returns See tmTimerPollInternal.
800	* @param pVM The cross context VM structure.
801	* @param u64Now Current virtual clock timestamp.
802	* @param u64Delta The delta to the next even in ticks of the
803	* virtual clock.
804	* @param pu64Delta Where to return the delta.
805	*/
806	DECLINLINE(uint64_t) tmTimerPollReturnMiss(PVM pVM, uint64_t u64Now, uint64_t u64Delta, uint64_t *pu64Delta)
807	{
808	Assert(!(u64Delta & RT_BIT_64(63)));
809
810	if (!pVM->tm.s.fVirtualWarpDrive)
811	{
812	*pu64Delta = u64Delta;
813	return u64Delta + u64Now + pVM->tm.s.u64VirtualOffset;
814	}
815
816	/*
817	* Warp drive adjustments - this is the reverse of what tmVirtualGetRaw is doing.
818	*/
819	uint64_t const u64Start = pVM->tm.s.u64VirtualWarpDriveStart;
820	uint32_t const u32Pct = pVM->tm.s.u32VirtualWarpDrivePercentage;
821
822	uint64_t u64GipTime = u64Delta + u64Now + pVM->tm.s.u64VirtualOffset;
823	u64GipTime -= u64Start; /* the start is GIP time. */
824	if (u64GipTime >= u64Delta)
825	{
826	ASMMultU64ByU32DivByU32(u64GipTime, 100, u32Pct);
827	ASMMultU64ByU32DivByU32(u64Delta, 100, u32Pct);
828	}
829	else
830	{
831	u64Delta -= u64GipTime;
832	ASMMultU64ByU32DivByU32(u64GipTime, 100, u32Pct);
833	u64Delta += u64GipTime;
834	}
835	*pu64Delta = u64Delta;
836	u64GipTime += u64Start;
837	return u64GipTime;
838	}
839
840
841	/**
842	* Worker for tmTimerPollInternal dealing with returns on virtual CPUs other
843	* than the one dedicated to timer work.
844	*
845	* @returns See tmTimerPollInternal.
846	* @param pVM The cross context VM structure.
847	* @param u64Now Current virtual clock timestamp.
848	* @param pu64Delta Where to return the delta.
849	*/
850	DECL_FORCE_INLINE(uint64_t) tmTimerPollReturnOtherCpu(PVM pVM, uint64_t u64Now, uint64_t *pu64Delta)
851	{
852	static const uint64_t s_u64OtherRet = 500000000; /* 500 ms for non-timer EMTs. */
853	*pu64Delta = s_u64OtherRet;
854	return u64Now + pVM->tm.s.u64VirtualOffset + s_u64OtherRet;
855	}
856
857
858	/**
859	* Worker for tmTimerPollInternal.
860	*
861	* @returns See tmTimerPollInternal.
862	* @param pVM The cross context VM structure.
863	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
864	* @param pVCpuDst The cross context virtual CPU structure of the dedicated
865	* timer EMT.
866	* @param u64Now Current virtual clock timestamp.
867	* @param pu64Delta Where to return the delta.
868	* @param pCounter The statistics counter to update.
869	*/
870	DECL_FORCE_INLINE(uint64_t) tmTimerPollReturnHit(PVM pVM, PVMCPU pVCpu, PVMCPU pVCpuDst, uint64_t u64Now,
871	uint64_t *pu64Delta, PSTAMCOUNTER pCounter)
872	{
873	STAM_COUNTER_INC(pCounter); NOREF(pCounter);
874	if (pVCpuDst != pVCpu)
875	return tmTimerPollReturnOtherCpu(pVM, u64Now, pu64Delta);
876	*pu64Delta = 0;
877	return 0;
878	}
879
880
881	/**
882	* Common worker for TMTimerPollGIP and TMTimerPoll.
883	*
884	* This function is called before FFs are checked in the inner execution EM loops.
885	*
886	* @returns The GIP timestamp of the next event.
887	* 0 if the next event has already expired.
888	*
889	* @param pVM The cross context VM structure.
890	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
891	* @param pu64Delta Where to store the delta.
892	*
893	* @thread The emulation thread.
894	*
895	* @remarks GIP uses ns ticks.
896	*/
897	DECL_FORCE_INLINE(uint64_t) tmTimerPollInternal(PVMCC pVM, PVMCPUCC pVCpu, uint64_t *pu64Delta)
898	{
899	VMCPUID idCpu = pVM->tm.s.idTimerCpu;
900	AssertReturn(idCpu < pVM->cCpus, 0);
901	PVMCPUCC pVCpuDst = VMCC_GET_CPU(pVM, idCpu);
902
903	const uint64_t u64Now = TMVirtualGetNoCheck(pVM);
904	STAM_COUNTER_INC(&pVM->tm.s.StatPoll);
905
906	/*
907	* Return straight away if the timer FF is already set ...
908	*/
909	if (VMCPU_FF_IS_SET(pVCpuDst, VMCPU_FF_TIMER))
910	return tmTimerPollReturnHit(pVM, pVCpu, pVCpuDst, u64Now, pu64Delta, &pVM->tm.s.StatPollAlreadySet);
911
912	/*
913	* ... or if timers are being run.
914	*/
915	if (ASMAtomicReadBool(&pVM->tm.s.fRunningQueues))
916	{
917	STAM_COUNTER_INC(&pVM->tm.s.StatPollRunning);
918	return tmTimerPollReturnOtherCpu(pVM, u64Now, pu64Delta);
919	}
920
921	/*
922	* Check for TMCLOCK_VIRTUAL expiration.
923	*/
924	const uint64_t u64Expire1 = ASMAtomicReadU64(&pVM->tm.s.aTimerQueues[TMCLOCK_VIRTUAL].u64Expire);
925	const int64_t i64Delta1 = u64Expire1 - u64Now;
926	if (i64Delta1 <= 0)
927	{
928	if (!VMCPU_FF_IS_SET(pVCpuDst, VMCPU_FF_TIMER))
929	{
930	Log5(("TMAll(%u): FF: %d -> 1\n", __LINE__, VMCPU_FF_IS_SET(pVCpuDst, VMCPU_FF_TIMER)));
931	VMCPU_FF_SET(pVCpuDst, VMCPU_FF_TIMER);
932	}
933	LogFlow(("TMTimerPoll: expire1=%'RU64 <= now=%'RU64\n", u64Expire1, u64Now));
934	return tmTimerPollReturnHit(pVM, pVCpu, pVCpuDst, u64Now, pu64Delta, &pVM->tm.s.StatPollVirtual);
935	}
936
937	/*
938	* Check for TMCLOCK_VIRTUAL_SYNC expiration.
939	* This isn't quite as straight forward if in a catch-up, not only do
940	* we have to adjust the 'now' but when have to adjust the delta as well.
941	*/
942
943	/*
944	* Optimistic lockless approach.
945	*/
946	uint64_t u64VirtualSyncNow;
947	uint64_t u64Expire2 = ASMAtomicUoReadU64(&pVM->tm.s.aTimerQueues[TMCLOCK_VIRTUAL_SYNC].u64Expire);
948	if (ASMAtomicUoReadBool(&pVM->tm.s.fVirtualSyncTicking))
949	{
950	if (!ASMAtomicUoReadBool(&pVM->tm.s.fVirtualSyncCatchUp))
951	{
952	u64VirtualSyncNow = ASMAtomicReadU64(&pVM->tm.s.offVirtualSync);
953	if (RT_LIKELY( ASMAtomicUoReadBool(&pVM->tm.s.fVirtualSyncTicking)
954	&& !ASMAtomicUoReadBool(&pVM->tm.s.fVirtualSyncCatchUp)
955	&& u64VirtualSyncNow == ASMAtomicReadU64(&pVM->tm.s.offVirtualSync)
956	&& u64Expire2 == ASMAtomicUoReadU64(&pVM->tm.s.aTimerQueues[TMCLOCK_VIRTUAL_SYNC].u64Expire)))
957	{
958	u64VirtualSyncNow = u64Now - u64VirtualSyncNow;
959	int64_t i64Delta2 = u64Expire2 - u64VirtualSyncNow;
960	if (i64Delta2 > 0)
961	{
962	STAM_COUNTER_INC(&pVM->tm.s.StatPollSimple);
963	STAM_COUNTER_INC(&pVM->tm.s.StatPollMiss);
964
965	if (pVCpu == pVCpuDst)
966	return tmTimerPollReturnMiss(pVM, u64Now, RT_MIN(i64Delta1, i64Delta2), pu64Delta);
967	return tmTimerPollReturnOtherCpu(pVM, u64Now, pu64Delta);
968	}
969
970	if ( !pVM->tm.s.fRunningQueues
971	&& !VMCPU_FF_IS_SET(pVCpuDst, VMCPU_FF_TIMER))
972	{
973	Log5(("TMAll(%u): FF: %d -> 1\n", __LINE__, VMCPU_FF_IS_SET(pVCpuDst, VMCPU_FF_TIMER)));
974	VMCPU_FF_SET(pVCpuDst, VMCPU_FF_TIMER);
975	}
976
977	STAM_COUNTER_INC(&pVM->tm.s.StatPollSimple);
978	LogFlow(("TMTimerPoll: expire2=%'RU64 <= now=%'RU64\n", u64Expire2, u64Now));
979	return tmTimerPollReturnHit(pVM, pVCpu, pVCpuDst, u64Now, pu64Delta, &pVM->tm.s.StatPollVirtualSync);
980	}
981	}
982	}
983	else
984	{
985	STAM_COUNTER_INC(&pVM->tm.s.StatPollSimple);
986	LogFlow(("TMTimerPoll: stopped\n"));
987	return tmTimerPollReturnHit(pVM, pVCpu, pVCpuDst, u64Now, pu64Delta, &pVM->tm.s.StatPollVirtualSync);
988	}
989
990	/*
991	* Complicated lockless approach.
992	*/
993	uint64_t off;
994	uint32_t u32Pct = 0;
995	bool fCatchUp;
996	int cOuterTries = 42;
997	for (;; cOuterTries--)
998	{
999	fCatchUp = ASMAtomicReadBool(&pVM->tm.s.fVirtualSyncCatchUp);
1000	off = ASMAtomicReadU64(&pVM->tm.s.offVirtualSync);
1001	u64Expire2 = ASMAtomicReadU64(&pVM->tm.s.aTimerQueues[TMCLOCK_VIRTUAL_SYNC].u64Expire);
1002	if (fCatchUp)
1003	{
1004	/* No changes allowed, try get a consistent set of parameters. */
1005	uint64_t const u64Prev = ASMAtomicReadU64(&pVM->tm.s.u64VirtualSyncCatchUpPrev);
1006	uint64_t const offGivenUp = ASMAtomicReadU64(&pVM->tm.s.offVirtualSyncGivenUp);
1007	u32Pct = ASMAtomicReadU32(&pVM->tm.s.u32VirtualSyncCatchUpPercentage);
1008	if ( ( u64Prev == ASMAtomicReadU64(&pVM->tm.s.u64VirtualSyncCatchUpPrev)
1009	&& offGivenUp == ASMAtomicReadU64(&pVM->tm.s.offVirtualSyncGivenUp)
1010	&& u32Pct == ASMAtomicReadU32(&pVM->tm.s.u32VirtualSyncCatchUpPercentage)
1011	&& off == ASMAtomicReadU64(&pVM->tm.s.offVirtualSync)
1012	&& u64Expire2 == ASMAtomicReadU64(&pVM->tm.s.aTimerQueues[TMCLOCK_VIRTUAL_SYNC].u64Expire)
1013	&& ASMAtomicReadBool(&pVM->tm.s.fVirtualSyncCatchUp)
1014	&& ASMAtomicReadBool(&pVM->tm.s.fVirtualSyncTicking))
1015	\|\| cOuterTries <= 0)
1016	{
1017	uint64_t u64Delta = u64Now - u64Prev;
1018	if (RT_LIKELY(!(u64Delta >> 32)))
1019	{
1020	uint64_t u64Sub = ASMMultU64ByU32DivByU32(u64Delta, u32Pct, 100);
1021	if (off > u64Sub + offGivenUp)
1022	off -= u64Sub;
1023	else /* we've completely caught up. */
1024	off = offGivenUp;
1025	}
1026	else
1027	/* More than 4 seconds since last time (or negative), ignore it. */
1028	Log(("TMVirtualGetSync: u64Delta=%RX64 (NoLock)\n", u64Delta));
1029
1030	/* Check that we're still running and in catch up. */
1031	if ( ASMAtomicUoReadBool(&pVM->tm.s.fVirtualSyncTicking)
1032	&& ASMAtomicReadBool(&pVM->tm.s.fVirtualSyncCatchUp))
1033	break;
1034	}
1035	}
1036	else if ( off == ASMAtomicReadU64(&pVM->tm.s.offVirtualSync)
1037	&& u64Expire2 == ASMAtomicReadU64(&pVM->tm.s.aTimerQueues[TMCLOCK_VIRTUAL_SYNC].u64Expire)
1038	&& !ASMAtomicReadBool(&pVM->tm.s.fVirtualSyncCatchUp)
1039	&& ASMAtomicReadBool(&pVM->tm.s.fVirtualSyncTicking))
1040	break; /* Got an consistent offset */
1041
1042	/* Repeat the initial checks before iterating. */
1043	if (VMCPU_FF_IS_SET(pVCpuDst, VMCPU_FF_TIMER))
1044	return tmTimerPollReturnHit(pVM, pVCpu, pVCpuDst, u64Now, pu64Delta, &pVM->tm.s.StatPollAlreadySet);
1045	if (ASMAtomicUoReadBool(&pVM->tm.s.fRunningQueues))
1046	{
1047	STAM_COUNTER_INC(&pVM->tm.s.StatPollRunning);
1048	return tmTimerPollReturnOtherCpu(pVM, u64Now, pu64Delta);
1049	}
1050	if (!ASMAtomicUoReadBool(&pVM->tm.s.fVirtualSyncTicking))
1051	{
1052	LogFlow(("TMTimerPoll: stopped\n"));
1053	return tmTimerPollReturnHit(pVM, pVCpu, pVCpuDst, u64Now, pu64Delta, &pVM->tm.s.StatPollVirtualSync);
1054	}
1055	if (cOuterTries <= 0)
1056	break; /* that's enough */
1057	}
1058	if (cOuterTries <= 0)
1059	STAM_COUNTER_INC(&pVM->tm.s.StatPollELoop);
1060	u64VirtualSyncNow = u64Now - off;
1061
1062	/* Calc delta and see if we've got a virtual sync hit. */
1063	int64_t i64Delta2 = u64Expire2 - u64VirtualSyncNow;
1064	if (i64Delta2 <= 0)
1065	{
1066	if ( !pVM->tm.s.fRunningQueues
1067	&& !VMCPU_FF_IS_SET(pVCpuDst, VMCPU_FF_TIMER))
1068	{
1069	Log5(("TMAll(%u): FF: %d -> 1\n", __LINE__, VMCPU_FF_IS_SET(pVCpuDst, VMCPU_FF_TIMER)));
1070	VMCPU_FF_SET(pVCpuDst, VMCPU_FF_TIMER);
1071	}
1072	STAM_COUNTER_INC(&pVM->tm.s.StatPollVirtualSync);
1073	LogFlow(("TMTimerPoll: expire2=%'RU64 <= now=%'RU64\n", u64Expire2, u64Now));
1074	return tmTimerPollReturnHit(pVM, pVCpu, pVCpuDst, u64Now, pu64Delta, &pVM->tm.s.StatPollVirtualSync);
1075	}
1076
1077	/*
1078	* Return the time left to the next event.
1079	*/
1080	STAM_COUNTER_INC(&pVM->tm.s.StatPollMiss);
1081	if (pVCpu == pVCpuDst)
1082	{
1083	if (fCatchUp)
1084	i64Delta2 = ASMMultU64ByU32DivByU32(i64Delta2, 100, u32Pct + 100);
1085	return tmTimerPollReturnMiss(pVM, u64Now, RT_MIN(i64Delta1, i64Delta2), pu64Delta);
1086	}
1087	return tmTimerPollReturnOtherCpu(pVM, u64Now, pu64Delta);
1088	}
1089
1090
1091	/**
1092	* Set FF if we've passed the next virtual event.
1093	*
1094	* This function is called before FFs are checked in the inner execution EM loops.
1095	*
1096	* @returns true if timers are pending, false if not.
1097	*
1098	* @param pVM The cross context VM structure.
1099	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
1100	* @thread The emulation thread.
1101	*/
1102	VMMDECL(bool) TMTimerPollBool(PVMCC pVM, PVMCPUCC pVCpu)
1103	{
1104	AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
1105	uint64_t off = 0;
1106	tmTimerPollInternal(pVM, pVCpu, &off);
1107	return off == 0;
1108	}
1109
1110
1111	/**
1112	* Set FF if we've passed the next virtual event.
1113	*
1114	* This function is called before FFs are checked in the inner execution EM loops.
1115	*
1116	* @param pVM The cross context VM structure.
1117	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
1118	* @thread The emulation thread.
1119	*/
1120	VMM_INT_DECL(void) TMTimerPollVoid(PVMCC pVM, PVMCPUCC pVCpu)
1121	{
1122	uint64_t off;
1123	tmTimerPollInternal(pVM, pVCpu, &off);
1124	}
1125
1126
1127	/**
1128	* Set FF if we've passed the next virtual event.
1129	*
1130	* This function is called before FFs are checked in the inner execution EM loops.
1131	*
1132	* @returns The GIP timestamp of the next event.
1133	* 0 if the next event has already expired.
1134	* @param pVM The cross context VM structure.
1135	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
1136	* @param pu64Delta Where to store the delta.
1137	* @thread The emulation thread.
1138	*/
1139	VMM_INT_DECL(uint64_t) TMTimerPollGIP(PVMCC pVM, PVMCPUCC pVCpu, uint64_t *pu64Delta)
1140	{
1141	return tmTimerPollInternal(pVM, pVCpu, pu64Delta);
1142	}
1143
1144	#endif /* VBOX_HIGH_RES_TIMERS_HACK */
1145
1146	/**
1147	* Locks the timer clock.
1148	*
1149	* @returns VINF_SUCCESS on success, @a rcBusy if busy, and VERR_NOT_SUPPORTED
1150	* if the clock does not have a lock.
1151	* @param pVM The cross context VM structure.
1152	* @param hTimer Timer handle as returned by one of the create functions.
1153	* @param rcBusy What to return in ring-0 and raw-mode context if the
1154	* lock is busy. Pass VINF_SUCCESS to acquired the
1155	* critical section thru a ring-3 call if necessary.
1156	*
1157	* @remarks Currently only supported on timers using the virtual sync clock.
1158	*/
1159	VMMDECL(int) TMTimerLock(PVMCC pVM, TMTIMERHANDLE hTimer, int rcBusy)
1160	{
1161	TMTIMER_HANDLE_TO_VARS_RETURN(pVM, hTimer); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
1162	AssertReturn(idxQueue == TMCLOCK_VIRTUAL_SYNC, VERR_NOT_SUPPORTED);
1163	return PDMCritSectEnter(pVM, &pVM->tm.s.VirtualSyncLock, rcBusy);
1164	}
1165
1166
1167	/**
1168	* Unlocks a timer clock locked by TMTimerLock.
1169	*
1170	* @param pVM The cross context VM structure.
1171	* @param hTimer Timer handle as returned by one of the create functions.
1172	*/
1173	VMMDECL(void) TMTimerUnlock(PVMCC pVM, TMTIMERHANDLE hTimer)
1174	{
1175	TMTIMER_HANDLE_TO_VARS_RETURN_VOID(pVM, hTimer); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
1176	AssertReturnVoid(idxQueue == TMCLOCK_VIRTUAL_SYNC);
1177	PDMCritSectLeave(pVM, &pVM->tm.s.VirtualSyncLock);
1178	}
1179
1180
1181	/**
1182	* Checks if the current thread owns the timer clock lock.
1183	*
1184	* @returns @c true if its the owner, @c false if not.
1185	* @param pVM The cross context VM structure.
1186	* @param hTimer Timer handle as returned by one of the create functions.
1187	*/
1188	VMMDECL(bool) TMTimerIsLockOwner(PVMCC pVM, TMTIMERHANDLE hTimer)
1189	{
1190	TMTIMER_HANDLE_TO_VARS_RETURN_EX(pVM, hTimer, false); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
1191	AssertReturn(idxQueue == TMCLOCK_VIRTUAL_SYNC, false);
1192	return PDMCritSectIsOwner(pVM, &pVM->tm.s.VirtualSyncLock);
1193	}
1194
1195
1196	/**
1197	* Optimized TMTimerSet code path for starting an inactive timer.
1198	*
1199	* @returns VBox status code.
1200	*
1201	* @param pVM The cross context VM structure.
1202	* @param pTimer The timer handle.
1203	* @param u64Expire The new expire time.
1204	* @param pQueue Pointer to the shared timer queue data.
1205	* @param idxQueue The queue index.
1206	*/
1207	static int tmTimerSetOptimizedStart(PVMCC pVM, PTMTIMER pTimer, uint64_t u64Expire, PTMTIMERQUEUE pQueue, uint32_t idxQueue)
1208	{
1209	Assert(pTimer->idxPrev == UINT32_MAX);
1210	Assert(pTimer->idxNext == UINT32_MAX);
1211	Assert(pTimer->enmState == TMTIMERSTATE_ACTIVE);
1212
1213	/*
1214	* Calculate and set the expiration time.
1215	*/
1216	if (idxQueue == TMCLOCK_VIRTUAL_SYNC)
1217	{
1218	uint64_t u64Last = ASMAtomicReadU64(&pVM->tm.s.u64VirtualSync);
1219	AssertMsgStmt(u64Expire >= u64Last,
1220	("exp=%#llx last=%#llx\n", u64Expire, u64Last),
1221	u64Expire = u64Last);
1222	}
1223	ASMAtomicWriteU64(&pTimer->u64Expire, u64Expire);
1224	Log2(("tmTimerSetOptimizedStart: %p:{.pszDesc='%s', .u64Expire=%'RU64}\n", pTimer, pTimer->szName, u64Expire));
1225
1226	/*
1227	* Link the timer into the active list.
1228	*/
1229	tmTimerQueueLinkActive(pVM, TM_GET_TIMER_QUEUE_CC(pVM, idxQueue, pQueue), pQueue, pTimer, u64Expire);
1230
1231	STAM_COUNTER_INC(&pVM->tm.s.StatTimerSetOpt);
1232	return VINF_SUCCESS;
1233	}
1234
1235
1236	/**
1237	* TMTimerSet for the virtual sync timer queue.
1238	*
1239	* This employs a greatly simplified state machine by always acquiring the
1240	* queue lock and bypassing the scheduling list.
1241	*
1242	* @returns VBox status code
1243	* @param pVM The cross context VM structure.
1244	* @param pTimer The timer handle.
1245	* @param u64Expire The expiration time.
1246	*/
1247	static int tmTimerVirtualSyncSet(PVMCC pVM, PTMTIMER pTimer, uint64_t u64Expire)
1248	{
1249	STAM_PROFILE_START(&pVM->tm.s.CTX_SUFF_Z(StatTimerSetVs), a);
1250	VM_ASSERT_EMT(pVM);
1251	TMTIMER_ASSERT_SYNC_CRITSECT_ORDER(pVM, pTimer);
1252	int rc = PDMCritSectEnter(pVM, &pVM->tm.s.VirtualSyncLock, VINF_SUCCESS);
1253	AssertRCReturn(rc, rc);
1254
1255	PTMTIMERQUEUE const pQueue = &pVM->tm.s.aTimerQueues[TMCLOCK_VIRTUAL_SYNC];
1256	PTMTIMERQUEUECC const pQueueCC = TM_GET_TIMER_QUEUE_CC(pVM, TMCLOCK_VIRTUAL_SYNC, pQueue);
1257	TMTIMERSTATE const enmState = pTimer->enmState;
1258	switch (enmState)
1259	{
1260	case TMTIMERSTATE_EXPIRED_DELIVER:
1261	case TMTIMERSTATE_STOPPED:
1262	if (enmState == TMTIMERSTATE_EXPIRED_DELIVER)
1263	STAM_COUNTER_INC(&pVM->tm.s.StatTimerSetVsStExpDeliver);
1264	else
1265	STAM_COUNTER_INC(&pVM->tm.s.StatTimerSetVsStStopped);
1266
1267	AssertMsg(u64Expire >= pVM->tm.s.u64VirtualSync,
1268	("%'RU64 < %'RU64 %s\n", u64Expire, pVM->tm.s.u64VirtualSync, pTimer->szName));
1269	pTimer->u64Expire = u64Expire;
1270	TM_SET_STATE(pTimer, TMTIMERSTATE_ACTIVE);
1271	tmTimerQueueLinkActive(pVM, pQueueCC, pQueue, pTimer, u64Expire);
1272	rc = VINF_SUCCESS;
1273	break;
1274
1275	case TMTIMERSTATE_ACTIVE:
1276	STAM_COUNTER_INC(&pVM->tm.s.StatTimerSetVsStActive);
1277	tmTimerQueueUnlinkActive(pVM, pQueueCC, pQueue, pTimer);
1278	pTimer->u64Expire = u64Expire;
1279	tmTimerQueueLinkActive(pVM, pQueueCC, pQueue, pTimer, u64Expire);
1280	rc = VINF_SUCCESS;
1281	break;
1282
1283	case TMTIMERSTATE_PENDING_RESCHEDULE:
1284	case TMTIMERSTATE_PENDING_STOP:
1285	case TMTIMERSTATE_PENDING_SCHEDULE:
1286	case TMTIMERSTATE_PENDING_STOP_SCHEDULE:
1287	case TMTIMERSTATE_EXPIRED_GET_UNLINK:
1288	case TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE:
1289	case TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE:
1290	case TMTIMERSTATE_DESTROY:
1291	case TMTIMERSTATE_FREE:
1292	AssertLogRelMsgFailed(("Invalid timer state %s: %s\n", tmTimerState(enmState), pTimer->szName));
1293	rc = VERR_TM_INVALID_STATE;
1294	break;
1295
1296	default:
1297	AssertMsgFailed(("Unknown timer state %d: %s\n", enmState, pTimer->szName));
1298	rc = VERR_TM_UNKNOWN_STATE;
1299	break;
1300	}
1301
1302	STAM_PROFILE_STOP(&pVM->tm.s.CTX_SUFF_Z(StatTimerSetVs), a);
1303	PDMCritSectLeave(pVM, &pVM->tm.s.VirtualSyncLock);
1304	return rc;
1305	}
1306
1307
1308	/**
1309	* Arm a timer with a (new) expire time.
1310	*
1311	* @returns VBox status code.
1312	* @param pVM The cross context VM structure.
1313	* @param hTimer Timer handle as returned by one of the create functions.
1314	* @param u64Expire New expire time.
1315	*/
1316	VMMDECL(int) TMTimerSet(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t u64Expire)
1317	{
1318	TMTIMER_HANDLE_TO_VARS_RETURN(pVM, hTimer); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
1319	STAM_COUNTER_INC(&pTimer->StatSetAbsolute);
1320
1321	/* Treat virtual sync timers specially. */
1322	if (idxQueue == TMCLOCK_VIRTUAL_SYNC)
1323	return tmTimerVirtualSyncSet(pVM, pTimer, u64Expire);
1324
1325	STAM_PROFILE_START(&pVM->tm.s.CTX_SUFF_Z(StatTimerSet), a);
1326	TMTIMER_ASSERT_CRITSECT(pVM, pTimer);
1327
1328	DBGFTRACE_U64_TAG2(pVM, u64Expire, "TMTimerSet", pTimer->szName);
1329
1330	#ifdef VBOX_WITH_STATISTICS
1331	/*
1332	* Gather optimization info.
1333	*/
1334	STAM_COUNTER_INC(&pVM->tm.s.StatTimerSet);
1335	TMTIMERSTATE enmOrgState = pTimer->enmState;
1336	switch (enmOrgState)
1337	{
1338	case TMTIMERSTATE_STOPPED: STAM_COUNTER_INC(&pVM->tm.s.StatTimerSetStStopped); break;
1339	case TMTIMERSTATE_EXPIRED_DELIVER: STAM_COUNTER_INC(&pVM->tm.s.StatTimerSetStExpDeliver); break;
1340	case TMTIMERSTATE_ACTIVE: STAM_COUNTER_INC(&pVM->tm.s.StatTimerSetStActive); break;
1341	case TMTIMERSTATE_PENDING_STOP: STAM_COUNTER_INC(&pVM->tm.s.StatTimerSetStPendStop); break;
1342	case TMTIMERSTATE_PENDING_STOP_SCHEDULE: STAM_COUNTER_INC(&pVM->tm.s.StatTimerSetStPendStopSched); break;
1343	case TMTIMERSTATE_PENDING_SCHEDULE: STAM_COUNTER_INC(&pVM->tm.s.StatTimerSetStPendSched); break;
1344	case TMTIMERSTATE_PENDING_RESCHEDULE: STAM_COUNTER_INC(&pVM->tm.s.StatTimerSetStPendResched); break;
1345	default: STAM_COUNTER_INC(&pVM->tm.s.StatTimerSetStOther); break;
1346	}
1347	#endif
1348
1349	#if 1
1350	/*
1351	* The most common case is setting the timer again during the callback.
1352	* The second most common case is starting a timer at some other time.
1353	*/
1354	TMTIMERSTATE enmState1 = pTimer->enmState;
1355	if ( enmState1 == TMTIMERSTATE_EXPIRED_DELIVER
1356	\|\| ( enmState1 == TMTIMERSTATE_STOPPED
1357	&& pTimer->pCritSect))
1358	{
1359	/* Try take the TM lock and check the state again. */
1360	int rc = PDMCritSectTryEnter(pVM, &pQueue->TimerLock);
1361	if (RT_SUCCESS_NP(rc))
1362	{
1363	if (RT_LIKELY(tmTimerTry(pTimer, TMTIMERSTATE_ACTIVE, enmState1)))
1364	{
1365	tmTimerSetOptimizedStart(pVM, pTimer, u64Expire, pQueue, idxQueue);
1366	STAM_PROFILE_STOP(&pVM->tm.s.CTX_SUFF_Z(StatTimerSet), a);
1367	PDMCritSectLeave(pVM, &pQueue->TimerLock);
1368	return VINF_SUCCESS;
1369	}
1370	PDMCritSectLeave(pVM, &pQueue->TimerLock);
1371	}
1372	}
1373	#endif
1374
1375	/*
1376	* Unoptimized code path.
1377	*/
1378	int cRetries = 1000;
1379	do
1380	{
1381	/*
1382	* Change to any of the SET_EXPIRE states if valid and then to SCHEDULE or RESCHEDULE.
1383	*/
1384	TMTIMERSTATE enmState = pTimer->enmState;
1385	Log2(("TMTimerSet: %p:{.enmState=%s, .pszDesc='%s'} cRetries=%d u64Expire=%'RU64\n",
1386	pTimer, tmTimerState(enmState), pTimer->szName, cRetries, u64Expire));
1387	switch (enmState)
1388	{
1389	case TMTIMERSTATE_EXPIRED_DELIVER:
1390	case TMTIMERSTATE_STOPPED:
1391	if (tmTimerTryWithLink(pQueueCC, pQueue, pTimer, TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE, enmState))
1392	{
1393	Assert(pTimer->idxPrev == UINT32_MAX);
1394	Assert(pTimer->idxNext == UINT32_MAX);
1395	pTimer->u64Expire = u64Expire;
1396	TM_SET_STATE(pTimer, TMTIMERSTATE_PENDING_SCHEDULE);
1397	tmSchedule(pVM, pQueueCC, pQueue, pTimer);
1398	STAM_PROFILE_STOP(&pVM->tm.s.CTX_SUFF_Z(StatTimerSet), a);
1399	return VINF_SUCCESS;
1400	}
1401	break;
1402
1403	case TMTIMERSTATE_PENDING_SCHEDULE:
1404	case TMTIMERSTATE_PENDING_STOP_SCHEDULE:
1405	if (tmTimerTry(pTimer, TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE, enmState))
1406	{
1407	pTimer->u64Expire = u64Expire;
1408	TM_SET_STATE(pTimer, TMTIMERSTATE_PENDING_SCHEDULE);
1409	tmSchedule(pVM, pQueueCC, pQueue, pTimer);
1410	STAM_PROFILE_STOP(&pVM->tm.s.CTX_SUFF_Z(StatTimerSet), a);
1411	return VINF_SUCCESS;
1412	}
1413	break;
1414
1415
1416	case TMTIMERSTATE_ACTIVE:
1417	if (tmTimerTryWithLink(pQueueCC, pQueue, pTimer, TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE, enmState))
1418	{
1419	pTimer->u64Expire = u64Expire;
1420	TM_SET_STATE(pTimer, TMTIMERSTATE_PENDING_RESCHEDULE);
1421	tmSchedule(pVM, pQueueCC, pQueue, pTimer);
1422	STAM_PROFILE_STOP(&pVM->tm.s.CTX_SUFF_Z(StatTimerSet), a);
1423	return VINF_SUCCESS;
1424	}
1425	break;
1426
1427	case TMTIMERSTATE_PENDING_RESCHEDULE:
1428	case TMTIMERSTATE_PENDING_STOP:
1429	if (tmTimerTry(pTimer, TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE, enmState))
1430	{
1431	pTimer->u64Expire = u64Expire;
1432	TM_SET_STATE(pTimer, TMTIMERSTATE_PENDING_RESCHEDULE);
1433	tmSchedule(pVM, pQueueCC, pQueue, pTimer);
1434	STAM_PROFILE_STOP(&pVM->tm.s.CTX_SUFF_Z(StatTimerSet), a);
1435	return VINF_SUCCESS;
1436	}
1437	break;
1438
1439
1440	case TMTIMERSTATE_EXPIRED_GET_UNLINK:
1441	case TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE:
1442	case TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE:
1443	#ifdef IN_RING3
1444	if (!RTThreadYield())
1445	RTThreadSleep(1);
1446	#else
1447	/** @todo call host context and yield after a couple of iterations */
1448	#endif
1449	break;
1450
1451	/*
1452	* Invalid states.
1453	*/
1454	case TMTIMERSTATE_DESTROY:
1455	case TMTIMERSTATE_FREE:
1456	AssertMsgFailed(("Invalid timer state %d (%s)\n", enmState, pTimer->szName));
1457	return VERR_TM_INVALID_STATE;
1458	default:
1459	AssertMsgFailed(("Unknown timer state %d (%s)\n", enmState, pTimer->szName));
1460	return VERR_TM_UNKNOWN_STATE;
1461	}
1462	} while (cRetries-- > 0);
1463
1464	AssertMsgFailed(("Failed waiting for stable state. state=%d (%s)\n", pTimer->enmState, pTimer->szName));
1465	STAM_PROFILE_STOP(&pVM->tm.s.CTX_SUFF_Z(StatTimerSet), a);
1466	return VERR_TM_TIMER_UNSTABLE_STATE;
1467	}
1468
1469
1470	/**
1471	* Return the current time for the specified clock, setting pu64Now if not NULL.
1472	*
1473	* @returns Current time.
1474	* @param pVM The cross context VM structure.
1475	* @param enmClock The clock to query.
1476	* @param pu64Now Optional pointer where to store the return time
1477	*/
1478	DECL_FORCE_INLINE(uint64_t) tmTimerSetRelativeNowWorker(PVMCC pVM, TMCLOCK enmClock, uint64_t *pu64Now)
1479	{
1480	uint64_t u64Now;
1481	switch (enmClock)
1482	{
1483	case TMCLOCK_VIRTUAL_SYNC:
1484	u64Now = TMVirtualSyncGet(pVM);
1485	break;
1486	case TMCLOCK_VIRTUAL:
1487	u64Now = TMVirtualGet(pVM);
1488	break;
1489	case TMCLOCK_REAL:
1490	u64Now = TMRealGet(pVM);
1491	break;
1492	default:
1493	AssertFatalMsgFailed(("%d\n", enmClock));
1494	}
1495
1496	if (pu64Now)
1497	*pu64Now = u64Now;
1498	return u64Now;
1499	}
1500
1501
1502	/**
1503	* Optimized TMTimerSetRelative code path.
1504	*
1505	* @returns VBox status code.
1506	*
1507	* @param pVM The cross context VM structure.
1508	* @param pTimer The timer handle.
1509	* @param cTicksToNext Clock ticks until the next time expiration.
1510	* @param pu64Now Where to return the current time stamp used.
1511	* Optional.
1512	* @param pQueueCC The context specific queue data (same as @a pQueue
1513	* for ring-3).
1514	* @param pQueue The shared queue data.
1515	*/
1516	static int tmTimerSetRelativeOptimizedStart(PVMCC pVM, PTMTIMER pTimer, uint64_t cTicksToNext, uint64_t *pu64Now,
1517	PTMTIMERQUEUECC pQueueCC, PTMTIMERQUEUE pQueue)
1518	{
1519	Assert(pTimer->idxPrev == UINT32_MAX);
1520	Assert(pTimer->idxNext == UINT32_MAX);
1521	Assert(pTimer->enmState == TMTIMERSTATE_ACTIVE);
1522
1523	/*
1524	* Calculate and set the expiration time.
1525	*/
1526	uint64_t const u64Expire = cTicksToNext + tmTimerSetRelativeNowWorker(pVM, pQueue->enmClock, pu64Now);
1527	pTimer->u64Expire = u64Expire;
1528	Log2(("tmTimerSetRelativeOptimizedStart: %p:{.pszDesc='%s', .u64Expire=%'RU64} cTicksToNext=%'RU64\n", pTimer, pTimer->szName, u64Expire, cTicksToNext));
1529
1530	/*
1531	* Link the timer into the active list.
1532	*/
1533	DBGFTRACE_U64_TAG2(pVM, u64Expire, "tmTimerSetRelativeOptimizedStart", pTimer->szName);
1534	tmTimerQueueLinkActive(pVM, pQueueCC, pQueue, pTimer, u64Expire);
1535
1536	STAM_COUNTER_INC(&pVM->tm.s.StatTimerSetRelativeOpt);
1537	return VINF_SUCCESS;
1538	}
1539
1540
1541	/**
1542	* TMTimerSetRelative for the virtual sync timer queue.
1543	*
1544	* This employs a greatly simplified state machine by always acquiring the
1545	* queue lock and bypassing the scheduling list.
1546	*
1547	* @returns VBox status code
1548	* @param pVM The cross context VM structure.
1549	* @param pTimer The timer to (re-)arm.
1550	* @param cTicksToNext Clock ticks until the next time expiration.
1551	* @param pu64Now Where to return the current time stamp used.
1552	* Optional.
1553	*/
1554	static int tmTimerVirtualSyncSetRelative(PVMCC pVM, PTMTIMER pTimer, uint64_t cTicksToNext, uint64_t *pu64Now)
1555	{
1556	STAM_PROFILE_START(pVM->tm.s.CTX_SUFF_Z(StatTimerSetRelativeVs), a);
1557	VM_ASSERT_EMT(pVM);
1558	TMTIMER_ASSERT_SYNC_CRITSECT_ORDER(pVM, pTimer);
1559	int rc = PDMCritSectEnter(pVM, &pVM->tm.s.VirtualSyncLock, VINF_SUCCESS);
1560	AssertRCReturn(rc, rc);
1561
1562	/* Calculate the expiration tick. */
1563	uint64_t u64Expire = TMVirtualSyncGetNoCheck(pVM);
1564	if (pu64Now)
1565	*pu64Now = u64Expire;
1566	u64Expire += cTicksToNext;
1567
1568	/* Update the timer. */
1569	PTMTIMERQUEUE const pQueue = &pVM->tm.s.aTimerQueues[TMCLOCK_VIRTUAL_SYNC];
1570	PTMTIMERQUEUECC const pQueueCC = TM_GET_TIMER_QUEUE_CC(pVM, TMCLOCK_VIRTUAL_SYNC, pQueue);
1571	TMTIMERSTATE const enmState = pTimer->enmState;
1572	switch (enmState)
1573	{
1574	case TMTIMERSTATE_EXPIRED_DELIVER:
1575	case TMTIMERSTATE_STOPPED:
1576	if (enmState == TMTIMERSTATE_EXPIRED_DELIVER)
1577	STAM_COUNTER_INC(&pVM->tm.s.StatTimerSetRelativeVsStExpDeliver);
1578	else
1579	STAM_COUNTER_INC(&pVM->tm.s.StatTimerSetRelativeVsStStopped);
1580	pTimer->u64Expire = u64Expire;
1581	TM_SET_STATE(pTimer, TMTIMERSTATE_ACTIVE);
1582	tmTimerQueueLinkActive(pVM, pQueueCC, pQueue, pTimer, u64Expire);
1583	rc = VINF_SUCCESS;
1584	break;
1585
1586	case TMTIMERSTATE_ACTIVE:
1587	STAM_COUNTER_INC(&pVM->tm.s.StatTimerSetRelativeVsStActive);
1588	tmTimerQueueUnlinkActive(pVM, pQueueCC, pQueue, pTimer);
1589	pTimer->u64Expire = u64Expire;
1590	tmTimerQueueLinkActive(pVM, pQueueCC, pQueue, pTimer, u64Expire);
1591	rc = VINF_SUCCESS;
1592	break;
1593
1594	case TMTIMERSTATE_PENDING_RESCHEDULE:
1595	case TMTIMERSTATE_PENDING_STOP:
1596	case TMTIMERSTATE_PENDING_SCHEDULE:
1597	case TMTIMERSTATE_PENDING_STOP_SCHEDULE:
1598	case TMTIMERSTATE_EXPIRED_GET_UNLINK:
1599	case TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE:
1600	case TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE:
1601	case TMTIMERSTATE_DESTROY:
1602	case TMTIMERSTATE_FREE:
1603	AssertLogRelMsgFailed(("Invalid timer state %s: %s\n", tmTimerState(enmState), pTimer->szName));
1604	rc = VERR_TM_INVALID_STATE;
1605	break;
1606
1607	default:
1608	AssertMsgFailed(("Unknown timer state %d: %s\n", enmState, pTimer->szName));
1609	rc = VERR_TM_UNKNOWN_STATE;
1610	break;
1611	}
1612
1613	STAM_PROFILE_STOP(&pVM->tm.s.CTX_SUFF_Z(StatTimerSetRelativeVs), a);
1614	PDMCritSectLeave(pVM, &pVM->tm.s.VirtualSyncLock);
1615	return rc;
1616	}
1617
1618
1619	/**
1620	* Arm a timer with a expire time relative to the current time.
1621	*
1622	* @returns VBox status code.
1623	* @param pVM The cross context VM structure.
1624	* @param pTimer The timer to arm.
1625	* @param cTicksToNext Clock ticks until the next time expiration.
1626	* @param pu64Now Where to return the current time stamp used.
1627	* Optional.
1628	* @param pQueueCC The context specific queue data (same as @a pQueue
1629	* for ring-3).
1630	* @param pQueue The shared queue data.
1631	*/
1632	static int tmTimerSetRelative(PVMCC pVM, PTMTIMER pTimer, uint64_t cTicksToNext, uint64_t *pu64Now,
1633	PTMTIMERQUEUECC pQueueCC, PTMTIMERQUEUE pQueue)
1634	{
1635	STAM_COUNTER_INC(&pTimer->StatSetRelative);
1636
1637	/* Treat virtual sync timers specially. */
1638	if (pQueue->enmClock == TMCLOCK_VIRTUAL_SYNC)
1639	return tmTimerVirtualSyncSetRelative(pVM, pTimer, cTicksToNext, pu64Now);
1640
1641	STAM_PROFILE_START(&pVM->tm.s.CTX_SUFF_Z(StatTimerSetRelative), a);
1642	TMTIMER_ASSERT_CRITSECT(pVM, pTimer);
1643
1644	DBGFTRACE_U64_TAG2(pVM, cTicksToNext, "TMTimerSetRelative", pTimer->szName);
1645
1646	#ifdef VBOX_WITH_STATISTICS
1647	/*
1648	* Gather optimization info.
1649	*/
1650	STAM_COUNTER_INC(&pVM->tm.s.StatTimerSetRelative);
1651	TMTIMERSTATE enmOrgState = pTimer->enmState;
1652	switch (enmOrgState)
1653	{
1654	case TMTIMERSTATE_STOPPED: STAM_COUNTER_INC(&pVM->tm.s.StatTimerSetRelativeStStopped); break;
1655	case TMTIMERSTATE_EXPIRED_DELIVER: STAM_COUNTER_INC(&pVM->tm.s.StatTimerSetRelativeStExpDeliver); break;
1656	case TMTIMERSTATE_ACTIVE: STAM_COUNTER_INC(&pVM->tm.s.StatTimerSetRelativeStActive); break;
1657	case TMTIMERSTATE_PENDING_STOP: STAM_COUNTER_INC(&pVM->tm.s.StatTimerSetRelativeStPendStop); break;
1658	case TMTIMERSTATE_PENDING_STOP_SCHEDULE: STAM_COUNTER_INC(&pVM->tm.s.StatTimerSetRelativeStPendStopSched); break;
1659	case TMTIMERSTATE_PENDING_SCHEDULE: STAM_COUNTER_INC(&pVM->tm.s.StatTimerSetRelativeStPendSched); break;
1660	case TMTIMERSTATE_PENDING_RESCHEDULE: STAM_COUNTER_INC(&pVM->tm.s.StatTimerSetRelativeStPendResched); break;
1661	default: STAM_COUNTER_INC(&pVM->tm.s.StatTimerSetRelativeStOther); break;
1662	}
1663	#endif
1664
1665	/*
1666	* Try to take the TM lock and optimize the common cases.
1667	*
1668	* With the TM lock we can safely make optimizations like immediate
1669	* scheduling and we can also be 100% sure that we're not racing the
1670	* running of the timer queues. As an additional restraint we require the
1671	* timer to have a critical section associated with to be 100% there aren't
1672	* concurrent operations on the timer. (This latter isn't necessary any
1673	* longer as this isn't supported for any timers, critsect or not.)
1674	*
1675	* Note! Lock ordering doesn't apply when we only _try_ to
1676	* get the innermost locks.
1677	*/
1678	bool fOwnTMLock = RT_SUCCESS_NP(PDMCritSectTryEnter(pVM, &pQueue->TimerLock));
1679	#if 1
1680	if ( fOwnTMLock
1681	&& pTimer->pCritSect)
1682	{
1683	TMTIMERSTATE enmState = pTimer->enmState;
1684	if (RT_LIKELY( ( enmState == TMTIMERSTATE_EXPIRED_DELIVER
1685	\|\| enmState == TMTIMERSTATE_STOPPED)
1686	&& tmTimerTry(pTimer, TMTIMERSTATE_ACTIVE, enmState)))
1687	{
1688	tmTimerSetRelativeOptimizedStart(pVM, pTimer, cTicksToNext, pu64Now, pQueueCC, pQueue);
1689	STAM_PROFILE_STOP(&pVM->tm.s.CTX_SUFF_Z(StatTimerSetRelative), a);
1690	PDMCritSectLeave(pVM, &pQueue->TimerLock);
1691	return VINF_SUCCESS;
1692	}
1693
1694	/* Optimize other states when it becomes necessary. */
1695	}
1696	#endif
1697
1698	/*
1699	* Unoptimized path.
1700	*/
1701	int rc;
1702	for (int cRetries = 1000; ; cRetries--)
1703	{
1704	/*
1705	* Change to any of the SET_EXPIRE states if valid and then to SCHEDULE or RESCHEDULE.
1706	*/
1707	TMTIMERSTATE enmState = pTimer->enmState;
1708	switch (enmState)
1709	{
1710	case TMTIMERSTATE_STOPPED:
1711	if (pQueue->enmClock == TMCLOCK_VIRTUAL_SYNC)
1712	{
1713	/** @todo To fix assertion in tmR3TimerQueueRunVirtualSync:
1714	* Figure a safe way of activating this timer while the queue is
1715	* being run.
1716	* (99.9% sure this that the assertion is caused by DevAPIC.cpp
1717	* re-starting the timer in response to a initial_count write.) */
1718	}
1719	RT_FALL_THRU();
1720	case TMTIMERSTATE_EXPIRED_DELIVER:
1721	if (tmTimerTryWithLink(pQueueCC, pQueue, pTimer, TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE, enmState))
1722	{
1723	Assert(pTimer->idxPrev == UINT32_MAX);
1724	Assert(pTimer->idxNext == UINT32_MAX);
1725	pTimer->u64Expire = cTicksToNext + tmTimerSetRelativeNowWorker(pVM, pQueue->enmClock, pu64Now);
1726	Log2(("TMTimerSetRelative: %p:{.enmState=%s, .pszDesc='%s', .u64Expire=%'RU64} cRetries=%d [EXP/STOP]\n",
1727	pTimer, tmTimerState(enmState), pTimer->szName, pTimer->u64Expire, cRetries));
1728	TM_SET_STATE(pTimer, TMTIMERSTATE_PENDING_SCHEDULE);
1729	tmSchedule(pVM, pQueueCC, pQueue, pTimer);
1730	rc = VINF_SUCCESS;
1731	break;
1732	}
1733	rc = VERR_TRY_AGAIN;
1734	break;
1735
1736	case TMTIMERSTATE_PENDING_SCHEDULE:
1737	case TMTIMERSTATE_PENDING_STOP_SCHEDULE:
1738	if (tmTimerTry(pTimer, TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE, enmState))
1739	{
1740	pTimer->u64Expire = cTicksToNext + tmTimerSetRelativeNowWorker(pVM, pQueue->enmClock, pu64Now);
1741	Log2(("TMTimerSetRelative: %p:{.enmState=%s, .pszDesc='%s', .u64Expire=%'RU64} cRetries=%d [PEND_SCHED]\n",
1742	pTimer, tmTimerState(enmState), pTimer->szName, pTimer->u64Expire, cRetries));
1743	TM_SET_STATE(pTimer, TMTIMERSTATE_PENDING_SCHEDULE);
1744	tmSchedule(pVM, pQueueCC, pQueue, pTimer);
1745	rc = VINF_SUCCESS;
1746	break;
1747	}
1748	rc = VERR_TRY_AGAIN;
1749	break;
1750
1751
1752	case TMTIMERSTATE_ACTIVE:
1753	if (tmTimerTryWithLink(pQueueCC, pQueue, pTimer, TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE, enmState))
1754	{
1755	pTimer->u64Expire = cTicksToNext + tmTimerSetRelativeNowWorker(pVM, pQueue->enmClock, pu64Now);
1756	Log2(("TMTimerSetRelative: %p:{.enmState=%s, .pszDesc='%s', .u64Expire=%'RU64} cRetries=%d [ACTIVE]\n",
1757	pTimer, tmTimerState(enmState), pTimer->szName, pTimer->u64Expire, cRetries));
1758	TM_SET_STATE(pTimer, TMTIMERSTATE_PENDING_RESCHEDULE);
1759	tmSchedule(pVM, pQueueCC, pQueue, pTimer);
1760	rc = VINF_SUCCESS;
1761	break;
1762	}
1763	rc = VERR_TRY_AGAIN;
1764	break;
1765
1766	case TMTIMERSTATE_PENDING_RESCHEDULE:
1767	case TMTIMERSTATE_PENDING_STOP:
1768	if (tmTimerTry(pTimer, TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE, enmState))
1769	{
1770	pTimer->u64Expire = cTicksToNext + tmTimerSetRelativeNowWorker(pVM, pQueue->enmClock, pu64Now);
1771	Log2(("TMTimerSetRelative: %p:{.enmState=%s, .pszDesc='%s', .u64Expire=%'RU64} cRetries=%d [PEND_RESCH/STOP]\n",
1772	pTimer, tmTimerState(enmState), pTimer->szName, pTimer->u64Expire, cRetries));
1773	TM_SET_STATE(pTimer, TMTIMERSTATE_PENDING_RESCHEDULE);
1774	tmSchedule(pVM, pQueueCC, pQueue, pTimer);
1775	rc = VINF_SUCCESS;
1776	break;
1777	}
1778	rc = VERR_TRY_AGAIN;
1779	break;
1780
1781
1782	case TMTIMERSTATE_EXPIRED_GET_UNLINK:
1783	case TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE:
1784	case TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE:
1785	#ifdef IN_RING3
1786	if (!RTThreadYield())
1787	RTThreadSleep(1);
1788	#else
1789	/** @todo call host context and yield after a couple of iterations */
1790	#endif
1791	rc = VERR_TRY_AGAIN;
1792	break;
1793
1794	/*
1795	* Invalid states.
1796	*/
1797	case TMTIMERSTATE_DESTROY:
1798	case TMTIMERSTATE_FREE:
1799	AssertMsgFailed(("Invalid timer state %d (%s)\n", enmState, pTimer->szName));
1800	rc = VERR_TM_INVALID_STATE;
1801	break;
1802
1803	default:
1804	AssertMsgFailed(("Unknown timer state %d (%s)\n", enmState, pTimer->szName));
1805	rc = VERR_TM_UNKNOWN_STATE;
1806	break;
1807	}
1808
1809	/* switch + loop is tedious to break out of. */
1810	if (rc == VINF_SUCCESS)
1811	break;
1812
1813	if (rc != VERR_TRY_AGAIN)
1814	{
1815	tmTimerSetRelativeNowWorker(pVM, pQueue->enmClock, pu64Now);
1816	break;
1817	}
1818	if (cRetries <= 0)
1819	{
1820	AssertMsgFailed(("Failed waiting for stable state. state=%d (%s)\n", pTimer->enmState, pTimer->szName));
1821	rc = VERR_TM_TIMER_UNSTABLE_STATE;
1822	tmTimerSetRelativeNowWorker(pVM, pQueue->enmClock, pu64Now);
1823	break;
1824	}
1825
1826	/*
1827	* Retry to gain locks.
1828	*/
1829	if (!fOwnTMLock)
1830	fOwnTMLock = RT_SUCCESS_NP(PDMCritSectTryEnter(pVM, &pQueue->TimerLock));
1831
1832	} /* for (;;) */
1833
1834	/*
1835	* Clean up and return.
1836	*/
1837	if (fOwnTMLock)
1838	PDMCritSectLeave(pVM, &pQueue->TimerLock);
1839
1840	STAM_PROFILE_STOP(&pVM->tm.s.CTX_SUFF_Z(StatTimerSetRelative), a);
1841	return rc;
1842	}
1843
1844
1845	/**
1846	* Arm a timer with a expire time relative to the current time.
1847	*
1848	* @returns VBox status code.
1849	* @param pVM The cross context VM structure.
1850	* @param hTimer Timer handle as returned by one of the create functions.
1851	* @param cTicksToNext Clock ticks until the next time expiration.
1852	* @param pu64Now Where to return the current time stamp used.
1853	* Optional.
1854	*/
1855	VMMDECL(int) TMTimerSetRelative(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cTicksToNext, uint64_t *pu64Now)
1856	{
1857	TMTIMER_HANDLE_TO_VARS_RETURN(pVM, hTimer); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
1858	return tmTimerSetRelative(pVM, pTimer, cTicksToNext, pu64Now, pQueueCC, pQueue);
1859	}
1860
1861
1862	/**
1863	* Drops a hint about the frequency of the timer.
1864	*
1865	* This is used by TM and the VMM to calculate how often guest execution needs
1866	* to be interrupted. The hint is automatically cleared by TMTimerStop.
1867	*
1868	* @returns VBox status code.
1869	* @param pVM The cross context VM structure.
1870	* @param hTimer Timer handle as returned by one of the create functions.
1871	* @param uHzHint The frequency hint. Pass 0 to clear the hint.
1872	*
1873	* @remarks We're using an integer hertz value here since anything above 1 HZ
1874	* is not going to be any trouble satisfying scheduling wise. The
1875	* range where it makes sense is >= 100 HZ.
1876	*/
1877	VMMDECL(int) TMTimerSetFrequencyHint(PVMCC pVM, TMTIMERHANDLE hTimer, uint32_t uHzHint)
1878	{
1879	TMTIMER_HANDLE_TO_VARS_RETURN(pVM, hTimer); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
1880	TMTIMER_ASSERT_CRITSECT(pVM, pTimer);
1881
1882	uint32_t const uHzOldHint = pTimer->uHzHint;
1883	pTimer->uHzHint = uHzHint;
1884
1885	uint32_t const uMaxHzHint = pQueue->uMaxHzHint;
1886	if ( uHzHint > uMaxHzHint
1887	\|\| uHzOldHint >= uMaxHzHint)
1888	ASMAtomicOrU64(&pVM->tm.s.HzHint.u64Combined, RT_BIT_32(idxQueue) \| RT_BIT_32(idxQueue + 16));
1889
1890	return VINF_SUCCESS;
1891	}
1892
1893
1894	/**
1895	* TMTimerStop for the virtual sync timer queue.
1896	*
1897	* This employs a greatly simplified state machine by always acquiring the
1898	* queue lock and bypassing the scheduling list.
1899	*
1900	* @returns VBox status code
1901	* @param pVM The cross context VM structure.
1902	* @param pTimer The timer handle.
1903	*/
1904	static int tmTimerVirtualSyncStop(PVMCC pVM, PTMTIMER pTimer)
1905	{
1906	STAM_PROFILE_START(&pVM->tm.s.CTX_SUFF_Z(StatTimerStopVs), a);
1907	VM_ASSERT_EMT(pVM);
1908	TMTIMER_ASSERT_SYNC_CRITSECT_ORDER(pVM, pTimer);
1909	int rc = PDMCritSectEnter(pVM, &pVM->tm.s.VirtualSyncLock, VINF_SUCCESS);
1910	AssertRCReturn(rc, rc);
1911
1912	/* Reset the HZ hint. */
1913	uint32_t uOldHzHint = pTimer->uHzHint;
1914	if (uOldHzHint)
1915	{
1916	if (uOldHzHint >= pVM->tm.s.aTimerQueues[TMCLOCK_VIRTUAL_SYNC].uMaxHzHint)
1917	ASMAtomicOrU64(&pVM->tm.s.HzHint.u64Combined, RT_BIT_32(TMCLOCK_VIRTUAL_SYNC) \| RT_BIT_32(TMCLOCK_VIRTUAL_SYNC + 16));
1918	pTimer->uHzHint = 0;
1919	}
1920
1921	/* Update the timer state. */
1922	TMTIMERSTATE const enmState = pTimer->enmState;
1923	switch (enmState)
1924	{
1925	case TMTIMERSTATE_ACTIVE:
1926	{
1927	PTMTIMERQUEUE const pQueue = &pVM->tm.s.aTimerQueues[TMCLOCK_VIRTUAL_SYNC];
1928	tmTimerQueueUnlinkActive(pVM, TM_GET_TIMER_QUEUE_CC(pVM, TMCLOCK_VIRTUAL_SYNC, pQueue), pQueue, pTimer);
1929	TM_SET_STATE(pTimer, TMTIMERSTATE_STOPPED);
1930	rc = VINF_SUCCESS;
1931	break;
1932	}
1933
1934	case TMTIMERSTATE_EXPIRED_DELIVER:
1935	TM_SET_STATE(pTimer, TMTIMERSTATE_STOPPED);
1936	rc = VINF_SUCCESS;
1937	break;
1938
1939	case TMTIMERSTATE_STOPPED:
1940	rc = VINF_SUCCESS;
1941	break;
1942
1943	case TMTIMERSTATE_PENDING_RESCHEDULE:
1944	case TMTIMERSTATE_PENDING_STOP:
1945	case TMTIMERSTATE_PENDING_SCHEDULE:
1946	case TMTIMERSTATE_PENDING_STOP_SCHEDULE:
1947	case TMTIMERSTATE_EXPIRED_GET_UNLINK:
1948	case TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE:
1949	case TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE:
1950	case TMTIMERSTATE_DESTROY:
1951	case TMTIMERSTATE_FREE:
1952	AssertLogRelMsgFailed(("Invalid timer state %s: %s\n", tmTimerState(enmState), pTimer->szName));
1953	rc = VERR_TM_INVALID_STATE;
1954	break;
1955
1956	default:
1957	AssertMsgFailed(("Unknown timer state %d: %s\n", enmState, pTimer->szName));
1958	rc = VERR_TM_UNKNOWN_STATE;
1959	break;
1960	}
1961
1962	STAM_PROFILE_STOP(&pVM->tm.s.CTX_SUFF_Z(StatTimerStopVs), a);
1963	PDMCritSectLeave(pVM, &pVM->tm.s.VirtualSyncLock);
1964	return rc;
1965	}
1966
1967
1968	/**
1969	* Stop the timer.
1970	* Use TMR3TimerArm() to "un-stop" the timer.
1971	*
1972	* @returns VBox status code.
1973	* @param pVM The cross context VM structure.
1974	* @param hTimer Timer handle as returned by one of the create functions.
1975	*/
1976	VMMDECL(int) TMTimerStop(PVMCC pVM, TMTIMERHANDLE hTimer)
1977	{
1978	TMTIMER_HANDLE_TO_VARS_RETURN(pVM, hTimer); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
1979	STAM_COUNTER_INC(&pTimer->StatStop);
1980
1981	/* Treat virtual sync timers specially. */
1982	if (idxQueue == TMCLOCK_VIRTUAL_SYNC)
1983	return tmTimerVirtualSyncStop(pVM, pTimer);
1984
1985	STAM_PROFILE_START(&pVM->tm.s.CTX_SUFF_Z(StatTimerStop), a);
1986	TMTIMER_ASSERT_CRITSECT(pVM, pTimer);
1987
1988	/*
1989	* Reset the HZ hint.
1990	*/
1991	uint32_t const uOldHzHint = pTimer->uHzHint;
1992	if (uOldHzHint)
1993	{
1994	if (uOldHzHint >= pQueue->uMaxHzHint)
1995	ASMAtomicOrU64(&pVM->tm.s.HzHint.u64Combined, RT_BIT_32(idxQueue) \| RT_BIT_32(idxQueue + 16));
1996	pTimer->uHzHint = 0;
1997	}
1998
1999	/** @todo see if this function needs optimizing. */
2000	int cRetries = 1000;
2001	do
2002	{
2003	/*
2004	* Change to any of the SET_EXPIRE states if valid and then to SCHEDULE or RESCHEDULE.
2005	*/
2006	TMTIMERSTATE enmState = pTimer->enmState;
2007	Log2(("TMTimerStop: %p:{.enmState=%s, .pszDesc='%s'} cRetries=%d\n",
2008	pTimer, tmTimerState(enmState), pTimer->szName, cRetries));
2009	switch (enmState)
2010	{
2011	case TMTIMERSTATE_EXPIRED_DELIVER:
2012	//AssertMsgFailed(("You don't stop an expired timer dude!\n"));
2013	return VERR_INVALID_PARAMETER;
2014
2015	case TMTIMERSTATE_STOPPED:
2016	case TMTIMERSTATE_PENDING_STOP:
2017	case TMTIMERSTATE_PENDING_STOP_SCHEDULE:
2018	STAM_PROFILE_STOP(&pVM->tm.s.CTX_SUFF_Z(StatTimerStop), a);
2019	return VINF_SUCCESS;
2020
2021	case TMTIMERSTATE_PENDING_SCHEDULE:
2022	if (tmTimerTry(pTimer, TMTIMERSTATE_PENDING_STOP_SCHEDULE, enmState))
2023	{
2024	tmSchedule(pVM, pQueueCC, pQueue, pTimer);
2025	STAM_PROFILE_STOP(&pVM->tm.s.CTX_SUFF_Z(StatTimerStop), a);
2026	return VINF_SUCCESS;
2027	}
2028	break;
2029
2030	case TMTIMERSTATE_PENDING_RESCHEDULE:
2031	if (tmTimerTry(pTimer, TMTIMERSTATE_PENDING_STOP, enmState))
2032	{
2033	tmSchedule(pVM, pQueueCC, pQueue, pTimer);
2034	STAM_PROFILE_STOP(&pVM->tm.s.CTX_SUFF_Z(StatTimerStop), a);
2035	return VINF_SUCCESS;
2036	}
2037	break;
2038
2039	case TMTIMERSTATE_ACTIVE:
2040	if (tmTimerTryWithLink(pQueueCC, pQueue, pTimer, TMTIMERSTATE_PENDING_STOP, enmState))
2041	{
2042	tmSchedule(pVM, pQueueCC, pQueue, pTimer);
2043	STAM_PROFILE_STOP(&pVM->tm.s.CTX_SUFF_Z(StatTimerStop), a);
2044	return VINF_SUCCESS;
2045	}
2046	break;
2047
2048	case TMTIMERSTATE_EXPIRED_GET_UNLINK:
2049	case TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE:
2050	case TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE:
2051	#ifdef IN_RING3
2052	if (!RTThreadYield())
2053	RTThreadSleep(1);
2054	#else
2055	/** @todo call host and yield cpu after a while. */
2056	#endif
2057	break;
2058
2059	/*
2060	* Invalid states.
2061	*/
2062	case TMTIMERSTATE_DESTROY:
2063	case TMTIMERSTATE_FREE:
2064	AssertMsgFailed(("Invalid timer state %d (%s)\n", enmState, pTimer->szName));
2065	return VERR_TM_INVALID_STATE;
2066	default:
2067	AssertMsgFailed(("Unknown timer state %d (%s)\n", enmState, pTimer->szName));
2068	return VERR_TM_UNKNOWN_STATE;
2069	}
2070	} while (cRetries-- > 0);
2071
2072	AssertMsgFailed(("Failed waiting for stable state. state=%d (%s)\n", pTimer->enmState, pTimer->szName));
2073	STAM_PROFILE_STOP(&pVM->tm.s.CTX_SUFF_Z(StatTimerStop), a);
2074	return VERR_TM_TIMER_UNSTABLE_STATE;
2075	}
2076
2077
2078	/**
2079	* Get the current clock time.
2080	* Handy for calculating the new expire time.
2081	*
2082	* @returns Current clock time.
2083	* @param pVM The cross context VM structure.
2084	* @param hTimer Timer handle as returned by one of the create functions.
2085	*/
2086	VMMDECL(uint64_t) TMTimerGet(PVMCC pVM, TMTIMERHANDLE hTimer)
2087	{
2088	TMTIMER_HANDLE_TO_VARS_RETURN_EX(pVM, hTimer, 0); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
2089	STAM_COUNTER_INC(&pTimer->StatGet);
2090
2091	uint64_t u64;
2092	switch (pQueue->enmClock)
2093	{
2094	case TMCLOCK_VIRTUAL:
2095	u64 = TMVirtualGet(pVM);
2096	break;
2097	case TMCLOCK_VIRTUAL_SYNC:
2098	u64 = TMVirtualSyncGet(pVM);
2099	break;
2100	case TMCLOCK_REAL:
2101	u64 = TMRealGet(pVM);
2102	break;
2103	default:
2104	AssertMsgFailed(("Invalid enmClock=%d\n", pQueue->enmClock));
2105	return UINT64_MAX;
2106	}
2107	//Log2(("TMTimerGet: returns %'RU64 (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n",
2108	// u64, pTimer, tmTimerState(pTimer->enmState), pTimer->szName));
2109	return u64;
2110	}
2111
2112
2113	/**
2114	* Get the frequency of the timer clock.
2115	*
2116	* @returns Clock frequency (as Hz of course).
2117	* @param pVM The cross context VM structure.
2118	* @param hTimer Timer handle as returned by one of the create functions.
2119	*/
2120	VMMDECL(uint64_t) TMTimerGetFreq(PVMCC pVM, TMTIMERHANDLE hTimer)
2121	{
2122	TMTIMER_HANDLE_TO_VARS_RETURN_EX(pVM, hTimer, 0); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
2123	switch (pQueue->enmClock)
2124	{
2125	case TMCLOCK_VIRTUAL:
2126	case TMCLOCK_VIRTUAL_SYNC:
2127	return TMCLOCK_FREQ_VIRTUAL;
2128
2129	case TMCLOCK_REAL:
2130	return TMCLOCK_FREQ_REAL;
2131
2132	default:
2133	AssertMsgFailed(("Invalid enmClock=%d\n", pQueue->enmClock));
2134	return 0;
2135	}
2136	}
2137
2138
2139	/**
2140	* Get the expire time of the timer.
2141	* Only valid for active timers.
2142	*
2143	* @returns Expire time of the timer.
2144	* @param pVM The cross context VM structure.
2145	* @param hTimer Timer handle as returned by one of the create functions.
2146	*/
2147	VMMDECL(uint64_t) TMTimerGetExpire(PVMCC pVM, TMTIMERHANDLE hTimer)
2148	{
2149	TMTIMER_HANDLE_TO_VARS_RETURN_EX(pVM, hTimer, UINT64_MAX); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
2150	TMTIMER_ASSERT_CRITSECT(pVM, pTimer);
2151	int cRetries = 1000;
2152	do
2153	{
2154	TMTIMERSTATE enmState = pTimer->enmState;
2155	switch (enmState)
2156	{
2157	case TMTIMERSTATE_EXPIRED_GET_UNLINK:
2158	case TMTIMERSTATE_EXPIRED_DELIVER:
2159	case TMTIMERSTATE_STOPPED:
2160	case TMTIMERSTATE_PENDING_STOP:
2161	case TMTIMERSTATE_PENDING_STOP_SCHEDULE:
2162	Log2(("TMTimerGetExpire: returns ~0 (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n",
2163	pTimer, tmTimerState(pTimer->enmState), pTimer->szName));
2164	return UINT64_MAX;
2165
2166	case TMTIMERSTATE_ACTIVE:
2167	case TMTIMERSTATE_PENDING_RESCHEDULE:
2168	case TMTIMERSTATE_PENDING_SCHEDULE:
2169	Log2(("TMTimerGetExpire: returns %'RU64 (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n",
2170	pTimer->u64Expire, pTimer, tmTimerState(pTimer->enmState), pTimer->szName));
2171	return pTimer->u64Expire;
2172
2173	case TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE:
2174	case TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE:
2175	#ifdef IN_RING3
2176	if (!RTThreadYield())
2177	RTThreadSleep(1);
2178	#endif
2179	break;
2180
2181	/*
2182	* Invalid states.
2183	*/
2184	case TMTIMERSTATE_DESTROY:
2185	case TMTIMERSTATE_FREE:
2186	AssertMsgFailed(("Invalid timer state %d (%s)\n", enmState, pTimer->szName));
2187	Log2(("TMTimerGetExpire: returns ~0 (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n",
2188	pTimer, tmTimerState(pTimer->enmState), pTimer->szName));
2189	return UINT64_MAX;
2190	default:
2191	AssertMsgFailed(("Unknown timer state %d (%s)\n", enmState, pTimer->szName));
2192	return UINT64_MAX;
2193	}
2194	} while (cRetries-- > 0);
2195
2196	AssertMsgFailed(("Failed waiting for stable state. state=%d (%s)\n", pTimer->enmState, pTimer->szName));
2197	Log2(("TMTimerGetExpire: returns ~0 (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n",
2198	pTimer, tmTimerState(pTimer->enmState), pTimer->szName));
2199	return UINT64_MAX;
2200	}
2201
2202
2203	/**
2204	* Checks if a timer is active or not.
2205	*
2206	* @returns True if active.
2207	* @returns False if not active.
2208	* @param pVM The cross context VM structure.
2209	* @param hTimer Timer handle as returned by one of the create functions.
2210	*/
2211	VMMDECL(bool) TMTimerIsActive(PVMCC pVM, TMTIMERHANDLE hTimer)
2212	{
2213	TMTIMER_HANDLE_TO_VARS_RETURN_EX(pVM, hTimer, false); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
2214	TMTIMERSTATE enmState = pTimer->enmState;
2215	switch (enmState)
2216	{
2217	case TMTIMERSTATE_STOPPED:
2218	case TMTIMERSTATE_EXPIRED_GET_UNLINK:
2219	case TMTIMERSTATE_EXPIRED_DELIVER:
2220	case TMTIMERSTATE_PENDING_STOP:
2221	case TMTIMERSTATE_PENDING_STOP_SCHEDULE:
2222	Log2(("TMTimerIsActive: returns false (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n",
2223	pTimer, tmTimerState(pTimer->enmState), pTimer->szName));
2224	return false;
2225
2226	case TMTIMERSTATE_ACTIVE:
2227	case TMTIMERSTATE_PENDING_RESCHEDULE:
2228	case TMTIMERSTATE_PENDING_SCHEDULE:
2229	case TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE:
2230	case TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE:
2231	Log2(("TMTimerIsActive: returns true (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n",
2232	pTimer, tmTimerState(pTimer->enmState), pTimer->szName));
2233	return true;
2234
2235	/*
2236	* Invalid states.
2237	*/
2238	case TMTIMERSTATE_DESTROY:
2239	case TMTIMERSTATE_FREE:
2240	AssertMsgFailed(("Invalid timer state %s (%s)\n", tmTimerState(enmState), pTimer->szName));
2241	Log2(("TMTimerIsActive: returns false (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n",
2242	pTimer, tmTimerState(pTimer->enmState), pTimer->szName));
2243	return false;
2244	default:
2245	AssertMsgFailed(("Unknown timer state %d (%s)\n", enmState, pTimer->szName));
2246	return false;
2247	}
2248	}
2249
2250
2251	/* -=-=-=-=-=-=- Convenience APIs -=-=-=-=-=-=- */
2252
2253
2254	/**
2255	* Arm a timer with a (new) expire time relative to current time.
2256	*
2257	* @returns VBox status code.
2258	* @param pVM The cross context VM structure.
2259	* @param hTimer Timer handle as returned by one of the create functions.
2260	* @param cMilliesToNext Number of milliseconds to the next tick.
2261	*/
2262	VMMDECL(int) TMTimerSetMillies(PVMCC pVM, TMTIMERHANDLE hTimer, uint32_t cMilliesToNext)
2263	{
2264	TMTIMER_HANDLE_TO_VARS_RETURN(pVM, hTimer); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
2265	switch (pQueue->enmClock)
2266	{
2267	case TMCLOCK_VIRTUAL:
2268	AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
2269	return tmTimerSetRelative(pVM, pTimer, cMilliesToNext * UINT64_C(1000000), NULL, pQueueCC, pQueue);
2270
2271	case TMCLOCK_VIRTUAL_SYNC:
2272	AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
2273	return tmTimerSetRelative(pVM, pTimer, cMilliesToNext * UINT64_C(1000000), NULL, pQueueCC, pQueue);
2274
2275	case TMCLOCK_REAL:
2276	AssertCompile(TMCLOCK_FREQ_REAL == 1000);
2277	return tmTimerSetRelative(pVM, pTimer, cMilliesToNext, NULL, pQueueCC, pQueue);
2278
2279	default:
2280	AssertMsgFailed(("Invalid enmClock=%d\n", pQueue->enmClock));
2281	return VERR_TM_TIMER_BAD_CLOCK;
2282	}
2283	}
2284
2285
2286	/**
2287	* Arm a timer with a (new) expire time relative to current time.
2288	*
2289	* @returns VBox status code.
2290	* @param pVM The cross context VM structure.
2291	* @param hTimer Timer handle as returned by one of the create functions.
2292	* @param cMicrosToNext Number of microseconds to the next tick.
2293	*/
2294	VMMDECL(int) TMTimerSetMicro(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cMicrosToNext)
2295	{
2296	TMTIMER_HANDLE_TO_VARS_RETURN(pVM, hTimer); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
2297	switch (pQueue->enmClock)
2298	{
2299	case TMCLOCK_VIRTUAL:
2300	AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
2301	return tmTimerSetRelative(pVM, pTimer, cMicrosToNext * 1000, NULL, pQueueCC, pQueue);
2302
2303	case TMCLOCK_VIRTUAL_SYNC:
2304	AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
2305	return tmTimerSetRelative(pVM, pTimer, cMicrosToNext * 1000, NULL, pQueueCC, pQueue);
2306
2307	case TMCLOCK_REAL:
2308	AssertCompile(TMCLOCK_FREQ_REAL == 1000);
2309	return tmTimerSetRelative(pVM, pTimer, cMicrosToNext / 1000, NULL, pQueueCC, pQueue);
2310
2311	default:
2312	AssertMsgFailed(("Invalid enmClock=%d\n", pQueue->enmClock));
2313	return VERR_TM_TIMER_BAD_CLOCK;
2314	}
2315	}
2316
2317
2318	/**
2319	* Arm a timer with a (new) expire time relative to current time.
2320	*
2321	* @returns VBox status code.
2322	* @param pVM The cross context VM structure.
2323	* @param hTimer Timer handle as returned by one of the create functions.
2324	* @param cNanosToNext Number of nanoseconds to the next tick.
2325	*/
2326	VMMDECL(int) TMTimerSetNano(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cNanosToNext)
2327	{
2328	TMTIMER_HANDLE_TO_VARS_RETURN(pVM, hTimer); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
2329	switch (pQueue->enmClock)
2330	{
2331	case TMCLOCK_VIRTUAL:
2332	AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
2333	return tmTimerSetRelative(pVM, pTimer, cNanosToNext, NULL, pQueueCC, pQueue);
2334
2335	case TMCLOCK_VIRTUAL_SYNC:
2336	AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
2337	return tmTimerSetRelative(pVM, pTimer, cNanosToNext, NULL, pQueueCC, pQueue);
2338
2339	case TMCLOCK_REAL:
2340	AssertCompile(TMCLOCK_FREQ_REAL == 1000);
2341	return tmTimerSetRelative(pVM, pTimer, cNanosToNext / 1000000, NULL, pQueueCC, pQueue);
2342
2343	default:
2344	AssertMsgFailed(("Invalid enmClock=%d\n", pQueue->enmClock));
2345	return VERR_TM_TIMER_BAD_CLOCK;
2346	}
2347	}
2348
2349
2350	/**
2351	* Get the current clock time as nanoseconds.
2352	*
2353	* @returns The timer clock as nanoseconds.
2354	* @param pVM The cross context VM structure.
2355	* @param hTimer Timer handle as returned by one of the create functions.
2356	*/
2357	VMMDECL(uint64_t) TMTimerGetNano(PVMCC pVM, TMTIMERHANDLE hTimer)
2358	{
2359	return TMTimerToNano(pVM, hTimer, TMTimerGet(pVM, hTimer));
2360	}
2361
2362
2363	/**
2364	* Get the current clock time as microseconds.
2365	*
2366	* @returns The timer clock as microseconds.
2367	* @param pVM The cross context VM structure.
2368	* @param hTimer Timer handle as returned by one of the create functions.
2369	*/
2370	VMMDECL(uint64_t) TMTimerGetMicro(PVMCC pVM, TMTIMERHANDLE hTimer)
2371	{
2372	return TMTimerToMicro(pVM, hTimer, TMTimerGet(pVM, hTimer));
2373	}
2374
2375
2376	/**
2377	* Get the current clock time as milliseconds.
2378	*
2379	* @returns The timer clock as milliseconds.
2380	* @param pVM The cross context VM structure.
2381	* @param hTimer Timer handle as returned by one of the create functions.
2382	*/
2383	VMMDECL(uint64_t) TMTimerGetMilli(PVMCC pVM, TMTIMERHANDLE hTimer)
2384	{
2385	return TMTimerToMilli(pVM, hTimer, TMTimerGet(pVM, hTimer));
2386	}
2387
2388
2389	/**
2390	* Converts the specified timer clock time to nanoseconds.
2391	*
2392	* @returns nanoseconds.
2393	* @param pVM The cross context VM structure.
2394	* @param hTimer Timer handle as returned by one of the create functions.
2395	* @param cTicks The clock ticks.
2396	* @remark There could be rounding errors here. We just do a simple integer divide
2397	* without any adjustments.
2398	*/
2399	VMMDECL(uint64_t) TMTimerToNano(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cTicks)
2400	{
2401	TMTIMER_HANDLE_TO_VARS_RETURN_EX(pVM, hTimer, 0); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
2402	switch (pQueue->enmClock)
2403	{
2404	case TMCLOCK_VIRTUAL:
2405	case TMCLOCK_VIRTUAL_SYNC:
2406	AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
2407	return cTicks;
2408
2409	case TMCLOCK_REAL:
2410	AssertCompile(TMCLOCK_FREQ_REAL == 1000);
2411	return cTicks * 1000000;
2412
2413	default:
2414	AssertMsgFailed(("Invalid enmClock=%d\n", pQueue->enmClock));
2415	return 0;
2416	}
2417	}
2418
2419
2420	/**
2421	* Converts the specified timer clock time to microseconds.
2422	*
2423	* @returns microseconds.
2424	* @param pVM The cross context VM structure.
2425	* @param hTimer Timer handle as returned by one of the create functions.
2426	* @param cTicks The clock ticks.
2427	* @remark There could be rounding errors here. We just do a simple integer divide
2428	* without any adjustments.
2429	*/
2430	VMMDECL(uint64_t) TMTimerToMicro(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cTicks)
2431	{
2432	TMTIMER_HANDLE_TO_VARS_RETURN_EX(pVM, hTimer, 0); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
2433	switch (pQueue->enmClock)
2434	{
2435	case TMCLOCK_VIRTUAL:
2436	case TMCLOCK_VIRTUAL_SYNC:
2437	AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
2438	return cTicks / 1000;
2439
2440	case TMCLOCK_REAL:
2441	AssertCompile(TMCLOCK_FREQ_REAL == 1000);
2442	return cTicks * 1000;
2443
2444	default:
2445	AssertMsgFailed(("Invalid enmClock=%d\n", pQueue->enmClock));
2446	return 0;
2447	}
2448	}
2449
2450
2451	/**
2452	* Converts the specified timer clock time to milliseconds.
2453	*
2454	* @returns milliseconds.
2455	* @param pVM The cross context VM structure.
2456	* @param hTimer Timer handle as returned by one of the create functions.
2457	* @param cTicks The clock ticks.
2458	* @remark There could be rounding errors here. We just do a simple integer divide
2459	* without any adjustments.
2460	*/
2461	VMMDECL(uint64_t) TMTimerToMilli(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cTicks)
2462	{
2463	TMTIMER_HANDLE_TO_VARS_RETURN_EX(pVM, hTimer, 0); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
2464	switch (pQueue->enmClock)
2465	{
2466	case TMCLOCK_VIRTUAL:
2467	case TMCLOCK_VIRTUAL_SYNC:
2468	AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
2469	return cTicks / 1000000;
2470
2471	case TMCLOCK_REAL:
2472	AssertCompile(TMCLOCK_FREQ_REAL == 1000);
2473	return cTicks;
2474
2475	default:
2476	AssertMsgFailed(("Invalid enmClock=%d\n", pQueue->enmClock));
2477	return 0;
2478	}
2479	}
2480
2481
2482	/**
2483	* Converts the specified nanosecond timestamp to timer clock ticks.
2484	*
2485	* @returns timer clock ticks.
2486	* @param pVM The cross context VM structure.
2487	* @param hTimer Timer handle as returned by one of the create functions.
2488	* @param cNanoSecs The nanosecond value ticks to convert.
2489	* @remark There could be rounding and overflow errors here.
2490	*/
2491	VMMDECL(uint64_t) TMTimerFromNano(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cNanoSecs)
2492	{
2493	TMTIMER_HANDLE_TO_VARS_RETURN_EX(pVM, hTimer, 0); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
2494	switch (pQueue->enmClock)
2495	{
2496	case TMCLOCK_VIRTUAL:
2497	case TMCLOCK_VIRTUAL_SYNC:
2498	AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
2499	return cNanoSecs;
2500
2501	case TMCLOCK_REAL:
2502	AssertCompile(TMCLOCK_FREQ_REAL == 1000);
2503	return cNanoSecs / 1000000;
2504
2505	default:
2506	AssertMsgFailed(("Invalid enmClock=%d\n", pQueue->enmClock));
2507	return 0;
2508	}
2509	}
2510
2511
2512	/**
2513	* Converts the specified microsecond timestamp to timer clock ticks.
2514	*
2515	* @returns timer clock ticks.
2516	* @param pVM The cross context VM structure.
2517	* @param hTimer Timer handle as returned by one of the create functions.
2518	* @param cMicroSecs The microsecond value ticks to convert.
2519	* @remark There could be rounding and overflow errors here.
2520	*/
2521	VMMDECL(uint64_t) TMTimerFromMicro(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cMicroSecs)
2522	{
2523	TMTIMER_HANDLE_TO_VARS_RETURN_EX(pVM, hTimer, 0); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
2524	switch (pQueue->enmClock)
2525	{
2526	case TMCLOCK_VIRTUAL:
2527	case TMCLOCK_VIRTUAL_SYNC:
2528	AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
2529	return cMicroSecs * 1000;
2530
2531	case TMCLOCK_REAL:
2532	AssertCompile(TMCLOCK_FREQ_REAL == 1000);
2533	return cMicroSecs / 1000;
2534
2535	default:
2536	AssertMsgFailed(("Invalid enmClock=%d\n", pQueue->enmClock));
2537	return 0;
2538	}
2539	}
2540
2541
2542	/**
2543	* Converts the specified millisecond timestamp to timer clock ticks.
2544	*
2545	* @returns timer clock ticks.
2546	* @param pVM The cross context VM structure.
2547	* @param hTimer Timer handle as returned by one of the create functions.
2548	* @param cMilliSecs The millisecond value ticks to convert.
2549	* @remark There could be rounding and overflow errors here.
2550	*/
2551	VMMDECL(uint64_t) TMTimerFromMilli(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cMilliSecs)
2552	{
2553	TMTIMER_HANDLE_TO_VARS_RETURN_EX(pVM, hTimer, 0); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
2554	switch (pQueue->enmClock)
2555	{
2556	case TMCLOCK_VIRTUAL:
2557	case TMCLOCK_VIRTUAL_SYNC:
2558	AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
2559	return cMilliSecs * 1000000;
2560
2561	case TMCLOCK_REAL:
2562	AssertCompile(TMCLOCK_FREQ_REAL == 1000);
2563	return cMilliSecs;
2564
2565	default:
2566	AssertMsgFailed(("Invalid enmClock=%d\n", pQueue->enmClock));
2567	return 0;
2568	}
2569	}
2570
2571
2572	/**
2573	* Convert state to string.
2574	*
2575	* @returns Readonly status name.
2576	* @param enmState State.
2577	*/
2578	const char *tmTimerState(TMTIMERSTATE enmState)
2579	{
2580	switch (enmState)
2581	{
2582	#define CASE(num, state) \
2583	case TMTIMERSTATE_##state: \
2584	AssertCompile(TMTIMERSTATE_##state == (num)); \
2585	return #num "-" #state
2586	CASE( 0,INVALID);
2587	CASE( 1,STOPPED);
2588	CASE( 2,ACTIVE);
2589	CASE( 3,EXPIRED_GET_UNLINK);
2590	CASE( 4,EXPIRED_DELIVER);
2591	CASE( 5,PENDING_STOP);
2592	CASE( 6,PENDING_STOP_SCHEDULE);
2593	CASE( 7,PENDING_SCHEDULE_SET_EXPIRE);
2594	CASE( 8,PENDING_SCHEDULE);
2595	CASE( 9,PENDING_RESCHEDULE_SET_EXPIRE);
2596	CASE(10,PENDING_RESCHEDULE);
2597	CASE(11,DESTROY);
2598	CASE(12,FREE);
2599	default:
2600	AssertMsgFailed(("Invalid state enmState=%d\n", enmState));
2601	return "Invalid state!";
2602	#undef CASE
2603	}
2604	}
2605
2606
2607	#if defined(IN_RING0) \|\| defined(IN_RING3)
2608	/**
2609	* Copies over old timers and initialized newly allocted ones.
2610	*
2611	* Helper for TMR0TimerQueueGrow an tmR3TimerQueueGrow.
2612	*
2613	* @param paTimers The new timer allocation.
2614	* @param paOldTimers The old timers.
2615	* @param cNewTimers Number of new timers.
2616	* @param cOldTimers Number of old timers.
2617	*/
2618	void tmHCTimerQueueGrowInit(PTMTIMER paTimers, TMTIMER const *paOldTimers, uint32_t cNewTimers, uint32_t cOldTimers)
2619	{
2620	Assert(cOldTimers < cNewTimers);
2621
2622	/*
2623	* Copy over the old info and initialize the new handles.
2624	*/
2625	if (cOldTimers > 0)
2626	memcpy(paTimers, paOldTimers, sizeof(TMTIMER) * cOldTimers);
2627
2628	size_t i = cNewTimers;
2629	while (i-- > cOldTimers)
2630	{
2631	paTimers[i].u64Expire = UINT64_MAX;
2632	paTimers[i].enmType = TMTIMERTYPE_INVALID;
2633	paTimers[i].enmState = TMTIMERSTATE_FREE;
2634	paTimers[i].idxScheduleNext = UINT32_MAX;
2635	paTimers[i].idxNext = UINT32_MAX;
2636	paTimers[i].idxPrev = UINT32_MAX;
2637	paTimers[i].hSelf = NIL_TMTIMERHANDLE;
2638	}
2639
2640	/*
2641	* Mark the zero'th entry as allocated but invalid if we just allocated it.
2642	*/
2643	if (cOldTimers == 0)
2644	{
2645	paTimers[0].enmState = TMTIMERSTATE_INVALID;
2646	paTimers[0].szName[0] = 'n';
2647	paTimers[0].szName[1] = 'i';
2648	paTimers[0].szName[2] = 'l';
2649	paTimers[0].szName[3] = '\0';
2650	}
2651	}
2652	#endif /* IN_RING0 \|\| IN_RING3 */
2653
2654
2655	/**
2656	* The slow path of tmGetFrequencyHint() where we try to recalculate the value.
2657	*
2658	* @returns The highest frequency. 0 if no timers care.
2659	* @param pVM The cross context VM structure.
2660	* @param uOldMaxHzHint The old global hint.
2661	*/
2662	DECL_NO_INLINE(static, uint32_t) tmGetFrequencyHintSlow(PVMCC pVM, uint32_t uOldMaxHzHint)
2663	{
2664	/* Set two bits, though not entirely sure it's needed (too exhaused to think clearly)
2665	but it should force other callers thru the slow path while we're recalculating and
2666	help us detect changes while we're recalculating. */
2667	AssertCompile(RT_ELEMENTS(pVM->tm.s.aTimerQueues) <= 16);
2668
2669	/*
2670	* The "right" highest frequency value isn't so important that we'll block
2671	* waiting on the timer semaphores.
2672	*/
2673	uint32_t uMaxHzHint = 0;
2674	for (uint32_t idxQueue = 0; idxQueue < RT_ELEMENTS(pVM->tm.s.aTimerQueues); idxQueue++)
2675	{
2676	PTMTIMERQUEUE pQueue = &pVM->tm.s.aTimerQueues[idxQueue];
2677
2678	/* Get the max Hz hint for the queue. */
2679	uint32_t uMaxHzHintQueue;
2680	if ( !(ASMAtomicUoReadU64(&pVM->tm.s.HzHint.u64Combined) & (RT_BIT_32(idxQueue) \| RT_BIT_32(idxQueue + 16)))
2681	\|\| RT_FAILURE_NP(PDMCritSectTryEnter(pVM, &pQueue->TimerLock)))
2682	uMaxHzHintQueue = ASMAtomicReadU32(&pQueue->uMaxHzHint);
2683	else
2684	{
2685	/* Is it still necessary to do updating? */
2686	if (ASMAtomicUoReadU64(&pVM->tm.s.HzHint.u64Combined) & (RT_BIT_32(idxQueue) \| RT_BIT_32(idxQueue + 16)))
2687	{
2688	ASMAtomicAndU64(&pVM->tm.s.HzHint.u64Combined, ~RT_BIT_64(idxQueue + 16)); /* clear one flag up front */
2689
2690	PTMTIMERQUEUECC pQueueCC = TM_GET_TIMER_QUEUE_CC(pVM, idxQueue, pQueue);
2691	uMaxHzHintQueue = 0;
2692	for (PTMTIMER pCur = tmTimerQueueGetHead(pQueueCC, pQueue);
2693	pCur;
2694	pCur = tmTimerGetNext(pQueueCC, pCur))
2695	{
2696	uint32_t uHzHint = ASMAtomicUoReadU32(&pCur->uHzHint);
2697	if (uHzHint > uMaxHzHintQueue)
2698	{
2699	TMTIMERSTATE enmState = pCur->enmState;
2700	switch (enmState)
2701	{
2702	case TMTIMERSTATE_ACTIVE:
2703	case TMTIMERSTATE_EXPIRED_GET_UNLINK:
2704	case TMTIMERSTATE_EXPIRED_DELIVER:
2705	case TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE:
2706	case TMTIMERSTATE_PENDING_SCHEDULE:
2707	case TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE:
2708	case TMTIMERSTATE_PENDING_RESCHEDULE:
2709	uMaxHzHintQueue = uHzHint;
2710	break;
2711
2712	case TMTIMERSTATE_STOPPED:
2713	case TMTIMERSTATE_PENDING_STOP:
2714	case TMTIMERSTATE_PENDING_STOP_SCHEDULE:
2715	case TMTIMERSTATE_DESTROY:
2716	case TMTIMERSTATE_FREE:
2717	case TMTIMERSTATE_INVALID:
2718	break;
2719	/* no default, want gcc warnings when adding more states. */
2720	}
2721	}
2722	}
2723
2724	/* Write the new Hz hint for the quest and clear the other update flag. */
2725	ASMAtomicUoWriteU32(&pQueue->uMaxHzHint, uMaxHzHintQueue);
2726	ASMAtomicAndU64(&pVM->tm.s.HzHint.u64Combined, ~RT_BIT_64(idxQueue));
2727	}
2728	else
2729	uMaxHzHintQueue = ASMAtomicUoReadU32(&pQueue->uMaxHzHint);
2730
2731	PDMCritSectLeave(pVM, &pQueue->TimerLock);
2732	}
2733
2734	/* Update the global max Hz hint. */
2735	if (uMaxHzHint < uMaxHzHintQueue)
2736	uMaxHzHint = uMaxHzHintQueue;
2737	}
2738
2739	/*
2740	* Update the frequency hint if no pending frequency changes and we didn't race anyone thru here.
2741	*/
2742	uint64_t u64Actual = RT_MAKE_U64(0 /no pending updates/, uOldMaxHzHint);
2743	if (ASMAtomicCmpXchgExU64(&pVM->tm.s.HzHint.u64Combined, RT_MAKE_U64(0, uMaxHzHint), u64Actual, &u64Actual))
2744	Log(("tmGetFrequencyHintSlow: New value %u Hz\n", uMaxHzHint));
2745	else
2746	for (uint32_t iTry = 1;; iTry++)
2747	{
2748	if (RT_LO_U32(u64Actual) != 0)
2749	Log(("tmGetFrequencyHintSlow: Outdated value %u Hz (%#x, try %u)\n", uMaxHzHint, RT_LO_U32(u64Actual), iTry));
2750	else if (iTry >= 4)
2751	Log(("tmGetFrequencyHintSlow: Unable to set %u Hz (try %u)\n", uMaxHzHint, iTry));
2752	else if (ASMAtomicCmpXchgExU64(&pVM->tm.s.HzHint.u64Combined, RT_MAKE_U64(0, uMaxHzHint), u64Actual, &u64Actual))
2753	Log(("tmGetFrequencyHintSlow: New value %u Hz (try %u)\n", uMaxHzHint, iTry));
2754	else
2755	continue;
2756	break;
2757	}
2758	return uMaxHzHint;
2759	}
2760
2761
2762	/**
2763	* Gets the highest frequency hint for all the important timers.
2764	*
2765	* @returns The highest frequency. 0 if no timers care.
2766	* @param pVM The cross context VM structure.
2767	*/
2768	DECLINLINE(uint32_t) tmGetFrequencyHint(PVMCC pVM)
2769	{
2770	/*
2771	* Query the value, recalculate it if necessary.
2772	*/
2773	uint64_t u64Combined = ASMAtomicReadU64(&pVM->tm.s.HzHint.u64Combined);
2774	if (RT_HI_U32(u64Combined) == 0)
2775	return RT_LO_U32(u64Combined); /* hopefully somewhat likely */
2776	return tmGetFrequencyHintSlow(pVM, RT_LO_U32(u64Combined));
2777	}
2778
2779
2780	/**
2781	* Calculates a host timer frequency that would be suitable for the current
2782	* timer load.
2783	*
2784	* This will take the highest timer frequency, adjust for catch-up and warp
2785	* driver, and finally add a little fudge factor. The caller (VMM) will use
2786	* the result to adjust the per-cpu preemption timer.
2787	*
2788	* @returns The highest frequency. 0 if no important timers around.
2789	* @param pVM The cross context VM structure.
2790	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
2791	*/
2792	VMM_INT_DECL(uint32_t) TMCalcHostTimerFrequency(PVMCC pVM, PVMCPUCC pVCpu)
2793	{
2794	uint32_t uHz = tmGetFrequencyHint(pVM);
2795
2796	/* Catch up, we have to be more aggressive than the % indicates at the
2797	beginning of the effort. */
2798	if (ASMAtomicUoReadBool(&pVM->tm.s.fVirtualSyncCatchUp))
2799	{
2800	uint32_t u32Pct = ASMAtomicReadU32(&pVM->tm.s.u32VirtualSyncCatchUpPercentage);
2801	if (ASMAtomicReadBool(&pVM->tm.s.fVirtualSyncCatchUp))
2802	{
2803	if (u32Pct <= 100)
2804	u32Pct = u32Pct * pVM->tm.s.cPctHostHzFudgeFactorCatchUp100 / 100;
2805	else if (u32Pct <= 200)
2806	u32Pct = u32Pct * pVM->tm.s.cPctHostHzFudgeFactorCatchUp200 / 100;
2807	else if (u32Pct <= 400)
2808	u32Pct = u32Pct * pVM->tm.s.cPctHostHzFudgeFactorCatchUp400 / 100;
2809	uHz *= u32Pct + 100;
2810	uHz /= 100;
2811	}
2812	}
2813
2814	/* Warp drive. */
2815	if (ASMAtomicUoReadBool(&pVM->tm.s.fVirtualWarpDrive))
2816	{
2817	uint32_t u32Pct = ASMAtomicReadU32(&pVM->tm.s.u32VirtualWarpDrivePercentage);
2818	if (ASMAtomicReadBool(&pVM->tm.s.fVirtualWarpDrive))
2819	{
2820	uHz *= u32Pct;
2821	uHz /= 100;
2822	}
2823	}
2824
2825	/* Fudge factor. */
2826	if (pVCpu->idCpu == pVM->tm.s.idTimerCpu)
2827	uHz *= pVM->tm.s.cPctHostHzFudgeFactorTimerCpu;
2828	else
2829	uHz *= pVM->tm.s.cPctHostHzFudgeFactorOtherCpu;
2830	uHz /= 100;
2831
2832	/* Make sure it isn't too high. */
2833	if (uHz > pVM->tm.s.cHostHzMax)
2834	uHz = pVM->tm.s.cHostHzMax;
2835
2836	return uHz;
2837	}
2838
2839
2840	/**
2841	* Whether the guest virtual clock is ticking.
2842	*
2843	* @returns true if ticking, false otherwise.
2844	* @param pVM The cross context VM structure.
2845	*/
2846	VMM_INT_DECL(bool) TMVirtualIsTicking(PVM pVM)
2847	{
2848	return RT_BOOL(pVM->tm.s.cVirtualTicking);
2849	}
2850

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

source: vbox/trunk/src/VBox/VMM/VMMAll/TMAll.cpp@ 98122

Download in other formats: