Changeset 26338 in vbox

Timestamp:

Feb 9, 2010 12:54:20 AM (15 years ago)

Author:

vboxsync

Message:

AsyncCompletion: Introduce range locks to prevent concurrent access to the same file range. Fixes inconsistent data for tasks with unaligned tasks where we have to use bounce buffers (i.e block table updates when a VDI file grows)

Location:

trunk/src/VBox/VMM

Files:

• PDMAsyncCompletionFile.cpp (modified) (3 diffs)
• PDMAsyncCompletionFileInternal.h (modified) (9 diffs)
• PDMAsyncCompletionFileNormal.cpp (modified) (6 diffs)
• testcase/tstPDMAsyncCompletionStress.cpp (modified) (3 diffs)

trunk/src/VBox/VMM/PDMAsyncCompletionFile.cpp

@@ -738 +738 @@
                 }
 
-                pEpFile->enmState = PDMASYNCCOMPLETIONENDPOINTFILESTATE_ACTIVE;
-
-                /* Assign the endpoint to the thread. */
-                rc = pdmacFileAioMgrAddEndpoint(pAioMgr, pEpFile);
-                if (RT_FAILURE(rc))
-                    MMR3HeapFree(pEpFile->pTasksFreeHead);
+                pEpFile->AioMgr.pTreeRangesLocked = (PAVLRFOFFTREE)RTMemAllocZ(sizeof(AVLRFOFFTREE));
+                if (!pEpFile->AioMgr.pTreeRangesLocked)
+                    rc = VERR_NO_MEMORY;
+                else
+                {
+                    pEpFile->enmState = PDMASYNCCOMPLETIONENDPOINTFILESTATE_ACTIVE;
+
+                    /* Assign the endpoint to the thread. */
+                    rc = pdmacFileAioMgrAddEndpoint(pAioMgr, pEpFile);
+                    if (RT_FAILURE(rc))
+                    {
+                        RTMemFree(pEpFile->AioMgr.pTreeRangesLocked);
+                        MMR3HeapFree(pEpFile->pTasksFreeHead);
+                    }
+                }
             }
         }
@@ -767 +776 @@
 
     return rc;
+}
+
+static int pdmacFileEpRangesLockedDestroy(PAVLRFOFFNODECORE pNode, void *pvUser)
+{
+    AssertMsgFailed(("The locked ranges tree should be empty at that point\n"));
+    return VINF_SUCCESS;
 }
 
@@ -798 +813 @@
     if (pEpFile->fCaching)
         pdmacFileEpCacheDestroy(pEpFile);
+
+    /* Destroy the locked ranges tree now. */
+    RTAvlrFileOffsetDestroy(pEpFile->AioMgr.pTreeRangesLocked, pdmacFileEpRangesLockedDestroy, NULL);
 
     RTFileClose(pEpFile->File);

trunk/src/VBox/VMM/PDMAsyncCompletionFileInternal.h

@@ -34 +34 @@
 #include "PDMAsyncCompletionInternal.h"
 
-/** Enable the 2Q cache alogrithm. */
-#define VBOX_WITH_2Q_CACHE 1
-
 /** @todo: Revise the caching of tasks. We have currently four caches:
  *  Per endpoint task cache
@@ -61 +58 @@
 /** Pointer to the global cache structure. */
 typedef struct PDMACFILECACHEGLOBAL *PPDMACFILECACHEGLOBAL;
+/** Pointer to a task segment. */
+typedef struct PDMACFILETASKSEG *PPDMACFILETASKSEG;
 
 /**
@@ -189 +188 @@
 
 /**
+ * A file access range lock.
+ */
+typedef struct PDMACFILERANGELOCK
+{
+    /** AVL node in the locked range tree of the endpoint. */
+    AVLRFOFFNODECORE            Core;
+    /** How many tasks have locked this range. */
+    uint32_t                    cRefs;
+    /** Flag whether this is a read or write lock. */
+    bool                        fReadLock;
+    /** List of tasks which are waiting that the range gets unlocked. */
+    PPDMACTASKFILE              pWaitingTasksHead;
+    /** List of tasks which are waiting that the range gets unlocked. */
+    PPDMACTASKFILE              pWaitingTasksTail;
+} PDMACFILERANGELOCK, *PPDMACFILERANGELOCK;
+
+/**
  * Data for one request segment waiting for cache entry.
  */
@@ -205 +221 @@
     /** Flag whether this entry writes data to the cache. */
     bool                        fWrite;
-} PDMACFILETASKSEG, *PPDMACFILETASKSEG;
+} PDMACFILETASKSEG;
 
 /**
@@ -260 +276 @@
 {
     /** Head of the list. */
-    PPDMACFILECACHEENTRY pHead;
+    PPDMACFILECACHEENTRY  pHead;
     /** Tail of the list. */
-    PPDMACFILECACHEENTRY pTail;
+    PPDMACFILECACHEENTRY  pTail;
     /** Number of bytes cached in the list. */
-    uint32_t             cbCached;
+    uint32_t              cbCached;
 } PDMACFILELRULIST;
 
@@ -278 +294 @@
     /** Critical section protecting the cache. */
     RTCRITSECT       CritSect;
-#ifdef VBOX_WITH_2Q_CACHE
     uint32_t         cbRecentlyUsedInMax;
     uint32_t         cbRecentlyUsedOutMax;
@@ -284 +299 @@
     PDMACFILELRULIST LruRecentlyUsedOut;
     PDMACFILELRULIST LruFrequentlyUsed;
-#else
-    /** Adaption parameter (p) */
-    uint32_t         uAdaptVal;
-    /** LRU list for recently used entries (T1) */
-    PDMACFILELRULIST LruRecentlyUsed;
-    /** LRU list for frequently used entries (T2) */
-    PDMACFILELRULIST LruFrequentlyUsed;
-    /** LRU list for recently evicted entries (B1) */
-    PDMACFILELRULIST LruRecentlyGhost;
-    /** LRU list for evicted entries from T2 (B2) */
-    PDMACFILELRULIST LruFrequentlyGhost;
-#endif
 #ifdef VBOX_WITH_STATISTICS
     /** Hit counter. */
@@ -486 +489 @@
         /** Tail of pending requests. */
         R3PTRTYPE(PPDMACTASKFILE)                  pReqsPendingTail;
+        /** Tree of currently locked ranges.
+         * If a write task is enqueued the range gets locked and any other
+         * task writing to that range has to wait until the task completes.
+         */
+        PAVLRFOFFTREE                              pTreeRangesLocked;
         /** Number of requests currently being processed for this endpoint
          * (excluded flush requests). */
@@ -527 +535 @@
 typedef struct PDMACTASKFILE
 {
-    /** next task in the list. */
+    /** Pointer to the range lock we are waiting for */
+    PPDMACFILERANGELOCK                  pRangeLock;
+    /** Next task in the list. (Depending on the state) */
     struct PDMACTASKFILE                *pNext;
     /** Endpoint */

trunk/src/VBox/VMM/PDMAsyncCompletionFileNormal.cpp

@@ -36 +36 @@
 #define PDMACEPFILEMGR_REQS_MAX 512 /* @todo: Find better solution wrt. the request number*/
 
+/*******************************************************************************
+*   Internal functions                                                         *
+*******************************************************************************/
+static int pdmacFileAioMgrNormalProcessTaskList(PPDMACTASKFILE pTaskHead,
+                                                PPDMACEPFILEMGR pAioMgr,
+                                                PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint);
+
+
 int pdmacFileAioMgrNormalInit(PPDMACEPFILEMGR pAioMgr)
 {
@@ -399 +407 @@
 }
 
+/**
+ * Allocates a async I/O request.
+ *
+ * @returns Handle to the request.
+ * @param   pAioMgr    The I/O manager.
+ */
+static RTFILEAIOREQ pdmacFileAioMgrNormalRequestAlloc(PPDMACEPFILEMGR pAioMgr)
+{
+    RTFILEAIOREQ hReq = NIL_RTFILEAIOREQ;
+
+    /* Get a request handle. */
+    if (pAioMgr->iFreeReqNext != pAioMgr->iFreeEntryNext)
+    {
+        hReq = pAioMgr->pahReqsFree[pAioMgr->iFreeReqNext];
+        pAioMgr->pahReqsFree[pAioMgr->iFreeReqNext] = NIL_RTFILEAIOREQ;
+        pAioMgr->iFreeReqNext = (pAioMgr->iFreeReqNext + 1) % pAioMgr->cReqEntries;
+    }
+    else
+    {
+        int rc = RTFileAioReqCreate(&hReq);
+        AssertRC(rc);
+    }
+
+    return hReq;
+}
+
+static bool pdmacFileAioMgrNormalIsRangeLocked(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint,
+                                               RTFOFF offStart, size_t cbRange,
+                                               PPDMACTASKFILE pTask)
+{
+    PPDMACFILERANGELOCK pRangeLock = NULL; /** < Range lock */
+
+    AssertMsg(   pTask->enmTransferType == PDMACTASKFILETRANSFER_WRITE
+              || pTask->enmTransferType == PDMACTASKFILETRANSFER_READ,
+                 ("Invalid task type %d\n", pTask->enmTransferType));
+
+    pRangeLock = (PPDMACFILERANGELOCK)RTAvlrFileOffsetGet(pEndpoint->AioMgr.pTreeRangesLocked, offStart);
+    if (!pRangeLock)
+    {
+        pRangeLock = (PPDMACFILERANGELOCK)RTAvlrFileOffsetGetBestFit(pEndpoint->AioMgr.pTreeRangesLocked, offStart, true);
+        /* Check if we intersect with the range. */
+        if (   !pRangeLock
+            || !(   (pRangeLock->Core.Key) <= (offStart + (RTFOFF)cbRange - 1)
+                && (pRangeLock->Core.KeyLast) >= offStart))
+        {
+            pRangeLock = NULL; /* False alarm */
+        }
+    }
+
+    /* Check whether we have one of the situations explained below */
+    if (   pRangeLock
+#if 0 /** @todo: later. For now we will just block all requests if they interfere */
+        && (   (pRangeLock->fReadLock && pTask->enmTransferType == PDMACTASKFILETRANSFER_WRITE)
+            || (!pRangeLock->fReadLock)
+#endif
+        )
+    {
+        /* Add to the list. */
+        pTask->pNext = NULL;
+
+        if (!pRangeLock->pWaitingTasksHead)
+        {
+            Assert(!pRangeLock->pWaitingTasksTail);
+            pRangeLock->pWaitingTasksHead = pTask;
+            pRangeLock->pWaitingTasksTail = pTask;
+        }
+        else
+        {
+            AssertPtr(pRangeLock->pWaitingTasksTail);
+            pRangeLock->pWaitingTasksTail->pNext = pTask;
+            pRangeLock->pWaitingTasksTail = pTask;
+        }
+        return true;
+    }
+
+    return false;
+}
+
+static int pdmacFileAioMgrNormalRangeLock(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint,
+                                          RTFOFF offStart, size_t cbRange,
+                                          PPDMACTASKFILE pTask)
+{
+    AssertMsg(!pdmacFileAioMgrNormalIsRangeLocked(pEndpoint, offStart, cbRange, pTask),
+              ("Range is already locked offStart=%RTfoff cbRange=%u\n",
+               offStart, cbRange));
+
+    PPDMACFILERANGELOCK pRangeLock = (PPDMACFILERANGELOCK)RTMemAllocZ(sizeof(PDMACFILERANGELOCK));
+    if (!pRangeLock)
+        return VERR_NO_MEMORY;
+
+    /* Init the lock. */
+    pRangeLock->Core.Key     = offStart;
+    pRangeLock->Core.KeyLast = offStart + cbRange - 1;
+    pRangeLock->cRefs        = 1;
+    pRangeLock->fReadLock    = pTask->enmTransferType == PDMACTASKFILETRANSFER_READ;
+
+    bool fInserted = RTAvlrFileOffsetInsert(pEndpoint->AioMgr.pTreeRangesLocked, &pRangeLock->Core);
+    AssertMsg(fInserted, ("Range lock was not inserted!\n"));
+
+    /* Let the task point to its lock. */
+    pTask->pRangeLock = pRangeLock;
+
+    return VINF_SUCCESS;
+}
+
+static int pdmacFileAioMgrNormalRangeLockFree(PPDMACEPFILEMGR pAioMgr,
+                                              PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint,
+                                              PPDMACFILERANGELOCK pRangeLock)
+{
+    PPDMACTASKFILE pTasksWaitingHead;
+
+    AssertPtr(pRangeLock);
+    Assert(pRangeLock->cRefs == 1);
+
+    RTAvlrFileOffsetRemove(pEndpoint->AioMgr.pTreeRangesLocked, pRangeLock->Core.Key);
+    pTasksWaitingHead = pRangeLock->pWaitingTasksHead;
+    RTMemFree(pRangeLock);
+
+    return pdmacFileAioMgrNormalProcessTaskList(pTasksWaitingHead, pAioMgr, pEndpoint);
+}
+
+static int pdmacFileAioMgrNormalTaskPrepare(PPDMACEPFILEMGR pAioMgr,
+                                            PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint,
+                                            PPDMACTASKFILE pTask, PRTFILEAIOREQ phReq)
+{
+    int rc = VINF_SUCCESS;
+    RTFILEAIOREQ hReq = NIL_RTFILEAIOREQ;
+    PPDMASYNCCOMPLETIONEPCLASSFILE pEpClassFile = (PPDMASYNCCOMPLETIONEPCLASSFILE)pEndpoint->Core.pEpClass;
+    void *pvBuf = pTask->DataSeg.pvSeg;
+
+    /* Get a request handle. */
+    hReq = pdmacFileAioMgrNormalRequestAlloc(pAioMgr);
+    AssertMsg(hReq != NIL_RTFILEAIOREQ, ("Out of request handles\n"));
+
+    /*
+     * Check if the alignment requirements are met.
+     * Offset, transfer size and buffer address
+     * need to be on a 512 boundary.
+     */
+    RTFOFF offStart = pTask->Off & ~(RTFOFF)(512-1);
+    size_t cbToTransfer = RT_ALIGN_Z(pTask->DataSeg.cbSeg + (pTask->Off - offStart), 512);
+    PDMACTASKFILETRANSFER enmTransferType = pTask->enmTransferType;
+
+    AssertMsg(   pTask->enmTransferType == PDMACTASKFILETRANSFER_WRITE
+              || (uint64_t)(offStart + cbToTransfer) <= pEndpoint->cbFile,
+              ("Read exceeds file size offStart=%RTfoff cbToTransfer=%d cbFile=%llu\n",
+               offStart, cbToTransfer, pEndpoint->cbFile));
+
+    pTask->fPrefetch = false;
+
+    /*
+     * Before we start to setup the request we have to check whether there is a task
+     * already active which range intersects with ours. We have to defer execution
+     * of this task in two cases:
+     *     - The pending task is a write and the current is either read or write
+     *     - The pending task is a read and the current task is a write task.
+     *
+     * To check whether a range is currently "locked" we use the AVL tree where every pending task
+     * is stored by its file offset range. The current task will be added to the active task
+     * and will be executed when the active one completes. (The method below
+     * which checks whether a range is already used will add the task)
+     *
+     * This is neccessary because of the requirementto align all requests to a 512 boundary
+     * which is enforced by the host OS (Linux and Windows atm). It is possible that
+     * we have to process unaligned tasks and need to align them using bounce buffers.
+     * While the data is feteched from the file another request might arrive writing to
+     * the same range. This will result in data corruption if both are executed concurrently.
+     */
+    bool fLocked = pdmacFileAioMgrNormalIsRangeLocked(pEndpoint, offStart, cbToTransfer, pTask);
+
+    if (!fLocked)
+    {
+        if (   RT_UNLIKELY(cbToTransfer != pTask->DataSeg.cbSeg)
+            || RT_UNLIKELY(offStart != pTask->Off)
+            || ((pEpClassFile->uBitmaskAlignment & (RTR3UINTPTR)pvBuf) != (RTR3UINTPTR)pvBuf))
+        {
+            LogFlow(("Using bounce buffer for task %#p cbToTransfer=%zd cbSeg=%zd offStart=%RTfoff off=%RTfoff\n",
+                     pTask, cbToTransfer, pTask->DataSeg.cbSeg, offStart, pTask->Off));
+
+            /* Create bounce buffer. */
+            pTask->fBounceBuffer = true;
+
+            AssertMsg(pTask->Off >= offStart, ("Overflow in calculation Off=%llu offStart=%llu\n",
+                      pTask->Off, offStart));
+            pTask->uBounceBufOffset = pTask->Off - offStart;
+
+            /** @todo: I think we need something like a RTMemAllocAligned method here.
+             * Current assumption is that the maximum alignment is 4096byte
+             * (GPT disk on Windows)
+             * so we can use RTMemPageAlloc here.
+             */
+            pTask->pvBounceBuffer = RTMemPageAlloc(cbToTransfer);
+            if (RT_LIKELY(pTask->pvBounceBuffer))
+            {
+                pvBuf = pTask->pvBounceBuffer;
+
+                if (pTask->enmTransferType == PDMACTASKFILETRANSFER_WRITE)
+                {
+                    if (   RT_UNLIKELY(cbToTransfer != pTask->DataSeg.cbSeg)
+                        || RT_UNLIKELY(offStart != pTask->Off))
+                    {
+                        /* We have to fill the buffer first before we can update the data. */
+                        LogFlow(("Prefetching data for task %#p\n", pTask));
+                        pTask->fPrefetch = true;
+                        enmTransferType = PDMACTASKFILETRANSFER_READ;
+                    }
+                    else
+                        memcpy(pvBuf, pTask->DataSeg.pvSeg, pTask->DataSeg.cbSeg);
+                }
+            }
+            else
+                rc = VERR_NO_MEMORY;
+        }
+        else
+            pTask->fBounceBuffer = false;
+
+        if (RT_SUCCESS(rc))
+        {
+            AssertMsg((pEpClassFile->uBitmaskAlignment & (RTR3UINTPTR)pvBuf) == (RTR3UINTPTR)pvBuf,
+                      ("AIO: Alignment restrictions not met! pvBuf=%p uBitmaskAlignment=%p\n", pvBuf, pEpClassFile->uBitmaskAlignment));
+
+            if (enmTransferType == PDMACTASKFILETRANSFER_WRITE)
+            {
+                /* Grow the file if needed. */
+                if (RT_UNLIKELY((uint64_t)(pTask->Off + pTask->DataSeg.cbSeg) > pEndpoint->cbFile))
+                {
+                    ASMAtomicWriteU64(&pEndpoint->cbFile, pTask->Off + pTask->DataSeg.cbSeg);
+                    RTFileSetSize(pEndpoint->File, pTask->Off + pTask->DataSeg.cbSeg);
+                }
+
+                rc = RTFileAioReqPrepareWrite(hReq, pEndpoint->File,
+                                              offStart, pvBuf, cbToTransfer, pTask);
+            }
+            else
+                rc = RTFileAioReqPrepareRead(hReq, pEndpoint->File,
+                                             offStart, pvBuf, cbToTransfer, pTask);
+            AssertRC(rc);
+
+            rc = pdmacFileAioMgrNormalRangeLock(pEndpoint, offStart, cbToTransfer, pTask);
+
+            if (RT_SUCCESS(rc))
+                *phReq = hReq;
+            else
+            {
+                /* Cleanup */
+                if (pTask->fBounceBuffer)
+                    RTMemPageFree(pTask->pvBounceBuffer);
+            }
+        }
+    }
+    else
+    {
+        LogFlow(("Task %#p was deferred because the access range is locked\n", pTask));
+        rc = VINF_SUCCESS;
+    }
+
+    return rc;
+}
+
 static int pdmacFileAioMgrNormalProcessTaskList(PPDMACTASKFILE pTaskHead,
                                                 PPDMACEPFILEMGR pAioMgr,
@@ -407 +674 @@
     unsigned      cMaxRequests = PDMACEPFILEMGR_REQS_MAX - pAioMgr->cRequestsActive;
     int           rc = VINF_SUCCESS;
-    PPDMASYNCCOMPLETIONEPCLASSFILE pEpClassFile = (PPDMASYNCCOMPLETIONEPCLASSFILE)pEndpoint->Core.pEpClass;
 
     AssertMsg(pEndpoint->enmState == PDMASYNCCOMPLETIONENDPOINTFILESTATE_ACTIVE,
@@ -439 +705 @@
                 else
                 {
+                    Assert(!pEndpoint->pFlushReq);
                     pEndpoint->pFlushReq = pCurr;
                 }
@@ -447 +714 @@
             {
                 RTFILEAIOREQ hReq = NIL_RTFILEAIOREQ;
-                void *pvBuf = pCurr->DataSeg.pvSeg;
-
-                /* Get a request handle. */
-                if (pAioMgr->iFreeReqNext != pAioMgr->iFreeEntryNext)
+
+                rc = pdmacFileAioMgrNormalTaskPrepare(pAioMgr, pEndpoint, pCurr, &hReq);
+                AssertRC(rc);
+
+                if (hReq != NIL_RTFILEAIOREQ)
                 {
-                    hReq = pAioMgr->pahReqsFree[pAioMgr->iFreeReqNext];
-                    pAioMgr->pahReqsFree[pAioMgr->iFreeReqNext] = NIL_RTFILEAIOREQ;
-                    pAioMgr->iFreeReqNext = (pAioMgr->iFreeReqNext + 1) % pAioMgr->cReqEntries;
-                }
-                else
-                {
-                    rc = RTFileAioReqCreate(&hReq);
-                    AssertRC(rc);
-                }
-
-                AssertMsg(hReq != NIL_RTFILEAIOREQ, ("Out of request handles\n"));
-
-                /* Check if the alignment requirements are met.
-                 * Offset, transfer size and buffer address
-                 * need to be on a 512 boundary. */
-                RTFOFF offStart = pCurr->Off & ~(RTFOFF)(512-1);
-                size_t cbToTransfer = RT_ALIGN_Z(pCurr->DataSeg.cbSeg + (pCurr->Off - offStart), 512);
-                PDMACTASKFILETRANSFER enmTransferType = pCurr->enmTransferType;
-
-                AssertMsg(   pCurr->enmTransferType == PDMACTASKFILETRANSFER_WRITE
-                          || (uint64_t)(offStart + cbToTransfer) <= pEndpoint->cbFile,
-                          ("Read exceeds file size offStart=%RTfoff cbToTransfer=%d cbFile=%llu\n",
-                          offStart, cbToTransfer, pEndpoint->cbFile));
-
-                pCurr->fPrefetch = false;
-
-                if (   RT_UNLIKELY(cbToTransfer != pCurr->DataSeg.cbSeg)
-                    || RT_UNLIKELY(offStart != pCurr->Off)
-                    || ((pEpClassFile->uBitmaskAlignment & (RTR3UINTPTR)pvBuf) != (RTR3UINTPTR)pvBuf))
-                {
-                    LogFlow(("Using bounce buffer for task %#p cbToTransfer=%zd cbSeg=%zd offStart=%RTfoff off=%RTfoff\n",
-                             pCurr, cbToTransfer, pCurr->DataSeg.cbSeg, offStart, pCurr->Off));
-
-                    /* Create bounce buffer. */
-                    pCurr->fBounceBuffer = true;
-
-                    AssertMsg(pCurr->Off >= offStart, ("Overflow in calculation Off=%llu offStart=%llu\n",
-                              pCurr->Off, offStart));
-                    pCurr->uBounceBufOffset = pCurr->Off - offStart;
-
-                    /** @todo: I think we need something like a RTMemAllocAligned method here.
-                     * Current assumption is that the maximum alignment is 4096byte
-                     * (GPT disk on Windows)
-                     * so we can use RTMemPageAlloc here.
-                     */
-                    pCurr->pvBounceBuffer = RTMemPageAlloc(cbToTransfer);
-                    AssertPtr(pCurr->pvBounceBuffer);
-                    pvBuf = pCurr->pvBounceBuffer;
-
-                    if (pCurr->enmTransferType == PDMACTASKFILETRANSFER_WRITE)
+                    apReqs[cRequests] = hReq;
+                    pEndpoint->AioMgr.cReqsProcessed++;
+                    cMaxRequests--;
+                    cRequests++;
+                    if (cRequests == RT_ELEMENTS(apReqs))
                     {
-                        if (   RT_UNLIKELY(cbToTransfer != pCurr->DataSeg.cbSeg)
-                            || RT_UNLIKELY(offStart != pCurr->Off))
-                        {
-                            /* We have to fill the buffer first before we can update the data. */
-                            LogFlow(("Prefetching data for task %#p\n", pCurr));
-                            pCurr->fPrefetch = true;
-                            enmTransferType = PDMACTASKFILETRANSFER_READ;
-                        }
-                        else
-                            memcpy(pvBuf, pCurr->DataSeg.pvSeg, pCurr->DataSeg.cbSeg);
+                        rc = pdmacFileAioMgrNormalReqsEnqueue(pAioMgr, pEndpoint, apReqs, cRequests);
+                        cRequests = 0;
+                        AssertMsg(RT_SUCCESS(rc) || (rc == VERR_FILE_AIO_INSUFFICIENT_RESSOURCES),
+                                  ("Unexpected return code\n"));
                     }
-                }
-                else
-                    pCurr->fBounceBuffer = false;
-
-                AssertMsg((pEpClassFile->uBitmaskAlignment & (RTR3UINTPTR)pvBuf) == (RTR3UINTPTR)pvBuf,
-                          ("AIO: Alignment restrictions not met! pvBuf=%p uBitmaskAlignment=%p\n", pvBuf, pEpClassFile->uBitmaskAlignment));
-
-                if (enmTransferType == PDMACTASKFILETRANSFER_WRITE)
-                {
-                    /* Grow the file if needed. */
-                    if (RT_UNLIKELY((uint64_t)(pCurr->Off + pCurr->DataSeg.cbSeg) > pEndpoint->cbFile))
-                    {
-                        ASMAtomicWriteU64(&pEndpoint->cbFile, pCurr->Off + pCurr->DataSeg.cbSeg);
-                        RTFileSetSize(pEndpoint->File, pCurr->Off + pCurr->DataSeg.cbSeg);
-                    }
-
-                    rc = RTFileAioReqPrepareWrite(hReq, pEndpoint->File,
-                                                  offStart, pvBuf, cbToTransfer, pCurr);
-                }
-                else
-                    rc = RTFileAioReqPrepareRead(hReq, pEndpoint->File,
-                                                 offStart, pvBuf, cbToTransfer, pCurr);
-                AssertRC(rc);
-
-                apReqs[cRequests] = hReq;
-                pEndpoint->AioMgr.cReqsProcessed++;
-                cMaxRequests--;
-                cRequests++;
-                if (cRequests == RT_ELEMENTS(apReqs))
-                {
-                    rc = pdmacFileAioMgrNormalReqsEnqueue(pAioMgr, pEndpoint, apReqs, cRequests);
-                    cRequests = 0;
-                    AssertMsg(RT_SUCCESS(rc) || (rc == VERR_FILE_AIO_INSUFFICIENT_RESSOURCES),
-                              ("Unexpected return code\n"));
                 }
                 break;
@@ -968 +1151 @@
                             pEndpoint->AioMgr.cReqsProcessed++;
 
+                            /* Free the lock and process pending tasks if neccessary */
+                            pdmacFileAioMgrNormalRangeLockFree(pAioMgr, pEndpoint, pTask->pRangeLock);
+
                             /* Call completion callback */
                             pTask->pfnCompleted(pTask, pTask->pvUser);

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

@@ -49 +49 @@
 #include <iprt/thread.h>
 #include <iprt/param.h>
+#include <iprt/message.h>
 
 #define TESTCASE "tstPDMAsyncCompletionStress"
@@ -179 +180 @@
 
         if (memcmp(pbBuf, pbTestPattern, cbCompare))
-            AssertMsgFailed(("Unexpected data for off=%RTfoff size=%u\n", pTestTask->off, pTestTask->DataSeg.cbSeg));
+        {
+            unsigned idx = 0;
+
+            while (   (pbBuf[idx] == pbTestPattern[idx])
+                   && (idx < cbCompare))
+                idx++;
+
+            RTMsgError("Unexpected data for off=%RTfoff size=%u\n"
+                       "Expected %c got %c\n",
+                       pTestTask->off + idx, pTestTask->DataSeg.cbSeg,
+                       pbTestPattern[idx], pbBuf[idx]);
+            RTAssertDebugBreak();
+        }
 
         pbBuf  += cbCompare;
@@ -315 +328 @@
     int uRnd = RTRandU32Ex(0, 100);
 
-    return (uRnd < iPercentage); /* This should be enough for our purpose */
+    return (uRnd <= iPercentage); /* This should be enough for our purpose */
 }