VirtualBox

Changeset 32691 in vbox


Ignore:
Timestamp:
Sep 22, 2010 10:09:54 AM (14 years ago)
Author:
vboxsync
Message:

Storage/VBoxHDD+iSCSI+DrvVD,Main/Medium: Make the IO and TCPNET interfaces per i
mage, fix comments, remove forgotten dead code, handle disk and image interfaces

separately in Medium, whitespace cleanup

Location:
trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/VBoxHDD.h

    r32553 r32691  
    253253    /** Interface to pass error message to upper layers. Per-disk. */
    254254    VDINTERFACETYPE_ERROR = VDINTERFACETYPE_FIRST,
    255     /** Interface for I/O operations. Per-disk. */
     255    /** Interface for I/O operations. Per-image. */
    256256    VDINTERFACETYPE_IO,
    257257    /** Interface for progress notification. Per-operation. */
    … …  
    259259    /** Interface for configuration information. Per-image. */
    260260    VDINTERFACETYPE_CONFIG,
    261     /** Interface for TCP network stack. Per-disk. */
     261    /** Interface for TCP network stack. Per-image. */
    262262    VDINTERFACETYPE_TCPNET,
    263263    /** Interface for getting parent image state. Per-operation. */
    … …  
    429429 * to upper layers.
    430430 *
    431  * Per disk interface. Optional, but think twice if you want to miss the
     431 * Per-disk interface. Optional, but think twice if you want to miss the
    432432 * opportunity of reporting better human-readable error messages.
    433433 */
    … …  
    509509 * Support interface for I/O
    510510 *
    511  * Per-disk. Optional as input.
     511 * Per-image. Optional as input.
    512512 */
    513513typedef struct VDINTERFACEIO
    514514{
    515515    /**
    516      * Size of the async interface.
     516     * Size of the I/O interface.
    517517     */
    518518    uint32_t    cbSize;
    … …  
    537537     *                          VDAsyncRead or VDAsyncWrite) in pvCompletion
    538538     *                          if this is NULL.
    539      * @param   pVDIfsDisk      Pointer to the per-disk VD interface list.
    540539     * @param   ppStorage       Where to store the opaque storage handle.
    541540     */
    … …  
    543542                                        uint32_t fOpen,
    544543                                        PFNVDCOMPLETED pfnCompleted,
    545                                         PVDINTERFACE pVDIfsDisk,
    546544                                        void **ppStorage));
    547545
    … …  
    705703
    706704/**
    707  * Get async I/O interface from opaque callback table.
     705 * Get I/O interface from opaque callback table.
    708706 *
    709707 * @return Pointer to the callback table.
    … …  
    714712    PVDINTERFACEIO pInterfaceIO;
    715713
    716     /* Check that the interface descriptor is a async I/O interface. */
     714    /* Check that the interface descriptor is an I/O interface. */
    717715    AssertMsgReturn(   (pInterface->enmInterface == VDINTERFACETYPE_IO)
    718716                    && (pInterface->cbSize == sizeof(VDINTERFACE)),
    719                     ("Not an async I/O interface"), NULL);
     717                    ("Not an I/O interface"), NULL);
    720718
    721719    pInterfaceIO = (PVDINTERFACEIO)pInterface->pCallbacks;
    … …  
    724722    AssertMsgReturn(   (pInterfaceIO->cbSize == sizeof(VDINTERFACEIO))
    725723                    && (pInterfaceIO->enmInterface == VDINTERFACETYPE_IO),
    726                     ("A non async I/O callback table attached to a I/O interface descriptor\n"), NULL);
     724                    ("A non I/O callback table attached to an I/O interface descriptor\n"), NULL);
    727725
    728726    return pInterfaceIO;
    … …  
    11181116 * TCP network stack interface
    11191117 *
    1120  * Per-disk. Mandatory for backends which have the VD_CAP_TCPNET bit set.
     1118 * Per-image. Mandatory for backends which have the VD_CAP_TCPNET bit set.
    11211119 */
    11221120typedef struct VDINTERFACETCPNET
    … …  
    13401338 * Interface to get the parent state.
    13411339 *
    1342  * Per operation interface. Optional, present only if there is a parent, and
     1340 * Per-operation interface. Optional, present only if there is a parent, and
    13431341 * used only internally for compacting.
    13441342 */
    … …  
    14161414 * about worst case affected areas.
    14171415 *
    1418  * Per disk interface. Optional, needed if the disk is accessed concurrently
     1416 * Per-disk interface. Optional, needed if the disk is accessed concurrently
    14191417 * by several threads, e.g. when merging diff images while a VM is running.
    14201418 */
    … …  
    19081906DECLINLINE(PVDINTERFACEIOINT) VDGetInterfaceIOInt(PVDINTERFACE pInterface)
    19091907{
    1910     PVDINTERFACEIOINT pInterfaceIO;
    1911 
    1912     /* Check that the interface descriptor is a async I/O interface. */
     1908    PVDINTERFACEIOINT pInterfaceIOInt;
     1909
     1910    /* Check that the interface descriptor is an internal I/O interface. */
    19131911    AssertMsgReturn(   (pInterface->enmInterface == VDINTERFACETYPE_IOINT)
    19141912                    && (pInterface->cbSize == sizeof(VDINTERFACE)),
    1915                     ("Not an I/O interface"), NULL);
    1916 
    1917     pInterfaceIO = (PVDINTERFACEIOINT)pInterface->pCallbacks;
     1913                    ("Not an internal I/O interface"), NULL);
     1914
     1915    pInterfaceIOInt = (PVDINTERFACEIOINT)pInterface->pCallbacks;
    19181916
    19191917    /* Do basic checks. */
    1920     AssertMsgReturn(   (pInterfaceIO->cbSize == sizeof(VDINTERFACEIOINT))
    1921                     && (pInterfaceIO->enmInterface == VDINTERFACETYPE_IOINT),
    1922                     ("A non I/O callback table attached to a I/O interface descriptor\n"), NULL);
    1923 
    1924     return pInterfaceIO;
     1918    AssertMsgReturn(   (pInterfaceIOInt->cbSize == sizeof(VDINTERFACEIOINT))
     1919                    && (pInterfaceIOInt->enmInterface == VDINTERFACETYPE_IOINT),
     1920                    ("A non internal I/O callback table attached to an internal I/O interface descriptor\n"), NULL);
     1921
     1922    return pInterfaceIOInt;
    19251923}
    19261924

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

    r32553 r32691  
    8686    /** Common structure for the configuration information interface. */
    8787    VDINTERFACE        VDIConfig;
     88    /** Common structure for the supported TCP network stack interface. */
     89    VDINTERFACE        VDITcpNet;
     90    /** Common structure for the supported I/O interface. */
     91    VDINTERFACE        VDIIO;
    8892} VBOXIMAGE, *PVBOXIMAGE;
    8993
    … …  
    105109    /** Callback routine */
    106110    PFNVDCOMPLETED              pfnCompleted;
    107 
    108     /** Pointer to the optional thread synchronization interface of the disk. */
    109     PVDINTERFACE        pInterfaceThreadSync;
    110     /** Pointer to the optional thread synchronization callbacks of the disk. */
    111     PVDINTERFACETHREADSYNC pInterfaceThreadSyncCallbacks;
    112111} DRVVDSTORAGEBACKEND, *PDRVVDSTORAGEBACKEND;
    113112
    … …  
    140139    /** Callback table for error interface. */
    141140    VDINTERFACEERROR   VDIErrorCallbacks;
    142     /** Common structure for the supported TCP network stack interface. */
    143     VDINTERFACE        VDITcpNet;
    144     /** Callback table for TCP network stack interface. */
    145     VDINTERFACETCPNET  VDITcpNetCallbacks;
    146     /** Common structure for the supported I/O interface. */
    147     VDINTERFACE        VDIIO;
    148     /** Callback table for I/O interface. */
    149     VDINTERFACEIO      VDIIOCallbacks;
    150141    /** Common structure for the supported thread synchronization interface. */
    151142    VDINTERFACE        VDIThreadSync;
    152143    /** Callback table for thread synchronization interface. */
    153144    VDINTERFACETHREADSYNC VDIThreadSyncCallbacks;
     145
    154146    /** Callback table for the configuration information interface. */
    155147    VDINTERFACECONFIG  VDIConfigCallbacks;
     148    /** Callback table for TCP network stack interface. */
     149    VDINTERFACETCPNET  VDITcpNetCallbacks;
     150    /** Callback table for I/O interface. */
     151    VDINTERFACEIO      VDIIOCallbacks;
     152
    156153    /** Flag whether opened disk suppports async I/O operations. */
    157154    bool               fAsyncIOSupported;
    … …  
    334331                                          uint32_t fOpen,
    335332                                          PFNVDCOMPLETED pfnCompleted,
    336                                           PVDINTERFACE pVDIfsDisk,
    337333                                          void **ppStorage)
    338334{
    … …  
    346342        pStorageBackend->rcReqLast      = VINF_SUCCESS;
    347343        pStorageBackend->pfnCompleted   = pfnCompleted;
    348         pStorageBackend->pInterfaceThreadSync = NULL;
    349         pStorageBackend->pInterfaceThreadSyncCallbacks = NULL;
    350 
    351         pStorageBackend->pInterfaceThreadSync = VDInterfaceGet(pVDIfsDisk, VDINTERFACETYPE_THREADSYNC);
    352         if (RT_UNLIKELY(pStorageBackend->pInterfaceThreadSync))
    353             pStorageBackend->pInterfaceThreadSyncCallbacks = VDGetInterfaceThreadSync(pStorageBackend->pInterfaceThreadSync);
    354344
    355345        rc = RTSemEventCreate(&pStorageBackend->EventSem);
    … …  
    21312121    if (RT_SUCCESS(rc))
    21322122    {
    2133         /* First of all figure out what kind of TCP networking stack interface
    2134          * to use. This is done unconditionally, as backends which don't need
    2135          * it will just ignore it. */
     2123        /* Construct TCPNET callback table depending on the config. This is
     2124         * done unconditionally, as uninterested backends will ignore it. */
    21362125        if (fHostIP)
    21372126        {
    … …  
    22022191#endif /* VBOX_WITH_INIP */
    22032192        }
    2204         if (RT_SUCCESS(rc))
    2205         {
    2206             rc = VDInterfaceAdd(&pThis->VDITcpNet, "DrvVD_INIP",
    2207                                 VDINTERFACETYPE_TCPNET,
    2208                                 &pThis->VDITcpNetCallbacks, NULL,
    2209                                 &pThis->pVDIfsDisk);
    2210         }
    22112193
    22122194        /** @todo quick hack to work around problems in the async I/O
    … …  
    22312213            pThis->VDIIOCallbacks.pfnWriteAsync = drvvdAsyncIOWriteAsync;
    22322214            pThis->VDIIOCallbacks.pfnFlushAsync = drvvdAsyncIOFlushAsync;
    2233 
    2234             rc = VDInterfaceAdd(&pThis->VDIIO, "DrvVD_IO", VDINTERFACETYPE_IO,
    2235                                 &pThis->VDIIOCallbacks, pThis, &pThis->pVDIfsDisk);
    22362215#else /* !VBOX_WITH_PDM_ASYNC_COMPLETION */
    22372216            rc = PDMDrvHlpVMSetError(pDrvIns, VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES,
    … …  
    23482327                            &pThis->VDIConfigCallbacks, pCfgVDConfig, &pImage->pVDIfsImage);
    23492328        AssertRC(rc);
     2329
     2330        /* Unconditionally insert the TCPNET interface, don't bother to check
     2331         * if an image really needs it. Will be ignored. Since the TCPNET
     2332         * interface is per image we could make this more flexible in the
     2333         * future if we want to. */
     2334        rc = VDInterfaceAdd(&pImage->VDITcpNet, "DrvVD_TCPNET",
     2335                            VDINTERFACETYPE_TCPNET, &pThis->VDITcpNetCallbacks,
     2336                            NULL, &pImage->pVDIfsImage);
     2337        AssertRC(rc);
     2338
     2339        /* Insert the custom I/O interface only if we're told to use new IO.
     2340         * Since the I/O interface is per image we could make this more
     2341         * flexible in the future if we want to. */
     2342        if (fUseNewIo)
     2343        {
     2344            rc = VDInterfaceAdd(&pImage->VDIIO, "DrvVD_IO", VDINTERFACETYPE_IO,
     2345                                &pThis->VDIIOCallbacks, pThis,
     2346                                &pImage->pVDIfsImage);
     2347            AssertRC(rc);
     2348        }
    23502349
    23512350        /*

  • trunk/src/VBox/Devices/Storage/ISCSIHDDCore.cpp

    r32598 r32691  
    527527    /** Error interface callback table. */
    528528    PVDINTERFACEERROR   pInterfaceErrorCallbacks;
    529     /** TCP network stack interface. */
    530     PVDINTERFACE        pInterfaceNet;
    531     /** TCP network stack interface callback table. */
    532     PVDINTERFACETCPNET  pInterfaceNetCallbacks;
    533529    /** Pointer to the per-image VD interface list. */
    534530    PVDINTERFACE        pVDIfsImage;
    … …  
    541537    /** I/O interface callback table. */
    542538    PVDINTERFACEIOINT   pInterfaceIoCallbacks;
     539    /** TCP network stack interface. */
     540    PVDINTERFACE        pInterfaceNet;
     541    /** TCP network stack interface callback table. */
     542    PVDINTERFACETCPNET  pInterfaceNetCallbacks;
    543543    /** Image open flags. */
    544544    unsigned            uOpenFlags;
    … …  
    37333733
    37343734    /* Get TCP network stack interface. */
    3735     pImage->pInterfaceNet = VDInterfaceGet(pImage->pVDIfsDisk, VDINTERFACETYPE_TCPNET);
     3735    pImage->pInterfaceNet = VDInterfaceGet(pImage->pVDIfsImage, VDINTERFACETYPE_TCPNET);
    37363736    if (pImage->pInterfaceNet)
    37373737        pImage->pInterfaceNetCallbacks = VDGetInterfaceTcpNet(pImage->pInterfaceNet);

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

    r32641 r32691  
    8686    /** Function pointers for the various backend methods. */
    8787    PCVBOXHDDBACKEND    Backend;
    88     /** Per image internal I/O interface. */
    89     VDINTERFACE         VDIIO;
     88
    9089    /** Pointer to list of VD interfaces, per-image. */
    9190    PVDINTERFACE        pVDIfsImage;
     91
     92    /** I/O interface to the upper layer. */
     93    PVDINTERFACE        pInterfaceIO;
     94    /** I/O interface callback table. */
     95    PVDINTERFACEIO      pInterfaceIOCallbacks;
     96
     97    /** Per image internal I/O interface. */
     98    VDINTERFACE         VDIIOInt;
     99
     100    /** Fallback I/O interface, only used if the caller doesn't provide it. */
     101    VDINTERFACE         VDIIO;
     102
    92103    /** Disk this image is part of */
    93104    PVBOXHDD            pDisk;
    … …  
    119130    /** Function pointers for the various backend methods. */
    120131    PCVDCACHEBACKEND    Backend;
    121     /** Per image internal I/O interface. */
    122     VDINTERFACE         VDIIO;
     132
    123133    /** Pointer to list of VD interfaces, per-cache. */
    124134    PVDINTERFACE        pVDIfsCache;
     135
     136    /** I/O interface to the upper layer. */
     137    PVDINTERFACE        pInterfaceIO;
     138    /** I/O interface callback table. */
     139    PVDINTERFACEIO      pInterfaceIOCallbacks;
     140
     141    /** Per image internal I/O interface. */
     142    VDINTERFACE         VDIIOInt;
     143
     144    /** Fallback I/O interface, only used if the caller doesn't provide it. */
     145    VDINTERFACE         VDIIO;
     146
    125147    /** Disk this image is part of */
    126148    PVBOXHDD            pDisk;
    … …  
    170192    VDINTERFACEIOINT    VDIIOIntCallbacks;
    171193
    172     /** I/O interface to the upper layer. */
    173     PVDINTERFACE        pInterfaceIO;
    174     /** I/O interface callback table. */
    175     PVDINTERFACEIO      pInterfaceIOCallbacks;
    176 
    177     /** Fallback I/O interface. */
    178     VDINTERFACE         VDIIO;
    179194    /** Callback table for the fallback I/O interface. */
    180195    VDINTERFACEIO       VDIIOCallbacks;
    … …  
    22162231 * VD async I/O interface open callback.
    22172232 */
    2218 static int vdIOOpenFallback(void *pvUser, const char *pszLocation, uint32_t fOpen,
    2219                             PFNVDCOMPLETED pfnCompleted, PVDINTERFACE pVDIfsDisk,
     2233static int vdIOOpenFallback(void *pvUser, const char *pszLocation,
     2234                            uint32_t fOpen, PFNVDCOMPLETED pfnCompleted,
    22202235                            void **ppStorage)
    22212236{
    … …  
    26402655 */
    26412656static int vdIOIntOpen(void *pvUser, const char *pszLocation,
    2642                     unsigned uOpenFlags, PPVDIOSTORAGE ppIoStorage)
     2657                       unsigned uOpenFlags, PPVDIOSTORAGE ppIoStorage)
    26432658{
    26442659    int rc = VINF_SUCCESS;
    26452660    PVDIMAGE pImage         = (PVDIMAGE)pvUser;
    2646     PVBOXHDD pDisk          = pImage->pDisk;
    26472661    PVDIOSTORAGE pIoStorage = (PVDIOSTORAGE)RTMemAllocZ(sizeof(VDIOSTORAGE));
    26482662
    … …  
    26562670    if (pIoStorage->pTreeMetaXfers)
    26572671    {
    2658         rc = pDisk->pInterfaceIOCallbacks->pfnOpen(pDisk->pInterfaceIO->pvUser,
    2659                                                    pszLocation, uOpenFlags,
    2660                                                    vdIOIntReqCompleted,
    2661                                                    pDisk->pVDIfsDisk,
    2662                                                    &pIoStorage->pStorage);
     2672        rc = pImage->pInterfaceIOCallbacks->pfnOpen(pImage->pInterfaceIO->pvUser,
     2673                                                    pszLocation, uOpenFlags,
     2674                                                    vdIOIntReqCompleted,
     2675                                                    &pIoStorage->pStorage);
    26632676        if (RT_SUCCESS(rc))
    26642677        {
    … …  
    26852698{
    26862699    PVDIMAGE pImage = (PVDIMAGE)pvUser;
    2687     PVBOXHDD pDisk  = pImage->pDisk;
    2688 
    2689     int rc = pDisk->pInterfaceIOCallbacks->pfnClose(pDisk->pInterfaceIO->pvUser,
    2690                                                     pIoStorage->pStorage);
     2700
     2701    int rc = pImage->pInterfaceIOCallbacks->pfnClose(pImage->pInterfaceIO->pvUser,
     2702                                                     pIoStorage->pStorage);
    26912703    AssertRC(rc);
    26922704
    … …  
    26992711static int vdIOIntDelete(void *pvUser, const char *pcszFilename)
    27002712{
    2701     PVDIMAGE pImage         = (PVDIMAGE)pvUser;
    2702     PVBOXHDD pDisk          = pImage->pDisk;
    2703     return pDisk->pInterfaceIOCallbacks->pfnDelete(pDisk->pInterfaceIO->pvUser,
    2704                                                    pcszFilename);
    2705 }
    2706 
    2707 static int vdIOIntMove(void *pvUser, const char *pcszSrc, const char *pcszDst, unsigned fMove)
    2708 {
    2709     PVDIMAGE pImage         = (PVDIMAGE)pvUser;
    2710     PVBOXHDD pDisk          = pImage->pDisk;
    2711     return pDisk->pInterfaceIOCallbacks->pfnMove(pDisk->pInterfaceIO->pvUser,
    2712                                                  pcszSrc, pcszDst, fMove);
    2713 }
    2714 
    2715 static int vdIOIntGetFreeSpace(void *pvUser, const char *pcszFilename, int64_t *pcbFreeSpace)
    2716 {
    2717     PVDIMAGE pImage         = (PVDIMAGE)pvUser;
    2718     PVBOXHDD pDisk          = pImage->pDisk;
    2719     return pDisk->pInterfaceIOCallbacks->pfnGetFreeSpace(pDisk->pInterfaceIO->pvUser,
    2720                                                          pcszFilename, pcbFreeSpace);
    2721 }
    2722 
    2723 static int vdIOIntGetModificationTime(void *pvUser, const char *pcszFilename, PRTTIMESPEC pModificationTime)
    2724 {
    2725     PVDIMAGE pImage         = (PVDIMAGE)pvUser;
    2726     PVBOXHDD pDisk          = pImage->pDisk;
    2727     return pDisk->pInterfaceIOCallbacks->pfnGetModificationTime(pDisk->pInterfaceIO->pvUser,
    2728                                                                 pcszFilename, pModificationTime);
     2713    PVDIMAGE pImage = (PVDIMAGE)pvUser;
     2714    return pImage->pInterfaceIOCallbacks->pfnDelete(pImage->pInterfaceIO->pvUser,
     2715                                                    pcszFilename);
     2716}
     2717
     2718static int vdIOIntMove(void *pvUser, const char *pcszSrc, const char *pcszDst,
     2719                       unsigned fMove)
     2720{
     2721    PVDIMAGE pImage = (PVDIMAGE)pvUser;
     2722    return pImage->pInterfaceIOCallbacks->pfnMove(pImage->pInterfaceIO->pvUser,
     2723                                                  pcszSrc, pcszDst, fMove);
     2724}
     2725
     2726static int vdIOIntGetFreeSpace(void *pvUser, const char *pcszFilename,
     2727                               int64_t *pcbFreeSpace)
     2728{
     2729    PVDIMAGE pImage = (PVDIMAGE)pvUser;
     2730    return pImage->pInterfaceIOCallbacks->pfnGetFreeSpace(pImage->pInterfaceIO->pvUser,
     2731                                                          pcszFilename,
     2732                                                          pcbFreeSpace);
     2733}
     2734
     2735static int vdIOIntGetModificationTime(void *pvUser, const char *pcszFilename,
     2736                                      PRTTIMESPEC pModificationTime)
     2737{
     2738    PVDIMAGE pImage = (PVDIMAGE)pvUser;
     2739    return pImage->pInterfaceIOCallbacks->pfnGetModificationTime(pImage->pInterfaceIO->pvUser,
     2740                                                                 pcszFilename,
     2741                                                                 pModificationTime);
    27292742}
    27302743
    27312744static int vdIOIntGetSize(void *pvUser, PVDIOSTORAGE pIoStorage,
    2732                        uint64_t *pcbSize)
     2745                          uint64_t *pcbSize)
    27332746{
    27342747    PVDIMAGE pImage = (PVDIMAGE)pvUser;
    2735     PVBOXHDD pDisk  = pImage->pDisk;
    2736 
    2737     return pDisk->pInterfaceIOCallbacks->pfnGetSize(pDisk->pInterfaceIO->pvUser,
     2748
     2749    return pImage->pInterfaceIOCallbacks->pfnGetSize(pImage->pInterfaceIO->pvUser,
    27382750                                                    pIoStorage->pStorage,
    27392751                                                    pcbSize);
    … …  
    27412753
    27422754static int vdIOIntSetSize(void *pvUser, PVDIOSTORAGE pIoStorage,
    2743                        uint64_t cbSize)
     2755                          uint64_t cbSize)
    27442756{
    27452757    PVDIMAGE pImage = (PVDIMAGE)pvUser;
    2746     PVBOXHDD pDisk  = pImage->pDisk;
    2747 
    2748     return pDisk->pInterfaceIOCallbacks->pfnSetSize(pDisk->pInterfaceIO->pvUser,
    2749                                                     pIoStorage->pStorage,
    2750                                                     cbSize);
    2751 }
    2752 
    2753 static int vdIOIntWriteSync(void *pvUser, PVDIOSTORAGE pIoStorage, uint64_t uOffset,
    2754                          const void *pvBuf, size_t cbWrite, size_t *pcbWritten)
     2758
     2759    return pImage->pInterfaceIOCallbacks->pfnSetSize(pImage->pInterfaceIO->pvUser,
     2760                                                     pIoStorage->pStorage,
     2761                                                     cbSize);
     2762}
     2763
     2764static int vdIOIntWriteSync(void *pvUser, PVDIOSTORAGE pIoStorage,
     2765                            uint64_t uOffset, const void *pvBuf,
     2766                           size_t cbWrite, size_t *pcbWritten)
    27552767{
    27562768    PVDIMAGE pImage = (PVDIMAGE)pvUser;
    2757     PVBOXHDD pDisk  = pImage->pDisk;
    2758 
    2759     return pDisk->pInterfaceIOCallbacks->pfnWriteSync(pDisk->pInterfaceIO->pvUser,
     2769
     2770    return pImage->pInterfaceIOCallbacks->pfnWriteSync(pImage->pInterfaceIO->pvUser,
     2771                                                       pIoStorage->pStorage,
     2772                                                       uOffset, pvBuf, cbWrite,
     2773                                                       pcbWritten);
     2774}
     2775
     2776static int vdIOIntReadSync(void *pvUser, PVDIOSTORAGE pIoStorage,
     2777                           uint64_t uOffset, void *pvBuf, size_t cbRead,
     2778                           size_t *pcbRead)
     2779{
     2780    PVDIMAGE pImage = (PVDIMAGE)pvUser;
     2781
     2782    return pImage->pInterfaceIOCallbacks->pfnReadSync(pImage->pInterfaceIO->pvUser,
    27602783                                                      pIoStorage->pStorage,
    2761                                                       uOffset, pvBuf, cbWrite,
    2762                                                       pcbWritten);
    2763 }
    2764 
    2765 static int vdIOIntReadSync(void *pvUser, PVDIOSTORAGE pIoStorage, uint64_t uOffset,
    2766                         void *pvBuf, size_t cbRead, size_t *pcbRead)
     2784                                                      uOffset, pvBuf, cbRead,
     2785                                                      pcbRead);
     2786}
     2787
     2788static int vdIOIntFlushSync(void *pvUser, PVDIOSTORAGE pIoStorage)
    27672789{
    27682790    PVDIMAGE pImage = (PVDIMAGE)pvUser;
    2769     PVBOXHDD pDisk  = pImage->pDisk;
    2770 
    2771     return pDisk->pInterfaceIOCallbacks->pfnReadSync(pDisk->pInterfaceIO->pvUser,
    2772                                                      pIoStorage->pStorage,
    2773                                                      uOffset, pvBuf, cbRead,
    2774                                                      pcbRead);
    2775 }
    2776 
    2777 static int vdIOIntFlushSync(void *pvUser, PVDIOSTORAGE pIoStorage)
    2778 {
    2779     PVDIMAGE pImage = (PVDIMAGE)pvUser;
    2780     PVBOXHDD pDisk  = pImage->pDisk;
    2781 
    2782     return pDisk->pInterfaceIOCallbacks->pfnFlushSync(pDisk->pInterfaceIO->pvUser,
    2783                                                       pIoStorage->pStorage);
     2791
     2792    return pImage->pInterfaceIOCallbacks->pfnFlushSync(pImage->pInterfaceIO->pvUser,
     2793                                                       pIoStorage->pStorage);
    27842794}
    27852795
    27862796static int vdIOIntReadUserAsync(void *pvUser, PVDIOSTORAGE pIoStorage,
    2787                              uint64_t uOffset, PVDIOCTX pIoCtx,
    2788                              size_t cbRead)
     2797                                uint64_t uOffset, PVDIOCTX pIoCtx,
     2798                                size_t cbRead)
    27892799{
    27902800    int rc = VINF_SUCCESS;
    … …  
    28242834
    28252835        void *pvTask;
    2826         rc = pDisk->pInterfaceIOCallbacks->pfnReadAsync(pDisk->pInterfaceIO->pvUser,
    2827                                                              pIoStorage->pStorage,
    2828                                                              uOffset, aSeg, cSegments,
    2829                                                              cbTaskRead, pIoTask,
    2830                                                              &pvTask);
     2836        rc = pImage->pInterfaceIOCallbacks->pfnReadAsync(pImage->pInterfaceIO->pvUser,
     2837                                                         pIoStorage->pStorage,
     2838                                                         uOffset, aSeg, cSegments,
     2839                                                         cbTaskRead, pIoTask,
     2840                                                         &pvTask);
    28312841        if (RT_SUCCESS(rc))
    28322842        {
    … …  
    28512861
    28522862static int vdIOIntWriteUserAsync(void *pvUser, PVDIOSTORAGE pIoStorage,
    2853                               uint64_t uOffset, PVDIOCTX pIoCtx,
    2854                               size_t cbWrite,
    2855                               PFNVDXFERCOMPLETED pfnComplete,
    2856                               void *pvCompleteUser)
     2863                                 uint64_t uOffset, PVDIOCTX pIoCtx,
     2864                                 size_t cbWrite,
     2865                                 PFNVDXFERCOMPLETED pfnComplete,
     2866                                 void *pvCompleteUser)
    28572867{
    28582868    int rc = VINF_SUCCESS;
    … …  
    28922902
    28932903        void *pvTask;
    2894         rc = pDisk->pInterfaceIOCallbacks->pfnWriteAsync(pDisk->pInterfaceIO->pvUser,
    2895                                                               pIoStorage->pStorage,
    2896                                                               uOffset, aSeg, cSegments,
    2897                                                               cbTaskWrite, pIoTask,
    2898                                                               &pvTask);
     2904        rc = pImage->pInterfaceIOCallbacks->pfnWriteAsync(pImage->pInterfaceIO->pvUser,
     2905                                                          pIoStorage->pStorage,
     2906                                                          uOffset, aSeg, cSegments,
     2907                                                          cbTaskWrite, pIoTask,
     2908                                                          &pvTask);
    28992909        if (RT_SUCCESS(rc))
    29002910        {
    … …  
    29182928
    29192929static int vdIOIntReadMetaAsync(void *pvUser, PVDIOSTORAGE pIoStorage,
    2920                              uint64_t uOffset, void *pvBuf,
    2921                              size_t cbRead, PVDIOCTX pIoCtx,
    2922                              PPVDMETAXFER ppMetaXfer,
    2923                              PFNVDXFERCOMPLETED pfnComplete,
    2924                              void *pvCompleteUser)
     2930                                uint64_t uOffset, void *pvBuf,
     2931                                size_t cbRead, PVDIOCTX pIoCtx,
     2932                                PPVDMETAXFER ppMetaXfer,
     2933                                PFNVDXFERCOMPLETED pfnComplete,
     2934                                void *pvCompleteUser)
    29252935{
    29262936    PVDIMAGE pImage = (PVDIMAGE)pvUser;
    … …  
    29622972
    29632973        VDMETAXFER_TXDIR_SET(pMetaXfer->fFlags, VDMETAXFER_TXDIR_READ);
    2964         rc = pDisk->pInterfaceIOCallbacks->pfnReadAsync(pDisk->pInterfaceIO->pvUser,
    2965                                                              pIoStorage->pStorage,
    2966                                                              uOffset, &Seg, 1,
    2967                                                              cbRead, pIoTask,
    2968                                                              &pvTask);
     2974        rc = pImage->pInterfaceIOCallbacks->pfnReadAsync(pImage->pInterfaceIO->pvUser,
     2975                                                         pIoStorage->pStorage,
     2976                                                         uOffset, &Seg, 1,
     2977                                                         cbRead, pIoTask,
     2978                                                         &pvTask);
    29692979
    29702980        if (RT_SUCCESS(rc) || rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
    … …  
    30173027
    30183028static int vdIOIntWriteMetaAsync(void *pvUser, PVDIOSTORAGE pIoStorage,
    3019                               uint64_t uOffset, void *pvBuf,
    3020                               size_t cbWrite, PVDIOCTX pIoCtx,
    3021                               PFNVDXFERCOMPLETED pfnComplete,
    3022                               void *pvCompleteUser)
     3029                                 uint64_t uOffset, void *pvBuf,
     3030                                 size_t cbWrite, PVDIOCTX pIoCtx,
     3031                                 PFNVDXFERCOMPLETED pfnComplete,
     3032                                 void *pvCompleteUser)
    30233033{
    30243034    PVDIMAGE pImage = (PVDIMAGE)pvUser;
    … …  
    30673077
    30683078    VDMETAXFER_TXDIR_SET(pMetaXfer->fFlags, VDMETAXFER_TXDIR_WRITE);
    3069     rc = pDisk->pInterfaceIOCallbacks->pfnWriteAsync(pDisk->pInterfaceIO->pvUser,
    3070                                                           pIoStorage->pStorage,
    3071                                                           uOffset, &Seg, 1,
    3072                                                           cbWrite, pIoTask,
    3073                                                           &pvTask);
     3079    rc = pImage->pInterfaceIOCallbacks->pfnWriteAsync(pImage->pInterfaceIO->pvUser,
     3080                                                      pIoStorage->pStorage,
     3081                                                      uOffset, &Seg, 1,
     3082                                                      cbWrite, pIoTask,
     3083                                                      &pvTask);
    30743084    if (RT_SUCCESS(rc))
    30753085    {
    … …  
    31143124{
    31153125    PVDIMAGE pImage = (PVDIMAGE)pvUser;
     3126    PVBOXHDD pDisk  = pImage->pDisk;
    31163127    PVDIOSTORAGE pIoStorage = pMetaXfer->pIoStorage;
    31173128
    3118     VD_THREAD_IS_CRITSECT_OWNER(pImage->pDisk);
     3129    VD_THREAD_IS_CRITSECT_OWNER(pDisk);
    31193130
    31203131    Assert(   VDMETAXFER_TXDIR_GET(pMetaXfer->fFlags) == VDMETAXFER_TXDIR_NONE
    … …  
    31373148
    31383149static int vdIOIntFlushAsync(void *pvUser, PVDIOSTORAGE pIoStorage,
    3139                           PVDIOCTX pIoCtx,
    3140                           PFNVDXFERCOMPLETED pfnComplete,
    3141                           void *pvCompleteUser)
     3150                             PVDIOCTX pIoCtx, PFNVDXFERCOMPLETED pfnComplete,
     3151                             void *pvCompleteUser)
    31423152{
    31433153    PVDIMAGE pImage = (PVDIMAGE)pvUser;
    … …  
    31753185    RTListAppend(&pMetaXfer->ListIoCtxWaiting, &pDeferred->NodeDeferred);
    31763186    VDMETAXFER_TXDIR_SET(pMetaXfer->fFlags, VDMETAXFER_TXDIR_FLUSH);
    3177     rc = pDisk->pInterfaceIOCallbacks->pfnFlushAsync(pDisk->pInterfaceIO->pvUser,
    3178                                                           pIoStorage->pStorage,
    3179                                                           pIoTask,
    3180                                                           &pvTask);
     3187    rc = pImage->pInterfaceIOCallbacks->pfnFlushAsync(pImage->pInterfaceIO->pvUser,
     3188                                                      pIoStorage->pStorage,
     3189                                                      pIoTask, &pvTask);
    31813190    if (RT_SUCCESS(rc))
    31823191    {
    … …  
    31943203
    31953204static size_t vdIOIntIoCtxCopyTo(void *pvUser, PVDIOCTX pIoCtx,
    3196                               void *pvBuf, size_t cbBuf)
     3205                                 void *pvBuf, size_t cbBuf)
    31973206{
    31983207    PVDIMAGE pImage = (PVDIMAGE)pvUser;
    … …  
    32113220
    32123221static size_t vdIOIntIoCtxCopyFrom(void *pvUser, PVDIOCTX pIoCtx,
    3213                                 void *pvBuf, size_t cbBuf)
     3222                                   void *pvBuf, size_t cbBuf)
    32143223{
    32153224    PVDIMAGE pImage = (PVDIMAGE)pvUser;
    … …  
    32273236}
    32283237
    3229 static size_t vdIOIntIoCtxSet(void *pvUser, PVDIOCTX pIoCtx,
    3230                            int ch, size_t cb)
     3238static size_t vdIOIntIoCtxSet(void *pvUser, PVDIOCTX pIoCtx, int ch, size_t cb)
    32313239{
    32323240    PVDIMAGE pImage = (PVDIMAGE)pvUser;
    … …  
    32453253
    32463254static size_t vdIOIntIoCtxSegArrayCreate(void *pvUser, PVDIOCTX pIoCtx,
    3247                                      PRTSGSEG paSeg, unsigned *pcSeg,
    3248                                      size_t cbData)
     3255                                         PRTSGSEG paSeg, unsigned *pcSeg,
     3256                                         size_t cbData)
    32493257{
    32503258    PVDIMAGE pImage = (PVDIMAGE)pvUser;
    … …  
    32613269
    32623270static void vdIOIntIoCtxCompleted(void *pvUser, PVDIOCTX pIoCtx, int rcReq,
    3263                                size_t cbCompleted)
     3271                                  size_t cbCompleted)
    32643272{
    32653273    /* Continue */
    … …  
    32893297
    32903298    rc = pInterfaceIOCallbacks->pfnOpen(NULL, pszLocation, fOpen,
    3291                                         NULL, NULL, &pIoStorage->pStorage);
     3299                                        NULL, &pIoStorage->pStorage);
    32923300    if (RT_SUCCESS(rc))
    32933301        *ppIoStorage = pIoStorage;
    … …  
    33143322}
    33153323
    3316 static int vdIOIntMoveLimited(void *pvUser, const char *pcszSrc, const char *pcszDst, unsigned fMove)
     3324static int vdIOIntMoveLimited(void *pvUser, const char *pcszSrc,
     3325                              const char *pcszDst, unsigned fMove)
    33173326{
    33183327    PVDINTERFACEIO pInterfaceIOCallbacks = (PVDINTERFACEIO)pvUser;
    … …  
    33203329}
    33213330
    3322 static int vdIOIntGetFreeSpaceLimited(void *pvUser, const char *pcszFilename, int64_t *pcbFreeSpace)
     3331static int vdIOIntGetFreeSpaceLimited(void *pvUser, const char *pcszFilename,
     3332                                      int64_t *pcbFreeSpace)
    33233333{
    33243334    PVDINTERFACEIO pInterfaceIOCallbacks = (PVDINTERFACEIO)pvUser;
    … …  
    33263336}
    33273337
    3328 static int vdIOIntGetModificationTimeLimited(void *pvUser, const char *pcszFilename, PRTTIMESPEC pModificationTime)
     3338static int vdIOIntGetModificationTimeLimited(void *pvUser,
     3339                                             const char *pcszFilename,
     3340                                             PRTTIMESPEC pModificationTime)
    33293341{
    33303342    PVDINTERFACEIO pInterfaceIOCallbacks = (PVDINTERFACEIO)pvUser;
    … …  
    33333345
    33343346static int vdIOIntGetSizeLimited(void *pvUser, PVDIOSTORAGE pIoStorage,
    3335                        uint64_t *pcbSize)
     3347                                 uint64_t *pcbSize)
    33363348{
    33373349    PVDINTERFACEIO pInterfaceIOCallbacks = (PVDINTERFACEIO)pvUser;
    … …  
    33403352
    33413353static int vdIOIntSetSizeLimited(void *pvUser, PVDIOSTORAGE pIoStorage,
    3342                        uint64_t cbSize)
     3354                                 uint64_t cbSize)
    33433355{
    33443356    PVDINTERFACEIO pInterfaceIOCallbacks = (PVDINTERFACEIO)pvUser;
    … …  
    33463358}
    33473359
    3348 static int vdIOIntWriteSyncLimited(void *pvUser, PVDIOSTORAGE pIoStorage, uint64_t uOffset,
    3349                          const void *pvBuf, size_t cbWrite, size_t *pcbWritten)
     3360static int vdIOIntWriteSyncLimited(void *pvUser, PVDIOSTORAGE pIoStorage,
     3361                                   uint64_t uOffset, const void *pvBuf,
     3362                                   size_t cbWrite, size_t *pcbWritten)
    33503363{
    33513364    PVDINTERFACEIO pInterfaceIOCallbacks = (PVDINTERFACEIO)pvUser;
    … …  
    33533366}
    33543367
    3355 static int vdIOIntReadSyncLimited(void *pvUser, PVDIOSTORAGE pIoStorage, uint64_t uOffset,
    3356                         void *pvBuf, size_t cbRead, size_t *pcbRead)
     3368static int vdIOIntReadSyncLimited(void *pvUser, PVDIOSTORAGE pIoStorage,
     3369                                  uint64_t uOffset, void *pvBuf, size_t cbRead,
     3370                                  size_t *pcbRead)
    33573371{
    33583372    PVDINTERFACEIO pInterfaceIOCallbacks = (PVDINTERFACEIO)pvUser;
    … …  
    36163630            if (pDisk->pInterfaceThreadSync)
    36173631                pDisk->pInterfaceThreadSyncCallbacks = VDGetInterfaceThreadSync(pDisk->pInterfaceThreadSync);
    3618             pDisk->pInterfaceIO    = VDInterfaceGet(pVDIfsDisk, VDINTERFACETYPE_IO);
    3619             if (pDisk->pInterfaceIO)
    3620                 pDisk->pInterfaceIOCallbacks = VDGetInterfaceIO(pDisk->pInterfaceIO);
    3621             else
    3622             {
    3623                 /* Create fallback I/O interface */
    3624                 pDisk->VDIIOCallbacks.cbSize                 = sizeof(VDINTERFACEIO);
    3625                 pDisk->VDIIOCallbacks.enmInterface           = VDINTERFACETYPE_IO;
    3626                 pDisk->VDIIOCallbacks.pfnOpen                = vdIOOpenFallback;
    3627                 pDisk->VDIIOCallbacks.pfnClose               = vdIOCloseFallback;
    3628                 pDisk->VDIIOCallbacks.pfnDelete              = vdIODeleteFallback;
    3629                 pDisk->VDIIOCallbacks.pfnMove                = vdIOMoveFallback;
    3630                 pDisk->VDIIOCallbacks.pfnGetFreeSpace        = vdIOGetFreeSpaceFallback;
    3631                 pDisk->VDIIOCallbacks.pfnGetModificationTime = vdIOGetModificationTimeFallback;
    3632                 pDisk->VDIIOCallbacks.pfnGetSize             = vdIOGetSizeFallback;
    3633                 pDisk->VDIIOCallbacks.pfnSetSize             = vdIOSetSizeFallback;
    3634                 pDisk->VDIIOCallbacks.pfnReadSync            = vdIOReadSyncFallback;
    3635                 pDisk->VDIIOCallbacks.pfnWriteSync           = vdIOWriteSyncFallback;
    3636                 pDisk->VDIIOCallbacks.pfnFlushSync           = vdIOFlushSyncFallback;
    3637                 pDisk->VDIIOCallbacks.pfnReadAsync           = vdIOReadAsyncFallback;
    3638                 pDisk->VDIIOCallbacks.pfnWriteAsync          = vdIOWriteAsyncFallback;
    3639                 pDisk->VDIIOCallbacks.pfnFlushAsync          = vdIOFlushAsyncFallback;
    3640                 pDisk->pInterfaceIOCallbacks                 = &pDisk->VDIIOCallbacks;
    3641 
    3642                 pDisk->VDIIO.pszInterfaceName = "VD_IO";
    3643                 pDisk->VDIIO.cbSize           = sizeof(VDINTERFACE);
    3644                 pDisk->VDIIO.pNext            = NULL;
    3645                 pDisk->VDIIO.enmInterface     = VDINTERFACETYPE_IO;
    3646                 pDisk->VDIIO.pvUser           = pDisk;
    3647                 pDisk->VDIIO.pCallbacks       = pDisk->pInterfaceIOCallbacks;
    3648                 pDisk->pInterfaceIO           = &pDisk->VDIIO;
    3649             }
     3632
     3633            /* Create fallback I/O callback table */
     3634            pDisk->VDIIOCallbacks.cbSize                 = sizeof(VDINTERFACEIO);
     3635            pDisk->VDIIOCallbacks.enmInterface           = VDINTERFACETYPE_IO;
     3636            pDisk->VDIIOCallbacks.pfnOpen                = vdIOOpenFallback;
     3637            pDisk->VDIIOCallbacks.pfnClose               = vdIOCloseFallback;
     3638            pDisk->VDIIOCallbacks.pfnDelete              = vdIODeleteFallback;
     3639            pDisk->VDIIOCallbacks.pfnMove                = vdIOMoveFallback;
     3640            pDisk->VDIIOCallbacks.pfnGetFreeSpace        = vdIOGetFreeSpaceFallback;
     3641            pDisk->VDIIOCallbacks.pfnGetModificationTime = vdIOGetModificationTimeFallback;
     3642            pDisk->VDIIOCallbacks.pfnGetSize             = vdIOGetSizeFallback;
     3643            pDisk->VDIIOCallbacks.pfnSetSize             = vdIOSetSizeFallback;
     3644            pDisk->VDIIOCallbacks.pfnReadSync            = vdIOReadSyncFallback;
     3645            pDisk->VDIIOCallbacks.pfnWriteSync           = vdIOWriteSyncFallback;
     3646            pDisk->VDIIOCallbacks.pfnFlushSync           = vdIOFlushSyncFallback;
     3647            pDisk->VDIIOCallbacks.pfnReadAsync           = vdIOReadAsyncFallback;
     3648            pDisk->VDIIOCallbacks.pfnWriteAsync          = vdIOWriteAsyncFallback;
     3649            pDisk->VDIIOCallbacks.pfnFlushAsync          = vdIOFlushAsyncFallback;
    36503650
    36513651            /*
    … …  
    37743774        pInterfaceIOCallbacks = VDGetInterfaceIO(pInterfaceIO);
    37753775
     3776    /* Set up the internal I/O interface. */
     3777    AssertReturn(!VDInterfaceGet(pVDIfsImage, VDINTERFACETYPE_IOINT),
     3778                 VERR_INVALID_PARAMETER);
    37763779    VDIIOIntCallbacks.cbSize                    = sizeof(VDINTERFACEIOINT);
    37773780    VDIIOIntCallbacks.enmInterface              = VDINTERFACETYPE_IOINT;
    … …  
    39403943        }
    39413944
    3942         /* Set up the I/O interface if necessary. */
    3943         if (!VDInterfaceGet(pVDIfsImage, VDINTERFACETYPE_IOINT))
    3944         {
    3945             rc = VDInterfaceAdd(&pImage->VDIIO, "VD_IOINT", VDINTERFACETYPE_IOINT,
    3946                                 &pDisk->VDIIOIntCallbacks, pImage,
    3947                                 &pImage->pVDIfsImage);
    3948             AssertRC(rc);
    3949         }
     3945        /* Set up the I/O interface. */
     3946        pImage->pInterfaceIO = VDInterfaceGet(pVDIfsImage, VDINTERFACETYPE_IO);
     3947        if (pImage->pInterfaceIO)
     3948            pImage->pInterfaceIOCallbacks = VDGetInterfaceIO(pImage->pInterfaceIO);
     3949        else
     3950        {
     3951            rc = VDInterfaceAdd(&pImage->VDIIO, "VD_IO", VDINTERFACETYPE_IO,
     3952                                &pDisk->VDIIOCallbacks, pDisk, &pVDIfsImage);
     3953            pImage->pInterfaceIO = &pImage->VDIIO;
     3954            pImage->pInterfaceIOCallbacks = &pDisk->VDIIOCallbacks;
     3955        }
     3956
     3957        /* Set up the internal I/O interface. */
     3958        AssertBreakStmt(!VDInterfaceGet(pVDIfsImage, VDINTERFACETYPE_IOINT),
     3959                        rc = VERR_INVALID_PARAMETER);
     3960        rc = VDInterfaceAdd(&pImage->VDIIOInt, "VD_IOINT", VDINTERFACETYPE_IOINT,
     3961                            &pDisk->VDIIOIntCallbacks, pImage, &pImage->pVDIfsImage);
     3962        AssertRC(rc);
    39503963
    39513964        pImage->uOpenFlags = uOpenFlags & VD_OPEN_FLAGS_HONOR_SAME;
    … …  
    41824195
    41834196        /* Set up the I/O interface. */
    4184         rc = VDInterfaceAdd(&pCache->VDIIO, "VD_IOINT", VDINTERFACETYPE_IOINT,
     4197        pCache->pInterfaceIO = VDInterfaceGet(pVDIfsCache, VDINTERFACETYPE_IO);
     4198        if (pCache->pInterfaceIO)
     4199            pCache->pInterfaceIOCallbacks = VDGetInterfaceIO(pCache->pInterfaceIO);
     4200        else
     4201        {
     4202            rc = VDInterfaceAdd(&pCache->VDIIO, "VD_IO", VDINTERFACETYPE_IO,
     4203                                &pDisk->VDIIOCallbacks, pDisk, &pVDIfsCache);
     4204            pCache->pInterfaceIO = &pCache->VDIIO;
     4205            pCache->pInterfaceIOCallbacks = &pDisk->VDIIOCallbacks;
     4206        }
     4207
     4208        /* Set up the internal I/O interface. */
     4209        AssertBreakStmt(!VDInterfaceGet(pVDIfsCache, VDINTERFACETYPE_IOINT),
     4210                        rc = VERR_INVALID_PARAMETER);
     4211        rc = VDInterfaceAdd(&pCache->VDIIOInt, "VD_IOINT", VDINTERFACETYPE_IOINT,
    41854212                            &pDisk->VDIIOIntCallbacks, pCache, &pCache->pVDIfsCache);
    41864213        AssertRC(rc);
    … …  
    44024429        pImage->pVDIfsImage = pVDIfsImage;
    44034430
    4404         rc = VDInterfaceAdd(&pImage->VDIIO, "VD_IOINT", VDINTERFACETYPE_IOINT,
    4405                             &pDisk->VDIIOIntCallbacks, pImage,
    4406                             &pImage->pVDIfsImage);
     4431        /* Set up the I/O interface. */
     4432        pImage->pInterfaceIO = VDInterfaceGet(pVDIfsImage, VDINTERFACETYPE_IO);
     4433        if (pImage->pInterfaceIO)
     4434            pImage->pInterfaceIOCallbacks = VDGetInterfaceIO(pImage->pInterfaceIO);
     4435        else
     4436        {
     4437            rc = VDInterfaceAdd(&pImage->VDIIO, "VD_IO", VDINTERFACETYPE_IO,
     4438                                &pDisk->VDIIOCallbacks, pDisk, &pVDIfsImage);
     4439            pImage->pInterfaceIO = &pImage->VDIIO;
     4440            pImage->pInterfaceIOCallbacks = &pDisk->VDIIOCallbacks;
     4441        }
     4442
     4443        /* Set up the internal I/O interface. */
     4444        AssertBreakStmt(!VDInterfaceGet(pVDIfsImage, VDINTERFACETYPE_IOINT),
     4445                        rc = VERR_INVALID_PARAMETER);
     4446        rc = VDInterfaceAdd(&pImage->VDIIOInt, "VD_IOINT", VDINTERFACETYPE_IOINT,
     4447                            &pDisk->VDIIOIntCallbacks, pImage, &pImage->pVDIfsImage);
    44074448        AssertRC(rc);
    44084449
    … …  
    46554696        pImage->pVDIfsImage = pVDIfsImage;
    46564697
    4657         rc = VDInterfaceAdd(&pImage->VDIIO, "VD_IOINT", VDINTERFACETYPE_IOINT,
    4658                             &pDisk->VDIIOIntCallbacks, pImage,
    4659                             &pImage->pVDIfsImage);
     4698        /* Set up the I/O interface. */
     4699        pImage->pInterfaceIO = VDInterfaceGet(pVDIfsImage, VDINTERFACETYPE_IO);
     4700        if (pImage->pInterfaceIO)
     4701            pImage->pInterfaceIOCallbacks = VDGetInterfaceIO(pImage->pInterfaceIO);
     4702        else
     4703        {
     4704            rc = VDInterfaceAdd(&pImage->VDIIO, "VD_IO", VDINTERFACETYPE_IO,
     4705                                &pDisk->VDIIOCallbacks, pDisk, &pVDIfsImage);
     4706            pImage->pInterfaceIO = &pImage->VDIIO;
     4707            pImage->pInterfaceIOCallbacks = &pDisk->VDIIOCallbacks;
     4708        }
     4709
     4710        /* Set up the internal I/O interface. */
     4711        AssertBreakStmt(!VDInterfaceGet(pVDIfsImage, VDINTERFACETYPE_IOINT),
     4712                        rc = VERR_INVALID_PARAMETER);
     4713        rc = VDInterfaceAdd(&pImage->VDIIOInt, "VD_IOINT", VDINTERFACETYPE_IOINT,
     4714                            &pDisk->VDIIOIntCallbacks, pImage, &pImage->pVDIfsImage);
    46604715        AssertRC(rc);
    46614716
    … …  
    48984953
    48994954        /* Set up the I/O interface. */
    4900         rc = VDInterfaceAdd(&pCache->VDIIO, "VD_IOINT", VDINTERFACETYPE_IOINT,
     4955        pCache->pInterfaceIO = VDInterfaceGet(pVDIfsCache, VDINTERFACETYPE_IO);
     4956        if (pCache->pInterfaceIO)
     4957            pCache->pInterfaceIOCallbacks = VDGetInterfaceIO(pCache->pInterfaceIO);
     4958        else
     4959        {
     4960            rc = VDInterfaceAdd(&pCache->VDIIO, "VD_IO", VDINTERFACETYPE_IO,
     4961                                &pDisk->VDIIOCallbacks, pDisk, &pVDIfsCache);
     4962            pCache->pInterfaceIO = &pCache->VDIIO;
     4963            pCache->pInterfaceIOCallbacks = &pDisk->VDIIOCallbacks;
     4964        }
     4965
     4966        /* Set up the internal I/O interface. */
     4967        AssertBreakStmt(!VDInterfaceGet(pVDIfsCache, VDINTERFACETYPE_IOINT),
     4968                        rc = VERR_INVALID_PARAMETER);
     4969        rc = VDInterfaceAdd(&pCache->VDIIOInt, "VD_IOINT", VDINTERFACETYPE_IOINT,
    49014970                            &pDisk->VDIIOIntCallbacks, pCache, &pCache->pVDIfsCache);
    49024971        AssertRC(rc);

  • trunk/src/VBox/Main/MediumImpl.cpp

    r32536 r32691  
    100100          implicit(false),
    101101          numCreateDiffTasks(0),
    102           vdDiskIfaces(NULL)
     102          vdDiskIfaces(NULL),
     103          vdImageIfaces(NULL)
    103104    { }
    104105
    … …  
    163164
    164165    PVDINTERFACE vdDiskIfaces;
     166    PVDINTERFACE vdImageIfaces;
    165167};
    166168
    … …  
    729731    m->vdIfCallsTcpNet.pfnPoke = NULL;
    730732
    731     /* Initialize the per-disk interface chain */
     733    /* Initialize the per-disk interface chain (could be done more globally,
     734     * but it's not wasting much time or space so it's not worth it). */
    732735    int vrc;
    733736    vrc = VDInterfaceAdd(&m->vdIfError,
    … …  
    737740    AssertRCReturn(vrc, E_FAIL);
    738741
     742    /* Initialize the per-image interface chain */
    739743    vrc = VDInterfaceAdd(&m->vdIfConfig,
    740744                         "Medium::vdInterfaceConfig",
    741745                         VDINTERFACETYPE_CONFIG,
    742                          &m->vdIfCallsConfig, this, &m->vdDiskIfaces);
     746                         &m->vdIfCallsConfig, this, &m->vdImageIfaces);
    743747    AssertRCReturn(vrc, E_FAIL);
    744748
    … …  
    746750                         "Medium::vdInterfaceTcpNet",
    747751                         VDINTERFACETYPE_TCPNET,
    748                          &m->vdIfCallsTcpNet, this, &m->vdDiskIfaces);
     752                         &m->vdIfCallsTcpNet, this, &m->vdImageIfaces);
    749753    AssertRCReturn(vrc, E_FAIL);
    750754
    … …  
    37153719                         location.c_str(),
    37163720                         uOpenFlags,
    3717                          m->vdDiskIfaces);
     3721                         m->vdImageIfaces);
    37183722            if (RT_FAILURE(vrc))
    37193723            {
    … …  
    39553959                             location.c_str(),
    39563960                             uOpenFlags & ~VD_OPEN_FLAGS_READONLY,
    3957                              m->vdDiskIfaces);
     3961                             m->vdImageIfaces);
    39583962                if (RT_FAILURE(vrc))
    39593963                    throw S_OK;
    … …  
    54795483                             pMedium->m->strLocationFull.c_str(),
    54805484                             VD_OPEN_FLAGS_READONLY,
    5481                              pMedium->m->vdDiskIfaces);
     5485                             pMedium->m->vdImageIfaces);
    54825486                if (RT_FAILURE(vrc))
    54835487                    throw vrc;
    … …  
    54935497                             (*it)->m->strLocationFull.c_str(),
    54945498                             VD_OPEN_FLAGS_INFO,
    5495                              (*it)->m->vdDiskIfaces);
     5499                             (*it)->m->vdImageIfaces);
    54965500                if (RT_FAILURE(vrc))
    54975501                    throw vrc;
    … …  
    56235627                               id.raw(),
    56245628                               VD_OPEN_FLAGS_NORMAL,
    5625                                NULL,
     5629                               m->vdImageIfaces,
    56265630                               task.mVDOperationIfaces);
    56275631            if (RT_FAILURE(vrc))
    … …  
    57705774                             pMedium->m->strLocationFull.c_str(),
    57715775                             VD_OPEN_FLAGS_READONLY,
    5772                              pMedium->m->vdDiskIfaces);
     5776                             pMedium->m->vdImageIfaces);
    57735777                if (RT_FAILURE(vrc))
    57745778                    throw setError(VBOX_E_FILE_ERROR,
    … …  
    57915795                               id.raw(),
    57925796                               VD_OPEN_FLAGS_NORMAL,
    5793                                pTarget->m->vdDiskIfaces,
     5797                               pTarget->m->vdImageIfaces,
    57945798                               task.mVDOperationIfaces);
    57955799            if (RT_FAILURE(vrc))
    … …  
    59745978                             pMedium->m->strLocationFull.c_str(),
    59755979                             uOpenFlags,
    5976                              pMedium->m->vdDiskIfaces);
     5980                             pMedium->m->vdImageIfaces);
    59775981                if (RT_FAILURE(vrc))
    59785982                    throw vrc;
    … …  
    60066010                                     (*it)->m->strLocationFull.c_str(),
    60076011                                     VD_OPEN_FLAGS_INFO,
    6008                                      (*it)->m->vdDiskIfaces);
     6012                                     (*it)->m->vdImageIfaces);
    60096013                        if (RT_FAILURE(vrc))
    60106014                            throw vrc;
    … …  
    62556259                             pMedium->m->strLocationFull.c_str(),
    62566260                             VD_OPEN_FLAGS_READONLY,
    6257                              pMedium->m->vdDiskIfaces);
     6261                             pMedium->m->vdImageIfaces);
    62586262                if (RT_FAILURE(vrc))
    62596263                    throw setError(VBOX_E_FILE_ERROR,
    … …  
    63196323                                 pMedium->m->strLocationFull.c_str(),
    63206324                                 uOpenFlags,
    6321                                  pMedium->m->vdDiskIfaces);
     6325                                 pMedium->m->vdImageIfaces);
    63226326                    if (RT_FAILURE(vrc))
    63236327                        throw setError(VBOX_E_FILE_ERROR,
    … …  
    63336337                             targetFormat.c_str(),
    63346338                             (fCreatingTarget) ? targetLocation.c_str() : (char *)NULL,
    6335                              false,
    6336                              0,
     6339                             false /* fMoveByRename */,
     6340                             0 /* cbSize */,
    63376341                             task.mVariant,
    63386342                             targetId.raw(),
    6339                              NULL,
    6340                              pTarget->m->vdDiskIfaces,
     6343                             NULL /* pVDIfsOperation */,
     6344                             pTarget->m->vdImageIfaces,
    63416345                             task.mVDOperationIfaces);
    63426346                if (RT_FAILURE(vrc))
    … …  
    64716475                         location.c_str(),
    64726476                         VD_OPEN_FLAGS_READONLY | VD_OPEN_FLAGS_INFO,
    6473                          m->vdDiskIfaces);
     6477                         m->vdImageIfaces);
    64746478            if (RT_SUCCESS(vrc))
    64756479                vrc = VDClose(hdd, true /* fDelete */);
    … …  
    65696573                             pMedium->m->strLocationFull.c_str(),
    65706574                             VD_OPEN_FLAGS_READONLY,
    6571                              pMedium->m->vdDiskIfaces);
     6575                             pMedium->m->vdImageIfaces);
    65726576                if (RT_FAILURE(vrc))
    65736577                    throw setError(VBOX_E_FILE_ERROR,
    … …  
    65936597                         parentLocation.c_str(),
    65946598                         VD_OPEN_FLAGS_READONLY | VD_OPEN_FLAGS_INFO,
    6595                          m->vdDiskIfaces);
     6599                         m->vdImageIfaces);
    65966600            if (RT_FAILURE(vrc))
    65976601                throw setError(VBOX_E_FILE_ERROR,
    … …  
    66086612                               parentId.raw(),
    66096613                               VD_OPEN_FLAGS_NORMAL,
    6610                                m->vdDiskIfaces,
     6614                               m->vdImageIfaces,
    66116615                               task.mVDOperationIfaces);
    66126616            if (RT_FAILURE(vrc))
    … …  
    66996703                             pMedium->m->strLocationFull.c_str(),
    67006704                             (it == mediumListLast) ? VD_OPEN_FLAGS_NORMAL : VD_OPEN_FLAGS_READONLY,
    6701                              pMedium->m->vdDiskIfaces);
     6705                             pMedium->m->vdImageIfaces);
    67026706                if (RT_FAILURE(vrc))
    67036707                    throw setError(VBOX_E_FILE_ERROR,
    … …  
    67966800                             pMedium->m->strLocationFull.c_str(),
    67976801                             (it == mediumListLast) ? VD_OPEN_FLAGS_NORMAL : VD_OPEN_FLAGS_READONLY,
    6798                              pMedium->m->vdDiskIfaces);
     6802                             pMedium->m->vdImageIfaces);
    67996803                if (RT_FAILURE(vrc))
    68006804                    throw setError(VBOX_E_FILE_ERROR,
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette