VirtualBox

source: vbox/trunk/src/VBox/VMM/VMMAll/EMAll.cpp@ 26600

Last change on this file since 26600 was 26273, checked in by vboxsync, 15 years ago

VMM: more RC/GC warnings.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 115.9 KB
Line 
1/* $Id: EMAll.cpp 26273 2010-02-05 04:24:36Z vboxsync $ */
2/** @file
3 * EM - Execution Monitor(/Manager) - All contexts
4 */
5
6/*
7 * Copyright (C) 2006-2007 Sun Microsystems, Inc.
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18 * Clara, CA 95054 USA or visit http://www.sun.com if you need
19 * additional information or have any questions.
20 */
21
22/*******************************************************************************
23* Header Files *
24*******************************************************************************/
25#define LOG_GROUP LOG_GROUP_EM
26#include <VBox/em.h>
27#include <VBox/mm.h>
28#include <VBox/selm.h>
29#include <VBox/patm.h>
30#include <VBox/csam.h>
31#include <VBox/pgm.h>
32#include <VBox/iom.h>
33#include <VBox/stam.h>
34#include "EMInternal.h"
35#include <VBox/vm.h>
36#include <VBox/vmm.h>
37#include <VBox/hwaccm.h>
38#include <VBox/tm.h>
39#include <VBox/pdmapi.h>
40
41#include <VBox/param.h>
42#include <VBox/err.h>
43#include <VBox/dis.h>
44#include <VBox/disopcode.h>
45#include <VBox/log.h>
46#include <iprt/assert.h>
47#include <iprt/asm.h>
48#include <iprt/string.h>
49
50
51/*******************************************************************************
52* Defined Constants And Macros *
53*******************************************************************************/
54/** @def EM_ASSERT_FAULT_RETURN
55 * Safety check.
56 *
57 * Could in theory misfire on a cross page boundary access...
58 *
59 * Currently disabled because the CSAM (+ PATM) patch monitoring occasionally
60 * turns up an alias page instead of the original faulting one and annoying the
61 * heck out of anyone running a debug build. See @bugref{2609} and @bugref{1931}.
62 */
63#if 0
64# define EM_ASSERT_FAULT_RETURN(expr, rc) AssertReturn(expr, rc)
65#else
66# define EM_ASSERT_FAULT_RETURN(expr, rc) do { } while (0)
67#endif
68
69/* Used to pass information during instruction disassembly. */
70typedef struct
71{
72 PVM pVM;
73 PVMCPU pVCpu;
74 RTGCPTR GCPtr;
75 uint8_t aOpcode[8];
76} EMDISSTATE, *PEMDISSTATE;
77
78/*******************************************************************************
79* Internal Functions *
80*******************************************************************************/
81DECLINLINE(int) emInterpretInstructionCPU(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize);
82
83
84
85/**
86 * Get the current execution manager status.
87 *
88 * @returns Current status.
89 * @param pVCpu The VMCPU to operate on.
90 */
91VMMDECL(EMSTATE) EMGetState(PVMCPU pVCpu)
92{
93 return pVCpu->em.s.enmState;
94}
95
96/**
97 * Sets the current execution manager status. (use only when you know what you're doing!)
98 *
99 * @param pVCpu The VMCPU to operate on.
100 */
101VMMDECL(void) EMSetState(PVMCPU pVCpu, EMSTATE enmNewState)
102{
103 /* Only allowed combination: */
104 Assert(pVCpu->em.s.enmState == EMSTATE_WAIT_SIPI && enmNewState == EMSTATE_HALTED);
105 pVCpu->em.s.enmState = enmNewState;
106}
107
108
109/**
110 * Read callback for disassembly function; supports reading bytes that cross a page boundary
111 *
112 * @returns VBox status code.
113 * @param pSrc GC source pointer
114 * @param pDest HC destination pointer
115 * @param cb Number of bytes to read
116 * @param dwUserdata Callback specific user data (pDis)
117 *
118 */
119DECLCALLBACK(int) EMReadBytes(RTUINTPTR pSrc, uint8_t *pDest, unsigned cb, void *pvUserdata)
120{
121 PDISCPUSTATE pDis = (PDISCPUSTATE)pvUserdata;
122 PEMDISSTATE pState = (PEMDISSTATE)pDis->apvUserData[0];
123 PVM pVM = pState->pVM;
124 PVMCPU pVCpu = pState->pVCpu;
125
126# ifdef IN_RING0
127 int rc;
128
129 if ( pState->GCPtr
130 && pSrc + cb <= pState->GCPtr + sizeof(pState->aOpcode))
131 {
132 unsigned offset = pSrc - pState->GCPtr;
133
134 Assert(pSrc >= pState->GCPtr);
135
136 for (unsigned i=0; i<cb; i++)
137 {
138 pDest[i] = pState->aOpcode[offset + i];
139 }
140 return VINF_SUCCESS;
141 }
142
143 rc = PGMPhysSimpleReadGCPtr(pVCpu, pDest, pSrc, cb);
144 AssertMsgRC(rc, ("PGMPhysSimpleReadGCPtr failed for pSrc=%RGv cb=%x rc=%d\n", pSrc, cb, rc));
145# elif defined(IN_RING3)
146 if (!PATMIsPatchGCAddr(pVM, pSrc))
147 {
148 int rc = PGMPhysSimpleReadGCPtr(pVCpu, pDest, pSrc, cb);
149 AssertRC(rc);
150 }
151 else
152 memcpy(pDest, PATMR3GCPtrToHCPtr(pVM, pSrc), cb);
153
154# elif defined(IN_RC)
155 if (!PATMIsPatchGCAddr(pVM, pSrc))
156 {
157 int rc = MMGCRamRead(pVM, pDest, (void *)(uintptr_t)pSrc, cb);
158 if (rc == VERR_ACCESS_DENIED)
159 {
160 /* Recently flushed; access the data manually. */
161 rc = PGMPhysSimpleReadGCPtr(pVCpu, pDest, pSrc, cb);
162 AssertRC(rc);
163 }
164 }
165 else /* the hypervisor region is always present. */
166 memcpy(pDest, (RTRCPTR)(uintptr_t)pSrc, cb);
167
168# endif /* IN_RING3 */
169 return VINF_SUCCESS;
170}
171
172
173#ifndef IN_RC
174DECLINLINE(int) emDisCoreOne(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, RTGCUINTPTR InstrGC, uint32_t *pOpsize)
175{
176 EMDISSTATE State;
177
178 State.pVM = pVM;
179 State.pVCpu = pVCpu;
180 int rc = PGMPhysSimpleReadGCPtr(pVCpu, &State.aOpcode, InstrGC, sizeof(State.aOpcode));
181 if (RT_SUCCESS(rc))
182 {
183 State.GCPtr = InstrGC;
184 }
185 else
186 {
187 if (PAGE_ADDRESS(InstrGC) == PAGE_ADDRESS(InstrGC + sizeof(State.aOpcode) - 1))
188 {
189 if (rc == VERR_PAGE_TABLE_NOT_PRESENT)
190 HWACCMInvalidatePage(pVCpu, InstrGC);
191
192 Log(("emDisCoreOne: read failed with %d\n", rc));
193 return rc;
194 }
195 State.GCPtr = NIL_RTGCPTR;
196 }
197 return DISCoreOneEx(InstrGC, pDis->mode, EMReadBytes, &State, pDis, pOpsize);
198}
199
200#else /* IN_RC */
201
202DECLINLINE(int) emDisCoreOne(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, RTGCUINTPTR InstrGC, uint32_t *pOpsize)
203{
204 EMDISSTATE State;
205
206 State.pVM = pVM;
207 State.pVCpu = pVCpu;
208 State.GCPtr = InstrGC;
209
210 return DISCoreOneEx(InstrGC, pDis->mode, EMReadBytes, &State, pDis, pOpsize);
211}
212
213#endif /* IN_RC */
214
215
216/**
217 * Disassembles one instruction.
218 *
219 * @returns VBox status code, see SELMToFlatEx and EMInterpretDisasOneEx for
220 * details.
221 * @retval VERR_INTERNAL_ERROR on DISCoreOneEx failure.
222 *
223 * @param pVM The VM handle.
224 * @param pVCpu The VMCPU handle.
225 * @param pCtxCore The context core (used for both the mode and instruction).
226 * @param pDis Where to return the parsed instruction info.
227 * @param pcbInstr Where to return the instruction size. (optional)
228 */
229VMMDECL(int) EMInterpretDisasOne(PVM pVM, PVMCPU pVCpu, PCCPUMCTXCORE pCtxCore, PDISCPUSTATE pDis, unsigned *pcbInstr)
230{
231 RTGCPTR GCPtrInstr;
232 int rc = SELMToFlatEx(pVM, DIS_SELREG_CS, pCtxCore, pCtxCore->rip, 0, &GCPtrInstr);
233 if (RT_FAILURE(rc))
234 {
235 Log(("EMInterpretDisasOne: Failed to convert %RTsel:%RGv (cpl=%d) - rc=%Rrc !!\n",
236 pCtxCore->cs, (RTGCPTR)pCtxCore->rip, pCtxCore->ss & X86_SEL_RPL, rc));
237 return rc;
238 }
239 return EMInterpretDisasOneEx(pVM, pVCpu, (RTGCUINTPTR)GCPtrInstr, pCtxCore, pDis, pcbInstr);
240}
241
242
243/**
244 * Disassembles one instruction.
245 *
246 * This is used by internally by the interpreter and by trap/access handlers.
247 *
248 * @returns VBox status code.
249 * @retval VERR_INTERNAL_ERROR on DISCoreOneEx failure.
250 *
251 * @param pVM The VM handle.
252 * @param pVCpu The VMCPU handle.
253 * @param GCPtrInstr The flat address of the instruction.
254 * @param pCtxCore The context core (used to determine the cpu mode).
255 * @param pDis Where to return the parsed instruction info.
256 * @param pcbInstr Where to return the instruction size. (optional)
257 */
258VMMDECL(int) EMInterpretDisasOneEx(PVM pVM, PVMCPU pVCpu, RTGCUINTPTR GCPtrInstr, PCCPUMCTXCORE pCtxCore, PDISCPUSTATE pDis, unsigned *pcbInstr)
259{
260 int rc;
261 EMDISSTATE State;
262
263 State.pVM = pVM;
264 State.pVCpu = pVCpu;
265
266#ifdef IN_RC
267 State.GCPtr = GCPtrInstr;
268#else /* ring 0/3 */
269 rc = PGMPhysSimpleReadGCPtr(pVCpu, &State.aOpcode, GCPtrInstr, sizeof(State.aOpcode));
270 if (RT_SUCCESS(rc))
271 {
272 State.GCPtr = GCPtrInstr;
273 }
274 else
275 {
276 if (PAGE_ADDRESS(GCPtrInstr) == PAGE_ADDRESS(GCPtrInstr + sizeof(State.aOpcode) - 1))
277 {
278 if (rc == VERR_PAGE_TABLE_NOT_PRESENT)
279 HWACCMInvalidatePage(pVCpu, GCPtrInstr);
280
281 Log(("EMInterpretDisasOneEx: read failed with %d\n", rc));
282 return rc;
283 }
284 State.GCPtr = NIL_RTGCPTR;
285 }
286#endif
287
288 rc = DISCoreOneEx(GCPtrInstr, SELMGetCpuModeFromSelector(pVM, pCtxCore->eflags, pCtxCore->cs, (PCPUMSELREGHID)&pCtxCore->csHid),
289 EMReadBytes, &State,
290 pDis, pcbInstr);
291 if (RT_SUCCESS(rc))
292 return VINF_SUCCESS;
293 AssertMsgFailed(("DISCoreOne failed to GCPtrInstr=%RGv rc=%Rrc\n", GCPtrInstr, rc));
294 return VERR_INTERNAL_ERROR;
295}
296
297
298/**
299 * Interprets the current instruction.
300 *
301 * @returns VBox status code.
302 * @retval VINF_* Scheduling instructions.
303 * @retval VERR_EM_INTERPRETER Something we can't cope with.
304 * @retval VERR_* Fatal errors.
305 *
306 * @param pVM The VM handle.
307 * @param pVCpu The VMCPU handle.
308 * @param pRegFrame The register frame.
309 * Updates the EIP if an instruction was executed successfully.
310 * @param pvFault The fault address (CR2).
311 * @param pcbSize Size of the write (if applicable).
312 *
313 * @remark Invalid opcode exceptions have a higher priority than GP (see Intel
314 * Architecture System Developers Manual, Vol 3, 5.5) so we don't need
315 * to worry about e.g. invalid modrm combinations (!)
316 */
317VMMDECL(int) EMInterpretInstruction(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
318{
319 RTGCPTR pbCode;
320
321 LogFlow(("EMInterpretInstruction %RGv fault %RGv\n", (RTGCPTR)pRegFrame->rip, pvFault));
322 int rc = SELMToFlatEx(pVM, DIS_SELREG_CS, pRegFrame, pRegFrame->rip, 0, &pbCode);
323 if (RT_SUCCESS(rc))
324 {
325 uint32_t cbOp;
326 PDISCPUSTATE pDis = &pVCpu->em.s.DisState;
327 pDis->mode = SELMGetCpuModeFromSelector(pVM, pRegFrame->eflags, pRegFrame->cs, &pRegFrame->csHid);
328 rc = emDisCoreOne(pVM, pVCpu, pDis, (RTGCUINTPTR)pbCode, &cbOp);
329 if (RT_SUCCESS(rc))
330 {
331 Assert(cbOp == pDis->opsize);
332 rc = EMInterpretInstructionCPU(pVM, pVCpu, pDis, pRegFrame, pvFault, pcbSize);
333 if (RT_SUCCESS(rc))
334 pRegFrame->rip += cbOp; /* Move on to the next instruction. */
335
336 return rc;
337 }
338 }
339 return VERR_EM_INTERPRETER;
340}
341
342
343/**
344 * Interprets the current instruction using the supplied DISCPUSTATE structure.
345 *
346 * EIP is *NOT* updated!
347 *
348 * @returns VBox status code.
349 * @retval VINF_* Scheduling instructions. When these are returned, it
350 * starts to get a bit tricky to know whether code was
351 * executed or not... We'll address this when it becomes a problem.
352 * @retval VERR_EM_INTERPRETER Something we can't cope with.
353 * @retval VERR_* Fatal errors.
354 *
355 * @param pVM The VM handle.
356 * @param pVCpu The VMCPU handle.
357 * @param pDis The disassembler cpu state for the instruction to be
358 * interpreted.
359 * @param pRegFrame The register frame. EIP is *NOT* changed!
360 * @param pvFault The fault address (CR2).
361 * @param pcbSize Size of the write (if applicable).
362 *
363 * @remark Invalid opcode exceptions have a higher priority than GP (see Intel
364 * Architecture System Developers Manual, Vol 3, 5.5) so we don't need
365 * to worry about e.g. invalid modrm combinations (!)
366 *
367 * @todo At this time we do NOT check if the instruction overwrites vital information.
368 * Make sure this can't happen!! (will add some assertions/checks later)
369 */
370VMMDECL(int) EMInterpretInstructionCPU(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
371{
372 STAM_PROFILE_START(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Emulate), a);
373 int rc = emInterpretInstructionCPU(pVM, pVCpu, pDis, pRegFrame, pvFault, pcbSize);
374 STAM_PROFILE_STOP(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Emulate), a);
375 if (RT_SUCCESS(rc))
376 STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,InterpretSucceeded));
377 else
378 STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,InterpretFailed));
379 return rc;
380}
381
382
383/**
384 * Interpret a port I/O instruction.
385 *
386 * @returns VBox status code suitable for scheduling.
387 * @param pVM The VM handle.
388 * @param pVCpu The VMCPU handle.
389 * @param pCtxCore The context core. This will be updated on successful return.
390 * @param pDis The instruction to interpret.
391 * @param cbOp The size of the instruction.
392 * @remark This may raise exceptions.
393 */
394VMMDECL(VBOXSTRICTRC) EMInterpretPortIO(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pCtxCore, PDISCPUSTATE pDis, uint32_t cbOp)
395{
396 /*
397 * Hand it on to IOM.
398 */
399#ifdef IN_RC
400 VBOXSTRICTRC rcStrict = IOMGCIOPortHandler(pVM, pCtxCore, pDis);
401 if (IOM_SUCCESS(rcStrict))
402 pCtxCore->rip += cbOp;
403 return rcStrict;
404#else
405 AssertReleaseMsgFailed(("not implemented\n"));
406 return VERR_NOT_IMPLEMENTED;
407#endif
408}
409
410
411DECLINLINE(int) emRamRead(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pCtxCore, void *pvDst, RTGCPTR GCPtrSrc, uint32_t cb)
412{
413#ifdef IN_RC
414 int rc = MMGCRamRead(pVM, pvDst, (void *)(uintptr_t)GCPtrSrc, cb);
415 if (RT_LIKELY(rc != VERR_ACCESS_DENIED))
416 return rc;
417 /*
418 * The page pool cache may end up here in some cases because it
419 * flushed one of the shadow mappings used by the trapping
420 * instruction and it either flushed the TLB or the CPU reused it.
421 */
422#endif
423 return PGMPhysInterpretedReadNoHandlers(pVCpu, pCtxCore, pvDst, GCPtrSrc, cb, /*fMayTrap*/ false);
424}
425
426
427DECLINLINE(int) emRamWrite(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pCtxCore, RTGCPTR GCPtrDst, const void *pvSrc, uint32_t cb)
428{
429#ifdef IN_RC
430 int rc = MMGCRamWrite(pVM, (void *)(uintptr_t)GCPtrDst, (void *)pvSrc, cb);
431 if (RT_LIKELY(rc != VERR_ACCESS_DENIED))
432 return rc;
433 /*
434 * The page pool cache may end up here in some cases because it
435 * flushed one of the shadow mappings used by the trapping
436 * instruction and it either flushed the TLB or the CPU reused it.
437 * We want to play safe here, verifying that we've got write
438 * access doesn't cost us much (see PGMPhysGCPtr2GCPhys()).
439 */
440#endif
441 return PGMPhysInterpretedWriteNoHandlers(pVCpu, pCtxCore, GCPtrDst, pvSrc, cb, /*fMayTrap*/ false);
442}
443
444
445/** Convert sel:addr to a flat GC address. */
446DECLINLINE(RTGCPTR) emConvertToFlatAddr(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pDis, POP_PARAMETER pParam, RTGCPTR pvAddr)
447{
448 DIS_SELREG enmPrefixSeg = DISDetectSegReg(pDis, pParam);
449 return SELMToFlat(pVM, enmPrefixSeg, pRegFrame, pvAddr);
450}
451
452
453#if defined(VBOX_STRICT) || defined(LOG_ENABLED)
454/**
455 * Get the mnemonic for the disassembled instruction.
456 *
457 * GC/R0 doesn't include the strings in the DIS tables because
458 * of limited space.
459 */
460static const char *emGetMnemonic(PDISCPUSTATE pDis)
461{
462 switch (pDis->pCurInstr->opcode)
463 {
464 case OP_XCHG: return "Xchg";
465 case OP_DEC: return "Dec";
466 case OP_INC: return "Inc";
467 case OP_POP: return "Pop";
468 case OP_OR: return "Or";
469 case OP_AND: return "And";
470 case OP_MOV: return "Mov";
471 case OP_INVLPG: return "InvlPg";
472 case OP_CPUID: return "CpuId";
473 case OP_MOV_CR: return "MovCRx";
474 case OP_MOV_DR: return "MovDRx";
475 case OP_LLDT: return "LLdt";
476 case OP_LGDT: return "LGdt";
477 case OP_LIDT: return "LGdt";
478 case OP_CLTS: return "Clts";
479 case OP_MONITOR: return "Monitor";
480 case OP_MWAIT: return "MWait";
481 case OP_RDMSR: return "Rdmsr";
482 case OP_WRMSR: return "Wrmsr";
483 case OP_ADD: return "Add";
484 case OP_ADC: return "Adc";
485 case OP_SUB: return "Sub";
486 case OP_SBB: return "Sbb";
487 case OP_RDTSC: return "Rdtsc";
488 case OP_STI: return "Sti";
489 case OP_CLI: return "Cli";
490 case OP_XADD: return "XAdd";
491 case OP_HLT: return "Hlt";
492 case OP_IRET: return "Iret";
493 case OP_MOVNTPS: return "MovNTPS";
494 case OP_STOSWD: return "StosWD";
495 case OP_WBINVD: return "WbInvd";
496 case OP_XOR: return "Xor";
497 case OP_BTR: return "Btr";
498 case OP_BTS: return "Bts";
499 case OP_BTC: return "Btc";
500 case OP_LMSW: return "Lmsw";
501 case OP_SMSW: return "Smsw";
502 case OP_CMPXCHG: return pDis->prefix & PREFIX_LOCK ? "Lock CmpXchg" : "CmpXchg";
503 case OP_CMPXCHG8B: return pDis->prefix & PREFIX_LOCK ? "Lock CmpXchg8b" : "CmpXchg8b";
504
505 default:
506 Log(("Unknown opcode %d\n", pDis->pCurInstr->opcode));
507 return "???";
508 }
509}
510#endif /* VBOX_STRICT || LOG_ENABLED */
511
512
513/**
514 * XCHG instruction emulation.
515 */
516static int emInterpretXchg(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
517{
518 OP_PARAMVAL param1, param2;
519
520 /* Source to make DISQueryParamVal read the register value - ugly hack */
521 int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_SOURCE);
522 if(RT_FAILURE(rc))
523 return VERR_EM_INTERPRETER;
524
525 rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, PARAM_SOURCE);
526 if(RT_FAILURE(rc))
527 return VERR_EM_INTERPRETER;
528
529#ifdef IN_RC
530 if (TRPMHasTrap(pVCpu))
531 {
532 if (TRPMGetErrorCode(pVCpu) & X86_TRAP_PF_RW)
533 {
534#endif
535 RTGCPTR pParam1 = 0, pParam2 = 0;
536 uint64_t valpar1, valpar2;
537
538 AssertReturn(pDis->param1.size == pDis->param2.size, VERR_EM_INTERPRETER);
539 switch(param1.type)
540 {
541 case PARMTYPE_IMMEDIATE: /* register type is translated to this one too */
542 valpar1 = param1.val.val64;
543 break;
544
545 case PARMTYPE_ADDRESS:
546 pParam1 = (RTGCPTR)param1.val.val64;
547 pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, pParam1);
548 EM_ASSERT_FAULT_RETURN(pParam1 == pvFault, VERR_EM_INTERPRETER);
549 rc = emRamRead(pVM, pVCpu, pRegFrame, &valpar1, pParam1, param1.size);
550 if (RT_FAILURE(rc))
551 {
552 AssertMsgFailed(("MMGCRamRead %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
553 return VERR_EM_INTERPRETER;
554 }
555 break;
556
557 default:
558 AssertFailed();
559 return VERR_EM_INTERPRETER;
560 }
561
562 switch(param2.type)
563 {
564 case PARMTYPE_ADDRESS:
565 pParam2 = (RTGCPTR)param2.val.val64;
566 pParam2 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param2, pParam2);
567 EM_ASSERT_FAULT_RETURN(pParam2 == pvFault, VERR_EM_INTERPRETER);
568 rc = emRamRead(pVM, pVCpu, pRegFrame, &valpar2, pParam2, param2.size);
569 if (RT_FAILURE(rc))
570 {
571 AssertMsgFailed(("MMGCRamRead %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
572 }
573 break;
574
575 case PARMTYPE_IMMEDIATE:
576 valpar2 = param2.val.val64;
577 break;
578
579 default:
580 AssertFailed();
581 return VERR_EM_INTERPRETER;
582 }
583
584 /* Write value of parameter 2 to parameter 1 (reg or memory address) */
585 if (pParam1 == 0)
586 {
587 Assert(param1.type == PARMTYPE_IMMEDIATE); /* register actually */
588 switch(param1.size)
589 {
590 case 1: //special case for AH etc
591 rc = DISWriteReg8(pRegFrame, pDis->param1.base.reg_gen, (uint8_t )valpar2); break;
592 case 2: rc = DISWriteReg16(pRegFrame, pDis->param1.base.reg_gen, (uint16_t)valpar2); break;
593 case 4: rc = DISWriteReg32(pRegFrame, pDis->param1.base.reg_gen, (uint32_t)valpar2); break;
594 case 8: rc = DISWriteReg64(pRegFrame, pDis->param1.base.reg_gen, valpar2); break;
595 default: AssertFailedReturn(VERR_EM_INTERPRETER);
596 }
597 if (RT_FAILURE(rc))
598 return VERR_EM_INTERPRETER;
599 }
600 else
601 {
602 rc = emRamWrite(pVM, pVCpu, pRegFrame, pParam1, &valpar2, param1.size);
603 if (RT_FAILURE(rc))
604 {
605 AssertMsgFailed(("emRamWrite %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
606 return VERR_EM_INTERPRETER;
607 }
608 }
609
610 /* Write value of parameter 1 to parameter 2 (reg or memory address) */
611 if (pParam2 == 0)
612 {
613 Assert(param2.type == PARMTYPE_IMMEDIATE); /* register actually */
614 switch(param2.size)
615 {
616 case 1: //special case for AH etc
617 rc = DISWriteReg8(pRegFrame, pDis->param2.base.reg_gen, (uint8_t )valpar1); break;
618 case 2: rc = DISWriteReg16(pRegFrame, pDis->param2.base.reg_gen, (uint16_t)valpar1); break;
619 case 4: rc = DISWriteReg32(pRegFrame, pDis->param2.base.reg_gen, (uint32_t)valpar1); break;
620 case 8: rc = DISWriteReg64(pRegFrame, pDis->param2.base.reg_gen, valpar1); break;
621 default: AssertFailedReturn(VERR_EM_INTERPRETER);
622 }
623 if (RT_FAILURE(rc))
624 return VERR_EM_INTERPRETER;
625 }
626 else
627 {
628 rc = emRamWrite(pVM, pVCpu, pRegFrame, pParam2, &valpar1, param2.size);
629 if (RT_FAILURE(rc))
630 {
631 AssertMsgFailed(("emRamWrite %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
632 return VERR_EM_INTERPRETER;
633 }
634 }
635
636 *pcbSize = param2.size;
637 return VINF_SUCCESS;
638#ifdef IN_RC
639 }
640 }
641#endif
642 return VERR_EM_INTERPRETER;
643}
644
645
646/**
647 * INC and DEC emulation.
648 */
649static int emInterpretIncDec(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize,
650 PFNEMULATEPARAM2 pfnEmulate)
651{
652 OP_PARAMVAL param1;
653
654 int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_DEST);
655 if(RT_FAILURE(rc))
656 return VERR_EM_INTERPRETER;
657
658#ifdef IN_RC
659 if (TRPMHasTrap(pVCpu))
660 {
661 if (TRPMGetErrorCode(pVCpu) & X86_TRAP_PF_RW)
662 {
663#endif
664 RTGCPTR pParam1 = 0;
665 uint64_t valpar1;
666
667 if (param1.type == PARMTYPE_ADDRESS)
668 {
669 pParam1 = (RTGCPTR)param1.val.val64;
670 pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, pParam1);
671#ifdef IN_RC
672 /* Safety check (in theory it could cross a page boundary and fault there though) */
673 AssertReturn(pParam1 == pvFault, VERR_EM_INTERPRETER);
674#endif
675 rc = emRamRead(pVM, pVCpu, pRegFrame, &valpar1, pParam1, param1.size);
676 if (RT_FAILURE(rc))
677 {
678 AssertMsgFailed(("emRamRead %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
679 return VERR_EM_INTERPRETER;
680 }
681 }
682 else
683 {
684 AssertFailed();
685 return VERR_EM_INTERPRETER;
686 }
687
688 uint32_t eflags;
689
690 eflags = pfnEmulate(&valpar1, param1.size);
691
692 /* Write result back */
693 rc = emRamWrite(pVM, pVCpu, pRegFrame, pParam1, &valpar1, param1.size);
694 if (RT_FAILURE(rc))
695 {
696 AssertMsgFailed(("emRamWrite %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
697 return VERR_EM_INTERPRETER;
698 }
699
700 /* Update guest's eflags and finish. */
701 pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF))
702 | (eflags & (X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF));
703
704 /* All done! */
705 *pcbSize = param1.size;
706 return VINF_SUCCESS;
707#ifdef IN_RC
708 }
709 }
710#endif
711 return VERR_EM_INTERPRETER;
712}
713
714
715/**
716 * POP Emulation.
717 */
718static int emInterpretPop(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
719{
720 Assert(pDis->mode != CPUMODE_64BIT); /** @todo check */
721 OP_PARAMVAL param1;
722 int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_DEST);
723 if(RT_FAILURE(rc))
724 return VERR_EM_INTERPRETER;
725
726#ifdef IN_RC
727 if (TRPMHasTrap(pVCpu))
728 {
729 if (TRPMGetErrorCode(pVCpu) & X86_TRAP_PF_RW)
730 {
731#endif
732 RTGCPTR pParam1 = 0;
733 uint32_t valpar1;
734 RTGCPTR pStackVal;
735
736 /* Read stack value first */
737 if (SELMGetCpuModeFromSelector(pVM, pRegFrame->eflags, pRegFrame->ss, &pRegFrame->ssHid) == CPUMODE_16BIT)
738 return VERR_EM_INTERPRETER; /* No legacy 16 bits stuff here, please. */
739
740 /* Convert address; don't bother checking limits etc, as we only read here */
741 pStackVal = SELMToFlat(pVM, DIS_SELREG_SS, pRegFrame, (RTGCPTR)pRegFrame->esp);
742 if (pStackVal == 0)
743 return VERR_EM_INTERPRETER;
744
745 rc = emRamRead(pVM, pVCpu, pRegFrame, &valpar1, pStackVal, param1.size);
746 if (RT_FAILURE(rc))
747 {
748 AssertMsgFailed(("emRamRead %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
749 return VERR_EM_INTERPRETER;
750 }
751
752 if (param1.type == PARMTYPE_ADDRESS)
753 {
754 pParam1 = (RTGCPTR)param1.val.val64;
755
756 /* pop [esp+xx] uses esp after the actual pop! */
757 AssertCompile(USE_REG_ESP == USE_REG_SP);
758 if ( (pDis->param1.flags & USE_BASE)
759 && (pDis->param1.flags & (USE_REG_GEN16|USE_REG_GEN32))
760 && pDis->param1.base.reg_gen == USE_REG_ESP
761 )
762 pParam1 = (RTGCPTR)((RTGCUINTPTR)pParam1 + param1.size);
763
764 pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, pParam1);
765 EM_ASSERT_FAULT_RETURN(pParam1 == pvFault || (RTGCPTR)pRegFrame->esp == pvFault, VERR_EM_INTERPRETER);
766 rc = emRamWrite(pVM, pVCpu, pRegFrame, pParam1, &valpar1, param1.size);
767 if (RT_FAILURE(rc))
768 {
769 AssertMsgFailed(("emRamWrite %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
770 return VERR_EM_INTERPRETER;
771 }
772
773 /* Update ESP as the last step */
774 pRegFrame->esp += param1.size;
775 }
776 else
777 {
778#ifndef DEBUG_bird // annoying assertion.
779 AssertFailed();
780#endif
781 return VERR_EM_INTERPRETER;
782 }
783
784 /* All done! */
785 *pcbSize = param1.size;
786 return VINF_SUCCESS;
787#ifdef IN_RC
788 }
789 }
790#endif
791 return VERR_EM_INTERPRETER;
792}
793
794
795/**
796 * XOR/OR/AND Emulation.
797 */
798static int emInterpretOrXorAnd(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize,
799 PFNEMULATEPARAM3 pfnEmulate)
800{
801 OP_PARAMVAL param1, param2;
802
803 int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_DEST);
804 if(RT_FAILURE(rc))
805 return VERR_EM_INTERPRETER;
806
807 rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, PARAM_SOURCE);
808 if(RT_FAILURE(rc))
809 return VERR_EM_INTERPRETER;
810
811#ifdef IN_RC
812 if (TRPMHasTrap(pVCpu))
813 {
814 if (TRPMGetErrorCode(pVCpu) & X86_TRAP_PF_RW)
815 {
816#endif
817 RTGCPTR pParam1;
818 uint64_t valpar1, valpar2;
819
820 if (pDis->param1.size != pDis->param2.size)
821 {
822 if (pDis->param1.size < pDis->param2.size)
823 {
824 AssertMsgFailed(("%s at %RGv parameter mismatch %d vs %d!!\n", emGetMnemonic(pDis), (RTGCPTR)pRegFrame->rip, pDis->param1.size, pDis->param2.size)); /* should never happen! */
825 return VERR_EM_INTERPRETER;
826 }
827 /* Or %Ev, Ib -> just a hack to save some space; the data width of the 1st parameter determines the real width */
828 pDis->param2.size = pDis->param1.size;
829 param2.size = param1.size;
830 }
831
832 /* The destination is always a virtual address */
833 if (param1.type == PARMTYPE_ADDRESS)
834 {
835 pParam1 = (RTGCPTR)param1.val.val64;
836 pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, pParam1);
837 EM_ASSERT_FAULT_RETURN(pParam1 == pvFault, VERR_EM_INTERPRETER);
838 rc = emRamRead(pVM, pVCpu, pRegFrame, &valpar1, pParam1, param1.size);
839 if (RT_FAILURE(rc))
840 {
841 AssertMsgFailed(("emRamRead %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
842 return VERR_EM_INTERPRETER;
843 }
844 }
845 else
846 {
847 AssertFailed();
848 return VERR_EM_INTERPRETER;
849 }
850
851 /* Register or immediate data */
852 switch(param2.type)
853 {
854 case PARMTYPE_IMMEDIATE: /* both immediate data and register (ugly) */
855 valpar2 = param2.val.val64;
856 break;
857
858 default:
859 AssertFailed();
860 return VERR_EM_INTERPRETER;
861 }
862
863 LogFlow(("emInterpretOrXorAnd %s %RGv %RX64 - %RX64 size %d (%d)\n", emGetMnemonic(pDis), pParam1, valpar1, valpar2, param2.size, param1.size));
864
865 /* Data read, emulate instruction. */
866 uint32_t eflags = pfnEmulate(&valpar1, valpar2, param2.size);
867
868 LogFlow(("emInterpretOrXorAnd %s result %RX64\n", emGetMnemonic(pDis), valpar1));
869
870 /* Update guest's eflags and finish. */
871 pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF))
872 | (eflags & (X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF));
873
874 /* And write it back */
875 rc = emRamWrite(pVM, pVCpu, pRegFrame, pParam1, &valpar1, param1.size);
876 if (RT_SUCCESS(rc))
877 {
878 /* All done! */
879 *pcbSize = param2.size;
880 return VINF_SUCCESS;
881 }
882#ifdef IN_RC
883 }
884 }
885#endif
886 return VERR_EM_INTERPRETER;
887}
888
889
890/**
891 * LOCK XOR/OR/AND Emulation.
892 */
893static int emInterpretLockOrXorAnd(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
894 uint32_t *pcbSize, PFNEMULATELOCKPARAM3 pfnEmulate)
895{
896 void *pvParam1;
897 OP_PARAMVAL param1, param2;
898
899#if HC_ARCH_BITS == 32
900 Assert(pDis->param1.size <= 4);
901#endif
902
903 int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_DEST);
904 if(RT_FAILURE(rc))
905 return VERR_EM_INTERPRETER;
906
907 rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, PARAM_SOURCE);
908 if(RT_FAILURE(rc))
909 return VERR_EM_INTERPRETER;
910
911 if (pDis->param1.size != pDis->param2.size)
912 {
913 AssertMsgReturn(pDis->param1.size >= pDis->param2.size, /* should never happen! */
914 ("%s at %RGv parameter mismatch %d vs %d!!\n", emGetMnemonic(pDis), (RTGCPTR)pRegFrame->rip, pDis->param1.size, pDis->param2.size),
915 VERR_EM_INTERPRETER);
916
917 /* Or %Ev, Ib -> just a hack to save some space; the data width of the 1st parameter determines the real width */
918 pDis->param2.size = pDis->param1.size;
919 param2.size = param1.size;
920 }
921
922#ifdef IN_RC
923 /* Safety check (in theory it could cross a page boundary and fault there though) */
924 Assert( TRPMHasTrap(pVCpu)
925 && (TRPMGetErrorCode(pVCpu) & X86_TRAP_PF_RW));
926 EM_ASSERT_FAULT_RETURN(GCPtrPar1 == pvFault, VERR_EM_INTERPRETER);
927#endif
928
929 /* Register and immediate data == PARMTYPE_IMMEDIATE */
930 AssertReturn(param2.type == PARMTYPE_IMMEDIATE, VERR_EM_INTERPRETER);
931 RTGCUINTREG ValPar2 = param2.val.val64;
932
933 /* The destination is always a virtual address */
934 AssertReturn(param1.type == PARMTYPE_ADDRESS, VERR_EM_INTERPRETER);
935
936 RTGCPTR GCPtrPar1 = param1.val.val64;
937 GCPtrPar1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, GCPtrPar1);
938#ifdef IN_RC
939 pvParam1 = (void *)(uintptr_t)GCPtrPar1;
940#else
941 PGMPAGEMAPLOCK Lock;
942 rc = PGMPhysGCPtr2CCPtr(pVCpu, GCPtrPar1, &pvParam1, &Lock);
943 AssertRCReturn(rc, VERR_EM_INTERPRETER);
944#endif
945
946 /* Try emulate it with a one-shot #PF handler in place. (RC) */
947 Log2(("%s %RGv imm%d=%RX64\n", emGetMnemonic(pDis), GCPtrPar1, pDis->param2.size*8, ValPar2));
948
949 RTGCUINTREG32 eflags = 0;
950#ifdef IN_RC
951 MMGCRamRegisterTrapHandler(pVM);
952#endif
953 rc = pfnEmulate(pvParam1, ValPar2, pDis->param2.size, &eflags);
954#ifdef IN_RC
955 MMGCRamDeregisterTrapHandler(pVM);
956#else
957 PGMPhysReleasePageMappingLock(pVM, &Lock);
958#endif
959 if (RT_FAILURE(rc))
960 {
961 Log(("%s %RGv imm%d=%RX64-> emulation failed due to page fault!\n", emGetMnemonic(pDis), GCPtrPar1, pDis->param2.size*8, ValPar2));
962 return VERR_EM_INTERPRETER;
963 }
964
965 /* Update guest's eflags and finish. */
966 pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF))
967 | (eflags & (X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF));
968
969 *pcbSize = param2.size;
970 return VINF_SUCCESS;
971}
972
973
974/**
975 * ADD, ADC & SUB Emulation.
976 */
977static int emInterpretAddSub(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize,
978 PFNEMULATEPARAM3 pfnEmulate)
979{
980 OP_PARAMVAL param1, param2;
981 int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_DEST);
982 if(RT_FAILURE(rc))
983 return VERR_EM_INTERPRETER;
984
985 rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, PARAM_SOURCE);
986 if(RT_FAILURE(rc))
987 return VERR_EM_INTERPRETER;
988
989#ifdef IN_RC
990 if (TRPMHasTrap(pVCpu))
991 {
992 if (TRPMGetErrorCode(pVCpu) & X86_TRAP_PF_RW)
993 {
994#endif
995 RTGCPTR pParam1;
996 uint64_t valpar1, valpar2;
997
998 if (pDis->param1.size != pDis->param2.size)
999 {
1000 if (pDis->param1.size < pDis->param2.size)
1001 {
1002 AssertMsgFailed(("%s at %RGv parameter mismatch %d vs %d!!\n", emGetMnemonic(pDis), (RTGCPTR)pRegFrame->rip, pDis->param1.size, pDis->param2.size)); /* should never happen! */
1003 return VERR_EM_INTERPRETER;
1004 }
1005 /* Or %Ev, Ib -> just a hack to save some space; the data width of the 1st parameter determines the real width */
1006 pDis->param2.size = pDis->param1.size;
1007 param2.size = param1.size;
1008 }
1009
1010 /* The destination is always a virtual address */
1011 if (param1.type == PARMTYPE_ADDRESS)
1012 {
1013 pParam1 = (RTGCPTR)param1.val.val64;
1014 pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, pParam1);
1015 EM_ASSERT_FAULT_RETURN(pParam1 == pvFault, VERR_EM_INTERPRETER);
1016 rc = emRamRead(pVM, pVCpu, pRegFrame, &valpar1, pParam1, param1.size);
1017 if (RT_FAILURE(rc))
1018 {
1019 AssertMsgFailed(("emRamRead %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
1020 return VERR_EM_INTERPRETER;
1021 }
1022 }
1023 else
1024 {
1025#ifndef DEBUG_bird
1026 AssertFailed();
1027#endif
1028 return VERR_EM_INTERPRETER;
1029 }
1030
1031 /* Register or immediate data */
1032 switch(param2.type)
1033 {
1034 case PARMTYPE_IMMEDIATE: /* both immediate data and register (ugly) */
1035 valpar2 = param2.val.val64;
1036 break;
1037
1038 default:
1039 AssertFailed();
1040 return VERR_EM_INTERPRETER;
1041 }
1042
1043 /* Data read, emulate instruction. */
1044 uint32_t eflags = pfnEmulate(&valpar1, valpar2, param2.size);
1045
1046 /* Update guest's eflags and finish. */
1047 pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF))
1048 | (eflags & (X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF));
1049
1050 /* And write it back */
1051 rc = emRamWrite(pVM, pVCpu, pRegFrame, pParam1, &valpar1, param1.size);
1052 if (RT_SUCCESS(rc))
1053 {
1054 /* All done! */
1055 *pcbSize = param2.size;
1056 return VINF_SUCCESS;
1057 }
1058#ifdef IN_RC
1059 }
1060 }
1061#endif
1062 return VERR_EM_INTERPRETER;
1063}
1064
1065
1066/**
1067 * ADC Emulation.
1068 */
1069static int emInterpretAdc(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
1070{
1071 if (pRegFrame->eflags.Bits.u1CF)
1072 return emInterpretAddSub(pVM, pVCpu, pDis, pRegFrame, pvFault, pcbSize, EMEmulateAdcWithCarrySet);
1073 else
1074 return emInterpretAddSub(pVM, pVCpu, pDis, pRegFrame, pvFault, pcbSize, EMEmulateAdd);
1075}
1076
1077
1078/**
1079 * BTR/C/S Emulation.
1080 */
1081static int emInterpretBitTest(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize,
1082 PFNEMULATEPARAM2UINT32 pfnEmulate)
1083{
1084 OP_PARAMVAL param1, param2;
1085 int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_DEST);
1086 if(RT_FAILURE(rc))
1087 return VERR_EM_INTERPRETER;
1088
1089 rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, PARAM_SOURCE);
1090 if(RT_FAILURE(rc))
1091 return VERR_EM_INTERPRETER;
1092
1093#ifdef IN_RC
1094 if (TRPMHasTrap(pVCpu))
1095 {
1096 if (TRPMGetErrorCode(pVCpu) & X86_TRAP_PF_RW)
1097 {
1098#endif
1099 RTGCPTR pParam1;
1100 uint64_t valpar1 = 0, valpar2;
1101 uint32_t eflags;
1102
1103 /* The destination is always a virtual address */
1104 if (param1.type != PARMTYPE_ADDRESS)
1105 return VERR_EM_INTERPRETER;
1106
1107 pParam1 = (RTGCPTR)param1.val.val64;
1108 pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, pParam1);
1109
1110 /* Register or immediate data */
1111 switch(param2.type)
1112 {
1113 case PARMTYPE_IMMEDIATE: /* both immediate data and register (ugly) */
1114 valpar2 = param2.val.val64;
1115 break;
1116
1117 default:
1118 AssertFailed();
1119 return VERR_EM_INTERPRETER;
1120 }
1121
1122 Log2(("emInterpret%s: pvFault=%RGv pParam1=%RGv val2=%x\n", emGetMnemonic(pDis), pvFault, pParam1, valpar2));
1123 pParam1 = (RTGCPTR)((RTGCUINTPTR)pParam1 + valpar2/8);
1124 EM_ASSERT_FAULT_RETURN((RTGCPTR)((RTGCUINTPTR)pParam1 & ~3) == pvFault, VERR_EM_INTERPRETER);
1125 rc = emRamRead(pVM, pVCpu, pRegFrame, &valpar1, pParam1, 1);
1126 if (RT_FAILURE(rc))
1127 {
1128 AssertMsgFailed(("emRamRead %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
1129 return VERR_EM_INTERPRETER;
1130 }
1131
1132 Log2(("emInterpretBtx: val=%x\n", valpar1));
1133 /* Data read, emulate bit test instruction. */
1134 eflags = pfnEmulate(&valpar1, valpar2 & 0x7);
1135
1136 Log2(("emInterpretBtx: val=%x CF=%d\n", valpar1, !!(eflags & X86_EFL_CF)));
1137
1138 /* Update guest's eflags and finish. */
1139 pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF))
1140 | (eflags & (X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF));
1141
1142 /* And write it back */
1143 rc = emRamWrite(pVM, pVCpu, pRegFrame, pParam1, &valpar1, 1);
1144 if (RT_SUCCESS(rc))
1145 {
1146 /* All done! */
1147 *pcbSize = 1;
1148 return VINF_SUCCESS;
1149 }
1150#ifdef IN_RC
1151 }
1152 }
1153#endif
1154 return VERR_EM_INTERPRETER;
1155}
1156
1157
1158/**
1159 * LOCK BTR/C/S Emulation.
1160 */
1161static int emInterpretLockBitTest(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
1162 uint32_t *pcbSize, PFNEMULATELOCKPARAM2 pfnEmulate)
1163{
1164 void *pvParam1;
1165
1166 OP_PARAMVAL param1, param2;
1167 int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_DEST);
1168 if(RT_FAILURE(rc))
1169 return VERR_EM_INTERPRETER;
1170
1171 rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, PARAM_SOURCE);
1172 if(RT_FAILURE(rc))
1173 return VERR_EM_INTERPRETER;
1174
1175 /* The destination is always a virtual address */
1176 if (param1.type != PARMTYPE_ADDRESS)
1177 return VERR_EM_INTERPRETER;
1178
1179 /* Register and immediate data == PARMTYPE_IMMEDIATE */
1180 AssertReturn(param2.type == PARMTYPE_IMMEDIATE, VERR_EM_INTERPRETER);
1181 uint64_t ValPar2 = param2.val.val64;
1182
1183 /* Adjust the parameters so what we're dealing with is a bit within the byte pointed to. */
1184 RTGCPTR GCPtrPar1 = param1.val.val64;
1185 GCPtrPar1 = (GCPtrPar1 + ValPar2 / 8);
1186 ValPar2 &= 7;
1187
1188 GCPtrPar1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, GCPtrPar1);
1189#ifdef IN_RC
1190 Assert(TRPMHasTrap(pVCpu));
1191 EM_ASSERT_FAULT_RETURN((RTGCPTR)((RTGCUINTPTR)GCPtrPar1 & ~(RTGCUINTPTR)3) == pvFault, VERR_EM_INTERPRETER);
1192#endif
1193
1194#ifdef IN_RC
1195 pvParam1 = (void *)(uintptr_t)GCPtrPar1;
1196#else
1197 PGMPAGEMAPLOCK Lock;
1198 rc = PGMPhysGCPtr2CCPtr(pVCpu, GCPtrPar1, &pvParam1, &Lock);
1199 AssertRCReturn(rc, VERR_EM_INTERPRETER);
1200#endif
1201
1202 Log2(("emInterpretLockBitTest %s: pvFault=%RGv GCPtrPar1=%RGv imm=%RX64\n", emGetMnemonic(pDis), pvFault, GCPtrPar1, ValPar2));
1203
1204 /* Try emulate it with a one-shot #PF handler in place. (RC) */
1205 RTGCUINTREG32 eflags = 0;
1206#ifdef IN_RC
1207 MMGCRamRegisterTrapHandler(pVM);
1208#endif
1209 rc = pfnEmulate(pvParam1, ValPar2, &eflags);
1210#ifdef IN_RC
1211 MMGCRamDeregisterTrapHandler(pVM);
1212#else
1213 PGMPhysReleasePageMappingLock(pVM, &Lock);
1214#endif
1215 if (RT_FAILURE(rc))
1216 {
1217 Log(("emInterpretLockBitTest %s: %RGv imm%d=%RX64 -> emulation failed due to page fault!\n",
1218 emGetMnemonic(pDis), GCPtrPar1, pDis->param2.size*8, ValPar2));
1219 return VERR_EM_INTERPRETER;
1220 }
1221
1222 Log2(("emInterpretLockBitTest %s: GCPtrPar1=%RGv imm=%RX64 CF=%d\n", emGetMnemonic(pDis), GCPtrPar1, ValPar2, !!(eflags & X86_EFL_CF)));
1223
1224 /* Update guest's eflags and finish. */
1225 pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF))
1226 | (eflags & (X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF));
1227
1228 *pcbSize = 1;
1229 return VINF_SUCCESS;
1230}
1231
1232
1233/**
1234 * MOV emulation.
1235 */
1236static int emInterpretMov(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
1237{
1238 OP_PARAMVAL param1, param2;
1239 int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_DEST);
1240 if(RT_FAILURE(rc))
1241 return VERR_EM_INTERPRETER;
1242
1243 rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, PARAM_SOURCE);
1244 if(RT_FAILURE(rc))
1245 return VERR_EM_INTERPRETER;
1246
1247#ifdef IN_RC
1248 if (TRPMHasTrap(pVCpu))
1249 {
1250 if (TRPMGetErrorCode(pVCpu) & X86_TRAP_PF_RW)
1251 {
1252#else
1253 /** @todo Make this the default and don't rely on TRPM information. */
1254 if (param1.type == PARMTYPE_ADDRESS)
1255 {
1256#endif
1257 RTGCPTR pDest;
1258 uint64_t val64;
1259
1260 switch(param1.type)
1261 {
1262 case PARMTYPE_IMMEDIATE:
1263 if(!(param1.flags & (PARAM_VAL32|PARAM_VAL64)))
1264 return VERR_EM_INTERPRETER;
1265 /* fallthru */
1266
1267 case PARMTYPE_ADDRESS:
1268 pDest = (RTGCPTR)param1.val.val64;
1269 pDest = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, pDest);
1270 break;
1271
1272 default:
1273 AssertFailed();
1274 return VERR_EM_INTERPRETER;
1275 }
1276
1277 switch(param2.type)
1278 {
1279 case PARMTYPE_IMMEDIATE: /* register type is translated to this one too */
1280 val64 = param2.val.val64;
1281 break;
1282
1283 default:
1284 Log(("emInterpretMov: unexpected type=%d rip=%RGv\n", param2.type, (RTGCPTR)pRegFrame->rip));
1285 return VERR_EM_INTERPRETER;
1286 }
1287#ifdef LOG_ENABLED
1288 if (pDis->mode == CPUMODE_64BIT)
1289 LogFlow(("EMInterpretInstruction at %RGv: OP_MOV %RGv <- %RX64 (%d) &val64=%RHv\n", (RTGCPTR)pRegFrame->rip, pDest, val64, param2.size, &val64));
1290 else
1291 LogFlow(("EMInterpretInstruction at %08RX64: OP_MOV %RGv <- %08X (%d) &val64=%RHv\n", pRegFrame->rip, pDest, (uint32_t)val64, param2.size, &val64));
1292#endif
1293
1294 Assert(param2.size <= 8 && param2.size > 0);
1295 EM_ASSERT_FAULT_RETURN(pDest == pvFault, VERR_EM_INTERPRETER);
1296 rc = emRamWrite(pVM, pVCpu, pRegFrame, pDest, &val64, param2.size);
1297 if (RT_FAILURE(rc))
1298 return VERR_EM_INTERPRETER;
1299
1300 *pcbSize = param2.size;
1301 }
1302 else
1303 { /* read fault */
1304 RTGCPTR pSrc;
1305 uint64_t val64;
1306
1307 /* Source */
1308 switch(param2.type)
1309 {
1310 case PARMTYPE_IMMEDIATE:
1311 if(!(param2.flags & (PARAM_VAL32|PARAM_VAL64)))
1312 return VERR_EM_INTERPRETER;
1313 /* fallthru */
1314
1315 case PARMTYPE_ADDRESS:
1316 pSrc = (RTGCPTR)param2.val.val64;
1317 pSrc = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param2, pSrc);
1318 break;
1319
1320 default:
1321 return VERR_EM_INTERPRETER;
1322 }
1323
1324 Assert(param1.size <= 8 && param1.size > 0);
1325 EM_ASSERT_FAULT_RETURN(pSrc == pvFault, VERR_EM_INTERPRETER);
1326 rc = emRamRead(pVM, pVCpu, pRegFrame, &val64, pSrc, param1.size);
1327 if (RT_FAILURE(rc))
1328 return VERR_EM_INTERPRETER;
1329
1330 /* Destination */
1331 switch(param1.type)
1332 {
1333 case PARMTYPE_REGISTER:
1334 switch(param1.size)
1335 {
1336 case 1: rc = DISWriteReg8(pRegFrame, pDis->param1.base.reg_gen, (uint8_t) val64); break;
1337 case 2: rc = DISWriteReg16(pRegFrame, pDis->param1.base.reg_gen, (uint16_t)val64); break;
1338 case 4: rc = DISWriteReg32(pRegFrame, pDis->param1.base.reg_gen, (uint32_t)val64); break;
1339 case 8: rc = DISWriteReg64(pRegFrame, pDis->param1.base.reg_gen, val64); break;
1340 default:
1341 return VERR_EM_INTERPRETER;
1342 }
1343 if (RT_FAILURE(rc))
1344 return rc;
1345 break;
1346
1347 default:
1348 return VERR_EM_INTERPRETER;
1349 }
1350#ifdef LOG_ENABLED
1351 if (pDis->mode == CPUMODE_64BIT)
1352 LogFlow(("EMInterpretInstruction: OP_MOV %RGv -> %RX64 (%d)\n", pSrc, val64, param1.size));
1353 else
1354 LogFlow(("EMInterpretInstruction: OP_MOV %RGv -> %08X (%d)\n", pSrc, (uint32_t)val64, param1.size));
1355#endif
1356 }
1357 return VINF_SUCCESS;
1358#ifdef IN_RC
1359 }
1360#endif
1361 return VERR_EM_INTERPRETER;
1362}
1363
1364
1365#ifndef IN_RC
1366/**
1367 * [REP] STOSWD emulation
1368 */
1369static int emInterpretStosWD(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
1370{
1371 int rc;
1372 RTGCPTR GCDest, GCOffset;
1373 uint32_t cbSize;
1374 uint64_t cTransfers;
1375 int offIncrement;
1376
1377 /* Don't support any but these three prefix bytes. */
1378 if ((pDis->prefix & ~(PREFIX_ADDRSIZE|PREFIX_OPSIZE|PREFIX_REP|PREFIX_REX)))
1379 return VERR_EM_INTERPRETER;
1380
1381 switch (pDis->addrmode)
1382 {
1383 case CPUMODE_16BIT:
1384 GCOffset = pRegFrame->di;
1385 cTransfers = pRegFrame->cx;
1386 break;
1387 case CPUMODE_32BIT:
1388 GCOffset = pRegFrame->edi;
1389 cTransfers = pRegFrame->ecx;
1390 break;
1391 case CPUMODE_64BIT:
1392 GCOffset = pRegFrame->rdi;
1393 cTransfers = pRegFrame->rcx;
1394 break;
1395 default:
1396 AssertFailed();
1397 return VERR_EM_INTERPRETER;
1398 }
1399
1400 GCDest = SELMToFlat(pVM, DIS_SELREG_ES, pRegFrame, GCOffset);
1401 switch (pDis->opmode)
1402 {
1403 case CPUMODE_16BIT:
1404 cbSize = 2;
1405 break;
1406 case CPUMODE_32BIT:
1407 cbSize = 4;
1408 break;
1409 case CPUMODE_64BIT:
1410 cbSize = 8;
1411 break;
1412 default:
1413 AssertFailed();
1414 return VERR_EM_INTERPRETER;
1415 }
1416
1417 offIncrement = pRegFrame->eflags.Bits.u1DF ? -(signed)cbSize : (signed)cbSize;
1418
1419 if (!(pDis->prefix & PREFIX_REP))
1420 {
1421 LogFlow(("emInterpretStosWD dest=%04X:%RGv (%RGv) cbSize=%d\n", pRegFrame->es, GCOffset, GCDest, cbSize));
1422
1423 rc = emRamWrite(pVM, pVCpu, pRegFrame, GCDest, &pRegFrame->rax, cbSize);
1424 if (RT_FAILURE(rc))
1425 return VERR_EM_INTERPRETER;
1426 Assert(rc == VINF_SUCCESS);
1427
1428 /* Update (e/r)di. */
1429 switch (pDis->addrmode)
1430 {
1431 case CPUMODE_16BIT:
1432 pRegFrame->di += offIncrement;
1433 break;
1434 case CPUMODE_32BIT:
1435 pRegFrame->edi += offIncrement;
1436 break;
1437 case CPUMODE_64BIT:
1438 pRegFrame->rdi += offIncrement;
1439 break;
1440 default:
1441 AssertFailed();
1442 return VERR_EM_INTERPRETER;
1443 }
1444
1445 }
1446 else
1447 {
1448 if (!cTransfers)
1449 return VINF_SUCCESS;
1450
1451 /*
1452 * Do *not* try emulate cross page stuff here because we don't know what might
1453 * be waiting for us on the subsequent pages. The caller has only asked us to
1454 * ignore access handlers fro the current page.
1455 * This also fends off big stores which would quickly kill PGMR0DynMap.
1456 */
1457 if ( cbSize > PAGE_SIZE
1458 || cTransfers > PAGE_SIZE
1459 || (GCDest >> PAGE_SHIFT) != ((GCDest + offIncrement * cTransfers) >> PAGE_SHIFT))
1460 {
1461 Log(("STOSWD is crosses pages, chicken out to the recompiler; GCDest=%RGv cbSize=%#x offIncrement=%d cTransfers=%#x\n",
1462 GCDest, cbSize, offIncrement, cTransfers));
1463 return VERR_EM_INTERPRETER;
1464 }
1465
1466 LogFlow(("emInterpretStosWD dest=%04X:%RGv (%RGv) cbSize=%d cTransfers=%x DF=%d\n", pRegFrame->es, GCOffset, GCDest, cbSize, cTransfers, pRegFrame->eflags.Bits.u1DF));
1467 /* Access verification first; we currently can't recover properly from traps inside this instruction */
1468 rc = PGMVerifyAccess(pVCpu, GCDest - ((offIncrement > 0) ? 0 : ((cTransfers-1) * cbSize)),
1469 cTransfers * cbSize,
1470 X86_PTE_RW | (CPUMGetGuestCPL(pVCpu, pRegFrame) == 3 ? X86_PTE_US : 0));
1471 if (rc != VINF_SUCCESS)
1472 {
1473 Log(("STOSWD will generate a trap -> recompiler, rc=%d\n", rc));
1474 return VERR_EM_INTERPRETER;
1475 }
1476
1477 /* REP case */
1478 while (cTransfers)
1479 {
1480 rc = emRamWrite(pVM, pVCpu, pRegFrame, GCDest, &pRegFrame->rax, cbSize);
1481 if (RT_FAILURE(rc))
1482 {
1483 rc = VERR_EM_INTERPRETER;
1484 break;
1485 }
1486
1487 Assert(rc == VINF_SUCCESS);
1488 GCOffset += offIncrement;
1489 GCDest += offIncrement;
1490 cTransfers--;
1491 }
1492
1493 /* Update the registers. */
1494 switch (pDis->addrmode)
1495 {
1496 case CPUMODE_16BIT:
1497 pRegFrame->di = GCOffset;
1498 pRegFrame->cx = cTransfers;
1499 break;
1500 case CPUMODE_32BIT:
1501 pRegFrame->edi = GCOffset;
1502 pRegFrame->ecx = cTransfers;
1503 break;
1504 case CPUMODE_64BIT:
1505 pRegFrame->rdi = GCOffset;
1506 pRegFrame->rcx = cTransfers;
1507 break;
1508 default:
1509 AssertFailed();
1510 return VERR_EM_INTERPRETER;
1511 }
1512 }
1513
1514 *pcbSize = cbSize;
1515 return rc;
1516}
1517#endif /* !IN_RC */
1518
1519#ifndef IN_RC
1520
1521/**
1522 * [LOCK] CMPXCHG emulation.
1523 */
1524static int emInterpretCmpXchg(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
1525{
1526 OP_PARAMVAL param1, param2;
1527
1528#if HC_ARCH_BITS == 32 && !defined(VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0)
1529 Assert(pDis->param1.size <= 4);
1530#endif
1531
1532 /* Source to make DISQueryParamVal read the register value - ugly hack */
1533 int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_SOURCE);
1534 if(RT_FAILURE(rc))
1535 return VERR_EM_INTERPRETER;
1536
1537 rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, PARAM_SOURCE);
1538 if(RT_FAILURE(rc))
1539 return VERR_EM_INTERPRETER;
1540
1541 uint64_t valpar;
1542 switch(param2.type)
1543 {
1544 case PARMTYPE_IMMEDIATE: /* register actually */
1545 valpar = param2.val.val64;
1546 break;
1547
1548 default:
1549 return VERR_EM_INTERPRETER;
1550 }
1551
1552 PGMPAGEMAPLOCK Lock;
1553 RTGCPTR GCPtrPar1;
1554 void *pvParam1;
1555 uint64_t eflags;
1556
1557 AssertReturn(pDis->param1.size == pDis->param2.size, VERR_EM_INTERPRETER);
1558 switch(param1.type)
1559 {
1560 case PARMTYPE_ADDRESS:
1561 GCPtrPar1 = param1.val.val64;
1562 GCPtrPar1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, GCPtrPar1);
1563
1564 rc = PGMPhysGCPtr2CCPtr(pVCpu, GCPtrPar1, &pvParam1, &Lock);
1565 AssertRCReturn(rc, VERR_EM_INTERPRETER);
1566 break;
1567
1568 default:
1569 return VERR_EM_INTERPRETER;
1570 }
1571
1572 LogFlow(("%s %RGv rax=%RX64 %RX64\n", emGetMnemonic(pDis), GCPtrPar1, pRegFrame->rax, valpar));
1573
1574 if (pDis->prefix & PREFIX_LOCK)
1575 eflags = EMEmulateLockCmpXchg(pvParam1, &pRegFrame->rax, valpar, pDis->param2.size);
1576 else
1577 eflags = EMEmulateCmpXchg(pvParam1, &pRegFrame->rax, valpar, pDis->param2.size);
1578
1579 LogFlow(("%s %RGv rax=%RX64 %RX64 ZF=%d\n", emGetMnemonic(pDis), GCPtrPar1, pRegFrame->rax, valpar, !!(eflags & X86_EFL_ZF)));
1580
1581 /* Update guest's eflags and finish. */
1582 pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF))
1583 | (eflags & (X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF));
1584
1585 *pcbSize = param2.size;
1586 PGMPhysReleasePageMappingLock(pVM, &Lock);
1587 return VINF_SUCCESS;
1588}
1589
1590
1591/**
1592 * [LOCK] CMPXCHG8B emulation.
1593 */
1594static int emInterpretCmpXchg8b(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
1595{
1596 Assert(pDis->mode != CPUMODE_64BIT); /** @todo check */
1597 OP_PARAMVAL param1;
1598
1599 /* Source to make DISQueryParamVal read the register value - ugly hack */
1600 int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_SOURCE);
1601 if(RT_FAILURE(rc))
1602 return VERR_EM_INTERPRETER;
1603
1604 RTGCPTR GCPtrPar1;
1605 void *pvParam1;
1606 uint64_t eflags;
1607 PGMPAGEMAPLOCK Lock;
1608
1609 AssertReturn(pDis->param1.size == 8, VERR_EM_INTERPRETER);
1610 switch(param1.type)
1611 {
1612 case PARMTYPE_ADDRESS:
1613 GCPtrPar1 = param1.val.val64;
1614 GCPtrPar1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, GCPtrPar1);
1615
1616 rc = PGMPhysGCPtr2CCPtr(pVCpu, GCPtrPar1, &pvParam1, &Lock);
1617 AssertRCReturn(rc, VERR_EM_INTERPRETER);
1618 break;
1619
1620 default:
1621 return VERR_EM_INTERPRETER;
1622 }
1623
1624 LogFlow(("%s %RGv=%08x eax=%08x\n", emGetMnemonic(pDis), pvParam1, pRegFrame->eax));
1625
1626 if (pDis->prefix & PREFIX_LOCK)
1627 eflags = EMEmulateLockCmpXchg8b(pvParam1, &pRegFrame->eax, &pRegFrame->edx, pRegFrame->ebx, pRegFrame->ecx);
1628 else
1629 eflags = EMEmulateCmpXchg8b(pvParam1, &pRegFrame->eax, &pRegFrame->edx, pRegFrame->ebx, pRegFrame->ecx);
1630
1631 LogFlow(("%s %RGv=%08x eax=%08x ZF=%d\n", emGetMnemonic(pDis), pvParam1, pRegFrame->eax, !!(eflags & X86_EFL_ZF)));
1632
1633 /* Update guest's eflags and finish; note that *only* ZF is affected. */
1634 pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_ZF))
1635 | (eflags & (X86_EFL_ZF));
1636
1637 *pcbSize = 8;
1638 PGMPhysReleasePageMappingLock(pVM, &Lock);
1639 return VINF_SUCCESS;
1640}
1641
1642#else /* IN_RC */
1643
1644/**
1645 * [LOCK] CMPXCHG emulation.
1646 */
1647static int emInterpretCmpXchg(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
1648{
1649 Assert(pDis->mode != CPUMODE_64BIT); /** @todo check */
1650 OP_PARAMVAL param1, param2;
1651
1652 /* Source to make DISQueryParamVal read the register value - ugly hack */
1653 int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_SOURCE);
1654 if(RT_FAILURE(rc))
1655 return VERR_EM_INTERPRETER;
1656
1657 rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, PARAM_SOURCE);
1658 if(RT_FAILURE(rc))
1659 return VERR_EM_INTERPRETER;
1660
1661 if (TRPMHasTrap(pVCpu))
1662 {
1663 if (TRPMGetErrorCode(pVCpu) & X86_TRAP_PF_RW)
1664 {
1665 RTRCPTR pParam1;
1666 uint32_t valpar, eflags;
1667
1668 AssertReturn(pDis->param1.size == pDis->param2.size, VERR_EM_INTERPRETER);
1669 switch(param1.type)
1670 {
1671 case PARMTYPE_ADDRESS:
1672 pParam1 = (RTRCPTR)(uintptr_t)emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, (RTRCUINTPTR)param1.val.val64);
1673 EM_ASSERT_FAULT_RETURN(pParam1 == (RTRCPTR)pvFault, VERR_EM_INTERPRETER);
1674 break;
1675
1676 default:
1677 return VERR_EM_INTERPRETER;
1678 }
1679
1680 switch(param2.type)
1681 {
1682 case PARMTYPE_IMMEDIATE: /* register actually */
1683 valpar = param2.val.val32;
1684 break;
1685
1686 default:
1687 return VERR_EM_INTERPRETER;
1688 }
1689
1690 LogFlow(("%s %RRv eax=%08x %08x\n", emGetMnemonic(pDis), pParam1, pRegFrame->eax, valpar));
1691
1692 MMGCRamRegisterTrapHandler(pVM);
1693 if (pDis->prefix & PREFIX_LOCK)
1694 rc = EMGCEmulateLockCmpXchg(pParam1, &pRegFrame->eax, valpar, pDis->param2.size, &eflags);
1695 else
1696 rc = EMGCEmulateCmpXchg(pParam1, &pRegFrame->eax, valpar, pDis->param2.size, &eflags);
1697 MMGCRamDeregisterTrapHandler(pVM);
1698
1699 if (RT_FAILURE(rc))
1700 {
1701 Log(("%s %RGv eax=%08x %08x -> emulation failed due to page fault!\n", emGetMnemonic(pDis), pParam1, pRegFrame->eax, valpar));
1702 return VERR_EM_INTERPRETER;
1703 }
1704
1705 LogFlow(("%s %RRv eax=%08x %08x ZF=%d\n", emGetMnemonic(pDis), pParam1, pRegFrame->eax, valpar, !!(eflags & X86_EFL_ZF)));
1706
1707 /* Update guest's eflags and finish. */
1708 pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF))
1709 | (eflags & (X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF));
1710
1711 *pcbSize = param2.size;
1712 return VINF_SUCCESS;
1713 }
1714 }
1715 return VERR_EM_INTERPRETER;
1716}
1717
1718
1719/**
1720 * [LOCK] CMPXCHG8B emulation.
1721 */
1722static int emInterpretCmpXchg8b(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
1723{
1724 Assert(pDis->mode != CPUMODE_64BIT); /** @todo check */
1725 OP_PARAMVAL param1;
1726
1727 /* Source to make DISQueryParamVal read the register value - ugly hack */
1728 int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_SOURCE);
1729 if(RT_FAILURE(rc))
1730 return VERR_EM_INTERPRETER;
1731
1732 if (TRPMHasTrap(pVCpu))
1733 {
1734 if (TRPMGetErrorCode(pVCpu) & X86_TRAP_PF_RW)
1735 {
1736 RTRCPTR pParam1;
1737 uint32_t eflags;
1738
1739 AssertReturn(pDis->param1.size == 8, VERR_EM_INTERPRETER);
1740 switch(param1.type)
1741 {
1742 case PARMTYPE_ADDRESS:
1743 pParam1 = (RTRCPTR)(uintptr_t)emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, (RTRCUINTPTR)param1.val.val64);
1744 EM_ASSERT_FAULT_RETURN(pParam1 == (RTRCPTR)pvFault, VERR_EM_INTERPRETER);
1745 break;
1746
1747 default:
1748 return VERR_EM_INTERPRETER;
1749 }
1750
1751 LogFlow(("%s %RRv=%08x eax=%08x\n", emGetMnemonic(pDis), pParam1, pRegFrame->eax));
1752
1753 MMGCRamRegisterTrapHandler(pVM);
1754 if (pDis->prefix & PREFIX_LOCK)
1755 rc = EMGCEmulateLockCmpXchg8b(pParam1, &pRegFrame->eax, &pRegFrame->edx, pRegFrame->ebx, pRegFrame->ecx, &eflags);
1756 else
1757 rc = EMGCEmulateCmpXchg8b(pParam1, &pRegFrame->eax, &pRegFrame->edx, pRegFrame->ebx, pRegFrame->ecx, &eflags);
1758 MMGCRamDeregisterTrapHandler(pVM);
1759
1760 if (RT_FAILURE(rc))
1761 {
1762 Log(("%s %RGv=%08x eax=%08x -> emulation failed due to page fault!\n", emGetMnemonic(pDis), pParam1, pRegFrame->eax));
1763 return VERR_EM_INTERPRETER;
1764 }
1765
1766 LogFlow(("%s %RGv=%08x eax=%08x ZF=%d\n", emGetMnemonic(pDis), pParam1, pRegFrame->eax, !!(eflags & X86_EFL_ZF)));
1767
1768 /* Update guest's eflags and finish; note that *only* ZF is affected. */
1769 pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_ZF))
1770 | (eflags & (X86_EFL_ZF));
1771
1772 *pcbSize = 8;
1773 return VINF_SUCCESS;
1774 }
1775 }
1776 return VERR_EM_INTERPRETER;
1777}
1778
1779#endif /* IN_RC */
1780
1781#ifdef IN_RC
1782/**
1783 * [LOCK] XADD emulation.
1784 */
1785static int emInterpretXAdd(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
1786{
1787 Assert(pDis->mode != CPUMODE_64BIT); /** @todo check */
1788 OP_PARAMVAL param1;
1789 uint32_t *pParamReg2;
1790 size_t cbSizeParamReg2;
1791
1792 /* Source to make DISQueryParamVal read the register value - ugly hack */
1793 int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_SOURCE);
1794 if(RT_FAILURE(rc))
1795 return VERR_EM_INTERPRETER;
1796
1797 rc = DISQueryParamRegPtr(pRegFrame, pDis, &pDis->param2, (void **)&pParamReg2, &cbSizeParamReg2);
1798 Assert(cbSizeParamReg2 <= 4);
1799 if(RT_FAILURE(rc))
1800 return VERR_EM_INTERPRETER;
1801
1802 if (TRPMHasTrap(pVCpu))
1803 {
1804 if (TRPMGetErrorCode(pVCpu) & X86_TRAP_PF_RW)
1805 {
1806 RTRCPTR pParam1;
1807 uint32_t eflags;
1808
1809 AssertReturn(pDis->param1.size == pDis->param2.size, VERR_EM_INTERPRETER);
1810 switch(param1.type)
1811 {
1812 case PARMTYPE_ADDRESS:
1813 pParam1 = (RTRCPTR)(uintptr_t)emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, (RTRCUINTPTR)param1.val.val64);
1814 EM_ASSERT_FAULT_RETURN(pParam1 == (RTRCPTR)pvFault, VERR_EM_INTERPRETER);
1815 break;
1816
1817 default:
1818 return VERR_EM_INTERPRETER;
1819 }
1820
1821 LogFlow(("XAdd %RRv=%08x reg=%08x\n", pParam1, *pParamReg2));
1822
1823 MMGCRamRegisterTrapHandler(pVM);
1824 if (pDis->prefix & PREFIX_LOCK)
1825 rc = EMGCEmulateLockXAdd(pParam1, pParamReg2, cbSizeParamReg2, &eflags);
1826 else
1827 rc = EMGCEmulateXAdd(pParam1, pParamReg2, cbSizeParamReg2, &eflags);
1828 MMGCRamDeregisterTrapHandler(pVM);
1829
1830 if (RT_FAILURE(rc))
1831 {
1832 Log(("XAdd %RGv reg=%08x -> emulation failed due to page fault!\n", pParam1, *pParamReg2));
1833 return VERR_EM_INTERPRETER;
1834 }
1835
1836 LogFlow(("XAdd %RGv reg=%08x ZF=%d\n", pParam1, *pParamReg2, !!(eflags & X86_EFL_ZF)));
1837
1838 /* Update guest's eflags and finish. */
1839 pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF))
1840 | (eflags & (X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF));
1841
1842 *pcbSize = cbSizeParamReg2;
1843 return VINF_SUCCESS;
1844 }
1845 }
1846 return VERR_EM_INTERPRETER;
1847}
1848#endif /* IN_RC */
1849
1850
1851#ifdef IN_RC
1852/**
1853 * Interpret IRET (currently only to V86 code)
1854 *
1855 * @returns VBox status code.
1856 * @param pVM The VM handle.
1857 * @param pVCpu The VMCPU handle.
1858 * @param pRegFrame The register frame.
1859 *
1860 */
1861VMMDECL(int) EMInterpretIret(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame)
1862{
1863 RTGCUINTPTR pIretStack = (RTGCUINTPTR)pRegFrame->esp;
1864 RTGCUINTPTR eip, cs, esp, ss, eflags, ds, es, fs, gs, uMask;
1865 int rc;
1866
1867 Assert(!CPUMIsGuestIn64BitCode(pVCpu, pRegFrame));
1868
1869 rc = emRamRead(pVM, pVCpu, pRegFrame, &eip, (RTGCPTR)pIretStack , 4);
1870 rc |= emRamRead(pVM, pVCpu, pRegFrame, &cs, (RTGCPTR)(pIretStack + 4), 4);
1871 rc |= emRamRead(pVM, pVCpu, pRegFrame, &eflags, (RTGCPTR)(pIretStack + 8), 4);
1872 AssertRCReturn(rc, VERR_EM_INTERPRETER);
1873 AssertReturn(eflags & X86_EFL_VM, VERR_EM_INTERPRETER);
1874
1875 rc |= emRamRead(pVM, pVCpu, pRegFrame, &esp, (RTGCPTR)(pIretStack + 12), 4);
1876 rc |= emRamRead(pVM, pVCpu, pRegFrame, &ss, (RTGCPTR)(pIretStack + 16), 4);
1877 rc |= emRamRead(pVM, pVCpu, pRegFrame, &es, (RTGCPTR)(pIretStack + 20), 4);
1878 rc |= emRamRead(pVM, pVCpu, pRegFrame, &ds, (RTGCPTR)(pIretStack + 24), 4);
1879 rc |= emRamRead(pVM, pVCpu, pRegFrame, &fs, (RTGCPTR)(pIretStack + 28), 4);
1880 rc |= emRamRead(pVM, pVCpu, pRegFrame, &gs, (RTGCPTR)(pIretStack + 32), 4);
1881 AssertRCReturn(rc, VERR_EM_INTERPRETER);
1882
1883 pRegFrame->eip = eip & 0xffff;
1884 pRegFrame->cs = cs;
1885
1886 /* Mask away all reserved bits */
1887 uMask = X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_TF | X86_EFL_IF | X86_EFL_DF | X86_EFL_OF | X86_EFL_IOPL | X86_EFL_NT | X86_EFL_RF | X86_EFL_VM | X86_EFL_AC | X86_EFL_VIF | X86_EFL_VIP | X86_EFL_ID;
1888 eflags &= uMask;
1889
1890#ifndef IN_RING0
1891 CPUMRawSetEFlags(pVCpu, pRegFrame, eflags);
1892#endif
1893 Assert((pRegFrame->eflags.u32 & (X86_EFL_IF|X86_EFL_IOPL)) == X86_EFL_IF);
1894
1895 pRegFrame->esp = esp;
1896 pRegFrame->ss = ss;
1897 pRegFrame->ds = ds;
1898 pRegFrame->es = es;
1899 pRegFrame->fs = fs;
1900 pRegFrame->gs = gs;
1901
1902 return VINF_SUCCESS;
1903}
1904#endif /* IN_RC */
1905
1906
1907/**
1908 * IRET Emulation.
1909 */
1910static int emInterpretIret(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
1911{
1912 /* only allow direct calls to EMInterpretIret for now */
1913 return VERR_EM_INTERPRETER;
1914}
1915
1916/**
1917 * WBINVD Emulation.
1918 */
1919static int emInterpretWbInvd(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
1920{
1921 /* Nothing to do. */
1922 return VINF_SUCCESS;
1923}
1924
1925
1926/**
1927 * Interpret INVLPG
1928 *
1929 * @returns VBox status code.
1930 * @param pVM The VM handle.
1931 * @param pVCpu The VMCPU handle.
1932 * @param pRegFrame The register frame.
1933 * @param pAddrGC Operand address
1934 *
1935 */
1936VMMDECL(int) EMInterpretInvlpg(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, RTGCPTR pAddrGC)
1937{
1938 int rc;
1939
1940 /** @todo is addr always a flat linear address or ds based
1941 * (in absence of segment override prefixes)????
1942 */
1943#ifdef IN_RC
1944 LogFlow(("RC: EMULATE: invlpg %RGv\n", pAddrGC));
1945#endif
1946 rc = PGMInvalidatePage(pVCpu, pAddrGC);
1947 if ( rc == VINF_SUCCESS
1948 || rc == VINF_PGM_SYNC_CR3 /* we can rely on the FF */)
1949 return VINF_SUCCESS;
1950 AssertMsgReturn(rc == VINF_EM_RAW_EMULATE_INSTR,
1951 ("%Rrc addr=%RGv\n", rc, pAddrGC),
1952 VERR_EM_INTERPRETER);
1953 return rc;
1954}
1955
1956
1957/**
1958 * INVLPG Emulation.
1959 */
1960static int emInterpretInvlPg(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
1961{
1962 OP_PARAMVAL param1;
1963 RTGCPTR addr;
1964
1965 int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_SOURCE);
1966 if(RT_FAILURE(rc))
1967 return VERR_EM_INTERPRETER;
1968
1969 switch(param1.type)
1970 {
1971 case PARMTYPE_IMMEDIATE:
1972 case PARMTYPE_ADDRESS:
1973 if(!(param1.flags & (PARAM_VAL32|PARAM_VAL64)))
1974 return VERR_EM_INTERPRETER;
1975 addr = (RTGCPTR)param1.val.val64;
1976 break;
1977
1978 default:
1979 return VERR_EM_INTERPRETER;
1980 }
1981
1982 /** @todo is addr always a flat linear address or ds based
1983 * (in absence of segment override prefixes)????
1984 */
1985#ifdef IN_RC
1986 LogFlow(("RC: EMULATE: invlpg %RGv\n", addr));
1987#endif
1988 rc = PGMInvalidatePage(pVCpu, addr);
1989 if ( rc == VINF_SUCCESS
1990 || rc == VINF_PGM_SYNC_CR3 /* we can rely on the FF */)
1991 return VINF_SUCCESS;
1992 AssertMsgReturn(rc == VINF_EM_RAW_EMULATE_INSTR,
1993 ("%Rrc addr=%RGv\n", rc, addr),
1994 VERR_EM_INTERPRETER);
1995 return rc;
1996}
1997
1998
1999/**
2000 * Interpret CPUID given the parameters in the CPU context
2001 *
2002 * @returns VBox status code.
2003 * @param pVM The VM handle.
2004 * @param pVCpu The VMCPU handle.
2005 * @param pRegFrame The register frame.
2006 *
2007 */
2008VMMDECL(int) EMInterpretCpuId(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame)
2009{
2010 uint32_t iLeaf = pRegFrame->eax;
2011
2012 /* cpuid clears the high dwords of the affected 64 bits registers. */
2013 pRegFrame->rax = 0;
2014 pRegFrame->rbx = 0;
2015 pRegFrame->rcx &= UINT64_C(0x00000000ffffffff);
2016 pRegFrame->rdx = 0;
2017
2018 /* Note: operates the same in 64 and non-64 bits mode. */
2019 CPUMGetGuestCpuId(pVCpu, iLeaf, &pRegFrame->eax, &pRegFrame->ebx, &pRegFrame->ecx, &pRegFrame->edx);
2020 Log(("Emulate: CPUID %x -> %08x %08x %08x %08x\n", iLeaf, pRegFrame->eax, pRegFrame->ebx, pRegFrame->ecx, pRegFrame->edx));
2021 return VINF_SUCCESS;
2022}
2023
2024
2025/**
2026 * CPUID Emulation.
2027 */
2028static int emInterpretCpuId(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2029{
2030 int rc = EMInterpretCpuId(pVM, pVCpu, pRegFrame);
2031 return rc;
2032}
2033
2034
2035/**
2036 * Interpret CRx read
2037 *
2038 * @returns VBox status code.
2039 * @param pVM The VM handle.
2040 * @param pVCpu The VMCPU handle.
2041 * @param pRegFrame The register frame.
2042 * @param DestRegGen General purpose register index (USE_REG_E**))
2043 * @param SrcRegCRx CRx register index (USE_REG_CR*)
2044 *
2045 */
2046VMMDECL(int) EMInterpretCRxRead(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, uint32_t DestRegGen, uint32_t SrcRegCrx)
2047{
2048 int rc;
2049 uint64_t val64;
2050
2051 if (SrcRegCrx == USE_REG_CR8)
2052 {
2053 val64 = 0;
2054 rc = PDMApicGetTPR(pVCpu, (uint8_t *)&val64, NULL);
2055 AssertMsgRCReturn(rc, ("PDMApicGetTPR failed\n"), VERR_EM_INTERPRETER);
2056 val64 >>= 4; /* bits 7-4 contain the task priority that go in cr8, bits 3-0*/
2057 }
2058 else
2059 {
2060 rc = CPUMGetGuestCRx(pVCpu, SrcRegCrx, &val64);
2061 AssertMsgRCReturn(rc, ("CPUMGetGuestCRx %d failed\n", SrcRegCrx), VERR_EM_INTERPRETER);
2062 }
2063
2064 if (CPUMIsGuestIn64BitCode(pVCpu, pRegFrame))
2065 rc = DISWriteReg64(pRegFrame, DestRegGen, val64);
2066 else
2067 rc = DISWriteReg32(pRegFrame, DestRegGen, val64);
2068
2069 if(RT_SUCCESS(rc))
2070 {
2071 LogFlow(("MOV_CR: gen32=%d CR=%d val=%RX64\n", DestRegGen, SrcRegCrx, val64));
2072 return VINF_SUCCESS;
2073 }
2074 return VERR_EM_INTERPRETER;
2075}
2076
2077
2078
2079/**
2080 * Interpret CLTS
2081 *
2082 * @returns VBox status code.
2083 * @param pVM The VM handle.
2084 * @param pVCpu The VMCPU handle.
2085 *
2086 */
2087VMMDECL(int) EMInterpretCLTS(PVM pVM, PVMCPU pVCpu)
2088{
2089 uint64_t cr0 = CPUMGetGuestCR0(pVCpu);
2090 if (!(cr0 & X86_CR0_TS))
2091 return VINF_SUCCESS;
2092 return CPUMSetGuestCR0(pVCpu, cr0 & ~X86_CR0_TS);
2093}
2094
2095/**
2096 * CLTS Emulation.
2097 */
2098static int emInterpretClts(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2099{
2100 return EMInterpretCLTS(pVM, pVCpu);
2101}
2102
2103
2104/**
2105 * Update CRx
2106 *
2107 * @returns VBox status code.
2108 * @param pVM The VM handle.
2109 * @param pVCpu The VMCPU handle.
2110 * @param pRegFrame The register frame.
2111 * @param DestRegCRx CRx register index (USE_REG_CR*)
2112 * @param val New CRx value
2113 *
2114 */
2115static int emUpdateCRx(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, uint32_t DestRegCrx, uint64_t val)
2116{
2117 uint64_t oldval;
2118 uint64_t msrEFER;
2119 int rc, rc2;
2120
2121 /** @todo Clean up this mess. */
2122 LogFlow(("EMInterpretCRxWrite at %RGv CR%d <- %RX64\n", (RTGCPTR)pRegFrame->rip, DestRegCrx, val));
2123 switch (DestRegCrx)
2124 {
2125 case USE_REG_CR0:
2126 oldval = CPUMGetGuestCR0(pVCpu);
2127#ifdef IN_RC
2128 /* CR0.WP and CR0.AM changes require a reschedule run in ring 3. */
2129 if ( (val & (X86_CR0_WP | X86_CR0_AM))
2130 != (oldval & (X86_CR0_WP | X86_CR0_AM)))
2131 return VERR_EM_INTERPRETER;
2132#endif
2133 rc = VINF_SUCCESS;
2134 CPUMSetGuestCR0(pVCpu, val);
2135 val = CPUMGetGuestCR0(pVCpu);
2136 if ( (oldval & (X86_CR0_PG | X86_CR0_WP | X86_CR0_PE))
2137 != (val & (X86_CR0_PG | X86_CR0_WP | X86_CR0_PE)))
2138 {
2139 /* global flush */
2140 rc = PGMFlushTLB(pVCpu, CPUMGetGuestCR3(pVCpu), true /* global */);
2141 AssertRCReturn(rc, rc);
2142 }
2143
2144 /* Deal with long mode enabling/disabling. */
2145 msrEFER = CPUMGetGuestEFER(pVCpu);
2146 if (msrEFER & MSR_K6_EFER_LME)
2147 {
2148 if ( !(oldval & X86_CR0_PG)
2149 && (val & X86_CR0_PG))
2150 {
2151 /* Illegal to have an active 64 bits CS selector (AMD Arch. Programmer's Manual Volume 2: Table 14-5) */
2152 if (pRegFrame->csHid.Attr.n.u1Long)
2153 {
2154 AssertMsgFailed(("Illegal enabling of paging with CS.u1Long = 1!!\n"));
2155 return VERR_EM_INTERPRETER; /* @todo generate #GP(0) */
2156 }
2157
2158 /* Illegal to switch to long mode before activating PAE first (AMD Arch. Programmer's Manual Volume 2: Table 14-5) */
2159 if (!(CPUMGetGuestCR4(pVCpu) & X86_CR4_PAE))
2160 {
2161 AssertMsgFailed(("Illegal enabling of paging with PAE disabled!!\n"));
2162 return VERR_EM_INTERPRETER; /* @todo generate #GP(0) */
2163 }
2164 msrEFER |= MSR_K6_EFER_LMA;
2165 }
2166 else
2167 if ( (oldval & X86_CR0_PG)
2168 && !(val & X86_CR0_PG))
2169 {
2170 msrEFER &= ~MSR_K6_EFER_LMA;
2171 /* @todo Do we need to cut off rip here? High dword of rip is undefined, so it shouldn't really matter. */
2172 }
2173 CPUMSetGuestEFER(pVCpu, msrEFER);
2174 }
2175 rc2 = PGMChangeMode(pVCpu, CPUMGetGuestCR0(pVCpu), CPUMGetGuestCR4(pVCpu), CPUMGetGuestEFER(pVCpu));
2176 return rc2 == VINF_SUCCESS ? rc : rc2;
2177
2178 case USE_REG_CR2:
2179 rc = CPUMSetGuestCR2(pVCpu, val); AssertRC(rc);
2180 return VINF_SUCCESS;
2181
2182 case USE_REG_CR3:
2183 /* Reloading the current CR3 means the guest just wants to flush the TLBs */
2184 rc = CPUMSetGuestCR3(pVCpu, val); AssertRC(rc);
2185 if (CPUMGetGuestCR0(pVCpu) & X86_CR0_PG)
2186 {
2187 /* flush */
2188 rc = PGMFlushTLB(pVCpu, val, !(CPUMGetGuestCR4(pVCpu) & X86_CR4_PGE));
2189 AssertRCReturn(rc, rc);
2190 }
2191 return rc;
2192
2193 case USE_REG_CR4:
2194 oldval = CPUMGetGuestCR4(pVCpu);
2195 rc = CPUMSetGuestCR4(pVCpu, val); AssertRC(rc);
2196 val = CPUMGetGuestCR4(pVCpu);
2197
2198 /* Illegal to disable PAE when long mode is active. (AMD Arch. Programmer's Manual Volume 2: Table 14-5) */
2199 msrEFER = CPUMGetGuestEFER(pVCpu);
2200 if ( (msrEFER & MSR_K6_EFER_LMA)
2201 && (oldval & X86_CR4_PAE)
2202 && !(val & X86_CR4_PAE))
2203 {
2204 return VERR_EM_INTERPRETER; /** @todo generate #GP(0) */
2205 }
2206
2207 rc = VINF_SUCCESS;
2208 if ( (oldval & (X86_CR4_PGE|X86_CR4_PAE|X86_CR4_PSE))
2209 != (val & (X86_CR4_PGE|X86_CR4_PAE|X86_CR4_PSE)))
2210 {
2211 /* global flush */
2212 rc = PGMFlushTLB(pVCpu, CPUMGetGuestCR3(pVCpu), true /* global */);
2213 AssertRCReturn(rc, rc);
2214 }
2215
2216 /* Feeling extremely lazy. */
2217# ifdef IN_RC
2218 if ( (oldval & (X86_CR4_OSFSXR|X86_CR4_OSXMMEEXCPT|X86_CR4_PCE|X86_CR4_MCE|X86_CR4_PAE|X86_CR4_DE|X86_CR4_TSD|X86_CR4_PVI|X86_CR4_VME))
2219 != (val & (X86_CR4_OSFSXR|X86_CR4_OSXMMEEXCPT|X86_CR4_PCE|X86_CR4_MCE|X86_CR4_PAE|X86_CR4_DE|X86_CR4_TSD|X86_CR4_PVI|X86_CR4_VME)))
2220 {
2221 Log(("emInterpretMovCRx: CR4: %#RX64->%#RX64 => R3\n", oldval, val));
2222 VMCPU_FF_SET(pVCpu, VMCPU_FF_TO_R3);
2223 }
2224# endif
2225 if ((val ^ oldval) & X86_CR4_VME)
2226 VMCPU_FF_SET(pVCpu, VMCPU_FF_SELM_SYNC_TSS);
2227
2228 rc2 = PGMChangeMode(pVCpu, CPUMGetGuestCR0(pVCpu), CPUMGetGuestCR4(pVCpu), CPUMGetGuestEFER(pVCpu));
2229 return rc2 == VINF_SUCCESS ? rc : rc2;
2230
2231 case USE_REG_CR8:
2232 return PDMApicSetTPR(pVCpu, val << 4); /* cr8 bits 3-0 correspond to bits 7-4 of the task priority mmio register. */
2233
2234 default:
2235 AssertFailed();
2236 case USE_REG_CR1: /* illegal op */
2237 break;
2238 }
2239 return VERR_EM_INTERPRETER;
2240}
2241
2242/**
2243 * Interpret CRx write
2244 *
2245 * @returns VBox status code.
2246 * @param pVM The VM handle.
2247 * @param pVCpu The VMCPU handle.
2248 * @param pRegFrame The register frame.
2249 * @param DestRegCRx CRx register index (USE_REG_CR*)
2250 * @param SrcRegGen General purpose register index (USE_REG_E**))
2251 *
2252 */
2253VMMDECL(int) EMInterpretCRxWrite(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, uint32_t DestRegCrx, uint32_t SrcRegGen)
2254{
2255 uint64_t val;
2256 int rc;
2257
2258 if (CPUMIsGuestIn64BitCode(pVCpu, pRegFrame))
2259 {
2260 rc = DISFetchReg64(pRegFrame, SrcRegGen, &val);
2261 }
2262 else
2263 {
2264 uint32_t val32;
2265 rc = DISFetchReg32(pRegFrame, SrcRegGen, &val32);
2266 val = val32;
2267 }
2268
2269 if (RT_SUCCESS(rc))
2270 return emUpdateCRx(pVM, pVCpu, pRegFrame, DestRegCrx, val);
2271
2272 return VERR_EM_INTERPRETER;
2273}
2274
2275/**
2276 * Interpret LMSW
2277 *
2278 * @returns VBox status code.
2279 * @param pVM The VM handle.
2280 * @param pVCpu The VMCPU handle.
2281 * @param pRegFrame The register frame.
2282 * @param u16Data LMSW source data.
2283 *
2284 */
2285VMMDECL(int) EMInterpretLMSW(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, uint16_t u16Data)
2286{
2287 uint64_t OldCr0 = CPUMGetGuestCR0(pVCpu);
2288
2289 /* Only PE, MP, EM and TS can be changed; note that PE can't be cleared by this instruction. */
2290 uint64_t NewCr0 = ( OldCr0 & ~( X86_CR0_MP | X86_CR0_EM | X86_CR0_TS))
2291 | (u16Data & (X86_CR0_PE | X86_CR0_MP | X86_CR0_EM | X86_CR0_TS));
2292
2293 return emUpdateCRx(pVM, pVCpu, pRegFrame, USE_REG_CR0, NewCr0);
2294}
2295
2296/**
2297 * LMSW Emulation.
2298 */
2299static int emInterpretLmsw(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2300{
2301 OP_PARAMVAL param1;
2302 uint32_t val;
2303
2304 int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_SOURCE);
2305 if(RT_FAILURE(rc))
2306 return VERR_EM_INTERPRETER;
2307
2308 switch(param1.type)
2309 {
2310 case PARMTYPE_IMMEDIATE:
2311 case PARMTYPE_ADDRESS:
2312 if(!(param1.flags & PARAM_VAL16))
2313 return VERR_EM_INTERPRETER;
2314 val = param1.val.val32;
2315 break;
2316
2317 default:
2318 return VERR_EM_INTERPRETER;
2319 }
2320
2321 LogFlow(("emInterpretLmsw %x\n", val));
2322 return EMInterpretLMSW(pVM, pVCpu, pRegFrame, val);
2323}
2324
2325#ifdef EM_EMULATE_SMSW
2326/**
2327 * SMSW Emulation.
2328 */
2329static int emInterpretSmsw(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2330{
2331 OP_PARAMVAL param1;
2332 uint64_t cr0 = CPUMGetGuestCR0(pVCpu);
2333
2334 int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_SOURCE);
2335 if(RT_FAILURE(rc))
2336 return VERR_EM_INTERPRETER;
2337
2338 switch(param1.type)
2339 {
2340 case PARMTYPE_IMMEDIATE:
2341 if(param1.size != sizeof(uint16_t))
2342 return VERR_EM_INTERPRETER;
2343 LogFlow(("emInterpretSmsw %d <- cr0 (%x)\n", pDis->param1.base.reg_gen, cr0));
2344 rc = DISWriteReg16(pRegFrame, pDis->param1.base.reg_gen, cr0);
2345 break;
2346
2347 case PARMTYPE_ADDRESS:
2348 {
2349 RTGCPTR pParam1;
2350
2351 /* Actually forced to 16 bits regardless of the operand size. */
2352 if(param1.size != sizeof(uint16_t))
2353 return VERR_EM_INTERPRETER;
2354
2355 pParam1 = (RTGCPTR)param1.val.val64;
2356 pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, pParam1);
2357 LogFlow(("emInterpretSmsw %RGv <- cr0 (%x)\n", pParam1, cr0));
2358
2359 rc = emRamWrite(pVM, pVCpu, pRegFrame, pParam1, &cr0, sizeof(uint16_t));
2360 if (RT_FAILURE(rc))
2361 {
2362 AssertMsgFailed(("emRamWrite %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
2363 return VERR_EM_INTERPRETER;
2364 }
2365 break;
2366 }
2367
2368 default:
2369 return VERR_EM_INTERPRETER;
2370 }
2371
2372 LogFlow(("emInterpretSmsw %x\n", cr0));
2373 return rc;
2374}
2375#endif
2376
2377/**
2378 * MOV CRx
2379 */
2380static int emInterpretMovCRx(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2381{
2382 if ((pDis->param1.flags == USE_REG_GEN32 || pDis->param1.flags == USE_REG_GEN64) && pDis->param2.flags == USE_REG_CR)
2383 return EMInterpretCRxRead(pVM, pVCpu, pRegFrame, pDis->param1.base.reg_gen, pDis->param2.base.reg_ctrl);
2384
2385 if (pDis->param1.flags == USE_REG_CR && (pDis->param2.flags == USE_REG_GEN32 || pDis->param2.flags == USE_REG_GEN64))
2386 return EMInterpretCRxWrite(pVM, pVCpu, pRegFrame, pDis->param1.base.reg_ctrl, pDis->param2.base.reg_gen);
2387
2388 AssertMsgFailedReturn(("Unexpected control register move\n"), VERR_EM_INTERPRETER);
2389 return VERR_EM_INTERPRETER;
2390}
2391
2392
2393/**
2394 * Interpret DRx write
2395 *
2396 * @returns VBox status code.
2397 * @param pVM The VM handle.
2398 * @param pVCpu The VMCPU handle.
2399 * @param pRegFrame The register frame.
2400 * @param DestRegDRx DRx register index (USE_REG_DR*)
2401 * @param SrcRegGen General purpose register index (USE_REG_E**))
2402 *
2403 */
2404VMMDECL(int) EMInterpretDRxWrite(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, uint32_t DestRegDrx, uint32_t SrcRegGen)
2405{
2406 uint64_t val;
2407 int rc;
2408
2409 if (CPUMIsGuestIn64BitCode(pVCpu, pRegFrame))
2410 {
2411 rc = DISFetchReg64(pRegFrame, SrcRegGen, &val);
2412 }
2413 else
2414 {
2415 uint32_t val32;
2416 rc = DISFetchReg32(pRegFrame, SrcRegGen, &val32);
2417 val = val32;
2418 }
2419
2420 if (RT_SUCCESS(rc))
2421 {
2422 /** @todo we don't fail if illegal bits are set/cleared for e.g. dr7 */
2423 rc = CPUMSetGuestDRx(pVCpu, DestRegDrx, val);
2424 if (RT_SUCCESS(rc))
2425 return rc;
2426 AssertMsgFailed(("CPUMSetGuestDRx %d failed\n", DestRegDrx));
2427 }
2428 return VERR_EM_INTERPRETER;
2429}
2430
2431
2432/**
2433 * Interpret DRx read
2434 *
2435 * @returns VBox status code.
2436 * @param pVM The VM handle.
2437 * @param pVCpu The VMCPU handle.
2438 * @param pRegFrame The register frame.
2439 * @param DestRegGen General purpose register index (USE_REG_E**))
2440 * @param SrcRegDRx DRx register index (USE_REG_DR*)
2441 *
2442 */
2443VMMDECL(int) EMInterpretDRxRead(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, uint32_t DestRegGen, uint32_t SrcRegDrx)
2444{
2445 uint64_t val64;
2446
2447 int rc = CPUMGetGuestDRx(pVCpu, SrcRegDrx, &val64);
2448 AssertMsgRCReturn(rc, ("CPUMGetGuestDRx %d failed\n", SrcRegDrx), VERR_EM_INTERPRETER);
2449 if (CPUMIsGuestIn64BitCode(pVCpu, pRegFrame))
2450 {
2451 rc = DISWriteReg64(pRegFrame, DestRegGen, val64);
2452 }
2453 else
2454 rc = DISWriteReg32(pRegFrame, DestRegGen, (uint32_t)val64);
2455
2456 if (RT_SUCCESS(rc))
2457 return VINF_SUCCESS;
2458
2459 return VERR_EM_INTERPRETER;
2460}
2461
2462
2463/**
2464 * MOV DRx
2465 */
2466static int emInterpretMovDRx(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2467{
2468 int rc = VERR_EM_INTERPRETER;
2469
2470 if((pDis->param1.flags == USE_REG_GEN32 || pDis->param1.flags == USE_REG_GEN64) && pDis->param2.flags == USE_REG_DBG)
2471 {
2472 rc = EMInterpretDRxRead(pVM, pVCpu, pRegFrame, pDis->param1.base.reg_gen, pDis->param2.base.reg_dbg);
2473 }
2474 else
2475 if(pDis->param1.flags == USE_REG_DBG && (pDis->param2.flags == USE_REG_GEN32 || pDis->param2.flags == USE_REG_GEN64))
2476 {
2477 rc = EMInterpretDRxWrite(pVM, pVCpu, pRegFrame, pDis->param1.base.reg_dbg, pDis->param2.base.reg_gen);
2478 }
2479 else
2480 AssertMsgFailed(("Unexpected debug register move\n"));
2481
2482 return rc;
2483}
2484
2485
2486/**
2487 * LLDT Emulation.
2488 */
2489static int emInterpretLLdt(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2490{
2491 OP_PARAMVAL param1;
2492 RTSEL sel;
2493
2494 int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_SOURCE);
2495 if(RT_FAILURE(rc))
2496 return VERR_EM_INTERPRETER;
2497
2498 switch(param1.type)
2499 {
2500 case PARMTYPE_ADDRESS:
2501 return VERR_EM_INTERPRETER; //feeling lazy right now
2502
2503 case PARMTYPE_IMMEDIATE:
2504 if(!(param1.flags & PARAM_VAL16))
2505 return VERR_EM_INTERPRETER;
2506 sel = (RTSEL)param1.val.val16;
2507 break;
2508
2509 default:
2510 return VERR_EM_INTERPRETER;
2511 }
2512
2513#ifdef IN_RING0
2514 /* Only for the VT-x real-mode emulation case. */
2515 AssertReturn(CPUMIsGuestInRealMode(pVCpu), VERR_EM_INTERPRETER);
2516 CPUMSetGuestLDTR(pVCpu, sel);
2517 return VINF_SUCCESS;
2518#else
2519 if (sel == 0)
2520 {
2521 if (CPUMGetHyperLDTR(pVCpu) == 0)
2522 {
2523 // this simple case is most frequent in Windows 2000 (31k - boot & shutdown)
2524 return VINF_SUCCESS;
2525 }
2526 }
2527 //still feeling lazy
2528 return VERR_EM_INTERPRETER;
2529#endif
2530}
2531
2532#ifdef IN_RING0
2533/**
2534 * LIDT/LGDT Emulation.
2535 */
2536static int emInterpretLIGdt(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2537{
2538 OP_PARAMVAL param1;
2539 RTGCPTR pParam1;
2540 X86XDTR32 dtr32;
2541
2542 Log(("Emulate %s at %RGv\n", emGetMnemonic(pDis), (RTGCPTR)pRegFrame->rip));
2543
2544 /* Only for the VT-x real-mode emulation case. */
2545 AssertReturn(CPUMIsGuestInRealMode(pVCpu), VERR_EM_INTERPRETER);
2546
2547 int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_SOURCE);
2548 if(RT_FAILURE(rc))
2549 return VERR_EM_INTERPRETER;
2550
2551 switch(param1.type)
2552 {
2553 case PARMTYPE_ADDRESS:
2554 pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, param1.val.val16);
2555 break;
2556
2557 default:
2558 return VERR_EM_INTERPRETER;
2559 }
2560
2561 rc = emRamRead(pVM, pVCpu, pRegFrame, &dtr32, pParam1, sizeof(dtr32));
2562 AssertRCReturn(rc, VERR_EM_INTERPRETER);
2563
2564 if (!(pDis->prefix & PREFIX_OPSIZE))
2565 dtr32.uAddr &= 0xffffff; /* 16 bits operand size */
2566
2567 if (pDis->pCurInstr->opcode == OP_LIDT)
2568 CPUMSetGuestIDTR(pVCpu, dtr32.uAddr, dtr32.cb);
2569 else
2570 CPUMSetGuestGDTR(pVCpu, dtr32.uAddr, dtr32.cb);
2571
2572 return VINF_SUCCESS;
2573}
2574#endif
2575
2576
2577#ifdef IN_RC
2578/**
2579 * STI Emulation.
2580 *
2581 * @remark the instruction following sti is guaranteed to be executed before any interrupts are dispatched
2582 */
2583static int emInterpretSti(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2584{
2585 PPATMGCSTATE pGCState = PATMQueryGCState(pVM);
2586
2587 if(!pGCState)
2588 {
2589 Assert(pGCState);
2590 return VERR_EM_INTERPRETER;
2591 }
2592 pGCState->uVMFlags |= X86_EFL_IF;
2593
2594 Assert(pRegFrame->eflags.u32 & X86_EFL_IF);
2595 Assert(pvFault == SELMToFlat(pVM, DIS_SELREG_CS, pRegFrame, (RTGCPTR)pRegFrame->rip));
2596
2597 pVCpu->em.s.GCPtrInhibitInterrupts = pRegFrame->eip + pDis->opsize;
2598 VMCPU_FF_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS);
2599
2600 return VINF_SUCCESS;
2601}
2602#endif /* IN_RC */
2603
2604
2605/**
2606 * HLT Emulation.
2607 */
2608static int emInterpretHlt(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2609{
2610 return VINF_EM_HALT;
2611}
2612
2613
2614/**
2615 * Interpret RDTSC
2616 *
2617 * @returns VBox status code.
2618 * @param pVM The VM handle.
2619 * @param pVCpu The VMCPU handle.
2620 * @param pRegFrame The register frame.
2621 *
2622 */
2623VMMDECL(int) EMInterpretRdtsc(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame)
2624{
2625 unsigned uCR4 = CPUMGetGuestCR4(pVCpu);
2626
2627 if (uCR4 & X86_CR4_TSD)
2628 return VERR_EM_INTERPRETER; /* genuine #GP */
2629
2630 uint64_t uTicks = TMCpuTickGet(pVCpu);
2631
2632 /* Same behaviour in 32 & 64 bits mode */
2633 pRegFrame->rax = (uint32_t)uTicks;
2634 pRegFrame->rdx = (uTicks >> 32ULL);
2635
2636 return VINF_SUCCESS;
2637}
2638
2639/**
2640 * Interpret RDTSCP
2641 *
2642 * @returns VBox status code.
2643 * @param pVM The VM handle.
2644 * @param pVCpu The VMCPU handle.
2645 * @param pCtx The CPU context.
2646 *
2647 */
2648VMMDECL(int) EMInterpretRdtscp(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx)
2649{
2650 unsigned uCR4 = CPUMGetGuestCR4(pVCpu);
2651
2652 if (!CPUMGetGuestCpuIdFeature(pVM, CPUMCPUIDFEATURE_RDTSCP))
2653 {
2654 AssertFailed();
2655 return VERR_EM_INTERPRETER; /* genuine #UD */
2656 }
2657
2658 if (uCR4 & X86_CR4_TSD)
2659 return VERR_EM_INTERPRETER; /* genuine #GP */
2660
2661 uint64_t uTicks = TMCpuTickGet(pVCpu);
2662
2663 /* Same behaviour in 32 & 64 bits mode */
2664 pCtx->rax = (uint32_t)uTicks;
2665 pCtx->rdx = (uTicks >> 32ULL);
2666 /* Low dword of the TSC_AUX msr only. */
2667 pCtx->rcx = (uint32_t)CPUMGetGuestMsr(pVCpu, MSR_K8_TSC_AUX);
2668
2669 return VINF_SUCCESS;
2670}
2671
2672/**
2673 * RDTSC Emulation.
2674 */
2675static int emInterpretRdtsc(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2676{
2677 return EMInterpretRdtsc(pVM, pVCpu, pRegFrame);
2678}
2679
2680/**
2681 * Interpret RDPMC
2682 *
2683 * @returns VBox status code.
2684 * @param pVM The VM handle.
2685 * @param pVCpu The VMCPU handle.
2686 * @param pRegFrame The register frame.
2687 *
2688 */
2689VMMDECL(int) EMInterpretRdpmc(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame)
2690{
2691 unsigned uCR4 = CPUMGetGuestCR4(pVCpu);
2692
2693 /* If X86_CR4_PCE is not set, then CPL must be zero. */
2694 if ( !(uCR4 & X86_CR4_PCE)
2695 && CPUMGetGuestCPL(pVCpu, pRegFrame) != 0)
2696 {
2697 Assert(CPUMGetGuestCR0(pVCpu) & X86_CR0_PE);
2698 return VERR_EM_INTERPRETER; /* genuine #GP */
2699 }
2700
2701 /* Just return zero here; rather tricky to properly emulate this, especially as the specs are a mess. */
2702 pRegFrame->rax = 0;
2703 pRegFrame->rdx = 0;
2704 /* @todo We should trigger a #GP here if the cpu doesn't support the index in ecx. */
2705 return VINF_SUCCESS;
2706}
2707
2708/**
2709 * RDPMC Emulation
2710 */
2711static int emInterpretRdpmc(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2712{
2713 return EMInterpretRdpmc(pVM, pVCpu, pRegFrame);
2714}
2715
2716/**
2717 * MONITOR Emulation.
2718 */
2719static int emInterpretMonitor(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2720{
2721 uint32_t u32Dummy, u32ExtFeatures, cpl;
2722
2723 Assert(pDis->mode != CPUMODE_64BIT); /** @todo check */
2724 if (pRegFrame->ecx != 0)
2725 return VERR_EM_INTERPRETER; /* illegal value. */
2726
2727 /* Get the current privilege level. */
2728 cpl = CPUMGetGuestCPL(pVCpu, pRegFrame);
2729 if (cpl != 0)
2730 return VERR_EM_INTERPRETER; /* supervisor only */
2731
2732 CPUMGetGuestCpuId(pVCpu, 1, &u32Dummy, &u32Dummy, &u32ExtFeatures, &u32Dummy);
2733 if (!(u32ExtFeatures & X86_CPUID_FEATURE_ECX_MONITOR))
2734 return VERR_EM_INTERPRETER; /* not supported */
2735
2736 return VINF_SUCCESS;
2737}
2738
2739
2740/**
2741 * MWAIT Emulation.
2742 */
2743VMMDECL(int) EMInterpretMWait(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame)
2744{
2745 uint32_t u32Dummy, u32ExtFeatures, cpl;
2746
2747 /* @todo bit 1 is supposed to tell the cpu to wake us up on interrupts even if IF is cleared.
2748 * Not sure which models. Intel docs say ecx and eax must be zero for Pentium 4 CPUs
2749 * CPUID.05H.ECX[0] defines support for power management extensions (eax)
2750 */
2751 if (pRegFrame->ecx != 0)
2752 return VERR_EM_INTERPRETER; /* illegal value. */
2753
2754 /* Get the current privilege level. */
2755 cpl = CPUMGetGuestCPL(pVCpu, pRegFrame);
2756 if (cpl != 0)
2757 return VERR_EM_INTERPRETER; /* supervisor only */
2758
2759 CPUMGetGuestCpuId(pVCpu, 1, &u32Dummy, &u32Dummy, &u32ExtFeatures, &u32Dummy);
2760 if (!(u32ExtFeatures & X86_CPUID_FEATURE_ECX_MONITOR))
2761 return VERR_EM_INTERPRETER; /* not supported */
2762
2763 /** @todo not completely correct */
2764 return VINF_EM_HALT;
2765}
2766
2767static int emInterpretMWait(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2768{
2769 Assert(pDis->mode != CPUMODE_64BIT); /** @todo check */
2770
2771 return EMInterpretMWait(pVM, pVCpu, pRegFrame);
2772}
2773
2774
2775#ifdef LOG_ENABLED
2776static const char *emMSRtoString(uint32_t uMsr)
2777{
2778 switch (uMsr)
2779 {
2780 case MSR_IA32_APICBASE:
2781 return "MSR_IA32_APICBASE";
2782 case MSR_IA32_CR_PAT:
2783 return "MSR_IA32_CR_PAT";
2784 case MSR_IA32_SYSENTER_CS:
2785 return "MSR_IA32_SYSENTER_CS";
2786 case MSR_IA32_SYSENTER_EIP:
2787 return "MSR_IA32_SYSENTER_EIP";
2788 case MSR_IA32_SYSENTER_ESP:
2789 return "MSR_IA32_SYSENTER_ESP";
2790 case MSR_K6_EFER:
2791 return "MSR_K6_EFER";
2792 case MSR_K8_SF_MASK:
2793 return "MSR_K8_SF_MASK";
2794 case MSR_K6_STAR:
2795 return "MSR_K6_STAR";
2796 case MSR_K8_LSTAR:
2797 return "MSR_K8_LSTAR";
2798 case MSR_K8_CSTAR:
2799 return "MSR_K8_CSTAR";
2800 case MSR_K8_FS_BASE:
2801 return "MSR_K8_FS_BASE";
2802 case MSR_K8_GS_BASE:
2803 return "MSR_K8_GS_BASE";
2804 case MSR_K8_KERNEL_GS_BASE:
2805 return "MSR_K8_KERNEL_GS_BASE";
2806 case MSR_K8_TSC_AUX:
2807 return "MSR_K8_TSC_AUX";
2808 case MSR_IA32_BIOS_SIGN_ID:
2809 return "Unsupported MSR_IA32_BIOS_SIGN_ID";
2810 case MSR_IA32_PLATFORM_ID:
2811 return "Unsupported MSR_IA32_PLATFORM_ID";
2812 case MSR_IA32_BIOS_UPDT_TRIG:
2813 return "Unsupported MSR_IA32_BIOS_UPDT_TRIG";
2814 case MSR_IA32_TSC:
2815 return "MSR_IA32_TSC";
2816 case MSR_IA32_MTRR_CAP:
2817 return "Unsupported MSR_IA32_MTRR_CAP";
2818 case MSR_IA32_MCP_CAP:
2819 return "Unsupported MSR_IA32_MCP_CAP";
2820 case MSR_IA32_MCP_STATUS:
2821 return "Unsupported MSR_IA32_MCP_STATUS";
2822 case MSR_IA32_MCP_CTRL:
2823 return "Unsupported MSR_IA32_MCP_CTRL";
2824 case MSR_IA32_MTRR_DEF_TYPE:
2825 return "Unsupported MSR_IA32_MTRR_DEF_TYPE";
2826 case MSR_K7_EVNTSEL0:
2827 return "Unsupported MSR_K7_EVNTSEL0";
2828 case MSR_K7_EVNTSEL1:
2829 return "Unsupported MSR_K7_EVNTSEL1";
2830 case MSR_K7_EVNTSEL2:
2831 return "Unsupported MSR_K7_EVNTSEL2";
2832 case MSR_K7_EVNTSEL3:
2833 return "Unsupported MSR_K7_EVNTSEL3";
2834 case MSR_IA32_MC0_CTL:
2835 return "Unsupported MSR_IA32_MC0_CTL";
2836 case MSR_IA32_MC0_STATUS:
2837 return "Unsupported MSR_IA32_MC0_STATUS";
2838 case MSR_IA32_PERFEVTSEL0:
2839 return "Unsupported MSR_IA32_PERFEVTSEL0";
2840 case MSR_IA32_PERFEVTSEL1:
2841 return "Unsupported MSR_IA32_PERFEVTSEL1";
2842 case MSR_IA32_PERF_STATUS:
2843 return "MSR_IA32_PERF_STATUS";
2844 case MSR_IA32_PERF_CTL:
2845 return "Unsupported MSR_IA32_PERF_CTL";
2846 case MSR_K7_PERFCTR0:
2847 return "Unsupported MSR_K7_PERFCTR0";
2848 case MSR_K7_PERFCTR1:
2849 return "Unsupported MSR_K7_PERFCTR1";
2850 case MSR_K7_PERFCTR2:
2851 return "Unsupported MSR_K7_PERFCTR2";
2852 case MSR_K7_PERFCTR3:
2853 return "Unsupported MSR_K7_PERFCTR3";
2854 }
2855 return "Unknown MSR";
2856}
2857#endif /* LOG_ENABLED */
2858
2859
2860/**
2861 * Interpret RDMSR
2862 *
2863 * @returns VBox status code.
2864 * @param pVM The VM handle.
2865 * @param pVCpu The VMCPU handle.
2866 * @param pRegFrame The register frame.
2867 *
2868 */
2869VMMDECL(int) EMInterpretRdmsr(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame)
2870{
2871 uint32_t u32Dummy, u32Features, cpl;
2872 uint64_t val;
2873 CPUMCTX *pCtx;
2874 int rc = VINF_SUCCESS;
2875
2876 /** @todo According to the Intel manuals, there's a REX version of RDMSR that is slightly different.
2877 * That version clears the high dwords of both RDX & RAX */
2878 pCtx = CPUMQueryGuestCtxPtr(pVCpu);
2879
2880 /* Get the current privilege level. */
2881 cpl = CPUMGetGuestCPL(pVCpu, pRegFrame);
2882 if (cpl != 0)
2883 return VERR_EM_INTERPRETER; /* supervisor only */
2884
2885 CPUMGetGuestCpuId(pVCpu, 1, &u32Dummy, &u32Dummy, &u32Dummy, &u32Features);
2886 if (!(u32Features & X86_CPUID_FEATURE_EDX_MSR))
2887 return VERR_EM_INTERPRETER; /* not supported */
2888
2889 switch (pRegFrame->ecx)
2890 {
2891 case MSR_IA32_TSC:
2892 val = TMCpuTickGet(pVCpu);
2893 break;
2894
2895 case MSR_IA32_APICBASE:
2896 rc = PDMApicGetBase(pVM, &val);
2897 AssertRC(rc);
2898 break;
2899
2900 case MSR_IA32_CR_PAT:
2901 val = pCtx->msrPAT;
2902 break;
2903
2904 case MSR_IA32_SYSENTER_CS:
2905 val = pCtx->SysEnter.cs;
2906 break;
2907
2908 case MSR_IA32_SYSENTER_EIP:
2909 val = pCtx->SysEnter.eip;
2910 break;
2911
2912 case MSR_IA32_SYSENTER_ESP:
2913 val = pCtx->SysEnter.esp;
2914 break;
2915
2916 case MSR_K6_EFER:
2917 val = pCtx->msrEFER;
2918 break;
2919
2920 case MSR_K8_SF_MASK:
2921 val = pCtx->msrSFMASK;
2922 break;
2923
2924 case MSR_K6_STAR:
2925 val = pCtx->msrSTAR;
2926 break;
2927
2928 case MSR_K8_LSTAR:
2929 val = pCtx->msrLSTAR;
2930 break;
2931
2932 case MSR_K8_CSTAR:
2933 val = pCtx->msrCSTAR;
2934 break;
2935
2936 case MSR_K8_FS_BASE:
2937 val = pCtx->fsHid.u64Base;
2938 break;
2939
2940 case MSR_K8_GS_BASE:
2941 val = pCtx->gsHid.u64Base;
2942 break;
2943
2944 case MSR_K8_KERNEL_GS_BASE:
2945 val = pCtx->msrKERNELGSBASE;
2946 break;
2947
2948 case MSR_K8_TSC_AUX:
2949 val = CPUMGetGuestMsr(pVCpu, MSR_K8_TSC_AUX);
2950 break;
2951
2952 case MSR_IA32_PERF_STATUS:
2953 val = CPUMGetGuestMsr(pVCpu, MSR_IA32_PERF_STATUS);
2954 break;
2955
2956#if 0 /*def IN_RING0 */
2957 case MSR_IA32_PLATFORM_ID:
2958 case MSR_IA32_BIOS_SIGN_ID:
2959 if (CPUMGetCPUVendor(pVM) == CPUMCPUVENDOR_INTEL)
2960 {
2961 /* Available since the P6 family. VT-x implies that this feature is present. */
2962 if (pRegFrame->ecx == MSR_IA32_PLATFORM_ID)
2963 val = ASMRdMsr(MSR_IA32_PLATFORM_ID);
2964 else
2965 if (pRegFrame->ecx == MSR_IA32_BIOS_SIGN_ID)
2966 val = ASMRdMsr(MSR_IA32_BIOS_SIGN_ID);
2967 break;
2968 }
2969 /* no break */
2970#endif
2971 default:
2972 /* In X2APIC specification this range is reserved for APIC control. */
2973 if ( pRegFrame->ecx >= MSR_IA32_APIC_START
2974 && pRegFrame->ecx < MSR_IA32_APIC_END)
2975 rc = PDMApicReadMSR(pVM, pVCpu->idCpu, pRegFrame->ecx, &val);
2976 else
2977 /* We should actually trigger a #GP here, but don't as that will cause more trouble. */
2978 val = 0;
2979 break;
2980 }
2981 LogFlow(("EMInterpretRdmsr %s (%x) -> val=%RX64\n", emMSRtoString(pRegFrame->ecx), pRegFrame->ecx, val));
2982 if (rc == VINF_SUCCESS)
2983 {
2984 pRegFrame->rax = (uint32_t) val;
2985 pRegFrame->rdx = (uint32_t)(val >> 32);
2986 }
2987 return rc;
2988}
2989
2990
2991/**
2992 * RDMSR Emulation.
2993 */
2994static int emInterpretRdmsr(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2995{
2996 /* Note: the Intel manual claims there's a REX version of RDMSR that's slightly different, so we play safe by completely disassembling the instruction. */
2997 Assert(!(pDis->prefix & PREFIX_REX));
2998 return EMInterpretRdmsr(pVM, pVCpu, pRegFrame);
2999}
3000
3001
3002/**
3003 * Interpret WRMSR
3004 *
3005 * @returns VBox status code.
3006 * @param pVM The VM handle.
3007 * @param pVCpu The VMCPU handle.
3008 * @param pRegFrame The register frame.
3009 */
3010VMMDECL(int) EMInterpretWrmsr(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame)
3011{
3012 uint32_t u32Dummy, u32Features, cpl;
3013 uint64_t val;
3014 CPUMCTX *pCtx;
3015
3016 /* Note: works the same in 32 and 64 bits modes. */
3017 pCtx = CPUMQueryGuestCtxPtr(pVCpu);
3018
3019 /* Get the current privilege level. */
3020 cpl = CPUMGetGuestCPL(pVCpu, pRegFrame);
3021 if (cpl != 0)
3022 return VERR_EM_INTERPRETER; /* supervisor only */
3023
3024 CPUMGetGuestCpuId(pVCpu, 1, &u32Dummy, &u32Dummy, &u32Dummy, &u32Features);
3025 if (!(u32Features & X86_CPUID_FEATURE_EDX_MSR))
3026 return VERR_EM_INTERPRETER; /* not supported */
3027
3028 val = RT_MAKE_U64(pRegFrame->eax, pRegFrame->edx);
3029 LogFlow(("EMInterpretWrmsr %s (%x) val=%RX64\n", emMSRtoString(pRegFrame->ecx), pRegFrame->ecx, val));
3030 switch (pRegFrame->ecx)
3031 {
3032 case MSR_IA32_TSC:
3033 TMCpuTickSet(pVM, pVCpu, val);
3034 break;
3035
3036 case MSR_IA32_APICBASE:
3037 {
3038 int rc = PDMApicSetBase(pVM, val);
3039 AssertRC(rc);
3040 break;
3041 }
3042
3043 case MSR_IA32_CR_PAT:
3044 pCtx->msrPAT = val;
3045 break;
3046
3047 case MSR_IA32_SYSENTER_CS:
3048 pCtx->SysEnter.cs = val & 0xffff; /* 16 bits selector */
3049 break;
3050
3051 case MSR_IA32_SYSENTER_EIP:
3052 pCtx->SysEnter.eip = val;
3053 break;
3054
3055 case MSR_IA32_SYSENTER_ESP:
3056 pCtx->SysEnter.esp = val;
3057 break;
3058
3059 case MSR_K6_EFER:
3060 {
3061 uint64_t uMask = 0;
3062 uint64_t oldval = pCtx->msrEFER;
3063
3064 /* Filter out those bits the guest is allowed to change. (e.g. LMA is read-only) */
3065 CPUMGetGuestCpuId(pVCpu, 0x80000001, &u32Dummy, &u32Dummy, &u32Dummy, &u32Features);
3066 if (u32Features & X86_CPUID_AMD_FEATURE_EDX_NX)
3067 uMask |= MSR_K6_EFER_NXE;
3068 if (u32Features & X86_CPUID_AMD_FEATURE_EDX_LONG_MODE)
3069 uMask |= MSR_K6_EFER_LME;
3070 if (u32Features & X86_CPUID_AMD_FEATURE_EDX_SEP)
3071 uMask |= MSR_K6_EFER_SCE;
3072 if (u32Features & X86_CPUID_AMD_FEATURE_EDX_FFXSR)
3073 uMask |= MSR_K6_EFER_FFXSR;
3074
3075 /* Check for illegal MSR_K6_EFER_LME transitions: not allowed to change LME if paging is enabled. (AMD Arch. Programmer's Manual Volume 2: Table 14-5) */
3076 if ( ((pCtx->msrEFER & MSR_K6_EFER_LME) != (val & uMask & MSR_K6_EFER_LME))
3077 && (pCtx->cr0 & X86_CR0_PG))
3078 {
3079 AssertMsgFailed(("Illegal MSR_K6_EFER_LME change: paging is enabled!!\n"));
3080 return VERR_EM_INTERPRETER; /* @todo generate #GP(0) */
3081 }
3082
3083 /* There are a few more: e.g. MSR_K6_EFER_LMSLE */
3084 AssertMsg(!(val & ~(MSR_K6_EFER_NXE|MSR_K6_EFER_LME|MSR_K6_EFER_LMA /* ignored anyway */ |MSR_K6_EFER_SCE|MSR_K6_EFER_FFXSR)), ("Unexpected value %RX64\n", val));
3085 pCtx->msrEFER = (pCtx->msrEFER & ~uMask) | (val & uMask);
3086
3087 /* AMD64 Architecture Programmer's Manual: 15.15 TLB Control; flush the TLB if MSR_K6_EFER_NXE, MSR_K6_EFER_LME or MSR_K6_EFER_LMA are changed. */
3088 if ((oldval & (MSR_K6_EFER_NXE|MSR_K6_EFER_LME|MSR_K6_EFER_LMA)) != (pCtx->msrEFER & (MSR_K6_EFER_NXE|MSR_K6_EFER_LME|MSR_K6_EFER_LMA)))
3089 HWACCMFlushTLB(pVCpu);
3090
3091 break;
3092 }
3093
3094 case MSR_K8_SF_MASK:
3095 pCtx->msrSFMASK = val;
3096 break;
3097
3098 case MSR_K6_STAR:
3099 pCtx->msrSTAR = val;
3100 break;
3101
3102 case MSR_K8_LSTAR:
3103 pCtx->msrLSTAR = val;
3104 break;
3105
3106 case MSR_K8_CSTAR:
3107 pCtx->msrCSTAR = val;
3108 break;
3109
3110 case MSR_K8_FS_BASE:
3111 pCtx->fsHid.u64Base = val;
3112 break;
3113
3114 case MSR_K8_GS_BASE:
3115 pCtx->gsHid.u64Base = val;
3116 break;
3117
3118 case MSR_K8_KERNEL_GS_BASE:
3119 pCtx->msrKERNELGSBASE = val;
3120 break;
3121
3122 case MSR_K8_TSC_AUX:
3123 CPUMSetGuestMsr(pVCpu, MSR_K8_TSC_AUX, val);
3124 break;
3125
3126 default:
3127 /* In X2APIC specification this range is reserved for APIC control. */
3128 if ( pRegFrame->ecx >= MSR_IA32_APIC_START
3129 && pRegFrame->ecx < MSR_IA32_APIC_END)
3130 return PDMApicWriteMSR(pVM, pVCpu->idCpu, pRegFrame->ecx, val);
3131
3132 /* We should actually trigger a #GP here, but don't as that might cause more trouble. */
3133 break;
3134 }
3135 return VINF_SUCCESS;
3136}
3137
3138
3139/**
3140 * WRMSR Emulation.
3141 */
3142static int emInterpretWrmsr(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
3143{
3144 return EMInterpretWrmsr(pVM, pVCpu, pRegFrame);
3145}
3146
3147
3148/**
3149 * Internal worker.
3150 * @copydoc EMInterpretInstructionCPU
3151 */
3152DECLINLINE(int) emInterpretInstructionCPU(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
3153{
3154 Assert(pcbSize);
3155 *pcbSize = 0;
3156
3157 /*
3158 * Only supervisor guest code!!
3159 * And no complicated prefixes.
3160 */
3161 /* Get the current privilege level. */
3162 uint32_t cpl = CPUMGetGuestCPL(pVCpu, pRegFrame);
3163 if ( cpl != 0
3164 && pDis->pCurInstr->opcode != OP_RDTSC) /* rdtsc requires emulation in ring 3 as well */
3165 {
3166 Log(("WARNING: refusing instruction emulation for user-mode code!!\n"));
3167 STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,FailedUserMode));
3168 return VERR_EM_INTERPRETER;
3169 }
3170
3171#ifdef IN_RC
3172 if ( (pDis->prefix & (PREFIX_REPNE | PREFIX_REP))
3173 || ( (pDis->prefix & PREFIX_LOCK)
3174 && pDis->pCurInstr->opcode != OP_CMPXCHG
3175 && pDis->pCurInstr->opcode != OP_CMPXCHG8B
3176 && pDis->pCurInstr->opcode != OP_XADD
3177 && pDis->pCurInstr->opcode != OP_OR
3178 && pDis->pCurInstr->opcode != OP_AND
3179 && pDis->pCurInstr->opcode != OP_XOR
3180 && pDis->pCurInstr->opcode != OP_BTR
3181 )
3182 )
3183#else
3184 if ( (pDis->prefix & PREFIX_REPNE)
3185 || ( (pDis->prefix & PREFIX_REP)
3186 && pDis->pCurInstr->opcode != OP_STOSWD
3187 )
3188 || ( (pDis->prefix & PREFIX_LOCK)
3189 && pDis->pCurInstr->opcode != OP_OR
3190 && pDis->pCurInstr->opcode != OP_AND
3191 && pDis->pCurInstr->opcode != OP_XOR
3192 && pDis->pCurInstr->opcode != OP_BTR
3193 && pDis->pCurInstr->opcode != OP_CMPXCHG
3194 && pDis->pCurInstr->opcode != OP_CMPXCHG8B
3195 )
3196 )
3197#endif
3198 {
3199 //Log(("EMInterpretInstruction: wrong prefix!!\n"));
3200 STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,FailedPrefix));
3201 return VERR_EM_INTERPRETER;
3202 }
3203
3204#if HC_ARCH_BITS == 32
3205 /*
3206 * Unable to emulate most >4 bytes accesses in 32 bits mode.
3207 * Whitelisted instructions are safe.
3208 */
3209 if ( pDis->param1.size > 4
3210 && CPUMIsGuestIn64BitCode(pVCpu, pRegFrame))
3211 {
3212 uint32_t uOpCode = pDis->pCurInstr->opcode;
3213 if ( uOpCode != OP_STOSWD
3214 && uOpCode != OP_MOV
3215 && uOpCode != OP_CMPXCHG8B
3216 && uOpCode != OP_XCHG
3217 && uOpCode != OP_BTS
3218 && uOpCode != OP_BTR
3219 && uOpCode != OP_BTC
3220# ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
3221 && uOpCode != OP_CMPXCHG /* solaris */
3222 && uOpCode != OP_AND /* windows */
3223 && uOpCode != OP_OR /* windows */
3224 && uOpCode != OP_XOR /* because we can */
3225 && uOpCode != OP_ADD /* windows (dripple) */
3226 && uOpCode != OP_ADC /* because we can */
3227 && uOpCode != OP_SUB /* because we can */
3228 /** @todo OP_BTS or is that a different kind of failure? */
3229# endif
3230 )
3231 {
3232# ifdef VBOX_WITH_STATISTICS
3233 switch (pDis->pCurInstr->opcode)
3234 {
3235# define INTERPRET_FAILED_CASE(opcode, Instr) \
3236 case opcode: STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Failed##Instr)); break;
3237 INTERPRET_FAILED_CASE(OP_XCHG,Xchg);
3238 INTERPRET_FAILED_CASE(OP_DEC,Dec);
3239 INTERPRET_FAILED_CASE(OP_INC,Inc);
3240 INTERPRET_FAILED_CASE(OP_POP,Pop);
3241 INTERPRET_FAILED_CASE(OP_OR, Or);
3242 INTERPRET_FAILED_CASE(OP_XOR,Xor);
3243 INTERPRET_FAILED_CASE(OP_AND,And);
3244 INTERPRET_FAILED_CASE(OP_MOV,Mov);
3245 INTERPRET_FAILED_CASE(OP_STOSWD,StosWD);
3246 INTERPRET_FAILED_CASE(OP_INVLPG,InvlPg);
3247 INTERPRET_FAILED_CASE(OP_CPUID,CpuId);
3248 INTERPRET_FAILED_CASE(OP_MOV_CR,MovCRx);
3249 INTERPRET_FAILED_CASE(OP_MOV_DR,MovDRx);
3250 INTERPRET_FAILED_CASE(OP_LLDT,LLdt);
3251 INTERPRET_FAILED_CASE(OP_LIDT,LIdt);
3252 INTERPRET_FAILED_CASE(OP_LGDT,LGdt);
3253 INTERPRET_FAILED_CASE(OP_LMSW,Lmsw);
3254 INTERPRET_FAILED_CASE(OP_CLTS,Clts);
3255 INTERPRET_FAILED_CASE(OP_MONITOR,Monitor);
3256 INTERPRET_FAILED_CASE(OP_MWAIT,MWait);
3257 INTERPRET_FAILED_CASE(OP_RDMSR,Rdmsr);
3258 INTERPRET_FAILED_CASE(OP_WRMSR,Wrmsr);
3259 INTERPRET_FAILED_CASE(OP_ADD,Add);
3260 INTERPRET_FAILED_CASE(OP_SUB,Sub);
3261 INTERPRET_FAILED_CASE(OP_ADC,Adc);
3262 INTERPRET_FAILED_CASE(OP_BTR,Btr);
3263 INTERPRET_FAILED_CASE(OP_BTS,Bts);
3264 INTERPRET_FAILED_CASE(OP_BTC,Btc);
3265 INTERPRET_FAILED_CASE(OP_RDTSC,Rdtsc);
3266 INTERPRET_FAILED_CASE(OP_CMPXCHG, CmpXchg);
3267 INTERPRET_FAILED_CASE(OP_STI, Sti);
3268 INTERPRET_FAILED_CASE(OP_XADD,XAdd);
3269 INTERPRET_FAILED_CASE(OP_CMPXCHG8B,CmpXchg8b);
3270 INTERPRET_FAILED_CASE(OP_HLT, Hlt);
3271 INTERPRET_FAILED_CASE(OP_IRET,Iret);
3272 INTERPRET_FAILED_CASE(OP_WBINVD,WbInvd);
3273 INTERPRET_FAILED_CASE(OP_MOVNTPS,MovNTPS);
3274# undef INTERPRET_FAILED_CASE
3275 default:
3276 STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,FailedMisc));
3277 break;
3278 }
3279# endif /* VBOX_WITH_STATISTICS */
3280 return VERR_EM_INTERPRETER;
3281 }
3282 }
3283#endif
3284
3285 int rc;
3286#if (defined(VBOX_STRICT) || defined(LOG_ENABLED))
3287 LogFlow(("emInterpretInstructionCPU %s\n", emGetMnemonic(pDis)));
3288#endif
3289 switch (pDis->pCurInstr->opcode)
3290 {
3291 /*
3292 * Macros for generating the right case statements.
3293 */
3294# define INTERPRET_CASE_EX_LOCK_PARAM3(opcode, Instr, InstrFn, pfnEmulate, pfnEmulateLock) \
3295 case opcode:\
3296 if (pDis->prefix & PREFIX_LOCK) \
3297 rc = emInterpretLock##InstrFn(pVM, pVCpu, pDis, pRegFrame, pvFault, pcbSize, pfnEmulateLock); \
3298 else \
3299 rc = emInterpret##InstrFn(pVM, pVCpu, pDis, pRegFrame, pvFault, pcbSize, pfnEmulate); \
3300 if (RT_SUCCESS(rc)) \
3301 STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Instr)); \
3302 else \
3303 STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Failed##Instr)); \
3304 return rc
3305#define INTERPRET_CASE_EX_PARAM3(opcode, Instr, InstrFn, pfnEmulate) \
3306 case opcode:\
3307 rc = emInterpret##InstrFn(pVM, pVCpu, pDis, pRegFrame, pvFault, pcbSize, pfnEmulate); \
3308 if (RT_SUCCESS(rc)) \
3309 STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Instr)); \
3310 else \
3311 STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Failed##Instr)); \
3312 return rc
3313
3314#define INTERPRET_CASE_EX_PARAM2(opcode, Instr, InstrFn, pfnEmulate) \
3315 INTERPRET_CASE_EX_PARAM3(opcode, Instr, InstrFn, pfnEmulate)
3316#define INTERPRET_CASE_EX_LOCK_PARAM2(opcode, Instr, InstrFn, pfnEmulate, pfnEmulateLock) \
3317 INTERPRET_CASE_EX_LOCK_PARAM3(opcode, Instr, InstrFn, pfnEmulate, pfnEmulateLock)
3318
3319#define INTERPRET_CASE(opcode, Instr) \
3320 case opcode:\
3321 rc = emInterpret##Instr(pVM, pVCpu, pDis, pRegFrame, pvFault, pcbSize); \
3322 if (RT_SUCCESS(rc)) \
3323 STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Instr)); \
3324 else \
3325 STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Failed##Instr)); \
3326 return rc
3327
3328#define INTERPRET_CASE_EX_DUAL_PARAM2(opcode, Instr, InstrFn) \
3329 case opcode:\
3330 rc = emInterpret##InstrFn(pVM, pVCpu, pDis, pRegFrame, pvFault, pcbSize); \
3331 if (RT_SUCCESS(rc)) \
3332 STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Instr)); \
3333 else \
3334 STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Failed##Instr)); \
3335 return rc
3336
3337#define INTERPRET_STAT_CASE(opcode, Instr) \
3338 case opcode: STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Failed##Instr)); return VERR_EM_INTERPRETER;
3339
3340 /*
3341 * The actual case statements.
3342 */
3343 INTERPRET_CASE(OP_XCHG,Xchg);
3344 INTERPRET_CASE_EX_PARAM2(OP_DEC,Dec, IncDec, EMEmulateDec);
3345 INTERPRET_CASE_EX_PARAM2(OP_INC,Inc, IncDec, EMEmulateInc);
3346 INTERPRET_CASE(OP_POP,Pop);
3347 INTERPRET_CASE_EX_LOCK_PARAM3(OP_OR, Or, OrXorAnd, EMEmulateOr, EMEmulateLockOr);
3348 INTERPRET_CASE_EX_LOCK_PARAM3(OP_XOR,Xor, OrXorAnd, EMEmulateXor, EMEmulateLockXor);
3349 INTERPRET_CASE_EX_LOCK_PARAM3(OP_AND,And, OrXorAnd, EMEmulateAnd, EMEmulateLockAnd);
3350 INTERPRET_CASE(OP_MOV,Mov);
3351#ifndef IN_RC
3352 INTERPRET_CASE(OP_STOSWD,StosWD);
3353#endif
3354 INTERPRET_CASE(OP_INVLPG,InvlPg);
3355 INTERPRET_CASE(OP_CPUID,CpuId);
3356 INTERPRET_CASE(OP_MOV_CR,MovCRx);
3357 INTERPRET_CASE(OP_MOV_DR,MovDRx);
3358#ifdef IN_RING0
3359 INTERPRET_CASE_EX_DUAL_PARAM2(OP_LIDT, LIdt, LIGdt);
3360 INTERPRET_CASE_EX_DUAL_PARAM2(OP_LGDT, LGdt, LIGdt);
3361#endif
3362 INTERPRET_CASE(OP_LLDT,LLdt);
3363 INTERPRET_CASE(OP_LMSW,Lmsw);
3364#ifdef EM_EMULATE_SMSW
3365 INTERPRET_CASE(OP_SMSW,Smsw);
3366#endif
3367 INTERPRET_CASE(OP_CLTS,Clts);
3368 INTERPRET_CASE(OP_MONITOR, Monitor);
3369 INTERPRET_CASE(OP_MWAIT, MWait);
3370 INTERPRET_CASE(OP_RDMSR, Rdmsr);
3371 INTERPRET_CASE(OP_WRMSR, Wrmsr);
3372 INTERPRET_CASE_EX_PARAM3(OP_ADD,Add, AddSub, EMEmulateAdd);
3373 INTERPRET_CASE_EX_PARAM3(OP_SUB,Sub, AddSub, EMEmulateSub);
3374 INTERPRET_CASE(OP_ADC,Adc);
3375 INTERPRET_CASE_EX_LOCK_PARAM2(OP_BTR,Btr, BitTest, EMEmulateBtr, EMEmulateLockBtr);
3376 INTERPRET_CASE_EX_PARAM2(OP_BTS,Bts, BitTest, EMEmulateBts);
3377 INTERPRET_CASE_EX_PARAM2(OP_BTC,Btc, BitTest, EMEmulateBtc);
3378 INTERPRET_CASE(OP_RDPMC,Rdpmc);
3379 INTERPRET_CASE(OP_RDTSC,Rdtsc);
3380 INTERPRET_CASE(OP_CMPXCHG, CmpXchg);
3381#ifdef IN_RC
3382 INTERPRET_CASE(OP_STI,Sti);
3383 INTERPRET_CASE(OP_XADD, XAdd);
3384#endif
3385 INTERPRET_CASE(OP_CMPXCHG8B, CmpXchg8b);
3386 INTERPRET_CASE(OP_HLT,Hlt);
3387 INTERPRET_CASE(OP_IRET,Iret);
3388 INTERPRET_CASE(OP_WBINVD,WbInvd);
3389#ifdef VBOX_WITH_STATISTICS
3390# ifndef IN_RC
3391 INTERPRET_STAT_CASE(OP_XADD, XAdd);
3392# endif
3393 INTERPRET_STAT_CASE(OP_MOVNTPS,MovNTPS);
3394#endif
3395
3396 default:
3397 Log3(("emInterpretInstructionCPU: opcode=%d\n", pDis->pCurInstr->opcode));
3398 STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,FailedMisc));
3399 return VERR_EM_INTERPRETER;
3400
3401#undef INTERPRET_CASE_EX_PARAM2
3402#undef INTERPRET_STAT_CASE
3403#undef INTERPRET_CASE_EX
3404#undef INTERPRET_CASE
3405 } /* switch (opcode) */
3406 AssertFailed();
3407 return VERR_INTERNAL_ERROR;
3408}
3409
3410
3411/**
3412 * Sets the PC for which interrupts should be inhibited.
3413 *
3414 * @param pVCpu The VMCPU handle.
3415 * @param PC The PC.
3416 */
3417VMMDECL(void) EMSetInhibitInterruptsPC(PVMCPU pVCpu, RTGCUINTPTR PC)
3418{
3419 pVCpu->em.s.GCPtrInhibitInterrupts = PC;
3420 VMCPU_FF_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS);
3421}
3422
3423
3424/**
3425 * Gets the PC for which interrupts should be inhibited.
3426 *
3427 * There are a few instructions which inhibits or delays interrupts
3428 * for the instruction following them. These instructions are:
3429 * - STI
3430 * - MOV SS, r/m16
3431 * - POP SS
3432 *
3433 * @returns The PC for which interrupts should be inhibited.
3434 * @param pVCpu The VMCPU handle.
3435 *
3436 */
3437VMMDECL(RTGCUINTPTR) EMGetInhibitInterruptsPC(PVMCPU pVCpu)
3438{
3439 return pVCpu->em.s.GCPtrInhibitInterrupts;
3440}
3441
3442/**
3443 * Locks REM execution to a single VCpu
3444 *
3445 * @param pVM VM handle.
3446 */
3447VMMDECL(void) EMRemLock(PVM pVM)
3448{
3449 if (!PDMCritSectIsInitialized(&pVM->em.s.CritSectREM))
3450 return; /* early init */
3451
3452 Assert(!PGMIsLockOwner(pVM) && !IOMIsLockOwner(pVM));
3453 int rc = PDMCritSectEnter(&pVM->em.s.CritSectREM, VERR_SEM_BUSY);
3454 AssertMsg(rc == VINF_SUCCESS, ("%Rrc\n", rc));
3455}
3456
3457/**
3458 * Unlocks REM execution
3459 *
3460 * @param pVM VM handle.
3461 */
3462VMMDECL(void) EMRemUnlock(PVM pVM)
3463{
3464 if (!PDMCritSectIsInitialized(&pVM->em.s.CritSectREM))
3465 return; /* early init */
3466
3467 PDMCritSectLeave(&pVM->em.s.CritSectREM);
3468}
3469
3470/**
3471 * Check if this VCPU currently owns the REM lock.
3472 *
3473 * @returns bool owner/not owner
3474 * @param pVM The VM to operate on.
3475 */
3476VMMDECL(bool) EMRemIsLockOwner(PVM pVM)
3477{
3478 return PDMCritSectIsOwner(&pVM->em.s.CritSectREM);
3479}
3480
3481/**
3482 * Try to acquire the REM lock.
3483 *
3484 * @returns VBox status code
3485 * @param pVM The VM to operate on.
3486 */
3487VMMDECL(int) EMTryEnterRemLock(PVM pVM)
3488{
3489 return PDMCritSectTryEnter(&pVM->em.s.CritSectREM);
3490}
3491
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette