Changeset 55421 in vbox for trunk/src/VBox/Devices/Graphics/HGSMI

Timestamp:

Apr 24, 2015 12:00:21 PM (10 years ago)

Author:

vboxsync

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

99763

Message:

HGSMI: cleanup, logging, comments, move legacy host heap support from common code to the host code.

Location:

trunk/src/VBox/Devices/Graphics/HGSMI

Files:

• HGSMIHost.cpp (modified) (28 diffs)
• HGSMIHost.h (modified) (3 diffs)

trunk/src/VBox/Devices/Graphics/HGSMI/HGSMIHost.cpp

@@ -67 +67 @@
 
 #include <VBox/err.h>
-#define LOG_GROUP LOG_GROUP_DEV_VGA
+#define LOG_GROUP LOG_GROUP_HGSMI
 #include <VBox/log.h>
 #include <VBox/vmm/ssm.h>
@@ -133 +133 @@
 
 
+/* Host heap types. */
+#define HGSMI_HEAP_TYPE_NULL    0 /* Heap not initialized. */
+#define HGSMI_HEAP_TYPE_POINTER 1 /* Deprecated, used only for old saved states. RTHEAPSIMPLE. */
+#define HGSMI_HEAP_TYPE_OFFSET  2 /* Deprecated, used only for old saved states. RTHEAPOFFSET. */
+#define HGSMI_HEAP_TYPE_MA      3 /* Memory allocator. */
+
+typedef struct HGSMIHOSTHEAP
+{
+    uint32_t u32HeapType;   /* HGSMI_HEAP_TYPE_* */
+    int32_t volatile cRefs; /* How many blocks allocated. */
+    HGSMIAREA area;         /* Host heap location. */
+    union
+    {
+        HGSMIMADATA ma;     /* Memory allocator for the default host heap implementation. */
+        struct              /* Legacy heap implementations. For old saved states. */
+        {
+            union
+            {
+                RTHEAPSIMPLE hPtr;  /* Pointer based heap. */
+                RTHEAPOFFSET hOff;  /* Offset based heap. */
+            } u;
+        } legacy;
+    } u;
+} HGSMIHOSTHEAP;
+
 typedef struct HGSMIINSTANCE
 {
@@ -142 +167 @@
 
     HGSMIAREA area; /* The shared memory description. */
-    HGSMIHEAP hostHeap;                /* Host heap instance. */
+    HGSMIHOSTHEAP hostHeap;            /* Host heap instance. */
     RTCRITSECT    hostHeapCritSect;    /* Heap serialization lock. */
 
@@ -182 +207 @@
     volatile uint32_t fl;              /* Status flags of the entry. */
 
-    HGSMIOFFSET offBuffer;             /* Offset in the memory region of the entry data. */
+    HGSMIOFFSET offBuffer;             /* Offset of the HGSMI buffer header in the HGSMI host heap:
+                                        * [pIns->hostHeap.area.offBase .. offLast]. */
 
 #if 0
@@ -510 +536 @@
 }
 
+static HGSMIOFFSET hgsmiHostHeapOffset(HGSMIHOSTHEAP *pHeap)
+{
+    return pHeap->area.offBase;
+}
+
+static HGSMISIZE hgsmiHostHeapSize(HGSMIHOSTHEAP *pHeap)
+{
+    return pHeap->area.cbArea;
+}
+
+static void *hgsmiHostHeapBufferAlloc(HGSMIHOSTHEAP *pHeap,
+                                      HGSMISIZE cbBuffer)
+{
+    void *pvBuf = NULL;
+
+    if (pHeap->u32HeapType == HGSMI_HEAP_TYPE_MA)
+    {
+        pvBuf = HGSMIMAAlloc(&pHeap->u.ma, cbBuffer);
+    }
+    else if (pHeap->u32HeapType == HGSMI_HEAP_TYPE_POINTER)
+    {
+        pvBuf = RTHeapSimpleAlloc(pHeap->u.legacy.u.hPtr, cbBuffer, 0);
+    }
+    else if (pHeap->u32HeapType == HGSMI_HEAP_TYPE_OFFSET)
+    {
+        pvBuf = RTHeapOffsetAlloc(pHeap->u.legacy.u.hOff, cbBuffer, 0);
+    }
+
+    if (pvBuf)
+    {
+        ++pHeap->cRefs;
+    }
+
+    return pvBuf;
+}
+
+static void hgsmiHostHeapBufferFree(HGSMIHOSTHEAP *pHeap,
+                                    void *pvBuf)
+{
+    if (pHeap->u32HeapType == HGSMI_HEAP_TYPE_MA)
+    {
+        HGSMIMAFree(&pHeap->u.ma, pvBuf);
+    }
+    else if (pHeap->u32HeapType == HGSMI_HEAP_TYPE_POINTER)
+    {
+        RTHeapSimpleFree(pHeap->u.legacy.u.hPtr, pvBuf);
+    }
+    else if (pHeap->u32HeapType == HGSMI_HEAP_TYPE_OFFSET)
+    {
+        RTHeapOffsetFree(pHeap->u.legacy.u.hOff, pvBuf);
+    }
+    --pHeap->cRefs;
+}
+
+static void *hgsmiHostHeapDataAlloc(HGSMIHOSTHEAP *pHeap,
+                                    HGSMISIZE cbData,
+                                    uint8_t u8Channel,
+                                    uint16_t u16ChannelInfo)
+{
+    HGSMISIZE cbAlloc = HGSMIBufferRequiredSize(cbData);
+    HGSMIBUFFERHEADER *pHeader = (HGSMIBUFFERHEADER *)hgsmiHostHeapBufferAlloc(pHeap, cbAlloc);
+    if (!pHeader)
+        return NULL;
+
+    HGSMIBufferInitializeSingle(&pHeap->area, pHeader, cbAlloc, u8Channel, u16ChannelInfo);
+
+    return HGSMIBufferDataFromPtr(pHeader);
+}
+
+static void hgsmiHostHeapDataFree(HGSMIHOSTHEAP *pHeap,
+                                  void *pvData)
+{
+    if (   pvData
+        && pHeap->u32HeapType != HGSMI_HEAP_TYPE_NULL)
+    {
+        HGSMIBUFFERHEADER *pHeader = HGSMIBufferHeaderFromData(pvData);
+        hgsmiHostHeapBufferFree(pHeap, pHeader);
+    }
+}
+
+/* Needed for heap relocation: offset of the heap handle relative to the start of heap area. */
+static HGSMIOFFSET hgsmiHostHeapHandleLocationOffset(HGSMIHOSTHEAP *pHeap)
+{
+    HGSMIOFFSET offHeapHandle;
+    if (pHeap->u32HeapType == HGSMI_HEAP_TYPE_POINTER)
+    {
+        offHeapHandle = (HGSMIOFFSET)((uintptr_t)pHeap->u.legacy.u.hPtr - (uintptr_t)pHeap->area.pu8Base);
+    }
+    else if (pHeap->u32HeapType == HGSMI_HEAP_TYPE_OFFSET)
+    {
+        offHeapHandle = (HGSMIOFFSET)((uintptr_t)pHeap->u.legacy.u.hOff - (uintptr_t)pHeap->area.pu8Base);
+    }
+    else
+    {
+        offHeapHandle = HGSMIOFFSET_VOID;
+    }
+    return offHeapHandle;
+}
+
+static int hgsmiHostHeapRelocate(HGSMIHOSTHEAP *pHeap,
+                                 uint32_t u32HeapType,
+                                 void *pvBase,
+                                 uint32_t offHeapHandle,
+                                 uintptr_t offDelta,
+                                 HGSMISIZE cbArea,
+                                 HGSMIOFFSET offBase)
+{
+    int rc = HGSMIAreaInitialize(&pHeap->area, pvBase, cbArea, offBase);
+    if (RT_SUCCESS(rc))
+    {
+        if (u32HeapType == HGSMI_HEAP_TYPE_OFFSET)
+        {
+            pHeap->u.legacy.u.hOff = (RTHEAPOFFSET)((uint8_t *)pvBase + offHeapHandle);
+        }
+        else if (u32HeapType == HGSMI_HEAP_TYPE_POINTER)
+        {
+            pHeap->u.legacy.u.hPtr = (RTHEAPSIMPLE)((uint8_t *)pvBase + offHeapHandle);
+            rc = RTHeapSimpleRelocate(pHeap->u.legacy.u.hPtr, offDelta); AssertRC(rc);
+        }
+        else
+        {
+            /* HGSMI_HEAP_TYPE_MA does not need the relocation. */
+            rc = VERR_NOT_SUPPORTED;
+        }
+
+        if (RT_SUCCESS(rc))
+        {
+            pHeap->u32HeapType = u32HeapType;
+        }
+        else
+        {
+            HGSMIAreaClear(&pHeap->area);
+        }
+    }
+
+    return rc;
+}
+
+static int hgsmiHostHeapRestoreMA(HGSMIHOSTHEAP *pHeap,
+                                  void *pvBase,
+                                  HGSMISIZE cbArea,
+                                  HGSMIOFFSET offBase,
+                                  uint32_t cBlocks,
+                                  HGSMIOFFSET *paDescriptors,
+                                  HGSMISIZE cbMaxBlock,
+                                  HGSMIENV *pEnv)
+{
+    int rc = HGSMIAreaInitialize(&pHeap->area, pvBase, cbArea, offBase);
+    if (RT_SUCCESS(rc))
+    {
+        rc = HGSMIMAInit(&pHeap->u.ma, &pHeap->area, paDescriptors, cBlocks, cbMaxBlock, pEnv);
+
+        if (RT_FAILURE(rc))
+        {
+            HGSMIAreaClear(&pHeap->area);
+        }
+    }
+
+    return rc;
+}
+
+static void hgsmiHostHeapSetupUninitialized(HGSMIHOSTHEAP *pHeap)
+{
+    RT_ZERO(*pHeap);
+    pHeap->u32HeapType = HGSMI_HEAP_TYPE_NULL;
+}
+
+static void hgsmiHostHeapDestroy(HGSMIHOSTHEAP *pHeap)
+{
+    if (pHeap->u32HeapType == HGSMI_HEAP_TYPE_MA)
+    {
+        HGSMIMAUninit(&pHeap->u.ma);
+    }
+    hgsmiHostHeapSetupUninitialized(pHeap);
+}
+
 static int hgsmiHostFIFOAlloc (HGSMIINSTANCE *pIns, HGSMIHOSTFIFOENTRY **ppEntry)
 {
@@ -557 +759 @@
 static int hgsmiHostCommandFreeByEntry (HGSMIHOSTFIFOENTRY *pEntry)
 {
+    LogFlowFunc(("offBuffer 0x%08X\n", pEntry->offBuffer));
+
     HGSMIINSTANCE *pIns = pEntry->pIns;
     int rc = hgsmiFIFOLock (pIns);
@@ -564 +768 @@
         hgsmiFIFOUnlock (pIns);
 
-        void *pvMem = HGSMIBufferDataFromOffset(&pIns->area, pEntry->offBuffer);
+        void *pvData = HGSMIBufferDataFromOffset(&pIns->hostHeap.area, pEntry->offBuffer);
 
         rc = hgsmiHostHeapLock (pIns);
@@ -570 +774 @@
         {
             /* Deallocate the host heap memory. */
-            HGSMIHeapFree (&pIns->hostHeap, pvMem);
+            hgsmiHostHeapDataFree(&pIns->hostHeap, pvData);
 
             hgsmiHostHeapUnlock(pIns);
@@ -577 +781 @@
         hgsmiHostFIFOFree (pIns, pEntry);
     }
+
+    LogFlowFunc(("%Rrc\n", rc));
     return rc;
 }
 
 static int hgsmiHostCommandFree (HGSMIINSTANCE *pIns,
-                                                void *pvMem)
-{
-    HGSMIOFFSET offMem = HGSMIHeapBufferOffset (&pIns->hostHeap, pvMem);
+                                                void *pvData)
+{
     int rc = VINF_SUCCESS;
-    if (offMem != HGSMIOFFSET_VOID)
-    {
+    if (HGSMIAreaContainsPointer(&pIns->hostHeap.area, pvData))
+    {
+        HGSMIHOSTFIFOENTRY *pEntry = NULL;
+        HGSMIOFFSET offBuffer = HGSMIBufferOffsetFromData(&pIns->hostHeap.area, pvData);
+
         rc = hgsmiFIFOLock (pIns);
         if(RT_SUCCESS(rc))
         {
-            /* Search the Processed list for the given offMem. */
-            HGSMIHOSTFIFOENTRY *pEntry = NULL;
-
+            /* Search the Processed list for the given offBuffer. */
             HGSMIHOSTFIFOENTRY *pIter;
             RTListForEach(&pIns->hostFIFOProcessed, pIter, HGSMIHOSTFIFOENTRY, nodeEntry)
@@ -598 +804 @@
                 Assert(pIter->fl == (HGSMI_F_HOST_FIFO_ALLOCATED | HGSMI_F_HOST_FIFO_PROCESSED));
 
-                if (pIter->offBuffer == offMem)
+                if (pIter->offBuffer == offBuffer)
                 {
                     pEntry = pIter;
@@ -611 +817 @@
             else
             {
-                LogRel(("HGSMI[%s]: the host frees unprocessed FIFO entry: 0x%08X\n", pIns->pszName, offMem));
-                AssertFailed ();
+                AssertLogRelMsgFailed(("HGSMI[%s]: the host frees unprocessed FIFO entry: 0x%08X\n",
+                                       pIns->pszName, offBuffer));
             }
 
@@ -621 +827 @@
             {
                 /* Deallocate the host heap memory. */
-                HGSMIHeapFree (&pIns->hostHeap, pvMem);
+                hgsmiHostHeapDataFree(&pIns->hostHeap, pvData);
 
                 hgsmiHostHeapUnlock(pIns);
@@ -636 +842 @@
     else
     {
+        AssertLogRelMsgFailed(("HGSMI[%s]: the host frees invalid FIFO entry: %p\n",
+                               pIns->pszName, pvData));
         rc = VERR_INVALID_POINTER;
-        LogRel(("HGSMI[%s]: the host frees invalid FIFO entry: %p\n", pIns->pszName, pvMem));
-        AssertFailed ();
     }
     return rc;
@@ -776 +982 @@
 #endif
 /**
- * Allocate a shared memory block. The host can write command/data to the memory.
- *
- * @param pIns   Pointer to HGSMI instance,
- * @param ppvMem Where to store the allocated memory pointer to data.
- * @param cbMem  How many bytes of data to allocate.
+ * Allocate a shared memory buffer. The host can write command/data to the memory.
+ * The allocated buffer contains the 'header', 'data' and the 'tail', but *ppvData
+ * will point to the 'data'.
+ *
+ * @return VBox status code. Pointer to the payload data in *ppvData.
+ * @param pIns           HGSMI instance,
+ * @param ppvData        Where to store the allocated memory pointer to data.
+ * @param cbData         How many bytes of data to allocate.
+ * @param u8Channel      HGSMI channel.
+ * @param u16ChannelInfo Command parameter.
  */
 int HGSMIHostCommandAlloc (HGSMIINSTANCE *pIns,
-                           void **ppvMem,
-                           HGSMISIZE cbMem,
+                           void **ppvData,
+                           HGSMISIZE cbData,
                            uint8_t u8Channel,
                            uint16_t u16ChannelInfo)
 {
-    LogFlowFunc (("pIns = %p, cbMem = 0x%08X(%d)\n", pIns, cbMem, cbMem));
+    LogFlowFunc (("pIns = %p, cbData = 0x%08X(%d)\n", pIns, cbData, cbData));
 
     int rc = hgsmiHostHeapLock (pIns);
     if(RT_SUCCESS(rc))
     {
-        void *pvMem = HGSMIHeapAlloc (&pIns->hostHeap,
-                                  cbMem,
-                                  u8Channel,
-                                  u16ChannelInfo);
+        void *pvData = hgsmiHostHeapDataAlloc(&pIns->hostHeap,
+                                              cbData,
+                                              u8Channel,
+                                              u16ChannelInfo);
         hgsmiHostHeapUnlock(pIns);
 
-        if (pvMem)
-        {
-            *ppvMem = pvMem;
+        if (pvData)
+        {
+            *ppvData = pvData;
         }
         else
         {
-            LogRel((0, "HGSMIHeapAlloc: HGSMIHeapAlloc failed\n"));
-            rc = VERR_GENERAL_FAILURE;
-        }
-    }
-
-    LogFlowFunc (("rc = %Rrc, pvMem = %p\n", rc, *ppvMem));
-
+            LogRel(("HGSMI[%s]: host heap allocation failed %dbytes\n", pIns->pszName, cbData));
+            rc = VERR_NO_MEMORY;
+        }
+    }
+
+    LogFlowFunc(("%Rrc, pvData = %p\n", rc, *ppvData));
     return rc;
 }
@@ -819 +1029 @@
  * and make it freed on completion.
  * The caller does not get notified in any way on command completion,
- * on success return the pvMem buffer can not be used after being passed to this function
- *
- * @param pIns  Pointer to HGSMI instance,
- * @param pvMem The pointer returned by 'HGSMIHostCommandAlloc'.
- * @param bDoIrq specifies whether the guest interrupt should be generated,
- * i.e. in case the command is not urgent(e.g. some guest command completion notification that does not require post-processing)
- * the command could be posted without raising an irq.
+ * on successful return the pvData buffer can not be used after being passed to this function.
+ *
+ * @param pIns   HGSMI instance,
+ * @param pvData The pointer returned by 'HGSMIHostCommandAlloc'.
+ * @param bDoIrq Specifies whether the guest interrupt should be generated.
+ *               In case the command is not urgent (e.g. some guest command
+ *               completion notification that does not require post-processing)
+ *               the command could be posted without raising an irq.
  */
 int HGSMIHostCommandProcessAndFreeAsynch (PHGSMIINSTANCE pIns,
-                             void *pvMem,
+                             void *pvData,
                              bool bDoIrq)
 {
-    LogFlowFunc(("pIns = %p, pvMem = %p\n", pIns, pvMem));
+    LogFlowFunc(("pIns = %p, pvData = %p\n", pIns, pvData));
 
 #if 0
@@ -837 +1048 @@
 #endif
 
-    HGSMIOFFSET offBuffer = HGSMIHeapBufferOffset (&pIns->hostHeap, pvMem);
+    HGSMIOFFSET offBuffer = HGSMIBufferOffsetFromData(&pIns->hostHeap.area, pvData);
 
     int rc = hgsmiHostCommandProcess (pIns, offBuffer,
@@ -925 +1136 @@
 };
 
-int HGSMISetupHostHeap (PHGSMIINSTANCE pIns,
-                        HGSMIOFFSET    offHeap,
-                        HGSMISIZE      cbHeap)
+int HGSMIHostHeapSetup(PHGSMIINSTANCE pIns,
+                       HGSMIOFFSET    offHeap,
+                       HGSMISIZE      cbHeap)
 {
     LogFlowFunc(("pIns %p, offHeap 0x%08X, cbHeap = 0x%08X\n", pIns, offHeap, cbHeap));
@@ -933 +1144 @@
     int rc = VINF_SUCCESS;
 
-    Assert (pIns);
-
-//    if (   offHeap >= pIns->cbMem
-//        || cbHeap > pIns->cbMem
-//        || offHeap + cbHeap > pIns->cbMem)
-//    {
-//        rc = VERR_INVALID_PARAMETER;
-//    }
-//    else
+    AssertPtrReturn(pIns, VERR_INVALID_PARAMETER);
+
+    if (   offHeap >= pIns->area.cbArea
+        || cbHeap > pIns->area.cbArea
+        || offHeap > pIns->area.cbArea - cbHeap)
+    {
+        AssertLogRelMsgFailed(("offHeap 0x%08X, cbHeap = 0x%08X, pIns->area.cbArea 0x%08X\n",
+                               offHeap, cbHeap, pIns->area.cbArea));
+        rc = VERR_INVALID_PARAMETER;
+    }
+    else
     {
         rc = hgsmiHostHeapLock (pIns);
@@ -949 +1162 @@
             if (pIns->hostHeap.cRefs)
             {
-                AssertFailed();
+                AssertLogRelMsgFailed(("HGSMI[%s]: host heap setup ignored. %d allocated.\n",
+                                       pIns->pszName, pIns->hostHeap.cRefs));
                 /* It is possible to change the heap only if there is no pending allocations. */
                 rc = VERR_ACCESS_DENIED;
@@ -955 +1169 @@
             else
             {
-                rc = HGSMIHeapSetup (&pIns->hostHeap,
-                                     HGSMI_HEAP_TYPE_MA,
-                                     pIns->area.pu8Base+offHeap,
-                                     cbHeap,
-                                     offHeap,
-                                     &g_hgsmiEnv);
+                rc = HGSMIAreaInitialize(&pIns->hostHeap.area, pIns->area.pu8Base + offHeap, cbHeap, offHeap);
+                if (RT_SUCCESS(rc))
+                {
+                    rc = HGSMIMAInit(&pIns->hostHeap.u.ma, &pIns->hostHeap.area, NULL, 0, 0, &g_hgsmiEnv);
+                }
+
+                if (RT_SUCCESS(rc))
+                {
+                    pIns->hostHeap.u32HeapType = HGSMI_HEAP_TYPE_MA;
+                }
+                else
+                {
+                    HGSMIAreaClear(&pIns->hostHeap.area);
+                }
             }
 
@@ -1205 +1427 @@
     off = pIns->hostHeap.u32HeapType == HGSMI_HEAP_TYPE_MA?
               0:
-              HGSMIHeapHandleLocationOffset(&pIns->hostHeap);
+              hgsmiHostHeapHandleLocationOffset(&pIns->hostHeap);
     rc = SSMR3PutU32 (pSSM, off);
     if(off != HGSMIOFFSET_VOID)
     {
-        SSMR3PutU32 (pSSM, HGSMIHeapOffset(&pIns->hostHeap));
-        SSMR3PutU32 (pSSM, HGSMIHeapSize(&pIns->hostHeap));
+        SSMR3PutU32 (pSSM, hgsmiHostHeapOffset(&pIns->hostHeap));
+        SSMR3PutU32 (pSSM, hgsmiHostHeapSize(&pIns->hostHeap));
         /* need save mem pointer to calculate offset on restore */
         SSMR3PutU64 (pSSM, (uint64_t)(uintptr_t)pIns->area.pu8Base);
@@ -1261 +1483 @@
     pIns->pHGFlags = (off != HGSMIOFFSET_VOID) ? (HGSMIHOSTFLAGS*)HGSMIOffsetToPointer (&pIns->area, off) : NULL;
 
-    HGSMIHEAP hHeap = pIns->hostHeap;
+    HGSMIHOSTHEAP hHeap = pIns->hostHeap;
     rc = SSMR3GetU32(pSSM, &off);
     AssertRCReturn(rc, rc);
@@ -1311 +1533 @@
                 if (RT_SUCCESS(rc))
                 {
-                    rc = HGSMIHeapRestoreMA(&pIns->hostHeap,
-                                            pIns->area.pu8Base+offHeap,
-                                            cbHeap,
-                                            offHeap,
-                                            cBlocks,
-                                            paDescriptors,
-                                            cbMaxBlock,
-                                            &g_hgsmiEnv);
+                    rc = hgsmiHostHeapRestoreMA(&pIns->hostHeap,
+                                                pIns->area.pu8Base+offHeap,
+                                                cbHeap,
+                                                offHeap,
+                                                cBlocks,
+                                                paDescriptors,
+                                                cbMaxBlock,
+                                                &g_hgsmiEnv);
 
                     RTMemFree(paDescriptors);
@@ -1332 +1554 @@
                     pIns->hostHeap.cRefs = 0;
 
-                    rc = HGSMIHeapRelocate(&pIns->hostHeap,
-                                           u32HeapType,
-                                           pIns->area.pu8Base+offHeap,
-                                           off,
-                                           uintptr_t(pIns->area.pu8Base) - uintptr_t(oldMem),
-                                           cbHeap,
-                                           offHeap);
+                    rc = hgsmiHostHeapRelocate(&pIns->hostHeap,
+                                               u32HeapType,
+                                               pIns->area.pu8Base+offHeap,
+                                               off,
+                                               uintptr_t(pIns->area.pu8Base) - uintptr_t(oldMem),
+                                               cbHeap,
+                                               offHeap);
 
                     hgsmiHostHeapUnlock (pIns);
@@ -1534 +1756 @@
                  size_t         cbContext)
 {
-    LogFlowFunc(("ppIns = %p, pVM = %p, pszName = [%s], pu8MemBase = %p, cbMem = 0x%08X, offMemBase = 0x%08X, "
+    LogFlowFunc(("ppIns = %p, pVM = %p, pszName = [%s], offBase = 0x%08X, pu8MemBase = %p, cbMem = 0x%08X, "
                  "pfnNotifyGuest = %p, pvNotifyGuest = %p, cbContext = %d\n",
                  ppIns,
                  pVM,
                  pszName,
+                 offBase,
                  pu8MemBase,
                  cbMem,
@@ -1585 +1808 @@
         pIns->pszName        = VALID_PTR(pszName)? pszName: "";
 
-        HGSMIHeapSetupUninitialized(&pIns->hostHeap);
+        hgsmiHostHeapSetupUninitialized(&pIns->hostHeap);
 
         pIns->pfnNotifyGuest = pfnNotifyGuest;
@@ -1634 +1857 @@
 #endif
 
-    HGSMIHeapDestroy(&pIns->hostHeap);
-
-    HGSMIHeapSetupUninitialized(&pIns->hostHeap);
+    hgsmiHostHeapDestroy(&pIns->hostHeap);
 
     return flags;
@@ -1647 +1868 @@
     if (pIns)
     {
-        HGSMIHeapDestroy(&pIns->hostHeap);
+        hgsmiHostHeapDestroy(&pIns->hostHeap);
 
         if (RTCritSectIsInitialized (&pIns->hostHeapCritSect))

trunk/src/VBox/Devices/Graphics/HGSMI/HGSMIHost.h

@@ -69 +69 @@
                               uint8_t *pu8Channel);
 
-int HGSMISetupHostHeap (PHGSMIINSTANCE pIns,
-                        HGSMIOFFSET    offHeap,
-                        HGSMISIZE      cbHeap);
+int HGSMIHostHeapSetup(PHGSMIINSTANCE pIns,
+                       HGSMIOFFSET    offHeap,
+                       HGSMISIZE      cbHeap);
 
 int HGSMISaveStateExec (PHGSMIINSTANCE pIns, PSSMHANDLE pSSM);
@@ -107 +107 @@
 /* Allocate a buffer in the host heap. */
 int HGSMIHostCommandAlloc (PHGSMIINSTANCE pIns,
-                           void **ppvMem,
-                           HGSMISIZE cbMem,
+                           void **ppvData,
+                           HGSMISIZE cbData,
                            uint8_t u8Channel,
                            uint16_t u16ChannelInfo);
@@ -116 +116 @@
 
 int HGSMIHostCommandProcessAndFreeAsynch (PHGSMIINSTANCE pIns,
-                             void *pvMem,
+                             void *pvData,
                              bool bDoIrq);