EM.cpp@ 105698

Last change on this file since 105698 was 105698, checked in by vboxsync, 4 months ago
VMM/IEM,TM: Adaptive timer polling and running of the timer queues from the IEM recompiler execution loop. bugref:10656
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 114.6 KB

Line
1	/* $Id: EM.cpp 105698 2024-08-15 23:33:49Z vboxsync $ */
2	/** @file
3	* EM - Execution Monitor / Manager.
4	*/
5
6	/*
7	* Copyright (C) 2006-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28	/** @page pg_em EM - The Execution Monitor / Manager
29	*
30	* The Execution Monitor/Manager is responsible for running the VM, scheduling
31	* the right kind of execution (Raw-mode, Hardware Assisted, Recompiled or
32	* Interpreted), and keeping the CPU states in sync. The function
33	* EMR3ExecuteVM() is the 'main-loop' of the VM, while each of the execution
34	* modes has different inner loops (emR3RawExecute, emR3HmExecute, and
35	* emR3RmExecute).
36	*
37	* The interpreted execution is only used to avoid switching between
38	* raw-mode/hm and the recompiler when fielding virtualization traps/faults.
39	* The interpretation is thus implemented as part of EM.
40	*
41	* @see grp_em
42	*/
43
44
45	/*********************************************************************************************************************************
46	* Header Files *
47	*********************************************************************************************************************************/
48	#define LOG_GROUP LOG_GROUP_EM
49	#define VMCPU_INCL_CPUM_GST_CTX /* for CPUM_IMPORT_GUEST_STATE_RET & interrupt injection */
50	#include <VBox/vmm/em.h>
51	#include <VBox/vmm/vmm.h>
52	#include <VBox/vmm/selm.h>
53	#include <VBox/vmm/trpm.h>
54	#include <VBox/vmm/iem.h>
55	#include <VBox/vmm/nem.h>
56	#include <VBox/vmm/iom.h>
57	#include <VBox/vmm/dbgf.h>
58	#include <VBox/vmm/pgm.h>
59	#include <VBox/vmm/apic.h>
60	#include <VBox/vmm/tm.h>
61	#include <VBox/vmm/mm.h>
62	#include <VBox/vmm/ssm.h>
63	#include <VBox/vmm/pdmapi.h>
64	#include <VBox/vmm/pdmcritsect.h>
65	#include <VBox/vmm/pdmqueue.h>
66	#include <VBox/vmm/hm.h>
67	#include "EMInternal.h"
68	#include <VBox/vmm/vm.h>
69	#include <VBox/vmm/uvm.h>
70	#include <VBox/vmm/cpumdis.h>
71	#include <VBox/dis.h>
72	#include <VBox/err.h>
73	#include "VMMTracing.h"
74
75	#include <iprt/asm.h>
76	#include <iprt/string.h>
77	#include <iprt/stream.h>
78	#include <iprt/thread.h>
79
80	#include "EMInline.h"
81
82
83	/*********************************************************************************************************************************
84	* Internal Functions *
85	*********************************************************************************************************************************/
86	static DECLCALLBACK(int) emR3Save(PVM pVM, PSSMHANDLE pSSM);
87	static DECLCALLBACK(int) emR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
88	#if defined(LOG_ENABLED) \|\| defined(VBOX_STRICT)
89	static const char *emR3GetStateName(EMSTATE enmState);
90	#endif
91	static VBOXSTRICTRC emR3Debug(PVM pVM, PVMCPU pVCpu, VBOXSTRICTRC rc);
92
93
94	/**
95	* Initializes the EM.
96	*
97	* @returns VBox status code.
98	* @param pVM The cross context VM structure.
99	*/
100	VMMR3_INT_DECL(int) EMR3Init(PVM pVM)
101	{
102	LogFlow(("EMR3Init\n"));
103	/*
104	* Assert alignment and sizes.
105	*/
106	AssertCompileMemberAlignment(VM, em.s, 32);
107	AssertCompile(sizeof(pVM->em.s) <= sizeof(pVM->em.padding));
108	AssertCompile(RT_SIZEOFMEMB(VMCPU, em.s.u.FatalLongJump) <= RT_SIZEOFMEMB(VMCPU, em.s.u.achPaddingFatalLongJump));
109	AssertCompile(RT_SIZEOFMEMB(VMCPU, em.s) <= RT_SIZEOFMEMB(VMCPU, em.padding));
110
111	/*
112	* Init the structure.
113	*/
114	PCFGMNODE pCfgRoot = CFGMR3GetRoot(pVM);
115	PCFGMNODE pCfgEM = CFGMR3GetChild(pCfgRoot, "EM");
116
117	int rc = CFGMR3QueryBoolDef(pCfgEM, "IemExecutesAll", &pVM->em.s.fIemExecutesAll,
118	#if defined(RT_ARCH_ARM64) && defined(RT_OS_DARWIN) && !defined(VBOX_VMM_TARGET_ARMV8)
119	true
120	#else
121	false
122	#endif
123	);
124	AssertLogRelRCReturn(rc, rc);
125
126	bool fEnabled;
127	rc = CFGMR3QueryBoolDef(pCfgEM, "TripleFaultReset", &fEnabled, false);
128	AssertLogRelRCReturn(rc, rc);
129	pVM->em.s.fGuruOnTripleFault = !fEnabled;
130	if (!pVM->em.s.fGuruOnTripleFault && pVM->cCpus > 1)
131	{
132	LogRel(("EM: Overriding /EM/TripleFaultReset, must be false on SMP.\n"));
133	pVM->em.s.fGuruOnTripleFault = true;
134	}
135
136	LogRel(("EMR3Init: fIemExecutesAll=%RTbool fGuruOnTripleFault=%RTbool\n", pVM->em.s.fIemExecutesAll, pVM->em.s.fGuruOnTripleFault));
137
138	/** @cfgm{/EM/ExitOptimizationEnabled, bool, true}
139	* Whether to try correlate exit history in any context, detect hot spots and
140	* try optimize these using IEM if there are other exits close by. This
141	* overrides the context specific settings. */
142	bool fExitOptimizationEnabled = true;
143	rc = CFGMR3QueryBoolDef(pCfgEM, "ExitOptimizationEnabled", &fExitOptimizationEnabled, true);
144	AssertLogRelRCReturn(rc, rc);
145
146	/** @cfgm{/EM/ExitOptimizationEnabledR0, bool, true}
147	* Whether to optimize exits in ring-0. Setting this to false will also disable
148	* the /EM/ExitOptimizationEnabledR0PreemptDisabled setting. Depending on preemption
149	* capabilities of the host kernel, this optimization may be unavailable. */
150	bool fExitOptimizationEnabledR0 = true;
151	rc = CFGMR3QueryBoolDef(pCfgEM, "ExitOptimizationEnabledR0", &fExitOptimizationEnabledR0, true);
152	AssertLogRelRCReturn(rc, rc);
153	fExitOptimizationEnabledR0 &= fExitOptimizationEnabled;
154
155	/** @cfgm{/EM/ExitOptimizationEnabledR0PreemptDisabled, bool, false}
156	* Whether to optimize exits in ring-0 when preemption is disable (or preemption
157	* hooks are in effect). */
158	/** @todo change the default to true here */
159	bool fExitOptimizationEnabledR0PreemptDisabled = true;
160	rc = CFGMR3QueryBoolDef(pCfgEM, "ExitOptimizationEnabledR0PreemptDisabled", &fExitOptimizationEnabledR0PreemptDisabled, false);
161	AssertLogRelRCReturn(rc, rc);
162	fExitOptimizationEnabledR0PreemptDisabled &= fExitOptimizationEnabledR0;
163
164	/** @cfgm{/EM/HistoryExecMaxInstructions, integer, 16, 65535, 8192}
165	* Maximum number of instruction to let EMHistoryExec execute in one go. */
166	uint16_t cHistoryExecMaxInstructions = 8192;
167	rc = CFGMR3QueryU16Def(pCfgEM, "HistoryExecMaxInstructions", &cHistoryExecMaxInstructions, cHistoryExecMaxInstructions);
168	AssertLogRelRCReturn(rc, rc);
169	if (cHistoryExecMaxInstructions < 16)
170	return VMSetError(pVM, VERR_OUT_OF_RANGE, RT_SRC_POS, "/EM/HistoryExecMaxInstructions value is too small, min 16");
171
172	/** @cfgm{/EM/HistoryProbeMaxInstructionsWithoutExit, integer, 2, 65535, 24 for HM, 32 for NEM}
173	* Maximum number of instruction between exits during probing. */
174	uint16_t cHistoryProbeMaxInstructionsWithoutExit = 24;
175	#ifdef RT_OS_WINDOWS
176	if (VM_IS_NEM_ENABLED(pVM))
177	cHistoryProbeMaxInstructionsWithoutExit = 32;
178	#endif
179	rc = CFGMR3QueryU16Def(pCfgEM, "HistoryProbeMaxInstructionsWithoutExit", &cHistoryProbeMaxInstructionsWithoutExit,
180	cHistoryProbeMaxInstructionsWithoutExit);
181	AssertLogRelRCReturn(rc, rc);
182	if (cHistoryProbeMaxInstructionsWithoutExit < 2)
183	return VMSetError(pVM, VERR_OUT_OF_RANGE, RT_SRC_POS,
184	"/EM/HistoryProbeMaxInstructionsWithoutExit value is too small, min 16");
185
186	/** @cfgm{/EM/HistoryProbMinInstructions, integer, 0, 65535, depends}
187	* The default is (/EM/HistoryProbeMaxInstructionsWithoutExit + 1) * 3. */
188	uint16_t cHistoryProbeMinInstructions = cHistoryProbeMaxInstructionsWithoutExit < 0x5554
189	? (cHistoryProbeMaxInstructionsWithoutExit + 1) * 3 : 0xffff;
190	rc = CFGMR3QueryU16Def(pCfgEM, "HistoryProbMinInstructions", &cHistoryProbeMinInstructions,
191	cHistoryProbeMinInstructions);
192	AssertLogRelRCReturn(rc, rc);
193
194	for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
195	{
196	PVMCPU pVCpu = pVM->apCpusR3[idCpu];
197	pVCpu->em.s.fExitOptimizationEnabled = fExitOptimizationEnabled;
198	pVCpu->em.s.fExitOptimizationEnabledR0 = fExitOptimizationEnabledR0;
199	pVCpu->em.s.fExitOptimizationEnabledR0PreemptDisabled = fExitOptimizationEnabledR0PreemptDisabled;
200	pVCpu->em.s.cHistoryExecMaxInstructions = cHistoryExecMaxInstructions;
201	pVCpu->em.s.cHistoryProbeMinInstructions = cHistoryProbeMinInstructions;
202	pVCpu->em.s.cHistoryProbeMaxInstructionsWithoutExit = cHistoryProbeMaxInstructionsWithoutExit;
203	}
204
205	#ifdef VBOX_WITH_IEM_RECOMPILER
206	/** @cfgm{/EM/IemRecompiled, bool, true}
207	* Whether IEM bulk execution is recompiled or interpreted. */
208	rc = CFGMR3QueryBoolDef(pCfgEM, "IemRecompiled", &pVM->em.s.fIemRecompiled, true);
209	AssertLogRelRCReturn(rc, rc);
210	#endif
211
212	/*
213	* Saved state.
214	*/
215	rc = SSMR3RegisterInternal(pVM, "em", 0, EM_SAVED_STATE_VERSION, 16,
216	NULL, NULL, NULL,
217	NULL, emR3Save, NULL,
218	NULL, emR3Load, NULL);
219	if (RT_FAILURE(rc))
220	return rc;
221
222	for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
223	{
224	PVMCPU pVCpu = pVM->apCpusR3[idCpu];
225
226	pVCpu->em.s.enmState = idCpu == 0 ? EMSTATE_NONE : EMSTATE_WAIT_SIPI;
227	pVCpu->em.s.enmPrevState = EMSTATE_NONE;
228	pVCpu->em.s.msTimeSliceStart = 0; /* paranoia */
229	pVCpu->em.s.idxContinueExitRec = UINT16_MAX;
230
231	# define EM_REG_COUNTER(a, b, c) \
232	rc = STAMR3RegisterF(pVM, a, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, c, b, idCpu); \
233	AssertRC(rc);
234
235	# define EM_REG_COUNTER_USED(a, b, c) \
236	rc = STAMR3RegisterF(pVM, a, STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES, c, b, idCpu); \
237	AssertRC(rc);
238
239	# define EM_REG_PROFILE(a, b, c) \
240	rc = STAMR3RegisterF(pVM, a, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, c, b, idCpu); \
241	AssertRC(rc);
242
243	# define EM_REG_PROFILE_ADV(a, b, c) \
244	rc = STAMR3RegisterF(pVM, a, STAMTYPE_PROFILE_ADV, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, c, b, idCpu); \
245	AssertRC(rc);
246
247	/*
248	* Statistics.
249	*/
250	#ifdef VBOX_WITH_STATISTICS
251	EM_REG_COUNTER_USED(&pVCpu->em.s.StatIoRestarted, "/EM/CPU%u/R3/PrivInst/IoRestarted", "I/O instructions restarted in ring-3.");
252	EM_REG_COUNTER_USED(&pVCpu->em.s.StatIoIem, "/EM/CPU%u/R3/PrivInst/IoIem", "I/O instructions end to IEM in ring-3.");
253
254	/* these should be considered for release statistics. */
255	EM_REG_COUNTER(&pVCpu->em.s.StatIOEmu, "/PROF/CPU%u/EM/Emulation/IO", "Profiling of emR3RawExecuteIOInstruction.");
256	EM_REG_COUNTER(&pVCpu->em.s.StatPrivEmu, "/PROF/CPU%u/EM/Emulation/Priv", "Profiling of emR3RawPrivileged.");
257	EM_REG_PROFILE(&pVCpu->em.s.StatHMEntry, "/PROF/CPU%u/EM/HMEnter", "Profiling Hardware Accelerated Mode entry overhead.");
258	#endif
259	EM_REG_PROFILE(&pVCpu->em.s.StatHMExec, "/PROF/CPU%u/EM/HMExec", "Profiling Hardware Accelerated Mode execution.");
260	EM_REG_COUNTER(&pVCpu->em.s.StatHMExecuteCalled, "/PROF/CPU%u/EM/HMExecuteCalled", "Number of times enmR3HMExecute is called.");
261	#ifdef VBOX_WITH_STATISTICS
262	EM_REG_PROFILE(&pVCpu->em.s.StatIEMEmu, "/PROF/CPU%u/EM/IEMEmuSingle", "Profiling single instruction IEM execution.");
263	EM_REG_PROFILE(&pVCpu->em.s.StatIEMThenREM, "/PROF/CPU%u/EM/IEMThenRem", "Profiling IEM-then-REM instruction execution (by IEM).");
264	EM_REG_PROFILE(&pVCpu->em.s.StatNEMEntry, "/PROF/CPU%u/EM/NEMEnter", "Profiling NEM entry overhead.");
265	#endif
266	EM_REG_PROFILE(&pVCpu->em.s.StatNEMExec, "/PROF/CPU%u/EM/NEMExec", "Profiling NEM execution.");
267	EM_REG_COUNTER(&pVCpu->em.s.StatNEMExecuteCalled, "/PROF/CPU%u/EM/NEMExecuteCalled", "Number of times enmR3NEMExecute is called.");
268	#ifdef VBOX_WITH_STATISTICS
269	EM_REG_PROFILE(&pVCpu->em.s.StatREMExec, "/PROF/CPU%u/EM/REMExec", "Profiling REM execution.");
270	#endif
271
272	EM_REG_COUNTER(&pVCpu->em.s.StatForcedActions, "/PROF/CPU%u/EM/ForcedActions", "Profiling forced action execution.");
273	EM_REG_COUNTER(&pVCpu->em.s.StatHalted, "/PROF/CPU%u/EM/Halted", "Profiling halted state (VMR3WaitHalted).");
274	EM_REG_PROFILE_ADV(&pVCpu->em.s.StatCapped, "/PROF/CPU%u/EM/Capped", "Profiling capped state (sleep).");
275	EM_REG_COUNTER(&pVCpu->em.s.StatREMTotal, "/PROF/CPU%u/EM/REMTotal", "Profiling emR3RecompilerExecute (excluding FFs).");
276
277	EM_REG_PROFILE_ADV(&pVCpu->em.s.StatTotal, "/PROF/CPU%u/EM/Total", "Profiling EMR3ExecuteVM.");
278
279	rc = STAMR3RegisterF(pVM, &pVCpu->em.s.iNextExit, STAMTYPE_U64, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,
280	"Number of recorded exits.", "/PROF/CPU%u/EM/RecordedExits", idCpu);
281	AssertRC(rc);
282
283	/* History record statistics */
284	rc = STAMR3RegisterF(pVM, &pVCpu->em.s.cExitRecordUsed, STAMTYPE_U32, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,
285	"Number of used hash table entries.", "/EM/CPU%u/ExitHashing/Used", idCpu);
286	AssertRC(rc);
287
288	for (uint32_t iStep = 0; iStep < RT_ELEMENTS(pVCpu->em.s.aStatHistoryRecHits); iStep++)
289	{
290	rc = STAMR3RegisterF(pVM, &pVCpu->em.s.aStatHistoryRecHits[iStep], STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES,
291	"Number of hits at this step.", "/EM/CPU%u/ExitHashing/Step%02u-Hits", idCpu, iStep);
292	AssertRC(rc);
293	rc = STAMR3RegisterF(pVM, &pVCpu->em.s.aStatHistoryRecTypeChanged[iStep], STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES,
294	"Number of type changes at this step.", "/EM/CPU%u/ExitHashing/Step%02u-TypeChanges", idCpu, iStep);
295	AssertRC(rc);
296	rc = STAMR3RegisterF(pVM, &pVCpu->em.s.aStatHistoryRecTypeChanged[iStep], STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES,
297	"Number of replacments at this step.", "/EM/CPU%u/ExitHashing/Step%02u-Replacments", idCpu, iStep);
298	AssertRC(rc);
299	rc = STAMR3RegisterF(pVM, &pVCpu->em.s.aStatHistoryRecNew[iStep], STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES,
300	"Number of new inserts at this step.", "/EM/CPU%u/ExitHashing/Step%02u-NewInserts", idCpu, iStep);
301	AssertRC(rc);
302	}
303
304	EM_REG_PROFILE(&pVCpu->em.s.StatHistoryExec, "/EM/CPU%u/ExitOpt/Exec", "Profiling normal EMHistoryExec operation.");
305	EM_REG_COUNTER(&pVCpu->em.s.StatHistoryExecSavedExits, "/EM/CPU%u/ExitOpt/ExecSavedExit", "Net number of saved exits.");
306	EM_REG_COUNTER(&pVCpu->em.s.StatHistoryExecInstructions, "/EM/CPU%u/ExitOpt/ExecInstructions", "Number of instructions executed during normal operation.");
307	EM_REG_PROFILE(&pVCpu->em.s.StatHistoryProbe, "/EM/CPU%u/ExitOpt/Probe", "Profiling EMHistoryExec when probing.");
308	EM_REG_COUNTER(&pVCpu->em.s.StatHistoryProbeInstructions, "/EM/CPU%u/ExitOpt/ProbeInstructions", "Number of instructions executed during probing.");
309	EM_REG_COUNTER(&pVCpu->em.s.StatHistoryProbedNormal, "/EM/CPU%u/ExitOpt/ProbedNormal", "Number of EMEXITACTION_NORMAL_PROBED results.");
310	EM_REG_COUNTER(&pVCpu->em.s.StatHistoryProbedExecWithMax, "/EM/CPU%u/ExitOpt/ProbedExecWithMax", "Number of EMEXITACTION_EXEC_WITH_MAX results.");
311	EM_REG_COUNTER(&pVCpu->em.s.StatHistoryProbedToRing3, "/EM/CPU%u/ExitOpt/ProbedToRing3", "Number of ring-3 probe continuations.");
312	}
313
314	emR3InitDbg(pVM);
315	return VINF_SUCCESS;
316	}
317
318
319	/**
320	* Called when a VM initialization stage is completed.
321	*
322	* @returns VBox status code.
323	* @param pVM The cross context VM structure.
324	* @param enmWhat The initialization state that was completed.
325	*/
326	VMMR3_INT_DECL(int) EMR3InitCompleted(PVM pVM, VMINITCOMPLETED enmWhat)
327	{
328	if (enmWhat == VMINITCOMPLETED_RING0)
329	LogRel(("EM: Exit history optimizations: enabled=%RTbool enabled-r0=%RTbool enabled-r0-no-preemption=%RTbool\n",
330	pVM->apCpusR3[0]->em.s.fExitOptimizationEnabled, pVM->apCpusR3[0]->em.s.fExitOptimizationEnabledR0,
331	pVM->apCpusR3[0]->em.s.fExitOptimizationEnabledR0PreemptDisabled));
332	return VINF_SUCCESS;
333	}
334
335
336	/**
337	* Applies relocations to data and code managed by this
338	* component. This function will be called at init and
339	* whenever the VMM need to relocate it self inside the GC.
340	*
341	* @param pVM The cross context VM structure.
342	*/
343	VMMR3_INT_DECL(void) EMR3Relocate(PVM pVM)
344	{
345	LogFlow(("EMR3Relocate\n"));
346	RT_NOREF(pVM);
347	}
348
349
350	/**
351	* Reset the EM state for a CPU.
352	*
353	* Called by EMR3Reset and hot plugging.
354	*
355	* @param pVCpu The cross context virtual CPU structure.
356	*/
357	VMMR3_INT_DECL(void) EMR3ResetCpu(PVMCPU pVCpu)
358	{
359	/* Reset scheduling state. */
360	VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_UNHALT);
361
362	/* VMR3ResetFF may return VINF_EM_RESET or VINF_EM_SUSPEND, so transition
363	out of the HALTED state here so that enmPrevState doesn't end up as
364	HALTED when EMR3Execute returns. */
365	if (pVCpu->em.s.enmState == EMSTATE_HALTED)
366	{
367	Log(("EMR3ResetCpu: Cpu#%u %s -> %s\n", pVCpu->idCpu, emR3GetStateName(pVCpu->em.s.enmState), pVCpu->idCpu == 0 ? "EMSTATE_NONE" : "EMSTATE_WAIT_SIPI"));
368	pVCpu->em.s.enmState = pVCpu->idCpu == 0 ? EMSTATE_NONE : EMSTATE_WAIT_SIPI;
369	}
370	}
371
372
373	/**
374	* Reset notification.
375	*
376	* @param pVM The cross context VM structure.
377	*/
378	VMMR3_INT_DECL(void) EMR3Reset(PVM pVM)
379	{
380	Log(("EMR3Reset: \n"));
381	for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
382	EMR3ResetCpu(pVM->apCpusR3[idCpu]);
383	}
384
385
386	/**
387	* Terminates the EM.
388	*
389	* Termination means cleaning up and freeing all resources,
390	* the VM it self is at this point powered off or suspended.
391	*
392	* @returns VBox status code.
393	* @param pVM The cross context VM structure.
394	*/
395	VMMR3_INT_DECL(int) EMR3Term(PVM pVM)
396	{
397	RT_NOREF(pVM);
398	return VINF_SUCCESS;
399	}
400
401
402	/**
403	* Execute state save operation.
404	*
405	* @returns VBox status code.
406	* @param pVM The cross context VM structure.
407	* @param pSSM SSM operation handle.
408	*/
409	static DECLCALLBACK(int) emR3Save(PVM pVM, PSSMHANDLE pSSM)
410	{
411	for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
412	{
413	PVMCPU pVCpu = pVM->apCpusR3[idCpu];
414
415	SSMR3PutBool(pSSM, false /fForceRAW/);
416
417	Assert(pVCpu->em.s.enmState == EMSTATE_SUSPENDED);
418	Assert(pVCpu->em.s.enmPrevState != EMSTATE_SUSPENDED);
419	SSMR3PutU32(pSSM,
420	pVCpu->em.s.enmPrevState == EMSTATE_NONE
421	\|\| pVCpu->em.s.enmPrevState == EMSTATE_HALTED
422	\|\| pVCpu->em.s.enmPrevState == EMSTATE_WAIT_SIPI
423	? pVCpu->em.s.enmPrevState : EMSTATE_NONE);
424
425	/* Save mwait state. */
426	SSMR3PutU32(pSSM, pVCpu->em.s.MWait.fWait);
427	SSMR3PutGCPtr(pSSM, pVCpu->em.s.MWait.uMWaitRAX);
428	SSMR3PutGCPtr(pSSM, pVCpu->em.s.MWait.uMWaitRCX);
429	SSMR3PutGCPtr(pSSM, pVCpu->em.s.MWait.uMonitorRAX);
430	SSMR3PutGCPtr(pSSM, pVCpu->em.s.MWait.uMonitorRCX);
431	int rc = SSMR3PutGCPtr(pSSM, pVCpu->em.s.MWait.uMonitorRDX);
432	AssertRCReturn(rc, rc);
433	}
434	return VINF_SUCCESS;
435	}
436
437
438	/**
439	* Execute state load operation.
440	*
441	* @returns VBox status code.
442	* @param pVM The cross context VM structure.
443	* @param pSSM SSM operation handle.
444	* @param uVersion Data layout version.
445	* @param uPass The data pass.
446	*/
447	static DECLCALLBACK(int) emR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
448	{
449	/*
450	* Validate version.
451	*/
452	if ( uVersion > EM_SAVED_STATE_VERSION
453	\|\| uVersion < EM_SAVED_STATE_VERSION_PRE_SMP)
454	{
455	AssertMsgFailed(("emR3Load: Invalid version uVersion=%d (current %d)!\n", uVersion, EM_SAVED_STATE_VERSION));
456	return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
457	}
458	Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
459
460	/*
461	* Load the saved state.
462	*/
463	for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
464	{
465	PVMCPU pVCpu = pVM->apCpusR3[idCpu];
466
467	bool fForceRAWIgnored;
468	int rc = SSMR3GetBool(pSSM, &fForceRAWIgnored);
469	AssertRCReturn(rc, rc);
470
471	if (uVersion > EM_SAVED_STATE_VERSION_PRE_SMP)
472	{
473	/* We are only intereseted in two enmPrevState values for use when
474	EMR3ExecuteVM is called.
475	Since ~r157540. only these two and EMSTATE_NONE are saved. */
476	SSM_GET_ENUM32_RET(pSSM, pVCpu->em.s.enmPrevState, EMSTATE);
477	Assert(pVCpu->em.s.enmPrevState != EMSTATE_SUSPENDED);
478	if ( pVCpu->em.s.enmPrevState != EMSTATE_WAIT_SIPI
479	&& pVCpu->em.s.enmPrevState != EMSTATE_HALTED)
480	pVCpu->em.s.enmPrevState = EMSTATE_NONE;
481
482	pVCpu->em.s.enmState = EMSTATE_SUSPENDED;
483	}
484	if (uVersion > EM_SAVED_STATE_VERSION_PRE_MWAIT)
485	{
486	/* Load mwait state. */
487	rc = SSMR3GetU32(pSSM, &pVCpu->em.s.MWait.fWait);
488	AssertRCReturn(rc, rc);
489	rc = SSMR3GetGCPtr(pSSM, &pVCpu->em.s.MWait.uMWaitRAX);
490	AssertRCReturn(rc, rc);
491	rc = SSMR3GetGCPtr(pSSM, &pVCpu->em.s.MWait.uMWaitRCX);
492	AssertRCReturn(rc, rc);
493	rc = SSMR3GetGCPtr(pSSM, &pVCpu->em.s.MWait.uMonitorRAX);
494	AssertRCReturn(rc, rc);
495	rc = SSMR3GetGCPtr(pSSM, &pVCpu->em.s.MWait.uMonitorRCX);
496	AssertRCReturn(rc, rc);
497	rc = SSMR3GetGCPtr(pSSM, &pVCpu->em.s.MWait.uMonitorRDX);
498	AssertRCReturn(rc, rc);
499	}
500	}
501	return VINF_SUCCESS;
502	}
503
504
505	/**
506	* Argument packet for emR3SetExecutionPolicy.
507	*/
508	struct EMR3SETEXECPOLICYARGS
509	{
510	EMEXECPOLICY enmPolicy;
511	bool fEnforce;
512	};
513
514
515	/**
516	* @callback_method_impl{FNVMMEMTRENDEZVOUS, Rendezvous callback for EMR3SetExecutionPolicy.}
517	*/
518	static DECLCALLBACK(VBOXSTRICTRC) emR3SetExecutionPolicy(PVM pVM, PVMCPU pVCpu, void *pvUser)
519	{
520	/*
521	* Only the first CPU changes the variables.
522	*/
523	if (pVCpu->idCpu == 0)
524	{
525	struct EMR3SETEXECPOLICYARGS pArgs = (struct EMR3SETEXECPOLICYARGS )pvUser;
526	switch (pArgs->enmPolicy)
527	{
528	case EMEXECPOLICY_IEM_ALL:
529	pVM->em.s.fIemExecutesAll = pArgs->fEnforce;
530
531	/* For making '.alliem 1' useful during debugging, transition the
532	EMSTATE_DEBUG_GUEST_XXX to EMSTATE_DEBUG_GUEST_IEM. */
533	for (VMCPUID i = 0; i < pVM->cCpus; i++)
534	{
535	PVMCPU pVCpuX = pVM->apCpusR3[i];
536	switch (pVCpuX->em.s.enmState)
537	{
538	case EMSTATE_DEBUG_GUEST_RECOMPILER:
539	if (pVM->em.s.fIemRecompiled)
540	break;
541	RT_FALL_THROUGH();
542	case EMSTATE_DEBUG_GUEST_RAW:
543	case EMSTATE_DEBUG_GUEST_HM:
544	case EMSTATE_DEBUG_GUEST_NEM:
545	Log(("EM: idCpu=%u: %s -> EMSTATE_DEBUG_GUEST_IEM\n", i, emR3GetStateName(pVCpuX->em.s.enmState) ));
546	pVCpuX->em.s.enmState = EMSTATE_DEBUG_GUEST_IEM;
547	break;
548	case EMSTATE_DEBUG_GUEST_IEM:
549	default:
550	break;
551	}
552	}
553	break;
554
555	case EMEXECPOLICY_IEM_RECOMPILED:
556	pVM->em.s.fIemRecompiled = pArgs->fEnforce;
557	break;
558
559	default:
560	AssertFailedReturn(VERR_INVALID_PARAMETER);
561	}
562	Log(("EM: Set execution policy: fIemExecutesAll=%RTbool fIemRecompiled=%RTbool\n",
563	pVM->em.s.fIemExecutesAll, pVM->em.s.fIemRecompiled));
564	}
565
566	/*
567	* Force rescheduling if in HM, NEM, IEM/interpreter or IEM/recompiler.
568	*/
569	Assert(pVCpu->em.s.enmState != EMSTATE_RAW_OBSOLETE);
570	return pVCpu->em.s.enmState == EMSTATE_HM
571	\|\| pVCpu->em.s.enmState == EMSTATE_NEM
572	\|\| pVCpu->em.s.enmState == EMSTATE_IEM
573	\|\| pVCpu->em.s.enmState == EMSTATE_RECOMPILER
574	? VINF_EM_RESCHEDULE
575	: VINF_SUCCESS;
576	}
577
578
579	/**
580	* Changes an execution scheduling policy parameter.
581	*
582	* This is used to enable or disable raw-mode / hardware-virtualization
583	* execution of user and supervisor code.
584	*
585	* @returns VINF_SUCCESS on success.
586	* @returns VINF_RESCHEDULE if a rescheduling might be required.
587	* @returns VERR_INVALID_PARAMETER on an invalid enmMode value.
588	*
589	* @param pUVM The user mode VM handle.
590	* @param enmPolicy The scheduling policy to change.
591	* @param fEnforce Whether to enforce the policy or not.
592	*/
593	VMMR3DECL(int) EMR3SetExecutionPolicy(PUVM pUVM, EMEXECPOLICY enmPolicy, bool fEnforce)
594	{
595	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
596	VM_ASSERT_VALID_EXT_RETURN(pUVM->pVM, VERR_INVALID_VM_HANDLE);
597	AssertReturn(enmPolicy > EMEXECPOLICY_INVALID && enmPolicy < EMEXECPOLICY_END, VERR_INVALID_PARAMETER);
598
599	struct EMR3SETEXECPOLICYARGS Args = { enmPolicy, fEnforce };
600	return VMMR3EmtRendezvous(pUVM->pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_DESCENDING, emR3SetExecutionPolicy, &Args);
601	}
602
603
604	/**
605	* Queries an execution scheduling policy parameter.
606	*
607	* @returns VBox status code
608	* @param pUVM The user mode VM handle.
609	* @param enmPolicy The scheduling policy to query.
610	* @param pfEnforced Where to return the current value.
611	*/
612	VMMR3DECL(int) EMR3QueryExecutionPolicy(PUVM pUVM, EMEXECPOLICY enmPolicy, bool *pfEnforced)
613	{
614	AssertReturn(enmPolicy > EMEXECPOLICY_INVALID && enmPolicy < EMEXECPOLICY_END, VERR_INVALID_PARAMETER);
615	AssertPtrReturn(pfEnforced, VERR_INVALID_POINTER);
616	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
617	PVM pVM = pUVM->pVM;
618	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
619
620	/* No need to bother EMTs with a query. */
621	switch (enmPolicy)
622	{
623	case EMEXECPOLICY_IEM_ALL:
624	*pfEnforced = pVM->em.s.fIemExecutesAll;
625	break;
626	case EMEXECPOLICY_IEM_RECOMPILED:
627	*pfEnforced = pVM->em.s.fIemRecompiled;
628	break;
629	default:
630	AssertFailedReturn(VERR_INTERNAL_ERROR_2);
631	}
632
633	return VINF_SUCCESS;
634	}
635
636
637	/**
638	* Queries the main execution engine of the VM.
639	*
640	* @returns VBox status code
641	* @param pUVM The user mode VM handle.
642	* @param pbMainExecutionEngine Where to return the result, VM_EXEC_ENGINE_XXX.
643	*/
644	VMMR3DECL(int) EMR3QueryMainExecutionEngine(PUVM pUVM, uint8_t *pbMainExecutionEngine)
645	{
646	AssertPtrReturn(pbMainExecutionEngine, VERR_INVALID_POINTER);
647	*pbMainExecutionEngine = VM_EXEC_ENGINE_NOT_SET;
648
649	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
650	PVM pVM = pUVM->pVM;
651	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
652
653	*pbMainExecutionEngine = pVM->bMainExecutionEngine;
654	return VINF_SUCCESS;
655	}
656
657
658	/**
659	* Raise a fatal error.
660	*
661	* Safely terminate the VM with full state report and stuff. This function
662	* will naturally never return.
663	*
664	* @param pVCpu The cross context virtual CPU structure.
665	* @param rc VBox status code.
666	*/
667	VMMR3DECL(void) EMR3FatalError(PVMCPU pVCpu, int rc)
668	{
669	pVCpu->em.s.enmState = EMSTATE_GURU_MEDITATION;
670	longjmp(pVCpu->em.s.u.FatalLongJump, rc);
671	}
672
673
674	#if defined(LOG_ENABLED) \|\| defined(VBOX_STRICT)
675	/**
676	* Gets the EM state name.
677	*
678	* @returns pointer to read only state name,
679	* @param enmState The state.
680	*/
681	static const char *emR3GetStateName(EMSTATE enmState)
682	{
683	switch (enmState)
684	{
685	case EMSTATE_NONE: return "EMSTATE_NONE";
686	case EMSTATE_RAW_OBSOLETE: return "EMSTATE_RAW_OBSOLETE";
687	case EMSTATE_HM: return "EMSTATE_HM";
688	case EMSTATE_IEM: return "EMSTATE_IEM";
689	case EMSTATE_RECOMPILER: return "EMSTATE_RECOMPILER";
690	case EMSTATE_HALTED: return "EMSTATE_HALTED";
691	case EMSTATE_WAIT_SIPI: return "EMSTATE_WAIT_SIPI";
692	case EMSTATE_SUSPENDED: return "EMSTATE_SUSPENDED";
693	case EMSTATE_TERMINATING: return "EMSTATE_TERMINATING";
694	case EMSTATE_DEBUG_GUEST_RAW: return "EMSTATE_DEBUG_GUEST_RAW";
695	case EMSTATE_DEBUG_GUEST_HM: return "EMSTATE_DEBUG_GUEST_HM";
696	case EMSTATE_DEBUG_GUEST_IEM: return "EMSTATE_DEBUG_GUEST_IEM";
697	case EMSTATE_DEBUG_GUEST_RECOMPILER: return "EMSTATE_DEBUG_GUEST_RECOMPILER";
698	case EMSTATE_DEBUG_HYPER: return "EMSTATE_DEBUG_HYPER";
699	case EMSTATE_GURU_MEDITATION: return "EMSTATE_GURU_MEDITATION";
700	case EMSTATE_IEM_THEN_REM_OBSOLETE: return "EMSTATE_IEM_THEN_REM_OBSOLETE";
701	case EMSTATE_NEM: return "EMSTATE_NEM";
702	case EMSTATE_DEBUG_GUEST_NEM: return "EMSTATE_DEBUG_GUEST_NEM";
703	default: return "Unknown!";
704	}
705	}
706	#endif /* LOG_ENABLED \|\| VBOX_STRICT */
707
708	#if !defined(VBOX_VMM_TARGET_ARMV8)
709
710	/**
711	* Handle pending ring-3 I/O port write.
712	*
713	* This is in response to a VINF_EM_PENDING_R3_IOPORT_WRITE status code returned
714	* by EMRZSetPendingIoPortWrite() in ring-0 or raw-mode context.
715	*
716	* @returns Strict VBox status code.
717	* @param pVM The cross context VM structure.
718	* @param pVCpu The cross context virtual CPU structure.
719	*/
720	VBOXSTRICTRC emR3ExecutePendingIoPortWrite(PVM pVM, PVMCPU pVCpu)
721	{
722	CPUM_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_RIP \| CPUMCTX_EXTRN_RFLAGS);
723
724	/* Get and clear the pending data. */
725	RTIOPORT const uPort = pVCpu->em.s.PendingIoPortAccess.uPort;
726	uint32_t const uValue = pVCpu->em.s.PendingIoPortAccess.uValue;
727	uint8_t const cbValue = pVCpu->em.s.PendingIoPortAccess.cbValue;
728	uint8_t const cbInstr = pVCpu->em.s.PendingIoPortAccess.cbInstr;
729	pVCpu->em.s.PendingIoPortAccess.cbValue = 0;
730
731	/* Assert sanity. */
732	switch (cbValue)
733	{
734	case 1: Assert(!(cbValue & UINT32_C(0xffffff00))); break;
735	case 2: Assert(!(cbValue & UINT32_C(0xffff0000))); break;
736	case 4: break;
737	default: AssertMsgFailedReturn(("cbValue=%#x\n", cbValue), VERR_EM_INTERNAL_ERROR);
738	}
739	AssertReturn(cbInstr <= 15 && cbInstr >= 1, VERR_EM_INTERNAL_ERROR);
740
741	/* Do the work.*/
742	VBOXSTRICTRC rcStrict = IOMIOPortWrite(pVM, pVCpu, uPort, uValue, cbValue);
743	LogFlow(("EM/OUT: %#x, %#x LB %u -> %Rrc\n", uPort, uValue, cbValue, VBOXSTRICTRC_VAL(rcStrict) ));
744	if (IOM_SUCCESS(rcStrict))
745	{
746	pVCpu->cpum.GstCtx.rip += cbInstr;
747	pVCpu->cpum.GstCtx.rflags.Bits.u1RF = 0;
748	}
749	return rcStrict;
750	}
751
752
753	/**
754	* Handle pending ring-3 I/O port write.
755	*
756	* This is in response to a VINF_EM_PENDING_R3_IOPORT_WRITE status code returned
757	* by EMRZSetPendingIoPortRead() in ring-0 or raw-mode context.
758	*
759	* @returns Strict VBox status code.
760	* @param pVM The cross context VM structure.
761	* @param pVCpu The cross context virtual CPU structure.
762	*/
763	VBOXSTRICTRC emR3ExecutePendingIoPortRead(PVM pVM, PVMCPU pVCpu)
764	{
765	CPUM_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_RIP \| CPUMCTX_EXTRN_RFLAGS \| CPUMCTX_EXTRN_RAX);
766
767	/* Get and clear the pending data. */
768	RTIOPORT const uPort = pVCpu->em.s.PendingIoPortAccess.uPort;
769	uint8_t const cbValue = pVCpu->em.s.PendingIoPortAccess.cbValue;
770	uint8_t const cbInstr = pVCpu->em.s.PendingIoPortAccess.cbInstr;
771	pVCpu->em.s.PendingIoPortAccess.cbValue = 0;
772
773	/* Assert sanity. */
774	switch (cbValue)
775	{
776	case 1: break;
777	case 2: break;
778	case 4: break;
779	default: AssertMsgFailedReturn(("cbValue=%#x\n", cbValue), VERR_EM_INTERNAL_ERROR);
780	}
781	AssertReturn(pVCpu->em.s.PendingIoPortAccess.uValue == UINT32_C(0x52454144) /* READ*/, VERR_EM_INTERNAL_ERROR);
782	AssertReturn(cbInstr <= 15 && cbInstr >= 1, VERR_EM_INTERNAL_ERROR);
783
784	/* Do the work.*/
785	uint32_t uValue = 0;
786	VBOXSTRICTRC rcStrict = IOMIOPortRead(pVM, pVCpu, uPort, &uValue, cbValue);
787	LogFlow(("EM/IN: %#x LB %u -> %Rrc, %#x\n", uPort, cbValue, VBOXSTRICTRC_VAL(rcStrict), uValue ));
788	if (IOM_SUCCESS(rcStrict))
789	{
790	if (cbValue == 4)
791	pVCpu->cpum.GstCtx.rax = uValue;
792	else if (cbValue == 2)
793	pVCpu->cpum.GstCtx.ax = (uint16_t)uValue;
794	else
795	pVCpu->cpum.GstCtx.al = (uint8_t)uValue;
796	pVCpu->cpum.GstCtx.rip += cbInstr;
797	pVCpu->cpum.GstCtx.rflags.Bits.u1RF = 0;
798	}
799	return rcStrict;
800	}
801
802
803	/**
804	* @callback_method_impl{FNVMMEMTRENDEZVOUS,
805	* Worker for emR3ExecuteSplitLockInstruction}
806	*/
807	static DECLCALLBACK(VBOXSTRICTRC) emR3ExecuteSplitLockInstructionRendezvous(PVM pVM, PVMCPU pVCpu, void *pvUser)
808	{
809	/* Only execute on the specified EMT. */
810	if (pVCpu == (PVMCPU)pvUser)
811	{
812	LogFunc(("\n"));
813	VBOXSTRICTRC rcStrict = IEMExecOneIgnoreLock(pVCpu);
814	LogFunc(("rcStrict=%Rrc\n", VBOXSTRICTRC_VAL(rcStrict)));
815	if (rcStrict == VINF_IEM_RAISED_XCPT)
816	rcStrict = VINF_SUCCESS;
817	return rcStrict;
818	}
819	RT_NOREF(pVM);
820	return VINF_SUCCESS;
821	}
822
823
824	/**
825	* Handle an instruction causing a split cacheline lock access in SMP VMs.
826	*
827	* Generally we only get here if the host has split-lock detection enabled and
828	* this caused an \#AC because of something the guest did. If we interpret the
829	* instruction as-is, we'll likely just repeat the split-lock access and
830	* possibly be killed, get a SIGBUS, or trigger a warning followed by extra MSR
831	* changes on context switching (costs a tiny bit). Assuming these \#ACs are
832	* rare to non-existing, we'll do a rendezvous of all EMTs and tell IEM to
833	* disregard the lock prefix when emulating the instruction.
834	*
835	* Yes, we could probably modify the MSR (or MSRs) controlling the detection
836	* feature when entering guest context, but the support for the feature isn't a
837	* 100% given and we'll need the debug-only supdrvOSMsrProberRead and
838	* supdrvOSMsrProberWrite functionality from SUPDrv.cpp to safely detect it.
839	* Thus the approach is to just deal with the spurious \#ACs first and maybe add
840	* propert detection to SUPDrv later if we find it necessary.
841	*
842	* @see @bugref{10052}
843	*
844	* @returns Strict VBox status code.
845	* @param pVM The cross context VM structure.
846	* @param pVCpu The cross context virtual CPU structure.
847	*/
848	VBOXSTRICTRC emR3ExecuteSplitLockInstruction(PVM pVM, PVMCPU pVCpu)
849	{
850	LogFunc(("\n"));
851	return VMMR3EmtRendezvous(pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_ALL_AT_ONCE, emR3ExecuteSplitLockInstructionRendezvous, pVCpu);
852	}
853
854	#endif /* VBOX_VMM_TARGET_ARMV8 */
855
856	/**
857	* Debug loop.
858	*
859	* @returns VBox status code for EM.
860	* @param pVM The cross context VM structure.
861	* @param pVCpu The cross context virtual CPU structure.
862	* @param rc Current EM VBox status code.
863	*/
864	static VBOXSTRICTRC emR3Debug(PVM pVM, PVMCPU pVCpu, VBOXSTRICTRC rc)
865	{
866	for (;;)
867	{
868	Log(("emR3Debug: rc=%Rrc\n", VBOXSTRICTRC_VAL(rc)));
869	const VBOXSTRICTRC rcLast = rc;
870
871	/*
872	* Debug related RC.
873	*/
874	switch (VBOXSTRICTRC_VAL(rc))
875	{
876	/*
877	* Single step an instruction.
878	*/
879	case VINF_EM_DBG_STEP:
880	if ( pVCpu->em.s.enmState == EMSTATE_DEBUG_GUEST_RAW
881	\|\| pVCpu->em.s.enmState == EMSTATE_DEBUG_HYPER)
882	AssertLogRelMsgFailedStmt(("Bad EM state."), rc = VERR_EM_INTERNAL_ERROR);
883	#if !defined(VBOX_VMM_TARGET_ARMV8)
884	else if (pVCpu->em.s.enmState == EMSTATE_DEBUG_GUEST_HM)
885	rc = EMR3HmSingleInstruction(pVM, pVCpu, 0 /fFlags/);
886	#endif
887	else if (pVCpu->em.s.enmState == EMSTATE_DEBUG_GUEST_NEM)
888	rc = VBOXSTRICTRC_TODO(emR3NemSingleInstruction(pVM, pVCpu, 0 /fFlags/));
889	else
890	{
891	rc = IEMExecOne(pVCpu); /** @todo add dedicated interface... */
892	if (rc == VINF_SUCCESS \|\| rc == VINF_EM_RESCHEDULE)
893	rc = VINF_EM_DBG_STEPPED;
894	}
895	#ifndef VBOX_VMM_TARGET_ARMV8
896	if (rc != VINF_EM_EMULATE_SPLIT_LOCK)
897	{ /* likely */ }
898	else
899	{
900	rc = emR3ExecuteSplitLockInstruction(pVM, pVCpu);
901	if (rc == VINF_SUCCESS \|\| rc == VINF_EM_RESCHEDULE)
902	rc = VINF_EM_DBG_STEPPED;
903	}
904	#endif
905	break;
906
907	/*
908	* Simple events: stepped, breakpoint, stop/assertion.
909	*/
910	case VINF_EM_DBG_STEPPED:
911	rc = DBGFR3Event(pVM, DBGFEVENT_STEPPED);
912	break;
913
914	case VINF_EM_DBG_BREAKPOINT:
915	rc = DBGFR3BpHit(pVM, pVCpu);
916	break;
917
918	case VINF_EM_DBG_STOP:
919	rc = DBGFR3EventSrc(pVM, DBGFEVENT_DEV_STOP, NULL, 0, NULL, NULL);
920	break;
921
922	case VINF_EM_DBG_EVENT:
923	rc = DBGFR3EventHandlePending(pVM, pVCpu);
924	break;
925
926	case VINF_EM_DBG_HYPER_STEPPED:
927	rc = DBGFR3Event(pVM, DBGFEVENT_STEPPED_HYPER);
928	break;
929
930	case VINF_EM_DBG_HYPER_BREAKPOINT:
931	rc = DBGFR3EventBreakpoint(pVM, DBGFEVENT_BREAKPOINT_HYPER);
932	break;
933
934	case VINF_EM_DBG_HYPER_ASSERTION:
935	RTPrintf("\nVINF_EM_DBG_HYPER_ASSERTION:\n%s%s\n", VMMR3GetRZAssertMsg1(pVM), VMMR3GetRZAssertMsg2(pVM));
936	RTLogFlush(NULL);
937	rc = DBGFR3EventAssertion(pVM, DBGFEVENT_ASSERTION_HYPER, VMMR3GetRZAssertMsg1(pVM), VMMR3GetRZAssertMsg2(pVM));
938	break;
939
940	/*
941	* Guru meditation.
942	*/
943	case VERR_VMM_RING0_ASSERTION: /** @todo Make a guru meditation event! */
944	rc = DBGFR3EventSrc(pVM, DBGFEVENT_FATAL_ERROR, "VERR_VMM_RING0_ASSERTION", 0, NULL, NULL);
945	break;
946	case VINF_EM_TRIPLE_FAULT: /** @todo Make a guru meditation event! */
947	rc = DBGFR3EventSrc(pVM, DBGFEVENT_DEV_STOP, "VINF_EM_TRIPLE_FAULT", 0, NULL, NULL);
948	break;
949
950	default: /** @todo don't use default for guru, but make special errors code! */
951	{
952	LogRel(("emR3Debug: rc=%Rrc\n", VBOXSTRICTRC_VAL(rc)));
953	rc = DBGFR3Event(pVM, DBGFEVENT_FATAL_ERROR);
954	break;
955	}
956	}
957
958	/*
959	* Process the result.
960	*/
961	switch (VBOXSTRICTRC_VAL(rc))
962	{
963	/*
964	* Continue the debugging loop.
965	*/
966	case VINF_EM_DBG_STEP:
967	case VINF_EM_DBG_STOP:
968	case VINF_EM_DBG_EVENT:
969	case VINF_EM_DBG_STEPPED:
970	case VINF_EM_DBG_BREAKPOINT:
971	case VINF_EM_DBG_HYPER_STEPPED:
972	case VINF_EM_DBG_HYPER_BREAKPOINT:
973	case VINF_EM_DBG_HYPER_ASSERTION:
974	break;
975
976	/*
977	* Resuming execution (in some form) has to be done here if we got
978	* a hypervisor debug event.
979	*/
980	case VINF_SUCCESS:
981	case VINF_EM_RESUME:
982	case VINF_EM_SUSPEND:
983	case VINF_EM_RESCHEDULE:
984	case VINF_EM_RESCHEDULE_REM:
985	case VINF_EM_HALT:
986	if (pVCpu->em.s.enmState == EMSTATE_DEBUG_HYPER)
987	AssertLogRelMsgFailedReturn(("Not implemented\n"), VERR_EM_INTERNAL_ERROR);
988	if (rc == VINF_SUCCESS)
989	rc = VINF_EM_RESCHEDULE;
990	return rc;
991
992	/*
993	* The debugger isn't attached.
994	* We'll simply turn the thing off since that's the easiest thing to do.
995	*/
996	case VERR_DBGF_NOT_ATTACHED:
997	switch (VBOXSTRICTRC_VAL(rcLast))
998	{
999	case VINF_EM_DBG_HYPER_STEPPED:
1000	case VINF_EM_DBG_HYPER_BREAKPOINT:
1001	case VINF_EM_DBG_HYPER_ASSERTION:
1002	case VERR_TRPM_PANIC:
1003	case VERR_TRPM_DONT_PANIC:
1004	case VERR_VMM_RING0_ASSERTION:
1005	case VERR_VMM_HYPER_CR3_MISMATCH:
1006	case VERR_VMM_RING3_CALL_DISABLED:
1007	return rcLast;
1008	}
1009	return VINF_EM_OFF;
1010
1011	/*
1012	* Status codes terminating the VM in one or another sense.
1013	*/
1014	case VINF_EM_TERMINATE:
1015	case VINF_EM_OFF:
1016	case VINF_EM_RESET:
1017	case VINF_EM_NO_MEMORY:
1018	case VINF_EM_RAW_STALE_SELECTOR:
1019	case VINF_EM_RAW_IRET_TRAP:
1020	case VERR_TRPM_PANIC:
1021	case VERR_TRPM_DONT_PANIC:
1022	case VERR_IEM_INSTR_NOT_IMPLEMENTED:
1023	case VERR_IEM_ASPECT_NOT_IMPLEMENTED:
1024	case VERR_VMM_RING0_ASSERTION:
1025	case VERR_VMM_HYPER_CR3_MISMATCH:
1026	case VERR_VMM_RING3_CALL_DISABLED:
1027	case VERR_INTERNAL_ERROR:
1028	case VERR_INTERNAL_ERROR_2:
1029	case VERR_INTERNAL_ERROR_3:
1030	case VERR_INTERNAL_ERROR_4:
1031	case VERR_INTERNAL_ERROR_5:
1032	case VERR_IPE_UNEXPECTED_STATUS:
1033	case VERR_IPE_UNEXPECTED_INFO_STATUS:
1034	case VERR_IPE_UNEXPECTED_ERROR_STATUS:
1035	return rc;
1036
1037	/*
1038	* The rest is unexpected, and will keep us here.
1039	*/
1040	default:
1041	AssertMsgFailed(("Unexpected rc %Rrc!\n", VBOXSTRICTRC_VAL(rc)));
1042	break;
1043	}
1044	} /* debug for ever */
1045	}
1046
1047
1048	/**
1049	* Executes recompiled code.
1050	*
1051	* This function contains the recompiler version of the inner
1052	* execution loop (the outer loop being in EMR3ExecuteVM()).
1053	*
1054	* @returns VBox status code. The most important ones are: VINF_EM_RESCHEDULE,
1055	* VINF_EM_SUSPEND, VINF_EM_RESET and VINF_EM_TERMINATE.
1056	*
1057	* @param pVM The cross context VM structure.
1058	* @param pVCpu The cross context virtual CPU structure.
1059	* @param fWasHalted Set if we're comming out of a CPU HALT state.
1060	* @param pfFFDone Where to store an indicator telling whether or not
1061	* FFs were done before returning.
1062	*
1063	*/
1064	static VBOXSTRICTRC emR3RecompilerExecute(PVM pVM, PVMCPU pVCpu, bool fWasHalted, bool *pfFFDone)
1065	{
1066	STAM_REL_PROFILE_START(&pVCpu->em.s.StatREMTotal, a);
1067	#ifdef VBOX_VMM_TARGET_ARMV8
1068	LogFlow(("emR3RecompilerExecute/%u: (pc=%RGv)\n", pVCpu->idCpu, (RTGCPTR)pVCpu->cpum.GstCtx.Pc.u64));
1069	#else
1070	LogFlow(("emR3RecompilerExecute/%u: (cs:eip=%04x:%RGv)\n", pVCpu->idCpu, pVCpu->cpum.GstCtx.cs.Sel, (RTGCPTR)pVCpu->cpum.GstCtx.rip));
1071	#endif
1072
1073	/*
1074	* Loop till we get a forced action which returns anything but VINF_SUCCESS.
1075	*/
1076	*pfFFDone = false;
1077	VBOXSTRICTRC rcStrict = VINF_SUCCESS;
1078	for (;;)
1079	{
1080	#ifdef LOG_ENABLED
1081	# if defined(VBOX_VMM_TARGET_ARMV8)
1082	Log3(("EM: pc=%08x\n", CPUMGetGuestFlatPC(pVCpu)));
1083	# else
1084	if (!pVCpu->cpum.GstCtx.eflags.Bits.u1VM)
1085	Log(("EMR%d: %04X:%08RX64 RSP=%08RX64 IF=%d CR0=%x eflags=%x\n", CPUMGetGuestCPL(pVCpu), pVCpu->cpum.GstCtx.cs.Sel,
1086	pVCpu->cpum.GstCtx.rip, pVCpu->cpum.GstCtx.rsp, pVCpu->cpum.GstCtx.eflags.Bits.u1IF,
1087	(uint32_t)pVCpu->cpum.GstCtx.cr0, pVCpu->cpum.GstCtx.eflags.u));
1088	else
1089	Log(("EMV86: %04X:%08X IF=%d\n", pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.eip, pVCpu->cpum.GstCtx.eflags.Bits.u1IF));
1090	# endif
1091	#endif
1092
1093	/*
1094	* Execute.
1095	*/
1096	if (RT_LIKELY(emR3IsExecutionAllowed(pVM, pVCpu)))
1097	{
1098	STAM_PROFILE_START(&pVCpu->em.s.StatREMExec, c);
1099	#ifdef VBOX_WITH_IEM_RECOMPILER
1100	if (pVM->em.s.fIemRecompiled)
1101	rcStrict = IEMExecRecompiler(pVM, pVCpu, fWasHalted);
1102	else
1103	#endif
1104	rcStrict = IEMExecLots(pVCpu, 8192 /cMaxInstructions/, 4095 /cPollRate/, NULL /pcInstructions/);
1105	STAM_PROFILE_STOP(&pVCpu->em.s.StatREMExec, c);
1106	}
1107	else
1108	{
1109	/* Give up this time slice; virtual time continues */
1110	STAM_REL_PROFILE_ADV_START(&pVCpu->em.s.StatCapped, u);
1111	RTThreadSleep(5);
1112	STAM_REL_PROFILE_ADV_STOP(&pVCpu->em.s.StatCapped, u);
1113	rcStrict = VINF_SUCCESS;
1114	}
1115
1116	/*
1117	* Deal with high priority post execution FFs before doing anything
1118	* else. Sync back the state and leave the lock to be on the safe side.
1119	*/
1120	if ( VM_FF_IS_ANY_SET(pVM, VM_FF_HIGH_PRIORITY_POST_MASK)
1121	\|\| VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_HIGH_PRIORITY_POST_MASK))
1122	rcStrict = emR3HighPriorityPostForcedActions(pVM, pVCpu, rcStrict);
1123
1124	/*
1125	* Process the returned status code.
1126	*/
1127	if (rcStrict != VINF_SUCCESS)
1128	{
1129	#ifndef VBOX_VMM_TARGET_ARMV8
1130	if (rcStrict == VINF_EM_EMULATE_SPLIT_LOCK)
1131	rcStrict = emR3ExecuteSplitLockInstruction(pVM, pVCpu);
1132	#endif
1133	if (rcStrict != VINF_SUCCESS)
1134	{
1135	#if 0
1136	if (RT_LIKELY(rcStrict >= VINF_EM_FIRST && rcStrict <= VINF_EM_LAST))
1137	break;
1138	/* Fatal error: */
1139	#endif
1140	break;
1141	}
1142	}
1143
1144
1145	/*
1146	* Check and execute forced actions.
1147	*
1148	* Sync back the VM state and leave the lock before calling any of
1149	* these, you never know what's going to happen here.
1150	*/
1151	#ifdef VBOX_HIGH_RES_TIMERS_HACK
1152	TMTimerPollVoid(pVM, pVCpu);
1153	#endif
1154	AssertCompile(VMCPU_FF_ALL_REM_MASK & VMCPU_FF_TIMER);
1155	if ( VM_FF_IS_ANY_SET(pVM, VM_FF_ALL_REM_MASK)
1156	\|\| VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_ALL_REM_MASK) )
1157	{
1158	rcStrict = emR3ForcedActions(pVM, pVCpu, VBOXSTRICTRC_TODO(rcStrict));
1159	VBOXVMM_EM_FF_ALL_RET(pVCpu, VBOXSTRICTRC_VAL(rcStrict));
1160	if ( rcStrict != VINF_SUCCESS
1161	&& rcStrict != VINF_EM_RESCHEDULE_REM)
1162	{
1163	*pfFFDone = true;
1164	break;
1165	}
1166	}
1167
1168	/*
1169	* Check if we can switch back to the main execution engine now.
1170	*/
1171	#if !defined(VBOX_VMM_TARGET_ARMV8)
1172	if (VM_IS_HM_ENABLED(pVM))
1173	{
1174	if (HMCanExecuteGuest(pVM, pVCpu, &pVCpu->cpum.GstCtx))
1175	{
1176	*pfFFDone = true;
1177	rcStrict = VINF_EM_RESCHEDULE_EXEC_ENGINE;
1178	break;
1179	}
1180	}
1181	else
1182	#endif
1183	if (VM_IS_NEM_ENABLED(pVM))
1184	{
1185	if (NEMR3CanExecuteGuest(pVM, pVCpu))
1186	{
1187	*pfFFDone = true;
1188	rcStrict = VINF_EM_RESCHEDULE_EXEC_ENGINE;
1189	break;
1190	}
1191	}
1192
1193	#ifdef VBOX_WITH_IEM_RECOMPILER
1194	fWasHalted = false;
1195	#else
1196	RT_NOREF(fWasHalted);
1197	#endif
1198	} /* The Inner Loop, recompiled execution mode version. */
1199
1200	STAM_REL_PROFILE_STOP(&pVCpu->em.s.StatREMTotal, a);
1201	return rcStrict;
1202	}
1203
1204
1205	/**
1206	* Decides whether to execute HM, NEM, IEM/interpreter or IEM/recompiler.
1207	*
1208	* @returns new EM state
1209	* @param pVM The cross context VM structure.
1210	* @param pVCpu The cross context virtual CPU structure.
1211	*/
1212	EMSTATE emR3Reschedule(PVM pVM, PVMCPU pVCpu)
1213	{
1214	/*
1215	* We stay in the wait for SIPI state unless explicitly told otherwise.
1216	*/
1217	if (pVCpu->em.s.enmState == EMSTATE_WAIT_SIPI)
1218	return EMSTATE_WAIT_SIPI;
1219
1220	/*
1221	* Execute everything in IEM?
1222	*/
1223	if ( pVM->em.s.fIemExecutesAll
1224	\|\| VM_IS_EXEC_ENGINE_IEM(pVM))
1225	#ifdef VBOX_WITH_IEM_RECOMPILER
1226	return pVM->em.s.fIemRecompiled ? EMSTATE_RECOMPILER : EMSTATE_IEM;
1227	#else
1228	return EMSTATE_IEM;
1229	#endif
1230
1231	#if !defined(VBOX_VMM_TARGET_ARMV8)
1232	if (VM_IS_HM_ENABLED(pVM))
1233	{
1234	if (HMCanExecuteGuest(pVM, pVCpu, &pVCpu->cpum.GstCtx))
1235	return EMSTATE_HM;
1236	}
1237	else
1238	#endif
1239	if (NEMR3CanExecuteGuest(pVM, pVCpu))
1240	return EMSTATE_NEM;
1241
1242	/*
1243	* Note! Raw mode and hw accelerated mode are incompatible. The latter
1244	* turns off monitoring features essential for raw mode!
1245	*/
1246	#ifdef VBOX_WITH_IEM_RECOMPILER
1247	return pVM->em.s.fIemRecompiled ? EMSTATE_RECOMPILER : EMSTATE_IEM;
1248	#else
1249	return EMSTATE_IEM;
1250	#endif
1251	}
1252
1253
1254	/**
1255	* Executes all high priority post execution force actions.
1256	*
1257	* @returns Strict VBox status code. Typically @a rc, but may be upgraded to
1258	* fatal error status code.
1259	*
1260	* @param pVM The cross context VM structure.
1261	* @param pVCpu The cross context virtual CPU structure.
1262	* @param rc The current strict VBox status code rc.
1263	*/
1264	VBOXSTRICTRC emR3HighPriorityPostForcedActions(PVM pVM, PVMCPU pVCpu, VBOXSTRICTRC rc)
1265	{
1266	VBOXVMM_EM_FF_HIGH(pVCpu, pVM->fGlobalForcedActions, pVCpu->fLocalForcedActions, VBOXSTRICTRC_VAL(rc));
1267
1268	if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_PDM_CRITSECT))
1269	PDMCritSectBothFF(pVM, pVCpu);
1270
1271	#if !defined(VBOX_VMM_TARGET_ARMV8)
1272	/* Update CR3 (Nested Paging case for HM). */
1273	if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_HM_UPDATE_CR3))
1274	{
1275	CPUM_IMPORT_EXTRN_RCSTRICT(pVCpu, CPUMCTX_EXTRN_CR0 \| CPUMCTX_EXTRN_CR3 \| CPUMCTX_EXTRN_CR4 \| CPUMCTX_EXTRN_EFER, rc);
1276	int const rc2 = PGMUpdateCR3(pVCpu, CPUMGetGuestCR3(pVCpu));
1277	if (RT_FAILURE(rc2))
1278	return rc2;
1279	Assert(!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_HM_UPDATE_CR3));
1280	}
1281	#endif
1282
1283	/* IEM has pending work (typically memory write after INS instruction). */
1284	if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_IEM))
1285	rc = IEMR3ProcessForceFlag(pVM, pVCpu, rc);
1286
1287	/* IOM has pending work (comitting an I/O or MMIO write). */
1288	if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_IOM))
1289	{
1290	rc = IOMR3ProcessForceFlag(pVM, pVCpu, rc);
1291	if (pVCpu->em.s.idxContinueExitRec >= RT_ELEMENTS(pVCpu->em.s.aExitRecords))
1292	{ /* half likely, or at least it's a line shorter. */ }
1293	else if (rc == VINF_SUCCESS)
1294	rc = VINF_EM_RESUME_R3_HISTORY_EXEC;
1295	else
1296	pVCpu->em.s.idxContinueExitRec = UINT16_MAX;
1297	}
1298
1299	if (VM_FF_IS_SET(pVM, VM_FF_PGM_NO_MEMORY))
1300	{
1301	if ( rc > VINF_EM_NO_MEMORY
1302	&& rc <= VINF_EM_LAST)
1303	rc = VINF_EM_NO_MEMORY;
1304	}
1305
1306	return rc;
1307	}
1308
1309
1310	#if !defined(VBOX_VMM_TARGET_ARMV8)
1311	/**
1312	* Helper for emR3ForcedActions() for VMX external interrupt VM-exit.
1313	*
1314	* @returns VBox status code.
1315	* @retval VINF_NO_CHANGE if the VMX external interrupt intercept was not active.
1316	* @param pVCpu The cross context virtual CPU structure.
1317	*/
1318	static int emR3VmxNstGstIntrIntercept(PVMCPU pVCpu)
1319	{
1320	#ifdef VBOX_WITH_NESTED_HWVIRT_VMX
1321	/* Handle the "external interrupt" VM-exit intercept. */
1322	if ( CPUMIsGuestVmxPinCtlsSet(&pVCpu->cpum.GstCtx, VMX_PIN_CTLS_EXT_INT_EXIT)
1323	&& !CPUMIsGuestVmxExitCtlsSet(&pVCpu->cpum.GstCtx, VMX_EXIT_CTLS_ACK_EXT_INT))
1324	{
1325	VBOXSTRICTRC rcStrict = IEMExecVmxVmexitExtInt(pVCpu, 0 /* uVector /, true / fIntPending */);
1326	AssertMsg( rcStrict != VINF_VMX_VMEXIT /* VM-exit should have been converted to VINF_SUCCESS. */
1327	&& rcStrict != VINF_NO_CHANGE
1328	&& rcStrict != VINF_VMX_INTERCEPT_NOT_ACTIVE, ("%Rrc\n", VBOXSTRICTRC_VAL(rcStrict)));
1329	return VBOXSTRICTRC_VAL(rcStrict);
1330	}
1331	#else
1332	RT_NOREF(pVCpu);
1333	#endif
1334	return VINF_NO_CHANGE;
1335	}
1336
1337
1338	/**
1339	* Helper for emR3ForcedActions() for SVM interrupt intercept.
1340	*
1341	* @returns VBox status code.
1342	* @retval VINF_NO_CHANGE if the SVM external interrupt intercept was not active.
1343	* @param pVCpu The cross context virtual CPU structure.
1344	*/
1345	static int emR3SvmNstGstIntrIntercept(PVMCPU pVCpu)
1346	{
1347	#ifdef VBOX_WITH_NESTED_HWVIRT_SVM
1348	/* Handle the physical interrupt intercept (can be masked by the nested hypervisor). */
1349	if (CPUMIsGuestSvmCtrlInterceptSet(pVCpu, &pVCpu->cpum.GstCtx, SVM_CTRL_INTERCEPT_INTR))
1350	{
1351	CPUM_ASSERT_NOT_EXTRN(pVCpu, IEM_CPUMCTX_EXTRN_SVM_VMEXIT_MASK);
1352	VBOXSTRICTRC rcStrict = IEMExecSvmVmexit(pVCpu, SVM_EXIT_INTR, 0, 0);
1353	if (RT_SUCCESS(rcStrict))
1354	{
1355	AssertMsg( rcStrict != VINF_SVM_VMEXIT
1356	&& rcStrict != VINF_NO_CHANGE, ("%Rrc\n", VBOXSTRICTRC_VAL(rcStrict)));
1357	return VBOXSTRICTRC_VAL(rcStrict);
1358	}
1359
1360	AssertMsgFailed(("INTR #VMEXIT failed! rc=%Rrc\n", VBOXSTRICTRC_VAL(rcStrict)));
1361	return VINF_EM_TRIPLE_FAULT;
1362	}
1363	#else
1364	NOREF(pVCpu);
1365	#endif
1366	return VINF_NO_CHANGE;
1367	}
1368
1369
1370	/**
1371	* Helper for emR3ForcedActions() for SVM virtual interrupt intercept.
1372	*
1373	* @returns VBox status code.
1374	* @retval VINF_NO_CHANGE if the SVM virtual interrupt intercept was not active.
1375	* @param pVCpu The cross context virtual CPU structure.
1376	*/
1377	static int emR3SvmNstGstVirtIntrIntercept(PVMCPU pVCpu)
1378	{
1379	#ifdef VBOX_WITH_NESTED_HWVIRT_SVM
1380	if (CPUMIsGuestSvmCtrlInterceptSet(pVCpu, &pVCpu->cpum.GstCtx, SVM_CTRL_INTERCEPT_VINTR))
1381	{
1382	CPUM_ASSERT_NOT_EXTRN(pVCpu, IEM_CPUMCTX_EXTRN_SVM_VMEXIT_MASK);
1383	VBOXSTRICTRC rcStrict = IEMExecSvmVmexit(pVCpu, SVM_EXIT_VINTR, 0, 0);
1384	if (RT_SUCCESS(rcStrict))
1385	{
1386	Assert(rcStrict != VINF_SVM_VMEXIT);
1387	return VBOXSTRICTRC_VAL(rcStrict);
1388	}
1389	AssertMsgFailed(("VINTR #VMEXIT failed! rc=%Rrc\n", VBOXSTRICTRC_VAL(rcStrict)));
1390	return VINF_EM_TRIPLE_FAULT;
1391	}
1392	#else
1393	NOREF(pVCpu);
1394	#endif
1395	return VINF_NO_CHANGE;
1396	}
1397	#endif
1398
1399
1400	/**
1401	* Executes all pending forced actions.
1402	*
1403	* Forced actions can cause execution delays and execution
1404	* rescheduling. The first we deal with using action priority, so
1405	* that for instance pending timers aren't scheduled and ran until
1406	* right before execution. The rescheduling we deal with using
1407	* return codes. The same goes for VM termination, only in that case
1408	* we exit everything.
1409	*
1410	* @returns VBox status code of equal or greater importance/severity than rc.
1411	* The most important ones are: VINF_EM_RESCHEDULE,
1412	* VINF_EM_SUSPEND, VINF_EM_RESET and VINF_EM_TERMINATE.
1413	*
1414	* @param pVM The cross context VM structure.
1415	* @param pVCpu The cross context virtual CPU structure.
1416	* @param rc The current rc.
1417	*
1418	*/
1419	int emR3ForcedActions(PVM pVM, PVMCPU pVCpu, int rc)
1420	{
1421	STAM_REL_PROFILE_START(&pVCpu->em.s.StatForcedActions, a);
1422	#ifdef VBOX_STRICT
1423	int rcIrq = VINF_SUCCESS;
1424	#endif
1425	int rc2;
1426	#define UPDATE_RC() \
1427	do { \
1428	AssertMsg(rc2 <= 0 \|\| (rc2 >= VINF_EM_FIRST && rc2 <= VINF_EM_LAST), ("Invalid FF return code: %Rra\n", rc2)); \
1429	if (rc2 == VINF_SUCCESS \|\| rc < VINF_SUCCESS) \
1430	break; \
1431	if (!rc \|\| rc2 < rc) \
1432	rc = rc2; \
1433	} while (0)
1434	VBOXVMM_EM_FF_ALL(pVCpu, pVM->fGlobalForcedActions, pVCpu->fLocalForcedActions, rc);
1435
1436	/*
1437	* Post execution chunk first.
1438	*/
1439	if ( VM_FF_IS_ANY_SET(pVM, VM_FF_NORMAL_PRIORITY_POST_MASK)
1440	\|\| (VMCPU_FF_NORMAL_PRIORITY_POST_MASK && VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_NORMAL_PRIORITY_POST_MASK)) )
1441	{
1442	/*
1443	* EMT Rendezvous (must be serviced before termination).
1444	*/
1445	if (VM_FF_IS_SET(pVM, VM_FF_EMT_RENDEZVOUS))
1446	{
1447	CPUM_IMPORT_EXTRN_RCSTRICT(pVCpu, ~CPUMCTX_EXTRN_KEEPER_MASK, rc);
1448	rc2 = VMMR3EmtRendezvousFF(pVM, pVCpu);
1449	UPDATE_RC();
1450	/** @todo HACK ALERT! The following test is to make sure EM+TM
1451	* thinks the VM is stopped/reset before the next VM state change
1452	* is made. We need a better solution for this, or at least make it
1453	* possible to do: (rc >= VINF_EM_FIRST && rc <=
1454	* VINF_EM_SUSPEND). */
1455	if (RT_UNLIKELY(rc == VINF_EM_SUSPEND \|\| rc == VINF_EM_RESET \|\| rc == VINF_EM_OFF))
1456	{
1457	Log2(("emR3ForcedActions: returns %Rrc\n", rc));
1458	STAM_REL_PROFILE_STOP(&pVCpu->em.s.StatForcedActions, a);
1459	return rc;
1460	}
1461	}
1462
1463	/*
1464	* State change request (cleared by vmR3SetStateLocked).
1465	*/
1466	if (VM_FF_IS_SET(pVM, VM_FF_CHECK_VM_STATE))
1467	{
1468	VMSTATE enmState = VMR3GetState(pVM);
1469	switch (enmState)
1470	{
1471	case VMSTATE_FATAL_ERROR:
1472	case VMSTATE_FATAL_ERROR_LS:
1473	case VMSTATE_GURU_MEDITATION:
1474	case VMSTATE_GURU_MEDITATION_LS:
1475	Log2(("emR3ForcedActions: %s -> VINF_EM_SUSPEND\n", VMGetStateName(enmState) ));
1476	STAM_REL_PROFILE_STOP(&pVCpu->em.s.StatForcedActions, a);
1477	return VINF_EM_SUSPEND;
1478
1479	case VMSTATE_DESTROYING:
1480	Log2(("emR3ForcedActions: %s -> VINF_EM_TERMINATE\n", VMGetStateName(enmState) ));
1481	STAM_REL_PROFILE_STOP(&pVCpu->em.s.StatForcedActions, a);
1482	return VINF_EM_TERMINATE;
1483
1484	default:
1485	AssertMsgFailed(("%s\n", VMGetStateName(enmState)));
1486	}
1487	}
1488
1489	/*
1490	* Debugger Facility polling.
1491	*/
1492	if ( VM_FF_IS_SET(pVM, VM_FF_DBGF)
1493	\|\| VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_DBGF) )
1494	{
1495	CPUM_IMPORT_EXTRN_RCSTRICT(pVCpu, ~CPUMCTX_EXTRN_KEEPER_MASK, rc);
1496	rc2 = DBGFR3VMMForcedAction(pVM, pVCpu);
1497	/** @todo why that VINF_EM_DBG_EVENT here? Duplicate info, should be handled
1498	* somewhere before we get here, I would think. */
1499	if (rc == VINF_EM_DBG_EVENT) /* HACK! We should've handled pending debug event. */
1500	rc = rc2;
1501	else
1502	UPDATE_RC();
1503	}
1504
1505	/*
1506	* Postponed reset request.
1507	*/
1508	if (VM_FF_TEST_AND_CLEAR(pVM, VM_FF_RESET))
1509	{
1510	CPUM_IMPORT_EXTRN_RCSTRICT(pVCpu, ~CPUMCTX_EXTRN_KEEPER_MASK, rc);
1511	rc2 = VBOXSTRICTRC_TODO(VMR3ResetFF(pVM));
1512	UPDATE_RC();
1513	}
1514
1515	/*
1516	* Out of memory? Putting this after CSAM as it may in theory cause us to run out of memory.
1517	*/
1518	if (VM_FF_IS_SET(pVM, VM_FF_PGM_NO_MEMORY))
1519	{
1520	rc2 = PGMR3PhysAllocateHandyPages(pVM);
1521	UPDATE_RC();
1522	if (rc == VINF_EM_NO_MEMORY)
1523	return rc;
1524	}
1525
1526	/* check that we got them all */
1527	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));
1528	AssertCompile(VMCPU_FF_NORMAL_PRIORITY_POST_MASK == VMCPU_FF_DBGF);
1529	}
1530
1531	/*
1532	* Normal priority then.
1533	* (Executed in no particular order.)
1534	*/
1535	if (VM_FF_IS_PENDING_EXCEPT(pVM, VM_FF_NORMAL_PRIORITY_MASK, VM_FF_PGM_NO_MEMORY))
1536	{
1537	/*
1538	* PDM Queues are pending.
1539	*/
1540	if (VM_FF_IS_PENDING_EXCEPT(pVM, VM_FF_PDM_QUEUES, VM_FF_PGM_NO_MEMORY))
1541	PDMR3QueueFlushAll(pVM);
1542
1543	/*
1544	* PDM DMA transfers are pending.
1545	*/
1546	if (VM_FF_IS_PENDING_EXCEPT(pVM, VM_FF_PDM_DMA, VM_FF_PGM_NO_MEMORY))
1547	PDMR3DmaRun(pVM);
1548
1549	/*
1550	* EMT Rendezvous (make sure they are handled before the requests).
1551	*/
1552	if (VM_FF_IS_SET(pVM, VM_FF_EMT_RENDEZVOUS))
1553	{
1554	CPUM_IMPORT_EXTRN_RCSTRICT(pVCpu, ~CPUMCTX_EXTRN_KEEPER_MASK, rc);
1555	rc2 = VMMR3EmtRendezvousFF(pVM, pVCpu);
1556	UPDATE_RC();
1557	/** @todo HACK ALERT! The following test is to make sure EM+TM
1558	* thinks the VM is stopped/reset before the next VM state change
1559	* is made. We need a better solution for this, or at least make it
1560	* possible to do: (rc >= VINF_EM_FIRST && rc <=
1561	* VINF_EM_SUSPEND). */
1562	if (RT_UNLIKELY(rc == VINF_EM_SUSPEND \|\| rc == VINF_EM_RESET \|\| rc == VINF_EM_OFF))
1563	{
1564	Log2(("emR3ForcedActions: returns %Rrc\n", rc));
1565	STAM_REL_PROFILE_STOP(&pVCpu->em.s.StatForcedActions, a);
1566	return rc;
1567	}
1568	}
1569
1570	/*
1571	* Requests from other threads.
1572	*/
1573	if (VM_FF_IS_PENDING_EXCEPT(pVM, VM_FF_REQUEST, VM_FF_PGM_NO_MEMORY))
1574	{
1575	CPUM_IMPORT_EXTRN_RCSTRICT(pVCpu, ~CPUMCTX_EXTRN_KEEPER_MASK, rc);
1576	rc2 = VMR3ReqProcessU(pVM->pUVM, VMCPUID_ANY, false /fPriorityOnly/);
1577	if (rc2 == VINF_EM_OFF \|\| rc2 == VINF_EM_TERMINATE) /** @todo this shouldn't be necessary */
1578	{
1579	Log2(("emR3ForcedActions: returns %Rrc\n", rc2));
1580	STAM_REL_PROFILE_STOP(&pVCpu->em.s.StatForcedActions, a);
1581	return rc2;
1582	}
1583	UPDATE_RC();
1584	/** @todo HACK ALERT! The following test is to make sure EM+TM
1585	* thinks the VM is stopped/reset before the next VM state change
1586	* is made. We need a better solution for this, or at least make it
1587	* possible to do: (rc >= VINF_EM_FIRST && rc <=
1588	* VINF_EM_SUSPEND). */
1589	if (RT_UNLIKELY(rc == VINF_EM_SUSPEND \|\| rc == VINF_EM_RESET \|\| rc == VINF_EM_OFF))
1590	{
1591	Log2(("emR3ForcedActions: returns %Rrc\n", rc));
1592	STAM_REL_PROFILE_STOP(&pVCpu->em.s.StatForcedActions, a);
1593	return rc;
1594	}
1595	}
1596
1597	/* check that we got them all */
1598	AssertCompile(VM_FF_NORMAL_PRIORITY_MASK == (VM_FF_REQUEST \| VM_FF_PDM_QUEUES \| VM_FF_PDM_DMA \| VM_FF_EMT_RENDEZVOUS));
1599	}
1600
1601	/*
1602	* Normal priority then. (per-VCPU)
1603	* (Executed in no particular order.)
1604	*/
1605	if ( !VM_FF_IS_SET(pVM, VM_FF_PGM_NO_MEMORY)
1606	&& VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_NORMAL_PRIORITY_MASK))
1607	{
1608	/*
1609	* Requests from other threads.
1610	*/
1611	if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_REQUEST))
1612	{
1613	CPUM_IMPORT_EXTRN_RCSTRICT(pVCpu, ~CPUMCTX_EXTRN_KEEPER_MASK, rc);
1614	rc2 = VMR3ReqProcessU(pVM->pUVM, pVCpu->idCpu, false /fPriorityOnly/);
1615	if (rc2 == VINF_EM_OFF \|\| rc2 == VINF_EM_TERMINATE \|\| rc2 == VINF_EM_RESET)
1616	{
1617	Log2(("emR3ForcedActions: returns %Rrc\n", rc2));
1618	STAM_REL_PROFILE_STOP(&pVCpu->em.s.StatForcedActions, a);
1619	return rc2;
1620	}
1621	UPDATE_RC();
1622	/** @todo HACK ALERT! The following test is to make sure EM+TM
1623	* thinks the VM is stopped/reset before the next VM state change
1624	* is made. We need a better solution for this, or at least make it
1625	* possible to do: (rc >= VINF_EM_FIRST && rc <=
1626	* VINF_EM_SUSPEND). */
1627	if (RT_UNLIKELY(rc == VINF_EM_SUSPEND \|\| rc == VINF_EM_RESET \|\| rc == VINF_EM_OFF))
1628	{
1629	Log2(("emR3ForcedActions: returns %Rrc\n", rc));
1630	STAM_REL_PROFILE_STOP(&pVCpu->em.s.StatForcedActions, a);
1631	return rc;
1632	}
1633	}
1634
1635	/* check that we got them all */
1636	Assert(!(VMCPU_FF_NORMAL_PRIORITY_MASK & ~VMCPU_FF_REQUEST));
1637	}
1638
1639	/*
1640	* High priority pre execution chunk last.
1641	* (Executed in ascending priority order.)
1642	*/
1643	if ( VM_FF_IS_ANY_SET(pVM, VM_FF_HIGH_PRIORITY_PRE_MASK)
1644	\|\| VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_HIGH_PRIORITY_PRE_MASK))
1645	{
1646	/*
1647	* Timers before interrupts.
1648	*/
1649	if ( VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_TIMER)
1650	&& !VM_FF_IS_SET(pVM, VM_FF_PGM_NO_MEMORY))
1651	TMR3TimerQueuesDo(pVM);
1652
1653	#if !defined(VBOX_VMM_TARGET_ARMV8)
1654	/*
1655	* Pick up asynchronously posted interrupts into the APIC.
1656	*/
1657	if (VMCPU_FF_TEST_AND_CLEAR(pVCpu, VMCPU_FF_UPDATE_APIC))
1658	APICUpdatePendingInterrupts(pVCpu);
1659
1660	/*
1661	* The instruction following an emulated STI should always be executed!
1662	*
1663	* Note! We intentionally don't clear CPUMCTX_INHIBIT_INT here if
1664	* the eip is the same as the inhibited instr address. Before we
1665	* are able to execute this instruction in raw mode (iret to
1666	* guest code) an external interrupt might force a world switch
1667	* again. Possibly allowing a guest interrupt to be dispatched
1668	* in the process. This could break the guest. Sounds very
1669	* unlikely, but such timing sensitive problem are not as rare as
1670	* you might think.
1671	*
1672	* Note! This used to be a force action flag. Can probably ditch this code.
1673	*/
1674	/** @todo r=bird: the clearing case will never be taken here as
1675	* CPUMIsInInterruptShadow already makes sure the RIPs matches. */
1676	if ( CPUMIsInInterruptShadow(&pVCpu->cpum.GstCtx)
1677	&& !VM_FF_IS_SET(pVM, VM_FF_PGM_NO_MEMORY))
1678	{
1679	CPUM_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_RIP \| CPUMCTX_EXTRN_INHIBIT_INT);
1680	if (CPUMGetGuestRIP(pVCpu) != pVCpu->cpum.GstCtx.uRipInhibitInt)
1681	{
1682	CPUMClearInterruptShadow(&pVCpu->cpum.GstCtx);
1683	Log(("Clearing CPUMCTX_INHIBIT_INT at %RGv - successor %RGv\n",
1684	(RTGCPTR)CPUMGetGuestRIP(pVCpu), (RTGCPTR)pVCpu->cpum.GstCtx.uRipInhibitInt));
1685	}
1686	else
1687	Log(("Leaving CPUMCTX_INHIBIT_INT set at %RGv\n", (RTGCPTR)CPUMGetGuestRIP(pVCpu)));
1688	}
1689
1690	/** @todo SMIs. If we implement SMIs, this is where they will have to be
1691	* delivered. */
1692
1693	# ifdef VBOX_WITH_NESTED_HWVIRT_VMX
1694	if (VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_VMX_APIC_WRITE \| VMCPU_FF_VMX_MTF \| VMCPU_FF_VMX_PREEMPT_TIMER
1695	\| VMCPU_FF_VMX_NMI_WINDOW \| VMCPU_FF_VMX_INT_WINDOW))
1696	{
1697	/*
1698	* VMX Nested-guest APIC-write pending (can cause VM-exits).
1699	* Takes priority over even SMI and INIT signals.
1700	* See Intel spec. 29.4.3.2 "APIC-Write Emulation".
1701	*/
1702	if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_VMX_APIC_WRITE))
1703	{
1704	rc2 = VBOXSTRICTRC_VAL(IEMExecVmxVmexitApicWrite(pVCpu));
1705	if (rc2 != VINF_VMX_INTERCEPT_NOT_ACTIVE)
1706	UPDATE_RC();
1707	}
1708
1709	/*
1710	* APIC write emulation MAY have a caused a VM-exit.
1711	* If it did cause a VM-exit, there's no point checking the other VMX non-root mode FFs here.
1712	*/
1713	if (CPUMIsGuestInVmxNonRootMode(&pVCpu->cpum.GstCtx))
1714	{
1715	/*
1716	* VMX Nested-guest monitor-trap flag (MTF) VM-exit.
1717	* Takes priority over "Traps on the previous instruction".
1718	* See Intel spec. 6.9 "Priority Among Simultaneous Exceptions And Interrupts".
1719	*/
1720	if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_VMX_MTF))
1721	{
1722	rc2 = VBOXSTRICTRC_VAL(IEMExecVmxVmexit(pVCpu, VMX_EXIT_MTF, 0 /* uExitQual */));
1723	Assert(rc2 != VINF_VMX_INTERCEPT_NOT_ACTIVE);
1724	UPDATE_RC();
1725	}
1726	/*
1727	* VMX Nested-guest preemption timer VM-exit.
1728	* Takes priority over NMI-window VM-exits.
1729	*/
1730	else if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_VMX_PREEMPT_TIMER))
1731	{
1732	rc2 = VBOXSTRICTRC_VAL(IEMExecVmxVmexitPreemptTimer(pVCpu));
1733	Assert(rc2 != VINF_VMX_INTERCEPT_NOT_ACTIVE);
1734	UPDATE_RC();
1735	}
1736	/*
1737	* VMX interrupt-window and NMI-window VM-exits.
1738	* Takes priority over non-maskable interrupts (NMIs) and external interrupts respectively.
1739	* If we are in an interrupt shadow or if we already in the process of delivering
1740	* an event then these VM-exits cannot occur.
1741	*
1742	* Interrupt shadows block NMI-window VM-exits.
1743	* Any event that is already in TRPM (e.g. injected during VM-entry) takes priority.
1744	*
1745	* See Intel spec. 25.2 "Other Causes Of VM Exits".
1746	* See Intel spec. 26.7.6 "NMI-Window Exiting".
1747	* See Intel spec. 6.7 "Nonmaskable Interrupt (NMI)".
1748	*/
1749	else if ( !CPUMIsInInterruptShadow(&pVCpu->cpum.GstCtx)
1750	&& !CPUMAreInterruptsInhibitedByNmi(&pVCpu->cpum.GstCtx)
1751	&& !TRPMHasTrap(pVCpu))
1752	{
1753	/*
1754	* VMX NMI-window VM-exit.
1755	*/
1756	if ( VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_VMX_NMI_WINDOW)
1757	&& !CPUMIsGuestVmxVirtNmiBlocking(&pVCpu->cpum.GstCtx))
1758	{
1759	Assert(CPUMIsGuestVmxProcCtlsSet(&pVCpu->cpum.GstCtx, VMX_PROC_CTLS_NMI_WINDOW_EXIT));
1760	Assert(CPUMIsGuestVmxInterceptEvents(&pVCpu->cpum.GstCtx));
1761	rc2 = VBOXSTRICTRC_VAL(IEMExecVmxVmexit(pVCpu, VMX_EXIT_NMI_WINDOW, 0 /* uExitQual */));
1762	AssertMsg( rc2 != VINF_VMX_INTERCEPT_NOT_ACTIVE
1763	&& rc2 != VINF_VMX_VMEXIT
1764	&& rc2 != VINF_NO_CHANGE, ("%Rrc\n", rc2));
1765	UPDATE_RC();
1766	}
1767	/*
1768	* VMX interrupt-window VM-exit.
1769	* This is a bit messy with the way the code below is currently structured,
1770	* but checking VMCPU_FF_INTERRUPT_NMI here (combined with CPUMAreInterruptsInhibitedByNmi
1771	* already checked at this point) should allow a pending NMI to be delivered prior to
1772	* causing an interrupt-window VM-exit.
1773	*/
1774	/** @todo Restructure this later to happen after injecting NMI/causing NMI-exit, see
1775	* code in VMX R0 event delivery. */
1776	else if ( VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_VMX_INT_WINDOW)
1777	&& !VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INTERRUPT_NMI)
1778	&& CPUMIsGuestVmxVirtIntrEnabled(&pVCpu->cpum.GstCtx))
1779	{
1780	Assert(CPUMIsGuestVmxProcCtlsSet(&pVCpu->cpum.GstCtx, VMX_PROC_CTLS_INT_WINDOW_EXIT));
1781	Assert(CPUMIsGuestVmxInterceptEvents(&pVCpu->cpum.GstCtx));
1782	rc2 = VBOXSTRICTRC_VAL(IEMExecVmxVmexit(pVCpu, VMX_EXIT_INT_WINDOW, 0 /* uExitQual */));
1783	AssertMsg( rc2 != VINF_VMX_INTERCEPT_NOT_ACTIVE
1784	&& rc2 != VINF_VMX_VMEXIT
1785	&& rc2 != VINF_NO_CHANGE, ("%Rrc\n", rc2));
1786	UPDATE_RC();
1787	}
1788	}
1789	}
1790
1791	/*
1792	* Interrupt-window and NMI-window force flags might still be pending if we didn't actually cause
1793	* a VM-exit above. They will get cleared eventually when ANY nested-guest VM-exit occurs.
1794	* However, the force flags asserted below MUST have been cleared at this point.
1795	*/
1796	Assert(!VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_VMX_APIC_WRITE \| VMCPU_FF_VMX_MTF \| VMCPU_FF_VMX_PREEMPT_TIMER));
1797	}
1798	# endif
1799
1800	/*
1801	* Guest event injection.
1802	*/
1803	Assert(!(pVCpu->cpum.GstCtx.fExtrn & (CPUMCTX_EXTRN_INHIBIT_INT \| CPUMCTX_EXTRN_INHIBIT_NMI)));
1804	bool fWakeupPending = false;
1805	if ( VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_VMX_NMI_WINDOW \| VMCPU_FF_VMX_INT_WINDOW
1806	\| VMCPU_FF_INTERRUPT_NMI \| VMCPU_FF_INTERRUPT_NESTED_GUEST
1807	\| VMCPU_FF_INTERRUPT_APIC \| VMCPU_FF_INTERRUPT_PIC)
1808	&& !VM_FF_IS_SET(pVM, VM_FF_PGM_NO_MEMORY)
1809	&& (!rc \|\| rc >= VINF_EM_RESCHEDULE_EXEC_ENGINE)
1810	&& !CPUMIsInInterruptShadow(&pVCpu->cpum.GstCtx) /* Interrupt shadows block both NMIs and interrupts. */
1811	&& !TRPMHasTrap(pVCpu)) /* An event could already be scheduled for dispatching. */
1812	{
1813	if (CPUMGetGuestGif(&pVCpu->cpum.GstCtx))
1814	{
1815	bool fInVmxNonRootMode;
1816	bool fInSvmHwvirtMode;
1817	if (!CPUMIsGuestInNestedHwvirtMode(&pVCpu->cpum.GstCtx))
1818	{
1819	fInVmxNonRootMode = false;
1820	fInSvmHwvirtMode = false;
1821	}
1822	else
1823	{
1824	fInVmxNonRootMode = CPUMIsGuestInVmxNonRootMode(&pVCpu->cpum.GstCtx);
1825	fInSvmHwvirtMode = CPUMIsGuestInSvmNestedHwVirtMode(&pVCpu->cpum.GstCtx);
1826	}
1827
1828	/*
1829	* NMIs (take priority over external interrupts).
1830	*/
1831	if ( VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INTERRUPT_NMI)
1832	&& !CPUMAreInterruptsInhibitedByNmi(&pVCpu->cpum.GstCtx))
1833	{
1834	# ifdef VBOX_WITH_NESTED_HWVIRT_VMX
1835	if ( fInVmxNonRootMode
1836	&& CPUMIsGuestVmxPinCtlsSet(&pVCpu->cpum.GstCtx, VMX_PIN_CTLS_NMI_EXIT))
1837	{
1838	/* We MUST clear the NMI force-flag here, see @bugref{10318#c19}. */
1839	VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INTERRUPT_NMI);
1840	rc2 = VBOXSTRICTRC_VAL(IEMExecVmxVmexitXcptNmi(pVCpu));
1841	Assert(rc2 != VINF_VMX_INTERCEPT_NOT_ACTIVE);
1842	UPDATE_RC();
1843	}
1844	else
1845	# endif
1846	# ifdef VBOX_WITH_NESTED_HWVIRT_SVM
1847	if ( fInSvmHwvirtMode
1848	&& CPUMIsGuestSvmCtrlInterceptSet(pVCpu, &pVCpu->cpum.GstCtx, SVM_CTRL_INTERCEPT_NMI))
1849	{
1850	rc2 = VBOXSTRICTRC_VAL(IEMExecSvmVmexit(pVCpu, SVM_EXIT_NMI, 0 /* uExitInfo1 /, 0 / uExitInfo2 */));
1851	AssertMsg( rc2 != VINF_SVM_VMEXIT
1852	&& rc2 != VINF_NO_CHANGE, ("%Rrc\n", rc2));
1853	UPDATE_RC();
1854	}
1855	else
1856	# endif
1857	{
1858	rc2 = TRPMAssertTrap(pVCpu, X86_XCPT_NMI, TRPM_NMI);
1859	if (rc2 == VINF_SUCCESS)
1860	{
1861	VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INTERRUPT_NMI);
1862	fWakeupPending = true;
1863	# if 0 /* HMR3IsActive is not reliable (esp. after restore), just return VINF_EM_RESCHEDULE. */
1864	if (pVM->em.s.fIemExecutesAll)
1865	rc2 = VINF_EM_RESCHEDULE;
1866	else
1867	{
1868	rc2 = HMR3IsActive(pVCpu) ? VINF_EM_RESCHEDULE_HM
1869	: VM_IS_NEM_ENABLED(pVM) ? VINF_EM_RESCHEDULE
1870	: VINF_EM_RESCHEDULE_REM;
1871	}
1872	# else
1873	rc2 = VINF_EM_RESCHEDULE;
1874	# endif
1875	}
1876	UPDATE_RC();
1877	}
1878	}
1879	# ifdef VBOX_WITH_NESTED_HWVIRT_SVM
1880	/** @todo NSTSVM: Handle this for SVM here too later not when an interrupt is
1881	* actually pending like we currently do. */
1882	# endif
1883	/*
1884	* External interrupts.
1885	*/
1886	else
1887	{
1888	/*
1889	* VMX: virtual interrupts takes priority over physical interrupts.
1890	* SVM: physical interrupts takes priority over virtual interrupts.
1891	*/
1892	if ( fInVmxNonRootMode
1893	&& VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INTERRUPT_NESTED_GUEST)
1894	&& CPUMIsGuestVmxVirtIntrEnabled(&pVCpu->cpum.GstCtx))
1895	{
1896	/** @todo NSTVMX: virtual-interrupt delivery. */
1897	rc2 = VINF_SUCCESS;
1898	}
1899	else if ( VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_INTERRUPT_APIC \| VMCPU_FF_INTERRUPT_PIC)
1900	&& CPUMIsGuestPhysIntrEnabled(pVCpu))
1901	{
1902	Assert(pVCpu->em.s.enmState != EMSTATE_WAIT_SIPI);
1903	if (fInVmxNonRootMode)
1904	rc2 = emR3VmxNstGstIntrIntercept(pVCpu);
1905	else if (fInSvmHwvirtMode)
1906	rc2 = emR3SvmNstGstIntrIntercept(pVCpu);
1907	else
1908	rc2 = VINF_NO_CHANGE;
1909
1910	if (rc2 == VINF_NO_CHANGE)
1911	{
1912	bool fInjected = false;
1913	CPUM_IMPORT_EXTRN_RET(pVCpu, IEM_CPUMCTX_EXTRN_XCPT_MASK);
1914	/** @todo this really isn't nice, should properly handle this */
1915	/* Note! This can still cause a VM-exit (on Intel). */
1916	LogFlow(("Calling TRPMR3InjectEvent: %04x:%08RX64 efl=%#x\n",
1917	pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip, pVCpu->cpum.GstCtx.eflags));
1918	rc2 = TRPMR3InjectEvent(pVM, pVCpu, TRPM_HARDWARE_INT, &fInjected);
1919	fWakeupPending = true;
1920	if ( pVM->em.s.fIemExecutesAll
1921	&& ( rc2 == VINF_EM_RESCHEDULE_REM
1922	\|\| rc2 == VINF_EM_RESCHEDULE_EXEC_ENGINE))
1923	rc2 = VINF_EM_RESCHEDULE;
1924	# ifdef VBOX_STRICT
1925	if (fInjected)
1926	rcIrq = rc2;
1927	# endif
1928	}
1929	UPDATE_RC();
1930	}
1931	else if ( fInSvmHwvirtMode
1932	&& VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INTERRUPT_NESTED_GUEST)
1933	&& CPUMIsGuestSvmVirtIntrEnabled(pVCpu, &pVCpu->cpum.GstCtx))
1934	{
1935	rc2 = emR3SvmNstGstVirtIntrIntercept(pVCpu);
1936	if (rc2 == VINF_NO_CHANGE)
1937	{
1938	VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INTERRUPT_NESTED_GUEST);
1939	uint8_t const uNstGstVector = CPUMGetGuestSvmVirtIntrVector(&pVCpu->cpum.GstCtx);
1940	AssertMsg(uNstGstVector > 0 && uNstGstVector <= X86_XCPT_LAST, ("Invalid VINTR %#x\n", uNstGstVector));
1941	TRPMAssertTrap(pVCpu, uNstGstVector, TRPM_HARDWARE_INT);
1942	Log(("EM: Asserting nested-guest virt. hardware intr: %#x\n", uNstGstVector));
1943	rc2 = VINF_EM_RESCHEDULE;
1944	# ifdef VBOX_STRICT
1945	rcIrq = rc2;
1946	# endif
1947	}
1948	UPDATE_RC();
1949	}
1950	}
1951	} /* CPUMGetGuestGif */
1952	}
1953
1954	#else /* VBOX_VMM_TARGET_ARMV8 */
1955	bool fWakeupPending = false;
1956
1957	if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_VTIMER_ACTIVATED))
1958	{
1959	VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_VTIMER_ACTIVATED);
1960
1961	fWakeupPending = true;
1962	rc2 = VINF_EM_RESCHEDULE;
1963	UPDATE_RC();
1964	}
1965	#endif /* VBOX_VMM_TARGET_ARMV8 */
1966
1967	/*
1968	* Allocate handy pages.
1969	*/
1970	if (VM_FF_IS_PENDING_EXCEPT(pVM, VM_FF_PGM_NEED_HANDY_PAGES, VM_FF_PGM_NO_MEMORY))
1971	{
1972	rc2 = PGMR3PhysAllocateHandyPages(pVM);
1973	UPDATE_RC();
1974	}
1975
1976	/*
1977	* Debugger Facility request.
1978	*/
1979	if ( ( VM_FF_IS_SET(pVM, VM_FF_DBGF)
1980	\|\| VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_DBGF) )
1981	&& !VM_FF_IS_SET(pVM, VM_FF_PGM_NO_MEMORY) )
1982	{
1983	CPUM_IMPORT_EXTRN_RCSTRICT(pVCpu, ~CPUMCTX_EXTRN_KEEPER_MASK, rc);
1984	rc2 = DBGFR3VMMForcedAction(pVM, pVCpu);
1985	UPDATE_RC();
1986	}
1987
1988	/*
1989	* EMT Rendezvous (must be serviced before termination).
1990	*/
1991	if ( !fWakeupPending /* don't miss the wakeup from EMSTATE_HALTED! */
1992	&& VM_FF_IS_SET(pVM, VM_FF_EMT_RENDEZVOUS))
1993	{
1994	CPUM_IMPORT_EXTRN_RCSTRICT(pVCpu, ~CPUMCTX_EXTRN_KEEPER_MASK, rc);
1995	rc2 = VMMR3EmtRendezvousFF(pVM, pVCpu);
1996	UPDATE_RC();
1997	/** @todo HACK ALERT! The following test is to make sure EM+TM thinks the VM is
1998	* stopped/reset before the next VM state change is made. We need a better
1999	* solution for this, or at least make it possible to do: (rc >= VINF_EM_FIRST
2000	* && rc >= VINF_EM_SUSPEND). */
2001	if (RT_UNLIKELY(rc == VINF_EM_SUSPEND \|\| rc == VINF_EM_RESET \|\| rc == VINF_EM_OFF))
2002	{
2003	Log2(("emR3ForcedActions: returns %Rrc\n", rc));
2004	STAM_REL_PROFILE_STOP(&pVCpu->em.s.StatForcedActions, a);
2005	return rc;
2006	}
2007	}
2008
2009	/*
2010	* State change request (cleared by vmR3SetStateLocked).
2011	*/
2012	if ( !fWakeupPending /* don't miss the wakeup from EMSTATE_HALTED! */
2013	&& VM_FF_IS_SET(pVM, VM_FF_CHECK_VM_STATE))
2014	{
2015	VMSTATE enmState = VMR3GetState(pVM);
2016	switch (enmState)
2017	{
2018	case VMSTATE_FATAL_ERROR:
2019	case VMSTATE_FATAL_ERROR_LS:
2020	case VMSTATE_GURU_MEDITATION:
2021	case VMSTATE_GURU_MEDITATION_LS:
2022	Log2(("emR3ForcedActions: %s -> VINF_EM_SUSPEND\n", VMGetStateName(enmState) ));
2023	STAM_REL_PROFILE_STOP(&pVCpu->em.s.StatForcedActions, a);
2024	return VINF_EM_SUSPEND;
2025
2026	case VMSTATE_DESTROYING:
2027	Log2(("emR3ForcedActions: %s -> VINF_EM_TERMINATE\n", VMGetStateName(enmState) ));
2028	STAM_REL_PROFILE_STOP(&pVCpu->em.s.StatForcedActions, a);
2029	return VINF_EM_TERMINATE;
2030
2031	default:
2032	AssertMsgFailed(("%s\n", VMGetStateName(enmState)));
2033	}
2034	}
2035
2036	/*
2037	* Out of memory? Since most of our fellow high priority actions may cause us
2038	* to run out of memory, we're employing VM_FF_IS_PENDING_EXCEPT and putting this
2039	* at the end rather than the start. Also, VM_FF_TERMINATE has higher priority
2040	* than us since we can terminate without allocating more memory.
2041	*/
2042	if (VM_FF_IS_SET(pVM, VM_FF_PGM_NO_MEMORY))
2043	{
2044	rc2 = PGMR3PhysAllocateHandyPages(pVM);
2045	UPDATE_RC();
2046	if (rc == VINF_EM_NO_MEMORY)
2047	return rc;
2048	}
2049
2050	/*
2051	* If the virtual sync clock is still stopped, make TM restart it.
2052	*/
2053	if (VM_FF_IS_SET(pVM, VM_FF_TM_VIRTUAL_SYNC))
2054	TMR3VirtualSyncFF(pVM, pVCpu);
2055
2056	#ifdef DEBUG
2057	/*
2058	* Debug, pause the VM.
2059	*/
2060	if (VM_FF_IS_SET(pVM, VM_FF_DEBUG_SUSPEND))
2061	{
2062	VM_FF_CLEAR(pVM, VM_FF_DEBUG_SUSPEND);
2063	Log(("emR3ForcedActions: returns VINF_EM_SUSPEND\n"));
2064	return VINF_EM_SUSPEND;
2065	}
2066	#endif
2067
2068	/* check that we got them all */
2069	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));
2070	#if defined(VBOX_VMM_TARGET_ARMV8)
2071	AssertCompile(VMCPU_FF_HIGH_PRIORITY_PRE_MASK == (VMCPU_FF_TIMER \| VMCPU_FF_INTERRUPT_IRQ \| VMCPU_FF_INTERRUPT_FIQ \| VMCPU_FF_DBGF));
2072	#else
2073	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_DBGF \| VMCPU_FF_INTERRUPT_NESTED_GUEST \| VMCPU_FF_VMX_MTF \| VMCPU_FF_VMX_APIC_WRITE \| VMCPU_FF_VMX_PREEMPT_TIMER \| VMCPU_FF_VMX_INT_WINDOW \| VMCPU_FF_VMX_NMI_WINDOW));
2074	#endif
2075	}
2076
2077	#undef UPDATE_RC
2078	Log2(("emR3ForcedActions: returns %Rrc\n", rc));
2079	STAM_REL_PROFILE_STOP(&pVCpu->em.s.StatForcedActions, a);
2080	Assert(rcIrq == VINF_SUCCESS \|\| rcIrq == rc);
2081	return rc;
2082	}
2083
2084
2085	/**
2086	* Check if the preset execution time cap restricts guest execution scheduling.
2087	*
2088	* @returns true if allowed, false otherwise
2089	* @param pVM The cross context VM structure.
2090	* @param pVCpu The cross context virtual CPU structure.
2091	*/
2092	bool emR3IsExecutionAllowedSlow(PVM pVM, PVMCPU pVCpu)
2093	{
2094	Assert(pVM->uCpuExecutionCap != 100);
2095	uint64_t cMsUserTime;
2096	uint64_t cMsKernelTime;
2097	if (RT_SUCCESS(RTThreadGetExecutionTimeMilli(&cMsKernelTime, &cMsUserTime)))
2098	{
2099	uint64_t const msTimeNow = RTTimeMilliTS();
2100	if (pVCpu->em.s.msTimeSliceStart + EM_TIME_SLICE < msTimeNow)
2101	{
2102	/* New time slice. */
2103	pVCpu->em.s.msTimeSliceStart = msTimeNow;
2104	pVCpu->em.s.cMsTimeSliceStartExec = cMsKernelTime + cMsUserTime;
2105	pVCpu->em.s.cMsTimeSliceExec = 0;
2106	}
2107	pVCpu->em.s.cMsTimeSliceExec = cMsKernelTime + cMsUserTime - pVCpu->em.s.cMsTimeSliceStartExec;
2108
2109	bool const fRet = pVCpu->em.s.cMsTimeSliceExec < (EM_TIME_SLICE * pVM->uCpuExecutionCap) / 100;
2110	Log2(("emR3IsExecutionAllowed: start=%RX64 startexec=%RX64 exec=%RX64 (cap=%x)\n", pVCpu->em.s.msTimeSliceStart,
2111	pVCpu->em.s.cMsTimeSliceStartExec, pVCpu->em.s.cMsTimeSliceExec, (EM_TIME_SLICE * pVM->uCpuExecutionCap) / 100));
2112	return fRet;
2113	}
2114	return true;
2115	}
2116
2117
2118	/**
2119	* Execute VM.
2120	*
2121	* This function is the main loop of the VM. The emulation thread
2122	* calls this function when the VM has been successfully constructed
2123	* and we're ready for executing the VM.
2124	*
2125	* Returning from this function means that the VM is turned off or
2126	* suspended (state already saved) and deconstruction is next in line.
2127	*
2128	* All interaction from other thread are done using forced actions
2129	* and signalling of the wait object.
2130	*
2131	* @returns VBox status code, informational status codes may indicate failure.
2132	* @param pVM The cross context VM structure.
2133	* @param pVCpu The cross context virtual CPU structure.
2134	*/
2135	VMMR3_INT_DECL(int) EMR3ExecuteVM(PVM pVM, PVMCPU pVCpu)
2136	{
2137	Log(("EMR3ExecuteVM: pVM=%p enmVMState=%d (%s) enmState=%d (%s) enmPrevState=%d (%s)\n",
2138	pVM,
2139	pVM->enmVMState, VMR3GetStateName(pVM->enmVMState),
2140	pVCpu->em.s.enmState, emR3GetStateName(pVCpu->em.s.enmState),
2141	pVCpu->em.s.enmPrevState, emR3GetStateName(pVCpu->em.s.enmPrevState) ));
2142	VM_ASSERT_EMT(pVM);
2143	AssertMsg( pVCpu->em.s.enmState == EMSTATE_NONE
2144	\|\| pVCpu->em.s.enmState == EMSTATE_WAIT_SIPI
2145	\|\| pVCpu->em.s.enmState == EMSTATE_SUSPENDED,
2146	("%s\n", emR3GetStateName(pVCpu->em.s.enmState)));
2147
2148	int rc = setjmp(pVCpu->em.s.u.FatalLongJump);
2149	if (rc == 0)
2150	{
2151	/*
2152	* Start the virtual time.
2153	*/
2154	TMR3NotifyResume(pVM, pVCpu);
2155
2156	/*
2157	* The Outer Main Loop.
2158	*/
2159	bool fFFDone = false;
2160
2161	/* Reschedule right away to start in the right state. */
2162	rc = VINF_SUCCESS;
2163
2164	/* If resuming after a pause or a state load, restore the previous
2165	state or else we'll start executing code. Else, just reschedule. */
2166	if ( pVCpu->em.s.enmState == EMSTATE_SUSPENDED
2167	&& ( pVCpu->em.s.enmPrevState == EMSTATE_WAIT_SIPI
2168	\|\| pVCpu->em.s.enmPrevState == EMSTATE_HALTED))
2169	pVCpu->em.s.enmState = pVCpu->em.s.enmPrevState;
2170	else
2171	pVCpu->em.s.enmState = emR3Reschedule(pVM, pVCpu);
2172	Log(("EMR3ExecuteVM: enmState=%s\n", emR3GetStateName(pVCpu->em.s.enmState)));
2173
2174	STAM_REL_PROFILE_ADV_START(&pVCpu->em.s.StatTotal, x);
2175	for (;;)
2176	{
2177	/*
2178	* Before we can schedule anything (we're here because
2179	* scheduling is required) we must service any pending
2180	* forced actions to avoid any pending action causing
2181	* immediate rescheduling upon entering an inner loop
2182	*
2183	* Do forced actions.
2184	*/
2185	if ( !fFFDone
2186	&& RT_SUCCESS(rc)
2187	&& rc != VINF_EM_TERMINATE
2188	&& rc != VINF_EM_OFF
2189	&& ( VM_FF_IS_ANY_SET(pVM, VM_FF_ALL_REM_MASK)
2190	\|\| VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_ALL_REM_MASK & ~VMCPU_FF_UNHALT)))
2191	{
2192	rc = emR3ForcedActions(pVM, pVCpu, rc);
2193	VBOXVMM_EM_FF_ALL_RET(pVCpu, rc);
2194	}
2195	else if (fFFDone)
2196	fFFDone = false;
2197
2198	#if defined(VBOX_STRICT) && !defined(VBOX_VMM_TARGET_ARMV8)
2199	CPUMAssertGuestRFlagsCookie(pVM, pVCpu);
2200	#endif
2201
2202	/*
2203	* Now what to do?
2204	*/
2205	Log2(("EMR3ExecuteVM: rc=%Rrc\n", rc));
2206	EMSTATE const enmOldState = pVCpu->em.s.enmState;
2207	switch (rc)
2208	{
2209	/*
2210	* Keep doing what we're currently doing.
2211	*/
2212	case VINF_SUCCESS:
2213	break;
2214
2215	/*
2216	* Reschedule - to main execution engine (HM, NEM, IEM/REM).
2217	*/
2218	case VINF_EM_RESCHEDULE_EXEC_ENGINE:
2219	Assert(!pVM->em.s.fIemExecutesAll \|\| pVCpu->em.s.enmState != EMSTATE_IEM);
2220	if (!pVM->em.s.fIemExecutesAll)
2221	{
2222	#if !defined(VBOX_VMM_TARGET_ARMV8)
2223	if (VM_IS_HM_ENABLED(pVM))
2224	{
2225	if (HMCanExecuteGuest(pVM, pVCpu, &pVCpu->cpum.GstCtx))
2226	{
2227	Log2(("EMR3ExecuteVM: VINF_EM_RESCHEDULE_EXEC_ENGINE: %d -> %d (EMSTATE_HM)\n", enmOldState, EMSTATE_HM));
2228	pVCpu->em.s.enmState = EMSTATE_HM;
2229	break;
2230	}
2231	}
2232	else
2233	#endif
2234	if (VM_IS_NEM_ENABLED(pVM) && NEMR3CanExecuteGuest(pVM, pVCpu))
2235	{
2236	Log2(("EMR3ExecuteVM: VINF_EM_RESCHEDULE_EXEC_ENGINE: %d -> %d (EMSTATE_NEM)\n", enmOldState, EMSTATE_NEM));
2237	pVCpu->em.s.enmState = EMSTATE_NEM;
2238	break;
2239	}
2240	}
2241
2242	Log2(("EMR3ExecuteVM: VINF_EM_RESCHEDULE_EXEC_ENGINE: %d -> %d (EMSTATE_RECOMPILER)\n", enmOldState, EMSTATE_RECOMPILER));
2243	pVCpu->em.s.enmState = EMSTATE_RECOMPILER;
2244	break;
2245
2246	/*
2247	* Reschedule - to recompiled execution.
2248	*/
2249	case VINF_EM_RESCHEDULE_REM:
2250	Assert(!pVM->em.s.fIemExecutesAll \|\| pVCpu->em.s.enmState != EMSTATE_IEM);
2251	Log2(("EMR3ExecuteVM: VINF_EM_RESCHEDULE_REM: %d -> %d (EMSTATE_REM)\n",
2252	enmOldState, EMSTATE_RECOMPILER));
2253	pVCpu->em.s.enmState = EMSTATE_RECOMPILER;
2254	break;
2255
2256	/*
2257	* Resume.
2258	*/
2259	case VINF_EM_RESUME:
2260	Log2(("EMR3ExecuteVM: VINF_EM_RESUME: %d -> VINF_EM_RESCHEDULE\n", enmOldState));
2261	/* Don't reschedule in the halted or wait-for-SIPI cases. */
2262	if ( pVCpu->em.s.enmPrevState == EMSTATE_WAIT_SIPI
2263	\|\| pVCpu->em.s.enmPrevState == EMSTATE_HALTED)
2264	{
2265	pVCpu->em.s.enmState = pVCpu->em.s.enmPrevState;
2266	break;
2267	}
2268	/* fall through and get scheduled. */
2269	RT_FALL_THRU();
2270
2271	/*
2272	* Reschedule.
2273	*/
2274	case VINF_EM_RESCHEDULE:
2275	{
2276	EMSTATE enmState = emR3Reschedule(pVM, pVCpu);
2277	Log2(("EMR3ExecuteVM: VINF_EM_RESCHEDULE: %d -> %d (%s)\n", enmOldState, enmState, emR3GetStateName(enmState)));
2278	pVCpu->em.s.enmState = enmState;
2279	break;
2280	}
2281
2282	/*
2283	* Halted.
2284	*/
2285	case VINF_EM_HALT:
2286	Log2(("EMR3ExecuteVM: VINF_EM_HALT: %d -> %d\n", enmOldState, EMSTATE_HALTED));
2287	pVCpu->em.s.enmState = EMSTATE_HALTED;
2288	break;
2289
2290	/*
2291	* Switch to the wait for SIPI state (application processor only)
2292	*/
2293	case VINF_EM_WAIT_SIPI:
2294	Assert(pVCpu->idCpu != 0);
2295	Log2(("EMR3ExecuteVM: VINF_EM_WAIT_SIPI: %d -> %d\n", enmOldState, EMSTATE_WAIT_SIPI));
2296	pVCpu->em.s.enmState = EMSTATE_WAIT_SIPI;
2297	break;
2298
2299
2300	/*
2301	* Suspend.
2302	*/
2303	case VINF_EM_SUSPEND:
2304	Log2(("EMR3ExecuteVM: VINF_EM_SUSPEND: %d -> %d\n", enmOldState, EMSTATE_SUSPENDED));
2305	Assert(enmOldState != EMSTATE_SUSPENDED);
2306	pVCpu->em.s.enmPrevState = enmOldState;
2307	pVCpu->em.s.enmState = EMSTATE_SUSPENDED;
2308	break;
2309
2310	/*
2311	* Reset.
2312	* We might end up doing a double reset for now, we'll have to clean up the mess later.
2313	*/
2314	case VINF_EM_RESET:
2315	{
2316	if (pVCpu->idCpu == 0)
2317	{
2318	EMSTATE enmState = emR3Reschedule(pVM, pVCpu);
2319	Log2(("EMR3ExecuteVM: VINF_EM_RESET: %d -> %d (%s)\n", enmOldState, enmState, emR3GetStateName(enmState)));
2320	pVCpu->em.s.enmState = enmState;
2321	}
2322	else
2323	{
2324	/* All other VCPUs go into the wait for SIPI state. */
2325	pVCpu->em.s.enmState = EMSTATE_WAIT_SIPI;
2326	}
2327	break;
2328	}
2329
2330	/*
2331	* Power Off.
2332	*/
2333	case VINF_EM_OFF:
2334	pVCpu->em.s.enmState = EMSTATE_TERMINATING;
2335	Log2(("EMR3ExecuteVM: returns VINF_EM_OFF (%d -> %d)\n", enmOldState, EMSTATE_TERMINATING));
2336	TMR3NotifySuspend(pVM, pVCpu);
2337	STAM_REL_PROFILE_ADV_STOP(&pVCpu->em.s.StatTotal, x);
2338	return rc;
2339
2340	/*
2341	* Terminate the VM.
2342	*/
2343	case VINF_EM_TERMINATE:
2344	pVCpu->em.s.enmState = EMSTATE_TERMINATING;
2345	Log(("EMR3ExecuteVM returns VINF_EM_TERMINATE (%d -> %d)\n", enmOldState, EMSTATE_TERMINATING));
2346	if (pVM->enmVMState < VMSTATE_DESTROYING) /* ugly */
2347	TMR3NotifySuspend(pVM, pVCpu);
2348	STAM_REL_PROFILE_ADV_STOP(&pVCpu->em.s.StatTotal, x);
2349	return rc;
2350
2351
2352	/*
2353	* Out of memory, suspend the VM and stuff.
2354	*/
2355	case VINF_EM_NO_MEMORY:
2356	Log2(("EMR3ExecuteVM: VINF_EM_NO_MEMORY: %d -> %d\n", enmOldState, EMSTATE_SUSPENDED));
2357	Assert(enmOldState != EMSTATE_SUSPENDED);
2358	pVCpu->em.s.enmPrevState = enmOldState;
2359	pVCpu->em.s.enmState = EMSTATE_SUSPENDED;
2360	TMR3NotifySuspend(pVM, pVCpu);
2361	STAM_REL_PROFILE_ADV_STOP(&pVCpu->em.s.StatTotal, x);
2362
2363	rc = VMSetRuntimeError(pVM, VMSETRTERR_FLAGS_SUSPEND, "HostMemoryLow",
2364	N_("Unable to allocate and lock memory. The virtual machine will be paused. Please close applications to free up memory or close the VM"));
2365	if (rc != VINF_EM_SUSPEND)
2366	{
2367	if (RT_SUCCESS_NP(rc))
2368	{
2369	AssertLogRelMsgFailed(("%Rrc\n", rc));
2370	rc = VERR_EM_INTERNAL_ERROR;
2371	}
2372	pVCpu->em.s.enmState = EMSTATE_GURU_MEDITATION;
2373	}
2374	return rc;
2375
2376	/*
2377	* Guest debug events.
2378	*/
2379	case VINF_EM_DBG_STEPPED:
2380	case VINF_EM_DBG_STOP:
2381	case VINF_EM_DBG_EVENT:
2382	case VINF_EM_DBG_BREAKPOINT:
2383	case VINF_EM_DBG_STEP:
2384	if (enmOldState == EMSTATE_HM)
2385	{
2386	Log2(("EMR3ExecuteVM: %Rrc: %d -> %d\n", rc, enmOldState, EMSTATE_DEBUG_GUEST_HM));
2387	pVCpu->em.s.enmState = EMSTATE_DEBUG_GUEST_HM;
2388	}
2389	else if (enmOldState == EMSTATE_NEM)
2390	{
2391	Log2(("EMR3ExecuteVM: %Rrc: %d -> %d\n", rc, enmOldState, EMSTATE_DEBUG_GUEST_NEM));
2392	pVCpu->em.s.enmState = EMSTATE_DEBUG_GUEST_NEM;
2393	}
2394	else if (enmOldState == EMSTATE_RECOMPILER)
2395	{
2396	Log2(("EMR3ExecuteVM: %Rrc: %d -> %d\n", rc, enmOldState, EMSTATE_DEBUG_GUEST_RECOMPILER));
2397	pVCpu->em.s.enmState = EMSTATE_DEBUG_GUEST_RECOMPILER;
2398	}
2399	else
2400	{
2401	Log2(("EMR3ExecuteVM: %Rrc: %d -> %d\n", rc, enmOldState, EMSTATE_DEBUG_GUEST_IEM));
2402	pVCpu->em.s.enmState = EMSTATE_DEBUG_GUEST_IEM;
2403	}
2404	break;
2405
2406	/*
2407	* Hypervisor debug events.
2408	*/
2409	case VINF_EM_DBG_HYPER_STEPPED:
2410	case VINF_EM_DBG_HYPER_BREAKPOINT:
2411	case VINF_EM_DBG_HYPER_ASSERTION:
2412	Log2(("EMR3ExecuteVM: %Rrc: %d -> %d\n", rc, enmOldState, EMSTATE_DEBUG_HYPER));
2413	pVCpu->em.s.enmState = EMSTATE_DEBUG_HYPER;
2414	break;
2415
2416	/*
2417	* Triple fault.
2418	*/
2419	case VINF_EM_TRIPLE_FAULT:
2420	if (!pVM->em.s.fGuruOnTripleFault)
2421	{
2422	Log(("EMR3ExecuteVM: VINF_EM_TRIPLE_FAULT: CPU reset...\n"));
2423	rc = VBOXSTRICTRC_TODO(VMR3ResetTripleFault(pVM));
2424	Log2(("EMR3ExecuteVM: VINF_EM_TRIPLE_FAULT: %d -> %d (rc=%Rrc)\n", enmOldState, pVCpu->em.s.enmState, rc));
2425	continue;
2426	}
2427	/* Else fall through and trigger a guru. */
2428	RT_FALL_THRU();
2429
2430	case VERR_VMM_RING0_ASSERTION:
2431	Log(("EMR3ExecuteVM: %Rrc: %d -> %d (EMSTATE_GURU_MEDITATION)\n", rc, enmOldState, EMSTATE_GURU_MEDITATION));
2432	pVCpu->em.s.enmState = EMSTATE_GURU_MEDITATION;
2433	break;
2434
2435	/*
2436	* Any error code showing up here other than the ones we
2437	* know and process above are considered to be FATAL.
2438	*
2439	* Unknown warnings and informational status codes are also
2440	* included in this.
2441	*/
2442	default:
2443	if (RT_SUCCESS_NP(rc))
2444	{
2445	AssertMsgFailed(("Unexpected warning or informational status code %Rra!\n", rc));
2446	rc = VERR_EM_INTERNAL_ERROR;
2447	}
2448	Log(("EMR3ExecuteVM: %Rrc: %d -> %d (EMSTATE_GURU_MEDITATION)\n", rc, enmOldState, EMSTATE_GURU_MEDITATION));
2449	pVCpu->em.s.enmState = EMSTATE_GURU_MEDITATION;
2450	break;
2451	}
2452
2453	/*
2454	* Act on state transition.
2455	*/
2456	EMSTATE const enmNewState = pVCpu->em.s.enmState;
2457	if (enmOldState != enmNewState)
2458	{
2459	VBOXVMM_EM_STATE_CHANGED(pVCpu, enmOldState, enmNewState, rc);
2460
2461	/* Clear MWait flags and the unhalt FF. */
2462	if ( enmOldState == EMSTATE_HALTED
2463	&& ( (pVCpu->em.s.MWait.fWait & EMMWAIT_FLAG_ACTIVE)
2464	\|\| VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_UNHALT))
2465	&& ( enmNewState == EMSTATE_HM
2466	\|\| enmNewState == EMSTATE_NEM
2467	\|\| enmNewState == EMSTATE_RECOMPILER
2468	\|\| enmNewState == EMSTATE_DEBUG_GUEST_HM
2469	\|\| enmNewState == EMSTATE_DEBUG_GUEST_NEM
2470	\|\| enmNewState == EMSTATE_DEBUG_GUEST_IEM
2471	\|\| enmNewState == EMSTATE_DEBUG_GUEST_RECOMPILER) )
2472	{
2473	if (pVCpu->em.s.MWait.fWait & EMMWAIT_FLAG_ACTIVE)
2474	{
2475	LogFlow(("EMR3ExecuteVM: Clearing MWAIT\n"));
2476	pVCpu->em.s.MWait.fWait &= ~(EMMWAIT_FLAG_ACTIVE \| EMMWAIT_FLAG_BREAKIRQIF0);
2477	}
2478	if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_UNHALT))
2479	{
2480	LogFlow(("EMR3ExecuteVM: Clearing UNHALT\n"));
2481	VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_UNHALT);
2482	}
2483	}
2484	}
2485	else
2486	VBOXVMM_EM_STATE_UNCHANGED(pVCpu, enmNewState, rc);
2487
2488	STAM_PROFILE_ADV_STOP(&pVCpu->em.s.StatTotal, x); /* (skip this in release) */
2489	STAM_PROFILE_ADV_START(&pVCpu->em.s.StatTotal, x);
2490
2491	/*
2492	* Act on the new state.
2493	*/
2494	switch (enmNewState)
2495	{
2496	/*
2497	* Execute hardware accelerated raw.
2498	*/
2499	case EMSTATE_HM:
2500	#if defined(VBOX_VMM_TARGET_ARMV8)
2501	AssertReleaseFailed(); /* Should never get here. */
2502	#else
2503	rc = emR3HmExecute(pVM, pVCpu, &fFFDone);
2504	#endif
2505	break;
2506
2507	/*
2508	* Execute hardware accelerated raw.
2509	*/
2510	case EMSTATE_NEM:
2511	rc = VBOXSTRICTRC_TODO(emR3NemExecute(pVM, pVCpu, &fFFDone));
2512	break;
2513
2514	/*
2515	* Execute recompiled.
2516	*/
2517	case EMSTATE_RECOMPILER:
2518	rc = VBOXSTRICTRC_TODO(emR3RecompilerExecute(pVM, pVCpu, enmOldState == EMSTATE_HALTED, &fFFDone));
2519	Log2(("EMR3ExecuteVM: emR3RecompilerExecute -> %Rrc\n", rc));
2520	break;
2521
2522	/*
2523	* Execute in the interpreter.
2524	*/
2525	case EMSTATE_IEM:
2526	{
2527	#if 0 /* For comparing HM and IEM (@bugref{10464}). */
2528	PCPUMCTX const pCtx = &pVCpu->cpum.GstCtx;
2529	PCX86FXSTATE const pX87 = &pCtx->XState.x87;
2530	Log11(("eax=%08x ebx=%08x ecx=%08x edx=%08x esi=%08x edi=%08x\n"
2531	"eip=%08x esp=%08x ebp=%08x eflags=%08x\n"
2532	"cs=%04x ss=%04x ds=%04x es=%04x fs=%04x gs=%04x\n"
2533	"fsw=%04x fcw=%04x ftw=%02x top=%u%s%s%s%s%s%s%s%s%s\n"
2534	"st0=%.10Rhxs st1=%.10Rhxs st2=%.10Rhxs st3=%.10Rhxs\n"
2535	"st4=%.10Rhxs st5=%.10Rhxs st6=%.10Rhxs st7=%.10Rhxs\n",
2536	pCtx->eax, pCtx->ebx, pCtx->ecx, pCtx->edx, pCtx->edi, pCtx->edi,
2537	pCtx->eip, pCtx->esp, pCtx->ebp, pCtx->eflags.u,
2538	pCtx->cs.Sel, pCtx->ss.Sel, pCtx->ds.Sel, pCtx->es.Sel, pCtx->fs.Sel, pCtx->gs.Sel,
2539	pX87->FSW, pX87->FCW, pX87->FTW, X86_FSW_TOP_GET(pX87->FSW),
2540	pX87->FSW & X86_FSW_ES ? " ES!" : "",
2541	pX87->FSW & X86_FSW_IE ? " IE" : "",
2542	pX87->FSW & X86_FSW_DE ? " DE" : "",
2543	pX87->FSW & X86_FSW_SF ? " SF" : "",
2544	pX87->FSW & X86_FSW_B ? " B!" : "",
2545	pX87->FSW & X86_FSW_C0 ? " C0" : "",
2546	pX87->FSW & X86_FSW_C1 ? " C1" : "",
2547	pX87->FSW & X86_FSW_C2 ? " C2" : "",
2548	pX87->FSW & X86_FSW_C3 ? " C3" : "",
2549	&pX87->aRegs[/X86_FSW_TOP_GET_ST(pVCpu->cpum.GstCtx.XState.x87.FSW,/(0)],
2550	&pX87->aRegs[/X86_FSW_TOP_GET_ST(pVCpu->cpum.GstCtx.XState.x87.FSW,/(1)],
2551	&pX87->aRegs[/X86_FSW_TOP_GET_ST(pVCpu->cpum.GstCtx.XState.x87.FSW,/(2)],
2552	&pX87->aRegs[/X86_FSW_TOP_GET_ST(pVCpu->cpum.GstCtx.XState.x87.FSW,/(3)],
2553	&pX87->aRegs[/X86_FSW_TOP_GET_ST(pVCpu->cpum.GstCtx.XState.x87.FSW,/(4)],
2554	&pX87->aRegs[/X86_FSW_TOP_GET_ST(pVCpu->cpum.GstCtx.XState.x87.FSW,/(5)],
2555	&pX87->aRegs[/X86_FSW_TOP_GET_ST(pVCpu->cpum.GstCtx.XState.x87.FSW,/(6)],
2556	&pX87->aRegs[/X86_FSW_TOP_GET_ST(pVCpu->cpum.GstCtx.XState.x87.FSW,/(7)]));
2557	DBGFR3DisasInstrCurrentLogInternal(pVCpu, NULL);
2558	#endif
2559
2560	uint32_t cInstructions = 0;
2561	#if 0 /* For testing purposes. */
2562	//STAM_PROFILE_START(&pVCpu->em.s.StatHmExec, x1);
2563	rc = VBOXSTRICTRC_TODO(EMR3HmSingleInstruction(pVM, pVCpu, EM_ONE_INS_FLAGS_RIP_CHANGE));
2564	//STAM_PROFILE_STOP(&pVCpu->em.s.StatHmExec, x1);
2565	if (rc == VINF_EM_DBG_STEPPED \|\| rc == VINF_EM_RESCHEDULE_EXEC_ENGINE \|\| rc == VINF_EM_RESCHEDULE_REM)
2566	rc = VINF_SUCCESS;
2567	else if (rc == VERR_EM_CANNOT_EXEC_GUEST)
2568	#endif
2569	rc = VBOXSTRICTRC_TODO(IEMExecLots(pVCpu, 4096 /cMaxInstructions/, 2047 /cPollRate/, &cInstructions));
2570	if (pVM->em.s.fIemExecutesAll)
2571	{
2572	Assert(rc != VINF_EM_RESCHEDULE_REM);
2573	Assert(rc != VINF_EM_RESCHEDULE_EXEC_ENGINE);
2574	#ifdef VBOX_HIGH_RES_TIMERS_HACK
2575	if (cInstructions < 2048)
2576	TMTimerPollVoid(pVM, pVCpu);
2577	#endif
2578	}
2579	else if (rc == VINF_SUCCESS)
2580	rc = VINF_EM_RESCHEDULE; /* Need to check whether we can run in HM or NEM again. */
2581	#ifndef VBOX_VMM_TARGET_ARMV8
2582	if (rc != VINF_EM_EMULATE_SPLIT_LOCK)
2583	{ /* likely */ }
2584	else
2585	rc = VBOXSTRICTRC_TODO(emR3ExecuteSplitLockInstruction(pVM, pVCpu));
2586	#endif
2587	fFFDone = false;
2588	break;
2589	}
2590
2591	/*
2592	* Application processor execution halted until SIPI.
2593	*/
2594	case EMSTATE_WAIT_SIPI:
2595	/* no break */
2596	/*
2597	* hlt - execution halted until interrupt.
2598	*/
2599	case EMSTATE_HALTED:
2600	{
2601	STAM_REL_PROFILE_START(&pVCpu->em.s.StatHalted, y);
2602	/* If HM (or someone else) store a pending interrupt in
2603	TRPM, it must be dispatched ASAP without any halting.
2604	Anything pending in TRPM has been accepted and the CPU
2605	should already be the right state to receive it. */
2606	if (TRPMHasTrap(pVCpu))
2607	rc = VINF_EM_RESCHEDULE;
2608	#if !defined(VBOX_VMM_TARGET_ARMV8)
2609	/* MWAIT has a special extension where it's woken up when
2610	an interrupt is pending even when IF=0. */
2611	else if ( (pVCpu->em.s.MWait.fWait & (EMMWAIT_FLAG_ACTIVE \| EMMWAIT_FLAG_BREAKIRQIF0))
2612	== (EMMWAIT_FLAG_ACTIVE \| EMMWAIT_FLAG_BREAKIRQIF0))
2613	{
2614	rc = VMR3WaitHalted(pVM, pVCpu, 0 /fFlags/);
2615	if (rc == VINF_SUCCESS)
2616	{
2617	if (VMCPU_FF_TEST_AND_CLEAR(pVCpu, VMCPU_FF_UPDATE_APIC))
2618	APICUpdatePendingInterrupts(pVCpu);
2619
2620	if (VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_INTERRUPT_APIC \| VMCPU_FF_INTERRUPT_PIC
2621	\| VMCPU_FF_INTERRUPT_NESTED_GUEST
2622	\| VMCPU_FF_INTERRUPT_NMI \| VMCPU_FF_INTERRUPT_SMI \| VMCPU_FF_UNHALT))
2623	{
2624	Log(("EMR3ExecuteVM: Triggering reschedule on pending IRQ after MWAIT\n"));
2625	rc = VINF_EM_RESCHEDULE;
2626	}
2627
2628	}
2629	}
2630	#endif
2631	else
2632	{
2633	#if defined(VBOX_VMM_TARGET_ARMV8)
2634	const uint32_t fWaitHalted = 0; /* WFI/WFE always return when an interrupt happens. */
2635	#else
2636	const uint32_t fWaitHalted = (CPUMGetGuestEFlags(pVCpu) & X86_EFL_IF) ? 0 : VMWAITHALTED_F_IGNORE_IRQS;
2637	#endif
2638	rc = VMR3WaitHalted(pVM, pVCpu, fWaitHalted);
2639	/* We're only interested in NMI/SMIs here which have their own FFs, so we don't need to
2640	check VMCPU_FF_UPDATE_APIC here. */
2641	if ( rc == VINF_SUCCESS
2642	#if defined(VBOX_VMM_TARGET_ARMV8)
2643	&& VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_INTERRUPT_NMI \| VMCPU_FF_INTERRUPT_SMI \| VMCPU_FF_VTIMER_ACTIVATED
2644	\| VMCPU_FF_INTERRUPT_FIQ \| VMCPU_FF_INTERRUPT_IRQ)
2645	#else
2646	&& VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_INTERRUPT_NMI \| VMCPU_FF_INTERRUPT_SMI \| VMCPU_FF_UNHALT)
2647	#endif
2648	)
2649	{
2650	Log(("EMR3ExecuteVM: Triggering reschedule on pending NMI/SMI/UNHALT after HLT\n"));
2651	rc = VINF_EM_RESCHEDULE;
2652	}
2653	}
2654
2655	STAM_REL_PROFILE_STOP(&pVCpu->em.s.StatHalted, y);
2656	break;
2657	}
2658
2659	/*
2660	* Suspended - return to VM.cpp.
2661	*/
2662	case EMSTATE_SUSPENDED:
2663	TMR3NotifySuspend(pVM, pVCpu);
2664	STAM_REL_PROFILE_ADV_STOP(&pVCpu->em.s.StatTotal, x);
2665	Log(("EMR3ExecuteVM: actually returns %Rrc (state %s / %s)\n", rc, emR3GetStateName(pVCpu->em.s.enmState), emR3GetStateName(enmOldState)));
2666	return VINF_EM_SUSPEND;
2667
2668	/*
2669	* Debugging in the guest.
2670	*/
2671	case EMSTATE_DEBUG_GUEST_RAW:
2672	case EMSTATE_DEBUG_GUEST_HM:
2673	case EMSTATE_DEBUG_GUEST_NEM:
2674	case EMSTATE_DEBUG_GUEST_IEM:
2675	case EMSTATE_DEBUG_GUEST_RECOMPILER:
2676	TMR3NotifySuspend(pVM, pVCpu);
2677	rc = VBOXSTRICTRC_TODO(emR3Debug(pVM, pVCpu, rc));
2678	TMR3NotifyResume(pVM, pVCpu);
2679	Log2(("EMR3ExecuteVM: emR3Debug -> %Rrc (state %d)\n", rc, pVCpu->em.s.enmState));
2680	break;
2681
2682	/*
2683	* Debugging in the hypervisor.
2684	*/
2685	case EMSTATE_DEBUG_HYPER:
2686	{
2687	TMR3NotifySuspend(pVM, pVCpu);
2688	STAM_REL_PROFILE_ADV_STOP(&pVCpu->em.s.StatTotal, x);
2689
2690	rc = VBOXSTRICTRC_TODO(emR3Debug(pVM, pVCpu, rc));
2691	Log2(("EMR3ExecuteVM: emR3Debug -> %Rrc (state %d)\n", rc, pVCpu->em.s.enmState));
2692	if (rc != VINF_SUCCESS)
2693	{
2694	if (rc == VINF_EM_OFF \|\| rc == VINF_EM_TERMINATE)
2695	pVCpu->em.s.enmState = EMSTATE_TERMINATING;
2696	else
2697	{
2698	/* switch to guru meditation mode */
2699	pVCpu->em.s.enmState = EMSTATE_GURU_MEDITATION;
2700	VMR3SetGuruMeditation(pVM); /* This notifies the other EMTs. */
2701	VMMR3FatalDump(pVM, pVCpu, rc);
2702	}
2703	Log(("EMR3ExecuteVM: actually returns %Rrc (state %s / %s)\n", rc, emR3GetStateName(pVCpu->em.s.enmState), emR3GetStateName(enmOldState)));
2704	return rc;
2705	}
2706
2707	STAM_REL_PROFILE_ADV_START(&pVCpu->em.s.StatTotal, x);
2708	TMR3NotifyResume(pVM, pVCpu);
2709	break;
2710	}
2711
2712	/*
2713	* Guru meditation takes place in the debugger.
2714	*/
2715	case EMSTATE_GURU_MEDITATION:
2716	{
2717	TMR3NotifySuspend(pVM, pVCpu);
2718	VMR3SetGuruMeditation(pVM); /* This notifies the other EMTs. */
2719	VMMR3FatalDump(pVM, pVCpu, rc);
2720	emR3Debug(pVM, pVCpu, rc);
2721	STAM_REL_PROFILE_ADV_STOP(&pVCpu->em.s.StatTotal, x);
2722	Log(("EMR3ExecuteVM: actually returns %Rrc (state %s / %s)\n", rc, emR3GetStateName(pVCpu->em.s.enmState), emR3GetStateName(enmOldState)));
2723	return rc;
2724	}
2725
2726	/*
2727	* The states we don't expect here.
2728	*/
2729	case EMSTATE_NONE:
2730	case EMSTATE_RAW_OBSOLETE:
2731	case EMSTATE_IEM_THEN_REM_OBSOLETE:
2732	case EMSTATE_TERMINATING:
2733	default:
2734	AssertMsgFailed(("EMR3ExecuteVM: Invalid state %d!\n", pVCpu->em.s.enmState));
2735	pVCpu->em.s.enmState = EMSTATE_GURU_MEDITATION;
2736	TMR3NotifySuspend(pVM, pVCpu);
2737	STAM_REL_PROFILE_ADV_STOP(&pVCpu->em.s.StatTotal, x);
2738	Log(("EMR3ExecuteVM: actually returns %Rrc (state %s / %s)\n", rc, emR3GetStateName(pVCpu->em.s.enmState), emR3GetStateName(enmOldState)));
2739	return VERR_EM_INTERNAL_ERROR;
2740	}
2741	} /* The Outer Main Loop */
2742	}
2743	else
2744	{
2745	/*
2746	* Fatal error.
2747	*/
2748	Log(("EMR3ExecuteVM: returns %Rrc because of longjmp / fatal error; (state %s / %s)\n", rc, emR3GetStateName(pVCpu->em.s.enmState), emR3GetStateName(pVCpu->em.s.enmPrevState)));
2749	TMR3NotifySuspend(pVM, pVCpu);
2750	VMR3SetGuruMeditation(pVM); /* This notifies the other EMTs. */
2751	VMMR3FatalDump(pVM, pVCpu, rc);
2752	emR3Debug(pVM, pVCpu, rc);
2753	STAM_REL_PROFILE_ADV_STOP(&pVCpu->em.s.StatTotal, x);
2754	/** @todo change the VM state! */
2755	return rc;
2756	}
2757
2758	/* not reached */
2759	}
2760

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

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

Download in other formats: