EMRaw.cpp@ 24911

Last change on this file since 24911 was 23372, checked in by vboxsync, 15 years ago
pgmR3PoolClearAll.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 58.7 KB

Line
1	/* $Id: EMRaw.cpp 23372 2009-09-28 12:46:22Z vboxsync $ */
2	/** @file
3	* EM - Execution Monitor / Manager - software virtualization
4	*/
5
6	/*
7	* Copyright (C) 2006-2009 Sun Microsystems, Inc.
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18	* Clara, CA 95054 USA or visit http://www.sun.com if you need
19	* additional information or have any questions.
20	*/
21
22	/** @page pg_em EM - The Execution Monitor / Manager
23	*
24	* The Execution Monitor/Manager is responsible for running the VM, scheduling
25	* the right kind of execution (Raw-mode, Hardware Assisted, Recompiled or
26	* Interpreted), and keeping the CPU states in sync. The function
27	* EMR3ExecuteVM() is the 'main-loop' of the VM, while each of the execution
28	* modes has different inner loops (emR3RawExecute, emR3HwAccExecute, and
29	* emR3RemExecute).
30	*
31	* The interpreted execution is only used to avoid switching between
32	* raw-mode/hwaccm and the recompiler when fielding virtualization traps/faults.
33	* The interpretation is thus implemented as part of EM.
34	*
35	* @see grp_em
36	*/
37
38	/*******************************************************************************
39	* Header Files *
40	*******************************************************************************/
41	#define LOG_GROUP LOG_GROUP_EM
42	#include <VBox/em.h>
43	#include <VBox/vmm.h>
44	#ifdef VBOX_WITH_VMI
45	# include <VBox/parav.h>
46	#endif
47	#include <VBox/patm.h>
48	#include <VBox/csam.h>
49	#include <VBox/selm.h>
50	#include <VBox/trpm.h>
51	#include <VBox/iom.h>
52	#include <VBox/dbgf.h>
53	#include <VBox/pgm.h>
54	#include <VBox/rem.h>
55	#include <VBox/tm.h>
56	#include <VBox/mm.h>
57	#include <VBox/ssm.h>
58	#include <VBox/pdmapi.h>
59	#include <VBox/pdmcritsect.h>
60	#include <VBox/pdmqueue.h>
61	#include <VBox/patm.h>
62	#include "EMInternal.h"
63	#include <VBox/vm.h>
64	#include <VBox/cpumdis.h>
65	#include <VBox/dis.h>
66	#include <VBox/disopcode.h>
67	#include <VBox/dbgf.h>
68
69	#include <VBox/log.h>
70	#include <iprt/string.h>
71	#include <iprt/stream.h>
72
73	/*******************************************************************************
74	* Defined Constants And Macros *
75	*******************************************************************************/
76
77
78	/*******************************************************************************
79	* Internal Functions *
80	*******************************************************************************/
81	static int emR3RawForcedActions(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx);
82	DECLINLINE(int) emR3ExecuteInstruction(PVM pVM, PVMCPU pVCpu, const char *pszPrefix, int rcGC = VINF_SUCCESS);
83	static int emR3RawGuestTrap(PVM pVM, PVMCPU pVCpu);
84	static int emR3PatchTrap(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx, int gcret);
85	static int emR3SingleStepExecRem(PVM pVM, uint32_t cIterations);
86	static int emR3RawPrivileged(PVM pVM, PVMCPU pVCpu);
87	static int emR3ExecuteIOInstruction(PVM pVM, PVMCPU pVCpu);
88	static int emR3RawRingSwitch(PVM pVM, PVMCPU pVCpu);
89
90	#define EMHANDLERC_WITH_PATM
91	#include "EMHandleRCTmpl.h"
92
93	/**
94	* Enables or disables a set of raw-mode execution modes.
95	*
96	* @returns VINF_SUCCESS on success.
97	* @returns VINF_RESCHEDULE if a rescheduling might be required.
98	* @returns VERR_INVALID_PARAMETER on an invalid enmMode value.
99	*
100	* @param pVM The VM to operate on.
101	* @param enmMode The execution mode change.
102	* @thread The emulation thread.
103	*/
104	VMMR3DECL(int) EMR3RawSetMode(PVM pVM, EMRAWMODE enmMode)
105	{
106	switch (enmMode)
107	{
108	case EMRAW_NONE:
109	pVM->fRawR3Enabled = false;
110	pVM->fRawR0Enabled = false;
111	break;
112	case EMRAW_RING3_ENABLE:
113	pVM->fRawR3Enabled = true;
114	break;
115	case EMRAW_RING3_DISABLE:
116	pVM->fRawR3Enabled = false;
117	break;
118	case EMRAW_RING0_ENABLE:
119	pVM->fRawR0Enabled = true;
120	break;
121	case EMRAW_RING0_DISABLE:
122	pVM->fRawR0Enabled = false;
123	break;
124	default:
125	AssertMsgFailed(("Invalid enmMode=%d\n", enmMode));
126	return VERR_INVALID_PARAMETER;
127	}
128	Log(("EMR3SetRawMode: fRawR3Enabled=%RTbool fRawR0Enabled=%RTbool\n",
129	pVM->fRawR3Enabled, pVM->fRawR0Enabled));
130	return pVM->aCpus[0].em.s.enmState == EMSTATE_RAW ? VINF_EM_RESCHEDULE : VINF_SUCCESS;
131	}
132
133
134
135	#ifdef VBOX_WITH_STATISTICS
136	/**
137	* Just a braindead function to keep track of cli addresses.
138	* @param pVM VM handle.
139	* @param pVMCPU VMCPU handle.
140	* @param GCPtrInstr The EIP of the cli instruction.
141	*/
142	static void emR3RecordCli(PVM pVM, PVMCPU pVCpu, RTGCPTR GCPtrInstr)
143	{
144	PCLISTAT pRec;
145
146	pRec = (PCLISTAT)RTAvlPVGet(&pVCpu->em.s.pCliStatTree, (AVLPVKEY)GCPtrInstr);
147	if (!pRec)
148	{
149	/* New cli instruction; insert into the tree. */
150	pRec = (PCLISTAT)MMR3HeapAllocZ(pVM, MM_TAG_EM, sizeof(*pRec));
151	Assert(pRec);
152	if (!pRec)
153	return;
154	pRec->Core.Key = (AVLPVKEY)GCPtrInstr;
155
156	char szCliStatName[32];
157	RTStrPrintf(szCliStatName, sizeof(szCliStatName), "/EM/Cli/0x%RGv", GCPtrInstr);
158	STAM_REG(pVM, &pRec->Counter, STAMTYPE_COUNTER, szCliStatName, STAMUNIT_OCCURENCES, "Number of times cli was executed.");
159
160	bool fRc = RTAvlPVInsert(&pVCpu->em.s.pCliStatTree, &pRec->Core);
161	Assert(fRc); NOREF(fRc);
162	}
163	STAM_COUNTER_INC(&pRec->Counter);
164	STAM_COUNTER_INC(&pVCpu->em.s.StatTotalClis);
165	}
166	#endif /* VBOX_WITH_STATISTICS */
167
168
169
170	/**
171	* Resumes executing hypervisor after a debug event.
172	*
173	* This is kind of special since our current guest state is
174	* potentially out of sync.
175	*
176	* @returns VBox status code.
177	* @param pVM The VM handle.
178	* @param pVCpu The VMCPU handle.
179	*/
180	int emR3RawResumeHyper(PVM pVM, PVMCPU pVCpu)
181	{
182	int rc;
183	PCPUMCTX pCtx = pVCpu->em.s.pCtx;
184	Assert(pVCpu->em.s.enmState == EMSTATE_DEBUG_HYPER);
185	Log(("emR3RawResumeHyper: cs:eip=%RTsel:%RGr efl=%RGr\n", pCtx->cs, pCtx->eip, pCtx->eflags));
186
187	/*
188	* Resume execution.
189	*/
190	CPUMRawEnter(pVCpu, NULL);
191	CPUMSetHyperEFlags(pVCpu, CPUMGetHyperEFlags(pVCpu) \| X86_EFL_RF);
192	rc = VMMR3ResumeHyper(pVM, pVCpu);
193	Log(("emR3RawResumeHyper: cs:eip=%RTsel:%RGr efl=%RGr - returned from GC with rc=%Rrc\n", pCtx->cs, pCtx->eip, pCtx->eflags, rc));
194	rc = CPUMRawLeave(pVCpu, NULL, rc);
195	VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_RESUME_GUEST_MASK);
196
197	/*
198	* Deal with the return code.
199	*/
200	rc = emR3HighPriorityPostForcedActions(pVM, pVCpu, rc);
201	rc = emR3RawHandleRC(pVM, pVCpu, pCtx, rc);
202	rc = emR3RawUpdateForceFlag(pVM, pVCpu, pCtx, rc);
203	return rc;
204	}
205
206
207	/**
208	* Steps rawmode.
209	*
210	* @returns VBox status code.
211	* @param pVM The VM handle.
212	* @param pVCpu The VMCPU handle.
213	*/
214	int emR3RawStep(PVM pVM, PVMCPU pVCpu)
215	{
216	Assert( pVCpu->em.s.enmState == EMSTATE_DEBUG_HYPER
217	\|\| pVCpu->em.s.enmState == EMSTATE_DEBUG_GUEST_RAW
218	\|\| pVCpu->em.s.enmState == EMSTATE_DEBUG_GUEST_REM);
219	int rc;
220	PCPUMCTX pCtx = pVCpu->em.s.pCtx;
221	bool fGuest = pVCpu->em.s.enmState != EMSTATE_DEBUG_HYPER;
222	#ifndef DEBUG_sandervl
223	Log(("emR3RawStep: cs:eip=%RTsel:%RGr efl=%RGr\n", fGuest ? CPUMGetGuestCS(pVCpu) : CPUMGetHyperCS(pVCpu),
224	fGuest ? CPUMGetGuestEIP(pVCpu) : CPUMGetHyperEIP(pVCpu), fGuest ? CPUMGetGuestEFlags(pVCpu) : CPUMGetHyperEFlags(pVCpu)));
225	#endif
226	if (fGuest)
227	{
228	/*
229	* Check vital forced actions, but ignore pending interrupts and timers.
230	*/
231	if ( VM_FF_ISPENDING(pVM, VM_FF_HIGH_PRIORITY_PRE_RAW_MASK)
232	\|\| VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_HIGH_PRIORITY_PRE_RAW_MASK))
233	{
234	rc = emR3RawForcedActions(pVM, pVCpu, pCtx);
235	if (rc != VINF_SUCCESS)
236	return rc;
237	}
238
239	/*
240	* Set flags for single stepping.
241	*/
242	CPUMSetGuestEFlags(pVCpu, CPUMGetGuestEFlags(pVCpu) \| X86_EFL_TF \| X86_EFL_RF);
243	}
244	else
245	CPUMSetHyperEFlags(pVCpu, CPUMGetHyperEFlags(pVCpu) \| X86_EFL_TF \| X86_EFL_RF);
246
247	/*
248	* Single step.
249	* We do not start time or anything, if anything we should just do a few nanoseconds.
250	*/
251	CPUMRawEnter(pVCpu, NULL);
252	do
253	{
254	if (pVCpu->em.s.enmState == EMSTATE_DEBUG_HYPER)
255	rc = VMMR3ResumeHyper(pVM, pVCpu);
256	else
257	rc = VMMR3RawRunGC(pVM, pVCpu);
258	#ifndef DEBUG_sandervl
259	Log(("emR3RawStep: cs:eip=%RTsel:%RGr efl=%RGr - GC rc %Rrc\n", fGuest ? CPUMGetGuestCS(pVCpu) : CPUMGetHyperCS(pVCpu),
260	fGuest ? CPUMGetGuestEIP(pVCpu) : CPUMGetHyperEIP(pVCpu), fGuest ? CPUMGetGuestEFlags(pVCpu) : CPUMGetHyperEFlags(pVCpu), rc));
261	#endif
262	} while ( rc == VINF_SUCCESS
263	\|\| rc == VINF_EM_RAW_INTERRUPT);
264	rc = CPUMRawLeave(pVCpu, NULL, rc);
265	VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_RESUME_GUEST_MASK);
266
267	/*
268	* Make sure the trap flag is cleared.
269	* (Too bad if the guest is trying to single step too.)
270	*/
271	if (fGuest)
272	CPUMSetGuestEFlags(pVCpu, CPUMGetGuestEFlags(pVCpu) & ~X86_EFL_TF);
273	else
274	CPUMSetHyperEFlags(pVCpu, CPUMGetHyperEFlags(pVCpu) & ~X86_EFL_TF);
275
276	/*
277	* Deal with the return codes.
278	*/
279	rc = emR3HighPriorityPostForcedActions(pVM, pVCpu, rc);
280	rc = emR3RawHandleRC(pVM, pVCpu, pCtx, rc);
281	rc = emR3RawUpdateForceFlag(pVM, pVCpu, pCtx, rc);
282	return rc;
283	}
284
285
286	#ifdef DEBUG
287
288
289	int emR3SingleStepExecRaw(PVM pVM, PVMCPU pVCpu, uint32_t cIterations)
290	{
291	int rc = VINF_SUCCESS;
292	EMSTATE enmOldState = pVCpu->em.s.enmState;
293	pVCpu->em.s.enmState = EMSTATE_DEBUG_GUEST_RAW;
294
295	Log(("Single step BEGIN:\n"));
296	for (uint32_t i = 0; i < cIterations; i++)
297	{
298	DBGFR3PrgStep(pVCpu);
299	DBGFR3DisasInstrCurrentLog(pVCpu, "RSS: ");
300	rc = emR3RawStep(pVM, pVCpu);
301	if (rc != VINF_SUCCESS)
302	break;
303	}
304	Log(("Single step END: rc=%Rrc\n", rc));
305	CPUMSetGuestEFlags(pVCpu, CPUMGetGuestEFlags(pVCpu) & ~X86_EFL_TF);
306	pVCpu->em.s.enmState = enmOldState;
307	return rc;
308	}
309
310	#endif /* DEBUG */
311
312
313	/**
314	* Executes one (or perhaps a few more) instruction(s).
315	*
316	* @returns VBox status code suitable for EM.
317	*
318	* @param pVM VM handle.
319	* @param pVCpu VMCPU handle
320	* @param rcGC GC return code
321	* @param pszPrefix Disassembly prefix. If not NULL we'll disassemble the
322	* instruction and prefix the log output with this text.
323	*/
324	#ifdef LOG_ENABLED
325	static int emR3ExecuteInstructionWorker(PVM pVM, PVMCPU pVCpu, int rcGC, const char *pszPrefix)
326	#else
327	static int emR3ExecuteInstructionWorker(PVM pVM, PVMCPU pVCpu, int rcGC)
328	#endif
329	{
330	PCPUMCTX pCtx = pVCpu->em.s.pCtx;
331	int rc;
332
333	/*
334	*
335	* The simple solution is to use the recompiler.
336	* The better solution is to disassemble the current instruction and
337	* try handle as many as possible without using REM.
338	*
339	*/
340
341	#ifdef LOG_ENABLED
342	/*
343	* Disassemble the instruction if requested.
344	*/
345	if (pszPrefix)
346	{
347	DBGFR3InfoLog(pVM, "cpumguest", pszPrefix);
348	DBGFR3DisasInstrCurrentLog(pVCpu, pszPrefix);
349	}
350	#endif /* LOG_ENABLED */
351
352	/*
353	* PATM is making life more interesting.
354	* We cannot hand anything to REM which has an EIP inside patch code. So, we'll
355	* tell PATM there is a trap in this code and have it take the appropriate actions
356	* to allow us execute the code in REM.
357	*/
358	if (PATMIsPatchGCAddr(pVM, pCtx->eip))
359	{
360	Log(("emR3ExecuteInstruction: In patch block. eip=%RRv\n", (RTRCPTR)pCtx->eip));
361
362	RTGCPTR pNewEip;
363	rc = PATMR3HandleTrap(pVM, pCtx, pCtx->eip, &pNewEip);
364	switch (rc)
365	{
366	/*
367	* It's not very useful to emulate a single instruction and then go back to raw
368	* mode; just execute the whole block until IF is set again.
369	*/
370	case VINF_SUCCESS:
371	Log(("emR3ExecuteInstruction: Executing instruction starting at new address %RGv IF=%d VMIF=%x\n",
372	pNewEip, pCtx->eflags.Bits.u1IF, pVCpu->em.s.pPatmGCState->uVMFlags));
373	pCtx->eip = pNewEip;
374	Assert(pCtx->eip);
375
376	if (pCtx->eflags.Bits.u1IF)
377	{
378	/*
379	* The last instruction in the patch block needs to be executed!! (sti/sysexit for example)
380	*/
381	Log(("PATCH: IF=1 -> emulate last instruction as it can't be interrupted!!\n"));
382	return emR3ExecuteInstruction(pVM, pVCpu, "PATCHIR");
383	}
384	else if (rcGC == VINF_PATM_PENDING_IRQ_AFTER_IRET)
385	{
386	/* special case: iret, that sets IF, detected a pending irq/event */
387	return emR3ExecuteInstruction(pVM, pVCpu, "PATCHIRET");
388	}
389	return VINF_EM_RESCHEDULE_REM;
390
391	/*
392	* One instruction.
393	*/
394	case VINF_PATCH_EMULATE_INSTR:
395	Log(("emR3ExecuteInstruction: Emulate patched instruction at %RGv IF=%d VMIF=%x\n",
396	pNewEip, pCtx->eflags.Bits.u1IF, pVCpu->em.s.pPatmGCState->uVMFlags));
397	pCtx->eip = pNewEip;
398	return emR3ExecuteInstruction(pVM, pVCpu, "PATCHIR");
399
400	/*
401	* The patch was disabled, hand it to the REM.
402	*/
403	case VERR_PATCH_DISABLED:
404	Log(("emR3ExecuteInstruction: Disabled patch -> new eip %RGv IF=%d VMIF=%x\n",
405	pNewEip, pCtx->eflags.Bits.u1IF, pVCpu->em.s.pPatmGCState->uVMFlags));
406	pCtx->eip = pNewEip;
407	if (pCtx->eflags.Bits.u1IF)
408	{
409	/*
410	* The last instruction in the patch block needs to be executed!! (sti/sysexit for example)
411	*/
412	Log(("PATCH: IF=1 -> emulate last instruction as it can't be interrupted!!\n"));
413	return emR3ExecuteInstruction(pVM, pVCpu, "PATCHIR");
414	}
415	return VINF_EM_RESCHEDULE_REM;
416
417	/* Force continued patch exection; usually due to write monitored stack. */
418	case VINF_PATCH_CONTINUE:
419	return VINF_SUCCESS;
420
421	default:
422	AssertReleaseMsgFailed(("Unknown return code %Rrc from PATMR3HandleTrap\n", rc));
423	return VERR_IPE_UNEXPECTED_STATUS;
424	}
425	}
426
427	#if 0
428	/* Try our own instruction emulator before falling back to the recompiler. */
429	DISCPUSTATE Cpu;
430	rc = CPUMR3DisasmInstrCPU(pVM, pVCpu, pCtx, pCtx->rip, &Cpu, "GEN EMU");
431	if (RT_SUCCESS(rc))
432	{
433	uint32_t size;
434
435	switch (Cpu.pCurInstr->opcode)
436	{
437	/* @todo we can do more now */
438	case OP_MOV:
439	case OP_AND:
440	case OP_OR:
441	case OP_XOR:
442	case OP_POP:
443	case OP_INC:
444	case OP_DEC:
445	case OP_XCHG:
446	STAM_PROFILE_START(&pVCpu->em.s.StatMiscEmu, a);
447	rc = EMInterpretInstructionCPU(pVM, &Cpu, CPUMCTX2CORE(pCtx), 0, &size);
448	if (RT_SUCCESS(rc))
449	{
450	pCtx->rip += Cpu.opsize;
451	STAM_PROFILE_STOP(&pVCpu->em.s.StatMiscEmu, a);
452	return rc;
453	}
454	if (rc != VERR_EM_INTERPRETER)
455	AssertMsgFailedReturn(("rc=%Rrc\n", rc), rc);
456	STAM_PROFILE_STOP(&pVCpu->em.s.StatMiscEmu, a);
457	break;
458	}
459	}
460	#endif /* 0 */
461	STAM_PROFILE_START(&pVCpu->em.s.StatREMEmu, a);
462	Log(("EMINS: %04x:%RGv RSP=%RGv\n", pCtx->cs, (RTGCPTR)pCtx->rip, (RTGCPTR)pCtx->rsp));
463	EMRemLock(pVM);
464	/* Flush the recompiler TLB if the VCPU has changed. */
465	if (pVM->em.s.idLastRemCpu != pVCpu->idCpu)
466	CPUMSetChangedFlags(pVCpu, CPUM_CHANGED_ALL);
467	pVM->em.s.idLastRemCpu = pVCpu->idCpu;
468
469	rc = REMR3EmulateInstruction(pVM, pVCpu);
470	EMRemUnlock(pVM);
471	STAM_PROFILE_STOP(&pVCpu->em.s.StatREMEmu, a);
472
473	return rc;
474	}
475
476
477	/**
478	* Executes one (or perhaps a few more) instruction(s).
479	* This is just a wrapper for discarding pszPrefix in non-logging builds.
480	*
481	* @returns VBox status code suitable for EM.
482	* @param pVM VM handle.
483	* @param pVCpu VMCPU handle.
484	* @param pszPrefix Disassembly prefix. If not NULL we'll disassemble the
485	* instruction and prefix the log output with this text.
486	* @param rcGC GC return code
487	*/
488	DECLINLINE(int) emR3ExecuteInstruction(PVM pVM, PVMCPU pVCpu, const char *pszPrefix, int rcGC)
489	{
490	#ifdef LOG_ENABLED
491	return emR3ExecuteInstructionWorker(pVM, pVCpu, rcGC, pszPrefix);
492	#else
493	return emR3ExecuteInstructionWorker(pVM, pVCpu, rcGC);
494	#endif
495	}
496
497	/**
498	* Executes one (or perhaps a few more) IO instruction(s).
499	*
500	* @returns VBox status code suitable for EM.
501	* @param pVM VM handle.
502	* @param pVCpu VMCPU handle.
503	*/
504	static int emR3ExecuteIOInstruction(PVM pVM, PVMCPU pVCpu)
505	{
506	PCPUMCTX pCtx = pVCpu->em.s.pCtx;
507
508	STAM_PROFILE_START(&pVCpu->em.s.StatIOEmu, a);
509
510	/** @todo probably we should fall back to the recompiler; otherwise we'll go back and forth between HC & GC
511	* as io instructions tend to come in packages of more than one
512	*/
513	DISCPUSTATE Cpu;
514	int rc = CPUMR3DisasmInstrCPU(pVM, pVCpu, pCtx, pCtx->rip, &Cpu, "IO EMU");
515	if (RT_SUCCESS(rc))
516	{
517	VBOXSTRICTRC rcStrict = VINF_EM_RAW_EMULATE_INSTR;
518
519	if (!(Cpu.prefix & (PREFIX_REP \| PREFIX_REPNE)))
520	{
521	switch (Cpu.pCurInstr->opcode)
522	{
523	case OP_IN:
524	{
525	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->StatIn);
526	rcStrict = IOMInterpretIN(pVM, CPUMCTX2CORE(pCtx), &Cpu);
527	break;
528	}
529
530	case OP_OUT:
531	{
532	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->StatOut);
533	rcStrict = IOMInterpretOUT(pVM, CPUMCTX2CORE(pCtx), &Cpu);
534	break;
535	}
536	}
537	}
538	else if (Cpu.prefix & PREFIX_REP)
539	{
540	switch (Cpu.pCurInstr->opcode)
541	{
542	case OP_INSB:
543	case OP_INSWD:
544	{
545	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->StatIn);
546	rcStrict = IOMInterpretINS(pVM, CPUMCTX2CORE(pCtx), &Cpu);
547	break;
548	}
549
550	case OP_OUTSB:
551	case OP_OUTSWD:
552	{
553	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->StatOut);
554	rcStrict = IOMInterpretOUTS(pVM, CPUMCTX2CORE(pCtx), &Cpu);
555	break;
556	}
557	}
558	}
559
560	/*
561	* Handled the I/O return codes.
562	* (The unhandled cases end up with rcStrict == VINF_EM_RAW_EMULATE_INSTR.)
563	*/
564	if (IOM_SUCCESS(rcStrict))
565	{
566	pCtx->rip += Cpu.opsize;
567	STAM_PROFILE_STOP(&pVCpu->em.s.StatIOEmu, a);
568	return VBOXSTRICTRC_TODO(rcStrict);
569	}
570
571	if (rcStrict == VINF_EM_RAW_GUEST_TRAP)
572	{
573	STAM_PROFILE_STOP(&pVCpu->em.s.StatIOEmu, a);
574	rcStrict = emR3RawGuestTrap(pVM, pVCpu);
575	return VBOXSTRICTRC_TODO(rcStrict);
576	}
577	AssertMsg(rcStrict != VINF_TRPM_XCPT_DISPATCHED, ("Handle VINF_TRPM_XCPT_DISPATCHED\n"));
578
579	if (RT_FAILURE(rcStrict))
580	{
581	STAM_PROFILE_STOP(&pVCpu->em.s.StatIOEmu, a);
582	return VBOXSTRICTRC_TODO(rcStrict);
583	}
584	AssertMsg(rcStrict == VINF_EM_RAW_EMULATE_INSTR \|\| rcStrict == VINF_EM_RESCHEDULE_REM, ("rcStrict=%Rrc\n", VBOXSTRICTRC_VAL(rcStrict)));
585	}
586	STAM_PROFILE_STOP(&pVCpu->em.s.StatIOEmu, a);
587	return emR3ExecuteInstruction(pVM, pVCpu, "IO: ");
588	}
589
590
591	/**
592	* Handle a guest context trap.
593	*
594	* @returns VBox status code suitable for EM.
595	* @param pVM VM handle.
596	* @param pVCpu VMCPU handle.
597	*/
598	static int emR3RawGuestTrap(PVM pVM, PVMCPU pVCpu)
599	{
600	PCPUMCTX pCtx = pVCpu->em.s.pCtx;
601
602	/*
603	* Get the trap info.
604	*/
605	uint8_t u8TrapNo;
606	TRPMEVENT enmType;
607	RTGCUINT uErrorCode;
608	RTGCUINTPTR uCR2;
609	int rc = TRPMQueryTrapAll(pVCpu, &u8TrapNo, &enmType, &uErrorCode, &uCR2);
610	if (RT_FAILURE(rc))
611	{
612	AssertReleaseMsgFailed(("No trap! (rc=%Rrc)\n", rc));
613	return rc;
614	}
615
616
617	#if 1 /* Experimental: Review, disable if it causes trouble. */
618	/*
619	* Handle traps in patch code first.
620	*
621	* We catch a few of these cases in RC before returning to R3 (#PF, #GP, #BP)
622	* but several traps isn't handled specially by TRPM in RC and we end up here
623	* instead. One example is #DE.
624	*/
625	uint32_t uCpl = CPUMGetGuestCPL(pVCpu, CPUMCTX2CORE(pCtx));
626	if ( uCpl == 0
627	&& PATMIsPatchGCAddr(pVM, (RTGCPTR)pCtx->eip))
628	{
629	LogFlow(("emR3RawGuestTrap: trap %#x in patch code; eip=%08x\n", u8TrapNo, pCtx->eip));
630	return emR3PatchTrap(pVM, pVCpu, pCtx, rc);
631	}
632	#endif
633
634	/*
635	* If the guest gate is marked unpatched, then we will check again if we can patch it.
636	* (This assumes that we've already tried and failed to dispatch the trap in
637	* RC for the gates that already has been patched. Which is true for most high
638	* volume traps, because these are handled specially, but not for odd ones like #DE.)
639	*/
640	if (TRPMR3GetGuestTrapHandler(pVM, u8TrapNo) == TRPM_INVALID_HANDLER)
641	{
642	CSAMR3CheckGates(pVM, u8TrapNo, 1);
643	Log(("emR3RawHandleRC: recheck gate %x -> valid=%d\n", u8TrapNo, TRPMR3GetGuestTrapHandler(pVM, u8TrapNo) != TRPM_INVALID_HANDLER));
644
645	/* If it was successful, then we could go back to raw mode. */
646	if (TRPMR3GetGuestTrapHandler(pVM, u8TrapNo) != TRPM_INVALID_HANDLER)
647	{
648	/* Must check pending forced actions as our IDT or GDT might be out of sync. */
649	rc = EMR3CheckRawForcedActions(pVM, pVCpu);
650	AssertRCReturn(rc, rc);
651
652	TRPMERRORCODE enmError = uErrorCode != ~0U
653	? TRPM_TRAP_HAS_ERRORCODE
654	: TRPM_TRAP_NO_ERRORCODE;
655	rc = TRPMForwardTrap(pVCpu, CPUMCTX2CORE(pCtx), u8TrapNo, uErrorCode, enmError, TRPM_TRAP, -1);
656	if (rc == VINF_SUCCESS /* Don't use RT_SUCCESS */)
657	{
658	TRPMResetTrap(pVCpu);
659	return VINF_EM_RESCHEDULE_RAW;
660	}
661	AssertMsg(rc == VINF_EM_RAW_GUEST_TRAP, ("%Rrc\n", rc));
662	}
663	}
664
665	/*
666	* Scan kernel code that traps; we might not get another chance.
667	*/
668	/** @todo move this up before the dispatching? */
669	if ( (pCtx->ss & X86_SEL_RPL) <= 1
670	&& !pCtx->eflags.Bits.u1VM)
671	{
672	Assert(!PATMIsPatchGCAddr(pVM, pCtx->eip));
673	CSAMR3CheckCodeEx(pVM, CPUMCTX2CORE(pCtx), pCtx->eip);
674	}
675
676	/*
677	* Trap specific handling.
678	*/
679	if (u8TrapNo == 6) /* (#UD) Invalid opcode. */
680	{
681	/*
682	* If MONITOR & MWAIT are supported, then interpret them here.
683	*/
684	DISCPUSTATE cpu;
685	rc = CPUMR3DisasmInstrCPU(pVM, pVCpu, pCtx, pCtx->rip, &cpu, "Guest Trap (#UD): ");
686	if ( RT_SUCCESS(rc)
687	&& (cpu.pCurInstr->opcode == OP_MONITOR \|\| cpu.pCurInstr->opcode == OP_MWAIT))
688	{
689	uint32_t u32Dummy, u32Features, u32ExtFeatures;
690	CPUMGetGuestCpuId(pVCpu, 1, &u32Dummy, &u32Dummy, &u32ExtFeatures, &u32Features);
691	if (u32ExtFeatures & X86_CPUID_FEATURE_ECX_MONITOR)
692	{
693	rc = TRPMResetTrap(pVCpu);
694	AssertRC(rc);
695
696	uint32_t opsize;
697	rc = EMInterpretInstructionCPU(pVM, pVCpu, &cpu, CPUMCTX2CORE(pCtx), 0, &opsize);
698	if (RT_SUCCESS(rc))
699	{
700	pCtx->rip += cpu.opsize;
701	return rc;
702	}
703	return emR3ExecuteInstruction(pVM, pVCpu, "Monitor: ");
704	}
705	}
706	}
707	else if (u8TrapNo == 13) /* (#GP) Privileged exception */
708	{
709	/*
710	* Handle I/O bitmap?
711	*/
712	/** @todo We're not supposed to be here with a false guest trap concerning
713	* I/O access. We can easily handle those in RC. */
714	DISCPUSTATE cpu;
715	rc = CPUMR3DisasmInstrCPU(pVM, pVCpu, pCtx, pCtx->rip, &cpu, "Guest Trap: ");
716	if ( RT_SUCCESS(rc)
717	&& (cpu.pCurInstr->optype & OPTYPE_PORTIO))
718	{
719	/*
720	* We should really check the TSS for the IO bitmap, but it's not like this
721	* lazy approach really makes things worse.
722	*/
723	rc = TRPMResetTrap(pVCpu);
724	AssertRC(rc);
725	return emR3ExecuteInstruction(pVM, pVCpu, "IO Guest Trap: ");
726	}
727	}
728
729	#ifdef LOG_ENABLED
730	DBGFR3InfoLog(pVM, "cpumguest", "Guest trap");
731	DBGFR3DisasInstrCurrentLog(pVCpu, "Guest trap");
732
733	/* Get guest page information. */
734	uint64_t fFlags = 0;
735	RTGCPHYS GCPhys = 0;
736	int rc2 = PGMGstGetPage(pVCpu, uCR2, &fFlags, &GCPhys);
737	Log(("emR3RawGuestTrap: cs:eip=%04x:%08x: trap=%02x err=%08x cr2=%08x cr0=%08x%s: Phys=%RGp fFlags=%08llx %s %s %s%s rc2=%d\n",
738	pCtx->cs, pCtx->eip, u8TrapNo, uErrorCode, uCR2, (uint32_t)pCtx->cr0, (enmType == TRPM_SOFTWARE_INT) ? " software" : "", GCPhys, fFlags,
739	fFlags & X86_PTE_P ? "P " : "NP", fFlags & X86_PTE_US ? "U" : "S",
740	fFlags & X86_PTE_RW ? "RW" : "R0", fFlags & X86_PTE_G ? " G" : "", rc2));
741	#endif
742
743	/*
744	* #PG has CR2.
745	* (Because of stuff like above we must set CR2 in a delayed fashion.)
746	*/
747	if (u8TrapNo == 14 /* #PG */)
748	pCtx->cr2 = uCR2;
749
750	return VINF_EM_RESCHEDULE_REM;
751	}
752
753
754	/**
755	* Handle a ring switch trap.
756	* Need to do statistics and to install patches. The result is going to REM.
757	*
758	* @returns VBox status code suitable for EM.
759	* @param pVM VM handle.
760	* @param pVCpu VMCPU handle.
761	*/
762	static int emR3RawRingSwitch(PVM pVM, PVMCPU pVCpu)
763	{
764	int rc;
765	DISCPUSTATE Cpu;
766	PCPUMCTX pCtx = pVCpu->em.s.pCtx;
767
768	/*
769	* sysenter, syscall & callgate
770	*/
771	rc = CPUMR3DisasmInstrCPU(pVM, pVCpu, pCtx, pCtx->rip, &Cpu, "RSWITCH: ");
772	if (RT_SUCCESS(rc))
773	{
774	if (Cpu.pCurInstr->opcode == OP_SYSENTER)
775	{
776	if (pCtx->SysEnter.cs != 0)
777	{
778	rc = PATMR3InstallPatch(pVM, SELMToFlat(pVM, DIS_SELREG_CS, CPUMCTX2CORE(pCtx), pCtx->eip),
779	(SELMGetCpuModeFromSelector(pVM, pCtx->eflags, pCtx->cs, &pCtx->csHid) == CPUMODE_32BIT) ? PATMFL_CODE32 : 0);
780	if (RT_SUCCESS(rc))
781	{
782	DBGFR3DisasInstrCurrentLog(pVCpu, "Patched sysenter instruction");
783	return VINF_EM_RESCHEDULE_RAW;
784	}
785	}
786	}
787
788	#ifdef VBOX_WITH_STATISTICS
789	switch (Cpu.pCurInstr->opcode)
790	{
791	case OP_SYSENTER:
792	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->StatSysEnter);
793	break;
794	case OP_SYSEXIT:
795	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->StatSysExit);
796	break;
797	case OP_SYSCALL:
798	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->StatSysCall);
799	break;
800	case OP_SYSRET:
801	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->StatSysRet);
802	break;
803	}
804	#endif
805	}
806	else
807	AssertRC(rc);
808
809	/* go to the REM to emulate a single instruction */
810	return emR3ExecuteInstruction(pVM, pVCpu, "RSWITCH: ");
811	}
812
813
814	/**
815	* Handle a trap (\#PF or \#GP) in patch code
816	*
817	* @returns VBox status code suitable for EM.
818	* @param pVM VM handle.
819	* @param pVCpu VMCPU handle.
820	* @param pCtx CPU context
821	* @param gcret GC return code
822	*/
823	static int emR3PatchTrap(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx, int gcret)
824	{
825	uint8_t u8TrapNo;
826	int rc;
827	TRPMEVENT enmType;
828	RTGCUINT uErrorCode;
829	RTGCUINTPTR uCR2;
830
831	Assert(PATMIsPatchGCAddr(pVM, pCtx->eip));
832
833	if (gcret == VINF_PATM_PATCH_INT3)
834	{
835	u8TrapNo = 3;
836	uCR2 = 0;
837	uErrorCode = 0;
838	}
839	else if (gcret == VINF_PATM_PATCH_TRAP_GP)
840	{
841	/* No active trap in this case. Kind of ugly. */
842	u8TrapNo = X86_XCPT_GP;
843	uCR2 = 0;
844	uErrorCode = 0;
845	}
846	else
847	{
848	rc = TRPMQueryTrapAll(pVCpu, &u8TrapNo, &enmType, &uErrorCode, &uCR2);
849	if (RT_FAILURE(rc))
850	{
851	AssertReleaseMsgFailed(("emR3PatchTrap: no trap! (rc=%Rrc) gcret=%Rrc\n", rc, gcret));
852	return rc;
853	}
854	/* Reset the trap as we'll execute the original instruction again. */
855	TRPMResetTrap(pVCpu);
856	}
857
858	/*
859	* Deal with traps inside patch code.
860	* (This code won't run outside GC.)
861	*/
862	if (u8TrapNo != 1)
863	{
864	#ifdef LOG_ENABLED
865	DBGFR3InfoLog(pVM, "cpumguest", "Trap in patch code");
866	DBGFR3DisasInstrCurrentLog(pVCpu, "Patch code");
867
868	DISCPUSTATE Cpu;
869	int rc;
870
871	rc = CPUMR3DisasmInstrCPU(pVM, pVCpu, pCtx, pCtx->eip, &Cpu, "Patch code: ");
872	if ( RT_SUCCESS(rc)
873	&& Cpu.pCurInstr->opcode == OP_IRET)
874	{
875	uint32_t eip, selCS, uEFlags;
876
877	/* Iret crashes are bad as we have already changed the flags on the stack */
878	rc = PGMPhysSimpleReadGCPtr(pVCpu, &eip, pCtx->esp, 4);
879	rc \|= PGMPhysSimpleReadGCPtr(pVCpu, &selCS, pCtx->esp+4, 4);
880	rc \|= PGMPhysSimpleReadGCPtr(pVCpu, &uEFlags, pCtx->esp+8, 4);
881	if (rc == VINF_SUCCESS)
882	{
883	if ( (uEFlags & X86_EFL_VM)
884	\|\| (selCS & X86_SEL_RPL) == 3)
885	{
886	uint32_t selSS, esp;
887
888	rc \|= PGMPhysSimpleReadGCPtr(pVCpu, &esp, pCtx->esp + 12, 4);
889	rc \|= PGMPhysSimpleReadGCPtr(pVCpu, &selSS, pCtx->esp + 16, 4);
890
891	if (uEFlags & X86_EFL_VM)
892	{
893	uint32_t selDS, selES, selFS, selGS;
894	rc = PGMPhysSimpleReadGCPtr(pVCpu, &selES, pCtx->esp + 20, 4);
895	rc \|= PGMPhysSimpleReadGCPtr(pVCpu, &selDS, pCtx->esp + 24, 4);
896	rc \|= PGMPhysSimpleReadGCPtr(pVCpu, &selFS, pCtx->esp + 28, 4);
897	rc \|= PGMPhysSimpleReadGCPtr(pVCpu, &selGS, pCtx->esp + 32, 4);
898	if (rc == VINF_SUCCESS)
899	{
900	Log(("Patch code: IRET->VM stack frame: return address %04X:%08RX32 eflags=%08x ss:esp=%04X:%08RX32\n", selCS, eip, uEFlags, selSS, esp));
901	Log(("Patch code: IRET->VM stack frame: DS=%04X ES=%04X FS=%04X GS=%04X\n", selDS, selES, selFS, selGS));
902	}
903	}
904	else
905	Log(("Patch code: IRET stack frame: return address %04X:%08RX32 eflags=%08x ss:esp=%04X:%08RX32\n", selCS, eip, uEFlags, selSS, esp));
906	}
907	else
908	Log(("Patch code: IRET stack frame: return address %04X:%08RX32 eflags=%08x\n", selCS, eip, uEFlags));
909	}
910	}
911	#endif /* LOG_ENABLED */
912	Log(("emR3PatchTrap: in patch: eip=%08x: trap=%02x err=%08x cr2=%08x cr0=%08x\n",
913	pCtx->eip, u8TrapNo, uErrorCode, uCR2, (uint32_t)pCtx->cr0));
914
915	RTGCPTR pNewEip;
916	rc = PATMR3HandleTrap(pVM, pCtx, pCtx->eip, &pNewEip);
917	switch (rc)
918	{
919	/*
920	* Execute the faulting instruction.
921	*/
922	case VINF_SUCCESS:
923	{
924	/** @todo execute a whole block */
925	Log(("emR3PatchTrap: Executing faulting instruction at new address %RGv\n", pNewEip));
926	if (!(pVCpu->em.s.pPatmGCState->uVMFlags & X86_EFL_IF))
927	Log(("emR3PatchTrap: Virtual IF flag disabled!!\n"));
928
929	pCtx->eip = pNewEip;
930	AssertRelease(pCtx->eip);
931
932	if (pCtx->eflags.Bits.u1IF)
933	{
934	/* Windows XP lets irets fault intentionally and then takes action based on the opcode; an
935	* int3 patch overwrites it and leads to blue screens. Remove the patch in this case.
936	*/
937	if ( u8TrapNo == X86_XCPT_GP
938	&& PATMIsInt3Patch(pVM, pCtx->eip, NULL, NULL))
939	{
940	/** @todo move to PATMR3HandleTrap */
941	Log(("Possible Windows XP iret fault at %08RX32\n", pCtx->eip));
942	PATMR3RemovePatch(pVM, pCtx->eip);
943	}
944
945	/** @todo Knoppix 5 regression when returning VINF_SUCCESS here and going back to raw mode. */
946	/* Note: possibly because a reschedule is required (e.g. iret to V86 code) */
947
948	return emR3ExecuteInstruction(pVM, pVCpu, "PATCHIR");
949	/* Interrupts are enabled; just go back to the original instruction.
950	return VINF_SUCCESS; */
951	}
952	return VINF_EM_RESCHEDULE_REM;
953	}
954
955	/*
956	* One instruction.
957	*/
958	case VINF_PATCH_EMULATE_INSTR:
959	Log(("emR3PatchTrap: Emulate patched instruction at %RGv IF=%d VMIF=%x\n",
960	pNewEip, pCtx->eflags.Bits.u1IF, pVCpu->em.s.pPatmGCState->uVMFlags));
961	pCtx->eip = pNewEip;
962	AssertRelease(pCtx->eip);
963	return emR3ExecuteInstruction(pVM, pVCpu, "PATCHEMUL: ");
964
965	/*
966	* The patch was disabled, hand it to the REM.
967	*/
968	case VERR_PATCH_DISABLED:
969	if (!(pVCpu->em.s.pPatmGCState->uVMFlags & X86_EFL_IF))
970	Log(("emR3PatchTrap: Virtual IF flag disabled!!\n"));
971	pCtx->eip = pNewEip;
972	AssertRelease(pCtx->eip);
973
974	if (pCtx->eflags.Bits.u1IF)
975	{
976	/*
977	* The last instruction in the patch block needs to be executed!! (sti/sysexit for example)
978	*/
979	Log(("PATCH: IF=1 -> emulate last instruction as it can't be interrupted!!\n"));
980	return emR3ExecuteInstruction(pVM, pVCpu, "PATCHIR");
981	}
982	return VINF_EM_RESCHEDULE_REM;
983
984	/* Force continued patch exection; usually due to write monitored stack. */
985	case VINF_PATCH_CONTINUE:
986	return VINF_SUCCESS;
987
988	/*
989	* Anything else is fatal.
990	*/
991	default:
992	AssertReleaseMsgFailed(("Unknown return code %Rrc from PATMR3HandleTrap!\n", rc));
993	return VERR_IPE_UNEXPECTED_STATUS;
994	}
995	}
996	return VINF_SUCCESS;
997	}
998
999
1000	/**
1001	* Handle a privileged instruction.
1002	*
1003	* @returns VBox status code suitable for EM.
1004	* @param pVM VM handle.
1005	* @param pVCpu VMCPU handle;
1006	*/
1007	static int emR3RawPrivileged(PVM pVM, PVMCPU pVCpu)
1008	{
1009	STAM_PROFILE_START(&pVCpu->em.s.StatPrivEmu, a);
1010	PCPUMCTX pCtx = pVCpu->em.s.pCtx;
1011
1012	Assert(!pCtx->eflags.Bits.u1VM);
1013
1014	if (PATMIsEnabled(pVM))
1015	{
1016	/*
1017	* Check if in patch code.
1018	*/
1019	if (PATMR3IsInsidePatchJump(pVM, pCtx->eip, NULL))
1020	{
1021	#ifdef LOG_ENABLED
1022	DBGFR3InfoLog(pVM, "cpumguest", "PRIV");
1023	#endif
1024	AssertMsgFailed(("FATAL ERROR: executing random instruction inside generated patch jump %08X\n", pCtx->eip));
1025	return VERR_EM_RAW_PATCH_CONFLICT;
1026	}
1027	if ( (pCtx->ss & X86_SEL_RPL) == 0
1028	&& !pCtx->eflags.Bits.u1VM
1029	&& !PATMIsPatchGCAddr(pVM, pCtx->eip))
1030	{
1031	int rc = PATMR3InstallPatch(pVM, SELMToFlat(pVM, DIS_SELREG_CS, CPUMCTX2CORE(pCtx), pCtx->eip),
1032	(SELMGetCpuModeFromSelector(pVM, pCtx->eflags, pCtx->cs, &pCtx->csHid) == CPUMODE_32BIT) ? PATMFL_CODE32 : 0);
1033	if (RT_SUCCESS(rc))
1034	{
1035	#ifdef LOG_ENABLED
1036	DBGFR3InfoLog(pVM, "cpumguest", "PRIV");
1037	#endif
1038	DBGFR3DisasInstrCurrentLog(pVCpu, "Patched privileged instruction");
1039	return VINF_SUCCESS;
1040	}
1041	}
1042	}
1043
1044	#ifdef LOG_ENABLED
1045	if (!PATMIsPatchGCAddr(pVM, pCtx->eip))
1046	{
1047	DBGFR3InfoLog(pVM, "cpumguest", "PRIV");
1048	DBGFR3DisasInstrCurrentLog(pVCpu, "Privileged instr: ");
1049	}
1050	#endif
1051
1052	/*
1053	* Instruction statistics and logging.
1054	*/
1055	DISCPUSTATE Cpu;
1056	int rc;
1057
1058	rc = CPUMR3DisasmInstrCPU(pVM, pVCpu, pCtx, pCtx->rip, &Cpu, "PRIV: ");
1059	if (RT_SUCCESS(rc))
1060	{
1061	#ifdef VBOX_WITH_STATISTICS
1062	PEMSTATS pStats = pVCpu->em.s.CTX_SUFF(pStats);
1063	switch (Cpu.pCurInstr->opcode)
1064	{
1065	case OP_INVLPG:
1066	STAM_COUNTER_INC(&pStats->StatInvlpg);
1067	break;
1068	case OP_IRET:
1069	STAM_COUNTER_INC(&pStats->StatIret);
1070	break;
1071	case OP_CLI:
1072	STAM_COUNTER_INC(&pStats->StatCli);
1073	emR3RecordCli(pVM, pVCpu, pCtx->rip);
1074	break;
1075	case OP_STI:
1076	STAM_COUNTER_INC(&pStats->StatSti);
1077	break;
1078	case OP_INSB:
1079	case OP_INSWD:
1080	case OP_IN:
1081	case OP_OUTSB:
1082	case OP_OUTSWD:
1083	case OP_OUT:
1084	AssertMsgFailed(("Unexpected privileged exception due to port IO\n"));
1085	break;
1086
1087	case OP_MOV_CR:
1088	if (Cpu.param1.flags & USE_REG_GEN32)
1089	{
1090	//read
1091	Assert(Cpu.param2.flags & USE_REG_CR);
1092	Assert(Cpu.param2.base.reg_ctrl <= USE_REG_CR4);
1093	STAM_COUNTER_INC(&pStats->StatMovReadCR[Cpu.param2.base.reg_ctrl]);
1094	}
1095	else
1096	{
1097	//write
1098	Assert(Cpu.param1.flags & USE_REG_CR);
1099	Assert(Cpu.param1.base.reg_ctrl <= USE_REG_CR4);
1100	STAM_COUNTER_INC(&pStats->StatMovWriteCR[Cpu.param1.base.reg_ctrl]);
1101	}
1102	break;
1103
1104	case OP_MOV_DR:
1105	STAM_COUNTER_INC(&pStats->StatMovDRx);
1106	break;
1107	case OP_LLDT:
1108	STAM_COUNTER_INC(&pStats->StatMovLldt);
1109	break;
1110	case OP_LIDT:
1111	STAM_COUNTER_INC(&pStats->StatMovLidt);
1112	break;
1113	case OP_LGDT:
1114	STAM_COUNTER_INC(&pStats->StatMovLgdt);
1115	break;
1116	case OP_SYSENTER:
1117	STAM_COUNTER_INC(&pStats->StatSysEnter);
1118	break;
1119	case OP_SYSEXIT:
1120	STAM_COUNTER_INC(&pStats->StatSysExit);
1121	break;
1122	case OP_SYSCALL:
1123	STAM_COUNTER_INC(&pStats->StatSysCall);
1124	break;
1125	case OP_SYSRET:
1126	STAM_COUNTER_INC(&pStats->StatSysRet);
1127	break;
1128	case OP_HLT:
1129	STAM_COUNTER_INC(&pStats->StatHlt);
1130	break;
1131	default:
1132	STAM_COUNTER_INC(&pStats->StatMisc);
1133	Log4(("emR3RawPrivileged: opcode=%d\n", Cpu.pCurInstr->opcode));
1134	break;
1135	}
1136	#endif /* VBOX_WITH_STATISTICS */
1137	if ( (pCtx->ss & X86_SEL_RPL) == 0
1138	&& !pCtx->eflags.Bits.u1VM
1139	&& SELMGetCpuModeFromSelector(pVM, pCtx->eflags, pCtx->cs, &pCtx->csHid) == CPUMODE_32BIT)
1140	{
1141	uint32_t size;
1142
1143	STAM_PROFILE_START(&pVCpu->em.s.StatPrivEmu, a);
1144	switch (Cpu.pCurInstr->opcode)
1145	{
1146	case OP_CLI:
1147	pCtx->eflags.u32 &= ~X86_EFL_IF;
1148	Assert(Cpu.opsize == 1);
1149	pCtx->rip += Cpu.opsize;
1150	STAM_PROFILE_STOP(&pVCpu->em.s.StatPrivEmu, a);
1151	return VINF_EM_RESCHEDULE_REM; /* must go to the recompiler now! */
1152
1153	case OP_STI:
1154	pCtx->eflags.u32 \|= X86_EFL_IF;
1155	EMSetInhibitInterruptsPC(pVCpu, pCtx->rip + Cpu.opsize);
1156	Assert(Cpu.opsize == 1);
1157	pCtx->rip += Cpu.opsize;
1158	STAM_PROFILE_STOP(&pVCpu->em.s.StatPrivEmu, a);
1159	return VINF_SUCCESS;
1160
1161	case OP_HLT:
1162	if (PATMIsPatchGCAddr(pVM, (RTGCPTR)pCtx->eip))
1163	{
1164	PATMTRANSSTATE enmState;
1165	RTGCPTR pOrgInstrGC = PATMR3PatchToGCPtr(pVM, pCtx->eip, &enmState);
1166
1167	if (enmState == PATMTRANS_OVERWRITTEN)
1168	{
1169	rc = PATMR3DetectConflict(pVM, pOrgInstrGC, pOrgInstrGC);
1170	Assert(rc == VERR_PATCH_DISABLED);
1171	/* Conflict detected, patch disabled */
1172	Log(("emR3RawPrivileged: detected conflict -> disabled patch at %08RX32\n", pCtx->eip));
1173
1174	enmState = PATMTRANS_SAFE;
1175	}
1176
1177	/* The translation had better be successful. Otherwise we can't recover. */
1178	AssertReleaseMsg(pOrgInstrGC && enmState != PATMTRANS_OVERWRITTEN, ("Unable to translate instruction address at %08RX32\n", pCtx->eip));
1179	if (enmState != PATMTRANS_OVERWRITTEN)
1180	pCtx->eip = pOrgInstrGC;
1181	}
1182	/* no break; we could just return VINF_EM_HALT here */
1183
1184	case OP_MOV_CR:
1185	case OP_MOV_DR:
1186	#ifdef LOG_ENABLED
1187	if (PATMIsPatchGCAddr(pVM, pCtx->eip))
1188	{
1189	DBGFR3InfoLog(pVM, "cpumguest", "PRIV");
1190	DBGFR3DisasInstrCurrentLog(pVCpu, "Privileged instr: ");
1191	}
1192	#endif
1193
1194	rc = EMInterpretInstructionCPU(pVM, pVCpu, &Cpu, CPUMCTX2CORE(pCtx), 0, &size);
1195	if (RT_SUCCESS(rc))
1196	{
1197	pCtx->rip += Cpu.opsize;
1198	STAM_PROFILE_STOP(&pVCpu->em.s.StatPrivEmu, a);
1199
1200	if ( Cpu.pCurInstr->opcode == OP_MOV_CR
1201	&& Cpu.param1.flags == USE_REG_CR /* write */
1202	)
1203	{
1204	/* Deal with CR0 updates inside patch code that force
1205	* us to go to the recompiler.
1206	*/
1207	if ( PATMIsPatchGCAddr(pVM, pCtx->rip)
1208	&& (pCtx->cr0 & (X86_CR0_WP\|X86_CR0_PG\|X86_CR0_PE)) != (X86_CR0_WP\|X86_CR0_PG\|X86_CR0_PE))
1209	{
1210	PATMTRANSSTATE enmState;
1211	RTGCPTR pOrgInstrGC = PATMR3PatchToGCPtr(pVM, pCtx->rip, &enmState);
1212
1213	Log(("Force recompiler switch due to cr0 (%RGp) update rip=%RGv -> %RGv (enmState=%d)\n", pCtx->cr0, pCtx->rip, pOrgInstrGC, enmState));
1214	if (enmState == PATMTRANS_OVERWRITTEN)
1215	{
1216	rc = PATMR3DetectConflict(pVM, pOrgInstrGC, pOrgInstrGC);
1217	Assert(rc == VERR_PATCH_DISABLED);
1218	/* Conflict detected, patch disabled */
1219	Log(("emR3RawPrivileged: detected conflict -> disabled patch at %RGv\n", (RTGCPTR)pCtx->rip));
1220	enmState = PATMTRANS_SAFE;
1221	}
1222	/* The translation had better be successful. Otherwise we can't recover. */
1223	AssertReleaseMsg(pOrgInstrGC && enmState != PATMTRANS_OVERWRITTEN, ("Unable to translate instruction address at %RGv\n", (RTGCPTR)pCtx->rip));
1224	if (enmState != PATMTRANS_OVERWRITTEN)
1225	pCtx->rip = pOrgInstrGC;
1226	}
1227
1228	/* Reschedule is necessary as the execution/paging mode might have changed. */
1229	return VINF_EM_RESCHEDULE;
1230	}
1231	return rc; /* can return VINF_EM_HALT as well. */
1232	}
1233	AssertMsgReturn(rc == VERR_EM_INTERPRETER, ("%Rrc\n", rc), rc);
1234	break; /* fall back to the recompiler */
1235	}
1236	STAM_PROFILE_STOP(&pVCpu->em.s.StatPrivEmu, a);
1237	}
1238	}
1239
1240	if (PATMIsPatchGCAddr(pVM, pCtx->eip))
1241	return emR3PatchTrap(pVM, pVCpu, pCtx, VINF_PATM_PATCH_TRAP_GP);
1242
1243	return emR3ExecuteInstruction(pVM, pVCpu, "PRIV");
1244	}
1245
1246
1247	/**
1248	* Update the forced rawmode execution modifier.
1249	*
1250	* This function is called when we're returning from the raw-mode loop(s). If we're
1251	* in patch code, it will set a flag forcing execution to be resumed in raw-mode,
1252	* if not in patch code, the flag will be cleared.
1253	*
1254	* We should never interrupt patch code while it's being executed. Cli patches can
1255	* contain big code blocks, but they are always executed with IF=0. Other patches
1256	* replace single instructions and should be atomic.
1257	*
1258	* @returns Updated rc.
1259	*
1260	* @param pVM The VM handle.
1261	* @param pVCpu The VMCPU handle.
1262	* @param pCtx The guest CPU context.
1263	* @param rc The result code.
1264	*/
1265	int emR3RawUpdateForceFlag(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx, int rc)
1266	{
1267	if (PATMIsPatchGCAddr(pVM, pCtx->eip)) /** @todo check cs selector base/type */
1268	{
1269	/* ignore reschedule attempts. */
1270	switch (rc)
1271	{
1272	case VINF_EM_RESCHEDULE:
1273	case VINF_EM_RESCHEDULE_REM:
1274	LogFlow(("emR3RawUpdateForceFlag: patch address -> force raw reschedule\n"));
1275	rc = VINF_SUCCESS;
1276	break;
1277	}
1278	pVCpu->em.s.fForceRAW = true;
1279	}
1280	else
1281	pVCpu->em.s.fForceRAW = false;
1282	return rc;
1283	}
1284
1285
1286	/**
1287	* Check for pending raw actions
1288	*
1289	* @returns VBox status code. May return VINF_EM_NO_MEMORY but none of the other
1290	* EM statuses.
1291	* @param pVM The VM to operate on.
1292	* @param pVCpu The VMCPU handle.
1293	*/
1294	VMMR3DECL(int) EMR3CheckRawForcedActions(PVM pVM, PVMCPU pVCpu)
1295	{
1296	return emR3RawForcedActions(pVM, pVCpu, pVCpu->em.s.pCtx);
1297	}
1298
1299
1300	/**
1301	* Process raw-mode specific forced actions.
1302	*
1303	* This function is called when any FFs in the VM_FF_HIGH_PRIORITY_PRE_RAW_MASK is pending.
1304	*
1305	* @returns VBox status code. May return VINF_EM_NO_MEMORY but none of the other
1306	* EM statuses.
1307	* @param pVM The VM handle.
1308	* @param pVCpu The VMCPU handle.
1309	* @param pCtx The guest CPUM register context.
1310	*/
1311	static int emR3RawForcedActions(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx)
1312	{
1313	/*
1314	* Note that the order is vitally important!
1315	* Also note that SELMR3UpdateFromCPUM may trigger VM_FF_SELM_SYNC_TSS.
1316	*/
1317
1318
1319	/*
1320	* Sync selector tables.
1321	*/
1322	if (VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_SELM_SYNC_GDT \| VMCPU_FF_SELM_SYNC_LDT))
1323	{
1324	int rc = SELMR3UpdateFromCPUM(pVM, pVCpu);
1325	if (RT_FAILURE(rc))
1326	return rc;
1327	}
1328
1329	/*
1330	* Sync IDT.
1331	*
1332	* The CSAMR3CheckGates call in TRPMR3SyncIDT may call PGMPrefetchPage
1333	* and PGMShwModifyPage, so we're in for trouble if for instance a
1334	* PGMSyncCR3+pgmR3PoolClearAll is pending.
1335	*/
1336	if (VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_TRPM_SYNC_IDT))
1337	{
1338	if ( VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_PGM_SYNC_CR3)
1339	&& EMIsRawRing0Enabled(pVM)
1340	&& CSAMIsEnabled(pVM))
1341	{
1342	int rc = PGMSyncCR3(pVCpu, pCtx->cr0, pCtx->cr3, pCtx->cr4, VMCPU_FF_ISSET(pVCpu, VMCPU_FF_PGM_SYNC_CR3));
1343	if (RT_FAILURE(rc))
1344	return rc;
1345	}
1346
1347	int rc = TRPMR3SyncIDT(pVM, pVCpu);
1348	if (RT_FAILURE(rc))
1349	return rc;
1350	}
1351
1352	/*
1353	* Sync TSS.
1354	*/
1355	if (VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_SELM_SYNC_TSS))
1356	{
1357	int rc = SELMR3SyncTSS(pVM, pVCpu);
1358	if (RT_FAILURE(rc))
1359	return rc;
1360	}
1361
1362	/*
1363	* Sync page directory.
1364	*/
1365	if (VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_PGM_SYNC_CR3 \| VMCPU_FF_PGM_SYNC_CR3_NON_GLOBAL))
1366	{
1367	Assert(pVCpu->em.s.enmState != EMSTATE_WAIT_SIPI);
1368	int rc = PGMSyncCR3(pVCpu, pCtx->cr0, pCtx->cr3, pCtx->cr4, VMCPU_FF_ISSET(pVCpu, VMCPU_FF_PGM_SYNC_CR3));
1369	if (RT_FAILURE(rc))
1370	return rc;
1371
1372	Assert(!VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_SELM_SYNC_GDT \| VMCPU_FF_SELM_SYNC_LDT));
1373
1374	/* Prefetch pages for EIP and ESP. */
1375	/** @todo This is rather expensive. Should investigate if it really helps at all. */
1376	rc = PGMPrefetchPage(pVCpu, SELMToFlat(pVM, DIS_SELREG_CS, CPUMCTX2CORE(pCtx), pCtx->rip));
1377	if (rc == VINF_SUCCESS)
1378	rc = PGMPrefetchPage(pVCpu, SELMToFlat(pVM, DIS_SELREG_SS, CPUMCTX2CORE(pCtx), pCtx->rsp));
1379	if (rc != VINF_SUCCESS)
1380	{
1381	if (rc != VINF_PGM_SYNC_CR3)
1382	{
1383	AssertLogRelMsgReturn(RT_FAILURE(rc), ("%Rrc\n", rc), VERR_IPE_UNEXPECTED_INFO_STATUS);
1384	return rc;
1385	}
1386	rc = PGMSyncCR3(pVCpu, pCtx->cr0, pCtx->cr3, pCtx->cr4, VMCPU_FF_ISSET(pVCpu, VMCPU_FF_PGM_SYNC_CR3));
1387	if (RT_FAILURE(rc))
1388	return rc;
1389	}
1390	/** @todo maybe prefetch the supervisor stack page as well */
1391	Assert(!VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_SELM_SYNC_GDT \| VMCPU_FF_SELM_SYNC_LDT));
1392	}
1393
1394	/*
1395	* Allocate handy pages (just in case the above actions have consumed some pages).
1396	*/
1397	if (VM_FF_IS_PENDING_EXCEPT(pVM, VM_FF_PGM_NEED_HANDY_PAGES, VM_FF_PGM_NO_MEMORY))
1398	{
1399	int rc = PGMR3PhysAllocateHandyPages(pVM);
1400	if (RT_FAILURE(rc))
1401	return rc;
1402	}
1403
1404	/*
1405	* Check whether we're out of memory now.
1406	*
1407	* This may stem from some of the above actions or operations that has been executed
1408	* since we ran FFs. The allocate handy pages must for instance always be followed by
1409	* this check.
1410	*/
1411	if (VM_FF_ISPENDING(pVM, VM_FF_PGM_NO_MEMORY))
1412	return VINF_EM_NO_MEMORY;
1413
1414	return VINF_SUCCESS;
1415	}
1416
1417
1418	/**
1419	* Executes raw code.
1420	*
1421	* This function contains the raw-mode version of the inner
1422	* execution loop (the outer loop being in EMR3ExecuteVM()).
1423	*
1424	* @returns VBox status code. The most important ones are: VINF_EM_RESCHEDULE,
1425	* VINF_EM_RESCHEDULE_REM, VINF_EM_SUSPEND, VINF_EM_RESET and VINF_EM_TERMINATE.
1426	*
1427	* @param pVM VM handle.
1428	* @param pVCpu VMCPU handle.
1429	* @param pfFFDone Where to store an indicator telling whether or not
1430	* FFs were done before returning.
1431	*/
1432	int emR3RawExecute(PVM pVM, PVMCPU pVCpu, bool *pfFFDone)
1433	{
1434	STAM_REL_PROFILE_ADV_START(&pVCpu->em.s.StatRAWTotal, a);
1435
1436	int rc = VERR_INTERNAL_ERROR;
1437	PCPUMCTX pCtx = pVCpu->em.s.pCtx;
1438	LogFlow(("emR3RawExecute: (cs:eip=%04x:%08x)\n", pCtx->cs, pCtx->eip));
1439	pVCpu->em.s.fForceRAW = false;
1440	*pfFFDone = false;
1441
1442
1443	/*
1444	*
1445	* Spin till we get a forced action or raw mode status code resulting in
1446	* in anything but VINF_SUCCESS or VINF_EM_RESCHEDULE_RAW.
1447	*
1448	*/
1449	for (;;)
1450	{
1451	STAM_PROFILE_ADV_START(&pVCpu->em.s.StatRAWEntry, b);
1452
1453	/*
1454	* Check various preconditions.
1455	*/
1456	#ifdef VBOX_STRICT
1457	Assert(REMR3QueryPendingInterrupt(pVM, pVCpu) == REM_NO_PENDING_IRQ);
1458	Assert(pCtx->eflags.Bits.u1VM \|\| (pCtx->ss & X86_SEL_RPL) == 3 \|\| (pCtx->ss & X86_SEL_RPL) == 0);
1459	AssertMsg( (pCtx->eflags.u32 & X86_EFL_IF)
1460	\|\| PATMShouldUseRawMode(pVM, (RTGCPTR)pCtx->eip),
1461	("Tried to execute code with IF at EIP=%08x!\n", pCtx->eip));
1462	if ( !VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_PGM_SYNC_CR3 \| VMCPU_FF_PGM_SYNC_CR3_NON_GLOBAL)
1463	&& PGMMapHasConflicts(pVM))
1464	{
1465	PGMMapCheck(pVM);
1466	AssertMsgFailed(("We should not get conflicts any longer!!!\n"));
1467	return VERR_INTERNAL_ERROR;
1468	}
1469	#endif /* VBOX_STRICT */
1470
1471	/*
1472	* Process high priority pre-execution raw-mode FFs.
1473	*/
1474	if ( VM_FF_ISPENDING(pVM, VM_FF_HIGH_PRIORITY_PRE_RAW_MASK)
1475	\|\| VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_HIGH_PRIORITY_PRE_RAW_MASK))
1476	{
1477	rc = emR3RawForcedActions(pVM, pVCpu, pCtx);
1478	if (rc != VINF_SUCCESS)
1479	break;
1480	}
1481
1482	/*
1483	* If we're going to execute ring-0 code, the guest state needs to
1484	* be modified a bit and some of the state components (IF, SS/CS RPL,
1485	* and perhaps EIP) needs to be stored with PATM.
1486	*/
1487	rc = CPUMRawEnter(pVCpu, NULL);
1488	if (rc != VINF_SUCCESS)
1489	{
1490	STAM_PROFILE_ADV_STOP(&pVCpu->em.s.StatRAWEntry, b);
1491	break;
1492	}
1493
1494	/*
1495	* Scan code before executing it. Don't bother with user mode or V86 code
1496	*/
1497	if ( (pCtx->ss & X86_SEL_RPL) <= 1
1498	&& !pCtx->eflags.Bits.u1VM
1499	&& !PATMIsPatchGCAddr(pVM, pCtx->eip))
1500	{
1501	STAM_PROFILE_ADV_SUSPEND(&pVCpu->em.s.StatRAWEntry, b);
1502	CSAMR3CheckCodeEx(pVM, CPUMCTX2CORE(pCtx), pCtx->eip);
1503	STAM_PROFILE_ADV_RESUME(&pVCpu->em.s.StatRAWEntry, b);
1504	if ( VM_FF_ISPENDING(pVM, VM_FF_HIGH_PRIORITY_PRE_RAW_MASK)
1505	\|\| VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_HIGH_PRIORITY_PRE_RAW_MASK))
1506	{
1507	rc = emR3RawForcedActions(pVM, pVCpu, pCtx);
1508	if (rc != VINF_SUCCESS)
1509	{
1510	rc = CPUMRawLeave(pVCpu, NULL, rc);
1511	break;
1512	}
1513	}
1514	}
1515
1516	#ifdef LOG_ENABLED
1517	/*
1518	* Log important stuff before entering GC.
1519	*/
1520	PPATMGCSTATE pGCState = PATMR3QueryGCStateHC(pVM);
1521	if (pCtx->eflags.Bits.u1VM)
1522	Log(("RV86: %04X:%08X IF=%d VMFlags=%x\n", pCtx->cs, pCtx->eip, pCtx->eflags.Bits.u1IF, pGCState->uVMFlags));
1523	else if ((pCtx->ss & X86_SEL_RPL) == 1)
1524	{
1525	bool fCSAMScanned = CSAMIsPageScanned(pVM, (RTGCPTR)pCtx->eip);
1526	Log(("RR0: %08X ESP=%08X IF=%d VMFlags=%x PIF=%d CPL=%d (Scanned=%d)\n", pCtx->eip, pCtx->esp, pCtx->eflags.Bits.u1IF, pGCState->uVMFlags, pGCState->fPIF, (pCtx->ss & X86_SEL_RPL), fCSAMScanned));
1527	}
1528	else if ((pCtx->ss & X86_SEL_RPL) == 3)
1529	Log(("RR3: %08X ESP=%08X IF=%d VMFlags=%x\n", pCtx->eip, pCtx->esp, pCtx->eflags.Bits.u1IF, pGCState->uVMFlags));
1530	#endif /* LOG_ENABLED */
1531
1532
1533
1534	/*
1535	* Execute the code.
1536	*/
1537	STAM_PROFILE_ADV_STOP(&pVCpu->em.s.StatRAWEntry, b);
1538	STAM_PROFILE_START(&pVCpu->em.s.StatRAWExec, c);
1539	rc = VMMR3RawRunGC(pVM, pVCpu);
1540	STAM_PROFILE_STOP(&pVCpu->em.s.StatRAWExec, c);
1541	STAM_PROFILE_ADV_START(&pVCpu->em.s.StatRAWTail, d);
1542
1543	LogFlow(("RR0-E: %08X ESP=%08X IF=%d VMFlags=%x PIF=%d CPL=%d\n", pCtx->eip, pCtx->esp, pCtx->eflags.Bits.u1IF, pGCState->uVMFlags, pGCState->fPIF, (pCtx->ss & X86_SEL_RPL)));
1544	LogFlow(("VMMR3RawRunGC returned %Rrc\n", rc));
1545
1546
1547
1548	/*
1549	* Restore the real CPU state and deal with high priority post
1550	* execution FFs before doing anything else.
1551	*/
1552	rc = CPUMRawLeave(pVCpu, NULL, rc);
1553	VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_RESUME_GUEST_MASK);
1554	if ( VM_FF_ISPENDING(pVM, VM_FF_HIGH_PRIORITY_POST_MASK)
1555	\|\| VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_HIGH_PRIORITY_POST_MASK))
1556	rc = emR3HighPriorityPostForcedActions(pVM, pVCpu, rc);
1557
1558	#ifdef VBOX_STRICT
1559	/*
1560	* Assert TSS consistency & rc vs patch code.
1561	*/
1562	if ( !VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_SELM_SYNC_TSS \| VMCPU_FF_SELM_SYNC_GDT) /* GDT implies TSS at the moment. */
1563	&& EMIsRawRing0Enabled(pVM))
1564	SELMR3CheckTSS(pVM);
1565	switch (rc)
1566	{
1567	case VINF_SUCCESS:
1568	case VINF_EM_RAW_INTERRUPT:
1569	case VINF_PATM_PATCH_TRAP_PF:
1570	case VINF_PATM_PATCH_TRAP_GP:
1571	case VINF_PATM_PATCH_INT3:
1572	case VINF_PATM_CHECK_PATCH_PAGE:
1573	case VINF_EM_RAW_EXCEPTION_PRIVILEGED:
1574	case VINF_EM_RAW_GUEST_TRAP:
1575	case VINF_EM_RESCHEDULE_RAW:
1576	break;
1577
1578	default:
1579	if (PATMIsPatchGCAddr(pVM, pCtx->eip) && !(pCtx->eflags.u32 & X86_EFL_TF))
1580	LogIt(NULL, 0, LOG_GROUP_PATM, ("Patch code interrupted at %RRv for reason %Rrc\n", (RTRCPTR)CPUMGetGuestEIP(pVCpu), rc));
1581	break;
1582	}
1583	/*
1584	* Let's go paranoid!
1585	*/
1586	if ( !VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_PGM_SYNC_CR3 \| VMCPU_FF_PGM_SYNC_CR3_NON_GLOBAL)
1587	&& PGMMapHasConflicts(pVM))
1588	{
1589	PGMMapCheck(pVM);
1590	AssertMsgFailed(("We should not get conflicts any longer!!! rc=%Rrc\n", rc));
1591	return VERR_INTERNAL_ERROR;
1592	}
1593	#endif /* VBOX_STRICT */
1594
1595	/*
1596	* Process the returned status code.
1597	*/
1598	if (rc >= VINF_EM_FIRST && rc <= VINF_EM_LAST)
1599	{
1600	STAM_PROFILE_ADV_STOP(&pVCpu->em.s.StatRAWTail, d);
1601	break;
1602	}
1603	rc = emR3RawHandleRC(pVM, pVCpu, pCtx, rc);
1604	if (rc != VINF_SUCCESS)
1605	{
1606	rc = emR3RawUpdateForceFlag(pVM, pVCpu, pCtx, rc);
1607	if (rc != VINF_SUCCESS)
1608	{
1609	STAM_PROFILE_ADV_STOP(&pVCpu->em.s.StatRAWTail, d);
1610	break;
1611	}
1612	}
1613
1614	/*
1615	* Check and execute forced actions.
1616	*/
1617	#ifdef VBOX_HIGH_RES_TIMERS_HACK
1618	TMTimerPollVoid(pVM, pVCpu);
1619	#endif
1620	STAM_PROFILE_ADV_STOP(&pVCpu->em.s.StatRAWTail, d);
1621	if ( VM_FF_ISPENDING(pVM, ~VM_FF_HIGH_PRIORITY_PRE_RAW_MASK \| VM_FF_PGM_NO_MEMORY)
1622	\|\| VMCPU_FF_ISPENDING(pVCpu, ~VMCPU_FF_HIGH_PRIORITY_PRE_RAW_MASK))
1623	{
1624	Assert(pCtx->eflags.Bits.u1VM \|\| (pCtx->ss & X86_SEL_RPL) != 1);
1625
1626	STAM_REL_PROFILE_ADV_SUSPEND(&pVCpu->em.s.StatRAWTotal, a);
1627	rc = emR3ForcedActions(pVM, pVCpu, rc);
1628	STAM_REL_PROFILE_ADV_RESUME(&pVCpu->em.s.StatRAWTotal, a);
1629	if ( rc != VINF_SUCCESS
1630	&& rc != VINF_EM_RESCHEDULE_RAW)
1631	{
1632	rc = emR3RawUpdateForceFlag(pVM, pVCpu, pCtx, rc);
1633	if (rc != VINF_SUCCESS)
1634	{
1635	*pfFFDone = true;
1636	break;
1637	}
1638	}
1639	}
1640	}
1641
1642	/*
1643	* Return to outer loop.
1644	*/
1645	#if defined(LOG_ENABLED) && defined(DEBUG)
1646	RTLogFlush(NULL);
1647	#endif
1648	STAM_REL_PROFILE_ADV_STOP(&pVCpu->em.s.StatRAWTotal, a);
1649	return rc;
1650	}
1651

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

source: vbox/trunk/src/VBox/VMM/EMRaw.cpp@ 24911

Download in other formats: