VDIHDDCore.cpp revision c1e8287e038e789c1eefcee00a2e63258ca22d48
/** @file
* Virtual Disk Image (VDI), Core Code.
*/
/*
* Copyright (C) 2006-2010 Sun Microsystems, Inc.
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
* Clara, CA 95054 USA or visit http://www.sun.com if you need
* additional information or have any questions.
*/
/*******************************************************************************
* Header Files *
*******************************************************************************/
#define LOG_GROUP LOG_GROUP_VD_VDI
#include <VBox/VBoxHDD-Plugin.h>
#define VBOX_VDICORE_VD /* Signal that the header is included from here. */
#include "VDICore.h"
#define VDI_IMAGE_DEFAULT_BLOCK_SIZE _1M
/*******************************************************************************
* Static Variables *
*******************************************************************************/
/** NULL-terminated array of supported file extensions. */
static const char *const s_apszVdiFileExtensions[] =
{
"vdi",
};
/*******************************************************************************
* Internal Functions *
*******************************************************************************/
static unsigned getPowerOfTwo(unsigned uNumber);
/**
* Internal: signal an error to the frontend.
*/
const char *pszFormat, ...)
{
return rc;
}
{
int rc = VINF_SUCCESS;
#ifndef VBOX_WITH_NEW_IO_CODE
if (fCreate)
fOpen |= RTFILE_O_CREATE;
else
fOpen |= RTFILE_O_OPEN;
#else
if (fCreate)
#endif
return rc;
}
{
int rc = VINF_SUCCESS;
#ifndef VBOX_WITH_NEW_IO_CODE
#else
#endif
return rc;
}
{
int rc = VINF_SUCCESS;
#ifndef VBOX_WITH_NEW_IO_CODE
#else
#endif
return rc;
}
{
int rc = VINF_SUCCESS;
#ifndef VBOX_WITH_NEW_IO_CODE
#else
pcbSize);
#endif
return rc;
}
{
int rc = VINF_SUCCESS;
#ifndef VBOX_WITH_NEW_IO_CODE
#else
cbSize);
#endif
return rc;
}
static int vdiFileWriteSync(PVDIIMAGEDESC pImage, uint64_t off, const void *pcvBuf, size_t cbWrite, size_t *pcbWritten)
{
int rc = VINF_SUCCESS;
#ifndef VBOX_WITH_NEW_IO_CODE
#else
#endif
return rc;
}
static int vdiFileReadSync(PVDIIMAGEDESC pImage, uint64_t off, void *pvBuf, size_t cbRead, size_t *pcbRead)
{
int rc = VINF_SUCCESS;
#ifndef VBOX_WITH_NEW_IO_CODE
#else
pcbRead);
#endif
return rc;
}
{
}
{
}
{
#ifndef VBOX_WITH_NEW_IO_CODE
#else
#endif
}
{
}
/**
* internal: return power of 2 or 0 if num error.
*/
static unsigned getPowerOfTwo(unsigned uNumber)
{
if (uNumber == 0)
return 0;
unsigned uPower2 = 0;
while ((uNumber & 1) == 0)
{
uNumber >>= 1;
uPower2++;
}
}
/**
* Internal: Init VDI preheader.
*/
{
}
/**
* Internal: check VDI preheader.
*/
{
return VERR_VD_VDI_INVALID_HEADER;
return VERR_VD_VDI_UNSUPPORTED_VERSION;
return VINF_SUCCESS;
}
/**
* Internal: translate VD image flags to VDI image type enum.
*/
{
if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
return VDI_IMAGE_TYPE_FIXED;
else if (uImageFlags & VD_IMAGE_FLAGS_DIFF)
return VDI_IMAGE_TYPE_DIFF;
else
return VDI_IMAGE_TYPE_NORMAL;
}
/**
* Internal: translate VDI image type enum to VD image type enum.
*/
{
switch (enmType)
{
case VDI_IMAGE_TYPE_NORMAL:
return VD_IMAGE_FLAGS_NONE;
case VDI_IMAGE_TYPE_FIXED:
return VD_IMAGE_FLAGS_FIXED;
case VDI_IMAGE_TYPE_DIFF:
return VD_IMAGE_FLAGS_DIFF;
default:
return VD_IMAGE_FLAGS_NONE;
}
}
/**
* Internal: Init VDI header. Always use latest header version.
* @param pHeader Assumes it was initially initialized to all zeros.
*/
{
#ifdef VBOX_STRICT
char achZero[VDI_IMAGE_COMMENT_SIZE] = {0};
#endif
if (pszComment)
{
}
/* Mark the legacy geometry not-calculated. */
/* Init offsets. */
pHeader->u.v1.offBlocks = RT_ALIGN_32(sizeof(VDIPREHEADER) + sizeof(VDIHEADER1), VDI_GEOMETRY_SECTOR_SIZE);
pHeader->u.v1.offData = RT_ALIGN_32(pHeader->u.v1.offBlocks + (pHeader->u.v1.cBlocks * sizeof(VDIIMAGEBLOCKPOINTER)), VDI_GEOMETRY_SECTOR_SIZE);
/* Init uuids. */
/* Mark LCHS geometry not-calculated. */
}
/**
* Internal: Check VDI header.
*/
{
/* Check version-dependend header parameters. */
switch (GET_MAJOR_HEADER_VERSION(pHeader))
{
case 0:
{
/* Old header version. */
break;
}
case 1:
{
/* Current header version. */
{
LogRel(("VDI: v1 header size wrong (%d < %d)\n",
return VERR_VD_VDI_INVALID_HEADER;
}
{
LogRel(("VDI: v1 blocks offset wrong (%d < %d)\n",
return VERR_VD_VDI_INVALID_HEADER;
}
if (getImageDataOffset(pHeader) < (getImageBlocksOffset(pHeader) + getImageBlocks(pHeader) * sizeof(VDIIMAGEBLOCKPOINTER)))
{
LogRel(("VDI: v1 image data offset wrong (%d < %d)\n",
getImageDataOffset(pHeader), getImageBlocksOffset(pHeader) + getImageBlocks(pHeader) * sizeof(VDIIMAGEBLOCKPOINTER)));
return VERR_VD_VDI_INVALID_HEADER;
}
break;
}
default:
/* Unsupported. */
return VERR_VD_VDI_UNSUPPORTED_VERSION;
}
/* Check common header parameters. */
bool fFailed = false;
{
fFailed = true;
}
{
fFailed = true;
}
if ( getImageLCHSGeometry(pHeader)
{
LogRel(("VDI: wrong sector size (%d != %d)\n",
fFailed = true;
}
if ( getImageDiskSize(pHeader) == 0
|| getImageBlockSize(pHeader) == 0
|| getImageBlocks(pHeader) == 0
{
LogRel(("VDI: wrong size (%lld, %d, %d, %d)\n",
fFailed = true;
}
{
LogRel(("VDI: too many blocks allocated (%d > %d)\n"
" blocksize=%d disksize=%lld\n",
fFailed = true;
}
if ( getImageExtraBlockSize(pHeader) != 0
{
LogRel(("VDI: wrong extra size (%d, %d)\n",
fFailed = true;
}
{
LogRel(("VDI: wrong disk size (%d, %d, %lld)\n",
fFailed = true;
}
{
LogRel(("VDI: uuid of creator is 0\n"));
fFailed = true;
}
{
LogRel(("VDI: uuid of modificator is 0\n"));
fFailed = true;
}
}
/**
* Internal: Set up VDIIMAGEDESC structure by image header.
*/
{
}
/**
* Internal: Create VDI image file.
*/
unsigned uImageFlags, const char *pszComment,
unsigned uPercentStart, unsigned uPercentSpan)
{
int rc;
/* Special check for comment length. */
if ( VALID_PTR(pszComment)
{
rc = vdiError(pImage, VERR_VD_VDI_COMMENT_TOO_LONG, RT_SRC_POS, N_("VDI: comment is too long for '%s'"), pImage->pszFilename);
goto out;
}
if (pImage->pInterfaceError)
#ifdef VBOX_WITH_NEW_IO_CODE
/* Try to get I/O interface. */
#endif
/* Save PCHS geometry. Not much work, and makes the flow of information
* quite a bit clearer - relying on the higher level isn't obvious. */
/* Set LCHS geometry (legacy geometry is ignored for the current 1.1+). */
pImage->paBlocks = (PVDIIMAGEBLOCKPOINTER)RTMemAlloc(sizeof(VDIIMAGEBLOCKPOINTER) * getImageBlocks(&pImage->Header));
{
rc = VERR_NO_MEMORY;
goto out;
}
if (!(uImageFlags & VD_IMAGE_FLAGS_FIXED))
{
/* for growing images mark all blocks in paBlocks as free. */
}
else
{
/* for fixed images mark all blocks in paBlocks as allocated */
}
/* Setup image parameters. */
/* Create image file. */
if (RT_FAILURE(rc))
{
goto out;
}
if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
{
/* Check the free space on the disk and leave early if there is not
* sufficient space available. */
{
rc = vdiError(pImage, VERR_DISK_FULL, RT_SRC_POS, N_("VDI: disk would overflow creating image '%s'"), pImage->pszFilename);
goto out;
}
}
if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
{
/*
* Allocate & commit whole file if fixed image, it must be more
* effective than expanding file by write operations.
*/
}
else
{
/* Set file size to hold header and blocks array. */
}
if (RT_FAILURE(rc))
{
rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: setting image size failed for '%s'"), pImage->pszFilename);
goto out;
}
/* Use specified image uuid */
/* Generate image last-modify uuid */
/* Write pre-header. */
if (RT_FAILURE(rc))
{
rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: writing pre-header failed for '%s'"), pImage->pszFilename);
goto out;
}
/* Write header. */
rc = vdiFileWriteSync(pImage, sizeof(pImage->PreHeader), &pImage->Header.u.v1plus, sizeof(pImage->Header.u.v1plus), NULL);
if (RT_FAILURE(rc))
{
rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: writing header failed for '%s'"), pImage->pszFilename);
goto out;
}
NULL);
if (RT_FAILURE(rc))
{
rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: writing block pointers failed for '%s'"), pImage->pszFilename);
goto out;
}
if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
{
/* Fill image with zeroes. We do this for every fixed-size image since on some systems
* (for example Windows Vista), it takes ages to write a block near the end of a sparse
* file and the guest could complain about an ATA timeout. */
/** @todo Starting with Linux 2.6.23, there is an fallocate() system call.
* Currently supported file systems are ext4 and ocfs2. */
/* Allocate a temporary zero-filled buffer. Use a bigger block size to optimize writing */
if (!pvBuf)
{
rc = VERR_NO_MEMORY;
goto out;
}
uOff = 0;
/* Write data to all image blocks. */
{
if (RT_FAILURE(rc))
{
rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: writing block failed for '%s'"), pImage->pszFilename);
goto out;
}
if (pfnProgress)
{
if (RT_FAILURE(rc))
goto out;
}
}
}
out:
if (RT_FAILURE(rc))
return rc;
}
/**
* Internal: Open a VDI image.
*/
{
int rc;
if (pImage->pInterfaceError)
#ifdef VBOX_WITH_NEW_IO_CODE
/* Try to get I/O interface. */
#endif
/*
* Open the image.
*/
if (RT_FAILURE(rc))
{
/* Do NOT signal an appropriate error here, as the VD layer has the
* choice of retrying the open if it failed. */
goto out;
}
/* Read pre-header. */
NULL);
if (RT_FAILURE(rc))
{
rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: error reading pre-header in '%s'"), pImage->pszFilename);
goto out;
}
if (RT_FAILURE(rc))
{
goto out;
}
/* Read header. */
{
case 0:
NULL);
if (RT_FAILURE(rc))
{
rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: error reading v0 header in '%s'"), pImage->pszFilename);
goto out;
}
break;
case 1:
NULL);
if (RT_FAILURE(rc))
{
rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: error reading v1 header in '%s'"), pImage->pszFilename);
goto out;
}
* Conversion is harmless, as any VirtualBox version supporting VDI
* 1.1 doesn't touch fields it doesn't know about. */
{
/* Mark LCHS geometry not-calculated. */
}
{
/* Read the actual VDI 1.1+ header completely. */
rc = vdiFileReadSync(pImage, sizeof(pImage->PreHeader), &pImage->Header.u.v1plus, sizeof(pImage->Header.u.v1plus), NULL);
if (RT_FAILURE(rc))
{
rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: error reading v1.1+ header in '%s'"), pImage->pszFilename);
goto out;
}
}
break;
default:
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);
goto out;
}
if (RT_FAILURE(rc))
{
rc = vdiError(pImage, VERR_VD_VDI_INVALID_HEADER, RT_SRC_POS, N_("VDI: invalid header in '%s'"), pImage->pszFilename);
goto out;
}
/* Setup image parameters by header. */
/* Allocate memory for blocks array. */
pImage->paBlocks = (PVDIIMAGEBLOCKPOINTER)RTMemAlloc(sizeof(VDIIMAGEBLOCKPOINTER) * getImageBlocks(&pImage->Header));
{
rc = VERR_NO_MEMORY;
goto out;
}
/* Read blocks array. */
NULL);
out:
if (RT_FAILURE(rc))
vdiFreeImage(pImage, false);
return rc;
}
/**
* Internal: Save header to file.
*/
{
int rc;
{
case 0:
rc = vdiFileWriteSync(pImage, sizeof(VDIPREHEADER), &pImage->Header.u.v0, sizeof(pImage->Header.u.v0), NULL);
break;
case 1:
rc = vdiFileWriteSync(pImage, sizeof(VDIPREHEADER), &pImage->Header.u.v1, sizeof(pImage->Header.u.v1), NULL);
else
rc = vdiFileWriteSync(pImage, sizeof(VDIPREHEADER), &pImage->Header.u.v1plus, sizeof(pImage->Header.u.v1plus), NULL);
break;
default:
break;
}
return rc;
}
/**
* Internal: Save header to file - async version.
*/
{
int rc;
{
case 0:
break;
case 1:
else
break;
default:
break;
}
return rc;
}
/**
* Internal: Save block pointer to file, save header to file.
*/
{
/* Update image header. */
if (RT_SUCCESS(rc))
{
/* write only one block pointer. */
sizeof(VDIIMAGEBLOCKPOINTER),
NULL);
}
return rc;
}
/**
* Internal: Save block pointer to file, save header to file - async version.
*/
{
/* Update image header. */
if (RT_SUCCESS(rc))
{
/* write only one block pointer. */
sizeof(VDIIMAGEBLOCKPOINTER),
}
return rc;
}
/**
* Internal: Flush the image file to disk.
*/
{
{
/* Save header. */
}
}
/**
* Internal: Flush the image file to disk - async version.
*/
{
{
/* Save header. */
}
}
/**
* Internal: Free all allocated space for representing an image, and optionally
* delete the image from disk.
*/
{
if (vdiFileOpened(pImage))
{
}
{
}
}
/** @copydoc VBOXHDDBACKEND::pfnCheckIfValid */
{
int rc = VINF_SUCCESS;
if ( !VALID_PTR(pszFilename)
|| !*pszFilename)
{
goto out;
}
if (!pImage)
{
rc = VERR_NO_MEMORY;
goto out;
}
#ifndef VBOX_WITH_NEW_IO_CODE
#else
#endif
vdiFreeImage(pImage, false);
out:
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnOpen */
void **ppBackendData)
{
LogFlowFunc(("pszFilename=\"%s\" uOpenFlags=%#x pVDIfsDisk=%#p pVDIfsImage=%#p ppBackendData=%#p\n", pszFilename, uOpenFlags, pVDIfsDisk, pVDIfsImage, ppBackendData));
int rc;
/* Check open flags. All valid flags are supported. */
if (uOpenFlags & ~VD_OPEN_FLAGS_MASK)
{
goto out;
}
/* Check remaining arguments. */
if ( !VALID_PTR(pszFilename)
|| !*pszFilename)
{
goto out;
}
if (!pImage)
{
rc = VERR_NO_MEMORY;
goto out;
}
#ifndef VBOX_WITH_NEW_IO_CODE
#else
#endif
if (RT_SUCCESS(rc))
*ppBackendData = pImage;
out:
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnCreate */
unsigned uImageFlags, const char *pszComment,
unsigned uOpenFlags, unsigned uPercentStart,
void **ppBackendData)
{
LogFlowFunc(("pszFilename=\"%s\" cbSize=%llu uImageFlags=%#x pszComment=\"%s\" pPCHSGeometry=%#p pLCHSGeometry=%#p Uuid=%RTuuid uOpenFlags=%#x uPercentStart=%u uPercentSpan=%u pVDIfsDisk=%#p pVDIfsImage=%#p pVDIfsOperation=%#p ppBackendData=%#p", pszFilename, cbSize, uImageFlags, pszComment, pPCHSGeometry, pLCHSGeometry, pUuid, uOpenFlags, uPercentStart, uPercentSpan, pVDIfsDisk, pVDIfsImage, pVDIfsOperation, ppBackendData));
int rc;
if (pIfProgress)
{
if (pCbProgress)
}
/* Check open flags. All valid flags are supported. */
if (uOpenFlags & ~VD_OPEN_FLAGS_MASK)
{
goto out;
}
/* Check size. Maximum 2PB-3M (to be on the safe side). No tricks with
* adjusting the 1M block size so far, which would extend the size. */
if ( !cbSize
{
goto out;
}
/* Check remaining arguments. */
if ( !VALID_PTR(pszFilename)
|| !*pszFilename
|| !VALID_PTR(pPCHSGeometry)
|| !VALID_PTR(pLCHSGeometry))
{
goto out;
}
if (!pImage)
{
rc = VERR_NO_MEMORY;
goto out;
}
#ifndef VBOX_WITH_NEW_IO_CODE
#else
#endif
if (RT_SUCCESS(rc))
{
* image is opened in read-only mode if the caller requested that. */
if (uOpenFlags & VD_OPEN_FLAGS_READONLY)
{
vdiFreeImage(pImage, false);
if (RT_FAILURE(rc))
goto out;
}
*ppBackendData = pImage;
}
else
out:
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnRename */
{
int rc = VINF_SUCCESS;
/* Check arguments. */
if ( !pImage
|| !pszFilename
|| !*pszFilename)
{
goto out;
}
/* Close the image. */
vdiFreeImage(pImage, false);
/* Rename the file. */
if (RT_FAILURE(rc))
{
/* The move failed, try to reopen the original image. */
if (RT_FAILURE(rc2))
goto out;
}
/* Update pImage with the new information. */
/* Open the new image. */
if (RT_FAILURE(rc))
goto out;
out:
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnClose */
{
int rc = VINF_SUCCESS;
/* Freeing a never allocated image (e.g. because the open failed) is
* not signalled as an error. After all nothing bad happens. */
if (pImage)
{
}
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnRead */
{
LogFlowFunc(("pBackendData=%#p uOffset=%llu pvBuf=%#p cbToRead=%zu pcbActuallyRead=%#p\n", pBackendData, uOffset, pvBuf, cbToRead, pcbActuallyRead));
unsigned uBlock;
unsigned offRead;
int rc;
|| !cbToRead)
{
goto out;
}
/* Calculate starting block number and offset inside it. */
/* Clip read range to at most the rest of the block. */
{
rc = VINF_SUCCESS;
}
else
{
/* Block present in image file, read relevant data. */
}
if (pcbActuallyRead)
out:
return rc;
}
/**@copydoc VBOXHDDBACKEND::pfnWrite */
{
LogFlowFunc(("pBackendData=%#p uOffset=%llu pvBuf=%#p cbToWrite=%zu pcbWriteProcess=%#p pcbPreRead=%#p pcbPostRead=%#p\n", pBackendData, uOffset, pvBuf, cbToWrite, pcbWriteProcess, pcbPreRead, pcbPostRead));
unsigned uBlock;
unsigned offWrite;
int rc = VINF_SUCCESS;
{
goto out;
}
{
goto out;
}
/* No size check here, will do that later. For dynamic images which are
* not multiples of the block size in length, this would prevent writing to
* the last grain. */
/* Calculate starting block number and offset inside it. */
/* Clip write range to at most the rest of the block. */
do
{
{
/* Block is either free or zero. */
{
/* If the destination block is unallocated at this point, it's
* either a zero block or a block which hasn't been used so far
* (which also means that it's a zero block. Don't need to write
* anything to this block if the data consists of just zeroes. */
{
break;
}
}
{
/* Full block write to previously unallocated block.
* Allocate block and write data. */
if (RT_FAILURE(rc))
goto out;
if (RT_FAILURE(rc))
goto out;
*pcbPreRead = 0;
*pcbPostRead = 0;
}
else
{
/* Trying to do a partial write to an unallocated block. Don't do
* anything except letting the upper layer know what to do. */
}
}
else
{
/* Block present in image file, write relevant data. */
}
} while (0);
if (pcbWriteProcess)
out:
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnFlush */
static int vdiFlush(void *pBackendData)
{
int rc = VINF_SUCCESS;
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnGetVersion */
static unsigned vdiGetVersion(void *pBackendData)
{
unsigned uVersion;
if (pImage)
else
uVersion = 0;
return uVersion;
}
/** @copydoc VBOXHDDBACKEND::pfnGetSize */
{
if (pImage)
else
cbSize = 0;
return cbSize;
}
/** @copydoc VBOXHDDBACKEND::pfnGetFileSize */
{
if (pImage)
{
if (vdiFileOpened(pImage))
{
if (RT_SUCCESS(rc))
}
}
return cb;
}
/** @copydoc VBOXHDDBACKEND::pfnGetPCHSGeometry */
static int vdiGetPCHSGeometry(void *pBackendData,
{
int rc;
if (pImage)
{
{
rc = VINF_SUCCESS;
}
else
}
else
LogFlowFunc(("returns %Rrc (PCHS=%u/%u/%u)\n", rc, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnSetPCHSGeometry */
static int vdiSetPCHSGeometry(void *pBackendData,
{
LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p PCHS=%u/%u/%u\n", pBackendData, pPCHSGeometry, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
int rc;
if (pImage)
{
{
goto out;
}
rc = VINF_SUCCESS;
}
else
out:
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnGetLCHSGeometry */
static int vdiGetLCHSGeometry(void *pBackendData,
{
int rc;
if (pImage)
{
if (!pGeometry)
if ( pGeometry->cCylinders > 0
{
rc = VINF_SUCCESS;
}
else
}
else
LogFlowFunc(("returns %Rrc (LCHS=%u/%u/%u)\n", rc, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnSetLCHSGeometry */
static int vdiSetLCHSGeometry(void *pBackendData,
{
LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p LCHS=%u/%u/%u\n", pBackendData, pLCHSGeometry, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
int rc;
if (pImage)
{
{
goto out;
}
if (pGeometry)
{
/* Update header information in base image file. */
}
rc = VINF_SUCCESS;
}
else
out:
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnGetImageFlags */
static unsigned vdiGetImageFlags(void *pBackendData)
{
unsigned uImageFlags;
if (pImage)
else
uImageFlags = 0;
return uImageFlags;
}
/** @copydoc VBOXHDDBACKEND::pfnGetOpenFlags */
static unsigned vdiGetOpenFlags(void *pBackendData)
{
unsigned uOpenFlags;
if (pImage)
else
uOpenFlags = 0;
return uOpenFlags;
}
/** @copydoc VBOXHDDBACKEND::pfnSetOpenFlags */
{
int rc;
const char *pszFilename;
/* Image must be opened and the new flags must be valid. Just readonly and
* info flags are supported. */
if (!pImage || (uOpenFlags & ~(VD_OPEN_FLAGS_READONLY | VD_OPEN_FLAGS_INFO | VD_OPEN_FLAGS_ASYNC_IO)))
{
goto out;
}
/* Implement this operation via reopening the image. */
vdiFreeImage(pImage, false);
out:
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnGetComment */
{
LogFlowFunc(("pBackendData=%#p pszComment=%#p cbComment=%zu\n", pBackendData, pszComment, cbComment));
int rc = VINF_SUCCESS;
if (pImage)
{
{
/* memcpy is much better than strncpy. */
}
else
}
else
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnGetComment */
{
int rc;
{
goto out;
}
if (pImage)
{
if (cchComment >= VDI_IMAGE_COMMENT_SIZE)
{
goto out;
}
/* we don't support old style images */
{
/*
* Update the comment field, making sure to zero out all of the previous comment.
*/
/* write out new the header */
}
else
}
else
out:
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnGetUuid */
{
int rc;
if (pImage)
{
rc = VINF_SUCCESS;
}
else
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnSetUuid */
{
int rc = VINF_SUCCESS;
if (pImage)
{
{
/* Make it possible to clone old VDIs. */
else
{
LogFunc(("Version is not supported!\n"));
}
}
else
}
else
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnGetModificationUuid */
{
int rc;
if (pImage)
{
rc = VINF_SUCCESS;
}
else
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnSetModificationUuid */
{
int rc = VINF_SUCCESS;
if (pImage)
{
{
/* Make it possible to clone old VDIs. */
else
{
LogFunc(("Version is not supported!\n"));
}
}
else
}
else
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnGetParentUuid */
{
int rc;
if (pImage)
{
rc = VINF_SUCCESS;
}
else
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnSetParentUuid */
{
int rc = VINF_SUCCESS;
if (pImage)
{
{
/* Make it possible to clone old VDIs. */
else
{
LogFunc(("Version is not supported!\n"));
}
}
else
}
else
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnGetParentModificationUuid */
{
int rc;
if (pImage)
{
rc = VINF_SUCCESS;
}
else
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnSetParentModificationUuid */
{
int rc = VINF_SUCCESS;
if (pImage)
{
{
else
{
LogFunc(("Version is not supported!\n"));
}
}
else
}
else
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnDump */
static void vdiDump(void *pBackendData)
{
#ifndef VBOX_WITH_NEW_IO_CODE
pImage->pInterfaceErrorCallbacks->pfnMessage(pImage->pInterfaceError->pvUser, "Dumping VDI image \"%s\" mode=%s uOpenFlags=%X File=%08X\n",
#else
pImage->pInterfaceErrorCallbacks->pfnMessage(pImage->pInterfaceError->pvUser, "Dumping VDI image \"%s\" mode=%s uOpenFlags=%X File=%#p\n",
#endif
pImage->pInterfaceErrorCallbacks->pfnMessage(pImage->pInterfaceError->pvUser, "Header: Version=%08X Type=%X Flags=%X Size=%llu\n",
pImage->pInterfaceErrorCallbacks->pfnMessage(pImage->pInterfaceError->pvUser, "Header: cbBlock=%u cbBlockExtra=%u cBlocks=%u cBlocksAllocated=%u\n",
pImage->pInterfaceErrorCallbacks->pfnMessage(pImage->pInterfaceError->pvUser, "Header: offBlocks=%u offData=%u\n",
if (pg)
pImage->pInterfaceErrorCallbacks->pfnMessage(pImage->pInterfaceError->pvUser, "Header: Geometry: C/H/S=%u/%u/%u cbSector=%u\n",
pImage->pInterfaceErrorCallbacks->pfnMessage(pImage->pInterfaceError->pvUser, "Header: uuidCreation={%RTuuid}\n", getImageCreationUUID(&pImage->Header));
pImage->pInterfaceErrorCallbacks->pfnMessage(pImage->pInterfaceError->pvUser, "Header: uuidModification={%RTuuid}\n", getImageModificationUUID(&pImage->Header));
pImage->pInterfaceErrorCallbacks->pfnMessage(pImage->pInterfaceError->pvUser, "Header: uuidParent={%RTuuid}\n", getImageParentUUID(&pImage->Header));
pImage->pInterfaceErrorCallbacks->pfnMessage(pImage->pInterfaceError->pvUser, "Header: uuidParentModification={%RTuuid}\n", getImageParentModificationUUID(&pImage->Header));
pImage->pInterfaceErrorCallbacks->pfnMessage(pImage->pInterfaceError->pvUser, "Image: fFlags=%08X offStartBlocks=%u offStartData=%u\n",
pImage->pInterfaceErrorCallbacks->pfnMessage(pImage->pInterfaceError->pvUser, "Image: uBlockMask=%08X cbTotalBlockData=%u uShiftOffset2Index=%u offStartBlockData=%u\n",
{
{
cBadBlocks++;
}
}
{
pImage->pInterfaceErrorCallbacks->pfnMessage(pImage->pInterfaceError->pvUser, "!! WARNING: %u blocks actually allocated (cBlocksAllocated=%u) !!\n",
}
if (cBadBlocks)
{
pImage->pInterfaceErrorCallbacks->pfnMessage(pImage->pInterfaceError->pvUser, "!! WARNING: %u bad blocks found !!\n",
}
}
{
int rc = VERR_NOT_IMPLEMENTED;
return rc;
}
{
int rc = VERR_NOT_IMPLEMENTED;
return rc;
}
{
int rc = VERR_NOT_IMPLEMENTED;
return rc;
}
{
int rc = VERR_NOT_IMPLEMENTED;
return rc;
}
{
int rc = VERR_NOT_IMPLEMENTED;
return rc;
}
static bool vdiIsAsyncIOSupported(void *pBackendData)
{
return true;
}
{
LogFlowFunc(("pvBackendData=%#p uOffset=%llu pIoCtx=%#p cbToRead=%zu pcbActuallyRead=%#p\n",
unsigned uBlock;
unsigned offRead;
int rc;
|| !cbToRead)
{
goto out;
}
/* Calculate starting block number and offset inside it. */
/* Clip read range to at most the rest of the block. */
{
rc = VINF_SUCCESS;
}
else
{
/* Block present in image file, read relevant data. */
}
if (pcbActuallyRead)
out:
return rc;
}
{
LogFlowFunc(("pvBackendData=%#p uOffset=%llu pIoCtx=%#p cbToWrite=%zu pcbWriteProcess=%#p pcbPreRead=%#p pcbPostRead=%#p\n",
unsigned uBlock;
unsigned offWrite;
int rc = VINF_SUCCESS;
{
goto out;
}
{
goto out;
}
/* No size check here, will do that later. For dynamic images which are
* not multiples of the block size in length, this would prevent writing to
* the last grain. */
/* Calculate starting block number and offset inside it. */
/* Clip write range to at most the rest of the block. */
do
{
{
/* Block is either free or zero. */
{
#if 0 /** @todo Provide interface to check an I/O context for a specific value */
/* If the destination block is unallocated at this point, it's
* either a zero block or a block which hasn't been used so far
* (which also means that it's a zero block. Don't need to write
* anything to this block if the data consists of just zeroes. */
{
break;
}
#endif
}
{
/* Full block write to previously unallocated block.
* Allocate block and write data. */
goto out;
if (RT_FAILURE(rc))
goto out;
*pcbPreRead = 0;
*pcbPostRead = 0;
}
else
{
/* Trying to do a partial write to an unallocated block. Don't do
* anything except letting the upper layer know what to do. */
}
}
else
{
/* Block present in image file, write relevant data. */
}
} while (0);
if (pcbWriteProcess)
out:
return rc;
}
{
int rc = VINF_SUCCESS;
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnCompact */
{
int rc = VINF_SUCCESS;
if (pIfParentState)
{
if (pCbParentState)
}
if (pIfProgress)
{
if (pCbProgress)
}
do {
unsigned cBlocks;
unsigned cBlocksToMove = 0;
if (pfnParentRead)
{
}
unsigned cBlocksAllocated = (unsigned)((cbFile - pImage->offStartData - pImage->offStartBlockData) >> pImage->uShiftOffset2Index);
if (cBlocksAllocated == 0)
{
/* No data blocks in this image, no need to compact. */
rc = VINF_SUCCESS;
break;
}
/* Allocate block array for back resolving. */
* compacting the image, just to be on the safe side. Update the
* image contents straight away, as this enables cancelling. */
for (unsigned i = 0; i < cBlocksAllocated; i++)
rc = VINF_SUCCESS;
for (unsigned i = 0; i < cBlocks; i++)
{
{
if (ptrBlock < cBlocksAllocated)
{
else
{
LogFunc(("Freed cross-linked block %u in file \"%s\"\n",
i, pImage->pszFilename));
if (RT_FAILURE(rc))
break;
}
}
else
{
LogFunc(("Freed out of bounds reference for block %u in file \"%s\"\n",
i, pImage->pszFilename));
if (RT_FAILURE(rc))
break;
}
}
}
if (RT_FAILURE(rc))
break;
/* Find redundant information and update the block pointers
* accordingly, creating bubbles. Keep disk up to date, as this
* enables cancelling. */
for (unsigned i = 0; i < cBlocks; i++)
{
{
/* Block present in image file, read relevant data. */
if (RT_FAILURE(rc))
break;
{
if (RT_FAILURE(rc))
break;
/* Adjust progress info, one block to be relocated. */
}
else if (pfnParentRead)
{
if (RT_FAILURE(rc))
break;
{
if (RT_FAILURE(rc))
break;
/* Adjust progress info, one block to be relocated. */
}
}
}
{
if (RT_FAILURE(rc))
break;
}
}
if (RT_FAILURE(rc))
break;
/* Fill bubbles with other data (if available). */
unsigned cBlocksMoved = 0;
unsigned uBlockUsedPos = cBlocksAllocated;
for (unsigned i = 0; i < cBlocksAllocated; i++)
{
if (uBlock == VDI_IMAGE_BLOCK_FREE)
{
unsigned uBlockData = VDI_IMAGE_BLOCK_FREE;
{
}
/* Terminate early if there is no block which needs copying. */
if (uBlockUsedPos == i)
break;
if (RT_FAILURE(rc))
break;
paBlocks2[i] = uBlockData;
cBlocksMoved++;
}
{
if (RT_FAILURE(rc))
break;
}
}
if (RT_FAILURE(rc))
break;
/* Update image header. */
/* Truncate the image to the proper size to finish compacting. */
} while (0);
if (paBlocks2)
if (pvTmp)
if (pvBuf)
{
}
return rc;
}
{
/* pszBackendName */
"VDI",
/* cbSize */
sizeof(VBOXHDDBACKEND),
/* uBackendCaps */
/* papszFileExtensions */
/* paConfigInfo */
NULL,
/* hPlugin */
/* pfnCheckIfValid */
/* pfnOpen */
/* pfnCreate */
/* pfnRename */
/* pfnClose */
/* pfnRead */
/* pfnWrite */
/* pfnFlush */
/* pfnGetVersion */
/* pfnGetSize */
/* pfnGetFileSize */
/* pfnGetPCHSGeometry */
/* pfnSetPCHSGeometry */
/* pfnGetLCHSGeometry */
/* pfnSetLCHSGeometry */
/* pfnGetImageFlags */
/* pfnGetOpenFlags */
/* pfnSetOpenFlags */
/* pfnGetComment */
/* pfnSetComment */
/* pfnGetUuid */
/* pfnSetUuid */
/* pfnGetModificationUuid */
/* pfnSetModificationUuid */
/* pfnGetParentUuid */
/* pfnSetParentUuid */
/* pfnGetParentModificationUuid */
/* pfnSetParentModificationUuid */
/* pfnDump */
/* pfnGetTimeStamp */
/* pfnGetParentTimeStamp */
/* pfnSetParentTimeStamp */
/* pfnGetParentFilename */
/* pfnSetParentFilename */
/* pfnIsAsyncIOSupported */
/* pfnAsyncRead */
/* pfnAsyncWrite */
/* pfnAsyncFlush */
/* pfnComposeLocation */
/* pfnComposeName */
/* pfnCompact */
};