Changeset 13195
- Timestamp:
- 10/13/08 10:45:56 (3 months ago)
- Files:
-
- trunk/include/VBox/hwacc_vmx.h (modified) (3 diffs)
- trunk/include/VBox/pgm.h (modified) (1 diff)
- trunk/src/VBox/VMM/VMMAll/PGMAll.cpp (modified) (1 diff)
- trunk/src/VBox/VMM/VMMR0/HWVMXR0.cpp (modified) (70 diffs)
- trunk/src/VBox/VMM/VMMR0/HWVMXR0.h (modified) (2 diffs)
Legend:
- Unmodified
- Added
- Removed
- Modified
- Copied
- Moved
trunk/include/VBox/hwacc_vmx.h
r13140 r13195 1382 1382 * @param u64Val 16, 32 or 64 bits value 1383 1383 */ 1384 #if HC_ARCH_BITS == 64 1384 1385 DECLASM(int) VMXWriteVMCS64(uint32_t idxField, uint64_t u64Val); 1386 #else 1387 DECLINLINE(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 1385 1396 1386 1397 /** … … 1391 1402 * @param u32Val 32 bits value 1392 1403 */ 1393 #if RT_INLINE_ASM_EXTERNAL || HC_ARCH_BITS == 64 1404 #if HC_ARCH_BITS == 64 1405 DECLINLINE(int) VMXWriteVMCS32(uint32_t idxField, uint32_t u32Val) 1406 { 1407 return VMXWriteVMCS64(idxField, u32Val); 1408 } 1409 #elif RT_INLINE_ASM_EXTERNAL 1394 1410 DECLASM(int) VMXWriteVMCS32(uint32_t idxField, uint32_t u32Val); 1395 1411 #else … … 1435 1451 } 1436 1452 #endif 1437 1438 #if HC_ARCH_BITS == 641439 #define VMXWriteVMCS VMXWriteVMCS641440 #else1441 #define VMXWriteVMCS VMXWriteVMCS321442 #endif /* HC_ARCH_BITS == 64 */1443 1453 1444 1454 trunk/include/VBox/pgm.h
r13146 r13195 336 336 VMMDECL(int) PGMGstSetPage(PVM pVM, RTGCPTR GCPtr, size_t cb, uint64_t fFlags); 337 337 VMMDECL(int) PGMGstModifyPage(PVM pVM, RTGCPTR GCPtr, size_t cb, uint64_t fFlags, uint64_t fMask); 338 VMMDECL(X86PDPE) PGMGstGetPaePDPtr(PVM pVM, unsigned iPdPt); 339 338 340 VMMDECL(int) PGMFlushTLB(PVM pVM, uint64_t cr3, bool fGlobal); 339 341 VMMDECL(int) PGMUpdateCR3(PVM pVM, uint64_t cr3); trunk/src/VBox/VMM/VMMAll/PGMAll.cpp
r13188 r13195 1211 1211 } 1212 1212 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 1213 1226 1214 1227 /** trunk/src/VBox/VMM/VMMR0/HWVMXR0.cpp
r13194 r13195 52 52 *******************************************************************************/ 53 53 #ifdef VBOX_STRICT 54 static void VMXR0ReportWorldSwitchError(PVM pVM, int rc, PCPUMCTX pCtx);54 static void vmxR0ReportWorldSwitchError(PVM pVM, int rc, PCPUMCTX pCtx); 55 55 #else 56 56 #define VMXR0ReportWorldSwitchError(a, b, c) do { } while (0); 57 57 #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) 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) 66 67 { 67 68 if (rc == VERR_VMX_GENERIC) … … 110 111 if (VBOX_FAILURE(rc)) 111 112 { 112 VMXR0CheckError(pVM, rc);113 vmxR0CheckError(pVM, rc); 113 114 ASMSetCR4(ASMGetCR4() & ~X86_CR4_VMXE); 114 115 return VERR_VMX_VMXON_FAILED; … … 278 279 val &= pVM->hwaccm.s.vmx.msr.vmx_pin_ctls.n.allowed1; 279 280 280 rc = VMXWriteVMCS (VMX_VMCS_CTRL_PIN_EXEC_CONTROLS, val);281 rc = VMXWriteVMCS32(VMX_VMCS_CTRL_PIN_EXEC_CONTROLS, val); 281 282 AssertRC(rc); 282 283 … … 328 329 pVM->hwaccm.s.vmx.proc_ctls = val; 329 330 330 rc = VMXWriteVMCS (VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, val);331 rc = VMXWriteVMCS32(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, val); 331 332 AssertRC(rc); 332 333 … … 353 354 val &= pVM->hwaccm.s.vmx.msr.vmx_proc_ctls2.n.allowed1; 354 355 355 rc = VMXWriteVMCS (VMX_VMCS_CTRL_PROC_EXEC_CONTROLS2, val);356 rc = VMXWriteVMCS32(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS2, val); 356 357 AssertRC(rc); 357 358 } … … 360 361 * Set required bits to one and zero according to the MSR capabilities. 361 362 */ 362 rc = VMXWriteVMCS (VMX_VMCS_CTRL_CR3_TARGET_COUNT, 0);363 rc = VMXWriteVMCS32(VMX_VMCS_CTRL_CR3_TARGET_COUNT, 0); 363 364 AssertRC(rc); 364 365 … … 377 378 val &= pVM->hwaccm.s.vmx.msr.vmx_exit.n.allowed1; 378 379 /* 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); 380 381 AssertRC(rc); 381 382 … … 397 398 pVM->hwaccm.s.vmx.u32TrapMask &= ~RT_BIT(X86_XCPT_PF); /* no longer need to intercept #PF. */ 398 399 #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); 400 401 AssertRC(rc); 401 402 402 403 /* 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); 405 406 AssertRC(rc); 406 407 407 408 /* 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); 424 416 AssertRC(rc); 425 417 … … 428 420 { 429 421 /* 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); 434 423 AssertRC(rc); 435 424 } 436 425 437 426 /* 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); 448 432 AssertRC(rc); 449 433 … … 452 436 Assert(pVM->hwaccm.s.vmx.pMemObjAPIC); 453 437 /* 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); 459 440 AssertRC(rc); 460 441 } 461 442 462 443 /* 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); 469 445 AssertRC(rc); 470 446 … … 476 452 if (pVM->hwaccm.s.fNestedPaging) 477 453 { 478 pVM->hwaccm.s.vmx.pfnSetupTaggedTLB = VMXR0SetupTLBEPT;454 pVM->hwaccm.s.vmx.pfnSetupTaggedTLB = vmxR0SetupTLBEPT; 479 455 480 456 /* Default values for flushing. */ … … 496 472 if (pVM->hwaccm.s.vmx.fVPID) 497 473 { 498 pVM->hwaccm.s.vmx.pfnSetupTaggedTLB = VMXR0SetupTLBVPID;474 pVM->hwaccm.s.vmx.pfnSetupTaggedTLB = vmxR0SetupTLBVPID; 499 475 500 476 /* Default values for flushing. */ … … 514 490 #endif /* HWACCM_VTX_WITH_VPID */ 515 491 else 516 pVM->hwaccm.s.vmx.pfnSetupTaggedTLB = VMXR0SetupTLBDummy;492 pVM->hwaccm.s.vmx.pfnSetupTaggedTLB = vmxR0SetupTLBDummy; 517 493 518 494 519 495 vmx_end: 520 VMXR0CheckError(pVM, rc);496 vmxR0CheckError(pVM, rc); 521 497 return rc; 522 498 } … … 573 549 574 550 /* 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); 579 555 580 556 AssertRC(rc); … … 616 592 LogFlow(("Enable irq window exit!\n")); 617 593 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); 619 595 AssertRC(rc); 620 596 } … … 732 708 733 709 /* 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()); 737 713 AssertRC(rc); 738 714 Log2(("VMX_VMCS_HOST_CR0 %08x\n", ASMGetCR0())); … … 741 717 742 718 /* Selector registers. */ 743 rc = VMXWriteVMCS (VMX_VMCS_HOST_FIELD_CS, ASMGetCS());719 rc = VMXWriteVMCS32(VMX_VMCS_HOST_FIELD_CS, ASMGetCS()); 744 720 /* 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); 747 723 #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()); 752 728 SelTR = ASMGetTR(); 753 rc |= VMXWriteVMCS (VMX_VMCS_HOST_FIELD_TR, SelTR);729 rc |= VMXWriteVMCS32(VMX_VMCS_HOST_FIELD_TR, SelTR); 754 730 AssertRC(rc); 755 731 Log2(("VMX_VMCS_HOST_FIELD_CS %08x\n", ASMGetCS())); … … 763 739 /* GDTR & IDTR */ 764 740 ASMGetGDTR(&gdtr); 765 rc = VMXWriteVMCS (VMX_VMCS_HOST_GDTR_BASE, gdtr.pGdt);741 rc = VMXWriteVMCS32(VMX_VMCS_HOST_GDTR_BASE, gdtr.pGdt); 766 742 ASMGetIDTR(&idtr); 767 rc |= VMXWriteVMCS (VMX_VMCS_HOST_IDTR_BASE, idtr.pIdt);743 rc |= VMXWriteVMCS32(VMX_VMCS_HOST_IDTR_BASE, idtr.pIdt); 768 744 AssertRC(rc); 769 745 Log2(("VMX_VMCS_HOST_GDTR_BASE %VHv\n", gdtr.pGdt)); … … 783 759 trBase = X86DESC_BASE(*pDesc); 784 760 #endif 785 rc = VMXWriteVMCS (VMX_VMCS_HOST_TR_BASE, trBase);761 rc = VMXWriteVMCS32(VMX_VMCS_HOST_TR_BASE, trBase); 786 762 AssertRC(rc); 787 763 Log2(("VMX_VMCS_HOST_TR_BASE %VHv\n", trBase)); … … 798 774 /* Sysenter MSRs. */ 799 775 /** @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)); 801 777 Log2(("VMX_VMCS_HOST_SYSENTER_CS %08x\n", ASMRdMsr_Low(MSR_IA32_SYSENTER_CS))); 802 778 #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)); 805 781 Log2(("VMX_VMCS_HOST_SYSENTER_EIP %VHv\n", ASMRdMsr_Low(MSR_IA32_SYSENTER_EIP))); 806 782 Log2(("VMX_VMCS_HOST_SYSENTER_ESP %VHv\n", ASMRdMsr_Low(MSR_IA32_SYSENTER_ESP))); … … 818 794 } 819 795 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 } 820 817 821 818 /** … … 960 957 if (pCtx->ldtr == 0) 961 958 { 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); 965 962 /* 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 */); 967 964 } 968 965 else 969 966 { 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); 974 971 } 975 972 AssertRC(rc); … … 988 985 AssertRC(rc); 989 986 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 */); 993 990 994 991 X86DESCATTR attr; … … 1002 999 #endif /* HWACCM_VMX_EMULATE_REALMODE */ 1003 1000 { 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); 1007 1004 1008 1005 val = pCtx->trHid.Attr.u; … … 1016 1013 1017 1014 } 1018 rc |= VMXWriteVMCS (VMX_VMCS_GUEST_TR_ACCESS_RIGHTS, val);1015 rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_TR_ACCESS_RIGHTS, val); 1019 1016 AssertRC(rc); 1020 1017 } … … 1022 1019 if (pVM->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_GUEST_GDTR) 1023 1020 { 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); 1026 1023 AssertRC(rc); 1027 1024 } … … 1029 1026 if (pVM->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_GUEST_IDTR) 1030 1027 { 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); 1033 1030 AssertRC(rc); 1034 1031 } … … 1037 1034 * Sysenter MSRs (unconditional) 1038 1035 */ 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); 1042 1039 AssertRC(rc); 1043 1040 … … 1046 1043 { 1047 1044 val = pCtx->cr0; 1048 rc = VMXWriteVMCS (VMX_VMCS_CTRL_CR0_READ_SHADOW, val);1045 rc = VMXWriteVMCS32(VMX_VMCS_CTRL_CR0_READ_SHADOW, val); 1049 1046 Log2(("Guest CR0-shadow %08x\n", val)); 1050 1047 if (CPUMIsGuestFPUStateActive(pVM) == false) … … 1064 1061 { 1065 1062 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); 1067 1064 AssertRC(rc); 1068 1065 pVM->hwaccm.s.fFPUOldStyleOverride = true; … … 1088 1085 | VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_CR3_STORE_EXIT; 1089 1086 } 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); 1091 1088 AssertRC(rc); 1092 1089 } … … 1100 1097 val &= ~(X86_CR0_CD|X86_CR0_NW); 1101 1098 1102 rc |= VMXWriteVMCS (VMX_VMCS_GUEST_CR0, val);1099 rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_CR0, val); 1103 1100 Log2(("Guest CR0 %08x\n", val)); 1104 1101 /* CR0 flags owned by the host; if the guests attempts to change them, then … … 1116 1113 pVM->hwaccm.s.vmx.cr0_mask = val; 1117 1114 1118 rc |= VMXWriteVMCS (VMX_VMCS_CTRL_CR0_MASK, val);1115 rc |= VMXWriteVMCS32(VMX_VMCS_CTRL_CR0_MASK, val); 1119 1116 Log2(("Guest CR0-mask %08x\n", val)); 1120 1117 AssertRC(rc); … … 1123 1120 { 1124 1121 /* CR4 */ 1125 rc = VMXWriteVMCS (VMX_VMCS_CTRL_CR4_READ_SHADOW, pCtx->cr4);1122 rc = VMXWriteVMCS32(VMX_VMCS_CTRL_CR4_READ_SHADOW, pCtx->cr4); 1126 1123 Log2(("Guest CR4-shadow %08x\n", pCtx->cr4)); 1127 1124 /* Set the required bits in cr4 too (currently X86_CR4_VMXE). */ … … 1171 1168 #endif /* HWACCM_VMX_EMULATE_REALMODE */ 1172 1169 1173 rc |= VMXWriteVMCS (VMX_VMCS_GUEST_CR4, val);1170 rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_CR4, val); 1174 1171 Log2(("Guest CR4 %08x\n", val)); 1175 1172 /* CR4 flags owned by the host; if the guests attempts to change them, then … … 1186 1183 pVM->hwaccm.s.vmx.cr4_mask = val; 1187 1184 1188 rc |= VMXWriteVMCS (VMX_VMCS_CTRL_CR4_MASK, val);1185 rc |= VMXWriteVMCS32(VMX_VMCS_CTRL_CR4_MASK, val); 1189 1186 Log2(("Guest CR4-mask %08x\n", val)); 1190 1187 AssertRC(rc); … … 1203 1200 | (VMX_EPT_PAGE_WALK_LENGTH_DEFAULT << VMX_EPT_PAGE_WALK_LENGTH_SHIFT); 1204 1201 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); 1209 1203 AssertRC(rc); 1210 1204 … … 1226 1220 /* Save the real guest CR3 in VMX_VMCS_GUEST_CR3 */ 1227 1221 val = pCtx->cr3; 1222 1223 /* Prefetch the four PDPT entries in PAE mode. */ 1224 vmxR0PrefetchPAEPdptrs(pVM, pCtx); 1228 1225 } 1229 1226 } … … 1235 1232 1236 1233 /* Save our shadow CR3 register. */ 1237 rc = VMXWriteVMCS (VMX_VMCS_GUEST_CR3, val);1234 rc = VMXWriteVMCS32(VMX_VMCS_GUEST_CR3, val); 1238 1235 AssertRC(rc); 1239 1236 } … … 1250 1247 1251 1248 /* Resync DR7 */ 1252 rc = VMXWriteVMCS (VMX_VMCS_GUEST_DR7, pCtx->dr[7]);1249 rc = VMXWriteVMCS32(VMX_VMCS_GUEST_DR7, pCtx->dr[7]); 1253 1250 AssertRC(rc); 1254 1251 … … 1262 1259 /* Disable drx move intercepts. */ 1263 1260 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); 1265 1262 AssertRC(rc); 1266 1263 … … 1271 1268 1272 1269 /* 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); 1275 1272 AssertRC(rc); 1276 1273 1277 1274 /** @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); 1279 1276 AssertRC(rc); 1280 1277 } 1281 1278 1282 1279 /* 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); 1285 1282 AssertRC(rc); 1286 1283 … … 1298 1295 } 1299 1296 #endif /* HWACCM_VMX_EMULATE_REALMODE */ 1300 rc = VMXWriteVMCS (VMX_VMCS_GUEST_RFLAGS, eflags.u32);1297 rc = VMXWriteVMCS32(VMX_VMCS_GUEST_RFLAGS, eflags.u32); 1301 1298 AssertRC(rc); 1302 1299 … … 1307 1304 { 1308 1305 /* 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); 1313 1307 AssertRC(rc); 1314 1308 1315 1309 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); 1317 1311 AssertRC(rc); 1318 1312 STAM_COUNTER_INC(&pVM->hwaccm.s.StatTSCOffset); … … 1321 1315 { 1322 1316 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); 1324 1318 AssertRC(rc); 1325 1319 STAM_COUNTER_INC(&pVM->hwaccm.s.StatTSCIntercept); … … 1340 1334 /* Mask away the bits that the CPU doesn't support */ 1341 1335 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); 1343 1337 AssertRC(rc); 1344 1338 … … 1352 1346 #endif 1353 1347 /* 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); 1357 1351 AssertRC(rc); 1358 1352 } … … 1369 1363 pVM->hwaccm.s.vmx.u32TrapMask &= ~RT_BIT(X86_XCPT_DB); 1370 1364 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); 1372 1366 #endif 1373 1367 … … 1382 1376 pVM->hwaccm.s.vmx.u32TrapMask &= ~RT_BIT(X86_XCPT_GP); 1383 1377 # 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); 1385 1379 AssertRC(rc); 1386 1380 #endif … … 1454 1448 PGMUpdateCR3(pVM, val); 1455 1449 } 1450 /* Prefetch the four PDPT entries in PAE mode. */ 1451 vmxR0PrefetchPAEPdptrs(pVM, pCtx); 1456 1452 } 1457 1453 … … 1516 1512 * @param pVM The VM to operate on. 1517 1513 */ 1518 static void VMXR0SetupTLBDummy(PVM pVM)1514 static void vmxR0SetupTLBDummy(PVM pVM) 1519 1515 { 1520 1516 return; … … 1527 1523 * @param pVM The VM to operate on. 1528 1524 */ 1529 static void VMXR0SetupTLBEPT(PVM pVM)1525 static void vmxR0SetupTLBEPT(PVM pVM) 1530 1526 { 1531 1527 PHWACCM_CPUINFO pCpu; … … 1552 1548 1553 1549 if (pVM->hwaccm.s.fForceTLBFlush) 1554 VMXR0FlushEPT(pVM, pVM->hwaccm.s.vmx.enmFlushContext, 0);1550 vmxR0FlushEPT(pVM, pVM->hwaccm.s.vmx.enmFlushContext, 0); 1555 1551 1556 1552 #ifdef VBOX_WITH_STATISTICS … … 1569 1565 * @param pVM The VM to operate on. 1570 1566 */ 1571 static void VMXR0SetupTLBVPID(PVM pVM)1567 static void vmxR0SetupTLBVPID(PVM pVM) 1572 1568 { 1573 1569 PHWACCM_CPUINFO pCpu; … … 1622 1618 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)); 1623 1619 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); 1625 1621 AssertRC(rc); 1626 1622 1627 1623 if (pVM->hwaccm.s.fForceTLBFlush) 1628 VMXR0FlushVPID(pVM, pVM->hwaccm.s.vmx.enmFlushContext, 0);1624 vmxr0lushVPID(pVM, pVM->hwaccm.s.vmx.enmFlushContext, 0); 1629 1625 1630 1626 #ifdef VBOX_WITH_STATISTICS … … 1741 1737 VM_FF_CLEAR(pVM, VM_FF_INHIBIT_INTERRUPTS); 1742 1738 /* 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); 1744 1740 AssertRC(rc); 1745 1741 } … … 1748 1744 { 1749 1745 /* 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); 1751 1747 AssertRC(rc); 1752 1748 } … … 1804 1800 * -> We don't need to be explicitely notified. There are enough world switches for detecting pending interrupts. 1805 1801 */ 1806 rc = VMXWriteVMCS (VMX_VMCS_CTRL_TPR_THRESHOLD, (fPending) ? u8TPR : 0);1802 rc = VMXWriteVMCS32(VMX_VMCS_CTRL_TPR_THRESHOLD, (fPending) ? u8TPR : 0); 1807 1803 AssertRC(rc); 1808 1804 … … 1859 1855 /* Non-register state Guest Context */ 1860 1856 /** @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); 1862 1858 AssertRC(rc); 1863 1859 … … 1900 1896 if (rc != VINF_SUCCESS) 1901 1897 { 1902 VMXR0ReportWorldSwitchError(pVM, rc, pCtx);1898 vmxR0ReportWorldSwitchError(pVM, rc, pCtx); 1903 1899 goto end; 1904 1900 } … … 2179 2175 2180 2176 /* Resync DR7 */ 2181 rc = VMXWriteVMCS (VMX_VMCS_GUEST_DR7, pCtx->dr[7]);2177 rc = VMXWriteVMCS32(VMX_VMCS_GUEST_DR7, pCtx->dr[7]); 2182 2178 AssertRC(rc); 2183 2179 … … 2340 2336 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)); 2341 2337 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); 2343 2339 AssertRC(rc); 2344 2340 STAM_COUNTER_INC(&pVM->hwaccm.s.StatExitIrqWindow); … … 2520 2516 /* Disable drx move intercepts. */ 2521 2517 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); 2523 2519 AssertRC(rc); 2524 2520 … … 2688 2684 2689 2685 /* Resync DR7 */ 2690 rc = VMXWriteVMCS (VMX_VMCS_GUEST_DR7, pCtx->dr[7]);2686 rc = VMXWriteVMCS32(VMX_VMCS_GUEST_DR7, pCtx->dr[7]); 2691 2687 AssertRC(rc); 2692 2688 … … 2962 2958 /* Enable drx move intercepts again. */ 2963 2959 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); 2965 2961 AssertRC(rc); 2966 2962 … … 2986 2982 * @param GCPhys Physical address of the page to flush 2987 2983 */ 2988 static void VMXR0FlushEPT(PVM pVM, VMX_FLUSH enmFlush, RTGCPHYS GCPhys)2984 static void vmxR0FlushEPT(PVM pVM, VMX_FLUSH enmFlush, RTGCPHYS GCPhys) 2989 2985 { 2990 2986 uint64_t descriptor[2]; … … 3007 3003 * @param GCPtr Virtual address of the page to flush 3008 3004 */ 3009 static void VMXR0FlushVPID(PVM pVM, VMX_FLUSH enmFlush, RTGCPTR GCPtr)3005 static void vmxR0FlushVPID(PVM pVM, VMX_FLUSH enmFlush, RTGCPTR GCPtr) 3010 3006 { 3011 3007 uint64_t descriptor[2]; … … 3037 3033 if ( !fFlushPending 3038 3034 && pVM->hwaccm.s.vmx.fVPID) 3039 VMXR0FlushVPID(pVM, pVM->hwaccm.s.vmx.enmFlushPage, GCVirt);3035 vmxR0FlushVPID(pVM, pVM->hwaccm.s.vmx.enmFlushPage, GCVirt); 3040 3036 #endif /* HWACCM_VTX_WITH_VPID */ 3041 3037 … … 3060 3056 /* Skip it if a TLB flush is already pending. */ 3061 3057 if (!fFlushPending) 3062 VMXR0FlushEPT(pVM, pVM->hwaccm.s.vmx.enmFlushPage, GCPhys);3058 vmxR0FlushEPT(pVM, pVM->hwaccm.s.vmx.enmFlushPage, GCPhys); 3063 3059 3064 3060 return VINF_SUCCESS; … … 3073 3069 * @param pCtx Current CPU context (not updated) 3074 3070 */ 3075 static void VMXR0ReportWorldSwitchError(PVM pVM, int rc, PCPUMCTX pCtx)3071 static void vmxR0ReportWorldSwitchError(PVM pVM, int rc, PCPUMCTX pCtx) 3076 3072 { 3077 3073 switch (rc) trunk/src/VBox/VMM/VMMR0/HWVMXR0.h
r12989 r13195 137 137 #define VMX_WRITE_SELREG(REG, reg) \ 138 138 { \ 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); \ 142 142 if ((pCtx->eflags.u32 & X86_EFL_VM)) \ 143 143 val = pCtx->reg##Hid.Attr.u; \ … … 156 156 val = 0x10000; /* Invalid guest state error otherwise. (BIT(16) = Unusable) */ \ 157 157 \ 158 rc |= VMXWriteVMCS (VMX_VMCS_GUEST_##REG##_ACCESS_RIGHTS, val);\158 rc |= VMXWriteVMCS32(VMX_VMCS_GUEST_##REG##_ACCESS_RIGHTS, val); \ 159 159 } 160 160

