GVMMR0.cpp@ 13789

Last change on this file since 13789 was 13789, checked in by vboxsync, 16 years ago
VMM: Ring-0 initializes VM::cCPUs, VMR3CreateVM validates i'ts input before doing anything, and use AssertLogRel.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 54.8 KB

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

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

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

Download in other formats: