VirtualBox

Changeset 66486 in vbox for trunk/src/VBox/Storage


Ignore:
Timestamp:
Apr 10, 2017 7:23:59 AM (8 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
114481
Message:

Storage/VD: Convert all backends to use the region list callbacks, remove the pfnGetSize and pfnGetSectorSize callbacks because they are covered by the region lists

Location:
trunk/src/VBox/Storage
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Storage/CUE.cpp

    r66211 r66486  
    15901590}
    15911591
    1592 /** @copydoc VDIMAGEBACKEND::pfnGetSectorSize */
    1593 static DECLCALLBACK(uint32_t) cueGetSectorSize(void *pBackendData)
    1594 {
    1595     LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    1596     PCUEIMAGE pThis = (PCUEIMAGE)pBackendData;
    1597     uint32_t cb = 0;
    1598 
    1599     AssertPtrReturn(pThis, 0);
    1600 
    1601     LogFlowFunc(("returns %u\n", cb));
    1602     return cb;
    1603 }
    1604 
    1605 /** @copydoc VDIMAGEBACKEND::pfnGetSize */
    1606 static DECLCALLBACK(uint64_t) cueGetSize(void *pBackendData)
    1607 {
    1608     LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    1609     PCUEIMAGE pThis = (PCUEIMAGE)pBackendData;
    1610 
    1611     AssertPtrReturn(pThis, 0);
    1612 
    1613     PCVDREGIONDESC pRegion = &pThis->pRegionList->aRegions[pThis->pRegionList->cRegions - 1];
    1614     uint64_t cb = pRegion->offRegion + pRegion->cRegionBlocksOrBytes;
    1615 
    1616     LogFlowFunc(("returns %llu\n", cb));
    1617     return cb;
    1618 }
    1619 
    16201592/** @copydoc VDIMAGEBACKEND::pfnGetFileSize */
    16211593static DECLCALLBACK(uint64_t) cueGetFileSize(void *pBackendData)
    … …  
    20151987    /* pfnGetVersion */
    20161988    cueGetVersion,
    2017     /* pfnGetSectorSize */
    2018     cueGetSectorSize,
    2019     /* pfnGetSize */
    2020     cueGetSize,
    20211989    /* pfnGetFileSize */
    20221990    cueGetFileSize,

  • trunk/src/VBox/Storage/DMG.cpp

    r66212 r66486  
    371371    /** Size of the buffer. */
    372372    size_t              cbDecompExtent;
     373    /** The static region list. */
     374    VDREGIONLIST        RegionList;
    373375} DMGIMAGE;
    374376/** Pointer to an instance of the DMG Image Interpreter. */
    … …  
    17171719    RTMemFree(pszXml);
    17181720
    1719     if (RT_FAILURE(rc))
     1721    if (RT_SUCCESS(rc))
     1722    {
     1723        PVDREGIONDESC pRegion = &pThis->RegionList.aRegions[0];
     1724        pThis->RegionList.fFlags   = 0;
     1725        pThis->RegionList.cRegions = 1;
     1726
     1727        pRegion->offRegion            = 0; /* Disk start. */
     1728        pRegion->cbBlock              = 2048;
     1729        pRegion->enmDataForm          = VDREGIONDATAFORM_RAW;
     1730        pRegion->enmMetadataForm      = VDREGIONMETADATAFORM_NONE;
     1731        pRegion->cbData               = 2048;
     1732        pRegion->cbMetadata           = 0;
     1733        pRegion->cRegionBlocksOrBytes = pThis->cbSize;
     1734    }
     1735    else
    17201736        dmgFreeImage(pThis, false);
    17211737    return rc;
    … …  
    18551871     */
    18561872    int rc = VERR_NO_MEMORY;
    1857     PDMGIMAGE pThis = (PDMGIMAGE)RTMemAllocZ(sizeof(*pThis));
     1873    PDMGIMAGE pThis = (PDMGIMAGE)RTMemAllocZ(RT_UOFFSETOF(DMGIMAGE, RegionList.aRegions[1]));
    18581874    if (pThis)
    18591875    {
    … …  
    20572073}
    20582074
    2059 /** @interface_method_impl{VDIMAGEBACKEND,pfnGetSectorSize} */
    2060 static DECLCALLBACK(uint32_t) dmgGetSectorSize(void *pBackendData)
    2061 {
    2062     LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    2063     PDMGIMAGE pThis = (PDMGIMAGE)pBackendData;
    2064 
    2065     AssertPtrReturn(pThis, 0);
    2066 
    2067     uint32_t cb = 0;
    2068     if (pThis->pStorage || pThis->hDmgFileInXar != NIL_RTVFSFILE)
    2069         cb = 2048;
    2070 
    2071     LogFlowFunc(("returns %u\n", cb));
    2072     return cb;
    2073 }
    2074 
    2075 /** @interface_method_impl{VDIMAGEBACKEND,pfnGetSize} */
    2076 static DECLCALLBACK(uint64_t) dmgGetSize(void *pBackendData)
    2077 {
    2078     LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    2079     PDMGIMAGE pThis = (PDMGIMAGE)pBackendData;
    2080 
    2081     AssertPtrReturn(pThis, 0);
    2082 
    2083     uint64_t cb = 0;
    2084     if (pThis->pStorage || pThis->hDmgFileInXar != NIL_RTVFSFILE)
    2085         cb = pThis->cbSize;
    2086 
    2087     LogFlowFunc(("returns %llu\n", cb));
    2088     return cb;
    2089 }
    2090 
    20912075/** @interface_method_impl{VDIMAGEBACKEND,pfnGetFileSize} */
    20922076static DECLCALLBACK(uint64_t) dmgGetFileSize(void *pBackendData)
    … …  
    21812165    LogFlowFunc(("returns %Rrc\n", rc));
    21822166    return rc;
     2167}
     2168
     2169/** @copydoc VDIMAGEBACKEND::pfnQueryRegions */
     2170static DECLCALLBACK(int) dmgQueryRegions(void *pBackendData, PCVDREGIONLIST *ppRegionList)
     2171{
     2172    LogFlowFunc(("pBackendData=%#p ppRegionList=%#p\n", pBackendData, ppRegionList));
     2173    PDMGIMAGE pThis = (PDMGIMAGE)pBackendData;
     2174
     2175    AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
     2176
     2177    *ppRegionList = &pThis->RegionList;
     2178    LogFlowFunc(("returns %Rrc\n", VINF_SUCCESS));
     2179    return VINF_SUCCESS;
     2180}
     2181
     2182/** @copydoc VDIMAGEBACKEND::pfnRegionListRelease */
     2183static DECLCALLBACK(void) dmgRegionListRelease(void *pBackendData, PCVDREGIONLIST pRegionList)
     2184{
     2185    RT_NOREF1(pRegionList);
     2186    LogFlowFunc(("pBackendData=%#p pRegionList=%#p\n", pBackendData, pRegionList));
     2187    PDMGIMAGE pThis = (PDMGIMAGE)pBackendData;
     2188    AssertPtr(pThis); RT_NOREF(pThis);
     2189
     2190    /* Nothing to do here. */
    21832191}
    21842192
    … …  
    24412449    /* pfnGetVersion */
    24422450    dmgGetVersion,
    2443     /* pfnGetSectorSize */
    2444     dmgGetSectorSize,
    2445     /* pfnGetSize */
    2446     dmgGetSize,
    24472451    /* pfnGetFileSize */
    24482452    dmgGetFileSize,
    … …  
    24562460    dmgSetLCHSGeometry,
    24572461    /* pfnQueryRegions */
    2458     NULL,
     2462    dmgQueryRegions,
    24592463    /* pfnRegionListRelease */
    2460     NULL,
     2464    dmgRegionListRelease,
    24612465    /* pfnGetImageFlags */
    24622466    dmgGetImageFlags,

  • trunk/src/VBox/Storage/ISCSI.cpp

    r66110 r66486  
    620620    /** Release log counter. */
    621621    unsigned            cLogRelErrors;
     622    /** The static region list. */
     623    VDREGIONLIST        RegionList;
    622624} ISCSIIMAGE;
    623625
    … …  
    46844686    }
    46854687
    4686     if (RT_FAILURE(rc))
     4688    if (RT_SUCCESS(rc))
     4689    {
     4690        PVDREGIONDESC pRegion = &pImage->RegionList.aRegions[0];
     4691        pImage->RegionList.fFlags   = 0;
     4692        pImage->RegionList.cRegions = 1;
     4693
     4694        pRegion->offRegion            = 0; /* Disk start. */
     4695        pRegion->cbBlock              = pImage->cbSector;
     4696        pRegion->enmDataForm          = VDREGIONDATAFORM_RAW;
     4697        pRegion->enmMetadataForm      = VDREGIONMETADATAFORM_NONE;
     4698        pRegion->cbData               = pImage->cbSector;
     4699        pRegion->cbMetadata           = 0;
     4700        pRegion->cRegionBlocksOrBytes = pImage->cbSize;
     4701    }
     4702    else
    46874703        iscsiFreeImage(pImage, false);
    46884704    return rc;
    … …  
    47204736    AssertReturn((VALID_PTR(pszFilename) && *pszFilename), VERR_INVALID_PARAMETER);
    47214737
    4722     PISCSIIMAGE pImage = (PISCSIIMAGE)RTMemAllocZ(sizeof(ISCSIIMAGE));
     4738    PISCSIIMAGE pImage = (PISCSIIMAGE)RTMemAllocZ(RT_UOFFSETOF(ISCSIIMAGE, RegionList.aRegions[1]));
    47234739    if (RT_LIKELY(pImage))
    47244740    {
    … …  
    51135129}
    51145130
    5115 /** @copydoc VDIMAGEBACKEND::pfnGetSectorSize */
    5116 static DECLCALLBACK(uint32_t) iscsiGetSectorSize(void *pBackendData)
    5117 {
    5118     LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    5119     PISCSIIMAGE pImage = (PISCSIIMAGE)pBackendData;
    5120 
    5121     AssertPtrReturn(pImage, 0);
    5122 
    5123     return pImage->cbSector;
    5124 }
    5125 
    5126 /** @copydoc VDIMAGEBACKEND::pfnGetSize */
    5127 static DECLCALLBACK(uint64_t) iscsiGetSize(void *pBackendData)
    5128 {
    5129     LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    5130     PISCSIIMAGE pImage = (PISCSIIMAGE)pBackendData;
    5131 
    5132     AssertPtrReturn(pImage, 0);
    5133 
    5134     return pImage->cbSize;
    5135 }
    5136 
    51375131/** @copydoc VDIMAGEBACKEND::pfnGetFileSize */
    51385132static DECLCALLBACK(uint64_t) iscsiGetFileSize(void *pBackendData)
    … …  
    52105204    LogFlowFunc(("returns %Rrc\n", rc));
    52115205    return rc;
     5206}
     5207
     5208/** @copydoc VDIMAGEBACKEND::pfnQueryRegions */
     5209static DECLCALLBACK(int) iscsiQueryRegions(void *pBackendData, PCVDREGIONLIST *ppRegionList)
     5210{
     5211    LogFlowFunc(("pBackendData=%#p ppRegionList=%#p\n", pBackendData, ppRegionList));
     5212    PISCSIIMAGE pImage = (PISCSIIMAGE)pBackendData;
     5213
     5214    AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
     5215
     5216    *ppRegionList = &pImage->RegionList;
     5217    LogFlowFunc(("returns %Rrc\n", VINF_SUCCESS));
     5218    return VINF_SUCCESS;
     5219}
     5220
     5221/** @copydoc VDIMAGEBACKEND::pfnRegionListRelease */
     5222static DECLCALLBACK(void) iscsiRegionListRelease(void *pBackendData, PCVDREGIONLIST pRegionList)
     5223{
     5224    RT_NOREF1(pRegionList);
     5225    LogFlowFunc(("pBackendData=%#p pRegionList=%#p\n", pBackendData, pRegionList));
     5226    PISCSIIMAGE pImage = (PISCSIIMAGE)pBackendData;
     5227    AssertPtr(pImage); RT_NOREF(pImage);
     5228
     5229    /* Nothing to do here. */
    52125230}
    52135231
    … …  
    55285546    /* pfnGetVersion */
    55295547    iscsiGetVersion,
    5530     /* pfnGetSectorSize */
    5531     iscsiGetSectorSize,
    5532     /* pfnGetSize */
    5533     iscsiGetSize,
    55345548    /* pfnGetFileSize */
    55355549    iscsiGetFileSize,
    … …  
    55435557    iscsiSetLCHSGeometry,
    55445558    /* pfnQueryRegions */
    5545     NULL,
     5559    iscsiQueryRegions,
    55465560    /* pfnRegionListRelease */
    5547     NULL,
     5561    iscsiRegionListRelease,
    55485562    /* pfnGetImageFlags */
    55495563    iscsiGetImageFlags,

  • trunk/src/VBox/Storage/Parallels.cpp

    r66110 r66486  
    9696    /** Current file size. */
    9797    uint64_t            cbFileCurrent;
     98    /** The static region list. */
     99    VDREGIONLIST        RegionList;
    98100} PARALLELSIMAGE, *PPARALLELSIMAGE;
    99101
    … …  
    248250    }
    249251
     252    if (RT_SUCCESS(rc))
     253    {
     254        PVDREGIONDESC pRegion = &pImage->RegionList.aRegions[0];
     255        pImage->RegionList.fFlags   = 0;
     256        pImage->RegionList.cRegions = 1;
     257
     258        pRegion->offRegion            = 0; /* Disk start. */
     259        pRegion->cbBlock              = 512;
     260        pRegion->enmDataForm          = VDREGIONDATAFORM_RAW;
     261        pRegion->enmMetadataForm      = VDREGIONMETADATAFORM_NONE;
     262        pRegion->cbData               = 512;
     263        pRegion->cbMetadata           = 0;
     264        pRegion->cRegionBlocksOrBytes = pImage->cbSize;
     265    }
     266
    250267    LogFlowFunc(("returns %Rrc\n", rc));
    251268    return rc;
    … …  
    336353        pfnProgress(pvUser, uPercentStart + uPercentSpan);
    337354
    338     if (RT_FAILURE(rc))
     355    if (RT_SUCCESS(rc))
     356    {
     357        PVDREGIONDESC pRegion = &pImage->RegionList.aRegions[0];
     358        pImage->RegionList.fFlags   = 0;
     359        pImage->RegionList.cRegions = 1;
     360
     361        pRegion->offRegion            = 0; /* Disk start. */
     362        pRegion->cbBlock              = 512;
     363        pRegion->enmDataForm          = VDREGIONDATAFORM_RAW;
     364        pRegion->enmMetadataForm      = VDREGIONMETADATAFORM_NONE;
     365        pRegion->cbData               = 512;
     366        pRegion->cbMetadata           = 0;
     367        pRegion->cRegionBlocksOrBytes = pImage->cbSize;
     368    }
     369    else
    339370        parallelsFreeImage(pImage, rc != VERR_ALREADY_EXISTS);
    340371    return rc;
    … …  
    417448    AssertReturn(VALID_PTR(pszFilename) && *pszFilename, VERR_INVALID_PARAMETER);
    418449
    419     pImage = (PPARALLELSIMAGE)RTMemAllocZ(sizeof(PARALLELSIMAGE));
     450    pImage = (PPARALLELSIMAGE)RTMemAllocZ(RT_UOFFSETOF(PARALLELSIMAGE, RegionList.aRegions[1]));
    420451    if (RT_LIKELY(pImage))
    421452    {
    … …  
    476507    }
    477508
    478     pImage = (PPARALLELSIMAGE)RTMemAllocZ(sizeof(PARALLELSIMAGE));
     509    pImage = (PPARALLELSIMAGE)RTMemAllocZ(RT_UOFFSETOF(PARALLELSIMAGE, RegionList.aRegions[1]));
    479510    if (RT_LIKELY(pImage))
    480511    {
    … …  
    715746}
    716747
    717 /** @copydoc VDIMAGEBACKEND::pfnGetSectorSize */
    718 static DECLCALLBACK(uint32_t) parallelsGetSectorSize(void *pBackendData)
    719 {
    720     LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    721     PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
    722     uint32_t cb = 0;
    723 
    724     AssertPtrReturn(pImage, 0);
    725 
    726     if (pImage->pStorage)
    727         cb = 512;
    728 
    729     LogFlowFunc(("returns %llu\n", cb));
    730     return cb;
    731 }
    732 
    733 /** @copydoc VDIMAGEBACKEND::pfnGetSize */
    734 static DECLCALLBACK(uint64_t) parallelsGetSize(void *pBackendData)
    735 {
    736     LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    737     PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
    738     uint64_t cb = 0;
    739 
    740     AssertPtrReturn(pImage, 0);
    741 
    742     if (pImage->pStorage)
    743         cb = pImage->cbSize;
    744 
    745     LogFlowFunc(("returns %llu\n", cb));
    746     return cb;
    747 }
    748 
    749748/** @copydoc VDIMAGEBACKEND::pfnGetFileSize */
    750749static DECLCALLBACK(uint64_t) parallelsGetFileSize(void *pBackendData)
    … …  
    838837    LogFlowFunc(("returns %Rrc\n", rc));
    839838    return rc;
     839}
     840
     841/** @copydoc VDIMAGEBACKEND::pfnQueryRegions */
     842static DECLCALLBACK(int) parallelsQueryRegions(void *pBackendData, PCVDREGIONLIST *ppRegionList)
     843{
     844    LogFlowFunc(("pBackendData=%#p ppRegionList=%#p\n", pBackendData, ppRegionList));
     845    PPARALLELSIMAGE pThis = (PPARALLELSIMAGE)pBackendData;
     846
     847    AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
     848
     849    *ppRegionList = &pThis->RegionList;
     850    LogFlowFunc(("returns %Rrc\n", VINF_SUCCESS));
     851    return VINF_SUCCESS;
     852}
     853
     854/** @copydoc VDIMAGEBACKEND::pfnRegionListRelease */
     855static DECLCALLBACK(void) parallelsRegionListRelease(void *pBackendData, PCVDREGIONLIST pRegionList)
     856{
     857    RT_NOREF1(pRegionList);
     858    LogFlowFunc(("pBackendData=%#p pRegionList=%#p\n", pBackendData, pRegionList));
     859    PPARALLELSIMAGE pThis = (PPARALLELSIMAGE)pBackendData;
     860    AssertPtr(pThis); RT_NOREF(pThis);
     861
     862    /* Nothing to do here. */
    840863}
    841864
    … …  
    10991122    /* pfnGetVersion */
    11001123    parallelsGetVersion,
    1101     /* pfnGetSectorSize */
    1102     parallelsGetSectorSize,
    1103     /* pfnGetSize */
    1104     parallelsGetSize,
    11051124    /* pfnGetFileSize */
    11061125    parallelsGetFileSize,
    … …  
    11141133    parallelsSetLCHSGeometry,
    11151134    /* pfnQueryRegions */
    1116     NULL,
     1135    parallelsQueryRegions,
    11171136    /* pfnRegionListRelease */
    1118     NULL,
     1137    parallelsRegionListRelease,
    11191138    /* pfnGetImageFlags */
    11201139    parallelsGetImageFlags,

  • trunk/src/VBox/Storage/QCOW.cpp

    r66110 r66486  
    251251     * (can be only one at a time). */
    252252    PQCOWL2CACHEENTRY   pL2TblAlloc;
    253 
     253    /** The static region list. */
     254    VDREGIONLIST        RegionList;
    254255} QCOWIMAGE, *PQCOWIMAGE;
    255256
    … …  
    12271228                       pImage->pszFilename);
    12281229
    1229     if (RT_FAILURE(rc))
     1230    if (RT_SUCCESS(rc))
     1231    {
     1232        PVDREGIONDESC pRegion = &pImage->RegionList.aRegions[0];
     1233        pImage->RegionList.fFlags   = 0;
     1234        pImage->RegionList.cRegions = 1;
     1235
     1236        pRegion->offRegion            = 0; /* Disk start. */
     1237        pRegion->cbBlock              = 512;
     1238        pRegion->enmDataForm          = VDREGIONDATAFORM_RAW;
     1239        pRegion->enmMetadataForm      = VDREGIONMETADATAFORM_NONE;
     1240        pRegion->cbData               = 512;
     1241        pRegion->cbMetadata           = 0;
     1242        pRegion->cRegionBlocksOrBytes = pImage->cbSize;
     1243    }
     1244    else
    12301245        qcowFreeImage(pImage, false);
    12311246    return rc;
    … …  
    13081323        vdIfProgress(pIfProgress, uPercentStart + uPercentSpan);
    13091324
    1310     if (RT_FAILURE(rc))
     1325    if (RT_SUCCESS(rc))
     1326    {
     1327        PVDREGIONDESC pRegion = &pImage->RegionList.aRegions[0];
     1328        pImage->RegionList.fFlags   = 0;
     1329        pImage->RegionList.cRegions = 1;
     1330
     1331        pRegion->offRegion            = 0; /* Disk start. */
     1332        pRegion->cbBlock              = 512;
     1333        pRegion->enmDataForm          = VDREGIONDATAFORM_RAW;
     1334        pRegion->enmMetadataForm      = VDREGIONMETADATAFORM_NONE;
     1335        pRegion->cbData               = 512;
     1336        pRegion->cbMetadata           = 0;
     1337        pRegion->cRegionBlocksOrBytes = pImage->cbSize;
     1338    }
     1339    else
    13111340        qcowFreeImage(pImage, rc != VERR_ALREADY_EXISTS);
    13121341    return rc;
    … …  
    15281557    AssertReturn((VALID_PTR(pszFilename) && *pszFilename), VERR_INVALID_PARAMETER);
    15291558
    1530     PQCOWIMAGE pImage = (PQCOWIMAGE)RTMemAllocZ(sizeof(QCOWIMAGE));
     1559    PQCOWIMAGE pImage = (PQCOWIMAGE)RTMemAllocZ(RT_UOFFSETOF(QCOWIMAGE, RegionList.aRegions[1]));
    15311560    if (RT_LIKELY(pImage))
    15321561    {
    … …  
    15751604                 && VALID_PTR(pLCHSGeometry), VERR_INVALID_PARAMETER);
    15761605
    1577     PQCOWIMAGE pImage = (PQCOWIMAGE)RTMemAllocZ(sizeof(QCOWIMAGE));
     1606    PQCOWIMAGE pImage = (PQCOWIMAGE)RTMemAllocZ(RT_UOFFSETOF(QCOWIMAGE, RegionList.aRegions[1]));
    15781607    if (RT_LIKELY(pImage))
    15791608    {
    … …  
    19181947}
    19191948
    1920 /** @copydoc VDIMAGEBACKEND::pfnGetSectorSize */
    1921 static DECLCALLBACK(uint32_t) qcowGetSectorSize(void *pBackendData)
    1922 {
    1923     LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    1924     PQCOWIMAGE pImage = (PQCOWIMAGE)pBackendData;
    1925     uint32_t cb = 0;
    1926 
    1927     AssertPtrReturn(pImage, 0);
    1928 
    1929     if (pImage->pStorage)
    1930         cb = 512;
    1931 
    1932     LogFlowFunc(("returns %u\n", cb));
    1933     return cb;
    1934 }
    1935 
    1936 /** @copydoc VDIMAGEBACKEND::pfnGetSize */
    1937 static DECLCALLBACK(uint64_t) qcowGetSize(void *pBackendData)
    1938 {
    1939     LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    1940     PQCOWIMAGE pImage = (PQCOWIMAGE)pBackendData;
    1941     uint64_t cb = 0;
    1942 
    1943     AssertPtrReturn(pImage, 0);
    1944 
    1945     if (pImage->pStorage)
    1946         cb = pImage->cbSize;
    1947 
    1948     LogFlowFunc(("returns %llu\n", cb));
    1949     return cb;
    1950 }
    1951 
    19521949/** @copydoc VDIMAGEBACKEND::pfnGetFileSize */
    19531950static DECLCALLBACK(uint64_t) qcowGetFileSize(void *pBackendData)
    … …  
    20442041    LogFlowFunc(("returns %Rrc\n", rc));
    20452042    return rc;
     2043}
     2044
     2045/** @copydoc VDIMAGEBACKEND::pfnQueryRegions */
     2046static DECLCALLBACK(int) qcowQueryRegions(void *pBackendData, PCVDREGIONLIST *ppRegionList)
     2047{
     2048    LogFlowFunc(("pBackendData=%#p ppRegionList=%#p\n", pBackendData, ppRegionList));
     2049    PQCOWIMAGE pThis = (PQCOWIMAGE)pBackendData;
     2050
     2051    AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
     2052
     2053    *ppRegionList = &pThis->RegionList;
     2054    LogFlowFunc(("returns %Rrc\n", VINF_SUCCESS));
     2055    return VINF_SUCCESS;
     2056}
     2057
     2058/** @copydoc VDIMAGEBACKEND::pfnRegionListRelease */
     2059static DECLCALLBACK(void) qcowRegionListRelease(void *pBackendData, PCVDREGIONLIST pRegionList)
     2060{
     2061    RT_NOREF1(pRegionList);
     2062    LogFlowFunc(("pBackendData=%#p pRegionList=%#p\n", pBackendData, pRegionList));
     2063    PQCOWIMAGE pThis = (PQCOWIMAGE)pBackendData;
     2064    AssertPtr(pThis); RT_NOREF(pThis);
     2065
     2066    /* Nothing to do here. */
    20462067}
    20472068
    … …  
    23692390    /* pfnGetVersion */
    23702391    qcowGetVersion,
    2371     /* pfnGetSectorSize */
    2372     qcowGetSectorSize,
    2373     /* pfnGetSize */
    2374     qcowGetSize,
    23752392    /* pfnGetFileSize */
    23762393    qcowGetFileSize,
    … …  
    23842401    qcowSetLCHSGeometry,
    23852402    /* pfnQueryRegions */
    2386     NULL,
     2403    qcowQueryRegions,
    23872404    /* pfnRegionListRelease */
    2388     NULL,
     2405    qcowRegionListRelease,
    23892406    /* pfnGetImageFlags */
    23902407    qcowGetImageFlags,

  • trunk/src/VBox/Storage/QED.cpp

    r66110 r66486  
    217217    /** The LRU L2 entry list used for eviction. */
    218218    RTLISTNODE          ListLru;
    219 
     219    /** The static region list. */
     220    VDREGIONLIST        RegionList;
    220221} QEDIMAGE, *PQEDIMAGE;
    221222
    … …  
    12421243                       pImage->pszFilename);
    12431244
    1244     if (RT_FAILURE(rc))
     1245    if (RT_SUCCESS(rc))
     1246    {
     1247        PVDREGIONDESC pRegion = &pImage->RegionList.aRegions[0];
     1248        pImage->RegionList.fFlags   = 0;
     1249        pImage->RegionList.cRegions = 1;
     1250
     1251        pRegion->offRegion            = 0; /* Disk start. */
     1252        pRegion->cbBlock              = 512;
     1253        pRegion->enmDataForm          = VDREGIONDATAFORM_RAW;
     1254        pRegion->enmMetadataForm      = VDREGIONMETADATAFORM_NONE;
     1255        pRegion->cbData               = 512;
     1256        pRegion->cbMetadata           = 0;
     1257        pRegion->cRegionBlocksOrBytes = pImage->cbSize;
     1258    }
     1259    else
    12451260        qedFreeImage(pImage, false);
    12461261    return rc;
    … …  
    13121327
    13131328    if (RT_SUCCESS(rc))
     1329    {
     1330        PVDREGIONDESC pRegion = &pImage->RegionList.aRegions[0];
     1331        pImage->RegionList.fFlags   = 0;
     1332        pImage->RegionList.cRegions = 1;
     1333
     1334        pRegion->offRegion            = 0; /* Disk start. */
     1335        pRegion->cbBlock              = 512;
     1336        pRegion->enmDataForm          = VDREGIONDATAFORM_RAW;
     1337        pRegion->enmMetadataForm      = VDREGIONMETADATAFORM_NONE;
     1338        pRegion->cbData               = 512;
     1339        pRegion->cbMetadata           = 0;
     1340        pRegion->cRegionBlocksOrBytes = pImage->cbSize;
     1341
    13141342        vdIfProgress(pIfProgress, uPercentStart + uPercentSpan);
     1343    }
    13151344    else
    13161345        qedFreeImage(pImage, rc != VERR_ALREADY_EXISTS);
    … …  
    15321561    AssertReturn((VALID_PTR(pszFilename) && *pszFilename), VERR_INVALID_PARAMETER);
    15331562
    1534     PQEDIMAGE pImage = (PQEDIMAGE)RTMemAllocZ(sizeof(QEDIMAGE));
     1563    PQEDIMAGE pImage = (PQEDIMAGE)RTMemAllocZ(RT_UOFFSETOF(QEDIMAGE, RegionList.aRegions[1]));
    15351564    if (RT_LIKELY(pImage))
    15361565    {
    … …  
    15791608                 && VALID_PTR(pLCHSGeometry), VERR_INVALID_PARAMETER);
    15801609
    1581     PQEDIMAGE pImage = (PQEDIMAGE)RTMemAllocZ(sizeof(QEDIMAGE));
     1610    PQEDIMAGE pImage = (PQEDIMAGE)RTMemAllocZ(RT_UOFFSETOF(QEDIMAGE, RegionList.aRegions[1]));
    15821611    if (RT_LIKELY(pImage))
    15831612    {
    … …  
    19251954}
    19261955
    1927 /** @copydoc VDIMAGEBACKEND::pfnGetSectorSize */
    1928 static DECLCALLBACK(uint32_t) qedGetSectorSize(void *pBackendData)
    1929 {
    1930     LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    1931     PQEDIMAGE pImage = (PQEDIMAGE)pBackendData;
    1932     uint32_t cb = 0;
    1933 
    1934     AssertPtrReturn(pImage, 0);
    1935 
    1936     if (pImage->pStorage)
    1937         cb = 512;
    1938 
    1939     LogFlowFunc(("returns %u\n", cb));
    1940     return cb;
    1941 }
    1942 
    1943 /** @copydoc VDIMAGEBACKEND::pfnGetSize */
    1944 static DECLCALLBACK(uint64_t) qedGetSize(void *pBackendData)
    1945 {
    1946     LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    1947     PQEDIMAGE pImage = (PQEDIMAGE)pBackendData;
    1948     uint64_t cb = 0;
    1949 
    1950     AssertPtrReturn(pImage, 0);
    1951 
    1952     if (pImage->pStorage)
    1953         cb = pImage->cbSize;
    1954 
    1955     LogFlowFunc(("returns %llu\n", cb));
    1956     return cb;
    1957 }
    1958 
    19591956/** @copydoc VDIMAGEBACKEND::pfnGetFileSize */
    19601957static DECLCALLBACK(uint64_t) qedGetFileSize(void *pBackendData)
    … …  
    20532050    LogFlowFunc(("returns %Rrc\n", rc));
    20542051    return rc;
     2052}
     2053
     2054/** @copydoc VDIMAGEBACKEND::pfnQueryRegions */
     2055static DECLCALLBACK(int) qedQueryRegions(void *pBackendData, PCVDREGIONLIST *ppRegionList)
     2056{
     2057    LogFlowFunc(("pBackendData=%#p ppRegionList=%#p\n", pBackendData, ppRegionList));
     2058    PQEDIMAGE pThis = (PQEDIMAGE)pBackendData;
     2059
     2060    AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
     2061
     2062    *ppRegionList = &pThis->RegionList;
     2063    LogFlowFunc(("returns %Rrc\n", VINF_SUCCESS));
     2064    return VINF_SUCCESS;
     2065}
     2066
     2067/** @copydoc VDIMAGEBACKEND::pfnRegionListRelease */
     2068static DECLCALLBACK(void) qedRegionListRelease(void *pBackendData, PCVDREGIONLIST pRegionList)
     2069{
     2070    RT_NOREF1(pRegionList);
     2071    LogFlowFunc(("pBackendData=%#p pRegionList=%#p\n", pBackendData, pRegionList));
     2072    PQEDIMAGE pThis = (PQEDIMAGE)pBackendData;
     2073    AssertPtr(pThis); RT_NOREF(pThis);
     2074
     2075    /* Nothing to do here. */
    20552076}
    20562077
    … …  
    24222443    /* pfnGetVersion */
    24232444    qedGetVersion,
    2424     /* pfnGetSectorSize */
    2425     qedGetSectorSize,
    2426     /* pfnGetSize */
    2427     qedGetSize,
    24282445    /* pfnGetFileSize */
    24292446    qedGetFileSize,
    … …  
    24372454    qedSetLCHSGeometry,
    24382455    /* pfnQueryRegions */
    2439     NULL,
     2456    qedQueryRegions,
    24402457    /* pfnRegionListRelease */
    2441     NULL,
     2458    qedRegionListRelease,
    24422459    /* pfnGetImageFlags */
    24432460    qedGetImageFlags,

  • trunk/src/VBox/Storage/RAW.cpp

    r66211 r66486  
    7171    /** Sector size of the image. */
    7272    uint32_t            cbSector;
     73    /** The static region list. */
     74    VDREGIONLIST        RegionList;
    7375} RAWIMAGE, *PRAWIMAGE;
    7476
    … …  
    210212     *       choice of retrying the open if it failed. */
    211213
    212     if (RT_FAILURE(rc))
     214    if (RT_SUCCESS(rc))
     215    {
     216        PVDREGIONDESC pRegion = &pImage->RegionList.aRegions[0];
     217        pImage->RegionList.fFlags   = 0;
     218        pImage->RegionList.cRegions = 1;
     219
     220        pRegion->offRegion            = 0; /* Disk start. */
     221        pRegion->cbBlock              = pImage->cbSector;
     222        pRegion->enmDataForm          = VDREGIONDATAFORM_RAW;
     223        pRegion->enmMetadataForm      = VDREGIONMETADATAFORM_NONE;
     224        pRegion->cbData               = pImage->cbSector;
     225        pRegion->cbMetadata           = 0;
     226        pRegion->cRegionBlocksOrBytes = pImage->cbSize;
     227    }
     228    else
    213229        rawFreeImage(pImage, false);
    214230    return rc;
    … …  
    282298
    283299    if (RT_SUCCESS(rc))
     300    {
     301        PVDREGIONDESC pRegion = &pImage->RegionList.aRegions[0];
     302        pImage->RegionList.fFlags   = 0;
     303        pImage->RegionList.cRegions = 1;
     304
     305        pRegion->offRegion            = 0; /* Disk start. */
     306        pRegion->cbBlock              = pImage->cbSector;
     307        pRegion->enmDataForm          = VDREGIONDATAFORM_RAW;
     308        pRegion->enmMetadataForm      = VDREGIONMETADATAFORM_NONE;
     309        pRegion->cbData               = pImage->cbSector;
     310        pRegion->cbMetadata           = 0;
     311        pRegion->cRegionBlocksOrBytes = pImage->cbSize;
     312
    284313        vdIfProgress(pIfProgress, uPercentStart + uPercentSpan);
     314    }
    285315
    286316    if (RT_FAILURE(rc))
    … …  
    382412    AssertReturn((VALID_PTR(pszFilename) && *pszFilename), VERR_INVALID_PARAMETER);
    383413
    384     pImage = (PRAWIMAGE)RTMemAllocZ(sizeof(RAWIMAGE));
     414    pImage = (PRAWIMAGE)RTMemAllocZ(RT_UOFFSETOF(RAWIMAGE, RegionList.aRegions[1]));
    385415    if (RT_LIKELY(pImage))
    386416    {
    … …  
    438468                 && VALID_PTR(pLCHSGeometry), VERR_INVALID_PARAMETER);
    439469
    440     PRAWIMAGE pImage = (PRAWIMAGE)RTMemAllocZ(sizeof(RAWIMAGE));
     470    PRAWIMAGE pImage = (PRAWIMAGE)RTMemAllocZ(RT_UOFFSETOF(RAWIMAGE, RegionList.aRegions[1]));
    441471    if (RT_LIKELY(pImage))
    442472    {
    … …  
    602632}
    603633
    604 /** @copydoc VDIMAGEBACKEND::pfnGetSize */
    605 static DECLCALLBACK(uint32_t) rawGetSectorSize(void *pBackendData)
    606 {
    607     LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    608     PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
    609     uint32_t cb = 0;
    610 
    611     AssertPtrReturn(pImage, 0);
    612 
    613     if (pImage->pStorage)
    614         cb = pImage->cbSector;
    615 
    616     LogFlowFunc(("returns %u\n", cb));
    617     return cb;
    618 }
    619 
    620 /** @copydoc VDIMAGEBACKEND::pfnGetSize */
    621 static DECLCALLBACK(uint64_t) rawGetSize(void *pBackendData)
    622 {
    623     LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    624     PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
    625     uint64_t cb = 0;
    626 
    627     AssertPtrReturn(pImage, 0);
    628 
    629     if (pImage->pStorage)
    630         cb = pImage->cbSize;
    631 
    632     LogFlowFunc(("returns %llu\n", cb));
    633     return cb;
    634 }
    635 
    636634/** @copydoc VDIMAGEBACKEND::pfnGetFileSize */
    637635static DECLCALLBACK(uint64_t) rawGetFileSize(void *pBackendData)
    … …  
    730728    LogFlowFunc(("returns %Rrc\n", rc));
    731729    return rc;
     730}
     731
     732/** @copydoc VDIMAGEBACKEND::pfnQueryRegions */
     733static DECLCALLBACK(int) rawQueryRegions(void *pBackendData, PCVDREGIONLIST *ppRegionList)
     734{
     735    LogFlowFunc(("pBackendData=%#p ppRegionList=%#p\n", pBackendData, ppRegionList));
     736    PRAWIMAGE pThis = (PRAWIMAGE)pBackendData;
     737
     738    AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
     739
     740    *ppRegionList = &pThis->RegionList;
     741    LogFlowFunc(("returns %Rrc\n", VINF_SUCCESS));
     742    return VINF_SUCCESS;
     743}
     744
     745/** @copydoc VDIMAGEBACKEND::pfnRegionListRelease */
     746static DECLCALLBACK(void) rawRegionListRelease(void *pBackendData, PCVDREGIONLIST pRegionList)
     747{
     748    RT_NOREF1(pRegionList);
     749    LogFlowFunc(("pBackendData=%#p pRegionList=%#p\n", pBackendData, pRegionList));
     750    PRAWIMAGE pThis = (PRAWIMAGE)pBackendData;
     751    AssertPtr(pThis); RT_NOREF(pThis);
     752
     753    /* Nothing to do here. */
    732754}
    733755
    … …  
    9931015    /* pfnGetVersion */
    9941016    rawGetVersion,
    995     /* pfnGetSectorSize */
    996     rawGetSectorSize,
    997     /* pfnGetSize */
    998     rawGetSize,
    9991017    /* pfnGetFileSize */
    10001018    rawGetFileSize,
    … …  
    10081026    rawSetLCHSGeometry,
    10091027    /* pfnQueryRegions */
    1010     NULL,
     1028    rawQueryRegions,
    10111029    /* pfnRegionListRelease */
    1012     NULL,
     1030    rawRegionListRelease,
    10131031    /* pfnGetImageFlags */
    10141032    rawGetImageFlags,

  • trunk/src/VBox/Storage/VD.cpp

    r66378 r66486  
    531531    }
    532532    return pImage;
     533}
     534
     535/**
     536 * Creates a new region list from the given one converting to match the flags if necessary.
     537 *
     538 * @returns VBox status code.
     539 * @param   pRegionList     The region list to convert from.
     540 * @param   fFlags          The flags for the new region list.
     541 * @param   ppRegionList    Where to store the new region list on success.
     542 */
     543static int vdRegionListConv(PCVDREGIONLIST pRegionList, uint32_t fFlags, PPVDREGIONLIST ppRegionList)
     544{
     545    int rc = VINF_SUCCESS;
     546    PVDREGIONLIST pRegionListNew = (PVDREGIONLIST)RTMemDup(pRegionList, RT_UOFFSETOF(VDREGIONLIST, aRegions[pRegionList->cRegions]));
     547    if (RT_LIKELY(pRegionListNew))
     548    {
     549        /* Do we have to convert anything? */
     550        if (pRegionList->fFlags != fFlags)
     551        {
     552            uint64_t offRegionNext = 0;
     553
     554            pRegionListNew->fFlags = fFlags;
     555            for (unsigned i = 0; i < pRegionListNew->cRegions; i++)
     556            {
     557                PVDREGIONDESC pRegion = &pRegionListNew->aRegions[i];
     558
     559                if (   (fFlags & VD_REGION_LIST_F_LOC_SIZE_BLOCKS)
     560                    && !(pRegionList->fFlags & VD_REGION_LIST_F_LOC_SIZE_BLOCKS))
     561                {
     562                    Assert(!(pRegion->cRegionBlocksOrBytes % pRegion->cbBlock));
     563
     564                    /* Convert from bytes to logical blocks. */
     565                    pRegion->offRegion            = offRegionNext;
     566                    pRegion->cRegionBlocksOrBytes = pRegion->cRegionBlocksOrBytes / pRegion->cbBlock;
     567                    offRegionNext += pRegion->cRegionBlocksOrBytes;
     568                }
     569                else
     570                {
     571                    /* Convert from logical blocks to bytes. */
     572                    pRegion->offRegion            = offRegionNext;
     573                    pRegion->cRegionBlocksOrBytes = pRegion->cRegionBlocksOrBytes * pRegion->cbBlock;
     574                    offRegionNext += pRegion->cRegionBlocksOrBytes;
     575                }
     576            }
     577        }
     578
     579        *ppRegionList = pRegionListNew;
     580    }
     581    else
     582        rc = VERR_NO_MEMORY;
     583
     584    return rc;
     585}
     586
     587/**
     588 * Returns the virtual size of the image in bytes.
     589 *
     590 * @returns Size of the given image in bytes.
     591 * @param   
     592 */
     593static uint64_t vdImageGetSize(PVDIMAGE pImage)
     594{
     595    uint64_t cbImage = 0;
     596    PCVDREGIONLIST pRegionList = NULL;
     597    int rc = pImage->Backend->pfnQueryRegions(pImage->pBackendData, &pRegionList);
     598    if (RT_SUCCESS(rc))
     599    {
     600        if (pRegionList->fFlags & VD_REGION_LIST_F_LOC_SIZE_BLOCKS)
     601        {
     602            PVDREGIONLIST pRegionListConv = NULL;
     603            rc = vdRegionListConv(pRegionList, 0, &pRegionListConv);
     604            if (RT_SUCCESS(rc))
     605            {
     606                for (uint32_t i = 0; i < pRegionListConv->cRegions; i++)
     607                    cbImage += pRegionListConv->aRegions[i].cRegionBlocksOrBytes;
     608
     609                VDRegionListFree(pRegionListConv);
     610            }
     611        }
     612        else
     613            for (uint32_t i = 0; i < pRegionList->cRegions; i++)
     614                cbImage += pRegionList->aRegions[i].cRegionBlocksOrBytes;
     615
     616        AssertPtr(pImage->Backend->pfnRegionListRelease);
     617        pImage->Backend->pfnRegionListRelease(pImage->pBackendData, pRegionList);
     618    }
     619
     620    return cbImage;
    533621}
    534622
    … …  
    45914679    PVDIO    pVDIo = (PVDIO)pvUser;
    45924680    PVDISK pDisk = pVDIo->pDisk;
     4681    size_t cbSector = 0;
    45934682
    45944683    PVDIMAGE pImage = vdGetImageByNumber(pDisk, VD_LAST_IMAGE);
    45954684    AssertPtrReturn(pImage, 0);
    4596     return pImage->Backend->pfnGetSectorSize(pImage->pBackendData);
     4685
     4686    PCVDREGIONLIST pRegionList = NULL;
     4687    int rc = pImage->Backend->pfnQueryRegions(pImage->pBackendData, &pRegionList);
     4688    if (RT_SUCCESS(rc))
     4689    {
     4690        cbSector = pRegionList->aRegions[0].cbBlock;
     4691
     4692        AssertPtr(pImage->Backend->pfnRegionListRelease);
     4693        pImage->Backend->pfnRegionListRelease(pImage->pBackendData, pRegionList);
     4694    }
     4695
     4696    return cbSector;
    45974697}
    45984698
    … …  
    48964996
    48974997    RTSemEventSignal(hEvent);
    4898 }
    4899 
    4900 /**
    4901  * Creates a new region list from the given one converting to match the flags if necessary.
    4902  *
    4903  * @returns VBox status code.
    4904  * @param   pRegionList     The region list to convert from.
    4905  * @param   fFlags          The flags for the new region list.
    4906  * @param   ppRegionList    Where to store the new region list on success.
    4907  */
    4908 static int vdRegionListConv(PCVDREGIONLIST pRegionList, uint32_t fFlags, PPVDREGIONLIST ppRegionList)
    4909 {
    4910     int rc = VINF_SUCCESS;
    4911     PVDREGIONLIST pRegionListNew = (PVDREGIONLIST)RTMemDup(pRegionList, RT_UOFFSETOF(VDREGIONLIST, aRegions[pRegionList->cRegions]));
    4912     if (RT_LIKELY(pRegionListNew))
    4913     {
    4914         /* Do we have to convert anything? */
    4915         if (pRegionList->fFlags != fFlags)
    4916         {
    4917             uint64_t offRegionNext = 0;
    4918 
    4919             pRegionListNew->fFlags = fFlags;
    4920             for (unsigned i = 0; i < pRegionListNew->cRegions; i++)
    4921             {
    4922                 PVDREGIONDESC pRegion = &pRegionListNew->aRegions[i];
    4923 
    4924                 if (   (fFlags & VD_REGION_LIST_F_LOC_SIZE_BLOCKS)
    4925                     && !(pRegionList->fFlags & VD_REGION_LIST_F_LOC_SIZE_BLOCKS))
    4926                 {
    4927                     Assert(!(pRegion->cRegionBlocksOrBytes % pRegion->cbBlock));
    4928 
    4929                     /* Convert from bytes to logical blocks. */
    4930                     pRegion->offRegion            = offRegionNext;
    4931                     pRegion->cRegionBlocksOrBytes = pRegion->cRegionBlocksOrBytes / pRegion->cbBlock;
    4932                     offRegionNext += pRegion->cRegionBlocksOrBytes;
    4933                 }
    4934                 else
    4935                 {
    4936                     /* Convert from logical blocks to bytes. */
    4937                     pRegion->offRegion            = offRegionNext;
    4938                     pRegion->cRegionBlocksOrBytes = pRegion->cRegionBlocksOrBytes * pRegion->cbBlock;
    4939                     offRegionNext += pRegion->cRegionBlocksOrBytes;
    4940                 }
    4941             }
    4942         }
    4943 
    4944         *ppRegionList = pRegionListNew;
    4945     }
    4946     else
    4947         rc = VERR_NO_MEMORY;
    4948 
    4949     return rc;
    49504998}
    49514999
    … …  
    57295777
    57305778        /* Cache disk information. */
    5731         pDisk->cbSize = pImage->Backend->pfnGetSize(pImage->pBackendData);
     5779        pDisk->cbSize = vdImageGetSize(pImage);
    57325780
    57335781        /* Cache PCHS geometry. */
    … …  
    63056353        {
    63066354            /* Cache disk information. */
    6307             pDisk->cbSize = pImage->Backend->pfnGetSize(pImage->pBackendData);
     6355            pDisk->cbSize = vdImageGetSize(pImage);
    63086356
    63096357            /* Cache PCHS geometry. */
    … …  
    69416989
    69426990        /* Get size of destination image. */
    6943         uint64_t cbSize = pImageTo->Backend->pfnGetSize(pImageTo->pBackendData);
     6991        uint64_t cbSize = vdImageGetSize(pImageTo);
    69446992        rc2 = vdThreadFinishWrite(pDisk);
    69456993        AssertRC(rc2);
    … …  
    74187466
    74197467        uint64_t cbSizeFrom;
    7420         cbSizeFrom = pImageFrom->Backend->pfnGetSize(pImageFrom->pBackendData);
     7468        cbSizeFrom = vdImageGetSize(pImageFrom);
    74217469        if (cbSizeFrom == 0)
    74227470        {
    … …  
    75217569
    75227570            uint64_t cbSizeTo;
    7523             cbSizeTo = pImageTo->Backend->pfnGetSize(pImageTo->pBackendData);
     7571            cbSizeTo = vdImageGetSize(pImageTo);
    75247572            if (cbSizeTo == 0)
    75257573            {
    … …  
    80128060            {
    80138061                /* Get size of image. */
    8014                 uint64_t cbSize = pImage->Backend->pfnGetSize(pImage->pBackendData);
     8062                uint64_t cbSize = vdImageGetSize(pImage);
    80158063                uint64_t cbSizeFile = pImage->Backend->pfnGetFileSize(pImage->pBackendData);
    80168064                uint64_t cbFileWritten = 0;
    … …  
    81888236
    81898237        /* Cache disk information. */
    8190         pDisk->cbSize = pImage->Backend->pfnGetSize(pImage->pBackendData);
     8238        pDisk->cbSize = vdImageGetSize(pImage);
    81918239
    81928240        /* Cache PCHS geometry. */
    … …  
    87518799        PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
    87528800        AssertPtrBreakStmt(pImage, cbSector = 0);
    8753         cbSector = pImage->Backend->pfnGetSectorSize(pImage->pBackendData);
     8801
     8802        PCVDREGIONLIST pRegionList = NULL;
     8803        int rc = pImage->Backend->pfnQueryRegions(pImage->pBackendData, &pRegionList);
     8804        if (RT_SUCCESS(rc))
     8805        {
     8806            AssertBreakStmt(pRegionList->cRegions == 1, cbSector = 0);
     8807            cbSector = pRegionList->aRegions[0].cbBlock;
     8808
     8809            AssertPtr(pImage->Backend->pfnRegionListRelease);
     8810            pImage->Backend->pfnRegionListRelease(pImage->pBackendData, pRegionList);
     8811        }
    87548812    } while (0);
    87558813
    … …  
    87918849        PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
    87928850        AssertPtrBreakStmt(pImage, cbSize = 0);
    8793         cbSize = pImage->Backend->pfnGetSize(pImage->pBackendData);
     8851
     8852        cbSize = vdImageGetSize(pImage);
    87948853    } while (0);
    87958854
    … …  
    92199278        AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
    92209279
    9221         if (pImage->Backend->pfnQueryRegions)
    9222         {
    9223             PCVDREGIONLIST pRegionList = NULL;
    9224             rc = pImage->Backend->pfnQueryRegions(pImage->pBackendData, &pRegionList);
    9225             if (RT_SUCCESS(rc))
    9226             {
    9227                 rc = vdRegionListConv(pRegionList, fFlags, ppRegionList);
    9228 
    9229                 AssertPtr(pImage->Backend->pfnRegionListRelease);
    9230                 pImage->Backend->pfnRegionListRelease(pImage->pBackendData, pRegionList);
    9231             }
    9232         }
    9233         else
    9234             rc = VERR_NOT_SUPPORTED;
    9235 
    9236         if (rc == VERR_NOT_SUPPORTED)
    9237         {
    9238             /*
    9239              * Create a list with a single region containing the data gathered from the
    9240              * image and sector size.
    9241              */
    9242             PVDREGIONLIST pRegionList = (PVDREGIONLIST)RTMemAllocZ(RT_UOFFSETOF(VDREGIONLIST, aRegions[1]));
    9243             if (RT_LIKELY(pRegionList))
    9244             {
    9245                 uint32_t cbSector = pImage->Backend->pfnGetSectorSize(pImage->pBackendData);
    9246                 uint64_t cbImage = pImage->Backend->pfnGetSize(pImage->pBackendData);
    9247 
    9248                 pRegionList->cRegions = 1;
    9249                 pRegionList->fFlags   = fFlags;
    9250 
    9251                 /*
    9252                  * Single region starting at the first byte/block covering the whole image,
    9253                  * block size equals sector size and contains no metadata.
    9254                  */
    9255                 PVDREGIONDESC pRegion = &pRegionList->aRegions[0];
    9256                 pRegion->offRegion       = 0; /* Disk start. */
    9257                 pRegion->cbBlock         = cbSector;
    9258                 pRegion->enmDataForm     = VDREGIONDATAFORM_RAW;
    9259                 pRegion->enmMetadataForm = VDREGIONMETADATAFORM_NONE;
    9260                 pRegion->cbData          = cbSector;
    9261                 pRegion->cbMetadata      = 0;
    9262                 if (fFlags & VD_REGION_LIST_F_LOC_SIZE_BLOCKS)
    9263                     pRegion->cRegionBlocksOrBytes = cbImage / cbSector;
    9264                 else
    9265                     pRegion->cRegionBlocksOrBytes = cbImage;
    9266 
    9267                 *ppRegionList  = pRegionList;
    9268                 rc = VINF_SUCCESS;
    9269             }
    9270             else
    9271                 rc = VERR_NO_MEMORY;
     9280        PCVDREGIONLIST pRegionList = NULL;
     9281        rc = pImage->Backend->pfnQueryRegions(pImage->pBackendData, &pRegionList);
     9282        if (RT_SUCCESS(rc))
     9283        {
     9284            rc = vdRegionListConv(pRegionList, fFlags, ppRegionList);
     9285
     9286            AssertPtr(pImage->Backend->pfnRegionListRelease);
     9287            pImage->Backend->pfnRegionListRelease(pImage->pBackendData, pRegionList);
    92729288        }
    92739289    } while (0);

  • trunk/src/VBox/Storage/VDI.cpp

    r66110 r66486  
    731731
    732732    if (RT_SUCCESS(rc))
     733    {
     734        PVDREGIONDESC pRegion = &pImage->RegionList.aRegions[0];
     735        pImage->RegionList.fFlags   = 0;
     736        pImage->RegionList.cRegions = 1;
     737
     738        pRegion->offRegion            = 0; /* Disk start. */
     739        pRegion->cbBlock              = 512;
     740        pRegion->enmDataForm          = VDREGIONDATAFORM_RAW;
     741        pRegion->enmMetadataForm      = VDREGIONMETADATAFORM_NONE;
     742        pRegion->cbData               = 512;
     743        pRegion->cbMetadata           = 0;
     744        pRegion->cRegionBlocksOrBytes = getImageDiskSize(&pImage->Header);
     745
    733746        vdIfProgress(pIfProgress, uPercentStart + uPercentSpan);
     747    }
    734748
    735749    if (RT_FAILURE(rc))
    … …  
    962976     *       choice of retrying the open if it failed. */
    963977
    964     if (RT_FAILURE(rc))
     978    if (RT_SUCCESS(rc))
     979    {
     980        PVDREGIONDESC pRegion = &pImage->RegionList.aRegions[0];
     981        pImage->RegionList.fFlags   = 0;
     982        pImage->RegionList.cRegions = 1;
     983
     984        pRegion->offRegion            = 0; /* Disk start. */
     985        pRegion->cbBlock              = 512;
     986        pRegion->enmDataForm          = VDREGIONDATAFORM_RAW;
     987        pRegion->enmMetadataForm      = VDREGIONMETADATAFORM_NONE;
     988        pRegion->cbData               = 512;
     989        pRegion->cbMetadata           = 0;
     990        pRegion->cRegionBlocksOrBytes = getImageDiskSize(&pImage->Header);
     991    }
     992    else
    965993        vdiFreeImage(pImage, false);
    966994    return rc;
    … …  
    13911419    AssertReturn((VALID_PTR(pszFilename) && *pszFilename), VERR_INVALID_PARAMETER);
    13921420
    1393     PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)RTMemAllocZ(sizeof(VDIIMAGEDESC));
     1421    PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)RTMemAllocZ(RT_UOFFSETOF(VDIIMAGEDESC, RegionList.aRegions[1]));
    13941422    if (RT_LIKELY(pImage))
    13951423    {
    … …  
    14471475                 && VALID_PTR(pLCHSGeometry), VERR_INVALID_PARAMETER);
    14481476
    1449     PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)RTMemAllocZ(sizeof(VDIIMAGEDESC));
     1477    PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)RTMemAllocZ(RT_UOFFSETOF(VDIIMAGEDESC, RegionList.aRegions[1]));
    14501478    if (RT_LIKELY(pImage))
    14511479    {
    … …  
    17361764}
    17371765
    1738 /** @copydoc VDIMAGEBACKEND::pfnGetSectorSize */
    1739 static DECLCALLBACK(uint32_t) vdiGetSectorSize(void *pBackendData)
    1740 {
    1741     LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    1742     PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
    1743     uint64_t cbSector = 0;
    1744 
    1745     AssertPtrReturn(pImage, 0);
    1746 
    1747     if (pImage->pStorage)
    1748         cbSector = 512;
    1749 
    1750     LogFlowFunc(("returns %zu\n", cbSector));
    1751     return cbSector;
    1752 }
    1753 
    1754 /** @copydoc VDIMAGEBACKEND::pfnGetSize */
    1755 static DECLCALLBACK(uint64_t) vdiGetSize(void *pBackendData)
    1756 {
    1757     LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    1758     PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
    1759 
    1760     AssertPtrReturn(pImage, 0);
    1761 
    1762     LogFlowFunc(("returns %llu\n", getImageDiskSize(&pImage->Header)));
    1763     return getImageDiskSize(&pImage->Header);
    1764 }
    1765 
    17661766/** @copydoc VDIMAGEBACKEND::pfnGetFileSize */
    17671767static DECLCALLBACK(uint64_t) vdiGetFileSize(void *pBackendData)
    … …  
    18811881    LogFlowFunc(("returns %Rrc\n", rc));
    18821882    return rc;
     1883}
     1884
     1885/** @copydoc VDIMAGEBACKEND::pfnQueryRegions */
     1886static DECLCALLBACK(int) vdiQueryRegions(void *pBackendData, PCVDREGIONLIST *ppRegionList)
     1887{
     1888    LogFlowFunc(("pBackendData=%#p ppRegionList=%#p\n", pBackendData, ppRegionList));
     1889    PVDIIMAGEDESC pThis = (PVDIIMAGEDESC)pBackendData;
     1890
     1891    AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
     1892
     1893    *ppRegionList = &pThis->RegionList;
     1894    LogFlowFunc(("returns %Rrc\n", VINF_SUCCESS));
     1895    return VINF_SUCCESS;
     1896}
     1897
     1898/** @copydoc VDIMAGEBACKEND::pfnRegionListRelease */
     1899static DECLCALLBACK(void) vdiRegionListRelease(void *pBackendData, PCVDREGIONLIST pRegionList)
     1900{
     1901    RT_NOREF1(pRegionList);
     1902    LogFlowFunc(("pBackendData=%#p pRegionList=%#p\n", pBackendData, pRegionList));
     1903    PVDIIMAGEDESC pThis = (PVDIIMAGEDESC)pBackendData;
     1904    AssertPtr(pThis); RT_NOREF(pThis);
     1905
     1906    /* Nothing to do here. */
    18831907}
    18841908
    … …  
    31243148    /* pfnGetVersion */
    31253149    vdiGetVersion,
    3126     /* pfnGetSectorSize */
    3127     vdiGetSectorSize,
    3128     /* pfnGetSize */
    3129     vdiGetSize,
    31303150    /* pfnGetFileSize */
    31313151    vdiGetFileSize,
    … …  
    31393159    vdiSetLCHSGeometry,
    31403160    /* pfnQueryRegions */
    3141     NULL,
     3161    vdiQueryRegions,
    31423162    /* pfnRegionListRelease */
    3143     NULL,
     3163    vdiRegionListRelease,
    31443164    /* pfnGetImageFlags */
    31453165    vdiGetImageFlags,

  • trunk/src/VBox/Storage/VDICore.h

    r62740 r66486  
    564564    /** Current size of the image (used for range validation when reading). */
    565565    uint64_t                cbImage;
     566    /** The static region list. */
     567    VDREGIONLIST            RegionList;
    566568} VDIIMAGEDESC, *PVDIIMAGEDESC;
    567569

  • trunk/src/VBox/Storage/VDInternal.h

    r66378 r66486  
    272272DECLHIDDEN(int)      vdFindFilterBackend(const char *pszFilter, PCVDFILTERBACKEND *ppBackend);
    273273
     274DECLHIDDEN(int)      vdIoIterQueryStartNext(VDIOITER hVdIoIter, uint64_t *pu64Start);
     275DECLHIDDEN(int)      vdIoIterQuerySegSizeByStart(VDIOITER hVdIoIter, uint64_t u64Start, size_t *pcRegSize);
     276DECLHIDDEN(int)      vdIoIterAdvance(VDIOITER hVdIoIter, uint64_t cBlocksOrBytes);
     277
    274278#endif /* !___VDInternal_h */
    275279

  • trunk/src/VBox/Storage/VHD.cpp

    r66110 r66486  
    188188    /** Flag to force dynamic disk header update. */
    189189    bool            fDynHdrNeedsUpdate;
     190    /** The static region list. */
     191    VDREGIONLIST    RegionList;
    190192} VHDIMAGE, *PVHDIMAGE;
    191193
    … …  
    892894        rc = vhdLoadDynamicDisk(pImage, pImage->u64DataOffset);
    893895
    894     if (RT_FAILURE(rc))
     896    if (RT_SUCCESS(rc))
     897    {
     898        PVDREGIONDESC pRegion = &pImage->RegionList.aRegions[0];
     899        pImage->RegionList.fFlags   = 0;
     900        pImage->RegionList.cRegions = 1;
     901
     902        pRegion->offRegion            = 0; /* Disk start. */
     903        pRegion->cbBlock              = 512;
     904        pRegion->enmDataForm          = VDREGIONDATAFORM_RAW;
     905        pRegion->enmMetadataForm      = VDREGIONMETADATAFORM_NONE;
     906        pRegion->cbData               = 512;
     907        pRegion->cbMetadata           = 0;
     908        pRegion->cRegionBlocksOrBytes = pImage->cbSize;
     909    }
     910    else
    895911        vhdFreeImage(pImage, false);
    896912    return rc;
    … …  
    12301246        vdIfProgress(pIfProgress, uPercentStart + uPercentSpan);
    12311247
    1232     if (RT_FAILURE(rc))
     1248    if (RT_SUCCESS(rc))
     1249    {
     1250        PVDREGIONDESC pRegion = &pImage->RegionList.aRegions[0];
     1251        pImage->RegionList.fFlags   = 0;
     1252        pImage->RegionList.cRegions = 1;
     1253
     1254        pRegion->offRegion            = 0; /* Disk start. */
     1255        pRegion->cbBlock              = 512;
     1256        pRegion->enmDataForm          = VDREGIONDATAFORM_RAW;
     1257        pRegion->enmMetadataForm      = VDREGIONMETADATAFORM_NONE;
     1258        pRegion->cbData               = 512;
     1259        pRegion->cbMetadata           = 0;
     1260        pRegion->cRegionBlocksOrBytes = pImage->cbSize;
     1261    }
     1262    else
    12331263        vhdFreeImage(pImage, rc != VERR_ALREADY_EXISTS);
    12341264    return rc;
    … …  
    13071337    AssertReturn((VALID_PTR(pszFilename) && *pszFilename), VERR_INVALID_PARAMETER);
    13081338
    1309     PVHDIMAGE pImage = (PVHDIMAGE)RTMemAllocZ(sizeof(VHDIMAGE));
     1339    PVHDIMAGE pImage = (PVHDIMAGE)RTMemAllocZ(RT_UOFFSETOF(VHDIMAGE, RegionList.aRegions[1]));
    13101340    if (RT_LIKELY(pImage))
    13111341    {
    … …  
    13551385    /** @todo Check the values of other params */
    13561386
    1357     PVHDIMAGE pImage = (PVHDIMAGE)RTMemAllocZ(sizeof(VHDIMAGE));
     1387    PVHDIMAGE pImage = (PVHDIMAGE)RTMemAllocZ(RT_UOFFSETOF(VHDIMAGE, RegionList.aRegions[1]));
    13581388    if (RT_LIKELY(pImage))
    13591389    {
    … …  
    18291859}
    18301860
    1831 /** @interface_method_impl{VDIMAGEBACKEND,pfnGetSectorSize} */
    1832 static DECLCALLBACK(uint32_t) vhdGetSectorSize(void *pBackendData)
    1833 {
    1834     LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    1835     PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
    1836     uint32_t cb = 0;
    1837 
    1838     AssertPtrReturn(pImage, 0);
    1839 
    1840     if (pImage->pStorage)
    1841         cb = VHD_SECTOR_SIZE;
    1842 
    1843     LogFlowFunc(("returns %zu\n", cb));
    1844     return cb;
    1845 }
    1846 
    1847 /** @interface_method_impl{VDIMAGEBACKEND,pfnGetSize} */
    1848 static DECLCALLBACK(uint64_t) vhdGetSize(void *pBackendData)
    1849 {
    1850     LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    1851     PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
    1852     uint64_t cb = 0;
    1853 
    1854     AssertPtr(pImage);
    1855 
    1856     if (pImage && pImage->pStorage)
    1857         cb = pImage->cbSize;
    1858 
    1859     LogFlowFunc(("returns %llu\n", cb));
    1860     return cb;
    1861 }
    1862 
    18631861/** @interface_method_impl{VDIMAGEBACKEND,pfnGetFileSize} */
    18641862static DECLCALLBACK(uint64_t) vhdGetFileSize(void *pBackendData)
    … …  
    19491947    LogFlowFunc(("returns %Rrc\n", rc));
    19501948    return rc;
     1949}
     1950
     1951/** @copydoc VDIMAGEBACKEND::pfnQueryRegions */
     1952static DECLCALLBACK(int) vhdQueryRegions(void *pBackendData, PCVDREGIONLIST *ppRegionList)
     1953{
     1954    LogFlowFunc(("pBackendData=%#p ppRegionList=%#p\n", pBackendData, ppRegionList));
     1955    PVHDIMAGE pThis = (PVHDIMAGE)pBackendData;
     1956
     1957    AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
     1958
     1959    *ppRegionList = &pThis->RegionList;
     1960    LogFlowFunc(("returns %Rrc\n", VINF_SUCCESS));
     1961    return VINF_SUCCESS;
     1962}
     1963
     1964/** @copydoc VDIMAGEBACKEND::pfnRegionListRelease */
     1965static DECLCALLBACK(void) vhdRegionListRelease(void *pBackendData, PCVDREGIONLIST pRegionList)
     1966{
     1967    RT_NOREF1(pRegionList);
     1968    LogFlowFunc(("pBackendData=%#p pRegionList=%#p\n", pBackendData, pRegionList));
     1969    PVHDIMAGE pThis = (PVHDIMAGE)pBackendData;
     1970    AssertPtr(pThis); RT_NOREF(pThis);
     1971
     1972    /* Nothing to do here. */
    19511973}
    19521974
    … …  
    30443066    /* pfnGetVersion */
    30453067    vhdGetVersion,
    3046     /* pfnGetSectorSize */
    3047     vhdGetSectorSize,
    3048     /* pfnGetSize */
    3049     vhdGetSize,
    30503068    /* pfnGetFileSize */
    30513069    vhdGetFileSize,
    … …  
    30593077    vhdSetLCHSGeometry,
    30603078    /* pfnQueryRegions */
    3061     NULL,
     3079    vhdQueryRegions,
    30623080    /* pfnRegionListRelease */
    3063     NULL,
     3081    vhdRegionListRelease,
    30643082    /* pfnGetImageFlags */
    30653083    vhdGetImageFlags,

  • trunk/src/VBox/Storage/VHDX.cpp

    r66110 r66486  
    550550    /** Chunk ratio. */
    551551    uint32_t            uChunkRatio;
    552 
     552    /** The static region list. */
     553    VDREGIONLIST        RegionList;
    553554} VHDXIMAGE, *PVHDXIMAGE;
    554555
    … …  
    17441745    }
    17451746
    1746     if (RT_FAILURE(rc))
     1747    if (RT_SUCCESS(rc))
     1748    {
     1749        PVDREGIONDESC pRegion = &pImage->RegionList.aRegions[0];
     1750        pImage->RegionList.fFlags   = 0;
     1751        pImage->RegionList.cRegions = 1;
     1752
     1753        pRegion->offRegion            = 0; /* Disk start. */
     1754        pRegion->cbBlock              = pImage->cbLogicalSector;
     1755        pRegion->enmDataForm          = VDREGIONDATAFORM_RAW;
     1756        pRegion->enmMetadataForm      = VDREGIONMETADATAFORM_NONE;
     1757        pRegion->cbData               = pImage->cbLogicalSector;
     1758        pRegion->cbMetadata           = 0;
     1759        pRegion->cRegionBlocksOrBytes = pImage->cbSize;
     1760    }
     1761    else
    17471762        vhdxFreeImage(pImage, false);
    17481763
    … …  
    18281843    else
    18291844    {
    1830         pImage = (PVHDXIMAGE)RTMemAllocZ(sizeof(VHDXIMAGE));
     1845        pImage = (PVHDXIMAGE)RTMemAllocZ(RT_UOFFSETOF(VHDXIMAGE, RegionList.aRegions[1]));
    18311846        if (!pImage)
    18321847            rc = VERR_NO_MEMORY;
    … …  
    20422057}
    20432058
    2044 /** @copydoc VDIMAGEBACKEND::pfnGetSectorSize */
    2045 static DECLCALLBACK(uint32_t) vhdxGetSectorSize(void *pBackendData)
    2046 {
    2047     LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    2048     PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
    2049     uint32_t cb = 0;
    2050 
    2051     AssertPtr(pImage);
    2052 
    2053     if (pImage && pImage->pStorage)
    2054         cb = pImage->cbLogicalSector;
    2055 
    2056     LogFlowFunc(("returns %u\n", cb));
    2057     return cb;
    2058 }
    2059 
    2060 /** @copydoc VDIMAGEBACKEND::pfnGetSize */
    2061 static DECLCALLBACK(uint64_t) vhdxGetSize(void *pBackendData)
    2062 {
    2063     LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    2064     PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
    2065     uint64_t cb = 0;
    2066 
    2067     AssertPtr(pImage);
    2068 
    2069     if (pImage && pImage->pStorage)
    2070         cb = pImage->cbSize;
    2071 
    2072     LogFlowFunc(("returns %llu\n", cb));
    2073     return cb;
    2074 }
    2075 
    20762059/** @copydoc VDIMAGEBACKEND::pfnGetFileSize */
    20772060static DECLCALLBACK(uint64_t) vhdxGetFileSize(void *pBackendData)
    … …  
    21952178    LogFlowFunc(("returns %Rrc\n", rc));
    21962179    return rc;
     2180}
     2181
     2182/** @copydoc VDIMAGEBACKEND::pfnQueryRegions */
     2183static DECLCALLBACK(int) vhdxQueryRegions(void *pBackendData, PCVDREGIONLIST *ppRegionList)
     2184{
     2185    LogFlowFunc(("pBackendData=%#p ppRegionList=%#p\n", pBackendData, ppRegionList));
     2186    PVHDXIMAGE pThis = (PVHDXIMAGE)pBackendData;
     2187
     2188    AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
     2189
     2190    *ppRegionList = &pThis->RegionList;
     2191    LogFlowFunc(("returns %Rrc\n", VINF_SUCCESS));
     2192    return VINF_SUCCESS;
     2193}
     2194
     2195/** @copydoc VDIMAGEBACKEND::pfnRegionListRelease */
     2196static DECLCALLBACK(void) vhdxRegionListRelease(void *pBackendData, PCVDREGIONLIST pRegionList)
     2197{
     2198    RT_NOREF1(pRegionList);
     2199    LogFlowFunc(("pBackendData=%#p pRegionList=%#p\n", pBackendData, pRegionList));
     2200    PVHDXIMAGE pThis = (PVHDXIMAGE)pBackendData;
     2201    AssertPtr(pThis); RT_NOREF(pThis);
     2202
     2203    /* Nothing to do here. */
    21972204}
    21982205
    … …  
    25202527    /* pfnGetVersion */
    25212528    vhdxGetVersion,
    2522     /* pfnGetSectorSize */
    2523     vhdxGetSectorSize,
    2524     /* pfnGetSize */
    2525     vhdxGetSize,
    25262529    /* pfnGetFileSize */
    25272530    vhdxGetFileSize,
    … …  
    25352538    vhdxSetLCHSGeometry,
    25362539    /* pfnQueryRegions */
    2537     NULL,
     2540    vhdxQueryRegions,
    25382541    /* pfnRegionListRelease */
    2539     NULL,
     2542    vhdxRegionListRelease,
    25402543    /* pfnGetImageFlags */
    25412544    vhdxGetImageFlags,

  • trunk/src/VBox/Storage/VMDK.cpp

    r66250 r66486  
    436436    /** Parsed descriptor file content. */
    437437    VMDKDESCRIPTOR  Descriptor;
     438    /** The static region list. */
     439    VDREGIONLIST    RegionList;
    438440} VMDKIMAGE;
    439441
    … …  
    33403342     *       choice of retrying the open if it failed. */
    33413343
    3342     if (RT_FAILURE(rc))
     3344    if (RT_SUCCESS(rc))
     3345    {
     3346        PVDREGIONDESC pRegion = &pImage->RegionList.aRegions[0];
     3347        pImage->RegionList.fFlags   = 0;
     3348        pImage->RegionList.cRegions = 1;
     3349
     3350        pRegion->offRegion            = 0; /* Disk start. */
     3351        pRegion->cbBlock              = 512;
     3352        pRegion->enmDataForm          = VDREGIONDATAFORM_RAW;
     3353        pRegion->enmMetadataForm      = VDREGIONMETADATAFORM_NONE;
     3354        pRegion->cbData               = 512;
     3355        pRegion->cbMetadata           = 0;
     3356        pRegion->cRegionBlocksOrBytes = pImage->cbSize;
     3357    }
     3358    else
    33433359        vmdkFreeImage(pImage, false);
    33443360    return rc;
    … …  
    40534069
    40544070    if (RT_SUCCESS(rc))
     4071    {
     4072        PVDREGIONDESC pRegion = &pImage->RegionList.aRegions[0];
     4073        pImage->RegionList.fFlags   = 0;
     4074        pImage->RegionList.cRegions = 1;
     4075
     4076        pRegion->offRegion            = 0; /* Disk start. */
     4077        pRegion->cbBlock              = 512;
     4078        pRegion->enmDataForm          = VDREGIONDATAFORM_RAW;
     4079        pRegion->enmMetadataForm      = VDREGIONMETADATAFORM_NONE;
     4080        pRegion->cbData               = 512;
     4081        pRegion->cbMetadata           = 0;
     4082        pRegion->cRegionBlocksOrBytes = pImage->cbSize;
     4083
    40554084        vdIfProgress(pIfProgress, uPercentStart + uPercentSpan);
     4085    }
    40564086    else
    40574087        vmdkFreeImage(pImage, rc != VERR_ALREADY_EXISTS);
    … …  
    51985228    AssertReturn((VALID_PTR(pszFilename) && *pszFilename), VERR_INVALID_PARAMETER);
    51995229
    5200     PVMDKIMAGE pImage = (PVMDKIMAGE)RTMemAllocZ(sizeof(VMDKIMAGE));
     5230    PVMDKIMAGE pImage = (PVMDKIMAGE)RTMemAllocZ(RT_UOFFSETOF(VMDKIMAGE, RegionList.aRegions[1]));
    52015231    if (RT_LIKELY(pImage))
    52025232    {
    … …  
    52595289                 && VALID_PTR(pLCHSGeometry), VERR_INVALID_PARAMETER);
    52605290
    5261     PVMDKIMAGE pImage = (PVMDKIMAGE)RTMemAllocZ(sizeof(VMDKIMAGE));
     5291    PVMDKIMAGE pImage = (PVMDKIMAGE)RTMemAllocZ(RT_UOFFSETOF(VMDKIMAGE, RegionList.aRegions[1]));
    52625292    if (RT_LIKELY(pImage))
    52635293    {
    … …  
    59135943}
    59145944
    5915 /** @copydoc VDIMAGEBACKEND::pfnGetSectorSize */
    5916 static DECLCALLBACK(uint32_t) vmdkGetSectorSize(void *pBackendData)
    5917 {
    5918     LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    5919     PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
    5920 
    5921     AssertPtrReturn(pImage, 0);
    5922 
    5923     return 512;
    5924 }
    5925 
    5926 /** @copydoc VDIMAGEBACKEND::pfnGetSize */
    5927 static DECLCALLBACK(uint64_t) vmdkGetSize(void *pBackendData)
    5928 {
    5929     LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    5930     PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
    5931 
    5932     AssertPtrReturn(pImage, 0);
    5933 
    5934     return pImage->cbSize;
    5935 }
    5936 
    59375945/** @copydoc VDIMAGEBACKEND::pfnGetFileSize */
    59385946static DECLCALLBACK(uint64_t) vmdkGetFileSize(void *pBackendData)
    … …  
    60566064    LogFlowFunc(("returns %Rrc\n", rc));
    60576065    return rc;
     6066}
     6067
     6068/** @copydoc VDIMAGEBACKEND::pfnQueryRegions */
     6069static DECLCALLBACK(int) vmdkQueryRegions(void *pBackendData, PCVDREGIONLIST *ppRegionList)
     6070{
     6071    LogFlowFunc(("pBackendData=%#p ppRegionList=%#p\n", pBackendData, ppRegionList));
     6072    PVMDKIMAGE pThis = (PVMDKIMAGE)pBackendData;
     6073
     6074    AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
     6075
     6076    *ppRegionList = &pThis->RegionList;
     6077    LogFlowFunc(("returns %Rrc\n", VINF_SUCCESS));
     6078    return VINF_SUCCESS;
     6079}
     6080
     6081/** @copydoc VDIMAGEBACKEND::pfnRegionListRelease */
     6082static DECLCALLBACK(void) vmdkRegionListRelease(void *pBackendData, PCVDREGIONLIST pRegionList)
     6083{
     6084    RT_NOREF1(pRegionList);
     6085    LogFlowFunc(("pBackendData=%#p pRegionList=%#p\n", pBackendData, pRegionList));
     6086    PVMDKIMAGE pThis = (PVMDKIMAGE)pBackendData;
     6087    AssertPtr(pThis); RT_NOREF(pThis);
     6088
     6089    /* Nothing to do here. */
    60586090}
    60596091
    … …  
    64016433    /* pfnGetVersion */
    64026434    vmdkGetVersion,
    6403     /* pfnGetSectorSize */
    6404     vmdkGetSectorSize,
    6405     /* pfnGetSize */
    6406     vmdkGetSize,
    64076435    /* pfnGetFileSize */
    64086436    vmdkGetFileSize,
    … …  
    64166444    vmdkSetLCHSGeometry,
    64176445    /* pfnQueryRegions */
    6418     NULL,
     6446    vmdkQueryRegions,
    64196447    /* pfnRegionListRelease */
    6420     NULL,
     6448    vmdkRegionListRelease,
    64216449    /* pfnGetImageFlags */
    64226450    vmdkGetImageFlags,
Note: See TracChangeset for help on using the changeset viewer.

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