1 | /* $Id: MachineImplCloneVM.cpp 98288 2023-01-24 15:32:43Z vboxsync $ */
|
---|
2 | /** @file
|
---|
3 | * Implementation of MachineCloneVM
|
---|
4 | */
|
---|
5 |
|
---|
6 | /*
|
---|
7 | * Copyright (C) 2011-2023 Oracle and/or its affiliates.
|
---|
8 | *
|
---|
9 | * This file is part of VirtualBox base platform packages, as
|
---|
10 | * available from https://www.virtualbox.org.
|
---|
11 | *
|
---|
12 | * This program is free software; you can redistribute it and/or
|
---|
13 | * modify it under the terms of the GNU General Public License
|
---|
14 | * as published by the Free Software Foundation, in version 3 of the
|
---|
15 | * License.
|
---|
16 | *
|
---|
17 | * This program is distributed in the hope that it will be useful, but
|
---|
18 | * WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
19 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
---|
20 | * General Public License for more details.
|
---|
21 | *
|
---|
22 | * You should have received a copy of the GNU General Public License
|
---|
23 | * along with this program; if not, see <https://www.gnu.org/licenses>.
|
---|
24 | *
|
---|
25 | * SPDX-License-Identifier: GPL-3.0-only
|
---|
26 | */
|
---|
27 |
|
---|
28 | #include <set>
|
---|
29 | #include <map>
|
---|
30 | #include "MachineImplCloneVM.h"
|
---|
31 |
|
---|
32 | #include "VirtualBoxImpl.h"
|
---|
33 | #include "MediumImpl.h"
|
---|
34 | #include "HostImpl.h"
|
---|
35 |
|
---|
36 | #include <iprt/path.h>
|
---|
37 | #include <iprt/dir.h>
|
---|
38 | #include <iprt/cpp/utils.h>
|
---|
39 | #ifdef DEBUG_poetzsch
|
---|
40 | # include <iprt/stream.h>
|
---|
41 | #endif
|
---|
42 |
|
---|
43 | #include <VBox/com/list.h>
|
---|
44 | #include <VBox/com/MultiResult.h>
|
---|
45 |
|
---|
46 | // typedefs
|
---|
47 | /////////////////////////////////////////////////////////////////////////////
|
---|
48 |
|
---|
49 | typedef struct
|
---|
50 | {
|
---|
51 | Utf8Str strBaseName;
|
---|
52 | ComPtr<IMedium> pMedium;
|
---|
53 | uint32_t uIdx;
|
---|
54 | ULONG uWeight;
|
---|
55 | } MEDIUMTASK;
|
---|
56 |
|
---|
57 | typedef struct
|
---|
58 | {
|
---|
59 | RTCList<MEDIUMTASK> chain;
|
---|
60 | DeviceType_T devType;
|
---|
61 | bool fCreateDiffs;
|
---|
62 | bool fAttachLinked;
|
---|
63 | } MEDIUMTASKCHAIN;
|
---|
64 |
|
---|
65 | typedef struct
|
---|
66 | {
|
---|
67 | Guid snapshotUuid;
|
---|
68 | Utf8Str strFile;
|
---|
69 | ULONG uWeight;
|
---|
70 | } FILECOPYTASK;
|
---|
71 |
|
---|
72 | // The private class
|
---|
73 | /////////////////////////////////////////////////////////////////////////////
|
---|
74 |
|
---|
75 | struct MachineCloneVMPrivate
|
---|
76 | {
|
---|
77 | MachineCloneVMPrivate(MachineCloneVM *a_q, ComObjPtr<Machine> &a_pSrcMachine, ComObjPtr<Machine> &a_pTrgMachine,
|
---|
78 | CloneMode_T a_mode, const RTCList<CloneOptions_T> &opts)
|
---|
79 | : q_ptr(a_q)
|
---|
80 | , p(a_pSrcMachine)
|
---|
81 | , pSrcMachine(a_pSrcMachine)
|
---|
82 | , pTrgMachine(a_pTrgMachine)
|
---|
83 | , mode(a_mode)
|
---|
84 | , options(opts)
|
---|
85 | {}
|
---|
86 |
|
---|
87 | DECLARE_TRANSLATE_METHODS(MachineCloneVMPrivate)
|
---|
88 |
|
---|
89 | /* Thread management */
|
---|
90 | int startWorker()
|
---|
91 | {
|
---|
92 | return RTThreadCreate(NULL,
|
---|
93 | MachineCloneVMPrivate::workerThread,
|
---|
94 | static_cast<void*>(this),
|
---|
95 | 0,
|
---|
96 | RTTHREADTYPE_MAIN_WORKER,
|
---|
97 | 0,
|
---|
98 | "MachineClone");
|
---|
99 | }
|
---|
100 |
|
---|
101 | static DECLCALLBACK(int) workerThread(RTTHREAD /* Thread */, void *pvUser)
|
---|
102 | {
|
---|
103 | MachineCloneVMPrivate *pTask = static_cast<MachineCloneVMPrivate*>(pvUser);
|
---|
104 | AssertReturn(pTask, VERR_INVALID_POINTER);
|
---|
105 |
|
---|
106 | HRESULT hrc = pTask->q_ptr->run();
|
---|
107 |
|
---|
108 | pTask->pProgress->i_notifyComplete(hrc);
|
---|
109 |
|
---|
110 | pTask->q_ptr->destroy();
|
---|
111 |
|
---|
112 | return VINF_SUCCESS;
|
---|
113 | }
|
---|
114 |
|
---|
115 | /* Private helper methods */
|
---|
116 |
|
---|
117 | /* MachineCloneVM::start helper: */
|
---|
118 | HRESULT createMachineList(const ComPtr<ISnapshot> &pSnapshot, RTCList< ComObjPtr<Machine> > &machineList) const;
|
---|
119 | inline void updateProgressStats(MEDIUMTASKCHAIN &mtc, bool fAttachLinked, ULONG &uCount, ULONG &uTotalWeight) const;
|
---|
120 | inline HRESULT addSaveState(const ComObjPtr<Machine> &machine, bool fAttachCurrent, ULONG &uCount, ULONG &uTotalWeight);
|
---|
121 | inline HRESULT addNVRAM(const ComObjPtr<Machine> &machine, bool fAttachCurrent, ULONG &uCount, ULONG &uTotalWeight);
|
---|
122 | inline HRESULT queryBaseName(const ComPtr<IMedium> &pMedium, Utf8Str &strBaseName) const;
|
---|
123 | HRESULT queryMediasForMachineState(const RTCList<ComObjPtr<Machine> > &machineList,
|
---|
124 | bool fAttachLinked, ULONG &uCount, ULONG &uTotalWeight);
|
---|
125 | HRESULT queryMediasForMachineAndChildStates(const RTCList<ComObjPtr<Machine> > &machineList,
|
---|
126 | bool fAttachLinked, ULONG &uCount, ULONG &uTotalWeight);
|
---|
127 | HRESULT queryMediasForAllStates(const RTCList<ComObjPtr<Machine> > &machineList, bool fAttachLinked, ULONG &uCount,
|
---|
128 | ULONG &uTotalWeight);
|
---|
129 |
|
---|
130 | /* MachineCloneVM::run helper: */
|
---|
131 | bool findSnapshot(const settings::SnapshotsList &snl, const Guid &id, settings::Snapshot &sn) const;
|
---|
132 | void updateMACAddresses(settings::NetworkAdaptersList &nwl) const;
|
---|
133 | void updateMACAddresses(settings::SnapshotsList &sl) const;
|
---|
134 | void updateStorageLists(settings::StorageControllersList &sc, const Bstr &bstrOldId, const Bstr &bstrNewId) const;
|
---|
135 | void updateSnapshotStorageLists(settings::SnapshotsList &sl, const Bstr &bstrOldId, const Bstr &bstrNewId) const;
|
---|
136 | void updateSaveStateFile(settings::SnapshotsList &snl, const Guid &id, const Utf8Str &strFile) const;
|
---|
137 | void updateNVRAMFile(settings::SnapshotsList &snl, const Guid &id, const Utf8Str &strFile) const;
|
---|
138 | HRESULT createDifferencingMedium(const ComObjPtr<Machine> &pMachine, const ComObjPtr<Medium> &pParent,
|
---|
139 | const Utf8Str &strSnapshotFolder, RTCList<ComObjPtr<Medium> > &newMedia,
|
---|
140 | ComObjPtr<Medium> *ppDiff) const;
|
---|
141 | static DECLCALLBACK(int) copyFileProgress(unsigned uPercentage, void *pvUser);
|
---|
142 | static void updateSnapshotHardwareUUIDs(settings::SnapshotsList &snapshot_list, const Guid &id);
|
---|
143 |
|
---|
144 | /* Private q and parent pointer */
|
---|
145 | MachineCloneVM *q_ptr;
|
---|
146 | ComObjPtr<Machine> p;
|
---|
147 |
|
---|
148 | /* Private helper members */
|
---|
149 | ComObjPtr<Machine> pSrcMachine;
|
---|
150 | ComObjPtr<Machine> pTrgMachine;
|
---|
151 | ComPtr<IMachine> pOldMachineState;
|
---|
152 | ComObjPtr<Progress> pProgress;
|
---|
153 | Guid snapshotId;
|
---|
154 | CloneMode_T mode;
|
---|
155 | RTCList<CloneOptions_T> options;
|
---|
156 | RTCList<MEDIUMTASKCHAIN> llMedias;
|
---|
157 | RTCList<FILECOPYTASK> llSaveStateFiles; /* Snapshot UUID -> File path */
|
---|
158 | RTCList<FILECOPYTASK> llNVRAMFiles; /* Snapshot UUID -> File path */
|
---|
159 | };
|
---|
160 |
|
---|
161 | HRESULT MachineCloneVMPrivate::createMachineList(const ComPtr<ISnapshot> &pSnapshot,
|
---|
162 | RTCList< ComObjPtr<Machine> > &machineList) const
|
---|
163 | {
|
---|
164 | Bstr name;
|
---|
165 | HRESULT hrc = pSnapshot->COMGETTER(Name)(name.asOutParam());
|
---|
166 | if (FAILED(hrc)) return hrc;
|
---|
167 |
|
---|
168 | ComPtr<IMachine> pMachine;
|
---|
169 | hrc = pSnapshot->COMGETTER(Machine)(pMachine.asOutParam());
|
---|
170 | if (FAILED(hrc)) return hrc;
|
---|
171 | machineList.append((Machine*)(IMachine*)pMachine);
|
---|
172 |
|
---|
173 | SafeIfaceArray<ISnapshot> sfaChilds;
|
---|
174 | hrc = pSnapshot->COMGETTER(Children)(ComSafeArrayAsOutParam(sfaChilds));
|
---|
175 | if (FAILED(hrc)) return hrc;
|
---|
176 | for (size_t i = 0; i < sfaChilds.size(); ++i)
|
---|
177 | {
|
---|
178 | hrc = createMachineList(sfaChilds[i], machineList);
|
---|
179 | if (FAILED(hrc)) return hrc;
|
---|
180 | }
|
---|
181 |
|
---|
182 | return hrc;
|
---|
183 | }
|
---|
184 |
|
---|
185 | void MachineCloneVMPrivate::updateProgressStats(MEDIUMTASKCHAIN &mtc, bool fAttachLinked,
|
---|
186 | ULONG &uCount, ULONG &uTotalWeight) const
|
---|
187 | {
|
---|
188 | if (fAttachLinked)
|
---|
189 | {
|
---|
190 | /* Implicit diff creation as part of attach is a pretty cheap
|
---|
191 | * operation, and does only need one operation per attachment. */
|
---|
192 | ++uCount;
|
---|
193 | uTotalWeight += 1; /* 1MB per attachment */
|
---|
194 | }
|
---|
195 | else
|
---|
196 | {
|
---|
197 | /* Currently the copying of diff images involves reading at least
|
---|
198 | * the biggest parent in the previous chain. So even if the new
|
---|
199 | * diff image is small in size, it could need some time to create
|
---|
200 | * it. Adding the biggest size in the chain should balance this a
|
---|
201 | * little bit more, i.e. the weight is the sum of the data which
|
---|
202 | * needs to be read and written. */
|
---|
203 | ULONG uMaxWeight = 0;
|
---|
204 | for (size_t e = mtc.chain.size(); e > 0; --e)
|
---|
205 | {
|
---|
206 | MEDIUMTASK &mt = mtc.chain.at(e - 1);
|
---|
207 | mt.uWeight += uMaxWeight;
|
---|
208 |
|
---|
209 | /* Calculate progress data */
|
---|
210 | ++uCount;
|
---|
211 | uTotalWeight += mt.uWeight;
|
---|
212 |
|
---|
213 | /* Save the max size for better weighting of diff image
|
---|
214 | * creation. */
|
---|
215 | uMaxWeight = RT_MAX(uMaxWeight, mt.uWeight);
|
---|
216 | }
|
---|
217 | }
|
---|
218 | }
|
---|
219 |
|
---|
220 | HRESULT MachineCloneVMPrivate::addSaveState(const ComObjPtr<Machine> &machine, bool fAttachCurrent, ULONG &uCount, ULONG &uTotalWeight)
|
---|
221 | {
|
---|
222 | Bstr bstrSrcSaveStatePath;
|
---|
223 | HRESULT hrc = machine->COMGETTER(StateFilePath)(bstrSrcSaveStatePath.asOutParam());
|
---|
224 | if (FAILED(hrc)) return hrc;
|
---|
225 | if (!bstrSrcSaveStatePath.isEmpty())
|
---|
226 | {
|
---|
227 | FILECOPYTASK fct;
|
---|
228 | if (fAttachCurrent)
|
---|
229 | {
|
---|
230 | /* Make this saved state part of "current state" of the target
|
---|
231 | * machine, whether it is part of a snapshot or not. */
|
---|
232 | fct.snapshotUuid.clear();
|
---|
233 | }
|
---|
234 | else
|
---|
235 | fct.snapshotUuid = machine->i_getSnapshotId();
|
---|
236 | fct.strFile = bstrSrcSaveStatePath;
|
---|
237 | uint64_t cbSize;
|
---|
238 | int vrc = RTFileQuerySizeByPath(fct.strFile.c_str(), &cbSize);
|
---|
239 | if (RT_FAILURE(vrc))
|
---|
240 | return p->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Could not query file size of '%s' (%Rrc)"),
|
---|
241 | fct.strFile.c_str(), vrc);
|
---|
242 | /* same rule as above: count both the data which needs to
|
---|
243 | * be read and written */
|
---|
244 | fct.uWeight = (ULONG)(2 * (cbSize + _1M - 1) / _1M);
|
---|
245 | llSaveStateFiles.append(fct);
|
---|
246 | ++uCount;
|
---|
247 | uTotalWeight += fct.uWeight;
|
---|
248 | }
|
---|
249 | return S_OK;
|
---|
250 | }
|
---|
251 |
|
---|
252 | HRESULT MachineCloneVMPrivate::addNVRAM(const ComObjPtr<Machine> &machine, bool fAttachCurrent, ULONG &uCount, ULONG &uTotalWeight)
|
---|
253 | {
|
---|
254 | Bstr bstrSrcNVRAMPath;
|
---|
255 | ComPtr<INvramStore> pNvramStore;
|
---|
256 | HRESULT hrc = machine->COMGETTER(NonVolatileStore)(pNvramStore.asOutParam());
|
---|
257 | if (FAILED(hrc)) return hrc;
|
---|
258 | hrc = pNvramStore->COMGETTER(NonVolatileStorageFile)(bstrSrcNVRAMPath.asOutParam());
|
---|
259 | if (FAILED(hrc)) return hrc;
|
---|
260 | if (!bstrSrcNVRAMPath.isEmpty())
|
---|
261 | {
|
---|
262 | FILECOPYTASK fct;
|
---|
263 | if (fAttachCurrent)
|
---|
264 | {
|
---|
265 | /* Make this saved state part of "current state" of the target
|
---|
266 | * machine, whether it is part of a snapshot or not. */
|
---|
267 | fct.snapshotUuid.clear();
|
---|
268 | }
|
---|
269 | else
|
---|
270 | fct.snapshotUuid = machine->i_getSnapshotId();
|
---|
271 | fct.strFile = bstrSrcNVRAMPath;
|
---|
272 | if (!RTFileExists(fct.strFile.c_str()))
|
---|
273 | return S_OK;
|
---|
274 | uint64_t cbSize;
|
---|
275 | int vrc = RTFileQuerySizeByPath(fct.strFile.c_str(), &cbSize);
|
---|
276 | if (RT_FAILURE(vrc))
|
---|
277 | return p->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Could not query file size of '%s' (%Rrc)"),
|
---|
278 | fct.strFile.c_str(), vrc);
|
---|
279 | /* same rule as above: count both the data which needs to
|
---|
280 | * be read and written */
|
---|
281 | fct.uWeight = (ULONG)(2 * (cbSize + _1M - 1) / _1M);
|
---|
282 | llNVRAMFiles.append(fct);
|
---|
283 | ++uCount;
|
---|
284 | uTotalWeight += fct.uWeight;
|
---|
285 | }
|
---|
286 | return S_OK;
|
---|
287 | }
|
---|
288 |
|
---|
289 | HRESULT MachineCloneVMPrivate::queryBaseName(const ComPtr<IMedium> &pMedium, Utf8Str &strBaseName) const
|
---|
290 | {
|
---|
291 | ComPtr<IMedium> pBaseMedium;
|
---|
292 | HRESULT hrc = pMedium->COMGETTER(Base)(pBaseMedium.asOutParam());
|
---|
293 | if (FAILED(hrc)) return hrc;
|
---|
294 | Bstr bstrBaseName;
|
---|
295 | hrc = pBaseMedium->COMGETTER(Name)(bstrBaseName.asOutParam());
|
---|
296 | if (FAILED(hrc)) return hrc;
|
---|
297 | strBaseName = bstrBaseName;
|
---|
298 | return hrc;
|
---|
299 | }
|
---|
300 |
|
---|
301 | HRESULT MachineCloneVMPrivate::queryMediasForMachineState(const RTCList<ComObjPtr<Machine> > &machineList,
|
---|
302 | bool fAttachLinked, ULONG &uCount, ULONG &uTotalWeight)
|
---|
303 | {
|
---|
304 | /* This mode is pretty straightforward. We didn't need to know about any
|
---|
305 | * parent/children relationship and therefore simply adding all directly
|
---|
306 | * attached images of the source VM as cloning targets. The IMedium code
|
---|
307 | * take than care to merge any (possibly) existing parents into the new
|
---|
308 | * image. */
|
---|
309 | HRESULT hrc = S_OK;
|
---|
310 | for (size_t i = 0; i < machineList.size(); ++i)
|
---|
311 | {
|
---|
312 | const ComObjPtr<Machine> &machine = machineList.at(i);
|
---|
313 | /* If this is the Snapshot Machine we want to clone, we need to
|
---|
314 | * create a new diff file for the new "current state". */
|
---|
315 | const bool fCreateDiffs = (machine == pOldMachineState);
|
---|
316 | /* Add all attachments of the different machines to a worker list. */
|
---|
317 | SafeIfaceArray<IMediumAttachment> sfaAttachments;
|
---|
318 | hrc = machine->COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(sfaAttachments));
|
---|
319 | if (FAILED(hrc)) return hrc;
|
---|
320 | for (size_t a = 0; a < sfaAttachments.size(); ++a)
|
---|
321 | {
|
---|
322 | const ComPtr<IMediumAttachment> &pAtt = sfaAttachments[a];
|
---|
323 | DeviceType_T type;
|
---|
324 | hrc = pAtt->COMGETTER(Type)(&type);
|
---|
325 | if (FAILED(hrc)) return hrc;
|
---|
326 |
|
---|
327 | /* Only harddisks and floppies are of interest. */
|
---|
328 | if ( type != DeviceType_HardDisk
|
---|
329 | && type != DeviceType_Floppy)
|
---|
330 | continue;
|
---|
331 |
|
---|
332 | /* Valid medium attached? */
|
---|
333 | ComPtr<IMedium> pSrcMedium;
|
---|
334 | hrc = pAtt->COMGETTER(Medium)(pSrcMedium.asOutParam());
|
---|
335 | if (FAILED(hrc)) return hrc;
|
---|
336 |
|
---|
337 | if (pSrcMedium.isNull())
|
---|
338 | continue;
|
---|
339 |
|
---|
340 | /* Create the medium task chain. In this case it will always
|
---|
341 | * contain one image only. */
|
---|
342 | MEDIUMTASKCHAIN mtc;
|
---|
343 | mtc.devType = type;
|
---|
344 | mtc.fCreateDiffs = fCreateDiffs;
|
---|
345 | mtc.fAttachLinked = fAttachLinked;
|
---|
346 |
|
---|
347 | /* Refresh the state so that the file size get read. */
|
---|
348 | MediumState_T e;
|
---|
349 | hrc = pSrcMedium->RefreshState(&e);
|
---|
350 | if (FAILED(hrc)) return hrc;
|
---|
351 | LONG64 lSize;
|
---|
352 | hrc = pSrcMedium->COMGETTER(Size)(&lSize);
|
---|
353 | if (FAILED(hrc)) return hrc;
|
---|
354 |
|
---|
355 | MEDIUMTASK mt;
|
---|
356 | mt.uIdx = UINT32_MAX; /* No read/write optimization possible. */
|
---|
357 |
|
---|
358 | /* Save the base name. */
|
---|
359 | hrc = queryBaseName(pSrcMedium, mt.strBaseName);
|
---|
360 | if (FAILED(hrc)) return hrc;
|
---|
361 |
|
---|
362 | /* Save the current medium, for later cloning. */
|
---|
363 | mt.pMedium = pSrcMedium;
|
---|
364 | if (fAttachLinked)
|
---|
365 | mt.uWeight = 0; /* dummy */
|
---|
366 | else
|
---|
367 | mt.uWeight = (ULONG)((lSize + _1M - 1) / _1M);
|
---|
368 | mtc.chain.append(mt);
|
---|
369 |
|
---|
370 | /* Update the progress info. */
|
---|
371 | updateProgressStats(mtc, fAttachLinked, uCount, uTotalWeight);
|
---|
372 | /* Append the list of images which have to be cloned. */
|
---|
373 | llMedias.append(mtc);
|
---|
374 | }
|
---|
375 | /* Add the save state file of this machine if there is one. */
|
---|
376 | hrc = addSaveState(machine, true /*fAttachCurrent*/, uCount, uTotalWeight);
|
---|
377 | if (FAILED(hrc)) return hrc;
|
---|
378 | /* Add the NVRAM file of this machine if there is one. */
|
---|
379 | hrc = addNVRAM(machine, true /*fAttachCurrent*/, uCount, uTotalWeight);
|
---|
380 | if (FAILED(hrc)) return hrc;
|
---|
381 | }
|
---|
382 |
|
---|
383 | return hrc;
|
---|
384 | }
|
---|
385 |
|
---|
386 | HRESULT MachineCloneVMPrivate::queryMediasForMachineAndChildStates(const RTCList<ComObjPtr<Machine> > &machineList,
|
---|
387 | bool fAttachLinked, ULONG &uCount, ULONG &uTotalWeight)
|
---|
388 | {
|
---|
389 | /* This is basically a three step approach. First select all medias
|
---|
390 | * directly or indirectly involved in the clone. Second create a histogram
|
---|
391 | * of the usage of all that medias. Third select the medias which are
|
---|
392 | * directly attached or have more than one directly/indirectly used child
|
---|
393 | * in the new clone. Step one and two are done in the first loop.
|
---|
394 | *
|
---|
395 | * Example of the histogram counts after going through 3 attachments from
|
---|
396 | * bottom to top:
|
---|
397 | *
|
---|
398 | * 3
|
---|
399 | * |
|
---|
400 | * -> 3
|
---|
401 | * / \
|
---|
402 | * 2 1 <-
|
---|
403 | * /
|
---|
404 | * -> 2
|
---|
405 | * / \
|
---|
406 | * -> 1 1
|
---|
407 | * \
|
---|
408 | * 1 <-
|
---|
409 | *
|
---|
410 | * Whenever the histogram count is changing compared to the previous one we
|
---|
411 | * need to include that image in the cloning step (Marked with <-). If we
|
---|
412 | * start at zero even the directly attached images are automatically
|
---|
413 | * included.
|
---|
414 | *
|
---|
415 | * Note: This still leads to media chains which can have the same medium
|
---|
416 | * included. This case is handled in "run" and therefore not critical, but
|
---|
417 | * it leads to wrong progress infos which isn't nice. */
|
---|
418 |
|
---|
419 | Assert(!fAttachLinked);
|
---|
420 | HRESULT hrc = S_OK;
|
---|
421 | std::map<ComPtr<IMedium>, uint32_t> mediaHist; /* Our usage histogram for the medias */
|
---|
422 | for (size_t i = 0; i < machineList.size(); ++i)
|
---|
423 | {
|
---|
424 | const ComObjPtr<Machine> &machine = machineList.at(i);
|
---|
425 | /* If this is the Snapshot Machine we want to clone, we need to
|
---|
426 | * create a new diff file for the new "current state". */
|
---|
427 | const bool fCreateDiffs = (machine == pOldMachineState);
|
---|
428 | /* Add all attachments (and their parents) of the different
|
---|
429 | * machines to a worker list. */
|
---|
430 | SafeIfaceArray<IMediumAttachment> sfaAttachments;
|
---|
431 | hrc = machine->COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(sfaAttachments));
|
---|
432 | if (FAILED(hrc)) return hrc;
|
---|
433 | for (size_t a = 0; a < sfaAttachments.size(); ++a)
|
---|
434 | {
|
---|
435 | const ComPtr<IMediumAttachment> &pAtt = sfaAttachments[a];
|
---|
436 | DeviceType_T type;
|
---|
437 | hrc = pAtt->COMGETTER(Type)(&type);
|
---|
438 | if (FAILED(hrc)) return hrc;
|
---|
439 |
|
---|
440 | /* Only harddisks and floppies are of interest. */
|
---|
441 | if ( type != DeviceType_HardDisk
|
---|
442 | && type != DeviceType_Floppy)
|
---|
443 | continue;
|
---|
444 |
|
---|
445 | /* Valid medium attached? */
|
---|
446 | ComPtr<IMedium> pSrcMedium;
|
---|
447 | hrc = pAtt->COMGETTER(Medium)(pSrcMedium.asOutParam());
|
---|
448 | if (FAILED(hrc)) return hrc;
|
---|
449 |
|
---|
450 | if (pSrcMedium.isNull())
|
---|
451 | continue;
|
---|
452 |
|
---|
453 | MEDIUMTASKCHAIN mtc;
|
---|
454 | mtc.devType = type;
|
---|
455 | mtc.fCreateDiffs = fCreateDiffs;
|
---|
456 | mtc.fAttachLinked = fAttachLinked;
|
---|
457 |
|
---|
458 | while (!pSrcMedium.isNull())
|
---|
459 | {
|
---|
460 | /* Build a histogram of used medias and the parent chain. */
|
---|
461 | ++mediaHist[pSrcMedium];
|
---|
462 |
|
---|
463 | /* Refresh the state so that the file size get read. */
|
---|
464 | MediumState_T e;
|
---|
465 | hrc = pSrcMedium->RefreshState(&e);
|
---|
466 | if (FAILED(hrc)) return hrc;
|
---|
467 | LONG64 lSize;
|
---|
468 | hrc = pSrcMedium->COMGETTER(Size)(&lSize);
|
---|
469 | if (FAILED(hrc)) return hrc;
|
---|
470 |
|
---|
471 | MEDIUMTASK mt;
|
---|
472 | mt.uIdx = UINT32_MAX;
|
---|
473 | mt.pMedium = pSrcMedium;
|
---|
474 | mt.uWeight = (ULONG)((lSize + _1M - 1) / _1M);
|
---|
475 | mtc.chain.append(mt);
|
---|
476 |
|
---|
477 | /* Query next parent. */
|
---|
478 | hrc = pSrcMedium->COMGETTER(Parent)(pSrcMedium.asOutParam());
|
---|
479 | if (FAILED(hrc)) return hrc;
|
---|
480 | }
|
---|
481 |
|
---|
482 | llMedias.append(mtc);
|
---|
483 | }
|
---|
484 | /* Add the save state file of this machine if there is one. */
|
---|
485 | hrc = addSaveState(machine, false /*fAttachCurrent*/, uCount, uTotalWeight);
|
---|
486 | if (FAILED(hrc)) return hrc;
|
---|
487 | /* Add the NVRAM file of this machine if there is one. */
|
---|
488 | hrc = addNVRAM(machine, false /*fAttachCurrent*/, uCount, uTotalWeight);
|
---|
489 | if (FAILED(hrc)) return hrc;
|
---|
490 | /* If this is the newly created current state, make sure that the
|
---|
491 | * saved state and NVRAM is also attached to it. */
|
---|
492 | if (fCreateDiffs)
|
---|
493 | {
|
---|
494 | hrc = addSaveState(machine, true /*fAttachCurrent*/, uCount, uTotalWeight);
|
---|
495 | if (FAILED(hrc)) return hrc;
|
---|
496 | hrc = addNVRAM(machine, true /*fAttachCurrent*/, uCount, uTotalWeight);
|
---|
497 | if (FAILED(hrc)) return hrc;
|
---|
498 | }
|
---|
499 | }
|
---|
500 | /* Build up the index list of the image chain. Unfortunately we can't do
|
---|
501 | * that in the previous loop, cause there we go from child -> parent and
|
---|
502 | * didn't know how many are between. */
|
---|
503 | for (size_t i = 0; i < llMedias.size(); ++i)
|
---|
504 | {
|
---|
505 | uint32_t uIdx = 0;
|
---|
506 | MEDIUMTASKCHAIN &mtc = llMedias.at(i);
|
---|
507 | for (size_t a = mtc.chain.size(); a > 0; --a)
|
---|
508 | mtc.chain[a - 1].uIdx = uIdx++;
|
---|
509 | }
|
---|
510 | #ifdef DEBUG_poetzsch
|
---|
511 | /* Print the histogram */
|
---|
512 | std::map<ComPtr<IMedium>, uint32_t>::iterator it;
|
---|
513 | for (it = mediaHist.begin(); it != mediaHist.end(); ++it)
|
---|
514 | {
|
---|
515 | Bstr bstrSrcName;
|
---|
516 | hrc = (*it).first->COMGETTER(Name)(bstrSrcName.asOutParam());
|
---|
517 | if (FAILED(hrc)) return hrc;
|
---|
518 | RTPrintf("%ls: %d\n", bstrSrcName.raw(), (*it).second);
|
---|
519 | }
|
---|
520 | #endif
|
---|
521 | /* Go over every medium in the list and check if it either a directly
|
---|
522 | * attached disk or has more than one children. If so it needs to be
|
---|
523 | * replicated. Also we have to make sure that any direct or indirect
|
---|
524 | * children knows of the new parent (which doesn't necessarily mean it
|
---|
525 | * is a direct children in the source chain). */
|
---|
526 | for (size_t i = 0; i < llMedias.size(); ++i)
|
---|
527 | {
|
---|
528 | MEDIUMTASKCHAIN &mtc = llMedias.at(i);
|
---|
529 | RTCList<MEDIUMTASK> newChain;
|
---|
530 | uint32_t used = 0;
|
---|
531 | for (size_t a = 0; a < mtc.chain.size(); ++a)
|
---|
532 | {
|
---|
533 | const MEDIUMTASK &mt = mtc.chain.at(a);
|
---|
534 | uint32_t hist = mediaHist[mt.pMedium];
|
---|
535 | #ifdef DEBUG_poetzsch
|
---|
536 | Bstr bstrSrcName;
|
---|
537 | hrc = mt.pMedium->COMGETTER(Name)(bstrSrcName.asOutParam());
|
---|
538 | if (FAILED(hrc)) return hrc;
|
---|
539 | RTPrintf("%ls: %d (%d)\n", bstrSrcName.raw(), hist, used);
|
---|
540 | #endif
|
---|
541 | /* Check if there is a "step" in the histogram when going the chain
|
---|
542 | * upwards. If so, we need this image, cause there is another branch
|
---|
543 | * from here in the cloned VM. */
|
---|
544 | if (hist > used)
|
---|
545 | {
|
---|
546 | newChain.append(mt);
|
---|
547 | used = hist;
|
---|
548 | }
|
---|
549 | }
|
---|
550 | /* Make sure we always using the old base name as new base name, even
|
---|
551 | * if the base is a differencing image in the source VM (with the UUID
|
---|
552 | * as name). */
|
---|
553 | hrc = queryBaseName(newChain.last().pMedium, newChain.last().strBaseName);
|
---|
554 | if (FAILED(hrc)) return hrc;
|
---|
555 | /* Update the old medium chain with the updated one. */
|
---|
556 | mtc.chain = newChain;
|
---|
557 | /* Update the progress info. */
|
---|
558 | updateProgressStats(mtc, fAttachLinked, uCount, uTotalWeight);
|
---|
559 | }
|
---|
560 |
|
---|
561 | return hrc;
|
---|
562 | }
|
---|
563 |
|
---|
564 | HRESULT MachineCloneVMPrivate::queryMediasForAllStates(const RTCList<ComObjPtr<Machine> > &machineList,
|
---|
565 | bool fAttachLinked, ULONG &uCount, ULONG &uTotalWeight)
|
---|
566 | {
|
---|
567 | /* In this case we create a exact copy of the original VM. This means just
|
---|
568 | * adding all directly and indirectly attached disk images to the worker
|
---|
569 | * list. */
|
---|
570 | Assert(!fAttachLinked);
|
---|
571 | HRESULT hrc = S_OK;
|
---|
572 | for (size_t i = 0; i < machineList.size(); ++i)
|
---|
573 | {
|
---|
574 | const ComObjPtr<Machine> &machine = machineList.at(i);
|
---|
575 | /* If this is the Snapshot Machine we want to clone, we need to
|
---|
576 | * create a new diff file for the new "current state". */
|
---|
577 | const bool fCreateDiffs = (machine == pOldMachineState);
|
---|
578 | /* Add all attachments (and their parents) of the different
|
---|
579 | * machines to a worker list. */
|
---|
580 | SafeIfaceArray<IMediumAttachment> sfaAttachments;
|
---|
581 | hrc = machine->COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(sfaAttachments));
|
---|
582 | if (FAILED(hrc)) return hrc;
|
---|
583 | for (size_t a = 0; a < sfaAttachments.size(); ++a)
|
---|
584 | {
|
---|
585 | const ComPtr<IMediumAttachment> &pAtt = sfaAttachments[a];
|
---|
586 | DeviceType_T type;
|
---|
587 | hrc = pAtt->COMGETTER(Type)(&type);
|
---|
588 | if (FAILED(hrc)) return hrc;
|
---|
589 |
|
---|
590 | /* Only harddisks and floppies are of interest. */
|
---|
591 | if ( type != DeviceType_HardDisk
|
---|
592 | && type != DeviceType_Floppy)
|
---|
593 | continue;
|
---|
594 |
|
---|
595 | /* Valid medium attached? */
|
---|
596 | ComPtr<IMedium> pSrcMedium;
|
---|
597 | hrc = pAtt->COMGETTER(Medium)(pSrcMedium.asOutParam());
|
---|
598 | if (FAILED(hrc)) return hrc;
|
---|
599 |
|
---|
600 | if (pSrcMedium.isNull())
|
---|
601 | continue;
|
---|
602 |
|
---|
603 | /* Build up a child->parent list of this attachment. (Note: we are
|
---|
604 | * not interested of any child's not attached to this VM. So this
|
---|
605 | * will not create a full copy of the base/child relationship.) */
|
---|
606 | MEDIUMTASKCHAIN mtc;
|
---|
607 | mtc.devType = type;
|
---|
608 | mtc.fCreateDiffs = fCreateDiffs;
|
---|
609 | mtc.fAttachLinked = fAttachLinked;
|
---|
610 |
|
---|
611 | while (!pSrcMedium.isNull())
|
---|
612 | {
|
---|
613 | /* Refresh the state so that the file size get read. */
|
---|
614 | MediumState_T e;
|
---|
615 | hrc = pSrcMedium->RefreshState(&e);
|
---|
616 | if (FAILED(hrc)) return hrc;
|
---|
617 | LONG64 lSize;
|
---|
618 | hrc = pSrcMedium->COMGETTER(Size)(&lSize);
|
---|
619 | if (FAILED(hrc)) return hrc;
|
---|
620 |
|
---|
621 | /* Save the current medium, for later cloning. */
|
---|
622 | MEDIUMTASK mt;
|
---|
623 | mt.uIdx = UINT32_MAX;
|
---|
624 | mt.pMedium = pSrcMedium;
|
---|
625 | mt.uWeight = (ULONG)((lSize + _1M - 1) / _1M);
|
---|
626 | mtc.chain.append(mt);
|
---|
627 |
|
---|
628 | /* Query next parent. */
|
---|
629 | hrc = pSrcMedium->COMGETTER(Parent)(pSrcMedium.asOutParam());
|
---|
630 | if (FAILED(hrc)) return hrc;
|
---|
631 | }
|
---|
632 | /* Update the progress info. */
|
---|
633 | updateProgressStats(mtc, fAttachLinked, uCount, uTotalWeight);
|
---|
634 | /* Append the list of images which have to be cloned. */
|
---|
635 | llMedias.append(mtc);
|
---|
636 | }
|
---|
637 | /* Add the save state file of this machine if there is one. */
|
---|
638 | hrc = addSaveState(machine, false /*fAttachCurrent*/, uCount, uTotalWeight);
|
---|
639 | if (FAILED(hrc)) return hrc;
|
---|
640 | /* Add the NVRAM file of this machine if there is one. */
|
---|
641 | hrc = addNVRAM(machine, false /*fAttachCurrent*/, uCount, uTotalWeight);
|
---|
642 | if (FAILED(hrc)) return hrc;
|
---|
643 | /* If this is the newly created current state, make sure that the
|
---|
644 | * saved state is also attached to it. */
|
---|
645 | if (fCreateDiffs)
|
---|
646 | {
|
---|
647 | hrc = addSaveState(machine, true /*fAttachCurrent*/, uCount, uTotalWeight);
|
---|
648 | if (FAILED(hrc)) return hrc;
|
---|
649 | hrc = addNVRAM(machine, true /*fAttachCurrent*/, uCount, uTotalWeight);
|
---|
650 | if (FAILED(hrc)) return hrc;
|
---|
651 | }
|
---|
652 | }
|
---|
653 | /* Build up the index list of the image chain. Unfortunately we can't do
|
---|
654 | * that in the previous loop, cause there we go from child -> parent and
|
---|
655 | * didn't know how many are between. */
|
---|
656 | for (size_t i = 0; i < llMedias.size(); ++i)
|
---|
657 | {
|
---|
658 | uint32_t uIdx = 0;
|
---|
659 | MEDIUMTASKCHAIN &mtc = llMedias.at(i);
|
---|
660 | for (size_t a = mtc.chain.size(); a > 0; --a)
|
---|
661 | mtc.chain[a - 1].uIdx = uIdx++;
|
---|
662 | }
|
---|
663 |
|
---|
664 | return hrc;
|
---|
665 | }
|
---|
666 |
|
---|
667 | bool MachineCloneVMPrivate::findSnapshot(const settings::SnapshotsList &snl, const Guid &id, settings::Snapshot &sn) const
|
---|
668 | {
|
---|
669 | settings::SnapshotsList::const_iterator it;
|
---|
670 | for (it = snl.begin(); it != snl.end(); ++it)
|
---|
671 | {
|
---|
672 | if (it->uuid == id)
|
---|
673 | {
|
---|
674 | sn = (*it);
|
---|
675 | return true;
|
---|
676 | }
|
---|
677 | else if (!it->llChildSnapshots.empty())
|
---|
678 | {
|
---|
679 | if (findSnapshot(it->llChildSnapshots, id, sn))
|
---|
680 | return true;
|
---|
681 | }
|
---|
682 | }
|
---|
683 | return false;
|
---|
684 | }
|
---|
685 |
|
---|
686 | void MachineCloneVMPrivate::updateMACAddresses(settings::NetworkAdaptersList &nwl) const
|
---|
687 | {
|
---|
688 | const bool fNotNAT = options.contains(CloneOptions_KeepNATMACs);
|
---|
689 | settings::NetworkAdaptersList::iterator it;
|
---|
690 | for (it = nwl.begin(); it != nwl.end(); ++it)
|
---|
691 | {
|
---|
692 | if ( fNotNAT
|
---|
693 | && it->mode == NetworkAttachmentType_NAT)
|
---|
694 | continue;
|
---|
695 | Host::i_generateMACAddress(it->strMACAddress);
|
---|
696 | }
|
---|
697 | }
|
---|
698 |
|
---|
699 | void MachineCloneVMPrivate::updateMACAddresses(settings::SnapshotsList &sl) const
|
---|
700 | {
|
---|
701 | settings::SnapshotsList::iterator it;
|
---|
702 | for (it = sl.begin(); it != sl.end(); ++it)
|
---|
703 | {
|
---|
704 | updateMACAddresses(it->hardware.llNetworkAdapters);
|
---|
705 | if (!it->llChildSnapshots.empty())
|
---|
706 | updateMACAddresses(it->llChildSnapshots);
|
---|
707 | }
|
---|
708 | }
|
---|
709 |
|
---|
710 | void MachineCloneVMPrivate::updateStorageLists(settings::StorageControllersList &sc,
|
---|
711 | const Bstr &bstrOldId, const Bstr &bstrNewId) const
|
---|
712 | {
|
---|
713 | settings::StorageControllersList::iterator it3;
|
---|
714 | for (it3 = sc.begin();
|
---|
715 | it3 != sc.end();
|
---|
716 | ++it3)
|
---|
717 | {
|
---|
718 | settings::AttachedDevicesList &llAttachments = it3->llAttachedDevices;
|
---|
719 | settings::AttachedDevicesList::iterator it4;
|
---|
720 | for (it4 = llAttachments.begin();
|
---|
721 | it4 != llAttachments.end();
|
---|
722 | ++it4)
|
---|
723 | {
|
---|
724 | if ( ( it4->deviceType == DeviceType_HardDisk
|
---|
725 | || it4->deviceType == DeviceType_Floppy)
|
---|
726 | && it4->uuid == bstrOldId)
|
---|
727 | {
|
---|
728 | it4->uuid = bstrNewId;
|
---|
729 | }
|
---|
730 | }
|
---|
731 | }
|
---|
732 | }
|
---|
733 |
|
---|
734 | void MachineCloneVMPrivate::updateSnapshotStorageLists(settings::SnapshotsList &sl, const Bstr &bstrOldId,
|
---|
735 | const Bstr &bstrNewId) const
|
---|
736 | {
|
---|
737 | settings::SnapshotsList::iterator it;
|
---|
738 | for ( it = sl.begin();
|
---|
739 | it != sl.end();
|
---|
740 | ++it)
|
---|
741 | {
|
---|
742 | updateStorageLists(it->hardware.storage.llStorageControllers, bstrOldId, bstrNewId);
|
---|
743 | if (!it->llChildSnapshots.empty())
|
---|
744 | updateSnapshotStorageLists(it->llChildSnapshots, bstrOldId, bstrNewId);
|
---|
745 | }
|
---|
746 | }
|
---|
747 |
|
---|
748 | void MachineCloneVMPrivate::updateSaveStateFile(settings::SnapshotsList &snl, const Guid &id, const Utf8Str &strFile) const
|
---|
749 | {
|
---|
750 | settings::SnapshotsList::iterator it;
|
---|
751 | for (it = snl.begin(); it != snl.end(); ++it)
|
---|
752 | {
|
---|
753 | if (it->uuid == id)
|
---|
754 | it->strStateFile = strFile;
|
---|
755 | else if (!it->llChildSnapshots.empty())
|
---|
756 | updateSaveStateFile(it->llChildSnapshots, id, strFile);
|
---|
757 | }
|
---|
758 | }
|
---|
759 |
|
---|
760 | void MachineCloneVMPrivate::updateNVRAMFile(settings::SnapshotsList &snl, const Guid &id, const Utf8Str &strFile) const
|
---|
761 | {
|
---|
762 | settings::SnapshotsList::iterator it;
|
---|
763 | for (it = snl.begin(); it != snl.end(); ++it)
|
---|
764 | {
|
---|
765 | if (it->uuid == id)
|
---|
766 | it->hardware.nvramSettings.strNvramPath = strFile;
|
---|
767 | else if (!it->llChildSnapshots.empty())
|
---|
768 | updateNVRAMFile(it->llChildSnapshots, id, strFile);
|
---|
769 | }
|
---|
770 | }
|
---|
771 |
|
---|
772 | HRESULT MachineCloneVMPrivate::createDifferencingMedium(const ComObjPtr<Machine> &pMachine, const ComObjPtr<Medium> &pParent,
|
---|
773 | const Utf8Str &strSnapshotFolder, RTCList<ComObjPtr<Medium> > &newMedia,
|
---|
774 | ComObjPtr<Medium> *ppDiff) const
|
---|
775 | {
|
---|
776 | HRESULT hrc = S_OK;
|
---|
777 | try
|
---|
778 | {
|
---|
779 | // check validity of parent object
|
---|
780 | {
|
---|
781 | AutoReadLock alock(pParent COMMA_LOCKVAL_SRC_POS);
|
---|
782 | Bstr bstrSrcId;
|
---|
783 | hrc = pParent->COMGETTER(Id)(bstrSrcId.asOutParam());
|
---|
784 | if (FAILED(hrc)) throw hrc;
|
---|
785 | }
|
---|
786 | ComObjPtr<Medium> diff;
|
---|
787 | diff.createObject();
|
---|
788 | hrc = diff->init(p->i_getVirtualBox(),
|
---|
789 | pParent->i_getPreferredDiffFormat(),
|
---|
790 | Utf8StrFmt("%s%c", strSnapshotFolder.c_str(), RTPATH_DELIMITER),
|
---|
791 | Guid::Empty /* empty media registry */,
|
---|
792 | DeviceType_HardDisk);
|
---|
793 | if (FAILED(hrc)) throw hrc;
|
---|
794 |
|
---|
795 | MediumLockList *pMediumLockList(new MediumLockList());
|
---|
796 | hrc = diff->i_createMediumLockList(true /* fFailIfInaccessible */,
|
---|
797 | diff /* pToLockWrite */,
|
---|
798 | false /* fMediumLockWriteAll */,
|
---|
799 | pParent,
|
---|
800 | *pMediumLockList);
|
---|
801 | if (FAILED(hrc)) throw hrc;
|
---|
802 | hrc = pMediumLockList->Lock();
|
---|
803 | if (FAILED(hrc)) throw hrc;
|
---|
804 |
|
---|
805 | /* this already registers the new diff image */
|
---|
806 | hrc = pParent->i_createDiffStorage(diff,
|
---|
807 | pParent->i_getPreferredDiffVariant(),
|
---|
808 | pMediumLockList,
|
---|
809 | NULL /* aProgress */,
|
---|
810 | true /* aWait */,
|
---|
811 | false /* aNotify */);
|
---|
812 | delete pMediumLockList;
|
---|
813 | if (FAILED(hrc)) throw hrc;
|
---|
814 | /* Remember created medium. */
|
---|
815 | newMedia.append(diff);
|
---|
816 | *ppDiff = diff;
|
---|
817 | }
|
---|
818 | catch (HRESULT rcXcpt)
|
---|
819 | {
|
---|
820 | hrc = rcXcpt;
|
---|
821 | }
|
---|
822 | catch (...)
|
---|
823 | {
|
---|
824 | hrc = VirtualBoxBase::handleUnexpectedExceptions(pMachine, RT_SRC_POS);
|
---|
825 | }
|
---|
826 |
|
---|
827 | return hrc;
|
---|
828 | }
|
---|
829 |
|
---|
830 | /* static */
|
---|
831 | DECLCALLBACK(int) MachineCloneVMPrivate::copyFileProgress(unsigned uPercentage, void *pvUser)
|
---|
832 | {
|
---|
833 | ComObjPtr<Progress> pProgress = *static_cast< ComObjPtr<Progress>* >(pvUser);
|
---|
834 |
|
---|
835 | BOOL fCanceled = false;
|
---|
836 | HRESULT hrc = pProgress->COMGETTER(Canceled)(&fCanceled);
|
---|
837 | if (FAILED(hrc)) return VERR_GENERAL_FAILURE;
|
---|
838 | /* If canceled by the user tell it to the copy operation. */
|
---|
839 | if (fCanceled) return VERR_CANCELLED;
|
---|
840 | /* Set the new process. */
|
---|
841 | hrc = pProgress->SetCurrentOperationProgress(uPercentage);
|
---|
842 | if (FAILED(hrc)) return VERR_GENERAL_FAILURE;
|
---|
843 |
|
---|
844 | return VINF_SUCCESS;
|
---|
845 | }
|
---|
846 |
|
---|
847 | void MachineCloneVMPrivate::updateSnapshotHardwareUUIDs(settings::SnapshotsList &snapshot_list, const Guid &id)
|
---|
848 | {
|
---|
849 | for (settings::SnapshotsList::iterator snapshot_it = snapshot_list.begin();
|
---|
850 | snapshot_it != snapshot_list.end();
|
---|
851 | ++snapshot_it)
|
---|
852 | {
|
---|
853 | if (!snapshot_it->hardware.uuid.isValid() || snapshot_it->hardware.uuid.isZero())
|
---|
854 | snapshot_it->hardware.uuid = id;
|
---|
855 | updateSnapshotHardwareUUIDs(snapshot_it->llChildSnapshots, id);
|
---|
856 | }
|
---|
857 | }
|
---|
858 |
|
---|
859 | // The public class
|
---|
860 | /////////////////////////////////////////////////////////////////////////////
|
---|
861 |
|
---|
862 | MachineCloneVM::MachineCloneVM(ComObjPtr<Machine> pSrcMachine, ComObjPtr<Machine> pTrgMachine, CloneMode_T mode,
|
---|
863 | const RTCList<CloneOptions_T> &opts) :
|
---|
864 | d_ptr(new MachineCloneVMPrivate(this, pSrcMachine, pTrgMachine, mode, opts))
|
---|
865 | {
|
---|
866 | }
|
---|
867 |
|
---|
868 | MachineCloneVM::~MachineCloneVM()
|
---|
869 | {
|
---|
870 | delete d_ptr;
|
---|
871 | }
|
---|
872 |
|
---|
873 | HRESULT MachineCloneVM::start(IProgress **pProgress)
|
---|
874 | {
|
---|
875 | DPTR(MachineCloneVM);
|
---|
876 | ComObjPtr<Machine> &p = d->p;
|
---|
877 |
|
---|
878 | HRESULT hrc;
|
---|
879 | try
|
---|
880 | {
|
---|
881 | /** @todo r=klaus this code cannot deal with someone crazy specifying
|
---|
882 | * IMachine corresponding to a mutable machine as d->pSrcMachine */
|
---|
883 | if (d->pSrcMachine->i_isSessionMachine())
|
---|
884 | throw p->setError(E_INVALIDARG, tr("The source machine is mutable"));
|
---|
885 |
|
---|
886 | /* Handle the special case that someone is requesting a _full_ clone
|
---|
887 | * with all snapshots (and the current state), but uses a snapshot
|
---|
888 | * machine (and not the current one) as source machine. In this case we
|
---|
889 | * just replace the source (snapshot) machine with the current machine. */
|
---|
890 | if ( d->mode == CloneMode_AllStates
|
---|
891 | && d->pSrcMachine->i_isSnapshotMachine())
|
---|
892 | {
|
---|
893 | Bstr bstrSrcMachineId;
|
---|
894 | hrc = d->pSrcMachine->COMGETTER(Id)(bstrSrcMachineId.asOutParam());
|
---|
895 | if (FAILED(hrc)) throw hrc;
|
---|
896 | ComPtr<IMachine> newSrcMachine;
|
---|
897 | hrc = d->pSrcMachine->i_getVirtualBox()->FindMachine(bstrSrcMachineId.raw(), newSrcMachine.asOutParam());
|
---|
898 | if (FAILED(hrc)) throw hrc;
|
---|
899 | d->pSrcMachine = (Machine*)(IMachine*)newSrcMachine;
|
---|
900 | }
|
---|
901 | bool fSubtreeIncludesCurrent = false;
|
---|
902 | ComObjPtr<Machine> pCurrState;
|
---|
903 | if (d->mode == CloneMode_MachineAndChildStates)
|
---|
904 | {
|
---|
905 | if (d->pSrcMachine->i_isSnapshotMachine())
|
---|
906 | {
|
---|
907 | /* find machine object for current snapshot of current state */
|
---|
908 | Bstr bstrSrcMachineId;
|
---|
909 | hrc = d->pSrcMachine->COMGETTER(Id)(bstrSrcMachineId.asOutParam());
|
---|
910 | if (FAILED(hrc)) throw hrc;
|
---|
911 | ComPtr<IMachine> pCurr;
|
---|
912 | hrc = d->pSrcMachine->i_getVirtualBox()->FindMachine(bstrSrcMachineId.raw(), pCurr.asOutParam());
|
---|
913 | if (FAILED(hrc)) throw hrc;
|
---|
914 | if (pCurr.isNull())
|
---|
915 | throw p->setError(VBOX_E_OBJECT_NOT_FOUND);
|
---|
916 | pCurrState = (Machine *)(IMachine *)pCurr;
|
---|
917 | ComPtr<ISnapshot> pSnapshot;
|
---|
918 | hrc = pCurrState->COMGETTER(CurrentSnapshot)(pSnapshot.asOutParam());
|
---|
919 | if (FAILED(hrc)) throw hrc;
|
---|
920 | if (pSnapshot.isNull())
|
---|
921 | throw p->setError(VBOX_E_OBJECT_NOT_FOUND);
|
---|
922 | ComPtr<IMachine> pCurrSnapMachine;
|
---|
923 | hrc = pSnapshot->COMGETTER(Machine)(pCurrSnapMachine.asOutParam());
|
---|
924 | if (FAILED(hrc)) throw hrc;
|
---|
925 | if (pCurrSnapMachine.isNull())
|
---|
926 | throw p->setError(VBOX_E_OBJECT_NOT_FOUND);
|
---|
927 |
|
---|
928 | /* now check if there is a parent chain which leads to the
|
---|
929 | * snapshot machine defining the subtree. */
|
---|
930 | while (!pSnapshot.isNull())
|
---|
931 | {
|
---|
932 | ComPtr<IMachine> pSnapMachine;
|
---|
933 | hrc = pSnapshot->COMGETTER(Machine)(pSnapMachine.asOutParam());
|
---|
934 | if (FAILED(hrc)) throw hrc;
|
---|
935 | if (pSnapMachine.isNull())
|
---|
936 | throw p->setError(VBOX_E_OBJECT_NOT_FOUND);
|
---|
937 | if (pSnapMachine == d->pSrcMachine)
|
---|
938 | {
|
---|
939 | fSubtreeIncludesCurrent = true;
|
---|
940 | break;
|
---|
941 | }
|
---|
942 | hrc = pSnapshot->COMGETTER(Parent)(pSnapshot.asOutParam());
|
---|
943 | if (FAILED(hrc)) throw hrc;
|
---|
944 | }
|
---|
945 | }
|
---|
946 | else
|
---|
947 | {
|
---|
948 | /* If the subtree is only the Current State simply use the
|
---|
949 | * 'machine' case for cloning. It is easier to understand. */
|
---|
950 | d->mode = CloneMode_MachineState;
|
---|
951 | }
|
---|
952 | }
|
---|
953 |
|
---|
954 | /* Lock the target machine early (so nobody mess around with it in the meantime). */
|
---|
955 | AutoWriteLock trgLock(d->pTrgMachine COMMA_LOCKVAL_SRC_POS);
|
---|
956 |
|
---|
957 | if (d->pSrcMachine->i_isSnapshotMachine())
|
---|
958 | d->snapshotId = d->pSrcMachine->i_getSnapshotId();
|
---|
959 |
|
---|
960 | /* Add the current machine and all snapshot machines below this machine
|
---|
961 | * in a list for further processing. */
|
---|
962 | RTCList< ComObjPtr<Machine> > machineList;
|
---|
963 |
|
---|
964 | /* Include current state? */
|
---|
965 | if ( d->mode == CloneMode_MachineState
|
---|
966 | || d->mode == CloneMode_AllStates)
|
---|
967 | machineList.append(d->pSrcMachine);
|
---|
968 | /* Should be done a depth copy with all child snapshots? */
|
---|
969 | if ( d->mode == CloneMode_MachineAndChildStates
|
---|
970 | || d->mode == CloneMode_AllStates)
|
---|
971 | {
|
---|
972 | ULONG cSnapshots = 0;
|
---|
973 | hrc = d->pSrcMachine->COMGETTER(SnapshotCount)(&cSnapshots);
|
---|
974 | if (FAILED(hrc)) throw hrc;
|
---|
975 | if (cSnapshots > 0)
|
---|
976 | {
|
---|
977 | Utf8Str id;
|
---|
978 | if (d->mode == CloneMode_MachineAndChildStates)
|
---|
979 | id = d->snapshotId.toString();
|
---|
980 | ComPtr<ISnapshot> pSnapshot;
|
---|
981 | hrc = d->pSrcMachine->FindSnapshot(Bstr(id).raw(), pSnapshot.asOutParam());
|
---|
982 | if (FAILED(hrc)) throw hrc;
|
---|
983 | hrc = d->createMachineList(pSnapshot, machineList);
|
---|
984 | if (FAILED(hrc)) throw hrc;
|
---|
985 | if (d->mode == CloneMode_MachineAndChildStates)
|
---|
986 | {
|
---|
987 | if (fSubtreeIncludesCurrent)
|
---|
988 | {
|
---|
989 | if (pCurrState.isNull())
|
---|
990 | throw p->setError(VBOX_E_OBJECT_NOT_FOUND);
|
---|
991 | machineList.append(pCurrState);
|
---|
992 | }
|
---|
993 | else
|
---|
994 | {
|
---|
995 | hrc = pSnapshot->COMGETTER(Machine)(d->pOldMachineState.asOutParam());
|
---|
996 | if (FAILED(hrc)) throw hrc;
|
---|
997 | }
|
---|
998 | }
|
---|
999 | }
|
---|
1000 | }
|
---|
1001 |
|
---|
1002 | /* We have different approaches for getting the medias which needs to
|
---|
1003 | * be replicated based on the clone mode the user requested (this is
|
---|
1004 | * mostly about the full clone mode).
|
---|
1005 | * MachineState:
|
---|
1006 | * - Only the images which are directly attached to an source VM will
|
---|
1007 | * be cloned. Any parent disks in the original chain will be merged
|
---|
1008 | * into the final cloned disk.
|
---|
1009 | * MachineAndChildStates:
|
---|
1010 | * - In this case we search for images which have more than one
|
---|
1011 | * children in the cloned VM or are directly attached to the new VM.
|
---|
1012 | * All others will be merged into the remaining images which are
|
---|
1013 | * cloned.
|
---|
1014 | * This case is the most complicated one and needs several iterations
|
---|
1015 | * to make sure we are only cloning images which are really
|
---|
1016 | * necessary.
|
---|
1017 | * AllStates:
|
---|
1018 | * - All disks which are directly or indirectly attached to the
|
---|
1019 | * original VM are cloned.
|
---|
1020 | *
|
---|
1021 | * Note: If you change something generic in one of the methods its
|
---|
1022 | * likely that it need to be changed in the others as well! */
|
---|
1023 | ULONG uCount = 2; /* One init task and the machine creation. */
|
---|
1024 | ULONG uTotalWeight = 2; /* The init task and the machine creation is worth one. */
|
---|
1025 | bool fAttachLinked = d->options.contains(CloneOptions_Link); /* Linked clones requested? */
|
---|
1026 | switch (d->mode)
|
---|
1027 | {
|
---|
1028 | case CloneMode_MachineState:
|
---|
1029 | d->queryMediasForMachineState(machineList, fAttachLinked, uCount, uTotalWeight);
|
---|
1030 | break;
|
---|
1031 | case CloneMode_MachineAndChildStates:
|
---|
1032 | d->queryMediasForMachineAndChildStates(machineList, fAttachLinked, uCount, uTotalWeight);
|
---|
1033 | break;
|
---|
1034 | case CloneMode_AllStates:
|
---|
1035 | d->queryMediasForAllStates(machineList, fAttachLinked, uCount, uTotalWeight);
|
---|
1036 | break;
|
---|
1037 | #ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
|
---|
1038 | case CloneMode_32BitHack: /* (compiler warnings) */
|
---|
1039 | AssertFailedBreak();
|
---|
1040 | #endif
|
---|
1041 | }
|
---|
1042 |
|
---|
1043 | /* Now create the progress project, so the user knows whats going on. */
|
---|
1044 | hrc = d->pProgress.createObject();
|
---|
1045 | if (FAILED(hrc)) throw hrc;
|
---|
1046 | hrc = d->pProgress->init(p->i_getVirtualBox(),
|
---|
1047 | static_cast<IMachine*>(d->pSrcMachine) /* aInitiator */,
|
---|
1048 | Bstr(tr("Cloning Machine")).raw(),
|
---|
1049 | true /* fCancellable */,
|
---|
1050 | uCount,
|
---|
1051 | uTotalWeight,
|
---|
1052 | Bstr(tr("Initialize Cloning")).raw(),
|
---|
1053 | 1);
|
---|
1054 | if (FAILED(hrc)) throw hrc;
|
---|
1055 |
|
---|
1056 | int vrc = d->startWorker();
|
---|
1057 |
|
---|
1058 | if (RT_FAILURE(vrc))
|
---|
1059 | p->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Could not create machine clone thread (%Rrc)"), vrc);
|
---|
1060 | }
|
---|
1061 | catch (HRESULT hrcXcpt)
|
---|
1062 | {
|
---|
1063 | hrc = hrcXcpt;
|
---|
1064 | }
|
---|
1065 |
|
---|
1066 | if (SUCCEEDED(hrc))
|
---|
1067 | d->pProgress.queryInterfaceTo(pProgress);
|
---|
1068 |
|
---|
1069 | return hrc;
|
---|
1070 | }
|
---|
1071 |
|
---|
1072 | HRESULT MachineCloneVM::run()
|
---|
1073 | {
|
---|
1074 | DPTR(MachineCloneVM);
|
---|
1075 | ComObjPtr<Machine> &p = d->p;
|
---|
1076 |
|
---|
1077 | AutoCaller autoCaller(p);
|
---|
1078 | if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
|
---|
1079 |
|
---|
1080 | AutoReadLock srcLock(p COMMA_LOCKVAL_SRC_POS);
|
---|
1081 | AutoWriteLock trgLock(d->pTrgMachine COMMA_LOCKVAL_SRC_POS);
|
---|
1082 |
|
---|
1083 | HRESULT hrc = S_OK;
|
---|
1084 |
|
---|
1085 | /*
|
---|
1086 | * Todo:
|
---|
1087 | * - What about log files?
|
---|
1088 | */
|
---|
1089 |
|
---|
1090 | /* Where should all the media go? */
|
---|
1091 | Utf8Str strTrgSnapshotFolder;
|
---|
1092 | Utf8Str strTrgMachineFolder = d->pTrgMachine->i_getSettingsFileFull();
|
---|
1093 | strTrgMachineFolder.stripFilename();
|
---|
1094 |
|
---|
1095 | RTCList<ComObjPtr<Medium> > newMedia; /* All created images */
|
---|
1096 | RTCList<Utf8Str> newFiles; /* All extra created files (save states, ...) */
|
---|
1097 | std::set<ComObjPtr<Medium> > pMediumsForNotify;
|
---|
1098 | std::map<Guid, DeviceType_T> uIdsForNotify;
|
---|
1099 | try
|
---|
1100 | {
|
---|
1101 | /* Copy all the configuration from this machine to an empty
|
---|
1102 | * configuration dataset. */
|
---|
1103 | settings::MachineConfigFile trgMCF = *d->pSrcMachine->mData->pMachineConfigFile;
|
---|
1104 |
|
---|
1105 | /* keep source machine hardware UUID if enabled*/
|
---|
1106 | if (d->options.contains(CloneOptions_KeepHwUUIDs))
|
---|
1107 | {
|
---|
1108 | /* because HW UUIDs must be preserved including snapshots by the option,
|
---|
1109 | * just fill zero UUIDs with corresponding machine UUID before any snapshot
|
---|
1110 | * processing will take place, while all uuids are from source machine */
|
---|
1111 | if (!trgMCF.hardwareMachine.uuid.isValid() || trgMCF.hardwareMachine.uuid.isZero())
|
---|
1112 | trgMCF.hardwareMachine.uuid = trgMCF.uuid;
|
---|
1113 |
|
---|
1114 | MachineCloneVMPrivate::updateSnapshotHardwareUUIDs(trgMCF.llFirstSnapshot, trgMCF.uuid);
|
---|
1115 | }
|
---|
1116 |
|
---|
1117 |
|
---|
1118 | /* Reset media registry. */
|
---|
1119 | trgMCF.mediaRegistry.llHardDisks.clear();
|
---|
1120 | trgMCF.mediaRegistry.llDvdImages.clear();
|
---|
1121 | trgMCF.mediaRegistry.llFloppyImages.clear();
|
---|
1122 | /* If we got a valid snapshot id, replace the hardware/storage section
|
---|
1123 | * with the stuff from the snapshot. */
|
---|
1124 | settings::Snapshot sn;
|
---|
1125 |
|
---|
1126 | if (d->snapshotId.isValid() && !d->snapshotId.isZero())
|
---|
1127 | if (!d->findSnapshot(trgMCF.llFirstSnapshot, d->snapshotId, sn))
|
---|
1128 | throw p->setError(E_FAIL,
|
---|
1129 | tr("Could not find data to snapshots '%s'"), d->snapshotId.toString().c_str());
|
---|
1130 |
|
---|
1131 | if (d->mode == CloneMode_MachineState)
|
---|
1132 | {
|
---|
1133 | if (sn.uuid.isValid() && !sn.uuid.isZero())
|
---|
1134 | trgMCF.hardwareMachine = sn.hardware;
|
---|
1135 |
|
---|
1136 | /* Remove any hint on snapshots. */
|
---|
1137 | trgMCF.llFirstSnapshot.clear();
|
---|
1138 | trgMCF.uuidCurrentSnapshot.clear();
|
---|
1139 | }
|
---|
1140 | else if ( d->mode == CloneMode_MachineAndChildStates
|
---|
1141 | && sn.uuid.isValid()
|
---|
1142 | && !sn.uuid.isZero())
|
---|
1143 | {
|
---|
1144 | if (!d->pOldMachineState.isNull())
|
---|
1145 | {
|
---|
1146 | /* Copy the snapshot data to the current machine. */
|
---|
1147 | trgMCF.hardwareMachine = sn.hardware;
|
---|
1148 |
|
---|
1149 | /* Current state is under root snapshot. */
|
---|
1150 | trgMCF.uuidCurrentSnapshot = sn.uuid;
|
---|
1151 | }
|
---|
1152 | /* The snapshot will be the root one. */
|
---|
1153 | trgMCF.llFirstSnapshot.clear();
|
---|
1154 | trgMCF.llFirstSnapshot.push_back(sn);
|
---|
1155 | }
|
---|
1156 |
|
---|
1157 | /* Generate new MAC addresses for all machines when not forbidden. */
|
---|
1158 | if (!d->options.contains(CloneOptions_KeepAllMACs))
|
---|
1159 | {
|
---|
1160 | d->updateMACAddresses(trgMCF.hardwareMachine.llNetworkAdapters);
|
---|
1161 | d->updateMACAddresses(trgMCF.llFirstSnapshot);
|
---|
1162 | }
|
---|
1163 |
|
---|
1164 | /* When the current snapshot folder is absolute we reset it to the
|
---|
1165 | * default relative folder. */
|
---|
1166 | if (RTPathStartsWithRoot(trgMCF.machineUserData.strSnapshotFolder.c_str()))
|
---|
1167 | trgMCF.machineUserData.strSnapshotFolder = "Snapshots";
|
---|
1168 | trgMCF.strStateFile = "";
|
---|
1169 | /* Set the new name. */
|
---|
1170 | const Utf8Str strOldVMName = trgMCF.machineUserData.strName;
|
---|
1171 | trgMCF.machineUserData.strName = d->pTrgMachine->mUserData->s.strName;
|
---|
1172 | trgMCF.uuid = d->pTrgMachine->mData->mUuid;
|
---|
1173 |
|
---|
1174 | Bstr bstrSrcSnapshotFolder;
|
---|
1175 | hrc = d->pSrcMachine->COMGETTER(SnapshotFolder)(bstrSrcSnapshotFolder.asOutParam());
|
---|
1176 | if (FAILED(hrc)) throw hrc;
|
---|
1177 | /* The absolute name of the snapshot folder. */
|
---|
1178 | strTrgSnapshotFolder.printf("%s%c%s", strTrgMachineFolder.c_str(), RTPATH_DELIMITER,
|
---|
1179 | trgMCF.machineUserData.strSnapshotFolder.c_str());
|
---|
1180 |
|
---|
1181 | /* Should we rename the disk names. */
|
---|
1182 | bool fKeepDiskNames = d->options.contains(CloneOptions_KeepDiskNames);
|
---|
1183 |
|
---|
1184 | /* We need to create a map with the already created medias. This is
|
---|
1185 | * necessary, cause different snapshots could have the same
|
---|
1186 | * parents/parent chain. If a medium is in this map already, it isn't
|
---|
1187 | * cloned a second time, but simply used. */
|
---|
1188 | typedef std::map<Utf8Str, ComObjPtr<Medium> > TStrMediumMap;
|
---|
1189 | typedef std::pair<Utf8Str, ComObjPtr<Medium> > TStrMediumPair;
|
---|
1190 | TStrMediumMap map;
|
---|
1191 | size_t cDisks = 0;
|
---|
1192 | for (size_t i = 0; i < d->llMedias.size(); ++i)
|
---|
1193 | {
|
---|
1194 | const MEDIUMTASKCHAIN &mtc = d->llMedias.at(i);
|
---|
1195 | ComObjPtr<Medium> pNewParent;
|
---|
1196 | uint32_t uSrcParentIdx = UINT32_MAX;
|
---|
1197 | uint32_t uTrgParentIdx = UINT32_MAX;
|
---|
1198 | for (size_t a = mtc.chain.size(); a > 0; --a)
|
---|
1199 | {
|
---|
1200 | const MEDIUMTASK &mt = mtc.chain.at(a - 1);
|
---|
1201 | ComPtr<IMedium> pMedium = mt.pMedium;
|
---|
1202 |
|
---|
1203 | Bstr bstrSrcName;
|
---|
1204 | hrc = pMedium->COMGETTER(Name)(bstrSrcName.asOutParam());
|
---|
1205 | if (FAILED(hrc)) throw hrc;
|
---|
1206 |
|
---|
1207 | hrc = d->pProgress->SetNextOperation(BstrFmt(tr("Cloning Disk '%ls' ..."), bstrSrcName.raw()).raw(), mt.uWeight);
|
---|
1208 | if (FAILED(hrc)) throw hrc;
|
---|
1209 |
|
---|
1210 | Bstr bstrSrcId;
|
---|
1211 | hrc = pMedium->COMGETTER(Id)(bstrSrcId.asOutParam());
|
---|
1212 | if (FAILED(hrc)) throw hrc;
|
---|
1213 |
|
---|
1214 | if (mtc.fAttachLinked)
|
---|
1215 | {
|
---|
1216 | IMedium *pTmp = pMedium;
|
---|
1217 | ComObjPtr<Medium> pLMedium = static_cast<Medium*>(pTmp);
|
---|
1218 | if (pLMedium.isNull())
|
---|
1219 | throw p->setError(VBOX_E_OBJECT_NOT_FOUND);
|
---|
1220 | ComObjPtr<Medium> pBase = pLMedium->i_getBase();
|
---|
1221 | if (pBase->i_isReadOnly())
|
---|
1222 | {
|
---|
1223 | ComObjPtr<Medium> pDiff;
|
---|
1224 | /* create the diff under the snapshot medium */
|
---|
1225 | trgLock.release();
|
---|
1226 | srcLock.release();
|
---|
1227 | hrc = d->createDifferencingMedium(p, pLMedium, strTrgSnapshotFolder,
|
---|
1228 | newMedia, &pDiff);
|
---|
1229 | srcLock.acquire();
|
---|
1230 | trgLock.acquire();
|
---|
1231 | if (FAILED(hrc)) throw hrc;
|
---|
1232 | map.insert(TStrMediumPair(Utf8Str(bstrSrcId), pDiff));
|
---|
1233 | /* diff image has to be used... */
|
---|
1234 | pNewParent = pDiff;
|
---|
1235 | pMediumsForNotify.insert(pDiff->i_getParent());
|
---|
1236 | uIdsForNotify[pDiff->i_getId()] = pDiff->i_getDeviceType();
|
---|
1237 | }
|
---|
1238 | else
|
---|
1239 | {
|
---|
1240 | /* Attach the medium directly, as its type is not
|
---|
1241 | * subject to diff creation. */
|
---|
1242 | newMedia.append(pLMedium);
|
---|
1243 | map.insert(TStrMediumPair(Utf8Str(bstrSrcId), pLMedium));
|
---|
1244 | pNewParent = pLMedium;
|
---|
1245 | }
|
---|
1246 | }
|
---|
1247 | else
|
---|
1248 | {
|
---|
1249 | /* Is a clone already there? */
|
---|
1250 | TStrMediumMap::iterator it = map.find(Utf8Str(bstrSrcId));
|
---|
1251 | if (it != map.end())
|
---|
1252 | pNewParent = it->second;
|
---|
1253 | else
|
---|
1254 | {
|
---|
1255 | ComPtr<IMediumFormat> pSrcFormat;
|
---|
1256 | hrc = pMedium->COMGETTER(MediumFormat)(pSrcFormat.asOutParam());
|
---|
1257 | ULONG uSrcCaps = 0;
|
---|
1258 | com::SafeArray <MediumFormatCapabilities_T> mediumFormatCap;
|
---|
1259 | hrc = pSrcFormat->COMGETTER(Capabilities)(ComSafeArrayAsOutParam(mediumFormatCap));
|
---|
1260 |
|
---|
1261 | if (FAILED(hrc)) throw hrc;
|
---|
1262 | else
|
---|
1263 | {
|
---|
1264 | for (ULONG j = 0; j < mediumFormatCap.size(); j++)
|
---|
1265 | uSrcCaps |= mediumFormatCap[j];
|
---|
1266 | }
|
---|
1267 |
|
---|
1268 | /* Default format? */
|
---|
1269 | Utf8Str strDefaultFormat;
|
---|
1270 | if (mtc.devType == DeviceType_HardDisk)
|
---|
1271 | p->mParent->i_getDefaultHardDiskFormat(strDefaultFormat);
|
---|
1272 | else
|
---|
1273 | strDefaultFormat = "RAW";
|
---|
1274 |
|
---|
1275 | Bstr bstrSrcFormat(strDefaultFormat);
|
---|
1276 |
|
---|
1277 | ULONG srcVar = MediumVariant_Standard;
|
---|
1278 | com::SafeArray <MediumVariant_T> mediumVariant;
|
---|
1279 |
|
---|
1280 | /* Is the source file based? */
|
---|
1281 | if ((uSrcCaps & MediumFormatCapabilities_File) == MediumFormatCapabilities_File)
|
---|
1282 | {
|
---|
1283 | /* Yes, just use the source format. Otherwise the defaults
|
---|
1284 | * will be used. */
|
---|
1285 | hrc = pMedium->COMGETTER(Format)(bstrSrcFormat.asOutParam());
|
---|
1286 | if (FAILED(hrc)) throw hrc;
|
---|
1287 |
|
---|
1288 | hrc = pMedium->COMGETTER(Variant)(ComSafeArrayAsOutParam(mediumVariant));
|
---|
1289 | if (FAILED(hrc)) throw hrc;
|
---|
1290 | else
|
---|
1291 | {
|
---|
1292 | for (size_t j = 0; j < mediumVariant.size(); j++)
|
---|
1293 | srcVar |= mediumVariant[j];
|
---|
1294 | }
|
---|
1295 | }
|
---|
1296 |
|
---|
1297 | Guid newId;
|
---|
1298 | newId.create();
|
---|
1299 | Utf8Str strNewName(bstrSrcName);
|
---|
1300 | if (!fKeepDiskNames)
|
---|
1301 | {
|
---|
1302 | Utf8Str strSrcTest = bstrSrcName;
|
---|
1303 | /* Check if we have to use another name. */
|
---|
1304 | if (!mt.strBaseName.isEmpty())
|
---|
1305 | strSrcTest = mt.strBaseName;
|
---|
1306 | strSrcTest.stripSuffix();
|
---|
1307 | /* If the old disk name was in {uuid} format we also
|
---|
1308 | * want the new name in this format, but with the
|
---|
1309 | * updated id of course. If the old disk was called
|
---|
1310 | * like the VM name, we change it to the new VM name.
|
---|
1311 | * For all other disks we rename them with this
|
---|
1312 | * template: "new name-disk1.vdi". */
|
---|
1313 | if (strSrcTest == strOldVMName)
|
---|
1314 | strNewName = Utf8StrFmt("%s%s", trgMCF.machineUserData.strName.c_str(),
|
---|
1315 | RTPathSuffix(Utf8Str(bstrSrcName).c_str()));
|
---|
1316 | else if ( strSrcTest.startsWith("{")
|
---|
1317 | && strSrcTest.endsWith("}"))
|
---|
1318 | {
|
---|
1319 | strSrcTest = strSrcTest.substr(1, strSrcTest.length() - 2);
|
---|
1320 |
|
---|
1321 | Guid temp_guid(strSrcTest);
|
---|
1322 | if (temp_guid.isValid() && !temp_guid.isZero())
|
---|
1323 | strNewName = Utf8StrFmt("%s%s", newId.toStringCurly().c_str(),
|
---|
1324 | RTPathSuffix(strNewName.c_str()));
|
---|
1325 | }
|
---|
1326 | else
|
---|
1327 | strNewName = Utf8StrFmt("%s-disk%d%s", trgMCF.machineUserData.strName.c_str(), ++cDisks,
|
---|
1328 | RTPathSuffix(Utf8Str(bstrSrcName).c_str()));
|
---|
1329 | }
|
---|
1330 |
|
---|
1331 | /* Check if this medium comes from the snapshot folder, if
|
---|
1332 | * so, put it there in the cloned machine as well.
|
---|
1333 | * Otherwise it goes to the machine folder. */
|
---|
1334 | Bstr bstrSrcPath;
|
---|
1335 | Utf8Str strFile = Utf8StrFmt("%s%c%s", strTrgMachineFolder.c_str(), RTPATH_DELIMITER, strNewName.c_str());
|
---|
1336 | hrc = pMedium->COMGETTER(Location)(bstrSrcPath.asOutParam());
|
---|
1337 | if (FAILED(hrc)) throw hrc;
|
---|
1338 | if ( !bstrSrcPath.isEmpty()
|
---|
1339 | && RTPathStartsWith(Utf8Str(bstrSrcPath).c_str(), Utf8Str(bstrSrcSnapshotFolder).c_str())
|
---|
1340 | && (fKeepDiskNames || mt.strBaseName.isEmpty()))
|
---|
1341 | strFile = Utf8StrFmt("%s%c%s", strTrgSnapshotFolder.c_str(), RTPATH_DELIMITER, strNewName.c_str());
|
---|
1342 |
|
---|
1343 | /* Start creating the clone. */
|
---|
1344 | ComObjPtr<Medium> pTarget;
|
---|
1345 | hrc = pTarget.createObject();
|
---|
1346 | if (FAILED(hrc)) throw hrc;
|
---|
1347 |
|
---|
1348 | hrc = pTarget->init(p->mParent, Utf8Str(bstrSrcFormat), strFile,
|
---|
1349 | Guid::Empty /* empty media registry */, mtc.devType);
|
---|
1350 | if (FAILED(hrc)) throw hrc;
|
---|
1351 |
|
---|
1352 | /* Update the new uuid. */
|
---|
1353 | pTarget->i_updateId(newId);
|
---|
1354 |
|
---|
1355 | /* Do the disk cloning. */
|
---|
1356 | ComPtr<IProgress> progress2;
|
---|
1357 |
|
---|
1358 | ComObjPtr<Medium> pLMedium = static_cast<Medium*>((IMedium*)pMedium);
|
---|
1359 | srcLock.release();
|
---|
1360 | hrc = pLMedium->i_cloneToEx(pTarget,
|
---|
1361 | (MediumVariant_T)srcVar,
|
---|
1362 | pNewParent,
|
---|
1363 | progress2.asOutParam(),
|
---|
1364 | uSrcParentIdx,
|
---|
1365 | uTrgParentIdx,
|
---|
1366 | false /* aNotify */);
|
---|
1367 | srcLock.acquire();
|
---|
1368 | if (FAILED(hrc)) throw hrc;
|
---|
1369 |
|
---|
1370 | /* Wait until the async process has finished. */
|
---|
1371 | srcLock.release();
|
---|
1372 | hrc = d->pProgress->WaitForOtherProgressCompletion(progress2, 0 /* indefinite wait */);
|
---|
1373 | srcLock.acquire();
|
---|
1374 | if (FAILED(hrc)) throw hrc;
|
---|
1375 |
|
---|
1376 | /* Remember created medium. */
|
---|
1377 | newMedia.append(pTarget);
|
---|
1378 | /* Get the medium type from the source and set it to the
|
---|
1379 | * new medium. */
|
---|
1380 | MediumType_T type;
|
---|
1381 | hrc = pMedium->COMGETTER(Type)(&type);
|
---|
1382 | if (FAILED(hrc)) throw hrc;
|
---|
1383 | trgLock.release();
|
---|
1384 | srcLock.release();
|
---|
1385 | hrc = pTarget->COMSETTER(Type)(type);
|
---|
1386 | srcLock.acquire();
|
---|
1387 | trgLock.acquire();
|
---|
1388 | if (FAILED(hrc)) throw hrc;
|
---|
1389 | map.insert(TStrMediumPair(Utf8Str(bstrSrcId), pTarget));
|
---|
1390 | /* register the new medium */
|
---|
1391 | {
|
---|
1392 | AutoWriteLock tlock(p->mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
|
---|
1393 | hrc = p->mParent->i_registerMedium(pTarget, &pTarget, tlock);
|
---|
1394 | if (FAILED(hrc)) throw hrc;
|
---|
1395 | }
|
---|
1396 | /* This medium becomes the parent of the next medium in the
|
---|
1397 | * chain. */
|
---|
1398 | pNewParent = pTarget;
|
---|
1399 | uIdsForNotify[pTarget->i_getId()] = pTarget->i_getDeviceType();
|
---|
1400 | }
|
---|
1401 | }
|
---|
1402 | /* Save the current source medium index as the new parent
|
---|
1403 | * medium index. */
|
---|
1404 | uSrcParentIdx = mt.uIdx;
|
---|
1405 | /* Simply increase the target index. */
|
---|
1406 | ++uTrgParentIdx;
|
---|
1407 | }
|
---|
1408 |
|
---|
1409 | Bstr bstrSrcId;
|
---|
1410 | hrc = mtc.chain.first().pMedium->COMGETTER(Id)(bstrSrcId.asOutParam());
|
---|
1411 | if (FAILED(hrc)) throw hrc;
|
---|
1412 | Bstr bstrTrgId;
|
---|
1413 | hrc = pNewParent->COMGETTER(Id)(bstrTrgId.asOutParam());
|
---|
1414 | if (FAILED(hrc)) throw hrc;
|
---|
1415 | /* update snapshot configuration */
|
---|
1416 | d->updateSnapshotStorageLists(trgMCF.llFirstSnapshot, bstrSrcId, bstrTrgId);
|
---|
1417 |
|
---|
1418 | /* create new 'Current State' diff for caller defined place */
|
---|
1419 | if (mtc.fCreateDiffs)
|
---|
1420 | {
|
---|
1421 | const MEDIUMTASK &mt = mtc.chain.first();
|
---|
1422 | ComObjPtr<Medium> pLMedium = static_cast<Medium*>((IMedium*)mt.pMedium);
|
---|
1423 | if (pLMedium.isNull())
|
---|
1424 | throw p->setError(VBOX_E_OBJECT_NOT_FOUND);
|
---|
1425 | ComObjPtr<Medium> pBase = pLMedium->i_getBase();
|
---|
1426 | if (pBase->i_isReadOnly())
|
---|
1427 | {
|
---|
1428 | ComObjPtr<Medium> pDiff;
|
---|
1429 | trgLock.release();
|
---|
1430 | srcLock.release();
|
---|
1431 | hrc = d->createDifferencingMedium(p, pNewParent, strTrgSnapshotFolder, newMedia, &pDiff);
|
---|
1432 | srcLock.acquire();
|
---|
1433 | trgLock.acquire();
|
---|
1434 | if (FAILED(hrc)) throw hrc;
|
---|
1435 | /* diff image has to be used... */
|
---|
1436 | pNewParent = pDiff;
|
---|
1437 | pMediumsForNotify.insert(pDiff->i_getParent());
|
---|
1438 | uIdsForNotify[pDiff->i_getId()] = pDiff->i_getDeviceType();
|
---|
1439 | }
|
---|
1440 | else
|
---|
1441 | {
|
---|
1442 | /* Attach the medium directly, as its type is not
|
---|
1443 | * subject to diff creation. */
|
---|
1444 | newMedia.append(pNewParent);
|
---|
1445 | }
|
---|
1446 |
|
---|
1447 | hrc = pNewParent->COMGETTER(Id)(bstrTrgId.asOutParam());
|
---|
1448 | if (FAILED(hrc)) throw hrc;
|
---|
1449 | }
|
---|
1450 | /* update 'Current State' configuration */
|
---|
1451 | d->updateStorageLists(trgMCF.hardwareMachine.storage.llStorageControllers, bstrSrcId, bstrTrgId);
|
---|
1452 | }
|
---|
1453 | /* Make sure all disks know of the new machine uuid. We do this last to
|
---|
1454 | * be able to change the medium type above. */
|
---|
1455 | for (size_t i = newMedia.size(); i > 0; --i)
|
---|
1456 | {
|
---|
1457 | const ComObjPtr<Medium> &pMedium = newMedia.at(i - 1);
|
---|
1458 | AutoCaller mac(pMedium);
|
---|
1459 | if (FAILED(mac.hrc())) throw mac.hrc();
|
---|
1460 | AutoWriteLock mlock(pMedium COMMA_LOCKVAL_SRC_POS);
|
---|
1461 | Guid uuid = d->pTrgMachine->mData->mUuid;
|
---|
1462 | if (d->options.contains(CloneOptions_Link))
|
---|
1463 | {
|
---|
1464 | ComObjPtr<Medium> pParent = pMedium->i_getParent();
|
---|
1465 | mlock.release();
|
---|
1466 | if (!pParent.isNull())
|
---|
1467 | {
|
---|
1468 | AutoCaller mac2(pParent);
|
---|
1469 | if (FAILED(mac2.hrc())) throw mac2.hrc();
|
---|
1470 | AutoReadLock mlock2(pParent COMMA_LOCKVAL_SRC_POS);
|
---|
1471 | if (pParent->i_getFirstRegistryMachineId(uuid))
|
---|
1472 | {
|
---|
1473 | mlock2.release();
|
---|
1474 | trgLock.release();
|
---|
1475 | srcLock.release();
|
---|
1476 | p->mParent->i_markRegistryModified(uuid);
|
---|
1477 | srcLock.acquire();
|
---|
1478 | trgLock.acquire();
|
---|
1479 | mlock2.acquire();
|
---|
1480 | }
|
---|
1481 | }
|
---|
1482 | mlock.acquire();
|
---|
1483 | }
|
---|
1484 | pMedium->i_removeRegistry(p->i_getVirtualBox()->i_getGlobalRegistryId());
|
---|
1485 | pMedium->i_addRegistry(uuid);
|
---|
1486 | }
|
---|
1487 | /* Check if a snapshot folder is necessary and if so doesn't already
|
---|
1488 | * exists. */
|
---|
1489 | if ( !d->llSaveStateFiles.isEmpty()
|
---|
1490 | && !RTDirExists(strTrgSnapshotFolder.c_str()))
|
---|
1491 | {
|
---|
1492 | int vrc = RTDirCreateFullPath(strTrgSnapshotFolder.c_str(), 0700);
|
---|
1493 | if (RT_FAILURE(vrc))
|
---|
1494 | throw p->setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
|
---|
1495 | tr("Could not create snapshots folder '%s' (%Rrc)"),
|
---|
1496 | strTrgSnapshotFolder.c_str(), vrc);
|
---|
1497 | }
|
---|
1498 | /* Clone all save state files. */
|
---|
1499 | for (size_t i = 0; i < d->llSaveStateFiles.size(); ++i)
|
---|
1500 | {
|
---|
1501 | FILECOPYTASK fct = d->llSaveStateFiles.at(i);
|
---|
1502 | const Utf8Str &strTrgSaveState = Utf8StrFmt("%s%c%s", strTrgSnapshotFolder.c_str(), RTPATH_DELIMITER,
|
---|
1503 | RTPathFilename(fct.strFile.c_str()));
|
---|
1504 |
|
---|
1505 | /* Move to next sub-operation. */
|
---|
1506 | hrc = d->pProgress->SetNextOperation(BstrFmt(tr("Copy save state file '%s' ..."),
|
---|
1507 | RTPathFilename(fct.strFile.c_str())).raw(), fct.uWeight);
|
---|
1508 | if (FAILED(hrc)) throw hrc;
|
---|
1509 | /* Copy the file only if it was not copied already. */
|
---|
1510 | if (!newFiles.contains(strTrgSaveState.c_str()))
|
---|
1511 | {
|
---|
1512 | int vrc = RTFileCopyEx(fct.strFile.c_str(), strTrgSaveState.c_str(), 0,
|
---|
1513 | MachineCloneVMPrivate::copyFileProgress, &d->pProgress);
|
---|
1514 | if (RT_FAILURE(vrc))
|
---|
1515 | throw p->setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
|
---|
1516 | tr("Could not copy state file '%s' to '%s' (%Rrc)"),
|
---|
1517 | fct.strFile.c_str(), strTrgSaveState.c_str(), vrc);
|
---|
1518 | newFiles.append(strTrgSaveState);
|
---|
1519 | }
|
---|
1520 | /* Update the path in the configuration either for the current
|
---|
1521 | * machine state or the snapshots. */
|
---|
1522 | if (!fct.snapshotUuid.isValid() || fct.snapshotUuid.isZero())
|
---|
1523 | trgMCF.strStateFile = strTrgSaveState;
|
---|
1524 | else
|
---|
1525 | d->updateSaveStateFile(trgMCF.llFirstSnapshot, fct.snapshotUuid, strTrgSaveState);
|
---|
1526 | }
|
---|
1527 |
|
---|
1528 | /* Clone all NVRAM files. */
|
---|
1529 | for (size_t i = 0; i < d->llNVRAMFiles.size(); ++i)
|
---|
1530 | {
|
---|
1531 | FILECOPYTASK fct = d->llNVRAMFiles.at(i);
|
---|
1532 | Utf8Str strTrgNVRAM;
|
---|
1533 | if (!fct.snapshotUuid.isValid() || fct.snapshotUuid.isZero())
|
---|
1534 | strTrgNVRAM = Utf8StrFmt("%s%c%s.nvram", strTrgMachineFolder.c_str(), RTPATH_DELIMITER,
|
---|
1535 | trgMCF.machineUserData.strName.c_str());
|
---|
1536 | else
|
---|
1537 | strTrgNVRAM = Utf8StrFmt("%s%c%s", strTrgSnapshotFolder.c_str(), RTPATH_DELIMITER,
|
---|
1538 | RTPathFilename(fct.strFile.c_str()));
|
---|
1539 |
|
---|
1540 | /* Move to next sub-operation. */
|
---|
1541 | hrc = d->pProgress->SetNextOperation(BstrFmt(tr("Copy NVRAM file '%s' ..."),
|
---|
1542 | RTPathFilename(fct.strFile.c_str())).raw(), fct.uWeight);
|
---|
1543 | if (FAILED(hrc)) throw hrc;
|
---|
1544 | /* Copy the file only if it was not copied already. */
|
---|
1545 | if (!newFiles.contains(strTrgNVRAM.c_str()))
|
---|
1546 | {
|
---|
1547 | hrc = p->i_getVirtualBox()->i_ensureFilePathExists(strTrgNVRAM.c_str(), true);
|
---|
1548 | if (FAILED(hrc)) throw hrc;
|
---|
1549 | int vrc = RTFileCopyEx(fct.strFile.c_str(), strTrgNVRAM.c_str(), 0,
|
---|
1550 | MachineCloneVMPrivate::copyFileProgress, &d->pProgress);
|
---|
1551 | if (RT_FAILURE(vrc))
|
---|
1552 | throw p->setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
|
---|
1553 | tr("Could not copy NVRAM file '%s' to '%s' (%Rrc)"),
|
---|
1554 | fct.strFile.c_str(), strTrgNVRAM.c_str(), vrc);
|
---|
1555 | newFiles.append(strTrgNVRAM);
|
---|
1556 | }
|
---|
1557 | /* Update the path in the configuration either for the current
|
---|
1558 | * machine state or the snapshots. */
|
---|
1559 | if (!fct.snapshotUuid.isValid() || fct.snapshotUuid.isZero())
|
---|
1560 | trgMCF.hardwareMachine.nvramSettings.strNvramPath = strTrgNVRAM;
|
---|
1561 | else
|
---|
1562 | d->updateNVRAMFile(trgMCF.llFirstSnapshot, fct.snapshotUuid, strTrgNVRAM);
|
---|
1563 | }
|
---|
1564 |
|
---|
1565 | {
|
---|
1566 | hrc = d->pProgress->SetNextOperation(BstrFmt(tr("Create Machine Clone '%s' ..."),
|
---|
1567 | trgMCF.machineUserData.strName.c_str()).raw(), 1);
|
---|
1568 | if (FAILED(hrc)) throw hrc;
|
---|
1569 | /* After modifying the new machine config, we can copy the stuff
|
---|
1570 | * over to the new machine. The machine have to be mutable for
|
---|
1571 | * this. */
|
---|
1572 | hrc = d->pTrgMachine->i_checkStateDependency(p->MutableStateDep);
|
---|
1573 | if (FAILED(hrc)) throw hrc;
|
---|
1574 | hrc = d->pTrgMachine->i_loadMachineDataFromSettings(trgMCF, &d->pTrgMachine->mData->mUuid);
|
---|
1575 | if (FAILED(hrc)) throw hrc;
|
---|
1576 |
|
---|
1577 | /* Fix up the "current state modified" flag to what it should be,
|
---|
1578 | * as the value guessed in i_loadMachineDataFromSettings can be
|
---|
1579 | * quite far off the logical value for the cloned VM. */
|
---|
1580 | if (d->mode == CloneMode_MachineState)
|
---|
1581 | d->pTrgMachine->mData->mCurrentStateModified = FALSE;
|
---|
1582 | else if ( d->mode == CloneMode_MachineAndChildStates
|
---|
1583 | && sn.uuid.isValid()
|
---|
1584 | && !sn.uuid.isZero())
|
---|
1585 | {
|
---|
1586 | if (!d->pOldMachineState.isNull())
|
---|
1587 | {
|
---|
1588 | /* There will be created a new differencing image based on
|
---|
1589 | * this snapshot. So reset the modified state. */
|
---|
1590 | d->pTrgMachine->mData->mCurrentStateModified = FALSE;
|
---|
1591 | }
|
---|
1592 | else
|
---|
1593 | d->pTrgMachine->mData->mCurrentStateModified = p->mData->mCurrentStateModified;
|
---|
1594 | }
|
---|
1595 | else if (d->mode == CloneMode_AllStates)
|
---|
1596 | d->pTrgMachine->mData->mCurrentStateModified = p->mData->mCurrentStateModified;
|
---|
1597 |
|
---|
1598 | /* If the target machine has saved state we MUST adjust the machine
|
---|
1599 | * state, otherwise saving settings will drop the information. */
|
---|
1600 | if (trgMCF.strStateFile.isNotEmpty())
|
---|
1601 | d->pTrgMachine->i_setMachineState(MachineState_Saved);
|
---|
1602 |
|
---|
1603 | /* save all VM data */
|
---|
1604 | bool fNeedsGlobalSaveSettings = false;
|
---|
1605 | hrc = d->pTrgMachine->i_saveSettings(&fNeedsGlobalSaveSettings, trgLock, Machine::SaveS_Force);
|
---|
1606 | if (FAILED(hrc)) throw hrc;
|
---|
1607 | /* Release all locks */
|
---|
1608 | trgLock.release();
|
---|
1609 | srcLock.release();
|
---|
1610 | if (fNeedsGlobalSaveSettings)
|
---|
1611 | {
|
---|
1612 | /* save the global settings; for that we should hold only the
|
---|
1613 | * VirtualBox lock */
|
---|
1614 | AutoWriteLock vlock(p->mParent COMMA_LOCKVAL_SRC_POS);
|
---|
1615 | hrc = p->mParent->i_saveSettings();
|
---|
1616 | if (FAILED(hrc)) throw hrc;
|
---|
1617 | }
|
---|
1618 | }
|
---|
1619 |
|
---|
1620 | /* Any additional machines need saving? */
|
---|
1621 | p->mParent->i_saveModifiedRegistries();
|
---|
1622 | }
|
---|
1623 | catch (HRESULT hrcXctp)
|
---|
1624 | {
|
---|
1625 | /* Error handling code only works correctly without locks held. */
|
---|
1626 | trgLock.release();
|
---|
1627 | srcLock.release();
|
---|
1628 | hrc = hrcXctp;
|
---|
1629 | }
|
---|
1630 | catch (...)
|
---|
1631 | {
|
---|
1632 | hrc = VirtualBoxBase::handleUnexpectedExceptions(p, RT_SRC_POS);
|
---|
1633 | }
|
---|
1634 |
|
---|
1635 | MultiResult mrc(hrc);
|
---|
1636 | /* Cleanup on failure (CANCEL also) */
|
---|
1637 | if (FAILED(hrc))
|
---|
1638 | {
|
---|
1639 | int vrc = VINF_SUCCESS;
|
---|
1640 | /* Delete all created files. */
|
---|
1641 | for (size_t i = 0; i < newFiles.size(); ++i)
|
---|
1642 | {
|
---|
1643 | vrc = RTFileDelete(newFiles.at(i).c_str());
|
---|
1644 | if (RT_FAILURE(vrc))
|
---|
1645 | mrc = p->setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
|
---|
1646 | tr("Could not delete file '%s' (%Rrc)"), newFiles.at(i).c_str(), vrc);
|
---|
1647 | }
|
---|
1648 | /* Delete all already created medias. (Reverse, cause there could be
|
---|
1649 | * parent->child relations.) */
|
---|
1650 | for (size_t i = newMedia.size(); i > 0; --i)
|
---|
1651 | {
|
---|
1652 | const ComObjPtr<Medium> &pMedium = newMedia.at(i - 1);
|
---|
1653 | mrc = pMedium->i_deleteStorage(NULL /* aProgress */,
|
---|
1654 | true /* aWait */,
|
---|
1655 | false /* aNotify */);
|
---|
1656 | pMedium->Close();
|
---|
1657 | }
|
---|
1658 | /* Delete the snapshot folder when not empty. */
|
---|
1659 | if (!strTrgSnapshotFolder.isEmpty())
|
---|
1660 | RTDirRemove(strTrgSnapshotFolder.c_str());
|
---|
1661 | /* Delete the machine folder when not empty. */
|
---|
1662 | RTDirRemove(strTrgMachineFolder.c_str());
|
---|
1663 |
|
---|
1664 | /* Must save the modified registries */
|
---|
1665 | p->mParent->i_saveModifiedRegistries();
|
---|
1666 | }
|
---|
1667 | else
|
---|
1668 | {
|
---|
1669 | for (std::map<Guid, DeviceType_T>::const_iterator it = uIdsForNotify.begin();
|
---|
1670 | it != uIdsForNotify.end();
|
---|
1671 | ++it)
|
---|
1672 | {
|
---|
1673 | p->mParent->i_onMediumRegistered(it->first, it->second, TRUE);
|
---|
1674 | }
|
---|
1675 | for (std::set<ComObjPtr<Medium> >::const_iterator it = pMediumsForNotify.begin();
|
---|
1676 | it != pMediumsForNotify.end();
|
---|
1677 | ++it)
|
---|
1678 | {
|
---|
1679 | if (it->isNotNull())
|
---|
1680 | p->mParent->i_onMediumConfigChanged(*it);
|
---|
1681 | }
|
---|
1682 | }
|
---|
1683 |
|
---|
1684 | return mrc;
|
---|
1685 | }
|
---|
1686 |
|
---|
1687 | void MachineCloneVM::destroy()
|
---|
1688 | {
|
---|
1689 | delete this;
|
---|
1690 | }
|
---|
1691 |
|
---|