Changeset 27977 in vbox for trunk/src

Timestamp:

Apr 4, 2010 7:21:59 PM (15 years ago)

Author:

vboxsync

Message:

VBoxHDD: Async I/O for flat images are back

Location:

trunk/src/VBox/Devices/Storage

Files:

• DrvSCSI.cpp (modified) (3 diffs)
• DrvVD.cpp (modified) (3 diffs)
• VBoxHDD.cpp (modified) (21 diffs)
• VDIHDDCore.cpp (modified) (2 diffs)
• VmdkHDDCore.cpp (modified) (3 diffs)

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

@@ -258 +258 @@
                                                              (PPDMDATASEG)paSeg, cSeg, cbTransfer,
                                                              hVScsiIoReq);
-                    if (RT_FAILURE(rc))
+                    if (RT_FAILURE(rc) && rc != VERR_VD_ASYNC_IO_IN_PROGRESS)
                         AssertMsgFailed(("%s: Failed to read data %Rrc\n", __FUNCTION__, rc));
                     STAM_REL_COUNTER_ADD(&pThis->StatBytesRead, cbTransfer);
@@ -268 +268 @@
                                                               (PPDMDATASEG)paSeg, cSeg, cbTransfer,
                                                               hVScsiIoReq);
-                    if (RT_FAILURE(rc))
+                    if (RT_FAILURE(rc) && rc != VERR_VD_ASYNC_IO_IN_PROGRESS)
                         AssertMsgFailed(("%s: Failed to write data %Rrc\n", __FUNCTION__, rc));
                     STAM_REL_COUNTER_ADD(&pThis->StatBytesWritten, cbTransfer);
@@ -284 +284 @@
                     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;

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

@@ -300 +300 @@
     else
     {
-        int rc = VINF_VD_ASYNC_IO_FINISHED;
-        void *pvCallerUser = NULL;
-
-        if (pStorageBackend->pfnCompleted)
-            rc = pStorageBackend->pfnCompleted(pvUser, &pvCallerUser);
-        else
-            pvCallerUser = pvUser;
+        int rc;
+
+        AssertPtr(pStorageBackend->pfnCompleted);
+        rc = pStorageBackend->pfnCompleted(pvUser);
+        AssertRC(rc);
 
         /* If thread synchronization is active, then signal the end of the
@@ -317 +315 @@
             AssertRC(rc2);
         }
-
-        if (rc == VINF_VD_ASYNC_IO_FINISHED)
-        {
-            rc = pThis->pDrvMediaAsyncPort->pfnTransferCompleteNotify(pThis->pDrvMediaAsyncPort, pvCallerUser);
-            AssertRC(rc);
-        }
-        else
-            AssertMsg(rc == VERR_VD_ASYNC_IO_IN_PROGRESS, ("Invalid return code from disk backend rc=%Rrc\n", rc));
     }
 }
@@ -1482 +1472 @@
     }
 
-#if 0 /* Temporary disabled. WIP */
-    if (pThis->pDrvMediaAsyncPort)
+    if (pThis->pDrvMediaAsyncPort && fUseNewIo)
         pThis->fAsyncIOSupported = true;
-#else
-    pThis->fAsyncIOSupported = false;
-#endif
 
     unsigned iImageIdx = 0;

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

@@ -49 +49 @@
 #define VD_MERGE_BUFFER_SIZE    (16 * _1M)
 
+/** Maximum number of segments in one I/O task. */
+#define VD_IO_TASK_SEGMENTS_MAX 64
+
 /**
  * VD async I/O interface storage descriptor.
@@ -152 +155 @@
     /** Memory cache for I/O contexts */
     RTMEMCACHE          hMemCacheIoCtx;
+    /** Memory cache for I/O tasks. */
+    RTMEMCACHE          hMemCacheIoTask;
 };
 
@@ -192 +197 @@
     /** User argument 1 passed on completion. */
     void                        *pvUser2;
+    /** Disk this is request is for. */
+    PVBOXHDD                     pDisk;
+    /** Return code. */
+    int                          rcReq;
     /** Transfer direction */
     VDIOCTXTXDIR                 enmTxDir;
@@ -208 +217 @@
     /** Number of bytes left in the current buffer. */
     size_t                       cbBufLeft;
+    /** How many meta data transfers are pending. */
+    volatile uint32_t            cMetaTransfersPending;
 } VDIOCTX;
+
+/**
+ * I/O task.
+ */
+typedef struct VDIOTASK
+{
+    /** Pointer to the I/O context the task belongs. */
+    PVDIOCTX                     pIoCtx;
+    /** Flag whether this is a meta data transfer. */
+    bool                         fMeta;
+    /** Type dependent data. */
+    union
+    {
+        /** User data transfer. */
+        struct
+        {
+            /** Number of bytes this task transfered. */
+            uint32_t             cbTransfer;
+        } User;
+        /** Meta data transfer. */
+        struct
+        {
+            /** Transfer direction (Read/Write) */
+            VDIOCTXTXDIR         enmTxDir;
+            /** Completion callback from the backend */
+            PFNVDMETACOMPLETED   pfnMetaComplete;
+            /** User data */
+            void                *pvMetaUser;
+        } Meta;
+    } Type;
+} VDIOTASK, *PVDIOTASK;
 
 /**
@@ -482 +524 @@
         pIoCtx->pvUser1        = pvUser1;
         pIoCtx->pvUser2        = pvUser2;
+        pIoCtx->pDisk          = pDisk;
         pIoCtx->enmTxDir       = enmTxDir;
         pIoCtx->cbTransferLeft = cbTransfer;
@@ -490 +533 @@
         pIoCtx->pbBuf          = (uint8_t *)pIoCtx->paDataSeg[0].pvSeg;
         pIoCtx->cbBufLeft      = pIoCtx->paDataSeg[0].cbSeg;
+        pIoCtx->cMetaTransfersPending = 0;
     }
 
@@ -495 +539 @@
 }
 
+static PVDIOTASK vdIoTaskUserAlloc(PVBOXHDD pDisk, PVDIOCTX pIoCtx, uint32_t cbTransfer)
+{
+    PVDIOTASK pIoTask = NULL;
+
+    pIoTask = (PVDIOTASK)RTMemCacheAlloc(pDisk->hMemCacheIoTask);
+    if (pIoTask)
+    {
+        pIoTask->pIoCtx               = pIoCtx;
+        pIoTask->fMeta                = false;
+        pIoTask->Type.User.cbTransfer = cbTransfer;
+    }
+
+    return pIoTask;
+}
+
+static PVDIOTASK vdIoTaskMetaAlloc(PVBOXHDD pDisk, PVDIOCTX pIoCtx, VDIOCTXTXDIR enmTxDir,
+                                   PFNVDMETACOMPLETED pfnMetaComplete, void *pvMetaUser)
+{
+    PVDIOTASK pIoTask = NULL;
+
+    pIoTask = (PVDIOTASK)RTMemCacheAlloc(pDisk->hMemCacheIoTask);
+    if (pIoTask)
+    {
+        pIoTask->pIoCtx                      = pIoCtx;
+        pIoTask->fMeta                       = true;
+        pIoTask->Type.Meta.enmTxDir          = enmTxDir;
+        pIoTask->Type.Meta.pfnMetaComplete   = pfnMetaComplete;
+        pIoTask->Type.Meta.pvMetaUser        = pvMetaUser;
+    }
+
+    return pIoTask;
+}
+
 static void vdIoCtxFree(PVBOXHDD pDisk, PVDIOCTX pIoCtx)
 {
     RTMemCacheFree(pDisk->hMemCacheIoCtx, pIoCtx);
+}
+
+static void vdIoTaskFree(PVBOXHDD pDisk, PVDIOTASK pIoTask)
+{
+    pIoTask->pIoCtx = NULL;
+    RTMemCacheFree(pDisk->hMemCacheIoTask, pIoTask);
 }
 
@@ -932 +1015 @@
 }
 
+/**
+ * internal: write buffer to the image, taking care of block boundaries and
+ * write optimizations - async version.
+ */
+static int vdWriteHelperAsync(PVBOXHDD pDisk, PVDIMAGE pImage, PVDIMAGE pImageParentOverride,
+                              PVDIOCTX pIoCtx, uint64_t uOffset, size_t cbWrite)
+{
+    int rc;
+    unsigned fWrite;
+    size_t cbThisWrite;
+    size_t cbPreRead, cbPostRead;
+
+    /* Loop until all written. */
+    do
+    {
+        /* Try to write the possibly partial block to the last opened image.
+         * This works when the block is already allocated in this image or
+         * if it is a full-block write (and allocation isn't suppressed below).
+         * For image formats which don't support zero blocks, it's beneficial
+         * to avoid unnecessarily allocating unchanged blocks. This prevents
+         * unwanted expanding of images. VMDK is an example. */
+        cbThisWrite = cbWrite;
+        fWrite =   (pImage->uOpenFlags & VD_OPEN_FLAGS_HONOR_SAME)
+                 ? 0 : VD_WRITE_NO_ALLOC;
+        rc = pImage->Backend->pfnAsyncWrite(pImage->pvBackendData, uOffset,
+                                            cbThisWrite, pIoCtx,
+                                            &cbThisWrite, &cbPreRead,
+                                            &cbPostRead, fWrite);
+#if 0
+        if (rc == VERR_VD_BLOCK_FREE)
+        {
+            void *pvTmp = RTMemTmpAlloc(cbPreRead + cbThisWrite + cbPostRead);
+            AssertBreakStmt(VALID_PTR(pvTmp), rc = VERR_NO_MEMORY);
+
+            if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_HONOR_SAME))
+            {
+                /* Optimized write, suppress writing to a so far unallocated
+                 * block if the data is in fact not changed. */
+                rc = vdWriteHelperOptimized(pDisk, pImage, pImageParentOverride,
+                                            uOffset, cbWrite,
+                                            cbThisWrite, cbPreRead, cbPostRead,
+                                            pvBuf, pvTmp);
+            }
+            else
+            {
+                /* Normal write, not optimized in any way. The block will
+                 * be written no matter what. This will usually (unless the
+                 * backend has some further optimization enabled) cause the
+                 * block to be allocated. */
+                rc = vdWriteHelperStandard(pDisk, pImage, pImageParentOverride,
+                                           uOffset, cbWrite,
+                                           cbThisWrite, cbPreRead, cbPostRead,
+                                           pvBuf, pvTmp);
+            }
+            RTMemTmpFree(pvTmp);
+            if (RT_FAILURE(rc))
+                break;
+        }
+#endif
+
+        if (RT_SUCCESS(rc))
+        {
+            /* Success and no async task is pending. */
+            Assert(rc == VINF_SUCCESS);
+            ASMAtomicSubU32(&pIoCtx->cbTransferLeft, cbThisWrite);
+        }
+
+        cbWrite -= cbThisWrite;
+        uOffset += cbThisWrite;
+    } while (cbWrite != 0 && (   RT_SUCCESS(rc)
+                              || rc == VERR_VD_ASYNC_IO_IN_PROGRESS));
+
+    return rc;
+}
 
 /**
@@ -1183 +1340 @@
 }
 
-static int vdIOReqCompleted(void *pvUser, void **ppvCaller)
-{
+static int vdIOReqCompleted(void *pvUser)
+{
+    PVDIOTASK pIoTask = (PVDIOTASK)pvUser;
+    PVDIOCTX  pIoCtx  = pIoTask->pIoCtx;
+    PVBOXHDD  pDisk   = pIoCtx->pDisk;
+    uint32_t  cbLeft  = ASMAtomicSubU32(&pIoCtx->cbTransferLeft, pIoTask->Type.User.cbTransfer);
+
+    Assert(!pIoTask->fMeta); /* No meta tasks spawned at the moment. */
+
+    if (cbLeft == pIoTask->Type.User.cbTransfer)
+    {
+        vdIoTaskFree(pDisk, pIoTask);
+        pIoCtx->pfnComplete(pIoCtx->pvUser1, pIoCtx->pvUser2);
+        vdIoCtxFree(pDisk, pIoCtx);
+    }
+    else
+        vdIoTaskFree(pDisk, pIoTask);
+
     return VINF_SUCCESS;
 }
@@ -1280 +1453 @@
                              size_t cbRead)
 {
-    return VERR_NOT_IMPLEMENTED;
+    int rc = VINF_SUCCESS;
+    PVBOXHDD pDisk = (PVBOXHDD)pvUser;
+
+    /* Build the S/G array and spawn a new I/O task */
+    while (cbRead)
+    {
+        PDMDATASEG  aSeg[VD_IO_TASK_SEGMENTS_MAX];
+        unsigned    cSegments  = 0;
+        unsigned    cbTaskRead = 0;
+
+        while (   cbRead
+               && cSegments < VD_IO_TASK_SEGMENTS_MAX)
+        {
+
+            size_t      cbThisSeg = cbRead;
+            uint8_t    *pbBuf     = NULL;
+
+            pbBuf = vdIoCtxGetBuffer(pIoCtx, &cbThisSeg);
+
+            aSeg[cSegments].cbSeg = cbThisSeg;
+            aSeg[cSegments].pvSeg = pbBuf;
+            cSegments++;
+            cbRead     -= cbThisSeg;
+            cbTaskRead += cbThisSeg;
+        }
+
+        PVDIOTASK pIoTask = vdIoTaskUserAlloc(pDisk, pIoCtx, cbTaskRead);
+
+        if (!pIoTask)
+            return VERR_NO_MEMORY;
+
+        void *pvTask;
+        int rc2 = pDisk->pInterfaceAsyncIOCallbacks->pfnReadAsync(pDisk->pInterfaceAsyncIO->pvUser,
+                                                                  pIoStorage->u.pStorage,
+                                                                  uOffset, aSeg, cSegments,
+                                                                  cbTaskRead, pIoTask,
+                                                                  &pvTask);
+        if (rc2 == VINF_SUCCESS)
+            vdIoTaskFree(pDisk, pIoTask);
+        else if (rc2 == VERR_VD_ASYNC_IO_IN_PROGRESS)
+            rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
+        else if (RT_FAILURE(rc2))
+            rc = rc2;
+
+        uOffset += cbTaskRead;
+    }
+
+    return rc;
 }
 
@@ -1287 +1507 @@
                               size_t cbWrite)
 {
-    return VERR_NOT_IMPLEMENTED;
+    int rc = VINF_SUCCESS;
+    PVBOXHDD pDisk = (PVBOXHDD)pvUser;
+
+    /* Build the S/G array and spawn a new I/O task */
+    while (cbWrite)
+    {
+        PDMDATASEG  aSeg[VD_IO_TASK_SEGMENTS_MAX];
+        unsigned    cSegments   = 0;
+        unsigned    cbTaskWrite = 0;
+
+        while (   cbWrite
+               && cSegments < VD_IO_TASK_SEGMENTS_MAX)
+        {
+
+            size_t      cbThisSeg = cbWrite;
+            uint8_t    *pbBuf     = NULL;
+
+            pbBuf = vdIoCtxGetBuffer(pIoCtx, &cbThisSeg);
+
+            aSeg[cSegments].cbSeg = cbThisSeg;
+            aSeg[cSegments].pvSeg = pbBuf;
+            cSegments++;
+            cbWrite     -= cbThisSeg;
+            cbTaskWrite += cbThisSeg;
+        }
+
+        PVDIOTASK pIoTask = vdIoTaskUserAlloc(pDisk, pIoCtx, cbTaskWrite);
+
+        if (!pIoTask)
+            return VERR_NO_MEMORY;
+
+        void *pvTask;
+        int rc2 = pDisk->pInterfaceAsyncIOCallbacks->pfnWriteAsync(pDisk->pInterfaceAsyncIO->pvUser,
+                                                                   pIoStorage->u.pStorage,
+                                                                   uOffset, aSeg, cSegments,
+                                                                   cbTaskWrite, pIoTask,
+                                                                   &pvTask);
+        if (rc2 == VINF_SUCCESS)
+            vdIoTaskFree(pDisk, pIoTask);
+        else if (rc2 == VERR_VD_ASYNC_IO_IN_PROGRESS)
+            rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
+        else if (RT_FAILURE(rc2))
+            rc = rc2;
+
+        uOffset += cbTaskWrite;
+    }
+
+    return rc;
 }
 
@@ -1585 +1852 @@
             pDisk->pInterfaceThreadSyncCallbacks = NULL;
 
-            /* Create the mem cache */
+            /* Create the I/O ctx cache */
             rc = RTMemCacheCreate(&pDisk->hMemCacheIoCtx, sizeof(VDIOCTX), 0, UINT32_MAX,
                                   NULL, NULL, NULL, 0);
@@ -1593 +1860 @@
                 break;
             }
+
+            /* Create the I/O task cache */
+            rc = RTMemCacheCreate(&pDisk->hMemCacheIoTask, sizeof(VDIOTASK), 0, UINT32_MAX,
+                                  NULL, NULL, NULL, 0);
+            if (RT_FAILURE(rc))
+            {
+                RTMemCacheDestroy(pDisk->hMemCacheIoCtx);
+                RTMemFree(pDisk);
+                break;
+            }
+
 
             pDisk->pInterfaceError = VDInterfaceGet(pVDIfsDisk, VDINTERFACETYPE_ERROR);
@@ -1683 +1961 @@
         VDCloseAll(pDisk);
         RTMemCacheDestroy(pDisk->hMemCacheIoCtx);
+        RTMemCacheDestroy(pDisk->hMemCacheIoTask);
         RTMemFree(pDisk);
     } while (0);
@@ -4975 +5254 @@
     int rc2;
     bool fLockRead = false;
+    PVDIOCTX pIoCtx;
 
     LogFlowFunc(("pDisk=%#p uOffset=%llu paSeg=%p cSeg=%u cbRead=%zu\n",
@@ -5004 +5284 @@
                            rc = VERR_INVALID_PARAMETER);
 
-        PVDIOCTX pIoCtx = vdIoCtxAlloc(pDisk, VDIOCTXTXDIR_READ, uOffset,
-                                       cbRead, paSeg, cSeg,
-                                       pfnComplete, pvUser1, pvUser2);
+        pIoCtx = vdIoCtxAlloc(pDisk, VDIOCTXTXDIR_READ, uOffset,
+                              cbRead, paSeg, cSeg,
+                              pfnComplete, pvUser1, pvUser2);
         if (!pIoCtx)
         {
@@ -5026 +5306 @@
 
     if (rc == VINF_SUCCESS)
+    {
+        vdIoCtxFree(pDisk, pIoCtx);
         rc = VINF_VD_ASYNC_IO_FINISHED;
+    }
 
     LogFlowFunc(("returns %Rrc\n", rc));
@@ -5041 +5324 @@
     int rc2;
     bool fLockWrite = false;
+    PVDIOCTX pIoCtx;
 
     LogFlowFunc(("pDisk=%#p uOffset=%llu paSeg=%p cSeg=%u cbWrite=%zu\n",
@@ -5060 +5344 @@
                            ("cSeg=%zu\n", cSeg),
                            rc = VERR_INVALID_PARAMETER);
-#if 0
+
         rc2 = vdThreadStartWrite(pDisk);
         AssertRC(rc2);
@@ -5070 +5354 @@
                            rc = VERR_INVALID_PARAMETER);
 
+        pIoCtx = vdIoCtxAlloc(pDisk, VDIOCTXTXDIR_READ, uOffset,
+                              cbWrite, paSeg, cSeg,
+                              pfnComplete, pvUser1, pvUser2);
+        if (!pIoCtx)
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+
         PVDIMAGE pImage = pDisk->pLast;
         AssertPtrBreakStmt(pImage, rc = VERR_VD_NOT_OPENED);
 
-        vdSetModifiedFlag(pDisk);
-        rc = pImage->Backend->pfnAsyncWrite(pImage->pvBackendData,
-                                            uOffset, cbWrite,
-                                            paSeg, cSeg, pvUser);
-#endif
+        rc = vdWriteHelperAsync(pDisk, pImage, NULL, pIoCtx, uOffset, cbWrite);
+
     } while (0);
 
@@ -5087 +5377 @@
 
     if (rc == VINF_SUCCESS)
+    {
+        vdIoCtxFree(pDisk, pIoCtx);
         rc = VINF_VD_ASYNC_IO_FINISHED;
+    }
 
     LogFlowFunc(("returns %Rrc\n", rc));

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

@@ -1976 +1976 @@
 static bool vdiIsAsyncIOSupported(void *pBackendData)
 {
+#if 0
+    return true;
+#else
     return false;
-}
-
-static int vdiAsyncRead(void *pvBackendData, uint64_t uOffset, size_t cbRead,
+#endif
+}
+
+static int vdiAsyncRead(void *pvBackendData, uint64_t uOffset, size_t cbToRead,
                         PVDIOCTX pIoCtx, size_t *pcbActuallyRead)
 {
-    int rc = VERR_NOT_IMPLEMENTED;
+    LogFlowFunc(("pvBackendData=%#p uOffset=%llu pIoCtx=%#p cbToRead=%zu pcbActuallyRead=%#p\n",
+                 pvBackendData, uOffset, pIoCtx, cbToRead, pcbActuallyRead));
+    PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pvBackendData;
+    unsigned uBlock;
+    unsigned offRead;
+    int rc;
+
+    AssertPtr(pImage);
+    Assert(!(uOffset % 512));
+    Assert(!(cbToRead % 512));
+
+    if (   uOffset + cbToRead > getImageDiskSize(&pImage->Header)
+        || !VALID_PTR(pIoCtx)
+        || !cbToRead)
+    {
+        rc = VERR_INVALID_PARAMETER;
+        goto out;
+    }
+
+    /* Calculate starting block number and offset inside it. */
+    uBlock = (unsigned)(uOffset >> pImage->uShiftOffset2Index);
+    offRead = (unsigned)uOffset & pImage->uBlockMask;
+
+    /* Clip read range to at most the rest of the block. */
+    cbToRead = RT_MIN(cbToRead, getImageBlockSize(&pImage->Header) - offRead);
+    Assert(!(cbToRead % 512));
+
+    if (pImage->paBlocks[uBlock] == VDI_IMAGE_BLOCK_FREE)
+        rc = VERR_VD_BLOCK_FREE;
+    else if (pImage->paBlocks[uBlock] == VDI_IMAGE_BLOCK_ZERO)
+    {
+        size_t cbSet;
+
+        cbSet = pImage->pInterfaceIOCallbacks->pfnIoCtxSet(pImage->pInterfaceIO->pvUser,
+                                                           pIoCtx, 0, cbToRead);
+        Assert(cbSet == cbToRead);
+
+        rc = VINF_SUCCESS;
+    }
+    else
+    {
+        /* Block present in image file, read relevant data. */
+        uint64_t u64Offset = (uint64_t)pImage->paBlocks[uBlock] * pImage->cbTotalBlockData
+                           + (pImage->offStartData + pImage->offStartBlockData + offRead);
+        rc = pImage->pInterfaceIOCallbacks->pfnReadUserAsync(pImage->pInterfaceIO->pvUser,
+                                                             pImage->pStorage,
+                                                             u64Offset,
+                                                             pIoCtx, cbToRead);
+    }
+
+    if (pcbActuallyRead)
+        *pcbActuallyRead = cbToRead;
+
+out:
     LogFlowFunc(("returns %Rrc\n", rc));
     return rc;
 }
 
-static int vdiAsyncWrite(void *pvBackendData, uint64_t uOffset, size_t cbWrite,
+static int vdiAsyncWrite(void *pvBackendData, uint64_t uOffset, size_t cbToWrite,
                          PVDIOCTX pIoCtx,
                          size_t *pcbWriteProcess, size_t *pcbPreRead,
                          size_t *pcbPostRead, unsigned fWrite)
 {
-    int rc = VERR_NOT_IMPLEMENTED;
+    LogFlowFunc(("pvBackendData=%#p uOffset=%llu pIoCtx=%#p cbToWrite=%zu pcbWriteProcess=%#p pcbPreRead=%#p pcbPostRead=%#p\n",
+                 pvBackendData, uOffset, pIoCtx, cbToWrite, pcbWriteProcess, pcbPreRead, pcbPostRead));
+    PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pvBackendData;
+    unsigned uBlock;
+    unsigned offWrite;
+    int rc = VINF_SUCCESS;
+
+    AssertPtr(pImage);
+    Assert(!(uOffset % 512));
+    Assert(!(cbToWrite % 512));
+
+    if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
+    {
+        rc = VERR_VD_IMAGE_READ_ONLY;
+        goto out;
+    }
+
+    if (!VALID_PTR(pIoCtx) || !cbToWrite)
+    {
+        rc = VERR_INVALID_PARAMETER;
+        goto out;
+    }
+
+    /* No size check here, will do that later.  For dynamic images which are
+     * not multiples of the block size in length, this would prevent writing to
+     * the last grain. */
+
+    /* Calculate starting block number and offset inside it. */
+    uBlock = (unsigned)(uOffset >> pImage->uShiftOffset2Index);
+    offWrite = (unsigned)uOffset & pImage->uBlockMask;
+
+    /* Clip write range to at most the rest of the block. */
+    cbToWrite = RT_MIN(cbToWrite, getImageBlockSize(&pImage->Header) - offWrite);
+    Assert(!(cbToWrite % 512));
+
+    do
+    {
+        if (!IS_VDI_IMAGE_BLOCK_ALLOCATED(pImage->paBlocks[uBlock]))
+        {
+            /* Block is either free or zero. */
+            if (   !(pImage->uOpenFlags & VD_OPEN_FLAGS_HONOR_ZEROES)
+                && (   pImage->paBlocks[uBlock] == VDI_IMAGE_BLOCK_ZERO
+                    || cbToWrite == getImageBlockSize(&pImage->Header)))
+            {
+#if 0 /** @todo Provide interface to check an I/O context for a specific value */
+                /* If the destination block is unallocated at this point, it's
+                 * either a zero block or a block which hasn't been used so far
+                 * (which also means that it's a zero block. Don't need to write
+                 * anything to this block  if the data consists of just zeroes. */
+                Assert(!(cbToWrite % 4));
+                Assert(cbToWrite * 8 <= UINT32_MAX);
+                if (ASMBitFirstSet((volatile void *)pvBuf, (uint32_t)cbToWrite * 8) == -1)
+                {
+                    pImage->paBlocks[uBlock] = VDI_IMAGE_BLOCK_ZERO;
+                    break;
+                }
+#endif
+            }
+
+            if (cbToWrite == getImageBlockSize(&pImage->Header))
+            {
+                /* Full block write to previously unallocated block.
+                 * Allocate block and write data. */
+                Assert(!offWrite);
+                unsigned cBlocksAllocated = getImageBlocksAllocated(&pImage->Header);
+                uint64_t u64Offset = (uint64_t)cBlocksAllocated * pImage->cbTotalBlockData
+                                   + (pImage->offStartData + pImage->offStartBlockData);
+                rc = pImage->pInterfaceIOCallbacks->pfnWriteUserAsync(pImage->pInterfaceIO->pvUser,
+                                                                      pImage->pStorage,
+                                                                      u64Offset,
+                                                                      pIoCtx, cbToWrite);
+                if (RT_UNLIKELY(RT_FAILURE_NP(rc) && (rc != VERR_VD_ASYNC_IO_IN_PROGRESS)))
+                    goto out;
+                pImage->paBlocks[uBlock] = cBlocksAllocated;
+                setImageBlocksAllocated(&pImage->Header, cBlocksAllocated + 1);
+
+                /** @todo Async */
+                rc = vdiUpdateBlockInfo(pImage, uBlock);
+                if (RT_FAILURE(rc))
+                    goto out;
+
+                *pcbPreRead = 0;
+                *pcbPostRead = 0;
+            }
+            else
+            {
+                /* Trying to do a partial write to an unallocated block. Don't do
+                 * anything except letting the upper layer know what to do. */
+                *pcbPreRead = offWrite % getImageBlockSize(&pImage->Header);
+                *pcbPostRead = getImageBlockSize(&pImage->Header) - cbToWrite - *pcbPreRead;
+                rc = VERR_VD_BLOCK_FREE;
+            }
+        }
+        else
+        {
+            /* Block present in image file, write relevant data. */
+            uint64_t u64Offset = (uint64_t)pImage->paBlocks[uBlock] * pImage->cbTotalBlockData
+                               + (pImage->offStartData + pImage->offStartBlockData + offWrite);
+            rc = pImage->pInterfaceIOCallbacks->pfnWriteUserAsync(pImage->pInterfaceIO->pvUser,
+                                                                  pImage->pStorage,
+                                                                  u64Offset,
+                                                                  pIoCtx, cbToWrite);
+        }
+    } while (0);
+
+    if (pcbWriteProcess)
+        *pcbWriteProcess = cbToWrite;
+
+out:
     LogFlowFunc(("returns %Rrc\n", rc));
     return rc;
@@ -2247 +2412 @@
     /* uBackendCaps */
       VD_CAP_UUID | VD_CAP_CREATE_FIXED | VD_CAP_CREATE_DYNAMIC
-    | VD_CAP_DIFF | VD_CAP_FILE,
+    | VD_CAP_DIFF | VD_CAP_FILE
+#if 0
+    | VD_CAP_ASYNC
+#endif
+    ,
     /* papszFileExtensions */
     s_apszVdiFileExtensions,

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

@@ -5856 +5856 @@
 static bool vmdkIsAsyncIOSupported(void *pvBackendData)
 {
-    return false;
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pvBackendData;
+    bool fAsyncIOSupported = false;
+
+    if (pImage)
+    {
+        fAsyncIOSupported = true;
+        for (unsigned i = 0; i < pImage->cExtents; i++)
+        {
+            if  (    pImage->pExtents[i].enmType != VMDKETYPE_FLAT
+                 &&  pImage->pExtents[i].enmType != VMDKETYPE_ZERO)
+            {
+                fAsyncIOSupported = false;
+                break; /* Stop search */
+            }
+        }
+    }
+
+    return fAsyncIOSupported;
 }
 
@@ -5862 +5879 @@
                          PVDIOCTX pIoCtx, size_t *pcbActuallyRead)
 {
-    int rc = VERR_NOT_IMPLEMENTED;
+    LogFlowFunc(("pvBackendData=%#p uOffset=%llu pIoCtx=%#p cbToRead=%zu pcbActuallyRead=%#p\n",
+                 pvBackendData, uOffset, pIoCtx, cbRead, pcbActuallyRead));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pvBackendData;
+    PVMDKEXTENT pExtent;
+    uint64_t uSectorExtentRel;
+    uint64_t uSectorExtentAbs;
+    int rc;
+
+    AssertPtr(pImage);
+    Assert(uOffset % 512 == 0);
+    Assert(cbRead % 512 == 0);
+
+    if (   uOffset + cbRead > pImage->cbSize
+        || cbRead == 0)
+    {
+        rc = VERR_INVALID_PARAMETER;
+        goto out;
+    }
+
+    rc = vmdkFindExtent(pImage, VMDK_BYTE2SECTOR(uOffset),
+                        &pExtent, &uSectorExtentRel);
+    if (RT_FAILURE(rc))
+        goto out;
+
+    /* Check access permissions as defined in the extent descriptor. */
+    if (pExtent->enmAccess == VMDKACCESS_NOACCESS)
+    {
+        rc = VERR_VD_VMDK_INVALID_STATE;
+        goto out;
+    }
+
+    /* Clip read range to remain in this extent. */
+    cbRead = RT_MIN(cbRead, VMDK_SECTOR2BYTE(pExtent->uSectorOffset + pExtent->cNominalSectors - uSectorExtentRel));
+
+    /* Handle the read according to the current extent type. */
+    switch (pExtent->enmType)
+    {
+        case VMDKETYPE_HOSTED_SPARSE:
+#ifdef VBOX_WITH_VMDK_ESX
+        case VMDKETYPE_ESX_SPARSE:
+#endif /* VBOX_WITH_VMDK_ESX */
+            AssertMsgFailed(("Not supported\n"));
+            break;
+        case VMDKETYPE_VMFS:
+        case VMDKETYPE_FLAT:
+            rc = pImage->pInterfaceIOCallbacks->pfnReadUserAsync(pImage->pInterfaceIO->pvUser,
+                                                                 pExtent->pFile->pStorage,
+                                                                 VMDK_SECTOR2BYTE(uSectorExtentRel),
+                                                                 pIoCtx, cbRead);
+            break;
+        case VMDKETYPE_ZERO:
+            size_t cbSet;
+
+            cbSet = pImage->pInterfaceIOCallbacks->pfnIoCtxSet(pImage->pInterfaceIO->pvUser,
+                                                               pIoCtx, 0, cbRead);
+            Assert(cbSet == cbRead);
+
+            rc = VINF_SUCCESS;
+            break;
+    }
+    if (pcbActuallyRead)
+        *pcbActuallyRead = cbRead;
+
+out:
     LogFlowFunc(("returns %Rrc\n", rc));
     return rc;
@@ -5872 +5952 @@
                           size_t *pcbPostRead, unsigned fWrite)
 {
-    int rc = VERR_NOT_IMPLEMENTED;
+    LogFlowFunc(("pvBackendData=%#p uOffset=%llu pIoCtx=%#p cbToWrite=%zu pcbWriteProcess=%#p pcbPreRead=%#p pcbPostRead=%#p\n",
+                 pvBackendData, uOffset, pIoCtx, cbWrite, pcbWriteProcess, pcbPreRead, pcbPostRead));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pvBackendData;
+    PVMDKEXTENT pExtent;
+    uint64_t uSectorExtentRel;
+    uint64_t uSectorExtentAbs;
+    int rc;
+
+    AssertPtr(pImage);
+    Assert(uOffset % 512 == 0);
+    Assert(cbWrite % 512 == 0);
+
+    if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
+    {
+        rc = VERR_VD_IMAGE_READ_ONLY;
+        goto out;
+    }
+
+    if (cbWrite == 0)
+    {
+        rc = VERR_INVALID_PARAMETER;
+        goto out;
+    }
+
+    /* No size check here, will do that later when the extent is located.
+     * There are sparse images out there which according to the spec are
+     * invalid, because the total size is not a multiple of the grain size.
+     * Also for sparse images which are stitched together in odd ways (not at
+     * grain boundaries, and with the nominal size not being a multiple of the
+     * grain size), this would prevent writing to the last grain. */
+
+    rc = vmdkFindExtent(pImage, VMDK_BYTE2SECTOR(uOffset),
+                        &pExtent, &uSectorExtentRel);
+    if (RT_FAILURE(rc))
+        goto out;
+
+    /* Check access permissions as defined in the extent descriptor. */
+    if (pExtent->enmAccess != VMDKACCESS_READWRITE)
+    {
+        rc = VERR_VD_VMDK_INVALID_STATE;
+        goto out;
+    }
+
+    /* Handle the write according to the current extent type. */
+    switch (pExtent->enmType)
+    {
+        case VMDKETYPE_HOSTED_SPARSE:
+#ifdef VBOX_WITH_VMDK_ESX
+        case VMDKETYPE_ESX_SPARSE:
+#endif /* VBOX_WITH_VMDK_ESX */
+            AssertMsgFailed(("Not supported\n"));
+            break;
+        case VMDKETYPE_VMFS:
+        case VMDKETYPE_FLAT:
+            /* Clip write range to remain in this extent. */
+            cbWrite = RT_MIN(cbWrite, VMDK_SECTOR2BYTE(pExtent->uSectorOffset + pExtent->cNominalSectors - uSectorExtentRel));
+            rc = pImage->pInterfaceIOCallbacks->pfnWriteUserAsync(pImage->pInterfaceIO->pvUser,
+                                                                  pExtent->pFile->pStorage,
+                                                                  VMDK_SECTOR2BYTE(uSectorExtentRel),
+                                                                  pIoCtx, cbWrite);
+            break;
+        case VMDKETYPE_ZERO:
+            /* Clip write range to remain in this extent. */
+            cbWrite = RT_MIN(cbWrite, VMDK_SECTOR2BYTE(pExtent->uSectorOffset + pExtent->cNominalSectors - uSectorExtentRel));
+            break;
+    }
+    if (pcbWriteProcess)
+        *pcbWriteProcess = cbWrite;
+
+out:
     LogFlowFunc(("returns %Rrc\n", rc));
     return rc;