[71492] | 1 | /* $Id: tracelogreader.cpp 103415 2024-02-19 07:52:27Z vboxsync $ */
|
---|
| 2 | /** @file
|
---|
| 3 | * IPRT - Trace log reader.
|
---|
| 4 | */
|
---|
| 5 |
|
---|
| 6 | /*
|
---|
[98103] | 7 | * Copyright (C) 2018-2023 Oracle and/or its affiliates.
|
---|
[71492] | 8 | *
|
---|
[96407] | 9 | * This file is part of VirtualBox base platform packages, as
|
---|
| 10 | * available from https://www.virtualbox.org.
|
---|
[71492] | 11 | *
|
---|
[96407] | 12 | * This program is free software; you can redistribute it and/or
|
---|
| 13 | * modify it under the terms of the GNU General Public License
|
---|
| 14 | * as published by the Free Software Foundation, in version 3 of the
|
---|
| 15 | * License.
|
---|
| 16 | *
|
---|
| 17 | * This program is distributed in the hope that it will be useful, but
|
---|
| 18 | * WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
| 19 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
---|
| 20 | * General Public License for more details.
|
---|
| 21 | *
|
---|
| 22 | * You should have received a copy of the GNU General Public License
|
---|
| 23 | * along with this program; if not, see <https://www.gnu.org/licenses>.
|
---|
| 24 | *
|
---|
[71492] | 25 | * The contents of this file may alternatively be used under the terms
|
---|
| 26 | * of the Common Development and Distribution License Version 1.0
|
---|
[96407] | 27 | * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
|
---|
| 28 | * in the VirtualBox distribution, in which case the provisions of the
|
---|
[71492] | 29 | * CDDL are applicable instead of those of the GPL.
|
---|
| 30 | *
|
---|
| 31 | * You may elect to license modified versions of this file under the
|
---|
| 32 | * terms and conditions of either the GPL or the CDDL or both.
|
---|
[96407] | 33 | *
|
---|
| 34 | * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
|
---|
[71492] | 35 | */
|
---|
| 36 |
|
---|
| 37 |
|
---|
| 38 | /*********************************************************************************************************************************
|
---|
| 39 | * Header Files *
|
---|
| 40 | *********************************************************************************************************************************/
|
---|
| 41 | #include "internal/iprt.h"
|
---|
| 42 | #include <iprt/formats/tracelog.h>
|
---|
| 43 | #include <iprt/tracelog.h>
|
---|
| 44 |
|
---|
| 45 |
|
---|
| 46 | #include <iprt/asm.h>
|
---|
| 47 | #include <iprt/assert.h>
|
---|
| 48 | #include <iprt/err.h>
|
---|
| 49 | #include <iprt/file.h>
|
---|
| 50 | #include <iprt/list.h>
|
---|
| 51 | #include <iprt/log.h>
|
---|
| 52 | #include <iprt/mem.h>
|
---|
| 53 | #include <iprt/semaphore.h>
|
---|
| 54 | #include <iprt/string.h>
|
---|
| 55 | #include <iprt/strcache.h>
|
---|
| 56 | #include <iprt/time.h>
|
---|
| 57 |
|
---|
| 58 | #include "internal/magics.h"
|
---|
| 59 |
|
---|
| 60 |
|
---|
| 61 | /*********************************************************************************************************************************
|
---|
| 62 | * Structures and Typedefs *
|
---|
| 63 | *********************************************************************************************************************************/
|
---|
| 64 | /** Pointer to a trace log reader instance. */
|
---|
| 65 | typedef struct RTTRACELOGRDRINT *PRTTRACELOGRDRINT;
|
---|
| 66 |
|
---|
| 67 | /**
|
---|
| 68 | * State enums the trace log reader can be in.
|
---|
| 69 | */
|
---|
| 70 | typedef enum RTTRACELOGRDRSTATE
|
---|
| 71 | {
|
---|
| 72 | /** Invalid state. */
|
---|
| 73 | RTTRACELOGRDRSTATE_INVALID = 0,
|
---|
| 74 | /** The header is currently being received. */
|
---|
| 75 | RTTRACELOGRDRSTATE_RECV_HDR,
|
---|
| 76 | /** The header description is being received (if available). */
|
---|
| 77 | RTTRACELOGRDRSTATE_RECV_HDR_DESC,
|
---|
| 78 | /** the magic is being received to decide what to do next. */
|
---|
| 79 | RTTRACELOGRDRSTATE_RECV_MAGIC,
|
---|
| 80 | /** The event descriptor is being received. */
|
---|
| 81 | RTTRACELOGRDRSTATE_RECV_EVT_DESC,
|
---|
| 82 | /** The event descriptor ID is being received. */
|
---|
| 83 | RTTRACELOGRDRSTATE_RECV_EVT_DESC_ID,
|
---|
| 84 | /** The event descriptor description is being received. */
|
---|
| 85 | RTTRACELOGRDRSTATE_RECV_EVT_DESC_DESC,
|
---|
| 86 | /** The event item descriptor is being received. */
|
---|
| 87 | RTTRACELOGRDRSTATE_RECV_EVT_ITEM_DESC,
|
---|
| 88 | /** The event item descriptor name is being received. */
|
---|
| 89 | RTTRACELOGRDRSTATE_RECV_EVT_ITEM_DESC_NAME,
|
---|
| 90 | /** The event item descriptor description is being received. */
|
---|
| 91 | RTTRACELOGRDRSTATE_RECV_EVT_ITEM_DESC_DESC,
|
---|
| 92 | /** The event marker is being received. */
|
---|
| 93 | RTTRACELOGRDRSTATE_RECV_EVT_MARKER,
|
---|
| 94 | /** The event data is being received. */
|
---|
| 95 | RTTRACELOGRDRSTATE_RECV_EVT_DATA,
|
---|
| 96 | /** 32bit hack. */
|
---|
[71493] | 97 | RTTRACELOGRDRSTATE_32BIT_HACK = 0x7fffffff
|
---|
[71492] | 98 | } RTTRACELOGRDRSTATE;
|
---|
| 99 |
|
---|
| 100 |
|
---|
| 101 | /** Pointer to internal trace log reader event descriptor. */
|
---|
| 102 | typedef struct RTTRACELOGRDREVTDESC *PRTTRACELOGRDREVTDESC;
|
---|
| 103 | /** Pointer to const internal trace log reader event descriptor. */
|
---|
| 104 | typedef const RTTRACELOGRDREVTDESC *PCRTTRACELOGRDREVTDESC;
|
---|
| 105 |
|
---|
| 106 |
|
---|
| 107 | /**
|
---|
| 108 | * Trace log reader event.
|
---|
| 109 | */
|
---|
| 110 | typedef struct RTTRACELOGRDREVTINT
|
---|
| 111 | {
|
---|
| 112 | /** List node for the global list of events. */
|
---|
[86386] | 113 | RTLISTNODE NdGlob;
|
---|
[71492] | 114 | /** The trace log reader instance the event belongs to. */
|
---|
| 115 | PRTTRACELOGRDRINT pRdr;
|
---|
| 116 | /** Trace log sequence number. */
|
---|
| 117 | uint64_t u64SeqNo;
|
---|
| 118 | /** Marker time stamp. */
|
---|
| 119 | uint64_t u64Ts;
|
---|
| 120 | /** Pointer to the event descriptor, describing the data layout. */
|
---|
| 121 | PCRTTRACELOGRDREVTDESC pEvtDesc;
|
---|
| 122 | /** Parent group ID if assigned. */
|
---|
| 123 | RTTRACELOGEVTGRPID idGrpParent;
|
---|
| 124 | /** Group ID this event belongs to. */
|
---|
| 125 | RTTRACELOGEVTGRPID idGrp;
|
---|
| 126 | /** Pointer to the array holding the non static raw data size values. */
|
---|
| 127 | size_t *pacbRawData;
|
---|
| 128 | /** Overall event data size in bytes, including non static data. */
|
---|
| 129 | size_t cbEvtData;
|
---|
| 130 | /** Event data, variable in size. */
|
---|
[86386] | 131 | RT_FLEXIBLE_ARRAY_EXTENSION
|
---|
| 132 | uint8_t abEvtData[RT_FLEXIBLE_ARRAY];
|
---|
[71492] | 133 | } RTTRACELOGRDREVTINT;
|
---|
| 134 | /** Pointer to a trace log reader event. */
|
---|
| 135 | typedef RTTRACELOGRDREVTINT *PRTTRACELOGRDREVTINT;
|
---|
| 136 | /** Pointer to a const trace log reader event. */
|
---|
| 137 | typedef const RTTRACELOGRDREVTINT *PCRTTRACELOGRDREVTINT;
|
---|
| 138 |
|
---|
| 139 |
|
---|
| 140 | /**
|
---|
| 141 | * Trace log reader internal event descriptor.
|
---|
| 142 | */
|
---|
| 143 | typedef struct RTTRACELOGRDREVTDESC
|
---|
| 144 | {
|
---|
| 145 | /** Overall size of the event data not counting variable raw data items. */
|
---|
| 146 | size_t cbEvtData;
|
---|
| 147 | /** Number of non static raw binary items in the descriptor. */
|
---|
| 148 | uint32_t cRawDataNonStatic;
|
---|
| 149 | /** Current event item descriptor to work on. */
|
---|
| 150 | uint32_t idxEvtItemCur;
|
---|
| 151 | /** Size of the name of the current item to work on. */
|
---|
| 152 | size_t cbStrItemName;
|
---|
| 153 | /** Size of the description of the current item to work on. */
|
---|
| 154 | size_t cbStrItemDesc;
|
---|
| 155 | /** Size of the ID in bytes including the terminator. */
|
---|
| 156 | size_t cbStrId;
|
---|
| 157 | /** Size of the description in bytes including the terminator. */
|
---|
| 158 | size_t cbStrDesc;
|
---|
| 159 | /** Embedded event descriptor. */
|
---|
| 160 | RTTRACELOGEVTDESC EvtDesc;
|
---|
| 161 | /** Array of event item descriptors, variable in size. */
|
---|
[86386] | 162 | RT_FLEXIBLE_ARRAY_EXTENSION
|
---|
| 163 | RTTRACELOGEVTITEMDESC aEvtItemDesc[RT_FLEXIBLE_ARRAY];
|
---|
[71492] | 164 | } RTTRACELOGRDREVTDESC;
|
---|
| 165 |
|
---|
| 166 |
|
---|
| 167 | /**
|
---|
| 168 | * Trace log reader instance data.
|
---|
| 169 | */
|
---|
| 170 | typedef struct RTTRACELOGRDRINT
|
---|
| 171 | {
|
---|
| 172 | /** Magic for identification. */
|
---|
| 173 | uint32_t u32Magic;
|
---|
| 174 | /** Stream out callback. */
|
---|
| 175 | PFNRTTRACELOGRDRSTREAM pfnStreamIn;
|
---|
| 176 | /** Stream close callback .*/
|
---|
| 177 | PFNRTTRACELOGSTREAMCLOSE pfnStreamClose;
|
---|
| 178 | /** Opaque user data passed to the stream callback. */
|
---|
| 179 | void *pvUser;
|
---|
| 180 | /** Mutex protecting the structure. */
|
---|
| 181 | RTSEMMUTEX hMtx;
|
---|
| 182 | /** Current state the reader is in. */
|
---|
| 183 | RTTRACELOGRDRSTATE enmState;
|
---|
| 184 | /** Flag whether to convert all inputs to the host endianess. */
|
---|
| 185 | bool fConvEndianess;
|
---|
| 186 | /** String cache for descriptions and IDs. */
|
---|
| 187 | RTSTRCACHE hStrCache;
|
---|
| 188 | /** Size of the description in characters. */
|
---|
| 189 | size_t cchDesc;
|
---|
| 190 | /** Pointer to the description if set. */
|
---|
| 191 | const char *pszDesc;
|
---|
[86386] | 192 | /** List of received events (PRTTRACELOGRDREVTINT::NdGlob). */
|
---|
[71492] | 193 | RTLISTANCHOR LstEvts;
|
---|
| 194 | /** Number of event descriptors known. */
|
---|
| 195 | uint32_t cEvtDescsCur;
|
---|
| 196 | /** Maximum number of event descriptors currently fitting into the array. */
|
---|
| 197 | uint32_t cEvtDescsMax;
|
---|
| 198 | /** Pointer to the array of event descriptor pointers. */
|
---|
| 199 | PRTTRACELOGRDREVTDESC *papEvtDescs;
|
---|
| 200 | /** Current event descriptor being initialised. */
|
---|
| 201 | PRTTRACELOGRDREVTDESC pEvtDescCur;
|
---|
| 202 | /** The current event being received. */
|
---|
| 203 | PRTTRACELOGRDREVTINT pEvtCur;
|
---|
| 204 | /** Last seen sequence number. */
|
---|
| 205 | uint64_t u64SeqNoLast;
|
---|
| 206 | /** Size of the scratch buffer holding the received data. */
|
---|
| 207 | size_t cbScratch;
|
---|
| 208 | /** Pointer to the scratch buffer. */
|
---|
| 209 | uint8_t *pbScratch;
|
---|
| 210 | /** Current offset into the scratch buffer to write fetched data to. */
|
---|
| 211 | uint32_t offScratch;
|
---|
| 212 | /** Number of bytes left to receive until processing the data. */
|
---|
| 213 | size_t cbRecvLeft;
|
---|
| 214 | /** Starting timestamp fetched from the header. */
|
---|
| 215 | uint64_t u64TsStart;
|
---|
| 216 | /** Size of the pointer type in the trace log. */
|
---|
| 217 | size_t cbTypePtr;
|
---|
| 218 | /** Size of the size_t type in the trace log. */
|
---|
| 219 | size_t cbTypeSize;
|
---|
| 220 | } RTTRACELOGRDRINT;
|
---|
| 221 |
|
---|
| 222 |
|
---|
| 223 | /**
|
---|
| 224 | * Internal reader iterator instance data.
|
---|
| 225 | */
|
---|
| 226 | typedef struct RTTRACELOGRDRITINT
|
---|
| 227 | {
|
---|
| 228 | /** The reader instance this iterator belongs to. */
|
---|
| 229 | PRTTRACELOGRDRINT pRdr;
|
---|
| 230 | /** The current event. */
|
---|
| 231 | PRTTRACELOGRDREVTINT pEvt;
|
---|
| 232 | } RTTRACELOGRDRITINT;
|
---|
| 233 | /** Pointer to an internal reader iterator instance. */
|
---|
| 234 | typedef RTTRACELOGRDRITINT *PRTTRACELOGRDRITINT;
|
---|
| 235 |
|
---|
| 236 |
|
---|
| 237 | /**
|
---|
| 238 | * Trace log handler state callback.
|
---|
| 239 | *
|
---|
| 240 | * @returns IPRT status code.
|
---|
| 241 | * @param pThis The trace log reader instance.
|
---|
| 242 | * @param penmEvt Where to store the event indicator if a user visible event happened.
|
---|
| 243 | * @param pfContinuePoll Where to store the flag whether to continue polling.
|
---|
| 244 | */
|
---|
[85121] | 245 | typedef DECLCALLBACKTYPE(int, FNRTTRACELOGRDRSTATEHANDLER,(PRTTRACELOGRDRINT pThis, RTTRACELOGRDRPOLLEVT *penmEvt,
|
---|
| 246 | bool *pfContinuePoll));
|
---|
[71492] | 247 | /** Pointer to a trace log reader state handler. */
|
---|
| 248 | typedef FNRTTRACELOGRDRSTATEHANDLER *PFNRTTRACELOGRDRSTATEHANDLER;
|
---|
| 249 |
|
---|
[71502] | 250 |
|
---|
[71492] | 251 | /*********************************************************************************************************************************
|
---|
[85160] | 252 | * Internal Functions *
|
---|
[71492] | 253 | *********************************************************************************************************************************/
|
---|
| 254 | static DECLCALLBACK(int) rtTraceLogRdrHdrRecvd(PRTTRACELOGRDRINT pThis, RTTRACELOGRDRPOLLEVT *penmEvt, bool *pfContinuePoll);
|
---|
| 255 | static DECLCALLBACK(int) rtTraceLogRdrHdrDescRecvd(PRTTRACELOGRDRINT pThis, RTTRACELOGRDRPOLLEVT *penmEvt, bool *pfContinuePoll);
|
---|
| 256 | static DECLCALLBACK(int) rtTraceLogRdrMagicRecvd(PRTTRACELOGRDRINT pThis, RTTRACELOGRDRPOLLEVT *penmEvt, bool *pfContinuePoll);
|
---|
| 257 | static DECLCALLBACK(int) rtTraceLogRdrEvtDescRecvd(PRTTRACELOGRDRINT pThis, RTTRACELOGRDRPOLLEVT *penmEvt, bool *pfContinuePoll);
|
---|
| 258 | static DECLCALLBACK(int) rtTraceLogRdrEvtDescIdRecvd(PRTTRACELOGRDRINT pThis, RTTRACELOGRDRPOLLEVT *penmEvt, bool *pfContinuePoll);
|
---|
| 259 | static DECLCALLBACK(int) rtTraceLogRdrEvtDescDescriptionRecvd(PRTTRACELOGRDRINT pThis, RTTRACELOGRDRPOLLEVT *penmEvt, bool *pfContinuePoll);
|
---|
| 260 | static DECLCALLBACK(int) rtTraceLogRdrEvtItemDescRecvd(PRTTRACELOGRDRINT pThis, RTTRACELOGRDRPOLLEVT *penmEvt, bool *pfContinuePoll);
|
---|
| 261 | static DECLCALLBACK(int) rtTraceLogRdrEvtItemDescNameRecvd(PRTTRACELOGRDRINT pThis, RTTRACELOGRDRPOLLEVT *penmEvt, bool *pfContinuePoll);
|
---|
| 262 | static DECLCALLBACK(int) rtTraceLogRdrEvtItemDescDescriptionRecvd(PRTTRACELOGRDRINT pThis, RTTRACELOGRDRPOLLEVT *penmEvt, bool *pfContinuePoll);
|
---|
| 263 | static DECLCALLBACK(int) rtTraceLogRdrEvtMarkerRecvd(PRTTRACELOGRDRINT pThis, RTTRACELOGRDRPOLLEVT *penmEvt, bool *pfContinuePoll);
|
---|
| 264 | static DECLCALLBACK(int) rtTraceLogRdrEvtDataRecvd(PRTTRACELOGRDRINT pThis, RTTRACELOGRDRPOLLEVT *penmEvt, bool *pfContinuePoll);
|
---|
| 265 |
|
---|
| 266 | /**
|
---|
| 267 | * State handlers.
|
---|
[85160] | 268 | * @note The struct wrapper is for working around a Clang nothrow attrib oddity.
|
---|
[71492] | 269 | */
|
---|
[85160] | 270 | static struct { PFNRTTRACELOGRDRSTATEHANDLER pfn; } g_aStateHandlers[] =
|
---|
[71492] | 271 | {
|
---|
[85160] | 272 | { NULL },
|
---|
| 273 | { rtTraceLogRdrHdrRecvd },
|
---|
| 274 | { rtTraceLogRdrHdrDescRecvd },
|
---|
| 275 | { rtTraceLogRdrMagicRecvd },
|
---|
| 276 | { rtTraceLogRdrEvtDescRecvd },
|
---|
| 277 | { rtTraceLogRdrEvtDescIdRecvd },
|
---|
| 278 | { rtTraceLogRdrEvtDescDescriptionRecvd },
|
---|
| 279 | { rtTraceLogRdrEvtItemDescRecvd },
|
---|
| 280 | { rtTraceLogRdrEvtItemDescNameRecvd },
|
---|
| 281 | { rtTraceLogRdrEvtItemDescDescriptionRecvd },
|
---|
| 282 | { rtTraceLogRdrEvtMarkerRecvd },
|
---|
| 283 | { rtTraceLogRdrEvtDataRecvd },
|
---|
| 284 | { NULL }
|
---|
[71492] | 285 | };
|
---|
| 286 |
|
---|
| 287 | /**
|
---|
| 288 | * Wrapper around the stream in callback.
|
---|
| 289 | *
|
---|
[71498] | 290 | * @returns IPRT status code returned by the stream callback.
|
---|
[71492] | 291 | * @param pThis The trace log reader instance.
|
---|
| 292 | * @param pvBuf The data to stream.
|
---|
| 293 | * @param cbBuf Number of bytes to read in.
|
---|
| 294 | * @param pcbRead Where to store the amount of data read.
|
---|
| 295 | * @param cMsTimeout How long to wait for something to arrive.
|
---|
| 296 | */
|
---|
| 297 | DECLINLINE(int) rtTraceLogRdrStreamRead(PRTTRACELOGRDRINT pThis, void *pvBuf, size_t cbBuf,
|
---|
| 298 | size_t *pcbRead, RTMSINTERVAL cMsTimeout)
|
---|
| 299 | {
|
---|
| 300 | return pThis->pfnStreamIn(pThis->pvUser, pvBuf, cbBuf, pcbRead, cMsTimeout);
|
---|
| 301 | }
|
---|
| 302 |
|
---|
| 303 |
|
---|
| 304 | /**
|
---|
| 305 | * Converts the header endianess to the host endianess.
|
---|
| 306 | *
|
---|
| 307 | * @param pHdr The trace log header to convert.
|
---|
| 308 | */
|
---|
| 309 | static void rtTraceLogRdrHdrEndianessConv(PTRACELOGHDR pHdr)
|
---|
| 310 | {
|
---|
| 311 | pHdr->u32Endianess = RT_BSWAP_U32(pHdr->u32Endianess);
|
---|
| 312 | pHdr->u32Version = RT_BSWAP_U32(pHdr->u32Version);
|
---|
| 313 | pHdr->fFlags = RT_BSWAP_U32(pHdr->fFlags);
|
---|
| 314 | pHdr->cbStrDesc = RT_BSWAP_U32(pHdr->cbStrDesc);
|
---|
| 315 | pHdr->u64TsStart = RT_BSWAP_U64(pHdr->u64TsStart);
|
---|
| 316 | }
|
---|
| 317 |
|
---|
| 318 |
|
---|
| 319 | /**
|
---|
| 320 | * Converts the event descriptor endianess to the host endianess.
|
---|
| 321 | *
|
---|
| 322 | * @param pEvtDesc The trace log event descriptor to convert.
|
---|
| 323 | */
|
---|
| 324 | static void rtTraceLogRdrEvtDescEndianessConv(PTRACELOGEVTDESC pEvtDesc)
|
---|
| 325 | {
|
---|
| 326 | pEvtDesc->u32Id = RT_BSWAP_U32(pEvtDesc->u32Id);
|
---|
| 327 | pEvtDesc->u32Severity = RT_BSWAP_U32(pEvtDesc->u32Severity);
|
---|
| 328 | pEvtDesc->cbStrId = RT_BSWAP_U32(pEvtDesc->cbStrId);
|
---|
| 329 | pEvtDesc->cbStrDesc = RT_BSWAP_U32(pEvtDesc->cbStrDesc);
|
---|
| 330 | pEvtDesc->cEvtItems = RT_BSWAP_U32(pEvtDesc->cEvtItems);
|
---|
| 331 | }
|
---|
| 332 |
|
---|
| 333 |
|
---|
| 334 | /**
|
---|
| 335 | * Converts the event item descriptor endianess to host endianess.
|
---|
| 336 | *
|
---|
| 337 | * @param pEvtItemDesc The trace log event item descriptor to convert.
|
---|
| 338 | */
|
---|
| 339 | static void rtTraceLogRdrEvtItemDescEndianessConv(PTRACELOGEVTITEMDESC pEvtItemDesc)
|
---|
| 340 | {
|
---|
| 341 | pEvtItemDesc->cbStrName = RT_BSWAP_U32(pEvtItemDesc->cbStrName);
|
---|
| 342 | pEvtItemDesc->cbStrDesc = RT_BSWAP_U32(pEvtItemDesc->cbStrDesc);
|
---|
| 343 | pEvtItemDesc->u32Type = RT_BSWAP_U32(pEvtItemDesc->u32Type);
|
---|
| 344 | pEvtItemDesc->cbRawData = RT_BSWAP_U32(pEvtItemDesc->cbRawData);
|
---|
| 345 | }
|
---|
| 346 |
|
---|
| 347 |
|
---|
| 348 | /**
|
---|
| 349 | * Converts the event marker endianess to host endianess.
|
---|
| 350 | *
|
---|
| 351 | * @param pEvt The trace log event marker to convert.
|
---|
| 352 | */
|
---|
| 353 | static void rtTraceLogRdrEvtEndianessConv(PTRACELOGEVT pEvt)
|
---|
| 354 | {
|
---|
| 355 | pEvt->u64SeqNo = RT_BSWAP_U64(pEvt->u64SeqNo);
|
---|
| 356 | pEvt->u64Ts = RT_BSWAP_U64(pEvt->u64Ts);
|
---|
| 357 | pEvt->u64EvtGrpId = RT_BSWAP_U64(pEvt->u64EvtGrpId);
|
---|
| 358 | pEvt->u64EvtParentGrpId = RT_BSWAP_U64(pEvt->u64EvtParentGrpId);
|
---|
| 359 | pEvt->fFlags = RT_BSWAP_U32(pEvt->fFlags);
|
---|
| 360 | pEvt->u32EvtDescId = RT_BSWAP_U32(pEvt->u32EvtDescId);
|
---|
| 361 | pEvt->cbEvtData = RT_BSWAP_U32(pEvt->cbEvtData);
|
---|
| 362 | pEvt->cRawEvtDataSz = RT_BSWAP_U32(pEvt->cRawEvtDataSz);
|
---|
| 363 | }
|
---|
| 364 |
|
---|
| 365 |
|
---|
| 366 | /**
|
---|
| 367 | * Converts severity field from stream to API value.
|
---|
| 368 | *
|
---|
| 369 | * @returns API severity enum, RTTRACELOGEVTSEVERITY_INVALID if the supplied stream value
|
---|
| 370 | * is invalid.
|
---|
| 371 | * @param u32Severity The severity value from the stream.
|
---|
| 372 | */
|
---|
| 373 | static RTTRACELOGEVTSEVERITY rtTraceLogRdrConvSeverity(uint32_t u32Severity)
|
---|
| 374 | {
|
---|
| 375 | RTTRACELOGEVTSEVERITY enmSeverity = RTTRACELOGEVTSEVERITY_INVALID;
|
---|
| 376 |
|
---|
| 377 | switch (u32Severity)
|
---|
| 378 | {
|
---|
| 379 | case TRACELOG_EVTDESC_SEVERITY_INFO:
|
---|
| 380 | enmSeverity = RTTRACELOGEVTSEVERITY_INFO;
|
---|
| 381 | break;
|
---|
| 382 | case TRACELOG_EVTDESC_SEVERITY_WARNING:
|
---|
| 383 | enmSeverity = RTTRACELOGEVTSEVERITY_WARNING;
|
---|
| 384 | break;
|
---|
| 385 | case TRACELOG_EVTDESC_SEVERITY_ERROR:
|
---|
| 386 | enmSeverity = RTTRACELOGEVTSEVERITY_ERROR;
|
---|
| 387 | break;
|
---|
| 388 | case TRACELOG_EVTDESC_SEVERITY_FATAL:
|
---|
| 389 | enmSeverity = RTTRACELOGEVTSEVERITY_FATAL;
|
---|
| 390 | break;
|
---|
| 391 | case TRACELOG_EVTDESC_SEVERITY_DEBUG:
|
---|
| 392 | enmSeverity = RTTRACELOGEVTSEVERITY_DEBUG;
|
---|
| 393 | break;
|
---|
| 394 | default:
|
---|
| 395 | enmSeverity = RTTRACELOGEVTSEVERITY_INVALID;
|
---|
| 396 | }
|
---|
| 397 |
|
---|
| 398 | return enmSeverity;
|
---|
| 399 | }
|
---|
| 400 |
|
---|
| 401 |
|
---|
| 402 | /**
|
---|
| 403 | * Converts type field from stream to API value.
|
---|
| 404 | *
|
---|
| 405 | * @returns API type enum, RTTRACELOGTYPE_INVALID if the supplied stream value
|
---|
| 406 | * is invalid.
|
---|
| 407 | * @param u32Type The type value from the stream.
|
---|
| 408 | */
|
---|
| 409 | static RTTRACELOGTYPE rtTraceLogRdrConvType(uint32_t u32Type)
|
---|
| 410 | {
|
---|
| 411 | RTTRACELOGTYPE enmType = RTTRACELOGTYPE_INVALID;
|
---|
| 412 |
|
---|
| 413 | switch (u32Type)
|
---|
| 414 | {
|
---|
| 415 | case TRACELOG_EVTITEMDESC_TYPE_BOOL:
|
---|
| 416 | enmType = RTTRACELOGTYPE_BOOL;
|
---|
| 417 | break;
|
---|
| 418 | case TRACELOG_EVTITEMDESC_TYPE_UINT8:
|
---|
| 419 | enmType = RTTRACELOGTYPE_UINT8;
|
---|
| 420 | break;
|
---|
| 421 | case TRACELOG_EVTITEMDESC_TYPE_INT8:
|
---|
| 422 | enmType = RTTRACELOGTYPE_INT8;
|
---|
| 423 | break;
|
---|
| 424 | case TRACELOG_EVTITEMDESC_TYPE_UINT16:
|
---|
| 425 | enmType = RTTRACELOGTYPE_UINT16;
|
---|
| 426 | break;
|
---|
| 427 | case TRACELOG_EVTITEMDESC_TYPE_INT16:
|
---|
| 428 | enmType = RTTRACELOGTYPE_INT16;
|
---|
| 429 | break;
|
---|
| 430 | case TRACELOG_EVTITEMDESC_TYPE_UINT32:
|
---|
| 431 | enmType = RTTRACELOGTYPE_UINT32;
|
---|
| 432 | break;
|
---|
| 433 | case TRACELOG_EVTITEMDESC_TYPE_INT32:
|
---|
| 434 | enmType = RTTRACELOGTYPE_INT32;
|
---|
| 435 | break;
|
---|
| 436 | case TRACELOG_EVTITEMDESC_TYPE_UINT64:
|
---|
| 437 | enmType = RTTRACELOGTYPE_UINT64;
|
---|
| 438 | break;
|
---|
| 439 | case TRACELOG_EVTITEMDESC_TYPE_INT64:
|
---|
| 440 | enmType = RTTRACELOGTYPE_INT64;
|
---|
| 441 | break;
|
---|
| 442 | case TRACELOG_EVTITEMDESC_TYPE_FLOAT32:
|
---|
| 443 | enmType = RTTRACELOGTYPE_FLOAT32;
|
---|
| 444 | break;
|
---|
| 445 | case TRACELOG_EVTITEMDESC_TYPE_FLOAT64:
|
---|
| 446 | enmType = RTTRACELOGTYPE_FLOAT64;
|
---|
| 447 | break;
|
---|
| 448 | case TRACELOG_EVTITEMDESC_TYPE_RAWDATA:
|
---|
| 449 | enmType = RTTRACELOGTYPE_RAWDATA;
|
---|
| 450 | break;
|
---|
| 451 | case TRACELOG_EVTITEMDESC_TYPE_POINTER:
|
---|
| 452 | enmType = RTTRACELOGTYPE_POINTER;
|
---|
| 453 | break;
|
---|
| 454 | case TRACELOG_EVTITEMDESC_TYPE_SIZE:
|
---|
| 455 | enmType = RTTRACELOGTYPE_SIZE;
|
---|
| 456 | break;
|
---|
| 457 | default:
|
---|
| 458 | enmType = RTTRACELOGTYPE_INVALID;
|
---|
| 459 | }
|
---|
| 460 |
|
---|
| 461 | return enmType;
|
---|
| 462 | }
|
---|
| 463 |
|
---|
| 464 |
|
---|
| 465 | /**
|
---|
| 466 | * Converts the type enum to the size of the the event item data in bytes.
|
---|
| 467 | *
|
---|
| 468 | * @returns Event item data size in bytes.
|
---|
[71500] | 469 | * @param pThis The trace log reader instance.
|
---|
[71498] | 470 | * @param pEvtItemDesc The event item descriptor.
|
---|
[71492] | 471 | */
|
---|
| 472 | static size_t rtTraceLogRdrGetEvtItemDataSz(PRTTRACELOGRDRINT pThis, PCRTTRACELOGEVTITEMDESC pEvtItemDesc)
|
---|
| 473 | {
|
---|
| 474 | size_t cb = 0;
|
---|
| 475 |
|
---|
| 476 | switch (pEvtItemDesc->enmType)
|
---|
| 477 | {
|
---|
| 478 | case RTTRACELOGTYPE_BOOL:
|
---|
| 479 | case RTTRACELOGTYPE_UINT8:
|
---|
| 480 | case RTTRACELOGTYPE_INT8:
|
---|
| 481 | {
|
---|
| 482 | cb = 1;
|
---|
| 483 | break;
|
---|
| 484 | }
|
---|
| 485 | case RTTRACELOGTYPE_UINT16:
|
---|
| 486 | case RTTRACELOGTYPE_INT16:
|
---|
| 487 | {
|
---|
| 488 | cb = 2;
|
---|
| 489 | break;
|
---|
| 490 | }
|
---|
| 491 | case RTTRACELOGTYPE_UINT32:
|
---|
| 492 | case RTTRACELOGTYPE_INT32:
|
---|
| 493 | case RTTRACELOGTYPE_FLOAT32:
|
---|
| 494 | {
|
---|
| 495 | cb = 4;
|
---|
| 496 | break;
|
---|
| 497 | }
|
---|
| 498 | case RTTRACELOGTYPE_UINT64:
|
---|
| 499 | case RTTRACELOGTYPE_INT64:
|
---|
| 500 | case RTTRACELOGTYPE_FLOAT64:
|
---|
| 501 | {
|
---|
| 502 | cb = 8;
|
---|
| 503 | break;
|
---|
| 504 | }
|
---|
| 505 | case RTTRACELOGTYPE_RAWDATA:
|
---|
| 506 | {
|
---|
| 507 | cb = pEvtItemDesc->cbRawData;
|
---|
| 508 | break;
|
---|
| 509 | }
|
---|
| 510 | case RTTRACELOGTYPE_POINTER:
|
---|
| 511 | {
|
---|
| 512 | cb = pThis->cbTypePtr;
|
---|
| 513 | break;
|
---|
| 514 | }
|
---|
| 515 | case RTTRACELOGTYPE_SIZE:
|
---|
| 516 | {
|
---|
| 517 | cb = pThis->cbTypeSize;
|
---|
| 518 | break;
|
---|
| 519 | }
|
---|
| 520 | default:
|
---|
| 521 | AssertMsgFailed(("Invalid type %d\n", pEvtItemDesc->enmType));
|
---|
| 522 | }
|
---|
| 523 |
|
---|
| 524 | return cb;
|
---|
| 525 | }
|
---|
| 526 |
|
---|
| 527 |
|
---|
| 528 | /**
|
---|
| 529 | * Calculates the overall event data size from the items in the event descriptor.
|
---|
| 530 | *
|
---|
| 531 | * @param pThis The trace log reader instance.
|
---|
| 532 | * @param pEvtDesc The event descriptor.
|
---|
| 533 | */
|
---|
| 534 | static void rtTraceLogRdrEvtCalcEvtDataSz(PRTTRACELOGRDRINT pThis, PRTTRACELOGRDREVTDESC pEvtDesc)
|
---|
| 535 | {
|
---|
| 536 | pEvtDesc->cbEvtData = 0;
|
---|
| 537 | pEvtDesc->cRawDataNonStatic = 0;
|
---|
| 538 |
|
---|
| 539 | for (unsigned i = 0; i < pEvtDesc->EvtDesc.cEvtItems; i++)
|
---|
| 540 | {
|
---|
| 541 | PCRTTRACELOGEVTITEMDESC pEvtItemDesc = &pEvtDesc->aEvtItemDesc[i];
|
---|
| 542 |
|
---|
| 543 | pEvtDesc->cbEvtData += rtTraceLogRdrGetEvtItemDataSz(pThis, pEvtItemDesc);
|
---|
| 544 | if ( pEvtItemDesc->enmType == RTTRACELOGTYPE_RAWDATA
|
---|
| 545 | && pEvtItemDesc->cbRawData == 0)
|
---|
| 546 | pEvtDesc->cRawDataNonStatic++;
|
---|
| 547 | }
|
---|
| 548 | }
|
---|
| 549 |
|
---|
| 550 |
|
---|
| 551 | /**
|
---|
| 552 | * Ensures that the scratch buffer can hold at least the given amount of data.
|
---|
| 553 | *
|
---|
| 554 | * @returns IPRT status code.
|
---|
| 555 | * @param pThis The trace log reader instance.
|
---|
| 556 | * @param cbScratch New size of the scratch buffer in bytes.
|
---|
| 557 | */
|
---|
| 558 | static int rtTraceLogRdrScratchEnsureSz(PRTTRACELOGRDRINT pThis, size_t cbScratch)
|
---|
| 559 | {
|
---|
| 560 | int rc = VINF_SUCCESS;
|
---|
| 561 |
|
---|
| 562 | if (pThis->cbScratch < cbScratch)
|
---|
| 563 | {
|
---|
| 564 | cbScratch = RT_ALIGN_Z(cbScratch, 64);
|
---|
| 565 | uint8_t *pbScratchNew = (uint8_t *)RTMemRealloc(pThis->pbScratch, cbScratch);
|
---|
| 566 | if (RT_LIKELY(pbScratchNew))
|
---|
| 567 | {
|
---|
| 568 | pThis->cbScratch = cbScratch;
|
---|
| 569 | pThis->pbScratch = pbScratchNew;
|
---|
| 570 | }
|
---|
| 571 | else
|
---|
| 572 | rc = VERR_NO_MEMORY;
|
---|
| 573 | }
|
---|
| 574 |
|
---|
| 575 | return rc;
|
---|
| 576 | }
|
---|
| 577 |
|
---|
| 578 |
|
---|
| 579 | /**
|
---|
| 580 | * Advances to the next state resetting the scratch/receive buffers to the given state.
|
---|
| 581 | *
|
---|
| 582 | * @returns IPRT status.
|
---|
| 583 | * @param pThis The trace log reader instance.
|
---|
| 584 | * @param enmState The next state.
|
---|
| 585 | * @param cbRecv How much to receive before processing the new data.
|
---|
| 586 | * @param offScratch Offset to set the receive buffer to (used
|
---|
| 587 | * when the magic was received which should still be saved).
|
---|
| 588 | */
|
---|
| 589 | static int rtTraceLogRdrStateAdvanceEx(PRTTRACELOGRDRINT pThis, RTTRACELOGRDRSTATE enmState, size_t cbRecv,
|
---|
| 590 | uint32_t offScratch)
|
---|
| 591 | {
|
---|
| 592 | Assert(cbRecv >= offScratch);
|
---|
| 593 |
|
---|
| 594 | pThis->enmState = enmState;
|
---|
| 595 | pThis->cbRecvLeft = cbRecv - offScratch;
|
---|
| 596 | pThis->offScratch = offScratch;
|
---|
| 597 | int rc = rtTraceLogRdrScratchEnsureSz(pThis, cbRecv);
|
---|
| 598 |
|
---|
| 599 | /* Zero out scratch buffer (don't care whether growing it failed, the old buffer is still there). */
|
---|
| 600 | memset(pThis->pbScratch + offScratch, 0, pThis->cbScratch - offScratch);
|
---|
| 601 |
|
---|
| 602 | return rc;
|
---|
| 603 | }
|
---|
| 604 |
|
---|
| 605 |
|
---|
| 606 | /**
|
---|
| 607 | * Advances to the next state resetting the scratch/receive buffers.
|
---|
| 608 | *
|
---|
| 609 | * @returns IPRT status.
|
---|
| 610 | * @param pThis The trace log reader instance.
|
---|
| 611 | * @param enmState The next state.
|
---|
| 612 | * @param cbRecv How much to receive before processing the new data.
|
---|
| 613 | */
|
---|
| 614 | static int rtTraceLogRdrStateAdvance(PRTTRACELOGRDRINT pThis, RTTRACELOGRDRSTATE enmState, size_t cbRecv)
|
---|
| 615 | {
|
---|
| 616 | return rtTraceLogRdrStateAdvanceEx(pThis, enmState, cbRecv, 0);
|
---|
| 617 | }
|
---|
| 618 |
|
---|
| 619 |
|
---|
| 620 | /**
|
---|
| 621 | * Marks a received event descriptor as completed and adds it to the array of known descriptors.
|
---|
| 622 | *
|
---|
| 623 | * @returns IPRT status code.
|
---|
| 624 | * @param pThis The trace log reader instance.
|
---|
| 625 | * @param pEvtDesc The event descriptor which completed.
|
---|
| 626 | */
|
---|
| 627 | static int rtTraceLogRdrEvtDescComplete(PRTTRACELOGRDRINT pThis, PRTTRACELOGRDREVTDESC pEvtDesc)
|
---|
| 628 | {
|
---|
| 629 | int rc = VINF_SUCCESS;
|
---|
| 630 |
|
---|
| 631 | rtTraceLogRdrEvtCalcEvtDataSz(pThis, pEvtDesc);
|
---|
| 632 | /* Insert into array of known event descriptors. */
|
---|
| 633 | if (pThis->cEvtDescsCur == pThis->cEvtDescsMax)
|
---|
| 634 | {
|
---|
| 635 | uint32_t cEvtDescsNew = pThis->cEvtDescsMax + 10;
|
---|
| 636 | size_t cbNew = cEvtDescsNew * sizeof(PRTTRACELOGRDREVTDESC *);
|
---|
| 637 | PRTTRACELOGRDREVTDESC *papEvtDescsNew = (PRTTRACELOGRDREVTDESC *)RTMemRealloc(pThis->papEvtDescs, cbNew);
|
---|
| 638 | if (RT_LIKELY(papEvtDescsNew))
|
---|
| 639 | {
|
---|
| 640 | pThis->papEvtDescs = papEvtDescsNew;
|
---|
| 641 | pThis->cEvtDescsMax = cEvtDescsNew;
|
---|
| 642 | }
|
---|
| 643 | else
|
---|
| 644 | rc = VERR_NO_MEMORY;
|
---|
| 645 | }
|
---|
| 646 |
|
---|
| 647 | if (RT_SUCCESS(rc))
|
---|
| 648 | {
|
---|
| 649 | pThis->papEvtDescs[pThis->cEvtDescsCur++] = pEvtDesc;
|
---|
| 650 | pThis->pEvtDescCur = NULL;
|
---|
| 651 | rc = rtTraceLogRdrStateAdvance(pThis, RTTRACELOGRDRSTATE_RECV_MAGIC, TRACELOG_MAGIC_SZ);
|
---|
| 652 | }
|
---|
| 653 |
|
---|
| 654 | return rc;
|
---|
| 655 | }
|
---|
| 656 |
|
---|
| 657 |
|
---|
| 658 | /**
|
---|
| 659 | * Decides which state to enter next after one event item descriptor was completed successfully.
|
---|
| 660 | *
|
---|
| 661 | * @returns IPRT status code.
|
---|
| 662 | * @param pThis The trace log reader instance.
|
---|
| 663 | * @param penmEvt Where to store the event indicator if a user visible event happened.
|
---|
| 664 | * @param pfContinuePoll Where to store the flag whether to continue polling.
|
---|
| 665 | */
|
---|
| 666 | static int rtTraceLogRdrEvtItemDescComplete(PRTTRACELOGRDRINT pThis, RTTRACELOGRDRPOLLEVT *penmEvt,
|
---|
| 667 | bool *pfContinuePoll)
|
---|
| 668 | {
|
---|
| 669 | RT_NOREF(penmEvt, pfContinuePoll);
|
---|
| 670 |
|
---|
| 671 | int rc = VINF_SUCCESS;
|
---|
| 672 | PRTTRACELOGRDREVTDESC pEvtDesc = pThis->pEvtDescCur;
|
---|
| 673 | pEvtDesc->idxEvtItemCur++;
|
---|
| 674 |
|
---|
| 675 | /* If this event descriptor is complete add it to the array of known descriptors. */
|
---|
| 676 | if (pEvtDesc->idxEvtItemCur == pEvtDesc->EvtDesc.cEvtItems)
|
---|
| 677 | rc = rtTraceLogRdrEvtDescComplete(pThis, pEvtDesc);
|
---|
| 678 | else
|
---|
| 679 | {
|
---|
| 680 | /* Not done yet. */
|
---|
| 681 | rc = rtTraceLogRdrStateAdvance(pThis, RTTRACELOGRDRSTATE_RECV_EVT_ITEM_DESC, sizeof(TRACELOGEVTITEMDESC));
|
---|
| 682 | }
|
---|
| 683 |
|
---|
| 684 | return rc;
|
---|
| 685 | }
|
---|
| 686 |
|
---|
| 687 |
|
---|
| 688 | /**
|
---|
| 689 | * @callback_method_impl{FNRTTRACELOGRDRSTATEHANDLER, Handles a received header.}
|
---|
| 690 | */
|
---|
| 691 | static DECLCALLBACK(int) rtTraceLogRdrHdrRecvd(PRTTRACELOGRDRINT pThis, RTTRACELOGRDRPOLLEVT *penmEvt,
|
---|
| 692 | bool *pfContinuePoll)
|
---|
| 693 | {
|
---|
| 694 | RT_NOREF(penmEvt, pfContinuePoll);
|
---|
| 695 | int rc = VINF_SUCCESS;
|
---|
| 696 | PTRACELOGHDR pHdr = (PTRACELOGHDR)pThis->pbScratch;
|
---|
| 697 |
|
---|
| 698 | /* Verify magic. */
|
---|
| 699 | if (!memcmp(&pHdr->szMagic[0], TRACELOG_HDR_MAGIC, sizeof(pHdr->szMagic)))
|
---|
| 700 | {
|
---|
| 701 | /* Check endianess. */
|
---|
| 702 | if (pHdr->u32Endianess == TRACELOG_HDR_ENDIANESS)
|
---|
| 703 | pThis->fConvEndianess = false;
|
---|
| 704 | else if (RT_BSWAP_U32(pHdr->u32Endianess) == TRACELOG_HDR_ENDIANESS)
|
---|
| 705 | {
|
---|
| 706 | pThis->fConvEndianess = true;
|
---|
| 707 | rtTraceLogRdrHdrEndianessConv(pHdr);
|
---|
| 708 | }
|
---|
| 709 | else
|
---|
| 710 | rc = VERR_TRACELOG_READER_MALFORMED_LOG;
|
---|
| 711 |
|
---|
| 712 | if (RT_SUCCESS(rc))
|
---|
| 713 | {
|
---|
| 714 | Assert(pHdr->u32Endianess == TRACELOG_HDR_ENDIANESS);
|
---|
| 715 |
|
---|
| 716 | /* Enforce strict limits to avoid exhausting memory. */
|
---|
| 717 | if ( pHdr->u32Version == TRACELOG_VERSION
|
---|
| 718 | && pHdr->cbStrDesc < _1K
|
---|
| 719 | && pHdr->cbTypePtr <= 8
|
---|
| 720 | && (pHdr->cbTypeSize == 8 || pHdr->cbTypeSize == 4))
|
---|
| 721 | {
|
---|
| 722 | pThis->u64TsStart = pHdr->u64TsStart;
|
---|
| 723 | pThis->cbTypePtr = pHdr->cbTypePtr;
|
---|
| 724 | pThis->cbTypeSize = pHdr->cbTypeSize;
|
---|
| 725 | pThis->cchDesc = pHdr->cbStrDesc;
|
---|
| 726 | pThis->cEvtDescsMax = 10;
|
---|
| 727 |
|
---|
| 728 | /* Allocate array to hold event descriptors later on. */
|
---|
| 729 | pThis->papEvtDescs = (PRTTRACELOGRDREVTDESC *)RTMemAllocZ(pThis->cEvtDescsMax * sizeof(PRTTRACELOGRDREVTDESC));
|
---|
| 730 | if (RT_LIKELY(pThis->papEvtDescs))
|
---|
| 731 | {
|
---|
| 732 | /* Switch to the next state. */
|
---|
| 733 | if (pHdr->cbStrDesc)
|
---|
| 734 | rc = rtTraceLogRdrStateAdvance(pThis, RTTRACELOGRDRSTATE_RECV_HDR_DESC, pHdr->cbStrDesc);
|
---|
| 735 | else
|
---|
| 736 | rc = rtTraceLogRdrStateAdvance(pThis, RTTRACELOGRDRSTATE_RECV_MAGIC, TRACELOG_MAGIC_SZ);
|
---|
| 737 |
|
---|
| 738 | if (RT_SUCCESS(rc))
|
---|
| 739 | {
|
---|
| 740 | *penmEvt = RTTRACELOGRDRPOLLEVT_HDR_RECVD;
|
---|
| 741 | *pfContinuePoll = false;
|
---|
| 742 | }
|
---|
| 743 | }
|
---|
| 744 | else
|
---|
| 745 | rc = VERR_NO_MEMORY;
|
---|
| 746 | }
|
---|
| 747 | else
|
---|
| 748 | rc = VERR_TRACELOG_READER_LOG_UNSUPPORTED;
|
---|
| 749 | }
|
---|
| 750 | }
|
---|
| 751 | else
|
---|
| 752 | rc = VERR_TRACELOG_READER_MALFORMED_LOG;
|
---|
| 753 |
|
---|
| 754 | return rc;
|
---|
| 755 | }
|
---|
| 756 |
|
---|
| 757 |
|
---|
| 758 | /**
|
---|
| 759 | * @callback_method_impl{FNRTTRACELOGRDRSTATEHANDLER, Handles a received log description.}
|
---|
| 760 | */
|
---|
| 761 | static DECLCALLBACK(int) rtTraceLogRdrHdrDescRecvd(PRTTRACELOGRDRINT pThis, RTTRACELOGRDRPOLLEVT *penmEvt,
|
---|
| 762 | bool *pfContinuePoll)
|
---|
| 763 | {
|
---|
| 764 | RT_NOREF(penmEvt, pfContinuePoll);
|
---|
| 765 | int rc = VINF_SUCCESS;
|
---|
| 766 | char *pszDesc = (char *)pThis->pbScratch;
|
---|
| 767 |
|
---|
| 768 | RTStrPurgeEncoding(pszDesc);
|
---|
| 769 | pThis->pszDesc = RTStrCacheEnterN(pThis->hStrCache, pszDesc, pThis->cchDesc);
|
---|
| 770 | if (pThis->pszDesc)
|
---|
| 771 | rc = rtTraceLogRdrStateAdvance(pThis, RTTRACELOGRDRSTATE_RECV_MAGIC, TRACELOG_MAGIC_SZ);
|
---|
| 772 | else
|
---|
| 773 | rc = VERR_NO_STR_MEMORY;
|
---|
| 774 | return rc;
|
---|
| 775 | }
|
---|
| 776 |
|
---|
| 777 |
|
---|
| 778 | /**
|
---|
| 779 | * @callback_method_impl{FNRTTRACELOGRDRSTATEHANDLER, Handles a received magic.}
|
---|
| 780 | */
|
---|
| 781 | static DECLCALLBACK(int) rtTraceLogRdrMagicRecvd(PRTTRACELOGRDRINT pThis, RTTRACELOGRDRPOLLEVT *penmEvt,
|
---|
| 782 | bool *pfContinuePoll)
|
---|
| 783 | {
|
---|
| 784 | RT_NOREF(penmEvt, pfContinuePoll);
|
---|
| 785 | int rc = VINF_SUCCESS;
|
---|
| 786 | char *pszMagic = (char *)pThis->pbScratch;
|
---|
| 787 |
|
---|
| 788 | if (!memcmp(pszMagic, TRACELOG_EVTDESC_MAGIC, TRACELOG_MAGIC_SZ))
|
---|
| 789 | rc = rtTraceLogRdrStateAdvanceEx(pThis, RTTRACELOGRDRSTATE_RECV_EVT_DESC,
|
---|
| 790 | sizeof(TRACELOGEVTDESC), TRACELOG_MAGIC_SZ);
|
---|
| 791 | else if (!memcmp(pszMagic, TRACELOG_EVT_MAGIC, TRACELOG_MAGIC_SZ))
|
---|
| 792 | rc = rtTraceLogRdrStateAdvanceEx(pThis, RTTRACELOGRDRSTATE_RECV_EVT_MARKER,
|
---|
| 793 | sizeof(TRACELOGEVT), TRACELOG_MAGIC_SZ);
|
---|
| 794 |
|
---|
| 795 | return rc;
|
---|
| 796 | }
|
---|
| 797 |
|
---|
| 798 |
|
---|
| 799 | /**
|
---|
| 800 | * @callback_method_impl{FNRTTRACELOGRDRSTATEHANDLER, Handles a received event descriptor.}
|
---|
| 801 | */
|
---|
| 802 | static DECLCALLBACK(int) rtTraceLogRdrEvtDescRecvd(PRTTRACELOGRDRINT pThis, RTTRACELOGRDRPOLLEVT *penmEvt,
|
---|
| 803 | bool *pfContinuePoll)
|
---|
| 804 | {
|
---|
| 805 | RT_NOREF(penmEvt, pfContinuePoll);
|
---|
| 806 | int rc = VINF_SUCCESS;
|
---|
| 807 | PTRACELOGEVTDESC pEvtDesc = (PTRACELOGEVTDESC)pThis->pbScratch;
|
---|
| 808 | if (pThis->fConvEndianess)
|
---|
| 809 | rtTraceLogRdrEvtDescEndianessConv(pEvtDesc);
|
---|
| 810 |
|
---|
| 811 | if ( !memcmp(&pEvtDesc->szMagic[0], TRACELOG_EVTDESC_MAGIC, sizeof(pEvtDesc->szMagic))
|
---|
| 812 | && pEvtDesc->u32Id == pThis->cEvtDescsCur
|
---|
| 813 | && (pEvtDesc->cbStrId >= 1 && pEvtDesc->cbStrId < 128)
|
---|
| 814 | && pEvtDesc->cbStrDesc < _1K
|
---|
| 815 | && pEvtDesc->cEvtItems < 128)
|
---|
| 816 | {
|
---|
| 817 | RTTRACELOGEVTSEVERITY enmSeverity = rtTraceLogRdrConvSeverity(pEvtDesc->u32Severity);
|
---|
| 818 | if (RT_LIKELY(enmSeverity != RTTRACELOGEVTSEVERITY_INVALID))
|
---|
| 819 | {
|
---|
| 820 | /* Allocate new internal event descriptor state. */
|
---|
[73097] | 821 | size_t cbEvtDesc = RT_UOFFSETOF_DYN(RTTRACELOGRDREVTDESC, aEvtItemDesc[pEvtDesc->cEvtItems]);
|
---|
[71492] | 822 | PRTTRACELOGRDREVTDESC pEvtDescInt = (PRTTRACELOGRDREVTDESC)RTMemAllocZ(cbEvtDesc);
|
---|
[94888] | 823 | if (RT_LIKELY(pEvtDescInt))
|
---|
[71492] | 824 | {
|
---|
| 825 | pEvtDescInt->cbStrId = pEvtDesc->cbStrId;
|
---|
| 826 | pEvtDescInt->cbStrDesc = pEvtDesc->cbStrDesc;
|
---|
| 827 | pEvtDescInt->EvtDesc.enmSeverity = enmSeverity;
|
---|
| 828 | pEvtDescInt->EvtDesc.cEvtItems = pEvtDesc->cEvtItems;
|
---|
| 829 | pEvtDescInt->EvtDesc.paEvtItemDesc = &pEvtDescInt->aEvtItemDesc[0];
|
---|
| 830 |
|
---|
| 831 | pThis->pEvtDescCur = pEvtDescInt;
|
---|
| 832 | rc = rtTraceLogRdrStateAdvance(pThis, RTTRACELOGRDRSTATE_RECV_EVT_DESC_ID, pEvtDescInt->cbStrId);
|
---|
| 833 | }
|
---|
| 834 | else
|
---|
| 835 | rc = VERR_NO_MEMORY;
|
---|
| 836 | }
|
---|
| 837 | else
|
---|
| 838 | rc = VERR_TRACELOG_READER_MALFORMED_LOG;
|
---|
| 839 | }
|
---|
| 840 | else
|
---|
| 841 | rc = VERR_TRACELOG_READER_MALFORMED_LOG;
|
---|
| 842 |
|
---|
| 843 | return rc;
|
---|
| 844 | }
|
---|
| 845 |
|
---|
| 846 |
|
---|
| 847 | /**
|
---|
| 848 | * @callback_method_impl{FNRTTRACELOGRDRSTATEHANDLER, Handles a received event descriptor ID.}
|
---|
| 849 | */
|
---|
| 850 | static DECLCALLBACK(int) rtTraceLogRdrEvtDescIdRecvd(PRTTRACELOGRDRINT pThis, RTTRACELOGRDRPOLLEVT *penmEvt,
|
---|
| 851 | bool *pfContinuePoll)
|
---|
| 852 | {
|
---|
| 853 | RT_NOREF(penmEvt, pfContinuePoll);
|
---|
| 854 |
|
---|
| 855 | int rc = VINF_SUCCESS;
|
---|
| 856 | pThis->pEvtDescCur->EvtDesc.pszId = RTStrCacheEnterN(pThis->hStrCache, (const char *)pThis->pbScratch,
|
---|
| 857 | pThis->pEvtDescCur->cbStrId);
|
---|
| 858 | if (RT_LIKELY(pThis->pEvtDescCur->EvtDesc.pszId))
|
---|
| 859 | {
|
---|
| 860 | if (pThis->pEvtDescCur->cbStrDesc)
|
---|
| 861 | rc = rtTraceLogRdrStateAdvance(pThis, RTTRACELOGRDRSTATE_RECV_EVT_DESC_DESC, pThis->pEvtDescCur->cbStrDesc);
|
---|
| 862 | else if (pThis->pEvtDescCur->EvtDesc.cEvtItems > 0)
|
---|
| 863 | rc = rtTraceLogRdrStateAdvance(pThis, RTTRACELOGRDRSTATE_RECV_EVT_ITEM_DESC, sizeof(TRACELOGEVTITEMDESC));
|
---|
| 864 | else
|
---|
| 865 | rc = rtTraceLogRdrEvtDescComplete(pThis, pThis->pEvtDescCur);
|
---|
| 866 | }
|
---|
| 867 | else
|
---|
| 868 | rc = VERR_NO_STR_MEMORY;
|
---|
| 869 |
|
---|
| 870 | return rc;
|
---|
| 871 | }
|
---|
| 872 |
|
---|
| 873 |
|
---|
| 874 | /**
|
---|
| 875 | * @callback_method_impl{FNRTTRACELOGRDRSTATEHANDLER, Handles a received event descriptor description.}
|
---|
| 876 | */
|
---|
| 877 | static DECLCALLBACK(int) rtTraceLogRdrEvtDescDescriptionRecvd(PRTTRACELOGRDRINT pThis, RTTRACELOGRDRPOLLEVT *penmEvt,
|
---|
| 878 | bool *pfContinuePoll)
|
---|
| 879 | {
|
---|
| 880 | RT_NOREF(penmEvt, pfContinuePoll);
|
---|
| 881 | int rc = VINF_SUCCESS;
|
---|
| 882 | pThis->pEvtDescCur->EvtDesc.pszDesc = RTStrCacheEnterN(pThis->hStrCache, (const char *)pThis->pbScratch,
|
---|
| 883 | pThis->pEvtDescCur->cbStrDesc);
|
---|
| 884 | if (RT_LIKELY(pThis->pEvtDescCur->EvtDesc.pszDesc))
|
---|
| 885 | {
|
---|
| 886 | if (pThis->pEvtDescCur->EvtDesc.cEvtItems > 0)
|
---|
| 887 | rc = rtTraceLogRdrStateAdvance(pThis, RTTRACELOGRDRSTATE_RECV_EVT_ITEM_DESC, sizeof(TRACELOGEVTITEMDESC));
|
---|
| 888 | else
|
---|
| 889 | rc = rtTraceLogRdrEvtDescComplete(pThis, pThis->pEvtDescCur);
|
---|
| 890 | }
|
---|
| 891 | else
|
---|
| 892 | rc = VERR_NO_STR_MEMORY;
|
---|
| 893 |
|
---|
| 894 | return rc;
|
---|
| 895 | }
|
---|
| 896 |
|
---|
| 897 |
|
---|
| 898 | /**
|
---|
| 899 | * @callback_method_impl{FNRTTRACELOGRDRSTATEHANDLER, Handles a received event item descriptor.}
|
---|
| 900 | */
|
---|
| 901 | static DECLCALLBACK(int) rtTraceLogRdrEvtItemDescRecvd(PRTTRACELOGRDRINT pThis, RTTRACELOGRDRPOLLEVT *penmEvt,
|
---|
| 902 | bool *pfContinuePoll)
|
---|
| 903 | {
|
---|
| 904 | RT_NOREF(penmEvt, pfContinuePoll);
|
---|
| 905 | int rc = VINF_SUCCESS;
|
---|
| 906 | PTRACELOGEVTITEMDESC pEvtItemDesc = (PTRACELOGEVTITEMDESC)pThis->pbScratch;
|
---|
| 907 | if (pThis->fConvEndianess)
|
---|
| 908 | rtTraceLogRdrEvtItemDescEndianessConv(pEvtItemDesc);
|
---|
| 909 |
|
---|
| 910 | if ( !memcmp(&pEvtItemDesc->szMagic[0], TRACELOG_EVTITEMDESC_MAGIC, sizeof(pEvtItemDesc->szMagic))
|
---|
| 911 | && (pEvtItemDesc->cbStrName >= 1 && pEvtItemDesc->cbStrName < 128)
|
---|
| 912 | && pEvtItemDesc->cbStrDesc < _1K
|
---|
| 913 | && pEvtItemDesc->cbRawData < _1M)
|
---|
| 914 | {
|
---|
| 915 | RTTRACELOGTYPE enmType = rtTraceLogRdrConvType(pEvtItemDesc->u32Type);
|
---|
| 916 | if (RT_LIKELY(enmType != RTTRACELOGTYPE_INVALID))
|
---|
| 917 | {
|
---|
| 918 | PRTTRACELOGEVTITEMDESC pEvtDesc = &pThis->pEvtDescCur->aEvtItemDesc[pThis->pEvtDescCur->idxEvtItemCur];
|
---|
| 919 |
|
---|
| 920 | pThis->pEvtDescCur->cbStrItemName = pEvtItemDesc->cbStrName;
|
---|
| 921 | pThis->pEvtDescCur->cbStrItemDesc = pEvtItemDesc->cbStrDesc;
|
---|
| 922 |
|
---|
| 923 | pEvtDesc->enmType = enmType;
|
---|
| 924 | pEvtDesc->cbRawData = pEvtItemDesc->cbRawData;
|
---|
| 925 | rc = rtTraceLogRdrStateAdvance(pThis, RTTRACELOGRDRSTATE_RECV_EVT_ITEM_DESC_NAME, pEvtItemDesc->cbStrName);
|
---|
| 926 | }
|
---|
| 927 | else
|
---|
| 928 | rc = VERR_TRACELOG_READER_MALFORMED_LOG;
|
---|
| 929 | }
|
---|
| 930 | else
|
---|
| 931 | rc = VERR_TRACELOG_READER_MALFORMED_LOG;
|
---|
| 932 |
|
---|
| 933 | return rc;
|
---|
| 934 | }
|
---|
| 935 |
|
---|
| 936 |
|
---|
| 937 | /**
|
---|
| 938 | * @callback_method_impl{FNRTTRACELOGRDRSTATEHANDLER, Handles a received event item descriptor name.}
|
---|
| 939 | */
|
---|
| 940 | static DECLCALLBACK(int) rtTraceLogRdrEvtItemDescNameRecvd(PRTTRACELOGRDRINT pThis, RTTRACELOGRDRPOLLEVT *penmEvt,
|
---|
| 941 | bool *pfContinuePoll)
|
---|
| 942 | {
|
---|
| 943 | int rc = VINF_SUCCESS;
|
---|
| 944 | PRTTRACELOGEVTITEMDESC pEvtDesc = &pThis->pEvtDescCur->aEvtItemDesc[pThis->pEvtDescCur->idxEvtItemCur];
|
---|
| 945 | pEvtDesc->pszName = RTStrCacheEnterN(pThis->hStrCache, (const char *)pThis->pbScratch, pThis->pEvtDescCur->cbStrItemName);
|
---|
| 946 | if (RT_LIKELY(pEvtDesc->pszName))
|
---|
| 947 | {
|
---|
| 948 | if (pThis->pEvtDescCur->cbStrItemDesc)
|
---|
| 949 | rc = rtTraceLogRdrStateAdvance(pThis, RTTRACELOGRDRSTATE_RECV_EVT_ITEM_DESC_DESC, pThis->pEvtDescCur->cbStrItemDesc);
|
---|
| 950 | else
|
---|
| 951 | rc = rtTraceLogRdrEvtItemDescComplete(pThis, penmEvt, pfContinuePoll);
|
---|
| 952 | }
|
---|
| 953 | else
|
---|
| 954 | rc = VERR_NO_STR_MEMORY;
|
---|
| 955 |
|
---|
| 956 | return rc;
|
---|
| 957 | }
|
---|
| 958 |
|
---|
| 959 |
|
---|
| 960 | /**
|
---|
| 961 | * @callback_method_impl{FNRTTRACELOGRDRSTATEHANDLER, Handles a received event item description.}
|
---|
| 962 | */
|
---|
| 963 | static DECLCALLBACK(int) rtTraceLogRdrEvtItemDescDescriptionRecvd(PRTTRACELOGRDRINT pThis, RTTRACELOGRDRPOLLEVT *penmEvt,
|
---|
| 964 | bool *pfContinuePoll)
|
---|
| 965 | {
|
---|
| 966 | int rc = VINF_SUCCESS;
|
---|
| 967 | PRTTRACELOGEVTITEMDESC pEvtDesc = &pThis->pEvtDescCur->aEvtItemDesc[pThis->pEvtDescCur->idxEvtItemCur];
|
---|
| 968 | pEvtDesc->pszDesc = RTStrCacheEnterN(pThis->hStrCache, (const char *)pThis->pbScratch, pThis->pEvtDescCur->cbStrItemDesc);
|
---|
| 969 | if (RT_LIKELY(pEvtDesc->pszDesc))
|
---|
| 970 | rc = rtTraceLogRdrEvtItemDescComplete(pThis, penmEvt, pfContinuePoll);
|
---|
| 971 | else
|
---|
| 972 | rc = VERR_NO_STR_MEMORY;
|
---|
| 973 |
|
---|
| 974 | return rc;
|
---|
| 975 | }
|
---|
| 976 |
|
---|
| 977 |
|
---|
| 978 | /**
|
---|
| 979 | * @callback_method_impl{FNRTTRACELOGRDRSTATEHANDLER, Handles a received event marker.}
|
---|
| 980 | */
|
---|
| 981 | static DECLCALLBACK(int) rtTraceLogRdrEvtMarkerRecvd(PRTTRACELOGRDRINT pThis, RTTRACELOGRDRPOLLEVT *penmEvt,
|
---|
| 982 | bool *pfContinuePoll)
|
---|
| 983 | {
|
---|
| 984 | int rc = VINF_SUCCESS;
|
---|
| 985 | PTRACELOGEVT pEvtStrm = (PTRACELOGEVT)pThis->pbScratch;
|
---|
| 986 | if (pThis->fConvEndianess)
|
---|
| 987 | rtTraceLogRdrEvtEndianessConv(pEvtStrm);
|
---|
| 988 |
|
---|
| 989 | if ( (pEvtStrm->u64SeqNo == pThis->u64SeqNoLast + 1)
|
---|
| 990 | && !(pEvtStrm->fFlags & ~TRACELOG_EVT_F_VALID)
|
---|
| 991 | && pEvtStrm->u32EvtDescId < pThis->cEvtDescsCur)
|
---|
| 992 | {
|
---|
| 993 | PRTTRACELOGRDREVTDESC pEvtDesc = pThis->papEvtDescs[pEvtStrm->u32EvtDescId];
|
---|
| 994 | if ( ( !pEvtDesc->cRawDataNonStatic
|
---|
| 995 | && pEvtStrm->cbEvtData == pEvtDesc->cbEvtData)
|
---|
| 996 | || ( pEvtDesc->cRawDataNonStatic
|
---|
| 997 | && pEvtStrm->cbEvtData >= pEvtDesc->cbEvtData
|
---|
| 998 | && pEvtStrm->cRawEvtDataSz == pEvtDesc->cRawDataNonStatic))
|
---|
| 999 | {
|
---|
[73097] | 1000 | size_t cbEvt = RT_UOFFSETOF_DYN(RTTRACELOGRDREVTINT, abEvtData[pEvtStrm->cbEvtData]);
|
---|
[71492] | 1001 | cbEvt += pEvtDesc->cRawDataNonStatic * sizeof(size_t);
|
---|
| 1002 | PRTTRACELOGRDREVTINT pEvt = (PRTTRACELOGRDREVTINT)RTMemAllocZ(cbEvt);
|
---|
| 1003 | if (RT_LIKELY(pEvt))
|
---|
| 1004 | {
|
---|
| 1005 | pEvt->pRdr = pThis;
|
---|
| 1006 | pEvt->u64SeqNo = pEvtStrm->u64SeqNo;
|
---|
| 1007 | pEvt->u64Ts = pEvtStrm->u64Ts;
|
---|
| 1008 | pEvt->pEvtDesc = pEvtDesc;
|
---|
| 1009 | pEvt->cbEvtData = pEvtStrm->cbEvtData;
|
---|
| 1010 | pEvt->pacbRawData = pEvtDesc->cRawDataNonStatic ? (size_t *)&pEvt->abEvtData[pEvtStrm->cbEvtData] : NULL;
|
---|
[71501] | 1011 | /** @todo Group handling and parenting. */
|
---|
[71492] | 1012 |
|
---|
| 1013 | size_t cbEvtDataRecv = pEvtStrm->cRawEvtDataSz * pThis->cbTypeSize + pEvtStrm->cbEvtData;
|
---|
| 1014 | if (cbEvtDataRecv)
|
---|
[86386] | 1015 | {
|
---|
| 1016 | pThis->pEvtCur = pEvt;
|
---|
[71492] | 1017 | rc = rtTraceLogRdrStateAdvance(pThis, RTTRACELOGRDRSTATE_RECV_EVT_DATA, cbEvtDataRecv);
|
---|
[86386] | 1018 | }
|
---|
[71492] | 1019 | else
|
---|
| 1020 | {
|
---|
| 1021 | pThis->pEvtCur = NULL;
|
---|
| 1022 | RTSemMutexRequest(pThis->hMtx, RT_INDEFINITE_WAIT);
|
---|
| 1023 | pThis->u64SeqNoLast = pEvt->u64SeqNo;
|
---|
| 1024 | RTListAppend(&pThis->LstEvts, &pEvt->NdGlob);
|
---|
| 1025 | RTSemMutexRelease(pThis->hMtx);
|
---|
| 1026 | *penmEvt = RTTRACELOGRDRPOLLEVT_TRACE_EVENT_RECVD;
|
---|
| 1027 | *pfContinuePoll = false;
|
---|
| 1028 | rc = rtTraceLogRdrStateAdvance(pThis, RTTRACELOGRDRSTATE_RECV_MAGIC, TRACELOG_MAGIC_SZ);
|
---|
| 1029 | }
|
---|
| 1030 | }
|
---|
| 1031 | else
|
---|
| 1032 | rc = VERR_NO_MEMORY;
|
---|
| 1033 | }
|
---|
| 1034 | else
|
---|
| 1035 | rc = VERR_TRACELOG_READER_MALFORMED_LOG;
|
---|
| 1036 | }
|
---|
| 1037 | else
|
---|
| 1038 | rc = VERR_TRACELOG_READER_MALFORMED_LOG;
|
---|
| 1039 |
|
---|
| 1040 | return rc;
|
---|
| 1041 | }
|
---|
| 1042 |
|
---|
| 1043 |
|
---|
| 1044 | /**
|
---|
| 1045 | * @callback_method_impl{FNRTTRACELOGRDRSTATEHANDLER, Handles received event data.}
|
---|
| 1046 | */
|
---|
| 1047 | static DECLCALLBACK(int) rtTraceLogRdrEvtDataRecvd(PRTTRACELOGRDRINT pThis, RTTRACELOGRDRPOLLEVT *penmEvt,
|
---|
| 1048 | bool *pfContinuePoll)
|
---|
| 1049 | {
|
---|
| 1050 | RT_NOREF(penmEvt, pfContinuePoll);
|
---|
| 1051 |
|
---|
| 1052 | int rc = VINF_SUCCESS;
|
---|
| 1053 | PRTTRACELOGRDREVTINT pEvt = pThis->pEvtCur;
|
---|
| 1054 | PCRTTRACELOGRDREVTDESC pEvtDesc = pEvt->pEvtDesc;
|
---|
| 1055 | uint8_t *pbData = pThis->pbScratch;
|
---|
| 1056 | size_t cbRawDataNonStatic = 0;
|
---|
| 1057 |
|
---|
| 1058 | /* Retrieve any raw data size indicators first. */
|
---|
| 1059 | for (unsigned i = 0; i < pEvtDesc->cRawDataNonStatic; i++)
|
---|
| 1060 | {
|
---|
| 1061 | size_t cb = 0;
|
---|
| 1062 | if (pThis->cbTypeSize == 4)
|
---|
| 1063 | {
|
---|
[84491] | 1064 | if (pThis->fConvEndianess)
|
---|
| 1065 | cb = RT_BSWAP_U32(*(uint32_t *)pbData);
|
---|
| 1066 | else
|
---|
| 1067 | cb = *(uint32_t *)pbData;
|
---|
[71492] | 1068 | pbData += 4;
|
---|
| 1069 | }
|
---|
| 1070 | else if (pThis->cbTypeSize == 8)
|
---|
| 1071 | {
|
---|
[84491] | 1072 | if (pThis->fConvEndianess)
|
---|
| 1073 | cb = RT_BSWAP_U64(*(uint64_t *)pbData);
|
---|
| 1074 | else
|
---|
| 1075 | cb = *(uint64_t *)pbData;
|
---|
[71492] | 1076 | pbData += 8;
|
---|
| 1077 | }
|
---|
| 1078 | else
|
---|
| 1079 | AssertMsgFailed(("Invalid size_t size %u\n", pThis->cbTypeSize));
|
---|
| 1080 |
|
---|
| 1081 | pEvt->pacbRawData[i] = cb;
|
---|
| 1082 | cbRawDataNonStatic += cb;
|
---|
| 1083 | }
|
---|
| 1084 |
|
---|
| 1085 | /* Verify that sizes add up. */
|
---|
| 1086 | if (pEvt->cbEvtData == pEvtDesc->cbEvtData + cbRawDataNonStatic)
|
---|
| 1087 | {
|
---|
| 1088 | /* Copy the data over. */
|
---|
| 1089 | memcpy(&pEvt->abEvtData[0], pbData, pEvt->cbEvtData);
|
---|
| 1090 |
|
---|
| 1091 | /* Done add event to global list and generate event. */
|
---|
| 1092 | pThis->pEvtCur = NULL;
|
---|
| 1093 | RTSemMutexRequest(pThis->hMtx, RT_INDEFINITE_WAIT);
|
---|
| 1094 | pThis->u64SeqNoLast = pEvt->u64SeqNo;
|
---|
| 1095 | RTListAppend(&pThis->LstEvts, &pEvt->NdGlob);
|
---|
| 1096 | RTSemMutexRelease(pThis->hMtx);
|
---|
| 1097 | *penmEvt = RTTRACELOGRDRPOLLEVT_TRACE_EVENT_RECVD;
|
---|
| 1098 | *pfContinuePoll = false;
|
---|
| 1099 | rc = rtTraceLogRdrStateAdvance(pThis, RTTRACELOGRDRSTATE_RECV_MAGIC, TRACELOG_MAGIC_SZ);
|
---|
| 1100 | }
|
---|
| 1101 | else
|
---|
| 1102 | rc = VERR_TRACELOG_READER_MALFORMED_LOG;
|
---|
| 1103 |
|
---|
| 1104 | return rc;
|
---|
| 1105 | }
|
---|
| 1106 |
|
---|
| 1107 |
|
---|
| 1108 | /**
|
---|
[71497] | 1109 | * @copydoc FNRTTRACELOGRDRSTREAM
|
---|
[71492] | 1110 | */
|
---|
| 1111 | static DECLCALLBACK(int) rtTraceLogRdrFileStream(void *pvUser, void *pvBuf, size_t cbBuf, size_t *pcbRead,
|
---|
| 1112 | RTMSINTERVAL cMsTimeout)
|
---|
| 1113 | {
|
---|
| 1114 | RT_NOREF(cMsTimeout);
|
---|
| 1115 | RTFILE hFile = (RTFILE)pvUser;
|
---|
| 1116 | return RTFileRead(hFile, pvBuf, cbBuf, pcbRead);
|
---|
| 1117 | }
|
---|
| 1118 |
|
---|
| 1119 |
|
---|
| 1120 | /**
|
---|
[71497] | 1121 | * @copydoc FNRTTRACELOGSTREAMCLOSE
|
---|
[71492] | 1122 | */
|
---|
| 1123 | static DECLCALLBACK(int) rtTraceLogRdrFileStreamClose(void *pvUser)
|
---|
| 1124 | {
|
---|
| 1125 | RTFILE hFile = (RTFILE)pvUser;
|
---|
| 1126 | return RTFileClose(hFile);
|
---|
| 1127 | }
|
---|
| 1128 |
|
---|
| 1129 |
|
---|
| 1130 | /**
|
---|
| 1131 | * Returns the size of the data for the given event item descriptor.
|
---|
| 1132 | *
|
---|
| 1133 | * @returns Size in bytes for the given event item descriptor.
|
---|
| 1134 | * @param pThis The trace log rader instance.
|
---|
| 1135 | * @param pEvtItemDesc The event item descriptor.
|
---|
| 1136 | * @param pacbRawData The raw data size array for he associated event to get the size for non static raw data items.
|
---|
| 1137 | * @param pidxRawData The index into the raw data size array for the next item to use.
|
---|
| 1138 | */
|
---|
| 1139 | static size_t rtTraceLogRdrEvtItemGetSz(PRTTRACELOGRDRINT pThis, PCRTTRACELOGEVTITEMDESC pEvtItemDesc,
|
---|
| 1140 | size_t *pacbRawData, unsigned *pidxRawData)
|
---|
| 1141 | {
|
---|
| 1142 | size_t cbRet = 0;
|
---|
| 1143 |
|
---|
| 1144 | switch (pEvtItemDesc->enmType)
|
---|
| 1145 | {
|
---|
| 1146 | case RTTRACELOGTYPE_BOOL:
|
---|
| 1147 | cbRet = sizeof(bool);
|
---|
| 1148 | break;
|
---|
| 1149 | case RTTRACELOGTYPE_UINT8:
|
---|
| 1150 | cbRet = sizeof(uint8_t);
|
---|
| 1151 | break;
|
---|
| 1152 | case RTTRACELOGTYPE_INT8:
|
---|
| 1153 | cbRet = sizeof(int8_t);
|
---|
| 1154 | break;
|
---|
| 1155 | case RTTRACELOGTYPE_UINT16:
|
---|
| 1156 | cbRet = sizeof(uint16_t);
|
---|
| 1157 | break;
|
---|
| 1158 | case RTTRACELOGTYPE_INT16:
|
---|
| 1159 | cbRet = sizeof(int16_t);
|
---|
| 1160 | break;
|
---|
| 1161 | case RTTRACELOGTYPE_UINT32:
|
---|
| 1162 | cbRet = sizeof(uint32_t);
|
---|
| 1163 | break;
|
---|
| 1164 | case RTTRACELOGTYPE_INT32:
|
---|
| 1165 | cbRet = sizeof(int32_t);
|
---|
| 1166 | break;
|
---|
| 1167 | case RTTRACELOGTYPE_UINT64:
|
---|
| 1168 | cbRet = sizeof(uint64_t);
|
---|
| 1169 | break;
|
---|
| 1170 | case RTTRACELOGTYPE_INT64:
|
---|
| 1171 | cbRet = sizeof(int64_t);
|
---|
| 1172 | break;
|
---|
| 1173 | case RTTRACELOGTYPE_FLOAT32:
|
---|
| 1174 | cbRet = sizeof(float);
|
---|
| 1175 | break;
|
---|
| 1176 | case RTTRACELOGTYPE_FLOAT64:
|
---|
| 1177 | cbRet = sizeof(double);
|
---|
| 1178 | break;
|
---|
| 1179 | case RTTRACELOGTYPE_RAWDATA:
|
---|
| 1180 | if (pEvtItemDesc->cbRawData == 0)
|
---|
| 1181 | {
|
---|
| 1182 | cbRet = pacbRawData[*pidxRawData];
|
---|
[103415] | 1183 | pidxRawData++;
|
---|
[71492] | 1184 | }
|
---|
| 1185 | else
|
---|
| 1186 | cbRet = pEvtItemDesc->cbRawData;
|
---|
| 1187 | break;
|
---|
| 1188 | case RTTRACELOGTYPE_POINTER:
|
---|
| 1189 | cbRet = pThis->cbTypePtr;
|
---|
| 1190 | break;
|
---|
| 1191 | case RTTRACELOGTYPE_SIZE:
|
---|
| 1192 | cbRet = pThis->cbTypeSize;
|
---|
| 1193 | break;
|
---|
| 1194 | default:
|
---|
| 1195 | AssertMsgFailed(("Invalid type given %d\n", pEvtItemDesc->enmType));
|
---|
| 1196 | }
|
---|
| 1197 |
|
---|
| 1198 | return cbRet;
|
---|
| 1199 | }
|
---|
| 1200 |
|
---|
| 1201 |
|
---|
| 1202 | /**
|
---|
| 1203 | * Resolves the offset of the field with the given name returning the offset and data type.
|
---|
| 1204 | *
|
---|
| 1205 | * @returns IPRT status code.
|
---|
| 1206 | * @param pEvt The event to fetch the data for.
|
---|
| 1207 | * @param pszName The field to fetch.
|
---|
| 1208 | * @param poffData Where to store the offset to the data on success.
|
---|
| 1209 | * @param pcbEvtData Where to store the size of the size of the event data.
|
---|
| 1210 | * @param ppEvtItemDesc Where to store the event item descriptor.
|
---|
| 1211 | */
|
---|
[85949] | 1212 | static int rtTraceLogRdrEvtResolveData(PCRTTRACELOGRDREVTINT pEvt, const char *pszName, uint32_t *poffData,
|
---|
[71492] | 1213 | size_t *pcbEvtData, PPCRTTRACELOGEVTITEMDESC ppEvtItemDesc)
|
---|
| 1214 | {
|
---|
| 1215 | PCRTTRACELOGRDREVTDESC pEvtDesc = pEvt->pEvtDesc;
|
---|
| 1216 | uint32_t offData = 0;
|
---|
| 1217 | unsigned idxRawData = 0;
|
---|
| 1218 |
|
---|
| 1219 | for (unsigned i = 0; i < pEvtDesc->EvtDesc.cEvtItems; i++)
|
---|
| 1220 | {
|
---|
| 1221 | PCRTTRACELOGEVTITEMDESC pEvtItemDesc = &pEvtDesc->aEvtItemDesc[i];
|
---|
| 1222 |
|
---|
| 1223 | if (!RTStrCmp(pszName, pEvtItemDesc->pszName))
|
---|
| 1224 | {
|
---|
| 1225 | *poffData = offData;
|
---|
| 1226 | *pcbEvtData = rtTraceLogRdrEvtItemGetSz(pEvt->pRdr, pEvtItemDesc, pEvt->pacbRawData, &idxRawData);
|
---|
| 1227 | *ppEvtItemDesc = pEvtItemDesc;
|
---|
| 1228 | return VINF_SUCCESS;
|
---|
| 1229 | }
|
---|
| 1230 |
|
---|
[71494] | 1231 | offData += (uint32_t)rtTraceLogRdrEvtItemGetSz(pEvt->pRdr, pEvtItemDesc, pEvt->pacbRawData, &idxRawData);
|
---|
[71492] | 1232 | }
|
---|
| 1233 |
|
---|
| 1234 | return VERR_NOT_FOUND;
|
---|
| 1235 | }
|
---|
| 1236 |
|
---|
| 1237 |
|
---|
| 1238 | /**
|
---|
| 1239 | * Fills a value with the given event data.
|
---|
| 1240 | *
|
---|
| 1241 | * @returns IPRT status code.
|
---|
| 1242 | * @param pEvt The event to fetch the data for.
|
---|
| 1243 | * @param offData Offset the data is located in the event.
|
---|
| 1244 | * @param cbData Number of bytes for the data.
|
---|
| 1245 | * @param pEvtItemDesc The event item descriptor.
|
---|
| 1246 | * @param pVal The value to fill.
|
---|
| 1247 | */
|
---|
[85949] | 1248 | static int rtTraceLogRdrEvtFillVal(PCRTTRACELOGRDREVTINT pEvt, uint32_t offData, size_t cbData, PCRTTRACELOGEVTITEMDESC pEvtItemDesc,
|
---|
[71492] | 1249 | PRTTRACELOGEVTVAL pVal)
|
---|
| 1250 | {
|
---|
| 1251 | PRTTRACELOGRDRINT pThis = pEvt->pRdr;
|
---|
[85949] | 1252 | const uint8_t *pbData = &pEvt->abEvtData[offData];
|
---|
[71492] | 1253 |
|
---|
| 1254 | pVal->pItemDesc = pEvtItemDesc;
|
---|
| 1255 | switch (pEvtItemDesc->enmType)
|
---|
| 1256 | {
|
---|
| 1257 | case RTTRACELOGTYPE_BOOL:
|
---|
[71494] | 1258 | pVal->u.f = *(bool *)pbData;
|
---|
[71492] | 1259 | break;
|
---|
| 1260 | case RTTRACELOGTYPE_UINT8:
|
---|
| 1261 | pVal->u.u8 = *pbData;
|
---|
| 1262 | break;
|
---|
| 1263 | case RTTRACELOGTYPE_INT8:
|
---|
| 1264 | pVal->u.i8 = *(int8_t *)pbData;
|
---|
| 1265 | break;
|
---|
| 1266 | case RTTRACELOGTYPE_UINT16:
|
---|
| 1267 | {
|
---|
| 1268 | uint16_t u16Tmp = *(uint16_t *)pbData;
|
---|
| 1269 | if (pThis->fConvEndianess)
|
---|
| 1270 | pVal->u.u16 = RT_BSWAP_U16(u16Tmp);
|
---|
| 1271 | else
|
---|
| 1272 | pVal->u.u16 = u16Tmp;
|
---|
| 1273 | break;
|
---|
| 1274 | }
|
---|
| 1275 | case RTTRACELOGTYPE_INT16:
|
---|
| 1276 | {
|
---|
| 1277 | uint8_t abData[2];
|
---|
| 1278 | if (pThis->fConvEndianess)
|
---|
| 1279 | {
|
---|
| 1280 | abData[0] = pbData[1];
|
---|
| 1281 | abData[1] = pbData[0];
|
---|
| 1282 | }
|
---|
| 1283 | else
|
---|
| 1284 | {
|
---|
| 1285 | abData[0] = pbData[0];
|
---|
| 1286 | abData[1] = pbData[1];
|
---|
| 1287 | }
|
---|
| 1288 |
|
---|
| 1289 | pVal->u.i16 = *(int16_t *)&abData[0];
|
---|
| 1290 | break;
|
---|
| 1291 | }
|
---|
| 1292 | case RTTRACELOGTYPE_UINT32:
|
---|
| 1293 | {
|
---|
| 1294 | uint32_t u32Tmp = *(uint32_t *)pbData;
|
---|
| 1295 | if (pThis->fConvEndianess)
|
---|
| 1296 | pVal->u.u32 = RT_BSWAP_U32(u32Tmp);
|
---|
| 1297 | else
|
---|
| 1298 | pVal->u.u32 = u32Tmp;
|
---|
| 1299 | break;
|
---|
| 1300 | }
|
---|
| 1301 | case RTTRACELOGTYPE_INT32:
|
---|
| 1302 | {
|
---|
| 1303 | uint8_t abData[4];
|
---|
| 1304 | if (pThis->fConvEndianess)
|
---|
| 1305 | {
|
---|
| 1306 | abData[0] = pbData[3];
|
---|
| 1307 | abData[1] = pbData[2];
|
---|
| 1308 | abData[2] = pbData[1];
|
---|
| 1309 | abData[3] = pbData[0];
|
---|
| 1310 | }
|
---|
| 1311 | else
|
---|
| 1312 | {
|
---|
| 1313 | abData[0] = pbData[0];
|
---|
| 1314 | abData[1] = pbData[1];
|
---|
| 1315 | abData[2] = pbData[2];
|
---|
| 1316 | abData[3] = pbData[3];
|
---|
| 1317 | }
|
---|
| 1318 |
|
---|
| 1319 | pVal->u.i32 = *(int32_t *)&abData[0];
|
---|
| 1320 | break;
|
---|
| 1321 | }
|
---|
| 1322 | case RTTRACELOGTYPE_UINT64:
|
---|
| 1323 | {
|
---|
| 1324 | uint64_t u64Tmp = *(uint64_t *)pbData;
|
---|
| 1325 | if (pThis->fConvEndianess)
|
---|
| 1326 | pVal->u.u64 = RT_BSWAP_U64(u64Tmp);
|
---|
| 1327 | else
|
---|
| 1328 | pVal->u.u64 = u64Tmp;
|
---|
| 1329 | break;
|
---|
| 1330 | }
|
---|
| 1331 | case RTTRACELOGTYPE_INT64:
|
---|
| 1332 | {
|
---|
| 1333 | uint8_t abData[8];
|
---|
| 1334 | if (pThis->fConvEndianess)
|
---|
| 1335 | {
|
---|
| 1336 | abData[0] = pbData[7];
|
---|
| 1337 | abData[1] = pbData[6];
|
---|
| 1338 | abData[2] = pbData[5];
|
---|
| 1339 | abData[3] = pbData[4];
|
---|
| 1340 | abData[4] = pbData[3];
|
---|
| 1341 | abData[5] = pbData[2];
|
---|
| 1342 | abData[6] = pbData[1];
|
---|
| 1343 | abData[7] = pbData[0];
|
---|
| 1344 | }
|
---|
| 1345 | else
|
---|
| 1346 | {
|
---|
| 1347 | abData[0] = pbData[0];
|
---|
| 1348 | abData[1] = pbData[1];
|
---|
| 1349 | abData[2] = pbData[2];
|
---|
| 1350 | abData[3] = pbData[3];
|
---|
| 1351 | abData[4] = pbData[4];
|
---|
| 1352 | abData[5] = pbData[5];
|
---|
| 1353 | abData[6] = pbData[6];
|
---|
| 1354 | abData[7] = pbData[7];
|
---|
| 1355 | }
|
---|
| 1356 |
|
---|
| 1357 | pVal->u.i32 = *(int64_t *)&abData[0];
|
---|
| 1358 | break;
|
---|
| 1359 | }
|
---|
| 1360 | case RTTRACELOGTYPE_FLOAT32:
|
---|
| 1361 | {
|
---|
| 1362 | uint8_t abData[4];
|
---|
| 1363 | if (pThis->fConvEndianess)
|
---|
| 1364 | {
|
---|
| 1365 | abData[0] = pbData[3];
|
---|
| 1366 | abData[1] = pbData[2];
|
---|
| 1367 | abData[2] = pbData[1];
|
---|
| 1368 | abData[3] = pbData[0];
|
---|
| 1369 | }
|
---|
| 1370 | else
|
---|
| 1371 | {
|
---|
| 1372 | abData[0] = pbData[0];
|
---|
| 1373 | abData[1] = pbData[1];
|
---|
| 1374 | abData[2] = pbData[2];
|
---|
| 1375 | abData[3] = pbData[3];
|
---|
| 1376 | }
|
---|
| 1377 |
|
---|
| 1378 | pVal->u.f32 = *(float *)&abData[0];
|
---|
| 1379 | break;
|
---|
| 1380 | }
|
---|
| 1381 | case RTTRACELOGTYPE_FLOAT64:
|
---|
| 1382 | {
|
---|
| 1383 | uint8_t abData[8];
|
---|
| 1384 | if (pThis->fConvEndianess)
|
---|
| 1385 | {
|
---|
| 1386 | abData[0] = pbData[7];
|
---|
| 1387 | abData[1] = pbData[6];
|
---|
| 1388 | abData[2] = pbData[5];
|
---|
| 1389 | abData[3] = pbData[4];
|
---|
| 1390 | abData[4] = pbData[3];
|
---|
| 1391 | abData[5] = pbData[2];
|
---|
| 1392 | abData[6] = pbData[1];
|
---|
| 1393 | abData[7] = pbData[0];
|
---|
| 1394 | }
|
---|
| 1395 | else
|
---|
| 1396 | {
|
---|
| 1397 | abData[0] = pbData[0];
|
---|
| 1398 | abData[1] = pbData[1];
|
---|
| 1399 | abData[2] = pbData[2];
|
---|
| 1400 | abData[3] = pbData[3];
|
---|
| 1401 | abData[4] = pbData[4];
|
---|
| 1402 | abData[5] = pbData[5];
|
---|
| 1403 | abData[6] = pbData[6];
|
---|
| 1404 | abData[7] = pbData[7];
|
---|
| 1405 | }
|
---|
| 1406 |
|
---|
| 1407 | pVal->u.f64 = *(double *)&abData[0];
|
---|
| 1408 | break;
|
---|
| 1409 | }
|
---|
| 1410 | case RTTRACELOGTYPE_RAWDATA:
|
---|
| 1411 | pVal->u.RawData.pb = pbData;
|
---|
| 1412 | if (pEvtItemDesc->cbRawData == 0)
|
---|
| 1413 | pVal->u.RawData.cb = cbData;
|
---|
| 1414 | else
|
---|
| 1415 | pVal->u.RawData.cb = pEvtItemDesc->cbRawData;
|
---|
| 1416 | break;
|
---|
| 1417 | case RTTRACELOGTYPE_POINTER:
|
---|
| 1418 | {
|
---|
| 1419 | if (pThis->cbTypePtr == 4)
|
---|
| 1420 | {
|
---|
| 1421 | if (pThis->fConvEndianess)
|
---|
| 1422 | pVal->u.uPtr = RT_BSWAP_U32(*(uint32_t *)pbData);
|
---|
| 1423 | else
|
---|
| 1424 | pVal->u.uPtr = *(uint32_t *)pbData;
|
---|
| 1425 | }
|
---|
| 1426 | else if (pThis->cbTypePtr == 8)
|
---|
| 1427 | {
|
---|
| 1428 | if (pThis->fConvEndianess)
|
---|
| 1429 | pVal->u.uPtr = RT_BSWAP_U64(*(uint64_t *)pbData);
|
---|
| 1430 | else
|
---|
| 1431 | pVal->u.uPtr = *(uint64_t *)pbData;
|
---|
| 1432 | }
|
---|
| 1433 | else
|
---|
| 1434 | AssertMsgFailed(("Invalid pointer size %d, should not happen!\n", pThis->cbTypePtr));
|
---|
| 1435 | break;
|
---|
| 1436 | }
|
---|
| 1437 | case RTTRACELOGTYPE_SIZE:
|
---|
| 1438 | {
|
---|
| 1439 | if (pThis->cbTypeSize == 4)
|
---|
| 1440 | {
|
---|
| 1441 | if (pThis->fConvEndianess)
|
---|
| 1442 | pVal->u.sz = RT_BSWAP_U32(*(uint32_t *)pbData);
|
---|
| 1443 | else
|
---|
| 1444 | pVal->u.sz = *(uint32_t *)pbData;
|
---|
| 1445 | }
|
---|
| 1446 | else if (pThis->cbTypeSize == 8)
|
---|
| 1447 | {
|
---|
| 1448 | if (pThis->fConvEndianess)
|
---|
| 1449 | pVal->u.sz = RT_BSWAP_U64(*(uint64_t *)pbData);
|
---|
| 1450 | else
|
---|
| 1451 | pVal->u.sz = *(uint64_t *)pbData;
|
---|
| 1452 | }
|
---|
| 1453 | else
|
---|
| 1454 | AssertMsgFailed(("Invalid size_t size %d, should not happen!\n", pThis->cbTypeSize));
|
---|
| 1455 | break;
|
---|
| 1456 | }
|
---|
| 1457 | default:
|
---|
| 1458 | AssertMsgFailed(("Invalid type given %d\n", pEvtItemDesc->enmType));
|
---|
| 1459 | }
|
---|
| 1460 |
|
---|
| 1461 | return VINF_SUCCESS;
|
---|
| 1462 | }
|
---|
| 1463 |
|
---|
| 1464 |
|
---|
[85949] | 1465 | /**
|
---|
| 1466 | * Finds the mapping descriptor for the given event.
|
---|
| 1467 | *
|
---|
| 1468 | * @returns Pointer to the mapping descriptor or NULL if not found.
|
---|
| 1469 | * @param paMapDesc Pointer to the array of mapping descriptors.
|
---|
| 1470 | * @param pEvt The event to look for the matching mapping descriptor.
|
---|
| 1471 | */
|
---|
| 1472 | static PCRTTRACELOGRDRMAPDESC rtTraceLogRdrMapDescFindForEvt(PCRTTRACELOGRDRMAPDESC paMapDesc, PCRTTRACELOGRDREVTINT pEvt)
|
---|
| 1473 | {
|
---|
| 1474 | AssertPtrReturn(paMapDesc, NULL);
|
---|
| 1475 | AssertPtrReturn(pEvt, NULL);
|
---|
| 1476 |
|
---|
| 1477 | while (paMapDesc->pszEvtId)
|
---|
| 1478 | {
|
---|
| 1479 | if (!RTStrCmp(paMapDesc->pszEvtId, pEvt->pEvtDesc->EvtDesc.pszId))
|
---|
| 1480 | return paMapDesc;
|
---|
| 1481 |
|
---|
| 1482 | paMapDesc++;
|
---|
| 1483 | }
|
---|
| 1484 |
|
---|
| 1485 | return NULL;
|
---|
| 1486 | }
|
---|
| 1487 |
|
---|
| 1488 |
|
---|
| 1489 | /**
|
---|
| 1490 | * Fills the given event header with data from the given event using the matching mapping descriptor.
|
---|
| 1491 | *
|
---|
| 1492 | * @returns IPRT statsu code.
|
---|
| 1493 | * @param pEvtHdr The event header to fill.
|
---|
| 1494 | * @param pMapDesc The mapping descriptor to use.
|
---|
| 1495 | * @param pEvt The raw event to get the data from.
|
---|
| 1496 | */
|
---|
| 1497 | static int rtTraceLogRdrMapFillEvt(PRTTRACELOGRDREVTHDR pEvtHdr, PCRTTRACELOGRDRMAPDESC pMapDesc, PCRTTRACELOGRDREVTINT pEvt)
|
---|
| 1498 | {
|
---|
| 1499 | int rc = VINF_SUCCESS;
|
---|
| 1500 |
|
---|
| 1501 | /* Fill in the status parts. */
|
---|
| 1502 | pEvtHdr->pEvtMapDesc = pMapDesc;
|
---|
| 1503 | pEvtHdr->pEvtDesc = &pEvt->pEvtDesc->EvtDesc;
|
---|
| 1504 | pEvtHdr->idSeqNo = pEvt->u64SeqNo;
|
---|
| 1505 | pEvtHdr->tsEvt = pEvt->u64Ts;
|
---|
| 1506 | pEvtHdr->paEvtItems = NULL;
|
---|
| 1507 |
|
---|
| 1508 | /* Now the individual items if any. */
|
---|
| 1509 | if (pMapDesc->cEvtItems)
|
---|
| 1510 | {
|
---|
| 1511 | /* Allocate values for the items. */
|
---|
| 1512 | pEvtHdr->paEvtItems = (PCRTTRACELOGEVTVAL)RTMemAllocZ(pMapDesc->cEvtItems * sizeof(RTTRACELOGEVTVAL));
|
---|
| 1513 | if (RT_LIKELY(pEvtHdr->paEvtItems))
|
---|
| 1514 | {
|
---|
| 1515 | for (uint32_t i = 0; (i < pMapDesc->cEvtItems) && RT_SUCCESS(rc); i++)
|
---|
| 1516 | {
|
---|
| 1517 | uint32_t offData = 0;
|
---|
| 1518 | size_t cbData = 0;
|
---|
| 1519 | PCRTTRACELOGEVTITEMDESC pEvtItemDesc = NULL;
|
---|
| 1520 | rc = rtTraceLogRdrEvtResolveData(pEvt, pMapDesc->paMapItems[i].pszName, &offData, &cbData, &pEvtItemDesc);
|
---|
| 1521 | if (RT_SUCCESS(rc))
|
---|
| 1522 | rc = rtTraceLogRdrEvtFillVal(pEvt, offData, cbData, pEvtItemDesc, (PRTTRACELOGEVTVAL)&pEvtHdr->paEvtItems[i]);
|
---|
| 1523 | }
|
---|
| 1524 |
|
---|
| 1525 | if (RT_FAILURE(rc))
|
---|
| 1526 | {
|
---|
| 1527 | RTMemFree((void *)pEvtHdr->paEvtItems);
|
---|
| 1528 | pEvtHdr->paEvtItems = NULL;
|
---|
| 1529 | }
|
---|
| 1530 | }
|
---|
| 1531 | else
|
---|
| 1532 | rc = VERR_NO_MEMORY;
|
---|
| 1533 | }
|
---|
| 1534 |
|
---|
| 1535 | return rc;
|
---|
| 1536 | }
|
---|
| 1537 |
|
---|
| 1538 |
|
---|
[71492] | 1539 | RTDECL(int) RTTraceLogRdrCreate(PRTTRACELOGRDR phTraceLogRdr, PFNRTTRACELOGRDRSTREAM pfnStreamIn,
|
---|
| 1540 | PFNRTTRACELOGSTREAMCLOSE pfnStreamClose, void *pvUser)
|
---|
| 1541 | {
|
---|
| 1542 | AssertPtrReturn(phTraceLogRdr, VERR_INVALID_POINTER);
|
---|
| 1543 | AssertPtrReturn(pfnStreamIn, VERR_INVALID_POINTER);
|
---|
| 1544 | AssertPtrReturn(pfnStreamClose, VERR_INVALID_POINTER);
|
---|
| 1545 | int rc = VINF_SUCCESS;
|
---|
| 1546 | PRTTRACELOGRDRINT pThis = (PRTTRACELOGRDRINT)RTMemAllocZ(sizeof(*pThis));
|
---|
| 1547 | if (pThis)
|
---|
| 1548 | {
|
---|
| 1549 | rc = RTSemMutexCreate(&pThis->hMtx);
|
---|
| 1550 | if (RT_SUCCESS(rc))
|
---|
| 1551 | {
|
---|
| 1552 | rc = RTStrCacheCreate(&pThis->hStrCache, "TRACELOGRDR");
|
---|
| 1553 | if (RT_SUCCESS(rc))
|
---|
| 1554 | {
|
---|
| 1555 | RTListInit(&pThis->LstEvts);
|
---|
| 1556 | pThis->u32Magic = RTTRACELOGRDR_MAGIC;
|
---|
| 1557 | pThis->pfnStreamIn = pfnStreamIn;
|
---|
| 1558 | pThis->pfnStreamClose = pfnStreamClose;
|
---|
| 1559 | pThis->pvUser = pvUser;
|
---|
| 1560 | pThis->enmState = RTTRACELOGRDRSTATE_RECV_HDR;
|
---|
| 1561 | pThis->fConvEndianess = false;
|
---|
| 1562 | pThis->pszDesc = NULL;
|
---|
| 1563 | pThis->cEvtDescsCur = 0;
|
---|
| 1564 | pThis->cEvtDescsMax = 0;
|
---|
| 1565 | pThis->papEvtDescs = NULL;
|
---|
| 1566 | pThis->pEvtDescCur = NULL;
|
---|
| 1567 | pThis->u64SeqNoLast = 0;
|
---|
| 1568 | pThis->cbScratch = sizeof(TRACELOGHDR);
|
---|
| 1569 | pThis->offScratch = 0;
|
---|
| 1570 | pThis->cbRecvLeft = sizeof(TRACELOGHDR);
|
---|
| 1571 | pThis->pbScratch = (uint8_t *)RTMemAllocZ(pThis->cbScratch);
|
---|
| 1572 | if (RT_LIKELY(pThis->pbScratch))
|
---|
| 1573 | {
|
---|
| 1574 | *phTraceLogRdr = pThis;
|
---|
| 1575 | return VINF_SUCCESS;
|
---|
| 1576 | }
|
---|
| 1577 | else
|
---|
| 1578 | rc = VERR_NO_MEMORY;
|
---|
| 1579 |
|
---|
| 1580 | RTStrCacheDestroy(pThis->hStrCache);
|
---|
| 1581 | }
|
---|
| 1582 |
|
---|
| 1583 | RTSemMutexDestroy(pThis->hMtx);
|
---|
| 1584 | }
|
---|
| 1585 | RTMemFree(pThis);
|
---|
| 1586 | }
|
---|
| 1587 | else
|
---|
| 1588 | rc = VERR_NO_MEMORY;
|
---|
| 1589 |
|
---|
| 1590 | return rc;
|
---|
| 1591 | }
|
---|
| 1592 |
|
---|
| 1593 |
|
---|
| 1594 | RTDECL(int) RTTraceLogRdrCreateFromFile(PRTTRACELOGRDR phTraceLogRdr, const char *pszFilename)
|
---|
| 1595 | {
|
---|
| 1596 | AssertPtrReturn(phTraceLogRdr, VERR_INVALID_POINTER);
|
---|
| 1597 | AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
|
---|
| 1598 |
|
---|
| 1599 | RTFILE hFile = NIL_RTFILE;
|
---|
| 1600 | int rc = RTFileOpen(&hFile, pszFilename, RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_NONE);
|
---|
| 1601 | if (RT_SUCCESS(rc))
|
---|
| 1602 | {
|
---|
| 1603 | rc = RTTraceLogRdrCreate(phTraceLogRdr, rtTraceLogRdrFileStream, rtTraceLogRdrFileStreamClose, hFile);
|
---|
| 1604 | if (RT_FAILURE(rc))
|
---|
| 1605 | {
|
---|
| 1606 | RTFileClose(hFile);
|
---|
| 1607 | RTFileDelete(pszFilename);
|
---|
| 1608 | }
|
---|
| 1609 | }
|
---|
| 1610 |
|
---|
| 1611 | return rc;
|
---|
| 1612 | }
|
---|
| 1613 |
|
---|
| 1614 |
|
---|
| 1615 | RTDECL(int) RTTraceLogRdrDestroy(RTTRACELOGRDR hTraceLogRdr)
|
---|
| 1616 | {
|
---|
[86386] | 1617 | if (hTraceLogRdr == NIL_RTTRACELOGRDR)
|
---|
| 1618 | return VINF_SUCCESS;
|
---|
[71492] | 1619 | PRTTRACELOGRDRINT pThis = hTraceLogRdr;
|
---|
| 1620 | AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
|
---|
[86386] | 1621 | AssertReturn(pThis->u32Magic == RTTRACELOGRDR_MAGIC, VERR_INVALID_HANDLE);
|
---|
[71492] | 1622 |
|
---|
| 1623 | pThis->u32Magic = RTTRACELOGRDR_MAGIC_DEAD;
|
---|
[86386] | 1624 | int rc = pThis->pfnStreamClose(pThis->pvUser);
|
---|
| 1625 | AssertRC(rc);
|
---|
| 1626 |
|
---|
[71492] | 1627 | for (unsigned i = 0; i < pThis->cEvtDescsCur; i++)
|
---|
| 1628 | RTMemFree(pThis->papEvtDescs[i]);
|
---|
| 1629 | if (pThis->papEvtDescs)
|
---|
[86386] | 1630 | {
|
---|
[71492] | 1631 | RTMemFree(pThis->papEvtDescs);
|
---|
[86386] | 1632 | pThis->papEvtDescs = NULL;
|
---|
| 1633 | }
|
---|
| 1634 |
|
---|
| 1635 | if (pThis->pEvtCur)
|
---|
| 1636 | {
|
---|
| 1637 | RTMemFree(pThis->pEvtCur);
|
---|
| 1638 | pThis->pEvtCur = NULL;
|
---|
| 1639 | }
|
---|
| 1640 |
|
---|
| 1641 | PRTTRACELOGRDREVTINT pCur, pNext;
|
---|
| 1642 | RTListForEachSafe(&pThis->LstEvts, pCur, pNext, RTTRACELOGRDREVTINT, NdGlob)
|
---|
| 1643 | {
|
---|
| 1644 | RTMemFree(pCur);
|
---|
| 1645 | }
|
---|
| 1646 |
|
---|
[71492] | 1647 | RTSemMutexDestroy(pThis->hMtx);
|
---|
[86386] | 1648 | pThis->hMtx = NIL_RTSEMMUTEX;
|
---|
| 1649 |
|
---|
[71492] | 1650 | RTMemFree(pThis->pbScratch);
|
---|
[86386] | 1651 | pThis->pbScratch = NULL;
|
---|
| 1652 |
|
---|
[71492] | 1653 | RTStrCacheDestroy(pThis->hStrCache);
|
---|
[86386] | 1654 | pThis->hStrCache = NIL_RTSTRCACHE;
|
---|
| 1655 |
|
---|
[71492] | 1656 | RTMemFree(pThis);
|
---|
| 1657 | return VINF_SUCCESS;
|
---|
| 1658 | }
|
---|
| 1659 |
|
---|
| 1660 |
|
---|
| 1661 | RTDECL(int) RTTraceLogRdrEvtPoll(RTTRACELOGRDR hTraceLogRdr, RTTRACELOGRDRPOLLEVT *penmEvt, RTMSINTERVAL cMsTimeout)
|
---|
| 1662 | {
|
---|
| 1663 | PRTTRACELOGRDRINT pThis = hTraceLogRdr;
|
---|
| 1664 | AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
|
---|
[86386] | 1665 | AssertReturn(pThis->u32Magic == RTTRACELOGRDR_MAGIC, VERR_INVALID_HANDLE);
|
---|
[71492] | 1666 | AssertPtrReturn(penmEvt, VERR_INVALID_POINTER);
|
---|
| 1667 |
|
---|
| 1668 | int rc = VINF_SUCCESS;
|
---|
| 1669 | bool fContinue = true;
|
---|
| 1670 | while ( RT_SUCCESS(rc)
|
---|
| 1671 | && fContinue)
|
---|
| 1672 | {
|
---|
| 1673 | size_t cbRecvd = 0;
|
---|
| 1674 |
|
---|
| 1675 | rc = rtTraceLogRdrStreamRead(pThis, &pThis->pbScratch[pThis->offScratch],
|
---|
| 1676 | pThis->cbRecvLeft, &cbRecvd, cMsTimeout);
|
---|
| 1677 | if (RT_SUCCESS(rc))
|
---|
| 1678 | {
|
---|
| 1679 | if (cbRecvd == pThis->cbRecvLeft)
|
---|
| 1680 | {
|
---|
| 1681 | /* Act according to the current state. */
|
---|
[85160] | 1682 | rc = g_aStateHandlers[pThis->enmState].pfn(pThis, penmEvt, &fContinue);
|
---|
[71492] | 1683 | }
|
---|
| 1684 | else
|
---|
| 1685 | pThis->cbRecvLeft -= cbRecvd;
|
---|
| 1686 | }
|
---|
| 1687 | }
|
---|
| 1688 |
|
---|
| 1689 | return rc;
|
---|
| 1690 | }
|
---|
| 1691 |
|
---|
| 1692 |
|
---|
| 1693 | RTDECL(int) RTTraceLogRdrQueryLastEvt(RTTRACELOGRDR hTraceLogRdr, PRTTRACELOGRDREVT phRdrEvt)
|
---|
| 1694 | {
|
---|
| 1695 | PRTTRACELOGRDRINT pThis = hTraceLogRdr;
|
---|
| 1696 | AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
|
---|
[86386] | 1697 | AssertReturn(pThis->u32Magic == RTTRACELOGRDR_MAGIC, VERR_INVALID_HANDLE);
|
---|
[71492] | 1698 | AssertPtrReturn(phRdrEvt, VERR_INVALID_POINTER);
|
---|
| 1699 |
|
---|
| 1700 | int rc = VINF_SUCCESS;
|
---|
| 1701 | RTSemMutexRequest(pThis->hMtx, RT_INDEFINITE_WAIT);
|
---|
| 1702 | PRTTRACELOGRDREVTINT pEvt = RTListGetLast(&pThis->LstEvts, RTTRACELOGRDREVTINT, NdGlob);
|
---|
| 1703 | *phRdrEvt = pEvt;
|
---|
| 1704 | if (!pEvt)
|
---|
| 1705 | rc = VERR_NOT_FOUND;
|
---|
| 1706 | RTSemMutexRelease(pThis->hMtx);
|
---|
| 1707 |
|
---|
| 1708 | return rc;
|
---|
| 1709 | }
|
---|
| 1710 |
|
---|
| 1711 |
|
---|
| 1712 | RTDECL(int) RTTraceLogRdrQueryIterator(RTTRACELOGRDR hTraceLogRdr, PRTTRACELOGRDRIT phIt)
|
---|
| 1713 | {
|
---|
| 1714 | PRTTRACELOGRDRINT pThis = hTraceLogRdr;
|
---|
| 1715 | AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
|
---|
[86386] | 1716 | AssertReturn(pThis->u32Magic == RTTRACELOGRDR_MAGIC, VERR_INVALID_HANDLE);
|
---|
[71492] | 1717 | AssertPtrReturn(phIt, VERR_INVALID_POINTER);
|
---|
| 1718 |
|
---|
| 1719 | int rc = VINF_SUCCESS;
|
---|
| 1720 | PRTTRACELOGRDRITINT pIt = (PRTTRACELOGRDRITINT)RTMemAllocZ(sizeof(*pIt));
|
---|
| 1721 | if (RT_LIKELY(pIt))
|
---|
| 1722 | {
|
---|
| 1723 | pIt->pRdr = pThis;
|
---|
| 1724 | pIt->pEvt = RTListGetFirst(&pThis->LstEvts, RTTRACELOGRDREVTINT, NdGlob);
|
---|
[95382] | 1725 | *phIt = pIt;
|
---|
[71492] | 1726 | }
|
---|
| 1727 | else
|
---|
| 1728 | rc = VERR_NO_MEMORY;
|
---|
| 1729 |
|
---|
| 1730 | return rc;
|
---|
| 1731 | }
|
---|
| 1732 |
|
---|
| 1733 |
|
---|
[85949] | 1734 | RTDECL(int) RTTraceLogRdrEvtMapToStruct(RTTRACELOGRDR hTraceLogRdr, uint32_t fFlags, uint32_t cEvts,
|
---|
| 1735 | PCRTTRACELOGRDRMAPDESC paMapDesc, PCRTTRACELOGRDREVTHDR *ppaEvtHdr,
|
---|
| 1736 | uint32_t *pcEvts)
|
---|
| 1737 | {
|
---|
| 1738 | RT_NOREF(fFlags);
|
---|
| 1739 |
|
---|
| 1740 | PRTTRACELOGRDRINT pThis = hTraceLogRdr;
|
---|
| 1741 | AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
|
---|
[86386] | 1742 | AssertReturn(pThis->u32Magic == RTTRACELOGRDR_MAGIC, VERR_INVALID_HANDLE);
|
---|
[85949] | 1743 | AssertPtrReturn(paMapDesc, VERR_INVALID_PARAMETER);
|
---|
| 1744 | AssertPtrReturn(ppaEvtHdr, VERR_INVALID_POINTER);
|
---|
| 1745 | AssertPtrReturn(pcEvts, VERR_INVALID_POINTER);
|
---|
| 1746 |
|
---|
| 1747 | int rc = VINF_SUCCESS;
|
---|
| 1748 | uint32_t cEvtsAlloc = cEvts != UINT32_MAX ? cEvts : _4K;
|
---|
| 1749 | PRTTRACELOGRDREVTHDR paEvtHdr = (PRTTRACELOGRDREVTHDR)RTMemAllocZ(cEvtsAlloc * sizeof(*paEvtHdr));
|
---|
| 1750 | if (RT_LIKELY(paEvtHdr))
|
---|
| 1751 | {
|
---|
| 1752 | uint32_t cEvtsRecv = 0;
|
---|
| 1753 |
|
---|
| 1754 | while ( RT_SUCCESS(rc)
|
---|
| 1755 | && cEvtsRecv < cEvts)
|
---|
| 1756 | {
|
---|
| 1757 | RTTRACELOGRDRPOLLEVT enmEvt = RTTRACELOGRDRPOLLEVT_INVALID;
|
---|
| 1758 | rc = RTTraceLogRdrEvtPoll(pThis, &enmEvt, 0 /*cMsTimeout*/);
|
---|
| 1759 | if ( RT_SUCCESS(rc)
|
---|
| 1760 | && enmEvt == RTTRACELOGRDRPOLLEVT_TRACE_EVENT_RECVD)
|
---|
| 1761 | {
|
---|
| 1762 | /* Find the mapping descriptor. */
|
---|
| 1763 | PRTTRACELOGRDREVTINT pEvt = NULL;
|
---|
| 1764 | rc = RTTraceLogRdrQueryLastEvt(hTraceLogRdr, &pEvt);
|
---|
| 1765 | if (RT_SUCCESS(rc))
|
---|
| 1766 | {
|
---|
| 1767 | PCRTTRACELOGRDRMAPDESC pMapDesc = rtTraceLogRdrMapDescFindForEvt(paMapDesc, pEvt);
|
---|
| 1768 | if (pMapDesc)
|
---|
| 1769 | {
|
---|
| 1770 | if (cEvtsRecv == cEvtsAlloc)
|
---|
| 1771 | {
|
---|
| 1772 | Assert(cEvts == UINT32_MAX);
|
---|
| 1773 | PRTTRACELOGRDREVTHDR paEvtHdrNew = (PRTTRACELOGRDREVTHDR)RTMemRealloc(paEvtHdr, (cEvtsAlloc + _4K) * sizeof(*paEvtHdr));
|
---|
| 1774 | if (RT_LIKELY(paEvtHdrNew))
|
---|
| 1775 | {
|
---|
| 1776 | paEvtHdr = paEvtHdrNew;
|
---|
| 1777 | cEvtsAlloc += _4K;
|
---|
| 1778 | }
|
---|
| 1779 | else
|
---|
| 1780 | rc = VERR_NO_MEMORY;
|
---|
| 1781 | }
|
---|
| 1782 |
|
---|
| 1783 | if (RT_SUCCESS(rc))
|
---|
| 1784 | rc = rtTraceLogRdrMapFillEvt(&paEvtHdr[cEvtsRecv++], pMapDesc, pEvt);
|
---|
| 1785 | cEvtsRecv++;
|
---|
| 1786 | }
|
---|
| 1787 | else
|
---|
| 1788 | rc = VERR_NOT_FOUND;
|
---|
| 1789 | }
|
---|
| 1790 | }
|
---|
| 1791 | }
|
---|
| 1792 |
|
---|
| 1793 | if (RT_SUCCESS(rc))
|
---|
| 1794 | {
|
---|
| 1795 | *ppaEvtHdr = paEvtHdr;
|
---|
| 1796 | *pcEvts = cEvtsRecv;
|
---|
| 1797 | }
|
---|
| 1798 | else
|
---|
| 1799 | RTTraceLogRdrEvtMapFree(paEvtHdr, cEvtsRecv);
|
---|
| 1800 | }
|
---|
| 1801 | else
|
---|
| 1802 | rc = VERR_NO_MEMORY;
|
---|
| 1803 |
|
---|
| 1804 | return rc;
|
---|
| 1805 | }
|
---|
| 1806 |
|
---|
| 1807 |
|
---|
| 1808 | RTDECL(void) RTTraceLogRdrEvtMapFree(PCRTTRACELOGRDREVTHDR paEvtHdr, uint32_t cEvts)
|
---|
| 1809 | {
|
---|
| 1810 | for (uint32_t i = 0; i < cEvts; i++)
|
---|
| 1811 | {
|
---|
| 1812 | if (paEvtHdr[i].paEvtItems)
|
---|
| 1813 | RTMemFree((void *)paEvtHdr[i].paEvtItems);
|
---|
| 1814 | }
|
---|
| 1815 |
|
---|
| 1816 | RTMemFree((void *)paEvtHdr);
|
---|
| 1817 | }
|
---|
| 1818 |
|
---|
| 1819 |
|
---|
[71492] | 1820 | RTDECL(void) RTTraceLogRdrIteratorFree(RTTRACELOGRDRIT hIt)
|
---|
| 1821 | {
|
---|
| 1822 | PRTTRACELOGRDRITINT pIt = hIt;
|
---|
| 1823 | AssertPtrReturnVoid(pIt);
|
---|
| 1824 |
|
---|
| 1825 | RTMemFree(pIt);
|
---|
| 1826 | }
|
---|
| 1827 |
|
---|
| 1828 |
|
---|
| 1829 | RTDECL(int) RTTraceLogRdrIteratorNext(RTTRACELOGRDRIT hIt)
|
---|
| 1830 | {
|
---|
| 1831 | PRTTRACELOGRDRITINT pIt = hIt;
|
---|
| 1832 | AssertPtrReturn(pIt, VERR_INVALID_HANDLE);
|
---|
| 1833 |
|
---|
| 1834 | if (!pIt->pEvt)
|
---|
| 1835 | return VERR_TRACELOG_READER_ITERATOR_END;
|
---|
| 1836 |
|
---|
| 1837 | int rc = VINF_SUCCESS;
|
---|
| 1838 | PRTTRACELOGRDREVTINT pEvtNext = RTListGetNext(&pIt->pRdr->LstEvts, pIt->pEvt, RTTRACELOGRDREVTINT, NdGlob);
|
---|
| 1839 |
|
---|
| 1840 | if (pEvtNext)
|
---|
| 1841 | pIt->pEvt = pEvtNext;
|
---|
| 1842 | else
|
---|
| 1843 | rc = VERR_TRACELOG_READER_ITERATOR_END;
|
---|
| 1844 |
|
---|
| 1845 | return rc;
|
---|
| 1846 | }
|
---|
| 1847 |
|
---|
| 1848 |
|
---|
| 1849 | RTDECL(int) RTTraceLogRdrIteratorQueryEvent(RTTRACELOGRDRIT hIt, PRTTRACELOGRDREVT phRdrEvt)
|
---|
| 1850 | {
|
---|
| 1851 | PRTTRACELOGRDRITINT pIt = hIt;
|
---|
| 1852 | AssertPtrReturn(pIt, VERR_INVALID_HANDLE);
|
---|
| 1853 | AssertPtrReturn(phRdrEvt, VERR_INVALID_POINTER);
|
---|
| 1854 |
|
---|
| 1855 | *phRdrEvt = pIt->pEvt;
|
---|
| 1856 | return VINF_SUCCESS;
|
---|
| 1857 | }
|
---|
| 1858 |
|
---|
| 1859 |
|
---|
| 1860 | RTDECL(uint64_t) RTTraceLogRdrEvtGetSeqNo(RTTRACELOGRDREVT hRdrEvt)
|
---|
| 1861 | {
|
---|
| 1862 | PRTTRACELOGRDREVTINT pEvt = hRdrEvt;
|
---|
[71494] | 1863 | AssertPtrReturn(pEvt, 0);
|
---|
[71492] | 1864 |
|
---|
| 1865 | return pEvt->u64SeqNo;
|
---|
| 1866 | }
|
---|
| 1867 |
|
---|
| 1868 |
|
---|
| 1869 | RTDECL(uint64_t) RTTraceLogRdrEvtGetTs(RTTRACELOGRDREVT hRdrEvt)
|
---|
| 1870 | {
|
---|
| 1871 | PRTTRACELOGRDREVTINT pEvt = hRdrEvt;
|
---|
[71494] | 1872 | AssertPtrReturn(pEvt, 0);
|
---|
[71492] | 1873 |
|
---|
| 1874 | return pEvt->u64Ts;
|
---|
| 1875 | }
|
---|
| 1876 |
|
---|
| 1877 |
|
---|
| 1878 | RTDECL(bool) RTTraceLogRdrEvtIsGrouped(RTTRACELOGRDREVT hRdrEvt)
|
---|
| 1879 | {
|
---|
| 1880 | PRTTRACELOGRDREVTINT pEvt = hRdrEvt;
|
---|
[71494] | 1881 | AssertPtrReturn(pEvt, false);
|
---|
[71492] | 1882 |
|
---|
| 1883 | return pEvt->idGrp != 0;
|
---|
| 1884 | }
|
---|
| 1885 |
|
---|
| 1886 |
|
---|
| 1887 | RTDECL(PCRTTRACELOGEVTDESC) RTTraceLogRdrEvtGetDesc(RTTRACELOGRDREVT hRdrEvt)
|
---|
| 1888 | {
|
---|
| 1889 | PRTTRACELOGRDREVTINT pEvt = hRdrEvt;
|
---|
| 1890 | AssertPtrReturn(pEvt, NULL);
|
---|
| 1891 |
|
---|
| 1892 | return &pEvt->pEvtDesc->EvtDesc;
|
---|
| 1893 | }
|
---|
| 1894 |
|
---|
| 1895 |
|
---|
| 1896 | RTDECL(int) RTTraceLogRdrEvtQueryVal(RTTRACELOGRDREVT hRdrEvt, const char *pszName, PRTTRACELOGEVTVAL pVal)
|
---|
| 1897 | {
|
---|
| 1898 | PRTTRACELOGRDREVTINT pEvt = hRdrEvt;
|
---|
| 1899 | AssertPtrReturn(pEvt, VERR_INVALID_HANDLE);
|
---|
| 1900 |
|
---|
| 1901 | uint32_t offData = 0;
|
---|
| 1902 | size_t cbData = 0;
|
---|
| 1903 | PCRTTRACELOGEVTITEMDESC pEvtItemDesc = NULL;
|
---|
| 1904 | int rc = rtTraceLogRdrEvtResolveData(pEvt, pszName, &offData, &cbData, &pEvtItemDesc);
|
---|
| 1905 | if (RT_SUCCESS(rc))
|
---|
| 1906 | rc = rtTraceLogRdrEvtFillVal(pEvt, offData, cbData, pEvtItemDesc, pVal);
|
---|
| 1907 | return rc;
|
---|
| 1908 | }
|
---|
| 1909 |
|
---|
| 1910 |
|
---|
| 1911 | RTDECL(int) RTTraceLogRdrEvtFillVals(RTTRACELOGRDREVT hRdrEvt, unsigned idxItemStart, PRTTRACELOGEVTVAL paVals,
|
---|
| 1912 | unsigned cVals, unsigned *pcVals)
|
---|
| 1913 | {
|
---|
| 1914 | PRTTRACELOGRDREVTINT pEvt = hRdrEvt;
|
---|
| 1915 | AssertPtrReturn(pEvt, VERR_INVALID_HANDLE);
|
---|
| 1916 |
|
---|
| 1917 | PCRTTRACELOGRDREVTDESC pEvtDesc = pEvt->pEvtDesc;
|
---|
| 1918 | AssertReturn(idxItemStart < pEvtDesc->EvtDesc.cEvtItems, VERR_INVALID_PARAMETER);
|
---|
| 1919 |
|
---|
| 1920 | /* Advance to the item the caller wants to fill in. */
|
---|
| 1921 | uint32_t offData = 0;
|
---|
| 1922 | unsigned idxRawData = 0;
|
---|
| 1923 |
|
---|
| 1924 | for (unsigned i = 0; i < idxItemStart; i++)
|
---|
| 1925 | {
|
---|
| 1926 | PCRTTRACELOGEVTITEMDESC pEvtItemDesc = &pEvtDesc->aEvtItemDesc[i];
|
---|
[71494] | 1927 | offData += (uint32_t)rtTraceLogRdrEvtItemGetSz(pEvt->pRdr, pEvtItemDesc, pEvt->pacbRawData, &idxRawData);
|
---|
[71492] | 1928 | }
|
---|
| 1929 |
|
---|
| 1930 | int rc = VINF_SUCCESS;
|
---|
| 1931 | unsigned idxItemEnd = RT_MIN(idxItemStart + cVals, pEvtDesc->EvtDesc.cEvtItems);
|
---|
| 1932 | for (unsigned i = idxItemStart; i < idxItemEnd && RT_SUCCESS(rc); i++)
|
---|
| 1933 | {
|
---|
| 1934 | PCRTTRACELOGEVTITEMDESC pEvtItemDesc = &pEvtDesc->aEvtItemDesc[i];
|
---|
| 1935 | size_t cbData = rtTraceLogRdrEvtItemGetSz(pEvt->pRdr, pEvtItemDesc, pEvt->pacbRawData, &idxRawData);
|
---|
| 1936 |
|
---|
| 1937 | rc = rtTraceLogRdrEvtFillVal(pEvt, offData, cbData, pEvtItemDesc, &paVals[i - idxItemStart]);
|
---|
[71494] | 1938 | offData += (uint32_t)cbData;
|
---|
[71492] | 1939 | }
|
---|
| 1940 |
|
---|
| 1941 | *pcVals = idxItemEnd - idxItemStart;
|
---|
| 1942 |
|
---|
| 1943 | return rc;
|
---|
| 1944 | }
|
---|
| 1945 |
|
---|