MMInternal.h@ 14683

Last change on this file since 14683 was 14597, checked in by vboxsync, 16 years ago
Added R0 address to MMR3HyperMapHCPhys and made the MMHyperXToR0 use pvR0 for HCPhys and Locked more strickly.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 26.3 KB

Line
1	/* $Id: MMInternal.h 14597 2008-11-25 20:41:40Z 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	*/
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_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	*/
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 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	/** The heap physical pages. */
284	R3PTRTYPE(PSUPPAGE) paPages;
285	#if HC_ARCH_BITS == 32
286	/** Padding the structure to a 64-bit aligned size. */
287	uint32_t u32Padding1;
288	#endif
289	} MMHYPERHEAP;
290	/** Pointer to the hypervisor heap. */
291	typedef MMHYPERHEAP *PMMHYPERHEAP;
292
293	/** Magic value for MMHYPERHEAP. (C. S. Lewis) */
294	#define MMHYPERHEAP_MAGIC UINT32_C(0x18981129)
295
296
297	/**
298	* Hypervisor heap minimum alignment (16 bytes).
299	*/
300	#define MMHYPER_HEAP_ALIGN_MIN 16
301
302	/**
303	* The aligned size of the the MMHYPERHEAP structure.
304	*/
305	#define MMYPERHEAP_HDR_SIZE RT_ALIGN_Z(sizeof(MMHYPERHEAP), MMHYPER_HEAP_ALIGN_MIN * 4)
306
307	/** @name Hypervisor heap chunk flags.
308	* The flags are put in the first bits of the MMHYPERCHUNK::offPrev member.
309	* These bits aren't used anyway because of the chunk minimal alignment (16 bytes).
310	* @{ */
311	/** The chunk is free. (The code ASSUMES this is 0!) */
312	#define MMHYPERCHUNK_FLAGS_FREE 0x0
313	/** The chunk is in use. */
314	#define MMHYPERCHUNK_FLAGS_USED 0x1
315	/** The type mask. */
316	#define MMHYPERCHUNK_FLAGS_TYPE_MASK 0x1
317	/** The flag mask */
318	#define MMHYPERCHUNK_FLAGS_MASK 0x1
319
320	/** Checks if the chunk is free. */
321	#define MMHYPERCHUNK_ISFREE(pChunk) ( (((pChunk)->offPrev) & MMHYPERCHUNK_FLAGS_TYPE_MASK) == MMHYPERCHUNK_FLAGS_FREE )
322	/** Checks if the chunk is used. */
323	#define MMHYPERCHUNK_ISUSED(pChunk) ( (((pChunk)->offPrev) & MMHYPERCHUNK_FLAGS_TYPE_MASK) == MMHYPERCHUNK_FLAGS_USED )
324	/** Toggles FREE/USED flag of a chunk. */
325	#define MMHYPERCHUNK_SET_TYPE(pChunk, type) do { (pChunk)->offPrev = ((pChunk)->offPrev & ~MMHYPERCHUNK_FLAGS_TYPE_MASK) \| ((type) & MMHYPERCHUNK_FLAGS_TYPE_MASK); } while (0)
326
327	/** Gets the prev offset without the flags. */
328	#define MMHYPERCHUNK_GET_OFFPREV(pChunk) ((int32_t)((pChunk)->offPrev & ~MMHYPERCHUNK_FLAGS_MASK))
329	/** Sets the prev offset without changing the flags. */
330	#define MMHYPERCHUNK_SET_OFFPREV(pChunk, off) do { (pChunk)->offPrev = (off) \| ((pChunk)->offPrev & MMHYPERCHUNK_FLAGS_MASK); } while (0)
331	#if 0
332	/** Clears one or more flags. */
333	#define MMHYPERCHUNK_FLAGS_OP_CLEAR(pChunk, fFlags) do { ((pChunk)->offPrev) &= ~((fFlags) & MMHYPERCHUNK_FLAGS_MASK); } while (0)
334	/** Sets one or more flags. */
335	#define MMHYPERCHUNK_FLAGS_OP_SET(pChunk, fFlags) do { ((pChunk)->offPrev) \|= ((fFlags) & MMHYPERCHUNK_FLAGS_MASK); } while (0)
336	/** Checks if one is set. */
337	#define MMHYPERCHUNK_FLAGS_OP_ISSET(pChunk, fFlag) (!!(((pChunk)->offPrev) & ((fFlag) & MMHYPERCHUNK_FLAGS_MASK)))
338	#endif
339	/** @} */
340
341	/** @} */
342
343
344	/** @name Page Pool Internals
345	* @{
346	*/
347
348	/**
349	* Page sub pool
350	*
351	* About the allocation of this structure. To keep the number of heap blocks,
352	* the number of heap calls, and fragmentation low we allocate all the data
353	* related to a MMPAGESUBPOOL node in one chunk. That means that after the
354	* bitmap (which is of variable size) comes the SUPPAGE records and then
355	* follows the lookup tree nodes. (The heap in question is the hyper heap.)
356	*/
357	typedef struct MMPAGESUBPOOL
358	{
359	/** Pointer to next sub pool. */
360	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
361	R3PTRTYPE(struct MMPAGESUBPOOL *) pNext;
362	#else
363	R3R0PTRTYPE(struct MMPAGESUBPOOL *) pNext;
364	#endif
365	/** Pointer to next sub pool in the free chain.
366	* This is NULL if we're not in the free chain or at the end of it. */
367	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
368	R3PTRTYPE(struct MMPAGESUBPOOL *) pNextFree;
369	#else
370	R3R0PTRTYPE(struct MMPAGESUBPOOL *) pNextFree;
371	#endif
372	/** Pointer to array of lock ranges.
373	* This is allocated together with the MMPAGESUBPOOL and thus needs no freeing.
374	* It follows immediately after the bitmap.
375	* The reserved field is a pointer to this structure.
376	*/
377	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
378	R3PTRTYPE(PSUPPAGE) paPhysPages;
379	#else
380	R3R0PTRTYPE(PSUPPAGE) paPhysPages;
381	#endif
382	/** Pointer to the first page. */
383	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
384	R3PTRTYPE(void *) pvPages;
385	#else
386	R3R0PTRTYPE(void *) pvPages;
387	#endif
388	/** Size of the subpool. */
389	uint32_t cPages;
390	/** Number of free pages. */
391	uint32_t cPagesFree;
392	/** The allocation bitmap.
393	* This may extend beyond the end of the defined array size.
394	*/
395	uint32_t auBitmap[1];
396	/* ... SUPPAGE aRanges[1]; */
397	} MMPAGESUBPOOL;
398	/** Pointer to page sub pool. */
399	typedef MMPAGESUBPOOL *PMMPAGESUBPOOL;
400
401	/**
402	* Page pool.
403	*/
404	typedef struct MMPAGEPOOL
405	{
406	/** List of subpools. */
407	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
408	R3PTRTYPE(PMMPAGESUBPOOL) pHead;
409	#else
410	R3R0PTRTYPE(PMMPAGESUBPOOL) pHead;
411	#endif
412	/** Head of subpools with free pages. */
413	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
414	R3PTRTYPE(PMMPAGESUBPOOL) pHeadFree;
415	#else
416	R3R0PTRTYPE(PMMPAGESUBPOOL) pHeadFree;
417	#endif
418	/** AVLPV tree for looking up HC virtual addresses.
419	* The tree contains MMLOOKUPVIRTPP records.
420	*/
421	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
422	R3PTRTYPE(PAVLPVNODECORE) pLookupVirt;
423	#else
424	R3R0PTRTYPE(PAVLPVNODECORE) pLookupVirt;
425	#endif
426	/** Tree for looking up HC physical addresses.
427	* The tree contains MMLOOKUPPHYSHC records.
428	*/
429	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
430	R3PTRTYPE(AVLHCPHYSTREE) pLookupPhys;
431	#else
432	R3R0PTRTYPE(AVLHCPHYSTREE) pLookupPhys;
433	#endif
434	/** Pointer to the VM this pool belongs. */
435	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
436	PVMR3 pVM;
437	#else
438	R3R0PTRTYPE(PVM) pVM;
439	#endif
440	/** Flag indicating the allocation method.
441	* Set: SUPLowAlloc().
442	* Clear: SUPPageAlloc() + SUPPageLock(). */
443	bool fLow;
444	/** Number of subpools. */
445	uint32_t cSubPools;
446	/** Number of pages in pool. */
447	uint32_t cPages;
448	#ifdef VBOX_WITH_STATISTICS
449	/** Number of free pages in pool. */
450	uint32_t cFreePages;
451	/** Number of alloc calls. */
452	STAMCOUNTER cAllocCalls;
453	/** Number of free calls. */
454	STAMCOUNTER cFreeCalls;
455	/** Number of to phys conversions. */
456	STAMCOUNTER cToPhysCalls;
457	/** Number of to virtual conversions. */
458	STAMCOUNTER cToVirtCalls;
459	/** Number of real errors. */
460	STAMCOUNTER cErrors;
461	#endif
462	} MMPAGEPOOL;
463	/** Pointer to page pool. */
464	typedef MMPAGEPOOL *PMMPAGEPOOL;
465
466	/**
467	* Lookup record for HC virtual memory in the page pool.
468	*/
469	typedef struct MMPPLOOKUPHCPTR
470	{
471	/** The key is virtual address. */
472	AVLPVNODECORE Core;
473	/** Pointer to subpool if lookup record for a pool. */
474	struct MMPAGESUBPOOL *pSubPool;
475	} MMPPLOOKUPHCPTR;
476	/** Pointer to virtual memory lookup record. */
477	typedef MMPPLOOKUPHCPTR *PMMPPLOOKUPHCPTR;
478
479	/**
480	* Lookup record for HC physical memory.
481	*/
482	typedef struct MMPPLOOKUPHCPHYS
483	{
484	/** The key is physical address. */
485	AVLHCPHYSNODECORE Core;
486	/** Pointer to SUPPAGE record for this physical address. */
487	PSUPPAGE pPhysPage;
488	} MMPPLOOKUPHCPHYS;
489	/** Pointer to physical memory lookup record. */
490	typedef MMPPLOOKUPHCPHYS *PMMPPLOOKUPHCPHYS;
491
492	/** @} */
493
494
495
496	/**
497	* Type of memory that's locked.
498	*/
499	typedef enum MMLOCKEDTYPE
500	{
501	/** Hypervisor: Ring-3 memory locked by MM. */
502	MM_LOCKED_TYPE_HYPER,
503	/** Hypervisor: Ring-3 memory locked by MM that shouldn't be freed up. */
504	MM_LOCKED_TYPE_HYPER_NOFREE,
505	/** Hypervisor: Pre-locked ring-3 pages. */
506	MM_LOCKED_TYPE_HYPER_PAGES,
507	/** Guest: Physical VM memory (RAM & MMIO2). */
508	MM_LOCKED_TYPE_PHYS
509	} MMLOCKEDTYPE;
510	/** Pointer to memory type. */
511	typedef MMLOCKEDTYPE *PMMLOCKEDTYPE;
512
513
514	/**
515	* Converts a SUPPAGE pointer to a MMLOCKEDMEM pointer.
516	* @returns Pointer to the MMLOCKEDMEM record the range is associated with.
517	* @param pSupPage Pointer to SUPPAGE structure managed by MM.
518	*/
519	#define MM_SUPRANGE_TO_MMLOCKEDMEM(pSupPage) ((PMMLOCKEDMEM)pSupPage->uReserved)
520
521
522	/**
523	* Locked memory record.
524	*/
525	typedef struct MMLOCKEDMEM
526	{
527	/** Address (host mapping). */
528	void *pv;
529	/** Size. */
530	size_t cb;
531	/** Next record. */
532	struct MMLOCKEDMEM *pNext;
533	/** Record type. */
534	MMLOCKEDTYPE eType;
535	/** Type specific data. */
536	union
537	{
538	/** Data for MM_LOCKED_TYPE_HYPER, MM_LOCKED_TYPE_HYPER_NOFREE and MM_LOCKED_TYPE_HYPER_PAGES. */
539	struct
540	{
541	unsigned uNothing;
542	} hyper;
543
544	/** Data for MM_LOCKED_TYPE_PHYS. */
545	struct
546	{
547	/** The GC physical address.
548	* (Assuming that this is a linear range of GC physical pages.)
549	*/
550	RTGCPHYS GCPhys;
551	} phys;
552	} u;
553
554	/** Physical Page Array. (Variable length.)
555	* The uReserved field contains pointer to the MMLOCKMEM record.
556	* Use the macro MM_SUPPAGE_TO_MMLOCKEDMEM() to convert.
557	*
558	* For MM_LOCKED_TYPE_PHYS the low 12 bits of the pvPhys member
559	* are bits (MM_RAM_FLAGS_*) and not part of the physical address.
560	*/
561	SUPPAGE aPhysPages[1];
562	} MMLOCKEDMEM;
563	/** Pointer to locked memory. */
564	typedef MMLOCKEDMEM *PMMLOCKEDMEM;
565
566
567	/**
568	* A registered Rom range.
569	*
570	* This is used to track ROM registrations both for debug reasons
571	* and for resetting shadow ROM at reset.
572	*
573	* This is allocated of the MMR3Heap and thus only accessibel from ring-3.
574	*/
575	typedef struct MMROMRANGE
576	{
577	/** Pointer to the next */
578	struct MMROMRANGE *pNext;
579	/** Address of the range. */
580	RTGCPHYS GCPhys;
581	/** Size of the range. */
582	uint32_t cbRange;
583	/** Shadow ROM? */
584	bool fShadow;
585	/** Is the shadow ROM currently wriable? */
586	bool fWritable;
587	/** The address of the virgin ROM image for shadow ROM. */
588	const void *pvBinary;
589	/** The address of the guest RAM that's shadowing the ROM. (lazy bird) */
590	void *pvCopy;
591	/** The ROM description. */
592	const char *pszDesc;
593	} MMROMRANGE;
594	/** Pointer to a ROM range. */
595	typedef MMROMRANGE *PMMROMRANGE;
596
597
598	/**
599	* Hypervisor memory mapping type.
600	*/
601	typedef enum MMLOOKUPHYPERTYPE
602	{
603	/** Invalid record. This is used for record which are incomplete. */
604	MMLOOKUPHYPERTYPE_INVALID = 0,
605	/** Mapping of locked memory. */
606	MMLOOKUPHYPERTYPE_LOCKED,
607	/** Mapping of contiguous HC physical memory. */
608	MMLOOKUPHYPERTYPE_HCPHYS,
609	/** Mapping of contiguous GC physical memory. */
610	MMLOOKUPHYPERTYPE_GCPHYS,
611	/** Mapping of MMIO2 memory. */
612	MMLOOKUPHYPERTYPE_MMIO2,
613	/** Dynamic mapping area (MMR3HyperReserve).
614	* A conversion will require to check what's in the page table for the pages. */
615	MMLOOKUPHYPERTYPE_DYNAMIC
616	} MMLOOKUPHYPERTYPE;
617
618	/**
619	* Lookup record for the hypervisor memory area.
620	*/
621	typedef struct MMLOOKUPHYPER
622	{
623	/** Byte offset from the start of this record to the next.
624	* If the value is NIL_OFFSET the chain is terminated. */
625	int32_t offNext;
626	/** Offset into the hypvervisor memory area. */
627	uint32_t off;
628	/** Size of this part. */
629	uint32_t cb;
630	/** Locking type. */
631	MMLOOKUPHYPERTYPE enmType;
632	/** Type specific data */
633	union
634	{
635	/** Locked memory. */
636	struct
637	{
638	/** Host context ring-3 pointer. */
639	R3PTRTYPE(void *) pvR3;
640	/** Host context ring-0 pointer. Optional. */
641	RTR0PTR pvR0;
642	/** Pointer to the locked mem record. */
643	R3PTRTYPE(PMMLOCKEDMEM) pLockedMem;
644	} Locked;
645
646	/** Contiguous physical memory. */
647	struct
648	{
649	/** Host context ring-3 pointer. */
650	R3PTRTYPE(void *) pvR3;
651	/** Host context ring-0 pointer. Optional. */
652	RTR0PTR pvR0;
653	/** HC physical address corresponding to pvR3/pvR0. */
654	RTHCPHYS HCPhys;
655	} HCPhys;
656
657	/** Contiguous guest physical memory. */
658	struct
659	{
660	/** The memory address (Guest Context). */
661	RTGCPHYS GCPhys;
662	} GCPhys;
663
664	/** MMIO2 memory. */
665	struct
666	{
667	/** The device instance owning the MMIO2 region. */
668	PPDMDEVINSR3 pDevIns;
669	/** The region number. */
670	uint32_t iRegion;
671	/** The offset into the MMIO2 region. */
672	RTGCPHYS off;
673	} MMIO2;
674	} u;
675	/** Description. */
676	R3PTRTYPE(const char *) pszDesc;
677	} MMLOOKUPHYPER;
678	/** Pointer to a hypervisor memory lookup record. */
679	typedef MMLOOKUPHYPER *PMMLOOKUPHYPER;
680
681
682	/**
683	* Converts a MM pointer into a VM pointer.
684	* @returns Pointer to the VM structure the MM is part of.
685	* @param pMM Pointer to MM instance data.
686	*/
687	#define MM2VM(pMM) ( (PVM)((uint8_t *)pMM - pMM->offVM) )
688
689
690	/**
691	* MM Data (part of VM)
692	*/
693	typedef struct MM
694	{
695	/** Offset to the VM structure.
696	* See MM2VM(). */
697	RTINT offVM;
698
699	/** Set if MMR3InitPaging has been called. */
700	bool fDoneMMR3InitPaging;
701	/** Set if PGM has been initialized and we can safely call PGMR3Map(). */
702	bool fPGMInitialized;
703	#if GC_ARCH_BITS == 64 \|\| HC_ARCH_BITS == 64
704	uint32_t u32Padding1; /*< alignment padding. /
705	#endif
706
707	/** Lookup list for the Hypervisor Memory Area.
708	* The offset is relative to the start of the heap.
709	* Use pHyperHeapR3, pHyperHeapR0 or pHypeRHeapRC to calculate the address.
710	*/
711	RTUINT offLookupHyper;
712
713	/** The offset of the next static mapping in the Hypervisor Memory Area. */
714	RTUINT offHyperNextStatic;
715	/** The size of the HMA.
716	* Starts at 12MB and will be fixed late in the init process. */
717	RTUINT cbHyperArea;
718
719	/** Guest address of the Hypervisor Memory Area.
720	* @remarks It's still a bit open whether this should be change to RTRCPTR or
721	* remain a RTGCPTR. */
722	RTGCPTR pvHyperAreaGC;
723
724	/** The hypervisor heap (GC Ptr). */
725	RCPTRTYPE(PMMHYPERHEAP) pHyperHeapRC;
726	#if HC_ARCH_BITS == 64 && GC_ARCH_BITS == 64
727	uint32_t u32Padding2;
728	#endif
729
730	/** The hypervisor heap (R0 Ptr). */
731	R0PTRTYPE(PMMHYPERHEAP) pHyperHeapR0;
732	#ifndef VBOX_WITH_2X_4GB_ADDR_SPACE
733	/** Page pool - R0 Ptr. */
734	R0PTRTYPE(PMMPAGEPOOL) pPagePoolR0;
735	/** Page pool pages in low memory R0 Ptr. */
736	R0PTRTYPE(PMMPAGEPOOL) pPagePoolLowR0;
737	#endif /* !VBOX_WITH_2X_4GB_ADDR_SPACE */
738
739	/** The hypervisor heap (R3 Ptr). */
740	R3PTRTYPE(PMMHYPERHEAP) pHyperHeapR3;
741	/** Page pool - R3 Ptr. */
742	R3PTRTYPE(PMMPAGEPOOL) pPagePoolR3;
743	/** Page pool pages in low memory R3 Ptr. */
744	R3PTRTYPE(PMMPAGEPOOL) pPagePoolLowR3;
745	/** List of memory locks. (HC only) */
746	R3PTRTYPE(PMMLOCKEDMEM) pLockedMem;
747
748	/** Pointer to the dummy page.
749	* The dummy page is a paranoia thingy used for instance for pure MMIO RAM ranges
750	* to make sure any bugs will not harm whatever the system stores in the first
751	* physical page. */
752	R3PTRTYPE(void *) pvDummyPage;
753	/** Physical address of the dummy page. */
754	RTHCPHYS HCPhysDummyPage;
755
756	/** Size of the base RAM in bytes. (The CFGM RamSize value.) */
757	uint64_t cbRamBase;
758	/** The number of base RAM pages that PGM has reserved (GMM).
759	* @remarks Shadow ROMs will be counted twice (RAM+ROM), so it won't be 1:1 with
760	* what the guest sees. */
761	uint64_t cBasePages;
762	/** The number of shadow pages PGM has reserved (GMM). */
763	uint32_t cShadowPages;
764	/** The number of fixed pages we've reserved (GMM). */
765	uint32_t cFixedPages;
766
767	/** The head of the ROM ranges. */
768	R3PTRTYPE(PMMROMRANGE) pRomHead;
769	} MM;
770	/** Pointer to MM Data (part of VM). */
771	typedef MM *PMM;
772
773
774	/**
775	* MM data kept in the UVM.
776	*/
777	typedef struct MMUSERPERVM
778	{
779	/** Pointer to the MM R3 Heap. */
780	R3PTRTYPE(PMMHEAP) pHeap;
781	} MMUSERPERVM;
782	/** Pointer to the MM data kept in the UVM. */
783	typedef MMUSERPERVM *PMMUSERPERVM;
784
785
786	__BEGIN_DECLS
787
788
789	int mmR3UpdateReservation(PVM pVM);
790
791	int mmR3PagePoolInit(PVM pVM);
792	void mmR3PagePoolTerm(PVM pVM);
793
794	int mmR3HeapCreateU(PUVM pUVM, PMMHEAP *ppHeap);
795	void mmR3HeapDestroy(PMMHEAP pHeap);
796
797	int mmR3HyperInit(PVM pVM);
798	int mmR3HyperInitPaging(PVM pVM);
799
800	int mmR3LockMem(PVM pVM, void pv, size_t cb, MMLOCKEDTYPE eType, PMMLOCKEDMEM ppLockedMem, bool fSilentFailure);
801	int mmR3MapLocked(PVM pVM, PMMLOCKEDMEM pLockedMem, RTGCPTR Addr, unsigned iPage, size_t cPages, unsigned fFlags);
802
803	const char *mmR3GetTagName(MMTAG enmTag);
804
805	void mmR3PhysRomReset(PVM pVM);
806
807	/**
808	* Converts a pool address to a physical address.
809	* The specified allocation type must match with the address.
810	*
811	* @returns Physical address.
812	* @returns NIL_RTHCPHYS if not found or eType is not matching.
813	* @param pPool Pointer to the page pool.
814	* @param pv The address to convert.
815	* @thread The Emulation Thread.
816	*/
817	RTHCPHYS mmPagePoolPtr2Phys(PMMPAGEPOOL pPool, void *pv);
818
819	/**
820	* Converts a pool physical address to a linear address.
821	* The specified allocation type must match with the address.
822	*
823	* @returns Physical address.
824	* @returns NULL if not found or eType is not matching.
825	* @param pPool Pointer to the page pool.
826	* @param HCPhys The address to convert.
827	* @thread The Emulation Thread.
828	*/
829	void *mmPagePoolPhys2Ptr(PMMPAGEPOOL pPool, RTHCPHYS HCPhys);
830
831	__END_DECLS
832
833	/** @} */
834
835	#endif
836

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

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

Download in other formats: