VirtualBox

Changeset 13195

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

Prefetch the four PDPT entries in PAE mode (EPT only).

Files:

Legend:

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

    r13140 r13195  
    13821382 * @param   u64Val          16, 32 or 64 bits value 
    13831383 */ 
     1384#if HC_ARCH_BITS == 64 
    13841385DECLASM(int) VMXWriteVMCS64(uint32_t idxField, uint64_t u64Val); 
     1386#else 
     1387DECLINLINE(int) VMXWriteVMCS64(uint32_t idxField, uint64_t u64Val) 
     1388{ 
     1389    int rc; 
     1390 
     1391    rc  = VMXWriteVMCS32(idxField,    u64Val); 
     1392    rc |= VMXWriteVMCS32(idxField+1,  u64Val >> 32ULL); 
     1393    return rc; 
     1394} 
     1395#endif 
    13851396 
    13861397/** 
     
    13911402 * @param   u32Val          32 bits value 
    13921403 */ 
    1393 #if RT_INLINE_ASM_EXTERNAL || HC_ARCH_BITS == 64 
     1404#if HC_ARCH_BITS == 64 
     1405DECLINLINE(int) VMXWriteVMCS32(uint32_t idxField, uint32_t u32Val) 
     1406
     1407    return VMXWriteVMCS64(idxField, u32Val); 
     1408
     1409#elif RT_INLINE_ASM_EXTERNAL 
    13941410DECLASM(int) VMXWriteVMCS32(uint32_t idxField, uint32_t u32Val); 
    13951411#else 
     
    14351451} 
    14361452#endif 
    1437  
    1438 #if HC_ARCH_BITS == 64 
    1439 #define VMXWriteVMCS VMXWriteVMCS64 
    1440 #else 
    1441 #define VMXWriteVMCS VMXWriteVMCS32 
    1442 #endif /* HC_ARCH_BITS == 64 */ 
    14431453 
    14441454 
  • trunk/include/VBox/pgm.h

    r13146 r13195  
    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); 
     338VMMDECL(X86PDPE) PGMGstGetPaePDPtr(PVM pVM, unsigned iPdPt); 
     339 
    338340VMMDECL(int)    PGMFlushTLB(PVM pVM, uint64_t cr3, bool fGlobal); 
    339341VMMDECL(int)    PGMUpdateCR3(PVM pVM, uint64_t cr3); 
  • trunk/src/VBox/VMM/VMMAll/PGMAll.cpp

    r13188 r13195  
    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 */ 
     1220VMMDECL(X86PDPE) PGMGstGetPaePDPtr(PVM pVM, unsigned iPdpt) 
     1221{ 
     1222    Assert(iPdpt <= 3); 
     1223    return pVM->pgm.s.CTXSUFF(pGstPaePDPT)->a[iPdpt & 3]; 
     1224} 
     1225 
    12131226 
    12141227/** 
  • trunk/src/VBox/VMM/VMMR0/HWVMXR0.cpp

    r13194 r13195  
    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  
    64  
    65 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); 
     63static void vmxR0PrefetchPAEPdptrs(PVM pVM, PCPUMCTX pCtx); 
     64 
     65 
     66static void vmxR0CheckError(PVM pVM, int rc) 
    6667{ 
    6768    if (rc == VERR_VMX_GENERIC) 
     
    110111    if (VBOX_FAILURE(rc)) 
    111112    { 
    112         VMXR0CheckError(pVM, rc); 
     113        vmxR0CheckError(pVM, rc); 
    113114        ASMSetCR4(ASMGetCR4() & ~X86_CR4_VMXE); 
    114115        return VERR_VMX_VMXON_FAILED; 
     
    278279    val &= pVM->hwaccm.s.vmx.msr.vmx_pin_ctls.n.allowed1; 
    279280 
    280     rc = VMXWriteVMCS(VMX_VMCS_CTRL_PIN_EXEC_CONTROLS, val); 
     281    rc = VMXWriteVMCS32(VMX_VMCS_CTRL_PIN_EXEC_CONTROLS, val); 
    281282    AssertRC(rc); 
    282283 
     
    328329    pVM->hwaccm.s.vmx.proc_ctls = val; 
    329330 
    330     rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, val); 
     331    rc = VMXWriteVMCS32(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, val); 
    331332    AssertRC(rc); 
    332333 
     
    353354        val &= pVM->hwaccm.s.vmx.msr.vmx_proc_ctls2.n.allowed1; 
    354355 
    355         rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS2, val); 
     356        rc = VMXWriteVMCS32(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS2, val); 
    356357        AssertRC(rc); 
    357358    } 
     
    360361     * Set required bits to one and zero according to the MSR capabilities. 
    361362     */ 
    362     rc = VMXWriteVMCS(VMX_VMCS_CTRL_CR3_TARGET_COUNT, 0); 
     363    rc = VMXWriteVMCS32(VMX_VMCS_CTRL_CR3_TARGET_COUNT, 0); 
    363364    AssertRC(rc); 
    364365 
     
    377378    val &= pVM->hwaccm.s.vmx.msr.vmx_exit.n.allowed1; 
    378379    /* Don't acknowledge external interrupts on VM-exit. */ 
    379     rc = VMXWriteVMCS(VMX_VMCS_CTRL_EXIT_CONTROLS, val); 
     380    rc = VMXWriteVMCS32(VMX_VMCS_CTRL_EXIT_CONTROLS, val); 
    380381    AssertRC(rc); 
    381382 
     
    397398        pVM->hwaccm.s.vmx.u32TrapMask &= ~RT_BIT(X86_XCPT_PF);   /* no longer need to intercept #PF. */ 
    398399#endif 
    399     rc = VMXWriteVMCS(VMX_VMCS_CTRL_EXCEPTION_BITMAP, pVM->hwaccm.s.vmx.u32TrapMask); 
     400    rc = VMXWriteVMCS32(VMX_VMCS_CTRL_EXCEPTION_BITMAP, pVM->hwaccm.s.vmx.u32TrapMask); 
    400401    AssertRC(rc); 
    401402 
    402403    /* Don't filter page faults; all of them should cause a switch. */ 
    403     rc  = VMXWriteVMCS(VMX_VMCS_CTRL_PAGEFAULT_ERROR_MASK, 0); 
    404     rc |= VMXWriteVMCS(VMX_VMCS_CTRL_PAGEFAULT_ERROR_MATCH, 0); 
     404    rc  = VMXWriteVMCS32(VMX_VMCS_CTRL_PAGEFAULT_ERROR_MASK, 0); 
     405    rc |= VMXWriteVMCS32(VMX_VMCS_CTRL_PAGEFAULT_ERROR_MATCH, 0); 
    405406    AssertRC(rc); 
    406407 
    407408    /* Init TSC offset to zero. */ 
    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 
     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); 
    424416    AssertRC(rc); 
    425417 
     
    428420    { 
    429421        /* Optional */ 
    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 
     422        rc  = VMXWriteVMCS64(VMX_VMCS_CTRL_MSR_BITMAP_FULL, pVM->hwaccm.s.vmx.pMSRBitmapPhys); 
    434423        AssertRC(rc); 
    435424    } 
    436425 
    437426    /* Clear MSR controls. */ 
    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); 
     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); 
    448432    AssertRC(rc); 
    449433 
     
    452436        Assert(pVM->hwaccm.s.vmx.pMemObjAPIC); 
    453437        /* Optional */ 
    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 
     438        rc  = VMXWriteVMCS32(VMX_VMCS_CTRL_TPR_THRESHOLD, 0); 
     439        rc |= VMXWriteVMCS64(VMX_VMCS_CTRL_VAPIC_PAGEADDR_FULL, pVM->hwaccm.s.vmx.pAPICPhys); 
    459440        AssertRC(rc); 
    460441    } 
    461442 
    462443    /* Set link pointer to -1. Not currently used. */ 
    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 
     444    rc  = VMXWriteVMCS64(VMX_VMCS_GUEST_LINK_PTR_FULL, 0xFFFFFFFFFFFFFFFF); 
    469445    AssertRC(rc); 
    470446 
     
    476452    if (pVM->hwaccm.s.fNestedPaging) 
    477453    { 
    478         pVM->hwaccm.s.vmx.pfnSetupTaggedTLB = VMXR0SetupTLBEPT; 
     454        pVM->hwaccm.s.vmx.pfnSetupTaggedTLB = vmxR0SetupTLBEPT; 
    479455 
    480456        /* Default values for flushing. */ 
     
    496472    if (pVM->hwaccm.s.vmx.fVPID) 
    497473    { 
    498         pVM->hwaccm.s.vmx.pfnSetupTaggedTLB = VMXR0SetupTLBVPID; 
     474        pVM->hwaccm.s.vmx.pfnSetupTaggedTLB = vmxR0SetupTLBVPID; 
    499475 
    500476        /* Default values for flushing. */ 
     
    514490#endif /* HWACCM_VTX_WITH_VPID */ 
    515491    else 
    516         pVM->hwaccm.s.vmx.pfnSetupTaggedTLB = VMXR0SetupTLBDummy; 
     492        pVM->hwaccm.s.vmx.pfnSetupTaggedTLB = vmxR0SetupTLBDummy; 
    517493 
    518494 
    519495vmx_end: 
    520     VMXR0CheckError(pVM, rc); 
     496    vmxR0CheckError(pVM, rc); 
    521497    return rc; 
    522498} 
     
    573549 
    574550    /* Set event injection state. */ 
    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); 
     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); 
    579555 
    580556    AssertRC(rc); 
     
    616592                LogFlow(("Enable irq window exit!\n")); 
    617593                pVM->hwaccm.s.vmx.proc_ctls |= VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_IRQ_WINDOW_EXIT; 
    618                 rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
     594                rc = VMXWriteVMCS32(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
    619595                AssertRC(rc); 
    620596            } 
     
    732708 
    733709        /* Control registers */ 
    734         rc  = VMXWriteVMCS(VMX_VMCS_HOST_CR0,               ASMGetCR0()); 
    735         rc |= VMXWriteVMCS(VMX_VMCS_HOST_CR3,               ASMGetCR3()); 
    736         rc |= VMXWriteVMCS(VMX_VMCS_HOST_CR4,               ASMGetCR4()); 
     710        rc  = VMXWriteVMCS32(VMX_VMCS_HOST_CR0,               ASMGetCR0()); 
     711        rc |= VMXWriteVMCS32(VMX_VMCS_HOST_CR3,               ASMGetCR3()); 
     712        rc |= VMXWriteVMCS32(VMX_VMCS_HOST_CR4,               ASMGetCR4()); 
    737713        AssertRC(rc); 
    738714        Log2(("VMX_VMCS_HOST_CR0 %08x\n", ASMGetCR0())); 
     
    741717 
    742718        /* Selector registers. */ 
    743         rc  = VMXWriteVMCS(VMX_VMCS_HOST_FIELD_CS,          ASMGetCS()); 
     719        rc  = VMXWriteVMCS32(VMX_VMCS_HOST_FIELD_CS,          ASMGetCS()); 
    744720        /* Note: VMX is (again) very picky about the RPL of the selectors here; we'll restore them manually. */ 
    745         rc |= VMXWriteVMCS(VMX_VMCS_HOST_FIELD_DS,          0); 
    746         rc |= VMXWriteVMCS(VMX_VMCS_HOST_FIELD_ES,          0); 
     721        rc |= VMXWriteVMCS32(VMX_VMCS_HOST_FIELD_DS,          0); 
     722        rc |= VMXWriteVMCS32(VMX_VMCS_HOST_FIELD_ES,          0); 
    747723#if HC_ARCH_BITS == 32 
    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()); 
     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()); 
    752728        SelTR = ASMGetTR(); 
    753         rc |= VMXWriteVMCS(VMX_VMCS_HOST_FIELD_TR,          SelTR); 
     729        rc |= VMXWriteVMCS32(VMX_VMCS_HOST_FIELD_TR,          SelTR); 
    754730        AssertRC(rc); 
    755731        Log2(("VMX_VMCS_HOST_FIELD_CS %08x\n", ASMGetCS())); 
     
    763739        /* GDTR & IDTR */ 
    764740        ASMGetGDTR(&gdtr); 
    765         rc  = VMXWriteVMCS(VMX_VMCS_HOST_GDTR_BASE, gdtr.pGdt); 
     741        rc  = VMXWriteVMCS32(VMX_VMCS_HOST_GDTR_BASE, gdtr.pGdt); 
    766742        ASMGetIDTR(&idtr); 
    767         rc |= VMXWriteVMCS(VMX_VMCS_HOST_IDTR_BASE, idtr.pIdt); 
     743        rc |= VMXWriteVMCS32(VMX_VMCS_HOST_IDTR_BASE, idtr.pIdt); 
    768744        AssertRC(rc); 
    769745        Log2(("VMX_VMCS_HOST_GDTR_BASE %VHv\n", gdtr.pGdt)); 
     
    783759        trBase = X86DESC_BASE(*pDesc); 
    784760#endif 
    785         rc = VMXWriteVMCS(VMX_VMCS_HOST_TR_BASE, trBase); 
     761        rc = VMXWriteVMCS32(VMX_VMCS_HOST_TR_BASE, trBase); 
    786762        AssertRC(rc); 
    787763        Log2(("VMX_VMCS_HOST_TR_BASE %VHv\n", trBase)); 
     
    798774        /* Sysenter MSRs. */ 
    799775        /** @todo expensive!! */ 
    800         rc  = VMXWriteVMCS(VMX_VMCS_HOST_SYSENTER_CS,       ASMRdMsr_Low(MSR_IA32_SYSENTER_CS)); 
     776        rc  = VMXWriteVMCS32(VMX_VMCS_HOST_SYSENTER_CS,       ASMRdMsr_Low(MSR_IA32_SYSENTER_CS)); 
    801777        Log2(("VMX_VMCS_HOST_SYSENTER_CS  %08x\n", ASMRdMsr_Low(MSR_IA32_SYSENTER_CS))); 
    802778#if HC_ARCH_BITS == 32 
    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)); 
     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)); 
    805781        Log2(("VMX_VMCS_HOST_SYSENTER_EIP %VHv\n", ASMRdMsr_Low(MSR_IA32_SYSENTER_EIP))); 
    806782        Log2(("VMX_VMCS_HOST_SYSENTER_ESP %VHv\n", ASMRdMsr_Low(MSR_IA32_SYSENTER_ESP))); 
     
    818794} 
    819795 
     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 */ 
     802static 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} 
    820817 
    821818/** 
     
    960957        if (pCtx->ldtr == 0) 
    961958        { 
    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); 
     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); 
    965962            /* Note: vmlaunch will fail with 0 or just 0x02. No idea why. */ 
    966             rc |= VMXWriteVMCS(VMX_VMCS_GUEST_LDTR_ACCESS_RIGHTS, 0x82 /* present, LDT */); 
     963            rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_LDTR_ACCESS_RIGHTS, 0x82 /* present, LDT */); 
    967964        } 
    968965        else 
    969966        { 
    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); 
     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); 
    974971        } 
    975972        AssertRC(rc); 
     
    988985            AssertRC(rc); 
    989986 
    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 */); 
     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 */); 
    993990 
    994991            X86DESCATTR attr; 
     
    1002999#endif /* HWACCM_VMX_EMULATE_REALMODE */ 
    10031000        { 
    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); 
     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); 
    10071004 
    10081005            val = pCtx->trHid.Attr.u; 
     
    10161013 
    10171014        } 
    1018         rc |= VMXWriteVMCS(VMX_VMCS_GUEST_TR_ACCESS_RIGHTS, val); 
     1015        rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_TR_ACCESS_RIGHTS, val); 
    10191016        AssertRC(rc); 
    10201017    } 
     
    10221019    if (pVM->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_GUEST_GDTR) 
    10231020    { 
    1024         rc  = VMXWriteVMCS(VMX_VMCS_GUEST_GDTR_LIMIT,       pCtx->gdtr.cbGdt); 
    1025         rc |= VMXWriteVMCS(VMX_VMCS_GUEST_GDTR_BASE,        pCtx->gdtr.pGdt); 
     1021        rc  = VMXWriteVMCS32(VMX_VMCS_GUEST_GDTR_LIMIT,       pCtx->gdtr.cbGdt); 
     1022        rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_GDTR_BASE,        pCtx->gdtr.pGdt); 
    10261023        AssertRC(rc); 
    10271024    } 
     
    10291026    if (pVM->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_GUEST_IDTR) 
    10301027    { 
    1031         rc  = VMXWriteVMCS(VMX_VMCS_GUEST_IDTR_LIMIT,       pCtx->idtr.cbIdt); 
    1032         rc |= VMXWriteVMCS(VMX_VMCS_GUEST_IDTR_BASE,        pCtx->idtr.pIdt); 
     1028        rc  = VMXWriteVMCS32(VMX_VMCS_GUEST_IDTR_LIMIT,       pCtx->idtr.cbIdt); 
     1029        rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_IDTR_BASE,        pCtx->idtr.pIdt); 
    10331030        AssertRC(rc); 
    10341031    } 
     
    10371034     * Sysenter MSRs (unconditional) 
    10381035     */ 
    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); 
     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); 
    10421039    AssertRC(rc); 
    10431040 
     
    10461043    { 
    10471044        val = pCtx->cr0; 
    1048         rc  = VMXWriteVMCS(VMX_VMCS_CTRL_CR0_READ_SHADOW,   val); 
     1045        rc  = VMXWriteVMCS32(VMX_VMCS_CTRL_CR0_READ_SHADOW,   val); 
    10491046        Log2(("Guest CR0-shadow %08x\n", val)); 
    10501047        if (CPUMIsGuestFPUStateActive(pVM) == false) 
     
    10641061                { 
    10651062                    pVM->hwaccm.s.vmx.u32TrapMask |= RT_BIT(X86_XCPT_MF); 
    1066                     rc = VMXWriteVMCS(VMX_VMCS_CTRL_EXCEPTION_BITMAP, pVM->hwaccm.s.vmx.u32TrapMask); 
     1063                    rc = VMXWriteVMCS32(VMX_VMCS_CTRL_EXCEPTION_BITMAP, pVM->hwaccm.s.vmx.u32TrapMask); 
    10671064                    AssertRC(rc); 
    10681065                    pVM->hwaccm.s.fFPUOldStyleOverride = true; 
     
    10881085                                               | VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_CR3_STORE_EXIT; 
    10891086            } 
    1090             rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
     1087            rc = VMXWriteVMCS32(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
    10911088            AssertRC(rc); 
    10921089        } 
     
    11001097        val &= ~(X86_CR0_CD|X86_CR0_NW); 
    11011098 
    1102         rc |= VMXWriteVMCS(VMX_VMCS_GUEST_CR0,              val); 
     1099        rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_CR0,              val); 
    11031100        Log2(("Guest CR0 %08x\n", val)); 
    11041101        /* CR0 flags owned by the host; if the guests attempts to change them, then 
     
    11161113        pVM->hwaccm.s.vmx.cr0_mask = val; 
    11171114 
    1118         rc |= VMXWriteVMCS(VMX_VMCS_CTRL_CR0_MASK, val); 
     1115        rc |= VMXWriteVMCS32(VMX_VMCS_CTRL_CR0_MASK, val); 
    11191116        Log2(("Guest CR0-mask %08x\n", val)); 
    11201117        AssertRC(rc); 
     
    11231120    { 
    11241121        /* CR4 */ 
    1125         rc  = VMXWriteVMCS(VMX_VMCS_CTRL_CR4_READ_SHADOW,   pCtx->cr4); 
     1122        rc  = VMXWriteVMCS32(VMX_VMCS_CTRL_CR4_READ_SHADOW,   pCtx->cr4); 
    11261123        Log2(("Guest CR4-shadow %08x\n", pCtx->cr4)); 
    11271124        /* Set the required bits in cr4 too (currently X86_CR4_VMXE). */ 
     
    11711168#endif /* HWACCM_VMX_EMULATE_REALMODE */ 
    11721169 
    1173         rc |= VMXWriteVMCS(VMX_VMCS_GUEST_CR4,              val); 
     1170        rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_CR4,              val); 
    11741171        Log2(("Guest CR4 %08x\n", val)); 
    11751172        /* CR4 flags owned by the host; if the guests attempts to change them, then 
     
    11861183        pVM->hwaccm.s.vmx.cr4_mask = val; 
    11871184 
    1188         rc |= VMXWriteVMCS(VMX_VMCS_CTRL_CR4_MASK, val); 
     1185        rc |= VMXWriteVMCS32(VMX_VMCS_CTRL_CR4_MASK, val); 
    11891186        Log2(("Guest CR4-mask %08x\n", val)); 
    11901187        AssertRC(rc); 
     
    12031200                                           | (VMX_EPT_PAGE_WALK_LENGTH_DEFAULT << VMX_EPT_PAGE_WALK_LENGTH_SHIFT); 
    12041201             
    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 
     1202            rc = VMXWriteVMCS64(VMX_VMCS_CTRL_EPTP_FULL, pVM->hwaccm.s.vmx.GCPhysEPTP); 
    12091203            AssertRC(rc); 
    12101204 
     
    12261220                /* Save the real guest CR3 in VMX_VMCS_GUEST_CR3 */ 
    12271221                val = pCtx->cr3; 
     1222 
     1223                /* Prefetch the four PDPT entries in PAE mode. */ 
     1224                vmxR0PrefetchPAEPdptrs(pVM, pCtx); 
    12281225            } 
    12291226        } 
     
    12351232 
    12361233        /* Save our shadow CR3 register. */ 
    1237         rc = VMXWriteVMCS(VMX_VMCS_GUEST_CR3, val); 
     1234        rc = VMXWriteVMCS32(VMX_VMCS_GUEST_CR3, val); 
    12381235        AssertRC(rc); 
    12391236    } 
     
    12501247 
    12511248        /* Resync DR7 */ 
    1252         rc = VMXWriteVMCS(VMX_VMCS_GUEST_DR7, pCtx->dr[7]); 
     1249        rc = VMXWriteVMCS32(VMX_VMCS_GUEST_DR7, pCtx->dr[7]); 
    12531250        AssertRC(rc); 
    12541251 
     
    12621259            /* Disable drx move intercepts. */ 
    12631260            pVM->hwaccm.s.vmx.proc_ctls &= ~VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_MOV_DR_EXIT; 
    1264             rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
     1261            rc = VMXWriteVMCS32(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
    12651262            AssertRC(rc); 
    12661263 
     
    12711268 
    12721269        /* IA32_DEBUGCTL MSR. */ 
    1273         rc  = VMXWriteVMCS(VMX_VMCS_GUEST_DEBUGCTL_FULL,    0); 
    1274         rc |= VMXWriteVMCS(VMX_VMCS_GUEST_DEBUGCTL_HIGH,    0); 
     1270        rc  = VMXWriteVMCS32(VMX_VMCS_GUEST_DEBUGCTL_FULL,    0); 
     1271        rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_DEBUGCTL_HIGH,    0); 
    12751272        AssertRC(rc); 
    12761273 
    12771274        /** @todo do we really ever need this? */ 
    1278         rc |= VMXWriteVMCS(VMX_VMCS_GUEST_DEBUG_EXCEPTIONS,         0); 
     1275        rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_DEBUG_EXCEPTIONS,         0); 
    12791276        AssertRC(rc); 
    12801277    } 
    12811278 
    12821279    /* EIP, ESP and EFLAGS */ 
    1283     rc  = VMXWriteVMCS(VMX_VMCS_GUEST_RIP,              pCtx->rip); 
    1284     rc |= VMXWriteVMCS(VMX_VMCS_GUEST_RSP,              pCtx->rsp); 
     1280    rc  = VMXWriteVMCS32(VMX_VMCS_GUEST_RIP,              pCtx->rip); 
     1281    rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_RSP,              pCtx->rsp); 
    12851282    AssertRC(rc); 
    12861283 
     
    12981295    } 
    12991296#endif /* HWACCM_VMX_EMULATE_REALMODE */ 
    1300     rc   = VMXWriteVMCS(VMX_VMCS_GUEST_RFLAGS,           eflags.u32); 
     1297    rc   = VMXWriteVMCS32(VMX_VMCS_GUEST_RFLAGS,           eflags.u32); 
    13011298    AssertRC(rc); 
    13021299 
     
    13071304    { 
    13081305        /* Note: VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_RDTSC_EXIT takes precedence over TSC_OFFSET */ 
    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 
     1306        rc  = VMXWriteVMCS64(VMX_VMCS_CTRL_TSC_OFFSET_FULL, u64TSCOffset); 
    13131307        AssertRC(rc); 
    13141308 
    13151309        pVM->hwaccm.s.vmx.proc_ctls &= ~VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_RDTSC_EXIT; 
    1316         rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
     1310        rc = VMXWriteVMCS32(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
    13171311        AssertRC(rc); 
    13181312        STAM_COUNTER_INC(&pVM->hwaccm.s.StatTSCOffset); 
     
    13211315    { 
    13221316        pVM->hwaccm.s.vmx.proc_ctls |= VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_RDTSC_EXIT; 
    1323         rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
     1317        rc = VMXWriteVMCS32(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
    13241318        AssertRC(rc); 
    13251319        STAM_COUNTER_INC(&pVM->hwaccm.s.StatTSCIntercept); 
     
    13401334    /* Mask away the bits that the CPU doesn't support */ 
    13411335    val &= pVM->hwaccm.s.vmx.msr.vmx_entry.n.allowed1; 
    1342     rc = VMXWriteVMCS(VMX_VMCS_CTRL_ENTRY_CONTROLS, val); 
     1336    rc = VMXWriteVMCS32(VMX_VMCS_CTRL_ENTRY_CONTROLS, val); 
    13431337    AssertRC(rc); 
    13441338 
     
    13521346#endif 
    13531347        /* Unconditionally update these as wrmsr might have changed them. */ 
    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); 
     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); 
    13571351        AssertRC(rc); 
    13581352    } 
     
    13691363        pVM->hwaccm.s.vmx.u32TrapMask &= ~RT_BIT(X86_XCPT_DB); 
    13701364 
    1371     rc = VMXWriteVMCS(VMX_VMCS_CTRL_EXCEPTION_BITMAP, pVM->hwaccm.s.vmx.u32TrapMask); 
     1365    rc = VMXWriteVMCS32(VMX_VMCS_CTRL_EXCEPTION_BITMAP, pVM->hwaccm.s.vmx.u32TrapMask); 
    13721366#endif 
    13731367 
     
    13821376        pVM->hwaccm.s.vmx.u32TrapMask &= ~RT_BIT(X86_XCPT_GP); 
    13831377# endif /* HWACCM_VMX_EMULATE_REALMODE */ 
    1384     rc = VMXWriteVMCS(VMX_VMCS_CTRL_EXCEPTION_BITMAP, pVM->hwaccm.s.vmx.u32TrapMask); 
     1378    rc = VMXWriteVMCS32(VMX_VMCS_CTRL_EXCEPTION_BITMAP, pVM->hwaccm.s.vmx.u32TrapMask); 
    13851379    AssertRC(rc); 
    13861380#endif 
     
    14541448            PGMUpdateCR3(pVM, val); 
    14551449        } 
     1450        /* Prefetch the four PDPT entries in PAE mode. */ 
     1451        vmxR0PrefetchPAEPdptrs(pVM, pCtx); 
    14561452    } 
    14571453 
     
    15161512 * @param   pVM         The VM to operate on. 
    15171513 */ 
    1518 static void VMXR0SetupTLBDummy(PVM pVM) 
     1514static void vmxR0SetupTLBDummy(PVM pVM) 
    15191515{ 
    15201516    return; 
     
    15271523 * @param   pVM         The VM to operate on. 
    15281524 */ 
    1529 static void VMXR0SetupTLBEPT(PVM pVM) 
     1525static void vmxR0SetupTLBEPT(PVM pVM) 
    15301526{ 
    15311527    PHWACCM_CPUINFO pCpu; 
     
    15521548 
    15531549    if (pVM->hwaccm.s.fForceTLBFlush) 
    1554         VMXR0FlushEPT(pVM, pVM->hwaccm.s.vmx.enmFlushContext, 0); 
     1550        vmxR0FlushEPT(pVM, pVM->hwaccm.s.vmx.enmFlushContext, 0); 
    15551551 
    15561552#ifdef VBOX_WITH_STATISTICS 
     
    15691565 * @param   pVM         The VM to operate on. 
    15701566 */ 
    1571 static void VMXR0SetupTLBVPID(PVM pVM) 
     1567static void vmxR0SetupTLBVPID(PVM pVM) 
    15721568{ 
    15731569    PHWACCM_CPUINFO pCpu; 
     
    16221618    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)); 
    16231619 
    1624     int rc  = VMXWriteVMCS(VMX_VMCS_GUEST_FIELD_VPID, pVM->hwaccm.s.uCurrentASID); 
     1620    int rc  = VMXWriteVMCS32(VMX_VMCS_GUEST_FIELD_VPID, pVM->hwaccm.s.uCurrentASID); 
    16251621    AssertRC(rc); 
    16261622 
    16271623    if (pVM->hwaccm.s.fForceTLBFlush) 
    1628         VMXR0FlushVPID(pVM, pVM->hwaccm.s.vmx.enmFlushContext, 0); 
     1624        vmxr0lushVPID(pVM, pVM->hwaccm.s.vmx.enmFlushContext, 0); 
    16291625 
    16301626#ifdef VBOX_WITH_STATISTICS 
     
    17411737            VM_FF_CLEAR(pVM, VM_FF_INHIBIT_INTERRUPTS); 
    17421738            /* Irq inhibition is no longer active; clear the corresponding VMX state. */ 
    1743             rc = VMXWriteVMCS(VMX_VMCS_GUEST_INTERRUPTIBILITY_STATE,   0); 
     1739            rc = VMXWriteVMCS32(VMX_VMCS_GUEST_INTERRUPTIBILITY_STATE,   0); 
    17441740            AssertRC(rc); 
    17451741        } 
     
    17481744    { 
    17491745        /* Irq inhibition is no longer active; clear the corresponding VMX state. */ 
    1750         rc = VMXWriteVMCS(VMX_VMCS_GUEST_INTERRUPTIBILITY_STATE,   0); 
     1746        rc = VMXWriteVMCS32(VMX_VMCS_GUEST_INTERRUPTIBILITY_STATE,   0); 
    17511747        AssertRC(rc); 
    17521748    } 
     
    18041800         *   -> We don't need to be explicitely notified. There are enough world switches for detecting pending interrupts. 
    18051801         */ 
    1806         rc  = VMXWriteVMCS(VMX_VMCS_CTRL_TPR_THRESHOLD, (fPending) ? u8TPR : 0); 
     1802        rc  = VMXWriteVMCS32(VMX_VMCS_CTRL_TPR_THRESHOLD, (fPending) ? u8TPR : 0); 
    18071803        AssertRC(rc); 
    18081804 
     
    18591855    /* Non-register state Guest Context */ 
    18601856    /** @todo change me according to cpu state */ 
    1861     rc = VMXWriteVMCS(VMX_VMCS_GUEST_ACTIVITY_STATE,           VMX_CMS_GUEST_ACTIVITY_ACTIVE); 
     1857    rc = VMXWriteVMCS32(VMX_VMCS_GUEST_ACTIVITY_STATE,           VMX_CMS_GUEST_ACTIVITY_ACTIVE); 
    18621858    AssertRC(rc); 
    18631859 
     
    19001896    if (rc != VINF_SUCCESS) 
    19011897    { 
    1902         VMXR0ReportWorldSwitchError(pVM, rc, pCtx); 
     1898        vmxR0ReportWorldSwitchError(pVM, rc, pCtx); 
    19031899        goto end; 
    19041900    } 
     
    21792175 
    21802176                    /* Resync DR7 */ 
    2181                     rc = VMXWriteVMCS(VMX_VMCS_GUEST_DR7, pCtx->dr[7]); 
     2177                    rc = VMXWriteVMCS32(VMX_VMCS_GUEST_DR7, pCtx->dr[7]); 
    21822178                    AssertRC(rc); 
    21832179 
     
    23402336        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)); 
    23412337        pVM->hwaccm.s.vmx.proc_ctls &= ~VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_IRQ_WINDOW_EXIT; 
    2342         rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
     2338        rc = VMXWriteVMCS32(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
    23432339        AssertRC(rc); 
    23442340        STAM_COUNTER_INC(&pVM->hwaccm.s.StatExitIrqWindow); 
     
    25202516            /* Disable drx move intercepts. */ 
    25212517            pVM->hwaccm.s.vmx.proc_ctls &= ~VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_MOV_DR_EXIT; 
    2522             rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
     2518            rc = VMXWriteVMCS32(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
    25232519            AssertRC(rc); 
    25242520 
     
    26882684 
    26892685                            /* Resync DR7 */ 
    2690                             rc = VMXWriteVMCS(VMX_VMCS_GUEST_DR7, pCtx->dr[7]); 
     2686                            rc = VMXWriteVMCS32(VMX_VMCS_GUEST_DR7, pCtx->dr[7]); 
    26912687                            AssertRC(rc); 
    26922688 
     
    29622958        /* Enable drx move intercepts again. */ 
    29632959        pVM->hwaccm.s.vmx.proc_ctls |= VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_MOV_DR_EXIT; 
    2964         int rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
     2960        int rc = VMXWriteVMCS32(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVM->hwaccm.s.vmx.proc_ctls); 
    29652961        AssertRC(rc); 
    29662962 
     
    29862982 * @param   GCPhys      Physical address of the page to flush 
    29872983 */ 
    2988 static void VMXR0FlushEPT(PVM pVM, VMX_FLUSH enmFlush, RTGCPHYS GCPhys) 
     2984static void vmxR0FlushEPT(PVM pVM, VMX_FLUSH enmFlush, RTGCPHYS GCPhys) 
    29892985{ 
    29902986    uint64_t descriptor[2]; 
     
    30073003 * @param   GCPtr       Virtual address of the page to flush 
    30083004 */ 
    3009 static void VMXR0FlushVPID(PVM pVM, VMX_FLUSH enmFlush, RTGCPTR GCPtr) 
     3005static void vmxR0FlushVPID(PVM pVM, VMX_FLUSH enmFlush, RTGCPTR GCPtr) 
    30103006{ 
    30113007    uint64_t descriptor[2]; 
     
    30373033    if (   !fFlushPending  
    30383034        && pVM->hwaccm.s.vmx.fVPID) 
    3039         VMXR0FlushVPID(pVM, pVM->hwaccm.s.vmx.enmFlushPage, GCVirt); 
     3035        vmxR0FlushVPID(pVM, pVM->hwaccm.s.vmx.enmFlushPage, GCVirt); 
    30403036#endif /* HWACCM_VTX_WITH_VPID */ 
    30413037 
     
    30603056    /* Skip it if a TLB flush is already pending. */ 
    30613057    if (!fFlushPending) 
    3062         VMXR0FlushEPT(pVM, pVM->hwaccm.s.vmx.enmFlushPage, GCPhys); 
     3058        vmxR0FlushEPT(pVM, pVM->hwaccm.s.vmx.enmFlushPage, GCPhys); 
    30633059 
    30643060    return VINF_SUCCESS; 
     
    30733069 * @param   pCtx        Current CPU context (not updated) 
    30743070 */ 
    3075 static void VMXR0ReportWorldSwitchError(PVM pVM, int rc, PCPUMCTX pCtx) 
     3071static void vmxR0ReportWorldSwitchError(PVM pVM, int rc, PCPUMCTX pCtx) 
    30763072{ 
    30773073    switch (rc) 
  • trunk/src/VBox/VMM/VMMR0/HWVMXR0.h

    r12989 r13195  
    137137#define VMX_WRITE_SELREG(REG, reg) \ 
    138138{                                                                                               \ 
    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);            \ 
     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);          \ 
    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 |= VMXWriteVMCS(VMX_VMCS_GUEST_##REG##_ACCESS_RIGHTS, val);                          \ 
     158        rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_##REG##_ACCESS_RIGHTS, val);                        \ 
    159159} 
    160160 

© 2008 Sun Microsystems, Inc.
ContactPrivacy policy