Changeset 32695 in vbox

Timestamp:

Sep 22, 2010 11:16:48 AM (14 years ago)

Author:

vboxsync

Message:

Main/Medium: new method exportFile which allows to export a medium using any VBoxHDD VFS implementation

Location:

trunk/src/VBox/Main

Files:

• MediumImpl.cpp (modified) (4 diffs)
• include/MediumImpl.h (modified) (4 diffs)

trunk/src/VBox/Main/MediumImpl.cpp

@@ -561 +561 @@
 };
 
+class Medium::ExportTask : public Medium::Task
+{
+public:
+    ExportTask(Medium *aMedium,
+               Progress *aProgress,
+               const char *aFilename,
+               MediumFormat *aFormat,
+               MediumVariant_T aVariant,
+               void *aVDImageIOCallbacks,
+               void *aVDImageIOUser,
+               MediumLockList *aSourceMediumLockList,
+               bool fKeepSourceMediumLockList = false)
+        : Medium::Task(aMedium, aProgress),
+          mpSourceMediumLockList(aSourceMediumLockList),
+          mFilename(aFilename),
+          mFormat(aFormat),
+          mVariant(aVariant),
+          mfKeepSourceMediumLockList(fKeepSourceMediumLockList)
+    {
+        AssertReturnVoidStmt(aSourceMediumLockList != NULL, mRC = E_FAIL);
+
+        mVDImageIfaces = aMedium->m->vdImageIfaces;
+        if (aVDImageIOCallbacks)
+        {
+            int vrc = VDInterfaceAdd(&mVDInterfaceIO, "Medium::vdInterfaceIO",
+                                     VDINTERFACETYPE_IO, aVDImageIOCallbacks,
+                                     aVDImageIOUser, &mVDImageIfaces);
+            AssertRCReturnVoidStmt(vrc, mRC = E_FAIL);
+        }
+    }
+
+    ~ExportTask()
+    {
+        if (!mfKeepSourceMediumLockList && mpSourceMediumLockList)
+            delete mpSourceMediumLockList;
+    }
+
+    MediumLockList *mpSourceMediumLockList;
+    Utf8Str mFilename;
+    ComObjPtr<MediumFormat> mFormat;
+    MediumVariant_T mVariant;
+    PVDINTERFACE mVDImageIfaces;
+
+private:
+    virtual HRESULT handler();
+
+    bool mfKeepSourceMediumLockList;
+    VDINTERFACE mVDInterfaceIO;
+};
+
 /**
  * Thread function for time-consuming medium tasks.
@@ -684 +734 @@
 {
     return mMedium->taskMergeHandler(*this);
+}
+
+/**
+ * Implementation code for the "export" task.
+ */
+HRESULT Medium::ExportTask::handler()
+{
+    return mMedium->taskExportHandler(*this);
 }
 
@@ -5054 +5112 @@
 }
 
+
+HRESULT Medium::exportFile(const char *aFilename,
+                           ComObjPtr<MediumFormat> aFormat,
+                           MediumVariant_T aVariant,
+                           void *aVDImageIOCallbacks, void *aVDImageIOUser,
+                           ComObjPtr<Progress> aProgress)
+{
+    return E_FAIL;
+
+    AssertPtrReturn(aFilename, E_INVALIDARG);
+    AssertReturn(!aFormat.isNull(), E_INVALIDARG);
+    AssertReturn(!aProgress.isNull(), E_INVALIDARG);
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    HRESULT rc = S_OK;
+    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
+        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+        /* Build the source lock list. */
+        MediumLockList *pSourceMediumLockList(new MediumLockList());
+        rc = createMediumLockList(true /* fFailIfInaccessible */,
+                                  false /* fMediumLockWrite */,
+                                  NULL,
+                                  *pSourceMediumLockList);
+        if (FAILED(rc))
+        {
+            delete pSourceMediumLockList;
+            throw rc;
+        }
+
+        rc = pSourceMediumLockList->Lock();
+        if (FAILED(rc))
+        {
+            delete pSourceMediumLockList;
+            throw setError(rc,
+                           tr("Failed to lock source media '%s'"),
+                           getLocationFull().c_str());
+        }
+
+        /* setup task object to carry out the operation asynchronously */
+        pTask = new Medium::ExportTask(this, aProgress, aFilename, aFormat,
+                                       aVariant, aVDImageIOCallbacks,
+                                       aVDImageIOUser, pSourceMediumLockList);
+        rc = pTask->rc();
+        AssertComRC(rc);
+        if (FAILED(rc))
+            throw rc;
+    }
+    catch (HRESULT aRC) { rc = aRC; }
+
+    if (SUCCEEDED(rc))
+        rc = startThread(pTask);
+    else if (pTask != NULL)
+        delete pTask;
+
+    return rc;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 //
@@ -6846 +6970 @@
 }
 
+/**
+ * Implementation code for the "export" task.
+ *
+ * This only gets started from Medium::exportFile() and always runs
+ * asynchronously. It doesn't touch anything configuration related, so
+ * we never save the VirtualBox.xml file here.
+ *
+ * @param task
+ * @return
+ */
+HRESULT Medium::taskExportHandler(Medium::ExportTask &task)
+{
+    HRESULT rc = S_OK;
+
+    try
+    {
+        /* Lock all in {parent,child} order. The lock is also used as a
+         * signal from the task initiator (which releases it only after
+         * RTThreadCreate()) that we can start the job. */
+        AutoWriteLock thisLock(this COMMA_LOCKVAL_SRC_POS);
+
+        PVBOXHDD hdd;
+        int vrc = VDCreate(m->vdDiskIfaces, &hdd);
+        ComAssertRCThrow(vrc, E_FAIL);
+
+        try
+        {
+            /* Open all media in the source chain. */
+            MediumLockList::Base::const_iterator sourceListBegin =
+                task.mpSourceMediumLockList->GetBegin();
+            MediumLockList::Base::const_iterator sourceListEnd =
+                task.mpSourceMediumLockList->GetEnd();
+            for (MediumLockList::Base::const_iterator it = sourceListBegin;
+                 it != sourceListEnd;
+                 ++it)
+            {
+                const MediumLock &mediumLock = *it;
+                const ComObjPtr<Medium> &pMedium = mediumLock.GetMedium();
+                AutoReadLock alock(pMedium COMMA_LOCKVAL_SRC_POS);
+
+                /* sanity check */
+                Assert(pMedium->m->state == MediumState_LockedRead);
+
+                /** Open all media in read-only mode. */
+                vrc = VDOpen(hdd,
+                             pMedium->m->strFormat.c_str(),
+                             pMedium->m->strLocationFull.c_str(),
+                             VD_OPEN_FLAGS_READONLY,
+                             pMedium->m->vdImageIfaces);
+                if (RT_FAILURE(vrc))
+                    throw setError(VBOX_E_FILE_ERROR,
+                                   tr("Could not open the medium storage unit '%s'%s"),
+                                   pMedium->m->strLocationFull.c_str(),
+                                   vdError(vrc).c_str());
+            }
+
+            Utf8Str targetFormat(task.mFormat->getId());
+            Utf8Str targetLocation(task.mFilename);
+
+            Assert(m->state == MediumState_LockedRead);
+
+            /* unlock before the potentially lengthy operation */
+            thisLock.release();
+
+            /* ensure the target directory exists */
+            rc = VirtualBox::ensureFilePathExists(targetLocation);
+            if (FAILED(rc))
+                throw rc;
+
+            PVBOXHDD targetHdd;
+            vrc = VDCreate(m->vdDiskIfaces, &targetHdd);
+            ComAssertRCThrow(vrc, E_FAIL);
+
+            try
+            {
+                vrc = VDCopy(hdd,
+                             VD_LAST_IMAGE,
+                             targetHdd,
+                             targetFormat.c_str(),
+                             targetLocation.c_str(),
+                             false /* fMoveByRename */,
+                             0 /* cbSize */,
+                             task.mVariant,
+                             NULL /* pDstUuid */,
+                             NULL /* pVDIfsOperation */,
+                             task.mVDImageIfaces,
+                             task.mVDOperationIfaces);
+                if (RT_FAILURE(vrc))
+                    throw setError(VBOX_E_FILE_ERROR,
+                                   tr("Could not create the clone medium '%s'%s"),
+                                   targetLocation.c_str(), vdError(vrc).c_str());
+            }
+            catch (HRESULT aRC) { rc = aRC; }
+
+            VDDestroy(targetHdd);
+        }
+        catch (HRESULT aRC) { rc = aRC; }
+
+        VDDestroy(hdd);
+    }
+    catch (HRESULT aRC) { rc = aRC; }
+
+    /* Everything is explicitly unlocked when the task exits,
+     * as the task destruction also destroys the source chain. */
+
+    /* Make sure the source chain is released early, otherwise it can
+     * lead to deadlocks with concurrent IAppliance activities. */
+    task.mpSourceMediumLockList->Clear();
+
+    return rc;
+}
+
 /* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

@@ -243 +243 @@
     HRESULT fixParentUuidOfChildren(const MediaList &childrenToReparent);
 
+    /**
+     * Used by IAppliance to export disk images.
+     *
+     * @param aFilename             Filename to create (UTF8).
+     * @param aFormat               Which medium format to use.
+     * @param aVariant              Which exact image format variant to use.
+     * @param aVDImageIOCallbacks   Pointer to the callback table for a
+     *                              VDINTERFACEIO interface. May be NULL.
+     * @param aVDImageIOUser        Opaque data for the callbacks.
+     * @param aProgress             Progress object to use.
+     * @return
+     */
+    HRESULT exportFile(const char *aFilename,
+                       ComObjPtr<MediumFormat> aFormat,
+                       MediumVariant_T aVariant,
+                       void *aVDImageIOCallbacks, void *aVDImageIOUser,
+                       ComObjPtr<Progress> aProgress);
+
     /** Returns a preferred format for a differencing hard disk. */
     Utf8Str getPreferredDiffFormat();
@@ -293 +311 @@
     class DeleteTask;
     class MergeTask;
+    class ExportTask;
     friend class Task;
     friend class CreateBaseTask;
@@ -302 +321 @@
     friend class DeleteTask;
     friend class MergeTask;
+    friend class ExportTask;
 
     HRESULT startThread(Medium::Task *pTask);
@@ -314 +334 @@
     HRESULT taskCompactHandler(Medium::CompactTask &task);
     HRESULT taskResizeHandler(Medium::ResizeTask &task);
+    HRESULT taskExportHandler(Medium::ExportTask &task);
 
     struct Data;            // opaque data struct, defined in MediumImpl.cpp