DBGFR3Type.cpp

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

Line
1	/* $Id: DBGFR3Type.cpp 106061 2024-09-16 14:03:52Z vboxsync $ */
2	/** @file
3	* DBGF - Debugger Facility, Type Management.
4	*/
5
6	/*
7	* Copyright (C) 2016-2024 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.215389.xyz.
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	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/** @page pg_dbgf_type DBGFType - Type Management
30	*
31	* The type management system is intended to ease retrieval of values from
32	* structures in the guest OS without having to take care of the size of pointers.
33	*
34	* @todo r=bird: We need to join this up with modules and address spaces. It
35	* cannot be standalone like this. Also, it must be comming from IPRT as
36	* there is no point in duplicating code (been there, done that with
37	* symbols and debug info already). This unfortunately means we need to
38	* find some common way of abstracting DWARF and Codeview type info so we
39	* can extend those debug info parsers to make type information available.
40	*/
41
42
43	/*********************************************************************************************************************************
44	* Header Files *
45	*********************************************************************************************************************************/
46	#define LOG_GROUP LOG_GROUP_DBGF
47	#include <VBox/vmm/dbgf.h>
48	#include "DBGFInternal.h"
49	#include <VBox/vmm/mm.h>
50	#include <VBox/vmm/uvm.h>
51	#include <VBox/err.h>
52	#include <VBox/log.h>
53
54	#include <iprt/assert.h>
55	#include <iprt/thread.h>
56	#include <iprt/param.h>
57
58
59	/*********************************************************************************************************************************
60	* Defined Constants And Macros *
61	*********************************************************************************************************************************/
62
63	/** Locks the type database for writing. */
64	#define DBGF_TYPE_DB_LOCK_WRITE(pUVM) \
65	do { \
66	int rcSem = RTSemRWRequestWrite((pUVM)->dbgf.s.hTypeDbLock, RT_INDEFINITE_WAIT); \
67	AssertRC(rcSem); \
68	} while (0)
69
70	/** Unlocks the type database after writing. */
71	#define DBGF_TYPE_DB_UNLOCK_WRITE(pUVM) \
72	do { \
73	int rcSem = RTSemRWReleaseWrite((pUVM)->dbgf.s.hTypeDbLock); \
74	AssertRC(rcSem); \
75	} while (0)
76
77	/** Locks the type database for reading. */
78	#define DBGF_TYPE_DB_LOCK_READ(pUVM) \
79	do { \
80	int rcSem = RTSemRWRequestRead((pUVM)->dbgf.s.hTypeDbLock, RT_INDEFINITE_WAIT); \
81	AssertRC(rcSem); \
82	} while (0)
83
84	/** Unlocks the type database after reading. */
85	#define DBGF_TYPE_DB_UNLOCK_READ(pUVM) \
86	do { \
87	int rcSem = RTSemRWReleaseRead((pUVM)->dbgf.s.hTypeDbLock); \
88	AssertRC(rcSem); \
89	} while (0)
90
91
92	/*********************************************************************************************************************************
93	* Structures and Typedefs *
94	*********************************************************************************************************************************/
95	/**
96	* DBGF registered type.
97	*/
98	typedef struct DBGFTYPE
99	{
100	/** String space core. */
101	RTSTRSPACECORE Core;
102	/** Pointer to the registration structure, NULL means builtin type. */
103	PCDBGFTYPEREG pReg;
104	/** How often the type is referenced by other types. */
105	volatile uint32_t cRefs;
106	/** Size of the type. */
107	size_t cbType;
108	/** Builtin type if pReg is NULL (otherwise it is invalid). */
109	DBGFTYPEBUILTIN enmTypeBuiltin;
110	} DBGFTYPE;
111	/** Pointer to a DBGF type. */
112	typedef DBGFTYPE *PDBGFTYPE;
113
114
115	/*********************************************************************************************************************************
116	* Internal Functions *
117	*********************************************************************************************************************************/
118	static int dbgfR3TypeParseBufferByType(PUVM pUVM, PDBGFTYPE pType, uint8_t *pbBuf, size_t cbBuf,
119	PDBGFTYPEVAL ppVal, size_t pcbParsed);
120
121
122	/**
123	* Looks up a type by the identifier.
124	*
125	* @returns Pointer to the type structure on success, NULL otherwise.
126	* @param pUVM The user mode VM handle.
127	* @param pszType The type identifier.
128	*/
129	static PDBGFTYPE dbgfR3TypeLookup(PUVM pUVM, const char *pszType)
130	{
131	PRTSTRSPACE pTypeSpace = &pUVM->dbgf.s.TypeSpace;
132	return (PDBGFTYPE)RTStrSpaceGet(pTypeSpace, pszType);
133	}
134
135
136	/**
137	* Calculate the size of the given type.
138	*
139	* @returns VBox status code.
140	* @param pUVM The user mode VM handle.
141	* @param pType The type to calculate the size for.
142	* @param fCalcNested Flag whether to calculate the size for nested
143	* structs if the sizes are 0.
144	*/
145	static int dbgfR3TypeCalcSize(PUVM pUVM, PDBGFTYPE pType, bool fCalcNested)
146	{
147	int rc = VINF_SUCCESS;
148
149	/* Builtin types are never recalculated. */
150	if (pType->pReg)
151	{
152	switch (pType->pReg->enmVariant)
153	{
154	case DBGFTYPEVARIANT_STRUCT:
155	{
156	size_t cbType = 0;
157
158	/* Go through the members and update size. */
159	for (uint32_t i = 0; i < pType->pReg->cMembers && RT_SUCCESS(rc); i++)
160	{
161	PCDBGFTYPEREGMEMBER pMember = &pType->pReg->paMembers[i];
162
163	if (pMember->fFlags & DBGFTYPEREGMEMBER_F_POINTER)
164	{
165	/* Use the current pointer size. */
166	PDBGFTYPE pTypeMember = dbgfR3TypeLookup(pUVM, "ptr_t");
167	if (RT_LIKELY(pTypeMember))
168	{
169	if (pMember->fFlags & DBGFTYPEREGMEMBER_F_ARRAY)
170	cbType += pMember->cElements * pTypeMember->cbType;
171	else
172	cbType += pTypeMember->cbType;
173	}
174	}
175	else
176	{
177	PDBGFTYPE pTypeMember = dbgfR3TypeLookup(pUVM, pMember->pszType);
178	if (RT_LIKELY(pTypeMember))
179	{
180	if ( pTypeMember->cbType == 0
181	&& fCalcNested)
182	rc = dbgfR3TypeCalcSize(pUVM, pTypeMember, fCalcNested);
183
184	if (RT_SUCCESS(rc))
185	{
186	if (pMember->fFlags & DBGFTYPEREGMEMBER_F_ARRAY)
187	cbType += pMember->cElements * pTypeMember->cbType;
188	else
189	cbType += pTypeMember->cbType;
190	}
191	}
192	else
193	rc = VERR_INVALID_STATE;
194	}
195	}
196
197	if (RT_SUCCESS(rc))
198	pType->cbType = cbType;
199	break;
200	}
201
202	case DBGFTYPEVARIANT_UNION:
203	{
204	/* Get size of the biggest member and use that one. */
205	size_t cbType = 0;
206
207	for (uint32_t i = 0; i < pType->pReg->cMembers && RT_SUCCESS(rc); i++)
208	{
209	PCDBGFTYPEREGMEMBER pMember = &pType->pReg->paMembers[i];
210
211	if (pMember->fFlags & DBGFTYPEREGMEMBER_F_POINTER)
212	{
213	/* Use the current pointer size. */
214	PDBGFTYPE pTypeMember = dbgfR3TypeLookup(pUVM, "ptr_t");
215	if (RT_LIKELY(pTypeMember))
216	{
217	if (pMember->fFlags & DBGFTYPEREGMEMBER_F_ARRAY)
218	cbType = RT_MAX(cbType, pMember->cElements * pTypeMember->cbType);
219	else
220	cbType = RT_MAX(cbType, pTypeMember->cbType);
221	}
222	}
223	else
224	{
225	PDBGFTYPE pTypeMember = dbgfR3TypeLookup(pUVM, pMember->pszType);
226	if (RT_LIKELY(pTypeMember))
227	{
228	if ( pTypeMember->cbType == 0
229	&& fCalcNested)
230	rc = dbgfR3TypeCalcSize(pUVM, pTypeMember, fCalcNested);
231
232	if (RT_SUCCESS(rc))
233	{
234	if (pMember->fFlags & DBGFTYPEREGMEMBER_F_ARRAY)
235	cbType = RT_MAX(cbType, pMember->cElements * pTypeMember->cbType);
236	else
237	cbType = RT_MAX(cbType, pTypeMember->cbType);
238	}
239	}
240	else
241	rc = VERR_INVALID_STATE;
242	}
243	}
244
245	if (RT_SUCCESS(rc))
246	pType->cbType = cbType;
247	break;
248	}
249
250	case DBGFTYPEVARIANT_ALIAS:
251	{
252	/* Get the size of the alias. */
253	PDBGFTYPE pAliased = dbgfR3TypeLookup(pUVM, pType->pReg->pszAliasedType);
254	if (RT_LIKELY(pAliased))
255	{
256	if ( pAliased->cbType == 0
257	&& fCalcNested)
258	rc = dbgfR3TypeCalcSize(pUVM, pAliased, fCalcNested);
259
260	if (RT_SUCCESS(rc))
261	pType->cbType = pAliased->cbType;
262	}
263	else
264	rc = VERR_INVALID_STATE;
265	break;
266	}
267
268	default:
269	AssertMsgFailedReturn(("Invalid type variant: %d", pType->pReg->enmVariant), VERR_INVALID_STATE);
270	}
271	}
272
273	return rc;
274	}
275
276
277	/**
278	* Callback for clearing the size of all non built-in types.
279	*
280	* @returns VBox status code.
281	* @param pStr The type structure.
282	* @param pvUser The user mode VM handle.
283	*/
284	static DECLCALLBACK(int) dbgfR3TypeTraverseClearSize(PRTSTRSPACECORE pStr, void *pvUser)
285	{
286	PDBGFTYPE pType = (PDBGFTYPE)pStr;
287
288	if (pType->pReg)
289	pType->cbType = 0;
290
291	NOREF(pvUser);
292	return VINF_SUCCESS;
293	}
294
295
296	/**
297	* Callback for calculating the size of all non built-in types.
298	*
299	* @returns VBox status code.
300	* @param pStr The type structure.
301	* @param pvUser The user mode VM handle.
302	*/
303	static DECLCALLBACK(int) dbgfR3TypeTraverseCalcSize(PRTSTRSPACECORE pStr, void *pvUser)
304	{
305	PDBGFTYPE pType = (PDBGFTYPE)pStr;
306
307	if ( pType->pReg
308	&& !pType->cbType)
309	dbgfR3TypeCalcSize((PUVM)pvUser, pType, true /* fCalcNested */);
310
311	return VINF_SUCCESS;
312	}
313
314
315	/**
316	* Recalculate the sizes of all registered non builtin types.
317	*
318	* @returns VBox status code.
319	* @param pUVM The user mode VM handle.
320	*/
321	static int dbgfR3TypeRecalculateAllSizes(PUVM pUVM)
322	{
323	int rc = VINF_SUCCESS;
324
325	/*
326	* Clear the sizes of all non builtin types to 0 first so we know which type we
327	* visited later on.
328	*/
329	rc = RTStrSpaceEnumerate(&pUVM->dbgf.s.TypeSpace, dbgfR3TypeTraverseClearSize, pUVM);
330	if (RT_SUCCESS(rc))
331	{
332	/* Now recalculate the size. */
333	rc = RTStrSpaceEnumerate(&pUVM->dbgf.s.TypeSpace, dbgfR3TypeTraverseCalcSize, pUVM);
334	}
335
336	return rc;
337	}
338
339	/**
340	* Validates a given type registration.
341	*
342	* @returns VBox status code.
343	* @param pUVM The user mode VM handle.
344	* @param pReg The type registration structure.
345	*/
346	static int dbgfR3TypeValidate(PUVM pUVM, PCDBGFTYPEREG pReg)
347	{
348	int rc = VINF_SUCCESS;
349
350	switch (pReg->enmVariant)
351	{
352	case DBGFTYPEVARIANT_ALIAS:
353	if ( pReg->cMembers > 0
354	\|\| pReg->paMembers
355	\|\| !pReg->pszAliasedType)
356	rc = VERR_INVALID_PARAMETER;
357	else
358	{
359	PDBGFTYPE pAlias = dbgfR3TypeLookup(pUVM, pReg->pszAliasedType);
360	if (RT_UNLIKELY(!pAlias))
361	rc = VERR_NOT_FOUND;
362	}
363	break;
364	case DBGFTYPEVARIANT_STRUCT:
365	case DBGFTYPEVARIANT_UNION:
366	if (!pReg->pszAliasedType)
367	{
368	for (uint32_t i = 0; i < pReg->cMembers; i++)
369	{
370	PCDBGFTYPEREGMEMBER pMember = &pReg->paMembers[i];
371
372	/* Use the current pointer size. */
373	PDBGFTYPE pTypeMember = dbgfR3TypeLookup(pUVM, pMember->pszType);
374	if (RT_UNLIKELY(!pTypeMember))
375	{
376	rc = VERR_NOT_FOUND;
377	break;
378	}
379
380	if (pMember->fFlags & DBGFTYPEREGMEMBER_F_ARRAY)
381	{
382	if (pMember->cElements == 0)
383	rc = VERR_INVALID_PARAMETER;
384	}
385	else if (pMember->cElements != 0)
386	rc = VERR_INVALID_PARAMETER;
387	}
388	}
389	else
390	rc = VERR_INVALID_PARAMETER;
391	break;
392	default:
393	AssertMsgFailedBreakStmt(("Invalid type variant: %d", pReg->enmVariant),
394	rc = VERR_INVALID_PARAMETER);
395	}
396
397	return rc;
398	}
399
400	/**
401	* Retains or releases the reference counters to referenced types for the given
402	* type registration structure.
403	*
404	* @returns VBox status code.
405	* @param pUVM The user mode VM handle.
406	* @param pReg The type registration structure.
407	* @param fRetain Flag whether to retain or release references.
408	*/
409	static int dbgfR3TypeUpdateRefCnts(PUVM pUVM, PCDBGFTYPEREG pReg, bool fRetain)
410	{
411	int rc = VINF_SUCCESS;
412
413	switch (pReg->enmVariant)
414	{
415	case DBGFTYPEVARIANT_ALIAS:
416	{
417	AssertPtr(pReg->pszAliasedType);
418
419	PDBGFTYPE pAlias = dbgfR3TypeLookup(pUVM, pReg->pszAliasedType);
420	AssertPtr(pAlias);
421
422	if (fRetain)
423	pAlias->cRefs++;
424	else
425	pAlias->cRefs--;
426	break;
427	}
428	case DBGFTYPEVARIANT_STRUCT:
429	case DBGFTYPEVARIANT_UNION:
430	{
431	for (uint32_t i = 0; i < pReg->cMembers; i++)
432	{
433	PCDBGFTYPEREGMEMBER pMember = &pReg->paMembers[i];
434
435	/* Use the current pointer size. */
436	PDBGFTYPE pTypeMember = dbgfR3TypeLookup(pUVM, pMember->pszType);
437	AssertPtr(pTypeMember);
438
439	if (fRetain)
440	pTypeMember->cRefs++;
441	else
442	pTypeMember->cRefs--;
443	}
444	break;
445	}
446	default:
447	AssertMsgFailedBreakStmt(("Invalid type variant: %d", pReg->enmVariant),
448	rc = VERR_INVALID_PARAMETER);
449	}
450
451	return rc;
452	}
453
454
455	/**
456	* Registers a single type in the database.
457	*
458	* @returns VBox status code.
459	* @retval VERR_ALREADY_EXISTS if the type exists already.
460	* @param pUVM The user mode VM handle.
461	* @param pReg The type registration structure.
462	*/
463	static int dbgfR3TypeRegister(PUVM pUVM, PCDBGFTYPEREG pReg)
464	{
465	int rc = VINF_SUCCESS;
466
467	LogFlowFunc(("pUVM=%#p pReg=%#p{%s}\n", pUVM, pReg, pReg->pszType));
468
469	if (dbgfR3TypeLookup(pUVM, pReg->pszType) == NULL)
470	{
471	rc = dbgfR3TypeValidate(pUVM, pReg);
472	if (RT_SUCCESS(rc))
473	{
474	PDBGFTYPE pType = (PDBGFTYPE)MMR3HeapAllocZU(pUVM, MM_TAG_DBGF_TYPE, sizeof(DBGFTYPE));
475	if (RT_LIKELY(pType))
476	{
477	pType->Core.pszString = pReg->pszType;
478	pType->pReg = pReg;
479	pType->cRefs = 0;
480	pType->enmTypeBuiltin = DBGFTYPEBUILTIN_INVALID;
481	rc = dbgfR3TypeCalcSize(pUVM, pType, false /* fCalcNested */);
482	if (RT_SUCCESS(rc))
483	{
484	rc = dbgfR3TypeUpdateRefCnts(pUVM, pReg, true /* fRetain */);
485	if (RT_SUCCESS(rc))
486	{
487	bool fSucc = RTStrSpaceInsert(&pUVM->dbgf.s.TypeSpace, &pType->Core);
488	Assert(fSucc);
489	if (!fSucc)
490	{
491	dbgfR3TypeUpdateRefCnts(pUVM, pReg, false /* fRetain */);
492	rc = VERR_ALREADY_EXISTS;
493	}
494	}
495	}
496
497	if (RT_FAILURE(rc))
498	MMR3HeapFree(pType);
499	}
500	else
501	rc = VERR_NO_MEMORY;
502	}
503	}
504	else
505	rc = VERR_ALREADY_EXISTS;
506
507	LogFlowFunc(("-> rc=%Rrc\n", rc));
508	return rc;
509	}
510
511
512	/**
513	* Registers a new built-in type
514	*
515	* @returns VBox status code.
516	* @param pUVM The user mode VM handle.
517	* @param enmTypeBuiltin The builtin type enum.
518	* @param cbType Size of the type in bytes.
519	* @param pszType The type identifier for the builtin type.
520	*/
521	static int dbgfR3TypeRegisterBuiltin(PUVM pUVM, DBGFTYPEBUILTIN enmTypeBuiltin,
522	size_t cbType, const char *pszType)
523	{
524	LogFlowFunc(("pUVM=%#p enmBuiltin=%d pszType=%s\n", pUVM, enmTypeBuiltin, pszType));
525
526	AssertReturn(!dbgfR3TypeLookup(pUVM, pszType), VERR_INVALID_STATE);
527
528	int rc = VINF_SUCCESS;
529	PDBGFTYPE pType = (PDBGFTYPE)MMR3HeapAllocZU(pUVM, MM_TAG_DBGF_TYPE, sizeof(DBGFTYPE));
530	if (RT_LIKELY(pType))
531	{
532	pType->Core.pszString = pszType;
533	pType->pReg = NULL;
534	pType->cRefs = 0;
535	pType->cbType = cbType;
536	pType->enmTypeBuiltin = enmTypeBuiltin;
537	bool fSucc = RTStrSpaceInsert(&pUVM->dbgf.s.TypeSpace, &pType->Core);
538	Assert(fSucc);
539	if (!fSucc)
540	rc = VERR_ALREADY_EXISTS;
541
542	if (RT_FAILURE(rc))
543	MMR3HeapFree(pType);
544	}
545	else
546	rc = VERR_NO_MEMORY;
547
548	return rc;
549	}
550
551
552	/**
553	* Registers builtin types.
554	*
555	* @returns VBox status code.
556	* @param pUVM The user mode VM handle.
557	*/
558	static int dbgfTypeRegisterBuiltinTypes(PUVM pUVM)
559	{
560	int rc = dbgfR3TypeRegisterBuiltin(pUVM, DBGFTYPEBUILTIN_UINT8, sizeof(uint8_t), "uint8_t");
561	if (RT_SUCCESS(rc))
562	rc = dbgfR3TypeRegisterBuiltin(pUVM, DBGFTYPEBUILTIN_INT8, sizeof(int8_t), "int8_t");
563	if (RT_SUCCESS(rc))
564	rc = dbgfR3TypeRegisterBuiltin(pUVM, DBGFTYPEBUILTIN_UINT16, sizeof(uint16_t), "uint16_t");
565	if (RT_SUCCESS(rc))
566	rc = dbgfR3TypeRegisterBuiltin(pUVM, DBGFTYPEBUILTIN_INT16, sizeof(int16_t), "int16_t");
567	if (RT_SUCCESS(rc))
568	rc = dbgfR3TypeRegisterBuiltin(pUVM, DBGFTYPEBUILTIN_UINT32, sizeof(uint32_t), "uint32_t");
569	if (RT_SUCCESS(rc))
570	rc = dbgfR3TypeRegisterBuiltin(pUVM, DBGFTYPEBUILTIN_INT32, sizeof(int32_t), "int32_t");
571	if (RT_SUCCESS(rc))
572	rc = dbgfR3TypeRegisterBuiltin(pUVM, DBGFTYPEBUILTIN_UINT64, sizeof(uint64_t), "uint64_t");
573	if (RT_SUCCESS(rc))
574	rc = dbgfR3TypeRegisterBuiltin(pUVM, DBGFTYPEBUILTIN_INT64, sizeof(int64_t), "int64_t");
575	if (RT_SUCCESS(rc))
576	rc = dbgfR3TypeRegisterBuiltin(pUVM, DBGFTYPEBUILTIN_PTR32, sizeof(uint32_t), "ptr32_t");
577	if (RT_SUCCESS(rc))
578	rc = dbgfR3TypeRegisterBuiltin(pUVM, DBGFTYPEBUILTIN_PTR64, sizeof(uint64_t), "ptr64_t");
579	if (RT_SUCCESS(rc))
580	rc = dbgfR3TypeRegisterBuiltin(pUVM, DBGFTYPEBUILTIN_PTR, 0, "ptr_t");
581	if (RT_SUCCESS(rc))
582	rc = dbgfR3TypeRegisterBuiltin(pUVM, DBGFTYPEBUILTIN_SIZE, 0, "size_t");
583
584	return rc;
585	}
586
587
588	/**
589	* Parses a single entry for a given type and assigns the value from the byte buffer
590	* to the value entry.
591	*
592	* @returns VBox status code.
593	* @param pUVM The user mode VM handle.
594	* @param pMember The type member.
595	* @param pValEntry The value entry holding the value on success.
596	* @param pbBuf The raw byte buffer.
597	* @param cbBuf Size of the byte buffer.
598	* @param pcbParsed Where to store the amount of consumed bytes on success.
599	*/
600	static int dbgfR3TypeParseEntry(PUVM pUVM, PCDBGFTYPEREGMEMBER pMember, PDBGFTYPEVALENTRY pValEntry,
601	uint8_t pbBuf, size_t cbBuf, size_t pcbParsed)
602	{
603	int rc = VINF_SUCCESS;
604	PDBGFTYPE pTypeMember = dbgfR3TypeLookup(pUVM, pMember->pszType);
605	uint32_t cValBufs = 1;
606	size_t cbParsed = 0;
607	PDBGFTYPEVALBUF pValBuf = &pValEntry->Buf.Val;
608
609	AssertPtrReturn(pTypeMember, VERR_INVALID_STATE);
610
611	if (pMember->fFlags & DBGFTYPEREGMEMBER_F_ARRAY)
612	{
613	cValBufs = pMember->cElements;
614	pValBuf = (PDBGFTYPEVALBUF)MMR3HeapAllocZU(pUVM, MM_TAG_DBGF_TYPE, cValBufs * sizeof(DBGFTYPEVALBUF));
615	if (RT_UNLIKELY(!pValBuf))
616	rc = VERR_NO_MEMORY;
617
618	pValEntry->Buf.pVal = pValBuf;
619	pValEntry->cEntries = cValBufs;
620	pValEntry->cbType = pTypeMember->cbType;
621	}
622
623	if (RT_SUCCESS(rc))
624	{
625	for (uint32_t iValBuf = 0; iValBuf < cValBufs && RT_SUCCESS(rc); iValBuf++)
626	{
627	size_t cbThisParsed = 0;
628
629	if (pTypeMember->pReg)
630	{
631	/* Compound or aliased type */
632	rc = dbgfR3TypeParseBufferByType(pUVM, pTypeMember, pbBuf, cbBuf,
633	&pValBuf->pVal, &cbThisParsed);
634	if (RT_SUCCESS(rc))
635	pValEntry->enmType = DBGFTYPEBUILTIN_COMPOUND;
636	}
637	else
638	{
639	void *pvVal = NULL;
640
641	switch (pTypeMember->enmTypeBuiltin)
642	{
643	case DBGFTYPEBUILTIN_UINT8:
644	pvVal = &pValBuf->u8;
645	cbThisParsed = 1;
646	break;
647	case DBGFTYPEBUILTIN_INT8:
648	pvVal = &pValBuf->i8;
649	cbThisParsed = 1;
650	break;
651	case DBGFTYPEBUILTIN_UINT16:
652	pvVal = &pValBuf->u16;
653	cbThisParsed = 2;
654	break;
655	case DBGFTYPEBUILTIN_INT16:
656	pvVal = &pValBuf->i16;
657	cbThisParsed = 2;
658	break;
659	case DBGFTYPEBUILTIN_UINT32:
660	pvVal = &pValBuf->u32;
661	cbThisParsed = 4;
662	break;
663	case DBGFTYPEBUILTIN_INT32:
664	pvVal = &pValBuf->i32;
665	cbThisParsed = 4;
666	break;
667	case DBGFTYPEBUILTIN_UINT64:
668	pvVal = &pValBuf->u64;
669	cbThisParsed = 8;
670	break;
671	case DBGFTYPEBUILTIN_INT64:
672	pvVal = &pValBuf->i64;
673	cbThisParsed = 8;
674	break;
675	case DBGFTYPEBUILTIN_PTR32:
676	pvVal = &pValBuf->GCPtr;
677	cbThisParsed = 4;
678	break;
679	case DBGFTYPEBUILTIN_PTR64:
680	pvVal = &pValBuf->GCPtr;
681	cbThisParsed = 8;
682	break;
683	case DBGFTYPEBUILTIN_PTR:
684	pvVal = &pValBuf->GCPtr;
685	cbThisParsed = pTypeMember->cbType;
686	break;
687	case DBGFTYPEBUILTIN_SIZE:
688	pvVal = &pValBuf->size;
689	cbThisParsed = pTypeMember->cbType;
690	break;
691	case DBGFTYPEBUILTIN_FLOAT32:
692	case DBGFTYPEBUILTIN_FLOAT64:
693	case DBGFTYPEBUILTIN_COMPOUND:
694	default:
695	AssertMsgFailedBreakStmt(("Invalid built-in type specified: %d\n", pTypeMember->enmTypeBuiltin),
696	rc = VERR_INVALID_STATE);
697	}
698
699	if (RT_SUCCESS(rc))
700	{
701	pValEntry->enmType = pTypeMember->enmTypeBuiltin;
702	if (cbBuf >= cbThisParsed)
703	memcpy(pvVal, pbBuf, cbThisParsed);
704	else
705	rc = VERR_BUFFER_OVERFLOW;
706	}
707	}
708
709	pValBuf++;
710
711	cbParsed += cbThisParsed;
712	pbBuf += cbThisParsed;
713	cbBuf -= cbThisParsed;
714	}
715	}
716
717	if ( RT_FAILURE(rc)
718	&& cValBufs > 1)
719	MMR3HeapFree(pValBuf);
720
721	if (RT_SUCCESS(rc))
722	{
723	pValEntry->cEntries = cValBufs;
724	*pcbParsed = cbParsed;
725	}
726
727	return rc;
728	}
729
730
731	/**
732	* Parses the given byte buffer and returns the value based no the type information.
733	*
734	* @returns VBox status code.
735	* @param pUVM The user mode VM handle.
736	* @param pType The type information.
737	* @param pbBuf The byte buffer to parse.
738	* @param cbBuf Size of the buffer.
739	* @param ppVal Where to store the pointer to the value on success.
740	* @param pcbParsed How many bytes of the buffer we consumed.
741	*/
742	static int dbgfR3TypeParseBufferByType(PUVM pUVM, PDBGFTYPE pType, uint8_t *pbBuf, size_t cbBuf,
743	PDBGFTYPEVAL ppVal, size_t pcbParsed)
744	{
745	int rc = VINF_SUCCESS;
746	uint32_t cEntries = pType->pReg ? pType->pReg->cMembers : 1;
747	PDBGFTYPEVAL pVal = (PDBGFTYPEVAL)MMR3HeapAllocZU(pUVM, MM_TAG_DBGF_TYPE,
748	RT_UOFFSETOF_DYN(DBGFTYPEVAL, aEntries[cEntries]));
749	if (RT_LIKELY(pVal))
750	{
751	size_t cbParsed = 0;
752
753	pVal->pTypeReg = pType->pReg;
754	for (uint32_t i = 0; i < cEntries && RT_SUCCESS(rc); i++)
755	{
756	PCDBGFTYPEREGMEMBER pMember = &pType->pReg->paMembers[i];
757	PDBGFTYPEVALENTRY pValEntry = &pVal->aEntries[i];
758	rc = dbgfR3TypeParseEntry(pUVM, pMember, pValEntry, pbBuf, cbBuf, &cbParsed);
759	if (RT_SUCCESS(rc))
760	{
761	pbBuf += cbParsed;
762	cbBuf -= cbParsed;
763	}
764	}
765
766	if (RT_SUCCESS(rc))
767	{
768	pVal->cEntries = cEntries;
769	*pcbParsed = cbParsed;
770	*ppVal = pVal;
771	}
772	else
773	MMR3HeapFree(pVal); /** @todo Leak for embedded structs. */
774	}
775	else
776	rc = VERR_NO_MEMORY;
777
778	return rc;
779	}
780
781
782	/**
783	* Dumps one level of a typed value.
784	*
785	* @returns VBox status code.
786	* @param pVal The value to dump.
787	* @param iLvl The current level.
788	* @param cLvlMax The maximum level.
789	* @param pfnDump The dumper callback.
790	* @param pvUser The opaque user data to pass to the dumper callback.
791	*/
792	static int dbgfR3TypeValDump(PDBGFTYPEVAL pVal, uint32_t iLvl, uint32_t cLvlMax,
793	PFNDBGFR3TYPEVALDUMP pfnDump, void *pvUser)
794	{
795	int rc = VINF_SUCCESS;
796	PCDBGFTYPEREG pType = pVal->pTypeReg;
797
798	for (uint32_t i = 0; i < pVal->cEntries && rc == VINF_SUCCESS; i++)
799	{
800	PCDBGFTYPEREGMEMBER pTypeMember = &pType->paMembers[i];
801	PDBGFTYPEVALENTRY pValEntry = &pVal->aEntries[i];
802	PDBGFTYPEVALBUF pValBuf = pValEntry->cEntries > 1 ? pValEntry->Buf.pVal : &pValEntry->Buf.Val;
803
804	rc = pfnDump(0 /* off */, pTypeMember->pszName, iLvl, pValEntry->enmType, pValEntry->cbType,
805	pValBuf, pValEntry->cEntries, pvUser);
806	if ( rc == VINF_SUCCESS
807	&& pValEntry->enmType == DBGFTYPEBUILTIN_COMPOUND
808	&& iLvl < cLvlMax)
809	{
810	/* Print embedded structs. */
811	for (uint32_t iValBuf = 0; iValBuf < pValEntry->cEntries && rc == VINF_SUCCESS; iValBuf++)
812	rc = dbgfR3TypeValDump(pValBuf[iValBuf].pVal, iLvl + 1, cLvlMax, pfnDump, pvUser);
813	}
814	}
815
816	return rc;
817	}
818
819
820	/**
821	* Dumps one level of a type.
822	*
823	* @returns VBox status code.
824	* @param pUVM The user mode VM handle.
825	* @param pType The type to dump.
826	* @param iLvl The current level.
827	* @param cLvlMax The maximum level.
828	* @param pfnDump The dumper callback.
829	* @param pvUser The opaque user data to pass to the dumper callback.
830	*/
831	static int dbgfR3TypeDump(PUVM pUVM, PDBGFTYPE pType, uint32_t iLvl, uint32_t cLvlMax,
832	PFNDBGFR3TYPEDUMP pfnDump, void *pvUser)
833	{
834	int rc = VINF_SUCCESS;
835	PCDBGFTYPEREG pTypeReg = pType->pReg;
836
837	switch (pTypeReg->enmVariant)
838	{
839	case DBGFTYPEVARIANT_ALIAS:
840	rc = VERR_NOT_IMPLEMENTED;
841	break;
842	case DBGFTYPEVARIANT_STRUCT:
843	case DBGFTYPEVARIANT_UNION:
844	for (uint32_t i = 0; i < pTypeReg->cMembers && rc == VINF_SUCCESS; i++)
845	{
846	PCDBGFTYPEREGMEMBER pTypeMember = &pTypeReg->paMembers[i];
847	PDBGFTYPE pTypeResolved = dbgfR3TypeLookup(pUVM, pTypeMember->pszType);
848
849	rc = pfnDump(0 /* off */, pTypeMember->pszName, iLvl, pTypeMember->pszType,
850	pTypeMember->fFlags, pTypeMember->cElements, pvUser);
851	if ( rc == VINF_SUCCESS
852	&& pTypeResolved->pReg
853	&& iLvl < cLvlMax)
854	{
855	/* Print embedded structs. */
856	rc = dbgfR3TypeDump(pUVM, pTypeResolved, iLvl + 1, cLvlMax, pfnDump, pvUser);
857	}
858	}
859	break;
860	default:
861	AssertMsgFailed(("Invalid type variant: %u\n", pTypeReg->enmVariant));
862	rc = VERR_INVALID_STATE;
863	}
864
865	return rc;
866	}
867
868
869	/**
870	* Initializes the type database.
871	*
872	* @returns VBox status code.
873	* @param pUVM The user mode VM handle.
874	*/
875	DECLHIDDEN(int) dbgfR3TypeInit(PUVM pUVM)
876	{
877	int rc = VINF_SUCCESS;
878	if (!pUVM->dbgf.s.fTypeDbInitialized)
879	{
880	rc = RTSemRWCreate(&pUVM->dbgf.s.hTypeDbLock);
881	if (RT_SUCCESS(rc))
882	{
883	rc = dbgfTypeRegisterBuiltinTypes(pUVM);
884	if (RT_FAILURE(rc))
885	{
886	RTSemRWDestroy(pUVM->dbgf.s.hTypeDbLock);
887	pUVM->dbgf.s.hTypeDbLock = NIL_RTSEMRW;
888	}
889	}
890	pUVM->dbgf.s.fTypeDbInitialized = RT_SUCCESS(rc);
891	}
892	return rc;
893	}
894
895
896	/**
897	* Terminates the type database.
898	*
899	* @param pUVM The user mode VM handle.
900	*/
901	DECLHIDDEN(void) dbgfR3TypeTerm(PUVM pUVM)
902	{
903	RTSemRWDestroy(pUVM->dbgf.s.hTypeDbLock);
904	pUVM->dbgf.s.hTypeDbLock = NIL_RTSEMRW;
905	pUVM->dbgf.s.fTypeDbInitialized = false;
906	}
907
908
909	/**
910	* Registers a new type for lookup.
911	*
912	* @returns VBox status code.
913	* @retval VERR_ALREADY_EXISTS if the type exists already.
914	* @param pUVM The user mode VM handle.
915	* @param cTypes Number of types to register.
916	* @param paTypes The array of type registration structures to register.
917	*/
918	VMMR3DECL(int) DBGFR3TypeRegister(PUVM pUVM, uint32_t cTypes, PCDBGFTYPEREG paTypes)
919	{
920	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
921	AssertReturn(cTypes > 0, VERR_INVALID_PARAMETER);
922	AssertPtrReturn(paTypes, VERR_INVALID_POINTER);
923
924	int rc = VINF_SUCCESS;
925	if (!pUVM->dbgf.s.fTypeDbInitialized)
926	{
927	rc = dbgfR3TypeInit(pUVM);
928	if (RT_FAILURE(rc))
929	return rc;
930	}
931
932	DBGF_TYPE_DB_LOCK_WRITE(pUVM);
933	for (uint32_t i = 0; i < cTypes && RT_SUCCESS(rc); i++)
934	{
935	rc = dbgfR3TypeRegister(pUVM, &paTypes[i]);
936	if ( RT_FAILURE(rc)
937	&& i > 0)
938	{
939	/* Deregister types in reverse order. */
940	do
941	{
942	int rc2 = DBGFR3TypeDeregister(pUVM, paTypes[i].pszType);
943	AssertRC(rc2);
944	i--;
945	} while (i > 0);
946
947	break;
948	}
949	}
950	DBGF_TYPE_DB_UNLOCK_WRITE(pUVM);
951
952	return rc;
953	}
954
955
956	/**
957	* Deregisters a previously registered type.
958	*
959	* @returns VBox status code.
960	* @retval VERR_NOT_FOUND if the type is not known.
961	* @retval VERR_RESOURCE_IN_USE if the type is used by another type.
962	* @param pUVM The user mode VM handle.
963	* @param pszType The type identifier to deregister.
964	*/
965	VMMR3DECL(int) DBGFR3TypeDeregister(PUVM pUVM, const char *pszType)
966	{
967	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
968	AssertPtrReturn(pszType, VERR_INVALID_POINTER);
969
970	int rc = VINF_SUCCESS;
971	if (!pUVM->dbgf.s.fTypeDbInitialized)
972	{
973	rc = dbgfR3TypeInit(pUVM);
974	if (RT_FAILURE(rc))
975	return rc;
976	}
977
978	DBGF_TYPE_DB_LOCK_WRITE(pUVM);
979	PDBGFTYPE pType = dbgfR3TypeLookup(pUVM, pszType);
980	if (pType)
981	{
982	if (!pType->cRefs)
983	{
984
985	}
986	else
987	rc = VERR_RESOURCE_IN_USE;
988	}
989	else
990	rc = VERR_NOT_FOUND;
991	DBGF_TYPE_DB_UNLOCK_WRITE(pUVM);
992
993	return rc;
994	}
995
996
997	/**
998	* Return the type registration structure for the given type identifier.
999	*
1000	* @returns VBox status code.
1001	* @retval VERR_NOT_FOUND if the type is not known.
1002	* @param pUVM The user mode VM handle.
1003	* @param pszType The type identifier to get the registration structure from.
1004	* @param ppTypeReg Where to store the type registration structure on success.
1005	*/
1006	VMMR3DECL(int) DBGFR3TypeQueryReg(PUVM pUVM, const char pszType, PCDBGFTYPEREG ppTypeReg)
1007	{
1008	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
1009	AssertPtrReturn(pszType, VERR_INVALID_POINTER);
1010	AssertPtrReturn(ppTypeReg, VERR_INVALID_POINTER);
1011
1012	int rc = VINF_SUCCESS;
1013	if (!pUVM->dbgf.s.fTypeDbInitialized)
1014	{
1015	rc = dbgfR3TypeInit(pUVM);
1016	if (RT_FAILURE(rc))
1017	return rc;
1018	}
1019
1020	DBGF_TYPE_DB_LOCK_READ(pUVM);
1021	PDBGFTYPE pType = dbgfR3TypeLookup(pUVM, pszType);
1022	if (pType)
1023	*ppTypeReg = pType->pReg;
1024	else
1025	rc = VERR_NOT_FOUND;
1026	DBGF_TYPE_DB_UNLOCK_READ(pUVM);
1027
1028	LogFlowFunc(("-> rc=%Rrc\n", rc));
1029	return rc;
1030	}
1031
1032
1033	/**
1034	* Queries the size a given type would occupy in memory.
1035	*
1036	* @returns VBox status code.
1037	* @retval VERR_NOT_FOUND if the type is not known.
1038	* @param pUVM The user mode VM handle.
1039	* @param pszType The type identifier.
1040	* @param pcbType Where to store the amount of memory occupied in bytes.
1041	*/
1042	VMMR3DECL(int) DBGFR3TypeQuerySize(PUVM pUVM, const char pszType, size_t pcbType)
1043	{
1044	LogFlowFunc(("pUVM=%#p pszType=%s pcbType=%#p\n", pUVM, pszType, pcbType));
1045	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
1046	AssertPtrReturn(pszType, VERR_INVALID_POINTER);
1047	AssertPtrReturn(pcbType, VERR_INVALID_POINTER);
1048
1049	int rc = VINF_SUCCESS;
1050	if (!pUVM->dbgf.s.fTypeDbInitialized)
1051	{
1052	rc = dbgfR3TypeInit(pUVM);
1053	if (RT_FAILURE(rc))
1054	return rc;
1055	}
1056
1057	DBGF_TYPE_DB_LOCK_READ(pUVM);
1058	PDBGFTYPE pType = dbgfR3TypeLookup(pUVM, pszType);
1059	if (pType)
1060	*pcbType = pType->cbType;
1061	else
1062	rc = VERR_NOT_FOUND;
1063	DBGF_TYPE_DB_UNLOCK_READ(pUVM);
1064
1065	LogFlowFunc(("-> rc=%Rrc\n", rc));
1066	return rc;
1067	}
1068
1069
1070	/**
1071	* Sets the size of the given type in bytes.
1072	*
1073	* @returns VBox status code.
1074	* @retval VERR_NOT_FOUND if the type is not known.
1075	* @retval VERR_NOT_SUPPORTED if changing the size of this type is not supported.
1076	* @param pUVM The user mode VM handle.
1077	* @param pszType The type identifier.
1078	* @param cbType The size of the type in bytes.
1079	*
1080	* @note: This currently works only for the builtin pointer type without the explicit
1081	* size (ptr_t or DBGFTYPEBUILTIN_PTR).
1082	*/
1083	VMMR3DECL(int) DBGFR3TypeSetSize(PUVM pUVM, const char *pszType, size_t cbType)
1084	{
1085	LogFlowFunc(("pUVM=%#p pszType=%s cbType=%zu\n", pUVM, pszType, cbType));
1086	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
1087	AssertPtrReturn(pszType, VERR_INVALID_POINTER);
1088	AssertReturn(cbType > 0, VERR_INVALID_PARAMETER);
1089
1090	int rc = VINF_SUCCESS;
1091	if (!pUVM->dbgf.s.fTypeDbInitialized)
1092	{
1093	rc = dbgfR3TypeInit(pUVM);
1094	if (RT_FAILURE(rc))
1095	return rc;
1096	}
1097
1098	DBGF_TYPE_DB_LOCK_WRITE(pUVM);
1099	PDBGFTYPE pType = dbgfR3TypeLookup(pUVM, pszType);
1100	if (pType)
1101	{
1102	if ( !pType->pReg
1103	&& ( pType->enmTypeBuiltin == DBGFTYPEBUILTIN_PTR
1104	\|\| pType->enmTypeBuiltin == DBGFTYPEBUILTIN_SIZE))
1105	{
1106	if (pType->cbType != cbType)
1107	{
1108	pType->cbType = cbType;
1109	rc = dbgfR3TypeRecalculateAllSizes(pUVM);
1110	}
1111	}
1112	else
1113	rc = VERR_NOT_SUPPORTED;
1114	}
1115	else
1116	rc = VERR_NOT_FOUND;
1117	DBGF_TYPE_DB_UNLOCK_WRITE(pUVM);
1118
1119	LogFlowFunc(("-> rc=%Rrc\n", rc));
1120	return rc;
1121	}
1122
1123
1124	/**
1125	* Dumps the type information of the given type.
1126	*
1127	* @returns VBox status code.
1128	* @param pUVM The user mode VM handle.
1129	* @param pszType The type identifier.
1130	* @param fFlags Flags to control the dumping (reserved, MBZ).
1131	* @param cLvlMax Maximum levels to nest.
1132	* @param pfnDump The dumper callback.
1133	* @param pvUser Opaque user data.
1134	*/
1135	VMMR3DECL(int) DBGFR3TypeDumpEx(PUVM pUVM, const char *pszType, uint32_t fFlags,
1136	uint32_t cLvlMax, PFNDBGFR3TYPEDUMP pfnDump, void *pvUser)
1137	{
1138	LogFlowFunc(("pUVM=%#p pszType=%s fFlags=%#x cLvlMax=%u pfnDump=%#p pvUser=%#p\n",
1139	pUVM, pszType, fFlags, cLvlMax, pfnDump, pvUser));
1140	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
1141	AssertPtrReturn(pszType, VERR_INVALID_POINTER);
1142	AssertPtrReturn(pfnDump, VERR_INVALID_POINTER);
1143	RT_NOREF_PV(fFlags);
1144
1145	int rc = VINF_SUCCESS;
1146	if (!pUVM->dbgf.s.fTypeDbInitialized)
1147	{
1148	rc = dbgfR3TypeInit(pUVM);
1149	if (RT_FAILURE(rc))
1150	return rc;
1151	}
1152
1153	DBGF_TYPE_DB_LOCK_READ(pUVM);
1154	PDBGFTYPE pType = dbgfR3TypeLookup(pUVM, pszType);
1155	if (pType)
1156	rc = dbgfR3TypeDump(pUVM, pType, 0 /* iLvl */, cLvlMax, pfnDump, pvUser);
1157	else
1158	rc = VERR_NOT_FOUND;
1159	DBGF_TYPE_DB_UNLOCK_READ(pUVM);
1160
1161	LogFlowFunc(("-> rc=%Rrc\n", rc));
1162	return rc;
1163	}
1164
1165
1166	/**
1167	* Returns the value of a memory buffer at the given address formatted for the given
1168	* type.
1169	*
1170	* @returns VBox status code.
1171	* @retval VERR_NOT_FOUND if the type is not known.
1172	* @param pUVM The user mode VM handle.
1173	* @param pAddress The address to start reading from.
1174	* @param pszType The type identifier.
1175	* @param ppVal Where to store the pointer to the value structure
1176	* on success.
1177	*/
1178	VMMR3DECL(int) DBGFR3TypeQueryValByType(PUVM pUVM, PCDBGFADDRESS pAddress, const char *pszType,
1179	PDBGFTYPEVAL *ppVal)
1180	{
1181	LogFlowFunc(("pUVM=%#p pAddress=%#p pszType=%s ppVal=%#p\n", pUVM, pAddress, pszType, ppVal));
1182	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
1183	AssertPtrReturn(pAddress, VERR_INVALID_POINTER);
1184	AssertPtrReturn(pszType, VERR_INVALID_POINTER);
1185	AssertPtrReturn(ppVal, VERR_INVALID_POINTER);
1186
1187	int rc = VINF_SUCCESS;
1188	if (!pUVM->dbgf.s.fTypeDbInitialized)
1189	{
1190	rc = dbgfR3TypeInit(pUVM);
1191	if (RT_FAILURE(rc))
1192	return rc;
1193	}
1194
1195	DBGF_TYPE_DB_LOCK_READ(pUVM);
1196	PDBGFTYPE pType = dbgfR3TypeLookup(pUVM, pszType);
1197	if (pType)
1198	{
1199	uint8_t pbBuf = (uint8_t )MMR3HeapAllocZU(pUVM, MM_TAG_DBGF_TYPE, pType->cbType);
1200	if (RT_LIKELY(pbBuf))
1201	{
1202	rc = DBGFR3MemRead(pUVM, 0 /idCpu/, pAddress, pbBuf, pType->cbType);
1203	if (RT_SUCCESS(rc))
1204	{
1205	/* Parse the buffer based on the type. */
1206	size_t cbParsed = 0;
1207	rc = dbgfR3TypeParseBufferByType(pUVM, pType, pbBuf, pType->cbType,
1208	ppVal, &cbParsed);
1209	}
1210
1211	MMR3HeapFree(pbBuf);
1212	}
1213	else
1214	rc = VERR_NO_MEMORY;
1215	}
1216	else
1217	rc = VERR_NOT_FOUND;
1218	DBGF_TYPE_DB_UNLOCK_READ(pUVM);
1219
1220	LogFlowFunc(("-> rc=%Rrc\n", rc));
1221	return rc;
1222	}
1223
1224
1225	/**
1226	* Frees all acquired resources of a value previously obtained with
1227	* DBGFR3TypeQueryValByType().
1228	*
1229	* @param pVal The value to free.
1230	*/
1231	VMMR3DECL(void) DBGFR3TypeValFree(PDBGFTYPEVAL pVal)
1232	{
1233	AssertPtrReturnVoid(pVal);
1234
1235	for (uint32_t i = 0; i < pVal->cEntries; i++)
1236	{
1237	PDBGFTYPEVALENTRY pValEntry = &pVal->aEntries[i];
1238	PDBGFTYPEVALBUF pValBuf = pValEntry->cEntries > 1 ? pValEntry->Buf.pVal : &pValEntry->Buf.Val;
1239
1240	if (pValEntry->enmType == DBGFTYPEBUILTIN_COMPOUND)
1241	for (uint32_t iBuf = 0; iBuf < pValEntry->cEntries; iBuf++)
1242	DBGFR3TypeValFree(pValBuf->pVal);
1243
1244	if (pValEntry->cEntries > 1)
1245	MMR3HeapFree(pValEntry->Buf.pVal);
1246	}
1247
1248	MMR3HeapFree(pVal);
1249	}
1250
1251
1252	/**
1253	* Reads the guest memory with the given type and dumps the content of the type.
1254	*
1255	* @returns VBox status code.
1256	* @param pUVM The user mode VM handle.
1257	* @param pAddress The address to start reading from.
1258	* @param pszType The type identifier.
1259	* @param fFlags Flags for tweaking (reserved, must be zero).
1260	* @param cLvlMax Maximum number of levels to expand embedded structs.
1261	* @param pfnDump The dumper callback.
1262	* @param pvUser The opaque user data to pass to the callback.
1263	*/
1264	VMMR3DECL(int) DBGFR3TypeValDumpEx(PUVM pUVM, PCDBGFADDRESS pAddress, const char *pszType, uint32_t fFlags,
1265	uint32_t cLvlMax, FNDBGFR3TYPEVALDUMP pfnDump, void *pvUser)
1266	{
1267	LogFlowFunc(("pUVM=%#p pAddress=%#p pszType=%s fFlags=%#x pfnDump=%#p pvUser=%#p\n",
1268	pUVM, pAddress, pszType, fFlags,pfnDump, pvUser));
1269	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
1270	AssertPtrReturn(pAddress, VERR_INVALID_POINTER);
1271	AssertPtrReturn(pszType, VERR_INVALID_POINTER);
1272	AssertPtrReturn(pfnDump, VERR_INVALID_POINTER);
1273	AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
1274	AssertReturn(cLvlMax >= 1, VERR_INVALID_PARAMETER);
1275
1276	PDBGFTYPEVAL pVal = NULL;
1277	int rc = DBGFR3TypeQueryValByType(pUVM, pAddress, pszType, &pVal);
1278	if (RT_SUCCESS(rc))
1279	{
1280	rc = dbgfR3TypeValDump(pVal, 0 /* iLvl */, cLvlMax, pfnDump, pvUser);
1281	DBGFR3TypeValFree(pVal);
1282	}
1283
1284	LogFlowFunc(("-> rc=%Rrc\n", rc));
1285	return rc;
1286	}
1287

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

source: vbox/trunk/src/VBox/VMM/VMMR3/DBGFR3Type.cpp

Download in other formats: