VirtualBox

Changeset 87760 in vbox


Ignore:
Timestamp:
Feb 15, 2021 10:45:27 PM (4 years ago)
Author:
vboxsync
Message:

VMM/TM,VMM/DevHlp: Require flag on timers that are to be used in ring-0 (and while refactoring a counte flag to check that all timers have been checked). Removed obsolete timer device helpers. bugref:9943

Location:
trunk
Files:
31 edited

Legend:

Unmodified
Added
Removed

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

    r87691 r87760  
    23512351
    23522352/** Current PDMDEVHLPR3 version number. */
    2353 #define PDM_DEVHLPR3_VERSION                    PDM_VERSION_MAKE_PP(0xffe7, 45, 0)
     2353#define PDM_DEVHLPR3_VERSION                    PDM_VERSION_MAKE_PP(0xffe7, 46, 0)
    23542354
    23552355/**
    … …  
    28002800
    28012801    /**
    2802      * Creates a timer.
    2803      *
    2804      * @returns VBox status.
    2805      * @param   pDevIns             The device instance.
    2806      * @param   enmClock            The clock to use on this timer.
    2807      * @param   pfnCallback         Callback function.
    2808      * @param   pvUser              User argument for the callback.
    2809      * @param   fFlags              Flags, see TMTIMER_FLAGS_*.
    2810      * @param   pszDesc             Pointer to description string which must stay around
    2811      *                              until the timer is fully destroyed (i.e. a bit after TMTimerDestroy()).
    2812      * @param   ppTimer             Where to store the timer on success.
    2813      * @remarks Caller enters the device critical section prior to invoking the
    2814      *          callback.
    2815      */
    2816     DECLR3CALLBACKMEMBER(int, pfnTMTimerCreate,(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback,
    2817                                                 void *pvUser, uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer));
    2818 
    2819     /**
    28202802     * Creates a timer w/ a cross context handle.
    28212803     *
    … …  
    28342816    DECLR3CALLBACKMEMBER(int, pfnTimerCreate,(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback,
    28352817                                              void *pvUser, uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer));
    2836 
    2837     /**
    2838      * Translates a timer handle to a pointer.
    2839      *
    2840      * @returns The time address.
    2841      * @param   pDevIns             The device instance.
    2842      * @param   hTimer              The timer handle.
    2843      */
    2844     DECLR3CALLBACKMEMBER(PTMTIMERR3, pfnTimerToPtr,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer));
    28452818
    28462819    /** @name Timer handle method wrappers
    … …  
    52255198    DECLR0CALLBACKMEMBER(VMCPUID, pfnGetCurrentCpuId,(PPDMDEVINS pDevIns));
    52265199
    5227     /**
    5228      * Translates a timer handle to a pointer.
    5229      *
    5230      * @returns The time address.
    5231      * @param   pDevIns             The device instance.
    5232      * @param   hTimer              The timer handle.
    5233      */
    5234     DECLR0CALLBACKMEMBER(PTMTIMERR0, pfnTimerToPtr,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer));
    5235 
    52365200    /** @name Timer handle method wrappers
    52375201     * @{ */
    … …  
    54895453
    54905454/** Current PDMDEVHLP version number. */
    5491 #define PDM_DEVHLPR0_VERSION                    PDM_VERSION_MAKE(0xffe5, 18, 0)
     5455#define PDM_DEVHLPR0_VERSION                    PDM_VERSION_MAKE(0xffe5, 19, 0)
    54925456
    54935457
    … …  
    63206284
    63216285/**
    6322  * @copydoc PDMDEVHLPR3::pfnTMTimerCreate
    6323  */
    6324 DECLINLINE(int) PDMDevHlpTMTimerCreate(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback, void *pvUser,
    6325                                        uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer)
    6326 {
    6327     return pDevIns->pHlpR3->pfnTMTimerCreate(pDevIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, ppTimer);
    6328 }
    6329 
    6330 /**
    63316286 * @copydoc PDMDEVHLPR3::pfnTimerCreate
    63326287 */
    … …  
    63386293
    63396294#endif /* IN_RING3 */
    6340 
    6341 /**
    6342  * @copydoc PDMDEVHLPR3::pfnTimerToPtr
    6343  */
    6344 DECLINLINE(PTMTIMER) PDMDevHlpTimerToPtr(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
    6345 {
    6346     return pDevIns->CTX_SUFF(pHlp)->pfnTimerToPtr(pDevIns, hTimer);
    6347 }
    63486295
    63496296/**

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

    r85121 r87760  
    15091509 * @copydoc PDMDRVHLPR3::pfnTMTimerCreate
    15101510 */
    1511 DECLINLINE(int) PDMDrvHlpTMTimerCreate(PPDMDRVINS pDrvIns, TMCLOCK enmClock, PFNTMTIMERDRV pfnCallback, void *pvUser, uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer)
     1511DECLINLINE(int) PDMDrvHlpTMTimerCreate(PPDMDRVINS pDrvIns, TMCLOCK enmClock, PFNTMTIMERDRV pfnCallback, void *pvUser,
     1512                                       uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer)
    15121513{
    15131514    return pDrvIns->pHlpR3->pfnTMTimerCreate(pDrvIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, ppTimer);

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

    r87751 r87760  
    8282 *  TMR3TimerSetCritSect(). */
    8383#define TMTIMER_FLAGS_NO_CRIT_SECT      RT_BIT_32(0)
     84/** Used in ring-0.  Must set this or TMTIMER_FLAGS_NO_RING0. */
     85#define TMTIMER_FLAGS_RING0             RT_BIT_32(1)
     86/** Not used in ring-0 (for refactoring and doc purposes). */
     87#define TMTIMER_FLAGS_NO_RING0          RT_BIT_32(31)
    8488/** @} */
    8589

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

    r87758 r87760  
    49224922     *        instead of the LPIB registers.
    49234923     */
     4924    /** @todo r=bird: The need to use virtual sync is perhaps because TM
     4925     *        doesn't schedule regular TMCLOCK_VIRTUAL timers as accurately as it
     4926     *        should (VT-x preemption timer, etc).  Hope to address that before
     4927     *        long. @bugref{9943}. */
    49244928    static const char * const s_apszNames[] =
    4925     {
    4926         "HDA SD0", "HDA SD1", "HDA SD2", "HDA SD3",
    4927         "HDA SD4", "HDA SD5", "HDA SD6", "HDA SD7",
    4928     };
     4929    { "HDA SD0", "HDA SD1", "HDA SD2", "HDA SD3", "HDA SD4", "HDA SD5", "HDA SD6", "HDA SD7", };
    49294930    AssertCompile(RT_ELEMENTS(s_apszNames) == HDA_MAX_STREAMS);
    49304931    for (size_t i = 0; i < HDA_MAX_STREAMS; i++)
    49314932    {
    49324933        rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, hdaR3Timer, (void *)(uintptr_t)i,
    4933                                   TMTIMER_FLAGS_NO_CRIT_SECT, s_apszNames[i], &pThis->aStreams[i].hTimer);
     4934                                  TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_NO_RING0,
     4935                                  s_apszNames[i], &pThis->aStreams[i].hTimer);
    49344936        AssertRCReturn(rc, rc);
    49354937

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

    r86741 r87760  
    651651/**
    652652 * Acquires the TM lock and AC'97 lock, returns on failure.
     653 *
     654 * @todo r=bird: Isn't this overkill for ring-0, only ring-3 access the timer
     655 *               from what I can tell (ichac97R3StreamTransferCalcNext,
     656 *               ichac97R3TimerSet, timer callback and state load).
    653657 */
    654658#define DEVAC97_LOCK_BOTH_RETURN(a_pDevIns, a_pThis, a_pStream, a_rcBusy) \
    … …  
    43304334     *        instead of the LPIB registers.
    43314335     */
     4336    /** @todo r=bird: The need to use virtual sync is perhaps because TM
     4337     *        doesn't schedule regular TMCLOCK_VIRTUAL timers as accurately as it
     4338     *        should (VT-x preemption timer, etc).  Hope to address that before
     4339     *        long. @bugref{9943}. */
    43324340    static const char * const s_apszNames[] = { "AC97 PI", "AC97 PO", "AC97 MC" };
    43334341    AssertCompile(RT_ELEMENTS(s_apszNames) == AC97_MAX_STREAMS);
    … …  
    43354343    {
    43364344        rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, ichac97R3Timer, &pThis->aStreams[i],
    4337                                   TMTIMER_FLAGS_NO_CRIT_SECT, s_apszNames[i], &pThis->aStreams[i].hTimer);
     4345                                  TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0, s_apszNames[i], &pThis->aStreams[i].hTimer);
    43384346        AssertRCReturn(rc, rc);
    43394347

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

    r82968 r87760  
    24302430     */
    24312431    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, sb16TimerIRQ, pThis,
    2432                               TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "SB16 IRQ timer", &pThis->hTimerIRQ);
     2432                              TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_NO_RING0, "SB16 IRQ timer", &pThis->hTimerIRQ);
    24332433    AssertRCReturn(rc, rc);
    24342434    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, sb16TimerIO, pThis,
    2435                               TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "SB16 IO timer", &pThis->hTimerIO);
     2435                              TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_NO_RING0, "SB16 IO timer", &pThis->hTimerIO);
    24362436    AssertRCReturn(rc, rc);
    24372437    pThis->cTicksTimerIOInterval = PDMDevHlpTimerGetFreq(pDevIns, pThis->hTimerIO) / uTimerHz;

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

    r87118 r87760  
    54455445 * @callback_method_impl{FNTMTIMERDEV, VGA Refresh Timer}
    54465446 */
    5447 static DECLCALLBACK(void) vgaTimerRefresh(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     5447static DECLCALLBACK(void) vgaR3TimerRefresh(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
    54485448{
    54495449    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
    … …  
    67836783     * Create the refresh timer.
    67846784     */
    6785     rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_REAL, vgaTimerRefresh, NULL, TMTIMER_FLAGS_NO_CRIT_SECT,
    6786                               "VGA Refresh Timer", &pThis->hRefreshTimer);
     6785    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_REAL, vgaR3TimerRefresh, NULL,
     6786                              TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_NO_RING0, "VGA Refresh Timer", &pThis->hRefreshTimer);
    67876787    AssertRCReturn(rc, rc);
    67886788

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

    r87378 r87760  
    14011401     */
    14021402    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, ps2kR3ThrottleTimer, pThis,
    1403                               TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "PS2K Throttle Timer", &pThis->hThrottleTimer);
     1403                              TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_RING0,
     1404                              "PS2K Throttle Timer", &pThis->hThrottleTimer);
    14041405    AssertRCReturn(rc, rc);
    14051406
    … …  
    14081409     */
    14091410    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, ps2kR3TypematicTimer, pThis,
    1410                               TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "PS2K Typematic Timer", &pThis->hKbdTypematicTimer);
     1411                              TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_RING0,
     1412                              "PS2K Typematic Timer", &pThis->hKbdTypematicTimer);
    14111413    AssertRCReturn(rc, rc);
    14121414
    … …  
    14151417     */
    14161418    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, ps2kR3DelayTimer, pThis,
    1417                               TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "PS2K Delay Timer", &pThis->hKbdDelayTimer);
     1419                              TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_RING0, "PS2K Delay Timer", &pThis->hKbdDelayTimer);
    14181420    AssertRCReturn(rc, rc);
    14191421

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

    r83444 r87760  
    10851085     */
    10861086    int rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_REAL, ps2mR3ThrottleTimer, pThis,
    1087                                   TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "PS2M Throttle Timer", &pThis->hThrottleTimer);
     1087                                  TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_NO_RING0,
     1088                                  "PS2M Throttle Timer", &pThis->hThrottleTimer);
    10881089    AssertRCReturn(rc, rc);
    10891090
    … …  
    10921093     */
    10931094    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, ps2mR3DelayTimer, pThis,
    1094                               TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "PS2M Delay Timer", &pThis->hDelayTimer);
     1095                              TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_RING0, "PS2M Delay Timer", &pThis->hDelayTimer);
    10951096    AssertRCReturn(rc, rc);
    10961097

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

    r87111 r87760  
    80748074#ifdef E1K_TX_DELAY
    80758075    /* Create Transmit Delay Timer */
    8076     rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, e1kR3TxDelayTimer, pThis, TMTIMER_FLAGS_NO_CRIT_SECT,
     8076    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, e1kR3TxDelayTimer, pThis,
     8077                              TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0,
    80778078                              "E1000 Transmit Delay Timer", &pThis->hTXDTimer);
    80788079    AssertRCReturn(rc, rc);
    … …  
    80858086    {
    80868087        /* Create Transmit Interrupt Delay Timer */
    8087         rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, e1kR3TxIntDelayTimer, pThis, TMTIMER_FLAGS_NO_CRIT_SECT,
     8088        rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, e1kR3TxIntDelayTimer, pThis,
     8089                                  TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0,
    80888090                                  "E1000 Transmit Interrupt Delay Timer", &pThis->hTIDTimer);
    80898091        AssertRCReturn(rc, rc);
    … …  
    80918093# ifndef E1K_NO_TAD
    80928094        /* Create Transmit Absolute Delay Timer */
    8093         rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, e1kR3TxAbsDelayTimer, pThis, TMTIMER_FLAGS_NO_CRIT_SECT,
     8095        rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, e1kR3TxAbsDelayTimer, pThis,
     8096                                  TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0,
    80948097                                  "E1000 Transmit Absolute Delay Timer", &pThis->hTADTimer);
    80958098        AssertRCReturn(rc, rc);
    … …  
    81008103#ifdef E1K_USE_RX_TIMERS
    81018104    /* Create Receive Interrupt Delay Timer */
    8102     rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, e1kR3RxIntDelayTimer, pThis, TMTIMER_FLAGS_NO_CRIT_SECT,
     8105    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, e1kR3RxIntDelayTimer, pThis,
     8106                              TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0,
    81038107                              "E1000 Receive Interrupt Delay Timer", &pThis->hRIDTimer);
    81048108    AssertRCReturn(rc, rc);
    81058109
    81068110    /* Create Receive Absolute Delay Timer */
    8107     rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, e1kR3RxAbsDelayTimer, pThis, TMTIMER_FLAGS_NO_CRIT_SECT,
     8111    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, e1kR3RxAbsDelayTimer, pThis,
     8112                              TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0,
    81088113                              "E1000 Receive Absolute Delay Timer", &pThis->hRADTimer);
    81098114    AssertRCReturn(rc, rc);
    … …  
    81118116
    81128117    /* Create Late Interrupt Timer */
    8113     rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, e1kR3LateIntTimer, pThis, TMTIMER_FLAGS_NO_CRIT_SECT,
     8118    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, e1kR3LateIntTimer, pThis,
     8119                              TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0,
    81148120                              "E1000 Late Interrupt Timer", &pThis->hIntTimer);
    81158121    AssertRCReturn(rc, rc);
    81168122
    81178123    /* Create Link Up Timer */
    8118     rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, e1kR3LinkUpTimer, pThis, TMTIMER_FLAGS_NO_CRIT_SECT,
     8124    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, e1kR3LinkUpTimer, pThis,
     8125                              TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0,
    81198126                              "E1000 Link Up Timer", &pThis->hLUTimer);
    81208127    AssertRCReturn(rc, rc);

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

    r87285 r87760  
    53285328
    53295329#else
    5330     rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, pcnetR3Timer, NULL, TMTIMER_FLAGS_NO_CRIT_SECT,
     5330    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, pcnetR3Timer, NULL, TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0,
    53315331                              "PCnet Poll Timer", &pThis->hTimerPoll);
    53325332    AssertRCReturn(rc, rc);
    … …  
    53375337    {
    53385338        /* Software Interrupt timer */
    5339         rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, pcnetR3TimerSoftInt, NULL, TMTIMER_FLAGS_NO_CRIT_SECT,
    5340                                   "PCnet SoftInt Timer", &pThis->hTimerSoftInt);
     5339        rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, pcnetR3TimerSoftInt, NULL,
     5340                                  TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0, "PCnet SoftInt Timer", &pThis->hTimerSoftInt);
    53415341        AssertRCReturn(rc, rc);
    53425342        rc = PDMDevHlpTimerSetCritSect(pDevIns, pThis->hTimerSoftInt, &pThis->CritSect);
    53435343        AssertRCReturn(rc, rc);
    53445344    }
    5345     rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, pcnetR3TimerRestore, pThis, TMTIMER_FLAGS_NO_CRIT_SECT,
    5346                               "PCnet Restore Timer", &pThis->hTimerRestore);
     5345    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, pcnetR3TimerRestore, pThis,
     5346                              TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_NO_RING0, "PCnet Restore Timer", &pThis->hTimerRestore);
    53475347    AssertRCReturn(rc, rc);
    53485348

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

    r85109 r87760  
    22482248
    22492249    /* Create Link Up Timer */
    2250     rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, vnetR3LinkUpTimer, NULL, TMTIMER_FLAGS_NO_CRIT_SECT,
     2250    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, vnetR3LinkUpTimer, NULL,
     2251                              TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_NO_RING0,
    22512252                              "VirtioNet Link Up Timer", &pThisCC->hLinkUpTimer);
    22522253    AssertRCReturn(rc, rc);
    … …  
    22542255# ifdef VNET_TX_DELAY
    22552256    /* Create Transmit Delay Timer */
    2256     rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, vnetR3TxTimer, pThis, TMTIMER_FLAGS_NO_CRIT_SECT,
     2257    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, vnetR3TxTimer, pThis,
     2258                              TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_NO_RING0,
    22572259                              "VirtioNet TX Delay Timer", &pThis->hTxTimer);
    22582260    AssertRCReturn(rc, rc);

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

    r86407 r87760  
    30363036
    30373037    /* Create Link Up Timer */
    3038     rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, virtioNetR3LinkUpTimer, NULL, TMTIMER_FLAGS_NO_CRIT_SECT,
     3038    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, virtioNetR3LinkUpTimer, NULL,
     3039                              TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_NO_RING0,
    30393040                              "VirtioNet Link Up Timer", &pThisCC->hLinkUpTimer);
    30403041

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

    r86408 r87760  
    43884388     */
    43894389    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, acpiR3PmTimer, NULL /*pvUser*/,
    4390                               TMTIMER_FLAGS_NO_CRIT_SECT, "ACPI PM Timer", &pThis->hPmTimer);
     4390                              TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0, "ACPI PM Timer", &pThis->hPmTimer);
    43914391    AssertRCReturn(rc, rc);
    43924392

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

    r86591 r87760  
    14651465
    14661466        rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, hpetR3Timer, pHpetTimer,
    1467                                   TMTIMER_FLAGS_NO_CRIT_SECT, s_apszTimerNames[i], &pThis->aTimers[i].hTimer);
     1467                                  TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0,
     1468                                  s_apszTimerNames[i], &pThis->aTimers[i].hTimer);
    14681469        AssertRCReturn(rc, rc);
    14691470        /** @todo r=bird: This is TOTALLY MESSED UP!  Why do we need

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

    r84334 r87760  
    14241424     */
    14251425    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, pitR3Timer, &pThis->channels[0],
    1426                               TMTIMER_FLAGS_NO_CRIT_SECT, "i8254 Programmable Interval Timer", &pThis->channels[0].hTimer);
     1426                              TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0,
     1427                              "i8254 Programmable Interval Timer", &pThis->channels[0].hTimer);
    14271428    AssertRCReturn(rc, rc);
    14281429    rc = PDMDevHlpTimerSetCritSect(pDevIns, pThis->channels[0].hTimer, &pThis->CritSect);

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

    r82968 r87760  
    588588    RT_NOREF2(pTimer, pvUser);
    589589    PRTCSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PRTCSTATE);
    590     Assert(pTimer == PDMDevHlpTimerToPtr(pDevIns, pThis->hPeriodicTimer));
    591590    Assert(PDMDevHlpTimerIsLockOwner(pDevIns, pThis->hPeriodicTimer));
    592591    Assert(PDMDevHlpCritSectIsOwner(pDevIns, pDevIns->CTX_SUFF(pCritSectRo)));
    … …  
    667666 * @callback_method_impl{FNTMTIMERDEV, Second timer.}
    668667 */
    669 static DECLCALLBACK(void) rtcTimerSecond(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     668static DECLCALLBACK(void) rtcR3TimerSecond(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
    670669{
    671670    PRTCSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PRTCSTATE);
    … …  
    673672    Assert(PDMDevHlpTimerIsLockOwner(pDevIns, pThis->hPeriodicTimer));
    674673    Assert(PDMDevHlpCritSectIsOwner(pDevIns, pDevIns->CTX_SUFF(pCritSectRo)));
    675     Assert(pTimer == PDMDevHlpTimerToPtr(pDevIns, pThis->hSecondTimer));
    676674    RT_NOREF(pvUser, pTimer);
    677675
    … …  
    700698
    701699
    702 /* Used by rtc_set_date and rtcTimerSecond2. */
     700/* Used by rtc_set_date and rtcR3TimerSecond2. */
    703701static void rtc_copy_date(PRTCSTATE pThis)
    704702{
    … …  
    730728 * @callback_method_impl{FNTMTIMERDEV, Second2 timer.}
    731729 */
    732 static DECLCALLBACK(void) rtcTimerSecond2(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     730static DECLCALLBACK(void) rtcR3TimerSecond2(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
    733731{
    734732    PRTCSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PRTCSTATE);
    … …  
    736734    Assert(PDMDevHlpTimerIsLockOwner(pDevIns, pThis->hPeriodicTimer));
    737735    Assert(PDMDevHlpCritSectIsOwner(pDevIns, pDevIns->CTX_SUFF(pCritSectRo)));
    738     Assert(pTimer == PDMDevHlpTimerToPtr(pDevIns, pThis->hSecondTimer2));
    739736    RT_NOREF2(pTimer, pvUser);
    740737
    … …  
    11591156    /* Periodic timer. */
    11601157    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, rtcTimerPeriodic, pThis,
    1161                               TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "MC146818 RTC (CMOS) - Periodic", &pThis->hPeriodicTimer);
     1158                              TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_RING0,
     1159                              "MC146818 RTC (CMOS) - Periodic", &pThis->hPeriodicTimer);
    11621160    AssertRCReturn(rc, rc);
    11631161
    11641162    /* Seconds timer. */
    1165     rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, rtcTimerSecond, pThis,
    1166                               TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "MC146818 RTC (CMOS) - Second", &pThis->hSecondTimer);
     1163    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, rtcR3TimerSecond, pThis,
     1164                              TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_RING0,
     1165                              "MC146818 RTC (CMOS) - Second", &pThis->hSecondTimer);
    11671166    AssertRCReturn(rc, rc);
    11681167
    11691168    /* The second2 timer, this is always active. */
    1170     rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, rtcTimerSecond2, pThis,
    1171                               TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "MC146818 RTC (CMOS) - Second2", &pThis->hSecondTimer2);
     1169    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, rtcR3TimerSecond2, pThis,
     1170                              TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_NO_RING0,
     1171                              "MC146818 RTC (CMOS) - Second2", &pThis->hSecondTimer2);
    11721172    AssertRCReturn(rc, rc);
    11731173

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

    r87726 r87760  
    20702070     */
    20712071    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, uartR3RcvFifoTimeoutTimer, pThisCC,
    2072                               TMTIMER_FLAGS_NO_CRIT_SECT, "UART Rcv FIFO Timer",
     2072                              TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0, "UART Rcv FIFO Timer",
    20732073                              &pThis->hTimerRcvFifoTimeout);
    20742074    AssertRCReturn(rc, rc);
    … …  
    20812081     */
    20822082    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, uartR3TxUnconnectedTimer, pThisCC,
    2083                               TMTIMER_FLAGS_NO_CRIT_SECT, "UART TX uncon. Timer",
     2083                              TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_NO_RING0, "UART TX uncon. Timer",
    20842084                              &pThis->hTimerTxUnconnected);
    20852085    AssertRCReturn(rc, rc);

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

    r87047 r87760  
    59375937     */
    59385938    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, ahciCccTimer, pThis,
    5939                               TMTIMER_FLAGS_NO_CRIT_SECT, "AHCI CCC Timer", &pThis->hHbaCccTimer);
     5939                              TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0, "AHCI CCC Timer", &pThis->hHbaCccTimer);
    59405940    AssertRCReturn(rc, rc);
    59415941

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

    r87121 r87760  
    29242924     */
    29252925    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, fdcTimerCallback, pThis,
    2926                               TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "FDC Timer", &pThis->hResultTimer);
     2926                              TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_NO_RING0,
     2927                              "FDC Timer", &pThis->hResultTimer);
    29272928    AssertRCReturn(rc, rc);
    29282929
    … …  
    29312932     */
    29322933    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, fdcTransferDelayTimer, pThis,
    2933                               TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "FDC Transfer Delay Timer", &pThis->hXferDelayTimer);
     2934                              TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_NO_RING0,
     2935                              "FDC Transfer Delay Timer", &pThis->hXferDelayTimer);
    29342936    AssertRCReturn(rc, rc);
    29352937
    … …  
    29382940     */
    29392941    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, fdcIrqDelayTimer, pThis,
    2940                               TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "FDC IRQ Delay Timer", &pThis->hIrqDelayTimer);
     2942                              TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_NO_RING0,
     2943                              "FDC IRQ Delay Timer", &pThis->hIrqDelayTimer);
    29412944    AssertRCReturn(rc, rc);
    29422945

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

    r87190 r87760  
    58225822    {
    58235823        int rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, ohciR3LoadReattachDevices, NULL /*pvUser*/,
    5824                                       TMTIMER_FLAGS_NO_CRIT_SECT, "OHCI reattach devices on load", &pThisCC->pLoad->hTimer);
     5824                                      TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_NO_RING0, "OHCI reattach devices on load",
     5825                                      &pThisCC->pLoad->hTimer);
    58255826        if (RT_SUCCESS(rc))
    58265827            rc = PDMDevHlpTimerSetMillies(pDevIns, pThisCC->pLoad->hTimer, 250);

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

    r87283 r87760  
    47924792     */
    47934793    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, vmmDevHeartbeatFlatlinedTimer, pThis,
    4794                               TMTIMER_FLAGS_NO_CRIT_SECT, "Heartbeat flatlined", &pThis->hFlatlinedTimer);
     4794                              TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0, "Heartbeat flatlined", &pThis->hFlatlinedTimer);
    47954795    AssertRCReturn(rc, rc);
    47964796

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

    r82968 r87760  
    716716     */
    717717    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, bmsR3TimerCallback, pThis,
    718                               TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "Bus Mouse Timer", &pThis->hMouseTimer);
     718                              TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_NO_RING0, "Bus Mouse Timer", &pThis->hMouseTimer);
    719719    AssertRCReturn(rc, rc);
    720720

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

    r87751 r87760  
    11091109VMMDECL(PTMTIMERR3) TMTimerR3Ptr(PTMTIMER pTimer)
    11101110{
     1111#ifdef IN_RING0
     1112    Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
     1113#endif
    11111114    return (PTMTIMERR3)MMHyperCCToR3(pTimer->CTX_SUFF(pVM), pTimer);
    11121115}
    … …  
    11211124VMMDECL(PTMTIMERR0) TMTimerR0Ptr(PTMTIMER pTimer)
    11221125{
     1126#ifdef IN_RING0
     1127    Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
     1128#endif
    11231129    return (PTMTIMERR0)MMHyperCCToR0(pTimer->CTX_SUFF(pVM), pTimer);
    11241130}
    … …  
    11331139VMMDECL(PTMTIMERRC) TMTimerRCPtr(PTMTIMER pTimer)
    11341140{
     1141#ifdef IN_RING0
     1142    Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
     1143#endif
    11351144    return (PTMTIMERRC)MMHyperCCToRC(pTimer->CTX_SUFF(pVM), pTimer);
    11361145}
    … …  
    11521161VMMDECL(int) TMTimerLock(PTMTIMER pTimer, int rcBusy)
    11531162{
     1163#ifdef IN_RING0
     1164    Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
     1165#endif
    11541166    AssertPtr(pTimer);
    11551167    AssertReturn(pTimer->enmClock == TMCLOCK_VIRTUAL_SYNC, VERR_NOT_SUPPORTED);
    … …  
    11651177VMMDECL(void) TMTimerUnlock(PTMTIMER pTimer)
    11661178{
     1179#ifdef IN_RING0
     1180    Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
     1181#endif
    11671182    AssertPtr(pTimer);
    11681183    AssertReturnVoid(pTimer->enmClock == TMCLOCK_VIRTUAL_SYNC);
    … …  
    11791194VMMDECL(bool) TMTimerIsLockOwner(PTMTIMER pTimer)
    11801195{
     1196#ifdef IN_RING0
     1197    Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
     1198#endif
    11811199    AssertPtr(pTimer);
    11821200    AssertReturn(pTimer->enmClock == TMCLOCK_VIRTUAL_SYNC, false);
    … …  
    13061324VMMDECL(int) TMTimerSet(PTMTIMER pTimer, uint64_t u64Expire)
    13071325{
     1326#ifdef IN_RING0
     1327    Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
     1328#endif
    13081329    PVMCC pVM = pTimer->CTX_SUFF(pVM);
    13091330    STAM_COUNTER_INC(&pTimer->StatSetAbsolute);
    … …  
    16131634VMMDECL(int) TMTimerSetRelative(PTMTIMER pTimer, uint64_t cTicksToNext, uint64_t *pu64Now)
    16141635{
     1636#ifdef IN_RING0
     1637    Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
     1638#endif
    16151639    PVMCC pVM = pTimer->CTX_SUFF(pVM);
    16161640    STAM_COUNTER_INC(&pTimer->StatSetRelative);
    … …  
    18411865VMMDECL(int) TMTimerSetFrequencyHint(PTMTIMER pTimer, uint32_t uHzHint)
    18421866{
     1867#ifdef IN_RING0
     1868    Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
     1869#endif
    18431870    TMTIMER_ASSERT_CRITSECT(pTimer);
    18441871
    … …  
    19361963VMMDECL(int) TMTimerStop(PTMTIMER pTimer)
    19371964{
     1965#ifdef IN_RING0
     1966    Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
     1967#endif
    19381968    PVMCC pVM = pTimer->CTX_SUFF(pVM);
    19391969    STAM_COUNTER_INC(&pTimer->StatStop);
    … …  
    20442074VMMDECL(uint64_t) TMTimerGet(PTMTIMER pTimer)
    20452075{
     2076#ifdef IN_RING0
     2077    Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
     2078#endif
    20462079    PVMCC pVM = pTimer->CTX_SUFF(pVM);
    20472080    STAM_COUNTER_INC(&pTimer->StatGet);
    … …  
    20772110VMMDECL(uint64_t) TMTimerGetFreq(PTMTIMER pTimer)
    20782111{
     2112#ifdef IN_RING0
     2113    Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
     2114#endif
    20792115    switch (pTimer->enmClock)
    20802116    {
    … …  
    21022138VMMDECL(uint64_t) TMTimerGetExpire(PTMTIMER pTimer)
    21032139{
     2140#ifdef IN_RING0
     2141    Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
     2142#endif
    21042143    TMTIMER_ASSERT_CRITSECT(pTimer);
    21052144    int cRetries = 1000;
    … …  
    21642203VMMDECL(bool) TMTimerIsActive(PTMTIMER pTimer)
    21652204{
     2205#ifdef IN_RING0
     2206    Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
     2207#endif
    21662208    TMTIMERSTATE enmState = pTimer->enmState;
    21672209    switch (enmState)
    … …  
    23412383VMMDECL(uint64_t) TMTimerToNano(PTMTIMER pTimer, uint64_t u64Ticks)
    23422384{
     2385#ifdef IN_RING0
     2386    Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
     2387#endif
    23432388    switch (pTimer->enmClock)
    23442389    {
    … …  
    23702415VMMDECL(uint64_t) TMTimerToMicro(PTMTIMER pTimer, uint64_t u64Ticks)
    23712416{
     2417#ifdef IN_RING0
     2418    Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
     2419#endif
    23722420    switch (pTimer->enmClock)
    23732421    {
    … …  
    23992447VMMDECL(uint64_t) TMTimerToMilli(PTMTIMER pTimer, uint64_t u64Ticks)
    24002448{
     2449#ifdef IN_RING0
     2450    Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
     2451#endif
    24012452    switch (pTimer->enmClock)
    24022453    {
    … …  
    24272478VMMDECL(uint64_t) TMTimerFromNano(PTMTIMER pTimer, uint64_t cNanoSecs)
    24282479{
     2480#ifdef IN_RING0
     2481    Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
     2482#endif
    24292483    switch (pTimer->enmClock)
    24302484    {
    … …  
    24552509VMMDECL(uint64_t) TMTimerFromMicro(PTMTIMER pTimer, uint64_t cMicroSecs)
    24562510{
     2511#ifdef IN_RING0
     2512    Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
     2513#endif
    24572514    switch (pTimer->enmClock)
    24582515    {
    … …  
    24832540VMMDECL(uint64_t) TMTimerFromMilli(PTMTIMER pTimer, uint64_t cMilliSecs)
    24842541{
     2542#ifdef IN_RING0
     2543    Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
     2544#endif
    24852545    switch (pTimer->enmClock)
    24862546    {

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

    r87691 r87760  
    415415
    416416
    417 /** @interface_method_impl{PDMDEVHLPR0,pfnTimerToPtr} */
    418 static DECLCALLBACK(PTMTIMERR0) pdmR0DevHlp_TimerToPtr(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
    419 {
    420     PDMDEV_ASSERT_DEVINS(pDevIns);
    421     RT_NOREF(pDevIns);
     417/** Converts a timer handle to a pointer (used to be exposed, will be
     418 *  rewritten later). */
     419DECLINLINE(PTMTIMERR0) pdmR0DevHlp_TimerToPtr(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
     420{
     421    PDMDEV_ASSERT_DEVINS(pDevIns);
    422422    return (PTMTIMERR0)MMHyperR3ToCC(pDevIns->Internal.s.pGVM, hTimer);
    423423}
    … …  
    12491249    pdmR0DevHlp_GetVMCPU,
    12501250    pdmR0DevHlp_GetCurrentCpuId,
    1251     pdmR0DevHlp_TimerToPtr,
    12521251    pdmR0DevHlp_TimerFromMicro,
    12531252    pdmR0DevHlp_TimerFromMilli,
    … …  
    13471346    pdmR0DevHlp_GetVMCPU,
    13481347    pdmR0DevHlp_GetCurrentCpuId,
    1349     pdmR0DevHlp_TimerToPtr,
    13501348    pdmR0DevHlp_TimerFromMicro,
    13511349    pdmR0DevHlp_TimerFromMilli,

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

    r87519 r87760  
    15021502        PAPICCPU pApicCpu = VMCPU_TO_APICCPU(pVCpu);
    15031503        RTStrPrintf(&pApicCpu->szTimerDesc[0], sizeof(pApicCpu->szTimerDesc), "APIC Timer %u", pVCpu->idCpu);
    1504         rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, apicR3TimerCallback, pVCpu, TMTIMER_FLAGS_NO_CRIT_SECT,
    1505                                   pApicCpu->szTimerDesc, &pApicCpu->hTimer);
     1504        rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, apicR3TimerCallback, pVCpu,
     1505                                  TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0, pApicCpu->szTimerDesc, &pApicCpu->hTimer);
    15061506        AssertRCReturn(rc, rc);
    15071507    }

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

    r87494 r87760  
    412412
    413413
    414 /** @interface_method_impl{PDMDEVHLPR3,pfnTMTimerCreate} */
    415 static DECLCALLBACK(int) pdmR3DevHlp_TMTimerCreate(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback, void *pvUser, uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer)
     414/** @interface_method_impl{PDMDEVHLPR3,pfnTimerCreate} */
     415static DECLCALLBACK(int) pdmR3DevHlp_TimerCreate(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback,
     416                                                 void *pvUser, uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer)
    416417{
    417418    PDMDEV_ASSERT_DEVINS(pDevIns);
    418419    PVM pVM = pDevIns->Internal.s.pVMR3;
    419420    VM_ASSERT_EMT(pVM);
    420     LogFlow(("pdmR3DevHlp_TMTimerCreate: caller='%s'/%d: enmClock=%d pfnCallback=%p pvUser=%p fFlags=%#x pszDesc=%p:{%s} ppTimer=%p\n",
    421              pDevIns->pReg->szName, pDevIns->iInstance, enmClock, pfnCallback, pvUser, fFlags, pszDesc, pszDesc, ppTimer));
     421    LogFlow(("pdmR3DevHlp_TimerCreate: caller='%s'/%d: enmClock=%d pfnCallback=%p pvUser=%p fFlags=%#x pszDesc=%p:{%s} phTimer=%p\n",
     422             pDevIns->pReg->szName, pDevIns->iInstance, enmClock, pfnCallback, pvUser, fFlags, pszDesc, pszDesc, phTimer));
    422423
    423424    if (pDevIns->iInstance > 0) /** @todo use a string cache here later. */
    … …  
    428429    }
    429430
    430     int rc = TMR3TimerCreateDevice(pVM, pDevIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, ppTimer);
    431 
    432     LogFlow(("pdmR3DevHlp_TMTimerCreate: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    433     return rc;
    434 }
    435 
    436 
    437 
    438 /** @interface_method_impl{PDMDEVHLPR3,pfnTimerCreate} */
    439 static DECLCALLBACK(int) pdmR3DevHlp_TimerCreate(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback,
    440                                                  void *pvUser, uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer)
    441 {
    442     PDMDEV_ASSERT_DEVINS(pDevIns);
    443     PVM pVM = pDevIns->Internal.s.pVMR3;
    444     VM_ASSERT_EMT(pVM);
    445     LogFlow(("pdmR3DevHlp_TimerCreate: caller='%s'/%d: enmClock=%d pfnCallback=%p pvUser=%p fFlags=%#x pszDesc=%p:{%s} phTimer=%p\n",
    446              pDevIns->pReg->szName, pDevIns->iInstance, enmClock, pfnCallback, pvUser, fFlags, pszDesc, pszDesc, phTimer));
    447 
    448     if (pDevIns->iInstance > 0) /** @todo use a string cache here later. */
    449     {
    450          char *pszDesc2 = MMR3HeapAPrintf(pVM, MM_TAG_PDM_DEVICE_DESC, "%s[%u]", pszDesc, pDevIns->iInstance);
    451          if (pszDesc2)
    452              pszDesc = pszDesc2;
    453     }
     431    /* Clear the ring-0 flag if the device isn't configured for ring-0. */
     432    if (fFlags & TMTIMER_FLAGS_RING0)
     433    {
     434        Assert(pDevIns->Internal.s.pDevR3->pReg->fFlags & PDM_DEVREG_FLAGS_R0);
     435        if (!(pDevIns->Internal.s.fIntFlags & PDMDEVINSINT_FLAGS_R0_ENABLED))
     436            fFlags &= ~TMTIMER_FLAGS_RING0;
     437    }
     438    else
     439        Assert(fFlags & TMTIMER_FLAGS_NO_RING0 /* just to make sure all devices has been considered */);
    454440
    455441    PTMTIMER pTimer = NULL;
    … …  
    462448
    463449
    464 /** @interface_method_impl{PDMDEVHLPR3,pfnTimerToPtr} */
    465 static DECLCALLBACK(PTMTIMERR3) pdmR3DevHlp_TimerToPtr(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
     450/** Converts timer handle to pointer (used to exposed, will be replace soon.) */
     451DECLINLINE(PTMTIMERR3) pdmR3DevHlp_TimerToPtr(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
    466452{
    467453    PDMDEV_ASSERT_DEVINS(pDevIns);
    … …  
    41894175    SSMR3HandleVersion,
    41904176    SSMR3HandleHostOSAndArch,
    4191     pdmR3DevHlp_TMTimerCreate,
    41924177    pdmR3DevHlp_TimerCreate,
    4193     pdmR3DevHlp_TimerToPtr,
    41944178    pdmR3DevHlp_TimerFromMicro,
    41954179    pdmR3DevHlp_TimerFromMilli,
    … …  
    45384522    SSMR3HandleVersion,
    45394523    SSMR3HandleHostOSAndArch,
    4540     pdmR3DevHlp_TMTimerCreate,
    45414524    pdmR3DevHlp_TimerCreate,
    4542     pdmR3DevHlp_TimerToPtr,
    45434525    pdmR3DevHlp_TimerFromMicro,
    45444526    pdmR3DevHlp_TimerFromMilli,
    … …  
    47764758    PDM_DEVHLPR3_VERSION /* the end */
    47774759};
    4778 #endif
     4760#endif /* VBOX_WITH_DBGF_TRACING */
    47794761
    47804762
    … …  
    50445026    SSMR3HandleVersion,
    50455027    SSMR3HandleHostOSAndArch,
    5046     pdmR3DevHlp_TMTimerCreate,
    50475028    pdmR3DevHlp_TimerCreate,
    5048     pdmR3DevHlp_TimerToPtr,
    50495029    pdmR3DevHlp_TimerFromMicro,
    50505030    pdmR3DevHlp_TimerFromMilli,

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

    r82968 r87760  
    13241324    LogFlow(("pdmR3DrvHlp_TMTimerCreate: caller='%s'/%d: enmClock=%d pfnCallback=%p pvUser=%p fFlags=%#x pszDesc=%p:{%s} ppTimer=%p\n",
    13251325             pDrvIns->pReg->szName, pDrvIns->iInstance, enmClock, pfnCallback, pvUser, fFlags, pszDesc, pszDesc, ppTimer));
     1326
     1327    /* Clear the ring-0 flag if the driver isn't configured for ring-0. */
     1328    if (fFlags & TMTIMER_FLAGS_RING0)
     1329    {
     1330        Assert(pDrvIns->Internal.s.pDrv->pReg->fFlags & PDM_DRVREG_FLAGS_R0);
     1331        /** @todo if (!(pDrvIns->Internal.s.fIntFlags & PDMDRVINSINT_FLAGS_R0_ENABLED))   */
     1332            fFlags &= ~TMTIMER_FLAGS_RING0;
     1333    }
    13261334
    13271335    int rc = TMR3TimerCreateDriver(pDrvIns->Internal.s.pVMR3, pDrvIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, ppTimer);

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

    r83196 r87760  
    18291829    if (pszDesc2)
    18301830        pszDesc = pszDesc2;
     1831
     1832    AssertStmt(!(fFlags & TMTIMER_FLAGS_RING0), fFlags &= ~TMTIMER_FLAGS_RING0);
    18311833
    18321834    int rc = TMR3TimerCreateUsb(pVM, pUsbIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, ppTimer);

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

    r87748 r87760  
    15081508 * @param   pVM         The cross context VM structure.
    15091509 * @param   enmClock    The timer clock.
     1510 * @param   fFlags      TMTIMER_FLAGS_XXX.
    15101511 * @param   pszDesc     The timer description.
    15111512 * @param   ppTimer     Where to store the timer pointer on success.
    15121513 */
    1513 static int tmr3TimerCreate(PVM pVM, TMCLOCK enmClock, const char *pszDesc, PPTMTIMERR3 ppTimer)
     1514static int tmr3TimerCreate(PVM pVM, TMCLOCK enmClock, uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer)
    15141515{
    15151516    VM_ASSERT_EMT(pVM);
    … …  
    15491550    pTimer->pCritSect       = NULL;
    15501551    pTimer->pszDesc         = pszDesc;
     1552    pTimer->fFlags          = fFlags;
    15511553
    15521554    /* insert into the list of created timers. */
    … …  
    16041606                                        uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer)
    16051607{
    1606     AssertReturn(!(fFlags & ~(TMTIMER_FLAGS_NO_CRIT_SECT)), VERR_INVALID_PARAMETER);
     1608    AssertReturn(!(fFlags & ~(TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0 | TMTIMER_FLAGS_NO_RING0)),
     1609                 VERR_INVALID_FLAGS);
    16071610
    16081611    /*
    16091612     * Allocate and init stuff.
    16101613     */
    1611     int rc = tmr3TimerCreate(pVM, enmClock, pszDesc, ppTimer);
     1614    int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszDesc, ppTimer);
    16121615    if (RT_SUCCESS(rc))
    16131616    {
    … …  
    16451648                                     uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer)
    16461649{
    1647     AssertReturn(!(fFlags & ~(TMTIMER_FLAGS_NO_CRIT_SECT)), VERR_INVALID_PARAMETER);
     1650    AssertReturn(!(fFlags & ~(TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_NO_RING0)), VERR_INVALID_PARAMETER);
    16481651
    16491652    /*
    16501653     * Allocate and init stuff.
    16511654     */
    1652     int rc = tmr3TimerCreate(pVM, enmClock, pszDesc, ppTimer);
     1655    int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszDesc, ppTimer);
    16531656    if (RT_SUCCESS(rc))
    16541657    {
    … …  
    16881691                                        uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer)
    16891692{
    1690     AssertReturn(!(fFlags & ~(TMTIMER_FLAGS_NO_CRIT_SECT)), VERR_INVALID_PARAMETER);
     1693    AssertReturn(!(fFlags & ~(TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0 | TMTIMER_FLAGS_NO_RING0)),
     1694                 VERR_INVALID_FLAGS);
    16911695
    16921696    /*
    16931697     * Allocate and init stuff.
    16941698     */
    1695     int rc = tmr3TimerCreate(pVM, enmClock, pszDesc, ppTimer);
     1699    int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszDesc, ppTimer);
    16961700    if (RT_SUCCESS(rc))
    16971701    {
    … …  
    17191723 * @param   ppTimer         Where to store the timer on success.
    17201724 */
    1721 VMMR3DECL(int) TMR3TimerCreateInternal(PVM pVM, TMCLOCK enmClock, PFNTMTIMERINT pfnCallback, void *pvUser, const char *pszDesc, PPTMTIMERR3 ppTimer)
     1725VMMR3DECL(int) TMR3TimerCreateInternal(PVM pVM, TMCLOCK enmClock,
     1726                                       PFNTMTIMERINT pfnCallback, void *pvUser, const char *pszDesc, PPTMTIMERR3 ppTimer)
    17221727{
    17231728    /*
    … …  
    17251730     */
    17261731    PTMTIMER pTimer;
    1727     int rc = tmr3TimerCreate(pVM, enmClock, pszDesc, &pTimer);
     1732    int rc = tmr3TimerCreate(pVM, enmClock, 0 /*fFlags*/, pszDesc, &pTimer);
    17281733    if (RT_SUCCESS(rc))
    17291734    {
    … …  
    17501755 *                          until the timer is fully destroyed (i.e. a bit after TMTimerDestroy()).
    17511756 */
    1752 VMMR3DECL(PTMTIMERR3) TMR3TimerCreateExternal(PVM pVM, TMCLOCK enmClock, PFNTMTIMEREXT pfnCallback, void *pvUser, const char *pszDesc)
     1757VMMR3DECL(PTMTIMERR3) TMR3TimerCreateExternal(PVM pVM, TMCLOCK enmClock,
     1758                                              PFNTMTIMEREXT pfnCallback, void *pvUser, const char *pszDesc)
    17531759{
    17541760    /*
    … …  
    17561762     */
    17571763    PTMTIMERR3 pTimer;
    1758     int rc = tmr3TimerCreate(pVM, enmClock, pszDesc, &pTimer);
     1764    int rc = tmr3TimerCreate(pVM, enmClock, 0 /*fFlags*/, pszDesc, &pTimer);
    17591765    if (RT_SUCCESS(rc))
    17601766    {

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

    r87750 r87760  
    206206    uint32_t                padding0; /**< pad structure to multiple of 8 bytes. */
    207207#endif
     208
     209    /** TMTIMER_FLAGS_XXX.   */
     210    uint32_t                fFlags;
     211    uint32_t                u32Pading;
     212
    208213#ifdef VBOX_WITH_STATISTICS
    209214    STAMPROFILE             StatTimer;
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