VirtualBox

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

Last change on this file since 44397 was 44387, checked in by vboxsync, 12 years ago

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

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