MMInternal.h@ 30441

Last change on this file since 30441 was 28800, checked in by vboxsync, 15 years ago
Automated rebranding to Oracle copyright/license strings via filemuncher
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 26.5 KB

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

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

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

Download in other formats: