VirtualBox

Changeset 72655 in vbox


Ignore:
Timestamp:
Jun 22, 2018 10:05:53 AM (6 years ago)
Author:
vboxsync
Message:

EM,HM,NEM,TRPM: Renamed some EMEXIT_XXXX stuff to shorten things down a bit. Added missing HMCPU_CF_SET(pVCpu, HM_CHANGED_ALL_GUEST) after EMHistoryExec in the VT-x code. Prepped the SVM code for CPUID, IO and MMIO exit optimizations. bugref:9198

Location:
trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/vmm/em.h

    r72642 r72655  
    230230 *
    231231 * The flags the exit type are combined to a 32-bit number using the
    232  * EMEXIT_MAKE_FLAGS_AND_TYPE() macro.
     232 * EMEXIT_MAKE_FT() macro.
    233233 *
    234234 * @{  */
    … …  
    242242#define EMEXIT_F_CS_EIP             UINT32_C(0x00010000)    /**< The PC is EIP in the low dword and CS in the high. */
    243243#define EMEXIT_F_UNFLATTENED_PC     UINT32_C(0x00020000)    /**< The PC hasn't had CS.BASE added to it. */
    244 /** Preemption is currently disabled (or we're using preemption hooks). */
    245 #define EMEXIT_F_PREEMPT_DISABLED   UINT32_C(0x00040000)
     244/** HM is calling (from ring-0).  Preemption is currently disabled or we're using preemption hooks. */
     245#define EMEXIT_F_HM                 UINT32_C(0x00040000)
    246246/** Combines flags and exit type into EMHistoryAddExit() input. */
    247 #define EMEXIT_MAKE_FLAGS_AND_TYPE(a_fFlags, a_uType)   ((a_fFlags) | (uint32_t)(a_uType))
     247#define EMEXIT_MAKE_FT(a_fFlags, a_uType)   ((a_fFlags) | (uint32_t)(a_uType))
    248248/** @} */
    249249
    … …  
    273273    /** The flat PC of the exit. */
    274274    uint64_t            uFlatPC;
    275     /** Flags and type, see EMEXIT_MAKE_FLAGS_AND_TYPE. */
     275    /** Flags and type, see EMEXIT_MAKE_FT. */
    276276    uint32_t            uFlagsAndType;
    277277    /** The action to take (EMEXITACTION). */

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

    r72642 r72655  
    603603{
    604604# ifdef IN_RING0
    605     /* Disregard the preempt disabled flag. */
    606     uFlagsAndType &= ~EMEXIT_F_PREEMPT_DISABLED;
     605    /* Disregard the hm flag. */
     606    uFlagsAndType &= ~EMEXIT_F_HM;
    607607# endif
    608608
    … …  
    775775# ifdef IN_RING0
    776776        && pVCpu->em.s.fExitOptimizationEnabledR0
    777         && ( !(uFlagsAndType & EMEXIT_F_PREEMPT_DISABLED) || pVCpu->em.s.fExitOptimizationEnabledR0PreemptDisabled)
     777        && ( !(uFlagsAndType & EMEXIT_F_HM) || pVCpu->em.s.fExitOptimizationEnabledR0PreemptDisabled)
    778778# else
    779779        && pVCpu->em.s.fExitOptimizationEnabled
    … …  
    864864# ifdef IN_RING0
    865865        && pVCpu->em.s.fExitOptimizationEnabledR0
    866         && ( !(uFlagsAndType & EMEXIT_F_PREEMPT_DISABLED) || pVCpu->em.s.fExitOptimizationEnabledR0PreemptDisabled)
     866        && ( !(uFlagsAndType & EMEXIT_F_HM) || pVCpu->em.s.fExitOptimizationEnabledR0PreemptDisabled)
    867867# else
    868868        && pVCpu->em.s.fExitOptimizationEnabled
    … …  
    909909# ifdef IN_RING0
    910910        && pVCpu->em.s.fExitOptimizationEnabledR0
    911         && ( !(uFlagsAndType & EMEXIT_F_PREEMPT_DISABLED) || pVCpu->em.s.fExitOptimizationEnabledR0PreemptDisabled)
     911        && ( !(uFlagsAndType & EMEXIT_F_HM) || pVCpu->em.s.fExitOptimizationEnabledR0PreemptDisabled)
    912912# else
    913913        && pVCpu->em.s.fExitOptimizationEnabled

  • trunk/src/VBox/VMM/VMMAll/NEMAllNativeTemplate-win.cpp.h

    r72575 r72655  
    18921892                      Info.fHasHandlers ? " handlers" : "", Info.fZeroPage    ? " zero-pg" : "",
    18931893                      State.fDidSomething ? "" : " no-change", g_apszHvInterceptAccessTypes[pMsg->Header.InterceptAccessType]));
    1894                 EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_NEM, NEMEXITTYPE_MEMORY_ACCESS),
     1894                EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_NEM, NEMEXITTYPE_MEMORY_ACCESS),
    18951895                                 pMsg->Header.Rip + pMsg->Header.CsSegment.Base, uHostTsc);
    18961896                return VINF_SUCCESS;
    … …  
    19141914    PCEMEXITREC pExitRec = EMHistoryAddExit(pVCpu,
    19151915                                              pMsg->Header.InterceptAccessType == HV_INTERCEPT_ACCESS_WRITE
    1916                                             ? EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_MMIO_WRITE)
    1917                                             : EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_MMIO_READ),
     1916                                            ? EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_MMIO_WRITE)
     1917                                            : EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_MMIO_READ),
    19181918                                            pMsg->Header.Rip + pMsg->Header.CsSegment.Base, uHostTsc);
    19191919    nemHCWinCopyStateFromX64Header(pVCpu, pCtx, &pMsg->Header);
    … …  
    20002000                      Info.fHasHandlers ? " handlers" : "", Info.fZeroPage    ? " zero-pg" : "",
    20012001                      State.fDidSomething ? "" : " no-change", g_apszHvInterceptAccessTypes[pExit->MemoryAccess.AccessInfo.AccessType]));
    2002                 EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_NEM, NEMEXITTYPE_MEMORY_ACCESS),
     2002                EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_NEM, NEMEXITTYPE_MEMORY_ACCESS),
    20032003                                 pExit->VpContext.Rip + pExit->VpContext.Cs.Base, uHostTsc);
    20042004                return VINF_SUCCESS;
    … …  
    20222022    PCEMEXITREC pExitRec = EMHistoryAddExit(pVCpu,
    20232023                                              pExit->MemoryAccess.AccessInfo.AccessType == WHvMemoryAccessWrite
    2024                                             ? EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_MMIO_WRITE)
    2025                                             : EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_MMIO_READ),
     2024                                            ? EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_MMIO_WRITE)
     2025                                            : EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_MMIO_READ),
    20262026                                            pExit->VpContext.Rip + pExit->VpContext.Cs.Base, uHostTsc);
    20272027    nemR3WinCopyStateFromX64Header(pVCpu, pCtx, &pExit->VpContext);
    … …  
    20902090                                            !pMsg->AccessInfo.StringOp
    20912091                                            ? (  pMsg->Header.InterceptAccessType == HV_INTERCEPT_ACCESS_WRITE
    2092                                                ? EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_IO_PORT_WRITE)
    2093                                                : EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_IO_PORT_READ))
     2092                                               ? EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_IO_PORT_WRITE)
     2093                                               : EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_IO_PORT_READ))
    20942094                                            : (  pMsg->Header.InterceptAccessType == HV_INTERCEPT_ACCESS_WRITE
    2095                                                ? EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_IO_PORT_STR_WRITE)
    2096                                                : EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_IO_PORT_STR_READ)),
     2095                                               ? EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_IO_PORT_STR_WRITE)
     2096                                               : EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_IO_PORT_STR_READ)),
    20972097                                            pMsg->Header.Rip + pMsg->Header.CsSegment.Base, ASMReadTSC());
    20982098    if (!pExitRec)
    … …  
    22892289                                            !pExit->IoPortAccess.AccessInfo.StringOp
    22902290                                            ? (  pExit->MemoryAccess.AccessInfo.AccessType == WHvMemoryAccessWrite
    2291                                                ? EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_IO_PORT_WRITE)
    2292                                                : EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_IO_PORT_READ))
     2291                                               ? EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_IO_PORT_WRITE)
     2292                                               : EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_IO_PORT_READ))
    22932293                                            : (  pExit->MemoryAccess.AccessInfo.AccessType == WHvMemoryAccessWrite
    2294                                                ? EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_IO_PORT_STR_WRITE)
    2295                                                : EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_IO_PORT_STR_READ)),
     2294                                               ? EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_IO_PORT_STR_WRITE)
     2295                                               : EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_IO_PORT_STR_READ)),
    22962296                                            pExit->VpContext.Rip + pExit->VpContext.Cs.Base, ASMReadTSC());
    22972297    if (!pExitRec)
    … …  
    24552455     * Just copy the state we've got and handle it in the loop for now.
    24562456     */
    2457     EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_NEM, NEMEXITTYPE_INTTERRUPT_WINDOW),
     2457    EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_NEM, NEMEXITTYPE_INTTERRUPT_WINDOW),
    24582458                     pMsg->Header.Rip + pMsg->Header.CsSegment.Base, ASMReadTSC());
    24592459
    … …  
    24922492     * Just copy the state we've got and handle it in the loop for now.
    24932493     */
    2494     EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_NEM, NEMEXITTYPE_INTTERRUPT_WINDOW),
     2494    EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_NEM, NEMEXITTYPE_INTTERRUPT_WINDOW),
    24952495                     pExit->VpContext.Rip + pExit->VpContext.Cs.Base, ASMReadTSC());
    24962496
    … …  
    25232523{
    25242524    AssertMsg(pMsg->Header.InstructionLength < 0x10, ("%#x\n", pMsg->Header.InstructionLength));
    2525     PCEMEXITREC pExitRec = EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_CPUID),
     2525    PCEMEXITREC pExitRec = EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_CPUID),
    25262526                                            pMsg->Header.Rip + pMsg->Header.CsSegment.Base, ASMReadTSC());
    25272527    if (!pExitRec)
    … …  
    26042604{
    26052605    AssertMsg(pExit->VpContext.InstructionLength < 0x10, ("%#x\n", pExit->VpContext.InstructionLength));
    2606     PCEMEXITREC pExitRec = EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_CPUID),
     2606    PCEMEXITREC pExitRec = EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_CPUID),
    26072607                                            pExit->VpContext.Rip + pExit->VpContext.Cs.Base, ASMReadTSC());
    26082608    if (!pExitRec)
    … …  
    27002700        PCEMEXITREC pExitRec = EMHistoryAddExit(pVCpu,
    27012701                                                  pMsg->Header.InterceptAccessType == HV_INTERCEPT_ACCESS_WRITE
    2702                                                 ? EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_MSR_WRITE)
    2703                                                 : EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_MSR_READ),
     2702                                                ? EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_MSR_WRITE)
     2703                                                : EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_MSR_READ),
    27042704                                                pMsg->Header.Rip + pMsg->Header.CsSegment.Base, ASMReadTSC());
    27052705
    … …  
    28452845        PCEMEXITREC pExitRec = EMHistoryAddExit(pVCpu,
    28462846                                                  pExit->MsrAccess.AccessInfo.IsWrite
    2847                                                 ? EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_MSR_WRITE)
    2848                                                 : EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_MSR_READ),
     2847                                                ? EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_MSR_WRITE)
     2848                                                : EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_MSR_READ),
    28492849                                                pExit->VpContext.Rip + pExit->VpContext.Cs.Base, ASMReadTSC());
    28502850        nemR3WinCopyStateFromX64Header(pVCpu, pCtx, &pExit->VpContext);
    … …  
    31263126        case X86_XCPT_UD:
    31273127            STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitExceptionUd);
    3128             EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_NEM, NEMEXITTYPE_XCPT_UD),
     3128            EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_NEM, NEMEXITTYPE_XCPT_UD),
    31293129                             pMsg->Header.Rip + pMsg->Header.CsSegment.Base, ASMReadTSC());
    31303130
    … …  
    31493149        case X86_XCPT_DB:
    31503150            STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitExceptionDb);
    3151             EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_NEM, NEMEXITTYPE_XCPT_DB),
     3151            EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_NEM, NEMEXITTYPE_XCPT_DB),
    31523152                             pMsg->Header.Rip + pMsg->Header.CsSegment.Base, ASMReadTSC());
    31533153            Log4(("XcptExit/%u: %04x:%08RX64/%s: #DB - TODO\n",
    … …  
    31573157        case X86_XCPT_BP:
    31583158            STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitExceptionBp);
    3159             EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_NEM, NEMEXITTYPE_XCPT_BP),
     3159            EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_NEM, NEMEXITTYPE_XCPT_BP),
    31603160                             pMsg->Header.Rip + pMsg->Header.CsSegment.Base, ASMReadTSC());
    31613161            Log4(("XcptExit/%u: %04x:%08RX64/%s: #BP - TODO - %u\n", pVCpu->idCpu, pMsg->Header.CsSegment.Selector,
    … …  
    32313231        case X86_XCPT_UD:
    32323232            STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitExceptionUd);
    3233             EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_NEM, NEMEXITTYPE_XCPT_UD),
     3233            EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_NEM, NEMEXITTYPE_XCPT_UD),
    32343234                             pExit->VpContext.Rip + pExit->VpContext.Cs.Base, ASMReadTSC());
    32353235            if (nemHcWinIsInterestingUndefinedOpcode(pExit->VpException.InstructionByteCount, pExit->VpException.InstructionBytes,
    … …  
    32563256        case X86_XCPT_DB:
    32573257            STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitExceptionDb);
    3258             EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_NEM, NEMEXITTYPE_XCPT_DB),
     3258            EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_NEM, NEMEXITTYPE_XCPT_DB),
    32593259                             pExit->VpContext.Rip + pExit->VpContext.Cs.Base, ASMReadTSC());
    32603260            Log4(("XcptExit/%u: %04x:%08RX64/%s: #DB - TODO\n",
    … …  
    32643264        case X86_XCPT_BP:
    32653265            STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitExceptionBp);
    3266             EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_NEM, NEMEXITTYPE_XCPT_BP),
     3266            EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_NEM, NEMEXITTYPE_XCPT_BP),
    32673267                             pExit->VpContext.Rip + pExit->VpContext.Cs.Base, ASMReadTSC());
    32683268            Log4(("XcptExit/%u: %04x:%08RX64/%s: #BP - TODO - %u\n", pVCpu->idCpu, pExit->VpContext.Cs.Selector,
    … …  
    33233323     * Let IEM decide whether this is really it.
    33243324     */
    3325     EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_NEM, NEMEXITTYPE_UNRECOVERABLE_EXCEPTION),
     3325    EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_NEM, NEMEXITTYPE_UNRECOVERABLE_EXCEPTION),
    33263326                     pMsgHdr->Rip + pMsgHdr->CsSegment.Base, ASMReadTSC());
    33273327    nemHCWinCopyStateFromX64Header(pVCpu, pCtx, pMsgHdr);
    … …  
    33803380     * Let IEM decide whether this is really it.
    33813381     */
    3382     EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_NEM, NEMEXITTYPE_UNRECOVERABLE_EXCEPTION),
     3382    EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_NEM, NEMEXITTYPE_UNRECOVERABLE_EXCEPTION),
    33833383                     pExit->VpContext.Rip + pExit->VpContext.Cs.Base, ASMReadTSC());
    33843384    nemR3WinCopyStateFromX64Header(pVCpu, pCtx, &pExit->VpContext);
    … …  
    34513451            case HvMessageTypeX64Halt:
    34523452                STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitHalt);
    3453                 EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_NEM, NEMEXITTYPE_HALT),
     3453                EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_NEM, NEMEXITTYPE_HALT),
    34543454                                 pMsg->X64InterceptHeader.Rip + pMsg->X64InterceptHeader.CsSegment.Base, ASMReadTSC());
    34553455                Log4(("HaltExit\n"));
    … …  
    35353535        case WHvRunVpExitReasonX64Halt:
    35363536            STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitHalt);
    3537             EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_NEM, NEMEXITTYPE_HALT),
     3537            EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_NEM, NEMEXITTYPE_HALT),
    35383538                             pExit->VpContext.Rip + pExit->VpContext.Cs.Base, ASMReadTSC());
    35393539            Log4(("HaltExit\n"));

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

    r72646 r72655  
    109109#define HMSVM_CPUMCTX_IMPORT_STATE(a_pVCpu, a_pCtx, a_fWhat) \
    110110    do { \
    111         hmR0SvmImportGuestState((a_pVCpu), (a_pCtx), (a_fWhat)); \
     111        if ((a_pCtx)->fExtrn & (a_fWhat)) \
     112            hmR0SvmImportGuestState((a_pVCpu), (a_pCtx), (a_fWhat)); \
    112113    } while (0)
    113114
    … …  
    49014902
    49024903    HMSVM_CPUMCTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CS | CPUMCTX_EXTRN_RIP);
    4903     EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_SVM, pSvmTransient->u64ExitCode & EMEXIT_F_TYPE_MASK),
     4904    EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_SVM, pSvmTransient->u64ExitCode & EMEXIT_F_TYPE_MASK),
    49044905                     pCtx->cs.u64Base + pCtx->rip, uHostTsc);
    49054906}
    … …  
    64986499    HMSVM_VALIDATE_EXIT_HANDLER_PARAMS();
    64996500
    6500     PVM pVM = pVCpu->CTX_SUFF(pVM);
    6501     int rc = EMInterpretCpuId(pVM, pVCpu, CPUMCTX2CORE(pCtx));
    6502     if (RT_LIKELY(rc == VINF_SUCCESS))
    6503     {
    6504         hmR0SvmAdvanceRipHwAssist(pVCpu, pCtx, 2);
    6505         HMSVM_CHECK_SINGLE_STEP(pVCpu, rc);
     6501    HMSVM_CPUMCTX_IMPORT_STATE(pVCpu, pCtx, CPUMCTX_EXTRN_RIP | CPUMCTX_EXTRN_CS);
     6502    VBOXSTRICTRC rcStrict;
     6503    PCEMEXITREC pExitRec = EMHistoryUpdateFlagsAndTypeAndPC(pVCpu,
     6504                                                            EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM | EMEXIT_F_HM, EMEXITTYPE_CPUID),
     6505                                                            pVCpu->cpum.GstCtx.rip + pVCpu->cpum.GstCtx.cs.u64Base);
     6506    if (!pExitRec)
     6507    {
     6508        PVM pVM = pVCpu->CTX_SUFF(pVM);
     6509        rcStrict = EMInterpretCpuId(pVM, pVCpu, CPUMCTX2CORE(pCtx));
     6510        if (RT_LIKELY(rcStrict == VINF_SUCCESS))
     6511        {
     6512            hmR0SvmAdvanceRipHwAssist(pVCpu, pCtx, 2);
     6513            HMSVM_CHECK_SINGLE_STEP(pVCpu, rcStrict);
     6514        }
     6515        else
     6516        {
     6517            AssertMsgFailed(("hmR0SvmExitCpuid: EMInterpretCpuId failed with %Rrc\n", VBOXSTRICTRC_VAL(rcStrict)));
     6518            rcStrict = VERR_EM_INTERPRETER;
     6519        }
    65066520    }
    65076521    else
    65086522    {
    6509         AssertMsgFailed(("hmR0SvmExitCpuid: EMInterpretCpuId failed with %Rrc\n", rc));
    6510         rc = VERR_EM_INTERPRETER;
     6523        /*
     6524         * Frequent exit or something needing probing.  Get state and call EMHistoryExec.
     6525         */
     6526        Assert(pCtx == &pVCpu->cpum.GstCtx);
     6527        HMSVM_CPUMCTX_IMPORT_STATE(pVCpu, pCtx, IEM_CPUMCTX_EXTRN_MUST_MASK);
     6528
     6529        Log4(("CpuIdExit/%u: %04x:%08RX64: %#x/%#x -> EMHistoryExec\n",
     6530              pVCpu->idCpu, pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip, pVCpu->cpum.GstCtx.eax, pVCpu->cpum.GstCtx.ecx));
     6531
     6532        rcStrict = EMHistoryExec(pVCpu, pExitRec, 0);
     6533
     6534        Log4(("CpuIdExit/%u: %04x:%08RX64: EMHistoryExec -> %Rrc + %04x:%08RX64\n",
     6535              pVCpu->idCpu, pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip,
     6536              VBOXSTRICTRC_VAL(rcStrict), pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip));
    65116537    }
    65126538    STAM_COUNTER_INC(&pVCpu->hm.s.StatExitCpuid);
    6513     return rc;
     6539    return VBOXSTRICTRC_TODO(rcStrict);
    65146540}
    65156541
    … …  
    70867112    }
    70877113
     7114    HMSVM_CPUMCTX_IMPORT_STATE(pVCpu, pCtx, CPUMCTX_EXTRN_RIP | CPUMCTX_EXTRN_CS | CPUMCTX_EXTRN_RFLAGS);
    70887115    VBOXSTRICTRC rcStrict;
    7089     bool fUpdateRipAlready = false;
    7090     if (IoExitInfo.n.u1Str)
    7091     {
    7092         /* INS/OUTS - I/O String instruction. */
    7093         /** @todo Huh? why can't we use the segment prefix information given by AMD-V
    7094          *        in EXITINFO1? Investigate once this thing is up and running. */
    7095         Log4(("CS:RIP=%04x:%08RX64 %#06x/%u %c str\n", pCtx->cs.Sel, pCtx->rip, IoExitInfo.n.u16Port, cbValue,
    7096               IoExitInfo.n.u1Type == SVM_IOIO_WRITE ? 'w' : 'r'));
    7097         AssertReturn(pCtx->dx == IoExitInfo.n.u16Port, VERR_SVM_IPE_2);
    7098         static IEMMODE const s_aenmAddrMode[8] =
    7099         {
    7100             (IEMMODE)-1, IEMMODE_16BIT, IEMMODE_32BIT, (IEMMODE)-1, IEMMODE_64BIT, (IEMMODE)-1, (IEMMODE)-1, (IEMMODE)-1
    7101         };
    7102         IEMMODE enmAddrMode = s_aenmAddrMode[(IoExitInfo.u >> 7) & 0x7];
    7103         if (enmAddrMode != (IEMMODE)-1)
    7104         {
    7105             uint64_t cbInstr = pVmcb->ctrl.u64ExitInfo2 - pCtx->rip;
    7106             if (cbInstr <= 15 && cbInstr >= 1)
     7116    PCEMEXITREC pExitRec = NULL;
     7117    if (   !pVCpu->hm.s.fSingleInstruction
     7118        && !pVCpu->cpum.GstCtx.eflags.Bits.u1TF)
     7119        pExitRec = EMHistoryUpdateFlagsAndTypeAndPC(pVCpu,
     7120                                                    !IoExitInfo.n.u1Str
     7121                                                    ? IoExitInfo.n.u1Type == SVM_IOIO_READ
     7122                                                    ? EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM | EMEXIT_F_HM, EMEXITTYPE_IO_PORT_READ)
     7123                                                    : EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM | EMEXIT_F_HM, EMEXITTYPE_IO_PORT_WRITE)
     7124                                                    : IoExitInfo.n.u1Type == SVM_IOIO_READ
     7125                                                    ? EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM | EMEXIT_F_HM, EMEXITTYPE_IO_PORT_STR_READ)
     7126                                                    : EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM | EMEXIT_F_HM, EMEXITTYPE_IO_PORT_STR_WRITE),
     7127                                                    pVCpu->cpum.GstCtx.rip + pVCpu->cpum.GstCtx.cs.u64Base);
     7128    if (!pExitRec)
     7129    {
     7130        bool fUpdateRipAlready = false;
     7131        if (IoExitInfo.n.u1Str)
     7132        {
     7133            /* INS/OUTS - I/O String instruction. */
     7134            /** @todo Huh? why can't we use the segment prefix information given by AMD-V
     7135             *        in EXITINFO1? Investigate once this thing is up and running. */
     7136            Log4(("CS:RIP=%04x:%08RX64 %#06x/%u %c str\n", pCtx->cs.Sel, pCtx->rip, IoExitInfo.n.u16Port, cbValue,
     7137                  IoExitInfo.n.u1Type == SVM_IOIO_WRITE ? 'w' : 'r'));
     7138            AssertReturn(pCtx->dx == IoExitInfo.n.u16Port, VERR_SVM_IPE_2);
     7139            static IEMMODE const s_aenmAddrMode[8] =
    71077140            {
    7108                 Assert(cbInstr >= 1U + IoExitInfo.n.u1Rep);
    7109                 if (IoExitInfo.n.u1Type == SVM_IOIO_WRITE)
     7141                (IEMMODE)-1, IEMMODE_16BIT, IEMMODE_32BIT, (IEMMODE)-1, IEMMODE_64BIT, (IEMMODE)-1, (IEMMODE)-1, (IEMMODE)-1
     7142            };
     7143            IEMMODE enmAddrMode = s_aenmAddrMode[(IoExitInfo.u >> 7) & 0x7];
     7144            if (enmAddrMode != (IEMMODE)-1)
     7145            {
     7146                uint64_t cbInstr = pVmcb->ctrl.u64ExitInfo2 - pCtx->rip;
     7147                if (cbInstr <= 15 && cbInstr >= 1)
    71107148                {
    7111                     /* Don't know exactly how to detect whether u3Seg is valid, currently
    7112                        only enabling it for Bulldozer and later with NRIP.  OS/2 broke on
    7113                        2384 Opterons when only checking NRIP. */
    7114                     bool const fSupportsNextRipSave = hmR0SvmSupportsNextRipSave(pVCpu, pCtx);
    7115                     if (   fSupportsNextRipSave
    7116                         && pVM->cpum.ro.GuestFeatures.enmMicroarch >= kCpumMicroarch_AMD_15h_First)
     7149                    Assert(cbInstr >= 1U + IoExitInfo.n.u1Rep);
     7150                    if (IoExitInfo.n.u1Type == SVM_IOIO_WRITE)
    71177151                    {
    7118                         AssertMsg(IoExitInfo.n.u3Seg == X86_SREG_DS || cbInstr > 1U + IoExitInfo.n.u1Rep,
    7119                                   ("u32Seg=%d cbInstr=%d u1REP=%d", IoExitInfo.n.u3Seg, cbInstr, IoExitInfo.n.u1Rep));
    7120                         rcStrict = IEMExecStringIoWrite(pVCpu, cbValue, enmAddrMode, IoExitInfo.n.u1Rep, (uint8_t)cbInstr,
    7121                                                         IoExitInfo.n.u3Seg, true /*fIoChecked*/);
     7152                        /* Don't know exactly how to detect whether u3Seg is valid, currently
     7153                           only enabling it for Bulldozer and later with NRIP.  OS/2 broke on
     7154                           2384 Opterons when only checking NRIP. */
     7155                        bool const fSupportsNextRipSave = hmR0SvmSupportsNextRipSave(pVCpu, pCtx);
     7156                        if (   fSupportsNextRipSave
     7157                            && pVM->cpum.ro.GuestFeatures.enmMicroarch >= kCpumMicroarch_AMD_15h_First)
     7158                        {
     7159                            AssertMsg(IoExitInfo.n.u3Seg == X86_SREG_DS || cbInstr > 1U + IoExitInfo.n.u1Rep,
     7160                                      ("u32Seg=%d cbInstr=%d u1REP=%d", IoExitInfo.n.u3Seg, cbInstr, IoExitInfo.n.u1Rep));
     7161                            rcStrict = IEMExecStringIoWrite(pVCpu, cbValue, enmAddrMode, IoExitInfo.n.u1Rep, (uint8_t)cbInstr,
     7162                                                            IoExitInfo.n.u3Seg, true /*fIoChecked*/);
     7163                        }
     7164                        else if (cbInstr == 1U + IoExitInfo.n.u1Rep)
     7165                            rcStrict = IEMExecStringIoWrite(pVCpu, cbValue, enmAddrMode, IoExitInfo.n.u1Rep, (uint8_t)cbInstr,
     7166                                                            X86_SREG_DS, true /*fIoChecked*/);
     7167                        else
     7168                            rcStrict = IEMExecOne(pVCpu);
     7169                        STAM_COUNTER_INC(&pVCpu->hm.s.StatExitIOStringWrite);
    71227170                    }
    7123                     else if (cbInstr == 1U + IoExitInfo.n.u1Rep)
    7124                         rcStrict = IEMExecStringIoWrite(pVCpu, cbValue, enmAddrMode, IoExitInfo.n.u1Rep, (uint8_t)cbInstr,
    7125                                                         X86_SREG_DS, true /*fIoChecked*/);
    71267171                    else
    7127                         rcStrict = IEMExecOne(pVCpu);
    7128                     STAM_COUNTER_INC(&pVCpu->hm.s.StatExitIOStringWrite);
     7172                    {
     7173                        AssertMsg(IoExitInfo.n.u3Seg == X86_SREG_ES /*=0*/, ("%#x\n", IoExitInfo.n.u3Seg));
     7174                        rcStrict = IEMExecStringIoRead(pVCpu, cbValue, enmAddrMode, IoExitInfo.n.u1Rep, (uint8_t)cbInstr,
     7175                                                       true /*fIoChecked*/);
     7176                        STAM_COUNTER_INC(&pVCpu->hm.s.StatExitIOStringRead);
     7177                    }
    71297178                }
    71307179                else
    71317180                {
    7132                     AssertMsg(IoExitInfo.n.u3Seg == X86_SREG_ES /*=0*/, ("%#x\n", IoExitInfo.n.u3Seg));
    7133                     rcStrict = IEMExecStringIoRead(pVCpu, cbValue, enmAddrMode, IoExitInfo.n.u1Rep, (uint8_t)cbInstr,
    7134                                                    true /*fIoChecked*/);
    7135                     STAM_COUNTER_INC(&pVCpu->hm.s.StatExitIOStringRead);
     7181                    AssertMsgFailed(("rip=%RX64 nrip=%#RX64 cbInstr=%#RX64\n", pCtx->rip, pVmcb->ctrl.u64ExitInfo2, cbInstr));
     7182                    rcStrict = IEMExecOne(pVCpu);
    71367183                }
    71377184            }
    71387185            else
    71397186            {
    7140                 AssertMsgFailed(("rip=%RX64 nrip=%#RX64 cbInstr=%#RX64\n", pCtx->rip, pVmcb->ctrl.u64ExitInfo2, cbInstr));
     7187                AssertMsgFailed(("IoExitInfo=%RX64\n", IoExitInfo.u));
    71417188                rcStrict = IEMExecOne(pVCpu);
    71427189            }
     7190            fUpdateRipAlready = true;
    71437191        }
    71447192        else
    71457193        {
    7146             AssertMsgFailed(("IoExitInfo=%RX64\n", IoExitInfo.u));
    7147             rcStrict = IEMExecOne(pVCpu);
    7148         }
    7149         fUpdateRipAlready = true;
     7194            /* IN/OUT - I/O instruction. */
     7195            Assert(!IoExitInfo.n.u1Rep);
     7196
     7197            if (IoExitInfo.n.u1Type == SVM_IOIO_WRITE)
     7198            {
     7199                rcStrict = IOMIOPortWrite(pVM, pVCpu, IoExitInfo.n.u16Port, pCtx->eax & uAndVal, cbValue);
     7200                STAM_COUNTER_INC(&pVCpu->hm.s.StatExitIOWrite);
     7201            }
     7202            else
     7203            {
     7204                uint32_t u32Val = 0;
     7205                rcStrict = IOMIOPortRead(pVM, pVCpu, IoExitInfo.n.u16Port, &u32Val, cbValue);
     7206                if (IOM_SUCCESS(rcStrict))
     7207                {
     7208                    /* Save result of I/O IN instr. in AL/AX/EAX. */
     7209                    /** @todo r=bird: 32-bit op size should clear high bits of rax! */
     7210                    pCtx->eax = (pCtx->eax & ~uAndVal) | (u32Val & uAndVal);
     7211                }
     7212                else if (rcStrict == VINF_IOM_R3_IOPORT_READ)
     7213                    HMR0SavePendingIOPortRead(pVCpu, pCtx->rip, pVmcb->ctrl.u64ExitInfo2, IoExitInfo.n.u16Port, uAndVal, cbValue);
     7214
     7215                STAM_COUNTER_INC(&pVCpu->hm.s.StatExitIORead);
     7216            }
     7217        }
     7218
     7219        if (IOM_SUCCESS(rcStrict))
     7220        {
     7221            /* AMD-V saves the RIP of the instruction following the IO instruction in EXITINFO2. */
     7222            if (!fUpdateRipAlready)
     7223                pCtx->rip = pVmcb->ctrl.u64ExitInfo2;
     7224
     7225            /*
     7226             * If any I/O breakpoints are armed, we need to check if one triggered
     7227             * and take appropriate action.
     7228             * Note that the I/O breakpoint type is undefined if CR4.DE is 0.
     7229             */
     7230            /** @todo Optimize away the DBGFBpIsHwIoArmed call by having DBGF tell the
     7231             *  execution engines about whether hyper BPs and such are pending. */
     7232            HMSVM_CPUMCTX_IMPORT_STATE(pVCpu, pCtx, CPUMCTX_EXTRN_DR7);
     7233            uint32_t const uDr7 = pCtx->dr[7];
     7234            if (RT_UNLIKELY(   (   (uDr7 & X86_DR7_ENABLED_MASK)
     7235                                && X86_DR7_ANY_RW_IO(uDr7)
     7236                                && (pCtx->cr4 & X86_CR4_DE))
     7237                            || DBGFBpIsHwIoArmed(pVM)))
     7238            {
     7239                /* We're playing with the host CPU state here, make sure we don't preempt or longjmp. */
     7240                VMMRZCallRing3Disable(pVCpu);
     7241                HM_DISABLE_PREEMPT();
     7242
     7243                STAM_COUNTER_INC(&pVCpu->hm.s.StatDRxIoCheck);
     7244                CPUMR0DebugStateMaybeSaveGuest(pVCpu, false /*fDr6*/);
     7245
     7246                VBOXSTRICTRC rcStrict2 = DBGFBpCheckIo(pVM, pVCpu, pCtx, IoExitInfo.n.u16Port, cbValue);
     7247                if (rcStrict2 == VINF_EM_RAW_GUEST_TRAP)
     7248                {
     7249                    /* Raise #DB. */
     7250                    pVmcb->guest.u64DR6 = pCtx->dr[6];
     7251                    pVmcb->guest.u64DR7 = pCtx->dr[7];
     7252                    pVmcb->ctrl.u32VmcbCleanBits &= ~HMSVM_VMCB_CLEAN_DRX;
     7253                    hmR0SvmSetPendingXcptDB(pVCpu);
     7254                }
     7255                /* rcStrict is VINF_SUCCESS, VINF_IOM_R3_IOPORT_COMMIT_WRITE, or in [VINF_EM_FIRST..VINF_EM_LAST],
     7256                   however we can ditch VINF_IOM_R3_IOPORT_COMMIT_WRITE as it has VMCPU_FF_IOM as backup. */
     7257                else if (   rcStrict2 != VINF_SUCCESS
     7258                         && (rcStrict == VINF_SUCCESS || rcStrict2 < rcStrict))
     7259                    rcStrict = rcStrict2;
     7260                AssertCompile(VINF_EM_LAST < VINF_IOM_R3_IOPORT_COMMIT_WRITE);
     7261
     7262                HM_RESTORE_PREEMPT();
     7263                VMMRZCallRing3Enable(pVCpu);
     7264            }
     7265
     7266            HMSVM_CHECK_SINGLE_STEP(pVCpu, rcStrict);
     7267        }
     7268
     7269#ifdef VBOX_STRICT
     7270        if (rcStrict == VINF_IOM_R3_IOPORT_READ)
     7271            Assert(IoExitInfo.n.u1Type == SVM_IOIO_READ);
     7272        else if (rcStrict == VINF_IOM_R3_IOPORT_WRITE || rcStrict == VINF_IOM_R3_IOPORT_COMMIT_WRITE)
     7273            Assert(IoExitInfo.n.u1Type == SVM_IOIO_WRITE);
     7274        else
     7275        {
     7276            /** @todo r=bird: This is missing a bunch of VINF_EM_FIRST..VINF_EM_LAST
     7277             *        statuses, that the VMM device and some others may return. See
     7278             *        IOM_SUCCESS() for guidance. */
     7279            AssertMsg(   RT_FAILURE(rcStrict)
     7280                      || rcStrict == VINF_SUCCESS
     7281                      || rcStrict == VINF_EM_RAW_EMULATE_INSTR
     7282                      || rcStrict == VINF_EM_DBG_BREAKPOINT
     7283                      || rcStrict == VINF_EM_RAW_GUEST_TRAP
     7284                      || rcStrict == VINF_EM_RAW_TO_R3
     7285                      || rcStrict == VINF_TRPM_XCPT_DISPATCHED
     7286                      || rcStrict == VINF_EM_TRIPLE_FAULT, ("%Rrc\n", VBOXSTRICTRC_VAL(rcStrict)));
     7287        }
     7288#endif
    71507289    }
    71517290    else
    71527291    {
    7153         /* IN/OUT - I/O instruction. */
    7154         Assert(!IoExitInfo.n.u1Rep);
    7155 
    7156         if (IoExitInfo.n.u1Type == SVM_IOIO_WRITE)
    7157         {
    7158             rcStrict = IOMIOPortWrite(pVM, pVCpu, IoExitInfo.n.u16Port, pCtx->eax & uAndVal, cbValue);
    7159             STAM_COUNTER_INC(&pVCpu->hm.s.StatExitIOWrite);
    7160         }
    7161         else
    7162         {
    7163             uint32_t u32Val = 0;
    7164             rcStrict = IOMIOPortRead(pVM, pVCpu, IoExitInfo.n.u16Port, &u32Val, cbValue);
    7165             if (IOM_SUCCESS(rcStrict))
    7166             {
    7167                 /* Save result of I/O IN instr. in AL/AX/EAX. */
    7168                 /** @todo r=bird: 32-bit op size should clear high bits of rax! */
    7169                 pCtx->eax = (pCtx->eax & ~uAndVal) | (u32Val & uAndVal);
    7170             }
    7171             else if (rcStrict == VINF_IOM_R3_IOPORT_READ)
    7172                 HMR0SavePendingIOPortRead(pVCpu, pCtx->rip, pVmcb->ctrl.u64ExitInfo2, IoExitInfo.n.u16Port, uAndVal, cbValue);
    7173 
    7174             STAM_COUNTER_INC(&pVCpu->hm.s.StatExitIORead);
    7175         }
    7176     }
    7177 
    7178     if (IOM_SUCCESS(rcStrict))
    7179     {
    7180         /* AMD-V saves the RIP of the instruction following the IO instruction in EXITINFO2. */
    7181         if (!fUpdateRipAlready)
    7182             pCtx->rip = pVmcb->ctrl.u64ExitInfo2;
    7183 
    71847292        /*
    7185          * If any I/O breakpoints are armed, we need to check if one triggered
    7186          * and take appropriate action.
    7187          * Note that the I/O breakpoint type is undefined if CR4.DE is 0.
     7293         * Frequent exit or something needing probing.  Get state and call EMHistoryExec.
    71887294         */
    7189         /** @todo Optimize away the DBGFBpIsHwIoArmed call by having DBGF tell the
    7190          *  execution engines about whether hyper BPs and such are pending. */
    7191         HMSVM_CPUMCTX_IMPORT_STATE(pVCpu, pCtx, CPUMCTX_EXTRN_DR7);
    7192         uint32_t const uDr7 = pCtx->dr[7];
    7193         if (RT_UNLIKELY(   (   (uDr7 & X86_DR7_ENABLED_MASK)
    7194                             && X86_DR7_ANY_RW_IO(uDr7)
    7195                             && (pCtx->cr4 & X86_CR4_DE))
    7196                         || DBGFBpIsHwIoArmed(pVM)))
    7197         {
    7198             /* We're playing with the host CPU state here, make sure we don't preempt or longjmp. */
    7199             VMMRZCallRing3Disable(pVCpu);
    7200             HM_DISABLE_PREEMPT();
    7201 
    7202             STAM_COUNTER_INC(&pVCpu->hm.s.StatDRxIoCheck);
    7203             CPUMR0DebugStateMaybeSaveGuest(pVCpu, false /*fDr6*/);
    7204 
    7205             VBOXSTRICTRC rcStrict2 = DBGFBpCheckIo(pVM, pVCpu, pCtx, IoExitInfo.n.u16Port, cbValue);
    7206             if (rcStrict2 == VINF_EM_RAW_GUEST_TRAP)
    7207             {
    7208                 /* Raise #DB. */
    7209                 pVmcb->guest.u64DR6 = pCtx->dr[6];
    7210                 pVmcb->guest.u64DR7 = pCtx->dr[7];
    7211                 pVmcb->ctrl.u32VmcbCleanBits &= ~HMSVM_VMCB_CLEAN_DRX;
    7212                 hmR0SvmSetPendingXcptDB(pVCpu);
    7213             }
    7214             /* rcStrict is VINF_SUCCESS, VINF_IOM_R3_IOPORT_COMMIT_WRITE, or in [VINF_EM_FIRST..VINF_EM_LAST],
    7215                however we can ditch VINF_IOM_R3_IOPORT_COMMIT_WRITE as it has VMCPU_FF_IOM as backup. */
    7216             else if (   rcStrict2 != VINF_SUCCESS
    7217                      && (rcStrict == VINF_SUCCESS || rcStrict2 < rcStrict))
    7218                 rcStrict = rcStrict2;
    7219             AssertCompile(VINF_EM_LAST < VINF_IOM_R3_IOPORT_COMMIT_WRITE);
    7220 
    7221             HM_RESTORE_PREEMPT();
    7222             VMMRZCallRing3Enable(pVCpu);
    7223         }
    7224 
    7225         HMSVM_CHECK_SINGLE_STEP(pVCpu, rcStrict);
    7226     }
    7227 
    7228 #ifdef VBOX_STRICT
    7229     if (rcStrict == VINF_IOM_R3_IOPORT_READ)
    7230         Assert(IoExitInfo.n.u1Type == SVM_IOIO_READ);
    7231     else if (rcStrict == VINF_IOM_R3_IOPORT_WRITE || rcStrict == VINF_IOM_R3_IOPORT_COMMIT_WRITE)
    7232         Assert(IoExitInfo.n.u1Type == SVM_IOIO_WRITE);
    7233     else
    7234     {
    7235         /** @todo r=bird: This is missing a bunch of VINF_EM_FIRST..VINF_EM_LAST
    7236          *        statuses, that the VMM device and some others may return. See
    7237          *        IOM_SUCCESS() for guidance. */
    7238         AssertMsg(   RT_FAILURE(rcStrict)
    7239                   || rcStrict == VINF_SUCCESS
    7240                   || rcStrict == VINF_EM_RAW_EMULATE_INSTR
    7241                   || rcStrict == VINF_EM_DBG_BREAKPOINT
    7242                   || rcStrict == VINF_EM_RAW_GUEST_TRAP
    7243                   || rcStrict == VINF_EM_RAW_TO_R3
    7244                   || rcStrict == VINF_TRPM_XCPT_DISPATCHED
    7245                   || rcStrict == VINF_EM_TRIPLE_FAULT, ("%Rrc\n", VBOXSTRICTRC_VAL(rcStrict)));
    7246     }
    7247 #endif
     7295        HMSVM_CPUMCTX_IMPORT_STATE(pVCpu, pCtx, IEM_CPUMCTX_EXTRN_MUST_MASK);
     7296        STAM_COUNTER_INC(!IoExitInfo.n.u1Str
     7297                         ? IoExitInfo.n.u1Type == SVM_IOIO_WRITE ? &pVCpu->hm.s.StatExitIOWrite : &pVCpu->hm.s.StatExitIORead
     7298                         : IoExitInfo.n.u1Type == SVM_IOIO_WRITE ? &pVCpu->hm.s.StatExitIOStringWrite : &pVCpu->hm.s.StatExitIOStringRead);
     7299        Log4(("IOExit/%u: %04x:%08RX64: %s%s%s %#x LB %u -> EMHistoryExec\n",
     7300              pVCpu->idCpu, pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip, IoExitInfo.n.u1Rep ? "REP " : "",
     7301              IoExitInfo.n.u1Type == SVM_IOIO_WRITE ? "OUT" : "IN", IoExitInfo.n.u1Str ? "S" : "", IoExitInfo.n.u16Port, uIOWidth));
     7302
     7303        rcStrict = EMHistoryExec(pVCpu, pExitRec, 0);
     7304        HMCPU_CF_SET(pVCpu, HM_CHANGED_ALL_GUEST);
     7305
     7306        Log4(("IOExit/%u: %04x:%08RX64: EMHistoryExec -> %Rrc + %04x:%08RX64\n",
     7307              pVCpu->idCpu, pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip,
     7308              VBOXSTRICTRC_VAL(rcStrict), pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip));
     7309    }
    72487310    return VBOXSTRICTRC_TODO(rcStrict);
    72497311}
    … …  
    73077369     * MMIO optimization using the reserved (RSVD) bit in the guest page tables for MMIO pages.
    73087370     */
    7309     int rc;
    73107371    Assert((u32ErrCode & (X86_TRAP_PF_RSVD | X86_TRAP_PF_P)) != X86_TRAP_PF_RSVD);
    73117372    if ((u32ErrCode & (X86_TRAP_PF_RSVD | X86_TRAP_PF_P)) == (X86_TRAP_PF_RSVD | X86_TRAP_PF_P))
    … …  
    73167377            return VINF_EM_RAW_INJECT_TRPM_EVENT;
    73177378
    7318         VBOXSTRICTRC rc2 = PGMR0Trap0eHandlerNPMisconfig(pVM, pVCpu, enmNestedPagingMode, CPUMCTX2CORE(pCtx), GCPhysFaultAddr,
    7319                                                          u32ErrCode);
    7320         rc = VBOXSTRICTRC_VAL(rc2);
    7321 
    7322         /*
    7323          * If we succeed, resume guest execution.
    7324          * If we fail in interpreting the instruction because we couldn't get the guest physical address
    7325          * of the page containing the instruction via the guest's page tables (we would invalidate the guest page
    7326          * in the host TLB), resume execution which would cause a guest page fault to let the guest handle this
    7327          * weird case. See @bugref{6043}.
    7328          */
    7329         if (   rc == VINF_SUCCESS
    7330             || rc == VERR_PAGE_TABLE_NOT_PRESENT
    7331             || rc == VERR_PAGE_NOT_PRESENT)
    7332         {
    7333             /* Successfully handled MMIO operation. */
    7334             HMCPU_CF_SET(pVCpu, HM_CHANGED_GUEST_APIC_STATE);
    7335             rc = VINF_SUCCESS;
    7336         }
    7337         return rc;
     7379        HMSVM_CPUMCTX_IMPORT_STATE(pVCpu, pCtx, CPUMCTX_EXTRN_RIP | CPUMCTX_EXTRN_CS);
     7380        VBOXSTRICTRC rcStrict;
     7381        PCEMEXITREC pExitRec = EMHistoryUpdateFlagsAndTypeAndPC(pVCpu,
     7382                                                                EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM | EMEXIT_F_HM, EMEXITTYPE_MMIO),
     7383                                                                pVCpu->cpum.GstCtx.rip + pVCpu->cpum.GstCtx.cs.u64Base);
     7384        if (!pExitRec)
     7385        {
     7386
     7387            rcStrict = PGMR0Trap0eHandlerNPMisconfig(pVM, pVCpu, enmNestedPagingMode, CPUMCTX2CORE(pCtx), GCPhysFaultAddr,
     7388                                                     u32ErrCode);
     7389
     7390            /*
     7391             * If we succeed, resume guest execution.
     7392             * If we fail in interpreting the instruction because we couldn't get the guest physical address
     7393             * of the page containing the instruction via the guest's page tables (we would invalidate the guest page
     7394             * in the host TLB), resume execution which would cause a guest page fault to let the guest handle this
     7395             * weird case. See @bugref{6043}.
     7396             */
     7397            if (   rcStrict == VINF_SUCCESS
     7398                || rcStrict == VERR_PAGE_TABLE_NOT_PRESENT
     7399                || rcStrict == VERR_PAGE_NOT_PRESENT)
     7400            {
     7401                /* Successfully handled MMIO operation. */
     7402                HMCPU_CF_SET(pVCpu, HM_CHANGED_GUEST_APIC_STATE);
     7403                rcStrict = VINF_SUCCESS;
     7404            }
     7405        }
     7406        else
     7407        {
     7408            /*
     7409             * Frequent exit or something needing probing.  Get state and call EMHistoryExec.
     7410             */
     7411            Assert(pCtx == &pVCpu->cpum.GstCtx);
     7412            HMSVM_CPUMCTX_IMPORT_STATE(pVCpu, pCtx, IEM_CPUMCTX_EXTRN_MUST_MASK);
     7413            Log4(("EptMisscfgExit/%u: %04x:%08RX64: %RGp -> EMHistoryExec\n",
     7414                  pVCpu->idCpu, pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip, GCPhysFaultAddr));
     7415
     7416            rcStrict = EMHistoryExec(pVCpu, pExitRec, 0);
     7417            HMCPU_CF_SET(pVCpu, HM_CHANGED_ALL_GUEST);
     7418
     7419            Log4(("EptMisscfgExit/%u: %04x:%08RX64: EMHistoryExec -> %Rrc + %04x:%08RX64\n",
     7420                  pVCpu->idCpu, pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip,
     7421                  VBOXSTRICTRC_VAL(rcStrict), pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip));
     7422        }
     7423        return VBOXSTRICTRC_TODO(rcStrict);
    73387424    }
    73397425
    73407426    TRPMAssertXcptPF(pVCpu, GCPhysFaultAddr, u32ErrCode);
    7341     rc = PGMR0Trap0eHandlerNestedPaging(pVM, pVCpu, enmNestedPagingMode, u32ErrCode, CPUMCTX2CORE(pCtx), GCPhysFaultAddr);
     7427    int rc = PGMR0Trap0eHandlerNestedPaging(pVM, pVCpu, enmNestedPagingMode, u32ErrCode, CPUMCTX2CORE(pCtx), GCPhysFaultAddr);
    73427428    TRPMResetTrap(pVCpu);
    73437429

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

    r72644 r72655  
    97309730         *       by amending the history entry added here.
    97319731         */
    9732         EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_VMX, pVmxTransient->uExitReason & EMEXIT_F_TYPE_MASK),
     9732        EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_VMX, pVmxTransient->uExitReason & EMEXIT_F_TYPE_MASK),
    97339733                         UINT64_MAX, uHostTsc);
    97349734
    … …  
    1226012260
    1226112261    VBOXSTRICTRC rcStrict;
    12262     PCEMEXITREC pExitRec;
    12263     pExitRec = EMHistoryUpdateFlagsAndTypeAndPC(pVCpu,
    12264                                                 EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM | EMEXIT_F_PREEMPT_DISABLED,
    12265                                                                            EMEXITTYPE_CPUID),
    12266                                                 pVCpu->cpum.GstCtx.rip + pVCpu->cpum.GstCtx.cs.u64Base);
     12262    PCEMEXITREC pExitRec = EMHistoryUpdateFlagsAndTypeAndPC(pVCpu,
     12263                                                            EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM | EMEXIT_F_HM, EMEXITTYPE_CPUID),
     12264                                                            pVCpu->cpum.GstCtx.rip + pVCpu->cpum.GstCtx.cs.u64Base);
    1226712265    if (!pExitRec)
    1226812266    {
    … …  
    1229712295
    1229812296        rcStrict = EMHistoryExec(pVCpu, pExitRec, 0);
     12297        HMCPU_CF_SET(pVCpu, HM_CHANGED_ALL_GUEST);
    1229912298
    1230012299        Log4(("CpuIdExit/%u: %04x:%08RX64: EMHistoryExec -> %Rrc + %04x:%08RX64\n",
    … …  
    1323413233                                                    !fIOString
    1323513234                                                    ? !fIOWrite
    13236                                                     ? EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM | EMEXIT_F_PREEMPT_DISABLED,
    13237                                                                                  EMEXITTYPE_IO_PORT_READ)
    13238                                                     : EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM | EMEXIT_F_PREEMPT_DISABLED,
    13239                                                                                  EMEXITTYPE_IO_PORT_WRITE)
     13235                                                    ? EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM | EMEXIT_F_HM, EMEXITTYPE_IO_PORT_READ)
     13236                                                    : EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM | EMEXIT_F_HM, EMEXITTYPE_IO_PORT_WRITE)
    1324013237                                                    : !fIOWrite
    13241                                                     ? EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM | EMEXIT_F_PREEMPT_DISABLED,
    13242                                                                                  EMEXITTYPE_IO_PORT_STR_READ)
    13243                                                     : EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM | EMEXIT_F_PREEMPT_DISABLED,
    13244                                                                                  EMEXITTYPE_IO_PORT_STR_WRITE),
     13238                                                    ? EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM | EMEXIT_F_HM, EMEXITTYPE_IO_PORT_STR_READ)
     13239                                                    : EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM | EMEXIT_F_HM, EMEXITTYPE_IO_PORT_STR_WRITE),
    1324513240                                                    pVCpu->cpum.GstCtx.rip + pVCpu->cpum.GstCtx.cs.u64Base);
    1324613241    if (!pExitRec)
    … …  
    1342713422        int rc2 = hmR0VmxSaveGuestRegsForIemInterpreting(pVCpu);
    1342813423        AssertRCReturn(rc2, rc2);
    13429 
     13424        STAM_COUNTER_INC(!fIOString ? fIOWrite ? &pVCpu->hm.s.StatExitIOWrite : &pVCpu->hm.s.StatExitIORead
     13425                         : fIOWrite ? &pVCpu->hm.s.StatExitIOStringWrite : &pVCpu->hm.s.StatExitIOStringRead);
    1343013426        Log4(("IOExit/%u: %04x:%08RX64: %s%s%s %#x LB %u -> EMHistoryExec\n",
    1343113427              pVCpu->idCpu, pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip,
    … …  
    1343413430
    1343513431        rcStrict = EMHistoryExec(pVCpu, pExitRec, 0);
     13432        HMCPU_CF_SET(pVCpu, HM_CHANGED_ALL_GUEST);
    1343613433
    1343713434        Log4(("IOExit/%u: %04x:%08RX64: EMHistoryExec -> %Rrc + %04x:%08RX64\n",
    … …  
    1373113728
    1373213729    VBOXSTRICTRC rcStrict;
    13733     PCEMEXITREC pExitRec;
    13734     pExitRec = EMHistoryUpdateFlagsAndTypeAndPC(pVCpu,
    13735                                                 EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM | EMEXIT_F_PREEMPT_DISABLED,
    13736                                                                            EMEXITTYPE_MMIO),
    13737                                                 pVCpu->cpum.GstCtx.rip + pVCpu->cpum.GstCtx.cs.u64Base);
     13730    PCEMEXITREC pExitRec = EMHistoryUpdateFlagsAndTypeAndPC(pVCpu,
     13731                                                            EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM | EMEXIT_F_HM, EMEXITTYPE_MMIO),
     13732                                                            pVCpu->cpum.GstCtx.rip + pVCpu->cpum.GstCtx.cs.u64Base);
    1373813733    if (!pExitRec)
    1373913734    {
    … …  
    1377313768
    1377413769        rcStrict = EMHistoryExec(pVCpu, pExitRec, 0);
     13770        HMCPU_CF_SET(pVCpu, HM_CHANGED_ALL_GUEST);
    1377513771
    1377613772        Log4(("EptMisscfgExit/%u: %04x:%08RX64: EMHistoryExec -> %Rrc + %04x:%08RX64\n",

  • trunk/src/VBox/VMM/VMMRC/IOMRC.cpp

    r72564 r72655  
    218218    {
    219219        case OP_IN:
    220             EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_IO_PORT_READ));
     220            EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_IO_PORT_READ));
    221221            return iomRCInterpretIN(pVM, pVCpu, pRegFrame, pCpu);
    222222
    223223        case OP_OUT:
    224             EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_IO_PORT_WRITE));
     224            EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_IO_PORT_WRITE));
    225225            return iomRCInterpretOUT(pVM, pVCpu, pRegFrame, pCpu);
    226226
    227227        case OP_INSB:
    228228        case OP_INSWD:
    229             EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_IO_PORT_STR_READ));
     229            EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_IO_PORT_STR_READ));
    230230            return iomRCInterpretINS(pVCpu, pCpu);
    231231
    232232        case OP_OUTSB:
    233233        case OP_OUTSWD:
    234             EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_IO_PORT_STR_WRITE));
     234            EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_IO_PORT_STR_WRITE));
    235235            return iomRCInterpretOUTS(pVCpu, pCpu);
    236236

  • trunk/src/VBox/VMM/VMMRC/TRPMRCHandlers.cpp

    r72567 r72655  
    333333    LogFlow(("TRPMGC01: cs:eip=%04x:%08x uDr6=%RTreg EFL=%x\n", pRegFrame->cs.Sel, pRegFrame->eip, uDr6, CPUMRawGetEFlags(pVCpu)));
    334334    TRPM_ENTER_DBG_HOOK(1);
    335     EMRCHistoryAddExitCsEip(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_XCPT, X86_XCPT_DB),
     335    EMRCHistoryAddExitCsEip(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_XCPT, X86_XCPT_DB),
    336336                            pRegFrame->cs.Sel, pRegFrame->eip, ASMReadTSC());
    337337
    … …  
    388388    PVMCPU      pVCpu = TRPMCPU_2_VMCPU(pTrpmCpu);
    389389    TRPM_ENTER_DBG_HOOK_HYPER(1);
    390     EMRCHistoryAddExitCsEip(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_XCPT, X86_XCPT_DB),
     390    EMRCHistoryAddExitCsEip(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_XCPT, X86_XCPT_DB),
    391391                            pRegFrame->cs.Sel, pRegFrame->eip, ASMReadTSC());
    392392    LogFlow(("TRPMGCHyper01: cs:eip=%04x:%08x uDr6=%RTreg\n", pRegFrame->cs.Sel, pRegFrame->eip, uDr6));
    … …  
    430430{
    431431    LogFlow(("TRPMGCTrap02Handler: cs:eip=%04x:%08x\n", pRegFrame->cs.Sel, pRegFrame->eip));
    432     EMRCHistoryAddExitCsEip(TRPMCPU_2_VMCPU(pTrpmCpu), EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_XCPT, X86_XCPT_NMI),
     432    EMRCHistoryAddExitCsEip(TRPMCPU_2_VMCPU(pTrpmCpu), EMEXIT_MAKE_FT(EMEXIT_F_KIND_XCPT, X86_XCPT_NMI),
    433433                           pRegFrame->cs.Sel, pRegFrame->eip, ASMReadTSC());
    434434#if 0 /* Enable this iff you have a COM port and really want this debug info. */
    … …  
    458458{
    459459    LogFlow(("TRPMGCHyperTrap02Handler: cs:eip=%04x:%08x\n", pRegFrame->cs.Sel, pRegFrame->eip));
    460     EMRCHistoryAddExitCsEip(TRPMCPU_2_VMCPU(pTrpmCpu), EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_XCPT, X86_XCPT_NMI),
     460    EMRCHistoryAddExitCsEip(TRPMCPU_2_VMCPU(pTrpmCpu), EMEXIT_MAKE_FT(EMEXIT_F_KIND_XCPT, X86_XCPT_NMI),
    461461                           pRegFrame->cs.Sel, pRegFrame->eip, ASMReadTSC());
    462462#if 0 /* Enable this iff you have a COM port and really want this debug info. */
    … …  
    486486    LogFlow(("TRPMGC03: %04x:%08x EFL=%x\n", pRegFrame->cs.Sel, pRegFrame->eip, CPUMRawGetEFlags(pVCpu)));
    487487    TRPM_ENTER_DBG_HOOK(3);
    488     EMRCHistoryAddExitCsEip(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_XCPT, X86_XCPT_BP),
     488    EMRCHistoryAddExitCsEip(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_XCPT, X86_XCPT_BP),
    489489                            pRegFrame->cs.Sel, pRegFrame->eip, ASMReadTSC());
    490490    PGMRZDynMapStartAutoSet(pVCpu);
    … …  
    540540    LogFlow(("TRPMGCHyper03: %04x:%08x EFL=%x\n", pRegFrame->cs.Sel, pRegFrame->eip, CPUMRawGetEFlags(pVCpu)));
    541541    TRPM_ENTER_DBG_HOOK_HYPER(3);
    542     EMRCHistoryAddExitCsEip(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_XCPT, X86_XCPT_BP),
     542    EMRCHistoryAddExitCsEip(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_XCPT, X86_XCPT_BP),
    543543                            pRegFrame->cs.Sel, pRegFrame->eip, ASMReadTSC());
    544544
    … …  
    573573    LogFlow(("TRPMGC06: %04x:%08x EFL=%#x/%#x\n", pRegFrame->cs.Sel, pRegFrame->eip, pRegFrame->eflags.u32, CPUMRawGetEFlags(pVCpu)));
    574574    TRPM_ENTER_DBG_HOOK(6);
    575     EMRCHistoryAddExitCsEip(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_XCPT, X86_XCPT_UD),
     575    EMRCHistoryAddExitCsEip(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_XCPT, X86_XCPT_UD),
    576576                            pRegFrame->cs.Sel, pRegFrame->eip, ASMReadTSC());
    577577    PGMRZDynMapStartAutoSet(pVCpu);
    … …  
    711711    LogFlow(("TRPMGC07: %04x:%08x EFL=%x\n", pRegFrame->cs.Sel, pRegFrame->eip, CPUMRawGetEFlags(pVCpu)));
    712712    TRPM_ENTER_DBG_HOOK(7);
    713     EMRCHistoryAddExitCsEip(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_XCPT, X86_XCPT_NM),
     713    EMRCHistoryAddExitCsEip(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_XCPT, X86_XCPT_NM),
    714714                            pRegFrame->cs.Sel, pRegFrame->eip, ASMReadTSC());
    715715    PGMRZDynMapStartAutoSet(pVCpu);
    … …  
    739739    LogFlow(("TRPMGC0b: %04x:%08x EFL=%x\n", pRegFrame->cs.Sel, pRegFrame->eip, CPUMRawGetEFlags(pVCpu)));
    740740    TRPM_ENTER_DBG_HOOK(0xb);
    741     EMRCHistoryAddExitCsEip(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_XCPT, X86_XCPT_NP),
     741    EMRCHistoryAddExitCsEip(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_XCPT, X86_XCPT_NP),
    742742                            pRegFrame->cs.Sel, pRegFrame->eip, ASMReadTSC());
    743743    PGMRZDynMapStartAutoSet(pVCpu);
    … …  
    864864        case OP_INT:
    865865        {
    866             EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_INT));
     866            EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_INT));
    867867            Assert(pCpu->Param1.fUse & DISUSE_IMMEDIATE8);
    868868            Assert(!(PATMIsPatchGCAddr(pVM, PC)));
    … …  
    897897
    898898        case OP_HLT:
    899             EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_HLT));
     899            EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_HLT));
    900900
    901901            /* If it's in patch code, defer to ring-3. */
    … …  
    921921            {
    922922                if (uOpcode == OP_MOV_CR)
    923                     EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_MOV_CRX));
     923                    EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_MOV_CRX));
    924924                else
    925                     EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_MOV_DRX));
     925                    EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_MOV_DRX));
    926926                break;
    927927            }
    … …  
    941941            {
    942942                case OP_MOV_CR:
    943                     EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_MOV_CRX));
     943                    EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_MOV_CRX));
    944944                    break;
    945945                case OP_MOV_DR:
    946                     EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_MOV_DRX));
     946                    EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_MOV_DRX));
    947947                    break;
    948948                case OP_INVLPG:
    949                     EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_INVLPG));
     949                    EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_INVLPG));
    950950                    break;
    951951                case OP_LLDT:
    952                     EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_LLDT));
     952                    EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_LLDT));
    953953                    break;
    954954                case OP_STI:
    955                     EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_STI));
     955                    EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_STI));
    956956                    break;
    957957                case OP_RDPMC:
    958                     EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_RDPMC));
     958                    EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_RDPMC));
    959959                    break;
    960960                case OP_CLTS:
    961                     EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_CLTS));
     961                    EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_CLTS));
    962962                    break;
    963963                case OP_WBINVD:
    964                     EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_CLTS));
     964                    EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_CLTS));
    965965                    break;
    966966                case OP_RDMSR:
    967                     EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_MSR_READ));
     967                    EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_MSR_READ));
    968968                    break;
    969969                case OP_WRMSR:
    970                     EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_MSR_WRITE));
     970                    EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_MSR_WRITE));
    971971                    break;
    972972            }
    … …  
    10201020        case OP_INT:
    10211021        {
    1022             EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_INT));
     1022            EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_INT));
    10231023            Assert(pCpu->Param1.fUse & DISUSE_IMMEDIATE8);
    10241024            rc = TRPMForwardTrap(pVCpu, pRegFrame, (uint32_t)pCpu->Param1.uValue, pCpu->cbInstr, TRPM_TRAP_NO_ERRORCODE, TRPM_SOFTWARE_INT, 0xd);
    … …  
    10411041        case OP_SYSENTER:
    10421042            if (uOpcode == OP_SYSCALL)
    1043                 EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_SYSCALL));
     1043                EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_SYSCALL));
    10441044            else
    1045                 EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_SYSENTER));
     1045                EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_SYSENTER));
    10461046#ifdef PATM_EMULATE_SYSENTER
    10471047            rc = PATMSysCall(pVM, CPUMCTX_FROM_CORE(pRegFrame), pCpu);
    … …  
    11871187    if (Cpu.pCurInstr->uOpcode == OP_RDTSC)
    11881188    {
    1189         EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_EM, EMEXITTYPE_RDTSC));
     1189        EMHistoryUpdateFlagsAndType(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_RDTSC));
    11901190        return trpmGCTrap0dHandlerRdTsc(pVM, pVCpu, pRegFrame);
    11911191    }
    … …  
    12581258    LogFlow(("TRPMGC0d: %04x:%08x err=%x EFL=%x\n", pRegFrame->cs.Sel, pRegFrame->eip, (uint32_t)pVCpu->trpm.s.uActiveErrorCode, CPUMRawGetEFlags(pVCpu)));
    12591259    TRPM_ENTER_DBG_HOOK(0xd);
    1260     EMRCHistoryAddExitCsEip(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_XCPT, X86_XCPT_GP),
     1260    EMRCHistoryAddExitCsEip(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_XCPT, X86_XCPT_GP),
    12611261                            pRegFrame->cs.Sel, pRegFrame->eip, ASMReadTSC());
    12621262
    … …  
    13251325    LogFlow(("TRPMGC0e: %04x:%08x err=%x cr2=%08x EFL=%x\n", pRegFrame->cs.Sel, pRegFrame->eip, (uint32_t)pVCpu->trpm.s.uActiveErrorCode, (uint32_t)pVCpu->trpm.s.uActiveCR2, CPUMRawGetEFlags(pVCpu)));
    13261326    TRPM_ENTER_DBG_HOOK(0xe);
    1327     EMRCHistoryAddExitCsEip(pVCpu, EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_XCPT, X86_XCPT_PF),
     1327    EMRCHistoryAddExitCsEip(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_XCPT, X86_XCPT_PF),
    13281328                            pRegFrame->cs.Sel, pRegFrame->eip, ASMReadTSC());
    13291329
    … …  
    14421442DECLASM(int) TRPMGCHyperTrap0bHandler(PTRPMCPU pTrpmCpu, PCPUMCTXCORE pRegFrame)
    14431443{
    1444     EMRCHistoryAddExitCsEip(TRPMCPU_2_VMCPU(pTrpmCpu), EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_XCPT, X86_XCPT_NP),
     1444    EMRCHistoryAddExitCsEip(TRPMCPU_2_VMCPU(pTrpmCpu), EMEXIT_MAKE_FT(EMEXIT_F_KIND_XCPT, X86_XCPT_NP),
    14451445                            pRegFrame->cs.Sel, pRegFrame->eip, ASMReadTSC());
    14461446    return trpmGCHyperGeneric(TRPMCPU_2_VM(pTrpmCpu), pRegFrame, g_aTrap0bHandlers, g_aTrap0bHandlersEnd);
    … …  
    14631463DECLASM(int) TRPMGCHyperTrap0dHandler(PTRPMCPU pTrpmCpu, PCPUMCTXCORE pRegFrame)
    14641464{
    1465     EMRCHistoryAddExitCsEip(TRPMCPU_2_VMCPU(pTrpmCpu), EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_XCPT, X86_XCPT_GP),
     1465    EMRCHistoryAddExitCsEip(TRPMCPU_2_VMCPU(pTrpmCpu), EMEXIT_MAKE_FT(EMEXIT_F_KIND_XCPT, X86_XCPT_GP),
    14661466                            pRegFrame->cs.Sel, pRegFrame->eip, ASMReadTSC());
    14671467    return trpmGCHyperGeneric(TRPMCPU_2_VM(pTrpmCpu), pRegFrame, g_aTrap0dHandlers, g_aTrap0dHandlersEnd);
    … …  
    14841484DECLASM(int) TRPMGCHyperTrap0eHandler(PTRPMCPU pTrpmCpu, PCPUMCTXCORE pRegFrame)
    14851485{
    1486     EMRCHistoryAddExitCsEip(TRPMCPU_2_VMCPU(pTrpmCpu), EMEXIT_MAKE_FLAGS_AND_TYPE(EMEXIT_F_KIND_XCPT, X86_XCPT_PF),
     1486    EMRCHistoryAddExitCsEip(TRPMCPU_2_VMCPU(pTrpmCpu), EMEXIT_MAKE_FT(EMEXIT_F_KIND_XCPT, X86_XCPT_PF),
    14871487                            pRegFrame->cs.Sel, pRegFrame->eip, ASMReadTSC());
    14881488    return trpmGCHyperGeneric(TRPMCPU_2_VM(pTrpmCpu), pRegFrame, g_aTrap0dHandlers, g_aTrap0dHandlersEnd);
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