VirtualBox

Changeset 79946 in vbox for trunk/src/VBox/VMM/VMMAll


Ignore:
Timestamp:
Jul 24, 2019 4:29:13 AM (6 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
132371
Message:

VMM/IEM: Nested VMX: bugref:9180 Don't use a separate HC page for the virtual-APIC page.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r79827 r79946  
    25772577            return iemVmxAbort(pVCpu, VMXABORT_SAVE_GUEST_MSRS);
    25782578
    2579         /*
    2580          * Write the contents of the virtual-APIC page back into guest memory (shouldn't really fail).
    2581          */
    2582         if (pVCpu->cpum.GstCtx.hwvirt.vmx.fVirtApicPageDirty)
    2583         {
    2584             Assert(pVmcs->u32ProcCtls & VMX_PROC_CTLS_USE_TPR_SHADOW);
    2585             int rc2 = PGMPhysSimpleWriteGCPhys(pVCpu->CTX_SUFF(pVM), pVmcs->u64AddrVirtApic.u,
    2586                                                pVCpu->cpum.GstCtx.hwvirt.vmx.CTX_SUFF(pvVirtApicPage), VMX_V_VIRT_APIC_SIZE);
    2587             AssertRCReturn(rc2, rc2);
    2588 
    2589             /* Clear the virtual-APIC page dirty bit now that it's written back to guest memory. */
    2590             pVCpu->cpum.GstCtx.hwvirt.vmx.fVirtApicPageDirty = false;
    2591         }
    2592 
    25932579        /* Clear any saved NMI-blocking state so we don't assert on next VM-entry (if it was in effect on the previous one). */
    25942580        pVCpu->cpum.GstCtx.hwvirt.fLocalForcedActions &= ~VMCPU_FF_BLOCK_NMIS;
    … …  
    38673853    Assert(pVmcs);
    38683854    Assert(offReg <= VMX_V_VIRT_APIC_SIZE - sizeof(uint32_t));
    3869     uint32_t const *pbVirtApicPage = (uint32_t const *)pVCpu->cpum.GstCtx.hwvirt.vmx.CTX_SUFF(pvVirtApicPage);
    3870     pbVirtApicPage += offReg;
    3871     uint32_t const uReg = *pbVirtApicPage;
     3855
     3856    uint32_t uReg;
     3857    RTGCPHYS const GCPhysVirtApic = pVmcs->u64AddrVirtApic.u;
     3858    int rc = PGMPhysSimpleReadGCPhys(pVCpu->CTX_SUFF(pVM), &uReg, GCPhysVirtApic + offReg, sizeof(uReg));
     3859    if (RT_SUCCESS(rc))
     3860    { /* likely */ }
     3861    else
     3862    {
     3863        AssertMsgFailed(("Failed to read %u bytes at offset %#x of the virtual-APIC page at %#RGp\n", sizeof(uReg), offReg,
     3864                         GCPhysVirtApic));
     3865        uReg = 0;
     3866    }
    38723867    return uReg;
    38733868}
    … …  
    38863881    Assert(pVmcs);
    38873882    Assert(offReg <= VMX_V_VIRT_APIC_SIZE - sizeof(uint64_t));
    3888     uint64_t const *pbVirtApicPage = (uint64_t const *)pVCpu->cpum.GstCtx.hwvirt.vmx.CTX_SUFF(pvVirtApicPage);
    3889     pbVirtApicPage += offReg;
    3890     uint64_t const uReg = *pbVirtApicPage;
     3883
     3884    uint64_t uReg;
     3885    RTGCPHYS const GCPhysVirtApic = pVmcs->u64AddrVirtApic.u;
     3886    int rc = PGMPhysSimpleReadGCPhys(pVCpu->CTX_SUFF(pVM), &uReg, GCPhysVirtApic + offReg, sizeof(uReg));
     3887    if (RT_SUCCESS(rc))
     3888    { /* likely */ }
     3889    else
     3890    {
     3891        AssertMsgFailed(("Failed to read %u bytes at offset %#x of the virtual-APIC page at %#RGp\n", sizeof(uReg), offReg,
     3892                         GCPhysVirtApic));
     3893        uReg = 0;
     3894    }
    38913895    return uReg;
    38923896}
    … …  
    39053909    Assert(pVmcs);
    39063910    Assert(offReg <= VMX_V_VIRT_APIC_SIZE - sizeof(uint32_t));
    3907     uint32_t *pbVirtApicPage = (uint32_t *)pVCpu->cpum.GstCtx.hwvirt.vmx.CTX_SUFF(pvVirtApicPage);
    3908     pbVirtApicPage += offReg;
    3909     *pbVirtApicPage = uReg;
    3910     pVCpu->cpum.GstCtx.hwvirt.vmx.fVirtApicPageDirty = true;
     3911
     3912    RTGCPHYS const GCPhysVirtApic = pVmcs->u64AddrVirtApic.u;
     3913    int rc = PGMPhysSimpleWriteGCPhys(pVCpu->CTX_SUFF(pVM), GCPhysVirtApic + offReg, &uReg, sizeof(uReg));
     3914    if (RT_SUCCESS(rc))
     3915    { /* likely */ }
     3916    else
     3917    {
     3918        AssertMsgFailed(("Failed to write %u bytes at offset %#x of the virtual-APIC page at %#RGp\n", sizeof(uReg), offReg,
     3919                         GCPhysVirtApic));
     3920    }
    39113921}
    39123922
    … …  
    39243934    Assert(pVmcs);
    39253935    Assert(offReg <= VMX_V_VIRT_APIC_SIZE - sizeof(uint64_t));
    3926     uint64_t *pbVirtApicPage = (uint64_t *)pVCpu->cpum.GstCtx.hwvirt.vmx.CTX_SUFF(pvVirtApicPage);
    3927     pbVirtApicPage += offReg;
    3928     *pbVirtApicPage = uReg;
    3929     pVCpu->cpum.GstCtx.hwvirt.vmx.fVirtApicPageDirty = true;
     3936
     3937    RTGCPHYS const GCPhysVirtApic = pVmcs->u64AddrVirtApic.u;
     3938    int rc = PGMPhysSimpleWriteGCPhys(pVCpu->CTX_SUFF(pVM), GCPhysVirtApic + offReg, &uReg, sizeof(uReg));
     3939    if (RT_SUCCESS(rc))
     3940    { /* likely */ }
     3941    else
     3942    {
     3943        AssertMsgFailed(("Failed to write %u bytes at offset %#x of the virtual-APIC page at %#RGp\n", sizeof(uReg), offReg,
     3944                         GCPhysVirtApic));
     3945    }
    39303946}
    39313947
    … …  
    39463962
    39473963    /* Determine the vector offset within the chunk. */
    3948     uint32_t       uReg;
    3949     uint32_t       *pbVirtApicPage = (uint32_t *)pVCpu->cpum.GstCtx.hwvirt.vmx.CTX_SUFF(pvVirtApicPage);
    3950     uint16_t const offVector       = (uVector & UINT32_C(0xe0)) >> 1;
     3964    uint16_t const offVector = (uVector & UINT32_C(0xe0)) >> 1;
    39513965
    39523966    /* Read the chunk at the offset. */
    3953     pbVirtApicPage += offReg + offVector;
    3954     uReg = *pbVirtApicPage;
    3955 
    3956     /* Set the vector bit in the chunk. */
    3957     uint16_t const idxVectorBit = uVector & UINT32_C(0x1f);
    3958     uReg |= RT_BIT(idxVectorBit);
    3959 
    3960     /* Write back the chunk at the offset. */
    3961     pbVirtApicPage += offReg + offVector;
    3962     *pbVirtApicPage = uReg;
    3963 
    3964     /* Mark the page dirty. */
    3965     pVCpu->cpum.GstCtx.hwvirt.vmx.fVirtApicPageDirty = true;
     3967    uint32_t uReg;
     3968    RTGCPHYS const GCPhysVirtApic = pVmcs->u64AddrVirtApic.u;
     3969    int rc = PGMPhysSimpleReadGCPhys(pVCpu->CTX_SUFF(pVM), &uReg, GCPhysVirtApic + offReg + offVector, sizeof(uReg));
     3970    if (RT_SUCCESS(rc))
     3971    {
     3972        /* Modify the chunk. */
     3973        uint16_t const idxVectorBit = uVector & UINT32_C(0x1f);
     3974        uReg |= RT_BIT(idxVectorBit);
     3975
     3976        /* Write the chunk. */
     3977        rc = PGMPhysSimpleWriteGCPhys(pVCpu->CTX_SUFF(pVM), GCPhysVirtApic + offReg + offVector, &uReg, sizeof(uReg));
     3978        if (RT_SUCCESS(rc))
     3979        { /* likely */ }
     3980        else
     3981        {
     3982            AssertMsgFailed(("Failed to set vector %#x in 256-bit register at %#x of the virtual-APIC page at %#RGp\n",
     3983                             uVector, offReg, GCPhysVirtApic));
     3984        }
     3985    }
     3986    else
     3987    {
     3988        AssertMsgFailed(("Failed to get vector %#x in 256-bit register at %#x of the virtual-APIC page at %#RGp\n",
     3989                         uVector, offReg, GCPhysVirtApic));
     3990    }
    39663991}
    39673992
    … …  
    39824007
    39834008    /* Determine the vector offset within the chunk. */
    3984     uint32_t       uReg;
    3985     uint32_t      *pbVirtApicPage = (uint32_t *)pVCpu->cpum.GstCtx.hwvirt.vmx.CTX_SUFF(pvVirtApicPage);
    39864009    uint16_t const offVector      = (uVector & UINT32_C(0xe0)) >> 1;
    39874010
    39884011    /* Read the chunk at the offset. */
    3989     pbVirtApicPage += offReg + offVector;
    3990     uReg = *pbVirtApicPage;
    3991 
    3992     /* Clear the vector bit in the chunk. */
    3993     uint16_t const idxVectorBit = uVector & UINT32_C(0x1f);
    3994     uReg &= ~RT_BIT(idxVectorBit);
    3995 
    3996     /* Write back the chunk at the offset. */
    3997     pbVirtApicPage += offReg + offVector;
    3998     *pbVirtApicPage = uReg;
    3999 
    4000     /* Mark the page dirty. */
    4001     pVCpu->cpum.GstCtx.hwvirt.vmx.fVirtApicPageDirty = true;
     4012    uint32_t uReg;
     4013    RTGCPHYS const GCPhysVirtApic = pVmcs->u64AddrVirtApic.u;
     4014    int rc = PGMPhysSimpleReadGCPhys(pVCpu->CTX_SUFF(pVM), &uReg, GCPhysVirtApic + offReg + offVector, sizeof(uReg));
     4015    if (RT_SUCCESS(rc))
     4016    {
     4017        /* Modify the chunk. */
     4018        uint16_t const idxVectorBit = uVector & UINT32_C(0x1f);
     4019        uReg &= ~RT_BIT(idxVectorBit);
     4020
     4021        /* Write the chunk. */
     4022        rc = PGMPhysSimpleWriteGCPhys(pVCpu->CTX_SUFF(pVM), GCPhysVirtApic + offReg + offVector, &uReg, sizeof(uReg));
     4023        if (RT_SUCCESS(rc))
     4024        { /* likely */ }
     4025        else
     4026        {
     4027            AssertMsgFailed(("Failed to clear vector %#x in 256-bit register at %#x of the virtual-APIC page at %#RGp\n",
     4028                             uVector, offReg, GCPhysVirtApic));
     4029        }
     4030    }
     4031    else
     4032    {
     4033        AssertMsgFailed(("Failed to get vector %#x in 256-bit register at %#x of the virtual-APIC page at %#RGp\n",
     4034                         uVector, offReg, GCPhysVirtApic));
     4035    }
    40024036}
    40034037
    … …  
    62506284            IEM_VMX_VMENTRY_FAILED_RET(pVCpu, pszInstr, pszFailure, kVmxVDiag_Vmentry_AddrVirtApicPage);
    62516285
    6252         /* Read the virtual-APIC page. */
    6253         int rc = PGMPhysSimpleReadGCPhys(pVCpu->CTX_SUFF(pVM), pVCpu->cpum.GstCtx.hwvirt.vmx.CTX_SUFF(pvVirtApicPage),
    6254                                          GCPhysVirtApic, VMX_V_VIRT_APIC_SIZE);
    6255         if (RT_SUCCESS(rc))
    6256         { /* likely */ }
    6257         else
    6258             IEM_VMX_VMENTRY_FAILED_RET(pVCpu, pszInstr, pszFailure, kVmxVDiag_Vmentry_VirtApicPagePtrReadPhys);
    6259 
    62606286        /* TPR threshold bits 31:4 MBZ without virtual-interrupt delivery. */
    62616287        if (   !(pVmcs->u32TprThreshold & ~VMX_TPR_THRESHOLD_MASK)
    … …  
    62706296        {
    62716297            /* Read the VTPR from the virtual-APIC page. */
    6272             uint8_t const *pbVirtApicPage = (uint8_t const *)pVCpu->cpum.GstCtx.hwvirt.vmx.CTX_SUFF(pvVirtApicPage);
    6273             pbVirtApicPage += XAPIC_OFF_TPR;
    6274             uint8_t const u8VTpr = *pbVirtApicPage;
     6298            uint8_t u8VTpr;
     6299            int rc = PGMPhysSimpleReadGCPhys(pVCpu->CTX_SUFF(pVM), &u8VTpr, GCPhysVirtApic + XAPIC_OFF_TPR, sizeof(u8VTpr));
     6300            if (RT_SUCCESS(rc))
     6301            { /* likely */ }
     6302            else
     6303                IEM_VMX_VMENTRY_FAILED_RET(pVCpu, pszInstr, pszFailure, kVmxVDiag_Vmentry_VirtApicPagePtrReadPhys);
    62756304
    62766305            /* Bits 3:0 of the TPR-threshold must not be greater than bits 7:4 of VTPR. */
    … …  
    72987327                                    return rcStrict;
    72997328                                }
    7300 
    7301                                 /* Clear virtual-APIC page dirty bit to ensure it's not stale due to prior, failed VM-exits. */
    7302                                 pVCpu->cpum.GstCtx.hwvirt.vmx.fVirtApicPageDirty = false;
    73037329
    73047330                                /* We've now entered nested-guest execution. */
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