VirtualBox

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

Last change on this file since 8217 was 8155, checked in by vboxsync, 17 years ago

The Big Sun Rebranding Header Change
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 57.2 KB
Line 
1/* $Id: CFGM.cpp 8155 2008-04-18 15:16:47Z vboxsync $ */
2/** @file
3 * CFGM - Configuration Manager.
4 *
5 * This is the main file of the \ref pg_cfgm "CFGM (Configuration Manager)".
6 */
7
8/*
9 * Copyright (C) 2006-2007 Sun Microsystems, Inc.
10 *
11 * This file is part of VirtualBox Open Source Edition (OSE), as
12 * available from http://www.virtualbox.org. This file is free software;
13 * you can redistribute it and/or modify it under the terms of the GNU
14 * General Public License (GPL) as published by the Free Software
15 * Foundation, in version 2 as it comes in the "COPYING" file of the
16 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18 *
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
20 * Clara, CA 95054 USA or visit http://www.sun.com if you need
21 * additional information or have any questions.
22 */
23
24/** @page pg_cfgm CFGM - The Configuration Manager
25 *
26 * The configuration manager will load and keep the configuration of a VM
27 * handy (thru query interface) while the VM is running. The VM properties
28 * are organized in a tree and individual nodes can be accessed by normal
29 * path walking.
30 *
31 * Exactly how the CFGM obtains the configuration is specific to the build.
32 * The default for a full build is to query it thru the IMachine interface and
33 * applies it onto a default setup. It's necessary to have a default in the
34 * bottom of this because the IMachine interface doesn't provide all the
35 * required details.
36 *
37 * Devices are given their own subtree where they are protected from accessing
38 * information of any parents. The exported PDM callback interfaces makes sure
39 * of this.
40 *
41 * Validating of the data obtained, except for validation of the primitive type,
42 * is all up to the user. The CFGM user is concidered in a better position to
43 * know the validation rules of the individual properties.
44 *
45 *
46 * @section sec_cfgm_primitives Data Primitives
47 *
48 * CFGM supports the following data primitives:
49 * - Integers. Representation is signed 64-bit. Boolean, unsigned and
50 * small integers are all represented using this primitive.
51 * - Zero terminated character strings. As everywhere else
52 * strings are UTF-8.
53 * - Variable length byte strings. This can be used to get/put binary
54 * objects.
55 *
56 */
57
58
59/*******************************************************************************
60* Header Files *
61*******************************************************************************/
62#define LOG_GROUP LOG_GROUP_CFGM
63#include <VBox/cfgm.h>
64#include <VBox/dbgf.h>
65#include <VBox/mm.h>
66#include "CFGMInternal.h"
67#include <VBox/vm.h>
68#include <VBox/err.h>
69
70#include <VBox/log.h>
71#include <iprt/assert.h>
72#include <iprt/string.h>
73#include <iprt/uuid.h>
74
75
76/*******************************************************************************
77* Internal Functions *
78*******************************************************************************/
79static int cfgmR3CreateDefault(PVM pVM);
80static void cfgmR3DumpPath(PCFGMNODE pNode, PCDBGFINFOHLP pHlp);
81static void cfgmR3Dump(PCFGMNODE pRoot, unsigned iLevel, PCDBGFINFOHLP pHlp);
82static DECLCALLBACK(void) cfgmR3Info(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
83static int cfgmR3ResolveNode(PCFGMNODE pNode, const char *pszPath, PCFGMNODE *ppChild);
84static int cfgmR3ResolveLeaf(PCFGMNODE pNode, const char *pszName, PCFGMLEAF *ppLeaf);
85static int cfgmR3InsertLeaf(PCFGMNODE pNode, const char *pszName, PCFGMLEAF *ppLeaf);
86static void cfgmR3RemoveLeaf(PCFGMNODE pNode, PCFGMLEAF pLeaf);
87static void cfgmR3FreeValue(PCFGMLEAF pLeaf);
88
89
90
91/**
92 * Constructs the configuration for the VM.
93 *
94 * @returns VBox status code.
95 * @param pVM Pointer to VM which configuration has not yet been loaded.
96 * @param pfnCFGMConstructor Pointer to callback function for constructing the VM configuration tree.
97 * This is called in the EM.
98 * @param pvUser The user argument passed to pfnCFGMConstructor.
99 */
100CFGMR3DECL(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.offVM = RT_OFFSETOF(VM, cfgm);
108 pVM->cfgm.s.pRoot = NULL;
109
110 /*
111 * Register DBGF into item.
112 */
113 int rc = DBGFR3InfoRegisterInternal(pVM, "cfgm", "Dumps a part of the CFGM tree. The argument indicates where to start.", cfgmR3Info);
114 AssertRCReturn(rc,rc);
115
116 /*
117 * Create the configuration tree.
118 */
119 if (pfnCFGMConstructor)
120 {
121 /*
122 * Root Node.
123 */
124 PCFGMNODE pRoot = (PCFGMNODE)MMR3HeapAllocZ(pVM, MM_TAG_CFGM, sizeof(*pRoot));
125 if (!pRoot)
126 return VERR_NO_MEMORY;
127 pRoot->pVM = pVM;
128 pRoot->cchName = 0;
129 pVM->cfgm.s.pRoot = pRoot;
130
131 /*
132 * Call the constructor.
133 */
134 rc = pfnCFGMConstructor(pVM, pvUser);
135 }
136 else
137 rc = cfgmR3CreateDefault(pVM);
138 if (VBOX_SUCCESS(rc))
139 {
140 Log(("CFGMR3Init: Successfully constructed the configuration\n"));
141 CFGMR3Dump(CFGMR3GetRoot(pVM));
142
143 }
144 else
145 NoDmik(AssertMsgFailed(("Constructor failed with rc=%Vrc pfnCFGMConstructor=%p\n", rc, pfnCFGMConstructor)));
146
147 return rc;
148}
149
150
151/**
152 * Terminates the configuration manager.
153 *
154 * @returns VBox status code.
155 * @param pVM VM handle.
156 */
157CFGMR3DECL(int) CFGMR3Term(PVM pVM)
158{
159 CFGMR3RemoveNode(pVM->cfgm.s.pRoot);
160 return 0;
161}
162
163
164/**
165 * Gets the root node for the VM.
166 *
167 * @returns Pointer to root node.
168 * @param pVM VM handle.
169 */
170CFGMR3DECL(PCFGMNODE) CFGMR3GetRoot(PVM pVM)
171{
172 return pVM->cfgm.s.pRoot;
173}
174
175
176/**
177 * Gets the parent of a CFGM node.
178 *
179 * @returns Pointer to the parent node.
180 * @returns NULL if pNode is Root or pNode is the start of a
181 * restricted subtree (use CFGMr3GetParentEx() for that).
182 *
183 * @param pNode The node which parent we query.
184 */
185CFGMR3DECL(PCFGMNODE) CFGMR3GetParent(PCFGMNODE pNode)
186{
187 if (pNode && !pNode->fRestrictedRoot)
188 return pNode->pParent;
189 return NULL;
190}
191
192
193/**
194 * Gets the parent of a CFGM node.
195 *
196 * @returns Pointer to the parent node.
197 * @returns NULL if pNode is Root or pVM is not correct.
198 *
199 * @param pVM The VM handle, used as token that the caller is trusted.
200 * @param pNode The node which parent we query.
201 */
202CFGMR3DECL(PCFGMNODE) CFGMR3GetParentEx(PVM pVM, PCFGMNODE pNode)
203{
204 if (pNode && pNode->pVM == pVM)
205 return pNode->pParent;
206 return NULL;
207}
208
209
210/**
211 * Query a child node.
212 *
213 * @returns Pointer to the specified node.
214 * @returns NULL if node was not found or pNode is NULL.
215 * @param pNode Node pszPath is relative to.
216 * @param pszPath Path to the child node or pNode.
217 * It's good style to end this with '/'.
218 */
219CFGMR3DECL(PCFGMNODE) CFGMR3GetChild(PCFGMNODE pNode, const char *pszPath)
220{
221 PCFGMNODE pChild;
222 int rc = cfgmR3ResolveNode(pNode, pszPath, &pChild);
223 if (VBOX_SUCCESS(rc))
224 return pChild;
225 return NULL;
226}
227
228
229/**
230 * Query a child node by a format string.
231 *
232 * @returns Pointer to the specified node.
233 * @returns NULL if node was not found or pNode is NULL.
234 * @param pNode Node pszPath is relative to.
235 * @param pszPathFormat Path to the child node or pNode.
236 * It's good style to end this with '/'.
237 * @param ... Arguments to pszPathFormat.
238 */
239CFGMR3DECL(PCFGMNODE) CFGMR3GetChildF(PCFGMNODE pNode, const char *pszPathFormat, ...)
240{
241 va_list Args;
242 va_start(Args, pszPathFormat);
243 PCFGMNODE pRet = CFGMR3GetChildFV(pNode, pszPathFormat, Args);
244 va_end(Args);
245 return pRet;
246}
247
248
249/**
250 * Query a child node by a format string.
251 *
252 * @returns Pointer to the specified node.
253 * @returns NULL if node was not found or pNode is NULL.
254 * @param pNode Node pszPath is relative to.
255 * @param pszPathFormat Path to the child node or pNode.
256 * It's good style to end this with '/'.
257 * @param Args Arguments to pszPathFormat.
258 */
259CFGMR3DECL(PCFGMNODE) CFGMR3GetChildFV(PCFGMNODE pNode, const char *pszPathFormat, va_list Args)
260{
261 char *pszPath;
262 RTStrAPrintfV(&pszPath, pszPathFormat, Args);
263 if (pszPath)
264 {
265 PCFGMNODE pChild;
266 int rc = cfgmR3ResolveNode(pNode, pszPath, &pChild);
267 if (VBOX_SUCCESS(rc))
268 return pChild;
269 RTStrFree(pszPath);
270 }
271 return NULL;
272}
273
274
275/**
276 * Gets the first child node.
277 * Use this to start an enumeration of child nodes.
278 *
279 * @returns Pointer to the first child.
280 * @returns NULL if no children.
281 * @param pNode Node to enumerate children for.
282 */
283CFGMR3DECL(PCFGMNODE) CFGMR3GetFirstChild(PCFGMNODE pNode)
284{
285 return pNode ? pNode->pFirstChild : NULL;
286}
287
288
289/**
290 * Gets the next sibling node.
291 * Use this to continue an enumeration.
292 *
293 * @returns Pointer to the first child.
294 * @returns NULL if no children.
295 * @param pCur Node to returned by a call to CFGMR3GetFirstChild()
296 * or successive calls to this function.
297 */
298CFGMR3DECL(PCFGMNODE) CFGMR3GetNextChild(PCFGMNODE pCur)
299{
300 return pCur ? pCur->pNext : NULL;
301}
302
303
304/**
305 * Gets the name of the current node.
306 * (Needed for enumeration.)
307 *
308 * @returns VBox status code.
309 * @param pCur Node to returned by a call to CFGMR3GetFirstChild()
310 * or successive calls to CFGMR3GetNextChild().
311 * @param pszName Where to store the node name.
312 * @param cchName Size of the buffer pointed to by pszName (with terminator).
313 */
314CFGMR3DECL(int) CFGMR3GetName(PCFGMNODE pCur, char *pszName, size_t cchName)
315{
316 int rc;
317 if (pCur)
318 {
319 if (cchName > pCur->cchName)
320 {
321 rc = VINF_SUCCESS;
322 memcpy(pszName, pCur->szName, pCur->cchName + 1);
323 }
324 else
325 rc = VERR_CFGM_NOT_ENOUGH_SPACE;
326 }
327 else
328 rc = VERR_CFGM_NO_NODE;
329 return rc;
330}
331
332
333/**
334 * Gets the length of the current node's name.
335 * (Needed for enumeration.)
336 *
337 * @returns Node name length in bytes including the terminating null char.
338 * @returns 0 if pCur is NULL.
339 * @param pCur Node to returned by a call to CFGMR3GetFirstChild()
340 * or successive calls to CFGMR3GetNextChild().
341 */
342CFGMR3DECL(int) CFGMR3GetNameLen(PCFGMNODE pCur)
343{
344 return pCur ? pCur->cchName + 1 : 0;
345}
346
347
348/**
349 * Validates that the child nodes are within a set of valid names.
350 *
351 * @returns true if all names are found in pszzAllowed.
352 * @returns false if not.
353 * @param pNode The node which children should be examined.
354 * @param pszzValid List of valid names separated by '\\0' and ending with
355 * a double '\\0'.
356 */
357CFGMR3DECL(bool) CFGMR3AreChildrenValid(PCFGMNODE pNode, const char *pszzValid)
358{
359 if (pNode)
360 {
361 for (PCFGMNODE pChild = pNode->pFirstChild; pChild; pChild = pChild->pNext)
362 {
363 /* search pszzValid for the name */
364 const char *psz = pszzValid;
365 while (*psz)
366 {
367 size_t cch = strlen(psz);
368 if ( cch == pChild->cchName
369 && !memcmp(psz, pChild->szName, cch))
370 break;
371
372 /* next */
373 psz += cch + 1;
374 }
375
376 /* if at end of pszzValid we didn't find it => failure */
377 if (!*psz)
378 {
379 AssertMsgFailed(("Couldn't find '%s' in the valid values\n", pChild->szName));
380 return false;
381 }
382 }
383 }
384
385 /* all ok. */
386 return true;
387}
388
389
390/**
391 * Gets the first value of a node.
392 * Use this to start an enumeration of values.
393 *
394 * @returns Pointer to the first value.
395 * @param pCur The node (Key) which values to enumerate.
396 */
397CFGMR3DECL(PCFGMLEAF) CFGMR3GetFirstValue(PCFGMNODE pCur)
398{
399 return pCur ? pCur->pFirstLeaf : NULL;
400}
401
402/**
403 * Gets the next value in enumeration.
404 *
405 * @returns Pointer to the next value.
406 * @param pCur The current value as returned by this function or CFGMR3GetFirstValue().
407 */
408CFGMR3DECL(PCFGMLEAF) CFGMR3GetNextValue(PCFGMLEAF pCur)
409{
410 return pCur ? pCur->pNext : NULL;
411}
412
413/**
414 * Get the value name.
415 * (Needed for enumeration.)
416 *
417 * @returns VBox status code.
418 * @param pCur Value returned by a call to CFGMR3GetFirstValue()
419 * or successive calls to CFGMR3GetNextValue().
420 * @param pszName Where to store the value name.
421 * @param cchName Size of the buffer pointed to by pszName (with terminator).
422 */
423CFGMR3DECL(int) CFGMR3GetValueName(PCFGMLEAF pCur, char *pszName, size_t cchName)
424{
425 int rc;
426 if (pCur)
427 {
428 if (cchName > pCur->cchName)
429 {
430 rc = VINF_SUCCESS;
431 memcpy(pszName, pCur->szName, pCur->cchName + 1);
432 }
433 else
434 rc = VERR_CFGM_NOT_ENOUGH_SPACE;
435 }
436 else
437 rc = VERR_CFGM_NO_NODE;
438 return rc;
439}
440
441
442/**
443 * Gets the length of the current node's name.
444 * (Needed for enumeration.)
445 *
446 * @returns Value name length in bytes including the terminating null char.
447 * @returns 0 if pCur is NULL.
448 * @param pCur Value returned by a call to CFGMR3GetFirstValue()
449 * or successive calls to CFGMR3GetNextValue().
450 */
451CFGMR3DECL(int) CFGMR3GetValueNameLen(PCFGMLEAF pCur)
452{
453 return pCur ? pCur->cchName + 1 : 0;
454}
455
456/**
457 * Gets the value type.
458 * (For enumeration.)
459 *
460 * @returns VBox status code.
461 * @param pCur Value returned by a call to CFGMR3GetFirstValue()
462 * or successive calls to CFGMR3GetNextValue().
463 */
464CFGMR3DECL(CFGMVALUETYPE) CFGMR3GetValueType(PCFGMLEAF pCur)
465{
466 Assert(pCur);
467 return pCur->enmType;
468}
469
470
471/**
472 * Validates that the values are within a set of valid names.
473 *
474 * @returns true if all names are found in pszzAllowed.
475 * @returns false if not.
476 * @param pNode The node which values should be examined.
477 * @param pszzValid List of valid names separated by '\\0' and ending with
478 * a double '\\0'.
479 */
480CFGMR3DECL(bool) CFGMR3AreValuesValid(PCFGMNODE pNode, const char *pszzValid)
481{
482 if (pNode)
483 {
484 for (PCFGMLEAF pLeaf = pNode->pFirstLeaf; pLeaf; pLeaf = pLeaf->pNext)
485 {
486 /* search pszzValid for the name */
487 const char *psz = pszzValid;
488 while (*psz)
489 {
490 size_t cch = strlen(psz);
491 if ( cch == pLeaf->cchName
492 && !memcmp(psz, pLeaf->szName, cch))
493 break;
494
495 /* next */
496 psz += cch + 1;
497 }
498
499 /* if at end of pszzValid we didn't find it => failure */
500 if (!*psz)
501 {
502 AssertMsgFailed(("Couldn't find '%s' in the valid values\n", pLeaf->szName));
503 return false;
504 }
505 }
506 }
507
508 /* all ok. */
509 return true;
510}
511
512
513
514/**
515 * Query value type.
516 *
517 * @returns VBox status code.
518 * @param pNode Which node to search for pszName in.
519 * @param pszName Name of an integer value.
520 * @param penmType Where to store the type.
521 */
522CFGMR3DECL(int) CFGMR3QueryType(PCFGMNODE pNode, const char *pszName, PCFGMVALUETYPE penmType)
523{
524 PCFGMLEAF pLeaf;
525 int rc = cfgmR3ResolveLeaf(pNode, pszName, &pLeaf);
526 if (VBOX_SUCCESS(rc))
527 {
528 if (penmType)
529 *penmType = pLeaf->enmType;
530 }
531 return rc;
532}
533
534
535/**
536 * Query value size.
537 * This works on all types of values.
538 *
539 * @returns VBox status code.
540 * @param pNode Which node to search for pszName in.
541 * @param pszName Name of an integer value.
542 * @param pcb Where to store the value size.
543 */
544CFGMR3DECL(int) CFGMR3QuerySize(PCFGMNODE pNode, const char *pszName, size_t *pcb)
545{
546 PCFGMLEAF pLeaf;
547 int rc = cfgmR3ResolveLeaf(pNode, pszName, &pLeaf);
548 if (VBOX_SUCCESS(rc))
549 {
550 switch (pLeaf->enmType)
551 {
552 case CFGMVALUETYPE_INTEGER:
553 *pcb = sizeof(pLeaf->Value.Integer.u64);
554 break;
555
556 case CFGMVALUETYPE_STRING:
557 *pcb = pLeaf->Value.String.cch;
558 break;
559
560 case CFGMVALUETYPE_BYTES:
561 *pcb = pLeaf->Value.Bytes.cb;
562 break;
563
564 default:
565 rc = VERR_INTERNAL_ERROR;
566 AssertMsgFailed(("Invalid value type %d\n", pLeaf->enmType));
567 break;
568 }
569 }
570 return rc;
571}
572
573
574/**
575 * Query integer value.
576 *
577 * @returns VBox status code.
578 * @param pNode Which node to search for pszName in.
579 * @param pszName Name of an integer value.
580 * @param pu64 Where to store the integer value.
581 */
582CFGMR3DECL(int) CFGMR3QueryInteger(PCFGMNODE pNode, const char *pszName, uint64_t *pu64)
583{
584 PCFGMLEAF pLeaf;
585 int rc = cfgmR3ResolveLeaf(pNode, pszName, &pLeaf);
586 if (VBOX_SUCCESS(rc))
587 {
588 if (pLeaf->enmType == CFGMVALUETYPE_INTEGER)
589 *pu64 = pLeaf->Value.Integer.u64;
590 else
591 rc = VERR_CFGM_NOT_INTEGER;
592 }
593 return rc;
594}
595
596
597/**
598 * Query zero terminated character value.
599 *
600 * @returns VBox status code.
601 * @param pNode Which node to search for pszName in.
602 * @param pszName Name of a zero terminate character value.
603 * @param pszString Where to store the string.
604 * @param cchString Size of the string buffer. (Includes terminator.)
605 */
606CFGMR3DECL(int) CFGMR3QueryString(PCFGMNODE pNode, const char *pszName, char *pszString, size_t cchString)
607{
608 PCFGMLEAF pLeaf;
609 int rc = cfgmR3ResolveLeaf(pNode, pszName, &pLeaf);
610 if (VBOX_SUCCESS(rc))
611 {
612 if (pLeaf->enmType == CFGMVALUETYPE_STRING)
613 {
614 if (cchString >= pLeaf->Value.String.cch)
615 {
616 memcpy(pszString, pLeaf->Value.String.psz, pLeaf->Value.String.cch);
617 memset(pszString + pLeaf->Value.String.cch, 0, cchString - pLeaf->Value.String.cch);
618 }
619 else
620 rc = VERR_CFGM_NOT_ENOUGH_SPACE;
621 }
622 else
623 rc = VERR_CFGM_NOT_STRING;
624 }
625 return rc;
626}
627
628
629/**
630 * Query byte string value.
631 *
632 * @returns VBox status code.
633 * @param pNode Which node to search for pszName in.
634 * @param pszName Name of a byte string value.
635 * @param pvData Where to store the binary data.
636 * @param cbData Size of buffer pvData points too.
637 */
638CFGMR3DECL(int) CFGMR3QueryBytes(PCFGMNODE pNode, const char *pszName, void *pvData, size_t cbData)
639{
640 PCFGMLEAF pLeaf;
641 int rc = cfgmR3ResolveLeaf(pNode, pszName, &pLeaf);
642 if (VBOX_SUCCESS(rc))
643 {
644 if (pLeaf->enmType == CFGMVALUETYPE_BYTES)
645 {
646 if (cbData >= pLeaf->Value.Bytes.cb)
647 {
648 memcpy(pvData, pLeaf->Value.Bytes.pau8, pLeaf->Value.Bytes.cb);
649 memset((char *)pvData + pLeaf->Value.Bytes.cb, 0, cbData - pLeaf->Value.Bytes.cb);
650 }
651 else
652 rc = VERR_CFGM_NOT_ENOUGH_SPACE;
653 }
654 else
655 rc = VERR_CFGM_NOT_BYTES;
656 }
657 return rc;
658}
659
660
661/**
662 * Creates the default configuration.
663 * This assumes an empty tree.
664 *
665 * @returns VBox status code.
666 * @param pVM VM handle.
667 */
668static int cfgmR3CreateDefault(PVM pVM)
669{
670 int rc;
671 int rcAll = VINF_SUCCESS;
672#define UPDATERC() do { if (VBOX_FAILURE(rc) && VBOX_SUCCESS(rcAll)) rcAll = rc; } while (0)
673
674 /*
675 * Root level.
676 */
677 PCFGMNODE pRoot = (PCFGMNODE)MMR3HeapAllocZ(pVM, MM_TAG_CFGM, sizeof(*pRoot));
678 if (!pRoot)
679 return VERR_NO_MEMORY;
680 pRoot->pVM = pVM;
681 pRoot->cchName = 0;
682
683 Assert(!pVM->cfgm.s.pRoot);
684 pVM->cfgm.s.pRoot = pRoot;
685
686 /*
687 * Create VM default values.
688 */
689 rc = CFGMR3InsertString(pRoot, "Name", "Default VM");
690 UPDATERC();
691 rc = CFGMR3InsertInteger(pRoot, "RamSize", 128 * _1M);
692 UPDATERC();
693 rc = CFGMR3InsertInteger(pRoot, "TimerMillies", 10);
694 UPDATERC();
695 rc = CFGMR3InsertInteger(pRoot, "RawR3Enabled", 1);
696 UPDATERC();
697 /** @todo CFGM Defaults: RawR0, PATMEnabled and CASMEnabled needs attention later. */
698 rc = CFGMR3InsertInteger(pRoot, "RawR0Enabled", 1);
699 UPDATERC();
700 rc = CFGMR3InsertInteger(pRoot, "PATMEnabled", 1);
701 UPDATERC();
702 rc = CFGMR3InsertInteger(pRoot, "CSAMEnabled", 1);
703 UPDATERC();
704
705 /*
706 * PDM.
707 */
708 PCFGMNODE pPdm;
709 rc = CFGMR3InsertNode(pRoot, "PDM", &pPdm);
710 UPDATERC();
711 PCFGMNODE pDevices = NULL;
712 rc = CFGMR3InsertNode(pPdm, "Devices", &pDevices);
713 UPDATERC();
714 rc = CFGMR3InsertInteger(pDevices, "LoadBuiltin", 1); /* boolean */
715 UPDATERC();
716 PCFGMNODE pDrivers = NULL;
717 rc = CFGMR3InsertNode(pPdm, "Drivers", &pDrivers);
718 UPDATERC();
719 rc = CFGMR3InsertInteger(pDrivers, "LoadBuiltin", 1); /* boolean */
720 UPDATERC();
721
722
723 /*
724 * Devices
725 */
726 pDevices = NULL;
727 rc = CFGMR3InsertNode(pRoot, "Devices", &pDevices);
728 UPDATERC();
729 /* device */
730 PCFGMNODE pDev = NULL;
731 PCFGMNODE pInst = NULL;
732 PCFGMNODE pCfg = NULL;
733#if 0
734 PCFGMNODE pLunL0 = NULL;
735 PCFGMNODE pLunL1 = NULL;
736#endif
737
738 /*
739 * PC Arch.
740 */
741 rc = CFGMR3InsertNode(pDevices, "pcarch", &pDev);
742 UPDATERC();
743 rc = CFGMR3InsertNode(pDev, "0", &pInst);
744 UPDATERC();
745 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */
746 UPDATERC();
747 rc = CFGMR3InsertNode(pInst, "Config", &pCfg);
748 UPDATERC();
749
750 /*
751 * PC Bios.
752 */
753 rc = CFGMR3InsertNode(pDevices, "pcbios", &pDev);
754 UPDATERC();
755 rc = CFGMR3InsertNode(pDev, "0", &pInst);
756 UPDATERC();
757 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */
758 UPDATERC();
759 rc = CFGMR3InsertNode(pInst, "Config", &pCfg);
760 UPDATERC();
761 rc = CFGMR3InsertInteger(pCfg, "RamSize", 128 * _1M);
762 UPDATERC();
763 rc = CFGMR3InsertString(pCfg, "BootDevice0", "IDE");
764 UPDATERC();
765 rc = CFGMR3InsertString(pCfg, "BootDevice1", "NONE");
766 UPDATERC();
767 rc = CFGMR3InsertString(pCfg, "BootDevice2", "NONE");
768 UPDATERC();
769 rc = CFGMR3InsertString(pCfg, "BootDevice3", "NONE");
770 UPDATERC();
771 rc = CFGMR3InsertString(pCfg, "HardDiskDevice", "piix3ide");
772 UPDATERC();
773 rc = CFGMR3InsertString(pCfg, "FloppyDevice", "");
774 UPDATERC();
775 RTUUID Uuid;
776 RTUuidClear(&Uuid);
777 rc = CFGMR3InsertBytes(pCfg, "UUID", &Uuid, sizeof(Uuid));
778 UPDATERC();
779
780 /*
781 * PCI bus.
782 */
783 rc = CFGMR3InsertNode(pDevices, "pci", &pDev); /* piix3 */
784 UPDATERC();
785 rc = CFGMR3InsertNode(pDev, "0", &pInst);
786 UPDATERC();
787 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */
788 UPDATERC();
789 rc = CFGMR3InsertNode(pInst, "Config", &pCfg);
790 UPDATERC();
791
792 /*
793 * PS/2 keyboard & mouse
794 */
795 rc = CFGMR3InsertNode(pDevices, "pckbd", &pDev);
796 UPDATERC();
797 rc = CFGMR3InsertNode(pDev, "0", &pInst);
798 UPDATERC();
799 rc = CFGMR3InsertNode(pInst, "Config", &pCfg);
800 UPDATERC();
801#if 0
802 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0);
803 UPDATERC();
804 rc = CFGMR3InsertString(pLunL0, "Driver", "KeyboardQueue");
805 UPDATERC();
806 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg);
807 UPDATERC();
808 rc = CFGMR3InsertInteger(pCfg, "QueueSize", 64);
809 UPDATERC();
810 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL1);
811 UPDATERC();
812 rc = CFGMR3InsertString(pLunL1, "Driver", "MainKeyboard");
813 UPDATERC();
814 rc = CFGMR3InsertNode(pLunL1, "Config", &pCfg);
815 UPDATERC();
816#endif
817#if 0
818 rc = CFGMR3InsertNode(pInst, "LUN#1", &pLunL0);
819 UPDATERC();
820 rc = CFGMR3InsertString(pLunL0, "Driver", "MouseQueue");
821 UPDATERC();
822 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg);
823 UPDATERC();
824 rc = CFGMR3InsertInteger(pCfg, "QueueSize", 128);
825 UPDATERC();
826 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL1);
827 UPDATERC();
828 rc = CFGMR3InsertString(pLunL1, "Driver", "MainMouse");
829 UPDATERC();
830 rc = CFGMR3InsertNode(pLunL1, "Config", &pCfg);
831 UPDATERC();
832#endif
833
834 /*
835 * i8254 Programmable Interval Timer And Dummy Speaker
836 */
837 rc = CFGMR3InsertNode(pDevices, "i8254", &pDev);
838 UPDATERC();
839 rc = CFGMR3InsertNode(pDev, "0", &pInst);
840 UPDATERC();
841#ifdef DEBUG
842 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */
843 UPDATERC();
844#endif
845 rc = CFGMR3InsertNode(pInst, "Config", &pCfg);
846 UPDATERC();
847
848 /*
849 * i8259 Programmable Interrupt Controller.
850 */
851 rc = CFGMR3InsertNode(pDevices, "i8259", &pDev);
852 UPDATERC();
853 rc = CFGMR3InsertNode(pDev, "0", &pInst);
854 UPDATERC();
855 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */
856 UPDATERC();
857 rc = CFGMR3InsertNode(pInst, "Config", &pCfg);
858 UPDATERC();
859
860 /*
861 * RTC MC146818.
862 */
863 rc = CFGMR3InsertNode(pDevices, "mc146818", &pDev);
864 UPDATERC();
865 rc = CFGMR3InsertNode(pDev, "0", &pInst);
866 UPDATERC();
867 rc = CFGMR3InsertNode(pInst, "Config", &pCfg);
868 UPDATERC();
869
870 /*
871 * VGA.
872 */
873 rc = CFGMR3InsertNode(pDevices, "vga", &pDev);
874 UPDATERC();
875 rc = CFGMR3InsertNode(pDev, "0", &pInst);
876 UPDATERC();
877 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */
878 UPDATERC();
879 rc = CFGMR3InsertNode(pInst, "Config", &pCfg);
880 UPDATERC();
881 rc = CFGMR3InsertInteger(pCfg, "VRamSize", 4 * _1M);
882 UPDATERC();
883
884 /* Bios logo. */
885 rc = CFGMR3InsertInteger(pCfg, "FadeIn", 1);
886 UPDATERC();
887 rc = CFGMR3InsertInteger(pCfg, "FadeOut", 1);
888 UPDATERC();
889 rc = CFGMR3InsertInteger(pCfg, "LogoTime", 0);
890 UPDATERC();
891 rc = CFGMR3InsertString(pCfg, "LogoFile", "");
892 UPDATERC();
893
894#if 0
895 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0);
896 UPDATERC();
897 rc = CFGMR3InsertString(pLunL0, "Driver", "MainDisplay");
898 UPDATERC();
899#endif
900
901 /*
902 * IDE controller.
903 */
904 rc = CFGMR3InsertNode(pDevices, "piix3ide", &pDev); /* piix3 */
905 UPDATERC();
906 rc = CFGMR3InsertNode(pDev, "0", &pInst);
907 UPDATERC();
908 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */
909 UPDATERC();
910 rc = CFGMR3InsertNode(pInst, "Config", &pCfg);
911 UPDATERC();
912
913
914
915 /*
916 * ...
917 */
918
919#undef UPDATERC
920 return rcAll;
921}
922
923
924
925
926/**
927 * Resolves a path reference to a child node.
928 *
929 * @returns VBox status code.
930 * @param pNode Which node to search for pszName in.
931 * @param pszPath Path to the child node.
932 * @param ppChild Where to store the pointer to the child node.
933 */
934static int cfgmR3ResolveNode(PCFGMNODE pNode, const char *pszPath, PCFGMNODE *ppChild)
935{
936 if (pNode)
937 {
938 PCFGMNODE pChild = NULL;
939 for (;;)
940 {
941 /* skip leading slashes. */
942 while (*pszPath == '/')
943 pszPath++;
944
945 /* End of path? */
946 if (!*pszPath)
947 {
948 if (!pChild)
949 return VERR_CFGM_INVALID_CHILD_PATH;
950 *ppChild = pChild;
951 return VINF_SUCCESS;
952 }
953
954 /* find end of component. */
955 const char *pszNext = strchr(pszPath, '/');
956 if (!pszNext)
957 pszNext = strchr(pszPath, '\0');
958 RTUINT cchName = pszNext - pszPath;
959
960 /* search child list. */
961 pChild = pNode->pFirstChild;
962 for ( ; pChild; pChild = pChild->pNext)
963 if ( pChild->cchName == cchName
964 && !memcmp(pszPath, pChild->szName, cchName) )
965 break;
966
967 /* if not found, we're done. */
968 if (!pChild)
969 return VERR_CFGM_CHILD_NOT_FOUND;
970
971 /* next iteration */
972 pNode = pChild;
973 pszPath = pszNext;
974 }
975
976 /* won't get here */
977 }
978 else
979 return VERR_CFGM_NO_PARENT;
980}
981
982
983/**
984 * Resolves a path reference to a child node.
985 *
986 * @returns VBox status code.
987 * @param pNode Which node to search for pszName in.
988 * @param pszName Name of a byte string value.
989 * @param ppLeaf Where to store the pointer to the leaf node.
990 */
991static int cfgmR3ResolveLeaf(PCFGMNODE pNode, const char *pszName, PCFGMLEAF *ppLeaf)
992{
993 int rc;
994 if (pNode)
995 {
996 RTUINT cchName = strlen(pszName);
997 PCFGMLEAF pLeaf = pNode->pFirstLeaf;
998 while (pLeaf)
999 {
1000 if ( cchName == pLeaf->cchName
1001 && !memcmp(pszName, pLeaf->szName, cchName) )
1002 {
1003 *ppLeaf = pLeaf;
1004 return VINF_SUCCESS;
1005 }
1006
1007 /* next */
1008 pLeaf = pLeaf->pNext;
1009 }
1010 rc = VERR_CFGM_VALUE_NOT_FOUND;
1011 }
1012 else
1013 rc = VERR_CFGM_NO_PARENT;
1014 return rc;
1015}
1016
1017
1018
1019/**
1020 * Creates a CFGM tree.
1021 *
1022 * This is intended for creating device/driver configs can be
1023 * passed around and later attached to the main tree in the
1024 * correct location.
1025 *
1026 * @returns Pointer to the root node.
1027 * @param pVM The VM handle.
1028 */
1029CFGMR3DECL(PCFGMNODE) CFGMR3CreateTree(PVM pVM)
1030{
1031 PCFGMNODE pNew = (PCFGMNODE)MMR3HeapAlloc(pVM, MM_TAG_CFGM, sizeof(*pNew));
1032 if (pNew)
1033 {
1034 pNew->pPrev = NULL;
1035 pNew->pNext = NULL;
1036 pNew->pParent = NULL;
1037 pNew->pFirstChild = NULL;
1038 pNew->pFirstLeaf = NULL;
1039 pNew->pVM = pVM;
1040 pNew->fRestrictedRoot = false;
1041 pNew->cchName = 0;
1042 pNew->szName[0] = 0;
1043 }
1044 return pNew;
1045}
1046
1047
1048/**
1049 * Insert subtree.
1050 *
1051 * This function inserts (no duplication) a tree created by CFGMR3CreateTree()
1052 * into the main tree.
1053 *
1054 * The root node of the inserted subtree will need to be reallocated, which
1055 * effectually means that the passed in pSubTree handle becomes invalid
1056 * upon successful return. Use the value returned in ppChild instead
1057 * of pSubTree.
1058 *
1059 * @returns VBox status code.
1060 * @returns VERR_CFGM_NODE_EXISTS if the final child node name component exists.
1061 * @param pNode Parent node.
1062 * @param pszName Name or path of the new child node.
1063 * @param pSubTree The subtree to insert. Must be returned by CFGMR3CreateTree().
1064 * @param ppChild Where to store the address of the new child node. (optional)
1065 */
1066CFGMR3DECL(int) CFGMR3InsertSubTree(PCFGMNODE pNode, const char *pszName, PCFGMNODE pSubTree, PCFGMNODE *ppChild)
1067{
1068 /*
1069 * Validate input.
1070 */
1071 AssertPtrReturn(pSubTree, VERR_INVALID_POINTER);
1072 AssertReturn(!pSubTree->pParent, VERR_INVALID_PARAMETER);
1073 AssertReturn(pSubTree->pVM, VERR_INVALID_PARAMETER);
1074 AssertReturn(pSubTree->pParent != pSubTree->pVM->cfgm.s.pRoot, VERR_INVALID_PARAMETER);
1075 Assert(!pSubTree->pNext);
1076 Assert(!pSubTree->pPrev);
1077
1078 /*
1079 * Use CFGMR3InsertNode to create a new node and then
1080 * re-attach the children and leafs of the subtree to it.
1081 */
1082 PCFGMNODE pNewChild;
1083 int rc = CFGMR3InsertNode(pNode, pszName, &pNewChild);
1084 if (RT_SUCCESS(rc))
1085 {
1086 Assert(!pNewChild->pFirstChild);
1087 pNewChild->pFirstChild = pSubTree->pFirstChild;
1088 Assert(!pNewChild->pFirstLeaf);
1089 pNewChild->pFirstLeaf = pSubTree->pFirstLeaf;
1090 if (ppChild)
1091 *ppChild = pNewChild;
1092
1093 /* free the old subtree root */
1094 pSubTree->pVM = NULL;
1095 pSubTree->pFirstLeaf = NULL;
1096 pSubTree->pFirstChild = NULL;
1097 MMR3HeapFree(pSubTree);
1098 }
1099 return rc;
1100}
1101
1102
1103/**
1104 * Insert a node.
1105 *
1106 * @returns VBox status code.
1107 * @returns VERR_CFGM_NODE_EXISTS if the final child node name component exists.
1108 * @param pNode Parent node.
1109 * @param pszName Name or path of the new child node.
1110 * @param ppChild Where to store the address of the new child node. (optional)
1111 */
1112CFGMR3DECL(int) CFGMR3InsertNode(PCFGMNODE pNode, const char *pszName, PCFGMNODE *ppChild)
1113{
1114 int rc;
1115 if (pNode)
1116 {
1117 /*
1118 * If given a path we have to deal with it component by compontent.
1119 */
1120 while (*pszName == '/')
1121 pszName++;
1122 if (strchr(pszName, '/'))
1123 {
1124 char *pszDup = RTStrDup(pszName);
1125 if (pszDup)
1126 {
1127 char *psz = pszDup;
1128 for (;;)
1129 {
1130 /* Terminate at '/' and find the next component. */
1131 char *pszNext = strchr(psz, '/');
1132 if (pszNext)
1133 {
1134 *pszNext++ = '\0';
1135 while (*pszNext == '/')
1136 pszNext++;
1137 if (*pszNext == '\0')
1138 pszNext = NULL;
1139 }
1140
1141 /* does it exist? */
1142 PCFGMNODE pChild = CFGMR3GetChild(pNode, psz);
1143 if (!pChild)
1144 {
1145 /* no, insert it */
1146 rc = CFGMR3InsertNode(pNode, psz, &pChild);
1147 if (VBOX_FAILURE(rc))
1148 break;
1149 if (!pszNext)
1150 {
1151 if (ppChild)
1152 *ppChild = pChild;
1153 break;
1154 }
1155
1156 }
1157 /* if last component fail */
1158 else if (!pszNext)
1159 {
1160 rc = VERR_CFGM_NODE_EXISTS;
1161 break;
1162 }
1163
1164 /* next */
1165 pNode = pChild;
1166 psz = pszNext;
1167 }
1168 RTStrFree(pszDup);
1169 }
1170 else
1171 rc = VERR_NO_TMP_MEMORY;
1172 }
1173 /*
1174 * Not multicomponent, just make sure it's a non-zero name.
1175 */
1176 else if (*pszName)
1177 {
1178 /*
1179 * Check if already exists and find last node in chain.
1180 */
1181 size_t cchName = strlen(pszName);
1182 PCFGMNODE pPrev = pNode->pFirstChild;
1183 if (pPrev)
1184 {
1185 for (;; pPrev = pPrev->pNext)
1186 {
1187 if ( cchName == pPrev->cchName
1188 && !memcmp(pszName, pPrev->szName, cchName))
1189 return VERR_CFGM_NODE_EXISTS;
1190 if (!pPrev->pNext)
1191 break;
1192 }
1193 }
1194
1195 /*
1196 * Allocate and init node.
1197 */
1198 PCFGMNODE pNew = (PCFGMNODE)MMR3HeapAlloc(pNode->pVM, MM_TAG_CFGM, sizeof(*pNew) + cchName);
1199 if (pNew)
1200 {
1201 pNew->pParent = pNode;
1202 pNew->pFirstChild = NULL;
1203 pNew->pFirstLeaf = NULL;
1204 pNew->pVM = pNode->pVM;
1205 pNew->fRestrictedRoot = false;
1206 pNew->cchName = cchName;
1207 memcpy(pNew->szName, pszName, cchName + 1);
1208
1209 /*
1210 * Insert into child list.
1211 */
1212 pNew->pNext = NULL;
1213 pNew->pPrev = pPrev;
1214 if (pPrev)
1215 pPrev->pNext = pNew;
1216 else
1217 pNode->pFirstChild = pNew;
1218 if (ppChild)
1219 *ppChild = pNew;
1220 rc = VINF_SUCCESS;
1221 }
1222 else
1223 rc = VERR_NO_MEMORY;
1224 }
1225 else
1226 {
1227 rc = VERR_CFGM_INVALID_NODE_PATH;
1228 AssertMsgFailed(("Invalid path %s\n", pszName));
1229 }
1230 }
1231 else
1232 {
1233 rc = VERR_CFGM_NO_PARENT;
1234 AssertMsgFailed(("No parent! path %s\n", pszName));
1235 }
1236
1237 return rc;
1238}
1239
1240
1241/**
1242 * Insert a node, format string name.
1243 *
1244 * @returns VBox status code.
1245 * @param pNode Parent node.
1246 * @param ppChild Where to store the address of the new child node. (optional)
1247 * @param pszNameFormat Name of or path the new child node.
1248 * @param ... Name format arguments.
1249 */
1250CFGMR3DECL(int) CFGMR3InsertNodeF(PCFGMNODE pNode, PCFGMNODE *ppChild, const char *pszNameFormat, ...)
1251{
1252 va_list Args;
1253 va_start(Args, pszNameFormat);
1254 int rc = CFGMR3InsertNodeFV(pNode, ppChild, pszNameFormat, Args);
1255 va_end(Args);
1256 return rc;
1257}
1258
1259
1260/**
1261 * Insert a node, format string name.
1262 *
1263 * @returns VBox status code.
1264 * @param pNode Parent node.
1265 * @param ppChild Where to store the address of the new child node. (optional)
1266 * @param pszNameFormat Name or path of the new child node.
1267 * @param Args Name format arguments.
1268 */
1269CFGMR3DECL(int) CFGMR3InsertNodeFV(PCFGMNODE pNode, PCFGMNODE *ppChild, const char *pszNameFormat, va_list Args)
1270{
1271 int rc;
1272 char *pszName;
1273 RTStrAPrintfV(&pszName, pszNameFormat, Args);
1274 if (pszName)
1275 {
1276 rc = CFGMR3InsertNode(pNode, pszName, ppChild);
1277 RTStrFree(pszName);
1278 }
1279 else
1280 rc = VERR_NO_MEMORY;
1281 return rc;
1282}
1283
1284
1285/**
1286 * Marks the node as the root of a restricted subtree, i.e. the end of
1287 * a CFGMR3GetParent() journey.
1288 *
1289 * @param pNode The node to mark.
1290 */
1291CFGMR3DECL(void) CFGMR3SetRestrictedRoot(PCFGMNODE pNode)
1292{
1293 if (pNode)
1294 pNode->fRestrictedRoot = true;
1295}
1296
1297
1298/**
1299 * Insert a node.
1300 *
1301 * @returns VBox status code.
1302 * @param pNode Parent node.
1303 * @param pszName Name of the new child node.
1304 * @param ppLeaf Where to store the new leaf.
1305 * The caller must fill in the enmType and Value fields!
1306 */
1307static int cfgmR3InsertLeaf(PCFGMNODE pNode, const char *pszName, PCFGMLEAF *ppLeaf)
1308{
1309 int rc;
1310 if (*pszName)
1311 {
1312 if (pNode)
1313 {
1314 /*
1315 * Check if already exists and find last node in chain.
1316 */
1317 size_t cchName = strlen(pszName);
1318 PCFGMLEAF pPrev = pNode->pFirstLeaf;
1319 if (pPrev)
1320 {
1321 for (;; pPrev = pPrev->pNext)
1322 {
1323 if ( cchName == pPrev->cchName
1324 && !memcmp(pszName, pPrev->szName, cchName))
1325 return VERR_CFGM_LEAF_EXISTS;
1326 if (!pPrev->pNext)
1327 break;
1328 }
1329 }
1330
1331 /*
1332 * Allocate and init node.
1333 */
1334 PCFGMLEAF pNew = (PCFGMLEAF)MMR3HeapAlloc(pNode->pVM, MM_TAG_CFGM, sizeof(*pNew) + cchName);
1335 if (pNew)
1336 {
1337 pNew->cchName = cchName;
1338 memcpy(pNew->szName, pszName, cchName + 1);
1339
1340 /*
1341 * Insert into child list.
1342 */
1343 pNew->pNext = NULL;
1344 pNew->pPrev = pPrev;
1345 if (pPrev)
1346 pPrev->pNext = pNew;
1347 else
1348 pNode->pFirstLeaf = pNew;
1349 *ppLeaf = pNew;
1350 rc = VINF_SUCCESS;
1351 }
1352 else
1353 rc = VERR_NO_MEMORY;
1354 }
1355 else
1356 rc = VERR_CFGM_NO_PARENT;
1357 }
1358 else
1359 rc = VERR_CFGM_INVALID_CHILD_PATH;
1360 return rc;
1361}
1362
1363
1364/**
1365 * Remove a node.
1366 *
1367 * @param pNode Parent node.
1368 */
1369CFGMR3DECL(void) CFGMR3RemoveNode(PCFGMNODE pNode)
1370{
1371 if (pNode)
1372 {
1373 /*
1374 * Free children.
1375 */
1376 while (pNode->pFirstChild)
1377 CFGMR3RemoveNode(pNode->pFirstChild);
1378
1379 /*
1380 * Free leafs.
1381 */
1382 while (pNode->pFirstLeaf)
1383 cfgmR3RemoveLeaf(pNode, pNode->pFirstLeaf);
1384
1385 /*
1386 * Unlink ourselves.
1387 */
1388 if (pNode->pPrev)
1389 pNode->pPrev->pNext = pNode->pNext;
1390 else
1391 {
1392 if (pNode->pParent)
1393 pNode->pParent->pFirstChild = pNode->pNext;
1394 else if (pNode == pNode->pVM->cfgm.s.pRoot) /* might be a different tree */
1395 pNode->pVM->cfgm.s.pRoot = NULL;
1396 }
1397 if (pNode->pNext)
1398 pNode->pNext->pPrev = pNode->pPrev;
1399
1400 /*
1401 * Free ourselves. (bit of paranoia first)
1402 */
1403 pNode->pVM = NULL;
1404 pNode->pNext = NULL;
1405 pNode->pPrev = NULL;
1406 pNode->pParent = NULL;
1407 MMR3HeapFree(pNode);
1408 }
1409}
1410
1411
1412/**
1413 * Removes a leaf.
1414 *
1415 * @param pNode Parent node.
1416 * @param pLeaf Leaf to remove.
1417 */
1418static void cfgmR3RemoveLeaf(PCFGMNODE pNode, PCFGMLEAF pLeaf)
1419{
1420 if (pNode && pLeaf)
1421 {
1422 /*
1423 * Unlink.
1424 */
1425 if (pLeaf->pPrev)
1426 pLeaf->pPrev->pNext = pLeaf->pNext;
1427 else
1428 pNode->pFirstLeaf = pLeaf->pNext;
1429 if (pLeaf->pNext)
1430 pLeaf->pNext->pPrev = pLeaf->pPrev;
1431
1432 /*
1433 * Free value and node.
1434 */
1435 cfgmR3FreeValue(pLeaf);
1436 pLeaf->pNext = NULL;
1437 pLeaf->pPrev = NULL;
1438 MMR3HeapFree(pLeaf);
1439 }
1440}
1441
1442
1443/**
1444 * Frees whatever resources the leaf value is owning.
1445 *
1446 * Use this before assigning a new value to a leaf.
1447 * The caller must either free the leaf or assign a new value to it.
1448 *
1449 * @param pLeaf Pointer to the leaf which value should be free.
1450 */
1451static void cfgmR3FreeValue(PCFGMLEAF pLeaf)
1452{
1453 if (pLeaf)
1454 {
1455 switch (pLeaf->enmType)
1456 {
1457 case CFGMVALUETYPE_BYTES:
1458 MMR3HeapFree(pLeaf->Value.Bytes.pau8);
1459 pLeaf->Value.Bytes.pau8 = NULL;
1460 pLeaf->Value.Bytes.cb = 0;
1461 break;
1462
1463 case CFGMVALUETYPE_STRING:
1464 MMR3HeapFree(pLeaf->Value.String.psz);
1465 pLeaf->Value.String.psz = NULL;
1466 pLeaf->Value.String.cch = 0;
1467 break;
1468
1469 case CFGMVALUETYPE_INTEGER:
1470 break;
1471 }
1472 pLeaf->enmType = (CFGMVALUETYPE)0;
1473 }
1474}
1475
1476
1477/**
1478 * Inserts a new integer value.
1479 *
1480 * @returns VBox status code.
1481 * @param pNode Parent node.
1482 * @param pszName Value name.
1483 * @param u64Integer The value.
1484 */
1485CFGMR3DECL(int) CFGMR3InsertInteger(PCFGMNODE pNode, const char *pszName, uint64_t u64Integer)
1486{
1487 PCFGMLEAF pLeaf;
1488 int rc = cfgmR3InsertLeaf(pNode, pszName, &pLeaf);
1489 if (VBOX_SUCCESS(rc))
1490 {
1491 pLeaf->enmType = CFGMVALUETYPE_INTEGER;
1492 pLeaf->Value.Integer.u64 = u64Integer;
1493 }
1494 return rc;
1495}
1496
1497
1498/**
1499 * Inserts a new string value.
1500 *
1501 * @returns VBox status code.
1502 * @param pNode Parent node.
1503 * @param pszName Value name.
1504 * @param pszString The value.
1505 */
1506CFGMR3DECL(int) CFGMR3InsertString(PCFGMNODE pNode, const char *pszName, const char *pszString)
1507{
1508 int rc;
1509 if (pNode)
1510 {
1511 /*
1512 * Allocate string object first.
1513 */
1514 size_t cchString = strlen(pszString) + 1;
1515 char *pszStringCopy = (char *)MMR3HeapAlloc(pNode->pVM, MM_TAG_CFGM_STRING, RT_ALIGN_Z(cchString, 16));
1516 if (pszStringCopy)
1517 {
1518 memcpy(pszStringCopy, pszString, cchString);
1519
1520 /*
1521 * Create value leaf and set it to string type.
1522 */
1523 PCFGMLEAF pLeaf;
1524 rc = cfgmR3InsertLeaf(pNode, pszName, &pLeaf);
1525 if (VBOX_SUCCESS(rc))
1526 {
1527 pLeaf->enmType = CFGMVALUETYPE_STRING;
1528 pLeaf->Value.String.psz = pszStringCopy;
1529 pLeaf->Value.String.cch = cchString;
1530 }
1531 }
1532 else
1533 rc = VERR_NO_MEMORY;
1534 }
1535 else
1536 rc = VERR_CFGM_NO_PARENT;
1537
1538 return rc;
1539}
1540
1541
1542
1543/**
1544 * Inserts a new integer value.
1545 *
1546 * @returns VBox status code.
1547 * @param pNode Parent node.
1548 * @param pszName Value name.
1549 * @param pvBytes The value.
1550 * @param cbBytes The value size.
1551 */
1552CFGMR3DECL(int) CFGMR3InsertBytes(PCFGMNODE pNode, const char *pszName, const void *pvBytes, size_t cbBytes)
1553{
1554 int rc;
1555 if (pNode)
1556 {
1557 if (cbBytes == (RTUINT)cbBytes)
1558 {
1559 /*
1560 * Allocate string object first.
1561 */
1562 void *pvCopy = MMR3HeapAlloc(pNode->pVM, MM_TAG_CFGM_STRING, RT_ALIGN_Z(cbBytes, 16));
1563 if (pvCopy || !cbBytes)
1564 {
1565 memcpy(pvCopy, pvBytes, cbBytes);
1566
1567 /*
1568 * Create value leaf and set it to string type.
1569 */
1570 PCFGMLEAF pLeaf;
1571 rc = cfgmR3InsertLeaf(pNode, pszName, &pLeaf);
1572 if (VBOX_SUCCESS(rc))
1573 {
1574 pLeaf->enmType = CFGMVALUETYPE_BYTES;
1575 pLeaf->Value.Bytes.cb = cbBytes;
1576 pLeaf->Value.Bytes.pau8 = (uint8_t *)pvCopy;
1577 }
1578 }
1579 else
1580 rc = VERR_NO_MEMORY;
1581 }
1582 else
1583 rc = VERR_OUT_OF_RANGE;
1584 }
1585 else
1586 rc = VERR_CFGM_NO_PARENT;
1587
1588 return rc;
1589}
1590
1591
1592/**
1593 * Remove a value.
1594 *
1595 * @returns VBox status code.
1596 * @param pNode Parent node.
1597 * @param pszName Name of the new child node.
1598 */
1599CFGMR3DECL(int) CFGMR3RemoveValue(PCFGMNODE pNode, const char *pszName)
1600{
1601 PCFGMLEAF pLeaf;
1602 int rc = cfgmR3ResolveLeaf(pNode, pszName, &pLeaf);
1603 if (VBOX_SUCCESS(rc))
1604 cfgmR3RemoveLeaf(pNode, pLeaf);
1605 return rc;
1606}
1607
1608
1609
1610/*
1611 * -+- helper apis -+-
1612 */
1613
1614
1615/**
1616 * Query unsigned 64-bit integer value.
1617 *
1618 * @returns VBox status code.
1619 * @param pNode Which node to search for pszName in.
1620 * @param pszName Name of an integer value.
1621 * @param pu64 Where to store the integer value.
1622 */
1623CFGMR3DECL(int) CFGMR3QueryU64(PCFGMNODE pNode, const char *pszName, uint64_t *pu64)
1624{
1625 return CFGMR3QueryInteger(pNode, pszName, pu64);
1626}
1627
1628
1629/**
1630 * Query signed 64-bit integer value.
1631 *
1632 * @returns VBox status code.
1633 * @param pNode Which node to search for pszName in.
1634 * @param pszName Name of an integer value.
1635 * @param pi64 Where to store the value.
1636 */
1637CFGMR3DECL(int) CFGMR3QueryS64(PCFGMNODE pNode, const char *pszName, int64_t *pi64)
1638{
1639 uint64_t u64;
1640 int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
1641 if (VBOX_SUCCESS(rc))
1642 *pi64 = (int64_t)u64;
1643 return rc;
1644}
1645
1646
1647/**
1648 * Query unsigned 32-bit integer value.
1649 *
1650 * @returns VBox status code.
1651 * @param pNode Which node to search for pszName in.
1652 * @param pszName Name of an integer value.
1653 * @param pu32 Where to store the value.
1654 */
1655CFGMR3DECL(int) CFGMR3QueryU32(PCFGMNODE pNode, const char *pszName, uint32_t *pu32)
1656{
1657 uint64_t u64;
1658 int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
1659 if (VBOX_SUCCESS(rc))
1660 {
1661 if (!(u64 & 0xffffffff00000000ULL))
1662 *pu32 = (uint32_t)u64;
1663 else
1664 rc = VERR_CFGM_INTEGER_TOO_BIG;
1665 }
1666 return rc;
1667}
1668
1669
1670/**
1671 * Query signed 32-bit integer value.
1672 *
1673 * @returns VBox status code.
1674 * @param pNode Which node to search for pszName in.
1675 * @param pszName Name of an integer value.
1676 * @param pi32 Where to store the value.
1677 */
1678CFGMR3DECL(int) CFGMR3QueryS32(PCFGMNODE pNode, const char *pszName, int32_t *pi32)
1679{
1680 uint64_t u64;
1681 int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
1682 if (VBOX_SUCCESS(rc))
1683 {
1684 if ( !(u64 & 0xffffffff80000000ULL)
1685 || (u64 & 0xffffffff80000000ULL) == 0xffffffff80000000ULL)
1686 *pi32 = (int32_t)u64;
1687 else
1688 rc = VERR_CFGM_INTEGER_TOO_BIG;
1689 }
1690 return rc;
1691}
1692
1693
1694/**
1695 * Query unsigned 16-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 pu16 Where to store the value.
1701 */
1702CFGMR3DECL(int) CFGMR3QueryU16(PCFGMNODE pNode, const char *pszName, uint16_t *pu16)
1703{
1704 uint64_t u64;
1705 int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
1706 if (VBOX_SUCCESS(rc))
1707 {
1708 if (!(u64 & 0xffffffffffff0000ULL))
1709 *pu16 = (int16_t)u64;
1710 else
1711 rc = VERR_CFGM_INTEGER_TOO_BIG;
1712 }
1713 return rc;
1714}
1715
1716
1717/**
1718 * Query signed 16-bit integer value.
1719 *
1720 * @returns VBox status code.
1721 * @param pNode Which node to search for pszName in.
1722 * @param pszName Name of an integer value.
1723 * @param pi16 Where to store the value.
1724 */
1725CFGMR3DECL(int) CFGMR3QueryS16(PCFGMNODE pNode, const char *pszName, int16_t *pi16)
1726{
1727 uint64_t u64;
1728 int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
1729 if (VBOX_SUCCESS(rc))
1730 {
1731 if ( !(u64 & 0xffffffffffff8000ULL)
1732 || (u64 & 0xffffffffffff8000ULL) == 0xffffffffffff8000ULL)
1733 *pi16 = (int16_t)u64;
1734 else
1735 rc = VERR_CFGM_INTEGER_TOO_BIG;
1736 }
1737 return rc;
1738}
1739
1740
1741/**
1742 * Query unsigned 8-bit integer value.
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 pu8 Where to store the value.
1748 */
1749CFGMR3DECL(int) CFGMR3QueryU8(PCFGMNODE pNode, const char *pszName, uint8_t *pu8)
1750{
1751 uint64_t u64;
1752 int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
1753 if (VBOX_SUCCESS(rc))
1754 {
1755 if (!(u64 & 0xffffffffffffff00ULL))
1756 *pu8 = (uint8_t)u64;
1757 else
1758 rc = VERR_CFGM_INTEGER_TOO_BIG;
1759 }
1760 return rc;
1761}
1762
1763
1764/**
1765 * Query signed 8-bit integer value.
1766 *
1767 * @returns VBox status code.
1768 * @param pNode Which node to search for pszName in.
1769 * @param pszName Name of an integer value.
1770 * @param pi8 Where to store the value.
1771 */
1772CFGMR3DECL(int) CFGMR3QueryS8(PCFGMNODE pNode, const char *pszName, int8_t *pi8)
1773{
1774 uint64_t u64;
1775 int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
1776 if (VBOX_SUCCESS(rc))
1777 {
1778 if ( !(u64 & 0xffffffffffffff80ULL)
1779 || (u64 & 0xffffffffffffff80ULL) == 0xffffffffffffff80ULL)
1780 *pi8 = (int8_t)u64;
1781 else
1782 rc = VERR_CFGM_INTEGER_TOO_BIG;
1783 }
1784 return rc;
1785}
1786
1787
1788/**
1789 * Query boolean integer value.
1790 *
1791 * @returns VBox status code.
1792 * @param pNode Which node to search for pszName in.
1793 * @param pszName Name of an integer value.
1794 * @param pf Where to store the value.
1795 * @remark This function will interpret any non-zero value as true.
1796 */
1797CFGMR3DECL(int) CFGMR3QueryBool(PCFGMNODE pNode, const char *pszName, bool *pf)
1798{
1799 uint64_t u64;
1800 int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
1801 if (VBOX_SUCCESS(rc))
1802 *pf = u64 ? true : false;
1803 return rc;
1804}
1805
1806
1807/**
1808 * Query pointer 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 ppv Where to store the value.
1814 */
1815CFGMR3DECL(int) CFGMR3QueryPtr(PCFGMNODE pNode, const char *pszName, void **ppv)
1816{
1817 uint64_t u64;
1818 int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
1819 if (VBOX_SUCCESS(rc))
1820 {
1821 uintptr_t u = (uintptr_t)u64;
1822 if (u64 == u)
1823 *ppv = (void *)u;
1824 else
1825 rc = VERR_CFGM_INTEGER_TOO_BIG;
1826 }
1827 return rc;
1828}
1829
1830
1831/**
1832 * Query Guest Context pointer integer value.
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 pGCPtr Where to store the value.
1838 */
1839CFGMR3DECL(int) CFGMR3QueryGCPtr(PCFGMNODE pNode, const char *pszName, PRTGCPTR pGCPtr)
1840{
1841 uint64_t u64;
1842 int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
1843 if (VBOX_SUCCESS(rc))
1844 {
1845 RTGCPTR u = (RTGCPTR)u64;
1846 if (u64 == u)
1847 *pGCPtr = u;
1848 else
1849 rc = VERR_CFGM_INTEGER_TOO_BIG;
1850 }
1851 return rc;
1852}
1853
1854
1855/**
1856 * Query Guest Context unsigned pointer value.
1857 *
1858 * @returns VBox status code.
1859 * @param pNode Which node to search for pszName in.
1860 * @param pszName Name of an integer value.
1861 * @param pGCPtr Where to store the value.
1862 */
1863CFGMR3DECL(int) CFGMR3QueryGCPtrU(PCFGMNODE pNode, const char *pszName, PRTGCUINTPTR pGCPtr)
1864{
1865 uint64_t u64;
1866 int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
1867 if (VBOX_SUCCESS(rc))
1868 {
1869 RTGCUINTPTR u = (RTGCUINTPTR)u64;
1870 if (u64 == u)
1871 *pGCPtr = u;
1872 else
1873 rc = VERR_CFGM_INTEGER_TOO_BIG;
1874 }
1875 return rc;
1876}
1877
1878
1879/**
1880 * Query Guest Context signed pointer value.
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 pGCPtr Where to store the value.
1886 */
1887CFGMR3DECL(int) CFGMR3QueryGCPtrS(PCFGMNODE pNode, const char *pszName, PRTGCINTPTR pGCPtr)
1888{
1889 uint64_t u64;
1890 int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
1891 if (VBOX_SUCCESS(rc))
1892 {
1893 RTGCINTPTR u = (RTGCINTPTR)u64;
1894 if (u64 == (uint64_t)u)
1895 *pGCPtr = u;
1896 else
1897 rc = VERR_CFGM_INTEGER_TOO_BIG;
1898 }
1899 return rc;
1900}
1901
1902
1903/**
1904 * Query zero terminated character value storing it in a
1905 * buffer allocated from the MM heap.
1906 *
1907 * @returns VBox status code.
1908 * @param pNode Which node to search for pszName in.
1909 * @param pszName Value name. This value must be of zero terminated character string type.
1910 * @param ppszString Where to store the string pointer.
1911 * Free this using MMR3HeapFree().
1912 */
1913CFGMR3DECL(int) CFGMR3QueryStringAlloc(PCFGMNODE pNode, const char *pszName, char **ppszString)
1914{
1915 size_t cch;
1916 int rc = CFGMR3QuerySize(pNode, pszName, &cch);
1917 if (VBOX_SUCCESS(rc))
1918 {
1919 char *pszString = (char *)MMR3HeapAlloc(pNode->pVM, MM_TAG_CFGM_USER, cch);
1920 if (pszString)
1921 {
1922 rc = CFGMR3QueryString(pNode, pszName, pszString, cch);
1923 if (VBOX_SUCCESS(rc))
1924 *ppszString = pszString;
1925 else
1926 MMR3HeapFree(pszString);
1927 }
1928 else
1929 rc = VERR_NO_MEMORY;
1930 }
1931 return rc;
1932}
1933
1934
1935
1936/**
1937 * Dumps the configuration (sub)tree to the release log.
1938 *
1939 * @param pRoot The root node of the dump.
1940 */
1941CFGMR3DECL(void) CFGMR3Dump(PCFGMNODE pRoot)
1942{
1943 LogRel(("************************* CFGM dump *************************\n"));
1944 cfgmR3Info(pRoot->pVM, DBGFR3InfoLogRelHlp(), NULL);
1945 LogRel(("********************* End of CFGM dump **********************\n"));
1946}
1947
1948
1949/**
1950 * Info handler, internal version.
1951 *
1952 * @param pVM The VM handle.
1953 * @param pHlp Callback functions for doing output.
1954 * @param pszArgs Argument string. Optional and specific to the handler.
1955 */
1956static DECLCALLBACK(void) cfgmR3Info(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs)
1957{
1958 /*
1959 * Figure where to start.
1960 */
1961 PCFGMNODE pRoot = pVM->cfgm.s.pRoot;
1962 if (pszArgs && *pszArgs)
1963 {
1964 int rc = cfgmR3ResolveNode(pRoot, pszArgs, &pRoot);
1965 if (VBOX_FAILURE(rc))
1966 {
1967 pHlp->pfnPrintf(pHlp, "Failed to resolve CFGM path '%s', %Vrc", pszArgs, rc);
1968 return;
1969 }
1970 }
1971
1972 /*
1973 * Dump the specified tree.
1974 */
1975 pHlp->pfnPrintf(pHlp, "pRoot=%p:{", pRoot);
1976 cfgmR3DumpPath(pRoot, pHlp);
1977 pHlp->pfnPrintf(pHlp, "}\n");
1978 cfgmR3Dump(pRoot, 0, pHlp);
1979}
1980
1981
1982/**
1983 * Recursivly prints a path name.
1984 */
1985static void cfgmR3DumpPath(PCFGMNODE pNode, PCDBGFINFOHLP pHlp)
1986{
1987 if (pNode->pParent)
1988 cfgmR3DumpPath(pNode->pParent, pHlp);
1989 pHlp->pfnPrintf(pHlp, "%s/", pNode->szName);
1990}
1991
1992
1993/**
1994 * Dumps a branch of a tree.
1995 */
1996static void cfgmR3Dump(PCFGMNODE pRoot, unsigned iLevel, PCDBGFINFOHLP pHlp)
1997{
1998 /*
1999 * Path.
2000 */
2001 pHlp->pfnPrintf(pHlp, "[");
2002 cfgmR3DumpPath(pRoot, pHlp);
2003 pHlp->pfnPrintf(pHlp, "] (level %d)%s\n", iLevel, pRoot->fRestrictedRoot ? " (restricted root)" : "");
2004
2005 /*
2006 * Values.
2007 */
2008 PCFGMLEAF pLeaf;
2009 unsigned cchMax = 0;
2010 for (pLeaf = CFGMR3GetFirstValue(pRoot); pLeaf; pLeaf = CFGMR3GetNextValue(pLeaf))
2011 cchMax = RT_MAX(cchMax, pLeaf->cchName);
2012 for (pLeaf = CFGMR3GetFirstValue(pRoot); pLeaf; pLeaf = CFGMR3GetNextValue(pLeaf))
2013 {
2014 switch (CFGMR3GetValueType(pLeaf))
2015 {
2016 case CFGMVALUETYPE_INTEGER:
2017 pHlp->pfnPrintf(pHlp, " %-*s <integer> = %#018llx (%lld)\n", cchMax, pLeaf->szName, pLeaf->Value.Integer.u64, pLeaf->Value.Integer.u64);
2018 break;
2019
2020 case CFGMVALUETYPE_STRING:
2021 pHlp->pfnPrintf(pHlp, " %-*s <string> = \"%s\" (cch=%d)\n", cchMax, pLeaf->szName, pLeaf->Value.String.psz, pLeaf->Value.String.cch);
2022 break;
2023
2024 case CFGMVALUETYPE_BYTES:
2025 pHlp->pfnPrintf(pHlp, " %-*s <bytes> = \"%.*Vhxs\" (cb=%d)\n", cchMax, pLeaf->szName, pLeaf->Value.Bytes.cb, pLeaf->Value.Bytes.pau8, pLeaf->Value.Bytes.cb);
2026 break;
2027
2028 default:
2029 AssertMsgFailed(("bad leaf!\n"));
2030 break;
2031 }
2032 }
2033 pHlp->pfnPrintf(pHlp, "\n");
2034
2035 /*
2036 * Children.
2037 */
2038 for (PCFGMNODE pChild = CFGMR3GetFirstChild(pRoot); pChild; pChild = CFGMR3GetNextChild(pChild))
2039 {
2040 Assert(pChild->pNext != pChild);
2041 Assert(pChild->pPrev != pChild);
2042 Assert(pChild->pPrev != pChild->pNext || !pChild->pPrev);
2043 Assert(pChild->pFirstChild != pChild);
2044 Assert(pChild->pParent != pChild);
2045 cfgmR3Dump(pChild, iLevel + 1, pHlp);
2046 }
2047}
2048
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