~ubuntu-branches/ubuntu/oneiric/virtualbox/oneiric-updates

/* $Id: VD.cpp 38449 2011-08-14 10:53:13Z vboxsync $ */

 * Extended version of vdReadHelper(), implementing certain optimizations

 * for image cloning.

 *

 * @returns VBox status code.

 * @param   pDisk                   The disk to read from.

 * @param   pImage                  The image to start reading from.

 * @param   pImageParentOverride    The parent image to read from

 *                                  if the starting image returns a free block.

 *                                  If NULL is passed the real parent of the image

 *                                  in the chain is used.

 * @param   uOffset                 Offset in the disk to start reading from.

 * @param   pvBuf                   Where to store the read data.

 * @param   cbRead                  How much to read.

 * @param   fZeroFreeBlocks         Flag whether free blocks should be zeroed.

 *                                  If false and no image has data for sepcified

 *                                  range VERR_VD_BLOCK_FREE is returned.

 *                                  Note that unallocated blocks are still zeroed

 *                                  if at least one image has valid data for a part

 *                                  of the range.

 * @param   fUpdateCache            Flag whether to update the attached cache if

 *                                  available.

 * @param   cImagesRead             Number of images in the chain to read until

 *                                  the read is cut off. A value of 0 disables the cut off.

static int vdReadHelperEx(PVBOXHDD pDisk, PVDIMAGE pImage, PVDIMAGE pImageParentOverride,

                          uint64_t uOffset, void *pvBuf, size_t cbRead,

                          bool fZeroFreeBlocks, bool fUpdateCache, unsigned cImagesRead)

                rc = vdDiskReadHelper(pDisk, pImage, NULL, uOffset, pvBuf, cbThisRead,

                                      &cbThisRead);

            if (   rc == VERR_VD_BLOCK_FREE

                && cImagesRead != 1)

                unsigned cImagesToProcess = cImagesRead;

 

                    if (cImagesToProcess == 1)

                        break;

                    else if (cImagesToProcess > 0)

                        cImagesToProcess--;

/**

 * internal: read the specified amount of data in whatever blocks the backend

 * will give us.

 */

static int vdReadHelper(PVBOXHDD pDisk, PVDIMAGE pImage, uint64_t uOffset,

                        void *pvBuf, size_t cbRead, bool fUpdateCache)

{

    return vdReadHelperEx(pDisk, pImage, NULL, uOffset, pvBuf, cbRead,

                          true /* fZeroFreeBlocks */, fUpdateCache, 0);

}

 

    return vdReadHelper(pParentState->pDisk, pParentState->pImage, uOffset,

                        pvBuf, cbRead, false /* fUpdateCache */);

        rc = vdReadHelperEx(pDisk, pImage, pImageParentOverride,

                            uOffset - cbPreRead, pvTmp, cbPreRead,

                            true /* fZeroFreeBlocks*/,

                            false /* fUpdateCache */, 0);

            rc = vdReadHelperEx(pDisk, pImage, pImageParentOverride,

                                uOffset + cbThisWrite + cbWriteCopy,

                                (char *)pvTmp + cbPreRead + cbThisWrite + cbWriteCopy,

                                cbReadImage, true /* fZeroFreeBlocks */,

                                false /* fUpdateCache */, 0);

                                  void *pvTmp, unsigned cImagesRead)

    rc = vdReadHelperEx(pDisk, pImage, pImageParentOverride, uOffset - cbPreRead, pvTmp,

                        cbPreRead + cbThisWrite + cbPostRead - cbFill,

                        true /* fZeroFreeBlocks */, false /* fUpdateCache */,

                        cImagesRead);

static int vdWriteHelperEx(PVBOXHDD pDisk, PVDIMAGE pImage,

                           PVDIMAGE pImageParentOverride, uint64_t uOffset,

                           const void *pvBuf, size_t cbWrite,

                           bool fUpdateCache, unsigned cImagesRead)

                                            pcvBufCur, pvTmp, cImagesRead);

 * internal: write buffer to the image, taking care of block boundaries and

 * write optimizations.

 */

static int vdWriteHelper(PVBOXHDD pDisk, PVDIMAGE pImage, uint64_t uOffset,

                         const void *pvBuf, size_t cbWrite, bool fUpdateCache)

{

    return vdWriteHelperEx(pDisk, pImage, NULL, uOffset, pvBuf, cbWrite,

                           fUpdateCache, 0);

}

 

/**

 * Internal: Copies the content of one disk to another one applying optimizations

 * to speed up the copy process if possible.

 */

static int vdCopyHelper(PVBOXHDD pDiskFrom, PVDIMAGE pImageFrom, PVBOXHDD pDiskTo,

                        uint64_t cbSize, unsigned cImagesFromRead, unsigned cImagesToRead,

                        bool fSuppressRedundantIo,

                        PVDINTERFACE pIfProgress, PVDINTERFACEPROGRESS pCbProgress,

                        PVDINTERFACE pDstIfProgress, PVDINTERFACEPROGRESS pDstCbProgress)

{

    int rc = VINF_SUCCESS;

    int rc2;

    uint64_t uOffset = 0;

    uint64_t cbRemaining = cbSize;

    void *pvBuf = NULL;

    bool fLockReadFrom = false;

    bool fLockWriteTo = false;

    bool fBlockwiseCopy = fSuppressRedundantIo || (cImagesFromRead > 0);

    unsigned uProgressOld = 0;

 

    LogFlowFunc(("pDiskFrom=%#p pImageFrom=%#p pDiskTo=%#p cbSize=%llu cImagesFromRead=%u cImagesToRead=%u fSuppressRedundantIo=%RTbool pIfProgress=%#p pCbProgress=%#p pDstIfProgress=%#p pDstCbProgress=%#p\n",

                 pDiskFrom, pImageFrom, pDiskTo, cbSize, cImagesFromRead, cImagesToRead, fSuppressRedundantIo, pIfProgress, pCbProgress, pDstIfProgress, pDstCbProgress));

 

    /* Allocate tmp buffer. */

    pvBuf = RTMemTmpAlloc(VD_MERGE_BUFFER_SIZE);

    if (!pvBuf)

        return rc;

 

    do

    {

        size_t cbThisRead = RT_MIN(VD_MERGE_BUFFER_SIZE, cbRemaining);

 

        /* Note that we don't attempt to synchronize cross-disk accesses.

         * It wouldn't be very difficult to do, just the lock order would

         * need to be defined somehow to prevent deadlocks. Postpone such

         * magic as there is no use case for this. */

 

        rc2 = vdThreadStartRead(pDiskFrom);

        AssertRC(rc2);

        fLockReadFrom = true;

 

        if (fBlockwiseCopy)

        {

            /* Read the source data. */

            rc = pImageFrom->Backend->pfnRead(pImageFrom->pBackendData,

                                              uOffset, pvBuf, cbThisRead,

                                              &cbThisRead);

 

            if (   rc == VERR_VD_BLOCK_FREE

                && cImagesFromRead != 1)

            {

                unsigned cImagesToProcess = cImagesFromRead;

 

                for (PVDIMAGE pCurrImage = pImageFrom->pPrev;

                     pCurrImage != NULL && rc == VERR_VD_BLOCK_FREE;

                     pCurrImage = pCurrImage->pPrev)

                {

                    rc = pCurrImage->Backend->pfnRead(pCurrImage->pBackendData,

                                                      uOffset, pvBuf, cbThisRead,

                                                      &cbThisRead);

                    if (cImagesToProcess == 1)

                        break;

                    else if (cImagesToProcess > 0)

                        cImagesToProcess--;

                }

            }

        }

        else

            rc = vdReadHelper(pDiskFrom, pImageFrom, uOffset, pvBuf, cbThisRead,

                              false /* fUpdateCache */);

 

        if (RT_FAILURE(rc) && rc != VERR_VD_BLOCK_FREE)

            break;

 

        rc2 = vdThreadFinishRead(pDiskFrom);

        AssertRC(rc2);

        fLockReadFrom = false;

 

        if (rc != VERR_VD_BLOCK_FREE)

        {

            rc2 = vdThreadStartWrite(pDiskTo);

            AssertRC(rc2);

            fLockWriteTo = true;

 

            /* Only do collapsed I/O if we are copying the data blockwise. */

            rc = vdWriteHelperEx(pDiskTo, pDiskTo->pLast, NULL, uOffset, pvBuf,

                                 cbThisRead, false /* fUpdateCache */,

                                 fBlockwiseCopy ? cImagesToRead : 0);

            if (RT_FAILURE(rc))

                break;

 

            rc2 = vdThreadFinishWrite(pDiskTo);

            AssertRC(rc2);

            fLockWriteTo = false;

        }

        else /* Don't propagate the error to the outside */

            rc = VINF_SUCCESS;

 

        uOffset += cbThisRead;

        cbRemaining -= cbThisRead;

 

        unsigned uProgressNew = uOffset * 99 / cbSize;

        if (uProgressNew != uProgressOld)

        {

            uProgressOld = uProgressNew;

 

            if (pCbProgress && pCbProgress->pfnProgress)

            {

                rc = pCbProgress->pfnProgress(pIfProgress->pvUser,

                                              uProgressOld);

                if (RT_FAILURE(rc))

                    break;

            }

            if (pDstCbProgress && pDstCbProgress->pfnProgress)

            {

                rc = pDstCbProgress->pfnProgress(pDstIfProgress->pvUser,

                                                 uProgressOld);

                if (RT_FAILURE(rc))

                    break;

            }

        }

    } while (uOffset < cbSize);

 

    RTMemFree(pvBuf);

 

    if (fLockReadFrom)

    {

        rc2 = vdThreadFinishRead(pDiskFrom);

        AssertRC(rc2);

    }

 

    if (fLockWriteTo)

    {

        rc2 = vdThreadFinishWrite(pDiskTo);

        AssertRC(rc2);

    }

 

    LogFlowFunc(("returns rc=%Rrc\n", rc));

    return rc;

}

 

/**

    VD_THREAD_IS_CRITSECT_OWNER(pDisk);

 

 

                    RTCritSectEnter(&pDisk->CritSect);

                        rc = vdWriteHelperEx(pDisk, pImageTo, pImageFrom->pPrev,

                                             uOffset, pvBuf, cbThisRead,

                                             true /* fUpdateCache */, 0);

                    rc = vdWriteHelper(pDisk, pImageTo, uOffset, pvBuf,

 * Copies an image from one HDD container to another - extended version.

 * @note The read/write accesses across disks are not synchronized, just the

 * accesses to each disk. Once there is a use case which requires a defined

 * read/write behavior in this situation this needs to be extended.

 *

 * @return  VBox status code.

 * @return  VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.

 * @param   pszBackend      Name of the image file backend to use (may be NULL to use the same as the source, case insensitive).

 * @param   pszFilename     New name of the image (may be NULL to specify that the

 *                          copy destination is the destination container, or

 *                          if pDiskFrom == pDiskTo, i.e. when moving).

 * @param   nImageSameFrom  todo

 * @param   nImageSameTo    todo

 *                          In all rename/move cases or copy to existing image cases the modification UUIDs are copied over.

 * @param   pDstVDIfsOperation Pointer to the per-operation VD interface list,

 *                          for the destination operation.

VBOXDDU_DECL(int) VDCopyEx(PVBOXHDD pDiskFrom, unsigned nImage, PVBOXHDD pDiskTo,

                           const char *pszBackend, const char *pszFilename,

                           bool fMoveByRename, uint64_t cbSize,

                           unsigned nImageFromSame, unsigned nImageToSame,

                           unsigned uImageFlags, PCRTUUID pDstUuid,

                           unsigned uOpenFlags, PVDINTERFACE pVDIfsOperation,

                           PVDINTERFACE pDstVDIfsImage,

                           PVDINTERFACE pDstVDIfsOperation)

    LogFlowFunc(("pDiskFrom=%#p nImage=%u pDiskTo=%#p pszBackend=\"%s\" pszFilename=\"%s\" fMoveByRename=%d cbSize=%llu nImageFromSame=%u nImageToSame=%u uImageFlags=%#x pDstUuid=%#p uOpenFlags=%#x pVDIfsOperation=%#p pDstVDIfsImage=%#p pDstVDIfsOperation=%#p\n",

                 pDiskFrom, nImage, pDiskTo, pszBackend, pszFilename, fMoveByRename, cbSize, nImageFromSame, nImageToSame, uImageFlags, pDstUuid, uOpenFlags, pVDIfsOperation, pDstVDIfsImage, pDstVDIfsOperation));

        AssertMsgBreakStmt(   (nImageFromSame < nImage || nImageFromSame == VD_IMAGE_CONTENT_UNKNOWN)

                           && (nImageToSame < pDiskTo->cImages || nImageToSame == VD_IMAGE_CONTENT_UNKNOWN)

                           && (   (nImageFromSame == VD_IMAGE_CONTENT_UNKNOWN && nImageToSame == VD_IMAGE_CONTENT_UNKNOWN)

                               || (nImageFromSame != VD_IMAGE_CONTENT_UNKNOWN && nImageToSame != VD_IMAGE_CONTENT_UNKNOWN)),

                           ("nImageFromSame=%u nImageToSame=%u\n", nImageFromSame, nImageToSame),

                           rc = VERR_INVALID_PARAMETER);

        bool fSuppressRedundantIo = (   !(pszFilename == NULL || cImagesTo > 0)

                                     || (nImageToSame != VD_IMAGE_CONTENT_UNKNOWN));

        unsigned cImagesFromReadBack, cImagesToReadBack;

 

        if (nImageFromSame == VD_IMAGE_CONTENT_UNKNOWN)

            cImagesFromReadBack = 0;

        else

        {

            if (nImage == VD_LAST_IMAGE)

                cImagesFromReadBack = pDiskFrom->cImages - nImageFromSame - 1;

            else

                cImagesFromReadBack = nImage - nImageFromSame;

        }

 

        if (nImageToSame == VD_IMAGE_CONTENT_UNKNOWN)

            cImagesToReadBack = 0;

        else

            cImagesToReadBack = pDiskTo->cImages - nImageToSame - 1;

        rc = vdCopyHelper(pDiskFrom, pImageFrom, pDiskTo, cbSize,

                          cImagesFromReadBack, cImagesToReadBack,

                          fSuppressRedundantIo, pIfProgress, pCbProgress,

                          pDstIfProgress, pDstCbProgress);

 * Copies an image from one HDD container to another.

 * The copy is opened in the target HDD container.

 * It is possible to convert between different image formats, because the

 * backend for the destination may be different from the source.

 * If both the source and destination reference the same HDD container,

 * then the image is moved (by copying/deleting or renaming) to the new location.

 * The source container is unchanged if the move operation fails, otherwise

 * the image at the new location is opened in the same way as the old one was.

 *

 * @returns VBox status code.

 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.

 * @param   pDiskFrom       Pointer to source HDD container.

 * @param   nImage          Image number, counts from 0. 0 is always base image of container.

 * @param   pDiskTo         Pointer to destination HDD container.

 * @param   pszBackend      Name of the image file backend to use.

 * @param   pszFilename     New name of the image (may be NULL if pDiskFrom == pDiskTo).

 * @param   fMoveByRename   If true, attempt to perform a move by renaming (if successful the new size is ignored).

 * @param   cbSize          New image size (0 means leave unchanged).

 * @param   uImageFlags     Flags specifying special destination image features.

 * @param   pDstUuid        New UUID of the destination image. If NULL, a new UUID is created.

 *                          This parameter is used if and only if a true copy is created.

 *                          In all rename/move cases the UUIDs are copied over.

 * @param   uOpenFlags      Image file open mode, see VD_OPEN_FLAGS_* constants.

 *                          Only used if the destination image is created.

 * @param   pVDIfsOperation Pointer to the per-operation VD interface list.

 * @param   pDstVDIfsImage  Pointer to the per-image VD interface list, for the

 *                          destination image.

 * @param   pDstVDIfsOperation Pointer to the per-image VD interface list,

 *                          for the destination image.

 */

VBOXDDU_DECL(int) VDCopy(PVBOXHDD pDiskFrom, unsigned nImage, PVBOXHDD pDiskTo,

                         const char *pszBackend, const char *pszFilename,

                         bool fMoveByRename, uint64_t cbSize,

                         unsigned uImageFlags, PCRTUUID pDstUuid,

                         unsigned uOpenFlags, PVDINTERFACE pVDIfsOperation,

                         PVDINTERFACE pDstVDIfsImage,

                         PVDINTERFACE pDstVDIfsOperation)

{

    return VDCopyEx(pDiskFrom, nImage, pDiskTo, pszBackend, pszFilename, fMoveByRename,

                    cbSize, VD_IMAGE_CONTENT_UNKNOWN, VD_IMAGE_CONTENT_UNKNOWN,

                    uImageFlags, pDstUuid, uOpenFlags, pVDIfsOperation,

                    pDstVDIfsImage, pDstVDIfsOperation);

}

 

/**

        rc = vdReadHelper(pDisk, pImage, uOffset, pvBuf, cbRead,

        rc = vdWriteHelper(pDisk, pImage, uOffset, pvBuf, cbWrite,

            rc = vdWriteHelper(pDisk, pDisk->pImageRelay, uOffset,