Changeset 97864 in vbox

Timestamp:

Dec 23, 2022 9:25:48 PM (21 months ago)

Author:

vboxsync

Message:

Main: Added API function Medium::resizeAndCloneTo. Modified Medium::resize. bugref:10090

Location:

trunk

Files:

• doc/manual/en_US/man_VBoxManage-clonemedium.xml (modified) (2 diffs)
• src/VBox/Frontends/VBoxManage/VBoxManageDisk.cpp (modified) (4 diffs)
• src/VBox/Main/idl/VirtualBox.xidl (modified) (2 diffs)
• src/VBox/Main/include/MediumImpl.h (modified) (1 diff)
• src/VBox/Main/src-server/MediumImpl.cpp (modified) (10 diffs)
• src/VBox/ValidationKit/tests/api/tdApi1.py (modified) (1 diff)
• src/VBox/ValidationKit/tests/api/tdCloneMedium1.py (added)

trunk/doc/manual/en_US/man_VBoxManage-clonemedium.xml

@@ -64 +64 @@
       </group>
       <arg>--existing</arg>
+      <arg>--resize=<replaceable>size-in-MB</replaceable></arg>
       <arg>--format=<group choice="plain">
           <arg choice="plain">VDI</arg>
@@ -134 +135 @@
       </varlistentry>
       <varlistentry>
+        <term><option>--resize=<replaceable>size-in-MB</replaceable></option></term>
+          <listitem><para>
+            Performs a resize of the target medium to the specified
+            size before performing the clone operation.
+          </para></listitem>
+      </varlistentry>
+      <varlistentry>
         <term><option>--format</option></term>
         <listitem><para>

trunk/src/VBox/Frontends/VBoxManage/VBoxManageDisk.cpp

@@ -1005 +1005 @@
     { "--variant",      'm', RTGETOPT_REQ_STRING },
     { "-variant",       'm', RTGETOPT_REQ_STRING },
+    { "--resize",       'r', RTGETOPT_REQ_UINT64 },
 };
 
@@ -1022 +1023 @@
     MediumVariant_T enmMediumVariant = MediumVariant_Standard;
     bool fExisting = false;
+    bool fNeedResize = false;
+    uint64_t cbResize = 0;
 
     int c;
@@ -1071 +1074 @@
                 if (RT_FAILURE(vrc))
                     return errorArgument(Disk::tr("Invalid medium variant '%s'"), ValueUnion.psz);
+                break;
+
+            case 'r':   // --resize
+                fNeedResize = true;
+                cbResize = ValueUnion.u64 * _1M;
                 break;
 
@@ -1191 +1199 @@
         }
 
-        CHECK_ERROR_BREAK(pSrcMedium, CloneTo(pDstMedium, ComSafeArrayAsInParam(l_variants), NULL, pProgress.asOutParam()));
+        if (fNeedResize)
+        {
+            CHECK_ERROR_BREAK(pSrcMedium, ResizeAndCloneTo(pDstMedium, cbResize, ComSafeArrayAsInParam(l_variants), NULL, pProgress.asOutParam()));
+        }
+        else
+        {
+            CHECK_ERROR_BREAK(pSrcMedium, CloneTo(pDstMedium, ComSafeArrayAsInParam(l_variants), NULL, pProgress.asOutParam()));
+        }
+
 
         hrc = showProgress(pProgress);

trunk/src/VBox/Main/idl/VirtualBox.xidl

@@ -18126 +18126 @@
   <interface
     name="IMedium" extends="$unknown"
-    uuid="ad47ad09-787b-44ab-b343-a082a3f2dfb1"
+    uuid="dbe1d807-5fa1-482f-9121-37b8fd855348"
     wsmap="managed"
     rest="managed"
@@ -19212 +19212 @@
       <param name="target" type="IMedium" dir="in">
         <desc>Target medium.</desc>
+      </param>
+      <param name="variant" type="MediumVariant" safearray="yes" dir="in">
+        <desc>Exact image variant which should be created (as a combination of
+          <link to="MediumVariant" /> flags).</desc>
+      </param>
+      <param name="parent" type="IMedium" dir="in">
+        <desc>Parent of the cloned medium.</desc>
+      </param>
+      <param name="progress" type="IProgress" dir="return">
+        <desc>Progress object to track the operation completion.</desc>
+      </param>
+    </method>
+
+    <method name="resizeAndCloneTo">
+      <rest request="post" path="/mediums/{mediumid}/actions/"/>
+
+      <desc>
+        This is a helper function that combines the functionality of
+        <link to="IMedium::cloneTo"/> and <link to="IMedium::resize"/>. The target medium will take the
+        contents of the calling medium.
+        <result name="E_NOTIMPL">
+          The specified cloning variant is not supported at the moment.
+        </result>
+      </desc>
+
+      <param name="target" type="IMedium" dir="in">
+        <desc>Target medium.</desc>
+      </param>
+      <param name="logicalSize" type="long long" dir="in">
+        <desc>New nominal capacity of the medium in bytes.</desc>
       </param>
       <param name="variant" type="MediumVariant" safearray="yes" dir="in">

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

@@ -317 +317 @@
                     const ComPtr<IMedium> &aParent,
                     ComPtr<IProgress> &aProgress);
+    HRESULT resizeAndCloneTo(const ComPtr<IMedium> &aTarget,
+                             const LONG64 aLogicalSize,
+                             const std::vector<MediumVariant_T> &aVariant,
+                             const ComPtr<IMedium> &aParent,
+                             ComPtr<IProgress> &aProgress);
     HRESULT cloneToBase(const ComPtr<IMedium> &aTarget,
                         const std::vector<MediumVariant_T> &aVariant,

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,
+                                 const 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 = 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,

trunk/src/VBox/ValidationKit/tests/api/tdApi1.py

@@ -95 +95 @@
     from tdTreeDepth1    import SubTstDrvTreeDepth1;  # pylint: disable=relative-import
     from tdMoveVm1       import SubTstDrvMoveVm1;     # pylint: disable=relative-import
+    from tdCloneMedium1  import SubTstDrvCloneMedium1;# pylint: disable=relative-import
     sys.exit(tdApi1([SubTstDrvPython1, SubTstDrvAppliance1, SubTstDrvMoveMedium1,
-                     SubTstDrvTreeDepth1, SubTstDrvMoveVm1]).main(sys.argv))
-
+                     SubTstDrvTreeDepth1, SubTstDrvMoveVm1, SubTstDrvCloneMedium1]).main(sys.argv))