VirtualBox

Changeset 14648 in vbox for trunk/src/VBox/VMM


Ignore:
Timestamp:
Nov 26, 2008 2:51:47 PM (16 years ago)
Author:
vboxsync
Message:

Initial work for 64 bits VT-x guests on 32 bits hosts.

Location:
trunk/src/VBox/VMM
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/VMM/HWACCMInternal.h

    r14532 r14648  
    399399        struct
    400400        {
    401             X86EFLAGS                   eflags;
     401            X86RFLAGS                   rflags;
    402402            uint32_t                    fValid;
    403403        } RealMode;

  • trunk/src/VBox/VMM/VMMR0/HWVMXR0.cpp

    r14647 r14648  
    413413
    414414        /* Init TSC offset to zero. */
    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
     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);
    431422        AssertRC(rc);
    432423
    … …  
    435426        {
    436427            /* Optional */
    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
     428            rc  = VMXWriteVMCS64(VMX_VMCS_CTRL_MSR_BITMAP_FULL, pVM->hwaccm.s.vmx.pMSRBitmapPhys);
    441429            AssertRC(rc);
    442430        }
    443431
    444432        /* Clear MSR controls. */
    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
     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);
    453436        rc |= VMXWriteVMCS(VMX_VMCS_CTRL_EXIT_MSR_STORE_COUNT, 0);
    454437        rc |= VMXWriteVMCS(VMX_VMCS_CTRL_EXIT_MSR_LOAD_COUNT, 0);
    … …  
    460443            /* Optional */
    461444            rc  = VMXWriteVMCS(VMX_VMCS_CTRL_TPR_THRESHOLD, 0);
    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
     445            rc |= VMXWriteVMCS64(VMX_VMCS_CTRL_VAPIC_PAGEADDR_FULL, pVM->hwaccm.s.vmx.pAPICPhys);
    466446            AssertRC(rc);
    467447        }
    468448
    469449        /* Set link pointer to -1. Not currently used. */
    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
     450        rc  = VMXWriteVMCS64(VMX_VMCS_GUEST_LINK_PTR_FULL, 0xFFFFFFFFFFFFFFFF);
    476451        AssertRC(rc);
    477452
    … …  
    908883        {
    909884            Pdpe = PGMGstGetPaePDPtr(pVM, i);
    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
     885            int rc = VMXWriteVMCS64(VMX_VMCS_GUEST_PDPTR0_FULL + i*2, Pdpe.u);
    914886            AssertRC(rc);
    915887        }
    … …  
    977949{
    978950    int         rc = VINF_SUCCESS;
     951    uint64_t    val64;
     952    X86RFLAGS   rflags;
    979953    RTGCUINTPTR val;
    980     X86EFLAGS   eflags;
    981954
    982955    /* Guest CPU context: ES, CS, SS, DS, FS, GS. */
    … …  
    10591032            rc =  VMXWriteVMCS(VMX_VMCS16_GUEST_FIELD_LDTR,         0);
    10601033            rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_LDTR_LIMIT,         0);
    1061             rc |= VMXWriteVMCS(VMX_VMCS_GUEST_LDTR_BASE,            0);
     1034            rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_LDTR_BASE,          0);
    10621035            /* Note: vmlaunch will fail with 0 or just 0x02. No idea why. */
    10631036            rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_LDTR_ACCESS_RIGHTS, 0x82 /* present, LDT */);
    … …  
    10671040            rc =  VMXWriteVMCS(VMX_VMCS16_GUEST_FIELD_LDTR,         pCtx->ldtr);
    10681041            rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_LDTR_LIMIT,         pCtx->ldtrHid.u32Limit);
    1069             rc |= VMXWriteVMCS(VMX_VMCS_GUEST_LDTR_BASE,            pCtx->ldtrHid.u64Base);
     1042            rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_LDTR_BASE,          pCtx->ldtrHid.u64Base);
    10701043            rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_LDTR_ACCESS_RIGHTS, pCtx->ldtrHid.Attr.u);
    10711044        }
    … …  
    10851058            AssertRC(rc);
    10861059
    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 */);
     1060            rc =  VMXWriteVMCS(VMX_VMCS16_GUEST_FIELD_TR,           0);
     1061            rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_TR_LIMIT,           HWACCM_VTX_TSS_SIZE);
     1062            rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_TR_BASE,          GCPhys /* phys = virt in this mode */);
    10901063
    10911064            X86DESCATTR attr;
    … …  
    10991072#endif /* HWACCM_VMX_EMULATE_REALMODE */
    11001073        {
    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);
     1074            rc =  VMXWriteVMCS(VMX_VMCS16_GUEST_FIELD_TR,           pCtx->tr);
     1075            rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_TR_LIMIT,           pCtx->trHid.u32Limit);
     1076            rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_TR_BASE,          pCtx->trHid.u64Base);
    11041077
    11051078            val = pCtx->trHid.Attr.u;
    … …  
    11191092    if (pVCpu->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_GUEST_GDTR)
    11201093    {
    1121         rc  = VMXWriteVMCS(VMX_VMCS32_GUEST_GDTR_LIMIT,       pCtx->gdtr.cbGdt);
    1122         rc |= VMXWriteVMCS(VMX_VMCS_GUEST_GDTR_BASE,          pCtx->gdtr.pGdt);
     1094        rc  = VMXWriteVMCS(VMX_VMCS32_GUEST_GDTR_LIMIT,         pCtx->gdtr.cbGdt);
     1095        rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_GDTR_BASE,        pCtx->gdtr.pGdt);
    11231096        AssertRC(rc);
    11241097    }
    … …  
    11261099    if (pVCpu->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_GUEST_IDTR)
    11271100    {
    1128         rc  = VMXWriteVMCS(VMX_VMCS32_GUEST_IDTR_LIMIT,       pCtx->idtr.cbIdt);
    1129         rc |= VMXWriteVMCS(VMX_VMCS_GUEST_IDTR_BASE,          pCtx->idtr.pIdt);
     1101        rc  = VMXWriteVMCS(VMX_VMCS32_GUEST_IDTR_LIMIT,         pCtx->idtr.cbIdt);
     1102        rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_IDTR_BASE,        pCtx->idtr.pIdt);
    11301103        AssertRC(rc);
    11311104    }
    … …  
    11341107     * Sysenter MSRs (unconditional)
    11351108     */
    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);
     1109    rc  = VMXWriteVMCS(VMX_VMCS32_GUEST_SYSENTER_CS,        pCtx->SysEnter.cs);
     1110    rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_SYSENTER_EIP,     pCtx->SysEnter.eip);
     1111    rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_SYSENTER_ESP,     pCtx->SysEnter.esp);
    11391112    AssertRC(rc);
    11401113
    … …  
    11421115    if (pVCpu->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_GUEST_CR0)
    11431116    {
    1144         val = pCtx->cr0;
    1145         rc  = VMXWriteVMCS(VMX_VMCS_CTRL_CR0_READ_SHADOW,   val);
    1146         Log2(("Guest CR0-shadow %08x\n", val));
     1117        val64 = pCtx->cr0;
     1118        rc  = VMXWriteVMCS64(VMX_VMCS64_CTRL_CR0_READ_SHADOW,   val64);
     1119        Log2(("Guest CR0-shadow %RX64\n", val64));
    11471120        if (CPUMIsGuestFPUStateActive(pVCpu) == false)
    11481121        {
    11491122            /* Always use #NM exceptions to load the FPU/XMM state on demand. */
    1150             val |= X86_CR0_TS | X86_CR0_ET | X86_CR0_NE | X86_CR0_MP;
     1123            val64 |= X86_CR0_TS | X86_CR0_ET | X86_CR0_NE | X86_CR0_MP;
    11511124        }
    11521125        else
    11531126        {
    11541127            /** @todo check if we support the old style mess correctly. */
    1155             if (!(val & X86_CR0_NE))
     1128            if (!(val64 & X86_CR0_NE))
    11561129                Log(("Forcing X86_CR0_NE!!!\n"));
    11571130
    1158             val |= X86_CR0_NE;  /* always turn on the native mechanism to report FPU errors (old style uses interrupts) */
     1131            val64 |= X86_CR0_NE;  /* always turn on the native mechanism to report FPU errors (old style uses interrupts) */
    11591132        }
    11601133        /* Note: protected mode & paging are always enabled; we use them for emulating real and protected mode without paging too. */
    1161         val |= X86_CR0_PE | X86_CR0_PG;
     1134        val64 |= X86_CR0_PE | X86_CR0_PG;
    11621135        if (pVM->hwaccm.s.fNestedPaging)
    11631136        {
    … …  
    11801153        {
    11811154            /* Note: We must also set this as we rely on protecting various pages for which supervisor writes must be caught. */
    1182             val |= X86_CR0_WP;
     1155            val64 |= X86_CR0_WP;
    11831156        }
    11841157
    11851158        /* Always enable caching. */
    1186         val &= ~(X86_CR0_CD|X86_CR0_NW);
    1187 
    1188         rc |= VMXWriteVMCS(VMX_VMCS_GUEST_CR0,              val);
    1189         Log2(("Guest CR0 %08x\n", val));
     1159        val64 &= ~(X86_CR0_CD|X86_CR0_NW);
     1160
     1161        rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_CR0,              val64);
     1162        Log2(("Guest CR0 %RX64\n", val64));
    11901163        /* CR0 flags owned by the host; if the guests attempts to change them, then
    11911164         * the VM will exit.
    11921165         */
    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));
     1166        val64 =   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_TS
     1170                | 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_NE
     1174                | X86_CR0_MP;
     1175        pVCpu->hwaccm.s.vmx.cr0_mask = val64;
     1176
     1177        rc |= VMXWriteVMCS64(VMX_VMCS64_CTRL_CR0_MASK, val64);
     1178        Log2(("Guest CR0-mask %RX64\n", val64));
    12061179        AssertRC(rc);
    12071180    }
    … …  
    12091182    {
    12101183        /* CR4 */
    1211         rc  = VMXWriteVMCS(VMX_VMCS_CTRL_CR4_READ_SHADOW,   pCtx->cr4);
    1212         Log2(("Guest CR4-shadow %08x\n", pCtx->cr4));
     1184        rc  = VMXWriteVMCS64(VMX_VMCS64_CTRL_CR4_READ_SHADOW,   pCtx->cr4);
     1185        Log2(("Guest CR4-shadow %RX64\n", pCtx->cr4));
    12131186        /* Set the required bits in cr4 too (currently X86_CR4_VMXE). */
    1214         val = pCtx->cr4 | (uint32_t)pVM->hwaccm.s.vmx.msr.vmx_cr4_fixed0;
     1187        val64 = pCtx->cr4 | (uint32_t)pVM->hwaccm.s.vmx.msr.vmx_cr4_fixed0;
    12151188
    12161189        if (!pVM->hwaccm.s.fNestedPaging)
    … …  
    12261199            case PGMMODE_PAE_NX:        /* PAE paging with NX enabled. */
    12271200                /** @todo use normal 32 bits paging */
    1228                 val |= X86_CR4_PAE;
     1201                val64 |= X86_CR4_PAE;
    12291202                break;
    12301203
    … …  
    12461219        {
    12471220            /* We use 4 MB pages in our identity mapping page table for real and protected mode without paging. */
    1248             val |= X86_CR4_PSE;
     1221            val64 |= X86_CR4_PSE;
    12491222            /* Our identity mapping is a 32 bits page directory. */
    1250             val &= ~X86_CR4_PAE;
     1223            val64 &= ~X86_CR4_PAE;
    12511224        }
    12521225
    … …  
    12541227        /* Real mode emulation using v86 mode with CR4.VME (interrupt redirection using the int bitmap in the TSS) */
    12551228        if (CPUMIsGuestInRealModeEx(pCtx))
    1256             val |= X86_CR4_VME;
     1229            val64 |= X86_CR4_VME;
    12571230#endif /* HWACCM_VMX_EMULATE_REALMODE */
    12581231
    1259         rc |= VMXWriteVMCS(VMX_VMCS_GUEST_CR4,              val);
    1260         Log2(("Guest CR4 %08x\n", val));
     1232        rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_CR4,              val64);
     1233        Log2(("Guest CR4 %08x\n", val64));
    12611234        /* CR4 flags owned by the host; if the guests attempts to change them, then
    12621235         * the VM will exit.
    12631236         */
    1264         val =   0
     1237        val64 =   0
    12651238#ifdef HWACCM_VMX_EMULATE_REALMODE
    12661239              | X86_CR4_VME
    … …  
    12701243              | X86_CR4_PSE
    12711244              | X86_CR4_VMXE;
    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));
     1245        pVCpu->hwaccm.s.vmx.cr4_mask = val64;
     1246
     1247        rc |= VMXWriteVMCS64(VMX_VMCS64_CTRL_CR4_MASK, val64);
     1248        Log2(("Guest CR4-mask %RX64\n", val64));
    12761249        AssertRC(rc);
    12771250    }
    … …  
    12891262                                             | (VMX_EPT_PAGE_WALK_LENGTH_DEFAULT << VMX_EPT_PAGE_WALK_LENGTH_SHIFT);
    12901263
    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
     1264            rc = VMXWriteVMCS64(VMX_VMCS_CTRL_EPTP_FULL, pVCpu->hwaccm.s.vmx.GCPhysEPTP);
    12951265            AssertRC(rc);
    12961266
    … …  
    13061276                 * take care of the translation to host physical addresses.
    13071277                 */
    1308                 val = GCPhys;
     1278                val64 = GCPhys;
    13091279            }
    13101280            else
    13111281            {
    13121282                /* Save the real guest CR3 in VMX_VMCS_GUEST_CR3 */
    1313                 val = pCtx->cr3;
     1283                val64 = pCtx->cr3;
    13141284                /* Prefetch the four PDPT entries in PAE mode. */
    13151285                vmxR0PrefetchPAEPdptrs(pVM, pCtx);
    … …  
    13181288        else
    13191289        {
    1320             val = PGMGetHyperCR3(pVM);
    1321             Assert(val);
     1290            val64 = PGMGetHyperCR3(pVM);
     1291            Assert(val64);
    13221292        }
    13231293
    13241294        /* Save our shadow CR3 register. */
    1325         rc = VMXWriteVMCS(VMX_VMCS_GUEST_CR3, val);
     1295        rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_CR3, val64);
    13261296        AssertRC(rc);
    13271297    }
    … …  
    13381308
    13391309        /* Resync DR7 */
    1340         rc = VMXWriteVMCS(VMX_VMCS_GUEST_DR7, pCtx->dr[7]);
     1310        rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_DR7, pCtx->dr[7]);
    13411311        AssertRC(rc);
    13421312
    … …  
    13591329
    13601330        /* IA32_DEBUGCTL MSR. */
    1361         rc  = VMXWriteVMCS(VMX_VMCS_GUEST_DEBUGCTL_FULL,    0);
    1362         rc |= VMXWriteVMCS(VMX_VMCS_GUEST_DEBUGCTL_HIGH,    0);
     1331        rc  = VMXWriteVMCS64(VMX_VMCS_GUEST_DEBUGCTL_FULL,    0);
    13631332        AssertRC(rc);
    13641333
    13651334        /** @todo do we really ever need this? */
    1366         rc |= VMXWriteVMCS(VMX_VMCS_GUEST_DEBUG_EXCEPTIONS,        0);
     1335        rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_DEBUG_EXCEPTIONS, 0);
    13671336        AssertRC(rc);
    13681337    }
    13691338
    13701339    /* EIP, ESP and EFLAGS */
    1371     rc  = VMXWriteVMCS(VMX_VMCS_GUEST_RIP,              pCtx->rip);
    1372     rc |= VMXWriteVMCS(VMX_VMCS_GUEST_RSP,              pCtx->rsp);
     1340    rc  = VMXWriteVMCS64(VMX_VMCS64_GUEST_RIP,              pCtx->rip);
     1341    rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_RSP,              pCtx->rsp);
    13731342    AssertRC(rc);
    13741343
    13751344    /* Bits 22-31, 15, 5 & 3 must be zero. Bit 1 must be 1. */
    1376     eflags      = pCtx->eflags;
    1377     eflags.u32 &= VMX_EFLAGS_RESERVED_0;
    1378     eflags.u32 |= VMX_EFLAGS_RESERVED_1;
     1345    rflags      = pCtx->rflags;
     1346    rflags.u64 &= VMX_EFLAGS_RESERVED_0;
     1347    rflags.u64 |= VMX_EFLAGS_RESERVED_1;
    13791348
    13801349#ifdef HWACCM_VMX_EMULATE_REALMODE
    … …  
    13821351    if (CPUMIsGuestInRealModeEx(pCtx))
    13831352    {
    1384         pVCpu->hwaccm.s.vmx.RealMode.eflags = eflags;
    1385 
    1386         eflags.Bits.u1VM   = 1;
    1387         eflags.Bits.u2IOPL = 3;
     1353        pVCpu->hwaccm.s.vmx.RealMode.rflags = rflags;
     1354
     1355        rflags.Bits.u1VM   = 1;
     1356        rflags.Bits.u2IOPL = 3;
    13881357    }
    13891358#endif /* HWACCM_VMX_EMULATE_REALMODE */
    1390     rc   = VMXWriteVMCS(VMX_VMCS_GUEST_RFLAGS,           eflags.u32);
     1359    rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_RFLAGS,           rflags.u64);
    13911360    AssertRC(rc);
    13921361
    … …  
    13971366    {
    13981367        /* Note: VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_RDTSC_EXIT takes precedence over TSC_OFFSET */
    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
     1368        rc  = VMXWriteVMCS64(VMX_VMCS_CTRL_TSC_OFFSET_FULL, u64TSCOffset);
    14031369        AssertRC(rc);
    14041370
    … …  
    14421408#endif
    14431409        /* Unconditionally update these as wrmsr might have changed them. */
    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);
     1410        rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_FS_BASE, pCtx->fsHid.u64Base);
     1411        AssertRC(rc);
     1412        rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_GS_BASE, pCtx->gsHid.u64Base);
    14471413        AssertRC(rc);
    14481414    }
    … …  
    14701436DECLINLINE(int) VMXR0SaveGuestState(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx)
    14711437{
    1472     RTCCUINTREG val, valShadow;
    1473     RTGCUINTPTR uInterruptState;
     1438    uint64_t    val64, u64Shadow;
     1439    RTHCUINTPTR val;
     1440    RTHCUINTPTR uInterruptState;
    14741441    int         rc;
    14751442
    14761443    /* Let's first sync back eip, esp, and eflags. */
    1477     rc = VMXReadVMCS(VMX_VMCS_GUEST_RIP,              &val);
     1444    rc = VMXReadVMCS64(VMX_VMCS64_GUEST_RIP,              &pCtx->rip);
    14781445    AssertRC(rc);
    1479     pCtx->rip               = val;
    1480     rc = VMXReadVMCS(VMX_VMCS_GUEST_RSP,              &val);
     1446    rc = VMXReadVMCS64(VMX_VMCS64_GUEST_RSP,              &pCtx->rsp);
    14811447    AssertRC(rc);
    1482     pCtx->rsp               = val;
    1483     rc = VMXReadVMCS(VMX_VMCS_GUEST_RFLAGS,           &val);
     1448    rc = VMXReadVMCS64(VMX_VMCS64_GUEST_RFLAGS,           &pCtx->rflags.u64);
    14841449    AssertRC(rc);
    1485     pCtx->eflags.u32        = val;
    14861450
    14871451    /* Take care of instruction fusing (sti, mov ss) */
    1488     rc |= VMXReadVMCS(VMX_VMCS32_GUEST_INTERRUPTIBILITY_STATE, &val);
    1489     uInterruptState = val;
     1452    rc |= VMXReadVMCS(VMX_VMCS32_GUEST_INTERRUPTIBILITY_STATE, &uInterruptState);
    14901453    if (uInterruptState != 0)
    14911454    {
    … …  
    14981461
    14991462    /* Control registers. */
    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);
     1463    VMXReadVMCS64(VMX_VMCS64_CTRL_CR0_READ_SHADOW,  &u64Shadow);
     1464    VMXReadVMCS64(VMX_VMCS64_GUEST_CR0,             &val64);
     1465    val64 = (u64Shadow & pVCpu->hwaccm.s.vmx.cr0_mask) | (val64 & ~pVCpu->hwaccm.s.vmx.cr0_mask);
     1466    CPUMSetGuestCR0(pVM, val64);
     1467
     1468    VMXReadVMCS64(VMX_VMCS64_CTRL_CR4_READ_SHADOW,  &u64Shadow);
     1469    VMXReadVMCS64(VMX_VMCS64_GUEST_CR4,             &val64);
     1470    val64 = (u64Shadow & pVCpu->hwaccm.s.vmx.cr4_mask) | (val64 & ~pVCpu->hwaccm.s.vmx.cr4_mask);
     1471    CPUMSetGuestCR4(pVM, val64);
    15091472
    15101473    /* Note: no reason to sync back the CRx registers. They can't be changed by the guest. */
    … …  
    15161479        CPUMSetGuestCR2(pVM, ASMGetCR2());
    15171480
    1518         VMXReadVMCS(VMX_VMCS_GUEST_CR3, &val);
    1519 
    1520         if (val != pCtx->cr3)
    1521         {
    1522             CPUMSetGuestCR3(pVM, val);
    1523             PGMUpdateCR3(pVM, val);
     1481        VMXReadVMCS64(VMX_VMCS64_GUEST_CR3, &val64);
     1482
     1483        if (val64 != pCtx->cr3)
     1484        {
     1485            CPUMSetGuestCR3(pVM, val64);
     1486            PGMUpdateCR3(pVM, val64);
    15241487        }
    15251488        /* Prefetch the four PDPT entries in PAE mode. */
    … …  
    15281491
    15291492    /* Sync back DR7 here. */
    1530     VMXReadVMCS(VMX_VMCS_GUEST_DR7, &val);
    1531     pCtx->dr[7] = val;
     1493    VMXReadVMCS64(VMX_VMCS64_GUEST_DR7, &pCtx->dr[7]);
    15321494
    15331495    /* Guest CPU context: ES, CS, SS, DS, FS, GS. */
    … …  
    15421504     * System MSRs
    15431505     */
    1544     VMXReadVMCS(VMX_VMCS32_GUEST_SYSENTER_CS,    &val);
     1506    VMXReadVMCS(VMX_VMCS32_GUEST_SYSENTER_CS,       &val);
    15451507    pCtx->SysEnter.cs       = val;
    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;
     1508    VMXReadVMCS64(VMX_VMCS64_GUEST_SYSENTER_EIP,    &pCtx->SysEnter.eip);
     1509    VMXReadVMCS64(VMX_VMCS64_GUEST_SYSENTER_ESP,    &pCtx->SysEnter.esp);
    15501510
    15511511    /* Misc. registers; must sync everything otherwise we can get out of sync when jumping to ring 3. */
    15521512    VMX_READ_SELREG(LDTR, ldtr);
    15531513
    1554     VMXReadVMCS(VMX_VMCS32_GUEST_GDTR_LIMIT,     &val);
     1514    VMXReadVMCS(VMX_VMCS32_GUEST_GDTR_LIMIT,        &val);
    15551515    pCtx->gdtr.cbGdt        = val;
    1556     VMXReadVMCS(VMX_VMCS_GUEST_GDTR_BASE,        &val);
    1557     pCtx->gdtr.pGdt         = val;
    1558 
    1559     VMXReadVMCS(VMX_VMCS32_GUEST_IDTR_LIMIT,     &val);
     1516    VMXReadVMCS64(VMX_VMCS64_GUEST_GDTR_BASE,       &pCtx->gdtr.pGdt);
     1517
     1518    VMXReadVMCS(VMX_VMCS32_GUEST_IDTR_LIMIT,        &val);
    15601519    pCtx->idtr.cbIdt        = val;
    1561     VMXReadVMCS(VMX_VMCS_GUEST_IDTR_BASE,        &val);
    1562     pCtx->idtr.pIdt         = val;
     1520    VMXReadVMCS64(VMX_VMCS64_GUEST_IDTR_BASE,       &pCtx->idtr.pIdt);
    15631521
    15641522#ifdef HWACCM_VMX_EMULATE_REALMODE
    … …  
    15681526        /* Hide our emulation flags */
    15691527        pCtx->eflags.Bits.u1VM   = 0;
    1570         pCtx->eflags.Bits.u2IOPL = pVCpu->hwaccm.s.vmx.RealMode.eflags.Bits.u2IOPL;
     1528        pCtx->eflags.Bits.u2IOPL = pVCpu->hwaccm.s.vmx.RealMode.rflags.Bits.u2IOPL;
    15711529
    15721530        /* Force a TR resync every time in case we switch modes. */
    … …  
    17251683    int         rc = VINF_SUCCESS;
    17261684    RTCCUINTREG val;
     1685    uint64_t    val64;
    17271686    RTCCUINTREG exitReason, instrError, cbInstr;
    1728     RTGCUINTPTR exitQualification;
     1687    uint64_t    exitQualification;
    17291688    RTGCUINTPTR intInfo = 0; /* shut up buggy gcc 4 */
    17301689    RTGCUINTPTR errCode, instrInfo;
    … …  
    20051964    rc |= VMXReadVMCS(VMX_VMCS32_RO_EXIT_INSTR_INFO, &val);
    20061965    instrInfo = val;
    2007     rc |= VMXReadVMCS(VMX_VMCS_RO_EXIT_QUALIFICATION, &val);
    2008     exitQualification = val;
     1966    rc |= VMXReadVMCS64(VMX_VMCS64_RO_EXIT_QUALIFICATION, &exitQualification);
    20091967    AssertRC(rc);
    20101968
    … …  
    22562214
    22572215                    /* Resync DR7 */
    2258                     rc = VMXWriteVMCS(VMX_VMCS_GUEST_DR7, pCtx->dr[7]);
     2216                    rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_DR7, pCtx->dr[7]);
    22592217                    AssertRC(rc);
    22602218
    … …  
    23732331        Assert(pVM->hwaccm.s.fNestedPaging);
    23742332
    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
     2333        rc = VMXReadVMCS64(VMX_VMCS_EXIT_PHYS_ADDR_FULL, &GCPhys);
     2334        AssertRC(rc);
    23862335
    23872336        Assert(((exitQualification >> 7) & 3) != 2);
    … …  
    24352384        Assert(pVM->hwaccm.s.fNestedPaging);
    24362385
    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
     2386        rc = VMXReadVMCS64(VMX_VMCS_EXIT_PHYS_ADDR_FULL, &GCPhys);
     2387        AssertRC(rc);
    24482388
    24492389        Log(("VMX_EXIT_EPT_MISCONFIG for %VGp\n", GCPhys));
    … …  
    28032743
    28042744                            /* Resync DR7 */
    2805                             rc = VMXWriteVMCS(VMX_VMCS_GUEST_DR7, pCtx->dr[7]);
     2745                            rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_DR7, pCtx->dr[7]);
    28062746                            AssertRC(rc);
    28072747
    … …  
    29512891        Log(("VMX_EXIT_ERR_INVALID_GUEST_STATE\n"));
    29522892
    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));
     2893        VMXReadVMCS64(VMX_VMCS64_GUEST_RIP, &val64);
     2894        Log(("Old eip %RGv new %RGv\n", (RTGCPTR)pCtx->rip, (RTGCPTR)val64));
     2895
     2896        VMXReadVMCS64(VMX_VMCS64_GUEST_CR0, &val64);
     2897        Log(("VMX_VMCS64_GUEST_CR0        %RX64\n", val64));
     2898
     2899        VMXReadVMCS64(VMX_VMCS64_GUEST_CR3, &val64);
     2900        Log(("VMX_VMCS64_GUEST_CR3        %RGp\n", val64));
     2901
     2902        VMXReadVMCS64(VMX_VMCS64_GUEST_CR4, &val64);
     2903        Log(("VMX_VMCS64_GUEST_CR4        %RX64\n", val64));
     2904
     2905        VMXReadVMCS64(VMX_VMCS64_GUEST_RFLAGS, &val64);
     2906        Log(("VMX_VMCS64_GUEST_RFLAGS     %08x\n", val64));
    29672907
    29682908        VMX_LOG_SELREG(CS, "CS");
    … …  
    29752915        VMX_LOG_SELREG(LDTR, "LDTR");
    29762916
    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));
     2917        VMXReadVMCS64(VMX_VMCS64_GUEST_GDTR_BASE, &val64);
     2918        Log(("VMX_VMCS64_GUEST_GDTR_BASE    %RGv\n", (RTGCPTR)val64));
     2919        VMXReadVMCS64(VMX_VMCS64_GUEST_IDTR_BASE, &val64);
     2920        Log(("VMX_VMCS64_GUEST_IDTR_BASE    %RGv\n", (RTGCPTR)val64));
    29812921#endif /* VBOX_STRICT */
    29822922        rc = VERR_VMX_INVALID_GUEST_STATE;
    … …  
    32133153    {
    32143154        int         rc;
    3215         RTCCUINTREG exitReason, instrError, val;
     3155        RTCCUINTREG exitReason, instrError;
    32163156
    32173157        rc  = VMXReadVMCS(VMX_VMCS32_RO_EXIT_REASON, &exitReason);
    … …  
    32273167
    32283168#ifdef VBOX_STRICT
    3229             RTGDTR     gdtr;
    3230             PX86DESCHC pDesc;
     3169            RTGDTR      gdtr;
     3170            PX86DESCHC  pDesc;
     3171            uint64_t    val64;
     3172            RTCCUINTREG val;
    32313173
    32323174            ASMGetGDTR(&gdtr);
    32333175
    3234             VMXReadVMCS(VMX_VMCS_GUEST_RIP, &val);
    3235             Log(("Old eip %RGv new %RGv\n", (RTGCPTR)pCtx->rip, (RTGCPTR)val));
     3176            VMXReadVMCS64(VMX_VMCS64_GUEST_RIP, &val64);
     3177            Log(("Old eip %RGv new %RGv\n", (RTGCPTR)pCtx->rip, (RTGCPTR)val64));
    32363178            VMXReadVMCS(VMX_VMCS_CTRL_PIN_EXEC_CONTROLS, &val);
    32373179            Log(("VMX_VMCS_CTRL_PIN_EXEC_CONTROLS   %08x\n", val));
    … …  
    32553197            Log(("VMX_VMCS_HOST_FIELD_CS %08x\n", val));
    32563198
    3257             VMXReadVMCS(VMX_VMCS_GUEST_RFLAGS, &val);
    3258             Log(("VMX_VMCS_GUEST_RFLAGS %08x\n", val));
     3199            VMXReadVMCS64(VMX_VMCS64_GUEST_RFLAGS, &val64);
     3200            Log(("VMX_VMCS_GUEST_RFLAGS %RX64\n", val64));
    32593201
    32603202            if (val < gdtr.cbGdt)

  • trunk/src/VBox/VMM/VMMR0/HWVMXR0.h

    r14581 r14648  
    142142#define VMX_WRITE_SELREG(REG, reg) \
    143143{                                                                                               \
    144         rc  = VMXWriteVMCS(VMX_VMCS16_GUEST_FIELD_##REG,      pCtx->reg);                         \
    145         rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_##REG##_LIMIT,    pCtx->reg##Hid.u32Limit);           \
    146         rc |= VMXWriteVMCS(VMX_VMCS_GUEST_##REG##_BASE,     pCtx->reg##Hid.u64Base);            \
     144        rc  = VMXWriteVMCS(VMX_VMCS16_GUEST_FIELD_##REG,      pCtx->reg);                       \
     145        rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_##REG##_LIMIT,    pCtx->reg##Hid.u32Limit);         \
     146        rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_##REG##_BASE,     pCtx->reg##Hid.u64Base);        \
    147147        if ((pCtx->eflags.u32 & X86_EFL_VM))                                                    \
    148148            val = pCtx->reg##Hid.Attr.u;                                                        \
    … …  
    161161            val = 0x10000;  /* Invalid guest state error otherwise. (BIT(16) = Unusable) */     \
    162162                                                                                                \
    163         rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_##REG##_ACCESS_RIGHTS, val);                          \
     163        rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_##REG##_ACCESS_RIGHTS, val);                        \
    164164}
    165165
    166166#define VMX_READ_SELREG(REG, reg) \
    167 {                                                                    \
    168         VMXReadVMCS(VMX_VMCS16_GUEST_FIELD_##REG,           &val);   \
    169         pCtx->reg                = val;                              \
    170         VMXReadVMCS(VMX_VMCS32_GUEST_##REG##_LIMIT,         &val);   \
    171         pCtx->reg##Hid.u32Limit    = val;                            \
    172         VMXReadVMCS(VMX_VMCS_GUEST_##REG##_BASE,          &val);     \
    173         pCtx->reg##Hid.u64Base     = val;                            \
    174         VMXReadVMCS(VMX_VMCS32_GUEST_##REG##_ACCESS_RIGHTS, &val);   \
    175         pCtx->reg##Hid.Attr.u    = val;                              \
     167{                                                                      \
     168        VMXReadVMCS(VMX_VMCS16_GUEST_FIELD_##REG,         &val);       \
     169        pCtx->reg                = val;                                \
     170        VMXReadVMCS(VMX_VMCS32_GUEST_##REG##_LIMIT,       &val);       \
     171        pCtx->reg##Hid.u32Limit    = val;                              \
     172        VMXReadVMCS64(VMX_VMCS64_GUEST_##REG##_BASE,        &val64);   \
     173        pCtx->reg##Hid.u64Base     = val64;                            \
     174        VMXReadVMCS(VMX_VMCS32_GUEST_##REG##_ACCESS_RIGHTS, &val);     \
     175        pCtx->reg##Hid.Attr.u    = val;                                \
    176176}
    177177
    178178#define VMX_LOG_SELREG(REG, szSelReg) \
    179 {                                                                    \
    180         VMXReadVMCS(VMX_VMCS16_GUEST_FIELD_##REG,           &val);   \
    181         Log(("%s Selector     %x\n", szSelReg, val));                \
    182         VMXReadVMCS(VMX_VMCS32_GUEST_##REG##_LIMIT,         &val);   \
    183         Log(("%s Limit        %x\n", szSelReg, val));                \
    184         VMXReadVMCS(VMX_VMCS_GUEST_##REG##_BASE,          &val);     \
    185         Log(("%s Base         %RX64\n", szSelReg, val));             \
    186         VMXReadVMCS(VMX_VMCS32_GUEST_##REG##_ACCESS_RIGHTS, &val);   \
    187         Log(("%s Attributes   %x\n", szSelReg, val));                \
     179{                                                                      \
     180        VMXReadVMCS(VMX_VMCS16_GUEST_FIELD_##REG,         &val);       \
     181        Log(("%s Selector     %x\n", szSelReg, val));                  \
     182        VMXReadVMCS(VMX_VMCS32_GUEST_##REG##_LIMIT,       &val);       \
     183        Log(("%s Limit        %x\n", szSelReg, val));                  \
     184        VMXReadVMCS64(VMX_VMCS64_GUEST_##REG##_BASE,        &val64);   \
     185        Log(("%s Base         %RX64\n", szSelReg, val64));             \
     186        VMXReadVMCS(VMX_VMCS32_GUEST_##REG##_ACCESS_RIGHTS, &val);     \
     187        Log(("%s Attributes   %x\n", szSelReg, val));                  \
    188188}
    189189
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette