MMAll.cpp@ 31996

Last change on this file since 31996 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: 19.2 KB

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

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

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

Download in other formats: