Changeset 38469 in vbox for trunk/src/VBox/Storage/QED.cpp

Timestamp:

Aug 16, 2011 10:34:32 AM (14 years ago)

Author:

vboxsync

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

73520

Message:

VD: Interface cleanup. Merge the two involved structures (generic interface descriptor and callback table) into one, remove the duplicated interface wrappers in the backends and move the interface definitions into separate headers separating public and private interfaces.

File:

• trunk/src/VBox/Storage/QED.cpp (modified) (61 diffs)

trunk/src/VBox/Storage/QED.cpp

@@ -150 +150 @@
     /** Storage handle. */
     PVDIOSTORAGE        pStorage;
-    /** I/O interface. */
-    PVDINTERFACE        pInterfaceIO;
-    /** Async I/O interface callbacks. */
-    PVDINTERFACEIOINT   pInterfaceIOCallbacks;
 
     /** Pointer to the per-disk VD interface list. */
@@ -159 +155 @@
     /** Pointer to the per-image VD interface list. */
     PVDINTERFACE        pVDIfsImage;
-
-    /** Error callback. */
-    PVDINTERFACE        pInterfaceError;
-    /** Opaque data for error callback. */
-    PVDINTERFACEERROR   pInterfaceErrorCallbacks;
+    /** Error interface. */
+    PVDINTERFACEERROR   pIfError;
+    /** I/O interface. */
+    PVDINTERFACEIOINT   pIfIo;
 
     /** Open flags passed by VBoxHD layer. */
@@ -186 +181 @@
     uint64_t            cbImage;
     /** Cluster size in bytes. */
-    size_t              cbCluster;
+    uint32_t            cbCluster;
     /** Number of entries in the L1 and L2 table. */
     uint32_t            cTableEntries;
     /** Size of an L1 or L2 table rounded to the next cluster size. */
-    size_t              cbTable;
+    uint32_t            cbTable;
     /** Pointer to the L1 table. */
     uint64_t            *paL1Table;
@@ -272 +267 @@
 
 /**
- * Internal: signal an error to the frontend.
- */
-DECLINLINE(int) qedError(PQEDIMAGE pImage, int rc, RT_SRC_POS_DECL,
-                         const char *pszFormat, ...)
-{
-    va_list va;
-    va_start(va, pszFormat);
-    if (pImage->pInterfaceError)
-        pImage->pInterfaceErrorCallbacks->pfnError(pImage->pInterfaceError->pvUser, rc, RT_SRC_POS_ARGS,
-                                                   pszFormat, va);
-    va_end(va);
-    return rc;
-}
-
-/**
- * Internal: signal an informational message to the frontend.
- */
-DECLINLINE(int) qedMessage(PQEDIMAGE pImage, const char *pszFormat, ...)
-{
-    int rc = VINF_SUCCESS;
-    va_list va;
-    va_start(va, pszFormat);
-    if (pImage->pInterfaceError)
-        rc = pImage->pInterfaceErrorCallbacks->pfnMessage(pImage->pInterfaceError->pvUser,
-                                                          pszFormat, va);
-    va_end(va);
-    return rc;
-}
-
-
-DECLINLINE(int) qedFileOpen(PQEDIMAGE pImage, const char *pszFilename,
-                            uint32_t fOpen)
-{
-    return pImage->pInterfaceIOCallbacks->pfnOpen(pImage->pInterfaceIO->pvUser,
-                                                  pszFilename, fOpen,
-                                                  &pImage->pStorage);
-}
-
-DECLINLINE(int) qedFileClose(PQEDIMAGE pImage)
-{
-    return pImage->pInterfaceIOCallbacks->pfnClose(pImage->pInterfaceIO->pvUser,
-                                                   pImage->pStorage);
-}
-
-DECLINLINE(int) qedFileDelete(PQEDIMAGE pImage, const char *pszFilename)
-{
-    return pImage->pInterfaceIOCallbacks->pfnDelete(pImage->pInterfaceIO->pvUser,
-                                                    pszFilename);
-}
-
-DECLINLINE(int) qedFileMove(PQEDIMAGE pImage, const char *pszSrc,
-                            const char *pszDst, unsigned fMove)
-{
-    return pImage->pInterfaceIOCallbacks->pfnMove(pImage->pInterfaceIO->pvUser,
-                                                  pszSrc, pszDst, fMove);
-}
-
-DECLINLINE(int) qedFileGetFreeSpace(PQEDIMAGE pImage, const char *pszFilename,
-                                    int64_t *pcbFree)
-{
-    return pImage->pInterfaceIOCallbacks->pfnGetFreeSpace(pImage->pInterfaceIO->pvUser,
-                                                          pszFilename, pcbFree);
-}
-
-DECLINLINE(int) qedFileGetSize(PQEDIMAGE pImage, uint64_t *pcbSize)
-{
-    return pImage->pInterfaceIOCallbacks->pfnGetSize(pImage->pInterfaceIO->pvUser,
-                                                     pImage->pStorage, pcbSize);
-}
-
-DECLINLINE(int) qedFileSetSize(PQEDIMAGE pImage, uint64_t cbSize)
-{
-    return pImage->pInterfaceIOCallbacks->pfnSetSize(pImage->pInterfaceIO->pvUser,
-                                                     pImage->pStorage, cbSize);
-}
-
-DECLINLINE(int) qedFileWriteSync(PQEDIMAGE pImage, uint64_t uOffset,
-                                 const void *pvBuffer, size_t cbBuffer,
-                                 size_t *pcbWritten)
-{
-    return pImage->pInterfaceIOCallbacks->pfnWriteSync(pImage->pInterfaceIO->pvUser,
-                                                       pImage->pStorage, uOffset,
-                                                       pvBuffer, cbBuffer, pcbWritten);
-}
-
-DECLINLINE(int) qedFileReadSync(PQEDIMAGE pImage, uint64_t uOffset,
-                                void *pvBuffer, size_t cbBuffer, size_t *pcbRead)
-{
-    return pImage->pInterfaceIOCallbacks->pfnReadSync(pImage->pInterfaceIO->pvUser,
-                                                      pImage->pStorage, uOffset,
-                                                      pvBuffer, cbBuffer, pcbRead);
-}
-
-DECLINLINE(int) qedFileFlushSync(PQEDIMAGE pImage)
-{
-    return pImage->pInterfaceIOCallbacks->pfnFlushSync(pImage->pInterfaceIO->pvUser,
-                                                       pImage->pStorage);
-}
-
-DECLINLINE(int) qedFileReadUserAsync(PQEDIMAGE pImage, uint64_t uOffset,
-                                     PVDIOCTX pIoCtx, size_t cbRead)
-{
-    return pImage->pInterfaceIOCallbacks->pfnReadUserAsync(pImage->pInterfaceIO->pvUser,
-                                                           pImage->pStorage,
-                                                           uOffset, pIoCtx,
-                                                           cbRead);
-}
-
-DECLINLINE(int) qedFileWriteUserAsync(PQEDIMAGE pImage, uint64_t uOffset,
-                                      PVDIOCTX pIoCtx, size_t cbWrite,
-                                      PFNVDXFERCOMPLETED pfnComplete,
-                                      void *pvCompleteUser)
-{
-    return pImage->pInterfaceIOCallbacks->pfnWriteUserAsync(pImage->pInterfaceIO->pvUser,
-                                                            pImage->pStorage,
-                                                            uOffset, pIoCtx,
-                                                            cbWrite,
-                                                            pfnComplete,
-                                                            pvCompleteUser);
-}
-
-/**
- * Internal: read metadata (async)
- */
-DECLINLINE(int) qedFileReadMetaAsync(PQEDIMAGE pImage,
-                                     uint64_t uOffset, void *pvBuffer,
-                                     size_t cbBuffer, PVDIOCTX pIoCtx,
-                                     PPVDMETAXFER ppMetaXfer,
-                                     PFNVDXFERCOMPLETED pfnComplete,
-                                     void *pvCompleteUser)
-{
-    return pImage->pInterfaceIOCallbacks->pfnReadMetaAsync(pImage->pInterfaceIO->pvUser,
-                                                           pImage->pStorage,
-                                                           uOffset, pvBuffer,
-                                                           cbBuffer, pIoCtx,
-                                                           ppMetaXfer,
-                                                           pfnComplete,
-                                                           pvCompleteUser);
-}
-
-/**
- * Internal: write metadata (async)
- */
-DECLINLINE(int) qedFileWriteMetaAsync(PQEDIMAGE pImage,
-                                      uint64_t uOffset, void *pvBuffer,
-                                      size_t cbBuffer, PVDIOCTX pIoCtx,
-                                      PFNVDXFERCOMPLETED pfnComplete,
-                                      void *pvCompleteUser)
-{
-    return pImage->pInterfaceIOCallbacks->pfnWriteMetaAsync(pImage->pInterfaceIO->pvUser,
-                                                            pImage->pStorage,
-                                                            uOffset, pvBuffer,
-                                                            cbBuffer, pIoCtx,
-                                                            pfnComplete,
-                                                            pvCompleteUser);
-}
-
-/**
- * Internal: releases a metadata transfer handle (async)
- */
-DECLINLINE(void) qedFileMetaXferRelease(PQEDIMAGE pImage, PVDMETAXFER pMetaXfer)
-{
-    pImage->pInterfaceIOCallbacks->pfnMetaXferRelease(pImage->pInterfaceIO->pvUser,
-                                                      pMetaXfer);
-}
-
-DECLINLINE(int) qedFileFlushAsync(PQEDIMAGE pImage, PVDIOCTX pIoCtx,
-                                  PFNVDXFERCOMPLETED pfnComplete,
-                                  void *pvCompleteUser)
-{
-    return pImage->pInterfaceIOCallbacks->pfnFlushAsync(pImage->pInterfaceIO->pvUser,
-                                                        pImage->pStorage,
-                                                        pIoCtx, pfnComplete,
-                                                        pvCompleteUser);
-}
-
-
-/**
  * Converts the image header to the host endianess and performs basic checks.
  *
@@ -753 +570 @@
             /* Read from the image. */
             pL2Entry->offL2Tbl = offL2Tbl;
-            rc = qedFileReadSync(pImage, offL2Tbl, pL2Entry->paL2Tbl, pImage->cbTable, NULL);
+            rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, offL2Tbl,
+                                       pL2Entry->paL2Tbl, pImage->cbTable, NULL);
             if (RT_SUCCESS(rc))
             {
@@ -802 +620 @@
 
             pL2Entry->offL2Tbl = offL2Tbl;
-            rc = qedFileReadMetaAsync(pImage, offL2Tbl, pL2Entry->paL2Tbl,
-                                      pImage->cbTable, pIoCtx,
-                                      &pMetaXfer, NULL, NULL);
+            rc = vdIfIoIntFileReadMetaAsync(pImage->pIfIo, pImage->pStorage,
+                                            offL2Tbl, pL2Entry->paL2Tbl,
+                                            pImage->cbTable, pIoCtx,
+                                            &pMetaXfer, NULL, NULL);
             if (RT_SUCCESS(rc))
             {
-                qedFileMetaXferRelease(pImage, pMetaXfer);
+                vdIfIoIntMetaXferRelease(pImage->pIfIo, pMetaXfer);
 #if defined(RT_BIG_ENDIAN)
                 qedTableConvertToHostEndianness(pL2Entry->paL2Tbl, pImage->cTableEntries);
@@ -1040 +859 @@
             qedTableConvertFromHostEndianess(p1L1TblImg, pImage->paL1Table,
                                              pImage->cTableEntries);
-            rc = qedFileWriteSync(pImage, pImage->offL1Table, paL1TblImg,
-                                  pImage->cbTable, NULL);
+            rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage,
+                                        pImage->offL1Table, paL1TblImg,
+                                        pImage->cbTable, NULL);
             RTMemFree(paL1TblImg);
         }
@@ -1048 +868 @@
 #else
         /* Write L1 table directly. */
-        rc = qedFileWriteSync(pImage, pImage->offL1Table, pImage->paL1Table,
-                              pImage->cbTable, NULL);
+        rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, pImage->offL1Table,
+                                    pImage->paL1Table, pImage->cbTable, NULL);
 #endif
         if (RT_SUCCESS(rc))
@@ -1055 +875 @@
             /* Write header. */
             qedHdrConvertFromHostEndianess(pImage, &Header);
-            rc = qedFileWriteSync(pImage, 0, &Header, sizeof(Header), NULL);
+            rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, 0, &Header,
+                                        sizeof(Header), NULL);
             if (RT_SUCCESS(rc))
-                rc = qedFileFlushSync(pImage);
+                rc = vdIfIoIntFileFlushSync(pImage->pIfIo, pImage->pStorage);
         }
     }
@@ -1087 +908 @@
             qedTableConvertFromHostEndianess(p1L1TblImg, pImage->paL1Table,
                                              pImage->cTableEntries);
-            rc = qedFileWriteMetaAsync(pImage, pImage->offL1Table, paL1TblImg,
-                                       pImage->cbTable, pIoCtx, NULL, NULL);
+            rc = vdIfIoIntFileWriteMetaAsync(pImage->pIfIo, pImage->pStorage,
+                                             pImage->offL1Table, paL1TblImg,
+                                             pImage->cbTable, pIoCtx, NULL, NULL);
             RTMemFree(paL1TblImg);
         }
@@ -1095 +917 @@
 #else
         /* Write L1 table directly. */
-        rc = qedFileWriteMetaAsync(pImage, pImage->offL1Table, pImage->paL1Table,
-                                   pImage->cbTable, pIoCtx, NULL, NULL);
+        rc = vdIfIoIntFileWriteMetaAsync(pImage->pIfIo, pImage->pStorage,
+                                         pImage->offL1Table, pImage->paL1Table,
+                                         pImage->cbTable, pIoCtx, NULL, NULL);
 #endif
         if (RT_SUCCESS(rc) || rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
@@ -1102 +925 @@
             /* Write header. */
             qedHdrConvertFromHostEndianess(pImage, &Header);
-            rc = qedFileWriteMetaAsync(pImage, 0, &Header, sizeof(Header),
-                                       pIoCtx, NULL, NULL);
+            rc = vdIfIoIntFileWriteMetaAsync(pImage->pIfIo, pImage->pStorage,
+                                             0, &Header, sizeof(Header),
+                                             pIoCtx, NULL, NULL);
             if (RT_SUCCESS(rc) || rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
-                rc = qedFileFlushAsync(pImage, pIoCtx, NULL, NULL);
+                rc = vdIfIoIntFileFlushAsync(pImage->pIfIo, pImage->pStorage,
+                                             pIoCtx, NULL, NULL);
         }
     }
@@ -1177 +1002 @@
 {
     uint64_t cbFile;
-    size_t cbTable;
+    uint32_t cbTable;
     uint32_t cTableEntries;
     uint64_t *paL1Tbl = NULL;
@@ -1191 +1016 @@
     do
     {
-        rc = qedFileGetSize(pImage, &cbFile);
+        rc = vdIfIoIntFileGetSize(pImage->pIfIo, pImage->pStorage, &cbFile);
         if (RT_FAILURE(rc))
         {
-            rc = qedError(pImage, rc, RT_SRC_POS,
-                          N_("Qed: Querying the file size of image '%s' failed"),
-                          pImage->pszFilename);
+            rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                           N_("Qed: Querying the file size of image '%s' failed"),
+                           pImage->pszFilename);
             break;
         }
@@ -1204 +1029 @@
         if (!paL1Tbl)
         {
-            rc = qedError(pImage, VERR_NO_MEMORY, RT_SRC_POS,
+            rc = vdIfError(pImage->pIfError, VERR_NO_MEMORY, RT_SRC_POS,
                           N_("Qed: Allocating memory for the L1 table for image '%s' failed"),
                           pImage->pszFilename);
@@ -1213 +1038 @@
         if (!paL2Tbl)
         {
-            rc = qedError(pImage, VERR_NO_MEMORY, RT_SRC_POS,
-                          N_("Qed: Allocating memory for the L2 table for image '%s' failed"),
-                          pImage->pszFilename);
+            rc = vdIfError(pImage->pIfError, VERR_NO_MEMORY, RT_SRC_POS,
+                           N_("Qed: Allocating memory for the L2 table for image '%s' failed"),
+                           pImage->pszFilename);
             break;
         }
@@ -1222 +1047 @@
         if (!pvClusterBitmap)
         {
-            rc = qedError(pImage, VERR_NO_MEMORY, RT_SRC_POS,
-                          N_("Qed: Allocating memory for the cluster bitmap for image '%s' failed"),
-                          pImage->pszFilename);
+            rc = vdIfError(pImage->pIfError, VERR_NO_MEMORY, RT_SRC_POS,
+                           N_("Qed: Allocating memory for the cluster bitmap for image '%s' failed"),
+                           pImage->pszFilename);
             break;
         }
@@ -1231 +1056 @@
         if (!qedIsTblOffsetValid(pHeader->u64OffL1Table, cbFile, cbTable, pHeader->u32ClusterSize))
         {
-            rc = qedError(pImage, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
-                              N_("Qed: L1 table offset of image '%s' is corrupt (%llu)"),
-                              pImage->pszFilename, pHeader->u64OffL1Table);
+            rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
+                           N_("Qed: L1 table offset of image '%s' is corrupt (%llu)"),
+                           pImage->pszFilename, pHeader->u64OffL1Table);
             break;
         }
 
         /* Read L1 table. */
-        rc = qedFileReadSync(pImage, pHeader->u64OffL1Table, paL1Tbl, cbTable, NULL);
+        rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage,
+                                   pHeader->u64OffL1Table, paL1Tbl, cbTable, NULL);
         if (RT_FAILURE(rc))
         {
-            rc = qedError(pImage, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
-                              N_("Qed: Reading the L1 table from image '%s' failed"),
-                              pImage->pszFilename);
+            rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
+                           N_("Qed: Reading the L1 table from image '%s' failed"),
+                           pImage->pszFilename);
             break;
         }
@@ -1263 +1089 @@
             if (!qedIsTblOffsetValid(paL1Tbl[iL1], cbFile, cbTable, pHeader->u32ClusterSize))
             {
-                rc = qedError(pImage, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
-                              N_("Qed: Entry %d of the L1 table from image '%s' is invalid (%llu)"),
-                              iL1, pImage->pszFilename, paL1Tbl[iL1]);
+                rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
+                               N_("Qed: Entry %d of the L1 table from image '%s' is invalid (%llu)"),
+                               iL1, pImage->pszFilename, paL1Tbl[iL1]);
                 break;
             }
@@ -1274 +1100 @@
             if (!fSet)
             {
-                rc = qedError(pImage, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
-                              N_("Qed: Entry %d of the L1 table from image '%s' points to a already used cluster (%llu)"),
-                              iL1, pImage->pszFilename, paL1Tbl[iL1]);
+                rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
+                               N_("Qed: Entry %d of the L1 table from image '%s' points to a already used cluster (%llu)"),
+                               iL1, pImage->pszFilename, paL1Tbl[iL1]);
                 break;
             }
 
             /* Read the linked L2 table and check it. */
-            rc = qedFileReadSync(pImage, paL1Tbl[iL1], paL2Tbl, cbTable, NULL);
+            rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage,
+                                       paL1Tbl[iL1], paL2Tbl, cbTable, NULL);
             if (RT_FAILURE(rc))
             {
-                rc = qedError(pImage, rc, RT_SRC_POS,
-                              N_("Qed: Reading the L2 table from image '%s' failed"),
-                              pImage->pszFilename);
+                rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                               N_("Qed: Reading the L2 table from image '%s' failed"),
+                               pImage->pszFilename);
                 break;
             }
@@ -1298 +1125 @@
                 if (!qedIsClusterOffsetValid(paL2Tbl[iL2], cbFile, pHeader->u32ClusterSize))
                 {
-                    rc = qedError(pImage, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
-                                  N_("Qed: Entry %d of the L2 table from image '%s' is invalid (%llu)"),
-                                  iL2, pImage->pszFilename, paL2Tbl[iL2]);
+                    rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
+                                   N_("Qed: Entry %d of the L2 table from image '%s' is invalid (%llu)"),
+                                   iL2, pImage->pszFilename, paL2Tbl[iL2]);
                     break;
                 }
@@ -1309 +1136 @@
                 if (!fSet)
                 {
-                    rc = qedError(pImage, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
-                                  N_("Qed: Entry %d of the L2 table from image '%s' points to a already used cluster (%llu)"),
-                                  iL2, pImage->pszFilename, paL2Tbl[iL2]);
+                    rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
+                                   N_("Qed: Entry %d of the L2 table from image '%s' points to a already used cluster (%llu)"),
+                                   iL2, pImage->pszFilename, paL2Tbl[iL2]);
                     break;
                 }
@@ -1346 +1173 @@
                 qedFlushImage(pImage);
 
-            qedFileClose(pImage);
+            vdIfIoIntFileClose(pImage->pIfIo, pImage->pStorage);
             pImage->pStorage = NULL;
         }
@@ -1359 +1186 @@
 
         if (fDelete && pImage->pszFilename)
-            qedFileDelete(pImage, pImage->pszFilename);
+            vdIfIoIntFileDelete(pImage->pIfIo, pImage->pszFilename);
     }
 
@@ -1375 +1202 @@
     pImage->uOpenFlags = uOpenFlags;
 
-    pImage->pInterfaceError = VDInterfaceGet(pImage->pVDIfsDisk, VDINTERFACETYPE_ERROR);
-    if (pImage->pInterfaceError)
-        pImage->pInterfaceErrorCallbacks = VDGetInterfaceError(pImage->pInterfaceError);
-
-    /* Get I/O interface. */
-    pImage->pInterfaceIO = VDInterfaceGet(pImage->pVDIfsImage, VDINTERFACETYPE_IOINT);
-    AssertPtrReturn(pImage->pInterfaceIO, VERR_INVALID_PARAMETER);
-    pImage->pInterfaceIOCallbacks = VDGetInterfaceIOInt(pImage->pInterfaceIO);
-    AssertPtrReturn(pImage->pInterfaceIOCallbacks, VERR_INVALID_PARAMETER);
+    pImage->pIfError = VDIfErrorGet(pImage->pVDIfsDisk);
+    pImage->pIfIo = VDIfIoIntGet(pImage->pVDIfsImage);
+    AssertPtrReturn(pImage->pIfIo, VERR_INVALID_PARAMETER);
 
     /*
      * Open the image.
      */
-    rc = qedFileOpen(pImage, pImage->pszFilename,
-                     VDOpenFlagsToFileOpenFlags(uOpenFlags,
-                                                false /* fCreate */));
+    rc = vdIfIoIntFileOpen(pImage->pIfIo, pImage->pszFilename,
+                           VDOpenFlagsToFileOpenFlags(uOpenFlags,
+                                                      false /* fCreate */),
+                           &pImage->pStorage);
     if (RT_FAILURE(rc))
     {
@@ -1400 +1222 @@
     uint64_t cbFile;
     QedHeader Header;
-    rc = qedFileGetSize(pImage, &cbFile);
+    rc = vdIfIoIntFileGetSize(pImage->pIfIo, pImage->pStorage, &cbFile);
     if (RT_FAILURE(rc))
         goto out;
     if (cbFile > sizeof(Header))
     {
-        rc = qedFileReadSync(pImage, 0, &Header, sizeof(Header), NULL);
+        rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, 0, &Header, sizeof(Header), NULL);
         if (   RT_SUCCESS(rc)
             && qedHdrConvertToHostEndianess(&Header))
@@ -1418 +1240 @@
                         rc = qedCheckImage(pImage, &Header);
                     else
-                        rc = qedError(pImage, VERR_NOT_SUPPORTED, RT_SRC_POS,
-                                      N_("Qed: Image '%s' needs checking but is opened readonly"),
-                                      pImage->pszFilename);
+                        rc = vdIfError(pImage->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
+                                       N_("Qed: Image '%s' needs checking but is opened readonly"),
+                                       pImage->pszFilename);
                 }
 
@@ -1432 +1254 @@
                         pImage->cbBackingFilename  = Header.u32BackingFilenameSize;
                         pImage->offBackingFilename = Header.u32OffBackingFilename;
-                        rc = qedFileReadSync(pImage, Header.u32OffBackingFilename, pImage->pszBackingFilename,
-                                             Header.u32BackingFilenameSize, NULL);
+                        rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage,
+                                                   Header.u32OffBackingFilename, pImage->pszBackingFilename,
+                                                   Header.u32BackingFilenameSize, NULL);
                     }
                     else
@@ -1454 +1277 @@
                     {
                         /* Read from the image. */
-                        rc = qedFileReadSync(pImage, pImage->offL1Table, pImage->paL1Table,
-                                             pImage->cbTable, NULL);
+                        rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage,
+                                                   pImage->offL1Table, pImage->paL1Table,
+                                                   pImage->cbTable, NULL);
                         if (RT_SUCCESS(rc))
                         {
@@ -1467 +1291 @@
                             }
                             else
-                                rc = qedError(pImage, rc, RT_SRC_POS,
-                                              N_("Qed: Creating the L2 table cache for image '%s' failed"),
-                                              pImage->pszFilename);
+                                rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                                               N_("Qed: Creating the L2 table cache for image '%s' failed"),
+                                               pImage->pszFilename);
                         }
                         else
-                            rc = qedError(pImage, rc, RT_SRC_POS,
-                                          N_("Qed: Reading the L1 table for image '%s' failed"),
-                                          pImage->pszFilename);
+                            rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                                           N_("Qed: Reading the L1 table for image '%s' failed"),
+                                           pImage->pszFilename);
                     }
                     else
-                        rc = qedError(pImage, VERR_NO_MEMORY, RT_SRC_POS,
-                                      N_("Qed: Out of memory allocating L1 table for image '%s'"),
-                                      pImage->pszFilename);
+                        rc = vdIfError(pImage->pIfError, VERR_NO_MEMORY, RT_SRC_POS,
+                                       N_("Qed: Out of memory allocating L1 table for image '%s'"),
+                                       pImage->pszFilename);
                 }
             }
             else
-                rc = qedError(pImage, VERR_NOT_SUPPORTED, RT_SRC_POS,
-                              N_("Qed: The image '%s' makes use of unsupported features"),
-                              pImage->pszFilename);
+                rc = vdIfError(pImage->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
+                               N_("Qed: The image '%s' makes use of unsupported features"),
+                               pImage->pszFilename);
         }
         else if (RT_SUCCESS(rc))
@@ -1510 +1334 @@
 {
     int rc;
-    uint64_t uOff;
     int32_t fOpen;
 
     if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
     {
-        rc = qedError(pImage, VERR_VD_INVALID_TYPE, RT_SRC_POS, N_("Qed: cannot create fixed image '%s'"), pImage->pszFilename);
+        rc = vdIfError(pImage->pIfError, VERR_VD_INVALID_TYPE, RT_SRC_POS, N_("Qed: cannot create fixed image '%s'"), pImage->pszFilename);
         goto out;
     }
@@ -1524 +1347 @@
     pImage->LCHSGeometry = *pLCHSGeometry;
 
-    pImage->pInterfaceError = VDInterfaceGet(pImage->pVDIfsDisk, VDINTERFACETYPE_ERROR);
-    if (pImage->pInterfaceError)
-        pImage->pInterfaceErrorCallbacks = VDGetInterfaceError(pImage->pInterfaceError);
-
-    /* Get I/O interface. */
-    pImage->pInterfaceIO = VDInterfaceGet(pImage->pVDIfsImage, VDINTERFACETYPE_IOINT);
-    AssertPtrReturn(pImage->pInterfaceIO, VERR_INVALID_PARAMETER);
-    pImage->pInterfaceIOCallbacks = VDGetInterfaceIOInt(pImage->pInterfaceIO);
-    AssertPtrReturn(pImage->pInterfaceIOCallbacks, VERR_INVALID_PARAMETER);
+    pImage->pIfError = VDIfErrorGet(pImage->pVDIfsDisk);
+    pImage->pIfIo = VDIfIoIntGet(pImage->pVDIfsImage);
+    AssertPtrReturn(pImage->pIfIo, VERR_INVALID_PARAMETER);
 
     /* Create image file. */
     fOpen = VDOpenFlagsToFileOpenFlags(pImage->uOpenFlags, true /* fCreate */);
-    rc = qedFileOpen(pImage, pImage->pszFilename, fOpen);
+    rc = vdIfIoIntFileOpen(pImage->pIfIo, pImage->pszFilename, fOpen, &pImage->pStorage);
     if (RT_FAILURE(rc))
     {
-        rc = qedError(pImage, rc, RT_SRC_POS, N_("Qed: cannot create image '%s'"), pImage->pszFilename);
+        rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("Qed: cannot create image '%s'"), pImage->pszFilename);
         goto out;
     }
@@ -1558 +1375 @@
     if (!pImage->paL1Table)
     {
-        rc = qedError(pImage, VERR_NO_MEMORY, RT_SRC_POS, N_("Qed: cannot allocate memory for L1 table of image '%s'"),
-                      pImage->pszFilename);
+        rc = vdIfError(pImage->pIfError, VERR_NO_MEMORY, RT_SRC_POS, N_("Qed: cannot allocate memory for L1 table of image '%s'"),
+                       pImage->pszFilename);
         goto out;
     }
@@ -1566 +1383 @@
     if (RT_FAILURE(rc))
     {
-        rc = qedError(pImage, rc, RT_SRC_POS, N_("Qed: Failed to create L2 cache for image '%s'"),
-                      pImage->pszFilename);
+        rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("Qed: Failed to create L2 cache for image '%s'"),
+                       pImage->pszFilename);
         goto out;
     }
@@ -1603 +1420 @@
         {
             /* Assumption right now is that the L1 table is not modified if the link fails. */
-            rc = qedFileSetSize(pImage, pClusterAlloc->cbImageOld);
+            rc = vdIfIoIntFileSetSize(pImage->pIfIo, pImage->pStorage, pClusterAlloc->cbImageOld);
             qedL2TblCacheEntryRelease(pClusterAlloc->pL2Entry); /* Release L2 cache entry. */
             qedL2TblCacheEntryFree(pImage, pClusterAlloc->pL2Entry); /* Free it, it is not in the cache yet. */
@@ -1611 +1428 @@
         {
             /* Assumption right now is that the L2 table is not modified if the link fails. */
-            rc = qedFileSetSize(pImage, pClusterAlloc->cbImageOld);
+            rc = vdIfIoIntFileSetSize(pImage->pIfIo, pImage->pStorage, pClusterAlloc->cbImageOld);
             qedL2TblCacheEntryRelease(pClusterAlloc->pL2Entry); /* Release L2 cache entry. */
         }
@@ -1651 +1468 @@
             /* Update the link in the on disk L1 table now. */
             pClusterAlloc->enmAllocState = QEDCLUSTERASYNCALLOCSTATE_L2_LINK;
-            rc = qedFileWriteMetaAsync(pImage, pImage->offL1Table + pClusterAlloc->idxL1*sizeof(uint64_t),
-                                       &offUpdateLe, sizeof(uint64_t), pIoCtx,
-                                       qedAsyncClusterAllocUpdate, pClusterAlloc);
+            rc = vdIfIoIntFileWriteMetaAsync(pImage->pIfIo, pImage->pStorage,
+                                             pImage->offL1Table + pClusterAlloc->idxL1*sizeof(uint64_t),
+                                             &offUpdateLe, sizeof(uint64_t), pIoCtx,
+                                             qedAsyncClusterAllocUpdate, pClusterAlloc);
             if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
                 break;
@@ -1678 +1496 @@
 
             /* Write data. */
-            rc = qedFileWriteUserAsync(pImage, offData, pIoCtx, pClusterAlloc->cbToWrite,
-                                       qedAsyncClusterAllocUpdate, pClusterAlloc);
+            rc = vdIfIoIntFileWriteUserAsync(pImage->pIfIo, pImage->pStorage,
+                                             offData, pIoCtx, pClusterAlloc->cbToWrite,
+                                             qedAsyncClusterAllocUpdate, pClusterAlloc);
             if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
                 break;
@@ -1696 +1515 @@
 
             /* Link L2 table and update it. */
-            rc = qedFileWriteMetaAsync(pImage, pImage->paL1Table[pClusterAlloc->idxL1] + pClusterAlloc->idxL2*sizeof(uint64_t),
-                                       &offUpdateLe, sizeof(uint64_t), pIoCtx,
-                                       qedAsyncClusterAllocUpdate, pClusterAlloc);
+            rc = vdIfIoIntFileWriteMetaAsync(pImage->pIfIo, pImage->pStorage,
+                                             pImage->paL1Table[pClusterAlloc->idxL1] + pClusterAlloc->idxL2*sizeof(uint64_t),
+                                             &offUpdateLe, sizeof(uint64_t), pIoCtx,
+                                             qedAsyncClusterAllocUpdate, pClusterAlloc);
             if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
                 break;
@@ -1735 +1555 @@
 
     /* Get I/O interface. */
-    PVDINTERFACE pInterfaceIO = VDInterfaceGet(pVDIfsImage, VDINTERFACETYPE_IOINT);
-    AssertPtrReturn(pInterfaceIO, VERR_INVALID_PARAMETER);
-    PVDINTERFACEIOINT pInterfaceIOCallbacks = VDGetInterfaceIOInt(pInterfaceIO);
-    AssertPtrReturn(pInterfaceIOCallbacks, VERR_INVALID_PARAMETER);
+    PVDINTERFACEIOINT pIfIo = VDIfIoIntGet(pVDIfsImage);
+    AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
 
     if (   !VALID_PTR(pszFilename)
@@ -1750 +1568 @@
      * Open the file and read the footer.
      */
-    rc = pInterfaceIOCallbacks->pfnOpen(pInterfaceIO->pvUser, pszFilename,
-                                        VDOpenFlagsToFileOpenFlags(VD_OPEN_FLAGS_READONLY,
-                                                                   false /* fCreate */),
-                                        &pStorage);
+    rc = vdIfIoIntFileOpen(pIfIo, pszFilename,
+                           VDOpenFlagsToFileOpenFlags(VD_OPEN_FLAGS_READONLY,
+                                                      false /* fCreate */),
+                           &pStorage);
     if (RT_SUCCESS(rc))
-        rc = pInterfaceIOCallbacks->pfnGetSize(pInterfaceIO->pvUser, pStorage,
-                                               &cbFile);
+        rc = vdIfIoIntFileGetSize(pIfIo, pStorage, &cbFile);
 
     if (   RT_SUCCESS(rc)
@@ -1763 +1580 @@
         QedHeader Header;
 
-        rc = pInterfaceIOCallbacks->pfnReadSync(pInterfaceIO->pvUser, pStorage, 0, &Header,
-                                                sizeof(Header), NULL);
+        rc = vdIfIoIntFileReadSync(pIfIo, pStorage, 0, &Header, sizeof(Header), NULL);
         if (   RT_SUCCESS(rc)
             && qedHdrConvertToHostEndianess(&Header))
@@ -1778 +1594 @@
 
     if (pStorage)
-        pInterfaceIOCallbacks->pfnClose(pInterfaceIO->pvUser, pStorage);
+        vdIfIoIntFileClose(pIfIo, pStorage);
 
 out:
@@ -1848 +1664 @@
     PFNVDPROGRESS pfnProgress = NULL;
     void *pvUser = NULL;
-    PVDINTERFACE pIfProgress = VDInterfaceGet(pVDIfsOperation,
-                                              VDINTERFACETYPE_PROGRESS);
-    PVDINTERFACEPROGRESS pCbProgress = NULL;
+    PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
     if (pIfProgress)
     {
-        pCbProgress = VDGetInterfaceProgress(pIfProgress);
-        if (pCbProgress)
-            pfnProgress = pCbProgress->pfnProgress;
-        pvUser = pIfProgress->pvUser;
+        pfnProgress = pIfProgress->pfnProgress;
+        pvUser = pIfProgress->Core.pvUser;
     }
 
@@ -1936 +1748 @@
 
     /* Rename the file. */
-    rc = qedFileMove(pImage, pImage->pszFilename, pszFilename, 0);
+    rc = vdIfIoIntFileMove(pImage->pIfIo, pImage->pszFilename, pszFilename, 0);
     if (RT_FAILURE(rc))
     {
@@ -2009 +1821 @@
     {
         LogFlowFunc(("offFile=%llu\n", offFile));
-        rc = qedFileReadSync(pImage, offFile, pvBuf, cbToRead, NULL);
+        rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, offFile,
+                                   pvBuf, cbToRead, NULL);
     }
 
@@ -2062 +1875 @@
     rc = qedConvertToImageOffset(pImage, idxL1, idxL2, offCluster, &offImage);
     if (RT_SUCCESS(rc))
-        rc = qedFileWriteSync(pImage, offImage, pvBuf, cbToWrite, NULL);
+        rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, offImage,
+                                    pvBuf, cbToWrite, NULL);
     else if (rc == VERR_VD_BLOCK_FREE)
     {
@@ -2099 +1913 @@
                      * is a leak of some clusters.
                      */
-                    rc = qedFileWriteSync(pImage, offL2Tbl, pL2Entry->paL2Tbl, pImage->cbTable, NULL);
+                    rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, offL2Tbl,
+                                                pL2Entry->paL2Tbl, pImage->cbTable, NULL);
                     if (RT_FAILURE(rc))
                         break;
@@ -2106 +1921 @@
                     pImage->paL1Table[idxL1] = offL2Tbl;
                     idxUpdateLe = RT_H2LE_U64(offL2Tbl);
-                    rc = qedFileWriteSync(pImage, pImage->offL1Table + idxL1*sizeof(uint64_t),
-                                          &idxUpdateLe, sizeof(uint64_t), NULL);
+                    rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage,
+                                                pImage->offL1Table + idxL1*sizeof(uint64_t),
+                                                &idxUpdateLe, sizeof(uint64_t), NULL);
                     if (RT_FAILURE(rc))
                         break;
@@ -2120 +1936 @@
 
                     /* Write data. */
-                    rc = qedFileWriteSync(pImage, offData, pvBuf, cbToWrite, NULL);
+                    rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage,
+                                                offData, pvBuf, cbToWrite, NULL);
                     if (RT_FAILURE(rc))
                         break;
@@ -2127 +1944 @@
                     pL2Entry->paL2Tbl[idxL2] = offData;
                     idxUpdateLe = RT_H2LE_U64(offData);
-                    rc = qedFileWriteSync(pImage, pImage->paL1Table[idxL1] + idxL2*sizeof(uint64_t),
-                                          &idxUpdateLe, sizeof(uint64_t), NULL);
+                    rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage,
+                                                pImage->paL1Table[idxL1] + idxL2*sizeof(uint64_t),
+                                                &idxUpdateLe, sizeof(uint64_t), NULL);
                     qedL2TblCacheEntryRelease(pL2Entry);
                 }
@@ -2210 +2028 @@
         if (pImage->pStorage)
         {
-            int rc = qedFileGetSize(pImage, &cbFile);
+            int rc = vdIfIoIntFileGetSize(pImage->pIfIo, pImage->pStorage, &cbFile);
             if (RT_SUCCESS(rc))
                 cb += cbFile;
@@ -2608 +2426 @@
     if (pImage)
     {
-        qedMessage(pImage, "Header: Geometry PCHS=%u/%u/%u LCHS=%u/%u/%u cbSector=%llu\n",
-                    pImage->PCHSGeometry.cCylinders, pImage->PCHSGeometry.cHeads, pImage->PCHSGeometry.cSectors,
-                    pImage->LCHSGeometry.cCylinders, pImage->LCHSGeometry.cHeads, pImage->LCHSGeometry.cSectors,
-                    pImage->cbSize / 512);
+        vdIfErrorMessage(pImage->pIfError, "Header: Geometry PCHS=%u/%u/%u LCHS=%u/%u/%u cbSector=%llu\n",
+                         pImage->PCHSGeometry.cCylinders, pImage->PCHSGeometry.cHeads, pImage->PCHSGeometry.cSectors,
+                         pImage->LCHSGeometry.cCylinders, pImage->LCHSGeometry.cHeads, pImage->LCHSGeometry.cSectors,
+                         pImage->cbSize / 512);
     }
 }
@@ -2665 +2483 @@
                     pImage->offBackingFilename = (uint32_t)offData;
                     pImage->cbBackingFilename  = strlen(pszParentFilename);
-                    rc = qedFileSetSize(pImage, offData + pImage->cbCluster);
+                    rc = vdIfIoIntFileSetSize(pImage->pIfIo, pImage->pStorage,
+                                              offData + pImage->cbCluster);
                 }
 
                 if (RT_SUCCESS(rc))
-                    rc = qedFileWriteSync(pImage, pImage->offBackingFilename,
-                                          pImage->pszBackingFilename, strlen(pImage->pszBackingFilename),
-                                          NULL);
+                    rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage,
+                                                pImage->offBackingFilename,
+                                                pImage->pszBackingFilename,
+                                                strlen(pImage->pszBackingFilename),
+                                                NULL);
             }
         }
@@ -2720 +2541 @@
                                       &offFile);
     if (RT_SUCCESS(rc))
-        rc = qedFileReadUserAsync(pImage, offFile, pIoCtx, cbToRead);
+        rc = vdIfIoIntFileReadUserAsync(pImage->pIfIo, pImage->pStorage, offFile,
+                                        pIoCtx, cbToRead);
 
     if (   (   RT_SUCCESS(rc)
@@ -2781 +2603 @@
                                       &offImage);
     if (RT_SUCCESS(rc))
-        rc = qedFileWriteUserAsync(pImage, offImage, pIoCtx, cbToWrite,
-                                   NULL, NULL);
+        rc = vdIfIoIntFileWriteUserAsync(pImage->pIfIo, pImage->pStorage,
+                                         offImage, pIoCtx, cbToWrite, NULL, NULL);
     else if (rc == VERR_VD_BLOCK_FREE)
     {
@@ -2837 +2659 @@
                      * is a leak of some clusters.
                      */
-                    rc = qedFileWriteMetaAsync(pImage, offL2Tbl, pL2Entry->paL2Tbl, pImage->cbTable, pIoCtx,
-                                               qedAsyncClusterAllocUpdate, pL2ClusterAlloc);
+                    rc = vdIfIoIntFileWriteMetaAsync(pImage->pIfIo, pImage->pStorage,
+                                                     offL2Tbl, pL2Entry->paL2Tbl, pImage->cbTable, pIoCtx,
+                                                     qedAsyncClusterAllocUpdate, pL2ClusterAlloc);
                     if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
                         break;
@@ -2879 +2702 @@
 
                         /* Write data. */
-                        rc = qedFileWriteUserAsync(pImage, offData, pIoCtx, cbToWrite,
-                                                   qedAsyncClusterAllocUpdate, pDataClusterAlloc);
+                        rc = vdIfIoIntFileWriteUserAsync(pImage->pIfIo, pImage->pStorage,
+                                                         offData, pIoCtx, cbToWrite,
+                                                         qedAsyncClusterAllocUpdate, pDataClusterAlloc);
                         if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
                             break;
@@ -2943 +2767 @@
     int rc = VINF_SUCCESS;
 
-    PFNVDPROGRESS pfnProgress = NULL;
-    void *pvUser = NULL;
-    PVDINTERFACE pIfProgress = VDInterfaceGet(pVDIfsOperation,
-                                              VDINTERFACETYPE_PROGRESS);
-    PVDINTERFACEPROGRESS pCbProgress = NULL;
-    if (pIfProgress)
-    {
-        pCbProgress = VDGetInterfaceProgress(pIfProgress);
-        if (pCbProgress)
-            pfnProgress = pCbProgress->pfnProgress;
-        pvUser = pIfProgress->pvUser;
-    }
+    PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
 
     /* Making the image smaller is not supported at the moment. */
@@ -2971 +2784 @@
          */
         if (qedByte2Cluster(pImage, pImage->cbTable)*pImage->cTableEntries*pImage->cTableEntries*pImage->cbCluster < cbSize)
-            rc = qedError(pImage, VERR_BUFFER_OVERFLOW, RT_SRC_POS,
-                          N_("Qed: Resizing the image '%s' is not supported because it would overflow the L1 and L2 table\n"),
-                          pImage->pszFilename);
+            rc = vdIfError(pImage->pIfError, VERR_BUFFER_OVERFLOW, RT_SRC_POS,
+                           N_("Qed: Resizing the image '%s' is not supported because it would overflow the L1 and L2 table\n"),
+                           pImage->pszFilename);
         else
         {
@@ -2984 +2797 @@
                 pImage->cbSize = cbSizeOld; /* Restore */
 
-                rc = qedError(pImage, rc, RT_SRC_POS, N_("Qed: Resizing the image '%s' failed\n"),
-                              pImage->pszFilename);
+                rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("Qed: Resizing the image '%s' failed\n"),
+                               pImage->pszFilename);
             }
         }