CFGM.cpp@ 30111

Last change on this file since 30111 was 28800, checked in by vboxsync, 15 years ago
Automated rebranding to Oracle copyright/license strings via filemuncher
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 79.9 KB

Line
1	/* $Id: CFGM.cpp 28800 2010-04-27 08:22:32Z vboxsync $ */
2	/** @file
3	* CFGM - Configuration Manager.
4	*/
5
6	/*
7	* Copyright (C) 2006-2008 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	/** @page pg_cfgm CFGM - The Configuration Manager
19	*
20	* The configuration manager is a directory containing the VM configuration at
21	* run time. It works in a manner similar to the windows registry - it's like a
22	* file system hierarchy, but the files (values) live in a separate name space
23	* and can include the path separators.
24	*
25	* The configuration is normally created via a callback passed to VMR3Create()
26	* via the pfnCFGMConstructor parameter. To make testcase writing a bit simpler,
27	* we allow the callback to be NULL, in which case a simple default
28	* configuration will be created by CFGMR3ConstructDefaultTree(). The
29	* Console::configConstructor() method in Main/ConsoleImpl2.cpp creates the
30	* configuration from the XML.
31	*
32	* Devices, drivers, services and other PDM stuff are given their own subtree
33	* where they are protected from accessing information of any parents. This is
34	* is implemented via the CFGMR3SetRestrictedRoot() API.
35	*
36	* Data validation out over the basic primitives is left to the caller. The
37	* caller is in a better position to know the proper validation rules of the
38	* individual properties.
39	*
40	* @see grp_cfgm
41	*
42	*
43	* @section sec_cfgm_primitives Data Primitives
44	*
45	* CFGM supports the following data primitives:
46	* - Integers. Representation is unsigned 64-bit. Boolean, unsigned and
47	* small integers, and pointers are all represented using this primitive.
48	* - Zero terminated character strings. These are of course UTF-8.
49	* - Variable length byte strings. This can be used to get/put binary
50	* objects like for instance RTMAC.
51	*
52	*/
53
54	/*******************************************************************************
55	* Header Files *
56	*******************************************************************************/
57	#define LOG_GROUP LOG_GROUP_CFGM
58	#include <VBox/cfgm.h>
59	#include <VBox/dbgf.h>
60	#include <VBox/mm.h>
61	#include "CFGMInternal.h"
62	#include <VBox/vm.h>
63	#include <VBox/err.h>
64
65	#include <VBox/log.h>
66	#include <iprt/assert.h>
67	#include <iprt/string.h>
68	#include <iprt/uuid.h>
69
70
71	/*******************************************************************************
72	* Internal Functions *
73	*******************************************************************************/
74	static void cfgmR3DumpPath(PCFGMNODE pNode, PCDBGFINFOHLP pHlp);
75	static void cfgmR3Dump(PCFGMNODE pRoot, unsigned iLevel, PCDBGFINFOHLP pHlp);
76	static DECLCALLBACK(void) cfgmR3Info(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
77	static int cfgmR3ResolveNode(PCFGMNODE pNode, const char pszPath, PCFGMNODE ppChild);
78	static int cfgmR3ResolveLeaf(PCFGMNODE pNode, const char pszName, PCFGMLEAF ppLeaf);
79	static int cfgmR3InsertLeaf(PCFGMNODE pNode, const char pszName, PCFGMLEAF ppLeaf);
80	static void cfgmR3RemoveLeaf(PCFGMNODE pNode, PCFGMLEAF pLeaf);
81	static void cfgmR3FreeValue(PCFGMLEAF pLeaf);
82
83
84
85	/**
86	* Constructs the configuration for the VM.
87	*
88	* @returns VBox status code.
89	* @param pVM Pointer to VM which configuration has not yet been loaded.
90	* @param pfnCFGMConstructor Pointer to callback function for constructing the VM configuration tree.
91	* This is called in the EM.
92	* @param pvUser The user argument passed to pfnCFGMConstructor.
93	* @thread EMT.
94	*/
95	VMMR3DECL(int) CFGMR3Init(PVM pVM, PFNCFGMCONSTRUCTOR pfnCFGMConstructor, void *pvUser)
96	{
97	LogFlow(("CFGMR3Init: pfnCFGMConstructor=%p pvUser=%p\n", pfnCFGMConstructor, pvUser));
98
99	/*
100	* Init data members.
101	*/
102	pVM->cfgm.s.pRoot = NULL;
103
104	/*
105	* Register DBGF into item.
106	*/
107	int rc = DBGFR3InfoRegisterInternal(pVM, "cfgm", "Dumps a part of the CFGM tree. The argument indicates where to start.", cfgmR3Info);
108	AssertRCReturn(rc,rc);
109
110	/*
111	* Root Node.
112	*/
113	PCFGMNODE pRoot = (PCFGMNODE)MMR3HeapAllocZ(pVM, MM_TAG_CFGM, sizeof(*pRoot));
114	if (!pRoot)
115	return VERR_NO_MEMORY;
116	pRoot->pVM = pVM;
117	pRoot->cchName = 0;
118	pVM->cfgm.s.pRoot = pRoot;
119
120	/*
121	* Call the constructor if specified, if not use the default one.
122	*/
123	if (pfnCFGMConstructor)
124	rc = pfnCFGMConstructor(pVM, pvUser);
125	else
126	rc = CFGMR3ConstructDefaultTree(pVM);
127	if (RT_SUCCESS(rc))
128	{
129	Log(("CFGMR3Init: Successfully constructed the configuration\n"));
130	CFGMR3Dump(CFGMR3GetRoot(pVM));
131	}
132	else
133	AssertMsgFailed(("Constructor failed with rc=%Rrc pfnCFGMConstructor=%p\n", rc, pfnCFGMConstructor));
134
135	return rc;
136	}
137
138
139	/**
140	* Terminates the configuration manager.
141	*
142	* @returns VBox status code.
143	* @param pVM VM handle.
144	*/
145	VMMR3DECL(int) CFGMR3Term(PVM pVM)
146	{
147	CFGMR3RemoveNode(pVM->cfgm.s.pRoot);
148	pVM->cfgm.s.pRoot = NULL;
149	return 0;
150	}
151
152
153	/**
154	* Gets the root node for the VM.
155	*
156	* @returns Pointer to root node.
157	* @param pVM VM handle.
158	*/
159	VMMR3DECL(PCFGMNODE) CFGMR3GetRoot(PVM pVM)
160	{
161	return pVM->cfgm.s.pRoot;
162	}
163
164
165	/**
166	* Gets the parent of a CFGM node.
167	*
168	* @returns Pointer to the parent node.
169	* @returns NULL if pNode is Root or pNode is the start of a
170	* restricted subtree (use CFGMr3GetParentEx() for that).
171	*
172	* @param pNode The node which parent we query.
173	*/
174	VMMR3DECL(PCFGMNODE) CFGMR3GetParent(PCFGMNODE pNode)
175	{
176	if (pNode && !pNode->fRestrictedRoot)
177	return pNode->pParent;
178	return NULL;
179	}
180
181
182	/**
183	* Gets the parent of a CFGM node.
184	*
185	* @returns Pointer to the parent node.
186	* @returns NULL if pNode is Root or pVM is not correct.
187	*
188	* @param pVM The VM handle, used as token that the caller is trusted.
189	* @param pNode The node which parent we query.
190	*/
191	VMMR3DECL(PCFGMNODE) CFGMR3GetParentEx(PVM pVM, PCFGMNODE pNode)
192	{
193	if (pNode && pNode->pVM == pVM)
194	return pNode->pParent;
195	return NULL;
196	}
197
198
199	/**
200	* Query a child node.
201	*
202	* @returns Pointer to the specified node.
203	* @returns NULL if node was not found or pNode is NULL.
204	* @param pNode Node pszPath is relative to.
205	* @param pszPath Path to the child node or pNode.
206	* It's good style to end this with '/'.
207	*/
208	VMMR3DECL(PCFGMNODE) CFGMR3GetChild(PCFGMNODE pNode, const char *pszPath)
209	{
210	PCFGMNODE pChild;
211	int rc = cfgmR3ResolveNode(pNode, pszPath, &pChild);
212	if (RT_SUCCESS(rc))
213	return pChild;
214	return NULL;
215	}
216
217
218	/**
219	* Query a child node by a format string.
220	*
221	* @returns Pointer to the specified node.
222	* @returns NULL if node was not found or pNode is NULL.
223	* @param pNode Node pszPath is relative to.
224	* @param pszPathFormat Path to the child node or pNode.
225	* It's good style to end this with '/'.
226	* @param ... Arguments to pszPathFormat.
227	*/
228	VMMR3DECL(PCFGMNODE) CFGMR3GetChildF(PCFGMNODE pNode, const char *pszPathFormat, ...)
229	{
230	va_list Args;
231	va_start(Args, pszPathFormat);
232	PCFGMNODE pRet = CFGMR3GetChildFV(pNode, pszPathFormat, Args);
233	va_end(Args);
234	return pRet;
235	}
236
237
238	/**
239	* Query a child node by a format string.
240	*
241	* @returns Pointer to the specified node.
242	* @returns NULL if node was not found or pNode is NULL.
243	* @param pNode Node pszPath is relative to.
244	* @param pszPathFormat Path to the child node or pNode.
245	* It's good style to end this with '/'.
246	* @param Args Arguments to pszPathFormat.
247	*/
248	VMMR3DECL(PCFGMNODE) CFGMR3GetChildFV(PCFGMNODE pNode, const char *pszPathFormat, va_list Args)
249	{
250	char *pszPath;
251	RTStrAPrintfV(&pszPath, pszPathFormat, Args);
252	if (pszPath)
253	{
254	PCFGMNODE pChild;
255	int rc = cfgmR3ResolveNode(pNode, pszPath, &pChild);
256	RTStrFree(pszPath);
257	if (RT_SUCCESS(rc))
258	return pChild;
259	}
260	return NULL;
261	}
262
263
264	/**
265	* Gets the first child node.
266	* Use this to start an enumeration of child nodes.
267	*
268	* @returns Pointer to the first child.
269	* @returns NULL if no children.
270	* @param pNode Node to enumerate children for.
271	*/
272	VMMR3DECL(PCFGMNODE) CFGMR3GetFirstChild(PCFGMNODE pNode)
273	{
274	return pNode ? pNode->pFirstChild : NULL;
275	}
276
277
278	/**
279	* Gets the next sibling node.
280	* Use this to continue an enumeration.
281	*
282	* @returns Pointer to the first child.
283	* @returns NULL if no children.
284	* @param pCur Node to returned by a call to CFGMR3GetFirstChild()
285	* or successive calls to this function.
286	*/
287	VMMR3DECL(PCFGMNODE) CFGMR3GetNextChild(PCFGMNODE pCur)
288	{
289	return pCur ? pCur->pNext : NULL;
290	}
291
292
293	/**
294	* Gets the name of the current node.
295	* (Needed for enumeration.)
296	*
297	* @returns VBox status code.
298	* @param pCur Node to returned by a call to CFGMR3GetFirstChild()
299	* or successive calls to CFGMR3GetNextChild().
300	* @param pszName Where to store the node name.
301	* @param cchName Size of the buffer pointed to by pszName (with terminator).
302	*/
303	VMMR3DECL(int) CFGMR3GetName(PCFGMNODE pCur, char *pszName, size_t cchName)
304	{
305	int rc;
306	if (pCur)
307	{
308	if (cchName > pCur->cchName)
309	{
310	rc = VINF_SUCCESS;
311	memcpy(pszName, pCur->szName, pCur->cchName + 1);
312	}
313	else
314	rc = VERR_CFGM_NOT_ENOUGH_SPACE;
315	}
316	else
317	rc = VERR_CFGM_NO_NODE;
318	return rc;
319	}
320
321
322	/**
323	* Gets the length of the current node's name.
324	* (Needed for enumeration.)
325	*
326	* @returns Node name length in bytes including the terminating null char.
327	* @returns 0 if pCur is NULL.
328	* @param pCur Node to returned by a call to CFGMR3GetFirstChild()
329	* or successive calls to CFGMR3GetNextChild().
330	*/
331	VMMR3DECL(size_t) CFGMR3GetNameLen(PCFGMNODE pCur)
332	{
333	return pCur ? pCur->cchName + 1 : 0;
334	}
335
336
337	/**
338	* Validates that the child nodes are within a set of valid names.
339	*
340	* @returns true if all names are found in pszzAllowed.
341	* @returns false if not.
342	* @param pNode The node which children should be examined.
343	* @param pszzValid List of valid names separated by '\\0' and ending with
344	* a double '\\0'.
345	*
346	* @deprecated Use CFGMR3ValidateConfig.
347	*/
348	VMMR3DECL(bool) CFGMR3AreChildrenValid(PCFGMNODE pNode, const char *pszzValid)
349	{
350	if (pNode)
351	{
352	for (PCFGMNODE pChild = pNode->pFirstChild; pChild; pChild = pChild->pNext)
353	{
354	/* search pszzValid for the name */
355	const char *psz = pszzValid;
356	while (*psz)
357	{
358	size_t cch = strlen(psz);
359	if ( cch == pChild->cchName
360	&& !memcmp(psz, pChild->szName, cch))
361	break;
362
363	/* next */
364	psz += cch + 1;
365	}
366
367	/* if at end of pszzValid we didn't find it => failure */
368	if (!*psz)
369	{
370	AssertMsgFailed(("Couldn't find '%s' in the valid values\n", pChild->szName));
371	return false;
372	}
373	}
374	}
375
376	/* all ok. */
377	return true;
378	}
379
380
381	/**
382	* Gets the first value of a node.
383	* Use this to start an enumeration of values.
384	*
385	* @returns Pointer to the first value.
386	* @param pCur The node (Key) which values to enumerate.
387	*/
388	VMMR3DECL(PCFGMLEAF) CFGMR3GetFirstValue(PCFGMNODE pCur)
389	{
390	return pCur ? pCur->pFirstLeaf : NULL;
391	}
392
393	/**
394	* Gets the next value in enumeration.
395	*
396	* @returns Pointer to the next value.
397	* @param pCur The current value as returned by this function or CFGMR3GetFirstValue().
398	*/
399	VMMR3DECL(PCFGMLEAF) CFGMR3GetNextValue(PCFGMLEAF pCur)
400	{
401	return pCur ? pCur->pNext : NULL;
402	}
403
404	/**
405	* Get the value name.
406	* (Needed for enumeration.)
407	*
408	* @returns VBox status code.
409	* @param pCur Value returned by a call to CFGMR3GetFirstValue()
410	* or successive calls to CFGMR3GetNextValue().
411	* @param pszName Where to store the value name.
412	* @param cchName Size of the buffer pointed to by pszName (with terminator).
413	*/
414	VMMR3DECL(int) CFGMR3GetValueName(PCFGMLEAF pCur, char *pszName, size_t cchName)
415	{
416	int rc;
417	if (pCur)
418	{
419	if (cchName > pCur->cchName)
420	{
421	rc = VINF_SUCCESS;
422	memcpy(pszName, pCur->szName, pCur->cchName + 1);
423	}
424	else
425	rc = VERR_CFGM_NOT_ENOUGH_SPACE;
426	}
427	else
428	rc = VERR_CFGM_NO_NODE;
429	return rc;
430	}
431
432
433	/**
434	* Gets the length of the current node's name.
435	* (Needed for enumeration.)
436	*
437	* @returns Value name length in bytes including the terminating null char.
438	* @returns 0 if pCur is NULL.
439	* @param pCur Value returned by a call to CFGMR3GetFirstValue()
440	* or successive calls to CFGMR3GetNextValue().
441	*/
442	VMMR3DECL(size_t) CFGMR3GetValueNameLen(PCFGMLEAF pCur)
443	{
444	return pCur ? pCur->cchName + 1 : 0;
445	}
446
447
448	/**
449	* Gets the value type.
450	* (For enumeration.)
451	*
452	* @returns VBox status code.
453	* @param pCur Value returned by a call to CFGMR3GetFirstValue()
454	* or successive calls to CFGMR3GetNextValue().
455	*/
456	VMMR3DECL(CFGMVALUETYPE) CFGMR3GetValueType(PCFGMLEAF pCur)
457	{
458	Assert(pCur);
459	return pCur->enmType;
460	}
461
462
463	/**
464	* Validates that the values are within a set of valid names.
465	*
466	* @returns true if all names are found in pszzAllowed.
467	* @returns false if not.
468	* @param pNode The node which values should be examined.
469	* @param pszzValid List of valid names separated by '\\0' and ending with
470	* a double '\\0'.
471	* @deprecated Use CFGMR3ValidateConfig.
472	*/
473	VMMR3DECL(bool) CFGMR3AreValuesValid(PCFGMNODE pNode, const char *pszzValid)
474	{
475	if (pNode)
476	{
477	for (PCFGMLEAF pLeaf = pNode->pFirstLeaf; pLeaf; pLeaf = pLeaf->pNext)
478	{
479	/* search pszzValid for the name */
480	const char *psz = pszzValid;
481	while (*psz)
482	{
483	size_t cch = strlen(psz);
484	if ( cch == pLeaf->cchName
485	&& !memcmp(psz, pLeaf->szName, cch))
486	break;
487
488	/* next */
489	psz += cch + 1;
490	}
491
492	/* if at end of pszzValid we didn't find it => failure */
493	if (!*psz)
494	{
495	AssertMsgFailed(("Couldn't find '%s' in the valid values\n", pLeaf->szName));
496	return false;
497	}
498	}
499	}
500
501	/* all ok. */
502	return true;
503	}
504
505
506
507	/**
508	* Query value type.
509	*
510	* @returns VBox status code.
511	* @param pNode Which node to search for pszName in.
512	* @param pszName Name of an integer value.
513	* @param penmType Where to store the type.
514	*/
515	VMMR3DECL(int) CFGMR3QueryType(PCFGMNODE pNode, const char *pszName, PCFGMVALUETYPE penmType)
516	{
517	PCFGMLEAF pLeaf;
518	int rc = cfgmR3ResolveLeaf(pNode, pszName, &pLeaf);
519	if (RT_SUCCESS(rc))
520	{
521	if (penmType)
522	*penmType = pLeaf->enmType;
523	}
524	return rc;
525	}
526
527
528	/**
529	* Query value size.
530	* This works on all types of values.
531	*
532	* @returns VBox status code.
533	* @param pNode Which node to search for pszName in.
534	* @param pszName Name of an integer value.
535	* @param pcb Where to store the value size.
536	*/
537	VMMR3DECL(int) CFGMR3QuerySize(PCFGMNODE pNode, const char pszName, size_t pcb)
538	{
539	PCFGMLEAF pLeaf;
540	int rc = cfgmR3ResolveLeaf(pNode, pszName, &pLeaf);
541	if (RT_SUCCESS(rc))
542	{
543	switch (pLeaf->enmType)
544	{
545	case CFGMVALUETYPE_INTEGER:
546	*pcb = sizeof(pLeaf->Value.Integer.u64);
547	break;
548
549	case CFGMVALUETYPE_STRING:
550	*pcb = pLeaf->Value.String.cb;
551	break;
552
553	case CFGMVALUETYPE_BYTES:
554	*pcb = pLeaf->Value.Bytes.cb;
555	break;
556
557	default:
558	rc = VERR_INTERNAL_ERROR;
559	AssertMsgFailed(("Invalid value type %d\n", pLeaf->enmType));
560	break;
561	}
562	}
563	return rc;
564	}
565
566
567	/**
568	* Query integer value.
569	*
570	* @returns VBox status code.
571	* @param pNode Which node to search for pszName in.
572	* @param pszName Name of an integer value.
573	* @param pu64 Where to store the integer value.
574	*/
575	VMMR3DECL(int) CFGMR3QueryInteger(PCFGMNODE pNode, const char pszName, uint64_t pu64)
576	{
577	PCFGMLEAF pLeaf;
578	int rc = cfgmR3ResolveLeaf(pNode, pszName, &pLeaf);
579	if (RT_SUCCESS(rc))
580	{
581	if (pLeaf->enmType == CFGMVALUETYPE_INTEGER)
582	*pu64 = pLeaf->Value.Integer.u64;
583	else
584	rc = VERR_CFGM_NOT_INTEGER;
585	}
586	return rc;
587	}
588
589
590	/**
591	* Query integer value with default.
592	*
593	* @returns VBox status code.
594	* @param pNode Which node to search for pszName in.
595	* @param pszName Name of an integer value.
596	* @param pu64 Where to store the integer value. This is set to the default on failure.
597	* @param u64Def The default value. This is always set.
598	*/
599	VMMR3DECL(int) CFGMR3QueryIntegerDef(PCFGMNODE pNode, const char pszName, uint64_t pu64, uint64_t u64Def)
600	{
601	PCFGMLEAF pLeaf;
602	int rc = cfgmR3ResolveLeaf(pNode, pszName, &pLeaf);
603	if (RT_SUCCESS(rc))
604	{
605	if (pLeaf->enmType == CFGMVALUETYPE_INTEGER)
606	*pu64 = pLeaf->Value.Integer.u64;
607	else
608	rc = VERR_CFGM_NOT_INTEGER;
609	}
610
611	if (RT_FAILURE(rc))
612	{
613	*pu64 = u64Def;
614	if (rc == VERR_CFGM_VALUE_NOT_FOUND \|\| rc == VERR_CFGM_NO_PARENT)
615	rc = VINF_SUCCESS;
616	}
617
618	return rc;
619	}
620
621
622	/**
623	* Query zero terminated character value.
624	*
625	* @returns VBox status code.
626	* @param pNode Which node to search for pszName in.
627	* @param pszName Name of a zero terminate character value.
628	* @param pszString Where to store the string.
629	* @param cchString Size of the string buffer. (Includes terminator.)
630	*/
631	VMMR3DECL(int) CFGMR3QueryString(PCFGMNODE pNode, const char pszName, char pszString, size_t cchString)
632	{
633	PCFGMLEAF pLeaf;
634	int rc = cfgmR3ResolveLeaf(pNode, pszName, &pLeaf);
635	if (RT_SUCCESS(rc))
636	{
637	if (pLeaf->enmType == CFGMVALUETYPE_STRING)
638	{
639	size_t cbSrc = pLeaf->Value.String.cb;
640	if (cchString >= cbSrc)
641	{
642	memcpy(pszString, pLeaf->Value.String.psz, cbSrc);
643	memset(pszString + cbSrc, 0, cchString - cbSrc);
644	}
645	else
646	rc = VERR_CFGM_NOT_ENOUGH_SPACE;
647	}
648	else
649	rc = VERR_CFGM_NOT_STRING;
650	}
651	return rc;
652	}
653
654
655	/**
656	* Query zero terminated character value with default.
657	*
658	* @returns VBox status code.
659	* @param pNode Which node to search for pszName in.
660	* @param pszName Name of a zero terminate character value.
661	* @param pszString Where to store the string. This will not be set on overflow error.
662	* @param cchString Size of the string buffer. (Includes terminator.)
663	* @param pszDef The default value.
664	*/
665	VMMR3DECL(int) CFGMR3QueryStringDef(PCFGMNODE pNode, const char pszName, char pszString, size_t cchString, const char *pszDef)
666	{
667	PCFGMLEAF pLeaf;
668	int rc = cfgmR3ResolveLeaf(pNode, pszName, &pLeaf);
669	if (RT_SUCCESS(rc))
670	{
671	if (pLeaf->enmType == CFGMVALUETYPE_STRING)
672	{
673	size_t cbSrc = pLeaf->Value.String.cb;
674	if (cchString >= cbSrc)
675	{
676	memcpy(pszString, pLeaf->Value.String.psz, cbSrc);
677	memset(pszString + cbSrc, 0, cchString - cbSrc);
678	}
679	else
680	rc = VERR_CFGM_NOT_ENOUGH_SPACE;
681	}
682	else
683	rc = VERR_CFGM_NOT_STRING;
684	}
685
686	if (RT_FAILURE(rc) && rc != VERR_CFGM_NOT_ENOUGH_SPACE)
687	{
688	size_t cchDef = strlen(pszDef);
689	if (cchString > cchDef)
690	{
691	memcpy(pszString, pszDef, cchDef);
692	memset(pszString + cchDef, 0, cchString - cchDef);
693	if (rc == VERR_CFGM_VALUE_NOT_FOUND \|\| rc == VERR_CFGM_NO_PARENT)
694	rc = VINF_SUCCESS;
695	}
696	else if (rc == VERR_CFGM_VALUE_NOT_FOUND \|\| rc == VERR_CFGM_NO_PARENT)
697	rc = VERR_CFGM_NOT_ENOUGH_SPACE;
698	}
699
700	return rc;
701	}
702
703
704	/**
705	* Query byte string value.
706	*
707	* @returns VBox status code.
708	* @param pNode Which node to search for pszName in.
709	* @param pszName Name of a byte string value.
710	* @param pvData Where to store the binary data.
711	* @param cbData Size of buffer pvData points too.
712	*/
713	VMMR3DECL(int) CFGMR3QueryBytes(PCFGMNODE pNode, const char pszName, void pvData, size_t cbData)
714	{
715	PCFGMLEAF pLeaf;
716	int rc = cfgmR3ResolveLeaf(pNode, pszName, &pLeaf);
717	if (RT_SUCCESS(rc))
718	{
719	if (pLeaf->enmType == CFGMVALUETYPE_BYTES)
720	{
721	if (cbData >= pLeaf->Value.Bytes.cb)
722	{
723	memcpy(pvData, pLeaf->Value.Bytes.pau8, pLeaf->Value.Bytes.cb);
724	memset((char *)pvData + pLeaf->Value.Bytes.cb, 0, cbData - pLeaf->Value.Bytes.cb);
725	}
726	else
727	rc = VERR_CFGM_NOT_ENOUGH_SPACE;
728	}
729	else
730	rc = VERR_CFGM_NOT_BYTES;
731	}
732	return rc;
733	}
734
735
736	/**
737	* Validate one level of a configuration node.
738	*
739	* This replaces the CFGMR3AreChildrenValid and CFGMR3AreValuesValid APIs.
740	*
741	* @returns VBox status code.
742	*
743	* When an error is returned, both VMSetError and AssertLogRelMsgFailed
744	* have been called. So, all the caller needs to do is to propagate
745	* the error status up to PDM.
746	*
747	* @param pNode The node to validate.
748	* @param pszNode The node path, always ends with a slash. Use
749	* "/" for the root config node.
750	* @param pszValidValues Patterns describing the valid value names. See
751	* RTStrSimplePatternMultiMatch for details on the
752	* pattern syntax.
753	* @param pszValidNodes Patterns describing the valid node (key) names.
754	* See RTStrSimplePatternMultiMatch for details on
755	* the pattern syntax.
756	* @param pszWho Who is calling.
757	* @param uInstance The instance number of the caller.
758	*/
759	VMMR3DECL(int) CFGMR3ValidateConfig(PCFGMNODE pNode, const char *pszNode,
760	const char pszValidValues, const char pszValidNodes,
761	const char *pszWho, uint32_t uInstance)
762	{
763	/* Input validation. */
764	AssertPtrNullReturn(pNode, VERR_INVALID_POINTER);
765	AssertPtrReturn(pszNode, VERR_INVALID_POINTER);
766	Assert(*pszNode && pszNode[strlen(pszNode) - 1] == '/');
767	AssertPtrReturn(pszValidValues, VERR_INVALID_POINTER);
768	AssertPtrReturn(pszValidNodes, VERR_INVALID_POINTER);
769	AssertPtrReturn(pszWho, VERR_INVALID_POINTER);
770
771	if (pNode)
772	{
773	/*
774	* Enumerate the leafs and check them against pszValidValues.
775	*/
776	for (PCFGMLEAF pLeaf = pNode->pFirstLeaf; pLeaf; pLeaf = pLeaf->pNext)
777	{
778	if (!RTStrSimplePatternMultiMatch(pszValidValues, RTSTR_MAX,
779	pLeaf->szName, pLeaf->cchName,
780	NULL))
781	{
782	AssertLogRelMsgFailed(("%s/%u: Value '%s/%s' didn't match '%s'\n",
783	pszWho, uInstance, pszNode, pLeaf->szName, pszValidValues));
784	return VMSetError(pNode->pVM, VERR_CFGM_CONFIG_UNKNOWN_VALUE, RT_SRC_POS,
785	N_("Unknown configuration value '%s/%s' found in the configuration of %s instance #%u"),
786	pszNode, pLeaf->szName, pszWho, uInstance);
787	}
788
789	}
790
791	/*
792	* Enumerate the child nodes and check them against pszValidNodes.
793	*/
794	for (PCFGMNODE pChild = pNode->pFirstChild; pChild; pChild = pChild->pNext)
795	{
796	if (!RTStrSimplePatternMultiMatch(pszValidNodes, RTSTR_MAX,
797	pChild->szName, pChild->cchName,
798	NULL))
799	{
800	AssertLogRelMsgFailed(("%s/%u: Node '%s/%s' didn't match '%s'\n",
801	pszWho, uInstance, pszNode, pChild->szName, pszValidNodes));
802	return VMSetError(pNode->pVM, VERR_CFGM_CONFIG_UNKNOWN_NODE, RT_SRC_POS,
803	N_("Unknown configuration node '%s/%s' found in the configuration of %s instance #%u"),
804	pszNode, pChild->szName, pszWho, uInstance);
805	}
806	}
807	}
808
809	/* All is well. */
810	return VINF_SUCCESS;
811	}
812
813
814
815	/**
816	* Populates the CFGM tree with the default configuration.
817	*
818	* This assumes an empty tree and is intended for testcases and such that only
819	* need to do very small adjustments to the config.
820	*
821	* @returns VBox status code.
822	* @param pVM VM handle.
823	*/
824	VMMR3DECL(int) CFGMR3ConstructDefaultTree(PVM pVM)
825	{
826	int rc;
827	int rcAll = VINF_SUCCESS;
828	#define UPDATERC() do { if (RT_FAILURE(rc) && RT_SUCCESS(rcAll)) rcAll = rc; } while (0)
829
830	PCFGMNODE pRoot = CFGMR3GetRoot(pVM);
831	AssertReturn(pRoot, VERR_WRONG_ORDER);
832
833	/*
834	* Create VM default values.
835	*/
836	rc = CFGMR3InsertString(pRoot, "Name", "Default VM");
837	UPDATERC();
838	rc = CFGMR3InsertInteger(pRoot, "RamSize", 128U * _1M);
839	UPDATERC();
840	rc = CFGMR3InsertInteger(pRoot, "RamHoleSize", 512U * _1M);
841	UPDATERC();
842	rc = CFGMR3InsertInteger(pRoot, "TimerMillies", 10);
843	UPDATERC();
844	rc = CFGMR3InsertInteger(pRoot, "RawR3Enabled", 1);
845	UPDATERC();
846	/** @todo CFGM Defaults: RawR0, PATMEnabled and CASMEnabled needs attention later. */
847	rc = CFGMR3InsertInteger(pRoot, "RawR0Enabled", 1);
848	UPDATERC();
849	rc = CFGMR3InsertInteger(pRoot, "PATMEnabled", 1);
850	UPDATERC();
851	rc = CFGMR3InsertInteger(pRoot, "CSAMEnabled", 1);
852	UPDATERC();
853
854	/*
855	* PDM.
856	*/
857	PCFGMNODE pPdm;
858	rc = CFGMR3InsertNode(pRoot, "PDM", &pPdm);
859	UPDATERC();
860	PCFGMNODE pDevices = NULL;
861	rc = CFGMR3InsertNode(pPdm, "Devices", &pDevices);
862	UPDATERC();
863	rc = CFGMR3InsertInteger(pDevices, "LoadBuiltin", 1); /* boolean */
864	UPDATERC();
865	PCFGMNODE pDrivers = NULL;
866	rc = CFGMR3InsertNode(pPdm, "Drivers", &pDrivers);
867	UPDATERC();
868	rc = CFGMR3InsertInteger(pDrivers, "LoadBuiltin", 1); /* boolean */
869	UPDATERC();
870
871
872	/*
873	* Devices
874	*/
875	pDevices = NULL;
876	rc = CFGMR3InsertNode(pRoot, "Devices", &pDevices);
877	UPDATERC();
878	/* device */
879	PCFGMNODE pDev = NULL;
880	PCFGMNODE pInst = NULL;
881	PCFGMNODE pCfg = NULL;
882	#if 0
883	PCFGMNODE pLunL0 = NULL;
884	PCFGMNODE pLunL1 = NULL;
885	#endif
886
887	/*
888	* PC Arch.
889	*/
890	rc = CFGMR3InsertNode(pDevices, "pcarch", &pDev);
891	UPDATERC();
892	rc = CFGMR3InsertNode(pDev, "0", &pInst);
893	UPDATERC();
894	rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */
895	UPDATERC();
896	rc = CFGMR3InsertNode(pInst, "Config", &pCfg);
897	UPDATERC();
898
899	/*
900	* PC Bios.
901	*/
902	rc = CFGMR3InsertNode(pDevices, "pcbios", &pDev);
903	UPDATERC();
904	rc = CFGMR3InsertNode(pDev, "0", &pInst);
905	UPDATERC();
906	rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */
907	UPDATERC();
908	rc = CFGMR3InsertNode(pInst, "Config", &pCfg);
909	UPDATERC();
910	rc = CFGMR3InsertInteger(pCfg, "RamSize", 128U * _1M);
911	UPDATERC();
912	rc = CFGMR3InsertInteger(pCfg, "RamHoleSize", 512U * _1M);
913	UPDATERC();
914	rc = CFGMR3InsertString(pCfg, "BootDevice0", "IDE");
915	UPDATERC();
916	rc = CFGMR3InsertString(pCfg, "BootDevice1", "NONE");
917	UPDATERC();
918	rc = CFGMR3InsertString(pCfg, "BootDevice2", "NONE");
919	UPDATERC();
920	rc = CFGMR3InsertString(pCfg, "BootDevice3", "NONE");
921	UPDATERC();
922	rc = CFGMR3InsertString(pCfg, "HardDiskDevice", "piix3ide");
923	UPDATERC();
924	rc = CFGMR3InsertString(pCfg, "FloppyDevice", "");
925	UPDATERC();
926	RTUUID Uuid;
927	RTUuidClear(&Uuid);
928	rc = CFGMR3InsertBytes(pCfg, "UUID", &Uuid, sizeof(Uuid));
929	UPDATERC();
930
931	/*
932	* PCI bus.
933	*/
934	rc = CFGMR3InsertNode(pDevices, "pci", &pDev); /* piix3 */
935	UPDATERC();
936	rc = CFGMR3InsertNode(pDev, "0", &pInst);
937	UPDATERC();
938	rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */
939	UPDATERC();
940	rc = CFGMR3InsertNode(pInst, "Config", &pCfg);
941	UPDATERC();
942
943	/*
944	* PS/2 keyboard & mouse
945	*/
946	rc = CFGMR3InsertNode(pDevices, "pckbd", &pDev);
947	UPDATERC();
948	rc = CFGMR3InsertNode(pDev, "0", &pInst);
949	UPDATERC();
950	rc = CFGMR3InsertNode(pInst, "Config", &pCfg);
951	UPDATERC();
952	#if 0
953	rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0);
954	UPDATERC();
955	rc = CFGMR3InsertString(pLunL0, "Driver", "KeyboardQueue");
956	UPDATERC();
957	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg);
958	UPDATERC();
959	rc = CFGMR3InsertInteger(pCfg, "QueueSize", 64);
960	UPDATERC();
961	rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL1);
962	UPDATERC();
963	rc = CFGMR3InsertString(pLunL1, "Driver", "MainKeyboard");
964	UPDATERC();
965	rc = CFGMR3InsertNode(pLunL1, "Config", &pCfg);
966	UPDATERC();
967	#endif
968	#if 0
969	rc = CFGMR3InsertNode(pInst, "LUN#1", &pLunL0);
970	UPDATERC();
971	rc = CFGMR3InsertString(pLunL0, "Driver", "MouseQueue");
972	UPDATERC();
973	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg);
974	UPDATERC();
975	rc = CFGMR3InsertInteger(pCfg, "QueueSize", 128);
976	UPDATERC();
977	rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL1);
978	UPDATERC();
979	rc = CFGMR3InsertString(pLunL1, "Driver", "MainMouse");
980	UPDATERC();
981	rc = CFGMR3InsertNode(pLunL1, "Config", &pCfg);
982	UPDATERC();
983	#endif
984
985	/*
986	* i8254 Programmable Interval Timer And Dummy Speaker
987	*/
988	rc = CFGMR3InsertNode(pDevices, "i8254", &pDev);
989	UPDATERC();
990	rc = CFGMR3InsertNode(pDev, "0", &pInst);
991	UPDATERC();
992	#ifdef DEBUG
993	rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */
994	UPDATERC();
995	#endif
996	rc = CFGMR3InsertNode(pInst, "Config", &pCfg);
997	UPDATERC();
998
999	/*
1000	* i8259 Programmable Interrupt Controller.
1001	*/
1002	rc = CFGMR3InsertNode(pDevices, "i8259", &pDev);
1003	UPDATERC();
1004	rc = CFGMR3InsertNode(pDev, "0", &pInst);
1005	UPDATERC();
1006	rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */
1007	UPDATERC();
1008	rc = CFGMR3InsertNode(pInst, "Config", &pCfg);
1009	UPDATERC();
1010
1011	/*
1012	* RTC MC146818.
1013	*/
1014	rc = CFGMR3InsertNode(pDevices, "mc146818", &pDev);
1015	UPDATERC();
1016	rc = CFGMR3InsertNode(pDev, "0", &pInst);
1017	UPDATERC();
1018	rc = CFGMR3InsertNode(pInst, "Config", &pCfg);
1019	UPDATERC();
1020
1021	/*
1022	* VGA.
1023	*/
1024	rc = CFGMR3InsertNode(pDevices, "vga", &pDev);
1025	UPDATERC();
1026	rc = CFGMR3InsertNode(pDev, "0", &pInst);
1027	UPDATERC();
1028	rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */
1029	UPDATERC();
1030	rc = CFGMR3InsertNode(pInst, "Config", &pCfg);
1031	UPDATERC();
1032	rc = CFGMR3InsertInteger(pCfg, "VRamSize", 4 * _1M);
1033	UPDATERC();
1034
1035	/* Bios logo. */
1036	rc = CFGMR3InsertInteger(pCfg, "FadeIn", 1);
1037	UPDATERC();
1038	rc = CFGMR3InsertInteger(pCfg, "FadeOut", 1);
1039	UPDATERC();
1040	rc = CFGMR3InsertInteger(pCfg, "LogoTime", 0);
1041	UPDATERC();
1042	rc = CFGMR3InsertString(pCfg, "LogoFile", "");
1043	UPDATERC();
1044
1045	#if 0
1046	rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0);
1047	UPDATERC();
1048	rc = CFGMR3InsertString(pLunL0, "Driver", "MainDisplay");
1049	UPDATERC();
1050	#endif
1051
1052	/*
1053	* IDE controller.
1054	*/
1055	rc = CFGMR3InsertNode(pDevices, "piix3ide", &pDev); /* piix3 */
1056	UPDATERC();
1057	rc = CFGMR3InsertNode(pDev, "0", &pInst);
1058	UPDATERC();
1059	rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */
1060	UPDATERC();
1061	rc = CFGMR3InsertNode(pInst, "Config", &pCfg);
1062	UPDATERC();
1063
1064
1065
1066	/*
1067	* ...
1068	*/
1069
1070	#undef UPDATERC
1071	return rcAll;
1072	}
1073
1074
1075
1076
1077	/**
1078	* Resolves a path reference to a child node.
1079	*
1080	* @returns VBox status code.
1081	* @param pNode Which node to search for pszName in.
1082	* @param pszPath Path to the child node.
1083	* @param ppChild Where to store the pointer to the child node.
1084	*/
1085	static int cfgmR3ResolveNode(PCFGMNODE pNode, const char pszPath, PCFGMNODE ppChild)
1086	{
1087	if (!pNode)
1088	return VERR_CFGM_NO_PARENT;
1089	PCFGMNODE pChild = NULL;
1090	for (;;)
1091	{
1092	/* skip leading slashes. */
1093	while (*pszPath == '/')
1094	pszPath++;
1095
1096	/* End of path? */
1097	if (!*pszPath)
1098	{
1099	if (!pChild)
1100	return VERR_CFGM_INVALID_CHILD_PATH;
1101	*ppChild = pChild;
1102	return VINF_SUCCESS;
1103	}
1104
1105	/* find end of component. */
1106	const char *pszNext = strchr(pszPath, '/');
1107	if (!pszNext)
1108	pszNext = strchr(pszPath, '\0');
1109	RTUINT cchName = pszNext - pszPath;
1110
1111	/* search child list. */
1112	pChild = pNode->pFirstChild;
1113	for ( ; pChild; pChild = pChild->pNext)
1114	if (pChild->cchName == cchName)
1115	{
1116	int iDiff = memcmp(pszPath, pChild->szName, cchName);
1117	if (iDiff <= 0)
1118	{
1119	if (iDiff != 0)
1120	pChild = NULL;
1121	break;
1122	}
1123	}
1124	if (!pChild)
1125	return VERR_CFGM_CHILD_NOT_FOUND;
1126
1127	/* next iteration */
1128	pNode = pChild;
1129	pszPath = pszNext;
1130	}
1131
1132	/* won't get here */
1133	}
1134
1135
1136	/**
1137	* Resolves a path reference to a child node.
1138	*
1139	* @returns VBox status code.
1140	* @param pNode Which node to search for pszName in.
1141	* @param pszName Name of a byte string value.
1142	* @param ppLeaf Where to store the pointer to the leaf node.
1143	*/
1144	static int cfgmR3ResolveLeaf(PCFGMNODE pNode, const char pszName, PCFGMLEAF ppLeaf)
1145	{
1146	if (!pNode)
1147	return VERR_CFGM_NO_PARENT;
1148
1149	size_t cchName = strlen(pszName);
1150	PCFGMLEAF pLeaf = pNode->pFirstLeaf;
1151	while (pLeaf)
1152	{
1153	if (cchName == pLeaf->cchName)
1154	{
1155	int iDiff = memcmp(pszName, pLeaf->szName, cchName);
1156	if (iDiff <= 0)
1157	{
1158	if (iDiff != 0)
1159	break;
1160	*ppLeaf = pLeaf;
1161	return VINF_SUCCESS;
1162	}
1163	}
1164
1165	/* next */
1166	pLeaf = pLeaf->pNext;
1167	}
1168	return VERR_CFGM_VALUE_NOT_FOUND;
1169	}
1170
1171
1172
1173	/**
1174	* Creates a CFGM tree.
1175	*
1176	* This is intended for creating device/driver configs can be
1177	* passed around and later attached to the main tree in the
1178	* correct location.
1179	*
1180	* @returns Pointer to the root node.
1181	* @param pVM The VM handle.
1182	*/
1183	VMMR3DECL(PCFGMNODE) CFGMR3CreateTree(PVM pVM)
1184	{
1185	PCFGMNODE pNew = (PCFGMNODE)MMR3HeapAlloc(pVM, MM_TAG_CFGM, sizeof(*pNew));
1186	if (pNew)
1187	{
1188	pNew->pPrev = NULL;
1189	pNew->pNext = NULL;
1190	pNew->pParent = NULL;
1191	pNew->pFirstChild = NULL;
1192	pNew->pFirstLeaf = NULL;
1193	pNew->pVM = pVM;
1194	pNew->fRestrictedRoot = false;
1195	pNew->cchName = 0;
1196	pNew->szName[0] = 0;
1197	}
1198	return pNew;
1199	}
1200
1201
1202	/**
1203	* Insert subtree.
1204	*
1205	* This function inserts (no duplication) a tree created by CFGMR3CreateTree()
1206	* into the main tree.
1207	*
1208	* The root node of the inserted subtree will need to be reallocated, which
1209	* effectually means that the passed in pSubTree handle becomes invalid
1210	* upon successful return. Use the value returned in ppChild instead
1211	* of pSubTree.
1212	*
1213	* @returns VBox status code.
1214	* @returns VERR_CFGM_NODE_EXISTS if the final child node name component exists.
1215	* @param pNode Parent node.
1216	* @param pszName Name or path of the new child node.
1217	* @param pSubTree The subtree to insert. Must be returned by CFGMR3CreateTree().
1218	* @param ppChild Where to store the address of the new child node. (optional)
1219	*/
1220	VMMR3DECL(int) CFGMR3InsertSubTree(PCFGMNODE pNode, const char pszName, PCFGMNODE pSubTree, PCFGMNODE ppChild)
1221	{
1222	/*
1223	* Validate input.
1224	*/
1225	AssertPtrReturn(pSubTree, VERR_INVALID_POINTER);
1226	AssertReturn(!pSubTree->pParent, VERR_INVALID_PARAMETER);
1227	AssertReturn(pSubTree->pVM, VERR_INVALID_PARAMETER);
1228	AssertReturn(pSubTree->pParent != pSubTree->pVM->cfgm.s.pRoot, VERR_INVALID_PARAMETER);
1229	Assert(!pSubTree->pNext);
1230	Assert(!pSubTree->pPrev);
1231
1232	/*
1233	* Use CFGMR3InsertNode to create a new node and then
1234	* re-attach the children and leafs of the subtree to it.
1235	*/
1236	PCFGMNODE pNewChild;
1237	int rc = CFGMR3InsertNode(pNode, pszName, &pNewChild);
1238	if (RT_SUCCESS(rc))
1239	{
1240	Assert(!pNewChild->pFirstChild);
1241	pNewChild->pFirstChild = pSubTree->pFirstChild;
1242	Assert(!pNewChild->pFirstLeaf);
1243	pNewChild->pFirstLeaf = pSubTree->pFirstLeaf;
1244	if (ppChild)
1245	*ppChild = pNewChild;
1246
1247	/* free the old subtree root */
1248	pSubTree->pVM = NULL;
1249	pSubTree->pFirstLeaf = NULL;
1250	pSubTree->pFirstChild = NULL;
1251	MMR3HeapFree(pSubTree);
1252	}
1253	return rc;
1254	}
1255
1256
1257	/**
1258	* Compares two names.
1259	*
1260	* @returns Similar to memcpy.
1261	* @param pszName1 The first name.
1262	* @param cchName1 The length of the first name.
1263	* @param pszName2 The second name.
1264	* @param cchName2 The length of the second name.
1265	*/
1266	DECLINLINE(int) cfgmR3CompareNames(const char pszName1, size_t cchName1, const char pszName2, size_t cchName2)
1267	{
1268	int iDiff;
1269	if (cchName1 <= cchName2)
1270	{
1271	iDiff = memcmp(pszName1, pszName2, cchName1);
1272	if (!iDiff && cchName1 < cchName2)
1273	iDiff = -1;
1274	}
1275	else
1276	{
1277	iDiff = memcmp(pszName1, pszName2, cchName2);
1278	if (!iDiff)
1279	iDiff = 1;
1280	}
1281	return iDiff;
1282	}
1283
1284
1285	/**
1286	* Insert a node.
1287	*
1288	* @returns VBox status code.
1289	* @returns VERR_CFGM_NODE_EXISTS if the final child node name component exists.
1290	* @param pNode Parent node.
1291	* @param pszName Name or path of the new child node.
1292	* @param ppChild Where to store the address of the new child node. (optional)
1293	*/
1294	VMMR3DECL(int) CFGMR3InsertNode(PCFGMNODE pNode, const char pszName, PCFGMNODE ppChild)
1295	{
1296	int rc;
1297	if (pNode)
1298	{
1299	/*
1300	* If given a path we have to deal with it component by compontent.
1301	*/
1302	while (*pszName == '/')
1303	pszName++;
1304	if (strchr(pszName, '/'))
1305	{
1306	char *pszDup = RTStrDup(pszName);
1307	if (pszDup)
1308	{
1309	char *psz = pszDup;
1310	for (;;)
1311	{
1312	/* Terminate at '/' and find the next component. */
1313	char *pszNext = strchr(psz, '/');
1314	if (pszNext)
1315	{
1316	*pszNext++ = '\0';
1317	while (*pszNext == '/')
1318	pszNext++;
1319	if (*pszNext == '\0')
1320	pszNext = NULL;
1321	}
1322
1323	/* does it exist? */
1324	PCFGMNODE pChild = CFGMR3GetChild(pNode, psz);
1325	if (!pChild)
1326	{
1327	/* no, insert it */
1328	rc = CFGMR3InsertNode(pNode, psz, &pChild);
1329	if (RT_FAILURE(rc))
1330	break;
1331	if (!pszNext)
1332	{
1333	if (ppChild)
1334	*ppChild = pChild;
1335	break;
1336	}
1337
1338	}
1339	/* if last component fail */
1340	else if (!pszNext)
1341	{
1342	rc = VERR_CFGM_NODE_EXISTS;
1343	break;
1344	}
1345
1346	/* next */
1347	pNode = pChild;
1348	psz = pszNext;
1349	}
1350	RTStrFree(pszDup);
1351	}
1352	else
1353	rc = VERR_NO_TMP_MEMORY;
1354	}
1355	/*
1356	* Not multicomponent, just make sure it's a non-zero name.
1357	*/
1358	else if (*pszName)
1359	{
1360	/*
1361	* Check if already exists and find last node in chain.
1362	*/
1363	size_t cchName = strlen(pszName);
1364	PCFGMNODE pPrev = NULL;
1365	PCFGMNODE pNext = pNode->pFirstChild;
1366	if (pNext)
1367	{
1368	for ( ; pNext; pPrev = pNext, pNext = pNext->pNext)
1369	{
1370	int iDiff = cfgmR3CompareNames(pszName, cchName, pNext->szName, pNext->cchName);
1371	if (iDiff <= 0)
1372	{
1373	if (!iDiff)
1374	return VERR_CFGM_NODE_EXISTS;
1375	break;
1376	}
1377	}
1378	}
1379
1380	/*
1381	* Allocate and init node.
1382	*/
1383	PCFGMNODE pNew = (PCFGMNODE)MMR3HeapAlloc(pNode->pVM, MM_TAG_CFGM, sizeof(*pNew) + cchName);
1384	if (pNew)
1385	{
1386	pNew->pParent = pNode;
1387	pNew->pFirstChild = NULL;
1388	pNew->pFirstLeaf = NULL;
1389	pNew->pVM = pNode->pVM;
1390	pNew->fRestrictedRoot = false;
1391	pNew->cchName = cchName;
1392	memcpy(pNew->szName, pszName, cchName + 1);
1393
1394	/*
1395	* Insert into child list.
1396	*/
1397	pNew->pPrev = pPrev;
1398	if (pPrev)
1399	pPrev->pNext = pNew;
1400	else
1401	pNode->pFirstChild = pNew;
1402	pNew->pNext = pNext;
1403	if (pNext)
1404	pNext->pPrev = pNew;
1405
1406	if (ppChild)
1407	*ppChild = pNew;
1408	rc = VINF_SUCCESS;
1409	}
1410	else
1411	rc = VERR_NO_MEMORY;
1412	}
1413	else
1414	{
1415	rc = VERR_CFGM_INVALID_NODE_PATH;
1416	AssertMsgFailed(("Invalid path %s\n", pszName));
1417	}
1418	}
1419	else
1420	{
1421	rc = VERR_CFGM_NO_PARENT;
1422	AssertMsgFailed(("No parent! path %s\n", pszName));
1423	}
1424
1425	return rc;
1426	}
1427
1428
1429	/**
1430	* Insert a node, format string name.
1431	*
1432	* @returns VBox status code.
1433	* @param pNode Parent node.
1434	* @param ppChild Where to store the address of the new child node. (optional)
1435	* @param pszNameFormat Name of or path the new child node.
1436	* @param ... Name format arguments.
1437	*/
1438	VMMR3DECL(int) CFGMR3InsertNodeF(PCFGMNODE pNode, PCFGMNODE ppChild, const char pszNameFormat, ...)
1439	{
1440	va_list Args;
1441	va_start(Args, pszNameFormat);
1442	int rc = CFGMR3InsertNodeFV(pNode, ppChild, pszNameFormat, Args);
1443	va_end(Args);
1444	return rc;
1445	}
1446
1447
1448	/**
1449	* Insert a node, format string name.
1450	*
1451	* @returns VBox status code.
1452	* @param pNode Parent node.
1453	* @param ppChild Where to store the address of the new child node. (optional)
1454	* @param pszNameFormat Name or path of the new child node.
1455	* @param Args Name format arguments.
1456	*/
1457	VMMR3DECL(int) CFGMR3InsertNodeFV(PCFGMNODE pNode, PCFGMNODE ppChild, const char pszNameFormat, va_list Args)
1458	{
1459	int rc;
1460	char *pszName;
1461	RTStrAPrintfV(&pszName, pszNameFormat, Args);
1462	if (pszName)
1463	{
1464	rc = CFGMR3InsertNode(pNode, pszName, ppChild);
1465	RTStrFree(pszName);
1466	}
1467	else
1468	rc = VERR_NO_MEMORY;
1469	return rc;
1470	}
1471
1472
1473	/**
1474	* Marks the node as the root of a restricted subtree, i.e. the end of
1475	* a CFGMR3GetParent() journey.
1476	*
1477	* @param pNode The node to mark.
1478	*/
1479	VMMR3DECL(void) CFGMR3SetRestrictedRoot(PCFGMNODE pNode)
1480	{
1481	if (pNode)
1482	pNode->fRestrictedRoot = true;
1483	}
1484
1485
1486	/**
1487	* Insert a node.
1488	*
1489	* @returns VBox status code.
1490	* @param pNode Parent node.
1491	* @param pszName Name of the new child node.
1492	* @param ppLeaf Where to store the new leaf.
1493	* The caller must fill in the enmType and Value fields!
1494	*/
1495	static int cfgmR3InsertLeaf(PCFGMNODE pNode, const char pszName, PCFGMLEAF ppLeaf)
1496	{
1497	int rc;
1498	if (*pszName)
1499	{
1500	if (pNode)
1501	{
1502	/*
1503	* Check if already exists and find last node in chain.
1504	*/
1505	size_t cchName = strlen(pszName);
1506	PCFGMLEAF pPrev = NULL;
1507	PCFGMLEAF pNext = pNode->pFirstLeaf;
1508	if (pNext)
1509	{
1510	for ( ; pNext; pPrev = pNext, pNext = pNext->pNext)
1511	{
1512	int iDiff = cfgmR3CompareNames(pszName, cchName, pNext->szName, pNext->cchName);
1513	if (iDiff <= 0)
1514	{
1515	if (!iDiff)
1516	return VERR_CFGM_LEAF_EXISTS;
1517	break;
1518	}
1519	}
1520	}
1521
1522	/*
1523	* Allocate and init node.
1524	*/
1525	PCFGMLEAF pNew = (PCFGMLEAF)MMR3HeapAlloc(pNode->pVM, MM_TAG_CFGM, sizeof(*pNew) + cchName);
1526	if (pNew)
1527	{
1528	pNew->cchName = cchName;
1529	memcpy(pNew->szName, pszName, cchName + 1);
1530
1531	/*
1532	* Insert into child list.
1533	*/
1534	pNew->pPrev = pPrev;
1535	if (pPrev)
1536	pPrev->pNext = pNew;
1537	else
1538	pNode->pFirstLeaf = pNew;
1539	pNew->pNext = pNext;
1540	if (pNext)
1541	pNext->pPrev = pNew;
1542
1543	*ppLeaf = pNew;
1544	rc = VINF_SUCCESS;
1545	}
1546	else
1547	rc = VERR_NO_MEMORY;
1548	}
1549	else
1550	rc = VERR_CFGM_NO_PARENT;
1551	}
1552	else
1553	rc = VERR_CFGM_INVALID_CHILD_PATH;
1554	return rc;
1555	}
1556
1557
1558	/**
1559	* Remove a node.
1560	*
1561	* @param pNode Parent node.
1562	*/
1563	VMMR3DECL(void) CFGMR3RemoveNode(PCFGMNODE pNode)
1564	{
1565	if (pNode)
1566	{
1567	/*
1568	* Free children.
1569	*/
1570	while (pNode->pFirstChild)
1571	CFGMR3RemoveNode(pNode->pFirstChild);
1572
1573	/*
1574	* Free leafs.
1575	*/
1576	while (pNode->pFirstLeaf)
1577	cfgmR3RemoveLeaf(pNode, pNode->pFirstLeaf);
1578
1579	/*
1580	* Unlink ourselves.
1581	*/
1582	if (pNode->pPrev)
1583	pNode->pPrev->pNext = pNode->pNext;
1584	else
1585	{
1586	if (pNode->pParent)
1587	pNode->pParent->pFirstChild = pNode->pNext;
1588	else if (pNode == pNode->pVM->cfgm.s.pRoot) /* might be a different tree */
1589	pNode->pVM->cfgm.s.pRoot = NULL;
1590	}
1591	if (pNode->pNext)
1592	pNode->pNext->pPrev = pNode->pPrev;
1593
1594	/*
1595	* Free ourselves. (bit of paranoia first)
1596	*/
1597	pNode->pVM = NULL;
1598	pNode->pNext = NULL;
1599	pNode->pPrev = NULL;
1600	pNode->pParent = NULL;
1601	MMR3HeapFree(pNode);
1602	}
1603	}
1604
1605
1606	/**
1607	* Removes a leaf.
1608	*
1609	* @param pNode Parent node.
1610	* @param pLeaf Leaf to remove.
1611	*/
1612	static void cfgmR3RemoveLeaf(PCFGMNODE pNode, PCFGMLEAF pLeaf)
1613	{
1614	if (pNode && pLeaf)
1615	{
1616	/*
1617	* Unlink.
1618	*/
1619	if (pLeaf->pPrev)
1620	pLeaf->pPrev->pNext = pLeaf->pNext;
1621	else
1622	pNode->pFirstLeaf = pLeaf->pNext;
1623	if (pLeaf->pNext)
1624	pLeaf->pNext->pPrev = pLeaf->pPrev;
1625
1626	/*
1627	* Free value and node.
1628	*/
1629	cfgmR3FreeValue(pLeaf);
1630	pLeaf->pNext = NULL;
1631	pLeaf->pPrev = NULL;
1632	MMR3HeapFree(pLeaf);
1633	}
1634	}
1635
1636
1637	/**
1638	* Frees whatever resources the leaf value is owning.
1639	*
1640	* Use this before assigning a new value to a leaf.
1641	* The caller must either free the leaf or assign a new value to it.
1642	*
1643	* @param pLeaf Pointer to the leaf which value should be free.
1644	*/
1645	static void cfgmR3FreeValue(PCFGMLEAF pLeaf)
1646	{
1647	if (pLeaf)
1648	{
1649	switch (pLeaf->enmType)
1650	{
1651	case CFGMVALUETYPE_BYTES:
1652	MMR3HeapFree(pLeaf->Value.Bytes.pau8);
1653	pLeaf->Value.Bytes.pau8 = NULL;
1654	pLeaf->Value.Bytes.cb = 0;
1655	break;
1656
1657	case CFGMVALUETYPE_STRING:
1658	MMR3HeapFree(pLeaf->Value.String.psz);
1659	pLeaf->Value.String.psz = NULL;
1660	pLeaf->Value.String.cb = 0;
1661	break;
1662
1663	case CFGMVALUETYPE_INTEGER:
1664	break;
1665	}
1666	pLeaf->enmType = (CFGMVALUETYPE)0;
1667	}
1668	}
1669
1670
1671	/**
1672	* Inserts a new integer value.
1673	*
1674	* @returns VBox status code.
1675	* @param pNode Parent node.
1676	* @param pszName Value name.
1677	* @param u64Integer The value.
1678	*/
1679	VMMR3DECL(int) CFGMR3InsertInteger(PCFGMNODE pNode, const char *pszName, uint64_t u64Integer)
1680	{
1681	PCFGMLEAF pLeaf;
1682	int rc = cfgmR3InsertLeaf(pNode, pszName, &pLeaf);
1683	if (RT_SUCCESS(rc))
1684	{
1685	pLeaf->enmType = CFGMVALUETYPE_INTEGER;
1686	pLeaf->Value.Integer.u64 = u64Integer;
1687	}
1688	return rc;
1689	}
1690
1691
1692	/**
1693	* Inserts a new string value.
1694	*
1695	* @returns VBox status code.
1696	* @param pNode Parent node.
1697	* @param pszName Value name.
1698	* @param pszString The value.
1699	*/
1700	VMMR3DECL(int) CFGMR3InsertString(PCFGMNODE pNode, const char pszName, const char pszString)
1701	{
1702	int rc;
1703	if (pNode)
1704	{
1705	/*
1706	* Allocate string object first.
1707	*/
1708	size_t cbString = strlen(pszString) + 1;
1709	char pszStringCopy = (char )MMR3HeapAlloc(pNode->pVM, MM_TAG_CFGM_STRING, cbString);
1710	if (pszStringCopy)
1711	{
1712	memcpy(pszStringCopy, pszString, cbString);
1713
1714	/*
1715	* Create value leaf and set it to string type.
1716	*/
1717	PCFGMLEAF pLeaf;
1718	rc = cfgmR3InsertLeaf(pNode, pszName, &pLeaf);
1719	if (RT_SUCCESS(rc))
1720	{
1721	pLeaf->enmType = CFGMVALUETYPE_STRING;
1722	pLeaf->Value.String.psz = pszStringCopy;
1723	pLeaf->Value.String.cb = cbString;
1724	}
1725	else
1726	MMR3HeapFree(pszStringCopy);
1727	}
1728	else
1729	rc = VERR_NO_MEMORY;
1730	}
1731	else
1732	rc = VERR_CFGM_NO_PARENT;
1733
1734	return rc;
1735	}
1736
1737
1738	/**
1739	* Same as CFGMR3InsertString except the string value given in RTStrPrintfV
1740	* fashion.
1741	*
1742	* @returns VBox status code.
1743	* @param pNode Parent node.
1744	* @param pszName Value name.
1745	* @param pszFormat The value given as a format string.
1746	* @param va Argument to pszFormat.
1747	*/
1748	VMMR3DECL(int) CFGMR3InsertStringFV(PCFGMNODE pNode, const char pszName, const char pszFormat, va_list va)
1749	{
1750	int rc;
1751	if (pNode)
1752	{
1753	/*
1754	* Allocate string object first.
1755	*/
1756	char *pszString = MMR3HeapAPrintfVU(pNode->pVM->pUVM, MM_TAG_CFGM_STRING, pszFormat, va);
1757	if (pszString)
1758	{
1759	/*
1760	* Create value leaf and set it to string type.
1761	*/
1762	PCFGMLEAF pLeaf;
1763	rc = cfgmR3InsertLeaf(pNode, pszName, &pLeaf);
1764	if (RT_SUCCESS(rc))
1765	{
1766	pLeaf->enmType = CFGMVALUETYPE_STRING;
1767	pLeaf->Value.String.psz = pszString;
1768	pLeaf->Value.String.cb = strlen(pszString) + 1;
1769	}
1770	else
1771	MMR3HeapFree(pszString);
1772	}
1773	else
1774	rc = VERR_NO_MEMORY;
1775	}
1776	else
1777	rc = VERR_CFGM_NO_PARENT;
1778
1779	return rc;
1780	}
1781
1782
1783	/**
1784	* Same as CFGMR3InsertString except the string value given in RTStrPrintf
1785	* fashion.
1786	*
1787	* @returns VBox status code.
1788	* @param pNode Parent node.
1789	* @param pszName Value name.
1790	* @param pszFormat The value given as a format string.
1791	* @param ... Argument to pszFormat.
1792	*/
1793	VMMR3DECL(int) CFGMR3InsertStringF(PCFGMNODE pNode, const char pszName, const char pszFormat, ...)
1794	{
1795	va_list va;
1796	va_start(va, pszFormat);
1797	int rc = CFGMR3InsertStringFV(pNode, pszName, pszFormat, va);
1798	va_end(va);
1799	return rc;
1800	}
1801
1802
1803	/**
1804	* Same as CFGMR3InsertString except the string value given as a UTF-16 string.
1805	*
1806	* @returns VBox status code.
1807	* @param pNode Parent node.
1808	* @param pszName Value name.
1809	* @param pwszValue The string value (UTF-16).
1810	*/
1811	VMMR3DECL(int) CFGMR3InsertStringW(PCFGMNODE pNode, const char *pszName, PCRTUTF16 pwszValue)
1812	{
1813	char *pszValue;
1814	int rc = RTUtf16ToUtf8(pwszValue, &pszValue);
1815	if (RT_SUCCESS(rc))
1816	{
1817	rc = CFGMR3InsertString(pNode, pszName, pszValue);
1818	RTStrFree(pszValue);
1819	}
1820	return rc;
1821	}
1822
1823
1824	/**
1825	* Inserts a new integer value.
1826	*
1827	* @returns VBox status code.
1828	* @param pNode Parent node.
1829	* @param pszName Value name.
1830	* @param pvBytes The value.
1831	* @param cbBytes The value size.
1832	*/
1833	VMMR3DECL(int) CFGMR3InsertBytes(PCFGMNODE pNode, const char pszName, const void pvBytes, size_t cbBytes)
1834	{
1835	int rc;
1836	if (pNode)
1837	{
1838	if (cbBytes == (RTUINT)cbBytes)
1839	{
1840	/*
1841	* Allocate string object first.
1842	*/
1843	void *pvCopy = MMR3HeapAlloc(pNode->pVM, MM_TAG_CFGM_STRING, cbBytes);
1844	if (pvCopy \|\| !cbBytes)
1845	{
1846	memcpy(pvCopy, pvBytes, cbBytes);
1847
1848	/*
1849	* Create value leaf and set it to string type.
1850	*/
1851	PCFGMLEAF pLeaf;
1852	rc = cfgmR3InsertLeaf(pNode, pszName, &pLeaf);
1853	if (RT_SUCCESS(rc))
1854	{
1855	pLeaf->enmType = CFGMVALUETYPE_BYTES;
1856	pLeaf->Value.Bytes.cb = cbBytes;
1857	pLeaf->Value.Bytes.pau8 = (uint8_t *)pvCopy;
1858	}
1859	}
1860	else
1861	rc = VERR_NO_MEMORY;
1862	}
1863	else
1864	rc = VERR_OUT_OF_RANGE;
1865	}
1866	else
1867	rc = VERR_CFGM_NO_PARENT;
1868
1869	return rc;
1870	}
1871
1872
1873	/**
1874	* Remove a value.
1875	*
1876	* @returns VBox status code.
1877	* @param pNode Parent node.
1878	* @param pszName Name of the new child node.
1879	*/
1880	VMMR3DECL(int) CFGMR3RemoveValue(PCFGMNODE pNode, const char *pszName)
1881	{
1882	PCFGMLEAF pLeaf;
1883	int rc = cfgmR3ResolveLeaf(pNode, pszName, &pLeaf);
1884	if (RT_SUCCESS(rc))
1885	cfgmR3RemoveLeaf(pNode, pLeaf);
1886	return rc;
1887	}
1888
1889
1890
1891	/*
1892	* -+- helper apis -+-
1893	*/
1894
1895
1896	/**
1897	* Query unsigned 64-bit integer value.
1898	*
1899	* @returns VBox status code.
1900	* @param pNode Which node to search for pszName in.
1901	* @param pszName Name of an integer value.
1902	* @param pu64 Where to store the integer value.
1903	*/
1904	VMMR3DECL(int) CFGMR3QueryU64(PCFGMNODE pNode, const char pszName, uint64_t pu64)
1905	{
1906	return CFGMR3QueryInteger(pNode, pszName, pu64);
1907	}
1908
1909
1910	/**
1911	* Query unsigned 64-bit integer value with default.
1912	*
1913	* @returns VBox status code.
1914	* @param pNode Which node to search for pszName in.
1915	* @param pszName Name of an integer value.
1916	* @param pu64 Where to store the integer value. Set to default on failure.
1917	* @param u64Def The default value.
1918	*/
1919	VMMR3DECL(int) CFGMR3QueryU64Def(PCFGMNODE pNode, const char pszName, uint64_t pu64, uint64_t u64Def)
1920	{
1921	return CFGMR3QueryIntegerDef(pNode, pszName, pu64, u64Def);
1922	}
1923
1924
1925	/**
1926	* Query signed 64-bit integer value.
1927	*
1928	* @returns VBox status code.
1929	* @param pNode Which node to search for pszName in.
1930	* @param pszName Name of an integer value.
1931	* @param pi64 Where to store the value.
1932	*/
1933	VMMR3DECL(int) CFGMR3QueryS64(PCFGMNODE pNode, const char pszName, int64_t pi64)
1934	{
1935	uint64_t u64;
1936	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
1937	if (RT_SUCCESS(rc))
1938	*pi64 = (int64_t)u64;
1939	return rc;
1940	}
1941
1942
1943	/**
1944	* Query signed 64-bit integer value with default.
1945	*
1946	* @returns VBox status code.
1947	* @param pNode Which node to search for pszName in.
1948	* @param pszName Name of an integer value.
1949	* @param pi64 Where to store the value. Set to default on failure.
1950	* @param i64Def The default value.
1951	*/
1952	VMMR3DECL(int) CFGMR3QueryS64Def(PCFGMNODE pNode, const char pszName, int64_t pi64, int64_t i64Def)
1953	{
1954	uint64_t u64;
1955	int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, i64Def);
1956	if (RT_SUCCESS(rc))
1957	*pi64 = (int64_t)u64;
1958	return rc;
1959	}
1960
1961
1962	/**
1963	* Query unsigned 32-bit integer value.
1964	*
1965	* @returns VBox status code.
1966	* @param pNode Which node to search for pszName in.
1967	* @param pszName Name of an integer value.
1968	* @param pu32 Where to store the value.
1969	*/
1970	VMMR3DECL(int) CFGMR3QueryU32(PCFGMNODE pNode, const char pszName, uint32_t pu32)
1971	{
1972	uint64_t u64;
1973	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
1974	if (RT_SUCCESS(rc))
1975	{
1976	if (!(u64 & UINT64_C(0xffffffff00000000)))
1977	*pu32 = (uint32_t)u64;
1978	else
1979	rc = VERR_CFGM_INTEGER_TOO_BIG;
1980	}
1981	return rc;
1982	}
1983
1984
1985	/**
1986	* Query unsigned 32-bit integer value with default.
1987	*
1988	* @returns VBox status code.
1989	* @param pNode Which node to search for pszName in.
1990	* @param pszName Name of an integer value.
1991	* @param pu32 Where to store the value. Set to default on failure.
1992	* @param u32Def The default value.
1993	*/
1994	VMMR3DECL(int) CFGMR3QueryU32Def(PCFGMNODE pNode, const char pszName, uint32_t pu32, uint32_t u32Def)
1995	{
1996	uint64_t u64;
1997	int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, u32Def);
1998	if (RT_SUCCESS(rc))
1999	{
2000	if (!(u64 & UINT64_C(0xffffffff00000000)))
2001	*pu32 = (uint32_t)u64;
2002	else
2003	rc = VERR_CFGM_INTEGER_TOO_BIG;
2004	}
2005	return rc;
2006	}
2007
2008
2009	/**
2010	* Query signed 32-bit integer value.
2011	*
2012	* @returns VBox status code.
2013	* @param pNode Which node to search for pszName in.
2014	* @param pszName Name of an integer value.
2015	* @param pi32 Where to store the value.
2016	*/
2017	VMMR3DECL(int) CFGMR3QueryS32(PCFGMNODE pNode, const char pszName, int32_t pi32)
2018	{
2019	uint64_t u64;
2020	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
2021	if (RT_SUCCESS(rc))
2022	{
2023	if ( !(u64 & UINT64_C(0xffffffff80000000))
2024	\|\| (u64 & UINT64_C(0xffffffff80000000)) == UINT64_C(0xffffffff80000000))
2025	*pi32 = (int32_t)u64;
2026	else
2027	rc = VERR_CFGM_INTEGER_TOO_BIG;
2028	}
2029	return rc;
2030	}
2031
2032
2033	/**
2034	* Query signed 32-bit integer value with default.
2035	*
2036	* @returns VBox status code.
2037	* @param pNode Which node to search for pszName in.
2038	* @param pszName Name of an integer value.
2039	* @param pi32 Where to store the value. Set to default on failure.
2040	* @param i32Def The default value.
2041	*/
2042	VMMR3DECL(int) CFGMR3QueryS32Def(PCFGMNODE pNode, const char pszName, int32_t pi32, int32_t i32Def)
2043	{
2044	uint64_t u64;
2045	int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, i32Def);
2046	if (RT_SUCCESS(rc))
2047	{
2048	if ( !(u64 & UINT64_C(0xffffffff80000000))
2049	\|\| (u64 & UINT64_C(0xffffffff80000000)) == UINT64_C(0xffffffff80000000))
2050	*pi32 = (int32_t)u64;
2051	else
2052	rc = VERR_CFGM_INTEGER_TOO_BIG;
2053	}
2054	return rc;
2055	}
2056
2057
2058	/**
2059	* Query unsigned 16-bit integer value.
2060	*
2061	* @returns VBox status code.
2062	* @param pNode Which node to search for pszName in.
2063	* @param pszName Name of an integer value.
2064	* @param pu16 Where to store the value.
2065	*/
2066	VMMR3DECL(int) CFGMR3QueryU16(PCFGMNODE pNode, const char pszName, uint16_t pu16)
2067	{
2068	uint64_t u64;
2069	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
2070	if (RT_SUCCESS(rc))
2071	{
2072	if (!(u64 & UINT64_C(0xffffffffffff0000)))
2073	*pu16 = (int16_t)u64;
2074	else
2075	rc = VERR_CFGM_INTEGER_TOO_BIG;
2076	}
2077	return rc;
2078	}
2079
2080
2081	/**
2082	* Query unsigned 16-bit integer value with default.
2083	*
2084	* @returns VBox status code.
2085	* @param pNode Which node to search for pszName in.
2086	* @param pszName Name of an integer value.
2087	* @param pu16 Where to store the value. Set to default on failure.
2088	* @param i16Def The default value.
2089	*/
2090	VMMR3DECL(int) CFGMR3QueryU16Def(PCFGMNODE pNode, const char pszName, uint16_t pu16, uint16_t u16Def)
2091	{
2092	uint64_t u64;
2093	int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, u16Def);
2094	if (RT_SUCCESS(rc))
2095	{
2096	if (!(u64 & UINT64_C(0xffffffffffff0000)))
2097	*pu16 = (int16_t)u64;
2098	else
2099	rc = VERR_CFGM_INTEGER_TOO_BIG;
2100	}
2101	return rc;
2102	}
2103
2104
2105	/**
2106	* Query signed 16-bit integer value.
2107	*
2108	* @returns VBox status code.
2109	* @param pNode Which node to search for pszName in.
2110	* @param pszName Name of an integer value.
2111	* @param pi16 Where to store the value.
2112	*/
2113	VMMR3DECL(int) CFGMR3QueryS16(PCFGMNODE pNode, const char pszName, int16_t pi16)
2114	{
2115	uint64_t u64;
2116	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
2117	if (RT_SUCCESS(rc))
2118	{
2119	if ( !(u64 & UINT64_C(0xffffffffffff8000))
2120	\|\| (u64 & UINT64_C(0xffffffffffff8000)) == UINT64_C(0xffffffffffff8000))
2121	*pi16 = (int16_t)u64;
2122	else
2123	rc = VERR_CFGM_INTEGER_TOO_BIG;
2124	}
2125	return rc;
2126	}
2127
2128
2129	/**
2130	* Query signed 16-bit integer value with default.
2131	*
2132	* @returns VBox status code.
2133	* @param pNode Which node to search for pszName in.
2134	* @param pszName Name of an integer value.
2135	* @param pi16 Where to store the value. Set to default on failure.
2136	* @param i16Def The default value.
2137	*/
2138	VMMR3DECL(int) CFGMR3QueryS16Def(PCFGMNODE pNode, const char pszName, int16_t pi16, int16_t i16Def)
2139	{
2140	uint64_t u64;
2141	int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, i16Def);
2142	if (RT_SUCCESS(rc))
2143	{
2144	if ( !(u64 & UINT64_C(0xffffffffffff8000))
2145	\|\| (u64 & UINT64_C(0xffffffffffff8000)) == UINT64_C(0xffffffffffff8000))
2146	*pi16 = (int16_t)u64;
2147	else
2148	rc = VERR_CFGM_INTEGER_TOO_BIG;
2149	}
2150	return rc;
2151	}
2152
2153
2154	/**
2155	* Query unsigned 8-bit integer value.
2156	*
2157	* @returns VBox status code.
2158	* @param pNode Which node to search for pszName in.
2159	* @param pszName Name of an integer value.
2160	* @param pu8 Where to store the value.
2161	*/
2162	VMMR3DECL(int) CFGMR3QueryU8(PCFGMNODE pNode, const char pszName, uint8_t pu8)
2163	{
2164	uint64_t u64;
2165	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
2166	if (RT_SUCCESS(rc))
2167	{
2168	if (!(u64 & UINT64_C(0xffffffffffffff00)))
2169	*pu8 = (uint8_t)u64;
2170	else
2171	rc = VERR_CFGM_INTEGER_TOO_BIG;
2172	}
2173	return rc;
2174	}
2175
2176
2177	/**
2178	* Query unsigned 8-bit integer value with default.
2179	*
2180	* @returns VBox status code.
2181	* @param pNode Which node to search for pszName in.
2182	* @param pszName Name of an integer value.
2183	* @param pu8 Where to store the value. Set to default on failure.
2184	* @param u8Def The default value.
2185	*/
2186	VMMR3DECL(int) CFGMR3QueryU8Def(PCFGMNODE pNode, const char pszName, uint8_t pu8, uint8_t u8Def)
2187	{
2188	uint64_t u64;
2189	int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, u8Def);
2190	if (RT_SUCCESS(rc))
2191	{
2192	if (!(u64 & UINT64_C(0xffffffffffffff00)))
2193	*pu8 = (uint8_t)u64;
2194	else
2195	rc = VERR_CFGM_INTEGER_TOO_BIG;
2196	}
2197	return rc;
2198	}
2199
2200
2201	/**
2202	* Query signed 8-bit integer value.
2203	*
2204	* @returns VBox status code.
2205	* @param pNode Which node to search for pszName in.
2206	* @param pszName Name of an integer value.
2207	* @param pi8 Where to store the value.
2208	*/
2209	VMMR3DECL(int) CFGMR3QueryS8(PCFGMNODE pNode, const char pszName, int8_t pi8)
2210	{
2211	uint64_t u64;
2212	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
2213	if (RT_SUCCESS(rc))
2214	{
2215	if ( !(u64 & UINT64_C(0xffffffffffffff80))
2216	\|\| (u64 & UINT64_C(0xffffffffffffff80)) == UINT64_C(0xffffffffffffff80))
2217	*pi8 = (int8_t)u64;
2218	else
2219	rc = VERR_CFGM_INTEGER_TOO_BIG;
2220	}
2221	return rc;
2222	}
2223
2224
2225	/**
2226	* Query signed 8-bit integer value with default.
2227	*
2228	* @returns VBox status code.
2229	* @param pNode Which node to search for pszName in.
2230	* @param pszName Name of an integer value.
2231	* @param pi8 Where to store the value. Set to default on failure.
2232	* @param i8Def The default value.
2233	*/
2234	VMMR3DECL(int) CFGMR3QueryS8Def(PCFGMNODE pNode, const char pszName, int8_t pi8, int8_t i8Def)
2235	{
2236	uint64_t u64;
2237	int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, i8Def);
2238	if (RT_SUCCESS(rc))
2239	{
2240	if ( !(u64 & UINT64_C(0xffffffffffffff80))
2241	\|\| (u64 & UINT64_C(0xffffffffffffff80)) == UINT64_C(0xffffffffffffff80))
2242	*pi8 = (int8_t)u64;
2243	else
2244	rc = VERR_CFGM_INTEGER_TOO_BIG;
2245	}
2246	return rc;
2247	}
2248
2249
2250	/**
2251	* Query boolean integer value.
2252	*
2253	* @returns VBox status code.
2254	* @param pNode Which node to search for pszName in.
2255	* @param pszName Name of an integer value.
2256	* @param pf Where to store the value.
2257	* @remark This function will interpret any non-zero value as true.
2258	*/
2259	VMMR3DECL(int) CFGMR3QueryBool(PCFGMNODE pNode, const char pszName, bool pf)
2260	{
2261	uint64_t u64;
2262	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
2263	if (RT_SUCCESS(rc))
2264	*pf = u64 ? true : false;
2265	return rc;
2266	}
2267
2268
2269	/**
2270	* Query boolean integer value with default.
2271	*
2272	* @returns VBox status code.
2273	* @param pNode Which node to search for pszName in.
2274	* @param pszName Name of an integer value.
2275	* @param pf Where to store the value. Set to default on failure.
2276	* @param fDef The default value.
2277	* @remark This function will interpret any non-zero value as true.
2278	*/
2279	VMMR3DECL(int) CFGMR3QueryBoolDef(PCFGMNODE pNode, const char pszName, bool pf, bool fDef)
2280	{
2281	uint64_t u64;
2282	int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, fDef);
2283	if (RT_SUCCESS(rc))
2284	*pf = u64 ? true : false;
2285	return rc;
2286	}
2287
2288
2289	/**
2290	* Query I/O port address value.
2291	*
2292	* @returns VBox status code.
2293	* @param pNode Which node to search for pszName in.
2294	* @param pszName Name of an integer value.
2295	* @param pPort Where to store the value.
2296	*/
2297	VMMR3DECL(int) CFGMR3QueryPort(PCFGMNODE pNode, const char *pszName, PRTIOPORT pPort)
2298	{
2299	AssertCompileSize(RTIOPORT, 2);
2300	return CFGMR3QueryU16(pNode, pszName, pPort);
2301	}
2302
2303
2304	/**
2305	* Query I/O port address value with default.
2306	*
2307	* @returns VBox status code.
2308	* @param pNode Which node to search for pszName in.
2309	* @param pszName Name of an integer value.
2310	* @param pPort Where to store the value. Set to default on failure.
2311	* @param PortDef The default value.
2312	*/
2313	VMMR3DECL(int) CFGMR3QueryPortDef(PCFGMNODE pNode, const char *pszName, PRTIOPORT pPort, RTIOPORT PortDef)
2314	{
2315	AssertCompileSize(RTIOPORT, 2);
2316	return CFGMR3QueryU16Def(pNode, pszName, pPort, PortDef);
2317	}
2318
2319
2320	/**
2321	* Query unsigned int address value.
2322	*
2323	* @returns VBox status code.
2324	* @param pNode Which node to search for pszName in.
2325	* @param pszName Name of an integer value.
2326	* @param pu Where to store the value.
2327	*/
2328	VMMR3DECL(int) CFGMR3QueryUInt(PCFGMNODE pNode, const char pszName, unsigned int pu)
2329	{
2330	AssertCompileSize(unsigned int, 4);
2331	return CFGMR3QueryU32(pNode, pszName, (uint32_t *)pu);
2332	}
2333
2334
2335	/**
2336	* Query unsigned int address value with default.
2337	*
2338	* @returns VBox status code.
2339	* @param pNode Which node to search for pszName in.
2340	* @param pszName Name of an integer value.
2341	* @param pu Where to store the value. Set to default on failure.
2342	* @param uDef The default value.
2343	*/
2344	VMMR3DECL(int) CFGMR3QueryUIntDef(PCFGMNODE pNode, const char pszName, unsigned int pu, unsigned int uDef)
2345	{
2346	AssertCompileSize(unsigned int, 4);
2347	return CFGMR3QueryU32Def(pNode, pszName, (uint32_t *)pu, uDef);
2348	}
2349
2350
2351	/**
2352	* Query signed int address value.
2353	*
2354	* @returns VBox status code.
2355	* @param pNode Which node to search for pszName in.
2356	* @param pszName Name of an integer value.
2357	* @param pi Where to store the value.
2358	*/
2359	VMMR3DECL(int) CFGMR3QuerySInt(PCFGMNODE pNode, const char pszName, signed int pi)
2360	{
2361	AssertCompileSize(signed int, 4);
2362	return CFGMR3QueryS32(pNode, pszName, (int32_t *)pi);
2363	}
2364
2365
2366	/**
2367	* Query unsigned int address value with default.
2368	*
2369	* @returns VBox status code.
2370	* @param pNode Which node to search for pszName in.
2371	* @param pszName Name of an integer value.
2372	* @param pi Where to store the value. Set to default on failure.
2373	* @param iDef The default value.
2374	*/
2375	VMMR3DECL(int) CFGMR3QuerySIntDef(PCFGMNODE pNode, const char pszName, signed int pi, signed int iDef)
2376	{
2377	AssertCompileSize(signed int, 4);
2378	return CFGMR3QueryS32Def(pNode, pszName, (int32_t *)pi, iDef);
2379	}
2380
2381
2382	/**
2383	* Query pointer integer value.
2384	*
2385	* @returns VBox status code.
2386	* @param pNode Which node to search for pszName in.
2387	* @param pszName Name of an integer value.
2388	* @param ppv Where to store the value.
2389	*/
2390	VMMR3DECL(int) CFGMR3QueryPtr(PCFGMNODE pNode, const char pszName, void *ppv)
2391	{
2392	uint64_t u64;
2393	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
2394	if (RT_SUCCESS(rc))
2395	{
2396	uintptr_t u = (uintptr_t)u64;
2397	if (u64 == u)
2398	ppv = (void )u;
2399	else
2400	rc = VERR_CFGM_INTEGER_TOO_BIG;
2401	}
2402	return rc;
2403	}
2404
2405
2406	/**
2407	* Query pointer integer value with default.
2408	*
2409	* @returns VBox status code.
2410	* @param pNode Which node to search for pszName in.
2411	* @param pszName Name of an integer value.
2412	* @param ppv Where to store the value. Set to default on failure.
2413	* @param pvDef The default value.
2414	*/
2415	VMMR3DECL(int) CFGMR3QueryPtrDef(PCFGMNODE pNode, const char pszName, void ppv, void pvDef)
2416	{
2417	uint64_t u64;
2418	int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, (uintptr_t)pvDef);
2419	if (RT_SUCCESS(rc))
2420	{
2421	uintptr_t u = (uintptr_t)u64;
2422	if (u64 == u)
2423	ppv = (void )u;
2424	else
2425	rc = VERR_CFGM_INTEGER_TOO_BIG;
2426	}
2427	return rc;
2428	}
2429
2430
2431	/**
2432	* Query Guest Context pointer integer value.
2433	*
2434	* @returns VBox status code.
2435	* @param pNode Which node to search for pszName in.
2436	* @param pszName Name of an integer value.
2437	* @param pGCPtr Where to store the value.
2438	*/
2439	VMMR3DECL(int) CFGMR3QueryGCPtr(PCFGMNODE pNode, const char *pszName, PRTGCPTR pGCPtr)
2440	{
2441	uint64_t u64;
2442	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
2443	if (RT_SUCCESS(rc))
2444	{
2445	RTGCPTR u = (RTGCPTR)u64;
2446	if (u64 == u)
2447	*pGCPtr = u;
2448	else
2449	rc = VERR_CFGM_INTEGER_TOO_BIG;
2450	}
2451	return rc;
2452	}
2453
2454
2455	/**
2456	* Query Guest Context pointer integer value with default.
2457	*
2458	* @returns VBox status code.
2459	* @param pNode Which node to search for pszName in.
2460	* @param pszName Name of an integer value.
2461	* @param pGCPtr Where to store the value. Set to default on failure.
2462	* @param GCPtrDef The default value.
2463	*/
2464	VMMR3DECL(int) CFGMR3QueryGCPtrDef(PCFGMNODE pNode, const char *pszName, PRTGCPTR pGCPtr, RTGCPTR GCPtrDef)
2465	{
2466	uint64_t u64;
2467	int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, GCPtrDef);
2468	if (RT_SUCCESS(rc))
2469	{
2470	RTGCPTR u = (RTGCPTR)u64;
2471	if (u64 == u)
2472	*pGCPtr = u;
2473	else
2474	rc = VERR_CFGM_INTEGER_TOO_BIG;
2475	}
2476	return rc;
2477	}
2478
2479
2480	/**
2481	* Query Guest Context unsigned pointer value.
2482	*
2483	* @returns VBox status code.
2484	* @param pNode Which node to search for pszName in.
2485	* @param pszName Name of an integer value.
2486	* @param pGCPtr Where to store the value.
2487	*/
2488	VMMR3DECL(int) CFGMR3QueryGCPtrU(PCFGMNODE pNode, const char *pszName, PRTGCUINTPTR pGCPtr)
2489	{
2490	uint64_t u64;
2491	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
2492	if (RT_SUCCESS(rc))
2493	{
2494	RTGCUINTPTR u = (RTGCUINTPTR)u64;
2495	if (u64 == u)
2496	*pGCPtr = u;
2497	else
2498	rc = VERR_CFGM_INTEGER_TOO_BIG;
2499	}
2500	return rc;
2501	}
2502
2503
2504	/**
2505	* Query Guest Context unsigned pointer value with default.
2506	*
2507	* @returns VBox status code.
2508	* @param pNode Which node to search for pszName in.
2509	* @param pszName Name of an integer value.
2510	* @param pGCPtr Where to store the value. Set to default on failure.
2511	* @param GCPtrDef The default value.
2512	*/
2513	VMMR3DECL(int) CFGMR3QueryGCPtrUDef(PCFGMNODE pNode, const char *pszName, PRTGCUINTPTR pGCPtr, RTGCUINTPTR GCPtrDef)
2514	{
2515	uint64_t u64;
2516	int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, GCPtrDef);
2517	if (RT_SUCCESS(rc))
2518	{
2519	RTGCUINTPTR u = (RTGCUINTPTR)u64;
2520	if (u64 == u)
2521	*pGCPtr = u;
2522	else
2523	rc = VERR_CFGM_INTEGER_TOO_BIG;
2524	}
2525	return rc;
2526	}
2527
2528
2529	/**
2530	* Query Guest Context signed pointer value.
2531	*
2532	* @returns VBox status code.
2533	* @param pNode Which node to search for pszName in.
2534	* @param pszName Name of an integer value.
2535	* @param pGCPtr Where to store the value.
2536	*/
2537	VMMR3DECL(int) CFGMR3QueryGCPtrS(PCFGMNODE pNode, const char *pszName, PRTGCINTPTR pGCPtr)
2538	{
2539	uint64_t u64;
2540	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
2541	if (RT_SUCCESS(rc))
2542	{
2543	RTGCINTPTR u = (RTGCINTPTR)u64;
2544	if (u64 == (uint64_t)u)
2545	*pGCPtr = u;
2546	else
2547	rc = VERR_CFGM_INTEGER_TOO_BIG;
2548	}
2549	return rc;
2550	}
2551
2552
2553	/**
2554	* Query Guest Context signed pointer value with default.
2555	*
2556	* @returns VBox status code.
2557	* @param pNode Which node to search for pszName in.
2558	* @param pszName Name of an integer value.
2559	* @param pGCPtr Where to store the value. Set to default on failure.
2560	* @param GCPtrDef The default value.
2561	*/
2562	VMMR3DECL(int) CFGMR3QueryGCPtrSDef(PCFGMNODE pNode, const char *pszName, PRTGCINTPTR pGCPtr, RTGCINTPTR GCPtrDef)
2563	{
2564	uint64_t u64;
2565	int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, GCPtrDef);
2566	if (RT_SUCCESS(rc))
2567	{
2568	RTGCINTPTR u = (RTGCINTPTR)u64;
2569	if (u64 == (uint64_t)u)
2570	*pGCPtr = u;
2571	else
2572	rc = VERR_CFGM_INTEGER_TOO_BIG;
2573	}
2574	return rc;
2575	}
2576
2577
2578	/**
2579	* Query zero terminated character value storing it in a
2580	* buffer allocated from the MM heap.
2581	*
2582	* @returns VBox status code.
2583	* @param pNode Which node to search for pszName in.
2584	* @param pszName Value name. This value must be of zero terminated character string type.
2585	* @param ppszString Where to store the string pointer.
2586	* Free this using MMR3HeapFree().
2587	*/
2588	VMMR3DECL(int) CFGMR3QueryStringAlloc(PCFGMNODE pNode, const char pszName, char *ppszString)
2589	{
2590	size_t cbString;
2591	int rc = CFGMR3QuerySize(pNode, pszName, &cbString);
2592	if (RT_SUCCESS(rc))
2593	{
2594	char pszString = (char )MMR3HeapAlloc(pNode->pVM, MM_TAG_CFGM_USER, cbString);
2595	if (pszString)
2596	{
2597	rc = CFGMR3QueryString(pNode, pszName, pszString, cbString);
2598	if (RT_SUCCESS(rc))
2599	*ppszString = pszString;
2600	else
2601	MMR3HeapFree(pszString);
2602	}
2603	else
2604	rc = VERR_NO_MEMORY;
2605	}
2606	return rc;
2607	}
2608
2609
2610	/**
2611	* Query zero terminated character value storing it in a
2612	* buffer allocated from the MM heap.
2613	*
2614	* @returns VBox status code.
2615	* @param pNode Which node to search for pszName in.
2616	* @param pszName Value name. This value must be of zero terminated character string type.
2617	* @param ppszString Where to store the string pointer. Not set on failure.
2618	* Free this using MMR3HeapFree().
2619	*/
2620	VMMR3DECL(int) CFGMR3QueryStringAllocDef(PCFGMNODE pNode, const char pszName, char ppszString, const char pszDef)
2621	{
2622	size_t cbString;
2623	int rc = CFGMR3QuerySize(pNode, pszName, &cbString);
2624	if (rc == VERR_CFGM_VALUE_NOT_FOUND \|\| rc == VERR_CFGM_NO_PARENT)
2625	{
2626	cbString = strlen(pszDef) + 1;
2627	rc = VINF_SUCCESS;
2628	}
2629	if (RT_SUCCESS(rc))
2630	{
2631	char pszString = (char )MMR3HeapAlloc(pNode->pVM, MM_TAG_CFGM_USER, cbString);
2632	if (pszString)
2633	{
2634	rc = CFGMR3QueryStringDef(pNode, pszName, pszString, cbString, pszDef);
2635	if (RT_SUCCESS(rc))
2636	*ppszString = pszString;
2637	else
2638	MMR3HeapFree(pszString);
2639	}
2640	else
2641	rc = VERR_NO_MEMORY;
2642	}
2643	return rc;
2644	}
2645
2646
2647	/**
2648	* Dumps the configuration (sub)tree to the release log.
2649	*
2650	* @param pRoot The root node of the dump.
2651	*/
2652	VMMR3DECL(void) CFGMR3Dump(PCFGMNODE pRoot)
2653	{
2654	LogRel(("*********************** CFGM dump ***********************\n"));
2655	cfgmR3Dump(pRoot, 0, DBGFR3InfoLogRelHlp());
2656	LogRel(("******************* End of CFGM dump ********************\n"));
2657	}
2658
2659
2660	/**
2661	* Info handler, internal version.
2662	*
2663	* @param pVM The VM handle.
2664	* @param pHlp Callback functions for doing output.
2665	* @param pszArgs Argument string. Optional and specific to the handler.
2666	*/
2667	static DECLCALLBACK(void) cfgmR3Info(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs)
2668	{
2669	/*
2670	* Figure where to start.
2671	*/
2672	PCFGMNODE pRoot = pVM->cfgm.s.pRoot;
2673	if (pszArgs && *pszArgs)
2674	{
2675	int rc = cfgmR3ResolveNode(pRoot, pszArgs, &pRoot);
2676	if (RT_FAILURE(rc))
2677	{
2678	pHlp->pfnPrintf(pHlp, "Failed to resolve CFGM path '%s', %Rrc", pszArgs, rc);
2679	return;
2680	}
2681	}
2682
2683	/*
2684	* Dump the specified tree.
2685	*/
2686	pHlp->pfnPrintf(pHlp, "pRoot=%p:{", pRoot);
2687	cfgmR3DumpPath(pRoot, pHlp);
2688	pHlp->pfnPrintf(pHlp, "}\n");
2689	cfgmR3Dump(pRoot, 0, pHlp);
2690	}
2691
2692
2693	/**
2694	* Recursivly prints a path name.
2695	*/
2696	static void cfgmR3DumpPath(PCFGMNODE pNode, PCDBGFINFOHLP pHlp)
2697	{
2698	if (pNode->pParent)
2699	cfgmR3DumpPath(pNode->pParent, pHlp);
2700	pHlp->pfnPrintf(pHlp, "%s/", pNode->szName);
2701	}
2702
2703
2704	/**
2705	* Dumps a branch of a tree.
2706	*/
2707	static void cfgmR3Dump(PCFGMNODE pRoot, unsigned iLevel, PCDBGFINFOHLP pHlp)
2708	{
2709	/*
2710	* Path.
2711	*/
2712	pHlp->pfnPrintf(pHlp, "[");
2713	cfgmR3DumpPath(pRoot, pHlp);
2714	pHlp->pfnPrintf(pHlp, "] (level %d)%s\n", iLevel, pRoot->fRestrictedRoot ? " (restricted root)" : "");
2715
2716	/*
2717	* Values.
2718	*/
2719	PCFGMLEAF pLeaf;
2720	size_t cchMax = 0;
2721	for (pLeaf = CFGMR3GetFirstValue(pRoot); pLeaf; pLeaf = CFGMR3GetNextValue(pLeaf))
2722	cchMax = RT_MAX(cchMax, pLeaf->cchName);
2723	for (pLeaf = CFGMR3GetFirstValue(pRoot); pLeaf; pLeaf = CFGMR3GetNextValue(pLeaf))
2724	{
2725	switch (CFGMR3GetValueType(pLeaf))
2726	{
2727	case CFGMVALUETYPE_INTEGER:
2728	pHlp->pfnPrintf(pHlp, " %-*s <integer> = %#018llx (%lld)\n", (int)cchMax, pLeaf->szName, pLeaf->Value.Integer.u64, pLeaf->Value.Integer.u64);
2729	break;
2730
2731	case CFGMVALUETYPE_STRING:
2732	pHlp->pfnPrintf(pHlp, " %-*s <string> = \"%s\" (cb=%zu)\n", (int)cchMax, pLeaf->szName, pLeaf->Value.String.psz, pLeaf->Value.String.cb);
2733	break;
2734
2735	case CFGMVALUETYPE_BYTES:
2736	pHlp->pfnPrintf(pHlp, " %-s <bytes> = \"%.Rhxs\" (cb=%zu)\n", (int)cchMax, pLeaf->szName, pLeaf->Value.Bytes.cb, pLeaf->Value.Bytes.pau8, pLeaf->Value.Bytes.cb);
2737	break;
2738
2739	default:
2740	AssertMsgFailed(("bad leaf!\n"));
2741	break;
2742	}
2743	}
2744	pHlp->pfnPrintf(pHlp, "\n");
2745
2746	/*
2747	* Children.
2748	*/
2749	for (PCFGMNODE pChild = CFGMR3GetFirstChild(pRoot); pChild; pChild = CFGMR3GetNextChild(pChild))
2750	{
2751	Assert(pChild->pNext != pChild);
2752	Assert(pChild->pPrev != pChild);
2753	Assert(pChild->pPrev != pChild->pNext \|\| !pChild->pPrev);
2754	Assert(pChild->pFirstChild != pChild);
2755	Assert(pChild->pParent != pChild);
2756	cfgmR3Dump(pChild, iLevel + 1, pHlp);
2757	}
2758	}
2759

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

source: vbox/trunk/src/VBox/VMM/CFGM.cpp@ 30111

Download in other formats: