MMAll.cpp@ 26624

Last change on this file since 26624 was 26273, checked in by vboxsync, 15 years ago
VMM: more RC/GC warnings.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 19.4 KB

Line
1	/* $Id: MMAll.cpp 26273 2010-02-05 04:24:36Z vboxsync $ */
2	/** @file
3	* MM - Memory Manager - Any Context.
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
23	/*******************************************************************************
24	* Header Files *
25	*******************************************************************************/
26	#define LOG_GROUP LOG_GROUP_MM_HYPER
27	#include <VBox/mm.h>
28	#include <VBox/vmm.h>
29	#include "MMInternal.h"
30	#include <VBox/vm.h>
31	#include <VBox/log.h>
32	#include <iprt/assert.h>
33	#include <iprt/string.h>
34
35
36
37	/**
38	* Lookup a host context ring-3 address.
39	*
40	* @returns Pointer to the corresponding lookup record.
41	* @returns NULL on failure.
42	* @param pVM The VM handle.
43	* @param R3Ptr The host context ring-3 address to lookup.
44	* @param poff Where to store the offset into the HMA memory chunk.
45	*/
46	DECLINLINE(PMMLOOKUPHYPER) mmHyperLookupR3(PVM pVM, RTR3PTR R3Ptr, uint32_t *poff)
47	{
48	/** @todo cache last lookup, this stuff ain't cheap! */
49	PMMLOOKUPHYPER pLookup = (PMMLOOKUPHYPER)((uint8_t *)pVM->mm.s.CTX_SUFF(pHyperHeap) + pVM->mm.s.offLookupHyper);
50	for (;;)
51	{
52	switch (pLookup->enmType)
53	{
54	case MMLOOKUPHYPERTYPE_LOCKED:
55	{
56	const RTR3UINTPTR off = (RTR3UINTPTR)R3Ptr - (RTR3UINTPTR)pLookup->u.Locked.pvR3;
57	if (off < pLookup->cb)
58	{
59	*poff = off;
60	return pLookup;
61	}
62	break;
63	}
64
65	case MMLOOKUPHYPERTYPE_HCPHYS:
66	{
67	const RTR3UINTPTR off = (RTR3UINTPTR)R3Ptr - (RTR3UINTPTR)pLookup->u.HCPhys.pvR3;
68	if (off < pLookup->cb)
69	{
70	*poff = off;
71	return pLookup;
72	}
73	break;
74	}
75
76	case MMLOOKUPHYPERTYPE_GCPHYS: /* (for now we'll not allow these kind of conversions) */
77	case MMLOOKUPHYPERTYPE_MMIO2:
78	case MMLOOKUPHYPERTYPE_DYNAMIC:
79	break;
80
81	default:
82	AssertMsgFailed(("enmType=%d\n", pLookup->enmType));
83	break;
84	}
85
86	/* next */
87	if (pLookup->offNext == (int32_t)NIL_OFFSET)
88	break;
89	pLookup = (PMMLOOKUPHYPER)((uint8_t *)pLookup + pLookup->offNext);
90	}
91
92	AssertMsgFailed(("R3Ptr=%RHv is not inside the hypervisor memory area!\n", R3Ptr));
93	return NULL;
94	}
95
96
97	/**
98	* Lookup a host context ring-0 address.
99	*
100	* @returns Pointer to the corresponding lookup record.
101	* @returns NULL on failure.
102	* @param pVM The VM handle.
103	* @param R0Ptr The host context ring-0 address to lookup.
104	* @param poff Where to store the offset into the HMA memory chunk.
105	*/
106	DECLINLINE(PMMLOOKUPHYPER) mmHyperLookupR0(PVM pVM, RTR0PTR R0Ptr, uint32_t *poff)
107	{
108	AssertCompile(sizeof(RTR0PTR) == sizeof(RTR3PTR));
109
110	/** @todo cache last lookup, this stuff ain't cheap! */
111	PMMLOOKUPHYPER pLookup = (PMMLOOKUPHYPER)((uint8_t *)pVM->mm.s.CTX_SUFF(pHyperHeap) + pVM->mm.s.offLookupHyper);
112	for (;;)
113	{
114	switch (pLookup->enmType)
115	{
116	case MMLOOKUPHYPERTYPE_LOCKED:
117	{
118	const RTR0UINTPTR off = (RTR0UINTPTR)R0Ptr - (RTR0UINTPTR)pLookup->u.Locked.pvR0;
119	if (off < pLookup->cb && pLookup->u.Locked.pvR0)
120	{
121	*poff = off;
122	return pLookup;
123	}
124	break;
125	}
126
127	case MMLOOKUPHYPERTYPE_HCPHYS:
128	{
129	const RTR0UINTPTR off = (RTR0UINTPTR)R0Ptr - (RTR0UINTPTR)pLookup->u.HCPhys.pvR0;
130	if (off < pLookup->cb && pLookup->u.HCPhys.pvR0)
131	{
132	*poff = off;
133	return pLookup;
134	}
135	break;
136	}
137
138	case MMLOOKUPHYPERTYPE_GCPHYS: /* (for now we'll not allow these kind of conversions) */
139	case MMLOOKUPHYPERTYPE_MMIO2:
140	case MMLOOKUPHYPERTYPE_DYNAMIC:
141	break;
142
143	default:
144	AssertMsgFailed(("enmType=%d\n", pLookup->enmType));
145	break;
146	}
147
148	/* next */
149	if (pLookup->offNext == (int32_t)NIL_OFFSET)
150	break;
151	pLookup = (PMMLOOKUPHYPER)((uint8_t *)pLookup + pLookup->offNext);
152	}
153
154	AssertMsgFailed(("R0Ptr=%RHv is not inside the hypervisor memory area!\n", R0Ptr));
155	return NULL;
156	}
157
158
159	/**
160	* Lookup a raw-mode context address.
161	*
162	* @returns Pointer to the corresponding lookup record.
163	* @returns NULL on failure.
164	* @param pVM The VM handle.
165	* @param RCPtr The raw-mode context address to lookup.
166	* @param poff Where to store the offset into the HMA memory chunk.
167	*/
168	DECLINLINE(PMMLOOKUPHYPER) mmHyperLookupRC(PVM pVM, RTRCPTR RCPtr, uint32_t *poff)
169	{
170	/** @todo cache last lookup this stuff ain't cheap! */
171	unsigned offRC = (RTRCUINTPTR)RCPtr - (RTGCUINTPTR)pVM->mm.s.pvHyperAreaGC;
172	PMMLOOKUPHYPER pLookup = (PMMLOOKUPHYPER)((uint8_t *)pVM->mm.s.CTX_SUFF(pHyperHeap) + pVM->mm.s.offLookupHyper);
173	for (;;)
174	{
175	const uint32_t off = offRC - pLookup->off;
176	if (off < pLookup->cb)
177	{
178	switch (pLookup->enmType)
179	{
180	case MMLOOKUPHYPERTYPE_LOCKED:
181	case MMLOOKUPHYPERTYPE_HCPHYS:
182	*poff = off;
183	return pLookup;
184	default:
185	break;
186	}
187	AssertMsgFailed(("enmType=%d\n", pLookup->enmType));
188	poff = 0; / shut up gcc */
189	return NULL;
190	}
191
192	/* next */
193	if (pLookup->offNext == (int32_t)NIL_OFFSET)
194	break;
195	pLookup = (PMMLOOKUPHYPER)((uint8_t *)pLookup + pLookup->offNext);
196	}
197
198	AssertMsgFailed(("RCPtr=%RRv is not inside the hypervisor memory area!\n", RCPtr));
199	poff = 0; / shut up gcc */
200	return NULL;
201	}
202
203
204	/**
205	* Lookup a current context address.
206	*
207	* @returns Pointer to the corresponding lookup record.
208	* @returns NULL on failure.
209	* @param pVM The VM handle.
210	* @param pv The current context address to lookup.
211	* @param poff Where to store the offset into the HMA memory chunk.
212	*/
213	DECLINLINE(PMMLOOKUPHYPER) mmHyperLookupCC(PVM pVM, void pv, uint32_t poff)
214	{
215	#ifdef IN_RC
216	return mmHyperLookupRC(pVM, (RTRCPTR)pv, poff);
217	#elif defined(IN_RING0)
218	return mmHyperLookupR0(pVM, pv, poff);
219	#else
220	return mmHyperLookupR3(pVM, pv, poff);
221	#endif
222	}
223
224
225	/**
226	* Calculate the host context ring-3 address of an offset into the HMA memory chunk.
227	*
228	* @returns the host context ring-3 address.
229	* @param pLookup The HMA lookup record.
230	* @param off The offset into the HMA memory chunk.
231	*/
232	DECLINLINE(RTR3PTR) mmHyperLookupCalcR3(PMMLOOKUPHYPER pLookup, uint32_t off)
233	{
234	switch (pLookup->enmType)
235	{
236	case MMLOOKUPHYPERTYPE_LOCKED:
237	return (RTR3PTR)((RTR3UINTPTR)pLookup->u.Locked.pvR3 + off);
238	case MMLOOKUPHYPERTYPE_HCPHYS:
239	return (RTR3PTR)((RTR3UINTPTR)pLookup->u.HCPhys.pvR3 + off);
240	default:
241	AssertMsgFailed(("enmType=%d\n", pLookup->enmType));
242	return NIL_RTR3PTR;
243	}
244	}
245
246
247	/**
248	* Calculate the host context ring-0 address of an offset into the HMA memory chunk.
249	*
250	* @returns the host context ring-0 address.
251	* @param pVM Pointer to the shared VM structure.
252	* @param pLookup The HMA lookup record.
253	* @param off The offset into the HMA memory chunk.
254	*/
255	DECLINLINE(RTR0PTR) mmHyperLookupCalcR0(PVM pVM, PMMLOOKUPHYPER pLookup, uint32_t off)
256	{
257	switch (pLookup->enmType)
258	{
259	case MMLOOKUPHYPERTYPE_LOCKED:
260	if (pLookup->u.Locked.pvR0)
261	return (RTR0PTR)((RTR0UINTPTR)pLookup->u.Locked.pvR0 + off);
262	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
263	AssertMsg(!VMMIsHwVirtExtForced(pVM), ("%s\n", R3STRING(pLookup->pszDesc)));
264	#else
265	AssertMsgFailed(("%s\n", R3STRING(pLookup->pszDesc)));
266	#endif
267	return NIL_RTR0PTR;
268
269	case MMLOOKUPHYPERTYPE_HCPHYS:
270	if (pLookup->u.HCPhys.pvR0)
271	return (RTR0PTR)((RTR0UINTPTR)pLookup->u.HCPhys.pvR0 + off);
272	AssertMsgFailed(("%s\n", R3STRING(pLookup->pszDesc)));
273	return NIL_RTR0PTR;
274
275	default:
276	AssertMsgFailed(("enmType=%d\n", pLookup->enmType));
277	return NIL_RTR0PTR;
278	}
279	}
280
281
282	/**
283	* Calculate the raw-mode context address of an offset into the HMA memory chunk.
284	*
285	* @returns the raw-mode context base address.
286	* @param pVM The the VM handle.
287	* @param pLookup The HMA lookup record.
288	* @param off The offset into the HMA memory chunk.
289	*/
290	DECLINLINE(RTRCPTR) mmHyperLookupCalcRC(PVM pVM, PMMLOOKUPHYPER pLookup, uint32_t off)
291	{
292	return (RTRCPTR)((RTRCUINTPTR)pVM->mm.s.pvHyperAreaGC + pLookup->off + off);
293	}
294
295
296	/**
297	* Calculate the guest context address of an offset into the HMA memory chunk.
298	*
299	* @returns the guest context base address.
300	* @param pVM The the VM handle.
301	* @param pLookup The HMA lookup record.
302	* @param off The offset into the HMA memory chunk.
303	*/
304	DECLINLINE(void *) mmHyperLookupCalcCC(PVM pVM, PMMLOOKUPHYPER pLookup, uint32_t off)
305	{
306	#ifdef IN_RC
307	return (void *)mmHyperLookupCalcRC(pVM, pLookup, off);
308	#elif defined(IN_RING0)
309	return mmHyperLookupCalcR0(pVM, pLookup, off);
310	#else
311	return mmHyperLookupCalcR3(pLookup, off);
312	#endif
313	}
314
315
316	/**
317	* Converts a ring-0 host context address in the Hypervisor memory region to a ring-3 host context address.
318	*
319	* @returns ring-3 host context address.
320	* @param pVM The VM to operate on.
321	* @param R0Ptr The ring-0 host context address.
322	* You'll be damned if this is not in the HMA! :-)
323	* @thread The Emulation Thread.
324	*/
325	VMMDECL(RTR3PTR) MMHyperR0ToR3(PVM pVM, RTR0PTR R0Ptr)
326	{
327	uint32_t off;
328	PMMLOOKUPHYPER pLookup = mmHyperLookupR0(pVM, R0Ptr, &off);
329	if (pLookup)
330	return mmHyperLookupCalcR3(pLookup, off);
331	return NIL_RTR3PTR;
332	}
333
334
335	/**
336	* Converts a ring-0 host context address in the Hypervisor memory region to a raw-mode context address.
337	*
338	* @returns raw-mode context address.
339	* @param pVM The VM to operate on.
340	* @param R0Ptr The ring-0 host context address.
341	* You'll be damned if this is not in the HMA! :-)
342	* @thread The Emulation Thread.
343	*/
344	VMMDECL(RTRCPTR) MMHyperR0ToRC(PVM pVM, RTR0PTR R0Ptr)
345	{
346	uint32_t off;
347	PMMLOOKUPHYPER pLookup = mmHyperLookupR0(pVM, R0Ptr, &off);
348	if (pLookup)
349	return mmHyperLookupCalcRC(pVM, pLookup, off);
350	return NIL_RTRCPTR;
351	}
352
353
354	#ifndef IN_RING0
355	/**
356	* Converts a ring-0 host context address in the Hypervisor memory region to a current context address.
357	*
358	* @returns current context address.
359	* @param pVM The VM to operate on.
360	* @param R0Ptr The ring-0 host context address.
361	* You'll be damned if this is not in the HMA! :-)
362	* @thread The Emulation Thread.
363	*/
364	VMMDECL(void *) MMHyperR0ToCC(PVM pVM, RTR0PTR R0Ptr)
365	{
366	uint32_t off;
367	PMMLOOKUPHYPER pLookup = mmHyperLookupR0(pVM, R0Ptr, &off);
368	if (pLookup)
369	return mmHyperLookupCalcCC(pVM, pLookup, off);
370	return NULL;
371	}
372	#endif
373
374
375	/**
376	* Converts a ring-3 host context address in the Hypervisor memory region to a ring-0 host context address.
377	*
378	* @returns ring-0 host context address.
379	* @param pVM The VM to operate on.
380	* @param R3Ptr The ring-3 host context address.
381	* You'll be damned if this is not in the HMA! :-)
382	* @thread The Emulation Thread.
383	*/
384	VMMDECL(RTR0PTR) MMHyperR3ToR0(PVM pVM, RTR3PTR R3Ptr)
385	{
386	uint32_t off;
387	PMMLOOKUPHYPER pLookup = mmHyperLookupR3(pVM, R3Ptr, &off);
388	if (pLookup)
389	return mmHyperLookupCalcR0(pVM, pLookup, off);
390	AssertMsgFailed(("R3Ptr=%p is not inside the hypervisor memory area!\n", R3Ptr));
391	return NIL_RTR0PTR;
392	}
393
394
395	/**
396	* Converts a ring-3 host context address in the Hypervisor memory region to a guest context address.
397	*
398	* @returns guest context address.
399	* @param pVM The VM to operate on.
400	* @param R3Ptr The ring-3 host context address.
401	* You'll be damned if this is not in the HMA! :-)
402	* @thread The Emulation Thread.
403	*/
404	VMMDECL(RTRCPTR) MMHyperR3ToRC(PVM pVM, RTR3PTR R3Ptr)
405	{
406	uint32_t off;
407	PMMLOOKUPHYPER pLookup = mmHyperLookupR3(pVM, R3Ptr, &off);
408	if (pLookup)
409	return mmHyperLookupCalcRC(pVM, pLookup, off);
410	AssertMsgFailed(("R3Ptr=%p is not inside the hypervisor memory area!\n", R3Ptr));
411	return NIL_RTRCPTR;
412	}
413
414
415	#ifndef IN_RING3
416	/**
417	* Converts a ring-3 host context address in the Hypervisor memory region to a current context address.
418	*
419	* @returns current context address.
420	* @param pVM The VM to operate on.
421	* @param R3Ptr The ring-3 host context address.
422	* You'll be damned if this is not in the HMA! :-)
423	* @thread The Emulation Thread.
424	*/
425	VMMDECL(void *) MMHyperR3ToCC(PVM pVM, RTR3PTR R3Ptr)
426	{
427	uint32_t off;
428	PMMLOOKUPHYPER pLookup = mmHyperLookupR3(pVM, R3Ptr, &off);
429	if (pLookup)
430	return mmHyperLookupCalcCC(pVM, pLookup, off);
431	return NULL;
432	}
433	#endif
434
435
436	/**
437	* Converts a raw-mode context address in the Hypervisor memory region to a ring-3 context address.
438	*
439	* @returns ring-3 host context address.
440	* @param pVM The VM to operate on.
441	* @param GCPtr The raw-mode context address.
442	* You'll be damned if this is not in the HMA! :-)
443	* @thread The Emulation Thread.
444	*/
445	VMMDECL(RTR3PTR) MMHyperRCToR3(PVM pVM, RTRCPTR RCPtr)
446	{
447	uint32_t off;
448	PMMLOOKUPHYPER pLookup = mmHyperLookupRC(pVM, RCPtr, &off);
449	if (pLookup)
450	return mmHyperLookupCalcR3(pLookup, off);
451	return NIL_RTR3PTR;
452	}
453
454
455	/**
456	* Converts a raw-mode context address in the Hypervisor memory region to a ring-0 host context address.
457	*
458	* @returns ring-0 host context address.
459	* @param pVM The VM to operate on.
460	* @param RCPtr The raw-mode context address.
461	* You'll be damned if this is not in the HMA! :-)
462	* @thread The Emulation Thread.
463	*/
464	VMMDECL(RTR0PTR) MMHyperRCToR0(PVM pVM, RTRCPTR RCPtr)
465	{
466	uint32_t off;
467	PMMLOOKUPHYPER pLookup = mmHyperLookupRC(pVM, RCPtr, &off);
468	if (pLookup)
469	return mmHyperLookupCalcR0(pVM, pLookup, off);
470	return NIL_RTR0PTR;
471	}
472
473	#ifndef IN_RC
474	/**
475	* Converts a raw-mode context address in the Hypervisor memory region to a current context address.
476	*
477	* @returns current context address.
478	* @param pVM The VM to operate on.
479	* @param RCPtr The raw-mode host context address.
480	* You'll be damned if this is not in the HMA! :-)
481	* @thread The Emulation Thread.
482	*/
483	VMMDECL(void *) MMHyperRCToCC(PVM pVM, RTRCPTR RCPtr)
484	{
485	uint32_t off;
486	PMMLOOKUPHYPER pLookup = mmHyperLookupRC(pVM, RCPtr, &off);
487	if (pLookup)
488	return mmHyperLookupCalcCC(pVM, pLookup, off);
489	return NULL;
490	}
491	#endif
492
493	#ifndef IN_RING3
494	/**
495	* Converts a current context address in the Hypervisor memory region to a ring-3 host context address.
496	*
497	* @returns ring-3 host context address.
498	* @param pVM The VM to operate on.
499	* @param pv The current context address.
500	* You'll be damned if this is not in the HMA! :-)
501	* @thread The Emulation Thread.
502	*/
503	VMMDECL(RTR3PTR) MMHyperCCToR3(PVM pVM, void *pv)
504	{
505	uint32_t off;
506	PMMLOOKUPHYPER pLookup = mmHyperLookupCC(pVM, pv, &off);
507	if (pLookup)
508	return mmHyperLookupCalcR3(pLookup, off);
509	return NIL_RTR3PTR;
510	}
511	#endif
512
513	#ifndef IN_RING0
514	/**
515	* Converts a current context address in the Hypervisor memory region to a ring-0 host context address.
516	*
517	* @returns ring-0 host context address.
518	* @param pVM The VM to operate on.
519	* @param pv The current context address.
520	* You'll be damned if this is not in the HMA! :-)
521	* @thread The Emulation Thread.
522	*/
523	VMMDECL(RTR0PTR) MMHyperCCToR0(PVM pVM, void *pv)
524	{
525	uint32_t off;
526	PMMLOOKUPHYPER pLookup = mmHyperLookupCC(pVM, pv, &off);
527	if (pLookup)
528	return mmHyperLookupCalcR0(pVM, pLookup, off);
529	return NIL_RTR0PTR;
530	}
531	#endif
532
533
534	#ifndef IN_RC
535	/**
536	* Converts a current context address in the Hypervisor memory region to a raw-mode context address.
537	*
538	* @returns guest context address.
539	* @param pVM The VM to operate on.
540	* @param pv The current context address.
541	* You'll be damned if this is not in the HMA! :-)
542	* @thread The Emulation Thread.
543	*/
544	VMMDECL(RTRCPTR) MMHyperCCToRC(PVM pVM, void *pv)
545	{
546	uint32_t off;
547	PMMLOOKUPHYPER pLookup = mmHyperLookupCC(pVM, pv, &off);
548	if (pLookup)
549	return mmHyperLookupCalcRC(pVM, pLookup, off);
550	return NIL_RTRCPTR;
551	}
552	#endif
553
554
555	/**
556	* Gets the string name of a memory tag.
557	*
558	* @returns name of enmTag.
559	* @param enmTag The tag.
560	*/
561	const char *mmGetTagName(MMTAG enmTag)
562	{
563	switch (enmTag)
564	{
565	#define TAG2STR(tag) case MM_TAG_##tag: return #tag
566
567	TAG2STR(CFGM);
568	TAG2STR(CFGM_BYTES);
569	TAG2STR(CFGM_STRING);
570	TAG2STR(CFGM_USER);
571
572	TAG2STR(CSAM);
573	TAG2STR(CSAM_PATCH);
574
575	TAG2STR(DBGF);
576	TAG2STR(DBGF_AS);
577	TAG2STR(DBGF_INFO);
578	TAG2STR(DBGF_LINE);
579	TAG2STR(DBGF_LINE_DUP);
580	TAG2STR(DBGF_MODULE);
581	TAG2STR(DBGF_OS);
582	TAG2STR(DBGF_STACK);
583	TAG2STR(DBGF_SYMBOL);
584	TAG2STR(DBGF_SYMBOL_DUP);
585
586	TAG2STR(EM);
587
588	TAG2STR(IOM);
589	TAG2STR(IOM_STATS);
590
591	TAG2STR(MM);
592	TAG2STR(MM_LOOKUP_GUEST);
593	TAG2STR(MM_LOOKUP_PHYS);
594	TAG2STR(MM_LOOKUP_VIRT);
595	TAG2STR(MM_PAGE);
596
597	TAG2STR(PARAV);
598
599	TAG2STR(PATM);
600	TAG2STR(PATM_PATCH);
601
602	TAG2STR(PDM);
603	TAG2STR(PDM_DEVICE);
604	TAG2STR(PDM_DEVICE_DESC);
605	TAG2STR(PDM_DEVICE_USER);
606	TAG2STR(PDM_DRIVER);
607	TAG2STR(PDM_DRIVER_DESC);
608	TAG2STR(PDM_DRIVER_USER);
609	TAG2STR(PDM_USB);
610	TAG2STR(PDM_USB_DESC);
611	TAG2STR(PDM_USB_USER);
612	TAG2STR(PDM_LUN);
613	TAG2STR(PDM_QUEUE);
614	TAG2STR(PDM_THREAD);
615	TAG2STR(PDM_ASYNC_COMPLETION);
616
617	TAG2STR(PGM);
618	TAG2STR(PGM_CHUNK_MAPPING);
619	TAG2STR(PGM_HANDLERS);
620	TAG2STR(PGM_MAPPINGS);
621	TAG2STR(PGM_PHYS);
622	TAG2STR(PGM_POOL);
623
624	TAG2STR(REM);
625
626	TAG2STR(SELM);
627
628	TAG2STR(SSM);
629
630	TAG2STR(STAM);
631
632	TAG2STR(TM);
633
634	TAG2STR(TRPM);
635
636	TAG2STR(VM);
637	TAG2STR(VM_REQ);
638
639	TAG2STR(VMM);
640
641	TAG2STR(HWACCM);
642
643	#undef TAG2STR
644
645	default:
646	{
647	AssertMsgFailed(("Unknown tag %d! forgot to add it to the switch?\n", enmTag));
648	#ifdef IN_RING3
649	static char sz[48];
650	RTStrPrintf(sz, sizeof(sz), "%d", enmTag);
651	return sz;
652	#else
653	return "unknown tag!";
654	#endif
655	}
656	}
657	}
658

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

source: vbox/trunk/src/VBox/VMM/VMMAll/MMAll.cpp@ 26624

Download in other formats: