Changeset 28154 in vbox

Timestamp:

Apr 9, 2010 7:11:23 PM (15 years ago)

Author:

vboxsync

Message:

VBoxHDD: async I/O for VDI and RAW images. Seems to work so far but still disabled ofc if UseNewIo is false

Location:

trunk/src/VBox/Devices/Storage

Files:

• RawHDDCore.cpp (modified) (4 diffs)
• VBoxHDD.cpp (modified) (15 diffs)
• VDIHDDCore.cpp (modified) (4 diffs)

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

@@ -1200 +1200 @@
 static bool rawIsAsyncIOSupported(void *pvBackendData)
 {
-    return false;
+    return true;
 }
 
@@ -1206 +1206 @@
                         PVDIOCTX pIoCtx, size_t *pcbActuallyRead)
 {
-    int rc = VERR_NOT_IMPLEMENTED;
-    LogFlowFunc(("returns %Rrc\n", rc));
+    int rc = VINF_SUCCESS;
+    PRAWIMAGE pImage = (PRAWIMAGE)pvBackendData;
+
+    rc = pImage->pInterfaceIOCallbacks->pfnReadUserAsync(pImage->pInterfaceIO->pvUser,
+                                                         pImage->pStorage,
+                                                         uOffset, pIoCtx, cbRead);
+    if (RT_SUCCESS(rc))
+        *pcbActuallyRead = cbRead;
+
     return rc;
 }
@@ -1216 +1223 @@
                          size_t *pcbPostRead, unsigned fWrite)
 {
-    int rc = VERR_NOT_IMPLEMENTED;
-    LogFlowFunc(("returns %Rrc\n", rc));
+    int rc = VINF_SUCCESS;
+    PRAWIMAGE pImage = (PRAWIMAGE)pvBackendData;
+
+    rc = pImage->pInterfaceIOCallbacks->pfnWriteUserAsync(pImage->pInterfaceIO->pvUser,
+                                                         pImage->pStorage,
+                                                         uOffset, pIoCtx, cbWrite);
+
+    if (RT_SUCCESS(rc))
+    {
+        *pcbWriteProcess = cbWrite;
+        *pcbPostRead = 0;
+        *pcbPreRead  = 0;
+    }
+
     return rc;
 }
@@ -1235 +1254 @@
     sizeof(VBOXHDDBACKEND),
     /* uBackendCaps */
-    VD_CAP_CREATE_FIXED | VD_CAP_FILE,
+    VD_CAP_CREATE_FIXED | VD_CAP_FILE | VD_CAP_ASYNC,
     /* papszFileExtensions */
     s_apszRawFileExtensions,

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

@@ -208 +208 @@
     /** Flag whether the request finished */
     volatile bool                fComplete;
+    /** Temporary allocated memory which is freed
+     * when the context completes. */
+    void                        *pvAllocation;
     /** Parent I/O context if any. Sets the type of the context (root/child) */
     PVDIOCTX                     pIoCtxParent;
@@ -527 +530 @@
 DECLINLINE(PVDIOCTX) vdIoCtxAlloc(PVBOXHDD pDisk, VDIOCTXTXDIR enmTxDir,
                                   uint64_t uOffset, size_t cbTransfer,
-                                  PCRTSGSEG pcaSeg, unsigned cSeg)
+                                  PCRTSGSEG pcaSeg, unsigned cSeg,
+                                  void *pvAllocation)
 {
     PVDIOCTX pIoCtx = NULL;
@@ -540 +544 @@
         pIoCtx->cMetaTransfersPending = 0;
         pIoCtx->fComplete             = false;
+        pIoCtx->pvAllocation          = pvAllocation;
 
         RTSgBufInit(&pIoCtx->SgBuf, pcaSeg, cSeg);
@@ -551 +556 @@
                                  PCRTSGSEG paSeg, unsigned cSeg,
                                  PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
-                                 void *pvUser1, void *pvUser2)
+                                 void *pvUser1, void *pvUser2,
+                                 void *pvAllocation)
 {
     PVDIOCTX pIoCtx = vdIoCtxAlloc(pDisk, enmTxDir, uOffset, cbTransfer,
-                                   paSeg, cSeg);
+                                   paSeg, cSeg, pvAllocation);
 
     if (RT_LIKELY(pIoCtx))
@@ -570 +576 @@
                                   uint64_t uOffset, size_t cbTransfer,
                                   PCRTSGSEG paSeg, unsigned cSeg,
-                                  PVDIOCTX pIoCtxParent, size_t cbTransferParent)
+                                  PVDIOCTX pIoCtxParent, size_t cbTransferParent,
+                                  void *pvAllocation)
 {
     PVDIOCTX pIoCtx = vdIoCtxAlloc(pDisk, enmTxDir, uOffset, cbTransfer,
-                                   paSeg, cSeg);
+                                   paSeg, cSeg, pvAllocation);
 
     if (RT_LIKELY(pIoCtx))
@@ -621 +628 @@
 static void vdIoCtxFree(PVBOXHDD pDisk, PVDIOCTX pIoCtx)
 {
+    if (pIoCtx->pvAllocation)
+        RTMemFree(pIoCtx->pvAllocation);
     RTMemCacheFree(pDisk->hMemCacheIoCtx, pIoCtx);
 }
@@ -1138 +1147 @@
         return rc;
 
-#if 0
+    /** @todo Snapshots */
+    Assert(!pIoCtxDst->cbTransferLeft && !pIoCtxDst->cMetaTransfersPending);
+
+    vdIoCtxChildReset(pIoCtxDst);
+    RTSgBufAdvance(&pIoCtxDst->SgBuf, cbPreRead);
+
     /* Check if the write would modify anything in this block. */
-    if (   !memcmp((char *)pvTmp + cbPreRead, pvBuf, cbThisWrite)
-        && (!cbWriteCopy || !memcmp((char *)pvTmp + cbPreRead + cbThisWrite,
-                                    (char *)pvBuf + cbThisWrite, cbWriteCopy)))
-    {
-        /* Block is completely unchanged, so no need to write anything. */
-        return VINF_SUCCESS;
+    if (!RTSgBufCmp(&pIoCtxDst->SgBuf, &pIoCtxSrc->SgBuf, cbThisWrite))
+    {
+        RTSGBUF SgBufSrcTmp;
+
+        RTSgBufClone(&SgBufSrcTmp, &pIoCtxSrc->SgBuf);
+        RTSgBufAdvance(&SgBufSrcTmp, cbThisWrite);
+        RTSgBufAdvance(&pIoCtxDst->SgBuf, cbThisWrite);
+
+        if (!cbWriteCopy || !RTSgBufCmp(&pIoCtxDst->SgBuf, &SgBufSrcTmp, cbWriteCopy))
+        {
+            /* Block is completely unchanged, so no need to write anything. */
+            LogFlowFunc(("Block didn't changed\n"));
+            ASMAtomicWriteU32(&pIoCtxDst->cbTransferLeft, 0);
+            return VINF_SUCCESS;
+        }
     }
 
     /* Copy the data to the right place in the buffer. */
-    memcpy((char *)pvTmp + cbPreRead, pvBuf, cbThisWrite);
+    RTSgBufReset(&pIoCtxDst->SgBuf);
+    RTSgBufAdvance(&pIoCtxDst->SgBuf, cbPreRead);
+    vdIoCtxCopy(pIoCtxDst, pIoCtxSrc, cbThisWrite);
 
     /* Handle the data that goes after the write to fill the block. */
@@ -1156 +1181 @@
         /* Now assemble the remaining data. */
         if (cbWriteCopy)
-            memcpy((char *)pvTmp + cbPreRead + cbThisWrite,
-                   (char *)pvBuf + cbThisWrite, cbWriteCopy);
+            vdIoCtxCopy(pIoCtxDst, pIoCtxSrc, cbWriteCopy);
         /* Zero out the remainder of this block. Will never be visible, as this
          * is beyond the limit of the image. */
         if (cbFill)
-            memset((char *)pvTmp + cbPreRead + cbThisWrite + cbWriteCopy + cbReadImage,
-                   '\0', cbFill);
+        {
+            RTSgBufAdvance(&pIoCtxDst->SgBuf, cbReadImage);
+            vdIoCtxSet(pIoCtxDst, '\0', cbFill);
+        }
     }
 
     /* Write the full block to the virtual disk. */
-    rc = pImage->Backend->pfnWrite(pImage->pvBackendData,
-                                   uOffset - cbPreRead, pvTmp,
-                                   cbPreRead + cbThisWrite + cbPostRead,
-                                   NULL, &cbPreRead, &cbPostRead, 0);
+    RTSgBufReset(&pIoCtxDst->SgBuf);
+    rc = pImage->Backend->pfnAsyncWrite(pImage->pvBackendData,
+                                        uOffset - cbPreRead,
+                                        cbPreRead + cbThisWrite + cbPostRead,
+                                        pIoCtxDst, NULL, &cbPreRead, &cbPostRead, 0);
     Assert(rc != VERR_VD_BLOCK_FREE);
     Assert(cbPreRead == 0);
     Assert(cbPostRead == 0);
-#endif
+
     return rc;
 }
@@ -1211 +1238 @@
              * A bit hackish but avoids the need to allocate memory twice.
              */
-            PRTSGSEG pTmp = (PRTSGSEG)RTMemTmpAlloc(cbPreRead + cbThisWrite + cbPostRead + sizeof(RTSGSEG));
+            PRTSGSEG pTmp = (PRTSGSEG)RTMemAlloc(cbPreRead + cbThisWrite + cbPostRead + sizeof(RTSGSEG));
             AssertBreakStmt(VALID_PTR(pTmp), rc = VERR_NO_MEMORY);
 
@@ -1218 +1245 @@
 
             PVDIOCTX pIoCtxWrite = vdIoCtxChildAlloc(pDisk, VDIOCTXTXDIR_WRITE,
-                                                     uOffset, pTmp->cbSeg, 
+                                                     uOffset - cbPreRead, pTmp->cbSeg,
                                                      pTmp, 1,
-                                                     pIoCtx, cbThisWrite);
+                                                     pIoCtx, cbThisWrite,
+                                                     pTmp);
             if (!VALID_PTR(pIoCtxWrite))
             {
@@ -1251 +1279 @@
             if (RT_FAILURE(rc))
             {
-                RTMemTmpFree(pTmp);
                 vdIoCtxFree(pDisk, pIoCtxWrite);
                 break;
@@ -1259 +1286 @@
                 && ASMAtomicCmpXchgBool(&pIoCtxWrite->fComplete, true, false))
             {
+                LogFlow(("Child write request completed\n"));
                 RTMemTmpFree(pTmp);
                 ASMAtomicSubU32(&pIoCtx->cbTransferLeft, cbThisWrite);
                 vdIoCtxFree(pDisk, pIoCtxWrite);
             }
+            else
+                LogFlow(("Child write pending\n"));
         }
 
@@ -1551 +1581 @@
     {
         LogFlowFunc(("I/O context completed\n"));
-        Assert(!pIoCtx->pIoCtxParent);
-        pIoCtx->Type.Root.pfnComplete(pIoCtx->Type.Root.pvUser1, pIoCtx->Type.Root.pvUser2);
+        if (pIoCtx->pIoCtxParent)
+        {
+            PVDIOCTX pIoCtxParent = pIoCtx->pIoCtxParent;
+
+            /* Update the parent state. */
+            Assert(!pIoCtxParent->pIoCtxParent);
+            Assert(pIoCtx->enmTxDir == VDIOCTXTXDIR_WRITE);
+            RTMemFree((void *)pIoCtx->SgBuf.pcaSeg); /* This will also free the attached buffer. */
+            ASMAtomicSubU32(&pIoCtxParent->cbTransferLeft, pIoCtx->Type.Child.cbTransferParent);
+
+            if (   !pIoCtxParent->cbTransferLeft
+                && !pIoCtxParent->cMetaTransfersPending
+                && ASMAtomicCmpXchgBool(&pIoCtxParent->fComplete, true, false))
+            {
+                pIoCtxParent->Type.Root.pfnComplete(pIoCtxParent->Type.Root.pvUser1, pIoCtxParent->Type.Root.pvUser2);
+                vdIoCtxFree(pDisk, pIoCtxParent);
+            }
+        }
+        else
+            pIoCtx->Type.Root.pfnComplete(pIoCtx->Type.Root.pvUser1, pIoCtx->Type.Root.pvUser2);
+
         vdIoCtxFree(pDisk, pIoCtx);
     }
@@ -5534 +5583 @@
         pIoCtx = vdIoCtxRootAlloc(pDisk, VDIOCTXTXDIR_READ, uOffset,
                                   cbRead, paSeg, cSeg,
-                                  pfnComplete, pvUser1, pvUser2);
+                                  pfnComplete, pvUser1, pvUser2,
+                                  NULL);
         if (!pIoCtx)
         {
@@ -5614 +5664 @@
                            rc = VERR_INVALID_PARAMETER);
 
-        pIoCtx = vdIoCtxRootAlloc(pDisk, VDIOCTXTXDIR_READ, uOffset,
+        pIoCtx = vdIoCtxRootAlloc(pDisk, VDIOCTXTXDIR_WRITE, uOffset,
                                   cbWrite, paSeg, cSeg,
-                                  pfnComplete, pvUser1, pvUser2);
+                                  pfnComplete, pvUser1, pvUser2,
+                                  NULL);
         if (!pIoCtx)
         {

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

@@ -712 +712 @@
 {
     int rc;
-
-    if (uOpenFlags & VD_OPEN_FLAGS_ASYNC_IO)
-        return VERR_NOT_SUPPORTED;
 
     pImage->uOpenFlags = uOpenFlags;
@@ -1632 +1629 @@
     /* Image must be opened and the new flags must be valid. Just readonly and
      * info flags are supported. */
-    if (!pImage || (uOpenFlags & ~(VD_OPEN_FLAGS_READONLY | VD_OPEN_FLAGS_INFO)))
+    if (!pImage || (uOpenFlags & ~(VD_OPEN_FLAGS_READONLY | VD_OPEN_FLAGS_INFO | VD_OPEN_FLAGS_ASYNC_IO)))
     {
         rc = VERR_INVALID_PARAMETER;
@@ -2049 +2046 @@
 static bool vdiIsAsyncIOSupported(void *pBackendData)
 {
-#if 0
     return true;
-#else
-    return false;
-#endif
 }
 
@@ -2484 +2477 @@
     /* uBackendCaps */
       VD_CAP_UUID | VD_CAP_CREATE_FIXED | VD_CAP_CREATE_DYNAMIC
-    | VD_CAP_DIFF | VD_CAP_FILE
-#if 0
-    | VD_CAP_ASYNC
-#endif
-    ,
+    | VD_CAP_DIFF | VD_CAP_FILE | VD_CAP_ASYNC,
     /* papszFileExtensions */
     s_apszVdiFileExtensions,