MachineImplCloneVM.cpp@ 69731

Last change on this file since 69731 was 69500, checked in by vboxsync, 7 years ago
*: scm --update-copyright-year
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 64.2 KB

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

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

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

Download in other formats: