MMInternal.h@ 87933

Last change on this file since 87933 was 82968, checked in by vboxsync, 5 years ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 20.8 KB

Line
1	/* $Id: MMInternal.h 82968 2020-02-04 10:35:17Z vboxsync $ */
2	/** @file
3	* MM - Internal header file.
4	*/
5
6	/*
7	* Copyright (C) 2006-2020 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	#ifndef VMM_INCLUDED_SRC_include_MMInternal_h
19	#define VMM_INCLUDED_SRC_include_MMInternal_h
20	#ifndef RT_WITHOUT_PRAGMA_ONCE
21	# pragma once
22	#endif
23
24	#include <VBox/cdefs.h>
25	#include <VBox/types.h>
26	#include <VBox/sup.h>
27	#include <VBox/vmm/stam.h>
28	#include <VBox/vmm/pdmcritsect.h>
29	#include <iprt/assert.h>
30	#include <iprt/avl.h>
31	#include <iprt/critsect.h>
32
33
34
35	/** @defgroup grp_mm_int Internals
36	* @ingroup grp_mm
37	* @internal
38	* @{
39	*/
40
41
42	/** @name MMR3Heap - VM Ring-3 Heap Internals
43	* @{
44	*/
45
46	/** @def MMR3HEAP_SIZE_ALIGNMENT
47	* The allocation size alignment of the MMR3Heap.
48	*/
49	#define MMR3HEAP_SIZE_ALIGNMENT 16
50
51	/** @def MMR3HEAP_WITH_STATISTICS
52	* Enable MMR3Heap statistics.
53	*/
54	#if !defined(MMR3HEAP_WITH_STATISTICS) && defined(VBOX_WITH_STATISTICS)
55	# define MMR3HEAP_WITH_STATISTICS
56	#endif
57
58	/**
59	* Heap statistics record.
60	* There is one global and one per allocation tag.
61	*/
62	typedef struct MMHEAPSTAT
63	{
64	/** Core avl node, key is the tag. */
65	AVLULNODECORE Core;
66	/** Pointer to the heap the memory belongs to. */
67	struct MMHEAP *pHeap;
68	#ifdef MMR3HEAP_WITH_STATISTICS
69	/** Number of bytes currently allocated. */
70	size_t cbCurAllocated;
71	/** Number of allocation. */
72	uint64_t cAllocations;
73	/** Number of reallocations. */
74	uint64_t cReallocations;
75	/** Number of frees. */
76	uint64_t cFrees;
77	/** Failures. */
78	uint64_t cFailures;
79	/** Number of bytes allocated (sum). */
80	uint64_t cbAllocated;
81	/** Number of bytes freed. */
82	uint64_t cbFreed;
83	#endif
84	} MMHEAPSTAT;
85	#if defined(MMR3HEAP_WITH_STATISTICS) && defined(IN_RING3)
86	AssertCompileMemberAlignment(MMHEAPSTAT, cAllocations, 8);
87	AssertCompileSizeAlignment(MMHEAPSTAT, 8);
88	#endif
89	/** Pointer to heap statistics record. */
90	typedef MMHEAPSTAT *PMMHEAPSTAT;
91
92
93
94
95	/**
96	* Additional heap block header for relating allocations to the VM.
97	*/
98	typedef struct MMHEAPHDR
99	{
100	/** Pointer to the next record. */
101	struct MMHEAPHDR *pNext;
102	/** Pointer to the previous record. */
103	struct MMHEAPHDR *pPrev;
104	/** Pointer to the heap statistics record.
105	* (Where the a PVM can be found.) */
106	PMMHEAPSTAT pStat;
107	/** Size of the allocation (including this header). */
108	size_t cbSize;
109	} MMHEAPHDR;
110	/** Pointer to MM heap header. */
111	typedef MMHEAPHDR *PMMHEAPHDR;
112
113
114	/** MM Heap structure. */
115	typedef struct MMHEAP
116	{
117	/** Lock protecting the heap. */
118	RTCRITSECT Lock;
119	/** Heap block list head. */
120	PMMHEAPHDR pHead;
121	/** Heap block list tail. */
122	PMMHEAPHDR pTail;
123	/** Heap per tag statistics tree. */
124	PAVLULNODECORE pStatTree;
125	/** The VM handle. */
126	PUVM pUVM;
127	/** Heap global statistics. */
128	MMHEAPSTAT Stat;
129	} MMHEAP;
130	/** Pointer to MM Heap structure. */
131	typedef MMHEAP *PMMHEAP;
132
133	/** @} */
134
135
136	/** @name MMUkHeap - VM User-kernel Heap Internals
137	* @{
138	*/
139
140	/** @def MMUKHEAP_SIZE_ALIGNMENT
141	* The allocation size alignment of the MMR3UkHeap.
142	*/
143	#define MMUKHEAP_SIZE_ALIGNMENT 16
144
145	/** @def MMUKHEAP_WITH_STATISTICS
146	* Enable MMUkHeap statistics.
147	*/
148	#if !defined(MMUKHEAP_WITH_STATISTICS) && defined(VBOX_WITH_STATISTICS)
149	# define MMUKHEAP_WITH_STATISTICS
150	#endif
151
152
153	/**
154	* Heap statistics record.
155	* There is one global and one per allocation tag.
156	*/
157	typedef struct MMUKHEAPSTAT
158	{
159	/** Core avl node, key is the tag. */
160	AVLULNODECORE Core;
161	/** Number of allocation. */
162	uint64_t cAllocations;
163	/** Number of reallocations. */
164	uint64_t cReallocations;
165	/** Number of frees. */
166	uint64_t cFrees;
167	/** Failures. */
168	uint64_t cFailures;
169	/** Number of bytes allocated (sum). */
170	uint64_t cbAllocated;
171	/** Number of bytes freed. */
172	uint64_t cbFreed;
173	/** Number of bytes currently allocated. */
174	size_t cbCurAllocated;
175	} MMUKHEAPSTAT;
176	#ifdef IN_RING3
177	AssertCompileMemberAlignment(MMUKHEAPSTAT, cAllocations, 8);
178	#endif
179	/** Pointer to heap statistics record. */
180	typedef MMUKHEAPSTAT *PMMUKHEAPSTAT;
181
182	/**
183	* Sub heap tracking record.
184	*/
185	typedef struct MMUKHEAPSUB
186	{
187	/** Pointer to the next sub-heap. */
188	struct MMUKHEAPSUB *pNext;
189	/** The base address of the sub-heap. */
190	void *pv;
191	/** The size of the sub-heap. */
192	size_t cb;
193	/** The handle of the simple block pointer. */
194	RTHEAPSIMPLE hSimple;
195	/** The ring-0 address corresponding to MMUKHEAPSUB::pv. */
196	RTR0PTR pvR0;
197	} MMUKHEAPSUB;
198	/** Pointer to a sub-heap tracking record. */
199	typedef MMUKHEAPSUB *PMMUKHEAPSUB;
200
201
202	/** MM User-kernel Heap structure. */
203	typedef struct MMUKHEAP
204	{
205	/** Lock protecting the heap. */
206	RTCRITSECT Lock;
207	/** Head of the sub-heap LIFO. */
208	PMMUKHEAPSUB pSubHeapHead;
209	/** Heap per tag statistics tree. */
210	PAVLULNODECORE pStatTree;
211	/** The VM handle. */
212	PUVM pUVM;
213	#if HC_ARCH_BITS == 32
214	/** Aligning the statistics on an 8 byte boundary (for uint64_t and STAM). */
215	void *pvAlignment;
216	#endif
217	/** Heap global statistics. */
218	MMUKHEAPSTAT Stat;
219	} MMUKHEAP;
220	#ifdef IN_RING3
221	AssertCompileMemberAlignment(MMUKHEAP, Stat, 8);
222	#endif
223	/** Pointer to MM Heap structure. */
224	typedef MMUKHEAP *PMMUKHEAP;
225
226	/** @} */
227
228
229
230	/** @name Hypervisor Heap Internals
231	* @{
232	*/
233
234	/** @def MMHYPER_HEAP_FREE_DELAY
235	* If defined, it indicates the number of frees that should be delayed.
236	*/
237	#if defined(DOXYGEN_RUNNING)
238	# define MMHYPER_HEAP_FREE_DELAY 64
239	#endif
240
241	/** @def MMHYPER_HEAP_FREE_POISON
242	* If defined, it indicates that freed memory should be poisoned
243	* with the value it has.
244	*/
245	#if defined(VBOX_STRICT) \|\| defined(DOXYGEN_RUNNING)
246	# define MMHYPER_HEAP_FREE_POISON 0xcb
247	#endif
248
249	/** @def MMHYPER_HEAP_STRICT
250	* Enables a bunch of assertions in the heap code. */
251	#if defined(VBOX_STRICT) \|\| defined(DOXYGEN_RUNNING)
252	# define MMHYPER_HEAP_STRICT 1
253	# if 0 \|\| defined(DOXYGEN_RUNNING)
254	/** @def MMHYPER_HEAP_STRICT_FENCE
255	* Enables tail fence. */
256	# define MMHYPER_HEAP_STRICT_FENCE
257	/** @def MMHYPER_HEAP_STRICT_FENCE_SIZE
258	* The fence size in bytes. */
259	# define MMHYPER_HEAP_STRICT_FENCE_SIZE 256
260	/** @def MMHYPER_HEAP_STRICT_FENCE_U32
261	* The fence filler. */
262	# define MMHYPER_HEAP_STRICT_FENCE_U32 UINT32_C(0xdeadbeef)
263	# endif
264	#endif
265
266	/**
267	* Hypervisor heap statistics record.
268	* There is one global and one per allocation tag.
269	*/
270	typedef struct MMHYPERSTAT
271	{
272	/** Core avl node, key is the tag.
273	* @todo The type is wrong! Get your lazy a$$ over and create that offsetted uint32_t version we need here! */
274	AVLOGCPHYSNODECORE Core;
275	/** Aligning the 64-bit fields on a 64-bit line. */
276	uint32_t u32Padding0;
277	/** Indicator for whether these statistics are registered with STAM or not. */
278	bool fRegistered;
279	/** Number of allocation. */
280	uint64_t cAllocations;
281	/** Number of frees. */
282	uint64_t cFrees;
283	/** Failures. */
284	uint64_t cFailures;
285	/** Number of bytes allocated (sum). */
286	uint64_t cbAllocated;
287	/** Number of bytes freed (sum). */
288	uint64_t cbFreed;
289	/** Number of bytes currently allocated. */
290	uint32_t cbCurAllocated;
291	/** Max number of bytes allocated. */
292	uint32_t cbMaxAllocated;
293	} MMHYPERSTAT;
294	AssertCompileMemberAlignment(MMHYPERSTAT, cAllocations, 8);
295	/** Pointer to hypervisor heap statistics record. */
296	typedef MMHYPERSTAT *PMMHYPERSTAT;
297
298	/**
299	* Hypervisor heap chunk.
300	*/
301	typedef struct MMHYPERCHUNK
302	{
303	/** Previous block in the list of all blocks.
304	* This is relative to the start of the heap. */
305	uint32_t offNext;
306	/** Offset to the previous block relative to this one. */
307	int32_t offPrev;
308	/** The statistics record this allocation belongs to (self relative). */
309	int32_t offStat;
310	/** Offset to the heap block (self relative). */
311	int32_t offHeap;
312	} MMHYPERCHUNK;
313	/** Pointer to a hypervisor heap chunk. */
314	typedef MMHYPERCHUNK *PMMHYPERCHUNK;
315
316
317	/**
318	* Hypervisor heap chunk.
319	*/
320	typedef struct MMHYPERCHUNKFREE
321	{
322	/** Main list. */
323	MMHYPERCHUNK core;
324	/** Offset of the next chunk in the list of free nodes. */
325	uint32_t offNext;
326	/** Offset of the previous chunk in the list of free nodes. */
327	int32_t offPrev;
328	/** Size of the block. */
329	uint32_t cb;
330	} MMHYPERCHUNKFREE;
331	/** Pointer to a free hypervisor heap chunk. */
332	typedef MMHYPERCHUNKFREE *PMMHYPERCHUNKFREE;
333
334
335	/**
336	* The hypervisor heap.
337	*/
338	typedef struct MMHYPERHEAP
339	{
340	/** The typical magic (MMHYPERHEAP_MAGIC). */
341	uint32_t u32Magic;
342	/** The heap size. (This structure is not included!) */
343	uint32_t cbHeap;
344	/** Lock protecting the heap. */
345	PDMCRITSECT Lock;
346	/** The HC ring-3 address of the heap. */
347	R3PTRTYPE(uint8_t *) pbHeapR3;
348	/** The HC ring-3 address of the shared VM structure. */
349	PVMR3 pVMR3;
350	/** The HC ring-0 address of the heap. */
351	R0PTRTYPE(uint8_t *) pbHeapR0;
352	/** The HC ring-0 address of the shared VM structure. */
353	PVMR0 pVMR0;
354	/** The RC address of the heap. */
355	RCPTRTYPE(uint8_t *) pbHeapRC;
356	/** The RC address of the shared VM structure. */
357	PVMRC pVMRC;
358	/** The amount of free memory in the heap. */
359	uint32_t cbFree;
360	/** Offset of the first free chunk in the heap.
361	* The offset is relative to the start of the heap. */
362	uint32_t offFreeHead;
363	/** Offset of the last free chunk in the heap.
364	* The offset is relative to the start of the heap. */
365	uint32_t offFreeTail;
366	/** Offset of the first page aligned block in the heap.
367	* The offset is equal to cbHeap initially. */
368	uint32_t offPageAligned;
369	/** Tree of hypervisor heap statistics. */
370	AVLOGCPHYSTREE HyperHeapStatTree;
371	#ifdef MMHYPER_HEAP_FREE_DELAY
372	/** Where to insert the next free. */
373	uint32_t iDelayedFree;
374	/** Array of delayed frees. Circular. Offsets relative to this structure. */
375	struct
376	{
377	/** The free caller address. */
378	RTUINTPTR uCaller;
379	/** The offset of the freed chunk. */
380	uint32_t offChunk;
381	} aDelayedFrees[MMHYPER_HEAP_FREE_DELAY];
382	#else
383	/** Padding the structure to a 64-bit aligned size. */
384	uint32_t u32Padding0;
385	#endif
386	/** The heap physical pages. */
387	R3PTRTYPE(PSUPPAGE) paPages;
388	#if HC_ARCH_BITS == 32
389	/** Padding the structure to a 64-bit aligned size. */
390	uint32_t u32Padding1;
391	#endif
392	} MMHYPERHEAP;
393	/** Pointer to the hypervisor heap. */
394	typedef MMHYPERHEAP *PMMHYPERHEAP;
395
396	/** Magic value for MMHYPERHEAP. (C. S. Lewis) */
397	#define MMHYPERHEAP_MAGIC UINT32_C(0x18981129)
398
399
400	/**
401	* Hypervisor heap minimum alignment (16 bytes).
402	*/
403	#define MMHYPER_HEAP_ALIGN_MIN 16
404
405	/**
406	* The aligned size of the MMHYPERHEAP structure.
407	*/
408	#define MMYPERHEAP_HDR_SIZE RT_ALIGN_Z(sizeof(MMHYPERHEAP), MMHYPER_HEAP_ALIGN_MIN * 4)
409
410	/** @name Hypervisor heap chunk flags.
411	* The flags are put in the first bits of the MMHYPERCHUNK::offPrev member.
412	* These bits aren't used anyway because of the chunk minimal alignment (16 bytes).
413	* @{ */
414	/** The chunk is free. (The code ASSUMES this is 0!) */
415	#define MMHYPERCHUNK_FLAGS_FREE 0x0
416	/** The chunk is in use. */
417	#define MMHYPERCHUNK_FLAGS_USED 0x1
418	/** The type mask. */
419	#define MMHYPERCHUNK_FLAGS_TYPE_MASK 0x1
420	/** The flag mask */
421	#define MMHYPERCHUNK_FLAGS_MASK 0x1
422
423	/** Checks if the chunk is free. */
424	#define MMHYPERCHUNK_ISFREE(pChunk) ( (((pChunk)->offPrev) & MMHYPERCHUNK_FLAGS_TYPE_MASK) == MMHYPERCHUNK_FLAGS_FREE )
425	/** Checks if the chunk is used. */
426	#define MMHYPERCHUNK_ISUSED(pChunk) ( (((pChunk)->offPrev) & MMHYPERCHUNK_FLAGS_TYPE_MASK) == MMHYPERCHUNK_FLAGS_USED )
427	/** Toggles FREE/USED flag of a chunk. */
428	#define MMHYPERCHUNK_SET_TYPE(pChunk, type) do { (pChunk)->offPrev = ((pChunk)->offPrev & ~MMHYPERCHUNK_FLAGS_TYPE_MASK) \| ((type) & MMHYPERCHUNK_FLAGS_TYPE_MASK); } while (0)
429
430	/** Gets the prev offset without the flags. */
431	#define MMHYPERCHUNK_GET_OFFPREV(pChunk) ((int32_t)((pChunk)->offPrev & ~MMHYPERCHUNK_FLAGS_MASK))
432	/** Sets the prev offset without changing the flags. */
433	#define MMHYPERCHUNK_SET_OFFPREV(pChunk, off) do { (pChunk)->offPrev = (off) \| ((pChunk)->offPrev & MMHYPERCHUNK_FLAGS_MASK); } while (0)
434	#if 0
435	/** Clears one or more flags. */
436	#define MMHYPERCHUNK_FLAGS_OP_CLEAR(pChunk, fFlags) do { ((pChunk)->offPrev) &= ~((fFlags) & MMHYPERCHUNK_FLAGS_MASK); } while (0)
437	/** Sets one or more flags. */
438	#define MMHYPERCHUNK_FLAGS_OP_SET(pChunk, fFlags) do { ((pChunk)->offPrev) \|= ((fFlags) & MMHYPERCHUNK_FLAGS_MASK); } while (0)
439	/** Checks if one is set. */
440	#define MMHYPERCHUNK_FLAGS_OP_ISSET(pChunk, fFlag) (!!(((pChunk)->offPrev) & ((fFlag) & MMHYPERCHUNK_FLAGS_MASK)))
441	#endif
442	/** @} */
443
444	/** @} */
445
446	/**
447	* Hypervisor memory mapping type.
448	*/
449	typedef enum MMLOOKUPHYPERTYPE
450	{
451	/** Invalid record. This is used for record which are incomplete. */
452	MMLOOKUPHYPERTYPE_INVALID = 0,
453	/** Mapping of locked memory. */
454	MMLOOKUPHYPERTYPE_LOCKED,
455	/** Mapping of contiguous HC physical memory. */
456	MMLOOKUPHYPERTYPE_HCPHYS,
457	/** Mapping of contiguous GC physical memory. */
458	MMLOOKUPHYPERTYPE_GCPHYS,
459	/** Mapping of MMIO2 memory. */
460	MMLOOKUPHYPERTYPE_MMIO2,
461	/** Dynamic mapping area (MMR3HyperReserve).
462	* A conversion will require to check what's in the page table for the pages. */
463	MMLOOKUPHYPERTYPE_DYNAMIC
464	} MMLOOKUPHYPERTYPE;
465
466	/**
467	* Lookup record for the hypervisor memory area.
468	*/
469	typedef struct MMLOOKUPHYPER
470	{
471	/** Byte offset from the start of this record to the next.
472	* If the value is NIL_OFFSET the chain is terminated. */
473	int32_t offNext;
474	/** Offset into the hypervisor memory area. */
475	uint32_t off;
476	/** Size of this part. */
477	uint32_t cb;
478	/** Locking type. */
479	MMLOOKUPHYPERTYPE enmType;
480	/** Type specific data */
481	union
482	{
483	/** Locked memory. */
484	struct
485	{
486	/** Host context ring-3 pointer. */
487	R3PTRTYPE(void *) pvR3;
488	/** Host context ring-0 pointer. Optional. */
489	RTR0PTR pvR0;
490	/** Pointer to an array containing the physical address of each page. */
491	R3PTRTYPE(PRTHCPHYS) paHCPhysPages;
492	} Locked;
493
494	/** Contiguous physical memory. */
495	struct
496	{
497	/** Host context ring-3 pointer. */
498	R3PTRTYPE(void *) pvR3;
499	/** Host context ring-0 pointer. Optional. */
500	RTR0PTR pvR0;
501	/** HC physical address corresponding to pvR3/pvR0. */
502	RTHCPHYS HCPhys;
503	} HCPhys;
504
505	/** Contiguous guest physical memory. */
506	struct
507	{
508	/** The memory address (Guest Context). */
509	RTGCPHYS GCPhys;
510	} GCPhys;
511
512	/** MMIO2 memory. */
513	struct
514	{
515	/** The device instance owning the MMIO2 region. */
516	PPDMDEVINSR3 pDevIns;
517	/** The sub-device number. */
518	uint32_t iSubDev;
519	/** The region number. */
520	uint32_t iRegion;
521	#if HC_ARCH_BITS == 32
522	/** Alignment padding. */
523	uint32_t uPadding;
524	#endif
525	/** The offset into the MMIO2 region. */
526	RTGCPHYS off;
527	} MMIO2;
528	} u;
529	/** Description. */
530	R3PTRTYPE(const char *) pszDesc;
531	} MMLOOKUPHYPER;
532	/** Pointer to a hypervisor memory lookup record. */
533	typedef MMLOOKUPHYPER *PMMLOOKUPHYPER;
534
535
536	/**
537	* Converts a MM pointer into a VM pointer.
538	* @returns Pointer to the VM structure the MM is part of.
539	* @param pMM Pointer to MM instance data.
540	*/
541	#define MM2VM(pMM) ( (PVM)((uint8_t *)pMM - pMM->offVM) )
542
543
544	/**
545	* MM Data (part of VM)
546	*/
547	typedef struct MM
548	{
549	/** Offset to the VM structure.
550	* See MM2VM(). */
551	RTINT offVM;
552
553	/** Set if MMR3InitPaging has been called. */
554	bool fDoneMMR3InitPaging;
555	/** Set if PGM has been initialized and we can safely call PGMR3Map(). */
556	bool fPGMInitialized;
557	#if GC_ARCH_BITS == 64 \|\| HC_ARCH_BITS == 64
558	uint32_t u32Padding1; /*< alignment padding. /
559	#endif
560
561	/** Lookup list for the Hypervisor Memory Area.
562	* The offset is relative to the start of the heap.
563	* Use pHyperHeapR3, pHyperHeapR0 or pHypeRHeapRC to calculate the address.
564	*/
565	RTUINT offLookupHyper;
566
567	/** The offset of the next static mapping in the Hypervisor Memory Area. */
568	RTUINT offHyperNextStatic;
569	/** The size of the HMA.
570	* Starts at 12MB and will be fixed late in the init process. */
571	RTUINT cbHyperArea;
572
573	/** Guest address of the Hypervisor Memory Area.
574	* @remarks It's still a bit open whether this should be change to RTRCPTR or
575	* remain a RTGCPTR. */
576	RTGCPTR pvHyperAreaGC;
577
578	/** The hypervisor heap (GC Ptr). */
579	RCPTRTYPE(PMMHYPERHEAP) pHyperHeapRC;
580	#if HC_ARCH_BITS == 64 && GC_ARCH_BITS == 64
581	uint32_t u32Padding2;
582	#endif
583
584	/** The hypervisor heap (R0 Ptr). */
585	R0PTRTYPE(PMMHYPERHEAP) pHyperHeapR0;
586
587	/** The hypervisor heap (R3 Ptr). */
588	R3PTRTYPE(PMMHYPERHEAP) pHyperHeapR3;
589
590	/** Pointer to the dummy page.
591	* The dummy page is a paranoia thingy used for instance for pure MMIO RAM ranges
592	* to make sure any bugs will not harm whatever the system stores in the first
593	* physical page. */
594	R3PTRTYPE(void *) pvDummyPage;
595	/** Physical address of the dummy page. */
596	RTHCPHYS HCPhysDummyPage;
597
598	/** Size of the base RAM in bytes. (The CFGM RamSize value.) */
599	uint64_t cbRamBase;
600	/** Number of bytes of RAM above 4GB, starting at address 4GB. */
601	uint64_t cbRamAbove4GB;
602	/** Size of the below 4GB RAM hole. */
603	uint32_t cbRamHole;
604	/** Number of bytes of RAM below 4GB, starting at address 0. */
605	uint32_t cbRamBelow4GB;
606	/** The number of base RAM pages that PGM has reserved (GMM).
607	* @remarks Shadow ROMs will be counted twice (RAM+ROM), so it won't be 1:1 with
608	* what the guest sees. */
609	uint64_t cBasePages;
610	/** The number of handy pages that PGM has reserved (GMM).
611	* These are kept out of cBasePages and thus out of the saved state. */
612	uint32_t cHandyPages;
613	/** The number of shadow pages PGM has reserved (GMM). */
614	uint32_t cShadowPages;
615	/** The number of fixed pages we've reserved (GMM). */
616	uint32_t cFixedPages;
617	/** Padding. */
618	uint32_t u32Padding0;
619	} MM;
620	/** Pointer to MM Data (part of VM). */
621	typedef MM *PMM;
622
623
624	/**
625	* MM data kept in the UVM.
626	*/
627	typedef struct MMUSERPERVM
628	{
629	/** Pointer to the MM R3 Heap. */
630	R3PTRTYPE(PMMHEAP) pHeap;
631	/** Pointer to the MM Uk Heap. */
632	R3PTRTYPE(PMMUKHEAP) pUkHeap;
633	} MMUSERPERVM;
634	/** Pointer to the MM data kept in the UVM. */
635	typedef MMUSERPERVM *PMMUSERPERVM;
636
637
638	RT_C_DECLS_BEGIN
639
640
641	int mmR3UpdateReservation(PVM pVM);
642
643	int mmR3HeapCreateU(PUVM pUVM, PMMHEAP *ppHeap);
644	void mmR3HeapDestroy(PMMHEAP pHeap);
645
646	void mmR3UkHeapDestroy(PMMUKHEAP pHeap);
647	int mmR3UkHeapCreateU(PUVM pUVM, PMMUKHEAP *ppHeap);
648
649
650	int mmR3HyperInit(PVM pVM);
651	int mmR3HyperTerm(PVM pVM);
652	int mmR3HyperInitPaging(PVM pVM);
653
654	const char *mmGetTagName(MMTAG enmTag);
655
656	RT_C_DECLS_END
657
658	/** @} */
659
660	#endif /* !VMM_INCLUDED_SRC_include_MMInternal_h */
661

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

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

Download in other formats: