VirtualBox

Changeset 87773 in vbox


Ignore:
Timestamp:
Feb 16, 2021 11:36:15 PM (4 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
142829
Message:

VMM/TM,Devices: Store the timer name in the TMTIMER structure and limit it to 31 characters. Shortened most timer names. bugref:9943

Location:
trunk
Files:
28 edited

Legend:

Unmodified
Added
Removed

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

    r87767 r87773  
    273273VMM_INT_DECL(int)       TMR3GetImportRC(PVM pVM, const char *pszSymbol, PRTRCPTR pRCPtrValue);
    274274VMM_INT_DECL(int)       TMR3TimerCreateDevice(PVM pVM, PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback,
    275                                               void *pvUser, uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer);
     275                                              void *pvUser, uint32_t fFlags, const char *pszName, PTMTIMERHANDLE phTimer);
    276276VMM_INT_DECL(int)       TMR3TimerCreateUsb(PVM pVM, PPDMUSBINS pUsbIns, TMCLOCK enmClock, PFNTMTIMERUSB pfnCallback,
    277                                            void *pvUser, uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer);
     277                                           void *pvUser, uint32_t fFlags, const char *pszName, PTMTIMERHANDLE phTimer);
    278278VMM_INT_DECL(int)       TMR3TimerCreateDriver(PVM pVM, PPDMDRVINS pDrvIns, TMCLOCK enmClock, PFNTMTIMERDRV pfnCallback,
    279                                               void *pvUser, uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer);
     279                                              void *pvUser, uint32_t fFlags, const char *pszName, PTMTIMERHANDLE phTimer);
    280280VMMR3DECL(int)          TMR3TimerCreate(PVM pVM, TMCLOCK enmClock, PFNTMTIMERINT pfnCallback, void *pvUser, uint32_t fFlags,
    281                                         const char *pszDesc, PTMTIMERHANDLE phTimer);
     281                                        const char *pszName, PTMTIMERHANDLE phTimer);
    282282VMMR3DECL(int)          TMR3TimerDestroy(PVM pVM, TMTIMERHANDLE hTimer);
    283283VMM_INT_DECL(int)       TMR3TimerDestroyDevice(PVM pVM, PPDMDEVINS pDevIns);

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

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

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

    r87767 r87773  
    67846784     */
    67856785    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_REAL, vgaR3TimerRefresh, NULL,
    6786                               TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_NO_RING0, "VGA Refresh Timer", &pThis->hRefreshTimer);
     6786                              TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_NO_RING0, "VGA Refresh", &pThis->hRefreshTimer);
    67876787    AssertRCReturn(rc, rc);
    67886788

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

    r87767 r87773  
    14021402    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, ps2kR3ThrottleTimer, pThis,
    14031403                              TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_RING0,
    1404                               "PS2K Throttle Timer", &pThis->hThrottleTimer);
     1404                              "PS2K Throttle", &pThis->hThrottleTimer);
    14051405    AssertRCReturn(rc, rc);
    14061406
    … …  
    14101410    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, ps2kR3TypematicTimer, pThis,
    14111411                              TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_RING0,
    1412                               "PS2K Typematic Timer", &pThis->hKbdTypematicTimer);
     1412                              "PS2K Typematic", &pThis->hKbdTypematicTimer);
    14131413    AssertRCReturn(rc, rc);
    14141414
    … …  
    14171417     */
    14181418    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, ps2kR3DelayTimer, pThis,
    1419                               TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_RING0, "PS2K Delay Timer", &pThis->hKbdDelayTimer);
     1419                              TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_RING0,
     1420                              "PS2K Delay", &pThis->hKbdDelayTimer);
    14201421    AssertRCReturn(rc, rc);
    14211422

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

    r87767 r87773  
    10861086    int rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_REAL, ps2mR3ThrottleTimer, pThis,
    10871087                                  TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_NO_RING0,
    1088                                   "PS2M Throttle Timer", &pThis->hThrottleTimer);
     1088                                  "PS2M Throttle", &pThis->hThrottleTimer);
    10891089    AssertRCReturn(rc, rc);
    10901090
    … …  
    10931093     */
    10941094    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, ps2mR3DelayTimer, pThis,
    1095                               TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_RING0, "PS2M Delay Timer", &pThis->hDelayTimer);
     1095                              TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_RING0, "PS2M Delay", &pThis->hDelayTimer);
    10961096    AssertRCReturn(rc, rc);
    10971097

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

    r87769 r87773  
    80328032    /* Create Transmit Delay Timer */
    80338033    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, e1kR3TxDelayTimer, pThis,
    8034                               TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0,
    8035                               "E1000 Transmit Delay Timer", &pThis->hTXDTimer);
     8034                              TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0, "E1000 Xmit Delay", &pThis->hTXDTimer);
    80368035    AssertRCReturn(rc, rc);
    80378036    rc = PDMDevHlpTimerSetCritSect(pDevIns, pThis->hTXDTimer, &pThis->csTx);
    … …  
    80448043        /* Create Transmit Interrupt Delay Timer */
    80458044        rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, e1kR3TxIntDelayTimer, pThis,
    8046                                   TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0,
    8047                                   "E1000 Transmit Interrupt Delay Timer", &pThis->hTIDTimer);
     8045                                  TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0, "E1000 Xmit IRQ Delay", &pThis->hTIDTimer);
    80488046        AssertRCReturn(rc, rc);
    80498047
    … …  
    80518049        /* Create Transmit Absolute Delay Timer */
    80528050        rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, e1kR3TxAbsDelayTimer, pThis,
    8053                                   TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0,
    8054                                   "E1000 Transmit Absolute Delay Timer", &pThis->hTADTimer);
     8051                                  TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0, "E1000 Xmit Abs Delay", &pThis->hTADTimer);
    80558052        AssertRCReturn(rc, rc);
    80568053# endif /* E1K_NO_TAD */
    … …  
    80618058    /* Create Receive Interrupt Delay Timer */
    80628059    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, e1kR3RxIntDelayTimer, pThis,
    8063                               TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0,
    8064                               "E1000 Receive Interrupt Delay Timer", &pThis->hRIDTimer);
     8060                              TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0,  "E1000 Recv IRQ Delay", &pThis->hRIDTimer);
    80658061    AssertRCReturn(rc, rc);
    80668062
    80678063    /* Create Receive Absolute Delay Timer */
    80688064    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, e1kR3RxAbsDelayTimer, pThis,
    8069                               TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0,
    8070                               "E1000 Receive Absolute Delay Timer", &pThis->hRADTimer);
     8065                              TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0,  "E1000 Recv Abs Delay", &pThis->hRADTimer);
    80718066    AssertRCReturn(rc, rc);
    80728067#endif /* E1K_USE_RX_TIMERS */
    … …  
    80748069    /* Create Late Interrupt Timer */
    80758070    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, e1kR3LateIntTimer, pThis,
    8076                               TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0,
    8077                               "E1000 Late Interrupt Timer", &pThis->hIntTimer);
     8071                              TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0,  "E1000 Late IRQ", &pThis->hIntTimer);
    80788072    AssertRCReturn(rc, rc);
    80798073
    80808074    /* Create Link Up Timer */
    80818075    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, e1kR3LinkUpTimer, pThis,
    8082                               TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0,
    8083                               "E1000 Link Up Timer", &pThis->hLUTimer);
     8076                              TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0,  "E1000 Link Up", &pThis->hLUTimer);
    80848077    AssertRCReturn(rc, rc);
    80858078

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

    r87768 r87773  
    53295329#else
    53305330    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, pcnetR3Timer, NULL, TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0,
    5331                               "PCnet Poll Timer", &pThis->hTimerPoll);
     5331                              "PCnet Poll", &pThis->hTimerPoll);
    53325332    AssertRCReturn(rc, rc);
    53335333    rc = PDMDevHlpTimerSetCritSect(pDevIns, pThis->hTimerPoll, &pThis->CritSect);
    … …  
    53385338        /* Software Interrupt timer */
    53395339        rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, pcnetR3TimerSoftInt, NULL,
    5340                                   TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0, "PCnet SoftInt Timer", &pThis->hTimerSoftInt);
     5340                                  TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0, "PCnet SoftInt", &pThis->hTimerSoftInt);
    53415341        AssertRCReturn(rc, rc);
    53425342        rc = PDMDevHlpTimerSetCritSect(pDevIns, pThis->hTimerSoftInt, &pThis->CritSect);
    … …  
    53445344    }
    53455345    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, pcnetR3TimerRestore, pThis,
    5346                               TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_NO_RING0, "PCnet Restore Timer", &pThis->hTimerRestore);
     5346                              TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_NO_RING0, "PCnet Restore", &pThis->hTimerRestore);
    53475347    AssertRCReturn(rc, rc);
    53485348

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

    r87767 r87773  
    22472247    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, vnetR3LinkUpTimer, NULL,
    22482248                              TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_NO_RING0,
    2249                               "VirtioNet Link Up Timer", &pThisCC->hLinkUpTimer);
     2249                              "VirtioNet Link Up", &pThisCC->hLinkUpTimer);
    22502250    AssertRCReturn(rc, rc);
    22512251
    … …  
    22542254    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, vnetR3TxTimer, pThis,
    22552255                              TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_NO_RING0,
    2256                               "VirtioNet TX Delay Timer", &pThis->hTxTimer);
     2256                              "VirtioNet TX Delay", &pThis->hTxTimer);
    22572257    AssertRCReturn(rc, rc);
    22582258

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

    r87767 r87773  
    30383038    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, virtioNetR3LinkUpTimer, NULL,
    30393039                              TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_NO_RING0,
    3040                               "VirtioNet Link Up Timer", &pThisCC->hLinkUpTimer);
     3040                              "VirtioNet Link Up", &pThisCC->hLinkUpTimer);
    30413041
    30423042    /*

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

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

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

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

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

    r87767 r87773  
    11581158    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, rtcTimerPeriodic, pThis,
    11591159                              TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_RING0,
    1160                               "MC146818 RTC (CMOS) - Periodic", &pThis->hPeriodicTimer);
     1160                              "MC146818 RTC Periodic", &pThis->hPeriodicTimer);
    11611161    AssertRCReturn(rc, rc);
    11621162
    … …  
    11641164    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, rtcR3TimerSecond, pThis,
    11651165                              TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_RING0,
    1166                               "MC146818 RTC (CMOS) - Second", &pThis->hSecondTimer);
     1166                              "MC146818 RTC Second", &pThis->hSecondTimer);
    11671167    AssertRCReturn(rc, rc);
    11681168
    … …  
    11701170    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, rtcR3TimerSecond2, pThis,
    11711171                              TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_NO_RING0,
    1172                               "MC146818 RTC (CMOS) - Second2", &pThis->hSecondTimer2);
     1172                              "MC146818 RTC Second2", &pThis->hSecondTimer2);
    11731173    AssertRCReturn(rc, rc);
    11741174

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

    r87767 r87773  
    20712071     */
    20722072    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, uartR3RcvFifoTimeoutTimer, pThisCC,
    2073                               TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0, "UART Rcv FIFO Timer",
     2073                              TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0, "UART Rcv FIFO",
    20742074                              &pThis->hTimerRcvFifoTimeout);
    20752075    AssertRCReturn(rc, rc);
    … …  
    20822082     */
    20832083    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, uartR3TxUnconnectedTimer, pThisCC,
    2084                               TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_NO_RING0, "UART TX uncon. Timer",
     2084                              TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_NO_RING0, "UART TX unconnect",
    20852085                              &pThis->hTimerTxUnconnected);
    20862086    AssertRCReturn(rc, rc);

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

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

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

    r87767 r87773  
    29332933    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, fdcTransferDelayTimer, pThis,
    29342934                              TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_NO_RING0,
    2935                               "FDC Transfer Delay Timer", &pThis->hXferDelayTimer);
     2935                              "FDC Transfer Delay", &pThis->hXferDelayTimer);
    29362936    AssertRCReturn(rc, rc);
    29372937
    … …  
    29412941    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, fdcIrqDelayTimer, pThis,
    29422942                              TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_NO_RING0,
    2943                               "FDC IRQ Delay Timer", &pThis->hIrqDelayTimer);
     2943                              "FDC IRQ Delay", &pThis->hIrqDelayTimer);
    29442944    AssertRCReturn(rc, rc);
    29452945

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

    r87767 r87773  
    58485848    {
    58495849        int rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, ohciR3LoadReattachDevices, NULL /*pvUser*/,
    5850                                       TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_NO_RING0, "OHCI reattach devices on load",
     5850                                      TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_NO_RING0, "OHCI reattach on load",
    58515851                                      &pThisCC->pLoad->hTimer);
    58525852        if (RT_SUCCESS(rc))

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

    r87767 r87773  
    18131813     */
    18141814    rc = PDMUsbHlpTimerCreate(pDev->pUsbIns, TMCLOCK_VIRTUAL, vusbDevResetDoneTimer, pDev, 0 /*fFlags*/,
    1815                               "USB Device Reset Timer", &pDev->hResetTimer);
     1815                              "USB Reset", &pDev->hResetTimer);
    18161816    AssertRCReturn(rc, rc);
    18171817

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

    r87767 r87773  
    717717     */
    718718    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, bmsR3TimerCallback, pThis,
    719                               TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_NO_RING0, "Bus Mouse Timer", &pThis->hMouseTimer);
     719                              TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_NO_RING0, "Bus Mouse", &pThis->hMouseTimer);
    720720    AssertRCReturn(rc, rc);
    721721

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

    r87771 r87773  
    7878                          || enmState == VMSTATE_RESETTING \
    7979                          || enmState == VMSTATE_RESETTING_LS ),\
    80                       ("pTimer=%p (%s) pCritSect=%p (%s)\n", a_pTimer, R3STRING(a_pTimer->pszDesc), \
     80                      ("pTimer=%p (%s) pCritSect=%p (%s)\n", a_pTimer, (a_pTimer)->szName, \
    8181                       (a_pTimer)->pCritSect, R3STRING(PDMR3CritSectName((a_pTimer)->pCritSect)) )); \
    8282        } \
    … …  
    112112                          || enmState == VMSTATE_RESETTING \
    113113                          || enmState == VMSTATE_RESETTING_LS ),\
    114                       ("pTimer=%p (%s) pCritSect=%p (%s)\n", pTimer, R3STRING(pTimer->pszDesc), \
     114                      ("pTimer=%p (%s) pCritSect=%p (%s)\n", pTimer, pTimer->szName, \
    115115                       (pTimer)->pCritSect, R3STRING(PDMR3CritSectName((pTimer)->pCritSect)) )); \
    116116        } \
    … …  
    478478                    TMTIMER_SET_HEAD(pQueue, pTimer);
    479479                    ASMAtomicWriteU64(&pQueue->u64Expire, u64Expire);
    480                     DBGFTRACE_U64_TAG2(pTimer->CTX_SUFF(pVM), u64Expire, "tmTimerQueueLinkActive head", R3STRING(pTimer->pszDesc));
     480                    DBGFTRACE_U64_TAG2(pTimer->CTX_SUFF(pVM), u64Expire, "tmTimerQueueLinkActive head", pTimer->szName);
    481481                }
    482482                TMTIMER_SET_PREV(pCur, pTimer);
    … …  
    487487                TMTIMER_SET_NEXT(pCur, pTimer);
    488488                TMTIMER_SET_PREV(pTimer, pCur);
    489                 DBGFTRACE_U64_TAG2(pTimer->CTX_SUFF(pVM), u64Expire, "tmTimerQueueLinkActive tail", R3STRING(pTimer->pszDesc));
     489                DBGFTRACE_U64_TAG2(pTimer->CTX_SUFF(pVM), u64Expire, "tmTimerQueueLinkActive tail", pTimer->szName);
    490490                return;
    491491            }
    … …  
    496496        TMTIMER_SET_HEAD(pQueue, pTimer);
    497497        ASMAtomicWriteU64(&pQueue->u64Expire, u64Expire);
    498         DBGFTRACE_U64_TAG2(pTimer->CTX_SUFF(pVM), u64Expire, "tmTimerQueueLinkActive empty", R3STRING(pTimer->pszDesc));
     498        DBGFTRACE_U64_TAG2(pTimer->CTX_SUFF(pVM), u64Expire, "tmTimerQueueLinkActive empty", pTimer->szName);
    499499    }
    500500}
    … …  
    628628         * Do the scheduling.
    629629         */
    630         Log2(("tmTimerQueueSchedule: %p:{.enmState=%s, .enmClock=%d, .enmType=%d, .pszDesc=%s}\n",
    631               pTimer, tmTimerState(pTimer->enmState), pTimer->enmClock, pTimer->enmType, R3STRING(pTimer->pszDesc)));
     630        Log2(("tmTimerQueueSchedule: %p:{.enmState=%s, .enmClock=%d, .enmType=%d, .szName=%s}\n",
     631              pTimer, tmTimerState(pTimer->enmState), pTimer->enmClock, pTimer->enmType, pTimer->szName));
    632632        tmTimerQueueScheduleOne(pVM, pQueue, pTimer);
    633633        Log2(("tmTimerQueueSchedule: %p: new %s\n", pTimer, tmTimerState(pTimer->enmState)));
    … …  
    11861186    }
    11871187    ASMAtomicWriteU64(&pTimer->u64Expire, u64Expire);
    1188     Log2(("tmTimerSetOptimizedStart: %p:{.pszDesc='%s', .u64Expire=%'RU64}\n", pTimer, R3STRING(pTimer->pszDesc), u64Expire));
     1188    Log2(("tmTimerSetOptimizedStart: %p:{.pszDesc='%s', .u64Expire=%'RU64}\n", pTimer, pTimer->szName, u64Expire));
    11891189
    11901190    /*
    … …  
    12301230
    12311231            AssertMsg(u64Expire >= pVM->tm.s.u64VirtualSync,
    1232                       ("%'RU64 < %'RU64 %s\n", u64Expire, pVM->tm.s.u64VirtualSync, R3STRING(pTimer->pszDesc)));
     1232                      ("%'RU64 < %'RU64 %s\n", u64Expire, pVM->tm.s.u64VirtualSync, pTimer->szName));
    12331233            pTimer->u64Expire = u64Expire;
    12341234            TM_SET_STATE(pTimer, TMTIMERSTATE_ACTIVE);
    … …  
    12541254        case TMTIMERSTATE_DESTROY:
    12551255        case TMTIMERSTATE_FREE:
    1256             AssertLogRelMsgFailed(("Invalid timer state %s: %s\n", tmTimerState(enmState), R3STRING(pTimer->pszDesc)));
     1256            AssertLogRelMsgFailed(("Invalid timer state %s: %s\n", tmTimerState(enmState), pTimer->szName));
    12571257            rc = VERR_TM_INVALID_STATE;
    12581258            break;
    12591259
    12601260        default:
    1261             AssertMsgFailed(("Unknown timer state %d: %s\n", enmState, R3STRING(pTimer->pszDesc)));
     1261            AssertMsgFailed(("Unknown timer state %d: %s\n", enmState, pTimer->szName));
    12621262            rc = VERR_TM_UNKNOWN_STATE;
    12631263            break;
    … …  
    12911291    TMTIMER_ASSERT_CRITSECT(pVM, pTimer);
    12921292
    1293     DBGFTRACE_U64_TAG2(pVM, u64Expire, "TMTimerSet", R3STRING(pTimer->pszDesc));
     1293    DBGFTRACE_U64_TAG2(pVM, u64Expire, "TMTimerSet", pTimer->szName);
    12941294
    12951295#ifdef VBOX_WITH_STATISTICS
    … …  
    13471347        TMTIMERSTATE enmState = pTimer->enmState;
    13481348        Log2(("TMTimerSet: %p:{.enmState=%s, .pszDesc='%s'} cRetries=%d u64Expire=%'RU64\n",
    1349               pTimer, tmTimerState(enmState), R3STRING(pTimer->pszDesc), cRetries, u64Expire));
     1349              pTimer, tmTimerState(enmState), pTimer->szName, cRetries, u64Expire));
    13501350        switch (enmState)
    13511351        {
    … …  
    14171417            case TMTIMERSTATE_DESTROY:
    14181418            case TMTIMERSTATE_FREE:
    1419                 AssertMsgFailed(("Invalid timer state %d (%s)\n", enmState, R3STRING(pTimer->pszDesc)));
     1419                AssertMsgFailed(("Invalid timer state %d (%s)\n", enmState, pTimer->szName));
    14201420                return VERR_TM_INVALID_STATE;
    14211421            default:
    1422                 AssertMsgFailed(("Unknown timer state %d (%s)\n", enmState, R3STRING(pTimer->pszDesc)));
     1422                AssertMsgFailed(("Unknown timer state %d (%s)\n", enmState, pTimer->szName));
    14231423                return VERR_TM_UNKNOWN_STATE;
    14241424        }
    14251425    } while (cRetries-- > 0);
    14261426
    1427     AssertMsgFailed(("Failed waiting for stable state. state=%d (%s)\n", pTimer->enmState, R3STRING(pTimer->pszDesc)));
     1427    AssertMsgFailed(("Failed waiting for stable state. state=%d (%s)\n", pTimer->enmState, pTimer->szName));
    14281428    STAM_PROFILE_STOP(&pVM->tm.s.CTX_SUFF_Z(StatTimerSet), a);
    14291429    return VERR_TM_TIMER_UNSTABLE_STATE;
    … …  
    14861486    uint64_t const  u64Expire = cTicksToNext + tmTimerSetRelativeNowWorker(pVM, enmClock, pu64Now);
    14871487    pTimer->u64Expire         = u64Expire;
    1488     Log2(("tmTimerSetRelativeOptimizedStart: %p:{.pszDesc='%s', .u64Expire=%'RU64} cTicksToNext=%'RU64\n", pTimer, R3STRING(pTimer->pszDesc), u64Expire, cTicksToNext));
     1488    Log2(("tmTimerSetRelativeOptimizedStart: %p:{.pszDesc='%s', .u64Expire=%'RU64} cTicksToNext=%'RU64\n", pTimer, pTimer->szName, u64Expire, cTicksToNext));
    14891489
    14901490    /*
    14911491     * Link the timer into the active list.
    14921492     */
    1493     DBGFTRACE_U64_TAG2(pVM, u64Expire, "tmTimerSetRelativeOptimizedStart", R3STRING(pTimer->pszDesc));
     1493    DBGFTRACE_U64_TAG2(pVM, u64Expire, "tmTimerSetRelativeOptimizedStart", pTimer->szName);
    14941494    tmTimerQueueLinkActive(&pVM->tm.s.CTX_SUFF(paTimerQueues)[enmClock], pTimer, u64Expire);
    14951495
    … …  
    15611561        case TMTIMERSTATE_DESTROY:
    15621562        case TMTIMERSTATE_FREE:
    1563             AssertLogRelMsgFailed(("Invalid timer state %s: %s\n", tmTimerState(enmState), R3STRING(pTimer->pszDesc)));
     1563            AssertLogRelMsgFailed(("Invalid timer state %s: %s\n", tmTimerState(enmState), pTimer->szName));
    15641564            rc = VERR_TM_INVALID_STATE;
    15651565            break;
    15661566
    15671567        default:
    1568             AssertMsgFailed(("Unknown timer state %d: %s\n", enmState, R3STRING(pTimer->pszDesc)));
     1568            AssertMsgFailed(("Unknown timer state %d: %s\n", enmState, pTimer->szName));
    15691569            rc = VERR_TM_UNKNOWN_STATE;
    15701570            break;
    … …  
    15981598    TMTIMER_ASSERT_CRITSECT(pVM, pTimer);
    15991599
    1600     DBGFTRACE_U64_TAG2(pVM, cTicksToNext, "TMTimerSetRelative", R3STRING(pTimer->pszDesc));
     1600    DBGFTRACE_U64_TAG2(pVM, cTicksToNext, "TMTimerSetRelative", pTimer->szName);
    16011601
    16021602#ifdef VBOX_WITH_STATISTICS
    … …  
    16811681                    pTimer->u64Expire = cTicksToNext + tmTimerSetRelativeNowWorker(pVM, enmClock, pu64Now);
    16821682                    Log2(("TMTimerSetRelative: %p:{.enmState=%s, .pszDesc='%s', .u64Expire=%'RU64} cRetries=%d [EXP/STOP]\n",
    1683                           pTimer, tmTimerState(enmState), R3STRING(pTimer->pszDesc), pTimer->u64Expire, cRetries));
     1683                          pTimer, tmTimerState(enmState), pTimer->szName, pTimer->u64Expire, cRetries));
    16841684                    TM_SET_STATE(pTimer, TMTIMERSTATE_PENDING_SCHEDULE);
    16851685                    tmSchedule(pVM, pTimer);
    … …  
    16961696                    pTimer->u64Expire = cTicksToNext + tmTimerSetRelativeNowWorker(pVM, enmClock, pu64Now);
    16971697                    Log2(("TMTimerSetRelative: %p:{.enmState=%s, .pszDesc='%s', .u64Expire=%'RU64} cRetries=%d [PEND_SCHED]\n",
    1698                           pTimer, tmTimerState(enmState), R3STRING(pTimer->pszDesc), pTimer->u64Expire, cRetries));
     1698                          pTimer, tmTimerState(enmState), pTimer->szName, pTimer->u64Expire, cRetries));
    16991699                    TM_SET_STATE(pTimer, TMTIMERSTATE_PENDING_SCHEDULE);
    17001700                    tmSchedule(pVM, pTimer);
    … …  
    17111711                    pTimer->u64Expire = cTicksToNext + tmTimerSetRelativeNowWorker(pVM, enmClock, pu64Now);
    17121712                    Log2(("TMTimerSetRelative: %p:{.enmState=%s, .pszDesc='%s', .u64Expire=%'RU64} cRetries=%d [ACTIVE]\n",
    1713                           pTimer, tmTimerState(enmState), R3STRING(pTimer->pszDesc), pTimer->u64Expire, cRetries));
     1713                          pTimer, tmTimerState(enmState), pTimer->szName, pTimer->u64Expire, cRetries));
    17141714                    TM_SET_STATE(pTimer, TMTIMERSTATE_PENDING_RESCHEDULE);
    17151715                    tmSchedule(pVM, pTimer);
    … …  
    17261726                    pTimer->u64Expire = cTicksToNext + tmTimerSetRelativeNowWorker(pVM, enmClock, pu64Now);
    17271727                    Log2(("TMTimerSetRelative: %p:{.enmState=%s, .pszDesc='%s', .u64Expire=%'RU64} cRetries=%d [PEND_RESCH/STOP]\n",
    1728                           pTimer, tmTimerState(enmState), R3STRING(pTimer->pszDesc), pTimer->u64Expire, cRetries));
     1728                          pTimer, tmTimerState(enmState), pTimer->szName, pTimer->u64Expire, cRetries));
    17291729                    TM_SET_STATE(pTimer, TMTIMERSTATE_PENDING_RESCHEDULE);
    17301730                    tmSchedule(pVM, pTimer);
    … …  
    17531753            case TMTIMERSTATE_DESTROY:
    17541754            case TMTIMERSTATE_FREE:
    1755                 AssertMsgFailed(("Invalid timer state %d (%s)\n", enmState, R3STRING(pTimer->pszDesc)));
     1755                AssertMsgFailed(("Invalid timer state %d (%s)\n", enmState, pTimer->szName));
    17561756                rc = VERR_TM_INVALID_STATE;
    17571757                break;
    17581758
    17591759            default:
    1760                 AssertMsgFailed(("Unknown timer state %d (%s)\n", enmState, R3STRING(pTimer->pszDesc)));
     1760                AssertMsgFailed(("Unknown timer state %d (%s)\n", enmState, pTimer->szName));
    17611761                rc = VERR_TM_UNKNOWN_STATE;
    17621762                break;
    … …  
    17741774        if (cRetries <= 0)
    17751775        {
    1776             AssertMsgFailed(("Failed waiting for stable state. state=%d (%s)\n", pTimer->enmState, R3STRING(pTimer->pszDesc)));
     1776            AssertMsgFailed(("Failed waiting for stable state. state=%d (%s)\n", pTimer->enmState, pTimer->szName));
    17771777            rc = VERR_TM_TIMER_UNSTABLE_STATE;
    17781778            tmTimerSetRelativeNowWorker(pVM, enmClock, pu64Now);
    … …  
    19051905        case TMTIMERSTATE_DESTROY:
    19061906        case TMTIMERSTATE_FREE:
    1907             AssertLogRelMsgFailed(("Invalid timer state %s: %s\n", tmTimerState(enmState), R3STRING(pTimer->pszDesc)));
     1907            AssertLogRelMsgFailed(("Invalid timer state %s: %s\n", tmTimerState(enmState), pTimer->szName));
    19081908            rc = VERR_TM_INVALID_STATE;
    19091909            break;
    19101910
    19111911        default:
    1912             AssertMsgFailed(("Unknown timer state %d: %s\n", enmState, R3STRING(pTimer->pszDesc)));
     1912            AssertMsgFailed(("Unknown timer state %d: %s\n", enmState, pTimer->szName));
    19131913            rc = VERR_TM_UNKNOWN_STATE;
    19141914            break;
    … …  
    19611961        TMTIMERSTATE    enmState = pTimer->enmState;
    19621962        Log2(("TMTimerStop: %p:{.enmState=%s, .pszDesc='%s'} cRetries=%d\n",
    1963               pTimer, tmTimerState(enmState), R3STRING(pTimer->pszDesc), cRetries));
     1963              pTimer, tmTimerState(enmState), pTimer->szName, cRetries));
    19641964        switch (enmState)
    19651965        {
    … …  
    20172017            case TMTIMERSTATE_DESTROY:
    20182018            case TMTIMERSTATE_FREE:
    2019                 AssertMsgFailed(("Invalid timer state %d (%s)\n", enmState, R3STRING(pTimer->pszDesc)));
     2019                AssertMsgFailed(("Invalid timer state %d (%s)\n", enmState, pTimer->szName));
    20202020                return VERR_TM_INVALID_STATE;
    20212021            default:
    2022                 AssertMsgFailed(("Unknown timer state %d (%s)\n", enmState, R3STRING(pTimer->pszDesc)));
     2022                AssertMsgFailed(("Unknown timer state %d (%s)\n", enmState, pTimer->szName));
    20232023                return VERR_TM_UNKNOWN_STATE;
    20242024        }
    20252025    } while (cRetries-- > 0);
    20262026
    2027     AssertMsgFailed(("Failed waiting for stable state. state=%d (%s)\n", pTimer->enmState, R3STRING(pTimer->pszDesc)));
     2027    AssertMsgFailed(("Failed waiting for stable state. state=%d (%s)\n", pTimer->enmState, pTimer->szName));
    20282028    STAM_PROFILE_STOP(&pVM->tm.s.CTX_SUFF_Z(StatTimerStop), a);
    20292029    return VERR_TM_TIMER_UNSTABLE_STATE;
    … …  
    20622062    }
    20632063    //Log2(("TMTimerGet: returns %'RU64 (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n",
    2064     //      u64, pTimer, tmTimerState(pTimer->enmState), R3STRING(pTimer->pszDesc)));
     2064    //      u64, pTimer, tmTimerState(pTimer->enmState), pTimer->szName));
    20652065    return u64;
    20662066}
    … …  
    21192119            case TMTIMERSTATE_PENDING_STOP_SCHEDULE:
    21202120                Log2(("TMTimerGetExpire: returns ~0 (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n",
    2121                       pTimer, tmTimerState(pTimer->enmState), R3STRING(pTimer->pszDesc)));
     2121                      pTimer, tmTimerState(pTimer->enmState), pTimer->szName));
    21222122                return UINT64_MAX;
    21232123
    … …  
    21262126            case TMTIMERSTATE_PENDING_SCHEDULE:
    21272127                Log2(("TMTimerGetExpire: returns %'RU64 (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n",
    2128                       pTimer->u64Expire, pTimer, tmTimerState(pTimer->enmState), R3STRING(pTimer->pszDesc)));
     2128                      pTimer->u64Expire, pTimer, tmTimerState(pTimer->enmState), pTimer->szName));
    21292129                return pTimer->u64Expire;
    21302130
    … …  
    21422142            case TMTIMERSTATE_DESTROY:
    21432143            case TMTIMERSTATE_FREE:
    2144                 AssertMsgFailed(("Invalid timer state %d (%s)\n", enmState, R3STRING(pTimer->pszDesc)));
     2144                AssertMsgFailed(("Invalid timer state %d (%s)\n", enmState, pTimer->szName));
    21452145                Log2(("TMTimerGetExpire: returns ~0 (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n",
    2146                       pTimer, tmTimerState(pTimer->enmState), R3STRING(pTimer->pszDesc)));
     2146                      pTimer, tmTimerState(pTimer->enmState), pTimer->szName));
    21472147                return UINT64_MAX;
    21482148            default:
    2149                 AssertMsgFailed(("Unknown timer state %d (%s)\n", enmState, R3STRING(pTimer->pszDesc)));
     2149                AssertMsgFailed(("Unknown timer state %d (%s)\n", enmState, pTimer->szName));
    21502150                return UINT64_MAX;
    21512151        }
    21522152    } while (cRetries-- > 0);
    21532153
    2154     AssertMsgFailed(("Failed waiting for stable state. state=%d (%s)\n", pTimer->enmState, R3STRING(pTimer->pszDesc)));
     2154    AssertMsgFailed(("Failed waiting for stable state. state=%d (%s)\n", pTimer->enmState, pTimer->szName));
    21552155    Log2(("TMTimerGetExpire: returns ~0 (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n",
    2156           pTimer, tmTimerState(pTimer->enmState), R3STRING(pTimer->pszDesc)));
     2156          pTimer, tmTimerState(pTimer->enmState), pTimer->szName));
    21572157    return UINT64_MAX;
    21582158}
    … …  
    21802180        case TMTIMERSTATE_PENDING_STOP_SCHEDULE:
    21812181            Log2(("TMTimerIsActive: returns false (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n",
    2182                   pTimer, tmTimerState(pTimer->enmState), R3STRING(pTimer->pszDesc)));
     2182                  pTimer, tmTimerState(pTimer->enmState), pTimer->szName));
    21832183            return false;
    21842184
    … …  
    21892189        case TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE:
    21902190            Log2(("TMTimerIsActive: returns true (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n",
    2191                   pTimer, tmTimerState(pTimer->enmState), R3STRING(pTimer->pszDesc)));
     2191                  pTimer, tmTimerState(pTimer->enmState), pTimer->szName));
    21922192            return true;
    21932193
    … …  
    21972197        case TMTIMERSTATE_DESTROY:
    21982198        case TMTIMERSTATE_FREE:
    2199             AssertMsgFailed(("Invalid timer state %s (%s)\n", tmTimerState(enmState), R3STRING(pTimer->pszDesc)));
     2199            AssertMsgFailed(("Invalid timer state %s (%s)\n", tmTimerState(enmState), pTimer->szName));
    22002200            Log2(("TMTimerIsActive: returns false (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n",
    2201                   pTimer, tmTimerState(pTimer->enmState), R3STRING(pTimer->pszDesc)));
     2201                  pTimer, tmTimerState(pTimer->enmState), pTimer->szName));
    22022202            return false;
    22032203        default:
    2204             AssertMsgFailed(("Unknown timer state %d (%s)\n", enmState, R3STRING(pTimer->pszDesc)));
     2204            AssertMsgFailed(("Unknown timer state %d (%s)\n", enmState, pTimer->szName));
    22052205            return false;
    22062206    }

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

    r87766 r87773  
    45104510                {
    45114511                    PVMCPU pVCpu = pVM->apCpusR3[idCpu];
    4512                     /* The string cannot live on the stack. It should be safe to call MMR3HeapAPrintf here as
    4513                        MMR3HyperInitFinalize has already completed at this point. */
    4514                     char *pszTimerName = MMR3HeapAPrintf(pVM, MM_TAG_CPUM_CTX, "Nested Guest VMX-preempt. timer %u", idCpu);
     4512                    char szName[32];
     4513                    RTStrPrintf(szName, sizeof(szName), "Nested VMX-preemption %u", idCpu);
    45154514                    int rc = TMR3TimerCreate(pVM, TMCLOCK_VIRTUAL_SYNC, cpumR3VmxPreemptTimerCallback, pVCpu,
    4516                                              TMTIMER_FLAGS_RING0, pszTimerName, &pVCpu->cpum.s.hNestedVmxPreemptTimer);
     4515                                             TMTIMER_FLAGS_RING0, szName, &pVCpu->cpum.s.hNestedVmxPreemptTimer);
    45174516                    AssertLogRelRCReturn(rc, rc);
    45184517                }

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

    r87766 r87773  
    518518
    519519                /* Create the timer and associate the context pointers. */
    520                 RTStrPrintf(&pHvStimer->szTimerDesc[0], sizeof(pHvStimer->szTimerDesc), "Hyper-V[%u] Timer%u", pVCpu->idCpu,
    521                             idxStimer);
     520                char szName[32];
     521                RTStrPrintf(szName, sizeof(szName), "Hyper-V[%u] Timer%u", pVCpu->idCpu, idxStimer);
    522522                rc = TMR3TimerCreate(pVM, TMCLOCK_VIRTUAL_SYNC, gimR3HvTimerCallback, pHvStimer /* pvUser */,
    523                                      TMTIMER_FLAGS_RING0, pHvStimer->szTimerDesc, &pHvStimer->hTimer);
     523                                     TMTIMER_FLAGS_RING0, szName, &pHvStimer->hTimer);
    524524                AssertLogRelRCReturn(rc, rc);
    525525            }

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

    r87766 r87773  
    422422             pDevIns->pReg->szName, pDevIns->iInstance, enmClock, pfnCallback, pvUser, fFlags, pszDesc, pszDesc, phTimer));
    423423
    424     if (pDevIns->iInstance > 0) /** @todo use a string cache here later. */
    425     {
    426          char *pszDesc2 = MMR3HeapAPrintf(pVM, MM_TAG_PDM_DEVICE_DESC, "%s[%u]", pszDesc, pDevIns->iInstance);
    427          if (pszDesc2)
    428              pszDesc = pszDesc2;
     424    /* Mangle the timer name if there are more than one instance of this device. */
     425    char szName[32];
     426    AssertReturn(strlen(pszDesc) < sizeof(szName) - 3, VERR_INVALID_NAME);
     427    if (pDevIns->iInstance > 0)
     428    {
     429        RTStrPrintf(szName, sizeof(szName), "%s[%u]", pszDesc, pDevIns->iInstance);
     430        pszDesc = szName;
    429431    }
    430432

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

    r87772 r87773  
    13251325    LogFlow(("pdmR3DrvHlp_TimerCreate: caller='%s'/%d: enmClock=%d pfnCallback=%p pvUser=%p fFlags=%#x pszDesc=%p:{%s} phTimer=%p\n",
    13261326             pDrvIns->pReg->szName, pDrvIns->iInstance, enmClock, pfnCallback, pvUser, fFlags, pszDesc, pszDesc, phTimer));
     1327
     1328    /* Mangle the timer name if there are more than once instance of this driver. */
     1329    char szName[32];
     1330    AssertReturn(strlen(pszDesc) < sizeof(szName) - 3, VERR_INVALID_NAME);
     1331    if (pDrvIns->iInstance > 0)
     1332    {
     1333        RTStrPrintf(szName, sizeof(szName), "%s[%u]", pszDesc, pDrvIns->iInstance);
     1334        pszDesc = szName;
     1335    }
    13271336
    13281337    /* Clear the ring-0 flag if the driver isn't configured for ring-0. */

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

    r87766 r87773  
    113113    if (cMilliesInterval)
    114114    {
    115         rc = TMR3TimerCreate(pVM, TMCLOCK_REAL, pdmR3QueueTimer, pQueue, TMTIMER_FLAGS_NO_RING0, "Queue timer", &pQueue->hTimer);
     115        char szName[32];
     116        RTStrPrintf(szName, sizeof(szName), "Queue %s", pQueue->pszName);
     117        rc = TMR3TimerCreate(pVM, TMCLOCK_REAL, pdmR3QueueTimer, pQueue, TMTIMER_FLAGS_NO_RING0, szName, &pQueue->hTimer);
    116118        if (RT_SUCCESS(rc))
    117119        {

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

    r87766 r87773  
    18281828    fFlags |= TMTIMER_FLAGS_NO_RING0;
    18291829
    1830     /** @todo use a string cache here later. */
    1831     char *pszDesc2 = MMR3HeapAPrintf(pVM, MM_TAG_PDM_USB_DESC, "%s[%s:%u]", pszDesc, pUsbIns->Internal.s.pUsbDev->pReg->szName, pUsbIns->iInstance);
    1832     if (pszDesc2)
    1833         pszDesc = pszDesc2;
     1830    /* Mangle the timer name if there are more than one instance of this device. */
     1831    char szName[32];
     1832    AssertReturn(strlen(pszDesc) < sizeof(szName) - 8, VERR_INVALID_NAME);
     1833    if (pUsbIns->iInstance > 0)
     1834    {
     1835        RTStrPrintf(szName, sizeof(szName), "%s[%u:%s]", pszDesc, pUsbIns->iInstance, pUsbIns->Internal.s.pUsbDev->pReg->szName);
     1836        pszDesc = szName;
     1837    }
    18341838
    18351839    int rc = TMR3TimerCreateUsb(pVM, pUsbIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, phTimer);

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

    r87771 r87773  
    15001500 * @param   enmClock    The timer clock.
    15011501 * @param   fFlags      TMTIMER_FLAGS_XXX.
    1502  * @param   pszDesc     The timer description.
     1502 * @param   pszName     The timer name.
    15031503 * @param   ppTimer     Where to store the timer pointer on success.
    15041504 */
    1505 static int tmr3TimerCreate(PVM pVM, TMCLOCK enmClock, uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer)
    1506 {
     1505static int tmr3TimerCreate(PVM pVM, TMCLOCK enmClock, uint32_t fFlags, const char *pszName, PPTMTIMERR3 ppTimer)
     1506{
     1507    PTMTIMERR3 pTimer;
     1508
     1509    /*
     1510     * Validate input.
     1511     */
    15071512    VM_ASSERT_EMT(pVM);
    15081513    AssertReturn((fFlags & (TMTIMER_FLAGS_RING0 | TMTIMER_FLAGS_NO_RING0)) != (TMTIMER_FLAGS_RING0 | TMTIMER_FLAGS_NO_RING0),
    15091514                 VERR_INVALID_FLAGS);
     1515    AssertPtrReturn(pszName, VERR_INVALID_POINTER);
     1516    size_t const cchName = strlen(pszName);
     1517    AssertMsgReturn(cchName < sizeof(pTimer->szName), ("timer name too long: %s\n", pszName), VERR_INVALID_NAME);
     1518    AssertMsgReturn(cchName > 2,  ("Too short timer name: %s\n", pszName), VERR_INVALID_NAME);
    15101519
    15111520    /*
    15121521     * Allocate the timer.
    15131522     */
    1514     PTMTIMERR3 pTimer = NULL;
    15151523    if (pVM->tm.s.pFree && VM_IS_EMT(pVM))
    15161524    {
    … …  
    15191527        Log3(("TM: Recycling timer %p, new free head %p.\n", pTimer, pTimer->pBigNext));
    15201528    }
     1529    else
     1530        pTimer = NULL;
    15211531
    15221532    if (!pTimer)
    … …  
    15421552    pTimer->pvUser          = NULL;
    15431553    pTimer->pCritSect       = NULL;
    1544     pTimer->pszDesc         = pszDesc;
     1554    memcpy(pTimer->szName, pszName, cchName);
     1555    pTimer->szName[cchName] = '\0';
    15451556
    15461557    /* insert into the list of created timers. */
    … …  
    15561567    TM_UNLOCK_TIMERS(pVM);
    15571568
     1569#ifdef VBOX_WITH_STATISTICS
    15581570    /*
    15591571     * Register statistics.
    15601572     */
    1561 #ifdef VBOX_WITH_STATISTICS
    1562 
    15631573    STAMR3RegisterF(pVM, &pTimer->StatTimer,        STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL,
    1564                     tmR3TimerClockName(pTimer), "/TM/Timers/%s", pszDesc);
     1574                    tmR3TimerClockName(pTimer), "/TM/Timers/%s", pTimer->szName);
    15651575    STAMR3RegisterF(pVM, &pTimer->StatCritSectEnter, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL,
    1566                     "", "/TM/Timers/%s/CritSectEnter", pszDesc);
     1576                    "", "/TM/Timers/%s/CritSectEnter", pTimer->szName);
    15671577    STAMR3RegisterF(pVM, &pTimer->StatGet,          STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS,
    1568                     "", "/TM/Timers/%s/Get", pszDesc);
     1578                    "", "/TM/Timers/%s/Get", pTimer->szName);
    15691579    STAMR3RegisterF(pVM, &pTimer->StatSetAbsolute,  STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS,
    1570                     "", "/TM/Timers/%s/SetAbsolute", pszDesc);
     1580                    "", "/TM/Timers/%s/SetAbsolute", pTimer->szName);
    15711581    STAMR3RegisterF(pVM, &pTimer->StatSetRelative,  STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS,
    1572                     "", "/TM/Timers/%s/SetRelative", pszDesc);
     1582                    "", "/TM/Timers/%s/SetRelative", pTimer->szName);
    15731583    STAMR3RegisterF(pVM, &pTimer->StatStop,         STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS,
    1574                     "", "/TM/Timers/%s/Stop", pszDesc);
     1584                    "", "/TM/Timers/%s/Stop", pTimer->szName);
    15751585#endif
    15761586
    … …  
    15901600 * @param   pvUser          The user argument to the callback.
    15911601 * @param   fFlags          Timer creation flags, see grp_tm_timer_flags.
    1592  * @param   pszDesc         Pointer to description string which must stay around
    1593  *                          until the timer is fully destroyed (i.e. a bit after TMTimerDestroy()).
     1602 * @param   pszName         Timer name (will be copied).  Max 31 chars.
    15941603 * @param   phTimer         Where to store the timer handle on success.
    15951604 */
    15961605VMM_INT_DECL(int) TMR3TimerCreateDevice(PVM pVM, PPDMDEVINS pDevIns, TMCLOCK enmClock,
    15971606                                        PFNTMTIMERDEV pfnCallback, void *pvUser,
    1598                                         uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer)
     1607                                        uint32_t fFlags, const char *pszName, PTMTIMERHANDLE phTimer)
    15991608{
    16001609    AssertReturn(!(fFlags & ~(TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0 | TMTIMER_FLAGS_NO_RING0)),
    … …  
    16051614     */
    16061615    PTMTIMER pTimer;
    1607     int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszDesc, &pTimer);
     1616    int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszName, &pTimer);
    16081617    if (RT_SUCCESS(rc))
    16091618    {
    … …  
    16151624            pTimer->pCritSect = PDMR3DevGetCritSect(pVM, pDevIns);
    16161625        *phTimer = pTimer->hSelf;
    1617         Log(("TM: Created device timer %p clock %d callback %p '%s'\n", phTimer, enmClock, pfnCallback, pszDesc));
     1626        Log(("TM: Created device timer %p clock %d callback %p '%s'\n", phTimer, enmClock, pfnCallback, pszName));
    16181627    }
    16191628
    … …  
    16341643 * @param   pvUser          The user argument to the callback.
    16351644 * @param   fFlags          Timer creation flags, see grp_tm_timer_flags.
    1636  * @param   pszDesc         Pointer to description string which must stay around
    1637  *                          until the timer is fully destroyed (i.e. a bit after TMTimerDestroy()).
     1645 * @param   pszName         Timer name (will be copied).  Max 31 chars.
    16381646 * @param   phTimer         Where to store the timer handle on success.
    16391647 */
    16401648VMM_INT_DECL(int) TMR3TimerCreateUsb(PVM pVM, PPDMUSBINS pUsbIns, TMCLOCK enmClock,
    16411649                                     PFNTMTIMERUSB pfnCallback, void *pvUser,
    1642                                      uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer)
     1650                                     uint32_t fFlags, const char *pszName, PTMTIMERHANDLE phTimer)
    16431651{
    16441652    AssertReturn(!(fFlags & ~(TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_NO_RING0)), VERR_INVALID_PARAMETER);
    … …  
    16481656     */
    16491657    PTMTIMER pTimer;
    1650     int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszDesc, &pTimer);
     1658    int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszName, &pTimer);
    16511659    if (RT_SUCCESS(rc))
    16521660    {
    … …  
    16631671        //}
    16641672        *phTimer = pTimer->hSelf;
    1665         Log(("TM: Created USB device timer %p clock %d callback %p '%s'\n", *phTimer, enmClock, pfnCallback, pszDesc));
     1673        Log(("TM: Created USB device timer %p clock %d callback %p '%s'\n", *phTimer, enmClock, pfnCallback, pszName));
    16661674    }
    16671675
    … …  
    16801688 * @param   pvUser          The user argument to the callback.
    16811689 * @param   fFlags          Timer creation flags, see grp_tm_timer_flags.
    1682  * @param   pszDesc         Pointer to description string which must stay around
    1683  *                          until the timer is fully destroyed (i.e. a bit after TMTimerDestroy()).
     1690 * @param   pszName         Timer name (will be copied).  Max 31 chars.
    16841691 * @param   phTimer         Where to store the timer handle on success.
    16851692 */
    16861693VMM_INT_DECL(int) TMR3TimerCreateDriver(PVM pVM, PPDMDRVINS pDrvIns, TMCLOCK enmClock, PFNTMTIMERDRV pfnCallback, void *pvUser,
    1687                                         uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer)
     1694                                        uint32_t fFlags, const char *pszName, PTMTIMERHANDLE phTimer)
    16881695{
    16891696    AssertReturn(!(fFlags & ~(TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0 | TMTIMER_FLAGS_NO_RING0)),
    … …  
    16941701     */
    16951702    PTMTIMER pTimer;
    1696     int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszDesc, &pTimer);
     1703    int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszName, &pTimer);
    16971704    if (RT_SUCCESS(rc))
    16981705    {
    … …  
    17021709        pTimer->pvUser          = pvUser;
    17031710        *phTimer = pTimer->hSelf;
    1704         Log(("TM: Created device timer %p clock %d callback %p '%s'\n", *phTimer, enmClock, pfnCallback, pszDesc));
     1711        Log(("TM: Created device timer %p clock %d callback %p '%s'\n", *phTimer, enmClock, pfnCallback, pszName));
    17051712    }
    17061713
    … …  
    17181725 * @param   pvUser          User argument to be passed to the callback.
    17191726 * @param   fFlags          Timer creation flags, see grp_tm_timer_flags.
    1720  * @param   pszDesc         Pointer to description string which must stay around
    1721  *                          until the timer is fully destroyed (i.e. a bit after TMTimerDestroy()).
     1727 * @param   pszName         Timer name (will be copied).  Max 31 chars.
    17221728 * @param   phTimer         Where to store the timer handle on success.
    17231729 */
    17241730VMMR3DECL(int) TMR3TimerCreate(PVM pVM, TMCLOCK enmClock, PFNTMTIMERINT pfnCallback, void *pvUser,
    1725                                uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer)
     1731                               uint32_t fFlags, const char *pszName, PTMTIMERHANDLE phTimer)
    17261732{
    17271733    AssertReturn(fFlags & (TMTIMER_FLAGS_RING0 | TMTIMER_FLAGS_NO_RING0), VERR_INVALID_FLAGS);
    … …  
    17331739     */
    17341740    PTMTIMER pTimer;
    1735     int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszDesc, &pTimer);
     1741    int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszName, &pTimer);
    17361742    if (RT_SUCCESS(rc))
    17371743    {
    … …  
    17401746        pTimer->pvUser              = pvUser;
    17411747        *phTimer = pTimer->hSelf;
    1742         Log(("TM: Created internal timer %p clock %d callback %p '%s'\n", pTimer, enmClock, pfnCallback, pszDesc));
     1748        Log(("TM: Created internal timer %p clock %d callback %p '%s'\n", pTimer, enmClock, pfnCallback, pszName));
    17431749    }
    17441750
    … …  
    17641770    AssertMsg(   !pTimer->pCritSect
    17651771              || VMR3GetState(pVM) != VMSTATE_RUNNING
    1766               || PDMCritSectIsOwner(pTimer->pCritSect), ("%s\n", pTimer->pszDesc));
     1772              || PDMCritSectIsOwner(pTimer->pCritSect), ("%s\n", pTimer->szName));
    17671773
    17681774    /*
    … …  
    17771783         */
    17781784        TMTIMERSTATE const enmState = pTimer->enmState;
    1779         Log2(("TMTimerDestroy: %p:{.enmState=%s, .pszDesc='%s'} cRetries=%d\n",
    1780               pTimer, tmTimerState(enmState), R3STRING(pTimer->pszDesc), cRetries));
     1785        Log2(("TMTimerDestroy: %p:{.enmState=%s, .szName='%s'} cRetries=%d\n",
     1786              pTimer, tmTimerState(enmState), pTimer->szName, cRetries));
    17811787        switch (enmState)
    17821788        {
    … …  
    18061812            case TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE:
    18071813            case TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE:
    1808                 AssertMsgFailed(("%p:.enmState=%s %s\n", pTimer, tmTimerState(enmState), pTimer->pszDesc));
     1814                AssertMsgFailed(("%p:.enmState=%s %s\n", pTimer, tmTimerState(enmState), pTimer->szName));
    18091815                TM_UNLOCK_TIMERS(pVM);
    18101816                if (!RTThreadYield())
    18111817                    RTThreadSleep(1);
    1812                 AssertMsgReturn(cRetries > 0, ("Failed waiting for stable state. state=%d (%s)\n", pTimer->enmState, pTimer->pszDesc),
     1818                AssertMsgReturn(cRetries > 0, ("Failed waiting for stable state. state=%d (%s)\n", pTimer->enmState, pTimer->szName),
    18131819                                VERR_TM_UNSTABLE_STATE);
    18141820                TM_LOCK_TIMERS(pVM);
    … …  
    18241830
    18251831            default:
    1826                 AssertMsgFailed(("Unknown timer state %d (%s)\n", enmState, R3STRING(pTimer->pszDesc)));
     1832                AssertMsgFailed(("Unknown timer state %d (%s)\n", enmState, pTimer->szName));
    18271833                TM_UNLOCK_TIMERS(pVM);
    18281834                return VERR_TM_UNKNOWN_STATE;
    … …  
    18371843        if (fRc)
    18381844            break;
    1839         AssertMsgFailed(("%p:.enmState=%s %s\n", pTimer, tmTimerState(enmState), pTimer->pszDesc));
     1845        AssertMsgFailed(("%p:.enmState=%s %s\n", pTimer, tmTimerState(enmState), pTimer->szName));
    18401846        TM_UNLOCK_TIMERS(pVM);
    1841         AssertMsgReturn(cRetries > 0, ("Failed waiting for stable state. state=%d (%s)\n", pTimer->enmState, pTimer->pszDesc),
     1847        AssertMsgReturn(cRetries > 0, ("Failed waiting for stable state. state=%d (%s)\n", pTimer->enmState, pTimer->szName),
    18421848                        VERR_TM_UNSTABLE_STATE);
    18431849        TM_LOCK_TIMERS(pVM);
    … …  
    18811887#ifdef VBOX_WITH_STATISTICS
    18821888    char szPrefix[128];
    1883     RTStrPrintf(szPrefix, sizeof(szPrefix), "/TM/Timers/%s", pTimer->pszDesc);
     1889    RTStrPrintf(szPrefix, sizeof(szPrefix), "/TM/Timers/%s", pTimer->szName);
    18841890    STAMR3DeregisterByPrefix(pVM->pUVM, szPrefix);
    18851891#endif
    … …  
    22662272            STAM_PROFILE_STOP(&pTimer->StatCritSectEnter, Locking);
    22672273        }
    2268         Log2(("tmR3TimerQueueRun: %p:{.enmState=%s, .enmClock=%d, .enmType=%d, u64Expire=%llx (now=%llx) .pszDesc=%s}\n",
    2269               pTimer, tmTimerState(pTimer->enmState), pTimer->enmClock, pTimer->enmType, pTimer->u64Expire, u64Now, pTimer->pszDesc));
     2274        Log2(("tmR3TimerQueueRun: %p:{.enmState=%s, .enmClock=%d, .enmType=%d, u64Expire=%llx (now=%llx) .szName='%s'}\n",
     2275              pTimer, tmTimerState(pTimer->enmState), pTimer->enmClock, pTimer->enmType, pTimer->u64Expire, u64Now, pTimer->szName));
    22702276        bool fRc;
    22712277        TM_TRY_SET_STATE(pTimer, TMTIMERSTATE_EXPIRED_GET_UNLINK, TMTIMERSTATE_ACTIVE, fRc);
    … …  
    22982304                case TMTIMERTYPE_INTERNAL:  pTimer->u.Internal.pfnTimer(pVM, pTimer->hSelf, pTimer->pvUser); break;
    22992305                default:
    2300                     AssertMsgFailed(("Invalid timer type %d (%s)\n", pTimer->enmType, pTimer->pszDesc));
     2306                    AssertMsgFailed(("Invalid timer type %d (%s)\n", pTimer->enmType, pTimer->szName));
    23012307                    break;
    23022308            }
    … …  
    24592465        }
    24602466
    2461         Log2(("tmR3TimerQueueRun: %p:{.enmState=%s, .enmClock=%d, .enmType=%d, u64Expire=%llx (now=%llx) .pszDesc=%s}\n",
    2462               pTimer, tmTimerState(pTimer->enmState), pTimer->enmClock, pTimer->enmType, pTimer->u64Expire, u64Now, pTimer->pszDesc));
     2467        Log2(("tmR3TimerQueueRun: %p:{.enmState=%s, .enmClock=%d, .enmType=%d, u64Expire=%llx (now=%llx) .szName='%s'}\n",
     2468              pTimer, tmTimerState(pTimer->enmState), pTimer->enmClock, pTimer->enmType, pTimer->u64Expire, u64Now, pTimer->szName));
    24632469
    24642470        /* Advance the clock - don't permit timers to be out of order or armed
    24652471           in the 'past'. */
    24662472#ifdef VBOX_STRICT
    2467         AssertMsg(pTimer->u64Expire >= u64Prev, ("%'RU64 < %'RU64 %s\n", pTimer->u64Expire, u64Prev, pTimer->pszDesc));
     2473        AssertMsg(pTimer->u64Expire >= u64Prev, ("%'RU64 < %'RU64 %s\n", pTimer->u64Expire, u64Prev, pTimer->szName));
    24682474        u64Prev = pTimer->u64Expire;
    24692475#endif
    … …  
    24822488            case TMTIMERTYPE_INTERNAL:  pTimer->u.Internal.pfnTimer(pVM, pTimer->hSelf, pTimer->pvUser); break;
    24832489            default:
    2484                 AssertMsgFailed(("Invalid timer type %d (%s)\n", pTimer->enmType, pTimer->pszDesc));
     2490                AssertMsgFailed(("Invalid timer type %d (%s)\n", pTimer->enmType, pTimer->szName));
    24852491                break;
    24862492        }
    … …  
    27132719    PTMTIMER pTimer;
    27142720    TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
    2715     LogFlow(("TMR3TimerSave: %p:{enmState=%s, .pszDesc={%s}} pSSM=%p\n", pTimer, tmTimerState(pTimer->enmState), pTimer->pszDesc, pSSM));
     2721    LogFlow(("TMR3TimerSave: %p:{enmState=%s, .szName='%s'} pSSM=%p\n", pTimer, tmTimerState(pTimer->enmState), pTimer->szName, pSSM));
    27162722
    27172723    switch (pTimer->enmState)
    … …  
    27242730        case TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE:
    27252731        case TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE:
    2726             AssertMsgFailed(("u64Expire is being updated! (%s)\n", pTimer->pszDesc));
     2732            AssertMsgFailed(("u64Expire is being updated! (%s)\n", pTimer->szName));
    27272733            if (!RTThreadYield())
    27282734                RTThreadSleep(1);
    … …  
    27382744        case TMTIMERSTATE_DESTROY:
    27392745        case TMTIMERSTATE_FREE:
    2740             AssertMsgFailed(("Invalid timer state %d %s (%s)\n", pTimer->enmState, tmTimerState(pTimer->enmState), pTimer->pszDesc));
     2746            AssertMsgFailed(("Invalid timer state %d %s (%s)\n", pTimer->enmState, tmTimerState(pTimer->enmState), pTimer->szName));
    27412747            return SSMR3HandleSetStatus(pSSM, VERR_TM_INVALID_STATE);
    27422748    }
    27432749
    2744     AssertMsgFailed(("Unknown timer state %d (%s)\n", pTimer->enmState, pTimer->pszDesc));
     2750    AssertMsgFailed(("Unknown timer state %d (%s)\n", pTimer->enmState, pTimer->szName));
    27452751    return SSMR3HandleSetStatus(pSSM, VERR_TM_UNKNOWN_STATE);
    27462752}
    … …  
    27612767    TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
    27622768    Assert(pSSM);
    2763     LogFlow(("TMR3TimerLoad: %p:{enmState=%s, .pszDesc={%s}} pSSM=%p\n", pTimer, tmTimerState(pTimer->enmState), pTimer->pszDesc, pSSM));
     2769    LogFlow(("TMR3TimerLoad: %p:{enmState=%s, .szName='%s'} pSSM=%p\n", pTimer, tmTimerState(pTimer->enmState), pTimer->szName, pSSM));
    27642770
    27652771    /*
    … …  
    29142920    AssertReturn(!pTimer->pCritSect, VERR_ALREADY_EXISTS);
    29152921    AssertReturn(pTimer->enmState == TMTIMERSTATE_STOPPED, VERR_INVALID_STATE);
    2916     LogFlow(("pTimer=%p (%s) pCritSect=%p (%s)\n", pTimer, pTimer->pszDesc, pCritSect, pszName));
     2922    LogFlow(("pTimer=%p (%s) pCritSect=%p (%s)\n", pTimer, pTimer->szName, pCritSect, pszName));
    29172923
    29182924    pTimer->pCritSect = pCritSect;
    … …  
    37003706                        pTimer->uHzHint,
    37013707                        tmTimerState(pTimer->enmState),
    3702                         pTimer->pszDesc);
     3708                        pTimer->szName);
    37033709    }
    37043710    TM_UNLOCK_TIMERS(pVM);
    … …  
    37463752                            pTimer->uHzHint,
    37473753                            tmTimerState(pTimer->enmState),
    3748                             pTimer->pszDesc);
     3754                            pTimer->szName);
    37493755        }
    37503756        TM_UNLOCK_TIMERS(pVM);

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

    r87766 r87773  
    12731273    /** Synthetic timer count MSR. */
    12741274    uint64_t                    uStimerCountMsr;
    1275     /** Timer description. */
    1276     char                        szTimerDesc[24];
    1277 
    12781275} GIMHVSTIMER;
    12791276/** Pointer to per-VCPU Hyper-V synthetic timer. */

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

    r87771 r87773  
    190190    /** Pointer to the previous timer in the list of all created timers. (TM::pTimers) */
    191191    PTMTIMERR3              pBigPrev;
    192 //    /** The timer name. */
    193 //    char                    szName[32]
    194     /** Pointer to the timer description. */
    195     R3PTRTYPE(const char *) pszDesc;
    196 #if HC_ARCH_BITS == 32
    197     uint32_t                padding0; /**< pad structure to multiple of 8 bytes. */
    198 #endif
     192    /** The timer name. */
     193    char                    szName[32];
    199194
    200195#ifdef VBOX_WITH_STATISTICS
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette