Changeset 27232 in vbox for trunk/src

Timestamp:

Mar 9, 2010 9:05:57 PM (15 years ago)

Author:

vboxsync

Message:

Storage/VBoxHDD+DrvVD: implement framework for providing thread synchronization. Additionally some cleanup to resolve a few minor long-standing todos.

Location:

trunk/src/VBox

Files:

• Devices/Storage/DrvVD.cpp (modified) (6 diffs)
• Devices/Storage/ParallelsHDDCore.cpp (modified) (2 diffs)
• Devices/Storage/RawHDDCore.cpp (modified) (7 diffs)
• Devices/Storage/VBoxHDD.cpp (modified) (152 diffs)
• Devices/Storage/VDIHDDCore.cpp (modified) (11 diffs)
• Devices/Storage/VHDHDDCore.cpp (modified) (6 diffs)
• Devices/Storage/VmdkHDDCore.cpp (modified) (10 diffs)
• Main/MediumImpl.cpp (modified) (1 diff)
• Main/include/MediumImpl.h (modified) (2 diffs)

trunk/src/VBox/Devices/Storage/DrvVD.cpp

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2006-2008 Sun Microsystems, Inc.
+ * Copyright (C) 2006-2010 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -103 +103 @@
     /** Callback routine */
     PFNVDCOMPLETED              pfnCompleted;
+
+    /** Pointer to the optional thread synchronization interface of the disk. */
+    PVDINTERFACE        pInterfaceThreadSync;
+    /** Pointer to the optional thread synchronization callbacks of the disk. */
+    PVDINTERFACETHREADSYNC pInterfaceThreadSyncCallbacks;
 } DRVVDSTORAGEBACKEND, *PDRVVDSTORAGEBACKEND;
 
@@ -263 +268 @@
             pvCallerUser = pvUser;
 
+        /* If thread synchronization is active, then signal the end of the
+         * this disk read/write operation. */
+        /** @todo provide a way to determine the type of task (read/write)
+         * which was completed, see also VBoxHDD.cpp. */
+        if (RT_UNLIKELY(pStorageBackend->pInterfaceThreadSyncCallbacks))
+        {
+            int rc2 = pStorageBackend->pInterfaceThreadSyncCallbacks->pfnFinishWrite(pStorageBackend->pInterfaceThreadSync->pvUser);
+            AssertRC(rc2);
+        }
+
         if (rc == VINF_VD_ASYNC_IO_FINISHED)
         {
@@ -273 +288 @@
 }
 
-static DECLCALLBACK(int) drvvdAsyncIOOpen(void *pvUser, const char *pszLocation, unsigned uOpenFlags,
-                                          PFNVDCOMPLETED pfnCompleted, void **ppStorage)
+static DECLCALLBACK(int) drvvdAsyncIOOpen(void *pvUser, const char *pszLocation,
+                                          unsigned uOpenFlags,
+                                          PFNVDCOMPLETED pfnCompleted, 
+                                          PVDINTERFACE pVDIfsDisk,
+                                          void **ppStorage)
 {
     PVBOXDISK pDrvVD = (PVBOXDISK)pvUser;
@@ -284 +302 @@
         pStorageBackend->fSyncIoPending = false;
         pStorageBackend->pfnCompleted   = pfnCompleted;
+        pStorageBackend->pInterfaceThreadSync = NULL;
+        pStorageBackend->pInterfaceThreadSyncCallbacks = NULL;
+
+        pStorageBackend->pInterfaceThreadSync = VDInterfaceGet(pVDIfsDisk, VDINTERFACETYPE_THREADSYNC);
+        if (RT_UNLIKELY(pStorageBackend->pInterfaceThreadSync))
+            pStorageBackend->pInterfaceThreadSyncCallbacks = VDGetInterfaceThreadSync(pStorageBackend->pInterfaceThreadSync);
 
         rc = RTSemEventCreate(&pStorageBackend->EventSem);
@@ -1265 +1289 @@
 #endif /* !VBOX_WITH_PDM_ASYNC_COMPLETION */
         }
+
+        /** @todo implement and set up the thread synchronization interface
+         * if enabled by some CFGM key. If this is enabled then there also
+         * needs to be a way for the console object to query the pDisk pointer
+         * (so that it can perform the merge in parallel), or alternatively
+         * some code needs to be added here which does the merge. The latter
+         * might be preferred, as a running merge must block the destruction
+         * of the disk, or things will go really wrong. */
 
         if (RT_SUCCESS(rc))

trunk/src/VBox/Devices/Storage/ParallelsHDDCore.cpp

@@ -6 +6 @@
 
 /*
- * Copyright (C) 2006-2009 Sun Microsystems, Inc.
+ * Copyright (C) 2006-2010 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -162 +162 @@
                                                      pImage->pszFilename,
                                                      uOpenFlags,
-                                                     NULL, &pImage->pvStorage);
+                                                     NULL, 
+                                                     pImage->pVDIfsDisk,
+                                                     &pImage->pvStorage);
 #endif
 

trunk/src/VBox/Devices/Storage/RawHDDCore.cpp

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2006-2007 Sun Microsystems, Inc.
+ * Copyright (C) 2006-2010 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -141 +141 @@
                                                      pImage->pszFilename,
                                                      uOpenFlags,
-                                                     NULL, &pImage->pvStorage);
+                                                     NULL, 
+                                                     pImage->pVDIfsDisk,
+                                                     &pImage->pvStorage);
 #endif
 
@@ -317 +319 @@
                           PCPDMMEDIAGEOMETRY pPCHSGeometry,
                           PCPDMMEDIAGEOMETRY pLCHSGeometry,
-                          PFNVMPROGRESS pfnProgress, void *pvUser,
+                          PFNVDPROGRESS pfnProgress, void *pvUser,
                           unsigned uPercentStart, unsigned uPercentSpan)
 {
@@ -403 +405 @@
         if (pfnProgress)
         {
-            rc = pfnProgress(NULL /* WARNING! pVM=NULL  */,
-                             uPercentStart + uOff * uPercentSpan * 98 / (cbSize * 100),
-                             pvUser);
+            rc = pfnProgress(pvUser,
+                             uPercentStart + uOff * uPercentSpan * 98 / (cbSize * 100));
             if (RT_FAILURE(rc))
                 goto out;
@@ -413 +414 @@
 
     if (RT_SUCCESS(rc) && pfnProgress)
-        pfnProgress(NULL /* WARNING! pVM=NULL  */,
-                    uPercentStart + uPercentSpan * 98 / 100, pvUser);
+        pfnProgress(pvUser, uPercentStart + uPercentSpan * 98 / 100);
 
     pImage->cbSize = cbSize;
@@ -422 +422 @@
 out:
     if (RT_SUCCESS(rc) && pfnProgress)
-        pfnProgress(NULL /* WARNING! pVM=NULL  */,
-                    uPercentStart + uPercentSpan, pvUser);
+        pfnProgress(pvUser, uPercentStart + uPercentSpan);
 
     if (RT_FAILURE(rc))
@@ -548 +547 @@
     PRAWIMAGE pImage;
 
-    PFNVMPROGRESS pfnProgress = NULL;
+    PFNVDPROGRESS pfnProgress = NULL;
     void *pvUser = NULL;
     PVDINTERFACE pIfProgress = VDInterfaceGet(pVDIfsOperation,

trunk/src/VBox/Devices/Storage/VBoxHDD.cpp

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2006-2008 Sun Microsystems, Inc.
+ * Copyright (C) 2006-2010 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -127 +127 @@
     /** Pointer to the common interface structure for error reporting. */
     PVDINTERFACE        pInterfaceError;
-    /** Pointer to the error interface we use if available. */
+    /** Pointer to the error interface callbacks we use if available. */
     PVDINTERFACEERROR   pInterfaceErrorCallbacks;
+
+    /** Pointer to the optional thread synchronization interface. */
+    PVDINTERFACE        pInterfaceThreadSync;
+    /** Pointer to the optional thread synchronization callbacks. */
+    PVDINTERFACETHREADSYNC pInterfaceThreadSyncCallbacks;
 
     /** Fallback async interface. */
@@ -206 +211 @@
         pDisk->pInterfaceErrorCallbacks->pfnError(pDisk->pInterfaceError->pvUser, rc, RT_SRC_POS_ARGS, pszFormat, va);
     va_end(va);
+    return rc;
+}
+
+/**
+ * internal: thread synchronization, start read.
+ */
+DECLINLINE(int) vdThreadStartRead(PVBOXHDD pDisk)
+{
+    int rc = VINF_SUCCESS;
+    if (RT_UNLIKELY(pDisk->pInterfaceThreadSyncCallbacks))
+        rc = pDisk->pInterfaceThreadSyncCallbacks->pfnStartRead(pDisk->pInterfaceThreadSync->pvUser);
+    return rc;
+}
+
+/**
+ * internal: thread synchronization, finish read.
+ */
+DECLINLINE(int) vdThreadFinishRead(PVBOXHDD pDisk)
+{
+    int rc = VINF_SUCCESS;
+    if (RT_UNLIKELY(pDisk->pInterfaceThreadSyncCallbacks))
+        rc = pDisk->pInterfaceThreadSyncCallbacks->pfnFinishRead(pDisk->pInterfaceThreadSync->pvUser);
+    return rc;
+}
+
+/**
+ * internal: thread synchronization, start write.
+ */
+DECLINLINE(int) vdThreadStartWrite(PVBOXHDD pDisk)
+{
+    int rc = VINF_SUCCESS;
+    if (RT_UNLIKELY(pDisk->pInterfaceThreadSyncCallbacks))
+        rc = pDisk->pInterfaceThreadSyncCallbacks->pfnStartWrite(pDisk->pInterfaceThreadSync->pvUser);
+    return rc;
+}
+
+/**
+ * internal: thread synchronization, finish write.
+ */
+DECLINLINE(int) vdThreadFinishWrite(PVBOXHDD pDisk)
+{
+    int rc = VINF_SUCCESS;
+    if (RT_UNLIKELY(pDisk->pInterfaceThreadSyncCallbacks))
+        rc = pDisk->pInterfaceThreadSyncCallbacks->pfnFinishWrite(pDisk->pInterfaceThreadSync->pvUser);
     return rc;
 }
@@ -744 +793 @@
  */
 static int vdAsyncIOOpen(void *pvUser, const char *pszLocation, unsigned uOpenFlags,
-                         PFNVDCOMPLETED pfnCompleted, void **ppStorage)
+                         PFNVDCOMPLETED pfnCompleted, PVDINTERFACE pVDIfsDisk,
+                         void **ppStorage)
 {
     PVDIASYNCIOSTORAGE pStorage = (PVDIASYNCIOSTORAGE)RTMemAllocZ(sizeof(VDIASYNCIOSTORAGE));
@@ -925 +975 @@
 
 
-
 /**
  * Lists all HDD backends and their capabilities in a caller-provided buffer.
- *
- * @todo this code contains memory leaks, inconsistent (and probably buggy)
- * allocation, and it lacks documentation what the caller needs to free.
  *
  * @returns VBox status code.
@@ -982 +1028 @@
 /**
  * Lists the capablities of a backend indentified by its name.
- * Free all returned names with RTStrFree() when you no longer need them.
  *
  * @returns VBox status code.
@@ -1055 +1100 @@
             pDisk->pInterfaceError = NULL;
             pDisk->pInterfaceErrorCallbacks = NULL;
+            pDisk->pInterfaceThreadSync = NULL;
+            pDisk->pInterfaceThreadSyncCallbacks = NULL;
 
             pDisk->pInterfaceError = VDInterfaceGet(pVDIfsDisk, VDINTERFACETYPE_ERROR);
             if (pDisk->pInterfaceError)
                 pDisk->pInterfaceErrorCallbacks = VDGetInterfaceError(pDisk->pInterfaceError);
+
+            pDisk->pInterfaceThreadSync = VDInterfaceGet(pVDIfsDisk, VDINTERFACETYPE_THREADSYNC);
+            if (pDisk->pInterfaceThreadSync)
+                pDisk->pInterfaceThreadSyncCallbacks = VDGetInterfaceThreadSync(pDisk->pInterfaceThreadSync);
 
             /* Use the fallback async I/O interface if the caller doesn't provide one. */
@@ -1228 +1279 @@
 {
     int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockWrite = false;
     PVDIMAGE pImage = NULL;
 
     LogFlowFunc(("pDisk=%#p pszBackend=\"%s\" pszFilename=\"%s\" uOpenFlags=%#x, pVDIfsImage=%#p\n",
                  pDisk, pszBackend, pszFilename, uOpenFlags, pVDIfsImage));
+
     do
     {
@@ -1303 +1357 @@
         }
 
-        unsigned uImageFlags;
-        uImageFlags = pImage->Backend->pfnGetImageFlags(pImage->pvBackendData);
+        /* Lock disk for writing, as we modify pDisk information below. */
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        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
@@ -1310 +1367 @@
          * diff images. Some image formats don't distinguish between normal
          * and diff images, so this must be corrected here. */
+        unsigned uImageFlags;
+        uImageFlags = pImage->Backend->pfnGetImageFlags(pImage->pvBackendData);
         if (RT_FAILURE(rc))
             uImageFlags = VD_IMAGE_FLAGS_NONE;
@@ -1341 +1400 @@
         /** @todo optionally check UUIDs */
 
-        int rc2;
-
         /* Cache disk information. */
         pDisk->cbSize = pImage->Backend->pfnGetSize(pImage->pvBackendData);
@@ -1406 +1463 @@
         }
     } while (0);
+
+    if (RT_UNLIKELY(fLockWrite))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
 
     if (RT_FAILURE(rc))
@@ -1448 +1511 @@
 {
     int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockWrite = false, fLockRead = false;
     PVDIMAGE pImage = NULL;
     RTUUID uuid;
@@ -1508 +1573 @@
                            rc = VERR_INVALID_PARAMETER);
 
-        /* Check state. */
+        /* Check state. Needs a temporary read lock. Holding the write lock
+         * all the time would be blocking other activities for too long. */
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = true;
         AssertMsgBreakStmt(pDisk->cImages == 0,
                            ("Create base image cannot be done with other images open\n"),
                            rc = VERR_VD_INVALID_STATE);
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = false;
 
         /* Set up image descriptor. */
@@ -1573 +1645 @@
                 pImage->uOpenFlags |= VD_OPEN_FLAGS_HONOR_SAME;
 
+            /* Lock disk for writing, as we modify pDisk information below. */
+            rc2 = vdThreadStartWrite(pDisk);
+            AssertRC(rc2);
+            fLockWrite = true;
+
             /** @todo optionally check UUIDs */
 
-            int rc2;
-
+            /* Re-check state, as the lock wasn't held and another image
+             * creation call could have been done by another thread. */
+            AssertMsgStmt(pDisk->cImages == 0,
+                          ("Create base image cannot be done with other images open\n"),
+                          rc = VERR_VD_INVALID_STATE);
+        }
+
+        if (RT_SUCCESS(rc))
+        {
             /* Cache disk information. */
             pDisk->cbSize = pImage->Backend->pfnGetSize(pImage->pvBackendData);
@@ -1612 +1696 @@
                 pDisk->LCHSGeometry.cSectors = RT_MIN(pDisk->LCHSGeometry.cSectors, 63);
             }
-        }
-
-        if (RT_SUCCESS(rc))
-        {
+
             /* Image successfully opened, make it the last image. */
             vdAddImageToList(pDisk, pImage);
@@ -1631 +1712 @@
     } while (0);
 
+    if (RT_UNLIKELY(fLockWrite))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+    else if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
+
     if (RT_FAILURE(rc))
     {
@@ -1642 +1734 @@
 
     if (RT_SUCCESS(rc) && pCbProgress && pCbProgress->pfnProgress)
-        pCbProgress->pfnProgress(NULL /* WARNING! pVM=NULL */, 100,
-                                 pIfProgress->pvUser);
+        pCbProgress->pfnProgress(pIfProgress, 100);
 
     LogFlowFunc(("returns %Rrc\n", rc));
@@ -1673 +1764 @@
 {
     int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockWrite = false, fLockRead = false;
     PVDIMAGE pImage = NULL;
     RTUUID uuid;
@@ -1714 +1807 @@
                            rc = VERR_INVALID_PARAMETER);
 
-        /* Check state. */
+        /* Check state. Needs a temporary read lock. Holding the write lock
+         * all the time would be blocking other activities for too long. */
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = true;
         AssertMsgBreakStmt(pDisk->cImages != 0,
                            ("Create diff image cannot be done without other images open\n"),
                            rc = VERR_VD_INVALID_STATE);
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = false;
 
         /* Set up image descriptor. */
@@ -1770 +1870 @@
                                         &pImage->pvBackendData);
 
-        if (RT_SUCCESS(rc) && pDisk->cImages != 0)
+        if (RT_SUCCESS(rc))
         {
             pImage->uImageFlags = uImageFlags;
+
+            /* Lock disk for writing, as we modify pDisk information below. */
+            rc2 = vdThreadStartWrite(pDisk);
+            AssertRC(rc2);
+            fLockWrite = true;
 
             /* Switch previous image to read-only mode. */
@@ -1782 +1887 @@
                 rc = pDisk->pLast->Backend->pfnSetOpenFlags(pDisk->pLast->pvBackendData, uOpenFlagsPrevImg);
             }
+
+            /** @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. */
+            AssertMsgStmt(pDisk->cImages != 0,
+                          ("Create diff image cannot be done without other images open\n"),
+                          rc = VERR_VD_INVALID_STATE);
         }
 
@@ -1788 +1901 @@
             RTUUID Uuid;
             RTTIMESPEC ts;
-            int rc2;
 
             if (pParentUuid && !RTUuidIsNull(pParentUuid))
@@ -1817 +1929 @@
         if (RT_SUCCESS(rc))
         {
-            /** @todo optionally check UUIDs */
-        }
-
-        if (RT_SUCCESS(rc))
-        {
             /* Image successfully opened, make it the last image. */
             vdAddImageToList(pDisk, pImage);
@@ -1830 +1937 @@
         {
             /* Error detected, but image opened. Close and delete image. */
-            int rc2;
             rc2 = pImage->Backend->pfnClose(pImage->pvBackendData, true);
             AssertRC(rc2);
@@ -1837 +1943 @@
     } while (0);
 
+    if (RT_UNLIKELY(fLockWrite))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+    else if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
+
     if (RT_FAILURE(rc))
     {
@@ -1848 +1965 @@
 
     if (RT_SUCCESS(rc) && pCbProgress && pCbProgress->pfnProgress)
-        pCbProgress->pfnProgress(NULL /* WARNING! pVM=NULL */, 100,
-                                 pIfProgress->pvUser);
+        pCbProgress->pfnProgress(pIfProgress, 100);
 
     LogFlowFunc(("returns %Rrc\n", rc));
@@ -1873 +1989 @@
 {
     int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockWrite = false, fLockRead = false;
     void *pvBuf = NULL;
 
@@ -1890 +2008 @@
         AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
 
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = true;
         PVDIMAGE pImageFrom = vdGetImageByNumber(pDisk, nImageFrom);
         PVDIMAGE pImageTo = vdGetImageByNumber(pDisk, nImageTo);
@@ -1912 +2033 @@
         /* Get size of destination image. */
         uint64_t cbSize = pImageTo->Backend->pfnGetSize(pImageTo->pvBackendData);
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = false;
 
         /* Allocate tmp buffer. */
@@ -1923 +2047 @@
         /* Merging is done directly on the images itself. This potentially
          * causes trouble if the disk is full in the middle of operation. */
-        /** @todo write alternative implementation which works with temporary
-         * images (which is safer, but requires even more space). Also has the
-         * drawback that merging into a raw disk parent simply isn't possible
-         * this way (but in that case disk full isn't really a problem). */
         if (nImageFrom < nImageTo)
         {
@@ -1937 +2057 @@
             {
                 size_t cbThisRead = RT_MIN(VD_MERGE_BUFFER_SIZE, cbRemaining);
+
+                /* Need to hold the write lock during a read-write operation. */
+                rc2 = vdThreadStartWrite(pDisk);
+                AssertRC(rc2);
+                fLockWrite = true;
+
                 rc = pImageTo->Backend->pfnRead(pImageTo->pvBackendData,
                                                 uOffset, pvBuf, cbThisRead,
@@ -1972 +2098 @@
                     break;
 
+                rc2 = vdThreadFinishWrite(pDisk);
+                AssertRC(rc2);
+                fLockWrite = false;
+
                 uOffset += cbThisRead;
                 cbRemaining -= cbThisRead;
@@ -1977 +2107 @@
                 if (pCbProgress && pCbProgress->pfnProgress)
                 {
-                    rc = pCbProgress->pfnProgress(NULL /* WARNING! pVM=NULL */,
-                                                  uOffset * 99 / cbSize,
-                                                  pIfProgress->pvUser);
+                    rc = pCbProgress->pfnProgress(pIfProgress->pvUser,
+                                                  uOffset * 99 / cbSize);
                     if (RT_FAILURE(rc))
                         break;
@@ -2020 +2149 @@
                 size_t cbThisRead = RT_MIN(VD_MERGE_BUFFER_SIZE, cbRemaining);
                 rc = VERR_VD_BLOCK_FREE;
+
+                /* Need to hold the write lock during a read-write operation. */
+                rc2 = vdThreadStartWrite(pDisk);
+                AssertRC(rc2);
+                fLockWrite = true;
+
                 /* Search for image with allocated block. Do not attempt to
                  * read more than the previous reads marked as valid. Otherwise
@@ -2045 +2180 @@
                     rc = VINF_SUCCESS;
 
+                rc2 = vdThreadFinishWrite(pDisk);
+                AssertRC(rc2);
+                fLockWrite = true;
+
                 uOffset += cbThisRead;
                 cbRemaining -= cbThisRead;
@@ -2050 +2189 @@
                 if (pCbProgress && pCbProgress->pfnProgress)
                 {
-                    rc = pCbProgress->pfnProgress(NULL /* WARNING! pVM=NULL */,
-                                                  uOffset * 99 / cbSize,
-                                                  pIfProgress->pvUser);
+                    rc = pCbProgress->pfnProgress(pIfProgress->pvUser,
+                                                  uOffset * 99 / cbSize);
                     if (RT_FAILURE(rc))
                         break;
@@ -2058 +2196 @@
             } while (uOffset < cbSize);
         }
+
+        /* Need to hold the write lock while finishing the merge. */
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
 
         /* Update parent UUID so that image chain is consistent. */
@@ -2137 +2280 @@
     } while (0);
 
+    if (RT_UNLIKELY(fLockWrite))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+    else if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
+
     if (pvBuf)
         RTMemTmpFree(pvBuf);
 
     if (RT_SUCCESS(rc) && pCbProgress && pCbProgress->pfnProgress)
-        pCbProgress->pfnProgress(NULL /* WARNING! pVM=NULL */, 100,
-                                 pIfProgress->pvUser);
+        pCbProgress->pfnProgress(pIfProgress->pvUser, 100);
 
     LogFlowFunc(("returns %Rrc\n", rc));
@@ -2185 +2338 @@
                          PVDINTERFACE pDstVDIfsOperation)
 {
-    int rc, rc2 = VINF_SUCCESS;
+    int rc = VINF_SUCCESS; 
+    int rc2;
+    bool fLockReadFrom = false, fLockWriteFrom = false, fLockWriteTo = false;
     void *pvBuf = NULL;
     PVDIMAGE pImageTo = NULL;
@@ -2211 +2366 @@
                   ("u32Signature=%08x\n", pDiskFrom->u32Signature));
 
+        rc2 = vdThreadStartRead(pDiskFrom);
+        AssertRC(rc2);
+        fLockReadFrom = true;
         PVDIMAGE pImageFrom = vdGetImageByNumber(pDiskFrom, nImage);
         AssertPtrBreakStmt(pImageFrom, rc = VERR_VD_IMAGE_NOT_FOUND);
@@ -2225 +2383 @@
                 &&  !RTStrICmp(pszBackend, pImageFrom->Backend->pszBackendName))
             {
+                rc2 = vdThreadFinishRead(pDiskFrom);
+                AssertRC(rc2);
+                fLockReadFrom = false;
+
+                rc2 = vdThreadStartWrite(pDiskFrom);
+                AssertRC(rc2);
+                fLockWriteFrom = true;
                 rc = pImageFrom->Backend->pfnRename(pImageFrom->pvBackendData, pszFilename ? pszFilename : pImageFrom->pszFilename);
                 break;
@@ -2288 +2453 @@
         uOpenFlagsFrom = pImageFrom->Backend->pfnGetOpenFlags(pImageFrom->pvBackendData);
 
+        rc2 = vdThreadFinishRead(pDiskFrom);
+        AssertRC(rc2);
+        fLockReadFrom = false;
+
         if (pszFilename)
         {
@@ -2296 +2465 @@
             /** @todo replace the VDCreateDiff/VDCreateBase calls by direct
              * calls to the backend. Unifies the code and reduces the API
-             * dependencies. */
+             * dependencies. Would also make the synchronization explicit. */
             if (uImageFlags & VD_IMAGE_FLAGS_DIFF)
             {
                 rc = VDCreateDiff(pDiskTo, pszBackend, pszFilename, uImageFlags,
                                   szComment, &ImageUuid, &ParentUuid, uOpenFlagsFrom & ~VD_OPEN_FLAGS_READONLY, NULL, NULL);
+
+                rc2 = vdThreadStartWrite(pDiskTo);
+                AssertRC(rc2);
+                fLockWriteTo = true;
             } else {
-                /** @todo Please, review this! It's an ugly hack I think... */
+                /** @todo hack to force creation of a fixed image for
+                 * the RAW backend, which can't handle anything else. */
                 if (!RTStrICmp(pszBackend, "RAW"))
                     uImageFlags |= VD_IMAGE_FLAGS_FIXED;
@@ -2325 +2499 @@
                                   &PCHSGeometryFrom, &LCHSGeometryFrom,
                                   NULL, uOpenFlagsFrom & ~VD_OPEN_FLAGS_READONLY, NULL, NULL);
+                    
+                rc2 = vdThreadStartWrite(pDiskTo);
+                AssertRC(rc2);
+                fLockWriteTo = true;
+
                 if (RT_SUCCESS(rc) && !RTUuidIsNull(&ImageUuid))
                      pDiskTo->pLast->Backend->pfnSetUuid(pDiskTo->pLast->pvBackendData, &ImageUuid);
@@ -2355 +2534 @@
         }
 
+        rc2 = vdThreadFinishWrite(pDiskTo);
+        AssertRC(rc2);
+        fLockWriteTo = false;
+
         /* Allocate tmp buffer. */
         pvBuf = RTMemTmpAlloc(VD_MERGE_BUFFER_SIZE);
@@ -2370 +2553 @@
         {
             size_t cbThisRead = RT_MIN(VD_MERGE_BUFFER_SIZE, cbRemaining);
+
+            /* 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. */
+
+            rc2 = vdThreadStartRead(pDiskFrom);
+            AssertRC(rc2);
+            fLockReadFrom = true;
 
             rc = vdReadHelper(pDiskFrom, pImageFrom, NULL, uOffset, pvBuf,
@@ -2376 +2568 @@
                 break;
 
+            rc2 = vdThreadFinishRead(pDiskFrom);
+            AssertRC(rc2);
+            fLockReadFrom = false;
+
+            rc2 = vdThreadStartWrite(pDiskTo);
+            AssertRC(rc2);
+            fLockWriteTo = true;
+
             rc = vdWriteHelper(pDiskTo, pImageTo, NULL, uOffset, pvBuf,
                                cbThisRead);
@@ -2381 +2581 @@
                 break;
 
+            rc2 = vdThreadFinishWrite(pDiskTo);
+            AssertRC(rc2);
+            fLockWriteTo = false;
+
             uOffset += cbThisRead;
             cbRemaining -= cbThisRead;
@@ -2386 +2590 @@
             if (pCbProgress && pCbProgress->pfnProgress)
             {
-                rc = pCbProgress->pfnProgress(NULL /* WARNING! pVM=NULL */,
-                                              uOffset * 99 / cbSize,
-                                              pIfProgress->pvUser);
+                rc = pCbProgress->pfnProgress(pIfProgress->pvUser,
+                                              uOffset * 99 / cbSize);
                 if (RT_FAILURE(rc))
                     break;
@@ -2394 +2597 @@
             if (pDstCbProgress && pDstCbProgress->pfnProgress)
             {
-                rc = pDstCbProgress->pfnProgress(NULL /* WARNING! pVM=NULL */,
-                                                 uOffset * 99 / cbSize,
-                                                 pDstIfProgress->pvUser);
+                rc = pDstCbProgress->pfnProgress(pDstIfProgress->pvUser,
+                                                 uOffset * 99 / cbSize);
                 if (RT_FAILURE(rc))
                     break;
@@ -2404 +2606 @@
         if (RT_SUCCESS(rc))
         {
+            rc2 = vdThreadStartWrite(pDiskTo);
+            AssertRC(rc2);
+            fLockWriteTo = true;
+
             /* Only set modification UUID if it is non-null, since the source
              * backend might not provide a valid modification UUID. */
@@ -2418 +2624 @@
     if (RT_FAILURE(rc) && pImageTo && pszFilename)
     {
+        /* Take the write lock only if it is not taken. Not worth making the
+         * above code even more complicated. */
+        if (RT_UNLIKELY(!fLockWriteTo))
+        {
+            rc2 = vdThreadStartWrite(pDiskTo);
+            AssertRC(rc2);
+            fLockWriteTo = true;
+        }
         /* Error detected, but new image created. Remove image from list. */
         vdRemoveImageFromList(pDiskTo, pImageTo);
@@ -2433 +2647 @@
     }
 
+    if (RT_UNLIKELY(fLockWriteTo))
+    {
+        rc2 = vdThreadFinishWrite(pDiskTo);
+        AssertRC(rc2);
+    }
+    if (RT_UNLIKELY(fLockWriteFrom))
+    {
+        rc2 = vdThreadFinishWrite(pDiskFrom);
+        AssertRC(rc2);
+    }
+    else if (RT_UNLIKELY(fLockReadFrom))
+    {
+        rc2 = vdThreadFinishRead(pDiskFrom);
+        AssertRC(rc2);
+    }
+
     if (pvBuf)
         RTMemTmpFree(pvBuf);
@@ -2439 +2669 @@
     {
         if (pCbProgress && pCbProgress->pfnProgress)
-            pCbProgress->pfnProgress(NULL /* WARNING! pVM=NULL */, 100,
-                                     pIfProgress->pvUser);
+            pCbProgress->pfnProgress(pIfProgress->pvUser, 100);
         if (pDstCbProgress && pDstCbProgress->pfnProgress)
-            pDstCbProgress->pfnProgress(NULL /* WARNING! pVM=NULL */, 100,
-                                        pDstIfProgress->pvUser);
+            pDstCbProgress->pfnProgress(pDstIfProgress->pvUser, 100);
     }
 
@@ -2469 +2697 @@
                             PVDINTERFACE pVDIfsOperation)
 {
-    int rc;
+    int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockRead = false, fLockWrite = false;
     void *pvBuf = NULL;
     void *pvTmp = NULL;
@@ -2488 +2718 @@
         AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE,
                   ("u32Signature=%08x\n", pDisk->u32Signature));
+
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = true;
 
         PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
@@ -2521 +2755 @@
         }
 
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = false;
+
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
+
         rc = pImage->Backend->pfnCompact(pImage->pvBackendData,
                                          0, 99,
+                                         pDisk->pVDIfsDisk,
+                                         pImage->pVDIfsImage,
                                          pVDIfsOperation);
     } while (0);
+
+    if (RT_UNLIKELY(fLockWrite))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+    else if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
 
     if (pvBuf)
@@ -2534 +2789 @@
     {
         if (pCbProgress && pCbProgress->pfnProgress)
-            pCbProgress->pfnProgress(NULL /* WARNING! pVM=NULL */, 100,
-                                     pIfProgress->pvUser);
+            pCbProgress->pfnProgress(pIfProgress->pvUser, 100);
     }
 
@@ -2544 +2798 @@
 /**
  * Closes the last opened image file in HDD container.
- * If previous image file was opened in read-only mode (that is normal) and closing image
- * was opened in read-write mode (the whole disk was in read-write mode) - the previous image
- * will be reopened in read/write mode.
+ * 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
+ * reopened in read/write mode.
  *
  * @returns VBox status code.
@@ -2556 +2810 @@
 {
     int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockWrite = false;
 
     LogFlowFunc(("pDisk=%#p fDelete=%d\n", pDisk, fDelete));
@@ -2563 +2819 @@
         AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
         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. */
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
 
         PVDIMAGE pImage = pDisk->pLast;
@@ -2593 +2856 @@
         }
 
-        int rc2;
-
         /* Cache disk information. */
         pDisk->cbSize = pImage->Backend->pfnGetSize(pImage->pvBackendData);
@@ -2632 +2893 @@
     } while (0);
 
+    if (RT_UNLIKELY(fLockWrite))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+
     LogFlowFunc(("returns %Rrc\n", rc));
     return rc;
@@ -2645 +2912 @@
 {
     int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockWrite = false;
 
     LogFlowFunc(("pDisk=%#p\n", pDisk));
@@ -2652 +2921 @@
         AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
         AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+        /* Lock the entire operation. */
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
 
         PVDIMAGE pImage = pDisk->pLast;
@@ -2671 +2945 @@
     } while (0);
 
+    if (RT_UNLIKELY(fLockWrite))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+
     LogFlowFunc(("returns %Rrc\n", rc));
     return rc;
@@ -2688 +2968 @@
                          size_t cbRead)
 {
-    int rc;
+    int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockRead = false;
 
     LogFlowFunc(("pDisk=%#p uOffset=%llu pvBuf=%p cbRead=%zu\n",
@@ -2705 +2987 @@
                            ("cbRead=%zu\n", cbRead),
                            rc = VERR_INVALID_PARAMETER);
+
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = true;
+
         AssertMsgBreakStmt(uOffset + cbRead <= pDisk->cbSize,
                            ("uOffset=%llu cbRead=%zu pDisk->cbSize=%llu\n",
@@ -2715 +3002 @@
         rc = vdReadHelper(pDisk, pImage, NULL, uOffset, pvBuf, cbRead);
     } while (0);
+
+    if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
 
     LogFlowFunc(("returns %Rrc\n", rc));
@@ -2735 +3028 @@
 {
     int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockWrite = false;
 
     LogFlowFunc(("pDisk=%#p uOffset=%llu pvBuf=%p cbWrite=%zu\n",
@@ -2751 +3046 @@
                            ("cbWrite=%zu\n", cbWrite),
                            rc = VERR_INVALID_PARAMETER);
+
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
+
         AssertMsgBreakStmt(uOffset + cbWrite <= pDisk->cbSize,
                            ("uOffset=%llu cbWrite=%zu pDisk->cbSize=%llu\n",
@@ -2763 +3063 @@
     } while (0);
 
+    if (RT_UNLIKELY(fLockWrite))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+
     LogFlowFunc(("returns %Rrc\n", rc));
     return rc;
@@ -2777 +3083 @@
 {
     int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockWrite = false;
 
     LogFlowFunc(("pDisk=%#p\n", pDisk));
@@ -2785 +3093 @@
         AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
 
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
+
         PVDIMAGE pImage = pDisk->pLast;
         AssertPtrBreakStmt(pImage, rc = VERR_VD_NOT_OPENED);
@@ -2792 +3104 @@
     } while (0);
 
+    if (RT_UNLIKELY(fLockWrite))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+
     LogFlowFunc(("returns %Rrc\n", rc));
     return rc;
@@ -2805 +3123 @@
 {
     unsigned cImages;
+    int rc2;
+    bool fLockRead = false;
 
     LogFlowFunc(("pDisk=%#p\n", pDisk));
@@ -2813 +3133 @@
         AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
 
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = true;
+
         cImages = pDisk->cImages;
     } while (0);
+
+    if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
 
     LogFlowFunc(("returns %u\n", cImages));
@@ -2830 +3160 @@
 {
     bool fReadOnly;
+    int rc2;
+    bool fLockRead = false;
 
     LogFlowFunc(("pDisk=%#p\n", pDisk));
@@ -2837 +3169 @@
         AssertPtrBreakStmt(pDisk, fReadOnly = false);
         AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = true;
 
         PVDIMAGE pImage = pDisk->pLast;
@@ -2846 +3182 @@
     } while (0);
 
+    if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
+
     LogFlowFunc(("returns %d\n", fReadOnly));
     return fReadOnly;
@@ -2861 +3203 @@
 {
     uint64_t cbSize;
+    int rc2;
+    bool fLockRead = false;
 
     LogFlowFunc(("pDisk=%#p nImage=%u\n", pDisk, nImage));
@@ -2868 +3212 @@
         AssertPtrBreakStmt(pDisk, cbSize = 0);
         AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = true;
 
         PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
@@ -2874 +3222 @@
     } while (0);
 
+    if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
+
     LogFlowFunc(("returns %llu\n", cbSize));
     return cbSize;
@@ -2889 +3243 @@
 {
     uint64_t cbSize;
+    int rc2;
+    bool fLockRead = false;
 
     LogFlowFunc(("pDisk=%#p nImage=%u\n", pDisk, nImage));
@@ -2896 +3252 @@
         AssertPtrBreakStmt(pDisk, cbSize = 0);
         AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = true;
 
         PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
@@ -2901 +3261 @@
         cbSize = pImage->Backend->pfnGetFileSize(pImage->pvBackendData);
     } while (0);
+
+    if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
 
     LogFlowFunc(("returns %llu\n", cbSize));
@@ -2920 +3286 @@
 {
     int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockRead = false;
 
     LogFlowFunc(("pDisk=%#p nImage=%u pPCHSGeometry=%#p\n",
@@ -2933 +3301 @@
                            ("pPCHSGeometry=%#p\n", pPCHSGeometry),
                            rc = VERR_INVALID_PARAMETER);
+
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = true;
 
         PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
@@ -2949 +3321 @@
                                                      pPCHSGeometry);
     } while (0);
+
+    if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
 
     LogFlowFunc(("%s: %Rrc (PCHS=%u/%u/%u)\n", __FUNCTION__, rc,
@@ -2972 +3350 @@
 {
     int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockWrite = false;
 
     LogFlowFunc(("pDisk=%#p nImage=%u pPCHSGeometry=%#p PCHS=%u/%u/%u\n",
@@ -2990 +3370 @@
                             pPCHSGeometry->cSectors),
                            rc = VERR_INVALID_PARAMETER);
+
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
 
         PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
@@ -3046 +3430 @@
     } while (0);
 
+    if (RT_UNLIKELY(fLockWrite))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+
     LogFlowFunc(("returns %Rrc\n", rc));
     return rc;
@@ -3064 +3454 @@
 {
     int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockRead = false;
 
     LogFlowFunc(("pDisk=%#p nImage=%u pLCHSGeometry=%#p\n",
@@ -3077 +3469 @@
                            ("pLCHSGeometry=%#p\n", pLCHSGeometry),
                            rc = VERR_INVALID_PARAMETER);
+
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = true;
 
         PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
@@ -3093 +3489 @@
                                                      pLCHSGeometry);
     } while (0);
+
+    if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
 
     LogFlowFunc((": %Rrc (LCHS=%u/%u/%u)\n", rc,
@@ -3116 +3518 @@
 {
     int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockWrite = false;
 
     LogFlowFunc(("pDisk=%#p nImage=%u pLCHSGeometry=%#p LCHS=%u/%u/%u\n",
@@ -3134 +3538 @@
                             pLCHSGeometry->cSectors),
                            rc = VERR_INVALID_PARAMETER);
+
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
 
         PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
@@ -3190 +3598 @@
     } while (0);
 
+    if (RT_UNLIKELY(fLockWrite))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+
     LogFlowFunc(("returns %Rrc\n", rc));
     return rc;
@@ -3207 +3621 @@
 {
     int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockRead = false;
 
     LogFlowFunc(("pDisk=%#p nImage=%u puVersion=%#p\n",
@@ -3221 +3637 @@
                            rc = VERR_INVALID_PARAMETER);
 
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = true;
+
         PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
         AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
@@ -3226 +3646 @@
         *puVersion = pImage->Backend->pfnGetVersion(pImage->pvBackendData);
     } while (0);
+
+    if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
 
     LogFlowFunc(("returns %Rrc uVersion=%#x\n", rc, *puVersion));
@@ -3244 +3670 @@
 {
     int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockRead = false;
 
     LogFlowFunc(("pDisk=%#p nImage=%u pBackendInfo=%#p\n",
@@ -3258 +3686 @@
                            rc = VERR_INVALID_PARAMETER);
 
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = true;
+
         PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
         AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
 
-        pBackendInfo->pszBackend = RTStrDup(pImage->Backend->pszBackendName);
+        pBackendInfo->pszBackend = pImage->Backend->pszBackendName;
         pBackendInfo->uBackendCaps = pImage->Backend->uBackendCaps;
         pBackendInfo->papszFileExtensions = pImage->Backend->papszFileExtensions;
         pBackendInfo->paConfigInfo = pImage->Backend->paConfigInfo;
     } while (0);
+
+    if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
 
     LogFlowFunc(("returns %Rrc\n", rc));
@@ -3284 +3722 @@
 {
     int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockRead = false;
 
     LogFlowFunc(("pDisk=%#p nImage=%u puImageFlags=%#p\n",
@@ -3298 +3738 @@
                            rc = VERR_INVALID_PARAMETER);
 
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = true;
+
         PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
         AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
@@ -3303 +3747 @@
         *puImageFlags = pImage->Backend->pfnGetImageFlags(pImage->pvBackendData);
     } while (0);
+
+    if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
 
     LogFlowFunc(("returns %Rrc uImageFlags=%#x\n", rc, *puImageFlags));
@@ -3321 +3771 @@
 {
     int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockRead = false;
 
     LogFlowFunc(("pDisk=%#p nImage=%u puOpenFlags=%#p\n",
@@ -3335 +3787 @@
                            rc = VERR_INVALID_PARAMETER);
 
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = true;
+
         PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
         AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
@@ -3340 +3796 @@
         *puOpenFlags = pImage->Backend->pfnGetOpenFlags(pImage->pvBackendData);
     } while (0);
+
+    if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
 
     LogFlowFunc(("returns %Rrc uOpenFlags=%#x\n", rc, *puOpenFlags));
@@ -3360 +3822 @@
 {
     int rc;
+    int rc2;
+    bool fLockWrite = false;
 
     LogFlowFunc(("pDisk=%#p uOpenFlags=%#u\n", pDisk, uOpenFlags));
@@ -3373 +3837 @@
                            rc = VERR_INVALID_PARAMETER);
 
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
+
         PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
         AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
@@ -3379 +3847 @@
                                               uOpenFlags);
     } while (0);
+
+    if (RT_UNLIKELY(fLockWrite))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
 
     LogFlowFunc(("returns %Rrc\n", rc));
@@ -3401 +3875 @@
 {
     int rc;
+    int rc2;
+    bool fLockRead = false;
 
     LogFlowFunc(("pDisk=%#p nImage=%u pszFilename=%#p cbFilename=%u\n",
@@ -3418 +3894 @@
                            rc = VERR_INVALID_PARAMETER);
 
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = true;
+
         PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
         AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
@@ -3434 +3914 @@
         }
     } while (0);
+
+    if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
 
     LogFlowFunc(("returns %Rrc, pszFilename=\"%s\"\n", rc, pszFilename));
@@ -3454 +3940 @@
 {
     int rc;
+    int rc2;
+    bool fLockRead = false;
 
     LogFlowFunc(("pDisk=%#p nImage=%u pszComment=%#p cbComment=%u\n",
@@ -3471 +3959 @@
                            rc = VERR_INVALID_PARAMETER);
 
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = true;
+
         PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
         AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
@@ -3477 +3969 @@
                                             cbComment);
     } while (0);
+
+    if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
 
     LogFlowFunc(("returns %Rrc, pszComment=\"%s\"\n", rc, pszComment));
@@ -3495 +3993 @@
 {
     int rc;
+    int rc2;
+    bool fLockWrite = false;
 
     LogFlowFunc(("pDisk=%#p nImage=%u pszComment=%#p \"%s\"\n",
@@ -3509 +4009 @@
                            rc = VERR_INVALID_PARAMETER);
 
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
+
         PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
         AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
@@ -3514 +4018 @@
         rc = pImage->Backend->pfnSetComment(pImage->pvBackendData, pszComment);
     } while (0);
+
+    if (RT_UNLIKELY(fLockWrite))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
 
     LogFlowFunc(("returns %Rrc\n", rc));
@@ -3532 +4042 @@
 {
     int rc;
+    int rc2;
+    bool fLockRead = false;
 
     LogFlowFunc(("pDisk=%#p nImage=%u pUuid=%#p\n", pDisk, nImage, pUuid));
@@ -3545 +4057 @@
                            rc = VERR_INVALID_PARAMETER);
 
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = true;
+
         PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
         AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
@@ -3550 +4066 @@
         rc = pImage->Backend->pfnGetUuid(pImage->pvBackendData, pUuid);
     } while (0);
+
+    if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
 
     LogFlowFunc(("returns %Rrc, Uuid={%RTuuid}\n", rc, pUuid));
@@ -3567 +4089 @@
 {
     int rc;
+    int rc2;
+    bool fLockWrite = false;
 
     LogFlowFunc(("pDisk=%#p nImage=%u pUuid=%#p {%RTuuid}\n",
@@ -3580 +4104 @@
                            rc = VERR_INVALID_PARAMETER);
 
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
+
         PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
         AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
@@ -3591 +4119 @@
         rc = pImage->Backend->pfnSetUuid(pImage->pvBackendData, pUuid);
     } while (0);
+
+    if (RT_UNLIKELY(fLockWrite))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
 
     LogFlowFunc(("returns %Rrc\n", rc));
@@ -3608 +4142 @@
 {
     int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockRead = false;
 
     LogFlowFunc(("pDisk=%#p nImage=%u pUuid=%#p\n", pDisk, nImage, pUuid));
@@ -3621 +4157 @@
                            rc = VERR_INVALID_PARAMETER);
 
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = true;
+
         PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
         AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
@@ -3627 +4167 @@
                                                      pUuid);
     } while (0);
+
+    if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
 
     LogFlowFunc(("returns %Rrc, Uuid={%RTuuid}\n", rc, pUuid));
@@ -3644 +4190 @@
 {
     int rc;
+    int rc2;
+    bool fLockWrite = false;
 
     LogFlowFunc(("pDisk=%#p nImage=%u pUuid=%#p {%RTuuid}\n",
@@ -3658 +4206 @@
                            rc = VERR_INVALID_PARAMETER);
 
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
+
         PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
         AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
@@ -3670 +4222 @@
                                                      pUuid);
     } while (0);
+
+    if (RT_UNLIKELY(fLockWrite))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
 
     LogFlowFunc(("returns %Rrc\n", rc));
@@ -3688 +4246 @@
 {
     int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockRead = false;
 
     LogFlowFunc(("pDisk=%#p nImage=%u pUuid=%#p\n", pDisk, nImage, pUuid));
@@ -3701 +4261 @@
                            rc = VERR_INVALID_PARAMETER);
 
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = true;
+
         PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
         AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
@@ -3706 +4270 @@
         rc = pImage->Backend->pfnGetParentUuid(pImage->pvBackendData, pUuid);
     } while (0);
+
+    if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
 
     LogFlowFunc(("returns %Rrc, Uuid={%RTuuid}\n", rc, pUuid));
@@ -3723 +4293 @@
 {
     int rc;
+    int rc2;
+    bool fLockWrite = false;
 
     LogFlowFunc(("pDisk=%#p nImage=%u pUuid=%#p {%RTuuid}\n",
@@ -3737 +4309 @@
                            rc = VERR_INVALID_PARAMETER);
 
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
+
         PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
         AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
@@ -3749 +4325 @@
     } while (0);
 
+    if (RT_UNLIKELY(fLockWrite))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+
     LogFlowFunc(("returns %Rrc\n", rc));
     return rc;
@@ -3761 +4343 @@
 VBOXDDU_DECL(void) VDDumpImages(PVBOXHDD pDisk)
 {
+    int rc2;
+    bool fLockRead = false;
+
     do
     {
@@ -3778 +4363 @@
         }
 
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = true;
+
         pfnMessage(pvUser, "--- Dumping VD Disk, Images=%u\n", pDisk->cImages);
         for (PVDIMAGE pImage = pDisk->pBase; pImage; pImage = pImage->pNext)
@@ -3786 +4375 @@
         }
     } while (0);
+
+    if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
 }
 
@@ -3800 +4395 @@
 {
     int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockRead = false;
 
     LogFlowFunc(("pDisk=%#p nImage=%u pfAIOSupported=%#p\n", pDisk, nImage, pfAIOSupported));
@@ -3812 +4409 @@
                            ("pfAIOSupported=%#p\n", pfAIOSupported),
                            rc = VERR_INVALID_PARAMETER);
+
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = true;
 
         PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
@@ -3821 +4422 @@
             *pfAIOSupported = false;
     } while (0);
+
+    if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
 
     LogFlowFunc(("returns %Rrc, fAIOSupported=%u\n", rc, *pfAIOSupported));
@@ -3842 +4449 @@
 {
     int rc = VERR_VD_BLOCK_FREE;
+    int rc2;
+    bool fLockWrite = false;
 
     LogFlowFunc(("pDisk=%#p uOffset=%llu paSeg=%p cSeg=%u cbRead=%zu\n",
@@ -3855 +4464 @@
                            ("cbRead=%zu\n", cbRead),
                            rc = VERR_INVALID_PARAMETER);
+        AssertMsgBreakStmt(VALID_PTR(paSeg),
+                           ("paSeg=%#p\n", paSeg),
+                           rc = VERR_INVALID_PARAMETER);
+        AssertMsgBreakStmt(cSeg,
+                           ("cSeg=%zu\n", cSeg),
+                           rc = VERR_INVALID_PARAMETER);
+
+        /** @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. */
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
+
         AssertMsgBreakStmt(uOffset + cbRead <= pDisk->cbSize,
                            ("uOffset=%llu cbRead=%zu pDisk->cbSize=%llu\n",
                             uOffset, cbRead, pDisk->cbSize),
                            rc = VERR_INVALID_PARAMETER);
-        AssertMsgBreakStmt(VALID_PTR(paSeg),
-                           ("paSeg=%#p\n", paSeg),
-                           rc = VERR_INVALID_PARAMETER);
-        AssertMsgBreakStmt(cSeg,
-                           ("cSeg=%zu\n", cSeg),
-                           rc = VERR_INVALID_PARAMETER);
-
 
         PVDIMAGE pImage = pDisk->pLast;
@@ -3890 +4505 @@
             /* Request finished without the need to enqueue a async I/O request. Tell caller. */
             rc = VINF_VD_ASYNC_IO_FINISHED;
+
+            rc2 = vdThreadFinishWrite(pDisk);
+            AssertRC(rc2);
+            fLockWrite = false;
         }
 
     } while (0);
+
+    if (RT_UNLIKELY(fLockWrite) && RT_FAILURE(rc))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
 
     LogFlowFunc(("returns %Rrc\n", rc));
@@ -3915 +4540 @@
 {
     int rc;
+    int rc2;
+    bool fLockWrite = false;
 
     LogFlowFunc(("pDisk=%#p uOffset=%llu paSeg=%p cSeg=%u cbWrite=%zu\n",
@@ -3928 +4555 @@
                            ("cbWrite=%zu\n", cbWrite),
                            rc = VERR_INVALID_PARAMETER);
+        AssertMsgBreakStmt(VALID_PTR(paSeg),
+                           ("paSeg=%#p\n", paSeg),
+                           rc = VERR_INVALID_PARAMETER);
+        AssertMsgBreakStmt(cSeg,
+                           ("cSeg=%zu\n", cSeg),
+                           rc = VERR_INVALID_PARAMETER);
+
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
+
         AssertMsgBreakStmt(uOffset + cbWrite <= pDisk->cbSize,
                            ("uOffset=%llu cbWrite=%zu pDisk->cbSize=%llu\n",
                             uOffset, cbWrite, pDisk->cbSize),
                            rc = VERR_INVALID_PARAMETER);
-        AssertMsgBreakStmt(VALID_PTR(paSeg),
-                           ("paSeg=%#p\n", paSeg),
-                           rc = VERR_INVALID_PARAMETER);
-        AssertMsgBreakStmt(cSeg,
-                           ("cSeg=%zu\n", cSeg),
-                           rc = VERR_INVALID_PARAMETER);
-
 
         PVDIMAGE pImage = pDisk->pLast;
@@ -3949 +4580 @@
     } while (0);
 
+    if (RT_UNLIKELY(fLockWrite) && RT_FAILURE(rc))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
     LogFlowFunc(("returns %Rrc\n", rc));
     return rc;

trunk/src/VBox/Devices/Storage/VDIHDDCore.cpp

@@ -4 +4 @@
 
 /*
- * Copyright (C) 2006-2007 Sun Microsystems, Inc.
+ * Copyright (C) 2006-2010 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -108 +108 @@
                                                      pImage->pszFilename,
                                                      uOpenFlags,
-                                                     NULL, &pImage->pvStorage);
+                                                     NULL,
+                                                     pImage->pVDIfsDisk,
+                                                     &pImage->pvStorage);
 #endif
 
@@ -499 +501 @@
                           PCPDMMEDIAGEOMETRY pPCHSGeometry,
                           PCPDMMEDIAGEOMETRY pLCHSGeometry, PCRTUUID pUuid,
-                          PFNVMPROGRESS pfnProgress, void *pvUser,
+                          PFNVDPROGRESS pfnProgress, void *pvUser,
                           unsigned uPercentStart, unsigned uPercentSpan)
 {
@@ -676 +678 @@
             if (pfnProgress)
             {
-                rc = pfnProgress(NULL /* WARNING! pVM=NULL  */,
-                                 uPercentStart + uOff * uPercentSpan / cbFill,
-                                 pvUser);
+                rc = pfnProgress(pvUser,
+                                 uPercentStart + uOff * uPercentSpan / cbFill);
                 if (RT_FAILURE(rc))
                     goto out;
@@ -688 +689 @@
 out:
     if (RT_SUCCESS(rc) && pfnProgress)
-        pfnProgress(NULL /* WARNING! pVM=NULL  */,
-                    uPercentStart + uPercentSpan, pvUser);
+        pfnProgress(pvUser, uPercentStart + uPercentSpan);
 
     if (RT_FAILURE(rc))
@@ -1012 +1012 @@
     PVDIIMAGEDESC pImage;
 
-    PFNVMPROGRESS pfnProgress = NULL;
+    PFNVDPROGRESS pfnProgress = NULL;
     void *pvUser = NULL;
     PVDINTERFACE pIfProgress = VDInterfaceGet(pVDIfsOperation,
@@ -2006 +2006 @@
 /** @copydoc VBOXHDDBACKEND::pfnCompact */
 static int vdiCompact(void *pBackendData, unsigned uPercentStart,
-                      unsigned uPercentSpan, PVDINTERFACE pVDIfsOperation)
+                      unsigned uPercentSpan, PVDINTERFACE pVDIfsDisk,
+                      PVDINTERFACE pVDIfsImage, PVDINTERFACE pVDIfsOperation)
 {
     PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
@@ -2026 +2027 @@
     }
 
-    PFNVMPROGRESS pfnProgress = NULL;
+    PFNVDPROGRESS pfnProgress = NULL;
     void *pvUser = NULL;
     PVDINTERFACE pIfProgress = VDInterfaceGet(pVDIfsOperation,
@@ -2156 +2157 @@
             if (pCbProgress && pCbProgress->pfnProgress)
             {
-                rc = pCbProgress->pfnProgress(NULL /* WARNING! pVM=NULL */,
-                                              (uint64_t)i * uPercentSpan / (cBlocks + cBlocksToMove) + uPercentStart,
-                                              pIfProgress->pvUser);
+                rc = pCbProgress->pfnProgress(pIfProgress->pvUser,
+                                              (uint64_t)i * uPercentSpan / (cBlocks + cBlocksToMove) + uPercentStart);
                 if (RT_FAILURE(rc))
                     break;
@@ -2201 +2201 @@
             if (pCbProgress && pCbProgress->pfnProgress)
             {
-                rc = pCbProgress->pfnProgress(NULL /* WARNING! pVM=NULL */,
-                                              (uint64_t)(cBlocks + cBlocksMoved) * uPercentSpan / (cBlocks + cBlocksToMove) + uPercentStart,
-                                              pIfProgress->pvUser);
+                rc = pCbProgress->pfnProgress(pIfProgress->pvUser,
+                                              (uint64_t)(cBlocks + cBlocksMoved) * uPercentSpan / (cBlocks + cBlocksToMove) + uPercentStart);
+                                             
                 if (RT_FAILURE(rc))
                     break;
@@ -2230 +2230 @@
     if (RT_SUCCESS(rc) && pCbProgress && pCbProgress->pfnProgress)
     {
-        pCbProgress->pfnProgress(NULL /* WARNING! pVM=NULL */,
-                                 uPercentStart + uPercentSpan,
-                                 pIfProgress->pvUser);
+        pCbProgress->pfnProgress(pIfProgress->pvUser,
+                                 uPercentStart + uPercentSpan);
     }
 

trunk/src/VBox/Devices/Storage/VHDHDDCore.cpp

@@ -4 +4 @@
 
 /*
- * Copyright (C) 2006-2008 Sun Microsystems, Inc.
+ * Copyright (C) 2006-2010 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -245 +245 @@
                                                      pImage->pszFilename,
                                                      uOpenFlags,
-                                                     NULL, &pImage->pvStorage);
+                                                     NULL,
+                                                     pImage->pVDIfsDisk,
+                                                     &pImage->pvStorage);
 #endif
 
@@ -1807 +1809 @@
                           PCPDMMEDIAGEOMETRY pLCHSGeometry, PCRTUUID pUuid,
                           unsigned uOpenFlags,
-                          PFNVMPROGRESS pfnProgress, void *pvUser,
+                          PFNVDPROGRESS pfnProgress, void *pvUser,
                           unsigned uPercentStart, unsigned uPercentSpan)
 {
@@ -1893 +1895 @@
         /* We are half way thourgh with creation of image, let the caller know. */
         if (pfnProgress)
-            pfnProgress(NULL /* WARNING! pVM=NULL  */, (uPercentStart + uPercentSpan) / 2, pvUser);
+            pfnProgress(pvUser, (uPercentStart + uPercentSpan) / 2);
 
         rc = vhdCreateDynamicImage(pImage, cbSize);
@@ -1929 +1931 @@
 
     if (pfnProgress)
-        pfnProgress(NULL /* WARNING! pVM=NULL  */, uPercentStart + uPercentSpan, pvUser);
+        pfnProgress(pvUser, uPercentStart + uPercentSpan);
 
 out:
@@ -1947 +1949 @@
     PVHDIMAGE pImage;
 
-    PFNVMPROGRESS pfnProgress = NULL;
+    PFNVDPROGRESS pfnProgress = NULL;
     void *pvUser = NULL;
     PVDINTERFACE pIfProgress = VDInterfaceGet(pVDIfsOperation,

trunk/src/VBox/Devices/Storage/VmdkHDDCore.cpp

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2006-2007 Sun Microsystems, Inc.
+ * Copyright (C) 2006-2010 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -587 +587 @@
                                                            : 0,
                                                          NULL,
+                                                         pImage->pVDIfsDisk,
                                                          &pVmdkFile->pStorage);
         pVmdkFile->fAsyncIO = true;
@@ -3487 +3488 @@
 static int vmdkCreateRegularImage(PVMDKIMAGE pImage, uint64_t cbSize,
                                   unsigned uImageFlags,
-                                  PFNVMPROGRESS pfnProgress, void *pvUser,
+                                  PFNVDPROGRESS pfnProgress, void *pvUser,
                                   unsigned uPercentStart, unsigned uPercentSpan)
 {
@@ -3626 +3627 @@
                 if (pfnProgress)
                 {
-                    rc = pfnProgress(NULL /* WARNING! pVM=NULL */,
-                                     uPercentStart + uOff * uPercentSpan / cbExtent,
-                                     pvUser);
+                    rc = pfnProgress(pvUser,
+                                     uPercentStart + uOff * uPercentSpan / cbExtent);
                     if (RT_FAILURE(rc))
                     {
@@ -3695 +3695 @@
 
         if (RT_SUCCESS(rc) && pfnProgress)
-            pfnProgress(NULL /* WARNING! pVM=NULL */,
-                        uPercentStart + i * uPercentSpan / cExtents,
-                        pvUser);
+            pfnProgress(pvUser, uPercentStart + i * uPercentSpan / cExtents);
 
         cbRemaining -= cbExtent;
@@ -3746 +3744 @@
                            PCPDMMEDIAGEOMETRY pPCHSGeometry,
                            PCPDMMEDIAGEOMETRY pLCHSGeometry, PCRTUUID pUuid,
-                           PFNVMPROGRESS pfnProgress, void *pvUser,
+                           PFNVDPROGRESS pfnProgress, void *pvUser,
                            unsigned uPercentStart, unsigned uPercentSpan)
 {
@@ -3793 +3791 @@
 
     if (RT_SUCCESS(rc) && pfnProgress)
-        pfnProgress(NULL /* WARNING! pVM=NULL */,
-                    uPercentStart + uPercentSpan * 98 / 100, pvUser);
+        pfnProgress(pvUser, uPercentStart + uPercentSpan * 98 / 100);
 
     pImage->cbSize = cbSize;
@@ -3880 +3877 @@
 
     if (RT_SUCCESS(rc) && pfnProgress)
-        pfnProgress(NULL /* WARNING! pVM=NULL */,
-                    uPercentStart + uPercentSpan * 99 / 100, pvUser);
+        pfnProgress(pvUser, uPercentStart + uPercentSpan * 99 / 100);
 
     rc = vmdkFlushImage(pImage);
@@ -3887 +3883 @@
 out:
     if (RT_SUCCESS(rc) && pfnProgress)
-        pfnProgress(NULL /* WARNING! pVM=NULL */,
-                    uPercentStart + uPercentSpan, pvUser);
+        pfnProgress(pvUser, uPercentStart + uPercentSpan);
 
     if (RT_FAILURE(rc))
@@ -4515 +4510 @@
     PVMDKIMAGE pImage;
 
-    PFNVMPROGRESS pfnProgress = NULL;
+    PFNVDPROGRESS pfnProgress = NULL;
     void *pvUser = NULL;
     PVDINTERFACE pIfProgress = VDInterfaceGet(pVDIfsOperation,

trunk/src/VBox/Main/MediumImpl.cpp

@@ -4785 +4785 @@
 
 /**
- * PFNVMPROGRESS callback handler for Task operations.
- *
+ * PFNVDPROGRESS callback handler for Task operations.
+ *
+ * @param pvUser      Pointer to the Progress instance.
  * @param uPercent    Completetion precentage (0-100).
- * @param pvUser      Pointer to the Progress instance.
  */
 /*static*/
-DECLCALLBACK(int) Medium::vdProgressCall(PVM /* pVM */, unsigned uPercent,
-                                         void *pvUser)
+DECLCALLBACK(int) Medium::vdProgressCall(void *pvUser, unsigned uPercent)
 {
     Progress *that = static_cast<Progress *>(pvUser);

trunk/src/VBox/Main/include/MediumImpl.h

@@ -27 +27 @@
 
 class Progress;
-struct VM;
 
 namespace settings
@@ -295 +294 @@
                                           const char *pszFormat, va_list va);
 
-    static DECLCALLBACK(int) vdProgressCall(VM* /* pVM */, unsigned uPercent,
-                                            void *pvUser);
+    static DECLCALLBACK(int) vdProgressCall(void *pvUser, unsigned uPercent);
 
     static DECLCALLBACK(bool) vdConfigAreKeysValid(void *pvUser,