GVMMR0.cpp@ 7508

Last change on this file since 7508 was 7135, checked in by vboxsync, 17 years ago
Fixed uninitialized cGuard variable. Fixes 2691.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 53.7 KB

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

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

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

Download in other formats: