Changeset 85949 in vbox for trunk

Timestamp:

Aug 31, 2020 10:22:50 AM (4 years ago)

Author:

vboxsync

Message:

Runtime/RTTraceLogRdr: Add API to extract a given set of values from multiple events at once

Location:

trunk

Files:

• include/iprt/mangling.h (modified) (1 diff)
• include/iprt/tracelog.h (modified) (2 diffs)
• src/VBox/Runtime/common/log/tracelogreader.cpp (modified) (4 diffs)

trunk/include/iprt/mangling.h

@@ -2622 +2622 @@
 # define RTTraceLogRdrEvtGetTs                          RT_MANGLER(RTTraceLogRdrEvtGetTs)
 # define RTTraceLogRdrEvtIsGrouped                      RT_MANGLER(RTTraceLogRdrEvtIsGrouped)
+# define RTTraceLogRdrEvtMapToStruct                    RT_MANGLER(RTTraceLogRdrEvtMapToStruct)
+# define RTTraceLogRdrEvtMapFree                        RT_MANGLER(RTTraceLogRdrEvtMapFree)
 # define RTTraceLogRdrEvtPoll                           RT_MANGLER(RTTraceLogRdrEvtPoll)
 # define RTTraceLogRdrEvtQueryVal                       RT_MANGLER(RTTraceLogRdrEvtQueryVal)

trunk/include/iprt/tracelog.h

@@ -214 +214 @@
 
 
+/**
+ * Item mapping descriptor.
+ */
+typedef struct RTTRACELOGRDRMAPITEM
+{
+    /** The item name. */
+    const char                  *pszName;
+    /** The value type to map the item to. */
+    RTTRACELOGTYPE              enmType;
+} RTTRACELOGRDRMAPITEM;
+/** Pointer to a mapping item descriptor. */
+typedef RTTRACELOGRDRMAPITEM *PRTTRACELOGRDRMAPITEM;
+/** Pointer to a const mapping item descriptor. */
+typedef const RTTRACELOGRDRMAPITEM *PCRTTRACELOGRDRMAPITEM;
+
+
+/**
+ * Event item to value mapping descriptor for RTTraceLogRdrEvtMapToStruct().
+ */
+typedef struct RTTRACELOGRDRMAPDESC
+{
+    /** The event ID this mapping describes. */
+    const char                  *pszEvtId;
+    /** Number of event items to extract. */
+    uint32_t                    cEvtItems;
+    /** Pointer to the event items to extract (in the given order). */
+    PCRTTRACELOGRDRMAPITEM      paMapItems;
+} RTTRACELOGRDRMAPDESC;
+/** Pointer to a event mapping descriptor. */
+typedef RTTRACELOGRDRMAPDESC *PRTTRACELOGRDRMAPDESC;
+/** Pointer to a const event mapping descriptor. */
+typedef const RTTRACELOGRDRMAPDESC *PCRTTRACELOGRDRMAPDESC;
+
+
+/**
+ * Header for an event mapped to a binary.
+ */
+typedef struct RTTRACELOGRDREVTHDR
+{
+    /** The mapping descriptor this event was mapped to. */
+    PCRTTRACELOGRDRMAPDESC      pEvtMapDesc;
+    /** The event descriptor as extracted from the event log. */
+    PCRTTRACELOGEVTDESC         pEvtDesc;
+    /** Sequence number of the descriptor. */
+    uint64_t                    idSeqNo;
+    /** The timestamp of the event. */
+    uint64_t                    tsEvt;
+    /** Pointer to the event data items. */
+    PCRTTRACELOGEVTVAL          paEvtItems;
+} RTTRACELOGRDREVTHDR;
+/** Pointer to an event header. */
+typedef RTTRACELOGRDREVTHDR *PRTTRACELOGRDREVTHDR;
+/** Pointer to a const event header. */
+typedef const RTTRACELOGRDREVTHDR *PCRTTRACELOGRDREVTHDR;
+
+
 /** Event group ID. */
 typedef uint64_t                   RTTRACELOGEVTGRPID;
@@ -517 +573 @@
 
 /**
+ * Extracts the given number of events from the given trace log reader instance returning
+ * and array of events with the values filled in from the mapping descriptor.
+ *
+ * @returns IPRT status code.
+ * @param   hTraceLogRdr        The trace log reader instance handle.
+ * @param   fFlags              Flags controlling the behavior, MBZ.
+ * @param   cEvts               Number of events to extract, UINT32_MAX to map all immediately available events.
+ * @param   paMapDesc           Pointer to an array of mapping descriptors describing how to map events.
+ * @param   ppaEvtHdr           Where to return the pointer to the allocated array of event headers on success.
+ * @param   pcEvts              Where to store the returned number of events on success.
+ */
+RTDECL(int) RTTraceLogRdrEvtMapToStruct(RTTRACELOGRDR hTraceLogRdr, uint32_t fFlags, uint32_t cEvts,
+                                        PCRTTRACELOGRDRMAPDESC paMapDesc, PCRTTRACELOGRDREVTHDR *ppaEvtHdr,
+                                        uint32_t *pcEvts);
+
+
+/**
+ * Frees all resources of the given array of event headers as allocated by RTTraceLogRdrEvtMapToStruct().
+ *
+ * @returns nothing.
+ * @param   paEvtHdr            Pointer to the array of events as returned by RTTraceLogRdrEvtMapToStruct().
+ * @param   cEvts               Number of events as returned by RTTraceLogRdrEvtMapToStruct().
+ */
+RTDECL(void) RTTraceLogRdrEvtMapFree(PCRTTRACELOGRDREVTHDR paEvtHdr, uint32_t cEvts);
+
+
+/**
  * Frees a previously created iterator.
  *

trunk/src/VBox/Runtime/common/log/tracelogreader.cpp

@@ -1202 +1202 @@
  * @param   ppEvtItemDesc       Where to store the event item descriptor.
  */
-static int rtTraceLogRdrEvtResolveData(PRTTRACELOGRDREVTINT pEvt, const char *pszName, uint32_t *poffData,
+static int rtTraceLogRdrEvtResolveData(PCRTTRACELOGRDREVTINT pEvt, const char *pszName, uint32_t *poffData,
                                        size_t *pcbEvtData, PPCRTTRACELOGEVTITEMDESC ppEvtItemDesc)
 {
@@ -1238 +1238 @@
  * @param   pVal                The value to fill.
  */
-static int rtTraceLogRdrEvtFillVal(PRTTRACELOGRDREVTINT pEvt, uint32_t offData, size_t cbData, PCRTTRACELOGEVTITEMDESC pEvtItemDesc,
+static int rtTraceLogRdrEvtFillVal(PCRTTRACELOGRDREVTINT pEvt, uint32_t offData, size_t cbData, PCRTTRACELOGEVTITEMDESC pEvtItemDesc,
                                    PRTTRACELOGEVTVAL pVal)
 {
     PRTTRACELOGRDRINT pThis = pEvt->pRdr;
-    uint8_t *pbData = &pEvt->abEvtData[offData];
+    const uint8_t *pbData = &pEvt->abEvtData[offData];
 
     pVal->pItemDesc = pEvtItemDesc;
@@ -1452 +1452 @@
 
     return VINF_SUCCESS;
+}
+
+
+/**
+ * Finds the mapping descriptor for the given event.
+ *
+ * @returns Pointer to the mapping descriptor or NULL if not found.
+ * @param   paMapDesc           Pointer to the array of mapping descriptors.
+ * @param   pEvt                The event to look for the matching mapping descriptor.
+ */
+static PCRTTRACELOGRDRMAPDESC rtTraceLogRdrMapDescFindForEvt(PCRTTRACELOGRDRMAPDESC paMapDesc, PCRTTRACELOGRDREVTINT pEvt)
+{
+    AssertPtrReturn(paMapDesc, NULL);
+    AssertPtrReturn(pEvt, NULL);
+
+    while (paMapDesc->pszEvtId)
+    {
+        if (!RTStrCmp(paMapDesc->pszEvtId, pEvt->pEvtDesc->EvtDesc.pszId))
+            return paMapDesc;
+
+        paMapDesc++;
+    }
+
+    return NULL;
+}
+
+
+/**
+ * Fills the given event header with data from the given event using the matching mapping descriptor.
+ *
+ * @returns IPRT statsu code.
+ * @param   pEvtHdr             The event header to fill.
+ * @param   pMapDesc            The mapping descriptor to use.
+ * @param   pEvt                The raw event to get the data from.
+ */
+static int rtTraceLogRdrMapFillEvt(PRTTRACELOGRDREVTHDR pEvtHdr, PCRTTRACELOGRDRMAPDESC pMapDesc, PCRTTRACELOGRDREVTINT pEvt)
+{
+    int rc = VINF_SUCCESS;
+
+    /* Fill in the status parts. */
+    pEvtHdr->pEvtMapDesc = pMapDesc;
+    pEvtHdr->pEvtDesc    = &pEvt->pEvtDesc->EvtDesc;
+    pEvtHdr->idSeqNo     = pEvt->u64SeqNo;
+    pEvtHdr->tsEvt       = pEvt->u64Ts;
+    pEvtHdr->paEvtItems  = NULL;
+
+    /* Now the individual items if any. */
+    if (pMapDesc->cEvtItems)
+    {
+        /* Allocate values for the items. */
+        pEvtHdr->paEvtItems = (PCRTTRACELOGEVTVAL)RTMemAllocZ(pMapDesc->cEvtItems * sizeof(RTTRACELOGEVTVAL));
+        if (RT_LIKELY(pEvtHdr->paEvtItems))
+        {
+            for (uint32_t i = 0; (i < pMapDesc->cEvtItems) && RT_SUCCESS(rc); i++)
+            {
+                uint32_t offData = 0;
+                size_t cbData = 0;
+                PCRTTRACELOGEVTITEMDESC pEvtItemDesc = NULL;
+                rc = rtTraceLogRdrEvtResolveData(pEvt, pMapDesc->paMapItems[i].pszName, &offData, &cbData, &pEvtItemDesc);
+                if (RT_SUCCESS(rc))
+                    rc = rtTraceLogRdrEvtFillVal(pEvt, offData, cbData, pEvtItemDesc, (PRTTRACELOGEVTVAL)&pEvtHdr->paEvtItems[i]);
+            }
+
+            if (RT_FAILURE(rc))
+            {
+                RTMemFree((void *)pEvtHdr->paEvtItems);
+                pEvtHdr->paEvtItems = NULL;
+            }
+        }
+        else
+            rc = VERR_NO_MEMORY;
+    }
+
+    return rc;
 }
 
@@ -1619 +1693 @@
 
 
+RTDECL(int) RTTraceLogRdrEvtMapToStruct(RTTRACELOGRDR hTraceLogRdr, uint32_t fFlags, uint32_t cEvts,
+                                        PCRTTRACELOGRDRMAPDESC paMapDesc, PCRTTRACELOGRDREVTHDR *ppaEvtHdr,
+                                        uint32_t *pcEvts)
+{
+    RT_NOREF(fFlags);
+
+    PRTTRACELOGRDRINT pThis = hTraceLogRdr;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertPtrReturn(paMapDesc, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(ppaEvtHdr, VERR_INVALID_POINTER);
+    AssertPtrReturn(pcEvts, VERR_INVALID_POINTER);
+
+    int rc = VINF_SUCCESS;
+    uint32_t cEvtsAlloc = cEvts != UINT32_MAX ? cEvts : _4K;
+    PRTTRACELOGRDREVTHDR paEvtHdr = (PRTTRACELOGRDREVTHDR)RTMemAllocZ(cEvtsAlloc * sizeof(*paEvtHdr));
+    if (RT_LIKELY(paEvtHdr))
+    {
+        uint32_t cEvtsRecv = 0;
+
+        while (   RT_SUCCESS(rc)
+               && cEvtsRecv < cEvts)
+        {
+            RTTRACELOGRDRPOLLEVT enmEvt = RTTRACELOGRDRPOLLEVT_INVALID;
+            rc = RTTraceLogRdrEvtPoll(pThis, &enmEvt, 0 /*cMsTimeout*/);
+            if (   RT_SUCCESS(rc)
+                && enmEvt == RTTRACELOGRDRPOLLEVT_TRACE_EVENT_RECVD)
+            {
+                /* Find the mapping descriptor. */
+                PRTTRACELOGRDREVTINT pEvt = NULL;
+                rc = RTTraceLogRdrQueryLastEvt(hTraceLogRdr, &pEvt);
+                if (RT_SUCCESS(rc))
+                {
+                    PCRTTRACELOGRDRMAPDESC pMapDesc = rtTraceLogRdrMapDescFindForEvt(paMapDesc, pEvt);
+                    if (pMapDesc)
+                    {
+                        if (cEvtsRecv == cEvtsAlloc)
+                        {
+                            Assert(cEvts == UINT32_MAX);
+                            PRTTRACELOGRDREVTHDR paEvtHdrNew = (PRTTRACELOGRDREVTHDR)RTMemRealloc(paEvtHdr, (cEvtsAlloc + _4K) * sizeof(*paEvtHdr));
+                            if (RT_LIKELY(paEvtHdrNew))
+                            {
+                                paEvtHdr = paEvtHdrNew;
+                                cEvtsAlloc += _4K;
+                            }
+                            else
+                                rc = VERR_NO_MEMORY;
+                        }
+
+                        if (RT_SUCCESS(rc))
+                            rc = rtTraceLogRdrMapFillEvt(&paEvtHdr[cEvtsRecv++], pMapDesc, pEvt);
+                        cEvtsRecv++;
+                    }
+                    else
+                        rc = VERR_NOT_FOUND;
+                }
+            }
+        }
+
+        if (RT_SUCCESS(rc))
+        {
+            *ppaEvtHdr = paEvtHdr;
+            *pcEvts    = cEvtsRecv;
+        }
+        else
+            RTTraceLogRdrEvtMapFree(paEvtHdr, cEvtsRecv);
+    }
+    else
+        rc = VERR_NO_MEMORY;
+
+    return rc;
+}
+
+
+RTDECL(void) RTTraceLogRdrEvtMapFree(PCRTTRACELOGRDREVTHDR paEvtHdr, uint32_t cEvts)
+{
+    for (uint32_t i = 0; i < cEvts; i++)
+    {
+        if (paEvtHdr[i].paEvtItems)
+            RTMemFree((void *)paEvtHdr[i].paEvtItems);
+    }
+
+    RTMemFree((void *)paEvtHdr);
+}
+
+
 RTDECL(void) RTTraceLogRdrIteratorFree(RTTRACELOGRDRIT hIt)
 {