Changeset 6312 in vbox for trunk/src/VBox

Timestamp:

Jan 9, 2008 10:25:55 PM (17 years ago)

Author:

vboxsync

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

27189

Message:

remove functions from PDMIMEDIAASYNC and PCMIBLOCKASYNC. PDMIMEDIA and PDMIBLOCK are mandatory now and the async versions are optional extensions which can be implemented. Removed duplicated code

File:

• trunk/src/VBox/Devices/Storage/DrvBlock.cpp (modified) (12 diffs)

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

@@ -95 +95 @@
     PDMIMOUNT               IMount;
 
+    /** Pointer to the async media driver below us.
+     * This is NULL if the media is not mounted. */
+    PPDMIMEDIAASYNC         pDrvMediaAsync;
+    /** Our media async port. */
+    PDMIMEDIAASYNCPORT      IMediaAsyncPort;
+    /** Pointer to the async block port interface above us. */
+    PPDMIBLOCKASYNCPORT     pDrvBlockAsyncPort;
+    /** Our async block interface. */
+    PDMIBLOCKASYNC          IBlockAsync;
+
     /** Uuid of the drive. */
     RTUUID                  Uuid;
@@ -109 +119 @@
 /** Makes a PDRVBLOCK out of a PPDMIBLOCK. */
 #define PDMIBLOCK_2_DRVBLOCK(pInterface)        ( (PDRVBLOCK)((uintptr_t)pInterface - RT_OFFSETOF(DRVBLOCK, IBlock)) )
-
 
 /** @copydoc PDMIBLOCK::pfnRead */
@@ -241 +250 @@
 }
 
+/* -=-=-=-=- IBlockAsync -=-=-=-=- */
+
+/** Makes a PDRVBLOCK out of a PPDMIBLOCKASYNC. */
+#define PDMIBLOCKASYNC_2_DRVBLOCK(pInterface)        ( (PDRVBLOCK)((uintptr_t)pInterface - RT_OFFSETOF(DRVBLOCK, IBlockAsync)) )
+
+/** @copydoc PDMIBLOCKASYNC::pfnRead */
+static DECLCALLBACK(int) drvblockAsyncReadStart(PPDMIBLOCKASYNC pInterface, uint64_t off, void *pvBuf, size_t cbRead, void *pvUser)
+{
+    PDRVBLOCK pData = PDMIBLOCKASYNC_2_DRVBLOCK(pInterface);
+
+    /*
+     * Check the state.
+     */
+    if (!pData->pDrvMediaAsync)
+    {
+        AssertMsgFailed(("Invalid state! Not mounted!\n"));
+        return VERR_PDM_MEDIA_NOT_MOUNTED;
+    }
+
+    int rc = pData->pDrvMediaAsync->pfnStartRead(pData->pDrvMediaAsync, off, pvBuf, cbRead, pvUser);
+    return rc;
+}
+
+
+/** @copydoc PDMIBLOCKASYNC::pfnWrite */
+static DECLCALLBACK(int) drvblockAsyncWriteStart(PPDMIBLOCKASYNC pInterface, uint64_t off, const void *pvBuf, size_t cbWrite, void *pvUser)
+{
+    PDRVBLOCK pData = PDMIBLOCKASYNC_2_DRVBLOCK(pInterface);
+
+    /*
+     * Check the state.
+     */
+    if (!pData->pDrvMediaAsync)
+    {
+        AssertMsgFailed(("Invalid state! Not mounted!\n"));
+        return VERR_PDM_MEDIA_NOT_MOUNTED;
+    }
+
+    int rc = pData->pDrvMediaAsync->pfnStartWrite(pData->pDrvMediaAsync, off, pvBuf, cbWrite, pvUser);
+
+    return rc;
+}
+
+/* -=-=-=-=- IMediaAsyncPort -=-=-=-=- */
+
+/** Makes a PDRVBLOCKASYNC out of a PPDMIMEDIAASYNCPORT. */
+#define PDMIMEDIAASYNCPORT_2_DRVBLOCK(pInterface)    ( (PDRVBLOCK((uintptr_t)pInterface - RT_OFFSETOF(DRVBLOCK, IMediaAsyncPort))) )
+
+
+static DECLCALLBACK(int) drvblockAsyncReadCompleteNotify(PPDMIMEDIAASYNCPORT pInterface, uint64_t uOffset, void *pvBuf, size_t cbRead, void *pvUser)
+{
+    PDRVBLOCK pData = PDMIMEDIAASYNCPORT_2_DRVBLOCK(pInterface);
+
+    return pData->pDrvBlockAsyncPort->pfnReadCompleteNotify(pData->pDrvBlockAsyncPort, uOffset, pvBuf, cbRead, pvUser);
+}
+
+static DECLCALLBACK(int) drvblockAsyncWriteCompleteNotify(PPDMIMEDIAASYNCPORT pInterface, uint64_t uOffset, void *pvBuf, size_t cbWritten, void *pvUser)
+{
+    PDRVBLOCK pData = PDMIMEDIAASYNCPORT_2_DRVBLOCK(pInterface);
+
+#ifdef VBOX_PERIODIC_FLUSH
+    if (pData->cbFlushInterval)
+    {
+        pData->cbDataWritten += cbWritten;
+        if (pData->cbDataWritten > pData->cbFlushInterval)
+        {
+            pData->cbDataWritten = 0;
+            pData->pDrvMedia->pfnFlush(pData->pDrvMedia);
+        }
+    }
+#endif /* VBOX_PERIODIC_FLUSH */
+
+    return pData->pDrvBlockAsyncPort->pfnWriteCompleteNotify(pData->pDrvBlockAsyncPort, uOffset, pvBuf, cbWritten, pvUser);
+}
 
 /* -=-=-=-=- IBlockBios -=-=-=-=- */
@@ -275 +358 @@
      */
     int rc = pData->pDrvMedia->pfnBiosGetPCHSGeometry(pData->pDrvMedia, &pData->PCHSGeometry);
+
     if (VBOX_SUCCESS(rc))
     {
@@ -308 +392 @@
      */
     int rc = pData->pDrvMedia->pfnBiosSetPCHSGeometry(pData->pDrvMedia, pPCHSGeometry);
+
     if (    VBOX_SUCCESS(rc)
         ||  rc == VERR_NOT_IMPLEMENTED)
@@ -345 +430 @@
      */
     int rc = pData->pDrvMedia->pfnBiosGetLCHSGeometry(pData->pDrvMedia, &pData->LCHSGeometry);
+
     if (VBOX_SUCCESS(rc))
     {
@@ -378 +464 @@
      */
     int rc = pData->pDrvMedia->pfnBiosSetLCHSGeometry(pData->pDrvMedia, pLCHSGeometry);
+
     if (    VBOX_SUCCESS(rc)
         ||  rc == VERR_NOT_IMPLEMENTED)
@@ -584 +671 @@
         case PDMINTERFACE_MOUNT:
             return pData->fMountable ? &pData->IMount : NULL;
+        case PDMINTERFACE_BLOCK_ASYNC:
+            return pData->pDrvMediaAsync ? &pData->IBlockAsync : NULL;
+        case PDMINTERFACE_MEDIA_ASYNC_PORT:
+            return &pData->IMediaAsyncPort;
         default:
             return NULL;
@@ -597 +688 @@
     PDRVBLOCK pData = PDMINS2DATA(pDrvIns, PDRVBLOCK);
     pData->pDrvMedia = NULL;
+    pData->pDrvMediaAsync = NULL;
 }
 
@@ -658 +750 @@
     pData->IMount.pfnIsLocked               = drvblockIsLocked;
 
+    /* IBlockAsync. */
+    pData->IBlockAsync.pfnStartRead         = drvblockAsyncReadStart;
+    pData->IBlockAsync.pfnStartWrite        = drvblockAsyncWriteStart;
+
+    /* IMediaAsyncPort. */
+    pData->IMediaAsyncPort.pfnReadCompleteNotify  = drvblockAsyncReadCompleteNotify;
+    pData->IMediaAsyncPort.pfnWriteCompleteNotify = drvblockAsyncWriteCompleteNotify;
+
     /*
      * Get the IBlockPort & IMountNotify interfaces of the above driver/device.
@@ -667 +767 @@
         return VERR_PDM_MISSING_INTERFACE_ABOVE;
     }
+
+    /* Try to get the optional async block port interface above. */
+    pData->pDrvBlockAsyncPort = (PPDMIBLOCKASYNCPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_BLOCK_ASYNC_PORT);
+
     pData->pDrvMountNotify = (PPDMIMOUNTNOTIFY)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_MOUNT_NOTIFY);
 
@@ -826 +930 @@
     if (!pData->pDrvMedia)
     {
-        AssertMsgFailed(("Configuration error: No media interface below!\n"));
-        return VERR_PDM_MISSING_INTERFACE_BELOW;
-    }
+            AssertMsgFailed(("Configuration error: No media or async media interface below!\n"));
+            return VERR_PDM_MISSING_INTERFACE_BELOW;
+    }
+
+    /* Try to get the optional async interface. */
+    pData->pDrvMediaAsync = (PPDMIMEDIAASYNC)pBase->pfnQueryInterface(pBase, PDMINTERFACE_MEDIA_ASYNC);
+
     if (RTUuidIsNull(&pData->Uuid))
     {