VirtualBox

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

Last change on this file since 24912 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*******************************************************************************/
81static int emR3RawForcedActions(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx);
82DECLINLINE(int) emR3ExecuteInstruction(PVM pVM, PVMCPU pVCpu, const char *pszPrefix, int rcGC = VINF_SUCCESS);
83static int emR3RawGuestTrap(PVM pVM, PVMCPU pVCpu);
84static int emR3PatchTrap(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx, int gcret);
85static int emR3SingleStepExecRem(PVM pVM, uint32_t cIterations);
86static int emR3RawPrivileged(PVM pVM, PVMCPU pVCpu);
87static int emR3ExecuteIOInstruction(PVM pVM, PVMCPU pVCpu);
88static 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 */
104VMMR3DECL(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 */
142static 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 */
180int 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 */
214int 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
289int 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
325static int emR3ExecuteInstructionWorker(PVM pVM, PVMCPU pVCpu, int rcGC, const char *pszPrefix)
326#else
327static 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 */
488DECLINLINE(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 */
504static 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 */
598static 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 */
762static 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 */
823static 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 */
1007static 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 */
1265int 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 */
1294VMMR3DECL(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 */
1311static 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 */
1432int 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.

© 2023 Oracle
ContactPrivacy policyTerms of Use