MMInternal.h@ 1995

Last change on this file since 1995 was 1480, checked in by vboxsync, 18 years ago
No longer require contiguous memory for the VM structure. Did long overdue IOCtl cleanup wrt R3/R0 pointers.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 21.4 KB

Line
1	/* $Id: MMInternal.h 1480 2007-03-14 18:27:47Z vboxsync $ */
2	/** @file
3	* MM - Internal header file.
4	*/
5
6	/*
7	* Copyright (C) 2006 InnoTek Systemberatung GmbH
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 as published by the Free Software Foundation,
13	* in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14	* distribution. VirtualBox OSE is distributed in the hope that it will
15	* be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* If you received this file as part of a commercial VirtualBox
18	* distribution, then only the terms of your commercial VirtualBox
19	* license agreement apply instead of the previous paragraph.
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	#if !defined(IN_MM_R3) && !defined(IN_MM_R0) && !defined(IN_MM_GC)
34	# error "Not in MM! This is an internal header!"
35	#endif
36
37
38	/** @defgroup grp_mm_int Internals
39	* @internal
40	* @ingroup grp_mm
41	* @{
42	*/
43
44	/** @name VM Ring-3 Heap Internals
45	* @{
46	*/
47
48	/** @def MMR3HEAP_WITH_STATISTICS
49	* Enable MMR3Heap statistics.
50	*/
51	#if !defined(MMR3HEAP_WITH_STATISTICS) && defined(VBOX_WITH_STATISTICS)
52	# define MMR3HEAP_WITH_STATISTICS
53	#endif
54
55	/** @def MMR3HEAP_SIZE_ALIGNMENT
56	* The allocation size alignment of the MMR3Heap.
57	*/
58	#define MMR3HEAP_SIZE_ALIGNMENT 16
59
60	/**
61	* Heap statistics record.
62	* There is one global and one per allocation tag.
63	*/
64	typedef struct MMHEAPSTAT
65	{
66	/** Core avl node, key is the tag. */
67	AVLULNODECORE Core;
68	/** Pointer to the heap the memory belongs to. */
69	struct MMHEAP *pHeap;
70	#ifdef MMR3HEAP_WITH_STATISTICS
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	/** Number of bytes currently allocated. */
84	size_t cbCurAllocated;
85	#endif
86	} MMHEAPSTAT;
87	/** Pointer to heap statistics record. */
88	typedef MMHEAPSTAT *PMMHEAPSTAT;
89
90
91
92	/**
93	* Additional heap block header for relating allocations to the VM.
94	*/
95	typedef struct MMHEAPHDR
96	{
97	/** Pointer to the next record. */
98	struct MMHEAPHDR *pNext;
99	/** Pointer to the previous record. */
100	struct MMHEAPHDR *pPrev;
101	/** Pointer to the heap statistics record.
102	* (Where the a PVM can be found.) */
103	PMMHEAPSTAT pStat;
104	/** Size of the allocation (including this header). */
105	size_t cbSize;
106	} MMHEAPHDR;
107	/** Pointer to MM heap header. */
108	typedef MMHEAPHDR *PMMHEAPHDR;
109
110
111	/** MM Heap structure. */
112	typedef struct MMHEAP
113	{
114	/** Lock protecting the heap. */
115	RTCRITSECT Lock;
116	/** Heap block list head. */
117	PMMHEAPHDR pHead;
118	/** Heap block list tail. */
119	PMMHEAPHDR pTail;
120	/** Heap per tag statistics tree. */
121	PAVLULNODECORE pStatTree;
122	/** The VM handle. */
123	PVM pVM;
124	/** Heap global statistics. */
125	MMHEAPSTAT Stat;
126	} MMHEAP;
127	/** Pointer to MM Heap structure. */
128	typedef MMHEAP *PMMHEAP;
129
130	/** @} */
131
132
133
134	/** @name Hypervisor Heap Internals
135	* @{
136	*/
137
138	/** @def MMHYPER_HEAP_FREE_DELAY
139	* If defined, it indicates the number of frees that should be delayed.
140	*/
141	#if defined(__DOXYGEN__)
142	# define MMHYPER_HEAP_FREE_DELAY 64
143	#endif
144
145	/** @def MMHYPER_HEAP_FREE_POISON
146	* If defined, it indicates that freed memory should be poisoned
147	* with the value it has.
148	*/
149	#if defined(VBOX_STRICT) \|\| defined(__DOXYGEN__)
150	# define MMHYPER_HEAP_FREE_POISON 0xCB
151	#endif
152
153	/**
154	* Hypervisor heap statistics record.
155	* There is one global and one per allocation tag.
156	*/
157	typedef struct MMHYPERSTAT
158	{
159	/** Core avl node, key is the tag.
160	* @todo The type is wrong! Get your lazy a$$ over and create that offsetted uint32_t version we need here! */
161	AVLOGCPHYSNODECORE Core;
162	/** Aligning the 64-bit fields on a 64-bit line. */
163	uint32_t u32Padding0;
164	/** Indicator for whether these statistics are registered with STAM or not. */
165	bool fRegistered;
166	/** Number of allocation. */
167	uint64_t cAllocations;
168	/** Number of frees. */
169	uint64_t cFrees;
170	/** Failures. */
171	uint64_t cFailures;
172	/** Number of bytes allocated (sum). */
173	uint64_t cbAllocated;
174	/** Number of bytes freed (sum). */
175	uint64_t cbFreed;
176	/** Number of bytes currently allocated. */
177	uint32_t cbCurAllocated;
178	/** Max number of bytes allocated. */
179	uint32_t cbMaxAllocated;
180	} MMHYPERSTAT;
181	/** Pointer to hypervisor heap statistics record. */
182	typedef MMHYPERSTAT *PMMHYPERSTAT;
183
184	/**
185	* Hypervisor heap chunk.
186	*/
187	typedef struct MMHYPERCHUNK
188	{
189	/** Previous block in the list of all blocks.
190	* This is relative to the start of the heap. */
191	uint32_t offNext;
192	/** Offset to the previous block relative to this one. */
193	int32_t offPrev;
194	/** The statistics record this allocation belongs to (self relative). */
195	int32_t offStat;
196	/** Offset to the heap block (self relative). */
197	int32_t offHeap;
198	} MMHYPERCHUNK;
199	/** Pointer to a hypervisor heap chunk. */
200	typedef MMHYPERCHUNK *PMMHYPERCHUNK;
201
202
203	/**
204	* Hypervisor heap chunk.
205	*/
206	typedef struct MMHYPERCHUNKFREE
207	{
208	/** Main list. */
209	MMHYPERCHUNK core;
210	/** Offset of the next chunk in the list of free nodes. */
211	uint32_t offNext;
212	/** Offset of the previous chunk in the list of free nodes. */
213	int32_t offPrev;
214	/** Size of the block. */
215	uint32_t cb;
216	} MMHYPERCHUNKFREE;
217	/** Pointer to a free hypervisor heap chunk. */
218	typedef MMHYPERCHUNKFREE *PMMHYPERCHUNKFREE;
219
220
221	/**
222	* The hypervisor heap.
223	*/
224	typedef struct MMHYPERHEAP
225	{
226	/** The typical magic (MMHYPERHEAP_MAGIC). */
227	uint32_t u32Magic;
228	/** The heap size. (This structure is not included!) */
229	uint32_t cbHeap;
230	/** The HC Ring-3 address of the VM. */
231	HCPTRTYPE(PVM) pVMHC;
232	/** The HC Ring-3 address of the heap. */
233	HCPTRTYPE(uint8_t *) pbHeapHC;
234	/** The GC address of the heap. */
235	GCPTRTYPE(uint8_t *) pbHeapGC;
236	/** The GC address of the VM. */
237	GCPTRTYPE(PVM) pVMGC;
238	/** The amount of free memory in the heap. */
239	uint32_t cbFree;
240	/** Offset of the first free chunk in the heap.
241	* The offset is relative to the start of the heap. */
242	uint32_t offFreeHead;
243	/** Offset of the last free chunk in the heap.
244	* The offset is relative to the start of the heap. */
245	uint32_t offFreeTail;
246	/** Offset of the first page aligned block in the heap.
247	* The offset is equal to cbHeap initially. */
248	uint32_t offPageAligned;
249	/** Tree of hypervisor heap statistics. */
250	AVLOGCPHYSTREE HyperHeapStatTree;
251	#ifdef MMHYPER_HEAP_FREE_DELAY
252	/** Where to insert the next free. */
253	uint32_t iDelayedFree;
254	/** Array of delayed frees. Circular. Offsets relative to this structure. */
255	struct
256	{
257	/** The free caller address. */
258	RTUINTPTR uCaller;
259	/** The offset of the freed chunk. */
260	uint32_t offChunk;
261	} aDelayedFrees[MMHYPER_HEAP_FREE_DELAY];
262	#else
263	/** Padding the structure to a 64-bit aligned size. */
264	uint32_t u32Padding0;
265	#endif
266	} MMHYPERHEAP;
267	/** Pointer to the hypervisor heap. */
268	typedef MMHYPERHEAP *PMMHYPERHEAP;
269
270	/** Magic value for MMHYPERHEAP. (C. S. Lewis) */
271	#define MMHYPERHEAP_MAGIC 0x18981129
272
273
274	/**
275	* Hypervisor heap minimum alignment (16 bytes).
276	*/
277	#define MMHYPER_HEAP_ALIGN_MIN 16
278
279	/**
280	* The aligned size of the the MMHYPERHEAP structure.
281	*/
282	#define MMYPERHEAP_HDR_SIZE RT_ALIGN_Z(sizeof(MMHYPERHEAP), MMHYPER_HEAP_ALIGN_MIN * 4)
283
284	/** @name Hypervisor heap chunk flags.
285	* The flags are put in the first bits of the MMHYPERCHUNK::offPrev member.
286	* These bits aren't used anyway because of the chunk minimal alignment (16 bytes).
287	* @{ */
288	/** The chunk is free. (The code ASSUMES this is 0!) */
289	#define MMHYPERCHUNK_FLAGS_FREE 0x0
290	/** The chunk is in use. */
291	#define MMHYPERCHUNK_FLAGS_USED 0x1
292	/** The type mask. */
293	#define MMHYPERCHUNK_FLAGS_TYPE_MASK 0x1
294	/** The flag mask */
295	#define MMHYPERCHUNK_FLAGS_MASK 0x1
296
297	/** Checks if the chunk is free. */
298	#define MMHYPERCHUNK_ISFREE(pChunk) ( (((pChunk)->offPrev) & MMHYPERCHUNK_FLAGS_TYPE_MASK) == MMHYPERCHUNK_FLAGS_FREE )
299	/** Checks if the chunk is used. */
300	#define MMHYPERCHUNK_ISUSED(pChunk) ( (((pChunk)->offPrev) & MMHYPERCHUNK_FLAGS_TYPE_MASK) == MMHYPERCHUNK_FLAGS_USED )
301	/** Toggles FREE/USED flag of a chunk. */
302	#define MMHYPERCHUNK_SET_TYPE(pChunk, type) do { (pChunk)->offPrev = ((pChunk)->offPrev & ~MMHYPERCHUNK_FLAGS_TYPE_MASK) \| ((type) & MMHYPERCHUNK_FLAGS_TYPE_MASK); } while (0)
303
304	/** Gets the prev offset without the flags. */
305	#define MMHYPERCHUNK_GET_OFFPREV(pChunk) ((int32_t)((pChunk)->offPrev & ~MMHYPERCHUNK_FLAGS_MASK))
306	/** Sets the prev offset without changing the flags. */
307	#define MMHYPERCHUNK_SET_OFFPREV(pChunk, off) do { (pChunk)->offPrev = (off) \| ((pChunk)->offPrev & MMHYPERCHUNK_FLAGS_MASK); } while (0)
308	#if 0
309	/** Clears one or more flags. */
310	#define MMHYPERCHUNK_FLAGS_OP_CLEAR(pChunk, fFlags) do { ((pChunk)->offPrev) &= ~((fFlags) & MMHYPERCHUNK_FLAGS_MASK); } while (0)
311	/** Sets one or more flags. */
312	#define MMHYPERCHUNK_FLAGS_OP_SET(pChunk, fFlags) do { ((pChunk)->offPrev) \|= ((fFlags) & MMHYPERCHUNK_FLAGS_MASK); } while (0)
313	/** Checks if one is set. */
314	#define MMHYPERCHUNK_FLAGS_OP_ISSET(pChunk, fFlag) (!!(((pChunk)->offPrev) & ((fFlag) & MMHYPERCHUNK_FLAGS_MASK)))
315	#endif
316	/** @} */
317
318	/** @} */
319
320
321	/** @name Page Pool Internals
322	* @{
323	*/
324
325	/**
326	* Page sub pool
327	*
328	* About the allocation of this structrue. To keep the number of heap blocks,
329	* the number of heap calls, and fragmentation low we allocate all the data
330	* related to a MMPAGESUBPOOL node in one chunk. That means that after the
331	* bitmap (which is of variable size) comes the SUPPAGE records and then
332	* follows the lookup tree nodes.
333	*/
334	typedef struct MMPAGESUBPOOL
335	{
336	/** Pointer to next sub pool. */
337	struct MMPAGESUBPOOL *pNext;
338	/** Pointer to next sub pool in the free chain.
339	* This is NULL if we're not in the free chain or at the end of it. */
340	struct MMPAGESUBPOOL *pNextFree;
341	/** Pointer to array of lock ranges.
342	* This is allocated together with the MMPAGESUBPOOL and thus needs no freeing.
343	* It follows immediately after the bitmap.
344	* The reserved field is a pointer to this structure.
345	*/
346	PSUPPAGE paPhysPages;
347	/** Pointer to the first page. */
348	void *pvPages;
349	/** Size of the subpool. */
350	unsigned cPages;
351	/** Number of free pages. */
352	unsigned cPagesFree;
353	/** The allocation bitmap.
354	* This may extend beyond the end of the defined array size.
355	*/
356	unsigned auBitmap[1];
357	/* ... SUPPAGE aRanges[1]; */
358	} MMPAGESUBPOOL;
359	/** Pointer to page sub pool. */
360	typedef MMPAGESUBPOOL *PMMPAGESUBPOOL;
361
362	/**
363	* Page pool.
364	*/
365	typedef struct MMPAGEPOOL
366	{
367	/** List of subpools. */
368	PMMPAGESUBPOOL pHead;
369	/** Head of subpools with free pages. */
370	PMMPAGESUBPOOL pHeadFree;
371	/** AVLPV tree for looking up HC virtual addresses.
372	* The tree contains MMLOOKUPVIRTPP records.
373	*/
374	PAVLPVNODECORE pLookupVirt;
375	/** Tree for looking up HC physical addresses.
376	* The tree contains MMLOOKUPPHYSHC records.
377	*/
378	AVLHCPHYSTREE pLookupPhys;
379	/** Pointer to the VM this pool belongs. */
380	PVM pVM;
381	/** Flag indicating the allocation method.
382	* Set: SUPLowAlloc().
383	* Clear: SUPPageAlloc() + SUPPageLock(). */
384	bool fLow;
385	/** Number of subpools. */
386	uint32_t cSubPools;
387	/** Number of pages in pool. */
388	uint32_t cPages;
389	#ifdef VBOX_WITH_STATISTICS
390	/** Number of free pages in pool. */
391	uint32_t cFreePages;
392	/** Number of alloc calls. */
393	STAMCOUNTER cAllocCalls;
394	/** Number of free calls. */
395	STAMCOUNTER cFreeCalls;
396	/** Number of to phys conversions. */
397	STAMCOUNTER cToPhysCalls;
398	/** Number of to virtual conversions. */
399	STAMCOUNTER cToVirtCalls;
400	/** Number of real errors. */
401	STAMCOUNTER cErrors;
402	#endif
403	} MMPAGEPOOL;
404	/** Pointer to page pool. */
405	typedef MMPAGEPOOL *PMMPAGEPOOL;
406
407	/**
408	* Lookup record for HC virtual memory in the page pool.
409	*/
410	typedef struct MMPPLOOKUPHCPTR
411	{
412	/** The key is virtual address. */
413	AVLPVNODECORE Core;
414	/** Pointer to subpool if lookup record for a pool. */
415	struct MMPAGESUBPOOL *pSubPool;
416	} MMPPLOOKUPHCPTR;
417	/** Pointer to virtual memory lookup record. */
418	typedef MMPPLOOKUPHCPTR *PMMPPLOOKUPHCPTR;
419
420	/**
421	* Lookup record for HC physical memory.
422	*/
423	typedef struct MMPPLOOKUPHCPHYS
424	{
425	/** The key is physical address. */
426	AVLHCPHYSNODECORE Core;
427	/** Pointer to SUPPAGE record for this physical address. */
428	PSUPPAGE pPhysPage;
429	} MMPPLOOKUPHCPHYS;
430	/** Pointer to physical memory lookup record. */
431	typedef MMPPLOOKUPHCPHYS *PMMPPLOOKUPHCPHYS;
432
433	/** @} */
434
435
436
437	/**
438	* Type of memory that's locked.
439	*/
440	typedef enum MMLOCKEDTYPE
441	{
442	/** Hypervisor: Ring-3 memory locked by MM. */
443	MM_LOCKED_TYPE_HYPER,
444	/** Hypervisor: Ring-3 memory locked by MM that shouldn't be freed up. */
445	MM_LOCKED_TYPE_HYPER_NOFREE,
446	/** Hypervisor: Pre-locked ring-3 pages. */
447	MM_LOCKED_TYPE_HYPER_PAGES,
448	/** Guest: Physical VM memory (RAM & MMIO2). */
449	MM_LOCKED_TYPE_PHYS
450	} MMLOCKEDTYPE;
451	/** Pointer to memory type. */
452	typedef MMLOCKEDTYPE *PMMLOCKEDTYPE;
453
454
455	/**
456	* Converts a SUPPAGE pointer to a MMLOCKEDMEM pointer.
457	* @returns Pointer to the MMLOCKEDMEM record the range is associated with.
458	* @param pSupPage Pointer to SUPPAGE structure managed by MM.
459	*/
460	#define MM_SUPRANGE_TO_MMLOCKEDMEM(pSupPage) ((PMMLOCKEDMEM)pSupPage->uReserved)
461
462
463	/**
464	* Locked memory record.
465	*/
466	typedef struct MMLOCKEDMEM
467	{
468	/** Address (host mapping). */
469	void *pv;
470	/** Size. */
471	size_t cb;
472	/** Next record. */
473	struct MMLOCKEDMEM *pNext;
474	/** Record type. */
475	MMLOCKEDTYPE eType;
476	/** Type specific data. */
477	union
478	{
479	/** Data for MM_LOCKED_TYPE_HYPER, MM_LOCKED_TYPE_HYPER_NOFREE and MM_LOCKED_TYPE_HYPER_PAGES. */
480	struct
481	{
482	unsigned uNothing;
483	} hyper;
484
485	/** Data for MM_LOCKED_TYPE_PHYS. */
486	struct
487	{
488	/** The GC physical address.
489	* (Assuming that this is a linear range of GC physical pages.)
490	*/
491	RTGCPHYS GCPhys;
492	} phys;
493	} u;
494
495	/** Physical Page Array. (Variable length.)
496	* The uReserved field contains pointer to the MMLOCKMEM record.
497	* Use the macro MM_SUPPAGE_TO_MMLOCKEDMEM() to convert.
498	*
499	* For MM_LOCKED_TYPE_PHYS the low 12 bits of the pvPhys member
500	* are bits (MM_RAM_FLAGS_*) and not part of the physical address.
501	*/
502	SUPPAGE aPhysPages[1];
503	} MMLOCKEDMEM;
504	/** Pointer to locked memory. */
505	typedef MMLOCKEDMEM *PMMLOCKEDMEM;
506
507
508	/**
509	* Hypervisor memory mapping type.
510	*/
511	typedef enum MMLOOKUPHYPERTYPE
512	{
513	/** Invalid record. This is used for record which are incomplete. */
514	MMLOOKUPHYPERTYPE_INVALID = 0,
515	/** Mapping of locked memory. */
516	MMLOOKUPHYPERTYPE_LOCKED,
517	/** Mapping of contiguous HC physical memory. */
518	MMLOOKUPHYPERTYPE_HCPHYS,
519	/** Mapping of contiguous GC physical memory. */
520	MMLOOKUPHYPERTYPE_GCPHYS,
521	/** Dynamic mapping area (MMR3HyperReserve).
522	* A conversion will require to check what's in the page table for the pages. */
523	MMLOOKUPHYPERTYPE_DYNAMIC
524	};
525
526	/**
527	* Lookup record for the hypervisor memory area.
528	*/
529	typedef struct MMLOOKUPHYPER
530	{
531	/** Byte offset from the start of this record to the next.
532	* If the value is NIL_OFFSET the chain is terminated. */
533	int32_t offNext;
534	/** Offset into the hypvervisor memory area. */
535	uint32_t off;
536	/** Size of this part. */
537	uint32_t cb;
538	/** Locking type. */
539	MMLOOKUPHYPERTYPE enmType;
540	/** Type specific data */
541	union
542	{
543	/** Locked memory. */
544	struct
545	{
546	/** Host context pointer. */
547	HCPTRTYPE(void *) pvHC;
548	/** Host context ring-0 pointer. */
549	RTR0PTR pvR0;
550	/** Pointer to the locked mem record. */
551	HCPTRTYPE(PMMLOCKEDMEM) pLockedMem;
552	} Locked;
553
554	/** Contiguous physical memory. */
555	struct
556	{
557	/** Host context pointer. */
558	HCPTRTYPE(void *) pvHC;
559	/** HC physical address corresponding to pvHC. */
560	RTHCPHYS HCPhys;
561	} HCPhys;
562	/** Contiguous guest physical memory. */
563	struct
564	{
565	/** HC physical address corresponding to pvHC. */
566	RTGCPHYS GCPhys;
567	} GCPhys;
568	} u;
569	/** Description. */
570	HCPTRTYPE(const char *) pszDesc;
571	} MMLOOKUPHYPER;
572	/** Pointer to a hypervisor memory lookup record. */
573	typedef MMLOOKUPHYPER *PMMLOOKUPHYPER;
574
575
576	/**
577	* Converts a MM pointer into a VM pointer.
578	* @returns Pointer to the VM structure the MM is part of.
579	* @param pMM Pointer to MM instance data.
580	*/
581	#define MM2VM(pMM) ( (PVM)((char*)pMM - pMM->offVM) )
582
583
584	/**
585	* MM Data (part of VM)
586	*/
587	typedef struct MM
588	{
589	/** Offset to the VM structure.
590	* See MM2VM(). */
591	RTINT offVM;
592
593	/** Set if PGM has been initialized and we can safely call PGMR3Map(). */
594	bool fPGMInitialized;
595	#if GC_ARCH_BITS == 64 \|\| HC_ARCH_BITS == 64
596	uint32_t u32Padding1; /*< alignment padding. /
597	#endif
598
599	/** Lookup list for the Hypervisor Memory Area.
600	* The offset is relative to the start of the heap.
601	* Use pHyperHeapHC or pHyperHeapGC to calculate the address.
602	*/
603	RTUINT offLookupHyper;
604
605	/** The offset of the next static mapping in the Hypervisor Memory Area. */
606	RTUINT offHyperNextStatic;
607	/** The size of the HMA.
608	* Starts at 12MB and will be fixed late in the init process. */
609	RTUINT cbHyperArea;
610
611	/** Guest address of the Hypervisor Memory Area. */
612	RTGCPTR pvHyperAreaGC;
613
614	/** The hypervisor heap (GC Ptr). */
615	GCPTRTYPE(PMMHYPERHEAP) pHyperHeapGC;
616	/** The hypervisor heap (HC Ptr). */
617	HCPTRTYPE(PMMHYPERHEAP) pHyperHeapHC;
618
619	/** List of memory locks. (HC only) */
620	HCPTRTYPE(PMMLOCKEDMEM) pLockedMem;
621
622	/** Page pool. (HC only) */
623	HCPTRTYPE(PMMPAGEPOOL) pPagePool;
624	/** Page pool pages in low memory. (HC only) */
625	HCPTRTYPE(PMMPAGEPOOL) pPagePoolLow;
626
627	/** Pointer to the dummy page.
628	* The dummy page is a paranoia thingy used for instance for pure MMIO RAM ranges
629	* to make sure any bugs will not harm whatever the system stores in the first
630	* physical page. */
631	HCPTRTYPE(void *) pvDummyPage;
632	/** Physical address of the dummy page. */
633	RTHCPHYS HCPhysDummyPage;
634
635	/** Size of the currently allocated guest RAM.
636	* Mark that this is the actual size, not the end address. */
637	RTUINT cbRAMSize;
638	/** Size of the base RAM in bytes. */
639	RTUINT cbRamBase;
640	/** Pointer to the base RAM. */
641	HCPTRTYPE(void *) pvRamBaseHC;
642
643	/** Pointer to the MM R3 Heap. */
644	HCPTRTYPE(PMMHEAP) pHeap;
645
646	} MM;
647	/** Pointer to MM Data (part of VM). */
648	typedef MM *PMM;
649
650	__BEGIN_DECLS
651
652
653	int mmr3PagePoolInit(PVM pVM);
654	void mmr3PagePoolTerm(PVM pVM);
655
656	int mmr3HeapCreate(PVM pVM, PMMHEAP *ppHeap);
657	void mmr3HeapDestroy(PMMHEAP pHeap);
658
659	int mmr3HyperInit(PVM pVM);
660	int mmR3HyperInitPaging(PVM pVM);
661
662	int mmr3LockMem(PVM pVM, void pv, size_t cb, MMLOCKEDTYPE eType, PMMLOCKEDMEM ppLockedMem, bool fSilentFailure);
663	int mmr3MapLocked(PVM pVM, PMMLOCKEDMEM pLockedMem, RTGCPTR Addr, unsigned iPage, size_t cPages, unsigned fFlags);
664
665	const char *mmR3GetTagName(MMTAG enmTag);
666
667	/**
668	* Converts a pool address to a physical address.
669	* The specified allocation type must match with the address.
670	*
671	* @returns Physical address.
672	* @returns NIL_RTHCPHYS if not found or eType is not matching.
673	* @param pPool Pointer to the page pool.
674	* @param pv The address to convert.
675	* @thread The Emulation Thread.
676	*/
677	MMDECL(RTHCPHYS) mmPagePoolPtr2Phys(PMMPAGEPOOL pPool, void *pv);
678
679	/**
680	* Converts a pool physical address to a linear address.
681	* The specified allocation type must match with the address.
682	*
683	* @returns Physical address.
684	* @returns NULL if not found or eType is not matching.
685	* @param pPool Pointer to the page pool.
686	* @param HCPhys The address to convert.
687	* @thread The Emulation Thread.
688	*/
689	MMDECL(void *) mmPagePoolPhys2Ptr(PMMPAGEPOOL pPool, RTHCPHYS HCPhys);
690
691	__END_DECLS
692
693	/** @} */
694
695	#endif

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

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

Download in other formats: