MMInternal.h@ 7932

Last change on this file since 7932 was 7635, checked in by vboxsync, 17 years ago
The new MMIO2 code. WARNING! This changes the pci mapping protocol for MMIO2 so it's working the same way as I/O ports and normal MMIO memory. External users of the interface will have to update their mapping routines.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 23.7 KB

Line
1	/* $Id: MMInternal.h 7635 2008-03-28 17:15:38Z 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	/** Mapping of MMIO2 memory. */
566	MMLOOKUPHYPERTYPE_MMIO2,
567	/** Dynamic mapping area (MMR3HyperReserve).
568	* A conversion will require to check what's in the page table for the pages. */
569	MMLOOKUPHYPERTYPE_DYNAMIC
570	} MMLOOKUPHYPERTYPE;
571
572	/**
573	* Lookup record for the hypervisor memory area.
574	*/
575	typedef struct MMLOOKUPHYPER
576	{
577	/** Byte offset from the start of this record to the next.
578	* If the value is NIL_OFFSET the chain is terminated. */
579	int32_t offNext;
580	/** Offset into the hypvervisor memory area. */
581	uint32_t off;
582	/** Size of this part. */
583	uint32_t cb;
584	/** Locking type. */
585	MMLOOKUPHYPERTYPE enmType;
586	/** Type specific data */
587	union
588	{
589	/** Locked memory. */
590	struct
591	{
592	/** Host context pointer. */
593	R3PTRTYPE(void *) pvHC;
594	/** Host context ring-0 pointer. */
595	RTR0PTR pvR0;
596	/** Pointer to the locked mem record. */
597	R3PTRTYPE(PMMLOCKEDMEM) pLockedMem;
598	} Locked;
599
600	/** Contiguous physical memory. */
601	struct
602	{
603	/** Host context pointer. */
604	R3PTRTYPE(void *) pvHC;
605	/** HC physical address corresponding to pvHC. */
606	RTHCPHYS HCPhys;
607	} HCPhys;
608	/** Contiguous guest physical memory. */
609	struct
610	{
611	/** HC physical address corresponding to pvHC. */
612	RTGCPHYS GCPhys;
613	} GCPhys;
614	/** MMIO2 memory. */
615	struct
616	{
617	/** The device instance owning the MMIO2 region. */
618	PPDMDEVINS pDevIns;
619	/** The region number. */
620	uint32_t iRegion;
621	/** The offset into the MMIO2 region. */
622	RTGCPHYS off;
623	} MMIO2;
624	} u;
625	/** Description. */
626	R3PTRTYPE(const char *) pszDesc;
627	} MMLOOKUPHYPER;
628	/** Pointer to a hypervisor memory lookup record. */
629	typedef MMLOOKUPHYPER *PMMLOOKUPHYPER;
630
631
632	/**
633	* Converts a MM pointer into a VM pointer.
634	* @returns Pointer to the VM structure the MM is part of.
635	* @param pMM Pointer to MM instance data.
636	*/
637	#define MM2VM(pMM) ( (PVM)((char*)pMM - pMM->offVM) )
638
639
640	/**
641	* MM Data (part of VM)
642	*/
643	typedef struct MM
644	{
645	/** Offset to the VM structure.
646	* See MM2VM(). */
647	RTINT offVM;
648
649	/** Set if MMR3InitPaging has been called. */
650	bool fDoneMMR3InitPaging;
651	/** Set if PGM has been initialized and we can safely call PGMR3Map(). */
652	bool fPGMInitialized;
653	#if GC_ARCH_BITS == 64 \|\| HC_ARCH_BITS == 64
654	uint32_t u32Padding1; /*< alignment padding. /
655	#endif
656
657	/** Lookup list for the Hypervisor Memory Area.
658	* The offset is relative to the start of the heap.
659	* Use pHyperHeapHC or pHyperHeapGC to calculate the address.
660	*/
661	RTUINT offLookupHyper;
662
663	/** The offset of the next static mapping in the Hypervisor Memory Area. */
664	RTUINT offHyperNextStatic;
665	/** The size of the HMA.
666	* Starts at 12MB and will be fixed late in the init process. */
667	RTUINT cbHyperArea;
668
669	/** Guest address of the Hypervisor Memory Area. */
670	RTGCPTR pvHyperAreaGC;
671
672	/** The hypervisor heap (GC Ptr). */
673	GCPTRTYPE(PMMHYPERHEAP) pHyperHeapGC;
674	/** The hypervisor heap (HC Ptr). */
675	R3R0PTRTYPE(PMMHYPERHEAP) pHyperHeapHC;
676
677	/** List of memory locks. (HC only) */
678	R3PTRTYPE(PMMLOCKEDMEM) pLockedMem;
679
680	/** Page pool. (HC only) */
681	R3R0PTRTYPE(PMMPAGEPOOL) pPagePool;
682	/** Page pool pages in low memory. (HC only) */
683	R3R0PTRTYPE(PMMPAGEPOOL) pPagePoolLow;
684
685	/** Pointer to the dummy page.
686	* The dummy page is a paranoia thingy used for instance for pure MMIO RAM ranges
687	* to make sure any bugs will not harm whatever the system stores in the first
688	* physical page. */
689	R3PTRTYPE(void *) pvDummyPage;
690	/** Physical address of the dummy page. */
691	RTHCPHYS HCPhysDummyPage;
692
693	/** Size of the base RAM in bytes. (The CFGM RamSize value.) */
694	uint64_t cbRamBase;
695	/** The number of base RAM pages that PGM has reserved (GMM).
696	* @remarks Shadow ROMs will be counted twice (RAM+ROM), so it won't be 1:1 with
697	* what the guest sees. */
698	uint64_t cBasePages;
699	/** The number of shadow pages PGM has reserved (GMM). */
700	uint32_t cShadowPages;
701	/** The number of fixed pages we've reserved (GMM). */
702	uint32_t cFixedPages;
703
704	/** The head of the ROM ranges. */
705	R3PTRTYPE(PMMROMRANGE) pRomHead;
706	} MM;
707	/** Pointer to MM Data (part of VM). */
708	typedef MM *PMM;
709
710
711	/**
712	* MM data kept in the UVM.
713	*/
714	typedef struct MMUSERPERVM
715	{
716	/** Pointer to the MM R3 Heap. */
717	R3PTRTYPE(PMMHEAP) pHeap;
718	} MMUSERPERVM;
719	/** Pointer to the MM data kept in the UVM. */
720	typedef MMUSERPERVM *PMMUSERPERVM;
721
722
723	__BEGIN_DECLS
724
725
726	int mmR3UpdateReservation(PVM pVM);
727
728	int mmR3PagePoolInit(PVM pVM);
729	void mmR3PagePoolTerm(PVM pVM);
730
731	int mmR3HeapCreateU(PUVM pUVM, PMMHEAP *ppHeap);
732	void mmR3HeapDestroy(PMMHEAP pHeap);
733
734	int mmR3HyperInit(PVM pVM);
735	int mmR3HyperInitPaging(PVM pVM);
736
737	int mmR3LockMem(PVM pVM, void pv, size_t cb, MMLOCKEDTYPE eType, PMMLOCKEDMEM ppLockedMem, bool fSilentFailure);
738	int mmR3MapLocked(PVM pVM, PMMLOCKEDMEM pLockedMem, RTGCPTR Addr, unsigned iPage, size_t cPages, unsigned fFlags);
739
740	const char *mmR3GetTagName(MMTAG enmTag);
741
742	void mmR3PhysRomReset(PVM pVM);
743
744	/**
745	* Converts a pool address to a physical address.
746	* The specified allocation type must match with the address.
747	*
748	* @returns Physical address.
749	* @returns NIL_RTHCPHYS if not found or eType is not matching.
750	* @param pPool Pointer to the page pool.
751	* @param pv The address to convert.
752	* @thread The Emulation Thread.
753	*/
754	MMDECL(RTHCPHYS) mmPagePoolPtr2Phys(PMMPAGEPOOL pPool, void *pv);
755
756	/**
757	* Converts a pool physical address to a linear address.
758	* The specified allocation type must match with the address.
759	*
760	* @returns Physical address.
761	* @returns NULL if not found or eType is not matching.
762	* @param pPool Pointer to the page pool.
763	* @param HCPhys The address to convert.
764	* @thread The Emulation Thread.
765	*/
766	MMDECL(void *) mmPagePoolPhys2Ptr(PMMPAGEPOOL pPool, RTHCPHYS HCPhys);
767
768	__END_DECLS
769
770	/** @} */
771
772	#endif

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

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

Download in other formats: