Changeset 46781 in vbox for trunk/src/VBox/VMM/VMMR3/CFGM.cpp

Timestamp:

Jun 25, 2013 2:04:17 PM (11 years ago)

Author:

vboxsync

Message:

CFGM: Made the CFGMR3CreateTree usable with pUVM == NULL for testing purposes.

File:

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

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

@@ -66 +66 @@
 #include <VBox/log.h>
 #include <iprt/assert.h>
+#include <iprt/mem.h>
 #include <iprt/param.h>
 #include <iprt/string.h>
@@ -81 +82 @@
 static int  cfgmR3InsertLeaf(PCFGMNODE pNode, const char *pszName, PCFGMLEAF *ppLeaf);
 static void cfgmR3RemoveLeaf(PCFGMNODE pNode, PCFGMLEAF pLeaf);
-static void cfgmR3FreeValue(PCFGMLEAF pLeaf);
+static void cfgmR3FreeValue(PVM pVM, PCFGMLEAF pLeaf);
+
+
+/**
+ * Allocator wrapper.
+ *
+ * @returns Pointer to the allocated memory, NULL on failure.
+ * @param   pVM                 The VM handle, if tree associated with one.
+ * @param   enmTag              The allocation tag.
+ * @param   cb                  The size of the allocation.
+ */
+static void *cfgmR3MemAlloc(PVM pVM, MMTAG enmTag, size_t cb)
+{
+    if (pVM)
+        return MMR3HeapAlloc(pVM, enmTag, cb);
+    return RTMemAlloc(cb);
+}
+
+
+/**
+ * Free wrapper.
+ *
+ * @returns Pointer to the allocated memory, NULL on failure.
+ * @param   pVM                 The VM handle, if tree associated with one.
+ * @param   pv                  The memory block to free.
+ */
+static void cfgmR3MemFree(PVM pVM, void *pv)
+{
+    if (pVM)
+        MMR3HeapFree(pv);
+    else
+        RTMemFree(pv);
+}
+
+
+/**
+ * String allocator wrapper.
+ *
+ * @returns Pointer to the allocated memory, NULL on failure.
+ * @param   pVM                 The VM handle, if tree associated with one.
+ * @param   enmTag              The allocation tag.
+ * @param   cbString            The size of the allocation, terminator included.
+ */
+static char *cfgmR3StrAlloc(PVM pVM, MMTAG enmTag,  size_t cbString)
+{
+    if (pVM)
+        return (char *)MMR3HeapAlloc(pVM, enmTag, cbString);
+    return (char *)RTStrAlloc(cbString);
+}
+
+
+/**
+ * String free wrapper.
+ *
+ * @returns Pointer to the allocated memory, NULL on failure.
+ * @param   pVM                 The VM handle, if tree associated with one.
+ * @param   pszString           The memory block to free.
+ */
+static void cfgmR3StrFree(PVM pVM, char *pszString)
+{
+    if (pVM)
+        MMR3HeapFree(pszString);
+    else
+        RTStrFree(pszString);
+}
+
+
+/**
+ * Frees one node, leaving any children or leaves to the caller.
+ *
+ * @param   pNode               The node structure to free.
+ */
+static void cfgmR3FreeNodeOnly(PCFGMNODE pNode)
+{
+    pNode->pFirstLeaf    = NULL;
+    pNode->pFirstChild   = NULL;
+    pNode->pNext         = NULL;
+    pNode->pPrev         = NULL;
+    if (!pNode->pVM)
+        RTMemFree(pNode);
+    else
+    {
+        pNode->pVM       = NULL;
+        MMR3HeapFree(pNode);
+    }
+}
+
 
 
@@ -1203 +1290 @@
  * @returns Pointer to the root node, NULL on error (out of memory or invalid
  *          VM handle).
- * @param   pUVM            The user mode VM handle.
+ * @param   pUVM            The user mode VM handle.  For testcase (and other
+ *                          purposes, NULL can be used.  However, the resulting
+ *                          tree cannot be inserted into a tree that has a
+ *                          non-NULL value.  Using NULL can be usedful for
+ *                          testcases and similar, non VMM uses.
  */
 VMMR3DECL(PCFGMNODE) CFGMR3CreateTree(PUVM pUVM)
 {
-    UVM_ASSERT_VALID_EXT_RETURN(pUVM, NULL);
-    VM_ASSERT_VALID_EXT_RETURN(pUVM->pVM, NULL);
-
-    PCFGMNODE pNew = (PCFGMNODE)MMR3HeapAllocU(pUVM, MM_TAG_CFGM, sizeof(*pNew));
+    if (pUVM)
+    {
+        UVM_ASSERT_VALID_EXT_RETURN(pUVM, NULL);
+        VM_ASSERT_VALID_EXT_RETURN(pUVM->pVM, NULL);
+    }
+
+    PCFGMNODE pNew;
+    if (pUVM)
+        pNew = (PCFGMNODE)MMR3HeapAllocU(pUVM, MM_TAG_CFGM, sizeof(*pNew));
+    else
+        pNew = (PCFGMNODE)RTMemAlloc(sizeof(*pNew));
     if (pNew)
     {
@@ -1218 +1316 @@
         pNew->pFirstChild   = NULL;
         pNew->pFirstLeaf    = NULL;
-        pNew->pVM           = pUVM->pVM;
+        pNew->pVM           = pUVM ? pUVM->pVM : NULL;
         pNew->fRestrictedRoot = false;
         pNew->cchName       = 0;
@@ -1242 +1340 @@
      * Create a new tree.
      */
-    PCFGMNODE pNewRoot = CFGMR3CreateTree(pRoot->pVM->pUVM);
+    PCFGMNODE pNewRoot = CFGMR3CreateTree(pRoot->pVM ? pRoot->pVM->pUVM : NULL);
     if (!pNewRoot)
         return VERR_NO_MEMORY;
@@ -1352 +1450 @@
     AssertReturn(pNode != pSubTree, VERR_INVALID_PARAMETER);
     AssertReturn(!pSubTree->pParent, VERR_INVALID_PARAMETER);
-    AssertReturn(pSubTree->pVM, VERR_INVALID_PARAMETER);
+    AssertReturn(pNode->pVM == pSubTree->pVM, VERR_INVALID_PARAMETER);
     Assert(!pSubTree->pNext);
     Assert(!pSubTree->pPrev);
@@ -1376 +1474 @@
 
         /* free the old subtree root */
-        pSubTree->pVM = NULL;
-        pSubTree->pFirstLeaf = NULL;
-        pSubTree->pFirstChild = NULL;
-        MMR3HeapFree(pSubTree);
+        cfgmR3FreeNodeOnly(pSubTree);
     }
     return rc;
@@ -1407 +1502 @@
     AssertReturn(pRoot != pNewRoot, VERR_INVALID_PARAMETER);
     AssertReturn(!pNewRoot->pParent, VERR_INVALID_PARAMETER);
-    AssertReturn(pNewRoot->pVM, VERR_INVALID_PARAMETER);
     AssertReturn(pNewRoot->pVM == pRoot->pVM, VERR_INVALID_PARAMETER);
     AssertReturn(!pNewRoot->pNext, VERR_INVALID_PARAMETER);
@@ -1429 +1523 @@
         pChild->pParent     = pRoot;
 
-    pNewRoot->pFirstLeaf    = NULL;
-    pNewRoot->pFirstChild   = NULL;
-    pNewRoot->pVM           = NULL;
-    MMR3HeapFree(pNewRoot);
+    cfgmR3FreeNodeOnly(pNewRoot);
 
     return VINF_SUCCESS;
@@ -1644 +1735 @@
              * Allocate and init node.
              */
-            PCFGMNODE pNew = (PCFGMNODE)MMR3HeapAlloc(pNode->pVM, MM_TAG_CFGM, sizeof(*pNew) + cchName);
+            PCFGMNODE pNew = (PCFGMNODE)cfgmR3MemAlloc(pNode->pVM, MM_TAG_CFGM, sizeof(*pNew) + cchName);
             if (pNew)
             {
@@ -1786 +1877 @@
              * Allocate and init node.
              */
-            PCFGMLEAF pNew = (PCFGMLEAF)MMR3HeapAlloc(pNode->pVM, MM_TAG_CFGM, sizeof(*pNew) + cchName);
+            PCFGMLEAF pNew = (PCFGMLEAF)cfgmR3MemAlloc(pNode->pVM, MM_TAG_CFGM, sizeof(*pNew) + cchName);
             if (pNew)
             {
@@ -1856 +1947 @@
 
         /*
-         * Free ourselves. (bit of paranoia first)
+         * Free ourselves.
          */
-        pNode->pVM = NULL;
-        pNode->pNext = NULL;
-        pNode->pPrev = NULL;
-        pNode->pParent = NULL;
-        MMR3HeapFree(pNode);
+        cfgmR3FreeNodeOnly(pNode);
     }
 }
@@ -1890 +1977 @@
          * Free value and node.
          */
-        cfgmR3FreeValue(pLeaf);
+        cfgmR3FreeValue(pNode->pVM, pLeaf);
         pLeaf->pNext = NULL;
         pLeaf->pPrev = NULL;
-        MMR3HeapFree(pLeaf);
+        cfgmR3MemFree(pNode->pVM, pLeaf);
     }
 }
@@ -1904 +1991 @@
  * The caller must either free the leaf or assign a new value to it.
  *
+ * @param   pVM         Used to select the heap.
  * @param   pLeaf       Pointer to the leaf which value should be free.
  */
-static void cfgmR3FreeValue(PCFGMLEAF pLeaf)
+static void cfgmR3FreeValue(PVM pVM, PCFGMLEAF pLeaf)
 {
     if (pLeaf)
@@ -1913 +2001 @@
         {
             case CFGMVALUETYPE_BYTES:
-                MMR3HeapFree(pLeaf->Value.Bytes.pau8);
+                cfgmR3MemFree(pVM, pLeaf->Value.Bytes.pau8);
                 pLeaf->Value.Bytes.pau8 = NULL;
                 pLeaf->Value.Bytes.cb = 0;
@@ -1919 +2007 @@
 
             case CFGMVALUETYPE_STRING:
-                MMR3HeapFree(pLeaf->Value.String.psz);
+                cfgmR3StrFree(pVM, pLeaf->Value.String.psz);
                 pLeaf->Value.String.psz = NULL;
                 pLeaf->Value.String.cb = 0;
@@ -1974 +2062 @@
          * Allocate string object first.
          */
-        char *pszStringCopy = (char *)MMR3HeapAlloc(pNode->pVM, MM_TAG_CFGM_STRING, cchString + 1);
+        char *pszStringCopy = (char *)cfgmR3StrAlloc(pNode->pVM, MM_TAG_CFGM_STRING, cchString + 1);
         if (pszStringCopy)
         {
@@ -1992 +2080 @@
             }
             else
-                MMR3HeapFree(pszStringCopy);
+                cfgmR3StrFree(pNode->pVM, pszStringCopy);
         }
         else
@@ -2037 +2125 @@
          * Allocate string object first.
          */
-        char *pszString = MMR3HeapAPrintfVU(pNode->pVM->pUVM, MM_TAG_CFGM_STRING, pszFormat, va);
+        char *pszString;
+        if (!pNode->pVM)
+            pszString = RTStrAPrintf2(pszFormat, va);
+        else
+            pszString = MMR3HeapAPrintfVU(pNode->pVM->pUVM, MM_TAG_CFGM_STRING, pszFormat, va);
         if (pszString)
         {
@@ -2052 +2144 @@
             }
             else
-                MMR3HeapFree(pszString);
+                cfgmR3StrFree(pNode->pVM, pszString);
         }
         else
@@ -2124 +2216 @@
              * Allocate string object first.
              */
-            void *pvCopy = MMR3HeapAlloc(pNode->pVM, MM_TAG_CFGM_STRING, cbBytes);
+            void *pvCopy = cfgmR3MemAlloc(pNode->pVM, MM_TAG_CFGM_STRING, cbBytes);
             if (pvCopy || !cbBytes)
             {
@@ -2140 +2232 @@
                     pLeaf->Value.Bytes.pau8 = (uint8_t *)pvCopy;
                 }
+                else
+                    cfgmR3MemFree(pNode->pVM, pvCopy);
             }
             else
@@ -2918 +3012 @@
  * @param   pszName         Value name. This value must be of zero terminated character string type.
  * @param   ppszString      Where to store the string pointer.
- *                          Free this using MMR3HeapFree().
+ *                          Free this using MMR3HeapFree() (or RTStrFree if not
+ *                          associated with a pUVM - see CFGMR3CreateTree).
  */
 VMMR3DECL(int) CFGMR3QueryStringAlloc(PCFGMNODE pNode, const char *pszName, char **ppszString)
@@ -2926 +3021 @@
     if (RT_SUCCESS(rc))
     {
-        char *pszString = (char *)MMR3HeapAlloc(pNode->pVM, MM_TAG_CFGM_USER, cbString);
+        char *pszString = cfgmR3StrAlloc(pNode->pVM, MM_TAG_CFGM_USER, cbString);
         if (pszString)
         {
@@ -2933 +3028 @@
                 *ppszString = pszString;
             else
-                MMR3HeapFree(pszString);
+                cfgmR3StrFree(pNode->pVM, pszString);
         }
         else
@@ -2953 +3048 @@
  * @param   pszName         Value name. This value must be of zero terminated character string type.
  * @param   ppszString      Where to store the string pointer. Not set on failure.
- *                          Free this using MMR3HeapFree().
+ *                          Free this using MMR3HeapFree() (or RTStrFree if not
+ *                          associated with a pUVM - see CFGMR3CreateTree).
  * @param   pszDef          The default return value.  This can be NULL.
  */
@@ -2971 +3067 @@
         {
             size_t const cbSrc = pLeaf->Value.String.cb;
-            char *pszString = (char *)MMR3HeapAlloc(pNode->pVM, MM_TAG_CFGM_USER, cbSrc);
+            char *pszString = cfgmR3StrAlloc(pNode->pVM, MM_TAG_CFGM_USER, cbSrc);
             if (pszString)
             {
@@ -2988 +3084 @@
             *ppszString = NULL;
         else
-            *ppszString = MMR3HeapStrDup(pNode->pVM, MM_TAG_CFGM_USER, pszDef);
+        {
+            size_t const cbDef = strlen(pszDef) + 1;
+            *ppszString = cfgmR3StrAlloc(pNode->pVM, MM_TAG_CFGM_USER, cbDef);
+            memcpy(*ppszString, pszDef, cbDef);
+        }
         if (rc == VERR_CFGM_VALUE_NOT_FOUND || rc == VERR_CFGM_NO_PARENT)
             rc = VINF_SUCCESS;