VirtualBox

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

Last change on this file since 13840 was 13840, checked in by vboxsync, 16 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette