VirtualBox

Changeset 80192 in vbox


Ignore:
Timestamp:
Aug 8, 2019 4:25:31 AM (5 years ago)
Author:
vboxsync
Message:

VMM: Kicking out 32-bit host support - VMX. bugref:9511

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r80171 r80192  
    71607160static void hmR0VmxImportGuestRFlags(PVMCPU pVCpu, PCVMXVMCSINFO pVmcsInfo)
    71617161{
    7162     RTHCUINTREG HCRegVal;
    71637162    PCPUMCTX pCtx = &pVCpu->cpum.GstCtx;
    71647163    if (pCtx->fExtrn & CPUMCTX_EXTRN_RFLAGS)
    71657164    {
    7166         int rc = VMXReadVmcsNw(VMX_VMCS_GUEST_RFLAGS, &HCRegVal);
     7165        uint64_t u64Val;
     7166        int rc = VMXReadVmcsNw(VMX_VMCS_GUEST_RFLAGS, &u64Val);
    71677167        AssertRC(rc);
    71687168
    7169         pCtx->rflags.u64 = HCRegVal;
     7169        pCtx->rflags.u64 = u64Val;
    71707170        if (pVmcsInfo->RealMode.fRealOnV86Active)
    71717171        {
    … …  
    72317231static int hmR0VmxImportGuestState(PVMCPU pVCpu, PVMXVMCSINFO pVmcsInfo, uint64_t fWhat)
    72327232{
    7233     int          rc   = VINF_SUCCESS;
    7234     PVM          pVM  = pVCpu->CTX_SUFF(pVM);
    7235     PCPUMCTX     pCtx = &pVCpu->cpum.GstCtx;
    7236     uint32_t     u32Val;
    7237     RTHCUINTREG  HCRegVal;
     7233    int      rc   = VINF_SUCCESS;
     7234    PVM      pVM  = pVCpu->CTX_SUFF(pVM);
     7235    PCPUMCTX pCtx = &pVCpu->cpum.GstCtx;
     7236    uint32_t u32Val;
    72387237
    72397238    /*
    … …  
    72757274            if (fWhat & CPUMCTX_EXTRN_RSP)
    72767275            {
    7277                 rc = VMXReadVmcsNw(VMX_VMCS_GUEST_RSP, &HCRegVal);
     7276                rc = VMXReadVmcsNw(VMX_VMCS_GUEST_RSP, &pCtx->rsp);
    72787277                AssertRC(rc);
    7279                 pCtx->rsp = HCRegVal;
    72807278            }
    72817279
    … …  
    73307328                if (fWhat & CPUMCTX_EXTRN_GDTR)
    73317329                {
    7332                     rc = VMXReadVmcsNw(VMX_VMCS_GUEST_GDTR_BASE,    &HCRegVal);     AssertRC(rc);
    7333                     rc = VMXReadVmcs32(VMX_VMCS32_GUEST_GDTR_LIMIT, &u32Val);       AssertRC(rc);
    7334                     pCtx->gdtr.pGdt  = HCRegVal;
     7330                    rc = VMXReadVmcsNw(VMX_VMCS_GUEST_GDTR_BASE,    &pCtx->gdtr.pGdt);  AssertRC(rc);
     7331                    rc = VMXReadVmcs32(VMX_VMCS32_GUEST_GDTR_LIMIT, &u32Val);           AssertRC(rc);
    73357332                    pCtx->gdtr.cbGdt = u32Val;
    73367333                }
    … …  
    73397336                if (fWhat & CPUMCTX_EXTRN_IDTR)
    73407337                {
    7341                     rc = VMXReadVmcsNw(VMX_VMCS_GUEST_IDTR_BASE,    &HCRegVal);     AssertRC(rc);
    7342                     rc = VMXReadVmcs32(VMX_VMCS32_GUEST_IDTR_LIMIT, &u32Val);       AssertRC(rc);
    7343                     pCtx->idtr.pIdt  = HCRegVal;
     7338                    rc = VMXReadVmcsNw(VMX_VMCS_GUEST_IDTR_BASE,    &pCtx->idtr.pIdt);  AssertRC(rc);
     7339                    rc = VMXReadVmcs32(VMX_VMCS32_GUEST_IDTR_LIMIT, &u32Val);           AssertRC(rc);
    73447340                    pCtx->idtr.cbIdt = u32Val;
    73457341                }
    … …  
    73587354            {
    73597355                if (!pVCpu->hm.s.fUsingHyperDR7)
    7360                 {
    7361                     /* Upper 32-bits are always zero. See Intel spec. 2.7.3 "Loading and Storing Debug Registers". */
    7362                     rc = VMXReadVmcsNw(VMX_VMCS_GUEST_DR7, &HCRegVal);  AssertRC(rc);
    7363                     pCtx->dr[7] = HCRegVal;
    7364                 }
     7356                    rc = VMXReadVmcsNw(VMX_VMCS_GUEST_DR7, &pCtx->dr[7]);   AssertRC(rc);
    73657357            }
    73667358
    73677359            if (fWhat & CPUMCTX_EXTRN_SYSENTER_MSRS)
    73687360            {
    7369                 rc = VMXReadVmcsNw(VMX_VMCS_GUEST_SYSENTER_EIP,  &HCRegVal);    AssertRC(rc);
    7370                 pCtx->SysEnter.eip = HCRegVal;
    7371                 rc = VMXReadVmcsNw(VMX_VMCS_GUEST_SYSENTER_ESP,  &HCRegVal);    AssertRC(rc);
    7372                 pCtx->SysEnter.esp = HCRegVal;
    7373                 rc = VMXReadVmcs32(VMX_VMCS32_GUEST_SYSENTER_CS, &u32Val);      AssertRC(rc);
     7361                rc = VMXReadVmcsNw(VMX_VMCS_GUEST_SYSENTER_EIP,  &pCtx->SysEnter.eip);  AssertRC(rc);
     7362                rc = VMXReadVmcsNw(VMX_VMCS_GUEST_SYSENTER_ESP,  &pCtx->SysEnter.esp);  AssertRC(rc);
     7363                rc = VMXReadVmcs32(VMX_VMCS32_GUEST_SYSENTER_CS, &u32Val);              AssertRC(rc);
    73747364                pCtx->SysEnter.cs = u32Val;
    73757365            }
    … …  
    74247414                if (fWhat & CPUMCTX_EXTRN_CR0)
    74257415                {
    7426                     RTHCUINTREG HCRegShadow;
    7427                     rc = VMXReadVmcsNw(VMX_VMCS_GUEST_CR0,            &HCRegVal);       AssertRC(rc);
    7428                     rc = VMXReadVmcsNw(VMX_VMCS_CTRL_CR0_READ_SHADOW, &HCRegShadow);    AssertRC(rc);
    7429                     HCRegVal = (HCRegVal    & ~pVmcsInfo->u64Cr0Mask)
    7430                              | (HCRegShadow &  pVmcsInfo->u64Cr0Mask);
     7416                    uint64_t u64Cr0;
     7417                    uint64_t u64Shadow;
     7418                    rc = VMXReadVmcsNw(VMX_VMCS_GUEST_CR0,            &u64Cr0);       AssertRC(rc);
     7419                    rc = VMXReadVmcsNw(VMX_VMCS_CTRL_CR0_READ_SHADOW, &u64Shadow);    AssertRC(rc);
     7420                    u64Cr0 = (u64Cr0    & ~pVmcsInfo->u64Cr0Mask)
     7421                           | (u64Shadow &  pVmcsInfo->u64Cr0Mask);
    74317422#ifdef VBOX_WITH_NESTED_HWVIRT_VMX
    74327423                    /*
    … …  
    74367427                    if (CPUMIsGuestInVmxNonRootMode(pCtx))
    74377428                    {
    7438                         HCRegVal |= pCtx->hwvirt.vmx.Msrs.u64Cr0Fixed0;
    7439                         HCRegVal &= pCtx->hwvirt.vmx.Msrs.u64Cr0Fixed1;
     7429                        u64Cr0 |= pCtx->hwvirt.vmx.Msrs.u64Cr0Fixed0;
     7430                        u64Cr0 &= pCtx->hwvirt.vmx.Msrs.u64Cr0Fixed1;
    74407431                    }
    74417432#endif
    74427433                    VMMRZCallRing3Disable(pVCpu);   /* May call into PGM which has Log statements. */
    7443                     CPUMSetGuestCR0(pVCpu, HCRegVal);
     7434                    CPUMSetGuestCR0(pVCpu, u64Cr0);
    74447435                    VMMRZCallRing3Enable(pVCpu);
    74457436                }
    … …  
    74477438                if (fWhat & CPUMCTX_EXTRN_CR4)
    74487439                {
    7449                     RTHCUINTREG HCRegShadow;
    7450                     rc  = VMXReadVmcsNw(VMX_VMCS_GUEST_CR4,            &HCRegVal);      AssertRC(rc);
    7451                     rc |= VMXReadVmcsNw(VMX_VMCS_CTRL_CR4_READ_SHADOW, &HCRegShadow);   AssertRC(rc);
    7452                     HCRegVal = (HCRegVal    & ~pVmcsInfo->u64Cr4Mask)
    7453                              | (HCRegShadow &  pVmcsInfo->u64Cr4Mask);
     7440                    uint64_t u64Cr4;
     7441                    uint64_t u64Shadow;
     7442                    rc  = VMXReadVmcsNw(VMX_VMCS_GUEST_CR4,            &u64Cr4);      AssertRC(rc);
     7443                    rc |= VMXReadVmcsNw(VMX_VMCS_CTRL_CR4_READ_SHADOW, &u64Shadow);   AssertRC(rc);
     7444                    u64Cr4 = (u64Cr4    & ~pVmcsInfo->u64Cr4Mask)
     7445                           | (u64Shadow &  pVmcsInfo->u64Cr4Mask);
    74547446#ifdef VBOX_WITH_NESTED_HWVIRT_VMX
    74557447                    /*
    … …  
    74597451                    if (CPUMIsGuestInVmxNonRootMode(pCtx))
    74607452                    {
    7461                         HCRegVal |= pCtx->hwvirt.vmx.Msrs.u64Cr4Fixed0;
    7462                         HCRegVal &= pCtx->hwvirt.vmx.Msrs.u64Cr4Fixed1;
     7453                        u64Cr4 |= pCtx->hwvirt.vmx.Msrs.u64Cr4Fixed0;
     7454                        u64Cr4 &= pCtx->hwvirt.vmx.Msrs.u64Cr4Fixed1;
    74637455                    }
    74647456#endif
    7465                     pCtx->cr4 = HCRegVal;
     7457                    pCtx->cr4 = u64Cr4;
    74667458                }
    74677459
    … …  
    74737465                            && CPUMIsGuestPagingEnabledEx(pCtx)))
    74747466                    {
    7475                         rc = VMXReadVmcsNw(VMX_VMCS_GUEST_CR3, &HCRegVal);  AssertRC(rc);
    7476                         if (pCtx->cr3 != HCRegVal)
     7467                        uint64_t u64Cr3;
     7468                        rc = VMXReadVmcsNw(VMX_VMCS_GUEST_CR3, &u64Cr3);  AssertRC(rc);
     7469                        if (pCtx->cr3 != u64Cr3)
    74777470                        {
    7478                             pCtx->cr3 = HCRegVal;
     7471                            pCtx->cr3 = u64Cr3;
    74797472                            VMCPU_FF_SET(pVCpu, VMCPU_FF_HM_UPDATE_CR3);
    74807473                        }
    … …  
    91659158         */
    91669159        /** @todo Why do we need to OR and AND the fixed-0 and fixed-1 bits below? */
    9167         uint32_t       fSetCr0 = (uint32_t)(pVM->hm.s.vmx.Msrs.u64Cr0Fixed0 & pVM->hm.s.vmx.Msrs.u64Cr0Fixed1);
    9168         uint32_t const fZapCr0 = (uint32_t)(pVM->hm.s.vmx.Msrs.u64Cr0Fixed0 | pVM->hm.s.vmx.Msrs.u64Cr0Fixed1);
     9160        uint64_t       fSetCr0 = (pVM->hm.s.vmx.Msrs.u64Cr0Fixed0 & pVM->hm.s.vmx.Msrs.u64Cr0Fixed1);
     9161        uint64_t const fZapCr0 = (pVM->hm.s.vmx.Msrs.u64Cr0Fixed0 | pVM->hm.s.vmx.Msrs.u64Cr0Fixed1);
    91699162        /* Exceptions for unrestricted guest execution for fixed CR0 bits (PE, PG).
    91709163           See Intel spec. 26.3.1 "Checks on Guest Control Registers, Debug Registers and MSRs." */
    91719164        if (fUnrestrictedGuest)
    9172             fSetCr0 &= ~(X86_CR0_PE | X86_CR0_PG);
    9173 
    9174         uint32_t u32GuestCr0;
    9175         rc = VMXReadVmcs32(VMX_VMCS_GUEST_CR0, &u32GuestCr0);
    9176         AssertRCBreak(rc);
    9177         HMVMX_CHECK_BREAK((u32GuestCr0 & fSetCr0) == fSetCr0, VMX_IGS_CR0_FIXED1);
    9178         HMVMX_CHECK_BREAK(!(u32GuestCr0 & ~fZapCr0), VMX_IGS_CR0_FIXED0);
     9165            fSetCr0 &= ~(uint64_t)(X86_CR0_PE | X86_CR0_PG);
     9166
     9167        uint64_t u64GuestCr0;
     9168        rc = VMXReadVmcsNw(VMX_VMCS_GUEST_CR0, &u64GuestCr0);
     9169        AssertRC(rc);
     9170        HMVMX_CHECK_BREAK((u64GuestCr0 & fSetCr0) == fSetCr0, VMX_IGS_CR0_FIXED1);
     9171        HMVMX_CHECK_BREAK(!(u64GuestCr0 & ~fZapCr0), VMX_IGS_CR0_FIXED0);
    91799172        if (   !fUnrestrictedGuest
    9180             &&  (u32GuestCr0 & X86_CR0_PG)
    9181             && !(u32GuestCr0 & X86_CR0_PE))
     9173            &&  (u64GuestCr0 & X86_CR0_PG)
     9174            && !(u64GuestCr0 & X86_CR0_PE))
    91829175        {
    91839176            HMVMX_ERROR_BREAK(VMX_IGS_CR0_PG_PE_COMBO);
    … …  
    91919184        uint64_t const fZapCr4 = (pVM->hm.s.vmx.Msrs.u64Cr4Fixed0 | pVM->hm.s.vmx.Msrs.u64Cr4Fixed1);
    91929185
    9193         uint32_t u32GuestCr4;
    9194         rc = VMXReadVmcs32(VMX_VMCS_GUEST_CR4, &u32GuestCr4);
    9195         AssertRCBreak(rc);
    9196         HMVMX_CHECK_BREAK((u32GuestCr4 & fSetCr4) == fSetCr4, VMX_IGS_CR4_FIXED1);
    9197         HMVMX_CHECK_BREAK(!(u32GuestCr4 & ~fZapCr4), VMX_IGS_CR4_FIXED0);
     9186        uint64_t u64GuestCr4;
     9187        rc = VMXReadVmcsNw(VMX_VMCS_GUEST_CR4, &u64GuestCr4);
     9188        AssertRC(rc);
     9189        HMVMX_CHECK_BREAK((u64GuestCr4 & fSetCr4) == fSetCr4, VMX_IGS_CR4_FIXED1);
     9190        HMVMX_CHECK_BREAK(!(u64GuestCr4 & ~fZapCr4), VMX_IGS_CR4_FIXED0);
    91989191
    91999192        /*
    … …  
    92029195        uint64_t u64Val;
    92039196        rc = VMXReadVmcs64(VMX_VMCS64_GUEST_DEBUGCTL_FULL, &u64Val);
    9204         AssertRCBreak(rc);
     9197        AssertRC(rc);
    92059198        if (   (pVmcsInfo->u32EntryCtls & VMX_ENTRY_CTLS_LOAD_DEBUG)
    92069199            && (u64Val & 0xfffffe3c))                           /* Bits 31:9, bits 5:2 MBZ. */
    … …  
    92129205#ifdef VBOX_STRICT
    92139206        rc = VMXReadVmcs32(VMX_VMCS32_CTRL_ENTRY, &u32Val);
    9214         AssertRCBreak(rc);
     9207        AssertRC(rc);
    92159208        Assert(u32Val == pVmcsInfo->u32EntryCtls);
    92169209#endif
    … …  
    92219214         */
    92229215        rc = VMXReadVmcsNw(VMX_VMCS_GUEST_RIP, &u64Val);
    9223         AssertRCBreak(rc);
     9216        AssertRC(rc);
    92249217        /* pCtx->rip can be different than the one in the VMCS (e.g. run guest code and VM-exits that don't update it). */
    92259218        if (   !fLongModeGuest
    … …  
    92359228        /* Flags in pCtx can be different (real-on-v86 for instance). We are only concerned about the VMCS contents here. */
    92369229        rc = VMXReadVmcsNw(VMX_VMCS_GUEST_RFLAGS, &u64Val);
    9237         AssertRCBreak(rc);
     9230        AssertRC(rc);
    92389231        HMVMX_CHECK_BREAK(!(u64Val & UINT64_C(0xffffffffffc08028)),                     /* Bit 63:22, Bit 15, 5, 3 MBZ. */
    92399232                          VMX_IGS_RFLAGS_RESERVED);
    … …  
    92439236        if (   fLongModeGuest
    92449237            || (   fUnrestrictedGuest
    9245                 && !(u32GuestCr0 & X86_CR0_PE)))
     9238                && !(u64GuestCr0 & X86_CR0_PE)))
    92469239        {
    92479240            HMVMX_CHECK_BREAK(!(u32Eflags & X86_EFL_VM), VMX_IGS_RFLAGS_VM_INVALID);
    … …  
    92509243        uint32_t u32EntryInfo;
    92519244        rc = VMXReadVmcs32(VMX_VMCS32_CTRL_ENTRY_INTERRUPTION_INFO, &u32EntryInfo);
    9252         AssertRCBreak(rc);
     9245        AssertRC(rc);
    92539246        if (VMX_ENTRY_INT_INFO_IS_EXT_INT(u32EntryInfo))
    92549247            HMVMX_CHECK_BREAK(u32Eflags & X86_EFL_IF, VMX_IGS_RFLAGS_IF_INVALID);
    … …  
    92599252        if (fLongModeGuest)
    92609253        {
    9261             HMVMX_CHECK_BREAK(u32GuestCr0 & X86_CR0_PG, VMX_IGS_CR0_PG_LONGMODE);
    9262             HMVMX_CHECK_BREAK(u32GuestCr4 & X86_CR4_PAE, VMX_IGS_CR4_PAE_LONGMODE);
     9254            HMVMX_CHECK_BREAK(u64GuestCr0 & X86_CR0_PG, VMX_IGS_CR0_PG_LONGMODE);
     9255            HMVMX_CHECK_BREAK(u64GuestCr4 & X86_CR4_PAE, VMX_IGS_CR4_PAE_LONGMODE);
    92639256        }
    92649257
    92659258        if (   !fLongModeGuest
    9266             && (u32GuestCr4 & X86_CR4_PCIDE))
     9259            && (u64GuestCr4 & X86_CR4_PCIDE))
    92679260        {
    92689261            HMVMX_ERROR_BREAK(VMX_IGS_CR4_PCIDE);
    … …  
    92799272
    92809273        rc = VMXReadVmcsNw(VMX_VMCS_HOST_SYSENTER_ESP, &u64Val);
    9281         AssertRCBreak(rc);
     9274        AssertRC(rc);
    92829275        HMVMX_CHECK_BREAK(X86_IS_CANONICAL(u64Val), VMX_IGS_SYSENTER_ESP_NOT_CANONICAL);
    92839276
    92849277        rc = VMXReadVmcsNw(VMX_VMCS_HOST_SYSENTER_EIP, &u64Val);
    9285         AssertRCBreak(rc);
     9278        AssertRC(rc);
    92869279        HMVMX_CHECK_BREAK(X86_IS_CANONICAL(u64Val), VMX_IGS_SYSENTER_EIP_NOT_CANONICAL);
    92879280
    … …  
    92929285        {
    92939286            rc = VMXReadVmcs64(VMX_VMCS64_GUEST_PERF_GLOBAL_CTRL_FULL, &u64Val);
    9294             AssertRCBreak(rc);
     9287            AssertRC(rc);
    92959288            HMVMX_CHECK_BREAK(!(u64Val & UINT64_C(0xfffffff8fffffffc)),
    92969289                              VMX_IGS_PERF_GLOBAL_MSR_RESERVED);        /* Bits 63:35, bits 31:2 MBZ. */
    … …  
    93039296        {
    93049297            rc = VMXReadVmcs64(VMX_VMCS64_GUEST_PAT_FULL, &u64Val);
    9305             AssertRCBreak(rc);
     9298            AssertRC(rc);
    93069299            HMVMX_CHECK_BREAK(!(u64Val & UINT64_C(0x707070707070707)), VMX_IGS_PAT_MSR_RESERVED);
    93079300            for (unsigned i = 0; i < 8; i++)
    … …  
    93289321            Assert(pVM->hm.s.vmx.fSupportsVmcsEfer);
    93299322            rc = VMXReadVmcs64(VMX_VMCS64_GUEST_EFER_FULL, &u64Val);
    9330             AssertRCBreak(rc);
     9323            AssertRC(rc);
    93319324            HMVMX_CHECK_BREAK(!(u64Val & UINT64_C(0xfffffffffffff2fe)),
    93329325                              VMX_IGS_EFER_MSR_RESERVED);               /* Bits 63:12, bit 9, bits 7:1 MBZ. */
    … …  
    93379330             *        iemVmxVmentryCheckGuestState(). */
    93389331            HMVMX_CHECK_BREAK(   fUnrestrictedGuest
    9339                               || !(u32GuestCr0 & X86_CR0_PG)
     9332                              || !(u64GuestCr0 & X86_CR0_PG)
    93409333                              || RT_BOOL(u64Val & MSR_K6_EFER_LMA) == RT_BOOL(u64Val & MSR_K6_EFER_LME),
    93419334                              VMX_IGS_EFER_LMA_LME_MISMATCH);
    … …  
    95539546         */
    95549547        rc = VMXReadVmcsNw(VMX_VMCS_GUEST_GDTR_BASE, &u64Val);
    9555         AssertRCBreak(rc);
     9548        AssertRC(rc);
    95569549        HMVMX_CHECK_BREAK(X86_IS_CANONICAL(u64Val), VMX_IGS_GDTR_BASE_NOT_CANONICAL);
    95579550
    95589551        rc = VMXReadVmcsNw(VMX_VMCS_GUEST_IDTR_BASE, &u64Val);
    9559         AssertRCBreak(rc);
     9552        AssertRC(rc);
    95609553        HMVMX_CHECK_BREAK(X86_IS_CANONICAL(u64Val), VMX_IGS_IDTR_BASE_NOT_CANONICAL);
    95619554
    95629555        rc = VMXReadVmcs32(VMX_VMCS32_GUEST_GDTR_LIMIT, &u32Val);
    9563         AssertRCBreak(rc);
     9556        AssertRC(rc);
    95649557        HMVMX_CHECK_BREAK(!(u32Val & 0xffff0000), VMX_IGS_GDTR_LIMIT_INVALID);      /* Bits 31:16 MBZ. */
    95659558
    95669559        rc = VMXReadVmcs32(VMX_VMCS32_GUEST_IDTR_LIMIT, &u32Val);
    9567         AssertRCBreak(rc);
     9560        AssertRC(rc);
    95689561        HMVMX_CHECK_BREAK(!(u32Val & 0xffff0000), VMX_IGS_IDTR_LIMIT_INVALID);      /* Bits 31:16 MBZ. */
    95699562
    … …  
    95749567        uint32_t u32ActivityState;
    95759568        rc = VMXReadVmcs32(VMX_VMCS32_GUEST_ACTIVITY_STATE, &u32ActivityState);
    9576         AssertRCBreak(rc);
     9569        AssertRC(rc);
    95779570        HMVMX_CHECK_BREAK(   !u32ActivityState
    95789571                          || (u32ActivityState & RT_BF_GET(pVM->hm.s.vmx.Msrs.u64Misc, VMX_BF_MISC_ACTIVITY_STATES)),
    … …  
    95829575        uint32_t u32IntrState;
    95839576        rc = VMXReadVmcs32(VMX_VMCS32_GUEST_INT_STATE, &u32IntrState);
    9584         AssertRCBreak(rc);
     9577        AssertRC(rc);
    95859578        if (   u32IntrState == VMX_VMCS_GUEST_INT_STATE_BLOCK_MOVSS
    95869579            || u32IntrState == VMX_VMCS_GUEST_INT_STATE_BLOCK_STI)
    … …  
    96319624        /* Pending debug exceptions. */
    96329625        rc = VMXReadVmcs64(VMX_VMCS_GUEST_PENDING_DEBUG_XCPTS, &u64Val);
    9633         AssertRCBreak(rc);
     9626        AssertRC(rc);
    96349627        /* Bits 63:15, Bit 13, Bits 11:4 MBZ. */
    96359628        HMVMX_CHECK_BREAK(!(u64Val & UINT64_C(0xffffffffffffaff0)), VMX_IGS_LONGMODE_PENDING_DEBUG_RESERVED);
    … …  
    96569649        /* VMCS link pointer. */
    96579650        rc = VMXReadVmcs64(VMX_VMCS64_GUEST_VMCS_LINK_PTR_FULL, &u64Val);
    9658         AssertRCBreak(rc);
     9651        AssertRC(rc);
    96599652        if (u64Val != UINT64_C(0xffffffffffffffff))
    96609653        {
    … …  
    96799672        {
    96809673            rc = VMXReadVmcs64(VMX_VMCS64_GUEST_PDPTE0_FULL, &u64Val);
    9681             AssertRCBreak(rc);
     9674            AssertRC(rc);
    96829675            HMVMX_CHECK_BREAK(!(u64Val & X86_PDPE_PAE_MBZ_MASK), VMX_IGS_PAE_PDPTE_RESERVED);
    96839676
    96849677            rc = VMXReadVmcs64(VMX_VMCS64_GUEST_PDPTE1_FULL, &u64Val);
    9685             AssertRCBreak(rc);
     9678            AssertRC(rc);
    96869679            HMVMX_CHECK_BREAK(!(u64Val & X86_PDPE_PAE_MBZ_MASK), VMX_IGS_PAE_PDPTE_RESERVED);
    96879680
    96889681            rc = VMXReadVmcs64(VMX_VMCS64_GUEST_PDPTE2_FULL, &u64Val);
    9689             AssertRCBreak(rc);
     9682            AssertRC(rc);
    96909683            HMVMX_CHECK_BREAK(!(u64Val & X86_PDPE_PAE_MBZ_MASK), VMX_IGS_PAE_PDPTE_RESERVED);
    96919684
    96929685            rc = VMXReadVmcs64(VMX_VMCS64_GUEST_PDPTE3_FULL, &u64Val);
    9693             AssertRCBreak(rc);
     9686            AssertRC(rc);
    96949687            HMVMX_CHECK_BREAK(!(u64Val & X86_PDPE_PAE_MBZ_MASK), VMX_IGS_PAE_PDPTE_RESERVED);
    96959688        }
    … …  
    1451814511
    1451914512#ifdef VBOX_STRICT
    14520     uint32_t    fIntrState;
    14521     RTHCUINTREG uHCReg;
    14522     uint64_t    u64Val;
    14523     uint32_t    u32Val;
     14513    uint32_t fIntrState;
     14514    uint64_t u64Val;
    1452414515    hmR0VmxReadEntryIntInfoVmcs(pVmxTransient);
    1452514516    hmR0VmxReadEntryXcptErrorCodeVmcs(pVmxTransient);
    1452614517    hmR0VmxReadEntryInstrLenVmcs(pVmxTransient);
    14527     rc = VMXReadVmcs32(VMX_VMCS32_GUEST_INT_STATE, &fIntrState);
    14528     AssertRC(rc);
    1452914518
    1453014519    Log4(("uInvalidReason                             %u\n",     uInvalidReason));
    … …  
    1453214521    Log4(("VMX_VMCS32_CTRL_ENTRY_EXCEPTION_ERRCODE    %#RX32\n", pVmxTransient->uEntryXcptErrorCode));
    1453314522    Log4(("VMX_VMCS32_CTRL_ENTRY_INSTR_LENGTH         %#RX32\n", pVmxTransient->cbEntryInstr));
     14523
     14524    rc = VMXReadVmcs32(VMX_VMCS32_GUEST_INT_STATE, &fIntrState);            AssertRC(rc);
    1453414525    Log4(("VMX_VMCS32_GUEST_INT_STATE                 %#RX32\n", fIntrState));
    14535 
    14536     rc = VMXReadVmcs32(VMX_VMCS_GUEST_CR0, &u32Val);                        AssertRC(rc);
    14537     Log4(("VMX_VMCS_GUEST_CR0                         %#RX32\n", u32Val));
    14538     rc = VMXReadVmcsNw(VMX_VMCS_CTRL_CR0_MASK, &uHCReg);                  AssertRC(rc);
    14539     Log4(("VMX_VMCS_CTRL_CR0_MASK                     %#RHr\n", uHCReg));
    14540     rc = VMXReadVmcsNw(VMX_VMCS_CTRL_CR0_READ_SHADOW, &uHCReg);           AssertRC(rc);
    14541     Log4(("VMX_VMCS_CTRL_CR4_READ_SHADOW              %#RHr\n", uHCReg));
    14542     rc = VMXReadVmcsNw(VMX_VMCS_CTRL_CR4_MASK, &uHCReg);                  AssertRC(rc);
    14543     Log4(("VMX_VMCS_CTRL_CR4_MASK                     %#RHr\n", uHCReg));
    14544     rc = VMXReadVmcsNw(VMX_VMCS_CTRL_CR4_READ_SHADOW, &uHCReg);           AssertRC(rc);
    14545     Log4(("VMX_VMCS_CTRL_CR4_READ_SHADOW              %#RHr\n", uHCReg));
     14526    rc = VMXReadVmcsNw(VMX_VMCS_GUEST_CR0, &u64Val);                        AssertRC(rc);
     14527    Log4(("VMX_VMCS_GUEST_CR0                         %#RX64\n", u64Val));
     14528    rc = VMXReadVmcsNw(VMX_VMCS_CTRL_CR0_MASK, &u64Val);                    AssertRC(rc);
     14529    Log4(("VMX_VMCS_CTRL_CR0_MASK                     %#RX64\n", u64Val));
     14530    rc = VMXReadVmcsNw(VMX_VMCS_CTRL_CR0_READ_SHADOW, &u64Val);             AssertRC(rc);
     14531    Log4(("VMX_VMCS_CTRL_CR4_READ_SHADOW              %#RX64\n", u64Val));
     14532    rc = VMXReadVmcsNw(VMX_VMCS_CTRL_CR4_MASK, &u64Val);                    AssertRC(rc);
     14533    Log4(("VMX_VMCS_CTRL_CR4_MASK                     %#RX64\n", u64Val));
     14534    rc = VMXReadVmcsNw(VMX_VMCS_CTRL_CR4_READ_SHADOW, &u64Val);             AssertRC(rc);
     14535    Log4(("VMX_VMCS_CTRL_CR4_READ_SHADOW              %#RX64\n", u64Val));
    1454614536    if (pVCpu->CTX_SUFF(pVM)->hm.s.fNestedPaging)
    1454714537    {
    … …  
    1454914539        Log4(("VMX_VMCS64_CTRL_EPTP_FULL                  %#RX64\n", u64Val));
    1455014540    }
    14551 
    1455214541    hmR0DumpRegs(pVCpu);
    1455314542#endif
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