Changeset 38469 in vbox for trunk/src/VBox/Main/src-server

Timestamp:

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

Author:

vboxsync

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.

Location:

trunk/src/VBox/Main/src-server

Files:

• ApplianceImplExport.cpp (modified) (8 diffs)
• ApplianceImplIO.cpp (modified) (29 diffs)
• ApplianceImplImport.cpp (modified) (10 diffs)
• MediumImpl.cpp (modified) (14 diffs)

trunk/src/VBox/Main/src-server/ApplianceImplExport.cpp

@@ -1676 +1676 @@
     HRESULT rc = S_OK;
 
-    PVDINTERFACEIO pSha1Callbacks = 0;
-    PVDINTERFACEIO pTarCallbacks = 0;
+    PVDINTERFACEIO pSha1Io = 0;
+    PVDINTERFACEIO pTarIo = 0;
     do
     {
-        pSha1Callbacks = Sha1CreateInterface();
-        if (!pSha1Callbacks)
+        pSha1Io = Sha1CreateInterface();
+        if (!pSha1Io)
         {
             rc = E_OUTOFMEMORY;
             break;
         }
-        pTarCallbacks = TarCreateInterface();
-        if (!pTarCallbacks)
+        pTarIo = TarCreateInterface();
+        if (!pTarIo)
         {
             rc = E_OUTOFMEMORY;
             break;
         }
-        VDINTERFACE VDInterfaceIO;
         SHA1STORAGE storage;
         RT_ZERO(storage);
         storage.fCreateDigest = m->fManifest;
-        vrc = VDInterfaceAdd(&VDInterfaceIO, "Appliance::IOTar",
-                             VDINTERFACETYPE_IO, pTarCallbacks,
-                             tar, &storage.pVDImageIfaces);
+        vrc = VDInterfaceAdd(&pTarIo->Core, "Appliance::IOTar",
+                             VDINTERFACETYPE_IO, tar, sizeof(VDINTERFACEIO),
+                             &storage.pVDImageIfaces);
         if (RT_FAILURE(vrc))
         {
@@ -1704 +1703 @@
             break;
         }
-        rc = writeFSImpl(pTask, writeLock, pSha1Callbacks, &storage);
+        rc = writeFSImpl(pTask, writeLock, pSha1Io, &storage);
     }while(0);
 
@@ -1710 +1709 @@
 
     /* Cleanup */
-    if (pSha1Callbacks)
-        RTMemFree(pSha1Callbacks);
-    if (pTarCallbacks)
-        RTMemFree(pTarCallbacks);
+    if (pSha1Io)
+        RTMemFree(pSha1Io);
+    if (pTarIo)
+        RTMemFree(pTarIo);
 
     /* Delete ova file on error */
@@ -1723 +1722 @@
 }
 
-HRESULT Appliance::writeFSImpl(TaskOVF *pTask, AutoWriteLockBase& writeLock, PVDINTERFACEIO pCallbacks, PSHA1STORAGE pStorage)
+HRESULT Appliance::writeFSImpl(TaskOVF *pTask, AutoWriteLockBase& writeLock, PVDINTERFACEIO pIfIo, PSHA1STORAGE pStorage)
 {
     LogFlowFuncEnter();
@@ -1755 +1754 @@
                                strOvfFile.c_str());
             /* Write the ovf file to disk. */
-            vrc = Sha1WriteBuf(strOvfFile.c_str(), pvBuf, cbSize, pCallbacks, pStorage);
+            vrc = Sha1WriteBuf(strOvfFile.c_str(), pvBuf, cbSize, pIfIo, pStorage);
             if (RT_FAILURE(vrc))
                 throw setError(VBOX_E_FILE_ERROR,
@@ -1825 +1824 @@
 
                 // create a flat copy of the source disk image
-                rc = pSourceDisk->exportFile(strTargetFilePath.c_str(), format, MediumVariant_VmdkStreamOptimized, pCallbacks, pStorage, pProgress2);
+                rc = pSourceDisk->exportFile(strTargetFilePath.c_str(), format, MediumVariant_VmdkStreamOptimized, pIfIo, pStorage, pProgress2);
                 if (FAILED(rc)) throw rc;
 
@@ -1872 +1871 @@
             pStorage->fCreateDigest = false;
             /* Write the manifest file to disk. */
-            vrc = Sha1WriteBuf(strMfFilePath.c_str(), pvBuf, cbSize, pCallbacks, pStorage);
+            vrc = Sha1WriteBuf(strMfFilePath.c_str(), pvBuf, cbSize, pIfIo, pStorage);
             RTMemFree(pvBuf);
             if (RT_FAILURE(vrc))
@@ -1897 +1896 @@
              it1 != fileList.end();
              ++it1)
-             pCallbacks->pfnDelete(pStorage, (*it1).first.c_str());
+             pIfIo->pfnDelete(pStorage, (*it1).first.c_str());
     }
 

trunk/src/VBox/Main/src-server/ApplianceImplIO.cpp

@@ -468 +468 @@
     PSHA1STORAGEINTERNAL pInt = (PSHA1STORAGEINTERNAL)pvUser;
 
-    PVDINTERFACE pIO = VDInterfaceGet(pInt->pSha1Storage->pVDImageIfaces, VDINTERFACETYPE_IO);
-    AssertPtrReturn(pIO, VERR_INVALID_PARAMETER);
-    PVDINTERFACEIO pCallbacks = VDGetInterfaceIO(pIO);
-    AssertPtrReturn(pCallbacks, VERR_INVALID_PARAMETER);
+    PVDINTERFACEIO pIfIo = VDIfIoGet(pInt->pSha1Storage->pVDImageIfaces);
+    AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
 
     int rc = VINF_SUCCESS;
@@ -518 +516 @@
                         size_t cbToWrite = cbMemRead - cbAllWritten;
                         size_t cbWritten = 0;
-                        rc = pCallbacks->pfnWriteSync(pIO->pvUser, pInt->pvStorage, pInt->cbCurFile, &pcBuf[cbAllWritten], cbToWrite, &cbWritten);
+                        rc = vdIfIoFileWriteSync(pIfIo, pInt->pvStorage, pInt->cbCurFile, &pcBuf[cbAllWritten], cbToWrite, &cbWritten);
 //                        RTPrintf ("%lu %lu %lu %Rrc\n", pInt->cbCurFile, cbToRead, cbRead, rc);
                         if (RT_FAILURE(rc))
@@ -570 +568 @@
                         size_t cbToRead = cbMemWrite - cbAllRead;
                         size_t cbRead = 0;
-                        rc = pCallbacks->pfnReadSync(pIO->pvUser, pInt->pvStorage, pInt->cbCurFile, &pcBuf[cbAllRead], cbToRead, &cbRead);
+                        rc = vdIfIoFileReadSync(pIfIo, pInt->pvStorage, pInt->cbCurFile, &pcBuf[cbAllRead], cbToRead, &cbRead);
 //                        RTPrintf ("%lu %lu %lu %Rrc\n", pInt->cbCurFile, cbToRead, cbRead, rc);
                         if (RT_FAILURE(rc))
@@ -670 +668 @@
 
     PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
-    PVDINTERFACE pIO = VDInterfaceGet(pSha1Storage->pVDImageIfaces, VDINTERFACETYPE_IO);
-    AssertPtrReturn(pIO, VERR_INVALID_PARAMETER);
-    PVDINTERFACEIO pCallbacks = VDGetInterfaceIO(pIO);
-    AssertPtrReturn(pCallbacks, VERR_INVALID_PARAMETER);
+    PVDINTERFACEIO pIfIo = VDIfIoGet(pSha1Storage->pVDImageIfaces);
+    AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
 
     DEBUG_PRINT_FLOW();
@@ -729 +725 @@
 
         /* Open the file. */
-        rc = pCallbacks->pfnOpen(pIO->pvUser, pszLocation,
-                                 fOpen, pInt->pfnCompleted,
-                                 &pInt->pvStorage);
+        rc = vdIfIoFileOpen(pIfIo, pszLocation, fOpen, pInt->pfnCompleted,
+                            &pInt->pvStorage);
         if (RT_FAILURE(rc))
             break;
@@ -773 +768 @@
 
     PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
-    PVDINTERFACE pIO = VDInterfaceGet(pSha1Storage->pVDImageIfaces, VDINTERFACETYPE_IO);
-    AssertPtrReturn(pIO, VERR_INVALID_PARAMETER);
-    PVDINTERFACEIO pCallbacks = VDGetInterfaceIO(pIO);
-    AssertPtrReturn(pCallbacks, VERR_INVALID_PARAMETER);
+    PVDINTERFACEIO pIfIo = VDIfIoGet(pSha1Storage->pVDImageIfaces);
+    AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
 
     PSHA1STORAGEINTERNAL pInt = (PSHA1STORAGEINTERNAL)pvStorage;
@@ -813 +806 @@
 
     /* Close the file */
-    rc = pCallbacks->pfnClose(pIO->pvUser, pInt->pvStorage);
+    rc = vdIfIoFileClose(pIfIo, pInt->pvStorage);
 
 //    RTPrintf("%lu %lu\n", pInt->calls, pInt->waits);
@@ -837 +830 @@
 
     PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
-    PVDINTERFACE pIO = VDInterfaceGet(pSha1Storage->pVDImageIfaces, VDINTERFACETYPE_IO);
-    AssertPtrReturn(pIO, VERR_INVALID_PARAMETER);
-    PVDINTERFACEIO pCallbacks = VDGetInterfaceIO(pIO);
-    AssertPtrReturn(pCallbacks, VERR_INVALID_PARAMETER);
-
-    DEBUG_PRINT_FLOW();
-
-    return pCallbacks->pfnDelete(pIO->pvUser, pcszFilename);
+    PVDINTERFACEIO pIfIo = VDIfIoGet(pSha1Storage->pVDImageIfaces);
+    AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
+
+    DEBUG_PRINT_FLOW();
+
+    return vdIfIoFileDelete(pIfIo, pcszFilename);
 }
 
@@ -853 +844 @@
 
     PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
-    PVDINTERFACE pIO = VDInterfaceGet(pSha1Storage->pVDImageIfaces, VDINTERFACETYPE_IO);
-    AssertPtrReturn(pIO, VERR_INVALID_PARAMETER);
-    PVDINTERFACEIO pCallbacks = VDGetInterfaceIO(pIO);
-    AssertPtrReturn(pCallbacks, VERR_INVALID_PARAMETER);
-
-    DEBUG_PRINT_FLOW();
-
-    return pCallbacks->pfnMove(pIO->pvUser, pcszSrc, pcszDst, fMove);
+    PVDINTERFACEIO pIfIo = VDIfIoGet(pSha1Storage->pVDImageIfaces);
+    AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
+
+
+    DEBUG_PRINT_FLOW();
+
+    return vdIfIoFileMove(pIfIo, pcszSrc, pcszDst, fMove);
 }
 
@@ -869 +859 @@
 
     PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
-    PVDINTERFACE pIO = VDInterfaceGet(pSha1Storage->pVDImageIfaces, VDINTERFACETYPE_IO);
-    AssertPtrReturn(pIO, VERR_INVALID_PARAMETER);
-    PVDINTERFACEIO pCallbacks = VDGetInterfaceIO(pIO);
-    AssertPtrReturn(pCallbacks, VERR_INVALID_PARAMETER);
-
-    DEBUG_PRINT_FLOW();
-
-    return pCallbacks->pfnGetFreeSpace(pIO->pvUser, pcszFilename, pcbFreeSpace);
+    PVDINTERFACEIO pIfIo = VDIfIoGet(pSha1Storage->pVDImageIfaces);
+    AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
+
+    DEBUG_PRINT_FLOW();
+
+    return vdIfIoFileGetFreeSpace(pIfIo, pcszFilename, pcbFreeSpace);
 }
 
@@ -885 +873 @@
 
     PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
-    PVDINTERFACE pIO = VDInterfaceGet(pSha1Storage->pVDImageIfaces, VDINTERFACETYPE_IO);
-    AssertPtrReturn(pIO, VERR_INVALID_PARAMETER);
-    PVDINTERFACEIO pCallbacks = VDGetInterfaceIO(pIO);
-    AssertPtrReturn(pCallbacks, VERR_INVALID_PARAMETER);
-
-    DEBUG_PRINT_FLOW();
-
-    return pCallbacks->pfnGetModificationTime(pIO->pvUser, pcszFilename, pModificationTime);
+    PVDINTERFACEIO pIfIo = VDIfIoGet(pSha1Storage->pVDImageIfaces);
+    AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
+
+    DEBUG_PRINT_FLOW();
+
+    return vdIfIoFileGetModificationTime(pIfIo, pcszFilename, pModificationTime);
 }
 
@@ -903 +889 @@
 
     PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
-    PVDINTERFACE pIO = VDInterfaceGet(pSha1Storage->pVDImageIfaces, VDINTERFACETYPE_IO);
-    AssertPtrReturn(pIO, VERR_INVALID_PARAMETER);
-    PVDINTERFACEIO pCallbacks = VDGetInterfaceIO(pIO);
-    AssertPtrReturn(pCallbacks, VERR_INVALID_PARAMETER);
+    PVDINTERFACEIO pIfIo = VDIfIoGet(pSha1Storage->pVDImageIfaces);
+    AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
 
     PSHA1STORAGEINTERNAL pInt = (PSHA1STORAGEINTERNAL)pvStorage;
@@ -913 +897 @@
 
     uint64_t cbSize;
-    int rc = pCallbacks->pfnGetSize(pIO->pvUser, pInt->pvStorage, &cbSize);
+    int rc = vdIfIoFileGetSize(pIfIo, pInt->pvStorage, &cbSize);
     if (RT_FAILURE(rc))
         return rc;
@@ -929 +913 @@
 
     PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
-    PVDINTERFACE pIO = VDInterfaceGet(pSha1Storage->pVDImageIfaces, VDINTERFACETYPE_IO);
-    AssertPtrReturn(pIO, VERR_INVALID_PARAMETER);
-    PVDINTERFACEIO pCallbacks = VDGetInterfaceIO(pIO);
-    AssertPtrReturn(pCallbacks, VERR_INVALID_PARAMETER);
+    PVDINTERFACEIO pIfIo = VDIfIoGet(pSha1Storage->pVDImageIfaces);
+    AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
 
     PSHA1STORAGEINTERNAL pInt = (PSHA1STORAGEINTERNAL)pvStorage;
@@ -938 +920 @@
     DEBUG_PRINT_FLOW();
 
-    return pCallbacks->pfnSetSize(pIO->pvUser, pInt->pvStorage, cbSize);
+    return vdIfIoFileSetSize(pIfIo, pInt->pvStorage, cbSize);
 }
 
@@ -949 +931 @@
 
     PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
-    PVDINTERFACE pIO = VDInterfaceGet(pSha1Storage->pVDImageIfaces, VDINTERFACETYPE_IO);
-    AssertPtrReturn(pIO, VERR_INVALID_PARAMETER);
-    PVDINTERFACEIO pCallbacks = VDGetInterfaceIO(pIO);
-    AssertPtrReturn(pCallbacks, VERR_INVALID_PARAMETER);
+    PVDINTERFACEIO pIfIo = VDIfIoGet(pSha1Storage->pVDImageIfaces);
+    AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
 
     PSHA1STORAGEINTERNAL pInt = (PSHA1STORAGEINTERNAL)pvStorage;
@@ -977 +957 @@
             size_t cbWritten = 0;
             rc = sha1WriteSyncCallback(pvUser, pvStorage, pInt->cbCurAll,
-                                         pInt->pvZeroBuf, cbToWrite, &cbWritten);
+                                       pInt->pvZeroBuf, cbToWrite, &cbWritten);
             if (RT_FAILURE(rc))
                 break;
@@ -1046 +1026 @@
 
     PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
-    PVDINTERFACE pIO = VDInterfaceGet(pSha1Storage->pVDImageIfaces, VDINTERFACETYPE_IO);
-    AssertPtrReturn(pIO, VERR_INVALID_PARAMETER);
-    PVDINTERFACEIO pCallbacks = VDGetInterfaceIO(pIO);
-    AssertPtrReturn(pCallbacks, VERR_INVALID_PARAMETER);
+    PVDINTERFACEIO pIfIo = VDIfIoGet(pSha1Storage->pVDImageIfaces);
+    AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
 
 //    DEBUG_PRINT_FLOW();
@@ -1135 +1113 @@
 
     PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
-    PVDINTERFACE pIO = VDInterfaceGet(pSha1Storage->pVDImageIfaces, VDINTERFACETYPE_IO);
-    AssertPtrReturn(pIO, VERR_INVALID_PARAMETER);
-    PVDINTERFACEIO pCallbacks = VDGetInterfaceIO(pIO);
-    AssertPtrReturn(pCallbacks, VERR_INVALID_PARAMETER);
+    PVDINTERFACEIO pIfIo = VDIfIoGet(pSha1Storage->pVDImageIfaces);
+    AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
 
     DEBUG_PRINT_FLOW();
@@ -1149 +1125 @@
         return rc;
 
-    return pCallbacks->pfnFlushSync(pIO->pvUser, pInt->pvStorage);
+    return vdIfIoFileFlushSync(pIfIo, pInt->pvStorage);
 }
 
@@ -1162 +1138 @@
         return NULL;
 
-    pCallbacks->cbSize                 = sizeof(VDINTERFACEIO);
-    pCallbacks->enmInterface           = VDINTERFACETYPE_IO;
     pCallbacks->pfnOpen                = sha1OpenCallback;
     pCallbacks->pfnClose               = sha1CloseCallback;
@@ -1185 +1159 @@
         return NULL;
 
-    pCallbacks->cbSize                 = sizeof(VDINTERFACEIO);
-    pCallbacks->enmInterface           = VDINTERFACETYPE_IO;
     pCallbacks->pfnOpen                = fileOpenCallback;
     pCallbacks->pfnClose               = fileCloseCallback;
@@ -1208 +1180 @@
         return NULL;
 
-    pCallbacks->cbSize                 = sizeof(VDINTERFACEIO);
-    pCallbacks->enmInterface           = VDINTERFACETYPE_IO;
     pCallbacks->pfnOpen                = tarOpenCallback;
     pCallbacks->pfnClose               = tarCloseCallback;
@@ -1225 +1195 @@
 }
 
-int Sha1ReadBuf(const char *pcszFilename, void **ppvBuf, size_t *pcbSize, PVDINTERFACEIO pCallbacks, void *pvUser)
+int Sha1ReadBuf(const char *pcszFilename, void **ppvBuf, size_t *pcbSize, PVDINTERFACEIO pIfIo, void *pvUser)
 {
     /* Validate input. */
     AssertPtrReturn(ppvBuf, VERR_INVALID_POINTER);
     AssertPtrReturn(pcbSize, VERR_INVALID_POINTER);
-    AssertPtrReturn(pCallbacks, VERR_INVALID_POINTER);
+    AssertPtrReturn(pIfIo, VERR_INVALID_POINTER);
 
     void *pvStorage;
-    int rc = pCallbacks->pfnOpen(pvUser, pcszFilename,
-                                 RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_NONE, 0,
-                                 &pvStorage);
+    int rc = pIfIo->pfnOpen(pvUser, pcszFilename,
+                            RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_NONE, 0,
+                            &pvStorage);
     if (RT_FAILURE(rc))
         return rc;
@@ -1255 +1225 @@
         {
             size_t cbRead = 0;
-            rc = pCallbacks->pfnReadSync(pvUser, pvStorage, cbAllRead, pvTmpBuf, cbTmpSize, &cbRead);
+            rc = pIfIo->pfnReadSync(pvUser, pvStorage, cbAllRead, pvTmpBuf, cbTmpSize, &cbRead);
             if (   RT_FAILURE(rc)
                 || cbRead == 0)
@@ -1270 +1240 @@
     }while(0);
 
-    pCallbacks->pfnClose(pvUser, pvStorage);
+    pIfIo->pfnClose(pvUser, pvStorage);
 
     if (rc == VERR_EOF)
@@ -1291 +1261 @@
 }
 
-int Sha1WriteBuf(const char *pcszFilename, void *pvBuf, size_t cbSize, PVDINTERFACEIO pCallbacks, void *pvUser)
+int Sha1WriteBuf(const char *pcszFilename, void *pvBuf, size_t cbSize, PVDINTERFACEIO pIfIo, void *pvUser)
 {
     /* Validate input. */
     AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
     AssertReturn(cbSize, VERR_INVALID_PARAMETER);
-    AssertPtrReturn(pCallbacks, VERR_INVALID_POINTER);
+    AssertPtrReturn(pIfIo, VERR_INVALID_POINTER);
 
     void *pvStorage;
-    int rc = pCallbacks->pfnOpen(pvUser, pcszFilename,
-                                 RTFILE_O_CREATE | RTFILE_O_WRITE | RTFILE_O_DENY_ALL, 0,
-                                 &pvStorage);
+    int rc = pIfIo->pfnOpen(pvUser, pcszFilename,
+                            RTFILE_O_CREATE | RTFILE_O_WRITE | RTFILE_O_DENY_ALL, 0,
+                            &pvStorage);
     if (RT_FAILURE(rc))
         return rc;
@@ -1312 +1282 @@
         size_t cbToWrite = cbSize - cbAllWritten;
         size_t cbWritten = 0;
-        rc = pCallbacks->pfnWriteSync(pvUser, pvStorage, cbAllWritten, &((char*)pvBuf)[cbAllWritten], cbToWrite, &cbWritten);
+        rc = pIfIo->pfnWriteSync(pvUser, pvStorage, cbAllWritten, &((char*)pvBuf)[cbAllWritten], cbToWrite, &cbWritten);
         if (RT_FAILURE(rc))
             break;
@@ -1318 +1288 @@
     }
 
-    pCallbacks->pfnClose(pvUser, pvStorage);
+    pIfIo->pfnClose(pvUser, pvStorage);
 
     return rc;

trunk/src/VBox/Main/src-server/ApplianceImplImport.cpp

@@ -870 +870 @@
     HRESULT rc = S_OK;
 
-    PVDINTERFACEIO pSha1Callbacks = 0;
-    PVDINTERFACEIO pTarCallbacks = 0;
+    PVDINTERFACEIO pSha1Io = 0;
+    PVDINTERFACEIO pTarIo = 0;
     char *pszFilename = 0;
     do
@@ -881 +881 @@
             break;
         }
-        pSha1Callbacks = Sha1CreateInterface();
-        if (!pSha1Callbacks)
+        pSha1Io = Sha1CreateInterface();
+        if (!pSha1Io)
         {
             rc = E_OUTOFMEMORY;
             break;
         }
-        pTarCallbacks = TarCreateInterface();
-        if (!pTarCallbacks)
+        pTarIo = TarCreateInterface();
+        if (!pTarIo)
         {
             rc = E_OUTOFMEMORY;
             break;
         }
-        VDINTERFACE VDInterfaceIO;
         SHA1STORAGE storage;
         RT_ZERO(storage);
-        vrc = VDInterfaceAdd(&VDInterfaceIO, "Appliance::IOTar",
-                             VDINTERFACETYPE_IO, pTarCallbacks,
-                             tar, &storage.pVDImageIfaces);
+        vrc = VDInterfaceAdd(&pTarIo->Core, "Appliance::IOTar",
+                             VDINTERFACETYPE_IO, tar, sizeof(VDINTERFACEIO),
+                             &storage.pVDImageIfaces);
         if (RT_FAILURE(vrc))
         {
@@ -904 +903 @@
             break;
         }
-        rc = readFSImpl(pTask, pszFilename, pSha1Callbacks, &storage);
+        rc = readFSImpl(pTask, pszFilename, pSha1Io, &storage);
     }while(0);
 
@@ -912 +911 @@
     if (pszFilename)
         RTMemFree(pszFilename);
-    if (pSha1Callbacks)
-        RTMemFree(pSha1Callbacks);
-    if (pTarCallbacks)
-        RTMemFree(pTarCallbacks);
+    if (pSha1Io)
+        RTMemFree(pSha1Io);
+    if (pTarIo)
+        RTMemFree(pTarIo);
 
     LogFlowFunc(("rc=%Rhrc\n", rc));
@@ -923 +922 @@
 }
 
-HRESULT Appliance::readFSImpl(TaskOVF *pTask, const RTCString &strFilename, PVDINTERFACEIO pCallbacks, PSHA1STORAGE pStorage)
+HRESULT Appliance::readFSImpl(TaskOVF *pTask, const RTCString &strFilename, PVDINTERFACEIO pIfIo, PSHA1STORAGE pStorage)
 {
     LogFlowFuncEnter();
@@ -936 +935 @@
         /* Read the OVF into a memory buffer */
         size_t cbSize = 0;
-        int vrc = Sha1ReadBuf(strFilename.c_str(), &pvTmpBuf, &cbSize, pCallbacks, pStorage);
+        int vrc = Sha1ReadBuf(strFilename.c_str(), &pvTmpBuf, &cbSize, pIfIo, pStorage);
         if (   RT_FAILURE(vrc)
             || !pvTmpBuf)
@@ -1307 +1306 @@
     HRESULT rc = S_OK;
 
-    PVDINTERFACEIO pSha1Callbacks = 0;
-    PVDINTERFACEIO pTarCallbacks = 0;
+    PVDINTERFACEIO pSha1Io = 0;
+    PVDINTERFACEIO pTarIo = 0;
     char *pszFilename = 0;
     void *pvMfBuf = 0;
@@ -1315 +1314 @@
     {
         /* Create the necessary file access interfaces. */
-        pSha1Callbacks = Sha1CreateInterface();
-        if (!pSha1Callbacks)
+        pSha1Io = Sha1CreateInterface();
+        if (!pSha1Io)
             throw E_OUTOFMEMORY;
-        pTarCallbacks = TarCreateInterface();
-        if (!pTarCallbacks)
+        pTarIo = TarCreateInterface();
+        if (!pTarIo)
             throw E_OUTOFMEMORY;
 
-        VDINTERFACE VDInterfaceIO;
         SHA1STORAGE storage;
         RT_ZERO(storage);
-        vrc = VDInterfaceAdd(&VDInterfaceIO, "Appliance::IOTar",
-                             VDINTERFACETYPE_IO, pTarCallbacks,
-                             tar, &storage.pVDImageIfaces);
+        vrc = VDInterfaceAdd(&pTarIo->Core, "Appliance::IOTar",
+                             VDINTERFACETYPE_IO, tar, sizeof(VDINTERFACEIO),
+                             &storage.pVDImageIfaces);
         if (RT_FAILURE(vrc))
             throw setError(E_FAIL,
@@ -1345 +1343 @@
                            tr("Internal error (%Rrc)"), vrc);
 
-        PVDINTERFACEIO pCallbacks = pSha1Callbacks;
+        PVDINTERFACEIO pCallbacks = pSha1Io;
         PSHA1STORAGE pStorage = &storage;
 
@@ -1400 +1398 @@
     if (pvMfBuf)
         RTMemFree(pvMfBuf);
-    if (pSha1Callbacks)
-        RTMemFree(pSha1Callbacks);
-    if (pTarCallbacks)
-        RTMemFree(pTarCallbacks);
+    if (pSha1Io)
+        RTMemFree(pSha1Io);
+    if (pTarIo)
+        RTMemFree(pTarIo);
 
     LogFlowFunc(("rc=%Rhrc\n", rc));

trunk/src/VBox/Main/src-server/MediumImpl.cpp

@@ -153 +153 @@
     Utf8Str vdError;        /*< Error remembered by the VD error callback. */
 
-    VDINTERFACE vdIfError;
-    VDINTERFACEERROR vdIfCallsError;
-
-    VDINTERFACE vdIfConfig;
-    VDINTERFACECONFIG vdIfCallsConfig;
-
-    VDINTERFACE vdIfTcpNet;
-    VDINTERFACETCPNET vdIfCallsTcpNet;
+    VDINTERFACEERROR vdIfError;
+
+    VDINTERFACECONFIG vdIfConfig;
+
+    VDINTERFACETCPNET vdIfTcpNet;
 
     PVDINTERFACE vdDiskIfaces;
@@ -214 +211 @@
         /* Set up a per-operation progress interface, can be used freely (for
          * binary operations you can use it either on the source or target). */
-        mVDIfCallsProgress.cbSize = sizeof(VDINTERFACEPROGRESS);
-        mVDIfCallsProgress.enmInterface = VDINTERFACETYPE_PROGRESS;
-        mVDIfCallsProgress.pfnProgress = vdProgressCall;
-        int vrc = VDInterfaceAdd(&mVDIfProgress,
+        mVDIfProgress.pfnProgress = vdProgressCall;
+        int vrc = VDInterfaceAdd(&mVDIfProgress.Core,
                                 "Medium::Task::vdInterfaceProgress",
                                 VDINTERFACETYPE_PROGRESS,
-                                &mVDIfCallsProgress,
                                 mProgress,
+                                sizeof(VDINTERFACEPROGRESS),
                                 &mVDOperationIfaces);
         AssertRC(vrc);
@@ -262 +257 @@
     static DECLCALLBACK(int) vdProgressCall(void *pvUser, unsigned uPercent);
 
-    VDINTERFACE mVDIfProgress;
-    VDINTERFACEPROGRESS mVDIfCallsProgress;
+    VDINTERFACEPROGRESS mVDIfProgress;
 
     /* Must have a strong VirtualBox reference during a task otherwise the
@@ -591 +585 @@
                MediumFormat *aFormat,
                MediumVariant_T aVariant,
-               void *aVDImageIOCallbacks,
+               VDINTERFACEIO *aVDImageIOIf,
                void *aVDImageIOUser,
                MediumLockList *aSourceMediumLockList,
@@ -605 +599 @@
 
         mVDImageIfaces = aMedium->m->vdImageIfaces;
-        if (aVDImageIOCallbacks)
-        {
-            int vrc = VDInterfaceAdd(&mVDInterfaceIO, "Medium::vdInterfaceIO",
-                                     VDINTERFACETYPE_IO, aVDImageIOCallbacks,
-                                     aVDImageIOUser, &mVDImageIfaces);
+        if (aVDImageIOIf)
+        {
+            int vrc = VDInterfaceAdd(&aVDImageIOIf->Core, "Medium::vdInterfaceIO",
+                                     VDINTERFACETYPE_IO, aVDImageIOUser,
+                                     sizeof(VDINTERFACEIO), &mVDImageIfaces);
             AssertRCReturnVoidStmt(vrc, mRC = E_FAIL);
         }
@@ -630 +624 @@
 
     bool mfKeepSourceMediumLockList;
-    VDINTERFACE mVDInterfaceIO;
 };
 
@@ -641 +634 @@
                MediumFormat *aFormat,
                MediumVariant_T aVariant,
-               void *aVDImageIOCallbacks,
+               VDINTERFACEIO *aVDImageIOIf,
                void *aVDImageIOUser,
                Medium *aParent,
@@ -662 +655 @@
 
         mVDImageIfaces = aMedium->m->vdImageIfaces;
-        if (aVDImageIOCallbacks)
-        {
-            int vrc = VDInterfaceAdd(&mVDInterfaceIO, "Medium::vdInterfaceIO",
-                                     VDINTERFACETYPE_IO, aVDImageIOCallbacks,
-                                     aVDImageIOUser, &mVDImageIfaces);
+        if (aVDImageIOIf)
+        {
+            int vrc = VDInterfaceAdd(&aVDImageIOIf->Core, "Medium::vdInterfaceIO",
+                                     VDINTERFACETYPE_IO, aVDImageIOUser,
+                                     sizeof(VDINTERFACEIO), &mVDImageIfaces);
             AssertRCReturnVoidStmt(vrc, mRC = E_FAIL);
         }
@@ -689 +682 @@
     AutoCaller mParentCaller;
     bool mfKeepTargetMediumLockList;
-    VDINTERFACE mVDInterfaceIO;
 };
 
@@ -846 +838 @@
 
     /* Initialize the callbacks of the VD error interface */
-    m->vdIfCallsError.cbSize = sizeof(VDINTERFACEERROR);
-    m->vdIfCallsError.enmInterface = VDINTERFACETYPE_ERROR;
-    m->vdIfCallsError.pfnError = vdErrorCall;
-    m->vdIfCallsError.pfnMessage = NULL;
+    m->vdIfError.pfnError = vdErrorCall;
+    m->vdIfError.pfnMessage = NULL;
 
     /* Initialize the callbacks of the VD config interface */
-    m->vdIfCallsConfig.cbSize = sizeof(VDINTERFACECONFIG);
-    m->vdIfCallsConfig.enmInterface = VDINTERFACETYPE_CONFIG;
-    m->vdIfCallsConfig.pfnAreKeysValid = vdConfigAreKeysValid;
-    m->vdIfCallsConfig.pfnQuerySize = vdConfigQuerySize;
-    m->vdIfCallsConfig.pfnQuery = vdConfigQuery;
+    m->vdIfConfig.pfnAreKeysValid = vdConfigAreKeysValid;
+    m->vdIfConfig.pfnQuerySize = vdConfigQuerySize;
+    m->vdIfConfig.pfnQuery = vdConfigQuery;
 
     /* Initialize the callbacks of the VD TCP interface (we always use the host
      * IP stack for now) */
-    m->vdIfCallsTcpNet.cbSize = sizeof(VDINTERFACETCPNET);
-    m->vdIfCallsTcpNet.enmInterface = VDINTERFACETYPE_TCPNET;
-    m->vdIfCallsTcpNet.pfnSocketCreate = vdTcpSocketCreate;
-    m->vdIfCallsTcpNet.pfnSocketDestroy = vdTcpSocketDestroy;
-    m->vdIfCallsTcpNet.pfnClientConnect = vdTcpClientConnect;
-    m->vdIfCallsTcpNet.pfnClientClose = vdTcpClientClose;
-    m->vdIfCallsTcpNet.pfnIsClientConnected = vdTcpIsClientConnected;
-    m->vdIfCallsTcpNet.pfnSelectOne = vdTcpSelectOne;
-    m->vdIfCallsTcpNet.pfnRead = vdTcpRead;
-    m->vdIfCallsTcpNet.pfnWrite = vdTcpWrite;
-    m->vdIfCallsTcpNet.pfnSgWrite = vdTcpSgWrite;
-    m->vdIfCallsTcpNet.pfnFlush = vdTcpFlush;
-    m->vdIfCallsTcpNet.pfnSetSendCoalescing = vdTcpSetSendCoalescing;
-    m->vdIfCallsTcpNet.pfnGetLocalAddress = vdTcpGetLocalAddress;
-    m->vdIfCallsTcpNet.pfnGetPeerAddress = vdTcpGetPeerAddress;
-    m->vdIfCallsTcpNet.pfnSelectOneEx = NULL;
-    m->vdIfCallsTcpNet.pfnPoke = NULL;
+    m->vdIfTcpNet.pfnSocketCreate = vdTcpSocketCreate;
+    m->vdIfTcpNet.pfnSocketDestroy = vdTcpSocketDestroy;
+    m->vdIfTcpNet.pfnClientConnect = vdTcpClientConnect;
+    m->vdIfTcpNet.pfnClientClose = vdTcpClientClose;
+    m->vdIfTcpNet.pfnIsClientConnected = vdTcpIsClientConnected;
+    m->vdIfTcpNet.pfnSelectOne = vdTcpSelectOne;
+    m->vdIfTcpNet.pfnRead = vdTcpRead;
+    m->vdIfTcpNet.pfnWrite = vdTcpWrite;
+    m->vdIfTcpNet.pfnSgWrite = vdTcpSgWrite;
+    m->vdIfTcpNet.pfnFlush = vdTcpFlush;
+    m->vdIfTcpNet.pfnSetSendCoalescing = vdTcpSetSendCoalescing;
+    m->vdIfTcpNet.pfnGetLocalAddress = vdTcpGetLocalAddress;
+    m->vdIfTcpNet.pfnGetPeerAddress = vdTcpGetPeerAddress;
+    m->vdIfTcpNet.pfnSelectOneEx = NULL;
+    m->vdIfTcpNet.pfnPoke = NULL;
 
     /* Initialize the per-disk interface chain (could be done more globally,
      * but it's not wasting much time or space so it's not worth it). */
     int vrc;
-    vrc = VDInterfaceAdd(&m->vdIfError,
+    vrc = VDInterfaceAdd(&m->vdIfError.Core,
                          "Medium::vdInterfaceError",
-                         VDINTERFACETYPE_ERROR,
-                         &m->vdIfCallsError, this, &m->vdDiskIfaces);
+                         VDINTERFACETYPE_ERROR, this,
+                         sizeof(VDINTERFACEERROR), &m->vdDiskIfaces);
     AssertRCReturn(vrc, E_FAIL);
 
     /* Initialize the per-image interface chain */
-    vrc = VDInterfaceAdd(&m->vdIfConfig,
+    vrc = VDInterfaceAdd(&m->vdIfConfig.Core,
                          "Medium::vdInterfaceConfig",
-                         VDINTERFACETYPE_CONFIG,
-                         &m->vdIfCallsConfig, this, &m->vdImageIfaces);
+                         VDINTERFACETYPE_CONFIG, this,
+                         sizeof(VDINTERFACECONFIG), &m->vdImageIfaces);
     AssertRCReturn(vrc, E_FAIL);
 
-    vrc = VDInterfaceAdd(&m->vdIfTcpNet,
+    vrc = VDInterfaceAdd(&m->vdIfTcpNet.Core,
                          "Medium::vdInterfaceTcpNet",
-                         VDINTERFACETYPE_TCPNET,
-                         &m->vdIfCallsTcpNet, this, &m->vdImageIfaces);
+                         VDINTERFACETYPE_TCPNET, this,
+                         sizeof(VDINTERFACETCPNET), &m->vdImageIfaces);
     AssertRCReturn(vrc, E_FAIL);
 
@@ -4952 +4938 @@
                            const ComObjPtr<MediumFormat> &aFormat,
                            MediumVariant_T aVariant,
-                           void *aVDImageIOCallbacks, void *aVDImageIOUser,
+                           PVDINTERFACEIO aVDImageIOIf, void *aVDImageIOUser,
                            const ComObjPtr<Progress> &aProgress)
 {
@@ -4995 +4981 @@
         /* setup task object to carry out the operation asynchronously */
         pTask = new Medium::ExportTask(this, aProgress, aFilename, aFormat,
-                                       aVariant, aVDImageIOCallbacks,
+                                       aVariant, aVDImageIOIf,
                                        aVDImageIOUser, pSourceMediumLockList);
         rc = pTask->rc();
@@ -5030 +5016 @@
                            const ComObjPtr<MediumFormat> &aFormat,
                            MediumVariant_T aVariant,
-                           void *aVDImageIOCallbacks, void *aVDImageIOUser,
+                           PVDINTERFACEIO aVDImageIOIf, void *aVDImageIOUser,
                            const ComObjPtr<Medium> &aParent,
                            const ComObjPtr<Progress> &aProgress)
@@ -5078 +5064 @@
         /* setup task object to carry out the operation asynchronously */
         pTask = new Medium::ImportTask(this, aProgress, aFilename, aFormat,
-                                       aVariant, aVDImageIOCallbacks,
+                                       aVariant, aVDImageIOIf,
                                        aVDImageIOUser, aParent,
                                        pTargetMediumLockList);