Changeset 25147 in vbox for trunk/src

Timestamp:

Dec 2, 2009 1:42:32 PM (15 years ago)

Author:

vboxsync

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

55558

Message:

AsyncCompletion/Cache: Complete all pending writes before completing a flush

Location:

trunk/src/VBox/VMM

Files:

• PDMAsyncCompletionFile.cpp (modified) (2 diffs)
• PDMAsyncCompletionFileCache.cpp (modified) (6 diffs)
• PDMAsyncCompletionFileInternal.h (modified) (2 diffs)

trunk/src/VBox/VMM/PDMAsyncCompletionFile.cpp

@@ -850 +850 @@
                             PPDMASYNCCOMPLETIONENDPOINT pEndpoint)
 {
+    int rc = VINF_SUCCESS;
     PPDMASYNCCOMPLETIONENDPOINTFILE pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pEndpoint;
     PPDMASYNCCOMPLETIONTASKFILE pTaskFile = (PPDMASYNCCOMPLETIONTASKFILE)pTask;
@@ -858 +859 @@
     pTaskFile->cbTransferLeft = 0;
 
-    PPDMACTASKFILE pIoTask = pdmacFileTaskAlloc(pEpFile);
-    AssertPtr(pIoTask);
-
-    pIoTask->pEndpoint       = pEpFile;
-    pIoTask->enmTransferType = PDMACTASKFILETRANSFER_FLUSH;
-    pIoTask->pvUser          = pTaskFile;
-    pIoTask->pfnCompleted    = pdmacFileEpTaskCompleted;
-    pdmacFileEpAddTask(pEpFile, pIoTask);
-
-    return VINF_SUCCESS;
+    if (pEpFile->fCaching)
+        rc = pdmacFileEpCacheFlush(pEpFile, pTaskFile);
+    else
+    {
+        PPDMACTASKFILE pIoTask = pdmacFileTaskAlloc(pEpFile);
+        AssertPtr(pIoTask);
+
+        pIoTask->pEndpoint       = pEpFile;
+        pIoTask->enmTransferType = PDMACTASKFILETRANSFER_FLUSH;
+        pIoTask->pvUser          = pTaskFile;
+        pIoTask->pfnCompleted    = pdmacFileEpTaskCompleted;
+        pdmacFileEpAddTask(pEpFile, pIoTask);
+    }
+
+    return rc;
 }
 

trunk/src/VBox/VMM/PDMAsyncCompletionFileCache.cpp

@@ -563 +563 @@
 
 /**
+ * Completes a task segment freeing all ressources and completes the task handle
+ * if everything was transfered.
+ *
+ * @returns Next task segment handle.
+ * @param   pEndpointCache    The endpoint cache.
+ * @param   pTaskSeg          Task segment to complete.
+ */
+static PPDMACFILETASKSEG pdmacFileCacheTaskComplete(PPDMACFILEENDPOINTCACHE pEndpointCache, PPDMACFILETASKSEG pTaskSeg)
+{
+    PPDMACFILETASKSEG pNext = pTaskSeg->pNext;
+
+    uint32_t uOld = ASMAtomicSubU32(&pTaskSeg->pTask->cbTransferLeft, pTaskSeg->cbTransfer);
+    AssertMsg(uOld >= pTaskSeg->cbTransfer, ("New value would overflow\n"));
+    if (!(uOld - pTaskSeg->cbTransfer)
+        && !ASMAtomicXchgBool(&pTaskSeg->pTask->fCompleted, true))
+    {
+        pdmR3AsyncCompletionCompleteTask(&pTaskSeg->pTask->Core);
+
+        if (pTaskSeg->fWrite)
+        {
+            /* Complete a pending flush if all writes have completed */
+            uint32_t cWritesOutstanding = ASMAtomicDecU32(&pEndpointCache->cWritesOutstanding);
+            PPDMASYNCCOMPLETIONTASKFILE pTaskFlush = (PPDMASYNCCOMPLETIONTASKFILE)ASMAtomicXchgPtr((void * volatile *)&pEndpointCache->pTaskFlush, NULL);
+
+            if (!cWritesOutstanding && pTaskFlush)
+                pdmR3AsyncCompletionCompleteTask(&pTaskFlush->Core);
+        }
+    }
+
+    RTMemFree(pTaskSeg);
+
+    return pNext;
+}
+
+/**
  * Completion callback for I/O tasks.
  *
@@ -613 +648 @@
                 pEntry->fFlags |= PDMACFILECACHE_ENTRY_IS_DIRTY;
 
-                uint32_t uOld = ASMAtomicSubU32(&pCurr->pTask->cbTransferLeft, pCurr->cbTransfer);
-                AssertMsg(uOld >= pCurr->cbTransfer, ("New value would overflow\n"));
-                if (!(uOld - pCurr->cbTransfer)
-                    && !ASMAtomicXchgBool(&pCurr->pTask->fCompleted, true))
-                    pdmR3AsyncCompletionCompleteTask(&pCurr->pTask->Core);
-
-                PPDMACFILETASKSEG pFree = pCurr;
-                pCurr = pCurr->pNext;
-
-                RTMemFree(pFree);
+                pCurr = pdmacFileCacheTaskComplete(pEndpointCache, pCurr);
             }
         }
@@ -641 +667 @@
                 memcpy(pCurr->pvBuf, pEntry->pbData + pCurr->uBufOffset, pCurr->cbTransfer);
 
-            uint32_t uOld = ASMAtomicSubU32(&pCurr->pTask->cbTransferLeft, pCurr->cbTransfer);
-            AssertMsg(uOld >= pCurr->cbTransfer, ("New value would overflow\n"));
-            if (!(uOld - pCurr->cbTransfer)
-                && !ASMAtomicXchgBool(&pCurr->pTask->fCompleted, true))
-                pdmR3AsyncCompletionCompleteTask(&pCurr->pTask->Core);
-
-            PPDMACFILETASKSEG pFree = pCurr;
-            pCurr = pCurr->pNext;
-
-            RTMemFree(pFree);
+            pCurr = pdmacFileCacheTaskComplete(pEndpointCache, pCurr);
         }
     }
@@ -1508 +1525 @@
     /* Set to completed to make sure that the task is valid while we access it. */
     ASMAtomicWriteBool(&pTask->fCompleted, true);
+    ASMAtomicIncU32(&pEndpointCache->cWritesOutstanding);
 
     int iSegCurr       = 0;
@@ -1909 +1927 @@
     if (ASMAtomicReadS32(&pTask->cbTransferLeft) == 0
         && !ASMAtomicXchgBool(&pTask->fCompleted, true))
+    {
         pdmR3AsyncCompletionCompleteTask(&pTask->Core);
 
+        /* Complete a pending flush if all writes have completed */
+        uint32_t cWritesOutstanding = ASMAtomicDecU32(&pEndpointCache->cWritesOutstanding);
+        PPDMASYNCCOMPLETIONTASKFILE pTaskFlush = (PPDMASYNCCOMPLETIONTASKFILE)ASMAtomicXchgPtr((void * volatile *)&pEndpointCache->pTaskFlush, NULL);
+
+        if (!cWritesOutstanding && pTaskFlush)
+            pdmR3AsyncCompletionCompleteTask(&pTaskFlush->Core);
+    }
+
     return VINF_SUCCESS;
 }
@@ -1916 +1943 @@
 #undef ADVANCE_SEGMENT_BUFFER
 
+int pdmacFileEpCacheFlush(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint, PPDMASYNCCOMPLETIONTASKFILE pTask)
+{
+    int rc = VINF_SUCCESS;
+
+    if (ASMAtomicReadPtr((void * volatile *)&pEndpoint->DataCache.pTaskFlush))
+        rc = VERR_RESOURCE_BUSY;
+    else
+    {
+        if (ASMAtomicReadU32(&pEndpoint->DataCache.cWritesOutstanding) > 0)
+            ASMAtomicWritePtr((void * volatile *)&pEndpoint->DataCache.pTaskFlush, pTask);
+        else
+            pdmR3AsyncCompletionCompleteTask(&pTask->Core);
+    }
+
+    return rc;
+}
+

trunk/src/VBox/VMM/PDMAsyncCompletionFileInternal.h

@@ -324 +324 @@
 {
     /** AVL tree managing cache entries. */
-    PAVLRFOFFTREE         pTree;
+    PAVLRFOFFTREE                        pTree;
     /** R/W semaphore protecting cached entries for this endpoint. */
-    RTSEMRW               SemRWEntries;
+    RTSEMRW                              SemRWEntries;
     /** Pointer to the gobal cache data */
-    PPDMACFILECACHEGLOBAL pCache;
-
+    PPDMACFILECACHEGLOBAL                pCache;
+    /** Number of writes outstanding. */
+    volatile uint32_t                    cWritesOutstanding;
+    /** Handle of the flush request if one is active */
+    volatile PPDMASYNCCOMPLETIONTASKFILE pTaskFlush;
 #ifdef VBOX_WITH_STATISTICS
     /** Number of times a write was deferred because the cache entry was still in progress */
-    STAMCOUNTER           StatWriteDeferred;
+    STAMCOUNTER                          StatWriteDeferred;
 #endif
 } PDMACFILEENDPOINTCACHE, *PPDMACFILEENDPOINTCACHE;
@@ -592 +595 @@
                           RTFOFF off, PCPDMDATASEG paSegments, size_t cSegments,
                           size_t cbWrite);
+int pdmacFileEpCacheFlush(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint, PPDMASYNCCOMPLETIONTASKFILE pTask);
 
 RT_C_DECLS_END