Changeset 247 in vbox

Timestamp:

Jan 23, 2007 5:10:04 PM (18 years ago)

Author:

vboxsync

Message:

Out of memory reporting for dynamic memory allocation case.

Location:

trunk/src/VBox/VMM

Files:

• MM.cpp (modified) (2 diffs)
• MMInternal.h (modified) (1 diff)
• MMPhys.cpp (modified) (2 diffs)
• PGMPhys.cpp (modified) (1 diff)
• VMEmt.cpp (modified) (4 diffs)
• VMInternal.h (modified) (2 diffs)
• VMMInternal.h (modified) (1 diff)

trunk/src/VBox/VMM/MM.cpp

@@ -407 +407 @@
  *
  * @returns VBox status code.
- * @param   pVM         The VM handle.
- * @param   pv          Pointer to memory range which shall be locked down.
- *                      This pointer is page aligned.
- * @param   cb          Size of memory range (in bytes). This size is page aligned.
- * @param   eType       Memory type.
- * @param   ppLockedMem Where to store the pointer to the created locked memory record.
- *                      This is optional, pass NULL if not used.
- */
-int mmr3LockMem(PVM pVM, void *pv, size_t cb, MMLOCKEDTYPE eType, PMMLOCKEDMEM *ppLockedMem)
+ * @param   pVM             The VM handle.
+ * @param   pv              Pointer to memory range which shall be locked down.
+ *                          This pointer is page aligned.
+ * @param   cb              Size of memory range (in bytes). This size is page aligned.
+ * @param   eType           Memory type.
+ * @param   ppLockedMem     Where to store the pointer to the created locked memory record.
+ *                          This is optional, pass NULL if not used.
+ * @param   fSilentFailure  Don't raise an error when unsuccessful. Upper layer with deal with it.
+ */
+int mmr3LockMem(PVM pVM, void *pv, size_t cb, MMLOCKEDTYPE eType, PMMLOCKEDMEM *ppLockedMem, bool fSilentFailure)
 {
     Assert(RT_ALIGN_P(pv, PAGE_SIZE) == pv);
@@ -465 +466 @@
         AssertMsgFailed(("SUPPageLock failed with rc=%d\n", rc));
         MMR3HeapFree(pLockedMem);
-        rc = VMSetError(pVM, rc, RT_SRC_POS, N_("Failed to lock %d bytes of host memory (out of memory)"), cb);
+        if (!fSilentFailure)
+            rc = VMSetError(pVM, rc, RT_SRC_POS, N_("Failed to lock %d bytes of host memory (out of memory)"), cb);
     }
 

trunk/src/VBox/VMM/MMInternal.h

@@ -656 +656 @@
 int  mmR3HyperInitPaging(PVM pVM);
 
-int  mmr3LockMem(PVM pVM, void *pv, size_t cb, MMLOCKEDTYPE eType, PMMLOCKEDMEM *ppLockedMem);
+int  mmr3LockMem(PVM pVM, void *pv, size_t cb, MMLOCKEDTYPE eType, PMMLOCKEDMEM *ppLockedMem, bool fSilentFailure = false);
 int  mmr3MapLocked(PVM pVM, PMMLOCKEDMEM pLockedMem, RTGCPTR Addr, unsigned iPage, size_t cPages, unsigned fFlags);
 

trunk/src/VBox/VMM/MMPhys.cpp

@@ -148 +148 @@
          */
         PMMLOCKEDMEM    pLockedMem;
-        rc = mmr3LockMem(pVM, pvRam, cb, MM_LOCKED_TYPE_PHYS, &pLockedMem);
+        rc = mmr3LockMem(pVM, pvRam, cb, MM_LOCKED_TYPE_PHYS, &pLockedMem, (enmType == MM_PHYS_TYPE_DYNALLOC_CHUNK) ? false : true /* fSilentFailure */);
         if (VBOX_SUCCESS(rc))
         {
@@ -182 +182 @@
         }
         /* Cleanup is done in VM destruction to which failure of this function will lead. */
+        /* Not true in case of MM_PHYS_TYPE_DYNALLOC_CHUNK */
     }
 

trunk/src/VBox/VMM/PGMPhys.cpp

@@ -376 +376 @@
         if (VBOX_SUCCESS(rc))
             return rc;
+
         SUPPageFree(pvRam);
+
+        LogRel(("pgmr3PhysGrowRange: out of memory. pause until the user resumes execution.\n"));
+        VMSetRuntimeError(pVM, false, "HostMemoryLow", "Unable to allocate and lock memory. The virtual machine will be paused. Please close applications to free up memory or save and close the VM.");
+ 
+        rc = VMR3Suspend(pVM);
+        AssertRC(rc);
+
+        /* Wait for resume event; will only return in that case. If the VM is stopped, the EMT thread will be destroyed. */
+        rc = VMR3WaitForResume(pVM);
+
+        /* Retry */
+        LogRel(("pgmr3PhysGrowRange: VM execution resumed -> retry.\n"));
+        return pgmr3PhysGrowRange(pVM, GCPhys);
+        
     }
     return rc;

trunk/src/VBox/VMM/VMEmt.cpp

@@ -68 +68 @@
     for (;;)
     {
+        /* Requested to exit the EMT thread out of sync? (currently only VMR3WaitForResume) */
+        if (setjmp(pVM->vm.s.emtJumpEnv) != 0)
+            break;
 
         /*
@@ -126 +129 @@
          * Some requests (both VMR3Req* and the DBGF) can potentially
          * resume or start the VM, in that case we'll get a change in
-         * VM status indicating that we're no running.
+         * VM status indicating that we're now running.
          */
         if (    VBOX_SUCCESS(rc)
@@ -140 +143 @@
 
     /*
-     * Exitting.
+     * Exiting.
      */
     Log(("vmR3EmulationThread: Terminating emulation thread! Thread=%#x pVM=%p rc=%Vrc enmBefore=%d enmVMState=%d\n",
@@ -159 +162 @@
 }
 
+/**
+ * Wait for VM to be resumed. Handle events like vmR3EmulationThread does.
+ * In case the VM is stopped, clean up and long jump to the main EMT loop.
+ *
+ * @returns VINF_SUCCESS or doesn't return
+ * @param   pVM             VM handle.
+ */
+VMR3DECL(int) VMR3WaitForResume(PVM pVM)
+{
+    /*
+     * The request loop.
+     */
+    VMSTATE enmBefore;
+    int     rc;
+    for (;;)
+    {
+
+        /*
+         * Pending requests which needs servicing?
+         *
+         * We check for state changes in addition to status codes when
+         * servicing requests. (Look after the ifs.)
+         */
+        enmBefore = pVM->enmVMState;
+        if (VM_FF_ISSET(pVM, VM_FF_TERMINATE))
+        {
+            rc = VINF_EM_TERMINATE;
+            break;
+        }
+        else if (pVM->vm.s.pReqs)
+        {
+            /*
+             * Service execute in EMT request.
+             */
+            rc = VMR3ReqProcess(pVM);
+            Log(("vmR3EmulationThread: Req rc=%Vrc, VM state %d -> %d\n", rc, enmBefore, pVM->enmVMState));
+        }
+        else if (VM_FF_ISSET(pVM, VM_FF_DBGF))
+        {
+            /*
+             * Service the debugger request.
+             */
+            rc = DBGFR3VMMForcedAction(pVM);
+            Log(("vmR3EmulationThread: Dbg rc=%Vrc, VM state %d -> %d\n", rc, enmBefore, pVM->enmVMState));
+        }
+        else if (VM_FF_ISSET(pVM, VM_FF_RESET))
+        {
+            /*
+             * Service a delay reset request.
+             */
+            rc = VMR3Reset(pVM);
+            VM_FF_CLEAR(pVM, VM_FF_RESET);
+            Log(("vmR3EmulationThread: Reset rc=%Vrc, VM state %d -> %d\n", rc, enmBefore, pVM->enmVMState));
+        }
+        else
+        {
+            /*
+             * Nothing important is pending, so wait for something.
+             */
+            rc = VMR3Wait(pVM);
+            if (VBOX_FAILURE(rc))
+                break;
+        }
+
+        /*
+         * Check for termination requests, these are extremely high priority.
+         */
+        if (    rc == VINF_EM_TERMINATE
+            ||  VM_FF_ISSET(pVM, VM_FF_TERMINATE))
+            break;
+
+        /*
+         * Some requests (both VMR3Req* and the DBGF) can potentially
+         * resume or start the VM, in that case we'll get a change in
+         * VM status indicating that we're now running.
+         */
+        if (    VBOX_SUCCESS(rc)
+            &&  enmBefore != pVM->enmVMState
+            &&  (pVM->enmVMState == VMSTATE_RUNNING))
+        {
+            /* Only valid exit reason. */
+            return VINF_SUCCESS;
+        }
+
+    } /* forever */
+
+    /* Return to the main loop in vmR3EmulationThread, which will clean up for us. */
+    longjmp(pVM->vm.s.emtJumpEnv, 1);
+}
 
 /**

trunk/src/VBox/VMM/VMInternal.h

@@ -25 +25 @@
 #include <VBox/cdefs.h>
 #include <VBox/vmapi.h>
-
+#include <setjmp.h>
 
 #if !defined(IN_VM_R3) && !defined(IN_VM_R0) && !defined(IN_VM_GC)
@@ -256 +256 @@
     bool                            fEMTDoesTheCleanup;
 
+    /** vmR3EmulationThread longjmp buffer */
+    jmp_buf                         emtJumpEnv;
+
     /** Number of VMR3ReqAlloc returning a new packet. */
     STAMCOUNTER                     StatReqAllocNew;

trunk/src/VBox/VMM/VMMInternal.h

@@ -250 +250 @@
     VMMR0JMPBUF                 CallHostR0JmpBuf;
     /** @} */
-
+    
     /** Number of VMMR0_DO_RUN_GC calls. */
     STAMCOUNTER                 StatRunGC;