VirtualBox

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

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

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