VirtualBox

Changeset 87767 in vbox


Ignore:
Timestamp:
Feb 16, 2021 4:41:18 PM (4 years ago)
Author:
vboxsync
Message:

VMM/TM,Devices/*: Changed the device and usb timer callbacks to take a timer handle rather than a pointer. Try a little harder using it. bugref:9943

Location:
trunk
Files:
24 edited

Legend:

Unmodified
Added
Removed

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

    r87766 r87767  
    171171 *
    172172 * @param   pDevIns         Device instance of the device which registered the timer.
    173  * @param   pTimer          The timer handle.
     173 * @param   hTimer          The timer handle.
    174174 * @param   pvUser          User argument specified upon timer creation.
    175175 */
    176 typedef DECLCALLBACKTYPE(void, FNTMTIMERDEV,(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser));
     176typedef DECLCALLBACKTYPE(void, FNTMTIMERDEV,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser));
    177177/** Pointer to a device timer callback function. */
    178178typedef FNTMTIMERDEV *PFNTMTIMERDEV;
    … …  
    183183 * @param   pUsbIns         The USB device instance the timer is associated
    184184 *                          with.
    185  * @param   pTimer          The timer handle.
     185 * @param   hTimer          The timer handle.
    186186 * @param   pvUser          User argument specified upon timer creation.
    187187 */
    188 typedef DECLCALLBACKTYPE(void, FNTMTIMERUSB,(PPDMUSBINS pUsbIns, PTMTIMER pTimer, void *pvUser));
     188typedef DECLCALLBACKTYPE(void, FNTMTIMERUSB,(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, void *pvUser));
    189189/** Pointer to a timer callback for a USB device. */
    190190typedef FNTMTIMERUSB *PFNTMTIMERUSB;
    … …  
    194194 *
    195195 * @param   pDrvIns         Device instance of the device which registered the timer.
    196  * @param   pTimer          The timer handle.
     196 * @param   hTimer          The timer handle.
    197197 * @param   pvUser          User argument specified upon timer creation.
    198198 */
    199 typedef DECLCALLBACKTYPE(void, FNTMTIMERDRV,(PPDMDRVINS pDrvIns, PTMTIMER pTimer, void *pvUser));
     199typedef DECLCALLBACKTYPE(void, FNTMTIMERDRV,(PPDMDRVINS pDrvIns, TMTIMERHANDLE hTimer, void *pvUser));
    200200/** Pointer to a driver timer callback function. */
    201201typedef FNTMTIMERDRV *PFNTMTIMERDRV;
    … …  
    205205 *
    206206 * @param   pSrvIns         Service instance of the device which registered the timer.
    207  * @param   pTimer          The timer handle.
    208  */
    209 typedef DECLCALLBACKTYPE(void, FNTMTIMERSRV,(PPDMSRVINS pSrvIns, PTMTIMER pTimer));
     207 * @param   hTimer          The timer handle.
     208 */
     209typedef DECLCALLBACKTYPE(void, FNTMTIMERSRV,(PPDMSRVINS pSrvIns, TMTIMERHANDLE hTimer));
    210210/** Pointer to a service timer callback function. */
    211211typedef FNTMTIMERSRV *PFNTMTIMERSRV;

  • trunk/src/VBox/Devices/Audio/DevHDA.cpp

    r87760 r87767  
    26432643 * @callback_method_impl{FNTMTIMERDEV, Main routine for the stream's timer.}
    26442644 */
    2645 static DECLCALLBACK(void) hdaR3Timer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     2645static DECLCALLBACK(void) hdaR3Timer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
    26462646{
    26472647    PHDASTATE       pThis         = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
    … …  
    26512651    PHDASTREAM      pStreamShared = &pThis->aStreams[idxStream];
    26522652    PHDASTREAMR3    pStreamR3     = &pThisCC->aStreams[idxStream];
    2653     TMTIMERHANDLE   hTimer        = pStreamShared->hTimer;
    2654     RT_NOREF(pTimer);
     2653    Assert(hTimer == pStreamShared->hTimer);
    26552654
    26562655    Assert(PDMDevHlpCritSectIsOwner(pDevIns, &pThis->CritSect));

  • trunk/src/VBox/Devices/Audio/DevIchAc97.cpp

    r87760 r87767  
    694694static DECLCALLBACK(void) ichac97R3Reset(PPDMDEVINS pDevIns);
    695695
    696 static DECLCALLBACK(void) ichac97R3Timer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser);
    697 
    698696static void               ichac97R3MixerRemoveDrvStreams(PAC97STATER3 pThisCC, PAUDMIXSINK pMixSink, PDMAUDIODIR enmDir,
    699697                                                         PDMAUDIODSTSRCUNION dstSrc);
    … …  
    27492747 * Timer callback which handles the audio data transfers on a periodic basis.}
    27502748 */
    2751 static DECLCALLBACK(void) ichac97R3Timer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     2749static DECLCALLBACK(void) ichac97R3Timer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
    27522750{
    27532751    PAC97STATE      pThis     = PDMDEVINS_2_DATA(pDevIns, PAC97STATE);
    … …  
    27562754    PAC97STREAM     pStream   = (PAC97STREAM)pvUser;
    27572755    PAC97STREAMR3   pStreamCC = &RT_SAFE_SUBSCRIPT8(pThisCC->aStreams, pStream->u8SD);
    2758     RT_NOREF(pTimer);
     2756    Assert(hTimer == pStream->hTimer); RT_NOREF(hTimer);
    27592757
    27602758    Assert(pStream - &pThis->aStreams[0] == pStream->u8SD);

  • trunk/src/VBox/Devices/Audio/DevSB16.cpp

    r87760 r87767  
    300300 * @callback_method_impl{PFNTMTIMERDEV}
    301301 */
    302 static DECLCALLBACK(void) sb16TimerIRQ(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     302static DECLCALLBACK(void) sb16TimerIRQ(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
    303303{
    304304    PSB16STATE pThis = PDMDEVINS_2_DATA(pDevIns, PSB16STATE);
    305     RT_NOREF(pvUser, pTimer);
     305    RT_NOREF(pvUser, hTimer);
    306306
    307307    pThis->can_write = 1;
    … …  
    16891689 * @callback_method_impl{FNTMTIMERDEV}
    16901690 */
    1691 static DECLCALLBACK(void) sb16TimerIO(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     1691static DECLCALLBACK(void) sb16TimerIO(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
    16921692{
    16931693    PSB16STATE pThis = PDMDEVINS_2_DATA(pDevIns, PSB16STATE);
    1694     RT_NOREF(pTimer, pvUser);
    1695 
    1696     uint64_t cTicksNow     = PDMDevHlpTimerGet(pDevIns, pThis->hTimerIO);
     1694    Assert(hTimer == pThis->hTimerIO); RT_NOREF(pvUser);
     1695
     1696    uint64_t cTicksNow     = PDMDevHlpTimerGet(pDevIns, hTimer);
    16971697    bool     fIsPlaying    = false; /* Whether one or more streams are still playing. */
    16981698    bool     fDoTransfer   = false;
    … …  
    17491749        uint64_t cTicks = pThis->cTicksTimerIOInterval;
    17501750        /** @todo adjust cTicks down by now much cbOutMin represents. */
    1751         PDMDevHlpTimerSet(pDevIns, pThis->hTimerIO, cTicksNow + cTicks);
     1751        PDMDevHlpTimerSet(pDevIns, hTimer, cTicksNow + cTicks);
    17521752    }
    17531753}

  • trunk/src/VBox/Devices/Graphics/DevVGA.cpp

    r87760 r87767  
    54455445 * @callback_method_impl{FNTMTIMERDEV, VGA Refresh Timer}
    54465446 */
    5447 static DECLCALLBACK(void) vgaR3TimerRefresh(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     5447static DECLCALLBACK(void) vgaR3TimerRefresh(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
    54485448{
    54495449    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
    54505450    PVGASTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
    5451     RT_NOREF(pvUser, pTimer);
     5451    RT_NOREF(pvUser);
    54525452
    54535453    if (pThis->fScanLineCfg & VBVASCANLINECFG_ENABLE_VSYNC_IRQ)
    … …  
    54585458
    54595459    if (pThis->cMilliesRefreshInterval)
    5460         PDMDevHlpTimerSetMillies(pDevIns, pThis->hRefreshTimer, pThis->cMilliesRefreshInterval);
     5460        PDMDevHlpTimerSetMillies(pDevIns, hTimer, pThis->cMilliesRefreshInterval);
    54615461
    54625462# ifdef VBOX_WITH_VIDEOHWACCEL

  • trunk/src/VBox/Devices/Input/DevPS2K.cpp

    r87760 r87767  
    957957 * done because it would needlessly slow things down.
    958958 */
    959 static DECLCALLBACK(void) ps2kR3ThrottleTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
    960 {
    961     RT_NOREF(pDevIns, pTimer);
     959static DECLCALLBACK(void) ps2kR3ThrottleTimer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
     960{
    962961    PPS2K       pThis = (PS2K *)pvUser;
    963962    unsigned    uHaveData;
     963    RT_NOREF(hTimer);
    964964
    965965    /* Grab the lock to avoid races with event delivery or EMTs. */
    … …  
    985985 * @note    Note that only the last key held down repeats (if typematic).
    986986 */
    987 static DECLCALLBACK(void) ps2kR3TypematicTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
    988 {
    989     RT_NOREF(pDevIns, pTimer);
     987static DECLCALLBACK(void) ps2kR3TypematicTimer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
     988{
    990989    PPS2K pThis = (PS2K *)pvUser;
     990    Assert(hTimer == pThis->hKbdTypematicTimer);
    991991    LogFlowFunc(("Typematic state=%d, key %08X\n", pThis->enmTypematicState, pThis->u32TypematicKey));
    992992
    … …  
    10021002        {
    10031003            ps2kR3ProcessKeyEvent(pDevIns, pThis, pThis->u32TypematicKey, true /* Key down */ );
    1004             PDMDevHlpTimerSetMillies(pDevIns, pThis->hKbdTypematicTimer, pThis->uTypematicRepeat);
     1004            PDMDevHlpTimerSetMillies(pDevIns, hTimer, pThis->uTypematicRepeat);
    10051005        }
    10061006    }
    … …  
    10131013 * to delay sending the result to the host for at least a tiny little while.
    10141014 */
    1015 static DECLCALLBACK(void) ps2kR3DelayTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
    1016 {
    1017     RT_NOREF(pDevIns, pTimer);
     1015static DECLCALLBACK(void) ps2kR3DelayTimer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
     1016{
    10181017    PPS2K pThis = (PS2K *)pvUser;
     1018    RT_NOREF(hTimer);
    10191019
    10201020    LogFlowFunc(("Delay timer: cmd %02X\n", pThis->u8CurrCmd));

  • trunk/src/VBox/Devices/Input/DevPS2M.cpp

    r87760 r87767  
    724724 * Event rate throttling timer to emulate the auxiliary device sampling rate.}
    725725 */
    726 static DECLCALLBACK(void) ps2mR3ThrottleTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
    727 {
    728     RT_NOREF(pDevIns, pTimer);
     726static DECLCALLBACK(void) ps2mR3ThrottleTimer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
     727{
    729728    PPS2M       pThis = (PS2M *)pvUser;
    730729    uint32_t    uHaveEvents;
     730    Assert(hTimer == pThis->hThrottleTimer);
    731731
    732732    /* Grab the lock to avoid races with PutEvent(). */
    … …  
    743743        ps2mReportAccumulatedEvents(pThis, &pThis->evtQ.Hdr, RT_ELEMENTS(pThis->evtQ.abQueue), pThis->evtQ.abQueue, true);
    744744        KBCUpdateInterrupts(pDevIns);
    745         PDMDevHlpTimerSetMillies(pDevIns, pThis->hThrottleTimer, pThis->uThrottleDelay);
     745        PDMDevHlpTimerSetMillies(pDevIns, hTimer, pThis->uThrottleDelay);
    746746    }
    747747    else
    … …  
    758758 * while.
    759759 */
    760 static DECLCALLBACK(void) ps2mR3DelayTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     760static DECLCALLBACK(void) ps2mR3DelayTimer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
    761761{
    762762    PPS2M   pThis   = &PDMDEVINS_2_DATA(pDevIns, PKBDSTATE)->Aux;
    763763    PPS2MR3 pThisCC = &PDMDEVINS_2_DATA_CC(pDevIns, PKBDSTATER3)->Aux;
    764     RT_NOREF(pvUser, pTimer);
     764    RT_NOREF(pvUser, hTimer);
    765765
    766766    LogFlowFunc(("Delay timer: cmd %02X\n", pThis->u8CurrCmd));

  • trunk/src/VBox/Devices/Network/DevE1000.cpp

    r87760 r87767  
    21912191            uint64_t tsNow = PDMDevHlpTimerGet(pDevIns, pThis->hIntTimer);
    21922192            if (!!ITR && tsNow - pThis->u64AckedAt < ITR * 256
    2193                      && pThis->fItrEnabled && (pThis->fItrRxEnabled || !(ICR & ICR_RXT0)))
     2193                && pThis->fItrEnabled && (pThis->fItrRxEnabled || !(ICR & ICR_RXT0)))
    21942194            {
    21952195                E1K_INC_ISTAT_CNT(pThis->uStatIntEarly);
    … …  
    35093509# ifdef E1K_TX_DELAY
    35103510/**
    3511  * Transmit Delay Timer handler.
    3512  *
    3513  * @remarks We only get here when the timer expires.
    3514  *
    3515  * @param   pDevIns     Pointer to device instance structure.
    3516  * @param   pTimer      Pointer to the timer.
    3517  * @param   pvUser      NULL.
    3518  * @thread  EMT
    3519  */
    3520 static DECLCALLBACK(void) e1kR3TxDelayTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     3511 * @callback_method_impl{FNTMTIMERDEV, Transmit Delay Timer handler.}
     3512 */
     3513static DECLCALLBACK(void) e1kR3TxDelayTimer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
    35213514{
    35223515    PE1KSTATE pThis = (PE1KSTATE)pvUser;
    35233516    Assert(PDMCritSectIsOwner(&pThis->csTx));
     3517    RT_NOREF(hTimer);
    35243518
    35253519    E1K_INC_ISTAT_CNT(pThis->uStatTxDelayExp);
    … …  
    35373531
    35383532/**
    3539  * Transmit Interrupt Delay Timer handler.
    3540  *
    3541  * @remarks We only get here when the timer expires.
    3542  *
    3543  * @param   pDevIns     Pointer to device instance structure.
    3544  * @param   pTimer      Pointer to the timer.
    3545  * @param   pvUser      NULL.
    3546  * @thread  EMT
    3547  */
    3548 static DECLCALLBACK(void) e1kR3TxIntDelayTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
    3549 {
    3550     RT_NOREF(pDevIns);
    3551     RT_NOREF(pTimer);
     3533 * @callback_method_impl{FNTMTIMERDEV, Transmit Interrupt Delay Timer handler.}
     3534 */
     3535static DECLCALLBACK(void) e1kR3TxIntDelayTimer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
     3536{
    35523537    PE1KSTATE pThis = (PE1KSTATE)pvUser;
     3538    Assert(hTimer == pThis->hTIDTimer); RT_NOREF(hTimer);
    35533539
    35543540    E1K_INC_ISTAT_CNT(pThis->uStatTID);
    … …  
    35613547
    35623548/**
    3563  * Transmit Absolute Delay Timer handler.
    3564  *
    3565  * @remarks We only get here when the timer expires.
    3566  *
    3567  * @param   pDevIns     Pointer to device instance structure.
    3568  * @param   pTimer      Pointer to the timer.
    3569  * @param   pvUser      NULL.
    3570  * @thread  EMT
    3571  */
    3572 static DECLCALLBACK(void) e1kR3TxAbsDelayTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
    3573 {
    3574     RT_NOREF(pDevIns);
    3575     RT_NOREF(pTimer);
     3549 * @callback_method_impl{FNTMTIMERDEV, Transmit Absolute Delay Timer handler.}
     3550 */
     3551static DECLCALLBACK(void) e1kR3TxAbsDelayTimer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
     3552{
    35763553    PE1KSTATE pThis = (PE1KSTATE)pvUser;
     3554    Assert(hTimer == pThis->hTADTimer); RT_NOREF(hTimer);
    35773555
    35783556    E1K_INC_ISTAT_CNT(pThis->uStatTAD);
    … …  
    35863564
    35873565/**
    3588  * Receive Interrupt Delay Timer handler.
    3589  *
    3590  * @remarks We only get here when the timer expires.
    3591  *
    3592  * @param   pDevIns     Pointer to device instance structure.
    3593  * @param   pTimer      Pointer to the timer.
    3594  * @param   pvUser      NULL.
    3595  * @thread  EMT
    3596  */
    3597 static DECLCALLBACK(void) e1kR3RxIntDelayTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     3566 * @callback_method_impl{FNTMTIMERDEV, Receive Interrupt Delay Timer handler.}
     3567 */
     3568static DECLCALLBACK(void) e1kR3RxIntDelayTimer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
    35983569{
    35993570    PE1KSTATE pThis = (PE1KSTATE)pvUser;
     3571    Assert(hTimer == pThis->hRIDTimer); RT_NOREF(hTimer);
    36003572
    36013573    E1K_INC_ISTAT_CNT(pThis->uStatRID);
    … …  
    36063578
    36073579/**
    3608  * Receive Absolute Delay Timer handler.
    3609  *
    3610  * @remarks We only get here when the timer expires.
    3611  *
    3612  * @param   pDevIns     Pointer to device instance structure.
    3613  * @param   pTimer      Pointer to the timer.
    3614  * @param   pvUser      NULL.
    3615  * @thread  EMT
    3616  */
    3617 static DECLCALLBACK(void) e1kR3RxAbsDelayTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     3580 * @callback_method_impl{FNTMTIMERDEV, Receive Absolute Delay Timer handler.}
     3581 */
     3582static DECLCALLBACK(void) e1kR3RxAbsDelayTimer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
    36183583{
    36193584    PE1KSTATE pThis = (PE1KSTATE)pvUser;
     3585    Assert(hTimer == pThis->hRADTimer); RT_NOREF(hTimer);
    36203586
    36213587    E1K_INC_ISTAT_CNT(pThis->uStatRAD);
    … …  
    36283594
    36293595/**
    3630  * Late Interrupt Timer handler.
    3631  *
    3632  * @param   pDevIns     Pointer to device instance structure.
    3633  * @param   pTimer      Pointer to the timer.
    3634  * @param   pvUser      NULL.
    3635  * @thread  EMT
    3636  */
    3637 static DECLCALLBACK(void) e1kR3LateIntTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
    3638 {
    3639     RT_NOREF(pDevIns, pTimer);
     3596 * @callback_method_impl{FNTMTIMERDEV, Late Interrupt Timer handler.}
     3597 */
     3598static DECLCALLBACK(void) e1kR3LateIntTimer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
     3599{
    36403600    PE1KSTATE pThis = (PE1KSTATE)pvUser;
     3601    Assert(hTimer == pThis->hIntTimer); RT_NOREF(hTimer);
     3602    RT_NOREF(hTimer);
    36413603
    36423604    STAM_PROFILE_ADV_START(&pThis->StatLateIntTimer, a);
    … …  
    36523614
    36533615/**
    3654  * Link Up Timer handler.
    3655  *
    3656  * @param   pDevIns     Pointer to device instance structure.
    3657  * @param   pTimer      Pointer to the timer.
    3658  * @param   pvUser      NULL.
    3659  * @thread  EMT
    3660  */
    3661 static DECLCALLBACK(void) e1kR3LinkUpTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
    3662 {
    3663     RT_NOREF(pTimer);
     3616 * @callback_method_impl{FNTMTIMERDEV, Link Up Timer handler.}
     3617 */
     3618static DECLCALLBACK(void) e1kR3LinkUpTimer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
     3619{
    36643620    PE1KSTATE   pThis   = (PE1KSTATE)pvUser;
    36653621    PE1KSTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PE1KSTATECC);
     3622    Assert(hTimer == pThis->hLUTimer); RT_NOREF(hTimer);
    36663623
    36673624    /*

  • trunk/src/VBox/Devices/Network/DevPCNet.cpp

    r87760 r87767  
    40094009 * @callback_method_impl{FNTMTIMERDEV, Poll timer}
    40104010 */
    4011 static DECLCALLBACK(void) pcnetR3Timer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     4011static DECLCALLBACK(void) pcnetR3Timer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
    40124012{
    40134013    PPCNETSTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
    40144014    PPCNETSTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PPCNETSTATECC);
    40154015    Assert(PDMDevHlpCritSectIsOwner(pDevIns, &pThis->CritSect));
    4016     RT_NOREF(pvUser, pTimer);
     4016    Assert(hTimer == pThis->hTimerPoll); RT_NOREF(pvUser, hTimer);
    40174017
    40184018    STAM_PROFILE_ADV_START(&pThis->StatTimer, a);
    … …  
    40264026 *      Software interrupt timer callback function.}
    40274027 */
    4028 static DECLCALLBACK(void) pcnetR3TimerSoftInt(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     4028static DECLCALLBACK(void) pcnetR3TimerSoftInt(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
    40294029{
    40304030    PPCNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
    40314031    Assert(PDMDevHlpCritSectIsOwner(pDevIns, &pThis->CritSect));
    4032     RT_NOREF(pvUser, pTimer);
     4032    Assert(hTimer == pThis->hTimerSoftInt); RT_NOREF(pvUser, hTimer);
    40334033
    40344034    pThis->aCSR[7] |= 0x0800; /* STINT */
    … …  
    40454045 * should be considered lost.
    40464046 */
    4047 static DECLCALLBACK(void) pcnetR3TimerRestore(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     4047static DECLCALLBACK(void) pcnetR3TimerRestore(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
    40484048{
    40494049    PPCNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
    4050     RT_NOREF(pTimer, pvUser);
     4050    Assert(hTimer == pThis->hTimerRestore); RT_NOREF(pvUser);
    40514051
    40524052    int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
    … …  
    40564056    if (pThis->cLinkDownReported <= PCNET_MAX_LINKDOWN_REPORTED)
    40574057    {
    4058         rc = PDMDevHlpTimerSetMillies(pDevIns, pThis->hTimerRestore, 1500);
     4058        rc = PDMDevHlpTimerSetMillies(pDevIns, hTimer, 1500);
    40594059        AssertRC(rc);
    40604060    }

  • trunk/src/VBox/Devices/Network/DevVirtioNet.cpp

    r87760 r87767  
    625625 * @callback_method_impl{FNTMTIMERDEV, Link Up Timer handler.}
    626626 */
    627 static DECLCALLBACK(void) vnetR3LinkUpTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     627static DECLCALLBACK(void) vnetR3LinkUpTimer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
    628628{
    629629    PVNETSTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
    630630    PVNETSTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVNETSTATECC);
    631     RT_NOREF(pTimer, pvUser);
     631    RT_NOREF(hTimer, pvUser);
    632632
    633633    int rc = vnetR3CsEnter(pDevIns, pThis, VERR_SEM_BUSY);
    … …  
    15091509 * @callback_method_impl{FNTMTIMERDEV, Transmit Delay Timer handler.}
    15101510 */
    1511 static DECLCALLBACK(void) vnetR3TxTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     1511static DECLCALLBACK(void) vnetR3TxTimer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
    15121512{
    15131513    PVNETSTATE      pThis   = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
    15141514    PVNETSTATECC    pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVNETSTATECC);
    1515     RT_NOREF(pTimer, pvUser);
     1515    RT_NOREF(hTimer, pvUser);
    15161516
    15171517    uint32_t u32MicroDiff = (uint32_t)((RTTimeNanoTS() - pThis->u64NanoTS) / 1000);
    … …  
    15271527//    Log3(("%s vnetR3TxTimer: Expired\n", INSTANCE(pThis)));
    15281528    vnetR3TransmitPendingPackets(pDevIns, pThis, pThisCC, pThisCC->pTxQueue, false /*fOnWorkerThread*/);
    1529     if (RT_FAILURE(vnetR3CsEnter(pDevIns, pThis, VERR_SEM_BUSY)))
    1530     {
    1531         LogRel(("vnetR3TxTimer: Failed to enter critical section!/n"));
    1532         return;
    1533     }
     1529    int rc = vnetR3CsEnter(pDevIns, pThis, VERR_SEM_BUSY)
     1530    AssertLogRelRCReturnVoid(rc);
    15341531    vringSetNotification(pDevIns, &pThisCC->pTxQueue->VRing, true);
    15351532    vnetR3CsLeave(pDevIns, pThis);

  • trunk/src/VBox/Devices/Network/DevVirtioNet_1_0.cpp

    r87760 r87767  
    24462446 * @callback_method_impl{FNTMTIMERDEV, Link Up Timer handler.}
    24472447 */
    2448 static DECLCALLBACK(void) virtioNetR3LinkUpTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     2448static DECLCALLBACK(void) virtioNetR3LinkUpTimer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
    24492449{
    24502450    PVIRTIONET   pThis   = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
    24512451    PVIRTIONETCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIONETCC);
    2452     RT_NOREF(pTimer, pvUser);
     2452    RT_NOREF(hTimer, pvUser);
    24532453
    24542454    SET_LINK_UP(pThis);

  • trunk/src/VBox/Devices/PC/DevACPI.cpp

    r87760 r87767  
    11721172    Assert(PDMDevHlpTimerIsLockOwner(pDevIns, pThis->hPmTimer));
    11731173
    1174     pThis->uPmTimerVal = ASMMultU64ByU32DivByU32(u64Elapsed, PM_TMR_FREQ,
    1175                                                  PDMDevHlpTimerGetFreq(pDevIns, pThis->hPmTimer))
     1174    pThis->uPmTimerVal = ASMMultU64ByU32DivByU32(u64Elapsed, PM_TMR_FREQ, PDMDevHlpTimerGetFreq(pDevIns, pThis->hPmTimer))
    11761175                       & TMR_VAL_MASK;
    11771176
    1178     if ( (pThis->uPmTimerVal & TMR_VAL_MSB) != msb)
     1177    if ((pThis->uPmTimerVal & TMR_VAL_MSB) != msb)
    11791178        acpiUpdatePm1a(pDevIns, pThis, pThis->pm1a_sts | TMR_STS, pThis->pm1a_en);
    11801179}
    … …  
    11851184 * @callback_method_impl{FNTMTIMERDEV, PM Timer callback}
    11861185 */
    1187 static DECLCALLBACK(void) acpiR3PmTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     1186static DECLCALLBACK(void) acpiR3PmTimer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
    11881187{
    11891188    PACPISTATE pThis = PDMDEVINS_2_DATA(pDevIns, PACPISTATE);
    1190     Assert(PDMDevHlpTimerIsLockOwner(pDevIns, pThis->hPmTimer));
    1191     RT_NOREF(pTimer, pvUser);
     1189    Assert(pThis->hPmTimer == hTimer);
     1190    Assert(PDMDevHlpTimerIsLockOwner(pDevIns, hTimer));
     1191    RT_NOREF(pvUser);
    11921192
    11931193    DEVACPI_LOCK_R3(pDevIns, pThis);
    … …  
    11951195         pThis->pm1a_sts, (pThis->pm1a_sts & TMR_STS) != 0,
    11961196         pThis->pm1a_en, (pThis->pm1a_en & TMR_EN) != 0));
    1197     uint64_t u64Now = PDMDevHlpTimerGet(pDevIns, pThis->hPmTimer);
    1198     acpiPmTimerUpdate(pDevIns, pThis, u64Now);
     1197    uint64_t tsNow = PDMDevHlpTimerGet(pDevIns, hTimer);
     1198    acpiPmTimerUpdate(pDevIns, pThis, tsNow);
    11991199    DEVACPI_UNLOCK(pDevIns, pThis);
    12001200
    1201     acpiR3PmTimerReset(pDevIns, pThis, u64Now);
     1201    acpiR3PmTimerReset(pDevIns, pThis, tsNow);
    12021202}
    12031203

  • trunk/src/VBox/Devices/PC/DevHPET.cpp

    r87760 r87767  
    11041104}
    11051105
    1106 /**
    1107  * Device timer callback function.
    1108  *
    1109  * @param   pDevIns         Device instance of the device which registered the timer.
    1110  * @param   pTimer          The timer handle.
    1111  * @param   pvUser          Pointer to the HPET timer state.
    1112  */
    1113 static DECLCALLBACK(void) hpetR3Timer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     1106
     1107/**
     1108 * @callback_method_impl{FNTMTIMERDEV, Device timer callback function.}
     1109 */
     1110static DECLCALLBACK(void) hpetR3Timer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
    11141111{
    11151112    PHPET       pThis      = PDMDEVINS_2_DATA(pDevIns, PHPET);
    … …  
    11181115    uint64_t    u64CurTick = hpetGetTicks(pDevIns, pThis);
    11191116    uint64_t    u64Diff;
    1120     RT_NOREF(pTimer);
     1117    Assert(hTimer == pHpetTimer->hTimer);
    11211118
    11221119    if (pHpetTimer->u64Config & HPET_TN_PERIODIC)
    … …  
    11331130                Log4(("HPET: periodic: next in %llu\n", hpetTicksToNs(pThis, u64Diff)));
    11341131                STAM_REL_COUNTER_INC(&pHpetTimer->StatSetTimer);
    1135                 PDMDevHlpTimerSetNano(pDevIns, pHpetTimer->hTimer, hpetTicksToNs(pThis, u64Diff));
     1132                PDMDevHlpTimerSetNano(pDevIns, hTimer, hpetTicksToNs(pThis, u64Diff));
    11361133            }
    11371134            else
    … …  
    11471144        {
    11481145            u64Diff = hpetComputeDiff(pHpetTimer, u64CurTick);
    1149             PDMDevHlpTimerSetNano(pDevIns, pHpetTimer->hTimer, hpetTicksToNs(pThis, u64Diff));
     1146            PDMDevHlpTimerSetNano(pDevIns, hTimer, hpetTicksToNs(pThis, u64Diff));
    11501147            pHpetTimer->u8Wrap = 0;
    11511148        }

  • trunk/src/VBox/Devices/PC/DevPit-i8254.cpp

    r87760 r87767  
    11141114 * @callback_method_impl{FNTMTIMERDEV, User argument points to the PIT channel state.}
    11151115 */
    1116 static DECLCALLBACK(void) pitR3Timer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     1116static DECLCALLBACK(void) pitR3Timer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
    11171117{
    11181118    PPITSTATE   pThis = PDMDEVINS_2_DATA(pDevIns, PPITSTATE);
    11191119    PPITCHANNEL pChan = (PPITCHANNEL)pvUser;
    1120     RT_NOREF(pTimer);
    11211120    STAM_PROFILE_ADV_START(&pThis->StatPITHandler, a);
     1121    Assert(hTimer == pChan->hTimer);
    11221122
    11231123    Log(("pitR3Timer\n"));
    11241124    Assert(PDMDevHlpCritSectIsOwner(pDevIns, &pThis->CritSect));
    1125     Assert(PDMDevHlpTimerIsLockOwner(pDevIns, pChan->hTimer));
    1126 
    1127     pitR3IrqTimerUpdate(pDevIns, pThis, pChan, pChan->next_transition_time, PDMDevHlpTimerGet(pDevIns, pChan->hTimer), true);
     1125    Assert(PDMDevHlpTimerIsLockOwner(pDevIns, hTimer));
     1126
     1127    pitR3IrqTimerUpdate(pDevIns, pThis, pChan, pChan->next_transition_time, PDMDevHlpTimerGet(pDevIns, hTimer), true);
    11281128
    11291129    STAM_PROFILE_ADV_STOP(&pThis->StatPITHandler, a);

  • trunk/src/VBox/Devices/PC/DevRTC.cpp

    r87760 r87767  
    584584 * @callback_method_impl{FNTMTIMERDEV, periodic}
    585585 */
    586 static DECLCALLBACK(void) rtcTimerPeriodic(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
    587 {
    588     RT_NOREF2(pTimer, pvUser);
     586static DECLCALLBACK(void) rtcTimerPeriodic(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
     587{
    589588    PRTCSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PRTCSTATE);
    590     Assert(PDMDevHlpTimerIsLockOwner(pDevIns, pThis->hPeriodicTimer));
     589    Assert(hTimer == pThis->hPeriodicTimer);
     590    Assert(PDMDevHlpTimerIsLockOwner(pDevIns, hTimer));
    591591    Assert(PDMDevHlpCritSectIsOwner(pDevIns, pDevIns->CTX_SUFF(pCritSectRo)));
     592    RT_NOREF2(hTimer, pvUser);
    592593
    593594    rtc_timer_update(pDevIns, pThis, pThis->next_periodic_time);
    … …  
    666667 * @callback_method_impl{FNTMTIMERDEV, Second timer.}
    667668 */
    668 static DECLCALLBACK(void) rtcR3TimerSecond(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     669static DECLCALLBACK(void) rtcR3TimerSecond(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
    669670{
    670671    PRTCSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PRTCSTATE);
    … …  
    672673    Assert(PDMDevHlpTimerIsLockOwner(pDevIns, pThis->hPeriodicTimer));
    673674    Assert(PDMDevHlpCritSectIsOwner(pDevIns, pDevIns->CTX_SUFF(pCritSectRo)));
    674     RT_NOREF(pvUser, pTimer);
     675    RT_NOREF(pvUser, hTimer);
    675676
    676677    /* if the oscillator is not in normal operation, we do not update */
    … …  
    728729 * @callback_method_impl{FNTMTIMERDEV, Second2 timer.}
    729730 */
    730 static DECLCALLBACK(void) rtcR3TimerSecond2(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     731static DECLCALLBACK(void) rtcR3TimerSecond2(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
    731732{
    732733    PRTCSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PRTCSTATE);
    … …  
    734735    Assert(PDMDevHlpTimerIsLockOwner(pDevIns, pThis->hPeriodicTimer));
    735736    Assert(PDMDevHlpCritSectIsOwner(pDevIns, pDevIns->CTX_SUFF(pCritSectRo)));
    736     RT_NOREF2(pTimer, pvUser);
     737    RT_NOREF2(hTimer, pvUser);
    737738
    738739    if (!(pThis->cmos_data[RTC_REG_B] & REG_B_SET))

  • trunk/src/VBox/Devices/Serial/UartCore.cpp

    r87760 r87767  
    14991499 * @callback_method_impl{FNTMTIMERDEV, Fifo timer function.}
    15001500 */
    1501 static DECLCALLBACK(void) uartR3RcvFifoTimeoutTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
    1502 {
    1503     LogFlowFunc(("pDevIns=%#p pTimer=%#p pvUser=%#p\n", pDevIns, pTimer, pvUser));
     1501static DECLCALLBACK(void) uartR3RcvFifoTimeoutTimer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
     1502{
     1503    LogFlowFunc(("pDevIns=%#p hTimer=%#p pvUser=%#p\n", pDevIns, hTimer, pvUser));
    15041504    PUARTCORER3 pThisCC = (PUARTCORECC)pvUser;
    15051505    PUARTCORE   pThis   = pThisCC->pShared;
    1506     RT_NOREF(pTimer);
     1506    RT_NOREF(hTimer);
    15071507
    15081508    if (pThis->FifoRecv.cbUsed < pThis->FifoRecv.cbItl)
    … …  
    15141514
    15151515/**
    1516  * @callback_method_impl{FNTMTIMERDEV, TX timer function when there is no driver connected for draining the THR/FIFO.}
    1517  */
    1518 static DECLCALLBACK(void) uartR3TxUnconnectedTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
    1519 {
    1520     LogFlowFunc(("pDevIns=%#p pTimer=%#p pvUser=%#p\n", pDevIns, pTimer, pvUser));
     1516 * @callback_method_impl{FNTMTIMERDEV,
     1517 *      TX timer function when there is no driver connected for
     1518 *      draining the THR/FIFO.}
     1519 */
     1520static DECLCALLBACK(void) uartR3TxUnconnectedTimer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
     1521{
     1522    LogFlowFunc(("pDevIns=%#p hTimer=%#p pvUser=%#p\n", pDevIns, hTimer, pvUser));
    15211523    PUARTCORER3 pThisCC = (PUARTCORECC)pvUser;
    15221524    PUARTCORE   pThis   = pThisCC->pShared;
    1523     RT_NOREF(pTimer);
    1524 
    1525     VBOXSTRICTRC rc1 = PDMDevHlpTimerLockClock2(pDevIns, pThis->hTimerTxUnconnected, &pThis->CritSect,
    1526                                                 VINF_SUCCESS /* must get it */);
     1525    Assert(hTimer == pThis->hTimerTxUnconnected);
     1526
     1527    VBOXSTRICTRC rc1 = PDMDevHlpTimerLockClock2(pDevIns, hTimer, &pThis->CritSect, VINF_SUCCESS /* must get it */);
    15271528    AssertRCReturnVoid(VBOXSTRICTRC_VAL(rc1));
    15281529
    … …  
    15661567
    15671568    if (cbRead == 1)
    1568         PDMDevHlpTimerSetRelative(pDevIns, pThis->hTimerTxUnconnected, pThis->cSymbolXferTicks, NULL);
     1569        PDMDevHlpTimerSetRelative(pDevIns, hTimer, pThis->cSymbolXferTicks, NULL);
    15691570    else
    15701571    {
    … …  
    15731574    }
    15741575
    1575     PDMDevHlpTimerUnlockClock2(pDevIns, pThis->hTimerTxUnconnected, &pThis->CritSect);
     1576    PDMDevHlpTimerUnlockClock2(pDevIns, hTimer, &pThis->CritSect);
    15761577}
    15771578

  • trunk/src/VBox/Devices/Storage/DevAHCI.cpp

    r87760 r87767  
    963963 * @callback_method_impl{FNTMTIMERDEV, Assert irq when an CCC timeout occurs.}
    964964 */
    965 static DECLCALLBACK(void) ahciCccTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
    966 {
    967     RT_NOREF(pDevIns, pTimer);
     965static DECLCALLBACK(void) ahciCccTimer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
     966{
     967    RT_NOREF(pDevIns, hTimer);
    968968    PAHCI pThis = (PAHCI)pvUser;
    969969

  • trunk/src/VBox/Devices/Storage/DevFdc.cpp

    r87760 r87767  
    22142214 * @callback_method_impl{FNTMTIMERDEV}
    22152215 */
    2216 static DECLCALLBACK(void) fdcTimerCallback(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     2216static DECLCALLBACK(void) fdcTimerCallback(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
    22172217{
    22182218    fdctrl_t *fdctrl = PDMDEVINS_2_DATA(pDevIns, fdctrl_t *);
    22192219    fdrive_t *cur_drv = get_cur_drv(fdctrl);
    2220     RT_NOREF(pTimer, pvUser);
     2220    RT_NOREF(hTimer, pvUser);
    22212221
    22222222    /* Pretend we are spinning.
    … …  
    22982298 * @callback_method_impl{FNTMTIMERDEV}
    22992299 */
    2300 static DECLCALLBACK(void) fdcTransferDelayTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     2300static DECLCALLBACK(void) fdcTransferDelayTimer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
    23012301{
    23022302    fdctrl_t *fdctrl = PDMDEVINS_2_DATA(pDevIns, fdctrl_t *);
    2303     RT_NOREF(pvUser, pTimer);
     2303    RT_NOREF(pvUser, hTimer);
    23042304    fdctrl_stop_transfer_now(fdctrl, fdctrl->st0, fdctrl->st1, fdctrl->st2);
    23052305}
    … …  
    23092309 * @callback_method_impl{FNTMTIMERDEV}
    23102310 */
    2311 static DECLCALLBACK(void) fdcIrqDelayTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     2311static DECLCALLBACK(void) fdcIrqDelayTimer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
    23122312{
    23132313    fdctrl_t *fdctrl = PDMDEVINS_2_DATA(pDevIns, fdctrl_t *);
    2314     RT_NOREF(pvUser, pTimer);
     2314    RT_NOREF(pvUser, hTimer);
    23152315    fdctrl_raise_irq_now(fdctrl, fdctrl->st0);
    23162316}

  • trunk/src/VBox/Devices/USB/DevOHCI.cpp

    r87760 r87767  
    904904static int                  ohciR3InDoneQueueFind(POHCICC pThisCC, uint32_t GCPhysTD);
    905905# endif
    906 static DECLCALLBACK(void)   ohciR3LoadReattachDevices(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser);
    907906#endif /* IN_RING3 */
    908907RT_C_DECLS_END
    … …  
    58045803
    58055804/**
     5805 * @callback_method_impl{FNTMTIMERDEV,
     5806 *      Reattaches devices after a saved state load.}
     5807 */
     5808static DECLCALLBACK(void) ohciR3LoadReattachDevices(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
     5809{
     5810    POHCICC      pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, POHCICC);
     5811    POHCILOAD    pLoad   = pThisCC->pLoad;
     5812    LogFlow(("ohciR3LoadReattachDevices:\n"));
     5813    Assert(hTimer == pLoad->hTimer); RT_NOREF(pvUser);
     5814
     5815    /*
     5816     * Reattach devices.
     5817     */
     5818    for (unsigned i = 0; i < pLoad->cDevs; i++)
     5819        VUSBIRhAttachDevice(pThisCC->RootHub.pIRhConn, pLoad->apDevs[i]);
     5820
     5821    /*
     5822     * Cleanup.
     5823     */
     5824    PDMDevHlpTimerDestroy(pDevIns, hTimer);
     5825    pLoad->hTimer = NIL_TMTIMERHANDLE;
     5826    PDMDevHlpMMHeapFree(pDevIns, pLoad);
     5827    pThisCC->pLoad = NULL;
     5828}
     5829
     5830
     5831/**
    58065832 * Done state load operation.
    58075833 *
    … …  
    58305856
    58315857    return VINF_SUCCESS;
    5832 }
    5833 
    5834 
    5835 /**
    5836  * @callback_method_impl{FNTMTIMERDEV,
    5837  *      Reattaches devices after a saved state load.}
    5838  */
    5839 static DECLCALLBACK(void) ohciR3LoadReattachDevices(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
    5840 {
    5841     POHCICC      pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, POHCICC);
    5842     POHCILOAD    pLoad   = pThisCC->pLoad;
    5843     LogFlow(("ohciR3LoadReattachDevices:\n"));
    5844     RT_NOREF(pTimer, pvUser);
    5845 
    5846     /*
    5847      * Reattach devices.
    5848      */
    5849     for (unsigned i = 0; i < pLoad->cDevs; i++)
    5850         VUSBIRhAttachDevice(pThisCC->RootHub.pIRhConn, pLoad->apDevs[i]);
    5851 
    5852     /*
    5853      * Cleanup.
    5854      */
    5855     PDMDevHlpTimerDestroy(pDevIns, pLoad->hTimer);
    5856     pLoad->hTimer = NIL_TMTIMERHANDLE;
    5857     PDMDevHlpMMHeapFree(pDevIns, pLoad);
    5858     pThisCC->pLoad = NULL;
    58595858}
    58605859

  • trunk/src/VBox/Devices/USB/VUSBDevice.cpp

    r87762 r87767  
    13721372
    13731373/**
    1374  * Timer callback for doing reset completion.
    1375  *
    1376  * @param   pUsbIns     The USB device instance.
    1377  * @param   pTimer      The timer instance.
    1378  * @param   pvUser      The VUSB device data.
    1379  * @thread EMT
    1380  */
    1381 static DECLCALLBACK(void) vusbDevResetDoneTimer(PPDMUSBINS pUsbIns, PTMTIMER pTimer, void *pvUser)
    1382 {
    1383     RT_NOREF(pUsbIns, pTimer);
     1374 * @callback_method_impl{FNTMTIMERUSB,
     1375 *          Timer callback for doing reset completion.}
     1376 */
     1377static DECLCALLBACK(void) vusbDevResetDoneTimer(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, void *pvUser)
     1378{
    13841379    PVUSBDEV        pDev  = (PVUSBDEV)pvUser;
    13851380    PVUSBRESETARGS  pArgs = (PVUSBRESETARGS)pDev->pvArgs;
    13861381    Assert(pDev->pUsbIns == pUsbIns);
     1382    RT_NOREF(pUsbIns, hTimer);
    13871383
    13881384    AssertPtr(pArgs);

  • trunk/src/VBox/Devices/VMMDev/VMMDev.cpp

    r87766 r87767  
    511511 * @remarks Does not take the VMMDev critsect.
    512512 */
    513 static DECLCALLBACK(void) vmmDevHeartbeatFlatlinedTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
    514 {
    515     RT_NOREF(pDevIns, pTimer);
     513static DECLCALLBACK(void) vmmDevHeartbeatFlatlinedTimer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
     514{
    516515    PVMMDEV pThis = (PVMMDEV)pvUser;
     516    Assert(hTimer == pThis->hFlatlinedTimer);
    517517    if (pThis->fHeartbeatActive)
    518518    {
    519         uint64_t cNsElapsed = PDMDevHlpTimerGetNano(pDevIns, pThis->hFlatlinedTimer) - pThis->nsLastHeartbeatTS;
     519        uint64_t cNsElapsed = PDMDevHlpTimerGetNano(pDevIns, hTimer) - pThis->nsLastHeartbeatTS;
    520520        if (   !pThis->fFlatlined
    521521            && cNsElapsed >= pThis->cNsHeartbeatInterval)

  • trunk/src/VBox/ExtPacks/BusMouseSample/DevBusMouse.cpp

    r87760 r87767  
    237237 * @callback_method_impl{FNTMTIMERDEV}
    238238 */
    239 static DECLCALLBACK(void) bmsR3TimerCallback(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     239static DECLCALLBACK(void) bmsR3TimerCallback(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
    240240{
    241241    PBMSSTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PBMSSTATE);
    242242    PBMSSTATER3 pThisCC = PDMDEVINS_2_DATA(pDevIns, PBMSSTATER3);
    243243    uint8_t     irq_bit;
    244     RT_NOREF(pvUser, pTimer);
     244    RT_NOREF(pvUser, hTimer);
     245    Assert(hTimer == pThis->hMouseTimer);
    245246
    246247    /* Toggle the IRQ line if interrupts are enabled. */
    … …  
    283284
    284285    /* Re-arm the timer. */
    285     PDMDevHlpTimerSetMillies(pDevIns, pThis->hMouseTimer, pThis->cTimerPeriodMs);
     286    PDMDevHlpTimerSetMillies(pDevIns, hTimer, pThis->cTimerPeriodMs);
    286287}
    287288

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

    r87760 r87767  
    11121112 *          thread.
    11131113 */
    1114 static DECLCALLBACK(void) apicR3TimerCallback(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     1114static DECLCALLBACK(void) apicR3TimerCallback(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
    11151115{
    11161116    PVMCPU      pVCpu    = (PVMCPU)pvUser;
    … …  
    11191119    Assert(pVCpu);
    11201120    LogFlow(("APIC%u: apicR3TimerCallback\n", pVCpu->idCpu));
    1121     RT_NOREF(pDevIns, pTimer, pApicCpu);
     1121    RT_NOREF(pDevIns, hTimer, pApicCpu);
    11221122
    11231123    PXAPICPAGE     pXApicPage = VMCPU_TO_XAPICPAGE(pVCpu);

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

    r87766 r87767  
    23032303            switch (pTimer->enmType)
    23042304            {
    2305                 case TMTIMERTYPE_DEV:       pTimer->u.Dev.pfnTimer(pTimer->u.Dev.pDevIns, pTimer, pTimer->pvUser); break;
    2306                 case TMTIMERTYPE_USB:       pTimer->u.Usb.pfnTimer(pTimer->u.Usb.pUsbIns, pTimer, pTimer->pvUser); break;
    2307                 case TMTIMERTYPE_DRV:       pTimer->u.Drv.pfnTimer(pTimer->u.Drv.pDrvIns, pTimer, pTimer->pvUser); break;
     2305                case TMTIMERTYPE_DEV:       pTimer->u.Dev.pfnTimer(pTimer->u.Dev.pDevIns, pTimer->hSelf, pTimer->pvUser); break;
     2306                case TMTIMERTYPE_USB:       pTimer->u.Usb.pfnTimer(pTimer->u.Usb.pUsbIns, pTimer->hSelf, pTimer->pvUser); break;
     2307                case TMTIMERTYPE_DRV:       pTimer->u.Drv.pfnTimer(pTimer->u.Drv.pDrvIns, pTimer->hSelf, pTimer->pvUser); break;
    23082308                case TMTIMERTYPE_INTERNAL:  pTimer->u.Internal.pfnTimer(pVM, pTimer->hSelf, pTimer->pvUser); break;
    23092309                default:
    … …  
    24872487        switch (pTimer->enmType)
    24882488        {
    2489             case TMTIMERTYPE_DEV:       pTimer->u.Dev.pfnTimer(pTimer->u.Dev.pDevIns, pTimer, pTimer->pvUser); break;
    2490             case TMTIMERTYPE_USB:       pTimer->u.Usb.pfnTimer(pTimer->u.Usb.pUsbIns, pTimer, pTimer->pvUser); break;
    2491             case TMTIMERTYPE_DRV:       pTimer->u.Drv.pfnTimer(pTimer->u.Drv.pDrvIns, pTimer, pTimer->pvUser); break;
     2489            case TMTIMERTYPE_DEV:       pTimer->u.Dev.pfnTimer(pTimer->u.Dev.pDevIns, pTimer->hSelf, pTimer->pvUser); break;
     2490            case TMTIMERTYPE_USB:       pTimer->u.Usb.pfnTimer(pTimer->u.Usb.pUsbIns, pTimer->hSelf, pTimer->pvUser); break;
     2491            case TMTIMERTYPE_DRV:       pTimer->u.Drv.pfnTimer(pTimer->u.Drv.pDrvIns, pTimer->hSelf, pTimer->pvUser); break;
    24922492            case TMTIMERTYPE_INTERNAL:  pTimer->u.Internal.pfnTimer(pVM, pTimer->hSelf, pTimer->pvUser); break;
    24932493            default:
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