VirtualBox

source: vbox/trunk/src/VBox/VMM/MMInternal.h@ 13762

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

VMM + VBox/cdefs.h: consolidated all the XYZ*DECLS of the VMM into VMM*DECL. Removed dead DECL and IN_XYZ* macros.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 25.0 KB
Line 
1/* $Id: MMInternal.h 12989 2008-10-06 02:15:39Z vboxsync $ */
2/** @file
3 * MM - Internal header file.
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#ifndef ___MMInternal_h
23#define ___MMInternal_h
24
25#include <VBox/cdefs.h>
26#include <VBox/types.h>
27#include <VBox/sup.h>
28#include <VBox/stam.h>
29#include <iprt/avl.h>
30#include <iprt/critsect.h>
31
32
33
34/** @defgroup grp_mm_int Internals
35 * @internal
36 * @ingroup grp_mm
37 * @{
38 */
39
40/** @name VM Ring-3 Heap Internals
41 * @{
42 */
43
44/** @def MMR3HEAP_WITH_STATISTICS
45 * Enable MMR3Heap statistics.
46 */
47#if !defined(MMR3HEAP_WITH_STATISTICS) && defined(VBOX_WITH_STATISTICS)
48# define MMR3HEAP_WITH_STATISTICS
49#endif
50
51/** @def MMR3HEAP_SIZE_ALIGNMENT
52 * The allocation size alignment of the MMR3Heap.
53 */
54#define MMR3HEAP_SIZE_ALIGNMENT 16
55
56/**
57 * Heap statistics record.
58 * There is one global and one per allocation tag.
59 */
60typedef struct MMHEAPSTAT
61{
62 /** Core avl node, key is the tag. */
63 AVLULNODECORE Core;
64 /** Pointer to the heap the memory belongs to. */
65 struct MMHEAP *pHeap;
66#ifdef MMR3HEAP_WITH_STATISTICS
67 /** Number of allocation. */
68 uint64_t cAllocations;
69 /** Number of reallocations. */
70 uint64_t cReallocations;
71 /** Number of frees. */
72 uint64_t cFrees;
73 /** Failures. */
74 uint64_t cFailures;
75 /** Number of bytes allocated (sum). */
76 uint64_t cbAllocated;
77 /** Number of bytes freed. */
78 uint64_t cbFreed;
79 /** Number of bytes currently allocated. */
80 size_t cbCurAllocated;
81#endif
82} MMHEAPSTAT;
83/** Pointer to heap statistics record. */
84typedef MMHEAPSTAT *PMMHEAPSTAT;
85
86
87
88/**
89 * Additional heap block header for relating allocations to the VM.
90 */
91typedef struct MMHEAPHDR
92{
93 /** Pointer to the next record. */
94 struct MMHEAPHDR *pNext;
95 /** Pointer to the previous record. */
96 struct MMHEAPHDR *pPrev;
97 /** Pointer to the heap statistics record.
98 * (Where the a PVM can be found.) */
99 PMMHEAPSTAT pStat;
100 /** Size of the allocation (including this header). */
101 size_t cbSize;
102} MMHEAPHDR;
103/** Pointer to MM heap header. */
104typedef MMHEAPHDR *PMMHEAPHDR;
105
106
107/** MM Heap structure. */
108typedef struct MMHEAP
109{
110 /** Lock protecting the heap. */
111 RTCRITSECT Lock;
112 /** Heap block list head. */
113 PMMHEAPHDR pHead;
114 /** Heap block list tail. */
115 PMMHEAPHDR pTail;
116 /** Heap per tag statistics tree. */
117 PAVLULNODECORE pStatTree;
118 /** The VM handle. */
119 PUVM pUVM;
120 /** Heap global statistics. */
121 MMHEAPSTAT Stat;
122} MMHEAP;
123/** Pointer to MM Heap structure. */
124typedef MMHEAP *PMMHEAP;
125
126/** @} */
127
128
129
130/** @name Hypervisor Heap Internals
131 * @{
132 */
133
134/** @def MMHYPER_HEAP_FREE_DELAY
135 * If defined, it indicates the number of frees that should be delayed.
136 */
137#if defined(DOXYGEN_RUNNING)
138# define MMHYPER_HEAP_FREE_DELAY 64
139#endif
140
141/** @def MMHYPER_HEAP_FREE_POISON
142 * If defined, it indicates that freed memory should be poisoned
143 * with the value it has.
144 */
145#if defined(VBOX_STRICT) || defined(DOXYGEN_RUNNING)
146# define MMHYPER_HEAP_FREE_POISON 0xcb
147#endif
148
149/** @def MMHYPER_HEAP_STRICT
150 * Enables a bunch of assertions in the heap code. */
151#if defined(VBOX_STRICT) || defined(DOXYGEN_RUNNING)
152# define MMHYPER_HEAP_STRICT 1
153# if 0 || defined(DOXYGEN_RUNNING)
154/** @def MMHYPER_HEAP_STRICT_FENCE
155 * Enables tail fence. */
156# define MMHYPER_HEAP_STRICT_FENCE
157/** @def MMHYPER_HEAP_STRICT_FENCE_SIZE
158 * The fence size in bytes. */
159# define MMHYPER_HEAP_STRICT_FENCE_SIZE 256
160/** @def MMHYPER_HEAP_STRICT_FENCE_U32
161 * The fence filler. */
162# define MMHYPER_HEAP_STRICT_FENCE_U32 UINT32_C(0xdeadbeef)
163# endif
164#endif
165
166/**
167 * Hypervisor heap statistics record.
168 * There is one global and one per allocation tag.
169 */
170typedef struct MMHYPERSTAT
171{
172 /** Core avl node, key is the tag.
173 * @todo The type is wrong! Get your lazy a$$ over and create that offsetted uint32_t version we need here! */
174 AVLOGCPHYSNODECORE Core;
175 /** Aligning the 64-bit fields on a 64-bit line. */
176 uint32_t u32Padding0;
177 /** Indicator for whether these statistics are registered with STAM or not. */
178 bool fRegistered;
179 /** Number of allocation. */
180 uint64_t cAllocations;
181 /** Number of frees. */
182 uint64_t cFrees;
183 /** Failures. */
184 uint64_t cFailures;
185 /** Number of bytes allocated (sum). */
186 uint64_t cbAllocated;
187 /** Number of bytes freed (sum). */
188 uint64_t cbFreed;
189 /** Number of bytes currently allocated. */
190 uint32_t cbCurAllocated;
191 /** Max number of bytes allocated. */
192 uint32_t cbMaxAllocated;
193} MMHYPERSTAT;
194/** Pointer to hypervisor heap statistics record. */
195typedef MMHYPERSTAT *PMMHYPERSTAT;
196
197/**
198 * Hypervisor heap chunk.
199 */
200typedef struct MMHYPERCHUNK
201{
202 /** Previous block in the list of all blocks.
203 * This is relative to the start of the heap. */
204 uint32_t offNext;
205 /** Offset to the previous block relative to this one. */
206 int32_t offPrev;
207 /** The statistics record this allocation belongs to (self relative). */
208 int32_t offStat;
209 /** Offset to the heap block (self relative). */
210 int32_t offHeap;
211} MMHYPERCHUNK;
212/** Pointer to a hypervisor heap chunk. */
213typedef MMHYPERCHUNK *PMMHYPERCHUNK;
214
215
216/**
217 * Hypervisor heap chunk.
218 */
219typedef struct MMHYPERCHUNKFREE
220{
221 /** Main list. */
222 MMHYPERCHUNK core;
223 /** Offset of the next chunk in the list of free nodes. */
224 uint32_t offNext;
225 /** Offset of the previous chunk in the list of free nodes. */
226 int32_t offPrev;
227 /** Size of the block. */
228 uint32_t cb;
229} MMHYPERCHUNKFREE;
230/** Pointer to a free hypervisor heap chunk. */
231typedef MMHYPERCHUNKFREE *PMMHYPERCHUNKFREE;
232
233
234/**
235 * The hypervisor heap.
236 */
237typedef struct MMHYPERHEAP
238{
239 /** The typical magic (MMHYPERHEAP_MAGIC). */
240 uint32_t u32Magic;
241 /** The heap size. (This structure is not included!) */
242 uint32_t cbHeap;
243 /** The HC ring-3 address of the heap. */
244 R3PTRTYPE(uint8_t *) pbHeapR3;
245 /** The HC ring-3 address of the shared VM strcture. */
246 PVMR3 pVMR3;
247 /** The HC ring-0 address of the heap. */
248 R0PTRTYPE(uint8_t *) pbHeapR0;
249 /** The HC ring-0 address of the shared VM strcture. */
250 PVMR0 pVMR0;
251 /** The RC address of the heap. */
252 RCPTRTYPE(uint8_t *) pbHeapRC;
253 /** The RC address of the shared VM strcture. */
254 PVMRC pVMRC;
255 /** The amount of free memory in the heap. */
256 uint32_t cbFree;
257 /** Offset of the first free chunk in the heap.
258 * The offset is relative to the start of the heap. */
259 uint32_t offFreeHead;
260 /** Offset of the last free chunk in the heap.
261 * The offset is relative to the start of the heap. */
262 uint32_t offFreeTail;
263 /** Offset of the first page aligned block in the heap.
264 * The offset is equal to cbHeap initially. */
265 uint32_t offPageAligned;
266 /** Tree of hypervisor heap statistics. */
267 AVLOGCPHYSTREE HyperHeapStatTree;
268#ifdef MMHYPER_HEAP_FREE_DELAY
269 /** Where to insert the next free. */
270 uint32_t iDelayedFree;
271 /** Array of delayed frees. Circular. Offsets relative to this structure. */
272 struct
273 {
274 /** The free caller address. */
275 RTUINTPTR uCaller;
276 /** The offset of the freed chunk. */
277 uint32_t offChunk;
278 } aDelayedFrees[MMHYPER_HEAP_FREE_DELAY];
279#else
280 /** Padding the structure to a 64-bit aligned size. */
281 uint32_t u32Padding0;
282#endif
283} MMHYPERHEAP;
284/** Pointer to the hypervisor heap. */
285typedef MMHYPERHEAP *PMMHYPERHEAP;
286
287/** Magic value for MMHYPERHEAP. (C. S. Lewis) */
288#define MMHYPERHEAP_MAGIC UINT32_C(0x18981129)
289
290
291/**
292 * Hypervisor heap minimum alignment (16 bytes).
293 */
294#define MMHYPER_HEAP_ALIGN_MIN 16
295
296/**
297 * The aligned size of the the MMHYPERHEAP structure.
298 */
299#define MMYPERHEAP_HDR_SIZE RT_ALIGN_Z(sizeof(MMHYPERHEAP), MMHYPER_HEAP_ALIGN_MIN * 4)
300
301/** @name Hypervisor heap chunk flags.
302 * The flags are put in the first bits of the MMHYPERCHUNK::offPrev member.
303 * These bits aren't used anyway because of the chunk minimal alignment (16 bytes).
304 * @{ */
305/** The chunk is free. (The code ASSUMES this is 0!) */
306#define MMHYPERCHUNK_FLAGS_FREE 0x0
307/** The chunk is in use. */
308#define MMHYPERCHUNK_FLAGS_USED 0x1
309/** The type mask. */
310#define MMHYPERCHUNK_FLAGS_TYPE_MASK 0x1
311/** The flag mask */
312#define MMHYPERCHUNK_FLAGS_MASK 0x1
313
314/** Checks if the chunk is free. */
315#define MMHYPERCHUNK_ISFREE(pChunk) ( (((pChunk)->offPrev) & MMHYPERCHUNK_FLAGS_TYPE_MASK) == MMHYPERCHUNK_FLAGS_FREE )
316/** Checks if the chunk is used. */
317#define MMHYPERCHUNK_ISUSED(pChunk) ( (((pChunk)->offPrev) & MMHYPERCHUNK_FLAGS_TYPE_MASK) == MMHYPERCHUNK_FLAGS_USED )
318/** Toggles FREE/USED flag of a chunk. */
319#define MMHYPERCHUNK_SET_TYPE(pChunk, type) do { (pChunk)->offPrev = ((pChunk)->offPrev & ~MMHYPERCHUNK_FLAGS_TYPE_MASK) | ((type) & MMHYPERCHUNK_FLAGS_TYPE_MASK); } while (0)
320
321/** Gets the prev offset without the flags. */
322#define MMHYPERCHUNK_GET_OFFPREV(pChunk) ((int32_t)((pChunk)->offPrev & ~MMHYPERCHUNK_FLAGS_MASK))
323/** Sets the prev offset without changing the flags. */
324#define MMHYPERCHUNK_SET_OFFPREV(pChunk, off) do { (pChunk)->offPrev = (off) | ((pChunk)->offPrev & MMHYPERCHUNK_FLAGS_MASK); } while (0)
325#if 0
326/** Clears one or more flags. */
327#define MMHYPERCHUNK_FLAGS_OP_CLEAR(pChunk, fFlags) do { ((pChunk)->offPrev) &= ~((fFlags) & MMHYPERCHUNK_FLAGS_MASK); } while (0)
328/** Sets one or more flags. */
329#define MMHYPERCHUNK_FLAGS_OP_SET(pChunk, fFlags) do { ((pChunk)->offPrev) |= ((fFlags) & MMHYPERCHUNK_FLAGS_MASK); } while (0)
330/** Checks if one is set. */
331#define MMHYPERCHUNK_FLAGS_OP_ISSET(pChunk, fFlag) (!!(((pChunk)->offPrev) & ((fFlag) & MMHYPERCHUNK_FLAGS_MASK)))
332#endif
333/** @} */
334
335/** @} */
336
337
338/** @name Page Pool Internals
339 * @{
340 */
341
342/**
343 * Page sub pool
344 *
345 * About the allocation of this structure. To keep the number of heap blocks,
346 * the number of heap calls, and fragmentation low we allocate all the data
347 * related to a MMPAGESUBPOOL node in one chunk. That means that after the
348 * bitmap (which is of variable size) comes the SUPPAGE records and then
349 * follows the lookup tree nodes. (The heap in question is the hyper heap.)
350 */
351typedef struct MMPAGESUBPOOL
352{
353 /** Pointer to next sub pool. */
354 R3R0PTRTYPE(struct MMPAGESUBPOOL *) pNext;
355 /** Pointer to next sub pool in the free chain.
356 * This is NULL if we're not in the free chain or at the end of it. */
357 R3R0PTRTYPE(struct MMPAGESUBPOOL *) pNextFree;
358 /** Pointer to array of lock ranges.
359 * This is allocated together with the MMPAGESUBPOOL and thus needs no freeing.
360 * It follows immediately after the bitmap.
361 * The reserved field is a pointer to this structure.
362 */
363 R3R0PTRTYPE(PSUPPAGE) paPhysPages;
364 /** Pointer to the first page. */
365 R3R0PTRTYPE(void *) pvPages;
366 /** Size of the subpool. */
367 unsigned cPages;
368 /** Number of free pages. */
369 unsigned cPagesFree;
370 /** The allocation bitmap.
371 * This may extend beyond the end of the defined array size.
372 */
373 unsigned auBitmap[1];
374 /* ... SUPPAGE aRanges[1]; */
375} MMPAGESUBPOOL;
376/** Pointer to page sub pool. */
377typedef MMPAGESUBPOOL *PMMPAGESUBPOOL;
378
379/**
380 * Page pool.
381 */
382typedef struct MMPAGEPOOL
383{
384 /** List of subpools. */
385 R3R0PTRTYPE(PMMPAGESUBPOOL) pHead;
386 /** Head of subpools with free pages. */
387 R3R0PTRTYPE(PMMPAGESUBPOOL) pHeadFree;
388 /** AVLPV tree for looking up HC virtual addresses.
389 * The tree contains MMLOOKUPVIRTPP records.
390 */
391 R3R0PTRTYPE(PAVLPVNODECORE) pLookupVirt;
392 /** Tree for looking up HC physical addresses.
393 * The tree contains MMLOOKUPPHYSHC records.
394 */
395 R3R0PTRTYPE(AVLHCPHYSTREE) pLookupPhys;
396 /** Pointer to the VM this pool belongs. */
397 R3R0PTRTYPE(PVM) pVM;
398 /** Flag indicating the allocation method.
399 * Set: SUPLowAlloc().
400 * Clear: SUPPageAlloc() + SUPPageLock(). */
401 bool fLow;
402 /** Number of subpools. */
403 uint32_t cSubPools;
404 /** Number of pages in pool. */
405 uint32_t cPages;
406#ifdef VBOX_WITH_STATISTICS
407 /** Number of free pages in pool. */
408 uint32_t cFreePages;
409 /** Number of alloc calls. */
410 STAMCOUNTER cAllocCalls;
411 /** Number of free calls. */
412 STAMCOUNTER cFreeCalls;
413 /** Number of to phys conversions. */
414 STAMCOUNTER cToPhysCalls;
415 /** Number of to virtual conversions. */
416 STAMCOUNTER cToVirtCalls;
417 /** Number of real errors. */
418 STAMCOUNTER cErrors;
419#endif
420} MMPAGEPOOL;
421/** Pointer to page pool. */
422typedef MMPAGEPOOL *PMMPAGEPOOL;
423
424/**
425 * Lookup record for HC virtual memory in the page pool.
426 */
427typedef struct MMPPLOOKUPHCPTR
428{
429 /** The key is virtual address. */
430 AVLPVNODECORE Core;
431 /** Pointer to subpool if lookup record for a pool. */
432 struct MMPAGESUBPOOL *pSubPool;
433} MMPPLOOKUPHCPTR;
434/** Pointer to virtual memory lookup record. */
435typedef MMPPLOOKUPHCPTR *PMMPPLOOKUPHCPTR;
436
437/**
438 * Lookup record for HC physical memory.
439 */
440typedef struct MMPPLOOKUPHCPHYS
441{
442 /** The key is physical address. */
443 AVLHCPHYSNODECORE Core;
444 /** Pointer to SUPPAGE record for this physical address. */
445 PSUPPAGE pPhysPage;
446} MMPPLOOKUPHCPHYS;
447/** Pointer to physical memory lookup record. */
448typedef MMPPLOOKUPHCPHYS *PMMPPLOOKUPHCPHYS;
449
450/** @} */
451
452
453
454/**
455 * Type of memory that's locked.
456 */
457typedef enum MMLOCKEDTYPE
458{
459 /** Hypervisor: Ring-3 memory locked by MM. */
460 MM_LOCKED_TYPE_HYPER,
461 /** Hypervisor: Ring-3 memory locked by MM that shouldn't be freed up. */
462 MM_LOCKED_TYPE_HYPER_NOFREE,
463 /** Hypervisor: Pre-locked ring-3 pages. */
464 MM_LOCKED_TYPE_HYPER_PAGES,
465 /** Guest: Physical VM memory (RAM & MMIO2). */
466 MM_LOCKED_TYPE_PHYS
467} MMLOCKEDTYPE;
468/** Pointer to memory type. */
469typedef MMLOCKEDTYPE *PMMLOCKEDTYPE;
470
471
472/**
473 * Converts a SUPPAGE pointer to a MMLOCKEDMEM pointer.
474 * @returns Pointer to the MMLOCKEDMEM record the range is associated with.
475 * @param pSupPage Pointer to SUPPAGE structure managed by MM.
476 */
477#define MM_SUPRANGE_TO_MMLOCKEDMEM(pSupPage) ((PMMLOCKEDMEM)pSupPage->uReserved)
478
479
480/**
481 * Locked memory record.
482 */
483typedef struct MMLOCKEDMEM
484{
485 /** Address (host mapping). */
486 void *pv;
487 /** Size. */
488 size_t cb;
489 /** Next record. */
490 struct MMLOCKEDMEM *pNext;
491 /** Record type. */
492 MMLOCKEDTYPE eType;
493 /** Type specific data. */
494 union
495 {
496 /** Data for MM_LOCKED_TYPE_HYPER, MM_LOCKED_TYPE_HYPER_NOFREE and MM_LOCKED_TYPE_HYPER_PAGES. */
497 struct
498 {
499 unsigned uNothing;
500 } hyper;
501
502 /** Data for MM_LOCKED_TYPE_PHYS. */
503 struct
504 {
505 /** The GC physical address.
506 * (Assuming that this is a linear range of GC physical pages.)
507 */
508 RTGCPHYS GCPhys;
509 } phys;
510 } u;
511
512 /** Physical Page Array. (Variable length.)
513 * The uReserved field contains pointer to the MMLOCKMEM record.
514 * Use the macro MM_SUPPAGE_TO_MMLOCKEDMEM() to convert.
515 *
516 * For MM_LOCKED_TYPE_PHYS the low 12 bits of the pvPhys member
517 * are bits (MM_RAM_FLAGS_*) and not part of the physical address.
518 */
519 SUPPAGE aPhysPages[1];
520} MMLOCKEDMEM;
521/** Pointer to locked memory. */
522typedef MMLOCKEDMEM *PMMLOCKEDMEM;
523
524
525/**
526 * A registered Rom range.
527 *
528 * This is used to track ROM registrations both for debug reasons
529 * and for resetting shadow ROM at reset.
530 *
531 * This is allocated of the MMR3Heap and thus only accessibel from ring-3.
532 */
533typedef struct MMROMRANGE
534{
535 /** Pointer to the next */
536 struct MMROMRANGE *pNext;
537 /** Address of the range. */
538 RTGCPHYS GCPhys;
539 /** Size of the range. */
540 uint32_t cbRange;
541 /** Shadow ROM? */
542 bool fShadow;
543 /** Is the shadow ROM currently wriable? */
544 bool fWritable;
545 /** The address of the virgin ROM image for shadow ROM. */
546 const void *pvBinary;
547 /** The address of the guest RAM that's shadowing the ROM. (lazy bird) */
548 void *pvCopy;
549 /** The ROM description. */
550 const char *pszDesc;
551} MMROMRANGE;
552/** Pointer to a ROM range. */
553typedef MMROMRANGE *PMMROMRANGE;
554
555
556/**
557 * Hypervisor memory mapping type.
558 */
559typedef enum MMLOOKUPHYPERTYPE
560{
561 /** Invalid record. This is used for record which are incomplete. */
562 MMLOOKUPHYPERTYPE_INVALID = 0,
563 /** Mapping of locked memory. */
564 MMLOOKUPHYPERTYPE_LOCKED,
565 /** Mapping of contiguous HC physical memory. */
566 MMLOOKUPHYPERTYPE_HCPHYS,
567 /** Mapping of contiguous GC physical memory. */
568 MMLOOKUPHYPERTYPE_GCPHYS,
569 /** Mapping of MMIO2 memory. */
570 MMLOOKUPHYPERTYPE_MMIO2,
571 /** Dynamic mapping area (MMR3HyperReserve).
572 * A conversion will require to check what's in the page table for the pages. */
573 MMLOOKUPHYPERTYPE_DYNAMIC
574} MMLOOKUPHYPERTYPE;
575
576/**
577 * Lookup record for the hypervisor memory area.
578 */
579typedef struct MMLOOKUPHYPER
580{
581 /** Byte offset from the start of this record to the next.
582 * If the value is NIL_OFFSET the chain is terminated. */
583 int32_t offNext;
584 /** Offset into the hypvervisor memory area. */
585 uint32_t off;
586 /** Size of this part. */
587 uint32_t cb;
588 /** Locking type. */
589 MMLOOKUPHYPERTYPE enmType;
590 /** Type specific data */
591 union
592 {
593 /** Locked memory. */
594 struct
595 {
596 /** Host context pointer. */
597 R3PTRTYPE(void *) pvR3;
598 /** Host context ring-0 pointer. */
599 /** @todo #1865: Check if this actually works (doubt it) */
600 RTR0PTR pvR0;
601 /** Pointer to the locked mem record. */
602 R3PTRTYPE(PMMLOCKEDMEM) pLockedMem;
603 } Locked;
604
605 /** Contiguous physical memory. */
606 struct
607 {
608 /** Host context pointer. */
609 R3PTRTYPE(void *) pvR3;
610 /** @todo #1865: Add a pvR0 here! */
611 /** HC physical address corresponding to pvR3. */
612 RTHCPHYS HCPhys;
613 } HCPhys;
614
615 /** Contiguous guest physical memory. */
616 struct
617 {
618 /** The memory address (Guest Context). */
619 RTGCPHYS GCPhys;
620 } GCPhys;
621
622 /** MMIO2 memory. */
623 struct
624 {
625 /** The device instance owning the MMIO2 region. */
626 PPDMDEVINSR3 pDevIns;
627 /** The region number. */
628 uint32_t iRegion;
629 /** The offset into the MMIO2 region. */
630 RTGCPHYS off;
631 } MMIO2;
632 } u;
633 /** Description. */
634 R3PTRTYPE(const char *) pszDesc;
635} MMLOOKUPHYPER;
636/** Pointer to a hypervisor memory lookup record. */
637typedef MMLOOKUPHYPER *PMMLOOKUPHYPER;
638
639
640/**
641 * Converts a MM pointer into a VM pointer.
642 * @returns Pointer to the VM structure the MM is part of.
643 * @param pMM Pointer to MM instance data.
644 */
645#define MM2VM(pMM) ( (PVM)((uint8_t *)pMM - pMM->offVM) )
646
647
648/**
649 * MM Data (part of VM)
650 */
651typedef struct MM
652{
653 /** Offset to the VM structure.
654 * See MM2VM(). */
655 RTINT offVM;
656
657 /** Set if MMR3InitPaging has been called. */
658 bool fDoneMMR3InitPaging;
659 /** Set if PGM has been initialized and we can safely call PGMR3Map(). */
660 bool fPGMInitialized;
661#if GC_ARCH_BITS == 64 || HC_ARCH_BITS == 64
662 uint32_t u32Padding1; /**< alignment padding. */
663#endif
664
665 /** Lookup list for the Hypervisor Memory Area.
666 * The offset is relative to the start of the heap.
667 * Use pHyperHeapR3, pHyperHeapR0 or pHypeRHeapRC to calculate the address.
668 */
669 RTUINT offLookupHyper;
670
671 /** The offset of the next static mapping in the Hypervisor Memory Area. */
672 RTUINT offHyperNextStatic;
673 /** The size of the HMA.
674 * Starts at 12MB and will be fixed late in the init process. */
675 RTUINT cbHyperArea;
676
677 /** Guest address of the Hypervisor Memory Area.
678 * @remarks It's still a bit open whether this should be change to RTRCPTR or
679 * remain a RTGCPTR. */
680 RTGCPTR pvHyperAreaGC;
681
682 /** The hypervisor heap (GC Ptr). */
683 RCPTRTYPE(PMMHYPERHEAP) pHyperHeapRC;
684#if HC_ARCH_BITS == 64 && GC_ARCH_BITS == 64
685 uint32_t u32Padding2;
686#endif
687
688 /** The hypervisor heap (R0 Ptr). */
689 R0PTRTYPE(PMMHYPERHEAP) pHyperHeapR0;
690 /** Page pool - R0 Ptr. */
691 R0PTRTYPE(PMMPAGEPOOL) pPagePoolR0;
692 /** Page pool pages in low memory R0 Ptr. */
693 R0PTRTYPE(PMMPAGEPOOL) pPagePoolLowR0;
694
695 /** The hypervisor heap (R3 Ptr). */
696 R3PTRTYPE(PMMHYPERHEAP) pHyperHeapR3;
697 /** Page pool - R3 Ptr. */
698 R3PTRTYPE(PMMPAGEPOOL) pPagePoolR3;
699 /** Page pool pages in low memory R3 Ptr. */
700 R3PTRTYPE(PMMPAGEPOOL) pPagePoolLowR3;
701 /** List of memory locks. (HC only) */
702 R3PTRTYPE(PMMLOCKEDMEM) pLockedMem;
703
704 /** Pointer to the dummy page.
705 * The dummy page is a paranoia thingy used for instance for pure MMIO RAM ranges
706 * to make sure any bugs will not harm whatever the system stores in the first
707 * physical page. */
708 R3PTRTYPE(void *) pvDummyPage;
709 /** Physical address of the dummy page. */
710 RTHCPHYS HCPhysDummyPage;
711
712 /** Size of the base RAM in bytes. (The CFGM RamSize value.) */
713 uint64_t cbRamBase;
714 /** The number of base RAM pages that PGM has reserved (GMM).
715 * @remarks Shadow ROMs will be counted twice (RAM+ROM), so it won't be 1:1 with
716 * what the guest sees. */
717 uint64_t cBasePages;
718 /** The number of shadow pages PGM has reserved (GMM). */
719 uint32_t cShadowPages;
720 /** The number of fixed pages we've reserved (GMM). */
721 uint32_t cFixedPages;
722
723 /** The head of the ROM ranges. */
724 R3PTRTYPE(PMMROMRANGE) pRomHead;
725} MM;
726/** Pointer to MM Data (part of VM). */
727typedef MM *PMM;
728
729
730/**
731 * MM data kept in the UVM.
732 */
733typedef struct MMUSERPERVM
734{
735 /** Pointer to the MM R3 Heap. */
736 R3PTRTYPE(PMMHEAP) pHeap;
737} MMUSERPERVM;
738/** Pointer to the MM data kept in the UVM. */
739typedef MMUSERPERVM *PMMUSERPERVM;
740
741
742__BEGIN_DECLS
743
744
745int mmR3UpdateReservation(PVM pVM);
746
747int mmR3PagePoolInit(PVM pVM);
748void mmR3PagePoolTerm(PVM pVM);
749
750int mmR3HeapCreateU(PUVM pUVM, PMMHEAP *ppHeap);
751void mmR3HeapDestroy(PMMHEAP pHeap);
752
753int mmR3HyperInit(PVM pVM);
754int mmR3HyperInitPaging(PVM pVM);
755
756int mmR3LockMem(PVM pVM, void *pv, size_t cb, MMLOCKEDTYPE eType, PMMLOCKEDMEM *ppLockedMem, bool fSilentFailure);
757int mmR3MapLocked(PVM pVM, PMMLOCKEDMEM pLockedMem, RTGCPTR Addr, unsigned iPage, size_t cPages, unsigned fFlags);
758
759const char *mmR3GetTagName(MMTAG enmTag);
760
761void mmR3PhysRomReset(PVM pVM);
762
763/**
764 * Converts a pool address to a physical address.
765 * The specified allocation type must match with the address.
766 *
767 * @returns Physical address.
768 * @returns NIL_RTHCPHYS if not found or eType is not matching.
769 * @param pPool Pointer to the page pool.
770 * @param pv The address to convert.
771 * @thread The Emulation Thread.
772 */
773VMMDECL(RTHCPHYS) mmPagePoolPtr2Phys(PMMPAGEPOOL pPool, void *pv);
774
775/**
776 * Converts a pool physical address to a linear address.
777 * The specified allocation type must match with the address.
778 *
779 * @returns Physical address.
780 * @returns NULL if not found or eType is not matching.
781 * @param pPool Pointer to the page pool.
782 * @param HCPhys The address to convert.
783 * @thread The Emulation Thread.
784 */
785VMMDECL(void *) mmPagePoolPhys2Ptr(PMMPAGEPOOL pPool, RTHCPHYS HCPhys);
786
787__END_DECLS
788
789/** @} */
790
791#endif
792
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use