Changeset 37449 in vbox for trunk/src/VBox/Main

Timestamp:

Jun 14, 2011 4:34:16 PM (13 years ago)

Author:

vboxsync

Message:

Main;VBoxManage: more clone vm work

Location:

trunk/src/VBox/Main

Files:

• idl/VirtualBox.xidl (modified) (6 diffs)
• include/MachineImpl.h (modified) (2 diffs)
• include/SnapshotImpl.h (modified) (1 diff)
• src-server/MachineImpl.cpp (modified) (8 diffs)
• src-server/SnapshotImpl.cpp (modified) (1 diff)

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

@@ -3513 +3513 @@
   </interface>
 
+  <enum
+    name="CloneMode" extends="$unknown"
+    uuid="A7A159FE-5096-4B8D-8C3C-D033CB0B35A8"
+    >
+
+    <desc>
+    Clone mode, used with <link to="IMachine::cloneTo" />.
+    </desc>
+
+    <const name="MachineState"                 value="1">
+      <desc>Clone the state of the machine.</desc>
+    </const>
+    <const name="MachineAndChildStates"        value="2">
+      <desc>Clone the state of the machine and if this machine object has child snapshots the state of this childs.</desc>
+    </const>
+    <const name="AllStates"                    value="3">
+      <desc>Clone all states (including all snapshots) of the machine, regardless of the machine object used.</desc>
+    </const>
+
+  </enum>
+
 
   <interface
     name="IMachine" extends="$unknown"
-    uuid="84208466-c072-4e64-b993-c35c096cc837"
+    uuid="5A398458-266D-4DCD-9745-0886AEBD761B"
     wsmap="managed"
     >
@@ -5963 +5984 @@
         <desc>Target machine object.</desc>
       </param>
+      <param name="mode" type="CloneMode" dir="in">
+        <desc>Which states should be cloned.</desc>
+      </param>
       <param name="fullClone" type="boolean" dir="in">
         <desc>Selects whether a full or linked clone is created.</desc>
@@ -9129 +9153 @@
     <method name="waitForAsyncProgressCompletion">
       <desc>
-         Waits until the other task is completed (including all
-         sub-operations) and forward all changes from the other progress to
-         this progress. This means sub-operation number, description, percent
-         and so on.
-
-         You have to take care on setting up at least the same count on
-         sub-operations in this progress object like there are in the other
-         progress object.
-
-         If the other progress object supports cancel and this object gets any
-         cancel request (when here enabled as well), it will be forwarded to
-         the other progress object.
-
-         If there is an error in the other progress, this error isn't
-         automatically transfered to this progress object. So you have to
-         check any operation error within the other progress object, after
-         this method returns.
-      </desc>
-
-     <param name="pProgressAsync" type="IProgress" dir="in">
-       <desc>
-         The progress object of the asynchrony process.
-       </desc>
-     </param>
+          Waits until the other task is completed (including all
+          sub-operations) and forward all changes from the other progress to
+          this progress. This means sub-operation number, description, percent
+          and so on.
+          
+          You have to take care on setting up at least the same count on
+          sub-operations in this progress object like there are in the other
+          progress object. 
+
+          If the other progress object supports cancel and this object gets any
+          cancel request (when here enabled as well), it will be forwarded to
+          the other progress object.
+
+          If there is an error in the other progress, this error isn't
+          automatically transfered to this progress object. So you have to
+          check any operation error within the other progress object, after
+          this method returns.
+      </desc>
+
+      <param name="pProgressAsync" type="IProgress" dir="in">
+        <desc>
+          The progress object of the asynchrony process.
+        </desc>
+      </param>
     </method>
 
@@ -9178 +9202 @@
   <interface
     name="ISnapshot" extends="$unknown"
-    uuid="1a2d0551-58a4-4107-857e-ef414fc42ffc"
+    uuid="0472823b-c6e7-472a-8e9f-d732e86b8463"
     wsmap="managed"
     >
@@ -9325 +9349 @@
       </desc>
     </attribute>
+
+    <method name="getChildrenCount" const="yes">
+      <desc>
+        Returns the number of direct childrens of this snapshot.
+      </desc>
+      <param name="childrenCount" type="unsigned long" dir="return">
+        <desc>
+        </desc>
+      </param>
+    </method>
 
   </interface>
@@ -10805 +10839 @@
         medium which is being cloned. Even cloning to a child of the source
         medium is possible. Note that when cloning to an existing image, the
-        @a parent irgument is ignored.
+        @a parent argument is ignored.
 
         After the returned progress object reports that the operation is

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

@@ -529 +529 @@
     STDMETHOD(AttachHostPciDevice(LONG hostAddress, LONG desiredGuestAddress, BOOL tryToUnbind));
     STDMETHOD(DetachHostPciDevice(LONG hostAddress));
-    STDMETHOD(CloneTo(IMachine *aTarget, BOOL aFullClone, IProgress **aProgress));
+    STDMETHOD(CloneTo(IMachine *aTarget, CloneMode_T mode, BOOL aFullClone, IProgress **aProgress));
     // public methods only for internal purposes
 
@@ -841 +841 @@
 
     struct CloneVMTask;
+    HRESULT cloneCreateMachineList(const ComPtr<ISnapshot> &pSnapshot, RTCList< ComPtr<IMachine> > &machineList) const;
+    settings::Snapshot cloneFindSnapshot(settings::MachineConfigFile *pMCF, const settings::SnapshotsList &snl, const Guid &id) const;
+    void cloneUpdateStorageLists(settings::StorageControllersList &sc, const Bstr &bstrOldId, const Bstr &bstrNewId) const;
+    void cloneUpdateSnapshotStorageLists(settings::SnapshotsList &sl, const Bstr &bstrOldId, const Bstr &bstrNewId) const;
+
     static DECLCALLBACK(int) cloneVMThread(RTTHREAD Thread, void *pvUser);
     HRESULT cloneVMTaskWorker(CloneVMTask *pTask);

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

@@ -83 +83 @@
 
     // ISnapshot methods
+    STDMETHOD(GetChildrenCount)(ULONG* count);
 
     // public methods only for internal purposes

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

@@ -6077 +6077 @@
     ComObjPtr<Machine>          pSrcMachine;
     ComObjPtr<Machine>          pTrgMachine;
+    ComPtr<IMachine>            pOldMachineState;
     ComObjPtr<Progress>         pProgress;
-    bool                        fLink;
+    Guid                        snapshotId;
+    CloneMode_T                 mode;
+    bool                        fLinkDisks;
     typedef struct
     {
@@ -6084 +6087 @@
         uint64_t                uSize;
     }MediumTask;
-    typedef RTCList<MediumTask> MediumTaskChain;
+    typedef struct
+    {
+        RTCList<MediumTask>     chain;
+        bool                    fCreateDiffs;
+    }MediumTaskChain;
     RTCList<MediumTaskChain>    llMedias;
+    RTCList< std::pair<Utf8Str, Utf8Str> > llSaveStateFiles; /* Snapshot UUID -> File path */
 };
 
-STDMETHODIMP Machine::CloneTo(IMachine *pTarget, BOOL fFullClone, IProgress **pProgress)
+STDMETHODIMP Machine::CloneTo(IMachine *pTarget, CloneMode_T mode, BOOL fFullClone, IProgress **pProgress)
 {
     LogFlowFuncEnter();
@@ -6106 +6114 @@
     {
         pTask = new CloneVMTask;
-        pTask->pSrcMachine = this;
-        pTask->pTrgMachine = static_cast<Machine*>(pTarget);
-        pTask->fLink       = !fFullClone;
-
+        pTask->pSrcMachine   = this;
+        pTask->pTrgMachine   = static_cast<Machine*>(pTarget);
+        pTask->fLinkDisks    = !fFullClone;
+        pTask->mode          = mode;
+
+        /* Lock the target machine early (so nobody mess around with it in the meantime). */
         AutoWriteLock trgLock(pTask->pTrgMachine COMMA_LOCKVAL_SRC_POS);
 
+        if (pTask->pSrcMachine->isSnapshotMachine())
+            pTask->snapshotId  = static_cast<SnapshotMachine*>((Machine*)pTask->pSrcMachine)->getSnapshotId();
+
+        /* Add the current machine and all snapshot machines below this machine
+         * in a list for further processing. */
+        RTCList< ComPtr<IMachine> > machineList;
+
+        /* Include current state? */
+        if (   pTask->mode == CloneMode_MachineState
+            || pTask->mode == CloneMode_AllStates)
+            machineList.append(static_cast< ComPtr<IMachine> >(pTask->pSrcMachine));
+        /* Should be done a depth copy with all child snapshots? */
+        if (   pTask->mode == CloneMode_MachineAndChildStates
+            || pTask->mode == CloneMode_AllStates)
+        {
+            ULONG cSnapshots = 0;
+            rc = pTask->pSrcMachine->COMGETTER(SnapshotCount)(&cSnapshots);
+            if (FAILED(rc)) throw rc;
+            if (cSnapshots > 0)
+            {
+                Utf8Str id;
+                if (   pTask->mode == CloneMode_MachineAndChildStates
+                    && !pTask->snapshotId.isEmpty())
+                    id = pTask->snapshotId.toString();
+                ComPtr<ISnapshot> pSnapshot;
+                rc = pTask->pSrcMachine->FindSnapshot(Bstr(id).raw(), pSnapshot.asOutParam());
+                if (FAILED(rc)) throw rc;
+                rc = cloneCreateMachineList(pSnapshot, machineList);
+                if (FAILED(rc)) throw rc;
+                rc = pSnapshot->COMGETTER(Machine)(pTask->pOldMachineState.asOutParam());
+                if (FAILED(rc)) throw rc;
+            }
+        }
+
+        /* Go over every machine and walk over every attachment this machine has. */
         ULONG uCount       = 2; /* One init task and the machine creation. */
         ULONG uTotalWeight = 2; /* The init task and the machine creation is worth one. */
-        for (MediaData::AttachmentList::iterator it = mMediaData->mAttachments.begin();
-             it != mMediaData->mAttachments.end();
-             ++it)
-        {
-            /* Query some info of the source image. */
-            const ComObjPtr<MediumAttachment> &pAtt = *it;
-            DeviceType_T type;
-            rc = pAtt->COMGETTER(Type)(&type);
+        for (size_t i = 0; i < machineList.size(); ++i)
+        {
+            /* If this is the Snapshot Machine we want to clone, we need to
+             * create a new diff file for the new "current state". */
+            bool fCreateDiffs = false;
+            if (machineList.at(i) == pTask->pOldMachineState)
+                fCreateDiffs = true;
+            SafeIfaceArray<IMediumAttachment> sfaAttachments;
+            rc = machineList.at(i)->COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(sfaAttachments));
             if (FAILED(rc)) throw rc;
-
-            /* Only harddisk's are of interest. */
-            if (type != DeviceType_HardDisk)
-                continue;
-
-            /* Valid medium attached? */
-            ComPtr<IMedium> pSrcMedium;
-            rc = pAtt->COMGETTER(Medium)(pSrcMedium.asOutParam());
-            if (FAILED(rc)) throw rc;
-            if (pSrcMedium.isNull())
-                continue;
-
-            /* Build up a child->parent list of this attachment. (Note: we are
-             * not interested of any child's not attached to this VM. So this
-             * will not create a full copy of the base/child relationship.) */
-            Machine::CloneVMTask::MediumTaskChain mtc;
-            while(!pSrcMedium.isNull())
+            /* Add all attachments (and there parents) of the different
+             * machines to a worker list. */
+            for (size_t a = 0; a < sfaAttachments.size(); ++a)
             {
-                /* Refresh the state so that the file size get read. */
-                MediumState_T e;
-                rc = pSrcMedium->RefreshState(&e);
+                const ComPtr<IMediumAttachment> &pAtt = sfaAttachments[a];
+                DeviceType_T type;
+                rc = pAtt->COMGETTER(Type)(&type);
                 if (FAILED(rc)) throw rc;
-                LONG64 lSize;
-                rc = pSrcMedium->COMGETTER(Size)(&lSize);
+
+                /* Only harddisk's are of interest. */
+                if (type != DeviceType_HardDisk)
+                    continue;
+
+                /* Valid medium attached? */
+                ComPtr<IMedium> pSrcMedium;
+                rc = pAtt->COMGETTER(Medium)(pSrcMedium.asOutParam());
                 if (FAILED(rc)) throw rc;
-
-                /* Save the current medium, for later cloning. */
-                Machine::CloneVMTask::MediumTask mt;
-                mt.pMedium = pSrcMedium;
-                mt.uSize   = lSize;
-                mtc.append(mt);
-
-                /* Calculate progress data */
-                ++uCount;
-                uTotalWeight += lSize;
-
-                /* Query next parent. */
-                rc = pSrcMedium->COMGETTER(Parent)(pSrcMedium.asOutParam());
-                if (FAILED(rc)) throw rc;
-            };
-            pTask->llMedias.append(mtc);
+                if (pSrcMedium.isNull())
+                    continue;
+
+                /* Build up a child->parent list of this attachment. (Note: we are
+                 * not interested of any child's not attached to this VM. So this
+                 * will not create a full copy of the base/child relationship.) */
+                Machine::CloneVMTask::MediumTaskChain mtc;
+                mtc.fCreateDiffs = fCreateDiffs;
+                while(!pSrcMedium.isNull())
+                {
+                    /* Refresh the state so that the file size get read. */
+                    MediumState_T e;
+                    rc = pSrcMedium->RefreshState(&e);
+                    if (FAILED(rc)) throw rc;
+                    LONG64 lSize;
+                    rc = pSrcMedium->COMGETTER(Size)(&lSize);
+                    if (FAILED(rc)) throw rc;
+
+                    /* Save the current medium, for later cloning. */
+                    Machine::CloneVMTask::MediumTask mt;
+                    mt.pMedium = pSrcMedium;
+                    mt.uSize   = lSize;
+                    mtc.chain.append(mt);
+
+                    /* Calculate progress data */
+                    ++uCount;
+                    uTotalWeight += lSize;
+
+                    /* Query next parent. */
+                    rc = pSrcMedium->COMGETTER(Parent)(pSrcMedium.asOutParam());
+                    if (FAILED(rc)) throw rc;
+                };
+                pTask->llMedias.append(mtc);
+            }
+            /* Todo: If this machine has save state files, they have to be copied as well. */
+//            Bstr bstrSrcSaveStatePath;
+//            rc = machineList.at(i)->COMGETTER(StateFilePath)(bstrSrcSaveStatePath.asOutParam());
+//            if (FAILED(rc)) throw rc;
+//            if (!bstrSrcSaveStatePath.isEmpty())
+//                pTask->llSaveStates.append(bstrSrcSaveStatePath);
         }
 
@@ -6231 +6293 @@
 }
 
+HRESULT Machine::cloneCreateMachineList(const ComPtr<ISnapshot> &pSnapshot, RTCList< ComPtr<IMachine> > &machineList) const
+{
+    HRESULT rc = S_OK;
+    Bstr name;
+    rc = pSnapshot->COMGETTER(Name)(name.asOutParam());
+    if (FAILED(rc)) return rc;
+
+    ComPtr<IMachine> pMachine;
+    rc = pSnapshot->COMGETTER(Machine)(pMachine.asOutParam());
+    if (FAILED(rc)) return rc;
+    machineList.append(pMachine);
+
+    SafeIfaceArray<ISnapshot> sfaChilds;
+    rc = pSnapshot->COMGETTER(Children)(ComSafeArrayAsOutParam(sfaChilds));
+    if (FAILED(rc)) return rc;
+    for (size_t i = 0; i < sfaChilds.size(); ++i)
+    {
+        rc = cloneCreateMachineList(sfaChilds[i], machineList);
+        if (FAILED(rc)) return rc;
+    }
+
+    return rc;
+}
+
+settings::Snapshot Machine::cloneFindSnapshot(settings::MachineConfigFile *pMCF, const settings::SnapshotsList &snl, const Guid &id) const
+{
+    settings::SnapshotsList::const_iterator it;
+    for (it = snl.begin(); it != snl.end(); ++it)
+    {
+        if (it->uuid == id)
+            return *it;
+        else if (!it->llChildSnapshots.empty())
+            return cloneFindSnapshot(pMCF, it->llChildSnapshots, id);
+    }
+    return settings::Snapshot();
+}
+
+void Machine::cloneUpdateStorageLists(settings::StorageControllersList &sc, const Bstr &bstrOldId, const Bstr &bstrNewId) const
+{
+    settings::StorageControllersList::iterator it3;
+    for (it3 = sc.begin();
+         it3 != sc.end();
+         ++it3)
+    {
+        settings::AttachedDevicesList &llAttachments = it3->llAttachedDevices;
+        settings::AttachedDevicesList::iterator it4;
+        for (it4 = llAttachments.begin();
+             it4 != llAttachments.end();
+             ++it4)
+        {
+            if (   it4->deviceType == DeviceType_HardDisk
+                && it4->uuid == bstrOldId)
+            {
+                it4->uuid = bstrNewId;
+            }
+        }
+    }
+}
+
+void Machine::cloneUpdateSnapshotStorageLists(settings::SnapshotsList &sl, const Bstr &bstrOldId, const Bstr &bstrNewId) const
+{
+    settings::SnapshotsList::iterator it;
+    for (  it  = sl.begin();
+           it != sl.end();
+         ++it)
+    {
+        cloneUpdateStorageLists(it->storage.llStorageControllers, bstrOldId, bstrNewId);
+        if (!it->llChildSnapshots.empty())
+            cloneUpdateSnapshotStorageLists(it->llChildSnapshots, bstrOldId, bstrNewId);
+    }
+}
+
 /**
  * Task thread implementation for Machine::CloneTo(), called from Machine::cloneVMThread().
@@ -6271 +6405 @@
         /* Reset media registry. */
         pTrgMCF->mediaRegistry.llHardDisks.clear();
-        /* Reset all snapshots. */
-        pTrgMCF->llFirstSnapshot.clear();
-        pTrgMCF->uuidCurrentSnapshot.clear();
+        /* If we got a valid snapshot id, replace the hardware/storage section
+         * with the stuff from the snapshot. */
+        settings::Snapshot sn;
+        if (!pTask->snapshotId.isEmpty())
+            sn = cloneFindSnapshot(pTrgMCF, pTrgMCF->llFirstSnapshot, pTask->snapshotId);
+
+        if (pTask->mode == CloneMode_MachineState)
+        {
+            if (!sn.uuid.isEmpty())
+            {
+                pTrgMCF->hardwareMachine = sn.hardware;
+                pTrgMCF->storageMachine  = sn.storage;
+            }
+
+            /* Remove any hint on snapshots. */
+            pTrgMCF->llFirstSnapshot.clear();
+            pTrgMCF->uuidCurrentSnapshot.clear();
+        }else
+        if (   pTask->mode == CloneMode_MachineAndChildStates
+            && !sn.uuid.isEmpty())
+        {
+            /* Copy the snapshot data to the current machine. */
+            pTrgMCF->hardwareMachine = sn.hardware;
+            pTrgMCF->storageMachine  = sn.storage;
+
+            /* The snapshot will be the root one. */
+            pTrgMCF->uuidCurrentSnapshot = sn.uuid;
+            pTrgMCF->llFirstSnapshot.clear();
+            pTrgMCF->llFirstSnapshot.push_back(sn);
+        }
+
+        /* Reset the snapshot folder to 'Snapshots' within the target directory.
+         * Todo: Not sure if this is what we want. */
+        pTrgMCF->machineUserData.strSnapshotFolder = "Snapshots";
         pTrgMCF->strStateFile = "";
         /* Force writing of setting file. */
@@ -6281 +6446 @@
         pTrgMCF->uuid = pTask->pTrgMachine->mData->mUuid;
 
+        /* The absolute name of the snapshot folder. */
+        Utf8Str strTrgSnapshotFolder = Utf8StrFmt("%s%c%s%c", strTrgMachineFolder.c_str(), RTPATH_DELIMITER, pTrgMCF->machineUserData.strSnapshotFolder.c_str(), RTPATH_DELIMITER);
+
+        /* We need to create a map with the already created medias. This is
+         * necessary, cause different snapshots could have the same
+         * parents/parent chain. If a medium is in this map already, it isn't
+         * cloned a second time, but simply used. */
+        typedef std::map<Utf8Str, ComObjPtr<Medium> > TStrMediumMap;
+        typedef std::pair<Utf8Str, ComObjPtr<Medium> > TStrMediumPair;
+        TStrMediumMap map;
         for (size_t i = 0; i < pTask->llMedias.size(); ++i)
         {
             const Machine::CloneVMTask::MediumTaskChain &mtc = pTask->llMedias.at(i);
             ComObjPtr<Medium> pNewParent;
-            for (size_t a = mtc.size(); a > 0; --a)
+            for (size_t a = mtc.chain.size(); a > 0; --a)
             {
-                const Machine::CloneVMTask::MediumTask &mt = mtc.at(a - 1);
+                const Machine::CloneVMTask::MediumTask &mt = mtc.chain.at(a - 1);
                 ComPtr<IMedium> pMedium = mt.pMedium;
 
@@ -6297 +6472 @@
                 if (FAILED(rc)) throw rc;
 
-                ComPtr<IMediumFormat> pSrcFormat;
-                rc = pMedium->COMGETTER(MediumFormat)(pSrcFormat.asOutParam());
-                ULONG uSrcCaps = 0;
-                rc = pSrcFormat->COMGETTER(Capabilities)(&uSrcCaps);
+                Bstr bstrSrcId;
+                rc = pMedium->COMGETTER(Id)(bstrSrcId.asOutParam());
                 if (FAILED(rc)) throw rc;
 
-                Bstr bstrSrcFormat     = "VDI";
-                ULONG srcVar = MediumVariant_Standard;
-                /* Is the source file based? */
-                if ((uSrcCaps & MediumFormatCapabilities_File) == MediumFormatCapabilities_File)
+                /* Is a clone already there? */
+                TStrMediumMap::iterator it = map.find(Utf8Str(bstrSrcId));
+                if (it != map.end())
+                    pNewParent = it->second;
+                else
                 {
-                    /* Yes, just use the source format. Otherwise the defaults
-                     * will be used. */
-                    rc = pMedium->COMGETTER(Format)(bstrSrcFormat.asOutParam());
+                    ComPtr<IMediumFormat> pSrcFormat;
+                    rc = pMedium->COMGETTER(MediumFormat)(pSrcFormat.asOutParam());
+                    ULONG uSrcCaps = 0;
+                    rc = pSrcFormat->COMGETTER(Capabilities)(&uSrcCaps);
                     if (FAILED(rc)) throw rc;
-                    rc = pMedium->COMGETTER(Variant)(&srcVar);
+
+                    Bstr bstrSrcFormat = "VDI";
+                    ULONG srcVar = MediumVariant_Standard;
+                    /* Is the source file based? */
+                    if ((uSrcCaps & MediumFormatCapabilities_File) == MediumFormatCapabilities_File)
+                    {
+                        /* Yes, just use the source format. Otherwise the defaults
+                         * will be used. */
+                        rc = pMedium->COMGETTER(Format)(bstrSrcFormat.asOutParam());
+                        if (FAILED(rc)) throw rc;
+                        rc = pMedium->COMGETTER(Variant)(&srcVar);
+                        if (FAILED(rc)) throw rc;
+                    }
+
+                    /* Start creating the clone. */
+                    ComObjPtr<Medium> pTarget;
+                    rc = pTarget.createObject();
                     if (FAILED(rc)) throw rc;
+
+                    Utf8Str strFile = Utf8StrFmt("%s%c%lS", strTrgMachineFolder.c_str(), RTPATH_DELIMITER, bstrSrcName.raw());
+                    rc = pTarget->init(mParent,
+                                       Utf8Str(bstrSrcFormat),
+                                       strFile,
+                                       pTask->pTrgMachine->mData->mUuid,  /* media registry */
+                                       NULL                               /* llRegistriesThatNeedSaving */);
+                    if (FAILED(rc)) throw rc;
+
+                    /* Do the disk cloning. */
+                    ComPtr<IProgress> progress2;
+                    rc = pMedium->CloneTo(pTarget,
+                                          srcVar,
+                                          pNewParent,
+                                          progress2.asOutParam());
+                    if (FAILED(rc)) throw rc;
+
+                    /* Wait until the asynchrony process has finished. */
+                    srcLock.release();
+                    rc = pTask->pProgress->WaitForAsyncProgressCompletion(progress2);
+                    srcLock.acquire();
+                    if (FAILED(rc)) throw rc;
+
+                    /* Check the result of the asynchrony process. */
+                    LONG iRc;
+                    rc = progress2->COMGETTER(ResultCode)(&iRc);
+                    if (FAILED(rc)) throw rc;
+                    if (FAILED(iRc))
+                    {
+                        /* If the thread of the progress object has an error, then
+                         * retrieve the error info from there, or it'll be lost. */
+                        ProgressErrorInfo info(progress2);
+                        throw setError(iRc, Utf8Str(info.getText()).c_str());
+                    }
+
+                    map.insert(TStrMediumPair(Utf8Str(bstrSrcId), pTarget));
+
+                    /* Remember created medias. */
+                    newMedias.append(pTarget);
+                    /* This medium becomes the parent of the next medium in the
+                     * chain. */
+                    pNewParent = pTarget;
                 }
-
-                /* Start creating the clone. */
-                ComObjPtr<Medium> pTarget;
-                rc = pTarget.createObject();
+            }
+
+            /* Create diffs for the last image chain. */
+            if (mtc.fCreateDiffs)
+            {
+                Bstr bstrSrcId;
+                rc = pNewParent->COMGETTER(Id)(bstrSrcId.asOutParam());
                 if (FAILED(rc)) throw rc;
-
-                Utf8Str strFile = Utf8StrFmt("%s%c%lS", strTrgMachineFolder.c_str(), RTPATH_DELIMITER, bstrSrcName.raw());
-                rc = pTarget->init(mParent,
-                                   Utf8Str(bstrSrcFormat),
-                                   strFile,
-                                   pTask->pTrgMachine->mData->mUuid,  /* media registry */
-                                   NULL                               /* llRegistriesThatNeedSaving */);
+                GuidList *pllRegistriesThatNeedSaving;
+                ComObjPtr<Medium> diff;
+                diff.createObject();
+                rc = diff->init(mParent,
+                                pNewParent->getPreferredDiffFormat(),
+                                strTrgSnapshotFolder,
+                                pTask->pTrgMachine->mData->mUuid,
+                                NULL); // pllRegistriesThatNeedSaving
                 if (FAILED(rc)) throw rc;
-
-                /* Do the disk cloning. */
-                ComPtr<IProgress> progress2;
-                rc = pMedium->CloneTo(pTarget,
-                                      srcVar,
-                                      pNewParent,
-                                      progress2.asOutParam());
+                MediumLockList *pMediumLockList(new MediumLockList()); /* todo: deleteeeeeeeee */
+                rc = diff->createMediumLockList(true /* fFailIfInaccessible */,
+                                                true /* fMediumLockWrite */,
+                                                pNewParent,
+                                                *pMediumLockList);
                 if (FAILED(rc)) throw rc;
-
-                /* Wait until the asynchrony process has finished. */
-                srcLock.release();
-                rc = pTask->pProgress->WaitForAsyncProgressCompletion(progress2);
-                srcLock.acquire();
+                rc = pMediumLockList->Lock();
                 if (FAILED(rc)) throw rc;
-
-                /* Check the result of the asynchrony process. */
-                LONG iRc;
-                rc = progress2->COMGETTER(ResultCode)(&iRc);
+                rc = pNewParent->createDiffStorage(diff, MediumVariant_Standard,
+                                                   pMediumLockList,
+                                                   NULL /* aProgress */,
+                                                   true /* aWait */,
+                                                   NULL); // pllRegistriesThatNeedSaving
+                delete pMediumLockList;
                 if (FAILED(rc)) throw rc;
-                if (FAILED(iRc))
-                {
-                    /* If the thread of the progress object has an error, then
-                     * retrieve the error info from there, or it'll be lost. */
-                    ProgressErrorInfo info(progress2);
-                    throw setError(iRc, Utf8Str(info.getText()).c_str());
-                }
-                /* Remember created medias. */
-                newMedias.append(pTarget);
-                /* This medium becomes the parent of the next medium in the
-                 * chain. */
-                pNewParent = pTarget;
+                pNewParent = diff;
             }
-
             Bstr bstrSrcId;
-            rc = mtc.first().pMedium->COMGETTER(Id)(bstrSrcId.asOutParam());
+            rc = mtc.chain.first().pMedium->COMGETTER(Id)(bstrSrcId.asOutParam());
             if (FAILED(rc)) throw rc;
             Bstr bstrTrgId;
@@ -6369 +6590 @@
             /* We have to patch the configuration, so it contains the new
              * medium uuid instead of the old one. */
-            settings::StorageControllersList::iterator it3;
-            for (it3 = pTrgMCF->storageMachine.llStorageControllers.begin();
-                 it3 != pTrgMCF->storageMachine.llStorageControllers.end();
-                 ++it3)
+            cloneUpdateStorageLists(pTrgMCF->storageMachine.llStorageControllers, bstrSrcId, bstrTrgId);
+            cloneUpdateSnapshotStorageLists(pTrgMCF->llFirstSnapshot, bstrSrcId, bstrTrgId);
+        }
+        /* Todo: Clone all save state files. */
+//        for (size_t i = 0; i < pTask->llSaveStates.size(); ++i)
+//        {
+//            RTPrintf("save state: %s\n", pTask->llSaveStates.at(i).c_str());
+//            RTFileCopy(llSaveStates.at(i).c_str(),);
+//        }
+
+        if (false)
+//        if (!pTask->pOldMachineState.isNull())
+        {
+            SafeIfaceArray<IMediumAttachment> sfaAttachments;
+            rc = pTask->pOldMachineState->COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(sfaAttachments));
+            if (FAILED(rc)) throw rc;
+            for (size_t a = 0; a < sfaAttachments.size(); ++a)
             {
-                settings::AttachedDevicesList &llAttachments = it3->llAttachedDevices;
-                settings::AttachedDevicesList::iterator it4;
-                for (it4 = llAttachments.begin();
-                     it4 != llAttachments.end();
-                     ++it4)
-                {
-                    if (   it4->deviceType == DeviceType_HardDisk
-                        && it4->uuid == bstrSrcId)
-                        it4->uuid = bstrTrgId;
-                }
+                const ComPtr<IMediumAttachment> &pAtt = sfaAttachments[a];
+                DeviceType_T type;
+                rc = pAtt->COMGETTER(Type)(&type);
+                if (FAILED(rc)) throw rc;
+
+                /* Only harddisk's are of interest. */
+                if (type != DeviceType_HardDisk)
+                    continue;
+
+                /* Valid medium attached? */
+                ComPtr<IMedium> pSrcMedium;
+                rc = pAtt->COMGETTER(Medium)(pSrcMedium.asOutParam());
+                if (FAILED(rc)) throw rc;
+                if (pSrcMedium.isNull())
+                    continue;
+
+//                ComObjPtr<Medium> pMedium = static_cast<Medium*>((IMedium*)pSrcMedium);
+//                ComObjPtr<Medium> diff;
+//                diff.createObject();
+                // store this diff in the same registry as the parent
+//                Guid uuidRegistryParent;
+//                if (!medium->getFirstRegistryMachineId(uuidRegistryParent))
+//                {
+                    // parent image has no registry: this can happen if we're attaching a new immutable
+                    // image that has not yet been attached (medium then points to the base and we're
+                    // creating the diff image for the immutable, and the parent is not yet registered);
+                    // put the parent in the machine registry then
+//                    addMediumToRegistry(medium, llRegistriesThatNeedSaving, &uuidRegistryParent);
+//                }
+//                rc = diff->init(mParent,
+//                                pMedium->getPreferredDiffFormat(),
+//                                strFullSnapshotFolder.append(RTPATH_SLASH_STR),
+//                                uuidRegistryParent,
+//                                pllRegistriesThatNeedSaving);
+//                if (FAILED(rc)) throw rc;
+//
+//                rc = pMedium->createDiffStorage(diff, MediumVariant_Standard,
+//                                                pMediumLockList,
+//                                                NULL /* aProgress */,
+//                                                true /* aWait */,
+//                                                pllRegistriesThatNeedSaving);
             }
         }

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

@@ -446 +446 @@
     SafeIfaceArray<ISnapshot> collection(m->llChildren);
     collection.detachTo(ComSafeArrayOutArg(aChildren));
+
+    return S_OK;
+}
+
+STDMETHODIMP Snapshot::GetChildrenCount(ULONG* count)
+{
+    CheckComArgOutPointerValid(count);
+
+    *count = getChildrenCount();
 
     return S_OK;