Changeset 38308 in vbox

Timestamp:

Aug 4, 2011 9:29:51 AM (13 years ago)

Author:

vboxsync

Message:

Main/Medium: public cloneToEx API for internal use which makes it possible to control certain optimizations during VM cloning

Location:

trunk/src/VBox/Main

Files:

• include/MediumImpl.h (modified) (1 diff)
• src-server/MediumImpl.cpp (modified) (6 diffs)

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

@@ -263 +263 @@
                        const ComObjPtr<Progress> &aProgress);
 
+    HRESULT cloneToEx(const ComObjPtr<Medium> &aTarget, ULONG aVariant,
+                      const ComObjPtr<Medium> &aParent, const ComObjPtr<Progress> &aProgress,
+                      uint32_t idxSrcImageSame, uint32_t idxDstImageSame);
+
 private:
 

trunk/src/VBox/Main/src-server/MediumImpl.cpp

@@ -341 +341 @@
               MediumVariant_T aVariant,
               Medium *aParent,
+              uint32_t idxSrcImageSame,
+              uint32_t idxDstImageSame,
               MediumLockList *aSourceMediumLockList,
               MediumLockList *aTargetMediumLockList,
@@ -351 +353 @@
           mpTargetMediumLockList(aTargetMediumLockList),
           mVariant(aVariant),
+          midxSrcImageSame(idxSrcImageSame),
+          midxDstImageSame(idxDstImageSame),
           mTargetCaller(aTarget),
           mParentCaller(aParent),
@@ -381 +385 @@
     MediumLockList *mpTargetMediumLockList;
     MediumVariant_T mVariant;
+    uint32_t midxSrcImageSame;
+    uint32_t midxDstImageSame;
 
 private:
@@ -2697 +2703 @@
         pTask = new Medium::CloneTask(this, pProgress, pTarget,
                                       (MediumVariant_T)aVariant,
-                                      pParent, pSourceMediumLockList,
-                                      pTargetMediumLockList);
+                                      pParent, UINT32_MAX, UINT32_MAX,
+                                      pSourceMediumLockList, pTargetMediumLockList);
         rc = pTask->rc();
         AssertComRC(rc);
@@ -5061 +5067 @@
         if (m->state == MediumState_NotCreated)
             m->state = MediumState_Creating;
+    }
+    catch (HRESULT aRC) { rc = aRC; }
+
+    if (SUCCEEDED(rc))
+        rc = startThread(pTask);
+    else if (pTask != NULL)
+        delete pTask;
+
+    return rc;
+}
+
+/**
+ * Internal version of the public CloneTo API which allows to enable certain
+ * optimizations to improve speed during VM cloning.
+ *
+ * @param aTarget            Target medium
+ * @param aVariant           Which exact image format variant to use
+ *                           for the destination image.
+ * @param aParent            Parent medium. May be NULL.
+ * @param aProgress          Progress object to use.
+ * @param idxSrcImageSame    The last image in the source chain which has the
+ *                           same content as the given image in the destination
+ *                           chain. Use UINT32_MAX to disable this optimization.
+ * @param idxDstImageSame    The last image in the destination chain which has the
+ *                           same content as the given image in the source chain.
+ *                           Use UINT32_MAX to disable this optimization.
+ * @return
+ */
+HRESULT Medium::cloneToEx(const ComObjPtr<Medium> &aTarget, ULONG aVariant,
+                          const ComObjPtr<Medium> &aParent, const ComObjPtr<Progress> &aProgress,
+                          uint32_t idxSrcImageSame, uint32_t idxDstImageSame)
+{
+    CheckComArgNotNull(aTarget);
+    AssertReturn(!aProgress.isNull(), E_INVALIDARG);
+    ComAssertRet(aTarget != this, E_INVALIDARG);
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    HRESULT rc = S_OK;
+    ComObjPtr<Progress> pProgress;
+    Medium::Task *pTask = NULL;
+
+    try
+    {
+        // locking: we need the tree lock first because we access parent pointers
+        AutoReadLock treeLock(m->pVirtualBox->getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
+        // and we need to write-lock the media involved
+        AutoMultiWriteLock3 alock(this, aTarget, aParent COMMA_LOCKVAL_SRC_POS);
+
+        if (    aTarget->m->state != MediumState_NotCreated
+            &&  aTarget->m->state != MediumState_Created)
+            throw aTarget->setStateError();
+
+        /* Build the source lock list. */
+        MediumLockList *pSourceMediumLockList(new MediumLockList());
+        rc = createMediumLockList(true /* fFailIfInaccessible */,
+                                  false /* fMediumLockWrite */,
+                                  NULL,
+                                  *pSourceMediumLockList);
+        if (FAILED(rc))
+        {
+            delete pSourceMediumLockList;
+            throw rc;
+        }
+
+        /* Build the target lock list (including the to-be parent chain). */
+        MediumLockList *pTargetMediumLockList(new MediumLockList());
+        rc = aTarget->createMediumLockList(true /* fFailIfInaccessible */,
+                                           true /* fMediumLockWrite */,
+                                           aParent,
+                                           *pTargetMediumLockList);
+        if (FAILED(rc))
+        {
+            delete pSourceMediumLockList;
+            delete pTargetMediumLockList;
+            throw rc;
+        }
+
+        rc = pSourceMediumLockList->Lock();
+        if (FAILED(rc))
+        {
+            delete pSourceMediumLockList;
+            delete pTargetMediumLockList;
+            throw setError(rc,
+                           tr("Failed to lock source media '%s'"),
+                           getLocationFull().c_str());
+        }
+        rc = pTargetMediumLockList->Lock();
+        if (FAILED(rc))
+        {
+            delete pSourceMediumLockList;
+            delete pTargetMediumLockList;
+            throw setError(rc,
+                           tr("Failed to lock target media '%s'"),
+                           aTarget->getLocationFull().c_str());
+        }
+
+        pProgress.createObject();
+        rc = pProgress->init(m->pVirtualBox,
+                             static_cast <IMedium *>(this),
+                             BstrFmt(tr("Creating clone medium '%s'"), aTarget->m->strLocationFull.c_str()).raw(),
+                             TRUE /* aCancelable */);
+        if (FAILED(rc))
+        {
+            delete pSourceMediumLockList;
+            delete pTargetMediumLockList;
+            throw rc;
+        }
+
+        /* setup task object to carry out the operation asynchronously */
+        pTask = new Medium::CloneTask(this, aProgress, aTarget,
+                                      (MediumVariant_T)aVariant,
+                                      aParent, idxSrcImageSame,
+                                      idxDstImageSame, pSourceMediumLockList,
+                                      pTargetMediumLockList);
+        rc = pTask->rc();
+        AssertComRC(rc);
+        if (FAILED(rc))
+            throw rc;
+
+        if (aTarget->m->state == MediumState_NotCreated)
+            aTarget->m->state = MediumState_Creating;
     }
     catch (HRESULT aRC) { rc = aRC; }
@@ -6971 +7100 @@
 
                 /** @todo r=klaus target isn't locked, race getting the state */
-                vrc = VDCopy(hdd,
-                             VD_LAST_IMAGE,
-                             targetHdd,
-                             targetFormat.c_str(),
-                             (fCreatingTarget) ? targetLocation.c_str() : (char *)NULL,
-                             false /* fMoveByRename */,
-                             0 /* cbSize */,
-                             task.mVariant,
-                             targetId.raw(),
-                             VD_OPEN_FLAGS_NORMAL,
-                             NULL /* pVDIfsOperation */,
-                             pTarget->m->vdImageIfaces,
-                             task.mVDOperationIfaces);
+                if (task.midxSrcImageSame == UINT32_MAX)
+                {
+                    vrc = VDCopy(hdd,
+                                 VD_LAST_IMAGE,
+                                 targetHdd,
+                                 targetFormat.c_str(),
+                                 (fCreatingTarget) ? targetLocation.c_str() : (char *)NULL,
+                                 false /* fMoveByRename */,
+                                 0 /* cbSize */,
+                                 task.mVariant,
+                                 targetId.raw(),
+                                 VD_OPEN_FLAGS_NORMAL,
+                                 NULL /* pVDIfsOperation */,
+                                 pTarget->m->vdImageIfaces,
+                                 task.mVDOperationIfaces);
+                }
+                else
+                {
+                    vrc = VDCopyEx(hdd,
+                                   VD_LAST_IMAGE,
+                                   targetHdd,
+                                   targetFormat.c_str(),
+                                   (fCreatingTarget) ? targetLocation.c_str() : (char *)NULL,
+                                   false /* fMoveByRename */,
+                                   0 /* cbSize */,
+                                   task.midxSrcImageSame,
+                                   task.midxDstImageSame,
+                                   task.mVariant,
+                                   targetId.raw(),
+                                   VD_OPEN_FLAGS_NORMAL,
+                                   NULL /* pVDIfsOperation */,
+                                   pTarget->m->vdImageIfaces,
+                                   task.mVDOperationIfaces);
+                }
                 if (RT_FAILURE(vrc))
                     throw setError(VBOX_E_FILE_ERROR,