VBoxHDD.cpp revision 16a9adc14900ca18e6909679a579f6833425e030
/* $Id$ */
/** @file
* VBoxHDD - VBox HDD Container implementation.
*/
/*
* 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
#include <VBox/VBoxHDD-Plugin.h>
#define VBOXHDDDISK_SIGNATURE 0x6f0e2a7d
/** Buffer size used for merging images. */
/**
* VD async I/O interface storage descriptor.
*/
typedef struct VDIASYNCIOSTORAGE
{
/** File handle. */
/** Completion callback. */
/** Thread for async access. */
/**
* VBox HDD Container image descriptor.
*/
typedef struct VDIMAGE
{
/** Link to parent image descriptor, if any. */
/** Link to child image descriptor, if any. */
/** Container base filename. (UTF-8) */
char *pszFilename;
/** Data managed by the backend which keeps the actual info. */
void *pvBackendData;
/** Cached sanitized image flags. */
unsigned uImageFlags;
/** Image open flags (only those handled generically in this code and which
* the backends will never ever see). */
unsigned uOpenFlags;
/** Function pointers for the various backend methods. */
/** Pointer to list of VD interfaces, per-image. */
/**
* uModified bit flags.
*/
#define VD_IMAGE_MODIFIED_FLAG RT_BIT(0)
/**
* VBox HDD Container main structure, private part.
*/
struct VBOXHDD
{
/** Structure signature (VBOXHDDDISK_SIGNATURE). */
/** Number of opened images. */
unsigned cImages;
/** Base image. */
/** Last opened image in the chain.
* The same as pBase if only one image is used. */
/** Flags representing the modification state. */
unsigned uModified;
/** Cached size of this disk. */
/** Cached PCHS geometry for this disk. */
/** Cached LCHS geometry for this disk. */
/** Pointer to list of VD interfaces, per-disk. */
/** Pointer to the common interface structure for error reporting. */
/** Pointer to the error interface callbacks we use if available. */
/** Pointer to the optional thread synchronization interface. */
/** Pointer to the optional thread synchronization callbacks. */
/** Fallback async interface. */
/** Fallback async I/O interface callback table. */
};
/**
* VBox parent read descriptor, used internally for compaction.
*/
typedef struct VDPARENTSTATEDESC
{
/** Pointer to disk descriptor. */
/** Pointer to image descriptor. */
extern VBOXHDDBACKEND g_RawBackend;
extern VBOXHDDBACKEND g_VmdkBackend;
extern VBOXHDDBACKEND g_VDIBackend;
extern VBOXHDDBACKEND g_VhdBackend;
extern VBOXHDDBACKEND g_ParallelsBackend;
#ifdef VBOX_WITH_ISCSI
extern VBOXHDDBACKEND g_ISCSIBackend;
#endif
static unsigned g_cBackends = 0;
static PVBOXHDDBACKEND aStaticBackends[] =
{
#ifdef VBOX_WITH_ISCSI
#endif
};
/**
* internal: add several backends.
*/
{
if (RT_UNLIKELY(!pTmp))
return VERR_NO_MEMORY;
g_apBackends = pTmp;
g_cBackends += cBackends;
return VINF_SUCCESS;
}
/**
* internal: add single backend.
*/
{
}
/**
* internal: issue error message.
*/
const char *pszFormat, ...)
{
pDisk->pInterfaceErrorCallbacks->pfnError(pDisk->pInterfaceError->pvUser, rc, RT_SRC_POS_ARGS, pszFormat, va);
return rc;
}
/**
* internal: thread synchronization, start read.
*/
{
int rc = VINF_SUCCESS;
return rc;
}
/**
* internal: thread synchronization, finish read.
*/
{
int rc = VINF_SUCCESS;
return rc;
}
/**
* internal: thread synchronization, start write.
*/
{
int rc = VINF_SUCCESS;
return rc;
}
/**
* internal: thread synchronization, finish write.
*/
{
int rc = VINF_SUCCESS;
return rc;
}
/**
* internal: find image format backend.
*/
{
int rc = VINF_SUCCESS;
if (!g_apBackends)
VDInit();
for (unsigned i = 0; i < g_cBackends; i++)
{
{
pBackend = g_apBackends[i];
break;
}
}
return rc;
}
/**
* internal: add image structure to the end of images list.
*/
{
{
}
else
{
}
}
/**
* internal: remove image structure from the images list.
*/
{
else
else
}
/**
* internal: find image by index into the images list.
*/
{
if (nImage == VD_LAST_IMAGE)
{
nImage--;
}
return pImage;
}
/**
* internal: read the specified amount of data in whatever blocks the backend
* will give us.
*/
{
int rc;
/* Loop until all read. */
do
{
/* Search for image with allocated block. Do not attempt to read more
* than the previous reads marked as valid. Otherwise this would return
* stale data when different block sizes are used for the images. */
cbThisRead = cbRead;
/*
* Try to read from the given image.
* If the block is not allocated read from override chain if present.
*/
&cbThisRead);
if (rc == VERR_VD_BLOCK_FREE)
{
{
&cbThisRead);
}
}
/* No image in the chain contains the data for the block. */
if (rc == VERR_VD_BLOCK_FREE)
{
rc = VINF_SUCCESS;
}
cbRead -= cbThisRead;
uOffset += cbThisRead;
return rc;
}
/**
* internal: parent image read wrapper for compacting.
*/
{
}
/**
* internal: mark the disk as not modified.
*/
{
{
/* generate new last-modified uuid */
{
RTUuidCreate(&Uuid);
&Uuid);
}
}
}
/**
* internal: mark the disk as modified.
*/
{
{
/* First modify, so create a UUID and ensure it's written to disk. */
}
}
/**
* internal: write a complete block (only used for diff images), taking the
* remaining data from parent images. This implementation does not optimize
* anything (except that it tries to read only that portions from parent
* images that are really needed).
*/
void *pvTmp)
{
int rc = VINF_SUCCESS;
/* Read the data that goes before the write to fill the block. */
if (cbPreRead)
{
if (RT_FAILURE(rc))
return rc;
}
/* Copy the data to the right place in the buffer. */
/* Read the data that goes after the write to fill the block. */
if (cbPostRead)
{
/* If we have data to be written, use that instead of reading
* data from the image. */
if (cbWrite > cbThisWrite)
else
cbWriteCopy = 0;
/* Figure out how much we cannnot read from the image, because
* the last block to write might exceed the nominal size of the
* image for technical reasons. */
else
cbFill = 0;
/* The rest must be read from the image. */
/* Now assemble the remaining data. */
if (cbWriteCopy)
if (cbReadImage)
if (RT_FAILURE(rc))
return rc;
/* Zero out the remainder of this block. Will never be visible, as this
* is beyond the limit of the image. */
if (cbFill)
'\0', cbFill);
}
/* Write the full block to the virtual disk. */
Assert(cbPostRead == 0);
return rc;
}
/**
* internal: write a complete block (only used for diff images), taking the
* remaining data from parent images. This implementation optimizes out writes
* that do not change the data relative to the state as of the parent images.
* All backends which support differential/growing images support this.
*/
void *pvTmp)
{
size_t cbWriteCopy = 0;
size_t cbReadImage = 0;
int rc;
if (cbPostRead)
{
/* Figure out how much we cannnot read from the image, because
* the last block to write might exceed the nominal size of the
* image for technical reasons. */
/* If we have data to be written, use that instead of reading
* data from the image. */
if (cbWrite > cbThisWrite)
/* The rest must be read from the image. */
}
/* Read the entire data of the block so that we can compare whether it will
* be modified by the write or not. */
if (RT_FAILURE(rc))
return rc;
/* Check if the write would modify anything in this block. */
{
/* Block is completely unchanged, so no need to write anything. */
return VINF_SUCCESS;
}
/* Copy the data to the right place in the buffer. */
/* Handle the data that goes after the write to fill the block. */
if (cbPostRead)
{
/* Now assemble the remaining data. */
if (cbWriteCopy)
/* Zero out the remainder of this block. Will never be visible, as this
* is beyond the limit of the image. */
if (cbFill)
'\0', cbFill);
}
/* Write the full block to the virtual disk. */
Assert(cbPostRead == 0);
return rc;
}
/**
* internal: write buffer to the image, taking care of block boundaries and
* write optimizations.
*/
{
int rc;
unsigned fWrite;
/* Loop until all written. */
do
{
/* Try to write the possibly partial block to the last opened image.
* This works when the block is already allocated in this image or
* if it is a full-block write (and allocation isn't suppressed below).
* For image formats which don't support zero blocks, it's beneficial
* to avoid unnecessarily allocating unchanged blocks. This prevents
* unwanted expanding of images. VMDK is an example. */
? 0 : VD_WRITE_NO_ALLOC;
&cbPostRead, fWrite);
if (rc == VERR_VD_BLOCK_FREE)
{
{
/* Optimized write, suppress writing to a so far unallocated
* block if the data is in fact not changed. */
}
else
{
/* Normal write, not optimized in any way. The block will
* be written no matter what. This will usually (unless the
* backend has some further optimization enabled) cause the
* block to be allocated. */
}
if (RT_FAILURE(rc))
break;
}
cbWrite -= cbThisWrite;
uOffset += cbThisWrite;
return rc;
}
/**
* internal: scans plugin directory and loads the backends have been found.
*/
static int vdLoadDynamicBackends()
{
int rc = VINF_SUCCESS;
/* Enumerate plugin backends. */
char szPath[RTPATH_MAX];
if (RT_FAILURE(rc))
return rc;
/* To get all entries with VBoxHDD as prefix. */
char *pszPluginFilter;
if (RT_FAILURE(rc))
{
rc = VERR_NO_MEMORY;
return rc;
}
/* The plugins are in the same directory as the other shared libs. */
if (RT_FAILURE(rc))
{
/* On Windows the above immediately signals that there are no
* files matching, while on other platforms enumerating the
* files below fails. Either way: no plugins. */
goto out;
}
if (!pPluginDirEntry)
{
rc = VERR_NO_MEMORY;
goto out;
}
while ((rc = RTDirReadEx(pPluginDir, pPluginDirEntry, &cbPluginDirEntry, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK)) != VERR_NO_MORE_FILES)
{
char *pszPluginPath = NULL;
if (rc == VERR_BUFFER_OVERFLOW)
{
/* allocate new buffer. */
/* Retry. */
rc = RTDirReadEx(pPluginDir, pPluginDirEntry, &cbPluginDirEntry, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
if (RT_FAILURE(rc))
break;
}
else if (RT_FAILURE(rc))
break;
/* We got the new entry. */
continue;
/* Prepend the path to the libraries. */
if (RT_FAILURE(rc))
{
rc = VERR_NO_MEMORY;
break;
}
if (RT_SUCCESS(rc))
{
{
LogFunc(("error resolving the entry point %s in plugin %s, rc=%Rrc, pfnHDDFormat=%#p\n", VBOX_HDDFORMAT_LOAD_NAME, pPluginDirEntry->szName, rc, pfnHDDFormatLoad));
if (RT_SUCCESS(rc))
}
if (RT_SUCCESS(rc))
{
/* Get the function table. */
{
}
else
LogFunc(("ignored plugin '%s': pBackend->cbSize=%d rc=%Rrc\n", pszPluginPath, pBackend->cbSize, rc));
}
else
if (RT_FAILURE(rc))
}
}
out:
if (rc == VERR_NO_MORE_FILES)
rc = VINF_SUCCESS;
if (pPluginDirEntry)
if (pPluginDir)
return rc;
}
/**
* VD async I/O interface open callback.
*/
void **ppStorage)
{
if (!pStorage)
return VERR_NO_MEMORY;
else
fOpen |= RTFILE_O_CREATE;
else
fOpen |= RTFILE_O_OPEN;
/* Open the file. */
if (RT_SUCCESS(rc))
{
return VINF_SUCCESS;
}
return rc;
}
/**
* VD async I/O interface close callback.
*/
{
return VINF_SUCCESS;
}
/**
* VD async I/O interface callback for retrieving the file size.
*/
{
}
/**
* VD async I/O interface callback for setting the file size.
*/
{
}
/**
* VD async I/O interface callback for a synchronous write to the file.
*/
{
}
/**
* VD async I/O interface callback for a synchronous read from the file.
*/
{
}
/**
* VD async I/O interface callback for a synchronous flush of the file data.
*/
{
}
/**
* VD async I/O interface callback for a asynchronous read from the file.
*/
void **ppTask)
{
return VERR_NOT_IMPLEMENTED;
}
/**
* VD async I/O interface callback for a asynchronous write to the file.
*/
void **ppTask)
{
return VERR_NOT_IMPLEMENTED;
}
/**
* VD async I/O interface callback for a asynchronous flush of the file data.
*/
void *pvCompletion, void **ppTask)
{
return VERR_NOT_IMPLEMENTED;
}
/**
* internal: send output to the log (unconditionally).
*/
{
return VINF_SUCCESS;
}
/**
* Initializes HDD backends.
*
* @returns VBox status code.
*/
VBOXDDU_DECL(int) VDInit(void)
{
if (RT_SUCCESS(rc))
rc = vdLoadDynamicBackends();
LogRel(("VDInit finished\n"));
return rc;
}
/**
* Destroys loaded HDD backends.
*
* @returns VBox status code.
*/
VBOXDDU_DECL(int) VDShutdown(void)
{
unsigned cBackends = g_cBackends;
if (!pBackends)
return VERR_INTERNAL_ERROR;
g_cBackends = 0;
g_apBackends = NULL;
for (unsigned i = 0; i < cBackends; i++)
return VINF_SUCCESS;
}
/**
* Lists all HDD backends and their capabilities in a caller-provided buffer.
*
* @returns VBox status code.
* VERR_BUFFER_OVERFLOW if not enough space is passed.
* @param cEntriesAlloc Number of list entries available.
* @param pEntries Pointer to array for the entries.
* @param pcEntriesUsed Number of entries returned.
*/
unsigned *pcEntriesUsed)
{
int rc = VINF_SUCCESS;
unsigned cEntries = 0;
LogFlowFunc(("cEntriesAlloc=%u pEntries=%#p pcEntriesUsed=%#p\n", cEntriesAlloc, pEntries, pcEntriesUsed));
/* Check arguments. */
("cEntriesAlloc=%u\n", cEntriesAlloc),
("pEntries=%#p\n", pEntries),
("pcEntriesUsed=%#p\n", pcEntriesUsed),
if (!g_apBackends)
VDInit();
if (cEntriesAlloc < g_cBackends)
{
return VERR_BUFFER_OVERFLOW;
}
for (unsigned i = 0; i < g_cBackends; i++)
{
}
return rc;
}
/**
* Lists the capablities of a backend indentified by its name.
*
* @returns VBox status code.
* @param pszBackend The backend name.
* @param pEntries Pointer to an entry.
*/
{
/* Check arguments. */
("pszBackend=%#p\n", pszBackend),
("pEntry=%#p\n", pEntry),
if (!g_apBackends)
VDInit();
/* Go through loaded backends. */
for (unsigned i = 0; i < g_cBackends; i++)
{
{
return VINF_SUCCESS;
}
}
return VERR_NOT_FOUND;
}
/**
* Allocates and initializes an empty HDD container.
* No image files are opened.
*
* @returns VBox status code.
* @param pVDIfsDisk Pointer to the per-disk VD interface list.
* @param ppDisk Where to store the reference to HDD container.
*/
{
int rc = VINF_SUCCESS;
do
{
/* Check arguments. */
("ppDisk=%#p\n", ppDisk),
if (pDisk)
{
if (pDisk->pInterfaceError)
if (pDisk->pInterfaceThreadSync)
/* Use the fallback async I/O interface if the caller doesn't provide one. */
if (!pVDIfAsyncIO)
{
}
}
else
{
rc = VERR_NO_MEMORY;
break;
}
} while (0);
return rc;
}
/**
* Destroys HDD container.
* If container has opened image files they will be closed.
*
* @param pDisk Pointer to HDD container.
*/
{
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
} while (0);
LogFlowFunc(("returns\n"));
}
/**
* Try to get the backend name which can use this image.
*
* @returns VBox status code.
* VINF_SUCCESS if a plugin was found.
* ppszFormat contains the string which can be used as backend name.
* VERR_NOT_SUPPORTED if no backend was found.
* @param pVDIfsDisk Pointer to the per-disk VD interface list.
* @param pszFilename Name of the image file for which the backend is queried.
* @param ppszFormat Receives pointer of the UTF-8 string which contains the format name.
* The returned pointer must be freed using RTStrFree().
*/
{
int rc = VERR_NOT_SUPPORTED;
/* Check arguments. */
("ppszFormat=%#p\n", ppszFormat),
if (!g_apBackends)
VDInit();
/* Use the fallback async I/O interface if the caller doesn't provide one. */
if (!pVDIfAsyncIO)
{
}
/* Find the backend supporting this file format. */
for (unsigned i = 0; i < g_cBackends; i++)
{
if (g_apBackends[i]->pfnCheckIfValid)
{
if ( RT_SUCCESS(rc)
/* The correct backend has been found, but there is a small
* incompatibility so that the file cannot be used. Stop here
* and signal success - the actual open will of course fail,
* but that will create a really sensible error message. */
|| ( rc != VERR_VD_GEN_INVALID_HEADER
&& rc != VERR_VD_VDI_INVALID_HEADER
&& rc != VERR_VD_VHD_INVALID_HEADER
&& rc != VERR_VD_RAW_INVALID_HEADER))
{
/* Copy the name into the new string. */
if (!pszFormat)
{
rc = VERR_NO_MEMORY;
break;
}
*ppszFormat = pszFormat;
rc = VINF_SUCCESS;
break;
}
}
}
return rc;
}
/**
* Opens an image file.
*
* The first opened image file in HDD container must have a base image type,
* others (next opened images) must be a differencing or undo images.
* Linkage is checked for differencing image to be in consistence with the previously opened image.
* mode, then the last image is reopened in read-only with deny write sharing mode. This allows
* other processes to use images in read-only mode too.
*
* Use VDIsReadOnly to check open mode.
*
* @returns VBox status code.
* @param pDisk Pointer to HDD container.
* @param pszBackend Name of the image file backend to use.
* @param pszFilename Name of the image file to open.
* @param uOpenFlags Image file open mode, see VD_OPEN_FLAGS_* constants.
* @param pVDIfsImage Pointer to the per-image VD interface list.
*/
const char *pszFilename, unsigned uOpenFlags,
{
int rc = VINF_SUCCESS;
int rc2;
bool fLockWrite = false;
LogFlowFunc(("pDisk=%#p pszBackend=\"%s\" pszFilename=\"%s\" uOpenFlags=%#x, pVDIfsImage=%#p\n",
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
/* Check arguments. */
("uOpenFlags=%#x\n", uOpenFlags),
/* Set up image descriptor. */
if (!pImage)
{
rc = VERR_NO_MEMORY;
break;
}
if (!pImage->pszFilename)
{
rc = VERR_NO_MEMORY;
break;
}
if (RT_FAILURE(rc))
break;
{
break;
}
&pImage->pvBackendData);
/* If the open in read-write mode failed, retry in read-only mode. */
if (RT_FAILURE(rc))
{
if (!(uOpenFlags & VD_OPEN_FLAGS_READONLY)
&& ( rc == VERR_ACCESS_DENIED
|| rc == VERR_PERMISSION_DENIED
|| rc == VERR_WRITE_PROTECT
|| rc == VERR_SHARING_VIOLATION
|| rc == VERR_FILE_LOCK_FAILED))
&pImage->pvBackendData);
if (RT_FAILURE(rc))
{
break;
}
}
/* Lock disk for writing, as we modify pDisk information below. */
fLockWrite = true;
/* Check image type. As the image itself has only partial knowledge
* whether it's a base image or not, this info is derived here. The
* base image can be fixed or normal, all others must be normal or
* diff images. Some image formats don't distinguish between normal
* and diff images, so this must be corrected here. */
unsigned uImageFlags;
if (RT_FAILURE(rc))
if ( RT_SUCCESS(rc)
&& !(uOpenFlags & VD_OPEN_FLAGS_INFO))
{
&& (uImageFlags & VD_IMAGE_FLAGS_DIFF))
{
break;
}
{
if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
{
break;
}
else
}
}
/* Force sane optimization settings. It's not worth avoiding writes
* to fixed size images. The overhead would have almost no payback. */
if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
/** @todo optionally check UUIDs */
/* Cache disk information. */
/* Cache PCHS geometry. */
&pDisk->PCHSGeometry);
if (RT_FAILURE(rc2))
{
}
else
{
/* Make sure the PCHS geometry is properly clipped. */
}
/* Cache LCHS geometry. */
&pDisk->LCHSGeometry);
if (RT_FAILURE(rc2))
{
}
else
{
/* Make sure the LCHS geometry is properly clipped. */
}
{
/* Switch previous image to read-only mode. */
unsigned uOpenFlagsPrevImg;
if (!(uOpenFlagsPrevImg & VD_OPEN_FLAGS_READONLY))
{
}
}
if (RT_SUCCESS(rc))
{
/* Image successfully opened, make it the last image. */
if (!(uOpenFlags & VD_OPEN_FLAGS_READONLY))
}
else
{
/* Error detected, but image opened. Close image. */
}
} while (0);
if (RT_UNLIKELY(fLockWrite))
{
}
if (RT_FAILURE(rc))
{
if (pImage)
{
if (pImage->pszFilename)
}
}
return rc;
}
/**
* Creates and opens a new base image file.
*
* @returns VBox status code.
* @param pDisk Pointer to HDD container.
* @param pszBackend Name of the image file backend to use.
* @param pszFilename Name of the image file to create.
* @param cbSize Image size in bytes.
* @param uImageFlags Flags specifying special image features.
* @param pszComment Pointer to image comment. NULL is ok.
* @param pPCHSGeometry Pointer to physical disk geometry <= (16383,16,63). Not NULL.
* @param pLCHSGeometry Pointer to logical disk geometry <= (x,255,63). Not NULL.
* @param pUuid New UUID of the image. If NULL, a new UUID is created.
* @param uOpenFlags Image file open mode, see VD_OPEN_FLAGS_* constants.
* @param pVDIfsImage Pointer to the per-image VD interface list.
* @param pVDIfsOperation Pointer to the per-operation VD interface list.
*/
unsigned uImageFlags, const char *pszComment,
{
int rc = VINF_SUCCESS;
int rc2;
bool fLockWrite = false, fLockRead = false;
LogFlowFunc(("pDisk=%#p pszBackend=\"%s\" pszFilename=\"%s\" cbSize=%llu uImageFlags=%#x pszComment=\"%s\" PCHS=%u/%u/%u LCHS=%u/%u/%u Uuid=%RTuuid uOpenFlags=%#x pVDIfsImage=%#p pVDIfsOperation=%#p\n",
if (pIfProgress)
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
/* Check arguments. */
("cbSize=%llu\n", cbSize),
("uImageFlags=%#x\n", uImageFlags),
/* The PCHS geometry fields may be 0 to leave it for later. */
("pPCHSGeometry=%#p PCHS=%u/%u/%u\n", pPCHSGeometry,
/* The LCHS geometry fields may be 0 to leave it to later autodetection. */
("pLCHSGeometry=%#p LCHS=%u/%u/%u\n", pLCHSGeometry,
/* The UUID may be NULL. */
("uOpenFlags=%#x\n", uOpenFlags),
/* Check state. Needs a temporary read lock. Holding the write lock
* all the time would be blocking other activities for too long. */
fLockRead = true;
("Create base image cannot be done with other images open\n"),
fLockRead = false;
/* Set up image descriptor. */
if (!pImage)
{
rc = VERR_NO_MEMORY;
break;
}
if (!pImage->pszFilename)
{
rc = VERR_NO_MEMORY;
break;
}
if (RT_FAILURE(rc))
break;
{
break;
}
/* Create UUID if the caller didn't specify one. */
if (!pUuid)
{
if (RT_FAILURE(rc))
{
N_("VD: cannot generate UUID for image '%s'"),
break;
}
}
0, 99,
&pImage->pvBackendData);
if (RT_SUCCESS(rc))
{
/* Force sane optimization settings. It's not worth avoiding writes
* to fixed size images. The overhead would have almost no payback. */
if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
/* Lock disk for writing, as we modify pDisk information below. */
fLockWrite = true;
/** @todo optionally check UUIDs */
/* Re-check state, as the lock wasn't held and another image
* creation call could have been done by another thread. */
("Create base image cannot be done with other images open\n"),
}
if (RT_SUCCESS(rc))
{
/* Cache disk information. */
/* Cache PCHS geometry. */
&pDisk->PCHSGeometry);
if (RT_FAILURE(rc2))
{
}
else
{
/* Make sure the CHS geometry is properly clipped. */
}
/* Cache LCHS geometry. */
&pDisk->LCHSGeometry);
if (RT_FAILURE(rc2))
{
}
else
{
/* Make sure the CHS geometry is properly clipped. */
}
/* Image successfully opened, make it the last image. */
if (!(uOpenFlags & VD_OPEN_FLAGS_READONLY))
}
else
{
/* Error detected, but image opened. Close and delete image. */
}
} while (0);
if (RT_UNLIKELY(fLockWrite))
{
}
else if (RT_UNLIKELY(fLockRead))
{
}
if (RT_FAILURE(rc))
{
if (pImage)
{
if (pImage->pszFilename)
}
}
return rc;
}
/**
* Creates and opens a new differencing image file in HDD container.
* See comments for VDOpen function about differencing images.
*
* @returns VBox status code.
* @param pDisk Pointer to HDD container.
* @param pszBackend Name of the image file backend to use.
* @param pszFilename Name of the differencing image file to create.
* @param uImageFlags Flags specifying special image features.
* @param pszComment Pointer to image comment. NULL is ok.
* @param pUuid New UUID of the image. If NULL, a new UUID is created.
* @param pParentUuid New parent UUID of the image. If NULL, the UUID is queried automatically.
* @param uOpenFlags Image file open mode, see VD_OPEN_FLAGS_* constants.
* @param pVDIfsImage Pointer to the per-image VD interface list.
* @param pVDIfsOperation Pointer to the per-operation VD interface list.
*/
const char *pszFilename, unsigned uImageFlags,
{
int rc = VINF_SUCCESS;
int rc2;
bool fLockWrite = false, fLockRead = false;
LogFlowFunc(("pDisk=%#p pszBackend=\"%s\" pszFilename=\"%s\" uImageFlags=%#x pszComment=\"%s\" Uuid=%RTuuid ParentUuid=%RTuuid uOpenFlags=%#x pVDIfsImage=%#p pVDIfsOperation=%#p\n",
if (pIfProgress)
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
/* Check arguments. */
("uImageFlags=%#x\n", uImageFlags),
/* The UUID may be NULL. */
/* The parent UUID may be NULL. */
("uOpenFlags=%#x\n", uOpenFlags),
/* Check state. Needs a temporary read lock. Holding the write lock
* all the time would be blocking other activities for too long. */
fLockRead = true;
("Create diff image cannot be done without other images open\n"),
fLockRead = false;
/* Set up image descriptor. */
if (!pImage)
{
rc = VERR_NO_MEMORY;
break;
}
if (!pImage->pszFilename)
{
rc = VERR_NO_MEMORY;
break;
}
if (RT_FAILURE(rc))
break;
{
break;
}
/* Create UUID if the caller didn't specify one. */
if (!pUuid)
{
if (RT_FAILURE(rc))
{
N_("VD: cannot generate UUID for image '%s'"),
break;
}
}
0, 99,
&pImage->pvBackendData);
if (RT_SUCCESS(rc))
{
/* Lock disk for writing, as we modify pDisk information below. */
fLockWrite = true;
/* Switch previous image to read-only mode. */
unsigned uOpenFlagsPrevImg;
if (!(uOpenFlagsPrevImg & VD_OPEN_FLAGS_READONLY))
{
}
/** @todo optionally check UUIDs */
/* Re-check state, as the lock wasn't held and another image
* creation call could have been done by another thread. */
("Create diff image cannot be done without other images open\n"),
}
if (RT_SUCCESS(rc))
{
{
Uuid = *pParentUuid;
}
else
{
&Uuid);
if (RT_SUCCESS(rc2))
}
&Uuid);
if (RT_SUCCESS(rc2))
&Uuid);
&ts);
if (RT_SUCCESS(rc2))
}
if (RT_SUCCESS(rc))
{
/* Image successfully opened, make it the last image. */
if (!(uOpenFlags & VD_OPEN_FLAGS_READONLY))
}
else
{
/* Error detected, but image opened. Close and delete image. */
}
} while (0);
if (RT_UNLIKELY(fLockWrite))
{
}
else if (RT_UNLIKELY(fLockRead))
{
}
if (RT_FAILURE(rc))
{
if (pImage)
{
if (pImage->pszFilename)
}
}
return rc;
}
/**
* As a side effect the source image and potentially the other images which
* are also merged to the destination are deleted from both the disk and the
* images in the HDD container.
*
* @returns VBox status code.
* @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
* @param pDisk Pointer to HDD container.
* @param nImageFrom Name of the image file to merge from.
* @param nImageTo Name of the image file to merge to.
* @param pVDIfsOperation Pointer to the per-operation VD interface list.
*/
{
int rc = VINF_SUCCESS;
int rc2;
bool fLockWrite = false, fLockRead = false;
LogFlowFunc(("pDisk=%#p nImageFrom=%u nImageTo=%u pVDIfsOperation=%#p\n",
if (pIfProgress)
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
/* For simplicity reasons lock for writing as the image reopen below
* might need it. After all the reopen is usually needed. */
fLockRead = true;
if (!pImageFrom || !pImageTo)
{
break;
}
/* Make sure destination image is writable. */
if (uOpenFlags & VD_OPEN_FLAGS_READONLY)
{
if (RT_FAILURE(rc))
break;
}
/* Get size of destination image. */
fLockRead = false;
/* Allocate tmp buffer. */
if (!pvBuf)
{
rc = VERR_NO_MEMORY;
break;
}
/* Merging is done directly on the images itself. This potentially
* causes trouble if the disk is full in the middle of operation. */
if (nImageFrom < nImageTo)
{
/* Merge parent state into child. This means writing all not
* allocated blocks in the destination image which are allocated in
* the images to be merged. */
do
{
/* Need to hold the write lock during a read-write operation. */
fLockWrite = true;
&cbThisRead);
if (rc == VERR_VD_BLOCK_FREE)
{
/* Search for image with allocated block. Do not attempt to
* read more than the previous reads marked as valid.
* Otherwise this would return stale data when different
* block sizes are used for the images. */
{
&cbThisRead);
}
if (rc != VERR_VD_BLOCK_FREE)
{
if (RT_FAILURE(rc))
break;
if (RT_FAILURE(rc))
break;
}
else
rc = VINF_SUCCESS;
}
else if (RT_FAILURE(rc))
break;
fLockWrite = false;
uOffset += cbThisRead;
{
/** @todo r=klaus: this can update the progress to the same
* percentage over and over again if the image format makes
* relatively small increments. */
if (RT_FAILURE(rc))
break;
}
}
else
{
/*
* We may need to update the parent uuid of the child coming after the
*
* This is done before we do the actual merge to prevent an incosistent
* chain if the mode change fails for some reason.
*/
if (pImageFrom->pNext)
{
if (uOpenFlags & VD_OPEN_FLAGS_READONLY)
{
if (RT_FAILURE(rc))
break;
}
}
/* Merge child state into parent. This means writing all blocks
* which are allocated in the image up to the source image to the
* destination image. */
do
{
/* Need to hold the write lock during a read-write operation. */
fLockWrite = true;
/* Search for image with allocated block. Do not attempt to
* read more than the previous reads marked as valid. Otherwise
* this would return stale data when different block sizes are
* used for the images. */
{
cbThisRead, &cbThisRead);
}
if (rc != VERR_VD_BLOCK_FREE)
{
if (RT_FAILURE(rc))
break;
if (RT_FAILURE(rc))
break;
}
else
rc = VINF_SUCCESS;
fLockWrite = true;
uOffset += cbThisRead;
{
/** @todo r=klaus: this can update the progress to the same
* percentage over and over again if the image format makes
* relatively small increments. */
if (RT_FAILURE(rc))
break;
}
}
/* Need to hold the write lock while finishing the merge. */
fLockWrite = true;
/* Update parent UUID so that image chain is consistent. */
if (nImageFrom < nImageTo)
{
if (pImageFrom->pPrev)
{
&Uuid);
}
else
RTUuidClear(&Uuid);
&Uuid);
}
else
{
/* Update the parent uuid of the child of the last merged image. */
if (pImageFrom->pNext)
{
&Uuid);
&Uuid);
}
}
/* Delete the no longer needed images. */
{
if (nImageFrom < nImageTo)
else
}
/* Make sure destination image is back to read only if necessary. */
{
if (RT_FAILURE(rc))
break;
}
/*
* Make sure the child is readonly
* for the child -> parent merge direction
* if neccessary.
*/
if ( nImageFrom > nImageTo
&& pImageChild
{
if (RT_FAILURE(rc))
break;
}
} while (0);
if (RT_UNLIKELY(fLockWrite))
{
}
else if (RT_UNLIKELY(fLockRead))
{
}
if (pvBuf)
return rc;
}
/**
* 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,
* 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.
* @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.
*/
const char *pszBackend, const char *pszFilename,
{
int rc = VINF_SUCCESS;
int rc2;
LogFlowFunc(("pDiskFrom=%#p nImage=%u pDiskTo=%#p pszBackend=\"%s\" pszFilename=\"%s\" fMoveByRename=%d cbSize=%llu pVDIfsOperation=%#p pDstVDIfsImage=%#p pDstVDIfsOperation=%#p\n",
pDiskFrom, nImage, pDiskTo, pszBackend, pszFilename, fMoveByRename, cbSize, pVDIfsOperation, pDstVDIfsImage, pDstVDIfsOperation));
if (pIfProgress)
if (pDstIfProgress)
do {
/* Check arguments. */
fLockReadFrom = true;
/* Move the image. */
{
/* Rename only works when backends are the same. */
if ( fMoveByRename
{
fLockReadFrom = false;
fLockWriteFrom = true;
rc = pImageFrom->Backend->pfnRename(pImageFrom->pvBackendData, pszFilename ? pszFilename : pImageFrom->pszFilename);
break;
}
* requested, but the rename attempt failed or it wasn't possible.
* Must now copy image to temp location. */
AssertReleaseMsgFailed(("VDCopy: moving by copy/delete not implemented\n"));
}
/* pszFilename is allowed to be NULL, as this indicates copy to the existing image. */
if (cbSizeFrom == 0)
{
break;
}
PDMMEDIAGEOMETRY PCHSGeometryFrom = {0, 0, 0};
PDMMEDIAGEOMETRY LCHSGeometryFrom = {0, 0, 0};
{
if (pDstUuid)
else
}
else
{
if (RT_FAILURE(rc))
}
rc = pImageFrom->Backend->pfnGetModificationUuid(pImageFrom->pvBackendData, &ImageModificationUuid);
if (RT_FAILURE(rc))
if (RT_FAILURE(rc))
rc = pImageFrom->Backend->pfnGetParentModificationUuid(pImageFrom->pvBackendData, &ParentModificationUuid);
if (RT_FAILURE(rc))
char szComment[1024];
if (RT_FAILURE(rc))
szComment[0] = '\0';
else
unsigned uOpenFlagsFrom;
fLockReadFrom = false;
if (pszFilename)
{
if (cbSize == 0)
cbSize = cbSizeFrom;
/* Create destination image with the properties of the source image. */
/** @todo replace the VDCreateDiff/VDCreateBase calls by direct
* calls to the backend. Unifies the code and reduces the API
* dependencies. Would also make the synchronization explicit. */
if (uImageFlags & VD_IMAGE_FLAGS_DIFF)
{
fLockWriteTo = true;
} else {
/** @todo hack to force creation of a fixed image for
* the RAW backend, which can't handle anything else. */
/* Fix broken PCHS geometry. Can happen for two reasons: either
* the backend mixes up PCHS and LCHS, or the application used
* to create the source image has put garbage in it. */
/** @todo double-check if the VHD backend correctly handles
* PCHS and LCHS geometry. also reconsider our current paranoia
* level when it comes to geometry settings here and in the
* backends. */
{
}
fLockWriteTo = true;
}
if (RT_FAILURE(rc))
break;
}
else
{
if (cbSizeTo == 0)
{
break;
}
if (cbSize == 0)
}
fLockWriteTo = false;
/* Allocate tmp buffer. */
if (!pvBuf)
{
rc = VERR_NO_MEMORY;
break;
}
/* Copy the data. */
do
{
/* 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. */
fLockReadFrom = true;
if (RT_FAILURE(rc))
break;
fLockReadFrom = false;
fLockWriteTo = true;
if (RT_FAILURE(rc))
break;
fLockWriteTo = false;
uOffset += cbThisRead;
{
/** @todo r=klaus: this can update the progress to the same
* percentage over and over again if the image format makes
* relatively small increments. */
if (RT_FAILURE(rc))
break;
}
{
/** @todo r=klaus: this can update the progress to the same
* percentage over and over again if the image format makes
* relatively small increments. */
if (RT_FAILURE(rc))
break;
}
if (RT_SUCCESS(rc))
{
fLockWriteTo = true;
/* Only set modification UUID if it is non-null, since the source
* backend might not provide a valid modification UUID. */
if (!RTUuidIsNull(&ImageModificationUuid))
/** @todo double-check this - it makes little sense to copy over the parent modification uuid,
* as the destination image can have a totally different parent. */
#if 0
#endif
}
} while (0);
{
/* Take the write lock only if it is not taken. Not worth making the
* above code even more complicated. */
if (RT_UNLIKELY(!fLockWriteTo))
{
fLockWriteTo = true;
}
/* Error detected, but new image created. Remove image from list. */
/* Close and delete image. */
/* Free remaining resources. */
if (pImageTo->pszFilename)
}
if (RT_UNLIKELY(fLockWriteTo))
{
}
if (RT_UNLIKELY(fLockWriteFrom))
{
}
else if (RT_UNLIKELY(fLockReadFrom))
{
}
if (pvBuf)
if (RT_SUCCESS(rc))
{
}
return rc;
}
/**
* Optimizes the storage consumption of an image. Typically the unused blocks
* have to be wiped with zeroes to achieve a substantial reduced storage use.
* Another optimization done is reordering the image blocks, which can provide
* a significant performance boost, as reads and writes tend to use less random
* file offsets.
*
* @return VBox status code.
* @return VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
* @return VERR_VD_IMAGE_READ_ONLY if image is not writable.
* @return VERR_NOT_SUPPORTED if this kind of image can be compacted, but
* the code for this isn't implemented yet.
* @param pDisk Pointer to HDD container.
* @param nImage Image number, counts from 0. 0 is always base image of container.
* @param pVDIfsOperation Pointer to the per-operation VD interface list.
*/
{
int rc = VINF_SUCCESS;
int rc2;
bool fLockRead = false, fLockWrite = false;
LogFlowFunc(("pDisk=%#p nImage=%u pVDIfsOperation=%#p\n",
if (pIfProgress)
do {
/* Check arguments. */
fLockRead = true;
/* If there is no compact callback for not file based backends then
* the backend doesn't need compaction. No need to make much fuss about
* this. For file based ones signal this as not yet supported. */
{
else
rc = VINF_SUCCESS;
break;
}
/* Insert interface for reading parent state into per-operation list,
* if there is a parent image. */
{
}
fLockRead = false;
fLockWrite = true;
0, 99,
} while (0);
if (RT_UNLIKELY(fLockWrite))
{
}
else if (RT_UNLIKELY(fLockRead))
{
}
if (pvBuf)
if (pvTmp)
if (RT_SUCCESS(rc))
{
}
return rc;
}
/**
* Closes the last opened image file in HDD container.
* If previous image file was opened in read-only mode (the normal case) and
* the last opened image is in read-write mode then the previous image will be
*
* @returns VBox status code.
* @returns VERR_VD_NOT_OPENED if no image is opened in HDD container.
* @param pDisk Pointer to HDD container.
* @param fDelete If true, delete the image from the host disk.
*/
{
int rc = VINF_SUCCESS;
int rc2;
bool fLockWrite = false;
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
/* Not worth splitting this up into a read lock phase and write
* lock phase, as closing an image is a relatively fast operation
* dominated by the part which needs the write lock. */
fLockWrite = true;
if (!pImage)
{
break;
}
/* Remove image from list of opened images. */
/* Close (and optionally delete) image. */
/* Free remaining resources related to the image. */
if (!pImage)
break;
* like this (if possible) after closing this image. Set the open flags
* accordingly. */
if (!(uOpenFlags & VD_OPEN_FLAGS_READONLY))
{
}
/* Cache disk information. */
/* Cache PCHS geometry. */
&pDisk->PCHSGeometry);
if (RT_FAILURE(rc2))
{
}
else
{
/* Make sure the PCHS geometry is properly clipped. */
}
/* Cache LCHS geometry. */
&pDisk->LCHSGeometry);
if (RT_FAILURE(rc2))
{
}
else
{
/* Make sure the LCHS geometry is properly clipped. */
}
} while (0);
if (RT_UNLIKELY(fLockWrite))
{
}
return rc;
}
/**
* Closes all opened image files in HDD container.
*
* @returns VBox status code.
* @param pDisk Pointer to HDD container.
*/
{
int rc = VINF_SUCCESS;
int rc2;
bool fLockWrite = false;
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
/* Lock the entire operation. */
fLockWrite = true;
{
/* Remove image from list of opened images. */
/* Close image. */
/* Free remaining resources related to the image. */
}
} while (0);
if (RT_UNLIKELY(fLockWrite))
{
}
return rc;
}
/**
* Read data from virtual HDD.
*
* @returns VBox status code.
* @returns VERR_VD_NOT_OPENED if no image is opened in HDD container.
* @param pDisk Pointer to HDD container.
* @param uOffset Offset of first reading byte from start of disk.
* @param pvBuf Pointer to buffer for reading data.
* @param cbRead Number of bytes to read.
*/
{
int rc = VINF_SUCCESS;
int rc2;
bool fLockRead = false;
LogFlowFunc(("pDisk=%#p uOffset=%llu pvBuf=%p cbRead=%zu\n",
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
/* Check arguments. */
("pvBuf=%#p\n", pvBuf),
("cbRead=%zu\n", cbRead),
fLockRead = true;
("uOffset=%llu cbRead=%zu pDisk->cbSize=%llu\n",
} while (0);
if (RT_UNLIKELY(fLockRead))
{
}
return rc;
}
/**
* Write data to virtual HDD.
*
* @returns VBox status code.
* @returns VERR_VD_NOT_OPENED if no image is opened in HDD container.
* @param pDisk Pointer to HDD container.
* @param uOffset Offset of the first byte being
* written from start of disk.
* @param pvBuf Pointer to buffer for writing data.
* @param cbWrite Number of bytes to write.
*/
{
int rc = VINF_SUCCESS;
int rc2;
bool fLockWrite = false;
LogFlowFunc(("pDisk=%#p uOffset=%llu pvBuf=%p cbWrite=%zu\n",
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
/* Check arguments. */
("pvBuf=%#p\n", pvBuf),
("cbWrite=%zu\n", cbWrite),
fLockWrite = true;
("uOffset=%llu cbWrite=%zu pDisk->cbSize=%llu\n",
} while (0);
if (RT_UNLIKELY(fLockWrite))
{
}
return rc;
}
/**
* Make sure the on disk representation of a virtual HDD is up to date.
*
* @returns VBox status code.
* @returns VERR_VD_NOT_OPENED if no image is opened in HDD container.
* @param pDisk Pointer to HDD container.
*/
{
int rc = VINF_SUCCESS;
int rc2;
bool fLockWrite = false;
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
fLockWrite = true;
} while (0);
if (RT_UNLIKELY(fLockWrite))
{
}
return rc;
}
/**
* Get number of opened images in HDD container.
*
* @returns Number of opened images for HDD container. 0 if no images have been opened.
* @param pDisk Pointer to HDD container.
*/
{
unsigned cImages;
int rc2;
bool fLockRead = false;
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
fLockRead = true;
} while (0);
if (RT_UNLIKELY(fLockRead))
{
}
return cImages;
}
/**
*
* @returns Virtual disk ReadOnly status.
* @returns true if no image is opened in HDD container.
* @param pDisk Pointer to HDD container.
*/
{
bool fReadOnly;
int rc2;
bool fLockRead = false;
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
fLockRead = true;
unsigned uOpenFlags;
} while (0);
if (RT_UNLIKELY(fLockRead))
{
}
return fReadOnly;
}
/**
* Get total capacity of an image in HDD container.
*
* @returns Virtual disk size in bytes.
* @returns 0 if no image with specified number was not opened.
* @param pDisk Pointer to HDD container.
* @param nImage Image number, counds from 0. 0 is always base image of container.
*/
{
int rc2;
bool fLockRead = false;
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
fLockRead = true;
} while (0);
if (RT_UNLIKELY(fLockRead))
{
}
return cbSize;
}
/**
* Get total file size of an image in HDD container.
*
* @returns Virtual disk size in bytes.
* @returns 0 if no image is opened in HDD container.
* @param pDisk Pointer to HDD container.
* @param nImage Image number, counts from 0. 0 is always base image of container.
*/
{
int rc2;
bool fLockRead = false;
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
fLockRead = true;
} while (0);
if (RT_UNLIKELY(fLockRead))
{
}
return cbSize;
}
/**
* Get virtual disk PCHS geometry stored in HDD container.
*
* @returns VBox status code.
* @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
* @returns VERR_VD_GEOMETRY_NOT_SET if no geometry present in the HDD container.
* @param pDisk Pointer to HDD container.
* @param nImage Image number, counts from 0. 0 is always base image of container.
* @param pPCHSGeometry Where to store PCHS geometry. Not NULL.
*/
{
int rc = VINF_SUCCESS;
int rc2;
bool fLockRead = false;
LogFlowFunc(("pDisk=%#p nImage=%u pPCHSGeometry=%#p\n",
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
/* Check arguments. */
("pPCHSGeometry=%#p\n", pPCHSGeometry),
fLockRead = true;
{
/* Use cached information if possible. */
else
}
else
} while (0);
if (RT_UNLIKELY(fLockRead))
{
}
return rc;
}
/**
* Store virtual disk PCHS geometry in HDD container.
*
* Note that in case of unrecoverable error all images in HDD container will be closed.
*
* @returns VBox status code.
* @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
* @returns VERR_VD_GEOMETRY_NOT_SET if no geometry present in the HDD container.
* @param pDisk Pointer to HDD container.
* @param nImage Image number, counts from 0. 0 is always base image of container.
* @param pPCHSGeometry Where to load PCHS geometry from. Not NULL.
*/
{
int rc = VINF_SUCCESS;
int rc2;
bool fLockWrite = false;
LogFlowFunc(("pDisk=%#p nImage=%u pPCHSGeometry=%#p PCHS=%u/%u/%u\n",
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
/* Check arguments. */
("pPCHSGeometry=%#p PCHS=%u/%u/%u\n", pPCHSGeometry,
fLockWrite = true;
{
{
/* Only update geometry if it is changed. Avoids similar checks
* in every backend. Most of the time the new geometry is set
* to the previous values, so no need to go through the hassle
* of updating an image which could be opened in read-only mode
* right now. */
/* Cache new geometry values in any case. */
&pDisk->PCHSGeometry);
if (RT_FAILURE(rc2))
{
}
else
{
/* Make sure the CHS geometry is properly clipped. */
}
}
}
else
{
&PCHS);
if ( RT_FAILURE(rc)
{
/* Only update geometry if it is changed. Avoids similar checks
* in every backend. Most of the time the new geometry is set
* to the previous values, so no need to go through the hassle
* of updating an image which could be opened in read-only mode
* right now. */
}
}
} while (0);
if (RT_UNLIKELY(fLockWrite))
{
}
return rc;
}
/**
* Get virtual disk LCHS geometry stored in HDD container.
*
* @returns VBox status code.
* @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
* @returns VERR_VD_GEOMETRY_NOT_SET if no geometry present in the HDD container.
* @param pDisk Pointer to HDD container.
* @param nImage Image number, counts from 0. 0 is always base image of container.
* @param pLCHSGeometry Where to store LCHS geometry. Not NULL.
*/
{
int rc = VINF_SUCCESS;
int rc2;
bool fLockRead = false;
LogFlowFunc(("pDisk=%#p nImage=%u pLCHSGeometry=%#p\n",
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
/* Check arguments. */
("pLCHSGeometry=%#p\n", pLCHSGeometry),
fLockRead = true;
{
/* Use cached information if possible. */
else
}
else
} while (0);
if (RT_UNLIKELY(fLockRead))
{
}
return rc;
}
/**
* Store virtual disk LCHS geometry in HDD container.
*
* Note that in case of unrecoverable error all images in HDD container will be closed.
*
* @returns VBox status code.
* @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
* @returns VERR_VD_GEOMETRY_NOT_SET if no geometry present in the HDD container.
* @param pDisk Pointer to HDD container.
* @param nImage Image number, counts from 0. 0 is always base image of container.
* @param pLCHSGeometry Where to load LCHS geometry from. Not NULL.
*/
{
int rc = VINF_SUCCESS;
int rc2;
bool fLockWrite = false;
LogFlowFunc(("pDisk=%#p nImage=%u pLCHSGeometry=%#p LCHS=%u/%u/%u\n",
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
/* Check arguments. */
("pLCHSGeometry=%#p LCHS=%u/%u/%u\n", pLCHSGeometry,
fLockWrite = true;
{
{
/* Only update geometry if it is changed. Avoids similar checks
* in every backend. Most of the time the new geometry is set
* to the previous values, so no need to go through the hassle
* of updating an image which could be opened in read-only mode
* right now. */
/* Cache new geometry values in any case. */
&pDisk->LCHSGeometry);
if (RT_FAILURE(rc2))
{
}
else
{
/* Make sure the CHS geometry is properly clipped. */
}
}
}
else
{
&LCHS);
if ( RT_FAILURE(rc)
{
/* Only update geometry if it is changed. Avoids similar checks
* in every backend. Most of the time the new geometry is set
* to the previous values, so no need to go through the hassle
* of updating an image which could be opened in read-only mode
* right now. */
}
}
} while (0);
if (RT_UNLIKELY(fLockWrite))
{
}
return rc;
}
/**
* Get version of image in HDD container.
*
* @returns VBox status code.
* @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
* @param pDisk Pointer to HDD container.
* @param nImage Image number, counts from 0. 0 is always base image of container.
* @param puVersion Where to store the image version.
*/
unsigned *puVersion)
{
int rc = VINF_SUCCESS;
int rc2;
bool fLockRead = false;
LogFlowFunc(("pDisk=%#p nImage=%u puVersion=%#p\n",
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
/* Check arguments. */
("puVersion=%#p\n", puVersion),
fLockRead = true;
} while (0);
if (RT_UNLIKELY(fLockRead))
{
}
return rc;
}
/**
* List the capabilities of image backend in HDD container.
*
* @returns VBox status code.
* @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
* @param pDisk Pointer to the HDD container.
* @param nImage Image number, counts from 0. 0 is always base image of container.
* @param pbackendInfo Where to store the backend information.
*/
{
int rc = VINF_SUCCESS;
int rc2;
bool fLockRead = false;
LogFlowFunc(("pDisk=%#p nImage=%u pBackendInfo=%#p\n",
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
/* Check arguments. */
("pBackendInfo=%#p\n", pBackendInfo),
fLockRead = true;
} while (0);
if (RT_UNLIKELY(fLockRead))
{
}
return rc;
}
/**
* Get flags of image in HDD container.
*
* @returns VBox status code.
* @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
* @param pDisk Pointer to HDD container.
* @param nImage Image number, counts from 0. 0 is always base image of container.
* @param puImageFlags Where to store the image flags.
*/
unsigned *puImageFlags)
{
int rc = VINF_SUCCESS;
int rc2;
bool fLockRead = false;
LogFlowFunc(("pDisk=%#p nImage=%u puImageFlags=%#p\n",
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
/* Check arguments. */
("puImageFlags=%#p\n", puImageFlags),
fLockRead = true;
} while (0);
if (RT_UNLIKELY(fLockRead))
{
}
return rc;
}
/**
* Get open flags of image in HDD container.
*
* @returns VBox status code.
* @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
* @param pDisk Pointer to HDD container.
* @param nImage Image number, counts from 0. 0 is always base image of container.
* @param puOpenFlags Where to store the image open flags.
*/
unsigned *puOpenFlags)
{
int rc = VINF_SUCCESS;
int rc2;
bool fLockRead = false;
LogFlowFunc(("pDisk=%#p nImage=%u puOpenFlags=%#p\n",
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
/* Check arguments. */
("puOpenFlags=%#p\n", puOpenFlags),
fLockRead = true;
} while (0);
if (RT_UNLIKELY(fLockRead))
{
}
return rc;
}
/**
* Set open flags of image in HDD container.
* Note that in case of unrecoverable error all images in HDD container will be closed.
*
* @returns VBox status code.
* @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
* @param pDisk Pointer to HDD container.
* @param nImage Image number, counts from 0. 0 is always base image of container.
* @param uOpenFlags Image file open mode, see VD_OPEN_FLAGS_* constants.
*/
unsigned uOpenFlags)
{
int rc;
int rc2;
bool fLockWrite = false;
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
/* Check arguments. */
("uOpenFlags=%#x\n", uOpenFlags),
fLockWrite = true;
} while (0);
if (RT_UNLIKELY(fLockWrite))
{
}
return rc;
}
/**
* Get base filename of image in HDD container. Some image formats use
* other filenames as well, so don't use this for anything but informational
* purposes.
*
* @returns VBox status code.
* @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
* @returns VERR_BUFFER_OVERFLOW if pszFilename buffer too small to hold filename.
* @param pDisk Pointer to HDD container.
* @param nImage Image number, counts from 0. 0 is always base image of container.
* @param pszFilename Where to store the image file name.
* @param cbFilename Size of buffer pszFilename points to.
*/
char *pszFilename, unsigned cbFilename)
{
int rc;
int rc2;
bool fLockRead = false;
LogFlowFunc(("pDisk=%#p nImage=%u pszFilename=%#p cbFilename=%u\n",
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
/* Check arguments. */
("cbFilename=%u\n", cbFilename),
fLockRead = true;
if (cb <= cbFilename)
{
rc = VINF_SUCCESS;
}
else
{
}
} while (0);
if (RT_UNLIKELY(fLockRead))
{
}
return rc;
}
/**
* Get the comment line of image in HDD container.
*
* @returns VBox status code.
* @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
* @returns VERR_BUFFER_OVERFLOW if pszComment buffer too small to hold comment text.
* @param pDisk Pointer to HDD container.
* @param nImage Image number, counts from 0. 0 is always base image of container.
* @param pszComment Where to store the comment string of image. NULL is ok.
* @param cbComment The size of pszComment buffer. 0 is ok.
*/
char *pszComment, unsigned cbComment)
{
int rc;
int rc2;
bool fLockRead = false;
LogFlowFunc(("pDisk=%#p nImage=%u pszComment=%#p cbComment=%u\n",
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
/* Check arguments. */
("cbComment=%u\n", cbComment),
fLockRead = true;
} while (0);
if (RT_UNLIKELY(fLockRead))
{
}
return rc;
}
/**
* Changes the comment line of image in HDD container.
*
* @returns VBox status code.
* @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
* @param pDisk Pointer to HDD container.
* @param nImage Image number, counts from 0. 0 is always base image of container.
* @param pszComment New comment string (UTF-8). NULL is allowed to reset the comment.
*/
const char *pszComment)
{
int rc;
int rc2;
bool fLockWrite = false;
LogFlowFunc(("pDisk=%#p nImage=%u pszComment=%#p \"%s\"\n",
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
/* Check arguments. */
fLockWrite = true;
} while (0);
if (RT_UNLIKELY(fLockWrite))
{
}
return rc;
}
/**
* Get UUID of image in HDD container.
*
* @returns VBox status code.
* @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
* @param pDisk Pointer to HDD container.
* @param nImage Image number, counts from 0. 0 is always base image of container.
* @param pUuid Where to store the image creation UUID.
*/
{
int rc;
int rc2;
bool fLockRead = false;
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
/* Check arguments. */
("pUuid=%#p\n", pUuid),
fLockRead = true;
} while (0);
if (RT_UNLIKELY(fLockRead))
{
}
return rc;
}
/**
* Set the image's UUID. Should not be used by normal applications.
*
* @returns VBox status code.
* @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
* @param pDisk Pointer to HDD container.
* @param nImage Image number, counts from 0. 0 is always base image of container.
* @param pUuid New UUID of the image. If NULL, a new UUID is created.
*/
{
int rc;
int rc2;
bool fLockWrite = false;
LogFlowFunc(("pDisk=%#p nImage=%u pUuid=%#p {%RTuuid}\n",
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
("pUuid=%#p\n", pUuid),
fLockWrite = true;
if (!pUuid)
{
RTUuidCreate(&Uuid);
}
} while (0);
if (RT_UNLIKELY(fLockWrite))
{
}
return rc;
}
/**
* Get last modification UUID of image in HDD container.
*
* @returns VBox status code.
* @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
* @param pDisk Pointer to HDD container.
* @param nImage Image number, counts from 0. 0 is always base image of container.
* @param pUuid Where to store the image modification UUID.
*/
{
int rc = VINF_SUCCESS;
int rc2;
bool fLockRead = false;
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
/* Check arguments. */
("pUuid=%#p\n", pUuid),
fLockRead = true;
pUuid);
} while (0);
if (RT_UNLIKELY(fLockRead))
{
}
return rc;
}
/**
* Set the image's last modification UUID. Should not be used by normal applications.
*
* @returns VBox status code.
* @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
* @param pDisk Pointer to HDD container.
* @param nImage Image number, counts from 0. 0 is always base image of container.
* @param pUuid New modification UUID of the image. If NULL, a new UUID is created.
*/
{
int rc;
int rc2;
bool fLockWrite = false;
LogFlowFunc(("pDisk=%#p nImage=%u pUuid=%#p {%RTuuid}\n",
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
/* Check arguments. */
("pUuid=%#p\n", pUuid),
fLockWrite = true;
if (!pUuid)
{
RTUuidCreate(&Uuid);
}
pUuid);
} while (0);
if (RT_UNLIKELY(fLockWrite))
{
}
return rc;
}
/**
* Get parent UUID of image in HDD container.
*
* @returns VBox status code.
* @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
* @param pDisk Pointer to HDD container.
* @param nImage Image number, counts from 0. 0 is always base image of container.
* @param pUuid Where to store the parent image UUID.
*/
{
int rc = VINF_SUCCESS;
int rc2;
bool fLockRead = false;
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
/* Check arguments. */
("pUuid=%#p\n", pUuid),
fLockRead = true;
} while (0);
if (RT_UNLIKELY(fLockRead))
{
}
return rc;
}
/**
* Set the image's parent UUID. Should not be used by normal applications.
*
* @returns VBox status code.
* @param pDisk Pointer to HDD container.
* @param nImage Image number, counts from 0. 0 is always base image of container.
* @param pUuid New parent UUID of the image. If NULL, a new UUID is created.
*/
{
int rc;
int rc2;
bool fLockWrite = false;
LogFlowFunc(("pDisk=%#p nImage=%u pUuid=%#p {%RTuuid}\n",
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
/* Check arguments. */
("pUuid=%#p\n", pUuid),
fLockWrite = true;
if (!pUuid)
{
RTUuidCreate(&Uuid);
}
} while (0);
if (RT_UNLIKELY(fLockWrite))
{
}
return rc;
}
/**
* Debug helper - dumps all opened images in HDD container into the log file.
*
* @param pDisk Pointer to HDD container.
*/
{
int rc2;
bool fLockRead = false;
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
int (*pfnMessage)(void *, const char *, ...) = NULL;
else
{
}
fLockRead = true;
{
}
} while (0);
if (RT_UNLIKELY(fLockRead))
{
}
}
/**
* Query if asynchronous operations are supported for this disk.
*
* @returns VBox status code.
* @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
* @param pDisk Pointer to the HDD container.
* @param nImage Image number, counts from 0. 0 is always base image of container.
* @param pfAIOSupported Where to store if async IO is supported.
*/
{
int rc = VINF_SUCCESS;
int rc2;
bool fLockRead = false;
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
/* Check arguments. */
("pfAIOSupported=%#p\n", pfAIOSupported),
fLockRead = true;
else
*pfAIOSupported = false;
} while (0);
if (RT_UNLIKELY(fLockRead))
{
}
return rc;
}
/**
* Start a asynchronous read request.
*
* @returns VBox status code.
* @param pDisk Pointer to the HDD container.
* @param uOffset The offset of the virtual disk to read from.
* @param cbRead How many bytes to read.
* @param paSeg Pointer to an array of segments.
* @param cSeg Number of segments in the array.
* @param pvUser User data which is passed on completion
*/
void *pvUser)
{
int rc = VERR_VD_BLOCK_FREE;
int rc2;
bool fLockWrite = false;
LogFlowFunc(("pDisk=%#p uOffset=%llu paSeg=%p cSeg=%u cbRead=%zu\n",
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
/* Check arguments. */
("cbRead=%zu\n", cbRead),
("paSeg=%#p\n", paSeg),
("cSeg=%zu\n", cSeg),
/** @todo handle this just like a write, as in the completion code in
* DrvVD.cpp there is no way to figure out if it is a read or write. */
fLockWrite = true;
("uOffset=%llu cbRead=%zu pDisk->cbSize=%llu\n",
/* @todo: This does not work for images which do not have all meta data in memory. */
{
pvUser);
}
/* No image in the chain contains the data for the block. */
if (rc == VERR_VD_BLOCK_FREE)
{
{
}
/* Request finished without the need to enqueue a async I/O request. Tell caller. */
fLockWrite = false;
}
} while (0);
{
}
if (rc == VINF_SUCCESS)
return rc;
}
/**
* Start a asynchronous write request.
*
* @returns VBox status code.
* @param pDisk Pointer to the HDD container.
* @param uOffset The offset of the virtual disk to write to.
* @param cbWrtie How many bytes to write.
* @param paSeg Pointer to an array of segments.
* @param cSeg Number of segments in the array.
* @param pvUser User data which is passed on completion.
*/
void *pvUser)
{
int rc;
int rc2;
bool fLockWrite = false;
LogFlowFunc(("pDisk=%#p uOffset=%llu paSeg=%p cSeg=%u cbWrite=%zu\n",
do
{
/* sanity check */
AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
/* Check arguments. */
("cbWrite=%zu\n", cbWrite),
("paSeg=%#p\n", paSeg),
("cSeg=%zu\n", cSeg),
fLockWrite = true;
("uOffset=%llu cbWrite=%zu pDisk->cbSize=%llu\n",
} while (0);
{
}
if (rc == VINF_SUCCESS)
return rc;
}
#if 0
/** @copydoc VBOXHDDBACKEND::pfnComposeLocation */
{
return NULL;
}
/** @copydoc VBOXHDDBACKEND::pfnComposeName */
{
return NULL;
}
#endif