CFGM.cpp@ 32963

Last change on this file since 32963 was 32356, checked in by vboxsync, 14 years ago
VMM: Avoid 700 unnecessary fflush(VBox.log) calls.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 80.8 KB

Line
1	/* $Id: CFGM.cpp 32356 2010-09-09 13:43:45Z 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. This variant expects that the caller know the length
1694	* of the string already so we can avoid calling strlen() here.
1695	*
1696	* @returns VBox status code.
1697	* @param pNode Parent node.
1698	* @param pszName Value name.
1699	* @param pszString The value. Must not be NULL.
1700	* @param cchString The length of the string excluding the
1701	* terminator.
1702	*/
1703	VMMR3DECL(int) CFGMR3InsertStringN(PCFGMNODE pNode, const char pszName, const char pszString, size_t cchString)
1704	{
1705	Assert(RTStrNLen(pszString, cchString) == cchString);
1706
1707	int rc;
1708	if (pNode)
1709	{
1710	/*
1711	* Allocate string object first.
1712	*/
1713	char pszStringCopy = (char )MMR3HeapAlloc(pNode->pVM, MM_TAG_CFGM_STRING, cchString + 1);
1714	if (pszStringCopy)
1715	{
1716	memcpy(pszStringCopy, pszString, cchString);
1717	pszStringCopy[cchString] = '\0';
1718
1719	/*
1720	* Create value leaf and set it to string type.
1721	*/
1722	PCFGMLEAF pLeaf;
1723	rc = cfgmR3InsertLeaf(pNode, pszName, &pLeaf);
1724	if (RT_SUCCESS(rc))
1725	{
1726	pLeaf->enmType = CFGMVALUETYPE_STRING;
1727	pLeaf->Value.String.psz = pszStringCopy;
1728	pLeaf->Value.String.cb = cchString + 1;
1729	}
1730	else
1731	MMR3HeapFree(pszStringCopy);
1732	}
1733	else
1734	rc = VERR_NO_MEMORY;
1735	}
1736	else
1737	rc = VERR_CFGM_NO_PARENT;
1738
1739	return rc;
1740	}
1741
1742
1743	/**
1744	* Inserts a new string value. Calls strlen(pszString) internally; if you know the
1745	* length of the string, CFGMR3InsertStringLengthKnown() is faster.
1746	*
1747	* @returns VBox status code.
1748	* @param pNode Parent node.
1749	* @param pszName Value name.
1750	* @param pszString The value.
1751	*/
1752	VMMR3DECL(int) CFGMR3InsertString(PCFGMNODE pNode, const char pszName, const char pszString)
1753	{
1754	return CFGMR3InsertStringN(pNode, pszName, pszString, strlen(pszString));
1755	}
1756
1757
1758	/**
1759	* Same as CFGMR3InsertString except the string value given in RTStrPrintfV
1760	* fashion.
1761	*
1762	* @returns VBox status code.
1763	* @param pNode Parent node.
1764	* @param pszName Value name.
1765	* @param pszFormat The value given as a format string.
1766	* @param va Argument to pszFormat.
1767	*/
1768	VMMR3DECL(int) CFGMR3InsertStringFV(PCFGMNODE pNode, const char pszName, const char pszFormat, va_list va)
1769	{
1770	int rc;
1771	if (pNode)
1772	{
1773	/*
1774	* Allocate string object first.
1775	*/
1776	char *pszString = MMR3HeapAPrintfVU(pNode->pVM->pUVM, MM_TAG_CFGM_STRING, pszFormat, va);
1777	if (pszString)
1778	{
1779	/*
1780	* Create value leaf and set it to string type.
1781	*/
1782	PCFGMLEAF pLeaf;
1783	rc = cfgmR3InsertLeaf(pNode, pszName, &pLeaf);
1784	if (RT_SUCCESS(rc))
1785	{
1786	pLeaf->enmType = CFGMVALUETYPE_STRING;
1787	pLeaf->Value.String.psz = pszString;
1788	pLeaf->Value.String.cb = strlen(pszString) + 1;
1789	}
1790	else
1791	MMR3HeapFree(pszString);
1792	}
1793	else
1794	rc = VERR_NO_MEMORY;
1795	}
1796	else
1797	rc = VERR_CFGM_NO_PARENT;
1798
1799	return rc;
1800	}
1801
1802
1803	/**
1804	* Same as CFGMR3InsertString except the string value given in RTStrPrintf
1805	* fashion.
1806	*
1807	* @returns VBox status code.
1808	* @param pNode Parent node.
1809	* @param pszName Value name.
1810	* @param pszFormat The value given as a format string.
1811	* @param ... Argument to pszFormat.
1812	*/
1813	VMMR3DECL(int) CFGMR3InsertStringF(PCFGMNODE pNode, const char pszName, const char pszFormat, ...)
1814	{
1815	va_list va;
1816	va_start(va, pszFormat);
1817	int rc = CFGMR3InsertStringFV(pNode, pszName, pszFormat, va);
1818	va_end(va);
1819	return rc;
1820	}
1821
1822
1823	/**
1824	* Same as CFGMR3InsertString except the string value given as a UTF-16 string.
1825	*
1826	* @returns VBox status code.
1827	* @param pNode Parent node.
1828	* @param pszName Value name.
1829	* @param pwszValue The string value (UTF-16).
1830	*/
1831	VMMR3DECL(int) CFGMR3InsertStringW(PCFGMNODE pNode, const char *pszName, PCRTUTF16 pwszValue)
1832	{
1833	char *pszValue;
1834	int rc = RTUtf16ToUtf8(pwszValue, &pszValue);
1835	if (RT_SUCCESS(rc))
1836	{
1837	rc = CFGMR3InsertString(pNode, pszName, pszValue);
1838	RTStrFree(pszValue);
1839	}
1840	return rc;
1841	}
1842
1843
1844	/**
1845	* Inserts a new integer value.
1846	*
1847	* @returns VBox status code.
1848	* @param pNode Parent node.
1849	* @param pszName Value name.
1850	* @param pvBytes The value.
1851	* @param cbBytes The value size.
1852	*/
1853	VMMR3DECL(int) CFGMR3InsertBytes(PCFGMNODE pNode, const char pszName, const void pvBytes, size_t cbBytes)
1854	{
1855	int rc;
1856	if (pNode)
1857	{
1858	if (cbBytes == (RTUINT)cbBytes)
1859	{
1860	/*
1861	* Allocate string object first.
1862	*/
1863	void *pvCopy = MMR3HeapAlloc(pNode->pVM, MM_TAG_CFGM_STRING, cbBytes);
1864	if (pvCopy \|\| !cbBytes)
1865	{
1866	memcpy(pvCopy, pvBytes, cbBytes);
1867
1868	/*
1869	* Create value leaf and set it to string type.
1870	*/
1871	PCFGMLEAF pLeaf;
1872	rc = cfgmR3InsertLeaf(pNode, pszName, &pLeaf);
1873	if (RT_SUCCESS(rc))
1874	{
1875	pLeaf->enmType = CFGMVALUETYPE_BYTES;
1876	pLeaf->Value.Bytes.cb = cbBytes;
1877	pLeaf->Value.Bytes.pau8 = (uint8_t *)pvCopy;
1878	}
1879	}
1880	else
1881	rc = VERR_NO_MEMORY;
1882	}
1883	else
1884	rc = VERR_OUT_OF_RANGE;
1885	}
1886	else
1887	rc = VERR_CFGM_NO_PARENT;
1888
1889	return rc;
1890	}
1891
1892
1893	/**
1894	* Remove a value.
1895	*
1896	* @returns VBox status code.
1897	* @param pNode Parent node.
1898	* @param pszName Name of the new child node.
1899	*/
1900	VMMR3DECL(int) CFGMR3RemoveValue(PCFGMNODE pNode, const char *pszName)
1901	{
1902	PCFGMLEAF pLeaf;
1903	int rc = cfgmR3ResolveLeaf(pNode, pszName, &pLeaf);
1904	if (RT_SUCCESS(rc))
1905	cfgmR3RemoveLeaf(pNode, pLeaf);
1906	return rc;
1907	}
1908
1909
1910
1911	/*
1912	* -+- helper apis -+-
1913	*/
1914
1915
1916	/**
1917	* Query unsigned 64-bit integer value.
1918	*
1919	* @returns VBox status code.
1920	* @param pNode Which node to search for pszName in.
1921	* @param pszName Name of an integer value.
1922	* @param pu64 Where to store the integer value.
1923	*/
1924	VMMR3DECL(int) CFGMR3QueryU64(PCFGMNODE pNode, const char pszName, uint64_t pu64)
1925	{
1926	return CFGMR3QueryInteger(pNode, pszName, pu64);
1927	}
1928
1929
1930	/**
1931	* Query unsigned 64-bit integer value with default.
1932	*
1933	* @returns VBox status code.
1934	* @param pNode Which node to search for pszName in.
1935	* @param pszName Name of an integer value.
1936	* @param pu64 Where to store the integer value. Set to default on failure.
1937	* @param u64Def The default value.
1938	*/
1939	VMMR3DECL(int) CFGMR3QueryU64Def(PCFGMNODE pNode, const char pszName, uint64_t pu64, uint64_t u64Def)
1940	{
1941	return CFGMR3QueryIntegerDef(pNode, pszName, pu64, u64Def);
1942	}
1943
1944
1945	/**
1946	* Query signed 64-bit integer value.
1947	*
1948	* @returns VBox status code.
1949	* @param pNode Which node to search for pszName in.
1950	* @param pszName Name of an integer value.
1951	* @param pi64 Where to store the value.
1952	*/
1953	VMMR3DECL(int) CFGMR3QueryS64(PCFGMNODE pNode, const char pszName, int64_t pi64)
1954	{
1955	uint64_t u64;
1956	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
1957	if (RT_SUCCESS(rc))
1958	*pi64 = (int64_t)u64;
1959	return rc;
1960	}
1961
1962
1963	/**
1964	* Query signed 64-bit integer value with default.
1965	*
1966	* @returns VBox status code.
1967	* @param pNode Which node to search for pszName in.
1968	* @param pszName Name of an integer value.
1969	* @param pi64 Where to store the value. Set to default on failure.
1970	* @param i64Def The default value.
1971	*/
1972	VMMR3DECL(int) CFGMR3QueryS64Def(PCFGMNODE pNode, const char pszName, int64_t pi64, int64_t i64Def)
1973	{
1974	uint64_t u64;
1975	int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, i64Def);
1976	if (RT_SUCCESS(rc))
1977	*pi64 = (int64_t)u64;
1978	return rc;
1979	}
1980
1981
1982	/**
1983	* Query unsigned 32-bit integer value.
1984	*
1985	* @returns VBox status code.
1986	* @param pNode Which node to search for pszName in.
1987	* @param pszName Name of an integer value.
1988	* @param pu32 Where to store the value.
1989	*/
1990	VMMR3DECL(int) CFGMR3QueryU32(PCFGMNODE pNode, const char pszName, uint32_t pu32)
1991	{
1992	uint64_t u64;
1993	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
1994	if (RT_SUCCESS(rc))
1995	{
1996	if (!(u64 & UINT64_C(0xffffffff00000000)))
1997	*pu32 = (uint32_t)u64;
1998	else
1999	rc = VERR_CFGM_INTEGER_TOO_BIG;
2000	}
2001	return rc;
2002	}
2003
2004
2005	/**
2006	* Query unsigned 32-bit integer value with default.
2007	*
2008	* @returns VBox status code.
2009	* @param pNode Which node to search for pszName in.
2010	* @param pszName Name of an integer value.
2011	* @param pu32 Where to store the value. Set to default on failure.
2012	* @param u32Def The default value.
2013	*/
2014	VMMR3DECL(int) CFGMR3QueryU32Def(PCFGMNODE pNode, const char pszName, uint32_t pu32, uint32_t u32Def)
2015	{
2016	uint64_t u64;
2017	int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, u32Def);
2018	if (RT_SUCCESS(rc))
2019	{
2020	if (!(u64 & UINT64_C(0xffffffff00000000)))
2021	*pu32 = (uint32_t)u64;
2022	else
2023	rc = VERR_CFGM_INTEGER_TOO_BIG;
2024	}
2025	return rc;
2026	}
2027
2028
2029	/**
2030	* Query signed 32-bit integer value.
2031	*
2032	* @returns VBox status code.
2033	* @param pNode Which node to search for pszName in.
2034	* @param pszName Name of an integer value.
2035	* @param pi32 Where to store the value.
2036	*/
2037	VMMR3DECL(int) CFGMR3QueryS32(PCFGMNODE pNode, const char pszName, int32_t pi32)
2038	{
2039	uint64_t u64;
2040	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
2041	if (RT_SUCCESS(rc))
2042	{
2043	if ( !(u64 & UINT64_C(0xffffffff80000000))
2044	\|\| (u64 & UINT64_C(0xffffffff80000000)) == UINT64_C(0xffffffff80000000))
2045	*pi32 = (int32_t)u64;
2046	else
2047	rc = VERR_CFGM_INTEGER_TOO_BIG;
2048	}
2049	return rc;
2050	}
2051
2052
2053	/**
2054	* Query signed 32-bit integer value with default.
2055	*
2056	* @returns VBox status code.
2057	* @param pNode Which node to search for pszName in.
2058	* @param pszName Name of an integer value.
2059	* @param pi32 Where to store the value. Set to default on failure.
2060	* @param i32Def The default value.
2061	*/
2062	VMMR3DECL(int) CFGMR3QueryS32Def(PCFGMNODE pNode, const char pszName, int32_t pi32, int32_t i32Def)
2063	{
2064	uint64_t u64;
2065	int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, i32Def);
2066	if (RT_SUCCESS(rc))
2067	{
2068	if ( !(u64 & UINT64_C(0xffffffff80000000))
2069	\|\| (u64 & UINT64_C(0xffffffff80000000)) == UINT64_C(0xffffffff80000000))
2070	*pi32 = (int32_t)u64;
2071	else
2072	rc = VERR_CFGM_INTEGER_TOO_BIG;
2073	}
2074	return rc;
2075	}
2076
2077
2078	/**
2079	* Query unsigned 16-bit integer value.
2080	*
2081	* @returns VBox status code.
2082	* @param pNode Which node to search for pszName in.
2083	* @param pszName Name of an integer value.
2084	* @param pu16 Where to store the value.
2085	*/
2086	VMMR3DECL(int) CFGMR3QueryU16(PCFGMNODE pNode, const char pszName, uint16_t pu16)
2087	{
2088	uint64_t u64;
2089	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
2090	if (RT_SUCCESS(rc))
2091	{
2092	if (!(u64 & UINT64_C(0xffffffffffff0000)))
2093	*pu16 = (int16_t)u64;
2094	else
2095	rc = VERR_CFGM_INTEGER_TOO_BIG;
2096	}
2097	return rc;
2098	}
2099
2100
2101	/**
2102	* Query unsigned 16-bit integer value with default.
2103	*
2104	* @returns VBox status code.
2105	* @param pNode Which node to search for pszName in.
2106	* @param pszName Name of an integer value.
2107	* @param pu16 Where to store the value. Set to default on failure.
2108	* @param i16Def The default value.
2109	*/
2110	VMMR3DECL(int) CFGMR3QueryU16Def(PCFGMNODE pNode, const char pszName, uint16_t pu16, uint16_t u16Def)
2111	{
2112	uint64_t u64;
2113	int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, u16Def);
2114	if (RT_SUCCESS(rc))
2115	{
2116	if (!(u64 & UINT64_C(0xffffffffffff0000)))
2117	*pu16 = (int16_t)u64;
2118	else
2119	rc = VERR_CFGM_INTEGER_TOO_BIG;
2120	}
2121	return rc;
2122	}
2123
2124
2125	/**
2126	* Query signed 16-bit integer value.
2127	*
2128	* @returns VBox status code.
2129	* @param pNode Which node to search for pszName in.
2130	* @param pszName Name of an integer value.
2131	* @param pi16 Where to store the value.
2132	*/
2133	VMMR3DECL(int) CFGMR3QueryS16(PCFGMNODE pNode, const char pszName, int16_t pi16)
2134	{
2135	uint64_t u64;
2136	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
2137	if (RT_SUCCESS(rc))
2138	{
2139	if ( !(u64 & UINT64_C(0xffffffffffff8000))
2140	\|\| (u64 & UINT64_C(0xffffffffffff8000)) == UINT64_C(0xffffffffffff8000))
2141	*pi16 = (int16_t)u64;
2142	else
2143	rc = VERR_CFGM_INTEGER_TOO_BIG;
2144	}
2145	return rc;
2146	}
2147
2148
2149	/**
2150	* Query signed 16-bit integer value with default.
2151	*
2152	* @returns VBox status code.
2153	* @param pNode Which node to search for pszName in.
2154	* @param pszName Name of an integer value.
2155	* @param pi16 Where to store the value. Set to default on failure.
2156	* @param i16Def The default value.
2157	*/
2158	VMMR3DECL(int) CFGMR3QueryS16Def(PCFGMNODE pNode, const char pszName, int16_t pi16, int16_t i16Def)
2159	{
2160	uint64_t u64;
2161	int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, i16Def);
2162	if (RT_SUCCESS(rc))
2163	{
2164	if ( !(u64 & UINT64_C(0xffffffffffff8000))
2165	\|\| (u64 & UINT64_C(0xffffffffffff8000)) == UINT64_C(0xffffffffffff8000))
2166	*pi16 = (int16_t)u64;
2167	else
2168	rc = VERR_CFGM_INTEGER_TOO_BIG;
2169	}
2170	return rc;
2171	}
2172
2173
2174	/**
2175	* Query unsigned 8-bit integer value.
2176	*
2177	* @returns VBox status code.
2178	* @param pNode Which node to search for pszName in.
2179	* @param pszName Name of an integer value.
2180	* @param pu8 Where to store the value.
2181	*/
2182	VMMR3DECL(int) CFGMR3QueryU8(PCFGMNODE pNode, const char pszName, uint8_t pu8)
2183	{
2184	uint64_t u64;
2185	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
2186	if (RT_SUCCESS(rc))
2187	{
2188	if (!(u64 & UINT64_C(0xffffffffffffff00)))
2189	*pu8 = (uint8_t)u64;
2190	else
2191	rc = VERR_CFGM_INTEGER_TOO_BIG;
2192	}
2193	return rc;
2194	}
2195
2196
2197	/**
2198	* Query unsigned 8-bit integer value with default.
2199	*
2200	* @returns VBox status code.
2201	* @param pNode Which node to search for pszName in.
2202	* @param pszName Name of an integer value.
2203	* @param pu8 Where to store the value. Set to default on failure.
2204	* @param u8Def The default value.
2205	*/
2206	VMMR3DECL(int) CFGMR3QueryU8Def(PCFGMNODE pNode, const char pszName, uint8_t pu8, uint8_t u8Def)
2207	{
2208	uint64_t u64;
2209	int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, u8Def);
2210	if (RT_SUCCESS(rc))
2211	{
2212	if (!(u64 & UINT64_C(0xffffffffffffff00)))
2213	*pu8 = (uint8_t)u64;
2214	else
2215	rc = VERR_CFGM_INTEGER_TOO_BIG;
2216	}
2217	return rc;
2218	}
2219
2220
2221	/**
2222	* Query signed 8-bit integer value.
2223	*
2224	* @returns VBox status code.
2225	* @param pNode Which node to search for pszName in.
2226	* @param pszName Name of an integer value.
2227	* @param pi8 Where to store the value.
2228	*/
2229	VMMR3DECL(int) CFGMR3QueryS8(PCFGMNODE pNode, const char pszName, int8_t pi8)
2230	{
2231	uint64_t u64;
2232	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
2233	if (RT_SUCCESS(rc))
2234	{
2235	if ( !(u64 & UINT64_C(0xffffffffffffff80))
2236	\|\| (u64 & UINT64_C(0xffffffffffffff80)) == UINT64_C(0xffffffffffffff80))
2237	*pi8 = (int8_t)u64;
2238	else
2239	rc = VERR_CFGM_INTEGER_TOO_BIG;
2240	}
2241	return rc;
2242	}
2243
2244
2245	/**
2246	* Query signed 8-bit integer value with default.
2247	*
2248	* @returns VBox status code.
2249	* @param pNode Which node to search for pszName in.
2250	* @param pszName Name of an integer value.
2251	* @param pi8 Where to store the value. Set to default on failure.
2252	* @param i8Def The default value.
2253	*/
2254	VMMR3DECL(int) CFGMR3QueryS8Def(PCFGMNODE pNode, const char pszName, int8_t pi8, int8_t i8Def)
2255	{
2256	uint64_t u64;
2257	int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, i8Def);
2258	if (RT_SUCCESS(rc))
2259	{
2260	if ( !(u64 & UINT64_C(0xffffffffffffff80))
2261	\|\| (u64 & UINT64_C(0xffffffffffffff80)) == UINT64_C(0xffffffffffffff80))
2262	*pi8 = (int8_t)u64;
2263	else
2264	rc = VERR_CFGM_INTEGER_TOO_BIG;
2265	}
2266	return rc;
2267	}
2268
2269
2270	/**
2271	* Query boolean integer value.
2272	*
2273	* @returns VBox status code.
2274	* @param pNode Which node to search for pszName in.
2275	* @param pszName Name of an integer value.
2276	* @param pf Where to store the value.
2277	* @remark This function will interpret any non-zero value as true.
2278	*/
2279	VMMR3DECL(int) CFGMR3QueryBool(PCFGMNODE pNode, const char pszName, bool pf)
2280	{
2281	uint64_t u64;
2282	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
2283	if (RT_SUCCESS(rc))
2284	*pf = u64 ? true : false;
2285	return rc;
2286	}
2287
2288
2289	/**
2290	* Query boolean integer value with default.
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 pf Where to store the value. Set to default on failure.
2296	* @param fDef The default value.
2297	* @remark This function will interpret any non-zero value as true.
2298	*/
2299	VMMR3DECL(int) CFGMR3QueryBoolDef(PCFGMNODE pNode, const char pszName, bool pf, bool fDef)
2300	{
2301	uint64_t u64;
2302	int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, fDef);
2303	if (RT_SUCCESS(rc))
2304	*pf = u64 ? true : false;
2305	return rc;
2306	}
2307
2308
2309	/**
2310	* Query I/O port address value.
2311	*
2312	* @returns VBox status code.
2313	* @param pNode Which node to search for pszName in.
2314	* @param pszName Name of an integer value.
2315	* @param pPort Where to store the value.
2316	*/
2317	VMMR3DECL(int) CFGMR3QueryPort(PCFGMNODE pNode, const char *pszName, PRTIOPORT pPort)
2318	{
2319	AssertCompileSize(RTIOPORT, 2);
2320	return CFGMR3QueryU16(pNode, pszName, pPort);
2321	}
2322
2323
2324	/**
2325	* Query I/O port address value with default.
2326	*
2327	* @returns VBox status code.
2328	* @param pNode Which node to search for pszName in.
2329	* @param pszName Name of an integer value.
2330	* @param pPort Where to store the value. Set to default on failure.
2331	* @param PortDef The default value.
2332	*/
2333	VMMR3DECL(int) CFGMR3QueryPortDef(PCFGMNODE pNode, const char *pszName, PRTIOPORT pPort, RTIOPORT PortDef)
2334	{
2335	AssertCompileSize(RTIOPORT, 2);
2336	return CFGMR3QueryU16Def(pNode, pszName, pPort, PortDef);
2337	}
2338
2339
2340	/**
2341	* Query unsigned int address value.
2342	*
2343	* @returns VBox status code.
2344	* @param pNode Which node to search for pszName in.
2345	* @param pszName Name of an integer value.
2346	* @param pu Where to store the value.
2347	*/
2348	VMMR3DECL(int) CFGMR3QueryUInt(PCFGMNODE pNode, const char pszName, unsigned int pu)
2349	{
2350	AssertCompileSize(unsigned int, 4);
2351	return CFGMR3QueryU32(pNode, pszName, (uint32_t *)pu);
2352	}
2353
2354
2355	/**
2356	* Query unsigned int address value with default.
2357	*
2358	* @returns VBox status code.
2359	* @param pNode Which node to search for pszName in.
2360	* @param pszName Name of an integer value.
2361	* @param pu Where to store the value. Set to default on failure.
2362	* @param uDef The default value.
2363	*/
2364	VMMR3DECL(int) CFGMR3QueryUIntDef(PCFGMNODE pNode, const char pszName, unsigned int pu, unsigned int uDef)
2365	{
2366	AssertCompileSize(unsigned int, 4);
2367	return CFGMR3QueryU32Def(pNode, pszName, (uint32_t *)pu, uDef);
2368	}
2369
2370
2371	/**
2372	* Query signed int address value.
2373	*
2374	* @returns VBox status code.
2375	* @param pNode Which node to search for pszName in.
2376	* @param pszName Name of an integer value.
2377	* @param pi Where to store the value.
2378	*/
2379	VMMR3DECL(int) CFGMR3QuerySInt(PCFGMNODE pNode, const char pszName, signed int pi)
2380	{
2381	AssertCompileSize(signed int, 4);
2382	return CFGMR3QueryS32(pNode, pszName, (int32_t *)pi);
2383	}
2384
2385
2386	/**
2387	* Query unsigned int address value with default.
2388	*
2389	* @returns VBox status code.
2390	* @param pNode Which node to search for pszName in.
2391	* @param pszName Name of an integer value.
2392	* @param pi Where to store the value. Set to default on failure.
2393	* @param iDef The default value.
2394	*/
2395	VMMR3DECL(int) CFGMR3QuerySIntDef(PCFGMNODE pNode, const char pszName, signed int pi, signed int iDef)
2396	{
2397	AssertCompileSize(signed int, 4);
2398	return CFGMR3QueryS32Def(pNode, pszName, (int32_t *)pi, iDef);
2399	}
2400
2401
2402	/**
2403	* Query pointer integer value.
2404	*
2405	* @returns VBox status code.
2406	* @param pNode Which node to search for pszName in.
2407	* @param pszName Name of an integer value.
2408	* @param ppv Where to store the value.
2409	*/
2410	VMMR3DECL(int) CFGMR3QueryPtr(PCFGMNODE pNode, const char pszName, void *ppv)
2411	{
2412	uint64_t u64;
2413	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
2414	if (RT_SUCCESS(rc))
2415	{
2416	uintptr_t u = (uintptr_t)u64;
2417	if (u64 == u)
2418	ppv = (void )u;
2419	else
2420	rc = VERR_CFGM_INTEGER_TOO_BIG;
2421	}
2422	return rc;
2423	}
2424
2425
2426	/**
2427	* Query pointer integer value with default.
2428	*
2429	* @returns VBox status code.
2430	* @param pNode Which node to search for pszName in.
2431	* @param pszName Name of an integer value.
2432	* @param ppv Where to store the value. Set to default on failure.
2433	* @param pvDef The default value.
2434	*/
2435	VMMR3DECL(int) CFGMR3QueryPtrDef(PCFGMNODE pNode, const char pszName, void ppv, void pvDef)
2436	{
2437	uint64_t u64;
2438	int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, (uintptr_t)pvDef);
2439	if (RT_SUCCESS(rc))
2440	{
2441	uintptr_t u = (uintptr_t)u64;
2442	if (u64 == u)
2443	ppv = (void )u;
2444	else
2445	rc = VERR_CFGM_INTEGER_TOO_BIG;
2446	}
2447	return rc;
2448	}
2449
2450
2451	/**
2452	* Query Guest Context pointer integer value.
2453	*
2454	* @returns VBox status code.
2455	* @param pNode Which node to search for pszName in.
2456	* @param pszName Name of an integer value.
2457	* @param pGCPtr Where to store the value.
2458	*/
2459	VMMR3DECL(int) CFGMR3QueryGCPtr(PCFGMNODE pNode, const char *pszName, PRTGCPTR pGCPtr)
2460	{
2461	uint64_t u64;
2462	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
2463	if (RT_SUCCESS(rc))
2464	{
2465	RTGCPTR u = (RTGCPTR)u64;
2466	if (u64 == u)
2467	*pGCPtr = u;
2468	else
2469	rc = VERR_CFGM_INTEGER_TOO_BIG;
2470	}
2471	return rc;
2472	}
2473
2474
2475	/**
2476	* Query Guest Context pointer integer value with default.
2477	*
2478	* @returns VBox status code.
2479	* @param pNode Which node to search for pszName in.
2480	* @param pszName Name of an integer value.
2481	* @param pGCPtr Where to store the value. Set to default on failure.
2482	* @param GCPtrDef The default value.
2483	*/
2484	VMMR3DECL(int) CFGMR3QueryGCPtrDef(PCFGMNODE pNode, const char *pszName, PRTGCPTR pGCPtr, RTGCPTR GCPtrDef)
2485	{
2486	uint64_t u64;
2487	int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, GCPtrDef);
2488	if (RT_SUCCESS(rc))
2489	{
2490	RTGCPTR u = (RTGCPTR)u64;
2491	if (u64 == u)
2492	*pGCPtr = u;
2493	else
2494	rc = VERR_CFGM_INTEGER_TOO_BIG;
2495	}
2496	return rc;
2497	}
2498
2499
2500	/**
2501	* Query Guest Context unsigned pointer value.
2502	*
2503	* @returns VBox status code.
2504	* @param pNode Which node to search for pszName in.
2505	* @param pszName Name of an integer value.
2506	* @param pGCPtr Where to store the value.
2507	*/
2508	VMMR3DECL(int) CFGMR3QueryGCPtrU(PCFGMNODE pNode, const char *pszName, PRTGCUINTPTR pGCPtr)
2509	{
2510	uint64_t u64;
2511	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
2512	if (RT_SUCCESS(rc))
2513	{
2514	RTGCUINTPTR u = (RTGCUINTPTR)u64;
2515	if (u64 == u)
2516	*pGCPtr = u;
2517	else
2518	rc = VERR_CFGM_INTEGER_TOO_BIG;
2519	}
2520	return rc;
2521	}
2522
2523
2524	/**
2525	* Query Guest Context unsigned pointer value with default.
2526	*
2527	* @returns VBox status code.
2528	* @param pNode Which node to search for pszName in.
2529	* @param pszName Name of an integer value.
2530	* @param pGCPtr Where to store the value. Set to default on failure.
2531	* @param GCPtrDef The default value.
2532	*/
2533	VMMR3DECL(int) CFGMR3QueryGCPtrUDef(PCFGMNODE pNode, const char *pszName, PRTGCUINTPTR pGCPtr, RTGCUINTPTR GCPtrDef)
2534	{
2535	uint64_t u64;
2536	int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, GCPtrDef);
2537	if (RT_SUCCESS(rc))
2538	{
2539	RTGCUINTPTR u = (RTGCUINTPTR)u64;
2540	if (u64 == u)
2541	*pGCPtr = u;
2542	else
2543	rc = VERR_CFGM_INTEGER_TOO_BIG;
2544	}
2545	return rc;
2546	}
2547
2548
2549	/**
2550	* Query Guest Context signed pointer value.
2551	*
2552	* @returns VBox status code.
2553	* @param pNode Which node to search for pszName in.
2554	* @param pszName Name of an integer value.
2555	* @param pGCPtr Where to store the value.
2556	*/
2557	VMMR3DECL(int) CFGMR3QueryGCPtrS(PCFGMNODE pNode, const char *pszName, PRTGCINTPTR pGCPtr)
2558	{
2559	uint64_t u64;
2560	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
2561	if (RT_SUCCESS(rc))
2562	{
2563	RTGCINTPTR u = (RTGCINTPTR)u64;
2564	if (u64 == (uint64_t)u)
2565	*pGCPtr = u;
2566	else
2567	rc = VERR_CFGM_INTEGER_TOO_BIG;
2568	}
2569	return rc;
2570	}
2571
2572
2573	/**
2574	* Query Guest Context signed pointer value with default.
2575	*
2576	* @returns VBox status code.
2577	* @param pNode Which node to search for pszName in.
2578	* @param pszName Name of an integer value.
2579	* @param pGCPtr Where to store the value. Set to default on failure.
2580	* @param GCPtrDef The default value.
2581	*/
2582	VMMR3DECL(int) CFGMR3QueryGCPtrSDef(PCFGMNODE pNode, const char *pszName, PRTGCINTPTR pGCPtr, RTGCINTPTR GCPtrDef)
2583	{
2584	uint64_t u64;
2585	int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, GCPtrDef);
2586	if (RT_SUCCESS(rc))
2587	{
2588	RTGCINTPTR u = (RTGCINTPTR)u64;
2589	if (u64 == (uint64_t)u)
2590	*pGCPtr = u;
2591	else
2592	rc = VERR_CFGM_INTEGER_TOO_BIG;
2593	}
2594	return rc;
2595	}
2596
2597
2598	/**
2599	* Query zero terminated character value storing it in a
2600	* buffer allocated from the MM heap.
2601	*
2602	* @returns VBox status code.
2603	* @param pNode Which node to search for pszName in.
2604	* @param pszName Value name. This value must be of zero terminated character string type.
2605	* @param ppszString Where to store the string pointer.
2606	* Free this using MMR3HeapFree().
2607	*/
2608	VMMR3DECL(int) CFGMR3QueryStringAlloc(PCFGMNODE pNode, const char pszName, char *ppszString)
2609	{
2610	size_t cbString;
2611	int rc = CFGMR3QuerySize(pNode, pszName, &cbString);
2612	if (RT_SUCCESS(rc))
2613	{
2614	char pszString = (char )MMR3HeapAlloc(pNode->pVM, MM_TAG_CFGM_USER, cbString);
2615	if (pszString)
2616	{
2617	rc = CFGMR3QueryString(pNode, pszName, pszString, cbString);
2618	if (RT_SUCCESS(rc))
2619	*ppszString = pszString;
2620	else
2621	MMR3HeapFree(pszString);
2622	}
2623	else
2624	rc = VERR_NO_MEMORY;
2625	}
2626	return rc;
2627	}
2628
2629
2630	/**
2631	* Query zero terminated character value storing it in a
2632	* buffer allocated from the MM heap.
2633	*
2634	* @returns VBox status code.
2635	* @param pNode Which node to search for pszName in.
2636	* @param pszName Value name. This value must be of zero terminated character string type.
2637	* @param ppszString Where to store the string pointer. Not set on failure.
2638	* Free this using MMR3HeapFree().
2639	*/
2640	VMMR3DECL(int) CFGMR3QueryStringAllocDef(PCFGMNODE pNode, const char pszName, char ppszString, const char pszDef)
2641	{
2642	size_t cbString;
2643	int rc = CFGMR3QuerySize(pNode, pszName, &cbString);
2644	if (rc == VERR_CFGM_VALUE_NOT_FOUND \|\| rc == VERR_CFGM_NO_PARENT)
2645	{
2646	cbString = strlen(pszDef) + 1;
2647	rc = VINF_SUCCESS;
2648	}
2649	if (RT_SUCCESS(rc))
2650	{
2651	char pszString = (char )MMR3HeapAlloc(pNode->pVM, MM_TAG_CFGM_USER, cbString);
2652	if (pszString)
2653	{
2654	rc = CFGMR3QueryStringDef(pNode, pszName, pszString, cbString, pszDef);
2655	if (RT_SUCCESS(rc))
2656	*ppszString = pszString;
2657	else
2658	MMR3HeapFree(pszString);
2659	}
2660	else
2661	rc = VERR_NO_MEMORY;
2662	}
2663	return rc;
2664	}
2665
2666
2667	/**
2668	* Dumps the configuration (sub)tree to the release log.
2669	*
2670	* @param pRoot The root node of the dump.
2671	*/
2672	VMMR3DECL(void) CFGMR3Dump(PCFGMNODE pRoot)
2673	{
2674	LogRel(("*********************** CFGM dump ***********************\n"));
2675	bool fOldBuffered = RTLogRelSetBuffering(true /fBuffered/);
2676	cfgmR3Dump(pRoot, 0, DBGFR3InfoLogRelHlp());
2677	RTLogRelSetBuffering(fOldBuffered);
2678	LogRel(("******************* End of CFGM dump ********************\n"));
2679	}
2680
2681
2682	/**
2683	* Info handler, internal version.
2684	*
2685	* @param pVM The VM handle.
2686	* @param pHlp Callback functions for doing output.
2687	* @param pszArgs Argument string. Optional and specific to the handler.
2688	*/
2689	static DECLCALLBACK(void) cfgmR3Info(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs)
2690	{
2691	/*
2692	* Figure where to start.
2693	*/
2694	PCFGMNODE pRoot = pVM->cfgm.s.pRoot;
2695	if (pszArgs && *pszArgs)
2696	{
2697	int rc = cfgmR3ResolveNode(pRoot, pszArgs, &pRoot);
2698	if (RT_FAILURE(rc))
2699	{
2700	pHlp->pfnPrintf(pHlp, "Failed to resolve CFGM path '%s', %Rrc", pszArgs, rc);
2701	return;
2702	}
2703	}
2704
2705	/*
2706	* Dump the specified tree.
2707	*/
2708	pHlp->pfnPrintf(pHlp, "pRoot=%p:{", pRoot);
2709	cfgmR3DumpPath(pRoot, pHlp);
2710	pHlp->pfnPrintf(pHlp, "}\n");
2711	cfgmR3Dump(pRoot, 0, pHlp);
2712	}
2713
2714
2715	/**
2716	* Recursivly prints a path name.
2717	*/
2718	static void cfgmR3DumpPath(PCFGMNODE pNode, PCDBGFINFOHLP pHlp)
2719	{
2720	if (pNode->pParent)
2721	cfgmR3DumpPath(pNode->pParent, pHlp);
2722	pHlp->pfnPrintf(pHlp, "%s/", pNode->szName);
2723	}
2724
2725
2726	/**
2727	* Dumps a branch of a tree.
2728	*/
2729	static void cfgmR3Dump(PCFGMNODE pRoot, unsigned iLevel, PCDBGFINFOHLP pHlp)
2730	{
2731	/*
2732	* Path.
2733	*/
2734	pHlp->pfnPrintf(pHlp, "[");
2735	cfgmR3DumpPath(pRoot, pHlp);
2736	pHlp->pfnPrintf(pHlp, "] (level %d)%s\n", iLevel, pRoot->fRestrictedRoot ? " (restricted root)" : "");
2737
2738	/*
2739	* Values.
2740	*/
2741	PCFGMLEAF pLeaf;
2742	size_t cchMax = 0;
2743	for (pLeaf = CFGMR3GetFirstValue(pRoot); pLeaf; pLeaf = CFGMR3GetNextValue(pLeaf))
2744	cchMax = RT_MAX(cchMax, pLeaf->cchName);
2745	for (pLeaf = CFGMR3GetFirstValue(pRoot); pLeaf; pLeaf = CFGMR3GetNextValue(pLeaf))
2746	{
2747	switch (CFGMR3GetValueType(pLeaf))
2748	{
2749	case CFGMVALUETYPE_INTEGER:
2750	pHlp->pfnPrintf(pHlp, " %-*s <integer> = %#018llx (%lld)\n", (int)cchMax, pLeaf->szName, pLeaf->Value.Integer.u64, pLeaf->Value.Integer.u64);
2751	break;
2752
2753	case CFGMVALUETYPE_STRING:
2754	pHlp->pfnPrintf(pHlp, " %-*s <string> = \"%s\" (cb=%zu)\n", (int)cchMax, pLeaf->szName, pLeaf->Value.String.psz, pLeaf->Value.String.cb);
2755	break;
2756
2757	case CFGMVALUETYPE_BYTES:
2758	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);
2759	break;
2760
2761	default:
2762	AssertMsgFailed(("bad leaf!\n"));
2763	break;
2764	}
2765	}
2766	pHlp->pfnPrintf(pHlp, "\n");
2767
2768	/*
2769	* Children.
2770	*/
2771	for (PCFGMNODE pChild = CFGMR3GetFirstChild(pRoot); pChild; pChild = CFGMR3GetNextChild(pChild))
2772	{
2773	Assert(pChild->pNext != pChild);
2774	Assert(pChild->pPrev != pChild);
2775	Assert(pChild->pPrev != pChild->pNext \|\| !pChild->pPrev);
2776	Assert(pChild->pFirstChild != pChild);
2777	Assert(pChild->pParent != pChild);
2778	cfgmR3Dump(pChild, iLevel + 1, pHlp);
2779	}
2780	}
2781

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

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

Download in other formats: