VirtualBox

Changeset 97053 in vbox


Ignore:
Timestamp:
Oct 7, 2022 9:59:10 PM (2 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
154002
Message:

VMM/HMVMXR0: Use a couple of template functions to try pack VMREADs into VMXTRANSIENT better.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r97041 r97053  
    3939#endif
    4040
     41/** Enables condensing of VMREAD instructions, see vmxHCReadToTransient(). */
     42#define HMVMX_WITH_CONDENSED_VMREADS
    4143
    4244/** Use the function table. */
    … …  
    13411343    }
    13421344}
     1345
     1346
     1347/**
     1348 * Reads VMCS fields into the VMXTRANSIENT structure, slow path version.
     1349 *
     1350 * Don't call directly unless the it's likely that some or all of the fields
     1351 * given in @a a_fReadMask have already been read.
     1352 *
     1353 * @tparam  a_fReadMask     The fields to read.
     1354 * @param   pVCpu           The cross context virtual CPU structure.
     1355 * @param   pVmxTransient   The VMX-transient structure.
     1356 */
     1357template<uint32_t const a_fReadMask>
     1358static void vmxHCReadToTransientSlow(PVMCPUCC pVCpu, PVMXTRANSIENT pVmxTransient)
     1359{
     1360    if ((pVmxTransient->fVmcsFieldsRead & a_fReadMask) != a_fReadMask)
     1361    {
     1362        uint32_t const fVmcsFieldsRead = pVmxTransient->fVmcsFieldsRead;
     1363        int            rc;
     1364
     1365        if (   (a_fReadMask      & HMVMX_READ_EXIT_QUALIFICATION)
     1366            && !(fVmcsFieldsRead & HMVMX_READ_EXIT_QUALIFICATION))
     1367        {
     1368            rc = VMX_VMCS_READ_NW(pVCpu, VMX_VMCS_RO_EXIT_QUALIFICATION,             &pVmxTransient->uExitQual);
     1369            AssertRC(rc);
     1370        }
     1371        if (    (a_fReadMask     & HMVMX_READ_EXIT_INSTR_LEN)
     1372            && !(fVmcsFieldsRead & HMVMX_READ_EXIT_INSTR_LEN))
     1373        {
     1374            rc = VMX_VMCS_READ_32(pVCpu, VMX_VMCS32_RO_EXIT_INSTR_LENGTH,            &pVmxTransient->cbExitInstr);
     1375            AssertRC(rc);
     1376        }
     1377        if (   (a_fReadMask      & HMVMX_READ_EXIT_INSTR_INFO)
     1378            && !(fVmcsFieldsRead & HMVMX_READ_EXIT_INSTR_INFO))
     1379        {
     1380            rc = VMX_VMCS_READ_32(pVCpu, VMX_VMCS32_RO_EXIT_INSTR_INFO,              &pVmxTransient->ExitInstrInfo.u);
     1381            AssertRC(rc);
     1382        }
     1383        if (   (a_fReadMask      & HMVMX_READ_IDT_VECTORING_INFO)
     1384            && !(fVmcsFieldsRead & HMVMX_READ_IDT_VECTORING_INFO))
     1385        {
     1386            rc = VMX_VMCS_READ_32(pVCpu, VMX_VMCS32_RO_IDT_VECTORING_INFO,           &pVmxTransient->uIdtVectoringInfo);
     1387            AssertRC(rc);
     1388        }
     1389        if (   (a_fReadMask      & HMVMX_READ_IDT_VECTORING_ERROR_CODE)
     1390            && !(fVmcsFieldsRead & HMVMX_READ_IDT_VECTORING_ERROR_CODE))
     1391        {
     1392            rc = VMX_VMCS_READ_32(pVCpu, VMX_VMCS32_RO_IDT_VECTORING_ERROR_CODE,     &pVmxTransient->uIdtVectoringErrorCode);
     1393            AssertRC(rc);
     1394        }
     1395        if (   (a_fReadMask      & HMVMX_READ_EXIT_INTERRUPTION_INFO)
     1396            && !(fVmcsFieldsRead & HMVMX_READ_EXIT_INTERRUPTION_INFO))
     1397        {
     1398            rc = VMX_VMCS_READ_32(pVCpu, VMX_VMCS32_RO_EXIT_INTERRUPTION_INFO,       &pVmxTransient->uExitIntInfo);
     1399            AssertRC(rc);
     1400        }
     1401        if (    (a_fReadMask     & HMVMX_READ_EXIT_INTERRUPTION_ERROR_CODE)
     1402            && !(fVmcsFieldsRead & HMVMX_READ_EXIT_INTERRUPTION_ERROR_CODE))
     1403        {
     1404            rc = VMX_VMCS_READ_32(pVCpu, VMX_VMCS32_RO_EXIT_INTERRUPTION_ERROR_CODE, &pVmxTransient->uExitIntErrorCode);
     1405            AssertRC(rc);
     1406        }
     1407        if (   (a_fReadMask      & HMVMX_READ_GUEST_LINEAR_ADDR)
     1408            && !(fVmcsFieldsRead & HMVMX_READ_GUEST_LINEAR_ADDR))
     1409        {
     1410            rc = VMX_VMCS_READ_NW(pVCpu, VMX_VMCS_RO_GUEST_LINEAR_ADDR,              &pVmxTransient->uGuestLinearAddr);
     1411            AssertRC(rc);
     1412        }
     1413        if (   (a_fReadMask      & HMVMX_READ_GUEST_PHYSICAL_ADDR)
     1414            && !(fVmcsFieldsRead & HMVMX_READ_GUEST_PHYSICAL_ADDR))
     1415        {
     1416            rc = VMX_VMCS_READ_64(pVCpu, VMX_VMCS64_RO_GUEST_PHYS_ADDR_FULL,         &pVmxTransient->uGuestPhysicalAddr);
     1417            AssertRC(rc);
     1418        }
     1419
     1420        pVmxTransient->fVmcsFieldsRead |= a_fReadMask;
     1421    }
     1422}
     1423
     1424
     1425/**
     1426 * Reads VMCS fields into the VMXTRANSIENT structure.
     1427 *
     1428 * This optimizes for the case where none of @a a_fReadMask has been read yet,
     1429 * generating an optimized read sequences w/o any conditionals between in
     1430 * non-strict builds.
     1431 *
     1432 * @tparam  a_fReadMask     The fields to read.  One or more of the
     1433 *                          HMVMX_READ_XXX fields ORed together.
     1434 * @param   pVCpu           The cross context virtual CPU structure.
     1435 * @param   pVmxTransient   The VMX-transient structure.
     1436 */
     1437template<uint32_t const a_fReadMask>
     1438DECLINLINE(void) vmxHCReadToTransient(PVMCPUCC pVCpu, PVMXTRANSIENT pVmxTransient)
     1439{
     1440    if (RT_LIKELY(!(pVmxTransient->fVmcsFieldsRead & a_fReadMask)))
     1441    {
     1442        int rc;
     1443        if (a_fReadMask & HMVMX_READ_EXIT_QUALIFICATION)
     1444        {
     1445            rc = VMX_VMCS_READ_NW(pVCpu, VMX_VMCS_RO_EXIT_QUALIFICATION,             &pVmxTransient->uExitQual);
     1446            AssertRC(rc);
     1447        }
     1448        if (a_fReadMask & HMVMX_READ_EXIT_INSTR_LEN)
     1449        {
     1450            rc = VMX_VMCS_READ_32(pVCpu, VMX_VMCS32_RO_EXIT_INSTR_LENGTH,            &pVmxTransient->cbExitInstr);
     1451            AssertRC(rc);
     1452        }
     1453        if (a_fReadMask & HMVMX_READ_EXIT_INSTR_INFO)
     1454        {
     1455            rc = VMX_VMCS_READ_32(pVCpu, VMX_VMCS32_RO_EXIT_INSTR_INFO,              &pVmxTransient->ExitInstrInfo.u);
     1456            AssertRC(rc);
     1457        }
     1458        if (a_fReadMask & HMVMX_READ_IDT_VECTORING_INFO)
     1459        {
     1460            rc = VMX_VMCS_READ_32(pVCpu, VMX_VMCS32_RO_IDT_VECTORING_INFO,           &pVmxTransient->uIdtVectoringInfo);
     1461            AssertRC(rc);
     1462        }
     1463        if (a_fReadMask & HMVMX_READ_IDT_VECTORING_ERROR_CODE)
     1464        {
     1465            rc = VMX_VMCS_READ_32(pVCpu, VMX_VMCS32_RO_IDT_VECTORING_ERROR_CODE,     &pVmxTransient->uIdtVectoringErrorCode);
     1466            AssertRC(rc);
     1467        }
     1468        if (a_fReadMask & HMVMX_READ_EXIT_INTERRUPTION_INFO)
     1469        {
     1470            rc = VMX_VMCS_READ_32(pVCpu, VMX_VMCS32_RO_EXIT_INTERRUPTION_INFO,       &pVmxTransient->uExitIntInfo);
     1471            AssertRC(rc);
     1472        }
     1473        if (a_fReadMask & HMVMX_READ_EXIT_INTERRUPTION_ERROR_CODE)
     1474        {
     1475            rc = VMX_VMCS_READ_32(pVCpu, VMX_VMCS32_RO_EXIT_INTERRUPTION_ERROR_CODE, &pVmxTransient->uExitIntErrorCode);
     1476            AssertRC(rc);
     1477        }
     1478        if (a_fReadMask & HMVMX_READ_GUEST_LINEAR_ADDR)
     1479        {
     1480            rc = VMX_VMCS_READ_NW(pVCpu, VMX_VMCS_RO_GUEST_LINEAR_ADDR,              &pVmxTransient->uGuestLinearAddr);
     1481            AssertRC(rc);
     1482        }
     1483        if (a_fReadMask & HMVMX_READ_GUEST_PHYSICAL_ADDR)
     1484        {
     1485            rc = VMX_VMCS_READ_64(pVCpu, VMX_VMCS64_RO_GUEST_PHYS_ADDR_FULL,         &pVmxTransient->uGuestPhysicalAddr);
     1486            AssertRC(rc);
     1487        }
     1488
     1489        pVmxTransient->fVmcsFieldsRead |= a_fReadMask;
     1490    }
     1491    else
     1492        vmxHCReadToTransientSlow<a_fReadMask>(pVCpu, pVmxTransient);
     1493}
     1494
    13431495
    13441496#ifdef HMVMX_ALWAYS_SAVE_RO_GUEST_STATE
    … …  
    71077259        {
    71087260            NOREF(uVector);
     7261#ifdef HMVMX_WITH_CONDENSED_VMREADS
     7262            vmxHCReadToTransient<  HMVMX_READ_EXIT_INTERRUPTION_ERROR_CODE
     7263                                 | HMVMX_READ_EXIT_INSTR_LEN
     7264                                 | HMVMX_READ_IDT_VECTORING_INFO
     7265                                 | HMVMX_READ_IDT_VECTORING_ERROR_CODE>(pVCpu, pVmxTransient);
     7266#else
    71097267            vmxHCReadExitIntErrorCodeVmcs(pVCpu, pVmxTransient);
    71107268            vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
    71117269            vmxHCReadIdtVectoringInfoVmcs(pVCpu, pVmxTransient);
    71127270            vmxHCReadIdtVectoringErrorCodeVmcs(pVCpu, pVmxTransient);
    7113 
     7271#endif
    71147272            rcStrict = vmxHCExitXcpt(pVCpu, pVmxTransient);
    71157273            break;
    … …  
    74277585
    74287586    PVMXVMCSINFO pVmcsInfo = pVmxTransient->pVmcsInfo;
     7587#ifdef HMVMX_WITH_CONDENSED_VMREADS
     7588    vmxHCReadToTransient<  HMVMX_READ_EXIT_QUALIFICATION
     7589                         | HMVMX_READ_EXIT_INSTR_LEN>(pVCpu, pVmxTransient);
     7590#else
    74297591    vmxHCReadExitQualVmcs(pVCpu, pVmxTransient);
    74307592    vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
     7593#endif
    74317594    int rc = vmxHCImportGuestState(pVCpu, pVmcsInfo, IEM_CPUMCTX_EXTRN_EXEC_DECODED_MEM_MASK);
    74327595    AssertRCReturn(rc, rc);
    … …  
    76047767    return VERR_EM_INTERPRETER;
    76057768#else
     7769# ifdef HMVMX_WITH_CONDENSED_VMREADS
     7770    vmxHCReadToTransient<  HMVMX_READ_EXIT_QUALIFICATION
     7771                         | HMVMX_READ_EXIT_INSTR_INFO
     7772                         | HMVMX_READ_EXIT_INSTR_LEN>(pVCpu, pVmxTransient);
     7773# else
    76067774    vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
    76077775    vmxHCReadExitInstrInfoVmcs(pVCpu, pVmxTransient);
    76087776    vmxHCReadExitQualVmcs(pVCpu, pVmxTransient);
     7777# endif
    76097778    int rc = vmxHCImportGuestState(pVCpu, pVmxTransient->pVmcsInfo, CPUMCTX_EXTRN_RSP | CPUMCTX_EXTRN_SREG_MASK
    76107779                                                                    | IEM_CPUMCTX_EXTRN_EXEC_DECODED_MEM_MASK);
    … …  
    76567825    uint32_t fIntrState;
    76577826    uint64_t u64Val;
     7827# ifdef HMVMX_WITH_CONDENSED_VMREADS
     7828    vmxHCReadToTransient<  HMVMX_READ_EXIT_INSTR_INFO
     7829                         | HMVMX_READ_EXIT_INSTR_LEN>(pVCpu, pVmxTransient);
     7830# else
    76587831    vmxHCReadEntryIntInfoVmcs(pVCpu, pVmxTransient);
     7832    vmxHCReadEntryInstrLenVmcs(pVCpu, pVmxTransient);
     7833# endif
    76597834    vmxHCReadEntryXcptErrorCodeVmcs(pVCpu, pVmxTransient);
    7660     vmxHCReadEntryInstrLenVmcs(pVCpu, pVmxTransient);
    76617835
    76627836    Log4(("uInvalidReason                             %u\n",     uInvalidReason));
    … …  
    80458219
    80468220    PVMXVMCSINFO pVmcsInfo = pVmxTransient->pVmcsInfo;
     8221# ifdef HMVMX_WITH_CONDENSED_VMREADS
     8222    vmxHCReadToTransient<  HMVMX_READ_EXIT_QUALIFICATION
     8223                         | HMVMX_READ_EXIT_INSTR_LEN>(pVCpu, pVmxTransient);
     8224# else
    80478225    vmxHCReadExitQualVmcs(pVCpu, pVmxTransient);
    80488226    vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
     8227# endif
    80498228
    80508229    VBOXSTRICTRC rcStrict;
    … …  
    82218400    PCPUMCTX pCtx = &pVCpu->cpum.GstCtx;
    82228401    PVMXVMCSINFO pVmcsInfo = pVmxTransient->pVmcsInfo;
     8402# ifdef HMVMX_WITH_CONDENSED_VMREADS
     8403    vmxHCReadToTransient<  HMVMX_READ_EXIT_QUALIFICATION
     8404                         | HMVMX_READ_EXIT_INSTR_LEN>(pVCpu, pVmxTransient);
     8405# else
    82238406    vmxHCReadExitQualVmcs(pVCpu, pVmxTransient);
    82248407    vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
     8408#endif
    82258409    int rc = vmxHCImportGuestState(pVCpu, pVmcsInfo, IEM_CPUMCTX_EXTRN_MUST_MASK | CPUMCTX_EXTRN_SREG_MASK
    82268410                                                     | CPUMCTX_EXTRN_EFER);
    … …  
    84868670
    84878671            vmxHCSetPendingEvent(pVCpu, VMX_ENTRY_INT_INFO_FROM_EXIT_IDT_INFO(pVmxTransient->uIdtVectoringInfo),
    8488                                    pVmxTransient->cbExitInstr, uErrCode, GCPtrFaultAddress);
     8672                                 pVmxTransient->cbExitInstr, uErrCode, GCPtrFaultAddress);
    84898673
    84908674            Log4Func(("Pending event. uIntType=%#x uVector=%#x\n", VMX_IDT_VECTORING_INFO_TYPE(pVmxTransient->uIdtVectoringInfo),
    … …  
    85248708    STAM_COUNTER_INC(&VCPU_2_VMXSTATS(pVCpu).StatExitApicAccess);
    85258709
     8710#ifdef HMVMX_WITH_CONDENSED_VMREADS
     8711    vmxHCReadToTransient<  HMVMX_READ_EXIT_QUALIFICATION
     8712                         | HMVMX_READ_EXIT_INSTR_LEN
     8713                         | HMVMX_READ_EXIT_INTERRUPTION_INFO
     8714                         | HMVMX_READ_EXIT_INTERRUPTION_ERROR_CODE
     8715                         | HMVMX_READ_IDT_VECTORING_INFO
     8716                         | HMVMX_READ_IDT_VECTORING_ERROR_CODE>(pVCpu, pVmxTransient);
     8717#else
     8718    vmxHCReadExitQualVmcs(pVCpu, pVmxTransient);
     8719    vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
    85268720    vmxHCReadExitIntInfoVmcs(pVCpu, pVmxTransient);
    85278721    vmxHCReadExitIntErrorCodeVmcs(pVCpu, pVmxTransient);
    8528     vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
    85298722    vmxHCReadIdtVectoringInfoVmcs(pVCpu, pVmxTransient);
    85308723    vmxHCReadIdtVectoringErrorCodeVmcs(pVCpu, pVmxTransient);
     8724#endif
    85318725
    85328726    /*
    … …  
    85518745    /* IOMMIOPhysHandler() below may call into IEM, save the necessary state. */
    85528746    PVMXVMCSINFO pVmcsInfo = pVmxTransient->pVmcsInfo;
    8553     vmxHCReadExitQualVmcs(pVCpu, pVmxTransient);
    85548747    int rc = vmxHCImportGuestState(pVCpu, pVmcsInfo, IEM_CPUMCTX_EXTRN_MUST_MASK);
    85558748    AssertRCReturn(rc, rc);
    … …  
    87188911    Assert(pVCpu->CTX_SUFF(pVM)->hmr0.s.fNestedPaging);
    87198912
     8913# ifdef HMVMX_WITH_CONDENSED_VMREADS
     8914    vmxHCReadToTransient<  HMVMX_READ_EXIT_INSTR_LEN
     8915                         | HMVMX_READ_EXIT_INTERRUPTION_INFO
     8916                         | HMVMX_READ_EXIT_INTERRUPTION_ERROR_CODE
     8917                         | HMVMX_READ_IDT_VECTORING_INFO
     8918                         | HMVMX_READ_IDT_VECTORING_ERROR_CODE
     8919                         | HMVMX_READ_GUEST_PHYSICAL_ADDR>(pVCpu, pVmxTransient);
     8920# else
     8921    vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
    87208922    vmxHCReadExitIntInfoVmcs(pVCpu, pVmxTransient);
    87218923    vmxHCReadExitIntErrorCodeVmcs(pVCpu, pVmxTransient);
    8722     vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
    87238924    vmxHCReadIdtVectoringInfoVmcs(pVCpu, pVmxTransient);
    87248925    vmxHCReadIdtVectoringErrorCodeVmcs(pVCpu, pVmxTransient);
     8926# endif
    87258927
    87268928    /*
    … …  
    87408942        {
    87418943            STAM_COUNTER_INC(&VCPU_2_VMXSTATS(pVCpu).StatInjectInterpret);
    8742 #ifdef VBOX_WITH_NESTED_HWVIRT_VMX
     8944# ifdef VBOX_WITH_NESTED_HWVIRT_VMX
    87438945            /** @todo NSTVMX: Think about how this should be handled. */
    87448946            if (pVmxTransient->fIsNestedGuest)
    87458947                return VERR_VMX_IPE_3;
    8746 #endif
     8948# endif
    87478949            return VINF_EM_RAW_INJECT_TRPM_EVENT;
    87488950        }
    … …  
    87588960     */
    87598961    PVMXVMCSINFO pVmcsInfo = pVmxTransient->pVmcsInfo;
     8962# ifndef HMVMX_WITH_CONDENSED_VMREADS
    87608963    vmxHCReadGuestPhysicalAddrVmcs(pVCpu, pVmxTransient);
     8964# endif
    87618965    int rc = vmxHCImportGuestState(pVCpu, pVmcsInfo, IEM_CPUMCTX_EXTRN_MUST_MASK);
    87628966    AssertRCReturn(rc, rc);
    … …  
    88319035    Assert(pVCpu->CTX_SUFF(pVM)->hmr0.s.fNestedPaging);
    88329036
     9037# ifdef HMVMX_WITH_CONDENSED_VMREADS
     9038    vmxHCReadToTransient<  HMVMX_READ_EXIT_QUALIFICATION
     9039                         | HMVMX_READ_EXIT_INSTR_LEN
     9040                         | HMVMX_READ_EXIT_INTERRUPTION_INFO
     9041                         | HMVMX_READ_EXIT_INTERRUPTION_ERROR_CODE
     9042                         | HMVMX_READ_IDT_VECTORING_INFO
     9043                         | HMVMX_READ_IDT_VECTORING_ERROR_CODE
     9044                         | HMVMX_READ_GUEST_PHYSICAL_ADDR>(pVCpu, pVmxTransient);
     9045# else
    88339046    vmxHCReadExitQualVmcs(pVCpu, pVmxTransient);
     9047    vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
    88349048    vmxHCReadExitIntInfoVmcs(pVCpu, pVmxTransient);
    88359049    vmxHCReadExitIntErrorCodeVmcs(pVCpu, pVmxTransient);
    8836     vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
    88379050    vmxHCReadIdtVectoringInfoVmcs(pVCpu, pVmxTransient);
    88389051    vmxHCReadIdtVectoringErrorCodeVmcs(pVCpu, pVmxTransient);
     9052# endif
    88399053
    88409054    /*
    … …  
    88589072
    88599073    PVMXVMCSINFO pVmcsInfo = pVmxTransient->pVmcsInfo;
     9074# ifndef HMVMX_WITH_CONDENSED_VMREADS
    88609075    vmxHCReadGuestPhysicalAddrVmcs(pVCpu, pVmxTransient);
     9076# endif
    88619077    int rc = vmxHCImportGuestState(pVCpu, pVmcsInfo, IEM_CPUMCTX_EXTRN_MUST_MASK);
    88629078    AssertRCReturn(rc, rc);
    … …  
    88969112        return VINF_SUCCESS;
    88979113    }
    8898 #else
     9114    Log4Func(("EPT return to ring-3 rcStrict=%Rrc\n", VBOXSTRICTRC_VAL(rcStrict)));
     9115    return rcStrict;
     9116
     9117#else /* IN_NEM_DARWIN */
    88999118    PVM pVM = pVCpu->CTX_SUFF(pVM);
    89009119    uint64_t const uHostTsc = ASMReadTSC(); RT_NOREF(uHostTsc);
    … …  
    89669185
    89679186    ASMAtomicUoOrU64(&VCPU_2_VMXSTATE(pVCpu).fCtxChanged, HM_CHANGED_ALL_GUEST);
    8968 #endif
    8969 
    8970     Log4Func(("EPT return to ring-3 rcStrict2=%Rrc\n", VBOXSTRICTRC_VAL(rcStrict)));
     9187
     9188    Log4Func(("EPT return rcStrict=%Rrc\n", VBOXSTRICTRC_VAL(rcStrict)));
    89719189    return rcStrict;
     9190#endif /* IN_NEM_DARWIN */
    89729191}
    89739192
    … …  
    89819200    HMVMX_VALIDATE_EXIT_HANDLER_PARAMS(pVCpu, pVmxTransient);
    89829201
     9202# ifdef HMVMX_WITH_CONDENSED_VMREADS
     9203    vmxHCReadToTransient<  HMVMX_READ_EXIT_QUALIFICATION
     9204                         | HMVMX_READ_EXIT_INSTR_INFO
     9205                         | HMVMX_READ_EXIT_INSTR_LEN>(pVCpu, pVmxTransient);
     9206# else
    89839207    vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
    89849208    vmxHCReadExitInstrInfoVmcs(pVCpu, pVmxTransient);
    89859209    vmxHCReadExitQualVmcs(pVCpu, pVmxTransient);
     9210# endif
    89869211    int rc = vmxHCImportGuestState(pVCpu, pVmxTransient->pVmcsInfo, CPUMCTX_EXTRN_RSP | CPUMCTX_EXTRN_SREG_MASK
    89879212                                                                    | CPUMCTX_EXTRN_HWVIRT
    … …  
    90429267    HMVMX_VALIDATE_EXIT_HANDLER_PARAMS(pVCpu, pVmxTransient);
    90439268
     9269# ifdef HMVMX_WITH_CONDENSED_VMREADS
     9270    vmxHCReadToTransient<  HMVMX_READ_EXIT_QUALIFICATION
     9271                         | HMVMX_READ_EXIT_INSTR_INFO
     9272                         | HMVMX_READ_EXIT_INSTR_LEN>(pVCpu, pVmxTransient);
     9273# else
    90449274    vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
    90459275    vmxHCReadExitInstrInfoVmcs(pVCpu, pVmxTransient);
    90469276    vmxHCReadExitQualVmcs(pVCpu, pVmxTransient);
     9277# endif
    90479278    int rc = vmxHCImportGuestState(pVCpu, pVmxTransient->pVmcsInfo, CPUMCTX_EXTRN_RSP | CPUMCTX_EXTRN_SREG_MASK
    90489279                                                                    | CPUMCTX_EXTRN_HWVIRT
    … …  
    90749305    HMVMX_VALIDATE_EXIT_HANDLER_PARAMS(pVCpu, pVmxTransient);
    90759306
     9307# ifdef HMVMX_WITH_CONDENSED_VMREADS
     9308    vmxHCReadToTransient<  HMVMX_READ_EXIT_QUALIFICATION
     9309                         | HMVMX_READ_EXIT_INSTR_INFO
     9310                         | HMVMX_READ_EXIT_INSTR_LEN>(pVCpu, pVmxTransient);
     9311# else
    90769312    vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
    90779313    vmxHCReadExitInstrInfoVmcs(pVCpu, pVmxTransient);
    90789314    vmxHCReadExitQualVmcs(pVCpu, pVmxTransient);
     9315#endif
    90799316    int rc = vmxHCImportGuestState(pVCpu, pVmxTransient->pVmcsInfo, CPUMCTX_EXTRN_RSP | CPUMCTX_EXTRN_SREG_MASK
    90809317                                                                    | CPUMCTX_EXTRN_HWVIRT
    … …  
    91119348     * code elsewhere dares look at unsynced VMCS fields.
    91129349     */
     9350# ifdef HMVMX_WITH_CONDENSED_VMREADS
     9351    vmxHCReadToTransient<  HMVMX_READ_EXIT_QUALIFICATION
     9352                         | HMVMX_READ_EXIT_INSTR_INFO
     9353                         | HMVMX_READ_EXIT_INSTR_LEN>(pVCpu, pVmxTransient);
     9354# else
    91139355    vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
    91149356    vmxHCReadExitInstrInfoVmcs(pVCpu, pVmxTransient);
    91159357    vmxHCReadExitQualVmcs(pVCpu, pVmxTransient);
     9358# endif
    91169359    int rc = vmxHCImportGuestState(pVCpu, pVmxTransient->pVmcsInfo, CPUMCTX_EXTRN_RSP | CPUMCTX_EXTRN_SREG_MASK
    91179360                                                                    | CPUMCTX_EXTRN_HWVIRT
    … …  
    91999442     * flags re-loading the entire shadow VMCS, we should save the entire shadow VMCS here.
    92009443     */
     9444# ifdef HMVMX_WITH_CONDENSED_VMREADS
     9445    vmxHCReadToTransient<  HMVMX_READ_EXIT_QUALIFICATION
     9446                         | HMVMX_READ_EXIT_INSTR_INFO
     9447                         | HMVMX_READ_EXIT_INSTR_LEN>(pVCpu, pVmxTransient);
     9448# else
    92019449    vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
    92029450    vmxHCReadExitInstrInfoVmcs(pVCpu, pVmxTransient);
    92039451    vmxHCReadExitQualVmcs(pVCpu, pVmxTransient);
     9452# endif
    92049453    int rc = vmxHCImportGuestState(pVCpu, pVmxTransient->pVmcsInfo, CPUMCTX_EXTRN_RSP | CPUMCTX_EXTRN_SREG_MASK
    92059454                                                                    | CPUMCTX_EXTRN_HWVIRT
    … …  
    92599508    HMVMX_VALIDATE_EXIT_HANDLER_PARAMS(pVCpu, pVmxTransient);
    92609509
     9510# ifdef HMVMX_WITH_CONDENSED_VMREADS
     9511    vmxHCReadToTransient<  HMVMX_READ_EXIT_QUALIFICATION
     9512                         | HMVMX_READ_EXIT_INSTR_INFO
     9513                         | HMVMX_READ_EXIT_INSTR_LEN>(pVCpu, pVmxTransient);
     9514# else
    92619515    vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
    92629516    vmxHCReadExitInstrInfoVmcs(pVCpu, pVmxTransient);
    92639517    vmxHCReadExitQualVmcs(pVCpu, pVmxTransient);
     9518# endif
    92649519    int rc = vmxHCImportGuestState(pVCpu, pVmxTransient->pVmcsInfo, CPUMCTX_EXTRN_RSP | CPUMCTX_EXTRN_SREG_MASK
    92659520                                                                    | CPUMCTX_EXTRN_HWVIRT
    … …  
    92919546    HMVMX_VALIDATE_EXIT_HANDLER_PARAMS(pVCpu, pVmxTransient);
    92929547
     9548# ifdef HMVMX_WITH_CONDENSED_VMREADS
     9549    vmxHCReadToTransient<  HMVMX_READ_EXIT_QUALIFICATION
     9550                         | HMVMX_READ_EXIT_INSTR_INFO
     9551                         | HMVMX_READ_EXIT_INSTR_LEN>(pVCpu, pVmxTransient);
     9552# else
    92939553    vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
    92949554    vmxHCReadExitInstrInfoVmcs(pVCpu, pVmxTransient);
    92959555    vmxHCReadExitQualVmcs(pVCpu, pVmxTransient);
     9556# endif
    92969557    int rc = vmxHCImportGuestState(pVCpu, pVmxTransient->pVmcsInfo, CPUMCTX_EXTRN_RSP | CPUMCTX_EXTRN_SREG_MASK
    92979558                                                                    | IEM_CPUMCTX_EXTRN_EXEC_DECODED_MEM_MASK);
    … …  
    93239584    HMVMX_VALIDATE_EXIT_HANDLER_PARAMS(pVCpu, pVmxTransient);
    93249585
     9586# ifdef HMVMX_WITH_CONDENSED_VMREADS
     9587    vmxHCReadToTransient<  HMVMX_READ_EXIT_QUALIFICATION
     9588                         | HMVMX_READ_EXIT_INSTR_INFO
     9589                         | HMVMX_READ_EXIT_INSTR_LEN>(pVCpu, pVmxTransient);
     9590# else
    93259591    vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
    93269592    vmxHCReadExitInstrInfoVmcs(pVCpu, pVmxTransient);
    93279593    vmxHCReadExitQualVmcs(pVCpu, pVmxTransient);
     9594# endif
    93289595    int rc = vmxHCImportGuestState(pVCpu, pVmxTransient->pVmcsInfo, CPUMCTX_EXTRN_RSP | CPUMCTX_EXTRN_SREG_MASK
    93299596                                                                    | IEM_CPUMCTX_EXTRN_EXEC_DECODED_MEM_MASK);
    … …  
    93939660        case VMX_EXIT_INT_INFO_TYPE_HW_XCPT:
    93949661        {
     9662# ifdef HMVMX_WITH_CONDENSED_VMREADS
     9663            vmxHCReadToTransient<  HMVMX_READ_EXIT_INTERRUPTION_ERROR_CODE
     9664                                 | HMVMX_READ_EXIT_INSTR_LEN
     9665                                 | HMVMX_READ_IDT_VECTORING_INFO
     9666                                 | HMVMX_READ_IDT_VECTORING_ERROR_CODE>(pVCpu, pVmxTransient);
     9667# else
    93959668            vmxHCReadExitIntErrorCodeVmcs(pVCpu, pVmxTransient);
    93969669            vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
    93979670            vmxHCReadIdtVectoringInfoVmcs(pVCpu, pVmxTransient);
    93989671            vmxHCReadIdtVectoringErrorCodeVmcs(pVCpu, pVmxTransient);
     9672# endif
    93999673
    94009674            PCCPUMCTX pCtx = &pVCpu->cpum.GstCtx;
    9401             bool const fIntercept = CPUMIsGuestVmxXcptInterceptSet(pCtx, VMX_EXIT_INT_INFO_VECTOR(uExitIntInfo),
    9402                                                                    pVmxTransient->uExitIntErrorCode);
    9403             if (fIntercept)
     9675            if (CPUMIsGuestVmxXcptInterceptSet(pCtx, VMX_EXIT_INT_INFO_VECTOR(uExitIntInfo), pVmxTransient->uExitIntErrorCode))
    94049676            {
    94059677                /* Exit qualification is required for debug and page-fault exceptions. */
    … …  
    94999771    HMVMX_VALIDATE_NESTED_EXIT_HANDLER_PARAMS(pVCpu, pVmxTransient);
    95009772
     9773# ifdef HMVMX_WITH_CONDENSED_VMREADS
     9774    vmxHCReadToTransient<  HMVMX_READ_EXIT_QUALIFICATION
     9775                         | HMVMX_READ_EXIT_INSTR_LEN
     9776                         | HMVMX_READ_IDT_VECTORING_INFO
     9777                         | HMVMX_READ_IDT_VECTORING_ERROR_CODE>(pVCpu, pVmxTransient);
     9778# else
    95019779    vmxHCReadExitQualVmcs(pVCpu, pVmxTransient);
    95029780    vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
    95039781    vmxHCReadIdtVectoringInfoVmcs(pVCpu, pVmxTransient);
    95049782    vmxHCReadIdtVectoringErrorCodeVmcs(pVCpu, pVmxTransient);
    9505 
     9783# endif
    95069784    VMXVEXITINFO const      ExitInfo      = VMXVEXITINFO_INIT_WITH_QUAL_AND_INSTR_LEN_FROM_TRANSIENT(pVmxTransient);
    95079785    VMXVEXITEVENTINFO const ExitEventInfo = VMXVEXITEVENTINFO_INIT_ONLY_IDT(pVmxTransient->uIdtVectoringInfo,
    … …  
    95369814    if (CPUMIsGuestVmxProcCtlsSet(&pVCpu->cpum.GstCtx, VMX_PROC_CTLS_INVLPG_EXIT))
    95379815    {
     9816# ifdef HMVMX_WITH_CONDENSED_VMREADS
     9817        vmxHCReadToTransient<  HMVMX_READ_EXIT_QUALIFICATION
     9818                             | HMVMX_READ_EXIT_INSTR_LEN>(pVCpu, pVmxTransient);
     9819# else
    95389820        vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
    95399821        vmxHCReadExitQualVmcs(pVCpu, pVmxTransient);
    9540 
     9822# endif
    95419823        VMXVEXITINFO const ExitInfo = VMXVEXITINFO_INIT_WITH_QUAL_AND_INSTR_LEN_FROM_TRANSIENT(pVmxTransient);
    95429824        return IEMExecVmxVmexitInstrWithInfo(pVCpu, &ExitInfo);
    … …  
    95859867    if (CPUMIsGuestVmxVmreadVmwriteInterceptSet(pVCpu, pVmxTransient->uExitReason, u64VmcsField))
    95869868    {
     9869# ifdef HMVMX_WITH_CONDENSED_VMREADS
     9870        vmxHCReadToTransient<  HMVMX_READ_EXIT_QUALIFICATION
     9871                             | HMVMX_READ_EXIT_INSTR_LEN>(pVCpu, pVmxTransient);
     9872# else
    95879873        vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
    95889874        vmxHCReadExitQualVmcs(pVCpu, pVmxTransient);
    9589 
     9875# endif
    95909876        VMXVEXITINFO const ExitInfo = VMXVEXITINFO_INIT_WITH_QUAL_AND_INSTR_INFO_FROM_TRANSIENT(pVmxTransient);
    95919877        return IEMExecVmxVmexitInstrWithInfo(pVCpu, &ExitInfo);
    … …  
    96239909    HMVMX_VALIDATE_NESTED_EXIT_HANDLER_PARAMS(pVCpu, pVmxTransient);
    96249910
     9911# ifdef HMVMX_WITH_CONDENSED_VMREADS
     9912    vmxHCReadToTransient<  HMVMX_READ_EXIT_QUALIFICATION
     9913                         | HMVMX_READ_EXIT_INSTR_LEN>(pVCpu, pVmxTransient);
     9914# else
    96259915    vmxHCReadExitQualVmcs(pVCpu, pVmxTransient);
    96269916    vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
     9917# endif
    96279918
    96289919    VBOXSTRICTRC rcStrict;
    … …  
    977110062    if (CPUMIsGuestVmxProcCtlsSet(&pVCpu->cpum.GstCtx, VMX_PROC_CTLS_MOV_DR_EXIT))
    977210063    {
     10064# ifdef HMVMX_WITH_CONDENSED_VMREADS
     10065        vmxHCReadToTransient<  HMVMX_READ_EXIT_QUALIFICATION
     10066                             | HMVMX_READ_EXIT_INSTR_LEN>(pVCpu, pVmxTransient);
     10067# else
    977310068        vmxHCReadExitQualVmcs(pVCpu, pVmxTransient);
    977410069        vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
    9775 
     10070# endif
    977610071        VMXVEXITINFO const ExitInfo = VMXVEXITINFO_INIT_WITH_QUAL_AND_INSTR_LEN_FROM_TRANSIENT(pVmxTransient);
    977710072        return IEMExecVmxVmexitInstrWithInfo(pVCpu, &ExitInfo);
    … …  
    997310268    HMVMX_VALIDATE_NESTED_EXIT_HANDLER_PARAMS(pVCpu, pVmxTransient);
    997410269
     10270# ifdef HMVMX_WITH_CONDENSED_VMREADS
     10271    vmxHCReadToTransient<  HMVMX_READ_EXIT_QUALIFICATION
     10272                         | HMVMX_READ_EXIT_INSTR_LEN
     10273                         | HMVMX_READ_IDT_VECTORING_INFO
     10274                         | HMVMX_READ_IDT_VECTORING_ERROR_CODE>(pVCpu, pVmxTransient);
     10275# else
    997510276    vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
    997610277    vmxHCReadIdtVectoringInfoVmcs(pVCpu, pVmxTransient);
    997710278    vmxHCReadIdtVectoringErrorCodeVmcs(pVCpu, pVmxTransient);
    997810279    vmxHCReadExitQualVmcs(pVCpu, pVmxTransient);
     10280# endif
    997910281
    998010282    Assert(CPUMIsGuestVmxProcCtls2Set(&pVCpu->cpum.GstCtx, VMX_PROC_CTLS2_VIRT_APIC_ACCESS));
    … …  
    1006110363    {
    1006210364        Assert(CPUMIsGuestVmxProcCtls2Set(&pVCpu->cpum.GstCtx, VMX_PROC_CTLS2_INVPCID));
     10365# ifdef HMVMX_WITH_CONDENSED_VMREADS
     10366        vmxHCReadToTransient<  HMVMX_READ_EXIT_QUALIFICATION
     10367                             | HMVMX_READ_EXIT_INSTR_INFO
     10368                             | HMVMX_READ_EXIT_INSTR_LEN>(pVCpu, pVmxTransient);
     10369# else
    1006310370        vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
    1006410371        vmxHCReadExitQualVmcs(pVCpu, pVmxTransient);
    1006510372        vmxHCReadExitInstrInfoVmcs(pVCpu, pVmxTransient);
    10066 
     10373# endif
    1006710374        VMXVEXITINFO const ExitInfo = VMXVEXITINFO_INIT_WITH_QUAL_AND_INSTR_INFO_FROM_TRANSIENT(pVmxTransient);
    1006810375        return IEMExecVmxVmexitInstrWithInfo(pVCpu, &ExitInfo);
    … …  
    1016610473# endif
    1016710474
     10475# ifdef HMVMX_WITH_CONDENSED_VMREADS
     10476    vmxHCReadToTransient<  HMVMX_READ_EXIT_QUALIFICATION
     10477                         | HMVMX_READ_EXIT_INSTR_LEN
     10478                         | HMVMX_READ_EXIT_INSTR_INFO>(pVCpu, pVmxTransient);
     10479# else
    1016810480    vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
    1016910481    vmxHCReadExitQualVmcs(pVCpu, pVmxTransient);
    1017010482    vmxHCReadExitInstrInfoVmcs(pVCpu, pVmxTransient);
    10171 
     10483# endif
    1017210484    VMXVEXITINFO const ExitInfo = VMXVEXITINFO_INIT_WITH_QUAL_AND_INSTR_INFO_FROM_TRANSIENT(pVmxTransient);
    1017310485    return IEMExecVmxVmexitInstrWithInfo(pVCpu, &ExitInfo);
    … …  
    1019410506        AssertRCReturn(rc, rc);
    1019510507
     10508#  ifdef DSL_IRQ_FIX_2
     10509#   ifdef HMVMX_WITH_CONDENSED_VMREADS
     10510        vmxHCReadToTransient<  HMVMX_READ_EXIT_QUALIFICATION
     10511                             | HMVMX_READ_EXIT_INSTR_LEN
     10512                             | HMVMX_READ_EXIT_INTERRUPTION_INFO
     10513                             | HMVMX_READ_EXIT_INTERRUPTION_ERROR_CODE
     10514                             | HMVMX_READ_IDT_VECTORING_INFO
     10515                             | HMVMX_READ_IDT_VECTORING_ERROR_CODE
     10516                             | HMVMX_READ_GUEST_PHYSICAL_ADDR>(pVCpu, pVmxTransient);
     10517#   else
    1019610518        vmxHCReadExitQualVmcs(pVCpu, pVmxTransient);
    10197         vmxHCReadGuestPhysicalAddrVmcs(pVCpu, pVmxTransient);
    10198 #  ifdef DSL_IRQ_FIX_2
     10519        vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
    1019910520        vmxHCReadExitIntInfoVmcs(pVCpu, pVmxTransient);
    1020010521        vmxHCReadExitIntErrorCodeVmcs(pVCpu, pVmxTransient);
    10201         vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
    1020210522        vmxHCReadIdtVectoringInfoVmcs(pVCpu, pVmxTransient);
    1020310523        vmxHCReadIdtVectoringErrorCodeVmcs(pVCpu, pVmxTransient);
     10524        vmxHCReadGuestPhysicalAddrVmcs(pVCpu, pVmxTransient);
     10525#   endif
    1020410526
    1020510527        /*
    … …  
    1021810540        bool const fClearEventOnForward = VCPU_2_VMXSTATE(pVCpu).Event.fPending; /* paranoia. should not inject events below.  */
    1021910541#  else
     10542        vmxHCReadExitQualVmcs(pVCpu, pVmxTransient);
     10543        vmxHCReadGuestPhysicalAddrVmcs(pVCpu, pVmxTransient);
    1022010544        VBOXSTRICTRC rcStrict;
    1022110545#  endif
    … …  
    1027410598        }
    1027510599
     10600#  ifndef DSL_IRQ_FIX_2
    1027610601        vmxHCReadExitInstrLenVmcs(pVCpu, pVmxTransient);
    1027710602        vmxHCReadIdtVectoringInfoVmcs(pVCpu, pVmxTransient);
    1027810603        vmxHCReadIdtVectoringErrorCodeVmcs(pVCpu, pVmxTransient);
    10279 #  ifdef DSL_IRQ_FIX_2
     10604#  else
    1028010605        if (fClearEventOnForward)
    1028110606            VCPU_2_VMXSTATE(pVCpu).Event.fPending = false;
    … …  
    1033310658
    1033410659        AssertMsg(Walk.fFailed & PGM_WALKFAIL_EPT_MISCONFIG, ("GCPhysNestedFault=%#RGp\n", GCPhysNestedFault));
     10660#  ifdef HMVMX_WITH_CONDENSED_VMREADS
     10661        vmxHCReadToTransient<  HMVMX_READ_IDT_VECTORING_INFO
     10662                             | HMVMX_READ_IDT_VECTORING_ERROR_CODE>(pVCpu, pVmxTransient);
     10663#  else
    1033510664        vmxHCReadIdtVectoringInfoVmcs(pVCpu, pVmxTransient);
    1033610665        vmxHCReadIdtVectoringErrorCodeVmcs(pVCpu, pVmxTransient);
     10666#  endif
    1033710667
    1033810668        VMXVEXITEVENTINFO const ExitEventInfo = VMXVEXITEVENTINFO_INIT_ONLY_IDT(pVmxTransient->uIdtVectoringInfo,
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