/* $Id$ */
/** @file
* VHD Disk image, Core Code.
*/
/*
* Copyright (C) 2006-2015 Oracle Corporation
*
* 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.
*/
/*******************************************************************************
* Header Files *
*******************************************************************************/
#include <VBox/vd-plugin.h>
#include "VDBackends.h"
/* This is common to all VHD disk types and is located at the end of the image */
#pragma pack(1)
typedef struct VHDFooter
{
} VHDFooter;
#pragma pack()
/* this really is spelled with only one n */
#define VHD_FOOTER_FEATURES_NOT_ENABLED 0
#define VHD_PLATFORM_CODE_NONE 0
/* Header for expanding disk images. */
#pragma pack(1)
typedef struct VHDParentLocatorEntry
{
typedef struct VHDDynamicDiskHeader
{
#pragma pack()
/**
* Complete VHD image data structure.
*/
typedef struct VHDIMAGE
{
/** Image file name. */
const char *pszFilename;
/** Opaque storage handle. */
/** Pointer to the per-disk VD interface list. */
/** Pointer to the per-image VD interface list. */
/** Error interface. */
/** I/O interface. */
/** Open flags passed by VBoxHDD layer. */
unsigned uOpenFlags;
/** Image flags defined during creation or determined during open. */
unsigned uImageFlags;
/** Total size of the image. */
/** Physical geometry of this image. */
/** Logical geometry of this image. */
/** Image UUID. */
/** Parent image UUID. */
/** Parent's time stamp at the time of image creation. */
/** Relative path to the parent image. */
char *pszParentFilename;
/** The Block Allocation Table. */
/** Number of entries in the table. */
/** Size of one data block. */
/** Sectors per data block. */
/** Length of the sector bitmap in bytes. */
/** A copy of the disk footer. */
/** Current end offset of the file (without the disk footer). */
/** Size of the data block bitmap in sectors. */
/** Start of the block allocation table. */
/** Buffer to hold block's bitmap for bit search operations. */
/** Offset to the next data structure (dynamic disk header). */
/** Flag to force dynamic disk header update. */
bool fDynHdrNeedsUpdate;
/**
* Structure tracking the expansion process of the image
* for async access.
*/
typedef struct VHDIMAGEEXPAND
{
/** Flag indicating the status of each step. */
/** The index in the block allocation table which is written. */
/** Big endian representation of the block index
* which is written in the BAT. */
/** Old end of the file - used for rollback in case of an error. */
/** Sector bitmap written to the new block - variable in size. */
/**
* Flag defines
*/
/** All steps completed successfully. */
/** All steps completed (no success indicator) */
/** Every status field has 2 bits so we can encode 4 steps in one byte. */
/**
* Helper macros to get and set the status field.
*/
/*******************************************************************************
* Static Variables *
*******************************************************************************/
/** NULL-terminated array of supported file extensions. */
{
{"vhd", VDTYPE_HDD},
};
/*******************************************************************************
* Internal Functions *
*******************************************************************************/
/**
* Internal: Compute and update header checksum.
*/
{
return ~checksum;
}
/**
* Internal: Convert filename to UTF16 with appropriate endianness.
*/
bool fBigEndian)
{
int rc;
if (RT_FAILURE(rc))
goto out;
{
goto out;
}
if (fBigEndian)
for (unsigned i = 0; i < cTmp16Len; i++)
else
if (pcbActualSize)
out:
if (tmp16)
return rc;
}
/**
* Internal: Update one locator entry.
*/
{
char *pszTmp;
if (!pvBuf)
return VERR_NO_MEMORY;
{
case VHD_PLATFORM_CODE_WI2R:
{
{
/* Convert to relative path. */
if (RT_SUCCESS(rc))
{
/* Update plain relative name. */
{
break;
}
}
}
else
{
/* Update plain relative name. */
{
break;
}
}
if (RT_SUCCESS(rc))
break;
}
case VHD_PLATFORM_CODE_WI2K:
/* Update plain absolute name. */
if (RT_SUCCESS(rc))
break;
case VHD_PLATFORM_CODE_W2RU:
{
/* Convert to relative path. */
if (RT_SUCCESS(rc))
}
else
{
/* Update unicode relative name. */
}
if (RT_SUCCESS(rc))
break;
case VHD_PLATFORM_CODE_W2KU:
/* Update unicode absolute name. */
if (!pszTmp)
{
rc = VERR_NO_MEMORY;
break;
}
if (RT_FAILURE(rc))
{
break;
}
if (RT_SUCCESS(rc))
break;
default:
break;
}
if (RT_SUCCESS(rc))
if (pvBuf)
return rc;
}
/**
* Internal: Update dynamic disk header from VHDIMAGE.
*/
{
int rc, i;
if (!pImage)
return VERR_VD_NOT_OPENED;
if (RT_FAILURE(rc))
return rc;
return VERR_VD_VHD_INVALID_HEADER;
return VERR_VD_VHD_INVALID_HEADER;
/* Update parent's timestamp. */
/* Update parent's filename. */
if (pImage->pszParentFilename)
{
if (RT_FAILURE(rc))
return rc;
}
/* Update parent's locators. */
for (i = 0; i < VHD_MAX_LOCATOR_ENTRIES; i++)
{
/* Skip empty locators */
&& pImage->pszParentFilename)
{
if (RT_FAILURE(rc))
return rc;
}
}
/* Update parent's UUID */
/* Update data offset and number of table entries. */
return rc;
}
/**
* Internal: Update the VHD footer.
*/
{
/* Update fields which can change. */
pImage->vhdFooterCopy.Checksum = RT_H2BE_U32(vhdChecksum(&pImage->vhdFooterCopy, sizeof(VHDFooter)));
if (pImage->pBlockAllocationTable)
if (RT_SUCCESS(rc))
sizeof(VHDFooter));
return rc;
}
/**
* Internal. Flush image data to disk.
*/
{
return VINF_SUCCESS;
if (pImage->pBlockAllocationTable)
{
/*
* This is an expanding image. Write the BAT and copy of the disk footer.
*/
return VERR_NO_MEMORY;
/*
* The BAT entries have to be stored in big endian format.
*/
for (unsigned i = 0; i < pImage->cBlockAllocationTableEntries; i++)
/*
* Write the block allocation table after the copy of the disk footer and the dynamic disk header.
*/
if (pImage->fDynHdrNeedsUpdate)
}
if (RT_SUCCESS(rc))
if (RT_SUCCESS(rc))
return rc;
}
/**
* Internal. Free all allocated space for representing an image except pImage,
* and optionally delete the image from disk.
*/
{
/* Freeing a never allocated image (e.g. because the open failed) is
* not signalled as an error. After all nothing bad happens. */
if (pImage)
{
{
/* No point updating the file that is deleted anyway. */
if (!fDelete)
}
if (pImage->pszParentFilename)
{
}
if (pImage->pBlockAllocationTable)
{
}
{
}
}
return rc;
}
/* 946684800 is the number of seconds between 1/1/1970 and 1/1/2000 */
{
}
{
}
/**
* Internal: Allocates the block bitmap rounding up to the next 32bit or 64bit boundary.
* Can be freed with RTMemFree. The memory is zeroed.
*/
{
#ifdef RT_ARCH_AMD64
#else
#endif
}
/**
* Internal: called when the async expansion process completed (failure or success).
* Will do the necessary rollback if an error occurred.
*/
{
bool fIoInProgress = false;
/* Quick path, check if everything succeeded. */
if (fFlags == VHDIMAGEEXPAND_ALL_SUCCESS)
{
}
else
{
if ( uStatus == VHDIMAGEEXPAND_STEP_FAILED
{
/* Undo and restore the old value. */
/* Restore the old value on the disk.
* No need for a completion callback because we can't
* do anything if this fails. */
if (uStatus == VHDIMAGEEXPAND_STEP_SUCCESS)
{
}
}
/* Restore old size (including the footer because another application might
* fill up the free space making it impossible to add the footer)
* and add the footer at the right place again. */
}
}
static int vhdAsyncExpansionStepCompleted(void *pBackendData, PVDIOCTX pIoCtx, void *pvUser, int rcReq, unsigned iStep)
{
LogFlowFunc(("pBackendData=%#p pIoCtx=%#p pvUser=%#p rcReq=%Rrc iStep=%u\n",
if (RT_SUCCESS(rcReq))
else
return VERR_VD_ASYNC_IO_IN_PROGRESS;
}
static int vhdAsyncExpansionDataBlockBitmapComplete(void *pBackendData, PVDIOCTX pIoCtx, void *pvUser, int rcReq)
{
return vhdAsyncExpansionStepCompleted(pBackendData, pIoCtx, pvUser, rcReq, VHDIMAGEEXPAND_BLOCKBITMAP_STATUS_SHIFT);
}
static int vhdAsyncExpansionDataComplete(void *pBackendData, PVDIOCTX pIoCtx, void *pvUser, int rcReq)
{
return vhdAsyncExpansionStepCompleted(pBackendData, pIoCtx, pvUser, rcReq, VHDIMAGEEXPAND_USERBLOCK_STATUS_SHIFT);
}
static int vhdAsyncExpansionBatUpdateComplete(void *pBackendData, PVDIOCTX pIoCtx, void *pvUser, int rcReq)
{
return vhdAsyncExpansionStepCompleted(pBackendData, pIoCtx, pvUser, rcReq, VHDIMAGEEXPAND_BAT_STATUS_SHIFT);
}
static int vhdAsyncExpansionFooterUpdateComplete(void *pBackendData, PVDIOCTX pIoCtx, void *pvUser, int rcReq)
{
return vhdAsyncExpansionStepCompleted(pBackendData, pIoCtx, pvUser, rcReq, VHDIMAGEEXPAND_FOOTER_STATUS_SHIFT);
}
{
unsigned i = 0;
Log(("Open a dynamic disk.\n"));
/*
* Read the dynamic disk header.
*/
&vhdDynamicDiskHeader, sizeof(VHDDynamicDiskHeader));
if (memcmp(vhdDynamicDiskHeader.Cookie, VHD_DYNAMIC_DISK_HEADER_COOKIE, VHD_DYNAMIC_DISK_HEADER_COOKIE_SIZE))
return VERR_INVALID_PARAMETER;
AssertMsg(!(pImage->cbDataBlock % VHD_SECTOR_SIZE), ("%s: Data block size is not a multiple of %!\n", __FUNCTION__, VHD_SECTOR_SIZE));
/*
* Every block starts with a bitmap indicating which sectors are valid and which are not.
* We store the size of it to be able to calculate the real offset.
*/
/* Round up to full sector size */
return VERR_NO_MEMORY;
pBlockAllocationTable = (uint32_t *)RTMemAllocZ(pImage->cBlockAllocationTableEntries * sizeof(uint32_t));
if (!pBlockAllocationTable)
return VERR_NO_MEMORY;
/*
* Read the table.
*/
/*
* Because the offset entries inside the allocation table are stored big endian
* we need to convert them into host endian.
*/
pImage->pBlockAllocationTable = (uint32_t *)RTMemAllocZ(pImage->cBlockAllocationTableEntries * sizeof(uint32_t));
if (!pImage->pBlockAllocationTable)
{
return VERR_NO_MEMORY;
}
for (i = 0; i < pImage->cBlockAllocationTableEntries; i++)
return rc;
}
{
/*
* Open the image.
*/
false /* fCreate */),
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. */
return rc;
}
if (RT_SUCCESS(rc))
{
{
/*
* There is also a backup header at the beginning in case the image got corrupted.
* Such corrupted images are detected here to let the open handler repair it later.
*/
if (RT_SUCCESS(rc))
{
else
}
}
}
if (RT_FAILURE(rc))
return rc;
{
break;
break;
break;
default:
return VERR_NOT_IMPLEMENTED;
}
/*
* Copy of the disk footer.
* If we allocate new blocks in differencing disks on write access
* the footer is overwritten. We need to write it at the end of the file.
*/
/*
* Is there a better way?
*/
if (RT_FAILURE(rc))
vhdFreeImage(pImage, false);
return rc;
}
/**
* Internal: Checks if a sector in the block bitmap is set
*/
{
/*
* The index of the bit in the byte of the data block bitmap.
* The most significant bit stands for a lower sector number.
*/
("VHD: Current bitmap position exceeds maximum size of the bitmap\n"));
}
/**
* Internal: Sets the given sector in the sector bitmap.
*/
DECLINLINE(bool) vhdBlockBitmapSectorSet(PVHDIMAGE pImage, uint8_t *pu8Bitmap, uint32_t cBlockBitmapEntry)
{
/*
* The index of the bit in the byte of the data block bitmap.
* The most significant bit stands for a lower sector number.
*/
("VHD: Current bitmap position exceeds maximum size of the bitmap\n"));
return fClear;
}
/**
* Internal: Derive drive geometry from its size.
*/
{
{
/* ATA disks limited to 127 GB. */
}
{
u32SectorsPerTrack = 255;
u32Heads = 16;
}
else
{
u32SectorsPerTrack = 17;
if (u32Heads < 4)
{
u32Heads = 4;
}
{
u32SectorsPerTrack = 31;
u32Heads = 16;
}
{
u32SectorsPerTrack = 63;
u32Heads = 16;
}
}
}
static uint32_t vhdAllocateParentLocators(PVHDIMAGE pImage, VHDDynamicDiskHeader *pDDH, uint64_t u64Offset)
{
/*
* The VHD spec states that the DataSpace field holds the number of sectors
* required to store the parent locator path.
* As it turned out VPC and Hyper-V store the amount of bytes reserved for the
* path and not the number of sectors.
*/
/* Unicode absolute Windows path. */
pLocator++;
/* Unicode relative Windows path. */
return u64Offset;
}
/**
* Internal: Additional code for dynamic VHD image creation.
*/
{
int rc;
/* Align to sector boundary */
return vdIfError(pImage->pIfError, VERR_NO_MEMORY, RT_SRC_POS, N_("VHD: cannot allocate memory for bitmap storage"));
/* Initialize BAT. */
pImage->cBlockAllocationTableEntries = (uint32_t)((cbSize + pImage->cbDataBlock - 1) / pImage->cbDataBlock); /* Align table to the block size. */
u32BlockAllocationTableSectors = (pImage->cBlockAllocationTableEntries * sizeof(uint32_t) + VHD_SECTOR_SIZE - 1) / VHD_SECTOR_SIZE;
pImage->pBlockAllocationTable = (uint32_t *)RTMemAllocZ(pImage->cBlockAllocationTableEntries * sizeof(uint32_t));
if (!pImage->pBlockAllocationTable)
return vdIfError(pImage->pIfError, VERR_NO_MEMORY, RT_SRC_POS, N_("VHD: cannot allocate memory for BAT"));
for (unsigned i = 0; i < pImage->cBlockAllocationTableEntries; i++)
{
}
/* Round up to the sector size. */
else
pImage->uCurrentEndOfFile = pImage->uBlockAllocationTableOffset + u32BlockAllocationTableSectors * VHD_SECTOR_SIZE;
/* Set dynamic image size. */
if (!pvTmp)
return vdIfError(pImage->pIfError, VERR_NO_MEMORY, RT_SRC_POS, N_("VHD: cannot set the file size for '%s'"), pImage->pszFilename);
if (RT_FAILURE(rc))
{
return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VHD: cannot set the file size for '%s'"), pImage->pszFilename);
}
/* Initialize and write the dynamic disk header. */
/* Compute and update checksum. */
DynamicDiskHeader.Checksum = RT_H2BE_U32(vhdChecksum(&DynamicDiskHeader, sizeof(DynamicDiskHeader)));
&DynamicDiskHeader, sizeof(DynamicDiskHeader));
if (RT_FAILURE(rc))
return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VHD: cannot write dynamic disk header to image '%s'"), pImage->pszFilename);
/* Write BAT. */
if (RT_FAILURE(rc))
return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VHD: cannot write BAT to image '%s'"), pImage->pszFilename);
return rc;
}
/**
* Internal: The actual code for VHD image creation, both fixed and dynamic.
*/
unsigned uImageFlags, const char *pszComment,
unsigned uOpenFlags,
unsigned uPercentStart, unsigned uPercentSpan)
{
int rc;
true /* fCreate */),
if (RT_FAILURE(rc))
return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VHD: cannot create image '%s'"), pImage->pszFilename);
/* Initialize the footer. */
#ifdef RT_OS_DARWIN
#else /* Virtual PC supports only two platforms atm, so everything else will be Wi2k. */
#endif
Footer.SavedState = 0;
if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
{
/*
* Initialize fixed image.
* "The size of the entire file is the size of the hard disk in
* the guest operating system plus the size of the footer."
*/
/** @todo r=klaus replace this with actual data writes, see the experience
* with VDI files on Windows, can cause long freezes when writing. */
if (RT_FAILURE(rc))
{
vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VHD: cannot set the file size for '%s'"), pImage->pszFilename);
goto out;
}
}
else
{
/*
* Initialize dynamic image.
*
* The overall structure of dynamic disk is:
*
* [Copy of hard disk footer (512 bytes)]
* [Dynamic disk header (1024 bytes)]
* [BAT (Block Allocation Table)]
* [Parent Locators]
* [Data block 1]
* [Data block 2]
* ...
* [Data block N]
* [Hard disk footer (512 bytes)]
*/
/* We are half way thorough with creation of image, let the caller know. */
if (pfnProgress)
if (RT_FAILURE(rc))
goto out;
}
/* Compute and update the footer checksum. */
/* Store the footer */
if (RT_FAILURE(rc))
{
vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VHD: cannot write footer to image '%s'"), pImage->pszFilename);
goto out;
}
/* Dynamic images contain a copy of the footer at the very beginning of the file. */
if (!(uImageFlags & VD_IMAGE_FLAGS_FIXED))
{
/* Write the copy of the footer. */
if (RT_FAILURE(rc))
{
vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VHD: cannot write a copy of footer to image '%s'"), pImage->pszFilename);
goto out;
}
}
out:
if (RT_FAILURE(rc))
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnCheckIfValid */
{
LogFlowFunc(("pszFilename=\"%s\" pVDIfsDisk=%#p pVDIfsImage=%#p\n", pszFilename, pVDIfsDisk, pVDIfsImage));
int rc;
false /* fCreate */),
&pStorage);
if (RT_FAILURE(rc))
goto out;
if (RT_FAILURE(rc))
{
goto out;
}
if (RT_SUCCESS(rc))
{
{
/*
* There is also a backup header at the beginning in case the image got corrupted.
* Such corrupted images are detected here to let the open handler repair it later.
*/
if ( RT_FAILURE(rc)
}
if (RT_SUCCESS(rc))
*penmType = VDTYPE_HDD;
}
else
out:
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnOpen */
{
LogFlowFunc(("pszFilename=\"%s\" uOpenFlags=%#x pVDIfsDisk=%#p pVDIfsImage=%#p enmType=%u ppBackendData=%#p\n", pszFilename, uOpenFlags, pVDIfsDisk, pVDIfsImage, enmType, ppBackendData));
/* 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;
}
if (RT_SUCCESS(rc))
*ppBackendData = pImage;
else
out:
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnCreate */
unsigned uImageFlags, const char *pszComment,
unsigned uPercentStart, unsigned uPercentSpan,
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 enmType=%u ppBackendData=%#p",
pszFilename, cbSize, uImageFlags, pszComment, pPCHSGeometry, pLCHSGeometry, pUuid, uOpenFlags, uPercentStart, uPercentSpan, pVDIfsDisk, pVDIfsImage, pVDIfsOperation, enmType, ppBackendData));
if (pIfProgress)
{
}
/* Check the VD container type. */
if (enmType != VDTYPE_HDD)
{
goto out;
}
/* Check open flags. All valid flags are supported. */
if (uOpenFlags & ~VD_OPEN_FLAGS_MASK)
{
return rc;
}
/* @todo Check the values of other params */
if (!pImage)
{
rc = VERR_NO_MEMORY;
return rc;
}
/* Get I/O interface. */
{
return VERR_INVALID_PARAMETER;
}
if (RT_SUCCESS(rc))
{
* image is opened in read-only mode if the caller requested that. */
if (uOpenFlags & VD_OPEN_FLAGS_READONLY)
{
vhdFreeImage(pImage, false);
if (RT_FAILURE(rc))
{
goto out;
}
}
*ppBackendData = pImage;
}
else
out:
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnRename */
{
/* Check arguments. */
if ( !pImage
|| !pszFilename
|| !*pszFilename)
{
goto out;
}
/* Close the image. */
if (RT_FAILURE(rc))
goto out;
/* 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 old file with new name. */
if (RT_FAILURE(rc))
goto out;
out:
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnClose */
{
int rc;
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnRead */
{
LogFlowFunc(("pBackendData=%p uOffset=%#llx pIoCtx=%#p cbRead=%u pcbActuallyRead=%p\n", pBackendData, uOffset, pIoCtx, cbRead, pcbActuallyRead));
return VERR_INVALID_PARAMETER;
/*
* If we have a dynamic disk image, we need to find the data block and sector to read.
*/
if (pImage->pBlockAllocationTable)
{
/*
* Get the data block first.
*/
LogFlowFunc(("cBlockAllocationTableEntry=%u cBatEntryIndex=%u\n", cBlockAllocationTableEntry, cBATEntryIndex));
LogFlowFunc(("BlockAllocationEntry=%u\n", pImage->pBlockAllocationTable[cBlockAllocationTableEntry]));
/*
* Clip read range to remain in this data block.
*/
/*
* If the block is not allocated the content of the entry is ~0
*/
else
{
uVhdOffset = ((uint64_t)pImage->pBlockAllocationTable[cBlockAllocationTableEntry] + pImage->cDataBlockBitmapSectors + cBATEntryIndex) * VHD_SECTOR_SIZE;
/* Read in the block's bitmap. */
if (RT_SUCCESS(rc))
{
{
cSectors = 1;
/*
* The first sector being read is marked dirty, read as much as we
* can from child. Note that only sectors that are marked dirty
* must be read from child.
*/
{
cSectors++;
}
}
else
{
/*
* The first sector being read is marked clean, so we should read from
* our parent instead, but only as much as there are the following
* clean sectors, because the block may still contain dirty sectors
* further on. We just need to compute the number of clean sectors
* and pass it to our caller along with the notification that they
* should be read from the parent.
*/
cSectors = 1;
{
cSectors++;
}
}
}
else
}
}
else
if (pcbActuallyRead)
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnWrite */
{
LogFlowFunc(("pBackendData=%p uOffset=%llu pIoCtx=%#p cbWrite=%u pcbWriteProcess=%p pcbPreRead=%p pcbPostRead=%p fWrite=%u\n",
if (pImage->pBlockAllocationTable)
{
/*
* Get the data block first.
*/
/*
* Clip write range.
*/
/*
* If the block is not allocated the content of the entry is ~0
* and we need to allocate a new block. Note that while blocks are
* allocated with a relatively big granularity, each sector has its
* own bitmap entry, indicating whether it has been written or not.
* So that means for the purposes of the higher level that the
* granularity is invisible. This means there's no need to return
* VERR_VD_BLOCK_FREE unless the block hasn't been allocated yet.
*/
{
/* Check if the block allocation should be suppressed. */
if ( (fWrite & VD_WRITE_NO_ALLOC)
{
if (pcbWriteProcess)
return VERR_VD_BLOCK_FREE;
}
PVHDIMAGEEXPAND pExpand = (PVHDIMAGEEXPAND)RTMemAllocZ(RT_OFFSETOF(VHDIMAGEEXPAND, au8Bitmap[pImage->cDataBlockBitmapSectors * VHD_SECTOR_SIZE]));
bool fIoInProgress = false;
if (!pExpand)
return VERR_NO_MEMORY;
/* Set the bits for all sectors having been written. */
{
/* No need to check for a changed value because this is an initial write. */
}
do
{
/*
* Start with the sector bitmap.
*/
pExpand);
if (RT_SUCCESS(rc))
VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_BLOCKBITMAP_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_SUCCESS);
else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
fIoInProgress = true;
else
{
VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_BLOCKBITMAP_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_USERBLOCK_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_BAT_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_FOOTER_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
break;
}
/*
* Write the new block at the current end of the file.
*/
pImage->uCurrentEndOfFile + (pImage->cDataBlockBitmapSectors + (cSector % pImage->cSectorsPerDataBlock)) * VHD_SECTOR_SIZE,
pExpand);
if (RT_SUCCESS(rc))
VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_USERBLOCK_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_SUCCESS);
else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
fIoInProgress = true;
else
{
VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_USERBLOCK_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_BAT_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_FOOTER_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
break;
}
/*
* Write entry in the BAT.
*/
pExpand);
if (RT_SUCCESS(rc))
VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_BAT_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_SUCCESS);
else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
fIoInProgress = true;
else
{
VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_BAT_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_FOOTER_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
break;
}
/*
* Set the new end of the file and link the new block into the BAT.
*/
pImage->uCurrentEndOfFile += pImage->cDataBlockBitmapSectors * VHD_SECTOR_SIZE + pImage->cbDataBlock;
/* Update the footer. */
pExpand);
if (RT_SUCCESS(rc))
VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_FOOTER_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_SUCCESS);
else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
fIoInProgress = true;
else
{
VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_FOOTER_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
break;
}
} while (0);
if (!fIoInProgress)
else
}
else
{
/*
* Calculate the real offset in the file.
*/
uVhdOffset = ((uint64_t)pImage->pBlockAllocationTable[cBlockAllocationTableEntry] + pImage->cDataBlockBitmapSectors + cBATEntryIndex) * VHD_SECTOR_SIZE;
/* Read in the block's bitmap. */
if (RT_SUCCESS(rc))
{
/* Write data. */
{
bool fChanged = false;
/* Set the bits for all sectors having been written. */
{
}
/* Only write the bitmap if it was changed. */
if (fChanged)
{
/*
* Write the bitmap back.
*
* @note We don't have a completion callback here because we
* can't do anything if the write fails for some reason.
* by the generic VD layer already and we don't need
* to rollback anything here.
*/
}
}
}
}
}
else
if (pcbWriteProcess)
/* Stay on the safe side. Do not run the risk of confusing the higher
* level, as that can be pretty lethal to image consistency. */
*pcbPreRead = 0;
*pcbPostRead = 0;
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnFlush */
{
/* No need to write anything here. Data is always updated on a write. */
}
/** @copydoc VBOXHDDBACKEND::pfnGetVersion */
{
unsigned ver = 0;
if (pImage)
return ver;
}
/** @copydoc VBOXHDDBACKEND::pfnGetSectorSize */
{
if (pImage)
cb = 512;
return cb;
}
/** @copydoc VBOXHDDBACKEND::pfnGetSize */
{
return cb;
}
/** @copydoc VBOXHDDBACKEND::pfnGetFileSize */
{
return cb;
}
/** @copydoc VBOXHDDBACKEND::pfnGetPCHSGeometry */
{
int rc;
if (pImage)
{
{
rc = VINF_SUCCESS;
}
else
}
else
LogFlowFunc(("returns %Rrc (CHS=%u/%u/%u)\n", rc, pImage->PCHSGeometry.cCylinders, pImage->PCHSGeometry.cHeads, pImage->PCHSGeometry.cSectors));
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnSetPCHSGeometry */
{
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 */
{
int rc;
if (pImage)
{
{
rc = VINF_SUCCESS;
}
else
}
else
LogFlowFunc(("returns %Rrc (CHS=%u/%u/%u)\n", rc, pImage->LCHSGeometry.cCylinders, pImage->LCHSGeometry.cHeads, pImage->LCHSGeometry.cSectors));
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnSetLCHSGeometry */
{
int rc;
if (pImage)
{
{
goto out;
}
rc = VINF_SUCCESS;
}
else
out:
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnGetImageFlags */
{
unsigned uImageFlags;
if (pImage)
else
uImageFlags = 0;
return uImageFlags;
}
/** @copydoc VBOXHDDBACKEND::pfnGetOpenFlags */
{
unsigned uOpenFlags;
if (pImage)
else
uOpenFlags = 0;
return uOpenFlags;
}
/** @copydoc VBOXHDDBACKEND::pfnSetOpenFlags */
{
int rc;
/* Image must be opened and the new flags must be valid. */
{
goto out;
}
/* Implement this operation via reopening the image. */
if (RT_FAILURE(rc))
goto out;
out:
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnGetComment */
{
LogFlowFunc(("pBackendData=%#p pszComment=%#p cbComment=%zu\n", pBackendData, pszComment, cbComment));
int rc;
if (pImage)
else
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnSetComment */
{
int rc;
if (pImage)
{
else
}
else
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnGetUuid */
{
int rc;
if (pImage)
{
rc = VINF_SUCCESS;
}
else
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnSetUuid */
{
int rc;
if (pImage)
{
{
/* Update the footer copy. It will get written to disk when the image is closed. */
/* Update checksum. */
pImage->vhdFooterCopy.Checksum = RT_H2BE_U32(vhdChecksum(&pImage->vhdFooterCopy, sizeof(VHDFooter)));
/* Need to update the dynamic disk header to update the disk footer copy at the beginning. */
pImage->fDynHdrNeedsUpdate = true;
rc = VINF_SUCCESS;
}
else
}
else
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnGetModificationUuid */
{
int rc;
if (pImage)
else
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnSetModificationUuid */
{
int rc;
if (pImage)
{
else
}
else
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnGetParentUuid */
{
int rc;
if (pImage)
{
rc = VINF_SUCCESS;
}
else
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnSetParentUuid */
{
{
{
pImage->fDynHdrNeedsUpdate = true;
}
else
}
else
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnGetParentModificationUuid */
{
int rc;
if (pImage)
else
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnSetParentModificationUuid */
{
int rc;
if (pImage)
{
else
}
else
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnDump */
{
if (pImage)
{
}
}
/** @copydoc VBOXHDDBACKEND::pfnGetTimestamp */
{
if (pImage)
else
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnGetParentTimeStamp */
{
if (pImage)
else
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnSetParentTimeStamp */
{
if (pImage)
{
else
{
pImage->fDynHdrNeedsUpdate = true;
}
}
else
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnGetParentFilename */
{
if (pImage)
else
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnSetParentFilename */
{
if (pImage)
{
else
{
if (pImage->pszParentFilename)
if (!pImage->pszParentFilename)
rc = VERR_NO_MEMORY;
else
pImage->fDynHdrNeedsUpdate = true;
}
}
else
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnCompact */
{
if (pIfParentState)
{
}
if (pIfProgress)
{
}
do
{
/* Reject fixed images as they don't have a BAT. */
{
break;
}
if (pfnParentRead)
{
}
unsigned cBlocksAllocated = 0;
unsigned cBlocksToMove = 0;
/* Count the number of allocated blocks and find the start offset for the data blocks. */
for (unsigned i = 0; i < cBlocks; i++)
if (paBat[i] != ~0U)
{
if (paBat[i] < offBlocksStart)
offBlocksStart = paBat[i];
}
if (!cBlocksAllocated)
{
/* Nothing to do. */
rc = VINF_SUCCESS;
break;
}
/* Invalidate the back resolving array. */
for (unsigned i = 0; i < cBlocksAllocated; i++)
paBlocks[i] = ~0U;
/* Fill the back resolving table. */
for (unsigned i = 0; i < cBlocks; i++)
if (paBat[i] != ~0U)
{
if ( idxBlock < cBlocksAllocated
else
{
/* The image is in an inconsistent state. Don't go further. */
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++)
{
if (paBat[i] != ~0U)
{
/* Block present in image file, read relevant data. */
if (RT_FAILURE(rc))
break;
{
paBat[i] = ~0;
/* Adjust progress info, one block to be relocated. */
}
else if (pfnParentRead)
{
if (RT_FAILURE(rc))
break;
{
paBat[i] = ~0U;
/* Adjust progress info, one block to be relocated. */
}
}
}
{
if (RT_FAILURE(rc))
break;
}
}
if (RT_SUCCESS(rc))
{
/* Fill bubbles with other data (if available). */
unsigned cBlocksMoved = 0;
size_t cbBlock = pImage->cbDataBlock + pImage->cbDataBlockBitmap; /** < Size of whole block containing the bitmap and the user data. */
/* Allocate data buffer to hold the data block and allocation bitmap in front of the actual data. */
for (unsigned i = 0; i < cBlocksAllocated; i++)
{
if (uBlock == ~0U)
{
unsigned uBlockData = ~0U;
while (uBlockUsedPos > i && uBlockData == ~0U)
{
}
/* Terminate early if there is no block which needs copying. */
if (uBlockUsedPos == i)
break;
+ (offBlocksStart * VHD_SECTOR_SIZE);
if (RT_FAILURE(rc))
break;
+ (offBlocksStart * VHD_SECTOR_SIZE);
if (RT_FAILURE(rc))
break;
paBat[uBlockData] = i*(pImage->cSectorsPerDataBlock + pImage->cDataBlockBitmapSectors) + offBlocksStart;
/* Truncate the file but leave enough room for the footer to avoid
* races if other processes fill the whole harddisk. */
if (RT_FAILURE(rc))
break;
/* Update pointers and write footer. */
/* We're kinda screwed if this failes. */
if (RT_FAILURE(rc))
break;
paBlocks[i] = uBlockData;
paBlocks[uBlockUsedPos] = ~0U;
cBlocksMoved++;
}
{
if (RT_FAILURE(rc))
break;
}
}
}
/* Write the new BAT in any case. */
} while (0);
if (paBlocks)
if (pvParent)
if (pvBuf)
{
}
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnResize */
unsigned uPercentStart, unsigned uPercentSpan,
{
if (pIfProgress)
{
}
/* Making the image smaller is not supported at the moment. */
{
unsigned cBlocksAllocated = 0;
size_t cbBlock = pImage->cbDataBlock + pImage->cbDataBlockBitmap; /** < Size of a block including the sector bitmap. */
uint32_t cBlocksNew = cbSize / pImage->cbDataBlock; /** < New number of blocks in the image after the resize */
cBlocksNew++;
uint32_t cBlocksOld = pImage->cBlockAllocationTableEntries; /** < Number of blocks before the resize. */
uint64_t cbBlockspaceNew = RT_ALIGN_32(cBlocksNew * sizeof(uint32_t), VHD_SECTOR_SIZE); /** < Required space for the block array after the resize. */
uint64_t offStartDataNew = RT_ALIGN_32(pImage->uBlockAllocationTableOffset + cbBlockspaceNew, VHD_SECTOR_SIZE); /** < New start offset for block data after the resize */
/* Go through the BAT and find the data start offset. */
{
{
if (offStartBlock < offStartDataOld)
}
}
if ( offStartDataOld != offStartDataNew
&& cBlocksAllocated > 0)
{
/* Calculate how many sectors nee to be relocated. */
if (cbOverlapping % cbBlock)
cBlocksReloc++;
/* Do the relocation. */
/*
* Get the blocks we need to relocate first, they are appended to the end
* of the image.
*/
do
{
/* Allocate data buffer. */
if (!pvBuf)
{
rc = VERR_NO_MEMORY;
break;
}
/* Allocate buffer for overwriting with zeroes. */
if (!pvZero)
{
rc = VERR_NO_MEMORY;
break;
}
for (unsigned i = 0; i < cBlocksReloc; i++)
{
/* Search the index in the block table. */
{
{
/* Read data and append to the end of the image. */
if (RT_FAILURE(rc))
break;
if (RT_FAILURE(rc))
break;
/* Zero out the old block area. */
if (RT_FAILURE(rc))
break;
/* Update block counter. */
/* Continue with the next block. */
break;
}
}
if (RT_FAILURE(rc))
break;
}
} while (0);
if (pvBuf)
if (pvZero)
}
/*
* Relocation done, expand the block array and update the header with
* the new data.
*/
if (RT_SUCCESS(rc))
{
uint32_t *paBlocksNew = (uint32_t *)RTMemRealloc(pImage->pBlockAllocationTable, cBlocksNew * sizeof(uint32_t));
if (paBlocksNew)
{
/* Mark the new blocks as unallocated. */
}
else
rc = VERR_NO_MEMORY;
if (RT_SUCCESS(rc))
{
/* Write the block array before updating the rest. */
cBlocksNew * sizeof(uint32_t));
}
if (RT_SUCCESS(rc))
{
/* Update size and new block count. */
/* Update geometry. */
}
}
/* Update header information in base image file. */
pImage->fDynHdrNeedsUpdate = true;
}
/* Same size doesn't change the image at all. */
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnRepair */
{
LogFlowFunc(("pszFilename=\"%s\" pVDIfsDisk=%#p pVDIfsImage=%#p\n", pszFilename, pVDIfsDisk, pVDIfsImage));
int rc;
do
{
bool fDynamic = false;
bool fRepairFooter = false;
bool fRepairBat = false;
bool fRepairDynHeader = false;
: 0,
false /* fCreate */),
&pStorage);
if (RT_FAILURE(rc))
{
break;
}
if (RT_FAILURE(rc))
{
break;
}
{
"Image must be at least %u bytes (got %llu)",
break;
}
if (RT_FAILURE(rc))
{
break;
}
{
/* Dynamic images have a backup at the beginning of the image. */
if (RT_FAILURE(rc))
{
break;
}
/*
* Check for the header, if this fails the image is either completely corrupted
* and impossible to repair or in another format.
*/
{
"No valid VHD structures found");
break;
}
else
/* Remember to fix the footer structure. */
fRepairFooter = true;
}
/* Verify that checksums match. */
if (u32ChkSumOld != u32ChkSum)
{
fRepairFooter = true;
break;
}
{
fDynamic = false;
break;
fDynamic = true;
break;
fDynamic = true;
break;
default:
{
"VHD image type %u is not supported",
break;
}
}
/* Load and check dynamic disk header if required. */
if (fDynamic)
{
{
"VHD image type is not supported");
break;
}
&dynamicDiskHeader, sizeof(VHDDynamicDiskHeader));
if (RT_FAILURE(rc))
{
"Failed to read dynamic disk header (at %llu), %Rrc",
break;
}
/* Verify that checksums match. */
if (u32ChkSumOld != u32ChkSum)
{
vdIfErrorMessage(pIfError, "Checksum of dynamic disk header is invalid (should be %u got %u), repairing\n",
fRepairDynHeader = true;
break;
}
/* Read the block allocation table and fix any inconsistencies. */
{
"Block allocation table is not inside the image");
break;
}
if (!paBat)
{
"Could not allocate memory for the block allocation table (%u bytes)",
cBatEntries * sizeof(uint32_t));
break;
}
cBatEntries * sizeof(uint32_t));
if (RT_FAILURE(rc))
{
"Could not read block allocation table (at %llu), %Rrc",
break;
}
if (!pu32BlockBitmap)
{
"Failed to allocate memory for block bitmap");
break;
}
for (uint32_t i = 0; i < cBatEntries; i++)
{
if (paBat[i] < idxMinBlock)
idxMinBlock = paBat[i];
}
for (uint32_t i = 0; i < cBatEntries; i++)
{
{
/*
* Check that the offsets are valid (inside of the image) and
* that there are no double references.
*/
{
i, offBlock);
fRepairBat = true;
}
{
i);
fRepairBat = true;
}
&& ASMBitTestAndSet(pu32BlockBitmap, (uint32_t)((paBat[i] - idxMinBlock) / (cbBlock / VHD_SECTOR_SIZE))))
{
i);
fRepairBat = true;
}
}
}
}
/* Write repaired structures now. */
else if (!(fFlags & VD_REPAIR_DRY_RUN))
{
if (fRepairBat)
{
for (uint32_t i = 0; i < cBatEntries; i++)
cBatEntries * sizeof(uint32_t));
if (RT_FAILURE(rc))
{
"Could not write repaired block allocation table (at %llu), %Rrc",
break;
}
}
if (fRepairDynHeader)
{
sizeof(VHDDynamicDiskHeader));
if (RT_FAILURE(rc))
{
"Could not write repaired dynamic disk header (at %llu), %Rrc",
break;
}
}
if (fRepairFooter)
{
if (fDynamic)
{
/* Write backup at image beginning. */
sizeof(VHDFooter));
if (RT_FAILURE(rc))
{
"Could not write repaired backup footer (at %llu), %Rrc",
0, rc);
break;
}
}
sizeof(VHDFooter));
if (RT_FAILURE(rc))
{
"Could not write repaired footer (at %llu), %Rrc",
break;
}
}
}
} while(0);
if (paBat)
if (pu32BlockBitmap)
if (pStorage)
{
if (RT_SUCCESS(rc))
}
return rc;
}
{
/* pszBackendName */
"VHD",
/* cbSize */
sizeof(VBOXHDDBACKEND),
/* uBackendCaps */
/* paFileExtensions */
/* paConfigInfo */
NULL,
/* pfnCheckIfValid */
/* pfnOpen */
/* pfnCreate */
/* pfnRename */
/* pfnClose */
/* pfnRead */
/* pfnWrite */
/* pfnFlush */
/* pfnDiscard */
NULL,
/* pfnGetVersion */
/* pfnGetSectorSize */
/* 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 */
/* pfnComposeLocation */
/* pfnComposeName */
/* pfnCompact */
/* pfnResize */
/* pfnRepair */
/* pfnTraverseMetadata */
};