MMInternal.h@ 19844

Last change on this file since 19844 was 19665, checked in by vboxsync, 16 years ago
Attempt at fixing alignment issues
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 25.8 KB

Line
1	/* $Id: MMInternal.h 19665 2009-05-13 15:17:32Z 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 <VBox/pdmcritsect.h>
30	#include <iprt/avl.h>
31	#include <iprt/critsect.h>
32
33
34
35	/** @defgroup grp_mm_int Internals
36	* @internal
37	* @ingroup grp_mm
38	* @{
39	*/
40
41
42	/** @name MMR3Heap - VM Ring-3 Heap Internals
43	* @{
44	*/
45
46	/** @def MMR3HEAP_SIZE_ALIGNMENT
47	* The allocation size alignment of the MMR3Heap.
48	*/
49	#define MMR3HEAP_SIZE_ALIGNMENT 16
50
51	/** @def MMR3HEAP_WITH_STATISTICS
52	* Enable MMR3Heap statistics.
53	*/
54	#if !defined(MMR3HEAP_WITH_STATISTICS) && defined(VBOX_WITH_STATISTICS)
55	# define MMR3HEAP_WITH_STATISTICS
56	#endif
57
58	/**
59	* Heap statistics record.
60	* There is one global and one per allocation tag.
61	*/
62	typedef struct MMHEAPSTAT
63	{
64	/** Core avl node, key is the tag. */
65	AVLULNODECORE Core;
66	/** Pointer to the heap the memory belongs to. */
67	struct MMHEAP *pHeap;
68	#ifdef MMR3HEAP_WITH_STATISTICS
69	/** Number of allocation. */
70	uint64_t cAllocations;
71	/** Number of reallocations. */
72	uint64_t cReallocations;
73	/** Number of frees. */
74	uint64_t cFrees;
75	/** Failures. */
76	uint64_t cFailures;
77	/** Number of bytes allocated (sum). */
78	uint64_t cbAllocated;
79	/** Number of bytes freed. */
80	uint64_t cbFreed;
81	/** Number of bytes currently allocated. */
82	size_t cbCurAllocated;
83	#endif
84	} MMHEAPSTAT;
85	/** Pointer to heap statistics record. */
86	typedef MMHEAPSTAT *PMMHEAPSTAT;
87
88
89
90	/**
91	* Additional heap block header for relating allocations to the VM.
92	*/
93	typedef struct MMHEAPHDR
94	{
95	/** Pointer to the next record. */
96	struct MMHEAPHDR *pNext;
97	/** Pointer to the previous record. */
98	struct MMHEAPHDR *pPrev;
99	/** Pointer to the heap statistics record.
100	* (Where the a PVM can be found.) */
101	PMMHEAPSTAT pStat;
102	/** Size of the allocation (including this header). */
103	size_t cbSize;
104	} MMHEAPHDR;
105	/** Pointer to MM heap header. */
106	typedef MMHEAPHDR *PMMHEAPHDR;
107
108
109	/** MM Heap structure. */
110	typedef struct MMHEAP
111	{
112	/** Lock protecting the heap. */
113	RTCRITSECT Lock;
114	/** Heap block list head. */
115	PMMHEAPHDR pHead;
116	/** Heap block list tail. */
117	PMMHEAPHDR pTail;
118	/** Heap per tag statistics tree. */
119	PAVLULNODECORE pStatTree;
120	/** The VM handle. */
121	PUVM pUVM;
122	/** Heap global statistics. */
123	MMHEAPSTAT Stat;
124	} MMHEAP;
125	/** Pointer to MM Heap structure. */
126	typedef MMHEAP *PMMHEAP;
127
128	/** @} */
129
130
131	/** @name MMUkHeap - VM User-kernel Heap Internals
132	* @{
133	*/
134
135	/** @def MMUKHEAP_SIZE_ALIGNMENT
136	* The allocation size alignment of the MMR3UkHeap.
137	*/
138	#define MMUKHEAP_SIZE_ALIGNMENT 16
139
140	/** @def MMUKHEAP_WITH_STATISTICS
141	* Enable MMUkHeap statistics.
142	*/
143	#if !defined(MMUKHEAP_WITH_STATISTICS) && defined(VBOX_WITH_STATISTICS)
144	# define MMUKHEAP_WITH_STATISTICS
145	#endif
146
147
148	/**
149	* Heap statistics record.
150	* There is one global and one per allocation tag.
151	*/
152	typedef struct MMUKHEAPSTAT
153	{
154	/** Core avl node, key is the tag. */
155	AVLULNODECORE Core;
156	/** Number of allocation. */
157	uint64_t cAllocations;
158	/** Number of reallocations. */
159	uint64_t cReallocations;
160	/** Number of frees. */
161	uint64_t cFrees;
162	/** Failures. */
163	uint64_t cFailures;
164	/** Number of bytes allocated (sum). */
165	uint64_t cbAllocated;
166	/** Number of bytes freed. */
167	uint64_t cbFreed;
168	/** Number of bytes currently allocated. */
169	size_t cbCurAllocated;
170	} MMUKHEAPSTAT;
171	/** Pointer to heap statistics record. */
172	typedef MMUKHEAPSTAT *PMMUKHEAPSTAT;
173
174	/**
175	* Sub heap tracking record.
176	*/
177	typedef struct MMUKHEAPSUB
178	{
179	/** Pointer to the next sub-heap. */
180	struct MMUKHEAPSUB *pNext;
181	/** The base address of the sub-heap. */
182	void *pv;
183	/** The size of the sub-heap. */
184	size_t cb;
185	/** The handle of the simple block pointer. */
186	RTHEAPSIMPLE hSimple;
187	/** The ring-0 address corresponding to MMUKHEAPSUB::pv. */
188	RTR0PTR pvR0;
189	} MMUKHEAPSUB;
190	/** Pointer to a sub-heap tracking record. */
191	typedef MMUKHEAPSUB *PMMUKHEAPSUB;
192
193
194	/** MM User-kernel Heap structure. */
195	typedef struct MMUKHEAP
196	{
197	/** Lock protecting the heap. */
198	RTCRITSECT Lock;
199	/** Head of the sub-heap LIFO. */
200	PMMUKHEAPSUB pSubHeapHead;
201	/** Heap per tag statistics tree. */
202	PAVLULNODECORE pStatTree;
203	/** The VM handle. */
204	PUVM pUVM;
205	/** Heap global statistics. */
206	MMUKHEAPSTAT Stat;
207	} MMUKHEAP;
208	/** Pointer to MM Heap structure. */
209	typedef MMUKHEAP *PMMUKHEAP;
210
211	/** @} */
212
213
214
215	/** @name Hypervisor Heap Internals
216	* @{
217	*/
218
219	/** @def MMHYPER_HEAP_FREE_DELAY
220	* If defined, it indicates the number of frees that should be delayed.
221	*/
222	#if defined(DOXYGEN_RUNNING)
223	# define MMHYPER_HEAP_FREE_DELAY 64
224	#endif
225
226	/** @def MMHYPER_HEAP_FREE_POISON
227	* If defined, it indicates that freed memory should be poisoned
228	* with the value it has.
229	*/
230	#if defined(VBOX_STRICT) \|\| defined(DOXYGEN_RUNNING)
231	# define MMHYPER_HEAP_FREE_POISON 0xcb
232	#endif
233
234	/** @def MMHYPER_HEAP_STRICT
235	* Enables a bunch of assertions in the heap code. */
236	#if defined(VBOX_STRICT) \|\| defined(DOXYGEN_RUNNING)
237	# define MMHYPER_HEAP_STRICT 1
238	# if 0 \|\| defined(DOXYGEN_RUNNING)
239	/** @def MMHYPER_HEAP_STRICT_FENCE
240	* Enables tail fence. */
241	# define MMHYPER_HEAP_STRICT_FENCE
242	/** @def MMHYPER_HEAP_STRICT_FENCE_SIZE
243	* The fence size in bytes. */
244	# define MMHYPER_HEAP_STRICT_FENCE_SIZE 256
245	/** @def MMHYPER_HEAP_STRICT_FENCE_U32
246	* The fence filler. */
247	# define MMHYPER_HEAP_STRICT_FENCE_U32 UINT32_C(0xdeadbeef)
248	# endif
249	#endif
250
251	/**
252	* Hypervisor heap statistics record.
253	* There is one global and one per allocation tag.
254	*/
255	typedef struct MMHYPERSTAT
256	{
257	/** Core avl node, key is the tag.
258	* @todo The type is wrong! Get your lazy a$$ over and create that offsetted uint32_t version we need here! */
259	AVLOGCPHYSNODECORE Core;
260	/** Aligning the 64-bit fields on a 64-bit line. */
261	uint32_t u32Padding0;
262	/** Indicator for whether these statistics are registered with STAM or not. */
263	bool fRegistered;
264	/** Number of allocation. */
265	uint64_t cAllocations;
266	/** Number of frees. */
267	uint64_t cFrees;
268	/** Failures. */
269	uint64_t cFailures;
270	/** Number of bytes allocated (sum). */
271	uint64_t cbAllocated;
272	/** Number of bytes freed (sum). */
273	uint64_t cbFreed;
274	/** Number of bytes currently allocated. */
275	uint32_t cbCurAllocated;
276	/** Max number of bytes allocated. */
277	uint32_t cbMaxAllocated;
278	} MMHYPERSTAT;
279	/** Pointer to hypervisor heap statistics record. */
280	typedef MMHYPERSTAT *PMMHYPERSTAT;
281
282	/**
283	* Hypervisor heap chunk.
284	*/
285	typedef struct MMHYPERCHUNK
286	{
287	/** Previous block in the list of all blocks.
288	* This is relative to the start of the heap. */
289	uint32_t offNext;
290	/** Offset to the previous block relative to this one. */
291	int32_t offPrev;
292	/** The statistics record this allocation belongs to (self relative). */
293	int32_t offStat;
294	/** Offset to the heap block (self relative). */
295	int32_t offHeap;
296	} MMHYPERCHUNK;
297	/** Pointer to a hypervisor heap chunk. */
298	typedef MMHYPERCHUNK *PMMHYPERCHUNK;
299
300
301	/**
302	* Hypervisor heap chunk.
303	*/
304	typedef struct MMHYPERCHUNKFREE
305	{
306	/** Main list. */
307	MMHYPERCHUNK core;
308	/** Offset of the next chunk in the list of free nodes. */
309	uint32_t offNext;
310	/** Offset of the previous chunk in the list of free nodes. */
311	int32_t offPrev;
312	/** Size of the block. */
313	uint32_t cb;
314	} MMHYPERCHUNKFREE;
315	/** Pointer to a free hypervisor heap chunk. */
316	typedef MMHYPERCHUNKFREE *PMMHYPERCHUNKFREE;
317
318
319	/**
320	* The hypervisor heap.
321	*/
322	typedef struct MMHYPERHEAP
323	{
324	/** The typical magic (MMHYPERHEAP_MAGIC). */
325	uint32_t u32Magic;
326	/** The heap size. (This structure is not included!) */
327	uint32_t cbHeap;
328	/** Lock protecting the heap. */
329	PDMCRITSECT Lock;
330	/** The HC ring-3 address of the heap. */
331	R3PTRTYPE(uint8_t *) pbHeapR3;
332	/** The HC ring-3 address of the shared VM strcture. */
333	PVMR3 pVMR3;
334	/** The HC ring-0 address of the heap. */
335	R0PTRTYPE(uint8_t *) pbHeapR0;
336	/** The HC ring-0 address of the shared VM strcture. */
337	PVMR0 pVMR0;
338	/** The RC address of the heap. */
339	RCPTRTYPE(uint8_t *) pbHeapRC;
340	/** The RC address of the shared VM strcture. */
341	PVMRC pVMRC;
342	/** The amount of free memory in the heap. */
343	uint32_t cbFree;
344	/** Offset of the first free chunk in the heap.
345	* The offset is relative to the start of the heap. */
346	uint32_t offFreeHead;
347	/** Offset of the last free chunk in the heap.
348	* The offset is relative to the start of the heap. */
349	uint32_t offFreeTail;
350	/** Offset of the first page aligned block in the heap.
351	* The offset is equal to cbHeap initially. */
352	uint32_t offPageAligned;
353	/** Tree of hypervisor heap statistics. */
354	AVLOGCPHYSTREE HyperHeapStatTree;
355	#ifdef MMHYPER_HEAP_FREE_DELAY
356	/** Where to insert the next free. */
357	uint32_t iDelayedFree;
358	/** Array of delayed frees. Circular. Offsets relative to this structure. */
359	struct
360	{
361	/** The free caller address. */
362	RTUINTPTR uCaller;
363	/** The offset of the freed chunk. */
364	uint32_t offChunk;
365	} aDelayedFrees[MMHYPER_HEAP_FREE_DELAY];
366	#else
367	/** Padding the structure to a 64-bit aligned size. */
368	uint32_t u32Padding0;
369	#endif
370	/** The heap physical pages. */
371	R3PTRTYPE(PSUPPAGE) paPages;
372	#if HC_ARCH_BITS == 32
373	/** Padding the structure to a 64-bit aligned size. */
374	uint32_t u32Padding1;
375	#endif
376	} MMHYPERHEAP;
377	/** Pointer to the hypervisor heap. */
378	typedef MMHYPERHEAP *PMMHYPERHEAP;
379
380	/** Magic value for MMHYPERHEAP. (C. S. Lewis) */
381	#define MMHYPERHEAP_MAGIC UINT32_C(0x18981129)
382
383
384	/**
385	* Hypervisor heap minimum alignment (16 bytes).
386	*/
387	#define MMHYPER_HEAP_ALIGN_MIN 16
388
389	/**
390	* The aligned size of the the MMHYPERHEAP structure.
391	*/
392	#define MMYPERHEAP_HDR_SIZE RT_ALIGN_Z(sizeof(MMHYPERHEAP), MMHYPER_HEAP_ALIGN_MIN * 4)
393
394	/** @name Hypervisor heap chunk flags.
395	* The flags are put in the first bits of the MMHYPERCHUNK::offPrev member.
396	* These bits aren't used anyway because of the chunk minimal alignment (16 bytes).
397	* @{ */
398	/** The chunk is free. (The code ASSUMES this is 0!) */
399	#define MMHYPERCHUNK_FLAGS_FREE 0x0
400	/** The chunk is in use. */
401	#define MMHYPERCHUNK_FLAGS_USED 0x1
402	/** The type mask. */
403	#define MMHYPERCHUNK_FLAGS_TYPE_MASK 0x1
404	/** The flag mask */
405	#define MMHYPERCHUNK_FLAGS_MASK 0x1
406
407	/** Checks if the chunk is free. */
408	#define MMHYPERCHUNK_ISFREE(pChunk) ( (((pChunk)->offPrev) & MMHYPERCHUNK_FLAGS_TYPE_MASK) == MMHYPERCHUNK_FLAGS_FREE )
409	/** Checks if the chunk is used. */
410	#define MMHYPERCHUNK_ISUSED(pChunk) ( (((pChunk)->offPrev) & MMHYPERCHUNK_FLAGS_TYPE_MASK) == MMHYPERCHUNK_FLAGS_USED )
411	/** Toggles FREE/USED flag of a chunk. */
412	#define MMHYPERCHUNK_SET_TYPE(pChunk, type) do { (pChunk)->offPrev = ((pChunk)->offPrev & ~MMHYPERCHUNK_FLAGS_TYPE_MASK) \| ((type) & MMHYPERCHUNK_FLAGS_TYPE_MASK); } while (0)
413
414	/** Gets the prev offset without the flags. */
415	#define MMHYPERCHUNK_GET_OFFPREV(pChunk) ((int32_t)((pChunk)->offPrev & ~MMHYPERCHUNK_FLAGS_MASK))
416	/** Sets the prev offset without changing the flags. */
417	#define MMHYPERCHUNK_SET_OFFPREV(pChunk, off) do { (pChunk)->offPrev = (off) \| ((pChunk)->offPrev & MMHYPERCHUNK_FLAGS_MASK); } while (0)
418	#if 0
419	/** Clears one or more flags. */
420	#define MMHYPERCHUNK_FLAGS_OP_CLEAR(pChunk, fFlags) do { ((pChunk)->offPrev) &= ~((fFlags) & MMHYPERCHUNK_FLAGS_MASK); } while (0)
421	/** Sets one or more flags. */
422	#define MMHYPERCHUNK_FLAGS_OP_SET(pChunk, fFlags) do { ((pChunk)->offPrev) \|= ((fFlags) & MMHYPERCHUNK_FLAGS_MASK); } while (0)
423	/** Checks if one is set. */
424	#define MMHYPERCHUNK_FLAGS_OP_ISSET(pChunk, fFlag) (!!(((pChunk)->offPrev) & ((fFlag) & MMHYPERCHUNK_FLAGS_MASK)))
425	#endif
426	/** @} */
427
428	/** @} */
429
430
431	/** @name Page Pool Internals
432	* @{
433	*/
434
435	/**
436	* Page sub pool
437	*
438	* About the allocation of this structure. To keep the number of heap blocks,
439	* the number of heap calls, and fragmentation low we allocate all the data
440	* related to a MMPAGESUBPOOL node in one chunk. That means that after the
441	* bitmap (which is of variable size) comes the SUPPAGE records and then
442	* follows the lookup tree nodes. (The heap in question is the hyper heap.)
443	*/
444	typedef struct MMPAGESUBPOOL
445	{
446	/** Pointer to next sub pool. */
447	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
448	R3PTRTYPE(struct MMPAGESUBPOOL *) pNext;
449	#else
450	R3R0PTRTYPE(struct MMPAGESUBPOOL *) pNext;
451	#endif
452	/** Pointer to next sub pool in the free chain.
453	* This is NULL if we're not in the free chain or at the end of it. */
454	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
455	R3PTRTYPE(struct MMPAGESUBPOOL *) pNextFree;
456	#else
457	R3R0PTRTYPE(struct MMPAGESUBPOOL *) pNextFree;
458	#endif
459	/** Pointer to array of lock ranges.
460	* This is allocated together with the MMPAGESUBPOOL and thus needs no freeing.
461	* It follows immediately after the bitmap.
462	* The reserved field is a pointer to this structure.
463	*/
464	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
465	R3PTRTYPE(PSUPPAGE) paPhysPages;
466	#else
467	R3R0PTRTYPE(PSUPPAGE) paPhysPages;
468	#endif
469	/** Pointer to the first page. */
470	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
471	R3PTRTYPE(void *) pvPages;
472	#else
473	R3R0PTRTYPE(void *) pvPages;
474	#endif
475	/** Size of the subpool. */
476	uint32_t cPages;
477	/** Number of free pages. */
478	uint32_t cPagesFree;
479	/** The allocation bitmap.
480	* This may extend beyond the end of the defined array size.
481	*/
482	uint32_t auBitmap[1];
483	/* ... SUPPAGE aRanges[1]; */
484	} MMPAGESUBPOOL;
485	/** Pointer to page sub pool. */
486	typedef MMPAGESUBPOOL *PMMPAGESUBPOOL;
487
488	/**
489	* Page pool.
490	*/
491	typedef struct MMPAGEPOOL
492	{
493	/** List of subpools. */
494	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
495	R3PTRTYPE(PMMPAGESUBPOOL) pHead;
496	#else
497	R3R0PTRTYPE(PMMPAGESUBPOOL) pHead;
498	#endif
499	/** Head of subpools with free pages. */
500	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
501	R3PTRTYPE(PMMPAGESUBPOOL) pHeadFree;
502	#else
503	R3R0PTRTYPE(PMMPAGESUBPOOL) pHeadFree;
504	#endif
505	/** AVLPV tree for looking up HC virtual addresses.
506	* The tree contains MMLOOKUPVIRTPP records.
507	*/
508	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
509	R3PTRTYPE(PAVLPVNODECORE) pLookupVirt;
510	#else
511	R3R0PTRTYPE(PAVLPVNODECORE) pLookupVirt;
512	#endif
513	/** Tree for looking up HC physical addresses.
514	* The tree contains MMLOOKUPPHYSHC records.
515	*/
516	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
517	R3PTRTYPE(AVLHCPHYSTREE) pLookupPhys;
518	#else
519	R3R0PTRTYPE(AVLHCPHYSTREE) pLookupPhys;
520	#endif
521	/** Pointer to the VM this pool belongs. */
522	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
523	PVMR3 pVM;
524	#else
525	R3R0PTRTYPE(PVM) pVM;
526	#endif
527	/** Flag indicating the allocation method.
528	* Set: SUPLowAlloc().
529	* Clear: SUPPageAlloc() + SUPPageLock(). */
530	bool fLow;
531	/** Number of subpools. */
532	uint32_t cSubPools;
533	/** Number of pages in pool. */
534	uint32_t cPages;
535	#ifdef VBOX_WITH_STATISTICS
536	/** Number of free pages in pool. */
537	uint32_t cFreePages;
538	/** Number of alloc calls. */
539	STAMCOUNTER cAllocCalls;
540	/** Number of free calls. */
541	STAMCOUNTER cFreeCalls;
542	/** Number of to phys conversions. */
543	STAMCOUNTER cToPhysCalls;
544	/** Number of to virtual conversions. */
545	STAMCOUNTER cToVirtCalls;
546	/** Number of real errors. */
547	STAMCOUNTER cErrors;
548	#endif
549	} MMPAGEPOOL;
550	/** Pointer to page pool. */
551	typedef MMPAGEPOOL *PMMPAGEPOOL;
552
553	/**
554	* Lookup record for HC virtual memory in the page pool.
555	*/
556	typedef struct MMPPLOOKUPHCPTR
557	{
558	/** The key is virtual address. */
559	AVLPVNODECORE Core;
560	/** Pointer to subpool if lookup record for a pool. */
561	struct MMPAGESUBPOOL *pSubPool;
562	} MMPPLOOKUPHCPTR;
563	/** Pointer to virtual memory lookup record. */
564	typedef MMPPLOOKUPHCPTR *PMMPPLOOKUPHCPTR;
565
566	/**
567	* Lookup record for HC physical memory.
568	*/
569	typedef struct MMPPLOOKUPHCPHYS
570	{
571	/** The key is physical address. */
572	AVLHCPHYSNODECORE Core;
573	/** Pointer to SUPPAGE record for this physical address. */
574	PSUPPAGE pPhysPage;
575	} MMPPLOOKUPHCPHYS;
576	/** Pointer to physical memory lookup record. */
577	typedef MMPPLOOKUPHCPHYS *PMMPPLOOKUPHCPHYS;
578
579	/** @} */
580
581
582	/**
583	* Hypervisor memory mapping type.
584	*/
585	typedef enum MMLOOKUPHYPERTYPE
586	{
587	/** Invalid record. This is used for record which are incomplete. */
588	MMLOOKUPHYPERTYPE_INVALID = 0,
589	/** Mapping of locked memory. */
590	MMLOOKUPHYPERTYPE_LOCKED,
591	/** Mapping of contiguous HC physical memory. */
592	MMLOOKUPHYPERTYPE_HCPHYS,
593	/** Mapping of contiguous GC physical memory. */
594	MMLOOKUPHYPERTYPE_GCPHYS,
595	/** Mapping of MMIO2 memory. */
596	MMLOOKUPHYPERTYPE_MMIO2,
597	/** Dynamic mapping area (MMR3HyperReserve).
598	* A conversion will require to check what's in the page table for the pages. */
599	MMLOOKUPHYPERTYPE_DYNAMIC
600	} MMLOOKUPHYPERTYPE;
601
602	/**
603	* Lookup record for the hypervisor memory area.
604	*/
605	typedef struct MMLOOKUPHYPER
606	{
607	/** Byte offset from the start of this record to the next.
608	* If the value is NIL_OFFSET the chain is terminated. */
609	int32_t offNext;
610	/** Offset into the hypvervisor memory area. */
611	uint32_t off;
612	/** Size of this part. */
613	uint32_t cb;
614	/** Locking type. */
615	MMLOOKUPHYPERTYPE enmType;
616	/** Type specific data */
617	union
618	{
619	/** Locked memory. */
620	struct
621	{
622	/** Host context ring-3 pointer. */
623	R3PTRTYPE(void *) pvR3;
624	/** Host context ring-0 pointer. Optional. */
625	RTR0PTR pvR0;
626	/** Pointer to an array containing the physical address of each page. */
627	R3PTRTYPE(PRTHCPHYS) paHCPhysPages;
628	} Locked;
629
630	/** Contiguous physical memory. */
631	struct
632	{
633	/** Host context ring-3 pointer. */
634	R3PTRTYPE(void *) pvR3;
635	/** Host context ring-0 pointer. Optional. */
636	RTR0PTR pvR0;
637	/** HC physical address corresponding to pvR3/pvR0. */
638	RTHCPHYS HCPhys;
639	} HCPhys;
640
641	/** Contiguous guest physical memory. */
642	struct
643	{
644	/** The memory address (Guest Context). */
645	RTGCPHYS GCPhys;
646	} GCPhys;
647
648	/** MMIO2 memory. */
649	struct
650	{
651	/** The device instance owning the MMIO2 region. */
652	PPDMDEVINSR3 pDevIns;
653	/** The region number. */
654	uint32_t iRegion;
655	/** The offset into the MMIO2 region. */
656	RTGCPHYS off;
657	} MMIO2;
658	} u;
659	/** Description. */
660	R3PTRTYPE(const char *) pszDesc;
661	} MMLOOKUPHYPER;
662	/** Pointer to a hypervisor memory lookup record. */
663	typedef MMLOOKUPHYPER *PMMLOOKUPHYPER;
664
665
666	/**
667	* Converts a MM pointer into a VM pointer.
668	* @returns Pointer to the VM structure the MM is part of.
669	* @param pMM Pointer to MM instance data.
670	*/
671	#define MM2VM(pMM) ( (PVM)((uint8_t *)pMM - pMM->offVM) )
672
673
674	/**
675	* MM Data (part of VM)
676	*/
677	typedef struct MM
678	{
679	/** Offset to the VM structure.
680	* See MM2VM(). */
681	RTINT offVM;
682
683	/** Set if MMR3InitPaging has been called. */
684	bool fDoneMMR3InitPaging;
685	/** Set if PGM has been initialized and we can safely call PGMR3Map(). */
686	bool fPGMInitialized;
687	#if GC_ARCH_BITS == 64 \|\| HC_ARCH_BITS == 64
688	uint32_t u32Padding1; /*< alignment padding. /
689	#endif
690
691	/** Lookup list for the Hypervisor Memory Area.
692	* The offset is relative to the start of the heap.
693	* Use pHyperHeapR3, pHyperHeapR0 or pHypeRHeapRC to calculate the address.
694	*/
695	RTUINT offLookupHyper;
696
697	/** The offset of the next static mapping in the Hypervisor Memory Area. */
698	RTUINT offHyperNextStatic;
699	/** The size of the HMA.
700	* Starts at 12MB and will be fixed late in the init process. */
701	RTUINT cbHyperArea;
702
703	/** Guest address of the Hypervisor Memory Area.
704	* @remarks It's still a bit open whether this should be change to RTRCPTR or
705	* remain a RTGCPTR. */
706	RTGCPTR pvHyperAreaGC;
707
708	/** The hypervisor heap (GC Ptr). */
709	RCPTRTYPE(PMMHYPERHEAP) pHyperHeapRC;
710	#if HC_ARCH_BITS == 64 && GC_ARCH_BITS == 64
711	uint32_t u32Padding2;
712	#endif
713
714	/** The hypervisor heap (R0 Ptr). */
715	R0PTRTYPE(PMMHYPERHEAP) pHyperHeapR0;
716	#ifndef VBOX_WITH_2X_4GB_ADDR_SPACE
717	/** Page pool - R0 Ptr. */
718	R0PTRTYPE(PMMPAGEPOOL) pPagePoolR0;
719	/** Page pool pages in low memory R0 Ptr. */
720	R0PTRTYPE(PMMPAGEPOOL) pPagePoolLowR0;
721	#endif /* !VBOX_WITH_2X_4GB_ADDR_SPACE */
722
723	/** The hypervisor heap (R3 Ptr). */
724	R3PTRTYPE(PMMHYPERHEAP) pHyperHeapR3;
725	/** Page pool - R3 Ptr. */
726	R3PTRTYPE(PMMPAGEPOOL) pPagePoolR3;
727	/** Page pool pages in low memory R3 Ptr. */
728	R3PTRTYPE(PMMPAGEPOOL) pPagePoolLowR3;
729
730	/** Pointer to the dummy page.
731	* The dummy page is a paranoia thingy used for instance for pure MMIO RAM ranges
732	* to make sure any bugs will not harm whatever the system stores in the first
733	* physical page. */
734	R3PTRTYPE(void *) pvDummyPage;
735	/** Physical address of the dummy page. */
736	RTHCPHYS HCPhysDummyPage;
737
738	/** Size of the base RAM in bytes. (The CFGM RamSize value.) */
739	uint64_t cbRamBase;
740	/** The number of base RAM pages that PGM has reserved (GMM).
741	* @remarks Shadow ROMs will be counted twice (RAM+ROM), so it won't be 1:1 with
742	* what the guest sees. */
743	uint64_t cBasePages;
744	/** The number of handy pages that PGM has reserved (GMM).
745	* These are kept out of cBasePages and thus out of the saved state. */
746	uint32_t cHandyPages;
747	/** The number of shadow pages PGM has reserved (GMM). */
748	uint32_t cShadowPages;
749	/** The number of fixed pages we've reserved (GMM). */
750	uint32_t cFixedPages;
751	/** Padding. */
752	uint32_t u32Padding0;
753	} MM;
754	/** Pointer to MM Data (part of VM). */
755	typedef MM *PMM;
756
757
758	/**
759	* MM data kept in the UVM.
760	*/
761	typedef struct MMUSERPERVM
762	{
763	/** Pointer to the MM R3 Heap. */
764	R3PTRTYPE(PMMHEAP) pHeap;
765	/** Pointer to the MM Uk Heap. */
766	R3PTRTYPE(PMMUKHEAP) pUkHeap;
767	} MMUSERPERVM;
768	/** Pointer to the MM data kept in the UVM. */
769	typedef MMUSERPERVM *PMMUSERPERVM;
770
771
772	__BEGIN_DECLS
773
774
775	int mmR3UpdateReservation(PVM pVM);
776
777	int mmR3PagePoolInit(PVM pVM);
778	void mmR3PagePoolTerm(PVM pVM);
779
780	int mmR3HeapCreateU(PUVM pUVM, PMMHEAP *ppHeap);
781	void mmR3HeapDestroy(PMMHEAP pHeap);
782
783	void mmR3UkHeapDestroy(PMMUKHEAP pHeap);
784	int mmR3UkHeapCreateU(PUVM pUVM, PMMUKHEAP *ppHeap);
785
786
787	int mmR3HyperInit(PVM pVM);
788	int mmR3HyperTerm(PVM pVM);
789	int mmR3HyperInitPaging(PVM pVM);
790
791	const char *mmR3GetTagName(MMTAG enmTag);
792
793	/**
794	* Converts a pool address to a physical address.
795	* The specified allocation type must match with the address.
796	*
797	* @returns Physical address.
798	* @returns NIL_RTHCPHYS if not found or eType is not matching.
799	* @param pPool Pointer to the page pool.
800	* @param pv The address to convert.
801	* @thread The Emulation Thread.
802	*/
803	RTHCPHYS mmPagePoolPtr2Phys(PMMPAGEPOOL pPool, void *pv);
804
805	/**
806	* Converts a pool physical address to a linear address.
807	* The specified allocation type must match with the address.
808	*
809	* @returns Physical address.
810	* @returns NULL if not found or eType is not matching.
811	* @param pPool Pointer to the page pool.
812	* @param HCPhys The address to convert.
813	* @thread The Emulation Thread.
814	*/
815	void *mmPagePoolPhys2Ptr(PMMPAGEPOOL pPool, RTHCPHYS HCPhys);
816
817	__END_DECLS
818
819	/** @} */
820
821	#endif
822

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

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

Download in other formats: