VirtualBox

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

Last change on this file since 13767 was 13767, checked in by vboxsync, 16 years ago

warning
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 40.4 KB
Line 
1/* $Id: MMHyper.cpp 13767 2008-11-03 17:32:21Z vboxsync $ */
2/** @file
3 * MM - Memory Manager - Hypervisor Memory Area.
4 */
5
6/*
7 * Copyright (C) 2006-2007 Sun Microsystems, Inc.
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18 * Clara, CA 95054 USA or visit http://www.sun.com if you need
19 * additional information or have any questions.
20 */
21
22
23/*******************************************************************************
24* Header Files *
25*******************************************************************************/
26#define LOG_GROUP LOG_GROUP_MM_HYPER
27#include <VBox/pgm.h>
28#include <VBox/mm.h>
29#include <VBox/dbgf.h>
30#include "MMInternal.h"
31#include <VBox/vm.h>
32#include <VBox/err.h>
33#include <VBox/param.h>
34#include <VBox/log.h>
35#include <iprt/alloc.h>
36#include <iprt/assert.h>
37#include <iprt/string.h>
38
39
40/*******************************************************************************
41* Internal Functions *
42*******************************************************************************/
43static DECLCALLBACK(bool) mmR3HyperRelocateCallback(PVM pVM, RTGCPTR GCPtrOld, RTGCPTR GCPtrNew, PGMRELOCATECALL enmMode, void *pvUser);
44static int mmR3HyperMap(PVM pVM, const size_t cb, const char *pszDesc, PRTGCPTR pGCPtr, PMMLOOKUPHYPER *ppLookup);
45static int mmR3HyperHeapCreate(PVM pVM, const size_t cb, PMMHYPERHEAP *ppHeap);
46static int mmR3HyperHeapMap(PVM pVM, PMMHYPERHEAP pHeap, PRTGCPTR ppHeapGC);
47static DECLCALLBACK(void) mmR3HyperInfoHma(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
48
49
50
51
52/**
53 * Initializes the hypvervisor related MM stuff without
54 * calling down to PGM.
55 *
56 * PGM is not initialized at this point, PGM relies on
57 * the heap to initialize.
58 *
59 * @returns VBox status.
60 */
61int mmR3HyperInit(PVM pVM)
62{
63 LogFlow(("mmR3HyperInit:\n"));
64
65 /*
66 * Decide Hypervisor mapping in the guest context
67 * And setup various hypervisor area and heap parameters.
68 */
69 pVM->mm.s.pvHyperAreaGC = (RTGCPTR)MM_HYPER_AREA_ADDRESS;
70 pVM->mm.s.cbHyperArea = MM_HYPER_AREA_MAX_SIZE;
71 AssertRelease(RT_ALIGN_T(pVM->mm.s.pvHyperAreaGC, 1 << X86_PD_SHIFT, RTGCPTR) == pVM->mm.s.pvHyperAreaGC);
72 Assert(pVM->mm.s.pvHyperAreaGC < 0xff000000);
73
74 /** @todo @bugref{1865}, @bugref{3202}: Change the cbHyperHeap default
75 * depending on whether VT-x/AMD-V is enabled or not! Don't waste
76 * precious kernel space on heap for the PATM. */
77 uint32_t cbHyperHeap;
78 int rc = CFGMR3QueryU32(CFGMR3GetChild(CFGMR3GetRoot(pVM), "MM"), "cbHyperHeap", &cbHyperHeap);
79 if (rc == VERR_CFGM_NO_PARENT || rc == VERR_CFGM_VALUE_NOT_FOUND)
80 cbHyperHeap = 1280*_1K;
81 else if (VBOX_FAILURE(rc))
82 {
83 LogRel(("MM/cbHyperHeap query -> %Vrc\n", rc));
84 AssertRCReturn(rc, rc);
85 }
86 cbHyperHeap = RT_ALIGN_32(cbHyperHeap, PAGE_SIZE);
87
88 /*
89 * Allocate the hypervisor heap.
90 *
91 * (This must be done before we start adding memory to the
92 * hypervisor static area because lookup records are allocated from it.)
93 */
94 rc = mmR3HyperHeapCreate(pVM, cbHyperHeap, &pVM->mm.s.pHyperHeapR3);
95 if (VBOX_SUCCESS(rc))
96 {
97 pVM->mm.s.pHyperHeapR0 = (uintptr_t)pVM->mm.s.pHyperHeapR3; /** @todo #1865: map into ring-0 / whatever. */
98
99 /*
100 * Make a small head fence to fend of accidental sequential access.
101 */
102 MMR3HyperReserve(pVM, PAGE_SIZE, "fence", NULL);
103
104 /*
105 * Map the VM structure into the hypervisor space.
106 */
107 AssertRelease(pVM->cbSelf == RT_UOFFSETOF(VM, aCpu[pVM->cCPUs]));
108
109 RTGCPTR GCPtr;
110 rc = MMR3HyperMapPages(pVM, pVM, pVM->pVMR0, RT_ALIGN_Z(pVM->cbSelf, PAGE_SIZE) >> PAGE_SHIFT, pVM->paVMPagesR3, "VM", &GCPtr);
111 if (VBOX_SUCCESS(rc))
112 {
113 pVM->pVMRC = (RTGCPTR32)GCPtr;
114 pVM->pVMGC = pVM->pVMRC;
115 for (uint32_t i = 0; i < pVM->cCPUs; i++)
116 pVM->aCpu[i].pVMRC = pVM->pVMRC;
117
118 /* Reserve a page for fencing. */
119 MMR3HyperReserve(pVM, PAGE_SIZE, "fence", NULL);
120
121 /*
122 * Map the heap into the hypervisor space.
123 */
124 rc = mmR3HyperHeapMap(pVM, pVM->mm.s.pHyperHeapR3, &GCPtr);
125 if (VBOX_SUCCESS(rc))
126 {
127 pVM->mm.s.pHyperHeapRC = (RTRCPTR)GCPtr;
128 Assert(pVM->mm.s.pHyperHeapRC == GCPtr);
129
130 /*
131 * Register info handlers.
132 */
133 DBGFR3InfoRegisterInternal(pVM, "hma", "Show the layout of the Hypervisor Memory Area.", mmR3HyperInfoHma);
134
135 LogFlow(("mmR3HyperInit: returns VINF_SUCCESS\n"));
136 return VINF_SUCCESS;
137 }
138 /* Caller will do proper cleanup. */
139 }
140 }
141
142 LogFlow(("mmR3HyperInit: returns %Vrc\n", rc));
143 return rc;
144}
145
146
147/**
148 * Finalizes the HMA mapping.
149 *
150 * This is called later during init, most (all) HMA allocations should be done
151 * by the time this function is called.
152 *
153 * @returns VBox status.
154 */
155VMMR3DECL(int) MMR3HyperInitFinalize(PVM pVM)
156{
157 LogFlow(("MMR3HyperInitFinalize:\n"));
158
159 /*
160 * Adjust and create the HMA mapping.
161 */
162 while ((RTINT)pVM->mm.s.offHyperNextStatic + 64*_1K < (RTINT)pVM->mm.s.cbHyperArea - _4M)
163 pVM->mm.s.cbHyperArea -= _4M;
164 int rc = PGMR3MapPT(pVM, pVM->mm.s.pvHyperAreaGC, pVM->mm.s.cbHyperArea,
165 mmR3HyperRelocateCallback, NULL, "Hypervisor Memory Area");
166 if (VBOX_FAILURE(rc))
167 return rc;
168 pVM->mm.s.fPGMInitialized = true;
169
170 /*
171 * Do all the delayed mappings.
172 */
173 PMMLOOKUPHYPER pLookup = (PMMLOOKUPHYPER)((uintptr_t)pVM->mm.s.pHyperHeapR3 + pVM->mm.s.offLookupHyper);
174 for (;;)
175 {
176 RTGCPTR GCPtr = pVM->mm.s.pvHyperAreaGC + pLookup->off;
177 unsigned cPages = pLookup->cb >> PAGE_SHIFT;
178 switch (pLookup->enmType)
179 {
180 case MMLOOKUPHYPERTYPE_LOCKED:
181 rc = mmR3MapLocked(pVM, pLookup->u.Locked.pLockedMem, GCPtr, 0, cPages, 0);
182 break;
183
184 case MMLOOKUPHYPERTYPE_HCPHYS:
185 rc = PGMMap(pVM, GCPtr, pLookup->u.HCPhys.HCPhys, pLookup->cb, 0);
186 break;
187
188 case MMLOOKUPHYPERTYPE_GCPHYS:
189 {
190 const RTGCPHYS GCPhys = pLookup->u.GCPhys.GCPhys;
191 const size_t cb = pLookup->cb;
192 for (unsigned off = 0; off < cb; off += PAGE_SIZE)
193 {
194 RTHCPHYS HCPhys;
195 rc = PGMPhysGCPhys2HCPhys(pVM, GCPhys + off, &HCPhys);
196 if (VBOX_FAILURE(rc))
197 break;
198 rc = PGMMap(pVM, GCPtr + off, HCPhys, PAGE_SIZE, 0);
199 if (VBOX_FAILURE(rc))
200 break;
201 }
202 break;
203 }
204
205 case MMLOOKUPHYPERTYPE_MMIO2:
206 {
207 const RTGCPHYS offEnd = pLookup->u.MMIO2.off + pLookup->cb;
208 for (RTGCPHYS offCur = pLookup->u.MMIO2.off; offCur < offEnd; offCur += PAGE_SIZE)
209 {
210 RTHCPHYS HCPhys;
211 rc = PGMR3PhysMMIO2GetHCPhys(pVM, pLookup->u.MMIO2.pDevIns, pLookup->u.MMIO2.iRegion, offCur, &HCPhys);
212 if (RT_FAILURE(rc))
213 break;
214 rc = PGMMap(pVM, GCPtr + (offCur - pLookup->u.MMIO2.off), HCPhys, PAGE_SIZE, 0);
215 if (RT_FAILURE(rc))
216 break;
217 }
218 break;
219 }
220
221 case MMLOOKUPHYPERTYPE_DYNAMIC:
222 /* do nothing here since these are either fences or managed by someone else using PGM. */
223 break;
224
225 default:
226 AssertMsgFailed(("enmType=%d\n", pLookup->enmType));
227 break;
228 }
229
230 if (VBOX_FAILURE(rc))
231 {
232 AssertMsgFailed(("rc=%Vrc cb=%d GCPtr=%VGv enmType=%d pszDesc=%s\n",
233 rc, pLookup->cb, pLookup->enmType, pLookup->pszDesc));
234 return rc;
235 }
236
237 /* next */
238 if (pLookup->offNext == (int32_t)NIL_OFFSET)
239 break;
240 pLookup = (PMMLOOKUPHYPER)((uintptr_t)pLookup + pLookup->offNext);
241 }
242
243 LogFlow(("MMR3HyperInitFinalize: returns VINF_SUCCESS\n"));
244 return VINF_SUCCESS;
245}
246
247
248/**
249 * Callback function which will be called when PGM is trying to find
250 * a new location for the mapping.
251 *
252 * The callback is called in two modes, 1) the check mode and 2) the relocate mode.
253 * In 1) the callback should say if it objects to a suggested new location. If it
254 * accepts the new location, it is called again for doing it's relocation.
255 *
256 *
257 * @returns true if the location is ok.
258 * @returns false if another location should be found.
259 * @param pVM The VM handle.
260 * @param GCPtrOld The old virtual address.
261 * @param GCPtrNew The new virtual address.
262 * @param enmMode Used to indicate the callback mode.
263 * @param pvUser User argument. Ignored.
264 * @remark The return value is no a failure indicator, it's an acceptance
265 * indicator. Relocation can not fail!
266 */
267static DECLCALLBACK(bool) mmR3HyperRelocateCallback(PVM pVM, RTGCPTR GCPtrOld, RTGCPTR GCPtrNew, PGMRELOCATECALL enmMode, void *pvUser)
268{
269 switch (enmMode)
270 {
271 /*
272 * Verify location - all locations are good for us.
273 */
274 case PGMRELOCATECALL_SUGGEST:
275 return true;
276
277 /*
278 * Execute the relocation.
279 */
280 case PGMRELOCATECALL_RELOCATE:
281 {
282 /*
283 * Accepted!
284 */
285 AssertMsg(GCPtrOld == pVM->mm.s.pvHyperAreaGC, ("GCPtrOld=%VGv pVM->mm.s.pvHyperAreaGC=%VGv\n", GCPtrOld, pVM->mm.s.pvHyperAreaGC));
286 Log(("Relocating the hypervisor from %VGv to %VGv\n", GCPtrOld, GCPtrNew));
287
288 /*
289 * Relocate the VM structure and ourselves.
290 */
291 RTGCINTPTR offDelta = GCPtrNew - GCPtrOld;
292 pVM->pVMRC += offDelta;
293 pVM->pVMGC = pVM->pVMRC;
294 for (uint32_t i = 0; i < pVM->cCPUs; i++)
295 pVM->aCpu[i].pVMRC = pVM->pVMRC;
296
297 pVM->mm.s.pvHyperAreaGC += offDelta;
298 Assert(pVM->mm.s.pvHyperAreaGC < _4G);
299 pVM->mm.s.pHyperHeapRC += offDelta;
300 pVM->mm.s.pHyperHeapR3->pbHeapRC += offDelta;
301 pVM->mm.s.pHyperHeapR3->pVMRC = pVM->pVMRC;
302
303 /*
304 * Relocate the rest.
305 */
306 VMR3Relocate(pVM, offDelta);
307 return true;
308 }
309
310 default:
311 AssertMsgFailed(("Invalid relocation mode %d\n", enmMode));
312 }
313
314 return false;
315}
316
317
318/**
319 * Maps contiguous HC physical memory into the hypervisor region in the GC.
320 *
321 * @return VBox status code.
322 *
323 * @param pVM VM handle.
324 * @param pvR3 Host context address of the memory. Must be page
325 * aligned!
326 * @param HCPhys Host context physical address of the memory to be
327 * mapped. Must be page aligned!
328 * @param cb Size of the memory. Will be rounded up to nearest page.
329 * @param pszDesc Description.
330 * @param pGCPtr Where to store the GC address.
331 */
332VMMR3DECL(int) MMR3HyperMapHCPhys(PVM pVM, void *pvR3, RTHCPHYS HCPhys, size_t cb, const char *pszDesc, PRTGCPTR pGCPtr)
333{
334 LogFlow(("MMR3HyperMapHCPhys: pvR3=%p HCPhys=%RHp cb=%d pszDesc=%p:{%s} pGCPtr=%p\n", pvR3, HCPhys, (int)cb, pszDesc, pszDesc, pGCPtr));
335
336 /*
337 * Validate input.
338 */
339 AssertReturn(RT_ALIGN_P(pvR3, PAGE_SIZE) == pvR3, VERR_INVALID_PARAMETER);
340 AssertReturn(RT_ALIGN_T(HCPhys, PAGE_SIZE, RTHCPHYS) == HCPhys, VERR_INVALID_PARAMETER);
341 AssertReturn(pszDesc && *pszDesc, VERR_INVALID_PARAMETER);
342
343 /*
344 * Add the memory to the hypervisor area.
345 */
346 uint32_t cbAligned = RT_ALIGN_32(cb, PAGE_SIZE);
347 AssertReturn(cbAligned >= cb, VERR_INVALID_PARAMETER);
348 RTGCPTR GCPtr;
349 PMMLOOKUPHYPER pLookup;
350 int rc = mmR3HyperMap(pVM, cbAligned, pszDesc, &GCPtr, &pLookup);
351 if (VBOX_SUCCESS(rc))
352 {
353 pLookup->enmType = MMLOOKUPHYPERTYPE_HCPHYS;
354 pLookup->u.HCPhys.pvR3 = pvR3;
355 pLookup->u.HCPhys.HCPhys = HCPhys;
356
357 /*
358 * Update the page table.
359 */
360 if (pVM->mm.s.fPGMInitialized)
361 rc = PGMMap(pVM, GCPtr, HCPhys, cbAligned, 0);
362 if (VBOX_SUCCESS(rc))
363 *pGCPtr = GCPtr;
364 }
365 return rc;
366}
367
368
369/**
370 * Maps contiguous GC physical memory into the hypervisor region in the GC.
371 *
372 * @return VBox status code.
373 *
374 * @param pVM VM handle.
375 * @param GCPhys Guest context physical address of the memory to be mapped. Must be page aligned!
376 * @param cb Size of the memory. Will be rounded up to nearest page.
377 * @param pszDesc Mapping description.
378 * @param pGCPtr Where to store the GC address.
379 */
380VMMR3DECL(int) MMR3HyperMapGCPhys(PVM pVM, RTGCPHYS GCPhys, size_t cb, const char *pszDesc, PRTGCPTR pGCPtr)
381{
382 LogFlow(("MMR3HyperMapGCPhys: GCPhys=%VGp cb=%d pszDesc=%p:{%s} pGCPtr=%p\n", GCPhys, (int)cb, pszDesc, pszDesc, pGCPtr));
383
384 /*
385 * Validate input.
386 */
387 AssertReturn(RT_ALIGN_T(GCPhys, PAGE_SIZE, RTGCPHYS) == GCPhys, VERR_INVALID_PARAMETER);
388 AssertReturn(pszDesc && *pszDesc, VERR_INVALID_PARAMETER);
389
390 /*
391 * Add the memory to the hypervisor area.
392 */
393 cb = RT_ALIGN_Z(cb, PAGE_SIZE);
394 RTGCPTR GCPtr;
395 PMMLOOKUPHYPER pLookup;
396 int rc = mmR3HyperMap(pVM, cb, pszDesc, &GCPtr, &pLookup);
397 if (VBOX_SUCCESS(rc))
398 {
399 pLookup->enmType = MMLOOKUPHYPERTYPE_GCPHYS;
400 pLookup->u.GCPhys.GCPhys = GCPhys;
401
402 /*
403 * Update the page table.
404 */
405 for (unsigned off = 0; off < cb; off += PAGE_SIZE)
406 {
407 RTHCPHYS HCPhys;
408 rc = PGMPhysGCPhys2HCPhys(pVM, GCPhys + off, &HCPhys);
409 AssertRC(rc);
410 if (VBOX_FAILURE(rc))
411 {
412 AssertMsgFailed(("rc=%Vrc GCPhys=%VGv off=%#x %s\n", rc, GCPhys, off, pszDesc));
413 break;
414 }
415 if (pVM->mm.s.fPGMInitialized)
416 {
417 rc = PGMMap(pVM, GCPtr + off, HCPhys, PAGE_SIZE, 0);
418 AssertRC(rc);
419 if (VBOX_FAILURE(rc))
420 {
421 AssertMsgFailed(("rc=%Vrc GCPhys=%VGv off=%#x %s\n", rc, GCPhys, off, pszDesc));
422 break;
423 }
424 }
425 }
426
427 if (VBOX_SUCCESS(rc) && pGCPtr)
428 *pGCPtr = GCPtr;
429 }
430 return rc;
431}
432
433
434/**
435 * Maps a portion of an MMIO2 region into the hypervisor region.
436 *
437 * Callers of this API must never deregister the MMIO2 region before the
438 * VM is powered off. If this becomes a requirement MMR3HyperUnmapMMIO2
439 * API will be needed to perform cleanups.
440 *
441 * @return VBox status code.
442 *
443 * @param pVM Pointer to the shared VM structure.
444 * @param pDevIns The device owning the MMIO2 memory.
445 * @param iRegion The region.
446 * @param off The offset into the region. Will be rounded down to closest page boundrary.
447 * @param cb The number of bytes to map. Will be rounded up to the closest page boundrary.
448 * @param pszDesc Mapping description.
449 * @param pRCPtr Where to store the RC address.
450 */
451VMMR3DECL(int) MMR3HyperMapMMIO2(PVM pVM, PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS off, RTGCPHYS cb,
452 const char *pszDesc, PRTRCPTR pRCPtr)
453{
454 LogFlow(("MMR3HyperMapMMIO2: pDevIns=%p iRegion=%#x off=%VGp cb=%VGp pszDesc=%p:{%s} pRCPtr=%p\n",
455 pDevIns, iRegion, off, cb, pszDesc, pszDesc, pRCPtr));
456 int rc;
457
458 /*
459 * Validate input.
460 */
461 AssertReturn(pszDesc && *pszDesc, VERR_INVALID_PARAMETER);
462 AssertReturn(off + cb > off, VERR_INVALID_PARAMETER);
463 uint32_t const offPage = off & PAGE_OFFSET_MASK;
464 off &= ~(RTGCPHYS)PAGE_OFFSET_MASK;
465 cb += offPage;
466 cb = RT_ALIGN_Z(cb, PAGE_SIZE);
467 const RTGCPHYS offEnd = off + cb;
468 AssertReturn(offEnd > off, VERR_INVALID_PARAMETER);
469 for (RTGCPHYS offCur = off; offCur < offEnd; offCur += PAGE_SIZE)
470 {
471 RTHCPHYS HCPhys;
472 rc = PGMR3PhysMMIO2GetHCPhys(pVM, pDevIns, iRegion, offCur, &HCPhys);
473 AssertMsgRCReturn(rc, ("rc=%Rrc - iRegion=%d off=%RGp\n", rc, iRegion, off), rc);
474 }
475
476 /*
477 * Add the memory to the hypervisor area.
478 */
479 RTGCPTR GCPtr;
480 PMMLOOKUPHYPER pLookup;
481 rc = mmR3HyperMap(pVM, cb, pszDesc, &GCPtr, &pLookup);
482 if (VBOX_SUCCESS(rc))
483 {
484 pLookup->enmType = MMLOOKUPHYPERTYPE_MMIO2;
485 pLookup->u.MMIO2.pDevIns = pDevIns;
486 pLookup->u.MMIO2.iRegion = iRegion;
487 pLookup->u.MMIO2.off = off;
488
489 /*
490 * Update the page table.
491 */
492 if (pVM->mm.s.fPGMInitialized)
493 {
494 for (RTGCPHYS offCur = off; offCur < offEnd; offCur += PAGE_SIZE)
495 {
496 RTHCPHYS HCPhys;
497 rc = PGMR3PhysMMIO2GetHCPhys(pVM, pDevIns, iRegion, offCur, &HCPhys);
498 AssertRCReturn(rc, VERR_INTERNAL_ERROR);
499 rc = PGMMap(pVM, GCPtr + (offCur - off), HCPhys, PAGE_SIZE, 0);
500 if (VBOX_FAILURE(rc))
501 {
502 AssertMsgFailed(("rc=%Vrc offCur=%RGp %s\n", rc, offCur, pszDesc));
503 break;
504 }
505 }
506 }
507
508 if (VBOX_SUCCESS(rc))
509 {
510 GCPtr |= offPage;
511 *pRCPtr = GCPtr;
512 AssertLogRelReturn(*pRCPtr == GCPtr, VERR_INTERNAL_ERROR);
513 }
514 }
515 return rc;
516}
517
518
519/**
520 * Locks and Maps HC virtual memory into the hypervisor region in the GC.
521 *
522 * @return VBox status code.
523 *
524 * @param pVM VM handle.
525 * @param pvR3 Host context address of the memory (may be not page
526 * aligned).
527 * @param cb Size of the memory. Will be rounded up to nearest page.
528 * @param fFree Set this if MM is responsible for freeing the memory
529 * using SUPPageFree.
530 * @param pszDesc Mapping description.
531 * @param pGCPtr Where to store the GC address corresponding to pvR3.
532 */
533VMMR3DECL(int) MMR3HyperMapHCRam(PVM pVM, void *pvR3, size_t cb, bool fFree, const char *pszDesc, PRTGCPTR pGCPtr)
534{
535 LogFlow(("MMR3HyperMapHCRam: pvR3=%p cb=%d fFree=%d pszDesc=%p:{%s} pGCPtr=%p\n", pvR3, (int)cb, fFree, pszDesc, pszDesc, pGCPtr));
536
537 /*
538 * Validate input.
539 */
540 if ( !pvR3
541 || cb <= 0
542 || !pszDesc
543 || !*pszDesc)
544 {
545 AssertMsgFailed(("Invalid parameter\n"));
546 return VERR_INVALID_PARAMETER;
547 }
548
549 /*
550 * Page align address and size.
551 */
552 void *pvR3Page = (void *)((uintptr_t)pvR3 & PAGE_BASE_HC_MASK);
553 cb += (uintptr_t)pvR3 & PAGE_OFFSET_MASK;
554 cb = RT_ALIGN_Z(cb, PAGE_SIZE);
555
556 /*
557 * Add the memory to the hypervisor area.
558 */
559 RTGCPTR GCPtr;
560 PMMLOOKUPHYPER pLookup;
561 int rc = mmR3HyperMap(pVM, cb, pszDesc, &GCPtr, &pLookup);
562 if (VBOX_SUCCESS(rc))
563 {
564 /*
565 * Lock the heap memory and tell PGM about the locked pages.
566 */
567 PMMLOCKEDMEM pLockedMem;
568 rc = mmR3LockMem(pVM, pvR3Page, cb, fFree ? MM_LOCKED_TYPE_HYPER : MM_LOCKED_TYPE_HYPER_NOFREE, &pLockedMem, false /* fSilentFailure */);
569 if (VBOX_SUCCESS(rc))
570 {
571 /* map the stuff into guest address space. */
572 if (pVM->mm.s.fPGMInitialized)
573 rc = mmR3MapLocked(pVM, pLockedMem, GCPtr, 0, ~(size_t)0, 0);
574 if (VBOX_SUCCESS(rc))
575 {
576 pLookup->enmType = MMLOOKUPHYPERTYPE_LOCKED;
577 pLookup->u.Locked.pvR3 = pvR3;
578 pLookup->u.Locked.pvR0 = NIL_RTR0PTR;
579 pLookup->u.Locked.pLockedMem = pLockedMem;
580
581 /* done. */
582 GCPtr |= (uintptr_t)pvR3 & PAGE_OFFSET_MASK;
583 *pGCPtr = GCPtr;
584 return rc;
585 }
586 /* Don't care about failure clean, we're screwed if this fails anyway. */
587 }
588 }
589
590 return rc;
591}
592
593
594/**
595 * Maps locked R3 virtual memory into the hypervisor region in the GC.
596 *
597 * @return VBox status code.
598 *
599 * @param pVM VM handle.
600 * @param pvR3 The ring-3 address of the memory, must be page aligned.
601 * @param pvR0 The ring-0 address of the memory, must be page aligned. (optional)
602 * @param cPages The number of pages.
603 * @param paPages The page descriptors.
604 * @param pszDesc Mapping description.
605 * @param pGCPtr Where to store the GC address corresponding to pvR3.
606 */
607VMMR3DECL(int) MMR3HyperMapPages(PVM pVM, void *pvR3, RTR0PTR pvR0, size_t cPages, PCSUPPAGE paPages, const char *pszDesc, PRTGCPTR pGCPtr)
608{
609 LogFlow(("MMR3HyperMapPages: pvR3=%p pvR0=%p cPages=%zu paPages=%p pszDesc=%p:{%s} pGCPtr=%p\n",
610 pvR3, pvR0, cPages, paPages, pszDesc, pszDesc, pGCPtr));
611
612 /*
613 * Validate input.
614 */
615 AssertPtrReturn(pvR3, VERR_INVALID_POINTER);
616 AssertPtrReturn(paPages, VERR_INVALID_POINTER);
617 AssertReturn(cPages > 0, VERR_INVALID_PARAMETER);
618 AssertReturn(cPages < 1024, VERR_INVALID_PARAMETER);
619 AssertPtrReturn(pszDesc, VERR_INVALID_POINTER);
620 AssertReturn(*pszDesc, VERR_INVALID_PARAMETER);
621 AssertPtrReturn(pGCPtr, VERR_INVALID_PARAMETER);
622
623 /*
624 * Add the memory to the hypervisor area.
625 */
626 RTGCPTR GCPtr;
627 PMMLOOKUPHYPER pLookup;
628 int rc = mmR3HyperMap(pVM, cPages << PAGE_SHIFT, pszDesc, &GCPtr, &pLookup);
629 if (VBOX_SUCCESS(rc))
630 {
631 /*
632 * Create a locked memory record and tell PGM about this.
633 */
634 PMMLOCKEDMEM pLockedMem = (PMMLOCKEDMEM)MMR3HeapAlloc(pVM, MM_TAG_MM, RT_OFFSETOF(MMLOCKEDMEM, aPhysPages[cPages]));
635 if (pLockedMem)
636 {
637 pLockedMem->pv = pvR3;
638 pLockedMem->cb = cPages << PAGE_SHIFT;
639 pLockedMem->eType = MM_LOCKED_TYPE_HYPER_PAGES;
640 memset(&pLockedMem->u, 0, sizeof(pLockedMem->u));
641 for (size_t i = 0; i < cPages; i++)
642 {
643 AssertReleaseReturn(paPages[i].Phys != 0 && paPages[i].Phys != NIL_RTHCPHYS && !(paPages[i].Phys & PAGE_OFFSET_MASK), VERR_INTERNAL_ERROR);
644 pLockedMem->aPhysPages[i].Phys = paPages[i].Phys;
645 pLockedMem->aPhysPages[i].uReserved = (RTHCUINTPTR)pLockedMem;
646 }
647
648 /* map the stuff into guest address space. */
649 if (pVM->mm.s.fPGMInitialized)
650 rc = mmR3MapLocked(pVM, pLockedMem, GCPtr, 0, ~(size_t)0, 0);
651 if (VBOX_SUCCESS(rc))
652 {
653 pLookup->enmType = MMLOOKUPHYPERTYPE_LOCKED;
654 pLookup->u.Locked.pvR3 = pvR3;
655 pLookup->u.Locked.pvR0 = pvR0;
656 pLookup->u.Locked.pLockedMem = pLockedMem;
657
658 /* done. */
659 *pGCPtr = GCPtr;
660 return rc;
661 }
662 /* Don't care about failure clean, we're screwed if this fails anyway. */
663 }
664 }
665
666 return rc;
667}
668
669
670/**
671 * Reserves a hypervisor memory area.
672 * Most frequent usage is fence pages and dynamically mappings like the guest PD and PDPT.
673 *
674 * @return VBox status code.
675 *
676 * @param pVM VM handle.
677 * @param cb Size of the memory. Will be rounded up to nearest page.
678 * @param pszDesc Mapping description.
679 * @param pGCPtr Where to store the assigned GC address. Optional.
680 */
681VMMR3DECL(int) MMR3HyperReserve(PVM pVM, unsigned cb, const char *pszDesc, PRTGCPTR pGCPtr)
682{
683 LogFlow(("MMR3HyperMapHCRam: cb=%d pszDesc=%p:{%s} pGCPtr=%p\n", (int)cb, pszDesc, pszDesc, pGCPtr));
684
685 /*
686 * Validate input.
687 */
688 if ( cb <= 0
689 || !pszDesc
690 || !*pszDesc)
691 {
692 AssertMsgFailed(("Invalid parameter\n"));
693 return VERR_INVALID_PARAMETER;
694 }
695
696 /*
697 * Add the memory to the hypervisor area.
698 */
699 RTGCPTR GCPtr;
700 PMMLOOKUPHYPER pLookup;
701 int rc = mmR3HyperMap(pVM, cb, pszDesc, &GCPtr, &pLookup);
702 if (VBOX_SUCCESS(rc))
703 {
704 pLookup->enmType = MMLOOKUPHYPERTYPE_DYNAMIC;
705 if (pGCPtr)
706 *pGCPtr = GCPtr;
707 return VINF_SUCCESS;
708 }
709 return rc;
710}
711
712
713/**
714 * Adds memory to the hypervisor memory arena.
715 *
716 * @return VBox status code.
717 * @param pVM The VM handle.
718 * @param cb Size of the memory. Will be rounded up to neares page.
719 * @param pszDesc The description of the memory.
720 * @param pGCPtr Where to store the GC address.
721 * @param ppLookup Where to store the pointer to the lookup record.
722 * @remark We assume the threading structure of VBox imposes natural
723 * serialization of most functions, this one included.
724 */
725static int mmR3HyperMap(PVM pVM, const size_t cb, const char *pszDesc, PRTGCPTR pGCPtr, PMMLOOKUPHYPER *ppLookup)
726{
727 /*
728 * Validate input.
729 */
730 const uint32_t cbAligned = RT_ALIGN(cb, PAGE_SIZE);
731 AssertReturn(cbAligned >= cb, VERR_INVALID_PARAMETER);
732 if (pVM->mm.s.offHyperNextStatic + cbAligned >= pVM->mm.s.cbHyperArea) /* don't use the last page, it's a fence. */
733 {
734 AssertMsgFailed(("Out of static mapping space in the HMA! offHyperAreaGC=%x cbAligned=%x\n",
735 pVM->mm.s.offHyperNextStatic, cbAligned));
736 return VERR_NO_MEMORY;
737 }
738
739 /*
740 * Allocate lookup record.
741 */
742 PMMLOOKUPHYPER pLookup;
743 int rc = MMHyperAlloc(pVM, sizeof(*pLookup), 1, MM_TAG_MM, (void **)&pLookup);
744 if (VBOX_SUCCESS(rc))
745 {
746 /*
747 * Initialize it and insert it.
748 */
749 pLookup->offNext = pVM->mm.s.offLookupHyper;
750 pLookup->cb = cbAligned;
751 pLookup->off = pVM->mm.s.offHyperNextStatic;
752 pVM->mm.s.offLookupHyper = (uint8_t *)pLookup - (uint8_t *)pVM->mm.s.pHyperHeapR3;
753 if (pLookup->offNext != (int32_t)NIL_OFFSET)
754 pLookup->offNext -= pVM->mm.s.offLookupHyper;
755 pLookup->enmType = MMLOOKUPHYPERTYPE_INVALID;
756 memset(&pLookup->u, 0xff, sizeof(pLookup->u));
757 pLookup->pszDesc = pszDesc;
758
759 /* Mapping. */
760 *pGCPtr = pVM->mm.s.pvHyperAreaGC + pVM->mm.s.offHyperNextStatic;
761 pVM->mm.s.offHyperNextStatic += cbAligned;
762
763 /* Return pointer. */
764 *ppLookup = pLookup;
765 }
766
767 AssertRC(rc);
768 LogFlow(("mmR3HyperMap: returns %Vrc *pGCPtr=%VGv\n", rc, *pGCPtr));
769 return rc;
770}
771
772
773/**
774 * Allocates a new heap.
775 *
776 * @returns VBox status code.
777 * @param pVM The VM handle.
778 * @param cb The size of the new heap.
779 * @param ppHeap Where to store the heap pointer on successful return.
780 */
781static int mmR3HyperHeapCreate(PVM pVM, const size_t cb, PMMHYPERHEAP *ppHeap)
782{
783 /*
784 * Allocate the hypervisor heap.
785 */
786 const uint32_t cbAligned = RT_ALIGN_Z(cb, PAGE_SIZE);
787 AssertReturn(cbAligned >= cb, VERR_INVALID_PARAMETER);
788 void *pv;
789 int rc = SUPPageAlloc(cbAligned >> PAGE_SHIFT, &pv); /** @todo #1865: heap allocation must be changed for osx (only). */
790 if (VBOX_SUCCESS(rc))
791 {
792 /*
793 * Initialize the heap and first free chunk.
794 */
795 PMMHYPERHEAP pHeap = (PMMHYPERHEAP)pv;
796 pHeap->u32Magic = MMHYPERHEAP_MAGIC;
797 pHeap->pbHeapR3 = (uint8_t *)pHeap + MMYPERHEAP_HDR_SIZE;
798 pHeap->pbHeapR0 = (uintptr_t)pHeap->pbHeapR3; /** @todo #1865: Map heap into ring-0 on darwin. */
799 //pHeap->pbHeapGC = 0; // set by mmR3HyperHeapMap()
800 pHeap->pVMR3 = pVM;
801 pHeap->pVMR0 = pVM->pVMR0;
802 pHeap->pVMRC = pVM->pVMRC;
803 pHeap->cbHeap = cbAligned - MMYPERHEAP_HDR_SIZE;
804 pHeap->cbFree = pHeap->cbHeap - sizeof(MMHYPERCHUNK);
805 //pHeap->offFreeHead = 0;
806 //pHeap->offFreeTail = 0;
807 pHeap->offPageAligned = pHeap->cbHeap;
808 //pHeap->HyperHeapStatTree = 0;
809
810 PMMHYPERCHUNKFREE pFree = (PMMHYPERCHUNKFREE)pHeap->pbHeapR3;
811 pFree->cb = pHeap->cbFree;
812 //pFree->core.offNext = 0;
813 MMHYPERCHUNK_SET_TYPE(&pFree->core, MMHYPERCHUNK_FLAGS_FREE);
814 pFree->core.offHeap = -(int32_t)MMYPERHEAP_HDR_SIZE;
815 //pFree->offNext = 0;
816 //pFree->offPrev = 0;
817
818 STAMR3Register(pVM, &pHeap->cbHeap, STAMTYPE_U32, STAMVISIBILITY_ALWAYS, "/MM/HyperHeap/cbHeap", STAMUNIT_BYTES, "The heap size.");
819 STAMR3Register(pVM, &pHeap->cbFree, STAMTYPE_U32, STAMVISIBILITY_ALWAYS, "/MM/HyperHeap/cbFree", STAMUNIT_BYTES, "The free space.");
820
821 *ppHeap = pHeap;
822 return VINF_SUCCESS;
823 }
824 AssertMsgFailed(("SUPPageAlloc(%d,) -> %Vrc\n", cbAligned >> PAGE_SHIFT, rc));
825
826 *ppHeap = NULL;
827 return rc;
828}
829
830
831/**
832 * Allocates a new heap.
833 */
834static int mmR3HyperHeapMap(PVM pVM, PMMHYPERHEAP pHeap, PRTGCPTR ppHeapGC)
835{
836 int rc = MMR3HyperMapHCRam(pVM, pHeap, pHeap->cbHeap + MMYPERHEAP_HDR_SIZE, true, "Heap", ppHeapGC);
837 if (VBOX_SUCCESS(rc))
838 {
839 pHeap->pVMRC = pVM->pVMRC;
840 pHeap->pbHeapRC = *ppHeapGC + MMYPERHEAP_HDR_SIZE;
841 /* Reserve a page for fencing. */
842 MMR3HyperReserve(pVM, PAGE_SIZE, "fence", NULL);
843 }
844 return rc;
845}
846
847
848#if 0
849/**
850 * Destroys a heap.
851 */
852static int mmR3HyperHeapDestroy(PVM pVM, PMMHYPERHEAP pHeap)
853{
854 /* all this is dealt with when unlocking and freeing locked memory. */
855}
856#endif
857
858
859/**
860 * Allocates memory in the Hypervisor (GC VMM) area which never will
861 * be freed and doesn't have any offset based relation to other heap blocks.
862 *
863 * The latter means that two blocks allocated by this API will not have the
864 * same relative position to each other in GC and HC. In short, never use
865 * this API for allocating nodes for an offset based AVL tree!
866 *
867 * The returned memory is of course zeroed.
868 *
869 * @returns VBox status code.
870 * @param pVM The VM to operate on.
871 * @param cb Number of bytes to allocate.
872 * @param uAlignment Required memory alignment in bytes.
873 * Values are 0,8,16,32 and PAGE_SIZE.
874 * 0 -> default alignment, i.e. 8 bytes.
875 * @param enmTag The statistics tag.
876 * @param ppv Where to store the address to the allocated
877 * memory.
878 * @remark This is assumed not to be used at times when serialization is required.
879 */
880VMMDECL(int) MMR3HyperAllocOnceNoRel(PVM pVM, size_t cb, unsigned uAlignment, MMTAG enmTag, void **ppv)
881{
882 AssertMsg(cb >= 8, ("Hey! Do you really mean to allocate less than 8 bytes?! cb=%d\n", cb));
883
884 /*
885 * Choose between allocating a new chunk of HMA memory
886 * and the heap. We will only do BIG allocations from HMA.
887 */
888 if ( cb < _64K
889 && ( uAlignment != PAGE_SIZE
890 || cb < 48*_1K))
891 {
892 int rc = MMHyperAlloc(pVM, cb, uAlignment, enmTag, ppv);
893 if ( rc != VERR_MM_HYPER_NO_MEMORY
894 || cb <= 8*_1K)
895 {
896 Log2(("MMR3HyperAllocOnceNoRel: cb=%#zx uAlignment=%#x returns %Rrc and *ppv=%p\n",
897 cb, uAlignment, rc, *ppv));
898 return rc;
899 }
900 }
901
902 /*
903 * Validate alignment.
904 */
905 switch (uAlignment)
906 {
907 case 0:
908 case 8:
909 case 16:
910 case 32:
911 case PAGE_SIZE:
912 break;
913 default:
914 AssertMsgFailed(("Invalid alignment %u\n", uAlignment));
915 return VERR_INVALID_PARAMETER;
916 }
917
918 /*
919 * Allocate the pages and the HMA space.
920 */
921 cb = RT_ALIGN(cb, PAGE_SIZE);
922 void *pvPages;
923 int rc = SUPPageAlloc(cb >> PAGE_SHIFT, &pvPages);
924 if (VBOX_SUCCESS(rc))
925 {
926 RTGCPTR GCPtr;
927 rc = MMR3HyperMapHCRam(pVM, pvPages, cb, true,
928 MMR3HeapAPrintf(pVM, MM_TAG_MM, "alloc once (%s)", mmR3GetTagName(enmTag)),
929 &GCPtr);
930 if (VBOX_SUCCESS(rc))
931 {
932 *ppv = pvPages;
933 Log2(("MMR3HyperAllocOnceNoRel: cb=%#x uAlignment=%#x returns VINF_SUCCESS and *ppv=%p\n",
934 cb, uAlignment, *ppv));
935 return rc;
936 }
937 AssertMsgFailed(("Failed to allocate %zd bytes! %Rrc\n", cb, rc));
938 SUPPageFree(pvPages, cb >> PAGE_SHIFT);
939
940 /*
941 * HACK ALERT! Try allocate it off the heap so that we don't freak
942 * out during vga/vmmdev mmio2 allocation with certain ram sizes.
943 */
944 /** @todo make a proper fix for this so we will never end up in this kind of situation! */
945 Log(("MMR3HyperAllocOnceNoRel: MMR3HyperMapHCRam failed with rc=%Rrc, try MMHyperAlloc(,%#d,,) instead\n", rc, cb));
946 int rc2 = MMHyperAlloc(pVM, cb, uAlignment, enmTag, ppv);
947 if (RT_SUCCESS(rc2))
948 {
949 Log2(("MMR3HyperAllocOnceNoRel: cb=%#x uAlignment=%#x returns %Rrc and *ppv=%p\n",
950 cb, uAlignment, rc, *ppv));
951 return rc;
952 }
953 }
954 else
955 AssertMsgFailed(("Failed to allocate %zd bytes! %Rrc\n", cb, rc));
956
957 if (rc == VERR_NO_MEMORY)
958 rc = VERR_MM_HYPER_NO_MEMORY;
959 LogRel(("MMR3HyperAllocOnceNoRel: cb=%#zx uAlignment=%#x returns %Rrc\n", cb, uAlignment, rc));
960 return rc;
961}
962
963
964/**
965 * Convert hypervisor HC virtual address to HC physical address.
966 *
967 * @returns HC physical address.
968 * @param pVM VM Handle
969 * @param pvR3 Host context virtual address.
970 */
971VMMR3DECL(RTHCPHYS) MMR3HyperHCVirt2HCPhys(PVM pVM, void *pvR3)
972{
973 PMMLOOKUPHYPER pLookup = (PMMLOOKUPHYPER)((uint8_t *)pVM->mm.s.pHyperHeapR3 + pVM->mm.s.offLookupHyper);
974 for (;;)
975 {
976 switch (pLookup->enmType)
977 {
978 case MMLOOKUPHYPERTYPE_LOCKED:
979 {
980 unsigned off = (uint8_t *)pvR3 - (uint8_t *)pLookup->u.Locked.pvR3;
981 if (off < pLookup->cb)
982 return (pLookup->u.Locked.pLockedMem->aPhysPages[off >> PAGE_SHIFT].Phys & X86_PTE_PAE_PG_MASK) | (off & PAGE_OFFSET_MASK);
983 break;
984 }
985
986 case MMLOOKUPHYPERTYPE_HCPHYS:
987 {
988 unsigned off = (uint8_t *)pvR3 - (uint8_t *)pLookup->u.HCPhys.pvR3;
989 if (off < pLookup->cb)
990 return pLookup->u.HCPhys.HCPhys + off;
991 break;
992 }
993
994 case MMLOOKUPHYPERTYPE_GCPHYS:
995 case MMLOOKUPHYPERTYPE_MMIO2:
996 case MMLOOKUPHYPERTYPE_DYNAMIC:
997 /* can (or don't want to) convert these kind of records. */
998 break;
999
1000 default:
1001 AssertMsgFailed(("enmType=%d\n", pLookup->enmType));
1002 break;
1003 }
1004
1005 /* next */
1006 if ((unsigned)pLookup->offNext == NIL_OFFSET)
1007 break;
1008 pLookup = (PMMLOOKUPHYPER)((uint8_t *)pLookup + pLookup->offNext);
1009 }
1010
1011 AssertMsgFailed(("pvR3=%p is not inside the hypervisor memory area!\n", pvR3));
1012 return NIL_RTHCPHYS;
1013}
1014
1015
1016#if 0 /* unused, not implemented */
1017/**
1018 * Convert hypervisor HC physical address to HC virtual address.
1019 *
1020 * @returns HC virtual address.
1021 * @param pVM VM Handle
1022 * @param HCPhys Host context physical address.
1023 */
1024VMMR3DECL(void *) MMR3HyperHCPhys2HCVirt(PVM pVM, RTHCPHYS HCPhys)
1025{
1026 void *pv;
1027 int rc = MMR3HyperHCPhys2HCVirtEx(pVM, HCPhys, &pv);
1028 if (VBOX_SUCCESS(rc))
1029 return pv;
1030 AssertMsgFailed(("Invalid address HCPhys=%x rc=%d\n", HCPhys, rc));
1031 return NULL;
1032}
1033
1034
1035/**
1036 * Convert hypervisor HC physical address to HC virtual address.
1037 *
1038 * @returns VBox status.
1039 * @param pVM VM Handle
1040 * @param HCPhys Host context physical address.
1041 * @param ppv Where to store the HC virtual address.
1042 */
1043VMMR3DECL(int) MMR3HyperHCPhys2HCVirtEx(PVM pVM, RTHCPHYS HCPhys, void **ppv)
1044{
1045 /*
1046 * Linear search.
1047 */
1048 /** @todo implement when actually used. */
1049 return VERR_INVALID_POINTER;
1050}
1051#endif /* unused, not implemented */
1052
1053
1054/**
1055 * Read hypervisor memory from GC virtual address.
1056 *
1057 * @returns VBox status.
1058 * @param pVM VM handle.
1059 * @param pvDst Destination address (HC of course).
1060 * @param GCPtr GC virtual address.
1061 * @param cb Number of bytes to read.
1062 *
1063 * @remarks For DBGF only.
1064 */
1065VMMR3DECL(int) MMR3HyperReadGCVirt(PVM pVM, void *pvDst, RTGCPTR GCPtr, size_t cb)
1066{
1067 if (GCPtr - pVM->mm.s.pvHyperAreaGC >= pVM->mm.s.cbHyperArea)
1068 return VERR_INVALID_PARAMETER;
1069 return PGMR3MapRead(pVM, pvDst, GCPtr, cb);
1070}
1071
1072
1073/**
1074 * Info handler for 'hma', it dumps the list of lookup records for the hypervisor memory area.
1075 *
1076 * @param pVM The VM handle.
1077 * @param pHlp Callback functions for doing output.
1078 * @param pszArgs Argument string. Optional and specific to the handler.
1079 */
1080static DECLCALLBACK(void) mmR3HyperInfoHma(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs)
1081{
1082 pHlp->pfnPrintf(pHlp, "Hypervisor Memory Area (HMA) Layout: Base %VGv, 0x%08x bytes\n",
1083 pVM->mm.s.pvHyperAreaGC, pVM->mm.s.cbHyperArea);
1084
1085 PMMLOOKUPHYPER pLookup = (PMMLOOKUPHYPER)((uint8_t *)pVM->mm.s.pHyperHeapR3 + pVM->mm.s.offLookupHyper);
1086 for (;;)
1087 {
1088 switch (pLookup->enmType)
1089 {
1090 case MMLOOKUPHYPERTYPE_LOCKED:
1091 pHlp->pfnPrintf(pHlp, "%VGv-%VGv %RHv LOCKED %-*s %s\n",
1092 pLookup->off + pVM->mm.s.pvHyperAreaGC,
1093 pLookup->off + pVM->mm.s.pvHyperAreaGC + pLookup->cb,
1094 pLookup->u.Locked.pvR3,
1095 sizeof(RTHCPTR) * 2,
1096 pLookup->u.Locked.pLockedMem->eType == MM_LOCKED_TYPE_HYPER_NOFREE ? "nofree"
1097 : pLookup->u.Locked.pLockedMem->eType == MM_LOCKED_TYPE_HYPER ? "autofree"
1098 : pLookup->u.Locked.pLockedMem->eType == MM_LOCKED_TYPE_HYPER_PAGES ? "pages"
1099 : pLookup->u.Locked.pLockedMem->eType == MM_LOCKED_TYPE_PHYS ? "gstphys"
1100 : "??",
1101 pLookup->pszDesc);
1102 break;
1103
1104 case MMLOOKUPHYPERTYPE_HCPHYS:
1105 pHlp->pfnPrintf(pHlp, "%VGv-%VGv %RHv HCPHYS %VHp %s\n",
1106 pLookup->off + pVM->mm.s.pvHyperAreaGC,
1107 pLookup->off + pVM->mm.s.pvHyperAreaGC + pLookup->cb,
1108 pLookup->u.HCPhys.pvR3, pLookup->u.HCPhys.HCPhys,
1109 pLookup->pszDesc);
1110 break;
1111
1112 case MMLOOKUPHYPERTYPE_GCPHYS:
1113 pHlp->pfnPrintf(pHlp, "%VGv-%VGv %*s GCPHYS %VGp%*s %s\n",
1114 pLookup->off + pVM->mm.s.pvHyperAreaGC,
1115 pLookup->off + pVM->mm.s.pvHyperAreaGC + pLookup->cb,
1116 sizeof(RTHCPTR) * 2, "",
1117 pLookup->u.GCPhys.GCPhys, RT_ABS((int)(sizeof(RTHCPHYS) - sizeof(RTGCPHYS))) * 2, "",
1118 pLookup->pszDesc);
1119 break;
1120
1121 case MMLOOKUPHYPERTYPE_MMIO2:
1122 pHlp->pfnPrintf(pHlp, "%VGv-%VGv %*s MMIO2 %VGp%*s %s\n",
1123 pLookup->off + pVM->mm.s.pvHyperAreaGC,
1124 pLookup->off + pVM->mm.s.pvHyperAreaGC + pLookup->cb,
1125 sizeof(RTHCPTR) * 2, "",
1126 pLookup->u.MMIO2.off, RT_ABS((int)(sizeof(RTHCPHYS) - sizeof(RTGCPHYS))) * 2, "",
1127 pLookup->pszDesc);
1128 break;
1129
1130 case MMLOOKUPHYPERTYPE_DYNAMIC:
1131 pHlp->pfnPrintf(pHlp, "%VGv-%VGv %*s DYNAMIC %*s %s\n",
1132 pLookup->off + pVM->mm.s.pvHyperAreaGC,
1133 pLookup->off + pVM->mm.s.pvHyperAreaGC + pLookup->cb,
1134 sizeof(RTHCPTR) * 2, "",
1135 sizeof(RTHCPTR) * 2, "",
1136 pLookup->pszDesc);
1137 break;
1138
1139 default:
1140 AssertMsgFailed(("enmType=%d\n", pLookup->enmType));
1141 break;
1142 }
1143
1144 /* next */
1145 if ((unsigned)pLookup->offNext == NIL_OFFSET)
1146 break;
1147 pLookup = (PMMLOOKUPHYPER)((uint8_t *)pLookup + pLookup->offNext);
1148 }
1149}
1150
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette