Changeset 98044 in vbox for trunk/src/VBox/Main/src-server/MediumImpl.cpp

Timestamp:

Jan 10, 2023 8:01:32 PM (2 years ago)

Author:

vboxsync

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

155144

Message:

Main: Added redundancy pending release. Fixed minor issues with resizeAndCloneTo. bugref:10090

File:

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

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

@@ -498 +498 @@
               bool fKeepTargetMediumLockList = false,
               bool fNotifyAboutChanges = true,
-              LONG64 aTargetLogicalSize = 0)
+              uint64_t aTargetLogicalSize = 0)
         : Medium::Task(aMedium, aProgress, fNotifyAboutChanges),
           mTarget(aTarget),
@@ -512 +512 @@
           mfKeepSourceMediumLockList(fKeepSourceMediumLockList),
           mfKeepTargetMediumLockList(fKeepTargetMediumLockList)
-
     {
         AssertReturnVoidStmt(aTarget != NULL, mRC = E_FAIL);
@@ -537 +536 @@
     const ComObjPtr<Medium> mTarget;
     const ComObjPtr<Medium> mParent;
-    LONG64 mTargetLogicalSize;
+    uint64_t mTargetLogicalSize;
     MediumLockList *mpSourceMediumLockList;
     MediumLockList *mpTargetMediumLockList;
@@ -3025 +3024 @@
                         ComPtr<IProgress> &aProgress)
 {
-    return resizeAndCloneTo(aTarget, 0, aVariant, aParent, aProgress);
+    /** @todo r=jack: Remove redundancy. Call Medium::resizeAndCloneTo. */
+
+    /** @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. */
+    ComAssertRet(aTarget != this, E_INVALIDARG);
+
+    IMedium *aT = aTarget;
+    ComObjPtr<Medium> pTarget = static_cast<Medium*>(aT);
+    ComObjPtr<Medium> pParent;
+    if (aParent)
+    {
+        IMedium *aP = aParent;
+        pParent = static_cast<Medium*>(aP);
+    }
+
+    HRESULT rc = S_OK;
+    ComObjPtr<Progress> pProgress;
+    Medium::Task *pTask = NULL;
+
+    try
+    {
+        // locking: we need the tree lock first because we access parent pointers
+        // and we need to write-lock the media involved
+        uint32_t    cHandles    = 3;
+        LockHandle* pHandles[4] = { &m->pVirtualBox->i_getMediaTreeLockHandle(),
+                                    this->lockHandle(),
+                                    pTarget->lockHandle() };
+        /* Only add parent to the lock if it is not null */
+        if (!pParent.isNull())
+            pHandles[cHandles++] = pParent->lockHandle();
+        AutoWriteLock alock(cHandles,
+                            pHandles
+                            COMMA_LOCKVAL_SRC_POS);
+
+        if (    pTarget->m->state != MediumState_NotCreated
+            &&  pTarget->m->state != MediumState_Created)
+            throw pTarget->i_setStateError();
+
+        /* Build the source lock list. */
+        MediumLockList *pSourceMediumLockList(new MediumLockList());
+        alock.release();
+        rc = i_createMediumLockList(true /* fFailIfInaccessible */,
+                                    NULL /* pToLockWrite */,
+                                    false /* fMediumLockWriteAll */,
+                                    NULL,
+                                    *pSourceMediumLockList);
+        alock.acquire();
+        if (FAILED(rc))
+        {
+            delete pSourceMediumLockList;
+            throw rc;
+        }
+
+        /* Build the target lock list (including the to-be parent chain). */
+        MediumLockList *pTargetMediumLockList(new MediumLockList());
+        alock.release();
+        rc = pTarget->i_createMediumLockList(true /* fFailIfInaccessible */,
+                                             pTarget /* pToLockWrite */,
+                                             false /* fMediumLockWriteAll */,
+                                             pParent,
+                                             *pTargetMediumLockList);
+        alock.acquire();
+        if (FAILED(rc))
+        {
+            delete pSourceMediumLockList;
+            delete pTargetMediumLockList;
+            throw rc;
+        }
+
+        alock.release();
+        rc = pSourceMediumLockList->Lock();
+        alock.acquire();
+        if (FAILED(rc))
+        {
+            delete pSourceMediumLockList;
+            delete pTargetMediumLockList;
+            throw setError(rc,
+                           tr("Failed to lock source media '%s'"),
+                           i_getLocationFull().c_str());
+        }
+        alock.release();
+        rc = pTargetMediumLockList->Lock();
+        alock.acquire();
+        if (FAILED(rc))
+        {
+            delete pSourceMediumLockList;
+            delete pTargetMediumLockList;
+            throw setError(rc,
+                           tr("Failed to lock target media '%s'"),
+                           pTarget->i_getLocationFull().c_str());
+        }
+
+        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;
+
+        if (aVariant.size())
+        {
+            for (size_t i = 0; i < aVariant.size(); i++)
+                mediumVariantFlags |= (ULONG)aVariant[i];
+        }
+
+        if (mediumVariantFlags & MediumVariant_Formatted)
+        {
+            delete pSourceMediumLockList;
+            delete pTargetMediumLockList;
+            throw setError(VBOX_E_NOT_SUPPORTED,
+                           tr("Medium variant 'formatted' applies to floppy images only"));
+        }
+
+        /* 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);
+        rc = pTask->rc();
+        AssertComRC(rc);
+        if (FAILED(rc))
+            throw rc;
+
+        if (pTarget->m->state == MediumState_NotCreated)
+            pTarget->m->state = MediumState_Creating;
+    }
+    catch (HRESULT aRC) { rc = aRC; }
+
+    if (SUCCEEDED(rc))
+    {
+        rc = pTask->createThread();
+        pTask = NULL;
+        if (SUCCEEDED(rc))
+            pProgress.queryInterfaceTo(aProgress.asOutParam());
+    }
+    else if (pTask != NULL)
+        delete pTask;
+
+    return rc;
 }
 
@@ -3062 +3207 @@
     /* Set up variables. Fetch needed data in lockable blocks */
     HRESULT rc = S_OK;
-    ComObjPtr<Progress> pTmpProgress;
     Medium::Task *pTask = NULL;
 
@@ -3091 +3235 @@
 
     if (FAILED(rc))
-        throw rc;
+        return rc;
 
     /* If target does not exist, handle resize. */
@@ -3099 +3243 @@
             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;
+                return rc;
             }
 
@@ -3115 +3258 @@
             rc = pTarget->LockWrite(pToken.asOutParam());
 
-            if (FAILED(rc)) throw rc;
+            if (FAILED(rc)) return rc;
 
             /**
@@ -3134 +3277 @@
                                 strTargetName.c_str());
                 delete pMediumLockListForResize;
-                throw rc;
+                return rc;
             }
 
@@ -3145 +3288 @@
                 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
                 delete pMediumLockListForResize;
-                throw rc;
+                return rc;
             }
 
@@ -3268 +3411 @@
                                           pParent, UINT32_MAX, UINT32_MAX,
                                           pSourceMediumLockList, pTargetMediumLockList,
-                                          false, false, true, aLogicalSize);
+                                          false, false, true, (uint64_t)aLogicalSize);
         }
 
@@ -3288 +3431 @@
             pProgress.queryInterfaceTo(aProgress.asOutParam());
     }
-    else if (pTask != NULL) {
+    else if (pTask != NULL)
         delete pTask;
-        throw rc;
-    }
 
     return rc;
@@ -9776 +9917 @@
                                  (fCreatingTarget) ? targetLocation.c_str() : (char *)NULL,
                                  false /* fMoveByRename */,
-                                 (uint64_t) task.mTargetLogicalSize /* cbSize */,
+                                 task.mTargetLogicalSize /* cbSize */,
                                  task.mVariant & ~(MediumVariant_NoCreateDir | MediumVariant_Formatted | MediumVariant_VmdkESX | MediumVariant_VmdkRawDisk),
                                  targetId.raw(),
@@ -9792 +9933 @@
                                    (fCreatingTarget) ? targetLocation.c_str() : (char *)NULL,
                                    false /* fMoveByRename */,
-                                   (uint64_t) task.mTargetLogicalSize /* cbSize */,
+                                   task.mTargetLogicalSize /* cbSize */,
                                    task.midxSrcImageSame,
                                    task.midxDstImageSame,