Changeset 23404 in vbox for trunk/src/VBox

Timestamp:

Sep 29, 2009 10:18:37 AM (15 years ago)

Author:

vboxsync

Message:

AsyncCompletion: Handle out of resources case properly. Should fix assertion on Darwin

Location:

trunk/src/VBox/VMM

Files:

• PDMAsyncCompletionFileInternal.h (modified) (1 diff)
• PDMAsyncCompletionFileNormal.cpp (modified) (7 diffs)
• testcase/tstPDMAsyncCompletion.cpp (modified) (1 diff)

trunk/src/VBox/VMM/PDMAsyncCompletionFileInternal.h

@@ -331 +331 @@
     /** Global cache data. */
     PDMACFILECACHEGLOBAL                Cache;
+    /** Flag whether the out of resources warning was printed already. */
+    bool                                fOutOfResourcesWarningPrinted;
 } PDMASYNCCOMPLETIONEPCLASSFILE;
 /** Pointer to the endpoint class data. */

trunk/src/VBox/VMM/PDMAsyncCompletionFileNormal.cpp

@@ -287 +287 @@
 }
 
+/**
+ * Put a list of tasks in the pending request list of an endpoint.
+ */
+DECLINLINE(void) pdmacFileAioMgrEpAddTaskList(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint, PPDMACTASKFILE pTaskHead)
+{
+    /* Add the rest of the tasks to the pending list */
+    if (!pEndpoint->AioMgr.pReqsPendingHead)
+    {
+        Assert(!pEndpoint->AioMgr.pReqsPendingTail);
+        pEndpoint->AioMgr.pReqsPendingHead = pTaskHead;
+    }
+    else
+    {
+        Assert(pEndpoint->AioMgr.pReqsPendingTail);
+        pEndpoint->AioMgr.pReqsPendingTail->pNext = pTaskHead;
+    }
+
+    /* Update the tail. */
+    while (pTaskHead->pNext)
+        pTaskHead = pTaskHead->pNext;
+
+    pEndpoint->AioMgr.pReqsPendingTail = pTaskHead;
+}
+
+/**
+ * Put one task in the pending request list of an endpoint.
+ */
+DECLINLINE(void) pdmacFileAioMgrEpAddTask(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint, PPDMACTASKFILE pTask)
+{
+    /* Add the rest of the tasks to the pending list */
+    if (!pEndpoint->AioMgr.pReqsPendingHead)
+    {
+        Assert(!pEndpoint->AioMgr.pReqsPendingTail);
+        pEndpoint->AioMgr.pReqsPendingHead = pTask;
+    }
+    else
+    {
+        Assert(pEndpoint->AioMgr.pReqsPendingTail);
+        pEndpoint->AioMgr.pReqsPendingTail->pNext = pTask;
+    }
+
+    pEndpoint->AioMgr.pReqsPendingTail = pTask;
+}
+
+/**
+ * Wrapper around RTFIleAioCtxSubmit() which is also doing error handling.
+ */
+static int pdmacFileAioMgrNormalReqsEnqueue(PPDMACEPFILEMGR pAioMgr,
+                                            PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint,
+                                            PRTFILEAIOREQ pahReqs, size_t cReqs)
+{
+    int rc;
+
+    pAioMgr->cRequestsActive += cReqs;
+    pEndpoint->AioMgr.cRequestsActive += cReqs;
+
+    rc = RTFileAioCtxSubmit(pAioMgr->hAioCtx, pahReqs, cReqs);
+    if (RT_FAILURE(rc))
+    {
+        if (rc == VERR_FILE_AIO_INSUFFICIENT_RESSOURCES)
+        {
+            PPDMASYNCCOMPLETIONEPCLASSFILE pEpClass = (PPDMASYNCCOMPLETIONEPCLASSFILE)pEndpoint->Core.pEpClass;
+
+            /*
+             * We run out of resources.
+             * Need to check which requests got queued
+             * and put the rest on the pending list again.
+             */
+            if (RT_UNLIKELY(!pEpClass->fOutOfResourcesWarningPrinted))
+            {
+                pEpClass->fOutOfResourcesWarningPrinted = true;
+                LogRel(("AIOMgr: The operating system doesn't have enough resources "
+                        "to handle the I/O load of the VM. Expect reduced I/O performance\n"));
+            }
+
+            for (size_t i = 0; i < cReqs; i++)
+            {
+                int rcReq = RTFileAioReqGetRC(pahReqs[i], NULL);
+
+                if (rcReq != VERR_FILE_AIO_IN_PROGRESS)
+                {
+                    AssertMsg(rcReq == VERR_FILE_AIO_NOT_SUBMITTED,
+                              ("Request returned unexpected return code: rc=%Rrc\n", rcReq));
+
+                    PPDMACTASKFILE pTask = (PPDMACTASKFILE)RTFileAioReqGetUser(pahReqs[i]);
+
+                    /* Put the entry on the free array */
+                    pAioMgr->pahReqsFree[pAioMgr->iFreeEntryNext] = pahReqs[i];
+                    pAioMgr->iFreeEntryNext = (pAioMgr->iFreeEntryNext + 1) % pAioMgr->cReqEntries;
+
+                    pdmacFileAioMgrEpAddTask(pEndpoint, pTask);
+                    pAioMgr->cRequestsActive--;
+                    pEndpoint->AioMgr.cRequestsActive--;
+                }
+            }
+        }
+        else
+            AssertMsgFailed(("Unexpected return code rc=%Rrc\n", rc));
+    }
+
+    return rc;
+}
+
 static int pdmacFileAioMgrNormalProcessTaskList(PPDMACTASKFILE pTaskHead,
                                                 PPDMACEPFILEMGR pAioMgr,
@@ -307 +410 @@
         pTaskHead = pTaskHead->pNext;
 
+        pCurr->pNext = NULL;
+
         AssertMsg(VALID_PTR(pCurr->pEndpoint) && (pCurr->pEndpoint == pEndpoint),
                   ("Endpoints do not match\n"));
@@ -324 +429 @@
                     pEndpoint->pFlushReq = pCurr;
 
-                    if (pTaskHead)
-                    {
-                        /* Add the rest of the tasks to the pending list */
-                        if (!pEndpoint->AioMgr.pReqsPendingHead)
-                        {
-                            Assert(!pEndpoint->AioMgr.pReqsPendingTail);
-                            pEndpoint->AioMgr.pReqsPendingHead = pTaskHead;
-                        }
-                        else
-                        {
-                            Assert(pEndpoint->AioMgr.pReqsPendingTail);
-                            pEndpoint->AioMgr.pReqsPendingTail->pNext = pTaskHead;
-                        }
-
-                        /* Update the tail. */
-                        while (pTaskHead->pNext)
-                            pTaskHead = pTaskHead->pNext;
-
-                        pEndpoint->AioMgr.pReqsPendingTail = pTaskHead;
-                    }
+                    /* Do not process the task list further until the flush finished. */
+                    pdmacFileAioMgrEpAddTaskList(pEndpoint, pTaskHead);
                 }
                 break;
@@ -444 +531 @@
                 if (cRequests == RT_ELEMENTS(apReqs))
                 {
-                    pAioMgr->cRequestsActive += cRequests;
-                    pEndpoint->AioMgr.cRequestsActive += cRequests;
-                    rc = RTFileAioCtxSubmit(pAioMgr->hAioCtx, apReqs, cRequests);
+                    rc = pdmacFileAioMgrNormalReqsEnqueue(pAioMgr, pEndpoint, apReqs, cRequests);
+                    cRequests = 0;
                     if (RT_FAILURE(rc))
                     {
-                        /* @todo implement */
-                        AssertMsgFailed(("Implement\n"));
+                        AssertMsg(rc == VERR_FILE_AIO_INSUFFICIENT_RESSOURCES, ("Unexpected return code\n"));
+                        break;
                     }
-
-                    cRequests = 0;
                 }
                 break;
@@ -464 +548 @@
     if (cRequests)
     {
-        pAioMgr->cRequestsActive += cRequests;
-        pEndpoint->AioMgr.cRequestsActive += cRequests;
-        rc = RTFileAioCtxSubmit(pAioMgr->hAioCtx, apReqs, cRequests);
-        AssertMsgReturn(RT_SUCCESS(rc), ("Could not submit %u requests %Rrc\n", cRequests, rc), rc);
-    }
-
-    if (RT_UNLIKELY(!cMaxRequests && pTaskHead && !pEndpoint->pFlushReq))
-    {
-        /*
-         * The I/O manager has no room left for more requests
-         * but there are still requests to process.
-         * Create a new I/O manager and let it handle some endpoints.
-         */
-
-        /* Add the rest of the tasks to the pending list first */
-        if (!pEndpoint->AioMgr.pReqsPendingHead)
-        {
-            Assert(!pEndpoint->AioMgr.pReqsPendingTail);
-            pEndpoint->AioMgr.pReqsPendingHead = pTaskHead;
-        }
-        else
-        {
-            Assert(pEndpoint->AioMgr.pReqsPendingTail);
-            pEndpoint->AioMgr.pReqsPendingTail->pNext = pTaskHead;
-        }
-
-        /* Update the tail. */
-        while (pTaskHead->pNext)
-            pTaskHead = pTaskHead->pNext;
-
-        pEndpoint->AioMgr.pReqsPendingTail = pTaskHead;
-
-        pdmacFileAioMgrNormalBalanceLoad(pAioMgr);
-    }
+        rc = pdmacFileAioMgrNormalReqsEnqueue(pAioMgr, pEndpoint, apReqs, cRequests);
+        AssertMsg(RT_SUCCESS(rc) || (rc == VERR_FILE_AIO_INSUFFICIENT_RESSOURCES),
+                  ("Unexpected return code rc=%Rrc\n", rc));
+    }
+
+    if (pTaskHead)
+    {
+        /* Add the rest of the tasks to the pending list */
+        pdmacFileAioMgrEpAddTaskList(pEndpoint, pTaskHead);
+
+
+        if (RT_UNLIKELY(!cMaxRequests && !pEndpoint->pFlushReq))
+        {
+            /*
+             * The I/O manager has no room left for more requests
+             * but there are still requests to process.
+             * Create a new I/O manager and let it handle some endpoints.
+             */
+            pdmacFileAioMgrNormalBalanceLoad(pAioMgr);
+        }
+    }
+
+    /* Insufficient resources are not fatal. */
+    if (rc == VERR_FILE_AIO_INSUFFICIENT_RESSOURCES)
+        rc = VINF_SUCCESS;
 
     return rc;
@@ -536 +611 @@
     }
 
-    if (!pEndpoint->pFlushReq)
+    if (!pEndpoint->pFlushReq && !pEndpoint->AioMgr.pReqsPendingHead)
     {
         /* Now the request queue. */
@@ -764 +839 @@
                         /* Put the entry on the free array */
                         pAioMgr->pahReqsFree[pAioMgr->iFreeEntryNext] = apReqs[i];
-                        pAioMgr->iFreeEntryNext = (pAioMgr->iFreeEntryNext + 1) %pAioMgr->cReqEntries;
+                        pAioMgr->iFreeEntryNext = (pAioMgr->iFreeEntryNext + 1) % pAioMgr->cReqEntries;
 
                         pAioMgr->cRequestsActive--;

trunk/src/VBox/VMM/testcase/tstPDMAsyncCompletion.cpp

@@ -55 +55 @@
  */
 #define NR_TASKS      80
-#define BUFFER_SIZE 4096 /* 4K */
+#define BUFFER_SIZE (64*_1K)
 
 /* Buffers to store data in .*/