Changeset 19370 in vbox for trunk/src/VBox/Runtime/r3

Timestamp:

May 5, 2009 12:20:09 PM (16 years ago)

Author:

vboxsync

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

46871

Message:

Runtime/Aio: Fix the POSIX backend for Darwin. We have to obey the AIO_LISTIO_MAX limit when calling lio_listio. Submitting more requests than AIO_LISTIO_MAX makes the call fail

File:

• trunk/src/VBox/Runtime/r3/posix/fileaio-posix.cpp (modified) (4 diffs)

trunk/src/VBox/Runtime/r3/posix/fileaio-posix.cpp

@@ -47 +47 @@
 #include <aio.h>
 #include <errno.h>
-
-#define AIO_MAXIMUM_REQUESTS_PER_CONTEXT 64
+#include <time.h>
+
+/*
+ * Linux does not define this value.
+ * Just define it with really big
+ * value.
+ */
+#ifndef AIO_LISTIO_MAX
+# define AIO_LISTIO_MAX UINT32_MAX
+#endif
 
 /*******************************************************************************
@@ -417 +425 @@
 }
 
-RTDECL(int) RTFileAioCtxSubmit(RTFILEAIOCTX hAioCtx, PRTFILEAIOREQ phReqs, size_t cReqs, size_t *pcReqs)
-{
+RTDECL(int) RTFileAioCtxSubmit(RTFILEAIOCTX hAioCtx, PRTFILEAIOREQ pahReqs, size_t cReqs, size_t *pcReqs)
+{
+    int rc = VINF_SUCCESS;
     PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx;
 
@@ -424 +433 @@
     AssertPtrReturn(pCtxInt, VERR_INVALID_HANDLE);
     AssertReturn(cReqs != 0, VERR_INVALID_POINTER);
-    AssertPtrReturn(phReqs,  VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pahReqs,  VERR_INVALID_PARAMETER);
 
     /* Check that we don't exceed the limit */
@@ -431 +440 @@
 
     PRTFILEAIOREQINTERNAL pHead = NULL;
-    for (size_t i = 0; i < cReqs; i++)
-    {
-        PRTFILEAIOREQINTERNAL pReqInt = phReqs[i];
-
-        pReqInt->pCtxInt = pCtxInt;
-        /* Link them together. */
-        pReqInt->pNext = pHead;
-        pHead = pReqInt;
-    }
-
-    int rcPosix = lio_listio(LIO_NOWAIT, (struct aiocb **)phReqs, cReqs, NULL);
-    if (RT_UNLIKELY(rcPosix < 0))
-        return RTErrConvertFromErrno(errno);
-
-    ASMAtomicAddS32(&pCtxInt->cRequests, cReqs);
-    *pcReqs = cReqs;
-
-    /*
-     * Forward them to the thread waiting for requests.
-     * We search for a free slot first and if we don't find one
-     * we will grab the first one and append our list to the existing entries.
-     */
-    unsigned iSlot = 0;
-    while (  (iSlot < RT_ELEMENTS(pCtxInt->apReqsNewHead))
-           && !ASMAtomicCmpXchgPtr((void * volatile *)&pCtxInt->apReqsNewHead[iSlot], pHead, NULL))
-        iSlot++;
-
-    if (iSlot == RT_ELEMENTS(pCtxInt->apReqsNewHead))
-    {
-        /* Nothing found. */
-        PRTFILEAIOREQINTERNAL pOldHead = (PRTFILEAIOREQINTERNAL)ASMAtomicXchgPtr((void * volatile *)&pCtxInt->apReqsNewHead[0],
-                                                                                  NULL);
-
-        /* Find the end of the current head and link the old list to the current. */
-        PRTFILEAIOREQINTERNAL pTail = pHead;
-        while (pTail->pNext)
-            pTail = pTail->pNext;
-
-        pTail->pNext = pOldHead;
-
-        ASMAtomicXchgPtr((void * volatile *)&pCtxInt->apReqsNewHead[0], pHead);
-    }
-
-    /* Set the internal wakeup flag and wakeup the thread if possible. */
-    bool fWokenUp = ASMAtomicXchgBool(&pCtxInt->fWokenUpInternal, true);
-    if (!fWokenUp)
-        rtFileAioCtxWakeup(pCtxInt);
-
-    return VINF_SUCCESS;
+
+    do
+    {
+        int rcPosix = 0;
+        size_t cReqsSubmit = 0;
+        size_t i = 0;
+        PRTFILEAIOREQINTERNAL pReqInt;
+
+        while (   (i < cReqs)
+               && (i < AIO_LISTIO_MAX))
+        {
+            pReqInt = pahReqs[i];
+            RTFILEAIOREQ_VALID_RETURN(pReqInt);
+
+            pReqInt->pCtxInt = pCtxInt;
+
+            /* Link them together. */
+            pReqInt->pNext = pHead;
+            pHead = pReqInt;
+
+            if (pReqInt->fFlush)
+                break;
+
+            cReqsSubmit++;
+            i++;
+        }
+
+        if (cReqsSubmit)
+        {
+            rcPosix = lio_listio(LIO_NOWAIT, (struct aiocb **)pahReqs, cReqsSubmit, NULL);
+            if (RT_UNLIKELY(rcPosix < 0))
+            {
+                rc = RTErrConvertFromErrno(errno);
+                break;
+            }
+
+            ASMAtomicAddS32(&pCtxInt->cRequests, cReqsSubmit);
+            cReqs   -= cReqsSubmit;
+            pahReqs += cReqsSubmit;
+            *pcReqs += cReqsSubmit;
+        }
+
+        /* Check if we have a flush request now. */
+        if (cReqs)
+        {
+            pReqInt = pahReqs[0];
+            RTFILEAIOREQ_VALID_RETURN(pReqInt);
+
+            if (pReqInt->fFlush)
+            {
+                /*
+                 * lio_listio does not work with flush requests so
+                 * we have to use aio_fsync directly.
+                 */
+                 rcPosix = aio_fsync(O_SYNC, &pReqInt->AioCB);
+                 if (RT_UNLIKELY(rcPosix < 0))
+                 {
+                    rc = RTErrConvertFromErrno(errno);
+                    break;
+                 }
+
+                ASMAtomicIncS32(&pCtxInt->cRequests);
+                cReqs--;
+                pahReqs++;
+                *pcReqs++;
+            }
+        }
+    } while (cReqs);
+
+    if (pHead)
+    {
+        /*
+         * Forward successfully submitted requests to the thread waiting for requests.
+         * We search for a free slot first and if we don't find one
+         * we will grab the first one and append our list to the existing entries.
+         */
+        unsigned iSlot = 0;
+        while (  (iSlot < RT_ELEMENTS(pCtxInt->apReqsNewHead))
+               && !ASMAtomicCmpXchgPtr((void * volatile *)&pCtxInt->apReqsNewHead[iSlot], pHead, NULL))
+            iSlot++;
+
+        if (iSlot == RT_ELEMENTS(pCtxInt->apReqsNewHead))
+        {
+            /* Nothing found. */
+            PRTFILEAIOREQINTERNAL pOldHead = (PRTFILEAIOREQINTERNAL)ASMAtomicXchgPtr((void * volatile *)&pCtxInt->apReqsNewHead[0],
+                                                                                      NULL);
+
+            /* Find the end of the current head and link the old list to the current. */
+            PRTFILEAIOREQINTERNAL pTail = pHead;
+            while (pTail->pNext)
+                pTail = pTail->pNext;
+
+            pTail->pNext = pOldHead;
+
+            ASMAtomicXchgPtr((void * volatile *)&pCtxInt->apReqsNewHead[0], pHead);
+        }
+
+        /* Set the internal wakeup flag and wakeup the thread if possible. */
+        bool fWokenUp = ASMAtomicXchgBool(&pCtxInt->fWokenUpInternal, true);
+        if (!fWokenUp)
+            rtFileAioCtxWakeup(pCtxInt);
+    }
+
+    return rc;
 }