/* $Id$ */
/** @file
* DrvVD - Generic VBox disk media driver.
*/
/*
* 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 <iprt/semaphore.h>
#include <iprt/memsafer.h>
#ifdef VBOX_WITH_INIP
/* All lwip header files are not C++ safe. So hack around this. */
# ifdef VBOX_WITH_NEW_LWIP
# endif
#endif /* VBOX_WITH_INIP */
#include "VBoxDD.h"
#ifdef VBOX_WITH_INIP
/* Small hack to get at lwIP initialized status */
extern bool DevINIPConfigured(void);
#endif /* VBOX_WITH_INIP */
/*******************************************************************************
* Defined types, constants and macros *
*******************************************************************************/
/** Converts a pointer to VBOXDISK::IMedia to a PVBOXDISK. */
/** Converts a pointer to VBOXDISK::IMediaAsync to a PVBOXDISK. */
/**
* VBox disk container, image information, private part.
*/
typedef struct VBOXIMAGE
{
/** Pointer to next image. */
/** Pointer to list of VD interfaces. Per-image. */
/** Configuration information interface. */
/** TCP network stack interface. */
/** I/O interface. */
/**
* Storage backend data.
*/
typedef struct DRVVDSTORAGEBACKEND
{
/** PDM async completion end point. */
/** The template. */
/** Event semaphore for synchronous operations. */
/** Flag whether a synchronous operation is currently pending. */
volatile bool fSyncIoPending;
/** Return code of the last completed request. */
int rcReqLast;
/** Callback routine */
/**
* VBox disk container media main structure, private part.
*
* @implements PDMIMEDIA
* @implements PDMIMEDIAASYNC
* @implements VDINTERFACEERROR
* @implements VDINTERFACETCPNET
* @implements VDINTERFACEASYNCIO
* @implements VDINTERFACECONFIG
*/
typedef struct VBOXDISK
{
/** The VBox disk container. */
/** The media interface. */
/** Media port. */
/** Pointer to the driver instance. */
/** Flag whether suspend has changed image open mode to read only. */
bool fTempReadOnly;
/** Flag whether to use the runtime (true) or startup error facility. */
bool fErrorUseRuntime;
/** Pointer to list of VD interfaces. Per-disk. */
/** Error interface. */
/** Thread synchronization interface. */
/** Flag whether opened disk supports async I/O operations. */
bool fAsyncIOSupported;
/** The async media interface. */
/** The async media port interface above. */
/** Pointer to the list of data we need to keep per image. */
/** Flag whether the media should allow concurrent open for writing. */
bool fShareable;
/** Flag whether a merge operation has been set up. */
bool fMergePending;
/** Synchronization to prevent destruction before merge finishes. */
/** Synchronization between merge and other image accesses. */
/** Source image index for merging. */
unsigned uMergeSource;
/** Target image index for merging. */
unsigned uMergeTarget;
/** Flag whether boot acceleration is enabled. */
bool fBootAccelEnabled;
/** Flag whether boot acceleration is currently active. */
bool fBootAccelActive;
/** Size of the disk, used for read truncation. */
/** Size of the configured buffer. */
/** Start offset for which the buffer holds data. */
/** Number of valid bytes in the buffer. */
/** The disk buffer. */
/** Bandwidth group the disk is assigned to. */
char *pszBwGroup;
/** Flag whether async I/O using the host cache is enabled. */
bool fAsyncIoWithHostCache;
/** I/O interface for a cache image. */
/** Interface list for the cache image. */
/** The block cache handle if configured. */
/** Cryptographic support
* @{ */
/** Pointer to the CFGM node containing the config of the crypto filter
* if enable. */
/** Config interface for the encryption filter. */
/** Crypto interface for the encryption filter. */
/** The secret key interface used to retrieve keys. */
/** The secret key helper interface used to notify about missing keys. */
/** @} */
/*******************************************************************************
* Internal Functions *
*******************************************************************************/
/**
* Internal: allocate new image descriptor and put it in the list
*/
{
if (pImage)
{
}
return pImage;
}
/**
* Internal: free the list of images descriptors.
*/
{
{
RTMemFree(p);
}
}
/**
* Make the image temporarily read-only.
*
* @returns VBox status code.
* @param pThis The driver instance data.
*/
{
{
unsigned uOpenFlags;
pThis->fTempReadOnly = true;
}
return rc;
}
/**
* Undo the temporary read-only status of the image.
*
* @returns VBox status code.
* @param pThis The driver instance data.
*/
{
if (pThis->fTempReadOnly)
{
unsigned uOpenFlags;
if (RT_SUCCESS(rc))
pThis->fTempReadOnly = false;
else
}
return rc;
}
/*******************************************************************************
* Error reporting callback *
*******************************************************************************/
{
if (pThis->fErrorUseRuntime)
/* We must not pass VMSETRTERR_FLAGS_FATAL as it could lead to a
* deadlock: We are probably executed in a thread context != EMT
* and the EM thread would wait until every thread is suspended
* but we would wait for the EM thread ... */
else
}
/*******************************************************************************
* VD Async I/O interface implementation *
*******************************************************************************/
static DECLCALLBACK(void) drvvdAsyncTaskCompleted(PPDMDRVINS pDrvIns, void *pvTemplateUser, void *pvUser, int rcReq)
{
LogFlowFunc(("pDrvIns=%#p pvTemplateUser=%#p pvUser=%#p rcReq=%d\n",
{
}
else
{
int rc;
}
}
void **ppStorage)
{
PDRVVDSTORAGEBACKEND pStorageBackend = (PDRVVDSTORAGEBACKEND)RTMemAllocZ(sizeof(DRVVDSTORAGEBACKEND));
if (pStorageBackend)
{
pStorageBackend->fSyncIoPending = false;
if (RT_SUCCESS(rc))
{
if (RT_SUCCESS(rc))
{
: 0;
if (pThis->fShareable)
{
}
if (pThis->fAsyncIoWithHostCache)
if (RT_SUCCESS(rc))
{
if (pThis->pszBwGroup)
if (RT_SUCCESS(rc))
{
LogFlow(("drvvdAsyncIOOpen: Successfully opened '%s'; fOpen=%#x pStorage=%p\n",
return VINF_SUCCESS;
}
}
}
}
}
else
rc = VERR_NO_MEMORY;
return rc;
}
{
return VINF_SUCCESS;;
}
{
int rc = PDMR3AsyncCompletionEpRead(pStorageBackend->pEndpoint, uOffset, &DataSeg, 1, cbRead, NULL, &pTask);
if (RT_FAILURE(rc))
return rc;
if (rc == VINF_AIO_TASK_PENDING)
{
/* Wait */
}
else
if (pcbRead)
return pStorageBackend->rcReqLast;
}
{
int rc = PDMR3AsyncCompletionEpWrite(pStorageBackend->pEndpoint, uOffset, &DataSeg, 1, cbWrite, NULL, &pTask);
if (RT_FAILURE(rc))
return rc;
if (rc == VINF_AIO_TASK_PENDING)
{
/* Wait */
}
else
if (pcbWritten)
*pcbWritten = cbWrite;
return pStorageBackend->rcReqLast;
}
{
if (RT_FAILURE(rc))
return rc;
if (rc == VINF_AIO_TASK_PENDING)
{
/* Wait */
LogFlowFunc(("Waiting for flush to complete\n"));
}
else
return pStorageBackend->rcReqLast;
}
void **ppTask)
{
int rc = PDMR3AsyncCompletionEpRead(pStorageBackend->pEndpoint, uOffset, paSegments, (unsigned)cSegments, cbRead,
if (rc == VINF_AIO_TASK_PENDING)
return rc;
}
void **ppTask)
{
int rc = PDMR3AsyncCompletionEpWrite(pStorageBackend->pEndpoint, uOffset, paSegments, (unsigned)cSegments, cbWrite,
if (rc == VINF_AIO_TASK_PENDING)
return rc;
}
void *pvCompletion, void **ppTask)
{
if (rc == VINF_AIO_TASK_PENDING)
return rc;
}
{
}
{
}
#endif /* VBOX_WITH_PDM_ASYNC_COMPLETION */
/*******************************************************************************
* VD Thread Synchronization interface implementation *
*******************************************************************************/
{
}
{
}
{
}
{
}
/*******************************************************************************
* VD Configuration interface implementation *
*******************************************************************************/
{
}
{
}
{
}
{
}
/*******************************************************************************
* VD Crypto interface implementation for the encryption support *
*******************************************************************************/
static DECLCALLBACK(int) drvvdCryptoKeyRetain(void *pvUser, const char *pszId, const uint8_t **ppbKey, size_t *pcbKey)
{
else
return rc;
}
{
else
return rc;
}
static DECLCALLBACK(int) drvvdCryptoKeyStorePasswordRetain(void *pvUser, const char *pszId, const char **ppszPassword)
{
else
return rc;
}
{
else
return rc;
}
#ifdef VBOX_WITH_INIP
/*******************************************************************************
* VD TCP network stack interface implementation - INIP case *
*******************************************************************************/
/**
* vvl: this structure duplicate meaning of sockaddr,
* perhaps it'd be better to get rid of it.
*/
typedef union INIPSOCKADDRUNION
{
#ifdef VBOX_WITH_NEW_LWIP
#endif
typedef struct INIPSOCKET
{
int hSock;
/** @copydoc VDINTERFACETCPNET::pfnSocketCreate */
{
/*
* The extended select method is not supported because it is impossible to wakeup
* the thread.
*/
return VERR_NOT_SUPPORTED;
if (pSocketInt)
{
return VINF_SUCCESS;
}
return VERR_NO_MEMORY;
}
/** @copydoc VDINTERFACETCPNET::pfnSocketCreate */
{
return VINF_SUCCESS;
}
/** @copydoc VDINTERFACETCPNET::pfnClientConnect */
static DECLCALLBACK(int) drvvdINIPClientConnect(VDSOCKET Sock, const char *pszAddress, uint32_t uPort,
{
#ifdef VBOX_WITH_NEW_LWIP
#endif
/* Check whether lwIP is set up in this VM instance. */
if (!DevINIPConfigured())
{
LogRelFunc(("no IP stack\n"));
return VERR_NET_HOST_UNREACHABLE;
}
/* Resolve hostname. As there is no standard resolver for lwIP yet,
* just accept numeric IP addresses for now. */
#ifdef VBOX_WITH_NEW_LWIP
else /* concatination with if */
#endif
{
return VERR_NET_HOST_UNREACHABLE;
}
/* Create socket and connect. */
if (iSock != -1)
{
if (iInetFamily == PF_INET)
{
}
#ifdef VBOX_WITH_NEW_LWIP
else
{
}
#endif
if ( pSockAddr
{
return VINF_SUCCESS;
}
}
else
return rc;
}
/** @copydoc VDINTERFACETCPNET::pfnClientClose */
{
return VINF_SUCCESS; /** @todo real solution needed */
}
/** @copydoc VDINTERFACETCPNET::pfnIsClientConnected */
{
}
/** @copydoc VDINTERFACETCPNET::pfnSelectOne */
{
int rc;
if (cMillies == RT_INDEFINITE_WAIT)
else
{
}
if (rc > 0)
return VINF_SUCCESS;
if (rc == 0)
return VERR_TIMEOUT;
return VERR_NET_CONNECTION_REFUSED; /** @todo real solution needed */
}
/** @copydoc VDINTERFACETCPNET::pfnRead */
static DECLCALLBACK(int) drvvdINIPRead(VDSOCKET Sock, void *pvBuffer, size_t cbBuffer, size_t *pcbRead)
{
/* Do params checking */
{
AssertMsgFailed(("Invalid params\n"));
return VERR_INVALID_PARAMETER;
}
/*
* Read loop.
* If pcbRead is NULL we have to fill the entire buffer!
*/
for (;;)
{
/** @todo this clipping here is just in case (the send function
* needed it, so I added it here, too). Didn't investigate if this
* really has issues. Better be safe than sorry. */
if (cbBytesRead < 0)
return VERR_NET_CONNECTION_REFUSED; /** @todo real solution */
if (cbBytesRead == 0 && errno) /** @todo r=bird: lwip_recv will not touch errno on Windows. This may apply to other hosts as well */
return VERR_NET_CONNECTION_REFUSED; /** @todo real solution */
if (pcbRead)
{
/* return partial data */
*pcbRead = cbBytesRead;
break;
}
/* read more? */
cbRead += cbBytesRead;
break;
/* next */
}
return VINF_SUCCESS;
}
/** @copydoc VDINTERFACETCPNET::pfnWrite */
{
do
{
/** @todo lwip send only supports up to 65535 bytes in a single
* send (stupid limitation buried in the code), so make sure we
* don't get any wraparounds. This should be moved to DevINIP
* stack interface once that's implemented. */
if (cbWritten < 0)
return VERR_NET_CONNECTION_REFUSED; /** @todo real solution needed */
AssertMsg(cbBuffer >= (size_t)cbWritten, ("Wrote more than we requested!!! cbWritten=%d cbBuffer=%d\n",
} while (cbBuffer);
return VINF_SUCCESS;
}
/** @copydoc VDINTERFACETCPNET::pfnSgWrite */
{
/* This is an extremely crude emulation, however it's good enough
* for our iSCSI code. INIP has no sendmsg(). */
{
if (RT_FAILURE(rc))
break;
}
if (RT_SUCCESS(rc))
return rc;
}
/** @copydoc VDINTERFACETCPNET::pfnFlush */
{
fFlag = 0;
return VINF_SUCCESS;
}
/** @copydoc VDINTERFACETCPNET::pfnSetSendCoalescing */
{
return VINF_SUCCESS;
}
/** @copydoc VDINTERFACETCPNET::pfnGetLocalAddress */
{
RT_ZERO(u);
{
/*
* Convert the address.
*/
if ( cbAddr == sizeof(struct sockaddr_in)
{
}
#ifdef VBOX_WITH_NEW_LWIP
else if ( cbAddr == sizeof(struct sockaddr_in6)
{
}
#endif
else
return VINF_SUCCESS;
}
return VERR_NET_OPERATION_NOT_SUPPORTED;
}
/** @copydoc VDINTERFACETCPNET::pfnGetPeerAddress */
{
RT_ZERO(u);
{
/*
* Convert the address.
*/
if ( cbAddr == sizeof(struct sockaddr_in)
{
}
#ifdef VBOX_WITH_NEW_LWIP
else if ( cbAddr == sizeof(struct sockaddr_in6)
{
}
#endif
else
return VINF_SUCCESS;
}
return VERR_NET_OPERATION_NOT_SUPPORTED;
}
/** @copydoc VDINTERFACETCPNET::pfnSelectOneEx */
static DECLCALLBACK(int) drvvdINIPSelectOneEx(VDSOCKET Sock, uint32_t fEvents, uint32_t *pfEvents, RTMSINTERVAL cMillies)
{
AssertMsgFailed(("Not supported!\n"));
return VERR_NOT_SUPPORTED;
}
/** @copydoc VDINTERFACETCPNET::pfnPoke */
{
AssertMsgFailed(("Not supported!\n"));
return VERR_NOT_SUPPORTED;
}
#endif /* VBOX_WITH_INIP */
/*******************************************************************************
* VD TCP network stack interface implementation - Host TCP case *
*******************************************************************************/
/**
* Socket data.
*/
typedef struct VDSOCKETINT
{
/** IPRT socket handle. */
/** Pollset with the wakeup pipe and socket. */
/** Pipe endpoint - read (in the pollset). */
/** Pipe endpoint - write. */
/** Flag whether the thread was woken up. */
volatile bool fWokenUp;
/** Flag whether the thread is waiting in the select call. */
volatile bool fWaiting;
/** Old event mask. */
/** Pollset id of the socket. */
#define VDSOCKET_POLL_ID_SOCKET 0
/** Pollset id of the pipe. */
/** @copydoc VDINTERFACETCPNET::pfnSocketCreate */
{
if (!pSockInt)
return VERR_NO_MEMORY;
{
/* Init pipe and pollset. */
if (RT_SUCCESS(rc))
{
if (RT_SUCCESS(rc))
{
if (RT_SUCCESS(rc))
{
return VINF_SUCCESS;
}
}
}
}
else
{
return VINF_SUCCESS;
}
return rc;
}
/** @copydoc VDINTERFACETCPNET::pfnSocketDestroy */
{
/* Destroy the pipe and pollset if necessary. */
{
{
}
}
return rc;
}
/** @copydoc VDINTERFACETCPNET::pfnClientConnect */
static DECLCALLBACK(int) drvvdTcpClientConnect(VDSOCKET Sock, const char *pszAddress, uint32_t uPort,
{
if (RT_SUCCESS(rc))
{
/* Add to the pollset if required. */
{
}
if (RT_SUCCESS(rc))
return VINF_SUCCESS;
}
return rc;
}
/** @copydoc VDINTERFACETCPNET::pfnClientClose */
{
{
}
return rc;
}
/** @copydoc VDINTERFACETCPNET::pfnIsClientConnected */
{
}
/** @copydoc VDINTERFACETCPNET::pfnSelectOne */
{
}
/** @copydoc VDINTERFACETCPNET::pfnRead */
static DECLCALLBACK(int) drvvdTcpRead(VDSOCKET Sock, void *pvBuffer, size_t cbBuffer, size_t *pcbRead)
{
}
/** @copydoc VDINTERFACETCPNET::pfnWrite */
{
}
/** @copydoc VDINTERFACETCPNET::pfnSgWrite */
{
}
/** @copydoc VDINTERFACETCPNET::pfnReadNB */
static DECLCALLBACK(int) drvvdTcpReadNB(VDSOCKET Sock, void *pvBuffer, size_t cbBuffer, size_t *pcbRead)
{
}
/** @copydoc VDINTERFACETCPNET::pfnWriteNB */
static DECLCALLBACK(int) drvvdTcpWriteNB(VDSOCKET Sock, const void *pvBuffer, size_t cbBuffer, size_t *pcbWritten)
{
}
/** @copydoc VDINTERFACETCPNET::pfnSgWriteNB */
{
}
/** @copydoc VDINTERFACETCPNET::pfnFlush */
{
}
/** @copydoc VDINTERFACETCPNET::pfnSetSendCoalescing */
{
}
/** @copydoc VDINTERFACETCPNET::pfnGetLocalAddress */
{
}
/** @copydoc VDINTERFACETCPNET::pfnGetPeerAddress */
{
}
{
*pfEvents = 0;
{
if (RT_FAILURE(rc))
return rc;
}
{
return VERR_INTERRUPTED;
}
if (RT_SUCCESS(rc))
{
if (id == VDSOCKET_POLL_ID_SOCKET)
{
if (fEventsRecv & RTPOLL_EVT_READ)
if (fEventsRecv & RTPOLL_EVT_WRITE)
if (fEventsRecv & RTPOLL_EVT_ERROR)
}
else
{
/* We got interrupted, drain the pipe. */
}
}
return rc;
}
/** @copydoc VDINTERFACETCPNET::pfnSelectOneEx */
{
*pfEvents = 0;
{
return VERR_INTERRUPTED;
}
|| !fEvents)
{
/*
* Only the pipe is configured or the caller doesn't wait for a socket event,
* wait until there is something to read from the pipe.
*/
char ch = 0;
if (RT_SUCCESS(rc))
{
}
}
else
{
{
/* Make sure the socket is not in the pollset. */
for (;;)
{
if (rc == VERR_TIMEOUT)
{
/* Check the socket. */
if (RT_SUCCESS(rc))
{
if (fEventsRecv & RTSOCKET_EVT_READ)
if (fEventsRecv & RTSOCKET_EVT_WRITE)
if (fEventsRecv & RTSOCKET_EVT_ERROR)
break; /* Quit */
}
else if (rc != VERR_TIMEOUT)
break;
}
else if (RT_SUCCESS(rc))
{
/* We got interrupted, drain the pipe. */
break;
}
else
break;
}
}
else /* The caller waits for a socket event. */
{
/* Loop until we got woken up or a socket event occurred. */
for (;;)
{
/** @todo find an adaptive wait algorithm based on the
* number of wakeups in the past. */
if (rc == VERR_TIMEOUT)
{
/* Check if there is an event pending. */
char ch = 0;
{
break; /* Quit */
}
else
}
else if (RT_SUCCESS(rc))
{
if (fEventsRecv & RTSOCKET_EVT_READ)
if (fEventsRecv & RTSOCKET_EVT_WRITE)
if (fEventsRecv & RTSOCKET_EVT_ERROR)
break; /* Quit */
}
else
break;
}
}
}
return rc;
}
/** @copydoc VDINTERFACETCPNET::pfnPoke */
{
{
}
return VINF_SUCCESS;
}
/**
* Checks the prerequisites for encrypted I/O.
*
* @returns VBox status code.
* @param pThis The VD driver instance data.
*/
{
if ( pThis->pCfgCrypto
{
int rc = PDMDrvHlpVMSetRuntimeError(pThis->pDrvIns, VMSETRTERR_FLAGS_SUSPEND | VMSETRTERR_FLAGS_NO_WAIT, "DrvVD_DEKMISSING",
N_("VD: The DEK for this disk is missing"));
return VERR_VD_DEK_MISSING;
}
return VINF_SUCCESS;
}
/*******************************************************************************
* Media interface methods *
*******************************************************************************/
/** @copydoc PDMIMEDIA::pfnRead */
{
if (RT_FAILURE(rc))
return rc;
if (!pThis->fBootAccelActive)
else
{
/* Can we serve the request from the buffer? */
{
}
if ( cbRead > 0
{
/* Increase request to the buffer size and read. */
if (RT_FAILURE(rc))
pThis->cbDataValid = 0;
else
}
{
}
}
if (RT_SUCCESS(rc))
return rc;
}
/** @copydoc PDMIMEDIA::pfnRead */
{
if ( pThis->pCfgCrypto
return VERR_VD_DEK_MISSING;
if (!pThis->fBootAccelActive)
else
{
/* Can we serve the request from the buffer? */
{
}
if ( cbRead > 0
{
/* Increase request to the buffer size and read. */
if (RT_FAILURE(rc))
pThis->cbDataValid = 0;
else
}
{
}
}
if (RT_SUCCESS(rc))
return rc;
}
/** @copydoc PDMIMEDIA::pfnWrite */
{
if (RT_FAILURE(rc))
return rc;
/* Invalidate any buffer if boot acceleration is enabled. */
if (pThis->fBootAccelActive)
{
pThis->cbDataValid = 0;
}
return rc;
}
/** @copydoc PDMIMEDIA::pfnFlush */
{
LogFlowFunc(("\n"));
return rc;
}
/** @copydoc PDMIMEDIA::pfnMerge */
void *pvUser)
{
LogFlowFunc(("\n"));
/* Note: There is an unavoidable race between destruction and another
* thread invoking this function. This is handled safely and gracefully by
* atomically invalidating the lock handle in drvvdDestruct. */
{
/* Take shortcut: PFNSIMPLEPROGRESS is exactly the same type as
* PFNVDPROGRESS, so there's no need for a conversion function. */
/** @todo maybe introduce a conversion which limits update frequency. */
pThis->fMergePending = false;
}
return rc;
}
/** @copydoc PDMIMEDIA::pfnSetKey */
static DECLCALLBACK(int) drvvdSetSecKeyIf(PPDMIMEDIA pInterface, PPDMISECKEY pIfSecKey, PPDMISECKEYHLP pIfSecKeyHlp)
{
LogFlowFunc(("\n"));
if (pThis->pCfgCrypto)
{
&& !pIfSecKey)
{
/* Unload the crypto filter first to make sure it doesn't access the keys anymore. */
}
if ( pIfSecKey
&& RT_SUCCESS(rc))
{
/* Load the crypt filter plugin. */
if (RT_FAILURE(rc))
}
}
else
return rc;
}
/** @copydoc PDMIMEDIA::pfnGetSize */
{
LogFlowFunc(("\n"));
return cb;
}
/** @copydoc PDMIMEDIA::pfnGetSectorSize */
{
LogFlowFunc(("\n"));
return cb;
}
/** @copydoc PDMIMEDIA::pfnIsReadOnly */
{
LogFlowFunc(("\n"));
LogFlowFunc(("returns %d\n", f));
return f;
}
/** @copydoc PDMIMEDIA::pfnBiosGetPCHSGeometry */
{
LogFlowFunc(("\n"));
if (RT_SUCCESS(rc))
{
}
else
{
LogFunc(("geometry not available.\n"));
}
LogFlowFunc(("returns %Rrc (CHS=%d/%d/%d)\n",
return rc;
}
/** @copydoc PDMIMEDIA::pfnBiosSetPCHSGeometry */
{
LogFlowFunc(("CHS=%d/%d/%d\n",
if (rc == VERR_VD_GEOMETRY_NOT_SET)
return rc;
}
/** @copydoc PDMIMEDIA::pfnBiosGetLCHSGeometry */
{
LogFlowFunc(("\n"));
if (RT_SUCCESS(rc))
{
}
else
{
LogFunc(("geometry not available.\n"));
}
LogFlowFunc(("returns %Rrc (CHS=%d/%d/%d)\n",
return rc;
}
/** @copydoc PDMIMEDIA::pfnBiosSetLCHSGeometry */
{
LogFlowFunc(("CHS=%d/%d/%d\n",
if (rc == VERR_VD_GEOMETRY_NOT_SET)
return rc;
}
/** @copydoc PDMIMEDIA::pfnGetUuid */
{
LogFlowFunc(("\n"));
return rc;
}
{
LogFlowFunc(("\n"));
return rc;
}
/** @copydoc PDMIMEDIA::pfnIoBufAlloc */
{
LogFlowFunc(("\n"));
int rc;
/* Configured encryption requires locked down memory. */
if (pThis->pCfgCrypto)
else
{
{
rc = VINF_SUCCESS;
}
else
rc = VERR_NO_MEMORY;
}
return rc;
}
/** @copydoc PDMIMEDIA::pfnIoBufFree */
{
LogFlowFunc(("\n"));
if (pThis->pCfgCrypto)
else
{
}
return rc;
}
/*******************************************************************************
* Async Media interface methods *
*******************************************************************************/
{
{
}
else
}
{
LogFlowFunc(("uOffset=%#llx paSeg=%#p cSeg=%u cbRead=%d pvUser=%#p\n",
if (RT_FAILURE(rc))
return rc;
pThis->fBootAccelActive = false;
else
{
if (rc == VINF_AIO_TASK_PENDING)
else if (rc == VINF_SUCCESS)
}
return rc;
}
{
LogFlowFunc(("uOffset=%#llx paSeg=%#p cSeg=%u cbWrite=%d pvUser=%#p\n",
if (RT_FAILURE(rc))
return rc;
pThis->fBootAccelActive = false;
else
{
if (rc == VINF_AIO_TASK_PENDING)
else if (rc == VINF_SUCCESS)
}
return rc;
}
{
else
{
if (rc == VINF_AIO_TASK_PENDING)
else if (rc == VINF_SUCCESS)
}
return rc;
}
{
LogFlowFunc(("paRanges=%#p cRanges=%u pvUser=%#p\n",
else
{
if (rc == VINF_AIO_TASK_PENDING)
else if (rc == VINF_SUCCESS)
}
return rc;
}
/** @copydoc FNPDMBLKCACHEXFERCOMPLETEDRV */
{
}
/** @copydoc FNPDMBLKCACHEXFERENQUEUEDRV */
{
switch (enmXferDir)
{
case PDMBLKCACHEXFERDIR_READ:
break;
case PDMBLKCACHEXFERDIR_WRITE:
break;
case PDMBLKCACHEXFERDIR_FLUSH:
break;
default:
}
if (rc == VINF_VD_ASYNC_IO_FINISHED)
return VINF_SUCCESS;
}
/** @copydoc FNPDMBLKCACHEXFERENQUEUEDISCARDDRV */
{
if (rc == VINF_VD_ASYNC_IO_FINISHED)
return VINF_SUCCESS;
}
/**
* Loads all configured plugins.
*
* @returns VBox status code.
* @param pThis The disk instance.
* @param pCfg CFGM node holding plugin list.
*/
{
if (pCfgPlugins)
{
while ( pPluginCur
&& RT_SUCCESS(rc))
{
if (RT_SUCCESS(rc))
}
}
return rc;
}
/**
* Sets up the disk filter chain.
*
* @returns VBox status code.
* @param pThis The disk instance.
* @param pCfg CFGM node holding the filter parameters.
*/
{
if (pCfgFilter)
{
if (RT_SUCCESS(rc))
{
}
}
return rc;
}
/*******************************************************************************
* Base interface methods *
*******************************************************************************/
/**
* @interface_method_impl{PDMIBASE,pfnQueryInterface}
*/
{
PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMEDIAASYNC, pThis->fAsyncIOSupported ? &pThis->IMediaAsync : NULL);
return NULL;
}
/*******************************************************************************
* Saved state notification methods *
*******************************************************************************/
/**
* Load done callback for re-opening the image writable during teleportation.
*
* This is called both for successful and failed load runs, we only care about
* successful ones.
*
* @returns VBox status code.
* @param pDrvIns The driver instance.
* @param pSSM The saved state handle.
*/
{
/* Drop out if we don't have any work to do or if it's a failed load. */
if ( !pThis->fTempReadOnly
return VINF_SUCCESS;
N_("Failed to write lock the images"));
return VINF_SUCCESS;
}
/*******************************************************************************
* Driver methods *
*******************************************************************************/
/**
* VM resume notification that we use to undo what the temporary read-only image
* mode set by drvvdSuspend.
*
* Also switch to runtime error mode if we're resuming after a state load
* without having been powered on first.
*
* @param pDrvIns The driver instance data.
*
* @todo The VMSetError vs VMSetRuntimeError mess must be fixed elsewhere,
* we're making assumptions about Main behavior here!
*/
{
LogFlowFunc(("\n"));
pThis->fErrorUseRuntime = true;
{
}
}
/**
* The VM is being suspended, temporarily change to read-only image mode.
*
* This is important for several reasons:
* -# It makes sure that there are no pending writes to the image. Most
* backends implements this by closing and reopening the image in read-only
* mode.
* -# It allows Main to read the images during snapshotting without having
* to account for concurrent writes.
* -# This is essential for making teleportation targets sharing images work
* right. Both with regards to caching and with regards to file sharing
* locks (RTFILE_O_DENY_*). (See also drvvdLoadDone.)
*
* @param pDrvIns The driver instance data.
*/
{
LogFlowFunc(("\n"));
{
}
}
/**
* VM PowerOn notification for undoing the TempReadOnly config option and
* changing to runtime error mode.
*
* @param pDrvIns The driver instance data.
*
* @todo The VMSetError vs VMSetRuntimeError mess must be fixed elsewhere,
* we're making assumptions about Main behavior here!
*/
{
LogFlowFunc(("\n"));
pThis->fErrorUseRuntime = true;
}
/**
* @copydoc FNPDMDRVRESET
*/
{
LogFlowFunc(("\n"));
{
}
if (pThis->fBootAccelEnabled)
{
pThis->fBootAccelActive = true;
pThis->cbDataValid = 0;
}
}
/**
* @copydoc FNPDMDRVDESTRUCT
*/
{
LogFlowFunc(("\n"));
if (mutex != NIL_RTSEMFASTMUTEX)
{
/* Request the semaphore to wait until a potentially running merge
* operation has been finished. */
pThis->fMergePending = false;
}
{
}
{
}
{
}
{
}
if (pThis->pszBwGroup)
{
}
}
/**
* Construct a VBox disk media driver instance.
*
* @copydoc FNPDMDRVCONSTRUCT
*/
{
LogFlowFunc(("\n"));
/*
* Init the static parts.
*/
pThis->fTempReadOnly = false;
pThis->fAsyncIOSupported = false;
pThis->fShareable = false;
pThis->fMergePending = false;
/* IMedia */
/* IMediaAsync */
/* Initialize supported VD interfaces. */
/* List of images is empty now. */
if (!pThis->pDrvMediaPort)
N_("No media port interface above"));
/* Try to attach async media port interface above.*/
/* Before we access any VD API load all given plugins. */
if (RT_FAILURE(rc))
/*
* Validate configuration and find all parent images.
* It's sort of up side down from the image dependency tree.
*/
bool fHostIP = false;
bool fUseNewIo = false;
bool fUseBlockCache = false;
bool fDiscard = false;
bool fInformAboutZeroBlocks = false;
bool fSkipConsistencyChecks = false;
unsigned iLevel = 0;
for (;;)
{
bool fValid;
{
/* Toplevel configuration additionally contains the global image
* open flags. Some might be converted to per-image flags later. */
"Format\0Path\0"
"ReadOnly\0MaybeReadOnly\0TempReadOnly\0Shareable\0HonorZeroWrites\0"
"HostIPStack\0UseNewIo\0BootAcceleration\0BootAccelerationBuffer\0"
"SetupMerge\0MergeSource\0MergeTarget\0BwGroup\0Type\0BlockCache\0"
"CachePath\0CacheFormat\0Discard\0InformAboutZeroBlocks\0"
"SkipConsistencyChecks\0");
}
else
{
/* All other image configurations only contain image name and
* the format information. */
"MergeSource\0MergeTarget\0");
}
if (!fValid)
{
break;
}
{
if (RT_FAILURE(rc))
{
N_("DrvVD: Configuration error: Querying \"HostIPStack\" as boolean failed"));
break;
}
if (RT_FAILURE(rc))
{
N_("DrvVD: Configuration error: Querying \"HonorZeroWrites\" as boolean failed"));
break;
}
if (RT_FAILURE(rc))
{
N_("DrvVD: Configuration error: Querying \"ReadOnly\" as boolean failed"));
break;
}
if (RT_FAILURE(rc))
{
N_("DrvVD: Configuration error: Querying \"MaybeReadOnly\" as boolean failed"));
break;
}
if (RT_FAILURE(rc))
{
N_("DrvVD: Configuration error: Querying \"TempReadOnly\" as boolean failed"));
break;
}
{
N_("DrvVD: Configuration error: Both \"ReadOnly\" and \"TempReadOnly\" are set"));
break;
}
if (RT_FAILURE(rc))
{
N_("DrvVD: Configuration error: Querying \"Shareable\" as boolean failed"));
break;
}
if (RT_FAILURE(rc))
{
N_("DrvVD: Configuration error: Querying \"UseNewIo\" as boolean failed"));
break;
}
if (RT_FAILURE(rc))
{
N_("DrvVD: Configuration error: Querying \"SetupMerge\" as boolean failed"));
break;
}
{
N_("DrvVD: Configuration error: Both \"ReadOnly\" and \"MergePending\" are set"));
break;
}
if (RT_FAILURE(rc))
{
N_("DrvVD: Configuration error: Querying \"BootAcceleration\" as boolean failed"));
break;
}
rc = CFGMR3QueryU32Def(pCurNode, "BootAccelerationBuffer", (uint32_t *)&pThis->cbBootAccelBuffer, 16 * _1K);
if (RT_FAILURE(rc))
{
N_("DrvVD: Configuration error: Querying \"BootAccelerationBuffer\" as integer failed"));
break;
}
if (RT_FAILURE(rc))
{
N_("DrvVD: Configuration error: Querying \"BlockCache\" as boolean failed"));
break;
}
{
N_("DrvVD: Configuration error: Querying \"BwGroup\" as string failed"));
break;
}
else
rc = VINF_SUCCESS;
if (RT_FAILURE(rc))
{
N_("DrvVD: Configuration error: Querying \"Discard\" as boolean failed"));
break;
}
{
N_("DrvVD: Configuration error: Both \"ReadOnly\" and \"Discard\" are set"));
break;
}
if (RT_FAILURE(rc))
{
N_("DrvVD: Configuration error: Querying \"InformAboutZeroBlocks\" as boolean failed"));
break;
}
if (RT_FAILURE(rc))
{
N_("DrvVD: Configuration error: Querying \"SKipConsistencyChecks\" as boolean failed"));
break;
}
char *psz;
if (RT_FAILURE(rc))
{
break;
}
else
{
break;
}
{
N_("DrvVD: Configuration error: Querying \"CachePath\" as string failed"));
break;
}
else
rc = VINF_SUCCESS;
if (pszCachePath)
{
if (RT_FAILURE(rc))
{
N_("DrvVD: Configuration error: Querying \"CacheFormat\" as string failed"));
break;
}
}
}
if (!pParent)
break;
iLevel++;
}
/*
* Create the image container and the necessary interfaces.
*/
if (RT_SUCCESS(rc))
{
/*
* The image has a bandwidth group but the host cache is enabled.
* Use the async I/O framework but tell it to enable the host cache.
*/
{
pThis->fAsyncIoWithHostCache = true;
fUseNewIo = true;
}
/** @todo quick hack to work around problems in the async I/O
* implementation (rw semaphore thread ownership problem)
* while a merge is running. Remove once this is fixed. */
if (pThis->fMergePending)
fUseNewIo = false;
{
if (RT_SUCCESS(rc))
if (RT_SUCCESS(rc))
{
}
else
{
N_("DrvVD: Failed to create semaphores for \"MergePending\""));
}
}
if (RT_SUCCESS(rc))
{
/* Error message is already set correctly. */
}
}
pThis->fAsyncIOSupported = true;
unsigned iImageIdx = 0;
{
/* Allocate per-image data. */
if (!pImage)
{
rc = VERR_NO_MEMORY;
break;
}
/*
* Read the image configuration.
*/
if (RT_FAILURE(rc))
{
N_("DrvVD: Configuration error: Querying \"Path\" as string failed"));
break;
}
if (RT_FAILURE(rc))
{
N_("DrvVD: Configuration error: Querying \"Format\" as string failed"));
break;
}
bool fMergeSource;
if (RT_FAILURE(rc))
{
N_("DrvVD: Configuration error: Querying \"MergeSource\" as boolean failed"));
break;
}
if (fMergeSource)
{
else
{
N_("DrvVD: Configuration error: Multiple \"MergeSource\" occurrences"));
break;
}
}
bool fMergeTarget;
if (RT_FAILURE(rc))
{
N_("DrvVD: Configuration error: Querying \"MergeTarget\" as boolean failed"));
break;
}
if (fMergeTarget)
{
else
{
N_("DrvVD: Configuration error: Multiple \"MergeTarget\" occurrences"));
break;
}
}
/* Check VDConfig for encryption config. */
if (pCfgVDConfig)
if (pThis->pCfgCrypto)
{
/* Setup VDConfig interface for disk encryption support. */
}
/* Unconditionally insert the TCPNET interface, don't bother to check
* if an image really needs it. Will be ignored. Since the TCPNET
* interface is per image we could make this more flexible in the
* future if we want to. */
/* Construct TCPNET callback table depending on the config. This is
* done unconditionally, as uninterested backends will ignore it. */
if (fHostIP)
{
/*
* There is a 15ms delay between receiving the data and marking the socket
* as readable on Windows XP which hurts async I/O performance of
* TCP backends badly. Provide a different select method without
* using poll on XP.
* This is only used on XP because it is not as efficient as the one using poll
* and all other Windows versions are working fine.
*/
{
LogRel(("VD: Detected Windows XP, disabled poll based waiting for TCP\n"));
}
else
}
else
{
#ifndef VBOX_WITH_INIP
#else /* VBOX_WITH_INIP */
#endif /* VBOX_WITH_INIP */
}
/* Insert the custom I/O interface only if we're told to use new IO.
* Since the I/O interface is per image we could make this more
* flexible in the future if we want to. */
if (fUseNewIo)
{
#else /* !VBOX_WITH_PDM_ASYNC_COMPLETION */
#endif /* !VBOX_WITH_PDM_ASYNC_COMPLETION */
if (RT_SUCCESS(rc))
}
/*
* Open the image.
*/
unsigned uOpenFlags;
else
if (fHonorZeroWrites)
if (pThis->fAsyncIOSupported)
if (pThis->fShareable)
if ( (uOpenFlags & VD_OPEN_FLAGS_READONLY)
/* Try to open backend in async I/O mode first. */
if (rc == VERR_NOT_SUPPORTED)
{
pThis->fAsyncIOSupported = false;
}
if (rc == VERR_VD_DISCARD_NOT_SUPPORTED)
{
fDiscard = false;
}
if (!fDiscard)
{
}
if (RT_SUCCESS(rc))
{
LogFunc(("%d - Opened '%s' in %s mode\n",
&& !fReadOnly
&& !fMaybeReadOnly
&& !pThis->fTempReadOnly
&& iLevel == 0)
{
N_("Failed to open image '%s' for writing due to wrong permissions"),
pszName);
break;
}
}
else
{
break;
}
/* next */
iLevel--;
iImageIdx++;
}
/* Open the cache image if set. */
if ( RT_SUCCESS(rc)
&& RT_VALID_PTR(pszCachePath))
{
/* Insert the custom I/O interface only if we're told to use new IO.
* Since the I/O interface is per image we could make this more
* flexible in the future if we want to. */
if (fUseNewIo)
{
#else /* !VBOX_WITH_PDM_ASYNC_COMPLETION */
#endif /* !VBOX_WITH_PDM_ASYNC_COMPLETION */
if (RT_SUCCESS(rc))
}
rc = VDCacheOpen(pThis->pDisk, pszCacheFormat, pszCachePath, VD_OPEN_FLAGS_NORMAL, pThis->pVDIfsCache);
if (RT_FAILURE(rc))
}
if (RT_VALID_PTR(pszCachePath))
if (RT_VALID_PTR(pszCacheFormat))
if ( RT_SUCCESS(rc)
&& pThis->fMergePending
{
N_("DrvVD: Configuration error: Inconsistent image merge data"));
}
/* Create the block cache if enabled. */
if ( fUseBlockCache
&& !pThis->fShareable
&& !fDiscard
&& RT_SUCCESS(rc))
{
/*
* We need a unique ID for the block cache (to identify the owner of data
* blocks in a saved state). UUIDs are not really suitable because
* there are image formats which don't support them. Furthermore it is
* possible that a new diff image was attached after a saved state
* which changes the UUID.
* However the device "name + device instance + LUN" triple the disk is
* attached to is always constant for saved states.
*/
const char *pcszController;
if (RT_FAILURE(rc))
N_("DrvVD: Configuration error: Could not query device data"));
else
{
if (cbStr > 0)
{
pszId);
if (rc == VERR_NOT_SUPPORTED)
{
LogRel(("VD: Block cache is not supported\n"));
rc = VINF_SUCCESS;
}
else
}
else
N_("DrvVD: Out of memory when creating block cache"));
}
}
if (RT_SUCCESS(rc))
/*
* Register a load-done callback so we can undo TempReadOnly config before
* we get to drvvdResume. Autoamtically deregistered upon destruction.
*/
if (RT_SUCCESS(rc))
/* Setup the boot acceleration stuff if enabled. */
{
{
pThis->fBootAccelActive = true;
pThis->cbDataValid = 0;
LogRel(("VD: Boot acceleration enabled\n"));
}
else
LogRel(("VD: Boot acceleration, out of memory, disabled\n"));
}
if (RT_FAILURE(rc))
{
if (RT_VALID_PTR(pszName))
if (RT_VALID_PTR(pszFormat))
/* drvvdDestruct does the rest. */
}
return rc;
}
/**
* VBox disk container media driver registration record.
*/
{
/* u32Version */
/* szName */
"VD",
/* szRCMod */
"",
/* szR0Mod */
"",
/* pszDescription */
"Generic VBox disk media driver.",
/* fFlags */
/* fClass. */
/* cMaxInstances */
~0U,
/* cbInstance */
sizeof(VBOXDISK),
/* pfnConstruct */
/* pfnDestruct */
/* pfnRelocate */
NULL,
/* pfnIOCtl */
NULL,
/* pfnPowerOn */
/* pfnReset */
/* pfnSuspend */
/* pfnResume */
/* pfnAttach */
NULL,
/* pfnDetach */
NULL,
/* pfnPowerOff */
NULL,
/* pfnSoftReset */
NULL,
/* u32EndVersion */
};