Changeset 66250 in vbox for trunk/src/VBox/Storage

Timestamp:

Mar 26, 2017 9:52:17 PM (8 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

114171

Message:

Storage,DrvVD,Main,VBoxManage: Rename VBOXHDD to VDISK, the VBoxHDD module is long gone:

Location:

trunk/src/VBox/Storage

Files:

• VD.cpp (modified) (125 diffs)
• VDVfs.cpp (modified) (4 diffs)
• VMDK.cpp (modified) (8 diffs)
• testcase/tstVD.cpp (modified) (8 diffs)
• testcase/tstVDFill.cpp (modified) (1 diff)
• testcase/tstVDIo.cpp (modified) (16 diffs)
• testcase/tstVDSnap.cpp (modified) (3 diffs)
• testcase/vbox-img.cpp (modified) (11 diffs)

trunk/src/VBox/Storage/VD.cpp

@@ -97 +97 @@
     void               *pBackendData;
     /** Disk this image is part of */
-    PVBOXHDD            pDisk;
+    PVDISK              pDisk;
     /** Flag whether to ignore flush requests. */
     bool                fIgnoreFlush;
@@ -222 +222 @@
  * VBox HDD Container main structure, private part.
  */
-struct VBOXHDD
+struct VDISK
 {
     /** Structure signature (VDISK_SIGNATURE). */
@@ -315 +315 @@
 {
     /** Pointer to disk descriptor. */
-    PVBOXHDD pDisk;
+    PVDISK pDisk;
     /** Pointer to image descriptor. */
     PVDIMAGE pImage;
@@ -350 +350 @@
     struct VDIOCTX * volatile    pIoCtxNext;
     /** Disk this is request is for. */
-    PVBOXHDD                     pDisk;
+    PVDISK                     pDisk;
     /** Return code. */
     int                          rcReq;
@@ -670 +670 @@
 static DECLCALLBACK(int) vdDiscardHelperAsync(PVDIOCTX pIoCtx);
 static DECLCALLBACK(int) vdWriteHelperAsync(PVDIOCTX pIoCtx);
-static void vdDiskProcessBlockedIoCtx(PVBOXHDD pDisk);
-static int vdDiskUnlock(PVBOXHDD pDisk, PVDIOCTX pIoCtxRc);
+static void vdDiskProcessBlockedIoCtx(PVDISK pDisk);
+static int vdDiskUnlock(PVDISK pDisk, PVDIOCTX pIoCtxRc);
 static DECLCALLBACK(void) vdIoCtxSyncComplete(void *pvUser1, void *pvUser2, int rcReq);
 
@@ -788 +788 @@
  * internal: issue error message.
  */
-static int vdError(PVBOXHDD pDisk, int rc, RT_SRC_POS_DECL,
+static int vdError(PVDISK pDisk, int rc, RT_SRC_POS_DECL,
                    const char *pszFormat, ...)
 {
@@ -802 +802 @@
  * internal: thread synchronization, start read.
  */
-DECLINLINE(int) vdThreadStartRead(PVBOXHDD pDisk)
+DECLINLINE(int) vdThreadStartRead(PVDISK pDisk)
 {
     int rc = VINF_SUCCESS;
@@ -813 +813 @@
  * internal: thread synchronization, finish read.
  */
-DECLINLINE(int) vdThreadFinishRead(PVBOXHDD pDisk)
+DECLINLINE(int) vdThreadFinishRead(PVDISK pDisk)
 {
     int rc = VINF_SUCCESS;
@@ -824 +824 @@
  * internal: thread synchronization, start write.
  */
-DECLINLINE(int) vdThreadStartWrite(PVBOXHDD pDisk)
+DECLINLINE(int) vdThreadStartWrite(PVDISK pDisk)
 {
     int rc = VINF_SUCCESS;
@@ -835 +835 @@
  * internal: thread synchronization, finish write.
  */
-DECLINLINE(int) vdThreadFinishWrite(PVBOXHDD pDisk)
+DECLINLINE(int) vdThreadFinishWrite(PVDISK pDisk)
 {
     int rc = VINF_SUCCESS;
@@ -913 +913 @@
  * internal: add image structure to the end of images list.
  */
-static void vdAddImageToList(PVBOXHDD pDisk, PVDIMAGE pImage)
+static void vdAddImageToList(PVDISK pDisk, PVDIMAGE pImage)
 {
     pImage->pPrev = NULL;
@@ -938 +938 @@
  * internal: remove image structure from the images list.
  */
-static void vdRemoveImageFromList(PVBOXHDD pDisk, PVDIMAGE pImage)
+static void vdRemoveImageFromList(PVDISK pDisk, PVDIMAGE pImage)
 {
     Assert(pDisk->cImages > 0);
@@ -991 +991 @@
  * internal: find image by index into the images list.
  */
-static PVDIMAGE vdGetImageByNumber(PVBOXHDD pDisk, unsigned nImage)
+static PVDIMAGE vdGetImageByNumber(PVDISK pDisk, unsigned nImage)
 {
     PVDIMAGE pImage = pDisk->pBase;
@@ -1013 +1013 @@
  * @param   pIoCtx   The I/O context associated with the request.
  */
-static int vdFilterChainApplyWrite(PVBOXHDD pDisk, uint64_t uOffset, size_t cbWrite,
+static int vdFilterChainApplyWrite(PVDISK pDisk, uint64_t uOffset, size_t cbWrite,
                                    PVDIOCTX pIoCtx)
 {
@@ -1042 +1042 @@
  * @param   pIoCtx   The I/O context associated with the request.
  */
-static int vdFilterChainApplyRead(PVBOXHDD pDisk, uint64_t uOffset, size_t cbRead,
+static int vdFilterChainApplyRead(PVDISK pDisk, uint64_t uOffset, size_t cbRead,
                                   PVDIOCTX pIoCtx)
 {
@@ -1065 +1065 @@
 }
 
-DECLINLINE(void) vdIoCtxRootComplete(PVBOXHDD pDisk, PVDIOCTX pIoCtx)
+DECLINLINE(void) vdIoCtxRootComplete(PVDISK pDisk, PVDIOCTX pIoCtx)
 {
     if (   RT_SUCCESS(pIoCtx->rcReq)
@@ -1080 +1080 @@
  * Initialize the structure members of a given I/O context.
  */
-DECLINLINE(void) vdIoCtxInit(PVDIOCTX pIoCtx, PVBOXHDD pDisk, VDIOCTXTXDIR enmTxDir,
+DECLINLINE(void) vdIoCtxInit(PVDIOCTX pIoCtx, PVDISK pDisk, VDIOCTXTXDIR enmTxDir,
                              uint64_t uOffset, size_t cbTransfer, PVDIMAGE pImageStart,
                              PCRTSGBUF pcSgBuf, void *pvAllocation,
@@ -1228 +1228 @@
  *                             The number of bytes waiting can be less.
  */
-static int vdDiscardRemoveBlocks(PVBOXHDD pDisk, PVDDISCARDSTATE pDiscard, size_t cbDiscardingNew)
+static int vdDiscardRemoveBlocks(PVDISK pDisk, PVDDISCARDSTATE pDiscard, size_t cbDiscardingNew)
 {
     int rc = VINF_SUCCESS;
@@ -1313 +1313 @@
  * @param   pDisk    VD disk container.
  */
-static int vdDiscardStateDestroy(PVBOXHDD pDisk)
+static int vdDiscardStateDestroy(PVDISK pDisk)
 {
     int rc = VINF_SUCCESS;
@@ -1339 +1339 @@
  * @param   cbRange  Number of bytes to mark as allocated.
  */
-static int vdDiscardSetRangeAllocated(PVBOXHDD pDisk, uint64_t uOffset, size_t cbRange)
+static int vdDiscardSetRangeAllocated(PVDISK pDisk, uint64_t uOffset, size_t cbRange)
 {
     PVDDISCARDSTATE pDiscard = pDisk->pDiscard;
@@ -1381 +1381 @@
 }
 
-DECLINLINE(PVDIOCTX) vdIoCtxAlloc(PVBOXHDD pDisk, VDIOCTXTXDIR enmTxDir,
+DECLINLINE(PVDIOCTX) vdIoCtxAlloc(PVDISK pDisk, VDIOCTXTXDIR enmTxDir,
                                   uint64_t uOffset, size_t cbTransfer,
                                   PVDIMAGE pImageStart,PCRTSGBUF pcSgBuf,
@@ -1399 +1399 @@
 }
 
-DECLINLINE(PVDIOCTX) vdIoCtxRootAlloc(PVBOXHDD pDisk, VDIOCTXTXDIR enmTxDir,
+DECLINLINE(PVDIOCTX) vdIoCtxRootAlloc(PVDISK pDisk, VDIOCTXTXDIR enmTxDir,
                                       uint64_t uOffset, size_t cbTransfer,
                                       PVDIMAGE pImageStart, PCRTSGBUF pcSgBuf,
@@ -1423 +1423 @@
 }
 
-DECLINLINE(void) vdIoCtxDiscardInit(PVDIOCTX pIoCtx, PVBOXHDD pDisk, PCRTRANGE paRanges,
+DECLINLINE(void) vdIoCtxDiscardInit(PVDIOCTX pIoCtx, PVDISK pDisk, PCRTRANGE paRanges,
                                     unsigned cRanges, PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
                                     void *pvUser1, void *pvUser2, void *pvAllocation,
@@ -1452 +1452 @@
 }
 
-DECLINLINE(PVDIOCTX) vdIoCtxDiscardAlloc(PVBOXHDD pDisk, PCRTRANGE paRanges,
+DECLINLINE(PVDIOCTX) vdIoCtxDiscardAlloc(PVDISK pDisk, PCRTRANGE paRanges,
                                          unsigned cRanges,
                                          PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
@@ -1473 +1473 @@
 }
 
-DECLINLINE(PVDIOCTX) vdIoCtxChildAlloc(PVBOXHDD pDisk, VDIOCTXTXDIR enmTxDir,
+DECLINLINE(PVDIOCTX) vdIoCtxChildAlloc(PVDISK pDisk, VDIOCTXTXDIR enmTxDir,
                                        uint64_t uOffset, size_t cbTransfer,
                                        PVDIMAGE pImageStart, PCRTSGBUF pcSgBuf,
@@ -1534 +1534 @@
 }
 
-DECLINLINE(void) vdIoCtxFree(PVBOXHDD pDisk, PVDIOCTX pIoCtx)
+DECLINLINE(void) vdIoCtxFree(PVDISK pDisk, PVDIOCTX pIoCtx)
 {
     Log(("Freeing I/O context %#p\n", pIoCtx));
@@ -1549 +1549 @@
 }
 
-DECLINLINE(void) vdIoTaskFree(PVBOXHDD pDisk, PVDIOTASK pIoTask)
+DECLINLINE(void) vdIoTaskFree(PVDISK pDisk, PVDIOTASK pIoTask)
 {
 #ifdef DEBUG
@@ -1601 +1601 @@
 }
 
-DECLINLINE(void) vdIoCtxDefer(PVBOXHDD pDisk, PVDIOCTX pIoCtx)
+DECLINLINE(void) vdIoCtxDefer(PVDISK pDisk, PVDIOCTX pIoCtx)
 {
     LogFlowFunc(("Deferring I/O context pIoCtx=%#p\n", pIoCtx));
@@ -1765 +1765 @@
  *                   to return the status code for.
  */
-static int vdDiskProcessWaitingIoCtx(PVBOXHDD pDisk, PVDIOCTX pIoCtxRc)
+static int vdDiskProcessWaitingIoCtx(PVDISK pDisk, PVDIOCTX pIoCtxRc)
 {
     int rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
@@ -1850 +1850 @@
  * @param   pDisk    The disk structure.
  */
-static void vdDiskProcessBlockedIoCtx(PVBOXHDD pDisk)
+static void vdDiskProcessBlockedIoCtx(PVDISK pDisk)
 {
     LogFlowFunc(("pDisk=%#p\n", pDisk));
@@ -1908 +1908 @@
 {
     int rc = VINF_SUCCESS;
-    PVBOXHDD pDisk = pIoCtx->pDisk;
+    PVDISK pDisk = pIoCtx->pDisk;
 
     Log(("Defer pIoCtx=%#p\n", pIoCtx));
@@ -1941 +1941 @@
 {
     int rc = VINF_SUCCESS;
-    PVBOXHDD pDisk = pIoCtx->pDisk;
+    PVDISK pDisk = pIoCtx->pDisk;
 
     LogFlowFunc(("pIoCtx=%p\n", pIoCtx));
@@ -1964 +1964 @@
 }
 
-DECLINLINE(bool) vdIoCtxIsDiskLockOwner(PVBOXHDD pDisk, PVDIOCTX pIoCtx)
+DECLINLINE(bool) vdIoCtxIsDiskLockOwner(PVDISK pDisk, PVDIOCTX pIoCtx)
 {
     return pDisk->pIoCtxLockOwner == pIoCtx;
 }
 
-static int vdIoCtxLockDisk(PVBOXHDD pDisk, PVDIOCTX pIoCtx)
+static int vdIoCtxLockDisk(PVDISK pDisk, PVDIOCTX pIoCtx)
 {
     int rc = VINF_SUCCESS;
@@ -1988 +1988 @@
 }
 
-static void vdIoCtxUnlockDisk(PVBOXHDD pDisk, PVDIOCTX pIoCtx, bool fProcessBlockedReqs)
+static void vdIoCtxUnlockDisk(PVDISK pDisk, PVDIOCTX pIoCtx, bool fProcessBlockedReqs)
 {
     RT_NOREF1(pIoCtx);
@@ -2012 +2012 @@
  * Internal: Reads a given amount of data from the image chain of the disk.
  **/
-static int vdDiskReadHelper(PVBOXHDD pDisk, PVDIMAGE pImage, PVDIMAGE pImageParentOverride,
+static int vdDiskReadHelper(PVDISK pDisk, PVDIMAGE pImage, PVDIMAGE pImageParentOverride,
                             uint64_t uOffset, size_t cbRead, PVDIOCTX pIoCtx, size_t *pcbThisRead)
 {
@@ -2056 +2056 @@
 {
     int rc;
-    PVBOXHDD pDisk                = pIoCtx->pDisk;
+    PVDISK pDisk                = pIoCtx->pDisk;
     size_t cbToRead               = pIoCtx->Req.Io.cbTransfer;
     uint64_t uOffset              = pIoCtx->Req.Io.uOffset;
@@ -2261 +2261 @@
  *                                  the read is cut off. A value of 0 disables the cut off.
  */
-static int vdReadHelperEx(PVBOXHDD pDisk, PVDIMAGE pImage, PVDIMAGE pImageParentOverride,
+static int vdReadHelperEx(PVDISK pDisk, PVDIMAGE pImage, PVDIMAGE pImageParentOverride,
                           uint64_t uOffset, void *pvBuf, size_t cbRead,
                           bool fZeroFreeBlocks, bool fUpdateCache, unsigned cImagesRead)
@@ -2301 +2301 @@
  * will give us.
  */
-static int vdReadHelper(PVBOXHDD pDisk, PVDIMAGE pImage, uint64_t uOffset,
+static int vdReadHelper(PVDISK pDisk, PVDIMAGE pImage, uint64_t uOffset,
                         void *pvBuf, size_t cbRead, bool fUpdateCache)
 {
@@ -2311 +2311 @@
  * internal: mark the disk as not modified.
  */
-static void vdResetModifiedFlag(PVBOXHDD pDisk)
+static void vdResetModifiedFlag(PVDISK pDisk)
 {
     if (pDisk->uModified & VD_IMAGE_MODIFIED_FLAG)
@@ -2336 +2336 @@
  * internal: mark the disk as modified.
  */
-static void vdSetModifiedFlag(PVBOXHDD pDisk)
+static void vdSetModifiedFlag(PVDISK pDisk)
 {
     pDisk->uModified |= VD_IMAGE_MODIFIED_FLAG;
@@ -2360 +2360 @@
  * write optimizations.
  */
-static int vdWriteHelperEx(PVBOXHDD pDisk, PVDIMAGE pImage,
+static int vdWriteHelperEx(PVDISK pDisk, PVDIMAGE pImage,
                            PVDIMAGE pImageParentOverride, uint64_t uOffset,
                            const void *pvBuf, size_t cbWrite,
@@ -2400 +2400 @@
  * write optimizations.
  */
-static int vdWriteHelper(PVBOXHDD pDisk, PVDIMAGE pImage, uint64_t uOffset,
+static int vdWriteHelper(PVDISK pDisk, PVDIMAGE pImage, uint64_t uOffset,
                          const void *pvBuf, size_t cbWrite, uint32_t fFlags)
 {
@@ -2411 +2411 @@
  * to speed up the copy process if possible.
  */
-static int vdCopyHelper(PVBOXHDD pDiskFrom, PVDIMAGE pImageFrom, PVBOXHDD pDiskTo,
+static int vdCopyHelper(PVDISK pDiskFrom, PVDIMAGE pImageFrom, PVDISK pDiskTo,
                         uint64_t cbSize, unsigned cImagesFromRead, unsigned cImagesToRead,
                         bool fSuppressRedundantIo, PVDINTERFACEPROGRESS pIfProgress,
@@ -2579 +2579 @@
  * internal: mark the disk as modified - async version.
  */
-static int vdSetModifiedFlagAsync(PVBOXHDD pDisk, PVDIOCTX pIoCtx)
+static int vdSetModifiedFlagAsync(PVDISK pDisk, PVDIOCTX pIoCtx)
 {
     int rc = VINF_SUCCESS;
@@ -2764 +2764 @@
 static DECLCALLBACK(int) vdWriteHelperOptimizedAsync(PVDIOCTX pIoCtx)
 {
-    PVBOXHDD pDisk = pIoCtx->pDisk;
+    PVDISK pDisk = pIoCtx->pDisk;
     uint64_t uOffset   = pIoCtx->Type.Child.uOffsetSaved;
     size_t cbThisWrite = pIoCtx->Type.Child.cbTransferParent;
@@ -2934 +2934 @@
 static DECLCALLBACK(int) vdWriteHelperStandardAsync(PVDIOCTX pIoCtx)
 {
-    PVBOXHDD pDisk = pIoCtx->pDisk;
+    PVDISK pDisk = pIoCtx->pDisk;
     uint64_t uOffset   = pIoCtx->Type.Child.uOffsetSaved;
     size_t cbThisWrite = pIoCtx->Type.Child.cbTransferParent;
@@ -2999 +2999 @@
     uint64_t uOffset = pIoCtx->Req.Io.uOffset;
     PVDIMAGE pImage  = pIoCtx->Req.Io.pImageCur;
-    PVBOXHDD pDisk   = pIoCtx->pDisk;
+    PVDISK pDisk   = pIoCtx->pDisk;
     unsigned fWrite;
     size_t cbThisWrite;
@@ -3176 +3176 @@
 {
     int rc = VINF_SUCCESS;
-    PVBOXHDD pDisk = pIoCtx->pDisk;
+    PVDISK pDisk = pIoCtx->pDisk;
     PVDIMAGE pImage = pIoCtx->Req.Io.pImageCur;
 
@@ -3220 +3220 @@
 {
     int rc = VINF_SUCCESS;
-    PVBOXHDD pDisk = pIoCtx->pDisk;
+    PVDISK pDisk = pIoCtx->pDisk;
     PVDDISCARDSTATE pDiscard = pDisk->pDiscard;
     PVDDISCARDBLOCK pBlock = pIoCtx->Req.Discard.pBlock;
@@ -3268 +3268 @@
  *                             The number of bytes waiting can be less.
  */
-static int vdDiscardRemoveBlocksAsync(PVBOXHDD pDisk, PVDIOCTX pIoCtx, size_t cbDiscardingNew)
+static int vdDiscardRemoveBlocksAsync(PVDISK pDisk, PVDIOCTX pIoCtx, size_t cbDiscardingNew)
 {
     int rc = VINF_SUCCESS;
@@ -3357 +3357 @@
 static DECLCALLBACK(int) vdDiscardCurrentRangeAsync(PVDIOCTX pIoCtx)
 {
-    PVBOXHDD        pDisk         = pIoCtx->pDisk;
+    PVDISK        pDisk         = pIoCtx->pDisk;
     PVDDISCARDSTATE pDiscard      = pDisk->pDiscard;
     uint64_t        offStart      = pIoCtx->Req.Discard.offCur;
@@ -3431 +3431 @@
 {
     int rc             = VINF_SUCCESS;
-    PVBOXHDD  pDisk    = pIoCtx->pDisk;
+    PVDISK  pDisk    = pIoCtx->pDisk;
     PCRTRANGE paRanges = pIoCtx->Req.Discard.paRanges;
     unsigned  cRanges  = pIoCtx->Req.Discard.cRanges;
@@ -4138 +4138 @@
 static int vdIoCtxContinue(PVDIOCTX pIoCtx, int rcReq)
 {
-    PVBOXHDD pDisk = pIoCtx->pDisk;
+    PVDISK pDisk = pIoCtx->pDisk;
     int rc = VINF_SUCCESS;
 
@@ -4238 +4238 @@
 {
     int rc = VINF_SUCCESS;
-    PVBOXHDD pDisk = pIoCtx->pDisk;
+    PVDISK pDisk = pIoCtx->pDisk;
 
     LogFlowFunc(("pIoStorage=%#p pIoCtx=%#p pfnComplete=%#p pvUser=%#p cbTransfer=%zu rcReq=%Rrc\n",
@@ -4298 +4298 @@
                                PVDMETAXFER pMetaXfer, int rcReq)
 {
-    PVBOXHDD pDisk = pIoStorage->pVDIo->pDisk;
+    PVDISK pDisk = pIoStorage->pVDIo->pDisk;
     RTLISTNODE ListIoCtxWaiting;
     bool fFlush;
@@ -4414 +4414 @@
  * @param   pDisk    The disk to process the list for.
  */
-static void vdIoTaskProcessWaitingList(PVBOXHDD pDisk)
+static void vdIoTaskProcessWaitingList(PVDISK pDisk)
 {
     LogFlowFunc(("pDisk=%#p\n", pDisk));
@@ -4459 +4459 @@
  * @param   pDisk    The disk.
  */
-static void vdIoCtxProcessHaltedList(PVBOXHDD pDisk)
+static void vdIoCtxProcessHaltedList(PVDISK pDisk)
 {
     LogFlowFunc(("pDisk=%#p\n", pDisk));
@@ -4501 +4501 @@
  * @param   pIoCtxRc The I/O context to get the status code from, optional.
  */
-static int vdDiskUnlock(PVBOXHDD pDisk, PVDIOCTX pIoCtxRc)
+static int vdDiskUnlock(PVDISK pDisk, PVDIOCTX pIoCtxRc)
 {
     int rc = VINF_SUCCESS;
@@ -4552 +4552 @@
 {
     PVDIOSTORAGE pIoStorage = pIoTask->pIoStorage;
-    PVBOXHDD pDisk = pIoStorage->pVDIo->pDisk;
+    PVDISK pDisk = pIoStorage->pVDIo->pDisk;
 
     Log(("Deferring I/O task pIoTask=%p\n", pIoTask));
@@ -4754 +4754 @@
     int rc = VINF_SUCCESS;
     PVDIO    pVDIo = (PVDIO)pvUser;
-    PVBOXHDD pDisk = pVDIo->pDisk;
+    PVDISK pDisk = pVDIo->pDisk;
 
     LogFlowFunc(("pvUser=%#p pIoStorage=%#p uOffset=%llu pIoCtx=%#p cbRead=%u\n",
@@ -4852 +4852 @@
     int rc = VINF_SUCCESS;
     PVDIO    pVDIo = (PVDIO)pvUser;
-    PVBOXHDD pDisk = pVDIo->pDisk;
+    PVDISK pDisk = pVDIo->pDisk;
 
     LogFlowFunc(("pvUser=%#p pIoStorage=%#p uOffset=%llu pIoCtx=%#p cbWrite=%u\n",
@@ -4952 +4952 @@
 {
     PVDIO pVDIo     = (PVDIO)pvUser;
-    PVBOXHDD pDisk  = pVDIo->pDisk;
+    PVDISK pDisk  = pVDIo->pDisk;
     int rc = VINF_SUCCESS;
     RTSGSEG Seg;
@@ -5073 +5073 @@
 {
     PVDIO    pVDIo = (PVDIO)pvUser;
-    PVBOXHDD pDisk = pVDIo->pDisk;
+    PVDISK pDisk = pVDIo->pDisk;
     int rc = VINF_SUCCESS;
     RTSGSEG Seg;
@@ -5229 +5229 @@
 {
     PVDIO    pVDIo = (PVDIO)pvUser;
-    PVBOXHDD pDisk = pVDIo->pDisk;
+    PVDISK pDisk = pVDIo->pDisk;
     PVDIOSTORAGE pIoStorage;
 
@@ -5265 +5265 @@
 {
     PVDIO    pVDIo = (PVDIO)pvUser;
-    PVBOXHDD pDisk = pVDIo->pDisk;
+    PVDISK pDisk = pVDIo->pDisk;
     int rc = VINF_SUCCESS;
     PVDIOTASK pIoTask;
@@ -5342 +5342 @@
 {
     PVDIO    pVDIo = (PVDIO)pvUser;
-    PVBOXHDD pDisk = pVDIo->pDisk;
+    PVDISK pDisk = pVDIo->pDisk;
     size_t cbCopied = 0;
 
@@ -5362 +5362 @@
 {
     PVDIO    pVDIo = (PVDIO)pvUser;
-    PVBOXHDD pDisk = pVDIo->pDisk;
+    PVDISK pDisk = pVDIo->pDisk;
     size_t cbCopied = 0;
 
@@ -5381 +5381 @@
 {
     PVDIO    pVDIo = (PVDIO)pvUser;
-    PVBOXHDD pDisk = pVDIo->pDisk;
+    PVDISK pDisk = pVDIo->pDisk;
     size_t cbSet = 0;
 
@@ -5402 +5402 @@
 {
     PVDIO    pVDIo = (PVDIO)pvUser;
-    PVBOXHDD pDisk = pVDIo->pDisk;
+    PVDISK pDisk = pVDIo->pDisk;
     size_t cbCreated = 0;
 
@@ -5425 +5425 @@
 {
     PVDIO    pVDIo = (PVDIO)pvUser;
-    PVBOXHDD pDisk = pVDIo->pDisk;
+    PVDISK pDisk = pVDIo->pDisk;
 
     LogFlowFunc(("pvUser=%#p pIoCtx=%#p rcReq=%Rrc cbCompleted=%zu\n",
@@ -5481 +5481 @@
     RT_NOREF1(pIoCtx);
     PVDIO    pVDIo = (PVDIO)pvUser;
-    PVBOXHDD pDisk = pVDIo->pDisk;
+    PVDISK pDisk = pVDIo->pDisk;
 
     PVDIMAGE pImage = vdGetImageByNumber(pDisk, VD_LAST_IMAGE);
@@ -5654 +5654 @@
 }
 
-DECLINLINE(int) vdMessageWrapper(PVBOXHDD pDisk, const char *pszFormat, ...)
+DECLINLINE(int) vdMessageWrapper(PVDISK pDisk, const char *pszFormat, ...)
 {
     va_list va;
@@ -6142 +6142 @@
  * @param   ppDisk          Where to store the reference to HDD container.
  */
-VBOXDDU_DECL(int) VDCreate(PVDINTERFACE pVDIfsDisk, VDTYPE enmType, PVBOXHDD *ppDisk)
+VBOXDDU_DECL(int) VDCreate(PVDINTERFACE pVDIfsDisk, VDTYPE enmType, PVDISK *ppDisk)
 {
     int rc = VINF_SUCCESS;
-    PVBOXHDD pDisk = NULL;
+    PVDISK pDisk = NULL;
 
     LogFlowFunc(("pVDIfsDisk=%#p\n", pVDIfsDisk));
@@ -6155 +6155 @@
                            rc = VERR_INVALID_PARAMETER);
 
-        pDisk = (PVBOXHDD)RTMemAllocZ(sizeof(VBOXHDD));
+        pDisk = (PVDISK)RTMemAllocZ(sizeof(VDISK));
         if (pDisk)
         {
@@ -6225 +6225 @@
  * @param   pDisk           Pointer to HDD container.
  */
-VBOXDDU_DECL(int) VDDestroy(PVBOXHDD pDisk)
+VBOXDDU_DECL(int) VDDestroy(PVDISK pDisk)
 {
     int rc = VINF_SUCCESS;
@@ -6411 +6411 @@
  * @param   pVDIfsImage     Pointer to the per-image VD interface list.
  */
-VBOXDDU_DECL(int) VDOpen(PVBOXHDD pDisk, const char *pszBackend,
+VBOXDDU_DECL(int) VDOpen(PVDISK pDisk, const char *pszBackend,
                          const char *pszFilename, unsigned uOpenFlags,
                          PVDINTERFACE pVDIfsImage)
@@ -6738 +6738 @@
  * @param   pVDIfsCache     Pointer to the per-cache VD interface list.
  */
-VBOXDDU_DECL(int) VDCacheOpen(PVBOXHDD pDisk, const char *pszBackend,
+VBOXDDU_DECL(int) VDCacheOpen(PVDISK pDisk, const char *pszBackend,
                               const char *pszFilename, unsigned uOpenFlags,
                               PVDINTERFACE pVDIfsCache)
@@ -6910 +6910 @@
 }
 
-VBOXDDU_DECL(int) VDFilterAdd(PVBOXHDD pDisk, const char *pszFilter, uint32_t fFlags,
+VBOXDDU_DECL(int) VDFilterAdd(PVDISK pDisk, const char *pszFilter, uint32_t fFlags,
                               PVDINTERFACE pVDIfsFilter)
 {
@@ -7021 +7021 @@
  * @param   pVDIfsOperation Pointer to the per-operation VD interface list.
  */
-VBOXDDU_DECL(int) VDCreateBase(PVBOXHDD pDisk, const char *pszBackend,
+VBOXDDU_DECL(int) VDCreateBase(PVDISK pDisk, const char *pszBackend,
                                const char *pszFilename, uint64_t cbSize,
                                unsigned uImageFlags, const char *pszComment,
@@ -7318 +7318 @@
  * @param   pVDIfsOperation Pointer to the per-operation VD interface list.
  */
-VBOXDDU_DECL(int) VDCreateDiff(PVBOXHDD pDisk, const char *pszBackend,
+VBOXDDU_DECL(int) VDCreateDiff(PVDISK pDisk, const char *pszBackend,
                                const char *pszFilename, unsigned uImageFlags,
                                const char *pszComment, PCRTUUID pUuid,
@@ -7593 +7593 @@
  * @param   pVDIfsOperation Pointer to the per-operation VD interface list.
  */
-VBOXDDU_DECL(int) VDCreateCache(PVBOXHDD pDisk, const char *pszBackend,
+VBOXDDU_DECL(int) VDCreateCache(PVDISK pDisk, const char *pszBackend,
                                 const char *pszFilename, uint64_t cbSize,
                                 unsigned uImageFlags, const char *pszComment,
@@ -7808 +7808 @@
  * @param   pVDIfsOperation Pointer to the per-operation VD interface list.
  */
-VBOXDDU_DECL(int) VDMerge(PVBOXHDD pDisk, unsigned nImageFrom,
+VBOXDDU_DECL(int) VDMerge(PVDISK pDisk, unsigned nImageFrom,
                           unsigned nImageTo, PVDINTERFACE pVDIfsOperation)
 {
@@ -8258 +8258 @@
  *                          for the destination operation.
  */
-VBOXDDU_DECL(int) VDCopyEx(PVBOXHDD pDiskFrom, unsigned nImage, PVBOXHDD pDiskTo,
+VBOXDDU_DECL(int) VDCopyEx(PVDISK pDiskFrom, unsigned nImage, PVDISK pDiskTo,
                            const char *pszBackend, const char *pszFilename,
                            bool fMoveByRename, uint64_t cbSize,
@@ -8589 +8589 @@
  *                          for the destination image.
  */
-VBOXDDU_DECL(int) VDCopy(PVBOXHDD pDiskFrom, unsigned nImage, PVBOXHDD pDiskTo,
+VBOXDDU_DECL(int) VDCopy(PVDISK pDiskFrom, unsigned nImage, PVDISK pDiskTo,
                          const char *pszBackend, const char *pszFilename,
                          bool fMoveByRename, uint64_t cbSize,
@@ -8619 +8619 @@
  * @param   pVDIfsOperation Pointer to the per-operation VD interface list.
  */
-VBOXDDU_DECL(int) VDCompact(PVBOXHDD pDisk, unsigned nImage,
+VBOXDDU_DECL(int) VDCompact(PVDISK pDisk, unsigned nImage,
                             PVDINTERFACE pVDIfsOperation)
 {
@@ -8727 +8727 @@
  * @param   pVDIfsOperation Pointer to the per-operation VD interface list.
  */
-VBOXDDU_DECL(int) VDResize(PVBOXHDD pDisk, uint64_t cbSize,
+VBOXDDU_DECL(int) VDResize(PVDISK pDisk, uint64_t cbSize,
                            PCVDGEOMETRY pPCHSGeometry,
                            PCVDGEOMETRY pLCHSGeometry,
@@ -8846 +8846 @@
 }
 
-VBOXDDU_DECL(int) VDPrepareWithFilters(PVBOXHDD pDisk, PVDINTERFACE pVDIfsOperation)
+VBOXDDU_DECL(int) VDPrepareWithFilters(PVDISK pDisk, PVDINTERFACE pVDIfsOperation)
 {
     int rc = VINF_SUCCESS;
@@ -9048 +9048 @@
  * @param   fDelete         If true, delete the image from the host disk.
  */
-VBOXDDU_DECL(int) VDClose(PVBOXHDD pDisk, bool fDelete)
+VBOXDDU_DECL(int) VDClose(PVDISK pDisk, bool fDelete)
 {
     int rc = VINF_SUCCESS;
@@ -9158 +9158 @@
  * @param   fDelete         If true, delete the image from the host disk.
  */
-VBOXDDU_DECL(int) VDCacheClose(PVBOXHDD pDisk, bool fDelete)
+VBOXDDU_DECL(int) VDCacheClose(PVDISK pDisk, bool fDelete)
 {
     int rc = VINF_SUCCESS;
@@ -9198 +9198 @@
 }
 
-VBOXDDU_DECL(int) VDFilterRemove(PVBOXHDD pDisk, uint32_t fFlags)
+VBOXDDU_DECL(int) VDFilterRemove(PVDISK pDisk, uint32_t fFlags)
 {
     int rc = VINF_SUCCESS;
@@ -9256 +9256 @@
  * @param   pDisk           Pointer to HDD container.
  */
-VBOXDDU_DECL(int) VDCloseAll(PVBOXHDD pDisk)
+VBOXDDU_DECL(int) VDCloseAll(PVDISK pDisk)
 {
     int rc = VINF_SUCCESS;
@@ -9320 +9320 @@
  * @param   pDisk           Pointer to HDD container.
  */
-VBOXDDU_DECL(int) VDFilterRemoveAll(PVBOXHDD pDisk)
+VBOXDDU_DECL(int) VDFilterRemoveAll(PVDISK pDisk)
 {
     int rc = VINF_SUCCESS;
@@ -9374 +9374 @@
  * @param   cbRead          Number of bytes to read.
  */
-VBOXDDU_DECL(int) VDRead(PVBOXHDD pDisk, uint64_t uOffset, void *pvBuf,
+VBOXDDU_DECL(int) VDRead(PVDISK pDisk, uint64_t uOffset, void *pvBuf,
                          size_t cbRead)
 {
@@ -9443 +9443 @@
  * @param   cbWrite         Number of bytes to write.
  */
-VBOXDDU_DECL(int) VDWrite(PVBOXHDD pDisk, uint64_t uOffset, const void *pvBuf,
+VBOXDDU_DECL(int) VDWrite(PVDISK pDisk, uint64_t uOffset, const void *pvBuf,
                           size_t cbWrite)
 {
@@ -9514 +9514 @@
  * @param   pDisk           Pointer to HDD container.
  */
-VBOXDDU_DECL(int) VDFlush(PVBOXHDD pDisk)
+VBOXDDU_DECL(int) VDFlush(PVDISK pDisk)
 {
     int rc = VINF_SUCCESS;
@@ -9568 +9568 @@
  * @param   pDisk           Pointer to HDD container.
  */
-VBOXDDU_DECL(unsigned) VDGetCount(PVBOXHDD pDisk)
+VBOXDDU_DECL(unsigned) VDGetCount(PVDISK pDisk)
 {
     unsigned cImages;
@@ -9605 +9605 @@
  * @param   pDisk           Pointer to HDD container.
  */
-VBOXDDU_DECL(bool) VDIsReadOnly(PVBOXHDD pDisk)
+VBOXDDU_DECL(bool) VDIsReadOnly(PVDISK pDisk)
 {
     bool fReadOnly;
@@ -9648 +9648 @@
  * @param   nImage          Image number, counts from 0. 0 is always base image of container.
  */
-VBOXDDU_DECL(uint32_t) VDGetSectorSize(PVBOXHDD pDisk, unsigned nImage)
+VBOXDDU_DECL(uint32_t) VDGetSectorSize(PVDISK pDisk, unsigned nImage)
 {
     uint64_t cbSector;
@@ -9688 +9688 @@
  * @param   nImage          Image number, counts from 0. 0 is always base image of container.
  */
-VBOXDDU_DECL(uint64_t) VDGetSize(PVBOXHDD pDisk, unsigned nImage)
+VBOXDDU_DECL(uint64_t) VDGetSize(PVDISK pDisk, unsigned nImage)
 {
     uint64_t cbSize;
@@ -9728 +9728 @@
  * @param   nImage          Image number, counts from 0. 0 is always base image of container.
  */
-VBOXDDU_DECL(uint64_t) VDGetFileSize(PVBOXHDD pDisk, unsigned nImage)
+VBOXDDU_DECL(uint64_t) VDGetFileSize(PVDISK pDisk, unsigned nImage)
 {
     uint64_t cbSize;
@@ -9770 +9770 @@
  * @param   pPCHSGeometry   Where to store PCHS geometry. Not NULL.
  */
-VBOXDDU_DECL(int) VDGetPCHSGeometry(PVBOXHDD pDisk, unsigned nImage,
+VBOXDDU_DECL(int) VDGetPCHSGeometry(PVDISK pDisk, unsigned nImage,
                                     PVDGEOMETRY pPCHSGeometry)
 {
@@ -9834 +9834 @@
  * @param   pPCHSGeometry   Where to load PCHS geometry from. Not NULL.
  */
-VBOXDDU_DECL(int) VDSetPCHSGeometry(PVBOXHDD pDisk, unsigned nImage,
+VBOXDDU_DECL(int) VDSetPCHSGeometry(PVDISK pDisk, unsigned nImage,
                                     PCVDGEOMETRY pPCHSGeometry)
 {
@@ -9938 +9938 @@
  * @param   pLCHSGeometry   Where to store LCHS geometry. Not NULL.
  */
-VBOXDDU_DECL(int) VDGetLCHSGeometry(PVBOXHDD pDisk, unsigned nImage,
+VBOXDDU_DECL(int) VDGetLCHSGeometry(PVDISK pDisk, unsigned nImage,
                                     PVDGEOMETRY pLCHSGeometry)
 {
@@ -10002 +10002 @@
  * @param   pLCHSGeometry   Where to load LCHS geometry from. Not NULL.
  */
-VBOXDDU_DECL(int) VDSetLCHSGeometry(PVBOXHDD pDisk, unsigned nImage,
+VBOXDDU_DECL(int) VDSetLCHSGeometry(PVDISK pDisk, unsigned nImage,
                                     PCVDGEOMETRY pLCHSGeometry)
 {
@@ -10108 +10108 @@
  *                          with VDRegionListFree().
  */
-VBOXDDU_DECL(int) VDQueryRegions(PVBOXHDD pDisk, unsigned nImage, uint32_t fFlags,
+VBOXDDU_DECL(int) VDQueryRegions(PVDISK pDisk, unsigned nImage, uint32_t fFlags,
                                  PPVDREGIONLIST ppRegionList)
 {
@@ -10219 +10219 @@
  * @param   puVersion       Where to store the image version.
  */
-VBOXDDU_DECL(int) VDGetVersion(PVBOXHDD pDisk, unsigned nImage,
+VBOXDDU_DECL(int) VDGetVersion(PVDISK pDisk, unsigned nImage,
                                unsigned *puVersion)
 {
@@ -10268 +10268 @@
  * @param   pBackendInfo    Where to store the backend information.
  */
-VBOXDDU_DECL(int) VDBackendInfoSingle(PVBOXHDD pDisk, unsigned nImage,
+VBOXDDU_DECL(int) VDBackendInfoSingle(PVDISK pDisk, unsigned nImage,
                                       PVDBACKENDINFO pBackendInfo)
 {
@@ -10320 +10320 @@
  * @param   puImageFlags    Where to store the image flags.
  */
-VBOXDDU_DECL(int) VDGetImageFlags(PVBOXHDD pDisk, unsigned nImage,
+VBOXDDU_DECL(int) VDGetImageFlags(PVDISK pDisk, unsigned nImage,
                                   unsigned *puImageFlags)
 {
@@ -10369 +10369 @@
  * @param   puOpenFlags     Where to store the image open flags.
  */
-VBOXDDU_DECL(int) VDGetOpenFlags(PVBOXHDD pDisk, unsigned nImage,
+VBOXDDU_DECL(int) VDGetOpenFlags(PVDISK pDisk, unsigned nImage,
                                  unsigned *puOpenFlags)
 {
@@ -10420 +10420 @@
  * @param   uOpenFlags      Image file open mode, see VD_OPEN_FLAGS_* constants.
  */
-VBOXDDU_DECL(int) VDSetOpenFlags(PVBOXHDD pDisk, unsigned nImage,
+VBOXDDU_DECL(int) VDSetOpenFlags(PVDISK pDisk, unsigned nImage,
                                  unsigned uOpenFlags)
 {
@@ -10480 +10480 @@
  * @param   cbFilename      Size of buffer pszFilename points to.
  */
-VBOXDDU_DECL(int) VDGetFilename(PVBOXHDD pDisk, unsigned nImage,
+VBOXDDU_DECL(int) VDGetFilename(PVDISK pDisk, unsigned nImage,
                                 char *pszFilename, unsigned cbFilename)
 {
@@ -10545 +10545 @@
  * @param   cbComment       The size of pszComment buffer. 0 is ok.
  */
-VBOXDDU_DECL(int) VDGetComment(PVBOXHDD pDisk, unsigned nImage,
+VBOXDDU_DECL(int) VDGetComment(PVDISK pDisk, unsigned nImage,
                                char *pszComment, unsigned cbComment)
 {
@@ -10598 +10598 @@
  * @param   pszComment      New comment string (UTF-8). NULL is allowed to reset the comment.
  */
-VBOXDDU_DECL(int) VDSetComment(PVBOXHDD pDisk, unsigned nImage,
+VBOXDDU_DECL(int) VDSetComment(PVDISK pDisk, unsigned nImage,
                                const char *pszComment)
 {
@@ -10648 +10648 @@
  * @param   pUuid           Where to store the image creation UUID.
  */
-VBOXDDU_DECL(int) VDGetUuid(PVBOXHDD pDisk, unsigned nImage, PRTUUID pUuid)
+VBOXDDU_DECL(int) VDGetUuid(PVDISK pDisk, unsigned nImage, PRTUUID pUuid)
 {
     int rc;
@@ -10695 +10695 @@
  * @param   pUuid           New UUID of the image. If NULL, a new UUID is created.
  */
-VBOXDDU_DECL(int) VDSetUuid(PVBOXHDD pDisk, unsigned nImage, PCRTUUID pUuid)
+VBOXDDU_DECL(int) VDSetUuid(PVDISK pDisk, unsigned nImage, PCRTUUID pUuid)
 {
     int rc;
@@ -10748 +10748 @@
  * @param   pUuid           Where to store the image modification UUID.
  */
-VBOXDDU_DECL(int) VDGetModificationUuid(PVBOXHDD pDisk, unsigned nImage, PRTUUID pUuid)
+VBOXDDU_DECL(int) VDGetModificationUuid(PVDISK pDisk, unsigned nImage, PRTUUID pUuid)
 {
     int rc = VINF_SUCCESS;
@@ -10796 +10796 @@
  * @param   pUuid           New modification UUID of the image. If NULL, a new UUID is created.
  */
-VBOXDDU_DECL(int) VDSetModificationUuid(PVBOXHDD pDisk, unsigned nImage, PCRTUUID pUuid)
+VBOXDDU_DECL(int) VDSetModificationUuid(PVDISK pDisk, unsigned nImage, PCRTUUID pUuid)
 {
     int rc;
@@ -10851 +10851 @@
  * @param   pUuid           Where to store the parent image UUID.
  */
-VBOXDDU_DECL(int) VDGetParentUuid(PVBOXHDD pDisk, unsigned nImage,
+VBOXDDU_DECL(int) VDGetParentUuid(PVDISK pDisk, unsigned nImage,
                                   PRTUUID pUuid)
 {
@@ -10898 +10898 @@
  * @param   pUuid           New parent UUID of the image. If NULL, a new UUID is created.
  */
-VBOXDDU_DECL(int) VDSetParentUuid(PVBOXHDD pDisk, unsigned nImage,
+VBOXDDU_DECL(int) VDSetParentUuid(PVDISK pDisk, unsigned nImage,
                                   PCRTUUID pUuid)
 {
@@ -10950 +10950 @@
  * @param   pDisk           Pointer to HDD container.
  */
-VBOXDDU_DECL(void) VDDumpImages(PVBOXHDD pDisk)
+VBOXDDU_DECL(void) VDDumpImages(PVDISK pDisk)
 {
     int rc2;
@@ -10985 +10985 @@
 
 
-VBOXDDU_DECL(int) VDDiscardRanges(PVBOXHDD pDisk, PCRTRANGE paRanges, unsigned cRanges)
+VBOXDDU_DECL(int) VDDiscardRanges(PVDISK pDisk, PCRTRANGE paRanges, unsigned cRanges)
 {
     int rc;
@@ -11043 +11043 @@
 
 
-VBOXDDU_DECL(int) VDAsyncRead(PVBOXHDD pDisk, uint64_t uOffset, size_t cbRead,
+VBOXDDU_DECL(int) VDAsyncRead(PVDISK pDisk, uint64_t uOffset, size_t cbRead,
                               PCRTSGBUF pcSgBuf,
                               PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
@@ -11115 +11115 @@
 
 
-VBOXDDU_DECL(int) VDAsyncWrite(PVBOXHDD pDisk, uint64_t uOffset, size_t cbWrite,
+VBOXDDU_DECL(int) VDAsyncWrite(PVDISK pDisk, uint64_t uOffset, size_t cbWrite,
                                PCRTSGBUF pcSgBuf,
                                PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
@@ -11185 +11185 @@
 
 
-VBOXDDU_DECL(int) VDAsyncFlush(PVBOXHDD pDisk, PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
+VBOXDDU_DECL(int) VDAsyncFlush(PVDISK pDisk, PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
                                void *pvUser1, void *pvUser2)
 {
@@ -11240 +11240 @@
 }
 
-VBOXDDU_DECL(int) VDAsyncDiscardRanges(PVBOXHDD pDisk, PCRTRANGE paRanges, unsigned cRanges,
+VBOXDDU_DECL(int) VDAsyncDiscardRanges(PVDISK pDisk, PCRTRANGE paRanges, unsigned cRanges,
                                        PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
                                        void *pvUser1, void *pvUser2)

trunk/src/VBox/Storage/VDVfs.cpp

@@ -43 +43 @@
 {
     /** The volume the VFS file belongs to. */
-    PVBOXHDD       pDisk;
+    PVDISK         pDisk;
     /** Current position. */
     uint64_t       offCurPos;
@@ -61 +61 @@
  * @param   cbRead   Amount of bytes to read.
  */
-static int vdReadHelper(PVBOXHDD pDisk, uint64_t off, void *pvBuf, size_t cbRead)
+static int vdReadHelper(PVDISK pDisk, uint64_t off, void *pvBuf, size_t cbRead)
 {
     int rc = VINF_SUCCESS;
@@ -129 +129 @@
  * @param   cbWrite  Amount of bytes to write.
  */
-static int vdWriteHelper(PVBOXHDD pDisk, uint64_t off, const void *pvBuf, size_t cbWrite)
+static int vdWriteHelper(PVDISK pDisk, uint64_t off, const void *pvBuf, size_t cbWrite)
 {
     int rc = VINF_SUCCESS;
@@ -520 +520 @@
 
 
-VBOXDDU_DECL(int) VDCreateVfsFileFromDisk(PVBOXHDD pDisk, uint32_t fFlags,
+VBOXDDU_DECL(int) VDCreateVfsFileFromDisk(PVDISK pDisk, uint32_t fFlags,
                                           PRTVFSFILE phVfsFile)
 {

trunk/src/VBox/Storage/VMDK.cpp

@@ -3348 +3348 @@
  * Internal: create VMDK images for raw disk/partition access.
  */
-static int vmdkCreateRawImage(PVMDKIMAGE pImage, const PVBOXHDDRAW pRaw,
+static int vmdkCreateRawImage(PVMDKIMAGE pImage, const PVDISKRAW pRaw,
                               uint64_t cbSize)
 {
@@ -3354 +3354 @@
     PVMDKEXTENT pExtent;
 
-    if (pRaw->uFlags & VBOXHDDRAW_DISK)
+    if (pRaw->uFlags & VDISKRAW_DISK)
     {
         /* Full raw disk access. This requires setting up a descriptor
@@ -3383 +3383 @@
         pExtent->cNominalSectors = VMDK_BYTE2SECTOR(cbSize);
         pExtent->uSectorOffset = 0;
-        pExtent->enmAccess = (pRaw->uFlags & VBOXHDDRAW_READONLY) ? VMDKACCESS_READONLY : VMDKACCESS_READWRITE;
+        pExtent->enmAccess = (pRaw->uFlags & VDISKRAW_READONLY) ? VMDKACCESS_READONLY : VMDKACCESS_READWRITE;
         pExtent->fMetaDirty = false;
 
@@ -3406 +3406 @@
         for (unsigned i = 0; i < pRaw->cPartDescs; i++)
         {
-            PVBOXHDDRAWPARTDESC pPart = &pRaw->pPartDescs[i];
+            PVDISKRAWPARTDESC pPart = &pRaw->pPartDescs[i];
             if (uStart > pPart->uStart)
                 return vdIfError(pImage->pIfError, VERR_INVALID_PARAMETER, RT_SRC_POS,
@@ -3452 +3452 @@
         for (unsigned i = 0; i < pRaw->cPartDescs; i++)
         {
-            PVBOXHDDRAWPARTDESC pPart = &pRaw->pPartDescs[i];
+            PVDISKRAWPARTDESC pPart = &pRaw->pPartDescs[i];
             pExtent = &pImage->pExtents[cExtents++];
 
@@ -3527 +3527 @@
                     pExtent->cNominalSectors = VMDK_BYTE2SECTOR(pPart->cbData);
                     pExtent->uSectorOffset = VMDK_BYTE2SECTOR(pPart->uStartOffset);
-                    pExtent->enmAccess = (pPart->uFlags & VBOXHDDRAW_READONLY) ? VMDKACCESS_READONLY : VMDKACCESS_READWRITE;
+                    pExtent->enmAccess = (pPart->uFlags & VDISKRAW_READONLY) ? VMDKACCESS_READONLY : VMDKACCESS_READWRITE;
                     pExtent->fMetaDirty = false;
 
@@ -3564 +3564 @@
 
     rc = vmdkDescBaseSetStr(pImage, &pImage->Descriptor, "createType",
-                            (pRaw->uFlags & VBOXHDDRAW_DISK) ?
+                            (pRaw->uFlags & VDISKRAW_DISK) ?
                             "fullDevice" : "partitionedDevice");
     if (RT_FAILURE(rc))
@@ -3947 +3947 @@
         {
             /* Raw disk image (includes raw partition). */
-            const PVBOXHDDRAW pRaw = (const PVBOXHDDRAW)pszComment;
+            const PVDISKRAW pRaw = (const PVDISKRAW)pszComment;
             /* As the comment is misused, zap it so that no garbage comment
              * is set below. */

trunk/src/VBox/Storage/testcase/tstVD.cpp

@@ -67 +67 @@
 {
     int rc;
-    PVBOXHDD pVD = NULL;
+    PVDISK pVD = NULL;
     VDGEOMETRY       PCHS = { 0, 0, 0 };
     VDGEOMETRY       LCHS = { 0, 0, 0 };
@@ -122 +122 @@
 {
     int rc;
-    PVBOXHDD         pVD = NULL;
+    PVDISK         pVD = NULL;
     PVDINTERFACE     pVDIfs = NULL;
     VDINTERFACEERROR VDIfError;
@@ -454 +454 @@
 }
 
-static void writeSegmentsToDisk(PVBOXHDD pVD, void *pvBuf, PSEGMENT pSegment)
+static void writeSegmentsToDisk(PVDISK pVD, void *pvBuf, PSEGMENT pSegment)
 {
     while (pSegment->u32Length)
@@ -465 +465 @@
 }
 
-static int readAndCompareSegments(PVBOXHDD pVD, void *pvBuf, PSEGMENT pSegment)
+static int readAndCompareSegments(PVDISK pVD, void *pvBuf, PSEGMENT pSegment)
 {
     while (pSegment->u32Length)
@@ -501 +501 @@
 {
     int rc;
-    PVBOXHDD pVD = NULL;
+    PVDISK pVD = NULL;
     char *pszFormat;
     VDTYPE enmType = VDTYPE_INVALID;
@@ -625 +625 @@
 {
     int rc;
-    PVBOXHDD pVD = NULL;
+    PVDISK pVD = NULL;
     VDGEOMETRY PCHS = { 0, 0, 0 };
     VDGEOMETRY LCHS = { 0, 0, 0 };
@@ -704 +704 @@
 {
     int rc;
-    PVBOXHDD pVD = NULL;
+    PVDISK pVD = NULL;
     PVDINTERFACE     pVDIfs = NULL;
     VDINTERFACEERROR VDIfError;
@@ -752 +752 @@
         return rc;
 
-    PVBOXHDD pVD = NULL;
+    PVDISK pVD = NULL;
     PVDINTERFACE     pVDIfs = NULL;
     VDINTERFACEERROR VDIfError;

trunk/src/VBox/Storage/testcase/tstVDFill.cpp

@@ -60 +60 @@
 {
     int rc;
-    PVBOXHDD pVD = NULL;
+    PVDISK pVD = NULL;
     VDGEOMETRY       PCHS = { 0, 0, 0 };
     VDGEOMETRY       LCHS = { 0, 0, 0 };

trunk/src/VBox/Storage/testcase/tstVDIo.cpp

@@ -99 +99 @@
     char          *pszName;
     /** HDD handle to operate on. */
-    PVBOXHDD       pVD;
+    PVDISK       pVD;
     /** Memory disk used for data verification. */
     PVDMEMDISK     pMemDiskVerify;
@@ -182 +182 @@
     /** S/G Buffer */
     RTSGBUF       SgBuf;
-    /** Data segment */
-    RTSGSEG       DataSeg;
     /** Flag whether the request is outstanding or not. */
     volatile bool fOutstanding;
     /** Buffer to use for reads. */
     void          *pvBufRead;
+    /** Contiguous buffer pointer backing the segments. */
+    void          *pvBuf;
     /** Opaque user data. */
     void          *pvUser;
+    /** Number of segments used for the data buffer. */
+    uint32_t      cSegs;
+    /** Array of data segments. */
+    RTSGSEG       aSegs[10];
 } VDIOREQ, *PVDIOREQ;
 
@@ -209 +213 @@
     /** Chance in percent to get a write. */
     unsigned    uWriteChance;
+    /** Maximum number of segments to create for one request. */
+    uint32_t    cSegsMax;
     /** Pointer to the I/O data generator. */
     PVDIORND    pIoRnd;
@@ -532 +538 @@
 }
 
-static int tstVDIoTestInit(PVDIOTEST pIoTest, PVDTESTGLOB pGlob, bool fRandomAcc, uint64_t cbIo,
-                           size_t cbBlkSize, uint64_t offStart, uint64_t offEnd,
+static int tstVDIoTestInit(PVDIOTEST pIoTest, PVDTESTGLOB pGlob, bool fRandomAcc, uint32_t cSegsMax,
+                           uint64_t cbIo, size_t cbBlkSize, uint64_t offStart, uint64_t offEnd,
                            unsigned uWriteChance, PVDPATTERN pPattern);
 static bool tstVDIoTestRunning(PVDIOTEST pIoTest);
@@ -756 +762 @@
 
         RTTestSub(pGlob->hTest, "Basic I/O");
-        rc = tstVDIoTestInit(&IoTest, pGlob, fRandomAcc, cbIo, cbBlkSize, offStart, offEnd, uWriteChance, pPattern);
+        rc = tstVDIoTestInit(&IoTest, pGlob, fRandomAcc, 5, cbIo, cbBlkSize, offStart, offEnd, uWriteChance, pPattern);
         if (RT_SUCCESS(rc))
         {
@@ -804 +810 @@
                                         case VDIOREQTXDIR_READ:
                                         {
-                                            rc = VDRead(pDisk->pVD, paIoReq[idx].off, paIoReq[idx].DataSeg.pvSeg, paIoReq[idx].cbReq);
+                                            rc = VDRead(pDisk->pVD, paIoReq[idx].off, paIoReq[idx].aSegs[0].pvSeg, paIoReq[idx].cbReq);
 
                                             if (RT_SUCCESS(rc)
@@ -810 +816 @@
                                             {
                                                 RTSGBUF SgBuf;
-                                                RTSgBufInit(&SgBuf, &paIoReq[idx].DataSeg, 1);
+                                                RTSgBufInit(&SgBuf, &paIoReq[idx].aSegs[0], paIoReq[idx].cSegs);
 
                                                 if (VDMemDiskCmp(pDisk->pMemDiskVerify, paIoReq[idx].off, paIoReq[idx].cbReq, &SgBuf))
@@ -822 +828 @@
                                         case VDIOREQTXDIR_WRITE:
                                         {
-                                            rc = VDWrite(pDisk->pVD, paIoReq[idx].off, paIoReq[idx].DataSeg.pvSeg, paIoReq[idx].cbReq);
+                                            rc = VDWrite(pDisk->pVD, paIoReq[idx].off, paIoReq[idx].aSegs[0].pvSeg, paIoReq[idx].cbReq);
 
                                             if (RT_SUCCESS(rc)
@@ -828 +834 @@
                                             {
                                                 RTSGBUF SgBuf;
-                                                RTSgBufInit(&SgBuf, &paIoReq[idx].DataSeg, 1);
+                                                RTSgBufInit(&SgBuf, &paIoReq[idx].aSegs[0], paIoReq[idx].cSegs);
                                                 rc = VDMemDiskWrite(pDisk->pMemDiskVerify, paIoReq[idx].off, paIoReq[idx].cbReq, &SgBuf);
                                             }
@@ -2371 +2377 @@
 }
 
-static int tstVDIoTestInit(PVDIOTEST pIoTest, PVDTESTGLOB pGlob, bool fRandomAcc, uint64_t cbIo,
-                           size_t cbBlkSize, uint64_t offStart, uint64_t offEnd,
+static int tstVDIoTestInit(PVDIOTEST pIoTest, PVDTESTGLOB pGlob, bool fRandomAcc, uint32_t cSegsMax,
+                           uint64_t cbIo, size_t cbBlkSize, uint64_t offStart, uint64_t offEnd,
                            unsigned uWriteChance, PVDPATTERN pPattern)
 {
@@ -2384 +2390 @@
     pIoTest->offEnd        = offEnd;
     pIoTest->uWriteChance  = uWriteChance;
+    pIoTest->cSegsMax      = cSegsMax;
     pIoTest->pIoRnd        = pGlob->pIoRnd;
     pIoTest->pPattern      = pPattern;
@@ -2424 +2431 @@
 }
 
+static uint32_t tstVDIoTestReqInitSegments(PVDIOTEST pIoTest, PRTSGSEG paSegs, uint32_t cSegs, void *pvBuf, size_t cbBuf)
+{
+    uint8_t *pbBuf = (uint8_t *)pvBuf;
+    size_t cSectorsLeft = cbBuf / 512;
+    uint32_t iSeg = 0;
+
+    /* Init all but the last segment which needs to take the rest. */
+    while (   iSeg < cSegs - 1
+           && cSectorsLeft)
+    {
+        uint32_t cThisSectors = VDIoRndGetU32Ex(pIoTest->pIoRnd, 1, cSectorsLeft / 2);
+        size_t cbThisBuf = cThisSectors * 512;
+
+        paSegs[iSeg].pvSeg = pbBuf;
+        paSegs[iSeg].cbSeg = cbThisBuf;
+        pbBuf        += cbThisBuf;
+        cSectorsLeft -= cThisSectors;
+        iSeg++;
+    }
+
+    if (cSectorsLeft)
+    {
+        paSegs[iSeg].pvSeg = pbBuf;
+        paSegs[iSeg].cbSeg = cSectorsLeft * 512;
+        iSeg++;
+    }
+
+    return iSeg;
+}
+
 /**
  * Returns true with the given chance in percent.
@@ -2447 +2484 @@
         pIoReq->cbReq = RT_MIN(pIoTest->cbBlkIo, pIoTest->cbIo);
         pIoTest->cbIo -= pIoReq->cbReq;
-        pIoReq->DataSeg.cbSeg = pIoReq->cbReq;
+
+        void *pvBuf = NULL;
 
         if (pIoReq->enmTxDir == VDIOREQTXDIR_WRITE)
         {
             if (pIoTest->pPattern)
-                rc = tstVDIoPatternGetBuffer(pIoTest->pPattern, &pIoReq->DataSeg.pvSeg, pIoReq->cbReq);
+                rc = tstVDIoPatternGetBuffer(pIoTest->pPattern, &pvBuf, pIoReq->cbReq);
             else
-                rc = VDIoRndGetBuffer(pIoTest->pIoRnd, &pIoReq->DataSeg.pvSeg, pIoReq->cbReq);
+                rc = VDIoRndGetBuffer(pIoTest->pIoRnd, &pvBuf, pIoReq->cbReq);
             AssertRC(rc);
         }
@@ -2460 +2498 @@
         {
             /* Read */
-            pIoReq->DataSeg.pvSeg = pIoReq->pvBufRead;
+            pvBuf = pIoReq->pvBufRead;
         }
 
         if (RT_SUCCESS(rc))
         {
-            RTSgBufInit(&pIoReq->SgBuf, &pIoReq->DataSeg, 1);
+            pIoReq->pvBuf = pvBuf;
+            uint32_t cSegsMax = VDIoRndGetU32Ex(pIoTest->pIoRnd, 1, RT_MIN(pIoTest->cSegsMax, RT_ELEMENTS(pIoReq->aSegs)));
+            pIoReq->cSegs = tstVDIoTestReqInitSegments(pIoTest, &pIoReq->aSegs[0], cSegsMax, pvBuf, pIoReq->cbReq);
+            RTSgBufInit(&pIoReq->SgBuf, &pIoReq->aSegs[0], pIoReq->cSegs);
 
             if (pIoTest->fRandomAccess)
@@ -2547 +2588 @@
             {
                 RTCritSectEnter(&pDisk->CritSectVerify);
-                RTSgBufReset(&pIoReq->SgBuf);
+
+                RTSGBUF SgBufCmp;
+                RTSGSEG SegCmp;
+                SegCmp.pvSeg = pIoReq->pvBuf;
+                SegCmp.cbSeg = pIoReq->cbReq;
+                RTSgBufInit(&SgBufCmp, &SegCmp, 1);
 
                 if (VDMemDiskCmp(pDisk->pMemDiskVerify, pIoReq->off, pIoReq->cbReq,
-                                 &pIoReq->SgBuf))
+                                 &SgBufCmp))
                     RTTestFailed(pDisk->pTestGlob->hTest, "Corrupted disk at offset %llu!\n", pIoReq->off);
                 RTCritSectLeave(&pDisk->CritSectVerify);
@@ -2558 +2604 @@
             {
                 RTCritSectEnter(&pDisk->CritSectVerify);
-                RTSgBufReset(&pIoReq->SgBuf);
+
+                RTSGBUF SgBuf;
+                RTSGSEG Seg;
+                Seg.pvSeg = pIoReq->pvBuf;
+                Seg.cbSeg = pIoReq->cbReq;
+                RTSgBufInit(&SgBuf, &Seg, 1);
 
                 int rc = VDMemDiskWrite(pDisk->pMemDiskVerify, pIoReq->off, pIoReq->cbReq,
-                                        &pIoReq->SgBuf);
+                                        &SgBuf);
                 AssertRC(rc);
                 RTCritSectLeave(&pDisk->CritSectVerify);

trunk/src/VBox/Storage/testcase/tstVDSnap.cpp

@@ -125 +125 @@
 }
 
-static int tstVDSnapWrite(PVBOXHDD pVD, PVDDISKSEG paDiskSegments, uint32_t cDiskSegments, uint64_t cbDisk, bool fInit)
+static int tstVDSnapWrite(PVDISK pVD, PVDDISKSEG paDiskSegments, uint32_t cDiskSegments, uint64_t cbDisk, bool fInit)
 {
     RT_NOREF1(cbDisk);
@@ -152 +152 @@
 }
 
-static int tstVDSnapReadVerify(PVBOXHDD pVD, PVDDISKSEG paDiskSegments, uint32_t cDiskSegments, uint64_t cbDisk)
+static int tstVDSnapReadVerify(PVDISK pVD, PVDDISKSEG paDiskSegments, uint32_t cDiskSegments, uint64_t cbDisk)
 {
     RT_NOREF1(cbDisk);
@@ -218 +218 @@
 {
     int rc;
-    PVBOXHDD pVD = NULL;
+    PVDISK pVD = NULL;
     VDGEOMETRY       PCHS = { 0, 0, 0 };
     VDGEOMETRY       LCHS = { 0, 0, 0 };

trunk/src/VBox/Storage/testcase/vbox-img.cpp

@@ -270 +270 @@
     }
 
-    PVBOXHDD pVD = NULL;
+    PVDISK pVD = NULL;
     rc = VDCreate(pVDIfs, enmType, &pVD);
     if (RT_FAILURE(rc))
@@ -406 +406 @@
     }
 
-    PVBOXHDD pVD = NULL;
+    PVDISK pVD = NULL;
     rc = VDCreate(pVDIfs, enmType, &pVD);
     if (RT_FAILURE(rc))
@@ -1020 +1020 @@
     const char *pszDstFormat = NULL;
     const char *pszVariant = NULL;
-    PVBOXHDD pSrcDisk = NULL;
-    PVBOXHDD pDstDisk = NULL;
+    PVDISK pSrcDisk = NULL;
+    PVDISK pDstDisk = NULL;
     unsigned uImageFlags = VD_IMAGE_FLAGS_NONE;
     PVDINTERFACE pIfsImageInput = NULL;
@@ -1259 +1259 @@
 {
     int rc = VINF_SUCCESS;
-    PVBOXHDD pDisk = NULL;
+    PVDISK pDisk = NULL;
     const char *pszFilename = NULL;
 
@@ -1318 +1318 @@
 {
     int rc = VINF_SUCCESS;
-    PVBOXHDD pDisk = (PVBOXHDD)pvUser;
+    PVDISK pDisk = (PVDISK)pvUser;
 
     /* Take shortcut if possible. */
@@ -1377 +1377 @@
 static DECLCALLBACK(int) vboximgDvmWrite(void *pvUser, uint64_t off, const void *pvBuf, size_t cbWrite)
 {
-    PVBOXHDD pDisk = (PVBOXHDD)pvUser;
+    PVDISK pDisk = (PVDISK)pvUser;
     return VDWrite(pDisk, off, pvBuf, cbWrite);
 }
@@ -1409 +1409 @@
 {
     int rc = VINF_SUCCESS;
-    PVBOXHDD pDisk = NULL;
+    PVDISK pDisk = NULL;
     const char *pszFilename = NULL;
     bool fFilesystemAware = false;
@@ -1590 +1590 @@
 {
     int rc = VINF_SUCCESS;
-    PVBOXHDD pDisk = NULL;
+    PVDISK pDisk = NULL;
     const char *pszFilename = NULL;
     uint64_t cbSize = 0;
@@ -1686 +1686 @@
 {
     int rc = VINF_SUCCESS;
-    PVBOXHDD pDisk = NULL;
+    PVDISK pDisk = NULL;
     const char *pszFilename = NULL;
     const char *pszBackend  = "VDI";
@@ -1854 +1854 @@
 {
     int rc = VINF_SUCCESS;
-    PVBOXHDD pDisk = NULL;
+    PVDISK pDisk = NULL;
     const char *pszFilename = NULL;
 
@@ -1911 +1911 @@
 {
     int rc = VINF_SUCCESS;
-    PVBOXHDD pDisk = NULL;
+    PVDISK pDisk = NULL;
     const char *pszFilename = NULL;
     uint64_t    cbNew = 0;