MachineImpl.cpp@ 70335

Last change on this file since 70335 was 70221, checked in by vboxsync, 7 years ago
Backed out r119656 as it was not the fix I asked for.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 517.1 KB

Line
1	/* $Id: MachineImpl.cpp 70221 2017-12-19 14:00:01Z vboxsync $ */
2	/** @file
3	* Implementation of IMachine in VBoxSVC.
4	*/
5
6	/*
7	* Copyright (C) 2004-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	/* Make sure all the stdint.h macros are included - must come first! */
19	#ifndef __STDC_LIMIT_MACROS
20	# define __STDC_LIMIT_MACROS
21	#endif
22	#ifndef __STDC_CONSTANT_MACROS
23	# define __STDC_CONSTANT_MACROS
24	#endif
25
26	#include "Logging.h"
27	#include "VirtualBoxImpl.h"
28	#include "MachineImpl.h"
29	#include "ClientToken.h"
30	#include "ProgressImpl.h"
31	#include "ProgressProxyImpl.h"
32	#include "MediumAttachmentImpl.h"
33	#include "MediumImpl.h"
34	#include "MediumLock.h"
35	#include "USBControllerImpl.h"
36	#include "USBDeviceFiltersImpl.h"
37	#include "HostImpl.h"
38	#include "SharedFolderImpl.h"
39	#include "GuestOSTypeImpl.h"
40	#include "VirtualBoxErrorInfoImpl.h"
41	#include "StorageControllerImpl.h"
42	#include "DisplayImpl.h"
43	#include "DisplayUtils.h"
44	#include "MachineImplCloneVM.h"
45	#include "AutostartDb.h"
46	#include "SystemPropertiesImpl.h"
47
48	// generated header
49	#include "VBoxEvents.h"
50
51	#ifdef VBOX_WITH_USB
52	# include "USBProxyService.h"
53	#endif
54
55	#include "AutoCaller.h"
56	#include "HashedPw.h"
57	#include "Performance.h"
58
59	#include <iprt/asm.h>
60	#include <iprt/path.h>
61	#include <iprt/dir.h>
62	#include <iprt/env.h>
63	#include <iprt/lockvalidator.h>
64	#include <iprt/process.h>
65	#include <iprt/cpp/utils.h>
66	#include <iprt/cpp/xml.h> /* xml::XmlFileWriter::s_pszSuff. /
67	#include <iprt/sha.h>
68	#include <iprt/string.h>
69
70	#include <VBox/com/array.h>
71	#include <VBox/com/list.h>
72
73	#include <VBox/err.h>
74	#include <VBox/param.h>
75	#include <VBox/settings.h>
76	#include <VBox/vmm/ssm.h>
77
78	#ifdef VBOX_WITH_GUEST_PROPS
79	# include <VBox/HostServices/GuestPropertySvc.h>
80	# include <VBox/com/array.h>
81	#endif
82
83	#include "VBox/com/MultiResult.h"
84
85	#include <algorithm>
86
87	#ifdef VBOX_WITH_DTRACE_R3_MAIN
88	# include "dtrace/VBoxAPI.h"
89	#endif
90
91	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_OS2)
92	# define HOSTSUFF_EXE ".exe"
93	#else /* !RT_OS_WINDOWS */
94	# define HOSTSUFF_EXE ""
95	#endif /* !RT_OS_WINDOWS */
96
97	// defines / prototypes
98	/////////////////////////////////////////////////////////////////////////////
99
100	/////////////////////////////////////////////////////////////////////////////
101	// Machine::Data structure
102	/////////////////////////////////////////////////////////////////////////////
103
104	Machine::Data::Data()
105	{
106	mRegistered = FALSE;
107	pMachineConfigFile = NULL;
108	/* Contains hints on what has changed when the user is using the VM (config
109	* changes, running the VM, ...). This is used to decide if a config needs
110	* to be written to disk. */
111	flModifications = 0;
112	/* VM modification usually also trigger setting the current state to
113	* "Modified". Although this is not always the case. An e.g. is the VM
114	* initialization phase or when snapshot related data is changed. The
115	* actually behavior is controlled by the following flag. */
116	m_fAllowStateModification = false;
117	mAccessible = FALSE;
118	/* mUuid is initialized in Machine::init() */
119
120	mMachineState = MachineState_PoweredOff;
121	RTTimeNow(&mLastStateChange);
122
123	mMachineStateDeps = 0;
124	mMachineStateDepsSem = NIL_RTSEMEVENTMULTI;
125	mMachineStateChangePending = 0;
126
127	mCurrentStateModified = TRUE;
128	mGuestPropertiesModified = FALSE;
129
130	mSession.mPID = NIL_RTPROCESS;
131	mSession.mLockType = LockType_Null;
132	mSession.mState = SessionState_Unlocked;
133	}
134
135	Machine::Data::~Data()
136	{
137	if (mMachineStateDepsSem != NIL_RTSEMEVENTMULTI)
138	{
139	RTSemEventMultiDestroy(mMachineStateDepsSem);
140	mMachineStateDepsSem = NIL_RTSEMEVENTMULTI;
141	}
142	if (pMachineConfigFile)
143	{
144	delete pMachineConfigFile;
145	pMachineConfigFile = NULL;
146	}
147	}
148
149	/////////////////////////////////////////////////////////////////////////////
150	// Machine::HWData structure
151	/////////////////////////////////////////////////////////////////////////////
152
153	Machine::HWData::HWData()
154	{
155	/* default values for a newly created machine */
156	mHWVersion = Utf8StrFmt("%d", SchemaDefs::DefaultHardwareVersion);
157	mMemorySize = 128;
158	mCPUCount = 1;
159	mCPUHotPlugEnabled = false;
160	mMemoryBalloonSize = 0;
161	mPageFusionEnabled = false;
162	mGraphicsControllerType = GraphicsControllerType_VBoxVGA;
163	mVRAMSize = 8;
164	mAccelerate3DEnabled = false;
165	mAccelerate2DVideoEnabled = false;
166	mMonitorCount = 1;
167	mVideoCaptureWidth = 1024;
168	mVideoCaptureHeight = 768;
169	mVideoCaptureRate = 512;
170	mVideoCaptureFPS = 25;
171	mVideoCaptureMaxTime = 0;
172	mVideoCaptureMaxFileSize = 0;
173	mVideoCaptureEnabled = false;
174	for (unsigned i = 0; i < RT_ELEMENTS(maVideoCaptureScreens); ++i)
175	maVideoCaptureScreens[i] = true;
176
177	mHWVirtExEnabled = true;
178	mHWVirtExNestedPagingEnabled = true;
179	#if HC_ARCH_BITS == 64 && !defined(RT_OS_LINUX)
180	mHWVirtExLargePagesEnabled = true;
181	#else
182	/* Not supported on 32 bits hosts. */
183	mHWVirtExLargePagesEnabled = false;
184	#endif
185	mHWVirtExVPIDEnabled = true;
186	mHWVirtExUXEnabled = true;
187	mHWVirtExForceEnabled = false;
188	#if HC_ARCH_BITS == 64 \|\| defined(RT_OS_WINDOWS) \|\| defined(RT_OS_DARWIN)
189	mPAEEnabled = true;
190	#else
191	mPAEEnabled = false;
192	#endif
193	mLongMode = HC_ARCH_BITS == 64 ? settings::Hardware::LongMode_Enabled : settings::Hardware::LongMode_Disabled;
194	mTripleFaultReset = false;
195	mAPIC = true;
196	mX2APIC = false;
197	mHPETEnabled = false;
198	mCpuExecutionCap = 100; /* Maximum CPU execution cap by default. */
199	mCpuIdPortabilityLevel = 0;
200	mCpuProfile = "host";
201
202	/* default boot order: floppy - DVD - HDD */
203	mBootOrder[0] = DeviceType_Floppy;
204	mBootOrder[1] = DeviceType_DVD;
205	mBootOrder[2] = DeviceType_HardDisk;
206	for (size_t i = 3; i < RT_ELEMENTS(mBootOrder); ++i)
207	mBootOrder[i] = DeviceType_Null;
208
209	mClipboardMode = ClipboardMode_Disabled;
210	mDnDMode = DnDMode_Disabled;
211
212	mFirmwareType = FirmwareType_BIOS;
213	mKeyboardHIDType = KeyboardHIDType_PS2Keyboard;
214	mPointingHIDType = PointingHIDType_PS2Mouse;
215	mChipsetType = ChipsetType_PIIX3;
216	mParavirtProvider = ParavirtProvider_Default;
217	mEmulatedUSBCardReaderEnabled = FALSE;
218
219	for (size_t i = 0; i < RT_ELEMENTS(mCPUAttached); ++i)
220	mCPUAttached[i] = false;
221
222	mIOCacheEnabled = true;
223	mIOCacheSize = 5; /* 5MB */
224	}
225
226	Machine::HWData::~HWData()
227	{
228	}
229
230	/////////////////////////////////////////////////////////////////////////////
231	// Machine class
232	/////////////////////////////////////////////////////////////////////////////
233
234	// constructor / destructor
235	/////////////////////////////////////////////////////////////////////////////
236
237	Machine::Machine() :
238	#ifdef VBOX_WITH_RESOURCE_USAGE_API
239	mCollectorGuest(NULL),
240	#endif
241	mPeer(NULL),
242	mParent(NULL),
243	mSerialPorts(),
244	mParallelPorts(),
245	uRegistryNeedsSaving(0)
246	{}
247
248	Machine::~Machine()
249	{}
250
251	HRESULT Machine::FinalConstruct()
252	{
253	LogFlowThisFunc(("\n"));
254	return BaseFinalConstruct();
255	}
256
257	void Machine::FinalRelease()
258	{
259	LogFlowThisFunc(("\n"));
260	uninit();
261	BaseFinalRelease();
262	}
263
264	/**
265	* Initializes a new machine instance; this init() variant creates a new, empty machine.
266	* This gets called from VirtualBox::CreateMachine().
267	*
268	* @param aParent Associated parent object
269	* @param strConfigFile Local file system path to the VM settings file (can
270	* be relative to the VirtualBox config directory).
271	* @param strName name for the machine
272	* @param llGroups list of groups for the machine
273	* @param aOsType OS Type of this machine or NULL.
274	* @param aId UUID for the new machine.
275	* @param fForceOverwrite Whether to overwrite an existing machine settings file.
276	* @param fDirectoryIncludesUUID Whether the use a special VM directory naming
277	* scheme (includes the UUID).
278	*
279	* @return Success indicator. if not S_OK, the machine object is invalid
280	*/
281	HRESULT Machine::init(VirtualBox *aParent,
282	const Utf8Str &strConfigFile,
283	const Utf8Str &strName,
284	const StringsList &llGroups,
285	GuestOSType *aOsType,
286	const Guid &aId,
287	bool fForceOverwrite,
288	bool fDirectoryIncludesUUID)
289	{
290	LogFlowThisFuncEnter();
291	LogFlowThisFunc(("(Init_New) aConfigFile='%s'\n", strConfigFile.c_str()));
292
293	/* Enclose the state transition NotReady->InInit->Ready */
294	AutoInitSpan autoInitSpan(this);
295	AssertReturn(autoInitSpan.isOk(), E_FAIL);
296
297	HRESULT rc = initImpl(aParent, strConfigFile);
298	if (FAILED(rc)) return rc;
299
300	rc = i_tryCreateMachineConfigFile(fForceOverwrite);
301	if (FAILED(rc)) return rc;
302
303	if (SUCCEEDED(rc))
304	{
305	// create an empty machine config
306	mData->pMachineConfigFile = new settings::MachineConfigFile(NULL);
307
308	rc = initDataAndChildObjects();
309	}
310
311	if (SUCCEEDED(rc))
312	{
313	// set to true now to cause uninit() to call uninitDataAndChildObjects() on failure
314	mData->mAccessible = TRUE;
315
316	unconst(mData->mUuid) = aId;
317
318	mUserData->s.strName = strName;
319
320	mUserData->s.llGroups = llGroups;
321
322	mUserData->s.fDirectoryIncludesUUID = fDirectoryIncludesUUID;
323	// the "name sync" flag determines whether the machine directory gets renamed along
324	// with the machine file; say so if the settings file name is the same as the
325	// settings file parent directory (machine directory)
326	mUserData->s.fNameSync = i_isInOwnDir();
327
328	// initialize the default snapshots folder
329	rc = COMSETTER(SnapshotFolder)(NULL);
330	AssertComRC(rc);
331
332	if (aOsType)
333	{
334	/* Store OS type */
335	mUserData->s.strOsType = aOsType->i_id();
336
337	/* Apply BIOS defaults */
338	mBIOSSettings->i_applyDefaults(aOsType);
339
340	/* Let the OS type select 64-bit ness. */
341	mHWData->mLongMode = aOsType->i_is64Bit()
342	? settings::Hardware::LongMode_Enabled : settings::Hardware::LongMode_Disabled;
343
344	/* Let the OS type enable the X2APIC */
345	mHWData->mX2APIC = aOsType->i_recommendedX2APIC();
346	}
347
348	/* Apply network adapters defaults */
349	for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
350	mNetworkAdapters[slot]->i_applyDefaults(aOsType);
351
352	/* Apply serial port defaults */
353	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
354	mSerialPorts[slot]->i_applyDefaults(aOsType);
355
356	/* Apply parallel port defaults */
357	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
358	mParallelPorts[slot]->i_applyDefaults();
359
360	/* At this point the changing of the current state modification
361	* flag is allowed. */
362	i_allowStateModification();
363
364	/* commit all changes made during the initialization */
365	i_commit();
366	}
367
368	/* Confirm a successful initialization when it's the case */
369	if (SUCCEEDED(rc))
370	{
371	if (mData->mAccessible)
372	autoInitSpan.setSucceeded();
373	else
374	autoInitSpan.setLimited();
375	}
376
377	LogFlowThisFunc(("mName='%s', mRegistered=%RTbool, mAccessible=%RTbool, rc=%08X\n",
378	!!mUserData ? mUserData->s.strName.c_str() : "NULL",
379	mData->mRegistered,
380	mData->mAccessible,
381	rc));
382
383	LogFlowThisFuncLeave();
384
385	return rc;
386	}
387
388	/**
389	* Initializes a new instance with data from machine XML (formerly Init_Registered).
390	* Gets called in two modes:
391	*
392	* -- from VirtualBox::initMachines() during VirtualBox startup; in that case, the
393	* UUID is specified and we mark the machine as "registered";
394	*
395	* -- from the public VirtualBox::OpenMachine() API, in which case the UUID is NULL
396	* and the machine remains unregistered until RegisterMachine() is called.
397	*
398	* @param aParent Associated parent object
399	* @param strConfigFile Local file system path to the VM settings file (can
400	* be relative to the VirtualBox config directory).
401	* @param aId UUID of the machine or NULL (see above).
402	*
403	* @return Success indicator. if not S_OK, the machine object is invalid
404	*/
405	HRESULT Machine::initFromSettings(VirtualBox *aParent,
406	const Utf8Str &strConfigFile,
407	const Guid *aId)
408	{
409	LogFlowThisFuncEnter();
410	LogFlowThisFunc(("(Init_Registered) aConfigFile='%s\n", strConfigFile.c_str()));
411
412	/* Enclose the state transition NotReady->InInit->Ready */
413	AutoInitSpan autoInitSpan(this);
414	AssertReturn(autoInitSpan.isOk(), E_FAIL);
415
416	HRESULT rc = initImpl(aParent, strConfigFile);
417	if (FAILED(rc)) return rc;
418
419	if (aId)
420	{
421	// loading a registered VM:
422	unconst(mData->mUuid) = *aId;
423	mData->mRegistered = TRUE;
424	// now load the settings from XML:
425	rc = i_registeredInit();
426	// this calls initDataAndChildObjects() and loadSettings()
427	}
428	else
429	{
430	// opening an unregistered VM (VirtualBox::OpenMachine()):
431	rc = initDataAndChildObjects();
432
433	if (SUCCEEDED(rc))
434	{
435	// set to true now to cause uninit() to call uninitDataAndChildObjects() on failure
436	mData->mAccessible = TRUE;
437
438	try
439	{
440	// load and parse machine XML; this will throw on XML or logic errors
441	mData->pMachineConfigFile = new settings::MachineConfigFile(&mData->m_strConfigFileFull);
442
443	// reject VM UUID duplicates, they can happen if someone
444	// tries to register an already known VM config again
445	if (aParent->i_findMachine(mData->pMachineConfigFile->uuid,
446	true /* fPermitInaccessible */,
447	false /* aDoSetError */,
448	NULL) != VBOX_E_OBJECT_NOT_FOUND)
449	{
450	throw setError(E_FAIL,
451	tr("Trying to open a VM config '%s' which has the same UUID as an existing virtual machine"),
452	mData->m_strConfigFile.c_str());
453	}
454
455	// use UUID from machine config
456	unconst(mData->mUuid) = mData->pMachineConfigFile->uuid;
457
458	rc = i_loadMachineDataFromSettings(*mData->pMachineConfigFile,
459	NULL /* puuidRegistry */);
460	if (FAILED(rc)) throw rc;
461
462	/* At this point the changing of the current state modification
463	* flag is allowed. */
464	i_allowStateModification();
465
466	i_commit();
467	}
468	catch (HRESULT err)
469	{
470	/* we assume that error info is set by the thrower */
471	rc = err;
472	}
473	catch (...)
474	{
475	rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
476	}
477	}
478	}
479
480	/* Confirm a successful initialization when it's the case */
481	if (SUCCEEDED(rc))
482	{
483	if (mData->mAccessible)
484	autoInitSpan.setSucceeded();
485	else
486	{
487	autoInitSpan.setLimited();
488
489	// uninit media from this machine's media registry, or else
490	// reloading the settings will fail
491	mParent->i_unregisterMachineMedia(i_getId());
492	}
493	}
494
495	LogFlowThisFunc(("mName='%s', mRegistered=%RTbool, mAccessible=%RTbool "
496	"rc=%08X\n",
497	!!mUserData ? mUserData->s.strName.c_str() : "NULL",
498	mData->mRegistered, mData->mAccessible, rc));
499
500	LogFlowThisFuncLeave();
501
502	return rc;
503	}
504
505	/**
506	* Initializes a new instance from a machine config that is already in memory
507	* (import OVF case). Since we are importing, the UUID in the machine
508	* config is ignored and we always generate a fresh one.
509	*
510	* @param aParent Associated parent object.
511	* @param strName Name for the new machine; this overrides what is specified in config and is used
512	* for the settings file as well.
513	* @param config Machine configuration loaded and parsed from XML.
514	*
515	* @return Success indicator. if not S_OK, the machine object is invalid
516	*/
517	HRESULT Machine::init(VirtualBox *aParent,
518	const Utf8Str &strName,
519	const settings::MachineConfigFile &config)
520	{
521	LogFlowThisFuncEnter();
522
523	/* Enclose the state transition NotReady->InInit->Ready */
524	AutoInitSpan autoInitSpan(this);
525	AssertReturn(autoInitSpan.isOk(), E_FAIL);
526
527	Utf8Str strConfigFile;
528	aParent->i_getDefaultMachineFolder(strConfigFile);
529	strConfigFile.append(RTPATH_DELIMITER);
530	strConfigFile.append(strName);
531	strConfigFile.append(RTPATH_DELIMITER);
532	strConfigFile.append(strName);
533	strConfigFile.append(".vbox");
534
535	HRESULT rc = initImpl(aParent, strConfigFile);
536	if (FAILED(rc)) return rc;
537
538	rc = i_tryCreateMachineConfigFile(false /* fForceOverwrite */);
539	if (FAILED(rc)) return rc;
540
541	rc = initDataAndChildObjects();
542
543	if (SUCCEEDED(rc))
544	{
545	// set to true now to cause uninit() to call uninitDataAndChildObjects() on failure
546	mData->mAccessible = TRUE;
547
548	// create empty machine config for instance data
549	mData->pMachineConfigFile = new settings::MachineConfigFile(NULL);
550
551	// generate fresh UUID, ignore machine config
552	unconst(mData->mUuid).create();
553
554	rc = i_loadMachineDataFromSettings(config,
555	&mData->mUuid); // puuidRegistry: initialize media with this registry ID
556
557	// override VM name as well, it may be different
558	mUserData->s.strName = strName;
559
560	if (SUCCEEDED(rc))
561	{
562	/* At this point the changing of the current state modification
563	* flag is allowed. */
564	i_allowStateModification();
565
566	/* commit all changes made during the initialization */
567	i_commit();
568	}
569	}
570
571	/* Confirm a successful initialization when it's the case */
572	if (SUCCEEDED(rc))
573	{
574	if (mData->mAccessible)
575	autoInitSpan.setSucceeded();
576	else
577	{
578	/* Ignore all errors from unregistering, they would destroy
579	- * the more interesting error information we already have,
580	- * pinpointing the issue with the VM config. */
581	ErrorInfoKeeper eik;
582
583	autoInitSpan.setLimited();
584
585	// uninit media from this machine's media registry, or else
586	// reloading the settings will fail
587	mParent->i_unregisterMachineMedia(i_getId());
588	}
589	}
590
591	LogFlowThisFunc(("mName='%s', mRegistered=%RTbool, mAccessible=%RTbool "
592	"rc=%08X\n",
593	!!mUserData ? mUserData->s.strName.c_str() : "NULL",
594	mData->mRegistered, mData->mAccessible, rc));
595
596	LogFlowThisFuncLeave();
597
598	return rc;
599	}
600
601	/**
602	* Shared code between the various init() implementations.
603	* @param aParent The VirtualBox object.
604	* @param strConfigFile Settings file.
605	* @return
606	*/
607	HRESULT Machine::initImpl(VirtualBox *aParent,
608	const Utf8Str &strConfigFile)
609	{
610	LogFlowThisFuncEnter();
611
612	AssertReturn(aParent, E_INVALIDARG);
613	AssertReturn(!strConfigFile.isEmpty(), E_INVALIDARG);
614
615	HRESULT rc = S_OK;
616
617	/* share the parent weakly */
618	unconst(mParent) = aParent;
619
620	/* allocate the essential machine data structure (the rest will be
621	* allocated later by initDataAndChildObjects() */
622	mData.allocate();
623
624	/* memorize the config file name (as provided) */
625	mData->m_strConfigFile = strConfigFile;
626
627	/* get the full file name */
628	int vrc1 = mParent->i_calculateFullPath(strConfigFile, mData->m_strConfigFileFull);
629	if (RT_FAILURE(vrc1))
630	return setError(VBOX_E_FILE_ERROR,
631	tr("Invalid machine settings file name '%s' (%Rrc)"),
632	strConfigFile.c_str(),
633	vrc1);
634
635	LogFlowThisFuncLeave();
636
637	return rc;
638	}
639
640	/**
641	* Tries to create a machine settings file in the path stored in the machine
642	* instance data. Used when a new machine is created to fail gracefully if
643	* the settings file could not be written (e.g. because machine dir is read-only).
644	* @return
645	*/
646	HRESULT Machine::i_tryCreateMachineConfigFile(bool fForceOverwrite)
647	{
648	HRESULT rc = S_OK;
649
650	// when we create a new machine, we must be able to create the settings file
651	RTFILE f = NIL_RTFILE;
652	int vrc = RTFileOpen(&f, mData->m_strConfigFileFull.c_str(), RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE);
653	if ( RT_SUCCESS(vrc)
654	\|\| vrc == VERR_SHARING_VIOLATION
655	)
656	{
657	if (RT_SUCCESS(vrc))
658	RTFileClose(f);
659	if (!fForceOverwrite)
660	rc = setError(VBOX_E_FILE_ERROR,
661	tr("Machine settings file '%s' already exists"),
662	mData->m_strConfigFileFull.c_str());
663	else
664	{
665	/* try to delete the config file, as otherwise the creation
666	* of a new settings file will fail. */
667	int vrc2 = RTFileDelete(mData->m_strConfigFileFull.c_str());
668	if (RT_FAILURE(vrc2))
669	rc = setError(VBOX_E_FILE_ERROR,
670	tr("Could not delete the existing settings file '%s' (%Rrc)"),
671	mData->m_strConfigFileFull.c_str(), vrc2);
672	}
673	}
674	else if ( vrc != VERR_FILE_NOT_FOUND
675	&& vrc != VERR_PATH_NOT_FOUND
676	)
677	rc = setError(VBOX_E_FILE_ERROR,
678	tr("Invalid machine settings file name '%s' (%Rrc)"),
679	mData->m_strConfigFileFull.c_str(),
680	vrc);
681	return rc;
682	}
683
684	/**
685	* Initializes the registered machine by loading the settings file.
686	* This method is separated from #init() in order to make it possible to
687	* retry the operation after VirtualBox startup instead of refusing to
688	* startup the whole VirtualBox server in case if the settings file of some
689	* registered VM is invalid or inaccessible.
690	*
691	* @note Must be always called from this object's write lock
692	* (unless called from #init() that doesn't need any locking).
693	* @note Locks the mUSBController method for writing.
694	* @note Subclasses must not call this method.
695	*/
696	HRESULT Machine::i_registeredInit()
697	{
698	AssertReturn(!i_isSessionMachine(), E_FAIL);
699	AssertReturn(!i_isSnapshotMachine(), E_FAIL);
700	AssertReturn(mData->mUuid.isValid(), E_FAIL);
701	AssertReturn(!mData->mAccessible, E_FAIL);
702
703	HRESULT rc = initDataAndChildObjects();
704
705	if (SUCCEEDED(rc))
706	{
707	/* Temporarily reset the registered flag in order to let setters
708	* potentially called from loadSettings() succeed (isMutable() used in
709	* all setters will return FALSE for a Machine instance if mRegistered
710	* is TRUE). */
711	mData->mRegistered = FALSE;
712
713	try
714	{
715	// load and parse machine XML; this will throw on XML or logic errors
716	mData->pMachineConfigFile = new settings::MachineConfigFile(&mData->m_strConfigFileFull);
717
718	if (mData->mUuid != mData->pMachineConfigFile->uuid)
719	throw setError(E_FAIL,
720	tr("Machine UUID {%RTuuid} in '%s' doesn't match its UUID {%s} in the registry file '%s'"),
721	mData->pMachineConfigFile->uuid.raw(),
722	mData->m_strConfigFileFull.c_str(),
723	mData->mUuid.toString().c_str(),
724	mParent->i_settingsFilePath().c_str());
725
726	rc = i_loadMachineDataFromSettings(*mData->pMachineConfigFile,
727	NULL /* const Guid puuidRegistry /);
728	if (FAILED(rc)) throw rc;
729	}
730	catch (HRESULT err)
731	{
732	/* we assume that error info is set by the thrower */
733	rc = err;
734	}
735	catch (...)
736	{
737	rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
738	}
739
740	/* Restore the registered flag (even on failure) */
741	mData->mRegistered = TRUE;
742	}
743
744	if (SUCCEEDED(rc))
745	{
746	/* Set mAccessible to TRUE only if we successfully locked and loaded
747	* the settings file */
748	mData->mAccessible = TRUE;
749
750	/* commit all changes made during loading the settings file */
751	i_commit(); /// @todo r=dj why do we need a commit during init?!? this is very expensive
752	/// @todo r=klaus for some reason the settings loading logic backs up
753	// the settings, and therefore a commit is needed. Should probably be changed.
754	}
755	else
756	{
757	/* If the machine is registered, then, instead of returning a
758	* failure, we mark it as inaccessible and set the result to
759	* success to give it a try later */
760
761	/* fetch the current error info */
762	mData->mAccessError = com::ErrorInfo();
763	Log1Warning(("Machine {%RTuuid} is inaccessible! [%ls]\n", mData->mUuid.raw(), mData->mAccessError.getText().raw()));
764
765	/* rollback all changes */
766	i_rollback(false /* aNotify */);
767
768	// uninit media from this machine's media registry, or else
769	// reloading the settings will fail
770	mParent->i_unregisterMachineMedia(i_getId());
771
772	/* uninitialize the common part to make sure all data is reset to
773	* default (null) values */
774	uninitDataAndChildObjects();
775
776	rc = S_OK;
777	}
778
779	return rc;
780	}
781
782	/**
783	* Uninitializes the instance.
784	* Called either from FinalRelease() or by the parent when it gets destroyed.
785	*
786	* @note The caller of this method must make sure that this object
787	* a) doesn't have active callers on the current thread and b) is not locked
788	* by the current thread; otherwise uninit() will hang either a) due to
789	* AutoUninitSpan waiting for a number of calls to drop to zero or b) due to
790	* a dead-lock caused by this thread waiting for all callers on the other
791	* threads are done but preventing them from doing so by holding a lock.
792	*/
793	void Machine::uninit()
794	{
795	LogFlowThisFuncEnter();
796
797	Assert(!isWriteLockOnCurrentThread());
798
799	Assert(!uRegistryNeedsSaving);
800	if (uRegistryNeedsSaving)
801	{
802	AutoCaller autoCaller(this);
803	if (SUCCEEDED(autoCaller.rc()))
804	{
805	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
806	i_saveSettings(NULL, Machine::SaveS_Force);
807	}
808	}
809
810	/* Enclose the state transition Ready->InUninit->NotReady */
811	AutoUninitSpan autoUninitSpan(this);
812	if (autoUninitSpan.uninitDone())
813	return;
814
815	Assert(!i_isSnapshotMachine());
816	Assert(!i_isSessionMachine());
817	Assert(!!mData);
818
819	LogFlowThisFunc(("initFailed()=%d\n", autoUninitSpan.initFailed()));
820	LogFlowThisFunc(("mRegistered=%d\n", mData->mRegistered));
821
822	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
823
824	if (!mData->mSession.mMachine.isNull())
825	{
826	/* Theoretically, this can only happen if the VirtualBox server has been
827	* terminated while there were clients running that owned open direct
828	* sessions. Since in this case we are definitely called by
829	* VirtualBox::uninit(), we may be sure that SessionMachine::uninit()
830	* won't happen on the client watcher thread (because it has a
831	* VirtualBox caller for the duration of the
832	* SessionMachine::i_checkForDeath() call, so that VirtualBox::uninit()
833	* cannot happen until the VirtualBox caller is released). This is
834	* important, because SessionMachine::uninit() cannot correctly operate
835	* after we return from this method (it expects the Machine instance is
836	* still valid). We'll call it ourselves below.
837	*/
838	Log1WarningThisFunc(("Session machine is not NULL (%p), the direct session is still open!\n",
839	(SessionMachine*)mData->mSession.mMachine));
840
841	if (Global::IsOnlineOrTransient(mData->mMachineState))
842	{
843	Log1WarningThisFunc(("Setting state to Aborted!\n"));
844	/* set machine state using SessionMachine reimplementation */
845	static_cast<Machine*>(mData->mSession.mMachine)->i_setMachineState(MachineState_Aborted);
846	}
847
848	/*
849	* Uninitialize SessionMachine using public uninit() to indicate
850	* an unexpected uninitialization.
851	*/
852	mData->mSession.mMachine->uninit();
853	/* SessionMachine::uninit() must set mSession.mMachine to null */
854	Assert(mData->mSession.mMachine.isNull());
855	}
856
857	// uninit media from this machine's media registry, if they're still there
858	Guid uuidMachine(i_getId());
859
860	/* the lock is no more necessary (SessionMachine is uninitialized) */
861	alock.release();
862
863	/* XXX This will fail with
864	* "cannot be closed because it is still attached to 1 virtual machines"
865	* because at this point we did not call uninitDataAndChildObjects() yet
866	* and therefore also removeBackReference() for all these mediums was not called! */
867
868	if (uuidMachine.isValid() && !uuidMachine.isZero()) // can be empty if we're called from a failure of Machine::init
869	mParent->i_unregisterMachineMedia(uuidMachine);
870
871	// has machine been modified?
872	if (mData->flModifications)
873	{
874	Log1WarningThisFunc(("Discarding unsaved settings changes!\n"));
875	i_rollback(false /* aNotify */);
876	}
877
878	if (mData->mAccessible)
879	uninitDataAndChildObjects();
880
881	/* free the essential data structure last */
882	mData.free();
883
884	LogFlowThisFuncLeave();
885	}
886
887	// Wrapped IMachine properties
888	/////////////////////////////////////////////////////////////////////////////
889	HRESULT Machine::getParent(ComPtr<IVirtualBox> &aParent)
890	{
891	/* mParent is constant during life time, no need to lock */
892	ComObjPtr<VirtualBox> pVirtualBox(mParent);
893	aParent = pVirtualBox;
894
895	return S_OK;
896	}
897
898
899	HRESULT Machine::getAccessible(BOOL *aAccessible)
900	{
901	/* In some cases (medium registry related), it is necessary to be able to
902	* go through the list of all machines. Happens when an inaccessible VM
903	* has a sensible medium registry. */
904	AutoReadLock mllock(mParent->i_getMachinesListLockHandle() COMMA_LOCKVAL_SRC_POS);
905	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
906
907	HRESULT rc = S_OK;
908
909	if (!mData->mAccessible)
910	{
911	/* try to initialize the VM once more if not accessible */
912
913	AutoReinitSpan autoReinitSpan(this);
914	AssertReturn(autoReinitSpan.isOk(), E_FAIL);
915
916	#ifdef DEBUG
917	LogFlowThisFunc(("Dumping media backreferences\n"));
918	mParent->i_dumpAllBackRefs();
919	#endif
920
921	if (mData->pMachineConfigFile)
922	{
923	// reset the XML file to force loadSettings() (called from i_registeredInit())
924	// to parse it again; the file might have changed
925	delete mData->pMachineConfigFile;
926	mData->pMachineConfigFile = NULL;
927	}
928
929	rc = i_registeredInit();
930
931	if (SUCCEEDED(rc) && mData->mAccessible)
932	{
933	autoReinitSpan.setSucceeded();
934
935	/* make sure interesting parties will notice the accessibility
936	* state change */
937	mParent->i_onMachineStateChange(mData->mUuid, mData->mMachineState);
938	mParent->i_onMachineDataChange(mData->mUuid);
939	}
940	}
941
942	if (SUCCEEDED(rc))
943	*aAccessible = mData->mAccessible;
944
945	LogFlowThisFuncLeave();
946
947	return rc;
948	}
949
950	HRESULT Machine::getAccessError(ComPtr<IVirtualBoxErrorInfo> &aAccessError)
951	{
952	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
953
954	if (mData->mAccessible \|\| !mData->mAccessError.isBasicAvailable())
955	{
956	/* return shortly */
957	aAccessError = NULL;
958	return S_OK;
959	}
960
961	HRESULT rc = S_OK;
962
963	ComObjPtr<VirtualBoxErrorInfo> errorInfo;
964	rc = errorInfo.createObject();
965	if (SUCCEEDED(rc))
966	{
967	errorInfo->init(mData->mAccessError.getResultCode(),
968	mData->mAccessError.getInterfaceID().ref(),
969	Utf8Str(mData->mAccessError.getComponent()).c_str(),
970	Utf8Str(mData->mAccessError.getText()));
971	aAccessError = errorInfo;
972	}
973
974	return rc;
975	}
976
977	HRESULT Machine::getName(com::Utf8Str &aName)
978	{
979	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
980
981	aName = mUserData->s.strName;
982
983	return S_OK;
984	}
985
986	HRESULT Machine::setName(const com::Utf8Str &aName)
987	{
988	// prohibit setting a UUID only as the machine name, or else it can
989	// never be found by findMachine()
990	Guid test(aName);
991
992	if (test.isValid())
993	return setError(E_INVALIDARG, tr("A machine cannot have a UUID as its name"));
994
995	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
996
997	HRESULT rc = i_checkStateDependency(MutableStateDep);
998	if (FAILED(rc)) return rc;
999
1000	i_setModified(IsModified_MachineData);
1001	mUserData.backup();
1002	mUserData->s.strName = aName;
1003
1004	return S_OK;
1005	}
1006
1007	HRESULT Machine::getDescription(com::Utf8Str &aDescription)
1008	{
1009	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1010
1011	aDescription = mUserData->s.strDescription;
1012
1013	return S_OK;
1014	}
1015
1016	HRESULT Machine::setDescription(const com::Utf8Str &aDescription)
1017	{
1018	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1019
1020	// this can be done in principle in any state as it doesn't affect the VM
1021	// significantly, but play safe by not messing around while complex
1022	// activities are going on
1023	HRESULT rc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
1024	if (FAILED(rc)) return rc;
1025
1026	i_setModified(IsModified_MachineData);
1027	mUserData.backup();
1028	mUserData->s.strDescription = aDescription;
1029
1030	return S_OK;
1031	}
1032
1033	HRESULT Machine::getId(com::Guid &aId)
1034	{
1035	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1036
1037	aId = mData->mUuid;
1038
1039	return S_OK;
1040	}
1041
1042	HRESULT Machine::getGroups(std::vector<com::Utf8Str> &aGroups)
1043	{
1044	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1045	aGroups.resize(mUserData->s.llGroups.size());
1046	size_t i = 0;
1047	for (StringsList::const_iterator
1048	it = mUserData->s.llGroups.begin();
1049	it != mUserData->s.llGroups.end();
1050	++it, ++i)
1051	aGroups[i] = (*it);
1052
1053	return S_OK;
1054	}
1055
1056	HRESULT Machine::setGroups(const std::vector<com::Utf8Str> &aGroups)
1057	{
1058	StringsList llGroups;
1059	HRESULT rc = mParent->i_convertMachineGroups(aGroups, &llGroups);
1060	if (FAILED(rc))
1061	return rc;
1062
1063	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1064
1065	rc = i_checkStateDependency(MutableOrSavedStateDep);
1066	if (FAILED(rc)) return rc;
1067
1068	i_setModified(IsModified_MachineData);
1069	mUserData.backup();
1070	mUserData->s.llGroups = llGroups;
1071
1072	return S_OK;
1073	}
1074
1075	HRESULT Machine::getOSTypeId(com::Utf8Str &aOSTypeId)
1076	{
1077	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1078
1079	aOSTypeId = mUserData->s.strOsType;
1080
1081	return S_OK;
1082	}
1083
1084	HRESULT Machine::setOSTypeId(const com::Utf8Str &aOSTypeId)
1085	{
1086	/* look up the object by Id to check it is valid */
1087	ComObjPtr<GuestOSType> pGuestOSType;
1088	HRESULT rc = mParent->i_findGuestOSType(aOSTypeId,
1089	pGuestOSType);
1090	if (FAILED(rc)) return rc;
1091
1092	/* when setting, always use the "etalon" value for consistency -- lookup
1093	* by ID is case-insensitive and the input value may have different case */
1094	Utf8Str osTypeId = pGuestOSType->i_id();
1095
1096	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1097
1098	rc = i_checkStateDependency(MutableStateDep);
1099	if (FAILED(rc)) return rc;
1100
1101	i_setModified(IsModified_MachineData);
1102	mUserData.backup();
1103	mUserData->s.strOsType = osTypeId;
1104
1105	return S_OK;
1106	}
1107
1108	HRESULT Machine::getFirmwareType(FirmwareType_T *aFirmwareType)
1109	{
1110	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1111
1112	*aFirmwareType = mHWData->mFirmwareType;
1113
1114	return S_OK;
1115	}
1116
1117	HRESULT Machine::setFirmwareType(FirmwareType_T aFirmwareType)
1118	{
1119	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1120
1121	HRESULT rc = i_checkStateDependency(MutableStateDep);
1122	if (FAILED(rc)) return rc;
1123
1124	i_setModified(IsModified_MachineData);
1125	mHWData.backup();
1126	mHWData->mFirmwareType = aFirmwareType;
1127
1128	return S_OK;
1129	}
1130
1131	HRESULT Machine::getKeyboardHIDType(KeyboardHIDType_T *aKeyboardHIDType)
1132	{
1133	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1134
1135	*aKeyboardHIDType = mHWData->mKeyboardHIDType;
1136
1137	return S_OK;
1138	}
1139
1140	HRESULT Machine::setKeyboardHIDType(KeyboardHIDType_T aKeyboardHIDType)
1141	{
1142	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1143
1144	HRESULT rc = i_checkStateDependency(MutableStateDep);
1145	if (FAILED(rc)) return rc;
1146
1147	i_setModified(IsModified_MachineData);
1148	mHWData.backup();
1149	mHWData->mKeyboardHIDType = aKeyboardHIDType;
1150
1151	return S_OK;
1152	}
1153
1154	HRESULT Machine::getPointingHIDType(PointingHIDType_T *aPointingHIDType)
1155	{
1156	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1157
1158	*aPointingHIDType = mHWData->mPointingHIDType;
1159
1160	return S_OK;
1161	}
1162
1163	HRESULT Machine::setPointingHIDType(PointingHIDType_T aPointingHIDType)
1164	{
1165	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1166
1167	HRESULT rc = i_checkStateDependency(MutableStateDep);
1168	if (FAILED(rc)) return rc;
1169
1170	i_setModified(IsModified_MachineData);
1171	mHWData.backup();
1172	mHWData->mPointingHIDType = aPointingHIDType;
1173
1174	return S_OK;
1175	}
1176
1177	HRESULT Machine::getChipsetType(ChipsetType_T *aChipsetType)
1178	{
1179	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1180
1181	*aChipsetType = mHWData->mChipsetType;
1182
1183	return S_OK;
1184	}
1185
1186	HRESULT Machine::setChipsetType(ChipsetType_T aChipsetType)
1187	{
1188	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1189
1190	HRESULT rc = i_checkStateDependency(MutableStateDep);
1191	if (FAILED(rc)) return rc;
1192
1193	if (aChipsetType != mHWData->mChipsetType)
1194	{
1195	i_setModified(IsModified_MachineData);
1196	mHWData.backup();
1197	mHWData->mChipsetType = aChipsetType;
1198
1199	// Resize network adapter array, to be finalized on commit/rollback.
1200	// We must not throw away entries yet, otherwise settings are lost
1201	// without a way to roll back.
1202	size_t newCount = Global::getMaxNetworkAdapters(aChipsetType);
1203	size_t oldCount = mNetworkAdapters.size();
1204	if (newCount > oldCount)
1205	{
1206	mNetworkAdapters.resize(newCount);
1207	for (size_t slot = oldCount; slot < mNetworkAdapters.size(); slot++)
1208	{
1209	unconst(mNetworkAdapters[slot]).createObject();
1210	mNetworkAdapters[slot]->init(this, (ULONG)slot);
1211	}
1212	}
1213	}
1214
1215	return S_OK;
1216	}
1217
1218	HRESULT Machine::getParavirtDebug(com::Utf8Str &aParavirtDebug)
1219	{
1220	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1221
1222	aParavirtDebug = mHWData->mParavirtDebug;
1223	return S_OK;
1224	}
1225
1226	HRESULT Machine::setParavirtDebug(const com::Utf8Str &aParavirtDebug)
1227	{
1228	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1229
1230	HRESULT rc = i_checkStateDependency(MutableStateDep);
1231	if (FAILED(rc)) return rc;
1232
1233	/** @todo Parse/validate options? */
1234	if (aParavirtDebug != mHWData->mParavirtDebug)
1235	{
1236	i_setModified(IsModified_MachineData);
1237	mHWData.backup();
1238	mHWData->mParavirtDebug = aParavirtDebug;
1239	}
1240
1241	return S_OK;
1242	}
1243
1244	HRESULT Machine::getParavirtProvider(ParavirtProvider_T *aParavirtProvider)
1245	{
1246	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1247
1248	*aParavirtProvider = mHWData->mParavirtProvider;
1249
1250	return S_OK;
1251	}
1252
1253	HRESULT Machine::setParavirtProvider(ParavirtProvider_T aParavirtProvider)
1254	{
1255	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1256
1257	HRESULT rc = i_checkStateDependency(MutableStateDep);
1258	if (FAILED(rc)) return rc;
1259
1260	if (aParavirtProvider != mHWData->mParavirtProvider)
1261	{
1262	i_setModified(IsModified_MachineData);
1263	mHWData.backup();
1264	mHWData->mParavirtProvider = aParavirtProvider;
1265	}
1266
1267	return S_OK;
1268	}
1269
1270	HRESULT Machine::getEffectiveParavirtProvider(ParavirtProvider_T *aParavirtProvider)
1271	{
1272	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1273
1274	*aParavirtProvider = mHWData->mParavirtProvider;
1275	switch (mHWData->mParavirtProvider)
1276	{
1277	case ParavirtProvider_None:
1278	case ParavirtProvider_HyperV:
1279	case ParavirtProvider_KVM:
1280	case ParavirtProvider_Minimal:
1281	break;
1282
1283	/* Resolve dynamic provider types to the effective types. */
1284	default:
1285	{
1286	ComObjPtr<GuestOSType> pGuestOSType;
1287	HRESULT hrc2 = mParent->i_findGuestOSType(mUserData->s.strOsType,
1288	pGuestOSType);
1289	AssertMsgReturn(SUCCEEDED(hrc2), ("Failed to get guest OS type. hrc2=%Rhrc\n", hrc2), hrc2);
1290
1291	Utf8Str guestTypeFamilyId = pGuestOSType->i_familyId();
1292	bool fOsXGuest = guestTypeFamilyId == "MacOS";
1293
1294	switch (mHWData->mParavirtProvider)
1295	{
1296	case ParavirtProvider_Legacy:
1297	{
1298	if (fOsXGuest)
1299	*aParavirtProvider = ParavirtProvider_Minimal;
1300	else
1301	*aParavirtProvider = ParavirtProvider_None;
1302	break;
1303	}
1304
1305	case ParavirtProvider_Default:
1306	{
1307	if (fOsXGuest)
1308	*aParavirtProvider = ParavirtProvider_Minimal;
1309	else if ( mUserData->s.strOsType == "Windows10"
1310	\|\| mUserData->s.strOsType == "Windows10_64"
1311	\|\| mUserData->s.strOsType == "Windows81"
1312	\|\| mUserData->s.strOsType == "Windows81_64"
1313	\|\| mUserData->s.strOsType == "Windows8"
1314	\|\| mUserData->s.strOsType == "Windows8_64"
1315	\|\| mUserData->s.strOsType == "Windows7"
1316	\|\| mUserData->s.strOsType == "Windows7_64"
1317	\|\| mUserData->s.strOsType == "WindowsVista"
1318	\|\| mUserData->s.strOsType == "WindowsVista_64"
1319	\|\| mUserData->s.strOsType == "Windows2012"
1320	\|\| mUserData->s.strOsType == "Windows2012_64"
1321	\|\| mUserData->s.strOsType == "Windows2008"
1322	\|\| mUserData->s.strOsType == "Windows2008_64")
1323	{
1324	*aParavirtProvider = ParavirtProvider_HyperV;
1325	}
1326	else if ( mUserData->s.strOsType == "Linux26" // Linux22 and Linux24 omitted as they're too old
1327	\|\| mUserData->s.strOsType == "Linux26_64" // for having any KVM paravirtualization support.
1328	\|\| mUserData->s.strOsType == "Linux"
1329	\|\| mUserData->s.strOsType == "Linux_64"
1330	\|\| mUserData->s.strOsType == "ArchLinux"
1331	\|\| mUserData->s.strOsType == "ArchLinux_64"
1332	\|\| mUserData->s.strOsType == "Debian"
1333	\|\| mUserData->s.strOsType == "Debian_64"
1334	\|\| mUserData->s.strOsType == "Fedora"
1335	\|\| mUserData->s.strOsType == "Fedora_64"
1336	\|\| mUserData->s.strOsType == "Gentoo"
1337	\|\| mUserData->s.strOsType == "Gentoo_64"
1338	\|\| mUserData->s.strOsType == "Mandriva"
1339	\|\| mUserData->s.strOsType == "Mandriva_64"
1340	\|\| mUserData->s.strOsType == "OpenSUSE"
1341	\|\| mUserData->s.strOsType == "OpenSUSE_64"
1342	\|\| mUserData->s.strOsType == "Oracle"
1343	\|\| mUserData->s.strOsType == "Oracle_64"
1344	\|\| mUserData->s.strOsType == "RedHat"
1345	\|\| mUserData->s.strOsType == "RedHat_64"
1346	\|\| mUserData->s.strOsType == "Turbolinux"
1347	\|\| mUserData->s.strOsType == "Turbolinux_64"
1348	\|\| mUserData->s.strOsType == "Ubuntu"
1349	\|\| mUserData->s.strOsType == "Ubuntu_64"
1350	\|\| mUserData->s.strOsType == "Xandros"
1351	\|\| mUserData->s.strOsType == "Xandros_64")
1352	{
1353	*aParavirtProvider = ParavirtProvider_KVM;
1354	}
1355	else
1356	*aParavirtProvider = ParavirtProvider_None;
1357	break;
1358	}
1359
1360	default: AssertFailedBreak(); /* Shut up MSC. */
1361	}
1362	break;
1363	}
1364	}
1365
1366	Assert( *aParavirtProvider == ParavirtProvider_None
1367	\|\| *aParavirtProvider == ParavirtProvider_Minimal
1368	\|\| *aParavirtProvider == ParavirtProvider_HyperV
1369	\|\| *aParavirtProvider == ParavirtProvider_KVM);
1370	return S_OK;
1371	}
1372
1373	HRESULT Machine::getHardwareVersion(com::Utf8Str &aHardwareVersion)
1374	{
1375	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1376
1377	aHardwareVersion = mHWData->mHWVersion;
1378
1379	return S_OK;
1380	}
1381
1382	HRESULT Machine::setHardwareVersion(const com::Utf8Str &aHardwareVersion)
1383	{
1384	/* check known version */
1385	Utf8Str hwVersion = aHardwareVersion;
1386	if ( hwVersion.compare("1") != 0
1387	&& hwVersion.compare("2") != 0) // VBox 2.1.x and later (VMMDev heap)
1388	return setError(E_INVALIDARG,
1389	tr("Invalid hardware version: %s\n"), aHardwareVersion.c_str());
1390
1391	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1392
1393	HRESULT rc = i_checkStateDependency(MutableStateDep);
1394	if (FAILED(rc)) return rc;
1395
1396	i_setModified(IsModified_MachineData);
1397	mHWData.backup();
1398	mHWData->mHWVersion = aHardwareVersion;
1399
1400	return S_OK;
1401	}
1402
1403	HRESULT Machine::getHardwareUUID(com::Guid &aHardwareUUID)
1404	{
1405	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1406
1407	if (!mHWData->mHardwareUUID.isZero())
1408	aHardwareUUID = mHWData->mHardwareUUID;
1409	else
1410	aHardwareUUID = mData->mUuid;
1411
1412	return S_OK;
1413	}
1414
1415	HRESULT Machine::setHardwareUUID(const com::Guid &aHardwareUUID)
1416	{
1417	if (!aHardwareUUID.isValid())
1418	return E_INVALIDARG;
1419
1420	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1421
1422	HRESULT rc = i_checkStateDependency(MutableStateDep);
1423	if (FAILED(rc)) return rc;
1424
1425	i_setModified(IsModified_MachineData);
1426	mHWData.backup();
1427	if (aHardwareUUID == mData->mUuid)
1428	mHWData->mHardwareUUID.clear();
1429	else
1430	mHWData->mHardwareUUID = aHardwareUUID;
1431
1432	return S_OK;
1433	}
1434
1435	HRESULT Machine::getMemorySize(ULONG *aMemorySize)
1436	{
1437	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1438
1439	*aMemorySize = mHWData->mMemorySize;
1440
1441	return S_OK;
1442	}
1443
1444	HRESULT Machine::setMemorySize(ULONG aMemorySize)
1445	{
1446	/* check RAM limits */
1447	if ( aMemorySize < MM_RAM_MIN_IN_MB
1448	\|\| aMemorySize > MM_RAM_MAX_IN_MB
1449	)
1450	return setError(E_INVALIDARG,
1451	tr("Invalid RAM size: %lu MB (must be in range [%lu, %lu] MB)"),
1452	aMemorySize, MM_RAM_MIN_IN_MB, MM_RAM_MAX_IN_MB);
1453
1454	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1455
1456	HRESULT rc = i_checkStateDependency(MutableStateDep);
1457	if (FAILED(rc)) return rc;
1458
1459	i_setModified(IsModified_MachineData);
1460	mHWData.backup();
1461	mHWData->mMemorySize = aMemorySize;
1462
1463	return S_OK;
1464	}
1465
1466	HRESULT Machine::getCPUCount(ULONG *aCPUCount)
1467	{
1468	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1469
1470	*aCPUCount = mHWData->mCPUCount;
1471
1472	return S_OK;
1473	}
1474
1475	HRESULT Machine::setCPUCount(ULONG aCPUCount)
1476	{
1477	/* check CPU limits */
1478	if ( aCPUCount < SchemaDefs::MinCPUCount
1479	\|\| aCPUCount > SchemaDefs::MaxCPUCount
1480	)
1481	return setError(E_INVALIDARG,
1482	tr("Invalid virtual CPU count: %lu (must be in range [%lu, %lu])"),
1483	aCPUCount, SchemaDefs::MinCPUCount, SchemaDefs::MaxCPUCount);
1484
1485	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1486
1487	/* We cant go below the current number of CPUs attached if hotplug is enabled*/
1488	if (mHWData->mCPUHotPlugEnabled)
1489	{
1490	for (unsigned idx = aCPUCount; idx < SchemaDefs::MaxCPUCount; idx++)
1491	{
1492	if (mHWData->mCPUAttached[idx])
1493	return setError(E_INVALIDARG,
1494	tr("There is still a CPU attached to socket %lu."
1495	"Detach the CPU before removing the socket"),
1496	aCPUCount, idx+1);
1497	}
1498	}
1499
1500	HRESULT rc = i_checkStateDependency(MutableStateDep);
1501	if (FAILED(rc)) return rc;
1502
1503	i_setModified(IsModified_MachineData);
1504	mHWData.backup();
1505	mHWData->mCPUCount = aCPUCount;
1506
1507	return S_OK;
1508	}
1509
1510	HRESULT Machine::getCPUExecutionCap(ULONG *aCPUExecutionCap)
1511	{
1512	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1513
1514	*aCPUExecutionCap = mHWData->mCpuExecutionCap;
1515
1516	return S_OK;
1517	}
1518
1519	HRESULT Machine::setCPUExecutionCap(ULONG aCPUExecutionCap)
1520	{
1521	HRESULT rc = S_OK;
1522
1523	/* check throttle limits */
1524	if ( aCPUExecutionCap < 1
1525	\|\| aCPUExecutionCap > 100
1526	)
1527	return setError(E_INVALIDARG,
1528	tr("Invalid CPU execution cap value: %lu (must be in range [%lu, %lu])"),
1529	aCPUExecutionCap, 1, 100);
1530
1531	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1532
1533	alock.release();
1534	rc = i_onCPUExecutionCapChange(aCPUExecutionCap);
1535	alock.acquire();
1536	if (FAILED(rc)) return rc;
1537
1538	i_setModified(IsModified_MachineData);
1539	mHWData.backup();
1540	mHWData->mCpuExecutionCap = aCPUExecutionCap;
1541
1542	/** Save settings if online - @todo why is this required? -- @bugref{6818} */
1543	if (Global::IsOnline(mData->mMachineState))
1544	i_saveSettings(NULL);
1545
1546	return S_OK;
1547	}
1548
1549	HRESULT Machine::getCPUHotPlugEnabled(BOOL *aCPUHotPlugEnabled)
1550	{
1551	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1552
1553	*aCPUHotPlugEnabled = mHWData->mCPUHotPlugEnabled;
1554
1555	return S_OK;
1556	}
1557
1558	HRESULT Machine::setCPUHotPlugEnabled(BOOL aCPUHotPlugEnabled)
1559	{
1560	HRESULT rc = S_OK;
1561
1562	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1563
1564	rc = i_checkStateDependency(MutableStateDep);
1565	if (FAILED(rc)) return rc;
1566
1567	if (mHWData->mCPUHotPlugEnabled != aCPUHotPlugEnabled)
1568	{
1569	if (aCPUHotPlugEnabled)
1570	{
1571	i_setModified(IsModified_MachineData);
1572	mHWData.backup();
1573
1574	/* Add the amount of CPUs currently attached */
1575	for (unsigned i = 0; i < mHWData->mCPUCount; ++i)
1576	mHWData->mCPUAttached[i] = true;
1577	}
1578	else
1579	{
1580	/*
1581	* We can disable hotplug only if the amount of maximum CPUs is equal
1582	* to the amount of attached CPUs
1583	*/
1584	unsigned cCpusAttached = 0;
1585	unsigned iHighestId = 0;
1586
1587	for (unsigned i = 0; i < SchemaDefs::MaxCPUCount; ++i)
1588	{
1589	if (mHWData->mCPUAttached[i])
1590	{
1591	cCpusAttached++;
1592	iHighestId = i;
1593	}
1594	}
1595
1596	if ( (cCpusAttached != mHWData->mCPUCount)
1597	\|\| (iHighestId >= mHWData->mCPUCount))
1598	return setError(E_INVALIDARG,
1599	tr("CPU hotplugging can't be disabled because the maximum number of CPUs is not equal to the amount of CPUs attached"));
1600
1601	i_setModified(IsModified_MachineData);
1602	mHWData.backup();
1603	}
1604	}
1605
1606	mHWData->mCPUHotPlugEnabled = aCPUHotPlugEnabled;
1607
1608	return rc;
1609	}
1610
1611	HRESULT Machine::getCPUIDPortabilityLevel(ULONG *aCPUIDPortabilityLevel)
1612	{
1613	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1614
1615	*aCPUIDPortabilityLevel = mHWData->mCpuIdPortabilityLevel;
1616
1617	return S_OK;
1618	}
1619
1620	HRESULT Machine::setCPUIDPortabilityLevel(ULONG aCPUIDPortabilityLevel)
1621	{
1622	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1623
1624	HRESULT hrc = i_checkStateDependency(MutableStateDep);
1625	if (SUCCEEDED(hrc))
1626	{
1627	i_setModified(IsModified_MachineData);
1628	mHWData.backup();
1629	mHWData->mCpuIdPortabilityLevel = aCPUIDPortabilityLevel;
1630	}
1631	return hrc;
1632	}
1633
1634	HRESULT Machine::getCPUProfile(com::Utf8Str &aCPUProfile)
1635	{
1636	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1637	aCPUProfile = mHWData->mCpuProfile;
1638	return S_OK;
1639	}
1640
1641	HRESULT Machine::setCPUProfile(const com::Utf8Str &aCPUProfile)
1642	{
1643	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1644	HRESULT hrc = i_checkStateDependency(MutableStateDep);
1645	if (SUCCEEDED(hrc))
1646	{
1647	i_setModified(IsModified_MachineData);
1648	mHWData.backup();
1649	/* Empty equals 'host'. */
1650	if (aCPUProfile.isNotEmpty())
1651	mHWData->mCpuProfile = aCPUProfile;
1652	else
1653	mHWData->mCpuProfile = "host";
1654	}
1655	return hrc;
1656	}
1657
1658	HRESULT Machine::getEmulatedUSBCardReaderEnabled(BOOL *aEmulatedUSBCardReaderEnabled)
1659	{
1660	#ifdef VBOX_WITH_USB_CARDREADER
1661	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1662
1663	*aEmulatedUSBCardReaderEnabled = mHWData->mEmulatedUSBCardReaderEnabled;
1664
1665	return S_OK;
1666	#else
1667	NOREF(aEmulatedUSBCardReaderEnabled);
1668	return E_NOTIMPL;
1669	#endif
1670	}
1671
1672	HRESULT Machine::setEmulatedUSBCardReaderEnabled(BOOL aEmulatedUSBCardReaderEnabled)
1673	{
1674	#ifdef VBOX_WITH_USB_CARDREADER
1675	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1676
1677	HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
1678	if (FAILED(rc)) return rc;
1679
1680	i_setModified(IsModified_MachineData);
1681	mHWData.backup();
1682	mHWData->mEmulatedUSBCardReaderEnabled = aEmulatedUSBCardReaderEnabled;
1683
1684	return S_OK;
1685	#else
1686	NOREF(aEmulatedUSBCardReaderEnabled);
1687	return E_NOTIMPL;
1688	#endif
1689	}
1690
1691	HRESULT Machine::getHPETEnabled(BOOL *aHPETEnabled)
1692	{
1693	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1694
1695	*aHPETEnabled = mHWData->mHPETEnabled;
1696
1697	return S_OK;
1698	}
1699
1700	HRESULT Machine::setHPETEnabled(BOOL aHPETEnabled)
1701	{
1702	HRESULT rc = S_OK;
1703
1704	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1705
1706	rc = i_checkStateDependency(MutableStateDep);
1707	if (FAILED(rc)) return rc;
1708
1709	i_setModified(IsModified_MachineData);
1710	mHWData.backup();
1711
1712	mHWData->mHPETEnabled = aHPETEnabled;
1713
1714	return rc;
1715	}
1716
1717	HRESULT Machine::getVideoCaptureEnabled(BOOL *aVideoCaptureEnabled)
1718	{
1719	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1720
1721	*aVideoCaptureEnabled = mHWData->mVideoCaptureEnabled;
1722	return S_OK;
1723	}
1724
1725	HRESULT Machine::setVideoCaptureEnabled(BOOL aVideoCaptureEnabled)
1726	{
1727	HRESULT rc = S_OK;
1728
1729	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1730
1731	i_setModified(IsModified_MachineData);
1732	mHWData.backup();
1733	mHWData->mVideoCaptureEnabled = aVideoCaptureEnabled;
1734
1735	alock.release();
1736	rc = i_onVideoCaptureChange();
1737	alock.acquire();
1738	if (FAILED(rc))
1739	{
1740	/*
1741	* Normally we would do the actual change _after_ i_onVideoCaptureChange() succeeded.
1742	* We cannot do this because that function uses Machine::GetVideoCaptureEnabled to
1743	* determine if it should start or stop capturing. Therefore we need to manually
1744	* undo change.
1745	*/
1746	mHWData->mVideoCaptureEnabled = mHWData.backedUpData()->mVideoCaptureEnabled;
1747	return rc;
1748	}
1749
1750	/** Save settings if online - @todo why is this required? -- @bugref{6818} */
1751	if (Global::IsOnline(mData->mMachineState))
1752	i_saveSettings(NULL);
1753
1754	return rc;
1755	}
1756
1757	HRESULT Machine::getVideoCaptureScreens(std::vector<BOOL> &aVideoCaptureScreens)
1758	{
1759	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1760	aVideoCaptureScreens.resize(mHWData->mMonitorCount);
1761	for (unsigned i = 0; i < mHWData->mMonitorCount; ++i)
1762	aVideoCaptureScreens[i] = mHWData->maVideoCaptureScreens[i];
1763	return S_OK;
1764	}
1765
1766	HRESULT Machine::setVideoCaptureScreens(const std::vector<BOOL> &aVideoCaptureScreens)
1767	{
1768	AssertReturn(aVideoCaptureScreens.size() <= RT_ELEMENTS(mHWData->maVideoCaptureScreens), E_INVALIDARG);
1769	bool fChanged = false;
1770
1771	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1772
1773	for (unsigned i = 0; i < aVideoCaptureScreens.size(); ++i)
1774	{
1775	if (mHWData->maVideoCaptureScreens[i] != RT_BOOL(aVideoCaptureScreens[i]))
1776	{
1777	mHWData->maVideoCaptureScreens[i] = RT_BOOL(aVideoCaptureScreens[i]);
1778	fChanged = true;
1779	}
1780	}
1781	if (fChanged)
1782	{
1783	alock.release();
1784	HRESULT rc = i_onVideoCaptureChange();
1785	alock.acquire();
1786	if (FAILED(rc)) return rc;
1787	i_setModified(IsModified_MachineData);
1788
1789	/** Save settings if online - @todo why is this required? -- @bugref{6818} */
1790	if (Global::IsOnline(mData->mMachineState))
1791	i_saveSettings(NULL);
1792	}
1793
1794	return S_OK;
1795	}
1796
1797	HRESULT Machine::getVideoCaptureFile(com::Utf8Str &aVideoCaptureFile)
1798	{
1799	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1800	if (mHWData->mVideoCaptureFile.isEmpty())
1801	i_getDefaultVideoCaptureFile(aVideoCaptureFile);
1802	else
1803	aVideoCaptureFile = mHWData->mVideoCaptureFile;
1804	return S_OK;
1805	}
1806
1807	HRESULT Machine::setVideoCaptureFile(const com::Utf8Str &aVideoCaptureFile)
1808	{
1809	Utf8Str strFile(aVideoCaptureFile);
1810	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1811
1812	if ( Global::IsOnline(mData->mMachineState)
1813	&& mHWData->mVideoCaptureEnabled)
1814	return setError(E_INVALIDARG, tr("Cannot change parameters while capturing is enabled"));
1815
1816	if (!RTPathStartsWithRoot(strFile.c_str()))
1817	return setError(E_INVALIDARG, tr("Video capture file name '%s' is not absolute"), strFile.c_str());
1818
1819	if (!strFile.isEmpty())
1820	{
1821	Utf8Str defaultFile;
1822	i_getDefaultVideoCaptureFile(defaultFile);
1823	if (!RTPathCompare(strFile.c_str(), defaultFile.c_str()))
1824	strFile.setNull();
1825	}
1826
1827	i_setModified(IsModified_MachineData);
1828	mHWData.backup();
1829	mHWData->mVideoCaptureFile = strFile;
1830
1831	return S_OK;
1832	}
1833
1834	HRESULT Machine::getVideoCaptureWidth(ULONG *aVideoCaptureWidth)
1835	{
1836	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1837	*aVideoCaptureWidth = mHWData->mVideoCaptureWidth;
1838	return S_OK;
1839	}
1840
1841	HRESULT Machine::setVideoCaptureWidth(ULONG aVideoCaptureWidth)
1842	{
1843	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1844
1845	if ( Global::IsOnline(mData->mMachineState)
1846	&& mHWData->mVideoCaptureEnabled)
1847	return setError(E_INVALIDARG, tr("Cannot change parameters while capturing is enabled"));
1848
1849	i_setModified(IsModified_MachineData);
1850	mHWData.backup();
1851	mHWData->mVideoCaptureWidth = aVideoCaptureWidth;
1852
1853	return S_OK;
1854	}
1855
1856	HRESULT Machine::getVideoCaptureHeight(ULONG *aVideoCaptureHeight)
1857	{
1858	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1859	*aVideoCaptureHeight = mHWData->mVideoCaptureHeight;
1860	return S_OK;
1861	}
1862
1863	HRESULT Machine::setVideoCaptureHeight(ULONG aVideoCaptureHeight)
1864	{
1865	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1866
1867	if ( Global::IsOnline(mData->mMachineState)
1868	&& mHWData->mVideoCaptureEnabled)
1869	return setError(E_INVALIDARG, tr("Cannot change parameters while capturing is enabled"));
1870
1871	i_setModified(IsModified_MachineData);
1872	mHWData.backup();
1873	mHWData->mVideoCaptureHeight = aVideoCaptureHeight;
1874
1875	return S_OK;
1876	}
1877
1878	HRESULT Machine::getVideoCaptureRate(ULONG *aVideoCaptureRate)
1879	{
1880	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1881	*aVideoCaptureRate = mHWData->mVideoCaptureRate;
1882	return S_OK;
1883	}
1884
1885	HRESULT Machine::setVideoCaptureRate(ULONG aVideoCaptureRate)
1886	{
1887	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1888
1889	if ( Global::IsOnline(mData->mMachineState)
1890	&& mHWData->mVideoCaptureEnabled)
1891	return setError(E_INVALIDARG, tr("Cannot change parameters while capturing is enabled"));
1892
1893	i_setModified(IsModified_MachineData);
1894	mHWData.backup();
1895	mHWData->mVideoCaptureRate = aVideoCaptureRate;
1896
1897	return S_OK;
1898	}
1899
1900	HRESULT Machine::getVideoCaptureFPS(ULONG *aVideoCaptureFPS)
1901	{
1902	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1903	*aVideoCaptureFPS = mHWData->mVideoCaptureFPS;
1904	return S_OK;
1905	}
1906
1907	HRESULT Machine::setVideoCaptureFPS(ULONG aVideoCaptureFPS)
1908	{
1909	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1910
1911	if ( Global::IsOnline(mData->mMachineState)
1912	&& mHWData->mVideoCaptureEnabled)
1913	return setError(E_INVALIDARG, tr("Cannot change parameters while capturing is enabled"));
1914
1915	i_setModified(IsModified_MachineData);
1916	mHWData.backup();
1917	mHWData->mVideoCaptureFPS = aVideoCaptureFPS;
1918
1919	return S_OK;
1920	}
1921
1922	HRESULT Machine::getVideoCaptureMaxTime(ULONG *aVideoCaptureMaxTime)
1923	{
1924	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1925	*aVideoCaptureMaxTime = mHWData->mVideoCaptureMaxTime;
1926	return S_OK;
1927	}
1928
1929	HRESULT Machine::setVideoCaptureMaxTime(ULONG aVideoCaptureMaxTime)
1930	{
1931	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1932
1933	if ( Global::IsOnline(mData->mMachineState)
1934	&& mHWData->mVideoCaptureEnabled)
1935	return setError(E_INVALIDARG, tr("Cannot change parameters while capturing is enabled"));
1936
1937	i_setModified(IsModified_MachineData);
1938	mHWData.backup();
1939	mHWData->mVideoCaptureMaxTime = aVideoCaptureMaxTime;
1940
1941	return S_OK;
1942	}
1943
1944	HRESULT Machine::getVideoCaptureMaxFileSize(ULONG *aVideoCaptureMaxFileSize)
1945	{
1946	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1947	*aVideoCaptureMaxFileSize = mHWData->mVideoCaptureMaxFileSize;
1948	return S_OK;
1949	}
1950
1951	HRESULT Machine::setVideoCaptureMaxFileSize(ULONG aVideoCaptureMaxFileSize)
1952	{
1953	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1954
1955	if ( Global::IsOnline(mData->mMachineState)
1956	&& mHWData->mVideoCaptureEnabled)
1957	return setError(E_INVALIDARG, tr("Cannot change parameters while capturing is enabled"));
1958
1959	i_setModified(IsModified_MachineData);
1960	mHWData.backup();
1961	mHWData->mVideoCaptureMaxFileSize = aVideoCaptureMaxFileSize;
1962
1963	return S_OK;
1964	}
1965
1966	HRESULT Machine::getVideoCaptureOptions(com::Utf8Str &aVideoCaptureOptions)
1967	{
1968	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1969
1970	aVideoCaptureOptions = mHWData->mVideoCaptureOptions;
1971	return S_OK;
1972	}
1973
1974	HRESULT Machine::setVideoCaptureOptions(const com::Utf8Str &aVideoCaptureOptions)
1975	{
1976	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1977
1978	if ( Global::IsOnline(mData->mMachineState)
1979	&& mHWData->mVideoCaptureEnabled)
1980	return setError(E_INVALIDARG, tr("Cannot change parameters while capturing is enabled"));
1981
1982	i_setModified(IsModified_MachineData);
1983	mHWData.backup();
1984	mHWData->mVideoCaptureOptions = aVideoCaptureOptions;
1985
1986	return S_OK;
1987	}
1988
1989	HRESULT Machine::getGraphicsControllerType(GraphicsControllerType_T *aGraphicsControllerType)
1990	{
1991	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1992
1993	*aGraphicsControllerType = mHWData->mGraphicsControllerType;
1994
1995	return S_OK;
1996	}
1997
1998	HRESULT Machine::setGraphicsControllerType(GraphicsControllerType_T aGraphicsControllerType)
1999	{
2000	switch (aGraphicsControllerType)
2001	{
2002	case GraphicsControllerType_Null:
2003	case GraphicsControllerType_VBoxVGA:
2004	#ifdef VBOX_WITH_VMSVGA
2005	case GraphicsControllerType_VMSVGA:
2006	#endif
2007	break;
2008	default:
2009	return setError(E_INVALIDARG, tr("The graphics controller type (%d) is invalid"), aGraphicsControllerType);
2010	}
2011
2012	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2013
2014	HRESULT rc = i_checkStateDependency(MutableStateDep);
2015	if (FAILED(rc)) return rc;
2016
2017	i_setModified(IsModified_MachineData);
2018	mHWData.backup();
2019	mHWData->mGraphicsControllerType = aGraphicsControllerType;
2020
2021	return S_OK;
2022	}
2023
2024	HRESULT Machine::getVRAMSize(ULONG *aVRAMSize)
2025	{
2026	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2027
2028	*aVRAMSize = mHWData->mVRAMSize;
2029
2030	return S_OK;
2031	}
2032
2033	HRESULT Machine::setVRAMSize(ULONG aVRAMSize)
2034	{
2035	/* check VRAM limits */
2036	if (aVRAMSize > SchemaDefs::MaxGuestVRAM)
2037	return setError(E_INVALIDARG,
2038	tr("Invalid VRAM size: %lu MB (must be in range [%lu, %lu] MB)"),
2039	aVRAMSize, SchemaDefs::MinGuestVRAM, SchemaDefs::MaxGuestVRAM);
2040
2041	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2042
2043	HRESULT rc = i_checkStateDependency(MutableStateDep);
2044	if (FAILED(rc)) return rc;
2045
2046	i_setModified(IsModified_MachineData);
2047	mHWData.backup();
2048	mHWData->mVRAMSize = aVRAMSize;
2049
2050	return S_OK;
2051	}
2052
2053	/** @todo this method should not be public */
2054	HRESULT Machine::getMemoryBalloonSize(ULONG *aMemoryBalloonSize)
2055	{
2056	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2057
2058	*aMemoryBalloonSize = mHWData->mMemoryBalloonSize;
2059
2060	return S_OK;
2061	}
2062
2063	/**
2064	* Set the memory balloon size.
2065	*
2066	* This method is also called from IGuest::COMSETTER(MemoryBalloonSize) so
2067	* we have to make sure that we never call IGuest from here.
2068	*/
2069	HRESULT Machine::setMemoryBalloonSize(ULONG aMemoryBalloonSize)
2070	{
2071	/* This must match GMMR0Init; currently we only support memory ballooning on all 64-bit hosts except Mac OS X */
2072	#if HC_ARCH_BITS == 64 && (defined(RT_OS_WINDOWS) \|\| defined(RT_OS_SOLARIS) \|\| defined(RT_OS_LINUX) \|\| defined(RT_OS_FREEBSD))
2073	/* check limits */
2074	if (aMemoryBalloonSize >= VMMDEV_MAX_MEMORY_BALLOON(mHWData->mMemorySize))
2075	return setError(E_INVALIDARG,
2076	tr("Invalid memory balloon size: %lu MB (must be in range [%lu, %lu] MB)"),
2077	aMemoryBalloonSize, 0, VMMDEV_MAX_MEMORY_BALLOON(mHWData->mMemorySize));
2078
2079	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2080
2081	i_setModified(IsModified_MachineData);
2082	mHWData.backup();
2083	mHWData->mMemoryBalloonSize = aMemoryBalloonSize;
2084
2085	return S_OK;
2086	#else
2087	NOREF(aMemoryBalloonSize);
2088	return setError(E_NOTIMPL, tr("Memory ballooning is only supported on 64-bit hosts"));
2089	#endif
2090	}
2091
2092	HRESULT Machine::getPageFusionEnabled(BOOL *aPageFusionEnabled)
2093	{
2094	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2095
2096	*aPageFusionEnabled = mHWData->mPageFusionEnabled;
2097	return S_OK;
2098	}
2099
2100	HRESULT Machine::setPageFusionEnabled(BOOL aPageFusionEnabled)
2101	{
2102	#ifdef VBOX_WITH_PAGE_SHARING
2103	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2104
2105	/** @todo must support changes for running vms and keep this in sync with IGuest. */
2106	i_setModified(IsModified_MachineData);
2107	mHWData.backup();
2108	mHWData->mPageFusionEnabled = aPageFusionEnabled;
2109	return S_OK;
2110	#else
2111	NOREF(aPageFusionEnabled);
2112	return setError(E_NOTIMPL, tr("Page fusion is only supported on 64-bit hosts"));
2113	#endif
2114	}
2115
2116	HRESULT Machine::getAccelerate3DEnabled(BOOL *aAccelerate3DEnabled)
2117	{
2118	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2119
2120	*aAccelerate3DEnabled = mHWData->mAccelerate3DEnabled;
2121
2122	return S_OK;
2123	}
2124
2125	HRESULT Machine::setAccelerate3DEnabled(BOOL aAccelerate3DEnabled)
2126	{
2127	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2128
2129	HRESULT rc = i_checkStateDependency(MutableStateDep);
2130	if (FAILED(rc)) return rc;
2131
2132	/** @todo check validity! */
2133
2134	i_setModified(IsModified_MachineData);
2135	mHWData.backup();
2136	mHWData->mAccelerate3DEnabled = aAccelerate3DEnabled;
2137
2138	return S_OK;
2139	}
2140
2141
2142	HRESULT Machine::getAccelerate2DVideoEnabled(BOOL *aAccelerate2DVideoEnabled)
2143	{
2144	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2145
2146	*aAccelerate2DVideoEnabled = mHWData->mAccelerate2DVideoEnabled;
2147
2148	return S_OK;
2149	}
2150
2151	HRESULT Machine::setAccelerate2DVideoEnabled(BOOL aAccelerate2DVideoEnabled)
2152	{
2153	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2154
2155	HRESULT rc = i_checkStateDependency(MutableStateDep);
2156	if (FAILED(rc)) return rc;
2157
2158	/** @todo check validity! */
2159	i_setModified(IsModified_MachineData);
2160	mHWData.backup();
2161	mHWData->mAccelerate2DVideoEnabled = aAccelerate2DVideoEnabled;
2162
2163	return S_OK;
2164	}
2165
2166	HRESULT Machine::getMonitorCount(ULONG *aMonitorCount)
2167	{
2168	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2169
2170	*aMonitorCount = mHWData->mMonitorCount;
2171
2172	return S_OK;
2173	}
2174
2175	HRESULT Machine::setMonitorCount(ULONG aMonitorCount)
2176	{
2177	/* make sure monitor count is a sensible number */
2178	if (aMonitorCount < 1 \|\| aMonitorCount > SchemaDefs::MaxGuestMonitors)
2179	return setError(E_INVALIDARG,
2180	tr("Invalid monitor count: %lu (must be in range [%lu, %lu])"),
2181	aMonitorCount, 1, SchemaDefs::MaxGuestMonitors);
2182
2183	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2184
2185	HRESULT rc = i_checkStateDependency(MutableStateDep);
2186	if (FAILED(rc)) return rc;
2187
2188	i_setModified(IsModified_MachineData);
2189	mHWData.backup();
2190	mHWData->mMonitorCount = aMonitorCount;
2191
2192	return S_OK;
2193	}
2194
2195	HRESULT Machine::getBIOSSettings(ComPtr<IBIOSSettings> &aBIOSSettings)
2196	{
2197	/* mBIOSSettings is constant during life time, no need to lock */
2198	aBIOSSettings = mBIOSSettings;
2199
2200	return S_OK;
2201	}
2202
2203	HRESULT Machine::getCPUProperty(CPUPropertyType_T aProperty, BOOL *aValue)
2204	{
2205	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2206
2207	switch (aProperty)
2208	{
2209	case CPUPropertyType_PAE:
2210	*aValue = mHWData->mPAEEnabled;
2211	break;
2212
2213	case CPUPropertyType_LongMode:
2214	if (mHWData->mLongMode == settings::Hardware::LongMode_Enabled)
2215	*aValue = TRUE;
2216	else if (mHWData->mLongMode == settings::Hardware::LongMode_Disabled)
2217	*aValue = FALSE;
2218	#if HC_ARCH_BITS == 64
2219	else
2220	*aValue = TRUE;
2221	#else
2222	else
2223	{
2224	*aValue = FALSE;
2225
2226	ComObjPtr<GuestOSType> pGuestOSType;
2227	HRESULT hrc2 = mParent->i_findGuestOSType(mUserData->s.strOsType,
2228	pGuestOSType);
2229	if (SUCCEEDED(hrc2))
2230	{
2231	if (pGuestOSType->i_is64Bit())
2232	{
2233	ComObjPtr<Host> pHost = mParent->i_host();
2234	alock.release();
2235
2236	hrc2 = pHost->GetProcessorFeature(ProcessorFeature_LongMode, aValue); AssertComRC(hrc2);
2237	if (FAILED(hrc2))
2238	*aValue = FALSE;
2239	}
2240	}
2241	}
2242	#endif
2243	break;
2244
2245	case CPUPropertyType_TripleFaultReset:
2246	*aValue = mHWData->mTripleFaultReset;
2247	break;
2248
2249	case CPUPropertyType_APIC:
2250	*aValue = mHWData->mAPIC;
2251	break;
2252
2253	case CPUPropertyType_X2APIC:
2254	*aValue = mHWData->mX2APIC;
2255	break;
2256
2257	default:
2258	return E_INVALIDARG;
2259	}
2260	return S_OK;
2261	}
2262
2263	HRESULT Machine::setCPUProperty(CPUPropertyType_T aProperty, BOOL aValue)
2264	{
2265	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2266
2267	HRESULT rc = i_checkStateDependency(MutableStateDep);
2268	if (FAILED(rc)) return rc;
2269
2270	switch (aProperty)
2271	{
2272	case CPUPropertyType_PAE:
2273	i_setModified(IsModified_MachineData);
2274	mHWData.backup();
2275	mHWData->mPAEEnabled = !!aValue;
2276	break;
2277
2278	case CPUPropertyType_LongMode:
2279	i_setModified(IsModified_MachineData);
2280	mHWData.backup();
2281	mHWData->mLongMode = !aValue ? settings::Hardware::LongMode_Disabled : settings::Hardware::LongMode_Enabled;
2282	break;
2283
2284	case CPUPropertyType_TripleFaultReset:
2285	i_setModified(IsModified_MachineData);
2286	mHWData.backup();
2287	mHWData->mTripleFaultReset = !!aValue;
2288	break;
2289
2290	case CPUPropertyType_APIC:
2291	if (mHWData->mX2APIC)
2292	aValue = TRUE;
2293	i_setModified(IsModified_MachineData);
2294	mHWData.backup();
2295	mHWData->mAPIC = !!aValue;
2296	break;
2297
2298	case CPUPropertyType_X2APIC:
2299	i_setModified(IsModified_MachineData);
2300	mHWData.backup();
2301	mHWData->mX2APIC = !!aValue;
2302	if (aValue)
2303	mHWData->mAPIC = !!aValue;
2304	break;
2305
2306	default:
2307	return E_INVALIDARG;
2308	}
2309	return S_OK;
2310	}
2311
2312	HRESULT Machine::getCPUIDLeafByOrdinal(ULONG aOrdinal, ULONG aIdx, ULONG aSubIdx, ULONG aValEax, ULONG aValEbx,
2313	ULONG aValEcx, ULONG aValEdx)
2314	{
2315	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2316	if (aOrdinal < mHWData->mCpuIdLeafList.size())
2317	{
2318	for (settings::CpuIdLeafsList::const_iterator it = mHWData->mCpuIdLeafList.begin();
2319	it != mHWData->mCpuIdLeafList.end();
2320	++it)
2321	{
2322	if (aOrdinal == 0)
2323	{
2324	const settings::CpuIdLeaf &rLeaf= *it;
2325	*aIdx = rLeaf.idx;
2326	*aSubIdx = rLeaf.idxSub;
2327	*aValEax = rLeaf.uEax;
2328	*aValEbx = rLeaf.uEbx;
2329	*aValEcx = rLeaf.uEcx;
2330	*aValEdx = rLeaf.uEdx;
2331	return S_OK;
2332	}
2333	aOrdinal--;
2334	}
2335	}
2336	return E_INVALIDARG;
2337	}
2338
2339	HRESULT Machine::getCPUIDLeaf(ULONG aIdx, ULONG aSubIdx, ULONG aValEax, ULONG aValEbx, ULONG aValEcx, ULONG aValEdx)
2340	{
2341	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2342
2343	/*
2344	* Search the list.
2345	*/
2346	for (settings::CpuIdLeafsList::const_iterator it = mHWData->mCpuIdLeafList.begin(); it != mHWData->mCpuIdLeafList.end(); ++it)
2347	{
2348	const settings::CpuIdLeaf &rLeaf= *it;
2349	if ( rLeaf.idx == aIdx
2350	&& ( aSubIdx == UINT32_MAX
2351	\|\| rLeaf.idxSub == aSubIdx) )
2352	{
2353	*aValEax = rLeaf.uEax;
2354	*aValEbx = rLeaf.uEbx;
2355	*aValEcx = rLeaf.uEcx;
2356	*aValEdx = rLeaf.uEdx;
2357	return S_OK;
2358	}
2359	}
2360
2361	return E_INVALIDARG;
2362	}
2363
2364
2365	HRESULT Machine::setCPUIDLeaf(ULONG aIdx, ULONG aSubIdx, ULONG aValEax, ULONG aValEbx, ULONG aValEcx, ULONG aValEdx)
2366	{
2367	/*
2368	* Validate input before taking locks and checking state.
2369	*/
2370	if (aSubIdx != 0 && aSubIdx != UINT32_MAX)
2371	return setError(E_INVALIDARG, tr("Currently only aSubIdx values 0 and 0xffffffff are supported: %#x"), aSubIdx);
2372	if ( aIdx >= UINT32_C(0x20)
2373	&& aIdx - UINT32_C(0x80000000) >= UINT32_C(0x20)
2374	&& aIdx - UINT32_C(0xc0000000) >= UINT32_C(0x10) )
2375	return setError(E_INVALIDARG, tr("CpuId override leaf %#x is out of range"), aIdx);
2376
2377	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2378	HRESULT rc = i_checkStateDependency(MutableStateDep);
2379	if (FAILED(rc)) return rc;
2380
2381	/*
2382	* Impose a maximum number of leaves.
2383	*/
2384	if (mHWData->mCpuIdLeafList.size() > 256)
2385	return setError(E_FAIL, tr("Max of 256 CPUID override leaves reached"));
2386
2387	/*
2388	* Updating the list is a bit more complicated. So, let's do a remove first followed by an insert.
2389	*/
2390	i_setModified(IsModified_MachineData);
2391	mHWData.backup();
2392
2393	for (settings::CpuIdLeafsList::iterator it = mHWData->mCpuIdLeafList.begin(); it != mHWData->mCpuIdLeafList.end(); )
2394	{
2395	settings::CpuIdLeaf &rLeaf= *it;
2396	if ( rLeaf.idx == aIdx
2397	&& ( aSubIdx == UINT32_MAX
2398	\|\| rLeaf.idxSub == aSubIdx) )
2399	it = mHWData->mCpuIdLeafList.erase(it);
2400	else
2401	++it;
2402	}
2403
2404	settings::CpuIdLeaf NewLeaf;
2405	NewLeaf.idx = aIdx;
2406	NewLeaf.idxSub = aSubIdx == UINT32_MAX ? 0 : aSubIdx;
2407	NewLeaf.uEax = aValEax;
2408	NewLeaf.uEbx = aValEbx;
2409	NewLeaf.uEcx = aValEcx;
2410	NewLeaf.uEdx = aValEdx;
2411	mHWData->mCpuIdLeafList.push_back(NewLeaf);
2412	return S_OK;
2413	}
2414
2415	HRESULT Machine::removeCPUIDLeaf(ULONG aIdx, ULONG aSubIdx)
2416	{
2417	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2418
2419	HRESULT rc = i_checkStateDependency(MutableStateDep);
2420	if (FAILED(rc)) return rc;
2421
2422	/*
2423	* Do the removal.
2424	*/
2425	bool fModified = false;
2426	for (settings::CpuIdLeafsList::iterator it = mHWData->mCpuIdLeafList.begin(); it != mHWData->mCpuIdLeafList.end(); )
2427	{
2428	settings::CpuIdLeaf &rLeaf= *it;
2429	if ( rLeaf.idx == aIdx
2430	&& ( aSubIdx == UINT32_MAX
2431	\|\| rLeaf.idxSub == aSubIdx) )
2432	{
2433	if (!fModified)
2434	{
2435	fModified = true;
2436	i_setModified(IsModified_MachineData);
2437	mHWData.backup();
2438	}
2439	it = mHWData->mCpuIdLeafList.erase(it);
2440	}
2441	else
2442	++it;
2443	}
2444
2445	return S_OK;
2446	}
2447
2448	HRESULT Machine::removeAllCPUIDLeaves()
2449	{
2450	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2451
2452	HRESULT rc = i_checkStateDependency(MutableStateDep);
2453	if (FAILED(rc)) return rc;
2454
2455	if (mHWData->mCpuIdLeafList.size() > 0)
2456	{
2457	i_setModified(IsModified_MachineData);
2458	mHWData.backup();
2459
2460	mHWData->mCpuIdLeafList.clear();
2461	}
2462
2463	return S_OK;
2464	}
2465	HRESULT Machine::getHWVirtExProperty(HWVirtExPropertyType_T aProperty, BOOL *aValue)
2466	{
2467	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2468
2469	switch(aProperty)
2470	{
2471	case HWVirtExPropertyType_Enabled:
2472	*aValue = mHWData->mHWVirtExEnabled;
2473	break;
2474
2475	case HWVirtExPropertyType_VPID:
2476	*aValue = mHWData->mHWVirtExVPIDEnabled;
2477	break;
2478
2479	case HWVirtExPropertyType_NestedPaging:
2480	*aValue = mHWData->mHWVirtExNestedPagingEnabled;
2481	break;
2482
2483	case HWVirtExPropertyType_UnrestrictedExecution:
2484	*aValue = mHWData->mHWVirtExUXEnabled;
2485	break;
2486
2487	case HWVirtExPropertyType_LargePages:
2488	*aValue = mHWData->mHWVirtExLargePagesEnabled;
2489	#if defined(DEBUG_bird) && defined(RT_OS_LINUX) /* This feature is deadly here */
2490	*aValue = FALSE;
2491	#endif
2492	break;
2493
2494	case HWVirtExPropertyType_Force:
2495	*aValue = mHWData->mHWVirtExForceEnabled;
2496	break;
2497
2498	default:
2499	return E_INVALIDARG;
2500	}
2501	return S_OK;
2502	}
2503
2504	HRESULT Machine::setHWVirtExProperty(HWVirtExPropertyType_T aProperty, BOOL aValue)
2505	{
2506	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2507
2508	HRESULT rc = i_checkStateDependency(MutableStateDep);
2509	if (FAILED(rc)) return rc;
2510
2511	switch(aProperty)
2512	{
2513	case HWVirtExPropertyType_Enabled:
2514	i_setModified(IsModified_MachineData);
2515	mHWData.backup();
2516	mHWData->mHWVirtExEnabled = !!aValue;
2517	break;
2518
2519	case HWVirtExPropertyType_VPID:
2520	i_setModified(IsModified_MachineData);
2521	mHWData.backup();
2522	mHWData->mHWVirtExVPIDEnabled = !!aValue;
2523	break;
2524
2525	case HWVirtExPropertyType_NestedPaging:
2526	i_setModified(IsModified_MachineData);
2527	mHWData.backup();
2528	mHWData->mHWVirtExNestedPagingEnabled = !!aValue;
2529	break;
2530
2531	case HWVirtExPropertyType_UnrestrictedExecution:
2532	i_setModified(IsModified_MachineData);
2533	mHWData.backup();
2534	mHWData->mHWVirtExUXEnabled = !!aValue;
2535	break;
2536
2537	case HWVirtExPropertyType_LargePages:
2538	i_setModified(IsModified_MachineData);
2539	mHWData.backup();
2540	mHWData->mHWVirtExLargePagesEnabled = !!aValue;
2541	break;
2542
2543	case HWVirtExPropertyType_Force:
2544	i_setModified(IsModified_MachineData);
2545	mHWData.backup();
2546	mHWData->mHWVirtExForceEnabled = !!aValue;
2547	break;
2548
2549	default:
2550	return E_INVALIDARG;
2551	}
2552
2553	return S_OK;
2554	}
2555
2556	HRESULT Machine::getSnapshotFolder(com::Utf8Str &aSnapshotFolder)
2557	{
2558	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2559
2560	i_calculateFullPath(mUserData->s.strSnapshotFolder, aSnapshotFolder);
2561
2562	return S_OK;
2563	}
2564
2565	HRESULT Machine::setSnapshotFolder(const com::Utf8Str &aSnapshotFolder)
2566	{
2567	/** @todo (r=dmik):
2568	* 1. Allow to change the name of the snapshot folder containing snapshots
2569	* 2. Rename the folder on disk instead of just changing the property
2570	* value (to be smart and not to leave garbage). Note that it cannot be
2571	* done here because the change may be rolled back. Thus, the right
2572	* place is #saveSettings().
2573	*/
2574
2575	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2576
2577	HRESULT rc = i_checkStateDependency(MutableStateDep);
2578	if (FAILED(rc)) return rc;
2579
2580	if (!mData->mCurrentSnapshot.isNull())
2581	return setError(E_FAIL,
2582	tr("The snapshot folder of a machine with snapshots cannot be changed (please delete all snapshots first)"));
2583
2584	Utf8Str strSnapshotFolder(aSnapshotFolder); // keep original
2585
2586	if (strSnapshotFolder.isEmpty())
2587	strSnapshotFolder = "Snapshots";
2588	int vrc = i_calculateFullPath(strSnapshotFolder,
2589	strSnapshotFolder);
2590	if (RT_FAILURE(vrc))
2591	return setError(E_FAIL,
2592	tr("Invalid snapshot folder '%s' (%Rrc)"),
2593	strSnapshotFolder.c_str(), vrc);
2594
2595	i_setModified(IsModified_MachineData);
2596	mUserData.backup();
2597
2598	i_copyPathRelativeToMachine(strSnapshotFolder, mUserData->s.strSnapshotFolder);
2599
2600	return S_OK;
2601	}
2602
2603	HRESULT Machine::getMediumAttachments(std::vector<ComPtr<IMediumAttachment> > &aMediumAttachments)
2604	{
2605	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2606
2607	aMediumAttachments.resize(mMediumAttachments->size());
2608	size_t i = 0;
2609	for (MediumAttachmentList::const_iterator
2610	it = mMediumAttachments->begin();
2611	it != mMediumAttachments->end();
2612	++it, ++i)
2613	aMediumAttachments[i] = *it;
2614
2615	return S_OK;
2616	}
2617
2618	HRESULT Machine::getVRDEServer(ComPtr<IVRDEServer> &aVRDEServer)
2619	{
2620	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2621
2622	Assert(!!mVRDEServer);
2623
2624	aVRDEServer = mVRDEServer;
2625
2626	return S_OK;
2627	}
2628
2629	HRESULT Machine::getAudioAdapter(ComPtr<IAudioAdapter> &aAudioAdapter)
2630	{
2631	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2632
2633	aAudioAdapter = mAudioAdapter;
2634
2635	return S_OK;
2636	}
2637
2638	HRESULT Machine::getUSBControllers(std::vector<ComPtr<IUSBController> > &aUSBControllers)
2639	{
2640	#ifdef VBOX_WITH_VUSB
2641	clearError();
2642	MultiResult rc(S_OK);
2643
2644	# ifdef VBOX_WITH_USB
2645	rc = mParent->i_host()->i_checkUSBProxyService();
2646	if (FAILED(rc)) return rc;
2647	# endif
2648
2649	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2650
2651	aUSBControllers.resize(mUSBControllers->size());
2652	size_t i = 0;
2653	for (USBControllerList::const_iterator
2654	it = mUSBControllers->begin();
2655	it != mUSBControllers->end();
2656	++it, ++i)
2657	aUSBControllers[i] = *it;
2658
2659	return S_OK;
2660	#else
2661	/* Note: The GUI depends on this method returning E_NOTIMPL with no
2662	* extended error info to indicate that USB is simply not available
2663	* (w/o treating it as a failure), for example, as in OSE */
2664	NOREF(aUSBControllers);
2665	ReturnComNotImplemented();
2666	#endif /* VBOX_WITH_VUSB */
2667	}
2668
2669	HRESULT Machine::getUSBDeviceFilters(ComPtr<IUSBDeviceFilters> &aUSBDeviceFilters)
2670	{
2671	#ifdef VBOX_WITH_VUSB
2672	clearError();
2673	MultiResult rc(S_OK);
2674
2675	# ifdef VBOX_WITH_USB
2676	rc = mParent->i_host()->i_checkUSBProxyService();
2677	if (FAILED(rc)) return rc;
2678	# endif
2679
2680	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2681
2682	aUSBDeviceFilters = mUSBDeviceFilters;
2683	return rc;
2684	#else
2685	/* Note: The GUI depends on this method returning E_NOTIMPL with no
2686	* extended error info to indicate that USB is simply not available
2687	* (w/o treating it as a failure), for example, as in OSE */
2688	NOREF(aUSBDeviceFilters);
2689	ReturnComNotImplemented();
2690	#endif /* VBOX_WITH_VUSB */
2691	}
2692
2693	HRESULT Machine::getSettingsFilePath(com::Utf8Str &aSettingsFilePath)
2694	{
2695	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2696
2697	aSettingsFilePath = mData->m_strConfigFileFull;
2698
2699	return S_OK;
2700	}
2701
2702	HRESULT Machine::getSettingsAuxFilePath(com::Utf8Str &aSettingsFilePath)
2703	{
2704	RT_NOREF(aSettingsFilePath);
2705	ReturnComNotImplemented();
2706	}
2707
2708	HRESULT Machine::getSettingsModified(BOOL *aSettingsModified)
2709	{
2710	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2711
2712	HRESULT rc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
2713	if (FAILED(rc)) return rc;
2714
2715	if (!mData->pMachineConfigFile->fileExists())
2716	// this is a new machine, and no config file exists yet:
2717	*aSettingsModified = TRUE;
2718	else
2719	*aSettingsModified = (mData->flModifications != 0);
2720
2721	return S_OK;
2722	}
2723
2724	HRESULT Machine::getSessionState(SessionState_T *aSessionState)
2725	{
2726	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2727
2728	*aSessionState = mData->mSession.mState;
2729
2730	return S_OK;
2731	}
2732
2733	HRESULT Machine::getSessionName(com::Utf8Str &aSessionName)
2734	{
2735	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2736
2737	aSessionName = mData->mSession.mName;
2738
2739	return S_OK;
2740	}
2741
2742	HRESULT Machine::getSessionPID(ULONG *aSessionPID)
2743	{
2744	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2745
2746	*aSessionPID = mData->mSession.mPID;
2747
2748	return S_OK;
2749	}
2750
2751	HRESULT Machine::getState(MachineState_T *aState)
2752	{
2753	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2754
2755	*aState = mData->mMachineState;
2756	Assert(mData->mMachineState != MachineState_Null);
2757
2758	return S_OK;
2759	}
2760
2761	HRESULT Machine::getLastStateChange(LONG64 *aLastStateChange)
2762	{
2763	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2764
2765	*aLastStateChange = RTTimeSpecGetMilli(&mData->mLastStateChange);
2766
2767	return S_OK;
2768	}
2769
2770	HRESULT Machine::getStateFilePath(com::Utf8Str &aStateFilePath)
2771	{
2772	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2773
2774	aStateFilePath = mSSData->strStateFilePath;
2775
2776	return S_OK;
2777	}
2778
2779	HRESULT Machine::getLogFolder(com::Utf8Str &aLogFolder)
2780	{
2781	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2782
2783	i_getLogFolder(aLogFolder);
2784
2785	return S_OK;
2786	}
2787
2788	HRESULT Machine::getCurrentSnapshot(ComPtr<ISnapshot> &aCurrentSnapshot)
2789	{
2790	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2791
2792	aCurrentSnapshot = mData->mCurrentSnapshot;
2793
2794	return S_OK;
2795	}
2796
2797	HRESULT Machine::getSnapshotCount(ULONG *aSnapshotCount)
2798	{
2799	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2800
2801	*aSnapshotCount = mData->mFirstSnapshot.isNull()
2802	? 0
2803	: mData->mFirstSnapshot->i_getAllChildrenCount() + 1;
2804
2805	return S_OK;
2806	}
2807
2808	HRESULT Machine::getCurrentStateModified(BOOL *aCurrentStateModified)
2809	{
2810	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2811
2812	/* Note: for machines with no snapshots, we always return FALSE
2813	* (mData->mCurrentStateModified will be TRUE in this case, for historical
2814	* reasons :) */
2815
2816	*aCurrentStateModified = mData->mFirstSnapshot.isNull()
2817	? FALSE
2818	: mData->mCurrentStateModified;
2819
2820	return S_OK;
2821	}
2822
2823	HRESULT Machine::getSharedFolders(std::vector<ComPtr<ISharedFolder> > &aSharedFolders)
2824	{
2825	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2826
2827	aSharedFolders.resize(mHWData->mSharedFolders.size());
2828	size_t i = 0;
2829	for (std::list<ComObjPtr<SharedFolder> >::const_iterator
2830	it = mHWData->mSharedFolders.begin();
2831	it != mHWData->mSharedFolders.end();
2832	++it, ++i)
2833	aSharedFolders[i] = *it;
2834
2835	return S_OK;
2836	}
2837
2838	HRESULT Machine::getClipboardMode(ClipboardMode_T *aClipboardMode)
2839	{
2840	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2841
2842	*aClipboardMode = mHWData->mClipboardMode;
2843
2844	return S_OK;
2845	}
2846
2847	HRESULT Machine::setClipboardMode(ClipboardMode_T aClipboardMode)
2848	{
2849	HRESULT rc = S_OK;
2850
2851	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2852
2853	alock.release();
2854	rc = i_onClipboardModeChange(aClipboardMode);
2855	alock.acquire();
2856	if (FAILED(rc)) return rc;
2857
2858	i_setModified(IsModified_MachineData);
2859	mHWData.backup();
2860	mHWData->mClipboardMode = aClipboardMode;
2861
2862	/** Save settings if online - @todo why is this required? -- @bugref{6818} */
2863	if (Global::IsOnline(mData->mMachineState))
2864	i_saveSettings(NULL);
2865
2866	return S_OK;
2867	}
2868
2869	HRESULT Machine::getDnDMode(DnDMode_T *aDnDMode)
2870	{
2871	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2872
2873	*aDnDMode = mHWData->mDnDMode;
2874
2875	return S_OK;
2876	}
2877
2878	HRESULT Machine::setDnDMode(DnDMode_T aDnDMode)
2879	{
2880	HRESULT rc = S_OK;
2881
2882	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2883
2884	alock.release();
2885	rc = i_onDnDModeChange(aDnDMode);
2886
2887	alock.acquire();
2888	if (FAILED(rc)) return rc;
2889
2890	i_setModified(IsModified_MachineData);
2891	mHWData.backup();
2892	mHWData->mDnDMode = aDnDMode;
2893
2894	/** Save settings if online - @todo why is this required? -- @bugref{6818} */
2895	if (Global::IsOnline(mData->mMachineState))
2896	i_saveSettings(NULL);
2897
2898	return S_OK;
2899	}
2900
2901	HRESULT Machine::getStorageControllers(std::vector<ComPtr<IStorageController> > &aStorageControllers)
2902	{
2903	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2904
2905	aStorageControllers.resize(mStorageControllers->size());
2906	size_t i = 0;
2907	for (StorageControllerList::const_iterator
2908	it = mStorageControllers->begin();
2909	it != mStorageControllers->end();
2910	++it, ++i)
2911	aStorageControllers[i] = *it;
2912
2913	return S_OK;
2914	}
2915
2916	HRESULT Machine::getTeleporterEnabled(BOOL *aEnabled)
2917	{
2918	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2919
2920	*aEnabled = mUserData->s.fTeleporterEnabled;
2921
2922	return S_OK;
2923	}
2924
2925	HRESULT Machine::setTeleporterEnabled(BOOL aTeleporterEnabled)
2926	{
2927	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2928
2929	/* Only allow it to be set to true when PoweredOff or Aborted.
2930	(Clearing it is always permitted.) */
2931	if ( aTeleporterEnabled
2932	&& mData->mRegistered
2933	&& ( !i_isSessionMachine()
2934	\|\| ( mData->mMachineState != MachineState_PoweredOff
2935	&& mData->mMachineState != MachineState_Teleported
2936	&& mData->mMachineState != MachineState_Aborted
2937	)
2938	)
2939	)
2940	return setError(VBOX_E_INVALID_VM_STATE,
2941	tr("The machine is not powered off (state is %s)"),
2942	Global::stringifyMachineState(mData->mMachineState));
2943
2944	i_setModified(IsModified_MachineData);
2945	mUserData.backup();
2946	mUserData->s.fTeleporterEnabled = !! aTeleporterEnabled;
2947
2948	return S_OK;
2949	}
2950
2951	HRESULT Machine::getTeleporterPort(ULONG *aTeleporterPort)
2952	{
2953	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2954
2955	*aTeleporterPort = (ULONG)mUserData->s.uTeleporterPort;
2956
2957	return S_OK;
2958	}
2959
2960	HRESULT Machine::setTeleporterPort(ULONG aTeleporterPort)
2961	{
2962	if (aTeleporterPort >= _64K)
2963	return setError(E_INVALIDARG, tr("Invalid port number %d"), aTeleporterPort);
2964
2965	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2966
2967	HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
2968	if (FAILED(rc)) return rc;
2969
2970	i_setModified(IsModified_MachineData);
2971	mUserData.backup();
2972	mUserData->s.uTeleporterPort = (uint32_t)aTeleporterPort;
2973
2974	return S_OK;
2975	}
2976
2977	HRESULT Machine::getTeleporterAddress(com::Utf8Str &aTeleporterAddress)
2978	{
2979	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2980
2981	aTeleporterAddress = mUserData->s.strTeleporterAddress;
2982
2983	return S_OK;
2984	}
2985
2986	HRESULT Machine::setTeleporterAddress(const com::Utf8Str &aTeleporterAddress)
2987	{
2988	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2989
2990	HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
2991	if (FAILED(rc)) return rc;
2992
2993	i_setModified(IsModified_MachineData);
2994	mUserData.backup();
2995	mUserData->s.strTeleporterAddress = aTeleporterAddress;
2996
2997	return S_OK;
2998	}
2999
3000	HRESULT Machine::getTeleporterPassword(com::Utf8Str &aTeleporterPassword)
3001	{
3002	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3003	aTeleporterPassword = mUserData->s.strTeleporterPassword;
3004
3005	return S_OK;
3006	}
3007
3008	HRESULT Machine::setTeleporterPassword(const com::Utf8Str &aTeleporterPassword)
3009	{
3010	/*
3011	* Hash the password first.
3012	*/
3013	com::Utf8Str aT = aTeleporterPassword;
3014
3015	if (!aT.isEmpty())
3016	{
3017	if (VBoxIsPasswordHashed(&aT))
3018	return setError(E_INVALIDARG, tr("Cannot set an already hashed password, only plain text password please"));
3019	VBoxHashPassword(&aT);
3020	}
3021
3022	/*
3023	* Do the update.
3024	*/
3025	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3026	HRESULT hrc = i_checkStateDependency(MutableOrSavedStateDep);
3027	if (SUCCEEDED(hrc))
3028	{
3029	i_setModified(IsModified_MachineData);
3030	mUserData.backup();
3031	mUserData->s.strTeleporterPassword = aT;
3032	}
3033
3034	return hrc;
3035	}
3036
3037	HRESULT Machine::getFaultToleranceState(FaultToleranceState_T *aFaultToleranceState)
3038	{
3039	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3040
3041	*aFaultToleranceState = mUserData->s.enmFaultToleranceState;
3042	return S_OK;
3043	}
3044
3045	HRESULT Machine::setFaultToleranceState(FaultToleranceState_T aFaultToleranceState)
3046	{
3047	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3048
3049	/** @todo deal with running state change. */
3050	HRESULT rc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
3051	if (FAILED(rc)) return rc;
3052
3053	i_setModified(IsModified_MachineData);
3054	mUserData.backup();
3055	mUserData->s.enmFaultToleranceState = aFaultToleranceState;
3056	return S_OK;
3057	}
3058
3059	HRESULT Machine::getFaultToleranceAddress(com::Utf8Str &aFaultToleranceAddress)
3060	{
3061	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3062
3063	aFaultToleranceAddress = mUserData->s.strFaultToleranceAddress;
3064	return S_OK;
3065	}
3066
3067	HRESULT Machine::setFaultToleranceAddress(const com::Utf8Str &aFaultToleranceAddress)
3068	{
3069	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3070
3071	/** @todo deal with running state change. */
3072	HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
3073	if (FAILED(rc)) return rc;
3074
3075	i_setModified(IsModified_MachineData);
3076	mUserData.backup();
3077	mUserData->s.strFaultToleranceAddress = aFaultToleranceAddress;
3078	return S_OK;
3079	}
3080
3081	HRESULT Machine::getFaultTolerancePort(ULONG *aFaultTolerancePort)
3082	{
3083	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3084
3085	*aFaultTolerancePort = mUserData->s.uFaultTolerancePort;
3086	return S_OK;
3087	}
3088
3089	HRESULT Machine::setFaultTolerancePort(ULONG aFaultTolerancePort)
3090	{
3091	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3092
3093	/** @todo deal with running state change. */
3094	HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
3095	if (FAILED(rc)) return rc;
3096
3097	i_setModified(IsModified_MachineData);
3098	mUserData.backup();
3099	mUserData->s.uFaultTolerancePort = aFaultTolerancePort;
3100	return S_OK;
3101	}
3102
3103	HRESULT Machine::getFaultTolerancePassword(com::Utf8Str &aFaultTolerancePassword)
3104	{
3105	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3106
3107	aFaultTolerancePassword = mUserData->s.strFaultTolerancePassword;
3108
3109	return S_OK;
3110	}
3111
3112	HRESULT Machine::setFaultTolerancePassword(const com::Utf8Str &aFaultTolerancePassword)
3113	{
3114	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3115
3116	/** @todo deal with running state change. */
3117	HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
3118	if (FAILED(rc)) return rc;
3119
3120	i_setModified(IsModified_MachineData);
3121	mUserData.backup();
3122	mUserData->s.strFaultTolerancePassword = aFaultTolerancePassword;
3123
3124	return S_OK;
3125	}
3126
3127	HRESULT Machine::getFaultToleranceSyncInterval(ULONG *aFaultToleranceSyncInterval)
3128	{
3129	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3130
3131	*aFaultToleranceSyncInterval = mUserData->s.uFaultToleranceInterval;
3132	return S_OK;
3133	}
3134
3135	HRESULT Machine::setFaultToleranceSyncInterval(ULONG aFaultToleranceSyncInterval)
3136	{
3137	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3138
3139	/** @todo deal with running state change. */
3140	HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
3141	if (FAILED(rc)) return rc;
3142
3143	i_setModified(IsModified_MachineData);
3144	mUserData.backup();
3145	mUserData->s.uFaultToleranceInterval = aFaultToleranceSyncInterval;
3146	return S_OK;
3147	}
3148
3149	HRESULT Machine::getRTCUseUTC(BOOL *aRTCUseUTC)
3150	{
3151	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3152
3153	*aRTCUseUTC = mUserData->s.fRTCUseUTC;
3154
3155	return S_OK;
3156	}
3157
3158	HRESULT Machine::setRTCUseUTC(BOOL aRTCUseUTC)
3159	{
3160	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3161
3162	/* Only allow it to be set to true when PoweredOff or Aborted.
3163	(Clearing it is always permitted.) */
3164	if ( aRTCUseUTC
3165	&& mData->mRegistered
3166	&& ( !i_isSessionMachine()
3167	\|\| ( mData->mMachineState != MachineState_PoweredOff
3168	&& mData->mMachineState != MachineState_Teleported
3169	&& mData->mMachineState != MachineState_Aborted
3170	)
3171	)
3172	)
3173	return setError(VBOX_E_INVALID_VM_STATE,
3174	tr("The machine is not powered off (state is %s)"),
3175	Global::stringifyMachineState(mData->mMachineState));
3176
3177	i_setModified(IsModified_MachineData);
3178	mUserData.backup();
3179	mUserData->s.fRTCUseUTC = !!aRTCUseUTC;
3180
3181	return S_OK;
3182	}
3183
3184	HRESULT Machine::getIOCacheEnabled(BOOL *aIOCacheEnabled)
3185	{
3186	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3187
3188	*aIOCacheEnabled = mHWData->mIOCacheEnabled;
3189
3190	return S_OK;
3191	}
3192
3193	HRESULT Machine::setIOCacheEnabled(BOOL aIOCacheEnabled)
3194	{
3195	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3196
3197	HRESULT rc = i_checkStateDependency(MutableStateDep);
3198	if (FAILED(rc)) return rc;
3199
3200	i_setModified(IsModified_MachineData);
3201	mHWData.backup();
3202	mHWData->mIOCacheEnabled = aIOCacheEnabled;
3203
3204	return S_OK;
3205	}
3206
3207	HRESULT Machine::getIOCacheSize(ULONG *aIOCacheSize)
3208	{
3209	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3210
3211	*aIOCacheSize = mHWData->mIOCacheSize;
3212
3213	return S_OK;
3214	}
3215
3216	HRESULT Machine::setIOCacheSize(ULONG aIOCacheSize)
3217	{
3218	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3219
3220	HRESULT rc = i_checkStateDependency(MutableStateDep);
3221	if (FAILED(rc)) return rc;
3222
3223	i_setModified(IsModified_MachineData);
3224	mHWData.backup();
3225	mHWData->mIOCacheSize = aIOCacheSize;
3226
3227	return S_OK;
3228	}
3229
3230
3231	/**
3232	* @note Locks objects!
3233	*/
3234	HRESULT Machine::lockMachine(const ComPtr<ISession> &aSession,
3235	LockType_T aLockType)
3236	{
3237	/* check the session state */
3238	SessionState_T state;
3239	HRESULT rc = aSession->COMGETTER(State)(&state);
3240	if (FAILED(rc)) return rc;
3241
3242	if (state != SessionState_Unlocked)
3243	return setError(VBOX_E_INVALID_OBJECT_STATE,
3244	tr("The given session is busy"));
3245
3246	// get the client's IInternalSessionControl interface
3247	ComPtr<IInternalSessionControl> pSessionControl = aSession;
3248	ComAssertMsgRet(!!pSessionControl, ("No IInternalSessionControl interface"),
3249	E_INVALIDARG);
3250
3251	// session name (only used in some code paths)
3252	Utf8Str strSessionName;
3253
3254	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3255
3256	if (!mData->mRegistered)
3257	return setError(E_UNEXPECTED,
3258	tr("The machine '%s' is not registered"),
3259	mUserData->s.strName.c_str());
3260
3261	LogFlowThisFunc(("mSession.mState=%s\n", Global::stringifySessionState(mData->mSession.mState)));
3262
3263	SessionState_T oldState = mData->mSession.mState;
3264	/* Hack: in case the session is closing and there is a progress object
3265	* which allows waiting for the session to be closed, take the opportunity
3266	* and do a limited wait (max. 1 second). This helps a lot when the system
3267	* is busy and thus session closing can take a little while. */
3268	if ( mData->mSession.mState == SessionState_Unlocking
3269	&& mData->mSession.mProgress)
3270	{
3271	alock.release();
3272	mData->mSession.mProgress->WaitForCompletion(1000);
3273	alock.acquire();
3274	LogFlowThisFunc(("after waiting: mSession.mState=%s\n", Global::stringifySessionState(mData->mSession.mState)));
3275	}
3276
3277	// try again now
3278	if ( (mData->mSession.mState == SessionState_Locked) // machine is write-locked already
3279	// (i.e. session machine exists)
3280	&& (aLockType == LockType_Shared) // caller wants a shared link to the
3281	// existing session that holds the write lock:
3282	)
3283	{
3284	// OK, share the session... we are now dealing with three processes:
3285	// 1) VBoxSVC (where this code runs);
3286	// 2) process C: the caller's client process (who wants a shared session);
3287	// 3) process W: the process which already holds the write lock on the machine (write-locking session)
3288
3289	// copy pointers to W (the write-locking session) before leaving lock (these must not be NULL)
3290	ComPtr<IInternalSessionControl> pSessionW = mData->mSession.mDirectControl;
3291	ComAssertRet(!pSessionW.isNull(), E_FAIL);
3292	ComObjPtr<SessionMachine> pSessionMachine = mData->mSession.mMachine;
3293	AssertReturn(!pSessionMachine.isNull(), E_FAIL);
3294
3295	/*
3296	* Release the lock before calling the client process. It's safe here
3297	* since the only thing to do after we get the lock again is to add
3298	* the remote control to the list (which doesn't directly influence
3299	* anything).
3300	*/
3301	alock.release();
3302
3303	// get the console of the session holding the write lock (this is a remote call)
3304	ComPtr<IConsole> pConsoleW;
3305	if (mData->mSession.mLockType == LockType_VM)
3306	{
3307	LogFlowThisFunc(("Calling GetRemoteConsole()...\n"));
3308	rc = pSessionW->COMGETTER(RemoteConsole)(pConsoleW.asOutParam());
3309	LogFlowThisFunc(("GetRemoteConsole() returned %08X\n", rc));
3310	if (FAILED(rc))
3311	// the failure may occur w/o any error info (from RPC), so provide one
3312	return setError(VBOX_E_VM_ERROR,
3313	tr("Failed to get a console object from the direct session (%Rhrc)"), rc);
3314	ComAssertRet(!pConsoleW.isNull(), E_FAIL);
3315	}
3316
3317	// share the session machine and W's console with the caller's session
3318	LogFlowThisFunc(("Calling AssignRemoteMachine()...\n"));
3319	rc = pSessionControl->AssignRemoteMachine(pSessionMachine, pConsoleW);
3320	LogFlowThisFunc(("AssignRemoteMachine() returned %08X\n", rc));
3321
3322	if (FAILED(rc))
3323	// the failure may occur w/o any error info (from RPC), so provide one
3324	return setError(VBOX_E_VM_ERROR,
3325	tr("Failed to assign the machine to the session (%Rhrc)"), rc);
3326	alock.acquire();
3327
3328	// need to revalidate the state after acquiring the lock again
3329	if (mData->mSession.mState != SessionState_Locked)
3330	{
3331	pSessionControl->Uninitialize();
3332	return setError(VBOX_E_INVALID_SESSION_STATE,
3333	tr("The machine '%s' was unlocked unexpectedly while attempting to share its session"),
3334	mUserData->s.strName.c_str());
3335	}
3336
3337	// add the caller's session to the list
3338	mData->mSession.mRemoteControls.push_back(pSessionControl);
3339	}
3340	else if ( mData->mSession.mState == SessionState_Locked
3341	\|\| mData->mSession.mState == SessionState_Unlocking
3342	)
3343	{
3344	// sharing not permitted, or machine still unlocking:
3345	return setError(VBOX_E_INVALID_OBJECT_STATE,
3346	tr("The machine '%s' is already locked for a session (or being unlocked)"),
3347	mUserData->s.strName.c_str());
3348	}
3349	else
3350	{
3351	// machine is not locked: then write-lock the machine (create the session machine)
3352
3353	// must not be busy
3354	AssertReturn(!Global::IsOnlineOrTransient(mData->mMachineState), E_FAIL);
3355
3356	// get the caller's session PID
3357	RTPROCESS pid = NIL_RTPROCESS;
3358	AssertCompile(sizeof(ULONG) == sizeof(RTPROCESS));
3359	pSessionControl->COMGETTER(PID)((ULONG*)&pid);
3360	Assert(pid != NIL_RTPROCESS);
3361
3362	bool fLaunchingVMProcess = (mData->mSession.mState == SessionState_Spawning);
3363
3364	if (fLaunchingVMProcess)
3365	{
3366	if (mData->mSession.mPID == NIL_RTPROCESS)
3367	{
3368	// two or more clients racing for a lock, the one which set the
3369	// session state to Spawning will win, the others will get an
3370	// error as we can't decide here if waiting a little would help
3371	// (only for shared locks this would avoid an error)
3372	return setError(VBOX_E_INVALID_OBJECT_STATE,
3373	tr("The machine '%s' already has a lock request pending"),
3374	mUserData->s.strName.c_str());
3375	}
3376
3377	// this machine is awaiting for a spawning session to be opened:
3378	// then the calling process must be the one that got started by
3379	// LaunchVMProcess()
3380
3381	LogFlowThisFunc(("mSession.mPID=%d(0x%x)\n", mData->mSession.mPID, mData->mSession.mPID));
3382	LogFlowThisFunc(("session.pid=%d(0x%x)\n", pid, pid));
3383
3384	#if defined(VBOX_WITH_HARDENING) && defined(RT_OS_WINDOWS)
3385	/* Hardened windows builds spawns three processes when a VM is
3386	launched, the 3rd one is the one that will end up here. */
3387	RTPROCESS ppid;
3388	int rc = RTProcQueryParent(pid, &ppid);
3389	if (RT_SUCCESS(rc))
3390	rc = RTProcQueryParent(ppid, &ppid);
3391	if ( (RT_SUCCESS(rc) && mData->mSession.mPID == ppid)
3392	\|\| rc == VERR_ACCESS_DENIED)
3393	{
3394	LogFlowThisFunc(("mSession.mPID => %d(%#x) - windows hardening stub\n", mData->mSession.mPID, pid));
3395	mData->mSession.mPID = pid;
3396	}
3397	#endif
3398
3399	if (mData->mSession.mPID != pid)
3400	return setError(E_ACCESSDENIED,
3401	tr("An unexpected process (PID=0x%08X) has tried to lock the "
3402	"machine '%s', while only the process started by LaunchVMProcess (PID=0x%08X) is allowed"),
3403	pid, mUserData->s.strName.c_str(), mData->mSession.mPID);
3404	}
3405
3406	// create the mutable SessionMachine from the current machine
3407	ComObjPtr<SessionMachine> sessionMachine;
3408	sessionMachine.createObject();
3409	rc = sessionMachine->init(this);
3410	AssertComRC(rc);
3411
3412	/* NOTE: doing return from this function after this point but
3413	* before the end is forbidden since it may call SessionMachine::uninit()
3414	* (through the ComObjPtr's destructor) which requests the VirtualBox write
3415	* lock while still holding the Machine lock in alock so that a deadlock
3416	* is possible due to the wrong lock order. */
3417
3418	if (SUCCEEDED(rc))
3419	{
3420	/*
3421	* Set the session state to Spawning to protect against subsequent
3422	* attempts to open a session and to unregister the machine after
3423	* we release the lock.
3424	*/
3425	SessionState_T origState = mData->mSession.mState;
3426	mData->mSession.mState = SessionState_Spawning;
3427
3428	#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
3429	/* Get the client token ID to be passed to the client process */
3430	Utf8Str strTokenId;
3431	sessionMachine->i_getTokenId(strTokenId);
3432	Assert(!strTokenId.isEmpty());
3433	#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
3434	/* Get the client token to be passed to the client process */
3435	ComPtr<IToken> pToken(sessionMachine->i_getToken());
3436	/* The token is now "owned" by pToken, fix refcount */
3437	if (!pToken.isNull())
3438	pToken->Release();
3439	#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
3440
3441	/*
3442	* Release the lock before calling the client process -- it will call
3443	* Machine/SessionMachine methods. Releasing the lock here is quite safe
3444	* because the state is Spawning, so that LaunchVMProcess() and
3445	* LockMachine() calls will fail. This method, called before we
3446	* acquire the lock again, will fail because of the wrong PID.
3447	*
3448	* Note that mData->mSession.mRemoteControls accessed outside
3449	* the lock may not be modified when state is Spawning, so it's safe.
3450	*/
3451	alock.release();
3452
3453	LogFlowThisFunc(("Calling AssignMachine()...\n"));
3454	#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
3455	rc = pSessionControl->AssignMachine(sessionMachine, aLockType, Bstr(strTokenId).raw());
3456	#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
3457	rc = pSessionControl->AssignMachine(sessionMachine, aLockType, pToken);
3458	/* Now the token is owned by the client process. */
3459	pToken.setNull();
3460	#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
3461	LogFlowThisFunc(("AssignMachine() returned %08X\n", rc));
3462
3463	/* The failure may occur w/o any error info (from RPC), so provide one */
3464	if (FAILED(rc))
3465	setError(VBOX_E_VM_ERROR,
3466	tr("Failed to assign the machine to the session (%Rhrc)"), rc);
3467
3468	// get session name, either to remember or to compare against
3469	// the already known session name.
3470	{
3471	Bstr bstrSessionName;
3472	HRESULT rc2 = aSession->COMGETTER(Name)(bstrSessionName.asOutParam());
3473	if (SUCCEEDED(rc2))
3474	strSessionName = bstrSessionName;
3475	}
3476
3477	if ( SUCCEEDED(rc)
3478	&& fLaunchingVMProcess
3479	)
3480	{
3481	/* complete the remote session initialization */
3482
3483	/* get the console from the direct session */
3484	ComPtr<IConsole> console;
3485	rc = pSessionControl->COMGETTER(RemoteConsole)(console.asOutParam());
3486	ComAssertComRC(rc);
3487
3488	if (SUCCEEDED(rc) && !console)
3489	{
3490	ComAssert(!!console);
3491	rc = E_FAIL;
3492	}
3493
3494	/* assign machine & console to the remote session */
3495	if (SUCCEEDED(rc))
3496	{
3497	/*
3498	* after LaunchVMProcess(), the first and the only
3499	* entry in remoteControls is that remote session
3500	*/
3501	LogFlowThisFunc(("Calling AssignRemoteMachine()...\n"));
3502	rc = mData->mSession.mRemoteControls.front()->AssignRemoteMachine(sessionMachine, console);
3503	LogFlowThisFunc(("AssignRemoteMachine() returned %08X\n", rc));
3504
3505	/* The failure may occur w/o any error info (from RPC), so provide one */
3506	if (FAILED(rc))
3507	setError(VBOX_E_VM_ERROR,
3508	tr("Failed to assign the machine to the remote session (%Rhrc)"), rc);
3509	}
3510
3511	if (FAILED(rc))
3512	pSessionControl->Uninitialize();
3513	}
3514
3515	/* acquire the lock again */
3516	alock.acquire();
3517
3518	/* Restore the session state */
3519	mData->mSession.mState = origState;
3520	}
3521
3522	// finalize spawning anyway (this is why we don't return on errors above)
3523	if (fLaunchingVMProcess)
3524	{
3525	Assert(mData->mSession.mName == strSessionName);
3526	/* Note that the progress object is finalized later */
3527	/** @todo Consider checking mData->mSession.mProgress for cancellation
3528	* around here. */
3529
3530	/* We don't reset mSession.mPID here because it is necessary for
3531	* SessionMachine::uninit() to reap the child process later. */
3532
3533	if (FAILED(rc))
3534	{
3535	/* Close the remote session, remove the remote control from the list
3536	* and reset session state to Closed (@note keep the code in sync
3537	* with the relevant part in checkForSpawnFailure()). */
3538
3539	Assert(mData->mSession.mRemoteControls.size() == 1);
3540	if (mData->mSession.mRemoteControls.size() == 1)
3541	{
3542	ErrorInfoKeeper eik;
3543	mData->mSession.mRemoteControls.front()->Uninitialize();
3544	}
3545
3546	mData->mSession.mRemoteControls.clear();
3547	mData->mSession.mState = SessionState_Unlocked;
3548	}
3549	}
3550	else
3551	{
3552	/* memorize PID of the directly opened session */
3553	if (SUCCEEDED(rc))
3554	mData->mSession.mPID = pid;
3555	}
3556
3557	if (SUCCEEDED(rc))
3558	{
3559	mData->mSession.mLockType = aLockType;
3560	/* memorize the direct session control and cache IUnknown for it */
3561	mData->mSession.mDirectControl = pSessionControl;
3562	mData->mSession.mState = SessionState_Locked;
3563	if (!fLaunchingVMProcess)
3564	mData->mSession.mName = strSessionName;
3565	/* associate the SessionMachine with this Machine */
3566	mData->mSession.mMachine = sessionMachine;
3567
3568	/* request an IUnknown pointer early from the remote party for later
3569	* identity checks (it will be internally cached within mDirectControl
3570	* at least on XPCOM) */
3571	ComPtr<IUnknown> unk = mData->mSession.mDirectControl;
3572	NOREF(unk);
3573	}
3574
3575	/* Release the lock since SessionMachine::uninit() locks VirtualBox which
3576	* would break the lock order */
3577	alock.release();
3578
3579	/* uninitialize the created session machine on failure */
3580	if (FAILED(rc))
3581	sessionMachine->uninit();
3582	}
3583
3584	if (SUCCEEDED(rc))
3585	{
3586	/*
3587	* tell the client watcher thread to update the set of
3588	* machines that have open sessions
3589	*/
3590	mParent->i_updateClientWatcher();
3591
3592	if (oldState != SessionState_Locked)
3593	/* fire an event */
3594	mParent->i_onSessionStateChange(i_getId(), SessionState_Locked);
3595	}
3596
3597	return rc;
3598	}
3599
3600	/**
3601	* @note Locks objects!
3602	*/
3603	HRESULT Machine::launchVMProcess(const ComPtr<ISession> &aSession,
3604	const com::Utf8Str &aName,
3605	const com::Utf8Str &aEnvironment,
3606	ComPtr<IProgress> &aProgress)
3607	{
3608	Utf8Str strFrontend(aName);
3609	/* "emergencystop" doesn't need the session, so skip the checks/interface
3610	* retrieval. This code doesn't quite fit in here, but introducing a
3611	* special API method would be even more effort, and would require explicit
3612	* support by every API client. It's better to hide the feature a bit. */
3613	if (strFrontend != "emergencystop")
3614	CheckComArgNotNull(aSession);
3615
3616	HRESULT rc = S_OK;
3617	if (strFrontend.isEmpty())
3618	{
3619	Bstr bstrFrontend;
3620	rc = COMGETTER(DefaultFrontend)(bstrFrontend.asOutParam());
3621	if (FAILED(rc))
3622	return rc;
3623	strFrontend = bstrFrontend;
3624	if (strFrontend.isEmpty())
3625	{
3626	ComPtr<ISystemProperties> systemProperties;
3627	rc = mParent->COMGETTER(SystemProperties)(systemProperties.asOutParam());
3628	if (FAILED(rc))
3629	return rc;
3630	rc = systemProperties->COMGETTER(DefaultFrontend)(bstrFrontend.asOutParam());
3631	if (FAILED(rc))
3632	return rc;
3633	strFrontend = bstrFrontend;
3634	}
3635	/* paranoia - emergencystop is not a valid default */
3636	if (strFrontend == "emergencystop")
3637	strFrontend = Utf8Str::Empty;
3638	}
3639	/* default frontend: Qt GUI */
3640	if (strFrontend.isEmpty())
3641	strFrontend = "GUI/Qt";
3642
3643	if (strFrontend != "emergencystop")
3644	{
3645	/* check the session state */
3646	SessionState_T state;
3647	rc = aSession->COMGETTER(State)(&state);
3648	if (FAILED(rc))
3649	return rc;
3650
3651	if (state != SessionState_Unlocked)
3652	return setError(VBOX_E_INVALID_OBJECT_STATE,
3653	tr("The given session is busy"));
3654
3655	/* get the IInternalSessionControl interface */
3656	ComPtr<IInternalSessionControl> control(aSession);
3657	ComAssertMsgRet(!control.isNull(),
3658	("No IInternalSessionControl interface"),
3659	E_INVALIDARG);
3660
3661	/* get the teleporter enable state for the progress object init. */
3662	BOOL fTeleporterEnabled;
3663	rc = COMGETTER(TeleporterEnabled)(&fTeleporterEnabled);
3664	if (FAILED(rc))
3665	return rc;
3666
3667	/* create a progress object */
3668	ComObjPtr<ProgressProxy> progress;
3669	progress.createObject();
3670	rc = progress->init(mParent,
3671	static_cast<IMachine*>(this),
3672	Bstr(tr("Starting VM")).raw(),
3673	TRUE /* aCancelable */,
3674	fTeleporterEnabled ? 20 : 10 /* uTotalOperationsWeight */,
3675	BstrFmt(tr("Creating process for virtual machine \"%s\" (%s)"),
3676	mUserData->s.strName.c_str(), strFrontend.c_str()).raw(),
3677	2 /* uFirstOperationWeight */,
3678	fTeleporterEnabled ? 3 : 1 /* cOtherProgressObjectOperations */);
3679
3680	if (SUCCEEDED(rc))
3681	{
3682	rc = i_launchVMProcess(control, strFrontend, aEnvironment, progress);
3683	if (SUCCEEDED(rc))
3684	{
3685	aProgress = progress;
3686
3687	/* signal the client watcher thread */
3688	mParent->i_updateClientWatcher();
3689
3690	/* fire an event */
3691	mParent->i_onSessionStateChange(i_getId(), SessionState_Spawning);
3692	}
3693	}
3694	}
3695	else
3696	{
3697	/* no progress object - either instant success or failure */
3698	aProgress = NULL;
3699
3700	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3701
3702	if (mData->mSession.mState != SessionState_Locked)
3703	return setError(VBOX_E_INVALID_OBJECT_STATE,
3704	tr("The machine '%s' is not locked by a session"),
3705	mUserData->s.strName.c_str());
3706
3707	/* must have a VM process associated - do not kill normal API clients
3708	* with an open session */
3709	if (!Global::IsOnline(mData->mMachineState))
3710	return setError(VBOX_E_INVALID_OBJECT_STATE,
3711	tr("The machine '%s' does not have a VM process"),
3712	mUserData->s.strName.c_str());
3713
3714	/* forcibly terminate the VM process */
3715	if (mData->mSession.mPID != NIL_RTPROCESS)
3716	RTProcTerminate(mData->mSession.mPID);
3717
3718	/* signal the client watcher thread, as most likely the client has
3719	* been terminated */
3720	mParent->i_updateClientWatcher();
3721	}
3722
3723	return rc;
3724	}
3725
3726	HRESULT Machine::setBootOrder(ULONG aPosition, DeviceType_T aDevice)
3727	{
3728	if (aPosition < 1 \|\| aPosition > SchemaDefs::MaxBootPosition)
3729	return setError(E_INVALIDARG,
3730	tr("Invalid boot position: %lu (must be in range [1, %lu])"),
3731	aPosition, SchemaDefs::MaxBootPosition);
3732
3733	if (aDevice == DeviceType_USB)
3734	return setError(E_NOTIMPL,
3735	tr("Booting from USB device is currently not supported"));
3736
3737	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3738
3739	HRESULT rc = i_checkStateDependency(MutableStateDep);
3740	if (FAILED(rc)) return rc;
3741
3742	i_setModified(IsModified_MachineData);
3743	mHWData.backup();
3744	mHWData->mBootOrder[aPosition - 1] = aDevice;
3745
3746	return S_OK;
3747	}
3748
3749	HRESULT Machine::getBootOrder(ULONG aPosition, DeviceType_T *aDevice)
3750	{
3751	if (aPosition < 1 \|\| aPosition > SchemaDefs::MaxBootPosition)
3752	return setError(E_INVALIDARG,
3753	tr("Invalid boot position: %lu (must be in range [1, %lu])"),
3754	aPosition, SchemaDefs::MaxBootPosition);
3755
3756	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3757
3758	*aDevice = mHWData->mBootOrder[aPosition - 1];
3759
3760	return S_OK;
3761	}
3762
3763	HRESULT Machine::attachDevice(const com::Utf8Str &aName,
3764	LONG aControllerPort,
3765	LONG aDevice,
3766	DeviceType_T aType,
3767	const ComPtr<IMedium> &aMedium)
3768	{
3769	IMedium *aM = aMedium;
3770	LogFlowThisFunc(("aControllerName=\"%s\" aControllerPort=%d aDevice=%d aType=%d aMedium=%p\n",
3771	aName.c_str(), aControllerPort, aDevice, aType, aM));
3772
3773	// request the host lock first, since might be calling Host methods for getting host drives;
3774	// next, protect the media tree all the while we're in here, as well as our member variables
3775	AutoMultiWriteLock2 alock(mParent->i_host(), this COMMA_LOCKVAL_SRC_POS);
3776	AutoWriteLock treeLock(&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
3777
3778	HRESULT rc = i_checkStateDependency(MutableOrRunningStateDep);
3779	if (FAILED(rc)) return rc;
3780
3781	/// @todo NEWMEDIA implicit machine registration
3782	if (!mData->mRegistered)
3783	return setError(VBOX_E_INVALID_OBJECT_STATE,
3784	tr("Cannot attach storage devices to an unregistered machine"));
3785
3786	AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
3787
3788	/* Check for an existing controller. */
3789	ComObjPtr<StorageController> ctl;
3790	rc = i_getStorageControllerByName(aName, ctl, true /* aSetError */);
3791	if (FAILED(rc)) return rc;
3792
3793	StorageControllerType_T ctrlType;
3794	rc = ctl->COMGETTER(ControllerType)(&ctrlType);
3795	if (FAILED(rc))
3796	return setError(E_FAIL,
3797	tr("Could not get type of controller '%s'"),
3798	aName.c_str());
3799
3800	bool fSilent = false;
3801	Utf8Str strReconfig;
3802
3803	/* Check whether the flag to allow silent storage attachment reconfiguration is set. */
3804	strReconfig = i_getExtraData(Utf8Str("VBoxInternal2/SilentReconfigureWhilePaused"));
3805	if ( mData->mMachineState == MachineState_Paused
3806	&& strReconfig == "1")
3807	fSilent = true;
3808
3809	/* Check that the controller can do hotplugging if we detach the device while the VM is running. */
3810	bool fHotplug = false;
3811	if (!fSilent && Global::IsOnlineOrTransient(mData->mMachineState))
3812	fHotplug = true;
3813
3814	if (fHotplug && !i_isControllerHotplugCapable(ctrlType))
3815	return setError(VBOX_E_INVALID_VM_STATE,
3816	tr("Controller '%s' does not support hotplugging"),
3817	aName.c_str());
3818
3819	// check that the port and device are not out of range
3820	rc = ctl->i_checkPortAndDeviceValid(aControllerPort, aDevice);
3821	if (FAILED(rc)) return rc;
3822
3823	/* check if the device slot is already busy */
3824	MediumAttachment *pAttachTemp;
3825	if ((pAttachTemp = i_findAttachment(*mMediumAttachments.data(),
3826	aName,
3827	aControllerPort,
3828	aDevice)))
3829	{
3830	Medium *pMedium = pAttachTemp->i_getMedium();
3831	if (pMedium)
3832	{
3833	AutoReadLock mediumLock(pMedium COMMA_LOCKVAL_SRC_POS);
3834	return setError(VBOX_E_OBJECT_IN_USE,
3835	tr("Medium '%s' is already attached to port %d, device %d of controller '%s' of this virtual machine"),
3836	pMedium->i_getLocationFull().c_str(),
3837	aControllerPort,
3838	aDevice,
3839	aName.c_str());
3840	}
3841	else
3842	return setError(VBOX_E_OBJECT_IN_USE,
3843	tr("Device is already attached to port %d, device %d of controller '%s' of this virtual machine"),
3844	aControllerPort, aDevice, aName.c_str());
3845	}
3846
3847	ComObjPtr<Medium> medium = static_cast<Medium*>(aM);
3848	if (aMedium && medium.isNull())
3849	return setError(E_INVALIDARG, "The given medium pointer is invalid");
3850
3851	AutoCaller mediumCaller(medium);
3852	if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
3853
3854	AutoWriteLock mediumLock(medium COMMA_LOCKVAL_SRC_POS);
3855
3856	if ( (pAttachTemp = i_findAttachment(*mMediumAttachments.data(), medium))
3857	&& !medium.isNull()
3858	)
3859	return setError(VBOX_E_OBJECT_IN_USE,
3860	tr("Medium '%s' is already attached to this virtual machine"),
3861	medium->i_getLocationFull().c_str());
3862
3863	if (!medium.isNull())
3864	{
3865	MediumType_T mtype = medium->i_getType();
3866	// MediumType_Readonly is also new, but only applies to DVDs and floppies.
3867	// For DVDs it's not written to the config file, so needs no global config
3868	// version bump. For floppies it's a new attribute "type", which is ignored
3869	// by older VirtualBox version, so needs no global config version bump either.
3870	// For hard disks this type is not accepted.
3871	if (mtype == MediumType_MultiAttach)
3872	{
3873	// This type is new with VirtualBox 4.0 and therefore requires settings
3874	// version 1.11 in the settings backend. Unfortunately it is not enough to do
3875	// the usual routine in MachineConfigFile::bumpSettingsVersionIfNeeded() for
3876	// two reasons: The medium type is a property of the media registry tree, which
3877	// can reside in the global config file (for pre-4.0 media); we would therefore
3878	// possibly need to bump the global config version. We don't want to do that though
3879	// because that might make downgrading to pre-4.0 impossible.
3880	// As a result, we can only use these two new types if the medium is NOT in the
3881	// global registry:
3882	const Guid &uuidGlobalRegistry = mParent->i_getGlobalRegistryId();
3883	if ( medium->i_isInRegistry(uuidGlobalRegistry)
3884	\|\| !mData->pMachineConfigFile->canHaveOwnMediaRegistry()
3885	)
3886	return setError(VBOX_E_INVALID_OBJECT_STATE,
3887	tr("Cannot attach medium '%s': the media type 'MultiAttach' can only be attached "
3888	"to machines that were created with VirtualBox 4.0 or later"),
3889	medium->i_getLocationFull().c_str());
3890	}
3891	}
3892
3893	bool fIndirect = false;
3894	if (!medium.isNull())
3895	fIndirect = medium->i_isReadOnly();
3896	bool associate = true;
3897
3898	do
3899	{
3900	if ( aType == DeviceType_HardDisk
3901	&& mMediumAttachments.isBackedUp())
3902	{
3903	const MediumAttachmentList &oldAtts = *mMediumAttachments.backedUpData();
3904
3905	/* check if the medium was attached to the VM before we started
3906	* changing attachments in which case the attachment just needs to
3907	* be restored */
3908	if ((pAttachTemp = i_findAttachment(oldAtts, medium)))
3909	{
3910	AssertReturn(!fIndirect, E_FAIL);
3911
3912	/* see if it's the same bus/channel/device */
3913	if (pAttachTemp->i_matches(aName, aControllerPort, aDevice))
3914	{
3915	/* the simplest case: restore the whole attachment
3916	* and return, nothing else to do */
3917	mMediumAttachments->push_back(pAttachTemp);
3918
3919	/* Reattach the medium to the VM. */
3920	if (fHotplug \|\| fSilent)
3921	{
3922	mediumLock.release();
3923	treeLock.release();
3924	alock.release();
3925
3926	MediumLockList *pMediumLockList(new MediumLockList());
3927
3928	rc = medium->i_createMediumLockList(true /* fFailIfInaccessible */,
3929	medium /* pToLockWrite */,
3930	false /* fMediumLockWriteAll */,
3931	NULL,
3932	*pMediumLockList);
3933	alock.acquire();
3934	if (FAILED(rc))
3935	delete pMediumLockList;
3936	else
3937	{
3938	mData->mSession.mLockedMedia.Unlock();
3939	alock.release();
3940	rc = mData->mSession.mLockedMedia.Insert(pAttachTemp, pMediumLockList);
3941	mData->mSession.mLockedMedia.Lock();
3942	alock.acquire();
3943	}
3944	alock.release();
3945
3946	if (SUCCEEDED(rc))
3947	{
3948	rc = i_onStorageDeviceChange(pAttachTemp, FALSE /* aRemove */, fSilent);
3949	/* Remove lock list in case of error. */
3950	if (FAILED(rc))
3951	{
3952	mData->mSession.mLockedMedia.Unlock();
3953	mData->mSession.mLockedMedia.Remove(pAttachTemp);
3954	mData->mSession.mLockedMedia.Lock();
3955	}
3956	}
3957	}
3958
3959	return S_OK;
3960	}
3961
3962	/* bus/channel/device differ; we need a new attachment object,
3963	* but don't try to associate it again */
3964	associate = false;
3965	break;
3966	}
3967	}
3968
3969	/* go further only if the attachment is to be indirect */
3970	if (!fIndirect)
3971	break;
3972
3973	/* perform the so called smart attachment logic for indirect
3974	* attachments. Note that smart attachment is only applicable to base
3975	* hard disks. */
3976
3977	if (medium->i_getParent().isNull())
3978	{
3979	/* first, investigate the backup copy of the current hard disk
3980	* attachments to make it possible to re-attach existing diffs to
3981	* another device slot w/o losing their contents */
3982	if (mMediumAttachments.isBackedUp())
3983	{
3984	const MediumAttachmentList &oldAtts = *mMediumAttachments.backedUpData();
3985
3986	MediumAttachmentList::const_iterator foundIt = oldAtts.end();
3987	uint32_t foundLevel = 0;
3988
3989	for (MediumAttachmentList::const_iterator
3990	it = oldAtts.begin();
3991	it != oldAtts.end();
3992	++it)
3993	{
3994	uint32_t level = 0;
3995	MediumAttachment pAttach = it;
3996	ComObjPtr<Medium> pMedium = pAttach->i_getMedium();
3997	Assert(!pMedium.isNull() \|\| pAttach->i_getType() != DeviceType_HardDisk);
3998	if (pMedium.isNull())
3999	continue;
4000
4001	if (pMedium->i_getBase(&level) == medium)
4002	{
4003	/* skip the hard disk if its currently attached (we
4004	* cannot attach the same hard disk twice) */
4005	if (i_findAttachment(*mMediumAttachments.data(),
4006	pMedium))
4007	continue;
4008
4009	/* matched device, channel and bus (i.e. attached to the
4010	* same place) will win and immediately stop the search;
4011	* otherwise the attachment that has the youngest
4012	* descendant of medium will be used
4013	*/
4014	if (pAttach->i_matches(aName, aControllerPort, aDevice))
4015	{
4016	/* the simplest case: restore the whole attachment
4017	* and return, nothing else to do */
4018	mMediumAttachments->push_back(*it);
4019
4020	/* Reattach the medium to the VM. */
4021	if (fHotplug \|\| fSilent)
4022	{
4023	mediumLock.release();
4024	treeLock.release();
4025	alock.release();
4026
4027	MediumLockList *pMediumLockList(new MediumLockList());
4028
4029	rc = medium->i_createMediumLockList(true /* fFailIfInaccessible */,
4030	medium /* pToLockWrite */,
4031	false /* fMediumLockWriteAll */,
4032	NULL,
4033	*pMediumLockList);
4034	alock.acquire();
4035	if (FAILED(rc))
4036	delete pMediumLockList;
4037	else
4038	{
4039	mData->mSession.mLockedMedia.Unlock();
4040	alock.release();
4041	rc = mData->mSession.mLockedMedia.Insert(pAttachTemp, pMediumLockList);
4042	mData->mSession.mLockedMedia.Lock();
4043	alock.acquire();
4044	}
4045	alock.release();
4046
4047	if (SUCCEEDED(rc))
4048	{
4049	rc = i_onStorageDeviceChange(pAttachTemp, FALSE /* aRemove */, fSilent);
4050	/* Remove lock list in case of error. */
4051	if (FAILED(rc))
4052	{
4053	mData->mSession.mLockedMedia.Unlock();
4054	mData->mSession.mLockedMedia.Remove(pAttachTemp);
4055	mData->mSession.mLockedMedia.Lock();
4056	}
4057	}
4058	}
4059
4060	return S_OK;
4061	}
4062	else if ( foundIt == oldAtts.end()
4063	\|\| level > foundLevel /* prefer younger */
4064	)
4065	{
4066	foundIt = it;
4067	foundLevel = level;
4068	}
4069	}
4070	}
4071
4072	if (foundIt != oldAtts.end())
4073	{
4074	/* use the previously attached hard disk */
4075	medium = (*foundIt)->i_getMedium();
4076	mediumCaller.attach(medium);
4077	if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
4078	mediumLock.attach(medium);
4079	/* not implicit, doesn't require association with this VM */
4080	fIndirect = false;
4081	associate = false;
4082	/* go right to the MediumAttachment creation */
4083	break;
4084	}
4085	}
4086
4087	/* must give up the medium lock and medium tree lock as below we
4088	* go over snapshots, which needs a lock with higher lock order. */
4089	mediumLock.release();
4090	treeLock.release();
4091
4092	/* then, search through snapshots for the best diff in the given
4093	* hard disk's chain to base the new diff on */
4094
4095	ComObjPtr<Medium> base;
4096	ComObjPtr<Snapshot> snap = mData->mCurrentSnapshot;
4097	while (snap)
4098	{
4099	AutoReadLock snapLock(snap COMMA_LOCKVAL_SRC_POS);
4100
4101	const MediumAttachmentList &snapAtts = *snap->i_getSnapshotMachine()->mMediumAttachments.data();
4102
4103	MediumAttachment *pAttachFound = NULL;
4104	uint32_t foundLevel = 0;
4105
4106	for (MediumAttachmentList::const_iterator
4107	it = snapAtts.begin();
4108	it != snapAtts.end();
4109	++it)
4110	{
4111	MediumAttachment pAttach = it;
4112	ComObjPtr<Medium> pMedium = pAttach->i_getMedium();
4113	Assert(!pMedium.isNull() \|\| pAttach->i_getType() != DeviceType_HardDisk);
4114	if (pMedium.isNull())
4115	continue;
4116
4117	uint32_t level = 0;
4118	if (pMedium->i_getBase(&level) == medium)
4119	{
4120	/* matched device, channel and bus (i.e. attached to the
4121	* same place) will win and immediately stop the search;
4122	* otherwise the attachment that has the youngest
4123	* descendant of medium will be used
4124	*/
4125	if ( pAttach->i_getDevice() == aDevice
4126	&& pAttach->i_getPort() == aControllerPort
4127	&& pAttach->i_getControllerName() == aName
4128	)
4129	{
4130	pAttachFound = pAttach;
4131	break;
4132	}
4133	else if ( !pAttachFound
4134	\|\| level > foundLevel /* prefer younger */
4135	)
4136	{
4137	pAttachFound = pAttach;
4138	foundLevel = level;
4139	}
4140	}
4141	}
4142
4143	if (pAttachFound)
4144	{
4145	base = pAttachFound->i_getMedium();
4146	break;
4147	}
4148
4149	snap = snap->i_getParent();
4150	}
4151
4152	/* re-lock medium tree and the medium, as we need it below */
4153	treeLock.acquire();
4154	mediumLock.acquire();
4155
4156	/* found a suitable diff, use it as a base */
4157	if (!base.isNull())
4158	{
4159	medium = base;
4160	mediumCaller.attach(medium);
4161	if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
4162	mediumLock.attach(medium);
4163	}
4164	}
4165
4166	Utf8Str strFullSnapshotFolder;
4167	i_calculateFullPath(mUserData->s.strSnapshotFolder, strFullSnapshotFolder);
4168
4169	ComObjPtr<Medium> diff;
4170	diff.createObject();
4171	// store this diff in the same registry as the parent
4172	Guid uuidRegistryParent;
4173	if (!medium->i_getFirstRegistryMachineId(uuidRegistryParent))
4174	{
4175	// parent image has no registry: this can happen if we're attaching a new immutable
4176	// image that has not yet been attached (medium then points to the base and we're
4177	// creating the diff image for the immutable, and the parent is not yet registered);
4178	// put the parent in the machine registry then
4179	mediumLock.release();
4180	treeLock.release();
4181	alock.release();
4182	i_addMediumToRegistry(medium);
4183	alock.acquire();
4184	treeLock.acquire();
4185	mediumLock.acquire();
4186	medium->i_getFirstRegistryMachineId(uuidRegistryParent);
4187	}
4188	rc = diff->init(mParent,
4189	medium->i_getPreferredDiffFormat(),
4190	strFullSnapshotFolder.append(RTPATH_SLASH_STR),
4191	uuidRegistryParent,
4192	DeviceType_HardDisk);
4193	if (FAILED(rc)) return rc;
4194
4195	/* Apply the normal locking logic to the entire chain. */
4196	MediumLockList *pMediumLockList(new MediumLockList());
4197	mediumLock.release();
4198	treeLock.release();
4199	rc = diff->i_createMediumLockList(true /* fFailIfInaccessible */,
4200	diff /* pToLockWrite */,
4201	false /* fMediumLockWriteAll */,
4202	medium,
4203	*pMediumLockList);
4204	treeLock.acquire();
4205	mediumLock.acquire();
4206	if (SUCCEEDED(rc))
4207	{
4208	mediumLock.release();
4209	treeLock.release();
4210	rc = pMediumLockList->Lock();
4211	treeLock.acquire();
4212	mediumLock.acquire();
4213	if (FAILED(rc))
4214	setError(rc,
4215	tr("Could not lock medium when creating diff '%s'"),
4216	diff->i_getLocationFull().c_str());
4217	else
4218	{
4219	/* will release the lock before the potentially lengthy
4220	* operation, so protect with the special state */
4221	MachineState_T oldState = mData->mMachineState;
4222	i_setMachineState(MachineState_SettingUp);
4223
4224	mediumLock.release();
4225	treeLock.release();
4226	alock.release();
4227
4228	rc = medium->i_createDiffStorage(diff,
4229	medium->i_getPreferredDiffVariant(),
4230	pMediumLockList,
4231	NULL /* aProgress */,
4232	true /* aWait */);
4233
4234	alock.acquire();
4235	treeLock.acquire();
4236	mediumLock.acquire();
4237
4238	i_setMachineState(oldState);
4239	}
4240	}
4241
4242	/* Unlock the media and free the associated memory. */
4243	delete pMediumLockList;
4244
4245	if (FAILED(rc)) return rc;
4246
4247	/* use the created diff for the actual attachment */
4248	medium = diff;
4249	mediumCaller.attach(medium);
4250	if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
4251	mediumLock.attach(medium);
4252	}
4253	while (0);
4254
4255	ComObjPtr<MediumAttachment> attachment;
4256	attachment.createObject();
4257	rc = attachment->init(this,
4258	medium,
4259	aName,
4260	aControllerPort,
4261	aDevice,
4262	aType,
4263	fIndirect,
4264	false /* fPassthrough */,
4265	false /* fTempEject */,
4266	false /* fNonRotational */,
4267	false /* fDiscard */,
4268	fHotplug /* fHotPluggable */,
4269	Utf8Str::Empty);
4270	if (FAILED(rc)) return rc;
4271
4272	if (associate && !medium.isNull())
4273	{
4274	// as the last step, associate the medium to the VM
4275	rc = medium->i_addBackReference(mData->mUuid);
4276	// here we can fail because of Deleting, or being in process of creating a Diff
4277	if (FAILED(rc)) return rc;
4278
4279	mediumLock.release();
4280	treeLock.release();
4281	alock.release();
4282	i_addMediumToRegistry(medium);
4283	alock.acquire();
4284	treeLock.acquire();
4285	mediumLock.acquire();
4286	}
4287
4288	/* success: finally remember the attachment */
4289	i_setModified(IsModified_Storage);
4290	mMediumAttachments.backup();
4291	mMediumAttachments->push_back(attachment);
4292
4293	mediumLock.release();
4294	treeLock.release();
4295	alock.release();
4296
4297	if (fHotplug \|\| fSilent)
4298	{
4299	if (!medium.isNull())
4300	{
4301	MediumLockList *pMediumLockList(new MediumLockList());
4302
4303	rc = medium->i_createMediumLockList(true /* fFailIfInaccessible */,
4304	medium /* pToLockWrite */,
4305	false /* fMediumLockWriteAll */,
4306	NULL,
4307	*pMediumLockList);
4308	alock.acquire();
4309	if (FAILED(rc))
4310	delete pMediumLockList;
4311	else
4312	{
4313	mData->mSession.mLockedMedia.Unlock();
4314	alock.release();
4315	rc = mData->mSession.mLockedMedia.Insert(attachment, pMediumLockList);
4316	mData->mSession.mLockedMedia.Lock();
4317	alock.acquire();
4318	}
4319	alock.release();
4320	}
4321
4322	if (SUCCEEDED(rc))
4323	{
4324	rc = i_onStorageDeviceChange(attachment, FALSE /* aRemove */, fSilent);
4325	/* Remove lock list in case of error. */
4326	if (FAILED(rc))
4327	{
4328	mData->mSession.mLockedMedia.Unlock();
4329	mData->mSession.mLockedMedia.Remove(attachment);
4330	mData->mSession.mLockedMedia.Lock();
4331	}
4332	}
4333	}
4334
4335	/* Save modified registries, but skip this machine as it's the caller's
4336	* job to save its settings like all other settings changes. */
4337	mParent->i_unmarkRegistryModified(i_getId());
4338	mParent->i_saveModifiedRegistries();
4339
4340	return rc;
4341	}
4342
4343	HRESULT Machine::detachDevice(const com::Utf8Str &aName, LONG aControllerPort,
4344	LONG aDevice)
4345	{
4346	LogFlowThisFunc(("aControllerName=\"%s\" aControllerPort=%d aDevice=%d\n",
4347	aName.c_str(), aControllerPort, aDevice));
4348
4349	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4350
4351	HRESULT rc = i_checkStateDependency(MutableOrRunningStateDep);
4352	if (FAILED(rc)) return rc;
4353
4354	AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
4355
4356	/* Check for an existing controller. */
4357	ComObjPtr<StorageController> ctl;
4358	rc = i_getStorageControllerByName(aName, ctl, true /* aSetError */);
4359	if (FAILED(rc)) return rc;
4360
4361	StorageControllerType_T ctrlType;
4362	rc = ctl->COMGETTER(ControllerType)(&ctrlType);
4363	if (FAILED(rc))
4364	return setError(E_FAIL,
4365	tr("Could not get type of controller '%s'"),
4366	aName.c_str());
4367
4368	bool fSilent = false;
4369	Utf8Str strReconfig;
4370
4371	/* Check whether the flag to allow silent storage attachment reconfiguration is set. */
4372	strReconfig = i_getExtraData(Utf8Str("VBoxInternal2/SilentReconfigureWhilePaused"));
4373	if ( mData->mMachineState == MachineState_Paused
4374	&& strReconfig == "1")
4375	fSilent = true;
4376
4377	/* Check that the controller can do hotplugging if we detach the device while the VM is running. */
4378	bool fHotplug = false;
4379	if (!fSilent && Global::IsOnlineOrTransient(mData->mMachineState))
4380	fHotplug = true;
4381
4382	if (fHotplug && !i_isControllerHotplugCapable(ctrlType))
4383	return setError(VBOX_E_INVALID_VM_STATE,
4384	tr("Controller '%s' does not support hotplugging"),
4385	aName.c_str());
4386
4387	MediumAttachment pAttach = i_findAttachment(mMediumAttachments.data(),
4388	aName,
4389	aControllerPort,
4390	aDevice);
4391	if (!pAttach)
4392	return setError(VBOX_E_OBJECT_NOT_FOUND,
4393	tr("No storage device attached to device slot %d on port %d of controller '%s'"),
4394	aDevice, aControllerPort, aName.c_str());
4395
4396	if (fHotplug && !pAttach->i_getHotPluggable())
4397	return setError(VBOX_E_NOT_SUPPORTED,
4398	tr("The device slot %d on port %d of controller '%s' does not support hotplugging"),
4399	aDevice, aControllerPort, aName.c_str());
4400
4401	/*
4402	* The VM has to detach the device before we delete any implicit diffs.
4403	* If this fails we can roll back without loosing data.
4404	*/
4405	if (fHotplug \|\| fSilent)
4406	{
4407	alock.release();
4408	rc = i_onStorageDeviceChange(pAttach, TRUE /* aRemove */, fSilent);
4409	alock.acquire();
4410	}
4411	if (FAILED(rc)) return rc;
4412
4413	/* If we are here everything went well and we can delete the implicit now. */
4414	rc = i_detachDevice(pAttach, alock, NULL /* pSnapshot */);
4415
4416	alock.release();
4417
4418	/* Save modified registries, but skip this machine as it's the caller's
4419	* job to save its settings like all other settings changes. */
4420	mParent->i_unmarkRegistryModified(i_getId());
4421	mParent->i_saveModifiedRegistries();
4422
4423	return rc;
4424	}
4425
4426	HRESULT Machine::passthroughDevice(const com::Utf8Str &aName, LONG aControllerPort,
4427	LONG aDevice, BOOL aPassthrough)
4428	{
4429	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d aPassthrough=%d\n",
4430	aName.c_str(), aControllerPort, aDevice, aPassthrough));
4431
4432	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4433
4434	HRESULT rc = i_checkStateDependency(MutableStateDep);
4435	if (FAILED(rc)) return rc;
4436
4437	AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
4438
4439	if (Global::IsOnlineOrTransient(mData->mMachineState))
4440	return setError(VBOX_E_INVALID_VM_STATE,
4441	tr("Invalid machine state: %s"),
4442	Global::stringifyMachineState(mData->mMachineState));
4443
4444	MediumAttachment pAttach = i_findAttachment(mMediumAttachments.data(),
4445	aName,
4446	aControllerPort,
4447	aDevice);
4448	if (!pAttach)
4449	return setError(VBOX_E_OBJECT_NOT_FOUND,
4450	tr("No storage device attached to device slot %d on port %d of controller '%s'"),
4451	aDevice, aControllerPort, aName.c_str());
4452
4453
4454	i_setModified(IsModified_Storage);
4455	mMediumAttachments.backup();
4456
4457	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
4458
4459	if (pAttach->i_getType() != DeviceType_DVD)
4460	return setError(E_INVALIDARG,
4461	tr("Setting passthrough rejected as the device attached to device slot %d on port %d of controller '%s' is not a DVD"),
4462	aDevice, aControllerPort, aName.c_str());
4463	pAttach->i_updatePassthrough(!!aPassthrough);
4464
4465	return S_OK;
4466	}
4467
4468	HRESULT Machine::temporaryEjectDevice(const com::Utf8Str &aName, LONG aControllerPort,
4469	LONG aDevice, BOOL aTemporaryEject)
4470	{
4471
4472	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d aTemporaryEject=%d\n",
4473	aName.c_str(), aControllerPort, aDevice, aTemporaryEject));
4474
4475	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4476
4477	HRESULT rc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
4478	if (FAILED(rc)) return rc;
4479
4480	MediumAttachment pAttach = i_findAttachment(mMediumAttachments.data(),
4481	aName,
4482	aControllerPort,
4483	aDevice);
4484	if (!pAttach)
4485	return setError(VBOX_E_OBJECT_NOT_FOUND,
4486	tr("No storage device attached to device slot %d on port %d of controller '%s'"),
4487	aDevice, aControllerPort, aName.c_str());
4488
4489
4490	i_setModified(IsModified_Storage);
4491	mMediumAttachments.backup();
4492
4493	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
4494
4495	if (pAttach->i_getType() != DeviceType_DVD)
4496	return setError(E_INVALIDARG,
4497	tr("Setting temporary eject flag rejected as the device attached to device slot %d on port %d of controller '%s' is not a DVD"),
4498	aDevice, aControllerPort, aName.c_str());
4499	pAttach->i_updateTempEject(!!aTemporaryEject);
4500
4501	return S_OK;
4502	}
4503
4504	HRESULT Machine::nonRotationalDevice(const com::Utf8Str &aName, LONG aControllerPort,
4505	LONG aDevice, BOOL aNonRotational)
4506	{
4507
4508	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d aNonRotational=%d\n",
4509	aName.c_str(), aControllerPort, aDevice, aNonRotational));
4510
4511	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4512
4513	HRESULT rc = i_checkStateDependency(MutableStateDep);
4514	if (FAILED(rc)) return rc;
4515
4516	AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
4517
4518	if (Global::IsOnlineOrTransient(mData->mMachineState))
4519	return setError(VBOX_E_INVALID_VM_STATE,
4520	tr("Invalid machine state: %s"),
4521	Global::stringifyMachineState(mData->mMachineState));
4522
4523	MediumAttachment pAttach = i_findAttachment(mMediumAttachments.data(),
4524	aName,
4525	aControllerPort,
4526	aDevice);
4527	if (!pAttach)
4528	return setError(VBOX_E_OBJECT_NOT_FOUND,
4529	tr("No storage device attached to device slot %d on port %d of controller '%s'"),
4530	aDevice, aControllerPort, aName.c_str());
4531
4532
4533	i_setModified(IsModified_Storage);
4534	mMediumAttachments.backup();
4535
4536	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
4537
4538	if (pAttach->i_getType() != DeviceType_HardDisk)
4539	return setError(E_INVALIDARG,
4540	tr("Setting the non-rotational medium flag rejected as the device attached to device slot %d on port %d of controller '%s' is not a hard disk"),
4541	aDevice, aControllerPort, aName.c_str());
4542	pAttach->i_updateNonRotational(!!aNonRotational);
4543
4544	return S_OK;
4545	}
4546
4547	HRESULT Machine::setAutoDiscardForDevice(const com::Utf8Str &aName, LONG aControllerPort,
4548	LONG aDevice, BOOL aDiscard)
4549	{
4550
4551	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d aDiscard=%d\n",
4552	aName.c_str(), aControllerPort, aDevice, aDiscard));
4553
4554	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4555
4556	HRESULT rc = i_checkStateDependency(MutableStateDep);
4557	if (FAILED(rc)) return rc;
4558
4559	AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
4560
4561	if (Global::IsOnlineOrTransient(mData->mMachineState))
4562	return setError(VBOX_E_INVALID_VM_STATE,
4563	tr("Invalid machine state: %s"),
4564	Global::stringifyMachineState(mData->mMachineState));
4565
4566	MediumAttachment pAttach = i_findAttachment(mMediumAttachments.data(),
4567	aName,
4568	aControllerPort,
4569	aDevice);
4570	if (!pAttach)
4571	return setError(VBOX_E_OBJECT_NOT_FOUND,
4572	tr("No storage device attached to device slot %d on port %d of controller '%s'"),
4573	aDevice, aControllerPort, aName.c_str());
4574
4575
4576	i_setModified(IsModified_Storage);
4577	mMediumAttachments.backup();
4578
4579	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
4580
4581	if (pAttach->i_getType() != DeviceType_HardDisk)
4582	return setError(E_INVALIDARG,
4583	tr("Setting the discard medium flag rejected as the device attached to device slot %d on port %d of controller '%s' is not a hard disk"),
4584	aDevice, aControllerPort, aName.c_str());
4585	pAttach->i_updateDiscard(!!aDiscard);
4586
4587	return S_OK;
4588	}
4589
4590	HRESULT Machine::setHotPluggableForDevice(const com::Utf8Str &aName, LONG aControllerPort,
4591	LONG aDevice, BOOL aHotPluggable)
4592	{
4593	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d aHotPluggable=%d\n",
4594	aName.c_str(), aControllerPort, aDevice, aHotPluggable));
4595
4596	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4597
4598	HRESULT rc = i_checkStateDependency(MutableStateDep);
4599	if (FAILED(rc)) return rc;
4600
4601	AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
4602
4603	if (Global::IsOnlineOrTransient(mData->mMachineState))
4604	return setError(VBOX_E_INVALID_VM_STATE,
4605	tr("Invalid machine state: %s"),
4606	Global::stringifyMachineState(mData->mMachineState));
4607
4608	MediumAttachment pAttach = i_findAttachment(mMediumAttachments.data(),
4609	aName,
4610	aControllerPort,
4611	aDevice);
4612	if (!pAttach)
4613	return setError(VBOX_E_OBJECT_NOT_FOUND,
4614	tr("No storage device attached to device slot %d on port %d of controller '%s'"),
4615	aDevice, aControllerPort, aName.c_str());
4616
4617	/* Check for an existing controller. */
4618	ComObjPtr<StorageController> ctl;
4619	rc = i_getStorageControllerByName(aName, ctl, true /* aSetError */);
4620	if (FAILED(rc)) return rc;
4621
4622	StorageControllerType_T ctrlType;
4623	rc = ctl->COMGETTER(ControllerType)(&ctrlType);
4624	if (FAILED(rc))
4625	return setError(E_FAIL,
4626	tr("Could not get type of controller '%s'"),
4627	aName.c_str());
4628
4629	if (!i_isControllerHotplugCapable(ctrlType))
4630	return setError(VBOX_E_NOT_SUPPORTED,
4631	tr("Controller '%s' does not support changing the hot-pluggable device flag"),
4632	aName.c_str());
4633
4634	i_setModified(IsModified_Storage);
4635	mMediumAttachments.backup();
4636
4637	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
4638
4639	if (pAttach->i_getType() == DeviceType_Floppy)
4640	return setError(E_INVALIDARG,
4641	tr("Setting the hot-pluggable device flag rejected as the device attached to device slot %d on port %d of controller '%s' is a floppy drive"),
4642	aDevice, aControllerPort, aName.c_str());
4643	pAttach->i_updateHotPluggable(!!aHotPluggable);
4644
4645	return S_OK;
4646	}
4647
4648	HRESULT Machine::setNoBandwidthGroupForDevice(const com::Utf8Str &aName, LONG aControllerPort,
4649	LONG aDevice)
4650	{
4651	int rc = S_OK;
4652	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d\n",
4653	aName.c_str(), aControllerPort, aDevice));
4654
4655	rc = setBandwidthGroupForDevice(aName, aControllerPort, aDevice, NULL);
4656
4657	return rc;
4658	}
4659
4660	HRESULT Machine::setBandwidthGroupForDevice(const com::Utf8Str &aName, LONG aControllerPort,
4661	LONG aDevice, const ComPtr<IBandwidthGroup> &aBandwidthGroup)
4662	{
4663	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d\n",
4664	aName.c_str(), aControllerPort, aDevice));
4665
4666	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4667
4668	HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
4669	if (FAILED(rc)) return rc;
4670
4671	if (Global::IsOnlineOrTransient(mData->mMachineState))
4672	return setError(VBOX_E_INVALID_VM_STATE,
4673	tr("Invalid machine state: %s"),
4674	Global::stringifyMachineState(mData->mMachineState));
4675
4676	MediumAttachment pAttach = i_findAttachment(mMediumAttachments.data(),
4677	aName,
4678	aControllerPort,
4679	aDevice);
4680	if (!pAttach)
4681	return setError(VBOX_E_OBJECT_NOT_FOUND,
4682	tr("No storage device attached to device slot %d on port %d of controller '%s'"),
4683	aDevice, aControllerPort, aName.c_str());
4684
4685
4686	i_setModified(IsModified_Storage);
4687	mMediumAttachments.backup();
4688
4689	IBandwidthGroup *iB = aBandwidthGroup;
4690	ComObjPtr<BandwidthGroup> group = static_cast<BandwidthGroup*>(iB);
4691	if (aBandwidthGroup && group.isNull())
4692	return setError(E_INVALIDARG, "The given bandwidth group pointer is invalid");
4693
4694	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
4695
4696	const Utf8Str strBandwidthGroupOld = pAttach->i_getBandwidthGroup();
4697	if (strBandwidthGroupOld.isNotEmpty())
4698	{
4699	/* Get the bandwidth group object and release it - this must not fail. */
4700	ComObjPtr<BandwidthGroup> pBandwidthGroupOld;
4701	rc = i_getBandwidthGroup(strBandwidthGroupOld, pBandwidthGroupOld, false);
4702	Assert(SUCCEEDED(rc));
4703
4704	pBandwidthGroupOld->i_release();
4705	pAttach->i_updateBandwidthGroup(Utf8Str::Empty);
4706	}
4707
4708	if (!group.isNull())
4709	{
4710	group->i_reference();
4711	pAttach->i_updateBandwidthGroup(group->i_getName());
4712	}
4713
4714	return S_OK;
4715	}
4716
4717	HRESULT Machine::attachDeviceWithoutMedium(const com::Utf8Str &aName,
4718	LONG aControllerPort,
4719	LONG aDevice,
4720	DeviceType_T aType)
4721	{
4722	HRESULT rc = S_OK;
4723
4724	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d aType=%d\n",
4725	aName.c_str(), aControllerPort, aDevice, aType));
4726
4727	rc = attachDevice(aName, aControllerPort, aDevice, aType, NULL);
4728
4729	return rc;
4730	}
4731
4732
4733	HRESULT Machine::unmountMedium(const com::Utf8Str &aName,
4734	LONG aControllerPort,
4735	LONG aDevice,
4736	BOOL aForce)
4737	{
4738	int rc = S_OK;
4739	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d",
4740	aName.c_str(), aControllerPort, aForce));
4741
4742	rc = mountMedium(aName, aControllerPort, aDevice, NULL, aForce);
4743
4744	return rc;
4745	}
4746
4747	HRESULT Machine::mountMedium(const com::Utf8Str &aName,
4748	LONG aControllerPort,
4749	LONG aDevice,
4750	const ComPtr<IMedium> &aMedium,
4751	BOOL aForce)
4752	{
4753	int rc = S_OK;
4754	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d aForce=%d\n",
4755	aName.c_str(), aControllerPort, aDevice, aForce));
4756
4757	// request the host lock first, since might be calling Host methods for getting host drives;
4758	// next, protect the media tree all the while we're in here, as well as our member variables
4759	AutoMultiWriteLock3 multiLock(mParent->i_host()->lockHandle(),
4760	this->lockHandle(),
4761	&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
4762
4763	ComObjPtr<MediumAttachment> pAttach = i_findAttachment(*mMediumAttachments.data(),
4764	aName,
4765	aControllerPort,
4766	aDevice);
4767	if (pAttach.isNull())
4768	return setError(VBOX_E_OBJECT_NOT_FOUND,
4769	tr("No drive attached to device slot %d on port %d of controller '%s'"),
4770	aDevice, aControllerPort, aName.c_str());
4771
4772	/* Remember previously mounted medium. The medium before taking the
4773	* backup is not necessarily the same thing. */
4774	ComObjPtr<Medium> oldmedium;
4775	oldmedium = pAttach->i_getMedium();
4776
4777	IMedium *iM = aMedium;
4778	ComObjPtr<Medium> pMedium = static_cast<Medium*>(iM);
4779	if (aMedium && pMedium.isNull())
4780	return setError(E_INVALIDARG, "The given medium pointer is invalid");
4781
4782	AutoCaller mediumCaller(pMedium);
4783	if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
4784
4785	AutoWriteLock mediumLock(pMedium COMMA_LOCKVAL_SRC_POS);
4786	if (pMedium)
4787	{
4788	DeviceType_T mediumType = pAttach->i_getType();
4789	switch (mediumType)
4790	{
4791	case DeviceType_DVD:
4792	case DeviceType_Floppy:
4793	break;
4794
4795	default:
4796	return setError(VBOX_E_INVALID_OBJECT_STATE,
4797	tr("The device at port %d, device %d of controller '%s' of this virtual machine is not removeable"),
4798	aControllerPort,
4799	aDevice,
4800	aName.c_str());
4801	}
4802	}
4803
4804	i_setModified(IsModified_Storage);
4805	mMediumAttachments.backup();
4806
4807	{
4808	// The backup operation makes the pAttach reference point to the
4809	// old settings. Re-get the correct reference.
4810	pAttach = i_findAttachment(*mMediumAttachments.data(),
4811	aName,
4812	aControllerPort,
4813	aDevice);
4814	if (!oldmedium.isNull())
4815	oldmedium->i_removeBackReference(mData->mUuid);
4816	if (!pMedium.isNull())
4817	{
4818	pMedium->i_addBackReference(mData->mUuid);
4819
4820	mediumLock.release();
4821	multiLock.release();
4822	i_addMediumToRegistry(pMedium);
4823	multiLock.acquire();
4824	mediumLock.acquire();
4825	}
4826
4827	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
4828	pAttach->i_updateMedium(pMedium);
4829	}
4830
4831	i_setModified(IsModified_Storage);
4832
4833	mediumLock.release();
4834	multiLock.release();
4835	rc = i_onMediumChange(pAttach, aForce);
4836	multiLock.acquire();
4837	mediumLock.acquire();
4838
4839	/* On error roll back this change only. */
4840	if (FAILED(rc))
4841	{
4842	if (!pMedium.isNull())
4843	pMedium->i_removeBackReference(mData->mUuid);
4844	pAttach = i_findAttachment(*mMediumAttachments.data(),
4845	aName,
4846	aControllerPort,
4847	aDevice);
4848	/* If the attachment is gone in the meantime, bail out. */
4849	if (pAttach.isNull())
4850	return rc;
4851	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
4852	if (!oldmedium.isNull())
4853	oldmedium->i_addBackReference(mData->mUuid);
4854	pAttach->i_updateMedium(oldmedium);
4855	}
4856
4857	mediumLock.release();
4858	multiLock.release();
4859
4860	/* Save modified registries, but skip this machine as it's the caller's
4861	* job to save its settings like all other settings changes. */
4862	mParent->i_unmarkRegistryModified(i_getId());
4863	mParent->i_saveModifiedRegistries();
4864
4865	return rc;
4866	}
4867	HRESULT Machine::getMedium(const com::Utf8Str &aName,
4868	LONG aControllerPort,
4869	LONG aDevice,
4870	ComPtr<IMedium> &aMedium)
4871	{
4872	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d\n",
4873	aName.c_str(), aControllerPort, aDevice));
4874
4875	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4876
4877	aMedium = NULL;
4878
4879	ComObjPtr<MediumAttachment> pAttach = i_findAttachment(*mMediumAttachments.data(),
4880	aName,
4881	aControllerPort,
4882	aDevice);
4883	if (pAttach.isNull())
4884	return setError(VBOX_E_OBJECT_NOT_FOUND,
4885	tr("No storage device attached to device slot %d on port %d of controller '%s'"),
4886	aDevice, aControllerPort, aName.c_str());
4887
4888	aMedium = pAttach->i_getMedium();
4889
4890	return S_OK;
4891	}
4892
4893	HRESULT Machine::getSerialPort(ULONG aSlot, ComPtr<ISerialPort> &aPort)
4894	{
4895
4896	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4897
4898	mSerialPorts[aSlot].queryInterfaceTo(aPort.asOutParam());
4899
4900	return S_OK;
4901	}
4902
4903	HRESULT Machine::getParallelPort(ULONG aSlot, ComPtr<IParallelPort> &aPort)
4904	{
4905	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4906
4907	mParallelPorts[aSlot].queryInterfaceTo(aPort.asOutParam());
4908
4909	return S_OK;
4910	}
4911
4912	HRESULT Machine::getNetworkAdapter(ULONG aSlot, ComPtr<INetworkAdapter> &aAdapter)
4913	{
4914	/* Do not assert if slot is out of range, just return the advertised
4915	status. testdriver/vbox.py triggers this in logVmInfo. */
4916	if (aSlot >= mNetworkAdapters.size())
4917	return setError(E_INVALIDARG,
4918	tr("No network adapter in slot %RU32 (total %RU32 adapters)"),
4919	aSlot, mNetworkAdapters.size());
4920
4921	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4922
4923	mNetworkAdapters[aSlot].queryInterfaceTo(aAdapter.asOutParam());
4924
4925	return S_OK;
4926	}
4927
4928	HRESULT Machine::getExtraDataKeys(std::vector<com::Utf8Str> &aKeys)
4929	{
4930	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4931
4932	aKeys.resize(mData->pMachineConfigFile->mapExtraDataItems.size());
4933	size_t i = 0;
4934	for (settings::StringsMap::const_iterator
4935	it = mData->pMachineConfigFile->mapExtraDataItems.begin();
4936	it != mData->pMachineConfigFile->mapExtraDataItems.end();
4937	++it, ++i)
4938	aKeys[i] = it->first;
4939
4940	return S_OK;
4941	}
4942
4943	/**
4944	* @note Locks this object for reading.
4945	*/
4946	HRESULT Machine::getExtraData(const com::Utf8Str &aKey,
4947	com::Utf8Str &aValue)
4948	{
4949	/* start with nothing found */
4950	aValue = "";
4951
4952	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4953
4954	settings::StringsMap::const_iterator it = mData->pMachineConfigFile->mapExtraDataItems.find(aKey);
4955	if (it != mData->pMachineConfigFile->mapExtraDataItems.end())
4956	// found:
4957	aValue = it->second; // source is a Utf8Str
4958
4959	/* return the result to caller (may be empty) */
4960	return S_OK;
4961	}
4962
4963	/**
4964	* @note Locks mParent for writing + this object for writing.
4965	*/
4966	HRESULT Machine::setExtraData(const com::Utf8Str &aKey, const com::Utf8Str &aValue)
4967	{
4968	Utf8Str strOldValue; // empty
4969
4970	// locking note: we only hold the read lock briefly to look up the old value,
4971	// then release it and call the onExtraCanChange callbacks. There is a small
4972	// chance of a race insofar as the callback might be called twice if two callers
4973	// change the same key at the same time, but that's a much better solution
4974	// than the deadlock we had here before. The actual changing of the extradata
4975	// is then performed under the write lock and race-free.
4976
4977	// look up the old value first; if nothing has changed then we need not do anything
4978	{
4979	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); // hold read lock only while looking up
4980
4981	// For snapshots don't even think about allowing changes, extradata
4982	// is global for a machine, so there is nothing snapshot specific.
4983	if (i_isSnapshotMachine())
4984	return setError(VBOX_E_INVALID_VM_STATE,
4985	tr("Cannot set extradata for a snapshot"));
4986
4987	// check if the right IMachine instance is used
4988	if (mData->mRegistered && !i_isSessionMachine())
4989	return setError(VBOX_E_INVALID_VM_STATE,
4990	tr("Cannot set extradata for an immutable machine"));
4991
4992	settings::StringsMap::const_iterator it = mData->pMachineConfigFile->mapExtraDataItems.find(aKey);
4993	if (it != mData->pMachineConfigFile->mapExtraDataItems.end())
4994	strOldValue = it->second;
4995	}
4996
4997	bool fChanged;
4998	if ((fChanged = (strOldValue != aValue)))
4999	{
5000	// ask for permission from all listeners outside the locks;
5001	// i_onExtraDataCanChange() only briefly requests the VirtualBox
5002	// lock to copy the list of callbacks to invoke
5003	Bstr error;
5004	Bstr bstrValue(aValue);
5005
5006	if (!mParent->i_onExtraDataCanChange(mData->mUuid, Bstr(aKey).raw(), bstrValue.raw(), error))
5007	{
5008	const char *sep = error.isEmpty() ? "" : ": ";
5009	CBSTR err = error.raw();
5010	Log1WarningFunc(("Someone vetoed! Change refused%s%ls\n", sep, err));
5011	return setError(E_ACCESSDENIED,
5012	tr("Could not set extra data because someone refused the requested change of '%s' to '%s'%s%ls"),
5013	aKey.c_str(),
5014	aValue.c_str(),
5015	sep,
5016	err);
5017	}
5018
5019	// data is changing and change not vetoed: then write it out under the lock
5020	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5021
5022	if (aValue.isEmpty())
5023	mData->pMachineConfigFile->mapExtraDataItems.erase(aKey);
5024	else
5025	mData->pMachineConfigFile->mapExtraDataItems[aKey] = aValue;
5026	// creates a new key if needed
5027
5028	bool fNeedsGlobalSaveSettings = false;
5029	// This saving of settings is tricky: there is no "old state" for the
5030	// extradata items at all (unlike all other settings), so the old/new
5031	// settings comparison would give a wrong result!
5032	i_saveSettings(&fNeedsGlobalSaveSettings, SaveS_Force);
5033
5034	if (fNeedsGlobalSaveSettings)
5035	{
5036	// save the global settings; for that we should hold only the VirtualBox lock
5037	alock.release();
5038	AutoWriteLock vboxlock(mParent COMMA_LOCKVAL_SRC_POS);
5039	mParent->i_saveSettings();
5040	}
5041	}
5042
5043	// fire notification outside the lock
5044	if (fChanged)
5045	mParent->i_onExtraDataChange(mData->mUuid, Bstr(aKey).raw(), Bstr(aValue).raw());
5046
5047	return S_OK;
5048	}
5049
5050	HRESULT Machine::setSettingsFilePath(const com::Utf8Str &aSettingsFilePath, ComPtr<IProgress> &aProgress)
5051	{
5052	aProgress = NULL;
5053	NOREF(aSettingsFilePath);
5054	ReturnComNotImplemented();
5055	}
5056
5057	HRESULT Machine::saveSettings()
5058	{
5059	AutoWriteLock mlock(this COMMA_LOCKVAL_SRC_POS);
5060
5061	HRESULT rc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
5062	if (FAILED(rc)) return rc;
5063
5064	/* the settings file path may never be null */
5065	ComAssertRet(!mData->m_strConfigFileFull.isEmpty(), E_FAIL);
5066
5067	/* save all VM data excluding snapshots */
5068	bool fNeedsGlobalSaveSettings = false;
5069	rc = i_saveSettings(&fNeedsGlobalSaveSettings);
5070	mlock.release();
5071
5072	if (SUCCEEDED(rc) && fNeedsGlobalSaveSettings)
5073	{
5074	// save the global settings; for that we should hold only the VirtualBox lock
5075	AutoWriteLock vlock(mParent COMMA_LOCKVAL_SRC_POS);
5076	rc = mParent->i_saveSettings();
5077	}
5078
5079	return rc;
5080	}
5081
5082
5083	HRESULT Machine::discardSettings()
5084	{
5085	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5086
5087	HRESULT rc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
5088	if (FAILED(rc)) return rc;
5089
5090	/*
5091	* during this rollback, the session will be notified if data has
5092	* been actually changed
5093	*/
5094	i_rollback(true /* aNotify */);
5095
5096	return S_OK;
5097	}
5098
5099	/** @note Locks objects! */
5100	HRESULT Machine::unregister(AutoCaller &autoCaller,
5101	CleanupMode_T aCleanupMode,
5102	std::vector<ComPtr<IMedium> > &aMedia)
5103	{
5104	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5105
5106	Guid id(i_getId());
5107
5108	if (mData->mSession.mState != SessionState_Unlocked)
5109	return setError(VBOX_E_INVALID_OBJECT_STATE,
5110	tr("Cannot unregister the machine '%s' while it is locked"),
5111	mUserData->s.strName.c_str());
5112
5113	// wait for state dependents to drop to zero
5114	i_ensureNoStateDependencies();
5115
5116	if (!mData->mAccessible)
5117	{
5118	// inaccessible maschines can only be unregistered; uninitialize ourselves
5119	// here because currently there may be no unregistered that are inaccessible
5120	// (this state combination is not supported). Note releasing the caller and
5121	// leaving the lock before calling uninit()
5122	alock.release();
5123	autoCaller.release();
5124
5125	uninit();
5126
5127	mParent->i_unregisterMachine(this, id);
5128	// calls VirtualBox::i_saveSettings()
5129
5130	return S_OK;
5131	}
5132
5133	HRESULT rc = S_OK;
5134
5135	/// @todo r=klaus this is stupid... why is the saved state always deleted?
5136	// discard saved state
5137	if (mData->mMachineState == MachineState_Saved)
5138	{
5139	// add the saved state file to the list of files the caller should delete
5140	Assert(!mSSData->strStateFilePath.isEmpty());
5141	mData->llFilesToDelete.push_back(mSSData->strStateFilePath);
5142
5143	mSSData->strStateFilePath.setNull();
5144
5145	// unconditionally set the machine state to powered off, we now
5146	// know no session has locked the machine
5147	mData->mMachineState = MachineState_PoweredOff;
5148	}
5149
5150	size_t cSnapshots = 0;
5151	if (mData->mFirstSnapshot)
5152	cSnapshots = mData->mFirstSnapshot->i_getAllChildrenCount() + 1;
5153	if (cSnapshots && aCleanupMode == CleanupMode_UnregisterOnly)
5154	// fail now before we start detaching media
5155	return setError(VBOX_E_INVALID_OBJECT_STATE,
5156	tr("Cannot unregister the machine '%s' because it has %d snapshots"),
5157	mUserData->s.strName.c_str(), cSnapshots);
5158
5159	// This list collects the medium objects from all medium attachments
5160	// which we will detach from the machine and its snapshots, in a specific
5161	// order which allows for closing all media without getting "media in use"
5162	// errors, simply by going through the list from the front to the back:
5163	// 1) first media from machine attachments (these have the "leaf" attachments with snapshots
5164	// and must be closed before the parent media from the snapshots, or closing the parents
5165	// will fail because they still have children);
5166	// 2) media from the youngest snapshots followed by those from the parent snapshots until
5167	// the root ("first") snapshot of the machine.
5168	MediaList llMedia;
5169
5170	if ( !mMediumAttachments.isNull() // can be NULL if machine is inaccessible
5171	&& mMediumAttachments->size()
5172	)
5173	{
5174	// we have media attachments: detach them all and add the Medium objects to our list
5175	if (aCleanupMode != CleanupMode_UnregisterOnly)
5176	i_detachAllMedia(alock, NULL /* pSnapshot */, aCleanupMode, llMedia);
5177	else
5178	return setError(VBOX_E_INVALID_OBJECT_STATE,
5179	tr("Cannot unregister the machine '%s' because it has %d media attachments"),
5180	mUserData->s.strName.c_str(), mMediumAttachments->size());
5181	}
5182
5183	if (cSnapshots)
5184	{
5185	// add the media from the medium attachments of the snapshots to llMedia
5186	// as well, after the "main" machine media; Snapshot::uninitRecursively()
5187	// calls Machine::detachAllMedia() for the snapshot machine, recursing
5188	// into the children first
5189
5190	// Snapshot::beginDeletingSnapshot() asserts if the machine state is not this
5191	MachineState_T oldState = mData->mMachineState;
5192	mData->mMachineState = MachineState_DeletingSnapshot;
5193
5194	// make a copy of the first snapshot so the refcount does not drop to 0
5195	// in beginDeletingSnapshot, which sets pFirstSnapshot to 0 (that hangs
5196	// because of the AutoCaller voodoo)
5197	ComObjPtr<Snapshot> pFirstSnapshot = mData->mFirstSnapshot;
5198
5199	// GO!
5200	pFirstSnapshot->i_uninitRecursively(alock, aCleanupMode, llMedia, mData->llFilesToDelete);
5201
5202	mData->mMachineState = oldState;
5203	}
5204
5205	if (FAILED(rc))
5206	{
5207	i_rollbackMedia();
5208	return rc;
5209	}
5210
5211	// commit all the media changes made above
5212	i_commitMedia();
5213
5214	mData->mRegistered = false;
5215
5216	// machine lock no longer needed
5217	alock.release();
5218
5219	// return media to caller
5220	aMedia.resize(llMedia.size());
5221	size_t i = 0;
5222	for (MediaList::const_iterator
5223	it = llMedia.begin();
5224	it != llMedia.end();
5225	++it, ++i)
5226	(*it).queryInterfaceTo(aMedia[i].asOutParam());
5227
5228	mParent->i_unregisterMachine(this, id);
5229	// calls VirtualBox::i_saveSettings() and VirtualBox::saveModifiedRegistries()
5230
5231	return S_OK;
5232	}
5233
5234	/**
5235	* Task record for deleting a machine config.
5236	*/
5237	class Machine::DeleteConfigTask
5238	: public Machine::Task
5239	{
5240	public:
5241	DeleteConfigTask(Machine *m,
5242	Progress *p,
5243	const Utf8Str &t,
5244	const RTCList<ComPtr<IMedium> > &llMediums,
5245	const StringsList &llFilesToDelete)
5246	: Task(m, p, t),
5247	m_llMediums(llMediums),
5248	m_llFilesToDelete(llFilesToDelete)
5249	{}
5250
5251	private:
5252	void handler()
5253	{
5254	try
5255	{
5256	m_pMachine->i_deleteConfigHandler(*this);
5257	}
5258	catch (...)
5259	{
5260	LogRel(("Some exception in the function Machine::i_deleteConfigHandler()\n"));
5261	}
5262	}
5263
5264	RTCList<ComPtr<IMedium> > m_llMediums;
5265	StringsList m_llFilesToDelete;
5266
5267	friend void Machine::i_deleteConfigHandler(DeleteConfigTask &task);
5268	};
5269
5270	/**
5271	* Task thread implementation for SessionMachine::DeleteConfig(), called from
5272	* SessionMachine::taskHandler().
5273	*
5274	* @note Locks this object for writing.
5275	*
5276	* @param task
5277	* @return
5278	*/
5279	void Machine::i_deleteConfigHandler(DeleteConfigTask &task)
5280	{
5281	LogFlowThisFuncEnter();
5282
5283	AutoCaller autoCaller(this);
5284	LogFlowThisFunc(("state=%d\n", getObjectState().getState()));
5285	if (FAILED(autoCaller.rc()))
5286	{
5287	/* we might have been uninitialized because the session was accidentally
5288	* closed by the client, so don't assert */
5289	HRESULT rc = setError(E_FAIL,
5290	tr("The session has been accidentally closed"));
5291	task.m_pProgress->i_notifyComplete(rc);
5292	LogFlowThisFuncLeave();
5293	return;
5294	}
5295
5296	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5297
5298	HRESULT rc = S_OK;
5299
5300	try
5301	{
5302	ULONG uLogHistoryCount = 3;
5303	ComPtr<ISystemProperties> systemProperties;
5304	rc = mParent->COMGETTER(SystemProperties)(systemProperties.asOutParam());
5305	if (FAILED(rc)) throw rc;
5306
5307	if (!systemProperties.isNull())
5308	{
5309	rc = systemProperties->COMGETTER(LogHistoryCount)(&uLogHistoryCount);
5310	if (FAILED(rc)) throw rc;
5311	}
5312
5313	MachineState_T oldState = mData->mMachineState;
5314	i_setMachineState(MachineState_SettingUp);
5315	alock.release();
5316	for (size_t i = 0; i < task.m_llMediums.size(); ++i)
5317	{
5318	ComObjPtr<Medium> pMedium = (Medium)(IMedium)(task.m_llMediums.at(i));
5319	{
5320	AutoCaller mac(pMedium);
5321	if (FAILED(mac.rc())) throw mac.rc();
5322	Utf8Str strLocation = pMedium->i_getLocationFull();
5323	LogFunc(("Deleting file %s\n", strLocation.c_str()));
5324	rc = task.m_pProgress->SetNextOperation(BstrFmt(tr("Deleting '%s'"), strLocation.c_str()).raw(), 1);
5325	if (FAILED(rc)) throw rc;
5326	}
5327	if (pMedium->i_isMediumFormatFile())
5328	{
5329	ComPtr<IProgress> pProgress2;
5330	rc = pMedium->DeleteStorage(pProgress2.asOutParam());
5331	if (FAILED(rc)) throw rc;
5332	rc = task.m_pProgress->WaitForAsyncProgressCompletion(pProgress2);
5333	if (FAILED(rc)) throw rc;
5334	/* Check the result of the asynchronous process. */
5335	LONG iRc;
5336	rc = pProgress2->COMGETTER(ResultCode)(&iRc);
5337	if (FAILED(rc)) throw rc;
5338	/* If the thread of the progress object has an error, then
5339	* retrieve the error info from there, or it'll be lost. */
5340	if (FAILED(iRc))
5341	throw setError(ProgressErrorInfo(pProgress2));
5342	}
5343
5344	/* Close the medium, deliberately without checking the return
5345	* code, and without leaving any trace in the error info, as
5346	* a failure here is a very minor issue, which shouldn't happen
5347	* as above we even managed to delete the medium. */
5348	{
5349	ErrorInfoKeeper eik;
5350	pMedium->Close();
5351	}
5352	}
5353	i_setMachineState(oldState);
5354	alock.acquire();
5355
5356	// delete the files pushed on the task list by Machine::Delete()
5357	// (this includes saved states of the machine and snapshots and
5358	// medium storage files from the IMedium list passed in, and the
5359	// machine XML file)
5360	for (StringsList::const_iterator
5361	it = task.m_llFilesToDelete.begin();
5362	it != task.m_llFilesToDelete.end();
5363	++it)
5364	{
5365	const Utf8Str &strFile = *it;
5366	LogFunc(("Deleting file %s\n", strFile.c_str()));
5367	rc = task.m_pProgress->SetNextOperation(BstrFmt(tr("Deleting '%s'"), it->c_str()).raw(), 1);
5368	if (FAILED(rc)) throw rc;
5369
5370	int vrc = RTFileDelete(strFile.c_str());
5371	if (RT_FAILURE(vrc))
5372	throw setError(VBOX_E_IPRT_ERROR,
5373	tr("Could not delete file '%s' (%Rrc)"), strFile.c_str(), vrc);
5374	}
5375
5376	rc = task.m_pProgress->SetNextOperation(Bstr(tr("Cleaning up machine directory")).raw(), 1);
5377	if (FAILED(rc)) throw rc;
5378
5379	/* delete the settings only when the file actually exists */
5380	if (mData->pMachineConfigFile->fileExists())
5381	{
5382	/* Delete any backup or uncommitted XML files. Ignore failures.
5383	See the fSafe parameter of xml::XmlFileWriter::write for details. */
5384	/** @todo Find a way to avoid referring directly to iprt/xml.h here. */
5385	Utf8Str otherXml = Utf8StrFmt("%s%s", mData->m_strConfigFileFull.c_str(), xml::XmlFileWriter::s_pszTmpSuff);
5386	RTFileDelete(otherXml.c_str());
5387	otherXml = Utf8StrFmt("%s%s", mData->m_strConfigFileFull.c_str(), xml::XmlFileWriter::s_pszPrevSuff);
5388	RTFileDelete(otherXml.c_str());
5389
5390	/* delete the Logs folder, nothing important should be left
5391	* there (we don't check for errors because the user might have
5392	* some private files there that we don't want to delete) */
5393	Utf8Str logFolder;
5394	getLogFolder(logFolder);
5395	Assert(logFolder.length());
5396	if (RTDirExists(logFolder.c_str()))
5397	{
5398	/* Delete all VBox.log[.N] files from the Logs folder
5399	* (this must be in sync with the rotation logic in
5400	* Console::powerUpThread()). Also, delete the VBox.png[.N]
5401	* files that may have been created by the GUI. */
5402	Utf8Str log = Utf8StrFmt("%s%cVBox.log",
5403	logFolder.c_str(), RTPATH_DELIMITER);
5404	RTFileDelete(log.c_str());
5405	log = Utf8StrFmt("%s%cVBox.png",
5406	logFolder.c_str(), RTPATH_DELIMITER);
5407	RTFileDelete(log.c_str());
5408	for (int i = uLogHistoryCount; i > 0; i--)
5409	{
5410	log = Utf8StrFmt("%s%cVBox.log.%d",
5411	logFolder.c_str(), RTPATH_DELIMITER, i);
5412	RTFileDelete(log.c_str());
5413	log = Utf8StrFmt("%s%cVBox.png.%d",
5414	logFolder.c_str(), RTPATH_DELIMITER, i);
5415	RTFileDelete(log.c_str());
5416	}
5417	#if defined(RT_OS_WINDOWS)
5418	log = Utf8StrFmt("%s%cVBoxStartup.log", logFolder.c_str(), RTPATH_DELIMITER);
5419	RTFileDelete(log.c_str());
5420	log = Utf8StrFmt("%s%cVBoxHardening.log", logFolder.c_str(), RTPATH_DELIMITER);
5421	RTFileDelete(log.c_str());
5422	#endif
5423
5424	RTDirRemove(logFolder.c_str());
5425	}
5426
5427	/* delete the Snapshots folder, nothing important should be left
5428	* there (we don't check for errors because the user might have
5429	* some private files there that we don't want to delete) */
5430	Utf8Str strFullSnapshotFolder;
5431	i_calculateFullPath(mUserData->s.strSnapshotFolder, strFullSnapshotFolder);
5432	Assert(!strFullSnapshotFolder.isEmpty());
5433	if (RTDirExists(strFullSnapshotFolder.c_str()))
5434	RTDirRemove(strFullSnapshotFolder.c_str());
5435
5436	// delete the directory that contains the settings file, but only
5437	// if it matches the VM name
5438	Utf8Str settingsDir;
5439	if (i_isInOwnDir(&settingsDir))
5440	RTDirRemove(settingsDir.c_str());
5441	}
5442
5443	alock.release();
5444
5445	mParent->i_saveModifiedRegistries();
5446	}
5447	catch (HRESULT aRC) { rc = aRC; }
5448
5449	task.m_pProgress->i_notifyComplete(rc);
5450
5451	LogFlowThisFuncLeave();
5452	}
5453
5454	HRESULT Machine::deleteConfig(const std::vector<ComPtr<IMedium> > &aMedia, ComPtr<IProgress> &aProgress)
5455	{
5456	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5457
5458	HRESULT rc = i_checkStateDependency(MutableStateDep);
5459	if (FAILED(rc)) return rc;
5460
5461	if (mData->mRegistered)
5462	return setError(VBOX_E_INVALID_VM_STATE,
5463	tr("Cannot delete settings of a registered machine"));
5464
5465	// collect files to delete
5466	StringsList llFilesToDelete(mData->llFilesToDelete); // saved states pushed here by Unregister()
5467	if (mData->pMachineConfigFile->fileExists())
5468	llFilesToDelete.push_back(mData->m_strConfigFileFull);
5469
5470	RTCList<ComPtr<IMedium> > llMediums;
5471	for (size_t i = 0; i < aMedia.size(); ++i)
5472	{
5473	IMedium *pIMedium(aMedia[i]);
5474	ComObjPtr<Medium> pMedium = static_cast<Medium*>(pIMedium);
5475	if (pMedium.isNull())
5476	return setError(E_INVALIDARG, "The given medium pointer with index %d is invalid", i);
5477	SafeArray<BSTR> ids;
5478	rc = pMedium->COMGETTER(MachineIds)(ComSafeArrayAsOutParam(ids));
5479	if (FAILED(rc)) return rc;
5480	/* At this point the medium should not have any back references
5481	* anymore. If it has it is attached to another VM and must not
5482	* deleted. */
5483	if (ids.size() < 1)
5484	llMediums.append(pMedium);
5485	}
5486
5487	ComObjPtr<Progress> pProgress;
5488	pProgress.createObject();
5489	rc = pProgress->init(i_getVirtualBox(),
5490	static_cast<IMachine>(this) / aInitiator */,
5491	tr("Deleting files"),
5492	true /* fCancellable */,
5493	(ULONG)(1 + llMediums.size() + llFilesToDelete.size() + 1), // cOperations
5494	tr("Collecting file inventory"));
5495	if (FAILED(rc))
5496	return rc;
5497
5498	/* create and start the task on a separate thread (note that it will not
5499	* start working until we release alock) */
5500	DeleteConfigTask *pTask = new DeleteConfigTask(this, pProgress, "DeleteVM", llMediums, llFilesToDelete);
5501	rc = pTask->createThread();
5502	if (FAILED(rc))
5503	return rc;
5504
5505	pProgress.queryInterfaceTo(aProgress.asOutParam());
5506
5507	LogFlowFuncLeave();
5508
5509	return S_OK;
5510	}
5511
5512	HRESULT Machine::findSnapshot(const com::Utf8Str &aNameOrId, ComPtr<ISnapshot> &aSnapshot)
5513	{
5514	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5515
5516	ComObjPtr<Snapshot> pSnapshot;
5517	HRESULT rc;
5518
5519	if (aNameOrId.isEmpty())
5520	// null case (caller wants root snapshot): i_findSnapshotById() handles this
5521	rc = i_findSnapshotById(Guid(), pSnapshot, true /* aSetError */);
5522	else
5523	{
5524	Guid uuid(aNameOrId);
5525	if (uuid.isValid())
5526	rc = i_findSnapshotById(uuid, pSnapshot, true /* aSetError */);
5527	else
5528	rc = i_findSnapshotByName(aNameOrId, pSnapshot, true /* aSetError */);
5529	}
5530	pSnapshot.queryInterfaceTo(aSnapshot.asOutParam());
5531
5532	return rc;
5533	}
5534
5535	HRESULT Machine::createSharedFolder(const com::Utf8Str &aName, const com::Utf8Str &aHostPath, BOOL aWritable, BOOL aAutomount)
5536	{
5537	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5538
5539	HRESULT rc = i_checkStateDependency(MutableOrRunningStateDep);
5540	if (FAILED(rc)) return rc;
5541
5542	ComObjPtr<SharedFolder> sharedFolder;
5543	rc = i_findSharedFolder(aName, sharedFolder, false /* aSetError */);
5544	if (SUCCEEDED(rc))
5545	return setError(VBOX_E_OBJECT_IN_USE,
5546	tr("Shared folder named '%s' already exists"),
5547	aName.c_str());
5548
5549	sharedFolder.createObject();
5550	rc = sharedFolder->init(i_getMachine(),
5551	aName,
5552	aHostPath,
5553	!!aWritable,
5554	!!aAutomount,
5555	true /* fFailOnError */);
5556	if (FAILED(rc)) return rc;
5557
5558	i_setModified(IsModified_SharedFolders);
5559	mHWData.backup();
5560	mHWData->mSharedFolders.push_back(sharedFolder);
5561
5562	/* inform the direct session if any */
5563	alock.release();
5564	i_onSharedFolderChange();
5565
5566	return S_OK;
5567	}
5568
5569	HRESULT Machine::removeSharedFolder(const com::Utf8Str &aName)
5570	{
5571	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5572
5573	HRESULT rc = i_checkStateDependency(MutableOrRunningStateDep);
5574	if (FAILED(rc)) return rc;
5575
5576	ComObjPtr<SharedFolder> sharedFolder;
5577	rc = i_findSharedFolder(aName, sharedFolder, true /* aSetError */);
5578	if (FAILED(rc)) return rc;
5579
5580	i_setModified(IsModified_SharedFolders);
5581	mHWData.backup();
5582	mHWData->mSharedFolders.remove(sharedFolder);
5583
5584	/* inform the direct session if any */
5585	alock.release();
5586	i_onSharedFolderChange();
5587
5588	return S_OK;
5589	}
5590
5591	HRESULT Machine::canShowConsoleWindow(BOOL *aCanShow)
5592	{
5593	/* start with No */
5594	*aCanShow = FALSE;
5595
5596	ComPtr<IInternalSessionControl> directControl;
5597	{
5598	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5599
5600	if (mData->mSession.mState != SessionState_Locked)
5601	return setError(VBOX_E_INVALID_VM_STATE,
5602	tr("Machine is not locked for session (session state: %s)"),
5603	Global::stringifySessionState(mData->mSession.mState));
5604
5605	if (mData->mSession.mLockType == LockType_VM)
5606	directControl = mData->mSession.mDirectControl;
5607	}
5608
5609	/* ignore calls made after #OnSessionEnd() is called */
5610	if (!directControl)
5611	return S_OK;
5612
5613	LONG64 dummy;
5614	return directControl->OnShowWindow(TRUE /* aCheck */, aCanShow, &dummy);
5615	}
5616
5617	HRESULT Machine::showConsoleWindow(LONG64 *aWinId)
5618	{
5619	ComPtr<IInternalSessionControl> directControl;
5620	{
5621	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5622
5623	if (mData->mSession.mState != SessionState_Locked)
5624	return setError(E_FAIL,
5625	tr("Machine is not locked for session (session state: %s)"),
5626	Global::stringifySessionState(mData->mSession.mState));
5627
5628	if (mData->mSession.mLockType == LockType_VM)
5629	directControl = mData->mSession.mDirectControl;
5630	}
5631
5632	/* ignore calls made after #OnSessionEnd() is called */
5633	if (!directControl)
5634	return S_OK;
5635
5636	BOOL dummy;
5637	return directControl->OnShowWindow(FALSE /* aCheck */, &dummy, aWinId);
5638	}
5639
5640	#ifdef VBOX_WITH_GUEST_PROPS
5641	/**
5642	* Look up a guest property in VBoxSVC's internal structures.
5643	*/
5644	HRESULT Machine::i_getGuestPropertyFromService(const com::Utf8Str &aName,
5645	com::Utf8Str &aValue,
5646	LONG64 *aTimestamp,
5647	com::Utf8Str &aFlags) const
5648	{
5649	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5650
5651	HWData::GuestPropertyMap::const_iterator it = mHWData->mGuestProperties.find(aName);
5652	if (it != mHWData->mGuestProperties.end())
5653	{
5654	char szFlags[GUEST_PROP_MAX_FLAGS_LEN + 1];
5655	aValue = it->second.strValue;
5656	*aTimestamp = it->second.mTimestamp;
5657	GuestPropWriteFlags(it->second.mFlags, szFlags);
5658	aFlags = Utf8Str(szFlags);
5659	}
5660
5661	return S_OK;
5662	}
5663
5664	/**
5665	* Query the VM that a guest property belongs to for the property.
5666	* @returns E_ACCESSDENIED if the VM process is not available or not
5667	* currently handling queries and the lookup should then be done in
5668	* VBoxSVC.
5669	*/
5670	HRESULT Machine::i_getGuestPropertyFromVM(const com::Utf8Str &aName,
5671	com::Utf8Str &aValue,
5672	LONG64 *aTimestamp,
5673	com::Utf8Str &aFlags) const
5674	{
5675	HRESULT rc = S_OK;
5676	BSTR bValue = NULL;
5677	BSTR bFlags = NULL;
5678
5679	ComPtr<IInternalSessionControl> directControl;
5680	{
5681	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5682	if (mData->mSession.mLockType == LockType_VM)
5683	directControl = mData->mSession.mDirectControl;
5684	}
5685
5686	/* ignore calls made after #OnSessionEnd() is called */
5687	if (!directControl)
5688	rc = E_ACCESSDENIED;
5689	else
5690	rc = directControl->AccessGuestProperty(Bstr(aName).raw(), Bstr::Empty.raw(), Bstr::Empty.raw(),
5691	0 /* accessMode */,
5692	&bValue, aTimestamp, &bFlags);
5693
5694	aValue = bValue;
5695	aFlags = bFlags;
5696
5697	return rc;
5698	}
5699	#endif // VBOX_WITH_GUEST_PROPS
5700
5701	HRESULT Machine::getGuestProperty(const com::Utf8Str &aName,
5702	com::Utf8Str &aValue,
5703	LONG64 *aTimestamp,
5704	com::Utf8Str &aFlags)
5705	{
5706	#ifndef VBOX_WITH_GUEST_PROPS
5707	ReturnComNotImplemented();
5708	#else // VBOX_WITH_GUEST_PROPS
5709
5710	HRESULT rc = i_getGuestPropertyFromVM(aName, aValue, aTimestamp, aFlags);
5711
5712	if (rc == E_ACCESSDENIED)
5713	/* The VM is not running or the service is not (yet) accessible */
5714	rc = i_getGuestPropertyFromService(aName, aValue, aTimestamp, aFlags);
5715	return rc;
5716	#endif // VBOX_WITH_GUEST_PROPS
5717	}
5718
5719	HRESULT Machine::getGuestPropertyValue(const com::Utf8Str &aProperty, com::Utf8Str &aValue)
5720	{
5721	LONG64 dummyTimestamp;
5722	com::Utf8Str dummyFlags;
5723	HRESULT rc = getGuestProperty(aProperty, aValue, &dummyTimestamp, dummyFlags);
5724	return rc;
5725
5726	}
5727	HRESULT Machine::getGuestPropertyTimestamp(const com::Utf8Str &aProperty, LONG64 *aValue)
5728	{
5729	com::Utf8Str dummyFlags;
5730	com::Utf8Str dummyValue;
5731	HRESULT rc = getGuestProperty(aProperty, dummyValue, aValue, dummyFlags);
5732	return rc;
5733	}
5734
5735	#ifdef VBOX_WITH_GUEST_PROPS
5736	/**
5737	* Set a guest property in VBoxSVC's internal structures.
5738	*/
5739	HRESULT Machine::i_setGuestPropertyToService(const com::Utf8Str &aName, const com::Utf8Str &aValue,
5740	const com::Utf8Str &aFlags, bool fDelete)
5741	{
5742	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5743	HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
5744	if (FAILED(rc)) return rc;
5745
5746	try
5747	{
5748	uint32_t fFlags = GUEST_PROP_F_NILFLAG;
5749	if (aFlags.length() && RT_FAILURE(GuestPropValidateFlags(aFlags.c_str(), &fFlags)))
5750	return setError(E_INVALIDARG, tr("Invalid guest property flag values: '%s'"), aFlags.c_str());
5751
5752	HWData::GuestPropertyMap::iterator it = mHWData->mGuestProperties.find(aName);
5753	if (it == mHWData->mGuestProperties.end())
5754	{
5755	if (!fDelete)
5756	{
5757	i_setModified(IsModified_MachineData);
5758	mHWData.backupEx();
5759
5760	RTTIMESPEC time;
5761	HWData::GuestProperty prop;
5762	prop.strValue = Bstr(aValue).raw();
5763	prop.mTimestamp = RTTimeSpecGetNano(RTTimeNow(&time));
5764	prop.mFlags = fFlags;
5765	mHWData->mGuestProperties[aName] = prop;
5766	}
5767	}
5768	else
5769	{
5770	if (it->second.mFlags & (GUEST_PROP_F_RDONLYHOST))
5771	{
5772	rc = setError(E_ACCESSDENIED, tr("The property '%s' cannot be changed by the host"), aName.c_str());
5773	}
5774	else
5775	{
5776	i_setModified(IsModified_MachineData);
5777	mHWData.backupEx();
5778
5779	/* The backupEx() operation invalidates our iterator,
5780	* so get a new one. */
5781	it = mHWData->mGuestProperties.find(aName);
5782	Assert(it != mHWData->mGuestProperties.end());
5783
5784	if (!fDelete)
5785	{
5786	RTTIMESPEC time;
5787	it->second.strValue = aValue;
5788	it->second.mTimestamp = RTTimeSpecGetNano(RTTimeNow(&time));
5789	it->second.mFlags = fFlags;
5790	}
5791	else
5792	mHWData->mGuestProperties.erase(it);
5793	}
5794	}
5795
5796	if (SUCCEEDED(rc))
5797	{
5798	alock.release();
5799
5800	mParent->i_onGuestPropertyChange(mData->mUuid,
5801	Bstr(aName).raw(),
5802	Bstr(aValue).raw(),
5803	Bstr(aFlags).raw());
5804	}
5805	}
5806	catch (std::bad_alloc &)
5807	{
5808	rc = E_OUTOFMEMORY;
5809	}
5810
5811	return rc;
5812	}
5813
5814	/**
5815	* Set a property on the VM that that property belongs to.
5816	* @returns E_ACCESSDENIED if the VM process is not available or not
5817	* currently handling queries and the setting should then be done in
5818	* VBoxSVC.
5819	*/
5820	HRESULT Machine::i_setGuestPropertyToVM(const com::Utf8Str &aName, const com::Utf8Str &aValue,
5821	const com::Utf8Str &aFlags, bool fDelete)
5822	{
5823	HRESULT rc;
5824
5825	try
5826	{
5827	ComPtr<IInternalSessionControl> directControl;
5828	{
5829	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5830	if (mData->mSession.mLockType == LockType_VM)
5831	directControl = mData->mSession.mDirectControl;
5832	}
5833
5834	BSTR dummy = NULL; /* will not be changed (setter) */
5835	LONG64 dummy64;
5836	if (!directControl)
5837	rc = E_ACCESSDENIED;
5838	else
5839	/** @todo Fix when adding DeleteGuestProperty(), see defect. */
5840	rc = directControl->AccessGuestProperty(Bstr(aName).raw(), Bstr(aValue).raw(), Bstr(aFlags).raw(),
5841	fDelete? 2: 1 /* accessMode */,
5842	&dummy, &dummy64, &dummy);
5843	}
5844	catch (std::bad_alloc &)
5845	{
5846	rc = E_OUTOFMEMORY;
5847	}
5848
5849	return rc;
5850	}
5851	#endif // VBOX_WITH_GUEST_PROPS
5852
5853	HRESULT Machine::setGuestProperty(const com::Utf8Str &aProperty, const com::Utf8Str &aValue,
5854	const com::Utf8Str &aFlags)
5855	{
5856	#ifndef VBOX_WITH_GUEST_PROPS
5857	ReturnComNotImplemented();
5858	#else // VBOX_WITH_GUEST_PROPS
5859	HRESULT rc = i_setGuestPropertyToVM(aProperty, aValue, aFlags, /* fDelete = */ false);
5860	if (rc == E_ACCESSDENIED)
5861	/* The VM is not running or the service is not (yet) accessible */
5862	rc = i_setGuestPropertyToService(aProperty, aValue, aFlags, /* fDelete = */ false);
5863	return rc;
5864	#endif // VBOX_WITH_GUEST_PROPS
5865	}
5866
5867	HRESULT Machine::setGuestPropertyValue(const com::Utf8Str &aProperty, const com::Utf8Str &aValue)
5868	{
5869	return setGuestProperty(aProperty, aValue, "");
5870	}
5871
5872	HRESULT Machine::deleteGuestProperty(const com::Utf8Str &aName)
5873	{
5874	#ifndef VBOX_WITH_GUEST_PROPS
5875	ReturnComNotImplemented();
5876	#else // VBOX_WITH_GUEST_PROPS
5877	HRESULT rc = i_setGuestPropertyToVM(aName, "", "", /* fDelete = */ true);
5878	if (rc == E_ACCESSDENIED)
5879	/* The VM is not running or the service is not (yet) accessible */
5880	rc = i_setGuestPropertyToService(aName, "", "", /* fDelete = */ true);
5881	return rc;
5882	#endif // VBOX_WITH_GUEST_PROPS
5883	}
5884
5885	#ifdef VBOX_WITH_GUEST_PROPS
5886	/**
5887	* Enumerate the guest properties in VBoxSVC's internal structures.
5888	*/
5889	HRESULT Machine::i_enumerateGuestPropertiesInService(const com::Utf8Str &aPatterns,
5890	std::vector<com::Utf8Str> &aNames,
5891	std::vector<com::Utf8Str> &aValues,
5892	std::vector<LONG64> &aTimestamps,
5893	std::vector<com::Utf8Str> &aFlags)
5894	{
5895	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5896	Utf8Str strPatterns(aPatterns);
5897
5898	/*
5899	* Look for matching patterns and build up a list.
5900	*/
5901	HWData::GuestPropertyMap propMap;
5902	for (HWData::GuestPropertyMap::const_iterator
5903	it = mHWData->mGuestProperties.begin();
5904	it != mHWData->mGuestProperties.end();
5905	++it)
5906	{
5907	if ( strPatterns.isEmpty()
5908	\|\| RTStrSimplePatternMultiMatch(strPatterns.c_str(),
5909	RTSTR_MAX,
5910	it->first.c_str(),
5911	RTSTR_MAX,
5912	NULL)
5913	)
5914	propMap.insert(*it);
5915	}
5916
5917	alock.release();
5918
5919	/*
5920	* And build up the arrays for returning the property information.
5921	*/
5922	size_t cEntries = propMap.size();
5923
5924	aNames.resize(cEntries);
5925	aValues.resize(cEntries);
5926	aTimestamps.resize(cEntries);
5927	aFlags.resize(cEntries);
5928
5929	char szFlags[GUEST_PROP_MAX_FLAGS_LEN + 1];
5930	size_t i = 0;
5931	for (HWData::GuestPropertyMap::const_iterator
5932	it = propMap.begin();
5933	it != propMap.end();
5934	++it, ++i)
5935	{
5936	aNames[i] = it->first;
5937	aValues[i] = it->second.strValue;
5938	aTimestamps[i] = it->second.mTimestamp;
5939	GuestPropWriteFlags(it->second.mFlags, szFlags);
5940	aFlags[i] = Utf8Str(szFlags);
5941	}
5942
5943	return S_OK;
5944	}
5945
5946	/**
5947	* Enumerate the properties managed by a VM.
5948	* @returns E_ACCESSDENIED if the VM process is not available or not
5949	* currently handling queries and the setting should then be done in
5950	* VBoxSVC.
5951	*/
5952	HRESULT Machine::i_enumerateGuestPropertiesOnVM(const com::Utf8Str &aPatterns,
5953	std::vector<com::Utf8Str> &aNames,
5954	std::vector<com::Utf8Str> &aValues,
5955	std::vector<LONG64> &aTimestamps,
5956	std::vector<com::Utf8Str> &aFlags)
5957	{
5958	HRESULT rc;
5959	ComPtr<IInternalSessionControl> directControl;
5960	{
5961	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5962	if (mData->mSession.mLockType == LockType_VM)
5963	directControl = mData->mSession.mDirectControl;
5964	}
5965
5966	com::SafeArray<BSTR> bNames;
5967	com::SafeArray<BSTR> bValues;
5968	com::SafeArray<LONG64> bTimestamps;
5969	com::SafeArray<BSTR> bFlags;
5970
5971	if (!directControl)
5972	rc = E_ACCESSDENIED;
5973	else
5974	rc = directControl->EnumerateGuestProperties(Bstr(aPatterns).raw(),
5975	ComSafeArrayAsOutParam(bNames),
5976	ComSafeArrayAsOutParam(bValues),
5977	ComSafeArrayAsOutParam(bTimestamps),
5978	ComSafeArrayAsOutParam(bFlags));
5979	size_t i;
5980	aNames.resize(bNames.size());
5981	for (i = 0; i < bNames.size(); ++i)
5982	aNames[i] = Utf8Str(bNames[i]);
5983	aValues.resize(bValues.size());
5984	for (i = 0; i < bValues.size(); ++i)
5985	aValues[i] = Utf8Str(bValues[i]);
5986	aTimestamps.resize(bTimestamps.size());
5987	for (i = 0; i < bTimestamps.size(); ++i)
5988	aTimestamps[i] = bTimestamps[i];
5989	aFlags.resize(bFlags.size());
5990	for (i = 0; i < bFlags.size(); ++i)
5991	aFlags[i] = Utf8Str(bFlags[i]);
5992
5993	return rc;
5994	}
5995	#endif // VBOX_WITH_GUEST_PROPS
5996	HRESULT Machine::enumerateGuestProperties(const com::Utf8Str &aPatterns,
5997	std::vector<com::Utf8Str> &aNames,
5998	std::vector<com::Utf8Str> &aValues,
5999	std::vector<LONG64> &aTimestamps,
6000	std::vector<com::Utf8Str> &aFlags)
6001	{
6002	#ifndef VBOX_WITH_GUEST_PROPS
6003	ReturnComNotImplemented();
6004	#else // VBOX_WITH_GUEST_PROPS
6005
6006	HRESULT rc = i_enumerateGuestPropertiesOnVM(aPatterns, aNames, aValues, aTimestamps, aFlags);
6007
6008	if (rc == E_ACCESSDENIED)
6009	/* The VM is not running or the service is not (yet) accessible */
6010	rc = i_enumerateGuestPropertiesInService(aPatterns, aNames, aValues, aTimestamps, aFlags);
6011	return rc;
6012	#endif // VBOX_WITH_GUEST_PROPS
6013	}
6014
6015	HRESULT Machine::getMediumAttachmentsOfController(const com::Utf8Str &aName,
6016	std::vector<ComPtr<IMediumAttachment> > &aMediumAttachments)
6017	{
6018	MediumAttachmentList atts;
6019
6020	HRESULT rc = i_getMediumAttachmentsOfController(aName, atts);
6021	if (FAILED(rc)) return rc;
6022
6023	aMediumAttachments.resize(atts.size());
6024	size_t i = 0;
6025	for (MediumAttachmentList::const_iterator
6026	it = atts.begin();
6027	it != atts.end();
6028	++it, ++i)
6029	(*it).queryInterfaceTo(aMediumAttachments[i].asOutParam());
6030
6031	return S_OK;
6032	}
6033
6034	HRESULT Machine::getMediumAttachment(const com::Utf8Str &aName,
6035	LONG aControllerPort,
6036	LONG aDevice,
6037	ComPtr<IMediumAttachment> &aAttachment)
6038	{
6039	LogFlowThisFunc(("aControllerName=\"%s\" aControllerPort=%d aDevice=%d\n",
6040	aName.c_str(), aControllerPort, aDevice));
6041
6042	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6043
6044	aAttachment = NULL;
6045
6046	ComObjPtr<MediumAttachment> pAttach = i_findAttachment(*mMediumAttachments.data(),
6047	aName,
6048	aControllerPort,
6049	aDevice);
6050	if (pAttach.isNull())
6051	return setError(VBOX_E_OBJECT_NOT_FOUND,
6052	tr("No storage device attached to device slot %d on port %d of controller '%s'"),
6053	aDevice, aControllerPort, aName.c_str());
6054
6055	pAttach.queryInterfaceTo(aAttachment.asOutParam());
6056
6057	return S_OK;
6058	}
6059
6060
6061	HRESULT Machine::addStorageController(const com::Utf8Str &aName,
6062	StorageBus_T aConnectionType,
6063	ComPtr<IStorageController> &aController)
6064	{
6065	if ( (aConnectionType <= StorageBus_Null)
6066	\|\| (aConnectionType > StorageBus_PCIe))
6067	return setError(E_INVALIDARG,
6068	tr("Invalid connection type: %d"),
6069	aConnectionType);
6070
6071	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6072
6073	HRESULT rc = i_checkStateDependency(MutableStateDep);
6074	if (FAILED(rc)) return rc;
6075
6076	/* try to find one with the name first. */
6077	ComObjPtr<StorageController> ctrl;
6078
6079	rc = i_getStorageControllerByName(aName, ctrl, false /* aSetError */);
6080	if (SUCCEEDED(rc))
6081	return setError(VBOX_E_OBJECT_IN_USE,
6082	tr("Storage controller named '%s' already exists"),
6083	aName.c_str());
6084
6085	ctrl.createObject();
6086
6087	/* get a new instance number for the storage controller */
6088	ULONG ulInstance = 0;
6089	bool fBootable = true;
6090	for (StorageControllerList::const_iterator
6091	it = mStorageControllers->begin();
6092	it != mStorageControllers->end();
6093	++it)
6094	{
6095	if ((*it)->i_getStorageBus() == aConnectionType)
6096	{
6097	ULONG ulCurInst = (*it)->i_getInstance();
6098
6099	if (ulCurInst >= ulInstance)
6100	ulInstance = ulCurInst + 1;
6101
6102	/* Only one controller of each type can be marked as bootable. */
6103	if ((*it)->i_getBootable())
6104	fBootable = false;
6105	}
6106	}
6107
6108	rc = ctrl->init(this, aName, aConnectionType, ulInstance, fBootable);
6109	if (FAILED(rc)) return rc;
6110
6111	i_setModified(IsModified_Storage);
6112	mStorageControllers.backup();
6113	mStorageControllers->push_back(ctrl);
6114
6115	ctrl.queryInterfaceTo(aController.asOutParam());
6116
6117	/* inform the direct session if any */
6118	alock.release();
6119	i_onStorageControllerChange();
6120
6121	return S_OK;
6122	}
6123
6124	HRESULT Machine::getStorageControllerByName(const com::Utf8Str &aName,
6125	ComPtr<IStorageController> &aStorageController)
6126	{
6127	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6128
6129	ComObjPtr<StorageController> ctrl;
6130
6131	HRESULT rc = i_getStorageControllerByName(aName, ctrl, true /* aSetError */);
6132	if (SUCCEEDED(rc))
6133	ctrl.queryInterfaceTo(aStorageController.asOutParam());
6134
6135	return rc;
6136	}
6137
6138	HRESULT Machine::getStorageControllerByInstance(StorageBus_T aConnectionType,
6139	ULONG aInstance,
6140	ComPtr<IStorageController> &aStorageController)
6141	{
6142	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6143
6144	for (StorageControllerList::const_iterator
6145	it = mStorageControllers->begin();
6146	it != mStorageControllers->end();
6147	++it)
6148	{
6149	if ( (*it)->i_getStorageBus() == aConnectionType
6150	&& (*it)->i_getInstance() == aInstance)
6151	{
6152	(*it).queryInterfaceTo(aStorageController.asOutParam());
6153	return S_OK;
6154	}
6155	}
6156
6157	return setError(VBOX_E_OBJECT_NOT_FOUND,
6158	tr("Could not find a storage controller with instance number '%lu'"),
6159	aInstance);
6160	}
6161
6162	HRESULT Machine::setStorageControllerBootable(const com::Utf8Str &aName, BOOL aBootable)
6163	{
6164	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6165
6166	HRESULT rc = i_checkStateDependency(MutableStateDep);
6167	if (FAILED(rc)) return rc;
6168
6169	ComObjPtr<StorageController> ctrl;
6170
6171	rc = i_getStorageControllerByName(aName, ctrl, true /* aSetError */);
6172	if (SUCCEEDED(rc))
6173	{
6174	/* Ensure that only one controller of each type is marked as bootable. */
6175	if (aBootable == TRUE)
6176	{
6177	for (StorageControllerList::const_iterator
6178	it = mStorageControllers->begin();
6179	it != mStorageControllers->end();
6180	++it)
6181	{
6182	ComObjPtr<StorageController> aCtrl = (*it);
6183
6184	if ( (aCtrl->i_getName() != aName)
6185	&& aCtrl->i_getBootable() == TRUE
6186	&& aCtrl->i_getStorageBus() == ctrl->i_getStorageBus()
6187	&& aCtrl->i_getControllerType() == ctrl->i_getControllerType())
6188	{
6189	aCtrl->i_setBootable(FALSE);
6190	break;
6191	}
6192	}
6193	}
6194
6195	if (SUCCEEDED(rc))
6196	{
6197	ctrl->i_setBootable(aBootable);
6198	i_setModified(IsModified_Storage);
6199	}
6200	}
6201
6202	if (SUCCEEDED(rc))
6203	{
6204	/* inform the direct session if any */
6205	alock.release();
6206	i_onStorageControllerChange();
6207	}
6208
6209	return rc;
6210	}
6211
6212	HRESULT Machine::removeStorageController(const com::Utf8Str &aName)
6213	{
6214	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6215
6216	HRESULT rc = i_checkStateDependency(MutableStateDep);
6217	if (FAILED(rc)) return rc;
6218
6219	ComObjPtr<StorageController> ctrl;
6220	rc = i_getStorageControllerByName(aName, ctrl, true /* aSetError */);
6221	if (FAILED(rc)) return rc;
6222
6223	{
6224	/* find all attached devices to the appropriate storage controller and detach them all */
6225	// make a temporary list because detachDevice invalidates iterators into
6226	// mMediumAttachments
6227	MediumAttachmentList llAttachments2 = *mMediumAttachments.data();
6228
6229	for (MediumAttachmentList::const_iterator
6230	it = llAttachments2.begin();
6231	it != llAttachments2.end();
6232	++it)
6233	{
6234	MediumAttachment pAttachTemp = it;
6235
6236	AutoCaller localAutoCaller(pAttachTemp);
6237	if (FAILED(localAutoCaller.rc())) return localAutoCaller.rc();
6238
6239	AutoReadLock local_alock(pAttachTemp COMMA_LOCKVAL_SRC_POS);
6240
6241	if (pAttachTemp->i_getControllerName() == aName)
6242	{
6243	rc = i_detachDevice(pAttachTemp, alock, NULL);
6244	if (FAILED(rc)) return rc;
6245	}
6246	}
6247	}
6248
6249	/* We can remove it now. */
6250	i_setModified(IsModified_Storage);
6251	mStorageControllers.backup();
6252
6253	ctrl->i_unshare();
6254
6255	mStorageControllers->remove(ctrl);
6256
6257	/* inform the direct session if any */
6258	alock.release();
6259	i_onStorageControllerChange();
6260
6261	return S_OK;
6262	}
6263
6264	HRESULT Machine::addUSBController(const com::Utf8Str &aName, USBControllerType_T aType,
6265	ComPtr<IUSBController> &aController)
6266	{
6267	if ( (aType <= USBControllerType_Null)
6268	\|\| (aType >= USBControllerType_Last))
6269	return setError(E_INVALIDARG,
6270	tr("Invalid USB controller type: %d"),
6271	aType);
6272
6273	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6274
6275	HRESULT rc = i_checkStateDependency(MutableStateDep);
6276	if (FAILED(rc)) return rc;
6277
6278	/* try to find one with the same type first. */
6279	ComObjPtr<USBController> ctrl;
6280
6281	rc = i_getUSBControllerByName(aName, ctrl, false /* aSetError */);
6282	if (SUCCEEDED(rc))
6283	return setError(VBOX_E_OBJECT_IN_USE,
6284	tr("USB controller named '%s' already exists"),
6285	aName.c_str());
6286
6287	/* Check that we don't exceed the maximum number of USB controllers for the given type. */
6288	ULONG maxInstances;
6289	rc = mParent->i_getSystemProperties()->GetMaxInstancesOfUSBControllerType(mHWData->mChipsetType, aType, &maxInstances);
6290	if (FAILED(rc))
6291	return rc;
6292
6293	ULONG cInstances = i_getUSBControllerCountByType(aType);
6294	if (cInstances >= maxInstances)
6295	return setError(E_INVALIDARG,
6296	tr("Too many USB controllers of this type"));
6297
6298	ctrl.createObject();
6299
6300	rc = ctrl->init(this, aName, aType);
6301	if (FAILED(rc)) return rc;
6302
6303	i_setModified(IsModified_USB);
6304	mUSBControllers.backup();
6305	mUSBControllers->push_back(ctrl);
6306
6307	ctrl.queryInterfaceTo(aController.asOutParam());
6308
6309	/* inform the direct session if any */
6310	alock.release();
6311	i_onUSBControllerChange();
6312
6313	return S_OK;
6314	}
6315
6316	HRESULT Machine::getUSBControllerByName(const com::Utf8Str &aName, ComPtr<IUSBController> &aController)
6317	{
6318	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6319
6320	ComObjPtr<USBController> ctrl;
6321
6322	HRESULT rc = i_getUSBControllerByName(aName, ctrl, true /* aSetError */);
6323	if (SUCCEEDED(rc))
6324	ctrl.queryInterfaceTo(aController.asOutParam());
6325
6326	return rc;
6327	}
6328
6329	HRESULT Machine::getUSBControllerCountByType(USBControllerType_T aType,
6330	ULONG *aControllers)
6331	{
6332	if ( (aType <= USBControllerType_Null)
6333	\|\| (aType >= USBControllerType_Last))
6334	return setError(E_INVALIDARG,
6335	tr("Invalid USB controller type: %d"),
6336	aType);
6337
6338	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6339
6340	ComObjPtr<USBController> ctrl;
6341
6342	*aControllers = i_getUSBControllerCountByType(aType);
6343
6344	return S_OK;
6345	}
6346
6347	HRESULT Machine::removeUSBController(const com::Utf8Str &aName)
6348	{
6349
6350	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6351
6352	HRESULT rc = i_checkStateDependency(MutableStateDep);
6353	if (FAILED(rc)) return rc;
6354
6355	ComObjPtr<USBController> ctrl;
6356	rc = i_getUSBControllerByName(aName, ctrl, true /* aSetError */);
6357	if (FAILED(rc)) return rc;
6358
6359	i_setModified(IsModified_USB);
6360	mUSBControllers.backup();
6361
6362	ctrl->i_unshare();
6363
6364	mUSBControllers->remove(ctrl);
6365
6366	/* inform the direct session if any */
6367	alock.release();
6368	i_onUSBControllerChange();
6369
6370	return S_OK;
6371	}
6372
6373	HRESULT Machine::querySavedGuestScreenInfo(ULONG aScreenId,
6374	ULONG *aOriginX,
6375	ULONG *aOriginY,
6376	ULONG *aWidth,
6377	ULONG *aHeight,
6378	BOOL *aEnabled)
6379	{
6380	uint32_t u32OriginX= 0;
6381	uint32_t u32OriginY= 0;
6382	uint32_t u32Width = 0;
6383	uint32_t u32Height = 0;
6384	uint16_t u16Flags = 0;
6385
6386	int vrc = readSavedGuestScreenInfo(mSSData->strStateFilePath, aScreenId,
6387	&u32OriginX, &u32OriginY, &u32Width, &u32Height, &u16Flags);
6388	if (RT_FAILURE(vrc))
6389	{
6390	#ifdef RT_OS_WINDOWS
6391	/* HACK: GUI sets *pfEnabled to 'true' and expects it to stay so if the API fails.
6392	* This works with XPCOM. But Windows COM sets all output parameters to zero.
6393	* So just assign fEnable to TRUE again.
6394	* The right fix would be to change GUI API wrappers to make sure that parameters
6395	* are changed only if API succeeds.
6396	*/
6397	*aEnabled = TRUE;
6398	#endif
6399	return setError(VBOX_E_IPRT_ERROR,
6400	tr("Saved guest size is not available (%Rrc)"),
6401	vrc);
6402	}
6403
6404	*aOriginX = u32OriginX;
6405	*aOriginY = u32OriginY;
6406	*aWidth = u32Width;
6407	*aHeight = u32Height;
6408	*aEnabled = (u16Flags & VBVA_SCREEN_F_DISABLED) == 0;
6409
6410	return S_OK;
6411	}
6412
6413	HRESULT Machine::readSavedThumbnailToArray(ULONG aScreenId, BitmapFormat_T aBitmapFormat,
6414	ULONG aWidth, ULONG aHeight, std::vector<BYTE> &aData)
6415	{
6416	if (aScreenId != 0)
6417	return E_NOTIMPL;
6418
6419	if ( aBitmapFormat != BitmapFormat_BGR0
6420	&& aBitmapFormat != BitmapFormat_BGRA
6421	&& aBitmapFormat != BitmapFormat_RGBA
6422	&& aBitmapFormat != BitmapFormat_PNG)
6423	return setError(E_NOTIMPL,
6424	tr("Unsupported saved thumbnail format 0x%08X"), aBitmapFormat);
6425
6426	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6427
6428	uint8_t *pu8Data = NULL;
6429	uint32_t cbData = 0;
6430	uint32_t u32Width = 0;
6431	uint32_t u32Height = 0;
6432
6433	int vrc = readSavedDisplayScreenshot(mSSData->strStateFilePath, 0 /* u32Type */, &pu8Data, &cbData, &u32Width, &u32Height);
6434
6435	if (RT_FAILURE(vrc))
6436	return setError(VBOX_E_IPRT_ERROR,
6437	tr("Saved thumbnail data is not available (%Rrc)"),
6438	vrc);
6439
6440	HRESULT hr = S_OK;
6441
6442	*aWidth = u32Width;
6443	*aHeight = u32Height;
6444
6445	if (cbData > 0)
6446	{
6447	/* Convert pixels to the format expected by the API caller. */
6448	if (aBitmapFormat == BitmapFormat_BGR0)
6449	{
6450	/* [0] B, [1] G, [2] R, [3] 0. */
6451	aData.resize(cbData);
6452	memcpy(&aData.front(), pu8Data, cbData);
6453	}
6454	else if (aBitmapFormat == BitmapFormat_BGRA)
6455	{
6456	/* [0] B, [1] G, [2] R, [3] A. */
6457	aData.resize(cbData);
6458	for (uint32_t i = 0; i < cbData; i += 4)
6459	{
6460	aData[i] = pu8Data[i];
6461	aData[i + 1] = pu8Data[i + 1];
6462	aData[i + 2] = pu8Data[i + 2];
6463	aData[i + 3] = 0xff;
6464	}
6465	}
6466	else if (aBitmapFormat == BitmapFormat_RGBA)
6467	{
6468	/* [0] R, [1] G, [2] B, [3] A. */
6469	aData.resize(cbData);
6470	for (uint32_t i = 0; i < cbData; i += 4)
6471	{
6472	aData[i] = pu8Data[i + 2];
6473	aData[i + 1] = pu8Data[i + 1];
6474	aData[i + 2] = pu8Data[i];
6475	aData[i + 3] = 0xff;
6476	}
6477	}
6478	else if (aBitmapFormat == BitmapFormat_PNG)
6479	{
6480	uint8_t *pu8PNG = NULL;
6481	uint32_t cbPNG = 0;
6482	uint32_t cxPNG = 0;
6483	uint32_t cyPNG = 0;
6484
6485	vrc = DisplayMakePNG(pu8Data, u32Width, u32Height, &pu8PNG, &cbPNG, &cxPNG, &cyPNG, 0);
6486
6487	if (RT_SUCCESS(vrc))
6488	{
6489	aData.resize(cbPNG);
6490	if (cbPNG)
6491	memcpy(&aData.front(), pu8PNG, cbPNG);
6492	}
6493	else
6494	hr = setError(VBOX_E_IPRT_ERROR,
6495	tr("Could not convert saved thumbnail to PNG (%Rrc)"),
6496	vrc);
6497
6498	RTMemFree(pu8PNG);
6499	}
6500	}
6501
6502	freeSavedDisplayScreenshot(pu8Data);
6503
6504	return hr;
6505	}
6506
6507	HRESULT Machine::querySavedScreenshotInfo(ULONG aScreenId,
6508	ULONG *aWidth,
6509	ULONG *aHeight,
6510	std::vector<BitmapFormat_T> &aBitmapFormats)
6511	{
6512	if (aScreenId != 0)
6513	return E_NOTIMPL;
6514
6515	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6516
6517	uint8_t *pu8Data = NULL;
6518	uint32_t cbData = 0;
6519	uint32_t u32Width = 0;
6520	uint32_t u32Height = 0;
6521
6522	int vrc = readSavedDisplayScreenshot(mSSData->strStateFilePath, 1 /* u32Type */, &pu8Data, &cbData, &u32Width, &u32Height);
6523
6524	if (RT_FAILURE(vrc))
6525	return setError(VBOX_E_IPRT_ERROR,
6526	tr("Saved screenshot data is not available (%Rrc)"),
6527	vrc);
6528
6529	*aWidth = u32Width;
6530	*aHeight = u32Height;
6531	aBitmapFormats.resize(1);
6532	aBitmapFormats[0] = BitmapFormat_PNG;
6533
6534	freeSavedDisplayScreenshot(pu8Data);
6535
6536	return S_OK;
6537	}
6538
6539	HRESULT Machine::readSavedScreenshotToArray(ULONG aScreenId,
6540	BitmapFormat_T aBitmapFormat,
6541	ULONG *aWidth,
6542	ULONG *aHeight,
6543	std::vector<BYTE> &aData)
6544	{
6545	if (aScreenId != 0)
6546	return E_NOTIMPL;
6547
6548	if (aBitmapFormat != BitmapFormat_PNG)
6549	return E_NOTIMPL;
6550
6551	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6552
6553	uint8_t *pu8Data = NULL;
6554	uint32_t cbData = 0;
6555	uint32_t u32Width = 0;
6556	uint32_t u32Height = 0;
6557
6558	int vrc = readSavedDisplayScreenshot(mSSData->strStateFilePath, 1 /* u32Type */, &pu8Data, &cbData, &u32Width, &u32Height);
6559
6560	if (RT_FAILURE(vrc))
6561	return setError(VBOX_E_IPRT_ERROR,
6562	tr("Saved screenshot thumbnail data is not available (%Rrc)"),
6563	vrc);
6564
6565	*aWidth = u32Width;
6566	*aHeight = u32Height;
6567
6568	aData.resize(cbData);
6569	if (cbData)
6570	memcpy(&aData.front(), pu8Data, cbData);
6571
6572	freeSavedDisplayScreenshot(pu8Data);
6573
6574	return S_OK;
6575	}
6576
6577	HRESULT Machine::hotPlugCPU(ULONG aCpu)
6578	{
6579	HRESULT rc = S_OK;
6580	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6581
6582	if (!mHWData->mCPUHotPlugEnabled)
6583	return setError(E_INVALIDARG, tr("CPU hotplug is not enabled"));
6584
6585	if (aCpu >= mHWData->mCPUCount)
6586	return setError(E_INVALIDARG, tr("CPU id exceeds number of possible CPUs [0:%lu]"), mHWData->mCPUCount-1);
6587
6588	if (mHWData->mCPUAttached[aCpu])
6589	return setError(VBOX_E_OBJECT_IN_USE, tr("CPU %lu is already attached"), aCpu);
6590
6591	alock.release();
6592	rc = i_onCPUChange(aCpu, false);
6593	alock.acquire();
6594	if (FAILED(rc)) return rc;
6595
6596	i_setModified(IsModified_MachineData);
6597	mHWData.backup();
6598	mHWData->mCPUAttached[aCpu] = true;
6599
6600	/** Save settings if online - @todo why is this required? -- @bugref{6818} */
6601	if (Global::IsOnline(mData->mMachineState))
6602	i_saveSettings(NULL);
6603
6604	return S_OK;
6605	}
6606
6607	HRESULT Machine::hotUnplugCPU(ULONG aCpu)
6608	{
6609	HRESULT rc = S_OK;
6610
6611	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6612
6613	if (!mHWData->mCPUHotPlugEnabled)
6614	return setError(E_INVALIDARG, tr("CPU hotplug is not enabled"));
6615
6616	if (aCpu >= SchemaDefs::MaxCPUCount)
6617	return setError(E_INVALIDARG,
6618	tr("CPU index exceeds maximum CPU count (must be in range [0:%lu])"),
6619	SchemaDefs::MaxCPUCount);
6620
6621	if (!mHWData->mCPUAttached[aCpu])
6622	return setError(VBOX_E_OBJECT_NOT_FOUND, tr("CPU %lu is not attached"), aCpu);
6623
6624	/* CPU 0 can't be detached */
6625	if (aCpu == 0)
6626	return setError(E_INVALIDARG, tr("It is not possible to detach CPU 0"));
6627
6628	alock.release();
6629	rc = i_onCPUChange(aCpu, true);
6630	alock.acquire();
6631	if (FAILED(rc)) return rc;
6632
6633	i_setModified(IsModified_MachineData);
6634	mHWData.backup();
6635	mHWData->mCPUAttached[aCpu] = false;
6636
6637	/** Save settings if online - @todo why is this required? -- @bugref{6818} */
6638	if (Global::IsOnline(mData->mMachineState))
6639	i_saveSettings(NULL);
6640
6641	return S_OK;
6642	}
6643
6644	HRESULT Machine::getCPUStatus(ULONG aCpu, BOOL *aAttached)
6645	{
6646	*aAttached = false;
6647
6648	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6649
6650	/* If hotplug is enabled the CPU is always enabled. */
6651	if (!mHWData->mCPUHotPlugEnabled)
6652	{
6653	if (aCpu < mHWData->mCPUCount)
6654	*aAttached = true;
6655	}
6656	else
6657	{
6658	if (aCpu < SchemaDefs::MaxCPUCount)
6659	*aAttached = mHWData->mCPUAttached[aCpu];
6660	}
6661
6662	return S_OK;
6663	}
6664
6665	HRESULT Machine::queryLogFilename(ULONG aIdx, com::Utf8Str &aFilename)
6666	{
6667	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6668
6669	Utf8Str log = i_getLogFilename(aIdx);
6670	if (!RTFileExists(log.c_str()))
6671	log.setNull();
6672	aFilename = log;
6673
6674	return S_OK;
6675	}
6676
6677	HRESULT Machine::readLog(ULONG aIdx, LONG64 aOffset, LONG64 aSize, std::vector<BYTE> &aData)
6678	{
6679	if (aSize < 0)
6680	return setError(E_INVALIDARG, tr("The size argument (%lld) is negative"), aSize);
6681
6682	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6683
6684	HRESULT rc = S_OK;
6685	Utf8Str log = i_getLogFilename(aIdx);
6686
6687	/* do not unnecessarily hold the lock while doing something which does
6688	* not need the lock and potentially takes a long time. */
6689	alock.release();
6690
6691	/* Limit the chunk size to 512K. Gives good performance over (XP)COM, and
6692	* keeps the SOAP reply size under 1M for the webservice (we're using
6693	* base64 encoded strings for binary data for years now, avoiding the
6694	* expansion of each byte array element to approx. 25 bytes of XML. */
6695	size_t cbData = (size_t)RT_MIN(aSize, _512K);
6696	aData.resize(cbData);
6697
6698	RTFILE LogFile;
6699	int vrc = RTFileOpen(&LogFile, log.c_str(),
6700	RTFILE_O_OPEN \| RTFILE_O_READ \| RTFILE_O_DENY_NONE);
6701	if (RT_SUCCESS(vrc))
6702	{
6703	vrc = RTFileReadAt(LogFile, aOffset, cbData? &aData.front(): NULL, cbData, &cbData);
6704	if (RT_SUCCESS(vrc))
6705	aData.resize(cbData);
6706	else
6707	rc = setError(VBOX_E_IPRT_ERROR,
6708	tr("Could not read log file '%s' (%Rrc)"),
6709	log.c_str(), vrc);
6710	RTFileClose(LogFile);
6711	}
6712	else
6713	rc = setError(VBOX_E_IPRT_ERROR,
6714	tr("Could not open log file '%s' (%Rrc)"),
6715	log.c_str(), vrc);
6716
6717	if (FAILED(rc))
6718	aData.resize(0);
6719
6720	return rc;
6721	}
6722
6723
6724	/**
6725	* Currently this method doesn't attach device to the running VM,
6726	* just makes sure it's plugged on next VM start.
6727	*/
6728	HRESULT Machine::attachHostPCIDevice(LONG aHostAddress, LONG aDesiredGuestAddress, BOOL /* aTryToUnbind */)
6729	{
6730	// lock scope
6731	{
6732	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6733
6734	HRESULT rc = i_checkStateDependency(MutableStateDep);
6735	if (FAILED(rc)) return rc;
6736
6737	ChipsetType_T aChipset = ChipsetType_PIIX3;
6738	COMGETTER(ChipsetType)(&aChipset);
6739
6740	if (aChipset != ChipsetType_ICH9)
6741	{
6742	return setError(E_INVALIDARG,
6743	tr("Host PCI attachment only supported with ICH9 chipset"));
6744	}
6745
6746	// check if device with this host PCI address already attached
6747	for (HWData::PCIDeviceAssignmentList::const_iterator
6748	it = mHWData->mPCIDeviceAssignments.begin();
6749	it != mHWData->mPCIDeviceAssignments.end();
6750	++it)
6751	{
6752	LONG iHostAddress = -1;
6753	ComPtr<PCIDeviceAttachment> pAttach;
6754	pAttach = *it;
6755	pAttach->COMGETTER(HostAddress)(&iHostAddress);
6756	if (iHostAddress == aHostAddress)
6757	return setError(E_INVALIDARG,
6758	tr("Device with host PCI address already attached to this VM"));
6759	}
6760
6761	ComObjPtr<PCIDeviceAttachment> pda;
6762	char name[32];
6763
6764	RTStrPrintf(name, sizeof(name), "host%02x:%02x.%x", (aHostAddress>>8) & 0xff,
6765	(aHostAddress & 0xf8) >> 3, aHostAddress & 7);
6766	pda.createObject();
6767	pda->init(this, name, aHostAddress, aDesiredGuestAddress, TRUE);
6768	i_setModified(IsModified_MachineData);
6769	mHWData.backup();
6770	mHWData->mPCIDeviceAssignments.push_back(pda);
6771	}
6772
6773	return S_OK;
6774	}
6775
6776	/**
6777	* Currently this method doesn't detach device from the running VM,
6778	* just makes sure it's not plugged on next VM start.
6779	*/
6780	HRESULT Machine::detachHostPCIDevice(LONG aHostAddress)
6781	{
6782	ComObjPtr<PCIDeviceAttachment> pAttach;
6783	bool fRemoved = false;
6784	HRESULT rc;
6785
6786	// lock scope
6787	{
6788	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6789
6790	rc = i_checkStateDependency(MutableStateDep);
6791	if (FAILED(rc)) return rc;
6792
6793	for (HWData::PCIDeviceAssignmentList::const_iterator
6794	it = mHWData->mPCIDeviceAssignments.begin();
6795	it != mHWData->mPCIDeviceAssignments.end();
6796	++it)
6797	{
6798	LONG iHostAddress = -1;
6799	pAttach = *it;
6800	pAttach->COMGETTER(HostAddress)(&iHostAddress);
6801	if (iHostAddress != -1 && iHostAddress == aHostAddress)
6802	{
6803	i_setModified(IsModified_MachineData);
6804	mHWData.backup();
6805	mHWData->mPCIDeviceAssignments.remove(pAttach);
6806	fRemoved = true;
6807	break;
6808	}
6809	}
6810	}
6811
6812
6813	/* Fire event outside of the lock */
6814	if (fRemoved)
6815	{
6816	Assert(!pAttach.isNull());
6817	ComPtr<IEventSource> es;
6818	rc = mParent->COMGETTER(EventSource)(es.asOutParam());
6819	Assert(SUCCEEDED(rc));
6820	Bstr mid;
6821	rc = this->COMGETTER(Id)(mid.asOutParam());
6822	Assert(SUCCEEDED(rc));
6823	fireHostPCIDevicePlugEvent(es, mid.raw(), false /* unplugged /, true / success */, pAttach, NULL);
6824	}
6825
6826	return fRemoved ? S_OK : setError(VBOX_E_OBJECT_NOT_FOUND,
6827	tr("No host PCI device %08x attached"),
6828	aHostAddress
6829	);
6830	}
6831
6832	HRESULT Machine::getPCIDeviceAssignments(std::vector<ComPtr<IPCIDeviceAttachment> > &aPCIDeviceAssignments)
6833	{
6834	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6835
6836	aPCIDeviceAssignments.resize(mHWData->mPCIDeviceAssignments.size());
6837	size_t i = 0;
6838	for (std::list<ComObjPtr<PCIDeviceAttachment> >::const_iterator
6839	it = mHWData->mPCIDeviceAssignments.begin();
6840	it != mHWData->mPCIDeviceAssignments.end();
6841	++it, ++i)
6842	(*it).queryInterfaceTo(aPCIDeviceAssignments[i].asOutParam());
6843
6844	return S_OK;
6845	}
6846
6847	HRESULT Machine::getBandwidthControl(ComPtr<IBandwidthControl> &aBandwidthControl)
6848	{
6849	mBandwidthControl.queryInterfaceTo(aBandwidthControl.asOutParam());
6850
6851	return S_OK;
6852	}
6853
6854	HRESULT Machine::getTracingEnabled(BOOL *aTracingEnabled)
6855	{
6856	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6857
6858	*aTracingEnabled = mHWData->mDebugging.fTracingEnabled;
6859
6860	return S_OK;
6861	}
6862
6863	HRESULT Machine::setTracingEnabled(BOOL aTracingEnabled)
6864	{
6865	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6866	HRESULT hrc = i_checkStateDependency(MutableStateDep);
6867	if (SUCCEEDED(hrc))
6868	{
6869	hrc = mHWData.backupEx();
6870	if (SUCCEEDED(hrc))
6871	{
6872	i_setModified(IsModified_MachineData);
6873	mHWData->mDebugging.fTracingEnabled = aTracingEnabled != FALSE;
6874	}
6875	}
6876	return hrc;
6877	}
6878
6879	HRESULT Machine::getTracingConfig(com::Utf8Str &aTracingConfig)
6880	{
6881	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6882	aTracingConfig = mHWData->mDebugging.strTracingConfig;
6883	return S_OK;
6884	}
6885
6886	HRESULT Machine::setTracingConfig(const com::Utf8Str &aTracingConfig)
6887	{
6888	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6889	HRESULT hrc = i_checkStateDependency(MutableStateDep);
6890	if (SUCCEEDED(hrc))
6891	{
6892	hrc = mHWData.backupEx();
6893	if (SUCCEEDED(hrc))
6894	{
6895	mHWData->mDebugging.strTracingConfig = aTracingConfig;
6896	if (SUCCEEDED(hrc))
6897	i_setModified(IsModified_MachineData);
6898	}
6899	}
6900	return hrc;
6901	}
6902
6903	HRESULT Machine::getAllowTracingToAccessVM(BOOL *aAllowTracingToAccessVM)
6904	{
6905	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6906
6907	*aAllowTracingToAccessVM = mHWData->mDebugging.fAllowTracingToAccessVM;
6908
6909	return S_OK;
6910	}
6911
6912	HRESULT Machine::setAllowTracingToAccessVM(BOOL aAllowTracingToAccessVM)
6913	{
6914	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6915	HRESULT hrc = i_checkStateDependency(MutableStateDep);
6916	if (SUCCEEDED(hrc))
6917	{
6918	hrc = mHWData.backupEx();
6919	if (SUCCEEDED(hrc))
6920	{
6921	i_setModified(IsModified_MachineData);
6922	mHWData->mDebugging.fAllowTracingToAccessVM = aAllowTracingToAccessVM != FALSE;
6923	}
6924	}
6925	return hrc;
6926	}
6927
6928	HRESULT Machine::getAutostartEnabled(BOOL *aAutostartEnabled)
6929	{
6930	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6931
6932	*aAutostartEnabled = mHWData->mAutostart.fAutostartEnabled;
6933
6934	return S_OK;
6935	}
6936
6937	HRESULT Machine::setAutostartEnabled(BOOL aAutostartEnabled)
6938	{
6939	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6940
6941	HRESULT hrc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
6942	if ( SUCCEEDED(hrc)
6943	&& mHWData->mAutostart.fAutostartEnabled != !!aAutostartEnabled)
6944	{
6945	AutostartDb *autostartDb = mParent->i_getAutostartDb();
6946	int vrc;
6947
6948	if (aAutostartEnabled)
6949	vrc = autostartDb->addAutostartVM(mUserData->s.strName.c_str());
6950	else
6951	vrc = autostartDb->removeAutostartVM(mUserData->s.strName.c_str());
6952
6953	if (RT_SUCCESS(vrc))
6954	{
6955	hrc = mHWData.backupEx();
6956	if (SUCCEEDED(hrc))
6957	{
6958	i_setModified(IsModified_MachineData);
6959	mHWData->mAutostart.fAutostartEnabled = aAutostartEnabled != FALSE;
6960	}
6961	}
6962	else if (vrc == VERR_NOT_SUPPORTED)
6963	hrc = setError(VBOX_E_NOT_SUPPORTED,
6964	tr("The VM autostart feature is not supported on this platform"));
6965	else if (vrc == VERR_PATH_NOT_FOUND)
6966	hrc = setError(E_FAIL,
6967	tr("The path to the autostart database is not set"));
6968	else
6969	hrc = setError(E_UNEXPECTED,
6970	tr("%s machine '%s' to the autostart database failed with %Rrc"),
6971	aAutostartEnabled ? "Adding" : "Removing",
6972	mUserData->s.strName.c_str(), vrc);
6973	}
6974	return hrc;
6975	}
6976
6977	HRESULT Machine::getAutostartDelay(ULONG *aAutostartDelay)
6978	{
6979	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6980
6981	*aAutostartDelay = mHWData->mAutostart.uAutostartDelay;
6982
6983	return S_OK;
6984	}
6985
6986	HRESULT Machine::setAutostartDelay(ULONG aAutostartDelay)
6987	{
6988	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6989	HRESULT hrc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
6990	if (SUCCEEDED(hrc))
6991	{
6992	hrc = mHWData.backupEx();
6993	if (SUCCEEDED(hrc))
6994	{
6995	i_setModified(IsModified_MachineData);
6996	mHWData->mAutostart.uAutostartDelay = aAutostartDelay;
6997	}
6998	}
6999	return hrc;
7000	}
7001
7002	HRESULT Machine::getAutostopType(AutostopType_T *aAutostopType)
7003	{
7004	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7005
7006	*aAutostopType = mHWData->mAutostart.enmAutostopType;
7007
7008	return S_OK;
7009	}
7010
7011	HRESULT Machine::setAutostopType(AutostopType_T aAutostopType)
7012	{
7013	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7014	HRESULT hrc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
7015	if ( SUCCEEDED(hrc)
7016	&& mHWData->mAutostart.enmAutostopType != aAutostopType)
7017	{
7018	AutostartDb *autostartDb = mParent->i_getAutostartDb();
7019	int vrc;
7020
7021	if (aAutostopType != AutostopType_Disabled)
7022	vrc = autostartDb->addAutostopVM(mUserData->s.strName.c_str());
7023	else
7024	vrc = autostartDb->removeAutostopVM(mUserData->s.strName.c_str());
7025
7026	if (RT_SUCCESS(vrc))
7027	{
7028	hrc = mHWData.backupEx();
7029	if (SUCCEEDED(hrc))
7030	{
7031	i_setModified(IsModified_MachineData);
7032	mHWData->mAutostart.enmAutostopType = aAutostopType;
7033	}
7034	}
7035	else if (vrc == VERR_NOT_SUPPORTED)
7036	hrc = setError(VBOX_E_NOT_SUPPORTED,
7037	tr("The VM autostop feature is not supported on this platform"));
7038	else if (vrc == VERR_PATH_NOT_FOUND)
7039	hrc = setError(E_FAIL,
7040	tr("The path to the autostart database is not set"));
7041	else
7042	hrc = setError(E_UNEXPECTED,
7043	tr("%s machine '%s' to the autostop database failed with %Rrc"),
7044	aAutostopType != AutostopType_Disabled ? "Adding" : "Removing",
7045	mUserData->s.strName.c_str(), vrc);
7046	}
7047	return hrc;
7048	}
7049
7050	HRESULT Machine::getDefaultFrontend(com::Utf8Str &aDefaultFrontend)
7051	{
7052	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7053
7054	aDefaultFrontend = mHWData->mDefaultFrontend;
7055
7056	return S_OK;
7057	}
7058
7059	HRESULT Machine::setDefaultFrontend(const com::Utf8Str &aDefaultFrontend)
7060	{
7061	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7062	HRESULT hrc = i_checkStateDependency(MutableOrSavedStateDep);
7063	if (SUCCEEDED(hrc))
7064	{
7065	hrc = mHWData.backupEx();
7066	if (SUCCEEDED(hrc))
7067	{
7068	i_setModified(IsModified_MachineData);
7069	mHWData->mDefaultFrontend = aDefaultFrontend;
7070	}
7071	}
7072	return hrc;
7073	}
7074
7075	HRESULT Machine::getIcon(std::vector<BYTE> &aIcon)
7076	{
7077	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7078	size_t cbIcon = mUserData->s.ovIcon.size();
7079	aIcon.resize(cbIcon);
7080	if (cbIcon)
7081	memcpy(&aIcon.front(), &mUserData->s.ovIcon[0], cbIcon);
7082	return S_OK;
7083	}
7084
7085	HRESULT Machine::setIcon(const std::vector<BYTE> &aIcon)
7086	{
7087	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7088	HRESULT hrc = i_checkStateDependency(MutableOrSavedStateDep);
7089	if (SUCCEEDED(hrc))
7090	{
7091	i_setModified(IsModified_MachineData);
7092	mUserData.backup();
7093	size_t cbIcon = aIcon.size();
7094	mUserData->s.ovIcon.resize(cbIcon);
7095	if (cbIcon)
7096	memcpy(&mUserData->s.ovIcon[0], &aIcon.front(), cbIcon);
7097	}
7098	return hrc;
7099	}
7100
7101	HRESULT Machine::getUSBProxyAvailable(BOOL *aUSBProxyAvailable)
7102	{
7103	#ifdef VBOX_WITH_USB
7104	*aUSBProxyAvailable = true;
7105	#else
7106	*aUSBProxyAvailable = false;
7107	#endif
7108	return S_OK;
7109	}
7110
7111	HRESULT Machine::getVMProcessPriority(com::Utf8Str &aVMProcessPriority)
7112	{
7113	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7114
7115	aVMProcessPriority = mUserData->s.strVMPriority;
7116
7117	return S_OK;
7118	}
7119
7120	HRESULT Machine::setVMProcessPriority(const com::Utf8Str &aVMProcessPriority)
7121	{
7122	RT_NOREF(aVMProcessPriority);
7123	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7124	HRESULT hrc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
7125	if (SUCCEEDED(hrc))
7126	{
7127	/** @todo r=klaus: currently this is marked as not implemented, as
7128	* the code for setting the priority of the process is not there
7129	* (neither when starting the VM nor at runtime). */
7130	ReturnComNotImplemented();
7131	#if 0
7132	hrc = mUserData.backupEx();
7133	if (SUCCEEDED(hrc))
7134	{
7135	i_setModified(IsModified_MachineData);
7136	mUserData->s.strVMPriority = aVMProcessPriority;
7137	}
7138	#endif
7139	}
7140	return hrc;
7141	}
7142
7143	HRESULT Machine::cloneTo(const ComPtr<IMachine> &aTarget, CloneMode_T aMode, const std::vector<CloneOptions_T> &aOptions,
7144	ComPtr<IProgress> &aProgress)
7145	{
7146	ComObjPtr<Progress> pP;
7147	Progress *ppP = pP;
7148	IProgress iP = static_cast<IProgress >(ppP);
7149	IProgress **pProgress = &iP;
7150
7151	IMachine *pTarget = aTarget;
7152
7153	/* Convert the options. */
7154	RTCList<CloneOptions_T> optList;
7155	if (aOptions.size())
7156	for (size_t i = 0; i < aOptions.size(); ++i)
7157	optList.append(aOptions[i]);
7158
7159	if (optList.contains(CloneOptions_Link))
7160	{
7161	if (!i_isSnapshotMachine())
7162	return setError(E_INVALIDARG,
7163	tr("Linked clone can only be created from a snapshot"));
7164	if (aMode != CloneMode_MachineState)
7165	return setError(E_INVALIDARG,
7166	tr("Linked clone can only be created for a single machine state"));
7167	}
7168	AssertReturn(!(optList.contains(CloneOptions_KeepAllMACs) && optList.contains(CloneOptions_KeepNATMACs)), E_INVALIDARG);
7169
7170	MachineCloneVM pWorker = new MachineCloneVM(this, static_cast<Machine>(pTarget), aMode, optList);
7171
7172	HRESULT rc = pWorker->start(pProgress);
7173
7174	pP = static_cast<Progress >(pProgress);
7175	pP.queryInterfaceTo(aProgress.asOutParam());
7176
7177	return rc;
7178
7179	}
7180
7181	HRESULT Machine::saveState(ComPtr<IProgress> &aProgress)
7182	{
7183	NOREF(aProgress);
7184	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7185
7186	// This check should always fail.
7187	HRESULT rc = i_checkStateDependency(MutableStateDep);
7188	if (FAILED(rc)) return rc;
7189
7190	AssertFailedReturn(E_NOTIMPL);
7191	}
7192
7193	HRESULT Machine::adoptSavedState(const com::Utf8Str &aSavedStateFile)
7194	{
7195	NOREF(aSavedStateFile);
7196	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7197
7198	// This check should always fail.
7199	HRESULT rc = i_checkStateDependency(MutableStateDep);
7200	if (FAILED(rc)) return rc;
7201
7202	AssertFailedReturn(E_NOTIMPL);
7203	}
7204
7205	HRESULT Machine::discardSavedState(BOOL aFRemoveFile)
7206	{
7207	NOREF(aFRemoveFile);
7208	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7209
7210	// This check should always fail.
7211	HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
7212	if (FAILED(rc)) return rc;
7213
7214	AssertFailedReturn(E_NOTIMPL);
7215	}
7216
7217	// public methods for internal purposes
7218	/////////////////////////////////////////////////////////////////////////////
7219
7220	/**
7221	* Adds the given IsModified_* flag to the dirty flags of the machine.
7222	* This must be called either during i_loadSettings or under the machine write lock.
7223	* @param fl Flag
7224	* @param fAllowStateModification If state modifications are allowed.
7225	*/
7226	void Machine::i_setModified(uint32_t fl, bool fAllowStateModification /* = true */)
7227	{
7228	mData->flModifications \|= fl;
7229	if (fAllowStateModification && i_isStateModificationAllowed())
7230	mData->mCurrentStateModified = true;
7231	}
7232
7233	/**
7234	* Adds the given IsModified_* flag to the dirty flags of the machine, taking
7235	* care of the write locking.
7236	*
7237	* @param fModification The flag to add.
7238	* @param fAllowStateModification If state modifications are allowed.
7239	*/
7240	void Machine::i_setModifiedLock(uint32_t fModification, bool fAllowStateModification /* = true */)
7241	{
7242	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7243	i_setModified(fModification, fAllowStateModification);
7244	}
7245
7246	/**
7247	* Saves the registry entry of this machine to the given configuration node.
7248	*
7249	* @param data Machine registry data.
7250	*
7251	* @note locks this object for reading.
7252	*/
7253	HRESULT Machine::i_saveRegistryEntry(settings::MachineRegistryEntry &data)
7254	{
7255	AutoLimitedCaller autoCaller(this);
7256	AssertComRCReturnRC(autoCaller.rc());
7257
7258	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7259
7260	data.uuid = mData->mUuid;
7261	data.strSettingsFile = mData->m_strConfigFile;
7262
7263	return S_OK;
7264	}
7265
7266	/**
7267	* Calculates the absolute path of the given path taking the directory of the
7268	* machine settings file as the current directory.
7269	*
7270	* @param strPath Path to calculate the absolute path for.
7271	* @param aResult Where to put the result (used only on success, can be the
7272	* same Utf8Str instance as passed in @a aPath).
7273	* @return IPRT result.
7274	*
7275	* @note Locks this object for reading.
7276	*/
7277	int Machine::i_calculateFullPath(const Utf8Str &strPath, Utf8Str &aResult)
7278	{
7279	AutoCaller autoCaller(this);
7280	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
7281
7282	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7283
7284	AssertReturn(!mData->m_strConfigFileFull.isEmpty(), VERR_GENERAL_FAILURE);
7285
7286	Utf8Str strSettingsDir = mData->m_strConfigFileFull;
7287
7288	strSettingsDir.stripFilename();
7289	char folder[RTPATH_MAX];
7290	int vrc = RTPathAbsEx(strSettingsDir.c_str(), strPath.c_str(), folder, sizeof(folder));
7291	if (RT_SUCCESS(vrc))
7292	aResult = folder;
7293
7294	return vrc;
7295	}
7296
7297	/**
7298	* Copies strSource to strTarget, making it relative to the machine folder
7299	* if it is a subdirectory thereof, or simply copying it otherwise.
7300	*
7301	* @param strSource Path to evaluate and copy.
7302	* @param strTarget Buffer to receive target path.
7303	*
7304	* @note Locks this object for reading.
7305	*/
7306	void Machine::i_copyPathRelativeToMachine(const Utf8Str &strSource,
7307	Utf8Str &strTarget)
7308	{
7309	AutoCaller autoCaller(this);
7310	AssertComRCReturn(autoCaller.rc(), (void)0);
7311
7312	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7313
7314	AssertReturnVoid(!mData->m_strConfigFileFull.isEmpty());
7315	// use strTarget as a temporary buffer to hold the machine settings dir
7316	strTarget = mData->m_strConfigFileFull;
7317	strTarget.stripFilename();
7318	if (RTPathStartsWith(strSource.c_str(), strTarget.c_str()))
7319	{
7320	// is relative: then append what's left
7321	strTarget = strSource.substr(strTarget.length() + 1); // skip '/'
7322	// for empty paths (only possible for subdirs) use "." to avoid
7323	// triggering default settings for not present config attributes.
7324	if (strTarget.isEmpty())
7325	strTarget = ".";
7326	}
7327	else
7328	// is not relative: then overwrite
7329	strTarget = strSource;
7330	}
7331
7332	/**
7333	* Returns the full path to the machine's log folder in the
7334	* \a aLogFolder argument.
7335	*/
7336	void Machine::i_getLogFolder(Utf8Str &aLogFolder)
7337	{
7338	AutoCaller autoCaller(this);
7339	AssertComRCReturnVoid(autoCaller.rc());
7340
7341	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7342
7343	char szTmp[RTPATH_MAX];
7344	int vrc = RTEnvGetEx(RTENV_DEFAULT, "VBOX_USER_VMLOGDIR", szTmp, sizeof(szTmp), NULL);
7345	if (RT_SUCCESS(vrc))
7346	{
7347	if (szTmp[0] && !mUserData.isNull())
7348	{
7349	char szTmp2[RTPATH_MAX];
7350	vrc = RTPathAbs(szTmp, szTmp2, sizeof(szTmp2));
7351	if (RT_SUCCESS(vrc))
7352	aLogFolder = Utf8StrFmt("%s%c%s",
7353	szTmp2,
7354	RTPATH_DELIMITER,
7355	mUserData->s.strName.c_str()); // path/to/logfolder/vmname
7356	}
7357	else
7358	vrc = VERR_PATH_IS_RELATIVE;
7359	}
7360
7361	if (RT_FAILURE(vrc))
7362	{
7363	// fallback if VBOX_USER_LOGHOME is not set or invalid
7364	aLogFolder = mData->m_strConfigFileFull; // path/to/machinesfolder/vmname/vmname.vbox
7365	aLogFolder.stripFilename(); // path/to/machinesfolder/vmname
7366	aLogFolder.append(RTPATH_DELIMITER);
7367	aLogFolder.append("Logs"); // path/to/machinesfolder/vmname/Logs
7368	}
7369	}
7370
7371	/**
7372	* Returns the full path to the machine's log file for an given index.
7373	*/
7374	Utf8Str Machine::i_getLogFilename(ULONG idx)
7375	{
7376	Utf8Str logFolder;
7377	getLogFolder(logFolder);
7378	Assert(logFolder.length());
7379
7380	Utf8Str log;
7381	if (idx == 0)
7382	log = Utf8StrFmt("%s%cVBox.log", logFolder.c_str(), RTPATH_DELIMITER);
7383	#if defined(RT_OS_WINDOWS) && defined(VBOX_WITH_HARDENING)
7384	else if (idx == 1)
7385	log = Utf8StrFmt("%s%cVBoxHardening.log", logFolder.c_str(), RTPATH_DELIMITER);
7386	else
7387	log = Utf8StrFmt("%s%cVBox.log.%u", logFolder.c_str(), RTPATH_DELIMITER, idx - 1);
7388	#else
7389	else
7390	log = Utf8StrFmt("%s%cVBox.log.%u", logFolder.c_str(), RTPATH_DELIMITER, idx);
7391	#endif
7392	return log;
7393	}
7394
7395	/**
7396	* Returns the full path to the machine's hardened log file.
7397	*/
7398	Utf8Str Machine::i_getHardeningLogFilename(void)
7399	{
7400	Utf8Str strFilename;
7401	getLogFolder(strFilename);
7402	Assert(strFilename.length());
7403	strFilename.append(RTPATH_SLASH_STR "VBoxHardening.log");
7404	return strFilename;
7405	}
7406
7407
7408	/**
7409	* Composes a unique saved state filename based on the current system time. The filename is
7410	* granular to the second so this will work so long as no more than one snapshot is taken on
7411	* a machine per second.
7412	*
7413	* Before version 4.1, we used this formula for saved state files:
7414	* Utf8StrFmt("%s%c{%RTuuid}.sav", strFullSnapshotFolder.c_str(), RTPATH_DELIMITER, mData->mUuid.raw())
7415	* which no longer works because saved state files can now be shared between the saved state of the
7416	* "saved" machine and an online snapshot, and the following would cause problems:
7417	* 1) save machine
7418	* 2) create online snapshot from that machine state --> reusing saved state file
7419	* 3) save machine again --> filename would be reused, breaking the online snapshot
7420	*
7421	* So instead we now use a timestamp.
7422	*
7423	* @param strStateFilePath
7424	*/
7425
7426	void Machine::i_composeSavedStateFilename(Utf8Str &strStateFilePath)
7427	{
7428	AutoCaller autoCaller(this);
7429	AssertComRCReturnVoid(autoCaller.rc());
7430
7431	{
7432	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7433	i_calculateFullPath(mUserData->s.strSnapshotFolder, strStateFilePath);
7434	}
7435
7436	RTTIMESPEC ts;
7437	RTTimeNow(&ts);
7438	RTTIME time;
7439	RTTimeExplode(&time, &ts);
7440
7441	strStateFilePath += RTPATH_DELIMITER;
7442	strStateFilePath += Utf8StrFmt("%04d-%02u-%02uT%02u-%02u-%02u-%09uZ.sav",
7443	time.i32Year, time.u8Month, time.u8MonthDay,
7444	time.u8Hour, time.u8Minute, time.u8Second, time.u32Nanosecond);
7445	}
7446
7447	/**
7448	* Returns the full path to the default video capture file.
7449	*/
7450	void Machine::i_getDefaultVideoCaptureFile(Utf8Str &strFile)
7451	{
7452	AutoCaller autoCaller(this);
7453	AssertComRCReturnVoid(autoCaller.rc());
7454
7455	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7456
7457	strFile = mData->m_strConfigFileFull; // path/to/machinesfolder/vmname/vmname.vbox
7458	strFile.stripSuffix(); // path/to/machinesfolder/vmname/vmname
7459	strFile.append(".webm"); // path/to/machinesfolder/vmname/vmname.webm
7460	}
7461
7462	/**
7463	* Returns whether at least one USB controller is present for the VM.
7464	*/
7465	bool Machine::i_isUSBControllerPresent()
7466	{
7467	AutoCaller autoCaller(this);
7468	AssertComRCReturn(autoCaller.rc(), false);
7469
7470	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7471
7472	return (mUSBControllers->size() > 0);
7473	}
7474
7475	/**
7476	* @note Locks this object for writing, calls the client process
7477	* (inside the lock).
7478	*/
7479	HRESULT Machine::i_launchVMProcess(IInternalSessionControl *aControl,
7480	const Utf8Str &strFrontend,
7481	const Utf8Str &strEnvironment,
7482	ProgressProxy *aProgress)
7483	{
7484	LogFlowThisFuncEnter();
7485
7486	AssertReturn(aControl, E_FAIL);
7487	AssertReturn(aProgress, E_FAIL);
7488	AssertReturn(!strFrontend.isEmpty(), E_FAIL);
7489
7490	AutoCaller autoCaller(this);
7491	if (FAILED(autoCaller.rc())) return autoCaller.rc();
7492
7493	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7494
7495	if (!mData->mRegistered)
7496	return setError(E_UNEXPECTED,
7497	tr("The machine '%s' is not registered"),
7498	mUserData->s.strName.c_str());
7499
7500	LogFlowThisFunc(("mSession.mState=%s\n", Global::stringifySessionState(mData->mSession.mState)));
7501
7502	/* The process started when launching a VM with separate UI/VM processes is always
7503	* the UI process, i.e. needs special handling as it won't claim the session. */
7504	bool fSeparate = strFrontend.endsWith("separate", Utf8Str::CaseInsensitive);
7505
7506	if (fSeparate)
7507	{
7508	if (mData->mSession.mState != SessionState_Unlocked && mData->mSession.mName != "headless")
7509	return setError(VBOX_E_INVALID_OBJECT_STATE,
7510	tr("The machine '%s' is in a state which is incompatible with launching a separate UI process"),
7511	mUserData->s.strName.c_str());
7512	}
7513	else
7514	{
7515	if ( mData->mSession.mState == SessionState_Locked
7516	\|\| mData->mSession.mState == SessionState_Spawning
7517	\|\| mData->mSession.mState == SessionState_Unlocking)
7518	return setError(VBOX_E_INVALID_OBJECT_STATE,
7519	tr("The machine '%s' is already locked by a session (or being locked or unlocked)"),
7520	mUserData->s.strName.c_str());
7521
7522	/* may not be busy */
7523	AssertReturn(!Global::IsOnlineOrTransient(mData->mMachineState), E_FAIL);
7524	}
7525
7526	/* get the path to the executable */
7527	char szPath[RTPATH_MAX];
7528	RTPathAppPrivateArch(szPath, sizeof(szPath) - 1);
7529	size_t cchBufLeft = strlen(szPath);
7530	szPath[cchBufLeft++] = RTPATH_DELIMITER;
7531	szPath[cchBufLeft] = 0;
7532	char *pszNamePart = szPath + cchBufLeft;
7533	cchBufLeft = sizeof(szPath) - cchBufLeft;
7534
7535	int vrc = VINF_SUCCESS;
7536	RTPROCESS pid = NIL_RTPROCESS;
7537
7538	RTENV env = RTENV_DEFAULT;
7539
7540	if (!strEnvironment.isEmpty())
7541	{
7542	char *newEnvStr = NULL;
7543
7544	do
7545	{
7546	/* clone the current environment */
7547	int vrc2 = RTEnvClone(&env, RTENV_DEFAULT);
7548	AssertRCBreakStmt(vrc2, vrc = vrc2);
7549
7550	newEnvStr = RTStrDup(strEnvironment.c_str());
7551	AssertPtrBreakStmt(newEnvStr, vrc = vrc2);
7552
7553	/* put new variables to the environment
7554	* (ignore empty variable names here since RTEnv API
7555	* intentionally doesn't do that) */
7556	char *var = newEnvStr;
7557	for (char p = newEnvStr; p; ++p)
7558	{
7559	if (p == '\n' && (p == newEnvStr \|\| (p - 1) != '\\'))
7560	{
7561	*p = '\0';
7562	if (*var)
7563	{
7564	char *val = strchr(var, '=');
7565	if (val)
7566	{
7567	*val++ = '\0';
7568	vrc2 = RTEnvSetEx(env, var, val);
7569	}
7570	else
7571	vrc2 = RTEnvUnsetEx(env, var);
7572	if (RT_FAILURE(vrc2))
7573	break;
7574	}
7575	var = p + 1;
7576	}
7577	}
7578	if (RT_SUCCESS(vrc2) && *var)
7579	vrc2 = RTEnvPutEx(env, var);
7580
7581	AssertRCBreakStmt(vrc2, vrc = vrc2);
7582	}
7583	while (0);
7584
7585	if (newEnvStr != NULL)
7586	RTStrFree(newEnvStr);
7587	}
7588
7589	/* Hardening logging */
7590	#if defined(RT_OS_WINDOWS) && defined(VBOX_WITH_HARDENING)
7591	Utf8Str strSupHardeningLogArg("--sup-hardening-log=");
7592	{
7593	Utf8Str strHardeningLogFile = i_getHardeningLogFilename();
7594	int vrc2 = RTFileDelete(strHardeningLogFile.c_str());
7595	if (vrc2 == VERR_PATH_NOT_FOUND \|\| vrc2 == VERR_FILE_NOT_FOUND)
7596	{
7597	Utf8Str strStartupLogDir = strHardeningLogFile;
7598	strStartupLogDir.stripFilename();
7599	RTDirCreateFullPath(strStartupLogDir.c_str(), 0755); /** @todo add a variant for creating the path to a
7600	file without stripping the file. */
7601	}
7602	strSupHardeningLogArg.append(strHardeningLogFile);
7603
7604	/* Remove legacy log filename to avoid confusion. */
7605	Utf8Str strOldStartupLogFile;
7606	getLogFolder(strOldStartupLogFile);
7607	strOldStartupLogFile.append(RTPATH_SLASH_STR "VBoxStartup.log");
7608	RTFileDelete(strOldStartupLogFile.c_str());
7609	}
7610	const char *pszSupHardeningLogArg = strSupHardeningLogArg.c_str();
7611	#else
7612	const char *pszSupHardeningLogArg = NULL;
7613	#endif
7614
7615	Utf8Str strCanonicalName;
7616
7617	#ifdef VBOX_WITH_QTGUI
7618	if ( !strFrontend.compare("gui", Utf8Str::CaseInsensitive)
7619	\|\| !strFrontend.compare("GUI/Qt", Utf8Str::CaseInsensitive)
7620	\|\| !strFrontend.compare("separate", Utf8Str::CaseInsensitive)
7621	\|\| !strFrontend.compare("gui/separate", Utf8Str::CaseInsensitive)
7622	\|\| !strFrontend.compare("GUI/Qt/separate", Utf8Str::CaseInsensitive))
7623	{
7624	strCanonicalName = "GUI/Qt";
7625	# ifdef RT_OS_DARWIN /* Avoid Launch Services confusing this with the selector by using a helper app. */
7626	/* Modify the base path so that we don't need to use ".." below. */
7627	RTPathStripTrailingSlash(szPath);
7628	RTPathStripFilename(szPath);
7629	cchBufLeft = strlen(szPath);
7630	pszNamePart = szPath + cchBufLeft;
7631	cchBufLeft = sizeof(szPath) - cchBufLeft;
7632
7633	# define OSX_APP_NAME "VirtualBoxVM"
7634	# define OSX_APP_PATH_FMT "/Resources/%s.app/Contents/MacOS/VirtualBoxVM"
7635
7636	Utf8Str strAppOverride = i_getExtraData(Utf8Str("VBoxInternal2/VirtualBoxVMAppOverride"));
7637	if ( strAppOverride.contains(".")
7638	\|\| strAppOverride.contains("/")
7639	\|\| strAppOverride.contains("\\")
7640	\|\| strAppOverride.contains(":"))
7641	strAppOverride.setNull();
7642	Utf8Str strAppPath;
7643	if (!strAppOverride.isEmpty())
7644	{
7645	strAppPath = Utf8StrFmt(OSX_APP_PATH_FMT, strAppOverride.c_str());
7646	Utf8Str strFullPath(szPath);
7647	strFullPath.append(strAppPath);
7648	/* there is a race, but people using this deserve the failure */
7649	if (!RTFileExists(strFullPath.c_str()))
7650	strAppOverride.setNull();
7651	}
7652	if (strAppOverride.isEmpty())
7653	strAppPath = Utf8StrFmt(OSX_APP_PATH_FMT, OSX_APP_NAME);
7654	AssertReturn(cchBufLeft > strAppPath.length(), E_UNEXPECTED);
7655	strcpy(pszNamePart, strAppPath.c_str());
7656	# else
7657	static const char s_szVirtualBox_exe[] = "VirtualBox" HOSTSUFF_EXE;
7658	Assert(cchBufLeft >= sizeof(s_szVirtualBox_exe));
7659	strcpy(pszNamePart, s_szVirtualBox_exe);
7660	# endif
7661
7662	Utf8Str idStr = mData->mUuid.toString();
7663	const char *apszArgs[] =
7664	{
7665	szPath,
7666	"--comment", mUserData->s.strName.c_str(),
7667	"--startvm", idStr.c_str(),
7668	"--no-startvm-errormsgbox",
7669	NULL, /* For "--separate". */
7670	NULL, /* For "--sup-startup-log". */
7671	NULL
7672	};
7673	unsigned iArg = 6;
7674	if (fSeparate)
7675	apszArgs[iArg++] = "--separate";
7676	apszArgs[iArg++] = pszSupHardeningLogArg;
7677
7678	vrc = RTProcCreate(szPath, apszArgs, env, 0, &pid);
7679	}
7680	#else /* !VBOX_WITH_QTGUI */
7681	if (0)
7682	;
7683	#endif /* VBOX_WITH_QTGUI */
7684
7685	else
7686
7687	#ifdef VBOX_WITH_VBOXSDL
7688	if ( !strFrontend.compare("sdl", Utf8Str::CaseInsensitive)
7689	\|\| !strFrontend.compare("GUI/SDL", Utf8Str::CaseInsensitive)
7690	\|\| !strFrontend.compare("sdl/separate", Utf8Str::CaseInsensitive)
7691	\|\| !strFrontend.compare("GUI/SDL/separate", Utf8Str::CaseInsensitive))
7692	{
7693	strCanonicalName = "GUI/SDL";
7694	static const char s_szVBoxSDL_exe[] = "VBoxSDL" HOSTSUFF_EXE;
7695	Assert(cchBufLeft >= sizeof(s_szVBoxSDL_exe));
7696	strcpy(pszNamePart, s_szVBoxSDL_exe);
7697
7698	Utf8Str idStr = mData->mUuid.toString();
7699	const char *apszArgs[] =
7700	{
7701	szPath,
7702	"--comment", mUserData->s.strName.c_str(),
7703	"--startvm", idStr.c_str(),
7704	NULL, /* For "--separate". */
7705	NULL, /* For "--sup-startup-log". */
7706	NULL
7707	};
7708	unsigned iArg = 5;
7709	if (fSeparate)
7710	apszArgs[iArg++] = "--separate";
7711	apszArgs[iArg++] = pszSupHardeningLogArg;
7712
7713	vrc = RTProcCreate(szPath, apszArgs, env, 0, &pid);
7714	}
7715	#else /* !VBOX_WITH_VBOXSDL */
7716	if (0)
7717	;
7718	#endif /* !VBOX_WITH_VBOXSDL */
7719
7720	else
7721
7722	#ifdef VBOX_WITH_HEADLESS
7723	if ( !strFrontend.compare("headless", Utf8Str::CaseInsensitive)
7724	\|\| !strFrontend.compare("capture", Utf8Str::CaseInsensitive)
7725	\|\| !strFrontend.compare("vrdp", Utf8Str::CaseInsensitive) /* Deprecated. Same as headless. */
7726	)
7727	{
7728	strCanonicalName = "headless";
7729	/* On pre-4.0 the "headless" type was used for passing "--vrdp off" to VBoxHeadless to let it work in OSE,
7730	* which did not contain VRDP server. In VBox 4.0 the remote desktop server (VRDE) is optional,
7731	* and a VM works even if the server has not been installed.
7732	* So in 4.0 the "headless" behavior remains the same for default VBox installations.
7733	* Only if a VRDE has been installed and the VM enables it, the "headless" will work
7734	* differently in 4.0 and 3.x.
7735	*/
7736	static const char s_szVBoxHeadless_exe[] = "VBoxHeadless" HOSTSUFF_EXE;
7737	Assert(cchBufLeft >= sizeof(s_szVBoxHeadless_exe));
7738	strcpy(pszNamePart, s_szVBoxHeadless_exe);
7739
7740	Utf8Str idStr = mData->mUuid.toString();
7741	const char *apszArgs[] =
7742	{
7743	szPath,
7744	"--comment", mUserData->s.strName.c_str(),
7745	"--startvm", idStr.c_str(),
7746	"--vrde", "config",
7747	NULL, /* For "--capture". */
7748	NULL, /* For "--sup-startup-log". */
7749	NULL
7750	};
7751	unsigned iArg = 7;
7752	if (!strFrontend.compare("capture", Utf8Str::CaseInsensitive))
7753	apszArgs[iArg++] = "--capture";
7754	apszArgs[iArg++] = pszSupHardeningLogArg;
7755
7756	# ifdef RT_OS_WINDOWS
7757	vrc = RTProcCreate(szPath, apszArgs, env, RTPROC_FLAGS_NO_WINDOW, &pid);
7758	# else
7759	vrc = RTProcCreate(szPath, apszArgs, env, 0, &pid);
7760	# endif
7761	}
7762	#else /* !VBOX_WITH_HEADLESS */
7763	if (0)
7764	;
7765	#endif /* !VBOX_WITH_HEADLESS */
7766	else
7767	{
7768	RTEnvDestroy(env);
7769	return setError(E_INVALIDARG,
7770	tr("Invalid frontend name: '%s'"),
7771	strFrontend.c_str());
7772	}
7773
7774	RTEnvDestroy(env);
7775
7776	if (RT_FAILURE(vrc))
7777	return setError(VBOX_E_IPRT_ERROR,
7778	tr("Could not launch a process for the machine '%s' (%Rrc)"),
7779	mUserData->s.strName.c_str(), vrc);
7780
7781	LogFlowThisFunc(("launched.pid=%d(0x%x)\n", pid, pid));
7782
7783	if (!fSeparate)
7784	{
7785	/*
7786	* Note that we don't release the lock here before calling the client,
7787	* because it doesn't need to call us back if called with a NULL argument.
7788	* Releasing the lock here is dangerous because we didn't prepare the
7789	* launch data yet, but the client we've just started may happen to be
7790	* too fast and call LockMachine() that will fail (because of PID, etc.),
7791	* so that the Machine will never get out of the Spawning session state.
7792	*/
7793
7794	/* inform the session that it will be a remote one */
7795	LogFlowThisFunc(("Calling AssignMachine (NULL)...\n"));
7796	#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
7797	HRESULT rc = aControl->AssignMachine(NULL, LockType_Write, Bstr::Empty.raw());
7798	#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
7799	HRESULT rc = aControl->AssignMachine(NULL, LockType_Write, NULL);
7800	#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
7801	LogFlowThisFunc(("AssignMachine (NULL) returned %08X\n", rc));
7802
7803	if (FAILED(rc))
7804	{
7805	/* restore the session state */
7806	mData->mSession.mState = SessionState_Unlocked;
7807	alock.release();
7808	mParent->i_addProcessToReap(pid);
7809	/* The failure may occur w/o any error info (from RPC), so provide one */
7810	return setError(VBOX_E_VM_ERROR,
7811	tr("Failed to assign the machine to the session (%Rhrc)"), rc);
7812	}
7813
7814	/* attach launch data to the machine */
7815	Assert(mData->mSession.mPID == NIL_RTPROCESS);
7816	mData->mSession.mRemoteControls.push_back(aControl);
7817	mData->mSession.mProgress = aProgress;
7818	mData->mSession.mPID = pid;
7819	mData->mSession.mState = SessionState_Spawning;
7820	Assert(strCanonicalName.isNotEmpty());
7821	mData->mSession.mName = strCanonicalName;
7822	}
7823	else
7824	{
7825	/* For separate UI process we declare the launch as completed instantly, as the
7826	* actual headless VM start may or may not come. No point in remembering anything
7827	* yet, as what matters for us is when the headless VM gets started. */
7828	aProgress->i_notifyComplete(S_OK);
7829	}
7830
7831	alock.release();
7832	mParent->i_addProcessToReap(pid);
7833
7834	LogFlowThisFuncLeave();
7835	return S_OK;
7836	}
7837
7838	/**
7839	* Returns @c true if the given session machine instance has an open direct
7840	* session (and optionally also for direct sessions which are closing) and
7841	* returns the session control machine instance if so.
7842	*
7843	* Note that when the method returns @c false, the arguments remain unchanged.
7844	*
7845	* @param aMachine Session machine object.
7846	* @param aControl Direct session control object (optional).
7847	* @param aRequireVM If true then only allow VM sessions.
7848	* @param aAllowClosing If true then additionally a session which is currently
7849	* being closed will also be allowed.
7850	*
7851	* @note locks this object for reading.
7852	*/
7853	bool Machine::i_isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
7854	ComPtr<IInternalSessionControl> aControl /= NULL*/,
7855	bool aRequireVM /= false/,
7856	bool aAllowClosing /= false/)
7857	{
7858	AutoLimitedCaller autoCaller(this);
7859	AssertComRCReturn(autoCaller.rc(), false);
7860
7861	/* just return false for inaccessible machines */
7862	if (getObjectState().getState() != ObjectState::Ready)
7863	return false;
7864
7865	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7866
7867	if ( ( mData->mSession.mState == SessionState_Locked
7868	&& (!aRequireVM \|\| mData->mSession.mLockType == LockType_VM))
7869	\|\| (aAllowClosing && mData->mSession.mState == SessionState_Unlocking)
7870	)
7871	{
7872	AssertReturn(!mData->mSession.mMachine.isNull(), false);
7873
7874	aMachine = mData->mSession.mMachine;
7875
7876	if (aControl != NULL)
7877	*aControl = mData->mSession.mDirectControl;
7878
7879	return true;
7880	}
7881
7882	return false;
7883	}
7884
7885	/**
7886	* Returns @c true if the given machine has an spawning direct session.
7887	*
7888	* @note locks this object for reading.
7889	*/
7890	bool Machine::i_isSessionSpawning()
7891	{
7892	AutoLimitedCaller autoCaller(this);
7893	AssertComRCReturn(autoCaller.rc(), false);
7894
7895	/* just return false for inaccessible machines */
7896	if (getObjectState().getState() != ObjectState::Ready)
7897	return false;
7898
7899	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7900
7901	if (mData->mSession.mState == SessionState_Spawning)
7902	return true;
7903
7904	return false;
7905	}
7906
7907	/**
7908	* Called from the client watcher thread to check for unexpected client process
7909	* death during Session_Spawning state (e.g. before it successfully opened a
7910	* direct session).
7911	*
7912	* On Win32 and on OS/2, this method is called only when we've got the
7913	* direct client's process termination notification, so it always returns @c
7914	* true.
7915	*
7916	* On other platforms, this method returns @c true if the client process is
7917	* terminated and @c false if it's still alive.
7918	*
7919	* @note Locks this object for writing.
7920	*/
7921	bool Machine::i_checkForSpawnFailure()
7922	{
7923	AutoCaller autoCaller(this);
7924	if (!autoCaller.isOk())
7925	{
7926	/* nothing to do */
7927	LogFlowThisFunc(("Already uninitialized!\n"));
7928	return true;
7929	}
7930
7931	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7932
7933	if (mData->mSession.mState != SessionState_Spawning)
7934	{
7935	/* nothing to do */
7936	LogFlowThisFunc(("Not spawning any more!\n"));
7937	return true;
7938	}
7939
7940	HRESULT rc = S_OK;
7941
7942	/* PID not yet initialized, skip check. */
7943	if (mData->mSession.mPID == NIL_RTPROCESS)
7944	return false;
7945
7946	RTPROCSTATUS status;
7947	int vrc = RTProcWait(mData->mSession.mPID, RTPROCWAIT_FLAGS_NOBLOCK, &status);
7948
7949	if (vrc != VERR_PROCESS_RUNNING)
7950	{
7951	Utf8Str strExtraInfo;
7952
7953	#if defined(RT_OS_WINDOWS) && defined(VBOX_WITH_HARDENING)
7954	/* If the startup logfile exists and is of non-zero length, tell the
7955	user to look there for more details to encourage them to attach it
7956	when reporting startup issues. */
7957	Utf8Str strHardeningLogFile = i_getHardeningLogFilename();
7958	uint64_t cbStartupLogFile = 0;
7959	int vrc2 = RTFileQuerySize(strHardeningLogFile.c_str(), &cbStartupLogFile);
7960	if (RT_SUCCESS(vrc2) && cbStartupLogFile > 0)
7961	strExtraInfo.append(Utf8StrFmt(tr(". More details may be available in '%s'"), strHardeningLogFile.c_str()));
7962	#endif
7963
7964	if (RT_SUCCESS(vrc) && status.enmReason == RTPROCEXITREASON_NORMAL)
7965	rc = setError(E_FAIL,
7966	tr("The virtual machine '%s' has terminated unexpectedly during startup with exit code %d (%#x)%s"),
7967	i_getName().c_str(), status.iStatus, status.iStatus, strExtraInfo.c_str());
7968	else if (RT_SUCCESS(vrc) && status.enmReason == RTPROCEXITREASON_SIGNAL)
7969	rc = setError(E_FAIL,
7970	tr("The virtual machine '%s' has terminated unexpectedly during startup because of signal %d%s"),
7971	i_getName().c_str(), status.iStatus, strExtraInfo.c_str());
7972	else if (RT_SUCCESS(vrc) && status.enmReason == RTPROCEXITREASON_ABEND)
7973	rc = setError(E_FAIL,
7974	tr("The virtual machine '%s' has terminated abnormally (iStatus=%#x)%s"),
7975	i_getName().c_str(), status.iStatus, strExtraInfo.c_str());
7976	else
7977	rc = setError(E_FAIL,
7978	tr("The virtual machine '%s' has terminated unexpectedly during startup (%Rrc)%s"),
7979	i_getName().c_str(), vrc, strExtraInfo.c_str());
7980	}
7981
7982	if (FAILED(rc))
7983	{
7984	/* Close the remote session, remove the remote control from the list
7985	* and reset session state to Closed (@note keep the code in sync with
7986	* the relevant part in LockMachine()). */
7987
7988	Assert(mData->mSession.mRemoteControls.size() == 1);
7989	if (mData->mSession.mRemoteControls.size() == 1)
7990	{
7991	ErrorInfoKeeper eik;
7992	mData->mSession.mRemoteControls.front()->Uninitialize();
7993	}
7994
7995	mData->mSession.mRemoteControls.clear();
7996	mData->mSession.mState = SessionState_Unlocked;
7997
7998	/* finalize the progress after setting the state */
7999	if (!mData->mSession.mProgress.isNull())
8000	{
8001	mData->mSession.mProgress->notifyComplete(rc);
8002	mData->mSession.mProgress.setNull();
8003	}
8004
8005	mData->mSession.mPID = NIL_RTPROCESS;
8006
8007	mParent->i_onSessionStateChange(mData->mUuid, SessionState_Unlocked);
8008	return true;
8009	}
8010
8011	return false;
8012	}
8013
8014	/**
8015	* Checks whether the machine can be registered. If so, commits and saves
8016	* all settings.
8017	*
8018	* @note Must be called from mParent's write lock. Locks this object and
8019	* children for writing.
8020	*/
8021	HRESULT Machine::i_prepareRegister()
8022	{
8023	AssertReturn(mParent->isWriteLockOnCurrentThread(), E_FAIL);
8024
8025	AutoLimitedCaller autoCaller(this);
8026	AssertComRCReturnRC(autoCaller.rc());
8027
8028	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
8029
8030	/* wait for state dependents to drop to zero */
8031	i_ensureNoStateDependencies();
8032
8033	if (!mData->mAccessible)
8034	return setError(VBOX_E_INVALID_OBJECT_STATE,
8035	tr("The machine '%s' with UUID {%s} is inaccessible and cannot be registered"),
8036	mUserData->s.strName.c_str(),
8037	mData->mUuid.toString().c_str());
8038
8039	AssertReturn(getObjectState().getState() == ObjectState::Ready, E_FAIL);
8040
8041	if (mData->mRegistered)
8042	return setError(VBOX_E_INVALID_OBJECT_STATE,
8043	tr("The machine '%s' with UUID {%s} is already registered"),
8044	mUserData->s.strName.c_str(),
8045	mData->mUuid.toString().c_str());
8046
8047	HRESULT rc = S_OK;
8048
8049	// Ensure the settings are saved. If we are going to be registered and
8050	// no config file exists yet, create it by calling i_saveSettings() too.
8051	if ( (mData->flModifications)
8052	\|\| (!mData->pMachineConfigFile->fileExists())
8053	)
8054	{
8055	rc = i_saveSettings(NULL);
8056	// no need to check whether VirtualBox.xml needs saving too since
8057	// we can't have a machine XML file rename pending
8058	if (FAILED(rc)) return rc;
8059	}
8060
8061	/* more config checking goes here */
8062
8063	if (SUCCEEDED(rc))
8064	{
8065	/* we may have had implicit modifications we want to fix on success */
8066	i_commit();
8067
8068	mData->mRegistered = true;
8069	}
8070	else
8071	{
8072	/* we may have had implicit modifications we want to cancel on failure*/
8073	i_rollback(false /* aNotify */);
8074	}
8075
8076	return rc;
8077	}
8078
8079	/**
8080	* Increases the number of objects dependent on the machine state or on the
8081	* registered state. Guarantees that these two states will not change at least
8082	* until #i_releaseStateDependency() is called.
8083	*
8084	* Depending on the @a aDepType value, additional state checks may be made.
8085	* These checks will set extended error info on failure. See
8086	* #i_checkStateDependency() for more info.
8087	*
8088	* If this method returns a failure, the dependency is not added and the caller
8089	* is not allowed to rely on any particular machine state or registration state
8090	* value and may return the failed result code to the upper level.
8091	*
8092	* @param aDepType Dependency type to add.
8093	* @param aState Current machine state (NULL if not interested).
8094	* @param aRegistered Current registered state (NULL if not interested).
8095	*
8096	* @note Locks this object for writing.
8097	*/
8098	HRESULT Machine::i_addStateDependency(StateDependency aDepType /* = AnyStateDep */,
8099	MachineState_T aState / = NULL */,
8100	BOOL aRegistered / = NULL */)
8101	{
8102	AutoCaller autoCaller(this);
8103	AssertComRCReturnRC(autoCaller.rc());
8104
8105	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
8106
8107	HRESULT rc = i_checkStateDependency(aDepType);
8108	if (FAILED(rc)) return rc;
8109
8110	{
8111	if (mData->mMachineStateChangePending != 0)
8112	{
8113	/* i_ensureNoStateDependencies() is waiting for state dependencies to
8114	* drop to zero so don't add more. It may make sense to wait a bit
8115	* and retry before reporting an error (since the pending state
8116	* transition should be really quick) but let's just assert for
8117	* now to see if it ever happens on practice. */
8118
8119	AssertFailed();
8120
8121	return setError(E_ACCESSDENIED,
8122	tr("Machine state change is in progress. Please retry the operation later."));
8123	}
8124
8125	++mData->mMachineStateDeps;
8126	Assert(mData->mMachineStateDeps != 0 /* overflow */);
8127	}
8128
8129	if (aState)
8130	*aState = mData->mMachineState;
8131	if (aRegistered)
8132	*aRegistered = mData->mRegistered;
8133
8134	return S_OK;
8135	}
8136
8137	/**
8138	* Decreases the number of objects dependent on the machine state.
8139	* Must always complete the #i_addStateDependency() call after the state
8140	* dependency is no more necessary.
8141	*/
8142	void Machine::i_releaseStateDependency()
8143	{
8144	AutoCaller autoCaller(this);
8145	AssertComRCReturnVoid(autoCaller.rc());
8146
8147	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
8148
8149	/* releaseStateDependency() w/o addStateDependency()? */
8150	AssertReturnVoid(mData->mMachineStateDeps != 0);
8151	-- mData->mMachineStateDeps;
8152
8153	if (mData->mMachineStateDeps == 0)
8154	{
8155	/* inform i_ensureNoStateDependencies() that there are no more deps */
8156	if (mData->mMachineStateChangePending != 0)
8157	{
8158	Assert(mData->mMachineStateDepsSem != NIL_RTSEMEVENTMULTI);
8159	RTSemEventMultiSignal (mData->mMachineStateDepsSem);
8160	}
8161	}
8162	}
8163
8164	Utf8Str Machine::i_getExtraData(const Utf8Str &strKey)
8165	{
8166	/* start with nothing found */
8167	Utf8Str strResult("");
8168
8169	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
8170
8171	settings::StringsMap::const_iterator it = mData->pMachineConfigFile->mapExtraDataItems.find(strKey);
8172	if (it != mData->pMachineConfigFile->mapExtraDataItems.end())
8173	// found:
8174	strResult = it->second; // source is a Utf8Str
8175
8176	return strResult;
8177	}
8178
8179	// protected methods
8180	/////////////////////////////////////////////////////////////////////////////
8181
8182	/**
8183	* Performs machine state checks based on the @a aDepType value. If a check
8184	* fails, this method will set extended error info, otherwise it will return
8185	* S_OK. It is supposed, that on failure, the caller will immediately return
8186	* the return value of this method to the upper level.
8187	*
8188	* When @a aDepType is AnyStateDep, this method always returns S_OK.
8189	*
8190	* When @a aDepType is MutableStateDep, this method returns S_OK only if the
8191	* current state of this machine object allows to change settings of the
8192	* machine (i.e. the machine is not registered, or registered but not running
8193	* and not saved). It is useful to call this method from Machine setters
8194	* before performing any change.
8195	*
8196	* When @a aDepType is MutableOrSavedStateDep, this method behaves the same
8197	* as for MutableStateDep except that if the machine is saved, S_OK is also
8198	* returned. This is useful in setters which allow changing machine
8199	* properties when it is in the saved state.
8200	*
8201	* When @a aDepType is MutableOrRunningStateDep, this method returns S_OK only
8202	* if the current state of this machine object allows to change runtime
8203	* changeable settings of the machine (i.e. the machine is not registered, or
8204	* registered but either running or not running and not saved). It is useful
8205	* to call this method from Machine setters before performing any changes to
8206	* runtime changeable settings.
8207	*
8208	* When @a aDepType is MutableOrSavedOrRunningStateDep, this method behaves
8209	* the same as for MutableOrRunningStateDep except that if the machine is
8210	* saved, S_OK is also returned. This is useful in setters which allow
8211	* changing runtime and saved state changeable machine properties.
8212	*
8213	* @param aDepType Dependency type to check.
8214	*
8215	* @note Non Machine based classes should use #i_addStateDependency() and
8216	* #i_releaseStateDependency() methods or the smart AutoStateDependency
8217	* template.
8218	*
8219	* @note This method must be called from under this object's read or write
8220	* lock.
8221	*/
8222	HRESULT Machine::i_checkStateDependency(StateDependency aDepType)
8223	{
8224	switch (aDepType)
8225	{
8226	case AnyStateDep:
8227	{
8228	break;
8229	}
8230	case MutableStateDep:
8231	{
8232	if ( mData->mRegistered
8233	&& ( !i_isSessionMachine()
8234	\|\| ( mData->mMachineState != MachineState_Aborted
8235	&& mData->mMachineState != MachineState_Teleported
8236	&& mData->mMachineState != MachineState_PoweredOff
8237	)
8238	)
8239	)
8240	return setError(VBOX_E_INVALID_VM_STATE,
8241	tr("The machine is not mutable (state is %s)"),
8242	Global::stringifyMachineState(mData->mMachineState));
8243	break;
8244	}
8245	case MutableOrSavedStateDep:
8246	{
8247	if ( mData->mRegistered
8248	&& ( !i_isSessionMachine()
8249	\|\| ( mData->mMachineState != MachineState_Aborted
8250	&& mData->mMachineState != MachineState_Teleported
8251	&& mData->mMachineState != MachineState_Saved
8252	&& mData->mMachineState != MachineState_PoweredOff
8253	)
8254	)
8255	)
8256	return setError(VBOX_E_INVALID_VM_STATE,
8257	tr("The machine is not mutable or saved (state is %s)"),
8258	Global::stringifyMachineState(mData->mMachineState));
8259	break;
8260	}
8261	case MutableOrRunningStateDep:
8262	{
8263	if ( mData->mRegistered
8264	&& ( !i_isSessionMachine()
8265	\|\| ( mData->mMachineState != MachineState_Aborted
8266	&& mData->mMachineState != MachineState_Teleported
8267	&& mData->mMachineState != MachineState_PoweredOff
8268	&& !Global::IsOnline(mData->mMachineState)
8269	)
8270	)
8271	)
8272	return setError(VBOX_E_INVALID_VM_STATE,
8273	tr("The machine is not mutable or running (state is %s)"),
8274	Global::stringifyMachineState(mData->mMachineState));
8275	break;
8276	}
8277	case MutableOrSavedOrRunningStateDep:
8278	{
8279	if ( mData->mRegistered
8280	&& ( !i_isSessionMachine()
8281	\|\| ( mData->mMachineState != MachineState_Aborted
8282	&& mData->mMachineState != MachineState_Teleported
8283	&& mData->mMachineState != MachineState_Saved
8284	&& mData->mMachineState != MachineState_PoweredOff
8285	&& !Global::IsOnline(mData->mMachineState)
8286	)
8287	)
8288	)
8289	return setError(VBOX_E_INVALID_VM_STATE,
8290	tr("The machine is not mutable, saved or running (state is %s)"),
8291	Global::stringifyMachineState(mData->mMachineState));
8292	break;
8293	}
8294	}
8295
8296	return S_OK;
8297	}
8298
8299	/**
8300	* Helper to initialize all associated child objects and allocate data
8301	* structures.
8302	*
8303	* This method must be called as a part of the object's initialization procedure
8304	* (usually done in the #init() method).
8305	*
8306	* @note Must be called only from #init() or from #i_registeredInit().
8307	*/
8308	HRESULT Machine::initDataAndChildObjects()
8309	{
8310	AutoCaller autoCaller(this);
8311	AssertComRCReturnRC(autoCaller.rc());
8312	AssertComRCReturn( getObjectState().getState() == ObjectState::InInit
8313	\|\| getObjectState().getState() == ObjectState::Limited, E_FAIL);
8314
8315	AssertReturn(!mData->mAccessible, E_FAIL);
8316
8317	/* allocate data structures */
8318	mSSData.allocate();
8319	mUserData.allocate();
8320	mHWData.allocate();
8321	mMediumAttachments.allocate();
8322	mStorageControllers.allocate();
8323	mUSBControllers.allocate();
8324
8325	/* initialize mOSTypeId */
8326	mUserData->s.strOsType = mParent->i_getUnknownOSType()->i_id();
8327
8328	/** @todo r=bird: init() methods never fails, right? Why don't we make them
8329	* return void then! */
8330
8331	/* create associated BIOS settings object */
8332	unconst(mBIOSSettings).createObject();
8333	mBIOSSettings->init(this);
8334
8335	/* create an associated VRDE object (default is disabled) */
8336	unconst(mVRDEServer).createObject();
8337	mVRDEServer->init(this);
8338
8339	/* create associated serial port objects */
8340	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
8341	{
8342	unconst(mSerialPorts[slot]).createObject();
8343	mSerialPorts[slot]->init(this, slot);
8344	}
8345
8346	/* create associated parallel port objects */
8347	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
8348	{
8349	unconst(mParallelPorts[slot]).createObject();
8350	mParallelPorts[slot]->init(this, slot);
8351	}
8352
8353	/* create the audio adapter object (always present, default is disabled) */
8354	unconst(mAudioAdapter).createObject();
8355	mAudioAdapter->init(this);
8356
8357	/* create the USB device filters object (always present) */
8358	unconst(mUSBDeviceFilters).createObject();
8359	mUSBDeviceFilters->init(this);
8360
8361	/* create associated network adapter objects */
8362	mNetworkAdapters.resize(Global::getMaxNetworkAdapters(mHWData->mChipsetType));
8363	for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
8364	{
8365	unconst(mNetworkAdapters[slot]).createObject();
8366	mNetworkAdapters[slot]->init(this, slot);
8367	}
8368
8369	/* create the bandwidth control */
8370	unconst(mBandwidthControl).createObject();
8371	mBandwidthControl->init(this);
8372
8373	return S_OK;
8374	}
8375
8376	/**
8377	* Helper to uninitialize all associated child objects and to free all data
8378	* structures.
8379	*
8380	* This method must be called as a part of the object's uninitialization
8381	* procedure (usually done in the #uninit() method).
8382	*
8383	* @note Must be called only from #uninit() or from #i_registeredInit().
8384	*/
8385	void Machine::uninitDataAndChildObjects()
8386	{
8387	AutoCaller autoCaller(this);
8388	AssertComRCReturnVoid(autoCaller.rc());
8389	AssertComRCReturnVoid( getObjectState().getState() == ObjectState::InUninit
8390	\|\| getObjectState().getState() == ObjectState::Limited);
8391
8392	/* tell all our other child objects we've been uninitialized */
8393	if (mBandwidthControl)
8394	{
8395	mBandwidthControl->uninit();
8396	unconst(mBandwidthControl).setNull();
8397	}
8398
8399	for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
8400	{
8401	if (mNetworkAdapters[slot])
8402	{
8403	mNetworkAdapters[slot]->uninit();
8404	unconst(mNetworkAdapters[slot]).setNull();
8405	}
8406	}
8407
8408	if (mUSBDeviceFilters)
8409	{
8410	mUSBDeviceFilters->uninit();
8411	unconst(mUSBDeviceFilters).setNull();
8412	}
8413
8414	if (mAudioAdapter)
8415	{
8416	mAudioAdapter->uninit();
8417	unconst(mAudioAdapter).setNull();
8418	}
8419
8420	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
8421	{
8422	if (mParallelPorts[slot])
8423	{
8424	mParallelPorts[slot]->uninit();
8425	unconst(mParallelPorts[slot]).setNull();
8426	}
8427	}
8428
8429	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
8430	{
8431	if (mSerialPorts[slot])
8432	{
8433	mSerialPorts[slot]->uninit();
8434	unconst(mSerialPorts[slot]).setNull();
8435	}
8436	}
8437
8438	if (mVRDEServer)
8439	{
8440	mVRDEServer->uninit();
8441	unconst(mVRDEServer).setNull();
8442	}
8443
8444	if (mBIOSSettings)
8445	{
8446	mBIOSSettings->uninit();
8447	unconst(mBIOSSettings).setNull();
8448	}
8449
8450	/* Deassociate media (only when a real Machine or a SnapshotMachine
8451	* instance is uninitialized; SessionMachine instances refer to real
8452	* Machine media). This is necessary for a clean re-initialization of
8453	* the VM after successfully re-checking the accessibility state. Note
8454	* that in case of normal Machine or SnapshotMachine uninitialization (as
8455	* a result of unregistering or deleting the snapshot), outdated media
8456	* attachments will already be uninitialized and deleted, so this
8457	* code will not affect them. */
8458	if ( !mMediumAttachments.isNull()
8459	&& !i_isSessionMachine()
8460	)
8461	{
8462	for (MediumAttachmentList::const_iterator
8463	it = mMediumAttachments->begin();
8464	it != mMediumAttachments->end();
8465	++it)
8466	{
8467	ComObjPtr<Medium> pMedium = (*it)->i_getMedium();
8468	if (pMedium.isNull())
8469	continue;
8470	HRESULT rc = pMedium->i_removeBackReference(mData->mUuid, i_getSnapshotId());
8471	AssertComRC(rc);
8472	}
8473	}
8474
8475	if (!i_isSessionMachine() && !i_isSnapshotMachine())
8476	{
8477	// clean up the snapshots list (Snapshot::uninit() will handle the snapshot's children recursively)
8478	if (mData->mFirstSnapshot)
8479	{
8480	// snapshots tree is protected by machine write lock; strictly
8481	// this isn't necessary here since we're deleting the entire
8482	// machine, but otherwise we assert in Snapshot::uninit()
8483	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
8484	mData->mFirstSnapshot->uninit();
8485	mData->mFirstSnapshot.setNull();
8486	}
8487
8488	mData->mCurrentSnapshot.setNull();
8489	}
8490
8491	/* free data structures (the essential mData structure is not freed here
8492	* since it may be still in use) */
8493	mMediumAttachments.free();
8494	mStorageControllers.free();
8495	mUSBControllers.free();
8496	mHWData.free();
8497	mUserData.free();
8498	mSSData.free();
8499	}
8500
8501	/**
8502	* Returns a pointer to the Machine object for this machine that acts like a
8503	* parent for complex machine data objects such as shared folders, etc.
8504	*
8505	* For primary Machine objects and for SnapshotMachine objects, returns this
8506	* object's pointer itself. For SessionMachine objects, returns the peer
8507	* (primary) machine pointer.
8508	*/
8509	Machine *Machine::i_getMachine()
8510	{
8511	if (i_isSessionMachine())
8512	return (Machine*)mPeer;
8513	return this;
8514	}
8515
8516	/**
8517	* Makes sure that there are no machine state dependents. If necessary, waits
8518	* for the number of dependents to drop to zero.
8519	*
8520	* Make sure this method is called from under this object's write lock to
8521	* guarantee that no new dependents may be added when this method returns
8522	* control to the caller.
8523	*
8524	* @note Locks this object for writing. The lock will be released while waiting
8525	* (if necessary).
8526	*
8527	* @warning To be used only in methods that change the machine state!
8528	*/
8529	void Machine::i_ensureNoStateDependencies()
8530	{
8531	AssertReturnVoid(isWriteLockOnCurrentThread());
8532
8533	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
8534
8535	/* Wait for all state dependents if necessary */
8536	if (mData->mMachineStateDeps != 0)
8537	{
8538	/* lazy semaphore creation */
8539	if (mData->mMachineStateDepsSem == NIL_RTSEMEVENTMULTI)
8540	RTSemEventMultiCreate(&mData->mMachineStateDepsSem);
8541
8542	LogFlowThisFunc(("Waiting for state deps (%d) to drop to zero...\n",
8543	mData->mMachineStateDeps));
8544
8545	++mData->mMachineStateChangePending;
8546
8547	/* reset the semaphore before waiting, the last dependent will signal
8548	* it */
8549	RTSemEventMultiReset(mData->mMachineStateDepsSem);
8550
8551	alock.release();
8552
8553	RTSemEventMultiWait(mData->mMachineStateDepsSem, RT_INDEFINITE_WAIT);
8554
8555	alock.acquire();
8556
8557	-- mData->mMachineStateChangePending;
8558	}
8559	}
8560
8561	/**
8562	* Changes the machine state and informs callbacks.
8563	*
8564	* This method is not intended to fail so it either returns S_OK or asserts (and
8565	* returns a failure).
8566	*
8567	* @note Locks this object for writing.
8568	*/
8569	HRESULT Machine::i_setMachineState(MachineState_T aMachineState)
8570	{
8571	LogFlowThisFuncEnter();
8572	LogFlowThisFunc(("aMachineState=%s\n", Global::stringifyMachineState(aMachineState) ));
8573	Assert(aMachineState != MachineState_Null);
8574
8575	AutoCaller autoCaller(this);
8576	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
8577
8578	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
8579
8580	/* wait for state dependents to drop to zero */
8581	i_ensureNoStateDependencies();
8582
8583	MachineState_T const enmOldState = mData->mMachineState;
8584	if (enmOldState != aMachineState)
8585	{
8586	mData->mMachineState = aMachineState;
8587	RTTimeNow(&mData->mLastStateChange);
8588
8589	#ifdef VBOX_WITH_DTRACE_R3_MAIN
8590	VBOXAPI_MACHINE_STATE_CHANGED(this, aMachineState, enmOldState, mData->mUuid.toStringCurly().c_str());
8591	#endif
8592	mParent->i_onMachineStateChange(mData->mUuid, aMachineState);
8593	}
8594
8595	LogFlowThisFuncLeave();
8596	return S_OK;
8597	}
8598
8599	/**
8600	* Searches for a shared folder with the given logical name
8601	* in the collection of shared folders.
8602	*
8603	* @param aName logical name of the shared folder
8604	* @param aSharedFolder where to return the found object
8605	* @param aSetError whether to set the error info if the folder is
8606	* not found
8607	* @return
8608	* S_OK when found or VBOX_E_OBJECT_NOT_FOUND when not found
8609	*
8610	* @note
8611	* must be called from under the object's lock!
8612	*/
8613	HRESULT Machine::i_findSharedFolder(const Utf8Str &aName,
8614	ComObjPtr<SharedFolder> &aSharedFolder,
8615	bool aSetError /* = false */)
8616	{
8617	HRESULT rc = VBOX_E_OBJECT_NOT_FOUND;
8618	for (HWData::SharedFolderList::const_iterator
8619	it = mHWData->mSharedFolders.begin();
8620	it != mHWData->mSharedFolders.end();
8621	++it)
8622	{
8623	SharedFolder pSF = it;
8624	AutoCaller autoCaller(pSF);
8625	if (pSF->i_getName() == aName)
8626	{
8627	aSharedFolder = pSF;
8628	rc = S_OK;
8629	break;
8630	}
8631	}
8632
8633	if (aSetError && FAILED(rc))
8634	setError(rc, tr("Could not find a shared folder named '%s'"), aName.c_str());
8635
8636	return rc;
8637	}
8638
8639	/**
8640	* Initializes all machine instance data from the given settings structures
8641	* from XML. The exception is the machine UUID which needs special handling
8642	* depending on the caller's use case, so the caller needs to set that herself.
8643	*
8644	* This gets called in several contexts during machine initialization:
8645	*
8646	* -- When machine XML exists on disk already and needs to be loaded into memory,
8647	* for example, from #i_registeredInit() to load all registered machines on
8648	* VirtualBox startup. In this case, puuidRegistry is NULL because the media
8649	* attached to the machine should be part of some media registry already.
8650	*
8651	* -- During OVF import, when a machine config has been constructed from an
8652	* OVF file. In this case, puuidRegistry is set to the machine UUID to
8653	* ensure that the media listed as attachments in the config (which have
8654	* been imported from the OVF) receive the correct registry ID.
8655	*
8656	* -- During VM cloning.
8657	*
8658	* @param config Machine settings from XML.
8659	* @param puuidRegistry If != NULL, Medium::setRegistryIdIfFirst() gets called with this registry ID
8660	* for each attached medium in the config.
8661	* @return
8662	*/
8663	HRESULT Machine::i_loadMachineDataFromSettings(const settings::MachineConfigFile &config,
8664	const Guid *puuidRegistry)
8665	{
8666	// copy name, description, OS type, teleporter, UTC etc.
8667	mUserData->s = config.machineUserData;
8668
8669	// look up the object by Id to check it is valid
8670	ComObjPtr<GuestOSType> pGuestOSType;
8671	HRESULT rc = mParent->i_findGuestOSType(mUserData->s.strOsType,
8672	pGuestOSType);
8673	if (FAILED(rc)) return rc;
8674	mUserData->s.strOsType = pGuestOSType->i_id();
8675
8676	// stateFile (optional)
8677	if (config.strStateFile.isEmpty())
8678	mSSData->strStateFilePath.setNull();
8679	else
8680	{
8681	Utf8Str stateFilePathFull(config.strStateFile);
8682	int vrc = i_calculateFullPath(stateFilePathFull, stateFilePathFull);
8683	if (RT_FAILURE(vrc))
8684	return setError(E_FAIL,
8685	tr("Invalid saved state file path '%s' (%Rrc)"),
8686	config.strStateFile.c_str(),
8687	vrc);
8688	mSSData->strStateFilePath = stateFilePathFull;
8689	}
8690
8691	// snapshot folder needs special processing so set it again
8692	rc = COMSETTER(SnapshotFolder)(Bstr(config.machineUserData.strSnapshotFolder).raw());
8693	if (FAILED(rc)) return rc;
8694
8695	/* Copy the extra data items (config may or may not be the same as
8696	* mData->pMachineConfigFile) if necessary. When loading the XML files
8697	* from disk they are the same, but not for OVF import. */
8698	if (mData->pMachineConfigFile != &config)
8699	mData->pMachineConfigFile->mapExtraDataItems = config.mapExtraDataItems;
8700
8701	/* currentStateModified (optional, default is true) */
8702	mData->mCurrentStateModified = config.fCurrentStateModified;
8703
8704	mData->mLastStateChange = config.timeLastStateChange;
8705
8706	/*
8707	* note: all mUserData members must be assigned prior this point because
8708	* we need to commit changes in order to let mUserData be shared by all
8709	* snapshot machine instances.
8710	*/
8711	mUserData.commitCopy();
8712
8713	// machine registry, if present (must be loaded before snapshots)
8714	if (config.canHaveOwnMediaRegistry())
8715	{
8716	// determine machine folder
8717	Utf8Str strMachineFolder = i_getSettingsFileFull();
8718	strMachineFolder.stripFilename();
8719	rc = mParent->initMedia(i_getId(), // media registry ID == machine UUID
8720	config.mediaRegistry,
8721	strMachineFolder);
8722	if (FAILED(rc)) return rc;
8723	}
8724
8725	/* Snapshot node (optional) */
8726	size_t cRootSnapshots;
8727	if ((cRootSnapshots = config.llFirstSnapshot.size()))
8728	{
8729	// there must be only one root snapshot
8730	Assert(cRootSnapshots == 1);
8731
8732	const settings::Snapshot &snap = config.llFirstSnapshot.front();
8733
8734	rc = i_loadSnapshot(snap,
8735	config.uuidCurrentSnapshot,
8736	NULL); // no parent == first snapshot
8737	if (FAILED(rc)) return rc;
8738	}
8739
8740	// hardware data
8741	rc = i_loadHardware(puuidRegistry, NULL, config.hardwareMachine, &config.debugging, &config.autostart);
8742	if (FAILED(rc)) return rc;
8743
8744	/*
8745	* NOTE: the assignment below must be the last thing to do,
8746	* otherwise it will be not possible to change the settings
8747	* somewhere in the code above because all setters will be
8748	* blocked by i_checkStateDependency(MutableStateDep).
8749	*/
8750
8751	/* set the machine state to Aborted or Saved when appropriate */
8752	if (config.fAborted)
8753	{
8754	mSSData->strStateFilePath.setNull();
8755
8756	/* no need to use i_setMachineState() during init() */
8757	mData->mMachineState = MachineState_Aborted;
8758	}
8759	else if (!mSSData->strStateFilePath.isEmpty())
8760	{
8761	/* no need to use i_setMachineState() during init() */
8762	mData->mMachineState = MachineState_Saved;
8763	}
8764
8765	// after loading settings, we are no longer different from the XML on disk
8766	mData->flModifications = 0;
8767
8768	return S_OK;
8769	}
8770
8771	/**
8772	* Recursively loads all snapshots starting from the given.
8773	*
8774	* @param data snapshot settings.
8775	* @param aCurSnapshotId Current snapshot ID from the settings file.
8776	* @param aParentSnapshot Parent snapshot.
8777	*/
8778	HRESULT Machine::i_loadSnapshot(const settings::Snapshot &data,
8779	const Guid &aCurSnapshotId,
8780	Snapshot *aParentSnapshot)
8781	{
8782	AssertReturn(!i_isSnapshotMachine(), E_FAIL);
8783	AssertReturn(!i_isSessionMachine(), E_FAIL);
8784
8785	HRESULT rc = S_OK;
8786
8787	Utf8Str strStateFile;
8788	if (!data.strStateFile.isEmpty())
8789	{
8790	/* optional */
8791	strStateFile = data.strStateFile;
8792	int vrc = i_calculateFullPath(strStateFile, strStateFile);
8793	if (RT_FAILURE(vrc))
8794	return setError(E_FAIL,
8795	tr("Invalid saved state file path '%s' (%Rrc)"),
8796	strStateFile.c_str(),
8797	vrc);
8798	}
8799
8800	/* create a snapshot machine object */
8801	ComObjPtr<SnapshotMachine> pSnapshotMachine;
8802	pSnapshotMachine.createObject();
8803	rc = pSnapshotMachine->initFromSettings(this,
8804	data.hardware,
8805	&data.debugging,
8806	&data.autostart,
8807	data.uuid.ref(),
8808	strStateFile);
8809	if (FAILED(rc)) return rc;
8810
8811	/* create a snapshot object */
8812	ComObjPtr<Snapshot> pSnapshot;
8813	pSnapshot.createObject();
8814	/* initialize the snapshot */
8815	rc = pSnapshot->init(mParent, // VirtualBox object
8816	data.uuid,
8817	data.strName,
8818	data.strDescription,
8819	data.timestamp,
8820	pSnapshotMachine,
8821	aParentSnapshot);
8822	if (FAILED(rc)) return rc;
8823
8824	/* memorize the first snapshot if necessary */
8825	if (!mData->mFirstSnapshot)
8826	mData->mFirstSnapshot = pSnapshot;
8827
8828	/* memorize the current snapshot when appropriate */
8829	if ( !mData->mCurrentSnapshot
8830	&& pSnapshot->i_getId() == aCurSnapshotId
8831	)
8832	mData->mCurrentSnapshot = pSnapshot;
8833
8834	// now create the children
8835	for (settings::SnapshotsList::const_iterator
8836	it = data.llChildSnapshots.begin();
8837	it != data.llChildSnapshots.end();
8838	++it)
8839	{
8840	const settings::Snapshot &childData = *it;
8841	// recurse
8842	rc = i_loadSnapshot(childData,
8843	aCurSnapshotId,
8844	pSnapshot); // parent = the one we created above
8845	if (FAILED(rc)) return rc;
8846	}
8847
8848	return rc;
8849	}
8850
8851	/**
8852	* Loads settings into mHWData.
8853	*
8854	* @param puuidRegistry Registry ID.
8855	* @param puuidSnapshot Snapshot ID
8856	* @param data Reference to the hardware settings.
8857	* @param pDbg Pointer to the debugging settings.
8858	* @param pAutostart Pointer to the autostart settings.
8859	*/
8860	HRESULT Machine::i_loadHardware(const Guid *puuidRegistry,
8861	const Guid *puuidSnapshot,
8862	const settings::Hardware &data,
8863	const settings::Debugging *pDbg,
8864	const settings::Autostart *pAutostart)
8865	{
8866	AssertReturn(!i_isSessionMachine(), E_FAIL);
8867
8868	HRESULT rc = S_OK;
8869
8870	try
8871	{
8872	ComObjPtr<GuestOSType> pGuestOSType;
8873	rc = mParent->i_findGuestOSType(Bstr(mUserData->s.strOsType).raw(),
8874	pGuestOSType);
8875	if (FAILED(rc))
8876	return rc;
8877
8878	/* The hardware version attribute (optional). */
8879	mHWData->mHWVersion = data.strVersion;
8880	mHWData->mHardwareUUID = data.uuid;
8881
8882	mHWData->mHWVirtExEnabled = data.fHardwareVirt;
8883	mHWData->mHWVirtExNestedPagingEnabled = data.fNestedPaging;
8884	mHWData->mHWVirtExLargePagesEnabled = data.fLargePages;
8885	mHWData->mHWVirtExVPIDEnabled = data.fVPID;
8886	mHWData->mHWVirtExUXEnabled = data.fUnrestrictedExecution;
8887	mHWData->mHWVirtExForceEnabled = data.fHardwareVirtForce;
8888	mHWData->mPAEEnabled = data.fPAE;
8889	mHWData->mLongMode = data.enmLongMode;
8890	mHWData->mTripleFaultReset = data.fTripleFaultReset;
8891	mHWData->mAPIC = data.fAPIC;
8892	mHWData->mX2APIC = data.fX2APIC;
8893	mHWData->mCPUCount = data.cCPUs;
8894	mHWData->mCPUHotPlugEnabled = data.fCpuHotPlug;
8895	mHWData->mCpuExecutionCap = data.ulCpuExecutionCap;
8896	mHWData->mCpuIdPortabilityLevel = data.uCpuIdPortabilityLevel;
8897	mHWData->mCpuProfile = data.strCpuProfile;
8898
8899	// cpu
8900	if (mHWData->mCPUHotPlugEnabled)
8901	{
8902	for (settings::CpuList::const_iterator
8903	it = data.llCpus.begin();
8904	it != data.llCpus.end();
8905	++it)
8906	{
8907	const settings::Cpu &cpu = *it;
8908
8909	mHWData->mCPUAttached[cpu.ulId] = true;
8910	}
8911	}
8912
8913	// cpuid leafs
8914	for (settings::CpuIdLeafsList::const_iterator
8915	it = data.llCpuIdLeafs.begin();
8916	it != data.llCpuIdLeafs.end();
8917	++it)
8918	{
8919	const settings::CpuIdLeaf &rLeaf= *it;
8920	if ( rLeaf.idx < UINT32_C(0x20)
8921	\|\| rLeaf.idx - UINT32_C(0x80000000) < UINT32_C(0x20)
8922	\|\| rLeaf.idx - UINT32_C(0xc0000000) < UINT32_C(0x10) )
8923	mHWData->mCpuIdLeafList.push_back(rLeaf);
8924	/* else: just ignore */
8925	}
8926
8927	mHWData->mMemorySize = data.ulMemorySizeMB;
8928	mHWData->mPageFusionEnabled = data.fPageFusionEnabled;
8929
8930	// boot order
8931	for (unsigned i = 0; i < RT_ELEMENTS(mHWData->mBootOrder); ++i)
8932	{
8933	settings::BootOrderMap::const_iterator it = data.mapBootOrder.find(i);
8934	if (it == data.mapBootOrder.end())
8935	mHWData->mBootOrder[i] = DeviceType_Null;
8936	else
8937	mHWData->mBootOrder[i] = it->second;
8938	}
8939
8940	mHWData->mGraphicsControllerType = data.graphicsControllerType;
8941	mHWData->mVRAMSize = data.ulVRAMSizeMB;
8942	mHWData->mMonitorCount = data.cMonitors;
8943	mHWData->mAccelerate3DEnabled = data.fAccelerate3D;
8944	mHWData->mAccelerate2DVideoEnabled = data.fAccelerate2DVideo;
8945	mHWData->mVideoCaptureWidth = data.ulVideoCaptureHorzRes;
8946	mHWData->mVideoCaptureHeight = data.ulVideoCaptureVertRes;
8947	mHWData->mVideoCaptureEnabled = data.fVideoCaptureEnabled;
8948	for (unsigned i = 0; i < RT_ELEMENTS(mHWData->maVideoCaptureScreens); ++i)
8949	mHWData->maVideoCaptureScreens[i] = ASMBitTest(&data.u64VideoCaptureScreens, i);
8950	AssertCompile(RT_ELEMENTS(mHWData->maVideoCaptureScreens) == sizeof(data.u64VideoCaptureScreens) * 8);
8951	mHWData->mVideoCaptureRate = data.ulVideoCaptureRate;
8952	mHWData->mVideoCaptureFPS = data.ulVideoCaptureFPS;
8953	if (!data.strVideoCaptureFile.isEmpty())
8954	i_calculateFullPath(data.strVideoCaptureFile, mHWData->mVideoCaptureFile);
8955	else
8956	mHWData->mVideoCaptureFile.setNull();
8957	mHWData->mVideoCaptureOptions = data.strVideoCaptureOptions;
8958	mHWData->mFirmwareType = data.firmwareType;
8959	mHWData->mPointingHIDType = data.pointingHIDType;
8960	mHWData->mKeyboardHIDType = data.keyboardHIDType;
8961	mHWData->mChipsetType = data.chipsetType;
8962	mHWData->mParavirtProvider = data.paravirtProvider;
8963	mHWData->mParavirtDebug = data.strParavirtDebug;
8964	mHWData->mEmulatedUSBCardReaderEnabled = data.fEmulatedUSBCardReader;
8965	mHWData->mHPETEnabled = data.fHPETEnabled;
8966
8967	/* VRDEServer */
8968	rc = mVRDEServer->i_loadSettings(data.vrdeSettings);
8969	if (FAILED(rc)) return rc;
8970
8971	/* BIOS */
8972	rc = mBIOSSettings->i_loadSettings(data.biosSettings);
8973	if (FAILED(rc)) return rc;
8974
8975	// Bandwidth control (must come before network adapters)
8976	rc = mBandwidthControl->i_loadSettings(data.ioSettings);
8977	if (FAILED(rc)) return rc;
8978
8979	/* Shared folders */
8980	for (settings::USBControllerList::const_iterator
8981	it = data.usbSettings.llUSBControllers.begin();
8982	it != data.usbSettings.llUSBControllers.end();
8983	++it)
8984	{
8985	const settings::USBController &settingsCtrl = *it;
8986	ComObjPtr<USBController> newCtrl;
8987
8988	newCtrl.createObject();
8989	newCtrl->init(this, settingsCtrl.strName, settingsCtrl.enmType);
8990	mUSBControllers->push_back(newCtrl);
8991	}
8992
8993	/* USB device filters */
8994	rc = mUSBDeviceFilters->i_loadSettings(data.usbSettings);
8995	if (FAILED(rc)) return rc;
8996
8997	// network adapters (establish array size first and apply defaults, to
8998	// ensure reading the same settings as we saved, since the list skips
8999	// adapters having defaults)
9000	size_t newCount = Global::getMaxNetworkAdapters(mHWData->mChipsetType);
9001	size_t oldCount = mNetworkAdapters.size();
9002	if (newCount > oldCount)
9003	{
9004	mNetworkAdapters.resize(newCount);
9005	for (size_t slot = oldCount; slot < mNetworkAdapters.size(); ++slot)
9006	{
9007	unconst(mNetworkAdapters[slot]).createObject();
9008	mNetworkAdapters[slot]->init(this, (ULONG)slot);
9009	}
9010	}
9011	else if (newCount < oldCount)
9012	mNetworkAdapters.resize(newCount);
9013	for (unsigned i = 0; i < mNetworkAdapters.size(); i++)
9014	mNetworkAdapters[i]->i_applyDefaults(pGuestOSType);
9015	for (settings::NetworkAdaptersList::const_iterator
9016	it = data.llNetworkAdapters.begin();
9017	it != data.llNetworkAdapters.end();
9018	++it)
9019	{
9020	const settings::NetworkAdapter &nic = *it;
9021
9022	/* slot uniqueness is guaranteed by XML Schema */
9023	AssertBreak(nic.ulSlot < mNetworkAdapters.size());
9024	rc = mNetworkAdapters[nic.ulSlot]->i_loadSettings(mBandwidthControl, nic);
9025	if (FAILED(rc)) return rc;
9026	}
9027
9028	// serial ports (establish defaults first, to ensure reading the same
9029	// settings as we saved, since the list skips ports having defaults)
9030	for (unsigned i = 0; i < RT_ELEMENTS(mSerialPorts); i++)
9031	mSerialPorts[i]->i_applyDefaults(pGuestOSType);
9032	for (settings::SerialPortsList::const_iterator
9033	it = data.llSerialPorts.begin();
9034	it != data.llSerialPorts.end();
9035	++it)
9036	{
9037	const settings::SerialPort &s = *it;
9038
9039	AssertBreak(s.ulSlot < RT_ELEMENTS(mSerialPorts));
9040	rc = mSerialPorts[s.ulSlot]->i_loadSettings(s);
9041	if (FAILED(rc)) return rc;
9042	}
9043
9044	// parallel ports (establish defaults first, to ensure reading the same
9045	// settings as we saved, since the list skips ports having defaults)
9046	for (unsigned i = 0; i < RT_ELEMENTS(mParallelPorts); i++)
9047	mParallelPorts[i]->i_applyDefaults();
9048	for (settings::ParallelPortsList::const_iterator
9049	it = data.llParallelPorts.begin();
9050	it != data.llParallelPorts.end();
9051	++it)
9052	{
9053	const settings::ParallelPort &p = *it;
9054
9055	AssertBreak(p.ulSlot < RT_ELEMENTS(mParallelPorts));
9056	rc = mParallelPorts[p.ulSlot]->i_loadSettings(p);
9057	if (FAILED(rc)) return rc;
9058	}
9059
9060	/* AudioAdapter */
9061	rc = mAudioAdapter->i_loadSettings(data.audioAdapter);
9062	if (FAILED(rc)) return rc;
9063
9064	/* storage controllers */
9065	rc = i_loadStorageControllers(data.storage,
9066	puuidRegistry,
9067	puuidSnapshot);
9068	if (FAILED(rc)) return rc;
9069
9070	/* Shared folders */
9071	for (settings::SharedFoldersList::const_iterator
9072	it = data.llSharedFolders.begin();
9073	it != data.llSharedFolders.end();
9074	++it)
9075	{
9076	const settings::SharedFolder &sf = *it;
9077
9078	ComObjPtr<SharedFolder> sharedFolder;
9079	/* Check for double entries. Not allowed! */
9080	rc = i_findSharedFolder(sf.strName, sharedFolder, false /* aSetError */);
9081	if (SUCCEEDED(rc))
9082	return setError(VBOX_E_OBJECT_IN_USE,
9083	tr("Shared folder named '%s' already exists"),
9084	sf.strName.c_str());
9085
9086	/* Create the new shared folder. Don't break on error. This will be
9087	* reported when the machine starts. */
9088	sharedFolder.createObject();
9089	rc = sharedFolder->init(i_getMachine(),
9090	sf.strName,
9091	sf.strHostPath,
9092	RT_BOOL(sf.fWritable),
9093	RT_BOOL(sf.fAutoMount),
9094	false /* fFailOnError */);
9095	if (FAILED(rc)) return rc;
9096	mHWData->mSharedFolders.push_back(sharedFolder);
9097	}
9098
9099	// Clipboard
9100	mHWData->mClipboardMode = data.clipboardMode;
9101
9102	// drag'n'drop
9103	mHWData->mDnDMode = data.dndMode;
9104
9105	// guest settings
9106	mHWData->mMemoryBalloonSize = data.ulMemoryBalloonSize;
9107
9108	// IO settings
9109	mHWData->mIOCacheEnabled = data.ioSettings.fIOCacheEnabled;
9110	mHWData->mIOCacheSize = data.ioSettings.ulIOCacheSize;
9111
9112	// Host PCI devices
9113	for (settings::HostPCIDeviceAttachmentList::const_iterator
9114	it = data.pciAttachments.begin();
9115	it != data.pciAttachments.end();
9116	++it)
9117	{
9118	const settings::HostPCIDeviceAttachment &hpda = *it;
9119	ComObjPtr<PCIDeviceAttachment> pda;
9120
9121	pda.createObject();
9122	pda->i_loadSettings(this, hpda);
9123	mHWData->mPCIDeviceAssignments.push_back(pda);
9124	}
9125
9126	/*
9127	* (The following isn't really real hardware, but it lives in HWData
9128	* for reasons of convenience.)
9129	*/
9130
9131	#ifdef VBOX_WITH_GUEST_PROPS
9132	/* Guest properties (optional) */
9133
9134	/* Only load transient guest properties for configs which have saved
9135	* state, because there shouldn't be any for powered off VMs. The same
9136	* logic applies for snapshots, as offline snapshots shouldn't have
9137	* any such properties. They confuse the code in various places.
9138	* Note: can't rely on the machine state, as it isn't set yet. */
9139	bool fSkipTransientGuestProperties = mSSData->strStateFilePath.isEmpty();
9140	/* apologies for the hacky unconst() usage, but this needs hacking
9141	* actually inconsistent settings into consistency, otherwise there
9142	* will be some corner cases where the inconsistency survives
9143	* surprisingly long without getting fixed, especially for snapshots
9144	* as there are no config changes. */
9145	settings::GuestPropertiesList &llGuestProperties = unconst(data.llGuestProperties);
9146	for (settings::GuestPropertiesList::iterator
9147	it = llGuestProperties.begin();
9148	it != llGuestProperties.end();
9149	/nothing/)
9150	{
9151	const settings::GuestProperty &prop = *it;
9152	uint32_t fFlags = GUEST_PROP_F_NILFLAG;
9153	GuestPropValidateFlags(prop.strFlags.c_str(), &fFlags);
9154	if ( fSkipTransientGuestProperties
9155	&& ( fFlags & GUEST_PROP_F_TRANSIENT
9156	\|\| fFlags & GUEST_PROP_F_TRANSRESET))
9157	{
9158	it = llGuestProperties.erase(it);
9159	continue;
9160	}
9161	HWData::GuestProperty property = { prop.strValue, (LONG64) prop.timestamp, fFlags };
9162	mHWData->mGuestProperties[prop.strName] = property;
9163	++it;
9164	}
9165	#endif /* VBOX_WITH_GUEST_PROPS defined */
9166
9167	rc = i_loadDebugging(pDbg);
9168	if (FAILED(rc))
9169	return rc;
9170
9171	mHWData->mAutostart = *pAutostart;
9172
9173	/* default frontend */
9174	mHWData->mDefaultFrontend = data.strDefaultFrontend;
9175	}
9176	catch (std::bad_alloc &)
9177	{
9178	return E_OUTOFMEMORY;
9179	}
9180
9181	AssertComRC(rc);
9182	return rc;
9183	}
9184
9185	/**
9186	* Called from i_loadHardware() to load the debugging settings of the
9187	* machine.
9188	*
9189	* @param pDbg Pointer to the settings.
9190	*/
9191	HRESULT Machine::i_loadDebugging(const settings::Debugging *pDbg)
9192	{
9193	mHWData->mDebugging = *pDbg;
9194	/* no more processing currently required, this will probably change. */
9195	return S_OK;
9196	}
9197
9198	/**
9199	* Called from i_loadMachineDataFromSettings() for the storage controller data, including media.
9200	*
9201	* @param data storage settings.
9202	* @param puuidRegistry media registry ID to set media to or NULL;
9203	* see Machine::i_loadMachineDataFromSettings()
9204	* @param puuidSnapshot snapshot ID
9205	* @return
9206	*/
9207	HRESULT Machine::i_loadStorageControllers(const settings::Storage &data,
9208	const Guid *puuidRegistry,
9209	const Guid *puuidSnapshot)
9210	{
9211	AssertReturn(!i_isSessionMachine(), E_FAIL);
9212
9213	HRESULT rc = S_OK;
9214
9215	for (settings::StorageControllersList::const_iterator
9216	it = data.llStorageControllers.begin();
9217	it != data.llStorageControllers.end();
9218	++it)
9219	{
9220	const settings::StorageController &ctlData = *it;
9221
9222	ComObjPtr<StorageController> pCtl;
9223	/* Try to find one with the name first. */
9224	rc = i_getStorageControllerByName(ctlData.strName, pCtl, false /* aSetError */);
9225	if (SUCCEEDED(rc))
9226	return setError(VBOX_E_OBJECT_IN_USE,
9227	tr("Storage controller named '%s' already exists"),
9228	ctlData.strName.c_str());
9229
9230	pCtl.createObject();
9231	rc = pCtl->init(this,
9232	ctlData.strName,
9233	ctlData.storageBus,
9234	ctlData.ulInstance,
9235	ctlData.fBootable);
9236	if (FAILED(rc)) return rc;
9237
9238	mStorageControllers->push_back(pCtl);
9239
9240	rc = pCtl->COMSETTER(ControllerType)(ctlData.controllerType);
9241	if (FAILED(rc)) return rc;
9242
9243	rc = pCtl->COMSETTER(PortCount)(ctlData.ulPortCount);
9244	if (FAILED(rc)) return rc;
9245
9246	rc = pCtl->COMSETTER(UseHostIOCache)(ctlData.fUseHostIOCache);
9247	if (FAILED(rc)) return rc;
9248
9249	/* Load the attached devices now. */
9250	rc = i_loadStorageDevices(pCtl,
9251	ctlData,
9252	puuidRegistry,
9253	puuidSnapshot);
9254	if (FAILED(rc)) return rc;
9255	}
9256
9257	return S_OK;
9258	}
9259
9260	/**
9261	* Called from i_loadStorageControllers for a controller's devices.
9262	*
9263	* @param aStorageController
9264	* @param data
9265	* @param puuidRegistry media registry ID to set media to or NULL; see
9266	* Machine::i_loadMachineDataFromSettings()
9267	* @param puuidSnapshot pointer to the snapshot ID if this is a snapshot machine
9268	* @return
9269	*/
9270	HRESULT Machine::i_loadStorageDevices(StorageController *aStorageController,
9271	const settings::StorageController &data,
9272	const Guid *puuidRegistry,
9273	const Guid *puuidSnapshot)
9274	{
9275	HRESULT rc = S_OK;
9276
9277	/* paranoia: detect duplicate attachments */
9278	for (settings::AttachedDevicesList::const_iterator
9279	it = data.llAttachedDevices.begin();
9280	it != data.llAttachedDevices.end();
9281	++it)
9282	{
9283	const settings::AttachedDevice &ad = *it;
9284
9285	for (settings::AttachedDevicesList::const_iterator it2 = it;
9286	it2 != data.llAttachedDevices.end();
9287	++it2)
9288	{
9289	if (it == it2)
9290	continue;
9291
9292	const settings::AttachedDevice &ad2 = *it2;
9293
9294	if ( ad.lPort == ad2.lPort
9295	&& ad.lDevice == ad2.lDevice)
9296	{
9297	return setError(E_FAIL,
9298	tr("Duplicate attachments for storage controller '%s', port %d, device %d of the virtual machine '%s'"),
9299	aStorageController->i_getName().c_str(),
9300	ad.lPort,
9301	ad.lDevice,
9302	mUserData->s.strName.c_str());
9303	}
9304	}
9305	}
9306
9307	for (settings::AttachedDevicesList::const_iterator
9308	it = data.llAttachedDevices.begin();
9309	it != data.llAttachedDevices.end();
9310	++it)
9311	{
9312	const settings::AttachedDevice &dev = *it;
9313	ComObjPtr<Medium> medium;
9314
9315	switch (dev.deviceType)
9316	{
9317	case DeviceType_Floppy:
9318	case DeviceType_DVD:
9319	if (dev.strHostDriveSrc.isNotEmpty())
9320	rc = mParent->i_host()->i_findHostDriveByName(dev.deviceType, dev.strHostDriveSrc,
9321	false /* fRefresh */, medium);
9322	else
9323	rc = mParent->i_findRemoveableMedium(dev.deviceType,
9324	dev.uuid,
9325	false /* fRefresh */,
9326	false /* aSetError */,
9327	medium);
9328	if (rc == VBOX_E_OBJECT_NOT_FOUND)
9329	// This is not an error. The host drive or UUID might have vanished, so just go
9330	// ahead without this removeable medium attachment
9331	rc = S_OK;
9332	break;
9333
9334	case DeviceType_HardDisk:
9335	{
9336	/* find a hard disk by UUID */
9337	rc = mParent->i_findHardDiskById(dev.uuid, true /* aDoSetError */, &medium);
9338	if (FAILED(rc))
9339	{
9340	if (i_isSnapshotMachine())
9341	{
9342	// wrap another error message around the "cannot find hard disk" set by findHardDisk
9343	// so the user knows that the bad disk is in a snapshot somewhere
9344	com::ErrorInfo info;
9345	return setError(E_FAIL,
9346	tr("A differencing image of snapshot {%RTuuid} could not be found. %ls"),
9347	puuidSnapshot->raw(),
9348	info.getText().raw());
9349	}
9350	else
9351	return rc;
9352	}
9353
9354	AutoWriteLock hdLock(medium COMMA_LOCKVAL_SRC_POS);
9355
9356	if (medium->i_getType() == MediumType_Immutable)
9357	{
9358	if (i_isSnapshotMachine())
9359	return setError(E_FAIL,
9360	tr("Immutable hard disk '%s' with UUID {%RTuuid} cannot be directly attached to snapshot with UUID {%RTuuid} "
9361	"of the virtual machine '%s' ('%s')"),
9362	medium->i_getLocationFull().c_str(),
9363	dev.uuid.raw(),
9364	puuidSnapshot->raw(),
9365	mUserData->s.strName.c_str(),
9366	mData->m_strConfigFileFull.c_str());
9367
9368	return setError(E_FAIL,
9369	tr("Immutable hard disk '%s' with UUID {%RTuuid} cannot be directly attached to the virtual machine '%s' ('%s')"),
9370	medium->i_getLocationFull().c_str(),
9371	dev.uuid.raw(),
9372	mUserData->s.strName.c_str(),
9373	mData->m_strConfigFileFull.c_str());
9374	}
9375
9376	if (medium->i_getType() == MediumType_MultiAttach)
9377	{
9378	if (i_isSnapshotMachine())
9379	return setError(E_FAIL,
9380	tr("Multi-attach hard disk '%s' with UUID {%RTuuid} cannot be directly attached to snapshot with UUID {%RTuuid} "
9381	"of the virtual machine '%s' ('%s')"),
9382	medium->i_getLocationFull().c_str(),
9383	dev.uuid.raw(),
9384	puuidSnapshot->raw(),
9385	mUserData->s.strName.c_str(),
9386	mData->m_strConfigFileFull.c_str());
9387
9388	return setError(E_FAIL,
9389	tr("Multi-attach hard disk '%s' with UUID {%RTuuid} cannot be directly attached to the virtual machine '%s' ('%s')"),
9390	medium->i_getLocationFull().c_str(),
9391	dev.uuid.raw(),
9392	mUserData->s.strName.c_str(),
9393	mData->m_strConfigFileFull.c_str());
9394	}
9395
9396	if ( !i_isSnapshotMachine()
9397	&& medium->i_getChildren().size() != 0
9398	)
9399	return setError(E_FAIL,
9400	tr("Hard disk '%s' with UUID {%RTuuid} cannot be directly attached to the virtual machine '%s' ('%s') "
9401	"because it has %d differencing child hard disks"),
9402	medium->i_getLocationFull().c_str(),
9403	dev.uuid.raw(),
9404	mUserData->s.strName.c_str(),
9405	mData->m_strConfigFileFull.c_str(),
9406	medium->i_getChildren().size());
9407
9408	if (i_findAttachment(*mMediumAttachments.data(),
9409	medium))
9410	return setError(E_FAIL,
9411	tr("Hard disk '%s' with UUID {%RTuuid} is already attached to the virtual machine '%s' ('%s')"),
9412	medium->i_getLocationFull().c_str(),
9413	dev.uuid.raw(),
9414	mUserData->s.strName.c_str(),
9415	mData->m_strConfigFileFull.c_str());
9416
9417	break;
9418	}
9419
9420	default:
9421	return setError(E_FAIL,
9422	tr("Device '%s' with unknown type is attached to the virtual machine '%s' ('%s')"),
9423	medium->i_getLocationFull().c_str(),
9424	mUserData->s.strName.c_str(),
9425	mData->m_strConfigFileFull.c_str());
9426	}
9427
9428	if (FAILED(rc))
9429	break;
9430
9431	/* Bandwidth groups are loaded at this point. */
9432	ComObjPtr<BandwidthGroup> pBwGroup;
9433
9434	if (!dev.strBwGroup.isEmpty())
9435	{
9436	rc = mBandwidthControl->i_getBandwidthGroupByName(dev.strBwGroup, pBwGroup, false /* aSetError */);
9437	if (FAILED(rc))
9438	return setError(E_FAIL,
9439	tr("Device '%s' with unknown bandwidth group '%s' is attached to the virtual machine '%s' ('%s')"),
9440	medium->i_getLocationFull().c_str(),
9441	dev.strBwGroup.c_str(),
9442	mUserData->s.strName.c_str(),
9443	mData->m_strConfigFileFull.c_str());
9444	pBwGroup->i_reference();
9445	}
9446
9447	const Utf8Str controllerName = aStorageController->i_getName();
9448	ComObjPtr<MediumAttachment> pAttachment;
9449	pAttachment.createObject();
9450	rc = pAttachment->init(this,
9451	medium,
9452	controllerName,
9453	dev.lPort,
9454	dev.lDevice,
9455	dev.deviceType,
9456	false,
9457	dev.fPassThrough,
9458	dev.fTempEject,
9459	dev.fNonRotational,
9460	dev.fDiscard,
9461	dev.fHotPluggable,
9462	pBwGroup.isNull() ? Utf8Str::Empty : pBwGroup->i_getName());
9463	if (FAILED(rc)) break;
9464
9465	/* associate the medium with this machine and snapshot */
9466	if (!medium.isNull())
9467	{
9468	AutoCaller medCaller(medium);
9469	if (FAILED(medCaller.rc())) return medCaller.rc();
9470	AutoWriteLock mlock(medium COMMA_LOCKVAL_SRC_POS);
9471
9472	if (i_isSnapshotMachine())
9473	rc = medium->i_addBackReference(mData->mUuid, *puuidSnapshot);
9474	else
9475	rc = medium->i_addBackReference(mData->mUuid);
9476	/* If the medium->addBackReference fails it sets an appropriate
9477	* error message, so no need to do any guesswork here. */
9478
9479	if (puuidRegistry)
9480	// caller wants registry ID to be set on all attached media (OVF import case)
9481	medium->i_addRegistry(*puuidRegistry);
9482	}
9483
9484	if (FAILED(rc))
9485	break;
9486
9487	/* back up mMediumAttachments to let registeredInit() properly rollback
9488	* on failure (= limited accessibility) */
9489	i_setModified(IsModified_Storage);
9490	mMediumAttachments.backup();
9491	mMediumAttachments->push_back(pAttachment);
9492	}
9493
9494	return rc;
9495	}
9496
9497	/**
9498	* Returns the snapshot with the given UUID or fails of no such snapshot exists.
9499	*
9500	* @param aId snapshot UUID to find (empty UUID refers the first snapshot)
9501	* @param aSnapshot where to return the found snapshot
9502	* @param aSetError true to set extended error info on failure
9503	*/
9504	HRESULT Machine::i_findSnapshotById(const Guid &aId,
9505	ComObjPtr<Snapshot> &aSnapshot,
9506	bool aSetError /* = false */)
9507	{
9508	AutoReadLock chlock(this COMMA_LOCKVAL_SRC_POS);
9509
9510	if (!mData->mFirstSnapshot)
9511	{
9512	if (aSetError)
9513	return setError(E_FAIL, tr("This machine does not have any snapshots"));
9514	return E_FAIL;
9515	}
9516
9517	if (aId.isZero())
9518	aSnapshot = mData->mFirstSnapshot;
9519	else
9520	aSnapshot = mData->mFirstSnapshot->i_findChildOrSelf(aId.ref());
9521
9522	if (!aSnapshot)
9523	{
9524	if (aSetError)
9525	return setError(E_FAIL,
9526	tr("Could not find a snapshot with UUID {%s}"),
9527	aId.toString().c_str());
9528	return E_FAIL;
9529	}
9530
9531	return S_OK;
9532	}
9533
9534	/**
9535	* Returns the snapshot with the given name or fails of no such snapshot.
9536	*
9537	* @param strName snapshot name to find
9538	* @param aSnapshot where to return the found snapshot
9539	* @param aSetError true to set extended error info on failure
9540	*/
9541	HRESULT Machine::i_findSnapshotByName(const Utf8Str &strName,
9542	ComObjPtr<Snapshot> &aSnapshot,
9543	bool aSetError /* = false */)
9544	{
9545	AssertReturn(!strName.isEmpty(), E_INVALIDARG);
9546
9547	AutoReadLock chlock(this COMMA_LOCKVAL_SRC_POS);
9548
9549	if (!mData->mFirstSnapshot)
9550	{
9551	if (aSetError)
9552	return setError(VBOX_E_OBJECT_NOT_FOUND,
9553	tr("This machine does not have any snapshots"));
9554	return VBOX_E_OBJECT_NOT_FOUND;
9555	}
9556
9557	aSnapshot = mData->mFirstSnapshot->i_findChildOrSelf(strName);
9558
9559	if (!aSnapshot)
9560	{
9561	if (aSetError)
9562	return setError(VBOX_E_OBJECT_NOT_FOUND,
9563	tr("Could not find a snapshot named '%s'"), strName.c_str());
9564	return VBOX_E_OBJECT_NOT_FOUND;
9565	}
9566
9567	return S_OK;
9568	}
9569
9570	/**
9571	* Returns a storage controller object with the given name.
9572	*
9573	* @param aName storage controller name to find
9574	* @param aStorageController where to return the found storage controller
9575	* @param aSetError true to set extended error info on failure
9576	*/
9577	HRESULT Machine::i_getStorageControllerByName(const Utf8Str &aName,
9578	ComObjPtr<StorageController> &aStorageController,
9579	bool aSetError /* = false */)
9580	{
9581	AssertReturn(!aName.isEmpty(), E_INVALIDARG);
9582
9583	for (StorageControllerList::const_iterator
9584	it = mStorageControllers->begin();
9585	it != mStorageControllers->end();
9586	++it)
9587	{
9588	if ((*it)->i_getName() == aName)
9589	{
9590	aStorageController = (*it);
9591	return S_OK;
9592	}
9593	}
9594
9595	if (aSetError)
9596	return setError(VBOX_E_OBJECT_NOT_FOUND,
9597	tr("Could not find a storage controller named '%s'"),
9598	aName.c_str());
9599	return VBOX_E_OBJECT_NOT_FOUND;
9600	}
9601
9602	/**
9603	* Returns a USB controller object with the given name.
9604	*
9605	* @param aName USB controller name to find
9606	* @param aUSBController where to return the found USB controller
9607	* @param aSetError true to set extended error info on failure
9608	*/
9609	HRESULT Machine::i_getUSBControllerByName(const Utf8Str &aName,
9610	ComObjPtr<USBController> &aUSBController,
9611	bool aSetError /* = false */)
9612	{
9613	AssertReturn(!aName.isEmpty(), E_INVALIDARG);
9614
9615	for (USBControllerList::const_iterator
9616	it = mUSBControllers->begin();
9617	it != mUSBControllers->end();
9618	++it)
9619	{
9620	if ((*it)->i_getName() == aName)
9621	{
9622	aUSBController = (*it);
9623	return S_OK;
9624	}
9625	}
9626
9627	if (aSetError)
9628	return setError(VBOX_E_OBJECT_NOT_FOUND,
9629	tr("Could not find a storage controller named '%s'"),
9630	aName.c_str());
9631	return VBOX_E_OBJECT_NOT_FOUND;
9632	}
9633
9634	/**
9635	* Returns the number of USB controller instance of the given type.
9636	*
9637	* @param enmType USB controller type.
9638	*/
9639	ULONG Machine::i_getUSBControllerCountByType(USBControllerType_T enmType)
9640	{
9641	ULONG cCtrls = 0;
9642
9643	for (USBControllerList::const_iterator
9644	it = mUSBControllers->begin();
9645	it != mUSBControllers->end();
9646	++it)
9647	{
9648	if ((*it)->i_getControllerType() == enmType)
9649	cCtrls++;
9650	}
9651
9652	return cCtrls;
9653	}
9654
9655	HRESULT Machine::i_getMediumAttachmentsOfController(const Utf8Str &aName,
9656	MediumAttachmentList &atts)
9657	{
9658	AutoCaller autoCaller(this);
9659	if (FAILED(autoCaller.rc())) return autoCaller.rc();
9660
9661	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
9662
9663	for (MediumAttachmentList::const_iterator
9664	it = mMediumAttachments->begin();
9665	it != mMediumAttachments->end();
9666	++it)
9667	{
9668	const ComObjPtr<MediumAttachment> &pAtt = *it;
9669	// should never happen, but deal with NULL pointers in the list.
9670	AssertContinue(!pAtt.isNull());
9671
9672	// getControllerName() needs caller+read lock
9673	AutoCaller autoAttCaller(pAtt);
9674	if (FAILED(autoAttCaller.rc()))
9675	{
9676	atts.clear();
9677	return autoAttCaller.rc();
9678	}
9679	AutoReadLock attLock(pAtt COMMA_LOCKVAL_SRC_POS);
9680
9681	if (pAtt->i_getControllerName() == aName)
9682	atts.push_back(pAtt);
9683	}
9684
9685	return S_OK;
9686	}
9687
9688
9689	/**
9690	* Helper for #i_saveSettings. Cares about renaming the settings directory and
9691	* file if the machine name was changed and about creating a new settings file
9692	* if this is a new machine.
9693	*
9694	* @note Must be never called directly but only from #saveSettings().
9695	*/
9696	HRESULT Machine::i_prepareSaveSettings(bool *pfNeedsGlobalSaveSettings)
9697	{
9698	AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
9699
9700	HRESULT rc = S_OK;
9701
9702	bool fSettingsFileIsNew = !mData->pMachineConfigFile->fileExists();
9703
9704	/// @todo need to handle primary group change, too
9705
9706	/* attempt to rename the settings file if machine name is changed */
9707	if ( mUserData->s.fNameSync
9708	&& mUserData.isBackedUp()
9709	&& ( mUserData.backedUpData()->s.strName != mUserData->s.strName
9710	\|\| mUserData.backedUpData()->s.llGroups.front() != mUserData->s.llGroups.front())
9711	)
9712	{
9713	bool dirRenamed = false;
9714	bool fileRenamed = false;
9715
9716	Utf8Str configFile, newConfigFile;
9717	Utf8Str configFilePrev, newConfigFilePrev;
9718	Utf8Str configDir, newConfigDir;
9719
9720	do
9721	{
9722	int vrc = VINF_SUCCESS;
9723
9724	Utf8Str name = mUserData.backedUpData()->s.strName;
9725	Utf8Str newName = mUserData->s.strName;
9726	Utf8Str group = mUserData.backedUpData()->s.llGroups.front();
9727	if (group == "/")
9728	group.setNull();
9729	Utf8Str newGroup = mUserData->s.llGroups.front();
9730	if (newGroup == "/")
9731	newGroup.setNull();
9732
9733	configFile = mData->m_strConfigFileFull;
9734
9735	/* first, rename the directory if it matches the group and machine name */
9736	Utf8Str groupPlusName = Utf8StrFmt("%s%c%s",
9737	group.c_str(), RTPATH_DELIMITER, name.c_str());
9738	/** @todo hack, make somehow use of ComposeMachineFilename */
9739	if (mUserData->s.fDirectoryIncludesUUID)
9740	groupPlusName += Utf8StrFmt(" (%RTuuid)", mData->mUuid.raw());
9741	Utf8Str newGroupPlusName = Utf8StrFmt("%s%c%s",
9742	newGroup.c_str(), RTPATH_DELIMITER, newName.c_str());
9743	/** @todo hack, make somehow use of ComposeMachineFilename */
9744	if (mUserData->s.fDirectoryIncludesUUID)
9745	newGroupPlusName += Utf8StrFmt(" (%RTuuid)", mData->mUuid.raw());
9746	configDir = configFile;
9747	configDir.stripFilename();
9748	newConfigDir = configDir;
9749	if ( configDir.length() >= groupPlusName.length()
9750	&& !RTPathCompare(configDir.substr(configDir.length() - groupPlusName.length(), groupPlusName.length()).c_str(),
9751	groupPlusName.c_str()))
9752	{
9753	newConfigDir = newConfigDir.substr(0, configDir.length() - groupPlusName.length());
9754	Utf8Str newConfigBaseDir(newConfigDir);
9755	newConfigDir.append(newGroupPlusName);
9756	/* consistency: use \ if appropriate on the platform */
9757	RTPathChangeToDosSlashes(newConfigDir.mutableRaw(), false);
9758	/* new dir and old dir cannot be equal here because of 'if'
9759	* above and because name != newName */
9760	Assert(configDir != newConfigDir);
9761	if (!fSettingsFileIsNew)
9762	{
9763	/* perform real rename only if the machine is not new */
9764	vrc = RTPathRename(configDir.c_str(), newConfigDir.c_str(), 0);
9765	if ( vrc == VERR_FILE_NOT_FOUND
9766	\|\| vrc == VERR_PATH_NOT_FOUND)
9767	{
9768	/* create the parent directory, then retry renaming */
9769	Utf8Str parent(newConfigDir);
9770	parent.stripFilename();
9771	(void)RTDirCreateFullPath(parent.c_str(), 0700);
9772	vrc = RTPathRename(configDir.c_str(), newConfigDir.c_str(), 0);
9773	}
9774	if (RT_FAILURE(vrc))
9775	{
9776	rc = setError(E_FAIL,
9777	tr("Could not rename the directory '%s' to '%s' to save the settings file (%Rrc)"),
9778	configDir.c_str(),
9779	newConfigDir.c_str(),
9780	vrc);
9781	break;
9782	}
9783	/* delete subdirectories which are no longer needed */
9784	Utf8Str dir(configDir);
9785	dir.stripFilename();
9786	while (dir != newConfigBaseDir && dir != ".")
9787	{
9788	vrc = RTDirRemove(dir.c_str());
9789	if (RT_FAILURE(vrc))
9790	break;
9791	dir.stripFilename();
9792	}
9793	dirRenamed = true;
9794	}
9795	}
9796
9797	newConfigFile = Utf8StrFmt("%s%c%s.vbox",
9798	newConfigDir.c_str(), RTPATH_DELIMITER, newName.c_str());
9799
9800	/* then try to rename the settings file itself */
9801	if (newConfigFile != configFile)
9802	{
9803	/* get the path to old settings file in renamed directory */
9804	configFile = Utf8StrFmt("%s%c%s",
9805	newConfigDir.c_str(),
9806	RTPATH_DELIMITER,
9807	RTPathFilename(configFile.c_str()));
9808	if (!fSettingsFileIsNew)
9809	{
9810	/* perform real rename only if the machine is not new */
9811	vrc = RTFileRename(configFile.c_str(), newConfigFile.c_str(), 0);
9812	if (RT_FAILURE(vrc))
9813	{
9814	rc = setError(E_FAIL,
9815	tr("Could not rename the settings file '%s' to '%s' (%Rrc)"),
9816	configFile.c_str(),
9817	newConfigFile.c_str(),
9818	vrc);
9819	break;
9820	}
9821	fileRenamed = true;
9822	configFilePrev = configFile;
9823	configFilePrev += "-prev";
9824	newConfigFilePrev = newConfigFile;
9825	newConfigFilePrev += "-prev";
9826	RTFileRename(configFilePrev.c_str(), newConfigFilePrev.c_str(), 0);
9827	}
9828	}
9829
9830	// update m_strConfigFileFull amd mConfigFile
9831	mData->m_strConfigFileFull = newConfigFile;
9832	// compute the relative path too
9833	mParent->i_copyPathRelativeToConfig(newConfigFile, mData->m_strConfigFile);
9834
9835	// store the old and new so that VirtualBox::i_saveSettings() can update
9836	// the media registry
9837	if ( mData->mRegistered
9838	&& (configDir != newConfigDir \|\| configFile != newConfigFile))
9839	{
9840	mParent->i_rememberMachineNameChangeForMedia(configDir, newConfigDir);
9841
9842	if (pfNeedsGlobalSaveSettings)
9843	*pfNeedsGlobalSaveSettings = true;
9844	}
9845
9846	// in the saved state file path, replace the old directory with the new directory
9847	if (RTPathStartsWith(mSSData->strStateFilePath.c_str(), configDir.c_str()))
9848	{
9849	Utf8Str strStateFileName = mSSData->strStateFilePath.c_str() + configDir.length();
9850	mSSData->strStateFilePath = newConfigDir + strStateFileName;
9851	}
9852
9853	// and do the same thing for the saved state file paths of all the online snapshots
9854	if (mData->mFirstSnapshot)
9855	mData->mFirstSnapshot->i_updateSavedStatePaths(configDir.c_str(),
9856	newConfigDir.c_str());
9857	}
9858	while (0);
9859
9860	if (FAILED(rc))
9861	{
9862	/* silently try to rename everything back */
9863	if (fileRenamed)
9864	{
9865	RTFileRename(newConfigFilePrev.c_str(), configFilePrev.c_str(), 0);
9866	RTFileRename(newConfigFile.c_str(), configFile.c_str(), 0);
9867	}
9868	if (dirRenamed)
9869	RTPathRename(newConfigDir.c_str(), configDir.c_str(), 0);
9870	}
9871
9872	if (FAILED(rc)) return rc;
9873	}
9874
9875	if (fSettingsFileIsNew)
9876	{
9877	/* create a virgin config file */
9878	int vrc = VINF_SUCCESS;
9879
9880	/* ensure the settings directory exists */
9881	Utf8Str path(mData->m_strConfigFileFull);
9882	path.stripFilename();
9883	if (!RTDirExists(path.c_str()))
9884	{
9885	vrc = RTDirCreateFullPath(path.c_str(), 0700);
9886	if (RT_FAILURE(vrc))
9887	{
9888	return setError(E_FAIL,
9889	tr("Could not create a directory '%s' to save the settings file (%Rrc)"),
9890	path.c_str(),
9891	vrc);
9892	}
9893	}
9894
9895	/* Note: open flags must correlate with RTFileOpen() in lockConfig() */
9896	path = Utf8Str(mData->m_strConfigFileFull);
9897	RTFILE f = NIL_RTFILE;
9898	vrc = RTFileOpen(&f, path.c_str(),
9899	RTFILE_O_READWRITE \| RTFILE_O_CREATE \| RTFILE_O_DENY_WRITE);
9900	if (RT_FAILURE(vrc))
9901	return setError(E_FAIL,
9902	tr("Could not create the settings file '%s' (%Rrc)"),
9903	path.c_str(),
9904	vrc);
9905	RTFileClose(f);
9906	}
9907
9908	return rc;
9909	}
9910
9911	/**
9912	* Saves and commits machine data, user data and hardware data.
9913	*
9914	* Note that on failure, the data remains uncommitted.
9915	*
9916	* @a aFlags may combine the following flags:
9917	*
9918	* - SaveS_ResetCurStateModified: Resets mData->mCurrentStateModified to FALSE.
9919	* Used when saving settings after an operation that makes them 100%
9920	* correspond to the settings from the current snapshot.
9921	* - SaveS_Force: settings will be saved without doing a deep compare of the
9922	* settings structures. This is used when this is called because snapshots
9923	* have changed to avoid the overhead of the deep compare.
9924	*
9925	* @note Must be called from under this object's write lock. Locks children for
9926	* writing.
9927	*
9928	* @param pfNeedsGlobalSaveSettings Optional pointer to a bool that must have been
9929	* initialized to false and that will be set to true by this function if
9930	* the caller must invoke VirtualBox::i_saveSettings() because the global
9931	* settings have changed. This will happen if a machine rename has been
9932	* saved and the global machine and media registries will therefore need
9933	* updating.
9934	* @param aFlags Flags.
9935	*/
9936	HRESULT Machine::i_saveSettings(bool *pfNeedsGlobalSaveSettings,
9937	int aFlags /= 0/)
9938	{
9939	LogFlowThisFuncEnter();
9940
9941	AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
9942
9943	/* make sure child objects are unable to modify the settings while we are
9944	* saving them */
9945	i_ensureNoStateDependencies();
9946
9947	AssertReturn(!i_isSnapshotMachine(),
9948	E_FAIL);
9949
9950	HRESULT rc = S_OK;
9951	bool fNeedsWrite = false;
9952
9953	/* First, prepare to save settings. It will care about renaming the
9954	* settings directory and file if the machine name was changed and about
9955	* creating a new settings file if this is a new machine. */
9956	rc = i_prepareSaveSettings(pfNeedsGlobalSaveSettings);
9957	if (FAILED(rc)) return rc;
9958
9959	// keep a pointer to the current settings structures
9960	settings::MachineConfigFile *pOldConfig = mData->pMachineConfigFile;
9961	settings::MachineConfigFile *pNewConfig = NULL;
9962
9963	try
9964	{
9965	// make a fresh one to have everyone write stuff into
9966	pNewConfig = new settings::MachineConfigFile(NULL);
9967	pNewConfig->copyBaseFrom(*mData->pMachineConfigFile);
9968
9969	// now go and copy all the settings data from COM to the settings structures
9970	// (this calls i_saveSettings() on all the COM objects in the machine)
9971	i_copyMachineDataToSettings(*pNewConfig);
9972
9973	if (aFlags & SaveS_ResetCurStateModified)
9974	{
9975	// this gets set by takeSnapshot() (if offline snapshot) and restoreSnapshot()
9976	mData->mCurrentStateModified = FALSE;
9977	fNeedsWrite = true; // always, no need to compare
9978	}
9979	else if (aFlags & SaveS_Force)
9980	{
9981	fNeedsWrite = true; // always, no need to compare
9982	}
9983	else
9984	{
9985	if (!mData->mCurrentStateModified)
9986	{
9987	// do a deep compare of the settings that we just saved with the settings
9988	// previously stored in the config file; this invokes MachineConfigFile::operator==
9989	// which does a deep compare of all the settings, which is expensive but less expensive
9990	// than writing out XML in vain
9991	bool fAnySettingsChanged = !(pNewConfig == pOldConfig);
9992
9993	// could still be modified if any settings changed
9994	mData->mCurrentStateModified = fAnySettingsChanged;
9995
9996	fNeedsWrite = fAnySettingsChanged;
9997	}
9998	else
9999	fNeedsWrite = true;
10000	}
10001
10002	pNewConfig->fCurrentStateModified = !!mData->mCurrentStateModified;
10003
10004	if (fNeedsWrite)
10005	// now spit it all out!
10006	pNewConfig->write(mData->m_strConfigFileFull);
10007
10008	mData->pMachineConfigFile = pNewConfig;
10009	delete pOldConfig;
10010	i_commit();
10011
10012	// after saving settings, we are no longer different from the XML on disk
10013	mData->flModifications = 0;
10014	}
10015	catch (HRESULT err)
10016	{
10017	// we assume that error info is set by the thrower
10018	rc = err;
10019
10020	// restore old config
10021	delete pNewConfig;
10022	mData->pMachineConfigFile = pOldConfig;
10023	}
10024	catch (...)
10025	{
10026	rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
10027	}
10028
10029	if (fNeedsWrite)
10030	{
10031	/* Fire the data change event, even on failure (since we've already
10032	* committed all data). This is done only for SessionMachines because
10033	* mutable Machine instances are always not registered (i.e. private
10034	* to the client process that creates them) and thus don't need to
10035	* inform callbacks. */
10036	if (i_isSessionMachine())
10037	mParent->i_onMachineDataChange(mData->mUuid);
10038	}
10039
10040	LogFlowThisFunc(("rc=%08X\n", rc));
10041	LogFlowThisFuncLeave();
10042	return rc;
10043	}
10044
10045	/**
10046	* Implementation for saving the machine settings into the given
10047	* settings::MachineConfigFile instance. This copies machine extradata
10048	* from the previous machine config file in the instance data, if any.
10049	*
10050	* This gets called from two locations:
10051	*
10052	* -- Machine::i_saveSettings(), during the regular XML writing;
10053	*
10054	* -- Appliance::buildXMLForOneVirtualSystem(), when a machine gets
10055	* exported to OVF and we write the VirtualBox proprietary XML
10056	* into a <vbox:Machine> tag.
10057	*
10058	* This routine fills all the fields in there, including snapshots, except
10059	* for the following:
10060	*
10061	* -- fCurrentStateModified. There is some special logic associated with that.
10062	*
10063	* The caller can then call MachineConfigFile::write() or do something else
10064	* with it.
10065	*
10066	* Caller must hold the machine lock!
10067	*
10068	* This throws XML errors and HRESULT, so the caller must have a catch block!
10069	*/
10070	void Machine::i_copyMachineDataToSettings(settings::MachineConfigFile &config)
10071	{
10072	// deep copy extradata, being extra careful with self assignment (the STL
10073	// map assignment on Mac OS X clang based Xcode isn't checking)
10074	if (&config != mData->pMachineConfigFile)
10075	config.mapExtraDataItems = mData->pMachineConfigFile->mapExtraDataItems;
10076
10077	config.uuid = mData->mUuid;
10078
10079	// copy name, description, OS type, teleport, UTC etc.
10080	config.machineUserData = mUserData->s;
10081
10082	if ( mData->mMachineState == MachineState_Saved
10083	\|\| mData->mMachineState == MachineState_Restoring
10084	// when doing certain snapshot operations we may or may not have
10085	// a saved state in the current state, so keep everything as is
10086	\|\| ( ( mData->mMachineState == MachineState_Snapshotting
10087	\|\| mData->mMachineState == MachineState_DeletingSnapshot
10088	\|\| mData->mMachineState == MachineState_RestoringSnapshot)
10089	&& (!mSSData->strStateFilePath.isEmpty())
10090	)
10091	)
10092	{
10093	Assert(!mSSData->strStateFilePath.isEmpty());
10094	/* try to make the file name relative to the settings file dir */
10095	i_copyPathRelativeToMachine(mSSData->strStateFilePath, config.strStateFile);
10096	}
10097	else
10098	{
10099	Assert(mSSData->strStateFilePath.isEmpty() \|\| mData->mMachineState == MachineState_Saving);
10100	config.strStateFile.setNull();
10101	}
10102
10103	if (mData->mCurrentSnapshot)
10104	config.uuidCurrentSnapshot = mData->mCurrentSnapshot->i_getId();
10105	else
10106	config.uuidCurrentSnapshot.clear();
10107
10108	config.timeLastStateChange = mData->mLastStateChange;
10109	config.fAborted = (mData->mMachineState == MachineState_Aborted);
10110	/// @todo Live Migration: config.fTeleported = (mData->mMachineState == MachineState_Teleported);
10111
10112	HRESULT rc = i_saveHardware(config.hardwareMachine, &config.debugging, &config.autostart);
10113	if (FAILED(rc)) throw rc;
10114
10115	// save machine's media registry if this is VirtualBox 4.0 or later
10116	if (config.canHaveOwnMediaRegistry())
10117	{
10118	// determine machine folder
10119	Utf8Str strMachineFolder = i_getSettingsFileFull();
10120	strMachineFolder.stripFilename();
10121	mParent->i_saveMediaRegistry(config.mediaRegistry,
10122	i_getId(), // only media with registry ID == machine UUID
10123	strMachineFolder);
10124	// this throws HRESULT
10125	}
10126
10127	// save snapshots
10128	rc = i_saveAllSnapshots(config);
10129	if (FAILED(rc)) throw rc;
10130	}
10131
10132	/**
10133	* Saves all snapshots of the machine into the given machine config file. Called
10134	* from Machine::buildMachineXML() and SessionMachine::deleteSnapshotHandler().
10135	* @param config
10136	* @return
10137	*/
10138	HRESULT Machine::i_saveAllSnapshots(settings::MachineConfigFile &config)
10139	{
10140	AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
10141
10142	HRESULT rc = S_OK;
10143
10144	try
10145	{
10146	config.llFirstSnapshot.clear();
10147
10148	if (mData->mFirstSnapshot)
10149	{
10150	// the settings use a list for "the first snapshot"
10151	config.llFirstSnapshot.push_back(settings::Snapshot::Empty);
10152
10153	// get reference to the snapshot on the list and work on that
10154	// element straight in the list to avoid excessive copying later
10155	rc = mData->mFirstSnapshot->i_saveSnapshot(config.llFirstSnapshot.back());
10156	if (FAILED(rc)) throw rc;
10157	}
10158
10159	// if (mType == IsSessionMachine)
10160	// mParent->onMachineDataChange(mData->mUuid); @todo is this necessary?
10161
10162	}
10163	catch (HRESULT err)
10164	{
10165	/* we assume that error info is set by the thrower */
10166	rc = err;
10167	}
10168	catch (...)
10169	{
10170	rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
10171	}
10172
10173	return rc;
10174	}
10175
10176	/**
10177	* Saves the VM hardware configuration. It is assumed that the
10178	* given node is empty.
10179	*
10180	* @param data Reference to the settings object for the hardware config.
10181	* @param pDbg Pointer to the settings object for the debugging config
10182	* which happens to live in mHWData.
10183	* @param pAutostart Pointer to the settings object for the autostart config
10184	* which happens to live in mHWData.
10185	*/
10186	HRESULT Machine::i_saveHardware(settings::Hardware &data, settings::Debugging *pDbg,
10187	settings::Autostart *pAutostart)
10188	{
10189	HRESULT rc = S_OK;
10190
10191	try
10192	{
10193	/* The hardware version attribute (optional).
10194	Automatically upgrade from 1 to current default hardware version
10195	when there is no saved state. (ugly!) */
10196	if ( mHWData->mHWVersion == "1"
10197	&& mSSData->strStateFilePath.isEmpty()
10198	)
10199	mHWData->mHWVersion = Utf8StrFmt("%d", SchemaDefs::DefaultHardwareVersion);
10200
10201	data.strVersion = mHWData->mHWVersion;
10202	data.uuid = mHWData->mHardwareUUID;
10203
10204	// CPU
10205	data.fHardwareVirt = !!mHWData->mHWVirtExEnabled;
10206	data.fNestedPaging = !!mHWData->mHWVirtExNestedPagingEnabled;
10207	data.fLargePages = !!mHWData->mHWVirtExLargePagesEnabled;
10208	data.fVPID = !!mHWData->mHWVirtExVPIDEnabled;
10209	data.fUnrestrictedExecution = !!mHWData->mHWVirtExUXEnabled;
10210	data.fHardwareVirtForce = !!mHWData->mHWVirtExForceEnabled;
10211	data.fPAE = !!mHWData->mPAEEnabled;
10212	data.enmLongMode = mHWData->mLongMode;
10213	data.fTripleFaultReset = !!mHWData->mTripleFaultReset;
10214	data.fAPIC = !!mHWData->mAPIC;
10215	data.fX2APIC = !!mHWData->mX2APIC;
10216	data.cCPUs = mHWData->mCPUCount;
10217	data.fCpuHotPlug = !!mHWData->mCPUHotPlugEnabled;
10218	data.ulCpuExecutionCap = mHWData->mCpuExecutionCap;
10219	data.uCpuIdPortabilityLevel = mHWData->mCpuIdPortabilityLevel;
10220	data.strCpuProfile = mHWData->mCpuProfile;
10221
10222	data.llCpus.clear();
10223	if (data.fCpuHotPlug)
10224	{
10225	for (unsigned idx = 0; idx < data.cCPUs; ++idx)
10226	{
10227	if (mHWData->mCPUAttached[idx])
10228	{
10229	settings::Cpu cpu;
10230	cpu.ulId = idx;
10231	data.llCpus.push_back(cpu);
10232	}
10233	}
10234	}
10235
10236	/* Standard and Extended CPUID leafs. */
10237	data.llCpuIdLeafs.clear();
10238	data.llCpuIdLeafs = mHWData->mCpuIdLeafList;
10239
10240	// memory
10241	data.ulMemorySizeMB = mHWData->mMemorySize;
10242	data.fPageFusionEnabled = !!mHWData->mPageFusionEnabled;
10243
10244	// firmware
10245	data.firmwareType = mHWData->mFirmwareType;
10246
10247	// HID
10248	data.pointingHIDType = mHWData->mPointingHIDType;
10249	data.keyboardHIDType = mHWData->mKeyboardHIDType;
10250
10251	// chipset
10252	data.chipsetType = mHWData->mChipsetType;
10253
10254	// paravirt
10255	data.paravirtProvider = mHWData->mParavirtProvider;
10256	data.strParavirtDebug = mHWData->mParavirtDebug;
10257
10258	// emulated USB card reader
10259	data.fEmulatedUSBCardReader = !!mHWData->mEmulatedUSBCardReaderEnabled;
10260
10261	// HPET
10262	data.fHPETEnabled = !!mHWData->mHPETEnabled;
10263
10264	// boot order
10265	data.mapBootOrder.clear();
10266	for (unsigned i = 0; i < RT_ELEMENTS(mHWData->mBootOrder); ++i)
10267	data.mapBootOrder[i] = mHWData->mBootOrder[i];
10268
10269	// display
10270	data.graphicsControllerType = mHWData->mGraphicsControllerType;
10271	data.ulVRAMSizeMB = mHWData->mVRAMSize;
10272	data.cMonitors = mHWData->mMonitorCount;
10273	data.fAccelerate3D = !!mHWData->mAccelerate3DEnabled;
10274	data.fAccelerate2DVideo = !!mHWData->mAccelerate2DVideoEnabled;
10275	data.ulVideoCaptureHorzRes = mHWData->mVideoCaptureWidth;
10276	data.ulVideoCaptureVertRes = mHWData->mVideoCaptureHeight;
10277	data.ulVideoCaptureRate = mHWData->mVideoCaptureRate;
10278	data.ulVideoCaptureFPS = mHWData->mVideoCaptureFPS;
10279	data.fVideoCaptureEnabled = !!mHWData->mVideoCaptureEnabled;
10280	for (unsigned i = 0; i < sizeof(data.u64VideoCaptureScreens) * 8; ++i)
10281	{
10282	if (mHWData->maVideoCaptureScreens[i])
10283	ASMBitSet(&data.u64VideoCaptureScreens, i);
10284	else
10285	ASMBitClear(&data.u64VideoCaptureScreens, i);
10286	}
10287	/* store relative video capture file if possible */
10288	i_copyPathRelativeToMachine(mHWData->mVideoCaptureFile, data.strVideoCaptureFile);
10289	data.strVideoCaptureOptions = mHWData->mVideoCaptureOptions;
10290
10291	/* VRDEServer settings (optional) */
10292	rc = mVRDEServer->i_saveSettings(data.vrdeSettings);
10293	if (FAILED(rc)) throw rc;
10294
10295	/* BIOS (required) */
10296	rc = mBIOSSettings->i_saveSettings(data.biosSettings);
10297	if (FAILED(rc)) throw rc;
10298
10299	/* USB Controller (required) */
10300	data.usbSettings.llUSBControllers.clear();
10301	for (USBControllerList::const_iterator
10302	it = mUSBControllers->begin();
10303	it != mUSBControllers->end();
10304	++it)
10305	{
10306	ComObjPtr<USBController> ctrl = *it;
10307	settings::USBController settingsCtrl;
10308
10309	settingsCtrl.strName = ctrl->i_getName();
10310	settingsCtrl.enmType = ctrl->i_getControllerType();
10311
10312	data.usbSettings.llUSBControllers.push_back(settingsCtrl);
10313	}
10314
10315	/* USB device filters (required) */
10316	rc = mUSBDeviceFilters->i_saveSettings(data.usbSettings);
10317	if (FAILED(rc)) throw rc;
10318
10319	/* Network adapters (required) */
10320	size_t uMaxNICs = RT_MIN(Global::getMaxNetworkAdapters(mHWData->mChipsetType), mNetworkAdapters.size());
10321	data.llNetworkAdapters.clear();
10322	/* Write out only the nominal number of network adapters for this
10323	* chipset type. Since Machine::commit() hasn't been called there
10324	* may be extra NIC settings in the vector. */
10325	for (size_t slot = 0; slot < uMaxNICs; ++slot)
10326	{
10327	settings::NetworkAdapter nic;
10328	nic.ulSlot = (uint32_t)slot;
10329	/* paranoia check... must not be NULL, but must not crash either. */
10330	if (mNetworkAdapters[slot])
10331	{
10332	if (mNetworkAdapters[slot]->i_hasDefaults())
10333	continue;
10334
10335	rc = mNetworkAdapters[slot]->i_saveSettings(nic);
10336	if (FAILED(rc)) throw rc;
10337
10338	data.llNetworkAdapters.push_back(nic);
10339	}
10340	}
10341
10342	/* Serial ports */
10343	data.llSerialPorts.clear();
10344	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
10345	{
10346	if (mSerialPorts[slot]->i_hasDefaults())
10347	continue;
10348
10349	settings::SerialPort s;
10350	s.ulSlot = slot;
10351	rc = mSerialPorts[slot]->i_saveSettings(s);
10352	if (FAILED(rc)) return rc;
10353
10354	data.llSerialPorts.push_back(s);
10355	}
10356
10357	/* Parallel ports */
10358	data.llParallelPorts.clear();
10359	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
10360	{
10361	if (mParallelPorts[slot]->i_hasDefaults())
10362	continue;
10363
10364	settings::ParallelPort p;
10365	p.ulSlot = slot;
10366	rc = mParallelPorts[slot]->i_saveSettings(p);
10367	if (FAILED(rc)) return rc;
10368
10369	data.llParallelPorts.push_back(p);
10370	}
10371
10372	/* Audio adapter */
10373	rc = mAudioAdapter->i_saveSettings(data.audioAdapter);
10374	if (FAILED(rc)) return rc;
10375
10376	rc = i_saveStorageControllers(data.storage);
10377	if (FAILED(rc)) return rc;
10378
10379	/* Shared folders */
10380	data.llSharedFolders.clear();
10381	for (HWData::SharedFolderList::const_iterator
10382	it = mHWData->mSharedFolders.begin();
10383	it != mHWData->mSharedFolders.end();
10384	++it)
10385	{
10386	SharedFolder pSF = it;
10387	AutoCaller sfCaller(pSF);
10388	AutoReadLock sfLock(pSF COMMA_LOCKVAL_SRC_POS);
10389	settings::SharedFolder sf;
10390	sf.strName = pSF->i_getName();
10391	sf.strHostPath = pSF->i_getHostPath();
10392	sf.fWritable = !!pSF->i_isWritable();
10393	sf.fAutoMount = !!pSF->i_isAutoMounted();
10394
10395	data.llSharedFolders.push_back(sf);
10396	}
10397
10398	// clipboard
10399	data.clipboardMode = mHWData->mClipboardMode;
10400
10401	// drag'n'drop
10402	data.dndMode = mHWData->mDnDMode;
10403
10404	/* Guest */
10405	data.ulMemoryBalloonSize = mHWData->mMemoryBalloonSize;
10406
10407	// IO settings
10408	data.ioSettings.fIOCacheEnabled = !!mHWData->mIOCacheEnabled;
10409	data.ioSettings.ulIOCacheSize = mHWData->mIOCacheSize;
10410
10411	/* BandwidthControl (required) */
10412	rc = mBandwidthControl->i_saveSettings(data.ioSettings);
10413	if (FAILED(rc)) throw rc;
10414
10415	/* Host PCI devices */
10416	data.pciAttachments.clear();
10417	for (HWData::PCIDeviceAssignmentList::const_iterator
10418	it = mHWData->mPCIDeviceAssignments.begin();
10419	it != mHWData->mPCIDeviceAssignments.end();
10420	++it)
10421	{
10422	ComObjPtr<PCIDeviceAttachment> pda = *it;
10423	settings::HostPCIDeviceAttachment hpda;
10424
10425	rc = pda->i_saveSettings(hpda);
10426	if (FAILED(rc)) throw rc;
10427
10428	data.pciAttachments.push_back(hpda);
10429	}
10430
10431	// guest properties
10432	data.llGuestProperties.clear();
10433	#ifdef VBOX_WITH_GUEST_PROPS
10434	for (HWData::GuestPropertyMap::const_iterator
10435	it = mHWData->mGuestProperties.begin();
10436	it != mHWData->mGuestProperties.end();
10437	++it)
10438	{
10439	HWData::GuestProperty property = it->second;
10440
10441	/* Remove transient guest properties at shutdown unless we
10442	* are saving state. Note that restoring snapshot intentionally
10443	* keeps them, they will be removed if appropriate once the final
10444	* machine state is set (as crashes etc. need to work). */
10445	if ( ( mData->mMachineState == MachineState_PoweredOff
10446	\|\| mData->mMachineState == MachineState_Aborted
10447	\|\| mData->mMachineState == MachineState_Teleported)
10448	&& (property.mFlags & (GUEST_PROP_F_TRANSIENT \| GUEST_PROP_F_TRANSRESET)))
10449	continue;
10450	settings::GuestProperty prop; /// @todo r=bird: some excellent variable name choices here: 'prop' and 'property'; No 'const' clue either.
10451	prop.strName = it->first;
10452	prop.strValue = property.strValue;
10453	prop.timestamp = property.mTimestamp;
10454	char szFlags[GUEST_PROP_MAX_FLAGS_LEN + 1];
10455	GuestPropWriteFlags(property.mFlags, szFlags);
10456	prop.strFlags = szFlags;
10457
10458	data.llGuestProperties.push_back(prop);
10459	}
10460
10461	/* I presume this doesn't require a backup(). */
10462	mData->mGuestPropertiesModified = FALSE;
10463	#endif /* VBOX_WITH_GUEST_PROPS defined */
10464
10465	*pDbg = mHWData->mDebugging;
10466	*pAutostart = mHWData->mAutostart;
10467
10468	data.strDefaultFrontend = mHWData->mDefaultFrontend;
10469	}
10470	catch (std::bad_alloc &)
10471	{
10472	return E_OUTOFMEMORY;
10473	}
10474
10475	AssertComRC(rc);
10476	return rc;
10477	}
10478
10479	/**
10480	* Saves the storage controller configuration.
10481	*
10482	* @param data storage settings.
10483	*/
10484	HRESULT Machine::i_saveStorageControllers(settings::Storage &data)
10485	{
10486	data.llStorageControllers.clear();
10487
10488	for (StorageControllerList::const_iterator
10489	it = mStorageControllers->begin();
10490	it != mStorageControllers->end();
10491	++it)
10492	{
10493	HRESULT rc;
10494	ComObjPtr<StorageController> pCtl = *it;
10495
10496	settings::StorageController ctl;
10497	ctl.strName = pCtl->i_getName();
10498	ctl.controllerType = pCtl->i_getControllerType();
10499	ctl.storageBus = pCtl->i_getStorageBus();
10500	ctl.ulInstance = pCtl->i_getInstance();
10501	ctl.fBootable = pCtl->i_getBootable();
10502
10503	/* Save the port count. */
10504	ULONG portCount;
10505	rc = pCtl->COMGETTER(PortCount)(&portCount);
10506	ComAssertComRCRet(rc, rc);
10507	ctl.ulPortCount = portCount;
10508
10509	/* Save fUseHostIOCache */
10510	BOOL fUseHostIOCache;
10511	rc = pCtl->COMGETTER(UseHostIOCache)(&fUseHostIOCache);
10512	ComAssertComRCRet(rc, rc);
10513	ctl.fUseHostIOCache = !!fUseHostIOCache;
10514
10515	/* save the devices now. */
10516	rc = i_saveStorageDevices(pCtl, ctl);
10517	ComAssertComRCRet(rc, rc);
10518
10519	data.llStorageControllers.push_back(ctl);
10520	}
10521
10522	return S_OK;
10523	}
10524
10525	/**
10526	* Saves the hard disk configuration.
10527	*/
10528	HRESULT Machine::i_saveStorageDevices(ComObjPtr<StorageController> aStorageController,
10529	settings::StorageController &data)
10530	{
10531	MediumAttachmentList atts;
10532
10533	HRESULT rc = i_getMediumAttachmentsOfController(aStorageController->i_getName(), atts);
10534	if (FAILED(rc)) return rc;
10535
10536	data.llAttachedDevices.clear();
10537	for (MediumAttachmentList::const_iterator
10538	it = atts.begin();
10539	it != atts.end();
10540	++it)
10541	{
10542	settings::AttachedDevice dev;
10543	IMediumAttachment iA = it;
10544	MediumAttachment pAttach = static_cast<MediumAttachment >(iA);
10545	Medium *pMedium = pAttach->i_getMedium();
10546
10547	dev.deviceType = pAttach->i_getType();
10548	dev.lPort = pAttach->i_getPort();
10549	dev.lDevice = pAttach->i_getDevice();
10550	dev.fPassThrough = pAttach->i_getPassthrough();
10551	dev.fHotPluggable = pAttach->i_getHotPluggable();
10552	if (pMedium)
10553	{
10554	if (pMedium->i_isHostDrive())
10555	dev.strHostDriveSrc = pMedium->i_getLocationFull();
10556	else
10557	dev.uuid = pMedium->i_getId();
10558	dev.fTempEject = pAttach->i_getTempEject();
10559	dev.fNonRotational = pAttach->i_getNonRotational();
10560	dev.fDiscard = pAttach->i_getDiscard();
10561	}
10562
10563	dev.strBwGroup = pAttach->i_getBandwidthGroup();
10564
10565	data.llAttachedDevices.push_back(dev);
10566	}
10567
10568	return S_OK;
10569	}
10570
10571	/**
10572	* Saves machine state settings as defined by aFlags
10573	* (SaveSTS_* values).
10574	*
10575	* @param aFlags Combination of SaveSTS_* flags.
10576	*
10577	* @note Locks objects for writing.
10578	*/
10579	HRESULT Machine::i_saveStateSettings(int aFlags)
10580	{
10581	if (aFlags == 0)
10582	return S_OK;
10583
10584	AutoCaller autoCaller(this);
10585	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10586
10587	/* This object's write lock is also necessary to serialize file access
10588	* (prevent concurrent reads and writes) */
10589	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
10590
10591	HRESULT rc = S_OK;
10592
10593	Assert(mData->pMachineConfigFile);
10594
10595	try
10596	{
10597	if (aFlags & SaveSTS_CurStateModified)
10598	mData->pMachineConfigFile->fCurrentStateModified = true;
10599
10600	if (aFlags & SaveSTS_StateFilePath)
10601	{
10602	if (!mSSData->strStateFilePath.isEmpty())
10603	/* try to make the file name relative to the settings file dir */
10604	i_copyPathRelativeToMachine(mSSData->strStateFilePath, mData->pMachineConfigFile->strStateFile);
10605	else
10606	mData->pMachineConfigFile->strStateFile.setNull();
10607	}
10608
10609	if (aFlags & SaveSTS_StateTimeStamp)
10610	{
10611	Assert( mData->mMachineState != MachineState_Aborted
10612	\|\| mSSData->strStateFilePath.isEmpty());
10613
10614	mData->pMachineConfigFile->timeLastStateChange = mData->mLastStateChange;
10615
10616	mData->pMachineConfigFile->fAborted = (mData->mMachineState == MachineState_Aborted);
10617	/// @todo live migration mData->pMachineConfigFile->fTeleported = (mData->mMachineState == MachineState_Teleported);
10618	}
10619
10620	mData->pMachineConfigFile->write(mData->m_strConfigFileFull);
10621	}
10622	catch (...)
10623	{
10624	rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
10625	}
10626
10627	return rc;
10628	}
10629
10630	/**
10631	* Ensures that the given medium is added to a media registry. If this machine
10632	* was created with 4.0 or later, then the machine registry is used. Otherwise
10633	* the global VirtualBox media registry is used.
10634	*
10635	* Caller must NOT hold machine lock, media tree or any medium locks!
10636	*
10637	* @param pMedium
10638	*/
10639	void Machine::i_addMediumToRegistry(ComObjPtr<Medium> &pMedium)
10640	{
10641	/* Paranoia checks: do not hold machine or media tree locks. */
10642	AssertReturnVoid(!isWriteLockOnCurrentThread());
10643	AssertReturnVoid(!mParent->i_getMediaTreeLockHandle().isWriteLockOnCurrentThread());
10644
10645	ComObjPtr<Medium> pBase;
10646	{
10647	AutoReadLock treeLock(&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
10648	pBase = pMedium->i_getBase();
10649	}
10650
10651	/* Paranoia checks: do not hold medium locks. */
10652	AssertReturnVoid(!pMedium->isWriteLockOnCurrentThread());
10653	AssertReturnVoid(!pBase->isWriteLockOnCurrentThread());
10654
10655	// decide which medium registry to use now that the medium is attached:
10656	Guid uuid;
10657	if (mData->pMachineConfigFile->canHaveOwnMediaRegistry())
10658	// machine XML is VirtualBox 4.0 or higher:
10659	uuid = i_getId(); // machine UUID
10660	else
10661	uuid = mParent->i_getGlobalRegistryId(); // VirtualBox global registry UUID
10662
10663	if (pMedium->i_addRegistry(uuid))
10664	mParent->i_markRegistryModified(uuid);
10665
10666	/* For more complex hard disk structures it can happen that the base
10667	* medium isn't yet associated with any medium registry. Do that now. */
10668	if (pMedium != pBase)
10669	{
10670	/* Tree lock needed by Medium::addRegistry when recursing. */
10671	AutoReadLock treeLock(&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
10672	if (pBase->i_addRegistryRecursive(uuid))
10673	{
10674	treeLock.release();
10675	mParent->i_markRegistryModified(uuid);
10676	}
10677	}
10678	}
10679
10680	/**
10681	* Creates differencing hard disks for all normal hard disks attached to this
10682	* machine and a new set of attachments to refer to created disks.
10683	*
10684	* Used when taking a snapshot or when deleting the current state. Gets called
10685	* from SessionMachine::BeginTakingSnapshot() and SessionMachine::restoreSnapshotHandler().
10686	*
10687	* This method assumes that mMediumAttachments contains the original hard disk
10688	* attachments it needs to create diffs for. On success, these attachments will
10689	* be replaced with the created diffs.
10690	*
10691	* Attachments with non-normal hard disks are left as is.
10692	*
10693	* If @a aOnline is @c false then the original hard disks that require implicit
10694	* diffs will be locked for reading. Otherwise it is assumed that they are
10695	* already locked for writing (when the VM was started). Note that in the latter
10696	* case it is responsibility of the caller to lock the newly created diffs for
10697	* writing if this method succeeds.
10698	*
10699	* @param aProgress Progress object to run (must contain at least as
10700	* many operations left as the number of hard disks
10701	* attached).
10702	* @param aWeight Weight of this operation.
10703	* @param aOnline Whether the VM was online prior to this operation.
10704	*
10705	* @note The progress object is not marked as completed, neither on success nor
10706	* on failure. This is a responsibility of the caller.
10707	*
10708	* @note Locks this object and the media tree for writing.
10709	*/
10710	HRESULT Machine::i_createImplicitDiffs(IProgress *aProgress,
10711	ULONG aWeight,
10712	bool aOnline)
10713	{
10714	LogFlowThisFunc(("aOnline=%d\n", aOnline));
10715
10716	AutoCaller autoCaller(this);
10717	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10718
10719	AutoMultiWriteLock2 alock(this->lockHandle(),
10720	&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
10721
10722	/* must be in a protective state because we release the lock below */
10723	AssertReturn( mData->mMachineState == MachineState_Snapshotting
10724	\|\| mData->mMachineState == MachineState_OnlineSnapshotting
10725	\|\| mData->mMachineState == MachineState_LiveSnapshotting
10726	\|\| mData->mMachineState == MachineState_RestoringSnapshot
10727	\|\| mData->mMachineState == MachineState_DeletingSnapshot
10728	, E_FAIL);
10729
10730	HRESULT rc = S_OK;
10731
10732	// use appropriate locked media map (online or offline)
10733	MediumLockListMap lockedMediaOffline;
10734	MediumLockListMap *lockedMediaMap;
10735	if (aOnline)
10736	lockedMediaMap = &mData->mSession.mLockedMedia;
10737	else
10738	lockedMediaMap = &lockedMediaOffline;
10739
10740	try
10741	{
10742	if (!aOnline)
10743	{
10744	/* lock all attached hard disks early to detect "in use"
10745	* situations before creating actual diffs */
10746	for (MediumAttachmentList::const_iterator
10747	it = mMediumAttachments->begin();
10748	it != mMediumAttachments->end();
10749	++it)
10750	{
10751	MediumAttachment pAtt = it;
10752	if (pAtt->i_getType() == DeviceType_HardDisk)
10753	{
10754	Medium *pMedium = pAtt->i_getMedium();
10755	Assert(pMedium);
10756
10757	MediumLockList *pMediumLockList(new MediumLockList());
10758	alock.release();
10759	rc = pMedium->i_createMediumLockList(true /* fFailIfInaccessible */,
10760	NULL /* pToLockWrite */,
10761	false /* fMediumLockWriteAll */,
10762	NULL,
10763	*pMediumLockList);
10764	alock.acquire();
10765	if (FAILED(rc))
10766	{
10767	delete pMediumLockList;
10768	throw rc;
10769	}
10770	rc = lockedMediaMap->Insert(pAtt, pMediumLockList);
10771	if (FAILED(rc))
10772	{
10773	throw setError(rc,
10774	tr("Collecting locking information for all attached media failed"));
10775	}
10776	}
10777	}
10778
10779	/* Now lock all media. If this fails, nothing is locked. */
10780	alock.release();
10781	rc = lockedMediaMap->Lock();
10782	alock.acquire();
10783	if (FAILED(rc))
10784	{
10785	throw setError(rc,
10786	tr("Locking of attached media failed"));
10787	}
10788	}
10789
10790	/* remember the current list (note that we don't use backup() since
10791	* mMediumAttachments may be already backed up) */
10792	MediumAttachmentList atts = *mMediumAttachments.data();
10793
10794	/* start from scratch */
10795	mMediumAttachments->clear();
10796
10797	/* go through remembered attachments and create diffs for normal hard
10798	* disks and attach them */
10799	for (MediumAttachmentList::const_iterator
10800	it = atts.begin();
10801	it != atts.end();
10802	++it)
10803	{
10804	MediumAttachment pAtt = it;
10805
10806	DeviceType_T devType = pAtt->i_getType();
10807	Medium *pMedium = pAtt->i_getMedium();
10808
10809	if ( devType != DeviceType_HardDisk
10810	\|\| pMedium == NULL
10811	\|\| pMedium->i_getType() != MediumType_Normal)
10812	{
10813	/* copy the attachment as is */
10814
10815	/** @todo the progress object created in SessionMachine::TakeSnaphot
10816	* only expects operations for hard disks. Later other
10817	* device types need to show up in the progress as well. */
10818	if (devType == DeviceType_HardDisk)
10819	{
10820	if (pMedium == NULL)
10821	aProgress->SetNextOperation(Bstr(tr("Skipping attachment without medium")).raw(),
10822	aWeight); // weight
10823	else
10824	aProgress->SetNextOperation(BstrFmt(tr("Skipping medium '%s'"),
10825	pMedium->i_getBase()->i_getName().c_str()).raw(),
10826	aWeight); // weight
10827	}
10828
10829	mMediumAttachments->push_back(pAtt);
10830	continue;
10831	}
10832
10833	/* need a diff */
10834	aProgress->SetNextOperation(BstrFmt(tr("Creating differencing hard disk for '%s'"),
10835	pMedium->i_getBase()->i_getName().c_str()).raw(),
10836	aWeight); // weight
10837
10838	Utf8Str strFullSnapshotFolder;
10839	i_calculateFullPath(mUserData->s.strSnapshotFolder, strFullSnapshotFolder);
10840
10841	ComObjPtr<Medium> diff;
10842	diff.createObject();
10843	// store the diff in the same registry as the parent
10844	// (this cannot fail here because we can't create implicit diffs for
10845	// unregistered images)
10846	Guid uuidRegistryParent;
10847	bool fInRegistry = pMedium->i_getFirstRegistryMachineId(uuidRegistryParent);
10848	Assert(fInRegistry); NOREF(fInRegistry);
10849	rc = diff->init(mParent,
10850	pMedium->i_getPreferredDiffFormat(),
10851	strFullSnapshotFolder.append(RTPATH_SLASH_STR),
10852	uuidRegistryParent,
10853	DeviceType_HardDisk);
10854	if (FAILED(rc)) throw rc;
10855
10856	/** @todo r=bird: How is the locking and diff image cleaned up if we fail before
10857	* the push_back? Looks like we're going to release medium with the
10858	* wrong kind of lock (general issue with if we fail anywhere at all)
10859	* and an orphaned VDI in the snapshots folder. */
10860
10861	/* update the appropriate lock list */
10862	MediumLockList *pMediumLockList;
10863	rc = lockedMediaMap->Get(pAtt, pMediumLockList);
10864	AssertComRCThrowRC(rc);
10865	if (aOnline)
10866	{
10867	alock.release();
10868	/* The currently attached medium will be read-only, change
10869	* the lock type to read. */
10870	rc = pMediumLockList->Update(pMedium, false);
10871	alock.acquire();
10872	AssertComRCThrowRC(rc);
10873	}
10874
10875	/* release the locks before the potentially lengthy operation */
10876	alock.release();
10877	rc = pMedium->i_createDiffStorage(diff,
10878	pMedium->i_getPreferredDiffVariant(),
10879	pMediumLockList,
10880	NULL /* aProgress */,
10881	true /* aWait */);
10882	alock.acquire();
10883	if (FAILED(rc)) throw rc;
10884
10885	/* actual lock list update is done in Machine::i_commitMedia */
10886
10887	rc = diff->i_addBackReference(mData->mUuid);
10888	AssertComRCThrowRC(rc);
10889
10890	/* add a new attachment */
10891	ComObjPtr<MediumAttachment> attachment;
10892	attachment.createObject();
10893	rc = attachment->init(this,
10894	diff,
10895	pAtt->i_getControllerName(),
10896	pAtt->i_getPort(),
10897	pAtt->i_getDevice(),
10898	DeviceType_HardDisk,
10899	true /* aImplicit */,
10900	false /* aPassthrough */,
10901	false /* aTempEject */,
10902	pAtt->i_getNonRotational(),
10903	pAtt->i_getDiscard(),
10904	pAtt->i_getHotPluggable(),
10905	pAtt->i_getBandwidthGroup());
10906	if (FAILED(rc)) throw rc;
10907
10908	rc = lockedMediaMap->ReplaceKey(pAtt, attachment);
10909	AssertComRCThrowRC(rc);
10910	mMediumAttachments->push_back(attachment);
10911	}
10912	}
10913	catch (HRESULT aRC) { rc = aRC; }
10914
10915	/* unlock all hard disks we locked when there is no VM */
10916	if (!aOnline)
10917	{
10918	ErrorInfoKeeper eik;
10919
10920	HRESULT rc1 = lockedMediaMap->Clear();
10921	AssertComRC(rc1);
10922	}
10923
10924	return rc;
10925	}
10926
10927	/**
10928	* Deletes implicit differencing hard disks created either by
10929	* #i_createImplicitDiffs() or by #attachDevice() and rolls back
10930	* mMediumAttachments.
10931	*
10932	* Note that to delete hard disks created by #attachDevice() this method is
10933	* called from #i_rollbackMedia() when the changes are rolled back.
10934	*
10935	* @note Locks this object and the media tree for writing.
10936	*/
10937	HRESULT Machine::i_deleteImplicitDiffs(bool aOnline)
10938	{
10939	LogFlowThisFunc(("aOnline=%d\n", aOnline));
10940
10941	AutoCaller autoCaller(this);
10942	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10943
10944	AutoMultiWriteLock2 alock(this->lockHandle(),
10945	&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
10946
10947	/* We absolutely must have backed up state. */
10948	AssertReturn(mMediumAttachments.isBackedUp(), E_FAIL);
10949
10950	/* Check if there are any implicitly created diff images. */
10951	bool fImplicitDiffs = false;
10952	for (MediumAttachmentList::const_iterator
10953	it = mMediumAttachments->begin();
10954	it != mMediumAttachments->end();
10955	++it)
10956	{
10957	const ComObjPtr<MediumAttachment> &pAtt = *it;
10958	if (pAtt->i_isImplicit())
10959	{
10960	fImplicitDiffs = true;
10961	break;
10962	}
10963	}
10964	/* If there is nothing to do, leave early. This saves lots of image locking
10965	* effort. It also avoids a MachineStateChanged event without real reason.
10966	* This is important e.g. when loading a VM config, because there should be
10967	* no events. Otherwise API clients can become thoroughly confused for
10968	* inaccessible VMs (the code for loading VM configs uses this method for
10969	* cleanup if the config makes no sense), as they take such events as an
10970	* indication that the VM is alive, and they would force the VM config to
10971	* be reread, leading to an endless loop. */
10972	if (!fImplicitDiffs)
10973	return S_OK;
10974
10975	HRESULT rc = S_OK;
10976	MachineState_T oldState = mData->mMachineState;
10977
10978	/* will release the lock before the potentially lengthy operation,
10979	* so protect with the special state (unless already protected) */
10980	if ( oldState != MachineState_Snapshotting
10981	&& oldState != MachineState_OnlineSnapshotting
10982	&& oldState != MachineState_LiveSnapshotting
10983	&& oldState != MachineState_RestoringSnapshot
10984	&& oldState != MachineState_DeletingSnapshot
10985	&& oldState != MachineState_DeletingSnapshotOnline
10986	&& oldState != MachineState_DeletingSnapshotPaused
10987	)
10988	i_setMachineState(MachineState_SettingUp);
10989
10990	// use appropriate locked media map (online or offline)
10991	MediumLockListMap lockedMediaOffline;
10992	MediumLockListMap *lockedMediaMap;
10993	if (aOnline)
10994	lockedMediaMap = &mData->mSession.mLockedMedia;
10995	else
10996	lockedMediaMap = &lockedMediaOffline;
10997
10998	try
10999	{
11000	if (!aOnline)
11001	{
11002	/* lock all attached hard disks early to detect "in use"
11003	* situations before deleting actual diffs */
11004	for (MediumAttachmentList::const_iterator
11005	it = mMediumAttachments->begin();
11006	it != mMediumAttachments->end();
11007	++it)
11008	{
11009	MediumAttachment pAtt = it;
11010	if (pAtt->i_getType() == DeviceType_HardDisk)
11011	{
11012	Medium *pMedium = pAtt->i_getMedium();
11013	Assert(pMedium);
11014
11015	MediumLockList *pMediumLockList(new MediumLockList());
11016	alock.release();
11017	rc = pMedium->i_createMediumLockList(true /* fFailIfInaccessible */,
11018	NULL /* pToLockWrite */,
11019	false /* fMediumLockWriteAll */,
11020	NULL,
11021	*pMediumLockList);
11022	alock.acquire();
11023
11024	if (FAILED(rc))
11025	{
11026	delete pMediumLockList;
11027	throw rc;
11028	}
11029
11030	rc = lockedMediaMap->Insert(pAtt, pMediumLockList);
11031	if (FAILED(rc))
11032	throw rc;
11033	}
11034	}
11035
11036	if (FAILED(rc))
11037	throw rc;
11038	} // end of offline
11039
11040	/* Lock lists are now up to date and include implicitly created media */
11041
11042	/* Go through remembered attachments and delete all implicitly created
11043	* diffs and fix up the attachment information */
11044	const MediumAttachmentList &oldAtts = *mMediumAttachments.backedUpData();
11045	MediumAttachmentList implicitAtts;
11046	for (MediumAttachmentList::const_iterator
11047	it = mMediumAttachments->begin();
11048	it != mMediumAttachments->end();
11049	++it)
11050	{
11051	ComObjPtr<MediumAttachment> pAtt = *it;
11052	ComObjPtr<Medium> pMedium = pAtt->i_getMedium();
11053	if (pMedium.isNull())
11054	continue;
11055
11056	// Implicit attachments go on the list for deletion and back references are removed.
11057	if (pAtt->i_isImplicit())
11058	{
11059	/* Deassociate and mark for deletion */
11060	LogFlowThisFunc(("Detaching '%s', pending deletion\n", pAtt->i_getLogName()));
11061	rc = pMedium->i_removeBackReference(mData->mUuid);
11062	if (FAILED(rc))
11063	throw rc;
11064	implicitAtts.push_back(pAtt);
11065	continue;
11066	}
11067
11068	/* Was this medium attached before? */
11069	if (!i_findAttachment(oldAtts, pMedium))
11070	{
11071	/* no: de-associate */
11072	LogFlowThisFunc(("Detaching '%s', no deletion\n", pAtt->i_getLogName()));
11073	rc = pMedium->i_removeBackReference(mData->mUuid);
11074	if (FAILED(rc))
11075	throw rc;
11076	continue;
11077	}
11078	LogFlowThisFunc(("Not detaching '%s'\n", pAtt->i_getLogName()));
11079	}
11080
11081	/* If there are implicit attachments to delete, throw away the lock
11082	* map contents (which will unlock all media) since the medium
11083	* attachments will be rolled back. Below we need to completely
11084	* recreate the lock map anyway since it is infinitely complex to
11085	* do this incrementally (would need reconstructing each attachment
11086	* change, which would be extremely hairy). */
11087	if (implicitAtts.size() != 0)
11088	{
11089	ErrorInfoKeeper eik;
11090
11091	HRESULT rc1 = lockedMediaMap->Clear();
11092	AssertComRC(rc1);
11093	}
11094
11095	/* rollback hard disk changes */
11096	mMediumAttachments.rollback();
11097
11098	MultiResult mrc(S_OK);
11099
11100	// Delete unused implicit diffs.
11101	if (implicitAtts.size() != 0)
11102	{
11103	alock.release();
11104
11105	for (MediumAttachmentList::const_iterator
11106	it = implicitAtts.begin();
11107	it != implicitAtts.end();
11108	++it)
11109	{
11110	// Remove medium associated with this attachment.
11111	ComObjPtr<MediumAttachment> pAtt = *it;
11112	Assert(pAtt);
11113	LogFlowThisFunc(("Deleting '%s'\n", pAtt->i_getLogName()));
11114	ComObjPtr<Medium> pMedium = pAtt->i_getMedium();
11115	Assert(pMedium);
11116
11117	rc = pMedium->i_deleteStorage(NULL /aProgress/, true /aWait/);
11118	// continue on delete failure, just collect error messages
11119	AssertMsg(SUCCEEDED(rc), ("rc=%Rhrc it=%s hd=%s\n", rc, pAtt->i_getLogName(),
11120	pMedium->i_getLocationFull().c_str() ));
11121	mrc = rc;
11122	}
11123	// Clear the list of deleted implicit attachments now, while not
11124	// holding the lock, as it will ultimately trigger Medium::uninit()
11125	// calls which assume that the media tree lock isn't held.
11126	implicitAtts.clear();
11127
11128	alock.acquire();
11129
11130	/* if there is a VM recreate media lock map as mentioned above,
11131	* otherwise it is a waste of time and we leave things unlocked */
11132	if (aOnline)
11133	{
11134	const ComObjPtr<SessionMachine> pMachine = mData->mSession.mMachine;
11135	/* must never be NULL, but better safe than sorry */
11136	if (!pMachine.isNull())
11137	{
11138	alock.release();
11139	rc = mData->mSession.mMachine->i_lockMedia();
11140	alock.acquire();
11141	if (FAILED(rc))
11142	throw rc;
11143	}
11144	}
11145	}
11146	}
11147	catch (HRESULT aRC) {rc = aRC;}
11148
11149	if (mData->mMachineState == MachineState_SettingUp)
11150	i_setMachineState(oldState);
11151
11152	/* unlock all hard disks we locked when there is no VM */
11153	if (!aOnline)
11154	{
11155	ErrorInfoKeeper eik;
11156
11157	HRESULT rc1 = lockedMediaMap->Clear();
11158	AssertComRC(rc1);
11159	}
11160
11161	return rc;
11162	}
11163
11164
11165	/**
11166	* Looks through the given list of media attachments for one with the given parameters
11167	* and returns it, or NULL if not found. The list is a parameter so that backup lists
11168	* can be searched as well if needed.
11169	*
11170	* @param ll
11171	* @param aControllerName
11172	* @param aControllerPort
11173	* @param aDevice
11174	* @return
11175	*/
11176	MediumAttachment *Machine::i_findAttachment(const MediumAttachmentList &ll,
11177	const Utf8Str &aControllerName,
11178	LONG aControllerPort,
11179	LONG aDevice)
11180	{
11181	for (MediumAttachmentList::const_iterator
11182	it = ll.begin();
11183	it != ll.end();
11184	++it)
11185	{
11186	MediumAttachment pAttach = it;
11187	if (pAttach->i_matches(aControllerName, aControllerPort, aDevice))
11188	return pAttach;
11189	}
11190
11191	return NULL;
11192	}
11193
11194	/**
11195	* Looks through the given list of media attachments for one with the given parameters
11196	* and returns it, or NULL if not found. The list is a parameter so that backup lists
11197	* can be searched as well if needed.
11198	*
11199	* @param ll
11200	* @param pMedium
11201	* @return
11202	*/
11203	MediumAttachment *Machine::i_findAttachment(const MediumAttachmentList &ll,
11204	ComObjPtr<Medium> pMedium)
11205	{
11206	for (MediumAttachmentList::const_iterator
11207	it = ll.begin();
11208	it != ll.end();
11209	++it)
11210	{
11211	MediumAttachment pAttach = it;
11212	ComObjPtr<Medium> pMediumThis = pAttach->i_getMedium();
11213	if (pMediumThis == pMedium)
11214	return pAttach;
11215	}
11216
11217	return NULL;
11218	}
11219
11220	/**
11221	* Looks through the given list of media attachments for one with the given parameters
11222	* and returns it, or NULL if not found. The list is a parameter so that backup lists
11223	* can be searched as well if needed.
11224	*
11225	* @param ll
11226	* @param id
11227	* @return
11228	*/
11229	MediumAttachment *Machine::i_findAttachment(const MediumAttachmentList &ll,
11230	Guid &id)
11231	{
11232	for (MediumAttachmentList::const_iterator
11233	it = ll.begin();
11234	it != ll.end();
11235	++it)
11236	{
11237	MediumAttachment pAttach = it;
11238	ComObjPtr<Medium> pMediumThis = pAttach->i_getMedium();
11239	if (pMediumThis->i_getId() == id)
11240	return pAttach;
11241	}
11242
11243	return NULL;
11244	}
11245
11246	/**
11247	* Main implementation for Machine::DetachDevice. This also gets called
11248	* from Machine::prepareUnregister() so it has been taken out for simplicity.
11249	*
11250	* @param pAttach Medium attachment to detach.
11251	* @param writeLock Machine write lock which the caller must have locked once.
11252	* This may be released temporarily in here.
11253	* @param pSnapshot If NULL, then the detachment is for the current machine.
11254	* Otherwise this is for a SnapshotMachine, and this must be
11255	* its snapshot.
11256	* @return
11257	*/
11258	HRESULT Machine::i_detachDevice(MediumAttachment *pAttach,
11259	AutoWriteLock &writeLock,
11260	Snapshot *pSnapshot)
11261	{
11262	ComObjPtr<Medium> oldmedium = pAttach->i_getMedium();
11263	DeviceType_T mediumType = pAttach->i_getType();
11264
11265	LogFlowThisFunc(("Entering, medium of attachment is %s\n", oldmedium ? oldmedium->i_getLocationFull().c_str() : "NULL"));
11266
11267	if (pAttach->i_isImplicit())
11268	{
11269	/* attempt to implicitly delete the implicitly created diff */
11270
11271	/// @todo move the implicit flag from MediumAttachment to Medium
11272	/// and forbid any hard disk operation when it is implicit. Or maybe
11273	/// a special media state for it to make it even more simple.
11274
11275	Assert(mMediumAttachments.isBackedUp());
11276
11277	/* will release the lock before the potentially lengthy operation, so
11278	* protect with the special state */
11279	MachineState_T oldState = mData->mMachineState;
11280	i_setMachineState(MachineState_SettingUp);
11281
11282	writeLock.release();
11283
11284	HRESULT rc = oldmedium->i_deleteStorage(NULL /aProgress/,
11285	true /aWait/);
11286
11287	writeLock.acquire();
11288
11289	i_setMachineState(oldState);
11290
11291	if (FAILED(rc)) return rc;
11292	}
11293
11294	i_setModified(IsModified_Storage);
11295	mMediumAttachments.backup();
11296	mMediumAttachments->remove(pAttach);
11297
11298	if (!oldmedium.isNull())
11299	{
11300	// if this is from a snapshot, do not defer detachment to i_commitMedia()
11301	if (pSnapshot)
11302	oldmedium->i_removeBackReference(mData->mUuid, pSnapshot->i_getId());
11303	// else if non-hard disk media, do not defer detachment to i_commitMedia() either
11304	else if (mediumType != DeviceType_HardDisk)
11305	oldmedium->i_removeBackReference(mData->mUuid);
11306	}
11307
11308	return S_OK;
11309	}
11310
11311	/**
11312	* Goes thru all media of the given list and
11313	*
11314	* 1) calls i_detachDevice() on each of them for this machine and
11315	* 2) adds all Medium objects found in the process to the given list,
11316	* depending on cleanupMode.
11317	*
11318	* If cleanupMode is CleanupMode_DetachAllReturnHardDisksOnly, this only
11319	* adds hard disks to the list. If it is CleanupMode_Full, this adds all
11320	* media to the list.
11321	*
11322	* This gets called from Machine::Unregister, both for the actual Machine and
11323	* the SnapshotMachine objects that might be found in the snapshots.
11324	*
11325	* Requires caller and locking. The machine lock must be passed in because it
11326	* will be passed on to i_detachDevice which needs it for temporary unlocking.
11327	*
11328	* @param writeLock Machine lock from top-level caller; this gets passed to
11329	* i_detachDevice.
11330	* @param pSnapshot Must be NULL when called for a "real" Machine or a snapshot
11331	* object if called for a SnapshotMachine.
11332	* @param cleanupMode If DetachAllReturnHardDisksOnly, only hard disk media get
11333	* added to llMedia; if Full, then all media get added;
11334	* otherwise no media get added.
11335	* @param llMedia Caller's list to receive Medium objects which got detached so
11336	* caller can close() them, depending on cleanupMode.
11337	* @return
11338	*/
11339	HRESULT Machine::i_detachAllMedia(AutoWriteLock &writeLock,
11340	Snapshot *pSnapshot,
11341	CleanupMode_T cleanupMode,
11342	MediaList &llMedia)
11343	{
11344	Assert(isWriteLockOnCurrentThread());
11345
11346	HRESULT rc;
11347
11348	// make a temporary list because i_detachDevice invalidates iterators into
11349	// mMediumAttachments
11350	MediumAttachmentList llAttachments2 = *mMediumAttachments.data();
11351
11352	for (MediumAttachmentList::iterator
11353	it = llAttachments2.begin();
11354	it != llAttachments2.end();
11355	++it)
11356	{
11357	ComObjPtr<MediumAttachment> &pAttach = *it;
11358	ComObjPtr<Medium> pMedium = pAttach->i_getMedium();
11359
11360	if (!pMedium.isNull())
11361	{
11362	AutoCaller mac(pMedium);
11363	if (FAILED(mac.rc())) return mac.rc();
11364	AutoReadLock lock(pMedium COMMA_LOCKVAL_SRC_POS);
11365	DeviceType_T devType = pMedium->i_getDeviceType();
11366	if ( ( cleanupMode == CleanupMode_DetachAllReturnHardDisksOnly
11367	&& devType == DeviceType_HardDisk)
11368	\|\| (cleanupMode == CleanupMode_Full)
11369	)
11370	{
11371	llMedia.push_back(pMedium);
11372	ComObjPtr<Medium> pParent = pMedium->i_getParent();
11373	/* Not allowed to keep this lock as below we need the parent
11374	* medium lock, and the lock order is parent to child. */
11375	lock.release();
11376	/*
11377	* Search for medias which are not attached to any machine, but
11378	* in the chain to an attached disk. Mediums are only consided
11379	* if they are:
11380	* - have only one child
11381	* - no references to any machines
11382	* - are of normal medium type
11383	*/
11384	while (!pParent.isNull())
11385	{
11386	AutoCaller mac1(pParent);
11387	if (FAILED(mac1.rc())) return mac1.rc();
11388	AutoReadLock lock1(pParent COMMA_LOCKVAL_SRC_POS);
11389	if (pParent->i_getChildren().size() == 1)
11390	{
11391	if ( pParent->i_getMachineBackRefCount() == 0
11392	&& pParent->i_getType() == MediumType_Normal
11393	&& find(llMedia.begin(), llMedia.end(), pParent) == llMedia.end())
11394	llMedia.push_back(pParent);
11395	}
11396	else
11397	break;
11398	pParent = pParent->i_getParent();
11399	}
11400	}
11401	}
11402
11403	// real machine: then we need to use the proper method
11404	rc = i_detachDevice(pAttach, writeLock, pSnapshot);
11405
11406	if (FAILED(rc))
11407	return rc;
11408	}
11409
11410	return S_OK;
11411	}
11412
11413	/**
11414	* Perform deferred hard disk detachments.
11415	*
11416	* Does nothing if the hard disk attachment data (mMediumAttachments) is not
11417	* changed (not backed up).
11418	*
11419	* If @a aOnline is @c true then this method will also unlock the old hard
11420	* disks for which the new implicit diffs were created and will lock these new
11421	* diffs for writing.
11422	*
11423	* @param aOnline Whether the VM was online prior to this operation.
11424	*
11425	* @note Locks this object for writing!
11426	*/
11427	void Machine::i_commitMedia(bool aOnline /= false/)
11428	{
11429	AutoCaller autoCaller(this);
11430	AssertComRCReturnVoid(autoCaller.rc());
11431
11432	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
11433
11434	LogFlowThisFunc(("Entering, aOnline=%d\n", aOnline));
11435
11436	HRESULT rc = S_OK;
11437
11438	/* no attach/detach operations -- nothing to do */
11439	if (!mMediumAttachments.isBackedUp())
11440	return;
11441
11442	MediumAttachmentList &oldAtts = *mMediumAttachments.backedUpData();
11443	bool fMediaNeedsLocking = false;
11444
11445	/* enumerate new attachments */
11446	for (MediumAttachmentList::const_iterator
11447	it = mMediumAttachments->begin();
11448	it != mMediumAttachments->end();
11449	++it)
11450	{
11451	MediumAttachment pAttach = it;
11452
11453	pAttach->i_commit();
11454
11455	Medium *pMedium = pAttach->i_getMedium();
11456	bool fImplicit = pAttach->i_isImplicit();
11457
11458	LogFlowThisFunc(("Examining current medium '%s' (implicit: %d)\n",
11459	(pMedium) ? pMedium->i_getName().c_str() : "NULL",
11460	fImplicit));
11461
11462	/** @todo convert all this Machine-based voodoo to MediumAttachment
11463	* based commit logic. */
11464	if (fImplicit)
11465	{
11466	/* convert implicit attachment to normal */
11467	pAttach->i_setImplicit(false);
11468
11469	if ( aOnline
11470	&& pMedium
11471	&& pAttach->i_getType() == DeviceType_HardDisk
11472	)
11473	{
11474	/* update the appropriate lock list */
11475	MediumLockList *pMediumLockList;
11476	rc = mData->mSession.mLockedMedia.Get(pAttach, pMediumLockList);
11477	AssertComRC(rc);
11478	if (pMediumLockList)
11479	{
11480	/* unlock if there's a need to change the locking */
11481	if (!fMediaNeedsLocking)
11482	{
11483	rc = mData->mSession.mLockedMedia.Unlock();
11484	AssertComRC(rc);
11485	fMediaNeedsLocking = true;
11486	}
11487	rc = pMediumLockList->Update(pMedium->i_getParent(), false);
11488	AssertComRC(rc);
11489	rc = pMediumLockList->Append(pMedium, true);
11490	AssertComRC(rc);
11491	}
11492	}
11493
11494	continue;
11495	}
11496
11497	if (pMedium)
11498	{
11499	/* was this medium attached before? */
11500	for (MediumAttachmentList::iterator
11501	oldIt = oldAtts.begin();
11502	oldIt != oldAtts.end();
11503	++oldIt)
11504	{
11505	MediumAttachment pOldAttach = oldIt;
11506	if (pOldAttach->i_getMedium() == pMedium)
11507	{
11508	LogFlowThisFunc(("--> medium '%s' was attached before, will not remove\n", pMedium->i_getName().c_str()));
11509
11510	/* yes: remove from old to avoid de-association */
11511	oldAtts.erase(oldIt);
11512	break;
11513	}
11514	}
11515	}
11516	}
11517
11518	/* enumerate remaining old attachments and de-associate from the
11519	* current machine state */
11520	for (MediumAttachmentList::const_iterator
11521	it = oldAtts.begin();
11522	it != oldAtts.end();
11523	++it)
11524	{
11525	MediumAttachment pAttach = it;
11526	Medium *pMedium = pAttach->i_getMedium();
11527
11528	/* Detach only hard disks, since DVD/floppy media is detached
11529	* instantly in MountMedium. */
11530	if (pAttach->i_getType() == DeviceType_HardDisk && pMedium)
11531	{
11532	LogFlowThisFunc(("detaching medium '%s' from machine\n", pMedium->i_getName().c_str()));
11533
11534	/* now de-associate from the current machine state */
11535	rc = pMedium->i_removeBackReference(mData->mUuid);
11536	AssertComRC(rc);
11537
11538	if (aOnline)
11539	{
11540	/* unlock since medium is not used anymore */
11541	MediumLockList *pMediumLockList;
11542	rc = mData->mSession.mLockedMedia.Get(pAttach, pMediumLockList);
11543	if (RT_UNLIKELY(rc == VBOX_E_INVALID_OBJECT_STATE))
11544	{
11545	/* this happens for online snapshots, there the attachment
11546	* is changing, but only to a diff image created under
11547	* the old one, so there is no separate lock list */
11548	Assert(!pMediumLockList);
11549	}
11550	else
11551	{
11552	AssertComRC(rc);
11553	if (pMediumLockList)
11554	{
11555	rc = mData->mSession.mLockedMedia.Remove(pAttach);
11556	AssertComRC(rc);
11557	}
11558	}
11559	}
11560	}
11561	}
11562
11563	/* take media locks again so that the locking state is consistent */
11564	if (fMediaNeedsLocking)
11565	{
11566	Assert(aOnline);
11567	rc = mData->mSession.mLockedMedia.Lock();
11568	AssertComRC(rc);
11569	}
11570
11571	/* commit the hard disk changes */
11572	mMediumAttachments.commit();
11573
11574	if (i_isSessionMachine())
11575	{
11576	/*
11577	* Update the parent machine to point to the new owner.
11578	* This is necessary because the stored parent will point to the
11579	* session machine otherwise and cause crashes or errors later
11580	* when the session machine gets invalid.
11581	*/
11582	/** @todo Change the MediumAttachment class to behave like any other
11583	* class in this regard by creating peer MediumAttachment
11584	* objects for session machines and share the data with the peer
11585	* machine.
11586	*/
11587	for (MediumAttachmentList::const_iterator
11588	it = mMediumAttachments->begin();
11589	it != mMediumAttachments->end();
11590	++it)
11591	(*it)->i_updateParentMachine(mPeer);
11592
11593	/* attach new data to the primary machine and reshare it */
11594	mPeer->mMediumAttachments.attach(mMediumAttachments);
11595	}
11596
11597	return;
11598	}
11599
11600	/**
11601	* Perform deferred deletion of implicitly created diffs.
11602	*
11603	* Does nothing if the hard disk attachment data (mMediumAttachments) is not
11604	* changed (not backed up).
11605	*
11606	* @note Locks this object for writing!
11607	*/
11608	void Machine::i_rollbackMedia()
11609	{
11610	AutoCaller autoCaller(this);
11611	AssertComRCReturnVoid(autoCaller.rc());
11612
11613	// AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
11614	LogFlowThisFunc(("Entering rollbackMedia\n"));
11615
11616	HRESULT rc = S_OK;
11617
11618	/* no attach/detach operations -- nothing to do */
11619	if (!mMediumAttachments.isBackedUp())
11620	return;
11621
11622	/* enumerate new attachments */
11623	for (MediumAttachmentList::const_iterator
11624	it = mMediumAttachments->begin();
11625	it != mMediumAttachments->end();
11626	++it)
11627	{
11628	MediumAttachment pAttach = it;
11629	/* Fix up the backrefs for DVD/floppy media. */
11630	if (pAttach->i_getType() != DeviceType_HardDisk)
11631	{
11632	Medium *pMedium = pAttach->i_getMedium();
11633	if (pMedium)
11634	{
11635	rc = pMedium->i_removeBackReference(mData->mUuid);
11636	AssertComRC(rc);
11637	}
11638	}
11639
11640	(*it)->i_rollback();
11641
11642	pAttach = *it;
11643	/* Fix up the backrefs for DVD/floppy media. */
11644	if (pAttach->i_getType() != DeviceType_HardDisk)
11645	{
11646	Medium *pMedium = pAttach->i_getMedium();
11647	if (pMedium)
11648	{
11649	rc = pMedium->i_addBackReference(mData->mUuid);
11650	AssertComRC(rc);
11651	}
11652	}
11653	}
11654
11655	/** @todo convert all this Machine-based voodoo to MediumAttachment
11656	* based rollback logic. */
11657	i_deleteImplicitDiffs(Global::IsOnline(mData->mMachineState));
11658
11659	return;
11660	}
11661
11662	/**
11663	* Returns true if the settings file is located in the directory named exactly
11664	* as the machine; this means, among other things, that the machine directory
11665	* should be auto-renamed.
11666	*
11667	* @param aSettingsDir if not NULL, the full machine settings file directory
11668	* name will be assigned there.
11669	*
11670	* @note Doesn't lock anything.
11671	* @note Not thread safe (must be called from this object's lock).
11672	*/
11673	bool Machine::i_isInOwnDir(Utf8Str aSettingsDir / = NULL */) const
11674	{
11675	Utf8Str strMachineDirName(mData->m_strConfigFileFull); // path/to/machinesfolder/vmname/vmname.vbox
11676	strMachineDirName.stripFilename(); // path/to/machinesfolder/vmname
11677	if (aSettingsDir)
11678	*aSettingsDir = strMachineDirName;
11679	strMachineDirName.stripPath(); // vmname
11680	Utf8Str strConfigFileOnly(mData->m_strConfigFileFull); // path/to/machinesfolder/vmname/vmname.vbox
11681	strConfigFileOnly.stripPath() // vmname.vbox
11682	.stripSuffix(); // vmname
11683	/** @todo hack, make somehow use of ComposeMachineFilename */
11684	if (mUserData->s.fDirectoryIncludesUUID)
11685	strConfigFileOnly += Utf8StrFmt(" (%RTuuid)", mData->mUuid.raw());
11686
11687	AssertReturn(!strMachineDirName.isEmpty(), false);
11688	AssertReturn(!strConfigFileOnly.isEmpty(), false);
11689
11690	return strMachineDirName == strConfigFileOnly;
11691	}
11692
11693	/**
11694	* Discards all changes to machine settings.
11695	*
11696	* @param aNotify Whether to notify the direct session about changes or not.
11697	*
11698	* @note Locks objects for writing!
11699	*/
11700	void Machine::i_rollback(bool aNotify)
11701	{
11702	AutoCaller autoCaller(this);
11703	AssertComRCReturn(autoCaller.rc(), (void)0);
11704
11705	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
11706
11707	if (!mStorageControllers.isNull())
11708	{
11709	if (mStorageControllers.isBackedUp())
11710	{
11711	/* unitialize all new devices (absent in the backed up list). */
11712	StorageControllerList *backedList = mStorageControllers.backedUpData();
11713	for (StorageControllerList::const_iterator
11714	it = mStorageControllers->begin();
11715	it != mStorageControllers->end();
11716	++it)
11717	{
11718	if ( std::find(backedList->begin(), backedList->end(), *it)
11719	== backedList->end()
11720	)
11721	{
11722	(*it)->uninit();
11723	}
11724	}
11725
11726	/* restore the list */
11727	mStorageControllers.rollback();
11728	}
11729
11730	/* rollback any changes to devices after restoring the list */
11731	if (mData->flModifications & IsModified_Storage)
11732	{
11733	for (StorageControllerList::const_iterator
11734	it = mStorageControllers->begin();
11735	it != mStorageControllers->end();
11736	++it)
11737	{
11738	(*it)->i_rollback();
11739	}
11740	}
11741	}
11742
11743	if (!mUSBControllers.isNull())
11744	{
11745	if (mUSBControllers.isBackedUp())
11746	{
11747	/* unitialize all new devices (absent in the backed up list). */
11748	USBControllerList *backedList = mUSBControllers.backedUpData();
11749	for (USBControllerList::const_iterator
11750	it = mUSBControllers->begin();
11751	it != mUSBControllers->end();
11752	++it)
11753	{
11754	if ( std::find(backedList->begin(), backedList->end(), *it)
11755	== backedList->end()
11756	)
11757	{
11758	(*it)->uninit();
11759	}
11760	}
11761
11762	/* restore the list */
11763	mUSBControllers.rollback();
11764	}
11765
11766	/* rollback any changes to devices after restoring the list */
11767	if (mData->flModifications & IsModified_USB)
11768	{
11769	for (USBControllerList::const_iterator
11770	it = mUSBControllers->begin();
11771	it != mUSBControllers->end();
11772	++it)
11773	{
11774	(*it)->i_rollback();
11775	}
11776	}
11777	}
11778
11779	mUserData.rollback();
11780
11781	mHWData.rollback();
11782
11783	if (mData->flModifications & IsModified_Storage)
11784	i_rollbackMedia();
11785
11786	if (mBIOSSettings)
11787	mBIOSSettings->i_rollback();
11788
11789	if (mVRDEServer && (mData->flModifications & IsModified_VRDEServer))
11790	mVRDEServer->i_rollback();
11791
11792	if (mAudioAdapter)
11793	mAudioAdapter->i_rollback();
11794
11795	if (mUSBDeviceFilters && (mData->flModifications & IsModified_USB))
11796	mUSBDeviceFilters->i_rollback();
11797
11798	if (mBandwidthControl && (mData->flModifications & IsModified_BandwidthControl))
11799	mBandwidthControl->i_rollback();
11800
11801	if (!mHWData.isNull())
11802	mNetworkAdapters.resize(Global::getMaxNetworkAdapters(mHWData->mChipsetType));
11803	NetworkAdapterVector networkAdapters(mNetworkAdapters.size());
11804	ComPtr<ISerialPort> serialPorts[RT_ELEMENTS(mSerialPorts)];
11805	ComPtr<IParallelPort> parallelPorts[RT_ELEMENTS(mParallelPorts)];
11806
11807	if (mData->flModifications & IsModified_NetworkAdapters)
11808	for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
11809	if ( mNetworkAdapters[slot]
11810	&& mNetworkAdapters[slot]->i_isModified())
11811	{
11812	mNetworkAdapters[slot]->i_rollback();
11813	networkAdapters[slot] = mNetworkAdapters[slot];
11814	}
11815
11816	if (mData->flModifications & IsModified_SerialPorts)
11817	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
11818	if ( mSerialPorts[slot]
11819	&& mSerialPorts[slot]->i_isModified())
11820	{
11821	mSerialPorts[slot]->i_rollback();
11822	serialPorts[slot] = mSerialPorts[slot];
11823	}
11824
11825	if (mData->flModifications & IsModified_ParallelPorts)
11826	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
11827	if ( mParallelPorts[slot]
11828	&& mParallelPorts[slot]->i_isModified())
11829	{
11830	mParallelPorts[slot]->i_rollback();
11831	parallelPorts[slot] = mParallelPorts[slot];
11832	}
11833
11834	if (aNotify)
11835	{
11836	/* inform the direct session about changes */
11837
11838	ComObjPtr<Machine> that = this;
11839	uint32_t flModifications = mData->flModifications;
11840	alock.release();
11841
11842	if (flModifications & IsModified_SharedFolders)
11843	that->i_onSharedFolderChange();
11844
11845	if (flModifications & IsModified_VRDEServer)
11846	that->i_onVRDEServerChange(/* aRestart */ TRUE);
11847	if (flModifications & IsModified_USB)
11848	that->i_onUSBControllerChange();
11849
11850	for (ULONG slot = 0; slot < networkAdapters.size(); ++slot)
11851	if (networkAdapters[slot])
11852	that->i_onNetworkAdapterChange(networkAdapters[slot], FALSE);
11853	for (ULONG slot = 0; slot < RT_ELEMENTS(serialPorts); ++slot)
11854	if (serialPorts[slot])
11855	that->i_onSerialPortChange(serialPorts[slot]);
11856	for (ULONG slot = 0; slot < RT_ELEMENTS(parallelPorts); ++slot)
11857	if (parallelPorts[slot])
11858	that->i_onParallelPortChange(parallelPorts[slot]);
11859
11860	if (flModifications & IsModified_Storage)
11861	that->i_onStorageControllerChange();
11862
11863	#if 0
11864	if (flModifications & IsModified_BandwidthControl)
11865	that->onBandwidthControlChange();
11866	#endif
11867	}
11868	}
11869
11870	/**
11871	* Commits all the changes to machine settings.
11872	*
11873	* Note that this operation is supposed to never fail.
11874	*
11875	* @note Locks this object and children for writing.
11876	*/
11877	void Machine::i_commit()
11878	{
11879	AutoCaller autoCaller(this);
11880	AssertComRCReturnVoid(autoCaller.rc());
11881
11882	AutoCaller peerCaller(mPeer);
11883	AssertComRCReturnVoid(peerCaller.rc());
11884
11885	AutoMultiWriteLock2 alock(mPeer, this COMMA_LOCKVAL_SRC_POS);
11886
11887	/*
11888	* use safe commit to ensure Snapshot machines (that share mUserData)
11889	* will still refer to a valid memory location
11890	*/
11891	mUserData.commitCopy();
11892
11893	mHWData.commit();
11894
11895	if (mMediumAttachments.isBackedUp())
11896	i_commitMedia(Global::IsOnline(mData->mMachineState));
11897
11898	mBIOSSettings->i_commit();
11899	mVRDEServer->i_commit();
11900	mAudioAdapter->i_commit();
11901	mUSBDeviceFilters->i_commit();
11902	mBandwidthControl->i_commit();
11903
11904	/* Since mNetworkAdapters is a list which might have been changed (resized)
11905	* without using the Backupable<> template we need to handle the copying
11906	* of the list entries manually, including the creation of peers for the
11907	* new objects. */
11908	bool commitNetworkAdapters = false;
11909	size_t newSize = Global::getMaxNetworkAdapters(mHWData->mChipsetType);
11910	if (mPeer)
11911	{
11912	/* commit everything, even the ones which will go away */
11913	for (size_t slot = 0; slot < mNetworkAdapters.size(); slot++)
11914	mNetworkAdapters[slot]->i_commit();
11915	/* copy over the new entries, creating a peer and uninit the original */
11916	mPeer->mNetworkAdapters.resize(RT_MAX(newSize, mPeer->mNetworkAdapters.size()));
11917	for (size_t slot = 0; slot < newSize; slot++)
11918	{
11919	/* look if this adapter has a peer device */
11920	ComObjPtr<NetworkAdapter> peer = mNetworkAdapters[slot]->i_getPeer();
11921	if (!peer)
11922	{
11923	/* no peer means the adapter is a newly created one;
11924	* create a peer owning data this data share it with */
11925	peer.createObject();
11926	peer->init(mPeer, mNetworkAdapters[slot], true /* aReshare */);
11927	}
11928	mPeer->mNetworkAdapters[slot] = peer;
11929	}
11930	/* uninit any no longer needed network adapters */
11931	for (size_t slot = newSize; slot < mNetworkAdapters.size(); ++slot)
11932	mNetworkAdapters[slot]->uninit();
11933	for (size_t slot = newSize; slot < mPeer->mNetworkAdapters.size(); ++slot)
11934	{
11935	if (mPeer->mNetworkAdapters[slot])
11936	mPeer->mNetworkAdapters[slot]->uninit();
11937	}
11938	/* Keep the original network adapter count until this point, so that
11939	* discarding a chipset type change will not lose settings. */
11940	mNetworkAdapters.resize(newSize);
11941	mPeer->mNetworkAdapters.resize(newSize);
11942	}
11943	else
11944	{
11945	/* we have no peer (our parent is the newly created machine);
11946	* just commit changes to the network adapters */
11947	commitNetworkAdapters = true;
11948	}
11949	if (commitNetworkAdapters)
11950	for (size_t slot = 0; slot < mNetworkAdapters.size(); ++slot)
11951	mNetworkAdapters[slot]->i_commit();
11952
11953	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
11954	mSerialPorts[slot]->i_commit();
11955	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
11956	mParallelPorts[slot]->i_commit();
11957
11958	bool commitStorageControllers = false;
11959
11960	if (mStorageControllers.isBackedUp())
11961	{
11962	mStorageControllers.commit();
11963
11964	if (mPeer)
11965	{
11966	/* Commit all changes to new controllers (this will reshare data with
11967	* peers for those who have peers) */
11968	StorageControllerList *newList = new StorageControllerList();
11969	for (StorageControllerList::const_iterator
11970	it = mStorageControllers->begin();
11971	it != mStorageControllers->end();
11972	++it)
11973	{
11974	(*it)->i_commit();
11975
11976	/* look if this controller has a peer device */
11977	ComObjPtr<StorageController> peer = (*it)->i_getPeer();
11978	if (!peer)
11979	{
11980	/* no peer means the device is a newly created one;
11981	* create a peer owning data this device share it with */
11982	peer.createObject();
11983	peer->init(mPeer, it, true / aReshare */);
11984	}
11985	else
11986	{
11987	/* remove peer from the old list */
11988	mPeer->mStorageControllers->remove(peer);
11989	}
11990	/* and add it to the new list */
11991	newList->push_back(peer);
11992	}
11993
11994	/* uninit old peer's controllers that are left */
11995	for (StorageControllerList::const_iterator
11996	it = mPeer->mStorageControllers->begin();
11997	it != mPeer->mStorageControllers->end();
11998	++it)
11999	{
12000	(*it)->uninit();
12001	}
12002
12003	/* attach new list of controllers to our peer */
12004	mPeer->mStorageControllers.attach(newList);
12005	}
12006	else
12007	{
12008	/* we have no peer (our parent is the newly created machine);
12009	* just commit changes to devices */
12010	commitStorageControllers = true;
12011	}
12012	}
12013	else
12014	{
12015	/* the list of controllers itself is not changed,
12016	* just commit changes to controllers themselves */
12017	commitStorageControllers = true;
12018	}
12019
12020	if (commitStorageControllers)
12021	{
12022	for (StorageControllerList::const_iterator
12023	it = mStorageControllers->begin();
12024	it != mStorageControllers->end();
12025	++it)
12026	{
12027	(*it)->i_commit();
12028	}
12029	}
12030
12031	bool commitUSBControllers = false;
12032
12033	if (mUSBControllers.isBackedUp())
12034	{
12035	mUSBControllers.commit();
12036
12037	if (mPeer)
12038	{
12039	/* Commit all changes to new controllers (this will reshare data with
12040	* peers for those who have peers) */
12041	USBControllerList *newList = new USBControllerList();
12042	for (USBControllerList::const_iterator
12043	it = mUSBControllers->begin();
12044	it != mUSBControllers->end();
12045	++it)
12046	{
12047	(*it)->i_commit();
12048
12049	/* look if this controller has a peer device */
12050	ComObjPtr<USBController> peer = (*it)->i_getPeer();
12051	if (!peer)
12052	{
12053	/* no peer means the device is a newly created one;
12054	* create a peer owning data this device share it with */
12055	peer.createObject();
12056	peer->init(mPeer, it, true / aReshare */);
12057	}
12058	else
12059	{
12060	/* remove peer from the old list */
12061	mPeer->mUSBControllers->remove(peer);
12062	}
12063	/* and add it to the new list */
12064	newList->push_back(peer);
12065	}
12066
12067	/* uninit old peer's controllers that are left */
12068	for (USBControllerList::const_iterator
12069	it = mPeer->mUSBControllers->begin();
12070	it != mPeer->mUSBControllers->end();
12071	++it)
12072	{
12073	(*it)->uninit();
12074	}
12075
12076	/* attach new list of controllers to our peer */
12077	mPeer->mUSBControllers.attach(newList);
12078	}
12079	else
12080	{
12081	/* we have no peer (our parent is the newly created machine);
12082	* just commit changes to devices */
12083	commitUSBControllers = true;
12084	}
12085	}
12086	else
12087	{
12088	/* the list of controllers itself is not changed,
12089	* just commit changes to controllers themselves */
12090	commitUSBControllers = true;
12091	}
12092
12093	if (commitUSBControllers)
12094	{
12095	for (USBControllerList::const_iterator
12096	it = mUSBControllers->begin();
12097	it != mUSBControllers->end();
12098	++it)
12099	{
12100	(*it)->i_commit();
12101	}
12102	}
12103
12104	if (i_isSessionMachine())
12105	{
12106	/* attach new data to the primary machine and reshare it */
12107	mPeer->mUserData.attach(mUserData);
12108	mPeer->mHWData.attach(mHWData);
12109	/* mmMediumAttachments is reshared by fixupMedia */
12110	// mPeer->mMediumAttachments.attach(mMediumAttachments);
12111	Assert(mPeer->mMediumAttachments.data() == mMediumAttachments.data());
12112	}
12113	}
12114
12115	/**
12116	* Copies all the hardware data from the given machine.
12117	*
12118	* Currently, only called when the VM is being restored from a snapshot. In
12119	* particular, this implies that the VM is not running during this method's
12120	* call.
12121	*
12122	* @note This method must be called from under this object's lock.
12123	*
12124	* @note This method doesn't call #i_commit(), so all data remains backed up and
12125	* unsaved.
12126	*/
12127	void Machine::i_copyFrom(Machine *aThat)
12128	{
12129	AssertReturnVoid(!i_isSnapshotMachine());
12130	AssertReturnVoid(aThat->i_isSnapshotMachine());
12131
12132	AssertReturnVoid(!Global::IsOnline(mData->mMachineState));
12133
12134	mHWData.assignCopy(aThat->mHWData);
12135
12136	// create copies of all shared folders (mHWData after attaching a copy
12137	// contains just references to original objects)
12138	for (HWData::SharedFolderList::iterator
12139	it = mHWData->mSharedFolders.begin();
12140	it != mHWData->mSharedFolders.end();
12141	++it)
12142	{
12143	ComObjPtr<SharedFolder> folder;
12144	folder.createObject();
12145	HRESULT rc = folder->initCopy(i_getMachine(), *it);
12146	AssertComRC(rc);
12147	*it = folder;
12148	}
12149
12150	mBIOSSettings->i_copyFrom(aThat->mBIOSSettings);
12151	mVRDEServer->i_copyFrom(aThat->mVRDEServer);
12152	mAudioAdapter->i_copyFrom(aThat->mAudioAdapter);
12153	mUSBDeviceFilters->i_copyFrom(aThat->mUSBDeviceFilters);
12154	mBandwidthControl->i_copyFrom(aThat->mBandwidthControl);
12155
12156	/* create private copies of all controllers */
12157	mStorageControllers.backup();
12158	mStorageControllers->clear();
12159	for (StorageControllerList::const_iterator
12160	it = aThat->mStorageControllers->begin();
12161	it != aThat->mStorageControllers->end();
12162	++it)
12163	{
12164	ComObjPtr<StorageController> ctrl;
12165	ctrl.createObject();
12166	ctrl->initCopy(this, *it);
12167	mStorageControllers->push_back(ctrl);
12168	}
12169
12170	/* create private copies of all USB controllers */
12171	mUSBControllers.backup();
12172	mUSBControllers->clear();
12173	for (USBControllerList::const_iterator
12174	it = aThat->mUSBControllers->begin();
12175	it != aThat->mUSBControllers->end();
12176	++it)
12177	{
12178	ComObjPtr<USBController> ctrl;
12179	ctrl.createObject();
12180	ctrl->initCopy(this, *it);
12181	mUSBControllers->push_back(ctrl);
12182	}
12183
12184	mNetworkAdapters.resize(aThat->mNetworkAdapters.size());
12185	for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
12186	{
12187	if (mNetworkAdapters[slot].isNotNull())
12188	mNetworkAdapters[slot]->i_copyFrom(aThat->mNetworkAdapters[slot]);
12189	else
12190	{
12191	unconst(mNetworkAdapters[slot]).createObject();
12192	mNetworkAdapters[slot]->initCopy(this, aThat->mNetworkAdapters[slot]);
12193	}
12194	}
12195	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
12196	mSerialPorts[slot]->i_copyFrom(aThat->mSerialPorts[slot]);
12197	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
12198	mParallelPorts[slot]->i_copyFrom(aThat->mParallelPorts[slot]);
12199	}
12200
12201	/**
12202	* Returns whether the given storage controller is hotplug capable.
12203	*
12204	* @returns true if the controller supports hotplugging
12205	* false otherwise.
12206	* @param enmCtrlType The controller type to check for.
12207	*/
12208	bool Machine::i_isControllerHotplugCapable(StorageControllerType_T enmCtrlType)
12209	{
12210	ComPtr<ISystemProperties> systemProperties;
12211	HRESULT rc = mParent->COMGETTER(SystemProperties)(systemProperties.asOutParam());
12212	if (FAILED(rc))
12213	return false;
12214
12215	BOOL aHotplugCapable = FALSE;
12216	systemProperties->GetStorageControllerHotplugCapable(enmCtrlType, &aHotplugCapable);
12217
12218	return RT_BOOL(aHotplugCapable);
12219	}
12220
12221	#ifdef VBOX_WITH_RESOURCE_USAGE_API
12222
12223	void Machine::i_getDiskList(MediaList &list)
12224	{
12225	for (MediumAttachmentList::const_iterator
12226	it = mMediumAttachments->begin();
12227	it != mMediumAttachments->end();
12228	++it)
12229	{
12230	MediumAttachment pAttach = it;
12231	/* just in case */
12232	AssertContinue(pAttach);
12233
12234	AutoCaller localAutoCallerA(pAttach);
12235	if (FAILED(localAutoCallerA.rc())) continue;
12236
12237	AutoReadLock local_alockA(pAttach COMMA_LOCKVAL_SRC_POS);
12238
12239	if (pAttach->i_getType() == DeviceType_HardDisk)
12240	list.push_back(pAttach->i_getMedium());
12241	}
12242	}
12243
12244	void Machine::i_registerMetrics(PerformanceCollector aCollector, Machine aMachine, RTPROCESS pid)
12245	{
12246	AssertReturnVoid(isWriteLockOnCurrentThread());
12247	AssertPtrReturnVoid(aCollector);
12248
12249	pm::CollectorHAL *hal = aCollector->getHAL();
12250	/* Create sub metrics */
12251	pm::SubMetric *cpuLoadUser = new pm::SubMetric("CPU/Load/User",
12252	"Percentage of processor time spent in user mode by the VM process.");
12253	pm::SubMetric *cpuLoadKernel = new pm::SubMetric("CPU/Load/Kernel",
12254	"Percentage of processor time spent in kernel mode by the VM process.");
12255	pm::SubMetric *ramUsageUsed = new pm::SubMetric("RAM/Usage/Used",
12256	"Size of resident portion of VM process in memory.");
12257	pm::SubMetric *diskUsageUsed = new pm::SubMetric("Disk/Usage/Used",
12258	"Actual size of all VM disks combined.");
12259	pm::SubMetric *machineNetRx = new pm::SubMetric("Net/Rate/Rx",
12260	"Network receive rate.");
12261	pm::SubMetric *machineNetTx = new pm::SubMetric("Net/Rate/Tx",
12262	"Network transmit rate.");
12263	/* Create and register base metrics */
12264	pm::BaseMetric *cpuLoad = new pm::MachineCpuLoadRaw(hal, aMachine, pid,
12265	cpuLoadUser, cpuLoadKernel);
12266	aCollector->registerBaseMetric(cpuLoad);
12267	pm::BaseMetric *ramUsage = new pm::MachineRamUsage(hal, aMachine, pid,
12268	ramUsageUsed);
12269	aCollector->registerBaseMetric(ramUsage);
12270	MediaList disks;
12271	i_getDiskList(disks);
12272	pm::BaseMetric *diskUsage = new pm::MachineDiskUsage(hal, aMachine, disks,
12273	diskUsageUsed);
12274	aCollector->registerBaseMetric(diskUsage);
12275
12276	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser, 0));
12277	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
12278	new pm::AggregateAvg()));
12279	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
12280	new pm::AggregateMin()));
12281	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
12282	new pm::AggregateMax()));
12283	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel, 0));
12284	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
12285	new pm::AggregateAvg()));
12286	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
12287	new pm::AggregateMin()));
12288	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
12289	new pm::AggregateMax()));
12290
12291	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed, 0));
12292	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
12293	new pm::AggregateAvg()));
12294	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
12295	new pm::AggregateMin()));
12296	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
12297	new pm::AggregateMax()));
12298
12299	aCollector->registerMetric(new pm::Metric(diskUsage, diskUsageUsed, 0));
12300	aCollector->registerMetric(new pm::Metric(diskUsage, diskUsageUsed,
12301	new pm::AggregateAvg()));
12302	aCollector->registerMetric(new pm::Metric(diskUsage, diskUsageUsed,
12303	new pm::AggregateMin()));
12304	aCollector->registerMetric(new pm::Metric(diskUsage, diskUsageUsed,
12305	new pm::AggregateMax()));
12306
12307
12308	/* Guest metrics collector */
12309	mCollectorGuest = new pm::CollectorGuest(aMachine, pid);
12310	aCollector->registerGuest(mCollectorGuest);
12311	Log7Func(("{%p}: mCollectorGuest=%p\n", this, mCollectorGuest));
12312
12313	/* Create sub metrics */
12314	pm::SubMetric *guestLoadUser = new pm::SubMetric("Guest/CPU/Load/User",
12315	"Percentage of processor time spent in user mode as seen by the guest.");
12316	pm::SubMetric *guestLoadKernel = new pm::SubMetric("Guest/CPU/Load/Kernel",
12317	"Percentage of processor time spent in kernel mode as seen by the guest.");
12318	pm::SubMetric *guestLoadIdle = new pm::SubMetric("Guest/CPU/Load/Idle",
12319	"Percentage of processor time spent idling as seen by the guest.");
12320
12321	/* The total amount of physical ram is fixed now, but we'll support dynamic guest ram configurations in the future. */
12322	pm::SubMetric *guestMemTotal = new pm::SubMetric("Guest/RAM/Usage/Total", "Total amount of physical guest RAM.");
12323	pm::SubMetric *guestMemFree = new pm::SubMetric("Guest/RAM/Usage/Free", "Free amount of physical guest RAM.");
12324	pm::SubMetric *guestMemBalloon = new pm::SubMetric("Guest/RAM/Usage/Balloon", "Amount of ballooned physical guest RAM.");
12325	pm::SubMetric *guestMemShared = new pm::SubMetric("Guest/RAM/Usage/Shared", "Amount of shared physical guest RAM.");
12326	pm::SubMetric *guestMemCache = new pm::SubMetric(
12327	"Guest/RAM/Usage/Cache", "Total amount of guest (disk) cache memory.");
12328
12329	pm::SubMetric *guestPagedTotal = new pm::SubMetric(
12330	"Guest/Pagefile/Usage/Total", "Total amount of space in the page file.");
12331
12332	/* Create and register base metrics */
12333	pm::BaseMetric *machineNetRate = new pm::MachineNetRate(mCollectorGuest, aMachine,
12334	machineNetRx, machineNetTx);
12335	aCollector->registerBaseMetric(machineNetRate);
12336
12337	pm::BaseMetric *guestCpuLoad = new pm::GuestCpuLoad(mCollectorGuest, aMachine,
12338	guestLoadUser, guestLoadKernel, guestLoadIdle);
12339	aCollector->registerBaseMetric(guestCpuLoad);
12340
12341	pm::BaseMetric *guestCpuMem = new pm::GuestRamUsage(mCollectorGuest, aMachine,
12342	guestMemTotal, guestMemFree,
12343	guestMemBalloon, guestMemShared,
12344	guestMemCache, guestPagedTotal);
12345	aCollector->registerBaseMetric(guestCpuMem);
12346
12347	aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetRx, 0));
12348	aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetRx, new pm::AggregateAvg()));
12349	aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetRx, new pm::AggregateMin()));
12350	aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetRx, new pm::AggregateMax()));
12351
12352	aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetTx, 0));
12353	aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetTx, new pm::AggregateAvg()));
12354	aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetTx, new pm::AggregateMin()));
12355	aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetTx, new pm::AggregateMax()));
12356
12357	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadUser, 0));
12358	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadUser, new pm::AggregateAvg()));
12359	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadUser, new pm::AggregateMin()));
12360	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadUser, new pm::AggregateMax()));
12361
12362	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadKernel, 0));
12363	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadKernel, new pm::AggregateAvg()));
12364	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadKernel, new pm::AggregateMin()));
12365	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadKernel, new pm::AggregateMax()));
12366
12367	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadIdle, 0));
12368	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadIdle, new pm::AggregateAvg()));
12369	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadIdle, new pm::AggregateMin()));
12370	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadIdle, new pm::AggregateMax()));
12371
12372	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemTotal, 0));
12373	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemTotal, new pm::AggregateAvg()));
12374	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemTotal, new pm::AggregateMin()));
12375	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemTotal, new pm::AggregateMax()));
12376
12377	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemFree, 0));
12378	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemFree, new pm::AggregateAvg()));
12379	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemFree, new pm::AggregateMin()));
12380	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemFree, new pm::AggregateMax()));
12381
12382	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemBalloon, 0));
12383	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemBalloon, new pm::AggregateAvg()));
12384	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemBalloon, new pm::AggregateMin()));
12385	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemBalloon, new pm::AggregateMax()));
12386
12387	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemShared, 0));
12388	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemShared, new pm::AggregateAvg()));
12389	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemShared, new pm::AggregateMin()));
12390	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemShared, new pm::AggregateMax()));
12391
12392	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemCache, 0));
12393	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemCache, new pm::AggregateAvg()));
12394	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemCache, new pm::AggregateMin()));
12395	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemCache, new pm::AggregateMax()));
12396
12397	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestPagedTotal, 0));
12398	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestPagedTotal, new pm::AggregateAvg()));
12399	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestPagedTotal, new pm::AggregateMin()));
12400	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestPagedTotal, new pm::AggregateMax()));
12401	}
12402
12403	void Machine::i_unregisterMetrics(PerformanceCollector aCollector, Machine aMachine)
12404	{
12405	AssertReturnVoid(isWriteLockOnCurrentThread());
12406
12407	if (aCollector)
12408	{
12409	aCollector->unregisterMetricsFor(aMachine);
12410	aCollector->unregisterBaseMetricsFor(aMachine);
12411	}
12412	}
12413
12414	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
12415
12416
12417	////////////////////////////////////////////////////////////////////////////////
12418
12419	DEFINE_EMPTY_CTOR_DTOR(SessionMachine)
12420
12421	HRESULT SessionMachine::FinalConstruct()
12422	{
12423	LogFlowThisFunc(("\n"));
12424
12425	mClientToken = NULL;
12426
12427	return BaseFinalConstruct();
12428	}
12429
12430	void SessionMachine::FinalRelease()
12431	{
12432	LogFlowThisFunc(("\n"));
12433
12434	Assert(!mClientToken);
12435	/* paranoia, should not hang around any more */
12436	if (mClientToken)
12437	{
12438	delete mClientToken;
12439	mClientToken = NULL;
12440	}
12441
12442	uninit(Uninit::Unexpected);
12443
12444	BaseFinalRelease();
12445	}
12446
12447	/**
12448	* @note Must be called only by Machine::LockMachine() from its own write lock.
12449	*/
12450	HRESULT SessionMachine::init(Machine *aMachine)
12451	{
12452	LogFlowThisFuncEnter();
12453	LogFlowThisFunc(("mName={%s}\n", aMachine->mUserData->s.strName.c_str()));
12454
12455	AssertReturn(aMachine, E_INVALIDARG);
12456
12457	AssertReturn(aMachine->lockHandle()->isWriteLockOnCurrentThread(), E_FAIL);
12458
12459	/* Enclose the state transition NotReady->InInit->Ready */
12460	AutoInitSpan autoInitSpan(this);
12461	AssertReturn(autoInitSpan.isOk(), E_FAIL);
12462
12463	HRESULT rc = S_OK;
12464
12465	RT_ZERO(mAuthLibCtx);
12466
12467	/* create the machine client token */
12468	try
12469	{
12470	mClientToken = new ClientToken(aMachine, this);
12471	if (!mClientToken->isReady())
12472	{
12473	delete mClientToken;
12474	mClientToken = NULL;
12475	rc = E_FAIL;
12476	}
12477	}
12478	catch (std::bad_alloc &)
12479	{
12480	rc = E_OUTOFMEMORY;
12481	}
12482	if (FAILED(rc))
12483	return rc;
12484
12485	/* memorize the peer Machine */
12486	unconst(mPeer) = aMachine;
12487	/* share the parent pointer */
12488	unconst(mParent) = aMachine->mParent;
12489
12490	/* take the pointers to data to share */
12491	mData.share(aMachine->mData);
12492	mSSData.share(aMachine->mSSData);
12493
12494	mUserData.share(aMachine->mUserData);
12495	mHWData.share(aMachine->mHWData);
12496	mMediumAttachments.share(aMachine->mMediumAttachments);
12497
12498	mStorageControllers.allocate();
12499	for (StorageControllerList::const_iterator
12500	it = aMachine->mStorageControllers->begin();
12501	it != aMachine->mStorageControllers->end();
12502	++it)
12503	{
12504	ComObjPtr<StorageController> ctl;
12505	ctl.createObject();
12506	ctl->init(this, *it);
12507	mStorageControllers->push_back(ctl);
12508	}
12509
12510	mUSBControllers.allocate();
12511	for (USBControllerList::const_iterator
12512	it = aMachine->mUSBControllers->begin();
12513	it != aMachine->mUSBControllers->end();
12514	++it)
12515	{
12516	ComObjPtr<USBController> ctl;
12517	ctl.createObject();
12518	ctl->init(this, *it);
12519	mUSBControllers->push_back(ctl);
12520	}
12521
12522	unconst(mBIOSSettings).createObject();
12523	mBIOSSettings->init(this, aMachine->mBIOSSettings);
12524	/* create another VRDEServer object that will be mutable */
12525	unconst(mVRDEServer).createObject();
12526	mVRDEServer->init(this, aMachine->mVRDEServer);
12527	/* create another audio adapter object that will be mutable */
12528	unconst(mAudioAdapter).createObject();
12529	mAudioAdapter->init(this, aMachine->mAudioAdapter);
12530	/* create a list of serial ports that will be mutable */
12531	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
12532	{
12533	unconst(mSerialPorts[slot]).createObject();
12534	mSerialPorts[slot]->init(this, aMachine->mSerialPorts[slot]);
12535	}
12536	/* create a list of parallel ports that will be mutable */
12537	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
12538	{
12539	unconst(mParallelPorts[slot]).createObject();
12540	mParallelPorts[slot]->init(this, aMachine->mParallelPorts[slot]);
12541	}
12542
12543	/* create another USB device filters object that will be mutable */
12544	unconst(mUSBDeviceFilters).createObject();
12545	mUSBDeviceFilters->init(this, aMachine->mUSBDeviceFilters);
12546
12547	/* create a list of network adapters that will be mutable */
12548	mNetworkAdapters.resize(aMachine->mNetworkAdapters.size());
12549	for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
12550	{
12551	unconst(mNetworkAdapters[slot]).createObject();
12552	mNetworkAdapters[slot]->init(this, aMachine->mNetworkAdapters[slot]);
12553	}
12554
12555	/* create another bandwidth control object that will be mutable */
12556	unconst(mBandwidthControl).createObject();
12557	mBandwidthControl->init(this, aMachine->mBandwidthControl);
12558
12559	/* default is to delete saved state on Saved -> PoweredOff transition */
12560	mRemoveSavedState = true;
12561
12562	/* Confirm a successful initialization when it's the case */
12563	autoInitSpan.setSucceeded();
12564
12565	miNATNetworksStarted = 0;
12566
12567	LogFlowThisFuncLeave();
12568	return rc;
12569	}
12570
12571	/**
12572	* Uninitializes this session object. If the reason is other than
12573	* Uninit::Unexpected, then this method MUST be called from #i_checkForDeath()
12574	* or the client watcher code.
12575	*
12576	* @param aReason uninitialization reason
12577	*
12578	* @note Locks mParent + this object for writing.
12579	*/
12580	void SessionMachine::uninit(Uninit::Reason aReason)
12581	{
12582	LogFlowThisFuncEnter();
12583	LogFlowThisFunc(("reason=%d\n", aReason));
12584
12585	/*
12586	* Strongly reference ourselves to prevent this object deletion after
12587	* mData->mSession.mMachine.setNull() below (which can release the last
12588	* reference and call the destructor). Important: this must be done before
12589	* accessing any members (and before AutoUninitSpan that does it as well).
12590	* This self reference will be released as the very last step on return.
12591	*/
12592	ComObjPtr<SessionMachine> selfRef;
12593	if (aReason != Uninit::Unexpected)
12594	selfRef = this;
12595
12596	/* Enclose the state transition Ready->InUninit->NotReady */
12597	AutoUninitSpan autoUninitSpan(this);
12598	if (autoUninitSpan.uninitDone())
12599	{
12600	LogFlowThisFunc(("Already uninitialized\n"));
12601	LogFlowThisFuncLeave();
12602	return;
12603	}
12604
12605	if (autoUninitSpan.initFailed())
12606	{
12607	/* We've been called by init() because it's failed. It's not really
12608	* necessary (nor it's safe) to perform the regular uninit sequence
12609	* below, the following is enough.
12610	*/
12611	LogFlowThisFunc(("Initialization failed.\n"));
12612	/* destroy the machine client token */
12613	if (mClientToken)
12614	{
12615	delete mClientToken;
12616	mClientToken = NULL;
12617	}
12618	uninitDataAndChildObjects();
12619	mData.free();
12620	unconst(mParent) = NULL;
12621	unconst(mPeer) = NULL;
12622	LogFlowThisFuncLeave();
12623	return;
12624	}
12625
12626	MachineState_T lastState;
12627	{
12628	AutoReadLock tempLock(this COMMA_LOCKVAL_SRC_POS);
12629	lastState = mData->mMachineState;
12630	}
12631	NOREF(lastState);
12632
12633	#ifdef VBOX_WITH_USB
12634	// release all captured USB devices, but do this before requesting the locks below
12635	if (aReason == Uninit::Abnormal && Global::IsOnline(lastState))
12636	{
12637	/* Console::captureUSBDevices() is called in the VM process only after
12638	* setting the machine state to Starting or Restoring.
12639	* Console::detachAllUSBDevices() will be called upon successful
12640	* termination. So, we need to release USB devices only if there was
12641	* an abnormal termination of a running VM.
12642	*
12643	* This is identical to SessionMachine::DetachAllUSBDevices except
12644	* for the aAbnormal argument. */
12645	HRESULT rc = mUSBDeviceFilters->i_notifyProxy(false /* aInsertFilters */);
12646	AssertComRC(rc);
12647	NOREF(rc);
12648
12649	USBProxyService *service = mParent->i_host()->i_usbProxyService();
12650	if (service)
12651	service->detachAllDevicesFromVM(this, true /* aDone /, true / aAbnormal */);
12652	}
12653	#endif /* VBOX_WITH_USB */
12654
12655	// we need to lock this object in uninit() because the lock is shared
12656	// with mPeer (as well as data we modify below). mParent lock is needed
12657	// by several calls to it.
12658	AutoMultiWriteLock2 multilock(mParent, this COMMA_LOCKVAL_SRC_POS);
12659
12660	#ifdef VBOX_WITH_RESOURCE_USAGE_API
12661	/*
12662	* It is safe to call Machine::i_unregisterMetrics() here because
12663	* PerformanceCollector::samplerCallback no longer accesses guest methods
12664	* holding the lock.
12665	*/
12666	i_unregisterMetrics(mParent->i_performanceCollector(), mPeer);
12667	/* The guest must be unregistered after its metrics (@bugref{5949}). */
12668	Log7Func(("{%p}: mCollectorGuest=%p\n", this, mCollectorGuest));
12669	if (mCollectorGuest)
12670	{
12671	mParent->i_performanceCollector()->unregisterGuest(mCollectorGuest);
12672	// delete mCollectorGuest; => CollectorGuestManager::destroyUnregistered()
12673	mCollectorGuest = NULL;
12674	}
12675	#endif
12676
12677	if (aReason == Uninit::Abnormal)
12678	{
12679	Log1WarningThisFunc(("ABNORMAL client termination! (wasBusy=%d)\n", Global::IsOnlineOrTransient(lastState)));
12680
12681	/* reset the state to Aborted */
12682	if (mData->mMachineState != MachineState_Aborted)
12683	i_setMachineState(MachineState_Aborted);
12684	}
12685
12686	// any machine settings modified?
12687	if (mData->flModifications)
12688	{
12689	Log1WarningThisFunc(("Discarding unsaved settings changes!\n"));
12690	i_rollback(false /* aNotify */);
12691	}
12692
12693	mData->mSession.mPID = NIL_RTPROCESS;
12694
12695	if (aReason == Uninit::Unexpected)
12696	{
12697	/* Uninitialization didn't come from #i_checkForDeath(), so tell the
12698	* client watcher thread to update the set of machines that have open
12699	* sessions. */
12700	mParent->i_updateClientWatcher();
12701	}
12702
12703	/* uninitialize all remote controls */
12704	if (mData->mSession.mRemoteControls.size())
12705	{
12706	LogFlowThisFunc(("Closing remote sessions (%d):\n",
12707	mData->mSession.mRemoteControls.size()));
12708
12709	/* Always restart a the beginning, since the iterator is invalidated
12710	* by using erase(). */
12711	for (Data::Session::RemoteControlList::iterator
12712	it = mData->mSession.mRemoteControls.begin();
12713	it != mData->mSession.mRemoteControls.end();
12714	it = mData->mSession.mRemoteControls.begin())
12715	{
12716	ComPtr<IInternalSessionControl> pControl = *it;
12717	mData->mSession.mRemoteControls.erase(it);
12718	multilock.release();
12719	LogFlowThisFunc((" Calling remoteControl->Uninitialize()...\n"));
12720	HRESULT rc = pControl->Uninitialize();
12721	LogFlowThisFunc((" remoteControl->Uninitialize() returned %08X\n", rc));
12722	if (FAILED(rc))
12723	Log1WarningThisFunc(("Forgot to close the remote session?\n"));
12724	multilock.acquire();
12725	}
12726	mData->mSession.mRemoteControls.clear();
12727	}
12728
12729	/* Remove all references to the NAT network service. The service will stop
12730	* if all references (also from other VMs) are removed. */
12731	for (; miNATNetworksStarted > 0; miNATNetworksStarted--)
12732	{
12733	for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
12734	{
12735	BOOL enabled;
12736	HRESULT hrc = mNetworkAdapters[slot]->COMGETTER(Enabled)(&enabled);
12737	if ( FAILED(hrc)
12738	\|\| !enabled)
12739	continue;
12740
12741	NetworkAttachmentType_T type;
12742	hrc = mNetworkAdapters[slot]->COMGETTER(AttachmentType)(&type);
12743	if ( SUCCEEDED(hrc)
12744	&& type == NetworkAttachmentType_NATNetwork)
12745	{
12746	Bstr name;
12747	hrc = mNetworkAdapters[slot]->COMGETTER(NATNetwork)(name.asOutParam());
12748	if (SUCCEEDED(hrc))
12749	{
12750	multilock.release();
12751	Utf8Str strName(name);
12752	LogRel(("VM '%s' stops using NAT network '%s'\n",
12753	mUserData->s.strName.c_str(), strName.c_str()));
12754	mParent->i_natNetworkRefDec(strName);
12755	multilock.acquire();
12756	}
12757	}
12758	}
12759	}
12760
12761	/*
12762	* An expected uninitialization can come only from #i_checkForDeath().
12763	* Otherwise it means that something's gone really wrong (for example,
12764	* the Session implementation has released the VirtualBox reference
12765	* before it triggered #OnSessionEnd(), or before releasing IPC semaphore,
12766	* etc). However, it's also possible, that the client releases the IPC
12767	* semaphore correctly (i.e. before it releases the VirtualBox reference),
12768	* but the VirtualBox release event comes first to the server process.
12769	* This case is practically possible, so we should not assert on an
12770	* unexpected uninit, just log a warning.
12771	*/
12772
12773	if (aReason == Uninit::Unexpected)
12774	Log1WarningThisFunc(("Unexpected SessionMachine uninitialization!\n"));
12775
12776	if (aReason != Uninit::Normal)
12777	{
12778	mData->mSession.mDirectControl.setNull();
12779	}
12780	else
12781	{
12782	/* this must be null here (see #OnSessionEnd()) */
12783	Assert(mData->mSession.mDirectControl.isNull());
12784	Assert(mData->mSession.mState == SessionState_Unlocking);
12785	Assert(!mData->mSession.mProgress.isNull());
12786	}
12787	if (mData->mSession.mProgress)
12788	{
12789	if (aReason == Uninit::Normal)
12790	mData->mSession.mProgress->i_notifyComplete(S_OK);
12791	else
12792	mData->mSession.mProgress->i_notifyComplete(E_FAIL,
12793	COM_IIDOF(ISession),
12794	getComponentName(),
12795	tr("The VM session was aborted"));
12796	mData->mSession.mProgress.setNull();
12797	}
12798
12799	if (mConsoleTaskData.mProgress)
12800	{
12801	Assert(aReason == Uninit::Abnormal);
12802	mConsoleTaskData.mProgress->i_notifyComplete(E_FAIL,
12803	COM_IIDOF(ISession),
12804	getComponentName(),
12805	tr("The VM session was aborted"));
12806	mConsoleTaskData.mProgress.setNull();
12807	}
12808
12809	/* remove the association between the peer machine and this session machine */
12810	Assert( (SessionMachine*)mData->mSession.mMachine == this
12811	\|\| aReason == Uninit::Unexpected);
12812
12813	/* reset the rest of session data */
12814	mData->mSession.mLockType = LockType_Null;
12815	mData->mSession.mMachine.setNull();
12816	mData->mSession.mState = SessionState_Unlocked;
12817	mData->mSession.mName.setNull();
12818
12819	/* destroy the machine client token before leaving the exclusive lock */
12820	if (mClientToken)
12821	{
12822	delete mClientToken;
12823	mClientToken = NULL;
12824	}
12825
12826	/* fire an event */
12827	mParent->i_onSessionStateChange(mData->mUuid, SessionState_Unlocked);
12828
12829	uninitDataAndChildObjects();
12830
12831	/* free the essential data structure last */
12832	mData.free();
12833
12834	/* release the exclusive lock before setting the below two to NULL */
12835	multilock.release();
12836
12837	unconst(mParent) = NULL;
12838	unconst(mPeer) = NULL;
12839
12840	AuthLibUnload(&mAuthLibCtx);
12841
12842	LogFlowThisFuncLeave();
12843	}
12844
12845	// util::Lockable interface
12846	////////////////////////////////////////////////////////////////////////////////
12847
12848	/**
12849	* Overrides VirtualBoxBase::lockHandle() in order to share the lock handle
12850	* with the primary Machine instance (mPeer).
12851	*/
12852	RWLockHandle *SessionMachine::lockHandle() const
12853	{
12854	AssertReturn(mPeer != NULL, NULL);
12855	return mPeer->lockHandle();
12856	}
12857
12858	// IInternalMachineControl methods
12859	////////////////////////////////////////////////////////////////////////////////
12860
12861	/**
12862	* Passes collected guest statistics to performance collector object
12863	*/
12864	HRESULT SessionMachine::reportVmStatistics(ULONG aValidStats, ULONG aCpuUser,
12865	ULONG aCpuKernel, ULONG aCpuIdle,
12866	ULONG aMemTotal, ULONG aMemFree,
12867	ULONG aMemBalloon, ULONG aMemShared,
12868	ULONG aMemCache, ULONG aPageTotal,
12869	ULONG aAllocVMM, ULONG aFreeVMM,
12870	ULONG aBalloonedVMM, ULONG aSharedVMM,
12871	ULONG aVmNetRx, ULONG aVmNetTx)
12872	{
12873	#ifdef VBOX_WITH_RESOURCE_USAGE_API
12874	if (mCollectorGuest)
12875	mCollectorGuest->updateStats(aValidStats, aCpuUser, aCpuKernel, aCpuIdle,
12876	aMemTotal, aMemFree, aMemBalloon, aMemShared,
12877	aMemCache, aPageTotal, aAllocVMM, aFreeVMM,
12878	aBalloonedVMM, aSharedVMM, aVmNetRx, aVmNetTx);
12879
12880	return S_OK;
12881	#else
12882	NOREF(aValidStats);
12883	NOREF(aCpuUser);
12884	NOREF(aCpuKernel);
12885	NOREF(aCpuIdle);
12886	NOREF(aMemTotal);
12887	NOREF(aMemFree);
12888	NOREF(aMemBalloon);
12889	NOREF(aMemShared);
12890	NOREF(aMemCache);
12891	NOREF(aPageTotal);
12892	NOREF(aAllocVMM);
12893	NOREF(aFreeVMM);
12894	NOREF(aBalloonedVMM);
12895	NOREF(aSharedVMM);
12896	NOREF(aVmNetRx);
12897	NOREF(aVmNetTx);
12898	return E_NOTIMPL;
12899	#endif
12900	}
12901
12902	////////////////////////////////////////////////////////////////////////////////
12903	//
12904	// SessionMachine task records
12905	//
12906	////////////////////////////////////////////////////////////////////////////////
12907
12908	/**
12909	* Task record for saving the machine state.
12910	*/
12911	class SessionMachine::SaveStateTask
12912	: public Machine::Task
12913	{
12914	public:
12915	SaveStateTask(SessionMachine *m,
12916	Progress *p,
12917	const Utf8Str &t,
12918	Reason_T enmReason,
12919	const Utf8Str &strStateFilePath)
12920	: Task(m, p, t),
12921	m_enmReason(enmReason),
12922	m_strStateFilePath(strStateFilePath)
12923	{}
12924
12925	private:
12926	void handler()
12927	{
12928	((SessionMachine )(Machine )m_pMachine)->i_saveStateHandler(*this);
12929	}
12930
12931	Reason_T m_enmReason;
12932	Utf8Str m_strStateFilePath;
12933
12934	friend class SessionMachine;
12935	};
12936
12937	/**
12938	* Task thread implementation for SessionMachine::SaveState(), called from
12939	* SessionMachine::taskHandler().
12940	*
12941	* @note Locks this object for writing.
12942	*
12943	* @param task
12944	* @return
12945	*/
12946	void SessionMachine::i_saveStateHandler(SaveStateTask &task)
12947	{
12948	LogFlowThisFuncEnter();
12949
12950	AutoCaller autoCaller(this);
12951	LogFlowThisFunc(("state=%d\n", getObjectState().getState()));
12952	if (FAILED(autoCaller.rc()))
12953	{
12954	/* we might have been uninitialized because the session was accidentally
12955	* closed by the client, so don't assert */
12956	HRESULT rc = setError(E_FAIL,
12957	tr("The session has been accidentally closed"));
12958	task.m_pProgress->i_notifyComplete(rc);
12959	LogFlowThisFuncLeave();
12960	return;
12961	}
12962
12963	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
12964
12965	HRESULT rc = S_OK;
12966
12967	try
12968	{
12969	ComPtr<IInternalSessionControl> directControl;
12970	if (mData->mSession.mLockType == LockType_VM)
12971	directControl = mData->mSession.mDirectControl;
12972	if (directControl.isNull())
12973	throw setError(VBOX_E_INVALID_VM_STATE,
12974	tr("Trying to save state without a running VM"));
12975	alock.release();
12976	BOOL fSuspendedBySave;
12977	rc = directControl->SaveStateWithReason(task.m_enmReason, task.m_pProgress, NULL, Bstr(task.m_strStateFilePath).raw(), task.m_machineStateBackup != MachineState_Paused, &fSuspendedBySave);
12978	Assert(!fSuspendedBySave);
12979	alock.acquire();
12980
12981	AssertStmt( (SUCCEEDED(rc) && mData->mMachineState == MachineState_Saved)
12982	\|\| (FAILED(rc) && mData->mMachineState == MachineState_Saving),
12983	throw E_FAIL);
12984
12985	if (SUCCEEDED(rc))
12986	{
12987	mSSData->strStateFilePath = task.m_strStateFilePath;
12988
12989	/* save all VM settings */
12990	rc = i_saveSettings(NULL);
12991	// no need to check whether VirtualBox.xml needs saving also since
12992	// we can't have a name change pending at this point
12993	}
12994	else
12995	{
12996	// On failure, set the state to the state we had at the beginning.
12997	i_setMachineState(task.m_machineStateBackup);
12998	i_updateMachineStateOnClient();
12999
13000	// Delete the saved state file (might have been already created).
13001	// No need to check whether this is shared with a snapshot here
13002	// because we certainly created a fresh saved state file here.
13003	RTFileDelete(task.m_strStateFilePath.c_str());
13004	}
13005	}
13006	catch (HRESULT aRC) { rc = aRC; }
13007
13008	task.m_pProgress->i_notifyComplete(rc);
13009
13010	LogFlowThisFuncLeave();
13011	}
13012
13013	/**
13014	* @note Locks this object for writing.
13015	*/
13016	HRESULT SessionMachine::saveState(ComPtr<IProgress> &aProgress)
13017	{
13018	return i_saveStateWithReason(Reason_Unspecified, aProgress);
13019	}
13020
13021	HRESULT SessionMachine::i_saveStateWithReason(Reason_T aReason, ComPtr<IProgress> &aProgress)
13022	{
13023	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13024
13025	HRESULT rc = i_checkStateDependency(MutableOrRunningStateDep);
13026	if (FAILED(rc)) return rc;
13027
13028	if ( mData->mMachineState != MachineState_Running
13029	&& mData->mMachineState != MachineState_Paused
13030	)
13031	return setError(VBOX_E_INVALID_VM_STATE,
13032	tr("Cannot save the execution state as the machine is not running or paused (machine state: %s)"),
13033	Global::stringifyMachineState(mData->mMachineState));
13034
13035	ComObjPtr<Progress> pProgress;
13036	pProgress.createObject();
13037	rc = pProgress->init(i_getVirtualBox(),
13038	static_cast<IMachine >(this) / aInitiator */,
13039	tr("Saving the execution state of the virtual machine"),
13040	FALSE /* aCancelable */);
13041	if (FAILED(rc))
13042	return rc;
13043
13044	Utf8Str strStateFilePath;
13045	i_composeSavedStateFilename(strStateFilePath);
13046
13047	/* create and start the task on a separate thread (note that it will not
13048	* start working until we release alock) */
13049	SaveStateTask *pTask = new SaveStateTask(this, pProgress, "SaveState", aReason, strStateFilePath);
13050	rc = pTask->createThread();
13051	if (FAILED(rc))
13052	return rc;
13053
13054	/* set the state to Saving (expected by Session::SaveStateWithReason()) */
13055	i_setMachineState(MachineState_Saving);
13056	i_updateMachineStateOnClient();
13057
13058	pProgress.queryInterfaceTo(aProgress.asOutParam());
13059
13060	return S_OK;
13061	}
13062
13063	/**
13064	* @note Locks this object for writing.
13065	*/
13066	HRESULT SessionMachine::adoptSavedState(const com::Utf8Str &aSavedStateFile)
13067	{
13068	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13069
13070	HRESULT rc = i_checkStateDependency(MutableStateDep);
13071	if (FAILED(rc)) return rc;
13072
13073	if ( mData->mMachineState != MachineState_PoweredOff
13074	&& mData->mMachineState != MachineState_Teleported
13075	&& mData->mMachineState != MachineState_Aborted
13076	)
13077	return setError(VBOX_E_INVALID_VM_STATE,
13078	tr("Cannot adopt the saved machine state as the machine is not in Powered Off, Teleported or Aborted state (machine state: %s)"),
13079	Global::stringifyMachineState(mData->mMachineState));
13080
13081	com::Utf8Str stateFilePathFull;
13082	int vrc = i_calculateFullPath(aSavedStateFile, stateFilePathFull);
13083	if (RT_FAILURE(vrc))
13084	return setError(VBOX_E_FILE_ERROR,
13085	tr("Invalid saved state file path '%s' (%Rrc)"),
13086	aSavedStateFile.c_str(),
13087	vrc);
13088
13089	mSSData->strStateFilePath = stateFilePathFull;
13090
13091	/* The below i_setMachineState() will detect the state transition and will
13092	* update the settings file */
13093
13094	return i_setMachineState(MachineState_Saved);
13095	}
13096
13097	/**
13098	* @note Locks this object for writing.
13099	*/
13100	HRESULT SessionMachine::discardSavedState(BOOL aFRemoveFile)
13101	{
13102	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13103
13104	HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
13105	if (FAILED(rc)) return rc;
13106
13107	if (mData->mMachineState != MachineState_Saved)
13108	return setError(VBOX_E_INVALID_VM_STATE,
13109	tr("Cannot delete the machine state as the machine is not in the saved state (machine state: %s)"),
13110	Global::stringifyMachineState(mData->mMachineState));
13111
13112	mRemoveSavedState = RT_BOOL(aFRemoveFile);
13113
13114	/*
13115	* Saved -> PoweredOff transition will be detected in the SessionMachine
13116	* and properly handled.
13117	*/
13118	rc = i_setMachineState(MachineState_PoweredOff);
13119	return rc;
13120	}
13121
13122
13123	/**
13124	* @note Locks the same as #i_setMachineState() does.
13125	*/
13126	HRESULT SessionMachine::updateState(MachineState_T aState)
13127	{
13128	return i_setMachineState(aState);
13129	}
13130
13131	/**
13132	* @note Locks this object for writing.
13133	*/
13134	HRESULT SessionMachine::beginPowerUp(const ComPtr<IProgress> &aProgress)
13135	{
13136	IProgress *pProgress(aProgress);
13137
13138	LogFlowThisFunc(("aProgress=%p\n", pProgress));
13139
13140	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13141
13142	if (mData->mSession.mState != SessionState_Locked)
13143	return VBOX_E_INVALID_OBJECT_STATE;
13144
13145	if (!mData->mSession.mProgress.isNull())
13146	mData->mSession.mProgress->setOtherProgressObject(pProgress);
13147
13148	/* If we didn't reference the NAT network service yet, add a reference to
13149	* force a start */
13150	if (miNATNetworksStarted < 1)
13151	{
13152	for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
13153	{
13154	BOOL enabled;
13155	HRESULT hrc = mNetworkAdapters[slot]->COMGETTER(Enabled)(&enabled);
13156	if ( FAILED(hrc)
13157	\|\| !enabled)
13158	continue;
13159
13160	NetworkAttachmentType_T type;
13161	hrc = mNetworkAdapters[slot]->COMGETTER(AttachmentType)(&type);
13162	if ( SUCCEEDED(hrc)
13163	&& type == NetworkAttachmentType_NATNetwork)
13164	{
13165	Bstr name;
13166	hrc = mNetworkAdapters[slot]->COMGETTER(NATNetwork)(name.asOutParam());
13167	if (SUCCEEDED(hrc))
13168	{
13169	Utf8Str strName(name);
13170	LogRel(("VM '%s' starts using NAT network '%s'\n",
13171	mUserData->s.strName.c_str(), strName.c_str()));
13172	mPeer->lockHandle()->unlockWrite();
13173	mParent->i_natNetworkRefInc(strName);
13174	#ifdef RT_LOCK_STRICT
13175	mPeer->lockHandle()->lockWrite(RT_SRC_POS);
13176	#else
13177	mPeer->lockHandle()->lockWrite();
13178	#endif
13179	}
13180	}
13181	}
13182	miNATNetworksStarted++;
13183	}
13184
13185	LogFlowThisFunc(("returns S_OK.\n"));
13186	return S_OK;
13187	}
13188
13189	/**
13190	* @note Locks this object for writing.
13191	*/
13192	HRESULT SessionMachine::endPowerUp(LONG aResult)
13193	{
13194	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13195
13196	if (mData->mSession.mState != SessionState_Locked)
13197	return VBOX_E_INVALID_OBJECT_STATE;
13198
13199	/* Finalize the LaunchVMProcess progress object. */
13200	if (mData->mSession.mProgress)
13201	{
13202	mData->mSession.mProgress->notifyComplete((HRESULT)aResult);
13203	mData->mSession.mProgress.setNull();
13204	}
13205
13206	if (SUCCEEDED((HRESULT)aResult))
13207	{
13208	#ifdef VBOX_WITH_RESOURCE_USAGE_API
13209	/* The VM has been powered up successfully, so it makes sense
13210	* now to offer the performance metrics for a running machine
13211	* object. Doing it earlier wouldn't be safe. */
13212	i_registerMetrics(mParent->i_performanceCollector(), mPeer,
13213	mData->mSession.mPID);
13214	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
13215	}
13216
13217	return S_OK;
13218	}
13219
13220	/**
13221	* @note Locks this object for writing.
13222	*/
13223	HRESULT SessionMachine::beginPoweringDown(ComPtr<IProgress> &aProgress)
13224	{
13225	LogFlowThisFuncEnter();
13226
13227	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13228
13229	AssertReturn(mConsoleTaskData.mLastState == MachineState_Null,
13230	E_FAIL);
13231
13232	/* create a progress object to track operation completion */
13233	ComObjPtr<Progress> pProgress;
13234	pProgress.createObject();
13235	pProgress->init(i_getVirtualBox(),
13236	static_cast<IMachine >(this) / aInitiator */,
13237	tr("Stopping the virtual machine"),
13238	FALSE /* aCancelable */);
13239
13240	/* fill in the console task data */
13241	mConsoleTaskData.mLastState = mData->mMachineState;
13242	mConsoleTaskData.mProgress = pProgress;
13243
13244	/* set the state to Stopping (this is expected by Console::PowerDown()) */
13245	i_setMachineState(MachineState_Stopping);
13246
13247	pProgress.queryInterfaceTo(aProgress.asOutParam());
13248
13249	return S_OK;
13250	}
13251
13252	/**
13253	* @note Locks this object for writing.
13254	*/
13255	HRESULT SessionMachine::endPoweringDown(LONG aResult,
13256	const com::Utf8Str &aErrMsg)
13257	{
13258	LogFlowThisFuncEnter();
13259
13260	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13261
13262	AssertReturn( ( (SUCCEEDED(aResult) && mData->mMachineState == MachineState_PoweredOff)
13263	\|\| (FAILED(aResult) && mData->mMachineState == MachineState_Stopping))
13264	&& mConsoleTaskData.mLastState != MachineState_Null,
13265	E_FAIL);
13266
13267	/*
13268	* On failure, set the state to the state we had when BeginPoweringDown()
13269	* was called (this is expected by Console::PowerDown() and the associated
13270	* task). On success the VM process already changed the state to
13271	* MachineState_PoweredOff, so no need to do anything.
13272	*/
13273	if (FAILED(aResult))
13274	i_setMachineState(mConsoleTaskData.mLastState);
13275
13276	/* notify the progress object about operation completion */
13277	Assert(mConsoleTaskData.mProgress);
13278	if (SUCCEEDED(aResult))
13279	mConsoleTaskData.mProgress->i_notifyComplete(S_OK);
13280	else
13281	{
13282	if (aErrMsg.length())
13283	mConsoleTaskData.mProgress->i_notifyComplete(aResult,
13284	COM_IIDOF(ISession),
13285	getComponentName(),
13286	aErrMsg.c_str());
13287	else
13288	mConsoleTaskData.mProgress->i_notifyComplete(aResult);
13289	}
13290
13291	/* clear out the temporary saved state data */
13292	mConsoleTaskData.mLastState = MachineState_Null;
13293	mConsoleTaskData.mProgress.setNull();
13294
13295	LogFlowThisFuncLeave();
13296	return S_OK;
13297	}
13298
13299
13300	/**
13301	* Goes through the USB filters of the given machine to see if the given
13302	* device matches any filter or not.
13303	*
13304	* @note Locks the same as USBController::hasMatchingFilter() does.
13305	*/
13306	HRESULT SessionMachine::runUSBDeviceFilters(const ComPtr<IUSBDevice> &aDevice,
13307	BOOL *aMatched,
13308	ULONG *aMaskedInterfaces)
13309	{
13310	LogFlowThisFunc(("\n"));
13311
13312	#ifdef VBOX_WITH_USB
13313	*aMatched = mUSBDeviceFilters->i_hasMatchingFilter(aDevice, aMaskedInterfaces);
13314	#else
13315	NOREF(aDevice);
13316	NOREF(aMaskedInterfaces);
13317	*aMatched = FALSE;
13318	#endif
13319
13320	return S_OK;
13321	}
13322
13323	/**
13324	* @note Locks the same as Host::captureUSBDevice() does.
13325	*/
13326	HRESULT SessionMachine::captureUSBDevice(const com::Guid &aId, const com::Utf8Str &aCaptureFilename)
13327	{
13328	LogFlowThisFunc(("\n"));
13329
13330	#ifdef VBOX_WITH_USB
13331	/* if captureDeviceForVM() fails, it must have set extended error info */
13332	clearError();
13333	MultiResult rc = mParent->i_host()->i_checkUSBProxyService();
13334	if (FAILED(rc)) return rc;
13335
13336	USBProxyService *service = mParent->i_host()->i_usbProxyService();
13337	AssertReturn(service, E_FAIL);
13338	return service->captureDeviceForVM(this, aId.ref(), aCaptureFilename);
13339	#else
13340	NOREF(aId);
13341	return E_NOTIMPL;
13342	#endif
13343	}
13344
13345	/**
13346	* @note Locks the same as Host::detachUSBDevice() does.
13347	*/
13348	HRESULT SessionMachine::detachUSBDevice(const com::Guid &aId,
13349	BOOL aDone)
13350	{
13351	LogFlowThisFunc(("\n"));
13352
13353	#ifdef VBOX_WITH_USB
13354	USBProxyService *service = mParent->i_host()->i_usbProxyService();
13355	AssertReturn(service, E_FAIL);
13356	return service->detachDeviceFromVM(this, aId.ref(), !!aDone);
13357	#else
13358	NOREF(aId);
13359	NOREF(aDone);
13360	return E_NOTIMPL;
13361	#endif
13362	}
13363
13364	/**
13365	* Inserts all machine filters to the USB proxy service and then calls
13366	* Host::autoCaptureUSBDevices().
13367	*
13368	* Called by Console from the VM process upon VM startup.
13369	*
13370	* @note Locks what called methods lock.
13371	*/
13372	HRESULT SessionMachine::autoCaptureUSBDevices()
13373	{
13374	LogFlowThisFunc(("\n"));
13375
13376	#ifdef VBOX_WITH_USB
13377	HRESULT rc = mUSBDeviceFilters->i_notifyProxy(true /* aInsertFilters */);
13378	AssertComRC(rc);
13379	NOREF(rc);
13380
13381	USBProxyService *service = mParent->i_host()->i_usbProxyService();
13382	AssertReturn(service, E_FAIL);
13383	return service->autoCaptureDevicesForVM(this);
13384	#else
13385	return S_OK;
13386	#endif
13387	}
13388
13389	/**
13390	* Removes all machine filters from the USB proxy service and then calls
13391	* Host::detachAllUSBDevices().
13392	*
13393	* Called by Console from the VM process upon normal VM termination or by
13394	* SessionMachine::uninit() upon abnormal VM termination (from under the
13395	* Machine/SessionMachine lock).
13396	*
13397	* @note Locks what called methods lock.
13398	*/
13399	HRESULT SessionMachine::detachAllUSBDevices(BOOL aDone)
13400	{
13401	LogFlowThisFunc(("\n"));
13402
13403	#ifdef VBOX_WITH_USB
13404	HRESULT rc = mUSBDeviceFilters->i_notifyProxy(false /* aInsertFilters */);
13405	AssertComRC(rc);
13406	NOREF(rc);
13407
13408	USBProxyService *service = mParent->i_host()->i_usbProxyService();
13409	AssertReturn(service, E_FAIL);
13410	return service->detachAllDevicesFromVM(this, !!aDone, false /* aAbnormal */);
13411	#else
13412	NOREF(aDone);
13413	return S_OK;
13414	#endif
13415	}
13416
13417	/**
13418	* @note Locks this object for writing.
13419	*/
13420	HRESULT SessionMachine::onSessionEnd(const ComPtr<ISession> &aSession,
13421	ComPtr<IProgress> &aProgress)
13422	{
13423	LogFlowThisFuncEnter();
13424
13425	LogFlowThisFunc(("callerstate=%d\n", getObjectState().getState()));
13426	/*
13427	* We don't assert below because it might happen that a non-direct session
13428	* informs us it is closed right after we've been uninitialized -- it's ok.
13429	*/
13430
13431	/* get IInternalSessionControl interface */
13432	ComPtr<IInternalSessionControl> control(aSession);
13433
13434	ComAssertRet(!control.isNull(), E_INVALIDARG);
13435
13436	/* Creating a Progress object requires the VirtualBox lock, and
13437	* thus locking it here is required by the lock order rules. */
13438	AutoMultiWriteLock2 alock(mParent, this COMMA_LOCKVAL_SRC_POS);
13439
13440	if (control == mData->mSession.mDirectControl)
13441	{
13442	/* The direct session is being normally closed by the client process
13443	* ----------------------------------------------------------------- */
13444
13445	/* go to the closing state (essential for all open*Session() calls and
13446	* for #i_checkForDeath()) */
13447	Assert(mData->mSession.mState == SessionState_Locked);
13448	mData->mSession.mState = SessionState_Unlocking;
13449
13450	/* set direct control to NULL to release the remote instance */
13451	mData->mSession.mDirectControl.setNull();
13452	LogFlowThisFunc(("Direct control is set to NULL\n"));
13453
13454	if (mData->mSession.mProgress)
13455	{
13456	/* finalize the progress, someone might wait if a frontend
13457	* closes the session before powering on the VM. */
13458	mData->mSession.mProgress->notifyComplete(E_FAIL,
13459	COM_IIDOF(ISession),
13460	getComponentName(),
13461	tr("The VM session was closed before any attempt to power it on"));
13462	mData->mSession.mProgress.setNull();
13463	}
13464
13465	/* Create the progress object the client will use to wait until
13466	* #i_checkForDeath() is called to uninitialize this session object after
13467	* it releases the IPC semaphore.
13468	* Note! Because we're "reusing" mProgress here, this must be a proxy
13469	* object just like for LaunchVMProcess. */
13470	Assert(mData->mSession.mProgress.isNull());
13471	ComObjPtr<ProgressProxy> progress;
13472	progress.createObject();
13473	ComPtr<IUnknown> pPeer(mPeer);
13474	progress->init(mParent, pPeer,
13475	Bstr(tr("Closing session")).raw(),
13476	FALSE /* aCancelable */);
13477	progress.queryInterfaceTo(aProgress.asOutParam());
13478	mData->mSession.mProgress = progress;
13479	}
13480	else
13481	{
13482	/* the remote session is being normally closed */
13483	bool found = false;
13484	for (Data::Session::RemoteControlList::iterator
13485	it = mData->mSession.mRemoteControls.begin();
13486	it != mData->mSession.mRemoteControls.end();
13487	++it)
13488	{
13489	if (control == *it)
13490	{
13491	found = true;
13492	// This MUST be erase(it), not remove(*it) as the latter
13493	// triggers a very nasty use after free due to the place where
13494	// the value "lives".
13495	mData->mSession.mRemoteControls.erase(it);
13496	break;
13497	}
13498	}
13499	ComAssertMsgRet(found, ("The session is not found in the session list!"),
13500	E_INVALIDARG);
13501	}
13502
13503	/* signal the client watcher thread, because the client is going away */
13504	mParent->i_updateClientWatcher();
13505
13506	LogFlowThisFuncLeave();
13507	return S_OK;
13508	}
13509
13510	HRESULT SessionMachine::pullGuestProperties(std::vector<com::Utf8Str> &aNames,
13511	std::vector<com::Utf8Str> &aValues,
13512	std::vector<LONG64> &aTimestamps,
13513	std::vector<com::Utf8Str> &aFlags)
13514	{
13515	LogFlowThisFunc(("\n"));
13516
13517	#ifdef VBOX_WITH_GUEST_PROPS
13518	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13519
13520	size_t cEntries = mHWData->mGuestProperties.size();
13521	aNames.resize(cEntries);
13522	aValues.resize(cEntries);
13523	aTimestamps.resize(cEntries);
13524	aFlags.resize(cEntries);
13525
13526	size_t i = 0;
13527	for (HWData::GuestPropertyMap::const_iterator
13528	it = mHWData->mGuestProperties.begin();
13529	it != mHWData->mGuestProperties.end();
13530	++it, ++i)
13531	{
13532	char szFlags[GUEST_PROP_MAX_FLAGS_LEN + 1];
13533	aNames[i] = it->first;
13534	aValues[i] = it->second.strValue;
13535	aTimestamps[i] = it->second.mTimestamp;
13536
13537	/* If it is NULL, keep it NULL. */
13538	if (it->second.mFlags)
13539	{
13540	GuestPropWriteFlags(it->second.mFlags, szFlags);
13541	aFlags[i] = szFlags;
13542	}
13543	else
13544	aFlags[i] = "";
13545	}
13546	return S_OK;
13547	#else
13548	ReturnComNotImplemented();
13549	#endif
13550	}
13551
13552	HRESULT SessionMachine::pushGuestProperty(const com::Utf8Str &aName,
13553	const com::Utf8Str &aValue,
13554	LONG64 aTimestamp,
13555	const com::Utf8Str &aFlags)
13556	{
13557	LogFlowThisFunc(("\n"));
13558
13559	#ifdef VBOX_WITH_GUEST_PROPS
13560	try
13561	{
13562	/*
13563	* Convert input up front.
13564	*/
13565	uint32_t fFlags = GUEST_PROP_F_NILFLAG;
13566	if (aFlags.length())
13567	{
13568	int vrc = GuestPropValidateFlags(aFlags.c_str(), &fFlags);
13569	AssertRCReturn(vrc, E_INVALIDARG);
13570	}
13571
13572	/*
13573	* Now grab the object lock, validate the state and do the update.
13574	*/
13575
13576	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13577
13578	if (!Global::IsOnline(mData->mMachineState))
13579	{
13580	AssertMsgFailedReturn(("%s\n", Global::stringifyMachineState(mData->mMachineState)),
13581	VBOX_E_INVALID_VM_STATE);
13582	}
13583
13584	i_setModified(IsModified_MachineData);
13585	mHWData.backup();
13586
13587	bool fDelete = !aValue.length();
13588	HWData::GuestPropertyMap::iterator it = mHWData->mGuestProperties.find(aName);
13589	if (it != mHWData->mGuestProperties.end())
13590	{
13591	if (!fDelete)
13592	{
13593	it->second.strValue = aValue;
13594	it->second.mTimestamp = aTimestamp;
13595	it->second.mFlags = fFlags;
13596	}
13597	else
13598	mHWData->mGuestProperties.erase(it);
13599
13600	mData->mGuestPropertiesModified = TRUE;
13601	}
13602	else if (!fDelete)
13603	{
13604	HWData::GuestProperty prop;
13605	prop.strValue = aValue;
13606	prop.mTimestamp = aTimestamp;
13607	prop.mFlags = fFlags;
13608
13609	mHWData->mGuestProperties[aName] = prop;
13610	mData->mGuestPropertiesModified = TRUE;
13611	}
13612
13613	alock.release();
13614
13615	mParent->i_onGuestPropertyChange(mData->mUuid,
13616	Bstr(aName).raw(),
13617	Bstr(aValue).raw(),
13618	Bstr(aFlags).raw());
13619	}
13620	catch (...)
13621	{
13622	return VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
13623	}
13624	return S_OK;
13625	#else
13626	ReturnComNotImplemented();
13627	#endif
13628	}
13629
13630
13631	HRESULT SessionMachine::lockMedia()
13632	{
13633	AutoMultiWriteLock2 alock(this->lockHandle(),
13634	&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
13635
13636	AssertReturn( mData->mMachineState == MachineState_Starting
13637	\|\| mData->mMachineState == MachineState_Restoring
13638	\|\| mData->mMachineState == MachineState_TeleportingIn, E_FAIL);
13639
13640	clearError();
13641	alock.release();
13642	return i_lockMedia();
13643	}
13644
13645	HRESULT SessionMachine::unlockMedia()
13646	{
13647	HRESULT hrc = i_unlockMedia();
13648	return hrc;
13649	}
13650
13651	HRESULT SessionMachine::ejectMedium(const ComPtr<IMediumAttachment> &aAttachment,
13652	ComPtr<IMediumAttachment> &aNewAttachment)
13653	{
13654	// request the host lock first, since might be calling Host methods for getting host drives;
13655	// next, protect the media tree all the while we're in here, as well as our member variables
13656	AutoMultiWriteLock3 multiLock(mParent->i_host()->lockHandle(),
13657	this->lockHandle(),
13658	&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
13659
13660	IMediumAttachment *iAttach = aAttachment;
13661	ComObjPtr<MediumAttachment> pAttach = static_cast<MediumAttachment *>(iAttach);
13662
13663	Utf8Str ctrlName;
13664	LONG lPort;
13665	LONG lDevice;
13666	bool fTempEject;
13667	{
13668	AutoReadLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
13669
13670	/* Need to query the details first, as the IMediumAttachment reference
13671	* might be to the original settings, which we are going to change. */
13672	ctrlName = pAttach->i_getControllerName();
13673	lPort = pAttach->i_getPort();
13674	lDevice = pAttach->i_getDevice();
13675	fTempEject = pAttach->i_getTempEject();
13676	}
13677
13678	if (!fTempEject)
13679	{
13680	/* Remember previously mounted medium. The medium before taking the
13681	* backup is not necessarily the same thing. */
13682	ComObjPtr<Medium> oldmedium;
13683	oldmedium = pAttach->i_getMedium();
13684
13685	i_setModified(IsModified_Storage);
13686	mMediumAttachments.backup();
13687
13688	// The backup operation makes the pAttach reference point to the
13689	// old settings. Re-get the correct reference.
13690	pAttach = i_findAttachment(*mMediumAttachments.data(),
13691	ctrlName,
13692	lPort,
13693	lDevice);
13694
13695	{
13696	AutoCaller autoAttachCaller(this);
13697	if (FAILED(autoAttachCaller.rc())) return autoAttachCaller.rc();
13698
13699	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
13700	if (!oldmedium.isNull())
13701	oldmedium->i_removeBackReference(mData->mUuid);
13702
13703	pAttach->i_updateMedium(NULL);
13704	pAttach->i_updateEjected();
13705	}
13706
13707	i_setModified(IsModified_Storage);
13708	}
13709	else
13710	{
13711	{
13712	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
13713	pAttach->i_updateEjected();
13714	}
13715	}
13716
13717	pAttach.queryInterfaceTo(aNewAttachment.asOutParam());
13718
13719	return S_OK;
13720	}
13721
13722	HRESULT SessionMachine::authenticateExternal(const std::vector<com::Utf8Str> &aAuthParams,
13723	com::Utf8Str &aResult)
13724	{
13725	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13726
13727	HRESULT hr = S_OK;
13728
13729	if (!mAuthLibCtx.hAuthLibrary)
13730	{
13731	/* Load the external authentication library. */
13732	Bstr authLibrary;
13733	mVRDEServer->COMGETTER(AuthLibrary)(authLibrary.asOutParam());
13734
13735	Utf8Str filename = authLibrary;
13736
13737	int rc = AuthLibLoad(&mAuthLibCtx, filename.c_str());
13738	if (RT_FAILURE(rc))
13739	{
13740	hr = setError(E_FAIL,
13741	tr("Could not load the external authentication library '%s' (%Rrc)"),
13742	filename.c_str(), rc);
13743	}
13744	}
13745
13746	/* The auth library might need the machine lock. */
13747	alock.release();
13748
13749	if (FAILED(hr))
13750	return hr;
13751
13752	if (aAuthParams[0] == "VRDEAUTH" && aAuthParams.size() == 7)
13753	{
13754	enum VRDEAuthParams
13755	{
13756	parmUuid = 1,
13757	parmGuestJudgement,
13758	parmUser,
13759	parmPassword,
13760	parmDomain,
13761	parmClientId
13762	};
13763
13764	AuthResult result = AuthResultAccessDenied;
13765
13766	Guid uuid(aAuthParams[parmUuid]);
13767	AuthGuestJudgement guestJudgement = (AuthGuestJudgement)aAuthParams[parmGuestJudgement].toUInt32();
13768	uint32_t u32ClientId = aAuthParams[parmClientId].toUInt32();
13769
13770	result = AuthLibAuthenticate(&mAuthLibCtx,
13771	uuid.raw(), guestJudgement,
13772	aAuthParams[parmUser].c_str(),
13773	aAuthParams[parmPassword].c_str(),
13774	aAuthParams[parmDomain].c_str(),
13775	u32ClientId);
13776
13777	/* Hack: aAuthParams[parmPassword] is const but the code believes in writable memory. */
13778	size_t cbPassword = aAuthParams[parmPassword].length();
13779	if (cbPassword)
13780	{
13781	RTMemWipeThoroughly((void )aAuthParams[parmPassword].c_str(), cbPassword, 10 / cPasses */);
13782	memset((void *)aAuthParams[parmPassword].c_str(), 'x', cbPassword);
13783	}
13784
13785	if (result == AuthResultAccessGranted)
13786	aResult = "granted";
13787	else
13788	aResult = "denied";
13789
13790	LogRel(("AUTH: VRDE authentification for user '%s' result '%s'\n",
13791	aAuthParams[parmUser].c_str(), aResult.c_str()));
13792	}
13793	else if (aAuthParams[0] == "VRDEAUTHDISCONNECT" && aAuthParams.size() == 3)
13794	{
13795	enum VRDEAuthDisconnectParams
13796	{
13797	parmUuid = 1,
13798	parmClientId
13799	};
13800
13801	Guid uuid(aAuthParams[parmUuid]);
13802	uint32_t u32ClientId = 0;
13803	AuthLibDisconnect(&mAuthLibCtx, uuid.raw(), u32ClientId);
13804	}
13805	else
13806	{
13807	hr = E_INVALIDARG;
13808	}
13809
13810	return hr;
13811	}
13812
13813	// public methods only for internal purposes
13814	/////////////////////////////////////////////////////////////////////////////
13815
13816	#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
13817	/**
13818	* Called from the client watcher thread to check for expected or unexpected
13819	* death of the client process that has a direct session to this machine.
13820	*
13821	* On Win32 and on OS/2, this method is called only when we've got the
13822	* mutex (i.e. the client has either died or terminated normally) so it always
13823	* returns @c true (the client is terminated, the session machine is
13824	* uninitialized).
13825	*
13826	* On other platforms, the method returns @c true if the client process has
13827	* terminated normally or abnormally and the session machine was uninitialized,
13828	* and @c false if the client process is still alive.
13829	*
13830	* @note Locks this object for writing.
13831	*/
13832	bool SessionMachine::i_checkForDeath()
13833	{
13834	Uninit::Reason reason;
13835	bool terminated = false;
13836
13837	/* Enclose autoCaller with a block because calling uninit() from under it
13838	* will deadlock. */
13839	{
13840	AutoCaller autoCaller(this);
13841	if (!autoCaller.isOk())
13842	{
13843	/* return true if not ready, to cause the client watcher to exclude
13844	* the corresponding session from watching */
13845	LogFlowThisFunc(("Already uninitialized!\n"));
13846	return true;
13847	}
13848
13849	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13850
13851	/* Determine the reason of death: if the session state is Closing here,
13852	* everything is fine. Otherwise it means that the client did not call
13853	* OnSessionEnd() before it released the IPC semaphore. This may happen
13854	* either because the client process has abnormally terminated, or
13855	* because it simply forgot to call ISession::Close() before exiting. We
13856	* threat the latter also as an abnormal termination (see
13857	* Session::uninit() for details). */
13858	reason = mData->mSession.mState == SessionState_Unlocking ?
13859	Uninit::Normal :
13860	Uninit::Abnormal;
13861
13862	if (mClientToken)
13863	terminated = mClientToken->release();
13864	} /* AutoCaller block */
13865
13866	if (terminated)
13867	uninit(reason);
13868
13869	return terminated;
13870	}
13871
13872	void SessionMachine::i_getTokenId(Utf8Str &strTokenId)
13873	{
13874	LogFlowThisFunc(("\n"));
13875
13876	strTokenId.setNull();
13877
13878	AutoCaller autoCaller(this);
13879	AssertComRCReturnVoid(autoCaller.rc());
13880
13881	Assert(mClientToken);
13882	if (mClientToken)
13883	mClientToken->getId(strTokenId);
13884	}
13885	#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
13886	IToken *SessionMachine::i_getToken()
13887	{
13888	LogFlowThisFunc(("\n"));
13889
13890	AutoCaller autoCaller(this);
13891	AssertComRCReturn(autoCaller.rc(), NULL);
13892
13893	Assert(mClientToken);
13894	if (mClientToken)
13895	return mClientToken->getToken();
13896	else
13897	return NULL;
13898	}
13899	#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
13900
13901	Machine::ClientToken *SessionMachine::i_getClientToken()
13902	{
13903	LogFlowThisFunc(("\n"));
13904
13905	AutoCaller autoCaller(this);
13906	AssertComRCReturn(autoCaller.rc(), NULL);
13907
13908	return mClientToken;
13909	}
13910
13911
13912	/**
13913	* @note Locks this object for reading.
13914	*/
13915	HRESULT SessionMachine::i_onNetworkAdapterChange(INetworkAdapter *networkAdapter, BOOL changeAdapter)
13916	{
13917	LogFlowThisFunc(("\n"));
13918
13919	AutoCaller autoCaller(this);
13920	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
13921
13922	ComPtr<IInternalSessionControl> directControl;
13923	{
13924	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13925	if (mData->mSession.mLockType == LockType_VM)
13926	directControl = mData->mSession.mDirectControl;
13927	}
13928
13929	/* ignore notifications sent after #OnSessionEnd() is called */
13930	if (!directControl)
13931	return S_OK;
13932
13933	return directControl->OnNetworkAdapterChange(networkAdapter, changeAdapter);
13934	}
13935
13936	/**
13937	* @note Locks this object for reading.
13938	*/
13939	HRESULT SessionMachine::i_onNATRedirectRuleChange(ULONG ulSlot, BOOL aNatRuleRemove, IN_BSTR aRuleName,
13940	NATProtocol_T aProto, IN_BSTR aHostIp, LONG aHostPort,
13941	IN_BSTR aGuestIp, LONG aGuestPort)
13942	{
13943	LogFlowThisFunc(("\n"));
13944
13945	AutoCaller autoCaller(this);
13946	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
13947
13948	ComPtr<IInternalSessionControl> directControl;
13949	{
13950	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13951	if (mData->mSession.mLockType == LockType_VM)
13952	directControl = mData->mSession.mDirectControl;
13953	}
13954
13955	/* ignore notifications sent after #OnSessionEnd() is called */
13956	if (!directControl)
13957	return S_OK;
13958	/*
13959	* instead acting like callback we ask IVirtualBox deliver corresponding event
13960	*/
13961
13962	mParent->i_onNatRedirectChange(i_getId(), ulSlot, RT_BOOL(aNatRuleRemove), aRuleName, aProto, aHostIp,
13963	(uint16_t)aHostPort, aGuestIp, (uint16_t)aGuestPort);
13964	return S_OK;
13965	}
13966
13967	/**
13968	* @note Locks this object for reading.
13969	*/
13970	HRESULT SessionMachine::i_onAudioAdapterChange(IAudioAdapter *audioAdapter)
13971	{
13972	LogFlowThisFunc(("\n"));
13973
13974	AutoCaller autoCaller(this);
13975	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
13976
13977	ComPtr<IInternalSessionControl> directControl;
13978	{
13979	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13980	if (mData->mSession.mLockType == LockType_VM)
13981	directControl = mData->mSession.mDirectControl;
13982	}
13983
13984	/* ignore notifications sent after #OnSessionEnd() is called */
13985	if (!directControl)
13986	return S_OK;
13987
13988	return directControl->OnAudioAdapterChange(audioAdapter);
13989	}
13990
13991	/**
13992	* @note Locks this object for reading.
13993	*/
13994	HRESULT SessionMachine::i_onSerialPortChange(ISerialPort *serialPort)
13995	{
13996	LogFlowThisFunc(("\n"));
13997
13998	AutoCaller autoCaller(this);
13999	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
14000
14001	ComPtr<IInternalSessionControl> directControl;
14002	{
14003	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14004	if (mData->mSession.mLockType == LockType_VM)
14005	directControl = mData->mSession.mDirectControl;
14006	}
14007
14008	/* ignore notifications sent after #OnSessionEnd() is called */
14009	if (!directControl)
14010	return S_OK;
14011
14012	return directControl->OnSerialPortChange(serialPort);
14013	}
14014
14015	/**
14016	* @note Locks this object for reading.
14017	*/
14018	HRESULT SessionMachine::i_onParallelPortChange(IParallelPort *parallelPort)
14019	{
14020	LogFlowThisFunc(("\n"));
14021
14022	AutoCaller autoCaller(this);
14023	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
14024
14025	ComPtr<IInternalSessionControl> directControl;
14026	{
14027	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14028	if (mData->mSession.mLockType == LockType_VM)
14029	directControl = mData->mSession.mDirectControl;
14030	}
14031
14032	/* ignore notifications sent after #OnSessionEnd() is called */
14033	if (!directControl)
14034	return S_OK;
14035
14036	return directControl->OnParallelPortChange(parallelPort);
14037	}
14038
14039	/**
14040	* @note Locks this object for reading.
14041	*/
14042	HRESULT SessionMachine::i_onStorageControllerChange()
14043	{
14044	LogFlowThisFunc(("\n"));
14045
14046	AutoCaller autoCaller(this);
14047	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
14048
14049	ComPtr<IInternalSessionControl> directControl;
14050	{
14051	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14052	if (mData->mSession.mLockType == LockType_VM)
14053	directControl = mData->mSession.mDirectControl;
14054	}
14055
14056	/* ignore notifications sent after #OnSessionEnd() is called */
14057	if (!directControl)
14058	return S_OK;
14059
14060	return directControl->OnStorageControllerChange();
14061	}
14062
14063	/**
14064	* @note Locks this object for reading.
14065	*/
14066	HRESULT SessionMachine::i_onMediumChange(IMediumAttachment *aAttachment, BOOL aForce)
14067	{
14068	LogFlowThisFunc(("\n"));
14069
14070	AutoCaller autoCaller(this);
14071	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
14072
14073	ComPtr<IInternalSessionControl> directControl;
14074	{
14075	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14076	if (mData->mSession.mLockType == LockType_VM)
14077	directControl = mData->mSession.mDirectControl;
14078	}
14079
14080	/* ignore notifications sent after #OnSessionEnd() is called */
14081	if (!directControl)
14082	return S_OK;
14083
14084	return directControl->OnMediumChange(aAttachment, aForce);
14085	}
14086
14087	/**
14088	* @note Locks this object for reading.
14089	*/
14090	HRESULT SessionMachine::i_onCPUChange(ULONG aCPU, BOOL aRemove)
14091	{
14092	LogFlowThisFunc(("\n"));
14093
14094	AutoCaller autoCaller(this);
14095	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
14096
14097	ComPtr<IInternalSessionControl> directControl;
14098	{
14099	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14100	if (mData->mSession.mLockType == LockType_VM)
14101	directControl = mData->mSession.mDirectControl;
14102	}
14103
14104	/* ignore notifications sent after #OnSessionEnd() is called */
14105	if (!directControl)
14106	return S_OK;
14107
14108	return directControl->OnCPUChange(aCPU, aRemove);
14109	}
14110
14111	HRESULT SessionMachine::i_onCPUExecutionCapChange(ULONG aExecutionCap)
14112	{
14113	LogFlowThisFunc(("\n"));
14114
14115	AutoCaller autoCaller(this);
14116	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
14117
14118	ComPtr<IInternalSessionControl> directControl;
14119	{
14120	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14121	if (mData->mSession.mLockType == LockType_VM)
14122	directControl = mData->mSession.mDirectControl;
14123	}
14124
14125	/* ignore notifications sent after #OnSessionEnd() is called */
14126	if (!directControl)
14127	return S_OK;
14128
14129	return directControl->OnCPUExecutionCapChange(aExecutionCap);
14130	}
14131
14132	/**
14133	* @note Locks this object for reading.
14134	*/
14135	HRESULT SessionMachine::i_onVRDEServerChange(BOOL aRestart)
14136	{
14137	LogFlowThisFunc(("\n"));
14138
14139	AutoCaller autoCaller(this);
14140	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
14141
14142	ComPtr<IInternalSessionControl> directControl;
14143	{
14144	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14145	if (mData->mSession.mLockType == LockType_VM)
14146	directControl = mData->mSession.mDirectControl;
14147	}
14148
14149	/* ignore notifications sent after #OnSessionEnd() is called */
14150	if (!directControl)
14151	return S_OK;
14152
14153	return directControl->OnVRDEServerChange(aRestart);
14154	}
14155
14156	/**
14157	* @note Locks this object for reading.
14158	*/
14159	HRESULT SessionMachine::i_onVideoCaptureChange()
14160	{
14161	LogFlowThisFunc(("\n"));
14162
14163	AutoCaller autoCaller(this);
14164	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
14165
14166	ComPtr<IInternalSessionControl> directControl;
14167	{
14168	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14169	if (mData->mSession.mLockType == LockType_VM)
14170	directControl = mData->mSession.mDirectControl;
14171	}
14172
14173	/* ignore notifications sent after #OnSessionEnd() is called */
14174	if (!directControl)
14175	return S_OK;
14176
14177	return directControl->OnVideoCaptureChange();
14178	}
14179
14180	/**
14181	* @note Locks this object for reading.
14182	*/
14183	HRESULT SessionMachine::i_onUSBControllerChange()
14184	{
14185	LogFlowThisFunc(("\n"));
14186
14187	AutoCaller autoCaller(this);
14188	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
14189
14190	ComPtr<IInternalSessionControl> directControl;
14191	{
14192	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14193	if (mData->mSession.mLockType == LockType_VM)
14194	directControl = mData->mSession.mDirectControl;
14195	}
14196
14197	/* ignore notifications sent after #OnSessionEnd() is called */
14198	if (!directControl)
14199	return S_OK;
14200
14201	return directControl->OnUSBControllerChange();
14202	}
14203
14204	/**
14205	* @note Locks this object for reading.
14206	*/
14207	HRESULT SessionMachine::i_onSharedFolderChange()
14208	{
14209	LogFlowThisFunc(("\n"));
14210
14211	AutoCaller autoCaller(this);
14212	AssertComRCReturnRC(autoCaller.rc());
14213
14214	ComPtr<IInternalSessionControl> directControl;
14215	{
14216	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14217	if (mData->mSession.mLockType == LockType_VM)
14218	directControl = mData->mSession.mDirectControl;
14219	}
14220
14221	/* ignore notifications sent after #OnSessionEnd() is called */
14222	if (!directControl)
14223	return S_OK;
14224
14225	return directControl->OnSharedFolderChange(FALSE /* aGlobal */);
14226	}
14227
14228	/**
14229	* @note Locks this object for reading.
14230	*/
14231	HRESULT SessionMachine::i_onClipboardModeChange(ClipboardMode_T aClipboardMode)
14232	{
14233	LogFlowThisFunc(("\n"));
14234
14235	AutoCaller autoCaller(this);
14236	AssertComRCReturnRC(autoCaller.rc());
14237
14238	ComPtr<IInternalSessionControl> directControl;
14239	{
14240	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14241	if (mData->mSession.mLockType == LockType_VM)
14242	directControl = mData->mSession.mDirectControl;
14243	}
14244
14245	/* ignore notifications sent after #OnSessionEnd() is called */
14246	if (!directControl)
14247	return S_OK;
14248
14249	return directControl->OnClipboardModeChange(aClipboardMode);
14250	}
14251
14252	/**
14253	* @note Locks this object for reading.
14254	*/
14255	HRESULT SessionMachine::i_onDnDModeChange(DnDMode_T aDnDMode)
14256	{
14257	LogFlowThisFunc(("\n"));
14258
14259	AutoCaller autoCaller(this);
14260	AssertComRCReturnRC(autoCaller.rc());
14261
14262	ComPtr<IInternalSessionControl> directControl;
14263	{
14264	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14265	if (mData->mSession.mLockType == LockType_VM)
14266	directControl = mData->mSession.mDirectControl;
14267	}
14268
14269	/* ignore notifications sent after #OnSessionEnd() is called */
14270	if (!directControl)
14271	return S_OK;
14272
14273	return directControl->OnDnDModeChange(aDnDMode);
14274	}
14275
14276	/**
14277	* @note Locks this object for reading.
14278	*/
14279	HRESULT SessionMachine::i_onBandwidthGroupChange(IBandwidthGroup *aBandwidthGroup)
14280	{
14281	LogFlowThisFunc(("\n"));
14282
14283	AutoCaller autoCaller(this);
14284	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
14285
14286	ComPtr<IInternalSessionControl> directControl;
14287	{
14288	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14289	if (mData->mSession.mLockType == LockType_VM)
14290	directControl = mData->mSession.mDirectControl;
14291	}
14292
14293	/* ignore notifications sent after #OnSessionEnd() is called */
14294	if (!directControl)
14295	return S_OK;
14296
14297	return directControl->OnBandwidthGroupChange(aBandwidthGroup);
14298	}
14299
14300	/**
14301	* @note Locks this object for reading.
14302	*/
14303	HRESULT SessionMachine::i_onStorageDeviceChange(IMediumAttachment *aAttachment, BOOL aRemove, BOOL aSilent)
14304	{
14305	LogFlowThisFunc(("\n"));
14306
14307	AutoCaller autoCaller(this);
14308	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
14309
14310	ComPtr<IInternalSessionControl> directControl;
14311	{
14312	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14313	if (mData->mSession.mLockType == LockType_VM)
14314	directControl = mData->mSession.mDirectControl;
14315	}
14316
14317	/* ignore notifications sent after #OnSessionEnd() is called */
14318	if (!directControl)
14319	return S_OK;
14320
14321	return directControl->OnStorageDeviceChange(aAttachment, aRemove, aSilent);
14322	}
14323
14324	/**
14325	* Returns @c true if this machine's USB controller reports it has a matching
14326	* filter for the given USB device and @c false otherwise.
14327	*
14328	* @note locks this object for reading.
14329	*/
14330	bool SessionMachine::i_hasMatchingUSBFilter(const ComObjPtr<HostUSBDevice> &aDevice, ULONG *aMaskedIfs)
14331	{
14332	AutoCaller autoCaller(this);
14333	/* silently return if not ready -- this method may be called after the
14334	* direct machine session has been called */
14335	if (!autoCaller.isOk())
14336	return false;
14337
14338	#ifdef VBOX_WITH_USB
14339	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14340
14341	switch (mData->mMachineState)
14342	{
14343	case MachineState_Starting:
14344	case MachineState_Restoring:
14345	case MachineState_TeleportingIn:
14346	case MachineState_Paused:
14347	case MachineState_Running:
14348	/** @todo Live Migration: snapshoting & teleporting. Need to fend things of
14349	* elsewhere... */
14350	alock.release();
14351	return mUSBDeviceFilters->i_hasMatchingFilter(aDevice, aMaskedIfs);
14352	default: break;
14353	}
14354	#else
14355	NOREF(aDevice);
14356	NOREF(aMaskedIfs);
14357	#endif
14358	return false;
14359	}
14360
14361	/**
14362	* @note The calls shall hold no locks. Will temporarily lock this object for reading.
14363	*/
14364	HRESULT SessionMachine::i_onUSBDeviceAttach(IUSBDevice *aDevice,
14365	IVirtualBoxErrorInfo *aError,
14366	ULONG aMaskedIfs,
14367	const com::Utf8Str &aCaptureFilename)
14368	{
14369	LogFlowThisFunc(("\n"));
14370
14371	AutoCaller autoCaller(this);
14372
14373	/* This notification may happen after the machine object has been
14374	* uninitialized (the session was closed), so don't assert. */
14375	if (FAILED(autoCaller.rc())) return autoCaller.rc();
14376
14377	ComPtr<IInternalSessionControl> directControl;
14378	{
14379	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14380	if (mData->mSession.mLockType == LockType_VM)
14381	directControl = mData->mSession.mDirectControl;
14382	}
14383
14384	/* fail on notifications sent after #OnSessionEnd() is called, it is
14385	* expected by the caller */
14386	if (!directControl)
14387	return E_FAIL;
14388
14389	/* No locks should be held at this point. */
14390	AssertMsg(RTLockValidatorWriteLockGetCount(RTThreadSelf()) == 0, ("%d\n", RTLockValidatorWriteLockGetCount(RTThreadSelf())));
14391	AssertMsg(RTLockValidatorReadLockGetCount(RTThreadSelf()) == 0, ("%d\n", RTLockValidatorReadLockGetCount(RTThreadSelf())));
14392
14393	return directControl->OnUSBDeviceAttach(aDevice, aError, aMaskedIfs, Bstr(aCaptureFilename).raw());
14394	}
14395
14396	/**
14397	* @note The calls shall hold no locks. Will temporarily lock this object for reading.
14398	*/
14399	HRESULT SessionMachine::i_onUSBDeviceDetach(IN_BSTR aId,
14400	IVirtualBoxErrorInfo *aError)
14401	{
14402	LogFlowThisFunc(("\n"));
14403
14404	AutoCaller autoCaller(this);
14405
14406	/* This notification may happen after the machine object has been
14407	* uninitialized (the session was closed), so don't assert. */
14408	if (FAILED(autoCaller.rc())) return autoCaller.rc();
14409
14410	ComPtr<IInternalSessionControl> directControl;
14411	{
14412	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14413	if (mData->mSession.mLockType == LockType_VM)
14414	directControl = mData->mSession.mDirectControl;
14415	}
14416
14417	/* fail on notifications sent after #OnSessionEnd() is called, it is
14418	* expected by the caller */
14419	if (!directControl)
14420	return E_FAIL;
14421
14422	/* No locks should be held at this point. */
14423	AssertMsg(RTLockValidatorWriteLockGetCount(RTThreadSelf()) == 0, ("%d\n", RTLockValidatorWriteLockGetCount(RTThreadSelf())));
14424	AssertMsg(RTLockValidatorReadLockGetCount(RTThreadSelf()) == 0, ("%d\n", RTLockValidatorReadLockGetCount(RTThreadSelf())));
14425
14426	return directControl->OnUSBDeviceDetach(aId, aError);
14427	}
14428
14429	// protected methods
14430	/////////////////////////////////////////////////////////////////////////////
14431
14432	/**
14433	* Deletes the given file if it is no longer in use by either the current machine state
14434	* (if the machine is "saved") or any of the machine's snapshots.
14435	*
14436	* Note: This checks mSSData->strStateFilePath, which is shared by the Machine and SessionMachine
14437	* but is different for each SnapshotMachine. When calling this, the order of calling this
14438	* function on the one hand and changing that variable OR the snapshots tree on the other hand
14439	* is therefore critical. I know, it's all rather messy.
14440	*
14441	* @param strStateFile
14442	* @param pSnapshotToIgnore Passed to Snapshot::sharesSavedStateFile(); this snapshot is ignored in
14443	* the test for whether the saved state file is in use.
14444	*/
14445	void SessionMachine::i_releaseSavedStateFile(const Utf8Str &strStateFile,
14446	Snapshot *pSnapshotToIgnore)
14447	{
14448	// it is safe to delete this saved state file if it is not currently in use by the machine ...
14449	if ( (strStateFile.isNotEmpty())
14450	&& (strStateFile != mSSData->strStateFilePath) // session machine's saved state
14451	)
14452	// ... and it must also not be shared with other snapshots
14453	if ( !mData->mFirstSnapshot
14454	\|\| !mData->mFirstSnapshot->i_sharesSavedStateFile(strStateFile, pSnapshotToIgnore)
14455	// this checks the SnapshotMachine's state file paths
14456	)
14457	RTFileDelete(strStateFile.c_str());
14458	}
14459
14460	/**
14461	* Locks the attached media.
14462	*
14463	* All attached hard disks are locked for writing and DVD/floppy are locked for
14464	* reading. Parents of attached hard disks (if any) are locked for reading.
14465	*
14466	* This method also performs accessibility check of all media it locks: if some
14467	* media is inaccessible, the method will return a failure and a bunch of
14468	* extended error info objects per each inaccessible medium.
14469	*
14470	* Note that this method is atomic: if it returns a success, all media are
14471	* locked as described above; on failure no media is locked at all (all
14472	* succeeded individual locks will be undone).
14473	*
14474	* The caller is responsible for doing the necessary state sanity checks.
14475	*
14476	* The locks made by this method must be undone by calling #unlockMedia() when
14477	* no more needed.
14478	*/
14479	HRESULT SessionMachine::i_lockMedia()
14480	{
14481	AutoCaller autoCaller(this);
14482	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
14483
14484	AutoMultiWriteLock2 alock(this->lockHandle(),
14485	&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
14486
14487	/* bail out if trying to lock things with already set up locking */
14488	AssertReturn(mData->mSession.mLockedMedia.IsEmpty(), E_FAIL);
14489
14490	MultiResult mrc(S_OK);
14491
14492	/* Collect locking information for all medium objects attached to the VM. */
14493	for (MediumAttachmentList::const_iterator
14494	it = mMediumAttachments->begin();
14495	it != mMediumAttachments->end();
14496	++it)
14497	{
14498	MediumAttachment pAtt = it;
14499	DeviceType_T devType = pAtt->i_getType();
14500	Medium *pMedium = pAtt->i_getMedium();
14501
14502	MediumLockList *pMediumLockList(new MediumLockList());
14503	// There can be attachments without a medium (floppy/dvd), and thus
14504	// it's impossible to create a medium lock list. It still makes sense
14505	// to have the empty medium lock list in the map in case a medium is
14506	// attached later.
14507	if (pMedium != NULL)
14508	{
14509	MediumType_T mediumType = pMedium->i_getType();
14510	bool fIsReadOnlyLock = mediumType == MediumType_Readonly
14511	\|\| mediumType == MediumType_Shareable;
14512	bool fIsVitalImage = (devType == DeviceType_HardDisk);
14513
14514	alock.release();
14515	mrc = pMedium->i_createMediumLockList(fIsVitalImage /* fFailIfInaccessible */,
14516	!fIsReadOnlyLock ? pMedium : NULL /* pToLockWrite */,
14517	false /* fMediumLockWriteAll */,
14518	NULL,
14519	*pMediumLockList);
14520	alock.acquire();
14521	if (FAILED(mrc))
14522	{
14523	delete pMediumLockList;
14524	mData->mSession.mLockedMedia.Clear();
14525	break;
14526	}
14527	}
14528
14529	HRESULT rc = mData->mSession.mLockedMedia.Insert(pAtt, pMediumLockList);
14530	if (FAILED(rc))
14531	{
14532	mData->mSession.mLockedMedia.Clear();
14533	mrc = setError(rc,
14534	tr("Collecting locking information for all attached media failed"));
14535	break;
14536	}
14537	}
14538
14539	if (SUCCEEDED(mrc))
14540	{
14541	/* Now lock all media. If this fails, nothing is locked. */
14542	alock.release();
14543	HRESULT rc = mData->mSession.mLockedMedia.Lock();
14544	alock.acquire();
14545	if (FAILED(rc))
14546	{
14547	mrc = setError(rc,
14548	tr("Locking of attached media failed. A possible reason is that one of the media is attached to a running VM"));
14549	}
14550	}
14551
14552	return mrc;
14553	}
14554
14555	/**
14556	* Undoes the locks made by by #lockMedia().
14557	*/
14558	HRESULT SessionMachine::i_unlockMedia()
14559	{
14560	AutoCaller autoCaller(this);
14561	AssertComRCReturn(autoCaller.rc(),autoCaller.rc());
14562
14563	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
14564
14565	/* we may be holding important error info on the current thread;
14566	* preserve it */
14567	ErrorInfoKeeper eik;
14568
14569	HRESULT rc = mData->mSession.mLockedMedia.Clear();
14570	AssertComRC(rc);
14571	return rc;
14572	}
14573
14574	/**
14575	* Helper to change the machine state (reimplementation).
14576	*
14577	* @note Locks this object for writing.
14578	* @note This method must not call i_saveSettings or SaveSettings, otherwise
14579	* it can cause crashes in random places due to unexpectedly committing
14580	* the current settings. The caller is responsible for that. The call
14581	* to saveStateSettings is fine, because this method does not commit.
14582	*/
14583	HRESULT SessionMachine::i_setMachineState(MachineState_T aMachineState)
14584	{
14585	LogFlowThisFuncEnter();
14586	LogFlowThisFunc(("aMachineState=%s\n", Global::stringifyMachineState(aMachineState) ));
14587
14588	AutoCaller autoCaller(this);
14589	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
14590
14591	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
14592
14593	MachineState_T oldMachineState = mData->mMachineState;
14594
14595	AssertMsgReturn(oldMachineState != aMachineState,
14596	("oldMachineState=%s, aMachineState=%s\n",
14597	Global::stringifyMachineState(oldMachineState), Global::stringifyMachineState(aMachineState)),
14598	E_FAIL);
14599
14600	HRESULT rc = S_OK;
14601
14602	int stsFlags = 0;
14603	bool deleteSavedState = false;
14604
14605	/* detect some state transitions */
14606
14607	if ( ( oldMachineState == MachineState_Saved
14608	&& aMachineState == MachineState_Restoring)
14609	\|\| ( ( oldMachineState == MachineState_PoweredOff
14610	\|\| oldMachineState == MachineState_Teleported
14611	\|\| oldMachineState == MachineState_Aborted
14612	)
14613	&& ( aMachineState == MachineState_TeleportingIn
14614	\|\| aMachineState == MachineState_Starting
14615	)
14616	)
14617	)
14618	{
14619	/* The EMT thread is about to start */
14620
14621	/* Nothing to do here for now... */
14622
14623	/// @todo NEWMEDIA don't let mDVDDrive and other children
14624	/// change anything when in the Starting/Restoring state
14625	}
14626	else if ( ( oldMachineState == MachineState_Running
14627	\|\| oldMachineState == MachineState_Paused
14628	\|\| oldMachineState == MachineState_Teleporting
14629	\|\| oldMachineState == MachineState_OnlineSnapshotting
14630	\|\| oldMachineState == MachineState_LiveSnapshotting
14631	\|\| oldMachineState == MachineState_Stuck
14632	\|\| oldMachineState == MachineState_Starting
14633	\|\| oldMachineState == MachineState_Stopping
14634	\|\| oldMachineState == MachineState_Saving
14635	\|\| oldMachineState == MachineState_Restoring
14636	\|\| oldMachineState == MachineState_TeleportingPausedVM
14637	\|\| oldMachineState == MachineState_TeleportingIn
14638	)
14639	&& ( aMachineState == MachineState_PoweredOff
14640	\|\| aMachineState == MachineState_Saved
14641	\|\| aMachineState == MachineState_Teleported
14642	\|\| aMachineState == MachineState_Aborted
14643	)
14644	)
14645	{
14646	/* The EMT thread has just stopped, unlock attached media. Note that as
14647	* opposed to locking that is done from Console, we do unlocking here
14648	* because the VM process may have aborted before having a chance to
14649	* properly unlock all media it locked. */
14650
14651	unlockMedia();
14652	}
14653
14654	if (oldMachineState == MachineState_Restoring)
14655	{
14656	if (aMachineState != MachineState_Saved)
14657	{
14658	/*
14659	* delete the saved state file once the machine has finished
14660	* restoring from it (note that Console sets the state from
14661	* Restoring to Saved if the VM couldn't restore successfully,
14662	* to give the user an ability to fix an error and retry --
14663	* we keep the saved state file in this case)
14664	*/
14665	deleteSavedState = true;
14666	}
14667	}
14668	else if ( oldMachineState == MachineState_Saved
14669	&& ( aMachineState == MachineState_PoweredOff
14670	\|\| aMachineState == MachineState_Aborted
14671	\|\| aMachineState == MachineState_Teleported
14672	)
14673	)
14674	{
14675	/*
14676	* delete the saved state after SessionMachine::ForgetSavedState() is called
14677	* or if the VM process (owning a direct VM session) crashed while the
14678	* VM was Saved
14679	*/
14680
14681	/// @todo (dmik)
14682	// Not sure that deleting the saved state file just because of the
14683	// client death before it attempted to restore the VM is a good
14684	// thing. But when it crashes we need to go to the Aborted state
14685	// which cannot have the saved state file associated... The only
14686	// way to fix this is to make the Aborted condition not a VM state
14687	// but a bool flag: i.e., when a crash occurs, set it to true and
14688	// change the state to PoweredOff or Saved depending on the
14689	// saved state presence.
14690
14691	deleteSavedState = true;
14692	mData->mCurrentStateModified = TRUE;
14693	stsFlags \|= SaveSTS_CurStateModified;
14694	}
14695
14696	if ( aMachineState == MachineState_Starting
14697	\|\| aMachineState == MachineState_Restoring
14698	\|\| aMachineState == MachineState_TeleportingIn
14699	)
14700	{
14701	/* set the current state modified flag to indicate that the current
14702	* state is no more identical to the state in the
14703	* current snapshot */
14704	if (!mData->mCurrentSnapshot.isNull())
14705	{
14706	mData->mCurrentStateModified = TRUE;
14707	stsFlags \|= SaveSTS_CurStateModified;
14708	}
14709	}
14710
14711	if (deleteSavedState)
14712	{
14713	if (mRemoveSavedState)
14714	{
14715	Assert(!mSSData->strStateFilePath.isEmpty());
14716
14717	// it is safe to delete the saved state file if ...
14718	if ( !mData->mFirstSnapshot // ... we have no snapshots or
14719	\|\| !mData->mFirstSnapshot->i_sharesSavedStateFile(mSSData->strStateFilePath, NULL /* pSnapshotToIgnore */)
14720	// ... none of the snapshots share the saved state file
14721	)
14722	RTFileDelete(mSSData->strStateFilePath.c_str());
14723	}
14724
14725	mSSData->strStateFilePath.setNull();
14726	stsFlags \|= SaveSTS_StateFilePath;
14727	}
14728
14729	/* redirect to the underlying peer machine */
14730	mPeer->i_setMachineState(aMachineState);
14731
14732	if ( oldMachineState != MachineState_RestoringSnapshot
14733	&& ( aMachineState == MachineState_PoweredOff
14734	\|\| aMachineState == MachineState_Teleported
14735	\|\| aMachineState == MachineState_Aborted
14736	\|\| aMachineState == MachineState_Saved))
14737	{
14738	/* the machine has stopped execution
14739	* (or the saved state file was adopted) */
14740	stsFlags \|= SaveSTS_StateTimeStamp;
14741	}
14742
14743	if ( ( oldMachineState == MachineState_PoweredOff
14744	\|\| oldMachineState == MachineState_Aborted
14745	\|\| oldMachineState == MachineState_Teleported
14746	)
14747	&& aMachineState == MachineState_Saved)
14748	{
14749	/* the saved state file was adopted */
14750	Assert(!mSSData->strStateFilePath.isEmpty());
14751	stsFlags \|= SaveSTS_StateFilePath;
14752	}
14753
14754	#ifdef VBOX_WITH_GUEST_PROPS
14755	if ( aMachineState == MachineState_PoweredOff
14756	\|\| aMachineState == MachineState_Aborted
14757	\|\| aMachineState == MachineState_Teleported)
14758	{
14759	/* Make sure any transient guest properties get removed from the
14760	* property store on shutdown. */
14761	BOOL fNeedsSaving = mData->mGuestPropertiesModified;
14762
14763	/* remove it from the settings representation */
14764	settings::GuestPropertiesList &llGuestProperties = mData->pMachineConfigFile->hardwareMachine.llGuestProperties;
14765	for (settings::GuestPropertiesList::iterator
14766	it = llGuestProperties.begin();
14767	it != llGuestProperties.end();
14768	/nothing/)
14769	{
14770	const settings::GuestProperty &prop = *it;
14771	if ( prop.strFlags.contains("TRANSRESET", Utf8Str::CaseInsensitive)
14772	\|\| prop.strFlags.contains("TRANSIENT", Utf8Str::CaseInsensitive))
14773	{
14774	it = llGuestProperties.erase(it);
14775	fNeedsSaving = true;
14776	}
14777	else
14778	{
14779	++it;
14780	}
14781	}
14782
14783	/* Additionally remove it from the HWData representation. Required to
14784	* keep everything in sync, as this is what the API keeps using. */
14785	HWData::GuestPropertyMap &llHWGuestProperties = mHWData->mGuestProperties;
14786	for (HWData::GuestPropertyMap::iterator
14787	it = llHWGuestProperties.begin();
14788	it != llHWGuestProperties.end();
14789	/nothing/)
14790	{
14791	uint32_t fFlags = it->second.mFlags;
14792	if (fFlags & (GUEST_PROP_F_TRANSIENT \| GUEST_PROP_F_TRANSRESET))
14793	{
14794	/* iterator where we need to continue after the erase call
14795	* (C++03 is a fact still, and it doesn't return the iterator
14796	* which would allow continuing) */
14797	HWData::GuestPropertyMap::iterator it2 = it;
14798	++it2;
14799	llHWGuestProperties.erase(it);
14800	it = it2;
14801	fNeedsSaving = true;
14802	}
14803	else
14804	{
14805	++it;
14806	}
14807	}
14808
14809	if (fNeedsSaving)
14810	{
14811	mData->mCurrentStateModified = TRUE;
14812	stsFlags \|= SaveSTS_CurStateModified;
14813	}
14814	}
14815	#endif /* VBOX_WITH_GUEST_PROPS */
14816
14817	rc = i_saveStateSettings(stsFlags);
14818
14819	if ( ( oldMachineState != MachineState_PoweredOff
14820	&& oldMachineState != MachineState_Aborted
14821	&& oldMachineState != MachineState_Teleported
14822	)
14823	&& ( aMachineState == MachineState_PoweredOff
14824	\|\| aMachineState == MachineState_Aborted
14825	\|\| aMachineState == MachineState_Teleported
14826	)
14827	)
14828	{
14829	/* we've been shut down for any reason */
14830	/* no special action so far */
14831	}
14832
14833	LogFlowThisFunc(("rc=%Rhrc [%s]\n", rc, Global::stringifyMachineState(mData->mMachineState) ));
14834	LogFlowThisFuncLeave();
14835	return rc;
14836	}
14837
14838	/**
14839	* Sends the current machine state value to the VM process.
14840	*
14841	* @note Locks this object for reading, then calls a client process.
14842	*/
14843	HRESULT SessionMachine::i_updateMachineStateOnClient()
14844	{
14845	AutoCaller autoCaller(this);
14846	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
14847
14848	ComPtr<IInternalSessionControl> directControl;
14849	{
14850	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14851	AssertReturn(!!mData, E_FAIL);
14852	if (mData->mSession.mLockType == LockType_VM)
14853	directControl = mData->mSession.mDirectControl;
14854
14855	/* directControl may be already set to NULL here in #OnSessionEnd()
14856	* called too early by the direct session process while there is still
14857	* some operation (like deleting the snapshot) in progress. The client
14858	* process in this case is waiting inside Session::close() for the
14859	* "end session" process object to complete, while #uninit() called by
14860	* #i_checkForDeath() on the Watcher thread is waiting for the pending
14861	* operation to complete. For now, we accept this inconsistent behavior
14862	* and simply do nothing here. */
14863
14864	if (mData->mSession.mState == SessionState_Unlocking)
14865	return S_OK;
14866	}
14867
14868	/* ignore notifications sent after #OnSessionEnd() is called */
14869	if (!directControl)
14870	return S_OK;
14871
14872	return directControl->UpdateMachineState(mData->mMachineState);
14873	}
14874
14875
14876	/static/
14877	HRESULT Machine::i_setErrorStatic(HRESULT aResultCode, const char *pcszMsg, ...)
14878	{
14879	va_list args;
14880	va_start(args, pcszMsg);
14881	HRESULT rc = setErrorInternal(aResultCode,
14882	getStaticClassIID(),
14883	getStaticComponentName(),
14884	Utf8Str(pcszMsg, args),
14885	false /* aWarning */,
14886	true /* aLogIt */);
14887	va_end(args);
14888	return rc;
14889	}
14890
14891
14892	HRESULT Machine::updateState(MachineState_T aState)
14893	{
14894	NOREF(aState);
14895	ReturnComNotImplemented();
14896	}
14897
14898	HRESULT Machine::beginPowerUp(const ComPtr<IProgress> &aProgress)
14899	{
14900	NOREF(aProgress);
14901	ReturnComNotImplemented();
14902	}
14903
14904	HRESULT Machine::endPowerUp(LONG aResult)
14905	{
14906	NOREF(aResult);
14907	ReturnComNotImplemented();
14908	}
14909
14910	HRESULT Machine::beginPoweringDown(ComPtr<IProgress> &aProgress)
14911	{
14912	NOREF(aProgress);
14913	ReturnComNotImplemented();
14914	}
14915
14916	HRESULT Machine::endPoweringDown(LONG aResult,
14917	const com::Utf8Str &aErrMsg)
14918	{
14919	NOREF(aResult);
14920	NOREF(aErrMsg);
14921	ReturnComNotImplemented();
14922	}
14923
14924	HRESULT Machine::runUSBDeviceFilters(const ComPtr<IUSBDevice> &aDevice,
14925	BOOL *aMatched,
14926	ULONG *aMaskedInterfaces)
14927	{
14928	NOREF(aDevice);
14929	NOREF(aMatched);
14930	NOREF(aMaskedInterfaces);
14931	ReturnComNotImplemented();
14932
14933	}
14934
14935	HRESULT Machine::captureUSBDevice(const com::Guid &aId, const com::Utf8Str &aCaptureFilename)
14936	{
14937	NOREF(aId); NOREF(aCaptureFilename);
14938	ReturnComNotImplemented();
14939	}
14940
14941	HRESULT Machine::detachUSBDevice(const com::Guid &aId,
14942	BOOL aDone)
14943	{
14944	NOREF(aId);
14945	NOREF(aDone);
14946	ReturnComNotImplemented();
14947	}
14948
14949	HRESULT Machine::autoCaptureUSBDevices()
14950	{
14951	ReturnComNotImplemented();
14952	}
14953
14954	HRESULT Machine::detachAllUSBDevices(BOOL aDone)
14955	{
14956	NOREF(aDone);
14957	ReturnComNotImplemented();
14958	}
14959
14960	HRESULT Machine::onSessionEnd(const ComPtr<ISession> &aSession,
14961	ComPtr<IProgress> &aProgress)
14962	{
14963	NOREF(aSession);
14964	NOREF(aProgress);
14965	ReturnComNotImplemented();
14966	}
14967
14968	HRESULT Machine::finishOnlineMergeMedium()
14969	{
14970	ReturnComNotImplemented();
14971	}
14972
14973	HRESULT Machine::pullGuestProperties(std::vector<com::Utf8Str> &aNames,
14974	std::vector<com::Utf8Str> &aValues,
14975	std::vector<LONG64> &aTimestamps,
14976	std::vector<com::Utf8Str> &aFlags)
14977	{
14978	NOREF(aNames);
14979	NOREF(aValues);
14980	NOREF(aTimestamps);
14981	NOREF(aFlags);
14982	ReturnComNotImplemented();
14983	}
14984
14985	HRESULT Machine::pushGuestProperty(const com::Utf8Str &aName,
14986	const com::Utf8Str &aValue,
14987	LONG64 aTimestamp,
14988	const com::Utf8Str &aFlags)
14989	{
14990	NOREF(aName);
14991	NOREF(aValue);
14992	NOREF(aTimestamp);
14993	NOREF(aFlags);
14994	ReturnComNotImplemented();
14995	}
14996
14997	HRESULT Machine::lockMedia()
14998	{
14999	ReturnComNotImplemented();
15000	}
15001
15002	HRESULT Machine::unlockMedia()
15003	{
15004	ReturnComNotImplemented();
15005	}
15006
15007	HRESULT Machine::ejectMedium(const ComPtr<IMediumAttachment> &aAttachment,
15008	ComPtr<IMediumAttachment> &aNewAttachment)
15009	{
15010	NOREF(aAttachment);
15011	NOREF(aNewAttachment);
15012	ReturnComNotImplemented();
15013	}
15014
15015	HRESULT Machine::reportVmStatistics(ULONG aValidStats,
15016	ULONG aCpuUser,
15017	ULONG aCpuKernel,
15018	ULONG aCpuIdle,
15019	ULONG aMemTotal,
15020	ULONG aMemFree,
15021	ULONG aMemBalloon,
15022	ULONG aMemShared,
15023	ULONG aMemCache,
15024	ULONG aPagedTotal,
15025	ULONG aMemAllocTotal,
15026	ULONG aMemFreeTotal,
15027	ULONG aMemBalloonTotal,
15028	ULONG aMemSharedTotal,
15029	ULONG aVmNetRx,
15030	ULONG aVmNetTx)
15031	{
15032	NOREF(aValidStats);
15033	NOREF(aCpuUser);
15034	NOREF(aCpuKernel);
15035	NOREF(aCpuIdle);
15036	NOREF(aMemTotal);
15037	NOREF(aMemFree);
15038	NOREF(aMemBalloon);
15039	NOREF(aMemShared);
15040	NOREF(aMemCache);
15041	NOREF(aPagedTotal);
15042	NOREF(aMemAllocTotal);
15043	NOREF(aMemFreeTotal);
15044	NOREF(aMemBalloonTotal);
15045	NOREF(aMemSharedTotal);
15046	NOREF(aVmNetRx);
15047	NOREF(aVmNetTx);
15048	ReturnComNotImplemented();
15049	}
15050
15051	HRESULT Machine::authenticateExternal(const std::vector<com::Utf8Str> &aAuthParams,
15052	com::Utf8Str &aResult)
15053	{
15054	NOREF(aAuthParams);
15055	NOREF(aResult);
15056	ReturnComNotImplemented();
15057	}
15058
15059	HRESULT Machine::applyDefaults(const com::Utf8Str &aFlags)
15060	{
15061	NOREF(aFlags);
15062	ReturnComNotImplemented();
15063	}
15064
15065	/* This isn't handled entirely by the wrapper generator yet. */
15066	#ifdef VBOX_WITH_XPCOM
15067	NS_DECL_CLASSINFO(SessionMachine)
15068	NS_IMPL_THREADSAFE_ISUPPORTS2_CI(SessionMachine, IMachine, IInternalMachineControl)
15069
15070	NS_DECL_CLASSINFO(SnapshotMachine)
15071	NS_IMPL_THREADSAFE_ISUPPORTS1_CI(SnapshotMachine, IMachine)
15072	#endif

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

source: vbox/trunk/src/VBox/Main/src-server/MachineImpl.cpp@ 70335

Download in other formats: