VirtualBox

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

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

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