RTTraceLogTool.cpp

Last change on this file was 106061, checked in by vboxsync, 8 weeks ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 32.5 KB

Line
1	/* $Id: RTTraceLogTool.cpp 106061 2024-09-16 14:03:52Z vboxsync $ */
2	/** @file
3	* IPRT - Utility for reading/receiving and dissecting trace logs.
4	*/
5
6	/*
7	* Copyright (C) 2018-2024 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
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	*
25	* The contents of this file may alternatively be used under the terms
26	* of the Common Development and Distribution License Version 1.0
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
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.
33	*
34	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35	*/
36
37
38	/*********************************************************************************************************************************
39	* Header Files *
40	*********************************************************************************************************************************/
41	#include <iprt/tracelog.h>
42	#include <iprt/tracelog-decoder-plugin.h>
43
44	#include <iprt/assert.h>
45	#include <iprt/errcore.h>
46	#include <iprt/file.h>
47	#include <iprt/getopt.h>
48	#include <iprt/initterm.h>
49	#include <iprt/ldr.h>
50	#include <iprt/message.h>
51	#include <iprt/mem.h>
52	#include <iprt/path.h>
53	#include <iprt/stream.h>
54	#include <iprt/string.h>
55	#include <iprt/tcp.h>
56
57
58	typedef struct RTTRACELOGDECODER
59	{
60	/** The tracelog decoder registration structure. */
61	PCRTTRACELOGDECODERREG pReg;
62	/** The helper structure for this decoder. */
63	RTTRACELOGDECODERHLP Hlp;
64	/** The decoder state if created. */
65	void *pvDecoderState;
66	/** The free callback of any attached decoder state. */
67	PFNTRACELOGDECODERSTATEFREE pfnDecoderStateFree;
68	/** Current struct nesting level. */
69	uint32_t cStructNesting;
70	/** Current array level nesting. */
71	uint32_t cArrayNesting;
72	} RTTRACELOGDECODER;
73	typedef RTTRACELOGDECODER *PRTTRACELOGDECODER;
74	typedef const RTTRACELOGDECODER *PCRTTRACELOGDECODER;
75
76
77	/**
78	* Loaded tracelog decoders.
79	*/
80	typedef struct RTTRACELOGDECODERSTATE
81	{
82	/** Pointer to the array of registered decoders. */
83	PRTTRACELOGDECODER paDecoders;
84	/** Number of entries in the decoder array. */
85	uint32_t cDecoders;
86	/** Allocation size of the decoder array. */
87	uint32_t cDecodersAlloc;
88	} RTTRACELOGDECODERSTATE;
89	typedef RTTRACELOGDECODERSTATE *PRTTRACELOGDECODERSTATE;
90
91
92	/**
93	* The tracelog tool TCP server/client state.
94	*/
95	typedef struct RTTRACELOGTOOLTCP
96	{
97	/** Flag whether this is a server. */
98	bool fIsServer;
99	/** The TCP socket handle for the connection. */
100	RTSOCKET hSock;
101	/** The TCP server. */
102	PRTTCPSERVER pTcpSrv;
103	/** File to save the read data to. */
104	RTFILE hFile;
105	} RTTRACELOGTOOLTCP;
106	/** Pointer to the TCP server/client state. */
107	typedef RTTRACELOGTOOLTCP *PRTTRACELOGTOOLTCP;
108
109
110	static void rtTraceLogTcpDestroy(PRTTRACELOGTOOLTCP pTrcLogTcp)
111	{
112	if (pTrcLogTcp->fIsServer)
113	RTTcpServerDestroy(pTrcLogTcp->pTcpSrv);
114	if (pTrcLogTcp->hSock != NIL_RTSOCKET)
115	{
116	if (pTrcLogTcp->fIsServer)
117	RTTcpServerDisconnectClient2(pTrcLogTcp->hSock);
118	else
119	RTTcpClientClose(pTrcLogTcp->hSock);
120	}
121	if (pTrcLogTcp->hFile != NIL_RTFILE)
122	{
123	RTFileClose(pTrcLogTcp->hFile);
124	pTrcLogTcp->hFile = NIL_RTFILE;
125	}
126	RTMemFree(pTrcLogTcp);
127	}
128
129
130	static DECLCALLBACK(int) rtTraceLogToolTcpInput(void pvUser, void pvBuf, size_t cbBuf, size_t *pcbRead,
131	RTMSINTERVAL cMsTimeout)
132	{
133	PRTTRACELOGTOOLTCP pTrcLogTcp = (PRTTRACELOGTOOLTCP)pvUser;
134	if ( pTrcLogTcp->fIsServer
135	&& pTrcLogTcp->hSock == NIL_RTSOCKET)
136	{
137	int rc = RTTcpServerListen2(pTrcLogTcp->pTcpSrv, &pTrcLogTcp->hSock);
138	if (RT_FAILURE(rc))
139	return rc;
140	}
141
142	int rc = RTTcpSelectOne(pTrcLogTcp->hSock, cMsTimeout);
143	if (RT_SUCCESS(rc))
144	rc = RTTcpReadNB(pTrcLogTcp->hSock, pvBuf, cbBuf, pcbRead);
145
146	if ( RT_SUCCESS(rc)
147	&& pTrcLogTcp->hFile != NIL_RTFILE)
148	{
149	int rc2 = RTFileWrite(pTrcLogTcp->hFile, pvBuf, *pcbRead, NULL);
150	if (RT_FAILURE(rc2))
151	RTMsgError("Failed to write received data to save file: %Rrc\n", rc2);
152	}
153
154	return rc;
155	}
156
157
158	static DECLCALLBACK(int) rtTraceLogToolTcpClose(void *pvUser)
159	{
160	PRTTRACELOGTOOLTCP pTrcLogTcp = (PRTTRACELOGTOOLTCP)pvUser;
161	rtTraceLogTcpDestroy(pTrcLogTcp);
162	return VINF_SUCCESS;
163	}
164
165
166	/**
167	* Tries to create a new trace log reader using the given input.
168	*
169	* @returns IPRT status code.
170	* @param phTraceLogRdr Where to store the handle to the trace log reader instance on success.
171	* @param pszInput The input path.
172	* @param pszSave The optional path to save
173	*/
174	static int rtTraceLogToolReaderCreate(PRTTRACELOGRDR phTraceLogRdr, const char pszInput, const char pszSave)
175	{
176	/* Try treating the input as a file first. */
177	int rc = RTTraceLogRdrCreateFromFile(phTraceLogRdr, pszInput);
178	if (RT_FAILURE(rc))
179	{
180	/*
181	* Check whether the input looks like a port number or an address:port pair.
182	* The former will create a server listening on the port while the latter tries
183	* to connect to the given address:port combination.
184	*/
185	uint32_t uPort = 0;
186	bool fIsServer = false;
187	PRTTCPSERVER pTcpSrv = NULL;
188	RTSOCKET hSock = NIL_RTSOCKET;
189	rc = RTStrToUInt32Full(pszInput, 10, &uPort);
190	if (rc == VINF_SUCCESS)
191	{
192	fIsServer = true;
193	rc = RTTcpServerCreateEx(NULL, uPort, &pTcpSrv);
194	}
195	else
196	{
197	/* Try treating the input as an address:port pair. */
198	}
199
200	if (RT_SUCCESS(rc))
201	{
202	/* Initialize structure and reader. */
203	PRTTRACELOGTOOLTCP pTrcLogTcp = (PRTTRACELOGTOOLTCP)RTMemAllocZ(sizeof(*pTrcLogTcp));
204	if (pTrcLogTcp)
205	{
206	pTrcLogTcp->fIsServer = fIsServer;
207	pTrcLogTcp->hSock = hSock;
208	pTrcLogTcp->pTcpSrv = pTcpSrv;
209	rc = RTTraceLogRdrCreate(phTraceLogRdr, rtTraceLogToolTcpInput, rtTraceLogToolTcpClose, pTrcLogTcp);
210	if (RT_FAILURE(rc))
211	rtTraceLogTcpDestroy(pTrcLogTcp);
212
213	if (pszSave)
214	{
215	rc = RTFileOpen(&pTrcLogTcp->hFile, pszSave, RTFILE_O_CREATE_REPLACE \| RTFILE_O_DENY_NONE \| RTFILE_O_READWRITE);
216	if (RT_FAILURE(rc))
217	rtTraceLogTcpDestroy(pTrcLogTcp);
218	}
219	}
220	else
221	{
222	if (fIsServer)
223	RTTcpServerDestroy(pTcpSrv);
224	else
225	RTSocketClose(hSock);
226	}
227	}
228	}
229	return rc;
230	}
231
232
233	static DECLCALLBACK(int) rtTraceLogToolDecoderHlpPrintf(PRTTRACELOGDECODERHLP pHlp, const char *pszFormat, ...)
234	{
235	RT_NOREF(pHlp);
236	va_list Args;
237	va_start(Args, pszFormat);
238	int rc = RTPrintfV(pszFormat, Args);
239	va_end(Args);
240	return rc;
241	}
242
243
244	static DECLCALLBACK(int) rtTraceLogToolDecoderHlpErrorMsg(PRTTRACELOGDECODERHLP pHlp, const char *pszFormat, ...)
245	{
246	RT_NOREF(pHlp);
247	va_list Args;
248	va_start(Args, pszFormat);
249	int rc = RTMsgErrorV(pszFormat, Args);
250	va_end(Args);
251	return rc;
252	}
253
254
255	static DECLCALLBACK(int) rtTraceLogToolDecoderHlpStateCreate(PRTTRACELOGDECODERHLP pHlp, size_t cbState, PFNTRACELOGDECODERSTATEFREE pfnFree,
256	void **ppvState)
257	{
258	PRTTRACELOGDECODER pDecoder = RT_FROM_MEMBER(pHlp, RTTRACELOGDECODER, Hlp);
259
260	if (pDecoder->pvDecoderState)
261	{
262	if (pDecoder->pfnDecoderStateFree)
263	pDecoder->pfnDecoderStateFree(pHlp, pDecoder->pvDecoderState);
264	RTMemFree(pDecoder->pvDecoderState);
265	pDecoder->pvDecoderState = NULL;
266	pDecoder->pfnDecoderStateFree = NULL;
267	}
268
269	pDecoder->pvDecoderState = RTMemAllocZ(cbState);
270	if (pDecoder->pvDecoderState)
271	{
272	pDecoder->pfnDecoderStateFree = pfnFree;
273	*ppvState = pDecoder->pvDecoderState;
274	return VINF_SUCCESS;
275	}
276
277	return VERR_NO_MEMORY;
278	}
279
280
281	static DECLCALLBACK(void) rtTraceLogToolDecoderHlpStateDestroy(PRTTRACELOGDECODERHLP pHlp)
282	{
283	PRTTRACELOGDECODER pDecoder = RT_FROM_MEMBER(pHlp, RTTRACELOGDECODER, Hlp);
284
285	if (pDecoder->pvDecoderState)
286	{
287	if (pDecoder->pfnDecoderStateFree)
288	pDecoder->pfnDecoderStateFree(pHlp, pDecoder->pvDecoderState);
289	RTMemFree(pDecoder->pvDecoderState);
290	pDecoder->pvDecoderState = NULL;
291	pDecoder->pfnDecoderStateFree = NULL;
292	}
293	}
294
295
296	static DECLCALLBACK(void*) rtTraceLogToolDecoderHlpStateGet(PRTTRACELOGDECODERHLP pHlp)
297	{
298	PRTTRACELOGDECODER pDecoder = RT_FROM_MEMBER(pHlp, RTTRACELOGDECODER, Hlp);
299
300	return pDecoder->pvDecoderState;
301	}
302
303
304	static DECLCALLBACK(int) rtTraceLogToolDecoderHlpStructBldBegin(PRTTRACELOGDECODERHLP pHlp, const char *pszName)
305	{
306	PRTTRACELOGDECODER pDecoder = RT_FROM_MEMBER(pHlp, RTTRACELOGDECODER, Hlp);
307
308	RTPrintf("%s%s:\n", pDecoder->cStructNesting 4, "", pszName);
309	pDecoder->cStructNesting++;
310	return VINF_SUCCESS;
311	}
312
313
314	static DECLCALLBACK(int) rtTraceLogToolDecoderHlpStructBldEnd(PRTTRACELOGDECODERHLP pHlp)
315	{
316	PRTTRACELOGDECODER pDecoder = RT_FROM_MEMBER(pHlp, RTTRACELOGDECODER, Hlp);
317
318	pDecoder->cStructNesting--;
319	return VINF_SUCCESS;
320	}
321
322
323	static DECLCALLBACK(int) rtTraceLogToolDecoderHlpStructBldAddBool(PRTTRACELOGDECODERHLP pHlp, const char *pszName, uint32_t fFlags, bool f)
324	{
325	PRTTRACELOGDECODER pDecoder = RT_FROM_MEMBER(pHlp, RTTRACELOGDECODER, Hlp);
326
327	RT_NOREF(fFlags);
328	RTPrintf("%s%-16s %32RTbool\n", pDecoder->cStructNesting 4, "", pszName, f);
329	return VINF_SUCCESS;
330	}
331
332
333	static DECLCALLBACK(int) rtTraceLogToolDecoderHlpStructBldAddU8(PRTTRACELOGDECODERHLP pHlp, const char *pszName, uint32_t fFlags, uint8_t u8)
334	{
335	PRTTRACELOGDECODER pDecoder = RT_FROM_MEMBER(pHlp, RTTRACELOGDECODER, Hlp);
336
337	if (pszName)
338	{
339	if (fFlags & RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX)
340	RTPrintf("%s%-16s %#32RX8\n", pDecoder->cStructNesting 4, "", pszName, u8);
341	else
342	RTPrintf("%s%-16s %32RU8\n", pDecoder->cStructNesting 4, "", pszName, u8);
343	}
344	else
345	{
346	Assert(pDecoder->cArrayNesting > 0);
347	if (fFlags & RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX)
348	RTPrintf(" %#02RX8", u8);
349	else
350	RTPrintf(" %02RU8", u8);
351	}
352	return VINF_SUCCESS;
353	}
354
355
356	static DECLCALLBACK(int) rtTraceLogToolDecoderHlpStructBldAddU16(PRTTRACELOGDECODERHLP pHlp, const char *pszName, uint32_t fFlags, uint16_t u16)
357	{
358	PRTTRACELOGDECODER pDecoder = RT_FROM_MEMBER(pHlp, RTTRACELOGDECODER, Hlp);
359
360	if (fFlags & RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX)
361	RTPrintf("%s%-16s %#32RX16\n", pDecoder->cStructNesting 4, "", pszName, u16);
362	else
363	RTPrintf("%s%-16s %32RU16\n", pDecoder->cStructNesting 4, "", pszName, u16);
364	return VINF_SUCCESS;
365	}
366
367
368	static DECLCALLBACK(int) rtTraceLogToolDecoderHlpStructBldAddU32(PRTTRACELOGDECODERHLP pHlp, const char *pszName, uint32_t fFlags, uint32_t u32)
369	{
370	PRTTRACELOGDECODER pDecoder = RT_FROM_MEMBER(pHlp, RTTRACELOGDECODER, Hlp);
371
372	if (fFlags & RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX)
373	RTPrintf("%s%-16s %#32RX32\n", pDecoder->cStructNesting 4, "", pszName, u32);
374	else
375	RTPrintf("%s%-16s %32RU32\n", pDecoder->cStructNesting 4, "", pszName, u32);
376	return VINF_SUCCESS;
377	}
378
379
380	static DECLCALLBACK(int) rtTraceLogToolDecoderHlpStructBldAddU64(PRTTRACELOGDECODERHLP pHlp, const char *pszName, uint32_t fFlags, uint64_t u64)
381	{
382	PRTTRACELOGDECODER pDecoder = RT_FROM_MEMBER(pHlp, RTTRACELOGDECODER, Hlp);
383
384	if (fFlags & RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX)
385	RTPrintf("%s%-16s %#32RX64\n", pDecoder->cStructNesting 4, "", pszName, u64);
386	else
387	RTPrintf("%s%-16s %32RU64\n", pDecoder->cStructNesting 4, "", pszName, u64);
388	return VINF_SUCCESS;
389	}
390
391
392	static DECLCALLBACK(int) rtTraceLogToolDecoderHlpStructBldAddS8(PRTTRACELOGDECODERHLP pHlp, const char *pszName, uint32_t fFlags, int8_t i8)
393	{
394	PRTTRACELOGDECODER pDecoder = RT_FROM_MEMBER(pHlp, RTTRACELOGDECODER, Hlp);
395
396	if (fFlags & RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX)
397	RTPrintf("%s%-16s %#32RX8\n", pDecoder->cStructNesting 4, "", pszName, i8);
398	else
399	RTPrintf("%s%-16s %32RI8\n", pDecoder->cStructNesting 4, "", pszName, i8);
400	return VINF_SUCCESS;
401	}
402
403
404	static DECLCALLBACK(int) rtTraceLogToolDecoderHlpStructBldAddS16(PRTTRACELOGDECODERHLP pHlp, const char *pszName, uint32_t fFlags, int16_t i16)
405	{
406	PRTTRACELOGDECODER pDecoder = RT_FROM_MEMBER(pHlp, RTTRACELOGDECODER, Hlp);
407
408	if (fFlags & RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX)
409	RTPrintf("%s%-16s %#32RX16\n", pDecoder->cStructNesting 4, "", pszName, i16);
410	else
411	RTPrintf("%s%-16s %32RI16\n", pDecoder->cStructNesting 4, "", pszName, i16);
412	return VINF_SUCCESS;
413	}
414
415
416	static DECLCALLBACK(int) rtTraceLogToolDecoderHlpStructBldAddS32(PRTTRACELOGDECODERHLP pHlp, const char *pszName, uint32_t fFlags, int32_t i32)
417	{
418	PRTTRACELOGDECODER pDecoder = RT_FROM_MEMBER(pHlp, RTTRACELOGDECODER, Hlp);
419
420	if (fFlags & RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX)
421	RTPrintf("%s%-16s %#RX32\n", pDecoder->cStructNesting 4, "", pszName, i32);
422	else
423	RTPrintf("%s%-16s %RI32\n", pDecoder->cStructNesting 4, "", pszName, i32);
424	return VINF_SUCCESS;
425	}
426
427
428	static DECLCALLBACK(int) rtTraceLogToolDecoderHlpStructBldAddS64(PRTTRACELOGDECODERHLP pHlp, const char *pszName, uint32_t fFlags, int64_t i64)
429	{
430	PRTTRACELOGDECODER pDecoder = RT_FROM_MEMBER(pHlp, RTTRACELOGDECODER, Hlp);
431
432	if (fFlags & RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX)
433	RTPrintf("%s%-16s %#RX64\n", pDecoder->cStructNesting 4, "", pszName, i64);
434	else
435	RTPrintf("%s%-16s %RI64\n", pDecoder->cStructNesting 4, "", pszName, i64);
436	return VINF_SUCCESS;
437	}
438
439
440	static DECLCALLBACK(int) rtTraceLogToolDecoderHlpStructBldAddStr(PRTTRACELOGDECODERHLP pHlp, const char pszName, uint32_t fFlags, const char pszStr)
441	{
442	PRTTRACELOGDECODER pDecoder = RT_FROM_MEMBER(pHlp, RTTRACELOGDECODER, Hlp);
443
444	RT_NOREF(fFlags);
445	RTPrintf("%s%-16s %32s\n", pDecoder->cStructNesting 4, "", pszName, pszStr);
446	return VINF_SUCCESS;
447	}
448
449
450	static DECLCALLBACK(int) rtTraceLogToolDecoderHlpStructBldAddBuf(PRTTRACELOGDECODERHLP pHlp, const char pszName, uint32_t fFlags, const uint8_t pb, size_t cb)
451	{
452	PRTTRACELOGDECODER pDecoder = RT_FROM_MEMBER(pHlp, RTTRACELOGDECODER, Hlp);
453
454	if (fFlags & RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX_DUMP_STR)
455	RTPrintf("%s%-16s %.Rhxs\n", pDecoder->cStructNesting * 4, "", pszName, cb, pb);
456	else
457	RTPrintf("%*s%-16s\n"
458	"%.Rhxd\n", pDecoder->cStructNesting 4, "", pszName, cb, pb);
459	return VINF_SUCCESS;
460	}
461
462
463	static DECLCALLBACK(int) rtTraceLogToolDecoderHlpStructBldAddEnum(PRTTRACELOGDECODERHLP pHlp, const char *pszName, uint32_t fFlags, uint8_t cBits,
464	PCRTTRACELOGDECODERSTRUCTBLDENUM paEnums, uint64_t u64Val)
465	{
466	PRTTRACELOGDECODER pDecoder = RT_FROM_MEMBER(pHlp, RTTRACELOGDECODER, Hlp);
467
468	const char *pszEnum = "<UNKNOWN>";
469	while (paEnums->pszString)
470	{
471	if (paEnums->u64EnumVal == u64Val)
472	{
473	pszEnum = paEnums->pszString;
474	break;
475	}
476	paEnums++;
477	}
478
479	RT_NOREF(cBits);
480	if (fFlags & RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX)
481	RTPrintf("%s%-16s 0x%0RX64 (%s)\n", pDecoder->cStructNesting * 4, "", pszName, cBits / 4, u64Val, pszEnum);
482	else
483	RTPrintf("%s%-16s %RU64 (%s)\n", pDecoder->cStructNesting 4, "", pszName, u64Val, pszEnum);
484	return VINF_SUCCESS;
485	}
486
487
488	static DECLCALLBACK(int) rtTraceLogToolDecoderHlpStructBldArrayBegin(PRTTRACELOGDECODERHLP pHlp, const char *pszName)
489	{
490	PRTTRACELOGDECODER pDecoder = RT_FROM_MEMBER(pHlp, RTTRACELOGDECODER, Hlp);
491
492	RTPrintf("%s%-16s [", pDecoder->cStructNesting 4, "", pszName);
493	Assert(!pDecoder->cArrayNesting);
494	pDecoder->cArrayNesting++;
495	return VINF_SUCCESS;
496	}
497
498
499	static DECLCALLBACK(int) rtTraceLogToolDecoderHlpStructBldArrayEnd(PRTTRACELOGDECODERHLP pHlp)
500	{
501	PRTTRACELOGDECODER pDecoder = RT_FROM_MEMBER(pHlp, RTTRACELOGDECODER, Hlp);
502	RTPrintf(" ]\n");
503	Assert(pDecoder->cArrayNesting > 0);
504	pDecoder->cArrayNesting--;
505	return VINF_SUCCESS;
506	}
507
508
509	static DECLCALLBACK(int) rtTraceLogToolRegisterDecoders(void *pvUser, PCRTTRACELOGDECODERREG paDecoders, uint32_t cDecoders)
510	{
511	PRTTRACELOGDECODERSTATE pDecoderState = (PRTTRACELOGDECODERSTATE)pvUser;
512
513	if (pDecoderState->cDecodersAlloc - pDecoderState->cDecoders <= cDecoders)
514	{
515	PRTTRACELOGDECODER paNew = (PRTTRACELOGDECODER)RTMemRealloc(pDecoderState->paDecoders,
516	(pDecoderState->cDecodersAlloc + cDecoders) * sizeof(*paNew));
517	if (!paNew)
518	return VERR_NO_MEMORY;
519
520	pDecoderState->paDecoders = paNew;
521	pDecoderState->cDecodersAlloc += cDecoders;
522	}
523
524	for (uint32_t i = 0; i < cDecoders; i++)
525	{
526	PRTTRACELOGDECODER pDecoder = &pDecoderState->paDecoders[i];
527
528	pDecoder->pReg = &paDecoders[i];
529	pDecoder->pvDecoderState = NULL;
530	pDecoder->pfnDecoderStateFree = NULL;
531	pDecoder->cStructNesting = 0;
532	pDecoder->cArrayNesting = 0;
533	pDecoder->Hlp.pfnPrintf = rtTraceLogToolDecoderHlpPrintf;
534	pDecoder->Hlp.pfnErrorMsg = rtTraceLogToolDecoderHlpErrorMsg;
535	pDecoder->Hlp.pfnDecoderStateCreate = rtTraceLogToolDecoderHlpStateCreate;
536	pDecoder->Hlp.pfnDecoderStateDestroy = rtTraceLogToolDecoderHlpStateDestroy;
537	pDecoder->Hlp.pfnDecoderStateGet = rtTraceLogToolDecoderHlpStateGet;
538	pDecoder->Hlp.pfnStructBldBegin = rtTraceLogToolDecoderHlpStructBldBegin;
539	pDecoder->Hlp.pfnStructBldEnd = rtTraceLogToolDecoderHlpStructBldEnd;
540	pDecoder->Hlp.pfnStructBldAddBool = rtTraceLogToolDecoderHlpStructBldAddBool;
541	pDecoder->Hlp.pfnStructBldAddU8 = rtTraceLogToolDecoderHlpStructBldAddU8;
542	pDecoder->Hlp.pfnStructBldAddU16 = rtTraceLogToolDecoderHlpStructBldAddU16;
543	pDecoder->Hlp.pfnStructBldAddU32 = rtTraceLogToolDecoderHlpStructBldAddU32;
544	pDecoder->Hlp.pfnStructBldAddU64 = rtTraceLogToolDecoderHlpStructBldAddU64;
545	pDecoder->Hlp.pfnStructBldAddS8 = rtTraceLogToolDecoderHlpStructBldAddS8;
546	pDecoder->Hlp.pfnStructBldAddS16 = rtTraceLogToolDecoderHlpStructBldAddS16;
547	pDecoder->Hlp.pfnStructBldAddS32 = rtTraceLogToolDecoderHlpStructBldAddS32;
548	pDecoder->Hlp.pfnStructBldAddS64 = rtTraceLogToolDecoderHlpStructBldAddS64;
549	pDecoder->Hlp.pfnStructBldAddStr = rtTraceLogToolDecoderHlpStructBldAddStr;
550	pDecoder->Hlp.pfnStructBldAddBuf = rtTraceLogToolDecoderHlpStructBldAddBuf;
551	pDecoder->Hlp.pfnStructBldAddEnum = rtTraceLogToolDecoderHlpStructBldAddEnum;
552	pDecoder->Hlp.pfnStructBldArrayBegin = rtTraceLogToolDecoderHlpStructBldArrayBegin;
553	pDecoder->Hlp.pfnStructBldArrayEnd = rtTraceLogToolDecoderHlpStructBldArrayEnd;
554	}
555
556	pDecoderState->cDecoders += cDecoders;
557	return VINF_SUCCESS;
558	}
559
560
561	int main(int argc, char **argv)
562	{
563	int rc = RTR3InitExe(argc, &argv, 0);
564	if (RT_FAILURE(rc))
565	return RTMsgInitFailure(rc);
566
567	/*
568	* Parse arguments.
569	*/
570	static const RTGETOPTDEF s_aOptions[] =
571	{
572	{ "--input", 'i', RTGETOPT_REQ_STRING },
573	{ "--save", 's', RTGETOPT_REQ_STRING },
574	{ "--load-decoder", 'l', RTGETOPT_REQ_STRING },
575	{ "--help", 'h', RTGETOPT_REQ_NOTHING },
576	{ "--version", 'V', RTGETOPT_REQ_NOTHING },
577	};
578
579	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
580	const char *pszInput = NULL;
581	const char *pszSave = NULL;
582	RTTRACELOGDECODERSTATE DecoderState; RT_ZERO(DecoderState);
583
584	RTGETOPTUNION ValueUnion;
585	RTGETOPTSTATE GetState;
586	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
587	while ((rc = RTGetOpt(&GetState, &ValueUnion)))
588	{
589	switch (rc)
590	{
591	case 'h':
592	RTPrintf("Usage: %s [options]\n"
593	"\n"
594	"Options:\n"
595	" -i,--input=<file\|port\|address:port>\n"
596	" Input path, can be a file a port to start listening on for incoming connections or an address:port to connect to\n"
597	" -s,--save=file\n"
598	" Save the input to a file for later use\n"
599	" -l,--load-decoder=<plugin path>\n"
600	" Loads the given decoder library used for decoding events\n"
601	" -h, -?, --help\n"
602	" Display this help text and exit successfully.\n"
603	" -V, --version\n"
604	" Display the revision and exit successfully.\n"
605	, RTPathFilename(argv[0]));
606	return RTEXITCODE_SUCCESS;
607	case 'V':
608	RTPrintf("$Revision: 106061 $\n");
609	return RTEXITCODE_SUCCESS;
610
611	case 'i':
612	pszInput = ValueUnion.psz;
613	break;
614	case 's':
615	pszSave = ValueUnion.psz;
616	break;
617	case 'l':
618	{
619	RTLDRMOD hLdrMod;
620	rc = RTLdrLoadEx(ValueUnion.psz, &hLdrMod, RTLDRLOAD_FLAGS_NO_UNLOAD, NULL);
621	if (RT_SUCCESS(rc))
622	{
623	PFNTRACELOGDECODERPLUGINLOAD pfnLoad = NULL;
624	rc = RTLdrGetSymbol(hLdrMod, RT_TRACELOG_DECODER_PLUGIN_LOAD, (void **)&pfnLoad);
625	if (RT_SUCCESS(rc))
626	{
627	RTTRACELOGDECODERREGISTER RegCb;
628
629	RegCb.u32Version = RT_TRACELOG_DECODERREG_CB_VERSION;
630	RegCb.pfnRegisterDecoders = rtTraceLogToolRegisterDecoders;
631
632	rc = pfnLoad(&DecoderState, &RegCb);
633	if (RT_FAILURE(rc))
634	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to register decoders %Rrc\n", rc);
635	}
636	else
637	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to lretrieve entry point '%s' %Rrc\n",
638	RT_TRACELOG_DECODER_PLUGIN_LOAD, rc);
639
640	RTLdrClose(hLdrMod);
641	}
642	else
643	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to load decoder library %Rrc\n", rc);
644	break;
645	}
646	default:
647	return RTGetOptPrintError(rc, &ValueUnion);
648	}
649	}
650
651	if (!pszInput)
652	{
653	RTPrintf("An input path must be given\n");
654	return RTEXITCODE_FAILURE;
655	}
656
657	/*
658	* Create trace log reader instance.
659	*/
660	RTTRACELOGRDR hTraceLogRdr = NIL_RTTRACELOGRDR;
661	rc = rtTraceLogToolReaderCreate(&hTraceLogRdr, pszInput, pszSave);
662	if (RT_SUCCESS(rc))
663	{
664	do
665	{
666	RTTRACELOGRDRPOLLEVT enmEvt = RTTRACELOGRDRPOLLEVT_INVALID;
667	rc = RTTraceLogRdrEvtPoll(hTraceLogRdr, &enmEvt, RT_INDEFINITE_WAIT);
668	if (RT_SUCCESS(rc))
669	{
670	switch (enmEvt)
671	{
672	case RTTRACELOGRDRPOLLEVT_HDR_RECVD:
673	RTMsgInfo("A valid header was received\n");
674	break;
675	case RTTRACELOGRDRPOLLEVT_TRACE_EVENT_RECVD:
676	{
677	RTTRACELOGRDREVT hTraceLogEvt;
678	rc = RTTraceLogRdrQueryLastEvt(hTraceLogRdr, &hTraceLogEvt);
679	if (RT_SUCCESS(rc))
680	{
681	PCRTTRACELOGEVTDESC pEvtDesc = RTTraceLogRdrEvtGetDesc(hTraceLogEvt);
682	RTMsgInfo("%llu %llu %s\n",
683	RTTraceLogRdrEvtGetSeqNo(hTraceLogEvt),
684	RTTraceLogRdrEvtGetTs(hTraceLogEvt),
685	pEvtDesc->pszId);
686
687	/*
688	* Look through our registered decoders and pass the decoding on to it.
689	* If there is no decoder registered just dump the raw values.
690	*/
691	PRTTRACELOGDECODER pDecoder = NULL;
692	PCRTTRACELOGDECODEEVT pDecodeEvt = NULL;
693	for (uint32_t i = 0; (i < DecoderState.cDecoders) && !pDecoder; i++)
694	{
695	PCRTTRACELOGDECODEEVT pTmp = DecoderState.paDecoders[i].pReg->paEvtIds;
696	while (pTmp->pszEvtId)
697	{
698	if (!strcmp(pTmp->pszEvtId, pEvtDesc->pszId))
699	{
700	pDecoder = &DecoderState.paDecoders[i];
701	pDecodeEvt = pTmp;
702	break;
703	}
704	pTmp++;
705	}
706	}
707
708	if (pDecoder)
709	{
710	Assert(pDecodeEvt);
711
712	/** @todo Dynamic value allocation (too lazy right now). */
713	RTTRACELOGEVTVAL aVals[32];
714	uint32_t cVals = 0;
715	rc = RTTraceLogRdrEvtFillVals(hTraceLogEvt, 0, &aVals[0], RT_ELEMENTS(aVals),
716	&cVals);
717	if ( RT_SUCCESS(rc)
718	\|\| cVals != pEvtDesc->cEvtItems)
719	{
720	pDecoder->cStructNesting = 0;
721	pDecoder->cArrayNesting = 0;
722	rc = pDecoder->pReg->pfnDecode(&pDecoder->Hlp, pDecodeEvt->idDecodeEvt, hTraceLogEvt,
723	pEvtDesc, &aVals[0], cVals);
724	if (RT_FAILURE(rc))
725	RTMsgError("Failed to decode event with ID '%s' -> %Rrc\n", pEvtDesc->pszId, rc);
726	}
727	else
728	RTMsgError("Failed to fill values for event with ID '%s' -> %Rrc (cVals=%u vs. cEvtItems=%u)\n",
729	pEvtDesc->pszId, rc, cVals, pEvtDesc->cEvtItems);
730	}
731	else
732	for (unsigned i = 0; i < pEvtDesc->cEvtItems; i++)
733	{
734	RTTRACELOGEVTVAL Val;
735	unsigned cVals = 0;
736	rc = RTTraceLogRdrEvtFillVals(hTraceLogEvt, i, &Val, 1, &cVals);
737	if (RT_SUCCESS(rc))
738	{
739	switch (Val.pItemDesc->enmType)
740	{
741	case RTTRACELOGTYPE_BOOL:
742	RTMsgInfo(" %s: %s\n", Val.pItemDesc->pszName, Val.u.f ? "true" : "false");
743	break;
744	case RTTRACELOGTYPE_UINT8:
745	RTMsgInfo(" %s: %u\n", Val.pItemDesc->pszName, Val.u.u8);
746	break;
747	case RTTRACELOGTYPE_INT8:
748	RTMsgInfo(" %s: %d\n", Val.pItemDesc->pszName, Val.u.i8);
749	break;
750	case RTTRACELOGTYPE_UINT16:
751	RTMsgInfo(" %s: %u\n", Val.pItemDesc->pszName, Val.u.u16);
752	break;
753	case RTTRACELOGTYPE_INT16:
754	RTMsgInfo(" %s: %d\n", Val.pItemDesc->pszName, Val.u.i16);
755	break;
756	case RTTRACELOGTYPE_UINT32:
757	RTMsgInfo(" %s: %u\n", Val.pItemDesc->pszName, Val.u.u32);
758	break;
759	case RTTRACELOGTYPE_INT32:
760	RTMsgInfo(" %s: %d\n", Val.pItemDesc->pszName, Val.u.i32);
761	break;
762	case RTTRACELOGTYPE_UINT64:
763	RTMsgInfo(" %s: %llu\n", Val.pItemDesc->pszName, Val.u.u64);
764	break;
765	case RTTRACELOGTYPE_INT64:
766	RTMsgInfo(" %s: %lld\n", Val.pItemDesc->pszName, Val.u.i64);
767	break;
768	case RTTRACELOGTYPE_RAWDATA:
769	RTMsgInfo(" %s:\n"
770	"%.*Rhxd\n", Val.pItemDesc->pszName, Val.u.RawData.cb, Val.u.RawData.pb);
771	break;
772	case RTTRACELOGTYPE_FLOAT32:
773	case RTTRACELOGTYPE_FLOAT64:
774	RTMsgInfo(" %s: Float32 and Float64 data not supported yet\n", Val.pItemDesc->pszName);
775	break;
776	case RTTRACELOGTYPE_POINTER:
777	RTMsgInfo(" %s: %#llx\n", Val.pItemDesc->pszName, Val.u.uPtr);
778	break;
779	case RTTRACELOGTYPE_SIZE:
780	RTMsgInfo(" %s: %llu\n", Val.pItemDesc->pszName, Val.u.sz);
781	break;
782	default:
783	RTMsgError(" %s: Invalid type given %d\n", Val.pItemDesc->pszName, Val.pItemDesc->enmType);
784	}
785	}
786	else
787	RTMsgInfo(" Failed to retrieve event data with %Rrc\n", rc);
788	}
789	}
790	break;
791	}
792	default:
793	RTMsgInfo("Invalid event received: %d\n", enmEvt);
794	}
795	}
796	else
797	rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "Polling for an event failed with %Rrc\n", rc);
798	} while (RT_SUCCESS(rc));
799
800	RTTraceLogRdrDestroy(hTraceLogRdr);
801	}
802	else
803	rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to create trace log reader with %Rrc\n", rc);
804
805	return rcExit;
806	}
807

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Runtime/tools/RTTraceLogTool.cpp

Download in other formats: