VirtualBox

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


Ignore:
Timestamp:
Jun 7, 2019 5:58:55 AM (6 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
131188
Message:

VMM/IEM: Nested VMX: bugref:9180 The Exit qualification is mandatory for all VM-exits (never undefined), so pass it explicitly to iemVmxVmexit along with the Exit reason. Adjusted all code to do this.

Location:
trunk/src/VBox/VMM/VMMAll
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/VMM/VMMAll/IEMAll.cpp

    r78982 r79031  
    1406014060        else if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_VMX_MTF))
    1406114061        {
    14062             rcStrict = iemVmxVmexit(pVCpu, VMX_EXIT_MTF);
     14062            rcStrict = iemVmxVmexit(pVCpu, VMX_EXIT_MTF, 0 /* u64ExitQual */);
    1406314063            fCheckRemainingIntercepts = false;
    1406414064            Assert(!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS));
    … …  
    1409614096                && CPUMIsGuestVmxVirtNmiBlocking(pVCpu, &pVCpu->cpum.GstCtx))
    1409714097            {
    14098                 rcStrict = iemVmxVmexit(pVCpu, VMX_EXIT_NMI_WINDOW);
     14098                rcStrict = iemVmxVmexit(pVCpu, VMX_EXIT_NMI_WINDOW, 0 /* u64ExitQual */);
    1409914099                Assert(!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_VMX_NMI_WINDOW));
    1410014100            }
    … …  
    1410214102                     && CPUMIsGuestVmxVirtIntrEnabled(pVCpu, &pVCpu->cpum.GstCtx))
    1410314103            {
    14104                 rcStrict = iemVmxVmexit(pVCpu, VMX_EXIT_INT_WINDOW);
     14104                rcStrict = iemVmxVmexit(pVCpu, VMX_EXIT_INT_WINDOW, 0 /* u64ExitQual */);
    1410514105                Assert(!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_VMX_INT_WINDOW));
    1410614106            }
    … …  
    1595515955VMM_INT_DECL(VBOXSTRICTRC) IEMExecVmxVmexitStartupIpi(PVMCPU pVCpu, uint8_t uVector)
    1595615956{
    15957     VBOXSTRICTRC rcStrict = iemVmxVmexitStartupIpi(pVCpu, uVector);
     15957    VBOXSTRICTRC rcStrict = iemVmxVmexit(pVCpu, VMX_EXIT_SIPI, uVector);
    1595815958    Assert(!pVCpu->iem.s.cActiveMappings);
    1595915959    return iemExecStatusCodeFiddling(pVCpu, rcStrict);
    … …  
    1596915969 * @param   pVCpu           The cross context virtual CPU structure of the calling EMT.
    1597015970 * @param   uExitReason     The VM-exit reason.
    15971  * @param   uExitQual       The VM-exit qualification.
     15971 * @param   u64ExitQual     The Exit qualification.
    1597215972 * @thread  EMT(pVCpu)
    1597315973 */
    15974 VMM_INT_DECL(VBOXSTRICTRC) IEMExecVmxVmexit(PVMCPU pVCpu, uint32_t uExitReason, uint64_t uExitQual)
    15975 {
    15976     iemVmxVmcsSetExitQual(pVCpu, uExitQual);
    15977     VBOXSTRICTRC rcStrict = iemVmxVmexit(pVCpu, uExitReason);
     15974VMM_INT_DECL(VBOXSTRICTRC) IEMExecVmxVmexit(PVMCPU pVCpu, uint32_t uExitReason, uint64_t u64ExitQual)
     15975{
     15976    VBOXSTRICTRC rcStrict = iemVmxVmexit(pVCpu, uExitReason, u64ExitQual);
    1597815977    Assert(!pVCpu->iem.s.cActiveMappings);
    1597915978    return iemExecStatusCodeFiddling(pVCpu, rcStrict);

  • trunk/src/VBox/VMM/VMMAll/IEMAllCImplVmxInstr.cpp.h

    r78982 r79031  
    951951
    952952/**
    953  * Sets the VM-exit qualification VMCS field.
    954  *
    955  * @param   pVCpu       The cross context virtual CPU structure.
    956  * @param   uExitQual   The VM-exit qualification.
    957  */
    958 DECL_FORCE_INLINE(void) iemVmxVmcsSetExitQual(PVMCPU pVCpu, uint64_t uExitQual)
     953 * Sets the Exit qualification VMCS field.
     954 *
     955 * @param   pVCpu           The cross context virtual CPU structure.
     956 * @param   u64ExitQual     The Exit qualification.
     957 */
     958DECL_FORCE_INLINE(void) iemVmxVmcsSetExitQual(PVMCPU pVCpu, uint64_t u64ExitQual)
    959959{
    960960    PVMXVVMCS pVmcs = pVCpu->cpum.GstCtx.hwvirt.vmx.CTX_SUFF(pVmcs);
    961     pVmcs->u64RoExitQual.u = uExitQual;
     961    pVmcs->u64RoExitQual.u = u64ExitQual;
    962962}
    963963
    … …  
    966966 * Sets the VM-exit interruption information field.
    967967 *
    968  * @param   pVCpu       The cross context virtual CPU structure.
    969  * @param   uExitQual   The VM-exit interruption information.
     968 * @param   pVCpu           The cross context virtual CPU structure.
     969 * @param   uExitIntInfo    The VM-exit interruption information.
    970970 */
    971971DECL_FORCE_INLINE(void) iemVmxVmcsSetExitIntInfo(PVMCPU pVCpu, uint32_t uExitIntInfo)
    … …  
    27102710 * @param   pVCpu           The cross context virtual CPU structure.
    27112711 * @param   uExitReason     The VM-exit reason.
    2712  *
    2713  * @remarks Make sure VM-exit qualification is updated before calling this
    2714  *          function!
    2715  */
    2716 IEM_STATIC VBOXSTRICTRC iemVmxVmexit(PVMCPU pVCpu, uint32_t uExitReason)
     2712 * @param   u64ExitQual     The Exit qualification.
     2713 */
     2714IEM_STATIC VBOXSTRICTRC iemVmxVmexit(PVMCPU pVCpu, uint32_t uExitReason, uint64_t u64ExitQual)
    27172715{
    27182716# if defined(VBOX_WITH_NESTED_HWVIRT_ONLY_IN_IEM) && !defined(IN_RING3)
    2719     RT_NOREF2(pVCpu, uExitReason);
     2717    RT_NOREF3(pVCpu, uExitReason, u64ExitQual);
    27202718    return VINF_EM_RAW_EMULATE_INSTR;
    27212719# else
    … …  
    27382736
    27392737    /*
    2740      * Update the VM-exit reason. Other VMCS data fields are expected to be updated by the caller already.
     2738     * Update the VM-exit reason and Exit qualification.
     2739     * Other VMCS read-only data fields are expected to be updated by the caller already.
    27412740     */
    27422741    pVmcs->u32RoExitReason = uExitReason;
    2743     Log3(("vmexit: uExitReason=%#RX32 uExitQual=%#RX64 cs:rip=%04x:%#RX64\n", uExitReason, pVmcs->u64RoExitQual,
     2742    pVmcs->u64RoExitQual.u = u64ExitQual;
     2743    Log3(("vmexit: uExitReason=%#RX32 u64ExitQual=%#RX64 cs:rip=%04x:%#RX64\n", uExitReason, pVmcs->u64RoExitQual.u,
    27442744          pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip));
    27452745
    … …  
    28872887    /*
    28882888     * For instructions where any of the following fields are not applicable:
     2889     *   - Exit qualification must be cleared.
    28892890     *   - VM-exit instruction info. is undefined.
    2890      *   - VM-exit qualification must be cleared.
    2891      *   - VM-exit guest-linear address is undefined.
    2892      *   - VM-exit guest-physical address is undefined.
     2891     *   - Guest-linear address is undefined.
     2892     *   - Guest-physical address is undefined.
    28932893     *
    28942894     * The VM-exit instruction length is mandatory for all VM-exits that are caused by
    … …  
    29102910    /* Update all the relevant fields from the VM-exit instruction information struct. */
    29112911    iemVmxVmcsSetExitInstrInfo(pVCpu, pExitInfo->InstrInfo.u);
    2912     iemVmxVmcsSetExitQual(pVCpu, pExitInfo->u64Qual);
    29132912    iemVmxVmcsSetExitGuestLinearAddr(pVCpu, pExitInfo->u64GuestLinearAddr);
    29142913    iemVmxVmcsSetExitGuestPhysAddr(pVCpu, pExitInfo->u64GuestPhysAddr);
    … …  
    29162915
    29172916    /* Perform the VM-exit. */
    2918     return iemVmxVmexit(pVCpu, pExitInfo->uReason);
     2917    return iemVmxVmexit(pVCpu, pExitInfo->uReason, pExitInfo->u64Qual);
    29192918}
    29202919
    … …  
    29722971 *
    29732972 * This is intended for instructions that have a ModR/M byte and update the VM-exit
    2974  * instruction information and VM-exit qualification fields.
     2973 * instruction information and Exit qualification fields.
    29752974 *
    29762975 * @param   pVCpu           The cross context virtual CPU structure.
    … …  
    29892988
    29902989    /*
    2991      * Update the VM-exit qualification field with displacement bytes.
     2990     * Update the Exit qualification field with displacement bytes.
    29922991     * See Intel spec. 27.2.1 "Basic VM-Exit Information".
    29932992     */
    … …  
    30173016            ExitInfo.InstrInfo.u = uInstrInfo;
    30183017
    3019             /* Update the VM-exit qualification. */
     3018            /* Update the Exit qualification. */
    30203019            ExitInfo.u64Qual = GCPtrDisp;
    30213020            break;
    … …  
    36493648{
    36503649    /*
    3651      * Task-switch VM-exits are unconditional and provide the VM-exit qualification.
     3650     * Task-switch VM-exits are unconditional and provide the Exit qualification.
    36523651     *
    36533652     * If the cause of the task switch is due to execution of CALL, IRET or the JMP
    … …  
    36723671    }
    36733672
    3674     uint64_t const uExitQual = RT_BF_MAKE(VMX_BF_EXIT_QUAL_TASK_SWITCH_NEW_TSS, SelNewTss)
    3675                              | RT_BF_MAKE(VMX_BF_EXIT_QUAL_TASK_SWITCH_SOURCE,  uType);
    3676     iemVmxVmcsSetExitQual(pVCpu, uExitQual);
     3673    uint64_t const u64ExitQual = RT_BF_MAKE(VMX_BF_EXIT_QUAL_TASK_SWITCH_NEW_TSS, SelNewTss)
     3674                               | RT_BF_MAKE(VMX_BF_EXIT_QUAL_TASK_SWITCH_SOURCE,  uType);
    36773675    iemVmxVmcsSetExitInstrLen(pVCpu, cbInstr);
    3678     return iemVmxVmexit(pVCpu, VMX_EXIT_TASK_SWITCH);
     3676    return iemVmxVmexit(pVCpu, VMX_EXIT_TASK_SWITCH, u64ExitQual);
    36793677}
    36803678
    … …  
    36973695    Assert(pExitEventInfo);
    36983696
    3699     /* The VM-exit qualification is mandatory for all task-switch VM-exits. */
     3697    /* The Exit qualification is mandatory for all task-switch VM-exits. */
    37003698    uint64_t const u64ExitQual = pExitInfo->u64Qual;
    37013699    iemVmxVmcsSetExitQual(pVCpu, u64ExitQual);
    … …  
    37433741        iemVmxVmcsSetExitInstrLen(pVCpu, pExitInfo->cbInstr);
    37443742    }
    3745     return iemVmxVmexit(pVCpu, VMX_EXIT_TASK_SWITCH);
     3743    return iemVmxVmexit(pVCpu, VMX_EXIT_TASK_SWITCH, u64ExitQual);
    37463744}
    37473745
    … …  
    37753773                pVmcs->u32PreemptTimer = 0;
    37763774
    3777             /* Cause the VMX-preemption timer VM-exit. The VM-exit qualification MBZ. */
    3778             return iemVmxVmexit(pVCpu, VMX_EXIT_PREEMPT_TIMER);
     3775            /* Cause the VMX-preemption timer VM-exit. The Exit qualification MBZ. */
     3776            return iemVmxVmexit(pVCpu, VMX_EXIT_PREEMPT_TIMER, 0 /* u64ExitQual */);
    37793777        }
    37803778    }
    … …  
    38203818             */
    38213819            if (!(pVmcs->u32ExitCtls & VMX_EXIT_CTLS_ACK_EXT_INT))
    3822                 return iemVmxVmexit(pVCpu, VMX_EXIT_EXT_INT);
     3820                return iemVmxVmexit(pVCpu, VMX_EXIT_EXT_INT, 0 /* u64ExitQual */);
    38233821
    38243822            /*
    … …  
    38463844                                          | RT_BF_MAKE(VMX_BF_EXIT_INT_INFO_VALID,            1);
    38473845            iemVmxVmcsSetExitIntInfo(pVCpu, uExitIntInfo);
    3848             return iemVmxVmexit(pVCpu, VMX_EXIT_EXT_INT);
     3846            return iemVmxVmexit(pVCpu, VMX_EXIT_EXT_INT, 0 /* u64ExitQual */);
    38493847        }
    38503848    }
    38513849
    38523850    return VINF_VMX_INTERCEPT_NOT_ACTIVE;
    3853 }
    3854 
    3855 
    3856 /**
    3857  * VMX VM-exit handler for VM-exits due to startup-IPIs (SIPI).
    3858  *
    3859  * @returns VBox strict status code.
    3860  * @param   pVCpu       The cross context virtual CPU structure.
    3861  * @param   uVector     The SIPI vector.
    3862  */
    3863 IEM_STATIC VBOXSTRICTRC iemVmxVmexitStartupIpi(PVMCPU pVCpu, uint8_t uVector)
    3864 {
    3865     iemVmxVmcsSetExitQual(pVCpu, uVector);
    3866     return iemVmxVmexit(pVCpu, VMX_EXIT_SIPI);
    38673851}
    38683852
    … …  
    38913875        iemVmxVmcsSetExitIntInfo(pVCpu, uExitIntInfo);
    38923876        iemVmxVmcsSetExitIntErrCode(pVCpu, 0);
    3893         iemVmxVmcsSetExitQual(pVCpu, 0);
    38943877        iemVmxVmcsSetExitInstrLen(pVCpu, 0);
    38953878
    … …  
    39063889        iemVmxVmcsSetIdtVectoringInfo(pVCpu, 0);
    39073890        iemVmxVmcsSetIdtVectoringErrCode(pVCpu, 0);
    3908 
    3909         return iemVmxVmexit(pVCpu, VMX_EXIT_XCPT_OR_NMI);
     3891        return iemVmxVmexit(pVCpu, VMX_EXIT_XCPT_OR_NMI, 0 /* u64ExitQual */);
    39103892    }
    39113893
    … …  
    39313913    Assert(VMX_EXIT_INT_INFO_IS_VALID(pExitEventInfo->uExitIntInfo));
    39323914
    3933     iemVmxVmcsSetExitQual(pVCpu, pExitInfo->u64Qual);
    39343915    iemVmxVmcsSetExitInstrLen(pVCpu, pExitInfo->cbInstr);
    39353916    iemVmxVmcsSetExitIntInfo(pVCpu, pExitEventInfo->uExitIntInfo);
    … …  
    39373918    iemVmxVmcsSetIdtVectoringInfo(pVCpu, pExitEventInfo->uIdtVectoringInfo);
    39383919    iemVmxVmcsSetIdtVectoringErrCode(pVCpu, pExitEventInfo->uIdtVectoringErrCode);
    3939     return iemVmxVmexit(pVCpu, VMX_EXIT_XCPT_OR_NMI);
     3920    return iemVmxVmexit(pVCpu, VMX_EXIT_XCPT_OR_NMI, pExitInfo->u64Qual);
    39403921}
    39413922
    … …  
    40234004
    40244005        /* Construct the rest of the event related information fields and cause the VM-exit. */
    4025         uint64_t uExitQual;
     4006        uint64_t u64ExitQual;
    40264007        if (uVector == X86_XCPT_PF)
    40274008        {
    40284009            Assert(fFlags & IEM_XCPT_FLAGS_CR2);
    4029             uExitQual = uCr2;
     4010            u64ExitQual = uCr2;
    40304011        }
    40314012        else if (uVector == X86_XCPT_DB)
    40324013        {
    40334014            IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_DR6);
    4034             uExitQual = pVCpu->cpum.GstCtx.dr[6] & VMX_VMCS_EXIT_QUAL_VALID_MASK;
    4035         }
    4036         else
    4037             uExitQual = 0;
     4015            u64ExitQual = pVCpu->cpum.GstCtx.dr[6] & VMX_VMCS_EXIT_QUAL_VALID_MASK;
     4016        }
     4017        else
     4018            u64ExitQual = 0;
    40384019
    40394020        uint8_t  const fNmiUnblocking = pVCpu->cpum.GstCtx.hwvirt.vmx.fNmiUnblockingIret;
    … …  
    40474028        iemVmxVmcsSetExitIntInfo(pVCpu, uExitIntInfo);
    40484029        iemVmxVmcsSetExitIntErrCode(pVCpu, uErrCode);
    4049         iemVmxVmcsSetExitQual(pVCpu, uExitQual);
    40504030
    40514031        /*
    … …  
    40604040            iemVmxVmcsSetExitInstrLen(pVCpu, 0);
    40614041
    4062         return iemVmxVmexit(pVCpu, VMX_EXIT_XCPT_OR_NMI);
     4042        return iemVmxVmexit(pVCpu, VMX_EXIT_XCPT_OR_NMI, u64ExitQual);
    40634043    }
    40644044
    … …  
    40874067    iemVmxVmcsSetIdtVectoringErrCode(pVCpu, 0);
    40884068
    4089     return iemVmxVmexit(pVCpu, VMX_EXIT_TRIPLE_FAULT);
     4069    return iemVmxVmexit(pVCpu, VMX_EXIT_TRIPLE_FAULT, 0 /* u64ExitQual */);
    40904070}
    40914071
    … …  
    41144094        enmAccess = VMXAPICACCESS_LINEAR_WRITE;
    41154095
    4116     uint64_t const uExitQual = RT_BF_MAKE(VMX_BF_EXIT_QUAL_APIC_ACCESS_OFFSET, offAccess)
    4117                              | RT_BF_MAKE(VMX_BF_EXIT_QUAL_APIC_ACCESS_TYPE,   enmAccess);
    4118     iemVmxVmcsSetExitQual(pVCpu, uExitQual);
    4119     return iemVmxVmexit(pVCpu, VMX_EXIT_APIC_ACCESS);
     4096    uint64_t const u64ExitQual = RT_BF_MAKE(VMX_BF_EXIT_QUAL_APIC_ACCESS_OFFSET, offAccess)
     4097                               | RT_BF_MAKE(VMX_BF_EXIT_QUAL_APIC_ACCESS_TYPE,   enmAccess);
     4098    return iemVmxVmexit(pVCpu, VMX_EXIT_APIC_ACCESS, u64ExitQual);
    41204099}
    41214100
    … …  
    41394118    iemVmxVmcsSetExitIntInfo(pVCpu, 0);
    41404119    iemVmxVmcsSetExitIntErrCode(pVCpu, 0);
    4141     iemVmxVmcsSetExitQual(pVCpu, pExitInfo->u64Qual);
    41424120    iemVmxVmcsSetIdtVectoringInfo(pVCpu, pExitEventInfo->uIdtVectoringInfo);
    41434121    iemVmxVmcsSetIdtVectoringErrCode(pVCpu, pExitEventInfo->uIdtVectoringErrCode);
    4144     return iemVmxVmexit(pVCpu, VMX_EXIT_APIC_ACCESS);
     4122    return iemVmxVmexit(pVCpu, VMX_EXIT_APIC_ACCESS, pExitInfo->u64Qual);
    41454123}
    41464124
    … …  
    41564134{
    41574135    Assert(offApic < XAPIC_OFF_END + 4);
    4158 
    4159     /* Write only bits 11:0 of the APIC offset into the VM-exit qualification field. */
     4136    /* Write only bits 11:0 of the APIC offset into the Exit qualification field. */
    41604137    offApic &= UINT16_C(0xfff);
    4161     iemVmxVmcsSetExitQual(pVCpu, offApic);
    4162     return iemVmxVmexit(pVCpu, VMX_EXIT_APIC_WRITE);
    4163 }
    4164 
    4165 
    4166 /**
    4167  * VMX VM-exit handler for virtualized-EOIs.
    4168  *
    4169  * @param   pVCpu       The cross context virtual CPU structure.
    4170  */
    4171 IEM_STATIC VBOXSTRICTRC iemVmxVmexitVirtEoi(PVMCPU pVCpu, uint8_t uVector)
    4172 {
    4173     iemVmxVmcsSetExitQual(pVCpu, uVector);
    4174     return iemVmxVmexit(pVCpu, VMX_EXIT_VIRTUALIZED_EOI);
     4138    return iemVmxVmexit(pVCpu, VMX_EXIT_APIC_WRITE, offApic);
    41754139}
    41764140
    … …  
    49264890        {
    49274891            Log2(("tpr_virt: uTpr=%u uTprThreshold=%u -> VM-exit\n", uTpr, uTprThreshold));
    4928             return iemVmxVmexit(pVCpu, VMX_EXIT_TPR_BELOW_THRESHOLD);
     4892            return iemVmxVmexit(pVCpu, VMX_EXIT_TPR_BELOW_THRESHOLD, 0 /* u64ExitQual */);
    49294893        }
    49304894    }
    … …  
    50014965    iemVmxPprVirtualization(pVCpu);
    50024966    if (iemVmxIsEoiInterceptSet(pVCpu, uVector))
    5003         return iemVmxVmexitVirtEoi(pVCpu, uVector);
     4967        return iemVmxVmexit(pVCpu, VMX_EXIT_VIRTUALIZED_EOI, uVector);
    50044968    iemVmxEvalPendingVirtIntrs(pVCpu);
    50054969    return VINF_SUCCESS;
    … …  
    59015865                /*
    59025866                 * We don't support injecting NMIs when blocking-by-STI would be in effect.
    5903                  * We update the VM-exit qualification only when blocking-by-STI is set
     5867                 * We update the Exit qualification only when blocking-by-STI is set
    59045868                 * without blocking-by-MovSS being set. Although in practise it  does not
    59055869                 * make much difference since the order of checks are implementation defined.
    … …  
    70517015                 * If we're in ring-0, we cannot handle returns to ring-3 at this point and continue VM-entry.
    70527016                 * If any guest hypervisor loads MSRs that require ring-3 handling, we cause a VM-entry failure
    7053                  * recording the MSR index in the VM-exit qualification (as per the Intel spec.) and indicated
     7017                 * recording the MSR index in the Exit qualification (as per the Intel spec.) and indicated
    70547018                 * further by our own, specific diagnostic code. Later, we can try implement handling of the
    70557019                 * MSR in ring-0 if possible, or come up with a better, generic solution.
    … …  
    74897453     * specified to be undefined needs to be initialized here.
    74907454     *
    7491      * Thus, it is especially important to clear the VM-exit qualification field
     7455     * Thus, it is especially important to clear the Exit qualification field
    74927456     * since it must be zero for VM-exits where it is not used. Similarly, the
    74937457     * VM-exit interruption information field's valid bit needs to be cleared for
    … …  
    76447608     * See Intel spec. 24.11.4 "Software Access to Related Structures".
    76457609     */
    7646     Assert(pVCpu->cpum.GstCtx.hwvirt.vmx.CTX_SUFF(pVmcs));
     7610    PVMXVVMCS pVmcs = pVCpu->cpum.GstCtx.hwvirt.vmx.CTX_SUFF(pVmcs);
     7611    Assert(pVmcs);
    76477612    Assert(IEM_VMX_HAS_CURRENT_VMCS(pVCpu));
     7613
    76487614    int rc = iemVmxVmentryCheckExecCtls(pVCpu, pszInstr);
    76497615    if (RT_SUCCESS(rc))
    … …  
    76827648                                /* VMLAUNCH instruction must update the VMCS launch state. */
    76837649                                if (uInstrId == VMXINSTRID_VMLAUNCH)
    7684                                     pVCpu->cpum.GstCtx.hwvirt.vmx.CTX_SUFF(pVmcs)->fVmcsState = VMX_V_VMCS_LAUNCH_STATE_LAUNCHED;
     7650                                    pVmcs->fVmcsState = VMX_V_VMCS_LAUNCH_STATE_LAUNCHED;
    76857651
    76867652                                /* Perform the VMX transition (PGM updates). */
    … …  
    77527718                                return rcStrict;
    77537719                            }
    7754                             return iemVmxVmexit(pVCpu, VMX_EXIT_ERR_MSR_LOAD | VMX_EXIT_REASON_ENTRY_FAILED);
     7720                            return iemVmxVmexit(pVCpu, VMX_EXIT_ERR_MSR_LOAD | VMX_EXIT_REASON_ENTRY_FAILED,
     7721                                                pVmcs->u64RoExitQual.u);
    77557722                        }
    77567723                    }
    7757                     return iemVmxVmexit(pVCpu, VMX_EXIT_ERR_INVALID_GUEST_STATE | VMX_EXIT_REASON_ENTRY_FAILED);
     7724                    return iemVmxVmexit(pVCpu, VMX_EXIT_ERR_INVALID_GUEST_STATE | VMX_EXIT_REASON_ENTRY_FAILED,
     7725                                        pVmcs->u64RoExitQual.u);
    77587726                }
    77597727
Note: See TracChangeset for help on using the changeset viewer.

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