VMM.cpp@ 11945

Last change on this file since 11945 was 11945, checked in by vboxsync, 16 years ago
Dropped stack position/empty requirement when restoring the vmm part. A save can never be initiated when we're in a host call (from GC).
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 98.8 KB

Line
1	/* $Id: VMM.cpp 11945 2008-09-01 17:43:08Z vboxsync $ */
2	/** @file
3	* VMM - The Virtual Machine Monitor Core.
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	//#define NO_SUPCALLR0VMM
23
24	/** @page pg_vmm VMM - The Virtual Machine Monitor
25	*
26	* !Revise this! It's already incorrect!
27	*
28	* The Virtual Machine Monitor (VMM) is the core of the virtual machine. It
29	* manages the alternate reality; controlling the virtualization, managing
30	* resources, tracking CPU state, it's resources and so on...
31	*
32	* We will split the VMM into smaller entities:
33	*
34	* - Virtual Machine Core Monitor (VMCM), which purpose it is to
35	* provide ring and world switching, that including routing
36	* interrupts to the host OS and traps to the appropriate trap
37	* handlers. It will implement an external interface for
38	* managing trap handlers.
39	*
40	* - CPU Monitor (CM), tracking the state of the CPU (in the alternate
41	* reality) and implementing external interfaces to read and change
42	* the state.
43	*
44	* - Memory Monitor (MM), which purpose it is to virtualize physical
45	* pages, segment descriptor tables, interrupt descriptor tables, task
46	* segments, and keep track of all memory providing external interfaces
47	* to access content and map pages. (Internally splitt into smaller entities!)
48	*
49	* - IO Monitor (IOM), which virtualizes in and out I/O operations. It
50	* interacts with the MM to implement memory mapped I/O. External
51	* interfaces for adding and removing I/O ranges are implemented.
52	*
53	* - External Interrupt Monitor (EIM), which purpose it is to manage
54	* interrupts generated by virtual devices. This monitor provides
55	* an interfaces for raising interrupts which is accessible at any
56	* time and from all thread.
57	* <p>
58	* A subentity of the EIM is the vitual Programmable Interrupt
59	* Controller Device (VPICD), and perhaps a virtual I/O Advanced
60	* Programmable Interrupt Controller Device (VAPICD).
61	*
62	* - Direct Memory Access Monitor (DMAM), which purpose it is to support
63	* virtual device using the DMA controller. Interfaces must be as the
64	* EIM interfaces independent and threadable.
65	* <p>
66	* A subentity of the DMAM is a virtual DMA Controller Device (VDMACD).
67	*
68	*
69	* Entities working on a higher level:
70	*
71	* - Device Manager (DM), which is a support facility for virtualized
72	* hardware. This provides generic facilities for efficient device
73	* virtualization. It will manage device attaching and detaching
74	* conversing with EIM and IOM.
75	*
76	* - Debugger Facility (DBGF) provides the basic features for
77	* debugging the alternate reality execution.
78	*
79	*
80	*
81	* @section pg_vmm_s_use_cases Use Cases
82	*
83	* @subsection pg_vmm_s_use_case_boot Bootstrap
84	*
85	* - Basic Init:
86	* - Init SUPDRV.
87	*
88	* - Init Virtual Machine Instance:
89	* - Load settings.
90	* - Check resource requirements (memory, com, stuff).
91	*
92	* - Init Host Ring 3 part:
93	* - Init Core code.
94	* - Load Pluggable Components.
95	* - Init Pluggable Components.
96	*
97	* - Init Host Ring 0 part:
98	* - Load Core (core = core components like VMM, RMI, CA, and so on) code.
99	* - Init Core code.
100	* - Load Pluggable Component code.
101	* - Init Pluggable Component code.
102	*
103	* - Allocate first chunk of memory and pin it down. This block of memory
104	* will fit the following pieces:
105	* - Virtual Machine Instance data. (Config, CPU state, VMM state, ++)
106	* (This is available from everywhere (at different addresses though)).
107	* - VMM Guest Context code.
108	* - Pluggable devices Guest Context code.
109	* - Page tables (directory and everything) for the VMM Guest
110	*
111	* - Setup Guest (Ring 0) part:
112	* - Setup initial page tables (i.e. directory all the stuff).
113	* - Load Core Guest Context code.
114	* - Load Pluggable Devices Guest Context code.
115	*
116	*
117	*/
118
119
120	/*******************************************************************************
121	* Header Files *
122	*******************************************************************************/
123	#define LOG_GROUP LOG_GROUP_VMM
124	#include <VBox/vmm.h>
125	#include <VBox/vmapi.h>
126	#include <VBox/pgm.h>
127	#include <VBox/cfgm.h>
128	#include <VBox/pdmqueue.h>
129	#include <VBox/pdmapi.h>
130	#include <VBox/cpum.h>
131	#include <VBox/mm.h>
132	#include <VBox/iom.h>
133	#include <VBox/trpm.h>
134	#include <VBox/selm.h>
135	#include <VBox/em.h>
136	#include <VBox/sup.h>
137	#include <VBox/dbgf.h>
138	#include <VBox/csam.h>
139	#include <VBox/patm.h>
140	#include <VBox/rem.h>
141	#include <VBox/ssm.h>
142	#include <VBox/tm.h>
143	#include "VMMInternal.h"
144	#include "VMMSwitcher/VMMSwitcher.h"
145	#include <VBox/vm.h>
146	#include <VBox/err.h>
147	#include <VBox/param.h>
148	#include <VBox/version.h>
149	#include <VBox/x86.h>
150	#include <VBox/hwaccm.h>
151	#include <iprt/assert.h>
152	#include <iprt/alloc.h>
153	#include <iprt/asm.h>
154	#include <iprt/time.h>
155	#include <iprt/stream.h>
156	#include <iprt/string.h>
157	#include <iprt/stdarg.h>
158	#include <iprt/ctype.h>
159
160
161
162	/** The saved state version. */
163	#define VMM_SAVED_STATE_VERSION 3
164
165
166	/*******************************************************************************
167	* Internal Functions *
168	*******************************************************************************/
169	static DECLCALLBACK(int) vmmR3Save(PVM pVM, PSSMHANDLE pSSM);
170	static DECLCALLBACK(int) vmmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t u32Version);
171	static DECLCALLBACK(void) vmmR3YieldEMT(PVM pVM, PTMTIMER pTimer, void *pvUser);
172	static int vmmR3ServiceCallHostRequest(PVM pVM);
173	static DECLCALLBACK(void) vmmR3InfoFF(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
174
175
176	/*******************************************************************************
177	* Global Variables *
178	*******************************************************************************/
179	/** Array of switcher defininitions.
180	* The type and index shall match!
181	*/
182	static PVMMSWITCHERDEF s_apSwitchers[VMMSWITCHER_MAX] =
183	{
184	NULL, /* invalid entry */
185	#ifndef RT_ARCH_AMD64
186	&vmmR3Switcher32BitTo32Bit_Def,
187	&vmmR3Switcher32BitToPAE_Def,
188	NULL, //&vmmR3Switcher32BitToAMD64_Def,
189	&vmmR3SwitcherPAETo32Bit_Def,
190	&vmmR3SwitcherPAEToPAE_Def,
191	NULL, //&vmmR3SwitcherPAEToAMD64_Def,
192	# ifdef VBOX_WITH_HYBIRD_32BIT_KERNEL
193	&vmmR3SwitcherAMD64ToPAE_Def,
194	# else
195	NULL, //&vmmR3SwitcherAMD64ToPAE_Def,
196	# endif
197	NULL //&vmmR3SwitcherAMD64ToAMD64_Def,
198	#else
199	NULL, //&vmmR3Switcher32BitTo32Bit_Def,
200	NULL, //&vmmR3Switcher32BitToPAE_Def,
201	NULL, //&vmmR3Switcher32BitToAMD64_Def,
202	NULL, //&vmmR3SwitcherPAETo32Bit_Def,
203	NULL, //&vmmR3SwitcherPAEToPAE_Def,
204	NULL, //&vmmR3SwitcherPAEToAMD64_Def,
205	&vmmR3SwitcherAMD64ToPAE_Def,
206	NULL //&vmmR3SwitcherAMD64ToAMD64_Def,
207	#endif
208	};
209
210
211
212	/**
213	* Initiates the core code.
214	*
215	* This is core per VM code which might need fixups and/or for ease of use
216	* are put on linear contiguous backing.
217	*
218	* @returns VBox status code.
219	* @param pVM Pointer to VM structure.
220	*/
221	static int vmmR3InitCoreCode(PVM pVM)
222	{
223	/*
224	* Calc the size.
225	*/
226	unsigned cbCoreCode = 0;
227	for (unsigned iSwitcher = 0; iSwitcher < RT_ELEMENTS(s_apSwitchers); iSwitcher++)
228	{
229	pVM->vmm.s.aoffSwitchers[iSwitcher] = cbCoreCode;
230	PVMMSWITCHERDEF pSwitcher = s_apSwitchers[iSwitcher];
231	if (pSwitcher)
232	{
233	AssertRelease((unsigned)pSwitcher->enmType == iSwitcher);
234	cbCoreCode += RT_ALIGN_32(pSwitcher->cbCode + 1, 32);
235	}
236	}
237
238	/*
239	* Allocate continguous pages for switchers and deal with
240	* conflicts in the intermediate mapping of the code.
241	*/
242	pVM->vmm.s.cbCoreCode = RT_ALIGN_32(cbCoreCode, PAGE_SIZE);
243	pVM->vmm.s.pvHCCoreCodeR3 = SUPContAlloc2(pVM->vmm.s.cbCoreCode >> PAGE_SHIFT, &pVM->vmm.s.pvHCCoreCodeR0, &pVM->vmm.s.HCPhysCoreCode);
244	int rc = VERR_NO_MEMORY;
245	if (pVM->vmm.s.pvHCCoreCodeR3)
246	{
247	rc = PGMR3MapIntermediate(pVM, pVM->vmm.s.pvHCCoreCodeR0, pVM->vmm.s.HCPhysCoreCode, cbCoreCode);
248	if (rc == VERR_PGM_INTERMEDIATE_PAGING_CONFLICT)
249	{
250	/* try more allocations - Solaris */
251	const unsigned cTries = 4112;
252	struct VMMInitBadTry
253	{
254	RTR0PTR pvR0;
255	void *pvR3;
256	RTHCPHYS HCPhys;
257	RTUINT cb;
258	} paBadTries = (struct VMMInitBadTry )RTMemTmpAlloc(sizeof(paBadTries) cTries);
259	AssertReturn(paBadTries, VERR_NO_TMP_MEMORY);
260	unsigned i = 0;
261	do
262	{
263	paBadTries[i].pvR3 = pVM->vmm.s.pvHCCoreCodeR3;
264	paBadTries[i].pvR0 = pVM->vmm.s.pvHCCoreCodeR0;
265	paBadTries[i].HCPhys = pVM->vmm.s.HCPhysCoreCode;
266	i++;
267	pVM->vmm.s.pvHCCoreCodeR0 = NIL_RTR0PTR;
268	pVM->vmm.s.HCPhysCoreCode = NIL_RTHCPHYS;
269	pVM->vmm.s.pvHCCoreCodeR3 = SUPContAlloc2(pVM->vmm.s.cbCoreCode >> PAGE_SHIFT, &pVM->vmm.s.pvHCCoreCodeR0, &pVM->vmm.s.HCPhysCoreCode);
270	if (!pVM->vmm.s.pvHCCoreCodeR3)
271	break;
272	rc = PGMR3MapIntermediate(pVM, pVM->vmm.s.pvHCCoreCodeR0, pVM->vmm.s.HCPhysCoreCode, cbCoreCode);
273	} while ( rc == VERR_PGM_INTERMEDIATE_PAGING_CONFLICT
274	&& i < cTries - 1);
275
276	/* cleanup */
277	if (VBOX_FAILURE(rc))
278	{
279	paBadTries[i].pvR3 = pVM->vmm.s.pvHCCoreCodeR3;
280	paBadTries[i].pvR0 = pVM->vmm.s.pvHCCoreCodeR0;
281	paBadTries[i].HCPhys = pVM->vmm.s.HCPhysCoreCode;
282	paBadTries[i].cb = pVM->vmm.s.cbCoreCode;
283	i++;
284	LogRel(("Failed to allocated and map core code: rc=%Vrc\n", rc));
285	}
286	while (i-- > 0)
287	{
288	LogRel(("Core code alloc attempt #%d: pvR3=%p pvR0=%p HCPhys=%VHp\n",
289	i, paBadTries[i].pvR3, paBadTries[i].pvR0, paBadTries[i].HCPhys));
290	SUPContFree(paBadTries[i].pvR3, paBadTries[i].cb >> PAGE_SHIFT);
291	}
292	RTMemTmpFree(paBadTries);
293	}
294	}
295	if (VBOX_SUCCESS(rc))
296	{
297	/*
298	* copy the code.
299	*/
300	for (unsigned iSwitcher = 0; iSwitcher < RT_ELEMENTS(s_apSwitchers); iSwitcher++)
301	{
302	PVMMSWITCHERDEF pSwitcher = s_apSwitchers[iSwitcher];
303	if (pSwitcher)
304	memcpy((uint8_t *)pVM->vmm.s.pvHCCoreCodeR3 + pVM->vmm.s.aoffSwitchers[iSwitcher],
305	pSwitcher->pvCode, pSwitcher->cbCode);
306	}
307
308	/*
309	* Map the code into the GC address space.
310	*/
311	RTGCPTR GCPtr;
312	rc = MMR3HyperMapHCPhys(pVM, pVM->vmm.s.pvHCCoreCodeR3, pVM->vmm.s.HCPhysCoreCode, cbCoreCode, "Core Code", &GCPtr);
313	if (VBOX_SUCCESS(rc))
314	{
315	pVM->vmm.s.pvGCCoreCode = GCPtr;
316	MMR3HyperReserve(pVM, PAGE_SIZE, "fence", NULL);
317	LogRel(("CoreCode: R3=%VHv R0=%VHv GC=%VRv Phys=%VHp cb=%#x\n",
318	pVM->vmm.s.pvHCCoreCodeR3, pVM->vmm.s.pvHCCoreCodeR0, pVM->vmm.s.pvGCCoreCode, pVM->vmm.s.HCPhysCoreCode, pVM->vmm.s.cbCoreCode));
319
320	/*
321	* Finally, PGM probably have selected a switcher already but we need
322	* to do get the addresses so we'll reselect it.
323	* This may legally fail so, we're ignoring the rc.
324	*/
325	VMMR3SelectSwitcher(pVM, pVM->vmm.s.enmSwitcher);
326	return rc;
327	}
328
329	/* shit */
330	AssertMsgFailed(("PGMR3Map(,%VRv, %VGp, %#x, 0) failed with rc=%Vrc\n", pVM->vmm.s.pvGCCoreCode, pVM->vmm.s.HCPhysCoreCode, cbCoreCode, rc));
331	SUPContFree(pVM->vmm.s.pvHCCoreCodeR3, pVM->vmm.s.cbCoreCode >> PAGE_SHIFT);
332	}
333	else
334	VMSetError(pVM, rc, RT_SRC_POS,
335	N_("Failed to allocate %d bytes of contiguous memory for the world switcher code"),
336	cbCoreCode);
337
338	pVM->vmm.s.pvHCCoreCodeR3 = NULL;
339	pVM->vmm.s.pvHCCoreCodeR0 = NIL_RTR0PTR;
340	pVM->vmm.s.pvGCCoreCode = 0;
341	return rc;
342	}
343
344
345	/**
346	* Initializes the VMM.
347	*
348	* @returns VBox status code.
349	* @param pVM The VM to operate on.
350	*/
351	VMMR3DECL(int) VMMR3Init(PVM pVM)
352	{
353	LogFlow(("VMMR3Init\n"));
354
355	/*
356	* Assert alignment, sizes and order.
357	*/
358	AssertMsg(pVM->vmm.s.offVM == 0, ("Already initialized!\n"));
359	AssertMsg(sizeof(pVM->vmm.padding) >= sizeof(pVM->vmm.s),
360	("pVM->vmm.padding is too small! vmm.padding %d while vmm.s is %d\n",
361	sizeof(pVM->vmm.padding), sizeof(pVM->vmm.s)));
362
363	/*
364	* Init basic VM VMM members.
365	*/
366	pVM->vmm.s.offVM = RT_OFFSETOF(VM, vmm);
367	int rc = CFGMR3QueryU32(CFGMR3GetRoot(pVM), "YieldEMTInterval", &pVM->vmm.s.cYieldEveryMillies);
368	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
369	pVM->vmm.s.cYieldEveryMillies = 23; /* Value arrived at after experimenting with the grub boot prompt. */
370	//pVM->vmm.s.cYieldEveryMillies = 8; //debugging
371	else
372	AssertMsgRCReturn(rc, ("Configuration error. Failed to query \"YieldEMTInterval\", rc=%Vrc\n", rc), rc);
373
374	/* GC switchers are enabled by default. Turned off by HWACCM. */
375	pVM->vmm.s.fSwitcherDisabled = false;
376
377	/*
378	* Register the saved state data unit.
379	*/
380	rc = SSMR3RegisterInternal(pVM, "vmm", 1, VMM_SAVED_STATE_VERSION, VMM_STACK_SIZE + sizeof(RTGCPTR),
381	NULL, vmmR3Save, NULL,
382	NULL, vmmR3Load, NULL);
383	if (VBOX_FAILURE(rc))
384	return rc;
385
386	/*
387	* Register the Ring-0 VM handle with the session for fast ioctl calls.
388	*/
389	rc = SUPSetVMForFastIOCtl(pVM->pVMR0);
390	if (VBOX_FAILURE(rc))
391	return rc;
392
393	/*
394	* Init core code.
395	*/
396	rc = vmmR3InitCoreCode(pVM);
397	if (VBOX_SUCCESS(rc))
398	{
399	/*
400	* Allocate & init VMM GC stack.
401	* The stack pages are also used by the VMM R0 when VMMR0CallHost is invoked.
402	* (The page protection is modifed during R3 init completion.)
403	*/
404	#ifdef VBOX_STRICT_VMM_STACK
405	rc = MMHyperAlloc(pVM, VMM_STACK_SIZE + PAGE_SIZE + PAGE_SIZE, PAGE_SIZE, MM_TAG_VMM, (void **)&pVM->vmm.s.pbHCStack);
406	#else
407	rc = MMHyperAlloc(pVM, VMM_STACK_SIZE, PAGE_SIZE, MM_TAG_VMM, (void **)&pVM->vmm.s.pbHCStack);
408	#endif
409	if (VBOX_SUCCESS(rc))
410	{
411	/* Set HC and GC stack pointers to top of stack. */
412	pVM->vmm.s.CallHostR0JmpBuf.pvSavedStack = (RTR0PTR)pVM->vmm.s.pbHCStack;
413	pVM->vmm.s.pbGCStack = MMHyperHC2GC(pVM, pVM->vmm.s.pbHCStack);
414	pVM->vmm.s.pbGCStackBottom = pVM->vmm.s.pbGCStack + VMM_STACK_SIZE;
415	AssertRelease(pVM->vmm.s.pbGCStack);
416
417	/* Set hypervisor eip. */
418	CPUMSetHyperESP(pVM, pVM->vmm.s.pbGCStack);
419
420	/*
421	* Allocate GC & R0 Logger instances (they are finalized in the relocator).
422	*/
423	#ifdef LOG_ENABLED
424	PRTLOGGER pLogger = RTLogDefaultInstance();
425	if (pLogger)
426	{
427	pVM->vmm.s.cbLoggerGC = RT_OFFSETOF(RTLOGGERRC, afGroups[pLogger->cGroups]);
428	rc = MMHyperAlloc(pVM, pVM->vmm.s.cbLoggerGC, 0, MM_TAG_VMM, (void **)&pVM->vmm.s.pLoggerHC);
429	if (VBOX_SUCCESS(rc))
430	{
431	pVM->vmm.s.pLoggerGC = MMHyperHC2GC(pVM, pVM->vmm.s.pLoggerHC);
432
433	/*
434	* Ring-0 logging isn't 100% safe yet (thread id reuse / process exit cleanup), so
435	* you have to sign up here by adding your defined(DEBUG_<userid>) to the #if.
436	*
437	* If you want to log in non-debug modes, you'll have to remember to change SUPDRvShared.c
438	* to not stub all the log functions.
439	*
440	* You might also wish to enable the AssertMsg1/2 overrides in VMMR0.cpp when enabling this.
441	*/
442	# if defined(DEBUG_sandervl) \|\| defined(DEBUG_frank)
443	rc = MMHyperAlloc(pVM, RT_OFFSETOF(VMMR0LOGGER, Logger.afGroups[pLogger->cGroups]),
444	0, MM_TAG_VMM, (void **)&pVM->vmm.s.pR0Logger);
445	if (VBOX_SUCCESS(rc))
446	{
447	pVM->vmm.s.pR0Logger->pVM = pVM->pVMR0;
448	//pVM->vmm.s.pR0Logger->fCreated = false;
449	pVM->vmm.s.pR0Logger->cbLogger = RT_OFFSETOF(RTLOGGER, afGroups[pLogger->cGroups]);
450	}
451	# endif
452	}
453	}
454	#endif /* LOG_ENABLED */
455
456	#ifdef VBOX_WITH_GC_AND_R0_RELEASE_LOG
457	/*
458	* Allocate GC Release Logger instances (finalized in the relocator).
459	*/
460	if (VBOX_SUCCESS(rc))
461	{
462	PRTLOGGER pRelLogger = RTLogRelDefaultInstance();
463	if (pRelLogger)
464	{
465	pVM->vmm.s.cbRelLoggerGC = RT_OFFSETOF(RTLOGGERRC, afGroups[pRelLogger->cGroups]);
466	rc = MMHyperAlloc(pVM, pVM->vmm.s.cbRelLoggerGC, 0, MM_TAG_VMM, (void **)&pVM->vmm.s.pRelLoggerHC);
467	if (VBOX_SUCCESS(rc))
468	pVM->vmm.s.pRelLoggerGC = MMHyperHC2GC(pVM, pVM->vmm.s.pRelLoggerHC);
469	}
470	}
471	#endif /* VBOX_WITH_GC_AND_R0_RELEASE_LOG */
472
473	#ifdef VBOX_WITH_NMI
474	/*
475	* Allocate mapping for the host APIC.
476	*/
477	if (VBOX_SUCCESS(rc))
478	{
479	rc = MMR3HyperReserve(pVM, PAGE_SIZE, "Host APIC", &pVM->vmm.s.GCPtrApicBase);
480	AssertRC(rc);
481	}
482	#endif
483	if (VBOX_SUCCESS(rc))
484	{
485	rc = RTCritSectInit(&pVM->vmm.s.CritSectVMLock);
486	if (VBOX_SUCCESS(rc))
487	{
488	/*
489	* Debug info.
490	*/
491	DBGFR3InfoRegisterInternal(pVM, "ff", "Displays the current Forced actions Flags.", vmmR3InfoFF);
492
493	/*
494	* Statistics.
495	*/
496	STAM_REG(pVM, &pVM->vmm.s.StatRunGC, STAMTYPE_COUNTER, "/VMM/RunGC", STAMUNIT_OCCURENCES, "Number of context switches.");
497	STAM_REG(pVM, &pVM->vmm.s.StatGCRetNormal, STAMTYPE_COUNTER, "/VMM/GCRet/Normal", STAMUNIT_OCCURENCES, "Number of VINF_SUCCESS returns.");
498	STAM_REG(pVM, &pVM->vmm.s.StatGCRetInterrupt, STAMTYPE_COUNTER, "/VMM/GCRet/Interrupt", STAMUNIT_OCCURENCES, "Number of VINF_EM_RAW_INTERRUPT returns.");
499	STAM_REG(pVM, &pVM->vmm.s.StatGCRetInterruptHyper, STAMTYPE_COUNTER, "/VMM/GCRet/InterruptHyper", STAMUNIT_OCCURENCES, "Number of VINF_EM_RAW_INTERRUPT_HYPER returns.");
500	STAM_REG(pVM, &pVM->vmm.s.StatGCRetGuestTrap, STAMTYPE_COUNTER, "/VMM/GCRet/GuestTrap", STAMUNIT_OCCURENCES, "Number of VINF_EM_RAW_GUEST_TRAP returns.");
501	STAM_REG(pVM, &pVM->vmm.s.StatGCRetRingSwitch, STAMTYPE_COUNTER, "/VMM/GCRet/RingSwitch", STAMUNIT_OCCURENCES, "Number of VINF_EM_RAW_RING_SWITCH returns.");
502	STAM_REG(pVM, &pVM->vmm.s.StatGCRetRingSwitchInt, STAMTYPE_COUNTER, "/VMM/GCRet/RingSwitchInt", STAMUNIT_OCCURENCES, "Number of VINF_EM_RAW_RING_SWITCH_INT returns.");
503	STAM_REG(pVM, &pVM->vmm.s.StatGCRetExceptionPrivilege, STAMTYPE_COUNTER, "/VMM/GCRet/ExceptionPrivilege", STAMUNIT_OCCURENCES, "Number of VINF_EM_RAW_EXCEPTION_PRIVILEGED returns.");
504	STAM_REG(pVM, &pVM->vmm.s.StatGCRetStaleSelector, STAMTYPE_COUNTER, "/VMM/GCRet/StaleSelector", STAMUNIT_OCCURENCES, "Number of VINF_EM_RAW_STALE_SELECTOR returns.");
505	STAM_REG(pVM, &pVM->vmm.s.StatGCRetIRETTrap, STAMTYPE_COUNTER, "/VMM/GCRet/IRETTrap", STAMUNIT_OCCURENCES, "Number of VINF_EM_RAW_IRET_TRAP returns.");
506	STAM_REG(pVM, &pVM->vmm.s.StatGCRetEmulate, STAMTYPE_COUNTER, "/VMM/GCRet/Emulate", STAMUNIT_OCCURENCES, "Number of VINF_EM_EXECUTE_INSTRUCTION returns.");
507	STAM_REG(pVM, &pVM->vmm.s.StatGCRetPatchEmulate, STAMTYPE_COUNTER, "/VMM/GCRet/PatchEmulate", STAMUNIT_OCCURENCES, "Number of VINF_PATCH_EMULATE_INSTR returns.");
508	STAM_REG(pVM, &pVM->vmm.s.StatGCRetIORead, STAMTYPE_COUNTER, "/VMM/GCRet/IORead", STAMUNIT_OCCURENCES, "Number of VINF_IOM_HC_IOPORT_READ returns.");
509	STAM_REG(pVM, &pVM->vmm.s.StatGCRetIOWrite, STAMTYPE_COUNTER, "/VMM/GCRet/IOWrite", STAMUNIT_OCCURENCES, "Number of VINF_IOM_HC_IOPORT_WRITE returns.");
510	STAM_REG(pVM, &pVM->vmm.s.StatGCRetMMIORead, STAMTYPE_COUNTER, "/VMM/GCRet/MMIORead", STAMUNIT_OCCURENCES, "Number of VINF_IOM_HC_MMIO_READ returns.");
511	STAM_REG(pVM, &pVM->vmm.s.StatGCRetMMIOWrite, STAMTYPE_COUNTER, "/VMM/GCRet/MMIOWrite", STAMUNIT_OCCURENCES, "Number of VINF_IOM_HC_MMIO_WRITE returns.");
512	STAM_REG(pVM, &pVM->vmm.s.StatGCRetMMIOReadWrite, STAMTYPE_COUNTER, "/VMM/GCRet/MMIOReadWrite", STAMUNIT_OCCURENCES, "Number of VINF_IOM_HC_MMIO_READ_WRITE returns.");
513	STAM_REG(pVM, &pVM->vmm.s.StatGCRetMMIOPatchRead, STAMTYPE_COUNTER, "/VMM/GCRet/MMIOPatchRead", STAMUNIT_OCCURENCES, "Number of VINF_IOM_HC_MMIO_PATCH_READ returns.");
514	STAM_REG(pVM, &pVM->vmm.s.StatGCRetMMIOPatchWrite, STAMTYPE_COUNTER, "/VMM/GCRet/MMIOPatchWrite", STAMUNIT_OCCURENCES, "Number of VINF_IOM_HC_MMIO_PATCH_WRITE returns.");
515	STAM_REG(pVM, &pVM->vmm.s.StatGCRetLDTFault, STAMTYPE_COUNTER, "/VMM/GCRet/LDTFault", STAMUNIT_OCCURENCES, "Number of VINF_EM_EXECUTE_INSTRUCTION_GDT_FAULT returns.");
516	STAM_REG(pVM, &pVM->vmm.s.StatGCRetGDTFault, STAMTYPE_COUNTER, "/VMM/GCRet/GDTFault", STAMUNIT_OCCURENCES, "Number of VINF_EM_EXECUTE_INSTRUCTION_LDT_FAULT returns.");
517	STAM_REG(pVM, &pVM->vmm.s.StatGCRetIDTFault, STAMTYPE_COUNTER, "/VMM/GCRet/IDTFault", STAMUNIT_OCCURENCES, "Number of VINF_EM_EXECUTE_INSTRUCTION_IDT_FAULT returns.");
518	STAM_REG(pVM, &pVM->vmm.s.StatGCRetTSSFault, STAMTYPE_COUNTER, "/VMM/GCRet/TSSFault", STAMUNIT_OCCURENCES, "Number of VINF_EM_EXECUTE_INSTRUCTION_TSS_FAULT returns.");
519	STAM_REG(pVM, &pVM->vmm.s.StatGCRetPDFault, STAMTYPE_COUNTER, "/VMM/GCRet/PDFault", STAMUNIT_OCCURENCES, "Number of VINF_EM_EXECUTE_INSTRUCTION_PD_FAULT returns.");
520	STAM_REG(pVM, &pVM->vmm.s.StatGCRetCSAMTask, STAMTYPE_COUNTER, "/VMM/GCRet/CSAMTask", STAMUNIT_OCCURENCES, "Number of VINF_CSAM_PENDING_ACTION returns.");
521	STAM_REG(pVM, &pVM->vmm.s.StatGCRetSyncCR3, STAMTYPE_COUNTER, "/VMM/GCRet/SyncCR", STAMUNIT_OCCURENCES, "Number of VINF_PGM_SYNC_CR3 returns.");
522	STAM_REG(pVM, &pVM->vmm.s.StatGCRetMisc, STAMTYPE_COUNTER, "/VMM/GCRet/Misc", STAMUNIT_OCCURENCES, "Number of misc returns.");
523	STAM_REG(pVM, &pVM->vmm.s.StatGCRetPatchInt3, STAMTYPE_COUNTER, "/VMM/GCRet/PatchInt3", STAMUNIT_OCCURENCES, "Number of VINF_PATM_PATCH_INT3 returns.");
524	STAM_REG(pVM, &pVM->vmm.s.StatGCRetPatchPF, STAMTYPE_COUNTER, "/VMM/GCRet/PatchPF", STAMUNIT_OCCURENCES, "Number of VINF_PATM_PATCH_TRAP_PF returns.");
525	STAM_REG(pVM, &pVM->vmm.s.StatGCRetPatchGP, STAMTYPE_COUNTER, "/VMM/GCRet/PatchGP", STAMUNIT_OCCURENCES, "Number of VINF_PATM_PATCH_TRAP_GP returns.");
526	STAM_REG(pVM, &pVM->vmm.s.StatGCRetPatchIretIRQ, STAMTYPE_COUNTER, "/VMM/GCRet/PatchIret", STAMUNIT_OCCURENCES, "Number of VINF_PATM_PENDING_IRQ_AFTER_IRET returns.");
527	STAM_REG(pVM, &pVM->vmm.s.StatGCRetPageOverflow, STAMTYPE_COUNTER, "/VMM/GCRet/InvlpgOverflow", STAMUNIT_OCCURENCES, "Number of VERR_REM_FLUSHED_PAGES_OVERFLOW returns.");
528	STAM_REG(pVM, &pVM->vmm.s.StatGCRetRescheduleREM, STAMTYPE_COUNTER, "/VMM/GCRet/ScheduleREM", STAMUNIT_OCCURENCES, "Number of VINF_EM_RESCHEDULE_REM returns.");
529	STAM_REG(pVM, &pVM->vmm.s.StatGCRetToR3, STAMTYPE_COUNTER, "/VMM/GCRet/ToR3", STAMUNIT_OCCURENCES, "Number of VINF_EM_RAW_TO_R3 returns.");
530	STAM_REG(pVM, &pVM->vmm.s.StatGCRetTimerPending, STAMTYPE_COUNTER, "/VMM/GCRet/TimerPending", STAMUNIT_OCCURENCES, "Number of VINF_EM_RAW_TIMER_PENDING returns.");
531	STAM_REG(pVM, &pVM->vmm.s.StatGCRetInterruptPending, STAMTYPE_COUNTER, "/VMM/GCRet/InterruptPending", STAMUNIT_OCCURENCES, "Number of VINF_EM_RAW_INTERRUPT_PENDING returns.");
532	STAM_REG(pVM, &pVM->vmm.s.StatGCRetCallHost, STAMTYPE_COUNTER, "/VMM/GCRet/CallHost/Misc", STAMUNIT_OCCURENCES, "Number of VINF_VMM_CALL_HOST returns.");
533	STAM_REG(pVM, &pVM->vmm.s.StatGCRetPGMGrowRAM, STAMTYPE_COUNTER, "/VMM/GCRet/CallHost/GrowRAM", STAMUNIT_OCCURENCES, "Number of VINF_VMM_CALL_HOST returns.");
534	STAM_REG(pVM, &pVM->vmm.s.StatGCRetPDMLock, STAMTYPE_COUNTER, "/VMM/GCRet/CallHost/PDMLock", STAMUNIT_OCCURENCES, "Number of VINF_VMM_CALL_HOST returns.");
535	STAM_REG(pVM, &pVM->vmm.s.StatGCRetLogFlush, STAMTYPE_COUNTER, "/VMM/GCRet/CallHost/LogFlush", STAMUNIT_OCCURENCES, "Number of VINF_VMM_CALL_HOST returns.");
536	STAM_REG(pVM, &pVM->vmm.s.StatGCRetPDMQueueFlush, STAMTYPE_COUNTER, "/VMM/GCRet/CallHost/QueueFlush", STAMUNIT_OCCURENCES, "Number of VINF_VMM_CALL_HOST returns.");
537	STAM_REG(pVM, &pVM->vmm.s.StatGCRetPGMPoolGrow, STAMTYPE_COUNTER, "/VMM/GCRet/CallHost/PGMPoolGrow",STAMUNIT_OCCURENCES, "Number of VINF_VMM_CALL_HOST returns.");
538	STAM_REG(pVM, &pVM->vmm.s.StatGCRetRemReplay, STAMTYPE_COUNTER, "/VMM/GCRet/CallHost/REMReplay", STAMUNIT_OCCURENCES, "Number of VINF_VMM_CALL_HOST returns.");
539	STAM_REG(pVM, &pVM->vmm.s.StatGCRetVMSetError, STAMTYPE_COUNTER, "/VMM/GCRet/CallHost/VMSetError", STAMUNIT_OCCURENCES, "Number of VINF_VMM_CALL_HOST returns.");
540	STAM_REG(pVM, &pVM->vmm.s.StatGCRetPGMLock, STAMTYPE_COUNTER, "/VMM/GCRet/CallHost/PGMLock", STAMUNIT_OCCURENCES, "Number of VINF_VMM_CALL_HOST returns.");
541	STAM_REG(pVM, &pVM->vmm.s.StatGCRetHyperAssertion, STAMTYPE_COUNTER, "/VMM/GCRet/CallHost/HyperAssert", STAMUNIT_OCCURENCES, "Number of VINF_VMM_CALL_HOST returns.");
542	STAM_REG(pVM, &pVM->vmm.s.StatGCRetPATMDuplicateFn, STAMTYPE_COUNTER, "/VMM/GCRet/PATMDuplicateFn", STAMUNIT_OCCURENCES, "Number of VINF_PATM_DUPLICATE_FUNCTION returns.");
543	STAM_REG(pVM, &pVM->vmm.s.StatGCRetPGMChangeMode, STAMTYPE_COUNTER, "/VMM/GCRet/PGMChangeMode", STAMUNIT_OCCURENCES, "Number of VINF_PGM_CHANGE_MODE returns.");
544	STAM_REG(pVM, &pVM->vmm.s.StatGCRetEmulHlt, STAMTYPE_COUNTER, "/VMM/GCRet/EmulHlt", STAMUNIT_OCCURENCES, "Number of VINF_EM_RAW_EMULATE_INSTR_HLT returns.");
545	STAM_REG(pVM, &pVM->vmm.s.StatGCRetPendingRequest, STAMTYPE_COUNTER, "/VMM/GCRet/PendingRequest", STAMUNIT_OCCURENCES, "Number of VINF_EM_PENDING_REQUEST returns.");
546
547	return VINF_SUCCESS;
548	}
549	AssertRC(rc);
550	}
551	}
552	/** @todo: Need failure cleanup. */
553
554	//more todo in here?
555	//if (VBOX_SUCCESS(rc))
556	//{
557	//}
558	//int rc2 = vmmR3TermCoreCode(pVM);
559	//AssertRC(rc2));
560	}
561
562	return rc;
563	}
564
565
566	/**
567	* Ring-3 init finalizing.
568	*
569	* @returns VBox status code.
570	* @param pVM The VM handle.
571	*/
572	VMMR3DECL(int) VMMR3InitFinalize(PVM pVM)
573	{
574	#ifdef VBOX_STRICT_VMM_STACK
575	/*
576	* Two inaccessible pages at each sides of the stack to catch over/under-flows.
577	*/
578	memset(pVM->vmm.s.pbHCStack - PAGE_SIZE, 0xcc, PAGE_SIZE);
579	PGMMapSetPage(pVM, MMHyperHC2GC(pVM, pVM->vmm.s.pbHCStack - PAGE_SIZE), PAGE_SIZE, 0);
580	RTMemProtect(pVM->vmm.s.pbHCStack - PAGE_SIZE, PAGE_SIZE, RTMEM_PROT_NONE);
581
582	memset(pVM->vmm.s.pbHCStack + VMM_STACK_SIZE, 0xcc, PAGE_SIZE);
583	PGMMapSetPage(pVM, MMHyperHC2GC(pVM, pVM->vmm.s.pbHCStack + VMM_STACK_SIZE), PAGE_SIZE, 0);
584	RTMemProtect(pVM->vmm.s.pbHCStack + VMM_STACK_SIZE, PAGE_SIZE, RTMEM_PROT_NONE);
585	#endif
586
587	/*
588	* Set page attributes to r/w for stack pages.
589	*/
590	int rc = PGMMapSetPage(pVM, pVM->vmm.s.pbGCStack, VMM_STACK_SIZE, X86_PTE_P \| X86_PTE_A \| X86_PTE_D \| X86_PTE_RW);
591	AssertRC(rc);
592	if (VBOX_SUCCESS(rc))
593	{
594	/*
595	* Create the EMT yield timer.
596	*/
597	rc = TMR3TimerCreateInternal(pVM, TMCLOCK_REAL, vmmR3YieldEMT, NULL, "EMT Yielder", &pVM->vmm.s.pYieldTimer);
598	if (VBOX_SUCCESS(rc))
599	rc = TMTimerSetMillies(pVM->vmm.s.pYieldTimer, pVM->vmm.s.cYieldEveryMillies);
600	}
601	#ifdef VBOX_WITH_NMI
602	/*
603	* Map the host APIC into GC - This may be host os specific!
604	*/
605	if (VBOX_SUCCESS(rc))
606	rc = PGMMap(pVM, pVM->vmm.s.GCPtrApicBase, 0xfee00000, PAGE_SIZE,
607	X86_PTE_P \| X86_PTE_RW \| X86_PTE_PWT \| X86_PTE_PCD \| X86_PTE_A \| X86_PTE_D);
608	#endif
609	return rc;
610	}
611
612
613	/**
614	* Initializes the R0 VMM.
615	*
616	* @returns VBox status code.
617	* @param pVM The VM to operate on.
618	*/
619	VMMR3DECL(int) VMMR3InitR0(PVM pVM)
620	{
621	int rc;
622
623	/*
624	* Initialize the ring-0 logger if we haven't done so yet.
625	*/
626	if ( pVM->vmm.s.pR0Logger
627	&& !pVM->vmm.s.pR0Logger->fCreated)
628	{
629	rc = VMMR3UpdateLoggers(pVM);
630	if (VBOX_FAILURE(rc))
631	return rc;
632	}
633
634	/*
635	* Call Ring-0 entry with init code.
636	*/
637	for (;;)
638	{
639	#ifdef NO_SUPCALLR0VMM
640	//rc = VERR_GENERAL_FAILURE;
641	rc = VINF_SUCCESS;
642	#else
643	rc = SUPCallVMMR0Ex(pVM->pVMR0, VMMR0_DO_VMMR0_INIT, VMMGetSvnRev(), NULL);
644	#endif
645	if ( pVM->vmm.s.pR0Logger
646	&& pVM->vmm.s.pR0Logger->Logger.offScratch > 0)
647	RTLogFlushToLogger(&pVM->vmm.s.pR0Logger->Logger, NULL);
648	if (rc != VINF_VMM_CALL_HOST)
649	break;
650	rc = vmmR3ServiceCallHostRequest(pVM);
651	if (VBOX_FAILURE(rc) \|\| (rc >= VINF_EM_FIRST && rc <= VINF_EM_LAST))
652	break;
653	/* Resume R0 */
654	}
655
656	if (VBOX_FAILURE(rc) \|\| (rc >= VINF_EM_FIRST && rc <= VINF_EM_LAST))
657	{
658	LogRel(("R0 init failed, rc=%Vra\n", rc));
659	if (VBOX_SUCCESS(rc))
660	rc = VERR_INTERNAL_ERROR;
661	}
662	return rc;
663	}
664
665
666	/**
667	* Initializes the GC VMM.
668	*
669	* @returns VBox status code.
670	* @param pVM The VM to operate on.
671	*/
672	VMMR3DECL(int) VMMR3InitGC(PVM pVM)
673	{
674	/* In VMX mode, there's no need to init GC. */
675	if (pVM->vmm.s.fSwitcherDisabled)
676	return VINF_SUCCESS;
677
678	/*
679	* Call VMMGCInit():
680	* -# resolve the address.
681	* -# setup stackframe and EIP to use the trampoline.
682	* -# do a generic hypervisor call.
683	*/
684	RTGCPTR32 GCPtrEP;
685	int rc = PDMR3GetSymbolGC(pVM, VMMGC_MAIN_MODULE_NAME, "VMMGCEntry", &GCPtrEP);
686	if (VBOX_SUCCESS(rc))
687	{
688	CPUMHyperSetCtxCore(pVM, NULL);
689	CPUMSetHyperESP(pVM, pVM->vmm.s.pbGCStackBottom); /* Clear the stack. */
690	uint64_t u64TS = RTTimeProgramStartNanoTS();
691	CPUMPushHyper(pVM, (uint32_t)(u64TS >> 32)); /* Param 3: The program startup TS - Hi. */
692	CPUMPushHyper(pVM, (uint32_t)u64TS); /* Param 3: The program startup TS - Lo. */
693	CPUMPushHyper(pVM, VMMGetSvnRev()); /* Param 2: Version argument. */
694	CPUMPushHyper(pVM, VMMGC_DO_VMMGC_INIT); /* Param 1: Operation. */
695	CPUMPushHyper(pVM, pVM->pVMGC); /* Param 0: pVM */
696	CPUMPushHyper(pVM, 3 * sizeof(RTGCPTR32)); /* trampoline param: stacksize. */
697	CPUMPushHyper(pVM, GCPtrEP); /* Call EIP. */
698	CPUMSetHyperEIP(pVM, pVM->vmm.s.pfnGCCallTrampoline);
699
700	for (;;)
701	{
702	#ifdef NO_SUPCALLR0VMM
703	//rc = VERR_GENERAL_FAILURE;
704	rc = VINF_SUCCESS;
705	#else
706	rc = SUPCallVMMR0(pVM->pVMR0, VMMR0_DO_CALL_HYPERVISOR, NULL);
707	#endif
708	#ifdef LOG_ENABLED
709	PRTLOGGERRC pLogger = pVM->vmm.s.pLoggerHC;
710	if ( pLogger
711	&& pLogger->offScratch > 0)
712	RTLogFlushGC(NULL, pLogger);
713	#endif
714	#ifdef VBOX_WITH_GC_AND_R0_RELEASE_LOG
715	PRTLOGGERRC pRelLogger = pVM->vmm.s.pRelLoggerHC;
716	if (RT_UNLIKELY(pRelLogger && pRelLogger->offScratch > 0))
717	RTLogFlushGC(RTLogRelDefaultInstance(), pRelLogger);
718	#endif
719	if (rc != VINF_VMM_CALL_HOST)
720	break;
721	rc = vmmR3ServiceCallHostRequest(pVM);
722	if (VBOX_FAILURE(rc) \|\| (rc >= VINF_EM_FIRST && rc <= VINF_EM_LAST))
723	break;
724	}
725
726	if (VBOX_FAILURE(rc) \|\| (rc >= VINF_EM_FIRST && rc <= VINF_EM_LAST))
727	{
728	VMMR3FatalDump(pVM, rc);
729	if (rc >= VINF_EM_FIRST && rc <= VINF_EM_LAST)
730	rc = VERR_INTERNAL_ERROR;
731	}
732	AssertRC(rc);
733	}
734	return rc;
735	}
736
737
738	/**
739	* Terminate the VMM bits.
740	*
741	* @returns VINF_SUCCESS.
742	* @param pVM The VM handle.
743	*/
744	VMMR3DECL(int) VMMR3Term(PVM pVM)
745	{
746	/*
747	* Call Ring-0 entry with termination code.
748	*/
749	int rc;
750	for (;;)
751	{
752	#ifdef NO_SUPCALLR0VMM
753	//rc = VERR_GENERAL_FAILURE;
754	rc = VINF_SUCCESS;
755	#else
756	rc = SUPCallVMMR0Ex(pVM->pVMR0, VMMR0_DO_VMMR0_TERM, 0, NULL);
757	#endif
758	if ( pVM->vmm.s.pR0Logger
759	&& pVM->vmm.s.pR0Logger->Logger.offScratch > 0)
760	RTLogFlushToLogger(&pVM->vmm.s.pR0Logger->Logger, NULL);
761	if (rc != VINF_VMM_CALL_HOST)
762	break;
763	rc = vmmR3ServiceCallHostRequest(pVM);
764	if (VBOX_FAILURE(rc) \|\| (rc >= VINF_EM_FIRST && rc <= VINF_EM_LAST))
765	break;
766	/* Resume R0 */
767	}
768	if (VBOX_FAILURE(rc) \|\| (rc >= VINF_EM_FIRST && rc <= VINF_EM_LAST))
769	{
770	LogRel(("VMMR3Term: R0 term failed, rc=%Vra. (warning)\n", rc));
771	if (VBOX_SUCCESS(rc))
772	rc = VERR_INTERNAL_ERROR;
773	}
774
775	#ifdef VBOX_STRICT_VMM_STACK
776	/*
777	* Make the two stack guard pages present again.
778	*/
779	RTMemProtect(pVM->vmm.s.pbHCStack - PAGE_SIZE, PAGE_SIZE, RTMEM_PROT_READ \| RTMEM_PROT_WRITE);
780	RTMemProtect(pVM->vmm.s.pbHCStack + VMM_STACK_SIZE, PAGE_SIZE, RTMEM_PROT_READ \| RTMEM_PROT_WRITE);
781	#endif
782	return rc;
783	}
784
785
786	/**
787	* Applies relocations to data and code managed by this
788	* component. This function will be called at init and
789	* whenever the VMM need to relocate it self inside the GC.
790	*
791	* The VMM will need to apply relocations to the core code.
792	*
793	* @param pVM The VM handle.
794	* @param offDelta The relocation delta.
795	*/
796	VMMR3DECL(void) VMMR3Relocate(PVM pVM, RTGCINTPTR offDelta)
797	{
798	LogFlow(("VMMR3Relocate: offDelta=%VGv\n", offDelta));
799
800	/*
801	* Recalc the GC address.
802	*/
803	pVM->vmm.s.pvGCCoreCode = MMHyperHC2GC(pVM, pVM->vmm.s.pvHCCoreCodeR3);
804
805	/*
806	* The stack.
807	*/
808	CPUMSetHyperESP(pVM, CPUMGetHyperESP(pVM) + offDelta);
809	pVM->vmm.s.pbGCStack = MMHyperHC2GC(pVM, pVM->vmm.s.pbHCStack);
810	pVM->vmm.s.pbGCStackBottom = pVM->vmm.s.pbGCStack + VMM_STACK_SIZE;
811
812	/*
813	* All the switchers.
814	*/
815	for (unsigned iSwitcher = 0; iSwitcher < RT_ELEMENTS(s_apSwitchers); iSwitcher++)
816	{
817	PVMMSWITCHERDEF pSwitcher = s_apSwitchers[iSwitcher];
818	if (pSwitcher && pSwitcher->pfnRelocate)
819	{
820	unsigned off = pVM->vmm.s.aoffSwitchers[iSwitcher];
821	pSwitcher->pfnRelocate(pVM,
822	pSwitcher,
823	(uint8_t *)pVM->vmm.s.pvHCCoreCodeR0 + off,
824	(uint8_t *)pVM->vmm.s.pvHCCoreCodeR3 + off,
825	pVM->vmm.s.pvGCCoreCode + off,
826	pVM->vmm.s.HCPhysCoreCode + off);
827	}
828	}
829
830	/*
831	* Recalc the GC address for the current switcher.
832	*/
833	PVMMSWITCHERDEF pSwitcher = s_apSwitchers[pVM->vmm.s.enmSwitcher];
834	RTGCPTR GCPtr = pVM->vmm.s.pvGCCoreCode + pVM->vmm.s.aoffSwitchers[pVM->vmm.s.enmSwitcher];
835	pVM->vmm.s.pfnGCGuestToHost = GCPtr + pSwitcher->offGCGuestToHost;
836	pVM->vmm.s.pfnGCCallTrampoline = GCPtr + pSwitcher->offGCCallTrampoline;
837	pVM->pfnVMMGCGuestToHostAsm = GCPtr + pSwitcher->offGCGuestToHostAsm;
838	pVM->pfnVMMGCGuestToHostAsmHyperCtx = GCPtr + pSwitcher->offGCGuestToHostAsmHyperCtx;
839	pVM->pfnVMMGCGuestToHostAsmGuestCtx = GCPtr + pSwitcher->offGCGuestToHostAsmGuestCtx;
840
841	/*
842	* Get other GC entry points.
843	*/
844	int rc = PDMR3GetSymbolGC(pVM, VMMGC_MAIN_MODULE_NAME, "CPUMGCResumeGuest", &pVM->vmm.s.pfnCPUMGCResumeGuest);
845	AssertReleaseMsgRC(rc, ("CPUMGCResumeGuest not found! rc=%Vra\n", rc));
846
847	rc = PDMR3GetSymbolGC(pVM, VMMGC_MAIN_MODULE_NAME, "CPUMGCResumeGuestV86", &pVM->vmm.s.pfnCPUMGCResumeGuestV86);
848	AssertReleaseMsgRC(rc, ("CPUMGCResumeGuestV86 not found! rc=%Vra\n", rc));
849
850	/*
851	* Update the logger.
852	*/
853	VMMR3UpdateLoggers(pVM);
854	}
855
856
857	/**
858	* Updates the settings for the GC and R0 loggers.
859	*
860	* @returns VBox status code.
861	* @param pVM The VM handle.
862	*/
863	VMMR3DECL(int) VMMR3UpdateLoggers(PVM pVM)
864	{
865	/*
866	* Simply clone the logger instance (for GC).
867	*/
868	int rc = VINF_SUCCESS;
869	RTGCPTR32 GCPtrLoggerFlush = 0;
870
871	if (pVM->vmm.s.pLoggerHC
872	#ifdef VBOX_WITH_GC_AND_R0_RELEASE_LOG
873	\|\| pVM->vmm.s.pRelLoggerHC
874	#endif
875	)
876	{
877	rc = PDMR3GetSymbolGC(pVM, VMMGC_MAIN_MODULE_NAME, "vmmGCLoggerFlush", &GCPtrLoggerFlush);
878	AssertReleaseMsgRC(rc, ("vmmGCLoggerFlush not found! rc=%Vra\n", rc));
879	}
880
881	if (pVM->vmm.s.pLoggerHC)
882	{
883	RTGCPTR32 GCPtrLoggerWrapper = 0;
884	rc = PDMR3GetSymbolGC(pVM, VMMGC_MAIN_MODULE_NAME, "vmmGCLoggerWrapper", &GCPtrLoggerWrapper);
885	AssertReleaseMsgRC(rc, ("vmmGCLoggerWrapper not found! rc=%Vra\n", rc));
886	pVM->vmm.s.pLoggerGC = MMHyperHC2GC(pVM, pVM->vmm.s.pLoggerHC);
887	rc = RTLogCloneRC(NULL /* default */, pVM->vmm.s.pLoggerHC, pVM->vmm.s.cbLoggerGC,
888	GCPtrLoggerWrapper, GCPtrLoggerFlush, RTLOGFLAGS_BUFFERED);
889	AssertReleaseMsgRC(rc, ("RTLogCloneGC failed! rc=%Vra\n", rc));
890	}
891
892	#ifdef VBOX_WITH_GC_AND_R0_RELEASE_LOG
893	if (pVM->vmm.s.pRelLoggerHC)
894	{
895	RTGCPTR32 GCPtrLoggerWrapper = 0;
896	rc = PDMR3GetSymbolGC(pVM, VMMGC_MAIN_MODULE_NAME, "vmmGCRelLoggerWrapper", &GCPtrLoggerWrapper);
897	AssertReleaseMsgRC(rc, ("vmmGCRelLoggerWrapper not found! rc=%Vra\n", rc));
898	pVM->vmm.s.pRelLoggerGC = MMHyperHC2GC(pVM, pVM->vmm.s.pRelLoggerHC);
899	rc = RTLogCloneRC(RTLogRelDefaultInstance(), pVM->vmm.s.pRelLoggerHC, pVM->vmm.s.cbRelLoggerGC,
900	GCPtrLoggerWrapper, GCPtrLoggerFlush, RTLOGFLAGS_BUFFERED);
901	AssertReleaseMsgRC(rc, ("RTLogCloneGC failed! rc=%Vra\n", rc));
902	}
903	#endif /* VBOX_WITH_GC_AND_R0_RELEASE_LOG */
904
905	/*
906	* For the ring-0 EMT logger, we use a per-thread logger
907	* instance in ring-0. Only initialize it once.
908	*/
909	PVMMR0LOGGER pR0Logger = pVM->vmm.s.pR0Logger;
910	if (pR0Logger)
911	{
912	if (!pR0Logger->fCreated)
913	{
914	RTR0PTR pfnLoggerWrapper = NIL_RTR0PTR;
915	rc = PDMR3GetSymbolR0(pVM, VMMR0_MAIN_MODULE_NAME, "vmmR0LoggerWrapper", &pfnLoggerWrapper);
916	AssertReleaseMsgRCReturn(rc, ("VMMLoggerWrapper not found! rc=%Vra\n", rc), rc);
917
918	RTR0PTR pfnLoggerFlush = NIL_RTR0PTR;
919	rc = PDMR3GetSymbolR0(pVM, VMMR0_MAIN_MODULE_NAME, "vmmR0LoggerFlush", &pfnLoggerFlush);
920	AssertReleaseMsgRCReturn(rc, ("VMMLoggerFlush not found! rc=%Vra\n", rc), rc);
921
922	rc = RTLogCreateForR0(&pR0Logger->Logger, pR0Logger->cbLogger,
923	(PFNRTLOGGER )&pfnLoggerWrapper, (PFNRTLOGFLUSH )&pfnLoggerFlush,
924	RTLOGFLAGS_BUFFERED, RTLOGDEST_DUMMY);
925	AssertReleaseMsgRCReturn(rc, ("RTLogCloneGC failed! rc=%Vra\n", rc), rc);
926	pR0Logger->fCreated = true;
927	}
928
929	rc = RTLogCopyGroupsAndFlags(&pR0Logger->Logger, NULL /* default */, pVM->vmm.s.pLoggerHC->fFlags, RTLOGFLAGS_BUFFERED);
930	AssertRC(rc);
931	}
932
933	return rc;
934	}
935
936
937	/**
938	* Generic switch code relocator.
939	*
940	* @param pVM The VM handle.
941	* @param pSwitcher The switcher definition.
942	* @param pu8CodeR3 Pointer to the core code block for the switcher, ring-3 mapping.
943	* @param pu8CodeR0 Pointer to the core code block for the switcher, ring-0 mapping.
944	* @param GCPtrCode The guest context address corresponding to pu8Code.
945	* @param u32IDCode The identity mapped (ID) address corresponding to pu8Code.
946	* @param SelCS The hypervisor CS selector.
947	* @param SelDS The hypervisor DS selector.
948	* @param SelTSS The hypervisor TSS selector.
949	* @param GCPtrGDT The GC address of the hypervisor GDT.
950	* @param SelCS64 The 64-bit mode hypervisor CS selector.
951	*/
952	static void vmmR3SwitcherGenericRelocate(PVM pVM, PVMMSWITCHERDEF pSwitcher, uint8_t pu8CodeR0, uint8_t pu8CodeR3, RTGCPTR GCPtrCode, uint32_t u32IDCode,
953	RTSEL SelCS, RTSEL SelDS, RTSEL SelTSS, RTGCPTR GCPtrGDT, RTSEL SelCS64)
954	{
955	union
956	{
957	const uint8_t *pu8;
958	const uint16_t *pu16;
959	const uint32_t *pu32;
960	const uint64_t *pu64;
961	const void *pv;
962	uintptr_t u;
963	} u;
964	u.pv = pSwitcher->pvFixups;
965
966	/*
967	* Process fixups.
968	*/
969	uint8_t u8;
970	while ((u8 = *u.pu8++) != FIX_THE_END)
971	{
972	/*
973	* Get the source (where to write the fixup).
974	*/
975	uint32_t offSrc = *u.pu32++;
976	Assert(offSrc < pSwitcher->cbCode);
977	union
978	{
979	uint8_t *pu8;
980	uint16_t *pu16;
981	uint32_t *pu32;
982	uint64_t *pu64;
983	uintptr_t u;
984	} uSrc;
985	uSrc.pu8 = pu8CodeR3 + offSrc;
986
987	/* The fixup target and method depends on the type. */
988	switch (u8)
989	{
990	/*
991	* 32-bit relative, source in HC and target in GC.
992	*/
993	case FIX_HC_2_GC_NEAR_REL:
994	{
995	Assert(offSrc - pSwitcher->offHCCode0 < pSwitcher->cbHCCode0 \|\| offSrc - pSwitcher->offHCCode1 < pSwitcher->cbHCCode1);
996	uint32_t offTrg = *u.pu32++;
997	Assert(offTrg - pSwitcher->offGCCode < pSwitcher->cbGCCode);
998	*uSrc.pu32 = (uint32_t)((GCPtrCode + offTrg) - (uSrc.u + 4));
999	break;
1000	}
1001
1002	/*
1003	* 32-bit relative, source in HC and target in ID.
1004	*/
1005	case FIX_HC_2_ID_NEAR_REL:
1006	{
1007	Assert(offSrc - pSwitcher->offHCCode0 < pSwitcher->cbHCCode0 \|\| offSrc - pSwitcher->offHCCode1 < pSwitcher->cbHCCode1);
1008	uint32_t offTrg = *u.pu32++;
1009	Assert(offTrg - pSwitcher->offIDCode0 < pSwitcher->cbIDCode0 \|\| offTrg - pSwitcher->offIDCode1 < pSwitcher->cbIDCode1);
1010	*uSrc.pu32 = (uint32_t)((u32IDCode + offTrg) - ((uintptr_t)pu8CodeR0 + offSrc + 4));
1011	break;
1012	}
1013
1014	/*
1015	* 32-bit relative, source in GC and target in HC.
1016	*/
1017	case FIX_GC_2_HC_NEAR_REL:
1018	{
1019	Assert(offSrc - pSwitcher->offGCCode < pSwitcher->cbGCCode);
1020	uint32_t offTrg = *u.pu32++;
1021	Assert(offTrg - pSwitcher->offHCCode0 < pSwitcher->cbHCCode0 \|\| offTrg - pSwitcher->offHCCode1 < pSwitcher->cbHCCode1);
1022	*uSrc.pu32 = (uint32_t)(((uintptr_t)pu8CodeR0 + offTrg) - (GCPtrCode + offSrc + 4));
1023	break;
1024	}
1025
1026	/*
1027	* 32-bit relative, source in GC and target in ID.
1028	*/
1029	case FIX_GC_2_ID_NEAR_REL:
1030	{
1031	Assert(offSrc - pSwitcher->offGCCode < pSwitcher->cbGCCode);
1032	uint32_t offTrg = *u.pu32++;
1033	Assert(offTrg - pSwitcher->offIDCode0 < pSwitcher->cbIDCode0 \|\| offTrg - pSwitcher->offIDCode1 < pSwitcher->cbIDCode1);
1034	*uSrc.pu32 = (uint32_t)((u32IDCode + offTrg) - (GCPtrCode + offSrc + 4));
1035	break;
1036	}
1037
1038	/*
1039	* 32-bit relative, source in ID and target in HC.
1040	*/
1041	case FIX_ID_2_HC_NEAR_REL:
1042	{
1043	Assert(offSrc - pSwitcher->offIDCode0 < pSwitcher->cbIDCode0 \|\| offSrc - pSwitcher->offIDCode1 < pSwitcher->cbIDCode1);
1044	uint32_t offTrg = *u.pu32++;
1045	Assert(offTrg - pSwitcher->offHCCode0 < pSwitcher->cbHCCode0 \|\| offTrg - pSwitcher->offHCCode1 < pSwitcher->cbHCCode1);
1046	*uSrc.pu32 = (uint32_t)(((uintptr_t)pu8CodeR0 + offTrg) - (u32IDCode + offSrc + 4));
1047	break;
1048	}
1049
1050	/*
1051	* 32-bit relative, source in ID and target in HC.
1052	*/
1053	case FIX_ID_2_GC_NEAR_REL:
1054	{
1055	Assert(offSrc - pSwitcher->offIDCode0 < pSwitcher->cbIDCode0 \|\| offSrc - pSwitcher->offIDCode1 < pSwitcher->cbIDCode1);
1056	uint32_t offTrg = *u.pu32++;
1057	Assert(offTrg - pSwitcher->offGCCode < pSwitcher->cbGCCode);
1058	*uSrc.pu32 = (uint32_t)((GCPtrCode + offTrg) - (u32IDCode + offSrc + 4));
1059	break;
1060	}
1061
1062	/*
1063	* 16:32 far jump, target in GC.
1064	*/
1065	case FIX_GC_FAR32:
1066	{
1067	uint32_t offTrg = *u.pu32++;
1068	Assert(offTrg - pSwitcher->offGCCode < pSwitcher->cbGCCode);
1069	*uSrc.pu32++ = (uint32_t)(GCPtrCode + offTrg);
1070	*uSrc.pu16++ = SelCS;
1071	break;
1072	}
1073
1074	/*
1075	* Make 32-bit GC pointer given CPUM offset.
1076	*/
1077	case FIX_GC_CPUM_OFF:
1078	{
1079	uint32_t offCPUM = *u.pu32++;
1080	Assert(offCPUM < sizeof(pVM->cpum));
1081	*uSrc.pu32 = (uint32_t)(VM_GUEST_ADDR(pVM, &pVM->cpum) + offCPUM);
1082	break;
1083	}
1084
1085	/*
1086	* Make 32-bit GC pointer given VM offset.
1087	*/
1088	case FIX_GC_VM_OFF:
1089	{
1090	uint32_t offVM = *u.pu32++;
1091	Assert(offVM < sizeof(VM));
1092	*uSrc.pu32 = (uint32_t)(VM_GUEST_ADDR(pVM, pVM) + offVM);
1093	break;
1094	}
1095
1096	/*
1097	* Make 32-bit HC pointer given CPUM offset.
1098	*/
1099	case FIX_HC_CPUM_OFF:
1100	{
1101	uint32_t offCPUM = *u.pu32++;
1102	Assert(offCPUM < sizeof(pVM->cpum));
1103	*uSrc.pu32 = (uint32_t)pVM->pVMR0 + RT_OFFSETOF(VM, cpum) + offCPUM;
1104	break;
1105	}
1106
1107	/*
1108	* Make 32-bit R0 pointer given VM offset.
1109	*/
1110	case FIX_HC_VM_OFF:
1111	{
1112	uint32_t offVM = *u.pu32++;
1113	Assert(offVM < sizeof(VM));
1114	*uSrc.pu32 = (uint32_t)pVM->pVMR0 + offVM;
1115	break;
1116	}
1117
1118	/*
1119	* Store the 32-Bit CR3 (32-bit) for the intermediate memory context.
1120	*/
1121	case FIX_INTER_32BIT_CR3:
1122	{
1123
1124	*uSrc.pu32 = PGMGetInter32BitCR3(pVM);
1125	break;
1126	}
1127
1128	/*
1129	* Store the PAE CR3 (32-bit) for the intermediate memory context.
1130	*/
1131	case FIX_INTER_PAE_CR3:
1132	{
1133
1134	*uSrc.pu32 = PGMGetInterPaeCR3(pVM);
1135	break;
1136	}
1137
1138	/*
1139	* Store the AMD64 CR3 (32-bit) for the intermediate memory context.
1140	*/
1141	case FIX_INTER_AMD64_CR3:
1142	{
1143
1144	*uSrc.pu32 = PGMGetInterAmd64CR3(pVM);
1145	break;
1146	}
1147
1148	/*
1149	* Store the 32-Bit CR3 (32-bit) for the hypervisor (shadow) memory context.
1150	*/
1151	case FIX_HYPER_32BIT_CR3:
1152	{
1153
1154	*uSrc.pu32 = PGMGetHyper32BitCR3(pVM);
1155	break;
1156	}
1157
1158	/*
1159	* Store the PAE CR3 (32-bit) for the hypervisor (shadow) memory context.
1160	*/
1161	case FIX_HYPER_PAE_CR3:
1162	{
1163
1164	*uSrc.pu32 = PGMGetHyperPaeCR3(pVM);
1165	break;
1166	}
1167
1168	/*
1169	* Store the AMD64 CR3 (32-bit) for the hypervisor (shadow) memory context.
1170	*/
1171	case FIX_HYPER_AMD64_CR3:
1172	{
1173
1174	*uSrc.pu32 = PGMGetHyperAmd64CR3(pVM);
1175	break;
1176	}
1177
1178	/*
1179	* Store Hypervisor CS (16-bit).
1180	*/
1181	case FIX_HYPER_CS:
1182	{
1183	*uSrc.pu16 = SelCS;
1184	break;
1185	}
1186
1187	/*
1188	* Store Hypervisor DS (16-bit).
1189	*/
1190	case FIX_HYPER_DS:
1191	{
1192	*uSrc.pu16 = SelDS;
1193	break;
1194	}
1195
1196	/*
1197	* Store Hypervisor TSS (16-bit).
1198	*/
1199	case FIX_HYPER_TSS:
1200	{
1201	*uSrc.pu16 = SelTSS;
1202	break;
1203	}
1204
1205	/*
1206	* Store the 32-bit GC address of the 2nd dword of the TSS descriptor (in the GDT).
1207	*/
1208	case FIX_GC_TSS_GDTE_DW2:
1209	{
1210	RTGCPTR GCPtr = GCPtrGDT + (SelTSS & ~7) + 4;
1211	*uSrc.pu32 = (uint32_t)GCPtr;
1212	break;
1213	}
1214
1215
1216	///@todo case FIX_CR4_MASK:
1217	///@todo case FIX_CR4_OSFSXR:
1218
1219	/*
1220	* Insert relative jump to specified target it FXSAVE/FXRSTOR isn't supported by the cpu.
1221	*/
1222	case FIX_NO_FXSAVE_JMP:
1223	{
1224	uint32_t offTrg = *u.pu32++;
1225	Assert(offTrg < pSwitcher->cbCode);
1226	if (!CPUMSupportsFXSR(pVM))
1227	{
1228	uSrc.pu8++ = 0xe9; / jmp rel32 */
1229	*uSrc.pu32++ = offTrg - (offSrc + 5);
1230	}
1231	else
1232	{
1233	uSrc.pu8++ = ((uint8_t *)pSwitcher->pvCode + offSrc);
1234	uSrc.pu32++ = (uint32_t )((uint8_t )pSwitcher->pvCode + offSrc + 1);
1235	}
1236	break;
1237	}
1238
1239	/*
1240	* Insert relative jump to specified target it SYSENTER isn't used by the host.
1241	*/
1242	case FIX_NO_SYSENTER_JMP:
1243	{
1244	uint32_t offTrg = *u.pu32++;
1245	Assert(offTrg < pSwitcher->cbCode);
1246	if (!CPUMIsHostUsingSysEnter(pVM))
1247	{
1248	uSrc.pu8++ = 0xe9; / jmp rel32 */
1249	*uSrc.pu32++ = offTrg - (offSrc + 5);
1250	}
1251	else
1252	{
1253	uSrc.pu8++ = ((uint8_t *)pSwitcher->pvCode + offSrc);
1254	uSrc.pu32++ = (uint32_t )((uint8_t )pSwitcher->pvCode + offSrc + 1);
1255	}
1256	break;
1257	}
1258
1259	/*
1260	* Insert relative jump to specified target it SYSENTER isn't used by the host.
1261	*/
1262	case FIX_NO_SYSCALL_JMP:
1263	{
1264	uint32_t offTrg = *u.pu32++;
1265	Assert(offTrg < pSwitcher->cbCode);
1266	if (!CPUMIsHostUsingSysEnter(pVM))
1267	{
1268	uSrc.pu8++ = 0xe9; / jmp rel32 */
1269	*uSrc.pu32++ = offTrg - (offSrc + 5);
1270	}
1271	else
1272	{
1273	uSrc.pu8++ = ((uint8_t *)pSwitcher->pvCode + offSrc);
1274	uSrc.pu32++ = (uint32_t )((uint8_t )pSwitcher->pvCode + offSrc + 1);
1275	}
1276	break;
1277	}
1278
1279	/*
1280	* 32-bit HC pointer fixup to (HC) target within the code (32-bit offset).
1281	*/
1282	case FIX_HC_32BIT:
1283	{
1284	uint32_t offTrg = *u.pu32++;
1285	Assert(offSrc < pSwitcher->cbCode);
1286	Assert(offTrg - pSwitcher->offHCCode0 < pSwitcher->cbHCCode0 \|\| offTrg - pSwitcher->offHCCode1 < pSwitcher->cbHCCode1);
1287	*uSrc.pu32 = (uintptr_t)pu8CodeR0 + offTrg;
1288	break;
1289	}
1290
1291	#if defined(RT_ARCH_AMD64) \|\| defined(VBOX_WITH_HYBIRD_32BIT_KERNEL)
1292	/*
1293	* 64-bit HC pointer fixup to (HC) target within the code (32-bit offset).
1294	*/
1295	case FIX_HC_64BIT:
1296	{
1297	uint32_t offTrg = *u.pu32++;
1298	Assert(offSrc < pSwitcher->cbCode);
1299	Assert(offTrg - pSwitcher->offHCCode0 < pSwitcher->cbHCCode0 \|\| offTrg - pSwitcher->offHCCode1 < pSwitcher->cbHCCode1);
1300	*uSrc.pu64 = (uintptr_t)pu8CodeR0 + offTrg;
1301	break;
1302	}
1303
1304	/*
1305	* 64-bit HC Code Selector (no argument).
1306	*/
1307	case FIX_HC_64BIT_CS:
1308	{
1309	Assert(offSrc < pSwitcher->cbCode);
1310	#if defined(RT_OS_DARWIN) && defined(VBOX_WITH_HYBIRD_32BIT_KERNEL)
1311	uSrc.pu16 = 0x80; / KERNEL64_CS from i386/seg.h */
1312	#else
1313	AssertFatalMsgFailed(("FIX_HC_64BIT_CS not implemented for this host\n"));
1314	#endif
1315	break;
1316	}
1317
1318	/*
1319	* 64-bit HC pointer to the CPUM instance data (no argument).
1320	*/
1321	case FIX_HC_64BIT_CPUM:
1322	{
1323	Assert(offSrc < pSwitcher->cbCode);
1324	*uSrc.pu64 = pVM->pVMR0 + RT_OFFSETOF(VM, cpum);
1325	break;
1326	}
1327	#endif
1328
1329	/*
1330	* 32-bit ID pointer to (ID) target within the code (32-bit offset).
1331	*/
1332	case FIX_ID_32BIT:
1333	{
1334	uint32_t offTrg = *u.pu32++;
1335	Assert(offSrc < pSwitcher->cbCode);
1336	Assert(offTrg - pSwitcher->offIDCode0 < pSwitcher->cbIDCode0 \|\| offTrg - pSwitcher->offIDCode1 < pSwitcher->cbIDCode1);
1337	*uSrc.pu32 = u32IDCode + offTrg;
1338	break;
1339	}
1340
1341	/*
1342	* 64-bit ID pointer to (ID) target within the code (32-bit offset).
1343	*/
1344	case FIX_ID_64BIT:
1345	{
1346	uint32_t offTrg = *u.pu32++;
1347	Assert(offSrc < pSwitcher->cbCode);
1348	Assert(offTrg - pSwitcher->offIDCode0 < pSwitcher->cbIDCode0 \|\| offTrg - pSwitcher->offIDCode1 < pSwitcher->cbIDCode1);
1349	*uSrc.pu64 = u32IDCode + offTrg;
1350	break;
1351	}
1352
1353	/*
1354	* Far 16:32 ID pointer to 64-bit mode (ID) target within the code (32-bit offset).
1355	*/
1356	case FIX_ID_FAR32_TO_64BIT_MODE:
1357	{
1358	uint32_t offTrg = *u.pu32++;
1359	Assert(offSrc < pSwitcher->cbCode);
1360	Assert(offTrg - pSwitcher->offIDCode0 < pSwitcher->cbIDCode0 \|\| offTrg - pSwitcher->offIDCode1 < pSwitcher->cbIDCode1);
1361	*uSrc.pu32++ = u32IDCode + offTrg;
1362	*uSrc.pu16 = SelCS64;
1363	AssertRelease(SelCS64);
1364	break;
1365	}
1366
1367	#ifdef VBOX_WITH_NMI
1368	/*
1369	* 32-bit address to the APIC base.
1370	*/
1371	case FIX_GC_APIC_BASE_32BIT:
1372	{
1373	*uSrc.pu32 = pVM->vmm.s.GCPtrApicBase;
1374	break;
1375	}
1376	#endif
1377
1378	default:
1379	AssertReleaseMsgFailed(("Unknown fixup %d in switcher %s\n", u8, pSwitcher->pszDesc));
1380	break;
1381	}
1382	}
1383
1384	#ifdef LOG_ENABLED
1385	/*
1386	* If Log2 is enabled disassemble the switcher code.
1387	*
1388	* The switcher code have 1-2 HC parts, 1 GC part and 0-2 ID parts.
1389	*/
1390	if (LogIs2Enabled())
1391	{
1392	RTLogPrintf("* Disassembly of switcher %d '%s' %#x bytes *\n"
1393	" pu8CodeR0 = %p\n"
1394	" pu8CodeR3 = %p\n"
1395	" GCPtrCode = %VGv\n"
1396	" u32IDCode = %08x\n"
1397	" pVMGC = %VGv\n"
1398	" pCPUMGC = %VGv\n"
1399	" pVMHC = %p\n"
1400	" pCPUMHC = %p\n"
1401	" GCPtrGDT = %VGv\n"
1402	" InterCR3s = %08x, %08x, %08x (32-Bit, PAE, AMD64)\n"
1403	" HyperCR3s = %08x, %08x, %08x (32-Bit, PAE, AMD64)\n"
1404	" SelCS = %04x\n"
1405	" SelDS = %04x\n"
1406	" SelCS64 = %04x\n"
1407	" SelTSS = %04x\n",
1408	pSwitcher->enmType, pSwitcher->pszDesc, pSwitcher->cbCode,
1409	pu8CodeR0, pu8CodeR3, GCPtrCode, u32IDCode, VM_GUEST_ADDR(pVM, pVM),
1410	VM_GUEST_ADDR(pVM, &pVM->cpum), pVM, &pVM->cpum,
1411	GCPtrGDT,
1412	PGMGetHyper32BitCR3(pVM), PGMGetHyperPaeCR3(pVM), PGMGetHyperAmd64CR3(pVM),
1413	PGMGetInter32BitCR3(pVM), PGMGetInterPaeCR3(pVM), PGMGetInterAmd64CR3(pVM),
1414	SelCS, SelDS, SelCS64, SelTSS);
1415
1416	uint32_t offCode = 0;
1417	while (offCode < pSwitcher->cbCode)
1418	{
1419	/*
1420	* Figure out where this is.
1421	*/
1422	const char *pszDesc = NULL;
1423	RTUINTPTR uBase;
1424	uint32_t cbCode;
1425	if (offCode - pSwitcher->offHCCode0 < pSwitcher->cbHCCode0)
1426	{
1427	pszDesc = "HCCode0";
1428	uBase = (RTUINTPTR)pu8CodeR0;
1429	offCode = pSwitcher->offHCCode0;
1430	cbCode = pSwitcher->cbHCCode0;
1431	}
1432	else if (offCode - pSwitcher->offHCCode1 < pSwitcher->cbHCCode1)
1433	{
1434	pszDesc = "HCCode1";
1435	uBase = (RTUINTPTR)pu8CodeR0;
1436	offCode = pSwitcher->offHCCode1;
1437	cbCode = pSwitcher->cbHCCode1;
1438	}
1439	else if (offCode - pSwitcher->offGCCode < pSwitcher->cbGCCode)
1440	{
1441	pszDesc = "GCCode";
1442	uBase = GCPtrCode;
1443	offCode = pSwitcher->offGCCode;
1444	cbCode = pSwitcher->cbGCCode;
1445	}
1446	else if (offCode - pSwitcher->offIDCode0 < pSwitcher->cbIDCode0)
1447	{
1448	pszDesc = "IDCode0";
1449	uBase = u32IDCode;
1450	offCode = pSwitcher->offIDCode0;
1451	cbCode = pSwitcher->cbIDCode0;
1452	}
1453	else if (offCode - pSwitcher->offIDCode1 < pSwitcher->cbIDCode1)
1454	{
1455	pszDesc = "IDCode1";
1456	uBase = u32IDCode;
1457	offCode = pSwitcher->offIDCode1;
1458	cbCode = pSwitcher->cbIDCode1;
1459	}
1460	else
1461	{
1462	RTLogPrintf(" %04x: %02x '%c' (nowhere)\n",
1463	offCode, pu8CodeR3[offCode], isprint(pu8CodeR3[offCode]) ? pu8CodeR3[offCode] : ' ');
1464	offCode++;
1465	continue;
1466	}
1467
1468	/*
1469	* Disassemble it.
1470	*/
1471	RTLogPrintf(" %s: offCode=%#x cbCode=%#x\n", pszDesc, offCode, cbCode);
1472	DISCPUSTATE Cpu;
1473
1474	memset(&Cpu, 0, sizeof(Cpu));
1475	Cpu.mode = CPUMODE_32BIT;
1476	while (cbCode > 0)
1477	{
1478	/* try label it */
1479	if (pSwitcher->offR0HostToGuest == offCode)
1480	RTLogPrintf(" *R0HostToGuest:\n");
1481	if (pSwitcher->offGCGuestToHost == offCode)
1482	RTLogPrintf(" *GCGuestToHost:\n");
1483	if (pSwitcher->offGCCallTrampoline == offCode)
1484	RTLogPrintf(" *GCCallTrampoline:\n");
1485	if (pSwitcher->offGCGuestToHostAsm == offCode)
1486	RTLogPrintf(" *GCGuestToHostAsm:\n");
1487	if (pSwitcher->offGCGuestToHostAsmHyperCtx == offCode)
1488	RTLogPrintf(" *GCGuestToHostAsmHyperCtx:\n");
1489	if (pSwitcher->offGCGuestToHostAsmGuestCtx == offCode)
1490	RTLogPrintf(" *GCGuestToHostAsmGuestCtx:\n");
1491
1492	/* disas */
1493	uint32_t cbInstr = 0;
1494	char szDisas[256];
1495	if (RT_SUCCESS(DISInstr(&Cpu, (RTUINTPTR)pu8CodeR3 + offCode, uBase - (RTUINTPTR)pu8CodeR3, &cbInstr, szDisas)))
1496	RTLogPrintf(" %04x: %s", offCode, szDisas); //for whatever reason szDisas includes '\n'.
1497	else
1498	{
1499	RTLogPrintf(" %04x: %02x '%c'\n",
1500	offCode, pu8CodeR3[offCode], isprint(pu8CodeR3[offCode]) ? pu8CodeR3[offCode] : ' ');
1501	cbInstr = 1;
1502	}
1503	offCode += cbInstr;
1504	cbCode -= RT_MIN(cbInstr, cbCode);
1505	}
1506	}
1507	}
1508	#endif
1509	}
1510
1511
1512	/**
1513	* Relocator for the 32-Bit to 32-Bit world switcher.
1514	*/
1515	DECLCALLBACK(void) vmmR3Switcher32BitTo32Bit_Relocate(PVM pVM, PVMMSWITCHERDEF pSwitcher, uint8_t pu8CodeR0, uint8_t pu8CodeR3, RTGCPTR GCPtrCode, uint32_t u32IDCode)
1516	{
1517	vmmR3SwitcherGenericRelocate(pVM, pSwitcher, pu8CodeR0, pu8CodeR3, GCPtrCode, u32IDCode,
1518	SELMGetHyperCS(pVM), SELMGetHyperDS(pVM), SELMGetHyperTSS(pVM), SELMGetHyperGDT(pVM), 0);
1519	}
1520
1521
1522	/**
1523	* Relocator for the 32-Bit to PAE world switcher.
1524	*/
1525	DECLCALLBACK(void) vmmR3Switcher32BitToPAE_Relocate(PVM pVM, PVMMSWITCHERDEF pSwitcher, uint8_t pu8CodeR0, uint8_t pu8CodeR3, RTGCPTR GCPtrCode, uint32_t u32IDCode)
1526	{
1527	vmmR3SwitcherGenericRelocate(pVM, pSwitcher, pu8CodeR0, pu8CodeR3, GCPtrCode, u32IDCode,
1528	SELMGetHyperCS(pVM), SELMGetHyperDS(pVM), SELMGetHyperTSS(pVM), SELMGetHyperGDT(pVM), 0);
1529	}
1530
1531
1532	/**
1533	* Relocator for the PAE to 32-Bit world switcher.
1534	*/
1535	DECLCALLBACK(void) vmmR3SwitcherPAETo32Bit_Relocate(PVM pVM, PVMMSWITCHERDEF pSwitcher, uint8_t pu8CodeR0, uint8_t pu8CodeR3, RTGCPTR GCPtrCode, uint32_t u32IDCode)
1536	{
1537	vmmR3SwitcherGenericRelocate(pVM, pSwitcher, pu8CodeR0, pu8CodeR3, GCPtrCode, u32IDCode,
1538	SELMGetHyperCS(pVM), SELMGetHyperDS(pVM), SELMGetHyperTSS(pVM), SELMGetHyperGDT(pVM), 0);
1539	}
1540
1541
1542	/**
1543	* Relocator for the PAE to PAE world switcher.
1544	*/
1545	DECLCALLBACK(void) vmmR3SwitcherPAEToPAE_Relocate(PVM pVM, PVMMSWITCHERDEF pSwitcher, uint8_t pu8CodeR0, uint8_t pu8CodeR3, RTGCPTR GCPtrCode, uint32_t u32IDCode)
1546	{
1547	vmmR3SwitcherGenericRelocate(pVM, pSwitcher, pu8CodeR0, pu8CodeR3, GCPtrCode, u32IDCode,
1548	SELMGetHyperCS(pVM), SELMGetHyperDS(pVM), SELMGetHyperTSS(pVM), SELMGetHyperGDT(pVM), 0);
1549	}
1550
1551
1552	/**
1553	* Relocator for the AMD64 to PAE world switcher.
1554	*/
1555	DECLCALLBACK(void) vmmR3SwitcherAMD64ToPAE_Relocate(PVM pVM, PVMMSWITCHERDEF pSwitcher, uint8_t pu8CodeR0, uint8_t pu8CodeR3, RTGCPTR GCPtrCode, uint32_t u32IDCode)
1556	{
1557	vmmR3SwitcherGenericRelocate(pVM, pSwitcher, pu8CodeR0, pu8CodeR3, GCPtrCode, u32IDCode,
1558	SELMGetHyperCS(pVM), SELMGetHyperDS(pVM), SELMGetHyperTSS(pVM), SELMGetHyperGDT(pVM), SELMGetHyperCS64(pVM));
1559	}
1560
1561
1562	/**
1563	* Gets the pointer to g_szRTAssertMsg1 in GC.
1564	* @returns Pointer to VMMGC::g_szRTAssertMsg1.
1565	* Returns NULL if not present.
1566	* @param pVM The VM handle.
1567	*/
1568	VMMR3DECL(const char *) VMMR3GetGCAssertMsg1(PVM pVM)
1569	{
1570	RTGCPTR32 GCPtr;
1571	int rc = PDMR3GetSymbolGC(pVM, NULL, "g_szRTAssertMsg1", &GCPtr);
1572	if (VBOX_SUCCESS(rc))
1573	return (const char *)MMHyperGC2HC(pVM, GCPtr);
1574	return NULL;
1575	}
1576
1577
1578	/**
1579	* Gets the pointer to g_szRTAssertMsg2 in GC.
1580	* @returns Pointer to VMMGC::g_szRTAssertMsg2.
1581	* Returns NULL if not present.
1582	* @param pVM The VM handle.
1583	*/
1584	VMMR3DECL(const char *) VMMR3GetGCAssertMsg2(PVM pVM)
1585	{
1586	RTGCPTR32 GCPtr;
1587	int rc = PDMR3GetSymbolGC(pVM, NULL, "g_szRTAssertMsg2", &GCPtr);
1588	if (VBOX_SUCCESS(rc))
1589	return (const char *)MMHyperGC2HC(pVM, GCPtr);
1590	return NULL;
1591	}
1592
1593
1594	/**
1595	* Execute state save operation.
1596	*
1597	* @returns VBox status code.
1598	* @param pVM VM Handle.
1599	* @param pSSM SSM operation handle.
1600	*/
1601	static DECLCALLBACK(int) vmmR3Save(PVM pVM, PSSMHANDLE pSSM)
1602	{
1603	LogFlow(("vmmR3Save:\n"));
1604
1605	/*
1606	* The hypervisor stack.
1607	*/
1608	SSMR3PutRCPtr(pSSM, pVM->vmm.s.pbGCStackBottom);
1609	RTRCPTR GCPtrESP = CPUMGetHyperESP(pVM);
1610	AssertMsg(pVM->vmm.s.pbGCStackBottom - GCPtrESP <= VMM_STACK_SIZE, ("Bottom %VGv ESP=%VGv\n", pVM->vmm.s.pbGCStackBottom, GCPtrESP));
1611	SSMR3PutRCPtr(pSSM, GCPtrESP);
1612	SSMR3PutMem(pSSM, pVM->vmm.s.pbHCStack, VMM_STACK_SIZE);
1613	return SSMR3PutU32(pSSM, ~0); /* terminator */
1614	}
1615
1616
1617	/**
1618	* Execute state load operation.
1619	*
1620	* @returns VBox status code.
1621	* @param pVM VM Handle.
1622	* @param pSSM SSM operation handle.
1623	* @param u32Version Data layout version.
1624	*/
1625	static DECLCALLBACK(int) vmmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t u32Version)
1626	{
1627	LogFlow(("vmmR3Load:\n"));
1628
1629	/*
1630	* Validate version.
1631	*/
1632	if (u32Version != VMM_SAVED_STATE_VERSION)
1633	{
1634	AssertMsgFailed(("vmmR3Load: Invalid version u32Version=%d!\n", u32Version));
1635	return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
1636	}
1637
1638	/*
1639	* Check that the stack is in the same place, or that it's fearly empty.
1640	*/
1641	RTRCPTR GCPtrStackBottom;
1642	SSMR3GetRCPtr(pSSM, &GCPtrStackBottom);
1643	RTRCPTR GCPtrESP;
1644	int rc = SSMR3GetRCPtr(pSSM, &GCPtrESP);
1645	if (VBOX_FAILURE(rc))
1646	return rc;
1647
1648	/* Previously we checked if the location of the stack was identical or that the stack was empty.
1649	* This is not required as we can never initiate a save when GC context code performs a ring 3 call.
1650	*/
1651	/* restore the stack. (not necessary; just consistency checking) */
1652	SSMR3GetMem(pSSM, pVM->vmm.s.pbHCStack, VMM_STACK_SIZE);
1653
1654	/* terminator */
1655	uint32_t u32;
1656	rc = SSMR3GetU32(pSSM, &u32);
1657	if (VBOX_FAILURE(rc))
1658	return rc;
1659	if (u32 != ~0U)
1660	{
1661	AssertMsgFailed(("u32=%#x\n", u32));
1662	return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
1663	}
1664	return VINF_SUCCESS;
1665	}
1666
1667
1668	/**
1669	* Selects the switcher to be used for switching to GC.
1670	*
1671	* @returns VBox status code.
1672	* @param pVM VM handle.
1673	* @param enmSwitcher The new switcher.
1674	* @remark This function may be called before the VMM is initialized.
1675	*/
1676	VMMR3DECL(int) VMMR3SelectSwitcher(PVM pVM, VMMSWITCHER enmSwitcher)
1677	{
1678	/*
1679	* Validate input.
1680	*/
1681	if ( enmSwitcher < VMMSWITCHER_INVALID
1682	\|\| enmSwitcher >= VMMSWITCHER_MAX)
1683	{
1684	AssertMsgFailed(("Invalid input enmSwitcher=%d\n", enmSwitcher));
1685	return VERR_INVALID_PARAMETER;
1686	}
1687
1688	/* Do nothing if the switcher is disabled. */
1689	if (pVM->vmm.s.fSwitcherDisabled)
1690	return VINF_SUCCESS;
1691
1692	/*
1693	* Select the new switcher.
1694	*/
1695	PVMMSWITCHERDEF pSwitcher = s_apSwitchers[enmSwitcher];
1696	if (pSwitcher)
1697	{
1698	Log(("VMMR3SelectSwitcher: enmSwitcher %d -> %d %s\n", pVM->vmm.s.enmSwitcher, enmSwitcher, pSwitcher->pszDesc));
1699	pVM->vmm.s.enmSwitcher = enmSwitcher;
1700
1701	RTR0PTR pbCodeR0 = (RTR0PTR)pVM->vmm.s.pvHCCoreCodeR0 + pVM->vmm.s.aoffSwitchers[enmSwitcher]; /** @todo fix the pvHCCoreCodeR0 type */
1702	pVM->vmm.s.pfnR0HostToGuest = pbCodeR0 + pSwitcher->offR0HostToGuest;
1703
1704	RTGCPTR GCPtr = pVM->vmm.s.pvGCCoreCode + pVM->vmm.s.aoffSwitchers[enmSwitcher];
1705	pVM->vmm.s.pfnGCGuestToHost = GCPtr + pSwitcher->offGCGuestToHost;
1706	pVM->vmm.s.pfnGCCallTrampoline = GCPtr + pSwitcher->offGCCallTrampoline;
1707	pVM->pfnVMMGCGuestToHostAsm = GCPtr + pSwitcher->offGCGuestToHostAsm;
1708	pVM->pfnVMMGCGuestToHostAsmHyperCtx = GCPtr + pSwitcher->offGCGuestToHostAsmHyperCtx;
1709	pVM->pfnVMMGCGuestToHostAsmGuestCtx = GCPtr + pSwitcher->offGCGuestToHostAsmGuestCtx;
1710	return VINF_SUCCESS;
1711	}
1712	return VERR_NOT_IMPLEMENTED;
1713	}
1714
1715	/**
1716	* Disable the switcher logic permanently.
1717	*
1718	* @returns VBox status code.
1719	* @param pVM VM handle.
1720	*/
1721	VMMR3DECL(int) VMMR3DisableSwitcher(PVM pVM)
1722	{
1723	/** @todo r=bird: I would suggest that we create a dummy switcher which just does something like:
1724	* @code
1725	* mov eax, VERR_INTERNAL_ERROR
1726	* ret
1727	* @endcode
1728	* And then check for fSwitcherDisabled in VMMR3SelectSwitcher() in order to prevent it from being removed.
1729	*/
1730	pVM->vmm.s.fSwitcherDisabled = true;
1731	return VINF_SUCCESS;
1732	}
1733
1734
1735	/**
1736	* Resolve a builtin GC symbol.
1737	* Called by PDM when loading or relocating GC modules.
1738	*
1739	* @returns VBox status
1740	* @param pVM VM Handle.
1741	* @param pszSymbol Symbol to resolv
1742	* @param pGCPtrValue Where to store the symbol value.
1743	* @remark This has to work before VMMR3Relocate() is called.
1744	*/
1745	VMMR3DECL(int) VMMR3GetImportGC(PVM pVM, const char *pszSymbol, PRTGCPTR pGCPtrValue)
1746	{
1747	if (!strcmp(pszSymbol, "g_Logger"))
1748	{
1749	if (pVM->vmm.s.pLoggerHC)
1750	pVM->vmm.s.pLoggerGC = MMHyperHC2GC(pVM, pVM->vmm.s.pLoggerHC);
1751	*pGCPtrValue = pVM->vmm.s.pLoggerGC;
1752	}
1753	else if (!strcmp(pszSymbol, "g_RelLogger"))
1754	{
1755	#ifdef VBOX_WITH_GC_AND_R0_RELEASE_LOG
1756	if (pVM->vmm.s.pRelLoggerHC)
1757	pVM->vmm.s.pRelLoggerGC = MMHyperHC2GC(pVM, pVM->vmm.s.pRelLoggerHC);
1758	*pGCPtrValue = pVM->vmm.s.pRelLoggerGC;
1759	#else
1760	*pGCPtrValue = NIL_RTGCPTR;
1761	#endif
1762	}
1763	else
1764	return VERR_SYMBOL_NOT_FOUND;
1765	return VINF_SUCCESS;
1766	}
1767
1768
1769	/**
1770	* Suspends the the CPU yielder.
1771	*
1772	* @param pVM The VM handle.
1773	*/
1774	VMMR3DECL(void) VMMR3YieldSuspend(PVM pVM)
1775	{
1776	if (!pVM->vmm.s.cYieldResumeMillies)
1777	{
1778	uint64_t u64Now = TMTimerGet(pVM->vmm.s.pYieldTimer);
1779	uint64_t u64Expire = TMTimerGetExpire(pVM->vmm.s.pYieldTimer);
1780	if (u64Now >= u64Expire \|\| u64Expire == ~(uint64_t)0)
1781	pVM->vmm.s.cYieldResumeMillies = pVM->vmm.s.cYieldEveryMillies;
1782	else
1783	pVM->vmm.s.cYieldResumeMillies = TMTimerToMilli(pVM->vmm.s.pYieldTimer, u64Expire - u64Now);
1784	TMTimerStop(pVM->vmm.s.pYieldTimer);
1785	}
1786	pVM->vmm.s.u64LastYield = RTTimeNanoTS();
1787	}
1788
1789
1790	/**
1791	* Stops the the CPU yielder.
1792	*
1793	* @param pVM The VM handle.
1794	*/
1795	VMMR3DECL(void) VMMR3YieldStop(PVM pVM)
1796	{
1797	if (!pVM->vmm.s.cYieldResumeMillies)
1798	TMTimerStop(pVM->vmm.s.pYieldTimer);
1799	pVM->vmm.s.cYieldResumeMillies = pVM->vmm.s.cYieldEveryMillies;
1800	pVM->vmm.s.u64LastYield = RTTimeNanoTS();
1801	}
1802
1803
1804	/**
1805	* Resumes the CPU yielder when it has been a suspended or stopped.
1806	*
1807	* @param pVM The VM handle.
1808	*/
1809	VMMR3DECL(void) VMMR3YieldResume(PVM pVM)
1810	{
1811	if (pVM->vmm.s.cYieldResumeMillies)
1812	{
1813	TMTimerSetMillies(pVM->vmm.s.pYieldTimer, pVM->vmm.s.cYieldResumeMillies);
1814	pVM->vmm.s.cYieldResumeMillies = 0;
1815	}
1816	}
1817
1818
1819	/**
1820	* Internal timer callback function.
1821	*
1822	* @param pVM The VM.
1823	* @param pTimer The timer handle.
1824	* @param pvUser User argument specified upon timer creation.
1825	*/
1826	static DECLCALLBACK(void) vmmR3YieldEMT(PVM pVM, PTMTIMER pTimer, void *pvUser)
1827	{
1828	/*
1829	* This really needs some careful tuning. While we shouldn't be too gready since
1830	* that'll cause the rest of the system to stop up, we shouldn't be too nice either
1831	* because that'll cause us to stop up.
1832	*
1833	* The current logic is to use the default interval when there is no lag worth
1834	* mentioning, but when we start accumulating lag we don't bother yielding at all.
1835	*
1836	* (This depends on the TMCLOCK_VIRTUAL_SYNC to be scheduled before TMCLOCK_REAL
1837	* so the lag is up to date.)
1838	*/
1839	const uint64_t u64Lag = TMVirtualSyncGetLag(pVM);
1840	if ( u64Lag < 50000000 /* 50ms */
1841	\|\| ( u64Lag < 1000000000 /* 1s */
1842	&& RTTimeNanoTS() - pVM->vmm.s.u64LastYield < 500000000 /* 500 ms */)
1843	)
1844	{
1845	uint64_t u64Elapsed = RTTimeNanoTS();
1846	pVM->vmm.s.u64LastYield = u64Elapsed;
1847
1848	RTThreadYield();
1849
1850	#ifdef LOG_ENABLED
1851	u64Elapsed = RTTimeNanoTS() - u64Elapsed;
1852	Log(("vmmR3YieldEMT: %RI64 ns\n", u64Elapsed));
1853	#endif
1854	}
1855	TMTimerSetMillies(pTimer, pVM->vmm.s.cYieldEveryMillies);
1856	}
1857
1858
1859	/**
1860	* Acquire global VM lock.
1861	*
1862	* @returns VBox status code
1863	* @param pVM The VM to operate on.
1864	*/
1865	VMMR3DECL(int) VMMR3Lock(PVM pVM)
1866	{
1867	return RTCritSectEnter(&pVM->vmm.s.CritSectVMLock);
1868	}
1869
1870
1871	/**
1872	* Release global VM lock.
1873	*
1874	* @returns VBox status code
1875	* @param pVM The VM to operate on.
1876	*/
1877	VMMR3DECL(int) VMMR3Unlock(PVM pVM)
1878	{
1879	return RTCritSectLeave(&pVM->vmm.s.CritSectVMLock);
1880	}
1881
1882
1883	/**
1884	* Return global VM lock owner.
1885	*
1886	* @returns Thread id of owner.
1887	* @returns NIL_RTTHREAD if no owner.
1888	* @param pVM The VM to operate on.
1889	*/
1890	VMMR3DECL(RTNATIVETHREAD) VMMR3LockGetOwner(PVM pVM)
1891	{
1892	return RTCritSectGetOwner(&pVM->vmm.s.CritSectVMLock);
1893	}
1894
1895
1896	/**
1897	* Checks if the current thread is the owner of the global VM lock.
1898	*
1899	* @returns true if owner.
1900	* @returns false if not owner.
1901	* @param pVM The VM to operate on.
1902	*/
1903	VMMR3DECL(bool) VMMR3LockIsOwner(PVM pVM)
1904	{
1905	return RTCritSectIsOwner(&pVM->vmm.s.CritSectVMLock);
1906	}
1907
1908
1909	/**
1910	* Executes guest code.
1911	*
1912	* @param pVM VM handle.
1913	*/
1914	VMMR3DECL(int) VMMR3RawRunGC(PVM pVM)
1915	{
1916	Log2(("VMMR3RawRunGC: (cs:eip=%04x:%08x)\n", CPUMGetGuestCS(pVM), CPUMGetGuestEIP(pVM)));
1917
1918	/*
1919	* Set the EIP and ESP.
1920	*/
1921	CPUMSetHyperEIP(pVM, CPUMGetGuestEFlags(pVM) & X86_EFL_VM
1922	? pVM->vmm.s.pfnCPUMGCResumeGuestV86
1923	: pVM->vmm.s.pfnCPUMGCResumeGuest);
1924	CPUMSetHyperESP(pVM, pVM->vmm.s.pbGCStackBottom);
1925
1926	/*
1927	* We hide log flushes (outer) and hypervisor interrupts (inner).
1928	*/
1929	for (;;)
1930	{
1931	int rc;
1932	do
1933	{
1934	#ifdef NO_SUPCALLR0VMM
1935	rc = VERR_GENERAL_FAILURE;
1936	#else
1937	rc = SUPCallVMMR0Fast(pVM->pVMR0, VMMR0_DO_RAW_RUN);
1938	if (RT_LIKELY(rc == VINF_SUCCESS))
1939	rc = pVM->vmm.s.iLastGCRc;
1940	#endif
1941	} while (rc == VINF_EM_RAW_INTERRUPT_HYPER);
1942
1943	/*
1944	* Flush the logs.
1945	*/
1946	#ifdef LOG_ENABLED
1947	PRTLOGGERRC pLogger = pVM->vmm.s.pLoggerHC;
1948	if ( pLogger
1949	&& pLogger->offScratch > 0)
1950	RTLogFlushGC(NULL, pLogger);
1951	#endif
1952	#ifdef VBOX_WITH_GC_AND_R0_RELEASE_LOG
1953	PRTLOGGERRC pRelLogger = pVM->vmm.s.pRelLoggerHC;
1954	if (RT_UNLIKELY(pRelLogger && pRelLogger->offScratch > 0))
1955	RTLogFlushGC(RTLogRelDefaultInstance(), pRelLogger);
1956	#endif
1957	if (rc != VINF_VMM_CALL_HOST)
1958	{
1959	Log2(("VMMR3RawRunGC: returns %Vrc (cs:eip=%04x:%08x)\n", rc, CPUMGetGuestCS(pVM), CPUMGetGuestEIP(pVM)));
1960	return rc;
1961	}
1962	rc = vmmR3ServiceCallHostRequest(pVM);
1963	if (VBOX_FAILURE(rc))
1964	return rc;
1965	/* Resume GC */
1966	}
1967	}
1968
1969
1970	/**
1971	* Executes guest code (Intel VT-x and AMD-V).
1972	*
1973	* @param pVM VM handle.
1974	*/
1975	VMMR3DECL(int) VMMR3HwAccRunGC(PVM pVM)
1976	{
1977	Log2(("VMMR3HwAccRunGC: (cs:eip=%04x:%08x)\n", CPUMGetGuestCS(pVM), CPUMGetGuestEIP(pVM)));
1978
1979	for (;;)
1980	{
1981	int rc;
1982	do
1983	{
1984	#ifdef NO_SUPCALLR0VMM
1985	rc = VERR_GENERAL_FAILURE;
1986	#else
1987	rc = SUPCallVMMR0Fast(pVM->pVMR0, VMMR0_DO_HWACC_RUN);
1988	if (RT_LIKELY(rc == VINF_SUCCESS))
1989	rc = pVM->vmm.s.iLastGCRc;
1990	#endif
1991	} while (rc == VINF_EM_RAW_INTERRUPT_HYPER);
1992
1993	#ifdef LOG_ENABLED
1994	/*
1995	* Flush the log
1996	*/
1997	PVMMR0LOGGER pR0Logger = pVM->vmm.s.pR0Logger;
1998	if ( pR0Logger
1999	&& pR0Logger->Logger.offScratch > 0)
2000	RTLogFlushToLogger(&pR0Logger->Logger, NULL);
2001	#endif /* !LOG_ENABLED */
2002	if (rc != VINF_VMM_CALL_HOST)
2003	{
2004	Log2(("VMMR3HwAccRunGC: returns %Vrc (cs:eip=%04x:%08x)\n", rc, CPUMGetGuestCS(pVM), CPUMGetGuestEIP(pVM)));
2005	return rc;
2006	}
2007	rc = vmmR3ServiceCallHostRequest(pVM);
2008	if (VBOX_FAILURE(rc) \|\| rc == VINF_EM_DBG_HYPER_ASSERTION)
2009	return rc;
2010	/* Resume R0 */
2011	}
2012	}
2013
2014	/**
2015	* Calls GC a function.
2016	*
2017	* @param pVM The VM handle.
2018	* @param GCPtrEntry The GC function address.
2019	* @param cArgs The number of arguments in the ....
2020	* @param ... Arguments to the function.
2021	*/
2022	VMMR3DECL(int) VMMR3CallGC(PVM pVM, RTRCPTR GCPtrEntry, unsigned cArgs, ...)
2023	{
2024	va_list args;
2025	va_start(args, cArgs);
2026	int rc = VMMR3CallGCV(pVM, GCPtrEntry, cArgs, args);
2027	va_end(args);
2028	return rc;
2029	}
2030
2031
2032	/**
2033	* Calls GC a function.
2034	*
2035	* @param pVM The VM handle.
2036	* @param GCPtrEntry The GC function address.
2037	* @param cArgs The number of arguments in the ....
2038	* @param args Arguments to the function.
2039	*/
2040	VMMR3DECL(int) VMMR3CallGCV(PVM pVM, RTRCPTR GCPtrEntry, unsigned cArgs, va_list args)
2041	{
2042	Log2(("VMMR3CallGCV: GCPtrEntry=%VRv cArgs=%d\n", GCPtrEntry, cArgs));
2043
2044	/*
2045	* Setup the call frame using the trampoline.
2046	*/
2047	CPUMHyperSetCtxCore(pVM, NULL);
2048	memset(pVM->vmm.s.pbHCStack, 0xaa, VMM_STACK_SIZE); /* Clear the stack. */
2049	CPUMSetHyperESP(pVM, pVM->vmm.s.pbGCStackBottom - cArgs * sizeof(RTGCUINTPTR32));
2050	PRTGCUINTPTR32 pFrame = (PRTGCUINTPTR32)(pVM->vmm.s.pbHCStack + VMM_STACK_SIZE) - cArgs;
2051	int i = cArgs;
2052	while (i-- > 0)
2053	*pFrame++ = va_arg(args, RTGCUINTPTR32);
2054
2055	CPUMPushHyper(pVM, cArgs * sizeof(RTGCUINTPTR32)); /* stack frame size */
2056	CPUMPushHyper(pVM, GCPtrEntry); /* what to call */
2057	CPUMSetHyperEIP(pVM, pVM->vmm.s.pfnGCCallTrampoline);
2058
2059	/*
2060	* We hide log flushes (outer) and hypervisor interrupts (inner).
2061	*/
2062	for (;;)
2063	{
2064	int rc;
2065	do
2066	{
2067	#ifdef NO_SUPCALLR0VMM
2068	rc = VERR_GENERAL_FAILURE;
2069	#else
2070	rc = SUPCallVMMR0Fast(pVM->pVMR0, VMMR0_DO_RAW_RUN);
2071	if (RT_LIKELY(rc == VINF_SUCCESS))
2072	rc = pVM->vmm.s.iLastGCRc;
2073	#endif
2074	} while (rc == VINF_EM_RAW_INTERRUPT_HYPER);
2075
2076	/*
2077	* Flush the logs.
2078	*/
2079	#ifdef LOG_ENABLED
2080	PRTLOGGERRC pLogger = pVM->vmm.s.pLoggerHC;
2081	if ( pLogger
2082	&& pLogger->offScratch > 0)
2083	RTLogFlushGC(NULL, pLogger);
2084	#endif
2085	#ifdef VBOX_WITH_GC_AND_R0_RELEASE_LOG
2086	PRTLOGGERRC pRelLogger = pVM->vmm.s.pRelLoggerHC;
2087	if (RT_UNLIKELY(pRelLogger && pRelLogger->offScratch > 0))
2088	RTLogFlushGC(RTLogRelDefaultInstance(), pRelLogger);
2089	#endif
2090	if (rc == VERR_TRPM_PANIC \|\| rc == VERR_TRPM_DONT_PANIC)
2091	VMMR3FatalDump(pVM, rc);
2092	if (rc != VINF_VMM_CALL_HOST)
2093	{
2094	Log2(("VMMR3CallGCV: returns %Vrc (cs:eip=%04x:%08x)\n", rc, CPUMGetGuestCS(pVM), CPUMGetGuestEIP(pVM)));
2095	return rc;
2096	}
2097	rc = vmmR3ServiceCallHostRequest(pVM);
2098	if (VBOX_FAILURE(rc))
2099	return rc;
2100	}
2101	}
2102
2103
2104	/**
2105	* Resumes executing hypervisor code when interrupted
2106	* by a queue flush or a debug event.
2107	*
2108	* @returns VBox status code.
2109	* @param pVM VM handle.
2110	*/
2111	VMMR3DECL(int) VMMR3ResumeHyper(PVM pVM)
2112	{
2113	Log(("VMMR3ResumeHyper: eip=%VGv esp=%VGv\n", CPUMGetHyperEIP(pVM), CPUMGetHyperESP(pVM)));
2114
2115	/*
2116	* We hide log flushes (outer) and hypervisor interrupts (inner).
2117	*/
2118	for (;;)
2119	{
2120	int rc;
2121	do
2122	{
2123	#ifdef NO_SUPCALLR0VMM
2124	rc = VERR_GENERAL_FAILURE;
2125	#else
2126	rc = SUPCallVMMR0Fast(pVM->pVMR0, VMMR0_DO_RAW_RUN);
2127	if (RT_LIKELY(rc == VINF_SUCCESS))
2128	rc = pVM->vmm.s.iLastGCRc;
2129	#endif
2130	} while (rc == VINF_EM_RAW_INTERRUPT_HYPER);
2131
2132	/*
2133	* Flush the loggers,
2134	*/
2135	#ifdef LOG_ENABLED
2136	PRTLOGGERRC pLogger = pVM->vmm.s.pLoggerHC;
2137	if ( pLogger
2138	&& pLogger->offScratch > 0)
2139	RTLogFlushGC(NULL, pLogger);
2140	#endif
2141	#ifdef VBOX_WITH_GC_AND_R0_RELEASE_LOG
2142	PRTLOGGERRC pRelLogger = pVM->vmm.s.pRelLoggerHC;
2143	if (RT_UNLIKELY(pRelLogger && pRelLogger->offScratch > 0))
2144	RTLogFlushGC(RTLogRelDefaultInstance(), pRelLogger);
2145	#endif
2146	if (rc == VERR_TRPM_PANIC \|\| rc == VERR_TRPM_DONT_PANIC)
2147	VMMR3FatalDump(pVM, rc);
2148	if (rc != VINF_VMM_CALL_HOST)
2149	{
2150	Log(("VMMR3ResumeHyper: returns %Vrc\n", rc));
2151	return rc;
2152	}
2153	rc = vmmR3ServiceCallHostRequest(pVM);
2154	if (VBOX_FAILURE(rc))
2155	return rc;
2156	}
2157	}
2158
2159
2160	/**
2161	* Service a call to the ring-3 host code.
2162	*
2163	* @returns VBox status code.
2164	* @param pVM VM handle.
2165	* @remark Careful with critsects.
2166	*/
2167	static int vmmR3ServiceCallHostRequest(PVM pVM)
2168	{
2169	switch (pVM->vmm.s.enmCallHostOperation)
2170	{
2171	/*
2172	* Acquire the PDM lock.
2173	*/
2174	case VMMCALLHOST_PDM_LOCK:
2175	{
2176	pVM->vmm.s.rcCallHost = PDMR3LockCall(pVM);
2177	break;
2178	}
2179
2180	/*
2181	* Flush a PDM queue.
2182	*/
2183	case VMMCALLHOST_PDM_QUEUE_FLUSH:
2184	{
2185	PDMR3QueueFlushWorker(pVM, NULL);
2186	pVM->vmm.s.rcCallHost = VINF_SUCCESS;
2187	break;
2188	}
2189
2190	/*
2191	* Grow the PGM pool.
2192	*/
2193	case VMMCALLHOST_PGM_POOL_GROW:
2194	{
2195	pVM->vmm.s.rcCallHost = PGMR3PoolGrow(pVM);
2196	break;
2197	}
2198
2199	/*
2200	* Maps an page allocation chunk into ring-3 so ring-0 can use it.
2201	*/
2202	case VMMCALLHOST_PGM_MAP_CHUNK:
2203	{
2204	pVM->vmm.s.rcCallHost = PGMR3PhysChunkMap(pVM, pVM->vmm.s.u64CallHostArg);
2205	break;
2206	}
2207
2208	/*
2209	* Allocates more handy pages.
2210	*/
2211	case VMMCALLHOST_PGM_ALLOCATE_HANDY_PAGES:
2212	{
2213	pVM->vmm.s.rcCallHost = PGMR3PhysAllocateHandyPages(pVM);
2214	break;
2215	}
2216	#ifndef VBOX_WITH_NEW_PHYS_CODE
2217
2218	case VMMCALLHOST_PGM_RAM_GROW_RANGE:
2219	{
2220	const RTGCPHYS GCPhys = pVM->vmm.s.u64CallHostArg;
2221	pVM->vmm.s.rcCallHost = PGM3PhysGrowRange(pVM, &GCPhys);
2222	break;
2223	}
2224	#endif
2225
2226	/*
2227	* Acquire the PGM lock.
2228	*/
2229	case VMMCALLHOST_PGM_LOCK:
2230	{
2231	pVM->vmm.s.rcCallHost = PGMR3LockCall(pVM);
2232	break;
2233	}
2234
2235	/*
2236	* Flush REM handler notifications.
2237	*/
2238	case VMMCALLHOST_REM_REPLAY_HANDLER_NOTIFICATIONS:
2239	{
2240	REMR3ReplayHandlerNotifications(pVM);
2241	break;
2242	}
2243
2244	/*
2245	* This is a noop. We just take this route to avoid unnecessary
2246	* tests in the loops.
2247	*/
2248	case VMMCALLHOST_VMM_LOGGER_FLUSH:
2249	break;
2250
2251	/*
2252	* Set the VM error message.
2253	*/
2254	case VMMCALLHOST_VM_SET_ERROR:
2255	VMR3SetErrorWorker(pVM);
2256	break;
2257
2258	/*
2259	* Set the VM runtime error message.
2260	*/
2261	case VMMCALLHOST_VM_SET_RUNTIME_ERROR:
2262	VMR3SetRuntimeErrorWorker(pVM);
2263	break;
2264
2265	/*
2266	* Signal a ring 0 hypervisor assertion.
2267	* Cancel the longjmp operation that's in progress.
2268	*/
2269	case VMMCALLHOST_VM_R0_HYPER_ASSERTION:
2270	pVM->vmm.s.enmCallHostOperation = VMMCALLHOST_INVALID;
2271	pVM->vmm.s.CallHostR0JmpBuf.fInRing3Call = false;
2272	#ifdef RT_ARCH_X86
2273	pVM->vmm.s.CallHostR0JmpBuf.eip = 0;
2274	#else
2275	pVM->vmm.s.CallHostR0JmpBuf.rip = 0;
2276	#endif
2277	return VINF_EM_DBG_HYPER_ASSERTION;
2278
2279	default:
2280	AssertMsgFailed(("enmCallHostOperation=%d\n", pVM->vmm.s.enmCallHostOperation));
2281	return VERR_INTERNAL_ERROR;
2282	}
2283
2284	pVM->vmm.s.enmCallHostOperation = VMMCALLHOST_INVALID;
2285	return VINF_SUCCESS;
2286	}
2287
2288
2289
2290	/**
2291	* Structure to pass to DBGFR3Info() and for doing all other
2292	* output during fatal dump.
2293	*/
2294	typedef struct VMMR3FATALDUMPINFOHLP
2295	{
2296	/** The helper core. */
2297	DBGFINFOHLP Core;
2298	/** The release logger instance. */
2299	PRTLOGGER pRelLogger;
2300	/** The saved release logger flags. */
2301	RTUINT fRelLoggerFlags;
2302	/** The logger instance. */
2303	PRTLOGGER pLogger;
2304	/** The saved logger flags. */
2305	RTUINT fLoggerFlags;
2306	/** The saved logger destination flags. */
2307	RTUINT fLoggerDestFlags;
2308	/** Whether to output to stderr or not. */
2309	bool fStdErr;
2310	} VMMR3FATALDUMPINFOHLP, *PVMMR3FATALDUMPINFOHLP;
2311	typedef const VMMR3FATALDUMPINFOHLP *PCVMMR3FATALDUMPINFOHLP;
2312
2313
2314	/**
2315	* Print formatted string.
2316	*
2317	* @param pHlp Pointer to this structure.
2318	* @param pszFormat The format string.
2319	* @param ... Arguments.
2320	*/
2321	static DECLCALLBACK(void) vmmR3FatalDumpInfoHlp_pfnPrintf(PCDBGFINFOHLP pHlp, const char *pszFormat, ...)
2322	{
2323	va_list args;
2324	va_start(args, pszFormat);
2325	pHlp->pfnPrintfV(pHlp, pszFormat, args);
2326	va_end(args);
2327	}
2328
2329
2330	/**
2331	* Print formatted string.
2332	*
2333	* @param pHlp Pointer to this structure.
2334	* @param pszFormat The format string.
2335	* @param args Argument list.
2336	*/
2337	static DECLCALLBACK(void) vmmR3FatalDumpInfoHlp_pfnPrintfV(PCDBGFINFOHLP pHlp, const char *pszFormat, va_list args)
2338	{
2339	PCVMMR3FATALDUMPINFOHLP pMyHlp = (PCVMMR3FATALDUMPINFOHLP)pHlp;
2340
2341	if (pMyHlp->pRelLogger)
2342	{
2343	va_list args2;
2344	va_copy(args2, args);
2345	RTLogLoggerV(pMyHlp->pRelLogger, pszFormat, args2);
2346	va_end(args2);
2347	}
2348	if (pMyHlp->pLogger)
2349	{
2350	va_list args2;
2351	va_copy(args2, args);
2352	RTLogLoggerV(pMyHlp->pLogger, pszFormat, args);
2353	va_end(args2);
2354	}
2355	if (pMyHlp->fStdErr)
2356	{
2357	va_list args2;
2358	va_copy(args2, args);
2359	RTStrmPrintfV(g_pStdErr, pszFormat, args);
2360	va_end(args2);
2361	}
2362	}
2363
2364
2365	/**
2366	* Initializes the fatal dump output helper.
2367	*
2368	* @param pHlp The structure to initialize.
2369	*/
2370	static void vmmR3FatalDumpInfoHlpInit(PVMMR3FATALDUMPINFOHLP pHlp)
2371	{
2372	memset(pHlp, 0, sizeof(*pHlp));
2373
2374	pHlp->Core.pfnPrintf = vmmR3FatalDumpInfoHlp_pfnPrintf;
2375	pHlp->Core.pfnPrintfV = vmmR3FatalDumpInfoHlp_pfnPrintfV;
2376
2377	/*
2378	* The loggers.
2379	*/
2380	pHlp->pRelLogger = RTLogRelDefaultInstance();
2381	#ifndef LOG_ENABLED
2382	if (!pHlp->pRelLogger)
2383	#endif
2384	pHlp->pLogger = RTLogDefaultInstance();
2385
2386	if (pHlp->pRelLogger)
2387	{
2388	pHlp->fRelLoggerFlags = pHlp->pRelLogger->fFlags;
2389	pHlp->pRelLogger->fFlags &= ~(RTLOGFLAGS_BUFFERED \| RTLOGFLAGS_DISABLED);
2390	}
2391
2392	if (pHlp->pLogger)
2393	{
2394	pHlp->fLoggerFlags = pHlp->pLogger->fFlags;
2395	pHlp->fLoggerDestFlags = pHlp->pLogger->fDestFlags;
2396	pHlp->pLogger->fFlags &= ~(RTLOGFLAGS_BUFFERED \| RTLOGFLAGS_DISABLED);
2397	#ifndef DEBUG_sandervl
2398	pHlp->pLogger->fDestFlags \|= RTLOGDEST_DEBUGGER;
2399	#endif
2400	}
2401
2402	/*
2403	* Check if we need write to stderr.
2404	*/
2405	#ifdef DEBUG_sandervl
2406	pHlp->fStdErr = false; /* takes too long to display here */
2407	#else
2408	pHlp->fStdErr = (!pHlp->pRelLogger \|\| !(pHlp->pRelLogger->fDestFlags & (RTLOGDEST_STDOUT \| RTLOGDEST_STDERR)))
2409	&& (!pHlp->pLogger \|\| !(pHlp->pLogger->fDestFlags & (RTLOGDEST_STDOUT \| RTLOGDEST_STDERR)));
2410	#endif
2411	}
2412
2413
2414	/**
2415	* Deletes the fatal dump output helper.
2416	*
2417	* @param pHlp The structure to delete.
2418	*/
2419	static void vmmR3FatalDumpInfoHlpDelete(PVMMR3FATALDUMPINFOHLP pHlp)
2420	{
2421	if (pHlp->pRelLogger)
2422	{
2423	RTLogFlush(pHlp->pRelLogger);
2424	pHlp->pRelLogger->fFlags = pHlp->fRelLoggerFlags;
2425	}
2426
2427	if (pHlp->pLogger)
2428	{
2429	RTLogFlush(pHlp->pLogger);
2430	pHlp->pLogger->fFlags = pHlp->fLoggerFlags;
2431	pHlp->pLogger->fDestFlags = pHlp->fLoggerDestFlags;
2432	}
2433	}
2434
2435
2436	/**
2437	* Dumps the VM state on a fatal error.
2438	*
2439	* @param pVM VM Handle.
2440	* @param rcErr VBox status code.
2441	*/
2442	VMMR3DECL(void) VMMR3FatalDump(PVM pVM, int rcErr)
2443	{
2444	/*
2445	* Create our output helper and sync it with the log settings.
2446	* This helper will be used for all the output.
2447	*/
2448	VMMR3FATALDUMPINFOHLP Hlp;
2449	PCDBGFINFOHLP pHlp = &Hlp.Core;
2450	vmmR3FatalDumpInfoHlpInit(&Hlp);
2451
2452	/*
2453	* Header.
2454	*/
2455	pHlp->pfnPrintf(pHlp,
2456	"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
2457	"!!\n"
2458	"!! Guru Meditation %d (%Vrc)\n"
2459	"!!\n",
2460	rcErr, rcErr);
2461
2462	/*
2463	* Continue according to context.
2464	*/
2465	bool fDoneHyper = false;
2466	switch (rcErr)
2467	{
2468	/*
2469	* Hyper visor errors.
2470	*/
2471	case VINF_EM_DBG_HYPER_ASSERTION:
2472	pHlp->pfnPrintf(pHlp, "%s%s!!\n", VMMR3GetGCAssertMsg1(pVM), VMMR3GetGCAssertMsg2(pVM));
2473	/* fall thru */
2474	case VERR_TRPM_DONT_PANIC:
2475	case VERR_TRPM_PANIC:
2476	case VINF_EM_RAW_STALE_SELECTOR:
2477	case VINF_EM_RAW_IRET_TRAP:
2478	case VINF_EM_DBG_HYPER_BREAKPOINT:
2479	case VINF_EM_DBG_HYPER_STEPPED:
2480	{
2481	/* Trap? */
2482	uint32_t uEIP = CPUMGetHyperEIP(pVM);
2483	TRPMEVENT enmType;
2484	uint8_t u8TrapNo = 0xce;
2485	RTGCUINT uErrorCode = 0xdeadface;
2486	RTGCUINTPTR uCR2 = 0xdeadface;
2487	int rc2 = TRPMQueryTrapAll(pVM, &u8TrapNo, &enmType, &uErrorCode, &uCR2);
2488	if (VBOX_SUCCESS(rc2))
2489	pHlp->pfnPrintf(pHlp,
2490	"!! TRAP=%02x ERRCD=%VGv CR2=%VGv EIP=%VGv Type=%d\n",
2491	u8TrapNo, uErrorCode, uCR2, uEIP, enmType);
2492	else
2493	pHlp->pfnPrintf(pHlp,
2494	"!! EIP=%VGv NOTRAP\n",
2495	uEIP);
2496
2497	/*
2498	* Try figure out where eip is.
2499	*/
2500	/** @todo make query call for core code or move this function to VMM. */
2501	/* core code? */
2502	//if (uEIP - (RTGCUINTPTR)pVM->vmm.s.pvGCCoreCode < pVM->vmm.s.cbCoreCode)
2503	// pHlp->pfnPrintf(pHlp,
2504	// "!! EIP is in CoreCode, offset %#x\n",
2505	// uEIP - (RTGCUINTPTR)pVM->vmm.s.pvGCCoreCode);
2506	//else
2507	{ /* ask PDM */
2508	/** @todo ask DBGFR3Sym later. */
2509	char szModName[64];
2510	RTGCPTR GCPtrMod;
2511	char szNearSym1[260];
2512	RTGCPTR GCPtrNearSym1;
2513	char szNearSym2[260];
2514	RTGCPTR GCPtrNearSym2;
2515	int rc = PDMR3QueryModFromEIP(pVM, uEIP,
2516	&szModName[0], sizeof(szModName), &GCPtrMod,
2517	&szNearSym1[0], sizeof(szNearSym1), &GCPtrNearSym1,
2518	&szNearSym2[0], sizeof(szNearSym2), &GCPtrNearSym2);
2519	if (VBOX_SUCCESS(rc))
2520	{
2521	pHlp->pfnPrintf(pHlp,
2522	"!! EIP in %s (%VGv) at rva %x near symbols:\n"
2523	"!! %VGv rva %VGv off %08x %s\n"
2524	"!! %VGv rva %VGv off -%08x %s\n",
2525	szModName, GCPtrMod, (unsigned)(uEIP - GCPtrMod),
2526	GCPtrNearSym1, GCPtrNearSym1 - GCPtrMod, (unsigned)(uEIP - GCPtrNearSym1), szNearSym1,
2527	GCPtrNearSym2, GCPtrNearSym2 - GCPtrMod, (unsigned)(GCPtrNearSym2 - uEIP), szNearSym2);
2528	}
2529	else
2530	pHlp->pfnPrintf(pHlp,
2531	"!! EIP is not in any code known to VMM!\n");
2532	}
2533
2534	/* Disassemble the instruction. */
2535	char szInstr[256];
2536	rc2 = DBGFR3DisasInstrEx(pVM, 0, 0, DBGF_DISAS_FLAGS_CURRENT_HYPER, &szInstr[0], sizeof(szInstr), NULL);
2537	if (VBOX_SUCCESS(rc2))
2538	pHlp->pfnPrintf(pHlp,
2539	"!! %s\n", szInstr);
2540
2541	/* Dump the hypervisor cpu state. */
2542	pHlp->pfnPrintf(pHlp,
2543	"!!\n"
2544	"!!\n"
2545	"!!\n");
2546	rc2 = DBGFR3Info(pVM, "cpumhyper", "verbose", pHlp);
2547	fDoneHyper = true;
2548
2549	/* Callstack. */
2550	DBGFSTACKFRAME Frame = {0};
2551	rc2 = DBGFR3StackWalkBeginHyper(pVM, &Frame);
2552	if (VBOX_SUCCESS(rc2))
2553	{
2554	pHlp->pfnPrintf(pHlp,
2555	"!!\n"
2556	"!! Call Stack:\n"
2557	"!!\n"
2558	"EBP Ret EBP Ret CS:EIP Arg0 Arg1 Arg2 Arg3 CS:EIP Symbol [line]\n");
2559	do
2560	{
2561	pHlp->pfnPrintf(pHlp,
2562	"%08RX32 %08RX32 %04RX32:%08RX32 %08RX32 %08RX32 %08RX32 %08RX32",
2563	(uint32_t)Frame.AddrFrame.off,
2564	(uint32_t)Frame.AddrReturnFrame.off,
2565	(uint32_t)Frame.AddrReturnPC.Sel,
2566	(uint32_t)Frame.AddrReturnPC.off,
2567	Frame.Args.au32[0],
2568	Frame.Args.au32[1],
2569	Frame.Args.au32[2],
2570	Frame.Args.au32[3]);
2571	pHlp->pfnPrintf(pHlp, " %RTsel:%08RGv", Frame.AddrPC.Sel, Frame.AddrPC.off);
2572	if (Frame.pSymPC)
2573	{
2574	RTGCINTPTR offDisp = Frame.AddrPC.FlatPtr - Frame.pSymPC->Value;
2575	if (offDisp > 0)
2576	pHlp->pfnPrintf(pHlp, " %s+%llx", Frame.pSymPC->szName, (int64_t)offDisp);
2577	else if (offDisp < 0)
2578	pHlp->pfnPrintf(pHlp, " %s-%llx", Frame.pSymPC->szName, -(int64_t)offDisp);
2579	else
2580	pHlp->pfnPrintf(pHlp, " %s", Frame.pSymPC->szName);
2581	}
2582	if (Frame.pLinePC)
2583	pHlp->pfnPrintf(pHlp, " [%s @ 0i%d]", Frame.pLinePC->szFilename, Frame.pLinePC->uLineNo);
2584	pHlp->pfnPrintf(pHlp, "\n");
2585
2586	/* next */
2587	rc2 = DBGFR3StackWalkNext(pVM, &Frame);
2588	} while (VBOX_SUCCESS(rc2));
2589	DBGFR3StackWalkEnd(pVM, &Frame);
2590	}
2591
2592	/* raw stack */
2593	pHlp->pfnPrintf(pHlp,
2594	"!!\n"
2595	"!! Raw stack (mind the direction).\n"
2596	"!!\n"
2597	"%.*Vhxd\n",
2598	VMM_STACK_SIZE, (char *)pVM->vmm.s.pbHCStack);
2599	break;
2600	}
2601
2602	default:
2603	{
2604	break;
2605	}
2606
2607	} /* switch (rcErr) */
2608
2609
2610	/*
2611	* Generic info dumper loop.
2612	*/
2613	static struct
2614	{
2615	const char *pszInfo;
2616	const char *pszArgs;
2617	} const aInfo[] =
2618	{
2619	{ "mappings", NULL },
2620	{ "hma", NULL },
2621	{ "cpumguest", "verbose" },
2622	{ "cpumguestinstr", "verbose" },
2623	{ "cpumhyper", "verbose" },
2624	{ "cpumhost", "verbose" },
2625	{ "mode", "all" },
2626	{ "cpuid", "verbose" },
2627	{ "gdt", NULL },
2628	{ "ldt", NULL },
2629	//{ "tss", NULL },
2630	{ "ioport", NULL },
2631	{ "mmio", NULL },
2632	{ "phys", NULL },
2633	//{ "pgmpd", NULL }, - doesn't always work at init time...
2634	{ "timers", NULL },
2635	{ "activetimers", NULL },
2636	{ "handlers", "phys virt hyper stats" },
2637	{ "cfgm", NULL },
2638	};
2639	for (unsigned i = 0; i < RT_ELEMENTS(aInfo); i++)
2640	{
2641	if (fDoneHyper && !strcmp(aInfo[i].pszInfo, "cpumhyper"))
2642	continue;
2643	pHlp->pfnPrintf(pHlp,
2644	"!!\n"
2645	"!! {%s, %s}\n"
2646	"!!\n",
2647	aInfo[i].pszInfo, aInfo[i].pszArgs);
2648	DBGFR3Info(pVM, aInfo[i].pszInfo, aInfo[i].pszArgs, pHlp);
2649	}
2650
2651	/* done */
2652	pHlp->pfnPrintf(pHlp,
2653	"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
2654
2655
2656	/*
2657	* Delete the output instance (flushing and restoring of flags).
2658	*/
2659	vmmR3FatalDumpInfoHlpDelete(&Hlp);
2660	}
2661
2662
2663
2664	/**
2665	* Displays the Force action Flags.
2666	*
2667	* @param pVM The VM handle.
2668	* @param pHlp The output helpers.
2669	* @param pszArgs The additional arguments (ignored).
2670	*/
2671	static DECLCALLBACK(void) vmmR3InfoFF(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs)
2672	{
2673	const uint32_t fForcedActions = pVM->fForcedActions;
2674
2675	pHlp->pfnPrintf(pHlp, "Forced action Flags: %#RX32", fForcedActions);
2676
2677	/* show the flag mnemonics */
2678	int c = 0;
2679	uint32_t f = fForcedActions;
2680	#define PRINT_FLAG(flag) do { \
2681	if (f & (flag)) \
2682	{ \
2683	static const char *s_psz = #flag; \
2684	if (!(c % 6)) \
2685	pHlp->pfnPrintf(pHlp, "%s\n %s", c ? "," : "", s_psz + 6); \
2686	else \
2687	pHlp->pfnPrintf(pHlp, ", %s", s_psz + 6); \
2688	c++; \
2689	f &= ~(flag); \
2690	} \
2691	} while (0)
2692	PRINT_FLAG(VM_FF_INTERRUPT_APIC);
2693	PRINT_FLAG(VM_FF_INTERRUPT_PIC);
2694	PRINT_FLAG(VM_FF_TIMER);
2695	PRINT_FLAG(VM_FF_PDM_QUEUES);
2696	PRINT_FLAG(VM_FF_PDM_DMA);
2697	PRINT_FLAG(VM_FF_PDM_CRITSECT);
2698	PRINT_FLAG(VM_FF_DBGF);
2699	PRINT_FLAG(VM_FF_REQUEST);
2700	PRINT_FLAG(VM_FF_TERMINATE);
2701	PRINT_FLAG(VM_FF_RESET);
2702	PRINT_FLAG(VM_FF_PGM_SYNC_CR3);
2703	PRINT_FLAG(VM_FF_PGM_SYNC_CR3_NON_GLOBAL);
2704	PRINT_FLAG(VM_FF_TRPM_SYNC_IDT);
2705	PRINT_FLAG(VM_FF_SELM_SYNC_TSS);
2706	PRINT_FLAG(VM_FF_SELM_SYNC_GDT);
2707	PRINT_FLAG(VM_FF_SELM_SYNC_LDT);
2708	PRINT_FLAG(VM_FF_INHIBIT_INTERRUPTS);
2709	PRINT_FLAG(VM_FF_CSAM_SCAN_PAGE);
2710	PRINT_FLAG(VM_FF_CSAM_PENDING_ACTION);
2711	PRINT_FLAG(VM_FF_TO_R3);
2712	PRINT_FLAG(VM_FF_DEBUG_SUSPEND);
2713	if (f)
2714	pHlp->pfnPrintf(pHlp, "%s\n Unknown bits: %#RX32\n", c ? "," : "", f);
2715	else
2716	pHlp->pfnPrintf(pHlp, "\n");
2717	#undef PRINT_FLAG
2718
2719	/* the groups */
2720	c = 0;
2721	#define PRINT_GROUP(grp) do { \
2722	if (fForcedActions & (grp)) \
2723	{ \
2724	static const char *s_psz = #grp; \
2725	if (!(c % 5)) \
2726	pHlp->pfnPrintf(pHlp, "%s %s", c ? ",\n" : "Groups:\n", s_psz + 6); \
2727	else \
2728	pHlp->pfnPrintf(pHlp, ", %s", s_psz + 6); \
2729	c++; \
2730	} \
2731	} while (0)
2732	PRINT_GROUP(VM_FF_EXTERNAL_SUSPENDED_MASK);
2733	PRINT_GROUP(VM_FF_EXTERNAL_HALTED_MASK);
2734	PRINT_GROUP(VM_FF_HIGH_PRIORITY_PRE_MASK);
2735	PRINT_GROUP(VM_FF_HIGH_PRIORITY_PRE_RAW_MASK);
2736	PRINT_GROUP(VM_FF_HIGH_PRIORITY_POST_MASK);
2737	PRINT_GROUP(VM_FF_NORMAL_PRIORITY_POST_MASK);
2738	PRINT_GROUP(VM_FF_NORMAL_PRIORITY_MASK);
2739	PRINT_GROUP(VM_FF_RESUME_GUEST_MASK);
2740	PRINT_GROUP(VM_FF_ALL_BUT_RAW_MASK);
2741	if (c)
2742	pHlp->pfnPrintf(pHlp, "\n");
2743	#undef PRINT_GROUP
2744	}
2745

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

source: vbox/trunk/src/VBox/VMM/VMM.cpp@ 11945

Download in other formats: