MMInternal.h@ 7632

Last change on this file since 7632 was 7632, checked in by vboxsync, 17 years ago
Added optional fences to the hyper heap.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 23.3 KB

Line
1	/* $Id: MMInternal.h 7632 2008-03-28 17:05:00Z vboxsync $ */
2	/** @file
3	* MM - Internal header file.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 innotek 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 (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 ___MMInternal_h
19	#define ___MMInternal_h
20
21	#include <VBox/cdefs.h>
22	#include <VBox/types.h>
23	#include <VBox/sup.h>
24	#include <VBox/stam.h>
25	#include <iprt/avl.h>
26	#include <iprt/critsect.h>
27
28
29	#if !defined(IN_MM_R3) && !defined(IN_MM_R0) && !defined(IN_MM_GC)
30	# error "Not in MM! This is an internal header!"
31	#endif
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	*/
60	typedef 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. */
84	typedef MMHEAPSTAT *PMMHEAPSTAT;
85
86
87
88	/**
89	* Additional heap block header for relating allocations to the VM.
90	*/
91	typedef 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. */
104	typedef MMHEAPHDR *PMMHEAPHDR;
105
106
107	/** MM Heap structure. */
108	typedef 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. */
124	typedef 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__)
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__)
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__)
152	# define MMHYPER_HEAP_STRICT 1
153	# if 0 \|\| defined(__DOXYGEN__)
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 0xdeadbeef
163	# endif
164	#endif
165
166	/**
167	* Hypervisor heap statistics record.
168	* There is one global and one per allocation tag.
169	*/
170	typedef 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. */
195	typedef MMHYPERSTAT *PMMHYPERSTAT;
196
197	/**
198	* Hypervisor heap chunk.
199	*/
200	typedef 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. */
213	typedef MMHYPERCHUNK *PMMHYPERCHUNK;
214
215
216	/**
217	* Hypervisor heap chunk.
218	*/
219	typedef 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. */
231	typedef MMHYPERCHUNKFREE *PMMHYPERCHUNKFREE;
232
233
234	/**
235	* The hypervisor heap.
236	*/
237	typedef 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 VM. */
244	R3PTRTYPE(PVM) pVMHC;
245	/** The HC Ring-3 address of the heap. */
246	R3R0PTRTYPE(uint8_t *) pbHeapHC;
247	/** The GC address of the heap. */
248	GCPTRTYPE(uint8_t *) pbHeapGC;
249	/** The GC address of the VM. */
250	GCPTRTYPE(PVM) pVMGC;
251	/** The amount of free memory in the heap. */
252	uint32_t cbFree;
253	/** Offset of the first free chunk in the heap.
254	* The offset is relative to the start of the heap. */
255	uint32_t offFreeHead;
256	/** Offset of the last free chunk in the heap.
257	* The offset is relative to the start of the heap. */
258	uint32_t offFreeTail;
259	/** Offset of the first page aligned block in the heap.
260	* The offset is equal to cbHeap initially. */
261	uint32_t offPageAligned;
262	/** Tree of hypervisor heap statistics. */
263	AVLOGCPHYSTREE HyperHeapStatTree;
264	#ifdef MMHYPER_HEAP_FREE_DELAY
265	/** Where to insert the next free. */
266	uint32_t iDelayedFree;
267	/** Array of delayed frees. Circular. Offsets relative to this structure. */
268	struct
269	{
270	/** The free caller address. */
271	RTUINTPTR uCaller;
272	/** The offset of the freed chunk. */
273	uint32_t offChunk;
274	} aDelayedFrees[MMHYPER_HEAP_FREE_DELAY];
275	#else
276	/** Padding the structure to a 64-bit aligned size. */
277	uint32_t u32Padding0;
278	#endif
279	} MMHYPERHEAP;
280	/** Pointer to the hypervisor heap. */
281	typedef MMHYPERHEAP *PMMHYPERHEAP;
282
283	/** Magic value for MMHYPERHEAP. (C. S. Lewis) */
284	#define MMHYPERHEAP_MAGIC 0x18981129
285
286
287	/**
288	* Hypervisor heap minimum alignment (16 bytes).
289	*/
290	#define MMHYPER_HEAP_ALIGN_MIN 16
291
292	/**
293	* The aligned size of the the MMHYPERHEAP structure.
294	*/
295	#define MMYPERHEAP_HDR_SIZE RT_ALIGN_Z(sizeof(MMHYPERHEAP), MMHYPER_HEAP_ALIGN_MIN * 4)
296
297	/** @name Hypervisor heap chunk flags.
298	* The flags are put in the first bits of the MMHYPERCHUNK::offPrev member.
299	* These bits aren't used anyway because of the chunk minimal alignment (16 bytes).
300	* @{ */
301	/** The chunk is free. (The code ASSUMES this is 0!) */
302	#define MMHYPERCHUNK_FLAGS_FREE 0x0
303	/** The chunk is in use. */
304	#define MMHYPERCHUNK_FLAGS_USED 0x1
305	/** The type mask. */
306	#define MMHYPERCHUNK_FLAGS_TYPE_MASK 0x1
307	/** The flag mask */
308	#define MMHYPERCHUNK_FLAGS_MASK 0x1
309
310	/** Checks if the chunk is free. */
311	#define MMHYPERCHUNK_ISFREE(pChunk) ( (((pChunk)->offPrev) & MMHYPERCHUNK_FLAGS_TYPE_MASK) == MMHYPERCHUNK_FLAGS_FREE )
312	/** Checks if the chunk is used. */
313	#define MMHYPERCHUNK_ISUSED(pChunk) ( (((pChunk)->offPrev) & MMHYPERCHUNK_FLAGS_TYPE_MASK) == MMHYPERCHUNK_FLAGS_USED )
314	/** Toggles FREE/USED flag of a chunk. */
315	#define MMHYPERCHUNK_SET_TYPE(pChunk, type) do { (pChunk)->offPrev = ((pChunk)->offPrev & ~MMHYPERCHUNK_FLAGS_TYPE_MASK) \| ((type) & MMHYPERCHUNK_FLAGS_TYPE_MASK); } while (0)
316
317	/** Gets the prev offset without the flags. */
318	#define MMHYPERCHUNK_GET_OFFPREV(pChunk) ((int32_t)((pChunk)->offPrev & ~MMHYPERCHUNK_FLAGS_MASK))
319	/** Sets the prev offset without changing the flags. */
320	#define MMHYPERCHUNK_SET_OFFPREV(pChunk, off) do { (pChunk)->offPrev = (off) \| ((pChunk)->offPrev & MMHYPERCHUNK_FLAGS_MASK); } while (0)
321	#if 0
322	/** Clears one or more flags. */
323	#define MMHYPERCHUNK_FLAGS_OP_CLEAR(pChunk, fFlags) do { ((pChunk)->offPrev) &= ~((fFlags) & MMHYPERCHUNK_FLAGS_MASK); } while (0)
324	/** Sets one or more flags. */
325	#define MMHYPERCHUNK_FLAGS_OP_SET(pChunk, fFlags) do { ((pChunk)->offPrev) \|= ((fFlags) & MMHYPERCHUNK_FLAGS_MASK); } while (0)
326	/** Checks if one is set. */
327	#define MMHYPERCHUNK_FLAGS_OP_ISSET(pChunk, fFlag) (!!(((pChunk)->offPrev) & ((fFlag) & MMHYPERCHUNK_FLAGS_MASK)))
328	#endif
329	/** @} */
330
331	/** @} */
332
333
334	/** @name Page Pool Internals
335	* @{
336	*/
337
338	/**
339	* Page sub pool
340	*
341	* About the allocation of this structrue. To keep the number of heap blocks,
342	* the number of heap calls, and fragmentation low we allocate all the data
343	* related to a MMPAGESUBPOOL node in one chunk. That means that after the
344	* bitmap (which is of variable size) comes the SUPPAGE records and then
345	* follows the lookup tree nodes.
346	*/
347	typedef struct MMPAGESUBPOOL
348	{
349	/** Pointer to next sub pool. */
350	struct MMPAGESUBPOOL *pNext;
351	/** Pointer to next sub pool in the free chain.
352	* This is NULL if we're not in the free chain or at the end of it. */
353	struct MMPAGESUBPOOL *pNextFree;
354	/** Pointer to array of lock ranges.
355	* This is allocated together with the MMPAGESUBPOOL and thus needs no freeing.
356	* It follows immediately after the bitmap.
357	* The reserved field is a pointer to this structure.
358	*/
359	PSUPPAGE paPhysPages;
360	/** Pointer to the first page. */
361	void *pvPages;
362	/** Size of the subpool. */
363	unsigned cPages;
364	/** Number of free pages. */
365	unsigned cPagesFree;
366	/** The allocation bitmap.
367	* This may extend beyond the end of the defined array size.
368	*/
369	unsigned auBitmap[1];
370	/* ... SUPPAGE aRanges[1]; */
371	} MMPAGESUBPOOL;
372	/** Pointer to page sub pool. */
373	typedef MMPAGESUBPOOL *PMMPAGESUBPOOL;
374
375	/**
376	* Page pool.
377	*/
378	typedef struct MMPAGEPOOL
379	{
380	/** List of subpools. */
381	PMMPAGESUBPOOL pHead;
382	/** Head of subpools with free pages. */
383	PMMPAGESUBPOOL pHeadFree;
384	/** AVLPV tree for looking up HC virtual addresses.
385	* The tree contains MMLOOKUPVIRTPP records.
386	*/
387	PAVLPVNODECORE pLookupVirt;
388	/** Tree for looking up HC physical addresses.
389	* The tree contains MMLOOKUPPHYSHC records.
390	*/
391	AVLHCPHYSTREE pLookupPhys;
392	/** Pointer to the VM this pool belongs. */
393	PVM pVM;
394	/** Flag indicating the allocation method.
395	* Set: SUPLowAlloc().
396	* Clear: SUPPageAlloc() + SUPPageLock(). */
397	bool fLow;
398	/** Number of subpools. */
399	uint32_t cSubPools;
400	/** Number of pages in pool. */
401	uint32_t cPages;
402	#ifdef VBOX_WITH_STATISTICS
403	/** Number of free pages in pool. */
404	uint32_t cFreePages;
405	/** Number of alloc calls. */
406	STAMCOUNTER cAllocCalls;
407	/** Number of free calls. */
408	STAMCOUNTER cFreeCalls;
409	/** Number of to phys conversions. */
410	STAMCOUNTER cToPhysCalls;
411	/** Number of to virtual conversions. */
412	STAMCOUNTER cToVirtCalls;
413	/** Number of real errors. */
414	STAMCOUNTER cErrors;
415	#endif
416	} MMPAGEPOOL;
417	/** Pointer to page pool. */
418	typedef MMPAGEPOOL *PMMPAGEPOOL;
419
420	/**
421	* Lookup record for HC virtual memory in the page pool.
422	*/
423	typedef struct MMPPLOOKUPHCPTR
424	{
425	/** The key is virtual address. */
426	AVLPVNODECORE Core;
427	/** Pointer to subpool if lookup record for a pool. */
428	struct MMPAGESUBPOOL *pSubPool;
429	} MMPPLOOKUPHCPTR;
430	/** Pointer to virtual memory lookup record. */
431	typedef MMPPLOOKUPHCPTR *PMMPPLOOKUPHCPTR;
432
433	/**
434	* Lookup record for HC physical memory.
435	*/
436	typedef struct MMPPLOOKUPHCPHYS
437	{
438	/** The key is physical address. */
439	AVLHCPHYSNODECORE Core;
440	/** Pointer to SUPPAGE record for this physical address. */
441	PSUPPAGE pPhysPage;
442	} MMPPLOOKUPHCPHYS;
443	/** Pointer to physical memory lookup record. */
444	typedef MMPPLOOKUPHCPHYS *PMMPPLOOKUPHCPHYS;
445
446	/** @} */
447
448
449
450	/**
451	* Type of memory that's locked.
452	*/
453	typedef enum MMLOCKEDTYPE
454	{
455	/** Hypervisor: Ring-3 memory locked by MM. */
456	MM_LOCKED_TYPE_HYPER,
457	/** Hypervisor: Ring-3 memory locked by MM that shouldn't be freed up. */
458	MM_LOCKED_TYPE_HYPER_NOFREE,
459	/** Hypervisor: Pre-locked ring-3 pages. */
460	MM_LOCKED_TYPE_HYPER_PAGES,
461	/** Guest: Physical VM memory (RAM & MMIO2). */
462	MM_LOCKED_TYPE_PHYS
463	} MMLOCKEDTYPE;
464	/** Pointer to memory type. */
465	typedef MMLOCKEDTYPE *PMMLOCKEDTYPE;
466
467
468	/**
469	* Converts a SUPPAGE pointer to a MMLOCKEDMEM pointer.
470	* @returns Pointer to the MMLOCKEDMEM record the range is associated with.
471	* @param pSupPage Pointer to SUPPAGE structure managed by MM.
472	*/
473	#define MM_SUPRANGE_TO_MMLOCKEDMEM(pSupPage) ((PMMLOCKEDMEM)pSupPage->uReserved)
474
475
476	/**
477	* Locked memory record.
478	*/
479	typedef struct MMLOCKEDMEM
480	{
481	/** Address (host mapping). */
482	void *pv;
483	/** Size. */
484	size_t cb;
485	/** Next record. */
486	struct MMLOCKEDMEM *pNext;
487	/** Record type. */
488	MMLOCKEDTYPE eType;
489	/** Type specific data. */
490	union
491	{
492	/** Data for MM_LOCKED_TYPE_HYPER, MM_LOCKED_TYPE_HYPER_NOFREE and MM_LOCKED_TYPE_HYPER_PAGES. */
493	struct
494	{
495	unsigned uNothing;
496	} hyper;
497
498	/** Data for MM_LOCKED_TYPE_PHYS. */
499	struct
500	{
501	/** The GC physical address.
502	* (Assuming that this is a linear range of GC physical pages.)
503	*/
504	RTGCPHYS GCPhys;
505	} phys;
506	} u;
507
508	/** Physical Page Array. (Variable length.)
509	* The uReserved field contains pointer to the MMLOCKMEM record.
510	* Use the macro MM_SUPPAGE_TO_MMLOCKEDMEM() to convert.
511	*
512	* For MM_LOCKED_TYPE_PHYS the low 12 bits of the pvPhys member
513	* are bits (MM_RAM_FLAGS_*) and not part of the physical address.
514	*/
515	SUPPAGE aPhysPages[1];
516	} MMLOCKEDMEM;
517	/** Pointer to locked memory. */
518	typedef MMLOCKEDMEM *PMMLOCKEDMEM;
519
520
521	/**
522	* A registered Rom range.
523	*
524	* This is used to track ROM registrations both for debug reasons
525	* and for resetting shadow ROM at reset.
526	*
527	* This is allocated of the MMR3Heap and thus only accessibel from ring-3.
528	*/
529	typedef struct MMROMRANGE
530	{
531	/** Pointer to the next */
532	struct MMROMRANGE *pNext;
533	/** Address of the range. */
534	RTGCPHYS GCPhys;
535	/** Size of the range. */
536	uint32_t cbRange;
537	/** Shadow ROM? */
538	bool fShadow;
539	/** Is the shadow ROM currently wriable? */
540	bool fWritable;
541	/** The address of the virgin ROM image for shadow ROM. */
542	const void *pvBinary;
543	/** The address of the guest RAM that's shadowing the ROM. (lazy bird) */
544	void *pvCopy;
545	/** The ROM description. */
546	const char *pszDesc;
547	} MMROMRANGE;
548	/** Pointer to a ROM range. */
549	typedef MMROMRANGE *PMMROMRANGE;
550
551
552	/**
553	* Hypervisor memory mapping type.
554	*/
555	typedef enum MMLOOKUPHYPERTYPE
556	{
557	/** Invalid record. This is used for record which are incomplete. */
558	MMLOOKUPHYPERTYPE_INVALID = 0,
559	/** Mapping of locked memory. */
560	MMLOOKUPHYPERTYPE_LOCKED,
561	/** Mapping of contiguous HC physical memory. */
562	MMLOOKUPHYPERTYPE_HCPHYS,
563	/** Mapping of contiguous GC physical memory. */
564	MMLOOKUPHYPERTYPE_GCPHYS,
565	/** Dynamic mapping area (MMR3HyperReserve).
566	* A conversion will require to check what's in the page table for the pages. */
567	MMLOOKUPHYPERTYPE_DYNAMIC
568	} MMLOOKUPHYPERTYPE;
569
570	/**
571	* Lookup record for the hypervisor memory area.
572	*/
573	typedef struct MMLOOKUPHYPER
574	{
575	/** Byte offset from the start of this record to the next.
576	* If the value is NIL_OFFSET the chain is terminated. */
577	int32_t offNext;
578	/** Offset into the hypvervisor memory area. */
579	uint32_t off;
580	/** Size of this part. */
581	uint32_t cb;
582	/** Locking type. */
583	MMLOOKUPHYPERTYPE enmType;
584	/** Type specific data */
585	union
586	{
587	/** Locked memory. */
588	struct
589	{
590	/** Host context pointer. */
591	R3PTRTYPE(void *) pvHC;
592	/** Host context ring-0 pointer. */
593	RTR0PTR pvR0;
594	/** Pointer to the locked mem record. */
595	R3PTRTYPE(PMMLOCKEDMEM) pLockedMem;
596	} Locked;
597
598	/** Contiguous physical memory. */
599	struct
600	{
601	/** Host context pointer. */
602	R3PTRTYPE(void *) pvHC;
603	/** HC physical address corresponding to pvHC. */
604	RTHCPHYS HCPhys;
605	} HCPhys;
606	/** Contiguous guest physical memory. */
607	struct
608	{
609	/** HC physical address corresponding to pvHC. */
610	RTGCPHYS GCPhys;
611	} GCPhys;
612	} u;
613	/** Description. */
614	R3PTRTYPE(const char *) pszDesc;
615	} MMLOOKUPHYPER;
616	/** Pointer to a hypervisor memory lookup record. */
617	typedef MMLOOKUPHYPER *PMMLOOKUPHYPER;
618
619
620	/**
621	* Converts a MM pointer into a VM pointer.
622	* @returns Pointer to the VM structure the MM is part of.
623	* @param pMM Pointer to MM instance data.
624	*/
625	#define MM2VM(pMM) ( (PVM)((char*)pMM - pMM->offVM) )
626
627
628	/**
629	* MM Data (part of VM)
630	*/
631	typedef struct MM
632	{
633	/** Offset to the VM structure.
634	* See MM2VM(). */
635	RTINT offVM;
636
637	/** Set if MMR3InitPaging has been called. */
638	bool fDoneMMR3InitPaging;
639	/** Set if PGM has been initialized and we can safely call PGMR3Map(). */
640	bool fPGMInitialized;
641	#if GC_ARCH_BITS == 64 \|\| HC_ARCH_BITS == 64
642	uint32_t u32Padding1; /*< alignment padding. /
643	#endif
644
645	/** Lookup list for the Hypervisor Memory Area.
646	* The offset is relative to the start of the heap.
647	* Use pHyperHeapHC or pHyperHeapGC to calculate the address.
648	*/
649	RTUINT offLookupHyper;
650
651	/** The offset of the next static mapping in the Hypervisor Memory Area. */
652	RTUINT offHyperNextStatic;
653	/** The size of the HMA.
654	* Starts at 12MB and will be fixed late in the init process. */
655	RTUINT cbHyperArea;
656
657	/** Guest address of the Hypervisor Memory Area. */
658	RTGCPTR pvHyperAreaGC;
659
660	/** The hypervisor heap (GC Ptr). */
661	GCPTRTYPE(PMMHYPERHEAP) pHyperHeapGC;
662	/** The hypervisor heap (HC Ptr). */
663	R3R0PTRTYPE(PMMHYPERHEAP) pHyperHeapHC;
664
665	/** List of memory locks. (HC only) */
666	R3PTRTYPE(PMMLOCKEDMEM) pLockedMem;
667
668	/** Page pool. (HC only) */
669	R3R0PTRTYPE(PMMPAGEPOOL) pPagePool;
670	/** Page pool pages in low memory. (HC only) */
671	R3R0PTRTYPE(PMMPAGEPOOL) pPagePoolLow;
672
673	/** Pointer to the dummy page.
674	* The dummy page is a paranoia thingy used for instance for pure MMIO RAM ranges
675	* to make sure any bugs will not harm whatever the system stores in the first
676	* physical page. */
677	R3PTRTYPE(void *) pvDummyPage;
678	/** Physical address of the dummy page. */
679	RTHCPHYS HCPhysDummyPage;
680
681	/** Size of the base RAM in bytes. (The CFGM RamSize value.) */
682	uint64_t cbRamBase;
683	/** The number of base RAM pages that PGM has reserved (GMM).
684	* @remarks Shadow ROMs will be counted twice (RAM+ROM), so it won't be 1:1 with
685	* what the guest sees. */
686	uint64_t cBasePages;
687	/** The number of shadow pages PGM has reserved (GMM). */
688	uint32_t cShadowPages;
689	/** The number of fixed pages we've reserved (GMM). */
690	uint32_t cFixedPages;
691
692	/** The head of the ROM ranges. */
693	R3PTRTYPE(PMMROMRANGE) pRomHead;
694	} MM;
695	/** Pointer to MM Data (part of VM). */
696	typedef MM *PMM;
697
698
699	/**
700	* MM data kept in the UVM.
701	*/
702	typedef struct MMUSERPERVM
703	{
704	/** Pointer to the MM R3 Heap. */
705	R3PTRTYPE(PMMHEAP) pHeap;
706	} MMUSERPERVM;
707	/** Pointer to the MM data kept in the UVM. */
708	typedef MMUSERPERVM *PMMUSERPERVM;
709
710
711	__BEGIN_DECLS
712
713
714	int mmR3UpdateReservation(PVM pVM);
715
716	int mmR3PagePoolInit(PVM pVM);
717	void mmR3PagePoolTerm(PVM pVM);
718
719	int mmR3HeapCreateU(PUVM pUVM, PMMHEAP *ppHeap);
720	void mmR3HeapDestroy(PMMHEAP pHeap);
721
722	int mmR3HyperInit(PVM pVM);
723	int mmR3HyperInitPaging(PVM pVM);
724
725	int mmR3LockMem(PVM pVM, void pv, size_t cb, MMLOCKEDTYPE eType, PMMLOCKEDMEM ppLockedMem, bool fSilentFailure);
726	int mmR3MapLocked(PVM pVM, PMMLOCKEDMEM pLockedMem, RTGCPTR Addr, unsigned iPage, size_t cPages, unsigned fFlags);
727
728	const char *mmR3GetTagName(MMTAG enmTag);
729
730	void mmR3PhysRomReset(PVM pVM);
731
732	/**
733	* Converts a pool address to a physical address.
734	* The specified allocation type must match with the address.
735	*
736	* @returns Physical address.
737	* @returns NIL_RTHCPHYS if not found or eType is not matching.
738	* @param pPool Pointer to the page pool.
739	* @param pv The address to convert.
740	* @thread The Emulation Thread.
741	*/
742	MMDECL(RTHCPHYS) mmPagePoolPtr2Phys(PMMPAGEPOOL pPool, void *pv);
743
744	/**
745	* Converts a pool physical address to a linear address.
746	* The specified allocation type must match with the address.
747	*
748	* @returns Physical address.
749	* @returns NULL if not found or eType is not matching.
750	* @param pPool Pointer to the page pool.
751	* @param HCPhys The address to convert.
752	* @thread The Emulation Thread.
753	*/
754	MMDECL(void *) mmPagePoolPhys2Ptr(PMMPAGEPOOL pPool, RTHCPHYS HCPhys);
755
756	__END_DECLS
757
758	/** @} */
759
760	#endif

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

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

Download in other formats: