MachineImplCloneVM.cpp@ 44380

Last change on this file since 44380 was 44380, checked in by vboxsync, 12 years ago
remove compiler warning about that some variable shadows a previous local
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 58.8 KB

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

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

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

Download in other formats: