Changeset 13197
- Timestamp:
- 10/13/08 10:52:06 (3 months ago)
- Files:
-
- trunk/include/VBox/hwacc_vmx.h (modified) (2 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
r13196 r13197 1380 1380 * @returns VBox status code 1381 1381 * @param idxField VMCS index 1382 * @param u64Val 16, 32 or 64 bits value 1383 */ 1384 DECLASM(int) VMXWriteVMCS64(uint32_t idxField, uint64_t u64Val); 1385 1386 /** 1387 * Executes VMWRITE 1388 * 1389 * @returns VBox status code 1390 * @param idxField VMCS index 1382 1391 * @param u32Val 32 bits value 1383 1392 */ 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 1390 1394 DECLASM(int) VMXWriteVMCS32(uint32_t idxField, uint32_t u32Val); 1391 1395 #else … … 1432 1436 #endif 1433 1437 1434 /**1435 * Executes VMWRITE1436 *1437 * @returns VBox status code1438 * @param idxField VMCS index1439 * @param u64Val 16, 32 or 64 bits value1440 */1441 1438 #if HC_ARCH_BITS == 64 1442 DECLASM(int) VMXWriteVMCS64(uint32_t idxField, uint64_t u64Val); 1439 #define VMXWriteVMCS VMXWriteVMCS64 1443 1440 #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 */ 1453 1443 1454 1444 trunk/include/VBox/pgm.h
r13195 r13197 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 340 338 VMMDECL(int) PGMFlushTLB(PVM pVM, uint64_t cr3, bool fGlobal); 341 339 VMMDECL(int) PGMUpdateCR3(PVM pVM, uint64_t cr3); trunk/src/VBox/VMM/VMMAll/PGMAll.cpp
r13195 r13197 1211 1211 } 1212 1212 1213 /**1214 * Gets the specified page directory pointer table entry.1215 *1216 * @returns PDP entry1217 * @param pPGM Pointer to the PGM instance data.1218 * @param iPdpt PDPT index1219 */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 1226 1213 1227 1214 /** trunk/src/VBox/VMM/VMMR0/HWVMXR0.cpp
r13195 r13197 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 static void vmxR0PrefetchPAEPdptrs(PVM pVM, PCPUMCTX pCtx); 64 65 66 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 64 65 static void VMXR0CheckError(PVM pVM, int rc) 67 66 { 68 67 if (rc == VERR_VMX_GENERIC) … … 111 110 if (VBOX_FAILURE(rc)) 112 111 { 113 vmxR0CheckError(pVM, rc);112 VMXR0CheckError(pVM, rc); 114 113 ASMSetCR4(ASMGetCR4() & ~X86_CR4_VMXE); 115 114 return VERR_VMX_VMXON_FAILED; … … 279 278 val &= pVM->hwaccm.s.vmx.msr.vmx_pin_ctls.n.allowed1; 280 279 281 rc = VMXWriteVMCS 32(VMX_VMCS_CTRL_PIN_EXEC_CONTROLS, val);280 rc = VMXWriteVMCS(VMX_VMCS_CTRL_PIN_EXEC_CONTROLS, val); 282 281 AssertRC(rc); 283 282 … … 329 328 pVM->hwaccm.s.vmx.proc_ctls = val; 330 329 331 rc = VMXWriteVMCS 32(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, val);330 rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, val); 332 331 AssertRC(rc); 333 332 … … 354 353 val &= pVM->hwaccm.s.vmx.msr.vmx_proc_ctls2.n.allowed1; 355 354 356 rc = VMXWriteVMCS 32(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS2, val);355 rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS2, val); 357 356 AssertRC(rc); 358 357 } … … 361 360 * Set required bits to one and zero according to the MSR capabilities. 362 361 */ 363 rc = VMXWriteVMCS 32(VMX_VMCS_CTRL_CR3_TARGET_COUNT, 0);362 rc = VMXWriteVMCS(VMX_VMCS_CTRL_CR3_TARGET_COUNT, 0); 364 363 AssertRC(rc); 365 364 … … 378 377 val &= pVM->hwaccm.s.vmx.msr.vmx_exit.n.allowed1; 379 378 /* Don't acknowledge external interrupts on VM-exit. */ 380 rc = VMXWriteVMCS 32(VMX_VMCS_CTRL_EXIT_CONTROLS, val);379 rc = VMXWriteVMCS(VMX_VMCS_CTRL_EXIT_CONTROLS, val); 381 380 AssertRC(rc); 382 381 … … 398 397 pVM->hwaccm.s.vmx.u32TrapMask &= ~RT_BIT(X86_XCPT_PF); /* no longer need to intercept #PF. */ 399 398 #endif 400 rc = VMXWriteVMCS 32(VMX_VMCS_CTRL_EXCEPTION_BITMAP, pVM->hwaccm.s.vmx.u32TrapMask);399 rc = VMXWriteVMCS(VMX_VMCS_CTRL_EXCEPTION_BITMAP, pVM->hwaccm.s.vmx.u32TrapMask); 401 400 AssertRC(rc); 402 401 403 402 /* Don't filter page faults; all of them should cause a switch. */ 404 rc = VMXWriteVMCS 32(VMX_VMCS_CTRL_PAGEFAULT_ERROR_MASK, 0);405 rc |= VMXWriteVMCS 32(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); 406 405 AssertRC(rc); 407 406 408 407 /* 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 416 424 AssertRC(rc); 417 425 … … 420 428 { 421 429 /* 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 423 434 AssertRC(rc); 424 435 } 425 436 426 437 /* 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); 432 448 AssertRC(rc); 433 449 … … 436 452 Assert(pVM->hwaccm.s.vmx.pMemObjAPIC); 437 453 /* 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 440 459 AssertRC(rc); 441 460 } 442 461 443 462 /* 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 445 469 AssertRC(rc); 446 470 … … 452 476 if (pVM->hwaccm.s.fNestedPaging) 453 477 { 454 pVM->hwaccm.s.vmx.pfnSetupTaggedTLB = vmxR0SetupTLBEPT;478 pVM->hwaccm.s.vmx.pfnSetupTaggedTLB = VMXR0SetupTLBEPT; 455 479 456 480 /* Default values for flushing. */ … … 472 496 if (pVM->hwaccm.s.vmx.fVPID) 473 497 { 474 pVM->hwaccm.s.vmx.pfnSetupTaggedTLB = vmxR0SetupTLBVPID;498 pVM->hwaccm.s.vmx.pfnSetupTaggedTLB = VMXR0SetupTLBVPID; 475 499 476 500 /* Default values for flushing. */ … … 490 514 #endif /* HWACCM_VTX_WITH_VPID */ 491 515 else 492 pVM->hwaccm.s.vmx.pfnSetupTaggedTLB = vmxR0SetupTLBDummy;516 pVM->hwaccm.s.vmx.pfnSetupTaggedTLB = VMXR0SetupTLBDummy; 493 517 494 518 495 519 vmx_end: 496 vmxR0CheckError(pVM, rc);520 VMXR0CheckError(pVM, rc); 497 521 return rc; 498 522 } … … 549 573 550 574 /* Set event injection state. */ 551 rc = VMXWriteVMCS 32(VMX_VMCS_CTRL_ENTRY_IRQ_INFO, intInfo | (1 << VMX_EXIT_INTERRUPTION_INFO_VALID_SHIFT));552 553 rc |= VMXWriteVMCS 32(VMX_VMCS_CTRL_ENTRY_INSTR_LENGTH, cbInstr);554 rc |= VMXWriteVMCS 32(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); 555 579 556 580 AssertRC(rc); … … 592 616 LogFlow(("Enable irq window exit!\n")); 593 617 pVM->hwaccm.s.vmx.proc_ctls |= VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_IRQ_WINDOW_EXIT; 594 rc = VMXWriteVMCS 32(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); 595 619 AssertRC(rc); 596 620 } … … 708 732 709 733 /* Control registers */ 710 rc = VMXWriteVMCS 32(VMX_VMCS_HOST_CR0, ASMGetCR0());711 rc |= VMXWriteVMCS 32(VMX_VMCS_HOST_CR3, ASMGetCR3());712 rc |= VMXWriteVMCS 32(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()); 713 737 AssertRC(rc); 714 738 Log2(("VMX_VMCS_HOST_CR0 %08x\n", ASMGetCR0())); … … 717 741 718 742 /* Selector registers. */ 719 rc = VMXWriteVMCS 32(VMX_VMCS_HOST_FIELD_CS, ASMGetCS());743 rc = VMXWriteVMCS(VMX_VMCS_HOST_FIELD_CS, ASMGetCS()); 720 744 /* Note: VMX is (again) very picky about the RPL of the selectors here; we'll restore them manually. */ 721 rc |= VMXWriteVMCS 32(VMX_VMCS_HOST_FIELD_DS, 0);722 rc |= VMXWriteVMCS 32(VMX_VMCS_HOST_FIELD_ES, 0);745 rc |= VMXWriteVMCS(VMX_VMCS_HOST_FIELD_DS, 0); 746 rc |= VMXWriteVMCS(VMX_VMCS_HOST_FIELD_ES, 0); 723 747 #if HC_ARCH_BITS == 32 724 rc |= VMXWriteVMCS 32(VMX_VMCS_HOST_FIELD_FS, 0);725 rc |= VMXWriteVMCS 32(VMX_VMCS_HOST_FIELD_GS, 0);726 #endif 727 rc |= VMXWriteVMCS 32(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()); 728 752 SelTR = ASMGetTR(); 729 rc |= VMXWriteVMCS 32(VMX_VMCS_HOST_FIELD_TR, SelTR);753 rc |= VMXWriteVMCS(VMX_VMCS_HOST_FIELD_TR, SelTR); 730 754 AssertRC(rc); 731 755 Log2(("VMX_VMCS_HOST_FIELD_CS %08x\n", ASMGetCS())); … … 739 763 /* GDTR & IDTR */ 740 764 ASMGetGDTR(&gdtr); 741 rc = VMXWriteVMCS 32(VMX_VMCS_HOST_GDTR_BASE, gdtr.pGdt);765 rc = VMXWriteVMCS(VMX_VMCS_HOST_GDTR_BASE, gdtr.pGdt); 742 766 ASMGetIDTR(&idtr); 743 rc |= VMXWriteVMCS 32(VMX_VMCS_HOST_IDTR_BASE, idtr.pIdt);767 rc |= VMXWriteVMCS(VMX_VMCS_HOST_IDTR_BASE, idtr.pIdt); 744 768 AssertRC(rc); 745 769 Log2(("VMX_VMCS_HOST_GDTR_BASE %VHv\n", gdtr.pGdt)); … … 759 783 trBase = X86DESC_BASE(*pDesc); 760 784 #endif 761 rc = VMXWriteVMCS 32(VMX_VMCS_HOST_TR_BASE, trBase);785 rc = VMXWriteVMCS(VMX_VMCS_HOST_TR_BASE, trBase); 762 786 AssertRC(rc); 763 787 Log2(("VMX_VMCS_HOST_TR_BASE %VHv\n", trBase)); … … 774 798 /* Sysenter MSRs. */ 775 799 /** @todo expensive!! */ 776 rc = VMXWriteVMCS 32(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)); 777 801 Log2(("VMX_VMCS_HOST_SYSENTER_CS %08x\n", ASMRdMsr_Low(MSR_IA32_SYSENTER_CS))); 778 802 #if HC_ARCH_BITS == 32 779 rc |= VMXWriteVMCS 32(VMX_VMCS_HOST_SYSENTER_ESP, ASMRdMsr_Low(MSR_IA32_SYSENTER_ESP));780 rc |= VMXWriteVMCS 32(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)); 781 805 Log2(("VMX_VMCS_HOST_SYSENTER_EIP %VHv\n", ASMRdMsr_Low(MSR_IA32_SYSENTER_EIP))); 782 806 Log2(("VMX_VMCS_HOST_SYSENTER_ESP %VHv\n", ASMRdMsr_Low(MSR_IA32_SYSENTER_ESP))); … … 794 818 } 795 819 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 context801 */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 }817 820 818 821 /** … … 957 960 if (pCtx->ldtr == 0) 958 961 { 959 rc = VMXWriteVMCS 32(VMX_VMCS_GUEST_FIELD_LDTR, 0);960 rc |= VMXWriteVMCS 32(VMX_VMCS_GUEST_LDTR_LIMIT, 0);961 rc |= VMXWriteVMCS 32(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); 962 965 /* Note: vmlaunch will fail with 0 or just 0x02. No idea why. */ 963 rc |= VMXWriteVMCS 32(VMX_VMCS_GUEST_LDTR_ACCESS_RIGHTS, 0x82 /* present, LDT */);966 rc |= VMXWriteVMCS(VMX_VMCS_GUEST_LDTR_ACCESS_RIGHTS, 0x82 /* present, LDT */); 964 967 } 965 968 else 966 969 { 967 rc = VMXWriteVMCS 32(VMX_VMCS_GUEST_FIELD_LDTR, pCtx->ldtr);968 rc |= VMXWriteVMCS 32(VMX_VMCS_GUEST_LDTR_LIMIT, pCtx->ldtrHid.u32Limit);969 rc |= VMXWriteVMCS 32(VMX_VMCS_GUEST_LDTR_BASE, pCtx->ldtrHid.u64Base);970 rc |= VMXWriteVMCS 32(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); 971 974 } 972 975 AssertRC(rc); … … 985 988 AssertRC(rc); 986 989 987 rc = VMXWriteVMCS 32(VMX_VMCS_GUEST_FIELD_TR, 0);988 rc |= VMXWriteVMCS 32(VMX_VMCS_GUEST_TR_LIMIT, HWACCM_VTX_TSS_SIZE);989 rc |= VMXWriteVMCS 32(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 */); 990 993 991 994 X86DESCATTR attr; … … 999 1002 #endif /* HWACCM_VMX_EMULATE_REALMODE */ 1000 1003 { 1001 rc = VMXWriteVMCS 32(VMX_VMCS_GUEST_FIELD_TR, pCtx->tr);1002 rc |= VMXWriteVMCS 32(VMX_VMCS_GUEST_TR_LIMIT, pCtx->trHid.u32Limit);1003 rc |= VMXWriteVMCS 32(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); 1004 1007 1005 1008 val = pCtx->trHid.Attr.u; … … 1013 1016 1014 1017 } 1015 rc |= VMXWriteVMCS 32(VMX_VMCS_GUEST_TR_ACCESS_RIGHTS, val);1018 rc |= VMXWriteVMCS(VMX_VMCS_GUEST_TR_ACCESS_RIGHTS, val); 1016 1019 AssertRC(rc); 1017 1020 } … … 1019 1022 if (pVM->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_GUEST_GDTR) 1020 1023 { 1021 rc = VMXWriteVMCS 32(VMX_VMCS_GUEST_GDTR_LIMIT, pCtx->gdtr.cbGdt);1022 rc |= VMXWriteVMCS 32(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); 1023 1026 AssertRC(rc); 1024 1027 } … … 1026 1029 if (pVM->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_GUEST_IDTR) 1027 1030 { 1028 rc = VMXWriteVMCS 32(VMX_VMCS_GUEST_IDTR_LIMIT, pCtx->idtr.cbIdt);1029 rc |= VMXWriteVMCS 32(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); 1030 1033 AssertRC(rc); 1031 1034 } … … 1034 1037 * Sysenter MSRs (unconditional) 1035 1038 */ 1036 rc = VMXWriteVMCS 32(VMX_VMCS_GUEST_SYSENTER_CS, pCtx->SysEnter.cs);1037 rc |= VMXWriteVMCS 32(VMX_VMCS_GUEST_SYSENTER_EIP, pCtx->SysEnter.eip);1038 rc |= VMXWriteVMCS 32(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); 1039 1042 AssertRC(rc); 1040 1043 … … 1043 1046 { 1044 1047 val = pCtx->cr0; 1045 rc = VMXWriteVMCS 32(VMX_VMCS_CTRL_CR0_READ_SHADOW, val);1048 rc = VMXWriteVMCS(VMX_VMCS_CTRL_CR0_READ_SHADOW, val); 1046 1049 Log2(("Guest CR0-shadow %08x\n", val)); 1047 1050 if (CPUMIsGuestFPUStateActive(pVM) == false) … … 1061 1064 { 1062 1065 pVM->hwaccm.s.vmx.u32TrapMask |= RT_BIT(X86_XCPT_MF); 1063 rc = VMXWriteVMCS 32(VMX_VMCS_CTRL_EXCEPTION_BITMAP, pVM->hwaccm.s.vmx.u32TrapMask);1066 rc = VMXWriteVMCS(VMX_VMCS_CTRL_EXCEPTION_BITMAP, pVM->hwaccm.s.vmx.u32TrapMask); 1064 1067 AssertRC(rc); 1065 1068 pVM->hwaccm.s.fFPUOldStyleOverride = true; … … 1085 1088 | VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_CR3_STORE_EXIT; 1086 1089 } 1087 rc = VMXWriteVMCS 32(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); 1088 1091 AssertRC(rc); 1089 1092 } … … 1097 1100 val &= ~(X86_CR0_CD|X86_CR0_NW); 1098 1101 1099 rc |= VMXWriteVMCS 32(VMX_VMCS_GUEST_CR0, val);1102 rc |= VMXWriteVMCS(VMX_VMCS_GUEST_CR0, val); 1100 1103 Log2(("Guest CR0 %08x\n", val)); 1101 1104 /* CR0 flags owned by the host; if the guests attempts to change them, then … … 1113 1116 pVM->hwaccm.s.vmx.cr0_mask = val; 1114 1117 1115 rc |= VMXWriteVMCS 32(VMX_VMCS_CTRL_CR0_MASK, val);1118 rc |= VMXWriteVMCS(VMX_VMCS_CTRL_CR0_MASK, val); 1116 1119 Log2(("Guest CR0-mask %08x\n", val)); 1117 1120 AssertRC(rc); … … 1120 1123 { 1121 1124 /* CR4 */ 1122 rc = VMXWriteVMCS 32(VMX_VMCS_CTRL_CR4_READ_SHADOW, pCtx->cr4);1125 rc = VMXWriteVMCS(VMX_VMCS_CTRL_CR4_READ_SHADOW, pCtx->cr4); 1123 1126 Log2(("Guest CR4-shadow %08x\n", pCtx->cr4)); 1124 1127 /* Set the required bits in cr4 too (currently X86_CR4_VMXE). */ … … 1168 1171 #endif /* HWACCM_VMX_EMULATE_REALMODE */ 1169 1172 1170 rc |= VMXWriteVMCS 32(VMX_VMCS_GUEST_CR4, val);1173 rc |= VMXWriteVMCS(VMX_VMCS_GUEST_CR4, val); 1171 1174 Log2(("Guest CR4 %08x\n", val)); 1172 1175 /* CR4 flags owned by the host; if the guests attempts to change them, then … … 1183 1186 pVM->hwaccm.s.vmx.cr4_mask = val; 1184 1187 1185 rc |= VMXWriteVMCS 32(VMX_VMCS_CTRL_CR4_MASK, val);1188 rc |= VMXWriteVMCS(VMX_VMCS_CTRL_CR4_MASK, val); 1186 1189 Log2(("Guest CR4-mask %08x\n", val)); 1187 1190 AssertRC(rc); … … 1200 1203 | (VMX_EPT_PAGE_WALK_LENGTH_DEFAULT << VMX_EPT_PAGE_WALK_LENGTH_SHIFT); 1201 1204 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 1203 1209 AssertRC(rc); 1204 1210 … … 1220 1226 /* Save the real guest CR3 in VMX_VMCS_GUEST_CR3 */ 1221 1227 val = pCtx->cr3; 1222 1223 /* Prefetch the four PDPT entries in PAE mode. */1224 vmxR0PrefetchPAEPdptrs(pVM, pCtx);1225 1228 } 1226 1229 } … … 1232 1235 1233 1236 /* Save our shadow CR3 register. */ 1234 rc = VMXWriteVMCS 32(VMX_VMCS_GUEST_CR3, val);1237 rc = VMXWriteVMCS(VMX_VMCS_GUEST_CR3, val); 1235 1238 AssertRC(rc); 1236 1239 } … … 1247 1250 1248 1251 /* Resync DR7 */ 1249 rc = VMXWriteVMCS 32(VMX_VMCS_GUEST_DR7, pCtx->dr[7]);1252 rc = VMXWriteVMCS(VMX_VMCS_GUEST_DR7, pCtx->dr[7]); 1250 1253 AssertRC(rc); 1251 1254 … … 1259 1262 /* Disable drx move intercepts. */ 1260 1263 pVM->hwaccm.s.vmx.proc_ctls &= ~VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_MOV_DR_EXIT; 1261 rc = VMXWriteVMCS 32(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); 1262 1265 AssertRC(rc); 1263 1266 … … 1268 1271 1269 1272 /* IA32_DEBUGCTL MSR. */ 1270 rc = VMXWriteVMCS 32(VMX_VMCS_GUEST_DEBUGCTL_FULL, 0);1271 rc |= VMXWriteVMCS 32(VMX_VMCS_GUEST_DEBUGCTL_HIGH, 0);1273 rc = VMXWriteVMCS(VMX_VMCS_GUEST_DEBUGCTL_FULL, 0); 1274 rc |= VMXWriteVMCS(VMX_VMCS_GUEST_DEBUGCTL_HIGH, 0); 1272 1275 AssertRC(rc); 1273 1276 1274 1277 /** @todo do we really ever need this? */ 1275 rc |= VMXWriteVMCS 32(VMX_VMCS_GUEST_DEBUG_EXCEPTIONS, 0);1278 rc |= VMXWriteVMCS(VMX_VMCS_GUEST_DEBUG_EXCEPTIONS, 0); 1276 1279 AssertRC(rc); 1277 1280 } 1278 1281 1279 1282 /* EIP, ESP and EFLAGS */ 1280 rc = VMXWriteVMCS 32(VMX_VMCS_GUEST_RIP, pCtx->rip);1281 rc |= VMXWriteVMCS 32(VMX_VMCS_GUEST_RSP, pCtx->rsp);1283 rc = VMXWriteVMCS(VMX_VMCS_GUEST_RIP, pCtx->rip); 1284 rc |= VMXWriteVMCS(VMX_VMCS_GUEST_RSP, pCtx->rsp); 1282 1285 AssertRC(rc); 1283 1286 … … 1295 1298 } 1296 1299 #endif /* HWACCM_VMX_EMULATE_REALMODE */ 1297 rc = VMXWriteVMCS 32(VMX_VMCS_GUEST_RFLAGS, eflags.u32);1300 rc = VMXWriteVMCS(VMX_VMCS_GUEST_RFLAGS, eflags.u32); 1298 1301 AssertRC(rc); 1299 1302 … … 1304 1307 { 1305 1308 /* 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 1307 1313 AssertRC(rc); 1308 1314 1309 1315 pVM->hwaccm.s.vmx.proc_ctls &= ~VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_RDTSC_EXIT; 1310 rc = VMXWriteVMCS 32(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); 1311 1317 AssertRC(rc); 1312 1318 STAM_COUNTER_INC(&pVM->hwaccm.s.StatTSCOffset); … … 1315 1321 { 1316 1322 pVM->hwaccm.s.vmx.proc_ctls |= VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_RDTSC_EXIT; 1317 rc = VMXWriteVMCS 32(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); 1318 1324 AssertRC(rc); 1319 1325 STAM_COUNTER_INC(&pVM->hwaccm.s.StatTSCIntercept); … … 1334 1340 /* Mask away the bits that the CPU doesn't support */ 1335 1341 val &= pVM->hwaccm.s.vmx.msr.vmx_entry.n.allowed1; 1336 rc = VMXWriteVMCS 32(VMX_VMCS_CTRL_ENTRY_CONTROLS, val);1342 rc = VMXWriteVMCS(VMX_VMCS_CTRL_ENTRY_CONTROLS, val); 1337 1343 AssertRC(rc); 1338 1344 … … 1346 1352 #endif 1347 1353 /* Unconditionally update these as wrmsr might have changed them. */ 1348 rc = VMXWriteVMCS 32(VMX_VMCS_GUEST_FS_BASE, pCtx->fsHid.u64Base);1349 AssertRC(rc); 1350 rc = VMXWriteVMCS 32(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); 1351 1357 AssertRC(rc); 1352 1358 } … … 1363 1369 pVM->hwaccm.s.vmx.u32TrapMask &= ~RT_BIT(X86_XCPT_DB); 1364 1370 1365 rc = VMXWriteVMCS 32(VMX_VMCS_CTRL_EXCEPTION_BITMAP, pVM->hwaccm.s.vmx.u32TrapMask);1371 rc = VMXWriteVMCS(VMX_VMCS_CTRL_EXCEPTION_BITMAP, pVM->hwaccm.s.vmx.u32TrapMask); 1366 1372 #endif 1367 1373 … … 1376 1382 pVM->hwaccm.s.vmx.u32TrapMask &= ~RT_BIT(X86_XCPT_GP); 1377 1383 # endif /* HWACCM_VMX_EMULATE_REALMODE */ 1378 rc = VMXWriteVMCS 32(VMX_VMCS_CTRL_EXCEPTION_BITMAP, pVM->hwaccm.s.vmx.u32TrapMask);1384 rc = VMXWriteVMCS(VMX_VMCS_CTRL_EXCEPTION_BITMAP, pVM->hwaccm.s.vmx.u32TrapMask); 1379 1385 AssertRC(rc); 1380 1386 #endif … … 1448 1454 PGMUpdateCR3(pVM, val); 1449 1455 } 1450 /* Prefetch the four PDPT entries in PAE mode. */1451 vmxR0PrefetchPAEPdptrs(pVM, pCtx);1452 1456 } 1453 1457 … … 1512 1516 * @param pVM The VM to operate on. 1513 1517 */ 1514 static void vmxR0SetupTLBDummy(PVM pVM)1518 static void VMXR0SetupTLBDummy(PVM pVM) 1515 1519 { 1516 1520 return; … … 1523 1527 * @param pVM The VM to operate on. 1524 1528 */ 1525 static void vmxR0SetupTLBEPT(PVM pVM)1529 static void VMXR0SetupTLBEPT(PVM pVM) 1526 1530 { 1527 1531 PHWACCM_CPUINFO pCpu; … … 1548 1552 1549 1553 if (pVM->hwaccm.s.fForceTLBFlush) 1550 vmxR0FlushEPT(pVM, pVM->hwaccm.s.vmx.enmFlushContext, 0);1554 VMXR0FlushEPT(pVM, pVM->hwaccm.s.vmx.enmFlushContext, 0); 1551 1555 1552 1556 #ifdef VBOX_WITH_STATISTICS … … 1565 1569 * @param pVM The VM to operate on. 1566 1570 */ 1567 static void vmxR0SetupTLBVPID(PVM pVM)1571 static void VMXR0SetupTLBVPID(PVM pVM) 1568 1572 { 1569 1573 PHWACCM_CPUINFO pCpu; … … 1618 1622 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)); 1619 1623 1620 int rc = VMXWriteVMCS 32(VMX_VMCS_GUEST_FIELD_VPID, pVM->hwaccm.s.uCurrentASID);1624 int rc = VMXWriteVMCS(VMX_VMCS_GUEST_FIELD_VPID, pVM->hwaccm.s.uCurrentASID); 1621 1625 AssertRC(rc); 1622 1626 1623 1627 if (pVM->hwaccm.s.fForceTLBFlush) 1624 vmxr0lushVPID(pVM, pVM->hwaccm.s.vmx.enmFlushContext, 0);1628 VMXR0FlushVPID(pVM, pVM->hwaccm.s.vmx.enmFlushContext, 0); 1625 1629 1626 1630 #ifdef VBOX_WITH_STATISTICS … … 1737 1741 VM_FF_CLEAR(pVM, VM_FF_INHIBIT_INTERRUPTS); 1738 1742 /* Irq inhibition is no longer active; clear the corresponding VMX state. */ 1739 rc = VMXWriteVMCS 32(VMX_VMCS_GUEST_INTERRUPTIBILITY_STATE, 0);1743 rc = VMXWriteVMCS(VMX_VMCS_GUEST_INTERRUPTIBILITY_STATE, 0); 1740 1744 AssertRC(rc); 1741 1745 } … … 1744 1748 { 1745 1749 /* Irq inhibition is no longer active; clear the corresponding VMX state. */ 1746 rc = VMXWriteVMCS 32(VMX_VMCS_GUEST_INTERRUPTIBILITY_STATE, 0);1750 rc = VMXWriteVMCS(VMX_VMCS_GUEST_INTERRUPTIBILITY_STATE, 0); 1747 1751 AssertRC(rc); 1748 1752 } … … 1800 1804 * -> We don't need to be explicitely notified. There are enough world switches for detecting pending interrupts. 1801 1805 */ 1802 rc = VMXWriteVMCS 32(VMX_VMCS_CTRL_TPR_THRESHOLD, (fPending) ? u8TPR : 0);1806 rc = VMXWriteVMCS(VMX_VMCS_CTRL_TPR_THRESHOLD, (fPending) ? u8TPR : 0); 1803 1807 AssertRC(rc); 1804 1808 … … 1855 1859 /* Non-register state Guest Context */ 1856 1860 /** @todo change me according to cpu state */ 1857 rc = VMXWriteVMCS 32(VMX_VMCS_GUEST_ACTIVITY_STATE, VMX_CMS_GUEST_ACTIVITY_ACTIVE);1861 rc = VMXWriteVMCS(VMX_VMCS_GUEST_ACTIVITY_STATE, VMX_CMS_GUEST_ACTIVITY_ACTIVE); 1858 1862 AssertRC(rc); 1859 1863 … … 1896 1900 if (rc != VINF_SUCCESS) 1897 1901 { 1898 vmxR0ReportWorldSwitchError(pVM, rc, pCtx);1902 VMXR0ReportWorldSwitchError(pVM, rc, pCtx); 1899 1903 goto end; 1900 1904 } … … 2175 2179 2176 2180 /* Resync DR7 */ 2177 rc = VMXWriteVMCS 32(VMX_VMCS_GUEST_DR7, pCtx->dr[7]);2181 rc = VMXWriteVMCS(VMX_VMCS_GUEST_DR7, pCtx->dr[7]); 2178 2182 AssertRC(rc); 2179 2183 … … 2336 2340 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)); 2337 2341 pVM->hwaccm.s.vmx.proc_ctls &= ~VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_IRQ_WINDOW_EXIT; 2338 rc = VMXWriteVMCS 32(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); 2339 2343 AssertRC(rc); 2340 2344 STAM_COUNTER_INC(&pVM->hwaccm.s.StatExitIrqWindow); … … 2516 2520 /* Disable drx move intercepts. */ 2517 2521 pVM->hwaccm.s.vmx.proc_ctls &= ~VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_MOV_DR_EXIT; 2518 rc = VMXWriteVMCS 32(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); 2519 2523 AssertRC(rc); 2520 2524 … … 2684 2688 2685 2689 /* Resync DR7 */ 2686 rc = VMXWriteVMCS 32(VMX_VMCS_GUEST_DR7, pCtx->dr[7]);2690 rc = VMXWriteVMCS(VMX_VMCS_GUEST_DR7, pCtx->dr[7]); 2687 2691 AssertRC(rc); 2688 2692 … … 2958 2962 /* Enable drx move intercepts again. */ 2959 2963 pVM->hwaccm.s.vmx.proc_ctls |= VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_MOV_DR_EXIT; 2960 int rc = VMXWriteVMCS 32(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); 2961 2965 AssertRC(rc); 2962 2966 … … 2982 2986 * @param GCPhys Physical address of the page to flush 2983 2987 */ 2984 static void vmxR0FlushEPT(PVM pVM, VMX_FLUSH enmFlush, RTGCPHYS GCPhys)2988 static void VMXR0FlushEPT(PVM pVM, VMX_FLUSH enmFlush, RTGCPHYS GCPhys) 2985 2989 { 2986 2990 uint64_t descriptor[2]; … … 3003 3007 * @param GCPtr Virtual address of the page to flush 3004 3008 */ 3005 static void vmxR0FlushVPID(PVM pVM, VMX_FLUSH enmFlush, RTGCPTR GCPtr)3009 static void VMXR0FlushVPID(PVM pVM, VMX_FLUSH enmFlush, RTGCPTR GCPtr) 3006 3010 { 3007 3011 uint64_t descriptor[2]; … … 3033 3037 if ( !fFlushPending 3034 3038 && pVM->hwaccm.s.vmx.fVPID) 3035 vmxR0FlushVPID(pVM, pVM->hwaccm.s.vmx.enmFlushPage, GCVirt);3039 VMXR0FlushVPID(pVM, pVM->hwaccm.s.vmx.enmFlushPage, GCVirt); 3036 3040 #endif /* HWACCM_VTX_WITH_VPID */ 3037 3041 … … 3056 3060 /* Skip it if a TLB flush is already pending. */ 3057 3061 if (!fFlushPending) 3058 vmxR0FlushEPT(pVM, pVM->hwaccm.s.vmx.enmFlushPage, GCPhys);3062 VMXR0FlushEPT(pVM, pVM->hwaccm.s.vmx.enmFlushPage, GCPhys); 3059 3063 3060 3064 return VINF_SUCCESS; … … 3069 3073 * @param pCtx Current CPU context (not updated) 3070 3074 */ 3071 static void vmxR0ReportWorldSwitchError(PVM pVM, int rc, PCPUMCTX pCtx)3075 static void VMXR0ReportWorldSwitchError(PVM pVM, int rc, PCPUMCTX pCtx) 3072 3076 { 3073 3077 switch (rc) trunk/src/VBox/VMM/VMMR0/HWVMXR0.h
r13195 r13197 137 137 #define VMX_WRITE_SELREG(REG, reg) \ 138 138 { \ 139 rc = VMXWriteVMCS 32(VMX_VMCS_GUEST_FIELD_##REG, pCtx->reg);\140 rc |= VMXWriteVMCS 32(VMX_VMCS_GUEST_##REG##_LIMIT, pCtx->reg##Hid.u32Limit);\141 rc |= VMXWriteVMCS 64(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); \ 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 32(VMX_VMCS_GUEST_##REG##_ACCESS_RIGHTS, val);\158 rc |= VMXWriteVMCS(VMX_VMCS_GUEST_##REG##_ACCESS_RIGHTS, val); \ 159 159 } 160 160

