EM.cpp@ 72487

Last change on this file since 72487 was 72461, checked in by vboxsync, 7 years ago
emR3Load: Status checking cleanups
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 134.4 KB

Line
1	/* $Id: EM.cpp 72461 2018-06-06 11:33:58Z vboxsync $ */
2	/** @file
3	* EM - Execution Monitor / Manager.
4	*/
5
6	/*
7	* Copyright (C) 2006-2017 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	/** @page pg_em EM - The Execution Monitor / Manager
19	*
20	* The Execution Monitor/Manager is responsible for running the VM, scheduling
21	* the right kind of execution (Raw-mode, Hardware Assisted, Recompiled or
22	* Interpreted), and keeping the CPU states in sync. The function
23	* EMR3ExecuteVM() is the 'main-loop' of the VM, while each of the execution
24	* modes has different inner loops (emR3RawExecute, emR3HmExecute, and
25	* emR3RemExecute).
26	*
27	* The interpreted execution is only used to avoid switching between
28	* raw-mode/hm and the recompiler when fielding virtualization traps/faults.
29	* The interpretation is thus implemented as part of EM.
30	*
31	* @see grp_em
32	*/
33
34
35	/*********************************************************************************************************************************
36	* Header Files *
37	*********************************************************************************************************************************/
38	#define LOG_GROUP LOG_GROUP_EM
39	#include <VBox/vmm/em.h>
40	#include <VBox/vmm/vmm.h>
41	#include <VBox/vmm/patm.h>
42	#include <VBox/vmm/csam.h>
43	#include <VBox/vmm/selm.h>
44	#include <VBox/vmm/trpm.h>
45	#include <VBox/vmm/iem.h>
46	#include <VBox/vmm/nem.h>
47	#include <VBox/vmm/iom.h>
48	#include <VBox/vmm/dbgf.h>
49	#include <VBox/vmm/pgm.h>
50	#ifdef VBOX_WITH_REM
51	# include <VBox/vmm/rem.h>
52	#endif
53	#include <VBox/vmm/apic.h>
54	#include <VBox/vmm/tm.h>
55	#include <VBox/vmm/mm.h>
56	#include <VBox/vmm/ssm.h>
57	#include <VBox/vmm/pdmapi.h>
58	#include <VBox/vmm/pdmcritsect.h>
59	#include <VBox/vmm/pdmqueue.h>
60	#include <VBox/vmm/hm.h>
61	#include <VBox/vmm/patm.h>
62	#include "EMInternal.h"
63	#include <VBox/vmm/vm.h>
64	#include <VBox/vmm/uvm.h>
65	#include <VBox/vmm/cpumdis.h>
66	#include <VBox/dis.h>
67	#include <VBox/disopcode.h>
68	#include "VMMTracing.h"
69
70	#include <iprt/asm.h>
71	#include <iprt/string.h>
72	#include <iprt/stream.h>
73	#include <iprt/thread.h>
74
75
76	/*********************************************************************************************************************************
77	* Defined Constants And Macros *
78	*********************************************************************************************************************************/
79	#if 0 /* Disabled till after 2.1.0 when we've time to test it. */
80	#define EM_NOTIFY_HM
81	#endif
82
83
84	/*********************************************************************************************************************************
85	* Internal Functions *
86	*********************************************************************************************************************************/
87	static DECLCALLBACK(int) emR3Save(PVM pVM, PSSMHANDLE pSSM);
88	static DECLCALLBACK(int) emR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
89	#if defined(LOG_ENABLED) \|\| defined(VBOX_STRICT)
90	static const char *emR3GetStateName(EMSTATE enmState);
91	#endif
92	static VBOXSTRICTRC emR3Debug(PVM pVM, PVMCPU pVCpu, VBOXSTRICTRC rc);
93	#if defined(VBOX_WITH_REM) \|\| defined(DEBUG)
94	static int emR3RemStep(PVM pVM, PVMCPU pVCpu);
95	#endif
96	static int emR3RemExecute(PVM pVM, PVMCPU pVCpu, bool *pfFFDone);
97	int emR3HighPriorityPostForcedActions(PVM pVM, PVMCPU pVCpu, int rc);
98
99
100	/**
101	* Initializes the EM.
102	*
103	* @returns VBox status code.
104	* @param pVM The cross context VM structure.
105	*/
106	VMMR3_INT_DECL(int) EMR3Init(PVM pVM)
107	{
108	LogFlow(("EMR3Init\n"));
109	/*
110	* Assert alignment and sizes.
111	*/
112	AssertCompileMemberAlignment(VM, em.s, 32);
113	AssertCompile(sizeof(pVM->em.s) <= sizeof(pVM->em.padding));
114	AssertCompile(sizeof(pVM->aCpus[0].em.s.u.FatalLongJump) <= sizeof(pVM->aCpus[0].em.s.u.achPaddingFatalLongJump));
115
116	/*
117	* Init the structure.
118	*/
119	pVM->em.s.offVM = RT_OFFSETOF(VM, em.s);
120	PCFGMNODE pCfgRoot = CFGMR3GetRoot(pVM);
121	PCFGMNODE pCfgEM = CFGMR3GetChild(pCfgRoot, "EM");
122
123	bool fEnabled;
124	int rc = CFGMR3QueryBoolDef(pCfgRoot, "RawR3Enabled", &fEnabled, true);
125	AssertLogRelRCReturn(rc, rc);
126	pVM->fRecompileUser = !fEnabled;
127
128	rc = CFGMR3QueryBoolDef(pCfgRoot, "RawR0Enabled", &fEnabled, true);
129	AssertLogRelRCReturn(rc, rc);
130	pVM->fRecompileSupervisor = !fEnabled;
131
132	#ifdef VBOX_WITH_RAW_RING1
133	rc = CFGMR3QueryBoolDef(pCfgRoot, "RawR1Enabled", &pVM->fRawRing1Enabled, false);
134	AssertLogRelRCReturn(rc, rc);
135	#else
136	pVM->fRawRing1Enabled = false; /* Disabled by default. */
137	#endif
138
139	rc = CFGMR3QueryBoolDef(pCfgEM, "IemExecutesAll", &pVM->em.s.fIemExecutesAll, false);
140	AssertLogRelRCReturn(rc, rc);
141
142	rc = CFGMR3QueryBoolDef(pCfgEM, "TripleFaultReset", &fEnabled, false);
143	AssertLogRelRCReturn(rc, rc);
144	pVM->em.s.fGuruOnTripleFault = !fEnabled;
145	if (!pVM->em.s.fGuruOnTripleFault && pVM->cCpus > 1)
146	{
147	LogRel(("EM: Overriding /EM/TripleFaultReset, must be false on SMP.\n"));
148	pVM->em.s.fGuruOnTripleFault = true;
149	}
150
151	LogRel(("EMR3Init: fRecompileUser=%RTbool fRecompileSupervisor=%RTbool fRawRing1Enabled=%RTbool fIemExecutesAll=%RTbool fGuruOnTripleFault=%RTbool\n",
152	pVM->fRecompileUser, pVM->fRecompileSupervisor, pVM->fRawRing1Enabled, pVM->em.s.fIemExecutesAll, pVM->em.s.fGuruOnTripleFault));
153
154	#ifdef VBOX_WITH_REM
155	/*
156	* Initialize the REM critical section.
157	*/
158	AssertCompileMemberAlignment(EM, CritSectREM, sizeof(uintptr_t));
159	rc = PDMR3CritSectInit(pVM, &pVM->em.s.CritSectREM, RT_SRC_POS, "EM-REM");
160	AssertRCReturn(rc, rc);
161	#endif
162
163	/*
164	* Saved state.
165	*/
166	rc = SSMR3RegisterInternal(pVM, "em", 0, EM_SAVED_STATE_VERSION, 16,
167	NULL, NULL, NULL,
168	NULL, emR3Save, NULL,
169	NULL, emR3Load, NULL);
170	if (RT_FAILURE(rc))
171	return rc;
172
173	for (VMCPUID i = 0; i < pVM->cCpus; i++)
174	{
175	PVMCPU pVCpu = &pVM->aCpus[i];
176
177	pVCpu->em.s.enmState = (i == 0) ? EMSTATE_NONE : EMSTATE_WAIT_SIPI;
178	pVCpu->em.s.enmPrevState = EMSTATE_NONE;
179	pVCpu->em.s.fForceRAW = false;
180
181	pVCpu->em.s.pCtx = CPUMQueryGuestCtxPtr(pVCpu);
182	#ifdef VBOX_WITH_RAW_MODE
183	if (VM_IS_RAW_MODE_ENABLED(pVM))
184	{
185	pVCpu->em.s.pPatmGCState = PATMR3QueryGCStateHC(pVM);
186	AssertMsg(pVCpu->em.s.pPatmGCState, ("PATMR3QueryGCStateHC failed!\n"));
187	}
188	#endif
189
190	/* Force reset of the time slice. */
191	pVCpu->em.s.u64TimeSliceStart = 0;
192
193	# define EM_REG_COUNTER(a, b, c) \
194	rc = STAMR3RegisterF(pVM, a, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, c, b, i); \
195	AssertRC(rc);
196
197	# define EM_REG_COUNTER_USED(a, b, c) \
198	rc = STAMR3RegisterF(pVM, a, STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES, c, b, i); \
199	AssertRC(rc);
200
201	# define EM_REG_PROFILE(a, b, c) \
202	rc = STAMR3RegisterF(pVM, a, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, c, b, i); \
203	AssertRC(rc);
204
205	# define EM_REG_PROFILE_ADV(a, b, c) \
206	rc = STAMR3RegisterF(pVM, a, STAMTYPE_PROFILE_ADV, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, c, b, i); \
207	AssertRC(rc);
208
209	/*
210	* Statistics.
211	*/
212	#ifdef VBOX_WITH_STATISTICS
213	PEMSTATS pStats;
214	rc = MMHyperAlloc(pVM, sizeof(pStats), 0, MM_TAG_EM, (void *)&pStats);
215	if (RT_FAILURE(rc))
216	return rc;
217
218	pVCpu->em.s.pStatsR3 = pStats;
219	pVCpu->em.s.pStatsR0 = MMHyperR3ToR0(pVM, pStats);
220	pVCpu->em.s.pStatsRC = MMHyperR3ToRC(pVM, pStats);
221
222	EM_REG_PROFILE(&pStats->StatRZEmulate, "/EM/CPU%d/RZ/Interpret", "Profiling of EMInterpretInstruction.");
223	EM_REG_PROFILE(&pStats->StatR3Emulate, "/EM/CPU%d/R3/Interpret", "Profiling of EMInterpretInstruction.");
224
225	EM_REG_PROFILE(&pStats->StatRZInterpretSucceeded, "/EM/CPU%d/RZ/Interpret/Success", "The number of times an instruction was successfully interpreted.");
226	EM_REG_PROFILE(&pStats->StatR3InterpretSucceeded, "/EM/CPU%d/R3/Interpret/Success", "The number of times an instruction was successfully interpreted.");
227
228	EM_REG_COUNTER_USED(&pStats->StatRZAnd, "/EM/CPU%d/RZ/Interpret/Success/And", "The number of times AND was successfully interpreted.");
229	EM_REG_COUNTER_USED(&pStats->StatR3And, "/EM/CPU%d/R3/Interpret/Success/And", "The number of times AND was successfully interpreted.");
230	EM_REG_COUNTER_USED(&pStats->StatRZAdd, "/EM/CPU%d/RZ/Interpret/Success/Add", "The number of times ADD was successfully interpreted.");
231	EM_REG_COUNTER_USED(&pStats->StatR3Add, "/EM/CPU%d/R3/Interpret/Success/Add", "The number of times ADD was successfully interpreted.");
232	EM_REG_COUNTER_USED(&pStats->StatRZAdc, "/EM/CPU%d/RZ/Interpret/Success/Adc", "The number of times ADC was successfully interpreted.");
233	EM_REG_COUNTER_USED(&pStats->StatR3Adc, "/EM/CPU%d/R3/Interpret/Success/Adc", "The number of times ADC was successfully interpreted.");
234	EM_REG_COUNTER_USED(&pStats->StatRZSub, "/EM/CPU%d/RZ/Interpret/Success/Sub", "The number of times SUB was successfully interpreted.");
235	EM_REG_COUNTER_USED(&pStats->StatR3Sub, "/EM/CPU%d/R3/Interpret/Success/Sub", "The number of times SUB was successfully interpreted.");
236	EM_REG_COUNTER_USED(&pStats->StatRZCpuId, "/EM/CPU%d/RZ/Interpret/Success/CpuId", "The number of times CPUID was successfully interpreted.");
237	EM_REG_COUNTER_USED(&pStats->StatR3CpuId, "/EM/CPU%d/R3/Interpret/Success/CpuId", "The number of times CPUID was successfully interpreted.");
238	EM_REG_COUNTER_USED(&pStats->StatRZDec, "/EM/CPU%d/RZ/Interpret/Success/Dec", "The number of times DEC was successfully interpreted.");
239	EM_REG_COUNTER_USED(&pStats->StatR3Dec, "/EM/CPU%d/R3/Interpret/Success/Dec", "The number of times DEC was successfully interpreted.");
240	EM_REG_COUNTER_USED(&pStats->StatRZHlt, "/EM/CPU%d/RZ/Interpret/Success/Hlt", "The number of times HLT was successfully interpreted.");
241	EM_REG_COUNTER_USED(&pStats->StatR3Hlt, "/EM/CPU%d/R3/Interpret/Success/Hlt", "The number of times HLT was successfully interpreted.");
242	EM_REG_COUNTER_USED(&pStats->StatRZInc, "/EM/CPU%d/RZ/Interpret/Success/Inc", "The number of times INC was successfully interpreted.");
243	EM_REG_COUNTER_USED(&pStats->StatR3Inc, "/EM/CPU%d/R3/Interpret/Success/Inc", "The number of times INC was successfully interpreted.");
244	EM_REG_COUNTER_USED(&pStats->StatRZInvlPg, "/EM/CPU%d/RZ/Interpret/Success/Invlpg", "The number of times INVLPG was successfully interpreted.");
245	EM_REG_COUNTER_USED(&pStats->StatR3InvlPg, "/EM/CPU%d/R3/Interpret/Success/Invlpg", "The number of times INVLPG was successfully interpreted.");
246	EM_REG_COUNTER_USED(&pStats->StatRZIret, "/EM/CPU%d/RZ/Interpret/Success/Iret", "The number of times IRET was successfully interpreted.");
247	EM_REG_COUNTER_USED(&pStats->StatR3Iret, "/EM/CPU%d/R3/Interpret/Success/Iret", "The number of times IRET was successfully interpreted.");
248	EM_REG_COUNTER_USED(&pStats->StatRZLLdt, "/EM/CPU%d/RZ/Interpret/Success/LLdt", "The number of times LLDT was successfully interpreted.");
249	EM_REG_COUNTER_USED(&pStats->StatR3LLdt, "/EM/CPU%d/R3/Interpret/Success/LLdt", "The number of times LLDT was successfully interpreted.");
250	EM_REG_COUNTER_USED(&pStats->StatRZLIdt, "/EM/CPU%d/RZ/Interpret/Success/LIdt", "The number of times LIDT was successfully interpreted.");
251	EM_REG_COUNTER_USED(&pStats->StatR3LIdt, "/EM/CPU%d/R3/Interpret/Success/LIdt", "The number of times LIDT was successfully interpreted.");
252	EM_REG_COUNTER_USED(&pStats->StatRZLGdt, "/EM/CPU%d/RZ/Interpret/Success/LGdt", "The number of times LGDT was successfully interpreted.");
253	EM_REG_COUNTER_USED(&pStats->StatR3LGdt, "/EM/CPU%d/R3/Interpret/Success/LGdt", "The number of times LGDT was successfully interpreted.");
254	EM_REG_COUNTER_USED(&pStats->StatRZMov, "/EM/CPU%d/RZ/Interpret/Success/Mov", "The number of times MOV was successfully interpreted.");
255	EM_REG_COUNTER_USED(&pStats->StatR3Mov, "/EM/CPU%d/R3/Interpret/Success/Mov", "The number of times MOV was successfully interpreted.");
256	EM_REG_COUNTER_USED(&pStats->StatRZMovCRx, "/EM/CPU%d/RZ/Interpret/Success/MovCRx", "The number of times MOV CRx was successfully interpreted.");
257	EM_REG_COUNTER_USED(&pStats->StatR3MovCRx, "/EM/CPU%d/R3/Interpret/Success/MovCRx", "The number of times MOV CRx was successfully interpreted.");
258	EM_REG_COUNTER_USED(&pStats->StatRZMovDRx, "/EM/CPU%d/RZ/Interpret/Success/MovDRx", "The number of times MOV DRx was successfully interpreted.");
259	EM_REG_COUNTER_USED(&pStats->StatR3MovDRx, "/EM/CPU%d/R3/Interpret/Success/MovDRx", "The number of times MOV DRx was successfully interpreted.");
260	EM_REG_COUNTER_USED(&pStats->StatRZOr, "/EM/CPU%d/RZ/Interpret/Success/Or", "The number of times OR was successfully interpreted.");
261	EM_REG_COUNTER_USED(&pStats->StatR3Or, "/EM/CPU%d/R3/Interpret/Success/Or", "The number of times OR was successfully interpreted.");
262	EM_REG_COUNTER_USED(&pStats->StatRZPop, "/EM/CPU%d/RZ/Interpret/Success/Pop", "The number of times POP was successfully interpreted.");
263	EM_REG_COUNTER_USED(&pStats->StatR3Pop, "/EM/CPU%d/R3/Interpret/Success/Pop", "The number of times POP was successfully interpreted.");
264	EM_REG_COUNTER_USED(&pStats->StatRZRdtsc, "/EM/CPU%d/RZ/Interpret/Success/Rdtsc", "The number of times RDTSC was successfully interpreted.");
265	EM_REG_COUNTER_USED(&pStats->StatR3Rdtsc, "/EM/CPU%d/R3/Interpret/Success/Rdtsc", "The number of times RDTSC was successfully interpreted.");
266	EM_REG_COUNTER_USED(&pStats->StatRZRdpmc, "/EM/CPU%d/RZ/Interpret/Success/Rdpmc", "The number of times RDPMC was successfully interpreted.");
267	EM_REG_COUNTER_USED(&pStats->StatR3Rdpmc, "/EM/CPU%d/R3/Interpret/Success/Rdpmc", "The number of times RDPMC was successfully interpreted.");
268	EM_REG_COUNTER_USED(&pStats->StatRZSti, "/EM/CPU%d/RZ/Interpret/Success/Sti", "The number of times STI was successfully interpreted.");
269	EM_REG_COUNTER_USED(&pStats->StatR3Sti, "/EM/CPU%d/R3/Interpret/Success/Sti", "The number of times STI was successfully interpreted.");
270	EM_REG_COUNTER_USED(&pStats->StatRZXchg, "/EM/CPU%d/RZ/Interpret/Success/Xchg", "The number of times XCHG was successfully interpreted.");
271	EM_REG_COUNTER_USED(&pStats->StatR3Xchg, "/EM/CPU%d/R3/Interpret/Success/Xchg", "The number of times XCHG was successfully interpreted.");
272	EM_REG_COUNTER_USED(&pStats->StatRZXor, "/EM/CPU%d/RZ/Interpret/Success/Xor", "The number of times XOR was successfully interpreted.");
273	EM_REG_COUNTER_USED(&pStats->StatR3Xor, "/EM/CPU%d/R3/Interpret/Success/Xor", "The number of times XOR was successfully interpreted.");
274	EM_REG_COUNTER_USED(&pStats->StatRZMonitor, "/EM/CPU%d/RZ/Interpret/Success/Monitor", "The number of times MONITOR was successfully interpreted.");
275	EM_REG_COUNTER_USED(&pStats->StatR3Monitor, "/EM/CPU%d/R3/Interpret/Success/Monitor", "The number of times MONITOR was successfully interpreted.");
276	EM_REG_COUNTER_USED(&pStats->StatRZMWait, "/EM/CPU%d/RZ/Interpret/Success/MWait", "The number of times MWAIT was successfully interpreted.");
277	EM_REG_COUNTER_USED(&pStats->StatR3MWait, "/EM/CPU%d/R3/Interpret/Success/MWait", "The number of times MWAIT was successfully interpreted.");
278	EM_REG_COUNTER_USED(&pStats->StatRZBtr, "/EM/CPU%d/RZ/Interpret/Success/Btr", "The number of times BTR was successfully interpreted.");
279	EM_REG_COUNTER_USED(&pStats->StatR3Btr, "/EM/CPU%d/R3/Interpret/Success/Btr", "The number of times BTR was successfully interpreted.");
280	EM_REG_COUNTER_USED(&pStats->StatRZBts, "/EM/CPU%d/RZ/Interpret/Success/Bts", "The number of times BTS was successfully interpreted.");
281	EM_REG_COUNTER_USED(&pStats->StatR3Bts, "/EM/CPU%d/R3/Interpret/Success/Bts", "The number of times BTS was successfully interpreted.");
282	EM_REG_COUNTER_USED(&pStats->StatRZBtc, "/EM/CPU%d/RZ/Interpret/Success/Btc", "The number of times BTC was successfully interpreted.");
283	EM_REG_COUNTER_USED(&pStats->StatR3Btc, "/EM/CPU%d/R3/Interpret/Success/Btc", "The number of times BTC was successfully interpreted.");
284	EM_REG_COUNTER_USED(&pStats->StatRZCmpXchg, "/EM/CPU%d/RZ/Interpret/Success/CmpXchg", "The number of times CMPXCHG was successfully interpreted.");
285	EM_REG_COUNTER_USED(&pStats->StatR3CmpXchg, "/EM/CPU%d/R3/Interpret/Success/CmpXchg", "The number of times CMPXCHG was successfully interpreted.");
286	EM_REG_COUNTER_USED(&pStats->StatRZCmpXchg8b, "/EM/CPU%d/RZ/Interpret/Success/CmpXchg8b", "The number of times CMPXCHG8B was successfully interpreted.");
287	EM_REG_COUNTER_USED(&pStats->StatR3CmpXchg8b, "/EM/CPU%d/R3/Interpret/Success/CmpXchg8b", "The number of times CMPXCHG8B was successfully interpreted.");
288	EM_REG_COUNTER_USED(&pStats->StatRZXAdd, "/EM/CPU%d/RZ/Interpret/Success/XAdd", "The number of times XADD was successfully interpreted.");
289	EM_REG_COUNTER_USED(&pStats->StatR3XAdd, "/EM/CPU%d/R3/Interpret/Success/XAdd", "The number of times XADD was successfully interpreted.");
290	EM_REG_COUNTER_USED(&pStats->StatR3Rdmsr, "/EM/CPU%d/R3/Interpret/Success/Rdmsr", "The number of times RDMSR was successfully interpreted.");
291	EM_REG_COUNTER_USED(&pStats->StatRZRdmsr, "/EM/CPU%d/RZ/Interpret/Success/Rdmsr", "The number of times RDMSR was successfully interpreted.");
292	EM_REG_COUNTER_USED(&pStats->StatR3Wrmsr, "/EM/CPU%d/R3/Interpret/Success/Wrmsr", "The number of times WRMSR was successfully interpreted.");
293	EM_REG_COUNTER_USED(&pStats->StatRZWrmsr, "/EM/CPU%d/RZ/Interpret/Success/Wrmsr", "The number of times WRMSR was successfully interpreted.");
294	EM_REG_COUNTER_USED(&pStats->StatR3StosWD, "/EM/CPU%d/R3/Interpret/Success/Stoswd", "The number of times STOSWD was successfully interpreted.");
295	EM_REG_COUNTER_USED(&pStats->StatRZStosWD, "/EM/CPU%d/RZ/Interpret/Success/Stoswd", "The number of times STOSWD was successfully interpreted.");
296	EM_REG_COUNTER_USED(&pStats->StatRZWbInvd, "/EM/CPU%d/RZ/Interpret/Success/WbInvd", "The number of times WBINVD was successfully interpreted.");
297	EM_REG_COUNTER_USED(&pStats->StatR3WbInvd, "/EM/CPU%d/R3/Interpret/Success/WbInvd", "The number of times WBINVD was successfully interpreted.");
298	EM_REG_COUNTER_USED(&pStats->StatRZLmsw, "/EM/CPU%d/RZ/Interpret/Success/Lmsw", "The number of times LMSW was successfully interpreted.");
299	EM_REG_COUNTER_USED(&pStats->StatR3Lmsw, "/EM/CPU%d/R3/Interpret/Success/Lmsw", "The number of times LMSW was successfully interpreted.");
300	EM_REG_COUNTER_USED(&pStats->StatRZSmsw, "/EM/CPU%d/RZ/Interpret/Success/Smsw", "The number of times SMSW was successfully interpreted.");
301	EM_REG_COUNTER_USED(&pStats->StatR3Smsw, "/EM/CPU%d/R3/Interpret/Success/Smsw", "The number of times SMSW was successfully interpreted.");
302
303	EM_REG_COUNTER(&pStats->StatRZInterpretFailed, "/EM/CPU%d/RZ/Interpret/Failed", "The number of times an instruction was not interpreted.");
304	EM_REG_COUNTER(&pStats->StatR3InterpretFailed, "/EM/CPU%d/R3/Interpret/Failed", "The number of times an instruction was not interpreted.");
305
306	EM_REG_COUNTER_USED(&pStats->StatRZFailedAnd, "/EM/CPU%d/RZ/Interpret/Failed/And", "The number of times AND was not interpreted.");
307	EM_REG_COUNTER_USED(&pStats->StatR3FailedAnd, "/EM/CPU%d/R3/Interpret/Failed/And", "The number of times AND was not interpreted.");
308	EM_REG_COUNTER_USED(&pStats->StatRZFailedCpuId, "/EM/CPU%d/RZ/Interpret/Failed/CpuId", "The number of times CPUID was not interpreted.");
309	EM_REG_COUNTER_USED(&pStats->StatR3FailedCpuId, "/EM/CPU%d/R3/Interpret/Failed/CpuId", "The number of times CPUID was not interpreted.");
310	EM_REG_COUNTER_USED(&pStats->StatRZFailedDec, "/EM/CPU%d/RZ/Interpret/Failed/Dec", "The number of times DEC was not interpreted.");
311	EM_REG_COUNTER_USED(&pStats->StatR3FailedDec, "/EM/CPU%d/R3/Interpret/Failed/Dec", "The number of times DEC was not interpreted.");
312	EM_REG_COUNTER_USED(&pStats->StatRZFailedHlt, "/EM/CPU%d/RZ/Interpret/Failed/Hlt", "The number of times HLT was not interpreted.");
313	EM_REG_COUNTER_USED(&pStats->StatR3FailedHlt, "/EM/CPU%d/R3/Interpret/Failed/Hlt", "The number of times HLT was not interpreted.");
314	EM_REG_COUNTER_USED(&pStats->StatRZFailedInc, "/EM/CPU%d/RZ/Interpret/Failed/Inc", "The number of times INC was not interpreted.");
315	EM_REG_COUNTER_USED(&pStats->StatR3FailedInc, "/EM/CPU%d/R3/Interpret/Failed/Inc", "The number of times INC was not interpreted.");
316	EM_REG_COUNTER_USED(&pStats->StatRZFailedInvlPg, "/EM/CPU%d/RZ/Interpret/Failed/InvlPg", "The number of times INVLPG was not interpreted.");
317	EM_REG_COUNTER_USED(&pStats->StatR3FailedInvlPg, "/EM/CPU%d/R3/Interpret/Failed/InvlPg", "The number of times INVLPG was not interpreted.");
318	EM_REG_COUNTER_USED(&pStats->StatRZFailedIret, "/EM/CPU%d/RZ/Interpret/Failed/Iret", "The number of times IRET was not interpreted.");
319	EM_REG_COUNTER_USED(&pStats->StatR3FailedIret, "/EM/CPU%d/R3/Interpret/Failed/Iret", "The number of times IRET was not interpreted.");
320	EM_REG_COUNTER_USED(&pStats->StatRZFailedLLdt, "/EM/CPU%d/RZ/Interpret/Failed/LLdt", "The number of times LLDT was not interpreted.");
321	EM_REG_COUNTER_USED(&pStats->StatR3FailedLLdt, "/EM/CPU%d/R3/Interpret/Failed/LLdt", "The number of times LLDT was not interpreted.");
322	EM_REG_COUNTER_USED(&pStats->StatRZFailedLIdt, "/EM/CPU%d/RZ/Interpret/Failed/LIdt", "The number of times LIDT was not interpreted.");
323	EM_REG_COUNTER_USED(&pStats->StatR3FailedLIdt, "/EM/CPU%d/R3/Interpret/Failed/LIdt", "The number of times LIDT was not interpreted.");
324	EM_REG_COUNTER_USED(&pStats->StatRZFailedLGdt, "/EM/CPU%d/RZ/Interpret/Failed/LGdt", "The number of times LGDT was not interpreted.");
325	EM_REG_COUNTER_USED(&pStats->StatR3FailedLGdt, "/EM/CPU%d/R3/Interpret/Failed/LGdt", "The number of times LGDT was not interpreted.");
326	EM_REG_COUNTER_USED(&pStats->StatRZFailedMov, "/EM/CPU%d/RZ/Interpret/Failed/Mov", "The number of times MOV was not interpreted.");
327	EM_REG_COUNTER_USED(&pStats->StatR3FailedMov, "/EM/CPU%d/R3/Interpret/Failed/Mov", "The number of times MOV was not interpreted.");
328	EM_REG_COUNTER_USED(&pStats->StatRZFailedMovCRx, "/EM/CPU%d/RZ/Interpret/Failed/MovCRx", "The number of times MOV CRx was not interpreted.");
329	EM_REG_COUNTER_USED(&pStats->StatR3FailedMovCRx, "/EM/CPU%d/R3/Interpret/Failed/MovCRx", "The number of times MOV CRx was not interpreted.");
330	EM_REG_COUNTER_USED(&pStats->StatRZFailedMovDRx, "/EM/CPU%d/RZ/Interpret/Failed/MovDRx", "The number of times MOV DRx was not interpreted.");
331	EM_REG_COUNTER_USED(&pStats->StatR3FailedMovDRx, "/EM/CPU%d/R3/Interpret/Failed/MovDRx", "The number of times MOV DRx was not interpreted.");
332	EM_REG_COUNTER_USED(&pStats->StatRZFailedOr, "/EM/CPU%d/RZ/Interpret/Failed/Or", "The number of times OR was not interpreted.");
333	EM_REG_COUNTER_USED(&pStats->StatR3FailedOr, "/EM/CPU%d/R3/Interpret/Failed/Or", "The number of times OR was not interpreted.");
334	EM_REG_COUNTER_USED(&pStats->StatRZFailedPop, "/EM/CPU%d/RZ/Interpret/Failed/Pop", "The number of times POP was not interpreted.");
335	EM_REG_COUNTER_USED(&pStats->StatR3FailedPop, "/EM/CPU%d/R3/Interpret/Failed/Pop", "The number of times POP was not interpreted.");
336	EM_REG_COUNTER_USED(&pStats->StatRZFailedSti, "/EM/CPU%d/RZ/Interpret/Failed/Sti", "The number of times STI was not interpreted.");
337	EM_REG_COUNTER_USED(&pStats->StatR3FailedSti, "/EM/CPU%d/R3/Interpret/Failed/Sti", "The number of times STI was not interpreted.");
338	EM_REG_COUNTER_USED(&pStats->StatRZFailedXchg, "/EM/CPU%d/RZ/Interpret/Failed/Xchg", "The number of times XCHG was not interpreted.");
339	EM_REG_COUNTER_USED(&pStats->StatR3FailedXchg, "/EM/CPU%d/R3/Interpret/Failed/Xchg", "The number of times XCHG was not interpreted.");
340	EM_REG_COUNTER_USED(&pStats->StatRZFailedXor, "/EM/CPU%d/RZ/Interpret/Failed/Xor", "The number of times XOR was not interpreted.");
341	EM_REG_COUNTER_USED(&pStats->StatR3FailedXor, "/EM/CPU%d/R3/Interpret/Failed/Xor", "The number of times XOR was not interpreted.");
342	EM_REG_COUNTER_USED(&pStats->StatRZFailedMonitor, "/EM/CPU%d/RZ/Interpret/Failed/Monitor", "The number of times MONITOR was not interpreted.");
343	EM_REG_COUNTER_USED(&pStats->StatR3FailedMonitor, "/EM/CPU%d/R3/Interpret/Failed/Monitor", "The number of times MONITOR was not interpreted.");
344	EM_REG_COUNTER_USED(&pStats->StatRZFailedMWait, "/EM/CPU%d/RZ/Interpret/Failed/MWait", "The number of times MWAIT was not interpreted.");
345	EM_REG_COUNTER_USED(&pStats->StatR3FailedMWait, "/EM/CPU%d/R3/Interpret/Failed/MWait", "The number of times MWAIT was not interpreted.");
346	EM_REG_COUNTER_USED(&pStats->StatRZFailedRdtsc, "/EM/CPU%d/RZ/Interpret/Failed/Rdtsc", "The number of times RDTSC was not interpreted.");
347	EM_REG_COUNTER_USED(&pStats->StatR3FailedRdtsc, "/EM/CPU%d/R3/Interpret/Failed/Rdtsc", "The number of times RDTSC was not interpreted.");
348	EM_REG_COUNTER_USED(&pStats->StatRZFailedRdpmc, "/EM/CPU%d/RZ/Interpret/Failed/Rdpmc", "The number of times RDPMC was not interpreted.");
349	EM_REG_COUNTER_USED(&pStats->StatR3FailedRdpmc, "/EM/CPU%d/R3/Interpret/Failed/Rdpmc", "The number of times RDPMC was not interpreted.");
350	EM_REG_COUNTER_USED(&pStats->StatRZFailedRdmsr, "/EM/CPU%d/RZ/Interpret/Failed/Rdmsr", "The number of times RDMSR was not interpreted.");
351	EM_REG_COUNTER_USED(&pStats->StatR3FailedRdmsr, "/EM/CPU%d/R3/Interpret/Failed/Rdmsr", "The number of times RDMSR was not interpreted.");
352	EM_REG_COUNTER_USED(&pStats->StatRZFailedWrmsr, "/EM/CPU%d/RZ/Interpret/Failed/Wrmsr", "The number of times WRMSR was not interpreted.");
353	EM_REG_COUNTER_USED(&pStats->StatR3FailedWrmsr, "/EM/CPU%d/R3/Interpret/Failed/Wrmsr", "The number of times WRMSR was not interpreted.");
354	EM_REG_COUNTER_USED(&pStats->StatRZFailedLmsw, "/EM/CPU%d/RZ/Interpret/Failed/Lmsw", "The number of times LMSW was not interpreted.");
355	EM_REG_COUNTER_USED(&pStats->StatR3FailedLmsw, "/EM/CPU%d/R3/Interpret/Failed/Lmsw", "The number of times LMSW was not interpreted.");
356	EM_REG_COUNTER_USED(&pStats->StatRZFailedSmsw, "/EM/CPU%d/RZ/Interpret/Failed/Smsw", "The number of times SMSW was not interpreted.");
357	EM_REG_COUNTER_USED(&pStats->StatR3FailedSmsw, "/EM/CPU%d/R3/Interpret/Failed/Smsw", "The number of times SMSW was not interpreted.");
358
359	EM_REG_COUNTER_USED(&pStats->StatRZFailedMisc, "/EM/CPU%d/RZ/Interpret/Failed/Misc", "The number of times some misc instruction was encountered.");
360	EM_REG_COUNTER_USED(&pStats->StatR3FailedMisc, "/EM/CPU%d/R3/Interpret/Failed/Misc", "The number of times some misc instruction was encountered.");
361	EM_REG_COUNTER_USED(&pStats->StatRZFailedAdd, "/EM/CPU%d/RZ/Interpret/Failed/Add", "The number of times ADD was not interpreted.");
362	EM_REG_COUNTER_USED(&pStats->StatR3FailedAdd, "/EM/CPU%d/R3/Interpret/Failed/Add", "The number of times ADD was not interpreted.");
363	EM_REG_COUNTER_USED(&pStats->StatRZFailedAdc, "/EM/CPU%d/RZ/Interpret/Failed/Adc", "The number of times ADC was not interpreted.");
364	EM_REG_COUNTER_USED(&pStats->StatR3FailedAdc, "/EM/CPU%d/R3/Interpret/Failed/Adc", "The number of times ADC was not interpreted.");
365	EM_REG_COUNTER_USED(&pStats->StatRZFailedBtr, "/EM/CPU%d/RZ/Interpret/Failed/Btr", "The number of times BTR was not interpreted.");
366	EM_REG_COUNTER_USED(&pStats->StatR3FailedBtr, "/EM/CPU%d/R3/Interpret/Failed/Btr", "The number of times BTR was not interpreted.");
367	EM_REG_COUNTER_USED(&pStats->StatRZFailedBts, "/EM/CPU%d/RZ/Interpret/Failed/Bts", "The number of times BTS was not interpreted.");
368	EM_REG_COUNTER_USED(&pStats->StatR3FailedBts, "/EM/CPU%d/R3/Interpret/Failed/Bts", "The number of times BTS was not interpreted.");
369	EM_REG_COUNTER_USED(&pStats->StatRZFailedBtc, "/EM/CPU%d/RZ/Interpret/Failed/Btc", "The number of times BTC was not interpreted.");
370	EM_REG_COUNTER_USED(&pStats->StatR3FailedBtc, "/EM/CPU%d/R3/Interpret/Failed/Btc", "The number of times BTC was not interpreted.");
371	EM_REG_COUNTER_USED(&pStats->StatRZFailedCli, "/EM/CPU%d/RZ/Interpret/Failed/Cli", "The number of times CLI was not interpreted.");
372	EM_REG_COUNTER_USED(&pStats->StatR3FailedCli, "/EM/CPU%d/R3/Interpret/Failed/Cli", "The number of times CLI was not interpreted.");
373	EM_REG_COUNTER_USED(&pStats->StatRZFailedCmpXchg, "/EM/CPU%d/RZ/Interpret/Failed/CmpXchg", "The number of times CMPXCHG was not interpreted.");
374	EM_REG_COUNTER_USED(&pStats->StatR3FailedCmpXchg, "/EM/CPU%d/R3/Interpret/Failed/CmpXchg", "The number of times CMPXCHG was not interpreted.");
375	EM_REG_COUNTER_USED(&pStats->StatRZFailedCmpXchg8b, "/EM/CPU%d/RZ/Interpret/Failed/CmpXchg8b", "The number of times CMPXCHG8B was not interpreted.");
376	EM_REG_COUNTER_USED(&pStats->StatR3FailedCmpXchg8b, "/EM/CPU%d/R3/Interpret/Failed/CmpXchg8b", "The number of times CMPXCHG8B was not interpreted.");
377	EM_REG_COUNTER_USED(&pStats->StatRZFailedXAdd, "/EM/CPU%d/RZ/Interpret/Failed/XAdd", "The number of times XADD was not interpreted.");
378	EM_REG_COUNTER_USED(&pStats->StatR3FailedXAdd, "/EM/CPU%d/R3/Interpret/Failed/XAdd", "The number of times XADD was not interpreted.");
379	EM_REG_COUNTER_USED(&pStats->StatRZFailedMovNTPS, "/EM/CPU%d/RZ/Interpret/Failed/MovNTPS", "The number of times MOVNTPS was not interpreted.");
380	EM_REG_COUNTER_USED(&pStats->StatR3FailedMovNTPS, "/EM/CPU%d/R3/Interpret/Failed/MovNTPS", "The number of times MOVNTPS was not interpreted.");
381	EM_REG_COUNTER_USED(&pStats->StatRZFailedStosWD, "/EM/CPU%d/RZ/Interpret/Failed/StosWD", "The number of times STOSWD was not interpreted.");
382	EM_REG_COUNTER_USED(&pStats->StatR3FailedStosWD, "/EM/CPU%d/R3/Interpret/Failed/StosWD", "The number of times STOSWD was not interpreted.");
383	EM_REG_COUNTER_USED(&pStats->StatRZFailedSub, "/EM/CPU%d/RZ/Interpret/Failed/Sub", "The number of times SUB was not interpreted.");
384	EM_REG_COUNTER_USED(&pStats->StatR3FailedSub, "/EM/CPU%d/R3/Interpret/Failed/Sub", "The number of times SUB was not interpreted.");
385	EM_REG_COUNTER_USED(&pStats->StatRZFailedWbInvd, "/EM/CPU%d/RZ/Interpret/Failed/WbInvd", "The number of times WBINVD was not interpreted.");
386	EM_REG_COUNTER_USED(&pStats->StatR3FailedWbInvd, "/EM/CPU%d/R3/Interpret/Failed/WbInvd", "The number of times WBINVD was not interpreted.");
387
388	EM_REG_COUNTER_USED(&pStats->StatRZFailedUserMode, "/EM/CPU%d/RZ/Interpret/Failed/UserMode", "The number of rejections because of CPL.");
389	EM_REG_COUNTER_USED(&pStats->StatR3FailedUserMode, "/EM/CPU%d/R3/Interpret/Failed/UserMode", "The number of rejections because of CPL.");
390	EM_REG_COUNTER_USED(&pStats->StatRZFailedPrefix, "/EM/CPU%d/RZ/Interpret/Failed/Prefix", "The number of rejections because of prefix .");
391	EM_REG_COUNTER_USED(&pStats->StatR3FailedPrefix, "/EM/CPU%d/R3/Interpret/Failed/Prefix", "The number of rejections because of prefix .");
392
393	EM_REG_COUNTER_USED(&pStats->StatIoRestarted, "/EM/CPU%d/R3/PrivInst/IoRestarted", "I/O instructions restarted in ring-3.");
394	EM_REG_COUNTER_USED(&pStats->StatIoIem, "/EM/CPU%d/R3/PrivInst/IoIem", "I/O instructions end to IEM in ring-3.");
395	EM_REG_COUNTER_USED(&pStats->StatCli, "/EM/CPU%d/R3/PrivInst/Cli", "Number of cli instructions.");
396	EM_REG_COUNTER_USED(&pStats->StatSti, "/EM/CPU%d/R3/PrivInst/Sti", "Number of sli instructions.");
397	EM_REG_COUNTER_USED(&pStats->StatHlt, "/EM/CPU%d/R3/PrivInst/Hlt", "Number of hlt instructions not handled in GC because of PATM.");
398	EM_REG_COUNTER_USED(&pStats->StatInvlpg, "/EM/CPU%d/R3/PrivInst/Invlpg", "Number of invlpg instructions.");
399	EM_REG_COUNTER_USED(&pStats->StatMisc, "/EM/CPU%d/R3/PrivInst/Misc", "Number of misc. instructions.");
400	EM_REG_COUNTER_USED(&pStats->StatMovWriteCR[0], "/EM/CPU%d/R3/PrivInst/Mov CR0, X", "Number of mov CR0 write instructions.");
401	EM_REG_COUNTER_USED(&pStats->StatMovWriteCR[1], "/EM/CPU%d/R3/PrivInst/Mov CR1, X", "Number of mov CR1 write instructions.");
402	EM_REG_COUNTER_USED(&pStats->StatMovWriteCR[2], "/EM/CPU%d/R3/PrivInst/Mov CR2, X", "Number of mov CR2 write instructions.");
403	EM_REG_COUNTER_USED(&pStats->StatMovWriteCR[3], "/EM/CPU%d/R3/PrivInst/Mov CR3, X", "Number of mov CR3 write instructions.");
404	EM_REG_COUNTER_USED(&pStats->StatMovWriteCR[4], "/EM/CPU%d/R3/PrivInst/Mov CR4, X", "Number of mov CR4 write instructions.");
405	EM_REG_COUNTER_USED(&pStats->StatMovReadCR[0], "/EM/CPU%d/R3/PrivInst/Mov X, CR0", "Number of mov CR0 read instructions.");
406	EM_REG_COUNTER_USED(&pStats->StatMovReadCR[1], "/EM/CPU%d/R3/PrivInst/Mov X, CR1", "Number of mov CR1 read instructions.");
407	EM_REG_COUNTER_USED(&pStats->StatMovReadCR[2], "/EM/CPU%d/R3/PrivInst/Mov X, CR2", "Number of mov CR2 read instructions.");
408	EM_REG_COUNTER_USED(&pStats->StatMovReadCR[3], "/EM/CPU%d/R3/PrivInst/Mov X, CR3", "Number of mov CR3 read instructions.");
409	EM_REG_COUNTER_USED(&pStats->StatMovReadCR[4], "/EM/CPU%d/R3/PrivInst/Mov X, CR4", "Number of mov CR4 read instructions.");
410	EM_REG_COUNTER_USED(&pStats->StatMovDRx, "/EM/CPU%d/R3/PrivInst/MovDRx", "Number of mov DRx instructions.");
411	EM_REG_COUNTER_USED(&pStats->StatIret, "/EM/CPU%d/R3/PrivInst/Iret", "Number of iret instructions.");
412	EM_REG_COUNTER_USED(&pStats->StatMovLgdt, "/EM/CPU%d/R3/PrivInst/Lgdt", "Number of lgdt instructions.");
413	EM_REG_COUNTER_USED(&pStats->StatMovLidt, "/EM/CPU%d/R3/PrivInst/Lidt", "Number of lidt instructions.");
414	EM_REG_COUNTER_USED(&pStats->StatMovLldt, "/EM/CPU%d/R3/PrivInst/Lldt", "Number of lldt instructions.");
415	EM_REG_COUNTER_USED(&pStats->StatSysEnter, "/EM/CPU%d/R3/PrivInst/Sysenter", "Number of sysenter instructions.");
416	EM_REG_COUNTER_USED(&pStats->StatSysExit, "/EM/CPU%d/R3/PrivInst/Sysexit", "Number of sysexit instructions.");
417	EM_REG_COUNTER_USED(&pStats->StatSysCall, "/EM/CPU%d/R3/PrivInst/Syscall", "Number of syscall instructions.");
418	EM_REG_COUNTER_USED(&pStats->StatSysRet, "/EM/CPU%d/R3/PrivInst/Sysret", "Number of sysret instructions.");
419
420	EM_REG_COUNTER(&pVCpu->em.s.StatTotalClis, "/EM/CPU%d/Cli/Total", "Total number of cli instructions executed.");
421	pVCpu->em.s.pCliStatTree = 0;
422
423	/* these should be considered for release statistics. */
424	EM_REG_COUNTER(&pVCpu->em.s.StatIOEmu, "/PROF/CPU%d/EM/Emulation/IO", "Profiling of emR3RawExecuteIOInstruction.");
425	EM_REG_COUNTER(&pVCpu->em.s.StatPrivEmu, "/PROF/CPU%d/EM/Emulation/Priv", "Profiling of emR3RawPrivileged.");
426	EM_REG_PROFILE(&pVCpu->em.s.StatHMEntry, "/PROF/CPU%d/EM/HMEnter", "Profiling Hardware Accelerated Mode entry overhead.");
427	EM_REG_PROFILE(&pVCpu->em.s.StatHMExec, "/PROF/CPU%d/EM/HMExec", "Profiling Hardware Accelerated Mode execution.");
428	EM_REG_COUNTER(&pVCpu->em.s.StatHMExecuteCalled, "/PROF/CPU%d/EM/HMExecuteCalled", "Number of times enmR3HMExecute is called.");
429	EM_REG_PROFILE(&pVCpu->em.s.StatIEMEmu, "/PROF/CPU%d/EM/IEMEmuSingle", "Profiling single instruction IEM execution.");
430	EM_REG_PROFILE(&pVCpu->em.s.StatIEMThenREM, "/PROF/CPU%d/EM/IEMThenRem", "Profiling IEM-then-REM instruction execution (by IEM).");
431	EM_REG_PROFILE(&pVCpu->em.s.StatNEMEntry, "/PROF/CPU%d/EM/NEMEnter", "Profiling NEM entry overhead.");
432	#endif /* VBOX_WITH_STATISTICS */
433	EM_REG_PROFILE(&pVCpu->em.s.StatNEMExec, "/PROF/CPU%d/EM/NEMExec", "Profiling NEM execution.");
434	EM_REG_COUNTER(&pVCpu->em.s.StatNEMExecuteCalled, "/PROF/CPU%d/EM/NEMExecuteCalled", "Number of times enmR3NEMExecute is called.");
435	#ifdef VBOX_WITH_STATISTICS
436	EM_REG_PROFILE(&pVCpu->em.s.StatREMEmu, "/PROF/CPU%d/EM/REMEmuSingle", "Profiling single instruction REM execution.");
437	EM_REG_PROFILE(&pVCpu->em.s.StatREMExec, "/PROF/CPU%d/EM/REMExec", "Profiling REM execution.");
438	EM_REG_PROFILE(&pVCpu->em.s.StatREMSync, "/PROF/CPU%d/EM/REMSync", "Profiling REM context syncing.");
439	EM_REG_PROFILE(&pVCpu->em.s.StatRAWEntry, "/PROF/CPU%d/EM/RAWEnter", "Profiling Raw Mode entry overhead.");
440	EM_REG_PROFILE(&pVCpu->em.s.StatRAWExec, "/PROF/CPU%d/EM/RAWExec", "Profiling Raw Mode execution.");
441	EM_REG_PROFILE(&pVCpu->em.s.StatRAWTail, "/PROF/CPU%d/EM/RAWTail", "Profiling Raw Mode tail overhead.");
442	#endif /* VBOX_WITH_STATISTICS */
443
444	EM_REG_COUNTER(&pVCpu->em.s.StatForcedActions, "/PROF/CPU%d/EM/ForcedActions", "Profiling forced action execution.");
445	EM_REG_COUNTER(&pVCpu->em.s.StatHalted, "/PROF/CPU%d/EM/Halted", "Profiling halted state (VMR3WaitHalted).");
446	EM_REG_PROFILE_ADV(&pVCpu->em.s.StatCapped, "/PROF/CPU%d/EM/Capped", "Profiling capped state (sleep).");
447	EM_REG_COUNTER(&pVCpu->em.s.StatREMTotal, "/PROF/CPU%d/EM/REMTotal", "Profiling emR3RemExecute (excluding FFs).");
448	EM_REG_COUNTER(&pVCpu->em.s.StatRAWTotal, "/PROF/CPU%d/EM/RAWTotal", "Profiling emR3RawExecute (excluding FFs).");
449
450	EM_REG_PROFILE_ADV(&pVCpu->em.s.StatTotal, "/PROF/CPU%d/EM/Total", "Profiling EMR3ExecuteVM.");
451	}
452
453	emR3InitDbg(pVM);
454	return VINF_SUCCESS;
455	}
456
457
458	/**
459	* Applies relocations to data and code managed by this
460	* component. This function will be called at init and
461	* whenever the VMM need to relocate it self inside the GC.
462	*
463	* @param pVM The cross context VM structure.
464	*/
465	VMMR3_INT_DECL(void) EMR3Relocate(PVM pVM)
466	{
467	LogFlow(("EMR3Relocate\n"));
468	for (VMCPUID i = 0; i < pVM->cCpus; i++)
469	{
470	PVMCPU pVCpu = &pVM->aCpus[i];
471	if (pVCpu->em.s.pStatsR3)
472	pVCpu->em.s.pStatsRC = MMHyperR3ToRC(pVM, pVCpu->em.s.pStatsR3);
473	}
474	}
475
476
477	/**
478	* Reset the EM state for a CPU.
479	*
480	* Called by EMR3Reset and hot plugging.
481	*
482	* @param pVCpu The cross context virtual CPU structure.
483	*/
484	VMMR3_INT_DECL(void) EMR3ResetCpu(PVMCPU pVCpu)
485	{
486	/* Reset scheduling state. */
487	pVCpu->em.s.fForceRAW = false;
488	VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_UNHALT);
489
490	/* VMR3ResetFF may return VINF_EM_RESET or VINF_EM_SUSPEND, so transition
491	out of the HALTED state here so that enmPrevState doesn't end up as
492	HALTED when EMR3Execute returns. */
493	if (pVCpu->em.s.enmState == EMSTATE_HALTED)
494	{
495	Log(("EMR3ResetCpu: Cpu#%u %s -> %s\n", pVCpu->idCpu, emR3GetStateName(pVCpu->em.s.enmState), pVCpu->idCpu == 0 ? "EMSTATE_NONE" : "EMSTATE_WAIT_SIPI"));
496	pVCpu->em.s.enmState = pVCpu->idCpu == 0 ? EMSTATE_NONE : EMSTATE_WAIT_SIPI;
497	}
498	}
499
500
501	/**
502	* Reset notification.
503	*
504	* @param pVM The cross context VM structure.
505	*/
506	VMMR3_INT_DECL(void) EMR3Reset(PVM pVM)
507	{
508	Log(("EMR3Reset: \n"));
509	for (VMCPUID i = 0; i < pVM->cCpus; i++)
510	EMR3ResetCpu(&pVM->aCpus[i]);
511	}
512
513
514	/**
515	* Terminates the EM.
516	*
517	* Termination means cleaning up and freeing all resources,
518	* the VM it self is at this point powered off or suspended.
519	*
520	* @returns VBox status code.
521	* @param pVM The cross context VM structure.
522	*/
523	VMMR3_INT_DECL(int) EMR3Term(PVM pVM)
524	{
525	AssertMsg(pVM->em.s.offVM, ("bad init order!\n"));
526
527	#ifdef VBOX_WITH_REM
528	PDMR3CritSectDelete(&pVM->em.s.CritSectREM);
529	#else
530	RT_NOREF(pVM);
531	#endif
532	return VINF_SUCCESS;
533	}
534
535
536	/**
537	* Execute state save operation.
538	*
539	* @returns VBox status code.
540	* @param pVM The cross context VM structure.
541	* @param pSSM SSM operation handle.
542	*/
543	static DECLCALLBACK(int) emR3Save(PVM pVM, PSSMHANDLE pSSM)
544	{
545	for (VMCPUID i = 0; i < pVM->cCpus; i++)
546	{
547	PVMCPU pVCpu = &pVM->aCpus[i];
548
549	SSMR3PutBool(pSSM, pVCpu->em.s.fForceRAW);
550
551	Assert(pVCpu->em.s.enmState == EMSTATE_SUSPENDED);
552	Assert(pVCpu->em.s.enmPrevState != EMSTATE_SUSPENDED);
553	SSMR3PutU32(pSSM, pVCpu->em.s.enmPrevState);
554
555	/* Save mwait state. */
556	SSMR3PutU32(pSSM, pVCpu->em.s.MWait.fWait);
557	SSMR3PutGCPtr(pSSM, pVCpu->em.s.MWait.uMWaitRAX);
558	SSMR3PutGCPtr(pSSM, pVCpu->em.s.MWait.uMWaitRCX);
559	SSMR3PutGCPtr(pSSM, pVCpu->em.s.MWait.uMonitorRAX);
560	SSMR3PutGCPtr(pSSM, pVCpu->em.s.MWait.uMonitorRCX);
561	int rc = SSMR3PutGCPtr(pSSM, pVCpu->em.s.MWait.uMonitorRDX);
562	AssertRCReturn(rc, rc);
563	}
564	return VINF_SUCCESS;
565	}
566
567
568	/**
569	* Execute state load operation.
570	*
571	* @returns VBox status code.
572	* @param pVM The cross context VM structure.
573	* @param pSSM SSM operation handle.
574	* @param uVersion Data layout version.
575	* @param uPass The data pass.
576	*/
577	static DECLCALLBACK(int) emR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
578	{
579	/*
580	* Validate version.
581	*/
582	if ( uVersion > EM_SAVED_STATE_VERSION
583	\|\| uVersion < EM_SAVED_STATE_VERSION_PRE_SMP)
584	{
585	AssertMsgFailed(("emR3Load: Invalid version uVersion=%d (current %d)!\n", uVersion, EM_SAVED_STATE_VERSION));
586	return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
587	}
588	Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
589
590	/*
591	* Load the saved state.
592	*/
593	for (VMCPUID i = 0; i < pVM->cCpus; i++)
594	{
595	PVMCPU pVCpu = &pVM->aCpus[i];
596
597	int rc = SSMR3GetBool(pSSM, &pVCpu->em.s.fForceRAW);
598	if (RT_FAILURE(rc))
599	pVCpu->em.s.fForceRAW = false;
600	AssertRCReturn(rc, rc);
601
602	if (uVersion > EM_SAVED_STATE_VERSION_PRE_SMP)
603	{
604	AssertCompile(sizeof(pVCpu->em.s.enmPrevState) == sizeof(uint32_t));
605	rc = SSMR3GetU32(pSSM, (uint32_t *)&pVCpu->em.s.enmPrevState);
606	AssertRCReturn(rc, rc);
607	Assert(pVCpu->em.s.enmPrevState != EMSTATE_SUSPENDED);
608
609	pVCpu->em.s.enmState = EMSTATE_SUSPENDED;
610	}
611	if (uVersion > EM_SAVED_STATE_VERSION_PRE_MWAIT)
612	{
613	/* Load mwait state. */
614	rc = SSMR3GetU32(pSSM, &pVCpu->em.s.MWait.fWait);
615	AssertRCReturn(rc, rc);
616	rc = SSMR3GetGCPtr(pSSM, &pVCpu->em.s.MWait.uMWaitRAX);
617	AssertRCReturn(rc, rc);
618	rc = SSMR3GetGCPtr(pSSM, &pVCpu->em.s.MWait.uMWaitRCX);
619	AssertRCReturn(rc, rc);
620	rc = SSMR3GetGCPtr(pSSM, &pVCpu->em.s.MWait.uMonitorRAX);
621	AssertRCReturn(rc, rc);
622	rc = SSMR3GetGCPtr(pSSM, &pVCpu->em.s.MWait.uMonitorRCX);
623	AssertRCReturn(rc, rc);
624	rc = SSMR3GetGCPtr(pSSM, &pVCpu->em.s.MWait.uMonitorRDX);
625	AssertRCReturn(rc, rc);
626	}
627
628	Assert(!pVCpu->em.s.pCliStatTree);
629	}
630	return VINF_SUCCESS;
631	}
632
633
634	/**
635	* Argument packet for emR3SetExecutionPolicy.
636	*/
637	struct EMR3SETEXECPOLICYARGS
638	{
639	EMEXECPOLICY enmPolicy;
640	bool fEnforce;
641	};
642
643
644	/**
645	* @callback_method_impl{FNVMMEMTRENDEZVOUS, Rendezvous callback for EMR3SetExecutionPolicy.}
646	*/
647	static DECLCALLBACK(VBOXSTRICTRC) emR3SetExecutionPolicy(PVM pVM, PVMCPU pVCpu, void *pvUser)
648	{
649	/*
650	* Only the first CPU changes the variables.
651	*/
652	if (pVCpu->idCpu == 0)
653	{
654	struct EMR3SETEXECPOLICYARGS pArgs = (struct EMR3SETEXECPOLICYARGS )pvUser;
655	switch (pArgs->enmPolicy)
656	{
657	case EMEXECPOLICY_RECOMPILE_RING0:
658	pVM->fRecompileSupervisor = pArgs->fEnforce;
659	break;
660	case EMEXECPOLICY_RECOMPILE_RING3:
661	pVM->fRecompileUser = pArgs->fEnforce;
662	break;
663	case EMEXECPOLICY_IEM_ALL:
664	pVM->em.s.fIemExecutesAll = pArgs->fEnforce;
665	break;
666	default:
667	AssertFailedReturn(VERR_INVALID_PARAMETER);
668	}
669	LogRel(("emR3SetExecutionPolicy: fRecompileUser=%RTbool fRecompileSupervisor=%RTbool fIemExecutesAll=%RTbool\n",
670	pVM->fRecompileUser, pVM->fRecompileSupervisor, pVM->em.s.fIemExecutesAll));
671	}
672
673	/*
674	* Force rescheduling if in RAW, HM, NEM, IEM, or REM.
675	*/
676	return pVCpu->em.s.enmState == EMSTATE_RAW
677	\|\| pVCpu->em.s.enmState == EMSTATE_HM
678	\|\| pVCpu->em.s.enmState == EMSTATE_NEM
679	\|\| pVCpu->em.s.enmState == EMSTATE_IEM
680	\|\| pVCpu->em.s.enmState == EMSTATE_REM
681	\|\| pVCpu->em.s.enmState == EMSTATE_IEM_THEN_REM
682	? VINF_EM_RESCHEDULE
683	: VINF_SUCCESS;
684	}
685
686
687	/**
688	* Changes an execution scheduling policy parameter.
689	*
690	* This is used to enable or disable raw-mode / hardware-virtualization
691	* execution of user and supervisor code.
692	*
693	* @returns VINF_SUCCESS on success.
694	* @returns VINF_RESCHEDULE if a rescheduling might be required.
695	* @returns VERR_INVALID_PARAMETER on an invalid enmMode value.
696	*
697	* @param pUVM The user mode VM handle.
698	* @param enmPolicy The scheduling policy to change.
699	* @param fEnforce Whether to enforce the policy or not.
700	*/
701	VMMR3DECL(int) EMR3SetExecutionPolicy(PUVM pUVM, EMEXECPOLICY enmPolicy, bool fEnforce)
702	{
703	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
704	VM_ASSERT_VALID_EXT_RETURN(pUVM->pVM, VERR_INVALID_VM_HANDLE);
705	AssertReturn(enmPolicy > EMEXECPOLICY_INVALID && enmPolicy < EMEXECPOLICY_END, VERR_INVALID_PARAMETER);
706
707	struct EMR3SETEXECPOLICYARGS Args = { enmPolicy, fEnforce };
708	return VMMR3EmtRendezvous(pUVM->pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_DESCENDING, emR3SetExecutionPolicy, &Args);
709	}
710
711
712	/**
713	* Queries an execution scheduling policy parameter.
714	*
715	* @returns VBox status code
716	* @param pUVM The user mode VM handle.
717	* @param enmPolicy The scheduling policy to query.
718	* @param pfEnforced Where to return the current value.
719	*/
720	VMMR3DECL(int) EMR3QueryExecutionPolicy(PUVM pUVM, EMEXECPOLICY enmPolicy, bool *pfEnforced)
721	{
722	AssertReturn(enmPolicy > EMEXECPOLICY_INVALID && enmPolicy < EMEXECPOLICY_END, VERR_INVALID_PARAMETER);
723	AssertPtrReturn(pfEnforced, VERR_INVALID_POINTER);
724	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
725	PVM pVM = pUVM->pVM;
726	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
727
728	/* No need to bother EMTs with a query. */
729	switch (enmPolicy)
730	{
731	case EMEXECPOLICY_RECOMPILE_RING0:
732	*pfEnforced = pVM->fRecompileSupervisor;
733	break;
734	case EMEXECPOLICY_RECOMPILE_RING3:
735	*pfEnforced = pVM->fRecompileUser;
736	break;
737	case EMEXECPOLICY_IEM_ALL:
738	*pfEnforced = pVM->em.s.fIemExecutesAll;
739	break;
740	default:
741	AssertFailedReturn(VERR_INTERNAL_ERROR_2);
742	}
743
744	return VINF_SUCCESS;
745	}
746
747
748	/**
749	* Queries the main execution engine of the VM.
750	*
751	* @returns VBox status code
752	* @param pUVM The user mode VM handle.
753	* @param pbMainExecutionEngine Where to return the result, VM_EXEC_ENGINE_XXX.
754	*/
755	VMMR3DECL(int) EMR3QueryMainExecutionEngine(PUVM pUVM, uint8_t *pbMainExecutionEngine)
756	{
757	AssertPtrReturn(pbMainExecutionEngine, VERR_INVALID_POINTER);
758	*pbMainExecutionEngine = VM_EXEC_ENGINE_NOT_SET;
759
760	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
761	PVM pVM = pUVM->pVM;
762	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
763
764	*pbMainExecutionEngine = pVM->bMainExecutionEngine;
765	return VINF_SUCCESS;
766	}
767
768
769	/**
770	* Raise a fatal error.
771	*
772	* Safely terminate the VM with full state report and stuff. This function
773	* will naturally never return.
774	*
775	* @param pVCpu The cross context virtual CPU structure.
776	* @param rc VBox status code.
777	*/
778	VMMR3DECL(void) EMR3FatalError(PVMCPU pVCpu, int rc)
779	{
780	pVCpu->em.s.enmState = EMSTATE_GURU_MEDITATION;
781	longjmp(pVCpu->em.s.u.FatalLongJump, rc);
782	}
783
784
785	#if defined(LOG_ENABLED) \|\| defined(VBOX_STRICT)
786	/**
787	* Gets the EM state name.
788	*
789	* @returns pointer to read only state name,
790	* @param enmState The state.
791	*/
792	static const char *emR3GetStateName(EMSTATE enmState)
793	{
794	switch (enmState)
795	{
796	case EMSTATE_NONE: return "EMSTATE_NONE";
797	case EMSTATE_RAW: return "EMSTATE_RAW";
798	case EMSTATE_HM: return "EMSTATE_HM";
799	case EMSTATE_IEM: return "EMSTATE_IEM";
800	case EMSTATE_REM: return "EMSTATE_REM";
801	case EMSTATE_HALTED: return "EMSTATE_HALTED";
802	case EMSTATE_WAIT_SIPI: return "EMSTATE_WAIT_SIPI";
803	case EMSTATE_SUSPENDED: return "EMSTATE_SUSPENDED";
804	case EMSTATE_TERMINATING: return "EMSTATE_TERMINATING";
805	case EMSTATE_DEBUG_GUEST_RAW: return "EMSTATE_DEBUG_GUEST_RAW";
806	case EMSTATE_DEBUG_GUEST_HM: return "EMSTATE_DEBUG_GUEST_HM";
807	case EMSTATE_DEBUG_GUEST_IEM: return "EMSTATE_DEBUG_GUEST_IEM";
808	case EMSTATE_DEBUG_GUEST_REM: return "EMSTATE_DEBUG_GUEST_REM";
809	case EMSTATE_DEBUG_HYPER: return "EMSTATE_DEBUG_HYPER";
810	case EMSTATE_GURU_MEDITATION: return "EMSTATE_GURU_MEDITATION";
811	case EMSTATE_IEM_THEN_REM: return "EMSTATE_IEM_THEN_REM";
812	case EMSTATE_NEM: return "EMSTATE_NEM";
813	case EMSTATE_DEBUG_GUEST_NEM: return "EMSTATE_DEBUG_GUEST_NEM";
814	default: return "Unknown!";
815	}
816	}
817	#endif /* LOG_ENABLED \|\| VBOX_STRICT */
818
819
820	/**
821	* Debug loop.
822	*
823	* @returns VBox status code for EM.
824	* @param pVM The cross context VM structure.
825	* @param pVCpu The cross context virtual CPU structure.
826	* @param rc Current EM VBox status code.
827	*/
828	static VBOXSTRICTRC emR3Debug(PVM pVM, PVMCPU pVCpu, VBOXSTRICTRC rc)
829	{
830	for (;;)
831	{
832	Log(("emR3Debug: rc=%Rrc\n", VBOXSTRICTRC_VAL(rc)));
833	const VBOXSTRICTRC rcLast = rc;
834
835	/*
836	* Debug related RC.
837	*/
838	switch (VBOXSTRICTRC_VAL(rc))
839	{
840	/*
841	* Single step an instruction.
842	*/
843	case VINF_EM_DBG_STEP:
844	if ( pVCpu->em.s.enmState == EMSTATE_DEBUG_GUEST_RAW
845	\|\| pVCpu->em.s.enmState == EMSTATE_DEBUG_HYPER
846	\|\| pVCpu->em.s.fForceRAW /* paranoia */)
847	#ifdef VBOX_WITH_RAW_MODE
848	rc = emR3RawStep(pVM, pVCpu);
849	#else
850	AssertLogRelMsgFailedStmt(("Bad EM state."), VERR_EM_INTERNAL_ERROR);
851	#endif
852	else if (pVCpu->em.s.enmState == EMSTATE_DEBUG_GUEST_HM)
853	rc = EMR3HmSingleInstruction(pVM, pVCpu, 0 /fFlags/);
854	else if (pVCpu->em.s.enmState == EMSTATE_DEBUG_GUEST_NEM)
855	rc = VBOXSTRICTRC_TODO(emR3NemSingleInstruction(pVM, pVCpu, 0 /fFlags/));
856	#ifdef VBOX_WITH_REM
857	else if (pVCpu->em.s.enmState == EMSTATE_DEBUG_GUEST_REM)
858	rc = emR3RemStep(pVM, pVCpu);
859	#endif
860	else
861	{
862	rc = IEMExecOne(pVCpu); /** @todo add dedicated interface... */
863	if (rc == VINF_SUCCESS \|\| rc == VINF_EM_RESCHEDULE)
864	rc = VINF_EM_DBG_STEPPED;
865	}
866	break;
867
868	/*
869	* Simple events: stepped, breakpoint, stop/assertion.
870	*/
871	case VINF_EM_DBG_STEPPED:
872	rc = DBGFR3Event(pVM, DBGFEVENT_STEPPED);
873	break;
874
875	case VINF_EM_DBG_BREAKPOINT:
876	rc = DBGFR3EventBreakpoint(pVM, DBGFEVENT_BREAKPOINT);
877	break;
878
879	case VINF_EM_DBG_STOP:
880	rc = DBGFR3EventSrc(pVM, DBGFEVENT_DEV_STOP, NULL, 0, NULL, NULL);
881	break;
882
883	case VINF_EM_DBG_EVENT:
884	rc = DBGFR3EventHandlePending(pVM, pVCpu);
885	break;
886
887	case VINF_EM_DBG_HYPER_STEPPED:
888	rc = DBGFR3Event(pVM, DBGFEVENT_STEPPED_HYPER);
889	break;
890
891	case VINF_EM_DBG_HYPER_BREAKPOINT:
892	rc = DBGFR3EventBreakpoint(pVM, DBGFEVENT_BREAKPOINT_HYPER);
893	break;
894
895	case VINF_EM_DBG_HYPER_ASSERTION:
896	RTPrintf("\nVINF_EM_DBG_HYPER_ASSERTION:\n%s%s\n", VMMR3GetRZAssertMsg1(pVM), VMMR3GetRZAssertMsg2(pVM));
897	RTLogFlush(NULL);
898	rc = DBGFR3EventAssertion(pVM, DBGFEVENT_ASSERTION_HYPER, VMMR3GetRZAssertMsg1(pVM), VMMR3GetRZAssertMsg2(pVM));
899	break;
900
901	/*
902	* Guru meditation.
903	*/
904	case VERR_VMM_RING0_ASSERTION: /** @todo Make a guru meditation event! */
905	rc = DBGFR3EventSrc(pVM, DBGFEVENT_FATAL_ERROR, "VERR_VMM_RING0_ASSERTION", 0, NULL, NULL);
906	break;
907	case VERR_REM_TOO_MANY_TRAPS: /** @todo Make a guru meditation event! */
908	rc = DBGFR3EventSrc(pVM, DBGFEVENT_DEV_STOP, "VERR_REM_TOO_MANY_TRAPS", 0, NULL, NULL);
909	break;
910	case VINF_EM_TRIPLE_FAULT: /** @todo Make a guru meditation event! */
911	rc = DBGFR3EventSrc(pVM, DBGFEVENT_DEV_STOP, "VINF_EM_TRIPLE_FAULT", 0, NULL, NULL);
912	break;
913
914	default: /** @todo don't use default for guru, but make special errors code! */
915	{
916	LogRel(("emR3Debug: rc=%Rrc\n", VBOXSTRICTRC_VAL(rc)));
917	rc = DBGFR3Event(pVM, DBGFEVENT_FATAL_ERROR);
918	break;
919	}
920	}
921
922	/*
923	* Process the result.
924	*/
925	switch (VBOXSTRICTRC_VAL(rc))
926	{
927	/*
928	* Continue the debugging loop.
929	*/
930	case VINF_EM_DBG_STEP:
931	case VINF_EM_DBG_STOP:
932	case VINF_EM_DBG_EVENT:
933	case VINF_EM_DBG_STEPPED:
934	case VINF_EM_DBG_BREAKPOINT:
935	case VINF_EM_DBG_HYPER_STEPPED:
936	case VINF_EM_DBG_HYPER_BREAKPOINT:
937	case VINF_EM_DBG_HYPER_ASSERTION:
938	break;
939
940	/*
941	* Resuming execution (in some form) has to be done here if we got
942	* a hypervisor debug event.
943	*/
944	case VINF_SUCCESS:
945	case VINF_EM_RESUME:
946	case VINF_EM_SUSPEND:
947	case VINF_EM_RESCHEDULE:
948	case VINF_EM_RESCHEDULE_RAW:
949	case VINF_EM_RESCHEDULE_REM:
950	case VINF_EM_HALT:
951	if (pVCpu->em.s.enmState == EMSTATE_DEBUG_HYPER)
952	{
953	#ifdef VBOX_WITH_RAW_MODE
954	rc = emR3RawResumeHyper(pVM, pVCpu);
955	if (rc != VINF_SUCCESS && RT_SUCCESS(rc))
956	continue;
957	#else
958	AssertLogRelMsgFailedReturn(("Not implemented\n"), VERR_EM_INTERNAL_ERROR);
959	#endif
960	}
961	if (rc == VINF_SUCCESS)
962	rc = VINF_EM_RESCHEDULE;
963	return rc;
964
965	/*
966	* The debugger isn't attached.
967	* We'll simply turn the thing off since that's the easiest thing to do.
968	*/
969	case VERR_DBGF_NOT_ATTACHED:
970	switch (VBOXSTRICTRC_VAL(rcLast))
971	{
972	case VINF_EM_DBG_HYPER_STEPPED:
973	case VINF_EM_DBG_HYPER_BREAKPOINT:
974	case VINF_EM_DBG_HYPER_ASSERTION:
975	case VERR_TRPM_PANIC:
976	case VERR_TRPM_DONT_PANIC:
977	case VERR_VMM_RING0_ASSERTION:
978	case VERR_VMM_HYPER_CR3_MISMATCH:
979	case VERR_VMM_RING3_CALL_DISABLED:
980	return rcLast;
981	}
982	return VINF_EM_OFF;
983
984	/*
985	* Status codes terminating the VM in one or another sense.
986	*/
987	case VINF_EM_TERMINATE:
988	case VINF_EM_OFF:
989	case VINF_EM_RESET:
990	case VINF_EM_NO_MEMORY:
991	case VINF_EM_RAW_STALE_SELECTOR:
992	case VINF_EM_RAW_IRET_TRAP:
993	case VERR_TRPM_PANIC:
994	case VERR_TRPM_DONT_PANIC:
995	case VERR_IEM_INSTR_NOT_IMPLEMENTED:
996	case VERR_IEM_ASPECT_NOT_IMPLEMENTED:
997	case VERR_VMM_RING0_ASSERTION:
998	case VERR_VMM_HYPER_CR3_MISMATCH:
999	case VERR_VMM_RING3_CALL_DISABLED:
1000	case VERR_INTERNAL_ERROR:
1001	case VERR_INTERNAL_ERROR_2:
1002	case VERR_INTERNAL_ERROR_3:
1003	case VERR_INTERNAL_ERROR_4:
1004	case VERR_INTERNAL_ERROR_5:
1005	case VERR_IPE_UNEXPECTED_STATUS:
1006	case VERR_IPE_UNEXPECTED_INFO_STATUS:
1007	case VERR_IPE_UNEXPECTED_ERROR_STATUS:
1008	return rc;
1009
1010	/*
1011	* The rest is unexpected, and will keep us here.
1012	*/
1013	default:
1014	AssertMsgFailed(("Unexpected rc %Rrc!\n", VBOXSTRICTRC_VAL(rc)));
1015	break;
1016	}
1017	} /* debug for ever */
1018	}
1019
1020
1021	#if defined(VBOX_WITH_REM) \|\| defined(DEBUG)
1022	/**
1023	* Steps recompiled code.
1024	*
1025	* @returns VBox status code. The most important ones are: VINF_EM_STEP_EVENT,
1026	* VINF_EM_RESCHEDULE, VINF_EM_SUSPEND, VINF_EM_RESET and VINF_EM_TERMINATE.
1027	*
1028	* @param pVM The cross context VM structure.
1029	* @param pVCpu The cross context virtual CPU structure.
1030	*/
1031	static int emR3RemStep(PVM pVM, PVMCPU pVCpu)
1032	{
1033	Log3(("emR3RemStep: cs:eip=%04x:%08x\n", CPUMGetGuestCS(pVCpu), CPUMGetGuestEIP(pVCpu)));
1034
1035	# ifdef VBOX_WITH_REM
1036	EMRemLock(pVM);
1037
1038	/*
1039	* Switch to REM, step instruction, switch back.
1040	*/
1041	int rc = REMR3State(pVM, pVCpu);
1042	if (RT_SUCCESS(rc))
1043	{
1044	rc = REMR3Step(pVM, pVCpu);
1045	REMR3StateBack(pVM, pVCpu);
1046	}
1047	EMRemUnlock(pVM);
1048
1049	# else
1050	int rc = VBOXSTRICTRC_TODO(IEMExecOne(pVCpu)); NOREF(pVM);
1051	# endif
1052
1053	Log3(("emR3RemStep: returns %Rrc cs:eip=%04x:%08x\n", rc, CPUMGetGuestCS(pVCpu), CPUMGetGuestEIP(pVCpu)));
1054	return rc;
1055	}
1056	#endif /* VBOX_WITH_REM \|\| DEBUG */
1057
1058
1059	#ifdef VBOX_WITH_REM
1060	/**
1061	* emR3RemExecute helper that syncs the state back from REM and leave the REM
1062	* critical section.
1063	*
1064	* @returns false - new fInREMState value.
1065	* @param pVM The cross context VM structure.
1066	* @param pVCpu The cross context virtual CPU structure.
1067	*/
1068	DECLINLINE(bool) emR3RemExecuteSyncBack(PVM pVM, PVMCPU pVCpu)
1069	{
1070	STAM_PROFILE_START(&pVCpu->em.s.StatREMSync, a);
1071	REMR3StateBack(pVM, pVCpu);
1072	STAM_PROFILE_STOP(&pVCpu->em.s.StatREMSync, a);
1073
1074	EMRemUnlock(pVM);
1075	return false;
1076	}
1077	#endif
1078
1079
1080	/**
1081	* Executes recompiled code.
1082	*
1083	* This function contains the recompiler version of the inner
1084	* execution loop (the outer loop being in EMR3ExecuteVM()).
1085	*
1086	* @returns VBox status code. The most important ones are: VINF_EM_RESCHEDULE,
1087	* VINF_EM_SUSPEND, VINF_EM_RESET and VINF_EM_TERMINATE.
1088	*
1089	* @param pVM The cross context VM structure.
1090	* @param pVCpu The cross context virtual CPU structure.
1091	* @param pfFFDone Where to store an indicator telling whether or not
1092	* FFs were done before returning.
1093	*
1094	*/
1095	static int emR3RemExecute(PVM pVM, PVMCPU pVCpu, bool *pfFFDone)
1096	{
1097	#ifdef LOG_ENABLED
1098	PCPUMCTX pCtx = pVCpu->em.s.pCtx;
1099	uint32_t cpl = CPUMGetGuestCPL(pVCpu);
1100
1101	if (pCtx->eflags.Bits.u1VM)
1102	Log(("EMV86: %04X:%08X IF=%d\n", pCtx->cs.Sel, pCtx->eip, pCtx->eflags.Bits.u1IF));
1103	else
1104	Log(("EMR%d: %04X:%08X ESP=%08X IF=%d CR0=%x eflags=%x\n", cpl, pCtx->cs.Sel, pCtx->eip, pCtx->esp, pCtx->eflags.Bits.u1IF, (uint32_t)pCtx->cr0, pCtx->eflags.u));
1105	#endif
1106	STAM_REL_PROFILE_ADV_START(&pVCpu->em.s.StatREMTotal, a);
1107
1108	#if defined(VBOX_STRICT) && defined(DEBUG_bird)
1109	AssertMsg( VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_PGM_SYNC_CR3 \| VMCPU_FF_PGM_SYNC_CR3_NON_GLOBAL)
1110	\|\| !MMHyperIsInsideArea(pVM, CPUMGetGuestEIP(pVCpu)), /** @todo @bugref{1419} - get flat address. */
1111	("cs:eip=%RX16:%RX32\n", CPUMGetGuestCS(pVCpu), CPUMGetGuestEIP(pVCpu)));
1112	#endif
1113
1114	/*
1115	* Spin till we get a forced action which returns anything but VINF_SUCCESS
1116	* or the REM suggests raw-mode execution.
1117	*/
1118	*pfFFDone = false;
1119	#ifdef VBOX_WITH_REM
1120	bool fInREMState = false;
1121	#else
1122	uint32_t cLoops = 0;
1123	#endif
1124	int rc = VINF_SUCCESS;
1125	for (;;)
1126	{
1127	#ifdef VBOX_WITH_REM
1128	/*
1129	* Lock REM and update the state if not already in sync.
1130	*
1131	* Note! Big lock, but you are not supposed to own any lock when
1132	* coming in here.
1133	*/
1134	if (!fInREMState)
1135	{
1136	EMRemLock(pVM);
1137	STAM_PROFILE_START(&pVCpu->em.s.StatREMSync, b);
1138
1139	/* Flush the recompiler translation blocks if the VCPU has changed,
1140	also force a full CPU state resync. */
1141	if (pVM->em.s.idLastRemCpu != pVCpu->idCpu)
1142	{
1143	REMFlushTBs(pVM);
1144	CPUMSetChangedFlags(pVCpu, CPUM_CHANGED_ALL);
1145	}
1146	pVM->em.s.idLastRemCpu = pVCpu->idCpu;
1147
1148	rc = REMR3State(pVM, pVCpu);
1149
1150	STAM_PROFILE_STOP(&pVCpu->em.s.StatREMSync, b);
1151	if (RT_FAILURE(rc))
1152	break;
1153	fInREMState = true;
1154
1155	/*
1156	* We might have missed the raising of VMREQ, TIMER and some other
1157	* important FFs while we were busy switching the state. So, check again.
1158	*/
1159	if ( VM_FF_IS_PENDING(pVM, VM_FF_REQUEST \| VM_FF_PDM_QUEUES \| VM_FF_DBGF \| VM_FF_CHECK_VM_STATE \| VM_FF_RESET)
1160	\|\| VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_TIMER \| VMCPU_FF_REQUEST))
1161	{
1162	LogFlow(("emR3RemExecute: Skipping run, because FF is set. %#x\n", pVM->fGlobalForcedActions));
1163	goto l_REMDoForcedActions;
1164	}
1165	}
1166	#endif
1167
1168	/*
1169	* Execute REM.
1170	*/
1171	if (RT_LIKELY(emR3IsExecutionAllowed(pVM, pVCpu)))
1172	{
1173	STAM_PROFILE_START(&pVCpu->em.s.StatREMExec, c);
1174	#ifdef VBOX_WITH_REM
1175	rc = REMR3Run(pVM, pVCpu);
1176	#else
1177	rc = VBOXSTRICTRC_TODO(IEMExecLots(pVCpu, NULL /pcInstructions/));
1178	#endif
1179	STAM_PROFILE_STOP(&pVCpu->em.s.StatREMExec, c);
1180	}
1181	else
1182	{
1183	/* Give up this time slice; virtual time continues */
1184	STAM_REL_PROFILE_ADV_START(&pVCpu->em.s.StatCapped, u);
1185	RTThreadSleep(5);
1186	STAM_REL_PROFILE_ADV_STOP(&pVCpu->em.s.StatCapped, u);
1187	rc = VINF_SUCCESS;
1188	}
1189
1190	/*
1191	* Deal with high priority post execution FFs before doing anything
1192	* else. Sync back the state and leave the lock to be on the safe side.
1193	*/
1194	if ( VM_FF_IS_PENDING(pVM, VM_FF_HIGH_PRIORITY_POST_MASK)
1195	\|\| VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HIGH_PRIORITY_POST_MASK))
1196	{
1197	#ifdef VBOX_WITH_REM
1198	fInREMState = emR3RemExecuteSyncBack(pVM, pVCpu);
1199	#endif
1200	rc = emR3HighPriorityPostForcedActions(pVM, pVCpu, rc);
1201	}
1202
1203	/*
1204	* Process the returned status code.
1205	*/
1206	if (rc != VINF_SUCCESS)
1207	{
1208	if (rc >= VINF_EM_FIRST && rc <= VINF_EM_LAST)
1209	break;
1210	if (rc != VINF_REM_INTERRUPED_FF)
1211	{
1212	#ifndef VBOX_WITH_REM
1213	/* Try dodge unimplemented IEM trouble by reschduling. */
1214	if ( rc == VERR_IEM_ASPECT_NOT_IMPLEMENTED
1215	\|\| rc == VERR_IEM_INSTR_NOT_IMPLEMENTED)
1216	{
1217	EMSTATE enmNewState = emR3Reschedule(pVM, pVCpu, pVCpu->em.s.pCtx);
1218	if (enmNewState != EMSTATE_REM && enmNewState != EMSTATE_IEM_THEN_REM)
1219	{
1220	rc = VINF_EM_RESCHEDULE;
1221	break;
1222	}
1223	}
1224	#endif
1225
1226	/*
1227	* Anything which is not known to us means an internal error
1228	* and the termination of the VM!
1229	*/
1230	AssertMsg(rc == VERR_REM_TOO_MANY_TRAPS, ("Unknown GC return code: %Rra\n", rc));
1231	break;
1232	}
1233	}
1234
1235
1236	/*
1237	* Check and execute forced actions.
1238	*
1239	* Sync back the VM state and leave the lock before calling any of
1240	* these, you never know what's going to happen here.
1241	*/
1242	#ifdef VBOX_HIGH_RES_TIMERS_HACK
1243	TMTimerPollVoid(pVM, pVCpu);
1244	#endif
1245	AssertCompile(VMCPU_FF_ALL_REM_MASK & VMCPU_FF_TIMER);
1246	if ( VM_FF_IS_PENDING(pVM, VM_FF_ALL_REM_MASK)
1247	\|\| VMCPU_FF_IS_PENDING(pVCpu,
1248	VMCPU_FF_ALL_REM_MASK
1249	& VM_WHEN_RAW_MODE(~(VMCPU_FF_CSAM_PENDING_ACTION \| VMCPU_FF_CSAM_SCAN_PAGE), UINT32_MAX)) )
1250	{
1251	#ifdef VBOX_WITH_REM
1252	l_REMDoForcedActions:
1253	if (fInREMState)
1254	fInREMState = emR3RemExecuteSyncBack(pVM, pVCpu);
1255	#endif
1256	STAM_REL_PROFILE_ADV_SUSPEND(&pVCpu->em.s.StatREMTotal, a);
1257	rc = emR3ForcedActions(pVM, pVCpu, rc);
1258	VBOXVMM_EM_FF_ALL_RET(pVCpu, rc);
1259	STAM_REL_PROFILE_ADV_RESUME(&pVCpu->em.s.StatREMTotal, a);
1260	if ( rc != VINF_SUCCESS
1261	&& rc != VINF_EM_RESCHEDULE_REM)
1262	{
1263	*pfFFDone = true;
1264	break;
1265	}
1266	}
1267
1268	#ifndef VBOX_WITH_REM
1269	/*
1270	* Have to check if we can get back to fast execution mode every so often.
1271	*/
1272	if (!(++cLoops & 7))
1273	{
1274	EMSTATE enmCheck = emR3Reschedule(pVM, pVCpu, pVCpu->em.s.pCtx);
1275	if ( enmCheck != EMSTATE_REM
1276	&& enmCheck != EMSTATE_IEM_THEN_REM)
1277	return VINF_EM_RESCHEDULE;
1278	}
1279	#endif
1280
1281	} /* The Inner Loop, recompiled execution mode version. */
1282
1283
1284	#ifdef VBOX_WITH_REM
1285	/*
1286	* Returning. Sync back the VM state if required.
1287	*/
1288	if (fInREMState)
1289	fInREMState = emR3RemExecuteSyncBack(pVM, pVCpu);
1290	#endif
1291
1292	STAM_REL_PROFILE_ADV_STOP(&pVCpu->em.s.StatREMTotal, a);
1293	return rc;
1294	}
1295
1296
1297	#ifdef DEBUG
1298
1299	int emR3SingleStepExecRem(PVM pVM, PVMCPU pVCpu, uint32_t cIterations)
1300	{
1301	EMSTATE enmOldState = pVCpu->em.s.enmState;
1302
1303	pVCpu->em.s.enmState = EMSTATE_DEBUG_GUEST_REM;
1304
1305	Log(("Single step BEGIN:\n"));
1306	for (uint32_t i = 0; i < cIterations; i++)
1307	{
1308	DBGFR3PrgStep(pVCpu);
1309	DBGFR3_DISAS_INSTR_CUR_LOG(pVCpu, "RSS");
1310	emR3RemStep(pVM, pVCpu);
1311	if (emR3Reschedule(pVM, pVCpu, pVCpu->em.s.pCtx) != EMSTATE_REM)
1312	break;
1313	}
1314	Log(("Single step END:\n"));
1315	CPUMSetGuestEFlags(pVCpu, CPUMGetGuestEFlags(pVCpu) & ~X86_EFL_TF);
1316	pVCpu->em.s.enmState = enmOldState;
1317	return VINF_EM_RESCHEDULE;
1318	}
1319
1320	#endif /* DEBUG */
1321
1322
1323	/**
1324	* Try execute the problematic code in IEM first, then fall back on REM if there
1325	* is too much of it or if IEM doesn't implement something.
1326	*
1327	* @returns Strict VBox status code from IEMExecLots.
1328	* @param pVM The cross context VM structure.
1329	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
1330	* @param pfFFDone Force flags done indicator.
1331	*
1332	* @thread EMT(pVCpu)
1333	*/
1334	static VBOXSTRICTRC emR3ExecuteIemThenRem(PVM pVM, PVMCPU pVCpu, bool *pfFFDone)
1335	{
1336	LogFlow(("emR3ExecuteIemThenRem: %04x:%RGv\n", CPUMGetGuestCS(pVCpu), CPUMGetGuestRIP(pVCpu)));
1337	*pfFFDone = false;
1338
1339	/*
1340	* Execute in IEM for a while.
1341	*/
1342	while (pVCpu->em.s.cIemThenRemInstructions < 1024)
1343	{
1344	uint32_t cInstructions;
1345	VBOXSTRICTRC rcStrict = IEMExecLots(pVCpu, &cInstructions);
1346	pVCpu->em.s.cIemThenRemInstructions += cInstructions;
1347	if (rcStrict != VINF_SUCCESS)
1348	{
1349	if ( rcStrict == VERR_IEM_ASPECT_NOT_IMPLEMENTED
1350	\|\| rcStrict == VERR_IEM_INSTR_NOT_IMPLEMENTED)
1351	break;
1352
1353	Log(("emR3ExecuteIemThenRem: returns %Rrc after %u instructions\n",
1354	VBOXSTRICTRC_VAL(rcStrict), pVCpu->em.s.cIemThenRemInstructions));
1355	return rcStrict;
1356	}
1357
1358	EMSTATE enmNewState = emR3Reschedule(pVM, pVCpu, pVCpu->em.s.pCtx);
1359	if (enmNewState != EMSTATE_REM && enmNewState != EMSTATE_IEM_THEN_REM)
1360	{
1361	LogFlow(("emR3ExecuteIemThenRem: -> %d (%s) after %u instructions\n",
1362	enmNewState, emR3GetStateName(enmNewState), pVCpu->em.s.cIemThenRemInstructions));
1363	pVCpu->em.s.enmPrevState = pVCpu->em.s.enmState;
1364	pVCpu->em.s.enmState = enmNewState;
1365	return VINF_SUCCESS;
1366	}
1367
1368	/*
1369	* Check for pending actions.
1370	*/
1371	if ( VM_FF_IS_PENDING(pVM, VM_FF_ALL_REM_MASK)
1372	\|\| VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_ALL_REM_MASK & ~VMCPU_FF_UNHALT))
1373	return VINF_SUCCESS;
1374	}
1375
1376	/*
1377	* Switch to REM.
1378	*/
1379	Log(("emR3ExecuteIemThenRem: -> EMSTATE_REM (after %u instructions)\n", pVCpu->em.s.cIemThenRemInstructions));
1380	pVCpu->em.s.enmState = EMSTATE_REM;
1381	return VINF_SUCCESS;
1382	}
1383
1384
1385	/**
1386	* Decides whether to execute RAW, HWACC or REM.
1387	*
1388	* @returns new EM state
1389	* @param pVM The cross context VM structure.
1390	* @param pVCpu The cross context virtual CPU structure.
1391	* @param pCtx Pointer to the guest CPU context.
1392	*/
1393	EMSTATE emR3Reschedule(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx)
1394	{
1395	/*
1396	* When forcing raw-mode execution, things are simple.
1397	*/
1398	if (pVCpu->em.s.fForceRAW)
1399	return EMSTATE_RAW;
1400
1401	/*
1402	* We stay in the wait for SIPI state unless explicitly told otherwise.
1403	*/
1404	if (pVCpu->em.s.enmState == EMSTATE_WAIT_SIPI)
1405	return EMSTATE_WAIT_SIPI;
1406
1407	/*
1408	* Execute everything in IEM?
1409	*/
1410	if (pVM->em.s.fIemExecutesAll)
1411	return EMSTATE_IEM;
1412
1413	/* !!! THIS MUST BE IN SYNC WITH remR3CanExecuteRaw !!! */
1414	/* !!! THIS MUST BE IN SYNC WITH remR3CanExecuteRaw !!! */
1415	/* !!! THIS MUST BE IN SYNC WITH remR3CanExecuteRaw !!! */
1416
1417	X86EFLAGS EFlags = pCtx->eflags;
1418	if (!VM_IS_RAW_MODE_ENABLED(pVM))
1419	{
1420	if (EMIsHwVirtExecutionEnabled(pVM))
1421	{
1422	if (VM_IS_HM_ENABLED(pVM))
1423	{
1424	if (HMR3CanExecuteGuest(pVM, pCtx))
1425	return EMSTATE_HM;
1426	}
1427	else if (NEMR3CanExecuteGuest(pVM, pVCpu, pCtx))
1428	return EMSTATE_NEM;
1429
1430	/*
1431	* Note! Raw mode and hw accelerated mode are incompatible. The latter
1432	* turns off monitoring features essential for raw mode!
1433	*/
1434	return EMSTATE_IEM_THEN_REM;
1435	}
1436	}
1437
1438	/*
1439	* Standard raw-mode:
1440	*
1441	* Here we only support 16 & 32 bits protected mode ring 3 code that has no IO privileges
1442	* or 32 bits protected mode ring 0 code
1443	*
1444	* The tests are ordered by the likelihood of being true during normal execution.
1445	*/
1446	if (EFlags.u32 & (X86_EFL_TF /* \| HF_INHIBIT_IRQ_MASK*/))
1447	{
1448	Log2(("raw mode refused: EFlags=%#x\n", EFlags.u32));
1449	return EMSTATE_REM;
1450	}
1451
1452	# ifndef VBOX_RAW_V86
1453	if (EFlags.u32 & X86_EFL_VM) {
1454	Log2(("raw mode refused: VM_MASK\n"));
1455	return EMSTATE_REM;
1456	}
1457	# endif
1458
1459	/** @todo check up the X86_CR0_AM flag in respect to raw mode!!! We're probably not emulating it right! */
1460	uint32_t u32CR0 = pCtx->cr0;
1461	if ((u32CR0 & (X86_CR0_PG \| X86_CR0_PE)) != (X86_CR0_PG \| X86_CR0_PE))
1462	{
1463	//Log2(("raw mode refused: %s%s%s\n", (u32CR0 & X86_CR0_PG) ? "" : " !PG", (u32CR0 & X86_CR0_PE) ? "" : " !PE", (u32CR0 & X86_CR0_AM) ? "" : " !AM"));
1464	return EMSTATE_REM;
1465	}
1466
1467	if (pCtx->cr4 & X86_CR4_PAE)
1468	{
1469	uint32_t u32Dummy, u32Features;
1470
1471	CPUMGetGuestCpuId(pVCpu, 1, 0, &u32Dummy, &u32Dummy, &u32Dummy, &u32Features);
1472	if (!(u32Features & X86_CPUID_FEATURE_EDX_PAE))
1473	return EMSTATE_REM;
1474	}
1475
1476	unsigned uSS = pCtx->ss.Sel;
1477	if ( pCtx->eflags.Bits.u1VM
1478	\|\| (uSS & X86_SEL_RPL) == 3)
1479	{
1480	if (!EMIsRawRing3Enabled(pVM))
1481	return EMSTATE_REM;
1482
1483	if (!(EFlags.u32 & X86_EFL_IF))
1484	{
1485	Log2(("raw mode refused: IF (RawR3)\n"));
1486	return EMSTATE_REM;
1487	}
1488
1489	if (!(u32CR0 & X86_CR0_WP) && EMIsRawRing0Enabled(pVM))
1490	{
1491	Log2(("raw mode refused: CR0.WP + RawR0\n"));
1492	return EMSTATE_REM;
1493	}
1494	}
1495	else
1496	{
1497	if (!EMIsRawRing0Enabled(pVM))
1498	return EMSTATE_REM;
1499
1500	if (EMIsRawRing1Enabled(pVM))
1501	{
1502	/* Only ring 0 and 1 supervisor code. */
1503	if ((uSS & X86_SEL_RPL) == 2) /* ring 1 code is moved into ring 2, so we can't support ring-2 in that case. */
1504	{
1505	Log2(("raw r0 mode refused: CPL %d\n", uSS & X86_SEL_RPL));
1506	return EMSTATE_REM;
1507	}
1508	}
1509	/* Only ring 0 supervisor code. */
1510	else if ((uSS & X86_SEL_RPL) != 0)
1511	{
1512	Log2(("raw r0 mode refused: CPL %d\n", uSS & X86_SEL_RPL));
1513	return EMSTATE_REM;
1514	}
1515
1516	// Let's start with pure 32 bits ring 0 code first
1517	/** @todo What's pure 32-bit mode? flat? */
1518	if ( !(pCtx->ss.Attr.n.u1DefBig)
1519	\|\| !(pCtx->cs.Attr.n.u1DefBig))
1520	{
1521	Log2(("raw r0 mode refused: SS/CS not 32bit\n"));
1522	return EMSTATE_REM;
1523	}
1524
1525	/* Write protection must be turned on, or else the guest can overwrite our hypervisor code and data. */
1526	if (!(u32CR0 & X86_CR0_WP))
1527	{
1528	Log2(("raw r0 mode refused: CR0.WP=0!\n"));
1529	return EMSTATE_REM;
1530	}
1531
1532	# ifdef VBOX_WITH_RAW_MODE
1533	if (PATMShouldUseRawMode(pVM, (RTGCPTR)pCtx->eip))
1534	{
1535	Log2(("raw r0 mode forced: patch code\n"));
1536	# ifdef VBOX_WITH_SAFE_STR
1537	Assert(pCtx->tr.Sel);
1538	# endif
1539	return EMSTATE_RAW;
1540	}
1541	# endif /* VBOX_WITH_RAW_MODE */
1542
1543	# if !defined(VBOX_ALLOW_IF0) && !defined(VBOX_RUN_INTERRUPT_GATE_HANDLERS)
1544	if (!(EFlags.u32 & X86_EFL_IF))
1545	{
1546	////Log2(("R0: IF=0 VIF=%d %08X\n", eip, pVMeflags));
1547	//Log2(("RR0: Interrupts turned off; fall back to emulation\n"));
1548	return EMSTATE_REM;
1549	}
1550	# endif
1551
1552	# ifndef VBOX_WITH_RAW_RING1
1553	/** @todo still necessary??? */
1554	if (EFlags.Bits.u2IOPL != 0)
1555	{
1556	Log2(("raw r0 mode refused: IOPL %d\n", EFlags.Bits.u2IOPL));
1557	return EMSTATE_REM;
1558	}
1559	# endif
1560	}
1561
1562	/*
1563	* Stale hidden selectors means raw-mode is unsafe (being very careful).
1564	*/
1565	if (pCtx->cs.fFlags & CPUMSELREG_FLAGS_STALE)
1566	{
1567	Log2(("raw mode refused: stale CS\n"));
1568	return EMSTATE_REM;
1569	}
1570	if (pCtx->ss.fFlags & CPUMSELREG_FLAGS_STALE)
1571	{
1572	Log2(("raw mode refused: stale SS\n"));
1573	return EMSTATE_REM;
1574	}
1575	if (pCtx->ds.fFlags & CPUMSELREG_FLAGS_STALE)
1576	{
1577	Log2(("raw mode refused: stale DS\n"));
1578	return EMSTATE_REM;
1579	}
1580	if (pCtx->es.fFlags & CPUMSELREG_FLAGS_STALE)
1581	{
1582	Log2(("raw mode refused: stale ES\n"));
1583	return EMSTATE_REM;
1584	}
1585	if (pCtx->fs.fFlags & CPUMSELREG_FLAGS_STALE)
1586	{
1587	Log2(("raw mode refused: stale FS\n"));
1588	return EMSTATE_REM;
1589	}
1590	if (pCtx->gs.fFlags & CPUMSELREG_FLAGS_STALE)
1591	{
1592	Log2(("raw mode refused: stale GS\n"));
1593	return EMSTATE_REM;
1594	}
1595
1596	# ifdef VBOX_WITH_SAFE_STR
1597	if (pCtx->tr.Sel == 0)
1598	{
1599	Log(("Raw mode refused -> TR=0\n"));
1600	return EMSTATE_REM;
1601	}
1602	# endif
1603
1604	/Assert(PGMPhysIsA20Enabled(pVCpu));/
1605	return EMSTATE_RAW;
1606	}
1607
1608
1609	/**
1610	* Executes all high priority post execution force actions.
1611	*
1612	* @returns rc or a fatal status code.
1613	*
1614	* @param pVM The cross context VM structure.
1615	* @param pVCpu The cross context virtual CPU structure.
1616	* @param rc The current rc.
1617	*/
1618	int emR3HighPriorityPostForcedActions(PVM pVM, PVMCPU pVCpu, int rc)
1619	{
1620	VBOXVMM_EM_FF_HIGH(pVCpu, pVM->fGlobalForcedActions, pVCpu->fLocalForcedActions, rc);
1621
1622	if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_PDM_CRITSECT))
1623	PDMCritSectBothFF(pVCpu);
1624
1625	/* Update CR3 (Nested Paging case for HM). */
1626	if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HM_UPDATE_CR3))
1627	{
1628	int rc2 = PGMUpdateCR3(pVCpu, CPUMGetGuestCR3(pVCpu));
1629	if (RT_FAILURE(rc2))
1630	return rc2;
1631	Assert(!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HM_UPDATE_CR3));
1632	}
1633
1634	/* Update PAE PDPEs. This must be done after PGMUpdateCR3() and used only by the Nested Paging case for HM. */
1635	if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HM_UPDATE_PAE_PDPES))
1636	{
1637	if (CPUMIsGuestInPAEMode(pVCpu))
1638	{
1639	PX86PDPE pPdpes = HMGetPaePdpes(pVCpu);
1640	AssertPtr(pPdpes);
1641
1642	PGMGstUpdatePaePdpes(pVCpu, pPdpes);
1643	Assert(!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HM_UPDATE_PAE_PDPES));
1644	}
1645	else
1646	VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_HM_UPDATE_PAE_PDPES);
1647	}
1648
1649	/* IEM has pending work (typically memory write after INS instruction). */
1650	if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_IEM))
1651	rc = VBOXSTRICTRC_TODO(IEMR3ProcessForceFlag(pVM, pVCpu, rc));
1652
1653	/* IOM has pending work (comitting an I/O or MMIO write). */
1654	if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_IOM))
1655	rc = VBOXSTRICTRC_TODO(IOMR3ProcessForceFlag(pVM, pVCpu, rc));
1656
1657	#ifdef VBOX_WITH_RAW_MODE
1658	if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_CSAM_PENDING_ACTION))
1659	CSAMR3DoPendingAction(pVM, pVCpu);
1660	#endif
1661
1662	if (VM_FF_IS_PENDING(pVM, VM_FF_PGM_NO_MEMORY))
1663	{
1664	if ( rc > VINF_EM_NO_MEMORY
1665	&& rc <= VINF_EM_LAST)
1666	rc = VINF_EM_NO_MEMORY;
1667	}
1668
1669	return rc;
1670	}
1671
1672	#ifdef VBOX_WITH_NESTED_HWVIRT_SVM
1673	/**
1674	* Helper for emR3ForcedActions() for injecting interrupts into the
1675	* nested-guest.
1676	*
1677	* @returns VBox status code.
1678	* @param pVCpu The cross context virtual CPU structure.
1679	* @param pCtx Pointer to the nested-guest CPU context.
1680	* @param pfResched Where to store whether a reschedule is required.
1681	* @param pfInject Where to store whether an interrupt was injected (and if
1682	* a wake up is pending).
1683	*/
1684	static int emR3NstGstInjectIntr(PVMCPU pVCpu, PCPUMCTX pCtx, bool pfResched, bool pfInject)
1685	{
1686	*pfResched = false;
1687	*pfInject = false;
1688	if (CPUMIsGuestInSvmNestedHwVirtMode(pCtx))
1689	{
1690	PVM pVM = pVCpu->CTX_SUFF(pVM);
1691	Assert(pCtx->hwvirt.fGif);
1692	bool fVirtualGif = CPUMGetSvmNstGstVGif(pCtx);
1693	#ifdef VBOX_WITH_RAW_MODE
1694	fVirtualGif &= !PATMIsPatchGCAddr(pVM, pCtx->eip);
1695	#endif
1696	if (fVirtualGif)
1697	{
1698	if (CPUMCanSvmNstGstTakePhysIntr(pVCpu, pCtx))
1699	{
1700	Assert(pVCpu->em.s.enmState != EMSTATE_WAIT_SIPI);
1701	if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_APIC \| VMCPU_FF_INTERRUPT_PIC))
1702	{
1703	if (CPUMIsGuestSvmCtrlInterceptSet(pVCpu, pCtx, SVM_CTRL_INTERCEPT_INTR))
1704	{
1705	VBOXSTRICTRC rcStrict = IEMExecSvmVmexit(pVCpu, SVM_EXIT_INTR, 0, 0);
1706	if (RT_SUCCESS(rcStrict))
1707	{
1708	/** @todo r=ramshankar: Do we need to signal a wakeup here? If a nested-guest
1709	* doesn't intercept HLT but intercepts INTR? */
1710	*pfResched = true;
1711	Assert(rcStrict != VINF_PGM_CHANGE_MODE);
1712	if (rcStrict == VINF_SVM_VMEXIT)
1713	return VINF_SUCCESS;
1714	return VBOXSTRICTRC_VAL(rcStrict);
1715	}
1716
1717	AssertMsgFailed(("INTR #VMEXIT failed! rc=%Rrc\n", VBOXSTRICTRC_VAL(rcStrict)));
1718	return VINF_EM_TRIPLE_FAULT;
1719	}
1720
1721	/* Note: it's important to make sure the return code from TRPMR3InjectEvent isn't ignored! */
1722	/** @todo this really isn't nice, should properly handle this */
1723	int rc = TRPMR3InjectEvent(pVM, pVCpu, TRPM_HARDWARE_INT);
1724	Assert(rc != VINF_PGM_CHANGE_MODE);
1725	if (rc == VINF_SVM_VMEXIT)
1726	rc = VINF_SUCCESS;
1727	if (pVM->em.s.fIemExecutesAll && ( rc == VINF_EM_RESCHEDULE_REM
1728	\|\| rc == VINF_EM_RESCHEDULE_HM
1729	\|\| rc == VINF_EM_RESCHEDULE_RAW))
1730	{
1731	rc = VINF_EM_RESCHEDULE;
1732	}
1733
1734	*pfResched = true;
1735	*pfInject = true;
1736	return rc;
1737	}
1738	}
1739
1740	if ( VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_NESTED_GUEST)
1741	&& CPUMCanSvmNstGstTakeVirtIntr(pVCpu, pCtx))
1742	{
1743	if (CPUMIsGuestSvmCtrlInterceptSet(pVCpu, pCtx, SVM_CTRL_INTERCEPT_VINTR))
1744	{
1745	VBOXSTRICTRC rcStrict = IEMExecSvmVmexit(pVCpu, SVM_EXIT_VINTR, 0, 0);
1746	if (RT_SUCCESS(rcStrict))
1747	{
1748	/** @todo r=ramshankar: Do we need to signal a wakeup here? If a nested-guest
1749	* doesn't intercept HLT but intercepts VINTR? */
1750	*pfResched = true;
1751	Assert(rcStrict != VINF_PGM_CHANGE_MODE);
1752	if (rcStrict == VINF_SVM_VMEXIT)
1753	return VINF_SUCCESS;
1754	return VBOXSTRICTRC_VAL(rcStrict);
1755	}
1756
1757	AssertMsgFailed(("VINTR #VMEXIT failed! rc=%Rrc\n", VBOXSTRICTRC_VAL(rcStrict)));
1758	return VINF_EM_TRIPLE_FAULT;
1759	}
1760
1761	VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INTERRUPT_NESTED_GUEST);
1762	uint8_t const uNstGstVector = CPUMGetSvmNstGstInterrupt(pCtx);
1763	AssertMsg(uNstGstVector > 0 && uNstGstVector <= X86_XCPT_LAST, ("Invalid VINTR vector %#x\n", uNstGstVector));
1764	TRPMAssertTrap(pVCpu, uNstGstVector, TRPM_HARDWARE_INT);
1765	Log(("EM: Asserting nested-guest virt. hardware intr: %#x\n", uNstGstVector));
1766
1767	*pfResched = true;
1768	*pfInject = true;
1769	return VINF_EM_RESCHEDULE;
1770	}
1771	}
1772	return VINF_SUCCESS;
1773	}
1774
1775	if (CPUMIsGuestInVmxNestedHwVirtMode(pCtx))
1776	{ /** @todo Nested VMX. */ }
1777
1778	/* Shouldn't really get here. */
1779	AssertMsgFailed(("Unrecognized nested hwvirt. arch!\n"));
1780	return VERR_EM_INTERNAL_ERROR;
1781	}
1782	#endif
1783
1784	/**
1785	* Executes all pending forced actions.
1786	*
1787	* Forced actions can cause execution delays and execution
1788	* rescheduling. The first we deal with using action priority, so
1789	* that for instance pending timers aren't scheduled and ran until
1790	* right before execution. The rescheduling we deal with using
1791	* return codes. The same goes for VM termination, only in that case
1792	* we exit everything.
1793	*
1794	* @returns VBox status code of equal or greater importance/severity than rc.
1795	* The most important ones are: VINF_EM_RESCHEDULE,
1796	* VINF_EM_SUSPEND, VINF_EM_RESET and VINF_EM_TERMINATE.
1797	*
1798	* @param pVM The cross context VM structure.
1799	* @param pVCpu The cross context virtual CPU structure.
1800	* @param rc The current rc.
1801	*
1802	*/
1803	int emR3ForcedActions(PVM pVM, PVMCPU pVCpu, int rc)
1804	{
1805	STAM_REL_PROFILE_START(&pVCpu->em.s.StatForcedActions, a);
1806	#ifdef VBOX_STRICT
1807	int rcIrq = VINF_SUCCESS;
1808	#endif
1809	int rc2;
1810	#define UPDATE_RC() \
1811	do { \
1812	AssertMsg(rc2 <= 0 \|\| (rc2 >= VINF_EM_FIRST && rc2 <= VINF_EM_LAST), ("Invalid FF return code: %Rra\n", rc2)); \
1813	if (rc2 == VINF_SUCCESS \|\| rc < VINF_SUCCESS) \
1814	break; \
1815	if (!rc \|\| rc2 < rc) \
1816	rc = rc2; \
1817	} while (0)
1818	VBOXVMM_EM_FF_ALL(pVCpu, pVM->fGlobalForcedActions, pVCpu->fLocalForcedActions, rc);
1819
1820	/*
1821	* Post execution chunk first.
1822	*/
1823	if ( VM_FF_IS_PENDING(pVM, VM_FF_NORMAL_PRIORITY_POST_MASK)
1824	\|\| (VMCPU_FF_NORMAL_PRIORITY_POST_MASK && VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_NORMAL_PRIORITY_POST_MASK)) )
1825	{
1826	/*
1827	* EMT Rendezvous (must be serviced before termination).
1828	*/
1829	if (VM_FF_IS_PENDING(pVM, VM_FF_EMT_RENDEZVOUS))
1830	{
1831	rc2 = VMMR3EmtRendezvousFF(pVM, pVCpu);
1832	UPDATE_RC();
1833	/** @todo HACK ALERT! The following test is to make sure EM+TM
1834	* thinks the VM is stopped/reset before the next VM state change
1835	* is made. We need a better solution for this, or at least make it
1836	* possible to do: (rc >= VINF_EM_FIRST && rc <=
1837	* VINF_EM_SUSPEND). */
1838	if (RT_UNLIKELY(rc == VINF_EM_SUSPEND \|\| rc == VINF_EM_RESET \|\| rc == VINF_EM_OFF))
1839	{
1840	Log2(("emR3ForcedActions: returns %Rrc\n", rc));
1841	STAM_REL_PROFILE_STOP(&pVCpu->em.s.StatForcedActions, a);
1842	return rc;
1843	}
1844	}
1845
1846	/*
1847	* State change request (cleared by vmR3SetStateLocked).
1848	*/
1849	if (VM_FF_IS_PENDING(pVM, VM_FF_CHECK_VM_STATE))
1850	{
1851	VMSTATE enmState = VMR3GetState(pVM);
1852	switch (enmState)
1853	{
1854	case VMSTATE_FATAL_ERROR:
1855	case VMSTATE_FATAL_ERROR_LS:
1856	case VMSTATE_GURU_MEDITATION:
1857	case VMSTATE_GURU_MEDITATION_LS:
1858	Log2(("emR3ForcedActions: %s -> VINF_EM_SUSPEND\n", VMGetStateName(enmState) ));
1859	STAM_REL_PROFILE_STOP(&pVCpu->em.s.StatForcedActions, a);
1860	return VINF_EM_SUSPEND;
1861
1862	case VMSTATE_DESTROYING:
1863	Log2(("emR3ForcedActions: %s -> VINF_EM_TERMINATE\n", VMGetStateName(enmState) ));
1864	STAM_REL_PROFILE_STOP(&pVCpu->em.s.StatForcedActions, a);
1865	return VINF_EM_TERMINATE;
1866
1867	default:
1868	AssertMsgFailed(("%s\n", VMGetStateName(enmState)));
1869	}
1870	}
1871
1872	/*
1873	* Debugger Facility polling.
1874	*/
1875	if ( VM_FF_IS_PENDING(pVM, VM_FF_DBGF)
1876	\|\| VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_DBGF) )
1877	{
1878	rc2 = DBGFR3VMMForcedAction(pVM, pVCpu);
1879	UPDATE_RC();
1880	}
1881
1882	/*
1883	* Postponed reset request.
1884	*/
1885	if (VM_FF_TEST_AND_CLEAR(pVM, VM_FF_RESET))
1886	{
1887	rc2 = VBOXSTRICTRC_TODO(VMR3ResetFF(pVM));
1888	UPDATE_RC();
1889	}
1890
1891	#ifdef VBOX_WITH_RAW_MODE
1892	/*
1893	* CSAM page scanning.
1894	*/
1895	if ( !VM_FF_IS_PENDING(pVM, VM_FF_PGM_NO_MEMORY)
1896	&& VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_CSAM_SCAN_PAGE))
1897	{
1898	PCPUMCTX pCtx = pVCpu->em.s.pCtx;
1899
1900	/** @todo check for 16 or 32 bits code! (D bit in the code selector) */
1901	Log(("Forced action VMCPU_FF_CSAM_SCAN_PAGE\n"));
1902
1903	CSAMR3CheckCodeEx(pVM, pCtx, pCtx->eip);
1904	VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_CSAM_SCAN_PAGE);
1905	}
1906	#endif
1907
1908	/*
1909	* Out of memory? Putting this after CSAM as it may in theory cause us to run out of memory.
1910	*/
1911	if (VM_FF_IS_PENDING(pVM, VM_FF_PGM_NO_MEMORY))
1912	{
1913	rc2 = PGMR3PhysAllocateHandyPages(pVM);
1914	UPDATE_RC();
1915	if (rc == VINF_EM_NO_MEMORY)
1916	return rc;
1917	}
1918
1919	/* check that we got them all */
1920	AssertCompile(VM_FF_NORMAL_PRIORITY_POST_MASK == (VM_FF_CHECK_VM_STATE \| VM_FF_DBGF \| VM_FF_RESET \| VM_FF_PGM_NO_MEMORY \| VM_FF_EMT_RENDEZVOUS));
1921	AssertCompile(VMCPU_FF_NORMAL_PRIORITY_POST_MASK == (VM_WHEN_RAW_MODE(VMCPU_FF_CSAM_SCAN_PAGE, 0) \| VMCPU_FF_DBGF));
1922	}
1923
1924	/*
1925	* Normal priority then.
1926	* (Executed in no particular order.)
1927	*/
1928	if (VM_FF_IS_PENDING_EXCEPT(pVM, VM_FF_NORMAL_PRIORITY_MASK, VM_FF_PGM_NO_MEMORY))
1929	{
1930	/*
1931	* PDM Queues are pending.
1932	*/
1933	if (VM_FF_IS_PENDING_EXCEPT(pVM, VM_FF_PDM_QUEUES, VM_FF_PGM_NO_MEMORY))
1934	PDMR3QueueFlushAll(pVM);
1935
1936	/*
1937	* PDM DMA transfers are pending.
1938	*/
1939	if (VM_FF_IS_PENDING_EXCEPT(pVM, VM_FF_PDM_DMA, VM_FF_PGM_NO_MEMORY))
1940	PDMR3DmaRun(pVM);
1941
1942	/*
1943	* EMT Rendezvous (make sure they are handled before the requests).
1944	*/
1945	if (VM_FF_IS_PENDING(pVM, VM_FF_EMT_RENDEZVOUS))
1946	{
1947	rc2 = VMMR3EmtRendezvousFF(pVM, pVCpu);
1948	UPDATE_RC();
1949	/** @todo HACK ALERT! The following test is to make sure EM+TM
1950	* thinks the VM is stopped/reset before the next VM state change
1951	* is made. We need a better solution for this, or at least make it
1952	* possible to do: (rc >= VINF_EM_FIRST && rc <=
1953	* VINF_EM_SUSPEND). */
1954	if (RT_UNLIKELY(rc == VINF_EM_SUSPEND \|\| rc == VINF_EM_RESET \|\| rc == VINF_EM_OFF))
1955	{
1956	Log2(("emR3ForcedActions: returns %Rrc\n", rc));
1957	STAM_REL_PROFILE_STOP(&pVCpu->em.s.StatForcedActions, a);
1958	return rc;
1959	}
1960	}
1961
1962	/*
1963	* Requests from other threads.
1964	*/
1965	if (VM_FF_IS_PENDING_EXCEPT(pVM, VM_FF_REQUEST, VM_FF_PGM_NO_MEMORY))
1966	{
1967	rc2 = VMR3ReqProcessU(pVM->pUVM, VMCPUID_ANY, false /fPriorityOnly/);
1968	if (rc2 == VINF_EM_OFF \|\| rc2 == VINF_EM_TERMINATE) /** @todo this shouldn't be necessary */
1969	{
1970	Log2(("emR3ForcedActions: returns %Rrc\n", rc2));
1971	STAM_REL_PROFILE_STOP(&pVCpu->em.s.StatForcedActions, a);
1972	return rc2;
1973	}
1974	UPDATE_RC();
1975	/** @todo HACK ALERT! The following test is to make sure EM+TM
1976	* thinks the VM is stopped/reset before the next VM state change
1977	* is made. We need a better solution for this, or at least make it
1978	* possible to do: (rc >= VINF_EM_FIRST && rc <=
1979	* VINF_EM_SUSPEND). */
1980	if (RT_UNLIKELY(rc == VINF_EM_SUSPEND \|\| rc == VINF_EM_RESET \|\| rc == VINF_EM_OFF))
1981	{
1982	Log2(("emR3ForcedActions: returns %Rrc\n", rc));
1983	STAM_REL_PROFILE_STOP(&pVCpu->em.s.StatForcedActions, a);
1984	return rc;
1985	}
1986	}
1987
1988	#ifdef VBOX_WITH_REM
1989	/* Replay the handler notification changes. */
1990	if (VM_FF_IS_PENDING_EXCEPT(pVM, VM_FF_REM_HANDLER_NOTIFY, VM_FF_PGM_NO_MEMORY))
1991	{
1992	/* Try not to cause deadlocks. */
1993	if ( pVM->cCpus == 1
1994	\|\| ( !PGMIsLockOwner(pVM)
1995	&& !IOMIsLockWriteOwner(pVM))
1996	)
1997	{
1998	EMRemLock(pVM);
1999	REMR3ReplayHandlerNotifications(pVM);
2000	EMRemUnlock(pVM);
2001	}
2002	}
2003	#endif
2004
2005	/* check that we got them all */
2006	AssertCompile(VM_FF_NORMAL_PRIORITY_MASK == (VM_FF_REQUEST \| VM_FF_PDM_QUEUES \| VM_FF_PDM_DMA \| VM_FF_REM_HANDLER_NOTIFY \| VM_FF_EMT_RENDEZVOUS));
2007	}
2008
2009	/*
2010	* Normal priority then. (per-VCPU)
2011	* (Executed in no particular order.)
2012	*/
2013	if ( !VM_FF_IS_PENDING(pVM, VM_FF_PGM_NO_MEMORY)
2014	&& VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_NORMAL_PRIORITY_MASK))
2015	{
2016	/*
2017	* Requests from other threads.
2018	*/
2019	if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_REQUEST))
2020	{
2021	rc2 = VMR3ReqProcessU(pVM->pUVM, pVCpu->idCpu, false /fPriorityOnly/);
2022	if (rc2 == VINF_EM_OFF \|\| rc2 == VINF_EM_TERMINATE \|\| rc2 == VINF_EM_RESET)
2023	{
2024	Log2(("emR3ForcedActions: returns %Rrc\n", rc2));
2025	STAM_REL_PROFILE_STOP(&pVCpu->em.s.StatForcedActions, a);
2026	return rc2;
2027	}
2028	UPDATE_RC();
2029	/** @todo HACK ALERT! The following test is to make sure EM+TM
2030	* thinks the VM is stopped/reset before the next VM state change
2031	* is made. We need a better solution for this, or at least make it
2032	* possible to do: (rc >= VINF_EM_FIRST && rc <=
2033	* VINF_EM_SUSPEND). */
2034	if (RT_UNLIKELY(rc == VINF_EM_SUSPEND \|\| rc == VINF_EM_RESET \|\| rc == VINF_EM_OFF))
2035	{
2036	Log2(("emR3ForcedActions: returns %Rrc\n", rc));
2037	STAM_REL_PROFILE_STOP(&pVCpu->em.s.StatForcedActions, a);
2038	return rc;
2039	}
2040	}
2041
2042	/* check that we got them all */
2043	Assert(!(VMCPU_FF_NORMAL_PRIORITY_MASK & ~VMCPU_FF_REQUEST));
2044	}
2045
2046	/*
2047	* High priority pre execution chunk last.
2048	* (Executed in ascending priority order.)
2049	*/
2050	if ( VM_FF_IS_PENDING(pVM, VM_FF_HIGH_PRIORITY_PRE_MASK)
2051	\|\| VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HIGH_PRIORITY_PRE_MASK))
2052	{
2053	/*
2054	* Timers before interrupts.
2055	*/
2056	if ( VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_TIMER)
2057	&& !VM_FF_IS_PENDING(pVM, VM_FF_PGM_NO_MEMORY))
2058	TMR3TimerQueuesDo(pVM);
2059
2060	/*
2061	* Pick up asynchronously posted interrupts into the APIC.
2062	*/
2063	if (VMCPU_FF_TEST_AND_CLEAR(pVCpu, VMCPU_FF_UPDATE_APIC))
2064	APICUpdatePendingInterrupts(pVCpu);
2065
2066	/*
2067	* The instruction following an emulated STI should always be executed!
2068	*
2069	* Note! We intentionally don't clear VM_FF_INHIBIT_INTERRUPTS here if
2070	* the eip is the same as the inhibited instr address. Before we
2071	* are able to execute this instruction in raw mode (iret to
2072	* guest code) an external interrupt might force a world switch
2073	* again. Possibly allowing a guest interrupt to be dispatched
2074	* in the process. This could break the guest. Sounds very
2075	* unlikely, but such timing sensitive problem are not as rare as
2076	* you might think.
2077	*/
2078	if ( VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
2079	&& !VM_FF_IS_PENDING(pVM, VM_FF_PGM_NO_MEMORY))
2080	{
2081	if (CPUMGetGuestRIP(pVCpu) != EMGetInhibitInterruptsPC(pVCpu))
2082	{
2083	Log(("Clearing VMCPU_FF_INHIBIT_INTERRUPTS at %RGv - successor %RGv\n", (RTGCPTR)CPUMGetGuestRIP(pVCpu), EMGetInhibitInterruptsPC(pVCpu)));
2084	VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS);
2085	}
2086	else
2087	Log(("Leaving VMCPU_FF_INHIBIT_INTERRUPTS set at %RGv\n", (RTGCPTR)CPUMGetGuestRIP(pVCpu)));
2088	}
2089
2090	/*
2091	* Interrupts.
2092	*/
2093	bool fWakeupPending = false;
2094	if ( !VM_FF_IS_PENDING(pVM, VM_FF_PGM_NO_MEMORY)
2095	&& (!rc \|\| rc >= VINF_EM_RESCHEDULE_HM))
2096	{
2097	if ( !VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
2098	&& !TRPMHasTrap(pVCpu)) /* an interrupt could already be scheduled for dispatching in the recompiler. */
2099	{
2100	Assert(!HMR3IsEventPending(pVCpu));
2101	PCPUMCTX pCtx = pVCpu->em.s.pCtx;
2102	#ifdef VBOX_WITH_NESTED_HWVIRT_SVM
2103	if (CPUMIsGuestInNestedHwVirtMode(pCtx))
2104	{
2105	bool fResched, fInject;
2106	rc2 = emR3NstGstInjectIntr(pVCpu, pCtx, &fResched, &fInject);
2107	if (fInject)
2108	{
2109	fWakeupPending = true;
2110	#ifdef VBOX_STRICT
2111	rcIrq = rc2;
2112	#endif
2113	}
2114	if (fResched)
2115	UPDATE_RC();
2116	}
2117	else
2118	#endif
2119	{
2120	if ( VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_APIC \| VMCPU_FF_INTERRUPT_PIC)
2121	#ifdef VBOX_WITH_NESTED_HWVIRT_SVM
2122	&& pCtx->hwvirt.fGif
2123	#endif
2124	#ifdef VBOX_WITH_RAW_MODE
2125	&& !PATMIsPatchGCAddr(pVM, pCtx->eip)
2126	#endif
2127	&& pCtx->eflags.Bits.u1IF)
2128	{
2129	Assert(pVCpu->em.s.enmState != EMSTATE_WAIT_SIPI);
2130	/* Note: it's important to make sure the return code from TRPMR3InjectEvent isn't ignored! */
2131	/** @todo this really isn't nice, should properly handle this */
2132	rc2 = TRPMR3InjectEvent(pVM, pVCpu, TRPM_HARDWARE_INT);
2133	Log(("EM: TRPMR3InjectEvent -> %d\n", rc2));
2134	if (pVM->em.s.fIemExecutesAll && ( rc2 == VINF_EM_RESCHEDULE_REM
2135	\|\| rc2 == VINF_EM_RESCHEDULE_HM
2136	\|\| rc2 == VINF_EM_RESCHEDULE_RAW))
2137	{
2138	rc2 = VINF_EM_RESCHEDULE;
2139	}
2140	#ifdef VBOX_STRICT
2141	rcIrq = rc2;
2142	#endif
2143	UPDATE_RC();
2144	/* Reschedule required: We must not miss the wakeup below! */
2145	fWakeupPending = true;
2146	}
2147	}
2148	}
2149	}
2150
2151	/*
2152	* Allocate handy pages.
2153	*/
2154	if (VM_FF_IS_PENDING_EXCEPT(pVM, VM_FF_PGM_NEED_HANDY_PAGES, VM_FF_PGM_NO_MEMORY))
2155	{
2156	rc2 = PGMR3PhysAllocateHandyPages(pVM);
2157	UPDATE_RC();
2158	}
2159
2160	/*
2161	* Debugger Facility request.
2162	*/
2163	if ( ( VM_FF_IS_PENDING(pVM, VM_FF_DBGF)
2164	\|\| VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_DBGF) )
2165	&& !VM_FF_IS_PENDING(pVM, VM_FF_PGM_NO_MEMORY) )
2166	{
2167	rc2 = DBGFR3VMMForcedAction(pVM, pVCpu);
2168	UPDATE_RC();
2169	}
2170
2171	/*
2172	* EMT Rendezvous (must be serviced before termination).
2173	*/
2174	if ( !fWakeupPending /* don't miss the wakeup from EMSTATE_HALTED! */
2175	&& VM_FF_IS_PENDING(pVM, VM_FF_EMT_RENDEZVOUS))
2176	{
2177	rc2 = VMMR3EmtRendezvousFF(pVM, pVCpu);
2178	UPDATE_RC();
2179	/** @todo HACK ALERT! The following test is to make sure EM+TM thinks the VM is
2180	* stopped/reset before the next VM state change is made. We need a better
2181	* solution for this, or at least make it possible to do: (rc >= VINF_EM_FIRST
2182	* && rc >= VINF_EM_SUSPEND). */
2183	if (RT_UNLIKELY(rc == VINF_EM_SUSPEND \|\| rc == VINF_EM_RESET \|\| rc == VINF_EM_OFF))
2184	{
2185	Log2(("emR3ForcedActions: returns %Rrc\n", rc));
2186	STAM_REL_PROFILE_STOP(&pVCpu->em.s.StatForcedActions, a);
2187	return rc;
2188	}
2189	}
2190
2191	/*
2192	* State change request (cleared by vmR3SetStateLocked).
2193	*/
2194	if ( !fWakeupPending /* don't miss the wakeup from EMSTATE_HALTED! */
2195	&& VM_FF_IS_PENDING(pVM, VM_FF_CHECK_VM_STATE))
2196	{
2197	VMSTATE enmState = VMR3GetState(pVM);
2198	switch (enmState)
2199	{
2200	case VMSTATE_FATAL_ERROR:
2201	case VMSTATE_FATAL_ERROR_LS:
2202	case VMSTATE_GURU_MEDITATION:
2203	case VMSTATE_GURU_MEDITATION_LS:
2204	Log2(("emR3ForcedActions: %s -> VINF_EM_SUSPEND\n", VMGetStateName(enmState) ));
2205	STAM_REL_PROFILE_STOP(&pVCpu->em.s.StatForcedActions, a);
2206	return VINF_EM_SUSPEND;
2207
2208	case VMSTATE_DESTROYING:
2209	Log2(("emR3ForcedActions: %s -> VINF_EM_TERMINATE\n", VMGetStateName(enmState) ));
2210	STAM_REL_PROFILE_STOP(&pVCpu->em.s.StatForcedActions, a);
2211	return VINF_EM_TERMINATE;
2212
2213	default:
2214	AssertMsgFailed(("%s\n", VMGetStateName(enmState)));
2215	}
2216	}
2217
2218	/*
2219	* Out of memory? Since most of our fellow high priority actions may cause us
2220	* to run out of memory, we're employing VM_FF_IS_PENDING_EXCEPT and putting this
2221	* at the end rather than the start. Also, VM_FF_TERMINATE has higher priority
2222	* than us since we can terminate without allocating more memory.
2223	*/
2224	if (VM_FF_IS_PENDING(pVM, VM_FF_PGM_NO_MEMORY))
2225	{
2226	rc2 = PGMR3PhysAllocateHandyPages(pVM);
2227	UPDATE_RC();
2228	if (rc == VINF_EM_NO_MEMORY)
2229	return rc;
2230	}
2231
2232	/*
2233	* If the virtual sync clock is still stopped, make TM restart it.
2234	*/
2235	if (VM_FF_IS_PENDING(pVM, VM_FF_TM_VIRTUAL_SYNC))
2236	TMR3VirtualSyncFF(pVM, pVCpu);
2237
2238	#ifdef DEBUG
2239	/*
2240	* Debug, pause the VM.
2241	*/
2242	if (VM_FF_IS_PENDING(pVM, VM_FF_DEBUG_SUSPEND))
2243	{
2244	VM_FF_CLEAR(pVM, VM_FF_DEBUG_SUSPEND);
2245	Log(("emR3ForcedActions: returns VINF_EM_SUSPEND\n"));
2246	return VINF_EM_SUSPEND;
2247	}
2248	#endif
2249
2250	/* check that we got them all */
2251	AssertCompile(VM_FF_HIGH_PRIORITY_PRE_MASK == (VM_FF_TM_VIRTUAL_SYNC \| VM_FF_DBGF \| VM_FF_CHECK_VM_STATE \| VM_FF_DEBUG_SUSPEND \| VM_FF_PGM_NEED_HANDY_PAGES \| VM_FF_PGM_NO_MEMORY \| VM_FF_EMT_RENDEZVOUS));
2252	AssertCompile(VMCPU_FF_HIGH_PRIORITY_PRE_MASK == (VMCPU_FF_TIMER \| VMCPU_FF_INTERRUPT_APIC \| VMCPU_FF_UPDATE_APIC \| VMCPU_FF_INTERRUPT_PIC \| VMCPU_FF_PGM_SYNC_CR3 \| VMCPU_FF_PGM_SYNC_CR3_NON_GLOBAL \| VMCPU_FF_INHIBIT_INTERRUPTS \| VMCPU_FF_DBGF \| VM_WHEN_RAW_MODE(VMCPU_FF_SELM_SYNC_TSS \| VMCPU_FF_TRPM_SYNC_IDT \| VMCPU_FF_SELM_SYNC_GDT \| VMCPU_FF_SELM_SYNC_LDT, 0)));
2253	}
2254
2255	#undef UPDATE_RC
2256	Log2(("emR3ForcedActions: returns %Rrc\n", rc));
2257	STAM_REL_PROFILE_STOP(&pVCpu->em.s.StatForcedActions, a);
2258	Assert(rcIrq == VINF_SUCCESS \|\| rcIrq == rc);
2259	return rc;
2260	}
2261
2262
2263	/**
2264	* Check if the preset execution time cap restricts guest execution scheduling.
2265	*
2266	* @returns true if allowed, false otherwise
2267	* @param pVM The cross context VM structure.
2268	* @param pVCpu The cross context virtual CPU structure.
2269	*/
2270	bool emR3IsExecutionAllowed(PVM pVM, PVMCPU pVCpu)
2271	{
2272	uint64_t u64UserTime, u64KernelTime;
2273
2274	if ( pVM->uCpuExecutionCap != 100
2275	&& RT_SUCCESS(RTThreadGetExecutionTimeMilli(&u64KernelTime, &u64UserTime)))
2276	{
2277	uint64_t u64TimeNow = RTTimeMilliTS();
2278	if (pVCpu->em.s.u64TimeSliceStart + EM_TIME_SLICE < u64TimeNow)
2279	{
2280	/* New time slice. */
2281	pVCpu->em.s.u64TimeSliceStart = u64TimeNow;
2282	pVCpu->em.s.u64TimeSliceStartExec = u64KernelTime + u64UserTime;
2283	pVCpu->em.s.u64TimeSliceExec = 0;
2284	}
2285	pVCpu->em.s.u64TimeSliceExec = u64KernelTime + u64UserTime - pVCpu->em.s.u64TimeSliceStartExec;
2286
2287	Log2(("emR3IsExecutionAllowed: start=%RX64 startexec=%RX64 exec=%RX64 (cap=%x)\n", pVCpu->em.s.u64TimeSliceStart, pVCpu->em.s.u64TimeSliceStartExec, pVCpu->em.s.u64TimeSliceExec, (EM_TIME_SLICE * pVM->uCpuExecutionCap) / 100));
2288	if (pVCpu->em.s.u64TimeSliceExec >= (EM_TIME_SLICE * pVM->uCpuExecutionCap) / 100)
2289	return false;
2290	}
2291	return true;
2292	}
2293
2294
2295	/**
2296	* Execute VM.
2297	*
2298	* This function is the main loop of the VM. The emulation thread
2299	* calls this function when the VM has been successfully constructed
2300	* and we're ready for executing the VM.
2301	*
2302	* Returning from this function means that the VM is turned off or
2303	* suspended (state already saved) and deconstruction is next in line.
2304	*
2305	* All interaction from other thread are done using forced actions
2306	* and signaling of the wait object.
2307	*
2308	* @returns VBox status code, informational status codes may indicate failure.
2309	* @param pVM The cross context VM structure.
2310	* @param pVCpu The cross context virtual CPU structure.
2311	*/
2312	VMMR3_INT_DECL(int) EMR3ExecuteVM(PVM pVM, PVMCPU pVCpu)
2313	{
2314	Log(("EMR3ExecuteVM: pVM=%p enmVMState=%d (%s) enmState=%d (%s) enmPrevState=%d (%s) fForceRAW=%RTbool\n",
2315	pVM,
2316	pVM->enmVMState, VMR3GetStateName(pVM->enmVMState),
2317	pVCpu->em.s.enmState, emR3GetStateName(pVCpu->em.s.enmState),
2318	pVCpu->em.s.enmPrevState, emR3GetStateName(pVCpu->em.s.enmPrevState),
2319	pVCpu->em.s.fForceRAW));
2320	VM_ASSERT_EMT(pVM);
2321	AssertMsg( pVCpu->em.s.enmState == EMSTATE_NONE
2322	\|\| pVCpu->em.s.enmState == EMSTATE_WAIT_SIPI
2323	\|\| pVCpu->em.s.enmState == EMSTATE_SUSPENDED,
2324	("%s\n", emR3GetStateName(pVCpu->em.s.enmState)));
2325
2326	int rc = setjmp(pVCpu->em.s.u.FatalLongJump);
2327	if (rc == 0)
2328	{
2329	/*
2330	* Start the virtual time.
2331	*/
2332	TMR3NotifyResume(pVM, pVCpu);
2333
2334	/*
2335	* The Outer Main Loop.
2336	*/
2337	bool fFFDone = false;
2338
2339	/* Reschedule right away to start in the right state. */
2340	rc = VINF_SUCCESS;
2341
2342	/* If resuming after a pause or a state load, restore the previous
2343	state or else we'll start executing code. Else, just reschedule. */
2344	if ( pVCpu->em.s.enmState == EMSTATE_SUSPENDED
2345	&& ( pVCpu->em.s.enmPrevState == EMSTATE_WAIT_SIPI
2346	\|\| pVCpu->em.s.enmPrevState == EMSTATE_HALTED))
2347	pVCpu->em.s.enmState = pVCpu->em.s.enmPrevState;
2348	else
2349	pVCpu->em.s.enmState = emR3Reschedule(pVM, pVCpu, pVCpu->em.s.pCtx);
2350	pVCpu->em.s.cIemThenRemInstructions = 0;
2351	Log(("EMR3ExecuteVM: enmState=%s\n", emR3GetStateName(pVCpu->em.s.enmState)));
2352
2353	STAM_REL_PROFILE_ADV_START(&pVCpu->em.s.StatTotal, x);
2354	for (;;)
2355	{
2356	/*
2357	* Before we can schedule anything (we're here because
2358	* scheduling is required) we must service any pending
2359	* forced actions to avoid any pending action causing
2360	* immediate rescheduling upon entering an inner loop
2361	*
2362	* Do forced actions.
2363	*/
2364	if ( !fFFDone
2365	&& RT_SUCCESS(rc)
2366	&& rc != VINF_EM_TERMINATE
2367	&& rc != VINF_EM_OFF
2368	&& ( VM_FF_IS_PENDING(pVM, VM_FF_ALL_REM_MASK)
2369	\|\| VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_ALL_REM_MASK & ~VMCPU_FF_UNHALT)))
2370	{
2371	rc = emR3ForcedActions(pVM, pVCpu, rc);
2372	VBOXVMM_EM_FF_ALL_RET(pVCpu, rc);
2373	if ( ( rc == VINF_EM_RESCHEDULE_REM
2374	\|\| rc == VINF_EM_RESCHEDULE_HM)
2375	&& pVCpu->em.s.fForceRAW)
2376	rc = VINF_EM_RESCHEDULE_RAW;
2377	}
2378	else if (fFFDone)
2379	fFFDone = false;
2380
2381	/*
2382	* Now what to do?
2383	*/
2384	Log2(("EMR3ExecuteVM: rc=%Rrc\n", rc));
2385	EMSTATE const enmOldState = pVCpu->em.s.enmState;
2386	switch (rc)
2387	{
2388	/*
2389	* Keep doing what we're currently doing.
2390	*/
2391	case VINF_SUCCESS:
2392	break;
2393
2394	/*
2395	* Reschedule - to raw-mode execution.
2396	*/
2397	/** @todo r=bird: consider merging VINF_EM_RESCHEDULE_RAW with VINF_EM_RESCHEDULE_HM, they serve the same purpose here at least. */
2398	case VINF_EM_RESCHEDULE_RAW:
2399	Assert(!pVM->em.s.fIemExecutesAll \|\| pVCpu->em.s.enmState != EMSTATE_IEM);
2400	if (VM_IS_RAW_MODE_ENABLED(pVM))
2401	{
2402	Log2(("EMR3ExecuteVM: VINF_EM_RESCHEDULE_RAW: %d -> %d (EMSTATE_RAW)\n", enmOldState, EMSTATE_RAW));
2403	pVCpu->em.s.enmState = EMSTATE_RAW;
2404	}
2405	else
2406	{
2407	AssertLogRelFailed();
2408	pVCpu->em.s.enmState = EMSTATE_NONE;
2409	}
2410	break;
2411
2412	/*
2413	* Reschedule - to HM or NEM.
2414	*/
2415	case VINF_EM_RESCHEDULE_HM:
2416	Assert(!pVM->em.s.fIemExecutesAll \|\| pVCpu->em.s.enmState != EMSTATE_IEM);
2417	Assert(!pVCpu->em.s.fForceRAW);
2418	if (VM_IS_HM_ENABLED(pVM))
2419	{
2420	Log2(("EMR3ExecuteVM: VINF_EM_RESCHEDULE_HM: %d -> %d (EMSTATE_HM)\n", enmOldState, EMSTATE_HM));
2421	pVCpu->em.s.enmState = EMSTATE_HM;
2422	}
2423	else if (VM_IS_NEM_ENABLED(pVM))
2424	{
2425	Log2(("EMR3ExecuteVM: VINF_EM_RESCHEDULE_HM: %d -> %d (EMSTATE_NEM)\n", enmOldState, EMSTATE_NEM));
2426	pVCpu->em.s.enmState = EMSTATE_NEM;
2427	}
2428	else
2429	{
2430	AssertLogRelFailed();
2431	pVCpu->em.s.enmState = EMSTATE_NONE;
2432	}
2433	break;
2434
2435	/*
2436	* Reschedule - to recompiled execution.
2437	*/
2438	case VINF_EM_RESCHEDULE_REM:
2439	Assert(!pVM->em.s.fIemExecutesAll \|\| pVCpu->em.s.enmState != EMSTATE_IEM);
2440	if (!VM_IS_RAW_MODE_ENABLED(pVM))
2441	{
2442	Log2(("EMR3ExecuteVM: VINF_EM_RESCHEDULE_REM: %d -> %d (EMSTATE_IEM_THEN_REM)\n",
2443	enmOldState, EMSTATE_IEM_THEN_REM));
2444	if (pVCpu->em.s.enmState != EMSTATE_IEM_THEN_REM)
2445	{
2446	pVCpu->em.s.enmState = EMSTATE_IEM_THEN_REM;
2447	pVCpu->em.s.cIemThenRemInstructions = 0;
2448	}
2449	}
2450	else
2451	{
2452	Log2(("EMR3ExecuteVM: VINF_EM_RESCHEDULE_REM: %d -> %d (EMSTATE_REM)\n", enmOldState, EMSTATE_REM));
2453	pVCpu->em.s.enmState = EMSTATE_REM;
2454	}
2455	break;
2456
2457	/*
2458	* Resume.
2459	*/
2460	case VINF_EM_RESUME:
2461	Log2(("EMR3ExecuteVM: VINF_EM_RESUME: %d -> VINF_EM_RESCHEDULE\n", enmOldState));
2462	/* Don't reschedule in the halted or wait for SIPI case. */
2463	if ( pVCpu->em.s.enmPrevState == EMSTATE_WAIT_SIPI
2464	\|\| pVCpu->em.s.enmPrevState == EMSTATE_HALTED)
2465	{
2466	pVCpu->em.s.enmState = pVCpu->em.s.enmPrevState;
2467	break;
2468	}
2469	/* fall through and get scheduled. */
2470	RT_FALL_THRU();
2471
2472	/*
2473	* Reschedule.
2474	*/
2475	case VINF_EM_RESCHEDULE:
2476	{
2477	EMSTATE enmState = emR3Reschedule(pVM, pVCpu, pVCpu->em.s.pCtx);
2478	Log2(("EMR3ExecuteVM: VINF_EM_RESCHEDULE: %d -> %d (%s)\n", enmOldState, enmState, emR3GetStateName(enmState)));
2479	if (pVCpu->em.s.enmState != enmState && enmState == EMSTATE_IEM_THEN_REM)
2480	pVCpu->em.s.cIemThenRemInstructions = 0;
2481	pVCpu->em.s.enmState = enmState;
2482	break;
2483	}
2484
2485	/*
2486	* Halted.
2487	*/
2488	case VINF_EM_HALT:
2489	Log2(("EMR3ExecuteVM: VINF_EM_HALT: %d -> %d\n", enmOldState, EMSTATE_HALTED));
2490	pVCpu->em.s.enmState = EMSTATE_HALTED;
2491	break;
2492
2493	/*
2494	* Switch to the wait for SIPI state (application processor only)
2495	*/
2496	case VINF_EM_WAIT_SIPI:
2497	Assert(pVCpu->idCpu != 0);
2498	Log2(("EMR3ExecuteVM: VINF_EM_WAIT_SIPI: %d -> %d\n", enmOldState, EMSTATE_WAIT_SIPI));
2499	pVCpu->em.s.enmState = EMSTATE_WAIT_SIPI;
2500	break;
2501
2502
2503	/*
2504	* Suspend.
2505	*/
2506	case VINF_EM_SUSPEND:
2507	Log2(("EMR3ExecuteVM: VINF_EM_SUSPEND: %d -> %d\n", enmOldState, EMSTATE_SUSPENDED));
2508	Assert(enmOldState != EMSTATE_SUSPENDED);
2509	pVCpu->em.s.enmPrevState = enmOldState;
2510	pVCpu->em.s.enmState = EMSTATE_SUSPENDED;
2511	break;
2512
2513	/*
2514	* Reset.
2515	* We might end up doing a double reset for now, we'll have to clean up the mess later.
2516	*/
2517	case VINF_EM_RESET:
2518	{
2519	if (pVCpu->idCpu == 0)
2520	{
2521	EMSTATE enmState = emR3Reschedule(pVM, pVCpu, pVCpu->em.s.pCtx);
2522	Log2(("EMR3ExecuteVM: VINF_EM_RESET: %d -> %d (%s)\n", enmOldState, enmState, emR3GetStateName(enmState)));
2523	if (pVCpu->em.s.enmState != enmState && enmState == EMSTATE_IEM_THEN_REM)
2524	pVCpu->em.s.cIemThenRemInstructions = 0;
2525	pVCpu->em.s.enmState = enmState;
2526	}
2527	else
2528	{
2529	/* All other VCPUs go into the wait for SIPI state. */
2530	pVCpu->em.s.enmState = EMSTATE_WAIT_SIPI;
2531	}
2532	break;
2533	}
2534
2535	/*
2536	* Power Off.
2537	*/
2538	case VINF_EM_OFF:
2539	pVCpu->em.s.enmState = EMSTATE_TERMINATING;
2540	Log2(("EMR3ExecuteVM: returns VINF_EM_OFF (%d -> %d)\n", enmOldState, EMSTATE_TERMINATING));
2541	TMR3NotifySuspend(pVM, pVCpu);
2542	STAM_REL_PROFILE_ADV_STOP(&pVCpu->em.s.StatTotal, x);
2543	return rc;
2544
2545	/*
2546	* Terminate the VM.
2547	*/
2548	case VINF_EM_TERMINATE:
2549	pVCpu->em.s.enmState = EMSTATE_TERMINATING;
2550	Log(("EMR3ExecuteVM returns VINF_EM_TERMINATE (%d -> %d)\n", enmOldState, EMSTATE_TERMINATING));
2551	if (pVM->enmVMState < VMSTATE_DESTROYING) /* ugly */
2552	TMR3NotifySuspend(pVM, pVCpu);
2553	STAM_REL_PROFILE_ADV_STOP(&pVCpu->em.s.StatTotal, x);
2554	return rc;
2555
2556
2557	/*
2558	* Out of memory, suspend the VM and stuff.
2559	*/
2560	case VINF_EM_NO_MEMORY:
2561	Log2(("EMR3ExecuteVM: VINF_EM_NO_MEMORY: %d -> %d\n", enmOldState, EMSTATE_SUSPENDED));
2562	Assert(enmOldState != EMSTATE_SUSPENDED);
2563	pVCpu->em.s.enmPrevState = enmOldState;
2564	pVCpu->em.s.enmState = EMSTATE_SUSPENDED;
2565	TMR3NotifySuspend(pVM, pVCpu);
2566	STAM_REL_PROFILE_ADV_STOP(&pVCpu->em.s.StatTotal, x);
2567
2568	rc = VMSetRuntimeError(pVM, VMSETRTERR_FLAGS_SUSPEND, "HostMemoryLow",
2569	N_("Unable to allocate and lock memory. The virtual machine will be paused. Please close applications to free up memory or close the VM"));
2570	if (rc != VINF_EM_SUSPEND)
2571	{
2572	if (RT_SUCCESS_NP(rc))
2573	{
2574	AssertLogRelMsgFailed(("%Rrc\n", rc));
2575	rc = VERR_EM_INTERNAL_ERROR;
2576	}
2577	pVCpu->em.s.enmState = EMSTATE_GURU_MEDITATION;
2578	}
2579	return rc;
2580
2581	/*
2582	* Guest debug events.
2583	*/
2584	case VINF_EM_DBG_STEPPED:
2585	case VINF_EM_DBG_STOP:
2586	case VINF_EM_DBG_EVENT:
2587	case VINF_EM_DBG_BREAKPOINT:
2588	case VINF_EM_DBG_STEP:
2589	if (enmOldState == EMSTATE_RAW)
2590	{
2591	Log2(("EMR3ExecuteVM: %Rrc: %d -> %d\n", rc, enmOldState, EMSTATE_DEBUG_GUEST_RAW));
2592	pVCpu->em.s.enmState = EMSTATE_DEBUG_GUEST_RAW;
2593	}
2594	else if (enmOldState == EMSTATE_HM)
2595	{
2596	Log2(("EMR3ExecuteVM: %Rrc: %d -> %d\n", rc, enmOldState, EMSTATE_DEBUG_GUEST_HM));
2597	pVCpu->em.s.enmState = EMSTATE_DEBUG_GUEST_HM;
2598	}
2599	else if (enmOldState == EMSTATE_NEM)
2600	{
2601	Log2(("EMR3ExecuteVM: %Rrc: %d -> %d\n", rc, enmOldState, EMSTATE_DEBUG_GUEST_NEM));
2602	pVCpu->em.s.enmState = EMSTATE_DEBUG_GUEST_NEM;
2603	}
2604	else if (enmOldState == EMSTATE_REM)
2605	{
2606	Log2(("EMR3ExecuteVM: %Rrc: %d -> %d\n", rc, enmOldState, EMSTATE_DEBUG_GUEST_REM));
2607	pVCpu->em.s.enmState = EMSTATE_DEBUG_GUEST_REM;
2608	}
2609	else
2610	{
2611	Log2(("EMR3ExecuteVM: %Rrc: %d -> %d\n", rc, enmOldState, EMSTATE_DEBUG_GUEST_IEM));
2612	pVCpu->em.s.enmState = EMSTATE_DEBUG_GUEST_IEM;
2613	}
2614	break;
2615
2616	/*
2617	* Hypervisor debug events.
2618	*/
2619	case VINF_EM_DBG_HYPER_STEPPED:
2620	case VINF_EM_DBG_HYPER_BREAKPOINT:
2621	case VINF_EM_DBG_HYPER_ASSERTION:
2622	Log2(("EMR3ExecuteVM: %Rrc: %d -> %d\n", rc, enmOldState, EMSTATE_DEBUG_HYPER));
2623	pVCpu->em.s.enmState = EMSTATE_DEBUG_HYPER;
2624	break;
2625
2626	/*
2627	* Triple fault.
2628	*/
2629	case VINF_EM_TRIPLE_FAULT:
2630	if (!pVM->em.s.fGuruOnTripleFault)
2631	{
2632	Log(("EMR3ExecuteVM: VINF_EM_TRIPLE_FAULT: CPU reset...\n"));
2633	rc = VBOXSTRICTRC_TODO(VMR3ResetTripleFault(pVM));
2634	Log2(("EMR3ExecuteVM: VINF_EM_TRIPLE_FAULT: %d -> %d (rc=%Rrc)\n", enmOldState, pVCpu->em.s.enmState, rc));
2635	continue;
2636	}
2637	/* Else fall through and trigger a guru. */
2638	RT_FALL_THRU();
2639
2640	case VERR_VMM_RING0_ASSERTION:
2641	Log(("EMR3ExecuteVM: %Rrc: %d -> %d (EMSTATE_GURU_MEDITATION)\n", rc, enmOldState, EMSTATE_GURU_MEDITATION));
2642	pVCpu->em.s.enmState = EMSTATE_GURU_MEDITATION;
2643	break;
2644
2645	/*
2646	* Any error code showing up here other than the ones we
2647	* know and process above are considered to be FATAL.
2648	*
2649	* Unknown warnings and informational status codes are also
2650	* included in this.
2651	*/
2652	default:
2653	if (RT_SUCCESS_NP(rc))
2654	{
2655	AssertMsgFailed(("Unexpected warning or informational status code %Rra!\n", rc));
2656	rc = VERR_EM_INTERNAL_ERROR;
2657	}
2658	Log(("EMR3ExecuteVM: %Rrc: %d -> %d (EMSTATE_GURU_MEDITATION)\n", rc, enmOldState, EMSTATE_GURU_MEDITATION));
2659	pVCpu->em.s.enmState = EMSTATE_GURU_MEDITATION;
2660	break;
2661	}
2662
2663	/*
2664	* Act on state transition.
2665	*/
2666	EMSTATE const enmNewState = pVCpu->em.s.enmState;
2667	if (enmOldState != enmNewState)
2668	{
2669	VBOXVMM_EM_STATE_CHANGED(pVCpu, enmOldState, enmNewState, rc);
2670
2671	/* Clear MWait flags and the unhalt FF. */
2672	if ( enmOldState == EMSTATE_HALTED
2673	&& ( (pVCpu->em.s.MWait.fWait & EMMWAIT_FLAG_ACTIVE)
2674	\|\| VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_UNHALT))
2675	&& ( enmNewState == EMSTATE_RAW
2676	\|\| enmNewState == EMSTATE_HM
2677	\|\| enmNewState == EMSTATE_NEM
2678	\|\| enmNewState == EMSTATE_REM
2679	\|\| enmNewState == EMSTATE_IEM_THEN_REM
2680	\|\| enmNewState == EMSTATE_DEBUG_GUEST_RAW
2681	\|\| enmNewState == EMSTATE_DEBUG_GUEST_HM
2682	\|\| enmNewState == EMSTATE_DEBUG_GUEST_NEM
2683	\|\| enmNewState == EMSTATE_DEBUG_GUEST_IEM
2684	\|\| enmNewState == EMSTATE_DEBUG_GUEST_REM) )
2685	{
2686	if (pVCpu->em.s.MWait.fWait & EMMWAIT_FLAG_ACTIVE)
2687	{
2688	LogFlow(("EMR3ExecuteVM: Clearing MWAIT\n"));
2689	pVCpu->em.s.MWait.fWait &= ~(EMMWAIT_FLAG_ACTIVE \| EMMWAIT_FLAG_BREAKIRQIF0);
2690	}
2691	if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_UNHALT))
2692	{
2693	LogFlow(("EMR3ExecuteVM: Clearing UNHALT\n"));
2694	VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_UNHALT);
2695	}
2696	}
2697	}
2698	else
2699	VBOXVMM_EM_STATE_UNCHANGED(pVCpu, enmNewState, rc);
2700
2701	STAM_PROFILE_ADV_STOP(&pVCpu->em.s.StatTotal, x); /* (skip this in release) */
2702	STAM_PROFILE_ADV_START(&pVCpu->em.s.StatTotal, x);
2703
2704	/*
2705	* Act on the new state.
2706	*/
2707	switch (enmNewState)
2708	{
2709	/*
2710	* Execute raw.
2711	*/
2712	case EMSTATE_RAW:
2713	#ifdef VBOX_WITH_RAW_MODE
2714	rc = emR3RawExecute(pVM, pVCpu, &fFFDone);
2715	#else
2716	AssertLogRelMsgFailed(("%Rrc\n", rc));
2717	rc = VERR_EM_INTERNAL_ERROR;
2718	#endif
2719	break;
2720
2721	/*
2722	* Execute hardware accelerated raw.
2723	*/
2724	case EMSTATE_HM:
2725	rc = emR3HmExecute(pVM, pVCpu, &fFFDone);
2726	break;
2727
2728	/*
2729	* Execute hardware accelerated raw.
2730	*/
2731	case EMSTATE_NEM:
2732	rc = VBOXSTRICTRC_TODO(emR3NemExecute(pVM, pVCpu, &fFFDone));
2733	break;
2734
2735	/*
2736	* Execute recompiled.
2737	*/
2738	case EMSTATE_REM:
2739	rc = emR3RemExecute(pVM, pVCpu, &fFFDone);
2740	Log2(("EMR3ExecuteVM: emR3RemExecute -> %Rrc\n", rc));
2741	break;
2742
2743	/*
2744	* Execute in the interpreter.
2745	*/
2746	case EMSTATE_IEM:
2747	{
2748	#if 0 /* For testing purposes. */
2749	STAM_PROFILE_START(&pVCpu->em.s.StatHmExec, x1);
2750	rc = VBOXSTRICTRC_TODO(EMR3HmSingleInstruction(pVM, pVCpu, EM_ONE_INS_FLAGS_RIP_CHANGE));
2751	STAM_PROFILE_STOP(&pVCpu->em.s.StatHmExec, x1);
2752	if (rc == VINF_EM_DBG_STEPPED \|\| rc == VINF_EM_RESCHEDULE_HM \|\| rc == VINF_EM_RESCHEDULE_REM \|\| rc == VINF_EM_RESCHEDULE_RAW)
2753	rc = VINF_SUCCESS;
2754	else if (rc == VERR_EM_CANNOT_EXEC_GUEST)
2755	#endif
2756	rc = VBOXSTRICTRC_TODO(IEMExecLots(pVCpu, NULL /pcInstructions/));
2757	if (pVM->em.s.fIemExecutesAll)
2758	{
2759	Assert(rc != VINF_EM_RESCHEDULE_REM);
2760	Assert(rc != VINF_EM_RESCHEDULE_RAW);
2761	Assert(rc != VINF_EM_RESCHEDULE_HM);
2762	}
2763	fFFDone = false;
2764	break;
2765	}
2766
2767	/*
2768	* Execute in IEM, hoping we can quickly switch aback to HM
2769	* or RAW execution. If our hopes fail, we go to REM.
2770	*/
2771	case EMSTATE_IEM_THEN_REM:
2772	{
2773	STAM_PROFILE_START(&pVCpu->em.s.StatIEMThenREM, pIemThenRem);
2774	rc = VBOXSTRICTRC_TODO(emR3ExecuteIemThenRem(pVM, pVCpu, &fFFDone));
2775	STAM_PROFILE_STOP(&pVCpu->em.s.StatIEMThenREM, pIemThenRem);
2776	break;
2777	}
2778
2779	/*
2780	* Application processor execution halted until SIPI.
2781	*/
2782	case EMSTATE_WAIT_SIPI:
2783	/* no break */
2784	/*
2785	* hlt - execution halted until interrupt.
2786	*/
2787	case EMSTATE_HALTED:
2788	{
2789	STAM_REL_PROFILE_START(&pVCpu->em.s.StatHalted, y);
2790	/* If HM (or someone else) store a pending interrupt in
2791	TRPM, it must be dispatched ASAP without any halting.
2792	Anything pending in TRPM has been accepted and the CPU
2793	should already be the right state to receive it. */
2794	if (TRPMHasTrap(pVCpu))
2795	rc = VINF_EM_RESCHEDULE;
2796	/* MWAIT has a special extension where it's woken up when
2797	an interrupt is pending even when IF=0. */
2798	else if ( (pVCpu->em.s.MWait.fWait & (EMMWAIT_FLAG_ACTIVE \| EMMWAIT_FLAG_BREAKIRQIF0))
2799	== (EMMWAIT_FLAG_ACTIVE \| EMMWAIT_FLAG_BREAKIRQIF0))
2800	{
2801	rc = VMR3WaitHalted(pVM, pVCpu, false /fIgnoreInterrupts/);
2802	if (rc == VINF_SUCCESS)
2803	{
2804	if (VMCPU_FF_TEST_AND_CLEAR(pVCpu, VMCPU_FF_UPDATE_APIC))
2805	APICUpdatePendingInterrupts(pVCpu);
2806
2807	if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_APIC \| VMCPU_FF_INTERRUPT_PIC
2808	\| VMCPU_FF_INTERRUPT_NMI \| VMCPU_FF_INTERRUPT_SMI \| VMCPU_FF_UNHALT))
2809	{
2810	Log(("EMR3ExecuteVM: Triggering reschedule on pending IRQ after MWAIT\n"));
2811	rc = VINF_EM_RESCHEDULE;
2812	}
2813	}
2814	}
2815	else
2816	{
2817	rc = VMR3WaitHalted(pVM, pVCpu, !(CPUMGetGuestEFlags(pVCpu) & X86_EFL_IF));
2818	/* We're only interested in NMI/SMIs here which have their own FFs, so we don't need to
2819	check VMCPU_FF_UPDATE_APIC here. */
2820	if ( rc == VINF_SUCCESS
2821	&& VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_NMI \| VMCPU_FF_INTERRUPT_SMI \| VMCPU_FF_UNHALT))
2822	{
2823	Log(("EMR3ExecuteVM: Triggering reschedule on pending NMI/SMI/UNHALT after HLT\n"));
2824	rc = VINF_EM_RESCHEDULE;
2825	}
2826	}
2827
2828	STAM_REL_PROFILE_STOP(&pVCpu->em.s.StatHalted, y);
2829	break;
2830	}
2831
2832	/*
2833	* Suspended - return to VM.cpp.
2834	*/
2835	case EMSTATE_SUSPENDED:
2836	TMR3NotifySuspend(pVM, pVCpu);
2837	STAM_REL_PROFILE_ADV_STOP(&pVCpu->em.s.StatTotal, x);
2838	Log(("EMR3ExecuteVM: actually returns %Rrc (state %s / %s)\n", rc, emR3GetStateName(pVCpu->em.s.enmState), emR3GetStateName(enmOldState)));
2839	return VINF_EM_SUSPEND;
2840
2841	/*
2842	* Debugging in the guest.
2843	*/
2844	case EMSTATE_DEBUG_GUEST_RAW:
2845	case EMSTATE_DEBUG_GUEST_HM:
2846	case EMSTATE_DEBUG_GUEST_NEM:
2847	case EMSTATE_DEBUG_GUEST_IEM:
2848	case EMSTATE_DEBUG_GUEST_REM:
2849	TMR3NotifySuspend(pVM, pVCpu);
2850	rc = VBOXSTRICTRC_TODO(emR3Debug(pVM, pVCpu, rc));
2851	TMR3NotifyResume(pVM, pVCpu);
2852	Log2(("EMR3ExecuteVM: emR3Debug -> %Rrc (state %d)\n", rc, pVCpu->em.s.enmState));
2853	break;
2854
2855	/*
2856	* Debugging in the hypervisor.
2857	*/
2858	case EMSTATE_DEBUG_HYPER:
2859	{
2860	TMR3NotifySuspend(pVM, pVCpu);
2861	STAM_REL_PROFILE_ADV_STOP(&pVCpu->em.s.StatTotal, x);
2862
2863	rc = VBOXSTRICTRC_TODO(emR3Debug(pVM, pVCpu, rc));
2864	Log2(("EMR3ExecuteVM: emR3Debug -> %Rrc (state %d)\n", rc, pVCpu->em.s.enmState));
2865	if (rc != VINF_SUCCESS)
2866	{
2867	if (rc == VINF_EM_OFF \|\| rc == VINF_EM_TERMINATE)
2868	pVCpu->em.s.enmState = EMSTATE_TERMINATING;
2869	else
2870	{
2871	/* switch to guru meditation mode */
2872	pVCpu->em.s.enmState = EMSTATE_GURU_MEDITATION;
2873	VMR3SetGuruMeditation(pVM); /* This notifies the other EMTs. */
2874	VMMR3FatalDump(pVM, pVCpu, rc);
2875	}
2876	Log(("EMR3ExecuteVM: actually returns %Rrc (state %s / %s)\n", rc, emR3GetStateName(pVCpu->em.s.enmState), emR3GetStateName(enmOldState)));
2877	return rc;
2878	}
2879
2880	STAM_REL_PROFILE_ADV_START(&pVCpu->em.s.StatTotal, x);
2881	TMR3NotifyResume(pVM, pVCpu);
2882	break;
2883	}
2884
2885	/*
2886	* Guru meditation takes place in the debugger.
2887	*/
2888	case EMSTATE_GURU_MEDITATION:
2889	{
2890	TMR3NotifySuspend(pVM, pVCpu);
2891	VMR3SetGuruMeditation(pVM); /* This notifies the other EMTs. */
2892	VMMR3FatalDump(pVM, pVCpu, rc);
2893	emR3Debug(pVM, pVCpu, rc);
2894	STAM_REL_PROFILE_ADV_STOP(&pVCpu->em.s.StatTotal, x);
2895	Log(("EMR3ExecuteVM: actually returns %Rrc (state %s / %s)\n", rc, emR3GetStateName(pVCpu->em.s.enmState), emR3GetStateName(enmOldState)));
2896	return rc;
2897	}
2898
2899	/*
2900	* The states we don't expect here.
2901	*/
2902	case EMSTATE_NONE:
2903	case EMSTATE_TERMINATING:
2904	default:
2905	AssertMsgFailed(("EMR3ExecuteVM: Invalid state %d!\n", pVCpu->em.s.enmState));
2906	pVCpu->em.s.enmState = EMSTATE_GURU_MEDITATION;
2907	TMR3NotifySuspend(pVM, pVCpu);
2908	STAM_REL_PROFILE_ADV_STOP(&pVCpu->em.s.StatTotal, x);
2909	Log(("EMR3ExecuteVM: actually returns %Rrc (state %s / %s)\n", rc, emR3GetStateName(pVCpu->em.s.enmState), emR3GetStateName(enmOldState)));
2910	return VERR_EM_INTERNAL_ERROR;
2911	}
2912	} /* The Outer Main Loop */
2913	}
2914	else
2915	{
2916	/*
2917	* Fatal error.
2918	*/
2919	Log(("EMR3ExecuteVM: returns %Rrc because of longjmp / fatal error; (state %s / %s)\n", rc, emR3GetStateName(pVCpu->em.s.enmState), emR3GetStateName(pVCpu->em.s.enmPrevState)));
2920	TMR3NotifySuspend(pVM, pVCpu);
2921	VMR3SetGuruMeditation(pVM); /* This notifies the other EMTs. */
2922	VMMR3FatalDump(pVM, pVCpu, rc);
2923	emR3Debug(pVM, pVCpu, rc);
2924	STAM_REL_PROFILE_ADV_STOP(&pVCpu->em.s.StatTotal, x);
2925	/** @todo change the VM state! */
2926	return rc;
2927	}
2928
2929	/* not reached */
2930	}
2931
2932	/**
2933	* Notify EM of a state change (used by FTM)
2934	*
2935	* @param pVM The cross context VM structure.
2936	*/
2937	VMMR3_INT_DECL(int) EMR3NotifySuspend(PVM pVM)
2938	{
2939	PVMCPU pVCpu = VMMGetCpu(pVM);
2940
2941	TMR3NotifySuspend(pVM, pVCpu); /* Stop the virtual time. */
2942	pVCpu->em.s.enmPrevState = pVCpu->em.s.enmState;
2943	pVCpu->em.s.enmState = EMSTATE_SUSPENDED;
2944	return VINF_SUCCESS;
2945	}
2946
2947	/**
2948	* Notify EM of a state change (used by FTM)
2949	*
2950	* @param pVM The cross context VM structure.
2951	*/
2952	VMMR3_INT_DECL(int) EMR3NotifyResume(PVM pVM)
2953	{
2954	PVMCPU pVCpu = VMMGetCpu(pVM);
2955	EMSTATE enmCurState = pVCpu->em.s.enmState;
2956
2957	TMR3NotifyResume(pVM, pVCpu); /* Resume the virtual time. */
2958	pVCpu->em.s.enmState = pVCpu->em.s.enmPrevState;
2959	pVCpu->em.s.enmPrevState = enmCurState;
2960	return VINF_SUCCESS;
2961	}

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

source: vbox/trunk/src/VBox/VMM/VMMR3/EM.cpp@ 72487

Download in other formats: