VirtualBox

Changeset 19747 in vbox


Ignore:
Timestamp:
May 15, 2009 4:05:41 PM (16 years ago)
Author:
vboxsync
Message:

TM: Cleaned up pausing and resuming the clocks.

Location:
trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/tm.h

    r19709 r19747  
    7777VMMDECL(void)     TMNotifyStartOfHalt(PVMCPU pVCpu);
    7878VMMDECL(void)     TMNotifyEndOfHalt(PVMCPU pVCpu);
    79 
    80 VMMDECL(uint32_t) TMGetWarpDrive(PVM pVM);
    8179#ifdef IN_RING3
     80VMMR3DECL(int)    TMR3NotifySuspend(PVM pVM, PVMCPU pVCpu);
     81VMMR3DECL(int)    TMR3NotifyResume(PVM pVM, PVMCPU pVCpu);
    8282VMMR3DECL(int)    TMR3SetWarpDrive(PVM pVM, uint32_t u32Percent);
    8383#endif
     84VMMDECL(uint32_t) TMGetWarpDrive(PVM pVM);
    8485
    8586
    … …  
    103104VMMDECL(uint64_t) TMVirtualSyncGetNoCheck(PVM pVM);
    104105VMMDECL(uint64_t) TMVirtualSyncGetEx(PVM pVM, bool fCheckTimers);
    105 VMMDECL(int)      TMVirtualResume(PVM pVM);
    106 VMMDECL(int)      TMVirtualPause(PVM pVM);
    107106VMMDECL(uint64_t) TMVirtualToNano(PVM pVM, uint64_t u64VirtualTicks);
    108107VMMDECL(uint64_t) TMVirtualToMicro(PVM pVM, uint64_t u64VirtualTicks);
    … …  
    117116 * @{
    118117 */
    119 VMMDECL(int)      TMCpuTickResume(PVMCPU pVCpu);
    120 VMMDECL(int)      TMCpuTickPause(PVMCPU pVCpu);
    121118VMMDECL(uint64_t) TMCpuTickGet(PVMCPU pVCpu);
     119VMMDECL(uint64_t) TMCpuTickGetNoCheck(PVMCPU pVCpu);
    122120VMMDECL(bool)     TMCpuTickCanUseRealTSC(PVMCPU pVCpu, uint64_t *poffRealTSC);
    123121VMMDECL(int)      TMCpuTickSet(PVMCPU pVCpu, uint64_t u64Tick);

  • trunk/src/VBox/Devices/vl_vbox.h

    r19507 r19747  
    9494#define qemu_mod_timer(timer, expire)           TMTimerSet(timer, (uint64_t)expire)
    9595#define qemu_timer_pending(timer)               TMTimerIsActive(timer)
    96 #define cpu_disable_ticks()                     TMCpuTickPause((PVM)cpu_single_env->pVM)
    97 #define cpu_enable_ticks()                      TMCpuTickResume((PVM)cpu_single_env->pVM)
     96#define cpu_disable_ticks()                     ASMBreakpoint()
     97#define cpu_enable_ticks()                      ASMBreakpoint()
    9898#define cpu_calibrate_ticks()                   do {} while (0)
    9999#define init_timers()                           do {} while (0)

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

    r19746 r19747  
    36433643         * Start the virtual time.
    36443644         */
    3645         rc = TMVirtualResume(pVM);
    3646         Assert(rc == VINF_SUCCESS);
    3647         rc = TMCpuTickResume(pVCpu);
    3648         Assert(rc == VINF_SUCCESS);
     3645        TMR3NotifyResume(pVM, pVCpu);
    36493646
    36503647        /*
    … …  
    38153812                    pVCpu->em.s.enmState = EMSTATE_TERMINATING;
    38163813                    Log2(("EMR3ExecuteVM: returns VINF_EM_OFF (%d -> %d)\n", pVCpu->em.s.enmState, EMSTATE_TERMINATING));
    3817                     TMVirtualPause(pVM);
    3818                     TMCpuTickPause(pVCpu);
     3814                    TMR3NotifySuspend(pVM, pVCpu);
    38193815                    STAM_REL_PROFILE_ADV_STOP(&pVCpu->em.s.StatTotal, x);
    38203816                    return rc;
    … …  
    38263822                    pVCpu->em.s.enmState = EMSTATE_TERMINATING;
    38273823                    Log(("EMR3ExecuteVM returns VINF_EM_TERMINATE (%d -> %d)\n", pVCpu->em.s.enmState, EMSTATE_TERMINATING));
    3828                     TMVirtualPause(pVM);
    3829                     TMCpuTickPause(pVCpu);
     3824                    TMR3NotifySuspend(pVM, pVCpu);
    38303825                    STAM_REL_PROFILE_ADV_STOP(&pVCpu->em.s.StatTotal, x);
    38313826                    return rc;
    … …  
    38383833                    Log2(("EMR3ExecuteVM: VINF_EM_NO_MEMORY: %d -> %d\n", pVCpu->em.s.enmState, EMSTATE_SUSPENDED));
    38393834                    pVCpu->em.s.enmState = EMSTATE_SUSPENDED;
    3840                     TMVirtualPause(pVM);
    3841                     TMCpuTickPause(pVCpu);
     3835                    TMR3NotifySuspend(pVM, pVCpu);
    38423836                    STAM_REL_PROFILE_ADV_STOP(&pVCpu->em.s.StatTotal, x);
    38433837
    … …  
    39723966                 */
    39733967                case EMSTATE_SUSPENDED:
    3974                     TMVirtualPause(pVM);
    3975                     TMCpuTickPause(pVCpu);
     3968                    TMR3NotifySuspend(pVM, pVCpu);
    39763969                    STAM_REL_PROFILE_ADV_STOP(&pVCpu->em.s.StatTotal, x);
    39773970                    return VINF_EM_SUSPEND;
    … …  
    39823975                case EMSTATE_DEBUG_GUEST_REM:
    39833976                case EMSTATE_DEBUG_GUEST_RAW:
    3984                     TMVirtualPause(pVM);
    3985                     TMCpuTickPause(pVCpu);
     3977                    TMR3NotifySuspend(pVM, pVCpu);
    39863978                    rc = emR3Debug(pVM, pVCpu, rc);
    3987                     TMVirtualResume(pVM);
    3988                     TMCpuTickResume(pVCpu);
     3979                    TMR3NotifyResume(pVM, pVCpu);
    39893980                    Log2(("EMR3ExecuteVM: enmr3Debug -> %Rrc (state %d)\n", rc, pVCpu->em.s.enmState));
    39903981                    break;
    … …  
    39953986                case EMSTATE_DEBUG_HYPER:
    39963987                {
    3997                     TMVirtualPause(pVM);
    3998                     TMCpuTickPause(pVCpu);
     3988                    TMR3NotifySuspend(pVM, pVCpu);
    39993989                    STAM_REL_PROFILE_ADV_STOP(&pVCpu->em.s.StatTotal, x);
    40003990
    … …  
    40104000
    40114001                    STAM_REL_PROFILE_ADV_START(&pVCpu->em.s.StatTotal, x);
    4012                     TMVirtualResume(pVM);
    4013                     TMCpuTickResume(pVCpu);
     4002                    TMR3NotifyResume(pVM, pVCpu);
    40144003                    break;
    40154004                }
    … …  
    40204009                case EMSTATE_GURU_MEDITATION:
    40214010                {
    4022                     TMVirtualPause(pVM);
    4023                     TMCpuTickPause(pVCpu);
     4011                    TMR3NotifySuspend(pVM, pVCpu);
    40244012                    VMMR3FatalDump(pVM, pVCpu, rc);
    40254013                    emR3Debug(pVM, pVCpu, rc);
    … …  
    40364024                    AssertMsgFailed(("EMR3ExecuteVM: Invalid state %d!\n", pVCpu->em.s.enmState));
    40374025                    pVCpu->em.s.enmState = EMSTATE_GURU_MEDITATION;
    4038                     TMVirtualPause(pVM);
    4039                     TMCpuTickPause(pVCpu);
     4026                    TMR3NotifySuspend(pVM, pVCpu);
    40404027                    STAM_REL_PROFILE_ADV_STOP(&pVCpu->em.s.StatTotal, x);
    40414028                    return VERR_EM_INTERNAL_ERROR;
    … …  
    40494036         */
    40504037        LogFlow(("EMR3ExecuteVM: returns %Rrc (longjmp / fatal error)\n", rc));
    4051         TMVirtualPause(pVM);
    4052         TMCpuTickPause(pVCpu);
     4038        TMR3NotifySuspend(pVM, pVCpu);
    40534039        VMMR3FatalDump(pVM, pVCpu, rc);
    40544040        emR3Debug(pVM, pVCpu, rc);

  • trunk/src/VBox/VMM/TM.cpp

    r19717 r19747  
    23132313
    23142314/**
     2315 * Pauses all clocks except TMCLOCK_REAL.
     2316 *
     2317 * @returns VBox status code, all errors are asserted.
     2318 * @param   pVM         The VM handle.
     2319 * @param   pVCpu       The virtual CPU handle.
     2320 * @thread  EMT corrsponding to the virtual CPU handle.
     2321 */
     2322VMMR3DECL(int) TMR3NotifySuspend(PVM pVM, PVMCPU pVCpu)
     2323{
     2324    VMCPU_ASSERT_EMT(pVCpu);
     2325
     2326    /*
     2327     * The shared virtual clock (includes virtual sync which is tied to it).
     2328     */
     2329    tmLock(pVM);
     2330    int rc = tmVirtualPauseLocked(pVM);
     2331    tmUnlock(pVM);
     2332    if (RT_FAILURE(rc))
     2333        return rc;
     2334
     2335    /*
     2336     * Pause the TSC last since it is normally linked to the virtual
     2337     * sync clock, so the above code may actually stop both clock.
     2338     */
     2339    return tmCpuTickPause(pVM, pVCpu);
     2340}
     2341
     2342
     2343/**
     2344 * Resumes all clocks except TMCLOCK_REAL.
     2345 *
     2346 * @returns VBox status code, all errors are asserted.
     2347 * @param   pVM         The VM handle.
     2348 * @param   pVCpu       The virtual CPU handle.
     2349 * @thread  EMT corrsponding to the virtual CPU handle.
     2350 */
     2351VMMR3DECL(int) TMR3NotifyResume(PVM pVM, PVMCPU pVCpu)
     2352{
     2353    VMCPU_ASSERT_EMT(pVCpu);
     2354    int rc;
     2355
     2356    /*
     2357     * Resume the TSC first since it is normally linked to the virtual sync
     2358     * clock, so it may actually not be resumed until we've executed the code
     2359     * below.
     2360     */
     2361    if (!pVM->tm.s.fTSCTiedToExecution)
     2362    {
     2363        rc = tmCpuTickResume(pVM, pVCpu);
     2364        if (RT_FAILURE(rc))
     2365            return rc;
     2366    }
     2367
     2368    /*
     2369     * The shared virtual clock (includes virtual sync which is tied to it).
     2370     */
     2371    tmLock(pVM);
     2372    rc = tmVirtualResumeLocked(pVM);
     2373    tmUnlock(pVM);
     2374
     2375    return rc;
     2376}
     2377
     2378
     2379/**
    23152380 * Sets the warp drive percent of the virtual time.
    23162381 *
    … …  
    23512416                    ("%RX32 is not between 2 and 20000 (inclusive).\n", u32Percent),
    23522417                    VERR_INVALID_PARAMETER);
    2353     tmLock(pVM); /* paranoia */
    23542418
    23552419/** @todo This isn't a feature specific to virtual time, move the variables to
    … …  
    23602424     * the warp drive settings.
    23612425     */
     2426    tmLock(pVM); /* paranoia */
    23622427    bool fPaused = !!pVM->tm.s.cVirtualTicking;
    2363     if (fPaused)
    2364     {
    2365         int rc = TMVirtualPause(pVM);
    2366         AssertRC(rc);
    2367         rc = TMCpuTickPause(pVCpu);
    2368         AssertRC(rc);
    2369     }
     2428    if (fPaused) /** @todo this isn't really working, but wtf. */
     2429        TMR3NotifySuspend(pVM, pVCpu);
    23702430
    23712431    pVM->tm.s.u32VirtualWarpDrivePercentage = u32Percent;
    … …  
    23752435
    23762436    if (fPaused)
    2377     {
    2378         int rc = TMVirtualResume(pVM);
    2379         AssertRC(rc);
    2380         rc = TMCpuTickResume(pVCpu);
    2381         AssertRC(rc);
    2382     }
    2383 
     2437        TMR3NotifyResume(pVM, pVCpu);
    23842438    tmUnlock(pVM);
    23852439    return VINF_SUCCESS;
    23862440}
    2387 
    2388 
    23892441
    23902442

  • trunk/src/VBox/VMM/TMInternal.h

    r19717 r19747  
    576576int                     tmCpuTickResume(PVM pVM, PVMCPU pVCpu);
    577577
     578int                     tmVirtualPauseLocked(PVM pVM);
     579int                     tmVirtualResumeLocked(PVM pVM);
    578580DECLEXPORT(void)        tmVirtualNanoTSBad(PRTTIMENANOTSDATA pData, uint64_t u64NanoTS, uint64_t u64DeltaPrev, uint64_t u64PrevNanoTS);
    579581DECLEXPORT(uint64_t)    tmVirtualNanoTSRediscover(PRTTIMENANOTSDATA pData);

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

    r19032 r19747  
    7878
    7979/**
    80  * Resumes the CPU timestamp counter ticking.
    81  *
    82  * @returns VBox status code.
    83  * @param   pVCpu       The VMCPU to operate on.
    84  * @todo replace this with TMNotifyResume
    85  */
    86 VMMDECL(int) TMCpuTickResume(PVMCPU pVCpu)
    87 {
    88     PVM pVM = pVCpu->CTX_SUFF(pVM);
    89 
    90     if (!pVM->tm.s.fTSCTiedToExecution)
    91         return tmCpuTickResume(pVM, pVCpu);
    92     /* ignored */
    93     return VINF_SUCCESS;
    94 }
    95 
    96 
    97 /**
    9880 * Pauses the CPU timestamp counter ticking.
    9981 *
    … …  
    10789    if (pVCpu->tm.s.fTSCTicking)
    10890    {
    109         pVCpu->tm.s.u64TSC = TMCpuTickGet(pVCpu);
     91        pVCpu->tm.s.u64TSC = TMCpuTickGetNoCheck(pVCpu);
    11092        pVCpu->tm.s.fTSCTicking = false;
    11193        return VINF_SUCCESS;
    … …  
    227209 * @param   pVCpu       The VMCPU to operate on.
    228210 */
    229 VMMDECL(uint64_t) TMCpuTickGet(PVMCPU pVCpu)
    230 {
    231     PVM      pVM = pVCpu->CTX_SUFF(pVM);
     211DECLINLINE(uint64_t) tmCpuTickGetInternal(PVMCPU pVCpu, bool fCheckTimers)
     212{
    232213    uint64_t u64;
    233214
    234215    if (RT_LIKELY(pVCpu->tm.s.fTSCTicking))
    235216    {
     217        PVM pVM = pVCpu->CTX_SUFF(pVM);
    236218        if (pVM->tm.s.fTSCVirtualized)
    237219        {
    … …  
    239221                u64 = ASMReadTSC();
    240222            else
    241                 u64 = tmCpuTickGetRawVirtual(pVM, true /* check for pending timers */);
     223                u64 = tmCpuTickGetRawVirtual(pVM, fCheckTimers);
    242224            u64 -= pVCpu->tm.s.u64TSCOffset;
    243225        }
    … …  
    252234
    253235/**
     236 * Read the current CPU timstamp counter.
     237 *
     238 * @returns Gets the CPU tsc.
     239 * @param   pVCpu       The VMCPU to operate on.
     240 */
     241VMMDECL(uint64_t) TMCpuTickGet(PVMCPU pVCpu)
     242{
     243    return tmCpuTickGetInternal(pVCpu, true /* fCheckTimers */);
     244}
     245
     246
     247/**
     248 * Read the current CPU timstamp counter, don't check for expired timers.
     249 *
     250 * @returns Gets the CPU tsc.
     251 * @param   pVCpu       The VMCPU to operate on.
     252 */
     253VMMDECL(uint64_t) TMCpuTickGetNoCheck(PVMCPU pVCpu)
     254{
     255    return tmCpuTickGetInternal(pVCpu, false /* fCheckTimers */);
     256}
     257
     258
     259/**
    254260 * Sets the current CPU timestamp counter.
    255261 *

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

    r19709 r19747  
    616616
    617617/**
    618  * Resumes the virtual clock.
    619  *
    620  * @returns VINF_SUCCESS on success.
    621  * @returns VINF_INTERNAL_ERROR and VBOX_STRICT assertion if called out of order.
    622  * @param   pVM     VM handle.
    623  */
    624 VMMDECL(int) TMVirtualResume(PVM pVM)
    625 {
    626     /*
    627      * Note! this is done only in specific cases (vcpu 0 init, termination, debug,
    628      * out of memory conditions; there is at least a race for fVirtualSyncTicking.
    629      */
    630     if (ASMAtomicIncU32(&pVM->tm.s.cVirtualTicking) == 1)
    631     {
    632         int rc = tmLock(pVM); /* paranoia */
    633 
     618 * Worker for TMR3PauseClocks.
     619 *
     620 * @returns VINF_SUCCESS or VERR_INTERNAL_ERROR (asserted).
     621 * @param   pVM     The VM handle.
     622 */
     623int tmVirtualPauseLocked(PVM pVM)
     624{
     625    uint32_t c = ASMAtomicDecU32(&pVM->tm.s.cVirtualTicking);
     626    AssertMsgReturn(c < pVM->cCPUs, ("%u vs %u\n", c, pVM->cCPUs), VERR_INTERNAL_ERROR);
     627    if (c == 0)
     628    {
     629        STAM_COUNTER_INC(&pVM->tm.s.StatVirtualPause);
     630        pVM->tm.s.u64Virtual = tmVirtualGetRaw(pVM);
     631        ASMAtomicWriteBool(&pVM->tm.s.fVirtualSyncTicking, false);
     632    }
     633    return VINF_SUCCESS;
     634}
     635
     636
     637/**
     638 * Worker for TMR3ResumeClocks.
     639 *
     640 * @returns VINF_SUCCESS or VERR_INTERNAL_ERROR (asserted).
     641 * @param   pVM     The VM handle.
     642 */
     643int tmVirtualResumeLocked(PVM pVM)
     644{
     645    uint32_t c = ASMAtomicIncU32(&pVM->tm.s.cVirtualTicking);
     646    AssertMsgReturn(c <= pVM->cCPUs, ("%u vs %u\n", c, pVM->cCPUs), VERR_INTERNAL_ERROR);
     647    if (c == 1)
     648    {
    634649        STAM_COUNTER_INC(&pVM->tm.s.StatVirtualResume);
    635650        pVM->tm.s.u64VirtualRawPrev         = 0;
    636651        pVM->tm.s.u64VirtualWarpDriveStart  = tmVirtualGetRawNanoTS(pVM);
    637652        pVM->tm.s.u64VirtualOffset          = pVM->tm.s.u64VirtualWarpDriveStart - pVM->tm.s.u64Virtual;
    638         pVM->tm.s.fVirtualSyncTicking       = true;
    639 
    640         if (RT_SUCCESS(rc))
    641             tmUnlock(pVM);
    642         return VINF_SUCCESS;
    643     }
    644     AssertMsgReturn(pVM->tm.s.cVirtualTicking <= pVM->cCPUs, ("%d vs %d\n", pVM->tm.s.cVirtualTicking, pVM->cCPUs), VERR_INTERNAL_ERROR);
    645     return VINF_SUCCESS;
    646 }
    647 
    648 
    649 /**
    650  * Pauses the virtual clock.
    651  *
    652  * @returns VINF_SUCCESS on success.
    653  * @returns VINF_INTERNAL_ERROR and VBOX_STRICT assertion if called out of order.
    654  * @param   pVM     VM handle.
    655  */
    656 VMMDECL(int) TMVirtualPause(PVM pVM)
    657 {
    658     /*
    659      * Note! this is done only in specific cases (vcpu 0 init, termination, debug,
    660      * out of memory conditions; there is at least a race for fVirtualSyncTicking.
    661      */
    662     if (ASMAtomicDecU32(&pVM->tm.s.cVirtualTicking) == 0)
    663     {
    664         int rc = tmLock(pVM); /* paranoia */
    665 
    666         STAM_COUNTER_INC(&pVM->tm.s.StatVirtualPause);
    667         pVM->tm.s.u64Virtual            = tmVirtualGetRaw(pVM);
    668         pVM->tm.s.fVirtualSyncTicking   = false;
    669 
    670         if (RT_SUCCESS(rc))
    671             tmUnlock(pVM);
    672         return VINF_SUCCESS;
    673     }
    674     AssertMsgReturn(pVM->tm.s.cVirtualTicking <= pVM->cCPUs, ("%d vs %d\n", pVM->tm.s.cVirtualTicking, pVM->cCPUs), VERR_INTERNAL_ERROR);
     653        ASMAtomicWriteBool(&pVM->tm.s.fVirtualSyncTicking, true);
     654    }
    675655    return VINF_SUCCESS;
    676656}

  • trunk/src/recompiler/VBoxREMWrapper.cpp

    r19660 r19747  
    11621162    { "STAMR3Deregister",                       (void *)(uintptr_t)&STAMR3Deregister,               &g_aArgsSTAMR3Deregister[0],                RT_ELEMENTS(g_aArgsSTAMR3Deregister),                  REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },
    11631163    { "TMCpuTickGet",                           (void *)(uintptr_t)&TMCpuTickGet,                   &g_aArgsVMCPU[0],                           RT_ELEMENTS(g_aArgsVMCPU),                             REMFNDESC_FLAGS_RET_INT,    sizeof(uint64_t),   NULL },
    1164     { "TMCpuTickPause",                         (void *)(uintptr_t)&TMCpuTickPause,                 &g_aArgsVMCPU[0],                           RT_ELEMENTS(g_aArgsVMCPU),                             REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },
    1165     { "TMCpuTickResume",                        (void *)(uintptr_t)&TMCpuTickResume,                &g_aArgsVMCPU[0],                           RT_ELEMENTS(g_aArgsVMCPU),                             REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },
     1164    { "TMR3NotifySuspend",                      (void *)(uintptr_t)&TMR3NotifySuspend,              &g_aArgsVMandVMCPU[0],                      RT_ELEMENTS(g_aArgsVMandVMCPU),                        REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },
     1165    { "TMR3NotifyResume",                       (void *)(uintptr_t)&TMR3NotifyResume,               &g_aArgsVMandVMCPU[0],                      RT_ELEMENTS(g_aArgsVMandVMCPU),                        REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },
    11661166    { "TMNotifyEndOfExecution",                 (void *)(uintptr_t)&TMNotifyEndOfExecution,         &g_aArgsVMCPU[0],                           RT_ELEMENTS(g_aArgsVMCPU),                             REMFNDESC_FLAGS_RET_VOID,   0,                  NULL },
    11671167    { "TMNotifyStartOfExecution",               (void *)(uintptr_t)&TMNotifyStartOfExecution,       &g_aArgsVMCPU[0],                           RT_ELEMENTS(g_aArgsVMCPU),                             REMFNDESC_FLAGS_RET_VOID,   0,                  NULL },
    11681168    { "TMTimerPoll",                            (void *)(uintptr_t)&TMTimerPoll,                    &g_aArgsVMandVMCPU[0],                      RT_ELEMENTS(g_aArgsVMandVMCPU),                        REMFNDESC_FLAGS_RET_INT,    sizeof(uint64_t),   NULL },
    11691169    { "TMR3TimerQueuesDo",                      (void *)(uintptr_t)&TMR3TimerQueuesDo,              &g_aArgsVM[0],                              RT_ELEMENTS(g_aArgsVM),                                REMFNDESC_FLAGS_RET_VOID,   0,                  NULL },
    1170     { "TMVirtualPause",                         (void *)(uintptr_t)&TMVirtualPause,                 &g_aArgsVM[0],                              RT_ELEMENTS(g_aArgsVM),                                REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },
    1171     { "TMVirtualResume",                        (void *)(uintptr_t)&TMVirtualResume,                &g_aArgsVM[0],                              RT_ELEMENTS(g_aArgsVM),                                REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },
    11721170    { "TRPMAssertTrap",                         (void *)(uintptr_t)&TRPMAssertTrap,                 &g_aArgsTRPMAssertTrap[0],                  RT_ELEMENTS(g_aArgsTRPMAssertTrap),                    REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },
    11731171    { "TRPMGetErrorCode",                       (void *)(uintptr_t)&TRPMGetErrorCode,               &g_aArgsVMCPU[0],                           RT_ELEMENTS(g_aArgsVMCPU),                             REMFNDESC_FLAGS_RET_INT,    sizeof(RTGCUINT),   NULL },

  • trunk/src/recompiler/VBoxRecompiler.c

    r19660 r19747  
    797797    if (rc == EXCP_DEBUG)
    798798    {
    799         TMCpuTickResume(pVCpu);
    800         TMCpuTickPause(pVCpu);
    801         TMVirtualResume(pVM);
    802         TMVirtualPause(pVM);
     799        TMR3NotifyResume(pVM, pVCpu);
     800        TMR3NotifySuspend(pVM, pVCpu);
    803801        rc = VINF_EM_DBG_STEPPED;
    804802    }
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