GVMMR0.cpp@ 19381

Last change on this file since 19381 was 19381, checked in by vboxsync, 16 years ago
Further breakup of GVM. Deal with VCPU thread handles.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 59.1 KB

Line
1	/* $Id: GVMMR0.cpp 19381 2009-05-05 14:44:43Z vboxsync $ */
2	/** @file
3	* GVMM - Global VM Manager.
4	*/
5
6	/*
7	* Copyright (C) 2007 Sun Microsystems, Inc.
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18	* Clara, CA 95054 USA or visit http://www.sun.com if you need
19	* additional information or have any questions.
20	*/
21
22
23	/** @page pg_gvmm GVMM - The Global VM Manager
24	*
25	* The Global VM Manager lives in ring-0. It's main function at the moment
26	* is to manage a list of all running VMs, keep a ring-0 only structure (GVM)
27	* for each of them, and assign them unique identifiers (so GMM can track
28	* page owners). The idea for the future is to add an idle priority kernel
29	* thread that can take care of tasks like page sharing.
30	*
31	* The GVMM will create a ring-0 object for each VM when it's registered,
32	* this is both for session cleanup purposes and for having a point where
33	* it's possible to implement usage polices later (in SUPR0ObjRegister).
34	*/
35
36
37	/*******************************************************************************
38	* Header Files *
39	*******************************************************************************/
40	#define LOG_GROUP LOG_GROUP_GVMM
41	#include <VBox/gvmm.h>
42	#include <VBox/gmm.h>
43	#include "GVMMR0Internal.h"
44	#include <VBox/gvm.h>
45	#include <VBox/vm.h>
46	#include <VBox/vmm.h>
47	#include <VBox/err.h>
48	#include <iprt/alloc.h>
49	#include <iprt/semaphore.h>
50	#include <iprt/time.h>
51	#include <VBox/log.h>
52	#include <iprt/thread.h>
53	#include <iprt/param.h>
54	#include <iprt/string.h>
55	#include <iprt/assert.h>
56	#include <iprt/mem.h>
57	#include <iprt/memobj.h>
58
59
60	/*******************************************************************************
61	* Structures and Typedefs *
62	*******************************************************************************/
63
64	/**
65	* Global VM handle.
66	*/
67	typedef struct GVMHANDLE
68	{
69	/** The index of the next handle in the list (free or used). (0 is nil.) */
70	uint16_t volatile iNext;
71	/** Our own index / handle value. */
72	uint16_t iSelf;
73	/** The pointer to the ring-0 only (aka global) VM structure. */
74	PGVM pGVM;
75	/** The ring-0 mapping of the shared VM instance data. */
76	PVM pVM;
77	/** The virtual machine object. */
78	void *pvObj;
79	/** The session this VM is associated with. */
80	PSUPDRVSESSION pSession;
81	/** The ring-0 handle of the EMT thread (VCPU 0).
82	* This is used for assertions and similar cases where we need to find the VM handle. */
83	RTNATIVETHREAD hEMTCpu0;
84	} GVMHANDLE;
85	/** Pointer to a global VM handle. */
86	typedef GVMHANDLE *PGVMHANDLE;
87
88	/** Number of GVM handles (including the NIL handle). */
89	#if HC_ARCH_BITS == 64
90	# define GVMM_MAX_HANDLES 1024
91	#else
92	# define GVMM_MAX_HANDLES 128
93	#endif
94
95	/**
96	* The GVMM instance data.
97	*/
98	typedef struct GVMM
99	{
100	/** Eyecatcher / magic. */
101	uint32_t u32Magic;
102	/** The index of the head of the free handle chain. (0 is nil.) */
103	uint16_t volatile iFreeHead;
104	/** The index of the head of the active handle chain. (0 is nil.) */
105	uint16_t volatile iUsedHead;
106	/** The number of VMs. */
107	uint16_t volatile cVMs;
108	// /** The number of halted EMT threads. */
109	// uint16_t volatile cHaltedEMTs;
110	/** The lock used to serialize VM creation, destruction and associated events that
111	* isn't performance critical. Owners may acquire the list lock. */
112	RTSEMFASTMUTEX CreateDestroyLock;
113	/** The lock used to serialize used list updates and accesses.
114	* This indirectly includes scheduling since the scheduler will have to walk the
115	* used list to examin running VMs. Owners may not acquire any other locks. */
116	RTSEMFASTMUTEX UsedLock;
117	/** The handle array.
118	* The size of this array defines the maximum number of currently running VMs.
119	* The first entry is unused as it represents the NIL handle. */
120	GVMHANDLE aHandles[GVMM_MAX_HANDLES];
121
122	/** @gcfgm{/GVMM/cVMsMeansCompany, 32-bit, 0, UINT32_MAX, 1}
123	* The number of VMs that means we no longer consider ourselves alone on a CPU/Core.
124	*/
125	uint32_t cVMsMeansCompany;
126	/** @gcfgm{/GVMM/MinSleepAlone,32-bit, 0, 100000000, 750000, ns}
127	* The minimum sleep time for when we're alone, in nano seconds.
128	*/
129	uint32_t nsMinSleepAlone;
130	/** @gcfgm{/GVMM/MinSleepCompany,32-bit,0, 100000000, 15000, ns}
131	* The minimum sleep time for when we've got company, in nano seconds.
132	*/
133	uint32_t nsMinSleepCompany;
134	/** @gcfgm{/GVMM/EarlyWakeUp1, 32-bit, 0, 100000000, 25000, ns}
135	* The limit for the first round of early wakeups, given in nano seconds.
136	*/
137	uint32_t nsEarlyWakeUp1;
138	/** @gcfgm{/GVMM/EarlyWakeUp2, 32-bit, 0, 100000000, 50000, ns}
139	* The limit for the second round of early wakeups, given in nano seconds.
140	*/
141	uint32_t nsEarlyWakeUp2;
142	} GVMM;
143	/** Pointer to the GVMM instance data. */
144	typedef GVMM *PGVMM;
145
146	/** The GVMM::u32Magic value (Charlie Haden). */
147	#define GVMM_MAGIC 0x19370806
148
149
150
151	/*******************************************************************************
152	* Global Variables *
153	*******************************************************************************/
154	/** Pointer to the GVMM instance data.
155	* (Just my general dislike for global variables.) */
156	static PGVMM g_pGVMM = NULL;
157
158	/** Macro for obtaining and validating the g_pGVMM pointer.
159	* On failure it will return from the invoking function with the specified return value.
160	*
161	* @param pGVMM The name of the pGVMM variable.
162	* @param rc The return value on failure. Use VERR_INTERNAL_ERROR for
163	* VBox status codes.
164	*/
165	#define GVMM_GET_VALID_INSTANCE(pGVMM, rc) \
166	do { \
167	(pGVMM) = g_pGVMM;\
168	AssertPtrReturn((pGVMM), (rc)); \
169	AssertMsgReturn((pGVMM)->u32Magic == GVMM_MAGIC, ("%p - %#x\n", (pGVMM), (pGVMM)->u32Magic), (rc)); \
170	} while (0)
171
172	/** Macro for obtaining and validating the g_pGVMM pointer, void function variant.
173	* On failure it will return from the invoking function.
174	*
175	* @param pGVMM The name of the pGVMM variable.
176	*/
177	#define GVMM_GET_VALID_INSTANCE_VOID(pGVMM) \
178	do { \
179	(pGVMM) = g_pGVMM;\
180	AssertPtrReturnVoid((pGVMM)); \
181	AssertMsgReturnVoid((pGVMM)->u32Magic == GVMM_MAGIC, ("%p - %#x\n", (pGVMM), (pGVMM)->u32Magic)); \
182	} while (0)
183
184
185	/*******************************************************************************
186	* Internal Functions *
187	*******************************************************************************/
188	static void gvmmR0InitPerVMData(PGVM pGVM);
189	static DECLCALLBACK(void) gvmmR0HandleObjDestructor(void pvObj, void pvGVMM, void *pvHandle);
190	static int gvmmR0ByVM(PVM pVM, PGVM ppGVM, PGVMM ppGVMM, bool fTakeUsedLock);
191	static int gvmmR0ByVMAndEMT(PVM pVM, unsigned idCpu, PGVM ppGVM, PGVMM ppGVMM);
192
193
194	/**
195	* Initializes the GVMM.
196	*
197	* This is called while owninng the loader sempahore (see supdrvIOCtl_LdrLoad()).
198	*
199	* @returns VBox status code.
200	*/
201	GVMMR0DECL(int) GVMMR0Init(void)
202	{
203	LogFlow(("GVMMR0Init:\n"));
204
205	/*
206	* Allocate and initialize the instance data.
207	*/
208	PGVMM pGVMM = (PGVMM)RTMemAllocZ(sizeof(*pGVMM));
209	if (!pGVMM)
210	return VERR_NO_MEMORY;
211	int rc = RTSemFastMutexCreate(&pGVMM->CreateDestroyLock);
212	if (RT_SUCCESS(rc))
213	{
214	rc = RTSemFastMutexCreate(&pGVMM->UsedLock);
215	if (RT_SUCCESS(rc))
216	{
217	pGVMM->u32Magic = GVMM_MAGIC;
218	pGVMM->iUsedHead = 0;
219	pGVMM->iFreeHead = 1;
220
221	/* the nil handle */
222	pGVMM->aHandles[0].iSelf = 0;
223	pGVMM->aHandles[0].iNext = 0;
224
225	/* the tail */
226	unsigned i = RT_ELEMENTS(pGVMM->aHandles) - 1;
227	pGVMM->aHandles[i].iSelf = i;
228	pGVMM->aHandles[i].iNext = 0; /* nil */
229
230	/* the rest */
231	while (i-- > 1)
232	{
233	pGVMM->aHandles[i].iSelf = i;
234	pGVMM->aHandles[i].iNext = i + 1;
235	}
236
237	/* The default configuration values. */
238	pGVMM->cVMsMeansCompany = 1; /** @todo should be adjusted to relative to the cpu count or something... */
239	pGVMM->nsMinSleepAlone = 750000 /* ns (0.750 ms) /; /* @todo this should be adjusted to be 75% (or something) of the scheduler granularity... */
240	pGVMM->nsMinSleepCompany = 15000 /* ns (0.015 ms) */;
241	pGVMM->nsEarlyWakeUp1 = 25000 /* ns (0.025 ms) */;
242	pGVMM->nsEarlyWakeUp2 = 50000 /* ns (0.050 ms) */;
243
244	g_pGVMM = pGVMM;
245	LogFlow(("GVMMR0Init: pGVMM=%p\n", pGVMM));
246	return VINF_SUCCESS;
247	}
248
249	RTSemFastMutexDestroy(pGVMM->CreateDestroyLock);
250	}
251
252	RTMemFree(pGVMM);
253	return rc;
254	}
255
256
257	/**
258	* Terminates the GVM.
259	*
260	* This is called while owning the loader semaphore (see supdrvLdrFree()).
261	* And unless something is wrong, there should be absolutely no VMs
262	* registered at this point.
263	*/
264	GVMMR0DECL(void) GVMMR0Term(void)
265	{
266	LogFlow(("GVMMR0Term:\n"));
267
268	PGVMM pGVMM = g_pGVMM;
269	g_pGVMM = NULL;
270	if (RT_UNLIKELY(!VALID_PTR(pGVMM)))
271	{
272	SUPR0Printf("GVMMR0Term: pGVMM=%p\n", pGVMM);
273	return;
274	}
275
276	pGVMM->u32Magic++;
277
278	RTSemFastMutexDestroy(pGVMM->UsedLock);
279	pGVMM->UsedLock = NIL_RTSEMFASTMUTEX;
280	RTSemFastMutexDestroy(pGVMM->CreateDestroyLock);
281	pGVMM->CreateDestroyLock = NIL_RTSEMFASTMUTEX;
282
283	pGVMM->iFreeHead = 0;
284	if (pGVMM->iUsedHead)
285	{
286	SUPR0Printf("GVMMR0Term: iUsedHead=%#x! (cVMs=%#x)\n", pGVMM->iUsedHead, pGVMM->cVMs);
287	pGVMM->iUsedHead = 0;
288	}
289
290	RTMemFree(pGVMM);
291	}
292
293
294	/**
295	* A quick hack for setting global config values.
296	*
297	* @returns VBox status code.
298	*
299	* @param pSession The session handle. Used for authentication.
300	* @param pszName The variable name.
301	* @param u64Value The new value.
302	*/
303	GVMMR0DECL(int) GVMMR0SetConfig(PSUPDRVSESSION pSession, const char *pszName, uint64_t u64Value)
304	{
305	/*
306	* Validate input.
307	*/
308	PGVMM pGVMM;
309	GVMM_GET_VALID_INSTANCE(pGVMM, VERR_INTERNAL_ERROR);
310	AssertPtrReturn(pSession, VERR_INVALID_HANDLE);
311	AssertPtrReturn(pszName, VERR_INVALID_POINTER);
312
313	/*
314	* String switch time!
315	*/
316	if (strncmp(pszName, "/GVMM/", sizeof("/GVMM/") - 1))
317	return VERR_CFGM_VALUE_NOT_FOUND; /* borrow status codes from CFGM... */
318	int rc = VINF_SUCCESS;
319	pszName += sizeof("/GVMM/") - 1;
320	if (!strcmp(pszName, "cVMsMeansCompany"))
321	{
322	if (u64Value <= UINT32_MAX)
323	pGVMM->cVMsMeansCompany = u64Value;
324	else
325	rc = VERR_OUT_OF_RANGE;
326	}
327	else if (!strcmp(pszName, "MinSleepAlone"))
328	{
329	if (u64Value <= 100000000)
330	pGVMM->nsMinSleepAlone = u64Value;
331	else
332	rc = VERR_OUT_OF_RANGE;
333	}
334	else if (!strcmp(pszName, "MinSleepCompany"))
335	{
336	if (u64Value <= 100000000)
337	pGVMM->nsMinSleepCompany = u64Value;
338	else
339	rc = VERR_OUT_OF_RANGE;
340	}
341	else if (!strcmp(pszName, "EarlyWakeUp1"))
342	{
343	if (u64Value <= 100000000)
344	pGVMM->nsEarlyWakeUp1 = u64Value;
345	else
346	rc = VERR_OUT_OF_RANGE;
347	}
348	else if (!strcmp(pszName, "EarlyWakeUp2"))
349	{
350	if (u64Value <= 100000000)
351	pGVMM->nsEarlyWakeUp2 = u64Value;
352	else
353	rc = VERR_OUT_OF_RANGE;
354	}
355	else
356	rc = VERR_CFGM_VALUE_NOT_FOUND;
357	return rc;
358	}
359
360
361	/**
362	* A quick hack for getting global config values.
363	*
364	* @returns VBox status code.
365	*
366	* @param pSession The session handle. Used for authentication.
367	* @param pszName The variable name.
368	* @param u64Value The new value.
369	*/
370	GVMMR0DECL(int) GVMMR0QueryConfig(PSUPDRVSESSION pSession, const char pszName, uint64_t pu64Value)
371	{
372	/*
373	* Validate input.
374	*/
375	PGVMM pGVMM;
376	GVMM_GET_VALID_INSTANCE(pGVMM, VERR_INTERNAL_ERROR);
377	AssertPtrReturn(pSession, VERR_INVALID_HANDLE);
378	AssertPtrReturn(pszName, VERR_INVALID_POINTER);
379	AssertPtrReturn(pu64Value, VERR_INVALID_POINTER);
380
381	/*
382	* String switch time!
383	*/
384	if (strncmp(pszName, "/GVMM/", sizeof("/GVMM/") - 1))
385	return VERR_CFGM_VALUE_NOT_FOUND; /* borrow status codes from CFGM... */
386	int rc = VINF_SUCCESS;
387	pszName += sizeof("/GVMM/") - 1;
388	if (!strcmp(pszName, "cVMsMeansCompany"))
389	*pu64Value = pGVMM->cVMsMeansCompany;
390	else if (!strcmp(pszName, "MinSleepAlone"))
391	*pu64Value = pGVMM->nsMinSleepAlone;
392	else if (!strcmp(pszName, "MinSleepCompany"))
393	*pu64Value = pGVMM->nsMinSleepCompany;
394	else if (!strcmp(pszName, "EarlyWakeUp1"))
395	*pu64Value = pGVMM->nsEarlyWakeUp1;
396	else if (!strcmp(pszName, "EarlyWakeUp2"))
397	*pu64Value = pGVMM->nsEarlyWakeUp2;
398	else
399	rc = VERR_CFGM_VALUE_NOT_FOUND;
400	return rc;
401	}
402
403
404	/**
405	* Try acquire the 'used' lock.
406	*
407	* @returns IPRT status code, see RTSemFastMutexRequest.
408	* @param pGVMM The GVMM instance data.
409	*/
410	DECLINLINE(int) gvmmR0UsedLock(PGVMM pGVMM)
411	{
412	LogFlow(("++gvmmR0UsedLock(%p)\n", pGVMM));
413	int rc = RTSemFastMutexRequest(pGVMM->UsedLock);
414	LogFlow(("gvmmR0UsedLock(%p)->%Rrc\n", pGVMM, rc));
415	return rc;
416	}
417
418
419	/**
420	* Release the 'used' lock.
421	*
422	* @returns IPRT status code, see RTSemFastMutexRelease.
423	* @param pGVMM The GVMM instance data.
424	*/
425	DECLINLINE(int) gvmmR0UsedUnlock(PGVMM pGVMM)
426	{
427	LogFlow(("--gvmmR0UsedUnlock(%p)\n", pGVMM));
428	int rc = RTSemFastMutexRelease(pGVMM->UsedLock);
429	AssertRC(rc);
430	return rc;
431	}
432
433
434	/**
435	* Try acquire the 'create & destroy' lock.
436	*
437	* @returns IPRT status code, see RTSemFastMutexRequest.
438	* @param pGVMM The GVMM instance data.
439	*/
440	DECLINLINE(int) gvmmR0CreateDestroyLock(PGVMM pGVMM)
441	{
442	LogFlow(("++gvmmR0CreateDestroyLock(%p)\n", pGVMM));
443	int rc = RTSemFastMutexRequest(pGVMM->CreateDestroyLock);
444	LogFlow(("gvmmR0CreateDestroyLock(%p)->%Rrc\n", pGVMM, rc));
445	return rc;
446	}
447
448
449	/**
450	* Release the 'create & destroy' lock.
451	*
452	* @returns IPRT status code, see RTSemFastMutexRequest.
453	* @param pGVMM The GVMM instance data.
454	*/
455	DECLINLINE(int) gvmmR0CreateDestroyUnlock(PGVMM pGVMM)
456	{
457	LogFlow(("--gvmmR0CreateDestroyUnlock(%p)\n", pGVMM));
458	int rc = RTSemFastMutexRelease(pGVMM->CreateDestroyLock);
459	AssertRC(rc);
460	return rc;
461	}
462
463
464	/**
465	* Request wrapper for the GVMMR0CreateVM API.
466	*
467	* @returns VBox status code.
468	* @param pReq The request buffer.
469	*/
470	GVMMR0DECL(int) GVMMR0CreateVMReq(PGVMMCREATEVMREQ pReq)
471	{
472	/*
473	* Validate the request.
474	*/
475	if (!VALID_PTR(pReq))
476	return VERR_INVALID_POINTER;
477	if (pReq->Hdr.cbReq != sizeof(*pReq))
478	return VERR_INVALID_PARAMETER;
479	if (!VALID_PTR(pReq->pSession))
480	return VERR_INVALID_POINTER;
481
482	/*
483	* Execute it.
484	*/
485	PVM pVM;
486	pReq->pVMR0 = NULL;
487	pReq->pVMR3 = NIL_RTR3PTR;
488	int rc = GVMMR0CreateVM(pReq->pSession, pReq->cCPUs, &pVM);
489	if (RT_SUCCESS(rc))
490	{
491	pReq->pVMR0 = pVM;
492	pReq->pVMR3 = pVM->pVMR3;
493	}
494	return rc;
495	}
496
497
498	/**
499	* Allocates the VM structure and registers it with GVM.
500	*
501	* The caller will become the VM owner and there by the EMT.
502	*
503	* @returns VBox status code.
504	* @param pSession The support driver session.
505	* @param cCPUs Number of virtual CPUs for the new VM.
506	* @param ppVM Where to store the pointer to the VM structure.
507	*
508	* @thread EMT.
509	*/
510	GVMMR0DECL(int) GVMMR0CreateVM(PSUPDRVSESSION pSession, uint32_t cCPUs, PVM *ppVM)
511	{
512	LogFlow(("GVMMR0CreateVM: pSession=%p\n", pSession));
513	PGVMM pGVMM;
514	GVMM_GET_VALID_INSTANCE(pGVMM, VERR_INTERNAL_ERROR);
515
516	AssertPtrReturn(ppVM, VERR_INVALID_POINTER);
517	*ppVM = NULL;
518
519	if ( cCPUs == 0
520	\|\| cCPUs > VMCPU_MAX_CPU_COUNT)
521	return VERR_INVALID_PARAMETER;
522
523	RTNATIVETHREAD hEMT = RTThreadNativeSelf();
524	AssertReturn(hEMT != NIL_RTNATIVETHREAD, VERR_INTERNAL_ERROR);
525
526	/*
527	* The whole allocation process is protected by the lock.
528	*/
529	int rc = gvmmR0CreateDestroyLock(pGVMM);
530	AssertRCReturn(rc, rc);
531
532	/*
533	* Allocate a handle first so we don't waste resources unnecessarily.
534	*/
535	uint16_t iHandle = pGVMM->iFreeHead;
536	if (iHandle)
537	{
538	PGVMHANDLE pHandle = &pGVMM->aHandles[iHandle];
539
540	/* consistency checks, a bit paranoid as always. */
541	if ( !pHandle->pVM
542	&& !pHandle->pGVM
543	&& !pHandle->pvObj
544	&& pHandle->iSelf == iHandle)
545	{
546	pHandle->pvObj = SUPR0ObjRegister(pSession, SUPDRVOBJTYPE_VM, gvmmR0HandleObjDestructor, pGVMM, pHandle);
547	if (pHandle->pvObj)
548	{
549	/*
550	* Move the handle from the free to used list and perform permission checks.
551	*/
552	rc = gvmmR0UsedLock(pGVMM);
553	AssertRC(rc);
554
555	pGVMM->iFreeHead = pHandle->iNext;
556	pHandle->iNext = pGVMM->iUsedHead;
557	pGVMM->iUsedHead = iHandle;
558	pGVMM->cVMs++;
559
560	pHandle->pVM = NULL;
561	pHandle->pGVM = NULL;
562	pHandle->pSession = pSession;
563	pHandle->hEMTCpu0 = NIL_RTNATIVETHREAD;
564
565	gvmmR0UsedUnlock(pGVMM);
566
567	rc = SUPR0ObjVerifyAccess(pHandle->pvObj, pSession, NULL);
568	if (RT_SUCCESS(rc))
569	{
570	/*
571	* Allocate the global VM structure (GVM) and initialize it.
572	*/
573	PGVM pGVM = (PGVM)RTMemAllocZ(RT_UOFFSETOF(GVM, aCpus[cCPUs]));
574	if (pGVM)
575	{
576	pGVM->u32Magic = GVM_MAGIC;
577	pGVM->hSelf = iHandle;
578	pGVM->pVM = NULL;
579	pGVM->cCPUs = cCPUs;
580
581	gvmmR0InitPerVMData(pGVM);
582	GMMR0InitPerVMData(pGVM);
583
584	/*
585	* Allocate the shared VM structure and associated page array.
586	*/
587	const uint32_t cbVM = RT_UOFFSETOF(VM, aCpus[cCPUs]);
588	const uint32_t cPages = RT_ALIGN_32(cbVM, PAGE_SIZE) >> PAGE_SHIFT;
589	rc = RTR0MemObjAllocLow(&pGVM->gvmm.s.VMMemObj, cPages << PAGE_SHIFT, false /* fExecutable */);
590	if (RT_SUCCESS(rc))
591	{
592	PVM pVM = (PVM)RTR0MemObjAddress(pGVM->gvmm.s.VMMemObj); AssertPtr(pVM);
593	memset(pVM, 0, cPages << PAGE_SHIFT);
594	pVM->enmVMState = VMSTATE_CREATING;
595	pVM->pVMR0 = pVM;
596	pVM->pSession = pSession;
597	pVM->hSelf = iHandle;
598	pVM->cbSelf = cbVM;
599	pVM->cCPUs = cCPUs;
600	pVM->offVMCPU = RT_UOFFSETOF(VM, aCpus);
601
602	rc = RTR0MemObjAllocPage(&pGVM->gvmm.s.VMPagesMemObj, cPages * sizeof(SUPPAGE), false /* fExecutable */);
603	if (RT_SUCCESS(rc))
604	{
605	PSUPPAGE paPages = (PSUPPAGE)RTR0MemObjAddress(pGVM->gvmm.s.VMPagesMemObj); AssertPtr(paPages);
606	for (uint32_t iPage = 0; iPage < cPages; iPage++)
607	{
608	paPages[iPage].uReserved = 0;
609	paPages[iPage].Phys = RTR0MemObjGetPagePhysAddr(pGVM->gvmm.s.VMMemObj, iPage);
610	Assert(paPages[iPage].Phys != NIL_RTHCPHYS);
611	}
612
613	/*
614	* Map them into ring-3.
615	*/
616	rc = RTR0MemObjMapUser(&pGVM->gvmm.s.VMMapObj, pGVM->gvmm.s.VMMemObj, (RTR3PTR)-1, 0,
617	RTMEM_PROT_READ \| RTMEM_PROT_WRITE, NIL_RTR0PROCESS);
618	if (RT_SUCCESS(rc))
619	{
620	pVM->pVMR3 = RTR0MemObjAddressR3(pGVM->gvmm.s.VMMapObj);
621	AssertPtr((void *)pVM->pVMR3);
622
623	/* Initialize all the VM pointers. */
624	for (uint32_t i = 0; i < cCPUs; i++)
625	{
626	pVM->aCpus[i].pVMR0 = pVM;
627	pVM->aCpus[i].pVMR3 = pVM->pVMR3;
628	}
629
630	rc = RTR0MemObjMapUser(&pGVM->gvmm.s.VMPagesMapObj, pGVM->gvmm.s.VMPagesMemObj, (RTR3PTR)-1, 0,
631	RTMEM_PROT_READ \| RTMEM_PROT_WRITE, NIL_RTR0PROCESS);
632	if (RT_SUCCESS(rc))
633	{
634	pVM->paVMPagesR3 = RTR0MemObjAddressR3(pGVM->gvmm.s.VMPagesMapObj);
635	AssertPtr((void *)pVM->paVMPagesR3);
636
637	/* complete the handle - take the UsedLock sem just to be careful. */
638	rc = gvmmR0UsedLock(pGVMM);
639	AssertRC(rc);
640
641	pHandle->pVM = pVM;
642	pHandle->pGVM = pGVM;
643	pHandle->hEMTCpu0 = hEMT;
644	pGVM->pVM = pVM;
645	pGVM->aCpus[0].hEMT = hEMT;
646
647	gvmmR0UsedUnlock(pGVMM);
648	gvmmR0CreateDestroyUnlock(pGVMM);
649
650	*ppVM = pVM;
651	Log(("GVMMR0CreateVM: pVM=%p pVMR3=%p pGVM=%p hGVM=%d\n", pVM, pVM->pVMR3, pGVM, iHandle));
652	return VINF_SUCCESS;
653	}
654
655	RTR0MemObjFree(pGVM->gvmm.s.VMMapObj, false /* fFreeMappings */);
656	pGVM->gvmm.s.VMMapObj = NIL_RTR0MEMOBJ;
657	}
658	RTR0MemObjFree(pGVM->gvmm.s.VMPagesMemObj, false /* fFreeMappings */);
659	pGVM->gvmm.s.VMPagesMemObj = NIL_RTR0MEMOBJ;
660	}
661	RTR0MemObjFree(pGVM->gvmm.s.VMMemObj, false /* fFreeMappings */);
662	pGVM->gvmm.s.VMMemObj = NIL_RTR0MEMOBJ;
663	}
664	}
665	}
666	/* else: The user wasn't permitted to create this VM. */
667
668	/*
669	* The handle will be freed by gvmmR0HandleObjDestructor as we release the
670	* object reference here. A little extra mess because of non-recursive lock.
671	*/
672	void *pvObj = pHandle->pvObj;
673	pHandle->pvObj = NULL;
674	gvmmR0CreateDestroyUnlock(pGVMM);
675
676	SUPR0ObjRelease(pvObj, pSession);
677
678	SUPR0Printf("GVMMR0CreateVM: failed, rc=%d\n", rc);
679	return rc;
680	}
681
682	rc = VERR_NO_MEMORY;
683	}
684	else
685	rc = VERR_INTERNAL_ERROR;
686	}
687	else
688	rc = VERR_GVM_TOO_MANY_VMS;
689
690	gvmmR0CreateDestroyUnlock(pGVMM);
691	return rc;
692	}
693
694
695	/**
696	* Initializes the per VM data belonging to GVMM.
697	*
698	* @param pGVM Pointer to the global VM structure.
699	*/
700	static void gvmmR0InitPerVMData(PGVM pGVM)
701	{
702	AssertCompile(RT_SIZEOFMEMB(GVM,gvmm.s) <= RT_SIZEOFMEMB(GVM,gvmm.padding));
703	AssertCompile(RT_SIZEOFMEMB(GVMCPU,gvmm.s) <= RT_SIZEOFMEMB(GVMCPU,gvmm.padding));
704	pGVM->gvmm.s.VMMemObj = NIL_RTR0MEMOBJ;
705	pGVM->gvmm.s.VMMapObj = NIL_RTR0MEMOBJ;
706	pGVM->gvmm.s.VMPagesMemObj = NIL_RTR0MEMOBJ;
707	pGVM->gvmm.s.VMPagesMapObj = NIL_RTR0MEMOBJ;
708	pGVM->gvmm.s.fDoneVMMR0Init = false;
709	pGVM->gvmm.s.fDoneVMMR0Term = false;
710
711	for (unsigned i=0; i< pGVM->cCPUs; i++)
712	{
713	pGVM->aCpus[i].gvmm.s.HaltEventMulti = NIL_RTSEMEVENTMULTI;
714	pGVM->aCpus[i].hEMT = NIL_RTNATIVETHREAD;
715	}
716	}
717
718
719	/**
720	* Does the VM initialization.
721	*
722	* @returns VBox status code.
723	* @param pVM Pointer to the shared VM structure.
724	*/
725	GVMMR0DECL(int) GVMMR0InitVM(PVM pVM)
726	{
727	LogFlow(("GVMMR0InitVM: pVM=%p\n", pVM));
728
729	/*
730	* Validate the VM structure, state and handle.
731	*/
732	PGVM pGVM;
733	PGVMM pGVMM;
734	int rc = gvmmR0ByVMAndEMT(pVM, 0 /* VCPU 0 */, &pGVM, &pGVMM);
735	if (RT_SUCCESS(rc))
736	{
737	if ( !pGVM->gvmm.s.fDoneVMMR0Init
738	&& pGVM->aCpus[0].gvmm.s.HaltEventMulti == NIL_RTSEMEVENTMULTI)
739	{
740	for (unsigned i=0; i < pGVM->cCPUs; i++)
741	{
742	rc = RTSemEventMultiCreate(&pGVM->aCpus[i].gvmm.s.HaltEventMulti);
743	if (RT_FAILURE(rc))
744	{
745	pGVM->aCpus[i].gvmm.s.HaltEventMulti = NIL_RTSEMEVENTMULTI;
746	break;
747	}
748	}
749	}
750	else
751	rc = VERR_WRONG_ORDER;
752	}
753
754	LogFlow(("GVMMR0InitVM: returns %Rrc\n", rc));
755	return rc;
756	}
757
758
759	/**
760	* Indicates that we're done with the ring-0 initialization
761	* of the VM.
762	*
763	* @param pVM Pointer to the shared VM structure.
764	*/
765	GVMMR0DECL(void) GVMMR0DoneInitVM(PVM pVM)
766	{
767	/* Validate the VM structure, state and handle. */
768	PGVM pGVM;
769	PGVMM pGVMM;
770	int rc = gvmmR0ByVMAndEMT(pVM, 0 /* VCPU 0 */, &pGVM, &pGVMM);
771	AssertRCReturnVoid(rc);
772
773	/* Set the indicator. */
774	pGVM->gvmm.s.fDoneVMMR0Init = true;
775	}
776
777
778	/**
779	* Indicates that we're doing the ring-0 termination of the VM.
780	*
781	* @returns true if termination hasn't been done already, false if it has.
782	* @param pVM Pointer to the shared VM structure.
783	* @param pGVM Pointer to the global VM structure. Optional.
784	*/
785	GVMMR0DECL(bool) GVMMR0DoingTermVM(PVM pVM, PGVM pGVM)
786	{
787	/* Validate the VM structure, state and handle. */
788	AssertPtrNullReturn(pGVM, false);
789	AssertReturn(!pGVM \|\| pGVM->u32Magic == GVM_MAGIC, false);
790	if (!pGVM)
791	{
792	PGVMM pGVMM;
793	int rc = gvmmR0ByVMAndEMT(pVM, 0 /* VCPU 0 */, &pGVM, &pGVMM);
794	AssertRCReturn(rc, false);
795	}
796
797	/* Set the indicator. */
798	if (pGVM->gvmm.s.fDoneVMMR0Term)
799	return false;
800	pGVM->gvmm.s.fDoneVMMR0Term = true;
801	return true;
802	}
803
804
805	/**
806	* Destroys the VM, freeing all associated resources (the ring-0 ones anyway).
807	*
808	* This is call from the vmR3DestroyFinalBit and from a error path in VMR3Create,
809	* and the caller is not the EMT thread, unfortunately. For security reasons, it
810	* would've been nice if the caller was actually the EMT thread or that we somehow
811	* could've associated the calling thread with the VM up front.
812	*
813	* @returns VBox status code.
814	* @param pVM Where to store the pointer to the VM structure.
815	*
816	* @thread EMT if it's associated with the VM, otherwise any thread.
817	*/
818	GVMMR0DECL(int) GVMMR0DestroyVM(PVM pVM)
819	{
820	LogFlow(("GVMMR0DestroyVM: pVM=%p\n", pVM));
821	PGVMM pGVMM;
822	GVMM_GET_VALID_INSTANCE(pGVMM, VERR_INTERNAL_ERROR);
823
824
825	/*
826	* Validate the VM structure, state and caller.
827	*/
828	AssertPtrReturn(pVM, VERR_INVALID_POINTER);
829	AssertReturn(!((uintptr_t)pVM & PAGE_OFFSET_MASK), VERR_INVALID_POINTER);
830	AssertMsgReturn(pVM->enmVMState >= VMSTATE_CREATING && pVM->enmVMState <= VMSTATE_TERMINATED, ("%d\n", pVM->enmVMState), VERR_WRONG_ORDER);
831
832	uint32_t hGVM = pVM->hSelf;
833	AssertReturn(hGVM != NIL_GVM_HANDLE, VERR_INVALID_HANDLE);
834	AssertReturn(hGVM < RT_ELEMENTS(pGVMM->aHandles), VERR_INVALID_HANDLE);
835
836	PGVMHANDLE pHandle = &pGVMM->aHandles[hGVM];
837	AssertReturn(pHandle->pVM == pVM, VERR_NOT_OWNER);
838
839	RTNATIVETHREAD hSelf = RTThreadNativeSelf();
840	AssertReturn(pHandle->hEMTCpu0 == hSelf \|\| pHandle->hEMTCpu0 == NIL_RTNATIVETHREAD, VERR_NOT_OWNER);
841
842	/*
843	* Lookup the handle and destroy the object.
844	* Since the lock isn't recursive and we'll have to leave it before dereferencing the
845	* object, we take some precautions against racing callers just in case...
846	*/
847	int rc = gvmmR0CreateDestroyLock(pGVMM);
848	AssertRC(rc);
849
850	/* be careful here because we might theoretically be racing someone else cleaning up. */
851	if ( pHandle->pVM == pVM
852	&& ( pHandle->hEMTCpu0 == hSelf
853	\|\| pHandle->hEMTCpu0 == NIL_RTNATIVETHREAD)
854	&& VALID_PTR(pHandle->pvObj)
855	&& VALID_PTR(pHandle->pSession)
856	&& VALID_PTR(pHandle->pGVM)
857	&& pHandle->pGVM->u32Magic == GVM_MAGIC)
858	{
859	void *pvObj = pHandle->pvObj;
860	pHandle->pvObj = NULL;
861	gvmmR0CreateDestroyUnlock(pGVMM);
862
863	SUPR0ObjRelease(pvObj, pHandle->pSession);
864	}
865	else
866	{
867	SUPR0Printf("GVMMR0DestroyVM: pHandle=%p:{.pVM=%p, hEMT=%p, .pvObj=%p} pVM=%p hSelf=%p\n",
868	pHandle, pHandle->pVM, pHandle->hEMTCpu0, pHandle->pvObj, pVM, hSelf);
869	gvmmR0CreateDestroyUnlock(pGVMM);
870	rc = VERR_INTERNAL_ERROR;
871	}
872
873	return rc;
874	}
875
876
877	/**
878	* Performs VM cleanup task as part of object destruction.
879	*
880	* @param pGVM The GVM pointer.
881	*/
882	static void gvmmR0CleanupVM(PGVM pGVM)
883	{
884	if ( pGVM->gvmm.s.fDoneVMMR0Init
885	&& !pGVM->gvmm.s.fDoneVMMR0Term)
886	{
887	if ( pGVM->gvmm.s.VMMemObj != NIL_RTR0MEMOBJ
888	&& RTR0MemObjAddress(pGVM->gvmm.s.VMMemObj) == pGVM->pVM)
889	{
890	LogFlow(("gvmmR0CleanupVM: Calling VMMR0TermVM\n"));
891	VMMR0TermVM(pGVM->pVM, pGVM);
892	}
893	else
894	AssertMsgFailed(("gvmmR0CleanupVM: VMMemObj=%p pVM=%p\n", pGVM->gvmm.s.VMMemObj, pGVM->pVM));
895	}
896
897	GMMR0CleanupVM(pGVM);
898	}
899
900
901	/**
902	* Handle destructor.
903	*
904	* @param pvGVMM The GVM instance pointer.
905	* @param pvHandle The handle pointer.
906	*/
907	static DECLCALLBACK(void) gvmmR0HandleObjDestructor(void pvObj, void pvGVMM, void *pvHandle)
908	{
909	LogFlow(("gvmmR0HandleObjDestructor: %p %p %p\n", pvObj, pvGVMM, pvHandle));
910
911	/*
912	* Some quick, paranoid, input validation.
913	*/
914	PGVMHANDLE pHandle = (PGVMHANDLE)pvHandle;
915	AssertPtr(pHandle);
916	PGVMM pGVMM = (PGVMM)pvGVMM;
917	Assert(pGVMM == g_pGVMM);
918	const uint16_t iHandle = pHandle - &pGVMM->aHandles[0];
919	if ( !iHandle
920	\|\| iHandle >= RT_ELEMENTS(pGVMM->aHandles)
921	\|\| iHandle != pHandle->iSelf)
922	{
923	SUPR0Printf("GVM: handle %d is out of range or corrupt (iSelf=%d)!\n", iHandle, pHandle->iSelf);
924	return;
925	}
926
927	int rc = gvmmR0CreateDestroyLock(pGVMM);
928	AssertRC(rc);
929	rc = gvmmR0UsedLock(pGVMM);
930	AssertRC(rc);
931
932	/*
933	* This is a tad slow but a doubly linked list is too much hazzle.
934	*/
935	if (RT_UNLIKELY(pHandle->iNext >= RT_ELEMENTS(pGVMM->aHandles)))
936	{
937	SUPR0Printf("GVM: used list index %d is out of range!\n", pHandle->iNext);
938	gvmmR0UsedUnlock(pGVMM);
939	gvmmR0CreateDestroyUnlock(pGVMM);
940	return;
941	}
942
943	if (pGVMM->iUsedHead == iHandle)
944	pGVMM->iUsedHead = pHandle->iNext;
945	else
946	{
947	uint16_t iPrev = pGVMM->iUsedHead;
948	int c = RT_ELEMENTS(pGVMM->aHandles) + 2;
949	while (iPrev)
950	{
951	if (RT_UNLIKELY(iPrev >= RT_ELEMENTS(pGVMM->aHandles)))
952	{
953	SUPR0Printf("GVM: used list index %d is out of range!\n");
954	gvmmR0UsedUnlock(pGVMM);
955	gvmmR0CreateDestroyUnlock(pGVMM);
956	return;
957	}
958	if (RT_UNLIKELY(c-- <= 0))
959	{
960	iPrev = 0;
961	break;
962	}
963
964	if (pGVMM->aHandles[iPrev].iNext == iHandle)
965	break;
966	iPrev = pGVMM->aHandles[iPrev].iNext;
967	}
968	if (!iPrev)
969	{
970	SUPR0Printf("GVM: can't find the handle previous previous of %d!\n", pHandle->iSelf);
971	gvmmR0UsedUnlock(pGVMM);
972	gvmmR0CreateDestroyUnlock(pGVMM);
973	return;
974	}
975
976	Assert(pGVMM->aHandles[iPrev].iNext == iHandle);
977	pGVMM->aHandles[iPrev].iNext = pHandle->iNext;
978	}
979	pHandle->iNext = 0;
980	pGVMM->cVMs--;
981
982	gvmmR0UsedUnlock(pGVMM);
983
984	/*
985	* Do the global cleanup round.
986	*/
987	PGVM pGVM = pHandle->pGVM;
988	if ( VALID_PTR(pGVM)
989	&& pGVM->u32Magic == GVM_MAGIC)
990	{
991	gvmmR0CleanupVM(pGVM);
992
993	/*
994	* Do the GVMM cleanup - must be done last.
995	*/
996	/* The VM and VM pages mappings/allocations. */
997	if (pGVM->gvmm.s.VMPagesMapObj != NIL_RTR0MEMOBJ)
998	{
999	rc = RTR0MemObjFree(pGVM->gvmm.s.VMPagesMapObj, false /* fFreeMappings */); AssertRC(rc);
1000	pGVM->gvmm.s.VMPagesMapObj = NIL_RTR0MEMOBJ;
1001	}
1002
1003	if (pGVM->gvmm.s.VMMapObj != NIL_RTR0MEMOBJ)
1004	{
1005	rc = RTR0MemObjFree(pGVM->gvmm.s.VMMapObj, false /* fFreeMappings */); AssertRC(rc);
1006	pGVM->gvmm.s.VMMapObj = NIL_RTR0MEMOBJ;
1007	}
1008
1009	if (pGVM->gvmm.s.VMPagesMemObj != NIL_RTR0MEMOBJ)
1010	{
1011	rc = RTR0MemObjFree(pGVM->gvmm.s.VMPagesMemObj, false /* fFreeMappings */); AssertRC(rc);
1012	pGVM->gvmm.s.VMPagesMemObj = NIL_RTR0MEMOBJ;
1013	}
1014
1015	if (pGVM->gvmm.s.VMMemObj != NIL_RTR0MEMOBJ)
1016	{
1017	rc = RTR0MemObjFree(pGVM->gvmm.s.VMMemObj, false /* fFreeMappings */); AssertRC(rc);
1018	pGVM->gvmm.s.VMMemObj = NIL_RTR0MEMOBJ;
1019	}
1020
1021	for (unsigned i=0; i< pGVM->cCPUs; i++)
1022	{
1023	if (pGVM->aCpus[i].gvmm.s.HaltEventMulti != NIL_RTSEMEVENTMULTI)
1024	{
1025	rc = RTSemEventMultiDestroy(pGVM->aCpus[i].gvmm.s.HaltEventMulti); AssertRC(rc);
1026	pGVM->aCpus[i].gvmm.s.HaltEventMulti = NIL_RTSEMEVENTMULTI;
1027	}
1028	}
1029
1030	/* the GVM structure itself. */
1031	pGVM->u32Magic \|= UINT32_C(0x80000000);
1032	RTMemFree(pGVM);
1033	}
1034	/* else: GVMMR0CreateVM cleanup. */
1035
1036	/*
1037	* Free the handle.
1038	* Reacquire the UsedLock here to since we're updating handle fields.
1039	*/
1040	rc = gvmmR0UsedLock(pGVMM);
1041	AssertRC(rc);
1042
1043	pHandle->iNext = pGVMM->iFreeHead;
1044	pGVMM->iFreeHead = iHandle;
1045	ASMAtomicXchgPtr((void * volatile *)&pHandle->pGVM, NULL);
1046	ASMAtomicXchgPtr((void * volatile *)&pHandle->pVM, NULL);
1047	ASMAtomicXchgPtr((void * volatile *)&pHandle->pvObj, NULL);
1048	ASMAtomicXchgPtr((void * volatile *)&pHandle->pSession, NULL);
1049	ASMAtomicXchgSize(&pHandle->hEMTCpu0, NIL_RTNATIVETHREAD);
1050
1051	gvmmR0UsedUnlock(pGVMM);
1052	gvmmR0CreateDestroyUnlock(pGVMM);
1053	LogFlow(("gvmmR0HandleObjDestructor: returns\n"));
1054	}
1055
1056
1057	/**
1058	* Lookup a GVM structure by its handle.
1059	*
1060	* @returns The GVM pointer on success, NULL on failure.
1061	* @param hGVM The global VM handle. Asserts on bad handle.
1062	*/
1063	GVMMR0DECL(PGVM) GVMMR0ByHandle(uint32_t hGVM)
1064	{
1065	PGVMM pGVMM;
1066	GVMM_GET_VALID_INSTANCE(pGVMM, NULL);
1067
1068	/*
1069	* Validate.
1070	*/
1071	AssertReturn(hGVM != NIL_GVM_HANDLE, NULL);
1072	AssertReturn(hGVM < RT_ELEMENTS(pGVMM->aHandles), NULL);
1073
1074	/*
1075	* Look it up.
1076	*/
1077	PGVMHANDLE pHandle = &pGVMM->aHandles[hGVM];
1078	AssertPtrReturn(pHandle->pVM, NULL);
1079	AssertPtrReturn(pHandle->pvObj, NULL);
1080	PGVM pGVM = pHandle->pGVM;
1081	AssertPtrReturn(pGVM, NULL);
1082	AssertReturn(pGVM->pVM == pHandle->pVM, NULL);
1083
1084	return pHandle->pGVM;
1085	}
1086
1087
1088	/**
1089	* Lookup a GVM structure by the shared VM structure.
1090	*
1091	* @returns VBox status code.
1092	* @param pVM The shared VM structure (the ring-0 mapping).
1093	* @param ppGVM Where to store the GVM pointer.
1094	* @param ppGVMM Where to store the pointer to the GVMM instance data.
1095	* @param fTakeUsedLock Whether to take the used lock or not.
1096	* Be very careful if not taking the lock as it's possible that
1097	* the VM will disappear then.
1098	*
1099	* @remark This will not assert on an invalid pVM but try return sliently.
1100	*/
1101	static int gvmmR0ByVM(PVM pVM, PGVM ppGVM, PGVMM ppGVMM, bool fTakeUsedLock)
1102	{
1103	PGVMM pGVMM;
1104	GVMM_GET_VALID_INSTANCE(pGVMM, VERR_INTERNAL_ERROR);
1105
1106	/*
1107	* Validate.
1108	*/
1109	if (RT_UNLIKELY( !VALID_PTR(pVM)
1110	\|\| ((uintptr_t)pVM & PAGE_OFFSET_MASK)))
1111	return VERR_INVALID_POINTER;
1112	if (RT_UNLIKELY( pVM->enmVMState < VMSTATE_CREATING
1113	\|\| pVM->enmVMState >= VMSTATE_TERMINATED))
1114	return VERR_INVALID_POINTER;
1115
1116	uint16_t hGVM = pVM->hSelf;
1117	if (RT_UNLIKELY( hGVM == NIL_GVM_HANDLE
1118	\|\| hGVM >= RT_ELEMENTS(pGVMM->aHandles)))
1119	return VERR_INVALID_HANDLE;
1120
1121	/*
1122	* Look it up.
1123	*/
1124	PGVMHANDLE pHandle = &pGVMM->aHandles[hGVM];
1125	PGVM pGVM;
1126	if (fTakeUsedLock)
1127	{
1128	int rc = gvmmR0UsedLock(pGVMM);
1129	AssertRCReturn(rc, rc);
1130
1131	pGVM = pHandle->pGVM;
1132	if (RT_UNLIKELY( pHandle->pVM != pVM
1133	\|\| !VALID_PTR(pHandle->pvObj)
1134	\|\| !VALID_PTR(pGVM)
1135	\|\| pGVM->pVM != pVM))
1136	{
1137	gvmmR0UsedUnlock(pGVMM);
1138	return VERR_INVALID_HANDLE;
1139	}
1140	}
1141	else
1142	{
1143	if (RT_UNLIKELY(pHandle->pVM != pVM))
1144	return VERR_INVALID_HANDLE;
1145	if (RT_UNLIKELY(!VALID_PTR(pHandle->pvObj)))
1146	return VERR_INVALID_HANDLE;
1147
1148	pGVM = pHandle->pGVM;
1149	if (RT_UNLIKELY(!VALID_PTR(pGVM)))
1150	return VERR_INVALID_HANDLE;
1151	if (RT_UNLIKELY(pGVM->pVM != pVM))
1152	return VERR_INVALID_HANDLE;
1153	}
1154
1155	*ppGVM = pGVM;
1156	*ppGVMM = pGVMM;
1157	return VINF_SUCCESS;
1158	}
1159
1160
1161	/**
1162	* Lookup a GVM structure by the shared VM structure.
1163	*
1164	* @returns The GVM pointer on success, NULL on failure.
1165	* @param pVM The shared VM structure (the ring-0 mapping).
1166	*
1167	* @remark This will not take the 'used'-lock because it doesn't do
1168	* nesting and this function will be used from under the lock.
1169	*/
1170	GVMMR0DECL(PGVM) GVMMR0ByVM(PVM pVM)
1171	{
1172	PGVMM pGVMM;
1173	PGVM pGVM;
1174	int rc = gvmmR0ByVM(pVM, &pGVM, &pGVMM, false /* fTakeUsedLock */);
1175	if (RT_SUCCESS(rc))
1176	return pGVM;
1177	AssertRC(rc);
1178	return NULL;
1179	}
1180
1181
1182	/**
1183	* Lookup a GVM structure by the shared VM structure
1184	* and ensuring that the caller is the EMT thread.
1185	*
1186	* @returns VBox status code.
1187	* @param pVM The shared VM structure (the ring-0 mapping).
1188	* @param idCpu VCPU id
1189	* @param ppGVM Where to store the GVM pointer.
1190	* @param ppGVMM Where to store the pointer to the GVMM instance data.
1191	* @thread EMT
1192	*
1193	* @remark This will assert in failure paths.
1194	*/
1195	static int gvmmR0ByVMAndEMT(PVM pVM, unsigned idCpu, PGVM ppGVM, PGVMM ppGVMM)
1196	{
1197	PGVMM pGVMM;
1198	GVMM_GET_VALID_INSTANCE(pGVMM, VERR_INTERNAL_ERROR);
1199
1200	/*
1201	* Validate.
1202	*/
1203	AssertPtrReturn(pVM, VERR_INVALID_POINTER);
1204	AssertReturn(!((uintptr_t)pVM & PAGE_OFFSET_MASK), VERR_INVALID_POINTER);
1205
1206	uint16_t hGVM = pVM->hSelf;
1207	AssertReturn(hGVM != NIL_GVM_HANDLE, VERR_INVALID_HANDLE);
1208	AssertReturn(hGVM < RT_ELEMENTS(pGVMM->aHandles), VERR_INVALID_HANDLE);
1209
1210	/*
1211	* Look it up.
1212	*/
1213	PGVMHANDLE pHandle = &pGVMM->aHandles[hGVM];
1214	RTNATIVETHREAD hAllegedEMT = RTThreadNativeSelf();
1215	AssertReturn(pHandle->pVM == pVM, VERR_NOT_OWNER);
1216	AssertPtrReturn(pHandle->pvObj, VERR_INTERNAL_ERROR);
1217
1218	PGVM pGVM = pHandle->pGVM;
1219	AssertPtrReturn(pGVM, VERR_INTERNAL_ERROR);
1220	AssertReturn(pGVM->pVM == pVM, VERR_INTERNAL_ERROR);
1221	AssertReturn(pGVM->aCpus[idCpu].hEMT == hAllegedEMT, VERR_INTERNAL_ERROR);
1222
1223	*ppGVM = pGVM;
1224	*ppGVMM = pGVMM;
1225	return VINF_SUCCESS;
1226	}
1227
1228
1229	/**
1230	* Lookup a GVM structure by the shared VM structure
1231	* and ensuring that the caller is the EMT thread.
1232	*
1233	* @returns VBox status code.
1234	* @param pVM The shared VM structure (the ring-0 mapping).
1235	* @param idCpu VCPU id
1236	* @param ppGVM Where to store the GVM pointer.
1237	* @thread EMT
1238	*/
1239	GVMMR0DECL(int) GVMMR0ByVMAndEMT(PVM pVM, unsigned idCpu, PGVM *ppGVM)
1240	{
1241	AssertPtrReturn(ppGVM, VERR_INVALID_POINTER);
1242	PGVMM pGVMM;
1243	return gvmmR0ByVMAndEMT(pVM, idCpu, ppGVM, &pGVMM);
1244	}
1245
1246
1247	/**
1248	* Lookup a VM by its global handle.
1249	*
1250	* @returns The VM handle on success, NULL on failure.
1251	* @param hGVM The global VM handle. Asserts on bad handle.
1252	*/
1253	GVMMR0DECL(PVM) GVMMR0GetVMByHandle(uint32_t hGVM)
1254	{
1255	PGVM pGVM = GVMMR0ByHandle(hGVM);
1256	return pGVM ? pGVM->pVM : NULL;
1257	}
1258
1259
1260	/**
1261	* Looks up the VM belonging to the specified EMT thread.
1262	*
1263	* This is used by the assertion machinery in VMMR0.cpp to avoid causing
1264	* unnecessary kernel panics when the EMT thread hits an assertion. The
1265	* call may or not be an EMT thread.
1266	*
1267	* @returns The VM handle on success, NULL on failure.
1268	* @param hEMT The native thread handle of the EMT.
1269	* NIL_RTNATIVETHREAD means the current thread
1270	*/
1271	GVMMR0DECL(PVM) GVMMR0GetVMByEMT(RTNATIVETHREAD hEMT)
1272	{
1273	/*
1274	* No Assertions here as we're usually called in a AssertMsgN or
1275	* RTAssert* context.
1276	*/
1277	PGVMM pGVMM = g_pGVMM;
1278	if ( !VALID_PTR(pGVMM)
1279	\|\| pGVMM->u32Magic != GVMM_MAGIC)
1280	return NULL;
1281
1282	if (hEMT == NIL_RTNATIVETHREAD)
1283	hEMT = RTThreadNativeSelf();
1284
1285	/*
1286	* Search the handles in a linear fashion as we don't dare to take the lock (assert).
1287	*/
1288	for (unsigned i = 1; i < RT_ELEMENTS(pGVMM->aHandles); i++)
1289	{
1290	if ( pGVMM->aHandles[i].iSelf == i
1291	&& VALID_PTR(pGVMM->aHandles[i].pvObj)
1292	&& VALID_PTR(pGVMM->aHandles[i].pVM)
1293	&& VALID_PTR(pGVMM->aHandles[i].pGVM))
1294	{
1295	PGVM pGVM = pGVMM->aHandles[i].pGVM;
1296
1297	for (unsigned idCpu = 0; idCpu < pGVM->cCPUs; idCpu++)
1298	if (pGVM->aCpus[idCpu].hEMT == hEMT)
1299	return pGVMM->aHandles[i].pVM;
1300	}
1301	}
1302	return NULL;
1303	}
1304
1305
1306	/**
1307	* This is will wake up expired and soon-to-be expired VMs.
1308	*
1309	* @returns Number of VMs that has been woken up.
1310	* @param pGVMM Pointer to the GVMM instance data.
1311	* @param u64Now The current time.
1312	*/
1313	static unsigned gvmmR0SchedDoWakeUps(PGVMM pGVMM, uint64_t u64Now)
1314	{
1315	/*
1316	* The first pass will wake up VMs which have actually expired
1317	* and look for VMs that should be woken up in the 2nd and 3rd passes.
1318	*/
1319	unsigned cWoken = 0;
1320	unsigned cHalted = 0;
1321	unsigned cTodo2nd = 0;
1322	unsigned cTodo3rd = 0;
1323	for (unsigned i = pGVMM->iUsedHead, cGuard = 0;
1324	i != NIL_GVM_HANDLE && i < RT_ELEMENTS(pGVMM->aHandles);
1325	i = pGVMM->aHandles[i].iNext)
1326	{
1327	PGVM pCurGVM = pGVMM->aHandles[i].pGVM;
1328	if ( VALID_PTR(pCurGVM)
1329	&& pCurGVM->u32Magic == GVM_MAGIC)
1330	{
1331	for (unsigned idCpu = 0; idCpu < pCurGVM->cCPUs; idCpu++)
1332	{
1333	PGVMCPU pCurGVCpu = &pCurGVM->aCpus[idCpu];
1334
1335	uint64_t u64 = pCurGVCpu->gvmm.s.u64HaltExpire;
1336	if (u64)
1337	{
1338	if (u64 <= u64Now)
1339	{
1340	if (ASMAtomicXchgU64(&pCurGVCpu->gvmm.s.u64HaltExpire, 0))
1341	{
1342	int rc = RTSemEventMultiSignal(pCurGVCpu->gvmm.s.HaltEventMulti);
1343	AssertRC(rc);
1344	cWoken++;
1345	}
1346	}
1347	else
1348	{
1349	cHalted++;
1350	if (u64 <= u64Now + pGVMM->nsEarlyWakeUp1)
1351	cTodo2nd++;
1352	else if (u64 <= u64Now + pGVMM->nsEarlyWakeUp2)
1353	cTodo3rd++;
1354	}
1355	}
1356	}
1357	}
1358	AssertLogRelBreak(cGuard++ < RT_ELEMENTS(pGVMM->aHandles));
1359	}
1360
1361	if (cTodo2nd)
1362	{
1363	for (unsigned i = pGVMM->iUsedHead, cGuard = 0;
1364	i != NIL_GVM_HANDLE && i < RT_ELEMENTS(pGVMM->aHandles);
1365	i = pGVMM->aHandles[i].iNext)
1366	{
1367	PGVM pCurGVM = pGVMM->aHandles[i].pGVM;
1368	if ( VALID_PTR(pCurGVM)
1369	&& pCurGVM->u32Magic == GVM_MAGIC)
1370	{
1371	for (unsigned idCpu = 0; idCpu < pCurGVM->cCPUs; idCpu++)
1372	{
1373	PGVMCPU pCurGVCpu = &pCurGVM->aCpus[idCpu];
1374
1375	if ( pCurGVCpu->gvmm.s.u64HaltExpire
1376	&& pCurGVCpu->gvmm.s.u64HaltExpire <= u64Now + pGVMM->nsEarlyWakeUp1)
1377	{
1378	if (ASMAtomicXchgU64(&pCurGVCpu->gvmm.s.u64HaltExpire, 0))
1379	{
1380	int rc = RTSemEventMultiSignal(pCurGVCpu->gvmm.s.HaltEventMulti);
1381	AssertRC(rc);
1382	cWoken++;
1383	}
1384	}
1385	}
1386	}
1387	AssertLogRelBreak(cGuard++ < RT_ELEMENTS(pGVMM->aHandles));
1388	}
1389	}
1390
1391	if (cTodo3rd)
1392	{
1393	for (unsigned i = pGVMM->iUsedHead, cGuard = 0;
1394	i != NIL_GVM_HANDLE && i < RT_ELEMENTS(pGVMM->aHandles);
1395	i = pGVMM->aHandles[i].iNext)
1396	{
1397	PGVM pCurGVM = pGVMM->aHandles[i].pGVM;
1398	if ( VALID_PTR(pCurGVM)
1399	&& pCurGVM->u32Magic == GVM_MAGIC)
1400	{
1401	for (unsigned idCpu = 0; idCpu < pCurGVM->cCPUs; idCpu++)
1402	{
1403	PGVMCPU pCurGVCpu = &pCurGVM->aCpus[idCpu];
1404
1405	if ( pCurGVCpu->gvmm.s.u64HaltExpire
1406	&& pCurGVCpu->gvmm.s.u64HaltExpire <= u64Now + pGVMM->nsEarlyWakeUp2)
1407	{
1408	if (ASMAtomicXchgU64(&pCurGVCpu->gvmm.s.u64HaltExpire, 0))
1409	{
1410	int rc = RTSemEventMultiSignal(pCurGVCpu->gvmm.s.HaltEventMulti);
1411	AssertRC(rc);
1412	cWoken++;
1413	}
1414	}
1415	}
1416	}
1417	AssertLogRelBreak(cGuard++ < RT_ELEMENTS(pGVMM->aHandles));
1418	}
1419	}
1420
1421	return cWoken;
1422	}
1423
1424
1425	/**
1426	* Halt the EMT thread.
1427	*
1428	* @returns VINF_SUCCESS normal wakeup (timeout or kicked by other thread).
1429	* VERR_INTERRUPTED if a signal was scheduled for the thread.
1430	* @param pVM Pointer to the shared VM structure.
1431	* @param idCpu VCPU id
1432	* @param u64ExpireGipTime The time for the sleep to expire expressed as GIP time.
1433	* @thread EMT.
1434	*/
1435	GVMMR0DECL(int) GVMMR0SchedHalt(PVM pVM, unsigned idCpu, uint64_t u64ExpireGipTime)
1436	{
1437	LogFlow(("GVMMR0SchedHalt: pVM=%p\n", pVM));
1438
1439	/*
1440	* Validate the VM structure, state and handle.
1441	*/
1442	PGVMM pGVMM;
1443	PGVM pGVM;
1444	PGVMCPU pCurGVCpu;
1445
1446	int rc = gvmmR0ByVMAndEMT(pVM, idCpu, &pGVM, &pGVMM);
1447	if (RT_FAILURE(rc))
1448	return rc;
1449
1450	pGVM->gvmm.s.StatsSched.cHaltCalls++;
1451
1452	pCurGVCpu = &pGVM->aCpus[idCpu];
1453	Assert(idCpu < pGVM->cCPUs);
1454	Assert(!pCurGVCpu->gvmm.s.u64HaltExpire);
1455
1456	/*
1457	* Take the UsedList semaphore, get the current time
1458	* and check if anyone needs waking up.
1459	* Interrupts must NOT be disabled at this point because we ask for GIP time!
1460	*/
1461	rc = gvmmR0UsedLock(pGVMM);
1462	AssertRC(rc);
1463
1464	pCurGVCpu->gvmm.s.iCpuEmt = ASMGetApicId();
1465
1466	Assert(ASMGetFlags() & X86_EFL_IF);
1467	const uint64_t u64Now = RTTimeNanoTS(); /* (GIP time) */
1468	pGVM->gvmm.s.StatsSched.cHaltWakeUps += gvmmR0SchedDoWakeUps(pGVMM, u64Now);
1469
1470	/*
1471	* Go to sleep if we must...
1472	*/
1473	if ( u64Now < u64ExpireGipTime
1474	&& u64ExpireGipTime - u64Now > (pGVMM->cVMs > pGVMM->cVMsMeansCompany
1475	? pGVMM->nsMinSleepCompany
1476	: pGVMM->nsMinSleepAlone))
1477	{
1478	pGVM->gvmm.s.StatsSched.cHaltBlocking++;
1479	ASMAtomicXchgU64(&pCurGVCpu->gvmm.s.u64HaltExpire, u64ExpireGipTime);
1480	gvmmR0UsedUnlock(pGVMM);
1481
1482	uint32_t cMillies = (u64ExpireGipTime - u64Now) / 1000000;
1483	rc = RTSemEventMultiWaitNoResume(pCurGVCpu->gvmm.s.HaltEventMulti, cMillies ? cMillies : 1);
1484	ASMAtomicXchgU64(&pCurGVCpu->gvmm.s.u64HaltExpire, 0);
1485	if (rc == VERR_TIMEOUT)
1486	{
1487	pGVM->gvmm.s.StatsSched.cHaltTimeouts++;
1488	rc = VINF_SUCCESS;
1489	}
1490	}
1491	else
1492	{
1493	pGVM->gvmm.s.StatsSched.cHaltNotBlocking++;
1494	gvmmR0UsedUnlock(pGVMM);
1495	}
1496
1497	/* Make sure false wake up calls (gvmmR0SchedDoWakeUps) cause us to spin. */
1498	RTSemEventMultiReset(pCurGVCpu->gvmm.s.HaltEventMulti);
1499
1500	return rc;
1501	}
1502
1503
1504	/**
1505	* Wakes up the halted EMT thread so it can service a pending request.
1506	*
1507	* @returns VINF_SUCCESS if not yielded.
1508	* VINF_GVM_NOT_BLOCKED if the EMT thread wasn't blocked.
1509	* @param pVM Pointer to the shared VM structure.
1510	* @param idCpu VCPU id
1511	* @thread Any but EMT.
1512	*/
1513	GVMMR0DECL(int) GVMMR0SchedWakeUp(PVM pVM, unsigned idCpu)
1514	{
1515	/*
1516	* Validate input and take the UsedLock.
1517	*/
1518	PGVMM pGVMM;
1519	PGVM pGVM;
1520	PGVMCPU pCurGVCpu;
1521
1522	int rc = gvmmR0ByVM(pVM, &pGVM, &pGVMM, true /* fTakeUsedLock */);
1523	if (RT_SUCCESS(rc))
1524	{
1525	Assert(idCpu < pGVM->cCPUs);
1526
1527	pCurGVCpu = &pGVM->aCpus[idCpu];
1528
1529	pGVM->gvmm.s.StatsSched.cWakeUpCalls++;
1530
1531	/*
1532	* Signal the semaphore regardless of whether it's current blocked on it.
1533	*
1534	* The reason for this is that there is absolutely no way we can be 100%
1535	* certain that it isn't about go to go to sleep on it and just got
1536	* delayed a bit en route. So, we will always signal the semaphore when
1537	* the it is flagged as halted in the VMM.
1538	*/
1539	if (pCurGVCpu->gvmm.s.u64HaltExpire)
1540	{
1541	rc = VINF_SUCCESS;
1542	ASMAtomicXchgU64(&pCurGVCpu->gvmm.s.u64HaltExpire, 0);
1543	}
1544	else
1545	{
1546	rc = VINF_GVM_NOT_BLOCKED;
1547	pGVM->gvmm.s.StatsSched.cWakeUpNotHalted++;
1548	}
1549
1550	int rc2 = RTSemEventMultiSignal(pCurGVCpu->gvmm.s.HaltEventMulti);
1551	AssertRC(rc2);
1552
1553	/*
1554	* While we're here, do a round of scheduling.
1555	*/
1556	Assert(ASMGetFlags() & X86_EFL_IF);
1557	const uint64_t u64Now = RTTimeNanoTS(); /* (GIP time) */
1558	pGVM->gvmm.s.StatsSched.cWakeUpWakeUps += gvmmR0SchedDoWakeUps(pGVMM, u64Now);
1559
1560
1561	rc2 = gvmmR0UsedUnlock(pGVMM);
1562	AssertRC(rc2);
1563	}
1564
1565	LogFlow(("GVMMR0SchedWakeUp: returns %Rrc\n", rc));
1566	return rc;
1567	}
1568
1569
1570	/**
1571	* Poll the schedule to see if someone else should get a chance to run.
1572	*
1573	* This is a bit hackish and will not work too well if the machine is
1574	* under heavy load from non-VM processes.
1575	*
1576	* @returns VINF_SUCCESS if not yielded.
1577	* VINF_GVM_YIELDED if an attempt to switch to a different VM task was made.
1578	* @param pVM Pointer to the shared VM structure.
1579	* @param idCpu VCPU id
1580	* @param u64ExpireGipTime The time for the sleep to expire expressed as GIP time.
1581	* @param fYield Whether to yield or not.
1582	* This is for when we're spinning in the halt loop.
1583	* @thread EMT.
1584	*/
1585	GVMMR0DECL(int) GVMMR0SchedPoll(PVM pVM, unsigned idCpu, bool fYield)
1586	{
1587	/*
1588	* Validate input.
1589	*/
1590	PGVM pGVM;
1591	PGVMM pGVMM;
1592	int rc = gvmmR0ByVMAndEMT(pVM, idCpu, &pGVM, &pGVMM);
1593	if (RT_SUCCESS(rc))
1594	{
1595	rc = gvmmR0UsedLock(pGVMM);
1596	AssertRC(rc);
1597	pGVM->gvmm.s.StatsSched.cPollCalls++;
1598
1599	Assert(ASMGetFlags() & X86_EFL_IF);
1600	const uint64_t u64Now = RTTimeNanoTS(); /* (GIP time) */
1601
1602	if (!fYield)
1603	pGVM->gvmm.s.StatsSched.cPollWakeUps += gvmmR0SchedDoWakeUps(pGVMM, u64Now);
1604	else
1605	{
1606	/** @todo implement this... */
1607	rc = VERR_NOT_IMPLEMENTED;
1608	}
1609
1610	gvmmR0UsedUnlock(pGVMM);
1611	}
1612
1613	LogFlow(("GVMMR0SchedWakeUp: returns %Rrc\n", rc));
1614	return rc;
1615	}
1616
1617
1618
1619	/**
1620	* Retrieves the GVMM statistics visible to the caller.
1621	*
1622	* @returns VBox status code.
1623	*
1624	* @param pStats Where to put the statistics.
1625	* @param pSession The current session.
1626	* @param pVM The VM to obtain statistics for. Optional.
1627	*/
1628	GVMMR0DECL(int) GVMMR0QueryStatistics(PGVMMSTATS pStats, PSUPDRVSESSION pSession, PVM pVM)
1629	{
1630	LogFlow(("GVMMR0QueryStatistics: pStats=%p pSession=%p pVM=%p\n", pStats, pSession, pVM));
1631
1632	/*
1633	* Validate input.
1634	*/
1635	AssertPtrReturn(pSession, VERR_INVALID_POINTER);
1636	AssertPtrReturn(pStats, VERR_INVALID_POINTER);
1637	pStats->cVMs = 0; /* (crash before taking the sem...) */
1638
1639	/*
1640	* Take the lock and get the VM statistics.
1641	*/
1642	PGVMM pGVMM;
1643	if (pVM)
1644	{
1645	PGVM pGVM;
1646	int rc = gvmmR0ByVM(pVM, &pGVM, &pGVMM, true /fTakeUsedLock/);
1647	if (RT_FAILURE(rc))
1648	return rc;
1649	pStats->SchedVM = pGVM->gvmm.s.StatsSched;
1650	}
1651	else
1652	{
1653	GVMM_GET_VALID_INSTANCE(pGVMM, VERR_INTERNAL_ERROR);
1654	memset(&pStats->SchedVM, 0, sizeof(pStats->SchedVM));
1655
1656	int rc = gvmmR0UsedLock(pGVMM);
1657	AssertRCReturn(rc, rc);
1658	}
1659
1660	/*
1661	* Enumerate the VMs and add the ones visibile to the statistics.
1662	*/
1663	pStats->cVMs = 0;
1664	memset(&pStats->SchedSum, 0, sizeof(pStats->SchedSum));
1665
1666	for (unsigned i = pGVMM->iUsedHead;
1667	i != NIL_GVM_HANDLE && i < RT_ELEMENTS(pGVMM->aHandles);
1668	i = pGVMM->aHandles[i].iNext)
1669	{
1670	PGVM pGVM = pGVMM->aHandles[i].pGVM;
1671	void *pvObj = pGVMM->aHandles[i].pvObj;
1672	if ( VALID_PTR(pvObj)
1673	&& VALID_PTR(pGVM)
1674	&& pGVM->u32Magic == GVM_MAGIC
1675	&& RT_SUCCESS(SUPR0ObjVerifyAccess(pvObj, pSession, NULL)))
1676	{
1677	pStats->cVMs++;
1678
1679	pStats->SchedSum.cHaltCalls += pGVM->gvmm.s.StatsSched.cHaltCalls;
1680	pStats->SchedSum.cHaltBlocking += pGVM->gvmm.s.StatsSched.cHaltBlocking;
1681	pStats->SchedSum.cHaltTimeouts += pGVM->gvmm.s.StatsSched.cHaltTimeouts;
1682	pStats->SchedSum.cHaltNotBlocking += pGVM->gvmm.s.StatsSched.cHaltNotBlocking;
1683	pStats->SchedSum.cHaltWakeUps += pGVM->gvmm.s.StatsSched.cHaltWakeUps;
1684
1685	pStats->SchedSum.cWakeUpCalls += pGVM->gvmm.s.StatsSched.cWakeUpCalls;
1686	pStats->SchedSum.cWakeUpNotHalted += pGVM->gvmm.s.StatsSched.cWakeUpNotHalted;
1687	pStats->SchedSum.cWakeUpWakeUps += pGVM->gvmm.s.StatsSched.cWakeUpWakeUps;
1688
1689	pStats->SchedSum.cPollCalls += pGVM->gvmm.s.StatsSched.cPollCalls;
1690	pStats->SchedSum.cPollHalts += pGVM->gvmm.s.StatsSched.cPollHalts;
1691	pStats->SchedSum.cPollWakeUps += pGVM->gvmm.s.StatsSched.cPollWakeUps;
1692	}
1693	}
1694
1695	gvmmR0UsedUnlock(pGVMM);
1696
1697	return VINF_SUCCESS;
1698	}
1699
1700
1701	/**
1702	* VMMR0 request wrapper for GVMMR0QueryStatistics.
1703	*
1704	* @returns see GVMMR0QueryStatistics.
1705	* @param pVM Pointer to the shared VM structure. Optional.
1706	* @param pReq The request packet.
1707	*/
1708	GVMMR0DECL(int) GVMMR0QueryStatisticsReq(PVM pVM, PGVMMQUERYSTATISTICSSREQ pReq)
1709	{
1710	/*
1711	* Validate input and pass it on.
1712	*/
1713	AssertPtrReturn(pReq, VERR_INVALID_POINTER);
1714	AssertMsgReturn(pReq->Hdr.cbReq == sizeof(pReq), ("%#x != %#x\n", pReq->Hdr.cbReq, sizeof(pReq)), VERR_INVALID_PARAMETER);
1715
1716	return GVMMR0QueryStatistics(&pReq->Stats, pReq->pSession, pVM);
1717	}
1718
1719
1720	/**
1721	* Resets the specified GVMM statistics.
1722	*
1723	* @returns VBox status code.
1724	*
1725	* @param pStats Which statistics to reset, that is, non-zero fields indicates which to reset.
1726	* @param pSession The current session.
1727	* @param pVM The VM to reset statistics for. Optional.
1728	*/
1729	GVMMR0DECL(int) GVMMR0ResetStatistics(PCGVMMSTATS pStats, PSUPDRVSESSION pSession, PVM pVM)
1730	{
1731	LogFlow(("GVMMR0ResetStatistics: pStats=%p pSession=%p pVM=%p\n", pStats, pSession, pVM));
1732
1733	/*
1734	* Validate input.
1735	*/
1736	AssertPtrReturn(pSession, VERR_INVALID_POINTER);
1737	AssertPtrReturn(pStats, VERR_INVALID_POINTER);
1738
1739	/*
1740	* Take the lock and get the VM statistics.
1741	*/
1742	PGVMM pGVMM;
1743	if (pVM)
1744	{
1745	PGVM pGVM;
1746	int rc = gvmmR0ByVM(pVM, &pGVM, &pGVMM, true /fTakeUsedLock/);
1747	if (RT_FAILURE(rc))
1748	return rc;
1749	# define MAYBE_RESET_FIELD(field) \
1750	do { if (pStats->SchedVM. field ) { pGVM->gvmm.s.StatsSched. field = 0; } } while (0)
1751	MAYBE_RESET_FIELD(cHaltCalls);
1752	MAYBE_RESET_FIELD(cHaltBlocking);
1753	MAYBE_RESET_FIELD(cHaltTimeouts);
1754	MAYBE_RESET_FIELD(cHaltNotBlocking);
1755	MAYBE_RESET_FIELD(cHaltWakeUps);
1756	MAYBE_RESET_FIELD(cWakeUpCalls);
1757	MAYBE_RESET_FIELD(cWakeUpNotHalted);
1758	MAYBE_RESET_FIELD(cWakeUpWakeUps);
1759	MAYBE_RESET_FIELD(cPollCalls);
1760	MAYBE_RESET_FIELD(cPollHalts);
1761	MAYBE_RESET_FIELD(cPollWakeUps);
1762	# undef MAYBE_RESET_FIELD
1763	}
1764	else
1765	{
1766	GVMM_GET_VALID_INSTANCE(pGVMM, VERR_INTERNAL_ERROR);
1767
1768	int rc = gvmmR0UsedLock(pGVMM);
1769	AssertRCReturn(rc, rc);
1770	}
1771
1772	/*
1773	* Enumerate the VMs and add the ones visibile to the statistics.
1774	*/
1775	if (ASMMemIsAll8(&pStats->SchedSum, sizeof(pStats->SchedSum), 0))
1776	{
1777	for (unsigned i = pGVMM->iUsedHead;
1778	i != NIL_GVM_HANDLE && i < RT_ELEMENTS(pGVMM->aHandles);
1779	i = pGVMM->aHandles[i].iNext)
1780	{
1781	PGVM pGVM = pGVMM->aHandles[i].pGVM;
1782	void *pvObj = pGVMM->aHandles[i].pvObj;
1783	if ( VALID_PTR(pvObj)
1784	&& VALID_PTR(pGVM)
1785	&& pGVM->u32Magic == GVM_MAGIC
1786	&& RT_SUCCESS(SUPR0ObjVerifyAccess(pvObj, pSession, NULL)))
1787	{
1788	# define MAYBE_RESET_FIELD(field) \
1789	do { if (pStats->SchedSum. field ) { pGVM->gvmm.s.StatsSched. field = 0; } } while (0)
1790	MAYBE_RESET_FIELD(cHaltCalls);
1791	MAYBE_RESET_FIELD(cHaltBlocking);
1792	MAYBE_RESET_FIELD(cHaltTimeouts);
1793	MAYBE_RESET_FIELD(cHaltNotBlocking);
1794	MAYBE_RESET_FIELD(cHaltWakeUps);
1795	MAYBE_RESET_FIELD(cWakeUpCalls);
1796	MAYBE_RESET_FIELD(cWakeUpNotHalted);
1797	MAYBE_RESET_FIELD(cWakeUpWakeUps);
1798	MAYBE_RESET_FIELD(cPollCalls);
1799	MAYBE_RESET_FIELD(cPollHalts);
1800	MAYBE_RESET_FIELD(cPollWakeUps);
1801	# undef MAYBE_RESET_FIELD
1802	}
1803	}
1804	}
1805
1806	gvmmR0UsedUnlock(pGVMM);
1807
1808	return VINF_SUCCESS;
1809	}
1810
1811
1812	/**
1813	* VMMR0 request wrapper for GVMMR0ResetStatistics.
1814	*
1815	* @returns see GVMMR0ResetStatistics.
1816	* @param pVM Pointer to the shared VM structure. Optional.
1817	* @param pReq The request packet.
1818	*/
1819	GVMMR0DECL(int) GVMMR0ResetStatisticsReq(PVM pVM, PGVMMRESETSTATISTICSSREQ pReq)
1820	{
1821	/*
1822	* Validate input and pass it on.
1823	*/
1824	AssertPtrReturn(pReq, VERR_INVALID_POINTER);
1825	AssertMsgReturn(pReq->Hdr.cbReq == sizeof(pReq), ("%#x != %#x\n", pReq->Hdr.cbReq, sizeof(pReq)), VERR_INVALID_PARAMETER);
1826
1827	return GVMMR0ResetStatistics(&pReq->Stats, pReq->pSession, pVM);
1828	}
1829

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

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

Download in other formats: