MachineImplCloneVM.cpp@ 98351

Last change on this file since 98351 was 98351, checked in by vboxsync, 22 months ago
Main: Fix plural of "medium" in many comments.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 71.5 KB

Line
1	/* $Id: MachineImplCloneVM.cpp 98351 2023-01-30 19:26:27Z 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 media
390	* directly or indirectly involved in the clone. Second create a histogram
391	* of the usage of all that media. Third select the media 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 media */
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 media 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 media 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 media. 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 media. (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

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Main/src-server/MachineImplCloneVM.cpp@ 98351

Download in other formats: