VirtualBox

Changeset 13197

Show
Ignore:
Timestamp:
10/13/08 10:52:06 (3 months ago)
Author:
vboxsync
Message:

Backed out 37737&37738. (regressions)

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/include/VBox/hwacc_vmx.h

    r13196 r13197  
    13801380 * @returns VBox status code 
    13811381 * @param   idxField        VMCS index 
     1382 * @param   u64Val          16, 32 or 64 bits value 
     1383 */ 
     1384DECLASM(int) VMXWriteVMCS64(uint32_t idxField, uint64_t u64Val); 
     1385 
     1386/** 
     1387 * Executes VMWRITE 
     1388 * 
     1389 * @returns VBox status code 
     1390 * @param   idxField        VMCS index 
    13821391 * @param   u32Val          32 bits value 
    13831392 */ 
    1384 #if HC_ARCH_BITS == 64 
    1385 DECLINLINE(int) VMXWriteVMCS32(uint32_t idxField, uint32_t u32Val) 
    1386 
    1387     return VMXWriteVMCS64(idxField, u32Val); 
    1388 
    1389 #elif RT_INLINE_ASM_EXTERNAL 
     1393#if RT_INLINE_ASM_EXTERNAL || HC_ARCH_BITS == 64 
    13901394DECLASM(int) VMXWriteVMCS32(uint32_t idxField, uint32_t u32Val); 
    13911395#else 
     
    14321436#endif 
    14331437 
    1434 /** 
    1435  * Executes VMWRITE 
    1436  * 
    1437  * @returns VBox status code 
    1438  * @param   idxField        VMCS index 
    1439  * @param   u64Val          16, 32 or 64 bits value 
    1440  */ 
    14411438#if HC_ARCH_BITS == 64 
    1442 DECLASM(int) VMXWriteVMCS64(uint32_t idxField, uint64_t u64Val); 
     1439#define VMXWriteVMCS VMXWriteVMCS64 
    14431440#else 
    1444 DECLINLINE(int) VMXWriteVMCS64(uint32_t idxField, uint64_t u64Val) 
    1445 
    1446     int rc; 
    1447  
    1448     rc  = VMXWriteVMCS32(idxField,    u64Val); 
    1449     rc |= VMXWriteVMCS32(idxField+1,  u64Val >> 32ULL); 
    1450     return rc; 
    1451 
    1452 #endif 
     1441#define VMXWriteVMCS VMXWriteVMCS32 
     1442#endif /* HC_ARCH_BITS == 64 */ 
    14531443 
    14541444 
  • trunk/include/VBox/pgm.h

    r13195 r13197  
    336336VMMDECL(int)    PGMGstSetPage(PVM pVM, RTGCPTR GCPtr, size_t cb, uint64_t fFlags); 
    337337VMMDECL(int)    PGMGstModifyPage(PVM pVM, RTGCPTR GCPtr, size_t cb, uint64_t fFlags, uint64_t fMask); 
    338 VMMDECL(X86PDPE) PGMGstGetPaePDPtr(PVM pVM, unsigned iPdPt); 
    339  
    340338VMMDECL(int)    PGMFlushTLB(PVM pVM, uint64_t cr3, bool fGlobal); 
    341339VMMDECL(int)    PGMUpdateCR3(PVM pVM, uint64_t cr3); 
  • trunk/src/VBox/VMM/VMMAll/PGMAll.cpp

    r13195 r13197  
    12111211} 
    12121212 
    1213 /** 
    1214  * Gets the specified page directory pointer table entry. 
    1215  * 
    1216  * @returns PDP entry 
    1217  * @param   pPGM        Pointer to the PGM instance data. 
    1218  * @param   iPdpt       PDPT index 
    1219  */ 
    1220 VMMDECL(X86PDPE) PGMGstGetPaePDPtr(PVM pVM, unsigned iPdpt) 
    1221 { 
    1222     Assert(iPdpt <= 3); 
    1223     return pVM->pgm.s.CTXSUFF(pGstPaePDPT)->a[iPdpt & 3]; 
    1224 } 
    1225  
    12261213 
    12271214/** 
  • trunk/src/VBox/VMM/VMMR0/HWVMXR0.cpp

    r13195 r13197  
    5252*******************************************************************************/ 
    5353#ifdef VBOX_STRICT 
    54 static void vmxR0ReportWorldSwitchError(PVM pVM, int rc, PCPUMCTX pCtx); 
     54static void VMXR0ReportWorldSwitchError(PVM pVM, int rc, PCPUMCTX pCtx); 
    5555#else 
    5656#define VMXR0ReportWorldSwitchError(a, b, c)      do { } while (0); 
    5757#endif /* VBOX_STRICT */ 
    58 static void vmxR0SetupTLBEPT(PVM pVM); 
    59 static void vmxR0SetupTLBVPID(PVM pVM); 
    60 static void vmxR0SetupTLBDummy(PVM pVM); 
    61 static void vmxR0FlushEPT(PVM pVM, VMX_FLUSH enmFlush, RTGCPHYS GCPhys); 
    62 static void vmxR0FlushVPID(PVM pVM, VMX_FLUSH enmFlush, RTGCPTR GCPtr); 
    63 static void vmxR0PrefetchPAEPdptrs(PVM pVM, PCPUMCTX pCtx); 
    64  
    65  
    66 static void vmxR0CheckError(PVM pVM, int rc) 
     58static void VMXR0SetupTLBEPT(PVM pVM); 
     59static void VMXR0SetupTLBVPID(PVM pVM); 
     60static void VMXR0SetupTLBDummy(PVM pVM); 
     61static void VMXR0FlushEPT(PVM pVM, VMX_FLUSH enmFlush, RTGCPHYS GCPhys); 
     62static void VMXR0FlushVPID(PVM pVM, VMX_FLUSH enmFlush, RTGCPTR GCPtr); 
     63 
     64 
     65static void VMXR0CheckError(PVM pVM, int rc) 
    6766{ 
    6867    if (rc == VERR_VMX_GENERIC) 
     
    111110    if (VBOX_FAILURE(rc)) 
    112111    { 
    113         vmxR0CheckError(pVM, rc); 
     112        VMXR0CheckError(pVM, rc); 
    114113        ASMSetCR4(ASMGetCR4() & ~X86_CR4_VMXE); 
    115114        return VERR_VMX_VMXON_FAILED; 
     
    279278    val &= pVM->hwaccm.s.vmx.msr.vmx_pin_ctls.n.allowed1; 
    280279 
    281     rc = VMXWriteVMCS32(VMX_VMCS_CTRL_PIN_EXEC_CONTROLS, val); 
     280    rc = VMXWriteVMCS(VMX_VMCS_CTRL_PIN_EXEC_CONTROLS, val); 
    282281    AssertRC(rc); 
    283282 
     
    329328    pVM->hwaccm.s.vmx.proc_ctls = val; 
    330329 
    331     rc = VMXWriteVMCS32(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, val); 
     330    rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, val); 
    332331    AssertRC(rc); 
    333332 
     
    354353        val &= pVM->hwaccm.s.vmx.msr.vmx_proc_ctls2.n.allowed1; 
    355354 
    356         rc = VMXWriteVMCS32(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS2, val); 
     355        rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS2, val); 
    357356        AssertRC(rc); 
    358357    } 
     
    361360     * Set required bits to one and zero according to the MSR capabilities. 
    362361     */ 
    363     rc = VMXWriteVMCS32(VMX_VMCS_CTRL_CR3_TARGET_COUNT, 0); 
     362    rc = VMXWriteVMCS(VMX_VMCS_CTRL_CR3_TARGET_COUNT, 0); 
    364363    AssertRC(rc); 
    365364 
     
    378377    val &= pVM->hwaccm.s.vmx.msr.vmx_exit.n.allowed1; 
    379378    /* Don't acknowledge external interrupts on VM-exit. */ 
    380     rc = VMXWriteVMCS32(VMX_VMCS_CTRL_EXIT_CONTROLS, val); 
     379    rc = VMXWriteVMCS(VMX_VMCS_CTRL_EXIT_CONTROLS, val); 
    381380    AssertRC(rc); 
    382381 
     
    398397        pVM->hwaccm.s.vmx.u32TrapMask &= ~RT_BIT(X86_XCPT_PF);   /* no longer need to intercept #PF. */ 
    399398#endif 
    400     rc = VMXWriteVMCS32(VMX_VMCS_CTRL_EXCEPTION_BITMAP, pVM->hwaccm.s.vmx.u32TrapMask); 
     399    rc = VMXWriteVMCS(VMX_VMCS_CTRL_EXCEPTION_BITMAP, pVM->hwaccm.s.vmx.u32TrapMask); 
    401400    AssertRC(rc); 
    402401 
    403402    /* Don't filter page faults; all of them should cause a switch. */ 
    404     rc  = VMXWriteVMCS32(VMX_VMCS_CTRL_PAGEFAULT_ERROR_MASK, 0); 
    405     rc |= VMXWriteVMCS32(VMX_VMCS_CTRL_PAGEFAULT_ERROR_MATCH, 0); 
     403    rc  = VMXWriteVMCS(VMX_VMCS_CTRL_PAGEFAULT_ERROR_MASK, 0); 
     404    rc |= VMXWriteVMCS(VMX_VMCS_CTRL_PAGEFAULT_ERROR_MATCH, 0); 
    406405    AssertRC(rc); 
    407406 
    408407    /* Init TSC offset to zero. */ 
    409     rc  = VMXWriteVMCS64(VMX_VMCS_CTRL_TSC_OFFSET_FULL, 0); 
    410     AssertRC(rc); 
    411  
    412     rc  = VMXWriteVMCS64(VMX_VMCS_CTRL_IO_BITMAP_A_FULL, 0); 
    413     AssertRC(rc); 
    414  
    415     rc  = VMXWriteVMCS64(VMX_VMCS_CTRL_IO_BITMAP_B_FULL, 0); 
     408    rc  = VMXWriteVMCS(VMX_VMCS_CTRL_TSC_OFFSET_FULL, 0); 
     409#if HC_ARCH_BITS == 32 
     410    rc |= VMXWriteVMCS(VMX_VMCS_CTRL_TSC_OFFSET_HIGH, 0); 
     411#endif 
     412    AssertRC(rc); 
     413 
     414    rc  = VMXWriteVMCS(VMX_VMCS_CTRL_IO_BITMAP_A_FULL, 0); 
     415#if HC_ARCH_BITS == 32 
     416    rc |= VMXWriteVMCS(VMX_VMCS_CTRL_IO_BITMAP_A_HIGH, 0); 
     417#endif 
     418    AssertRC(rc); 
     419 
     420    rc  = VMXWriteVMCS(VMX_VMCS_CTRL_IO_BITMAP_B_FULL, 0); 
     421#if HC_ARCH_BITS == 32 
     422    rc |= VMXWriteVMCS(VMX_VMCS_CTRL_IO_BITMAP_B_HIGH, 0); 
     423#endif 
    416424    AssertRC(rc); 
    417425 
     
    420428    { 
    421429        /* Optional */ 
    422         rc  = VMXWriteVMCS64(VMX_VMCS_CTRL_MSR_BITMAP_FULL, pVM->hwaccm.s.vmx.pMSRBitmapPhys); 
     430        rc  = VMXWriteVMCS(VMX_VMCS_CTRL_MSR_BITMAP_FULL, pVM->hwaccm.s.vmx.pMSRBitmapPhys); 
     431#if HC_ARCH_BITS == 32 
     432        rc |= VMXWriteVMCS(VMX_VMCS_CTRL_MSR_BITMAP_HIGH, pVM->hwaccm.s.vmx.pMSRBitmapPhys >> 32ULL); 
     433#endif 
    423434        AssertRC(rc); 
    424435    } 
    425436 
    426437    /* Clear MSR controls. */ 
    427     rc  = VMXWriteVMCS64(VMX_VMCS_CTRL_VMEXIT_MSR_STORE_FULL, 0); 
    428     rc |= VMXWriteVMCS64(VMX_VMCS_CTRL_VMEXIT_MSR_LOAD_FULL, 0); 
    429     rc |= VMXWriteVMCS64(VMX_VMCS_CTRL_VMENTRY_MSR_LOAD_FULL, 0); 
    430     rc |= VMXWriteVMCS32(VMX_VMCS_CTRL_EXIT_MSR_STORE_COUNT, 0); 
    431     rc |= VMXWriteVMCS32(VMX_VMCS_CTRL_EXIT_MSR_LOAD_COUNT, 0); 
     438    rc  = VMXWriteVMCS(VMX_VMCS_CTRL_VMEXIT_MSR_STORE_FULL, 0); 
     439    rc |= VMXWriteVMCS(VMX_VMCS_CTRL_VMEXIT_MSR_LOAD_FULL, 0); 
     440    rc |= VMXWriteVMCS(VMX_VMCS_CTRL_VMENTRY_MSR_LOAD_FULL, 0); 
     441#if HC_ARCH_BITS == 32 
     442    rc |= VMXWriteVMCS(VMX_VMCS_CTRL_VMEXIT_MSR_STORE_HIGH, 0); 
     443    rc |= VMXWriteVMCS(VMX_VMCS_CTRL_VMEXIT_MSR_LOAD_HIGH, 0); 
     444    rc |= VMXWriteVMCS(VMX_VMCS_CTRL_VMEXIT_MSR_LOAD_HIGH, 0); 
     445#endif 
     446    rc |= VMXWriteVMCS(VMX_VMCS_CTRL_EXIT_MSR_STORE_COUNT, 0); 
     447    rc |= VMXWriteVMCS(VMX_VMCS_CTRL_EXIT_MSR_LOAD_COUNT, 0); 
    432448    AssertRC(rc); 
    433449 
     
    436452        Assert(pVM->hwaccm.s.vmx.pMemObjAPIC); 
    437453        /* Optional */ 
    438         rc  = VMXWriteVMCS32(VMX_VMCS_CTRL_TPR_THRESHOLD, 0); 
    439         rc |= VMXWriteVMCS64(VMX_VMCS_CTRL_VAPIC_PAGEADDR_FULL, pVM->hwaccm.s.vmx.pAPICPhys); 
     454        rc  = VMXWriteVMCS(VMX_VMCS_CTRL_TPR_THRESHOLD, 0); 
     455        rc |= VMXWriteVMCS(VMX_VMCS_CTRL_VAPIC_PAGEADDR_FULL, pVM->hwaccm.s.vmx.pAPICPhys); 
     456#if HC_ARCH_BITS == 32 
     457        rc |= VMXWriteVMCS(VMX_VMCS_CTRL_VAPIC_PAGEADDR_HIGH, pVM->hwaccm.s.vmx.pAPICPhys >> 32ULL); 
     458#endif 
    440459        AssertRC(rc); 
    441460    } 
    442461 
    443462    /* Set link pointer to -1. Not currently used. */ 
    444     rc  = VMXWriteVMCS64(VMX_VMCS_GUEST_LINK_PTR_FULL, 0xFFFFFFFFFFFFFFFF); 
     463#if HC_ARCH_BITS == 32 
     464    rc  = VMXWriteVMCS(VMX_VMCS_GUEST_LINK_PTR_FULL, 0xFFFFFFFF); 
     465    rc |= VMXWriteVMCS(VMX_VMCS_GUEST_LINK_PTR_HIGH, 0xFFFFFFFF); 
     466#else 
     467    rc  = VMXWriteVMCS(VMX_VMCS_GUEST_LINK_PTR_FULL, 0xFFFFFFFFFFFFFFFF); 
     468#endif 
    445469    AssertRC(rc); 
    446470 
     
    452476    if (pVM->hwaccm.s.fNestedPaging) 
    453477    { 
    454         pVM->hwaccm.s.vmx.pfnSetupTaggedTLB = vmxR0SetupTLBEPT; 
     478        pVM->hwaccm.s.vmx.pfnSetupTaggedTLB = VMXR0SetupTLBEPT; 
    455479 
    456480        /* Default values for flushing. */ 
     
    472496    if (pVM->hwaccm.s.vmx.fVPID) 
    473497    { 
    474         pVM->hwaccm.s.vmx.pfnSetupTaggedTLB = vmxR0SetupTLBVPID; 
     498        pVM->hwaccm.s.vmx.pfnSetupTaggedTLB = VMXR0SetupTLBVPID; 
    475499 
    476500        /* Default values for flushing. */ 
     
    490514#endif /* HWACCM_VTX_WITH_VPID */ 
    491515    else 
    492         pVM->hwaccm.s.vmx.pfnSetupTaggedTLB = vmxR0SetupTLBDummy; 
     516        pVM->hwaccm.s.vmx.pfnSetupTaggedTLB = VMXR0SetupTLBDummy; 
    493517 
    494518 
    495519vmx_end: 
    496     vmxR0CheckError(pVM, rc); 
     520    VMXR0CheckError(pVM, rc); 
    497521    return rc; 
    498522} 
     
    549573 
    550574    /* Set event injection state. */ 
    551     rc  = VMXWriteVMCS32(VMX_VMCS_CTRL_ENTRY_IRQ_INFO, intInfo | (1 << VMX_EXIT_INTERRUPTION_INFO_VALID_SHIFT)); 
    552  
    553     rc |= VMXWriteVMCS32(VMX_VMCS_CTRL_ENTRY_INSTR_LENGTH, cbInstr); 
    554     rc |= VMXWriteVMCS32(VMX_VMCS_CTRL_ENTRY_EXCEPTION_ERRCODE, errCode); 
     575    rc  = VMXWriteVMCS(VMX_VMCS_CTRL_ENTRY_IRQ_INFO, intInfo | (1 << VMX_EXIT_INTERRUPTION_INFO_VALID_SHIFT)); 
     576 
     577    rc |= VMXWriteVMCS(VMX_VMCS_CTRL_ENTRY_INSTR_LENGTH, cbInstr); 
     578    rc |= VMXWriteVMCS(VMX_VMCS_CTRL_ENTRY_EXCEPTION_ERRCODE, errCode); 
    555579 
    556580    AssertRC(rc); 
     
    592616                LogFlow(("Enable irq window exit!\n")); 
    593617                pVM->hwaccm.s.vmx.proc_ctls |= VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_IRQ_WINDOW_EXIT; 
    594                 rc = VMXWriteVMCS32(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
     618                rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
    595619                AssertRC(rc); 
    596620            } 
     
    708732 
    709733        /* Control registers */ 
    710         rc  = VMXWriteVMCS32(VMX_VMCS_HOST_CR0,               ASMGetCR0()); 
    711         rc |= VMXWriteVMCS32(VMX_VMCS_HOST_CR3,               ASMGetCR3()); 
    712         rc |= VMXWriteVMCS32(VMX_VMCS_HOST_CR4,               ASMGetCR4()); 
     734        rc  = VMXWriteVMCS(VMX_VMCS_HOST_CR0,               ASMGetCR0()); 
     735        rc |= VMXWriteVMCS(VMX_VMCS_HOST_CR3,               ASMGetCR3()); 
     736        rc |= VMXWriteVMCS(VMX_VMCS_HOST_CR4,               ASMGetCR4()); 
    713737        AssertRC(rc); 
    714738        Log2(("VMX_VMCS_HOST_CR0 %08x\n", ASMGetCR0())); 
     
    717741 
    718742        /* Selector registers. */ 
    719         rc  = VMXWriteVMCS32(VMX_VMCS_HOST_FIELD_CS,          ASMGetCS()); 
     743        rc  = VMXWriteVMCS(VMX_VMCS_HOST_FIELD_CS,          ASMGetCS()); 
    720744        /* Note: VMX is (again) very picky about the RPL of the selectors here; we'll restore them manually. */ 
    721         rc |= VMXWriteVMCS32(VMX_VMCS_HOST_FIELD_DS,          0); 
    722         rc |= VMXWriteVMCS32(VMX_VMCS_HOST_FIELD_ES,          0); 
     745        rc |= VMXWriteVMCS(VMX_VMCS_HOST_FIELD_DS,          0); 
     746        rc |= VMXWriteVMCS(VMX_VMCS_HOST_FIELD_ES,          0); 
    723747#if HC_ARCH_BITS == 32 
    724         rc |= VMXWriteVMCS32(VMX_VMCS_HOST_FIELD_FS,          0); 
    725         rc |= VMXWriteVMCS32(VMX_VMCS_HOST_FIELD_GS,          0); 
    726 #endif 
    727         rc |= VMXWriteVMCS32(VMX_VMCS_HOST_FIELD_SS,          ASMGetSS()); 
     748        rc |= VMXWriteVMCS(VMX_VMCS_HOST_FIELD_FS,          0); 
     749        rc |= VMXWriteVMCS(VMX_VMCS_HOST_FIELD_GS,          0); 
     750#endif 
     751        rc |= VMXWriteVMCS(VMX_VMCS_HOST_FIELD_SS,          ASMGetSS()); 
    728752        SelTR = ASMGetTR(); 
    729         rc |= VMXWriteVMCS32(VMX_VMCS_HOST_FIELD_TR,          SelTR); 
     753        rc |= VMXWriteVMCS(VMX_VMCS_HOST_FIELD_TR,          SelTR); 
    730754        AssertRC(rc); 
    731755        Log2(("VMX_VMCS_HOST_FIELD_CS %08x\n", ASMGetCS())); 
     
    739763        /* GDTR & IDTR */ 
    740764        ASMGetGDTR(&gdtr); 
    741         rc  = VMXWriteVMCS32(VMX_VMCS_HOST_GDTR_BASE, gdtr.pGdt); 
     765        rc  = VMXWriteVMCS(VMX_VMCS_HOST_GDTR_BASE, gdtr.pGdt); 
    742766        ASMGetIDTR(&idtr); 
    743         rc |= VMXWriteVMCS32(VMX_VMCS_HOST_IDTR_BASE, idtr.pIdt); 
     767        rc |= VMXWriteVMCS(VMX_VMCS_HOST_IDTR_BASE, idtr.pIdt); 
    744768        AssertRC(rc); 
    745769        Log2(("VMX_VMCS_HOST_GDTR_BASE %VHv\n", gdtr.pGdt)); 
     
    759783        trBase = X86DESC_BASE(*pDesc); 
    760784#endif 
    761         rc = VMXWriteVMCS32(VMX_VMCS_HOST_TR_BASE, trBase); 
     785        rc = VMXWriteVMCS(VMX_VMCS_HOST_TR_BASE, trBase); 
    762786        AssertRC(rc); 
    763787        Log2(("VMX_VMCS_HOST_TR_BASE %VHv\n", trBase)); 
     
    774798        /* Sysenter MSRs. */ 
    775799        /** @todo expensive!! */ 
    776         rc  = VMXWriteVMCS32(VMX_VMCS_HOST_SYSENTER_CS,       ASMRdMsr_Low(MSR_IA32_SYSENTER_CS)); 
     800        rc  = VMXWriteVMCS(VMX_VMCS_HOST_SYSENTER_CS,       ASMRdMsr_Low(MSR_IA32_SYSENTER_CS)); 
    777801        Log2(("VMX_VMCS_HOST_SYSENTER_CS  %08x\n", ASMRdMsr_Low(MSR_IA32_SYSENTER_CS))); 
    778802#if HC_ARCH_BITS == 32 
    779         rc |= VMXWriteVMCS32(VMX_VMCS_HOST_SYSENTER_ESP,      ASMRdMsr_Low(MSR_IA32_SYSENTER_ESP)); 
    780         rc |= VMXWriteVMCS32(VMX_VMCS_HOST_SYSENTER_EIP,      ASMRdMsr_Low(MSR_IA32_SYSENTER_EIP)); 
     803        rc |= VMXWriteVMCS(VMX_VMCS_HOST_SYSENTER_ESP,      ASMRdMsr_Low(MSR_IA32_SYSENTER_ESP)); 
     804        rc |= VMXWriteVMCS(VMX_VMCS_HOST_SYSENTER_EIP,      ASMRdMsr_Low(MSR_IA32_SYSENTER_EIP)); 
    781805        Log2(("VMX_VMCS_HOST_SYSENTER_EIP %VHv\n", ASMRdMsr_Low(MSR_IA32_SYSENTER_EIP))); 
    782806        Log2(("VMX_VMCS_HOST_SYSENTER_ESP %VHv\n", ASMRdMsr_Low(MSR_IA32_SYSENTER_ESP))); 
     
    794818} 
    795819 
    796 /** 
    797  * Prefetch the 4 PDPT pointers (PAE and nested paging only) 
    798  * 
    799  * @param   pVM         The VM to operate on. 
    800  * @param   pCtx        Guest context 
    801  */ 
    802 static void vmxR0PrefetchPAEPdptrs(PVM pVM, PCPUMCTX pCtx) 
    803 { 
    804     if (    (pCtx->cr4 & X86_CR4_PAE) 
    805         &&  !CPUMIsGuestInLongModeEx(pCtx)) 
    806     { 
    807         X86PDPE Pdpe; 
    808  
    809         for (unsigned i=0;i<4;i++) 
    810         { 
    811             Pdpe = PGMGstGetPaePDPtr(pVM, i); 
    812             int rc = VMXWriteVMCS64(VMX_VMCS_GUEST_PDPTR0_FULL + i*2, Pdpe.u); 
    813             AssertRC(rc); 
    814         } 
    815     } 
    816 } 
    817820 
    818821/** 
     
    957960        if (pCtx->ldtr == 0) 
    958961        { 
    959             rc =  VMXWriteVMCS32(VMX_VMCS_GUEST_FIELD_LDTR,         0); 
    960             rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_LDTR_LIMIT,         0); 
    961             rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_LDTR_BASE,          0); 
     962            rc =  VMXWriteVMCS(VMX_VMCS_GUEST_FIELD_LDTR,         0); 
     963            rc |= VMXWriteVMCS(VMX_VMCS_GUEST_LDTR_LIMIT,         0); 
     964            rc |= VMXWriteVMCS(VMX_VMCS_GUEST_LDTR_BASE,          0); 
    962965            /* Note: vmlaunch will fail with 0 or just 0x02. No idea why. */ 
    963             rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_LDTR_ACCESS_RIGHTS, 0x82 /* present, LDT */); 
     966            rc |= VMXWriteVMCS(VMX_VMCS_GUEST_LDTR_ACCESS_RIGHTS, 0x82 /* present, LDT */); 
    964967        } 
    965968        else 
    966969        { 
    967             rc =  VMXWriteVMCS32(VMX_VMCS_GUEST_FIELD_LDTR,         pCtx->ldtr); 
    968             rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_LDTR_LIMIT,         pCtx->ldtrHid.u32Limit); 
    969             rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_LDTR_BASE,          pCtx->ldtrHid.u64Base); 
    970             rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_LDTR_ACCESS_RIGHTS, pCtx->ldtrHid.Attr.u); 
     970            rc =  VMXWriteVMCS(VMX_VMCS_GUEST_FIELD_LDTR,         pCtx->ldtr); 
     971            rc |= VMXWriteVMCS(VMX_VMCS_GUEST_LDTR_LIMIT,         pCtx->ldtrHid.u32Limit); 
     972            rc |= VMXWriteVMCS(VMX_VMCS_GUEST_LDTR_BASE,          pCtx->ldtrHid.u64Base); 
     973            rc |= VMXWriteVMCS(VMX_VMCS_GUEST_LDTR_ACCESS_RIGHTS, pCtx->ldtrHid.Attr.u); 
    971974        } 
    972975        AssertRC(rc); 
     
    985988            AssertRC(rc); 
    986989 
    987             rc =  VMXWriteVMCS32(VMX_VMCS_GUEST_FIELD_TR,         0); 
    988             rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_TR_LIMIT,         HWACCM_VTX_TSS_SIZE); 
    989             rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_TR_BASE,          GCPhys /* phys = virt in this mode */); 
     990            rc =  VMXWriteVMCS(VMX_VMCS_GUEST_FIELD_TR,         0); 
     991            rc |= VMXWriteVMCS(VMX_VMCS_GUEST_TR_LIMIT,         HWACCM_VTX_TSS_SIZE); 
     992            rc |= VMXWriteVMCS(VMX_VMCS_GUEST_TR_BASE,          GCPhys /* phys = virt in this mode */); 
    990993 
    991994            X86DESCATTR attr; 
     
    9991002#endif /* HWACCM_VMX_EMULATE_REALMODE */ 
    10001003        { 
    1001             rc =  VMXWriteVMCS32(VMX_VMCS_GUEST_FIELD_TR,         pCtx->tr); 
    1002             rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_TR_LIMIT,         pCtx->trHid.u32Limit); 
    1003             rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_TR_BASE,          pCtx->trHid.u64Base); 
     1004            rc =  VMXWriteVMCS(VMX_VMCS_GUEST_FIELD_TR,         pCtx->tr); 
     1005            rc |= VMXWriteVMCS(VMX_VMCS_GUEST_TR_LIMIT,         pCtx->trHid.u32Limit); 
     1006            rc |= VMXWriteVMCS(VMX_VMCS_GUEST_TR_BASE,          pCtx->trHid.u64Base); 
    10041007 
    10051008            val = pCtx->trHid.Attr.u; 
     
    10131016 
    10141017        } 
    1015         rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_TR_ACCESS_RIGHTS, val); 
     1018        rc |= VMXWriteVMCS(VMX_VMCS_GUEST_TR_ACCESS_RIGHTS, val); 
    10161019        AssertRC(rc); 
    10171020    } 
     
    10191022    if (pVM->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_GUEST_GDTR) 
    10201023    { 
    1021         rc  = VMXWriteVMCS32(VMX_VMCS_GUEST_GDTR_LIMIT,       pCtx->gdtr.cbGdt); 
    1022         rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_GDTR_BASE,        pCtx->gdtr.pGdt); 
     1024        rc  = VMXWriteVMCS(VMX_VMCS_GUEST_GDTR_LIMIT,       pCtx->gdtr.cbGdt); 
     1025        rc |= VMXWriteVMCS(VMX_VMCS_GUEST_GDTR_BASE,        pCtx->gdtr.pGdt); 
    10231026        AssertRC(rc); 
    10241027    } 
     
    10261029    if (pVM->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_GUEST_IDTR) 
    10271030    { 
    1028         rc  = VMXWriteVMCS32(VMX_VMCS_GUEST_IDTR_LIMIT,       pCtx->idtr.cbIdt); 
    1029         rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_IDTR_BASE,        pCtx->idtr.pIdt); 
     1031        rc  = VMXWriteVMCS(VMX_VMCS_GUEST_IDTR_LIMIT,       pCtx->idtr.cbIdt); 
     1032        rc |= VMXWriteVMCS(VMX_VMCS_GUEST_IDTR_BASE,        pCtx->idtr.pIdt); 
    10301033        AssertRC(rc); 
    10311034    } 
     
    10341037     * Sysenter MSRs (unconditional) 
    10351038     */ 
    1036     rc  = VMXWriteVMCS32(VMX_VMCS_GUEST_SYSENTER_CS,      pCtx->SysEnter.cs); 
    1037     rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_SYSENTER_EIP,     pCtx->SysEnter.eip); 
    1038     rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_SYSENTER_ESP,     pCtx->SysEnter.esp); 
     1039    rc  = VMXWriteVMCS(VMX_VMCS_GUEST_SYSENTER_CS,      pCtx->SysEnter.cs); 
     1040    rc |= VMXWriteVMCS(VMX_VMCS_GUEST_SYSENTER_EIP,     pCtx->SysEnter.eip); 
     1041    rc |= VMXWriteVMCS(VMX_VMCS_GUEST_SYSENTER_ESP,     pCtx->SysEnter.esp); 
    10391042    AssertRC(rc); 
    10401043 
     
    10431046    { 
    10441047        val = pCtx->cr0; 
    1045         rc  = VMXWriteVMCS32(VMX_VMCS_CTRL_CR0_READ_SHADOW,   val); 
     1048        rc  = VMXWriteVMCS(VMX_VMCS_CTRL_CR0_READ_SHADOW,   val); 
    10461049        Log2(("Guest CR0-shadow %08x\n", val)); 
    10471050        if (CPUMIsGuestFPUStateActive(pVM) == false) 
     
    10611064                { 
    10621065                    pVM->hwaccm.s.vmx.u32TrapMask |= RT_BIT(X86_XCPT_MF); 
    1063                     rc = VMXWriteVMCS32(VMX_VMCS_CTRL_EXCEPTION_BITMAP, pVM->hwaccm.s.vmx.u32TrapMask); 
     1066                    rc = VMXWriteVMCS(VMX_VMCS_CTRL_EXCEPTION_BITMAP, pVM->hwaccm.s.vmx.u32TrapMask); 
    10641067                    AssertRC(rc); 
    10651068                    pVM->hwaccm.s.fFPUOldStyleOverride = true; 
     
    10851088                                               | VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_CR3_STORE_EXIT; 
    10861089            } 
    1087             rc = VMXWriteVMCS32(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
     1090            rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
    10881091            AssertRC(rc); 
    10891092        } 
     
    10971100        val &= ~(X86_CR0_CD|X86_CR0_NW); 
    10981101 
    1099         rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_CR0,              val); 
     1102        rc |= VMXWriteVMCS(VMX_VMCS_GUEST_CR0,              val); 
    11001103        Log2(("Guest CR0 %08x\n", val)); 
    11011104        /* CR0 flags owned by the host; if the guests attempts to change them, then 
     
    11131116        pVM->hwaccm.s.vmx.cr0_mask = val; 
    11141117 
    1115         rc |= VMXWriteVMCS32(VMX_VMCS_CTRL_CR0_MASK, val); 
     1118        rc |= VMXWriteVMCS(VMX_VMCS_CTRL_CR0_MASK, val); 
    11161119        Log2(("Guest CR0-mask %08x\n", val)); 
    11171120        AssertRC(rc); 
     
    11201123    { 
    11211124        /* CR4 */ 
    1122         rc  = VMXWriteVMCS32(VMX_VMCS_CTRL_CR4_READ_SHADOW,   pCtx->cr4); 
     1125        rc  = VMXWriteVMCS(VMX_VMCS_CTRL_CR4_READ_SHADOW,   pCtx->cr4); 
    11231126        Log2(("Guest CR4-shadow %08x\n", pCtx->cr4)); 
    11241127        /* Set the required bits in cr4 too (currently X86_CR4_VMXE). */ 
     
    11681171#endif /* HWACCM_VMX_EMULATE_REALMODE */ 
    11691172 
    1170         rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_CR4,              val); 
     1173        rc |= VMXWriteVMCS(VMX_VMCS_GUEST_CR4,              val); 
    11711174        Log2(("Guest CR4 %08x\n", val)); 
    11721175        /* CR4 flags owned by the host; if the guests attempts to change them, then 
     
    11831186        pVM->hwaccm.s.vmx.cr4_mask = val; 
    11841187 
    1185         rc |= VMXWriteVMCS32(VMX_VMCS_CTRL_CR4_MASK, val); 
     1188        rc |= VMXWriteVMCS(VMX_VMCS_CTRL_CR4_MASK, val); 
    11861189        Log2(("Guest CR4-mask %08x\n", val)); 
    11871190        AssertRC(rc); 
     
    12001203                                           | (VMX_EPT_PAGE_WALK_LENGTH_DEFAULT << VMX_EPT_PAGE_WALK_LENGTH_SHIFT); 
    12011204             
    1202             rc = VMXWriteVMCS64(VMX_VMCS_CTRL_EPTP_FULL, pVM->hwaccm.s.vmx.GCPhysEPTP); 
     1205            rc = VMXWriteVMCS(VMX_VMCS_CTRL_EPTP_FULL, pVM->hwaccm.s.vmx.GCPhysEPTP); 
     1206#if HC_ARCH_BITS == 32 
     1207            rc = VMXWriteVMCS(VMX_VMCS_CTRL_EPTP_HIGH, (uint32_t)(pVM->hwaccm.s.vmx.GCPhysEPTP >> 32ULL)); 
     1208#endif 
    12031209            AssertRC(rc); 
    12041210 
     
    12201226                /* Save the real guest CR3 in VMX_VMCS_GUEST_CR3 */ 
    12211227                val = pCtx->cr3; 
    1222  
    1223                 /* Prefetch the four PDPT entries in PAE mode. */ 
    1224                 vmxR0PrefetchPAEPdptrs(pVM, pCtx); 
    12251228            } 
    12261229        } 
     
    12321235 
    12331236        /* Save our shadow CR3 register. */ 
    1234         rc = VMXWriteVMCS32(VMX_VMCS_GUEST_CR3, val); 
     1237        rc = VMXWriteVMCS(VMX_VMCS_GUEST_CR3, val); 
    12351238        AssertRC(rc); 
    12361239    } 
     
    12471250 
    12481251        /* Resync DR7 */ 
    1249         rc = VMXWriteVMCS32(VMX_VMCS_GUEST_DR7, pCtx->dr[7]); 
     1252        rc = VMXWriteVMCS(VMX_VMCS_GUEST_DR7, pCtx->dr[7]); 
    12501253        AssertRC(rc); 
    12511254 
     
    12591262            /* Disable drx move intercepts. */ 
    12601263            pVM->hwaccm.s.vmx.proc_ctls &= ~VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_MOV_DR_EXIT; 
    1261             rc = VMXWriteVMCS32(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
     1264            rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
    12621265            AssertRC(rc); 
    12631266 
     
    12681271 
    12691272        /* IA32_DEBUGCTL MSR. */ 
    1270         rc  = VMXWriteVMCS32(VMX_VMCS_GUEST_DEBUGCTL_FULL,    0); 
    1271         rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_DEBUGCTL_HIGH,    0); 
     1273        rc  = VMXWriteVMCS(VMX_VMCS_GUEST_DEBUGCTL_FULL,    0); 
     1274        rc |= VMXWriteVMCS(VMX_VMCS_GUEST_DEBUGCTL_HIGH,    0); 
    12721275        AssertRC(rc); 
    12731276 
    12741277        /** @todo do we really ever need this? */ 
    1275         rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_DEBUG_EXCEPTIONS,         0); 
     1278        rc |= VMXWriteVMCS(VMX_VMCS_GUEST_DEBUG_EXCEPTIONS,         0); 
    12761279        AssertRC(rc); 
    12771280    } 
    12781281 
    12791282    /* EIP, ESP and EFLAGS */ 
    1280     rc  = VMXWriteVMCS32(VMX_VMCS_GUEST_RIP,              pCtx->rip); 
    1281     rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_RSP,              pCtx->rsp); 
     1283    rc  = VMXWriteVMCS(VMX_VMCS_GUEST_RIP,              pCtx->rip); 
     1284    rc |= VMXWriteVMCS(VMX_VMCS_GUEST_RSP,              pCtx->rsp); 
    12821285    AssertRC(rc); 
    12831286 
     
    12951298    } 
    12961299#endif /* HWACCM_VMX_EMULATE_REALMODE */ 
    1297     rc   = VMXWriteVMCS32(VMX_VMCS_GUEST_RFLAGS,           eflags.u32); 
     1300    rc   = VMXWriteVMCS(VMX_VMCS_GUEST_RFLAGS,           eflags.u32); 
    12981301    AssertRC(rc); 
    12991302 
     
    13041307    { 
    13051308        /* Note: VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_RDTSC_EXIT takes precedence over TSC_OFFSET */ 
    1306         rc  = VMXWriteVMCS64(VMX_VMCS_CTRL_TSC_OFFSET_FULL, u64TSCOffset); 
     1309        rc  = VMXWriteVMCS(VMX_VMCS_CTRL_TSC_OFFSET_FULL, u64TSCOffset); 
     1310#if HC_ARCH_BITS == 32 
     1311        rc |= VMXWriteVMCS(VMX_VMCS_CTRL_TSC_OFFSET_HIGH, (uint32_t)(u64TSCOffset >> 32ULL)); 
     1312#endif 
    13071313        AssertRC(rc); 
    13081314 
    13091315        pVM->hwaccm.s.vmx.proc_ctls &= ~VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_RDTSC_EXIT; 
    1310         rc = VMXWriteVMCS32(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
     1316        rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
    13111317        AssertRC(rc); 
    13121318        STAM_COUNTER_INC(&pVM->hwaccm.s.StatTSCOffset); 
     
    13151321    { 
    13161322        pVM->hwaccm.s.vmx.proc_ctls |= VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_RDTSC_EXIT; 
    1317         rc = VMXWriteVMCS32(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
     1323        rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
    13181324        AssertRC(rc); 
    13191325        STAM_COUNTER_INC(&pVM->hwaccm.s.StatTSCIntercept); 
     
    13341340    /* Mask away the bits that the CPU doesn't support */ 
    13351341    val &= pVM->hwaccm.s.vmx.msr.vmx_entry.n.allowed1; 
    1336     rc = VMXWriteVMCS32(VMX_VMCS_CTRL_ENTRY_CONTROLS, val); 
     1342    rc = VMXWriteVMCS(VMX_VMCS_CTRL_ENTRY_CONTROLS, val); 
    13371343    AssertRC(rc); 
    13381344 
     
    13461352#endif 
    13471353        /* Unconditionally update these as wrmsr might have changed them. */ 
    1348         rc = VMXWriteVMCS32(VMX_VMCS_GUEST_FS_BASE, pCtx->fsHid.u64Base); 
    1349         AssertRC(rc); 
    1350         rc = VMXWriteVMCS32(VMX_VMCS_GUEST_GS_BASE, pCtx->gsHid.u64Base); 
     1354        rc = VMXWriteVMCS(VMX_VMCS_GUEST_FS_BASE, pCtx->fsHid.u64Base); 
     1355        AssertRC(rc); 
     1356        rc = VMXWriteVMCS(VMX_VMCS_GUEST_GS_BASE, pCtx->gsHid.u64Base); 
    13511357        AssertRC(rc); 
    13521358    } 
     
    13631369        pVM->hwaccm.s.vmx.u32TrapMask &= ~RT_BIT(X86_XCPT_DB); 
    13641370 
    1365     rc = VMXWriteVMCS32(VMX_VMCS_CTRL_EXCEPTION_BITMAP, pVM->hwaccm.s.vmx.u32TrapMask); 
     1371    rc = VMXWriteVMCS(VMX_VMCS_CTRL_EXCEPTION_BITMAP, pVM->hwaccm.s.vmx.u32TrapMask); 
    13661372#endif 
    13671373 
     
    13761382        pVM->hwaccm.s.vmx.u32TrapMask &= ~RT_BIT(X86_XCPT_GP); 
    13771383# endif /* HWACCM_VMX_EMULATE_REALMODE */ 
    1378     rc = VMXWriteVMCS32(VMX_VMCS_CTRL_EXCEPTION_BITMAP, pVM->hwaccm.s.vmx.u32TrapMask); 
     1384    rc = VMXWriteVMCS(VMX_VMCS_CTRL_EXCEPTION_BITMAP, pVM->hwaccm.s.vmx.u32TrapMask); 
    13791385    AssertRC(rc); 
    13801386#endif 
     
    14481454            PGMUpdateCR3(pVM, val); 
    14491455        } 
    1450         /* Prefetch the four PDPT entries in PAE mode. */ 
    1451         vmxR0PrefetchPAEPdptrs(pVM, pCtx); 
    14521456    } 
    14531457 
     
    15121516 * @param   pVM         The VM to operate on. 
    15131517 */ 
    1514 static void vmxR0SetupTLBDummy(PVM pVM) 
     1518static void VMXR0SetupTLBDummy(PVM pVM) 
    15151519{ 
    15161520    return; 
     
    15231527 * @param   pVM         The VM to operate on. 
    15241528 */ 
    1525 static void vmxR0SetupTLBEPT(PVM pVM) 
     1529static void VMXR0SetupTLBEPT(PVM pVM) 
    15261530{ 
    15271531    PHWACCM_CPUINFO pCpu; 
     
    15481552 
    15491553    if (pVM->hwaccm.s.fForceTLBFlush) 
    1550         vmxR0FlushEPT(pVM, pVM->hwaccm.s.vmx.enmFlushContext, 0); 
     1554        VMXR0FlushEPT(pVM, pVM->hwaccm.s.vmx.enmFlushContext, 0); 
    15511555 
    15521556#ifdef VBOX_WITH_STATISTICS 
     
    15651569 * @param   pVM         The VM to operate on. 
    15661570 */ 
    1567 static void vmxR0SetupTLBVPID(PVM pVM) 
     1571static void VMXR0SetupTLBVPID(PVM pVM) 
    15681572{ 
    15691573    PHWACCM_CPUINFO pCpu; 
     
    16181622    AssertMsg(pVM->hwaccm.s.uCurrentASID >= 1 && pVM->hwaccm.s.uCurrentASID < pVM->hwaccm.s.uMaxASID, ("cpu%d VM uCurrentASID = %x\n", pCpu->idCpu, pVM->hwaccm.s.uCurrentASID)); 
    16191623 
    1620     int rc  = VMXWriteVMCS32(VMX_VMCS_GUEST_FIELD_VPID, pVM->hwaccm.s.uCurrentASID); 
     1624    int rc  = VMXWriteVMCS(VMX_VMCS_GUEST_FIELD_VPID, pVM->hwaccm.s.uCurrentASID); 
    16211625    AssertRC(rc); 
    16221626 
    16231627    if (pVM->hwaccm.s.fForceTLBFlush) 
    1624         vmxr0lushVPID(pVM, pVM->hwaccm.s.vmx.enmFlushContext, 0); 
     1628        VMXR0FlushVPID(pVM, pVM->hwaccm.s.vmx.enmFlushContext, 0); 
    16251629 
    16261630#ifdef VBOX_WITH_STATISTICS 
     
    17371741            VM_FF_CLEAR(pVM, VM_FF_INHIBIT_INTERRUPTS); 
    17381742            /* Irq inhibition is no longer active; clear the corresponding VMX state. */ 
    1739             rc = VMXWriteVMCS32(VMX_VMCS_GUEST_INTERRUPTIBILITY_STATE,   0); 
     1743            rc = VMXWriteVMCS(VMX_VMCS_GUEST_INTERRUPTIBILITY_STATE,   0); 
    17401744            AssertRC(rc); 
    17411745        } 
     
    17441748    { 
    17451749        /* Irq inhibition is no longer active; clear the corresponding VMX state. */ 
    1746         rc = VMXWriteVMCS32(VMX_VMCS_GUEST_INTERRUPTIBILITY_STATE,   0); 
     1750        rc = VMXWriteVMCS(VMX_VMCS_GUEST_INTERRUPTIBILITY_STATE,   0); 
    17471751        AssertRC(rc); 
    17481752    } 
     
    18001804         *   -> We don't need to be explicitely notified. There are enough world switches for detecting pending interrupts. 
    18011805         */ 
    1802         rc  = VMXWriteVMCS32(VMX_VMCS_CTRL_TPR_THRESHOLD, (fPending) ? u8TPR : 0); 
     1806        rc  = VMXWriteVMCS(VMX_VMCS_CTRL_TPR_THRESHOLD, (fPending) ? u8TPR : 0); 
    18031807        AssertRC(rc); 
    18041808 
     
    18551859    /* Non-register state Guest Context */ 
    18561860    /** @todo change me according to cpu state */ 
    1857     rc = VMXWriteVMCS32(VMX_VMCS_GUEST_ACTIVITY_STATE,           VMX_CMS_GUEST_ACTIVITY_ACTIVE); 
     1861    rc = VMXWriteVMCS(VMX_VMCS_GUEST_ACTIVITY_STATE,           VMX_CMS_GUEST_ACTIVITY_ACTIVE); 
    18581862    AssertRC(rc); 
    18591863 
     
    18961900    if (rc != VINF_SUCCESS) 
    18971901    { 
    1898         vmxR0ReportWorldSwitchError(pVM, rc, pCtx); 
     1902        VMXR0ReportWorldSwitchError(pVM, rc, pCtx); 
    18991903        goto end; 
    19001904    } 
     
    21752179 
    21762180                    /* Resync DR7 */ 
    2177                     rc = VMXWriteVMCS32(VMX_VMCS_GUEST_DR7, pCtx->dr[7]); 
     2181                    rc = VMXWriteVMCS(VMX_VMCS_GUEST_DR7, pCtx->dr[7]); 
    21782182                    AssertRC(rc); 
    21792183 
     
    23362340        LogFlow(("VMX_EXIT_IRQ_WINDOW %VGv pending=%d IF=%d\n", pCtx->rip, VM_FF_ISPENDING(pVM, (VM_FF_INTERRUPT_APIC|VM_FF_INTERRUPT_PIC)), pCtx->eflags.Bits.u1IF)); 
    23372341        pVM->hwaccm.s.vmx.proc_ctls &= ~VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_IRQ_WINDOW_EXIT; 
    2338         rc = VMXWriteVMCS32(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
     2342        rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
    23392343        AssertRC(rc); 
    23402344        STAM_COUNTER_INC(&pVM->hwaccm.s.StatExitIrqWindow); 
     
    25162520            /* Disable drx move intercepts. */ 
    25172521            pVM->hwaccm.s.vmx.proc_ctls &= ~VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_MOV_DR_EXIT; 
    2518             rc = VMXWriteVMCS32(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
     2522            rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
    25192523            AssertRC(rc); 
    25202524 
     
    26842688 
    26852689                            /* Resync DR7 */ 
    2686                             rc = VMXWriteVMCS32(VMX_VMCS_GUEST_DR7, pCtx->dr[7]); 
     2690                            rc = VMXWriteVMCS(VMX_VMCS_GUEST_DR7, pCtx->dr[7]); 
    26872691                            AssertRC(rc); 
    26882692 
     
    29582962        /* Enable drx move intercepts again. */ 
    29592963        pVM->hwaccm.s.vmx.proc_ctls |= VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_MOV_DR_EXIT; 
    2960         int rc = VMXWriteVMCS32(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
     2964        int rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
    29612965        AssertRC(rc); 
    29622966 
     
    29822986 * @param   GCPhys      Physical address of the page to flush 
    29832987 */ 
    2984 static void vmxR0FlushEPT(PVM pVM, VMX_FLUSH enmFlush, RTGCPHYS GCPhys) 
     2988static void VMXR0FlushEPT(PVM pVM, VMX_FLUSH enmFlush, RTGCPHYS GCPhys) 
    29852989{ 
    29862990    uint64_t descriptor[2]; 
     
    30033007 * @param   GCPtr       Virtual address of the page to flush 
    30043008 */ 
    3005 static void vmxR0FlushVPID(PVM pVM, VMX_FLUSH enmFlush, RTGCPTR GCPtr) 
     3009static void VMXR0FlushVPID(PVM pVM, VMX_FLUSH enmFlush, RTGCPTR GCPtr) 
    30063010{ 
    30073011    uint64_t descriptor[2]; 
     
    30333037    if (   !fFlushPending  
    30343038        && pVM->hwaccm.s.vmx.fVPID) 
    3035         vmxR0FlushVPID(pVM, pVM->hwaccm.s.vmx.enmFlushPage, GCVirt); 
     3039        VMXR0FlushVPID(pVM, pVM->hwaccm.s.vmx.enmFlushPage, GCVirt); 
    30363040#endif /* HWACCM_VTX_WITH_VPID */ 
    30373041 
     
    30563060    /* Skip it if a TLB flush is already pending. */ 
    30573061    if (!fFlushPending) 
    3058         vmxR0FlushEPT(pVM, pVM->hwaccm.s.vmx.enmFlushPage, GCPhys); 
     3062        VMXR0FlushEPT(pVM, pVM->hwaccm.s.vmx.enmFlushPage, GCPhys); 
    30593063 
    30603064    return VINF_SUCCESS; 
     
    30693073 * @param   pCtx        Current CPU context (not updated) 
    30703074 */ 
    3071 static void vmxR0ReportWorldSwitchError(PVM pVM, int rc, PCPUMCTX pCtx) 
     3075static void VMXR0ReportWorldSwitchError(PVM pVM, int rc, PCPUMCTX pCtx) 
    30723076{ 
    30733077    switch (rc) 
  • trunk/src/VBox/VMM/VMMR0/HWVMXR0.h

    r13195 r13197  
    137137#define VMX_WRITE_SELREG(REG, reg) \ 
    138138{                                                                                               \ 
    139         rc  = VMXWriteVMCS32(VMX_VMCS_GUEST_FIELD_##REG,      pCtx->reg);                       \ 
    140         rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_##REG##_LIMIT,    pCtx->reg##Hid.u32Limit);         \ 
    141         rc |= VMXWriteVMCS64(VMX_VMCS_GUEST_##REG##_BASE,     pCtx->reg##Hid.u64Base);          \ 
     139        rc  = VMXWriteVMCS(VMX_VMCS_GUEST_FIELD_##REG,      pCtx->reg);                         \ 
     140        rc |= VMXWriteVMCS(VMX_VMCS_GUEST_##REG##_LIMIT,    pCtx->reg##Hid.u32Limit);           \ 
     141        rc |= VMXWriteVMCS(VMX_VMCS_GUEST_##REG##_BASE,     pCtx->reg##Hid.u64Base);            \ 
    142142        if ((pCtx->eflags.u32 & X86_EFL_VM))                                                    \ 
    143143            val = pCtx->reg##Hid.Attr.u;                                                        \ 
     
    156156            val = 0x10000;  /* Invalid guest state error otherwise. (BIT(16) = Unusable) */     \ 
    157157                                                                                                \ 
    158         rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_##REG##_ACCESS_RIGHTS, val);                        \ 
     158        rc |= VMXWriteVMCS(VMX_VMCS_GUEST_##REG##_ACCESS_RIGHTS, val);                          \ 
    159159} 
    160160 

© 2008 Sun Microsystems, Inc.
ContactPrivacy policy