MMHyper.cpp@ 34147

Last change on this file since 34147 was 33998, checked in by vboxsync, 14 years ago
MM: even larger hyperheap for ICH9
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 49.8 KB

Line
1	/* $Id: MMHyper.cpp 33998 2010-11-11 14:52:22Z vboxsync $ */
2	/** @file
3	* MM - Memory Manager - Hypervisor Memory Area.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*******************************************************************************
20	* Header Files *
21	*******************************************************************************/
22	#define LOG_GROUP LOG_GROUP_MM_HYPER
23	#include <VBox/pgm.h>
24	#include <VBox/mm.h>
25	#include <VBox/dbgf.h>
26	#include "MMInternal.h"
27	#include <VBox/vm.h>
28	#include <VBox/err.h>
29	#include <VBox/param.h>
30	#include <VBox/log.h>
31	#include <include/internal/pgm.h>
32	#include <iprt/alloc.h>
33	#include <iprt/assert.h>
34	#include <iprt/string.h>
35
36
37	/*******************************************************************************
38	* Internal Functions *
39	*******************************************************************************/
40	static DECLCALLBACK(bool) mmR3HyperRelocateCallback(PVM pVM, RTGCPTR GCPtrOld, RTGCPTR GCPtrNew, PGMRELOCATECALL enmMode, void *pvUser);
41	static int mmR3HyperMap(PVM pVM, const size_t cb, const char pszDesc, PRTGCPTR pGCPtr, PMMLOOKUPHYPER ppLookup);
42	static int mmR3HyperHeapCreate(PVM pVM, const size_t cb, PMMHYPERHEAP *ppHeap, PRTR0PTR pR0PtrHeap);
43	static int mmR3HyperHeapMap(PVM pVM, PMMHYPERHEAP pHeap, PRTGCPTR ppHeapGC);
44	static DECLCALLBACK(void) mmR3HyperInfoHma(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
45
46
47	DECLINLINE(uint32_t) mmR3ComputeHyperHeapSize(PVM pVM, bool fCanUseLargerHeap)
48	{
49	bool fHwVirtExtForced = VMMIsHwVirtExtForced(pVM);
50
51	/* Newer chipset allows for much more devices, putting additional pressure on hyperheap */
52	/* @todo: maybe base hyperheap size upon number of devices attached too */
53	if (fCanUseLargerHeap)
54	return _2M + pVM->cCpus * 2 * _64K;
55
56	if (pVM->cCpus > 1)
57	return _1M + pVM->cCpus * 2 * _64K;
58
59	if (fHwVirtExtForced)
60	{
61	uint64_t cbRam = 0;
62	CFGMR3QueryU64(CFGMR3GetRoot(pVM), "RamSize", &cbRam);
63
64	/* Need a bit more space for large memory guests. (@todo: only for shadow paging!) */
65	if (cbRam >= _4G)
66	return _1M;
67	else
68	return 640 * _1K;
69	}
70	else
71	/* Size must be kept like this for saved state compatibility (only for raw mode though). */
72	return 1280*_1K;
73	}
74
75
76	/**
77	* Initializes the hypervisor related MM stuff without
78	* calling down to PGM.
79	*
80	* PGM is not initialized at this point, PGM relies on
81	* the heap to initialize.
82	*
83	* @returns VBox status.
84	*/
85	int mmR3HyperInit(PVM pVM)
86	{
87	LogFlow(("mmR3HyperInit:\n"));
88
89	/*
90	* Decide Hypervisor mapping in the guest context
91	* And setup various hypervisor area and heap parameters.
92	*/
93	pVM->mm.s.pvHyperAreaGC = (RTGCPTR)MM_HYPER_AREA_ADDRESS;
94	pVM->mm.s.cbHyperArea = MM_HYPER_AREA_MAX_SIZE;
95	AssertRelease(RT_ALIGN_T(pVM->mm.s.pvHyperAreaGC, 1 << X86_PD_SHIFT, RTGCPTR) == pVM->mm.s.pvHyperAreaGC);
96	Assert(pVM->mm.s.pvHyperAreaGC < 0xff000000);
97
98	/** @todo @bugref{1865}, @bugref{3202}: Change the cbHyperHeap default
99	* depending on whether VT-x/AMD-V is enabled or not! Don't waste
100	* precious kernel space on heap for the PATM.
101	*/
102	PCFGMNODE pMM = CFGMR3GetChild(CFGMR3GetRoot(pVM), "MM");
103	bool fCanUseLargerHeap = false;
104	int rc = CFGMR3QueryBoolDef(pMM, "CanUseLargerHeap", &fCanUseLargerHeap, false);
105	uint32_t cbHyperHeap = mmR3ComputeHyperHeapSize(pVM, fCanUseLargerHeap);
106	rc = CFGMR3QueryU32Def(pMM, "cbHyperHeap", &cbHyperHeap, cbHyperHeap);
107	AssertLogRelRCReturn(rc, rc);
108
109	cbHyperHeap = RT_ALIGN_32(cbHyperHeap, PAGE_SIZE);
110	LogRel(("MM: cbHyperHeap=%#x (%u)\n", cbHyperHeap, cbHyperHeap));
111
112	/*
113	* Allocate the hypervisor heap.
114	*
115	* (This must be done before we start adding memory to the
116	* hypervisor static area because lookup records are allocated from it.)
117	*/
118	rc = mmR3HyperHeapCreate(pVM, cbHyperHeap, &pVM->mm.s.pHyperHeapR3, &pVM->mm.s.pHyperHeapR0);
119	if (RT_SUCCESS(rc))
120	{
121	/*
122	* Make a small head fence to fend of accidental sequential access.
123	*/
124	MMR3HyperReserve(pVM, PAGE_SIZE, "fence", NULL);
125
126	/*
127	* Map the VM structure into the hypervisor space.
128	*/
129	AssertRelease(pVM->cbSelf == RT_UOFFSETOF(VM, aCpus[pVM->cCpus]));
130	RTGCPTR GCPtr;
131	rc = MMR3HyperMapPages(pVM, pVM, pVM->pVMR0, RT_ALIGN_Z(pVM->cbSelf, PAGE_SIZE) >> PAGE_SHIFT, pVM->paVMPagesR3, "VM", &GCPtr);
132	if (RT_SUCCESS(rc))
133	{
134	pVM->pVMRC = (RTRCPTR)GCPtr;
135	for (VMCPUID i = 0; i < pVM->cCpus; i++)
136	pVM->aCpus[i].pVMRC = pVM->pVMRC;
137
138	/* Reserve a page for fencing. */
139	MMR3HyperReserve(pVM, PAGE_SIZE, "fence", NULL);
140
141	/*
142	* Map the heap into the hypervisor space.
143	*/
144	rc = mmR3HyperHeapMap(pVM, pVM->mm.s.pHyperHeapR3, &GCPtr);
145	if (RT_SUCCESS(rc))
146	{
147	pVM->mm.s.pHyperHeapRC = (RTRCPTR)GCPtr;
148	Assert(pVM->mm.s.pHyperHeapRC == GCPtr);
149
150	/*
151	* Register info handlers.
152	*/
153	DBGFR3InfoRegisterInternal(pVM, "hma", "Show the layout of the Hypervisor Memory Area.", mmR3HyperInfoHma);
154
155	LogFlow(("mmR3HyperInit: returns VINF_SUCCESS\n"));
156	return VINF_SUCCESS;
157	}
158	/* Caller will do proper cleanup. */
159	}
160	}
161
162	LogFlow(("mmR3HyperInit: returns %Rrc\n", rc));
163	return rc;
164	}
165
166
167	/**
168	* Cleans up the hypervisor heap.
169	*
170	* @returns VBox status.
171	*/
172	int mmR3HyperTerm(PVM pVM)
173	{
174	if (pVM->mm.s.pHyperHeapR3)
175	PDMR3CritSectDelete(&pVM->mm.s.pHyperHeapR3->Lock);
176
177	return VINF_SUCCESS;
178	}
179
180
181	/**
182	* Finalizes the HMA mapping.
183	*
184	* This is called later during init, most (all) HMA allocations should be done
185	* by the time this function is called.
186	*
187	* @returns VBox status.
188	*/
189	VMMR3DECL(int) MMR3HyperInitFinalize(PVM pVM)
190	{
191	LogFlow(("MMR3HyperInitFinalize:\n"));
192
193	/*
194	* Initialize the hyper heap critical section.
195	*/
196	int rc = PDMR3CritSectInit(pVM, &pVM->mm.s.pHyperHeapR3->Lock, RT_SRC_POS, "MM-HYPER");
197	AssertRC(rc);
198
199	/*
200	* Adjust and create the HMA mapping.
201	*/
202	while ((RTINT)pVM->mm.s.offHyperNextStatic + 64*_1K < (RTINT)pVM->mm.s.cbHyperArea - _4M)
203	pVM->mm.s.cbHyperArea -= _4M;
204	rc = PGMR3MapPT(pVM, pVM->mm.s.pvHyperAreaGC, pVM->mm.s.cbHyperArea, 0 /fFlags/,
205	mmR3HyperRelocateCallback, NULL, "Hypervisor Memory Area");
206	if (RT_FAILURE(rc))
207	return rc;
208	pVM->mm.s.fPGMInitialized = true;
209
210	/*
211	* Do all the delayed mappings.
212	*/
213	PMMLOOKUPHYPER pLookup = (PMMLOOKUPHYPER)((uintptr_t)pVM->mm.s.pHyperHeapR3 + pVM->mm.s.offLookupHyper);
214	for (;;)
215	{
216	RTGCPTR GCPtr = pVM->mm.s.pvHyperAreaGC + pLookup->off;
217	uint32_t cPages = pLookup->cb >> PAGE_SHIFT;
218	switch (pLookup->enmType)
219	{
220	case MMLOOKUPHYPERTYPE_LOCKED:
221	{
222	PCRTHCPHYS paHCPhysPages = pLookup->u.Locked.paHCPhysPages;
223	for (uint32_t i = 0; i < cPages; i++)
224	{
225	rc = PGMMap(pVM, GCPtr + (i << PAGE_SHIFT), paHCPhysPages[i], PAGE_SIZE, 0);
226	AssertRCReturn(rc, rc);
227	}
228	break;
229	}
230
231	case MMLOOKUPHYPERTYPE_HCPHYS:
232	rc = PGMMap(pVM, GCPtr, pLookup->u.HCPhys.HCPhys, pLookup->cb, 0);
233	break;
234
235	case MMLOOKUPHYPERTYPE_GCPHYS:
236	{
237	const RTGCPHYS GCPhys = pLookup->u.GCPhys.GCPhys;
238	const uint32_t cb = pLookup->cb;
239	for (uint32_t off = 0; off < cb; off += PAGE_SIZE)
240	{
241	RTHCPHYS HCPhys;
242	rc = PGMPhysGCPhys2HCPhys(pVM, GCPhys + off, &HCPhys);
243	if (RT_FAILURE(rc))
244	break;
245	rc = PGMMap(pVM, GCPtr + off, HCPhys, PAGE_SIZE, 0);
246	if (RT_FAILURE(rc))
247	break;
248	}
249	break;
250	}
251
252	case MMLOOKUPHYPERTYPE_MMIO2:
253	{
254	const RTGCPHYS offEnd = pLookup->u.MMIO2.off + pLookup->cb;
255	for (RTGCPHYS offCur = pLookup->u.MMIO2.off; offCur < offEnd; offCur += PAGE_SIZE)
256	{
257	RTHCPHYS HCPhys;
258	rc = PGMR3PhysMMIO2GetHCPhys(pVM, pLookup->u.MMIO2.pDevIns, pLookup->u.MMIO2.iRegion, offCur, &HCPhys);
259	if (RT_FAILURE(rc))
260	break;
261	rc = PGMMap(pVM, GCPtr + (offCur - pLookup->u.MMIO2.off), HCPhys, PAGE_SIZE, 0);
262	if (RT_FAILURE(rc))
263	break;
264	}
265	break;
266	}
267
268	case MMLOOKUPHYPERTYPE_DYNAMIC:
269	/* do nothing here since these are either fences or managed by someone else using PGM. */
270	break;
271
272	default:
273	AssertMsgFailed(("enmType=%d\n", pLookup->enmType));
274	break;
275	}
276
277	if (RT_FAILURE(rc))
278	{
279	AssertMsgFailed(("rc=%Rrc cb=%d off=%#RX32 enmType=%d pszDesc=%s\n",
280	rc, pLookup->cb, pLookup->off, pLookup->enmType, pLookup->pszDesc));
281	return rc;
282	}
283
284	/* next */
285	if (pLookup->offNext == (int32_t)NIL_OFFSET)
286	break;
287	pLookup = (PMMLOOKUPHYPER)((uintptr_t)pLookup + pLookup->offNext);
288	}
289
290	LogFlow(("MMR3HyperInitFinalize: returns VINF_SUCCESS\n"));
291	return VINF_SUCCESS;
292	}
293
294
295	/**
296	* Callback function which will be called when PGM is trying to find
297	* a new location for the mapping.
298	*
299	* The callback is called in two modes, 1) the check mode and 2) the relocate mode.
300	* In 1) the callback should say if it objects to a suggested new location. If it
301	* accepts the new location, it is called again for doing it's relocation.
302	*
303	*
304	* @returns true if the location is ok.
305	* @returns false if another location should be found.
306	* @param pVM The VM handle.
307	* @param GCPtrOld The old virtual address.
308	* @param GCPtrNew The new virtual address.
309	* @param enmMode Used to indicate the callback mode.
310	* @param pvUser User argument. Ignored.
311	* @remark The return value is no a failure indicator, it's an acceptance
312	* indicator. Relocation can not fail!
313	*/
314	static DECLCALLBACK(bool) mmR3HyperRelocateCallback(PVM pVM, RTGCPTR GCPtrOld, RTGCPTR GCPtrNew, PGMRELOCATECALL enmMode, void *pvUser)
315	{
316	switch (enmMode)
317	{
318	/*
319	* Verify location - all locations are good for us.
320	*/
321	case PGMRELOCATECALL_SUGGEST:
322	return true;
323
324	/*
325	* Execute the relocation.
326	*/
327	case PGMRELOCATECALL_RELOCATE:
328	{
329	/*
330	* Accepted!
331	*/
332	AssertMsg(GCPtrOld == pVM->mm.s.pvHyperAreaGC, ("GCPtrOld=%RGv pVM->mm.s.pvHyperAreaGC=%RGv\n", GCPtrOld, pVM->mm.s.pvHyperAreaGC));
333	Log(("Relocating the hypervisor from %RGv to %RGv\n", GCPtrOld, GCPtrNew));
334
335	/*
336	* Relocate the VM structure and ourselves.
337	*/
338	RTGCINTPTR offDelta = GCPtrNew - GCPtrOld;
339	pVM->pVMRC += offDelta;
340	for (VMCPUID i = 0; i < pVM->cCpus; i++)
341	pVM->aCpus[i].pVMRC = pVM->pVMRC;
342
343	pVM->mm.s.pvHyperAreaGC += offDelta;
344	Assert(pVM->mm.s.pvHyperAreaGC < _4G);
345	pVM->mm.s.pHyperHeapRC += offDelta;
346	pVM->mm.s.pHyperHeapR3->pbHeapRC += offDelta;
347	pVM->mm.s.pHyperHeapR3->pVMRC = pVM->pVMRC;
348
349	/*
350	* Relocate the rest.
351	*/
352	VMR3Relocate(pVM, offDelta);
353	return true;
354	}
355
356	default:
357	AssertMsgFailed(("Invalid relocation mode %d\n", enmMode));
358	}
359
360	return false;
361	}
362
363	/**
364	* Service a VMMCALLRING3_MMHYPER_LOCK call.
365	*
366	* @returns VBox status code.
367	* @param pVM The VM handle.
368	*/
369	VMMR3DECL(int) MMR3LockCall(PVM pVM)
370	{
371	PMMHYPERHEAP pHeap = pVM->mm.s.CTX_SUFF(pHyperHeap);
372
373	int rc = PDMR3CritSectEnterEx(&pHeap->Lock, true /* fHostCall */);
374	AssertRC(rc);
375	return rc;
376	}
377
378	/**
379	* Maps contiguous HC physical memory into the hypervisor region in the GC.
380	*
381	* @return VBox status code.
382	*
383	* @param pVM VM handle.
384	* @param pvR3 Ring-3 address of the memory. Must be page aligned!
385	* @param pvR0 Optional ring-0 address of the memory.
386	* @param HCPhys Host context physical address of the memory to be
387	* mapped. Must be page aligned!
388	* @param cb Size of the memory. Will be rounded up to nearest page.
389	* @param pszDesc Description.
390	* @param pGCPtr Where to store the GC address.
391	*/
392	VMMR3DECL(int) MMR3HyperMapHCPhys(PVM pVM, void pvR3, RTR0PTR pvR0, RTHCPHYS HCPhys, size_t cb, const char pszDesc, PRTGCPTR pGCPtr)
393	{
394	LogFlow(("MMR3HyperMapHCPhys: pvR3=%p pvR0=%p HCPhys=%RHp cb=%d pszDesc=%p:{%s} pGCPtr=%p\n", pvR3, pvR0, HCPhys, (int)cb, pszDesc, pszDesc, pGCPtr));
395
396	/*
397	* Validate input.
398	*/
399	AssertReturn(RT_ALIGN_P(pvR3, PAGE_SIZE) == pvR3, VERR_INVALID_PARAMETER);
400	AssertReturn(RT_ALIGN_T(pvR0, PAGE_SIZE, RTR0PTR) == pvR0, VERR_INVALID_PARAMETER);
401	AssertReturn(RT_ALIGN_T(HCPhys, PAGE_SIZE, RTHCPHYS) == HCPhys, VERR_INVALID_PARAMETER);
402	AssertReturn(pszDesc && *pszDesc, VERR_INVALID_PARAMETER);
403
404	/*
405	* Add the memory to the hypervisor area.
406	*/
407	uint32_t cbAligned = RT_ALIGN_32(cb, PAGE_SIZE);
408	AssertReturn(cbAligned >= cb, VERR_INVALID_PARAMETER);
409	RTGCPTR GCPtr;
410	PMMLOOKUPHYPER pLookup;
411	int rc = mmR3HyperMap(pVM, cbAligned, pszDesc, &GCPtr, &pLookup);
412	if (RT_SUCCESS(rc))
413	{
414	pLookup->enmType = MMLOOKUPHYPERTYPE_HCPHYS;
415	pLookup->u.HCPhys.pvR3 = pvR3;
416	pLookup->u.HCPhys.pvR0 = pvR0;
417	pLookup->u.HCPhys.HCPhys = HCPhys;
418
419	/*
420	* Update the page table.
421	*/
422	if (pVM->mm.s.fPGMInitialized)
423	rc = PGMMap(pVM, GCPtr, HCPhys, cbAligned, 0);
424	if (RT_SUCCESS(rc))
425	*pGCPtr = GCPtr;
426	}
427	return rc;
428	}
429
430
431	/**
432	* Maps contiguous GC physical memory into the hypervisor region in the GC.
433	*
434	* @return VBox status code.
435	*
436	* @param pVM VM handle.
437	* @param GCPhys Guest context physical address of the memory to be mapped. Must be page aligned!
438	* @param cb Size of the memory. Will be rounded up to nearest page.
439	* @param pszDesc Mapping description.
440	* @param pGCPtr Where to store the GC address.
441	*/
442	VMMR3DECL(int) MMR3HyperMapGCPhys(PVM pVM, RTGCPHYS GCPhys, size_t cb, const char *pszDesc, PRTGCPTR pGCPtr)
443	{
444	LogFlow(("MMR3HyperMapGCPhys: GCPhys=%RGp cb=%d pszDesc=%p:{%s} pGCPtr=%p\n", GCPhys, (int)cb, pszDesc, pszDesc, pGCPtr));
445
446	/*
447	* Validate input.
448	*/
449	AssertReturn(RT_ALIGN_T(GCPhys, PAGE_SIZE, RTGCPHYS) == GCPhys, VERR_INVALID_PARAMETER);
450	AssertReturn(pszDesc && *pszDesc, VERR_INVALID_PARAMETER);
451
452	/*
453	* Add the memory to the hypervisor area.
454	*/
455	cb = RT_ALIGN_Z(cb, PAGE_SIZE);
456	RTGCPTR GCPtr;
457	PMMLOOKUPHYPER pLookup;
458	int rc = mmR3HyperMap(pVM, cb, pszDesc, &GCPtr, &pLookup);
459	if (RT_SUCCESS(rc))
460	{
461	pLookup->enmType = MMLOOKUPHYPERTYPE_GCPHYS;
462	pLookup->u.GCPhys.GCPhys = GCPhys;
463
464	/*
465	* Update the page table.
466	*/
467	for (unsigned off = 0; off < cb; off += PAGE_SIZE)
468	{
469	RTHCPHYS HCPhys;
470	rc = PGMPhysGCPhys2HCPhys(pVM, GCPhys + off, &HCPhys);
471	AssertRC(rc);
472	if (RT_FAILURE(rc))
473	{
474	AssertMsgFailed(("rc=%Rrc GCPhys=%RGp off=%#x %s\n", rc, GCPhys, off, pszDesc));
475	break;
476	}
477	if (pVM->mm.s.fPGMInitialized)
478	{
479	rc = PGMMap(pVM, GCPtr + off, HCPhys, PAGE_SIZE, 0);
480	AssertRC(rc);
481	if (RT_FAILURE(rc))
482	{
483	AssertMsgFailed(("rc=%Rrc GCPhys=%RGp off=%#x %s\n", rc, GCPhys, off, pszDesc));
484	break;
485	}
486	}
487	}
488
489	if (RT_SUCCESS(rc) && pGCPtr)
490	*pGCPtr = GCPtr;
491	}
492	return rc;
493	}
494
495
496	/**
497	* Maps a portion of an MMIO2 region into the hypervisor region.
498	*
499	* Callers of this API must never deregister the MMIO2 region before the
500	* VM is powered off. If this becomes a requirement MMR3HyperUnmapMMIO2
501	* API will be needed to perform cleanups.
502	*
503	* @return VBox status code.
504	*
505	* @param pVM Pointer to the shared VM structure.
506	* @param pDevIns The device owning the MMIO2 memory.
507	* @param iRegion The region.
508	* @param off The offset into the region. Will be rounded down to closest page boundary.
509	* @param cb The number of bytes to map. Will be rounded up to the closest page boundary.
510	* @param pszDesc Mapping description.
511	* @param pRCPtr Where to store the RC address.
512	*/
513	VMMR3DECL(int) MMR3HyperMapMMIO2(PVM pVM, PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS off, RTGCPHYS cb,
514	const char *pszDesc, PRTRCPTR pRCPtr)
515	{
516	LogFlow(("MMR3HyperMapMMIO2: pDevIns=%p iRegion=%#x off=%RGp cb=%RGp pszDesc=%p:{%s} pRCPtr=%p\n",
517	pDevIns, iRegion, off, cb, pszDesc, pszDesc, pRCPtr));
518	int rc;
519
520	/*
521	* Validate input.
522	*/
523	AssertReturn(pszDesc && *pszDesc, VERR_INVALID_PARAMETER);
524	AssertReturn(off + cb > off, VERR_INVALID_PARAMETER);
525	uint32_t const offPage = off & PAGE_OFFSET_MASK;
526	off &= ~(RTGCPHYS)PAGE_OFFSET_MASK;
527	cb += offPage;
528	cb = RT_ALIGN_Z(cb, PAGE_SIZE);
529	const RTGCPHYS offEnd = off + cb;
530	AssertReturn(offEnd > off, VERR_INVALID_PARAMETER);
531	for (RTGCPHYS offCur = off; offCur < offEnd; offCur += PAGE_SIZE)
532	{
533	RTHCPHYS HCPhys;
534	rc = PGMR3PhysMMIO2GetHCPhys(pVM, pDevIns, iRegion, offCur, &HCPhys);
535	AssertMsgRCReturn(rc, ("rc=%Rrc - iRegion=%d off=%RGp\n", rc, iRegion, off), rc);
536	}
537
538	/*
539	* Add the memory to the hypervisor area.
540	*/
541	RTGCPTR GCPtr;
542	PMMLOOKUPHYPER pLookup;
543	rc = mmR3HyperMap(pVM, cb, pszDesc, &GCPtr, &pLookup);
544	if (RT_SUCCESS(rc))
545	{
546	pLookup->enmType = MMLOOKUPHYPERTYPE_MMIO2;
547	pLookup->u.MMIO2.pDevIns = pDevIns;
548	pLookup->u.MMIO2.iRegion = iRegion;
549	pLookup->u.MMIO2.off = off;
550
551	/*
552	* Update the page table.
553	*/
554	if (pVM->mm.s.fPGMInitialized)
555	{
556	for (RTGCPHYS offCur = off; offCur < offEnd; offCur += PAGE_SIZE)
557	{
558	RTHCPHYS HCPhys;
559	rc = PGMR3PhysMMIO2GetHCPhys(pVM, pDevIns, iRegion, offCur, &HCPhys);
560	AssertRCReturn(rc, VERR_INTERNAL_ERROR);
561	rc = PGMMap(pVM, GCPtr + (offCur - off), HCPhys, PAGE_SIZE, 0);
562	if (RT_FAILURE(rc))
563	{
564	AssertMsgFailed(("rc=%Rrc offCur=%RGp %s\n", rc, offCur, pszDesc));
565	break;
566	}
567	}
568	}
569
570	if (RT_SUCCESS(rc))
571	{
572	GCPtr \|= offPage;
573	*pRCPtr = GCPtr;
574	AssertLogRelReturn(*pRCPtr == GCPtr, VERR_INTERNAL_ERROR);
575	}
576	}
577	return rc;
578	}
579
580
581	/**
582	* Maps locked R3 virtual memory into the hypervisor region in the GC.
583	*
584	* @return VBox status code.
585	*
586	* @param pVM VM handle.
587	* @param pvR3 The ring-3 address of the memory, must be page aligned.
588	* @param pvR0 The ring-0 address of the memory, must be page aligned. (optional)
589	* @param cPages The number of pages.
590	* @param paPages The page descriptors.
591	* @param pszDesc Mapping description.
592	* @param pGCPtr Where to store the GC address corresponding to pvR3.
593	*/
594	VMMR3DECL(int) MMR3HyperMapPages(PVM pVM, void pvR3, RTR0PTR pvR0, size_t cPages, PCSUPPAGE paPages, const char pszDesc, PRTGCPTR pGCPtr)
595	{
596	LogFlow(("MMR3HyperMapPages: pvR3=%p pvR0=%p cPages=%zu paPages=%p pszDesc=%p:{%s} pGCPtr=%p\n",
597	pvR3, pvR0, cPages, paPages, pszDesc, pszDesc, pGCPtr));
598
599	/*
600	* Validate input.
601	*/
602	AssertPtrReturn(pvR3, VERR_INVALID_POINTER);
603	AssertPtrReturn(paPages, VERR_INVALID_POINTER);
604	AssertReturn(cPages > 0, VERR_PAGE_COUNT_OUT_OF_RANGE);
605	AssertReturn(cPages <= VBOX_MAX_ALLOC_PAGE_COUNT, VERR_PAGE_COUNT_OUT_OF_RANGE);
606	AssertPtrReturn(pszDesc, VERR_INVALID_POINTER);
607	AssertReturn(*pszDesc, VERR_INVALID_PARAMETER);
608	AssertPtrReturn(pGCPtr, VERR_INVALID_PARAMETER);
609
610	/*
611	* Add the memory to the hypervisor area.
612	*/
613	RTGCPTR GCPtr;
614	PMMLOOKUPHYPER pLookup;
615	int rc = mmR3HyperMap(pVM, cPages << PAGE_SHIFT, pszDesc, &GCPtr, &pLookup);
616	if (RT_SUCCESS(rc))
617	{
618	/*
619	* Copy the physical page addresses and tell PGM about them.
620	*/
621	PRTHCPHYS paHCPhysPages = (PRTHCPHYS)MMR3HeapAlloc(pVM, MM_TAG_MM, sizeof(RTHCPHYS) * cPages);
622	if (paHCPhysPages)
623	{
624	for (size_t i = 0; i < cPages; i++)
625	{
626	AssertReleaseMsgReturn(paPages[i].Phys != 0 && paPages[i].Phys != NIL_RTHCPHYS && !(paPages[i].Phys & PAGE_OFFSET_MASK),
627	("i=%#zx Phys=%RHp %s\n", i, paPages[i].Phys, pszDesc),
628	VERR_INTERNAL_ERROR);
629	paHCPhysPages[i] = paPages[i].Phys;
630	}
631
632	if (pVM->mm.s.fPGMInitialized)
633	{
634	for (size_t i = 0; i < cPages; i++)
635	{
636	rc = PGMMap(pVM, GCPtr + (i << PAGE_SHIFT), paHCPhysPages[i], PAGE_SIZE, 0);
637	AssertRCBreak(rc);
638	}
639	}
640	if (RT_SUCCESS(rc))
641	{
642	pLookup->enmType = MMLOOKUPHYPERTYPE_LOCKED;
643	pLookup->u.Locked.pvR3 = pvR3;
644	pLookup->u.Locked.pvR0 = pvR0;
645	pLookup->u.Locked.paHCPhysPages = paHCPhysPages;
646
647	/* done. */
648	*pGCPtr = GCPtr;
649	return rc;
650	}
651	/* Don't care about failure clean, we're screwed if this fails anyway. */
652	}
653	}
654
655	return rc;
656	}
657
658
659	/**
660	* Reserves a hypervisor memory area.
661	* Most frequent usage is fence pages and dynamically mappings like the guest PD and PDPT.
662	*
663	* @return VBox status code.
664	*
665	* @param pVM VM handle.
666	* @param cb Size of the memory. Will be rounded up to nearest page.
667	* @param pszDesc Mapping description.
668	* @param pGCPtr Where to store the assigned GC address. Optional.
669	*/
670	VMMR3DECL(int) MMR3HyperReserve(PVM pVM, unsigned cb, const char *pszDesc, PRTGCPTR pGCPtr)
671	{
672	LogFlow(("MMR3HyperMapHCRam: cb=%d pszDesc=%p:{%s} pGCPtr=%p\n", (int)cb, pszDesc, pszDesc, pGCPtr));
673
674	/*
675	* Validate input.
676	*/
677	if ( cb <= 0
678	\|\| !pszDesc
679	\|\| !*pszDesc)
680	{
681	AssertMsgFailed(("Invalid parameter\n"));
682	return VERR_INVALID_PARAMETER;
683	}
684
685	/*
686	* Add the memory to the hypervisor area.
687	*/
688	RTGCPTR GCPtr;
689	PMMLOOKUPHYPER pLookup;
690	int rc = mmR3HyperMap(pVM, cb, pszDesc, &GCPtr, &pLookup);
691	if (RT_SUCCESS(rc))
692	{
693	pLookup->enmType = MMLOOKUPHYPERTYPE_DYNAMIC;
694	if (pGCPtr)
695	*pGCPtr = GCPtr;
696	return VINF_SUCCESS;
697	}
698	return rc;
699	}
700
701
702	/**
703	* Adds memory to the hypervisor memory arena.
704	*
705	* @return VBox status code.
706	* @param pVM The VM handle.
707	* @param cb Size of the memory. Will be rounded up to nearest page.
708	* @param pszDesc The description of the memory.
709	* @param pGCPtr Where to store the GC address.
710	* @param ppLookup Where to store the pointer to the lookup record.
711	* @remark We assume the threading structure of VBox imposes natural
712	* serialization of most functions, this one included.
713	*/
714	static int mmR3HyperMap(PVM pVM, const size_t cb, const char pszDesc, PRTGCPTR pGCPtr, PMMLOOKUPHYPER ppLookup)
715	{
716	/*
717	* Validate input.
718	*/
719	const uint32_t cbAligned = RT_ALIGN_32(cb, PAGE_SIZE);
720	AssertReturn(cbAligned >= cb, VERR_INVALID_PARAMETER);
721	if (pVM->mm.s.offHyperNextStatic + cbAligned >= pVM->mm.s.cbHyperArea) /* don't use the last page, it's a fence. */
722	{
723	AssertMsgFailed(("Out of static mapping space in the HMA! offHyperAreaGC=%x cbAligned=%x cbHyperArea=%x\n",
724	pVM->mm.s.offHyperNextStatic, cbAligned, pVM->mm.s.cbHyperArea));
725	return VERR_NO_MEMORY;
726	}
727
728	/*
729	* Allocate lookup record.
730	*/
731	PMMLOOKUPHYPER pLookup;
732	int rc = MMHyperAlloc(pVM, sizeof(pLookup), 1, MM_TAG_MM, (void *)&pLookup);
733	if (RT_SUCCESS(rc))
734	{
735	/*
736	* Initialize it and insert it.
737	*/
738	pLookup->offNext = pVM->mm.s.offLookupHyper;
739	pLookup->cb = cbAligned;
740	pLookup->off = pVM->mm.s.offHyperNextStatic;
741	pVM->mm.s.offLookupHyper = (uint8_t )pLookup - (uint8_t )pVM->mm.s.pHyperHeapR3;
742	if (pLookup->offNext != (int32_t)NIL_OFFSET)
743	pLookup->offNext -= pVM->mm.s.offLookupHyper;
744	pLookup->enmType = MMLOOKUPHYPERTYPE_INVALID;
745	memset(&pLookup->u, 0xff, sizeof(pLookup->u));
746	pLookup->pszDesc = pszDesc;
747
748	/* Mapping. */
749	*pGCPtr = pVM->mm.s.pvHyperAreaGC + pVM->mm.s.offHyperNextStatic;
750	pVM->mm.s.offHyperNextStatic += cbAligned;
751
752	/* Return pointer. */
753	*ppLookup = pLookup;
754	}
755
756	AssertRC(rc);
757	LogFlow(("mmR3HyperMap: returns %Rrc pGCPtr=%RGv\n", rc, pGCPtr));
758	return rc;
759	}
760
761
762	/**
763	* Allocates a new heap.
764	*
765	* @returns VBox status code.
766	* @param pVM The VM handle.
767	* @param cb The size of the new heap.
768	* @param ppHeap Where to store the heap pointer on successful return.
769	* @param pR0PtrHeap Where to store the ring-0 address of the heap on
770	* success.
771	*/
772	static int mmR3HyperHeapCreate(PVM pVM, const size_t cb, PMMHYPERHEAP *ppHeap, PRTR0PTR pR0PtrHeap)
773	{
774	/*
775	* Allocate the hypervisor heap.
776	*/
777	const uint32_t cbAligned = RT_ALIGN_32(cb, PAGE_SIZE);
778	AssertReturn(cbAligned >= cb, VERR_INVALID_PARAMETER);
779	uint32_t const cPages = cbAligned >> PAGE_SHIFT;
780	PSUPPAGE paPages = (PSUPPAGE)MMR3HeapAlloc(pVM, MM_TAG_MM, cPages * sizeof(paPages[0]));
781	if (!paPages)
782	return VERR_NO_MEMORY;
783	void *pv;
784	RTR0PTR pvR0 = NIL_RTR0PTR;
785	int rc = SUPR3PageAllocEx(cPages,
786	0 /fFlags/,
787	&pv,
788	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
789	VMMIsHwVirtExtForced(pVM) ? &pvR0 : NULL,
790	#else
791	NULL,
792	#endif
793	paPages);
794	if (RT_SUCCESS(rc))
795	{
796	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
797	if (!VMMIsHwVirtExtForced(pVM))
798	pvR0 = NIL_RTR0PTR;
799	#else
800	pvR0 = (uintptr_t)pv;
801	#endif
802	memset(pv, 0, cbAligned);
803
804	/*
805	* Initialize the heap and first free chunk.
806	*/
807	PMMHYPERHEAP pHeap = (PMMHYPERHEAP)pv;
808	pHeap->u32Magic = MMHYPERHEAP_MAGIC;
809	pHeap->pbHeapR3 = (uint8_t *)pHeap + MMYPERHEAP_HDR_SIZE;
810	pHeap->pbHeapR0 = pvR0 != NIL_RTR0PTR ? pvR0 + MMYPERHEAP_HDR_SIZE : NIL_RTR0PTR;
811	//pHeap->pbHeapRC = 0; // set by mmR3HyperHeapMap()
812	pHeap->pVMR3 = pVM;
813	pHeap->pVMR0 = pVM->pVMR0;
814	pHeap->pVMRC = pVM->pVMRC;
815	pHeap->cbHeap = cbAligned - MMYPERHEAP_HDR_SIZE;
816	pHeap->cbFree = pHeap->cbHeap - sizeof(MMHYPERCHUNK);
817	//pHeap->offFreeHead = 0;
818	//pHeap->offFreeTail = 0;
819	pHeap->offPageAligned = pHeap->cbHeap;
820	//pHeap->HyperHeapStatTree = 0;
821	pHeap->paPages = paPages;
822
823	PMMHYPERCHUNKFREE pFree = (PMMHYPERCHUNKFREE)pHeap->pbHeapR3;
824	pFree->cb = pHeap->cbFree;
825	//pFree->core.offNext = 0;
826	MMHYPERCHUNK_SET_TYPE(&pFree->core, MMHYPERCHUNK_FLAGS_FREE);
827	pFree->core.offHeap = -(int32_t)MMYPERHEAP_HDR_SIZE;
828	//pFree->offNext = 0;
829	//pFree->offPrev = 0;
830
831	STAMR3Register(pVM, &pHeap->cbHeap, STAMTYPE_U32, STAMVISIBILITY_ALWAYS, "/MM/HyperHeap/cbHeap", STAMUNIT_BYTES, "The heap size.");
832	STAMR3Register(pVM, &pHeap->cbFree, STAMTYPE_U32, STAMVISIBILITY_ALWAYS, "/MM/HyperHeap/cbFree", STAMUNIT_BYTES, "The free space.");
833
834	*ppHeap = pHeap;
835	*pR0PtrHeap = pvR0;
836	return VINF_SUCCESS;
837	}
838	AssertMsgFailed(("SUPR3PageAllocEx(%d,,,,) -> %Rrc\n", cbAligned >> PAGE_SHIFT, rc));
839
840	*ppHeap = NULL;
841	return rc;
842	}
843
844	/**
845	* Allocates a new heap.
846	*/
847	static int mmR3HyperHeapMap(PVM pVM, PMMHYPERHEAP pHeap, PRTGCPTR ppHeapGC)
848	{
849	Assert(RT_ALIGN_Z(pHeap->cbHeap + MMYPERHEAP_HDR_SIZE, PAGE_SIZE) == pHeap->cbHeap + MMYPERHEAP_HDR_SIZE);
850	Assert(pHeap->paPages);
851	int rc = MMR3HyperMapPages(pVM,
852	pHeap,
853	pHeap->pbHeapR0 != NIL_RTR0PTR ? pHeap->pbHeapR0 - MMYPERHEAP_HDR_SIZE : NIL_RTR0PTR,
854	(pHeap->cbHeap + MMYPERHEAP_HDR_SIZE) >> PAGE_SHIFT,
855	pHeap->paPages,
856	"Heap", ppHeapGC);
857	if (RT_SUCCESS(rc))
858	{
859	pHeap->pVMRC = pVM->pVMRC;
860	pHeap->pbHeapRC = *ppHeapGC + MMYPERHEAP_HDR_SIZE;
861	/* Reserve a page for fencing. */
862	MMR3HyperReserve(pVM, PAGE_SIZE, "fence", NULL);
863
864	/* We won't need these any more. */
865	MMR3HeapFree(pHeap->paPages);
866	pHeap->paPages = NULL;
867	}
868	return rc;
869	}
870
871
872	/**
873	* Allocates memory in the Hypervisor (GC VMM) area which never will
874	* be freed and doesn't have any offset based relation to other heap blocks.
875	*
876	* The latter means that two blocks allocated by this API will not have the
877	* same relative position to each other in GC and HC. In short, never use
878	* this API for allocating nodes for an offset based AVL tree!
879	*
880	* The returned memory is of course zeroed.
881	*
882	* @returns VBox status code.
883	* @param pVM The VM to operate on.
884	* @param cb Number of bytes to allocate.
885	* @param uAlignment Required memory alignment in bytes.
886	* Values are 0,8,16,32 and PAGE_SIZE.
887	* 0 -> default alignment, i.e. 8 bytes.
888	* @param enmTag The statistics tag.
889	* @param ppv Where to store the address to the allocated
890	* memory.
891	* @remark This is assumed not to be used at times when serialization is required.
892	*/
893	VMMR3DECL(int) MMR3HyperAllocOnceNoRel(PVM pVM, size_t cb, unsigned uAlignment, MMTAG enmTag, void **ppv)
894	{
895	return MMR3HyperAllocOnceNoRelEx(pVM, cb, uAlignment, enmTag, 0/fFlags/, ppv);
896	}
897
898
899	/**
900	* Allocates memory in the Hypervisor (GC VMM) area which never will
901	* be freed and doesn't have any offset based relation to other heap blocks.
902	*
903	* The latter means that two blocks allocated by this API will not have the
904	* same relative position to each other in GC and HC. In short, never use
905	* this API for allocating nodes for an offset based AVL tree!
906	*
907	* The returned memory is of course zeroed.
908	*
909	* @returns VBox status code.
910	* @param pVM The VM to operate on.
911	* @param cb Number of bytes to allocate.
912	* @param uAlignment Required memory alignment in bytes.
913	* Values are 0,8,16,32 and PAGE_SIZE.
914	* 0 -> default alignment, i.e. 8 bytes.
915	* @param enmTag The statistics tag.
916	* @param fFlags Flags, see MMHYPER_AONR_FLAGS_KERNEL_MAPPING.
917	* @param ppv Where to store the address to the allocated memory.
918	* @remark This is assumed not to be used at times when serialization is required.
919	*/
920	VMMR3DECL(int) MMR3HyperAllocOnceNoRelEx(PVM pVM, size_t cb, unsigned uAlignment, MMTAG enmTag, uint32_t fFlags, void **ppv)
921	{
922	AssertMsg(cb >= 8, ("Hey! Do you really mean to allocate less than 8 bytes?! cb=%d\n", cb));
923	Assert(!(fFlags & ~(MMHYPER_AONR_FLAGS_KERNEL_MAPPING)));
924
925	/*
926	* Choose between allocating a new chunk of HMA memory
927	* and the heap. We will only do BIG allocations from HMA and
928	* only at creation time.
929	*/
930	if ( ( cb < _64K
931	&& ( uAlignment != PAGE_SIZE
932	\|\| cb < 48*_1K)
933	&& !(fFlags & MMHYPER_AONR_FLAGS_KERNEL_MAPPING)
934	)
935	\|\| VMR3GetState(pVM) != VMSTATE_CREATING
936	)
937	{
938	Assert(!(fFlags & MMHYPER_AONR_FLAGS_KERNEL_MAPPING));
939	int rc = MMHyperAlloc(pVM, cb, uAlignment, enmTag, ppv);
940	if ( rc != VERR_MM_HYPER_NO_MEMORY
941	\|\| cb <= 8*_1K)
942	{
943	Log2(("MMR3HyperAllocOnceNoRel: cb=%#zx uAlignment=%#x returns %Rrc and *ppv=%p\n",
944	cb, uAlignment, rc, *ppv));
945	return rc;
946	}
947	}
948
949	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
950	/*
951	* Set MMHYPER_AONR_FLAGS_KERNEL_MAPPING if we're in going to execute in ring-0.
952	*/
953	if (VMMIsHwVirtExtForced(pVM))
954	fFlags \|= MMHYPER_AONR_FLAGS_KERNEL_MAPPING;
955	#endif
956
957	/*
958	* Validate alignment.
959	*/
960	switch (uAlignment)
961	{
962	case 0:
963	case 8:
964	case 16:
965	case 32:
966	case PAGE_SIZE:
967	break;
968	default:
969	AssertMsgFailed(("Invalid alignment %u\n", uAlignment));
970	return VERR_INVALID_PARAMETER;
971	}
972
973	/*
974	* Allocate the pages and map them into HMA space.
975	*/
976	uint32_t const cbAligned = RT_ALIGN_32(cb, PAGE_SIZE);
977	AssertReturn(cbAligned >= cb, VERR_INVALID_PARAMETER);
978	uint32_t const cPages = cbAligned >> PAGE_SHIFT;
979	PSUPPAGE paPages = (PSUPPAGE)RTMemTmpAlloc(cPages * sizeof(paPages[0]));
980	if (!paPages)
981	return VERR_NO_TMP_MEMORY;
982	void *pvPages;
983	RTR0PTR pvR0 = NIL_RTR0PTR;
984	int rc = SUPR3PageAllocEx(cPages,
985	0 /fFlags/,
986	&pvPages,
987	fFlags & MMHYPER_AONR_FLAGS_KERNEL_MAPPING ? &pvR0 : NULL,
988	paPages);
989	if (RT_SUCCESS(rc))
990	{
991	if (!(fFlags & MMHYPER_AONR_FLAGS_KERNEL_MAPPING))
992	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
993	pvR0 = NIL_RTR0PTR;
994	#else
995	pvR0 = (RTR0PTR)pvPages;
996	#endif
997
998	memset(pvPages, 0, cbAligned);
999
1000	RTGCPTR GCPtr;
1001	rc = MMR3HyperMapPages(pVM,
1002	pvPages,
1003	pvR0,
1004	cPages,
1005	paPages,
1006	MMR3HeapAPrintf(pVM, MM_TAG_MM, "alloc once (%s)", mmGetTagName(enmTag)),
1007	&GCPtr);
1008	if (RT_SUCCESS(rc))
1009	{
1010	*ppv = pvPages;
1011	Log2(("MMR3HyperAllocOnceNoRel: cbAligned=%#x uAlignment=%#x returns VINF_SUCCESS and *ppv=%p\n",
1012	cbAligned, uAlignment, *ppv));
1013	MMR3HyperReserve(pVM, PAGE_SIZE, "fence", NULL);
1014	return rc;
1015	}
1016	AssertMsgFailed(("Failed to allocate %zd bytes! %Rrc\n", cbAligned, rc));
1017	SUPR3PageFreeEx(pvPages, cPages);
1018
1019
1020	/*
1021	* HACK ALERT! Try allocate it off the heap so that we don't freak
1022	* out during vga/vmmdev mmio2 allocation with certain ram sizes.
1023	*/
1024	/** @todo make a proper fix for this so we will never end up in this kind of situation! */
1025	Log(("MMR3HyperAllocOnceNoRel: MMR3HyperMapHCRam failed with rc=%Rrc, try MMHyperAlloc(,%#x,,) instead\n", rc, cb));
1026	int rc2 = MMHyperAlloc(pVM, cb, uAlignment, enmTag, ppv);
1027	if (RT_SUCCESS(rc2))
1028	{
1029	Log2(("MMR3HyperAllocOnceNoRel: cb=%#x uAlignment=%#x returns %Rrc and *ppv=%p\n",
1030	cb, uAlignment, rc, *ppv));
1031	return rc;
1032	}
1033	}
1034	else
1035	AssertMsgFailed(("Failed to allocate %zd bytes! %Rrc\n", cbAligned, rc));
1036
1037	if (rc == VERR_NO_MEMORY)
1038	rc = VERR_MM_HYPER_NO_MEMORY;
1039	LogRel(("MMR3HyperAllocOnceNoRel: cb=%#zx uAlignment=%#x returns %Rrc\n", cb, uAlignment, rc));
1040	return rc;
1041	}
1042
1043
1044	/**
1045	* Lookus up a ring-3 pointer to HMA.
1046	*
1047	* @returns The lookup record on success, NULL on failure.
1048	* @param pVM The VM handle.
1049	* @param pvR3 The ring-3 address to look up.
1050	*/
1051	DECLINLINE(PMMLOOKUPHYPER) mmR3HyperLookupR3(PVM pVM, void *pvR3)
1052	{
1053	PMMLOOKUPHYPER pLookup = (PMMLOOKUPHYPER)((uint8_t *)pVM->mm.s.pHyperHeapR3 + pVM->mm.s.offLookupHyper);
1054	for (;;)
1055	{
1056	switch (pLookup->enmType)
1057	{
1058	case MMLOOKUPHYPERTYPE_LOCKED:
1059	{
1060	unsigned off = (uint8_t )pvR3 - (uint8_t )pLookup->u.Locked.pvR3;
1061	if (off < pLookup->cb)
1062	return pLookup;
1063	break;
1064	}
1065
1066	case MMLOOKUPHYPERTYPE_HCPHYS:
1067	{
1068	unsigned off = (uint8_t )pvR3 - (uint8_t )pLookup->u.HCPhys.pvR3;
1069	if (off < pLookup->cb)
1070	return pLookup;
1071	break;
1072	}
1073
1074	case MMLOOKUPHYPERTYPE_GCPHYS:
1075	case MMLOOKUPHYPERTYPE_MMIO2:
1076	case MMLOOKUPHYPERTYPE_DYNAMIC:
1077	/** @todo ? */
1078	break;
1079
1080	default:
1081	AssertMsgFailed(("enmType=%d\n", pLookup->enmType));
1082	return NULL;
1083	}
1084
1085	/* next */
1086	if ((unsigned)pLookup->offNext == NIL_OFFSET)
1087	return NULL;
1088	pLookup = (PMMLOOKUPHYPER)((uint8_t *)pLookup + pLookup->offNext);
1089	}
1090	}
1091
1092
1093	/**
1094	* Set / unset guard status on one or more hyper heap pages.
1095	*
1096	* @returns VBox status code (first failure).
1097	* @param pVM The VM handle.
1098	* @param pvStart The hyper heap page address. Must be page
1099	* aligned.
1100	* @param cb The number of bytes. Must be page aligned.
1101	* @param fSet Whether to set or unset guard page status.
1102	*/
1103	VMMR3DECL(int) MMR3HyperSetGuard(PVM pVM, void *pvStart, size_t cb, bool fSet)
1104	{
1105	/*
1106	* Validate input.
1107	*/
1108	AssertReturn(!((uintptr_t)pvStart & PAGE_OFFSET_MASK), VERR_INVALID_POINTER);
1109	AssertReturn(!(cb & PAGE_OFFSET_MASK), VERR_INVALID_PARAMETER);
1110	AssertReturn(cb <= UINT32_MAX, VERR_INVALID_PARAMETER);
1111	PMMLOOKUPHYPER pLookup = mmR3HyperLookupR3(pVM, pvStart);
1112	AssertReturn(pLookup, VERR_INVALID_PARAMETER);
1113	AssertReturn(pLookup->enmType == MMLOOKUPHYPERTYPE_LOCKED, VERR_INVALID_PARAMETER);
1114
1115	/*
1116	* Get down to business.
1117	* Note! We quietly ignore errors from the support library since the
1118	* protection stuff isn't possible to implement on all platforms.
1119	*/
1120	uint8_t pbR3 = (uint8_t )pLookup->u.Locked.pvR3;
1121	RTR0PTR R0Ptr = pLookup->u.Locked.pvR0 != (uintptr_t)pLookup->u.Locked.pvR3
1122	? pLookup->u.Locked.pvR0
1123	: NIL_RTR0PTR;
1124	uint32_t off = (uint32_t)((uint8_t *)pvStart - pbR3);
1125	int rc;
1126	if (fSet)
1127	{
1128	rc = PGMMapSetPage(pVM, MMHyperR3ToRC(pVM, pvStart), cb, 0);
1129	SUPR3PageProtect(pbR3, R0Ptr, off, (uint32_t)cb, RTMEM_PROT_NONE);
1130	}
1131	else
1132	{
1133	rc = PGMMapSetPage(pVM, MMHyperR3ToRC(pVM, pvStart), cb, X86_PTE_P \| X86_PTE_A \| X86_PTE_D \| X86_PTE_RW);
1134	SUPR3PageProtect(pbR3, R0Ptr, off, (uint32_t)cb, RTMEM_PROT_READ \| RTMEM_PROT_WRITE);
1135	}
1136	return rc;
1137	}
1138
1139
1140	/**
1141	* Convert hypervisor HC virtual address to HC physical address.
1142	*
1143	* @returns HC physical address.
1144	* @param pVM VM Handle
1145	* @param pvR3 Host context virtual address.
1146	*/
1147	VMMR3DECL(RTHCPHYS) MMR3HyperHCVirt2HCPhys(PVM pVM, void *pvR3)
1148	{
1149	PMMLOOKUPHYPER pLookup = (PMMLOOKUPHYPER)((uint8_t *)pVM->mm.s.pHyperHeapR3 + pVM->mm.s.offLookupHyper);
1150	for (;;)
1151	{
1152	switch (pLookup->enmType)
1153	{
1154	case MMLOOKUPHYPERTYPE_LOCKED:
1155	{
1156	unsigned off = (uint8_t )pvR3 - (uint8_t )pLookup->u.Locked.pvR3;
1157	if (off < pLookup->cb)
1158	return pLookup->u.Locked.paHCPhysPages[off >> PAGE_SHIFT] \| (off & PAGE_OFFSET_MASK);
1159	break;
1160	}
1161
1162	case MMLOOKUPHYPERTYPE_HCPHYS:
1163	{
1164	unsigned off = (uint8_t )pvR3 - (uint8_t )pLookup->u.HCPhys.pvR3;
1165	if (off < pLookup->cb)
1166	return pLookup->u.HCPhys.HCPhys + off;
1167	break;
1168	}
1169
1170	case MMLOOKUPHYPERTYPE_GCPHYS:
1171	case MMLOOKUPHYPERTYPE_MMIO2:
1172	case MMLOOKUPHYPERTYPE_DYNAMIC:
1173	/* can (or don't want to) convert these kind of records. */
1174	break;
1175
1176	default:
1177	AssertMsgFailed(("enmType=%d\n", pLookup->enmType));
1178	break;
1179	}
1180
1181	/* next */
1182	if ((unsigned)pLookup->offNext == NIL_OFFSET)
1183	break;
1184	pLookup = (PMMLOOKUPHYPER)((uint8_t *)pLookup + pLookup->offNext);
1185	}
1186
1187	AssertMsgFailed(("pvR3=%p is not inside the hypervisor memory area!\n", pvR3));
1188	return NIL_RTHCPHYS;
1189	}
1190
1191
1192	/**
1193	* Implements the return case of MMR3HyperQueryInfoFromHCPhys.
1194	*
1195	* @returns VINF_SUCCESS, VINF_BUFFER_OVERFLOW.
1196	* @param pVM The VM handle.
1197	* @param HCPhys The host physical address to look for.
1198	* @param pLookup The HMA lookup entry corresponding to HCPhys.
1199	* @param pszWhat Where to return the description.
1200	* @param cbWhat Size of the return buffer.
1201	* @param pcbAlloc Where to return the size of whatever it is.
1202	*/
1203	static int mmR3HyperQueryInfoFromHCPhysFound(PVM pVM, RTHCPHYS HCPhys, PMMLOOKUPHYPER pLookup,
1204	char pszWhat, size_t cbWhat, uint32_t pcbAlloc)
1205	{
1206	*pcbAlloc = pLookup->cb;
1207	int rc = RTStrCopy(pszWhat, cbWhat, pLookup->pszDesc);
1208	return rc == VERR_BUFFER_OVERFLOW ? VINF_BUFFER_OVERFLOW : rc;
1209	}
1210
1211
1212	/**
1213	* Scans the HMA for the physical page and reports back a description if found.
1214	*
1215	* @returns VINF_SUCCESS, VINF_BUFFER_OVERFLOW, VERR_NOT_FOUND.
1216	* @param pVM The VM handle.
1217	* @param HCPhys The host physical address to look for.
1218	* @param pszWhat Where to return the description.
1219	* @param cbWhat Size of the return buffer.
1220	* @param pcbAlloc Where to return the size of whatever it is.
1221	*/
1222	VMMR3_INT_DECL(int) MMR3HyperQueryInfoFromHCPhys(PVM pVM, RTHCPHYS HCPhys, char pszWhat, size_t cbWhat, uint32_t pcbAlloc)
1223	{
1224	RTHCPHYS HCPhysPage = HCPhys & ~(RTHCPHYS)PAGE_OFFSET_MASK;
1225	PMMLOOKUPHYPER pLookup = (PMMLOOKUPHYPER)((uint8_t *)pVM->mm.s.pHyperHeapR3 + pVM->mm.s.offLookupHyper);
1226	for (;;)
1227	{
1228	switch (pLookup->enmType)
1229	{
1230	case MMLOOKUPHYPERTYPE_LOCKED:
1231	{
1232	uint32_t i = pLookup->cb >> PAGE_SHIFT;
1233	while (i-- > 0)
1234	if (pLookup->u.Locked.paHCPhysPages[i] == HCPhysPage)
1235	return mmR3HyperQueryInfoFromHCPhysFound(pVM, HCPhys, pLookup, pszWhat, cbWhat, pcbAlloc);
1236	break;
1237	}
1238
1239	case MMLOOKUPHYPERTYPE_HCPHYS:
1240	{
1241	if (pLookup->u.HCPhys.HCPhys - HCPhysPage < pLookup->cb)
1242	return mmR3HyperQueryInfoFromHCPhysFound(pVM, HCPhys, pLookup, pszWhat, cbWhat, pcbAlloc);
1243	break;
1244	}
1245
1246	case MMLOOKUPHYPERTYPE_MMIO2:
1247	case MMLOOKUPHYPERTYPE_GCPHYS:
1248	case MMLOOKUPHYPERTYPE_DYNAMIC:
1249	{
1250	/* brute force. */
1251	uint32_t i = pLookup->cb >> PAGE_SHIFT;
1252	while (i-- > 0)
1253	{
1254	RTGCPTR GCPtr = pLookup->off + pVM->mm.s.pvHyperAreaGC;
1255	RTHCPHYS HCPhysCur;
1256	int rc = PGMMapGetPage(pVM, GCPtr, NULL, &HCPhysCur);
1257	if (RT_SUCCESS(rc) && HCPhysCur == HCPhysPage)
1258	return mmR3HyperQueryInfoFromHCPhysFound(pVM, HCPhys, pLookup, pszWhat, cbWhat, pcbAlloc);
1259	}
1260	break;
1261	}
1262	default:
1263	AssertMsgFailed(("enmType=%d\n", pLookup->enmType));
1264	break;
1265	}
1266
1267	/* next */
1268	if ((unsigned)pLookup->offNext == NIL_OFFSET)
1269	break;
1270	pLookup = (PMMLOOKUPHYPER)((uint8_t *)pLookup + pLookup->offNext);
1271	}
1272	return VERR_NOT_FOUND;
1273	}
1274
1275
1276	#if 0 /* unused, not implemented */
1277	/**
1278	* Convert hypervisor HC physical address to HC virtual address.
1279	*
1280	* @returns HC virtual address.
1281	* @param pVM VM Handle
1282	* @param HCPhys Host context physical address.
1283	*/
1284	VMMR3DECL(void *) MMR3HyperHCPhys2HCVirt(PVM pVM, RTHCPHYS HCPhys)
1285	{
1286	void *pv;
1287	int rc = MMR3HyperHCPhys2HCVirtEx(pVM, HCPhys, &pv);
1288	if (RT_SUCCESS(rc))
1289	return pv;
1290	AssertMsgFailed(("Invalid address HCPhys=%x rc=%d\n", HCPhys, rc));
1291	return NULL;
1292	}
1293
1294
1295	/**
1296	* Convert hypervisor HC physical address to HC virtual address.
1297	*
1298	* @returns VBox status.
1299	* @param pVM VM Handle
1300	* @param HCPhys Host context physical address.
1301	* @param ppv Where to store the HC virtual address.
1302	*/
1303	VMMR3DECL(int) MMR3HyperHCPhys2HCVirtEx(PVM pVM, RTHCPHYS HCPhys, void **ppv)
1304	{
1305	/*
1306	* Linear search.
1307	*/
1308	/** @todo implement when actually used. */
1309	return VERR_INVALID_POINTER;
1310	}
1311	#endif /* unused, not implemented */
1312
1313
1314	/**
1315	* Read hypervisor memory from GC virtual address.
1316	*
1317	* @returns VBox status.
1318	* @param pVM VM handle.
1319	* @param pvDst Destination address (HC of course).
1320	* @param GCPtr GC virtual address.
1321	* @param cb Number of bytes to read.
1322	*
1323	* @remarks For DBGF only.
1324	*/
1325	VMMR3DECL(int) MMR3HyperReadGCVirt(PVM pVM, void *pvDst, RTGCPTR GCPtr, size_t cb)
1326	{
1327	if (GCPtr - pVM->mm.s.pvHyperAreaGC >= pVM->mm.s.cbHyperArea)
1328	return VERR_INVALID_POINTER;
1329	return PGMR3MapRead(pVM, pvDst, GCPtr, cb);
1330	}
1331
1332
1333	/**
1334	* Info handler for 'hma', it dumps the list of lookup records for the hypervisor memory area.
1335	*
1336	* @param pVM The VM handle.
1337	* @param pHlp Callback functions for doing output.
1338	* @param pszArgs Argument string. Optional and specific to the handler.
1339	*/
1340	static DECLCALLBACK(void) mmR3HyperInfoHma(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs)
1341	{
1342	pHlp->pfnPrintf(pHlp, "Hypervisor Memory Area (HMA) Layout: Base %RGv, 0x%08x bytes\n",
1343	pVM->mm.s.pvHyperAreaGC, pVM->mm.s.cbHyperArea);
1344
1345	PMMLOOKUPHYPER pLookup = (PMMLOOKUPHYPER)((uint8_t *)pVM->mm.s.pHyperHeapR3 + pVM->mm.s.offLookupHyper);
1346	for (;;)
1347	{
1348	switch (pLookup->enmType)
1349	{
1350	case MMLOOKUPHYPERTYPE_LOCKED:
1351	pHlp->pfnPrintf(pHlp, "%RGv-%RGv %RHv %RHv LOCKED %-*s %s\n",
1352	pLookup->off + pVM->mm.s.pvHyperAreaGC,
1353	pLookup->off + pVM->mm.s.pvHyperAreaGC + pLookup->cb,
1354	pLookup->u.Locked.pvR3,
1355	pLookup->u.Locked.pvR0,
1356	sizeof(RTHCPTR) * 2, "",
1357	pLookup->pszDesc);
1358	break;
1359
1360	case MMLOOKUPHYPERTYPE_HCPHYS:
1361	pHlp->pfnPrintf(pHlp, "%RGv-%RGv %RHv %RHv HCPHYS %RHp %s\n",
1362	pLookup->off + pVM->mm.s.pvHyperAreaGC,
1363	pLookup->off + pVM->mm.s.pvHyperAreaGC + pLookup->cb,
1364	pLookup->u.HCPhys.pvR3,
1365	pLookup->u.HCPhys.pvR0,
1366	pLookup->u.HCPhys.HCPhys,
1367	pLookup->pszDesc);
1368	break;
1369
1370	case MMLOOKUPHYPERTYPE_GCPHYS:
1371	pHlp->pfnPrintf(pHlp, "%RGv-%RGv %s GCPHYS %RGp%s %s\n",
1372	pLookup->off + pVM->mm.s.pvHyperAreaGC,
1373	pLookup->off + pVM->mm.s.pvHyperAreaGC + pLookup->cb,
1374	sizeof(RTHCPTR) * 2 * 2 + 1, "",
1375	pLookup->u.GCPhys.GCPhys, RT_ABS((int)(sizeof(RTHCPHYS) - sizeof(RTGCPHYS))) * 2, "",
1376	pLookup->pszDesc);
1377	break;
1378
1379	case MMLOOKUPHYPERTYPE_MMIO2:
1380	pHlp->pfnPrintf(pHlp, "%RGv-%RGv %s MMIO2 %RGp%s %s\n",
1381	pLookup->off + pVM->mm.s.pvHyperAreaGC,
1382	pLookup->off + pVM->mm.s.pvHyperAreaGC + pLookup->cb,
1383	sizeof(RTHCPTR) * 2 * 2 + 1, "",
1384	pLookup->u.MMIO2.off, RT_ABS((int)(sizeof(RTHCPHYS) - sizeof(RTGCPHYS))) * 2, "",
1385	pLookup->pszDesc);
1386	break;
1387
1388	case MMLOOKUPHYPERTYPE_DYNAMIC:
1389	pHlp->pfnPrintf(pHlp, "%RGv-%RGv %s DYNAMIC %s %s\n",
1390	pLookup->off + pVM->mm.s.pvHyperAreaGC,
1391	pLookup->off + pVM->mm.s.pvHyperAreaGC + pLookup->cb,
1392	sizeof(RTHCPTR) * 2 * 2 + 1, "",
1393	sizeof(RTHCPTR) * 2, "",
1394	pLookup->pszDesc);
1395	break;
1396
1397	default:
1398	AssertMsgFailed(("enmType=%d\n", pLookup->enmType));
1399	break;
1400	}
1401
1402	/* next */
1403	if ((unsigned)pLookup->offNext == NIL_OFFSET)
1404	break;
1405	pLookup = (PMMLOOKUPHYPER)((uint8_t *)pLookup + pLookup->offNext);
1406	}
1407	}

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

source: vbox/trunk/src/VBox/VMM/MMHyper.cpp@ 34147

Download in other formats: