VirtualBox

Changeset 46423 in vbox


Ignore:
Timestamp:
Jun 6, 2013 7:48:27 PM (12 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
86256
Message:

VMM,Main: Introduced a execute-all-in-IEM debug mode.

Location:
trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed

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

    r45907 r46423  
    5353    /** Hardware accelerated raw-mode execution. */
    5454    EMSTATE_HM,
    55     /** Value reserved for future use (used to be PARAV). */
    56     EMSTATE_RESERVED,
     55    /** Executing in IEM. */
     56    EMSTATE_IEM,
    5757    /** Recompiled mode execution. */
    5858    EMSTATE_REM,
    … …  
    252252    /** Whether to recompile ring-3 code or execute it in raw/hm. */
    253253    EMEXECPOLICY_RECOMPILE_RING3,
     254    /** Whether to only use IEM for execution. */
     255    EMEXECPOLICY_IEM_ALL,
    254256    /** End of valid value (not included). */
    255257    EMEXECPOLICY_END,
    … …  
    258260} EMEXECPOLICY;
    259261VMMR3DECL(int)                  EMR3SetExecutionPolicy(PUVM pUVM, EMEXECPOLICY enmPolicy, bool fEnforce);
    260 VMMR3DECL(bool)                 EMR3IsRawRing3Enabled(PUVM pUVM);
    261 VMMR3DECL(bool)                 EMR3IsRawRing0Enabled(PUVM pUVM);
     262VMMR3DECL(int)                  EMR3QueryExecutionPolicy(PUVM pUVM, EMEXECPOLICY enmPolicy, bool *pfEnforced);
    262263
    263264VMMR3_INT_DECL(int)             EMR3Init(PVM pVM);
    … …  
    271272VMMR3_INT_DECL(int)             EMR3NotifyResume(PVM pVM);
    272273VMMR3_INT_DECL(int)             EMR3NotifySuspend(PVM pVM);
    273 VMMR3_INT_DECL(bool)            EMR3IsExecutionAllowed(PVM pVM, PVMCPU pVCpu);
    274274/** @} */
    275275#endif /* IN_RING3 */

  • trunk/src/VBox/Main/idl/VirtualBox.xidl

    r46367 r46423  
    1550215502  <interface
    1550315503    name="IMachineDebugger" extends="$unknown"
    15504     uuid="1eeeb3c2-0089-4448-878e-414aee00e03b"
     15504    uuid="5e4534dc-21b8-4f6b-8a08-eef50e1a0aa1"
    1550515505    wsmap="managed"
    1550615506    >
    … …  
    1584415844    <attribute name="recompileSupervisor" type="boolean">
    1584515845      <desc>Switch for forcing code recompilation for supervisor mode code.</desc>
     15846    </attribute>
     15847
     15848    <attribute name="executeAllInIEM" type="boolean">
     15849      <desc>
     15850        Whether to execute all the code in the instruction interpreter. This
     15851        is mainly for testing the interpreter and not an execution mode
     15852        intended for general consumption.
     15853      </desc>
    1584615854    </attribute>
    1584715855

  • trunk/src/VBox/Main/include/MachineDebuggerImpl.h

    r45971 r46423  
    2323#include "VirtualBoxBase.h"
    2424#include <iprt/log.h>
     25#include <VBox/vmm/em.h>
    2526
    2627class Console;
    … …  
    5859    STDMETHOD(COMGETTER(RecompileSupervisor))(BOOL *a_pfEnabled);
    5960    STDMETHOD(COMSETTER(RecompileSupervisor))(BOOL a_fEnable);
     61    STDMETHOD(COMGETTER(ExecuteAllInIEM))(BOOL *a_pfEnabled);
     62    STDMETHOD(COMSETTER(ExecuteAllInIEM))(BOOL a_fEnable);
    6063    STDMETHOD(COMGETTER(PATMEnabled))(BOOL *a_pfEnabled);
    6164    STDMETHOD(COMSETTER(PATMEnabled))(BOOL a_fEnable);
    … …  
    110113    // private methods
    111114    bool queueSettings() const;
     115    HRESULT getEmExecPolicyProperty(EMEXECPOLICY enmPolicy, BOOL *pfEnforced);
     116    HRESULT setEmExecPolicyProperty(EMEXECPOLICY enmPolicy, BOOL fEnforce);
    112117
    113118    /** RTLogGetFlags, RTLogGetGroupSettings and RTLogGetDestinations function. */
    … …  
    121126     *        to the VM (not up yet, etc.)
    122127     * @{ */
     128    uint8_t maiQueuedEmExecPolicyParams[EMEXECPOLICY_END];
    123129    int mSingleStepQueued;
    124130    int mRecompileUserQueued;

  • trunk/src/VBox/Main/src-client/MachineDebuggerImpl.cpp

    r45971 r46423  
    8282    unconst(mParent) = aParent;
    8383
     84    for (unsigned i = 0; i < RT_ELEMENTS(maiQueuedEmExecPolicyParams); i++)
     85        maiQueuedEmExecPolicyParams[i] = UINT8_MAX;
    8486    mSingleStepQueued = ~0;
    8587    mRecompileUserQueued = ~0;
    … …  
    168170
    169171/**
    170  * Returns the current recompile user mode code flag.
    171  *
    172  * @returns COM status code
    173  * @param   a_fEnabled address of result variable
    174  */
    175 STDMETHODIMP MachineDebugger::COMGETTER(RecompileUser) (BOOL *aEnabled)
    176 {
    177     CheckComArgOutPointerValid(aEnabled);
    178 
    179     AutoCaller autoCaller(this);
    180     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    181 
    182     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    183 
    184     Console::SafeVMPtrQuiet ptrVM(mParent);
    185 
    186     if (ptrVM.isOk())
    187         *aEnabled = !EMR3IsRawRing3Enabled(ptrVM.rawUVM());
    188     else
    189         *aEnabled = false;
    190 
    191     return S_OK;
    192 }
    193 
    194 /**
    195  * Sets the recompile user mode code flag.
    196  *
    197  * @returns COM status
    198  * @param   aEnable new user mode code recompile flag.
    199  */
    200 STDMETHODIMP MachineDebugger::COMSETTER(RecompileUser)(BOOL aEnable)
    201 {
    202     LogFlowThisFunc(("enable=%d\n", aEnable));
    203 
    204     AutoCaller autoCaller(this);
    205     HRESULT hrc = autoCaller.rc();
    206     if (SUCCEEDED(hrc))
    207     {
    208         AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     172 * Internal worker for getting an EM executable policy setting.
     173 *
     174 * @returns COM status code.
     175 * @param   enmPolicy           Which EM policy.
     176 * @param   pfEnforced          Where to return the policy setting.
     177 */
     178HRESULT MachineDebugger::getEmExecPolicyProperty(EMEXECPOLICY enmPolicy, BOOL *pfEnforced)
     179{
     180    CheckComArgOutPointerValid(pfEnforced);
     181
     182    AutoCaller autoCaller(this);
     183    HRESULT hrc = autoCaller.rc();
     184    if (SUCCEEDED(hrc))
     185    {
     186        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    209187        if (queueSettings())
    210             mRecompileUserQueued = aEnable; // queue the request
     188            *pfEnforced = maiQueuedEmExecPolicyParams[enmPolicy] == 1;
    211189        else
    212190        {
    213             Console::SafeVMPtr ptrVM(mParent);
     191            bool fEnforced = false;
     192            Console::SafeVMPtrQuiet ptrVM(mParent);
     193            hrc = ptrVM.rc();
     194            if (SUCCEEDED(hrc))
     195                EMR3QueryExecutionPolicy(ptrVM.rawUVM(), enmPolicy, &fEnforced);
     196            *pfEnforced = fEnforced;
     197        }
     198    }
     199    return hrc;
     200}
     201
     202/**
     203 * Internal worker for setting an EM executable policy.
     204 *
     205 * @returns COM status code.
     206 * @param   enmPolicy           Which policy to change.
     207 * @param   fEnforce            Whether to enforce the policy or not.
     208 */
     209HRESULT MachineDebugger::setEmExecPolicyProperty(EMEXECPOLICY enmPolicy, BOOL fEnforce)
     210{
     211    AutoCaller autoCaller(this);
     212    HRESULT hrc = autoCaller.rc();
     213    if (SUCCEEDED(hrc))
     214    {
     215        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     216        if (queueSettings())
     217            maiQueuedEmExecPolicyParams[enmPolicy] = fEnforce ? 1 : 0;
     218        else
     219        {
     220            Console::SafeVMPtrQuiet ptrVM(mParent);
    214221            hrc = ptrVM.rc();
    215222            if (SUCCEEDED(hrc))
    216223            {
    217                 int vrc = EMR3SetExecutionPolicy(ptrVM.rawUVM(), EMEXECPOLICY_RECOMPILE_RING3, RT_BOOL(aEnable));
     224                int vrc = EMR3SetExecutionPolicy(ptrVM.rawUVM(), enmPolicy, fEnforce != FALSE);
    218225                if (RT_FAILURE(vrc))
    219226                    hrc = setError(VBOX_E_VM_ERROR, tr("EMR3SetExecutionPolicy failed with %Rrc"), vrc);
    … …  
    225232
    226233/**
     234 * Returns the current recompile user mode code flag.
     235 *
     236 * @returns COM status code
     237 * @param   a_fEnabled address of result variable
     238 */
     239STDMETHODIMP MachineDebugger::COMGETTER(RecompileUser) (BOOL *aEnabled)
     240{
     241    return getEmExecPolicyProperty(EMEXECPOLICY_RECOMPILE_RING3, aEnabled);
     242}
     243
     244/**
     245 * Sets the recompile user mode code flag.
     246 *
     247 * @returns COM status
     248 * @param   aEnable new user mode code recompile flag.
     249 */
     250STDMETHODIMP MachineDebugger::COMSETTER(RecompileUser)(BOOL aEnable)
     251{
     252    LogFlowThisFunc(("enable=%d\n", aEnable));
     253    return setEmExecPolicyProperty(EMEXECPOLICY_RECOMPILE_RING3, aEnable);
     254}
     255
     256/**
    227257 * Returns the current recompile supervisor code flag.
    228258 *
    … …  
    232262STDMETHODIMP MachineDebugger::COMGETTER(RecompileSupervisor) (BOOL *aEnabled)
    233263{
    234     CheckComArgOutPointerValid(aEnabled);
    235 
    236     AutoCaller autoCaller(this);
    237     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    238 
    239     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    240 
    241     Console::SafeVMPtrQuiet ptrVM(mParent);
    242 
    243     if (ptrVM.isOk())
    244         *aEnabled = !EMR3IsRawRing0Enabled(ptrVM.rawUVM());
    245     else
    246         *aEnabled = false;
    247 
    248     return S_OK;
     264    return getEmExecPolicyProperty(EMEXECPOLICY_RECOMPILE_RING0, aEnabled);
    249265}
    250266
    … …  
    258274{
    259275    LogFlowThisFunc(("enable=%d\n", aEnable));
    260 
    261     AutoCaller autoCaller(this);
    262     HRESULT hrc = autoCaller.rc();
    263     if (SUCCEEDED(hrc))
    264     {
    265         AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    266         if (queueSettings())
    267             mRecompileSupervisorQueued = aEnable; // queue the request
    268         else
    269         {
    270             Console::SafeVMPtr ptrVM(mParent);
    271             hrc = ptrVM.rc();
    272             if (SUCCEEDED(hrc))
    273             {
    274                 int vrc = EMR3SetExecutionPolicy(ptrVM.rawUVM(), EMEXECPOLICY_RECOMPILE_RING0, RT_BOOL(aEnable));
    275                 if (RT_FAILURE(vrc))
    276                     hrc = setError(VBOX_E_VM_ERROR, tr("EMR3SetExecutionPolicy failed with %Rrc"), vrc);
    277             }
    278         }
    279     }
    280     return hrc;
     276    return setEmExecPolicyProperty(EMEXECPOLICY_RECOMPILE_RING0, aEnable);
     277}
     278
     279/**
     280 * Returns the current execute-all-in-IEM setting.
     281 *
     282 * @returns COM status code
     283 * @param   aEnabled    Address of result variable.
     284 */
     285STDMETHODIMP MachineDebugger::COMGETTER(ExecuteAllInIEM) (BOOL *aEnabled)
     286{
     287    return getEmExecPolicyProperty(EMEXECPOLICY_IEM_ALL, aEnabled);
     288}
     289
     290/**
     291 * Changes the execute-all-in-IEM setting.
     292 *
     293 * @returns COM status code
     294 * @param   aEnable     New setting.
     295 */
     296STDMETHODIMP MachineDebugger::COMSETTER(ExecuteAllInIEM)(BOOL aEnable)
     297{
     298    LogFlowThisFunc(("enable=%d\n", aEnable));
     299    return setEmExecPolicyProperty(EMEXECPOLICY_IEM_ALL, aEnable);
    281300}
    282301
    … …  
    15151534        mSingleStepQueued = ~0;
    15161535    }
    1517     if (mRecompileUserQueued != ~0)
    1518     {
    1519         COMSETTER(RecompileUser)(mRecompileUserQueued);
    1520         mRecompileUserQueued = ~0;
    1521     }
    1522     if (mRecompileSupervisorQueued != ~0)
    1523     {
    1524         COMSETTER(RecompileSupervisor)(mRecompileSupervisorQueued);
    1525         mRecompileSupervisorQueued = ~0;
    1526     }
     1536    for (unsigned i = 0; i < EMEXECPOLICY_END; i++)
     1537        if (maiQueuedEmExecPolicyParams[i] != UINT8_MAX)
     1538        {
     1539            setEmExecPolicyProperty((EMEXECPOLICY)i, RT_BOOL(maiQueuedEmExecPolicyParams[i]));
     1540            maiQueuedEmExecPolicyParams[i] = UINT8_MAX;
     1541        }
    15271542    if (mPatmEnabledQueued != ~0)
    15281543    {

  • trunk/src/VBox/VMM/Makefile.kmk

    r46167 r46423  
    128128        VMMR3/DBGFR3Trace.cpp \
    129129        VMMR3/EM.cpp \
     130        VMMR3/EMR3Dbg.cpp \
    130131        $(if $(VBOX_WITH_RAW_MODE),VMMR3/EMRaw.cpp) \
    131132        VMMR3/EMHM.cpp \

  • trunk/src/VBox/VMM/VMMR3/EM.cpp

    r46420 r46423  
    4242#include <VBox/vmm/selm.h>
    4343#include <VBox/vmm/trpm.h>
     44#include <VBox/vmm/iem.h>
    4445#include <VBox/vmm/iom.h>
    4546#include <VBox/vmm/dbgf.h>
    … …  
    4748#ifdef VBOX_WITH_REM
    4849# include <VBox/vmm/rem.h>
    49 #else
    50 # include <VBox/vmm/iem.h>
    5150#endif
    5251#include <VBox/vmm/tm.h>
    … …  
    118117     */
    119118    pVM->em.s.offVM = RT_OFFSETOF(VM, em.s);
     119    PCFGMNODE pCfgRoot = CFGMR3GetRoot(pVM);
     120    PCFGMNODE pCfgEM = CFGMR3GetChild(pCfgRoot, "EM");
     121
    120122    bool fEnabled;
    121     int rc = CFGMR3QueryBool(CFGMR3GetRoot(pVM), "RawR3Enabled", &fEnabled);
    122     pVM->fRecompileUser       = RT_SUCCESS(rc) ? !fEnabled : false;
    123     rc = CFGMR3QueryBool(CFGMR3GetRoot(pVM), "RawR0Enabled", &fEnabled);
    124     pVM->fRecompileSupervisor = RT_SUCCESS(rc) ? !fEnabled : false;
    125     Log(("EMR3Init: fRecompileUser=%RTbool fRecompileSupervisor=%RTbool\n", pVM->fRecompileUser, pVM->fRecompileSupervisor));
     123    int rc = CFGMR3QueryBoolDef(pCfgRoot, "RawR3Enabled", &fEnabled, true);
     124    AssertLogRelRCReturn(rc, rc);
     125    pVM->fRecompileUser       = !fEnabled;
     126
     127    rc = CFGMR3QueryBoolDef(pCfgRoot, "RawR0Enabled", &fEnabled, true);
     128    AssertLogRelRCReturn(rc, rc);
     129    pVM->fRecompileSupervisor = !fEnabled;
    126130
    127131#ifdef VBOX_WITH_RAW_RING1
    128     rc = CFGMR3QueryBool(CFGMR3GetRoot(pVM), "RawR1Enabled", &fEnabled);
    129     pVM->fRawRing1Enabled = RT_SUCCESS(rc) ? fEnabled : false;
    130     Log(("EMR3Init: fRawRing1Enabled=%RTbool\n", pVM->fRawRing1Enabled));
     132    rc = CFGMR3QueryBoolDef(pCfgRoot, "RawR1Enabled", &pVM->fRawRing1Enabled, false);
     133    AssertLogRelRCReturn(rc, rc);
    131134#else
    132     pVM->fRawRing1Enabled = false;      /* disabled by default. */
    133 #endif
     135    pVM->fRawRing1Enabled = false;      /* Disabled by default. */
     136#endif
     137
     138    rc = CFGMR3QueryBoolDef(pCfgEM, "IemExecutesAll", &pVM->em.s.fIemExecutesAll, false);
     139    AssertLogRelRCReturn(rc, rc);
     140
     141    Log(("EMR3Init: fRecompileUser=%RTbool fRecompileSupervisor=%RTbool fRawRing1Enabled=%RTbool fIemExecutesAll=%RTbool\n",
     142         pVM->fRecompileUser, pVM->fRecompileSupervisor, pVM->fRawRing1Enabled, pVM->em.s.fIemExecutesAll));
    134143
    135144#ifdef VBOX_WITH_REM
    … …  
    428437    }
    429438
     439    emR3InitDbg(pVM);
    430440    return VINF_SUCCESS;
    431441}
    … …  
    559569     * Validate version.
    560570     */
    561     if (    uVersion != EM_SAVED_STATE_VERSION
    562         &&  uVersion != EM_SAVED_STATE_VERSION_PRE_MWAIT
    563         &&  uVersion != EM_SAVED_STATE_VERSION_PRE_SMP)
     571    if (    uVersion > EM_SAVED_STATE_VERSION
     572        ||  uVersion < EM_SAVED_STATE_VERSION_PRE_SMP)
    564573    {
    565574        AssertMsgFailed(("emR3Load: Invalid version uVersion=%d (current %d)!\n", uVersion, EM_SAVED_STATE_VERSION));
    … …  
    641650                pVM->fRecompileUser = pArgs->fEnforce;
    642651                break;
     652            case EMEXECPOLICY_IEM_ALL:
     653                pVM->em.s.fIemExecutesAll = pArgs->fEnforce;
     654                break;
    643655            default:
    644656                AssertFailedReturn(VERR_INVALID_PARAMETER);
    645657        }
    646         Log(("emR3SetExecutionPolicy: fRecompileUser=%RTbool fRecompileSupervisor=%RTbool\n",
    647               pVM->fRecompileUser, pVM->fRecompileSupervisor));
     658        Log(("emR3SetExecutionPolicy: fRecompileUser=%RTbool fRecompileSupervisor=%RTbool fIemExecutesAll=%RTbool\n",
     659              pVM->fRecompileUser, pVM->fRecompileSupervisor, pVM->em.s.fIemExecutesAll));
    648660    }
    649661
    650662    /*
    651      * Force rescheduling if in RAW, HM or REM.
     663     * Force rescheduling if in RAW, HM, IEM, or REM.
    652664     */
    653665    return    pVCpu->em.s.enmState == EMSTATE_RAW
    654666           || pVCpu->em.s.enmState == EMSTATE_HM
     667           || pVCpu->em.s.enmState == EMSTATE_IEM
    655668           || pVCpu->em.s.enmState == EMSTATE_REM
    656669         ? VINF_EM_RESCHEDULE
    … …  
    660673
    661674/**
    662  * Changes a the execution scheduling policy.
     675 * Changes an execution scheduling policy parameter.
    663676 *
    664677 * This is used to enable or disable raw-mode / hardware-virtualization
    … …  
    685698
    686699/**
    687  * Checks if raw ring-3 execute mode is enabled.
    688  *
    689  * @returns true if enabled, false if disabled.
     700 * Queries an execution scheduling policy parameter.
     701 *
     702 * @returns VBox status code
    690703 * @param   pUVM            The user mode VM handle.
    691  */
    692 VMMR3DECL(bool) EMR3IsRawRing3Enabled(PUVM pUVM)
     704 * @param   enmPolicy       The scheduling policy to query.
     705 * @param   pfEnforced      Where to return the current value.
     706 */
     707VMMR3DECL(int) EMR3QueryExecutionPolicy(PUVM pUVM, EMEXECPOLICY enmPolicy, bool *pfEnforced)
    693708{
    694     UVM_ASSERT_VALID_EXT_RETURN(pUVM, false);
     709    AssertReturn(enmPolicy > EMEXECPOLICY_INVALID && enmPolicy < EMEXECPOLICY_END, VERR_INVALID_PARAMETER);
     710    AssertPtrReturn(pfEnforced, VERR_INVALID_POINTER);
     711    UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
    695712    PVM pVM = pUVM->pVM;
    696     VM_ASSERT_VALID_EXT_RETURN(pVM, false);
    697     return EMIsRawRing3Enabled(pVM);
    698 }
    699 
    700 
    701 /**
    702  * Checks if raw ring-0 execute mode is enabled.
    703  *
    704  * @returns true if enabled, false if disabled.
    705  * @param   pUVM            The user mode VM handle.
    706  */
    707 VMMR3DECL(bool) EMR3IsRawRing0Enabled(PUVM pUVM)
    708 {
    709     UVM_ASSERT_VALID_EXT_RETURN(pUVM, false);
    710     PVM pVM = pUVM->pVM;
    711     VM_ASSERT_VALID_EXT_RETURN(pVM, false);
    712     return EMIsRawRing0Enabled(pVM);
     713    VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
     714
     715    /* No need to bother EMTs with a query. */
     716    switch (enmPolicy)
     717    {
     718        case EMEXECPOLICY_RECOMPILE_RING0:
     719            *pfEnforced = pVM->fRecompileSupervisor;
     720            break;
     721        case EMEXECPOLICY_RECOMPILE_RING3:
     722            *pfEnforced = pVM->fRecompileUser;
     723            break;
     724        case EMEXECPOLICY_IEM_ALL:
     725            *pfEnforced = pVM->em.s.fIemExecutesAll;
     726            break;
     727        default:
     728            AssertFailedReturn(VERR_INTERNAL_ERROR_2);
     729    }
     730
     731    return VINF_SUCCESS;
    713732}
    714733
    … …  
    744763        case EMSTATE_NONE:              return "EMSTATE_NONE";
    745764        case EMSTATE_RAW:               return "EMSTATE_RAW";
    746         case EMSTATE_HM:             return "EMSTATE_HM";
     765        case EMSTATE_HM:                return "EMSTATE_HM";
     766        case EMSTATE_IEM:               return "EMSTATE_IEM";
    747767        case EMSTATE_REM:               return "EMSTATE_REM";
    748768        case EMSTATE_HALTED:            return "EMSTATE_HALTED";
    … …  
    944964}
    945965
     966
    946967/**
    947968 * Steps recompiled code.
    … …  
    10901111         * Execute REM.
    10911112         */
    1092         if (RT_LIKELY(EMR3IsExecutionAllowed(pVM, pVCpu)))
     1113        if (RT_LIKELY(emR3IsExecutionAllowed(pVM, pVCpu)))
    10931114        {
    10941115            STAM_PROFILE_START(&pVCpu->em.s.StatREMExec, c);
    … …  
    12401261    if (pVCpu->em.s.enmState == EMSTATE_WAIT_SIPI)
    12411262        return EMSTATE_WAIT_SIPI;
     1263
     1264    /*
     1265     * Execute everything in IEM?
     1266     */
     1267    if (pVM->em.s.fIemExecutesAll)
     1268        return EMSTATE_IEM;
    12421269
    12431270    /* !!! THIS MUST BE IN SYNC WITH remR3CanExecuteRaw !!! */
    … …  
    19421969 * @param   pVM         Pointer to the VM.
    19431970 * @param   pVCpu       Pointer to the VMCPU.
    1944  *
    1945  */
    1946 VMMR3_INT_DECL(bool) EMR3IsExecutionAllowed(PVM pVM, PVMCPU pVCpu)
     1971 */
     1972bool emR3IsExecutionAllowed(PVM pVM, PVMCPU pVCpu)
    19471973{
    19481974    uint64_t u64UserTime, u64KernelTime;
    … …  
    23422368
    23432369                /*
     2370                 * Execute in the interpreter.
     2371                 */
     2372                case EMSTATE_IEM:
     2373                    rc = VBOXSTRICTRC_TODO(IEMExecLots(pVCpu));
     2374                    fFFDone = false;
     2375                    break;
     2376
     2377                /*
    23442378                 * Application processor execution halted until SIPI.
    23452379                 */

  • trunk/src/VBox/VMM/VMMR3/EMHM.cpp

    r46420 r46423  
    545545        STAM_PROFILE_ADV_STOP(&pVCpu->em.s.StatHmEntry, a);
    546546
    547         if (RT_LIKELY(EMR3IsExecutionAllowed(pVM, pVCpu)))
     547        if (RT_LIKELY(emR3IsExecutionAllowed(pVM, pVCpu)))
    548548        {
    549549            STAM_PROFILE_START(&pVCpu->em.s.StatHmExec, x);

  • trunk/src/VBox/VMM/VMMR3/EMRaw.cpp

    r46420 r46423  
    14481448         */
    14491449        STAM_PROFILE_ADV_STOP(&pVCpu->em.s.StatRAWEntry, b);
    1450         if (RT_LIKELY(EMR3IsExecutionAllowed(pVM, pVCpu)))
     1450        if (RT_LIKELY(emR3IsExecutionAllowed(pVM, pVCpu)))
    14511451        {
    14521452            STAM_PROFILE_START(&pVCpu->em.s.StatRAWExec, c);

  • trunk/src/VBox/VMM/include/EMInternal.h

    r45528 r46423  
    3939
    4040/** The saved state version. */
    41 #define EM_SAVED_STATE_VERSION                          4
     41#define EM_SAVED_STATE_VERSION                          5
     42#define EM_SAVED_STATE_VERSION_PRE_IEM                  4
    4243#define EM_SAVED_STATE_VERSION_PRE_MWAIT                3
    4344#define EM_SAVED_STATE_VERSION_PRE_SMP                  2
    … …  
    308309    RTUINT                  offVM;
    309310
     311    /** Whether IEM executes everything. */
     312    bool                    fIemExecutesAll;
     313    /** Alignment padding. */
     314    bool                    afPadding[7];
     315
    310316    /** Id of the VCPU that last executed code in the recompiler. */
    311317    VMCPUID                 idLastRemCpu;
    … …  
    443449/** @} */
    444450
     451int     emR3InitDbg(PVM pVM);
    445452
    446453int     emR3HmExecute(PVM pVM, PVMCPU pVCpu, bool *pfFFDone);
    … …  
    455462int     emR3RawStep(PVM pVM, PVMCPU pVCpu);
    456463int     emR3SingleStepExecRem(PVM pVM, PVMCPU pVCpu, uint32_t cIterations);
     464bool    emR3IsExecutionAllowed(PVM pVM, PVMCPU pVCpu);
    457465
    458466RT_C_DECLS_END
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