Changeset 39853 in vbox for trunk/src/VBox/VMM

Timestamp:

Jan 24, 2012 4:38:14 PM (13 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

75878

Message:

CFGM: Added CFGMR3InsertValue and CFGMR3CopyTree; changed CFGMR3DuplicateSubTree; bugfixed CFGMR3InsertSubTree and CFGMR3ReplaceSubTree.

File:

• trunk/src/VBox/VMM/VMMR3/CFGM.cpp (modified) (11 diffs)

trunk/src/VBox/VMM/VMMR3/CFGM.cpp

@@ -1208 +1208 @@
  *          input parameter is NULL.
  * @param   pRoot       The root of the tree to duplicate.
- */
-VMMR3DECL(PCFGMNODE) CFGMR3DuplicateSubTree(PCFGMNODE pRoot)
-{
-    AssertPtrReturn(pRoot, NULL);
+ * @param   ppCopy      Where to return the root of the duplicate.
+ */
+VMMR3DECL(int) CFGMR3DuplicateSubTree(PCFGMNODE pRoot, PCFGMNODE *ppCopy)
+{
+    AssertPtrReturn(pRoot, VERR_INVALID_POINTER);
 
     /*
@@ -1218 +1219 @@
     PCFGMNODE pNewRoot = CFGMR3CreateTree(pRoot->pVM);
     if (!pNewRoot)
-        return pNewRoot;
+        return VERR_NO_MEMORY;
 
     /*
@@ -1236 +1237 @@
             /** @todo this isn't the most efficient way to do it. */
             for (PCFGMLEAF pLeaf = pSrcCur->pFirstLeaf; pLeaf && RT_SUCCESS(rc); pLeaf = pLeaf->pNext)
-            {
-                switch (pLeaf->enmType)
-                {
-                    case CFGMVALUETYPE_INTEGER:
-                        rc = CFGMR3InsertInteger(pDstCur, pLeaf->szName, pLeaf->Value.Integer.u64);
-                        break;
-
-                    case CFGMVALUETYPE_BYTES:
-                        rc = CFGMR3InsertBytes(pDstCur, pLeaf->szName, pLeaf->Value.Bytes.pau8, pLeaf->Value.Bytes.cb);
-                        break;
-
-                    case CFGMVALUETYPE_STRING:
-                        rc = CFGMR3InsertStringN(pDstCur, pLeaf->szName, pLeaf->Value.String.psz, pLeaf->Value.String.cb - 1);
-                        break;
-
-                    default:
-                        rc = VERR_CFGM_IPE_1;
-                        AssertMsgFailed(("Invalid value type %d\n", pLeaf->enmType));
-                        break;
-                }
-            }
+                rc = CFGMR3InsertValue(pDstCur, pLeaf);
 
             /*
@@ -1311 +1292 @@
     {
         CFGMR3RemoveNode(pNewRoot);
-        return NULL;
-    }
-
-    return pNewRoot;
+        return rc;
+    }
+
+    *ppCopy = pNewRoot;
+    return VINF_SUCCESS;
 }
 
@@ -1341 +1323 @@
      * Validate input.
      */
+    AssertPtrReturn(pNode, VERR_INVALID_POINTER);
     AssertPtrReturn(pSubTree, VERR_INVALID_POINTER);
+    AssertReturn(pNode != pSubTree, VERR_INVALID_PARAMETER);
     AssertReturn(!pSubTree->pParent, VERR_INVALID_PARAMETER);
     AssertReturn(pSubTree->pVM, VERR_INVALID_PARAMETER);
@@ -1356 +1340 @@
     {
         Assert(!pNewChild->pFirstChild);
+        Assert(!pNewChild->pFirstLeaf);
+
         pNewChild->pFirstChild = pSubTree->pFirstChild;
-        Assert(!pNewChild->pFirstLeaf);
         pNewChild->pFirstLeaf = pSubTree->pFirstLeaf;
+        for (PCFGMNODE pChild = pNewChild->pFirstChild; pChild; pChild = pChild->pNext)
+            pChild->pParent = pNewChild;
+
         if (ppChild)
             *ppChild = pNewChild;
@@ -1392 +1380 @@
     AssertPtrReturn(pRoot, VERR_INVALID_POINTER);
     AssertPtrReturn(pNewRoot, VERR_INVALID_POINTER);
+    AssertReturn(pRoot != pNewRoot, VERR_INVALID_PARAMETER);
     AssertReturn(!pNewRoot->pParent, VERR_INVALID_PARAMETER);
     AssertReturn(pNewRoot->pVM, VERR_INVALID_PARAMETER);
@@ -1412 +1401 @@
     pRoot->pFirstLeaf       = pNewRoot->pFirstLeaf;
     pRoot->pFirstChild      = pNewRoot->pFirstChild;
+    for (PCFGMNODE pChild = pRoot->pFirstChild; pChild; pChild = pChild->pNext)
+        pChild->pParent     = pRoot;
 
     pNewRoot->pFirstLeaf    = NULL;
@@ -1420 +1411 @@
     return VINF_SUCCESS;
 }
+
+
+VMMR3DECL(int) CFGMR3CopyTree(PCFGMNODE pDstTree, PCFGMNODE pSrcTree, uint32_t fFlags)
+{
+    /*
+     * Input validation.
+     */
+    AssertPtrReturn(pSrcTree, VERR_INVALID_POINTER);
+    AssertPtrReturn(pDstTree, VERR_INVALID_POINTER);
+    AssertReturn(pDstTree != pDstTree, VERR_INVALID_PARAMETER);
+    AssertReturn(!(fFlags & ~(CFGM_COPY_FLAGS_VALUE_DISP_MASK | CFGM_COPY_FLAGS_KEY_DISP_MASK)), VERR_INVALID_PARAMETER);
+    AssertReturn(   (fFlags & CFGM_COPY_FLAGS_VALUE_DISP_MASK) != CFGM_COPY_FLAGS_RESERVED_VALUE_DISP_0
+                 && (fFlags & CFGM_COPY_FLAGS_VALUE_DISP_MASK) != CFGM_COPY_FLAGS_RESERVED_VALUE_DISP_1,
+                 VERR_INVALID_PARAMETER);
+    AssertReturn((fFlags & CFGM_COPY_FLAGS_KEY_DISP_MASK) != CFGM_COPY_FLAGS_RESERVED_KEY_DISP,
+                 VERR_INVALID_PARAMETER);
+
+    /*
+     * Copy the values.
+     */
+    int rc;
+    for (PCFGMLEAF pValue = CFGMR3GetFirstValue(pSrcTree); pValue; pValue = CFGMR3GetNextValue(pValue))
+    {
+        rc = CFGMR3InsertValue(pDstTree, pValue);
+        if (rc == VERR_CFGM_LEAF_EXISTS)
+        {
+            if ((fFlags & CFGM_COPY_FLAGS_VALUE_DISP_MASK) == CFGM_COPY_FLAGS_REPLACE_VALUES)
+            {
+                rc = CFGMR3RemoveValue(pDstTree, pValue->szName);
+                if (RT_FAILURE(rc))
+                    break;
+                rc = CFGMR3InsertValue(pDstTree, pValue);
+            }
+            else
+                rc = VINF_SUCCESS;
+        }
+        AssertRCReturn(rc, rc);
+    }
+
+    /*
+     * Copy/merge the keys - merging results in recursion.
+     */
+    for (PCFGMNODE pSrcChild = CFGMR3GetFirstChild(pSrcTree); pSrcChild; pSrcChild = CFGMR3GetNextChild(pSrcChild))
+    {
+        PCFGMNODE pDstChild = CFGMR3GetChild(pDstTree, pSrcChild->szName);
+        if (   pDstChild
+            && (fFlags & CFGM_COPY_FLAGS_KEY_DISP_MASK) == CFGM_COPY_FLAGS_REPLACE_KEYS)
+        {
+            CFGMR3RemoveNode(pDstChild);
+            pDstChild = NULL;
+        }
+        if (!pDstChild)
+        {
+            PCFGMNODE pChildCopy;
+            rc = CFGMR3DuplicateSubTree(pSrcChild, &pChildCopy);
+            AssertRCReturn(rc, rc);
+            rc = CFGMR3InsertSubTree(pDstTree, pSrcChild->szName, pChildCopy, NULL);
+            AssertRCReturnStmt(rc, CFGMR3RemoveNode(pChildCopy), rc);
+        }
+        else if ((fFlags & CFGM_COPY_FLAGS_KEY_DISP_MASK) == CFGM_COPY_FLAGS_MERGE_KEYS)
+        {
+            rc = CFGMR3CopyTree(pDstChild, pSrcChild, fFlags);
+            AssertRCReturn(rc, rc);
+        }
+    }
+
+    return VINF_SUCCESS;
+}
+
 
 
@@ -2059 +2119 @@
 
 /**
+ * Make a copy of the specified value under the given node.
+ *
+ * @returns VBox status code.
+ * @param   pNode               Parent node.
+ * @param   pValue              The value to copy and insert.
+ */
+VMMR3DECL(int) CFGMR3InsertValue(PCFGMNODE pNode, PCFGMLEAF pValue)
+{
+    int rc;
+    switch (pValue->enmType)
+    {
+        case CFGMVALUETYPE_INTEGER:
+            rc = CFGMR3InsertInteger(pNode, pValue->szName, pValue->Value.Integer.u64);
+            break;
+
+        case CFGMVALUETYPE_BYTES:
+            rc = CFGMR3InsertBytes(pNode, pValue->szName, pValue->Value.Bytes.pau8, pValue->Value.Bytes.cb);
+            break;
+
+        case CFGMVALUETYPE_STRING:
+            rc = CFGMR3InsertStringN(pNode, pValue->szName, pValue->Value.String.psz, pValue->Value.String.cb - 1);
+            break;
+
+        default:
+            rc = VERR_CFGM_IPE_1;
+            AssertMsgFailed(("Invalid value type %d\n", pValue->enmType));
+            break;
+    }
+    return rc;
+}
+
+
+/**
  * Remove a value.
  *
@@ -2973 +3066 @@
         Assert(pChild->pPrev != pChild->pNext || !pChild->pPrev);
         Assert(pChild->pFirstChild != pChild);
-        Assert(pChild->pParent != pChild);
+        Assert(pChild->pParent == pRoot);
         cfgmR3Dump(pChild, iLevel + 1, pHlp);
     }