Changeset 28383 in vbox for trunk/src/VBox

Timestamp:

Apr 15, 2010 6:07:21 PM (15 years ago)

Author:

vboxsync

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

60144

Message:

async I/O: Add async flush method

Location:

trunk/src/VBox/Devices/Storage

Files:

• DrvBlock.cpp (modified) (2 diffs)
• DrvSCSI.cpp (modified) (4 diffs)
• DrvVD.cpp (modified) (2 diffs)
• VBoxHDD.cpp (modified) (2 diffs)
• VDIHDDCore.cpp (modified) (3 diffs)

trunk/src/VBox/Devices/Storage/DrvBlock.cpp

@@ -326 +326 @@
 }
 
+
+/** @copydoc PDMIBLOCKASYNC::pfnStartFLush */
+static DECLCALLBACK(int) drvblockAsyncFlushStart(PPDMIBLOCKASYNC pInterface, void *pvUser)
+{
+    PDRVBLOCK pThis = PDMIBLOCKASYNC_2_DRVBLOCK(pInterface);
+
+    /*
+     * Check the state.
+     */
+    if (!pThis->pDrvMediaAsync)
+    {
+        AssertMsgFailed(("Invalid state! Not mounted!\n"));
+        return VERR_PDM_MEDIA_NOT_MOUNTED;
+    }
+
+    int rc = pThis->pDrvMediaAsync->pfnStartFlush(pThis->pDrvMediaAsync, pvUser);
+
+    return rc;
+}
+
 /* -=-=-=-=- IMediaAsyncPort -=-=-=-=- */
 
@@ -774 +794 @@
     pThis->IBlockAsync.pfnStartRead         = drvblockAsyncReadStart;
     pThis->IBlockAsync.pfnStartWrite        = drvblockAsyncWriteStart;
+    pThis->IBlockAsync.pfnStartFlush        = drvblockAsyncFlushStart;
 
     /* IMediaAsyncPort. */

trunk/src/VBox/Devices/Storage/DrvSCSI.cpp

@@ -223 +223 @@
     if (pThis->pDrvBlockAsync)
     {
-        /* asnyc I/O path. */
+        /* async I/O path. */
         VSCSIIOREQTXDIR enmTxDir;
 
@@ -234 +234 @@
             case VSCSIIOREQTXDIR_FLUSH:
             {
-                /** @todo Flush callback for the async I/O interface. */
-                ASMAtomicDecU32(&pThis->StatIoDepth);
-                VSCSIIoReqCompleted(hVScsiIoReq, VINF_SUCCESS);
+                rc = pThis->pDrvBlockAsync->pfnStartFlush(pThis->pDrvBlockAsync, hVScsiIoReq);
+                if (RT_FAILURE(rc) && rc != VERR_VD_ASYNC_IO_IN_PROGRESS)
+                    AssertMsgFailed(("%s: Failed to flush data %Rrc\n", __FUNCTION__, rc));
                 break;
             }
@@ -273 +273 @@
                 }
 
-                if (rc == VINF_VD_ASYNC_IO_FINISHED)
-                {
-                    if (enmTxDir == VSCSIIOREQTXDIR_READ)
-                        pThis->pLed->Actual.s.fReading = 0;
-                    else if (enmTxDir == VSCSIIOREQTXDIR_WRITE)
-                        pThis->pLed->Actual.s.fWriting = 0;
-                    else
-                        AssertMsgFailed(("Invalid transfer direction %u\n", enmTxDir));
-                    ASMAtomicDecU32(&pThis->StatIoDepth);
-                    VSCSIIoReqCompleted(hVScsiIoReq, VINF_SUCCESS);
-                }
-                else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
-                    rc = VINF_SUCCESS;
-                else if (RT_FAILURE(rc))
-                {
-                    if (enmTxDir == VSCSIIOREQTXDIR_READ)
-                        pThis->pLed->Actual.s.fReading = 0;
-                    else if (enmTxDir == VSCSIIOREQTXDIR_WRITE)
-                        pThis->pLed->Actual.s.fWriting = 0;
-                    else
-                        AssertMsgFailed(("Invalid transfer direction %u\n", enmTxDir));
-                    ASMAtomicDecU32(&pThis->StatIoDepth);
-                    VSCSIIoReqCompleted(hVScsiIoReq, rc);
-                }
-                else
-                    AssertMsgFailed(("Invalid return coe rc=%Rrc\n", rc));
-
                 break;
             }
@@ -305 +278 @@
                 AssertMsgFailed(("Invalid transfer direction %u\n", enmTxDir));
         }
+
+        if (rc == VINF_VD_ASYNC_IO_FINISHED)
+        {
+            if (enmTxDir == VSCSIIOREQTXDIR_READ)
+                pThis->pLed->Actual.s.fReading = 0;
+            else if (enmTxDir == VSCSIIOREQTXDIR_WRITE)
+                pThis->pLed->Actual.s.fWriting = 0;
+            else
+                AssertMsg(enmTxDir == VSCSIIOREQTXDIR_FLUSH, ("Invalid transfer direction %u\n", enmTxDir));
+
+            ASMAtomicDecU32(&pThis->StatIoDepth);
+            VSCSIIoReqCompleted(hVScsiIoReq, VINF_SUCCESS);
+        }
+        else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
+            rc = VINF_SUCCESS;
+        else if (RT_FAILURE(rc))
+        {
+            if (enmTxDir == VSCSIIOREQTXDIR_READ)
+                pThis->pLed->Actual.s.fReading = 0;
+            else if (enmTxDir == VSCSIIOREQTXDIR_WRITE)
+                pThis->pLed->Actual.s.fWriting = 0;
+            else
+                AssertMsg(enmTxDir == VSCSIIOREQTXDIR_FLUSH, ("Invalid transfer direction %u\n", enmTxDir));
+
+            ASMAtomicDecU32(&pThis->StatIoDepth);
+            VSCSIIoReqCompleted(hVScsiIoReq, rc);
+        }
+        else
+            AssertMsgFailed(("Invalid return code rc=%Rrc\n", rc));
     }
     else

trunk/src/VBox/Devices/Storage/DrvVD.cpp

@@ -1017 +1017 @@
                                          size_t cbWrite, void *pvUser)
 {
-     LogFlow(("%s: uOffset=%#llx paSeg=%#p cSeg=%u cbWrite=%d\n pvUser=%#p", __FUNCTION__,
+     LogFlow(("%s: uOffset=%#llx paSeg=%#p cSeg=%u cbWrite=%d pvUser=%#p\n", __FUNCTION__,
              uOffset, paSeg, cSeg, cbWrite, pvUser));
     PVBOXDISK pThis = PDMIMEDIAASYNC_2_VBOXDISK(pInterface);
     int rc = VDAsyncWrite(pThis->pDisk, uOffset, cbWrite, paSeg, cSeg,
                           drvvdAsyncReqComplete, pThis, pvUser);
+    LogFlow(("%s: returns %Rrc\n", __FUNCTION__, rc));
+    return rc;
+}
+
+static DECLCALLBACK(int) drvvdStartFlush(PPDMIMEDIAASYNC pInterface, void *pvUser)
+{
+     LogFlow(("%s: pvUser=%#p\n", __FUNCTION__, pvUser));
+    PVBOXDISK pThis = PDMIMEDIAASYNC_2_VBOXDISK(pInterface);
+    int rc = VDAsyncFlush(pThis->pDisk, drvvdAsyncReqComplete, pThis, pvUser);
     LogFlow(("%s: returns %Rrc\n", __FUNCTION__, rc));
     return rc;
@@ -1240 +1249 @@
     pThis->IMediaAsync.pfnStartRead       = drvvdStartRead;
     pThis->IMediaAsync.pfnStartWrite      = drvvdStartWrite;
+    pThis->IMediaAsync.pfnStartFlush      = drvvdStartFlush;
 
     /* Initialize supported VD interfaces. */

trunk/src/VBox/Devices/Storage/VBoxHDD.cpp

@@ -1873 +1873 @@
                           PVDIOCTX pIoCtx)
 {
-    return VERR_NOT_IMPLEMENTED;
+    PVBOXHDD pDisk = (PVBOXHDD)pvUser;
+    int rc = VINF_SUCCESS;
+    PVDIOTASK pIoTask;
+    void *pvTask = NULL;
+
+    pIoTask = vdIoTaskMetaAlloc(pDisk, pIoCtx, VDIOCTXTXDIR_FLUSH,
+                                NULL, NULL);
+    if (!pIoTask)
+        return VERR_NO_MEMORY;
+
+    ASMAtomicIncU32(&pIoCtx->cMetaTransfersPending);
+
+    int rc2 = pDisk->pInterfaceAsyncIOCallbacks->pfnFlushAsync(pDisk->pInterfaceAsyncIO->pvUser,
+                                                               pIoStorage->u.pStorage,
+                                                               pIoTask,
+                                                               &pvTask);
+    if (rc2 == VINF_SUCCESS)
+    {
+        ASMAtomicDecU32(&pIoCtx->cMetaTransfersPending);
+        vdIoTaskFree(pDisk, pIoTask);
+    }
+    else if (rc2 == VERR_VD_ASYNC_IO_IN_PROGRESS)
+        rc = VINF_SUCCESS;
+    else if (RT_FAILURE(rc2))
+        rc = rc2;
+
+    return rc;
 }
 
@@ -5705 +5731 @@
     LogFlowFunc(("returns %Rrc\n", rc));
     return rc;
-
+}
+
+
+VBOXDDU_DECL(int) VDAsyncFlush(PVBOXHDD pDisk, PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
+                               void *pvUser1, void *pvUser2)
+{
+    int rc;
+    int rc2;
+    bool fLockWrite = false;
+    PVDIOCTX pIoCtx = NULL;
+
+    LogFlowFunc(("pDisk=%#p\n", pDisk));
+
+    do
+    {
+        /* sanity check */
+        AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
+        AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
+
+        pIoCtx = vdIoCtxRootAlloc(pDisk, VDIOCTXTXDIR_FLUSH, 0,
+                                  0, NULL, 0,
+                                  pfnComplete, pvUser1, pvUser2,
+                                  NULL);
+        if (!pIoCtx)
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+
+        PVDIMAGE pImage = pDisk->pLast;
+        AssertPtrBreakStmt(pImage, rc = VERR_VD_NOT_OPENED);
+
+        vdResetModifiedFlag(pDisk);
+        rc = pImage->Backend->pfnAsyncFlush(pImage->pvBackendData, pIoCtx);
+    } while (0);
+
+    if (RT_UNLIKELY(fLockWrite) && RT_FAILURE(rc))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        if (   !pIoCtx->cbTransferLeft
+            && !pIoCtx->cMetaTransfersPending
+            && ASMAtomicCmpXchgBool(&pIoCtx->fComplete, true, false))
+        {
+            vdIoCtxFree(pDisk, pIoCtx);
+            rc = VINF_VD_ASYNC_IO_FINISHED;
+        }
+        else
+        {
+            LogFlow(("cbTransferLeft=%u cMetaTransfersPending=%u fComplete=%RTbool\n",
+                     pIoCtx->cbTransferLeft, pIoCtx->cMetaTransfersPending,
+                     pIoCtx->fComplete));
+            rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
+        }
+    }
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
 }
 

trunk/src/VBox/Devices/Storage/VDIHDDCore.cpp

@@ -234 +234 @@
     return pImage->pStorage != NULL;
 #endif
+}
+
+static int vdiFileFlushAsync(PVDIIMAGEDESC pImage, PVDIOCTX pIoCtx)
+{
+    return pImage->pInterfaceIOCallbacks->pfnFlushAsync(pImage->pInterfaceIO->pvUser,
+                                                        pImage->pStorage, pIoCtx);
 }
 
@@ -951 +957 @@
 
 /**
+ * Internal: Flush the image file to disk - async version.
+ */
+static void vdiFlushImageAsync(PVDIIMAGEDESC pImage, PVDIOCTX pIoCtx)
+{
+    if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
+    {
+        /* Save header. */
+        int rc = vdiUpdateHeaderAsync(pImage, pIoCtx);
+        AssertMsgRC(rc, ("vdiUpdateHeaderAsync() failed, filename=\"%s\", rc=%Rrc\n",
+                         pImage->pszFilename, rc));
+        rc = vdiFileFlushAsync(pImage, pIoCtx);
+        AssertMsgRC(rc, ("Flushing data to disk failed rc=%Rrc\n", rc));
+    }
+}
+
+/**
  * Internal: Free all allocated space for representing an image, and optionally
  * delete the image from disk.
@@ -2229 +2251 @@
 static int vdiAsyncFlush(void *pvBackendData, PVDIOCTX pIoCtx)
 {
-    int rc = VERR_NOT_IMPLEMENTED;
+    LogFlowFunc(("pBackendData=%#p\n", pvBackendData));
+    PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pvBackendData;
+    int rc = VINF_SUCCESS;
+
+    Assert(pImage);
+
+    vdiFlushImageAsync(pImage, pIoCtx);
     LogFlowFunc(("returns %Rrc\n", rc));
     return rc;