Changeset 5135

Timestamp:

10/02/07 11:17:01 (1 year ago)

Author:

vboxsync

Message:

More GMM code.

Files:

• trunk/include/VBox/err.h (modified) (1 diff)
• trunk/include/VBox/gmm.h (modified) (2 diffs)
• trunk/include/VBox/vmm.h (modified) (1 diff)
• trunk/src/VBox/VMM/VMMR0/GMMR0.cpp (modified) (18 diffs)
• trunk/src/VBox/VMM/VMMR0/GMMR0Internal.h (modified) (1 diff)
• trunk/src/VBox/VMM/VMMR0/VMMR0.cpp (modified) (2 diffs)

trunk/include/VBox/err.h

@@ -1123 +1123 @@
-/** Hit the a VM account limit. */
-#define VERR_GMM_HIT_VM_ACCOUNT_LIMIT               (-4153)
+/** Attempt to free more memory than what was previously allocated. */
+#define VERR_GMM_ATTEMPT_TO_FREE_TOO_MUCH           (-4154)
+/** Attempted to report too many pages as deflated.  */
+#define VERR_GMM_ATTEMPT_TO_DEFLATE_TOO_MUCH        (-4155)
-/** The page to be freed or updated was not found. */
-4
+6
-/** The specified shared page was not actually private. */
-5
+7
-/** The specified shared page was not actually shared. */
-
+
+
+
+
+
-/** The reservation or reservation update was declined - too many VMs, too
- * little memory, and/or too low GMM configuration. */
-57
+61
-/** @} */
-

trunk/include/VBox/gmm.h

@@ -220 +220 @@
-GMMR0DECL(int)  GMMR0AllocatePages(PVM pVM, uint32_t cPages, PGMMPAGEDESC paPages, GMMACCOUNT enmAccount);
-GMMR0DECL(int)  GMMR0FreePages(PVM pVM, uint32_t cPages, PGMMFREEPAGEDESC paPages, GMMACCOUNT enmAccount);
-
+
+
-GMMR0DECL(int)  GMMR0FreeMapUnmapChunk(PVM pVM, uint32_t idChunkMap, uint32_t idChunkUnmap, PRTR3PTR pvR3);
-GMMR0DECL(int)  GMMR0SeedChunk(PVM pVM, RTR3PTR pvR3);
@@ -317 +318 @@
-    /** The number of pages to free. */
-    uint32_t        cPagesToFree;
+    /** Whether the ballooning request is completed or more pages are still to come. */
+    bool            fCompleted;
-    /** Array of free page descriptors. */
-    GMMFREEPAGEDESC aPages[1];

trunk/include/VBox/vmm.h

@@ -386 +386 @@
-    /** Call GMMR0BalloonedPages(). */
-    VMMR0_DO_GMM_BALLOONED_PAGES,
+    /** Call GMMR0DeflatedBalloon(). */
+    VMMR0_DO_GMM_DEFLATED_BALLOON,
-    /** Call GMMR0MapUnmapChunk(). */
-    VMMR0_DO_GMM_MAP_UNMAP_CHUNK,

trunk/src/VBox/VMM/VMMR0/GMMR0.cpp

@@ -483 +483 @@
-     * (The number of pages we've allocated from the host can be derived from this.) */
-    uint32_t            cChunks;
+    /** The number of current ballooned pages. */
+    uint64_t            cBalloonedPages;
-
-    /** The legacy mode indicator.
@@ -543 +545 @@
-static DECLCALLBACK(int) gmmR0TermDestroyChunk(PAVLU32NODECORE pNode, void *pvGMM);
-static DECLCALLBACK(int) gmmR0FreeVMPagesInChunk(PAVLU32NODECORE pNode, void *pvhGVM);
+static void gmmR0FreeSharedPage(PGMM pGMM, uint32_t idPage, PGMMPAGE pPage);
-
-
@@ -1021 +1024 @@
- * Finds a allocation chunk.
- *
+ * This is not expected to fail and will bitch if it does.
+ *
- * @returns Pointer to the allocation chunk, NULL if not found.
- * @param   pGMM        Pointer to the GMM instance.
@@ -1034 +1039 @@
- * Finds a page.
- *
+ * This is not expected to fail and will bitch if it does.
+ *
- * @returns Pointer to the page, NULL if not found.
- * @param   pGMM        Pointer to the GMM instance.
@@ -1040 +1047 @@
-DECLINLINE(PGMMPAGE) gmmR0GetPage(PGMM pGMM, uint32_t idPage)
-{
+    /* must log pages that aren't found.  */
-    return NULL;
-}
+
-
-/**
@@ -1159 +1168 @@
-
-    return pGMM->idChunkPrev = idChunk;
-}
-
-
-/**
- * Frees a chunk, giving it back to the host OS.
- *
- * @param   pGMM        Pointer to the GMM instance.
- * @param   pChunk      The chunk to free.
- */
-static void gmmR0FreeChunk(PGMM pGMM, PGMMCHUNK pChunk)
-{
-    /*
-     * If there are current mappings of the chunk, then request the
-     * VMs to unmap them. Reposition the chunk in the free list so
-     * it won't be a likely candidate for allocations.
-     */
-    if (pChunk->cMappings)
-    {
-        /** @todo R0 -> VM request */
-
-    }
-    else
-    {
-        /*
-         * Try free the memory object.
-         */
-        int rc = RTR0MemObjFree(pChunk->MemObj, false /* fFreeMappings */);
-        if (RT_SUCCESS(rc))
-        {
-            pChunk->MemObj = NIL_RTR0MEMOBJ;
-
-            /*
-             * Unlink it from everywhere.
-             */
-            gmmR0UnlinkChunk(pChunk);
-
-            PAVLU32NODECORE pCore = RTAvlU32Remove(&pGMM->pChunks, pChunk->Core.Key);
-            Assert(pCore == &pChunk->Core); NOREF(pCore);
-
-            PGMMCHUNKTLBE pTlbe = &pGMM->ChunkTLB.aEntries[GMM_CHUNKTLB_IDX(pCore->Key)];
-            if (pTlbe->pChunk == pChunk)
-            {
-                pTlbe->idChunk = NIL_GMM_CHUNKID;
-                pTlbe->pChunk = NULL;
-            }
-
-            Assert(pGMM->cChunks > 0);
-            pGMM->cChunks--;
-
-            /*
-             * Free the Chunk ID and struct.
-             */
-            gmmR0FreeChunkId(pGMM, pChunk->Core.Key);
-            pChunk->Core.Key = NIL_GMM_CHUNKID;
-
-            RTMemFree(pChunk->paMappings);
-            pChunk->paMappings = NULL;
-
-            RTMemFree(pChunk);
-        }
-        else
-            AssertRC(rc);
-    }
-}
-
-
-/**
- * Free page worker.
- *
- * The caller does all the statistic decrementing, we do all the incrementing.
- *
- * @param   pGMM        Pointer to the GMM instance data.
- * @param   pChunk      Pointer to the chunk this page belongs to.
- * @param   pPage       Pointer to the page.
- */
-static void gmmR0FreePageWorker(PGMM pGMM, PGMMCHUNK pChunk, PGMMPAGE pPage)
-{
-    /*
-     * Put the page on the free list.
-     */
-    pPage->u = 0;
-    pPage->Free.u2State = GMM_PAGE_STATE_FREE;
-    Assert(pChunk->iFreeHead < RT_ELEMENTS(pChunk->aPages) || pChunk->iFreeHead == UINT16_MAX);
-    pPage->Free.iNext = pChunk->iFreeHead;
-    pChunk->iFreeHead = pPage - &pChunk->aPages[0];
-
-    /*
-     * Update statistics (the cShared/cPrivate stats are up to date already),
-     * and relink the chunk if necessary.
-     */
-    if ((pChunk->cFree & GMM_CHUNK_FREE_SET_MASK) == 0)
-    {
-        gmmR0UnlinkChunk(pChunk);
-        pChunk->cFree++;
-        gmmR0LinkChunk(pChunk, pChunk->cShared ? &pGMM->Shared : &pGMM->Private);
-    }
-    else
-    {
-        pChunk->cFree++;
-        pChunk->pSet->cPages++;
-
-        /*
-         * If the chunk becomes empty, consider giving memory back to the host OS.
-         *
-         * The current strategy is to try give it back if there are other chunks
-         * in this free list, meaning if there are at least 240 free pages in this
-         * category. Note that since there are probably mappings of the chunk,
-         * it won't be freed up instantly, which probably screws up this logic
-         * a bit...
-         */
-        if (RT_UNLIKELY(   pChunk->cFree == GMM_CHUNK_NUM_PAGES
-                        && pChunk->pFreeNext
-                        && pChunk->pFreePrev))
-            gmmR0FreeChunk(pGMM, pChunk);
-    }
-}
-
-
-/**
- * Frees a shared page, the page is known to exist and be valid and such.
- *
- * @param   pGMM        Pointer to the GMM instance.
- * @param   idPage      The Page ID
- * @param   pPage       The page structure.
- */
-static void gmmR0FreeSharedPage(PGMM pGMM, uint32_t idPage, PGMMPAGE pPage)
-{
-    PGMMCHUNK pChunk = gmmR0GetChunk(pGMM, idPage >> GMM_CHUNKID_SHIFT);
-    Assert(pChunk);
-    Assert(pChunk->cFree < GMM_CHUNK_NUM_PAGES);
-    Assert(pChunk->cShared > 0);
-    Assert(pGMM->cSharedPages > 0);
-    Assert(pGMM->cAllocatedPages > 0);
-
-    pChunk->cShared--;
-    pGMM->cAllocatedPages--;
-    pGMM->cSharedPages--;
-    gmmR0FreePageWorker(pGMM, pChunk, pPage);
-}
-
@@ -1471 +1342 @@
-        case GMMACCOUNT_BASE:
-            if (RT_UNLIKELY(pGVM->gmm.s.Allocated.cBasePages + cPages > pGVM->gmm.s.Reserved.cBasePages))
+            {
+                Log(("gmmR0AllocatePages: Reserved=%#llx Allocated+Requested=%#llx+%#x!\n",
+                     pGVM->gmm.s.Reserved.cBasePages, pGVM->gmm.s.Allocated.cBasePages, cPages));
-                return VERR_GMM_HIT_VM_ACCOUNT_LIMIT;
+            }
-            break;
-        case GMMACCOUNT_SHADOW:
-            if (RT_UNLIKELY(pGVM->gmm.s.Allocated.cShadowPages + cPages > pGVM->gmm.s.Reserved.cShadowPages))
+            {
+                Log(("gmmR0AllocatePages: Reserved=%#llx Allocated+Requested=%#llx+%#x!\n",
+                     pGVM->gmm.s.Reserved.cShadowPages, pGVM->gmm.s.Allocated.cShadowPages, cPages));
-                return VERR_GMM_HIT_VM_ACCOUNT_LIMIT;
+            }
-            break;
-        case GMMACCOUNT_FIXED:
-            if (RT_UNLIKELY(pGVM->gmm.s.Allocated.cFixedPages + cPages > pGVM->gmm.s.Reserved.cFixedPages))
+            {
+                Log(("gmmR0AllocatePages: Reserved=%#llx Allocated+Requested=%#llx+%#x!\n",
+                     pGVM->gmm.s.Reserved.cFixedPages, pGVM->gmm.s.Allocated.cFixedPages, cPages));
-                return VERR_GMM_HIT_VM_ACCOUNT_LIMIT;
+            }
-            break;
-        default:
@@ -1565 +1448 @@
-    switch (enmAccount)
-    {
-
+  
-        case GMMACCOUNT_SHADOW: pGVM->gmm.s.Allocated.cShadowPages += iPage;
-
+ 
-        default:
-            AssertMsgFailedReturn(("enmAccount=%d\n", enmAccount), VERR_INTERNAL_ERROR);
-    }
-    pGVM->gmm.s.cPrivatePages += iPage;
-
+    
-
-    AssertMsgReturn(iPage == cPages, ("%d != %d\n", iPage, cPages), VERR_INTERNAL_ERROR);
@@ -1602 +1485 @@
-GMMR0DECL(int) GMMR0AllocateHandyPages(PVM pVM, uint32_t cPagesToUpdate, uint32_t cPagesToAlloc, PGMMPAGEDESC paPages)
-{
+    LogFlow(("GMMR0AllocateHandyPages: pVM=%p cPagesToUpdate=%#x cPagesToAlloc=%#x paPages=%p\n",
+             pVM, cPagesToUpdate, cPagesToAlloc, paPages));
+
-    /*
-     * Validate, get basics and take the semaphore.
@@ -1654 +1540 @@
-        /*
-         * Perform the updates.
+         * Stop on the first error.
-         */
-        for (iPage = 0; iPage < cPagesToUpdate; iPage++)
@@ -1664 +1551 @@
-                    if (RT_LIKELY(GMM_PAGE_IS_PRIVATE(pPage)))
-                    {
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                    }
-                    else
+                    {
+                        Log(("GMMR0AllocateHandyPages: #%#x/%#x: Not private!\n", iPage, paPages[iPage].idPage));
-                        rc = VERR_GMM_PAGE_NOT_PRIVATE;
+                        break;
+                    }
-                }
-                else
+                {
+                    Log(("GMMR0AllocateHandyPages: #%#x/%#x: Not found! (private)\n", iPage, paPages[iPage].idPage));
-                    rc = VERR_GMM_PAGE_NOT_FOUND;
+                    break;
+                }
-            }
-
@@ -1690 +1595 @@
-                        AssertCompile(NIL_RTHCPHYS > GMM_GCPHYS_END && GMM_GCPHYS_UNSHAREABLE > GMM_GCPHYS_END);
-                        Assert(pPage->Shared.cRefs);
+                        Assert(pGVM->gmm.s.cSharedPages);
+                        Assert(pGVM->gmm.s.Allocated.cBasePages);
+
+                        pGVM->gmm.s.cSharedPages--;
+                        pGVM->gmm.s.Allocated.cBasePages--;
-                        if (!--pPage->Shared.cRefs)
-                        {
-                            Assert(pGVM->gmm.s.cSharedPages);
-                            pGVM->gmm.s.cSharedPages--;
-                            Assert(pGVM->gmm.s.Allocated.cBasePages);
-                            pGVM->gmm.s.Allocated.cBasePages--;
-                            gmmR0FreeSharedPage(pGMM, paPages[iPage].idSharedPage, pPage);
-                        }
-
-                        paPages[iPage].idSharedPage = NIL_GMM_PAGEID;
-                    }
-                    else
+                    {
+                        Log(("GMMR0AllocateHandyPages: #%#x/%#x: Not shared!\n", iPage, paPages[iPage].idSharedPage));
-                        rc = VERR_GMM_PAGE_NOT_SHARED;
+                        break;
+                    }
-                }
-                else
+                {
+                    Log(("GMMR0AllocateHandyPages: #%#x/%#x: Not found! (shared)\n", iPage, paPages[iPage].idSharedPage));
-                    rc = VERR_GMM_PAGE_NOT_FOUND;
+                    break;
+                }
-            }
-        }
-
-        /*
-And
+Join paths with GMMR0AllocatePages for
-         */
-        if (RT_SUCCESS(rc))
@@ -1719 +1631 @@
-
-    RTSemFastMutexRelease(pGMM->Mtx);
-UpdateReservation
+AllocateHandyPages
-    return rc;
-}
@@ -1815 +1727 @@
-
-/**
+ * Frees a chunk, giving it back to the host OS.
+ *
+ * @param   pGMM        Pointer to the GMM instance.
+ * @param   pChunk      The chunk to free.
+ */
+static void gmmR0FreeChunk(PGMM pGMM, PGMMCHUNK pChunk)
+{
+    /*
+     * If there are current mappings of the chunk, then request the
+     * VMs to unmap them. Reposition the chunk in the free list so
+     * it won't be a likely candidate for allocations.
+     */
+    if (pChunk->cMappings)
+    {
+        /** @todo R0 -> VM request */
+
+    }
+    else
+    {
+        /*
+         * Try free the memory object.
+         */
+        int rc = RTR0MemObjFree(pChunk->MemObj, false /* fFreeMappings */);
+        if (RT_SUCCESS(rc))
+        {
+            pChunk->MemObj = NIL_RTR0MEMOBJ;
+
+            /*
+             * Unlink it from everywhere.
+             */
+            gmmR0UnlinkChunk(pChunk);
+
+            PAVLU32NODECORE pCore = RTAvlU32Remove(&pGMM->pChunks, pChunk->Core.Key);
+            Assert(pCore == &pChunk->Core); NOREF(pCore);
+
+            PGMMCHUNKTLBE pTlbe = &pGMM->ChunkTLB.aEntries[GMM_CHUNKTLB_IDX(pCore->Key)];
+            if (pTlbe->pChunk == pChunk)
+            {
+                pTlbe->idChunk = NIL_GMM_CHUNKID;
+                pTlbe->pChunk = NULL;
+            }
+
+            Assert(pGMM->cChunks > 0);
+            pGMM->cChunks--;
+
+            /*
+             * Free the Chunk ID and struct.
+             */
+            gmmR0FreeChunkId(pGMM, pChunk->Core.Key);
+            pChunk->Core.Key = NIL_GMM_CHUNKID;
+
+            RTMemFree(pChunk->paMappings);
+            pChunk->paMappings = NULL;
+
+            RTMemFree(pChunk);
+        }
+        else
+            AssertRC(rc);
+    }
+}
+
+
+/**
+ * Free page worker.
+ *
+ * The caller does all the statistic decrementing, we do all the incrementing.
+ *
+ * @param   pGMM        Pointer to the GMM instance data.
+ * @param   pChunk      Pointer to the chunk this page belongs to.
+ * @param   pPage       Pointer to the page.
+ */
+static void gmmR0FreePageWorker(PGMM pGMM, PGMMCHUNK pChunk, PGMMPAGE pPage)
+{
+    /*
+     * Put the page on the free list.
+     */
+    pPage->u = 0;
+    pPage->Free.u2State = GMM_PAGE_STATE_FREE;
+    Assert(pChunk->iFreeHead < RT_ELEMENTS(pChunk->aPages) || pChunk->iFreeHead == UINT16_MAX);
+    pPage->Free.iNext = pChunk->iFreeHead;
+    pChunk->iFreeHead = pPage - &pChunk->aPages[0];
+
+    /*
+     * Update statistics (the cShared/cPrivate stats are up to date already),
+     * and relink the chunk if necessary.
+     */
+    if ((pChunk->cFree & GMM_CHUNK_FREE_SET_MASK) == 0)
+    {
+        gmmR0UnlinkChunk(pChunk);
+        pChunk->cFree++;
+        gmmR0LinkChunk(pChunk, pChunk->cShared ? &pGMM->Shared : &pGMM->Private);
+    }
+    else
+    {
+        pChunk->cFree++;
+        pChunk->pSet->cPages++;
+
+        /*
+         * If the chunk becomes empty, consider giving memory back to the host OS.
+         *
+         * The current strategy is to try give it back if there are other chunks
+         * in this free list, meaning if there are at least 240 free pages in this
+         * category. Note that since there are probably mappings of the chunk,
+         * it won't be freed up instantly, which probably screws up this logic
+         * a bit...
+         */
+        if (RT_UNLIKELY(   pChunk->cFree == GMM_CHUNK_NUM_PAGES
+                        && pChunk->pFreeNext
+                        && pChunk->pFreePrev))
+            gmmR0FreeChunk(pGMM, pChunk);
+    }
+}
+
+
+/**
+ * Frees a shared page, the page is known to exist and be valid and such.
+ *
+ * @param   pGMM        Pointer to the GMM instance.
+ * @param   idPage      The Page ID
+ * @param   pPage       The page structure.
+ */
+DECLINLINE(void) gmmR0FreeSharedPage(PGMM pGMM, uint32_t idPage, PGMMPAGE pPage)
+{
+    PGMMCHUNK pChunk = gmmR0GetChunk(pGMM, idPage >> GMM_CHUNKID_SHIFT);
+    Assert(pChunk);
+    Assert(pChunk->cFree < GMM_CHUNK_NUM_PAGES);
+    Assert(pChunk->cShared > 0);
+    Assert(pGMM->cSharedPages > 0);
+    Assert(pGMM->cAllocatedPages > 0);
+    Assert(!pPage->Shared.cRefs);
+
+    pChunk->cShared--;
+    pGMM->cAllocatedPages--;
+    pGMM->cSharedPages--;
+    gmmR0FreePageWorker(pGMM, pChunk, pPage);
+}
+
+
+/**
+ * Frees a private page, the page is known to exist and be valid and such.
+ *
+ * @param   pGMM        Pointer to the GMM instance.
+ * @param   idPage      The Page ID
+ * @param   pPage       The page structure.
+ */
+DECLINLINE(void) gmmR0FreePrivatePage(PGMM pGMM, uint32_t idPage, PGMMPAGE pPage)
+{
+    PGMMCHUNK pChunk = gmmR0GetChunk(pGMM, idPage >> GMM_CHUNKID_SHIFT);
+    Assert(pChunk);
+    Assert(pChunk->cFree < GMM_CHUNK_NUM_PAGES);
+    Assert(pChunk->cPrivate > 0);
+    Assert(pGMM->cAllocatedPages > 0);
+
+    pChunk->cPrivate--;
+    pGMM->cAllocatedPages--;
+    gmmR0FreePageWorker(pGMM, pChunk, pPage);
+}
+
+
+/**
+ * Common worker for GMMR0FreePages and GMMR0BalloonedPages.
+ *
+ * @returns VBox status code:
+ * @retval  xxx
+ *
+ * @param   pGMM                Pointer to the GMM instance data.
+ * @param   pGVM                Pointer to the shared VM structure.
+ * @param   cPages              The number of pages to free.
+ * @param   paPages             Pointer to the page descriptors.
+ * @param   enmAccount          The account this relates to.
+ */
+static int gmmR0FreePages(PGMM pGMM, PGVM pGVM, uint32_t cPages, PGMMFREEPAGEDESC paPages, GMMACCOUNT enmAccount)
+{
+    /*
+     * Check that the request isn't impossible wrt to the account status.
+     */
+    switch (enmAccount)
+    {
+        case GMMACCOUNT_BASE:
+            if (RT_UNLIKELY(pGVM->gmm.s.Allocated.cBasePages < cPages))
+            {
+                Log(("gmmR0FreePages: allocated=%#llx cPages=%#x!\n", pGVM->gmm.s.Allocated.cBasePages, cPages));
+                return VERR_GMM_ATTEMPT_TO_FREE_TOO_MUCH;
+            }
+            break;
+        case GMMACCOUNT_SHADOW:
+            if (RT_UNLIKELY(pGVM->gmm.s.Allocated.cShadowPages < cPages))
+            {
+                Log(("gmmR0FreePages: allocated=%#llx cPages=%#x!\n", pGVM->gmm.s.Allocated.cShadowPages, cPages));
+                return VERR_GMM_ATTEMPT_TO_FREE_TOO_MUCH;
+            }
+            break;
+        case GMMACCOUNT_FIXED:
+            if (RT_UNLIKELY(pGVM->gmm.s.Allocated.cFixedPages < cPages))
+            {
+                Log(("gmmR0FreePages: allocated=%#llx cPages=%#x!\n", pGVM->gmm.s.Allocated.cFixedPages, cPages));
+                return VERR_GMM_ATTEMPT_TO_FREE_TOO_MUCH;
+            }
+            break;
+        default:
+            AssertMsgFailedReturn(("enmAccount=%d\n", enmAccount), VERR_INTERNAL_ERROR);
+    }
+
+    /*
+     * Walk the descriptors and free the pages.
+     *
+     * Statistics (except the account) are being updated as we go along,
+     * unlike the alloc code. Also, stop on the first error.
+     */
+    int rc = VINF_SUCCESS;
+    uint32_t iPage;
+    for (iPage = 0; iPage < cPages; iPage++)
+    {
+        uint32_t idPage = paPages[iPage].idPage;
+        PGMMPAGE pPage = gmmR0GetPage(pGMM, idPage);
+        if (RT_LIKELY(pPage))
+        {
+            if (RT_LIKELY(GMM_PAGE_IS_PRIVATE(pPage)))
+            {
+                if (RT_LIKELY(pPage->Private.hGVM == pGVM->hSelf))
+                {
+                    Assert(pGVM->gmm.s.cPrivatePages);
+                    pGVM->gmm.s.cPrivatePages--;
+                    gmmR0FreePrivatePage(pGMM, idPage, pPage);
+                }
+                else
+                {
+                    Log(("gmmR0AllocatePages: #%#x/%#x: not owner! hGVM=%#x hSelf=%#x\n", iPage, idPage,
+                         pPage->Private.hGVM, pGVM->hEMT));
+                    rc = VERR_GMM_NOT_PAGE_OWNER;
+                    break;
+                }
+            }
+            else if (RT_LIKELY(GMM_PAGE_IS_SHARED(pPage)))
+            {
+                Assert(pGVM->gmm.s.cSharedPages);
+                pGVM->gmm.s.cSharedPages--;
+                Assert(pPage->Shared.cRefs);
+                if (!--pPage->Shared.cRefs)
+                    gmmR0FreeSharedPage(pGMM, idPage, pPage);
+            }
+            else
+            {
+                Log(("gmmR0AllocatePages: #%#x/%#x: already free!\n", iPage, idPage));
+                rc = VERR_GMM_PAGE_ALREADY_FREE;
+                break;
+            }
+        }
+        else
+        {
+            Log(("gmmR0AllocatePages: #%#x/%#x: not found!\n", iPage, idPage));
+            rc = VERR_GMM_PAGE_NOT_FOUND;
+            break;
+        }
+        paPages[iPage].idPage = NIL_GMM_PAGEID;
+    }
+
+    /*
+     * Update the account.
+     */
+    switch (enmAccount)
+    {
+        case GMMACCOUNT_BASE:   pGVM->gmm.s.Allocated.cBasePages   -= iPage;
+        case GMMACCOUNT_SHADOW: pGVM->gmm.s.Allocated.cShadowPages -= iPage;
+        case GMMACCOUNT_FIXED:  pGVM->gmm.s.Allocated.cFixedPages  -= iPage;
+        default:
+            AssertMsgFailedReturn(("enmAccount=%d\n", enmAccount), VERR_INTERNAL_ERROR);
+    }
+
+    /*
+     * Any threshold stuff to be done here?
+     */
+
+    return rc;
+}
+
+
+/**
- * Free one or more pages.
- *
@@ -1830 +2020 @@
-GMMR0DECL(int) GMMR0FreePages(PVM pVM, uint32_t cPages, PGMMFREEPAGEDESC paPages, GMMACCOUNT enmAccount)
-{
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}
-
@@ -1860 +2082 @@
-
-/**
-
-
-
+
+
+
+
+
+
+
+
+
- *
- * @returns VBox status code:
@@ -1871 +2099 @@
- * @param   cPagesToFree        The number of pages to be freed.
- * @param   paPages             Pointer to the page descriptors for the pages that's to be freed.
+ * @param   fCompleted          Indicates whether the ballooning request was completed (true) or
+ *                              if there is more pages to come (false). If the ballooning was not
+ *                              not triggered by the GMM, don't set this.
- * @thread  EMT.
- */
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}
-
@@ -1900 +2203 @@
-                    VERR_INVALID_PARAMETER);
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}
-

trunk/src/VBox/VMM/VMMR0/GMMR0Internal.h

@@ -63 +63 @@
-    /** The max number of pages that can be ballooned. */
-    uint64_t        cMaxBalloonedPages;
-
+
+
-    uint64_t        cReqBalloonedPages;
+    /** The number of pages the guest has given us in response to the request.
+     * This is not reset on request completed and may be used in later decisions. */
+    uint64_t        cReqActuallyBalloonedPages;
+    /** The number of pages we've currently requested the guest to take back. */
+    uint64_t        cReqDeflatePages;
-    /** Whether ballooning is enabled or not. */
-    bool            fBallooningEnabled;

trunk/src/VBox/VMM/VMMR0/VMMR0.cpp

@@ -747 +747 @@
-        case VMMR0_DO_GMM_BALLOONED_PAGES:
-            return GMMR0BalloonedPagesReq(pVM, (PGMMBALLOONEDPAGESREQ)pReqHdr);
+        case VMMR0_DO_GMM_DEFLATED_BALLOON:
+            return GMMR0DeflatedBalloon(pVM, (uint32_t)u64Arg);
-
-        case VMMR0_DO_GMM_MAP_UNMAP_CHUNK:
@@ -902 +904 @@
-            case VMMR0_DO_VMMR0_INIT: