Changeset 97931 in vbox for trunk/src/VBox/Main/src-server

Timestamp:

Dec 31, 2022 9:44:15 PM (2 years ago)

Author:

vboxsync

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

155021

Message:

Main: Added resizeAndCloneTo(). Modified cloneTo(), bugref:10090

File:

• trunk/src/VBox/Main/src-server/MediumImpl.cpp (modified) (10 diffs)

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

@@ -497 +497 @@
               bool fKeepSourceMediumLockList = false,
               bool fKeepTargetMediumLockList = false,
-              bool fNotifyAboutChanges = true)
+              bool fNotifyAboutChanges = true,
+              LONG64 aTargetLogicalSize = 0)
         : Medium::Task(aMedium, aProgress, fNotifyAboutChanges),
           mTarget(aTarget),
           mParent(aParent),
+          mTargetLogicalSize(aTargetLogicalSize),
           mpSourceMediumLockList(aSourceMediumLockList),
           mpTargetMediumLockList(aTargetMediumLockList),
@@ -510 +512 @@
           mfKeepSourceMediumLockList(fKeepSourceMediumLockList),
           mfKeepTargetMediumLockList(fKeepTargetMediumLockList)
+
     {
         AssertReturnVoidStmt(aTarget != NULL, mRC = E_FAIL);
@@ -534 +537 @@
     const ComObjPtr<Medium> mTarget;
     const ComObjPtr<Medium> mParent;
+    LONG64 mTargetLogicalSize;
     MediumLockList *mpSourceMediumLockList;
     MediumLockList *mpTargetMediumLockList;
@@ -3020 +3024 @@
                         ComPtr<IProgress> &aProgress)
 {
-    /** @todo r=klaus The code below needs to be double checked with regard
-     * to lock order violations, it probably causes lock order issues related
-     * to the AutoCaller usage. */
+    return resizeAndCloneTo(aTarget, 0, aVariant, aParent, aProgress);
+}
+
+/**
+ * This is a helper function that combines the functionality of
+ * Medium::cloneTo() and Medium::resize(). The target medium will take the
+ * contents of the calling medium.
+ *
+ * @param aTarget           Medium to resize and clone to
+ * @param aLogicalSize      Desired size for targer medium
+ * @param aVariant
+ * @param aParent
+ * @param aProgress
+ * @return HRESULT
+ */
+HRESULT Medium::resizeAndCloneTo(const ComPtr<IMedium> &aTarget,
+                                 LONG64 aLogicalSize,
+                                 const std::vector<MediumVariant_T> &aVariant,
+                                 const ComPtr<IMedium> &aParent,
+                                 ComPtr<IProgress> &aProgress)
+{
+    /* Check for valid args */
     ComAssertRet(aTarget != this, E_INVALIDARG);
-
+    CheckComArgExpr(aLogicalSize, aLogicalSize >= 0);
+
+    /* Convert args to usable/needed types */
     IMedium *aT = aTarget;
     ComObjPtr<Medium> pTarget = static_cast<Medium*>(aT);
@@ -3034 +3059 @@
     }
 
+    /* Set up variables. Fetch needed data in lockable blocks */
     HRESULT rc = S_OK;
+    ComObjPtr<Progress> pTmpProgress;
+    Medium::Task *pTask = NULL;
+
+    Utf8Str strSourceName;
+    {
+        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+        strSourceName = i_getName();
+    }
+
+    uint64_t uTargetExistingSize = 0;
+    Utf8Str strTargetName;
+    {
+        AutoReadLock alock(pTarget COMMA_LOCKVAL_SRC_POS);
+        uTargetExistingSize = pTarget->i_getLogicalSize();
+        strTargetName = pTarget->i_getName();
+    }
+
+    /* Set up internal multi-subprocess progress object */
     ComObjPtr<Progress> pProgress;
-    Medium::Task *pTask = NULL;
+    pProgress.createObject();
+    rc = pProgress->init(m->pVirtualBox,
+                static_cast<IMedium*>(this),
+                BstrFmt(tr("Resizing medium and cloning into it")).raw(),
+                TRUE, /* aCancelable */
+                2, /* Number of opearations */
+                BstrFmt(tr("Resizing medium before clone")).raw()
+                );
+
+    if (FAILED(rc))
+        throw rc;
+
+    /* If target does not exist, handle resize. */
+    if (pTarget->m->state != MediumState_NotCreated && aLogicalSize > 0)
+    {
+        if ((LONG64)uTargetExistingSize != aLogicalSize) {
+            if (!i_isMediumFormatFile())
+            {
+                AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+                rc = setError(VBOX_E_NOT_SUPPORTED,
+                              tr("Sizes of '%s' and '%s' are different and \
+                                 medium format does not support resing"),
+                              strSourceName.c_str(), strTargetName.c_str());
+                throw rc;
+            }
+
+            /**
+             * Need to lock the target medium as i_resize does do so
+             * automatically.
+             */
+
+            ComPtr<IToken> pToken;
+            rc = pTarget->LockWrite(pToken.asOutParam());
+
+            if (FAILED(rc)) throw rc;
+
+            /**
+             * Have to make own lock list, because "resize" method resizes only
+             * last image in the lock chain.
+             */
+
+            MediumLockList* pMediumLockListForResize = new MediumLockList();
+            pMediumLockListForResize->Append(pTarget, pTarget->m->state == MediumState_LockedWrite);
+
+            rc = pMediumLockListForResize->Lock(true /* fSkipOverLockedMedia */);
+
+            if (FAILED(rc))
+            {
+                AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+                rc = setError(rc,
+                                tr("Failed to lock the medium '%s' to resize before merge"),
+                                strTargetName.c_str());
+                delete pMediumLockListForResize;
+                throw rc;
+            }
+
+
+            rc = pTarget->i_resize((uint64_t)aLogicalSize, pMediumLockListForResize, &pProgress, true, false);
+
+            if (FAILED(rc))
+            {
+                /* No need to setError becasue i_resize and i_taskResizeHandler handle this automatically. */
+                AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+                delete pMediumLockListForResize;
+                throw rc;
+            }
+
+            delete pMediumLockListForResize;
+
+            pTarget->m->logicalSize = (uint64_t)aLogicalSize;
+
+            pToken->Abandon();
+            pToken.setNull();
+        }
+    }
+
+    /* Report progress to supplied progress argument */
+    if (SUCCEEDED(rc))
+    {
+        pProgress.queryInterfaceTo(aProgress.asOutParam());
+    }
 
     try
@@ -3111 +3235 @@
         }
 
-        pProgress.createObject();
-        rc = pProgress->init(m->pVirtualBox,
-                             static_cast <IMedium *>(this),
-                             BstrFmt(tr("Creating clone medium '%s'"), pTarget->m->strLocationFull.c_str()).raw(),
-                             TRUE /* aCancelable */);
-        if (FAILED(rc))
-        {
-            delete pSourceMediumLockList;
-            delete pTargetMediumLockList;
-            throw rc;
-        }
-
         ULONG mediumVariantFlags = 0;
 
@@ -3139 +3251 @@
         }
 
-        /* setup task object to carry out the operation asynchronously */
-        pTask = new Medium::CloneTask(this, pProgress, pTarget,
-                                      (MediumVariant_T)mediumVariantFlags,
-                                      pParent, UINT32_MAX, UINT32_MAX,
-                                      pSourceMediumLockList, pTargetMediumLockList);
+        if (pTarget->m->state != MediumState_NotCreated || aLogicalSize == 0)
+        {
+            /* setup task object to carry out the operation asynchronously */
+            pTask = new Medium::CloneTask(this, pProgress, pTarget,
+                                          (MediumVariant_T)mediumVariantFlags,
+                                          pParent, UINT32_MAX, UINT32_MAX,
+                                          pSourceMediumLockList, pTargetMediumLockList,
+                                          false, false, true, 0);
+        }
+        else
+        {
+            /* setup task object to carry out the operation asynchronously */
+            pTask = new Medium::CloneTask(this, pProgress, pTarget,
+                                          (MediumVariant_T)mediumVariantFlags,
+                                          pParent, UINT32_MAX, UINT32_MAX,
+                                          pSourceMediumLockList, pTargetMediumLockList,
+                                          false, false, true, aLogicalSize);
+        }
+
         rc = pTask->rc();
         AssertComRC(rc);
@@ -3161 +3287 @@
             pProgress.queryInterfaceTo(aProgress.asOutParam());
     }
-    else if (pTask != NULL)
+    else if (pTask != NULL) {
         delete pTask;
+        throw rc;
+    }
 
     return rc;
@@ -9647 +9775 @@
                                  (fCreatingTarget) ? targetLocation.c_str() : (char *)NULL,
                                  false /* fMoveByRename */,
-                                 0 /* cbSize */,
+                                 (uint64_t) task.mTargetLogicalSize /* cbSize */,
                                  task.mVariant & ~(MediumVariant_NoCreateDir | MediumVariant_Formatted),
                                  targetId.raw(),
@@ -9663 +9791 @@
                                    (fCreatingTarget) ? targetLocation.c_str() : (char *)NULL,
                                    false /* fMoveByRename */,
-                                   0 /* cbSize */,
+                                   (uint64_t) task.mTargetLogicalSize /* cbSize */,
                                    task.midxSrcImageSame,
                                    task.midxDstImageSame,