Changeset 14649
- Timestamp:
- 11/26/08 16:01:53 (1 month ago)
- Files:
-
- trunk/include/VBox/hwacc_vmx.h (modified) (7 diffs)
- trunk/src/VBox/VMM/HWACCMInternal.h (modified) (1 diff)
- trunk/src/VBox/VMM/VMMR0/HWVMXR0.cpp (modified) (44 diffs)
- trunk/src/VBox/VMM/VMMR0/HWVMXR0.h (modified) (2 diffs)
Legend:
- Unmodified
- Added
- Removed
- Modified
- Copied
- Moved
trunk/include/VBox/hwacc_vmx.h
r14648 r14649 983 983 * @{ 984 984 */ 985 #define VMX_VMCS 64_CTRL_CR0_MASK 0x6000986 #define VMX_VMCS 64_CTRL_CR4_MASK 0x6002987 #define VMX_VMCS 64_CTRL_CR0_READ_SHADOW 0x6004988 #define VMX_VMCS 64_CTRL_CR4_READ_SHADOW 0x6006989 #define VMX_VMCS 64_CTRL_CR3_TARGET_VAL0 0x6008990 #define VMX_VMCS 64_CTRL_CR3_TARGET_VAL1 0x600A991 #define VMX_VMCS 64_CTRL_CR3_TARGET_VAL2 0x600C992 #define VMX_VMCS 64_CTRL_CR3_TARGET_VAL31 0x600E985 #define VMX_VMCS_CTRL_CR0_MASK 0x6000 986 #define VMX_VMCS_CTRL_CR4_MASK 0x6002 987 #define VMX_VMCS_CTRL_CR0_READ_SHADOW 0x6004 988 #define VMX_VMCS_CTRL_CR4_READ_SHADOW 0x6006 989 #define VMX_VMCS_CTRL_CR3_TARGET_VAL0 0x6008 990 #define VMX_VMCS_CTRL_CR3_TARGET_VAL1 0x600A 991 #define VMX_VMCS_CTRL_CR3_TARGET_VAL2 0x600C 992 #define VMX_VMCS_CTRL_CR3_TARGET_VAL31 0x600E 993 993 /** @} */ 994 994 … … 997 997 * @{ 998 998 */ 999 #define VMX_VMCS 64_RO_EXIT_QUALIFICATION 0x64001000 #define VMX_VMCS 64_RO_IO_RCX 0x64021001 #define VMX_VMCS 64_RO_IO_RSX 0x64041002 #define VMX_VMCS 64_RO_IO_RDI 0x64061003 #define VMX_VMCS 64_RO_IO_RIP 0x64081004 #define VMX_VMCS 64_EXIT_GUEST_LINEAR_ADDR 0x640A999 #define VMX_VMCS_RO_EXIT_QUALIFICATION 0x6400 1000 #define VMX_VMCS_RO_IO_RCX 0x6402 1001 #define VMX_VMCS_RO_IO_RSX 0x6404 1002 #define VMX_VMCS_RO_IO_RDI 0x6406 1003 #define VMX_VMCS_RO_IO_RIP 0x6408 1004 #define VMX_VMCS_EXIT_GUEST_LINEAR_ADDR 0x640A 1005 1005 /** @} */ 1006 1006 … … 1124 1124 * @{ 1125 1125 */ 1126 #define VMX_VMCS 64_GUEST_CR00x68001127 #define VMX_VMCS 64_GUEST_CR30x68021128 #define VMX_VMCS 64_GUEST_CR40x68041129 #define VMX_VMCS 64_GUEST_ES_BASE0x68061130 #define VMX_VMCS 64_GUEST_CS_BASE0x68081131 #define VMX_VMCS 64_GUEST_SS_BASE0x680A1132 #define VMX_VMCS 64_GUEST_DS_BASE0x680C1133 #define VMX_VMCS 64_GUEST_FS_BASE0x680E1134 #define VMX_VMCS 64_GUEST_GS_BASE0x68101135 #define VMX_VMCS 64_GUEST_LDTR_BASE0x68121136 #define VMX_VMCS 64_GUEST_TR_BASE0x68141137 #define VMX_VMCS 64_GUEST_GDTR_BASE0x68161138 #define VMX_VMCS 64_GUEST_IDTR_BASE0x68181139 #define VMX_VMCS 64_GUEST_DR70x681A1140 #define VMX_VMCS 64_GUEST_RSP0x681C1141 #define VMX_VMCS 64_GUEST_RIP0x681E1142 #define VMX_VMCS 64_GUEST_RFLAGS0x68201143 #define VMX_VMCS 64_GUEST_DEBUG_EXCEPTIONS0x68221144 #define VMX_VMCS 64_GUEST_SYSENTER_ESP0x6824 /**< MSR IA32_SYSENTER_ESP */1145 #define VMX_VMCS 64_GUEST_SYSENTER_EIP0x6826 /**< MSR IA32_SYSENTER_EIP */1126 #define VMX_VMCS_GUEST_CR0 0x6800 1127 #define VMX_VMCS_GUEST_CR3 0x6802 1128 #define VMX_VMCS_GUEST_CR4 0x6804 1129 #define VMX_VMCS_GUEST_ES_BASE 0x6806 1130 #define VMX_VMCS_GUEST_CS_BASE 0x6808 1131 #define VMX_VMCS_GUEST_SS_BASE 0x680A 1132 #define VMX_VMCS_GUEST_DS_BASE 0x680C 1133 #define VMX_VMCS_GUEST_FS_BASE 0x680E 1134 #define VMX_VMCS_GUEST_GS_BASE 0x6810 1135 #define VMX_VMCS_GUEST_LDTR_BASE 0x6812 1136 #define VMX_VMCS_GUEST_TR_BASE 0x6814 1137 #define VMX_VMCS_GUEST_GDTR_BASE 0x6816 1138 #define VMX_VMCS_GUEST_IDTR_BASE 0x6818 1139 #define VMX_VMCS_GUEST_DR7 0x681A 1140 #define VMX_VMCS_GUEST_RSP 0x681C 1141 #define VMX_VMCS_GUEST_RIP 0x681E 1142 #define VMX_VMCS_GUEST_RFLAGS 0x6820 1143 #define VMX_VMCS_GUEST_DEBUG_EXCEPTIONS 0x6822 1144 #define VMX_VMCS_GUEST_SYSENTER_ESP 0x6824 /**< MSR IA32_SYSENTER_ESP */ 1145 #define VMX_VMCS_GUEST_SYSENTER_EIP 0x6826 /**< MSR IA32_SYSENTER_EIP */ 1146 1146 /** @} */ 1147 1147 … … 1385 1385 * @returns VBox status code 1386 1386 * @param idxField VMCS index 1387 * @param u64Val 16, 32 or 64 bits value 1388 */ 1389 DECLASM(int) VMXWriteVMCS64(uint32_t idxField, uint64_t u64Val); 1390 1391 /** 1392 * Executes VMWRITE 1393 * 1394 * @returns VBox status code 1395 * @param idxField VMCS index 1387 1396 * @param u32Val 32 bits value 1388 1397 */ … … 1432 1441 #endif 1433 1442 1434 /**1435 * Executes VMWRITE1436 *1437 * @returns VBox status code1438 * @param idxField VMCS index1439 * @param u64Val 16, 32 or 64 bits value1440 */1441 #if HC_ARCH_BITS == 641442 DECLASM(int) VMXWriteVMCS64(uint32_t idxField, uint64_t u64Val);1443 #else1444 DECLINLINE(int) VMXWriteVMCS64(uint32_t idxField, uint64_t u64Val)1445 {1446 int rc;1447 1448 rc = VMXWriteVMCS32(idxField, u64Val);1449 rc |= VMXWriteVMCS32(idxField + 1, (uint32_t)(u64Val >> 32ULL));1450 AssertRC(rc);1451 return rc;1452 }1453 #endif1454 1455 1443 #if HC_ARCH_BITS == 64 1456 1444 #define VMXWriteVMCS VMXWriteVMCS64 … … 1459 1447 #endif /* HC_ARCH_BITS == 64 */ 1460 1448 1449 1450 /** 1451 * Executes VMREAD 1452 * 1453 * @returns VBox status code 1454 * @param idxField VMCS index 1455 * @param pData Ptr to store VM field value 1456 */ 1457 DECLASM(int) VMXReadVMCS64(uint32_t idxField, uint64_t *pData); 1461 1458 1462 1459 /** … … 1532 1529 1533 1530 #if HC_ARCH_BITS == 64 1534 /**1535 * Executes VMREAD1536 *1537 * @returns VBox status code1538 * @param idxField VMCS index1539 * @param pData Ptr to store VM field value1540 */1541 DECLASM(int) VMXReadVMCS64(uint32_t idxField, uint64_t *pData);1542 #else1543 DECLINLINE(int) VMXReadVMCS64(uint32_t idxField, uint64_t *pData)1544 {1545 int rc;1546 1547 uint32_t val_hi, val;1548 rc = VMXReadVMCS32(idxField, &val);1549 rc |= VMXReadVMCS32(idxField + 1, &val_hi);1550 AssertRC(rc);1551 *pData = RT_MAKE_U64(val, val_hi);1552 return rc;1553 }1554 #endif1555 1556 #if HC_ARCH_BITS == 641557 1531 # define VMXReadVMCS VMXReadVMCS64 1558 1532 #else trunk/src/VBox/VMM/HWACCMInternal.h
r14648 r14649 399 399 struct 400 400 { 401 X86 RFLAGS rflags;401 X86EFLAGS eflags; 402 402 uint32_t fValid; 403 403 } RealMode; trunk/src/VBox/VMM/VMMR0/HWVMXR0.cpp
r14648 r14649 413 413 414 414 /* Init TSC offset to zero. */ 415 rc = VMXWriteVMCS64(VMX_VMCS_CTRL_TSC_OFFSET_FULL, 0); 416 AssertRC(rc); 417 418 rc = VMXWriteVMCS64(VMX_VMCS_CTRL_IO_BITMAP_A_FULL, 0); 419 AssertRC(rc); 420 421 rc = VMXWriteVMCS64(VMX_VMCS_CTRL_IO_BITMAP_B_FULL, 0); 415 rc = VMXWriteVMCS(VMX_VMCS_CTRL_TSC_OFFSET_FULL, 0); 416 #if HC_ARCH_BITS == 32 417 rc |= VMXWriteVMCS(VMX_VMCS_CTRL_TSC_OFFSET_HIGH, 0); 418 #endif 419 AssertRC(rc); 420 421 rc = VMXWriteVMCS(VMX_VMCS_CTRL_IO_BITMAP_A_FULL, 0); 422 #if HC_ARCH_BITS == 32 423 rc |= VMXWriteVMCS(VMX_VMCS_CTRL_IO_BITMAP_A_HIGH, 0); 424 #endif 425 AssertRC(rc); 426 427 rc = VMXWriteVMCS(VMX_VMCS_CTRL_IO_BITMAP_B_FULL, 0); 428 #if HC_ARCH_BITS == 32 429 rc |= VMXWriteVMCS(VMX_VMCS_CTRL_IO_BITMAP_B_HIGH, 0); 430 #endif 422 431 AssertRC(rc); 423 432 … … 426 435 { 427 436 /* Optional */ 428 rc = VMXWriteVMCS64(VMX_VMCS_CTRL_MSR_BITMAP_FULL, pVM->hwaccm.s.vmx.pMSRBitmapPhys); 437 rc = VMXWriteVMCS(VMX_VMCS_CTRL_MSR_BITMAP_FULL, pVM->hwaccm.s.vmx.pMSRBitmapPhys); 438 #if HC_ARCH_BITS == 32 439 rc |= VMXWriteVMCS(VMX_VMCS_CTRL_MSR_BITMAP_HIGH, pVM->hwaccm.s.vmx.pMSRBitmapPhys >> 32ULL); 440 #endif 429 441 AssertRC(rc); 430 442 } 431 443 432 444 /* Clear MSR controls. */ 433 rc = VMXWriteVMCS64(VMX_VMCS_CTRL_VMEXIT_MSR_STORE_FULL, 0); 434 rc |= VMXWriteVMCS64(VMX_VMCS_CTRL_VMEXIT_MSR_LOAD_FULL, 0); 435 rc |= VMXWriteVMCS64(VMX_VMCS_CTRL_VMENTRY_MSR_LOAD_FULL, 0); 445 rc = VMXWriteVMCS(VMX_VMCS_CTRL_VMEXIT_MSR_STORE_FULL, 0); 446 rc |= VMXWriteVMCS(VMX_VMCS_CTRL_VMEXIT_MSR_LOAD_FULL, 0); 447 rc |= VMXWriteVMCS(VMX_VMCS_CTRL_VMENTRY_MSR_LOAD_FULL, 0); 448 #if HC_ARCH_BITS == 32 449 rc |= VMXWriteVMCS(VMX_VMCS_CTRL_VMEXIT_MSR_STORE_HIGH, 0); 450 rc |= VMXWriteVMCS(VMX_VMCS_CTRL_VMEXIT_MSR_LOAD_HIGH, 0); 451 rc |= VMXWriteVMCS(VMX_VMCS_CTRL_VMEXIT_MSR_LOAD_HIGH, 0); 452 #endif 436 453 rc |= VMXWriteVMCS(VMX_VMCS_CTRL_EXIT_MSR_STORE_COUNT, 0); 437 454 rc |= VMXWriteVMCS(VMX_VMCS_CTRL_EXIT_MSR_LOAD_COUNT, 0); … … 443 460 /* Optional */ 444 461 rc = VMXWriteVMCS(VMX_VMCS_CTRL_TPR_THRESHOLD, 0); 445 rc |= VMXWriteVMCS64(VMX_VMCS_CTRL_VAPIC_PAGEADDR_FULL, pVM->hwaccm.s.vmx.pAPICPhys); 462 rc |= VMXWriteVMCS(VMX_VMCS_CTRL_VAPIC_PAGEADDR_FULL, pVM->hwaccm.s.vmx.pAPICPhys); 463 #if HC_ARCH_BITS == 32 464 rc |= VMXWriteVMCS(VMX_VMCS_CTRL_VAPIC_PAGEADDR_HIGH, pVM->hwaccm.s.vmx.pAPICPhys >> 32ULL); 465 #endif 446 466 AssertRC(rc); 447 467 } 448 468 449 469 /* Set link pointer to -1. Not currently used. */ 450 rc = VMXWriteVMCS64(VMX_VMCS_GUEST_LINK_PTR_FULL, 0xFFFFFFFFFFFFFFFF); 470 #if HC_ARCH_BITS == 32 471 rc = VMXWriteVMCS(VMX_VMCS_GUEST_LINK_PTR_FULL, 0xFFFFFFFF); 472 rc |= VMXWriteVMCS(VMX_VMCS_GUEST_LINK_PTR_HIGH, 0xFFFFFFFF); 473 #else 474 rc = VMXWriteVMCS(VMX_VMCS_GUEST_LINK_PTR_FULL, 0xFFFFFFFFFFFFFFFF); 475 #endif 451 476 AssertRC(rc); 452 477 … … 883 908 { 884 909 Pdpe = PGMGstGetPaePDPtr(pVM, i); 885 int rc = VMXWriteVMCS64(VMX_VMCS_GUEST_PDPTR0_FULL + i*2, Pdpe.u); 910 int rc = VMXWriteVMCS(VMX_VMCS_GUEST_PDPTR0_FULL + i*2, Pdpe.u); 911 #if HC_ARCH_BITS == 32 912 rc |= VMXWriteVMCS(VMX_VMCS_GUEST_PDPTR0_FULL + i*2 + 1, Pdpe.u >> 32ULL); 913 #endif 886 914 AssertRC(rc); 887 915 } … … 949 977 { 950 978 int rc = VINF_SUCCESS; 951 uint64_t val64;952 X86RFLAGS rflags;953 979 RTGCUINTPTR val; 980 X86EFLAGS eflags; 954 981 955 982 /* Guest CPU context: ES, CS, SS, DS, FS, GS. */ … … 1032 1059 rc = VMXWriteVMCS(VMX_VMCS16_GUEST_FIELD_LDTR, 0); 1033 1060 rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_LDTR_LIMIT, 0); 1034 rc |= VMXWriteVMCS 64(VMX_VMCS64_GUEST_LDTR_BASE,0);1061 rc |= VMXWriteVMCS(VMX_VMCS_GUEST_LDTR_BASE, 0); 1035 1062 /* Note: vmlaunch will fail with 0 or just 0x02. No idea why. */ 1036 1063 rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_LDTR_ACCESS_RIGHTS, 0x82 /* present, LDT */); … … 1040 1067 rc = VMXWriteVMCS(VMX_VMCS16_GUEST_FIELD_LDTR, pCtx->ldtr); 1041 1068 rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_LDTR_LIMIT, pCtx->ldtrHid.u32Limit); 1042 rc |= VMXWriteVMCS 64(VMX_VMCS64_GUEST_LDTR_BASE,pCtx->ldtrHid.u64Base);1069 rc |= VMXWriteVMCS(VMX_VMCS_GUEST_LDTR_BASE, pCtx->ldtrHid.u64Base); 1043 1070 rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_LDTR_ACCESS_RIGHTS, pCtx->ldtrHid.Attr.u); 1044 1071 } … … 1058 1085 AssertRC(rc); 1059 1086 1060 rc = VMXWriteVMCS(VMX_VMCS16_GUEST_FIELD_TR, 0);1061 rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_TR_LIMIT, HWACCM_VTX_TSS_SIZE);1062 rc |= VMXWriteVMCS 64(VMX_VMCS64_GUEST_TR_BASE,GCPhys /* phys = virt in this mode */);1087 rc = VMXWriteVMCS(VMX_VMCS16_GUEST_FIELD_TR, 0); 1088 rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_TR_LIMIT, HWACCM_VTX_TSS_SIZE); 1089 rc |= VMXWriteVMCS(VMX_VMCS_GUEST_TR_BASE, GCPhys /* phys = virt in this mode */); 1063 1090 1064 1091 X86DESCATTR attr; … … 1072 1099 #endif /* HWACCM_VMX_EMULATE_REALMODE */ 1073 1100 { 1074 rc = VMXWriteVMCS(VMX_VMCS16_GUEST_FIELD_TR, pCtx->tr);1075 rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_TR_LIMIT, pCtx->trHid.u32Limit);1076 rc |= VMXWriteVMCS 64(VMX_VMCS64_GUEST_TR_BASE,pCtx->trHid.u64Base);1101 rc = VMXWriteVMCS(VMX_VMCS16_GUEST_FIELD_TR, pCtx->tr); 1102 rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_TR_LIMIT, pCtx->trHid.u32Limit); 1103 rc |= VMXWriteVMCS(VMX_VMCS_GUEST_TR_BASE, pCtx->trHid.u64Base); 1077 1104 1078 1105 val = pCtx->trHid.Attr.u; … … 1092 1119 if (pVCpu->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_GUEST_GDTR) 1093 1120 { 1094 rc = VMXWriteVMCS(VMX_VMCS32_GUEST_GDTR_LIMIT, pCtx->gdtr.cbGdt);1095 rc |= VMXWriteVMCS 64(VMX_VMCS64_GUEST_GDTR_BASE,pCtx->gdtr.pGdt);1121 rc = VMXWriteVMCS(VMX_VMCS32_GUEST_GDTR_LIMIT, pCtx->gdtr.cbGdt); 1122 rc |= VMXWriteVMCS(VMX_VMCS_GUEST_GDTR_BASE, pCtx->gdtr.pGdt); 1096 1123 AssertRC(rc); 1097 1124 } … … 1099 1126 if (pVCpu->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_GUEST_IDTR) 1100 1127 { 1101 rc = VMXWriteVMCS(VMX_VMCS32_GUEST_IDTR_LIMIT, pCtx->idtr.cbIdt);1102 rc |= VMXWriteVMCS 64(VMX_VMCS64_GUEST_IDTR_BASE,pCtx->idtr.pIdt);1128 rc = VMXWriteVMCS(VMX_VMCS32_GUEST_IDTR_LIMIT, pCtx->idtr.cbIdt); 1129 rc |= VMXWriteVMCS(VMX_VMCS_GUEST_IDTR_BASE, pCtx->idtr.pIdt); 1103 1130 AssertRC(rc); 1104 1131 } … … 1107 1134 * Sysenter MSRs (unconditional) 1108 1135 */ 1109 rc = VMXWriteVMCS(VMX_VMCS32_GUEST_SYSENTER_CS, pCtx->SysEnter.cs);1110 rc |= VMXWriteVMCS 64(VMX_VMCS64_GUEST_SYSENTER_EIP, pCtx->SysEnter.eip);1111 rc |= VMXWriteVMCS 64(VMX_VMCS64_GUEST_SYSENTER_ESP, pCtx->SysEnter.esp);1136 rc = VMXWriteVMCS(VMX_VMCS32_GUEST_SYSENTER_CS, pCtx->SysEnter.cs); 1137 rc |= VMXWriteVMCS(VMX_VMCS_GUEST_SYSENTER_EIP, pCtx->SysEnter.eip); 1138 rc |= VMXWriteVMCS(VMX_VMCS_GUEST_SYSENTER_ESP, pCtx->SysEnter.esp); 1112 1139 AssertRC(rc); 1113 1140 … … 1115 1142 if (pVCpu->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_GUEST_CR0) 1116 1143 { 1117 val 64= pCtx->cr0;1118 rc = VMXWriteVMCS 64(VMX_VMCS64_CTRL_CR0_READ_SHADOW, val64);1119 Log2(("Guest CR0-shadow % RX64\n", val64));1144 val = pCtx->cr0; 1145 rc = VMXWriteVMCS(VMX_VMCS_CTRL_CR0_READ_SHADOW, val); 1146 Log2(("Guest CR0-shadow %08x\n", val)); 1120 1147 if (CPUMIsGuestFPUStateActive(pVCpu) == false) 1121 1148 { 1122 1149 /* Always use #NM exceptions to load the FPU/XMM state on demand. */ 1123 val 64|= X86_CR0_TS | X86_CR0_ET | X86_CR0_NE | X86_CR0_MP;1150 val |= X86_CR0_TS | X86_CR0_ET | X86_CR0_NE | X86_CR0_MP; 1124 1151 } 1125 1152 else 1126 1153 { 1127 1154 /** @todo check if we support the old style mess correctly. */ 1128 if (!(val 64& X86_CR0_NE))1155 if (!(val & X86_CR0_NE)) 1129 1156 Log(("Forcing X86_CR0_NE!!!\n")); 1130 1157 1131 val 64|= X86_CR0_NE; /* always turn on the native mechanism to report FPU errors (old style uses interrupts) */1158 val |= X86_CR0_NE; /* always turn on the native mechanism to report FPU errors (old style uses interrupts) */ 1132 1159 } 1133 1160 /* Note: protected mode & paging are always enabled; we use them for emulating real and protected mode without paging too. */ 1134 val 64|= X86_CR0_PE | X86_CR0_PG;1161 val |= X86_CR0_PE | X86_CR0_PG; 1135 1162 if (pVM->hwaccm.s.fNestedPaging) 1136 1163 { … … 1153 1180 { 1154 1181 /* Note: We must also set this as we rely on protecting various pages for which supervisor writes must be caught. */ 1155 val 64|= X86_CR0_WP;1182 val |= X86_CR0_WP; 1156 1183 } 1157 1184 1158 1185 /* Always enable caching. */ 1159 val 64&= ~(X86_CR0_CD|X86_CR0_NW);1160 1161 rc |= VMXWriteVMCS 64(VMX_VMCS64_GUEST_CR0, val64);1162 Log2(("Guest CR0 % RX64\n", val64));1186 val &= ~(X86_CR0_CD|X86_CR0_NW); 1187 1188 rc |= VMXWriteVMCS(VMX_VMCS_GUEST_CR0, val); 1189 Log2(("Guest CR0 %08x\n", val)); 1163 1190 /* CR0 flags owned by the host; if the guests attempts to change them, then 1164 1191 * the VM will exit. 1165 1192 */ 1166 val 64= X86_CR0_PE /* Must monitor this bit (assumptions are made for real mode emulation) */1167 | X86_CR0_WP /* Must monitor this bit (it must always be enabled). */1168 | X86_CR0_PG /* Must monitor this bit (assumptions are made for real mode & protected mode without paging emulation) */1169 | X86_CR0_TS1170 | X86_CR0_ET /* Bit not restored during VM-exit! */1171 | X86_CR0_CD /* Bit not restored during VM-exit! */1172 | X86_CR0_NW /* Bit not restored during VM-exit! */1173 | X86_CR0_NE1174 | X86_CR0_MP;1175 pVCpu->hwaccm.s.vmx.cr0_mask = val 64;1176 1177 rc |= VMXWriteVMCS 64(VMX_VMCS64_CTRL_CR0_MASK, val64);1178 Log2(("Guest CR0-mask % RX64\n", val64));1193 val = X86_CR0_PE /* Must monitor this bit (assumptions are made for real mode emulation) */ 1194 | X86_CR0_WP /* Must monitor this bit (it must always be enabled). */ 1195 | X86_CR0_PG /* Must monitor this bit (assumptions are made for real mode & protected mode without paging emulation) */ 1196 | X86_CR0_TS 1197 | X86_CR0_ET /* Bit not restored during VM-exit! */ 1198 | X86_CR0_CD /* Bit not restored during VM-exit! */ 1199 | X86_CR0_NW /* Bit not restored during VM-exit! */ 1200 | X86_CR0_NE 1201 | X86_CR0_MP; 1202 pVCpu->hwaccm.s.vmx.cr0_mask = val; 1203 1204 rc |= VMXWriteVMCS(VMX_VMCS_CTRL_CR0_MASK, val); 1205 Log2(("Guest CR0-mask %08x\n", val)); 1179 1206 AssertRC(rc); 1180 1207 } … … 1182 1209 { 1183 1210 /* CR4 */ 1184 rc = VMXWriteVMCS 64(VMX_VMCS64_CTRL_CR4_READ_SHADOW, pCtx->cr4);1185 Log2(("Guest CR4-shadow % RX64\n", pCtx->cr4));1211 rc = VMXWriteVMCS(VMX_VMCS_CTRL_CR4_READ_SHADOW, pCtx->cr4); 1212 Log2(("Guest CR4-shadow %08x\n", pCtx->cr4)); 1186 1213 /* Set the required bits in cr4 too (currently X86_CR4_VMXE). */ 1187 val 64= pCtx->cr4 | (uint32_t)pVM->hwaccm.s.vmx.msr.vmx_cr4_fixed0;1214 val = pCtx->cr4 | (uint32_t)pVM->hwaccm.s.vmx.msr.vmx_cr4_fixed0; 1188 1215 1189 1216 if (!pVM->hwaccm.s.fNestedPaging) … … 1199 1226 case PGMMODE_PAE_NX: /* PAE paging with NX enabled. */ 1200 1227 /** @todo use normal 32 bits paging */ 1201 val 64|= X86_CR4_PAE;1228 val |= X86_CR4_PAE; 1202 1229 break; 1203 1230 … … 1219 1246 { 1220 1247 /* We use 4 MB pages in our identity mapping page table for real and protected mode without paging. */ 1221 val 64|= X86_CR4_PSE;1248 val |= X86_CR4_PSE; 1222 1249 /* Our identity mapping is a 32 bits page directory. */ 1223 val 64&= ~X86_CR4_PAE;1250 val &= ~X86_CR4_PAE; 1224 1251 } 1225 1252 … … 1227 1254 /* Real mode emulation using v86 mode with CR4.VME (interrupt redirection using the int bitmap in the TSS) */ 1228 1255 if (CPUMIsGuestInRealModeEx(pCtx)) 1229 val 64|= X86_CR4_VME;1256 val |= X86_CR4_VME; 1230 1257 #endif /* HWACCM_VMX_EMULATE_REALMODE */ 1231 1258 1232 rc |= VMXWriteVMCS 64(VMX_VMCS64_GUEST_CR4, val64);1233 Log2(("Guest CR4 %08x\n", val 64));1259 rc |= VMXWriteVMCS(VMX_VMCS_GUEST_CR4, val); 1260 Log2(("Guest CR4 %08x\n", val)); 1234 1261 /* CR4 flags owned by the host; if the guests attempts to change them, then 1235 1262 * the VM will exit. 1236 1263 */ 1237 val 64= 01264 val = 0 1238 1265 #ifdef HWACCM_VMX_EMULATE_REALMODE 1239 1266 | X86_CR4_VME … … 1243 1270 | X86_CR4_PSE 1244 1271 | X86_CR4_VMXE; 1245 pVCpu->hwaccm.s.vmx.cr4_mask = val 64;1246 1247 rc |= VMXWriteVMCS 64(VMX_VMCS64_CTRL_CR4_MASK, val64);1248 Log2(("Guest CR4-mask % RX64\n", val64));1272 pVCpu->hwaccm.s.vmx.cr4_mask = val; 1273 1274 rc |= VMXWriteVMCS(VMX_VMCS_CTRL_CR4_MASK, val); 1275 Log2(("Guest CR4-mask %08x\n", val)); 1249 1276 AssertRC(rc); 1250 1277 } … … 1262 1289 | (VMX_EPT_PAGE_WALK_LENGTH_DEFAULT << VMX_EPT_PAGE_WALK_LENGTH_SHIFT); 1263 1290 1264 rc = VMXWriteVMCS64(VMX_VMCS_CTRL_EPTP_FULL, pVCpu->hwaccm.s.vmx.GCPhysEPTP); 1291 rc = VMXWriteVMCS(VMX_VMCS_CTRL_EPTP_FULL, pVCpu->hwaccm.s.vmx.GCPhysEPTP); 1292 #if HC_ARCH_BITS == 32 1293 rc = VMXWriteVMCS(VMX_VMCS_CTRL_EPTP_HIGH, (uint32_t)(pVCpu->hwaccm.s.vmx.GCPhysEPTP >> 32ULL)); 1294 #endif 1265 1295 AssertRC(rc); 1266 1296 … … 1276 1306 * take care of the translation to host physical addresses. 1277 1307 */ 1278 val 64= GCPhys;1308 val = GCPhys; 1279 1309 } 1280 1310 else 1281 1311 { 1282 1312 /* Save the real guest CR3 in VMX_VMCS_GUEST_CR3 */ 1283 val 64= pCtx->cr3;1313 val = pCtx->cr3; 1284 1314 /* Prefetch the four PDPT entries in PAE mode. */ 1285 1315 vmxR0PrefetchPAEPdptrs(pVM, pCtx); … … 1288 1318 else 1289 1319 { 1290 val 64= PGMGetHyperCR3(pVM);1291 Assert(val 64);1320 val = PGMGetHyperCR3(pVM); 1321 Assert(val); 1292 1322 } 1293 1323 1294 1324 /* Save our shadow CR3 register. */ 1295 rc = VMXWriteVMCS 64(VMX_VMCS64_GUEST_CR3, val64);1325 rc = VMXWriteVMCS(VMX_VMCS_GUEST_CR3, val); 1296 1326 AssertRC(rc); 1297 1327 } … … 1308 1338 1309 1339 /* Resync DR7 */ 1310 rc = VMXWriteVMCS 64(VMX_VMCS64_GUEST_DR7, pCtx->dr[7]);1340 rc = VMXWriteVMCS(VMX_VMCS_GUEST_DR7, pCtx->dr[7]); 1311 1341 AssertRC(rc); 1312 1342 … … 1329 1359 1330 1360 /* IA32_DEBUGCTL MSR. */ 1331 rc = VMXWriteVMCS64(VMX_VMCS_GUEST_DEBUGCTL_FULL, 0); 1361 rc = VMXWriteVMCS(VMX_VMCS_GUEST_DEBUGCTL_FULL, 0); 1362 rc |= VMXWriteVMCS(VMX_VMCS_GUEST_DEBUGCTL_HIGH, 0); 1332 1363 AssertRC(rc); 1333 1364 1334 1365 /** @todo do we really ever need this? */ 1335 rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_DEBUG_EXCEPTIONS,0);1366 rc |= VMXWriteVMCS(VMX_VMCS_GUEST_DEBUG_EXCEPTIONS, 0); 1336 1367 AssertRC(rc); 1337 1368 } 1338 1369 1339 1370 /* EIP, ESP and EFLAGS */ 1340 rc = VMXWriteVMCS 64(VMX_VMCS64_GUEST_RIP, pCtx->rip);1341 rc |= VMXWriteVMCS 64(VMX_VMCS64_GUEST_RSP, pCtx->rsp);1371 rc = VMXWriteVMCS(VMX_VMCS_GUEST_RIP, pCtx->rip); 1372 rc |= VMXWriteVMCS(VMX_VMCS_GUEST_RSP, pCtx->rsp); 1342 1373 AssertRC(rc); 1343 1374 1344 1375 /* Bits 22-31, 15, 5 & 3 must be zero. Bit 1 must be 1. */ 1345 rflags = pCtx->rflags;1346 rflags.u64&= VMX_EFLAGS_RESERVED_0;1347 rflags.u64|= VMX_EFLAGS_RESERVED_1;1376 eflags = pCtx->eflags; 1377 eflags.u32 &= VMX_EFLAGS_RESERVED_0; 1378 eflags.u32 |= VMX_EFLAGS_RESERVED_1; 1348 1379 1349 1380 #ifdef HWACCM_VMX_EMULATE_REALMODE … … 1351 1382 if (CPUMIsGuestInRealModeEx(pCtx)) 1352 1383 { 1353 pVCpu->hwaccm.s.vmx.RealMode. rflags = rflags;1354 1355 rflags.Bits.u1VM = 1;1356 rflags.Bits.u2IOPL = 3;1384 pVCpu->hwaccm.s.vmx.RealMode.eflags = eflags; 1385 1386 eflags.Bits.u1VM = 1; 1387 eflags.Bits.u2IOPL = 3; 1357 1388 } 1358 1389 #endif /* HWACCM_VMX_EMULATE_REALMODE */ 1359 rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_RFLAGS, rflags.u64);1390 rc = VMXWriteVMCS(VMX_VMCS_GUEST_RFLAGS, eflags.u32); 1360 1391 AssertRC(rc); 1361 1392 … … 1366 1397 { 1367 1398 /* Note: VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_RDTSC_EXIT takes precedence over TSC_OFFSET */ 1368 rc = VMXWriteVMCS64(VMX_VMCS_CTRL_TSC_OFFSET_FULL, u64TSCOffset); 1399 rc = VMXWriteVMCS(VMX_VMCS_CTRL_TSC_OFFSET_FULL, u64TSCOffset); 1400 #if HC_ARCH_BITS == 32 1401 rc |= VMXWriteVMCS(VMX_VMCS_CTRL_TSC_OFFSET_HIGH, (uint32_t)(u64TSCOffset >> 32ULL)); 1402 #endif 1369 1403 AssertRC(rc); 1370 1404 … … 1408 1442 #endif 1409 1443 /* Unconditionally update these as wrmsr might have changed them. */ 1410 rc = VMXWriteVMCS 64(VMX_VMCS64_GUEST_FS_BASE, pCtx->fsHid.u64Base);1411 AssertRC(rc); 1412 rc = VMXWriteVMCS 64(VMX_VMCS64_GUEST_GS_BASE, pCtx->gsHid.u64Base);1444 rc = VMXWriteVMCS(VMX_VMCS_GUEST_FS_BASE, pCtx->fsHid.u64Base); 1445 AssertRC(rc); 1446 rc = VMXWriteVMCS(VMX_VMCS_GUEST_GS_BASE, pCtx->gsHid.u64Base); 1413 1447 AssertRC(rc); 1414 1448 } … … 1436 1470 DECLINLINE(int) VMXR0SaveGuestState(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx) 1437 1471 { 1438 uint64_t val64, u64Shadow; 1439 RTHCUINTPTR val; 1440 RTHCUINTPTR uInterruptState; 1472 RTCCUINTREG val, valShadow; 1473 RTGCUINTPTR uInterruptState; 1441 1474 int rc; 1442 1475 1443 1476 /* Let's first sync back eip, esp, and eflags. */ 1444 rc = VMXReadVMCS 64(VMX_VMCS64_GUEST_RIP, &pCtx->rip);1477 rc = VMXReadVMCS(VMX_VMCS_GUEST_RIP, &val); 1445 1478 AssertRC(rc); 1446 rc = VMXReadVMCS64(VMX_VMCS64_GUEST_RSP, &pCtx->rsp); 1479 pCtx->rip = val; 1480 rc = VMXReadVMCS(VMX_VMCS_GUEST_RSP, &val); 1447 1481 AssertRC(rc); 1448 rc = VMXReadVMCS64(VMX_VMCS64_GUEST_RFLAGS, &pCtx->rflags.u64); 1482 pCtx->rsp = val; 1483 rc = VMXReadVMCS(VMX_VMCS_GUEST_RFLAGS, &val); 1449 1484 AssertRC(rc); 1485 pCtx->eflags.u32 = val; 1450 1486 1451 1487 /* Take care of instruction fusing (sti, mov ss) */ 1452 rc |= VMXReadVMCS(VMX_VMCS32_GUEST_INTERRUPTIBILITY_STATE, &uInterruptState); 1488 rc |= VMXReadVMCS(VMX_VMCS32_GUEST_INTERRUPTIBILITY_STATE, &val); 1489 uInterruptState = val; 1453 1490 if (uInterruptState != 0) 1454 1491 { … … 1461 1498 1462 1499 /* Control registers. */ 1463 VMXReadVMCS 64(VMX_VMCS64_CTRL_CR0_READ_SHADOW, &u64Shadow);1464 VMXReadVMCS 64(VMX_VMCS64_GUEST_CR0, &val64);1465 val 64 = (u64Shadow & pVCpu->hwaccm.s.vmx.cr0_mask) | (val64& ~pVCpu->hwaccm.s.vmx.cr0_mask);1466 CPUMSetGuestCR0(pVM, val 64);1467 1468 VMXReadVMCS 64(VMX_VMCS64_CTRL_CR4_READ_SHADOW, &u64Shadow);1469 VMXReadVMCS 64(VMX_VMCS64_GUEST_CR4, &val64);1470 val 64 = (u64Shadow & pVCpu->hwaccm.s.vmx.cr4_mask) | (val64& ~pVCpu->hwaccm.s.vmx.cr4_mask);1471 CPUMSetGuestCR4(pVM, val 64);1500 VMXReadVMCS(VMX_VMCS_CTRL_CR0_READ_SHADOW, &valShadow); 1501 VMXReadVMCS(VMX_VMCS_GUEST_CR0, &val); 1502 val = (valShadow & pVCpu->hwaccm.s.vmx.cr0_mask) | (val & ~pVCpu->hwaccm.s.vmx.cr0_mask); 1503 CPUMSetGuestCR0(pVM, val); 1504 1505 VMXReadVMCS(VMX_VMCS_CTRL_CR4_READ_SHADOW, &valShadow); 1506 VMXReadVMCS(VMX_VMCS_GUEST_CR4, &val); 1507 val = (valShadow & pVCpu->hwaccm.s.vmx.cr4_mask) | (val & ~pVCpu->hwaccm.s.vmx.cr4_mask); 1508 CPUMSetGuestCR4(pVM, val); 1472 1509 1473 1510 /* Note: no reason to sync back the CRx registers. They can't be changed by the guest. */ … … 1479 1516 CPUMSetGuestCR2(pVM, ASMGetCR2()); 1480 1517 1481 VMXReadVMCS 64(VMX_VMCS64_GUEST_CR3, &val64);1482 1483 if (val 64!= pCtx->cr3)1484 { 1485 CPUMSetGuestCR3(pVM, val 64);1486 PGMUpdateCR3(pVM, val 64);1518 VMXReadVMCS(VMX_VMCS_GUEST_CR3, &val); 1519 1520 if (val != pCtx->cr3) 1521 { 1522 CPUMSetGuestCR3(pVM, val); 1523 PGMUpdateCR3(pVM, val); 1487 1524 } 1488 1525 /* Prefetch the four PDPT entries in PAE mode. */ … … 1491 1528 1492 1529 /* Sync back DR7 here. */ 1493 VMXReadVMCS64(VMX_VMCS64_GUEST_DR7, &pCtx->dr[7]); 1530 VMXReadVMCS(VMX_VMCS_GUEST_DR7, &val); 1531 pCtx->dr[7] = val; 1494 1532 1495 1533 /* Guest CPU context: ES, CS, SS, DS, FS, GS. */ … … 1504 1542 * System MSRs 1505 1543 */ 1506 VMXReadVMCS(VMX_VMCS32_GUEST_SYSENTER_CS, &val);1544 VMXReadVMCS(VMX_VMCS32_GUEST_SYSENTER_CS, &val); 1507 1545 pCtx->SysEnter.cs = val; 1508 VMXReadVMCS64(VMX_VMCS64_GUEST_SYSENTER_EIP, &pCtx->SysEnter.eip); 1509 VMXReadVMCS64(VMX_VMCS64_GUEST_SYSENTER_ESP, &pCtx->SysEnter.esp); 1546 VMXReadVMCS(VMX_VMCS_GUEST_SYSENTER_EIP, &val); 1547 pCtx->SysEnter.eip = val; 1548 VMXReadVMCS(VMX_VMCS_GUEST_SYSENTER_ESP, &val); 1549 pCtx->SysEnter.esp = val; 1510 1550 1511 1551 /* Misc. registers; must sync everything otherwise we can get out of sync when jumping to ring 3. */ 1512 1552 VMX_READ_SELREG(LDTR, ldtr); 1513 1553 1514 VMXReadVMCS(VMX_VMCS32_GUEST_GDTR_LIMIT, &val);1554 VMXReadVMCS(VMX_VMCS32_GUEST_GDTR_LIMIT, &val); 1515 1555 pCtx->gdtr.cbGdt = val; 1516 VMXReadVMCS64(VMX_VMCS64_GUEST_GDTR_BASE, &pCtx->gdtr.pGdt); 1517 1518 VMXReadVMCS(VMX_VMCS32_GUEST_IDTR_LIMIT, &val); 1556 VMXReadVMCS(VMX_VMCS_GUEST_GDTR_BASE, &val); 1557 pCtx->gdtr.pGdt = val; 1558 1559 VMXReadVMCS(VMX_VMCS32_GUEST_IDTR_LIMIT, &val); 1519 1560 pCtx->idtr.cbIdt = val; 1520 VMXReadVMCS64(VMX_VMCS64_GUEST_IDTR_BASE, &pCtx->idtr.pIdt); 1561 VMXReadVMCS(VMX_VMCS_GUEST_IDTR_BASE, &val); 1562 pCtx->idtr.pIdt = val; 1521 1563 1522 1564 #ifdef HWACCM_VMX_EMULATE_REALMODE … … 1526 1568 /* Hide our emulation flags */ 1527 1569 pCtx->eflags.Bits.u1VM = 0; 1528 pCtx->eflags.Bits.u2IOPL = pVCpu->hwaccm.s.vmx.RealMode. rflags.Bits.u2IOPL;1570 pCtx->eflags.Bits.u2IOPL = pVCpu->hwaccm.s.vmx.RealMode.eflags.Bits.u2IOPL; 1529 1571 1530 1572 /* Force a TR resync every time in case we switch modes. */ … … 1683 1725 int rc = VINF_SUCCESS; 1684 1726 RTCCUINTREG val; 1685 uint64_t val64;1686 1727 RTCCUINTREG exitReason, instrError, cbInstr; 1687 uint64_texitQualification;1728 RTGCUINTPTR exitQualification; 1688 1729 RTGCUINTPTR intInfo = 0; /* shut up buggy gcc 4 */ 1689 1730 RTGCUINTPTR errCode, instrInfo; … … 1964 2005 rc |= VMXReadVMCS(VMX_VMCS32_RO_EXIT_INSTR_INFO, &val); 1965 2006 instrInfo = val; 1966 rc |= VMXReadVMCS64(VMX_VMCS64_RO_EXIT_QUALIFICATION, &exitQualification); 2007 rc |= VMXReadVMCS(VMX_VMCS_RO_EXIT_QUALIFICATION, &val); 2008 exitQualification = val; 1967 2009 AssertRC(rc); 1968 2010 … … 2214 2256 2215 2257 /* Resync DR7 */ 2216 rc = VMXWriteVMCS 64(VMX_VMCS64_GUEST_DR7, pCtx->dr[7]);2258 rc = VMXWriteVMCS(VMX_VMCS_GUEST_DR7, pCtx->dr[7]); 2217 2259 AssertRC(rc); 2218 2260 … … 2331 2373 Assert(pVM->hwaccm.s.fNestedPaging); 2332 2374 2333 rc = VMXReadVMCS64(VMX_VMCS_EXIT_PHYS_ADDR_FULL, &GCPhys); 2334 AssertRC(rc); 2375 #if HC_ARCH_BITS == 64 2376 rc = VMXReadVMCS(VMX_VMCS_EXIT_PHYS_ADDR_FULL, &GCPhys); 2377 AssertRC(rc); 2378 #else 2379 uint32_t val_hi; 2380 rc = VMXReadVMCS(VMX_VMCS_EXIT_PHYS_ADDR_FULL, &val); 2381 AssertRC(rc); 2382 rc = VMXReadVMCS(VMX_VMCS_EXIT_PHYS_ADDR_HIGH, &val_hi); 2383 AssertRC(rc); 2384 GCPhys = RT_MAKE_U64(val, val_hi); 2385 #endif 2335 2386 2336 2387 Assert(((exitQualification >> 7) & 3) != 2); … … 2384 2435 Assert(pVM->hwaccm.s.fNestedPaging); 2385 2436 2386 rc = VMXReadVMCS64(VMX_VMCS_EXIT_PHYS_ADDR_FULL, &GCPhys); 2387 AssertRC(rc); 2437 #if HC_ARCH_BITS == 64 2438 rc = VMXReadVMCS(VMX_VMCS_EXIT_PHYS_ADDR_FULL, &GCPhys); 2439 AssertRC(rc); 2440 #else 2441 uint32_t val_hi; 2442 rc = VMXReadVMCS(VMX_VMCS_EXIT_PHYS_ADDR_FULL, &val); 2443 AssertRC(rc); 2444 rc = VMXReadVMCS(VMX_VMCS_EXIT_PHYS_ADDR_HIGH, &val_hi); 2445 AssertRC(rc); 2446 GCPhys = RT_MAKE_U64(val, val_hi); 2447 #endif 2388 2448 2389 2449 Log(("VMX_EXIT_EPT_MISCONFIG for %VGp\n", GCPhys)); … … 2743 2803 2744 2804 /* Resync DR7 */ 2745 rc = VMXWriteVMCS 64(VMX_VMCS64_GUEST_DR7, pCtx->dr[7]);2805 rc = VMXWriteVMCS(VMX_VMCS_GUEST_DR7, pCtx->dr[7]); 2746 2806 AssertRC(rc); 2747 2807 … … 2891 2951 Log(("VMX_EXIT_ERR_INVALID_GUEST_STATE\n")); 2892 2952 2893 VMXReadVMCS 64(VMX_VMCS64_GUEST_RIP, &val64);2894 Log(("Old eip %RGv new %RGv\n", (RTGCPTR)pCtx->rip, (RTGCPTR)val 64));2895 2896 VMXReadVMCS 64(VMX_VMCS64_GUEST_CR0, &val64);2897 Log(("VMX_VMCS 64_GUEST_CR0 %RX64\n", val64));2898 2899 VMXReadVMCS 64(VMX_VMCS64_GUEST_CR3, &val64);2900 Log(("VMX_VMCS 64_GUEST_CR3 %RGp\n", val64));2901 2902 VMXReadVMCS 64(VMX_VMCS64_GUEST_CR4, &val64);2903 Log(("VMX_VMCS 64_GUEST_CR4 %RX64\n", val64));2904 2905 VMXReadVMCS 64(VMX_VMCS64_GUEST_RFLAGS, &val64);2906 Log(("VMX_VMCS 64_GUEST_RFLAGS %08x\n", val64));2953 VMXReadVMCS(VMX_VMCS_GUEST_RIP, &val); 2954 Log(("Old eip %RGv new %RGv\n", (RTGCPTR)pCtx->rip, (RTGCPTR)val)); 2955 2956 VMXReadVMCS(VMX_VMCS_GUEST_CR0, &val); 2957 Log(("VMX_VMCS_GUEST_CR0 %RX64\n", val)); 2958 2959 VMXReadVMCS(VMX_VMCS_GUEST_CR3, &val); 2960 Log(("VMX_VMCS_GUEST_CR3 %RGp\n", val)); 2961 2962 VMXReadVMCS(VMX_VMCS_GUEST_CR4, &val); 2963 Log(("VMX_VMCS_GUEST_CR4 %RX64\n", val)); 2964 2965 VMXReadVMCS(VMX_VMCS_GUEST_RFLAGS, &val); 2966 Log(("VMX_VMCS_GUEST_RFLAGS %08x\n", val)); 2907 2967 2908 2968 VMX_LOG_SELREG(CS, "CS"); … … 2915 2975 VMX_LOG_SELREG(LDTR, "LDTR"); 2916 2976 2917 VMXReadVMCS 64(VMX_VMCS64_GUEST_GDTR_BASE, &val64);2918 Log(("VMX_VMCS 64_GUEST_GDTR_BASE %RGv\n", (RTGCPTR)val64));2919 VMXReadVMCS 64(VMX_VMCS64_GUEST_IDTR_BASE, &val64);2920 Log(("VMX_VMCS 64_GUEST_IDTR_BASE %RGv\n", (RTGCPTR)val64));2977 VMXReadVMCS(VMX_VMCS_GUEST_GDTR_BASE, &val); 2978 Log(("VMX_VMCS_GUEST_GDTR_BASE %RGv\n", val)); 2979 VMXReadVMCS(VMX_VMCS_GUEST_IDTR_BASE, &val); 2980 Log(("VMX_VMCS_GUEST_IDTR_BASE %RGv\n", val)); 2921 2981 #endif /* VBOX_STRICT */ 2922 2982 rc = VERR_VMX_INVALID_GUEST_STATE; … … 3153 3213 { 3154 3214 int rc; 3155 RTCCUINTREG exitReason, instrError ;3215 RTCCUINTREG exitReason, instrError, val; 3156 3216 3157 3217 rc = VMXReadVMCS(VMX_VMCS32_RO_EXIT_REASON, &exitReason); … … 3167 3227 3168 3228 #ifdef VBOX_STRICT 3169 RTGDTR gdtr; 3170 PX86DESCHC pDesc; 3171 uint64_t val64; 3172 RTCCUINTREG val; 3229 RTGDTR gdtr; 3230 PX86DESCHC pDesc; 3173 3231 3174 3232 ASMGetGDTR(&gdtr); 3175 3233 3176 VMXReadVMCS 64(VMX_VMCS64_GUEST_RIP, &val64);3177 Log(("Old eip %RGv new %RGv\n", (RTGCPTR)pCtx->rip, (RTGCPTR)val 64));3234 VMXReadVMCS(VMX_VMCS_GUEST_RIP, &val); 3235 Log(("Old eip %RGv new %RGv\n", (RTGCPTR)pCtx->rip, (RTGCPTR)val)); 3178 3236 VMXReadVMCS(VMX_VMCS_CTRL_PIN_EXEC_CONTROLS, &val); 3179 3237 Log(("VMX_VMCS_CTRL_PIN_EXEC_CONTROLS %08x\n", val)); … … 3197 3255 Log(("VMX_VMCS_HOST_FIELD_CS %08x\n", val)); 3198 3256 3199 VMXReadVMCS 64(VMX_VMCS64_GUEST_RFLAGS, &val64);3200 Log(("VMX_VMCS_GUEST_RFLAGS % RX64\n", val64));3257 VMXReadVMCS(VMX_VMCS_GUEST_RFLAGS, &val); 3258 Log(("VMX_VMCS_GUEST_RFLAGS %08x\n", val)); 3201 3259 3202 3260

