GVMMR0.cpp@ 58944

Last change on this file since 58944 was 58833, checked in by vboxsync, 9 years ago
GVMMR0.cpp: Build fix
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 93.8 KB

Line
1	/* $Id: GVMMR0.cpp 58833 2015-11-23 17:42:56Z vboxsync $ */
2	/** @file
3	* GVMM - Global VM Manager.
4	*/
5
6	/*
7	* Copyright (C) 2007-2015 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/** @page pg_gvmm GVMM - The Global VM Manager
20	*
21	* The Global VM Manager lives in ring-0. Its main function at the moment is
22	* to manage a list of all running VMs, keep a ring-0 only structure (GVM) for
23	* each of them, and assign them unique identifiers (so GMM can track page
24	* owners). The GVMM also manage some of the host CPU resources, like the
25	* periodic preemption timer.
26	*
27	* The GVMM will create a ring-0 object for each VM when it is registered, this
28	* is both for session cleanup purposes and for having a point where it is
29	* possible to implement usage polices later (in SUPR0ObjRegister).
30	*
31	*
32	* @section sec_gvmm_ppt Periodic Preemption Timer (PPT)
33	*
34	* On system that sports a high resolution kernel timer API, we use per-cpu
35	* timers to generate interrupts that preempts VT-x, AMD-V and raw-mode guest
36	* execution. The timer frequency is calculating by taking the max
37	* TMCalcHostTimerFrequency for all VMs running on a CPU for the last ~160 ms
38	* (RT_ELEMENTS((PGVMMHOSTCPU)0, Ppt.aHzHistory) *
39	* GVMMHOSTCPU_PPT_HIST_INTERVAL_NS).
40	*
41	* The TMCalcHostTimerFrequency() part of the things gets its takes the max
42	* TMTimerSetFrequencyHint() value and adjusts by the current catch-up percent,
43	* warp drive percent and some fudge factors. VMMR0.cpp reports the result via
44	* GVMMR0SchedUpdatePeriodicPreemptionTimer() before switching to the VT-x,
45	* AMD-V and raw-mode execution environments.
46	*/
47
48
49	/*********************************************************************************************************************************
50	* Header Files *
51	*********************************************************************************************************************************/
52	#define LOG_GROUP LOG_GROUP_GVMM
53	#include <VBox/vmm/gvmm.h>
54	#include <VBox/vmm/gmm.h>
55	#include "GVMMR0Internal.h"
56	#include <VBox/vmm/gvm.h>
57	#include <VBox/vmm/vm.h>
58	#include <VBox/vmm/vmcpuset.h>
59	#include <VBox/vmm/vmm.h>
60	#include <VBox/param.h>
61	#include <VBox/err.h>
62
63	#include <iprt/asm.h>
64	#include <iprt/asm-amd64-x86.h>
65	#include <iprt/critsect.h>
66	#include <iprt/mem.h>
67	#include <iprt/semaphore.h>
68	#include <iprt/time.h>
69	#include <VBox/log.h>
70	#include <iprt/thread.h>
71	#include <iprt/process.h>
72	#include <iprt/param.h>
73	#include <iprt/string.h>
74	#include <iprt/assert.h>
75	#include <iprt/mem.h>
76	#include <iprt/memobj.h>
77	#include <iprt/mp.h>
78	#include <iprt/cpuset.h>
79	#include <iprt/spinlock.h>
80	#include <iprt/timer.h>
81
82	#include "dtrace/VBoxVMM.h"
83
84
85	/*********************************************************************************************************************************
86	* Defined Constants And Macros *
87	*********************************************************************************************************************************/
88	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_SOLARIS) \|\| defined(DOXYGEN_RUNNING)
89	/** Define this to enable the periodic preemption timer. */
90	# define GVMM_SCHED_WITH_PPT
91	#endif
92
93
94	/** @def GVMM_CHECK_SMAP_SETUP
95	* SMAP check setup. */
96	/** @def GVMM_CHECK_SMAP_CHECK
97	* Checks that the AC flag is set if SMAP is enabled. If AC is not set,
98	* it will be logged and @a a_BadExpr is executed. */
99	/** @def GVMM_CHECK_SMAP_CHECK2
100	* Checks that the AC flag is set if SMAP is enabled. If AC is not set, it will
101	* be logged, written to the VMs assertion text buffer, and @a a_BadExpr is
102	* executed. */
103	#if defined(VBOX_STRICT) \|\| 1
104	# define GVMM_CHECK_SMAP_SETUP() uint32_t const fKernelFeatures = SUPR0GetKernelFeatures()
105	# define GVMM_CHECK_SMAP_CHECK(a_BadExpr) \
106	do { \
107	if (fKernelFeatures & SUPKERNELFEATURES_SMAP) \
108	{ \
109	RTCCUINTREG fEflCheck = ASMGetFlags(); \
110	if (RT_LIKELY(fEflCheck & X86_EFL_AC)) \
111	{ /* likely */ } \
112	else \
113	{ \
114	SUPR0Printf("%s, line %d: EFLAGS.AC is clear! (%#x)\n", __FUNCTION__, __LINE__, (uint32_t)fEflCheck); \
115	a_BadExpr; \
116	} \
117	} \
118	} while (0)
119	# define GVMM_CHECK_SMAP_CHECK2(a_pVM, a_BadExpr) \
120	do { \
121	if (fKernelFeatures & SUPKERNELFEATURES_SMAP) \
122	{ \
123	RTCCUINTREG fEflCheck = ASMGetFlags(); \
124	if (RT_LIKELY(fEflCheck & X86_EFL_AC)) \
125	{ /* likely */ } \
126	else \
127	{ \
128	SUPR0BadContext((a_pVM) ? (a_pVM)->pSession : NULL, __FILE__, __LINE__, "EFLAGS.AC is zero!"); \
129	a_BadExpr; \
130	} \
131	} \
132	} while (0)
133	#else
134	# define GVMM_CHECK_SMAP_SETUP() uint32_t const fKernelFeatures = 0
135	# define GVMM_CHECK_SMAP_CHECK(a_BadExpr) NOREF(fKernelFeatures)
136	# define GVMM_CHECK_SMAP_CHECK2(a_pVM, a_BadExpr) NOREF(fKernelFeatures)
137	#endif
138
139
140
141	/*********************************************************************************************************************************
142	* Structures and Typedefs *
143	*********************************************************************************************************************************/
144
145	/**
146	* Global VM handle.
147	*/
148	typedef struct GVMHANDLE
149	{
150	/** The index of the next handle in the list (free or used). (0 is nil.) */
151	uint16_t volatile iNext;
152	/** Our own index / handle value. */
153	uint16_t iSelf;
154	/** The process ID of the handle owner.
155	* This is used for access checks. */
156	RTPROCESS ProcId;
157	/** The pointer to the ring-0 only (aka global) VM structure. */
158	PGVM pGVM;
159	/** The ring-0 mapping of the shared VM instance data. */
160	PVM pVM;
161	/** The virtual machine object. */
162	void *pvObj;
163	/** The session this VM is associated with. */
164	PSUPDRVSESSION pSession;
165	/** The ring-0 handle of the EMT0 thread.
166	* This is used for ownership checks as well as looking up a VM handle by thread
167	* at times like assertions. */
168	RTNATIVETHREAD hEMT0;
169	} GVMHANDLE;
170	/** Pointer to a global VM handle. */
171	typedef GVMHANDLE *PGVMHANDLE;
172
173	/** Number of GVM handles (including the NIL handle). */
174	#if HC_ARCH_BITS == 64
175	# define GVMM_MAX_HANDLES 8192
176	#else
177	# define GVMM_MAX_HANDLES 128
178	#endif
179
180	/**
181	* Per host CPU GVMM data.
182	*/
183	typedef struct GVMMHOSTCPU
184	{
185	/** Magic number (GVMMHOSTCPU_MAGIC). */
186	uint32_t volatile u32Magic;
187	/** The CPU ID. */
188	RTCPUID idCpu;
189	/** The CPU set index. */
190	uint32_t idxCpuSet;
191
192	#ifdef GVMM_SCHED_WITH_PPT
193	/** Periodic preemption timer data. */
194	struct
195	{
196	/** The handle to the periodic preemption timer. */
197	PRTTIMER pTimer;
198	/** Spinlock protecting the data below. */
199	RTSPINLOCK hSpinlock;
200	/** The smalles Hz that we need to care about. (static) */
201	uint32_t uMinHz;
202	/** The number of ticks between each historization. */
203	uint32_t cTicksHistoriziationInterval;
204	/** The current historization tick (counting up to
205	* cTicksHistoriziationInterval and then resetting). */
206	uint32_t iTickHistorization;
207	/** The current timer interval. This is set to 0 when inactive. */
208	uint32_t cNsInterval;
209	/** The current timer frequency. This is set to 0 when inactive. */
210	uint32_t uTimerHz;
211	/** The current max frequency reported by the EMTs.
212	* This gets historicize and reset by the timer callback. This is
213	* read without holding the spinlock, so needs atomic updating. */
214	uint32_t volatile uDesiredHz;
215	/** Whether the timer was started or not. */
216	bool volatile fStarted;
217	/** Set if we're starting timer. */
218	bool volatile fStarting;
219	/** The index of the next history entry (mod it). */
220	uint32_t iHzHistory;
221	/** Historicized uDesiredHz values. The array wraps around, new entries
222	* are added at iHzHistory. This is updated approximately every
223	* GVMMHOSTCPU_PPT_HIST_INTERVAL_NS by the timer callback. */
224	uint32_t aHzHistory[8];
225	/** Statistics counter for recording the number of interval changes. */
226	uint32_t cChanges;
227	/** Statistics counter for recording the number of timer starts. */
228	uint32_t cStarts;
229	} Ppt;
230	#endif /* GVMM_SCHED_WITH_PPT */
231
232	} GVMMHOSTCPU;
233	/** Pointer to the per host CPU GVMM data. */
234	typedef GVMMHOSTCPU *PGVMMHOSTCPU;
235	/** The GVMMHOSTCPU::u32Magic value (Petra, Tanya & Rachel Haden). */
236	#define GVMMHOSTCPU_MAGIC UINT32_C(0x19711011)
237	/** The interval on history entry should cover (approximately) give in
238	* nanoseconds. */
239	#define GVMMHOSTCPU_PPT_HIST_INTERVAL_NS UINT32_C(20000000)
240
241
242	/**
243	* The GVMM instance data.
244	*/
245	typedef struct GVMM
246	{
247	/** Eyecatcher / magic. */
248	uint32_t u32Magic;
249	/** The index of the head of the free handle chain. (0 is nil.) */
250	uint16_t volatile iFreeHead;
251	/** The index of the head of the active handle chain. (0 is nil.) */
252	uint16_t volatile iUsedHead;
253	/** The number of VMs. */
254	uint16_t volatile cVMs;
255	/** Alignment padding. */
256	uint16_t u16Reserved;
257	/** The number of EMTs. */
258	uint32_t volatile cEMTs;
259	/** The number of EMTs that have halted in GVMMR0SchedHalt. */
260	uint32_t volatile cHaltedEMTs;
261	/** Mini lock for restricting early wake-ups to one thread. */
262	bool volatile fDoingEarlyWakeUps;
263	bool afPadding[3]; /*< explicit alignment padding. /
264	/** When the next halted or sleeping EMT will wake up.
265	* This is set to 0 when it needs recalculating and to UINT64_MAX when
266	* there are no halted or sleeping EMTs in the GVMM. */
267	uint64_t uNsNextEmtWakeup;
268	/** The lock used to serialize VM creation, destruction and associated events that
269	* isn't performance critical. Owners may acquire the list lock. */
270	RTCRITSECT CreateDestroyLock;
271	/** The lock used to serialize used list updates and accesses.
272	* This indirectly includes scheduling since the scheduler will have to walk the
273	* used list to examin running VMs. Owners may not acquire any other locks. */
274	RTCRITSECTRW UsedLock;
275	/** The handle array.
276	* The size of this array defines the maximum number of currently running VMs.
277	* The first entry is unused as it represents the NIL handle. */
278	GVMHANDLE aHandles[GVMM_MAX_HANDLES];
279
280	/** @gcfgm{/GVMM/cEMTsMeansCompany, 32-bit, 0, UINT32_MAX, 1}
281	* The number of EMTs that means we no longer consider ourselves alone on a
282	* CPU/Core.
283	*/
284	uint32_t cEMTsMeansCompany;
285	/** @gcfgm{/GVMM/MinSleepAlone,32-bit, 0, 100000000, 750000, ns}
286	* The minimum sleep time for when we're alone, in nano seconds.
287	*/
288	uint32_t nsMinSleepAlone;
289	/** @gcfgm{/GVMM/MinSleepCompany,32-bit,0, 100000000, 15000, ns}
290	* The minimum sleep time for when we've got company, in nano seconds.
291	*/
292	uint32_t nsMinSleepCompany;
293	/** @gcfgm{/GVMM/EarlyWakeUp1, 32-bit, 0, 100000000, 25000, ns}
294	* The limit for the first round of early wake-ups, given in nano seconds.
295	*/
296	uint32_t nsEarlyWakeUp1;
297	/** @gcfgm{/GVMM/EarlyWakeUp2, 32-bit, 0, 100000000, 50000, ns}
298	* The limit for the second round of early wake-ups, given in nano seconds.
299	*/
300	uint32_t nsEarlyWakeUp2;
301
302	/** Set if we're doing early wake-ups.
303	* This reflects nsEarlyWakeUp1 and nsEarlyWakeUp2. */
304	bool volatile fDoEarlyWakeUps;
305
306	/** The number of entries in the host CPU array (aHostCpus). */
307	uint32_t cHostCpus;
308	/** Per host CPU data (variable length). */
309	GVMMHOSTCPU aHostCpus[1];
310	} GVMM;
311	AssertCompileMemberAlignment(GVMM, CreateDestroyLock, 8);
312	AssertCompileMemberAlignment(GVMM, UsedLock, 8);
313	AssertCompileMemberAlignment(GVMM, uNsNextEmtWakeup, 8);
314	/** Pointer to the GVMM instance data. */
315	typedef GVMM *PGVMM;
316
317	/** The GVMM::u32Magic value (Charlie Haden). */
318	#define GVMM_MAGIC UINT32_C(0x19370806)
319
320
321
322	/*********************************************************************************************************************************
323	* Global Variables *
324	*********************************************************************************************************************************/
325	/** Pointer to the GVMM instance data.
326	* (Just my general dislike for global variables.) */
327	static PGVMM g_pGVMM = NULL;
328
329	/** Macro for obtaining and validating the g_pGVMM pointer.
330	* On failure it will return from the invoking function with the specified return value.
331	*
332	* @param pGVMM The name of the pGVMM variable.
333	* @param rc The return value on failure. Use VERR_GVMM_INSTANCE for VBox
334	* status codes.
335	*/
336	#define GVMM_GET_VALID_INSTANCE(pGVMM, rc) \
337	do { \
338	(pGVMM) = g_pGVMM;\
339	AssertPtrReturn((pGVMM), (rc)); \
340	AssertMsgReturn((pGVMM)->u32Magic == GVMM_MAGIC, ("%p - %#x\n", (pGVMM), (pGVMM)->u32Magic), (rc)); \
341	} while (0)
342
343	/** Macro for obtaining and validating the g_pGVMM pointer, void function variant.
344	* On failure it will return from the invoking function.
345	*
346	* @param pGVMM The name of the pGVMM variable.
347	*/
348	#define GVMM_GET_VALID_INSTANCE_VOID(pGVMM) \
349	do { \
350	(pGVMM) = g_pGVMM;\
351	AssertPtrReturnVoid((pGVMM)); \
352	AssertMsgReturnVoid((pGVMM)->u32Magic == GVMM_MAGIC, ("%p - %#x\n", (pGVMM), (pGVMM)->u32Magic)); \
353	} while (0)
354
355
356	/*********************************************************************************************************************************
357	* Internal Functions *
358	*********************************************************************************************************************************/
359	static void gvmmR0InitPerVMData(PGVM pGVM);
360	static DECLCALLBACK(void) gvmmR0HandleObjDestructor(void pvObj, void pvGVMM, void *pvHandle);
361	static int gvmmR0ByVM(PVM pVM, PGVM ppGVM, PGVMM ppGVMM, bool fTakeUsedLock);
362	static int gvmmR0ByVMAndEMT(PVM pVM, VMCPUID idCpu, PGVM ppGVM, PGVMM ppGVMM);
363	#ifdef GVMM_SCHED_WITH_PPT
364	static DECLCALLBACK(void) gvmmR0SchedPeriodicPreemptionTimerCallback(PRTTIMER pTimer, void *pvUser, uint64_t iTick);
365	#endif
366
367
368	/**
369	* Initializes the GVMM.
370	*
371	* This is called while owning the loader semaphore (see supdrvIOCtl_LdrLoad()).
372	*
373	* @returns VBox status code.
374	*/
375	GVMMR0DECL(int) GVMMR0Init(void)
376	{
377	LogFlow(("GVMMR0Init:\n"));
378
379	/*
380	* Allocate and initialize the instance data.
381	*/
382	uint32_t cHostCpus = RTMpGetArraySize();
383	AssertMsgReturn(cHostCpus > 0 && cHostCpus < _64K, ("%d", (int)cHostCpus), VERR_GVMM_HOST_CPU_RANGE);
384
385	PGVMM pGVMM = (PGVMM)RTMemAllocZ(RT_UOFFSETOF(GVMM, aHostCpus[cHostCpus]));
386	if (!pGVMM)
387	return VERR_NO_MEMORY;
388	int rc = RTCritSectInitEx(&pGVMM->CreateDestroyLock, 0, NIL_RTLOCKVALCLASS, RTLOCKVAL_SUB_CLASS_NONE,
389	"GVMM-CreateDestroyLock");
390	if (RT_SUCCESS(rc))
391	{
392	rc = RTCritSectRwInitEx(&pGVMM->UsedLock, 0, NIL_RTLOCKVALCLASS, RTLOCKVAL_SUB_CLASS_NONE, "GVMM-UsedLock");
393	if (RT_SUCCESS(rc))
394	{
395	pGVMM->u32Magic = GVMM_MAGIC;
396	pGVMM->iUsedHead = 0;
397	pGVMM->iFreeHead = 1;
398
399	/* the nil handle */
400	pGVMM->aHandles[0].iSelf = 0;
401	pGVMM->aHandles[0].iNext = 0;
402
403	/* the tail */
404	unsigned i = RT_ELEMENTS(pGVMM->aHandles) - 1;
405	pGVMM->aHandles[i].iSelf = i;
406	pGVMM->aHandles[i].iNext = 0; /* nil */
407
408	/* the rest */
409	while (i-- > 1)
410	{
411	pGVMM->aHandles[i].iSelf = i;
412	pGVMM->aHandles[i].iNext = i + 1;
413	}
414
415	/* The default configuration values. */
416	uint32_t cNsResolution = RTSemEventMultiGetResolution();
417	pGVMM->cEMTsMeansCompany = 1; /** @todo should be adjusted to relative to the cpu count or something... */
418	if (cNsResolution >= 5*RT_NS_100US)
419	{
420	pGVMM->nsMinSleepAlone = 750000 /* ns (0.750 ms) /; /* @todo this should be adjusted to be 75% (or something) of the scheduler granularity... */
421	pGVMM->nsMinSleepCompany = 15000 /* ns (0.015 ms) */;
422	pGVMM->nsEarlyWakeUp1 = 25000 /* ns (0.025 ms) */;
423	pGVMM->nsEarlyWakeUp2 = 50000 /* ns (0.050 ms) */;
424	}
425	else if (cNsResolution > RT_NS_100US)
426	{
427	pGVMM->nsMinSleepAlone = cNsResolution / 2;
428	pGVMM->nsMinSleepCompany = cNsResolution / 4;
429	pGVMM->nsEarlyWakeUp1 = 0;
430	pGVMM->nsEarlyWakeUp2 = 0;
431	}
432	else
433	{
434	pGVMM->nsMinSleepAlone = 2000;
435	pGVMM->nsMinSleepCompany = 2000;
436	pGVMM->nsEarlyWakeUp1 = 0;
437	pGVMM->nsEarlyWakeUp2 = 0;
438	}
439	pGVMM->fDoEarlyWakeUps = pGVMM->nsEarlyWakeUp1 > 0 && pGVMM->nsEarlyWakeUp2 > 0;
440
441	/* The host CPU data. */
442	pGVMM->cHostCpus = cHostCpus;
443	uint32_t iCpu = cHostCpus;
444	RTCPUSET PossibleSet;
445	RTMpGetSet(&PossibleSet);
446	while (iCpu-- > 0)
447	{
448	pGVMM->aHostCpus[iCpu].idxCpuSet = iCpu;
449	#ifdef GVMM_SCHED_WITH_PPT
450	pGVMM->aHostCpus[iCpu].Ppt.pTimer = NULL;
451	pGVMM->aHostCpus[iCpu].Ppt.hSpinlock = NIL_RTSPINLOCK;
452	pGVMM->aHostCpus[iCpu].Ppt.uMinHz = 5; /** @todo Add some API which figures this one out. (not that important) */
453	pGVMM->aHostCpus[iCpu].Ppt.cTicksHistoriziationInterval = 1;
454	//pGVMM->aHostCpus[iCpu].Ppt.iTickHistorization = 0;
455	//pGVMM->aHostCpus[iCpu].Ppt.cNsInterval = 0;
456	//pGVMM->aHostCpus[iCpu].Ppt.uTimerHz = 0;
457	//pGVMM->aHostCpus[iCpu].Ppt.uDesiredHz = 0;
458	//pGVMM->aHostCpus[iCpu].Ppt.fStarted = false;
459	//pGVMM->aHostCpus[iCpu].Ppt.fStarting = false;
460	//pGVMM->aHostCpus[iCpu].Ppt.iHzHistory = 0;
461	//pGVMM->aHostCpus[iCpu].Ppt.aHzHistory = {0};
462	#endif
463
464	if (RTCpuSetIsMember(&PossibleSet, iCpu))
465	{
466	pGVMM->aHostCpus[iCpu].idCpu = RTMpCpuIdFromSetIndex(iCpu);
467	pGVMM->aHostCpus[iCpu].u32Magic = GVMMHOSTCPU_MAGIC;
468
469	#ifdef GVMM_SCHED_WITH_PPT
470	rc = RTTimerCreateEx(&pGVMM->aHostCpus[iCpu].Ppt.pTimer,
471	5010001000 /* whatever */,
472	RTTIMER_FLAGS_CPU(iCpu) \| RTTIMER_FLAGS_HIGH_RES,
473	gvmmR0SchedPeriodicPreemptionTimerCallback,
474	&pGVMM->aHostCpus[iCpu]);
475	if (RT_SUCCESS(rc))
476	rc = RTSpinlockCreate(&pGVMM->aHostCpus[iCpu].Ppt.hSpinlock, RTSPINLOCK_FLAGS_INTERRUPT_SAFE, "GVMM/CPU");
477	if (RT_FAILURE(rc))
478	{
479	while (iCpu < cHostCpus)
480	{
481	RTTimerDestroy(pGVMM->aHostCpus[iCpu].Ppt.pTimer);
482	RTSpinlockDestroy(pGVMM->aHostCpus[iCpu].Ppt.hSpinlock);
483	pGVMM->aHostCpus[iCpu].Ppt.hSpinlock = NIL_RTSPINLOCK;
484	iCpu++;
485	}
486	break;
487	}
488	#endif
489	}
490	else
491	{
492	pGVMM->aHostCpus[iCpu].idCpu = NIL_RTCPUID;
493	pGVMM->aHostCpus[iCpu].u32Magic = 0;
494	}
495	}
496	if (RT_SUCCESS(rc))
497	{
498	g_pGVMM = pGVMM;
499	LogFlow(("GVMMR0Init: pGVMM=%p cHostCpus=%u\n", pGVMM, cHostCpus));
500	return VINF_SUCCESS;
501	}
502
503	/* bail out. */
504	RTCritSectRwDelete(&pGVMM->UsedLock);
505	}
506	RTCritSectDelete(&pGVMM->CreateDestroyLock);
507	}
508
509	RTMemFree(pGVMM);
510	return rc;
511	}
512
513
514	/**
515	* Terminates the GVM.
516	*
517	* This is called while owning the loader semaphore (see supdrvLdrFree()).
518	* And unless something is wrong, there should be absolutely no VMs
519	* registered at this point.
520	*/
521	GVMMR0DECL(void) GVMMR0Term(void)
522	{
523	LogFlow(("GVMMR0Term:\n"));
524
525	PGVMM pGVMM = g_pGVMM;
526	g_pGVMM = NULL;
527	if (RT_UNLIKELY(!VALID_PTR(pGVMM)))
528	{
529	SUPR0Printf("GVMMR0Term: pGVMM=%p\n", pGVMM);
530	return;
531	}
532
533	/*
534	* First of all, stop all active timers.
535	*/
536	uint32_t cActiveTimers = 0;
537	uint32_t iCpu = pGVMM->cHostCpus;
538	while (iCpu-- > 0)
539	{
540	ASMAtomicWriteU32(&pGVMM->aHostCpus[iCpu].u32Magic, ~GVMMHOSTCPU_MAGIC);
541	#ifdef GVMM_SCHED_WITH_PPT
542	if ( pGVMM->aHostCpus[iCpu].Ppt.pTimer != NULL
543	&& RT_SUCCESS(RTTimerStop(pGVMM->aHostCpus[iCpu].Ppt.pTimer)))
544	cActiveTimers++;
545	#endif
546	}
547	if (cActiveTimers)
548	RTThreadSleep(1); /* fudge */
549
550	/*
551	* Invalidate the and free resources.
552	*/
553	pGVMM->u32Magic = ~GVMM_MAGIC;
554	RTCritSectRwDelete(&pGVMM->UsedLock);
555	RTCritSectDelete(&pGVMM->CreateDestroyLock);
556
557	pGVMM->iFreeHead = 0;
558	if (pGVMM->iUsedHead)
559	{
560	SUPR0Printf("GVMMR0Term: iUsedHead=%#x! (cVMs=%#x cEMTs=%#x)\n", pGVMM->iUsedHead, pGVMM->cVMs, pGVMM->cEMTs);
561	pGVMM->iUsedHead = 0;
562	}
563
564	#ifdef GVMM_SCHED_WITH_PPT
565	iCpu = pGVMM->cHostCpus;
566	while (iCpu-- > 0)
567	{
568	RTTimerDestroy(pGVMM->aHostCpus[iCpu].Ppt.pTimer);
569	pGVMM->aHostCpus[iCpu].Ppt.pTimer = NULL;
570	RTSpinlockDestroy(pGVMM->aHostCpus[iCpu].Ppt.hSpinlock);
571	pGVMM->aHostCpus[iCpu].Ppt.hSpinlock = NIL_RTSPINLOCK;
572	}
573	#endif
574
575	RTMemFree(pGVMM);
576	}
577
578
579	/**
580	* A quick hack for setting global config values.
581	*
582	* @returns VBox status code.
583	*
584	* @param pSession The session handle. Used for authentication.
585	* @param pszName The variable name.
586	* @param u64Value The new value.
587	*/
588	GVMMR0DECL(int) GVMMR0SetConfig(PSUPDRVSESSION pSession, const char *pszName, uint64_t u64Value)
589	{
590	/*
591	* Validate input.
592	*/
593	PGVMM pGVMM;
594	GVMM_GET_VALID_INSTANCE(pGVMM, VERR_GVMM_INSTANCE);
595	AssertPtrReturn(pSession, VERR_INVALID_HANDLE);
596	AssertPtrReturn(pszName, VERR_INVALID_POINTER);
597
598	/*
599	* String switch time!
600	*/
601	if (strncmp(pszName, RT_STR_TUPLE("/GVMM/")))
602	return VERR_CFGM_VALUE_NOT_FOUND; /* borrow status codes from CFGM... */
603	int rc = VINF_SUCCESS;
604	pszName += sizeof("/GVMM/") - 1;
605	if (!strcmp(pszName, "cEMTsMeansCompany"))
606	{
607	if (u64Value <= UINT32_MAX)
608	pGVMM->cEMTsMeansCompany = u64Value;
609	else
610	rc = VERR_OUT_OF_RANGE;
611	}
612	else if (!strcmp(pszName, "MinSleepAlone"))
613	{
614	if (u64Value <= RT_NS_100MS)
615	pGVMM->nsMinSleepAlone = u64Value;
616	else
617	rc = VERR_OUT_OF_RANGE;
618	}
619	else if (!strcmp(pszName, "MinSleepCompany"))
620	{
621	if (u64Value <= RT_NS_100MS)
622	pGVMM->nsMinSleepCompany = u64Value;
623	else
624	rc = VERR_OUT_OF_RANGE;
625	}
626	else if (!strcmp(pszName, "EarlyWakeUp1"))
627	{
628	if (u64Value <= RT_NS_100MS)
629	{
630	pGVMM->nsEarlyWakeUp1 = u64Value;
631	pGVMM->fDoEarlyWakeUps = pGVMM->nsEarlyWakeUp1 > 0 && pGVMM->nsEarlyWakeUp2 > 0;
632	}
633	else
634	rc = VERR_OUT_OF_RANGE;
635	}
636	else if (!strcmp(pszName, "EarlyWakeUp2"))
637	{
638	if (u64Value <= RT_NS_100MS)
639	{
640	pGVMM->nsEarlyWakeUp2 = u64Value;
641	pGVMM->fDoEarlyWakeUps = pGVMM->nsEarlyWakeUp1 > 0 && pGVMM->nsEarlyWakeUp2 > 0;
642	}
643	else
644	rc = VERR_OUT_OF_RANGE;
645	}
646	else
647	rc = VERR_CFGM_VALUE_NOT_FOUND;
648	return rc;
649	}
650
651
652	/**
653	* A quick hack for getting global config values.
654	*
655	* @returns VBox status code.
656	*
657	* @param pSession The session handle. Used for authentication.
658	* @param pszName The variable name.
659	* @param pu64Value Where to return the value.
660	*/
661	GVMMR0DECL(int) GVMMR0QueryConfig(PSUPDRVSESSION pSession, const char pszName, uint64_t pu64Value)
662	{
663	/*
664	* Validate input.
665	*/
666	PGVMM pGVMM;
667	GVMM_GET_VALID_INSTANCE(pGVMM, VERR_GVMM_INSTANCE);
668	AssertPtrReturn(pSession, VERR_INVALID_HANDLE);
669	AssertPtrReturn(pszName, VERR_INVALID_POINTER);
670	AssertPtrReturn(pu64Value, VERR_INVALID_POINTER);
671
672	/*
673	* String switch time!
674	*/
675	if (strncmp(pszName, RT_STR_TUPLE("/GVMM/")))
676	return VERR_CFGM_VALUE_NOT_FOUND; /* borrow status codes from CFGM... */
677	int rc = VINF_SUCCESS;
678	pszName += sizeof("/GVMM/") - 1;
679	if (!strcmp(pszName, "cEMTsMeansCompany"))
680	*pu64Value = pGVMM->cEMTsMeansCompany;
681	else if (!strcmp(pszName, "MinSleepAlone"))
682	*pu64Value = pGVMM->nsMinSleepAlone;
683	else if (!strcmp(pszName, "MinSleepCompany"))
684	*pu64Value = pGVMM->nsMinSleepCompany;
685	else if (!strcmp(pszName, "EarlyWakeUp1"))
686	*pu64Value = pGVMM->nsEarlyWakeUp1;
687	else if (!strcmp(pszName, "EarlyWakeUp2"))
688	*pu64Value = pGVMM->nsEarlyWakeUp2;
689	else
690	rc = VERR_CFGM_VALUE_NOT_FOUND;
691	return rc;
692	}
693
694
695	/**
696	* Acquire the 'used' lock in shared mode.
697	*
698	* This prevents destruction of the VM while we're in ring-0.
699	*
700	* @returns IPRT status code, see RTSemFastMutexRequest.
701	* @param a_pGVMM The GVMM instance data.
702	* @sa GVMMR0_USED_SHARED_UNLOCK, GVMMR0_USED_EXCLUSIVE_LOCK
703	*/
704	#define GVMMR0_USED_SHARED_LOCK(a_pGVMM) RTCritSectRwEnterShared(&(a_pGVMM)->UsedLock)
705
706	/**
707	* Release the 'used' lock in when owning it in shared mode.
708	*
709	* @returns IPRT status code, see RTSemFastMutexRequest.
710	* @param a_pGVMM The GVMM instance data.
711	* @sa GVMMR0_USED_SHARED_LOCK
712	*/
713	#define GVMMR0_USED_SHARED_UNLOCK(a_pGVMM) RTCritSectRwLeaveShared(&(a_pGVMM)->UsedLock)
714
715	/**
716	* Acquire the 'used' lock in exclusive mode.
717	*
718	* Only use this function when making changes to the used list.
719	*
720	* @returns IPRT status code, see RTSemFastMutexRequest.
721	* @param a_pGVMM The GVMM instance data.
722	* @sa GVMMR0_USED_EXCLUSIVE_UNLOCK
723	*/
724	#define GVMMR0_USED_EXCLUSIVE_LOCK(a_pGVMM) RTCritSectRwEnterExcl(&(a_pGVMM)->UsedLock)
725
726	/**
727	* Release the 'used' lock when owning it in exclusive mode.
728	*
729	* @returns IPRT status code, see RTSemFastMutexRelease.
730	* @param a_pGVMM The GVMM instance data.
731	* @sa GVMMR0_USED_EXCLUSIVE_LOCK, GVMMR0_USED_SHARED_UNLOCK
732	*/
733	#define GVMMR0_USED_EXCLUSIVE_UNLOCK(a_pGVMM) RTCritSectRwLeaveExcl(&(a_pGVMM)->UsedLock)
734
735
736	/**
737	* Try acquire the 'create & destroy' lock.
738	*
739	* @returns IPRT status code, see RTSemFastMutexRequest.
740	* @param pGVMM The GVMM instance data.
741	*/
742	DECLINLINE(int) gvmmR0CreateDestroyLock(PGVMM pGVMM)
743	{
744	LogFlow(("++gvmmR0CreateDestroyLock(%p)\n", pGVMM));
745	int rc = RTCritSectEnter(&pGVMM->CreateDestroyLock);
746	LogFlow(("gvmmR0CreateDestroyLock(%p)->%Rrc\n", pGVMM, rc));
747	return rc;
748	}
749
750
751	/**
752	* Release the 'create & destroy' lock.
753	*
754	* @returns IPRT status code, see RTSemFastMutexRequest.
755	* @param pGVMM The GVMM instance data.
756	*/
757	DECLINLINE(int) gvmmR0CreateDestroyUnlock(PGVMM pGVMM)
758	{
759	LogFlow(("--gvmmR0CreateDestroyUnlock(%p)\n", pGVMM));
760	int rc = RTCritSectLeave(&pGVMM->CreateDestroyLock);
761	AssertRC(rc);
762	return rc;
763	}
764
765
766	/**
767	* Request wrapper for the GVMMR0CreateVM API.
768	*
769	* @returns VBox status code.
770	* @param pReq The request buffer.
771	*/
772	GVMMR0DECL(int) GVMMR0CreateVMReq(PGVMMCREATEVMREQ pReq)
773	{
774	/*
775	* Validate the request.
776	*/
777	if (!VALID_PTR(pReq))
778	return VERR_INVALID_POINTER;
779	if (pReq->Hdr.cbReq != sizeof(*pReq))
780	return VERR_INVALID_PARAMETER;
781	if (!VALID_PTR(pReq->pSession))
782	return VERR_INVALID_POINTER;
783
784	/*
785	* Execute it.
786	*/
787	PVM pVM;
788	pReq->pVMR0 = NULL;
789	pReq->pVMR3 = NIL_RTR3PTR;
790	int rc = GVMMR0CreateVM(pReq->pSession, pReq->cCpus, &pVM);
791	if (RT_SUCCESS(rc))
792	{
793	pReq->pVMR0 = pVM;
794	pReq->pVMR3 = pVM->pVMR3;
795	}
796	return rc;
797	}
798
799
800	/**
801	* Allocates the VM structure and registers it with GVM.
802	*
803	* The caller will become the VM owner and there by the EMT.
804	*
805	* @returns VBox status code.
806	* @param pSession The support driver session.
807	* @param cCpus Number of virtual CPUs for the new VM.
808	* @param ppVM Where to store the pointer to the VM structure.
809	*
810	* @thread EMT.
811	*/
812	GVMMR0DECL(int) GVMMR0CreateVM(PSUPDRVSESSION pSession, uint32_t cCpus, PVM *ppVM)
813	{
814	LogFlow(("GVMMR0CreateVM: pSession=%p\n", pSession));
815	PGVMM pGVMM;
816	GVMM_GET_VALID_INSTANCE(pGVMM, VERR_GVMM_INSTANCE);
817
818	AssertPtrReturn(ppVM, VERR_INVALID_POINTER);
819	*ppVM = NULL;
820
821	if ( cCpus == 0
822	\|\| cCpus > VMM_MAX_CPU_COUNT)
823	return VERR_INVALID_PARAMETER;
824
825	RTNATIVETHREAD hEMT0 = RTThreadNativeSelf();
826	AssertReturn(hEMT0 != NIL_RTNATIVETHREAD, VERR_GVMM_BROKEN_IPRT);
827	RTPROCESS ProcId = RTProcSelf();
828	AssertReturn(ProcId != NIL_RTPROCESS, VERR_GVMM_BROKEN_IPRT);
829
830	/*
831	* The whole allocation process is protected by the lock.
832	*/
833	int rc = gvmmR0CreateDestroyLock(pGVMM);
834	AssertRCReturn(rc, rc);
835
836	/*
837	* Allocate a handle first so we don't waste resources unnecessarily.
838	*/
839	uint16_t iHandle = pGVMM->iFreeHead;
840	if (iHandle)
841	{
842	PGVMHANDLE pHandle = &pGVMM->aHandles[iHandle];
843
844	/* consistency checks, a bit paranoid as always. */
845	if ( !pHandle->pVM
846	&& !pHandle->pGVM
847	&& !pHandle->pvObj
848	&& pHandle->iSelf == iHandle)
849	{
850	pHandle->pvObj = SUPR0ObjRegister(pSession, SUPDRVOBJTYPE_VM, gvmmR0HandleObjDestructor, pGVMM, pHandle);
851	if (pHandle->pvObj)
852	{
853	/*
854	* Move the handle from the free to used list and perform permission checks.
855	*/
856	rc = GVMMR0_USED_EXCLUSIVE_LOCK(pGVMM);
857	AssertRC(rc);
858
859	pGVMM->iFreeHead = pHandle->iNext;
860	pHandle->iNext = pGVMM->iUsedHead;
861	pGVMM->iUsedHead = iHandle;
862	pGVMM->cVMs++;
863
864	pHandle->pVM = NULL;
865	pHandle->pGVM = NULL;
866	pHandle->pSession = pSession;
867	pHandle->hEMT0 = NIL_RTNATIVETHREAD;
868	pHandle->ProcId = NIL_RTPROCESS;
869
870	GVMMR0_USED_EXCLUSIVE_UNLOCK(pGVMM);
871
872	rc = SUPR0ObjVerifyAccess(pHandle->pvObj, pSession, NULL);
873	if (RT_SUCCESS(rc))
874	{
875	/*
876	* Allocate the global VM structure (GVM) and initialize it.
877	*/
878	PGVM pGVM = (PGVM)RTMemAllocZ(RT_UOFFSETOF(GVM, aCpus[cCpus]));
879	if (pGVM)
880	{
881	pGVM->u32Magic = GVM_MAGIC;
882	pGVM->hSelf = iHandle;
883	pGVM->pVM = NULL;
884	pGVM->cCpus = cCpus;
885
886	gvmmR0InitPerVMData(pGVM);
887	GMMR0InitPerVMData(pGVM);
888
889	/*
890	* Allocate the shared VM structure and associated page array.
891	*/
892	const uint32_t cbVM = RT_UOFFSETOF(VM, aCpus[cCpus]);
893	const uint32_t cPages = RT_ALIGN_32(cbVM, PAGE_SIZE) >> PAGE_SHIFT;
894	rc = RTR0MemObjAllocLow(&pGVM->gvmm.s.VMMemObj, cPages << PAGE_SHIFT, false /* fExecutable */);
895	if (RT_SUCCESS(rc))
896	{
897	PVM pVM = (PVM)RTR0MemObjAddress(pGVM->gvmm.s.VMMemObj); AssertPtr(pVM);
898	memset(pVM, 0, cPages << PAGE_SHIFT);
899	pVM->enmVMState = VMSTATE_CREATING;
900	pVM->pVMR0 = pVM;
901	pVM->pSession = pSession;
902	pVM->hSelf = iHandle;
903	pVM->cbSelf = cbVM;
904	pVM->cCpus = cCpus;
905	pVM->uCpuExecutionCap = 100; /* default is no cap. */
906	pVM->offVMCPU = RT_UOFFSETOF(VM, aCpus);
907	AssertCompileMemberAlignment(VM, cpum, 64);
908	AssertCompileMemberAlignment(VM, tm, 64);
909	AssertCompileMemberAlignment(VM, aCpus, PAGE_SIZE);
910
911	rc = RTR0MemObjAllocPage(&pGVM->gvmm.s.VMPagesMemObj, cPages * sizeof(SUPPAGE), false /* fExecutable */);
912	if (RT_SUCCESS(rc))
913	{
914	PSUPPAGE paPages = (PSUPPAGE)RTR0MemObjAddress(pGVM->gvmm.s.VMPagesMemObj); AssertPtr(paPages);
915	for (uint32_t iPage = 0; iPage < cPages; iPage++)
916	{
917	paPages[iPage].uReserved = 0;
918	paPages[iPage].Phys = RTR0MemObjGetPagePhysAddr(pGVM->gvmm.s.VMMemObj, iPage);
919	Assert(paPages[iPage].Phys != NIL_RTHCPHYS);
920	}
921
922	/*
923	* Map them into ring-3.
924	*/
925	rc = RTR0MemObjMapUser(&pGVM->gvmm.s.VMMapObj, pGVM->gvmm.s.VMMemObj, (RTR3PTR)-1, 0,
926	RTMEM_PROT_READ \| RTMEM_PROT_WRITE, NIL_RTR0PROCESS);
927	if (RT_SUCCESS(rc))
928	{
929	pVM->pVMR3 = RTR0MemObjAddressR3(pGVM->gvmm.s.VMMapObj);
930	AssertPtr((void *)pVM->pVMR3);
931
932	/* Initialize all the VM pointers. */
933	for (uint32_t i = 0; i < cCpus; i++)
934	{
935	pVM->aCpus[i].pVMR0 = pVM;
936	pVM->aCpus[i].pVMR3 = pVM->pVMR3;
937	pVM->aCpus[i].idHostCpu = NIL_RTCPUID;
938	pVM->aCpus[i].hNativeThreadR0 = NIL_RTNATIVETHREAD;
939	}
940
941	rc = RTR0MemObjMapUser(&pGVM->gvmm.s.VMPagesMapObj, pGVM->gvmm.s.VMPagesMemObj, (RTR3PTR)-1,
942	0 /* uAlignment */, RTMEM_PROT_READ \| RTMEM_PROT_WRITE,
943	NIL_RTR0PROCESS);
944	if (RT_SUCCESS(rc))
945	{
946	pVM->paVMPagesR3 = RTR0MemObjAddressR3(pGVM->gvmm.s.VMPagesMapObj);
947	AssertPtr((void *)pVM->paVMPagesR3);
948
949	/* complete the handle - take the UsedLock sem just to be careful. */
950	rc = GVMMR0_USED_EXCLUSIVE_LOCK(pGVMM);
951	AssertRC(rc);
952
953	pHandle->pVM = pVM;
954	pHandle->pGVM = pGVM;
955	pHandle->hEMT0 = hEMT0;
956	pHandle->ProcId = ProcId;
957	pGVM->pVM = pVM;
958	pGVM->aCpus[0].hEMT = hEMT0;
959	pVM->aCpus[0].hNativeThreadR0 = hEMT0;
960	pGVMM->cEMTs += cCpus;
961
962	rc = VMMR0ThreadCtxHookCreateForEmt(&pVM->aCpus[0]);
963	if (RT_SUCCESS(rc))
964	{
965	VBOXVMM_R0_GVMM_VM_CREATED(pGVM, pVM, ProcId, (void *)hEMT0, cCpus);
966
967	GVMMR0_USED_EXCLUSIVE_UNLOCK(pGVMM);
968	gvmmR0CreateDestroyUnlock(pGVMM);
969
970	*ppVM = pVM;
971	Log(("GVMMR0CreateVM: pVM=%p pVMR3=%p pGVM=%p hGVM=%d\n", pVM, pVM->pVMR3, pGVM, iHandle));
972	return VINF_SUCCESS;
973	}
974
975	GVMMR0_USED_EXCLUSIVE_UNLOCK(pGVMM);
976	}
977
978	RTR0MemObjFree(pGVM->gvmm.s.VMMapObj, false /* fFreeMappings */);
979	pGVM->gvmm.s.VMMapObj = NIL_RTR0MEMOBJ;
980	}
981	RTR0MemObjFree(pGVM->gvmm.s.VMPagesMemObj, false /* fFreeMappings */);
982	pGVM->gvmm.s.VMPagesMemObj = NIL_RTR0MEMOBJ;
983	}
984	RTR0MemObjFree(pGVM->gvmm.s.VMMemObj, false /* fFreeMappings */);
985	pGVM->gvmm.s.VMMemObj = NIL_RTR0MEMOBJ;
986	}
987	}
988	}
989	/* else: The user wasn't permitted to create this VM. */
990
991	/*
992	* The handle will be freed by gvmmR0HandleObjDestructor as we release the
993	* object reference here. A little extra mess because of non-recursive lock.
994	*/
995	void *pvObj = pHandle->pvObj;
996	pHandle->pvObj = NULL;
997	gvmmR0CreateDestroyUnlock(pGVMM);
998
999	SUPR0ObjRelease(pvObj, pSession);
1000
1001	SUPR0Printf("GVMMR0CreateVM: failed, rc=%d\n", rc);
1002	return rc;
1003	}
1004
1005	rc = VERR_NO_MEMORY;
1006	}
1007	else
1008	rc = VERR_GVMM_IPE_1;
1009	}
1010	else
1011	rc = VERR_GVM_TOO_MANY_VMS;
1012
1013	gvmmR0CreateDestroyUnlock(pGVMM);
1014	return rc;
1015	}
1016
1017
1018	/**
1019	* Initializes the per VM data belonging to GVMM.
1020	*
1021	* @param pGVM Pointer to the global VM structure.
1022	*/
1023	static void gvmmR0InitPerVMData(PGVM pGVM)
1024	{
1025	AssertCompile(RT_SIZEOFMEMB(GVM,gvmm.s) <= RT_SIZEOFMEMB(GVM,gvmm.padding));
1026	AssertCompile(RT_SIZEOFMEMB(GVMCPU,gvmm.s) <= RT_SIZEOFMEMB(GVMCPU,gvmm.padding));
1027	pGVM->gvmm.s.VMMemObj = NIL_RTR0MEMOBJ;
1028	pGVM->gvmm.s.VMMapObj = NIL_RTR0MEMOBJ;
1029	pGVM->gvmm.s.VMPagesMemObj = NIL_RTR0MEMOBJ;
1030	pGVM->gvmm.s.VMPagesMapObj = NIL_RTR0MEMOBJ;
1031	pGVM->gvmm.s.fDoneVMMR0Init = false;
1032	pGVM->gvmm.s.fDoneVMMR0Term = false;
1033
1034	for (VMCPUID i = 0; i < pGVM->cCpus; i++)
1035	{
1036	pGVM->aCpus[i].gvmm.s.HaltEventMulti = NIL_RTSEMEVENTMULTI;
1037	pGVM->aCpus[i].hEMT = NIL_RTNATIVETHREAD;
1038	}
1039	}
1040
1041
1042	/**
1043	* Does the VM initialization.
1044	*
1045	* @returns VBox status code.
1046	* @param pVM The cross context VM structure.
1047	*/
1048	GVMMR0DECL(int) GVMMR0InitVM(PVM pVM)
1049	{
1050	LogFlow(("GVMMR0InitVM: pVM=%p\n", pVM));
1051
1052	/*
1053	* Validate the VM structure, state and handle.
1054	*/
1055	PGVM pGVM;
1056	PGVMM pGVMM;
1057	int rc = gvmmR0ByVMAndEMT(pVM, 0 /* idCpu */, &pGVM, &pGVMM);
1058	if (RT_SUCCESS(rc))
1059	{
1060	if ( !pGVM->gvmm.s.fDoneVMMR0Init
1061	&& pGVM->aCpus[0].gvmm.s.HaltEventMulti == NIL_RTSEMEVENTMULTI)
1062	{
1063	for (VMCPUID i = 0; i < pGVM->cCpus; i++)
1064	{
1065	rc = RTSemEventMultiCreate(&pGVM->aCpus[i].gvmm.s.HaltEventMulti);
1066	if (RT_FAILURE(rc))
1067	{
1068	pGVM->aCpus[i].gvmm.s.HaltEventMulti = NIL_RTSEMEVENTMULTI;
1069	break;
1070	}
1071	}
1072	}
1073	else
1074	rc = VERR_WRONG_ORDER;
1075	}
1076
1077	LogFlow(("GVMMR0InitVM: returns %Rrc\n", rc));
1078	return rc;
1079	}
1080
1081
1082	/**
1083	* Indicates that we're done with the ring-0 initialization
1084	* of the VM.
1085	*
1086	* @param pVM The cross context VM structure.
1087	* @thread EMT(0)
1088	*/
1089	GVMMR0DECL(void) GVMMR0DoneInitVM(PVM pVM)
1090	{
1091	/* Validate the VM structure, state and handle. */
1092	PGVM pGVM;
1093	PGVMM pGVMM;
1094	int rc = gvmmR0ByVMAndEMT(pVM, 0 /* idCpu */, &pGVM, &pGVMM);
1095	AssertRCReturnVoid(rc);
1096
1097	/* Set the indicator. */
1098	pGVM->gvmm.s.fDoneVMMR0Init = true;
1099	}
1100
1101
1102	/**
1103	* Indicates that we're doing the ring-0 termination of the VM.
1104	*
1105	* @returns true if termination hasn't been done already, false if it has.
1106	* @param pVM The cross context VM structure.
1107	* @param pGVM Pointer to the global VM structure. Optional.
1108	* @thread EMT(0)
1109	*/
1110	GVMMR0DECL(bool) GVMMR0DoingTermVM(PVM pVM, PGVM pGVM)
1111	{
1112	/* Validate the VM structure, state and handle. */
1113	AssertPtrNullReturn(pGVM, false);
1114	AssertReturn(!pGVM \|\| pGVM->u32Magic == GVM_MAGIC, false);
1115	if (!pGVM)
1116	{
1117	PGVMM pGVMM;
1118	int rc = gvmmR0ByVMAndEMT(pVM, 0 /* idCpu */, &pGVM, &pGVMM);
1119	AssertRCReturn(rc, false);
1120	}
1121
1122	/* Set the indicator. */
1123	if (pGVM->gvmm.s.fDoneVMMR0Term)
1124	return false;
1125	pGVM->gvmm.s.fDoneVMMR0Term = true;
1126	return true;
1127	}
1128
1129
1130	/**
1131	* Destroys the VM, freeing all associated resources (the ring-0 ones anyway).
1132	*
1133	* This is call from the vmR3DestroyFinalBit and from a error path in VMR3Create,
1134	* and the caller is not the EMT thread, unfortunately. For security reasons, it
1135	* would've been nice if the caller was actually the EMT thread or that we somehow
1136	* could've associated the calling thread with the VM up front.
1137	*
1138	* @returns VBox status code.
1139	* @param pVM The cross context VM structure.
1140	*
1141	* @thread EMT(0) if it's associated with the VM, otherwise any thread.
1142	*/
1143	GVMMR0DECL(int) GVMMR0DestroyVM(PVM pVM)
1144	{
1145	LogFlow(("GVMMR0DestroyVM: pVM=%p\n", pVM));
1146	PGVMM pGVMM;
1147	GVMM_GET_VALID_INSTANCE(pGVMM, VERR_GVMM_INSTANCE);
1148
1149	/*
1150	* Validate the VM structure, state and caller.
1151	*/
1152	AssertPtrReturn(pVM, VERR_INVALID_POINTER);
1153	AssertReturn(!((uintptr_t)pVM & PAGE_OFFSET_MASK), VERR_INVALID_POINTER);
1154	AssertMsgReturn(pVM->enmVMState >= VMSTATE_CREATING && pVM->enmVMState <= VMSTATE_TERMINATED, ("%d\n", pVM->enmVMState),
1155	VERR_WRONG_ORDER);
1156
1157	uint32_t hGVM = pVM->hSelf;
1158	AssertReturn(hGVM != NIL_GVM_HANDLE, VERR_INVALID_HANDLE);
1159	AssertReturn(hGVM < RT_ELEMENTS(pGVMM->aHandles), VERR_INVALID_HANDLE);
1160
1161	PGVMHANDLE pHandle = &pGVMM->aHandles[hGVM];
1162	AssertReturn(pHandle->pVM == pVM, VERR_NOT_OWNER);
1163
1164	RTPROCESS ProcId = RTProcSelf();
1165	RTNATIVETHREAD hSelf = RTThreadNativeSelf();
1166	AssertReturn( ( pHandle->hEMT0 == hSelf
1167	&& pHandle->ProcId == ProcId)
1168	\|\| pHandle->hEMT0 == NIL_RTNATIVETHREAD, VERR_NOT_OWNER);
1169
1170	/*
1171	* Lookup the handle and destroy the object.
1172	* Since the lock isn't recursive and we'll have to leave it before dereferencing the
1173	* object, we take some precautions against racing callers just in case...
1174	*/
1175	int rc = gvmmR0CreateDestroyLock(pGVMM);
1176	AssertRC(rc);
1177
1178	/* Be careful here because we might theoretically be racing someone else cleaning up. */
1179	if ( pHandle->pVM == pVM
1180	&& ( ( pHandle->hEMT0 == hSelf
1181	&& pHandle->ProcId == ProcId)
1182	\|\| pHandle->hEMT0 == NIL_RTNATIVETHREAD)
1183	&& VALID_PTR(pHandle->pvObj)
1184	&& VALID_PTR(pHandle->pSession)
1185	&& VALID_PTR(pHandle->pGVM)
1186	&& pHandle->pGVM->u32Magic == GVM_MAGIC)
1187	{
1188	void *pvObj = pHandle->pvObj;
1189	pHandle->pvObj = NULL;
1190	gvmmR0CreateDestroyUnlock(pGVMM);
1191
1192	for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
1193	{
1194	/** @todo Can we busy wait here for all thread-context hooks to be
1195	* deregistered before releasing (destroying) it? Only until we find a
1196	* solution for not deregistering hooks everytime we're leaving HMR0
1197	* context. */
1198	VMMR0ThreadCtxHookDestroyForEmt(&pVM->aCpus[idCpu]);
1199	}
1200
1201	SUPR0ObjRelease(pvObj, pHandle->pSession);
1202	}
1203	else
1204	{
1205	SUPR0Printf("GVMMR0DestroyVM: pHandle=%p:{.pVM=%p, .hEMT0=%p, .ProcId=%u, .pvObj=%p} pVM=%p hSelf=%p\n",
1206	pHandle, pHandle->pVM, pHandle->hEMT0, pHandle->ProcId, pHandle->pvObj, pVM, hSelf);
1207	gvmmR0CreateDestroyUnlock(pGVMM);
1208	rc = VERR_GVMM_IPE_2;
1209	}
1210
1211	return rc;
1212	}
1213
1214
1215	/**
1216	* Performs VM cleanup task as part of object destruction.
1217	*
1218	* @param pGVM The GVM pointer.
1219	*/
1220	static void gvmmR0CleanupVM(PGVM pGVM)
1221	{
1222	if ( pGVM->gvmm.s.fDoneVMMR0Init
1223	&& !pGVM->gvmm.s.fDoneVMMR0Term)
1224	{
1225	if ( pGVM->gvmm.s.VMMemObj != NIL_RTR0MEMOBJ
1226	&& RTR0MemObjAddress(pGVM->gvmm.s.VMMemObj) == pGVM->pVM)
1227	{
1228	LogFlow(("gvmmR0CleanupVM: Calling VMMR0TermVM\n"));
1229	VMMR0TermVM(pGVM->pVM, pGVM);
1230	}
1231	else
1232	AssertMsgFailed(("gvmmR0CleanupVM: VMMemObj=%p pVM=%p\n", pGVM->gvmm.s.VMMemObj, pGVM->pVM));
1233	}
1234
1235	GMMR0CleanupVM(pGVM);
1236	}
1237
1238
1239	/**
1240	* @callback_method_impl{FNSUPDRVDESTRUCTOR,VM handle destructor}
1241	*
1242	* pvUser1 is the GVM instance pointer.
1243	* pvUser2 is the handle pointer.
1244	*/
1245	static DECLCALLBACK(void) gvmmR0HandleObjDestructor(void pvObj, void pvUser1, void *pvUser2)
1246	{
1247	LogFlow(("gvmmR0HandleObjDestructor: %p %p %p\n", pvObj, pvUser1, pvUser2));
1248
1249	NOREF(pvObj);
1250
1251	/*
1252	* Some quick, paranoid, input validation.
1253	*/
1254	PGVMHANDLE pHandle = (PGVMHANDLE)pvUser2;
1255	AssertPtr(pHandle);
1256	PGVMM pGVMM = (PGVMM)pvUser1;
1257	Assert(pGVMM == g_pGVMM);
1258	const uint16_t iHandle = pHandle - &pGVMM->aHandles[0];
1259	if ( !iHandle
1260	\|\| iHandle >= RT_ELEMENTS(pGVMM->aHandles)
1261	\|\| iHandle != pHandle->iSelf)
1262	{
1263	SUPR0Printf("GVM: handle %d is out of range or corrupt (iSelf=%d)!\n", iHandle, pHandle->iSelf);
1264	return;
1265	}
1266
1267	int rc = gvmmR0CreateDestroyLock(pGVMM);
1268	AssertRC(rc);
1269	rc = GVMMR0_USED_EXCLUSIVE_LOCK(pGVMM);
1270	AssertRC(rc);
1271
1272	/*
1273	* This is a tad slow but a doubly linked list is too much hassle.
1274	*/
1275	if (RT_UNLIKELY(pHandle->iNext >= RT_ELEMENTS(pGVMM->aHandles)))
1276	{
1277	SUPR0Printf("GVM: used list index %d is out of range!\n", pHandle->iNext);
1278	GVMMR0_USED_EXCLUSIVE_UNLOCK(pGVMM);
1279	gvmmR0CreateDestroyUnlock(pGVMM);
1280	return;
1281	}
1282
1283	if (pGVMM->iUsedHead == iHandle)
1284	pGVMM->iUsedHead = pHandle->iNext;
1285	else
1286	{
1287	uint16_t iPrev = pGVMM->iUsedHead;
1288	int c = RT_ELEMENTS(pGVMM->aHandles) + 2;
1289	while (iPrev)
1290	{
1291	if (RT_UNLIKELY(iPrev >= RT_ELEMENTS(pGVMM->aHandles)))
1292	{
1293	SUPR0Printf("GVM: used list index %d is out of range!\n", iPrev);
1294	GVMMR0_USED_EXCLUSIVE_UNLOCK(pGVMM);
1295	gvmmR0CreateDestroyUnlock(pGVMM);
1296	return;
1297	}
1298	if (RT_UNLIKELY(c-- <= 0))
1299	{
1300	iPrev = 0;
1301	break;
1302	}
1303
1304	if (pGVMM->aHandles[iPrev].iNext == iHandle)
1305	break;
1306	iPrev = pGVMM->aHandles[iPrev].iNext;
1307	}
1308	if (!iPrev)
1309	{
1310	SUPR0Printf("GVM: can't find the handle previous previous of %d!\n", pHandle->iSelf);
1311	GVMMR0_USED_EXCLUSIVE_UNLOCK(pGVMM);
1312	gvmmR0CreateDestroyUnlock(pGVMM);
1313	return;
1314	}
1315
1316	Assert(pGVMM->aHandles[iPrev].iNext == iHandle);
1317	pGVMM->aHandles[iPrev].iNext = pHandle->iNext;
1318	}
1319	pHandle->iNext = 0;
1320	pGVMM->cVMs--;
1321
1322	/*
1323	* Do the global cleanup round.
1324	*/
1325	PGVM pGVM = pHandle->pGVM;
1326	if ( VALID_PTR(pGVM)
1327	&& pGVM->u32Magic == GVM_MAGIC)
1328	{
1329	pGVMM->cEMTs -= pGVM->cCpus;
1330	GVMMR0_USED_EXCLUSIVE_UNLOCK(pGVMM);
1331
1332	gvmmR0CleanupVM(pGVM);
1333
1334	/*
1335	* Do the GVMM cleanup - must be done last.
1336	*/
1337	/* The VM and VM pages mappings/allocations. */
1338	if (pGVM->gvmm.s.VMPagesMapObj != NIL_RTR0MEMOBJ)
1339	{
1340	rc = RTR0MemObjFree(pGVM->gvmm.s.VMPagesMapObj, false /* fFreeMappings */); AssertRC(rc);
1341	pGVM->gvmm.s.VMPagesMapObj = NIL_RTR0MEMOBJ;
1342	}
1343
1344	if (pGVM->gvmm.s.VMMapObj != NIL_RTR0MEMOBJ)
1345	{
1346	rc = RTR0MemObjFree(pGVM->gvmm.s.VMMapObj, false /* fFreeMappings */); AssertRC(rc);
1347	pGVM->gvmm.s.VMMapObj = NIL_RTR0MEMOBJ;
1348	}
1349
1350	if (pGVM->gvmm.s.VMPagesMemObj != NIL_RTR0MEMOBJ)
1351	{
1352	rc = RTR0MemObjFree(pGVM->gvmm.s.VMPagesMemObj, false /* fFreeMappings */); AssertRC(rc);
1353	pGVM->gvmm.s.VMPagesMemObj = NIL_RTR0MEMOBJ;
1354	}
1355
1356	if (pGVM->gvmm.s.VMMemObj != NIL_RTR0MEMOBJ)
1357	{
1358	rc = RTR0MemObjFree(pGVM->gvmm.s.VMMemObj, false /* fFreeMappings */); AssertRC(rc);
1359	pGVM->gvmm.s.VMMemObj = NIL_RTR0MEMOBJ;
1360	}
1361
1362	for (VMCPUID i = 0; i < pGVM->cCpus; i++)
1363	{
1364	if (pGVM->aCpus[i].gvmm.s.HaltEventMulti != NIL_RTSEMEVENTMULTI)
1365	{
1366	rc = RTSemEventMultiDestroy(pGVM->aCpus[i].gvmm.s.HaltEventMulti); AssertRC(rc);
1367	pGVM->aCpus[i].gvmm.s.HaltEventMulti = NIL_RTSEMEVENTMULTI;
1368	}
1369	}
1370
1371	/* the GVM structure itself. */
1372	pGVM->u32Magic \|= UINT32_C(0x80000000);
1373	RTMemFree(pGVM);
1374
1375	/* Re-acquire the UsedLock before freeing the handle since we're updating handle fields. */
1376	rc = GVMMR0_USED_EXCLUSIVE_LOCK(pGVMM);
1377	AssertRC(rc);
1378	}
1379	/* else: GVMMR0CreateVM cleanup. */
1380
1381	/*
1382	* Free the handle.
1383	*/
1384	pHandle->iNext = pGVMM->iFreeHead;
1385	pGVMM->iFreeHead = iHandle;
1386	ASMAtomicWriteNullPtr(&pHandle->pGVM);
1387	ASMAtomicWriteNullPtr(&pHandle->pVM);
1388	ASMAtomicWriteNullPtr(&pHandle->pvObj);
1389	ASMAtomicWriteNullPtr(&pHandle->pSession);
1390	ASMAtomicWriteHandle(&pHandle->hEMT0, NIL_RTNATIVETHREAD);
1391	ASMAtomicWriteU32(&pHandle->ProcId, NIL_RTPROCESS);
1392
1393	GVMMR0_USED_EXCLUSIVE_UNLOCK(pGVMM);
1394	gvmmR0CreateDestroyUnlock(pGVMM);
1395	LogFlow(("gvmmR0HandleObjDestructor: returns\n"));
1396	}
1397
1398
1399	/**
1400	* Registers the calling thread as the EMT of a Virtual CPU.
1401	*
1402	* Note that VCPU 0 is automatically registered during VM creation.
1403	*
1404	* @returns VBox status code
1405	* @param pVM The cross context VM structure.
1406	* @param idCpu VCPU id.
1407	*/
1408	GVMMR0DECL(int) GVMMR0RegisterVCpu(PVM pVM, VMCPUID idCpu)
1409	{
1410	AssertReturn(idCpu != 0, VERR_NOT_OWNER);
1411
1412	/*
1413	* Validate the VM structure, state and handle.
1414	*/
1415	PGVM pGVM;
1416	PGVMM pGVMM;
1417	int rc = gvmmR0ByVM(pVM, &pGVM, &pGVMM, false /* fTakeUsedLock /); /* @todo take lock here. */
1418	if (RT_FAILURE(rc))
1419	return rc;
1420
1421	AssertReturn(idCpu < pGVM->cCpus, VERR_INVALID_CPU_ID);
1422	AssertReturn(pGVM->aCpus[idCpu].hEMT == NIL_RTNATIVETHREAD, VERR_ACCESS_DENIED);
1423	Assert(pGVM->cCpus == pVM->cCpus);
1424	Assert(pVM->aCpus[idCpu].hNativeThreadR0 == NIL_RTNATIVETHREAD);
1425
1426	pVM->aCpus[idCpu].hNativeThreadR0 = pGVM->aCpus[idCpu].hEMT = RTThreadNativeSelf();
1427
1428	return VMMR0ThreadCtxHookCreateForEmt(&pVM->aCpus[idCpu]);
1429	}
1430
1431
1432	/**
1433	* Lookup a GVM structure by its handle.
1434	*
1435	* @returns The GVM pointer on success, NULL on failure.
1436	* @param hGVM The global VM handle. Asserts on bad handle.
1437	*/
1438	GVMMR0DECL(PGVM) GVMMR0ByHandle(uint32_t hGVM)
1439	{
1440	PGVMM pGVMM;
1441	GVMM_GET_VALID_INSTANCE(pGVMM, NULL);
1442
1443	/*
1444	* Validate.
1445	*/
1446	AssertReturn(hGVM != NIL_GVM_HANDLE, NULL);
1447	AssertReturn(hGVM < RT_ELEMENTS(pGVMM->aHandles), NULL);
1448
1449	/*
1450	* Look it up.
1451	*/
1452	PGVMHANDLE pHandle = &pGVMM->aHandles[hGVM];
1453	AssertPtrReturn(pHandle->pVM, NULL);
1454	AssertPtrReturn(pHandle->pvObj, NULL);
1455	PGVM pGVM = pHandle->pGVM;
1456	AssertPtrReturn(pGVM, NULL);
1457	AssertReturn(pGVM->pVM == pHandle->pVM, NULL);
1458
1459	return pHandle->pGVM;
1460	}
1461
1462
1463	/**
1464	* Lookup a GVM structure by the shared VM structure.
1465	*
1466	* The calling thread must be in the same process as the VM. All current lookups
1467	* are by threads inside the same process, so this will not be an issue.
1468	*
1469	* @returns VBox status code.
1470	* @param pVM The cross context VM structure.
1471	* @param ppGVM Where to store the GVM pointer.
1472	* @param ppGVMM Where to store the pointer to the GVMM instance data.
1473	* @param fTakeUsedLock Whether to take the used lock or not. We take it in
1474	* shared mode when requested.
1475	*
1476	* Be very careful if not taking the lock as it's
1477	* possible that the VM will disappear then!
1478	*
1479	* @remark This will not assert on an invalid pVM but try return silently.
1480	*/
1481	static int gvmmR0ByVM(PVM pVM, PGVM ppGVM, PGVMM ppGVMM, bool fTakeUsedLock)
1482	{
1483	RTPROCESS ProcId = RTProcSelf();
1484	PGVMM pGVMM;
1485	GVMM_GET_VALID_INSTANCE(pGVMM, VERR_GVMM_INSTANCE);
1486
1487	/*
1488	* Validate.
1489	*/
1490	if (RT_UNLIKELY( !VALID_PTR(pVM)
1491	\|\| ((uintptr_t)pVM & PAGE_OFFSET_MASK)))
1492	return VERR_INVALID_POINTER;
1493	if (RT_UNLIKELY( pVM->enmVMState < VMSTATE_CREATING
1494	\|\| pVM->enmVMState >= VMSTATE_TERMINATED))
1495	return VERR_INVALID_POINTER;
1496
1497	uint16_t hGVM = pVM->hSelf;
1498	if (RT_UNLIKELY( hGVM == NIL_GVM_HANDLE
1499	\|\| hGVM >= RT_ELEMENTS(pGVMM->aHandles)))
1500	return VERR_INVALID_HANDLE;
1501
1502	/*
1503	* Look it up.
1504	*/
1505	PGVMHANDLE pHandle = &pGVMM->aHandles[hGVM];
1506	PGVM pGVM;
1507	if (fTakeUsedLock)
1508	{
1509	int rc = GVMMR0_USED_SHARED_LOCK(pGVMM);
1510	AssertRCReturn(rc, rc);
1511
1512	pGVM = pHandle->pGVM;
1513	if (RT_UNLIKELY( pHandle->pVM != pVM
1514	\|\| pHandle->ProcId != ProcId
1515	\|\| !VALID_PTR(pHandle->pvObj)
1516	\|\| !VALID_PTR(pGVM)
1517	\|\| pGVM->pVM != pVM))
1518	{
1519	GVMMR0_USED_SHARED_UNLOCK(pGVMM);
1520	return VERR_INVALID_HANDLE;
1521	}
1522	}
1523	else
1524	{
1525	if (RT_UNLIKELY(pHandle->pVM != pVM))
1526	return VERR_INVALID_HANDLE;
1527	if (RT_UNLIKELY(pHandle->ProcId != ProcId))
1528	return VERR_INVALID_HANDLE;
1529	if (RT_UNLIKELY(!VALID_PTR(pHandle->pvObj)))
1530	return VERR_INVALID_HANDLE;
1531
1532	pGVM = pHandle->pGVM;
1533	if (RT_UNLIKELY(!VALID_PTR(pGVM)))
1534	return VERR_INVALID_HANDLE;
1535	if (RT_UNLIKELY(pGVM->pVM != pVM))
1536	return VERR_INVALID_HANDLE;
1537	}
1538
1539	*ppGVM = pGVM;
1540	*ppGVMM = pGVMM;
1541	return VINF_SUCCESS;
1542	}
1543
1544
1545	/**
1546	* Lookup a GVM structure by the shared VM structure.
1547	*
1548	* @returns VBox status code.
1549	* @param pVM The cross context VM structure.
1550	* @param ppGVM Where to store the GVM pointer.
1551	*
1552	* @remark This will not take the 'used'-lock because it doesn't do
1553	* nesting and this function will be used from under the lock.
1554	* Update: This is no longer true. Consider taking the lock in shared
1555	* mode!
1556	*/
1557	GVMMR0DECL(int) GVMMR0ByVM(PVM pVM, PGVM *ppGVM)
1558	{
1559	PGVMM pGVMM;
1560	return gvmmR0ByVM(pVM, ppGVM, &pGVMM, false /* fTakeUsedLock */);
1561	}
1562
1563
1564	/**
1565	* Lookup a GVM structure by the shared VM structure and ensuring that the
1566	* caller is an EMT thread.
1567	*
1568	* @returns VBox status code.
1569	* @param pVM The cross context VM structure.
1570	* @param idCpu The Virtual CPU ID of the calling EMT.
1571	* @param ppGVM Where to store the GVM pointer.
1572	* @param ppGVMM Where to store the pointer to the GVMM instance data.
1573	* @thread EMT
1574	*
1575	* @remark This will assert in all failure paths.
1576	*/
1577	static int gvmmR0ByVMAndEMT(PVM pVM, VMCPUID idCpu, PGVM ppGVM, PGVMM ppGVMM)
1578	{
1579	PGVMM pGVMM;
1580	GVMM_GET_VALID_INSTANCE(pGVMM, VERR_GVMM_INSTANCE);
1581
1582	/*
1583	* Validate.
1584	*/
1585	AssertPtrReturn(pVM, VERR_INVALID_POINTER);
1586	AssertReturn(!((uintptr_t)pVM & PAGE_OFFSET_MASK), VERR_INVALID_POINTER);
1587
1588	uint16_t hGVM = pVM->hSelf;
1589	AssertReturn(hGVM != NIL_GVM_HANDLE, VERR_INVALID_HANDLE);
1590	AssertReturn(hGVM < RT_ELEMENTS(pGVMM->aHandles), VERR_INVALID_HANDLE);
1591
1592	/*
1593	* Look it up.
1594	*/
1595	PGVMHANDLE pHandle = &pGVMM->aHandles[hGVM];
1596	AssertReturn(pHandle->pVM == pVM, VERR_NOT_OWNER);
1597	RTPROCESS ProcId = RTProcSelf();
1598	AssertReturn(pHandle->ProcId == ProcId, VERR_NOT_OWNER);
1599	AssertPtrReturn(pHandle->pvObj, VERR_NOT_OWNER);
1600
1601	PGVM pGVM = pHandle->pGVM;
1602	AssertPtrReturn(pGVM, VERR_NOT_OWNER);
1603	AssertReturn(pGVM->pVM == pVM, VERR_NOT_OWNER);
1604	RTNATIVETHREAD hAllegedEMT = RTThreadNativeSelf();
1605	AssertReturn(idCpu < pGVM->cCpus, VERR_INVALID_CPU_ID);
1606	AssertReturn(pGVM->aCpus[idCpu].hEMT == hAllegedEMT, VERR_NOT_OWNER);
1607
1608	*ppGVM = pGVM;
1609	*ppGVMM = pGVMM;
1610	return VINF_SUCCESS;
1611	}
1612
1613
1614	/**
1615	* Lookup a GVM structure by the shared VM structure
1616	* and ensuring that the caller is the EMT thread.
1617	*
1618	* @returns VBox status code.
1619	* @param pVM The cross context VM structure.
1620	* @param idCpu The Virtual CPU ID of the calling EMT.
1621	* @param ppGVM Where to store the GVM pointer.
1622	* @thread EMT
1623	*/
1624	GVMMR0DECL(int) GVMMR0ByVMAndEMT(PVM pVM, VMCPUID idCpu, PGVM *ppGVM)
1625	{
1626	AssertPtrReturn(ppGVM, VERR_INVALID_POINTER);
1627	PGVMM pGVMM;
1628	return gvmmR0ByVMAndEMT(pVM, idCpu, ppGVM, &pGVMM);
1629	}
1630
1631
1632	/**
1633	* Lookup a VM by its global handle.
1634	*
1635	* @returns Pointer to the VM on success, NULL on failure.
1636	* @param hGVM The global VM handle. Asserts on bad handle.
1637	*/
1638	GVMMR0DECL(PVM) GVMMR0GetVMByHandle(uint32_t hGVM)
1639	{
1640	PGVM pGVM = GVMMR0ByHandle(hGVM);
1641	return pGVM ? pGVM->pVM : NULL;
1642	}
1643
1644
1645	/**
1646	* Looks up the VM belonging to the specified EMT thread.
1647	*
1648	* This is used by the assertion machinery in VMMR0.cpp to avoid causing
1649	* unnecessary kernel panics when the EMT thread hits an assertion. The
1650	* call may or not be an EMT thread.
1651	*
1652	* @returns Pointer to the VM on success, NULL on failure.
1653	* @param hEMT The native thread handle of the EMT.
1654	* NIL_RTNATIVETHREAD means the current thread
1655	*/
1656	GVMMR0DECL(PVM) GVMMR0GetVMByEMT(RTNATIVETHREAD hEMT)
1657	{
1658	/*
1659	* No Assertions here as we're usually called in a AssertMsgN or
1660	* RTAssert* context.
1661	*/
1662	PGVMM pGVMM = g_pGVMM;
1663	if ( !VALID_PTR(pGVMM)
1664	\|\| pGVMM->u32Magic != GVMM_MAGIC)
1665	return NULL;
1666
1667	if (hEMT == NIL_RTNATIVETHREAD)
1668	hEMT = RTThreadNativeSelf();
1669	RTPROCESS ProcId = RTProcSelf();
1670
1671	/*
1672	* Search the handles in a linear fashion as we don't dare to take the lock (assert).
1673	*/
1674	for (unsigned i = 1; i < RT_ELEMENTS(pGVMM->aHandles); i++)
1675	{
1676	if ( pGVMM->aHandles[i].iSelf == i
1677	&& pGVMM->aHandles[i].ProcId == ProcId
1678	&& VALID_PTR(pGVMM->aHandles[i].pvObj)
1679	&& VALID_PTR(pGVMM->aHandles[i].pVM)
1680	&& VALID_PTR(pGVMM->aHandles[i].pGVM))
1681	{
1682	if (pGVMM->aHandles[i].hEMT0 == hEMT)
1683	return pGVMM->aHandles[i].pVM;
1684
1685	/* This is fearly safe with the current process per VM approach. */
1686	PGVM pGVM = pGVMM->aHandles[i].pGVM;
1687	VMCPUID const cCpus = pGVM->cCpus;
1688	if ( cCpus < 1
1689	\|\| cCpus > VMM_MAX_CPU_COUNT)
1690	continue;
1691	for (VMCPUID idCpu = 1; idCpu < cCpus; idCpu++)
1692	if (pGVM->aCpus[idCpu].hEMT == hEMT)
1693	return pGVMM->aHandles[i].pVM;
1694	}
1695	}
1696	return NULL;
1697	}
1698
1699
1700	/**
1701	* This is will wake up expired and soon-to-be expired VMs.
1702	*
1703	* @returns Number of VMs that has been woken up.
1704	* @param pGVMM Pointer to the GVMM instance data.
1705	* @param u64Now The current time.
1706	*/
1707	static unsigned gvmmR0SchedDoWakeUps(PGVMM pGVMM, uint64_t u64Now)
1708	{
1709	/*
1710	* Skip this if we've got disabled because of high resolution wakeups or by
1711	* the user.
1712	*/
1713	if (!pGVMM->fDoEarlyWakeUps)
1714	return 0;
1715
1716	/** @todo Rewrite this algorithm. See performance defect XYZ. */
1717
1718	/*
1719	* A cheap optimization to stop wasting so much time here on big setups.
1720	*/
1721	const uint64_t uNsEarlyWakeUp2 = u64Now + pGVMM->nsEarlyWakeUp2;
1722	if ( pGVMM->cHaltedEMTs == 0
1723	\|\| uNsEarlyWakeUp2 > pGVMM->uNsNextEmtWakeup)
1724	return 0;
1725
1726	/*
1727	* Only one thread doing this at a time.
1728	*/
1729	if (!ASMAtomicCmpXchgBool(&pGVMM->fDoingEarlyWakeUps, true, false))
1730	return 0;
1731
1732	/*
1733	* The first pass will wake up VMs which have actually expired
1734	* and look for VMs that should be woken up in the 2nd and 3rd passes.
1735	*/
1736	const uint64_t uNsEarlyWakeUp1 = u64Now + pGVMM->nsEarlyWakeUp1;
1737	uint64_t u64Min = UINT64_MAX;
1738	unsigned cWoken = 0;
1739	unsigned cHalted = 0;
1740	unsigned cTodo2nd = 0;
1741	unsigned cTodo3rd = 0;
1742	for (unsigned i = pGVMM->iUsedHead, cGuard = 0;
1743	i != NIL_GVM_HANDLE && i < RT_ELEMENTS(pGVMM->aHandles);
1744	i = pGVMM->aHandles[i].iNext)
1745	{
1746	PGVM pCurGVM = pGVMM->aHandles[i].pGVM;
1747	if ( VALID_PTR(pCurGVM)
1748	&& pCurGVM->u32Magic == GVM_MAGIC)
1749	{
1750	for (VMCPUID idCpu = 0; idCpu < pCurGVM->cCpus; idCpu++)
1751	{
1752	PGVMCPU pCurGVCpu = &pCurGVM->aCpus[idCpu];
1753	uint64_t u64 = ASMAtomicUoReadU64(&pCurGVCpu->gvmm.s.u64HaltExpire);
1754	if (u64)
1755	{
1756	if (u64 <= u64Now)
1757	{
1758	if (ASMAtomicXchgU64(&pCurGVCpu->gvmm.s.u64HaltExpire, 0))
1759	{
1760	int rc = RTSemEventMultiSignal(pCurGVCpu->gvmm.s.HaltEventMulti);
1761	AssertRC(rc);
1762	cWoken++;
1763	}
1764	}
1765	else
1766	{
1767	cHalted++;
1768	if (u64 <= uNsEarlyWakeUp1)
1769	cTodo2nd++;
1770	else if (u64 <= uNsEarlyWakeUp2)
1771	cTodo3rd++;
1772	else if (u64 < u64Min)
1773	u64 = u64Min;
1774	}
1775	}
1776	}
1777	}
1778	AssertLogRelBreak(cGuard++ < RT_ELEMENTS(pGVMM->aHandles));
1779	}
1780
1781	if (cTodo2nd)
1782	{
1783	for (unsigned i = pGVMM->iUsedHead, cGuard = 0;
1784	i != NIL_GVM_HANDLE && i < RT_ELEMENTS(pGVMM->aHandles);
1785	i = pGVMM->aHandles[i].iNext)
1786	{
1787	PGVM pCurGVM = pGVMM->aHandles[i].pGVM;
1788	if ( VALID_PTR(pCurGVM)
1789	&& pCurGVM->u32Magic == GVM_MAGIC)
1790	{
1791	for (VMCPUID idCpu = 0; idCpu < pCurGVM->cCpus; idCpu++)
1792	{
1793	PGVMCPU pCurGVCpu = &pCurGVM->aCpus[idCpu];
1794	uint64_t u64 = ASMAtomicUoReadU64(&pCurGVCpu->gvmm.s.u64HaltExpire);
1795	if ( u64
1796	&& u64 <= uNsEarlyWakeUp1)
1797	{
1798	if (ASMAtomicXchgU64(&pCurGVCpu->gvmm.s.u64HaltExpire, 0))
1799	{
1800	int rc = RTSemEventMultiSignal(pCurGVCpu->gvmm.s.HaltEventMulti);
1801	AssertRC(rc);
1802	cWoken++;
1803	}
1804	}
1805	}
1806	}
1807	AssertLogRelBreak(cGuard++ < RT_ELEMENTS(pGVMM->aHandles));
1808	}
1809	}
1810
1811	if (cTodo3rd)
1812	{
1813	for (unsigned i = pGVMM->iUsedHead, cGuard = 0;
1814	i != NIL_GVM_HANDLE && i < RT_ELEMENTS(pGVMM->aHandles);
1815	i = pGVMM->aHandles[i].iNext)
1816	{
1817	PGVM pCurGVM = pGVMM->aHandles[i].pGVM;
1818	if ( VALID_PTR(pCurGVM)
1819	&& pCurGVM->u32Magic == GVM_MAGIC)
1820	{
1821	for (VMCPUID idCpu = 0; idCpu < pCurGVM->cCpus; idCpu++)
1822	{
1823	PGVMCPU pCurGVCpu = &pCurGVM->aCpus[idCpu];
1824	uint64_t u64 = ASMAtomicUoReadU64(&pCurGVCpu->gvmm.s.u64HaltExpire);
1825	if ( u64
1826	&& u64 <= uNsEarlyWakeUp2)
1827	{
1828	if (ASMAtomicXchgU64(&pCurGVCpu->gvmm.s.u64HaltExpire, 0))
1829	{
1830	int rc = RTSemEventMultiSignal(pCurGVCpu->gvmm.s.HaltEventMulti);
1831	AssertRC(rc);
1832	cWoken++;
1833	}
1834	}
1835	}
1836	}
1837	AssertLogRelBreak(cGuard++ < RT_ELEMENTS(pGVMM->aHandles));
1838	}
1839	}
1840
1841	/*
1842	* Set the minimum value.
1843	*/
1844	pGVMM->uNsNextEmtWakeup = u64Min;
1845
1846	ASMAtomicWriteBool(&pGVMM->fDoingEarlyWakeUps, false);
1847	return cWoken;
1848	}
1849
1850
1851	/**
1852	* Halt the EMT thread.
1853	*
1854	* @returns VINF_SUCCESS normal wakeup (timeout or kicked by other thread).
1855	* VERR_INTERRUPTED if a signal was scheduled for the thread.
1856	* @param pVM The cross context VM structure.
1857	* @param idCpu The Virtual CPU ID of the calling EMT.
1858	* @param u64ExpireGipTime The time for the sleep to expire expressed as GIP time.
1859	* @thread EMT(idCpu).
1860	*/
1861	GVMMR0DECL(int) GVMMR0SchedHalt(PVM pVM, VMCPUID idCpu, uint64_t u64ExpireGipTime)
1862	{
1863	LogFlow(("GVMMR0SchedHalt: pVM=%p\n", pVM));
1864	GVMM_CHECK_SMAP_SETUP();
1865	GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
1866
1867	/*
1868	* Validate the VM structure, state and handle.
1869	*/
1870	PGVM pGVM;
1871	PGVMM pGVMM;
1872	int rc = gvmmR0ByVMAndEMT(pVM, idCpu, &pGVM, &pGVMM);
1873	if (RT_FAILURE(rc))
1874	return rc;
1875	pGVM->gvmm.s.StatsSched.cHaltCalls++;
1876	GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
1877
1878	PGVMCPU pCurGVCpu = &pGVM->aCpus[idCpu];
1879	Assert(!pCurGVCpu->gvmm.s.u64HaltExpire);
1880
1881	/*
1882	* If we're doing early wake-ups, we must take the UsedList lock before we
1883	* start querying the current time.
1884	* Note! Interrupts must NOT be disabled at this point because we ask for GIP time!
1885	*/
1886	bool const fDoEarlyWakeUps = pGVMM->fDoEarlyWakeUps;
1887	if (fDoEarlyWakeUps)
1888	{
1889	rc = GVMMR0_USED_SHARED_LOCK(pGVMM); AssertRC(rc);
1890	GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
1891	}
1892
1893	pCurGVCpu->gvmm.s.iCpuEmt = ASMGetApicId();
1894
1895	/* GIP hack: We might are frequently sleeping for short intervals where the
1896	difference between GIP and system time matters on systems with high resolution
1897	system time. So, convert the input from GIP to System time in that case. */
1898	Assert(ASMGetFlags() & X86_EFL_IF);
1899	const uint64_t u64NowSys = RTTimeSystemNanoTS();
1900	const uint64_t u64NowGip = RTTimeNanoTS();
1901	GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
1902
1903	if (fDoEarlyWakeUps)
1904	{
1905	pGVM->gvmm.s.StatsSched.cHaltWakeUps += gvmmR0SchedDoWakeUps(pGVMM, u64NowGip);
1906	GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
1907	}
1908
1909	/*
1910	* Go to sleep if we must...
1911	* Cap the sleep time to 1 second to be on the safe side.
1912	*/
1913	uint64_t cNsInterval = u64ExpireGipTime - u64NowGip;
1914	if ( u64NowGip < u64ExpireGipTime
1915	&& cNsInterval >= (pGVMM->cEMTs > pGVMM->cEMTsMeansCompany
1916	? pGVMM->nsMinSleepCompany
1917	: pGVMM->nsMinSleepAlone))
1918	{
1919	pGVM->gvmm.s.StatsSched.cHaltBlocking++;
1920	if (cNsInterval > RT_NS_1SEC)
1921	u64ExpireGipTime = u64NowGip + RT_NS_1SEC;
1922	ASMAtomicWriteU64(&pCurGVCpu->gvmm.s.u64HaltExpire, u64ExpireGipTime);
1923	ASMAtomicIncU32(&pGVMM->cHaltedEMTs);
1924	if (fDoEarlyWakeUps)
1925	{
1926	if (u64ExpireGipTime < pGVMM->uNsNextEmtWakeup)
1927	pGVMM->uNsNextEmtWakeup = u64ExpireGipTime;
1928	GVMMR0_USED_SHARED_UNLOCK(pGVMM);
1929	}
1930	GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
1931
1932	rc = RTSemEventMultiWaitEx(pCurGVCpu->gvmm.s.HaltEventMulti,
1933	RTSEMWAIT_FLAGS_ABSOLUTE \| RTSEMWAIT_FLAGS_NANOSECS \| RTSEMWAIT_FLAGS_INTERRUPTIBLE,
1934	u64NowGip > u64NowSys ? u64ExpireGipTime : u64NowSys + cNsInterval);
1935	GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
1936
1937	ASMAtomicWriteU64(&pCurGVCpu->gvmm.s.u64HaltExpire, 0);
1938	ASMAtomicDecU32(&pGVMM->cHaltedEMTs);
1939
1940	/* Reset the semaphore to try prevent a few false wake-ups. */
1941	if (rc == VINF_SUCCESS)
1942	{
1943	RTSemEventMultiReset(pCurGVCpu->gvmm.s.HaltEventMulti);
1944	GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
1945	}
1946	else if (rc == VERR_TIMEOUT)
1947	{
1948	pGVM->gvmm.s.StatsSched.cHaltTimeouts++;
1949	rc = VINF_SUCCESS;
1950	}
1951	}
1952	else
1953	{
1954	pGVM->gvmm.s.StatsSched.cHaltNotBlocking++;
1955	if (fDoEarlyWakeUps)
1956	GVMMR0_USED_SHARED_UNLOCK(pGVMM);
1957	GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
1958	RTSemEventMultiReset(pCurGVCpu->gvmm.s.HaltEventMulti);
1959	GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
1960	}
1961
1962	return rc;
1963	}
1964
1965
1966	/**
1967	* Worker for GVMMR0SchedWakeUp and GVMMR0SchedWakeUpAndPokeCpus that wakes up
1968	* the a sleeping EMT.
1969	*
1970	* @retval VINF_SUCCESS if successfully woken up.
1971	* @retval VINF_GVM_NOT_BLOCKED if the EMT wasn't blocked.
1972	*
1973	* @param pGVM The global (ring-0) VM structure.
1974	* @param pGVCpu The global (ring-0) VCPU structure.
1975	*/
1976	DECLINLINE(int) gvmmR0SchedWakeUpOne(PGVM pGVM, PGVMCPU pGVCpu)
1977	{
1978	pGVM->gvmm.s.StatsSched.cWakeUpCalls++;
1979
1980	/*
1981	* Signal the semaphore regardless of whether it's current blocked on it.
1982	*
1983	* The reason for this is that there is absolutely no way we can be 100%
1984	* certain that it isn't about go to go to sleep on it and just got
1985	* delayed a bit en route. So, we will always signal the semaphore when
1986	* the it is flagged as halted in the VMM.
1987	*/
1988	/** @todo we can optimize some of that by means of the pVCpu->enmState now. */
1989	int rc;
1990	if (pGVCpu->gvmm.s.u64HaltExpire)
1991	{
1992	rc = VINF_SUCCESS;
1993	ASMAtomicWriteU64(&pGVCpu->gvmm.s.u64HaltExpire, 0);
1994	}
1995	else
1996	{
1997	rc = VINF_GVM_NOT_BLOCKED;
1998	pGVM->gvmm.s.StatsSched.cWakeUpNotHalted++;
1999	}
2000
2001	int rc2 = RTSemEventMultiSignal(pGVCpu->gvmm.s.HaltEventMulti);
2002	AssertRC(rc2);
2003
2004	return rc;
2005	}
2006
2007
2008	/**
2009	* Wakes up the halted EMT thread so it can service a pending request.
2010	*
2011	* @returns VBox status code.
2012	* @retval VINF_SUCCESS if successfully woken up.
2013	* @retval VINF_GVM_NOT_BLOCKED if the EMT wasn't blocked.
2014	*
2015	* @param pVM The cross context VM structure.
2016	* @param idCpu The Virtual CPU ID of the EMT to wake up.
2017	* @param fTakeUsedLock Take the used lock or not
2018	* @thread Any but EMT.
2019	*/
2020	GVMMR0DECL(int) GVMMR0SchedWakeUpEx(PVM pVM, VMCPUID idCpu, bool fTakeUsedLock)
2021	{
2022	GVMM_CHECK_SMAP_SETUP();
2023	GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
2024
2025	/*
2026	* Validate input and take the UsedLock.
2027	*/
2028	PGVM pGVM;
2029	PGVMM pGVMM;
2030	int rc = gvmmR0ByVM(pVM, &pGVM, &pGVMM, fTakeUsedLock);
2031	GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
2032	if (RT_SUCCESS(rc))
2033	{
2034	if (idCpu < pGVM->cCpus)
2035	{
2036	/*
2037	* Do the actual job.
2038	*/
2039	rc = gvmmR0SchedWakeUpOne(pGVM, &pGVM->aCpus[idCpu]);
2040	GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
2041
2042	if (fTakeUsedLock && pGVMM->fDoEarlyWakeUps)
2043	{
2044	/*
2045	* While we're here, do a round of scheduling.
2046	*/
2047	Assert(ASMGetFlags() & X86_EFL_IF);
2048	const uint64_t u64Now = RTTimeNanoTS(); /* (GIP time) */
2049	pGVM->gvmm.s.StatsSched.cWakeUpWakeUps += gvmmR0SchedDoWakeUps(pGVMM, u64Now);
2050	GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
2051	}
2052	}
2053	else
2054	rc = VERR_INVALID_CPU_ID;
2055
2056	if (fTakeUsedLock)
2057	{
2058	int rc2 = GVMMR0_USED_SHARED_UNLOCK(pGVMM);
2059	AssertRC(rc2);
2060	GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
2061	}
2062	}
2063
2064	LogFlow(("GVMMR0SchedWakeUp: returns %Rrc\n", rc));
2065	return rc;
2066	}
2067
2068
2069	/**
2070	* Wakes up the halted EMT thread so it can service a pending request.
2071	*
2072	* @returns VBox status code.
2073	* @retval VINF_SUCCESS if successfully woken up.
2074	* @retval VINF_GVM_NOT_BLOCKED if the EMT wasn't blocked.
2075	*
2076	* @param pVM The cross context VM structure.
2077	* @param idCpu The Virtual CPU ID of the EMT to wake up.
2078	* @thread Any but EMT.
2079	*/
2080	GVMMR0DECL(int) GVMMR0SchedWakeUp(PVM pVM, VMCPUID idCpu)
2081	{
2082	return GVMMR0SchedWakeUpEx(pVM, idCpu, true /* fTakeUsedLock */);
2083	}
2084
2085	/**
2086	* Worker common to GVMMR0SchedPoke and GVMMR0SchedWakeUpAndPokeCpus that pokes
2087	* the Virtual CPU if it's still busy executing guest code.
2088	*
2089	* @returns VBox status code.
2090	* @retval VINF_SUCCESS if poked successfully.
2091	* @retval VINF_GVM_NOT_BUSY_IN_GC if the EMT wasn't busy in GC.
2092	*
2093	* @param pGVM The global (ring-0) VM structure.
2094	* @param pVCpu The cross context virtual CPU structure.
2095	*/
2096	DECLINLINE(int) gvmmR0SchedPokeOne(PGVM pGVM, PVMCPU pVCpu)
2097	{
2098	pGVM->gvmm.s.StatsSched.cPokeCalls++;
2099
2100	RTCPUID idHostCpu = pVCpu->idHostCpu;
2101	if ( idHostCpu == NIL_RTCPUID
2102	\|\| VMCPU_GET_STATE(pVCpu) != VMCPUSTATE_STARTED_EXEC)
2103	{
2104	pGVM->gvmm.s.StatsSched.cPokeNotBusy++;
2105	return VINF_GVM_NOT_BUSY_IN_GC;
2106	}
2107
2108	/* Note: this function is not implemented on Darwin and Linux (kernel < 2.6.19) */
2109	RTMpPokeCpu(idHostCpu);
2110	return VINF_SUCCESS;
2111	}
2112
2113	/**
2114	* Pokes an EMT if it's still busy running guest code.
2115	*
2116	* @returns VBox status code.
2117	* @retval VINF_SUCCESS if poked successfully.
2118	* @retval VINF_GVM_NOT_BUSY_IN_GC if the EMT wasn't busy in GC.
2119	*
2120	* @param pVM The cross context VM structure.
2121	* @param idCpu The ID of the virtual CPU to poke.
2122	* @param fTakeUsedLock Take the used lock or not
2123	*/
2124	GVMMR0DECL(int) GVMMR0SchedPokeEx(PVM pVM, VMCPUID idCpu, bool fTakeUsedLock)
2125	{
2126	/*
2127	* Validate input and take the UsedLock.
2128	*/
2129	PGVM pGVM;
2130	PGVMM pGVMM;
2131	int rc = gvmmR0ByVM(pVM, &pGVM, &pGVMM, fTakeUsedLock);
2132	if (RT_SUCCESS(rc))
2133	{
2134	if (idCpu < pGVM->cCpus)
2135	rc = gvmmR0SchedPokeOne(pGVM, &pVM->aCpus[idCpu]);
2136	else
2137	rc = VERR_INVALID_CPU_ID;
2138
2139	if (fTakeUsedLock)
2140	{
2141	int rc2 = GVMMR0_USED_SHARED_UNLOCK(pGVMM);
2142	AssertRC(rc2);
2143	}
2144	}
2145
2146	LogFlow(("GVMMR0SchedWakeUpAndPokeCpus: returns %Rrc\n", rc));
2147	return rc;
2148	}
2149
2150
2151	/**
2152	* Pokes an EMT if it's still busy running guest code.
2153	*
2154	* @returns VBox status code.
2155	* @retval VINF_SUCCESS if poked successfully.
2156	* @retval VINF_GVM_NOT_BUSY_IN_GC if the EMT wasn't busy in GC.
2157	*
2158	* @param pVM The cross context VM structure.
2159	* @param idCpu The ID of the virtual CPU to poke.
2160	*/
2161	GVMMR0DECL(int) GVMMR0SchedPoke(PVM pVM, VMCPUID idCpu)
2162	{
2163	return GVMMR0SchedPokeEx(pVM, idCpu, true /* fTakeUsedLock */);
2164	}
2165
2166
2167	/**
2168	* Wakes up a set of halted EMT threads so they can service pending request.
2169	*
2170	* @returns VBox status code, no informational stuff.
2171	*
2172	* @param pVM The cross context VM structure.
2173	* @param pSleepSet The set of sleepers to wake up.
2174	* @param pPokeSet The set of CPUs to poke.
2175	*/
2176	GVMMR0DECL(int) GVMMR0SchedWakeUpAndPokeCpus(PVM pVM, PCVMCPUSET pSleepSet, PCVMCPUSET pPokeSet)
2177	{
2178	AssertPtrReturn(pSleepSet, VERR_INVALID_POINTER);
2179	AssertPtrReturn(pPokeSet, VERR_INVALID_POINTER);
2180	GVMM_CHECK_SMAP_SETUP();
2181	GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
2182	RTNATIVETHREAD hSelf = RTThreadNativeSelf();
2183
2184	/*
2185	* Validate input and take the UsedLock.
2186	*/
2187	PGVM pGVM;
2188	PGVMM pGVMM;
2189	int rc = gvmmR0ByVM(pVM, &pGVM, &pGVMM, true /* fTakeUsedLock */);
2190	GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
2191	if (RT_SUCCESS(rc))
2192	{
2193	rc = VINF_SUCCESS;
2194	VMCPUID idCpu = pGVM->cCpus;
2195	while (idCpu-- > 0)
2196	{
2197	/* Don't try poke or wake up ourselves. */
2198	if (pGVM->aCpus[idCpu].hEMT == hSelf)
2199	continue;
2200
2201	/* just ignore errors for now. */
2202	if (VMCPUSET_IS_PRESENT(pSleepSet, idCpu))
2203	{
2204	gvmmR0SchedWakeUpOne(pGVM, &pGVM->aCpus[idCpu]);
2205	GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
2206	}
2207	else if (VMCPUSET_IS_PRESENT(pPokeSet, idCpu))
2208	{
2209	gvmmR0SchedPokeOne(pGVM, &pVM->aCpus[idCpu]);
2210	GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
2211	}
2212	}
2213
2214	int rc2 = GVMMR0_USED_SHARED_UNLOCK(pGVMM);
2215	AssertRC(rc2);
2216	GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
2217	}
2218
2219	LogFlow(("GVMMR0SchedWakeUpAndPokeCpus: returns %Rrc\n", rc));
2220	return rc;
2221	}
2222
2223
2224	/**
2225	* VMMR0 request wrapper for GVMMR0SchedWakeUpAndPokeCpus.
2226	*
2227	* @returns see GVMMR0SchedWakeUpAndPokeCpus.
2228	* @param pVM The cross context VM structure.
2229	* @param pReq Pointer to the request packet.
2230	*/
2231	GVMMR0DECL(int) GVMMR0SchedWakeUpAndPokeCpusReq(PVM pVM, PGVMMSCHEDWAKEUPANDPOKECPUSREQ pReq)
2232	{
2233	/*
2234	* Validate input and pass it on.
2235	*/
2236	AssertPtrReturn(pReq, VERR_INVALID_POINTER);
2237	AssertMsgReturn(pReq->Hdr.cbReq == sizeof(pReq), ("%#x != %#x\n", pReq->Hdr.cbReq, sizeof(pReq)), VERR_INVALID_PARAMETER);
2238
2239	return GVMMR0SchedWakeUpAndPokeCpus(pVM, &pReq->SleepSet, &pReq->PokeSet);
2240	}
2241
2242
2243
2244	/**
2245	* Poll the schedule to see if someone else should get a chance to run.
2246	*
2247	* This is a bit hackish and will not work too well if the machine is
2248	* under heavy load from non-VM processes.
2249	*
2250	* @returns VINF_SUCCESS if not yielded.
2251	* VINF_GVM_YIELDED if an attempt to switch to a different VM task was made.
2252	* @param pVM The cross context VM structure.
2253	* @param idCpu The Virtual CPU ID of the calling EMT.
2254	* @param fYield Whether to yield or not.
2255	* This is for when we're spinning in the halt loop.
2256	* @thread EMT(idCpu).
2257	*/
2258	GVMMR0DECL(int) GVMMR0SchedPoll(PVM pVM, VMCPUID idCpu, bool fYield)
2259	{
2260	/*
2261	* Validate input.
2262	*/
2263	PGVM pGVM;
2264	PGVMM pGVMM;
2265	int rc = gvmmR0ByVMAndEMT(pVM, idCpu, &pGVM, &pGVMM);
2266	if (RT_SUCCESS(rc))
2267	{
2268	/*
2269	* We currently only implement helping doing wakeups (fYield = false), so don't
2270	* bother taking the lock if gvmmR0SchedDoWakeUps is not going to do anything.
2271	*/
2272	if (!fYield && pGVMM->fDoEarlyWakeUps)
2273	{
2274	rc = GVMMR0_USED_SHARED_LOCK(pGVMM); AssertRC(rc);
2275	pGVM->gvmm.s.StatsSched.cPollCalls++;
2276
2277	Assert(ASMGetFlags() & X86_EFL_IF);
2278	const uint64_t u64Now = RTTimeNanoTS(); /* (GIP time) */
2279
2280	pGVM->gvmm.s.StatsSched.cPollWakeUps += gvmmR0SchedDoWakeUps(pGVMM, u64Now);
2281
2282	GVMMR0_USED_SHARED_UNLOCK(pGVMM);
2283	}
2284	/*
2285	* Not quite sure what we could do here...
2286	*/
2287	else if (fYield)
2288	rc = VERR_NOT_IMPLEMENTED; /** @todo implement this... */
2289	else
2290	rc = VINF_SUCCESS;
2291	}
2292
2293	LogFlow(("GVMMR0SchedWakeUp: returns %Rrc\n", rc));
2294	return rc;
2295	}
2296
2297
2298	#ifdef GVMM_SCHED_WITH_PPT
2299	/**
2300	* Timer callback for the periodic preemption timer.
2301	*
2302	* @param pTimer The timer handle.
2303	* @param pvUser Pointer to the per cpu structure.
2304	* @param iTick The current tick.
2305	*/
2306	static DECLCALLBACK(void) gvmmR0SchedPeriodicPreemptionTimerCallback(PRTTIMER pTimer, void *pvUser, uint64_t iTick)
2307	{
2308	PGVMMHOSTCPU pCpu = (PGVMMHOSTCPU)pvUser;
2309	NOREF(pTimer); NOREF(iTick);
2310
2311	/*
2312	* Termination check
2313	*/
2314	if (pCpu->u32Magic != GVMMHOSTCPU_MAGIC)
2315	return;
2316
2317	/*
2318	* Do the house keeping.
2319	*/
2320	RTSpinlockAcquire(pCpu->Ppt.hSpinlock);
2321
2322	if (++pCpu->Ppt.iTickHistorization >= pCpu->Ppt.cTicksHistoriziationInterval)
2323	{
2324	/*
2325	* Historicize the max frequency.
2326	*/
2327	uint32_t iHzHistory = ++pCpu->Ppt.iHzHistory % RT_ELEMENTS(pCpu->Ppt.aHzHistory);
2328	pCpu->Ppt.aHzHistory[iHzHistory] = pCpu->Ppt.uDesiredHz;
2329	pCpu->Ppt.iTickHistorization = 0;
2330	pCpu->Ppt.uDesiredHz = 0;
2331
2332	/*
2333	* Check if the current timer frequency.
2334	*/
2335	uint32_t uHistMaxHz = 0;
2336	for (uint32_t i = 0; i < RT_ELEMENTS(pCpu->Ppt.aHzHistory); i++)
2337	if (pCpu->Ppt.aHzHistory[i] > uHistMaxHz)
2338	uHistMaxHz = pCpu->Ppt.aHzHistory[i];
2339	if (uHistMaxHz == pCpu->Ppt.uTimerHz)
2340	RTSpinlockRelease(pCpu->Ppt.hSpinlock);
2341	else if (uHistMaxHz)
2342	{
2343	/*
2344	* Reprogram it.
2345	*/
2346	pCpu->Ppt.cChanges++;
2347	pCpu->Ppt.iTickHistorization = 0;
2348	pCpu->Ppt.uTimerHz = uHistMaxHz;
2349	uint32_t const cNsInterval = RT_NS_1SEC / uHistMaxHz;
2350	pCpu->Ppt.cNsInterval = cNsInterval;
2351	if (cNsInterval < GVMMHOSTCPU_PPT_HIST_INTERVAL_NS)
2352	pCpu->Ppt.cTicksHistoriziationInterval = ( GVMMHOSTCPU_PPT_HIST_INTERVAL_NS
2353	+ GVMMHOSTCPU_PPT_HIST_INTERVAL_NS / 2 - 1)
2354	/ cNsInterval;
2355	else
2356	pCpu->Ppt.cTicksHistoriziationInterval = 1;
2357	RTSpinlockRelease(pCpu->Ppt.hSpinlock);
2358
2359	/SUPR0Printf("Cpu%u: change to %u Hz / %u ns\n", pCpu->idxCpuSet, uHistMaxHz, cNsInterval);/
2360	RTTimerChangeInterval(pTimer, cNsInterval);
2361	}
2362	else
2363	{
2364	/*
2365	* Stop it.
2366	*/
2367	pCpu->Ppt.fStarted = false;
2368	pCpu->Ppt.uTimerHz = 0;
2369	pCpu->Ppt.cNsInterval = 0;
2370	RTSpinlockRelease(pCpu->Ppt.hSpinlock);
2371
2372	/SUPR0Printf("Cpu%u: stopping (%u Hz)\n", pCpu->idxCpuSet, uHistMaxHz);/
2373	RTTimerStop(pTimer);
2374	}
2375	}
2376	else
2377	RTSpinlockRelease(pCpu->Ppt.hSpinlock);
2378	}
2379	#endif /* GVMM_SCHED_WITH_PPT */
2380
2381
2382	/**
2383	* Updates the periodic preemption timer for the calling CPU.
2384	*
2385	* The caller must have disabled preemption!
2386	* The caller must check that the host can do high resolution timers.
2387	*
2388	* @param pVM The cross context VM structure.
2389	* @param idHostCpu The current host CPU id.
2390	* @param uHz The desired frequency.
2391	*/
2392	GVMMR0DECL(void) GVMMR0SchedUpdatePeriodicPreemptionTimer(PVM pVM, RTCPUID idHostCpu, uint32_t uHz)
2393	{
2394	NOREF(pVM);
2395	#ifdef GVMM_SCHED_WITH_PPT
2396	Assert(!RTThreadPreemptIsEnabled(NIL_RTTHREAD));
2397	Assert(RTTimerCanDoHighResolution());
2398
2399	/*
2400	* Resolve the per CPU data.
2401	*/
2402	uint32_t iCpu = RTMpCpuIdToSetIndex(idHostCpu);
2403	PGVMM pGVMM = g_pGVMM;
2404	if ( !VALID_PTR(pGVMM)
2405	\|\| pGVMM->u32Magic != GVMM_MAGIC)
2406	return;
2407	AssertMsgReturnVoid(iCpu < pGVMM->cHostCpus, ("iCpu=%d cHostCpus=%d\n", iCpu, pGVMM->cHostCpus));
2408	PGVMMHOSTCPU pCpu = &pGVMM->aHostCpus[iCpu];
2409	AssertMsgReturnVoid( pCpu->u32Magic == GVMMHOSTCPU_MAGIC
2410	&& pCpu->idCpu == idHostCpu,
2411	("u32Magic=%#x idCpu=% idHostCpu=%d\n", pCpu->u32Magic, pCpu->idCpu, idHostCpu));
2412
2413	/*
2414	* Check whether we need to do anything about the timer.
2415	* We have to be a little bit careful since we might be race the timer
2416	* callback here.
2417	*/
2418	if (uHz > 16384)
2419	uHz = 16384; /** @todo add a query method for this! */
2420	if (RT_UNLIKELY( uHz > ASMAtomicReadU32(&pCpu->Ppt.uDesiredHz)
2421	&& uHz >= pCpu->Ppt.uMinHz
2422	&& !pCpu->Ppt.fStarting /* solaris paranoia */))
2423	{
2424	RTSpinlockAcquire(pCpu->Ppt.hSpinlock);
2425
2426	pCpu->Ppt.uDesiredHz = uHz;
2427	uint32_t cNsInterval = 0;
2428	if (!pCpu->Ppt.fStarted)
2429	{
2430	pCpu->Ppt.cStarts++;
2431	pCpu->Ppt.fStarted = true;
2432	pCpu->Ppt.fStarting = true;
2433	pCpu->Ppt.iTickHistorization = 0;
2434	pCpu->Ppt.uTimerHz = uHz;
2435	pCpu->Ppt.cNsInterval = cNsInterval = RT_NS_1SEC / uHz;
2436	if (cNsInterval < GVMMHOSTCPU_PPT_HIST_INTERVAL_NS)
2437	pCpu->Ppt.cTicksHistoriziationInterval = ( GVMMHOSTCPU_PPT_HIST_INTERVAL_NS
2438	+ GVMMHOSTCPU_PPT_HIST_INTERVAL_NS / 2 - 1)
2439	/ cNsInterval;
2440	else
2441	pCpu->Ppt.cTicksHistoriziationInterval = 1;
2442	}
2443
2444	RTSpinlockRelease(pCpu->Ppt.hSpinlock);
2445
2446	if (cNsInterval)
2447	{
2448	RTTimerChangeInterval(pCpu->Ppt.pTimer, cNsInterval);
2449	int rc = RTTimerStart(pCpu->Ppt.pTimer, cNsInterval);
2450	AssertRC(rc);
2451
2452	RTSpinlockAcquire(pCpu->Ppt.hSpinlock);
2453	if (RT_FAILURE(rc))
2454	pCpu->Ppt.fStarted = false;
2455	pCpu->Ppt.fStarting = false;
2456	RTSpinlockRelease(pCpu->Ppt.hSpinlock);
2457	}
2458	}
2459	#else /* !GVMM_SCHED_WITH_PPT */
2460	NOREF(idHostCpu); NOREF(uHz);
2461	#endif /* !GVMM_SCHED_WITH_PPT */
2462	}
2463
2464
2465	/**
2466	* Retrieves the GVMM statistics visible to the caller.
2467	*
2468	* @returns VBox status code.
2469	*
2470	* @param pStats Where to put the statistics.
2471	* @param pSession The current session.
2472	* @param pVM The VM to obtain statistics for. Optional.
2473	*/
2474	GVMMR0DECL(int) GVMMR0QueryStatistics(PGVMMSTATS pStats, PSUPDRVSESSION pSession, PVM pVM)
2475	{
2476	LogFlow(("GVMMR0QueryStatistics: pStats=%p pSession=%p pVM=%p\n", pStats, pSession, pVM));
2477
2478	/*
2479	* Validate input.
2480	*/
2481	AssertPtrReturn(pSession, VERR_INVALID_POINTER);
2482	AssertPtrReturn(pStats, VERR_INVALID_POINTER);
2483	pStats->cVMs = 0; /* (crash before taking the sem...) */
2484
2485	/*
2486	* Take the lock and get the VM statistics.
2487	*/
2488	PGVMM pGVMM;
2489	if (pVM)
2490	{
2491	PGVM pGVM;
2492	int rc = gvmmR0ByVM(pVM, &pGVM, &pGVMM, true /fTakeUsedLock/);
2493	if (RT_FAILURE(rc))
2494	return rc;
2495	pStats->SchedVM = pGVM->gvmm.s.StatsSched;
2496	}
2497	else
2498	{
2499	GVMM_GET_VALID_INSTANCE(pGVMM, VERR_GVMM_INSTANCE);
2500	memset(&pStats->SchedVM, 0, sizeof(pStats->SchedVM));
2501
2502	int rc = GVMMR0_USED_SHARED_LOCK(pGVMM);
2503	AssertRCReturn(rc, rc);
2504	}
2505
2506	/*
2507	* Enumerate the VMs and add the ones visible to the statistics.
2508	*/
2509	pStats->cVMs = 0;
2510	pStats->cEMTs = 0;
2511	memset(&pStats->SchedSum, 0, sizeof(pStats->SchedSum));
2512
2513	for (unsigned i = pGVMM->iUsedHead;
2514	i != NIL_GVM_HANDLE && i < RT_ELEMENTS(pGVMM->aHandles);
2515	i = pGVMM->aHandles[i].iNext)
2516	{
2517	PGVM pGVM = pGVMM->aHandles[i].pGVM;
2518	void *pvObj = pGVMM->aHandles[i].pvObj;
2519	if ( VALID_PTR(pvObj)
2520	&& VALID_PTR(pGVM)
2521	&& pGVM->u32Magic == GVM_MAGIC
2522	&& RT_SUCCESS(SUPR0ObjVerifyAccess(pvObj, pSession, NULL)))
2523	{
2524	pStats->cVMs++;
2525	pStats->cEMTs += pGVM->cCpus;
2526
2527	pStats->SchedSum.cHaltCalls += pGVM->gvmm.s.StatsSched.cHaltCalls;
2528	pStats->SchedSum.cHaltBlocking += pGVM->gvmm.s.StatsSched.cHaltBlocking;
2529	pStats->SchedSum.cHaltTimeouts += pGVM->gvmm.s.StatsSched.cHaltTimeouts;
2530	pStats->SchedSum.cHaltNotBlocking += pGVM->gvmm.s.StatsSched.cHaltNotBlocking;
2531	pStats->SchedSum.cHaltWakeUps += pGVM->gvmm.s.StatsSched.cHaltWakeUps;
2532
2533	pStats->SchedSum.cWakeUpCalls += pGVM->gvmm.s.StatsSched.cWakeUpCalls;
2534	pStats->SchedSum.cWakeUpNotHalted += pGVM->gvmm.s.StatsSched.cWakeUpNotHalted;
2535	pStats->SchedSum.cWakeUpWakeUps += pGVM->gvmm.s.StatsSched.cWakeUpWakeUps;
2536
2537	pStats->SchedSum.cPokeCalls += pGVM->gvmm.s.StatsSched.cPokeCalls;
2538	pStats->SchedSum.cPokeNotBusy += pGVM->gvmm.s.StatsSched.cPokeNotBusy;
2539
2540	pStats->SchedSum.cPollCalls += pGVM->gvmm.s.StatsSched.cPollCalls;
2541	pStats->SchedSum.cPollHalts += pGVM->gvmm.s.StatsSched.cPollHalts;
2542	pStats->SchedSum.cPollWakeUps += pGVM->gvmm.s.StatsSched.cPollWakeUps;
2543	}
2544	}
2545
2546	/*
2547	* Copy out the per host CPU statistics.
2548	*/
2549	uint32_t iDstCpu = 0;
2550	uint32_t cSrcCpus = pGVMM->cHostCpus;
2551	for (uint32_t iSrcCpu = 0; iSrcCpu < cSrcCpus; iSrcCpu++)
2552	{
2553	if (pGVMM->aHostCpus[iSrcCpu].idCpu != NIL_RTCPUID)
2554	{
2555	pStats->aHostCpus[iDstCpu].idCpu = pGVMM->aHostCpus[iSrcCpu].idCpu;
2556	pStats->aHostCpus[iDstCpu].idxCpuSet = pGVMM->aHostCpus[iSrcCpu].idxCpuSet;
2557	#ifdef GVMM_SCHED_WITH_PPT
2558	pStats->aHostCpus[iDstCpu].uDesiredHz = pGVMM->aHostCpus[iSrcCpu].Ppt.uDesiredHz;
2559	pStats->aHostCpus[iDstCpu].uTimerHz = pGVMM->aHostCpus[iSrcCpu].Ppt.uTimerHz;
2560	pStats->aHostCpus[iDstCpu].cChanges = pGVMM->aHostCpus[iSrcCpu].Ppt.cChanges;
2561	pStats->aHostCpus[iDstCpu].cStarts = pGVMM->aHostCpus[iSrcCpu].Ppt.cStarts;
2562	#else
2563	pStats->aHostCpus[iDstCpu].uDesiredHz = 0;
2564	pStats->aHostCpus[iDstCpu].uTimerHz = 0;
2565	pStats->aHostCpus[iDstCpu].cChanges = 0;
2566	pStats->aHostCpus[iDstCpu].cStarts = 0;
2567	#endif
2568	iDstCpu++;
2569	if (iDstCpu >= RT_ELEMENTS(pStats->aHostCpus))
2570	break;
2571	}
2572	}
2573	pStats->cHostCpus = iDstCpu;
2574
2575	GVMMR0_USED_SHARED_UNLOCK(pGVMM);
2576
2577	return VINF_SUCCESS;
2578	}
2579
2580
2581	/**
2582	* VMMR0 request wrapper for GVMMR0QueryStatistics.
2583	*
2584	* @returns see GVMMR0QueryStatistics.
2585	* @param pVM The cross context VM structure. Optional.
2586	* @param pReq Pointer to the request packet.
2587	*/
2588	GVMMR0DECL(int) GVMMR0QueryStatisticsReq(PVM pVM, PGVMMQUERYSTATISTICSSREQ pReq)
2589	{
2590	/*
2591	* Validate input and pass it on.
2592	*/
2593	AssertPtrReturn(pReq, VERR_INVALID_POINTER);
2594	AssertMsgReturn(pReq->Hdr.cbReq == sizeof(pReq), ("%#x != %#x\n", pReq->Hdr.cbReq, sizeof(pReq)), VERR_INVALID_PARAMETER);
2595
2596	return GVMMR0QueryStatistics(&pReq->Stats, pReq->pSession, pVM);
2597	}
2598
2599
2600	/**
2601	* Resets the specified GVMM statistics.
2602	*
2603	* @returns VBox status code.
2604	*
2605	* @param pStats Which statistics to reset, that is, non-zero fields indicates which to reset.
2606	* @param pSession The current session.
2607	* @param pVM The VM to reset statistics for. Optional.
2608	*/
2609	GVMMR0DECL(int) GVMMR0ResetStatistics(PCGVMMSTATS pStats, PSUPDRVSESSION pSession, PVM pVM)
2610	{
2611	LogFlow(("GVMMR0ResetStatistics: pStats=%p pSession=%p pVM=%p\n", pStats, pSession, pVM));
2612
2613	/*
2614	* Validate input.
2615	*/
2616	AssertPtrReturn(pSession, VERR_INVALID_POINTER);
2617	AssertPtrReturn(pStats, VERR_INVALID_POINTER);
2618
2619	/*
2620	* Take the lock and get the VM statistics.
2621	*/
2622	PGVMM pGVMM;
2623	if (pVM)
2624	{
2625	PGVM pGVM;
2626	int rc = gvmmR0ByVM(pVM, &pGVM, &pGVMM, true /fTakeUsedLock/);
2627	if (RT_FAILURE(rc))
2628	return rc;
2629	# define MAYBE_RESET_FIELD(field) \
2630	do { if (pStats->SchedVM. field ) { pGVM->gvmm.s.StatsSched. field = 0; } } while (0)
2631	MAYBE_RESET_FIELD(cHaltCalls);
2632	MAYBE_RESET_FIELD(cHaltBlocking);
2633	MAYBE_RESET_FIELD(cHaltTimeouts);
2634	MAYBE_RESET_FIELD(cHaltNotBlocking);
2635	MAYBE_RESET_FIELD(cHaltWakeUps);
2636	MAYBE_RESET_FIELD(cWakeUpCalls);
2637	MAYBE_RESET_FIELD(cWakeUpNotHalted);
2638	MAYBE_RESET_FIELD(cWakeUpWakeUps);
2639	MAYBE_RESET_FIELD(cPokeCalls);
2640	MAYBE_RESET_FIELD(cPokeNotBusy);
2641	MAYBE_RESET_FIELD(cPollCalls);
2642	MAYBE_RESET_FIELD(cPollHalts);
2643	MAYBE_RESET_FIELD(cPollWakeUps);
2644	# undef MAYBE_RESET_FIELD
2645	}
2646	else
2647	{
2648	GVMM_GET_VALID_INSTANCE(pGVMM, VERR_GVMM_INSTANCE);
2649
2650	int rc = GVMMR0_USED_SHARED_LOCK(pGVMM);
2651	AssertRCReturn(rc, rc);
2652	}
2653
2654	/*
2655	* Enumerate the VMs and add the ones visible to the statistics.
2656	*/
2657	if (ASMMemIsAll8(&pStats->SchedSum, sizeof(pStats->SchedSum), 0))
2658	{
2659	for (unsigned i = pGVMM->iUsedHead;
2660	i != NIL_GVM_HANDLE && i < RT_ELEMENTS(pGVMM->aHandles);
2661	i = pGVMM->aHandles[i].iNext)
2662	{
2663	PGVM pGVM = pGVMM->aHandles[i].pGVM;
2664	void *pvObj = pGVMM->aHandles[i].pvObj;
2665	if ( VALID_PTR(pvObj)
2666	&& VALID_PTR(pGVM)
2667	&& pGVM->u32Magic == GVM_MAGIC
2668	&& RT_SUCCESS(SUPR0ObjVerifyAccess(pvObj, pSession, NULL)))
2669	{
2670	# define MAYBE_RESET_FIELD(field) \
2671	do { if (pStats->SchedSum. field ) { pGVM->gvmm.s.StatsSched. field = 0; } } while (0)
2672	MAYBE_RESET_FIELD(cHaltCalls);
2673	MAYBE_RESET_FIELD(cHaltBlocking);
2674	MAYBE_RESET_FIELD(cHaltTimeouts);
2675	MAYBE_RESET_FIELD(cHaltNotBlocking);
2676	MAYBE_RESET_FIELD(cHaltWakeUps);
2677	MAYBE_RESET_FIELD(cWakeUpCalls);
2678	MAYBE_RESET_FIELD(cWakeUpNotHalted);
2679	MAYBE_RESET_FIELD(cWakeUpWakeUps);
2680	MAYBE_RESET_FIELD(cPokeCalls);
2681	MAYBE_RESET_FIELD(cPokeNotBusy);
2682	MAYBE_RESET_FIELD(cPollCalls);
2683	MAYBE_RESET_FIELD(cPollHalts);
2684	MAYBE_RESET_FIELD(cPollWakeUps);
2685	# undef MAYBE_RESET_FIELD
2686	}
2687	}
2688	}
2689
2690	GVMMR0_USED_SHARED_UNLOCK(pGVMM);
2691
2692	return VINF_SUCCESS;
2693	}
2694
2695
2696	/**
2697	* VMMR0 request wrapper for GVMMR0ResetStatistics.
2698	*
2699	* @returns see GVMMR0ResetStatistics.
2700	* @param pVM The cross context VM structure. Optional.
2701	* @param pReq Pointer to the request packet.
2702	*/
2703	GVMMR0DECL(int) GVMMR0ResetStatisticsReq(PVM pVM, PGVMMRESETSTATISTICSSREQ pReq)
2704	{
2705	/*
2706	* Validate input and pass it on.
2707	*/
2708	AssertPtrReturn(pReq, VERR_INVALID_POINTER);
2709	AssertMsgReturn(pReq->Hdr.cbReq == sizeof(pReq), ("%#x != %#x\n", pReq->Hdr.cbReq, sizeof(pReq)), VERR_INVALID_PARAMETER);
2710
2711	return GVMMR0ResetStatistics(&pReq->Stats, pReq->pSession, pVM);
2712	}
2713

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

source: vbox/trunk/src/VBox/VMM/VMMR0/GVMMR0.cpp@ 58944

Download in other formats: