VirtualBox

Changeset 15366 in vbox for trunk/src/VBox/Devices


Ignore:
Timestamp:
Dec 12, 2008 1:50:32 PM (16 years ago)
Author:
vboxsync
Message:

Storage: Eradicated the last bits using the old VDI only backend, keeping only the testcases for now (no longer built).

Completely removed old iSCSI driver.

Added intnet option to addiscsidisk and adjusted documentation.

Made backend name comparisons case-insensitive.

Detect VMDK files not according to VMDK 1.0 and reject with clear error message.

Changed format probing logic to not fall through to the "unsupported" case if it's a known format, i.e. has valid header.

VBoxManage converthd generic format converter made official.

Added format flag to VBoxManage createhd, allows creating VMDK files.

VBoxManage convertdd reimplemented based on new framework, supporting any image format.

VBoxManage internalcommands sethduuid reimplemented based on new framework, supporting any image format.

Cleaned up error codes.

Location:
trunk/src/VBox/Devices
Files:
2 deleted
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Builtins.cpp

    r14965 r15366  
    181181    if (RT_FAILURE(rc))
    182182        return rc;
    183     rc = pCallbacks->pfnRegister(pCallbacks, &g_DrvVBoxHDD);
    184     if (RT_FAILURE(rc))
    185         return rc;
    186183    rc = pCallbacks->pfnRegister(pCallbacks, &g_DrvVD);
    187184    if (RT_FAILURE(rc))
    … …  
    203200    if (RT_FAILURE(rc))
    204201        return rc;
    205 #ifdef VBOX_WITH_ISCSI
    206     rc = pCallbacks->pfnRegister(pCallbacks, &g_DrvISCSI);
    207     if (RT_FAILURE(rc))
    208         return rc;
    209     rc = pCallbacks->pfnRegister(pCallbacks, &g_DrvISCSITransportTcp);
    210     if (RT_FAILURE(rc))
    211         return rc;
    212 #endif
    213202#ifndef RT_OS_L4
    214203    rc = pCallbacks->pfnRegister(pCallbacks, &g_DrvNAT);

  • trunk/src/VBox/Devices/Makefile.kmk

    r15287 r15366  
    8282VBoxDDU_SOURCES          = \
    8383        Storage/VBoxHDD-new.cpp \
    84         Storage/VDICore.cpp \
    8584        Storage/VDIHDDCore.cpp \
    8685        Storage/VHDHDDCore.cpp \
    … …  
    579578        Storage/DrvRawImage.cpp \
    580579        Storage/DrvVD.cpp \
    581         Storage/VBoxHDD.cpp \
    582580        Network/DrvNetSniffer.cpp \
    583581        Network/Pcap.cpp
    … …  
    644642        Input/DrvMouseQueue.cpp \
    645643        Input/DrvKeyboardQueue.cpp \
    646         Storage/VBoxHDD.cpp \
    647644        Storage/DrvBlock.cpp \
    648645        Storage/DrvMediaISO.cpp \
    … …  
    712709
    713710ifdef VBOX_WITH_ISCSI
    714  Drivers_SOURCES      += \
    715         Storage/DrvISCSI.cpp \
    716         Storage/DrvISCSITransportTCP.cpp
    717  Drivers_DEFS         += VBOX_WITH_ISCSI
    718  Storage/DrvISCSITransportTCP.cpp_INCS = \
    719         Network/lwip/src/include \
    720         Network/lwip/src/include/ipv4 \
    721         Network/lwip/vbox/include
    722711 VBoxDDU_SOURCES      += \
    723712    Storage/ISCSIHDDCore.cpp

  • trunk/src/VBox/Devices/PC/DevPcBios.cpp

    r15192 r15366  
    458458        }
    459459        rc = pHardDisk->pfnSetLCHSGeometry(pHardDisk, &LCHSGeometry);
    460         if (rc == VERR_VDI_IMAGE_READ_ONLY)
     460        if (rc == VERR_VD_IMAGE_READ_ONLY)
    461461        {
    462462            LogRel(("DevPcBios: ATA failed to update LCHS geometry, read only\n"));

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

    r15156 r15366  
    552552    PVBOXDISK pThis = PDMIMEDIA_2_VBOXDISK(pInterface);
    553553    int rc = VDSetPCHSGeometry(pThis->pDisk, VD_LAST_IMAGE, pPCHSGeometry);
    554     if (rc == VERR_VDI_GEOMETRY_NOT_SET)
     554    if (rc == VERR_VD_GEOMETRY_NOT_SET)
    555555        rc = VERR_PDM_GEOMETRY_NOT_SET;
    556556    LogFlow(("%s: returns %Rrc\n", __FUNCTION__, rc));
    … …  
    583583    PVBOXDISK pThis = PDMIMEDIA_2_VBOXDISK(pInterface);
    584584    int rc = VDSetLCHSGeometry(pThis->pDisk, VD_LAST_IMAGE, pLCHSGeometry);
    585     if (rc == VERR_VDI_GEOMETRY_NOT_SET)
     585    if (rc == VERR_VD_GEOMETRY_NOT_SET)
    586586        rc = VERR_PDM_GEOMETRY_NOT_SET;
    587587    LogFlow(("%s: returns %Rrc\n", __FUNCTION__, rc));
    … …  
    635635    PVBOXDISK pThis = PDMITRANSPORTASYNCPORT_2_VBOXDISK(pInterface);
    636636    PDRVVDASYNCTASK pDrvVDAsyncTask = (PDRVVDASYNCTASK)pvUser;
    637     int rc = VINF_VDI_ASYNC_IO_FINISHED;
     637    int rc = VINF_VD_ASYNC_IO_FINISHED;
    638638
    639639    /* Having a completion callback for a task is not mandatory. */
    … …  
    642642
    643643    /* Check if the request is finished. */
    644     if (rc == VINF_VDI_ASYNC_IO_FINISHED)
     644    if (rc == VINF_VD_ASYNC_IO_FINISHED)
    645645    {
    646646        rc = pThis->pDrvMediaAsyncPort->pfnTransferCompleteNotify(pThis->pDrvMediaAsyncPort, pDrvVDAsyncTask->pvUserCaller);
    647647    }
    648     else if (rc == VERR_VDI_ASYNC_IO_IN_PROGRESS)
     648    else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
    649649        rc = VINF_SUCCESS;
    650650

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

    r14967 r15366  
    143143    if (pImage->cbSize % 512)
    144144    {
    145         rc = VERR_VDI_INVALID_HEADER;
     145        rc = VERR_VD_RAW_INVALID_HEADER;
    146146        goto out;
    147147    }
    … …  
    174174    if (enmType != VD_IMAGE_TYPE_FIXED)
    175175    {
    176         rc = rawError(pImage, VERR_VDI_INVALID_TYPE, RT_SRC_POS, N_("Raw: cannot create diff image '%s'"), pImage->pszFilename);
     176        rc = rawError(pImage, VERR_VD_RAW_INVALID_TYPE, RT_SRC_POS, N_("Raw: cannot create diff image '%s'"), pImage->pszFilename);
    177177        goto out;
    178178    }
    … …  
    322322
    323323    /* Always return failure, to avoid opening everything as a raw image. */
    324     rc = VERR_VDI_INVALID_HEADER;
     324    rc = VERR_VD_RAW_INVALID_HEADER;
    325325
    326326out:
    … …  
    519519    if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
    520520    {
    521         rc = VERR_VDI_IMAGE_READ_ONLY;
     521        rc = VERR_VD_IMAGE_READ_ONLY;
    522522        goto out;
    523523    }
    … …  
    578578        *penmImageType = pImage->enmImageType;
    579579    else
    580         rc = VERR_VDI_NOT_OPENED;
     580        rc = VERR_VD_NOT_OPENED;
    581581
    582582    LogFlowFunc(("returns %Rrc enmImageType=%u\n", rc, *penmImageType));
    … …  
    640640        }
    641641        else
    642             rc = VERR_VDI_GEOMETRY_NOT_SET;
    643     }
    644     else
    645         rc = VERR_VDI_NOT_OPENED;
     642            rc = VERR_VD_GEOMETRY_NOT_SET;
     643    }
     644    else
     645        rc = VERR_VD_NOT_OPENED;
    646646
    647647    LogFlowFunc(("returns %Rrc (PCHS=%u/%u/%u)\n", rc, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
    … …  
    663663        if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
    664664        {
    665             rc = VERR_VDI_IMAGE_READ_ONLY;
     665            rc = VERR_VD_IMAGE_READ_ONLY;
    666666            goto out;
    667667        }
    … …  
    671671    }
    672672    else
    673         rc = VERR_VDI_NOT_OPENED;
     673        rc = VERR_VD_NOT_OPENED;
    674674
    675675out:
    … …  
    696696        }
    697697        else
    698             rc = VERR_VDI_GEOMETRY_NOT_SET;
    699     }
    700     else
    701         rc = VERR_VDI_NOT_OPENED;
     698            rc = VERR_VD_GEOMETRY_NOT_SET;
     699    }
     700    else
     701        rc = VERR_VD_NOT_OPENED;
    702702
    703703    LogFlowFunc(("returns %Rrc (LCHS=%u/%u/%u)\n", rc, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
    … …  
    719719        if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
    720720        {
    721             rc = VERR_VDI_IMAGE_READ_ONLY;
     721            rc = VERR_VD_IMAGE_READ_ONLY;
    722722            goto out;
    723723        }
    … …  
    727727    }
    728728    else
    729         rc = VERR_VDI_NOT_OPENED;
     729        rc = VERR_VD_NOT_OPENED;
    730730
    731731out:
    … …  
    811811    }
    812812    else
    813         rc = VERR_VDI_NOT_OPENED;
     813        rc = VERR_VD_NOT_OPENED;
    814814
    815815    LogFlowFunc(("returns %Rrc comment='%s'\n", rc, pszComment));
    … …  
    828828    if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
    829829    {
    830         rc = VERR_VDI_IMAGE_READ_ONLY;
     830        rc = VERR_VD_IMAGE_READ_ONLY;
    831831        goto out;
    832832    }
    … …  
    835835        rc = VERR_NOT_SUPPORTED;
    836836    else
    837         rc = VERR_VDI_NOT_OPENED;
     837        rc = VERR_VD_NOT_OPENED;
    838838
    839839out:
    … …  
    854854        rc = VERR_NOT_SUPPORTED;
    855855    else
    856         rc = VERR_VDI_NOT_OPENED;
     856        rc = VERR_VD_NOT_OPENED;
    857857
    858858    LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
    … …  
    875875            rc = VERR_NOT_SUPPORTED;
    876876        else
    877             rc = VERR_VDI_IMAGE_READ_ONLY;
    878     }
    879     else
    880         rc = VERR_VDI_NOT_OPENED;
     877            rc = VERR_VD_IMAGE_READ_ONLY;
     878    }
     879    else
     880        rc = VERR_VD_NOT_OPENED;
    881881
    882882    LogFlowFunc(("returns %Rrc\n", rc));
    … …  
    896896        rc = VERR_NOT_SUPPORTED;
    897897    else
    898         rc = VERR_VDI_NOT_OPENED;
     898        rc = VERR_VD_NOT_OPENED;
    899899
    900900    LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
    … …  
    916916            rc = VERR_NOT_SUPPORTED;
    917917        else
    918             rc = VERR_VDI_IMAGE_READ_ONLY;
    919     }
    920     else
    921         rc = VERR_VDI_NOT_OPENED;
     918            rc = VERR_VD_IMAGE_READ_ONLY;
     919    }
     920    else
     921        rc = VERR_VD_NOT_OPENED;
    922922
    923923    LogFlowFunc(("returns %Rrc\n", rc));
    … …  
    937937        rc = VERR_NOT_SUPPORTED;
    938938    else
    939         rc = VERR_VDI_NOT_OPENED;
     939        rc = VERR_VD_NOT_OPENED;
    940940
    941941    LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
    … …  
    957957            rc = VERR_NOT_SUPPORTED;
    958958        else
    959             rc = VERR_VDI_IMAGE_READ_ONLY;
    960     }
    961     else
    962         rc = VERR_VDI_NOT_OPENED;
     959            rc = VERR_VD_IMAGE_READ_ONLY;
     960    }
     961    else
     962        rc = VERR_VD_NOT_OPENED;
    963963
    964964    LogFlowFunc(("returns %Rrc\n", rc));
    … …  
    978978        rc = VERR_NOT_SUPPORTED;
    979979    else
    980         rc = VERR_VDI_NOT_OPENED;
     980        rc = VERR_VD_NOT_OPENED;
    981981
    982982    LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
    … …  
    998998            rc = VERR_NOT_SUPPORTED;
    999999        else
    1000             rc = VERR_VDI_IMAGE_READ_ONLY;
    1001     }
    1002     else
    1003         rc = VERR_VDI_NOT_OPENED;
     1000            rc = VERR_VD_IMAGE_READ_ONLY;
     1001    }
     1002    else
     1003        rc = VERR_VD_NOT_OPENED;
    10041004
    10051005    LogFlowFunc(("returns %Rrc\n", rc));

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

    r14967 r15366  
    190190    for (unsigned i = 0; i < g_cBackends; i++)
    191191    {
    192         if (!strcmp(pszBackend, g_apBackends[i]->pszBackendName))
     192        if (!RTStrICmp(pszBackend, g_apBackends[i]->pszBackendName))
    193193        {
    194194            pBackend = g_apBackends[i];
    … …  
    281281         * stale data when different block sizes are used for the images. */
    282282        cbThisRead = cbRead;
    283         rc = VERR_VDI_BLOCK_FREE;
     283        rc = VERR_VD_BLOCK_FREE;
    284284        for (PVDIMAGE pCurrImage = pImage;
    285              pCurrImage != NULL && rc == VERR_VDI_BLOCK_FREE;
     285             pCurrImage != NULL && rc == VERR_VD_BLOCK_FREE;
    286286             pCurrImage = pCurrImage->pPrev)
    287287        {
    … …  
    292292
    293293        /* No image in the chain contains the data for the block. */
    294         if (rc == VERR_VDI_BLOCK_FREE)
     294        if (rc == VERR_VD_BLOCK_FREE)
    295295        {
    296296            memset(pvBuf, '\0', cbThisRead);
    … …  
    415415                                   cbPreRead + cbThisWrite + cbPostRead,
    416416                                   NULL, &cbPreRead, &cbPostRead, 0);
    417     Assert(rc != VERR_VDI_BLOCK_FREE);
     417    Assert(rc != VERR_VD_BLOCK_FREE);
    418418    Assert(cbPreRead == 0);
    419419    Assert(cbPostRead == 0);
    … …  
    494494                                   cbPreRead + cbThisWrite + cbPostRead,
    495495                                   NULL, &cbPreRead, &cbPostRead, 0);
    496     Assert(rc != VERR_VDI_BLOCK_FREE);
     496    Assert(rc != VERR_VD_BLOCK_FREE);
    497497    Assert(cbPreRead == 0);
    498498    Assert(cbPostRead == 0);
    … …  
    528528                                       cbThisWrite, &cbThisWrite, &cbPreRead,
    529529                                       &cbPostRead, fWrite);
    530         if (rc == VERR_VDI_BLOCK_FREE)
     530        if (rc == VERR_VD_BLOCK_FREE)
    531531        {
    532532            void *pvTmp = RTMemTmpAlloc(cbPreRead + cbThisWrite + cbPostRead);
    … …  
    800800    for (unsigned i = 0; i < g_cBackends; i++)
    801801    {
    802         if (!strcmp(pszBackend, g_apBackends[i]->pszBackendName))
     802        if (!RTStrICmp(pszBackend, g_apBackends[i]->pszBackendName))
    803803        {
    804804            pEntry->pszBackend = g_apBackends[i]->pszBackendName;
    … …  
    921921        {
    922922            rc = g_apBackends[i]->pfnCheckIfValid(pszFilename);
    923             if (RT_SUCCESS(rc))
     923            if (    RT_SUCCESS(rc)
     924                /* The correct backend has been found, but there is a small
     925                 * incompatibility so that the file cannot be used. Stop here
     926                 * and signal success - the actual open will of course fail,
     927                 * but that will create a really sensible error message. */
     928                ||  (   rc != VERR_VD_GEN_INVALID_HEADER
     929                     && rc != VERR_VD_VDI_INVALID_HEADER
     930                     && rc != VERR_VD_VMDK_INVALID_HEADER
     931                     && rc != VERR_VD_ISCSI_INVALID_HEADER
     932                     && rc != VERR_VD_VHD_INVALID_HEADER
     933                     && rc != VERR_VD_RAW_INVALID_HEADER))
    924934            {
    925935                /* Copy the name into the new string. */
    … …  
    934944                break;
    935945            }
     946            rc = VERR_NOT_SUPPORTED;
    936947        }
    937948    }
    … …  
    10581069                &&  enmImageType != VD_IMAGE_TYPE_NORMAL)
    10591070            {
    1060                 rc = VERR_VDI_INVALID_TYPE;
     1071                rc = VERR_VD_INVALID_TYPE;
    10611072                break;
    10621073            }
    … …  
    10661077                    &&  enmImageType != VD_IMAGE_TYPE_DIFF)
    10671078                {
    1068                     rc = VERR_VDI_INVALID_TYPE;
     1079                    rc = VERR_VD_INVALID_TYPE;
    10691080                    break;
    10701081                }
    … …  
    12601271        AssertMsgBreakStmt(pDisk->cImages == 0,
    12611272                           ("Create base image cannot be done with other images open\n"),
    1262                            rc = VERR_VDI_INVALID_STATE);
     1273                           rc = VERR_VD_INVALID_STATE);
    12631274
    12641275        /* Set up image descriptor. */
    … …  
    14601471        AssertMsgBreakStmt(pDisk->cImages != 0,
    14611472                           ("Create diff image cannot be done without other images open\n"),
    1462                            rc = VERR_VDI_INVALID_STATE);
     1473                           rc = VERR_VD_INVALID_STATE);
    14631474
    14641475        /* Set up image descriptor. */
    … …  
    15971608 *
    15981609 * @returns VBox status code.
    1599  * @returns VERR_VDI_IMAGE_NOT_FOUND if image with specified number was not opened.
     1610 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
    16001611 * @param   pDisk           Pointer to HDD container.
    16011612 * @param   nImageFrom      Name of the image file to merge from.
    … …  
    16281639        if (!pImageFrom || !pImageTo)
    16291640        {
    1630             rc = VERR_VDI_IMAGE_NOT_FOUND;
     1641            rc = VERR_VD_IMAGE_NOT_FOUND;
    16311642            break;
    16321643        }
    … …  
    16741685                                                uOffset, pvBuf, cbThisRead,
    16751686                                                &cbThisRead);
    1676                 if (rc == VERR_VDI_BLOCK_FREE)
     1687                if (rc == VERR_VD_BLOCK_FREE)
    16771688                {
    16781689                    /* Search for image with allocated block. Do not attempt to
    … …  
    16811692                     * block sizes are used for the images. */
    16821693                    for (PVDIMAGE pCurrImage = pImageTo->pPrev;
    1683                          pCurrImage != NULL && pCurrImage != pImageFrom->pPrev && rc == VERR_VDI_BLOCK_FREE;
     1694                         pCurrImage != NULL && pCurrImage != pImageFrom->pPrev && rc == VERR_VD_BLOCK_FREE;
    16841695                         pCurrImage = pCurrImage->pPrev)
    16851696                    {
    … …  
    16901701                    }
    16911702
    1692                     if (rc != VERR_VDI_BLOCK_FREE)
     1703                    if (rc != VERR_VD_BLOCK_FREE)
    16931704                    {
    16941705                        if (RT_FAILURE(rc))
    … …  
    17281739            {
    17291740                size_t cbThisRead = RT_MIN(VD_MERGE_BUFFER_SIZE, cbRemaining);
    1730                 rc = VERR_VDI_BLOCK_FREE;
     1741                rc = VERR_VD_BLOCK_FREE;
    17311742                /* Search for image with allocated block. Do not attempt to
    17321743                 * read more than the previous reads marked as valid. Otherwise
    … …  
    17341745                 * used for the images. */
    17351746                for (PVDIMAGE pCurrImage = pImageFrom;
    1736                      pCurrImage != NULL && pCurrImage != pImageTo && rc == VERR_VDI_BLOCK_FREE;
     1747                     pCurrImage != NULL && pCurrImage != pImageTo && rc == VERR_VD_BLOCK_FREE;
    17371748                     pCurrImage = pCurrImage->pPrev)
    17381749                {
    … …  
    17421753                }
    17431754
    1744                 if (rc != VERR_VDI_BLOCK_FREE)
     1755                if (rc != VERR_VD_BLOCK_FREE)
    17451756                {
    17461757                    if (RT_FAILURE(rc))
    … …  
    18461857 *
    18471858 * @returns VBox status code.
    1848  * @returns VERR_VDI_IMAGE_NOT_FOUND if image with specified number was not opened.
     1859 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
    18491860 * @param   pDiskFrom       Pointer to source HDD container.
    18501861 * @param   nImage          Image number, counts from 0. 0 is always base image of container.
    … …  
    18941905
    18951906        PVDIMAGE pImageFrom = vdGetImageByNumber(pDiskFrom, nImage);
    1896         AssertPtrBreakStmt(pImageFrom, rc = VERR_VDI_IMAGE_NOT_FOUND);
     1907        AssertPtrBreakStmt(pImageFrom, rc = VERR_VD_IMAGE_NOT_FOUND);
    18971908        AssertMsgBreakStmt(VALID_PTR(pDiskTo), ("pDiskTo=%#p\n", pDiskTo),
    18981909                           rc = VERR_INVALID_PARAMETER);
    … …  
    19021913        /* If the containers are equal and the backend is the same, rename the image. */
    19031914        if (   (pDiskFrom == pDiskTo)
    1904             && (!strcmp(pszBackend, pImageFrom->Backend->pszBackendName)))
     1915            && (!RTStrICmp(pszBackend, pImageFrom->Backend->pszBackendName)))
    19051916        {
    19061917            /* Rename the image. */
    … …  
    19111922        /* If the fMoveByRename flag is set and the backend is the same, rename the image. */
    19121923        if (   (fMoveByRename == true)
    1913             && (!strcmp(pszBackend, pImageFrom->Backend->pszBackendName)))
     1924            && (!RTStrICmp(pszBackend, pImageFrom->Backend->pszBackendName)))
    19141925        {
    19151926            /* Close the source image. */
    … …  
    19621973        if (cbSizeFrom == 0)
    19631974        {
    1964             rc = VERR_VDI_VALUE_NOT_FOUND;
     1975            rc = VERR_VD_VALUE_NOT_FOUND;
    19651976            break;
    19661977        }
    … …  
    19982009
    19992010        pImageTo = pDiskTo->pLast;
    2000         AssertPtrBreakStmt(pImageTo, rc = VERR_VDI_IMAGE_NOT_FOUND);
     2011        AssertPtrBreakStmt(pImageTo, rc = VERR_VD_IMAGE_NOT_FOUND);
    20012012
    20022013        /* Allocate tmp buffer. */
    … …  
    20492060        /* If fMoveByRename is set but the backend is different, close and delete pImageFrom. */
    20502061        if (   (fMoveByRename == true)
    2051             && (strcmp(pszBackend, pImageFrom->Backend->pszBackendName)))
     2062            && (RTStrICmp(pszBackend, pImageFrom->Backend->pszBackendName)))
    20522063        {
    20532064            vdRemoveImageFromList(pDiskFrom, pImageFrom);
    … …  
    21072118 *
    21082119 * @returns VBox status code.
    2109  * @returns VERR_VDI_NOT_OPENED if no image is opened in HDD container.
     2120 * @returns VERR_VD_NOT_OPENED if no image is opened in HDD container.
    21102121 * @param   pDisk           Pointer to HDD container.
    21112122 * @param   fDelete         If true, delete the image from the host disk.
    … …  
    21232134
    21242135        PVDIMAGE pImage = pDisk->pLast;
    2125         AssertPtrBreakStmt(pImage, rc = VERR_VDI_NOT_OPENED);
     2136        AssertPtrBreakStmt(pImage, rc = VERR_VD_NOT_OPENED);
    21262137        unsigned uOpenFlags = pImage->Backend->pfnGetOpenFlags(pImage->pvBackendData);
    21272138        /* Remove image from list of opened images. */
    … …  
    22342245 *
    22352246 * @returns VBox status code.
    2236  * @returns VERR_VDI_NOT_OPENED if no image is opened in HDD container.
     2247 * @returns VERR_VD_NOT_OPENED if no image is opened in HDD container.
    22372248 * @param   pDisk           Pointer to HDD container.
    22382249 * @param   uOffset         Offset of first reading byte from start of disk.
    … …  
    22662277
    22672278        PVDIMAGE pImage = pDisk->pLast;
    2268         AssertPtrBreakStmt(pImage, rc = VERR_VDI_NOT_OPENED);
     2279        AssertPtrBreakStmt(pImage, rc = VERR_VD_NOT_OPENED);
    22692280
    22702281        rc = vdReadHelper(pDisk, pImage, uOffset, pvBuf, cbRead);
    … …  
    22792290 *
    22802291 * @returns VBox status code.
    2281  * @returns VERR_VDI_NOT_OPENED if no image is opened in HDD container.
     2292 * @returns VERR_VD_NOT_OPENED if no image is opened in HDD container.
    22822293 * @param   pDisk           Pointer to HDD container.
    22832294 * @param   uOffset         Offset of the first byte being
    … …  
    23122323
    23132324        PVDIMAGE pImage = pDisk->pLast;
    2314         AssertPtrBreakStmt(pImage, rc = VERR_VDI_NOT_OPENED);
     2325        AssertPtrBreakStmt(pImage, rc = VERR_VD_NOT_OPENED);
    23152326
    23162327        vdSetModifiedFlag(pDisk);
    … …  
    23262337 *
    23272338 * @returns VBox status code.
    2328  * @returns VERR_VDI_NOT_OPENED if no image is opened in HDD container.
     2339 * @returns VERR_VD_NOT_OPENED if no image is opened in HDD container.
    23292340 * @param   pDisk           Pointer to HDD container.
    23302341 */
    … …  
    23412352
    23422353        PVDIMAGE pImage = pDisk->pLast;
    2343         AssertPtrBreakStmt(pImage, rc = VERR_VDI_NOT_OPENED);
     2354        AssertPtrBreakStmt(pImage, rc = VERR_VD_NOT_OPENED);
    23442355
    23452356        vdResetModifiedFlag(pDisk);
    … …  
    24652476 *
    24662477 * @returns VBox status code.
    2467  * @returns VERR_VDI_IMAGE_NOT_FOUND if image with specified number was not opened.
    2468  * @returns VERR_VDI_GEOMETRY_NOT_SET if no geometry present in the HDD container.
     2478 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
     2479 * @returns VERR_VD_GEOMETRY_NOT_SET if no geometry present in the HDD container.
    24692480 * @param   pDisk           Pointer to HDD container.
    24702481 * @param   nImage          Image number, counts from 0. 0 is always base image of container.
    … …  
    24902501
    24912502        PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
    2492         AssertPtrBreakStmt(pImage, rc = VERR_VDI_IMAGE_NOT_FOUND);
     2503        AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
    24932504
    24942505        if (pImage == pDisk->pLast)
    … …  
    24982509                *pPCHSGeometry = pDisk->PCHSGeometry;
    24992510            else
    2500                 rc = VERR_VDI_GEOMETRY_NOT_SET;
     2511                rc = VERR_VD_GEOMETRY_NOT_SET;
    25012512        }
    25022513        else
    … …  
    25172528 *
    25182529 * @returns VBox status code.
    2519  * @returns VERR_VDI_IMAGE_NOT_FOUND if image with specified number was not opened.
    2520  * @returns VERR_VDI_GEOMETRY_NOT_SET if no geometry present in the HDD container.
     2530 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
     2531 * @returns VERR_VD_GEOMETRY_NOT_SET if no geometry present in the HDD container.
    25212532 * @param   pDisk           Pointer to HDD container.
    25222533 * @param   nImage          Image number, counts from 0. 0 is always base image of container.
    … …  
    25482559
    25492560        PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
    2550         AssertPtrBreakStmt(pImage, rc = VERR_VDI_IMAGE_NOT_FOUND);
     2561        AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
    25512562
    25522563        if (pImage == pDisk->pLast)
    … …  
    26112622 *
    26122623 * @returns VBox status code.
    2613  * @returns VERR_VDI_IMAGE_NOT_FOUND if image with specified number was not opened.
    2614  * @returns VERR_VDI_GEOMETRY_NOT_SET if no geometry present in the HDD container.
     2624 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
     2625 * @returns VERR_VD_GEOMETRY_NOT_SET if no geometry present in the HDD container.
    26152626 * @param   pDisk           Pointer to HDD container.
    26162627 * @param   nImage          Image number, counts from 0. 0 is always base image of container.
    … …  
    26362647
    26372648        PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
    2638         AssertPtrBreakStmt(pImage, rc = VERR_VDI_IMAGE_NOT_FOUND);
     2649        AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
    26392650
    26402651        if (pImage == pDisk->pLast)
    … …  
    26442655                *pLCHSGeometry = pDisk->LCHSGeometry;
    26452656            else
    2646                 rc = VERR_VDI_GEOMETRY_NOT_SET;
     2657                rc = VERR_VD_GEOMETRY_NOT_SET;
    26472658        }
    26482659        else
    … …  
    26632674 *
    26642675 * @returns VBox status code.
    2665  * @returns VERR_VDI_IMAGE_NOT_FOUND if image with specified number was not opened.
    2666  * @returns VERR_VDI_GEOMETRY_NOT_SET if no geometry present in the HDD container.
     2676 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
     2677 * @returns VERR_VD_GEOMETRY_NOT_SET if no geometry present in the HDD container.
    26672678 * @param   pDisk           Pointer to HDD container.
    26682679 * @param   nImage          Image number, counts from 0. 0 is always base image of container.
    … …  
    26942705
    26952706        PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
    2696         AssertPtrBreakStmt(pImage, rc = VERR_VDI_IMAGE_NOT_FOUND);
     2707        AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
    26972708
    26982709        if (pImage == pDisk->pLast)
    … …  
    27572768 *
    27582769 * @returns VBox status code.
    2759  * @returns VERR_VDI_IMAGE_NOT_FOUND if image with specified number was not opened.
     2770 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
    27602771 * @param   pDisk           Pointer to HDD container.
    27612772 * @param   nImage          Image number, counts from 0. 0 is always base image of container.
    … …  
    27812792
    27822793        PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
    2783         AssertPtrBreakStmt(pImage, rc = VERR_VDI_IMAGE_NOT_FOUND);
     2794        AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
    27842795
    27852796        *puVersion = pImage->Backend->pfnGetVersion(pImage->pvBackendData);
    … …  
    27942805 *
    27952806 * @returns VBox status code.
    2796  * @returns VERR_VDI_IMAGE_NOT_FOUND if image with specified number was not opened.
     2807 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
    27972808 * @param   pDisk           Pointer to HDD container.
    27982809 * @param   nImage          Image number, counts from 0. 0 is always base image of container.
    … …  
    28182829
    28192830        PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
    2820         AssertPtrBreakStmt(pImage, rc = VERR_VDI_IMAGE_NOT_FOUND);
     2831        AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
    28212832
    28222833        if (    pImage->enmImageType >= VD_IMAGE_TYPE_FIRST
    … …  
    28272838        }
    28282839        else
    2829             rc = VERR_VDI_INVALID_TYPE;
     2840            rc = VERR_VD_INVALID_TYPE;
    28302841    } while (0);
    28312842
    … …  
    28392850 *
    28402851 * @returns VBox status code.
    2841  * @returns VERR_VDI_IMAGE_NOT_FOUND if image with specified number was not opened.
     2852 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
    28422853 * @param   pDisk           Pointer to the HDD container.
    28432854 * @param   nImage          Image number, counts from 0. 0 is always base image of container.
    … …  
    28632874
    28642875        PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
    2865         AssertPtrBreakStmt(pImage, rc = VERR_VDI_IMAGE_NOT_FOUND);
     2876        AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
    28662877
    28672878        if (    pImage->enmImageType >= VD_IMAGE_TYPE_FIRST
    … …  
    28752886        }
    28762887        else
    2877             rc = VERR_VDI_INVALID_TYPE;
     2888            rc = VERR_VD_INVALID_TYPE;
    28782889    } while (0);
    28792890
    … …  
    28862897 *
    28872898 * @returns VBox status code.
    2888  * @returns VERR_VDI_IMAGE_NOT_FOUND if image with specified number was not opened.
     2899 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
    28892900 * @param   pDisk           Pointer to HDD container.
    28902901 * @param   nImage          Image number, counts from 0. 0 is always base image of container.
    … …  
    29102921
    29112922        PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
    2912         AssertPtrBreakStmt(pImage, rc = VERR_VDI_IMAGE_NOT_FOUND);
     2923        AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
    29132924
    29142925        *puImageFlags = pImage->Backend->pfnGetImageFlags(pImage->pvBackendData);
    … …  
    29232934 *
    29242935 * @returns VBox status code.
    2925  * @returns VERR_VDI_IMAGE_NOT_FOUND if image with specified number was not opened.
     2936 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
    29262937 * @param   pDisk           Pointer to HDD container.
    29272938 * @param   nImage          Image number, counts from 0. 0 is always base image of container.
    … …  
    29472958
    29482959        PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
    2949         AssertPtrBreakStmt(pImage, rc = VERR_VDI_IMAGE_NOT_FOUND);
     2960        AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
    29502961
    29512962        *puOpenFlags = pImage->Backend->pfnGetOpenFlags(pImage->pvBackendData);
    … …  
    29622973 *
    29632974 * @returns VBox status code.
    2964  * @returns VERR_VDI_IMAGE_NOT_FOUND if image with specified number was not opened.
     2975 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
    29652976 * @param   pDisk           Pointer to HDD container.
    29662977 * @param   nImage          Image number, counts from 0. 0 is always base image of container.
    … …  
    29852996
    29862997        PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
    2987         AssertPtrBreakStmt(pImage, rc = VERR_VDI_IMAGE_NOT_FOUND);
     2998        AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
    29882999
    29893000        rc = pImage->Backend->pfnSetOpenFlags(pImage->pvBackendData,
    … …  
    30013012 *
    30023013 * @returns VBox status code.
    3003  * @returns VERR_VDI_IMAGE_NOT_FOUND if image with specified number was not opened.
     3014 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
    30043015 * @returns VERR_BUFFER_OVERFLOW if pszFilename buffer too small to hold filename.
    30053016 * @param   pDisk           Pointer to HDD container.
    … …  
    30303041
    30313042        PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
    3032         AssertPtrBreakStmt(pImage, rc = VERR_VDI_IMAGE_NOT_FOUND);
     3043        AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
    30333044
    30343045        size_t cb = strlen(pImage->pszFilename);
    … …  
    30543065 *
    30553066 * @returns VBox status code.
    3056  * @returns VERR_VDI_IMAGE_NOT_FOUND if image with specified number was not opened.
     3067 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
    30573068 * @returns VERR_BUFFER_OVERFLOW if pszComment buffer too small to hold comment text.
    30583069 * @param   pDisk           Pointer to HDD container.
    … …  
    30833094
    30843095        PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
    3085         AssertPtrBreakStmt(pImage, rc = VERR_VDI_IMAGE_NOT_FOUND);
     3096        AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
    30863097
    30873098        rc = pImage->Backend->pfnGetComment(pImage->pvBackendData, pszComment,
    … …  
    30973108 *
    30983109 * @returns VBox status code.
    3099  * @returns VERR_VDI_IMAGE_NOT_FOUND if image with specified number was not opened.
     3110 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
    31003111 * @param   pDisk           Pointer to HDD container.
    31013112 * @param   nImage          Image number, counts from 0. 0 is always base image of container.
    … …  
    31213132
    31223133        PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
    3123         AssertPtrBreakStmt(pImage, rc = VERR_VDI_IMAGE_NOT_FOUND);
     3134        AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
    31243135
    31253136        rc = pImage->Backend->pfnSetComment(pImage->pvBackendData, pszComment);
    … …  
    31353146 *
    31363147 * @returns VBox status code.
    3137  * @returns VERR_VDI_IMAGE_NOT_FOUND if image with specified number was not opened.
     3148 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
    31383149 * @param   pDisk           Pointer to HDD container.
    31393150 * @param   nImage          Image number, counts from 0. 0 is always base image of container.
    … …  
    31573168
    31583169        PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
    3159         AssertPtrBreakStmt(pImage, rc = VERR_VDI_IMAGE_NOT_FOUND);
     3170        AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
    31603171
    31613172        rc = pImage->Backend->pfnGetUuid(pImage->pvBackendData, pUuid);
    … …  
    31703181 *
    31713182 * @returns VBox status code.
    3172  * @returns VERR_VDI_IMAGE_NOT_FOUND if image with specified number was not opened.
     3183 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
    31733184 * @param   pDisk           Pointer to HDD container.
    31743185 * @param   nImage          Image number, counts from 0. 0 is always base image of container.
    … …  
    31923203
    31933204        PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
    3194         AssertPtrBreakStmt(pImage, rc = VERR_VDI_IMAGE_NOT_FOUND);
     3205        AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
    31953206
    31963207        RTUUID Uuid;
    … …  
    32113222 *
    32123223 * @returns VBox status code.
    3213  * @returns VERR_VDI_IMAGE_NOT_FOUND if image with specified number was not opened.
     3224 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
    32143225 * @param   pDisk           Pointer to HDD container.
    32153226 * @param   nImage          Image number, counts from 0. 0 is always base image of container.
    … …  
    32333244
    32343245        PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
    3235         AssertPtrBreakStmt(pImage, rc = VERR_VDI_IMAGE_NOT_FOUND);
     3246        AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
    32363247
    32373248        rc = pImage->Backend->pfnGetModificationUuid(pImage->pvBackendData,
    … …  
    32473258 *
    32483259 * @returns VBox status code.
    3249  * @returns VERR_VDI_IMAGE_NOT_FOUND if image with specified number was not opened.
     3260 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
    32503261 * @param   pDisk           Pointer to HDD container.
    32513262 * @param   nImage          Image number, counts from 0. 0 is always base image of container.
    … …  
    32703281
    32713282        PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
    3272         AssertPtrBreakStmt(pImage, rc = VERR_VDI_IMAGE_NOT_FOUND);
     3283        AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
    32733284
    32743285        RTUUID Uuid;
    … …  
    32903301 *
    32913302 * @returns VBox status code.
    3292  * @returns VERR_VDI_IMAGE_NOT_FOUND if image with specified number was not opened.
     3303 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
    32933304 * @param   pDisk           Pointer to HDD container.
    32943305 * @param   nImage          Image number, counts from 0. 0 is always base image of container.
    … …  
    33133324
    33143325        PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
    3315         AssertPtrBreakStmt(pImage, rc = VERR_VDI_IMAGE_NOT_FOUND);
     3326        AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
    33163327
    33173328        rc = pImage->Backend->pfnGetParentUuid(pImage->pvBackendData, pUuid);
    … …  
    33493360
    33503361        PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
    3351         AssertPtrBreakStmt(pImage, rc = VERR_VDI_IMAGE_NOT_FOUND);
     3362        AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
    33523363
    33533364        RTUUID Uuid;
    … …  
    33923403 *
    33933404 * @returns VBox status code.
    3394  * @returns VERR_VDI_IMAGE_NOT_FOUND if image with specified number was not opened.
     3405 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
    33953406 * @param   pDisk           Pointer to the HDD container.
    33963407 * @param   nImage          Image number, counts from 0. 0 is always base image of container.
    … …  
    34143425
    34153426        PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
    3416         AssertPtrBreakStmt(pImage, rc = VERR_VDI_IMAGE_NOT_FOUND);
     3427        AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
    34173428
    34183429        if (pImage->Backend->uBackendCaps & VD_CAP_ASYNC)
    … …  
    34413452                              void *pvUser)
    34423453{
    3443     int rc = VERR_VDI_BLOCK_FREE;
     3454    int rc = VERR_VD_BLOCK_FREE;
    34443455
    34453456    LogFlowFunc(("pDisk=%#p uOffset=%llu paSeg=%p cSeg=%u cbRead=%zu\n",
    … …  
    34683479
    34693480        PVDIMAGE pImage = pDisk->pLast;
    3470         AssertPtrBreakStmt(pImage, rc = VERR_VDI_NOT_OPENED);
     3481        AssertPtrBreakStmt(pImage, rc = VERR_VD_NOT_OPENED);
    34713482
    34723483        /* @todo: This does not work for images which do not have all meta data in memory. */
    34733484        for (PVDIMAGE pCurrImage = pImage;
    3474              pCurrImage != NULL && rc == VERR_VDI_BLOCK_FREE;
     3485             pCurrImage != NULL && rc == VERR_VD_BLOCK_FREE;
    34753486             pCurrImage = pCurrImage->pPrev)
    34763487        {
    … …  
    34813492
    34823493        /* No image in the chain contains the data for the block. */
    3483         if (rc == VERR_VDI_BLOCK_FREE)
     3494        if (rc == VERR_VD_BLOCK_FREE)
    34843495        {
    34853496            for (unsigned i = 0; i < cSeg && (cbRead > 0); i++)
    … …  
    34893500            }
    34903501            /* Request finished without the need to enqueue a async I/O request. Tell caller. */
    3491             rc = VINF_VDI_ASYNC_IO_FINISHED;
     3502            rc = VINF_VD_ASYNC_IO_FINISHED;
    34923503        }
    34933504
    … …  
    35413552
    35423553        PVDIMAGE pImage = pDisk->pLast;
    3543         AssertPtrBreakStmt(pImage, rc = VERR_VDI_NOT_OPENED);
     3554        AssertPtrBreakStmt(pImage, rc = VERR_VD_NOT_OPENED);
    35443555
    35453556        vdSetModifiedFlag(pDisk);

  • trunk/src/VBox/Devices/Storage/VBoxHDD-newInternal.h

    r14967 r15366  
    161161     *
    162162     * @returns VBox status code.
    163      * @returns VINF_VDI_BLOCK_FREE if this image contains no data for this block.
    164      * @returns VINF_VDI_BLOCK_ZERO if this image contains a zero data block.
     163     * @returns VINF_VD_BLOCK_FREE if this image contains no data for this block.
     164     * @returns VINF_VD_BLOCK_ZERO if this image contains a zero data block.
    165165     * @param   pvBackendData   Opaque state data for this image.
    166166     * @param   off             Offset to start reading from.
    … …  
    177177     *
    178178     * @returns VBox status code.
    179      * @returns VINF_VDI_BLOCK_FREE if this image contains no data for this block and
     179     * @returns VINF_VD_BLOCK_FREE if this image contains no data for this block and
    180180     *          this is not a full-block write. The write must be repeated with
    181181     *          the correct amount of prefix/postfix data read from the images below
    … …  
    189189     * @param   pcbWriteProcess Pointer to returned number of bytes that could
    190190     *                          be processed. In case the function returned
    191      *                          VINF_VDI_BLOCK_FREE this is the number of bytes
     191     *                          VINF_VD_BLOCK_FREE this is the number of bytes
    192192     *                          that could be written in a full block write,
    193193     *                          when prefixed/postfixed by the appropriate
    … …  
    250250     *
    251251     * @returns VBox status code.
    252      * @returns VERR_VDI_GEOMETRY_NOT_SET if no geometry present in the image.
     252     * @returns VERR_VD_GEOMETRY_NOT_SET if no geometry present in the image.
    253253     * @param   pvBackendData   Opaque state data for this image.
    254254     * @param   pPCHSGeometry   Where to store the geometry. Not NULL.
    … …  
    270270     *
    271271     * @returns VBox status code.
    272      * @returns VERR_VDI_GEOMETRY_NOT_SET if no geometry present in the image.
     272     * @returns VERR_VD_GEOMETRY_NOT_SET if no geometry present in the image.
    273273     * @param   pvBackendData   Opaque state data for this image.
    274274     * @param   pLCHSGeometry   Where to store the geometry. Not NULL.

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

    r14967 r15366  
    117117{
    118118    if (pPreHdr->u32Signature != VDI_IMAGE_SIGNATURE)
    119         return VERR_VDI_INVALID_SIGNATURE;
     119        return VERR_VD_VDI_INVALID_SIGNATURE;
    120120
    121121    if (    VDI_GET_VERSION_MAJOR(pPreHdr->u32Version) != VDI_IMAGE_VERSION_MAJOR
    122122        &&  pPreHdr->u32Version != 0x00000002)    /* old version. */
    123         return VERR_VDI_UNSUPPORTED_VERSION;
     123        return VERR_VD_VDI_UNSUPPORTED_VERSION;
    124124
    125125    return VINF_SUCCESS;
    … …  
    246246                LogRel(("VDI: v1 header size wrong (%d < %d)\n",
    247247                       pHeader->u.v1.cbHeader, sizeof(VDIHEADER1)));
    248                 return VERR_VDI_INVALID_HEADER;
     248                return VERR_VD_VDI_INVALID_HEADER;
    249249            }
    250250
    … …  
    253253                LogRel(("VDI: v1 blocks offset wrong (%d < %d)\n",
    254254                       getImageBlocksOffset(pHeader), sizeof(VDIPREHEADER) + sizeof(VDIHEADER1)));
    255                 return VERR_VDI_INVALID_HEADER;
     255                return VERR_VD_VDI_INVALID_HEADER;
    256256            }
    257257
    … …  
    260260                LogRel(("VDI: v1 image data offset wrong (%d < %d)\n",
    261261                       getImageDataOffset(pHeader), getImageBlocksOffset(pHeader) + getImageBlocks(pHeader) * sizeof(VDIIMAGEBLOCKPOINTER)));
    262                 return VERR_VDI_INVALID_HEADER;
     262                return VERR_VD_VDI_INVALID_HEADER;
    263263            }
    264264
    … …  
    267267        default:
    268268            /* Unsupported. */
    269             return VERR_VDI_UNSUPPORTED_VERSION;
     269            return VERR_VD_VDI_UNSUPPORTED_VERSION;
    270270    }
    271271
    … …  
    342342    }
    343343
    344     return fFailed ? VERR_VDI_INVALID_HEADER : VINF_SUCCESS;
     344    return fFailed ? VERR_VD_VDI_INVALID_HEADER : VINF_SUCCESS;
    345345}
    346346
    … …  
    381381        && strlen(pszComment) >= VDI_IMAGE_COMMENT_SIZE)
    382382    {
    383         rc = vdiError(pImage, VERR_VDI_COMMENT_TOO_LONG, RT_SRC_POS, N_("VDI: comment is too long for '%s'"), pImage->pszFilename);
     383        rc = vdiError(pImage, VERR_VD_VDI_COMMENT_TOO_LONG, RT_SRC_POS, N_("VDI: comment is too long for '%s'"), pImage->pszFilename);
    384384        goto out;
    385385    }
    … …  
    656656            break;
    657657        default:
    658             rc = vdiError(pImage, VERR_VDI_UNSUPPORTED_VERSION, RT_SRC_POS, N_("VDI: unsupported major version %u in '%s'"), GET_MAJOR_HEADER_VERSION(&pImage->Header), pImage->pszFilename);
     658            rc = vdiError(pImage, VERR_VD_VDI_UNSUPPORTED_VERSION, RT_SRC_POS, N_("VDI: unsupported major version %u in '%s'"), GET_MAJOR_HEADER_VERSION(&pImage->Header), pImage->pszFilename);
    659659            goto out;
    660660    }
    … …  
    663663    if (RT_FAILURE(rc))
    664664    {
    665         rc = vdiError(pImage, VERR_VDI_UNSUPPORTED_VERSION, RT_SRC_POS, N_("VDI: invalid header in '%s'"), pImage->pszFilename);
     665        rc = vdiError(pImage, VERR_VD_VDI_INVALID_HEADER, RT_SRC_POS, N_("VDI: invalid header in '%s'"), pImage->pszFilename);
    666666        goto out;
    667667    }
    … …  
    707707            break;
    708708        default:
    709             rc = VERR_VDI_UNSUPPORTED_VERSION;
     709            rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
    710710            break;
    711711    }
    … …  
    10301030
    10311031    if (pImage->paBlocks[uBlock] == VDI_IMAGE_BLOCK_FREE)
    1032         rc = VERR_VDI_BLOCK_FREE;
     1032        rc = VERR_VD_BLOCK_FREE;
    10331033    else if (pImage->paBlocks[uBlock] == VDI_IMAGE_BLOCK_ZERO)
    10341034    {
    … …  
    10691069    if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
    10701070    {
    1071         rc = VERR_VDI_IMAGE_READ_ONLY;
     1071        rc = VERR_VD_IMAGE_READ_ONLY;
    10721072        goto out;
    10731073    }
    … …  
    11381138            *pcbPreRead = offWrite % getImageBlockSize(&pImage->Header);
    11391139            *pcbPostRead = getImageBlockSize(&pImage->Header) - cbToWrite - *pcbPreRead;
    1140             rc = VERR_VDI_BLOCK_FREE;
     1140            rc = VERR_VD_BLOCK_FREE;
    11411141        }
    11421142    }
    … …  
    12011201        *penmImageType = vdiTranslateTypeVDI2VD(getImageType(&pImage->Header));
    12021202    else
    1203         rc = VERR_VDI_NOT_OPENED;
     1203        rc = VERR_VD_NOT_OPENED;
    12041204
    12051205    LogFlowFunc(("returns %Rrc enmImageType=%u\n", rc, *penmImageType));
    … …  
    12671267        }
    12681268        else
    1269             rc = VERR_VDI_GEOMETRY_NOT_SET;
    1270     }
    1271     else
    1272         rc = VERR_VDI_NOT_OPENED;
     1269            rc = VERR_VD_GEOMETRY_NOT_SET;
     1270    }
     1271    else
     1272        rc = VERR_VD_NOT_OPENED;
    12731273
    12741274    LogFlowFunc(("returns %Rrc (PCHS=%u/%u/%u)\n", rc, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
    … …  
    12901290        if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
    12911291        {
    1292             rc = VERR_VDI_IMAGE_READ_ONLY;
     1292            rc = VERR_VD_IMAGE_READ_ONLY;
    12931293            goto out;
    12941294        }
    … …  
    12981298    }
    12991299    else
    1300         rc = VERR_VDI_NOT_OPENED;
     1300        rc = VERR_VD_NOT_OPENED;
    13011301
    13021302out:
    … …  
    13321332        }
    13331333        else
    1334             rc = VERR_VDI_GEOMETRY_NOT_SET;
    1335     }
    1336     else
    1337         rc = VERR_VDI_NOT_OPENED;
     1334            rc = VERR_VD_GEOMETRY_NOT_SET;
     1335    }
     1336    else
     1337        rc = VERR_VD_NOT_OPENED;
    13381338
    13391339    LogFlowFunc(("returns %Rrc (LCHS=%u/%u/%u)\n", rc, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
    … …  
    13561356        if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
    13571357        {
    1358             rc = VERR_VDI_IMAGE_READ_ONLY;
     1358            rc = VERR_VD_IMAGE_READ_ONLY;
    13591359            goto out;
    13601360        }
    … …  
    13741374    }
    13751375    else
    1376         rc = VERR_VDI_NOT_OPENED;
     1376        rc = VERR_VD_NOT_OPENED;
    13771377
    13781378out:
    … …  
    14661466    }
    14671467    else
    1468         rc = VERR_VDI_NOT_OPENED;
     1468        rc = VERR_VD_NOT_OPENED;
    14691469
    14701470    LogFlowFunc(("returns %Rrc comment=\"%s\"\n", rc, pszComment));
    … …  
    14831483    if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
    14841484    {
    1485         rc = VERR_VDI_IMAGE_READ_ONLY;
     1485        rc = VERR_VD_IMAGE_READ_ONLY;
    14861486        goto out;
    14871487    }
    … …  
    14931493        {
    14941494            LogFunc(("pszComment is too long, %d bytes!\n", cchComment));
    1495             rc = VERR_VDI_COMMENT_TOO_LONG;
     1495            rc = VERR_VD_VDI_COMMENT_TOO_LONG;
    14961496            goto out;
    14971497        }
    … …  
    15101510        }
    15111511        else
    1512             rc = VERR_VDI_UNSUPPORTED_VERSION;
    1513     }
    1514     else
    1515         rc = VERR_VDI_NOT_OPENED;
     1512            rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
     1513    }
     1514    else
     1515        rc = VERR_VD_NOT_OPENED;
    15161516
    15171517out:
    … …  
    15351535    }
    15361536    else
    1537         rc = VERR_VDI_NOT_OPENED;
     1537        rc = VERR_VD_NOT_OPENED;
    15381538
    15391539    LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
    … …  
    15621562            {
    15631563                LogFunc(("Version is not supported!\n"));
    1564                 rc = VERR_VDI_UNSUPPORTED_VERSION;
     1564                rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
    15651565            }
    15661566        }
    15671567        else
    1568             rc = VERR_VDI_IMAGE_READ_ONLY;
    1569     }
    1570     else
    1571         rc = VERR_VDI_NOT_OPENED;
     1568            rc = VERR_VD_IMAGE_READ_ONLY;
     1569    }
     1570    else
     1571        rc = VERR_VD_NOT_OPENED;
    15721572
    15731573    LogFlowFunc(("returns %Rrc\n", rc));
    … …  
    15901590    }
    15911591    else
    1592         rc = VERR_VDI_NOT_OPENED;
     1592        rc = VERR_VD_NOT_OPENED;
    15931593
    15941594    LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
    … …  
    16171617            {
    16181618                LogFunc(("Version is not supported!\n"));
    1619                 rc = VERR_VDI_UNSUPPORTED_VERSION;
     1619                rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
    16201620            }
    16211621        }
    16221622        else
    1623             rc = VERR_VDI_IMAGE_READ_ONLY;
    1624     }
    1625     else
    1626         rc = VERR_VDI_NOT_OPENED;
     1623            rc = VERR_VD_IMAGE_READ_ONLY;
     1624    }
     1625    else
     1626        rc = VERR_VD_NOT_OPENED;
    16271627
    16281628    LogFlowFunc(("returns %Rrc\n", rc));
    … …  
    16451645    }
    16461646    else
    1647         rc = VERR_VDI_NOT_OPENED;
     1647        rc = VERR_VD_NOT_OPENED;
    16481648
    16491649    LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
    … …  
    16721672            {
    16731673                LogFunc(("Version is not supported!\n"));
    1674                 rc = VERR_VDI_UNSUPPORTED_VERSION;
     1674                rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
    16751675            }
    16761676        }
    16771677        else
    1678             rc = VERR_VDI_IMAGE_READ_ONLY;
    1679     }
    1680     else
    1681         rc = VERR_VDI_NOT_OPENED;
     1678            rc = VERR_VD_IMAGE_READ_ONLY;
     1679    }
     1680    else
     1681        rc = VERR_VD_NOT_OPENED;
    16821682
    16831683    LogFlowFunc(("returns %Rrc\n", rc));
    … …  
    17001700    }
    17011701    else
    1702         rc = VERR_VDI_NOT_OPENED;
     1702        rc = VERR_VD_NOT_OPENED;
    17031703
    17041704    LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
    … …  
    17241724            {
    17251725                LogFunc(("Version is not supported!\n"));
    1726                 rc = VERR_VDI_UNSUPPORTED_VERSION;
     1726                rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
    17271727            }
    17281728        }
    17291729        else
    1730             rc = VERR_VDI_IMAGE_READ_ONLY;
    1731     }
    1732     else
    1733         rc = VERR_VDI_NOT_OPENED;
     1730            rc = VERR_VD_IMAGE_READ_ONLY;
     1731    }
     1732    else
     1733        rc = VERR_VD_NOT_OPENED;
    17341734
    17351735    LogFlowFunc(("returns %Rrc\n", rc));

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

    r14967 r15366  
    344344
    345345    if (!pImage)
    346         return VERR_VDI_NOT_OPENED;
     346        return VERR_VD_NOT_OPENED;
    347347
    348348    rc = RTFileReadAt(pImage->File, pImage->u64DataOffset, &ddh, sizeof(ddh), NULL);
    … …  
    351351    if (memcmp(ddh.Cookie, VHD_DYNAMIC_DISK_HEADER_COOKIE, VHD_DYNAMIC_DISK_HEADER_COOKIE_SIZE) != 0)
    352352    {
    353         return VERR_VDI_INVALID_HEADER;
     353        return VERR_VD_VHD_INVALID_HEADER;
    354354    }
    355355    uint32_t u32Checksum = RT_BE2H_U32(ddh.Checksum);
    … …  
    357357    if (u32Checksum != vhdChecksum(&ddh, sizeof(ddh)))
    358358    {
    359         return VERR_VDI_INVALID_HEADER;
     359        return VERR_VD_VHD_INVALID_HEADER;
    360360    }
    361361    /* Update parent's timestamp. */
    … …  
    423423    rc = RTFileReadAt(File, pImage->uCurrentEndOfFile, &vhdFooter, sizeof(VHDFooter), NULL);
    424424    if (memcmp(vhdFooter.Cookie, VHD_FOOTER_COOKIE, VHD_FOOTER_COOKIE_SIZE) != 0) {
    425         return VERR_VDI_INVALID_HEADER;
     425        return VERR_VD_VHD_INVALID_HEADER;
    426426    }
    427427
    … …  
    588588    rc = RTFileOpen(&File, pszFilename, RTFILE_O_READ | RTFILE_O_OPEN);
    589589    if (RT_FAILURE(rc))
    590         return VERR_VDI_INVALID_HEADER;
     590        return VERR_VD_VHD_INVALID_HEADER;
    591591
    592592    rc = RTFileGetSize(File, &cbFile);
    … …  
    594594    {
    595595        RTFileClose(File);
    596         return VERR_VDI_INVALID_HEADER;
     596        return VERR_VD_VHD_INVALID_HEADER;
    597597    }
    598598
    599599    rc = RTFileReadAt(File, cbFile - sizeof(VHDFooter), &vhdFooter, sizeof(VHDFooter), NULL);
    600600    if (RT_FAILURE(rc) || (memcmp(vhdFooter.Cookie, VHD_FOOTER_COOKIE, VHD_FOOTER_COOKIE_SIZE) != 0))
    601         rc = VERR_VDI_INVALID_HEADER;
     601        rc = VERR_VD_VHD_INVALID_HEADER;
    602602    else
    603603        rc = VINF_SUCCESS;
    … …  
    631631        *penmImageType = pImage->enmImageType;
    632632    else
    633         rc = VERR_VDI_NOT_OPENED;
     633        rc = VERR_VD_NOT_OPENED;
    634634
    635635    return rc;
    … …  
    651651        }
    652652        else
    653             rc = VERR_VDI_GEOMETRY_NOT_SET;
    654     }
    655     else
    656         rc = VERR_VDI_NOT_OPENED;
     653            rc = VERR_VD_GEOMETRY_NOT_SET;
     654    }
     655    else
     656        rc = VERR_VD_NOT_OPENED;
    657657
    658658    LogFlowFunc(("returned %Rrc (CHS=%u/%u/%u)\n", rc, pImage->PCHSGeometry.cCylinders, pImage->PCHSGeometry.cHeads, pImage->PCHSGeometry.cSectors));
    … …  
    671671        if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
    672672        {
    673             rc = VERR_VDI_IMAGE_READ_ONLY;
     673            rc = VERR_VD_IMAGE_READ_ONLY;
    674674            goto out;
    675675        }
    … …  
    679679    }
    680680    else
    681         rc = VERR_VDI_NOT_OPENED;
     681        rc = VERR_VD_NOT_OPENED;
    682682
    683683out:
    … …  
    701701        }
    702702        else
    703             rc = VERR_VDI_GEOMETRY_NOT_SET;
    704     }
    705     else
    706         rc = VERR_VDI_NOT_OPENED;
     703            rc = VERR_VD_GEOMETRY_NOT_SET;
     704    }
     705    else
     706        rc = VERR_VD_NOT_OPENED;
    707707
    708708    LogFlowFunc(("returned %Rrc (CHS=%u/%u/%u)\n", rc, pImage->LCHSGeometry.cCylinders, pImage->LCHSGeometry.cHeads, pImage->LCHSGeometry.cSectors));
    … …  
    721721        if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
    722722        {
    723             rc = VERR_VDI_IMAGE_READ_ONLY;
     723            rc = VERR_VD_IMAGE_READ_ONLY;
    724724            goto out;
    725725        }
    … …  
    729729    }
    730730    else
    731         rc = VERR_VDI_NOT_OPENED;
     731        rc = VERR_VD_NOT_OPENED;
    732732
    733733out:
    … …  
    891891            /* Return block size as read. */
    892892            *pcbActuallyRead = RT_MIN(cbRead, pImage->cSectorsPerDataBlock * VHD_SECTOR_SIZE);
    893             return VERR_VDI_BLOCK_FREE;
     893            return VERR_VD_BLOCK_FREE;
    894894        }
    895895
    … …  
    976976                cbRead = cSectors * VHD_SECTOR_SIZE;
    977977                Log(("%s: Sectors free: uVhdOffset=%llu cbRead=%u\n", uVhdOffset, cbRead));
    978                 rc = VERR_VDI_BLOCK_FREE;
     978                rc = VERR_VD_BLOCK_FREE;
    979979            }
    980980        }
    … …  
    11871187    }
    11881188    else
    1189         rc = VERR_VDI_NOT_OPENED;
     1189        rc = VERR_VD_NOT_OPENED;
    11901190    LogFlowFunc(("returned %Rrc (%RTuuid)\n", rc, pUuid));
    11911191    return rc;
    … …  
    12071207    }
    12081208    else
    1209         rc = VERR_VDI_NOT_OPENED;
     1209        rc = VERR_VD_NOT_OPENED;
    12101210    LogFlowFunc(("returned %Rrc\n", rc));
    12111211    return rc;
    … …  
    12211221    if (pImage)
    12221222    {
    1223         rc = VERR_VDI_VALUE_NOT_FOUND;
    1224     }
    1225     else
    1226         rc = VERR_VDI_NOT_OPENED;
     1223        rc = VERR_NOT_SUPPORTED;
     1224    }
     1225    else
     1226        rc = VERR_VD_NOT_OPENED;
    12271227
    12281228    LogFlowFunc(("returned %Rrc comment='%s'\n", rc, pszComment));
    … …  
    12441244    }
    12451245    else
    1246         rc = VERR_VDI_NOT_OPENED;
     1246        rc = VERR_VD_NOT_OPENED;
    12471247
    12481248    LogFlowFunc(("returned %Rrc\n", rc));
    … …  
    12591259    if (pImage)
    12601260    {
    1261         rc = VERR_VDI_VALUE_NOT_FOUND;
    1262     }
    1263     else
    1264         rc = VERR_VDI_NOT_OPENED;
     1261        rc = VERR_NOT_SUPPORTED;
     1262    }
     1263    else
     1264        rc = VERR_VD_NOT_OPENED;
    12651265    LogFlowFunc(("returned %Rrc (%RTuuid)\n", rc, pUuid));
    12661266    return rc;
    … …  
    12801280    }
    12811281    else
    1282         rc = VERR_VDI_NOT_OPENED;
     1282        rc = VERR_VD_NOT_OPENED;
    12831283    LogFlowFunc(("returned %Rrc\n", rc));
    12841284    return rc;
    … …  
    12981298    }
    12991299    else
    1300         rc = VERR_VDI_NOT_OPENED;
     1300        rc = VERR_VD_NOT_OPENED;
    13011301    LogFlowFunc(("returned %Rrc (%RTuuid)\n", rc, pUuid));
    13021302    return rc;
    … …  
    13221322    }
    13231323    else
    1324         rc = VERR_VDI_NOT_OPENED;
     1324        rc = VERR_VD_NOT_OPENED;
    13251325    LogFlowFunc(("returned %Rrc\n", rc));
    13261326    return rc;
    … …  
    13361336    if (pImage)
    13371337    {
    1338         rc = VERR_VDI_VALUE_NOT_FOUND;
    1339     }
    1340     else
    1341         rc = VERR_VDI_NOT_OPENED;
     1338        rc = VERR_NOT_SUPPORTED;
     1339    }
     1340    else
     1341        rc = VERR_VD_NOT_OPENED;
    13421342    LogFlowFunc(("returned %Rrc (%RTuuid)\n", rc, pUuid));
    13431343    return rc;
    … …  
    13571357    }
    13581358    else
    1359         rc = VERR_VDI_NOT_OPENED;
     1359        rc = VERR_VD_NOT_OPENED;
    13601360    LogFlowFunc(("returned %Rrc\n", rc));
    13611361    return rc;
    … …  
    17591759    }
    17601760    else
    1761         rc = VERR_VDI_NOT_OPENED;
     1761        rc = VERR_VD_NOT_OPENED;
    17621762    LogFlowFunc(("returned %Rrc\n", rc));
    17631763    return rc;
    … …  
    17731773        vhdTime2RtTime(pTimeStamp, pImage->u32ParentTimeStamp);
    17741774    else
    1775         rc = VERR_VDI_NOT_OPENED;
     1775        rc = VERR_VD_NOT_OPENED;
    17761776    LogFlowFunc(("returned %Rrc\n", rc));
    17771777    return rc;
    … …  
    17871787    {
    17881788        if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
    1789             rc = VERR_VDI_IMAGE_READ_ONLY;
     1789            rc = VERR_VD_IMAGE_READ_ONLY;
    17901790        else
    17911791        {
    … …  
    17951795    }
    17961796    else
    1797         rc = VERR_VDI_NOT_OPENED;
     1797        rc = VERR_VD_NOT_OPENED;
    17981798    LogFlowFunc(("returned %Rrc\n", rc));
    17991799    return rc;
    … …  
    18091809        *ppszParentFilename = RTStrDup(pImage->pszParentFilename);
    18101810    else
    1811         rc = VERR_VDI_NOT_OPENED;
     1811        rc = VERR_VD_NOT_OPENED;
    18121812    LogFlowFunc(("returned %Rrc\n", rc));
    18131813    return rc;
    … …  
    18231823    {
    18241824        if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
    1825             rc = VERR_VDI_IMAGE_READ_ONLY;
     1825            rc = VERR_VD_IMAGE_READ_ONLY;
    18261826        else
    18271827        {
    … …  
    18361836    }
    18371837    else
    1838         rc = VERR_VDI_NOT_OPENED;
     1838        rc = VERR_VD_NOT_OPENED;
    18391839    LogFlowFunc(("returned %Rrc\n", rc));
    18401840    return rc;

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

    r14967 r15366  
    758758            else if (CpQ == '\0')
    759759            {
    760                 rc = VERR_VDI_INVALID_HEADER;
     760                rc = VERR_VD_VMDK_INVALID_HEADER;
    761761                break;
    762762            }
    … …  
    859859                RTMemTmpFree(pTmpGT1);
    860860                RTMemTmpFree(pTmpGT2);
    861                 rc = vmdkError(pExtent->pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: inconsistent references to grain directory in '%s'"), pExtent->pszFullname);
     861                rc = vmdkError(pExtent->pImage, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: inconsistent references to grain directory in '%s'"), pExtent->pszFullname);
    862862                goto out;
    863863            }
    … …  
    884884                RTMemTmpFree(pTmpGT1);
    885885                RTMemTmpFree(pTmpGT2);
    886                 rc = vmdkError(pExtent->pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: inconsistency between grain table and backup grain table in '%s'"), pExtent->pszFullname);
     886                rc = vmdkError(pExtent->pImage, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: inconsistency between grain table and backup grain table in '%s'"), pExtent->pszFullname);
    887887                goto out;
    888888            }
    … …  
    10031003        pszStr++;
    10041004    if (*pszStr++ != '"')
    1005         return vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: incorrectly quoted value in descriptor in '%s'"), pImage->pszFilename);
     1005        return vmdkError(pImage, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: incorrectly quoted value in descriptor in '%s'"), pImage->pszFilename);
    10061006
    10071007    pszQ = (char *)strchr(pszStr, '"');
    10081008    if (pszQ == NULL)
    1009         return vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: incorrectly quoted value in descriptor in '%s'"), pImage->pszFilename);
     1009        return vmdkError(pImage, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: incorrectly quoted value in descriptor in '%s'"), pImage->pszFilename);
    10101010    pszUnquoted = (char *)RTMemTmpAlloc(pszQ - pszStr + 1);
    10111011    if (!pszUnquoted)
    … …  
    11831183    if (!vmdkDescGetStr(pDescriptor, pDescriptor->uFirstDesc, pszKey,
    11841184                        &pszValue))
    1185         return VERR_VDI_VALUE_NOT_FOUND;
     1185        return VERR_VD_VMDK_VALUE_NOT_FOUND;
    11861186    return RTStrToUInt32Ex(pszValue, NULL, 10, puValue);
    11871187}
    … …  
    11951195    if (!vmdkDescGetStr(pDescriptor, pDescriptor->uFirstDesc, pszKey,
    11961196                        &pszValue))
    1197         return VERR_VDI_VALUE_NOT_FOUND;
     1197        return VERR_VD_VMDK_VALUE_NOT_FOUND;
    11981198    int rc = vmdkStringUnquote(pImage, pszValue, &pszValueUnquoted, NULL);
    11991199    if (RT_FAILURE(rc))
    … …  
    13241324    if (!vmdkDescGetStr(pDescriptor, pDescriptor->uFirstDDB, pszKey,
    13251325                        &pszValue))
    1326         return VERR_VDI_VALUE_NOT_FOUND;
     1326        return VERR_VD_VMDK_VALUE_NOT_FOUND;
    13271327    int rc = vmdkStringUnquote(pImage, pszValue, &pszValueUnquoted, NULL);
    13281328    if (RT_FAILURE(rc))
    … …  
    13401340    if (!vmdkDescGetStr(pDescriptor, pDescriptor->uFirstDDB, pszKey,
    13411341                        &pszValue))
    1342         return VERR_VDI_VALUE_NOT_FOUND;
     1342        return VERR_VD_VMDK_VALUE_NOT_FOUND;
    13431343    int rc = vmdkStringUnquote(pImage, pszValue, &pszValueUnquoted, NULL);
    13441344    if (RT_FAILURE(rc))
    … …  
    13571357    if (!vmdkDescGetStr(pDescriptor, pDescriptor->uFirstDDB, pszKey,
    13581358                        &pszValue))
    1359         return VERR_VDI_VALUE_NOT_FOUND;
     1359        return VERR_VD_VMDK_VALUE_NOT_FOUND;
    13601360    int rc = vmdkStringUnquote(pImage, pszValue, &pszValueUnquoted, NULL);
    13611361    if (RT_FAILURE(rc))
    … …  
    14291429        if (cLine >= VMDK_DESCRIPTOR_LINES_MAX)
    14301430        {
    1431             rc = vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: descriptor too big in '%s'"), pImage->pszFilename);
     1431            rc = vmdkError(pImage, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: descriptor too big in '%s'"), pImage->pszFilename);
    14321432            goto out;
    14331433        }
    … …  
    14391439                if (*(pTmp + 1) != '\n')
    14401440                {
    1441                     rc = vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: unsupported end of line in descriptor in '%s'"), pImage->pszFilename);
     1441                    rc = vmdkError(pImage, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: unsupported end of line in descriptor in '%s'"), pImage->pszFilename);
    14421442                    goto out;
    14431443                }
    … …  
    14641464        &&  strcmp(pDescriptor->aLines[0], "# Disk Descriptor File"))
    14651465    {
    1466         rc = vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: descriptor does not start as expected in '%s'"), pImage->pszFilename);
     1466        rc = vmdkError(pImage, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: descriptor does not start as expected in '%s'"), pImage->pszFilename);
    14671467        goto out;
    14681468    }
    … …  
    14841484                {
    14851485                    /* Incorrect ordering of entries. */
    1486                     rc = vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: incorrect ordering of entries in descriptor in '%s'"), pImage->pszFilename);
     1486                    rc = vmdkError(pImage, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: incorrect ordering of entries in descriptor in '%s'"), pImage->pszFilename);
    14871487                    goto out;
    14881488                }
    … …  
    14991499                {
    15001500                    /* Incorrect ordering of entries. */
    1501                     rc = vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: incorrect ordering of entries in descriptor in '%s'"), pImage->pszFilename);
     1501                    rc = vmdkError(pImage, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: incorrect ordering of entries in descriptor in '%s'"), pImage->pszFilename);
    15021502                    goto out;
    15031503                }
    … …  
    15141514                {
    15151515                    /* Incorrect ordering of entries. */
    1516                     rc = vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: incorrect ordering of entries in descriptor in '%s'"), pImage->pszFilename);
     1516                    rc = vmdkError(pImage, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: incorrect ordering of entries in descriptor in '%s'"), pImage->pszFilename);
    15171517                    goto out;
    15181518                }
    … …  
    16591659        return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error finding key 'version' in descriptor in '%s'"), pImage->pszFilename);
    16601660    if (uVersion != 1)
    1661         return vmdkError(pImage, VERR_VDI_UNSUPPORTED_VERSION, RT_SRC_POS, N_("VMDK: unsupported format version in descriptor in '%s'"), pImage->pszFilename);
     1661        return vmdkError(pImage, VERR_VD_VMDK_UNSUPPORTED_VERSION, RT_SRC_POS, N_("VMDK: unsupported format version in descriptor in '%s'"), pImage->pszFilename);
    16621662
    16631663    /* Get image creation type and determine image flags. */
    … …  
    16861686    {
    16871687        /* Monolithic image, must have only one extent (already opened). */
    1688         return vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: monolithic image may only have one extent in '%s'"), pImage->pszFilename);
     1688        return vmdkError(pImage, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: monolithic image may only have one extent in '%s'"), pImage->pszFilename);
    16891689    }
    16901690
    … …  
    17191719        }
    17201720        else
    1721             return vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
     1721            return vmdkError(pImage, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
    17221722        if (*pszLine++ != ' ')
    1723             return vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
     1723            return vmdkError(pImage, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
    17241724
    17251725        /* Nominal size of the extent. */
    … …  
    17271727                             &pImage->pExtents[i].cNominalSectors);
    17281728        if (RT_FAILURE(rc))
    1729             return vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
     1729            return vmdkError(pImage, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
    17301730        if (*pszLine++ != ' ')
    1731             return vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
     1731            return vmdkError(pImage, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
    17321732
    17331733        /* Type of the extent. */
    … …  
    17531753        }
    17541754        else
    1755             return vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
     1755            return vmdkError(pImage, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
    17561756        if (pImage->pExtents[i].enmType == VMDKETYPE_ZERO)
    17571757        {
    … …  
    17601760                pszLine++;
    17611761            if (*pszLine != '\0')
    1762                 return vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
     1762                return vmdkError(pImage, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
    17631763            pImage->pExtents[i].pszBasename = NULL;
    17641764        }
    … …  
    17671767            /* All other extent types have basename and optional offset. */
    17681768            if (*pszLine++ != ' ')
    1769                 return vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
     1769                return vmdkError(pImage, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
    17701770
    17711771            /* Basename of the image. Surrounded by quotes. */
    … …  
    17841784                                         &pImage->pExtents[i].uSectorOffset);
    17851785                    if (RT_FAILURE(rc))
    1786                         return vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
     1786                        return vmdkError(pImage, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
    17871787                }
    17881788            }
    17891789
    17901790            if (*pszLine != '\0')
    1791                 return vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
     1791                return vmdkError(pImage, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
    17921792        }
    17931793    }
    … …  
    17971797                           VMDK_DDB_GEO_PCHS_CYLINDERS,
    17981798                           &pImage->PCHSGeometry.cCylinders);
    1799     if (rc == VERR_VDI_VALUE_NOT_FOUND)
     1799    if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
    18001800        pImage->PCHSGeometry.cCylinders = 0;
    18011801    else if (RT_FAILURE(rc))
    … …  
    18041804                           VMDK_DDB_GEO_PCHS_HEADS,
    18051805                           &pImage->PCHSGeometry.cHeads);
    1806     if (rc == VERR_VDI_VALUE_NOT_FOUND)
     1806    if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
    18071807        pImage->PCHSGeometry.cHeads = 0;
    18081808    else if (RT_FAILURE(rc))
    … …  
    18111811                           VMDK_DDB_GEO_PCHS_SECTORS,
    18121812                           &pImage->PCHSGeometry.cSectors);
    1813     if (rc == VERR_VDI_VALUE_NOT_FOUND)
     1813    if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
    18141814        pImage->PCHSGeometry.cSectors = 0;
    18151815    else if (RT_FAILURE(rc))
    … …  
    18321832                           VMDK_DDB_GEO_LCHS_CYLINDERS,
    18331833                           &pImage->LCHSGeometry.cCylinders);
    1834     if (rc == VERR_VDI_VALUE_NOT_FOUND)
     1834    if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
    18351835        pImage->LCHSGeometry.cCylinders = 0;
    18361836    else if (RT_FAILURE(rc))
    … …  
    18391839                           VMDK_DDB_GEO_LCHS_HEADS,
    18401840                           &pImage->LCHSGeometry.cHeads);
    1841     if (rc == VERR_VDI_VALUE_NOT_FOUND)
     1841    if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
    18421842        pImage->LCHSGeometry.cHeads = 0;
    18431843    else if (RT_FAILURE(rc))
    … …  
    18461846                           VMDK_DDB_GEO_LCHS_SECTORS,
    18471847                           &pImage->LCHSGeometry.cSectors);
    1848     if (rc == VERR_VDI_VALUE_NOT_FOUND)
     1848    if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
    18491849        pImage->LCHSGeometry.cSectors = 0;
    18501850    else if (RT_FAILURE(rc))
    … …  
    18621862    rc = vmdkDescDDBGetUuid(pImage, &pImage->Descriptor, VMDK_DDB_IMAGE_UUID,
    18631863                            &pImage->ImageUuid);
    1864     if (rc == VERR_VDI_VALUE_NOT_FOUND)
     1864    if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
    18651865    {
    18661866        /* Image without UUID. Probably created by VMware and not yet used
    … …  
    18871887                            VMDK_DDB_MODIFICATION_UUID,
    18881888                            &pImage->ModificationUuid);
    1889     if (rc == VERR_VDI_VALUE_NOT_FOUND)
     1889    if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
    18901890    {
    18911891        /* Image without UUID. Probably created by VMware and not yet used
    … …  
    19121912    rc = vmdkDescDDBGetUuid(pImage, &pImage->Descriptor, VMDK_DDB_PARENT_UUID,
    19131913                            &pImage->ParentUuid);
    1914     if (rc == VERR_VDI_VALUE_NOT_FOUND)
     1914    if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
    19151915    {
    19161916        /* Image without UUID. Probably created by VMware and not yet used
    … …  
    19371937                            VMDK_DDB_PARENT_MODIFICATION_UUID,
    19381938                            &pImage->ParentModificationUuid);
    1939     if (rc == VERR_VDI_VALUE_NOT_FOUND)
     1939    if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
    19401940    {
    19411941        /* Image without UUID. Probably created by VMware and not yet used
    … …  
    20402040        goto out;
    20412041    }
    2042     if (    RT_LE2H_U32(Header.magicNumber) != VMDK_SPARSE_MAGICNUMBER
    2043         ||  RT_LE2H_U32(Header.version) != 1)
    2044     {
    2045         rc = vmdkError(pExtent->pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: incorrect magic/version in extent header in '%s'"), pExtent->pszFullname);
     2042    if (RT_LE2H_U32(Header.magicNumber) != VMDK_SPARSE_MAGICNUMBER)
     2043    {
     2044        rc = vmdkError(pExtent->pImage, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: incorrect magic in sparse extent header in '%s'"), pExtent->pszFullname);
     2045        goto out;
     2046    }
     2047    if (RT_LE2H_U32(Header.version) != 1)
     2048    {
     2049        rc = vmdkError(pExtent->pImage, VERR_VD_VMDK_UNSUPPORTED_VERSION, RT_SRC_POS, N_("VMDK: incorrect version in sparse extent header in '%s', not a VMDK 1.0 conforming file"), pExtent->pszFullname);
    20462050        goto out;
    20472051    }
    … …  
    20522056             || Header.doubleEndLineChar2 != '\n') )
    20532057    {
    2054         rc = vmdkError(pExtent->pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: corrupted by CR/LF translation in '%s'"), pExtent->pszFullname);
     2058        rc = vmdkError(pExtent->pImage, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: corrupted by CR/LF translation in '%s'"), pExtent->pszFullname);
    20552059        goto out;
    20562060    }
    … …  
    20622066    if (pExtent->uDescriptorSector && !pExtent->cDescriptorSectors)
    20632067    {
    2064         rc = vmdkError(pExtent->pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: inconsistent embedded descriptor config in '%s'"), pExtent->pszFullname);
     2068        rc = vmdkError(pExtent->pImage, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: inconsistent embedded descriptor config in '%s'"), pExtent->pszFullname);
    20652069        goto out;
    20662070    }
    … …  
    20832087    if (!cSectorsPerGDE || cSectorsPerGDE > UINT32_MAX)
    20842088    {
    2085         rc = vmdkError(pExtent->pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: incorrect grain directory size in '%s'"), pExtent->pszFullname);
     2089        rc = vmdkError(pExtent->pImage, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: incorrect grain directory size in '%s'"), pExtent->pszFullname);
    20862090        goto out;
    20872091    }
    … …  
    21312135        &&  (pExtent->enmType != VMDKETYPE_FLAT || pExtent->cNominalSectors + pExtent->uSectorOffset > VMDK_BYTE2SECTOR(cbExtentSize)))
    21322136    {
    2133         rc = vmdkError(pExtent->pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: file size is not a multiple of 512 in '%s', file is truncated or otherwise garbled"), pExtent->pszFullname);
     2137        rc = vmdkError(pExtent->pImage, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: file size is not a multiple of 512 in '%s', file is truncated or otherwise garbled"), pExtent->pszFullname);
    21342138        goto out;
    21352139    }
    … …  
    21432147        ||  pExtent->cSectorsPerGrain < 8)
    21442148    {
    2145         rc = vmdkError(pExtent->pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: invalid extent grain size %u in '%s'"), pExtent->cSectorsPerGrain, pExtent->pszFullname);
     2149        rc = vmdkError(pExtent->pImage, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: invalid extent grain size %u in '%s'"), pExtent->cSectorsPerGrain, pExtent->pszFullname);
    21462150        goto out;
    21472151    }
    … …  
    21522156        ||  pExtent->cGTEntries < VMDK_GT_CACHELINE_SIZE)
    21532157    {
    2154         rc = vmdkError(pExtent->pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: grain table cache size problem in '%s'"), pExtent->pszFullname);
     2158        rc = vmdkError(pExtent->pImage, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: grain table cache size problem in '%s'"), pExtent->pszFullname);
    21552159        goto out;
    21562160    }
    … …  
    22262230        ||  RT_LE2H_U32(Header.flags) != 3)
    22272231    {
    2228         rc = VERR_VDI_INVALID_HEADER;
     2232        rc = VERR_VD_VMDK_INVALID_HEADER;
    22292233        goto out;
    22302234    }
    … …  
    22382242        ||  pExtent->cSectorsPerGrain > 2048)
    22392243    {
    2240         rc = VERR_VDI_INVALID_HEADER;
     2244        rc = VERR_VD_VMDK_INVALID_HEADER;
    22412245        goto out;
    22422246    }
    … …  
    22502254    if (!cSectorsPerGDE || cSectorsPerGDE > UINT32_MAX)
    22512255    {
    2252         rc = VERR_VDI_INVALID_HEADER;
     2256        rc = VERR_VD_VMDK_INVALID_HEADER;
    22532257        goto out;
    22542258    }
    … …  
    22592263        /* Inconsistency detected. Computed number of GD entries doesn't match
    22602264         * stored value. Better be safe than sorry. */
    2261         rc = VERR_VDI_INVALID_HEADER;
     2265        rc = VERR_VD_VMDK_INVALID_HEADER;
    22622266        goto out;
    22632267    }
    … …  
    24442448        if (!pExtent->uDescriptorSector || !pExtent->cDescriptorSectors)
    24452449        {
    2446             rc = vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: monolithic image without descriptor in '%s'"), pImage->pszFilename);
     2450            rc = vmdkError(pImage, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: monolithic image without descriptor in '%s'"), pImage->pszFilename);
    24472451            goto out;
    24482452        }
    … …  
    25032507            /* Likely the read is truncated. Better fail a bit too early
    25042508             * (normally the descriptor is much smaller than our buffer). */
    2505             rc = vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: cannot read descriptor in '%s'"), pImage->pszFilename);
     2509            rc = vmdkError(pImage, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: cannot read descriptor in '%s'"), pImage->pszFilename);
    25062510            goto out;
    25072511        }
    … …  
    36123616         * ever happen on a valid extent. */
    36133617        if (uGTSector > UINT32_MAX)
    3614             return VERR_VDI_INVALID_HEADER;
     3618            return VERR_VD_VMDK_INVALID_HEADER;
    36153619        /* Write grain table by writing the required number of grain table
    36163620         * cache chunks. Avoids dynamic memory allocation, but is a bit
    … …  
    36303634        if (pExtent->pRGD)
    36313635        {
    3632             AssertReturn(!uRGTSector, VERR_VDI_INVALID_HEADER);
     3636            AssertReturn(!uRGTSector, VERR_VD_VMDK_INVALID_HEADER);
    36333637            rc = vmdkFileGetSize(pExtent->pFile, &cbExtentSize);
    36343638            if (RT_FAILURE(rc))
    … …  
    36403644             * this shouldn't ever happen on a valid extent. */
    36413645            if (uRGTSector > UINT32_MAX)
    3642                 return VERR_VDI_INVALID_HEADER;
     3646                return VERR_VD_VMDK_INVALID_HEADER;
    36433647            /* Write backup grain table by writing the required number of grain
    36443648             * table cache chunks. Avoids dynamic memory allocation, but is a
    … …  
    42594263    if (pExtent->enmAccess == VMDKACCESS_NOACCESS)
    42604264    {
    4261         rc = VERR_VDI_INVALID_STATE;
     4265        rc = VERR_VD_VMDK_INVALID_STATE;
    42624266        goto out;
    42634267    }
    … …  
    42814285            Assert(!(cbToRead % 512));
    42824286            if (uSectorExtentAbs == 0)
    4283                 rc = VERR_VDI_BLOCK_FREE;
     4287                rc = VERR_VD_BLOCK_FREE;
    42844288            else
    42854289                rc = vmdkFileReadAt(pExtent->pFile,
    … …  
    43224326    if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
    43234327    {
    4324         rc = VERR_VDI_IMAGE_READ_ONLY;
     4328        rc = VERR_VD_IMAGE_READ_ONLY;
    43254329        goto out;
    43264330    }
    … …  
    43474351    if (pExtent->enmAccess != VMDKACCESS_READWRITE)
    43484352    {
    4349         rc = VERR_VDI_INVALID_STATE;
     4353        rc = VERR_VD_VMDK_INVALID_STATE;
    43504354        goto out;
    43514355    }
    … …  
    43774381                    }
    43784382                    else
    4379                         rc = VERR_VDI_BLOCK_FREE;
     4383                        rc = VERR_VD_BLOCK_FREE;
    43804384                    *pcbPreRead = 0;
    43814385                    *pcbPostRead = 0;
    … …  
    43874391                    *pcbPreRead = VMDK_SECTOR2BYTE(uSectorExtentRel % pExtent->cSectorsPerGrain);
    43884392                    *pcbPostRead = VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain) - cbToWrite - *pcbPreRead;
    4389                     rc = VERR_VDI_BLOCK_FREE;
     4393                    rc = VERR_VD_BLOCK_FREE;
    43904394                }
    43914395            }
    … …  
    44564460        *penmImageType = pImage->enmImageType;
    44574461    else
    4458         rc = VERR_VDI_NOT_OPENED;
     4462        rc = VERR_VD_NOT_OPENED;
    44594463
    44604464    LogFlowFunc(("returns %Rrc enmImageType=%u\n", rc, *penmImageType));
    … …  
    45274531        }
    45284532        else
    4529             rc = VERR_VDI_GEOMETRY_NOT_SET;
     4533            rc = VERR_VD_GEOMETRY_NOT_SET;
    45304534    }
    45314535    else
    4532         rc = VERR_VDI_NOT_OPENED;
     4536        rc = VERR_VD_NOT_OPENED;
    45334537
    45344538    LogFlowFunc(("returns %Rrc (PCHS=%u/%u/%u)\n", rc, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
    … …  
    45504554        if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
    45514555        {
    4552             rc = VERR_VDI_IMAGE_READ_ONLY;
     4556            rc = VERR_VD_IMAGE_READ_ONLY;
    45534557            goto out;
    45544558        }
    … …  
    45614565    }
    45624566    else
    4563         rc = VERR_VDI_NOT_OPENED;
     4567        rc = VERR_VD_NOT_OPENED;
    45644568
    45654569out:
    … …  
    45864590        }
    45874591        else
    4588             rc = VERR_VDI_GEOMETRY_NOT_SET;
     4592            rc = VERR_VD_GEOMETRY_NOT_SET;
    45894593    }
    45904594    else
    4591         rc = VERR_VDI_NOT_OPENED;
     4595        rc = VERR_VD_NOT_OPENED;
    45924596
    45934597    LogFlowFunc(("returns %Rrc (LCHS=%u/%u/%u)\n", rc, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
    … …  
    46094613        if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
    46104614        {
    4611             rc = VERR_VDI_IMAGE_READ_ONLY;
     4615            rc = VERR_VD_IMAGE_READ_ONLY;
    46124616            goto out;
    46134617        }
    … …  
    46204624    }
    46214625    else
    4622         rc = VERR_VDI_NOT_OPENED;
     4626        rc = VERR_VD_NOT_OPENED;
    46234627
    46244628out:
    … …  
    47024706        rc = vmdkDescDDBGetStr(pImage, &pImage->Descriptor,
    47034707                              "ddb.comment", &pszCommentEncoded);
    4704         if (rc == VERR_VDI_VALUE_NOT_FOUND)
     4708        if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
    47054709            pszCommentEncoded = NULL;
    47064710        else if (RT_FAILURE(rc))
    … …  
    47154719    }
    47164720    else
    4717         rc = VERR_VDI_NOT_OPENED;
     4721        rc = VERR_VD_NOT_OPENED;
    47184722
    47194723out:
    … …  
    47334737    if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
    47344738    {
    4735         rc = VERR_VDI_IMAGE_READ_ONLY;
     4739        rc = VERR_VD_IMAGE_READ_ONLY;
    47364740        goto out;
    47374741    }
    … …  
    47404744        rc = vmdkSetImageComment(pImage, pszComment);
    47414745    else
    4742         rc = VERR_VDI_NOT_OPENED;
     4746        rc = VERR_VD_NOT_OPENED;
    47434747
    47444748out:
    … …  
    47624766    }
    47634767    else
    4764         rc = VERR_VDI_NOT_OPENED;
     4768        rc = VERR_VD_NOT_OPENED;
    47654769
    47664770    LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
    … …  
    47904794        }
    47914795        else
    4792             rc = VERR_VDI_IMAGE_READ_ONLY;
     4796            rc = VERR_VD_IMAGE_READ_ONLY;
    47934797    }
    47944798    else
    4795         rc = VERR_VDI_NOT_OPENED;
     4799        rc = VERR_VD_NOT_OPENED;
    47964800
    47974801    LogFlowFunc(("returns %Rrc\n", rc));
    … …  
    48144818    }
    48154819    else
    4816         rc = VERR_VDI_NOT_OPENED;
     4820        rc = VERR_VD_NOT_OPENED;
    48174821
    48184822    LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
    … …  
    48414845        }
    48424846        else
    4843             rc = VERR_VDI_IMAGE_READ_ONLY;
     4847            rc = VERR_VD_IMAGE_READ_ONLY;
    48444848    }
    48454849    else
    4846         rc = VERR_VDI_NOT_OPENED;
     4850        rc = VERR_VD_NOT_OPENED;
    48474851
    48484852    LogFlowFunc(("returns %Rrc\n", rc));
    … …  
    48654869    }
    48664870    else
    4867         rc = VERR_VDI_NOT_OPENED;
     4871        rc = VERR_VD_NOT_OPENED;
    48684872
    48694873    LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
    … …  
    48924896        }
    48934897        else
    4894             rc = VERR_VDI_IMAGE_READ_ONLY;
     4898            rc = VERR_VD_IMAGE_READ_ONLY;
    48954899    }
    48964900    else
    4897         rc = VERR_VDI_NOT_OPENED;
     4901        rc = VERR_VD_NOT_OPENED;
    48984902
    48994903    LogFlowFunc(("returns %Rrc\n", rc));
    … …  
    49164920    }
    49174921    else
    4918         rc = VERR_VDI_NOT_OPENED;
     4922        rc = VERR_VD_NOT_OPENED;
    49194923
    49204924    LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
    … …  
    49434947        }
    49444948        else
    4945             rc = VERR_VDI_IMAGE_READ_ONLY;
     4949            rc = VERR_VD_IMAGE_READ_ONLY;
    49464950    }
    49474951    else
    4948         rc = VERR_VDI_NOT_OPENED;
     4952        rc = VERR_VD_NOT_OPENED;
    49494953
    49504954    LogFlowFunc(("returns %Rrc\n", rc));
    … …  
    50655069        if (pExtent->enmAccess == VMDKACCESS_NOACCESS)
    50665070        {
    5067             rc = VERR_VDI_INVALID_STATE;
     5071            rc = VERR_VD_VMDK_INVALID_STATE;
    50685072            goto out;
    50695073        }
    … …  
    51495153    {
    51505154        /* The request was completely in a ZERO extent nothing to do. */
    5151         rc = VINF_VDI_ASYNC_IO_FINISHED;
     5155        rc = VINF_VD_ASYNC_IO_FINISHED;
    51525156    }
    51535157    else
    … …  
    52015205        if (pExtent->enmAccess == VMDKACCESS_NOACCESS)
    52025206        {
    5203             rc = VERR_VDI_INVALID_STATE;
     5207            rc = VERR_VD_VMDK_INVALID_STATE;
    52045208            goto out;
    52055209        }
    … …  
    52855289    {
    52865290        /* The request was completely in a ZERO extent nothing to do. */
    5287         rc = VINF_VDI_ASYNC_IO_FINISHED;
     5291        rc = VINF_VD_ASYNC_IO_FINISHED;
    52885292    }
    52895293    else

  • trunk/src/VBox/Devices/Storage/testcase/Makefile.kmk

    r14787 r15366  
    2727# probably will go away soon. Testcase only now.
    2828#
    29 ifdef VBOX_WITH_TESTCASES
    30  PROGRAMS += vditool
    31  ifeq ($(KBUILD_TARGET),l4)
    32   vditool_TEMPLATE = VBOXLNXHOSTR3EXE
    33   vditool_LIBS     = \
    34         $(PATH_LIB)/VBoxDDULnxHostR3.a \
    35         $(PATH_LIB)/RuntimeLnxHostR3.a
    36  else
    37   vditool_TEMPLATE = VBOXR3TSTEXE
    38   vditool_LIBS     = $(LIB_DDU) $(LIB_RUNTIME)
    39  endif
    40  vditool_SOURCES   = vditool.cpp
    41 endif
     29#ifdef VBOX_WITH_TESTCASES
     30# PROGRAMS += vditool
     31# ifeq ($(KBUILD_TARGET),l4)
     32#  vditool_TEMPLATE = VBOXLNXHOSTR3EXE
     33#  vditool_LIBS     = \
     34#       $(PATH_LIB)/VBoxDDULnxHostR3.a \
     35#       $(PATH_LIB)/RuntimeLnxHostR3.a
     36# else
     37#  vditool_TEMPLATE = VBOXR3TSTEXE
     38#  vditool_LIBS     = $(LIB_DDU) $(LIB_RUNTIME)
     39# endif
     40# vditool_SOURCES   = vditool.cpp
     41#endif
    4242
    4343
    … …  
    4545# Basic testcase for the VDI code.
    4646#
    47 ifdef VBOX_WITH_TESTCASES
    48  PROGRAMS += tstVDI
    49  ifeq ($(KBUILD_TARGET),l4)
    50   tstVDI_TEMPLATE = VBOXLNXHOSTR3EXE
    51  else
    52   tstVDI_TEMPLATE = VBOXR3TSTEXE
    53  endif
    54  tstVDI_LIBS     = $(vditool_LIBS)
    55  tstVDI_SOURCES  = tstVDI.cpp
    56 endif
     47#ifdef VBOX_WITH_TESTCASES
     48# PROGRAMS += tstVDI
     49# ifeq ($(KBUILD_TARGET),l4)
     50#  tstVDI_TEMPLATE = VBOXLNXHOSTR3EXE
     51# else
     52#  tstVDI_TEMPLATE = VBOXR3TSTEXE
     53# endif
     54# tstVDI_LIBS     = $(vditool_LIBS)
     55# tstVDI_SOURCES  = tstVDI.cpp
     56#endif
    5757
    5858#
    … …  
    6868  tstVD-2_TEMPLATE = VBOXR3TSTEXE
    6969 endif
    70  tstVD_LIBS     = $(vditool_LIBS)
    71  tstVD-2_LIBS     = $(vditool_LIBS)
     70 tstVD_LIBS     = $(LIB_DDU) $(LIB_RUNTIME)
     71 tstVD-2_LIBS   = $(LIB_DDU) $(LIB_RUNTIME)
    7272 tstVD_SOURCES  = tstVD.cpp
    7373 tstVD-2_SOURCES  = tstVD-2.cpp
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