VirtualBox

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

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

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