VirtualBox

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

Last change on this file since 35263 was 34240, checked in by vboxsync, 14 years ago

CFGMR3QueryStringAllocDef: Deal with pszDef = NULL.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 81.7 KB
Line 
1/* $Id: CFGM.cpp 34240 2010-11-22 14:24:49Z 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*******************************************************************************/
74static void cfgmR3DumpPath(PCFGMNODE pNode, PCDBGFINFOHLP pHlp);
75static void cfgmR3Dump(PCFGMNODE pRoot, unsigned iLevel, PCDBGFINFOHLP pHlp);
76static DECLCALLBACK(void) cfgmR3Info(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
77static int cfgmR3ResolveNode(PCFGMNODE pNode, const char *pszPath, PCFGMNODE *ppChild);
78static int cfgmR3ResolveLeaf(PCFGMNODE pNode, const char *pszName, PCFGMLEAF *ppLeaf);
79static int cfgmR3InsertLeaf(PCFGMNODE pNode, const char *pszName, PCFGMLEAF *ppLeaf);
80static void cfgmR3RemoveLeaf(PCFGMNODE pNode, PCFGMLEAF pLeaf);
81static 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 */
95VMMR3DECL(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 */
145VMMR3DECL(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 */
159VMMR3DECL(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 */
174VMMR3DECL(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 */
191VMMR3DECL(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 */
208VMMR3DECL(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 */
228VMMR3DECL(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 */
248VMMR3DECL(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 */
272VMMR3DECL(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 */
287VMMR3DECL(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 */
303VMMR3DECL(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 */
331VMMR3DECL(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 */
348VMMR3DECL(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 */
388VMMR3DECL(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 */
399VMMR3DECL(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 */
414VMMR3DECL(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 */
442VMMR3DECL(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 */
456VMMR3DECL(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 */
473VMMR3DECL(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 */
515VMMR3DECL(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 */
537VMMR3DECL(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 */
575VMMR3DECL(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 */
599VMMR3DECL(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 */
631VMMR3DECL(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 */
665VMMR3DECL(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 */
713VMMR3DECL(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 */
759VMMR3DECL(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 */
824VMMR3DECL(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 */
1085static 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 */
1144static 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 */
1183VMMR3DECL(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 */
1220VMMR3DECL(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 */
1266DECLINLINE(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 */
1294VMMR3DECL(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 component.
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 */
1438VMMR3DECL(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 */
1457VMMR3DECL(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 */
1479VMMR3DECL(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 */
1495static 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 */
1563VMMR3DECL(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 */
1612static 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 */
1645static 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 */
1679VMMR3DECL(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 */
1703VMMR3DECL(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 */
1752VMMR3DECL(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 */
1768VMMR3DECL(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 */
1813VMMR3DECL(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 */
1831VMMR3DECL(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 */
1853VMMR3DECL(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 */
1900VMMR3DECL(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 */
1924VMMR3DECL(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 */
1939VMMR3DECL(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 */
1953VMMR3DECL(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 */
1972VMMR3DECL(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 *pi64 = (int64_t)u64;
1977 return rc;
1978}
1979
1980
1981/**
1982 * Query unsigned 32-bit integer value.
1983 *
1984 * @returns VBox status code.
1985 * @param pNode Which node to search for pszName in.
1986 * @param pszName Name of an integer value.
1987 * @param pu32 Where to store the value.
1988 */
1989VMMR3DECL(int) CFGMR3QueryU32(PCFGMNODE pNode, const char *pszName, uint32_t *pu32)
1990{
1991 uint64_t u64;
1992 int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
1993 if (RT_SUCCESS(rc))
1994 {
1995 if (!(u64 & UINT64_C(0xffffffff00000000)))
1996 *pu32 = (uint32_t)u64;
1997 else
1998 rc = VERR_CFGM_INTEGER_TOO_BIG;
1999 }
2000 return rc;
2001}
2002
2003
2004/**
2005 * Query unsigned 32-bit integer value with default.
2006 *
2007 * @returns VBox status code.
2008 * @param pNode Which node to search for pszName in.
2009 * @param pszName Name of an integer value.
2010 * @param pu32 Where to store the value. Set to default on failure.
2011 * @param u32Def The default value.
2012 */
2013VMMR3DECL(int) CFGMR3QueryU32Def(PCFGMNODE pNode, const char *pszName, uint32_t *pu32, uint32_t u32Def)
2014{
2015 uint64_t u64;
2016 int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, u32Def);
2017 if (RT_SUCCESS(rc))
2018 {
2019 if (!(u64 & UINT64_C(0xffffffff00000000)))
2020 *pu32 = (uint32_t)u64;
2021 else
2022 rc = VERR_CFGM_INTEGER_TOO_BIG;
2023 }
2024 if (RT_FAILURE(rc))
2025 *pu32 = u32Def;
2026 return rc;
2027}
2028
2029
2030/**
2031 * Query signed 32-bit integer value.
2032 *
2033 * @returns VBox status code.
2034 * @param pNode Which node to search for pszName in.
2035 * @param pszName Name of an integer value.
2036 * @param pi32 Where to store the value.
2037 */
2038VMMR3DECL(int) CFGMR3QueryS32(PCFGMNODE pNode, const char *pszName, int32_t *pi32)
2039{
2040 uint64_t u64;
2041 int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
2042 if (RT_SUCCESS(rc))
2043 {
2044 if ( !(u64 & UINT64_C(0xffffffff80000000))
2045 || (u64 & UINT64_C(0xffffffff80000000)) == UINT64_C(0xffffffff80000000))
2046 *pi32 = (int32_t)u64;
2047 else
2048 rc = VERR_CFGM_INTEGER_TOO_BIG;
2049 }
2050 return rc;
2051}
2052
2053
2054/**
2055 * Query signed 32-bit integer value with default.
2056 *
2057 * @returns VBox status code.
2058 * @param pNode Which node to search for pszName in.
2059 * @param pszName Name of an integer value.
2060 * @param pi32 Where to store the value. Set to default on failure.
2061 * @param i32Def The default value.
2062 */
2063VMMR3DECL(int) CFGMR3QueryS32Def(PCFGMNODE pNode, const char *pszName, int32_t *pi32, int32_t i32Def)
2064{
2065 uint64_t u64;
2066 int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, i32Def);
2067 if (RT_SUCCESS(rc))
2068 {
2069 if ( !(u64 & UINT64_C(0xffffffff80000000))
2070 || (u64 & UINT64_C(0xffffffff80000000)) == UINT64_C(0xffffffff80000000))
2071 *pi32 = (int32_t)u64;
2072 else
2073 rc = VERR_CFGM_INTEGER_TOO_BIG;
2074 }
2075 if (RT_FAILURE(rc))
2076 *pi32 = i32Def;
2077 return rc;
2078}
2079
2080
2081/**
2082 * Query unsigned 16-bit integer value.
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.
2088 */
2089VMMR3DECL(int) CFGMR3QueryU16(PCFGMNODE pNode, const char *pszName, uint16_t *pu16)
2090{
2091 uint64_t u64;
2092 int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
2093 if (RT_SUCCESS(rc))
2094 {
2095 if (!(u64 & UINT64_C(0xffffffffffff0000)))
2096 *pu16 = (int16_t)u64;
2097 else
2098 rc = VERR_CFGM_INTEGER_TOO_BIG;
2099 }
2100 return rc;
2101}
2102
2103
2104/**
2105 * Query unsigned 16-bit integer value with default.
2106 *
2107 * @returns VBox status code.
2108 * @param pNode Which node to search for pszName in.
2109 * @param pszName Name of an integer value.
2110 * @param pu16 Where to store the value. Set to default on failure.
2111 * @param i16Def The default value.
2112 */
2113VMMR3DECL(int) CFGMR3QueryU16Def(PCFGMNODE pNode, const char *pszName, uint16_t *pu16, uint16_t u16Def)
2114{
2115 uint64_t u64;
2116 int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, u16Def);
2117 if (RT_SUCCESS(rc))
2118 {
2119 if (!(u64 & UINT64_C(0xffffffffffff0000)))
2120 *pu16 = (int16_t)u64;
2121 else
2122 rc = VERR_CFGM_INTEGER_TOO_BIG;
2123 }
2124 if (RT_FAILURE(rc))
2125 *pu16 = u16Def;
2126 return rc;
2127}
2128
2129
2130/**
2131 * Query signed 16-bit integer value.
2132 *
2133 * @returns VBox status code.
2134 * @param pNode Which node to search for pszName in.
2135 * @param pszName Name of an integer value.
2136 * @param pi16 Where to store the value.
2137 */
2138VMMR3DECL(int) CFGMR3QueryS16(PCFGMNODE pNode, const char *pszName, int16_t *pi16)
2139{
2140 uint64_t u64;
2141 int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
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 signed 16-bit integer value with default.
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 pi16 Where to store the value. Set to default on failure.
2161 * @param i16Def The default value.
2162 */
2163VMMR3DECL(int) CFGMR3QueryS16Def(PCFGMNODE pNode, const char *pszName, int16_t *pi16, int16_t i16Def)
2164{
2165 uint64_t u64;
2166 int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, i16Def);
2167 if (RT_SUCCESS(rc))
2168 {
2169 if ( !(u64 & UINT64_C(0xffffffffffff8000))
2170 || (u64 & UINT64_C(0xffffffffffff8000)) == UINT64_C(0xffffffffffff8000))
2171 *pi16 = (int16_t)u64;
2172 else
2173 rc = VERR_CFGM_INTEGER_TOO_BIG;
2174 }
2175 if (RT_FAILURE(rc))
2176 *pi16 = i16Def;
2177 return rc;
2178}
2179
2180
2181/**
2182 * Query unsigned 8-bit integer value.
2183 *
2184 * @returns VBox status code.
2185 * @param pNode Which node to search for pszName in.
2186 * @param pszName Name of an integer value.
2187 * @param pu8 Where to store the value.
2188 */
2189VMMR3DECL(int) CFGMR3QueryU8(PCFGMNODE pNode, const char *pszName, uint8_t *pu8)
2190{
2191 uint64_t u64;
2192 int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
2193 if (RT_SUCCESS(rc))
2194 {
2195 if (!(u64 & UINT64_C(0xffffffffffffff00)))
2196 *pu8 = (uint8_t)u64;
2197 else
2198 rc = VERR_CFGM_INTEGER_TOO_BIG;
2199 }
2200 return rc;
2201}
2202
2203
2204/**
2205 * Query unsigned 8-bit integer value with default.
2206 *
2207 * @returns VBox status code.
2208 * @param pNode Which node to search for pszName in.
2209 * @param pszName Name of an integer value.
2210 * @param pu8 Where to store the value. Set to default on failure.
2211 * @param u8Def The default value.
2212 */
2213VMMR3DECL(int) CFGMR3QueryU8Def(PCFGMNODE pNode, const char *pszName, uint8_t *pu8, uint8_t u8Def)
2214{
2215 uint64_t u64;
2216 int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, u8Def);
2217 if (RT_SUCCESS(rc))
2218 {
2219 if (!(u64 & UINT64_C(0xffffffffffffff00)))
2220 *pu8 = (uint8_t)u64;
2221 else
2222 rc = VERR_CFGM_INTEGER_TOO_BIG;
2223 }
2224 if (RT_FAILURE(rc))
2225 *pu8 = u8Def;
2226 return rc;
2227}
2228
2229
2230/**
2231 * Query signed 8-bit integer value.
2232 *
2233 * @returns VBox status code.
2234 * @param pNode Which node to search for pszName in.
2235 * @param pszName Name of an integer value.
2236 * @param pi8 Where to store the value.
2237 */
2238VMMR3DECL(int) CFGMR3QueryS8(PCFGMNODE pNode, const char *pszName, int8_t *pi8)
2239{
2240 uint64_t u64;
2241 int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
2242 if (RT_SUCCESS(rc))
2243 {
2244 if ( !(u64 & UINT64_C(0xffffffffffffff80))
2245 || (u64 & UINT64_C(0xffffffffffffff80)) == UINT64_C(0xffffffffffffff80))
2246 *pi8 = (int8_t)u64;
2247 else
2248 rc = VERR_CFGM_INTEGER_TOO_BIG;
2249 }
2250 return rc;
2251}
2252
2253
2254/**
2255 * Query signed 8-bit integer value with default.
2256 *
2257 * @returns VBox status code.
2258 * @param pNode Which node to search for pszName in.
2259 * @param pszName Name of an integer value.
2260 * @param pi8 Where to store the value. Set to default on failure.
2261 * @param i8Def The default value.
2262 */
2263VMMR3DECL(int) CFGMR3QueryS8Def(PCFGMNODE pNode, const char *pszName, int8_t *pi8, int8_t i8Def)
2264{
2265 uint64_t u64;
2266 int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, i8Def);
2267 if (RT_SUCCESS(rc))
2268 {
2269 if ( !(u64 & UINT64_C(0xffffffffffffff80))
2270 || (u64 & UINT64_C(0xffffffffffffff80)) == UINT64_C(0xffffffffffffff80))
2271 *pi8 = (int8_t)u64;
2272 else
2273 rc = VERR_CFGM_INTEGER_TOO_BIG;
2274 }
2275 if (RT_FAILURE(rc))
2276 *pi8 = i8Def;
2277 return rc;
2278}
2279
2280
2281/**
2282 * Query boolean integer value.
2283 *
2284 * @returns VBox status code.
2285 * @param pNode Which node to search for pszName in.
2286 * @param pszName Name of an integer value.
2287 * @param pf Where to store the value.
2288 * @remark This function will interpret any non-zero value as true.
2289 */
2290VMMR3DECL(int) CFGMR3QueryBool(PCFGMNODE pNode, const char *pszName, bool *pf)
2291{
2292 uint64_t u64;
2293 int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
2294 if (RT_SUCCESS(rc))
2295 *pf = u64 ? true : false;
2296 return rc;
2297}
2298
2299
2300/**
2301 * Query boolean integer value with default.
2302 *
2303 * @returns VBox status code.
2304 * @param pNode Which node to search for pszName in.
2305 * @param pszName Name of an integer value.
2306 * @param pf Where to store the value. Set to default on failure.
2307 * @param fDef The default value.
2308 * @remark This function will interpret any non-zero value as true.
2309 */
2310VMMR3DECL(int) CFGMR3QueryBoolDef(PCFGMNODE pNode, const char *pszName, bool *pf, bool fDef)
2311{
2312 uint64_t u64;
2313 int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, fDef);
2314 *pf = u64 ? true : false;
2315 return rc;
2316}
2317
2318
2319/**
2320 * Query I/O port address value.
2321 *
2322 * @returns VBox status code.
2323 * @param pNode Which node to search for pszName in.
2324 * @param pszName Name of an integer value.
2325 * @param pPort Where to store the value.
2326 */
2327VMMR3DECL(int) CFGMR3QueryPort(PCFGMNODE pNode, const char *pszName, PRTIOPORT pPort)
2328{
2329 AssertCompileSize(RTIOPORT, 2);
2330 return CFGMR3QueryU16(pNode, pszName, pPort);
2331}
2332
2333
2334/**
2335 * Query I/O port address value with default.
2336 *
2337 * @returns VBox status code.
2338 * @param pNode Which node to search for pszName in.
2339 * @param pszName Name of an integer value.
2340 * @param pPort Where to store the value. Set to default on failure.
2341 * @param PortDef The default value.
2342 */
2343VMMR3DECL(int) CFGMR3QueryPortDef(PCFGMNODE pNode, const char *pszName, PRTIOPORT pPort, RTIOPORT PortDef)
2344{
2345 AssertCompileSize(RTIOPORT, 2);
2346 return CFGMR3QueryU16Def(pNode, pszName, pPort, PortDef);
2347}
2348
2349
2350/**
2351 * Query unsigned int address value.
2352 *
2353 * @returns VBox status code.
2354 * @param pNode Which node to search for pszName in.
2355 * @param pszName Name of an integer value.
2356 * @param pu Where to store the value.
2357 */
2358VMMR3DECL(int) CFGMR3QueryUInt(PCFGMNODE pNode, const char *pszName, unsigned int *pu)
2359{
2360 AssertCompileSize(unsigned int, 4);
2361 return CFGMR3QueryU32(pNode, pszName, (uint32_t *)pu);
2362}
2363
2364
2365/**
2366 * Query unsigned int address value with default.
2367 *
2368 * @returns VBox status code.
2369 * @param pNode Which node to search for pszName in.
2370 * @param pszName Name of an integer value.
2371 * @param pu Where to store the value. Set to default on failure.
2372 * @param uDef The default value.
2373 */
2374VMMR3DECL(int) CFGMR3QueryUIntDef(PCFGMNODE pNode, const char *pszName, unsigned int *pu, unsigned int uDef)
2375{
2376 AssertCompileSize(unsigned int, 4);
2377 return CFGMR3QueryU32Def(pNode, pszName, (uint32_t *)pu, uDef);
2378}
2379
2380
2381/**
2382 * Query signed int address value.
2383 *
2384 * @returns VBox status code.
2385 * @param pNode Which node to search for pszName in.
2386 * @param pszName Name of an integer value.
2387 * @param pi Where to store the value.
2388 */
2389VMMR3DECL(int) CFGMR3QuerySInt(PCFGMNODE pNode, const char *pszName, signed int *pi)
2390{
2391 AssertCompileSize(signed int, 4);
2392 return CFGMR3QueryS32(pNode, pszName, (int32_t *)pi);
2393}
2394
2395
2396/**
2397 * Query unsigned int address value with default.
2398 *
2399 * @returns VBox status code.
2400 * @param pNode Which node to search for pszName in.
2401 * @param pszName Name of an integer value.
2402 * @param pi Where to store the value. Set to default on failure.
2403 * @param iDef The default value.
2404 */
2405VMMR3DECL(int) CFGMR3QuerySIntDef(PCFGMNODE pNode, const char *pszName, signed int *pi, signed int iDef)
2406{
2407 AssertCompileSize(signed int, 4);
2408 return CFGMR3QueryS32Def(pNode, pszName, (int32_t *)pi, iDef);
2409}
2410
2411
2412/**
2413 * Query pointer integer value.
2414 *
2415 * @returns VBox status code.
2416 * @param pNode Which node to search for pszName in.
2417 * @param pszName Name of an integer value.
2418 * @param ppv Where to store the value.
2419 */
2420VMMR3DECL(int) CFGMR3QueryPtr(PCFGMNODE pNode, const char *pszName, void **ppv)
2421{
2422 uint64_t u64;
2423 int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
2424 if (RT_SUCCESS(rc))
2425 {
2426 uintptr_t u = (uintptr_t)u64;
2427 if (u64 == u)
2428 *ppv = (void *)u;
2429 else
2430 rc = VERR_CFGM_INTEGER_TOO_BIG;
2431 }
2432 return rc;
2433}
2434
2435
2436/**
2437 * Query pointer integer value with default.
2438 *
2439 * @returns VBox status code.
2440 * @param pNode Which node to search for pszName in.
2441 * @param pszName Name of an integer value.
2442 * @param ppv Where to store the value. Set to default on failure.
2443 * @param pvDef The default value.
2444 */
2445VMMR3DECL(int) CFGMR3QueryPtrDef(PCFGMNODE pNode, const char *pszName, void **ppv, void *pvDef)
2446{
2447 uint64_t u64;
2448 int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, (uintptr_t)pvDef);
2449 if (RT_SUCCESS(rc))
2450 {
2451 uintptr_t u = (uintptr_t)u64;
2452 if (u64 == u)
2453 *ppv = (void *)u;
2454 else
2455 rc = VERR_CFGM_INTEGER_TOO_BIG;
2456 }
2457 if (RT_FAILURE(rc))
2458 *ppv = pvDef;
2459 return rc;
2460}
2461
2462
2463/**
2464 * Query Guest Context pointer integer value.
2465 *
2466 * @returns VBox status code.
2467 * @param pNode Which node to search for pszName in.
2468 * @param pszName Name of an integer value.
2469 * @param pGCPtr Where to store the value.
2470 */
2471VMMR3DECL(int) CFGMR3QueryGCPtr(PCFGMNODE pNode, const char *pszName, PRTGCPTR pGCPtr)
2472{
2473 uint64_t u64;
2474 int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
2475 if (RT_SUCCESS(rc))
2476 {
2477 RTGCPTR u = (RTGCPTR)u64;
2478 if (u64 == u)
2479 *pGCPtr = u;
2480 else
2481 rc = VERR_CFGM_INTEGER_TOO_BIG;
2482 }
2483 return rc;
2484}
2485
2486
2487/**
2488 * Query Guest Context pointer integer value with default.
2489 *
2490 * @returns VBox status code.
2491 * @param pNode Which node to search for pszName in.
2492 * @param pszName Name of an integer value.
2493 * @param pGCPtr Where to store the value. Set to default on failure.
2494 * @param GCPtrDef The default value.
2495 */
2496VMMR3DECL(int) CFGMR3QueryGCPtrDef(PCFGMNODE pNode, const char *pszName, PRTGCPTR pGCPtr, RTGCPTR GCPtrDef)
2497{
2498 uint64_t u64;
2499 int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, GCPtrDef);
2500 if (RT_SUCCESS(rc))
2501 {
2502 RTGCPTR u = (RTGCPTR)u64;
2503 if (u64 == u)
2504 *pGCPtr = u;
2505 else
2506 rc = VERR_CFGM_INTEGER_TOO_BIG;
2507 }
2508 if (RT_FAILURE(rc))
2509 *pGCPtr = GCPtrDef;
2510 return rc;
2511}
2512
2513
2514/**
2515 * Query Guest Context unsigned pointer value.
2516 *
2517 * @returns VBox status code.
2518 * @param pNode Which node to search for pszName in.
2519 * @param pszName Name of an integer value.
2520 * @param pGCPtr Where to store the value.
2521 */
2522VMMR3DECL(int) CFGMR3QueryGCPtrU(PCFGMNODE pNode, const char *pszName, PRTGCUINTPTR pGCPtr)
2523{
2524 uint64_t u64;
2525 int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
2526 if (RT_SUCCESS(rc))
2527 {
2528 RTGCUINTPTR u = (RTGCUINTPTR)u64;
2529 if (u64 == u)
2530 *pGCPtr = u;
2531 else
2532 rc = VERR_CFGM_INTEGER_TOO_BIG;
2533 }
2534 return rc;
2535}
2536
2537
2538/**
2539 * Query Guest Context unsigned pointer value with default.
2540 *
2541 * @returns VBox status code.
2542 * @param pNode Which node to search for pszName in.
2543 * @param pszName Name of an integer value.
2544 * @param pGCPtr Where to store the value. Set to default on failure.
2545 * @param GCPtrDef The default value.
2546 */
2547VMMR3DECL(int) CFGMR3QueryGCPtrUDef(PCFGMNODE pNode, const char *pszName, PRTGCUINTPTR pGCPtr, RTGCUINTPTR GCPtrDef)
2548{
2549 uint64_t u64;
2550 int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, GCPtrDef);
2551 if (RT_SUCCESS(rc))
2552 {
2553 RTGCUINTPTR u = (RTGCUINTPTR)u64;
2554 if (u64 == u)
2555 *pGCPtr = u;
2556 else
2557 rc = VERR_CFGM_INTEGER_TOO_BIG;
2558 }
2559 if (RT_FAILURE(rc))
2560 *pGCPtr = GCPtrDef;
2561 return rc;
2562}
2563
2564
2565/**
2566 * Query Guest Context signed pointer value.
2567 *
2568 * @returns VBox status code.
2569 * @param pNode Which node to search for pszName in.
2570 * @param pszName Name of an integer value.
2571 * @param pGCPtr Where to store the value.
2572 */
2573VMMR3DECL(int) CFGMR3QueryGCPtrS(PCFGMNODE pNode, const char *pszName, PRTGCINTPTR pGCPtr)
2574{
2575 uint64_t u64;
2576 int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
2577 if (RT_SUCCESS(rc))
2578 {
2579 RTGCINTPTR u = (RTGCINTPTR)u64;
2580 if (u64 == (uint64_t)u)
2581 *pGCPtr = u;
2582 else
2583 rc = VERR_CFGM_INTEGER_TOO_BIG;
2584 }
2585 return rc;
2586}
2587
2588
2589/**
2590 * Query Guest Context signed pointer value with default.
2591 *
2592 * @returns VBox status code.
2593 * @param pNode Which node to search for pszName in.
2594 * @param pszName Name of an integer value.
2595 * @param pGCPtr Where to store the value. Set to default on failure.
2596 * @param GCPtrDef The default value.
2597 */
2598VMMR3DECL(int) CFGMR3QueryGCPtrSDef(PCFGMNODE pNode, const char *pszName, PRTGCINTPTR pGCPtr, RTGCINTPTR GCPtrDef)
2599{
2600 uint64_t u64;
2601 int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, GCPtrDef);
2602 if (RT_SUCCESS(rc))
2603 {
2604 RTGCINTPTR u = (RTGCINTPTR)u64;
2605 if (u64 == (uint64_t)u)
2606 *pGCPtr = u;
2607 else
2608 rc = VERR_CFGM_INTEGER_TOO_BIG;
2609 }
2610 if (RT_FAILURE(rc))
2611 *pGCPtr = GCPtrDef;
2612 return rc;
2613}
2614
2615
2616/**
2617 * Query zero terminated character value storing it in a
2618 * buffer allocated from the MM heap.
2619 *
2620 * @returns VBox status code.
2621 * @param pNode Which node to search for pszName in.
2622 * @param pszName Value name. This value must be of zero terminated character string type.
2623 * @param ppszString Where to store the string pointer.
2624 * Free this using MMR3HeapFree().
2625 */
2626VMMR3DECL(int) CFGMR3QueryStringAlloc(PCFGMNODE pNode, const char *pszName, char **ppszString)
2627{
2628 size_t cbString;
2629 int rc = CFGMR3QuerySize(pNode, pszName, &cbString);
2630 if (RT_SUCCESS(rc))
2631 {
2632 char *pszString = (char *)MMR3HeapAlloc(pNode->pVM, MM_TAG_CFGM_USER, cbString);
2633 if (pszString)
2634 {
2635 rc = CFGMR3QueryString(pNode, pszName, pszString, cbString);
2636 if (RT_SUCCESS(rc))
2637 *ppszString = pszString;
2638 else
2639 MMR3HeapFree(pszString);
2640 }
2641 else
2642 rc = VERR_NO_MEMORY;
2643 }
2644 return rc;
2645}
2646
2647
2648/**
2649 * Query zero terminated character value storing it in a
2650 * buffer allocated from the MM heap.
2651 *
2652 * @returns VBox status code.
2653 * @param pNode Which node to search for pszName in.
2654 * @param pszName Value name. This value must be of zero terminated character string type.
2655 * @param ppszString Where to store the string pointer. Not set on failure.
2656 * Free this using MMR3HeapFree().
2657 * @param pszDef The default return value. This can be NULL.
2658 */
2659VMMR3DECL(int) CFGMR3QueryStringAllocDef(PCFGMNODE pNode, const char *pszName, char **ppszString, const char *pszDef)
2660{
2661 /*
2662 * (Don't call CFGMR3QuerySize and CFGMR3QueryStringDef here as the latter
2663 * cannot handle pszDef being NULL.)
2664 */
2665 PCFGMLEAF pLeaf;
2666 int rc = cfgmR3ResolveLeaf(pNode, pszName, &pLeaf);
2667 if (RT_SUCCESS(rc))
2668 {
2669 if (pLeaf->enmType == CFGMVALUETYPE_STRING)
2670 {
2671 size_t const cbSrc = pLeaf->Value.String.cb;
2672 char *pszString = (char *)MMR3HeapAlloc(pNode->pVM, MM_TAG_CFGM_USER, cbSrc);
2673 if (pszString)
2674 {
2675 memcpy(pszString, pLeaf->Value.String.psz, cbSrc);
2676 *ppszString = pszString;
2677 }
2678 else
2679 rc = VERR_NO_MEMORY;
2680 }
2681 else
2682 rc = VERR_CFGM_NOT_STRING;
2683 }
2684 if (RT_FAILURE(rc))
2685 {
2686 if (!pszDef)
2687 *ppszString = NULL;
2688 else
2689 *ppszString = MMR3HeapStrDup(pNode->pVM, MM_TAG_CFGM_USER, pszDef);
2690 if (rc == VERR_CFGM_VALUE_NOT_FOUND || rc == VERR_CFGM_NO_PARENT)
2691 rc = VINF_SUCCESS;
2692 }
2693
2694 return rc;
2695}
2696
2697
2698/**
2699 * Dumps the configuration (sub)tree to the release log.
2700 *
2701 * @param pRoot The root node of the dump.
2702 */
2703VMMR3DECL(void) CFGMR3Dump(PCFGMNODE pRoot)
2704{
2705 LogRel(("************************* CFGM dump *************************\n"));
2706 bool fOldBuffered = RTLogRelSetBuffering(true /*fBuffered*/);
2707 cfgmR3Dump(pRoot, 0, DBGFR3InfoLogRelHlp());
2708 RTLogRelSetBuffering(fOldBuffered);
2709 LogRel(("********************* End of CFGM dump **********************\n"));
2710}
2711
2712
2713/**
2714 * Info handler, internal version.
2715 *
2716 * @param pVM The VM handle.
2717 * @param pHlp Callback functions for doing output.
2718 * @param pszArgs Argument string. Optional and specific to the handler.
2719 */
2720static DECLCALLBACK(void) cfgmR3Info(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs)
2721{
2722 /*
2723 * Figure where to start.
2724 */
2725 PCFGMNODE pRoot = pVM->cfgm.s.pRoot;
2726 if (pszArgs && *pszArgs)
2727 {
2728 int rc = cfgmR3ResolveNode(pRoot, pszArgs, &pRoot);
2729 if (RT_FAILURE(rc))
2730 {
2731 pHlp->pfnPrintf(pHlp, "Failed to resolve CFGM path '%s', %Rrc", pszArgs, rc);
2732 return;
2733 }
2734 }
2735
2736 /*
2737 * Dump the specified tree.
2738 */
2739 pHlp->pfnPrintf(pHlp, "pRoot=%p:{", pRoot);
2740 cfgmR3DumpPath(pRoot, pHlp);
2741 pHlp->pfnPrintf(pHlp, "}\n");
2742 cfgmR3Dump(pRoot, 0, pHlp);
2743}
2744
2745
2746/**
2747 * Recursively prints a path name.
2748 */
2749static void cfgmR3DumpPath(PCFGMNODE pNode, PCDBGFINFOHLP pHlp)
2750{
2751 if (pNode->pParent)
2752 cfgmR3DumpPath(pNode->pParent, pHlp);
2753 pHlp->pfnPrintf(pHlp, "%s/", pNode->szName);
2754}
2755
2756
2757/**
2758 * Dumps a branch of a tree.
2759 */
2760static void cfgmR3Dump(PCFGMNODE pRoot, unsigned iLevel, PCDBGFINFOHLP pHlp)
2761{
2762 /*
2763 * Path.
2764 */
2765 pHlp->pfnPrintf(pHlp, "[");
2766 cfgmR3DumpPath(pRoot, pHlp);
2767 pHlp->pfnPrintf(pHlp, "] (level %d)%s\n", iLevel, pRoot->fRestrictedRoot ? " (restricted root)" : "");
2768
2769 /*
2770 * Values.
2771 */
2772 PCFGMLEAF pLeaf;
2773 size_t cchMax = 0;
2774 for (pLeaf = CFGMR3GetFirstValue(pRoot); pLeaf; pLeaf = CFGMR3GetNextValue(pLeaf))
2775 cchMax = RT_MAX(cchMax, pLeaf->cchName);
2776 for (pLeaf = CFGMR3GetFirstValue(pRoot); pLeaf; pLeaf = CFGMR3GetNextValue(pLeaf))
2777 {
2778 switch (CFGMR3GetValueType(pLeaf))
2779 {
2780 case CFGMVALUETYPE_INTEGER:
2781 pHlp->pfnPrintf(pHlp, " %-*s <integer> = %#018llx (%lld)\n", (int)cchMax, pLeaf->szName, pLeaf->Value.Integer.u64, pLeaf->Value.Integer.u64);
2782 break;
2783
2784 case CFGMVALUETYPE_STRING:
2785 pHlp->pfnPrintf(pHlp, " %-*s <string> = \"%s\" (cb=%zu)\n", (int)cchMax, pLeaf->szName, pLeaf->Value.String.psz, pLeaf->Value.String.cb);
2786 break;
2787
2788 case CFGMVALUETYPE_BYTES:
2789 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);
2790 break;
2791
2792 default:
2793 AssertMsgFailed(("bad leaf!\n"));
2794 break;
2795 }
2796 }
2797 pHlp->pfnPrintf(pHlp, "\n");
2798
2799 /*
2800 * Children.
2801 */
2802 for (PCFGMNODE pChild = CFGMR3GetFirstChild(pRoot); pChild; pChild = CFGMR3GetNextChild(pChild))
2803 {
2804 Assert(pChild->pNext != pChild);
2805 Assert(pChild->pPrev != pChild);
2806 Assert(pChild->pPrev != pChild->pNext || !pChild->pPrev);
2807 Assert(pChild->pFirstChild != pChild);
2808 Assert(pChild->pParent != pChild);
2809 cfgmR3Dump(pChild, iLevel + 1, pHlp);
2810 }
2811}
2812
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use