Changeset 26999 in vbox for trunk/src/VBox

Timestamp:

Mar 3, 2010 5:00:05 PM (15 years ago)

Author:

vboxsync

Message:

Guest Additions: memory ballooning for guests without support for RTR0MemObjAllocPhysNC() (does not work yet)

Location:

trunk/src/VBox/Additions

Files:

• WINNT/VBoxGuest/VBoxGuest.cpp (modified) (3 diffs)
• common/VBoxGuest/VBoxGuest.cpp (modified) (11 diffs)
• common/VBoxGuest/VBoxGuestInternal.h (modified) (2 diffs)
• common/VBoxGuestLib/VBoxGuestR3LibMisc.cpp (modified) (1 diff)
• common/VBoxService/VBoxServiceBalloon.cpp (modified) (4 diffs)

trunk/src/VBox/Additions/WINNT/VBoxGuest/VBoxGuest.cpp

@@ -745 +745 @@
         if (RT_FAILURE(rc))
         {
-            dprintf(("VBoxGuest::VBoxGuestDeviceControl VBOXGUEST_IOCTL_CTL_CHECK_BALLOON: error issuing request to VMMDev! "
+            dprintf(("VBoxGuest::VBoxGuestDeviceControl VBOXGUEST_IOCTL_CHECK_BALLOON: error issuing request to VMMDev! "
                      "rc = %Rrc\n", rc));
         }
@@ -1380 +1380 @@
 
 #ifdef VBOX_WITH_MANAGEMENT
-        case VBOXGUEST_IOCTL_CTL_CHECK_BALLOON_MASK:
+        case VBOXGUEST_IOCTL_CHECK_BALLOON:
         {
             ULONG *pMemBalloonSize = (ULONG *) pBuf;
@@ -1395 +1395 @@
             if (RT_FAILURE(rc))
             {
-                dprintf(("VBOXGUEST_IOCTL_CTL_CHECK_BALLOON: vbox rc = %Rrc\n", rc));
+                dprintf(("VBOXGUEST_IOCTL_CHECK_BALLOON: vbox rc = %Rrc\n", rc));
                 Status = STATUS_UNSUCCESSFUL;
             }

trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest.cpp

@@ -276 +276 @@
 
 /**
- * Infltate/deflate the memory balloon and notify the host.
+ * Inflate/deflate the memory balloon and notify the host.
  *
  * @returns VBox status code.
@@ -282 +282 @@
  * @param   u32BalloonSize The new size of the balloon in chunks of 1MB.
  */
-static int vboxGuestSetBalloonSize(PVBOXGUESTDEVEXT pDevExt, uint32_t u32BalloonSize)
-{
-    VMMDevChangeMemBalloon *pReq;
+static int vboxGuestSetBalloonSizeKernel(PVBOXGUESTDEVEXT pDevExt, uint32_t u32BalloonSize)
+{
     int rc = VINF_SUCCESS;
-    uint32_t i, j;
-    const size_t cbReq = RT_OFFSETOF(VMMDevChangeMemBalloon, aPhysPage[VMMDEV_MEMORY_BALLOON_CHUNK_PAGES]);
-
-    if (u32BalloonSize > pDevExt->MemBalloon.cMaxChunks)
-    {
-        AssertMsgFailed(("vboxGuestSetBalloonSize illegal balloon size %d (max=%d)\n",
-                         u32BalloonSize, pDevExt->MemBalloon.cMaxChunks));
-        return VERR_INVALID_PARAMETER;
-    }
-
-    if (u32BalloonSize == pDevExt->MemBalloon.cMaxChunks)
-        return VINF_SUCCESS;   /* nothing to do */
-
-    rc = VbglGRAlloc((VMMDevRequestHeader **)&pReq, cbReq, VMMDevReq_ChangeMemBalloon);
-    if (RT_FAILURE(rc))
-        return rc;
 
     if (pDevExt->MemBalloon.fUseKernelAPI)
     {
+        VMMDevChangeMemBalloon *pReq;
+        uint32_t i, j;
+        const size_t cbReq = RT_OFFSETOF(VMMDevChangeMemBalloon, aPhysPage[VMMDEV_MEMORY_BALLOON_CHUNK_PAGES]);
+
+        if (u32BalloonSize > pDevExt->MemBalloon.cMaxChunks)
+        {
+            AssertMsgFailed(("vboxGuestSetBalloonSize illegal balloon size %d (max=%d)\n",
+                             u32BalloonSize, pDevExt->MemBalloon.cMaxChunks));
+            return VERR_INVALID_PARAMETER;
+        }
+
+        if (u32BalloonSize == pDevExt->MemBalloon.cMaxChunks)
+            return VINF_SUCCESS;   /* nothing to do */
+
+        rc = VbglGRAlloc((VMMDevRequestHeader **)&pReq, cbReq, VMMDevReq_ChangeMemBalloon);
+        if (RT_FAILURE(rc))
+            return rc;
+
         if (u32BalloonSize > pDevExt->MemBalloon.cChunks)
         {
@@ -381 +382 @@
             }
         }
+
+        VbglGRFree(&pReq->header);
     }
 
     if (!pDevExt->MemBalloon.fUseKernelAPI)
     {
-        /* R3 to allocate memory, R0 to lock it down and tell the host */
-    }
+        /* R3 to allocate memory, then do ioctl(VBOXGUEST_IOCTL_CHANGE_BALLOON)
+         * and R0 to lock it down and tell the host. */
+        rc = VERR_NO_PHYS_MEMORY;
+    }
+
+    return rc;
+}
+
+
+/**
+ * Inflate/deflate the balloon by one chunk.
+ */
+static int vboxGuestSetBalloonSizeFromUser(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
+                                           uint64_t u64ChunkAddr, bool fInflate)
+{
+    VMMDevChangeMemBalloon *pReq;
+    int rc = VINF_SUCCESS;
+    uint32_t i, j;
+    const size_t cbReq = RT_OFFSETOF(VMMDevChangeMemBalloon, aPhysPage[VMMDEV_MEMORY_BALLOON_CHUNK_PAGES]);
+    PRTR0MEMOBJ pMemObj = NULL;
+
+    if (   fInflate
+        && pSession->MemBalloon.cChunks > pSession->MemBalloon.cMaxChunks - 1)
+    {
+        AssertMsgFailed(("vboxGuestSetBalloonSize: cannot inflate balloon, already have (max=%d)\n",
+                         pSession->MemBalloon.cChunks, pSession->MemBalloon.cMaxChunks));
+        return VERR_INVALID_PARAMETER;
+    }
+    else if (   !fInflate
+             && pSession->MemBalloon.cChunks == 0)
+    {
+        AssertMsgFailed(("vboxGuestSetBalloonSize: cannot decrease balloon, already at size 0\n"));
+        return VERR_INVALID_PARAMETER;
+    }
+
+    /*
+     * Enumerate all memory objects and check if the object is already registered.
+     */
+    for (i = 0; i < pSession->MemBalloon.cMaxChunks; i++)
+    {
+        if (   fInflate
+            && !pSession->MemBalloon.paMemObj[i] == NIL_RTR0MEMOBJ
+            && !pMemObj)
+            pMemObj = &pSession->MemBalloon.paMemObj[i]; /* found free object pointer */
+        if (RTR0MemObjAddressR3(pSession->MemBalloon.paMemObj[i]) == u64ChunkAddr)
+        {
+            if (fInflate)
+                return VERR_ALREADY_EXISTS; /* don't provide the same memory twice */
+            pMemObj = &pSession->MemBalloon.paMemObj[i];
+            break;
+        }
+    }
+    if (!pMemObj)
+    {
+        if (fInflate)
+            return VERR_NO_MEMORY; /* no free object pointer found -- should not happen */
+        else
+            return VERR_NOT_FOUND; /* cannot free this memory as it wasn't provided before */
+    }
+
+    rc = VbglGRAlloc((VMMDevRequestHeader **)&pReq, cbReq, VMMDevReq_ChangeMemBalloon);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    do
+    {
+        if (fInflate)
+        {
+            rc = RTR0MemObjLockUser(pMemObj, u64ChunkAddr, VMMDEV_MEMORY_BALLOON_CHUNK_PAGES * PAGE_SIZE,
+                                    RTMEM_PROT_READ | RTMEM_PROT_WRITE, NIL_RTR0PROCESS);
+            if (RT_SUCCESS(rc))
+            {
+                RTR0MEMOBJ MemObj = pDevExt->MemBalloon.paMemObj[i];
+                for (j = 0; j < VMMDEV_MEMORY_BALLOON_CHUNK_PAGES; j++)
+                {
+                    RTHCPHYS phys = RTR0MemObjGetPagePhysAddr(MemObj, j);
+                    pReq->aPhysPage[j] = phys;
+                }
+
+                pReq->header.size = cbReq;
+                pReq->cPages = VMMDEV_MEMORY_BALLOON_CHUNK_PAGES;
+                pReq->fInflate = true;
+
+                rc = VbglGRPerform(&pReq->header);
+                if (RT_FAILURE(rc))
+                {
+                    Log(("vboxGuestSetBalloonSize(inflate): VbglGRPerform failed, rc=%Rrc!\n", rc));
+                    break;
+                }
+                pSession->MemBalloon.cChunks++;
+            }
+        }
+        else
+        {
+            /* deflate */
+            for (j = 0; j < VMMDEV_MEMORY_BALLOON_CHUNK_PAGES; j++)
+            {
+                RTHCPHYS phys = RTR0MemObjGetPagePhysAddr(*pMemObj, j);
+                pReq->aPhysPage[j] = phys;
+            }
+
+            pReq->header.size = cbReq;
+            pReq->cPages = VMMDEV_MEMORY_BALLOON_CHUNK_PAGES;
+            pReq->fInflate = false;
+
+            rc = VbglGRPerform(&pReq->header);
+            if (RT_FAILURE(rc))
+            {
+                Log(("vboxGuestSetBalloonSize(deflate): VbglGRPerform failed, rc=%Rrc!\n", rc));
+                break;
+            }
+
+            rc = RTR0MemObjFree(*pMemObj, true);
+            if (RT_FAILURE(rc))
+            {
+                Log(("vboxGuestSetBalloonSize(deflate): RTR0MemObjFree() failed, rc=%Rrc!\n", rc));
+                break;
+            }
+            *pMemObj = NIL_RTR0MEMOBJ;
+            pSession->MemBalloon.cChunks--;
+        }
+    } while (0);
 
     VbglGRFree(&pReq->header);
@@ -402 +525 @@
     pDevExt->MemBalloon.cChunks = 0;
     pDevExt->MemBalloon.cMaxChunks = 0;
-#ifdef RT_OS_LINUX
-    pDevExt->MemBalloon.fUseKernelAPI = true;
-#else
+//#ifdef RT_OS_LINUX
+//    pDevExt->MemBalloon.fUseKernelAPI = true;
+//#else
     pDevExt->MemBalloon.fUseKernelAPI = false;
-#endif
+//#endif
     pDevExt->MemBalloon.paMemObj = NULL;
 }
@@ -420 +543 @@
     if (pDevExt->MemBalloon.paMemObj)
     {
-        vboxGuestSetBalloonSize(pDevExt, 0);
+        vboxGuestSetBalloonSizeKernel(pDevExt, 0);
         RTMemFree(pDevExt->MemBalloon.paMemObj);
         pDevExt->MemBalloon.paMemObj = NULL;
@@ -652 +775 @@
 int VBoxGuestCreateUserSession(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION *ppSession)
 {
+    unsigned i;
     PVBOXGUESTSESSION pSession = (PVBOXGUESTSESSION)RTMemAllocZ(sizeof(*pSession));
     if (RT_UNLIKELY(!pSession))
@@ -662 +786 @@
     pSession->R0Process = RTR0ProcHandleSelf();
     pSession->pDevExt = pDevExt;
+
+    pSession->MemBalloon.cChunks = 0;
+    pSession->MemBalloon.cMaxChunks = 0;
 
     *ppSession = pSession;
@@ -1612 +1739 @@
 
 /**
- * Handle VBOXGUEST_IOCTL_CTL_CHECK_BALLOON_MASK from R3. Ask the host for the size of
- * the balloon and set it accordingly.
+ * Handle VBOXGUEST_IOCTL_CHECK_BALLOON from R3. Ask the host for the size
+ * of the balloon and try to set it accordingly. If this fails, return with
+ * VERR_NO_PHYS_MEMORY and userland has to provide the memory.
  *
  * @returns VBox status code.
  */
-static int VBoxGuestCommonIOCtl_QueryMemoryBalloon(PVBOXGUESTDEVEXT pDevExt, uint32_t *memBalloonSize, size_t *pcbDataReturned)
+static int VBoxGuestCommonIOCtl_QueryMemoryBalloon(PVBOXGUESTDEVEXT pDevExt,
+                                                   uint32_t *memBalloonSize, size_t *pcbDataReturned)
 {
     VMMDevGetMemBalloonChangeRequest *pReq;
@@ -1642 +1771 @@
     }
 
-    rc = vboxGuestSetBalloonSize(pDevExt, pReq->u32BalloonSize);
+    rc = vboxGuestSetBalloonSizeKernel(pDevExt, pReq->u32BalloonSize);
     /* ignore out of memory failures */
     if (rc == VERR_NO_MEMORY)
@@ -1654 +1783 @@
     return rc;
 }
+
+
+/**
+ *
+ */
+static int VBoxGuestCommonIOCtl_ChangeMemoryBalloon(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
+                                                    VBoxGuestChangeBalloonInfo *pInfo, size_t *pcbDataReturned)
+{
+    int rc = vboxGuestSetBalloonSizeFromUser(pDevExt, pSession, pInfo->u64ChunkAddr, pInfo->fInflate);
+    if (pcbDataReturned)
+        *pcbDataReturned = 0;
+    return rc;
+}
+
 
 /**
@@ -1833 +1976 @@
 #endif /* VBOX_WITH_HGCM */
 
-            case VBOXGUEST_IOCTL_CTL_CHECK_BALLOON_MASK:
-                CHECKRET_MIN_SIZE("MEMORY_BALLOON", sizeof(uint32_t));
+            case VBOXGUEST_IOCTL_CHECK_BALLOON:
+                CHECKRET_MIN_SIZE("CHECK_MEMORY_BALLOON", sizeof(uint32_t));
                 rc = VBoxGuestCommonIOCtl_QueryMemoryBalloon(pDevExt, (uint32_t *)pvData, pcbDataReturned);
+                break;
+
+            case VBOXGUEST_IOCTL_CHANGE_BALLOON:
+                CHECKRET_MIN_SIZE("CHANGE_MEMORY_BALLOON", sizeof(VBoxGuestChangeBalloonInfo));
+                rc = VBoxGuestCommonIOCtl_ChangeMemoryBalloon(pDevExt, pSession, (VBoxGuestChangeBalloonInfo *)pvData, pcbDataReturned);
                 break;
 

trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuestInternal.h

@@ -140 +140 @@
     uint32_t                    u32ClipboardClientId;
 
-    /* Memory balloon information. */
+    /* Memory balloon information for RTR0MemObjAllocPhysNC(). */
     VBOXGUESTMEMBALLOON         MemBalloon;
 
@@ -183 +183 @@
      * Used to implement polling.  */
     uint32_t volatile           u32MousePosChangedSeq;
+
+    /* Memory ballooning information if userland provides the balloon memory. */
+    VBOXGUESTMEMBALLOON         MemBalloon;
 } VBOXGUESTSESSION;
 

trunk/src/VBox/Additions/common/VBoxGuestLib/VBoxGuestR3LibMisc.cpp

@@ -240 +240 @@
 VBGLR3DECL(int) VbglR3MemBalloonRefresh(uint32_t *pu32Size)
 {
-    return vbglR3DoIOCtl(VBOXGUEST_IOCTL_CTL_CHECK_BALLOON_MASK, pu32Size, sizeof(*pu32Size));
+    return vbglR3DoIOCtl(VBOXGUEST_IOCTL_CHECK_BALLOON, pu32Size, sizeof(*pu32Size));
+}
+
+
+/**
+ *
+ */
+VBGLR3DECL(int) VbglR3MemBalloonChange(void *pv, bool fInflate)
+{
+    VBoxGuestChangeBalloonInfo Info;
+    Info.u64ChunkAddr = (uint64_t)pv;
+    Info.fInflate = fInflate;
+    return vbglR3DoIOCtl(VBOXGUEST_IOCTL_CHANGE_BALLOON, &Info, sizeof(Info));
 }
 

trunk/src/VBox/Additions/common/VBoxService/VBoxServiceBalloon.cpp

@@ -22 +22 @@
 #include <iprt/mem.h>
 #include <iprt/thread.h>
+#include <iprt/stream.h>
 #include <iprt/string.h>
 #include <iprt/semaphore.h>
@@ -40 +41 @@
 static RTSEMEVENTMULTI  g_MemBalloonEvent = NIL_RTSEMEVENTMULTI;
 
+static void **g_pavBalloon = NULL;
+
+
+static void VBoxServiceBalloonSetUser(uint32_t OldSize, uint32_t NewSize)
+{
+    if (NewSize == OldSize)
+        return;
+
+    int rc = VINF_SUCCESS;
+    if (NewSize > OldSize)
+    {
+        /* inflate */
+        uint32_t i;
+        g_pavBalloon = (void**)RTMemRealloc(g_pavBalloon, NewSize * sizeof(void*));
+        RTPrintf("allocated %d bytes\n", g_pavBalloon, NewSize * sizeof(void*));
+        for (i = OldSize; i < NewSize; i++)
+        {
+            void *pv = RTMemAlloc(VMMDEV_MEMORY_BALLOON_CHUNK_PAGES * PAGE_SIZE);
+            VBoxServiceVerbose(3, "Alloc %p\n", pv);
+            rc = VbglR3MemBalloonChange(pv, /* inflate=*/ true);
+            if (RT_SUCCESS(rc))
+            {
+                VBoxServiceVerbose(3, " => %Rrc\n", rc);
+                g_pavBalloon[i] = pv;
+                OldSize++;
+            }
+            else
+                break;
+        }
+    }
+    else
+    {
+        /* deflate */
+        uint32_t i;
+        for (i = OldSize; i > NewSize; i--)
+        {
+            void *pv = g_pavBalloon[i-1];
+            rc = VbglR3MemBalloonChange(pv, /* inflate=*/ false);
+            if (RT_SUCCESS(rc))
+            {
+                VBoxServiceVerbose(3, "Free %p\n", g_pavBalloon[i-1]);
+                RTMemFree(g_pavBalloon[i-1]);
+                g_pavBalloon[i-1] = NULL;
+                OldSize--;
+            }
+            else
+                break;
+        }
+    }
+
+    if (RT_FAILURE(rc))
+        g_MemBalloonSize = OldSize;
+}
+
+
 /** @copydoc VBOXSERVICE::pfnPreInit */
 static DECLCALLBACK(int) VBoxServiceBalloonPreInit(void)
@@ -68 +124 @@
     if (RT_SUCCESS(rc))
         VBoxServiceVerbose(3, "VBoxMemBalloonInit: new balloon size %d MB\n", g_MemBalloonSize);
+    else if (rc == VERR_NO_PHYS_MEMORY)
+        VBoxServiceBalloonSetUser(0, g_MemBalloonSize);
     else
         VBoxServiceVerbose(3, "VBoxMemBalloonInit: VbglR3MemBalloonRefresh failed with %d\n", rc);
@@ -113 +171 @@
             &&  (fEvents & VMMDEV_EVENT_BALLOON_CHANGE_REQUEST))
         {
+            uint32_t OldMemBalloonSize = g_MemBalloonSize;
             rc = VbglR3MemBalloonRefresh(&g_MemBalloonSize);
             if (RT_SUCCESS(rc))
                 VBoxServiceVerbose(3, "VBoxServiceBalloonWorker: new balloon size %d MB\n", g_MemBalloonSize);
+            else if (rc == VERR_NO_PHYS_MEMORY)
+                VBoxServiceBalloonSetUser(OldMemBalloonSize, g_MemBalloonSize);
             else
                 VBoxServiceVerbose(3, "VBoxServiceBalloonWorker: VbglR3MemBalloonRefresh failed with %d\n", rc);