Changeset 87773 in vbox for trunk/src/VBox/VMM/VMMR3

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/src/VBox/VMM/VMMR3

Files:

• CPUM.cpp (modified) (1 diff)
• GIMHv.cpp (modified) (1 diff)
• PDMDevHlp.cpp (modified) (1 diff)
• PDMDriver.cpp (modified) (1 diff)
• PDMQueue.cpp (modified) (1 diff)
• PDMUsb.cpp (modified) (1 diff)
• TM.cpp (modified) (33 diffs)

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

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

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

@@ -518 +518 @@
 
                 /* Create the timer and associate the context pointers. */
-                RTStrPrintf(&pHvStimer->szTimerDesc[0], sizeof(pHvStimer->szTimerDesc), "Hyper-V[%u] Timer%u", pVCpu->idCpu,
-                            idxStimer);
+                char szName[32];
+                RTStrPrintf(szName, sizeof(szName), "Hyper-V[%u] Timer%u", pVCpu->idCpu, idxStimer);
                 rc = TMR3TimerCreate(pVM, TMCLOCK_VIRTUAL_SYNC, gimR3HvTimerCallback, pHvStimer /* pvUser */,
-                                     TMTIMER_FLAGS_RING0, pHvStimer->szTimerDesc, &pHvStimer->hTimer);
+                                     TMTIMER_FLAGS_RING0, szName, &pHvStimer->hTimer);
                 AssertLogRelRCReturn(rc, rc);
             }

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

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

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

@@ -1325 +1325 @@
     LogFlow(("pdmR3DrvHlp_TimerCreate: caller='%s'/%d: enmClock=%d pfnCallback=%p pvUser=%p fFlags=%#x pszDesc=%p:{%s} phTimer=%p\n",
              pDrvIns->pReg->szName, pDrvIns->iInstance, enmClock, pfnCallback, pvUser, fFlags, pszDesc, pszDesc, phTimer));
+
+    /* Mangle the timer name if there are more than once instance of this driver. */
+    char szName[32];
+    AssertReturn(strlen(pszDesc) < sizeof(szName) - 3, VERR_INVALID_NAME);
+    if (pDrvIns->iInstance > 0)
+    {
+        RTStrPrintf(szName, sizeof(szName), "%s[%u]", pszDesc, pDrvIns->iInstance);
+        pszDesc = szName;
+    }
 
     /* Clear the ring-0 flag if the driver isn't configured for ring-0. */

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

@@ -113 +113 @@
     if (cMilliesInterval)
     {
-        rc = TMR3TimerCreate(pVM, TMCLOCK_REAL, pdmR3QueueTimer, pQueue, TMTIMER_FLAGS_NO_RING0, "Queue timer", &pQueue->hTimer);
+        char szName[32];
+        RTStrPrintf(szName, sizeof(szName), "Queue %s", pQueue->pszName);
+        rc = TMR3TimerCreate(pVM, TMCLOCK_REAL, pdmR3QueueTimer, pQueue, TMTIMER_FLAGS_NO_RING0, szName, &pQueue->hTimer);
         if (RT_SUCCESS(rc))
         {

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

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

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

@@ -1500 +1500 @@
  * @param   enmClock    The timer clock.
  * @param   fFlags      TMTIMER_FLAGS_XXX.
- * @param   pszDesc     The timer description.
+ * @param   pszName     The timer name.
  * @param   ppTimer     Where to store the timer pointer on success.
  */
-static int tmr3TimerCreate(PVM pVM, TMCLOCK enmClock, uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer)
-{
+static int tmr3TimerCreate(PVM pVM, TMCLOCK enmClock, uint32_t fFlags, const char *pszName, PPTMTIMERR3 ppTimer)
+{
+    PTMTIMERR3 pTimer;
+
+    /*
+     * Validate input.
+     */
     VM_ASSERT_EMT(pVM);
     AssertReturn((fFlags & (TMTIMER_FLAGS_RING0 | TMTIMER_FLAGS_NO_RING0)) != (TMTIMER_FLAGS_RING0 | TMTIMER_FLAGS_NO_RING0),
                  VERR_INVALID_FLAGS);
+    AssertPtrReturn(pszName, VERR_INVALID_POINTER);
+    size_t const cchName = strlen(pszName);
+    AssertMsgReturn(cchName < sizeof(pTimer->szName), ("timer name too long: %s\n", pszName), VERR_INVALID_NAME);
+    AssertMsgReturn(cchName > 2,  ("Too short timer name: %s\n", pszName), VERR_INVALID_NAME);
 
     /*
      * Allocate the timer.
      */
-    PTMTIMERR3 pTimer = NULL;
     if (pVM->tm.s.pFree && VM_IS_EMT(pVM))
     {
@@ -1519 +1527 @@
         Log3(("TM: Recycling timer %p, new free head %p.\n", pTimer, pTimer->pBigNext));
     }
+    else
+        pTimer = NULL;
 
     if (!pTimer)
@@ -1542 +1552 @@
     pTimer->pvUser          = NULL;
     pTimer->pCritSect       = NULL;
-    pTimer->pszDesc         = pszDesc;
+    memcpy(pTimer->szName, pszName, cchName);
+    pTimer->szName[cchName] = '\0';
 
     /* insert into the list of created timers. */
@@ -1556 +1567 @@
     TM_UNLOCK_TIMERS(pVM);
 
+#ifdef VBOX_WITH_STATISTICS
     /*
      * Register statistics.
      */
-#ifdef VBOX_WITH_STATISTICS
-
     STAMR3RegisterF(pVM, &pTimer->StatTimer,        STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL,
-                    tmR3TimerClockName(pTimer), "/TM/Timers/%s", pszDesc);
+                    tmR3TimerClockName(pTimer), "/TM/Timers/%s", pTimer->szName);
     STAMR3RegisterF(pVM, &pTimer->StatCritSectEnter, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL,
-                    "", "/TM/Timers/%s/CritSectEnter", pszDesc);
+                    "", "/TM/Timers/%s/CritSectEnter", pTimer->szName);
     STAMR3RegisterF(pVM, &pTimer->StatGet,          STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS,
-                    "", "/TM/Timers/%s/Get", pszDesc);
+                    "", "/TM/Timers/%s/Get", pTimer->szName);
     STAMR3RegisterF(pVM, &pTimer->StatSetAbsolute,  STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS,
-                    "", "/TM/Timers/%s/SetAbsolute", pszDesc);
+                    "", "/TM/Timers/%s/SetAbsolute", pTimer->szName);
     STAMR3RegisterF(pVM, &pTimer->StatSetRelative,  STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS,
-                    "", "/TM/Timers/%s/SetRelative", pszDesc);
+                    "", "/TM/Timers/%s/SetRelative", pTimer->szName);
     STAMR3RegisterF(pVM, &pTimer->StatStop,         STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS,
-                    "", "/TM/Timers/%s/Stop", pszDesc);
+                    "", "/TM/Timers/%s/Stop", pTimer->szName);
 #endif
 
@@ -1590 +1600 @@
  * @param   pvUser          The user argument to the callback.
  * @param   fFlags          Timer creation flags, see grp_tm_timer_flags.
- * @param   pszDesc         Pointer to description string which must stay around
- *                          until the timer is fully destroyed (i.e. a bit after TMTimerDestroy()).
+ * @param   pszName         Timer name (will be copied).  Max 31 chars.
  * @param   phTimer         Where to store the timer handle on success.
  */
 VMM_INT_DECL(int) TMR3TimerCreateDevice(PVM pVM, PPDMDEVINS pDevIns, TMCLOCK enmClock,
                                         PFNTMTIMERDEV pfnCallback, void *pvUser,
-                                        uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer)
+                                        uint32_t fFlags, const char *pszName, PTMTIMERHANDLE phTimer)
 {
     AssertReturn(!(fFlags & ~(TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0 | TMTIMER_FLAGS_NO_RING0)),
@@ -1605 +1614 @@
      */
     PTMTIMER pTimer;
-    int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszDesc, &pTimer);
+    int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszName, &pTimer);
     if (RT_SUCCESS(rc))
     {
@@ -1615 +1624 @@
             pTimer->pCritSect = PDMR3DevGetCritSect(pVM, pDevIns);
         *phTimer = pTimer->hSelf;
-        Log(("TM: Created device timer %p clock %d callback %p '%s'\n", phTimer, enmClock, pfnCallback, pszDesc));
+        Log(("TM: Created device timer %p clock %d callback %p '%s'\n", phTimer, enmClock, pfnCallback, pszName));
     }
 
@@ -1634 +1643 @@
  * @param   pvUser          The user argument to the callback.
  * @param   fFlags          Timer creation flags, see grp_tm_timer_flags.
- * @param   pszDesc         Pointer to description string which must stay around
- *                          until the timer is fully destroyed (i.e. a bit after TMTimerDestroy()).
+ * @param   pszName         Timer name (will be copied).  Max 31 chars.
  * @param   phTimer         Where to store the timer handle on success.
  */
 VMM_INT_DECL(int) TMR3TimerCreateUsb(PVM pVM, PPDMUSBINS pUsbIns, TMCLOCK enmClock,
                                      PFNTMTIMERUSB pfnCallback, void *pvUser,
-                                     uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer)
+                                     uint32_t fFlags, const char *pszName, PTMTIMERHANDLE phTimer)
 {
     AssertReturn(!(fFlags & ~(TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_NO_RING0)), VERR_INVALID_PARAMETER);
@@ -1648 +1656 @@
      */
     PTMTIMER pTimer;
-    int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszDesc, &pTimer);
+    int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszName, &pTimer);
     if (RT_SUCCESS(rc))
     {
@@ -1663 +1671 @@
         //}
         *phTimer = pTimer->hSelf;
-        Log(("TM: Created USB device timer %p clock %d callback %p '%s'\n", *phTimer, enmClock, pfnCallback, pszDesc));
+        Log(("TM: Created USB device timer %p clock %d callback %p '%s'\n", *phTimer, enmClock, pfnCallback, pszName));
     }
 
@@ -1680 +1688 @@
  * @param   pvUser          The user argument to the callback.
  * @param   fFlags          Timer creation flags, see grp_tm_timer_flags.
- * @param   pszDesc         Pointer to description string which must stay around
- *                          until the timer is fully destroyed (i.e. a bit after TMTimerDestroy()).
+ * @param   pszName         Timer name (will be copied).  Max 31 chars.
  * @param   phTimer         Where to store the timer handle on success.
  */
 VMM_INT_DECL(int) TMR3TimerCreateDriver(PVM pVM, PPDMDRVINS pDrvIns, TMCLOCK enmClock, PFNTMTIMERDRV pfnCallback, void *pvUser,
-                                        uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer)
+                                        uint32_t fFlags, const char *pszName, PTMTIMERHANDLE phTimer)
 {
     AssertReturn(!(fFlags & ~(TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0 | TMTIMER_FLAGS_NO_RING0)),
@@ -1694 +1701 @@
      */
     PTMTIMER pTimer;
-    int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszDesc, &pTimer);
+    int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszName, &pTimer);
     if (RT_SUCCESS(rc))
     {
@@ -1702 +1709 @@
         pTimer->pvUser          = pvUser;
         *phTimer = pTimer->hSelf;
-        Log(("TM: Created device timer %p clock %d callback %p '%s'\n", *phTimer, enmClock, pfnCallback, pszDesc));
+        Log(("TM: Created device timer %p clock %d callback %p '%s'\n", *phTimer, enmClock, pfnCallback, pszName));
     }
 
@@ -1718 +1725 @@
  * @param   pvUser          User argument to be passed to the callback.
  * @param   fFlags          Timer creation flags, see grp_tm_timer_flags.
- * @param   pszDesc         Pointer to description string which must stay around
- *                          until the timer is fully destroyed (i.e. a bit after TMTimerDestroy()).
+ * @param   pszName         Timer name (will be copied).  Max 31 chars.
  * @param   phTimer         Where to store the timer handle on success.
  */
 VMMR3DECL(int) TMR3TimerCreate(PVM pVM, TMCLOCK enmClock, PFNTMTIMERINT pfnCallback, void *pvUser,
-                               uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer)
+                               uint32_t fFlags, const char *pszName, PTMTIMERHANDLE phTimer)
 {
     AssertReturn(fFlags & (TMTIMER_FLAGS_RING0 | TMTIMER_FLAGS_NO_RING0), VERR_INVALID_FLAGS);
@@ -1733 +1739 @@
      */
     PTMTIMER pTimer;
-    int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszDesc, &pTimer);
+    int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszName, &pTimer);
     if (RT_SUCCESS(rc))
     {
@@ -1740 +1746 @@
         pTimer->pvUser              = pvUser;
         *phTimer = pTimer->hSelf;
-        Log(("TM: Created internal timer %p clock %d callback %p '%s'\n", pTimer, enmClock, pfnCallback, pszDesc));
+        Log(("TM: Created internal timer %p clock %d callback %p '%s'\n", pTimer, enmClock, pfnCallback, pszName));
     }
 
@@ -1764 +1770 @@
     AssertMsg(   !pTimer->pCritSect
               || VMR3GetState(pVM) != VMSTATE_RUNNING
-              || PDMCritSectIsOwner(pTimer->pCritSect), ("%s\n", pTimer->pszDesc));
+              || PDMCritSectIsOwner(pTimer->pCritSect), ("%s\n", pTimer->szName));
 
     /*
@@ -1777 +1783 @@
          */
         TMTIMERSTATE const enmState = pTimer->enmState;
-        Log2(("TMTimerDestroy: %p:{.enmState=%s, .pszDesc='%s'} cRetries=%d\n",
-              pTimer, tmTimerState(enmState), R3STRING(pTimer->pszDesc), cRetries));
+        Log2(("TMTimerDestroy: %p:{.enmState=%s, .szName='%s'} cRetries=%d\n",
+              pTimer, tmTimerState(enmState), pTimer->szName, cRetries));
         switch (enmState)
         {
@@ -1806 +1812 @@
             case TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE:
             case TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE:
-                AssertMsgFailed(("%p:.enmState=%s %s\n", pTimer, tmTimerState(enmState), pTimer->pszDesc));
+                AssertMsgFailed(("%p:.enmState=%s %s\n", pTimer, tmTimerState(enmState), pTimer->szName));
                 TM_UNLOCK_TIMERS(pVM);
                 if (!RTThreadYield())
                     RTThreadSleep(1);
-                AssertMsgReturn(cRetries > 0, ("Failed waiting for stable state. state=%d (%s)\n", pTimer->enmState, pTimer->pszDesc),
+                AssertMsgReturn(cRetries > 0, ("Failed waiting for stable state. state=%d (%s)\n", pTimer->enmState, pTimer->szName),
                                 VERR_TM_UNSTABLE_STATE);
                 TM_LOCK_TIMERS(pVM);
@@ -1824 +1830 @@
 
             default:
-                AssertMsgFailed(("Unknown timer state %d (%s)\n", enmState, R3STRING(pTimer->pszDesc)));
+                AssertMsgFailed(("Unknown timer state %d (%s)\n", enmState, pTimer->szName));
                 TM_UNLOCK_TIMERS(pVM);
                 return VERR_TM_UNKNOWN_STATE;
@@ -1837 +1843 @@
         if (fRc)
             break;
-        AssertMsgFailed(("%p:.enmState=%s %s\n", pTimer, tmTimerState(enmState), pTimer->pszDesc));
+        AssertMsgFailed(("%p:.enmState=%s %s\n", pTimer, tmTimerState(enmState), pTimer->szName));
         TM_UNLOCK_TIMERS(pVM);
-        AssertMsgReturn(cRetries > 0, ("Failed waiting for stable state. state=%d (%s)\n", pTimer->enmState, pTimer->pszDesc),
+        AssertMsgReturn(cRetries > 0, ("Failed waiting for stable state. state=%d (%s)\n", pTimer->enmState, pTimer->szName),
                         VERR_TM_UNSTABLE_STATE);
         TM_LOCK_TIMERS(pVM);
@@ -1881 +1887 @@
 #ifdef VBOX_WITH_STATISTICS
     char szPrefix[128];
-    RTStrPrintf(szPrefix, sizeof(szPrefix), "/TM/Timers/%s", pTimer->pszDesc);
+    RTStrPrintf(szPrefix, sizeof(szPrefix), "/TM/Timers/%s", pTimer->szName);
     STAMR3DeregisterByPrefix(pVM->pUVM, szPrefix);
 #endif
@@ -2266 +2272 @@
             STAM_PROFILE_STOP(&pTimer->StatCritSectEnter, Locking);
         }
-        Log2(("tmR3TimerQueueRun: %p:{.enmState=%s, .enmClock=%d, .enmType=%d, u64Expire=%llx (now=%llx) .pszDesc=%s}\n",
-              pTimer, tmTimerState(pTimer->enmState), pTimer->enmClock, pTimer->enmType, pTimer->u64Expire, u64Now, pTimer->pszDesc));
+        Log2(("tmR3TimerQueueRun: %p:{.enmState=%s, .enmClock=%d, .enmType=%d, u64Expire=%llx (now=%llx) .szName='%s'}\n",
+              pTimer, tmTimerState(pTimer->enmState), pTimer->enmClock, pTimer->enmType, pTimer->u64Expire, u64Now, pTimer->szName));
         bool fRc;
         TM_TRY_SET_STATE(pTimer, TMTIMERSTATE_EXPIRED_GET_UNLINK, TMTIMERSTATE_ACTIVE, fRc);
@@ -2298 +2304 @@
                 case TMTIMERTYPE_INTERNAL:  pTimer->u.Internal.pfnTimer(pVM, pTimer->hSelf, pTimer->pvUser); break;
                 default:
-                    AssertMsgFailed(("Invalid timer type %d (%s)\n", pTimer->enmType, pTimer->pszDesc));
+                    AssertMsgFailed(("Invalid timer type %d (%s)\n", pTimer->enmType, pTimer->szName));
                     break;
             }
@@ -2459 +2465 @@
         }
 
-        Log2(("tmR3TimerQueueRun: %p:{.enmState=%s, .enmClock=%d, .enmType=%d, u64Expire=%llx (now=%llx) .pszDesc=%s}\n",
-              pTimer, tmTimerState(pTimer->enmState), pTimer->enmClock, pTimer->enmType, pTimer->u64Expire, u64Now, pTimer->pszDesc));
+        Log2(("tmR3TimerQueueRun: %p:{.enmState=%s, .enmClock=%d, .enmType=%d, u64Expire=%llx (now=%llx) .szName='%s'}\n",
+              pTimer, tmTimerState(pTimer->enmState), pTimer->enmClock, pTimer->enmType, pTimer->u64Expire, u64Now, pTimer->szName));
 
         /* Advance the clock - don't permit timers to be out of order or armed
            in the 'past'. */
 #ifdef VBOX_STRICT
-        AssertMsg(pTimer->u64Expire >= u64Prev, ("%'RU64 < %'RU64 %s\n", pTimer->u64Expire, u64Prev, pTimer->pszDesc));
+        AssertMsg(pTimer->u64Expire >= u64Prev, ("%'RU64 < %'RU64 %s\n", pTimer->u64Expire, u64Prev, pTimer->szName));
         u64Prev = pTimer->u64Expire;
 #endif
@@ -2482 +2488 @@
             case TMTIMERTYPE_INTERNAL:  pTimer->u.Internal.pfnTimer(pVM, pTimer->hSelf, pTimer->pvUser); break;
             default:
-                AssertMsgFailed(("Invalid timer type %d (%s)\n", pTimer->enmType, pTimer->pszDesc));
+                AssertMsgFailed(("Invalid timer type %d (%s)\n", pTimer->enmType, pTimer->szName));
                 break;
         }
@@ -2713 +2719 @@
     PTMTIMER pTimer;
     TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
-    LogFlow(("TMR3TimerSave: %p:{enmState=%s, .pszDesc={%s}} pSSM=%p\n", pTimer, tmTimerState(pTimer->enmState), pTimer->pszDesc, pSSM));
+    LogFlow(("TMR3TimerSave: %p:{enmState=%s, .szName='%s'} pSSM=%p\n", pTimer, tmTimerState(pTimer->enmState), pTimer->szName, pSSM));
 
     switch (pTimer->enmState)
@@ -2724 +2730 @@
         case TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE:
         case TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE:
-            AssertMsgFailed(("u64Expire is being updated! (%s)\n", pTimer->pszDesc));
+            AssertMsgFailed(("u64Expire is being updated! (%s)\n", pTimer->szName));
             if (!RTThreadYield())
                 RTThreadSleep(1);
@@ -2738 +2744 @@
         case TMTIMERSTATE_DESTROY:
         case TMTIMERSTATE_FREE:
-            AssertMsgFailed(("Invalid timer state %d %s (%s)\n", pTimer->enmState, tmTimerState(pTimer->enmState), pTimer->pszDesc));
+            AssertMsgFailed(("Invalid timer state %d %s (%s)\n", pTimer->enmState, tmTimerState(pTimer->enmState), pTimer->szName));
             return SSMR3HandleSetStatus(pSSM, VERR_TM_INVALID_STATE);
     }
 
-    AssertMsgFailed(("Unknown timer state %d (%s)\n", pTimer->enmState, pTimer->pszDesc));
+    AssertMsgFailed(("Unknown timer state %d (%s)\n", pTimer->enmState, pTimer->szName));
     return SSMR3HandleSetStatus(pSSM, VERR_TM_UNKNOWN_STATE);
 }
@@ -2761 +2767 @@
     TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
     Assert(pSSM);
-    LogFlow(("TMR3TimerLoad: %p:{enmState=%s, .pszDesc={%s}} pSSM=%p\n", pTimer, tmTimerState(pTimer->enmState), pTimer->pszDesc, pSSM));
+    LogFlow(("TMR3TimerLoad: %p:{enmState=%s, .szName='%s'} pSSM=%p\n", pTimer, tmTimerState(pTimer->enmState), pTimer->szName, pSSM));
 
     /*
@@ -2914 +2920 @@
     AssertReturn(!pTimer->pCritSect, VERR_ALREADY_EXISTS);
     AssertReturn(pTimer->enmState == TMTIMERSTATE_STOPPED, VERR_INVALID_STATE);
-    LogFlow(("pTimer=%p (%s) pCritSect=%p (%s)\n", pTimer, pTimer->pszDesc, pCritSect, pszName));
+    LogFlow(("pTimer=%p (%s) pCritSect=%p (%s)\n", pTimer, pTimer->szName, pCritSect, pszName));
 
     pTimer->pCritSect = pCritSect;
@@ -3700 +3706 @@
                         pTimer->uHzHint,
                         tmTimerState(pTimer->enmState),
-                        pTimer->pszDesc);
+                        pTimer->szName);
     }
     TM_UNLOCK_TIMERS(pVM);
@@ -3746 +3752 @@
                             pTimer->uHzHint,
                             tmTimerState(pTimer->enmState),
-                            pTimer->pszDesc);
+                            pTimer->szName);
         }
         TM_UNLOCK_TIMERS(pVM);