MachineImpl.cpp@ 86697

Last change on this file since 86697 was 86498, checked in by vboxsync, 4 years ago
VBoxSVC/MachineImpl.cpp: Fixed use-after-free problem in Machine::i_prepareSaveSettings where a Utf8Str::printf was fed its old value as one of the format argument. bugref:9841
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 537.5 KB

Line
1	/* $Id: MachineImpl.cpp 86498 2020-10-08 17:00:21Z vboxsync $ */
2	/** @file
3	* Implementation of IMachine in VBoxSVC.
4	*/
5
6	/*
7	* Copyright (C) 2004-2020 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	#define LOG_GROUP LOG_GROUP_MAIN_MACHINE
19
20	/* Make sure all the stdint.h macros are included - must come first! */
21	#ifndef __STDC_LIMIT_MACROS
22	# define __STDC_LIMIT_MACROS
23	#endif
24	#ifndef __STDC_CONSTANT_MACROS
25	# define __STDC_CONSTANT_MACROS
26	#endif
27
28	#include "LoggingNew.h"
29	#include "VirtualBoxImpl.h"
30	#include "MachineImpl.h"
31	#include "ClientToken.h"
32	#include "ProgressImpl.h"
33	#include "ProgressProxyImpl.h"
34	#include "MediumAttachmentImpl.h"
35	#include "MediumImpl.h"
36	#include "MediumLock.h"
37	#include "USBControllerImpl.h"
38	#include "USBDeviceFiltersImpl.h"
39	#include "HostImpl.h"
40	#include "SharedFolderImpl.h"
41	#include "GuestOSTypeImpl.h"
42	#include "VirtualBoxErrorInfoImpl.h"
43	#include "StorageControllerImpl.h"
44	#include "DisplayImpl.h"
45	#include "DisplayUtils.h"
46	#include "MachineImplCloneVM.h"
47	#include "AutostartDb.h"
48	#include "SystemPropertiesImpl.h"
49	#include "MachineImplMoveVM.h"
50	#include "ExtPackManagerImpl.h"
51	#include "MachineLaunchVMCommonWorker.h"
52
53	// generated header
54	#include "VBoxEvents.h"
55
56	#ifdef VBOX_WITH_USB
57	# include "USBProxyService.h"
58	#endif
59
60	#include "AutoCaller.h"
61	#include "HashedPw.h"
62	#include "Performance.h"
63
64	#include <iprt/asm.h>
65	#include <iprt/path.h>
66	#include <iprt/dir.h>
67	#include <iprt/env.h>
68	#include <iprt/lockvalidator.h>
69	#include <iprt/process.h>
70	#include <iprt/cpp/utils.h>
71	#include <iprt/cpp/xml.h> /* xml::XmlFileWriter::s_pszSuff. /
72	#include <iprt/sha.h>
73	#include <iprt/string.h>
74	#include <iprt/ctype.h>
75
76	#include <VBox/com/array.h>
77	#include <VBox/com/list.h>
78
79	#include <VBox/err.h>
80	#include <VBox/param.h>
81	#include <VBox/settings.h>
82	#include <VBox/VMMDev.h>
83	#include <VBox/vmm/ssm.h>
84
85	#ifdef VBOX_WITH_GUEST_PROPS
86	# include <VBox/HostServices/GuestPropertySvc.h>
87	# include <VBox/com/array.h>
88	#endif
89
90	#ifdef VBOX_WITH_SHARED_CLIPBOARD
91	# include <VBox/HostServices/VBoxClipboardSvc.h>
92	#endif
93
94	#include "VBox/com/MultiResult.h"
95
96	#include <algorithm>
97
98	#ifdef VBOX_WITH_DTRACE_R3_MAIN
99	# include "dtrace/VBoxAPI.h"
100	#endif
101
102	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_OS2)
103	# define HOSTSUFF_EXE ".exe"
104	#else /* !RT_OS_WINDOWS */
105	# define HOSTSUFF_EXE ""
106	#endif /* !RT_OS_WINDOWS */
107
108	// defines / prototypes
109	/////////////////////////////////////////////////////////////////////////////
110
111	/////////////////////////////////////////////////////////////////////////////
112	// Machine::Data structure
113	/////////////////////////////////////////////////////////////////////////////
114
115	Machine::Data::Data()
116	{
117	mRegistered = FALSE;
118	pMachineConfigFile = NULL;
119	/* Contains hints on what has changed when the user is using the VM (config
120	* changes, running the VM, ...). This is used to decide if a config needs
121	* to be written to disk. */
122	flModifications = 0;
123	/* VM modification usually also trigger setting the current state to
124	* "Modified". Although this is not always the case. An e.g. is the VM
125	* initialization phase or when snapshot related data is changed. The
126	* actually behavior is controlled by the following flag. */
127	m_fAllowStateModification = false;
128	mAccessible = FALSE;
129	/* mUuid is initialized in Machine::init() */
130
131	mMachineState = MachineState_PoweredOff;
132	RTTimeNow(&mLastStateChange);
133
134	mMachineStateDeps = 0;
135	mMachineStateDepsSem = NIL_RTSEMEVENTMULTI;
136	mMachineStateChangePending = 0;
137
138	mCurrentStateModified = TRUE;
139	mGuestPropertiesModified = FALSE;
140
141	mSession.mPID = NIL_RTPROCESS;
142	mSession.mLockType = LockType_Null;
143	mSession.mState = SessionState_Unlocked;
144	}
145
146	Machine::Data::~Data()
147	{
148	if (mMachineStateDepsSem != NIL_RTSEMEVENTMULTI)
149	{
150	RTSemEventMultiDestroy(mMachineStateDepsSem);
151	mMachineStateDepsSem = NIL_RTSEMEVENTMULTI;
152	}
153	if (pMachineConfigFile)
154	{
155	delete pMachineConfigFile;
156	pMachineConfigFile = NULL;
157	}
158	}
159
160	/////////////////////////////////////////////////////////////////////////////
161	// Machine::HWData structure
162	/////////////////////////////////////////////////////////////////////////////
163
164	Machine::HWData::HWData()
165	{
166	/* default values for a newly created machine */
167	mHWVersion.printf("%d", SchemaDefs::DefaultHardwareVersion);
168	mMemorySize = 128;
169	mCPUCount = 1;
170	mCPUHotPlugEnabled = false;
171	mMemoryBalloonSize = 0;
172	mPageFusionEnabled = false;
173	mHWVirtExEnabled = true;
174	mHWVirtExNestedPagingEnabled = true;
175	#if HC_ARCH_BITS == 64 && !defined(RT_OS_LINUX)
176	mHWVirtExLargePagesEnabled = true;
177	#else
178	/* Not supported on 32 bits hosts. */
179	mHWVirtExLargePagesEnabled = false;
180	#endif
181	mHWVirtExVPIDEnabled = true;
182	mHWVirtExUXEnabled = true;
183	mHWVirtExForceEnabled = false;
184	mHWVirtExUseNativeApi = false;
185	mHWVirtExVirtVmsaveVmload = true;
186	#if HC_ARCH_BITS == 64 \|\| defined(RT_OS_WINDOWS) \|\| defined(RT_OS_DARWIN)
187	mPAEEnabled = true;
188	#else
189	mPAEEnabled = false;
190	#endif
191	mLongMode = HC_ARCH_BITS == 64 ? settings::Hardware::LongMode_Enabled : settings::Hardware::LongMode_Disabled;
192	mTripleFaultReset = false;
193	mAPIC = true;
194	mX2APIC = false;
195	mIBPBOnVMExit = false;
196	mIBPBOnVMEntry = false;
197	mSpecCtrl = false;
198	mSpecCtrlByHost = false;
199	mL1DFlushOnSched = true;
200	mL1DFlushOnVMEntry = false;
201	mMDSClearOnSched = true;
202	mMDSClearOnVMEntry = false;
203	mNestedHWVirt = false;
204	mHPETEnabled = false;
205	mCpuExecutionCap = 100; /* Maximum CPU execution cap by default. */
206	mCpuIdPortabilityLevel = 0;
207	mCpuProfile = "host";
208
209	/* default boot order: floppy - DVD - HDD */
210	mBootOrder[0] = DeviceType_Floppy;
211	mBootOrder[1] = DeviceType_DVD;
212	mBootOrder[2] = DeviceType_HardDisk;
213	for (size_t i = 3; i < RT_ELEMENTS(mBootOrder); ++i)
214	mBootOrder[i] = DeviceType_Null;
215
216	mClipboardMode = ClipboardMode_Disabled;
217	mClipboardFileTransfersEnabled = FALSE;
218
219	mDnDMode = DnDMode_Disabled;
220
221	mFirmwareType = FirmwareType_BIOS;
222	mKeyboardHIDType = KeyboardHIDType_PS2Keyboard;
223	mPointingHIDType = PointingHIDType_PS2Mouse;
224	mChipsetType = ChipsetType_PIIX3;
225	mParavirtProvider = ParavirtProvider_Default;
226	mEmulatedUSBCardReaderEnabled = FALSE;
227
228	for (size_t i = 0; i < RT_ELEMENTS(mCPUAttached); ++i)
229	mCPUAttached[i] = false;
230
231	mIOCacheEnabled = true;
232	mIOCacheSize = 5; /* 5MB */
233	}
234
235	Machine::HWData::~HWData()
236	{
237	}
238
239	/////////////////////////////////////////////////////////////////////////////
240	// Machine class
241	/////////////////////////////////////////////////////////////////////////////
242
243	// constructor / destructor
244	/////////////////////////////////////////////////////////////////////////////
245
246	Machine::Machine() :
247	#ifdef VBOX_WITH_RESOURCE_USAGE_API
248	mCollectorGuest(NULL),
249	#endif
250	mPeer(NULL),
251	mParent(NULL),
252	mSerialPorts(),
253	mParallelPorts(),
254	uRegistryNeedsSaving(0)
255	{}
256
257	Machine::~Machine()
258	{}
259
260	HRESULT Machine::FinalConstruct()
261	{
262	LogFlowThisFunc(("\n"));
263	return BaseFinalConstruct();
264	}
265
266	void Machine::FinalRelease()
267	{
268	LogFlowThisFunc(("\n"));
269	uninit();
270	BaseFinalRelease();
271	}
272
273	/**
274	* Initializes a new machine instance; this init() variant creates a new, empty machine.
275	* This gets called from VirtualBox::CreateMachine().
276	*
277	* @param aParent Associated parent object
278	* @param strConfigFile Local file system path to the VM settings file (can
279	* be relative to the VirtualBox config directory).
280	* @param strName name for the machine
281	* @param llGroups list of groups for the machine
282	* @param strOsType OS Type string (stored as is if aOsType is NULL).
283	* @param aOsType OS Type of this machine or NULL.
284	* @param aId UUID for the new machine.
285	* @param fForceOverwrite Whether to overwrite an existing machine settings file.
286	* @param fDirectoryIncludesUUID Whether the use a special VM directory naming
287	* scheme (includes the UUID).
288	*
289	* @return Success indicator. if not S_OK, the machine object is invalid
290	*/
291	HRESULT Machine::init(VirtualBox *aParent,
292	const Utf8Str &strConfigFile,
293	const Utf8Str &strName,
294	const StringsList &llGroups,
295	const Utf8Str &strOsType,
296	GuestOSType *aOsType,
297	const Guid &aId,
298	bool fForceOverwrite,
299	bool fDirectoryIncludesUUID)
300	{
301	LogFlowThisFuncEnter();
302	LogFlowThisFunc(("(Init_New) aConfigFile='%s'\n", strConfigFile.c_str()));
303
304	/* Enclose the state transition NotReady->InInit->Ready */
305	AutoInitSpan autoInitSpan(this);
306	AssertReturn(autoInitSpan.isOk(), E_FAIL);
307
308	HRESULT rc = initImpl(aParent, strConfigFile);
309	if (FAILED(rc)) return rc;
310
311	rc = i_tryCreateMachineConfigFile(fForceOverwrite);
312	if (FAILED(rc)) return rc;
313
314	if (SUCCEEDED(rc))
315	{
316	// create an empty machine config
317	mData->pMachineConfigFile = new settings::MachineConfigFile(NULL);
318
319	rc = initDataAndChildObjects();
320	}
321
322	if (SUCCEEDED(rc))
323	{
324	// set to true now to cause uninit() to call uninitDataAndChildObjects() on failure
325	mData->mAccessible = TRUE;
326
327	unconst(mData->mUuid) = aId;
328
329	mUserData->s.strName = strName;
330
331	if (llGroups.size())
332	mUserData->s.llGroups = llGroups;
333
334	mUserData->s.fDirectoryIncludesUUID = fDirectoryIncludesUUID;
335	// the "name sync" flag determines whether the machine directory gets renamed along
336	// with the machine file; say so if the settings file name is the same as the
337	// settings file parent directory (machine directory)
338	mUserData->s.fNameSync = i_isInOwnDir();
339
340	// initialize the default snapshots folder
341	rc = COMSETTER(SnapshotFolder)(NULL);
342	AssertComRC(rc);
343
344	if (aOsType)
345	{
346	/* Store OS type */
347	mUserData->s.strOsType = aOsType->i_id();
348
349	/* Let the OS type select 64-bit ness. */
350	mHWData->mLongMode = aOsType->i_is64Bit()
351	? settings::Hardware::LongMode_Enabled : settings::Hardware::LongMode_Disabled;
352
353	/* Let the OS type enable the X2APIC */
354	mHWData->mX2APIC = aOsType->i_recommendedX2APIC();
355	}
356	else if (!strOsType.isEmpty())
357	{
358	/* Store OS type */
359	mUserData->s.strOsType = strOsType;
360
361	/* No guest OS type object. Pick some plausible defaults which the
362	* host can handle. There's no way to know or validate anything. */
363	mHWData->mLongMode = HC_ARCH_BITS == 64 ? settings::Hardware::LongMode_Enabled : settings::Hardware::LongMode_Disabled;
364	mHWData->mX2APIC = false;
365	}
366
367	/* Apply BIOS defaults. */
368	mBIOSSettings->i_applyDefaults(aOsType);
369
370	/* Apply record defaults. */
371	mRecordingSettings->i_applyDefaults();
372
373	/* Apply network adapters defaults */
374	for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
375	mNetworkAdapters[slot]->i_applyDefaults(aOsType);
376
377	/* Apply serial port defaults */
378	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
379	mSerialPorts[slot]->i_applyDefaults(aOsType);
380
381	/* Apply parallel port defaults */
382	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
383	mParallelPorts[slot]->i_applyDefaults();
384
385	/* At this point the changing of the current state modification
386	* flag is allowed. */
387	i_allowStateModification();
388
389	/* commit all changes made during the initialization */
390	i_commit();
391	}
392
393	/* Confirm a successful initialization when it's the case */
394	if (SUCCEEDED(rc))
395	{
396	if (mData->mAccessible)
397	autoInitSpan.setSucceeded();
398	else
399	autoInitSpan.setLimited();
400	}
401
402	LogFlowThisFunc(("mName='%s', mRegistered=%RTbool, mAccessible=%RTbool, rc=%08X\n",
403	!!mUserData ? mUserData->s.strName.c_str() : "NULL",
404	mData->mRegistered,
405	mData->mAccessible,
406	rc));
407
408	LogFlowThisFuncLeave();
409
410	return rc;
411	}
412
413	/**
414	* Initializes a new instance with data from machine XML (formerly Init_Registered).
415	* Gets called in two modes:
416	*
417	* -- from VirtualBox::initMachines() during VirtualBox startup; in that case, the
418	* UUID is specified and we mark the machine as "registered";
419	*
420	* -- from the public VirtualBox::OpenMachine() API, in which case the UUID is NULL
421	* and the machine remains unregistered until RegisterMachine() is called.
422	*
423	* @param aParent Associated parent object
424	* @param strConfigFile Local file system path to the VM settings file (can
425	* be relative to the VirtualBox config directory).
426	* @param aId UUID of the machine or NULL (see above).
427	*
428	* @return Success indicator. if not S_OK, the machine object is invalid
429	*/
430	HRESULT Machine::initFromSettings(VirtualBox *aParent,
431	const Utf8Str &strConfigFile,
432	const Guid *aId)
433	{
434	LogFlowThisFuncEnter();
435	LogFlowThisFunc(("(Init_Registered) aConfigFile='%s\n", strConfigFile.c_str()));
436
437	/* Enclose the state transition NotReady->InInit->Ready */
438	AutoInitSpan autoInitSpan(this);
439	AssertReturn(autoInitSpan.isOk(), E_FAIL);
440
441	HRESULT rc = initImpl(aParent, strConfigFile);
442	if (FAILED(rc)) return rc;
443
444	if (aId)
445	{
446	// loading a registered VM:
447	unconst(mData->mUuid) = *aId;
448	mData->mRegistered = TRUE;
449	// now load the settings from XML:
450	rc = i_registeredInit();
451	// this calls initDataAndChildObjects() and loadSettings()
452	}
453	else
454	{
455	// opening an unregistered VM (VirtualBox::OpenMachine()):
456	rc = initDataAndChildObjects();
457
458	if (SUCCEEDED(rc))
459	{
460	// set to true now to cause uninit() to call uninitDataAndChildObjects() on failure
461	mData->mAccessible = TRUE;
462
463	try
464	{
465	// load and parse machine XML; this will throw on XML or logic errors
466	mData->pMachineConfigFile = new settings::MachineConfigFile(&mData->m_strConfigFileFull);
467
468	// reject VM UUID duplicates, they can happen if someone
469	// tries to register an already known VM config again
470	if (aParent->i_findMachine(mData->pMachineConfigFile->uuid,
471	true /* fPermitInaccessible */,
472	false /* aDoSetError */,
473	NULL) != VBOX_E_OBJECT_NOT_FOUND)
474	{
475	throw setError(E_FAIL,
476	tr("Trying to open a VM config '%s' which has the same UUID as an existing virtual machine"),
477	mData->m_strConfigFile.c_str());
478	}
479
480	// use UUID from machine config
481	unconst(mData->mUuid) = mData->pMachineConfigFile->uuid;
482
483	rc = i_loadMachineDataFromSettings(*mData->pMachineConfigFile,
484	NULL /* puuidRegistry */);
485	if (FAILED(rc)) throw rc;
486
487	/* At this point the changing of the current state modification
488	* flag is allowed. */
489	i_allowStateModification();
490
491	i_commit();
492	}
493	catch (HRESULT err)
494	{
495	/* we assume that error info is set by the thrower */
496	rc = err;
497	}
498	catch (...)
499	{
500	rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
501	}
502	}
503	}
504
505	/* Confirm a successful initialization when it's the case */
506	if (SUCCEEDED(rc))
507	{
508	if (mData->mAccessible)
509	autoInitSpan.setSucceeded();
510	else
511	{
512	autoInitSpan.setLimited();
513
514	// uninit media from this machine's media registry, or else
515	// reloading the settings will fail
516	mParent->i_unregisterMachineMedia(i_getId());
517	}
518	}
519
520	LogFlowThisFunc(("mName='%s', mRegistered=%RTbool, mAccessible=%RTbool "
521	"rc=%08X\n",
522	!!mUserData ? mUserData->s.strName.c_str() : "NULL",
523	mData->mRegistered, mData->mAccessible, rc));
524
525	LogFlowThisFuncLeave();
526
527	return rc;
528	}
529
530	/**
531	* Initializes a new instance from a machine config that is already in memory
532	* (import OVF case). Since we are importing, the UUID in the machine
533	* config is ignored and we always generate a fresh one.
534	*
535	* @param aParent Associated parent object.
536	* @param strName Name for the new machine; this overrides what is specified in config.
537	* @param strSettingsFilename File name of .vbox file.
538	* @param config Machine configuration loaded and parsed from XML.
539	*
540	* @return Success indicator. if not S_OK, the machine object is invalid
541	*/
542	HRESULT Machine::init(VirtualBox *aParent,
543	const Utf8Str &strName,
544	const Utf8Str &strSettingsFilename,
545	const settings::MachineConfigFile &config)
546	{
547	LogFlowThisFuncEnter();
548
549	/* Enclose the state transition NotReady->InInit->Ready */
550	AutoInitSpan autoInitSpan(this);
551	AssertReturn(autoInitSpan.isOk(), E_FAIL);
552
553	HRESULT rc = initImpl(aParent, strSettingsFilename);
554	if (FAILED(rc)) return rc;
555
556	rc = i_tryCreateMachineConfigFile(false /* fForceOverwrite */);
557	if (FAILED(rc)) return rc;
558
559	rc = initDataAndChildObjects();
560
561	if (SUCCEEDED(rc))
562	{
563	// set to true now to cause uninit() to call uninitDataAndChildObjects() on failure
564	mData->mAccessible = TRUE;
565
566	// create empty machine config for instance data
567	mData->pMachineConfigFile = new settings::MachineConfigFile(NULL);
568
569	// generate fresh UUID, ignore machine config
570	unconst(mData->mUuid).create();
571
572	rc = i_loadMachineDataFromSettings(config,
573	&mData->mUuid); // puuidRegistry: initialize media with this registry ID
574
575	// override VM name as well, it may be different
576	mUserData->s.strName = strName;
577
578	if (SUCCEEDED(rc))
579	{
580	/* At this point the changing of the current state modification
581	* flag is allowed. */
582	i_allowStateModification();
583
584	/* commit all changes made during the initialization */
585	i_commit();
586	}
587	}
588
589	/* Confirm a successful initialization when it's the case */
590	if (SUCCEEDED(rc))
591	{
592	if (mData->mAccessible)
593	autoInitSpan.setSucceeded();
594	else
595	{
596	/* Ignore all errors from unregistering, they would destroy
597	- * the more interesting error information we already have,
598	- * pinpointing the issue with the VM config. */
599	ErrorInfoKeeper eik;
600
601	autoInitSpan.setLimited();
602
603	// uninit media from this machine's media registry, or else
604	// reloading the settings will fail
605	mParent->i_unregisterMachineMedia(i_getId());
606	}
607	}
608
609	LogFlowThisFunc(("mName='%s', mRegistered=%RTbool, mAccessible=%RTbool "
610	"rc=%08X\n",
611	!!mUserData ? mUserData->s.strName.c_str() : "NULL",
612	mData->mRegistered, mData->mAccessible, rc));
613
614	LogFlowThisFuncLeave();
615
616	return rc;
617	}
618
619	/**
620	* Shared code between the various init() implementations.
621	* @param aParent The VirtualBox object.
622	* @param strConfigFile Settings file.
623	* @return
624	*/
625	HRESULT Machine::initImpl(VirtualBox *aParent,
626	const Utf8Str &strConfigFile)
627	{
628	LogFlowThisFuncEnter();
629
630	AssertReturn(aParent, E_INVALIDARG);
631	AssertReturn(!strConfigFile.isEmpty(), E_INVALIDARG);
632
633	HRESULT rc = S_OK;
634
635	/* share the parent weakly */
636	unconst(mParent) = aParent;
637
638	/* allocate the essential machine data structure (the rest will be
639	* allocated later by initDataAndChildObjects() */
640	mData.allocate();
641
642	/* memorize the config file name (as provided) */
643	mData->m_strConfigFile = strConfigFile;
644
645	/* get the full file name */
646	int vrc1 = mParent->i_calculateFullPath(strConfigFile, mData->m_strConfigFileFull);
647	if (RT_FAILURE(vrc1))
648	return setErrorBoth(VBOX_E_FILE_ERROR, vrc1,
649	tr("Invalid machine settings file name '%s' (%Rrc)"),
650	strConfigFile.c_str(),
651	vrc1);
652
653	LogFlowThisFuncLeave();
654
655	return rc;
656	}
657
658	/**
659	* Tries to create a machine settings file in the path stored in the machine
660	* instance data. Used when a new machine is created to fail gracefully if
661	* the settings file could not be written (e.g. because machine dir is read-only).
662	* @return
663	*/
664	HRESULT Machine::i_tryCreateMachineConfigFile(bool fForceOverwrite)
665	{
666	HRESULT rc = S_OK;
667
668	// when we create a new machine, we must be able to create the settings file
669	RTFILE f = NIL_RTFILE;
670	int vrc = RTFileOpen(&f, mData->m_strConfigFileFull.c_str(), RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE);
671	if ( RT_SUCCESS(vrc)
672	\|\| vrc == VERR_SHARING_VIOLATION
673	)
674	{
675	if (RT_SUCCESS(vrc))
676	RTFileClose(f);
677	if (!fForceOverwrite)
678	rc = setError(VBOX_E_FILE_ERROR,
679	tr("Machine settings file '%s' already exists"),
680	mData->m_strConfigFileFull.c_str());
681	else
682	{
683	/* try to delete the config file, as otherwise the creation
684	* of a new settings file will fail. */
685	int vrc2 = RTFileDelete(mData->m_strConfigFileFull.c_str());
686	if (RT_FAILURE(vrc2))
687	rc = setErrorBoth(VBOX_E_FILE_ERROR, vrc2,
688	tr("Could not delete the existing settings file '%s' (%Rrc)"),
689	mData->m_strConfigFileFull.c_str(), vrc2);
690	}
691	}
692	else if ( vrc != VERR_FILE_NOT_FOUND
693	&& vrc != VERR_PATH_NOT_FOUND
694	)
695	rc = setErrorBoth(VBOX_E_FILE_ERROR, vrc,
696	tr("Invalid machine settings file name '%s' (%Rrc)"),
697	mData->m_strConfigFileFull.c_str(),
698	vrc);
699	return rc;
700	}
701
702	/**
703	* Initializes the registered machine by loading the settings file.
704	* This method is separated from #init() in order to make it possible to
705	* retry the operation after VirtualBox startup instead of refusing to
706	* startup the whole VirtualBox server in case if the settings file of some
707	* registered VM is invalid or inaccessible.
708	*
709	* @note Must be always called from this object's write lock
710	* (unless called from #init() that doesn't need any locking).
711	* @note Locks the mUSBController method for writing.
712	* @note Subclasses must not call this method.
713	*/
714	HRESULT Machine::i_registeredInit()
715	{
716	AssertReturn(!i_isSessionMachine(), E_FAIL);
717	AssertReturn(!i_isSnapshotMachine(), E_FAIL);
718	AssertReturn(mData->mUuid.isValid(), E_FAIL);
719	AssertReturn(!mData->mAccessible, E_FAIL);
720
721	HRESULT rc = initDataAndChildObjects();
722
723	if (SUCCEEDED(rc))
724	{
725	/* Temporarily reset the registered flag in order to let setters
726	* potentially called from loadSettings() succeed (isMutable() used in
727	* all setters will return FALSE for a Machine instance if mRegistered
728	* is TRUE). */
729	mData->mRegistered = FALSE;
730
731	try
732	{
733	// load and parse machine XML; this will throw on XML or logic errors
734	mData->pMachineConfigFile = new settings::MachineConfigFile(&mData->m_strConfigFileFull);
735
736	if (mData->mUuid != mData->pMachineConfigFile->uuid)
737	throw setError(E_FAIL,
738	tr("Machine UUID {%RTuuid} in '%s' doesn't match its UUID {%s} in the registry file '%s'"),
739	mData->pMachineConfigFile->uuid.raw(),
740	mData->m_strConfigFileFull.c_str(),
741	mData->mUuid.toString().c_str(),
742	mParent->i_settingsFilePath().c_str());
743
744	rc = i_loadMachineDataFromSettings(*mData->pMachineConfigFile,
745	NULL /* const Guid puuidRegistry /);
746	if (FAILED(rc)) throw rc;
747	}
748	catch (HRESULT err)
749	{
750	/* we assume that error info is set by the thrower */
751	rc = err;
752	}
753	catch (...)
754	{
755	rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
756	}
757
758	/* Restore the registered flag (even on failure) */
759	mData->mRegistered = TRUE;
760	}
761
762	if (SUCCEEDED(rc))
763	{
764	/* Set mAccessible to TRUE only if we successfully locked and loaded
765	* the settings file */
766	mData->mAccessible = TRUE;
767
768	/* commit all changes made during loading the settings file */
769	i_commit(); /// @todo r=dj why do we need a commit during init?!? this is very expensive
770	/// @todo r=klaus for some reason the settings loading logic backs up
771	// the settings, and therefore a commit is needed. Should probably be changed.
772	}
773	else
774	{
775	/* If the machine is registered, then, instead of returning a
776	* failure, we mark it as inaccessible and set the result to
777	* success to give it a try later */
778
779	/* fetch the current error info */
780	mData->mAccessError = com::ErrorInfo();
781	Log1Warning(("Machine {%RTuuid} is inaccessible! [%ls]\n", mData->mUuid.raw(), mData->mAccessError.getText().raw()));
782
783	/* rollback all changes */
784	i_rollback(false /* aNotify */);
785
786	// uninit media from this machine's media registry, or else
787	// reloading the settings will fail
788	mParent->i_unregisterMachineMedia(i_getId());
789
790	/* uninitialize the common part to make sure all data is reset to
791	* default (null) values */
792	uninitDataAndChildObjects();
793
794	rc = S_OK;
795	}
796
797	return rc;
798	}
799
800	/**
801	* Uninitializes the instance.
802	* Called either from FinalRelease() or by the parent when it gets destroyed.
803	*
804	* @note The caller of this method must make sure that this object
805	* a) doesn't have active callers on the current thread and b) is not locked
806	* by the current thread; otherwise uninit() will hang either a) due to
807	* AutoUninitSpan waiting for a number of calls to drop to zero or b) due to
808	* a dead-lock caused by this thread waiting for all callers on the other
809	* threads are done but preventing them from doing so by holding a lock.
810	*/
811	void Machine::uninit()
812	{
813	LogFlowThisFuncEnter();
814
815	Assert(!isWriteLockOnCurrentThread());
816
817	Assert(!uRegistryNeedsSaving);
818	if (uRegistryNeedsSaving)
819	{
820	AutoCaller autoCaller(this);
821	if (SUCCEEDED(autoCaller.rc()))
822	{
823	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
824	i_saveSettings(NULL, Machine::SaveS_Force);
825	}
826	}
827
828	/* Enclose the state transition Ready->InUninit->NotReady */
829	AutoUninitSpan autoUninitSpan(this);
830	if (autoUninitSpan.uninitDone())
831	return;
832
833	Assert(!i_isSnapshotMachine());
834	Assert(!i_isSessionMachine());
835	Assert(!!mData);
836
837	LogFlowThisFunc(("initFailed()=%d\n", autoUninitSpan.initFailed()));
838	LogFlowThisFunc(("mRegistered=%d\n", mData->mRegistered));
839
840	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
841
842	if (!mData->mSession.mMachine.isNull())
843	{
844	/* Theoretically, this can only happen if the VirtualBox server has been
845	* terminated while there were clients running that owned open direct
846	* sessions. Since in this case we are definitely called by
847	* VirtualBox::uninit(), we may be sure that SessionMachine::uninit()
848	* won't happen on the client watcher thread (because it has a
849	* VirtualBox caller for the duration of the
850	* SessionMachine::i_checkForDeath() call, so that VirtualBox::uninit()
851	* cannot happen until the VirtualBox caller is released). This is
852	* important, because SessionMachine::uninit() cannot correctly operate
853	* after we return from this method (it expects the Machine instance is
854	* still valid). We'll call it ourselves below.
855	*/
856	Log1WarningThisFunc(("Session machine is not NULL (%p), the direct session is still open!\n",
857	(SessionMachine*)mData->mSession.mMachine));
858
859	if (Global::IsOnlineOrTransient(mData->mMachineState))
860	{
861	Log1WarningThisFunc(("Setting state to Aborted!\n"));
862	/* set machine state using SessionMachine reimplementation */
863	static_cast<Machine*>(mData->mSession.mMachine)->i_setMachineState(MachineState_Aborted);
864	}
865
866	/*
867	* Uninitialize SessionMachine using public uninit() to indicate
868	* an unexpected uninitialization.
869	*/
870	mData->mSession.mMachine->uninit();
871	/* SessionMachine::uninit() must set mSession.mMachine to null */
872	Assert(mData->mSession.mMachine.isNull());
873	}
874
875	// uninit media from this machine's media registry, if they're still there
876	Guid uuidMachine(i_getId());
877
878	/* the lock is no more necessary (SessionMachine is uninitialized) */
879	alock.release();
880
881	/* XXX This will fail with
882	* "cannot be closed because it is still attached to 1 virtual machines"
883	* because at this point we did not call uninitDataAndChildObjects() yet
884	* and therefore also removeBackReference() for all these mediums was not called! */
885
886	if (uuidMachine.isValid() && !uuidMachine.isZero()) // can be empty if we're called from a failure of Machine::init
887	mParent->i_unregisterMachineMedia(uuidMachine);
888
889	// has machine been modified?
890	if (mData->flModifications)
891	{
892	Log1WarningThisFunc(("Discarding unsaved settings changes!\n"));
893	i_rollback(false /* aNotify */);
894	}
895
896	if (mData->mAccessible)
897	uninitDataAndChildObjects();
898
899	/* free the essential data structure last */
900	mData.free();
901
902	LogFlowThisFuncLeave();
903	}
904
905	// Wrapped IMachine properties
906	/////////////////////////////////////////////////////////////////////////////
907	HRESULT Machine::getParent(ComPtr<IVirtualBox> &aParent)
908	{
909	/* mParent is constant during life time, no need to lock */
910	ComObjPtr<VirtualBox> pVirtualBox(mParent);
911	aParent = pVirtualBox;
912
913	return S_OK;
914	}
915
916
917	HRESULT Machine::getAccessible(BOOL *aAccessible)
918	{
919	/* In some cases (medium registry related), it is necessary to be able to
920	* go through the list of all machines. Happens when an inaccessible VM
921	* has a sensible medium registry. */
922	AutoReadLock mllock(mParent->i_getMachinesListLockHandle() COMMA_LOCKVAL_SRC_POS);
923	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
924
925	HRESULT rc = S_OK;
926
927	if (!mData->mAccessible)
928	{
929	/* try to initialize the VM once more if not accessible */
930
931	AutoReinitSpan autoReinitSpan(this);
932	AssertReturn(autoReinitSpan.isOk(), E_FAIL);
933
934	#ifdef DEBUG
935	LogFlowThisFunc(("Dumping media backreferences\n"));
936	mParent->i_dumpAllBackRefs();
937	#endif
938
939	if (mData->pMachineConfigFile)
940	{
941	// reset the XML file to force loadSettings() (called from i_registeredInit())
942	// to parse it again; the file might have changed
943	delete mData->pMachineConfigFile;
944	mData->pMachineConfigFile = NULL;
945	}
946
947	rc = i_registeredInit();
948
949	if (SUCCEEDED(rc) && mData->mAccessible)
950	{
951	autoReinitSpan.setSucceeded();
952
953	/* make sure interesting parties will notice the accessibility
954	* state change */
955	mParent->i_onMachineStateChanged(mData->mUuid, mData->mMachineState);
956	mParent->i_onMachineDataChanged(mData->mUuid);
957	}
958	}
959
960	if (SUCCEEDED(rc))
961	*aAccessible = mData->mAccessible;
962
963	LogFlowThisFuncLeave();
964
965	return rc;
966	}
967
968	HRESULT Machine::getAccessError(ComPtr<IVirtualBoxErrorInfo> &aAccessError)
969	{
970	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
971
972	if (mData->mAccessible \|\| !mData->mAccessError.isBasicAvailable())
973	{
974	/* return shortly */
975	aAccessError = NULL;
976	return S_OK;
977	}
978
979	HRESULT rc = S_OK;
980
981	ComObjPtr<VirtualBoxErrorInfo> errorInfo;
982	rc = errorInfo.createObject();
983	if (SUCCEEDED(rc))
984	{
985	errorInfo->init(mData->mAccessError.getResultCode(),
986	mData->mAccessError.getInterfaceID().ref(),
987	Utf8Str(mData->mAccessError.getComponent()).c_str(),
988	Utf8Str(mData->mAccessError.getText()));
989	aAccessError = errorInfo;
990	}
991
992	return rc;
993	}
994
995	HRESULT Machine::getName(com::Utf8Str &aName)
996	{
997	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
998
999	aName = mUserData->s.strName;
1000
1001	return S_OK;
1002	}
1003
1004	HRESULT Machine::setName(const com::Utf8Str &aName)
1005	{
1006	// prohibit setting a UUID only as the machine name, or else it can
1007	// never be found by findMachine()
1008	Guid test(aName);
1009
1010	if (test.isValid())
1011	return setError(E_INVALIDARG, tr("A machine cannot have a UUID as its name"));
1012
1013	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1014
1015	HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
1016	if (FAILED(rc)) return rc;
1017
1018	i_setModified(IsModified_MachineData);
1019	mUserData.backup();
1020	mUserData->s.strName = aName;
1021
1022	return S_OK;
1023	}
1024
1025	HRESULT Machine::getDescription(com::Utf8Str &aDescription)
1026	{
1027	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1028
1029	aDescription = mUserData->s.strDescription;
1030
1031	return S_OK;
1032	}
1033
1034	HRESULT Machine::setDescription(const com::Utf8Str &aDescription)
1035	{
1036	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1037
1038	// this can be done in principle in any state as it doesn't affect the VM
1039	// significantly, but play safe by not messing around while complex
1040	// activities are going on
1041	HRESULT rc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
1042	if (FAILED(rc)) return rc;
1043
1044	i_setModified(IsModified_MachineData);
1045	mUserData.backup();
1046	mUserData->s.strDescription = aDescription;
1047
1048	return S_OK;
1049	}
1050
1051	HRESULT Machine::getId(com::Guid &aId)
1052	{
1053	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1054
1055	aId = mData->mUuid;
1056
1057	return S_OK;
1058	}
1059
1060	HRESULT Machine::getGroups(std::vector<com::Utf8Str> &aGroups)
1061	{
1062	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1063	aGroups.resize(mUserData->s.llGroups.size());
1064	size_t i = 0;
1065	for (StringsList::const_iterator
1066	it = mUserData->s.llGroups.begin();
1067	it != mUserData->s.llGroups.end();
1068	++it, ++i)
1069	aGroups[i] = (*it);
1070
1071	return S_OK;
1072	}
1073
1074	HRESULT Machine::setGroups(const std::vector<com::Utf8Str> &aGroups)
1075	{
1076	StringsList llGroups;
1077	HRESULT rc = mParent->i_convertMachineGroups(aGroups, &llGroups);
1078	if (FAILED(rc))
1079	return rc;
1080
1081	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1082
1083	rc = i_checkStateDependency(MutableOrSavedStateDep);
1084	if (FAILED(rc)) return rc;
1085
1086	i_setModified(IsModified_MachineData);
1087	mUserData.backup();
1088	mUserData->s.llGroups = llGroups;
1089
1090	return S_OK;
1091	}
1092
1093	HRESULT Machine::getOSTypeId(com::Utf8Str &aOSTypeId)
1094	{
1095	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1096
1097	aOSTypeId = mUserData->s.strOsType;
1098
1099	return S_OK;
1100	}
1101
1102	HRESULT Machine::setOSTypeId(const com::Utf8Str &aOSTypeId)
1103	{
1104	/* look up the object by Id to check it is valid */
1105	ComObjPtr<GuestOSType> pGuestOSType;
1106	mParent->i_findGuestOSType(aOSTypeId, pGuestOSType);
1107
1108	/* when setting, always use the "etalon" value for consistency -- lookup
1109	* by ID is case-insensitive and the input value may have different case */
1110	Utf8Str osTypeId = !pGuestOSType.isNull() ? pGuestOSType->i_id() : aOSTypeId;
1111
1112	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1113
1114	HRESULT rc = i_checkStateDependency(MutableStateDep);
1115	if (FAILED(rc)) return rc;
1116
1117	i_setModified(IsModified_MachineData);
1118	mUserData.backup();
1119	mUserData->s.strOsType = osTypeId;
1120
1121	return S_OK;
1122	}
1123
1124	HRESULT Machine::getFirmwareType(FirmwareType_T *aFirmwareType)
1125	{
1126	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1127
1128	*aFirmwareType = mHWData->mFirmwareType;
1129
1130	return S_OK;
1131	}
1132
1133	HRESULT Machine::setFirmwareType(FirmwareType_T aFirmwareType)
1134	{
1135	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1136
1137	HRESULT rc = i_checkStateDependency(MutableStateDep);
1138	if (FAILED(rc)) return rc;
1139
1140	i_setModified(IsModified_MachineData);
1141	mHWData.backup();
1142	mHWData->mFirmwareType = aFirmwareType;
1143	Utf8Str strNVRAM = i_getDefaultNVRAMFilename();
1144	alock.release();
1145
1146	mBIOSSettings->i_updateNonVolatileStorageFile(strNVRAM);
1147
1148	return S_OK;
1149	}
1150
1151	HRESULT Machine::getKeyboardHIDType(KeyboardHIDType_T *aKeyboardHIDType)
1152	{
1153	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1154
1155	*aKeyboardHIDType = mHWData->mKeyboardHIDType;
1156
1157	return S_OK;
1158	}
1159
1160	HRESULT Machine::setKeyboardHIDType(KeyboardHIDType_T aKeyboardHIDType)
1161	{
1162	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1163
1164	HRESULT rc = i_checkStateDependency(MutableStateDep);
1165	if (FAILED(rc)) return rc;
1166
1167	i_setModified(IsModified_MachineData);
1168	mHWData.backup();
1169	mHWData->mKeyboardHIDType = aKeyboardHIDType;
1170
1171	return S_OK;
1172	}
1173
1174	HRESULT Machine::getPointingHIDType(PointingHIDType_T *aPointingHIDType)
1175	{
1176	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1177
1178	*aPointingHIDType = mHWData->mPointingHIDType;
1179
1180	return S_OK;
1181	}
1182
1183	HRESULT Machine::setPointingHIDType(PointingHIDType_T aPointingHIDType)
1184	{
1185	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1186
1187	HRESULT rc = i_checkStateDependency(MutableStateDep);
1188	if (FAILED(rc)) return rc;
1189
1190	i_setModified(IsModified_MachineData);
1191	mHWData.backup();
1192	mHWData->mPointingHIDType = aPointingHIDType;
1193
1194	return S_OK;
1195	}
1196
1197	HRESULT Machine::getChipsetType(ChipsetType_T *aChipsetType)
1198	{
1199	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1200
1201	*aChipsetType = mHWData->mChipsetType;
1202
1203	return S_OK;
1204	}
1205
1206	HRESULT Machine::setChipsetType(ChipsetType_T aChipsetType)
1207	{
1208	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1209
1210	HRESULT rc = i_checkStateDependency(MutableStateDep);
1211	if (FAILED(rc)) return rc;
1212
1213	if (aChipsetType != mHWData->mChipsetType)
1214	{
1215	i_setModified(IsModified_MachineData);
1216	mHWData.backup();
1217	mHWData->mChipsetType = aChipsetType;
1218
1219	// Resize network adapter array, to be finalized on commit/rollback.
1220	// We must not throw away entries yet, otherwise settings are lost
1221	// without a way to roll back.
1222	size_t newCount = Global::getMaxNetworkAdapters(aChipsetType);
1223	size_t oldCount = mNetworkAdapters.size();
1224	if (newCount > oldCount)
1225	{
1226	mNetworkAdapters.resize(newCount);
1227	for (size_t slot = oldCount; slot < mNetworkAdapters.size(); slot++)
1228	{
1229	unconst(mNetworkAdapters[slot]).createObject();
1230	mNetworkAdapters[slot]->init(this, (ULONG)slot);
1231	}
1232	}
1233	}
1234
1235	return S_OK;
1236	}
1237
1238	HRESULT Machine::getParavirtDebug(com::Utf8Str &aParavirtDebug)
1239	{
1240	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1241
1242	aParavirtDebug = mHWData->mParavirtDebug;
1243	return S_OK;
1244	}
1245
1246	HRESULT Machine::setParavirtDebug(const com::Utf8Str &aParavirtDebug)
1247	{
1248	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1249
1250	HRESULT rc = i_checkStateDependency(MutableStateDep);
1251	if (FAILED(rc)) return rc;
1252
1253	/** @todo Parse/validate options? */
1254	if (aParavirtDebug != mHWData->mParavirtDebug)
1255	{
1256	i_setModified(IsModified_MachineData);
1257	mHWData.backup();
1258	mHWData->mParavirtDebug = aParavirtDebug;
1259	}
1260
1261	return S_OK;
1262	}
1263
1264	HRESULT Machine::getParavirtProvider(ParavirtProvider_T *aParavirtProvider)
1265	{
1266	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1267
1268	*aParavirtProvider = mHWData->mParavirtProvider;
1269
1270	return S_OK;
1271	}
1272
1273	HRESULT Machine::setParavirtProvider(ParavirtProvider_T aParavirtProvider)
1274	{
1275	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1276
1277	HRESULT rc = i_checkStateDependency(MutableStateDep);
1278	if (FAILED(rc)) return rc;
1279
1280	if (aParavirtProvider != mHWData->mParavirtProvider)
1281	{
1282	i_setModified(IsModified_MachineData);
1283	mHWData.backup();
1284	mHWData->mParavirtProvider = aParavirtProvider;
1285	}
1286
1287	return S_OK;
1288	}
1289
1290	HRESULT Machine::getEffectiveParavirtProvider(ParavirtProvider_T *aParavirtProvider)
1291	{
1292	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1293
1294	*aParavirtProvider = mHWData->mParavirtProvider;
1295	switch (mHWData->mParavirtProvider)
1296	{
1297	case ParavirtProvider_None:
1298	case ParavirtProvider_HyperV:
1299	case ParavirtProvider_KVM:
1300	case ParavirtProvider_Minimal:
1301	break;
1302
1303	/* Resolve dynamic provider types to the effective types. */
1304	default:
1305	{
1306	ComObjPtr<GuestOSType> pGuestOSType;
1307	HRESULT hrc2 = mParent->i_findGuestOSType(mUserData->s.strOsType,
1308	pGuestOSType);
1309	if (FAILED(hrc2) \|\| pGuestOSType.isNull())
1310	{
1311	*aParavirtProvider = ParavirtProvider_None;
1312	break;
1313	}
1314
1315	Utf8Str guestTypeFamilyId = pGuestOSType->i_familyId();
1316	bool fOsXGuest = guestTypeFamilyId == "MacOS";
1317
1318	switch (mHWData->mParavirtProvider)
1319	{
1320	case ParavirtProvider_Legacy:
1321	{
1322	if (fOsXGuest)
1323	*aParavirtProvider = ParavirtProvider_Minimal;
1324	else
1325	*aParavirtProvider = ParavirtProvider_None;
1326	break;
1327	}
1328
1329	case ParavirtProvider_Default:
1330	{
1331	if (fOsXGuest)
1332	*aParavirtProvider = ParavirtProvider_Minimal;
1333	else if ( mUserData->s.strOsType == "Windows10"
1334	\|\| mUserData->s.strOsType == "Windows10_64"
1335	\|\| mUserData->s.strOsType == "Windows81"
1336	\|\| mUserData->s.strOsType == "Windows81_64"
1337	\|\| mUserData->s.strOsType == "Windows8"
1338	\|\| mUserData->s.strOsType == "Windows8_64"
1339	\|\| mUserData->s.strOsType == "Windows7"
1340	\|\| mUserData->s.strOsType == "Windows7_64"
1341	\|\| mUserData->s.strOsType == "WindowsVista"
1342	\|\| mUserData->s.strOsType == "WindowsVista_64"
1343	\|\| mUserData->s.strOsType == "Windows2012"
1344	\|\| mUserData->s.strOsType == "Windows2012_64"
1345	\|\| mUserData->s.strOsType == "Windows2008"
1346	\|\| mUserData->s.strOsType == "Windows2008_64")
1347	{
1348	*aParavirtProvider = ParavirtProvider_HyperV;
1349	}
1350	else if ( mUserData->s.strOsType == "Linux26" // Linux22 and Linux24 omitted as they're too old
1351	\|\| mUserData->s.strOsType == "Linux26_64" // for having any KVM paravirtualization support.
1352	\|\| mUserData->s.strOsType == "Linux"
1353	\|\| mUserData->s.strOsType == "Linux_64"
1354	\|\| mUserData->s.strOsType == "ArchLinux"
1355	\|\| mUserData->s.strOsType == "ArchLinux_64"
1356	\|\| mUserData->s.strOsType == "Debian"
1357	\|\| mUserData->s.strOsType == "Debian_64"
1358	\|\| mUserData->s.strOsType == "Fedora"
1359	\|\| mUserData->s.strOsType == "Fedora_64"
1360	\|\| mUserData->s.strOsType == "Gentoo"
1361	\|\| mUserData->s.strOsType == "Gentoo_64"
1362	\|\| mUserData->s.strOsType == "Mandriva"
1363	\|\| mUserData->s.strOsType == "Mandriva_64"
1364	\|\| mUserData->s.strOsType == "OpenSUSE"
1365	\|\| mUserData->s.strOsType == "OpenSUSE_64"
1366	\|\| mUserData->s.strOsType == "Oracle"
1367	\|\| mUserData->s.strOsType == "Oracle_64"
1368	\|\| mUserData->s.strOsType == "RedHat"
1369	\|\| mUserData->s.strOsType == "RedHat_64"
1370	\|\| mUserData->s.strOsType == "Turbolinux"
1371	\|\| mUserData->s.strOsType == "Turbolinux_64"
1372	\|\| mUserData->s.strOsType == "Ubuntu"
1373	\|\| mUserData->s.strOsType == "Ubuntu_64"
1374	\|\| mUserData->s.strOsType == "Xandros"
1375	\|\| mUserData->s.strOsType == "Xandros_64")
1376	{
1377	*aParavirtProvider = ParavirtProvider_KVM;
1378	}
1379	else
1380	*aParavirtProvider = ParavirtProvider_None;
1381	break;
1382	}
1383
1384	default: AssertFailedBreak(); /* Shut up MSC. */
1385	}
1386	break;
1387	}
1388	}
1389
1390	Assert( *aParavirtProvider == ParavirtProvider_None
1391	\|\| *aParavirtProvider == ParavirtProvider_Minimal
1392	\|\| *aParavirtProvider == ParavirtProvider_HyperV
1393	\|\| *aParavirtProvider == ParavirtProvider_KVM);
1394	return S_OK;
1395	}
1396
1397	HRESULT Machine::getHardwareVersion(com::Utf8Str &aHardwareVersion)
1398	{
1399	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1400
1401	aHardwareVersion = mHWData->mHWVersion;
1402
1403	return S_OK;
1404	}
1405
1406	HRESULT Machine::setHardwareVersion(const com::Utf8Str &aHardwareVersion)
1407	{
1408	/* check known version */
1409	Utf8Str hwVersion = aHardwareVersion;
1410	if ( hwVersion.compare("1") != 0
1411	&& hwVersion.compare("2") != 0) // VBox 2.1.x and later (VMMDev heap)
1412	return setError(E_INVALIDARG,
1413	tr("Invalid hardware version: %s\n"), aHardwareVersion.c_str());
1414
1415	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1416
1417	HRESULT rc = i_checkStateDependency(MutableStateDep);
1418	if (FAILED(rc)) return rc;
1419
1420	i_setModified(IsModified_MachineData);
1421	mHWData.backup();
1422	mHWData->mHWVersion = aHardwareVersion;
1423
1424	return S_OK;
1425	}
1426
1427	HRESULT Machine::getHardwareUUID(com::Guid &aHardwareUUID)
1428	{
1429	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1430
1431	if (!mHWData->mHardwareUUID.isZero())
1432	aHardwareUUID = mHWData->mHardwareUUID;
1433	else
1434	aHardwareUUID = mData->mUuid;
1435
1436	return S_OK;
1437	}
1438
1439	HRESULT Machine::setHardwareUUID(const com::Guid &aHardwareUUID)
1440	{
1441	if (!aHardwareUUID.isValid())
1442	return E_INVALIDARG;
1443
1444	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1445
1446	HRESULT rc = i_checkStateDependency(MutableStateDep);
1447	if (FAILED(rc)) return rc;
1448
1449	i_setModified(IsModified_MachineData);
1450	mHWData.backup();
1451	if (aHardwareUUID == mData->mUuid)
1452	mHWData->mHardwareUUID.clear();
1453	else
1454	mHWData->mHardwareUUID = aHardwareUUID;
1455
1456	return S_OK;
1457	}
1458
1459	HRESULT Machine::getMemorySize(ULONG *aMemorySize)
1460	{
1461	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1462
1463	*aMemorySize = mHWData->mMemorySize;
1464
1465	return S_OK;
1466	}
1467
1468	HRESULT Machine::setMemorySize(ULONG aMemorySize)
1469	{
1470	/* check RAM limits */
1471	if ( aMemorySize < MM_RAM_MIN_IN_MB
1472	\|\| aMemorySize > MM_RAM_MAX_IN_MB
1473	)
1474	return setError(E_INVALIDARG,
1475	tr("Invalid RAM size: %lu MB (must be in range [%lu, %lu] MB)"),
1476	aMemorySize, MM_RAM_MIN_IN_MB, MM_RAM_MAX_IN_MB);
1477
1478	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1479
1480	HRESULT rc = i_checkStateDependency(MutableStateDep);
1481	if (FAILED(rc)) return rc;
1482
1483	i_setModified(IsModified_MachineData);
1484	mHWData.backup();
1485	mHWData->mMemorySize = aMemorySize;
1486
1487	return S_OK;
1488	}
1489
1490	HRESULT Machine::getCPUCount(ULONG *aCPUCount)
1491	{
1492	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1493
1494	*aCPUCount = mHWData->mCPUCount;
1495
1496	return S_OK;
1497	}
1498
1499	HRESULT Machine::setCPUCount(ULONG aCPUCount)
1500	{
1501	/* check CPU limits */
1502	if ( aCPUCount < SchemaDefs::MinCPUCount
1503	\|\| aCPUCount > SchemaDefs::MaxCPUCount
1504	)
1505	return setError(E_INVALIDARG,
1506	tr("Invalid virtual CPU count: %lu (must be in range [%lu, %lu])"),
1507	aCPUCount, SchemaDefs::MinCPUCount, SchemaDefs::MaxCPUCount);
1508
1509	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1510
1511	/* We cant go below the current number of CPUs attached if hotplug is enabled*/
1512	if (mHWData->mCPUHotPlugEnabled)
1513	{
1514	for (unsigned idx = aCPUCount; idx < SchemaDefs::MaxCPUCount; idx++)
1515	{
1516	if (mHWData->mCPUAttached[idx])
1517	return setError(E_INVALIDARG,
1518	tr("There is still a CPU attached to socket %lu."
1519	"Detach the CPU before removing the socket"),
1520	aCPUCount, idx+1);
1521	}
1522	}
1523
1524	HRESULT rc = i_checkStateDependency(MutableStateDep);
1525	if (FAILED(rc)) return rc;
1526
1527	i_setModified(IsModified_MachineData);
1528	mHWData.backup();
1529	mHWData->mCPUCount = aCPUCount;
1530
1531	return S_OK;
1532	}
1533
1534	HRESULT Machine::getCPUExecutionCap(ULONG *aCPUExecutionCap)
1535	{
1536	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1537
1538	*aCPUExecutionCap = mHWData->mCpuExecutionCap;
1539
1540	return S_OK;
1541	}
1542
1543	HRESULT Machine::setCPUExecutionCap(ULONG aCPUExecutionCap)
1544	{
1545	HRESULT rc = S_OK;
1546
1547	/* check throttle limits */
1548	if ( aCPUExecutionCap < 1
1549	\|\| aCPUExecutionCap > 100
1550	)
1551	return setError(E_INVALIDARG,
1552	tr("Invalid CPU execution cap value: %lu (must be in range [%lu, %lu])"),
1553	aCPUExecutionCap, 1, 100);
1554
1555	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1556
1557	alock.release();
1558	rc = i_onCPUExecutionCapChange(aCPUExecutionCap);
1559	alock.acquire();
1560	if (FAILED(rc)) return rc;
1561
1562	i_setModified(IsModified_MachineData);
1563	mHWData.backup();
1564	mHWData->mCpuExecutionCap = aCPUExecutionCap;
1565
1566	/** Save settings if online - @todo why is this required? -- @bugref{6818} */
1567	if (Global::IsOnline(mData->mMachineState))
1568	i_saveSettings(NULL);
1569
1570	return S_OK;
1571	}
1572
1573	HRESULT Machine::getCPUHotPlugEnabled(BOOL *aCPUHotPlugEnabled)
1574	{
1575	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1576
1577	*aCPUHotPlugEnabled = mHWData->mCPUHotPlugEnabled;
1578
1579	return S_OK;
1580	}
1581
1582	HRESULT Machine::setCPUHotPlugEnabled(BOOL aCPUHotPlugEnabled)
1583	{
1584	HRESULT rc = S_OK;
1585
1586	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1587
1588	rc = i_checkStateDependency(MutableStateDep);
1589	if (FAILED(rc)) return rc;
1590
1591	if (mHWData->mCPUHotPlugEnabled != aCPUHotPlugEnabled)
1592	{
1593	if (aCPUHotPlugEnabled)
1594	{
1595	i_setModified(IsModified_MachineData);
1596	mHWData.backup();
1597
1598	/* Add the amount of CPUs currently attached */
1599	for (unsigned i = 0; i < mHWData->mCPUCount; ++i)
1600	mHWData->mCPUAttached[i] = true;
1601	}
1602	else
1603	{
1604	/*
1605	* We can disable hotplug only if the amount of maximum CPUs is equal
1606	* to the amount of attached CPUs
1607	*/
1608	unsigned cCpusAttached = 0;
1609	unsigned iHighestId = 0;
1610
1611	for (unsigned i = 0; i < SchemaDefs::MaxCPUCount; ++i)
1612	{
1613	if (mHWData->mCPUAttached[i])
1614	{
1615	cCpusAttached++;
1616	iHighestId = i;
1617	}
1618	}
1619
1620	if ( (cCpusAttached != mHWData->mCPUCount)
1621	\|\| (iHighestId >= mHWData->mCPUCount))
1622	return setError(E_INVALIDARG,
1623	tr("CPU hotplugging can't be disabled because the maximum number of CPUs is not equal to the amount of CPUs attached"));
1624
1625	i_setModified(IsModified_MachineData);
1626	mHWData.backup();
1627	}
1628	}
1629
1630	mHWData->mCPUHotPlugEnabled = aCPUHotPlugEnabled;
1631
1632	return rc;
1633	}
1634
1635	HRESULT Machine::getCPUIDPortabilityLevel(ULONG *aCPUIDPortabilityLevel)
1636	{
1637	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1638
1639	*aCPUIDPortabilityLevel = mHWData->mCpuIdPortabilityLevel;
1640
1641	return S_OK;
1642	}
1643
1644	HRESULT Machine::setCPUIDPortabilityLevel(ULONG aCPUIDPortabilityLevel)
1645	{
1646	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1647
1648	HRESULT hrc = i_checkStateDependency(MutableStateDep);
1649	if (SUCCEEDED(hrc))
1650	{
1651	i_setModified(IsModified_MachineData);
1652	mHWData.backup();
1653	mHWData->mCpuIdPortabilityLevel = aCPUIDPortabilityLevel;
1654	}
1655	return hrc;
1656	}
1657
1658	HRESULT Machine::getCPUProfile(com::Utf8Str &aCPUProfile)
1659	{
1660	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1661	aCPUProfile = mHWData->mCpuProfile;
1662	return S_OK;
1663	}
1664
1665	HRESULT Machine::setCPUProfile(const com::Utf8Str &aCPUProfile)
1666	{
1667	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1668	HRESULT hrc = i_checkStateDependency(MutableStateDep);
1669	if (SUCCEEDED(hrc))
1670	{
1671	i_setModified(IsModified_MachineData);
1672	mHWData.backup();
1673	/* Empty equals 'host'. */
1674	if (aCPUProfile.isNotEmpty())
1675	mHWData->mCpuProfile = aCPUProfile;
1676	else
1677	mHWData->mCpuProfile = "host";
1678	}
1679	return hrc;
1680	}
1681
1682	HRESULT Machine::getEmulatedUSBCardReaderEnabled(BOOL *aEmulatedUSBCardReaderEnabled)
1683	{
1684	#ifdef VBOX_WITH_USB_CARDREADER
1685	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1686
1687	*aEmulatedUSBCardReaderEnabled = mHWData->mEmulatedUSBCardReaderEnabled;
1688
1689	return S_OK;
1690	#else
1691	NOREF(aEmulatedUSBCardReaderEnabled);
1692	return E_NOTIMPL;
1693	#endif
1694	}
1695
1696	HRESULT Machine::setEmulatedUSBCardReaderEnabled(BOOL aEmulatedUSBCardReaderEnabled)
1697	{
1698	#ifdef VBOX_WITH_USB_CARDREADER
1699	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1700
1701	HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
1702	if (FAILED(rc)) return rc;
1703
1704	i_setModified(IsModified_MachineData);
1705	mHWData.backup();
1706	mHWData->mEmulatedUSBCardReaderEnabled = aEmulatedUSBCardReaderEnabled;
1707
1708	return S_OK;
1709	#else
1710	NOREF(aEmulatedUSBCardReaderEnabled);
1711	return E_NOTIMPL;
1712	#endif
1713	}
1714
1715	HRESULT Machine::getHPETEnabled(BOOL *aHPETEnabled)
1716	{
1717	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1718
1719	*aHPETEnabled = mHWData->mHPETEnabled;
1720
1721	return S_OK;
1722	}
1723
1724	HRESULT Machine::setHPETEnabled(BOOL aHPETEnabled)
1725	{
1726	HRESULT rc = S_OK;
1727
1728	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1729
1730	rc = i_checkStateDependency(MutableStateDep);
1731	if (FAILED(rc)) return rc;
1732
1733	i_setModified(IsModified_MachineData);
1734	mHWData.backup();
1735
1736	mHWData->mHPETEnabled = aHPETEnabled;
1737
1738	return rc;
1739	}
1740
1741	/** @todo this method should not be public */
1742	HRESULT Machine::getMemoryBalloonSize(ULONG *aMemoryBalloonSize)
1743	{
1744	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1745
1746	*aMemoryBalloonSize = mHWData->mMemoryBalloonSize;
1747
1748	return S_OK;
1749	}
1750
1751	/**
1752	* Set the memory balloon size.
1753	*
1754	* This method is also called from IGuest::COMSETTER(MemoryBalloonSize) so
1755	* we have to make sure that we never call IGuest from here.
1756	*/
1757	HRESULT Machine::setMemoryBalloonSize(ULONG aMemoryBalloonSize)
1758	{
1759	/* This must match GMMR0Init; currently we only support memory ballooning on all 64-bit hosts except Mac OS X */
1760	#if HC_ARCH_BITS == 64 && (defined(RT_OS_WINDOWS) \|\| defined(RT_OS_SOLARIS) \|\| defined(RT_OS_LINUX) \|\| defined(RT_OS_FREEBSD))
1761	/* check limits */
1762	if (aMemoryBalloonSize >= VMMDEV_MAX_MEMORY_BALLOON(mHWData->mMemorySize))
1763	return setError(E_INVALIDARG,
1764	tr("Invalid memory balloon size: %lu MB (must be in range [%lu, %lu] MB)"),
1765	aMemoryBalloonSize, 0, VMMDEV_MAX_MEMORY_BALLOON(mHWData->mMemorySize));
1766
1767	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1768
1769	i_setModified(IsModified_MachineData);
1770	mHWData.backup();
1771	mHWData->mMemoryBalloonSize = aMemoryBalloonSize;
1772
1773	return S_OK;
1774	#else
1775	NOREF(aMemoryBalloonSize);
1776	return setError(E_NOTIMPL, tr("Memory ballooning is only supported on 64-bit hosts"));
1777	#endif
1778	}
1779
1780	HRESULT Machine::getPageFusionEnabled(BOOL *aPageFusionEnabled)
1781	{
1782	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1783
1784	*aPageFusionEnabled = mHWData->mPageFusionEnabled;
1785	return S_OK;
1786	}
1787
1788	HRESULT Machine::setPageFusionEnabled(BOOL aPageFusionEnabled)
1789	{
1790	#ifdef VBOX_WITH_PAGE_SHARING
1791	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1792
1793	/** @todo must support changes for running vms and keep this in sync with IGuest. */
1794	i_setModified(IsModified_MachineData);
1795	mHWData.backup();
1796	mHWData->mPageFusionEnabled = aPageFusionEnabled;
1797	return S_OK;
1798	#else
1799	NOREF(aPageFusionEnabled);
1800	return setError(E_NOTIMPL, tr("Page fusion is only supported on 64-bit hosts"));
1801	#endif
1802	}
1803
1804	HRESULT Machine::getBIOSSettings(ComPtr<IBIOSSettings> &aBIOSSettings)
1805	{
1806	/* mBIOSSettings is constant during life time, no need to lock */
1807	aBIOSSettings = mBIOSSettings;
1808
1809	return S_OK;
1810	}
1811
1812	HRESULT Machine::getRecordingSettings(ComPtr<IRecordingSettings> &aRecordingSettings)
1813	{
1814	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1815
1816	aRecordingSettings = mRecordingSettings;
1817
1818	return S_OK;
1819	}
1820
1821	HRESULT Machine::getGraphicsAdapter(ComPtr<IGraphicsAdapter> &aGraphicsAdapter)
1822	{
1823	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1824
1825	aGraphicsAdapter = mGraphicsAdapter;
1826
1827	return S_OK;
1828	}
1829
1830	HRESULT Machine::getCPUProperty(CPUPropertyType_T aProperty, BOOL *aValue)
1831	{
1832	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1833
1834	switch (aProperty)
1835	{
1836	case CPUPropertyType_PAE:
1837	*aValue = mHWData->mPAEEnabled;
1838	break;
1839
1840	case CPUPropertyType_LongMode:
1841	if (mHWData->mLongMode == settings::Hardware::LongMode_Enabled)
1842	*aValue = TRUE;
1843	else if (mHWData->mLongMode == settings::Hardware::LongMode_Disabled)
1844	*aValue = FALSE;
1845	#if HC_ARCH_BITS == 64
1846	else
1847	*aValue = TRUE;
1848	#else
1849	else
1850	{
1851	*aValue = FALSE;
1852
1853	ComObjPtr<GuestOSType> pGuestOSType;
1854	HRESULT hrc2 = mParent->i_findGuestOSType(mUserData->s.strOsType,
1855	pGuestOSType);
1856	if (SUCCEEDED(hrc2) && !pGuestOSType.isNull())
1857	{
1858	if (pGuestOSType->i_is64Bit())
1859	{
1860	ComObjPtr<Host> pHost = mParent->i_host();
1861	alock.release();
1862
1863	hrc2 = pHost->GetProcessorFeature(ProcessorFeature_LongMode, aValue); AssertComRC(hrc2);
1864	if (FAILED(hrc2))
1865	*aValue = FALSE;
1866	}
1867	}
1868	}
1869	#endif
1870	break;
1871
1872	case CPUPropertyType_TripleFaultReset:
1873	*aValue = mHWData->mTripleFaultReset;
1874	break;
1875
1876	case CPUPropertyType_APIC:
1877	*aValue = mHWData->mAPIC;
1878	break;
1879
1880	case CPUPropertyType_X2APIC:
1881	*aValue = mHWData->mX2APIC;
1882	break;
1883
1884	case CPUPropertyType_IBPBOnVMExit:
1885	*aValue = mHWData->mIBPBOnVMExit;
1886	break;
1887
1888	case CPUPropertyType_IBPBOnVMEntry:
1889	*aValue = mHWData->mIBPBOnVMEntry;
1890	break;
1891
1892	case CPUPropertyType_SpecCtrl:
1893	*aValue = mHWData->mSpecCtrl;
1894	break;
1895
1896	case CPUPropertyType_SpecCtrlByHost:
1897	*aValue = mHWData->mSpecCtrlByHost;
1898	break;
1899
1900	case CPUPropertyType_HWVirt:
1901	*aValue = mHWData->mNestedHWVirt;
1902	break;
1903
1904	case CPUPropertyType_L1DFlushOnEMTScheduling:
1905	*aValue = mHWData->mL1DFlushOnSched;
1906	break;
1907
1908	case CPUPropertyType_L1DFlushOnVMEntry:
1909	*aValue = mHWData->mL1DFlushOnVMEntry;
1910	break;
1911
1912	case CPUPropertyType_MDSClearOnEMTScheduling:
1913	*aValue = mHWData->mMDSClearOnSched;
1914	break;
1915
1916	case CPUPropertyType_MDSClearOnVMEntry:
1917	*aValue = mHWData->mMDSClearOnVMEntry;
1918	break;
1919
1920	default:
1921	return E_INVALIDARG;
1922	}
1923	return S_OK;
1924	}
1925
1926	HRESULT Machine::setCPUProperty(CPUPropertyType_T aProperty, BOOL aValue)
1927	{
1928	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1929
1930	HRESULT rc = i_checkStateDependency(MutableStateDep);
1931	if (FAILED(rc)) return rc;
1932
1933	switch (aProperty)
1934	{
1935	case CPUPropertyType_PAE:
1936	i_setModified(IsModified_MachineData);
1937	mHWData.backup();
1938	mHWData->mPAEEnabled = !!aValue;
1939	break;
1940
1941	case CPUPropertyType_LongMode:
1942	i_setModified(IsModified_MachineData);
1943	mHWData.backup();
1944	mHWData->mLongMode = !aValue ? settings::Hardware::LongMode_Disabled : settings::Hardware::LongMode_Enabled;
1945	break;
1946
1947	case CPUPropertyType_TripleFaultReset:
1948	i_setModified(IsModified_MachineData);
1949	mHWData.backup();
1950	mHWData->mTripleFaultReset = !!aValue;
1951	break;
1952
1953	case CPUPropertyType_APIC:
1954	if (mHWData->mX2APIC)
1955	aValue = TRUE;
1956	i_setModified(IsModified_MachineData);
1957	mHWData.backup();
1958	mHWData->mAPIC = !!aValue;
1959	break;
1960
1961	case CPUPropertyType_X2APIC:
1962	i_setModified(IsModified_MachineData);
1963	mHWData.backup();
1964	mHWData->mX2APIC = !!aValue;
1965	if (aValue)
1966	mHWData->mAPIC = !!aValue;
1967	break;
1968
1969	case CPUPropertyType_IBPBOnVMExit:
1970	i_setModified(IsModified_MachineData);
1971	mHWData.backup();
1972	mHWData->mIBPBOnVMExit = !!aValue;
1973	break;
1974
1975	case CPUPropertyType_IBPBOnVMEntry:
1976	i_setModified(IsModified_MachineData);
1977	mHWData.backup();
1978	mHWData->mIBPBOnVMEntry = !!aValue;
1979	break;
1980
1981	case CPUPropertyType_SpecCtrl:
1982	i_setModified(IsModified_MachineData);
1983	mHWData.backup();
1984	mHWData->mSpecCtrl = !!aValue;
1985	break;
1986
1987	case CPUPropertyType_SpecCtrlByHost:
1988	i_setModified(IsModified_MachineData);
1989	mHWData.backup();
1990	mHWData->mSpecCtrlByHost = !!aValue;
1991	break;
1992
1993	case CPUPropertyType_HWVirt:
1994	i_setModified(IsModified_MachineData);
1995	mHWData.backup();
1996	mHWData->mNestedHWVirt = !!aValue;
1997	break;
1998
1999	case CPUPropertyType_L1DFlushOnEMTScheduling:
2000	i_setModified(IsModified_MachineData);
2001	mHWData.backup();
2002	mHWData->mL1DFlushOnSched = !!aValue;
2003	break;
2004
2005	case CPUPropertyType_L1DFlushOnVMEntry:
2006	i_setModified(IsModified_MachineData);
2007	mHWData.backup();
2008	mHWData->mL1DFlushOnVMEntry = !!aValue;
2009	break;
2010
2011	case CPUPropertyType_MDSClearOnEMTScheduling:
2012	i_setModified(IsModified_MachineData);
2013	mHWData.backup();
2014	mHWData->mMDSClearOnSched = !!aValue;
2015	break;
2016
2017	case CPUPropertyType_MDSClearOnVMEntry:
2018	i_setModified(IsModified_MachineData);
2019	mHWData.backup();
2020	mHWData->mMDSClearOnVMEntry = !!aValue;
2021	break;
2022
2023	default:
2024	return E_INVALIDARG;
2025	}
2026	return S_OK;
2027	}
2028
2029	HRESULT Machine::getCPUIDLeafByOrdinal(ULONG aOrdinal, ULONG aIdx, ULONG aSubIdx, ULONG aValEax, ULONG aValEbx,
2030	ULONG aValEcx, ULONG aValEdx)
2031	{
2032	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2033	if (aOrdinal < mHWData->mCpuIdLeafList.size())
2034	{
2035	for (settings::CpuIdLeafsList::const_iterator it = mHWData->mCpuIdLeafList.begin();
2036	it != mHWData->mCpuIdLeafList.end();
2037	++it)
2038	{
2039	if (aOrdinal == 0)
2040	{
2041	const settings::CpuIdLeaf &rLeaf= *it;
2042	*aIdx = rLeaf.idx;
2043	*aSubIdx = rLeaf.idxSub;
2044	*aValEax = rLeaf.uEax;
2045	*aValEbx = rLeaf.uEbx;
2046	*aValEcx = rLeaf.uEcx;
2047	*aValEdx = rLeaf.uEdx;
2048	return S_OK;
2049	}
2050	aOrdinal--;
2051	}
2052	}
2053	return E_INVALIDARG;
2054	}
2055
2056	HRESULT Machine::getCPUIDLeaf(ULONG aIdx, ULONG aSubIdx, ULONG aValEax, ULONG aValEbx, ULONG aValEcx, ULONG aValEdx)
2057	{
2058	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2059
2060	/*
2061	* Search the list.
2062	*/
2063	for (settings::CpuIdLeafsList::const_iterator it = mHWData->mCpuIdLeafList.begin(); it != mHWData->mCpuIdLeafList.end(); ++it)
2064	{
2065	const settings::CpuIdLeaf &rLeaf= *it;
2066	if ( rLeaf.idx == aIdx
2067	&& ( aSubIdx == UINT32_MAX
2068	\|\| rLeaf.idxSub == aSubIdx) )
2069	{
2070	*aValEax = rLeaf.uEax;
2071	*aValEbx = rLeaf.uEbx;
2072	*aValEcx = rLeaf.uEcx;
2073	*aValEdx = rLeaf.uEdx;
2074	return S_OK;
2075	}
2076	}
2077
2078	return E_INVALIDARG;
2079	}
2080
2081
2082	HRESULT Machine::setCPUIDLeaf(ULONG aIdx, ULONG aSubIdx, ULONG aValEax, ULONG aValEbx, ULONG aValEcx, ULONG aValEdx)
2083	{
2084	/*
2085	* Validate input before taking locks and checking state.
2086	*/
2087	if (aSubIdx != 0 && aSubIdx != UINT32_MAX)
2088	return setError(E_INVALIDARG, tr("Currently only aSubIdx values 0 and 0xffffffff are supported: %#x"), aSubIdx);
2089	if ( aIdx >= UINT32_C(0x20)
2090	&& aIdx - UINT32_C(0x80000000) >= UINT32_C(0x20)
2091	&& aIdx - UINT32_C(0xc0000000) >= UINT32_C(0x10) )
2092	return setError(E_INVALIDARG, tr("CpuId override leaf %#x is out of range"), aIdx);
2093
2094	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2095	HRESULT rc = i_checkStateDependency(MutableStateDep);
2096	if (FAILED(rc)) return rc;
2097
2098	/*
2099	* Impose a maximum number of leaves.
2100	*/
2101	if (mHWData->mCpuIdLeafList.size() > 256)
2102	return setError(E_FAIL, tr("Max of 256 CPUID override leaves reached"));
2103
2104	/*
2105	* Updating the list is a bit more complicated. So, let's do a remove first followed by an insert.
2106	*/
2107	i_setModified(IsModified_MachineData);
2108	mHWData.backup();
2109
2110	for (settings::CpuIdLeafsList::iterator it = mHWData->mCpuIdLeafList.begin(); it != mHWData->mCpuIdLeafList.end(); )
2111	{
2112	settings::CpuIdLeaf &rLeaf= *it;
2113	if ( rLeaf.idx == aIdx
2114	&& ( aSubIdx == UINT32_MAX
2115	\|\| rLeaf.idxSub == aSubIdx) )
2116	it = mHWData->mCpuIdLeafList.erase(it);
2117	else
2118	++it;
2119	}
2120
2121	settings::CpuIdLeaf NewLeaf;
2122	NewLeaf.idx = aIdx;
2123	NewLeaf.idxSub = aSubIdx == UINT32_MAX ? 0 : aSubIdx;
2124	NewLeaf.uEax = aValEax;
2125	NewLeaf.uEbx = aValEbx;
2126	NewLeaf.uEcx = aValEcx;
2127	NewLeaf.uEdx = aValEdx;
2128	mHWData->mCpuIdLeafList.push_back(NewLeaf);
2129	return S_OK;
2130	}
2131
2132	HRESULT Machine::removeCPUIDLeaf(ULONG aIdx, ULONG aSubIdx)
2133	{
2134	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2135
2136	HRESULT rc = i_checkStateDependency(MutableStateDep);
2137	if (FAILED(rc)) return rc;
2138
2139	/*
2140	* Do the removal.
2141	*/
2142	bool fModified = mHWData.isBackedUp();
2143	for (settings::CpuIdLeafsList::iterator it = mHWData->mCpuIdLeafList.begin(); it != mHWData->mCpuIdLeafList.end(); )
2144	{
2145	settings::CpuIdLeaf &rLeaf= *it;
2146	if ( rLeaf.idx == aIdx
2147	&& ( aSubIdx == UINT32_MAX
2148	\|\| rLeaf.idxSub == aSubIdx) )
2149	{
2150	if (!fModified)
2151	{
2152	fModified = true;
2153	i_setModified(IsModified_MachineData);
2154	mHWData.backup();
2155	// Start from the beginning, since mHWData.backup() creates
2156	// a new list, causing iterator mixup. This makes sure that
2157	// the settings are not unnecessarily marked as modified,
2158	// at the price of extra list walking.
2159	it = mHWData->mCpuIdLeafList.begin();
2160	}
2161	else
2162	it = mHWData->mCpuIdLeafList.erase(it);
2163	}
2164	else
2165	++it;
2166	}
2167
2168	return S_OK;
2169	}
2170
2171	HRESULT Machine::removeAllCPUIDLeaves()
2172	{
2173	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2174
2175	HRESULT rc = i_checkStateDependency(MutableStateDep);
2176	if (FAILED(rc)) return rc;
2177
2178	if (mHWData->mCpuIdLeafList.size() > 0)
2179	{
2180	i_setModified(IsModified_MachineData);
2181	mHWData.backup();
2182
2183	mHWData->mCpuIdLeafList.clear();
2184	}
2185
2186	return S_OK;
2187	}
2188	HRESULT Machine::getHWVirtExProperty(HWVirtExPropertyType_T aProperty, BOOL *aValue)
2189	{
2190	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2191
2192	switch(aProperty)
2193	{
2194	case HWVirtExPropertyType_Enabled:
2195	*aValue = mHWData->mHWVirtExEnabled;
2196	break;
2197
2198	case HWVirtExPropertyType_VPID:
2199	*aValue = mHWData->mHWVirtExVPIDEnabled;
2200	break;
2201
2202	case HWVirtExPropertyType_NestedPaging:
2203	*aValue = mHWData->mHWVirtExNestedPagingEnabled;
2204	break;
2205
2206	case HWVirtExPropertyType_UnrestrictedExecution:
2207	*aValue = mHWData->mHWVirtExUXEnabled;
2208	break;
2209
2210	case HWVirtExPropertyType_LargePages:
2211	*aValue = mHWData->mHWVirtExLargePagesEnabled;
2212	#if defined(DEBUG_bird) && defined(RT_OS_LINUX) /* This feature is deadly here */
2213	*aValue = FALSE;
2214	#endif
2215	break;
2216
2217	case HWVirtExPropertyType_Force:
2218	*aValue = mHWData->mHWVirtExForceEnabled;
2219	break;
2220
2221	case HWVirtExPropertyType_UseNativeApi:
2222	*aValue = mHWData->mHWVirtExUseNativeApi;
2223	break;
2224
2225	case HWVirtExPropertyType_VirtVmsaveVmload:
2226	*aValue = mHWData->mHWVirtExVirtVmsaveVmload;
2227	break;
2228
2229	default:
2230	return E_INVALIDARG;
2231	}
2232	return S_OK;
2233	}
2234
2235	HRESULT Machine::setHWVirtExProperty(HWVirtExPropertyType_T aProperty, BOOL aValue)
2236	{
2237	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2238
2239	HRESULT rc = i_checkStateDependency(MutableStateDep);
2240	if (FAILED(rc)) return rc;
2241
2242	switch (aProperty)
2243	{
2244	case HWVirtExPropertyType_Enabled:
2245	i_setModified(IsModified_MachineData);
2246	mHWData.backup();
2247	mHWData->mHWVirtExEnabled = !!aValue;
2248	break;
2249
2250	case HWVirtExPropertyType_VPID:
2251	i_setModified(IsModified_MachineData);
2252	mHWData.backup();
2253	mHWData->mHWVirtExVPIDEnabled = !!aValue;
2254	break;
2255
2256	case HWVirtExPropertyType_NestedPaging:
2257	i_setModified(IsModified_MachineData);
2258	mHWData.backup();
2259	mHWData->mHWVirtExNestedPagingEnabled = !!aValue;
2260	break;
2261
2262	case HWVirtExPropertyType_UnrestrictedExecution:
2263	i_setModified(IsModified_MachineData);
2264	mHWData.backup();
2265	mHWData->mHWVirtExUXEnabled = !!aValue;
2266	break;
2267
2268	case HWVirtExPropertyType_LargePages:
2269	i_setModified(IsModified_MachineData);
2270	mHWData.backup();
2271	mHWData->mHWVirtExLargePagesEnabled = !!aValue;
2272	break;
2273
2274	case HWVirtExPropertyType_Force:
2275	i_setModified(IsModified_MachineData);
2276	mHWData.backup();
2277	mHWData->mHWVirtExForceEnabled = !!aValue;
2278	break;
2279
2280	case HWVirtExPropertyType_UseNativeApi:
2281	i_setModified(IsModified_MachineData);
2282	mHWData.backup();
2283	mHWData->mHWVirtExUseNativeApi = !!aValue;
2284	break;
2285
2286	case HWVirtExPropertyType_VirtVmsaveVmload:
2287	i_setModified(IsModified_MachineData);
2288	mHWData.backup();
2289	mHWData->mHWVirtExVirtVmsaveVmload = !!aValue;
2290	break;
2291
2292	default:
2293	return E_INVALIDARG;
2294	}
2295
2296	return S_OK;
2297	}
2298
2299	HRESULT Machine::getSnapshotFolder(com::Utf8Str &aSnapshotFolder)
2300	{
2301	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2302
2303	i_calculateFullPath(mUserData->s.strSnapshotFolder, aSnapshotFolder);
2304
2305	return S_OK;
2306	}
2307
2308	HRESULT Machine::setSnapshotFolder(const com::Utf8Str &aSnapshotFolder)
2309	{
2310	/** @todo (r=dmik):
2311	* 1. Allow to change the name of the snapshot folder containing snapshots
2312	* 2. Rename the folder on disk instead of just changing the property
2313	* value (to be smart and not to leave garbage). Note that it cannot be
2314	* done here because the change may be rolled back. Thus, the right
2315	* place is #saveSettings().
2316	*/
2317
2318	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2319
2320	HRESULT rc = i_checkStateDependency(MutableStateDep);
2321	if (FAILED(rc)) return rc;
2322
2323	if (!mData->mCurrentSnapshot.isNull())
2324	return setError(E_FAIL,
2325	tr("The snapshot folder of a machine with snapshots cannot be changed (please delete all snapshots first)"));
2326
2327	Utf8Str strSnapshotFolder(aSnapshotFolder); // keep original
2328
2329	if (strSnapshotFolder.isEmpty())
2330	strSnapshotFolder = "Snapshots";
2331	int vrc = i_calculateFullPath(strSnapshotFolder, strSnapshotFolder);
2332	if (RT_FAILURE(vrc))
2333	return setErrorBoth(E_FAIL, vrc,
2334	tr("Invalid snapshot folder '%s' (%Rrc)"),
2335	strSnapshotFolder.c_str(), vrc);
2336
2337	i_setModified(IsModified_MachineData);
2338	mUserData.backup();
2339
2340	i_copyPathRelativeToMachine(strSnapshotFolder, mUserData->s.strSnapshotFolder);
2341
2342	return S_OK;
2343	}
2344
2345	HRESULT Machine::getMediumAttachments(std::vector<ComPtr<IMediumAttachment> > &aMediumAttachments)
2346	{
2347	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2348
2349	aMediumAttachments.resize(mMediumAttachments->size());
2350	size_t i = 0;
2351	for (MediumAttachmentList::const_iterator
2352	it = mMediumAttachments->begin();
2353	it != mMediumAttachments->end();
2354	++it, ++i)
2355	aMediumAttachments[i] = *it;
2356
2357	return S_OK;
2358	}
2359
2360	HRESULT Machine::getVRDEServer(ComPtr<IVRDEServer> &aVRDEServer)
2361	{
2362	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2363
2364	Assert(!!mVRDEServer);
2365
2366	aVRDEServer = mVRDEServer;
2367
2368	return S_OK;
2369	}
2370
2371	HRESULT Machine::getAudioAdapter(ComPtr<IAudioAdapter> &aAudioAdapter)
2372	{
2373	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2374
2375	aAudioAdapter = mAudioAdapter;
2376
2377	return S_OK;
2378	}
2379
2380	HRESULT Machine::getUSBControllers(std::vector<ComPtr<IUSBController> > &aUSBControllers)
2381	{
2382	#ifdef VBOX_WITH_VUSB
2383	clearError();
2384	MultiResult rc(S_OK);
2385
2386	# ifdef VBOX_WITH_USB
2387	rc = mParent->i_host()->i_checkUSBProxyService();
2388	if (FAILED(rc)) return rc;
2389	# endif
2390
2391	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2392
2393	aUSBControllers.resize(mUSBControllers->size());
2394	size_t i = 0;
2395	for (USBControllerList::const_iterator
2396	it = mUSBControllers->begin();
2397	it != mUSBControllers->end();
2398	++it, ++i)
2399	aUSBControllers[i] = *it;
2400
2401	return S_OK;
2402	#else
2403	/* Note: The GUI depends on this method returning E_NOTIMPL with no
2404	* extended error info to indicate that USB is simply not available
2405	* (w/o treating it as a failure), for example, as in OSE */
2406	NOREF(aUSBControllers);
2407	ReturnComNotImplemented();
2408	#endif /* VBOX_WITH_VUSB */
2409	}
2410
2411	HRESULT Machine::getUSBDeviceFilters(ComPtr<IUSBDeviceFilters> &aUSBDeviceFilters)
2412	{
2413	#ifdef VBOX_WITH_VUSB
2414	clearError();
2415	MultiResult rc(S_OK);
2416
2417	# ifdef VBOX_WITH_USB
2418	rc = mParent->i_host()->i_checkUSBProxyService();
2419	if (FAILED(rc)) return rc;
2420	# endif
2421
2422	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2423
2424	aUSBDeviceFilters = mUSBDeviceFilters;
2425	return rc;
2426	#else
2427	/* Note: The GUI depends on this method returning E_NOTIMPL with no
2428	* extended error info to indicate that USB is simply not available
2429	* (w/o treating it as a failure), for example, as in OSE */
2430	NOREF(aUSBDeviceFilters);
2431	ReturnComNotImplemented();
2432	#endif /* VBOX_WITH_VUSB */
2433	}
2434
2435	HRESULT Machine::getSettingsFilePath(com::Utf8Str &aSettingsFilePath)
2436	{
2437	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2438
2439	aSettingsFilePath = mData->m_strConfigFileFull;
2440
2441	return S_OK;
2442	}
2443
2444	HRESULT Machine::getSettingsAuxFilePath(com::Utf8Str &aSettingsFilePath)
2445	{
2446	RT_NOREF(aSettingsFilePath);
2447	ReturnComNotImplemented();
2448	}
2449
2450	HRESULT Machine::getSettingsModified(BOOL *aSettingsModified)
2451	{
2452	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2453
2454	HRESULT rc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
2455	if (FAILED(rc)) return rc;
2456
2457	if (!mData->pMachineConfigFile->fileExists())
2458	// this is a new machine, and no config file exists yet:
2459	*aSettingsModified = TRUE;
2460	else
2461	*aSettingsModified = (mData->flModifications != 0);
2462
2463	return S_OK;
2464	}
2465
2466	HRESULT Machine::getSessionState(SessionState_T *aSessionState)
2467	{
2468	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2469
2470	*aSessionState = mData->mSession.mState;
2471
2472	return S_OK;
2473	}
2474
2475	HRESULT Machine::getSessionName(com::Utf8Str &aSessionName)
2476	{
2477	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2478
2479	aSessionName = mData->mSession.mName;
2480
2481	return S_OK;
2482	}
2483
2484	HRESULT Machine::getSessionPID(ULONG *aSessionPID)
2485	{
2486	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2487
2488	*aSessionPID = mData->mSession.mPID;
2489
2490	return S_OK;
2491	}
2492
2493	HRESULT Machine::getState(MachineState_T *aState)
2494	{
2495	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2496
2497	*aState = mData->mMachineState;
2498	Assert(mData->mMachineState != MachineState_Null);
2499
2500	return S_OK;
2501	}
2502
2503	HRESULT Machine::getLastStateChange(LONG64 *aLastStateChange)
2504	{
2505	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2506
2507	*aLastStateChange = RTTimeSpecGetMilli(&mData->mLastStateChange);
2508
2509	return S_OK;
2510	}
2511
2512	HRESULT Machine::getStateFilePath(com::Utf8Str &aStateFilePath)
2513	{
2514	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2515
2516	aStateFilePath = mSSData->strStateFilePath;
2517
2518	return S_OK;
2519	}
2520
2521	HRESULT Machine::getLogFolder(com::Utf8Str &aLogFolder)
2522	{
2523	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2524
2525	i_getLogFolder(aLogFolder);
2526
2527	return S_OK;
2528	}
2529
2530	HRESULT Machine::getCurrentSnapshot(ComPtr<ISnapshot> &aCurrentSnapshot)
2531	{
2532	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2533
2534	aCurrentSnapshot = mData->mCurrentSnapshot;
2535
2536	return S_OK;
2537	}
2538
2539	HRESULT Machine::getSnapshotCount(ULONG *aSnapshotCount)
2540	{
2541	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2542
2543	*aSnapshotCount = mData->mFirstSnapshot.isNull()
2544	? 0
2545	: mData->mFirstSnapshot->i_getAllChildrenCount() + 1;
2546
2547	return S_OK;
2548	}
2549
2550	HRESULT Machine::getCurrentStateModified(BOOL *aCurrentStateModified)
2551	{
2552	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2553
2554	/* Note: for machines with no snapshots, we always return FALSE
2555	* (mData->mCurrentStateModified will be TRUE in this case, for historical
2556	* reasons :) */
2557
2558	*aCurrentStateModified = mData->mFirstSnapshot.isNull()
2559	? FALSE
2560	: mData->mCurrentStateModified;
2561
2562	return S_OK;
2563	}
2564
2565	HRESULT Machine::getSharedFolders(std::vector<ComPtr<ISharedFolder> > &aSharedFolders)
2566	{
2567	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2568
2569	aSharedFolders.resize(mHWData->mSharedFolders.size());
2570	size_t i = 0;
2571	for (std::list<ComObjPtr<SharedFolder> >::const_iterator
2572	it = mHWData->mSharedFolders.begin();
2573	it != mHWData->mSharedFolders.end();
2574	++it, ++i)
2575	aSharedFolders[i] = *it;
2576
2577	return S_OK;
2578	}
2579
2580	HRESULT Machine::getClipboardMode(ClipboardMode_T *aClipboardMode)
2581	{
2582	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2583
2584	*aClipboardMode = mHWData->mClipboardMode;
2585
2586	return S_OK;
2587	}
2588
2589	HRESULT Machine::setClipboardMode(ClipboardMode_T aClipboardMode)
2590	{
2591	HRESULT rc = S_OK;
2592
2593	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2594
2595	alock.release();
2596	rc = i_onClipboardModeChange(aClipboardMode);
2597	alock.acquire();
2598	if (FAILED(rc)) return rc;
2599
2600	i_setModified(IsModified_MachineData);
2601	mHWData.backup();
2602	mHWData->mClipboardMode = aClipboardMode;
2603
2604	/** Save settings if online - @todo why is this required? -- @bugref{6818} */
2605	if (Global::IsOnline(mData->mMachineState))
2606	i_saveSettings(NULL);
2607
2608	return S_OK;
2609	}
2610
2611	HRESULT Machine::getClipboardFileTransfersEnabled(BOOL *aEnabled)
2612	{
2613	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2614
2615	*aEnabled = mHWData->mClipboardFileTransfersEnabled;
2616
2617	return S_OK;
2618	}
2619
2620	HRESULT Machine::setClipboardFileTransfersEnabled(BOOL aEnabled)
2621	{
2622	HRESULT rc = S_OK;
2623
2624	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2625
2626	alock.release();
2627	rc = i_onClipboardFileTransferModeChange(aEnabled);
2628	alock.acquire();
2629	if (FAILED(rc)) return rc;
2630
2631	i_setModified(IsModified_MachineData);
2632	mHWData.backup();
2633	mHWData->mClipboardFileTransfersEnabled = aEnabled;
2634
2635	/** Save settings if online - @todo why is this required? -- @bugref{6818} */
2636	if (Global::IsOnline(mData->mMachineState))
2637	i_saveSettings(NULL);
2638
2639	return S_OK;
2640	}
2641
2642	HRESULT Machine::getDnDMode(DnDMode_T *aDnDMode)
2643	{
2644	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2645
2646	*aDnDMode = mHWData->mDnDMode;
2647
2648	return S_OK;
2649	}
2650
2651	HRESULT Machine::setDnDMode(DnDMode_T aDnDMode)
2652	{
2653	HRESULT rc = S_OK;
2654
2655	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2656
2657	alock.release();
2658	rc = i_onDnDModeChange(aDnDMode);
2659
2660	alock.acquire();
2661	if (FAILED(rc)) return rc;
2662
2663	i_setModified(IsModified_MachineData);
2664	mHWData.backup();
2665	mHWData->mDnDMode = aDnDMode;
2666
2667	/** Save settings if online - @todo why is this required? -- @bugref{6818} */
2668	if (Global::IsOnline(mData->mMachineState))
2669	i_saveSettings(NULL);
2670
2671	return S_OK;
2672	}
2673
2674	HRESULT Machine::getStorageControllers(std::vector<ComPtr<IStorageController> > &aStorageControllers)
2675	{
2676	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2677
2678	aStorageControllers.resize(mStorageControllers->size());
2679	size_t i = 0;
2680	for (StorageControllerList::const_iterator
2681	it = mStorageControllers->begin();
2682	it != mStorageControllers->end();
2683	++it, ++i)
2684	aStorageControllers[i] = *it;
2685
2686	return S_OK;
2687	}
2688
2689	HRESULT Machine::getTeleporterEnabled(BOOL *aEnabled)
2690	{
2691	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2692
2693	*aEnabled = mUserData->s.fTeleporterEnabled;
2694
2695	return S_OK;
2696	}
2697
2698	HRESULT Machine::setTeleporterEnabled(BOOL aTeleporterEnabled)
2699	{
2700	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2701
2702	/* Only allow it to be set to true when PoweredOff or Aborted.
2703	(Clearing it is always permitted.) */
2704	if ( aTeleporterEnabled
2705	&& mData->mRegistered
2706	&& ( !i_isSessionMachine()
2707	\|\| ( mData->mMachineState != MachineState_PoweredOff
2708	&& mData->mMachineState != MachineState_Teleported
2709	&& mData->mMachineState != MachineState_Aborted
2710	)
2711	)
2712	)
2713	return setError(VBOX_E_INVALID_VM_STATE,
2714	tr("The machine is not powered off (state is %s)"),
2715	Global::stringifyMachineState(mData->mMachineState));
2716
2717	i_setModified(IsModified_MachineData);
2718	mUserData.backup();
2719	mUserData->s.fTeleporterEnabled = !! aTeleporterEnabled;
2720
2721	return S_OK;
2722	}
2723
2724	HRESULT Machine::getTeleporterPort(ULONG *aTeleporterPort)
2725	{
2726	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2727
2728	*aTeleporterPort = (ULONG)mUserData->s.uTeleporterPort;
2729
2730	return S_OK;
2731	}
2732
2733	HRESULT Machine::setTeleporterPort(ULONG aTeleporterPort)
2734	{
2735	if (aTeleporterPort >= _64K)
2736	return setError(E_INVALIDARG, tr("Invalid port number %d"), aTeleporterPort);
2737
2738	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2739
2740	HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
2741	if (FAILED(rc)) return rc;
2742
2743	i_setModified(IsModified_MachineData);
2744	mUserData.backup();
2745	mUserData->s.uTeleporterPort = (uint32_t)aTeleporterPort;
2746
2747	return S_OK;
2748	}
2749
2750	HRESULT Machine::getTeleporterAddress(com::Utf8Str &aTeleporterAddress)
2751	{
2752	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2753
2754	aTeleporterAddress = mUserData->s.strTeleporterAddress;
2755
2756	return S_OK;
2757	}
2758
2759	HRESULT Machine::setTeleporterAddress(const com::Utf8Str &aTeleporterAddress)
2760	{
2761	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2762
2763	HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
2764	if (FAILED(rc)) return rc;
2765
2766	i_setModified(IsModified_MachineData);
2767	mUserData.backup();
2768	mUserData->s.strTeleporterAddress = aTeleporterAddress;
2769
2770	return S_OK;
2771	}
2772
2773	HRESULT Machine::getTeleporterPassword(com::Utf8Str &aTeleporterPassword)
2774	{
2775	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2776	aTeleporterPassword = mUserData->s.strTeleporterPassword;
2777
2778	return S_OK;
2779	}
2780
2781	HRESULT Machine::setTeleporterPassword(const com::Utf8Str &aTeleporterPassword)
2782	{
2783	/*
2784	* Hash the password first.
2785	*/
2786	com::Utf8Str aT = aTeleporterPassword;
2787
2788	if (!aT.isEmpty())
2789	{
2790	if (VBoxIsPasswordHashed(&aT))
2791	return setError(E_INVALIDARG, tr("Cannot set an already hashed password, only plain text password please"));
2792	VBoxHashPassword(&aT);
2793	}
2794
2795	/*
2796	* Do the update.
2797	*/
2798	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2799	HRESULT hrc = i_checkStateDependency(MutableOrSavedStateDep);
2800	if (SUCCEEDED(hrc))
2801	{
2802	i_setModified(IsModified_MachineData);
2803	mUserData.backup();
2804	mUserData->s.strTeleporterPassword = aT;
2805	}
2806
2807	return hrc;
2808	}
2809
2810	HRESULT Machine::getRTCUseUTC(BOOL *aRTCUseUTC)
2811	{
2812	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2813
2814	*aRTCUseUTC = mUserData->s.fRTCUseUTC;
2815
2816	return S_OK;
2817	}
2818
2819	HRESULT Machine::setRTCUseUTC(BOOL aRTCUseUTC)
2820	{
2821	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2822
2823	/* Only allow it to be set to true when PoweredOff or Aborted.
2824	(Clearing it is always permitted.) */
2825	if ( aRTCUseUTC
2826	&& mData->mRegistered
2827	&& ( !i_isSessionMachine()
2828	\|\| ( mData->mMachineState != MachineState_PoweredOff
2829	&& mData->mMachineState != MachineState_Teleported
2830	&& mData->mMachineState != MachineState_Aborted
2831	)
2832	)
2833	)
2834	return setError(VBOX_E_INVALID_VM_STATE,
2835	tr("The machine is not powered off (state is %s)"),
2836	Global::stringifyMachineState(mData->mMachineState));
2837
2838	i_setModified(IsModified_MachineData);
2839	mUserData.backup();
2840	mUserData->s.fRTCUseUTC = !!aRTCUseUTC;
2841
2842	return S_OK;
2843	}
2844
2845	HRESULT Machine::getIOCacheEnabled(BOOL *aIOCacheEnabled)
2846	{
2847	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2848
2849	*aIOCacheEnabled = mHWData->mIOCacheEnabled;
2850
2851	return S_OK;
2852	}
2853
2854	HRESULT Machine::setIOCacheEnabled(BOOL aIOCacheEnabled)
2855	{
2856	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2857
2858	HRESULT rc = i_checkStateDependency(MutableStateDep);
2859	if (FAILED(rc)) return rc;
2860
2861	i_setModified(IsModified_MachineData);
2862	mHWData.backup();
2863	mHWData->mIOCacheEnabled = aIOCacheEnabled;
2864
2865	return S_OK;
2866	}
2867
2868	HRESULT Machine::getIOCacheSize(ULONG *aIOCacheSize)
2869	{
2870	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2871
2872	*aIOCacheSize = mHWData->mIOCacheSize;
2873
2874	return S_OK;
2875	}
2876
2877	HRESULT Machine::setIOCacheSize(ULONG aIOCacheSize)
2878	{
2879	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2880
2881	HRESULT rc = i_checkStateDependency(MutableStateDep);
2882	if (FAILED(rc)) return rc;
2883
2884	i_setModified(IsModified_MachineData);
2885	mHWData.backup();
2886	mHWData->mIOCacheSize = aIOCacheSize;
2887
2888	return S_OK;
2889	}
2890
2891
2892	/**
2893	* @note Locks objects!
2894	*/
2895	HRESULT Machine::lockMachine(const ComPtr<ISession> &aSession,
2896	LockType_T aLockType)
2897	{
2898	/* check the session state */
2899	SessionState_T state;
2900	HRESULT rc = aSession->COMGETTER(State)(&state);
2901	if (FAILED(rc)) return rc;
2902
2903	if (state != SessionState_Unlocked)
2904	return setError(VBOX_E_INVALID_OBJECT_STATE,
2905	tr("The given session is busy"));
2906
2907	// get the client's IInternalSessionControl interface
2908	ComPtr<IInternalSessionControl> pSessionControl = aSession;
2909	ComAssertMsgRet(!!pSessionControl, ("No IInternalSessionControl interface"),
2910	E_INVALIDARG);
2911
2912	// session name (only used in some code paths)
2913	Utf8Str strSessionName;
2914
2915	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2916
2917	if (!mData->mRegistered)
2918	return setError(E_UNEXPECTED,
2919	tr("The machine '%s' is not registered"),
2920	mUserData->s.strName.c_str());
2921
2922	LogFlowThisFunc(("mSession.mState=%s\n", Global::stringifySessionState(mData->mSession.mState)));
2923
2924	SessionState_T oldState = mData->mSession.mState;
2925	/* Hack: in case the session is closing and there is a progress object
2926	* which allows waiting for the session to be closed, take the opportunity
2927	* and do a limited wait (max. 1 second). This helps a lot when the system
2928	* is busy and thus session closing can take a little while. */
2929	if ( mData->mSession.mState == SessionState_Unlocking
2930	&& mData->mSession.mProgress)
2931	{
2932	alock.release();
2933	mData->mSession.mProgress->WaitForCompletion(1000);
2934	alock.acquire();
2935	LogFlowThisFunc(("after waiting: mSession.mState=%s\n", Global::stringifySessionState(mData->mSession.mState)));
2936	}
2937
2938	// try again now
2939	if ( (mData->mSession.mState == SessionState_Locked) // machine is write-locked already
2940	// (i.e. session machine exists)
2941	&& (aLockType == LockType_Shared) // caller wants a shared link to the
2942	// existing session that holds the write lock:
2943	)
2944	{
2945	// OK, share the session... we are now dealing with three processes:
2946	// 1) VBoxSVC (where this code runs);
2947	// 2) process C: the caller's client process (who wants a shared session);
2948	// 3) process W: the process which already holds the write lock on the machine (write-locking session)
2949
2950	// copy pointers to W (the write-locking session) before leaving lock (these must not be NULL)
2951	ComPtr<IInternalSessionControl> pSessionW = mData->mSession.mDirectControl;
2952	ComAssertRet(!pSessionW.isNull(), E_FAIL);
2953	ComObjPtr<SessionMachine> pSessionMachine = mData->mSession.mMachine;
2954	AssertReturn(!pSessionMachine.isNull(), E_FAIL);
2955
2956	/*
2957	* Release the lock before calling the client process. It's safe here
2958	* since the only thing to do after we get the lock again is to add
2959	* the remote control to the list (which doesn't directly influence
2960	* anything).
2961	*/
2962	alock.release();
2963
2964	// get the console of the session holding the write lock (this is a remote call)
2965	ComPtr<IConsole> pConsoleW;
2966	if (mData->mSession.mLockType == LockType_VM)
2967	{
2968	LogFlowThisFunc(("Calling GetRemoteConsole()...\n"));
2969	rc = pSessionW->COMGETTER(RemoteConsole)(pConsoleW.asOutParam());
2970	LogFlowThisFunc(("GetRemoteConsole() returned %08X\n", rc));
2971	if (FAILED(rc))
2972	// the failure may occur w/o any error info (from RPC), so provide one
2973	return setError(VBOX_E_VM_ERROR,
2974	tr("Failed to get a console object from the direct session (%Rhrc)"), rc);
2975	ComAssertRet(!pConsoleW.isNull(), E_FAIL);
2976	}
2977
2978	// share the session machine and W's console with the caller's session
2979	LogFlowThisFunc(("Calling AssignRemoteMachine()...\n"));
2980	rc = pSessionControl->AssignRemoteMachine(pSessionMachine, pConsoleW);
2981	LogFlowThisFunc(("AssignRemoteMachine() returned %08X\n", rc));
2982
2983	if (FAILED(rc))
2984	// the failure may occur w/o any error info (from RPC), so provide one
2985	return setError(VBOX_E_VM_ERROR,
2986	tr("Failed to assign the machine to the session (%Rhrc)"), rc);
2987	alock.acquire();
2988
2989	// need to revalidate the state after acquiring the lock again
2990	if (mData->mSession.mState != SessionState_Locked)
2991	{
2992	pSessionControl->Uninitialize();
2993	return setError(VBOX_E_INVALID_SESSION_STATE,
2994	tr("The machine '%s' was unlocked unexpectedly while attempting to share its session"),
2995	mUserData->s.strName.c_str());
2996	}
2997
2998	// add the caller's session to the list
2999	mData->mSession.mRemoteControls.push_back(pSessionControl);
3000	}
3001	else if ( mData->mSession.mState == SessionState_Locked
3002	\|\| mData->mSession.mState == SessionState_Unlocking
3003	)
3004	{
3005	// sharing not permitted, or machine still unlocking:
3006	return setError(VBOX_E_INVALID_OBJECT_STATE,
3007	tr("The machine '%s' is already locked for a session (or being unlocked)"),
3008	mUserData->s.strName.c_str());
3009	}
3010	else
3011	{
3012	// machine is not locked: then write-lock the machine (create the session machine)
3013
3014	// must not be busy
3015	AssertReturn(!Global::IsOnlineOrTransient(mData->mMachineState), E_FAIL);
3016
3017	// get the caller's session PID
3018	RTPROCESS pid = NIL_RTPROCESS;
3019	AssertCompile(sizeof(ULONG) == sizeof(RTPROCESS));
3020	pSessionControl->COMGETTER(PID)((ULONG*)&pid);
3021	Assert(pid != NIL_RTPROCESS);
3022
3023	bool fLaunchingVMProcess = (mData->mSession.mState == SessionState_Spawning);
3024
3025	if (fLaunchingVMProcess)
3026	{
3027	if (mData->mSession.mPID == NIL_RTPROCESS)
3028	{
3029	// two or more clients racing for a lock, the one which set the
3030	// session state to Spawning will win, the others will get an
3031	// error as we can't decide here if waiting a little would help
3032	// (only for shared locks this would avoid an error)
3033	return setError(VBOX_E_INVALID_OBJECT_STATE,
3034	tr("The machine '%s' already has a lock request pending"),
3035	mUserData->s.strName.c_str());
3036	}
3037
3038	// this machine is awaiting for a spawning session to be opened:
3039	// then the calling process must be the one that got started by
3040	// LaunchVMProcess()
3041
3042	LogFlowThisFunc(("mSession.mPID=%d(0x%x)\n", mData->mSession.mPID, mData->mSession.mPID));
3043	LogFlowThisFunc(("session.pid=%d(0x%x)\n", pid, pid));
3044
3045	#if defined(VBOX_WITH_HARDENING) && defined(RT_OS_WINDOWS)
3046	/* Hardened windows builds spawns three processes when a VM is
3047	launched, the 3rd one is the one that will end up here. */
3048	RTPROCESS pidParent;
3049	int vrc = RTProcQueryParent(pid, &pidParent);
3050	if (RT_SUCCESS(vrc))
3051	vrc = RTProcQueryParent(pidParent, &pidParent);
3052	if ( (RT_SUCCESS(vrc) && mData->mSession.mPID == pidParent)
3053	\|\| vrc == VERR_ACCESS_DENIED)
3054	{
3055	LogFlowThisFunc(("mSession.mPID => %d(%#x) - windows hardening stub\n", mData->mSession.mPID, pid));
3056	mData->mSession.mPID = pid;
3057	}
3058	#endif
3059
3060	if (mData->mSession.mPID != pid)
3061	return setError(E_ACCESSDENIED,
3062	tr("An unexpected process (PID=0x%08X) has tried to lock the "
3063	"machine '%s', while only the process started by LaunchVMProcess (PID=0x%08X) is allowed"),
3064	pid, mUserData->s.strName.c_str(), mData->mSession.mPID);
3065	}
3066
3067	// create the mutable SessionMachine from the current machine
3068	ComObjPtr<SessionMachine> sessionMachine;
3069	sessionMachine.createObject();
3070	rc = sessionMachine->init(this);
3071	AssertComRC(rc);
3072
3073	/* NOTE: doing return from this function after this point but
3074	* before the end is forbidden since it may call SessionMachine::uninit()
3075	* (through the ComObjPtr's destructor) which requests the VirtualBox write
3076	* lock while still holding the Machine lock in alock so that a deadlock
3077	* is possible due to the wrong lock order. */
3078
3079	if (SUCCEEDED(rc))
3080	{
3081	/*
3082	* Set the session state to Spawning to protect against subsequent
3083	* attempts to open a session and to unregister the machine after
3084	* we release the lock.
3085	*/
3086	SessionState_T origState = mData->mSession.mState;
3087	mData->mSession.mState = SessionState_Spawning;
3088
3089	#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
3090	/* Get the client token ID to be passed to the client process */
3091	Utf8Str strTokenId;
3092	sessionMachine->i_getTokenId(strTokenId);
3093	Assert(!strTokenId.isEmpty());
3094	#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
3095	/* Get the client token to be passed to the client process */
3096	ComPtr<IToken> pToken(sessionMachine->i_getToken());
3097	/* The token is now "owned" by pToken, fix refcount */
3098	if (!pToken.isNull())
3099	pToken->Release();
3100	#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
3101
3102	/*
3103	* Release the lock before calling the client process -- it will call
3104	* Machine/SessionMachine methods. Releasing the lock here is quite safe
3105	* because the state is Spawning, so that LaunchVMProcess() and
3106	* LockMachine() calls will fail. This method, called before we
3107	* acquire the lock again, will fail because of the wrong PID.
3108	*
3109	* Note that mData->mSession.mRemoteControls accessed outside
3110	* the lock may not be modified when state is Spawning, so it's safe.
3111	*/
3112	alock.release();
3113
3114	LogFlowThisFunc(("Calling AssignMachine()...\n"));
3115	#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
3116	rc = pSessionControl->AssignMachine(sessionMachine, aLockType, Bstr(strTokenId).raw());
3117	#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
3118	rc = pSessionControl->AssignMachine(sessionMachine, aLockType, pToken);
3119	/* Now the token is owned by the client process. */
3120	pToken.setNull();
3121	#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
3122	LogFlowThisFunc(("AssignMachine() returned %08X\n", rc));
3123
3124	/* The failure may occur w/o any error info (from RPC), so provide one */
3125	if (FAILED(rc))
3126	setError(VBOX_E_VM_ERROR,
3127	tr("Failed to assign the machine to the session (%Rhrc)"), rc);
3128
3129	// get session name, either to remember or to compare against
3130	// the already known session name.
3131	{
3132	Bstr bstrSessionName;
3133	HRESULT rc2 = aSession->COMGETTER(Name)(bstrSessionName.asOutParam());
3134	if (SUCCEEDED(rc2))
3135	strSessionName = bstrSessionName;
3136	}
3137
3138	if ( SUCCEEDED(rc)
3139	&& fLaunchingVMProcess
3140	)
3141	{
3142	/* complete the remote session initialization */
3143
3144	/* get the console from the direct session */
3145	ComPtr<IConsole> console;
3146	rc = pSessionControl->COMGETTER(RemoteConsole)(console.asOutParam());
3147	ComAssertComRC(rc);
3148
3149	if (SUCCEEDED(rc) && !console)
3150	{
3151	ComAssert(!!console);
3152	rc = E_FAIL;
3153	}
3154
3155	/* assign machine & console to the remote session */
3156	if (SUCCEEDED(rc))
3157	{
3158	/*
3159	* after LaunchVMProcess(), the first and the only
3160	* entry in remoteControls is that remote session
3161	*/
3162	LogFlowThisFunc(("Calling AssignRemoteMachine()...\n"));
3163	rc = mData->mSession.mRemoteControls.front()->AssignRemoteMachine(sessionMachine, console);
3164	LogFlowThisFunc(("AssignRemoteMachine() returned %08X\n", rc));
3165
3166	/* The failure may occur w/o any error info (from RPC), so provide one */
3167	if (FAILED(rc))
3168	setError(VBOX_E_VM_ERROR,
3169	tr("Failed to assign the machine to the remote session (%Rhrc)"), rc);
3170	}
3171
3172	if (FAILED(rc))
3173	pSessionControl->Uninitialize();
3174	}
3175
3176	/* acquire the lock again */
3177	alock.acquire();
3178
3179	/* Restore the session state */
3180	mData->mSession.mState = origState;
3181	}
3182
3183	// finalize spawning anyway (this is why we don't return on errors above)
3184	if (fLaunchingVMProcess)
3185	{
3186	Assert(mData->mSession.mName == strSessionName \|\| FAILED(rc));
3187	/* Note that the progress object is finalized later */
3188	/** @todo Consider checking mData->mSession.mProgress for cancellation
3189	* around here. */
3190
3191	/* We don't reset mSession.mPID here because it is necessary for
3192	* SessionMachine::uninit() to reap the child process later. */
3193
3194	if (FAILED(rc))
3195	{
3196	/* Close the remote session, remove the remote control from the list
3197	* and reset session state to Closed (@note keep the code in sync
3198	* with the relevant part in checkForSpawnFailure()). */
3199
3200	Assert(mData->mSession.mRemoteControls.size() == 1);
3201	if (mData->mSession.mRemoteControls.size() == 1)
3202	{
3203	ErrorInfoKeeper eik;
3204	mData->mSession.mRemoteControls.front()->Uninitialize();
3205	}
3206
3207	mData->mSession.mRemoteControls.clear();
3208	mData->mSession.mState = SessionState_Unlocked;
3209	}
3210	}
3211	else
3212	{
3213	/* memorize PID of the directly opened session */
3214	if (SUCCEEDED(rc))
3215	mData->mSession.mPID = pid;
3216	}
3217
3218	if (SUCCEEDED(rc))
3219	{
3220	mData->mSession.mLockType = aLockType;
3221	/* memorize the direct session control and cache IUnknown for it */
3222	mData->mSession.mDirectControl = pSessionControl;
3223	mData->mSession.mState = SessionState_Locked;
3224	if (!fLaunchingVMProcess)
3225	mData->mSession.mName = strSessionName;
3226	/* associate the SessionMachine with this Machine */
3227	mData->mSession.mMachine = sessionMachine;
3228
3229	/* request an IUnknown pointer early from the remote party for later
3230	* identity checks (it will be internally cached within mDirectControl
3231	* at least on XPCOM) */
3232	ComPtr<IUnknown> unk = mData->mSession.mDirectControl;
3233	NOREF(unk);
3234	}
3235
3236	/* Release the lock since SessionMachine::uninit() locks VirtualBox which
3237	* would break the lock order */
3238	alock.release();
3239
3240	/* uninitialize the created session machine on failure */
3241	if (FAILED(rc))
3242	sessionMachine->uninit();
3243	}
3244
3245	if (SUCCEEDED(rc))
3246	{
3247	/*
3248	* tell the client watcher thread to update the set of
3249	* machines that have open sessions
3250	*/
3251	mParent->i_updateClientWatcher();
3252
3253	if (oldState != SessionState_Locked)
3254	/* fire an event */
3255	mParent->i_onSessionStateChanged(i_getId(), SessionState_Locked);
3256	}
3257
3258	return rc;
3259	}
3260
3261	/**
3262	* @note Locks objects!
3263	*/
3264	HRESULT Machine::launchVMProcess(const ComPtr<ISession> &aSession,
3265	const com::Utf8Str &aName,
3266	const std::vector<com::Utf8Str> &aEnvironmentChanges,
3267	ComPtr<IProgress> &aProgress)
3268	{
3269	Utf8Str strFrontend(aName);
3270	/* "emergencystop" doesn't need the session, so skip the checks/interface
3271	* retrieval. This code doesn't quite fit in here, but introducing a
3272	* special API method would be even more effort, and would require explicit
3273	* support by every API client. It's better to hide the feature a bit. */
3274	if (strFrontend != "emergencystop")
3275	CheckComArgNotNull(aSession);
3276
3277	HRESULT rc = S_OK;
3278	if (strFrontend.isEmpty())
3279	{
3280	Bstr bstrFrontend;
3281	rc = COMGETTER(DefaultFrontend)(bstrFrontend.asOutParam());
3282	if (FAILED(rc))
3283	return rc;
3284	strFrontend = bstrFrontend;
3285	if (strFrontend.isEmpty())
3286	{
3287	ComPtr<ISystemProperties> systemProperties;
3288	rc = mParent->COMGETTER(SystemProperties)(systemProperties.asOutParam());
3289	if (FAILED(rc))
3290	return rc;
3291	rc = systemProperties->COMGETTER(DefaultFrontend)(bstrFrontend.asOutParam());
3292	if (FAILED(rc))
3293	return rc;
3294	strFrontend = bstrFrontend;
3295	}
3296	/* paranoia - emergencystop is not a valid default */
3297	if (strFrontend == "emergencystop")
3298	strFrontend = Utf8Str::Empty;
3299	}
3300	/* default frontend: Qt GUI */
3301	if (strFrontend.isEmpty())
3302	strFrontend = "GUI/Qt";
3303
3304	if (strFrontend != "emergencystop")
3305	{
3306	/* check the session state */
3307	SessionState_T state;
3308	rc = aSession->COMGETTER(State)(&state);
3309	if (FAILED(rc))
3310	return rc;
3311
3312	if (state != SessionState_Unlocked)
3313	return setError(VBOX_E_INVALID_OBJECT_STATE,
3314	tr("The given session is busy"));
3315
3316	/* get the IInternalSessionControl interface */
3317	ComPtr<IInternalSessionControl> control(aSession);
3318	ComAssertMsgRet(!control.isNull(),
3319	("No IInternalSessionControl interface"),
3320	E_INVALIDARG);
3321
3322	/* get the teleporter enable state for the progress object init. */
3323	BOOL fTeleporterEnabled;
3324	rc = COMGETTER(TeleporterEnabled)(&fTeleporterEnabled);
3325	if (FAILED(rc))
3326	return rc;
3327
3328	/* create a progress object */
3329	ComObjPtr<ProgressProxy> progress;
3330	progress.createObject();
3331	rc = progress->init(mParent,
3332	static_cast<IMachine*>(this),
3333	Bstr(tr("Starting VM")).raw(),
3334	TRUE /* aCancelable */,
3335	fTeleporterEnabled ? 20 : 10 /* uTotalOperationsWeight */,
3336	BstrFmt(tr("Creating process for virtual machine \"%s\" (%s)"),
3337	mUserData->s.strName.c_str(), strFrontend.c_str()).raw(),
3338	2 /* uFirstOperationWeight */,
3339	fTeleporterEnabled ? 3 : 1 /* cOtherProgressObjectOperations */);
3340
3341	if (SUCCEEDED(rc))
3342	{
3343	rc = i_launchVMProcess(control, strFrontend, aEnvironmentChanges, progress);
3344	if (SUCCEEDED(rc))
3345	{
3346	aProgress = progress;
3347
3348	/* signal the client watcher thread */
3349	mParent->i_updateClientWatcher();
3350
3351	/* fire an event */
3352	mParent->i_onSessionStateChanged(i_getId(), SessionState_Spawning);
3353	}
3354	}
3355	}
3356	else
3357	{
3358	/* no progress object - either instant success or failure */
3359	aProgress = NULL;
3360
3361	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3362
3363	if (mData->mSession.mState != SessionState_Locked)
3364	return setError(VBOX_E_INVALID_OBJECT_STATE,
3365	tr("The machine '%s' is not locked by a session"),
3366	mUserData->s.strName.c_str());
3367
3368	/* must have a VM process associated - do not kill normal API clients
3369	* with an open session */
3370	if (!Global::IsOnline(mData->mMachineState))
3371	return setError(VBOX_E_INVALID_OBJECT_STATE,
3372	tr("The machine '%s' does not have a VM process"),
3373	mUserData->s.strName.c_str());
3374
3375	/* forcibly terminate the VM process */
3376	if (mData->mSession.mPID != NIL_RTPROCESS)
3377	RTProcTerminate(mData->mSession.mPID);
3378
3379	/* signal the client watcher thread, as most likely the client has
3380	* been terminated */
3381	mParent->i_updateClientWatcher();
3382	}
3383
3384	return rc;
3385	}
3386
3387	HRESULT Machine::setBootOrder(ULONG aPosition, DeviceType_T aDevice)
3388	{
3389	if (aPosition < 1 \|\| aPosition > SchemaDefs::MaxBootPosition)
3390	return setError(E_INVALIDARG,
3391	tr("Invalid boot position: %lu (must be in range [1, %lu])"),
3392	aPosition, SchemaDefs::MaxBootPosition);
3393
3394	if (aDevice == DeviceType_USB)
3395	return setError(E_NOTIMPL,
3396	tr("Booting from USB device is currently not supported"));
3397
3398	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3399
3400	HRESULT rc = i_checkStateDependency(MutableStateDep);
3401	if (FAILED(rc)) return rc;
3402
3403	i_setModified(IsModified_MachineData);
3404	mHWData.backup();
3405	mHWData->mBootOrder[aPosition - 1] = aDevice;
3406
3407	return S_OK;
3408	}
3409
3410	HRESULT Machine::getBootOrder(ULONG aPosition, DeviceType_T *aDevice)
3411	{
3412	if (aPosition < 1 \|\| aPosition > SchemaDefs::MaxBootPosition)
3413	return setError(E_INVALIDARG,
3414	tr("Invalid boot position: %lu (must be in range [1, %lu])"),
3415	aPosition, SchemaDefs::MaxBootPosition);
3416
3417	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3418
3419	*aDevice = mHWData->mBootOrder[aPosition - 1];
3420
3421	return S_OK;
3422	}
3423
3424	HRESULT Machine::attachDevice(const com::Utf8Str &aName,
3425	LONG aControllerPort,
3426	LONG aDevice,
3427	DeviceType_T aType,
3428	const ComPtr<IMedium> &aMedium)
3429	{
3430	IMedium *aM = aMedium;
3431	LogFlowThisFunc(("aControllerName=\"%s\" aControllerPort=%d aDevice=%d aType=%d aMedium=%p\n",
3432	aName.c_str(), aControllerPort, aDevice, aType, aM));
3433
3434	// request the host lock first, since might be calling Host methods for getting host drives;
3435	// next, protect the media tree all the while we're in here, as well as our member variables
3436	AutoMultiWriteLock2 alock(mParent->i_host(), this COMMA_LOCKVAL_SRC_POS);
3437	AutoWriteLock treeLock(&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
3438
3439	HRESULT rc = i_checkStateDependency(MutableOrRunningStateDep);
3440	if (FAILED(rc)) return rc;
3441
3442	/// @todo NEWMEDIA implicit machine registration
3443	if (!mData->mRegistered)
3444	return setError(VBOX_E_INVALID_OBJECT_STATE,
3445	tr("Cannot attach storage devices to an unregistered machine"));
3446
3447	AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
3448
3449	/* Check for an existing controller. */
3450	ComObjPtr<StorageController> ctl;
3451	rc = i_getStorageControllerByName(aName, ctl, true /* aSetError */);
3452	if (FAILED(rc)) return rc;
3453
3454	StorageControllerType_T ctrlType;
3455	rc = ctl->COMGETTER(ControllerType)(&ctrlType);
3456	if (FAILED(rc))
3457	return setError(E_FAIL,
3458	tr("Could not get type of controller '%s'"),
3459	aName.c_str());
3460
3461	bool fSilent = false;
3462	Utf8Str strReconfig;
3463
3464	/* Check whether the flag to allow silent storage attachment reconfiguration is set. */
3465	strReconfig = i_getExtraData(Utf8Str("VBoxInternal2/SilentReconfigureWhilePaused"));
3466	if ( mData->mMachineState == MachineState_Paused
3467	&& strReconfig == "1")
3468	fSilent = true;
3469
3470	/* Check that the controller can do hotplugging if we detach the device while the VM is running. */
3471	bool fHotplug = false;
3472	if (!fSilent && Global::IsOnlineOrTransient(mData->mMachineState))
3473	fHotplug = true;
3474
3475	if (fHotplug && !i_isControllerHotplugCapable(ctrlType))
3476	return setError(VBOX_E_INVALID_VM_STATE,
3477	tr("Controller '%s' does not support hotplugging"),
3478	aName.c_str());
3479
3480	// check that the port and device are not out of range
3481	rc = ctl->i_checkPortAndDeviceValid(aControllerPort, aDevice);
3482	if (FAILED(rc)) return rc;
3483
3484	/* check if the device slot is already busy */
3485	MediumAttachment *pAttachTemp;
3486	if ((pAttachTemp = i_findAttachment(*mMediumAttachments.data(),
3487	aName,
3488	aControllerPort,
3489	aDevice)))
3490	{
3491	Medium *pMedium = pAttachTemp->i_getMedium();
3492	if (pMedium)
3493	{
3494	AutoReadLock mediumLock(pMedium COMMA_LOCKVAL_SRC_POS);
3495	return setError(VBOX_E_OBJECT_IN_USE,
3496	tr("Medium '%s' is already attached to port %d, device %d of controller '%s' of this virtual machine"),
3497	pMedium->i_getLocationFull().c_str(),
3498	aControllerPort,
3499	aDevice,
3500	aName.c_str());
3501	}
3502	else
3503	return setError(VBOX_E_OBJECT_IN_USE,
3504	tr("Device is already attached to port %d, device %d of controller '%s' of this virtual machine"),
3505	aControllerPort, aDevice, aName.c_str());
3506	}
3507
3508	ComObjPtr<Medium> medium = static_cast<Medium*>(aM);
3509	if (aMedium && medium.isNull())
3510	return setError(E_INVALIDARG, "The given medium pointer is invalid");
3511
3512	AutoCaller mediumCaller(medium);
3513	if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
3514
3515	AutoWriteLock mediumLock(medium COMMA_LOCKVAL_SRC_POS);
3516
3517	if ( (pAttachTemp = i_findAttachment(*mMediumAttachments.data(), medium))
3518	&& !medium.isNull()
3519	&& ( medium->i_getType() != MediumType_Readonly
3520	\|\| medium->i_getDeviceType() != DeviceType_DVD)
3521	)
3522	return setError(VBOX_E_OBJECT_IN_USE,
3523	tr("Medium '%s' is already attached to this virtual machine"),
3524	medium->i_getLocationFull().c_str());
3525
3526	if (!medium.isNull())
3527	{
3528	MediumType_T mtype = medium->i_getType();
3529	// MediumType_Readonly is also new, but only applies to DVDs and floppies.
3530	// For DVDs it's not written to the config file, so needs no global config
3531	// version bump. For floppies it's a new attribute "type", which is ignored
3532	// by older VirtualBox version, so needs no global config version bump either.
3533	// For hard disks this type is not accepted.
3534	if (mtype == MediumType_MultiAttach)
3535	{
3536	// This type is new with VirtualBox 4.0 and therefore requires settings
3537	// version 1.11 in the settings backend. Unfortunately it is not enough to do
3538	// the usual routine in MachineConfigFile::bumpSettingsVersionIfNeeded() for
3539	// two reasons: The medium type is a property of the media registry tree, which
3540	// can reside in the global config file (for pre-4.0 media); we would therefore
3541	// possibly need to bump the global config version. We don't want to do that though
3542	// because that might make downgrading to pre-4.0 impossible.
3543	// As a result, we can only use these two new types if the medium is NOT in the
3544	// global registry:
3545	const Guid &uuidGlobalRegistry = mParent->i_getGlobalRegistryId();
3546	if ( medium->i_isInRegistry(uuidGlobalRegistry)
3547	\|\| !mData->pMachineConfigFile->canHaveOwnMediaRegistry()
3548	)
3549	return setError(VBOX_E_INVALID_OBJECT_STATE,
3550	tr("Cannot attach medium '%s': the media type 'MultiAttach' can only be attached "
3551	"to machines that were created with VirtualBox 4.0 or later"),
3552	medium->i_getLocationFull().c_str());
3553	}
3554	}
3555
3556	bool fIndirect = false;
3557	if (!medium.isNull())
3558	fIndirect = medium->i_isReadOnly();
3559	bool associate = true;
3560
3561	do
3562	{
3563	if ( aType == DeviceType_HardDisk
3564	&& mMediumAttachments.isBackedUp())
3565	{
3566	const MediumAttachmentList &oldAtts = *mMediumAttachments.backedUpData();
3567
3568	/* check if the medium was attached to the VM before we started
3569	* changing attachments in which case the attachment just needs to
3570	* be restored */
3571	if ((pAttachTemp = i_findAttachment(oldAtts, medium)))
3572	{
3573	AssertReturn(!fIndirect, E_FAIL);
3574
3575	/* see if it's the same bus/channel/device */
3576	if (pAttachTemp->i_matches(aName, aControllerPort, aDevice))
3577	{
3578	/* the simplest case: restore the whole attachment
3579	* and return, nothing else to do */
3580	mMediumAttachments->push_back(pAttachTemp);
3581
3582	/* Reattach the medium to the VM. */
3583	if (fHotplug \|\| fSilent)
3584	{
3585	mediumLock.release();
3586	treeLock.release();
3587	alock.release();
3588
3589	MediumLockList *pMediumLockList(new MediumLockList());
3590
3591	rc = medium->i_createMediumLockList(true /* fFailIfInaccessible */,
3592	medium /* pToLockWrite */,
3593	false /* fMediumLockWriteAll */,
3594	NULL,
3595	*pMediumLockList);
3596	alock.acquire();
3597	if (FAILED(rc))
3598	delete pMediumLockList;
3599	else
3600	{
3601	mData->mSession.mLockedMedia.Unlock();
3602	alock.release();
3603	rc = mData->mSession.mLockedMedia.Insert(pAttachTemp, pMediumLockList);
3604	mData->mSession.mLockedMedia.Lock();
3605	alock.acquire();
3606	}
3607	alock.release();
3608
3609	if (SUCCEEDED(rc))
3610	{
3611	rc = i_onStorageDeviceChange(pAttachTemp, FALSE /* aRemove */, fSilent);
3612	/* Remove lock list in case of error. */
3613	if (FAILED(rc))
3614	{
3615	mData->mSession.mLockedMedia.Unlock();
3616	mData->mSession.mLockedMedia.Remove(pAttachTemp);
3617	mData->mSession.mLockedMedia.Lock();
3618	}
3619	}
3620	}
3621
3622	return S_OK;
3623	}
3624
3625	/* bus/channel/device differ; we need a new attachment object,
3626	* but don't try to associate it again */
3627	associate = false;
3628	break;
3629	}
3630	}
3631
3632	/* go further only if the attachment is to be indirect */
3633	if (!fIndirect)
3634	break;
3635
3636	/* perform the so called smart attachment logic for indirect
3637	* attachments. Note that smart attachment is only applicable to base
3638	* hard disks. */
3639
3640	if (medium->i_getParent().isNull())
3641	{
3642	/* first, investigate the backup copy of the current hard disk
3643	* attachments to make it possible to re-attach existing diffs to
3644	* another device slot w/o losing their contents */
3645	if (mMediumAttachments.isBackedUp())
3646	{
3647	const MediumAttachmentList &oldAtts = *mMediumAttachments.backedUpData();
3648
3649	MediumAttachmentList::const_iterator foundIt = oldAtts.end();
3650	uint32_t foundLevel = 0;
3651
3652	for (MediumAttachmentList::const_iterator
3653	it = oldAtts.begin();
3654	it != oldAtts.end();
3655	++it)
3656	{
3657	uint32_t level = 0;
3658	MediumAttachment pAttach = it;
3659	ComObjPtr<Medium> pMedium = pAttach->i_getMedium();
3660	Assert(!pMedium.isNull() \|\| pAttach->i_getType() != DeviceType_HardDisk);
3661	if (pMedium.isNull())
3662	continue;
3663
3664	if (pMedium->i_getBase(&level) == medium)
3665	{
3666	/* skip the hard disk if its currently attached (we
3667	* cannot attach the same hard disk twice) */
3668	if (i_findAttachment(*mMediumAttachments.data(),
3669	pMedium))
3670	continue;
3671
3672	/* matched device, channel and bus (i.e. attached to the
3673	* same place) will win and immediately stop the search;
3674	* otherwise the attachment that has the youngest
3675	* descendant of medium will be used
3676	*/
3677	if (pAttach->i_matches(aName, aControllerPort, aDevice))
3678	{
3679	/* the simplest case: restore the whole attachment
3680	* and return, nothing else to do */
3681	mMediumAttachments->push_back(*it);
3682
3683	/* Reattach the medium to the VM. */
3684	if (fHotplug \|\| fSilent)
3685	{
3686	mediumLock.release();
3687	treeLock.release();
3688	alock.release();
3689
3690	MediumLockList *pMediumLockList(new MediumLockList());
3691
3692	rc = medium->i_createMediumLockList(true /* fFailIfInaccessible */,
3693	medium /* pToLockWrite */,
3694	false /* fMediumLockWriteAll */,
3695	NULL,
3696	*pMediumLockList);
3697	alock.acquire();
3698	if (FAILED(rc))
3699	delete pMediumLockList;
3700	else
3701	{
3702	mData->mSession.mLockedMedia.Unlock();
3703	alock.release();
3704	rc = mData->mSession.mLockedMedia.Insert(pAttachTemp, pMediumLockList);
3705	mData->mSession.mLockedMedia.Lock();
3706	alock.acquire();
3707	}
3708	alock.release();
3709
3710	if (SUCCEEDED(rc))
3711	{
3712	rc = i_onStorageDeviceChange(pAttachTemp, FALSE /* aRemove */, fSilent);
3713	/* Remove lock list in case of error. */
3714	if (FAILED(rc))
3715	{
3716	mData->mSession.mLockedMedia.Unlock();
3717	mData->mSession.mLockedMedia.Remove(pAttachTemp);
3718	mData->mSession.mLockedMedia.Lock();
3719	}
3720	}
3721	}
3722
3723	return S_OK;
3724	}
3725	else if ( foundIt == oldAtts.end()
3726	\|\| level > foundLevel /* prefer younger */
3727	)
3728	{
3729	foundIt = it;
3730	foundLevel = level;
3731	}
3732	}
3733	}
3734
3735	if (foundIt != oldAtts.end())
3736	{
3737	/* use the previously attached hard disk */
3738	medium = (*foundIt)->i_getMedium();
3739	mediumCaller.attach(medium);
3740	if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
3741	mediumLock.attach(medium);
3742	/* not implicit, doesn't require association with this VM */
3743	fIndirect = false;
3744	associate = false;
3745	/* go right to the MediumAttachment creation */
3746	break;
3747	}
3748	}
3749
3750	/* must give up the medium lock and medium tree lock as below we
3751	* go over snapshots, which needs a lock with higher lock order. */
3752	mediumLock.release();
3753	treeLock.release();
3754
3755	/* then, search through snapshots for the best diff in the given
3756	* hard disk's chain to base the new diff on */
3757
3758	ComObjPtr<Medium> base;
3759	ComObjPtr<Snapshot> snap = mData->mCurrentSnapshot;
3760	while (snap)
3761	{
3762	AutoReadLock snapLock(snap COMMA_LOCKVAL_SRC_POS);
3763
3764	const MediumAttachmentList &snapAtts = *snap->i_getSnapshotMachine()->mMediumAttachments.data();
3765
3766	MediumAttachment *pAttachFound = NULL;
3767	uint32_t foundLevel = 0;
3768
3769	for (MediumAttachmentList::const_iterator
3770	it = snapAtts.begin();
3771	it != snapAtts.end();
3772	++it)
3773	{
3774	MediumAttachment pAttach = it;
3775	ComObjPtr<Medium> pMedium = pAttach->i_getMedium();
3776	Assert(!pMedium.isNull() \|\| pAttach->i_getType() != DeviceType_HardDisk);
3777	if (pMedium.isNull())
3778	continue;
3779
3780	uint32_t level = 0;
3781	if (pMedium->i_getBase(&level) == medium)
3782	{
3783	/* matched device, channel and bus (i.e. attached to the
3784	* same place) will win and immediately stop the search;
3785	* otherwise the attachment that has the youngest
3786	* descendant of medium will be used
3787	*/
3788	if ( pAttach->i_getDevice() == aDevice
3789	&& pAttach->i_getPort() == aControllerPort
3790	&& pAttach->i_getControllerName() == aName
3791	)
3792	{
3793	pAttachFound = pAttach;
3794	break;
3795	}
3796	else if ( !pAttachFound
3797	\|\| level > foundLevel /* prefer younger */
3798	)
3799	{
3800	pAttachFound = pAttach;
3801	foundLevel = level;
3802	}
3803	}
3804	}
3805
3806	if (pAttachFound)
3807	{
3808	base = pAttachFound->i_getMedium();
3809	break;
3810	}
3811
3812	snap = snap->i_getParent();
3813	}
3814
3815	/* re-lock medium tree and the medium, as we need it below */
3816	treeLock.acquire();
3817	mediumLock.acquire();
3818
3819	/* found a suitable diff, use it as a base */
3820	if (!base.isNull())
3821	{
3822	medium = base;
3823	mediumCaller.attach(medium);
3824	if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
3825	mediumLock.attach(medium);
3826	}
3827	}
3828
3829	Utf8Str strFullSnapshotFolder;
3830	i_calculateFullPath(mUserData->s.strSnapshotFolder, strFullSnapshotFolder);
3831
3832	ComObjPtr<Medium> diff;
3833	diff.createObject();
3834	// store this diff in the same registry as the parent
3835	Guid uuidRegistryParent;
3836	if (!medium->i_getFirstRegistryMachineId(uuidRegistryParent))
3837	{
3838	// parent image has no registry: this can happen if we're attaching a new immutable
3839	// image that has not yet been attached (medium then points to the base and we're
3840	// creating the diff image for the immutable, and the parent is not yet registered);
3841	// put the parent in the machine registry then
3842	mediumLock.release();
3843	treeLock.release();
3844	alock.release();
3845	i_addMediumToRegistry(medium);
3846	alock.acquire();
3847	treeLock.acquire();
3848	mediumLock.acquire();
3849	medium->i_getFirstRegistryMachineId(uuidRegistryParent);
3850	}
3851	rc = diff->init(mParent,
3852	medium->i_getPreferredDiffFormat(),
3853	strFullSnapshotFolder.append(RTPATH_SLASH_STR),
3854	uuidRegistryParent,
3855	DeviceType_HardDisk);
3856	if (FAILED(rc)) return rc;
3857
3858	/* Apply the normal locking logic to the entire chain. */
3859	MediumLockList *pMediumLockList(new MediumLockList());
3860	mediumLock.release();
3861	treeLock.release();
3862	rc = diff->i_createMediumLockList(true /* fFailIfInaccessible */,
3863	diff /* pToLockWrite */,
3864	false /* fMediumLockWriteAll */,
3865	medium,
3866	*pMediumLockList);
3867	treeLock.acquire();
3868	mediumLock.acquire();
3869	if (SUCCEEDED(rc))
3870	{
3871	mediumLock.release();
3872	treeLock.release();
3873	rc = pMediumLockList->Lock();
3874	treeLock.acquire();
3875	mediumLock.acquire();
3876	if (FAILED(rc))
3877	setError(rc,
3878	tr("Could not lock medium when creating diff '%s'"),
3879	diff->i_getLocationFull().c_str());
3880	else
3881	{
3882	/* will release the lock before the potentially lengthy
3883	* operation, so protect with the special state */
3884	MachineState_T oldState = mData->mMachineState;
3885	i_setMachineState(MachineState_SettingUp);
3886
3887	mediumLock.release();
3888	treeLock.release();
3889	alock.release();
3890
3891	rc = medium->i_createDiffStorage(diff,
3892	medium->i_getPreferredDiffVariant(),
3893	pMediumLockList,
3894	NULL /* aProgress */,
3895	true /* aWait */,
3896	false /* aNotify */);
3897
3898	alock.acquire();
3899	treeLock.acquire();
3900	mediumLock.acquire();
3901
3902	i_setMachineState(oldState);
3903	}
3904	}
3905
3906	/* Unlock the media and free the associated memory. */
3907	delete pMediumLockList;
3908
3909	if (FAILED(rc)) return rc;
3910
3911	/* use the created diff for the actual attachment */
3912	medium = diff;
3913	mediumCaller.attach(medium);
3914	if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
3915	mediumLock.attach(medium);
3916	}
3917	while (0);
3918
3919	ComObjPtr<MediumAttachment> attachment;
3920	attachment.createObject();
3921	rc = attachment->init(this,
3922	medium,
3923	aName,
3924	aControllerPort,
3925	aDevice,
3926	aType,
3927	fIndirect,
3928	false /* fPassthrough */,
3929	false /* fTempEject */,
3930	false /* fNonRotational */,
3931	false /* fDiscard */,
3932	fHotplug /* fHotPluggable */,
3933	Utf8Str::Empty);
3934	if (FAILED(rc)) return rc;
3935
3936	if (associate && !medium.isNull())
3937	{
3938	// as the last step, associate the medium to the VM
3939	rc = medium->i_addBackReference(mData->mUuid);
3940	// here we can fail because of Deleting, or being in process of creating a Diff
3941	if (FAILED(rc)) return rc;
3942
3943	mediumLock.release();
3944	treeLock.release();
3945	alock.release();
3946	i_addMediumToRegistry(medium);
3947	alock.acquire();
3948	treeLock.acquire();
3949	mediumLock.acquire();
3950	}
3951
3952	/* success: finally remember the attachment */
3953	i_setModified(IsModified_Storage);
3954	mMediumAttachments.backup();
3955	mMediumAttachments->push_back(attachment);
3956
3957	mediumLock.release();
3958	treeLock.release();
3959	alock.release();
3960
3961	if (fHotplug \|\| fSilent)
3962	{
3963	if (!medium.isNull())
3964	{
3965	MediumLockList *pMediumLockList(new MediumLockList());
3966
3967	rc = medium->i_createMediumLockList(true /* fFailIfInaccessible */,
3968	medium /* pToLockWrite */,
3969	false /* fMediumLockWriteAll */,
3970	NULL,
3971	*pMediumLockList);
3972	alock.acquire();
3973	if (FAILED(rc))
3974	delete pMediumLockList;
3975	else
3976	{
3977	mData->mSession.mLockedMedia.Unlock();
3978	alock.release();
3979	rc = mData->mSession.mLockedMedia.Insert(attachment, pMediumLockList);
3980	mData->mSession.mLockedMedia.Lock();
3981	alock.acquire();
3982	}
3983	alock.release();
3984	}
3985
3986	if (SUCCEEDED(rc))
3987	{
3988	rc = i_onStorageDeviceChange(attachment, FALSE /* aRemove */, fSilent);
3989	/* Remove lock list in case of error. */
3990	if (FAILED(rc))
3991	{
3992	mData->mSession.mLockedMedia.Unlock();
3993	mData->mSession.mLockedMedia.Remove(attachment);
3994	mData->mSession.mLockedMedia.Lock();
3995	}
3996	}
3997	}
3998
3999	/* Save modified registries, but skip this machine as it's the caller's
4000	* job to save its settings like all other settings changes. */
4001	mParent->i_unmarkRegistryModified(i_getId());
4002	mParent->i_saveModifiedRegistries();
4003
4004	if (SUCCEEDED(rc))
4005	{
4006	if (fIndirect && medium != aM)
4007	mParent->i_onMediumConfigChanged(medium);
4008	mParent->i_onStorageDeviceChanged(attachment, FALSE, fSilent);
4009	}
4010
4011	return rc;
4012	}
4013
4014	HRESULT Machine::detachDevice(const com::Utf8Str &aName, LONG aControllerPort,
4015	LONG aDevice)
4016	{
4017	LogFlowThisFunc(("aControllerName=\"%s\" aControllerPort=%d aDevice=%d\n",
4018	aName.c_str(), aControllerPort, aDevice));
4019
4020	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4021
4022	HRESULT rc = i_checkStateDependency(MutableOrRunningStateDep);
4023	if (FAILED(rc)) return rc;
4024
4025	AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
4026
4027	/* Check for an existing controller. */
4028	ComObjPtr<StorageController> ctl;
4029	rc = i_getStorageControllerByName(aName, ctl, true /* aSetError */);
4030	if (FAILED(rc)) return rc;
4031
4032	StorageControllerType_T ctrlType;
4033	rc = ctl->COMGETTER(ControllerType)(&ctrlType);
4034	if (FAILED(rc))
4035	return setError(E_FAIL,
4036	tr("Could not get type of controller '%s'"),
4037	aName.c_str());
4038
4039	bool fSilent = false;
4040	Utf8Str strReconfig;
4041
4042	/* Check whether the flag to allow silent storage attachment reconfiguration is set. */
4043	strReconfig = i_getExtraData(Utf8Str("VBoxInternal2/SilentReconfigureWhilePaused"));
4044	if ( mData->mMachineState == MachineState_Paused
4045	&& strReconfig == "1")
4046	fSilent = true;
4047
4048	/* Check that the controller can do hotplugging if we detach the device while the VM is running. */
4049	bool fHotplug = false;
4050	if (!fSilent && Global::IsOnlineOrTransient(mData->mMachineState))
4051	fHotplug = true;
4052
4053	if (fHotplug && !i_isControllerHotplugCapable(ctrlType))
4054	return setError(VBOX_E_INVALID_VM_STATE,
4055	tr("Controller '%s' does not support hotplugging"),
4056	aName.c_str());
4057
4058	MediumAttachment pAttach = i_findAttachment(mMediumAttachments.data(),
4059	aName,
4060	aControllerPort,
4061	aDevice);
4062	if (!pAttach)
4063	return setError(VBOX_E_OBJECT_NOT_FOUND,
4064	tr("No storage device attached to device slot %d on port %d of controller '%s'"),
4065	aDevice, aControllerPort, aName.c_str());
4066
4067	if (fHotplug && !pAttach->i_getHotPluggable())
4068	return setError(VBOX_E_NOT_SUPPORTED,
4069	tr("The device slot %d on port %d of controller '%s' does not support hotplugging"),
4070	aDevice, aControllerPort, aName.c_str());
4071
4072	/*
4073	* The VM has to detach the device before we delete any implicit diffs.
4074	* If this fails we can roll back without loosing data.
4075	*/
4076	if (fHotplug \|\| fSilent)
4077	{
4078	alock.release();
4079	rc = i_onStorageDeviceChange(pAttach, TRUE /* aRemove */, fSilent);
4080	alock.acquire();
4081	}
4082	if (FAILED(rc)) return rc;
4083
4084	/* If we are here everything went well and we can delete the implicit now. */
4085	rc = i_detachDevice(pAttach, alock, NULL /* pSnapshot */);
4086
4087	alock.release();
4088
4089	/* Save modified registries, but skip this machine as it's the caller's
4090	* job to save its settings like all other settings changes. */
4091	mParent->i_unmarkRegistryModified(i_getId());
4092	mParent->i_saveModifiedRegistries();
4093
4094	if (SUCCEEDED(rc))
4095	mParent->i_onStorageDeviceChanged(pAttach, TRUE, fSilent);
4096
4097	return rc;
4098	}
4099
4100	HRESULT Machine::passthroughDevice(const com::Utf8Str &aName, LONG aControllerPort,
4101	LONG aDevice, BOOL aPassthrough)
4102	{
4103	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d aPassthrough=%d\n",
4104	aName.c_str(), aControllerPort, aDevice, aPassthrough));
4105
4106	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4107
4108	HRESULT rc = i_checkStateDependency(MutableOrRunningStateDep);
4109	if (FAILED(rc)) return rc;
4110
4111	AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
4112
4113	/* Check for an existing controller. */
4114	ComObjPtr<StorageController> ctl;
4115	rc = i_getStorageControllerByName(aName, ctl, true /* aSetError */);
4116	if (FAILED(rc)) return rc;
4117
4118	StorageControllerType_T ctrlType;
4119	rc = ctl->COMGETTER(ControllerType)(&ctrlType);
4120	if (FAILED(rc))
4121	return setError(E_FAIL,
4122	tr("Could not get type of controller '%s'"),
4123	aName.c_str());
4124
4125	bool fSilent = false;
4126	Utf8Str strReconfig;
4127
4128	/* Check whether the flag to allow silent storage attachment reconfiguration is set. */
4129	strReconfig = i_getExtraData(Utf8Str("VBoxInternal2/SilentReconfigureWhilePaused"));
4130	if ( mData->mMachineState == MachineState_Paused
4131	&& strReconfig == "1")
4132	fSilent = true;
4133
4134	/* Check that the controller can do hotplugging if we detach the device while the VM is running. */
4135	bool fHotplug = false;
4136	if (!fSilent && Global::IsOnlineOrTransient(mData->mMachineState))
4137	fHotplug = true;
4138
4139	if (fHotplug && !i_isControllerHotplugCapable(ctrlType))
4140	return setError(VBOX_E_INVALID_VM_STATE,
4141	tr("Controller '%s' does not support hotplugging which is required to change the passthrough setting while the VM is running"),
4142	aName.c_str());
4143
4144	MediumAttachment pAttach = i_findAttachment(mMediumAttachments.data(),
4145	aName,
4146	aControllerPort,
4147	aDevice);
4148	if (!pAttach)
4149	return setError(VBOX_E_OBJECT_NOT_FOUND,
4150	tr("No storage device attached to device slot %d on port %d of controller '%s'"),
4151	aDevice, aControllerPort, aName.c_str());
4152
4153
4154	i_setModified(IsModified_Storage);
4155	mMediumAttachments.backup();
4156
4157	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
4158
4159	if (pAttach->i_getType() != DeviceType_DVD)
4160	return setError(E_INVALIDARG,
4161	tr("Setting passthrough rejected as the device attached to device slot %d on port %d of controller '%s' is not a DVD"),
4162	aDevice, aControllerPort, aName.c_str());
4163
4164	bool fValueChanged = pAttach->i_getPassthrough() != (aPassthrough != 0);
4165
4166	pAttach->i_updatePassthrough(!!aPassthrough);
4167
4168	attLock.release();
4169	alock.release();
4170	rc = i_onStorageDeviceChange(pAttach, FALSE /* aRemove /, FALSE / aSilent */);
4171	if (SUCCEEDED(rc) && fValueChanged)
4172	mParent->i_onStorageDeviceChanged(pAttach, FALSE, FALSE);
4173
4174	return rc;
4175	}
4176
4177	HRESULT Machine::temporaryEjectDevice(const com::Utf8Str &aName, LONG aControllerPort,
4178	LONG aDevice, BOOL aTemporaryEject)
4179	{
4180
4181	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d aTemporaryEject=%d\n",
4182	aName.c_str(), aControllerPort, aDevice, aTemporaryEject));
4183
4184	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4185
4186	HRESULT rc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
4187	if (FAILED(rc)) return rc;
4188
4189	MediumAttachment pAttach = i_findAttachment(mMediumAttachments.data(),
4190	aName,
4191	aControllerPort,
4192	aDevice);
4193	if (!pAttach)
4194	return setError(VBOX_E_OBJECT_NOT_FOUND,
4195	tr("No storage device attached to device slot %d on port %d of controller '%s'"),
4196	aDevice, aControllerPort, aName.c_str());
4197
4198
4199	i_setModified(IsModified_Storage);
4200	mMediumAttachments.backup();
4201
4202	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
4203
4204	if (pAttach->i_getType() != DeviceType_DVD)
4205	return setError(E_INVALIDARG,
4206	tr("Setting temporary eject flag rejected as the device attached to device slot %d on port %d of controller '%s' is not a DVD"),
4207	aDevice, aControllerPort, aName.c_str());
4208	pAttach->i_updateTempEject(!!aTemporaryEject);
4209
4210	return S_OK;
4211	}
4212
4213	HRESULT Machine::nonRotationalDevice(const com::Utf8Str &aName, LONG aControllerPort,
4214	LONG aDevice, BOOL aNonRotational)
4215	{
4216
4217	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d aNonRotational=%d\n",
4218	aName.c_str(), aControllerPort, aDevice, aNonRotational));
4219
4220	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4221
4222	HRESULT rc = i_checkStateDependency(MutableStateDep);
4223	if (FAILED(rc)) return rc;
4224
4225	AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
4226
4227	if (Global::IsOnlineOrTransient(mData->mMachineState))
4228	return setError(VBOX_E_INVALID_VM_STATE,
4229	tr("Invalid machine state: %s"),
4230	Global::stringifyMachineState(mData->mMachineState));
4231
4232	MediumAttachment pAttach = i_findAttachment(mMediumAttachments.data(),
4233	aName,
4234	aControllerPort,
4235	aDevice);
4236	if (!pAttach)
4237	return setError(VBOX_E_OBJECT_NOT_FOUND,
4238	tr("No storage device attached to device slot %d on port %d of controller '%s'"),
4239	aDevice, aControllerPort, aName.c_str());
4240
4241
4242	i_setModified(IsModified_Storage);
4243	mMediumAttachments.backup();
4244
4245	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
4246
4247	if (pAttach->i_getType() != DeviceType_HardDisk)
4248	return setError(E_INVALIDARG,
4249	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"),
4250	aDevice, aControllerPort, aName.c_str());
4251	pAttach->i_updateNonRotational(!!aNonRotational);
4252
4253	return S_OK;
4254	}
4255
4256	HRESULT Machine::setAutoDiscardForDevice(const com::Utf8Str &aName, LONG aControllerPort,
4257	LONG aDevice, BOOL aDiscard)
4258	{
4259
4260	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d aDiscard=%d\n",
4261	aName.c_str(), aControllerPort, aDevice, aDiscard));
4262
4263	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4264
4265	HRESULT rc = i_checkStateDependency(MutableStateDep);
4266	if (FAILED(rc)) return rc;
4267
4268	AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
4269
4270	if (Global::IsOnlineOrTransient(mData->mMachineState))
4271	return setError(VBOX_E_INVALID_VM_STATE,
4272	tr("Invalid machine state: %s"),
4273	Global::stringifyMachineState(mData->mMachineState));
4274
4275	MediumAttachment pAttach = i_findAttachment(mMediumAttachments.data(),
4276	aName,
4277	aControllerPort,
4278	aDevice);
4279	if (!pAttach)
4280	return setError(VBOX_E_OBJECT_NOT_FOUND,
4281	tr("No storage device attached to device slot %d on port %d of controller '%s'"),
4282	aDevice, aControllerPort, aName.c_str());
4283
4284
4285	i_setModified(IsModified_Storage);
4286	mMediumAttachments.backup();
4287
4288	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
4289
4290	if (pAttach->i_getType() != DeviceType_HardDisk)
4291	return setError(E_INVALIDARG,
4292	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"),
4293	aDevice, aControllerPort, aName.c_str());
4294	pAttach->i_updateDiscard(!!aDiscard);
4295
4296	return S_OK;
4297	}
4298
4299	HRESULT Machine::setHotPluggableForDevice(const com::Utf8Str &aName, LONG aControllerPort,
4300	LONG aDevice, BOOL aHotPluggable)
4301	{
4302	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d aHotPluggable=%d\n",
4303	aName.c_str(), aControllerPort, aDevice, aHotPluggable));
4304
4305	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4306
4307	HRESULT rc = i_checkStateDependency(MutableStateDep);
4308	if (FAILED(rc)) return rc;
4309
4310	AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
4311
4312	if (Global::IsOnlineOrTransient(mData->mMachineState))
4313	return setError(VBOX_E_INVALID_VM_STATE,
4314	tr("Invalid machine state: %s"),
4315	Global::stringifyMachineState(mData->mMachineState));
4316
4317	MediumAttachment pAttach = i_findAttachment(mMediumAttachments.data(),
4318	aName,
4319	aControllerPort,
4320	aDevice);
4321	if (!pAttach)
4322	return setError(VBOX_E_OBJECT_NOT_FOUND,
4323	tr("No storage device attached to device slot %d on port %d of controller '%s'"),
4324	aDevice, aControllerPort, aName.c_str());
4325
4326	/* Check for an existing controller. */
4327	ComObjPtr<StorageController> ctl;
4328	rc = i_getStorageControllerByName(aName, ctl, true /* aSetError */);
4329	if (FAILED(rc)) return rc;
4330
4331	StorageControllerType_T ctrlType;
4332	rc = ctl->COMGETTER(ControllerType)(&ctrlType);
4333	if (FAILED(rc))
4334	return setError(E_FAIL,
4335	tr("Could not get type of controller '%s'"),
4336	aName.c_str());
4337
4338	if (!i_isControllerHotplugCapable(ctrlType))
4339	return setError(VBOX_E_NOT_SUPPORTED,
4340	tr("Controller '%s' does not support changing the hot-pluggable device flag"),
4341	aName.c_str());
4342
4343	i_setModified(IsModified_Storage);
4344	mMediumAttachments.backup();
4345
4346	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
4347
4348	if (pAttach->i_getType() == DeviceType_Floppy)
4349	return setError(E_INVALIDARG,
4350	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"),
4351	aDevice, aControllerPort, aName.c_str());
4352	pAttach->i_updateHotPluggable(!!aHotPluggable);
4353
4354	return S_OK;
4355	}
4356
4357	HRESULT Machine::setNoBandwidthGroupForDevice(const com::Utf8Str &aName, LONG aControllerPort,
4358	LONG aDevice)
4359	{
4360	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d\n",
4361	aName.c_str(), aControllerPort, aDevice));
4362
4363	return setBandwidthGroupForDevice(aName, aControllerPort, aDevice, NULL);
4364	}
4365
4366	HRESULT Machine::setBandwidthGroupForDevice(const com::Utf8Str &aName, LONG aControllerPort,
4367	LONG aDevice, const ComPtr<IBandwidthGroup> &aBandwidthGroup)
4368	{
4369	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d\n",
4370	aName.c_str(), aControllerPort, aDevice));
4371
4372	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4373
4374	HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
4375	if (FAILED(rc)) return rc;
4376
4377	if (Global::IsOnlineOrTransient(mData->mMachineState))
4378	return setError(VBOX_E_INVALID_VM_STATE,
4379	tr("Invalid machine state: %s"),
4380	Global::stringifyMachineState(mData->mMachineState));
4381
4382	MediumAttachment pAttach = i_findAttachment(mMediumAttachments.data(),
4383	aName,
4384	aControllerPort,
4385	aDevice);
4386	if (!pAttach)
4387	return setError(VBOX_E_OBJECT_NOT_FOUND,
4388	tr("No storage device attached to device slot %d on port %d of controller '%s'"),
4389	aDevice, aControllerPort, aName.c_str());
4390
4391
4392	i_setModified(IsModified_Storage);
4393	mMediumAttachments.backup();
4394
4395	IBandwidthGroup *iB = aBandwidthGroup;
4396	ComObjPtr<BandwidthGroup> group = static_cast<BandwidthGroup*>(iB);
4397	if (aBandwidthGroup && group.isNull())
4398	return setError(E_INVALIDARG, "The given bandwidth group pointer is invalid");
4399
4400	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
4401
4402	const Utf8Str strBandwidthGroupOld = pAttach->i_getBandwidthGroup();
4403	if (strBandwidthGroupOld.isNotEmpty())
4404	{
4405	/* Get the bandwidth group object and release it - this must not fail. */
4406	ComObjPtr<BandwidthGroup> pBandwidthGroupOld;
4407	rc = i_getBandwidthGroup(strBandwidthGroupOld, pBandwidthGroupOld, false);
4408	Assert(SUCCEEDED(rc));
4409
4410	pBandwidthGroupOld->i_release();
4411	pAttach->i_updateBandwidthGroup(Utf8Str::Empty);
4412	}
4413
4414	if (!group.isNull())
4415	{
4416	group->i_reference();
4417	pAttach->i_updateBandwidthGroup(group->i_getName());
4418	}
4419
4420	return S_OK;
4421	}
4422
4423	HRESULT Machine::attachDeviceWithoutMedium(const com::Utf8Str &aName,
4424	LONG aControllerPort,
4425	LONG aDevice,
4426	DeviceType_T aType)
4427	{
4428	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d aType=%d\n",
4429	aName.c_str(), aControllerPort, aDevice, aType));
4430
4431	return attachDevice(aName, aControllerPort, aDevice, aType, NULL);
4432	}
4433
4434
4435	HRESULT Machine::unmountMedium(const com::Utf8Str &aName,
4436	LONG aControllerPort,
4437	LONG aDevice,
4438	BOOL aForce)
4439	{
4440	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d",
4441	aName.c_str(), aControllerPort, aForce));
4442
4443	return mountMedium(aName, aControllerPort, aDevice, NULL, aForce);
4444	}
4445
4446	HRESULT Machine::mountMedium(const com::Utf8Str &aName,
4447	LONG aControllerPort,
4448	LONG aDevice,
4449	const ComPtr<IMedium> &aMedium,
4450	BOOL aForce)
4451	{
4452	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d aForce=%d\n",
4453	aName.c_str(), aControllerPort, aDevice, aForce));
4454
4455	// request the host lock first, since might be calling Host methods for getting host drives;
4456	// next, protect the media tree all the while we're in here, as well as our member variables
4457	AutoMultiWriteLock3 multiLock(mParent->i_host()->lockHandle(),
4458	this->lockHandle(),
4459	&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
4460
4461	ComObjPtr<MediumAttachment> pAttach = i_findAttachment(*mMediumAttachments.data(),
4462	aName,
4463	aControllerPort,
4464	aDevice);
4465	if (pAttach.isNull())
4466	return setError(VBOX_E_OBJECT_NOT_FOUND,
4467	tr("No drive attached to device slot %d on port %d of controller '%s'"),
4468	aDevice, aControllerPort, aName.c_str());
4469
4470	/* Remember previously mounted medium. The medium before taking the
4471	* backup is not necessarily the same thing. */
4472	ComObjPtr<Medium> oldmedium;
4473	oldmedium = pAttach->i_getMedium();
4474
4475	IMedium *iM = aMedium;
4476	ComObjPtr<Medium> pMedium = static_cast<Medium*>(iM);
4477	if (aMedium && pMedium.isNull())
4478	return setError(E_INVALIDARG, "The given medium pointer is invalid");
4479
4480	AutoCaller mediumCaller(pMedium);
4481	if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
4482
4483	AutoWriteLock mediumLock(pMedium COMMA_LOCKVAL_SRC_POS);
4484	if (pMedium)
4485	{
4486	DeviceType_T mediumType = pAttach->i_getType();
4487	switch (mediumType)
4488	{
4489	case DeviceType_DVD:
4490	case DeviceType_Floppy:
4491	break;
4492
4493	default:
4494	return setError(VBOX_E_INVALID_OBJECT_STATE,
4495	tr("The device at port %d, device %d of controller '%s' of this virtual machine is not removeable"),
4496	aControllerPort,
4497	aDevice,
4498	aName.c_str());
4499	}
4500	}
4501
4502	i_setModified(IsModified_Storage);
4503	mMediumAttachments.backup();
4504
4505	{
4506	// The backup operation makes the pAttach reference point to the
4507	// old settings. Re-get the correct reference.
4508	pAttach = i_findAttachment(*mMediumAttachments.data(),
4509	aName,
4510	aControllerPort,
4511	aDevice);
4512	if (!oldmedium.isNull())
4513	oldmedium->i_removeBackReference(mData->mUuid);
4514	if (!pMedium.isNull())
4515	{
4516	pMedium->i_addBackReference(mData->mUuid);
4517
4518	mediumLock.release();
4519	multiLock.release();
4520	i_addMediumToRegistry(pMedium);
4521	multiLock.acquire();
4522	mediumLock.acquire();
4523	}
4524
4525	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
4526	pAttach->i_updateMedium(pMedium);
4527	}
4528
4529	i_setModified(IsModified_Storage);
4530
4531	mediumLock.release();
4532	multiLock.release();
4533	HRESULT rc = i_onMediumChange(pAttach, aForce);
4534	multiLock.acquire();
4535	mediumLock.acquire();
4536
4537	/* On error roll back this change only. */
4538	if (FAILED(rc))
4539	{
4540	if (!pMedium.isNull())
4541	pMedium->i_removeBackReference(mData->mUuid);
4542	pAttach = i_findAttachment(*mMediumAttachments.data(),
4543	aName,
4544	aControllerPort,
4545	aDevice);
4546	/* If the attachment is gone in the meantime, bail out. */
4547	if (pAttach.isNull())
4548	return rc;
4549	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
4550	if (!oldmedium.isNull())
4551	oldmedium->i_addBackReference(mData->mUuid);
4552	pAttach->i_updateMedium(oldmedium);
4553	}
4554
4555	mediumLock.release();
4556	multiLock.release();
4557
4558	/* Save modified registries, but skip this machine as it's the caller's
4559	* job to save its settings like all other settings changes. */
4560	mParent->i_unmarkRegistryModified(i_getId());
4561	mParent->i_saveModifiedRegistries();
4562
4563	return rc;
4564	}
4565	HRESULT Machine::getMedium(const com::Utf8Str &aName,
4566	LONG aControllerPort,
4567	LONG aDevice,
4568	ComPtr<IMedium> &aMedium)
4569	{
4570	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d\n",
4571	aName.c_str(), aControllerPort, aDevice));
4572
4573	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4574
4575	aMedium = NULL;
4576
4577	ComObjPtr<MediumAttachment> pAttach = i_findAttachment(*mMediumAttachments.data(),
4578	aName,
4579	aControllerPort,
4580	aDevice);
4581	if (pAttach.isNull())
4582	return setError(VBOX_E_OBJECT_NOT_FOUND,
4583	tr("No storage device attached to device slot %d on port %d of controller '%s'"),
4584	aDevice, aControllerPort, aName.c_str());
4585
4586	aMedium = pAttach->i_getMedium();
4587
4588	return S_OK;
4589	}
4590
4591	HRESULT Machine::getSerialPort(ULONG aSlot, ComPtr<ISerialPort> &aPort)
4592	{
4593	if (aSlot < RT_ELEMENTS(mSerialPorts))
4594	{
4595	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4596	mSerialPorts[aSlot].queryInterfaceTo(aPort.asOutParam());
4597	return S_OK;
4598	}
4599	return setError(E_INVALIDARG, tr("Serial port slot %RU32 is out of bounds (max %zu)"), aSlot, RT_ELEMENTS(mSerialPorts));
4600	}
4601
4602	HRESULT Machine::getParallelPort(ULONG aSlot, ComPtr<IParallelPort> &aPort)
4603	{
4604	if (aSlot < RT_ELEMENTS(mParallelPorts))
4605	{
4606	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4607	mParallelPorts[aSlot].queryInterfaceTo(aPort.asOutParam());
4608	return S_OK;
4609	}
4610	return setError(E_INVALIDARG, tr("Parallel port slot %RU32 is out of bounds (max %zu)"), aSlot, RT_ELEMENTS(mParallelPorts));
4611	}
4612
4613
4614	HRESULT Machine::getNetworkAdapter(ULONG aSlot, ComPtr<INetworkAdapter> &aAdapter)
4615	{
4616	/* Do not assert if slot is out of range, just return the advertised
4617	status. testdriver/vbox.py triggers this in logVmInfo. */
4618	if (aSlot >= mNetworkAdapters.size())
4619	return setError(E_INVALIDARG,
4620	tr("No network adapter in slot %RU32 (total %RU32 adapters)"),
4621	aSlot, mNetworkAdapters.size());
4622
4623	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4624
4625	mNetworkAdapters[aSlot].queryInterfaceTo(aAdapter.asOutParam());
4626
4627	return S_OK;
4628	}
4629
4630	HRESULT Machine::getExtraDataKeys(std::vector<com::Utf8Str> &aKeys)
4631	{
4632	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4633
4634	aKeys.resize(mData->pMachineConfigFile->mapExtraDataItems.size());
4635	size_t i = 0;
4636	for (settings::StringsMap::const_iterator
4637	it = mData->pMachineConfigFile->mapExtraDataItems.begin();
4638	it != mData->pMachineConfigFile->mapExtraDataItems.end();
4639	++it, ++i)
4640	aKeys[i] = it->first;
4641
4642	return S_OK;
4643	}
4644
4645	/**
4646	* @note Locks this object for reading.
4647	*/
4648	HRESULT Machine::getExtraData(const com::Utf8Str &aKey,
4649	com::Utf8Str &aValue)
4650	{
4651	/* start with nothing found */
4652	aValue = "";
4653
4654	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4655
4656	settings::StringsMap::const_iterator it = mData->pMachineConfigFile->mapExtraDataItems.find(aKey);
4657	if (it != mData->pMachineConfigFile->mapExtraDataItems.end())
4658	// found:
4659	aValue = it->second; // source is a Utf8Str
4660
4661	/* return the result to caller (may be empty) */
4662	return S_OK;
4663	}
4664
4665	/**
4666	* @note Locks mParent for writing + this object for writing.
4667	*/
4668	HRESULT Machine::setExtraData(const com::Utf8Str &aKey, const com::Utf8Str &aValue)
4669	{
4670	/* Because control characters in aKey have caused problems in the settings
4671	* they are rejected unless the key should be deleted. */
4672	if (!aValue.isEmpty())
4673	{
4674	for (size_t i = 0; i < aKey.length(); ++i)
4675	{
4676	char ch = aKey[i];
4677	if (RTLocCIsCntrl(ch))
4678	return E_INVALIDARG;
4679	}
4680	}
4681
4682	Utf8Str strOldValue; // empty
4683
4684	// locking note: we only hold the read lock briefly to look up the old value,
4685	// then release it and call the onExtraCanChange callbacks. There is a small
4686	// chance of a race insofar as the callback might be called twice if two callers
4687	// change the same key at the same time, but that's a much better solution
4688	// than the deadlock we had here before. The actual changing of the extradata
4689	// is then performed under the write lock and race-free.
4690
4691	// look up the old value first; if nothing has changed then we need not do anything
4692	{
4693	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); // hold read lock only while looking up
4694
4695	// For snapshots don't even think about allowing changes, extradata
4696	// is global for a machine, so there is nothing snapshot specific.
4697	if (i_isSnapshotMachine())
4698	return setError(VBOX_E_INVALID_VM_STATE,
4699	tr("Cannot set extradata for a snapshot"));
4700
4701	// check if the right IMachine instance is used
4702	if (mData->mRegistered && !i_isSessionMachine())
4703	return setError(VBOX_E_INVALID_VM_STATE,
4704	tr("Cannot set extradata for an immutable machine"));
4705
4706	settings::StringsMap::const_iterator it = mData->pMachineConfigFile->mapExtraDataItems.find(aKey);
4707	if (it != mData->pMachineConfigFile->mapExtraDataItems.end())
4708	strOldValue = it->second;
4709	}
4710
4711	bool fChanged;
4712	if ((fChanged = (strOldValue != aValue)))
4713	{
4714	// ask for permission from all listeners outside the locks;
4715	// i_onExtraDataCanChange() only briefly requests the VirtualBox
4716	// lock to copy the list of callbacks to invoke
4717	Bstr bstrError;
4718	if (!mParent->i_onExtraDataCanChange(mData->mUuid, aKey, aValue, bstrError))
4719	{
4720	const char *sep = bstrError.isEmpty() ? "" : ": ";
4721	Log1WarningFunc(("Someone vetoed! Change refused%s%ls\n", sep, bstrError.raw()));
4722	return setError(E_ACCESSDENIED,
4723	tr("Could not set extra data because someone refused the requested change of '%s' to '%s'%s%ls"),
4724	aKey.c_str(),
4725	aValue.c_str(),
4726	sep,
4727	bstrError.raw());
4728	}
4729
4730	// data is changing and change not vetoed: then write it out under the lock
4731	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4732
4733	if (aValue.isEmpty())
4734	mData->pMachineConfigFile->mapExtraDataItems.erase(aKey);
4735	else
4736	mData->pMachineConfigFile->mapExtraDataItems[aKey] = aValue;
4737	// creates a new key if needed
4738
4739	bool fNeedsGlobalSaveSettings = false;
4740	// This saving of settings is tricky: there is no "old state" for the
4741	// extradata items at all (unlike all other settings), so the old/new
4742	// settings comparison would give a wrong result!
4743	i_saveSettings(&fNeedsGlobalSaveSettings, SaveS_Force);
4744
4745	if (fNeedsGlobalSaveSettings)
4746	{
4747	// save the global settings; for that we should hold only the VirtualBox lock
4748	alock.release();
4749	AutoWriteLock vboxlock(mParent COMMA_LOCKVAL_SRC_POS);
4750	mParent->i_saveSettings();
4751	}
4752	}
4753
4754	// fire notification outside the lock
4755	if (fChanged)
4756	mParent->i_onExtraDataChanged(mData->mUuid, aKey, aValue);
4757
4758	return S_OK;
4759	}
4760
4761	HRESULT Machine::setSettingsFilePath(const com::Utf8Str &aSettingsFilePath, ComPtr<IProgress> &aProgress)
4762	{
4763	aProgress = NULL;
4764	NOREF(aSettingsFilePath);
4765	ReturnComNotImplemented();
4766	}
4767
4768	HRESULT Machine::saveSettings()
4769	{
4770	AutoWriteLock mlock(this COMMA_LOCKVAL_SRC_POS);
4771
4772	HRESULT rc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
4773	if (FAILED(rc)) return rc;
4774
4775	/* the settings file path may never be null */
4776	ComAssertRet(!mData->m_strConfigFileFull.isEmpty(), E_FAIL);
4777
4778	/* save all VM data excluding snapshots */
4779	bool fNeedsGlobalSaveSettings = false;
4780	rc = i_saveSettings(&fNeedsGlobalSaveSettings);
4781	mlock.release();
4782
4783	if (SUCCEEDED(rc) && fNeedsGlobalSaveSettings)
4784	{
4785	// save the global settings; for that we should hold only the VirtualBox lock
4786	AutoWriteLock vlock(mParent COMMA_LOCKVAL_SRC_POS);
4787	rc = mParent->i_saveSettings();
4788	}
4789
4790	return rc;
4791	}
4792
4793
4794	HRESULT Machine::discardSettings()
4795	{
4796	/*
4797	* We need to take the machine list lock here as well as the machine one
4798	* or we'll get into trouble should any media stuff require rolling back.
4799	*
4800	* Details:
4801	*
4802	* 11:06:01.934284 00:00:05.805182 ALIEN-1 Wrong locking order! [uId=00007ff6853f6c34 thrd=ALIEN-1]
4803	* 11:06:01.934284 00:00:05.805182 ALIEN-1 Lock: s 000000000259ef40 RTCritSectRw-3 srec=000000000259f150 cls=4-LISTOFMACHINES/any [s]
4804	* 11:06:01.934284 00:00:05.805182 ALIEN-1 Other lock: 00000000025ec710 RTCritSectRw-158 own=ALIEN-1 r=1 cls=5-MACHINEOBJECT/any pos={MachineImpl.cpp(5085) Machine::discardSettings 00007ff6853f6ce4} [x]
4805	* 11:06:01.934284 00:00:05.805182 ALIEN-1 My class: class=0000000000d5eb10 4-LISTOFMACHINES created={AutoLock.cpp(98) util::InitAutoLockSystem 00007ff6853f571f} sub-class=any
4806	* 11:06:01.934284 00:00:05.805182 ALIEN-1 My class: Prior: #00: 2-VIRTUALBOXOBJECT, manually , 4 lookups
4807	* 11:06:01.934284 00:00:05.805182 ALIEN-1 My class: #01: 3-HOSTOBJECT, manually , 0 lookups
4808	* 11:06:01.934284 00:00:05.805182 ALIEN-1 My class: Hash Stats: 3 hits, 1 misses
4809	* 11:06:01.934284 00:00:05.805182 ALIEN-1 Other class: class=0000000000d5ecd0 5-MACHINEOBJECT created={AutoLock.cpp(98) util::InitAutoLockSystem 00007ff6853f571f} sub-class=any
4810	* 11:06:01.934284 00:00:05.805182 ALIEN-1 Other class: Prior: #00: 2-VIRTUALBOXOBJECT, manually , 2 lookups
4811	* 11:06:01.934284 00:00:05.805182 ALIEN-1 Other class: #01: 3-HOSTOBJECT, manually , 6 lookups
4812	* 11:06:01.934284 00:00:05.805182 ALIEN-1 Other class: #02: 4-LISTOFMACHINES, manually , 5 lookups
4813	* 11:06:01.934284 00:00:05.805182 ALIEN-1 Other class: Hash Stats: 10 hits, 3 misses
4814	* 11:06:01.934284 00:00:05.805182 ALIEN-1 ---- start of lock stack for 000000000259d2d0 ALIEN-1 - 2 entries ----
4815	* 11:06:01.934284 00:00:05.805182 ALIEN-1 #00: 00000000025ec710 RTCritSectRw-158 own=ALIEN-1 r=2 cls=5-MACHINEOBJECT/any pos={MachineImpl.cpp(11705) Machine::i_rollback 00007ff6853f6ce4} [x/r]
4816	* 11:06:01.934284 00:00:05.805182 ALIEN-1 #01: 00000000025ec710 RTCritSectRw-158 own=ALIEN-1 r=1 cls=5-MACHINEOBJECT/any pos={MachineImpl.cpp(5085) Machine::discardSettings 00007ff6853f6ce4} [x] (*)
4817	* 11:06:01.934284 00:00:05.805182 ALIEN-1 ---- end of lock stack ----
4818	* 0:005> k
4819	* # Child-SP RetAddr Call Site
4820	* 00 00000000`0287bc90 00007ffc`8c0bc8dc VBoxRT!rtLockValComplainPanic+0x23 [e:\vbox\svn\trunk\src\vbox\runtime\common\misc\lockvalidator.cpp @ 807]
4821	* 01 00000000`0287bcc0 00007ffc`8c0bc083 VBoxRT!rtLockValidatorStackWrongOrder+0xac [e:\vbox\svn\trunk\src\vbox\runtime\common\misc\lockvalidator.cpp @ 2149]
4822	* 02 00000000`0287bd10 00007ffc`8c0bbfc3 VBoxRT!rtLockValidatorStackCheckLockingOrder2+0x93 [e:\vbox\svn\trunk\src\vbox\runtime\common\misc\lockvalidator.cpp @ 2227]
4823	* 03 00000000`0287bdd0 00007ffc`8c0bf3c0 VBoxRT!rtLockValidatorStackCheckLockingOrder+0x523 [e:\vbox\svn\trunk\src\vbox\runtime\common\misc\lockvalidator.cpp @ 2406]
4824	* 04 00000000`0287be40 00007ffc`8c180de4 VBoxRT!RTLockValidatorRecSharedCheckOrder+0x210 [e:\vbox\svn\trunk\src\vbox\runtime\common\misc\lockvalidator.cpp @ 3607]
4825	* 05 00000000`0287be90 00007ffc`8c1819b8 VBoxRT!rtCritSectRwEnterShared+0x1a4 [e:\vbox\svn\trunk\src\vbox\runtime\generic\critsectrw-generic.cpp @ 222]
4826	* 06 00000000`0287bf60 00007ff6`853f5e78 VBoxRT!RTCritSectRwEnterSharedDebug+0x58 [e:\vbox\svn\trunk\src\vbox\runtime\generic\critsectrw-generic.cpp @ 428]
4827	* 07 00000000`0287bfb0 00007ff6`853f6c34 VBoxSVC!util::RWLockHandle::lockRead+0x58 [e:\vbox\svn\trunk\src\vbox\main\glue\autolock.cpp @ 245]
4828	* 08 00000000`0287c000 00007ff6`853f68a1 VBoxSVC!util::AutoReadLock::callLockImpl+0x64 [e:\vbox\svn\trunk\src\vbox\main\glue\autolock.cpp @ 552]
4829	* 09 00000000`0287c040 00007ff6`853f6a59 VBoxSVC!util::AutoLockBase::callLockOnAllHandles+0xa1 [e:\vbox\svn\trunk\src\vbox\main\glue\autolock.cpp @ 455]
4830	* 0a 00000000`0287c0a0 00007ff6`85038fdb VBoxSVC!util::AutoLockBase::acquire+0x89 [e:\vbox\svn\trunk\src\vbox\main\glue\autolock.cpp @ 500]
4831	* 0b 00000000`0287c0d0 00007ff6`85216dcf VBoxSVC!util::AutoReadLock::AutoReadLock+0x7b [e:\vbox\svn\trunk\include\vbox\com\autolock.h @ 370]
4832	* 0c 00000000`0287c120 00007ff6`8521cf08 VBoxSVC!VirtualBox::i_findMachine+0x14f [e:\vbox\svn\trunk\src\vbox\main\src-server\virtualboximpl.cpp @ 3216]
4833	* 0d 00000000`0287c260 00007ff6`8517a4b0 VBoxSVC!VirtualBox::i_markRegistryModified+0xa8 [e:\vbox\svn\trunk\src\vbox\main\src-server\virtualboximpl.cpp @ 4697]
4834	* 0e 00000000`0287c2f0 00007ff6`8517fac0 VBoxSVC!Medium::i_markRegistriesModified+0x170 [e:\vbox\svn\trunk\src\vbox\main\src-server\mediumimpl.cpp @ 4056]
4835	* 0f 00000000`0287c500 00007ff6`8511ca9d VBoxSVC!Medium::i_deleteStorage+0xb90 [e:\vbox\svn\trunk\src\vbox\main\src-server\mediumimpl.cpp @ 5114]
4836	* 10 00000000`0287cad0 00007ff6`8511ef0e VBoxSVC!Machine::i_deleteImplicitDiffs+0x11ed [e:\vbox\svn\trunk\src\vbox\main\src-server\machineimpl.cpp @ 11117]
4837	* 11 00000000`0287d2e0 00007ff6`8511f896 VBoxSVC!Machine::i_rollbackMedia+0x42e [e:\vbox\svn\trunk\src\vbox\main\src-server\machineimpl.cpp @ 11657]
4838	* 12 00000000`0287d3c0 00007ff6`850fd17a VBoxSVC!Machine::i_rollback+0x6a6 [e:\vbox\svn\trunk\src\vbox\main\src-server\machineimpl.cpp @ 11786]
4839	* 13 00000000`0287d710 00007ff6`85342dbe VBoxSVC!Machine::discardSettings+0x9a [e:\vbox\svn\trunk\src\vbox\main\src-server\machineimpl.cpp @ 5096]
4840	* 14 00000000`0287d790 00007ffc`c06813ff VBoxSVC!MachineWrap::DiscardSettings+0x16e [e:\vbox\svn\trunk\out\win.amd64\debug\obj\vboxapiwrap\machinewrap.cpp @ 9171]
4841	*
4842	*/
4843	AutoReadLock alockMachines(mParent->i_getMachinesListLockHandle() COMMA_LOCKVAL_SRC_POS);
4844	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4845
4846	HRESULT rc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
4847	if (FAILED(rc)) return rc;
4848
4849	/*
4850	* during this rollback, the session will be notified if data has
4851	* been actually changed
4852	*/
4853	i_rollback(true /* aNotify */);
4854
4855	return S_OK;
4856	}
4857
4858	/** @note Locks objects! */
4859	HRESULT Machine::unregister(AutoCaller &autoCaller,
4860	CleanupMode_T aCleanupMode,
4861	std::vector<ComPtr<IMedium> > &aMedia)
4862	{
4863	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4864
4865	Guid id(i_getId());
4866
4867	if (mData->mSession.mState != SessionState_Unlocked)
4868	return setError(VBOX_E_INVALID_OBJECT_STATE,
4869	tr("Cannot unregister the machine '%s' while it is locked"),
4870	mUserData->s.strName.c_str());
4871
4872	// wait for state dependents to drop to zero
4873	i_ensureNoStateDependencies();
4874
4875	if (!mData->mAccessible)
4876	{
4877	// inaccessible machines can only be unregistered; uninitialize ourselves
4878	// here because currently there may be no unregistered that are inaccessible
4879	// (this state combination is not supported). Note releasing the caller and
4880	// leaving the lock before calling uninit()
4881	alock.release();
4882	autoCaller.release();
4883
4884	uninit();
4885
4886	mParent->i_unregisterMachine(this, id);
4887	// calls VirtualBox::i_saveSettings()
4888
4889	return S_OK;
4890	}
4891
4892	HRESULT rc = S_OK;
4893	mData->llFilesToDelete.clear();
4894
4895	if (!mSSData->strStateFilePath.isEmpty())
4896	mData->llFilesToDelete.push_back(mSSData->strStateFilePath);
4897
4898	Utf8Str strNVRAMFile = mBIOSSettings->i_getNonVolatileStorageFile();
4899	if (!strNVRAMFile.isEmpty() && RTFileExists(strNVRAMFile.c_str()))
4900	mData->llFilesToDelete.push_back(strNVRAMFile);
4901
4902	// This list collects the medium objects from all medium attachments
4903	// which we will detach from the machine and its snapshots, in a specific
4904	// order which allows for closing all media without getting "media in use"
4905	// errors, simply by going through the list from the front to the back:
4906	// 1) first media from machine attachments (these have the "leaf" attachments with snapshots
4907	// and must be closed before the parent media from the snapshots, or closing the parents
4908	// will fail because they still have children);
4909	// 2) media from the youngest snapshots followed by those from the parent snapshots until
4910	// the root ("first") snapshot of the machine.
4911	MediaList llMedia;
4912
4913	if ( !mMediumAttachments.isNull() // can be NULL if machine is inaccessible
4914	&& mMediumAttachments->size()
4915	)
4916	{
4917	// we have media attachments: detach them all and add the Medium objects to our list
4918	i_detachAllMedia(alock, NULL /* pSnapshot */, aCleanupMode, llMedia);
4919	}
4920
4921	if (mData->mFirstSnapshot)
4922	{
4923	// add the media from the medium attachments of the snapshots to llMedia
4924	// as well, after the "main" machine media; Snapshot::uninitRecursively()
4925	// calls Machine::detachAllMedia() for the snapshot machine, recursing
4926	// into the children first
4927
4928	// Snapshot::beginDeletingSnapshot() asserts if the machine state is not this
4929	MachineState_T oldState = mData->mMachineState;
4930	mData->mMachineState = MachineState_DeletingSnapshot;
4931
4932	// make a copy of the first snapshot reference so the refcount does not
4933	// drop to 0 in beginDeletingSnapshot, which sets pFirstSnapshot to 0
4934	// (would hang due to the AutoCaller voodoo)
4935	ComObjPtr<Snapshot> pFirstSnapshot = mData->mFirstSnapshot;
4936
4937	// GO!
4938	pFirstSnapshot->i_uninitRecursively(alock, aCleanupMode, llMedia, mData->llFilesToDelete);
4939
4940	mData->mMachineState = oldState;
4941	}
4942
4943	if (FAILED(rc))
4944	{
4945	i_rollbackMedia();
4946	return rc;
4947	}
4948
4949	// commit all the media changes made above
4950	i_commitMedia();
4951
4952	mData->mRegistered = false;
4953
4954	// machine lock no longer needed
4955	alock.release();
4956
4957	/* Make sure that the settings of the current VM are not saved, because
4958	* they are rather crippled at this point to meet the cleanup expectations
4959	* and there's no point destroying the VM config on disk just because. */
4960	mParent->i_unmarkRegistryModified(id);
4961
4962	// return media to caller
4963	aMedia.resize(llMedia.size());
4964	size_t i = 0;
4965	for (MediaList::const_iterator
4966	it = llMedia.begin();
4967	it != llMedia.end();
4968	++it, ++i)
4969	(*it).queryInterfaceTo(aMedia[i].asOutParam());
4970
4971	mParent->i_unregisterMachine(this, id);
4972	// calls VirtualBox::i_saveSettings() and VirtualBox::saveModifiedRegistries()
4973
4974	return S_OK;
4975	}
4976
4977	/**
4978	* Task record for deleting a machine config.
4979	*/
4980	class Machine::DeleteConfigTask
4981	: public Machine::Task
4982	{
4983	public:
4984	DeleteConfigTask(Machine *m,
4985	Progress *p,
4986	const Utf8Str &t,
4987	const RTCList<ComPtr<IMedium> > &llMediums,
4988	const StringsList &llFilesToDelete)
4989	: Task(m, p, t),
4990	m_llMediums(llMediums),
4991	m_llFilesToDelete(llFilesToDelete)
4992	{}
4993
4994	private:
4995	void handler()
4996	{
4997	try
4998	{
4999	m_pMachine->i_deleteConfigHandler(*this);
5000	}
5001	catch (...)
5002	{
5003	LogRel(("Some exception in the function Machine::i_deleteConfigHandler()\n"));
5004	}
5005	}
5006
5007	RTCList<ComPtr<IMedium> > m_llMediums;
5008	StringsList m_llFilesToDelete;
5009
5010	friend void Machine::i_deleteConfigHandler(DeleteConfigTask &task);
5011	};
5012
5013	/**
5014	* Task thread implementation for SessionMachine::DeleteConfig(), called from
5015	* SessionMachine::taskHandler().
5016	*
5017	* @note Locks this object for writing.
5018	*
5019	* @param task
5020	* @return
5021	*/
5022	void Machine::i_deleteConfigHandler(DeleteConfigTask &task)
5023	{
5024	LogFlowThisFuncEnter();
5025
5026	AutoCaller autoCaller(this);
5027	LogFlowThisFunc(("state=%d\n", getObjectState().getState()));
5028	if (FAILED(autoCaller.rc()))
5029	{
5030	/* we might have been uninitialized because the session was accidentally
5031	* closed by the client, so don't assert */
5032	HRESULT rc = setError(E_FAIL,
5033	tr("The session has been accidentally closed"));
5034	task.m_pProgress->i_notifyComplete(rc);
5035	LogFlowThisFuncLeave();
5036	return;
5037	}
5038
5039	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5040
5041	HRESULT rc = S_OK;
5042
5043	try
5044	{
5045	ULONG uLogHistoryCount = 3;
5046	ComPtr<ISystemProperties> systemProperties;
5047	rc = mParent->COMGETTER(SystemProperties)(systemProperties.asOutParam());
5048	if (FAILED(rc)) throw rc;
5049
5050	if (!systemProperties.isNull())
5051	{
5052	rc = systemProperties->COMGETTER(LogHistoryCount)(&uLogHistoryCount);
5053	if (FAILED(rc)) throw rc;
5054	}
5055
5056	MachineState_T oldState = mData->mMachineState;
5057	i_setMachineState(MachineState_SettingUp);
5058	alock.release();
5059	for (size_t i = 0; i < task.m_llMediums.size(); ++i)
5060	{
5061	ComObjPtr<Medium> pMedium = (Medium)(IMedium)(task.m_llMediums.at(i));
5062	{
5063	AutoCaller mac(pMedium);
5064	if (FAILED(mac.rc())) throw mac.rc();
5065	Utf8Str strLocation = pMedium->i_getLocationFull();
5066	LogFunc(("Deleting file %s\n", strLocation.c_str()));
5067	rc = task.m_pProgress->SetNextOperation(BstrFmt(tr("Deleting '%s'"), strLocation.c_str()).raw(), 1);
5068	if (FAILED(rc)) throw rc;
5069	}
5070	if (pMedium->i_isMediumFormatFile())
5071	{
5072	ComPtr<IProgress> pProgress2;
5073	rc = pMedium->DeleteStorage(pProgress2.asOutParam());
5074	if (FAILED(rc)) throw rc;
5075	rc = task.m_pProgress->WaitForOtherProgressCompletion(pProgress2, 0 /* indefinite wait */);
5076	if (FAILED(rc)) throw rc;
5077	}
5078
5079	/* Close the medium, deliberately without checking the return
5080	* code, and without leaving any trace in the error info, as
5081	* a failure here is a very minor issue, which shouldn't happen
5082	* as above we even managed to delete the medium. */
5083	{
5084	ErrorInfoKeeper eik;
5085	pMedium->Close();
5086	}
5087	}
5088	i_setMachineState(oldState);
5089	alock.acquire();
5090
5091	// delete the files pushed on the task list by Machine::Delete()
5092	// (this includes saved states of the machine and snapshots and
5093	// medium storage files from the IMedium list passed in, and the
5094	// machine XML file)
5095	for (StringsList::const_iterator
5096	it = task.m_llFilesToDelete.begin();
5097	it != task.m_llFilesToDelete.end();
5098	++it)
5099	{
5100	const Utf8Str &strFile = *it;
5101	LogFunc(("Deleting file %s\n", strFile.c_str()));
5102	rc = task.m_pProgress->SetNextOperation(BstrFmt(tr("Deleting '%s'"), it->c_str()).raw(), 1);
5103	if (FAILED(rc)) throw rc;
5104
5105	int vrc = RTFileDelete(strFile.c_str());
5106	if (RT_FAILURE(vrc))
5107	throw setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
5108	tr("Could not delete file '%s' (%Rrc)"), strFile.c_str(), vrc);
5109	}
5110
5111	rc = task.m_pProgress->SetNextOperation(Bstr(tr("Cleaning up machine directory")).raw(), 1);
5112	if (FAILED(rc)) throw rc;
5113
5114	/* delete the settings only when the file actually exists */
5115	if (mData->pMachineConfigFile->fileExists())
5116	{
5117	/* Delete any backup or uncommitted XML files. Ignore failures.
5118	See the fSafe parameter of xml::XmlFileWriter::write for details. */
5119	/** @todo Find a way to avoid referring directly to iprt/xml.h here. */
5120	Utf8StrFmt otherXml("%s%s", mData->m_strConfigFileFull.c_str(), xml::XmlFileWriter::s_pszTmpSuff);
5121	RTFileDelete(otherXml.c_str());
5122	otherXml.printf("%s%s", mData->m_strConfigFileFull.c_str(), xml::XmlFileWriter::s_pszPrevSuff);
5123	RTFileDelete(otherXml.c_str());
5124
5125	/* delete the Logs folder, nothing important should be left
5126	* there (we don't check for errors because the user might have
5127	* some private files there that we don't want to delete) */
5128	Utf8Str logFolder;
5129	getLogFolder(logFolder);
5130	Assert(logFolder.length());
5131	if (RTDirExists(logFolder.c_str()))
5132	{
5133	/* Delete all VBox.log[.N] files from the Logs folder
5134	* (this must be in sync with the rotation logic in
5135	* Console::powerUpThread()). Also, delete the VBox.png[.N]
5136	* files that may have been created by the GUI. */
5137	Utf8StrFmt log("%s%cVBox.log", logFolder.c_str(), RTPATH_DELIMITER);
5138	RTFileDelete(log.c_str());
5139	log.printf("%s%cVBox.png", logFolder.c_str(), RTPATH_DELIMITER);
5140	RTFileDelete(log.c_str());
5141	for (ULONG i = uLogHistoryCount; i > 0; i--)
5142	{
5143	log.printf("%s%cVBox.log.%u", logFolder.c_str(), RTPATH_DELIMITER, i);
5144	RTFileDelete(log.c_str());
5145	log.printf("%s%cVBox.png.%u", logFolder.c_str(), RTPATH_DELIMITER, i);
5146	RTFileDelete(log.c_str());
5147	}
5148	#if defined(RT_OS_WINDOWS)
5149	log.printf("%s%cVBoxStartup.log", logFolder.c_str(), RTPATH_DELIMITER);
5150	RTFileDelete(log.c_str());
5151	log.printf("%s%cVBoxHardening.log", logFolder.c_str(), RTPATH_DELIMITER);
5152	RTFileDelete(log.c_str());
5153	#endif
5154
5155	RTDirRemove(logFolder.c_str());
5156	}
5157
5158	/* delete the Snapshots folder, nothing important should be left
5159	* there (we don't check for errors because the user might have
5160	* some private files there that we don't want to delete) */
5161	Utf8Str strFullSnapshotFolder;
5162	i_calculateFullPath(mUserData->s.strSnapshotFolder, strFullSnapshotFolder);
5163	Assert(!strFullSnapshotFolder.isEmpty());
5164	if (RTDirExists(strFullSnapshotFolder.c_str()))
5165	RTDirRemove(strFullSnapshotFolder.c_str());
5166
5167	// delete the directory that contains the settings file, but only
5168	// if it matches the VM name
5169	Utf8Str settingsDir;
5170	if (i_isInOwnDir(&settingsDir))
5171	RTDirRemove(settingsDir.c_str());
5172	}
5173
5174	alock.release();
5175
5176	mParent->i_saveModifiedRegistries();
5177	}
5178	catch (HRESULT aRC) { rc = aRC; }
5179
5180	task.m_pProgress->i_notifyComplete(rc);
5181
5182	LogFlowThisFuncLeave();
5183	}
5184
5185	HRESULT Machine::deleteConfig(const std::vector<ComPtr<IMedium> > &aMedia, ComPtr<IProgress> &aProgress)
5186	{
5187	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5188
5189	HRESULT rc = i_checkStateDependency(MutableStateDep);
5190	if (FAILED(rc)) return rc;
5191
5192	if (mData->mRegistered)
5193	return setError(VBOX_E_INVALID_VM_STATE,
5194	tr("Cannot delete settings of a registered machine"));
5195
5196	// collect files to delete
5197	StringsList llFilesToDelete(mData->llFilesToDelete); // saved states and NVRAM files pushed here by Unregister()
5198	// machine config file
5199	if (mData->pMachineConfigFile->fileExists())
5200	llFilesToDelete.push_back(mData->m_strConfigFileFull);
5201	// backup of machine config file
5202	Utf8Str strTmp(mData->m_strConfigFileFull);
5203	strTmp.append("-prev");
5204	if (RTFileExists(strTmp.c_str()))
5205	llFilesToDelete.push_back(strTmp);
5206
5207	RTCList<ComPtr<IMedium> > llMediums;
5208	for (size_t i = 0; i < aMedia.size(); ++i)
5209	{
5210	IMedium *pIMedium(aMedia[i]);
5211	ComObjPtr<Medium> pMedium = static_cast<Medium*>(pIMedium);
5212	if (pMedium.isNull())
5213	return setError(E_INVALIDARG, "The given medium pointer with index %d is invalid", i);
5214	SafeArray<BSTR> ids;
5215	rc = pMedium->COMGETTER(MachineIds)(ComSafeArrayAsOutParam(ids));
5216	if (FAILED(rc)) return rc;
5217	/* At this point the medium should not have any back references
5218	* anymore. If it has it is attached to another VM and must not
5219	* deleted. */
5220	if (ids.size() < 1)
5221	llMediums.append(pMedium);
5222	}
5223
5224	ComObjPtr<Progress> pProgress;
5225	pProgress.createObject();
5226	rc = pProgress->init(i_getVirtualBox(),
5227	static_cast<IMachine>(this) / aInitiator */,
5228	tr("Deleting files"),
5229	true /* fCancellable */,
5230	(ULONG)(1 + llMediums.size() + llFilesToDelete.size() + 1), // cOperations
5231	tr("Collecting file inventory"));
5232	if (FAILED(rc))
5233	return rc;
5234
5235	/* create and start the task on a separate thread (note that it will not
5236	* start working until we release alock) */
5237	DeleteConfigTask *pTask = new DeleteConfigTask(this, pProgress, "DeleteVM", llMediums, llFilesToDelete);
5238	rc = pTask->createThread();
5239	pTask = NULL;
5240	if (FAILED(rc))
5241	return rc;
5242
5243	pProgress.queryInterfaceTo(aProgress.asOutParam());
5244
5245	LogFlowFuncLeave();
5246
5247	return S_OK;
5248	}
5249
5250	HRESULT Machine::findSnapshot(const com::Utf8Str &aNameOrId, ComPtr<ISnapshot> &aSnapshot)
5251	{
5252	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5253
5254	ComObjPtr<Snapshot> pSnapshot;
5255	HRESULT rc;
5256
5257	if (aNameOrId.isEmpty())
5258	// null case (caller wants root snapshot): i_findSnapshotById() handles this
5259	rc = i_findSnapshotById(Guid(), pSnapshot, true /* aSetError */);
5260	else
5261	{
5262	Guid uuid(aNameOrId);
5263	if (uuid.isValid())
5264	rc = i_findSnapshotById(uuid, pSnapshot, true /* aSetError */);
5265	else
5266	rc = i_findSnapshotByName(aNameOrId, pSnapshot, true /* aSetError */);
5267	}
5268	pSnapshot.queryInterfaceTo(aSnapshot.asOutParam());
5269
5270	return rc;
5271	}
5272
5273	HRESULT Machine::createSharedFolder(const com::Utf8Str &aName, const com::Utf8Str &aHostPath, BOOL aWritable,
5274	BOOL aAutomount, const com::Utf8Str &aAutoMountPoint)
5275	{
5276	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5277
5278	HRESULT rc = i_checkStateDependency(MutableOrRunningStateDep);
5279	if (FAILED(rc)) return rc;
5280
5281	ComObjPtr<SharedFolder> sharedFolder;
5282	rc = i_findSharedFolder(aName, sharedFolder, false /* aSetError */);
5283	if (SUCCEEDED(rc))
5284	return setError(VBOX_E_OBJECT_IN_USE,
5285	tr("Shared folder named '%s' already exists"),
5286	aName.c_str());
5287
5288	sharedFolder.createObject();
5289	rc = sharedFolder->init(i_getMachine(),
5290	aName,
5291	aHostPath,
5292	!!aWritable,
5293	!!aAutomount,
5294	aAutoMountPoint,
5295	true /* fFailOnError */);
5296	if (FAILED(rc)) return rc;
5297
5298	i_setModified(IsModified_SharedFolders);
5299	mHWData.backup();
5300	mHWData->mSharedFolders.push_back(sharedFolder);
5301
5302	/* inform the direct session if any */
5303	alock.release();
5304	i_onSharedFolderChange();
5305
5306	return S_OK;
5307	}
5308
5309	HRESULT Machine::removeSharedFolder(const com::Utf8Str &aName)
5310	{
5311	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5312
5313	HRESULT rc = i_checkStateDependency(MutableOrRunningStateDep);
5314	if (FAILED(rc)) return rc;
5315
5316	ComObjPtr<SharedFolder> sharedFolder;
5317	rc = i_findSharedFolder(aName, sharedFolder, true /* aSetError */);
5318	if (FAILED(rc)) return rc;
5319
5320	i_setModified(IsModified_SharedFolders);
5321	mHWData.backup();
5322	mHWData->mSharedFolders.remove(sharedFolder);
5323
5324	/* inform the direct session if any */
5325	alock.release();
5326	i_onSharedFolderChange();
5327
5328	return S_OK;
5329	}
5330
5331	HRESULT Machine::canShowConsoleWindow(BOOL *aCanShow)
5332	{
5333	/* start with No */
5334	*aCanShow = FALSE;
5335
5336	ComPtr<IInternalSessionControl> directControl;
5337	{
5338	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5339
5340	if (mData->mSession.mState != SessionState_Locked)
5341	return setError(VBOX_E_INVALID_VM_STATE,
5342	tr("Machine is not locked for session (session state: %s)"),
5343	Global::stringifySessionState(mData->mSession.mState));
5344
5345	if (mData->mSession.mLockType == LockType_VM)
5346	directControl = mData->mSession.mDirectControl;
5347	}
5348
5349	/* ignore calls made after #OnSessionEnd() is called */
5350	if (!directControl)
5351	return S_OK;
5352
5353	LONG64 dummy;
5354	return directControl->OnShowWindow(TRUE /* aCheck */, aCanShow, &dummy);
5355	}
5356
5357	HRESULT Machine::showConsoleWindow(LONG64 *aWinId)
5358	{
5359	ComPtr<IInternalSessionControl> directControl;
5360	{
5361	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5362
5363	if (mData->mSession.mState != SessionState_Locked)
5364	return setError(E_FAIL,
5365	tr("Machine is not locked for session (session state: %s)"),
5366	Global::stringifySessionState(mData->mSession.mState));
5367
5368	if (mData->mSession.mLockType == LockType_VM)
5369	directControl = mData->mSession.mDirectControl;
5370	}
5371
5372	/* ignore calls made after #OnSessionEnd() is called */
5373	if (!directControl)
5374	return S_OK;
5375
5376	BOOL dummy;
5377	return directControl->OnShowWindow(FALSE /* aCheck */, &dummy, aWinId);
5378	}
5379
5380	#ifdef VBOX_WITH_GUEST_PROPS
5381	/**
5382	* Look up a guest property in VBoxSVC's internal structures.
5383	*/
5384	HRESULT Machine::i_getGuestPropertyFromService(const com::Utf8Str &aName,
5385	com::Utf8Str &aValue,
5386	LONG64 *aTimestamp,
5387	com::Utf8Str &aFlags) const
5388	{
5389	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5390
5391	HWData::GuestPropertyMap::const_iterator it = mHWData->mGuestProperties.find(aName);
5392	if (it != mHWData->mGuestProperties.end())
5393	{
5394	char szFlags[GUEST_PROP_MAX_FLAGS_LEN + 1];
5395	aValue = it->second.strValue;
5396	*aTimestamp = it->second.mTimestamp;
5397	GuestPropWriteFlags(it->second.mFlags, szFlags);
5398	aFlags = Utf8Str(szFlags);
5399	}
5400
5401	return S_OK;
5402	}
5403
5404	/**
5405	* Query the VM that a guest property belongs to for the property.
5406	* @returns E_ACCESSDENIED if the VM process is not available or not
5407	* currently handling queries and the lookup should then be done in
5408	* VBoxSVC.
5409	*/
5410	HRESULT Machine::i_getGuestPropertyFromVM(const com::Utf8Str &aName,
5411	com::Utf8Str &aValue,
5412	LONG64 *aTimestamp,
5413	com::Utf8Str &aFlags) const
5414	{
5415	HRESULT rc = S_OK;
5416	Bstr bstrValue;
5417	Bstr bstrFlags;
5418
5419	ComPtr<IInternalSessionControl> directControl;
5420	{
5421	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5422	if (mData->mSession.mLockType == LockType_VM)
5423	directControl = mData->mSession.mDirectControl;
5424	}
5425
5426	/* ignore calls made after #OnSessionEnd() is called */
5427	if (!directControl)
5428	rc = E_ACCESSDENIED;
5429	else
5430	rc = directControl->AccessGuestProperty(Bstr(aName).raw(), Bstr::Empty.raw(), Bstr::Empty.raw(),
5431	0 /* accessMode */,
5432	bstrValue.asOutParam(), aTimestamp, bstrFlags.asOutParam());
5433
5434	aValue = bstrValue;
5435	aFlags = bstrFlags;
5436
5437	return rc;
5438	}
5439	#endif // VBOX_WITH_GUEST_PROPS
5440
5441	HRESULT Machine::getGuestProperty(const com::Utf8Str &aName,
5442	com::Utf8Str &aValue,
5443	LONG64 *aTimestamp,
5444	com::Utf8Str &aFlags)
5445	{
5446	#ifndef VBOX_WITH_GUEST_PROPS
5447	ReturnComNotImplemented();
5448	#else // VBOX_WITH_GUEST_PROPS
5449
5450	HRESULT rc = i_getGuestPropertyFromVM(aName, aValue, aTimestamp, aFlags);
5451
5452	if (rc == E_ACCESSDENIED)
5453	/* The VM is not running or the service is not (yet) accessible */
5454	rc = i_getGuestPropertyFromService(aName, aValue, aTimestamp, aFlags);
5455	return rc;
5456	#endif // VBOX_WITH_GUEST_PROPS
5457	}
5458
5459	HRESULT Machine::getGuestPropertyValue(const com::Utf8Str &aProperty, com::Utf8Str &aValue)
5460	{
5461	LONG64 dummyTimestamp;
5462	com::Utf8Str dummyFlags;
5463	HRESULT rc = getGuestProperty(aProperty, aValue, &dummyTimestamp, dummyFlags);
5464	return rc;
5465
5466	}
5467	HRESULT Machine::getGuestPropertyTimestamp(const com::Utf8Str &aProperty, LONG64 *aValue)
5468	{
5469	com::Utf8Str dummyFlags;
5470	com::Utf8Str dummyValue;
5471	HRESULT rc = getGuestProperty(aProperty, dummyValue, aValue, dummyFlags);
5472	return rc;
5473	}
5474
5475	#ifdef VBOX_WITH_GUEST_PROPS
5476	/**
5477	* Set a guest property in VBoxSVC's internal structures.
5478	*/
5479	HRESULT Machine::i_setGuestPropertyToService(const com::Utf8Str &aName, const com::Utf8Str &aValue,
5480	const com::Utf8Str &aFlags, bool fDelete)
5481	{
5482	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5483	HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
5484	if (FAILED(rc)) return rc;
5485
5486	try
5487	{
5488	uint32_t fFlags = GUEST_PROP_F_NILFLAG;
5489	if (aFlags.length() && RT_FAILURE(GuestPropValidateFlags(aFlags.c_str(), &fFlags)))
5490	return setError(E_INVALIDARG, tr("Invalid guest property flag values: '%s'"), aFlags.c_str());
5491
5492	HWData::GuestPropertyMap::iterator it = mHWData->mGuestProperties.find(aName);
5493	if (it == mHWData->mGuestProperties.end())
5494	{
5495	if (!fDelete)
5496	{
5497	i_setModified(IsModified_MachineData);
5498	mHWData.backupEx();
5499
5500	RTTIMESPEC time;
5501	HWData::GuestProperty prop;
5502	prop.strValue = Bstr(aValue).raw();
5503	prop.mTimestamp = RTTimeSpecGetNano(RTTimeNow(&time));
5504	prop.mFlags = fFlags;
5505	mHWData->mGuestProperties[aName] = prop;
5506	}
5507	}
5508	else
5509	{
5510	if (it->second.mFlags & (GUEST_PROP_F_RDONLYHOST))
5511	{
5512	rc = setError(E_ACCESSDENIED, tr("The property '%s' cannot be changed by the host"), aName.c_str());
5513	}
5514	else
5515	{
5516	i_setModified(IsModified_MachineData);
5517	mHWData.backupEx();
5518
5519	/* The backupEx() operation invalidates our iterator,
5520	* so get a new one. */
5521	it = mHWData->mGuestProperties.find(aName);
5522	Assert(it != mHWData->mGuestProperties.end());
5523
5524	if (!fDelete)
5525	{
5526	RTTIMESPEC time;
5527	it->second.strValue = aValue;
5528	it->second.mTimestamp = RTTimeSpecGetNano(RTTimeNow(&time));
5529	it->second.mFlags = fFlags;
5530	}
5531	else
5532	mHWData->mGuestProperties.erase(it);
5533	}
5534	}
5535
5536	if (SUCCEEDED(rc))
5537	{
5538	alock.release();
5539
5540	mParent->i_onGuestPropertyChanged(mData->mUuid, aName, aValue, aFlags);
5541	}
5542	}
5543	catch (std::bad_alloc &)
5544	{
5545	rc = E_OUTOFMEMORY;
5546	}
5547
5548	return rc;
5549	}
5550
5551	/**
5552	* Set a property on the VM that that property belongs to.
5553	* @returns E_ACCESSDENIED if the VM process is not available or not
5554	* currently handling queries and the setting should then be done in
5555	* VBoxSVC.
5556	*/
5557	HRESULT Machine::i_setGuestPropertyToVM(const com::Utf8Str &aName, const com::Utf8Str &aValue,
5558	const com::Utf8Str &aFlags, bool fDelete)
5559	{
5560	HRESULT rc;
5561
5562	try
5563	{
5564	ComPtr<IInternalSessionControl> directControl;
5565	{
5566	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5567	if (mData->mSession.mLockType == LockType_VM)
5568	directControl = mData->mSession.mDirectControl;
5569	}
5570
5571	Bstr dummy1; /* will not be changed (setter) */
5572	Bstr dummy2; /* will not be changed (setter) */
5573	LONG64 dummy64;
5574	if (!directControl)
5575	rc = E_ACCESSDENIED;
5576	else
5577	/** @todo Fix when adding DeleteGuestProperty(), see defect. */
5578	rc = directControl->AccessGuestProperty(Bstr(aName).raw(), Bstr(aValue).raw(), Bstr(aFlags).raw(),
5579	fDelete ? 2 : 1 /* accessMode */,
5580	dummy1.asOutParam(), &dummy64, dummy2.asOutParam());
5581	}
5582	catch (std::bad_alloc &)
5583	{
5584	rc = E_OUTOFMEMORY;
5585	}
5586
5587	return rc;
5588	}
5589	#endif // VBOX_WITH_GUEST_PROPS
5590
5591	HRESULT Machine::setGuestProperty(const com::Utf8Str &aProperty, const com::Utf8Str &aValue,
5592	const com::Utf8Str &aFlags)
5593	{
5594	#ifndef VBOX_WITH_GUEST_PROPS
5595	ReturnComNotImplemented();
5596	#else // VBOX_WITH_GUEST_PROPS
5597	HRESULT rc = i_setGuestPropertyToVM(aProperty, aValue, aFlags, /* fDelete = */ false);
5598	if (rc == E_ACCESSDENIED)
5599	/* The VM is not running or the service is not (yet) accessible */
5600	rc = i_setGuestPropertyToService(aProperty, aValue, aFlags, /* fDelete = */ false);
5601	return rc;
5602	#endif // VBOX_WITH_GUEST_PROPS
5603	}
5604
5605	HRESULT Machine::setGuestPropertyValue(const com::Utf8Str &aProperty, const com::Utf8Str &aValue)
5606	{
5607	return setGuestProperty(aProperty, aValue, "");
5608	}
5609
5610	HRESULT Machine::deleteGuestProperty(const com::Utf8Str &aName)
5611	{
5612	#ifndef VBOX_WITH_GUEST_PROPS
5613	ReturnComNotImplemented();
5614	#else // VBOX_WITH_GUEST_PROPS
5615	HRESULT rc = i_setGuestPropertyToVM(aName, "", "", /* fDelete = */ true);
5616	if (rc == E_ACCESSDENIED)
5617	/* The VM is not running or the service is not (yet) accessible */
5618	rc = i_setGuestPropertyToService(aName, "", "", /* fDelete = */ true);
5619	return rc;
5620	#endif // VBOX_WITH_GUEST_PROPS
5621	}
5622
5623	#ifdef VBOX_WITH_GUEST_PROPS
5624	/**
5625	* Enumerate the guest properties in VBoxSVC's internal structures.
5626	*/
5627	HRESULT Machine::i_enumerateGuestPropertiesInService(const com::Utf8Str &aPatterns,
5628	std::vector<com::Utf8Str> &aNames,
5629	std::vector<com::Utf8Str> &aValues,
5630	std::vector<LONG64> &aTimestamps,
5631	std::vector<com::Utf8Str> &aFlags)
5632	{
5633	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5634	Utf8Str strPatterns(aPatterns);
5635
5636	/*
5637	* Look for matching patterns and build up a list.
5638	*/
5639	HWData::GuestPropertyMap propMap;
5640	for (HWData::GuestPropertyMap::const_iterator
5641	it = mHWData->mGuestProperties.begin();
5642	it != mHWData->mGuestProperties.end();
5643	++it)
5644	{
5645	if ( strPatterns.isEmpty()
5646	\|\| RTStrSimplePatternMultiMatch(strPatterns.c_str(),
5647	RTSTR_MAX,
5648	it->first.c_str(),
5649	RTSTR_MAX,
5650	NULL)
5651	)
5652	propMap.insert(*it);
5653	}
5654
5655	alock.release();
5656
5657	/*
5658	* And build up the arrays for returning the property information.
5659	*/
5660	size_t cEntries = propMap.size();
5661
5662	aNames.resize(cEntries);
5663	aValues.resize(cEntries);
5664	aTimestamps.resize(cEntries);
5665	aFlags.resize(cEntries);
5666
5667	char szFlags[GUEST_PROP_MAX_FLAGS_LEN + 1];
5668	size_t i = 0;
5669	for (HWData::GuestPropertyMap::const_iterator
5670	it = propMap.begin();
5671	it != propMap.end();
5672	++it, ++i)
5673	{
5674	aNames[i] = it->first;
5675	aValues[i] = it->second.strValue;
5676	aTimestamps[i] = it->second.mTimestamp;
5677	GuestPropWriteFlags(it->second.mFlags, szFlags);
5678	aFlags[i] = Utf8Str(szFlags);
5679	}
5680
5681	return S_OK;
5682	}
5683
5684	/**
5685	* Enumerate the properties managed by a VM.
5686	* @returns E_ACCESSDENIED if the VM process is not available or not
5687	* currently handling queries and the setting should then be done in
5688	* VBoxSVC.
5689	*/
5690	HRESULT Machine::i_enumerateGuestPropertiesOnVM(const com::Utf8Str &aPatterns,
5691	std::vector<com::Utf8Str> &aNames,
5692	std::vector<com::Utf8Str> &aValues,
5693	std::vector<LONG64> &aTimestamps,
5694	std::vector<com::Utf8Str> &aFlags)
5695	{
5696	HRESULT rc;
5697	ComPtr<IInternalSessionControl> directControl;
5698	{
5699	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5700	if (mData->mSession.mLockType == LockType_VM)
5701	directControl = mData->mSession.mDirectControl;
5702	}
5703
5704	com::SafeArray<BSTR> bNames;
5705	com::SafeArray<BSTR> bValues;
5706	com::SafeArray<LONG64> bTimestamps;
5707	com::SafeArray<BSTR> bFlags;
5708
5709	if (!directControl)
5710	rc = E_ACCESSDENIED;
5711	else
5712	rc = directControl->EnumerateGuestProperties(Bstr(aPatterns).raw(),
5713	ComSafeArrayAsOutParam(bNames),
5714	ComSafeArrayAsOutParam(bValues),
5715	ComSafeArrayAsOutParam(bTimestamps),
5716	ComSafeArrayAsOutParam(bFlags));
5717	size_t i;
5718	aNames.resize(bNames.size());
5719	for (i = 0; i < bNames.size(); ++i)
5720	aNames[i] = Utf8Str(bNames[i]);
5721	aValues.resize(bValues.size());
5722	for (i = 0; i < bValues.size(); ++i)
5723	aValues[i] = Utf8Str(bValues[i]);
5724	aTimestamps.resize(bTimestamps.size());
5725	for (i = 0; i < bTimestamps.size(); ++i)
5726	aTimestamps[i] = bTimestamps[i];
5727	aFlags.resize(bFlags.size());
5728	for (i = 0; i < bFlags.size(); ++i)
5729	aFlags[i] = Utf8Str(bFlags[i]);
5730
5731	return rc;
5732	}
5733	#endif // VBOX_WITH_GUEST_PROPS
5734	HRESULT Machine::enumerateGuestProperties(const com::Utf8Str &aPatterns,
5735	std::vector<com::Utf8Str> &aNames,
5736	std::vector<com::Utf8Str> &aValues,
5737	std::vector<LONG64> &aTimestamps,
5738	std::vector<com::Utf8Str> &aFlags)
5739	{
5740	#ifndef VBOX_WITH_GUEST_PROPS
5741	ReturnComNotImplemented();
5742	#else // VBOX_WITH_GUEST_PROPS
5743
5744	HRESULT rc = i_enumerateGuestPropertiesOnVM(aPatterns, aNames, aValues, aTimestamps, aFlags);
5745
5746	if (rc == E_ACCESSDENIED)
5747	/* The VM is not running or the service is not (yet) accessible */
5748	rc = i_enumerateGuestPropertiesInService(aPatterns, aNames, aValues, aTimestamps, aFlags);
5749	return rc;
5750	#endif // VBOX_WITH_GUEST_PROPS
5751	}
5752
5753	HRESULT Machine::getMediumAttachmentsOfController(const com::Utf8Str &aName,
5754	std::vector<ComPtr<IMediumAttachment> > &aMediumAttachments)
5755	{
5756	MediumAttachmentList atts;
5757
5758	HRESULT rc = i_getMediumAttachmentsOfController(aName, atts);
5759	if (FAILED(rc)) return rc;
5760
5761	aMediumAttachments.resize(atts.size());
5762	size_t i = 0;
5763	for (MediumAttachmentList::const_iterator
5764	it = atts.begin();
5765	it != atts.end();
5766	++it, ++i)
5767	(*it).queryInterfaceTo(aMediumAttachments[i].asOutParam());
5768
5769	return S_OK;
5770	}
5771
5772	HRESULT Machine::getMediumAttachment(const com::Utf8Str &aName,
5773	LONG aControllerPort,
5774	LONG aDevice,
5775	ComPtr<IMediumAttachment> &aAttachment)
5776	{
5777	LogFlowThisFunc(("aControllerName=\"%s\" aControllerPort=%d aDevice=%d\n",
5778	aName.c_str(), aControllerPort, aDevice));
5779
5780	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5781
5782	aAttachment = NULL;
5783
5784	ComObjPtr<MediumAttachment> pAttach = i_findAttachment(*mMediumAttachments.data(),
5785	aName,
5786	aControllerPort,
5787	aDevice);
5788	if (pAttach.isNull())
5789	return setError(VBOX_E_OBJECT_NOT_FOUND,
5790	tr("No storage device attached to device slot %d on port %d of controller '%s'"),
5791	aDevice, aControllerPort, aName.c_str());
5792
5793	pAttach.queryInterfaceTo(aAttachment.asOutParam());
5794
5795	return S_OK;
5796	}
5797
5798
5799	HRESULT Machine::addStorageController(const com::Utf8Str &aName,
5800	StorageBus_T aConnectionType,
5801	ComPtr<IStorageController> &aController)
5802	{
5803	if ( (aConnectionType <= StorageBus_Null)
5804	\|\| (aConnectionType > StorageBus_VirtioSCSI))
5805	return setError(E_INVALIDARG,
5806	tr("Invalid connection type: %d"),
5807	aConnectionType);
5808
5809	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5810
5811	HRESULT rc = i_checkStateDependency(MutableStateDep);
5812	if (FAILED(rc)) return rc;
5813
5814	/* try to find one with the name first. */
5815	ComObjPtr<StorageController> ctrl;
5816
5817	rc = i_getStorageControllerByName(aName, ctrl, false /* aSetError */);
5818	if (SUCCEEDED(rc))
5819	return setError(VBOX_E_OBJECT_IN_USE,
5820	tr("Storage controller named '%s' already exists"),
5821	aName.c_str());
5822
5823	ctrl.createObject();
5824
5825	/* get a new instance number for the storage controller */
5826	ULONG ulInstance = 0;
5827	bool fBootable = true;
5828	for (StorageControllerList::const_iterator
5829	it = mStorageControllers->begin();
5830	it != mStorageControllers->end();
5831	++it)
5832	{
5833	if ((*it)->i_getStorageBus() == aConnectionType)
5834	{
5835	ULONG ulCurInst = (*it)->i_getInstance();
5836
5837	if (ulCurInst >= ulInstance)
5838	ulInstance = ulCurInst + 1;
5839
5840	/* Only one controller of each type can be marked as bootable. */
5841	if ((*it)->i_getBootable())
5842	fBootable = false;
5843	}
5844	}
5845
5846	rc = ctrl->init(this, aName, aConnectionType, ulInstance, fBootable);
5847	if (FAILED(rc)) return rc;
5848
5849	i_setModified(IsModified_Storage);
5850	mStorageControllers.backup();
5851	mStorageControllers->push_back(ctrl);
5852
5853	ctrl.queryInterfaceTo(aController.asOutParam());
5854
5855	/* inform the direct session if any */
5856	alock.release();
5857	i_onStorageControllerChange(i_getId(), aName);
5858
5859	return S_OK;
5860	}
5861
5862	HRESULT Machine::getStorageControllerByName(const com::Utf8Str &aName,
5863	ComPtr<IStorageController> &aStorageController)
5864	{
5865	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5866
5867	ComObjPtr<StorageController> ctrl;
5868
5869	HRESULT rc = i_getStorageControllerByName(aName, ctrl, true /* aSetError */);
5870	if (SUCCEEDED(rc))
5871	ctrl.queryInterfaceTo(aStorageController.asOutParam());
5872
5873	return rc;
5874	}
5875
5876	HRESULT Machine::getStorageControllerByInstance(StorageBus_T aConnectionType,
5877	ULONG aInstance,
5878	ComPtr<IStorageController> &aStorageController)
5879	{
5880	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5881
5882	for (StorageControllerList::const_iterator
5883	it = mStorageControllers->begin();
5884	it != mStorageControllers->end();
5885	++it)
5886	{
5887	if ( (*it)->i_getStorageBus() == aConnectionType
5888	&& (*it)->i_getInstance() == aInstance)
5889	{
5890	(*it).queryInterfaceTo(aStorageController.asOutParam());
5891	return S_OK;
5892	}
5893	}
5894
5895	return setError(VBOX_E_OBJECT_NOT_FOUND,
5896	tr("Could not find a storage controller with instance number '%lu'"),
5897	aInstance);
5898	}
5899
5900	HRESULT Machine::setStorageControllerBootable(const com::Utf8Str &aName, BOOL aBootable)
5901	{
5902	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5903
5904	HRESULT rc = i_checkStateDependency(MutableStateDep);
5905	if (FAILED(rc)) return rc;
5906
5907	ComObjPtr<StorageController> ctrl;
5908
5909	rc = i_getStorageControllerByName(aName, ctrl, true /* aSetError */);
5910	if (SUCCEEDED(rc))
5911	{
5912	/* Ensure that only one controller of each type is marked as bootable. */
5913	if (aBootable == TRUE)
5914	{
5915	for (StorageControllerList::const_iterator
5916	it = mStorageControllers->begin();
5917	it != mStorageControllers->end();
5918	++it)
5919	{
5920	ComObjPtr<StorageController> aCtrl = (*it);
5921
5922	if ( (aCtrl->i_getName() != aName)
5923	&& aCtrl->i_getBootable() == TRUE
5924	&& aCtrl->i_getStorageBus() == ctrl->i_getStorageBus()
5925	&& aCtrl->i_getControllerType() == ctrl->i_getControllerType())
5926	{
5927	aCtrl->i_setBootable(FALSE);
5928	break;
5929	}
5930	}
5931	}
5932
5933	if (SUCCEEDED(rc))
5934	{
5935	ctrl->i_setBootable(aBootable);
5936	i_setModified(IsModified_Storage);
5937	}
5938	}
5939
5940	if (SUCCEEDED(rc))
5941	{
5942	/* inform the direct session if any */
5943	alock.release();
5944	i_onStorageControllerChange(i_getId(), aName);
5945	}
5946
5947	return rc;
5948	}
5949
5950	HRESULT Machine::removeStorageController(const com::Utf8Str &aName)
5951	{
5952	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5953
5954	HRESULT rc = i_checkStateDependency(MutableStateDep);
5955	if (FAILED(rc)) return rc;
5956
5957	ComObjPtr<StorageController> ctrl;
5958	rc = i_getStorageControllerByName(aName, ctrl, true /* aSetError */);
5959	if (FAILED(rc)) return rc;
5960
5961	MediumAttachmentList llDetachedAttachments;
5962	{
5963	/* find all attached devices to the appropriate storage controller and detach them all */
5964	// make a temporary list because detachDevice invalidates iterators into
5965	// mMediumAttachments
5966	MediumAttachmentList llAttachments2 = *mMediumAttachments.data();
5967
5968	for (MediumAttachmentList::const_iterator
5969	it = llAttachments2.begin();
5970	it != llAttachments2.end();
5971	++it)
5972	{
5973	MediumAttachment pAttachTemp = it;
5974
5975	AutoCaller localAutoCaller(pAttachTemp);
5976	if (FAILED(localAutoCaller.rc())) return localAutoCaller.rc();
5977
5978	AutoReadLock local_alock(pAttachTemp COMMA_LOCKVAL_SRC_POS);
5979
5980	if (pAttachTemp->i_getControllerName() == aName)
5981	{
5982	llDetachedAttachments.push_back(pAttachTemp);
5983	rc = i_detachDevice(pAttachTemp, alock, NULL);
5984	if (FAILED(rc)) return rc;
5985	}
5986	}
5987	}
5988
5989	/* send event about detached devices before removing parent controller */
5990	for (MediumAttachmentList::const_iterator
5991	it = llDetachedAttachments.begin();
5992	it != llDetachedAttachments.end();
5993	++it)
5994	{
5995	mParent->i_onStorageDeviceChanged(*it, TRUE, FALSE);
5996	}
5997
5998	/* We can remove it now. */
5999	i_setModified(IsModified_Storage);
6000	mStorageControllers.backup();
6001
6002	ctrl->i_unshare();
6003
6004	mStorageControllers->remove(ctrl);
6005
6006	/* inform the direct session if any */
6007	alock.release();
6008	i_onStorageControllerChange(i_getId(), aName);
6009
6010	return S_OK;
6011	}
6012
6013	HRESULT Machine::addUSBController(const com::Utf8Str &aName, USBControllerType_T aType,
6014	ComPtr<IUSBController> &aController)
6015	{
6016	if ( (aType <= USBControllerType_Null)
6017	\|\| (aType >= USBControllerType_Last))
6018	return setError(E_INVALIDARG,
6019	tr("Invalid USB controller type: %d"),
6020	aType);
6021
6022	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6023
6024	HRESULT rc = i_checkStateDependency(MutableStateDep);
6025	if (FAILED(rc)) return rc;
6026
6027	/* try to find one with the same type first. */
6028	ComObjPtr<USBController> ctrl;
6029
6030	rc = i_getUSBControllerByName(aName, ctrl, false /* aSetError */);
6031	if (SUCCEEDED(rc))
6032	return setError(VBOX_E_OBJECT_IN_USE,
6033	tr("USB controller named '%s' already exists"),
6034	aName.c_str());
6035
6036	/* Check that we don't exceed the maximum number of USB controllers for the given type. */
6037	ULONG maxInstances;
6038	rc = mParent->i_getSystemProperties()->GetMaxInstancesOfUSBControllerType(mHWData->mChipsetType, aType, &maxInstances);
6039	if (FAILED(rc))
6040	return rc;
6041
6042	ULONG cInstances = i_getUSBControllerCountByType(aType);
6043	if (cInstances >= maxInstances)
6044	return setError(E_INVALIDARG,
6045	tr("Too many USB controllers of this type"));
6046
6047	ctrl.createObject();
6048
6049	rc = ctrl->init(this, aName, aType);
6050	if (FAILED(rc)) return rc;
6051
6052	i_setModified(IsModified_USB);
6053	mUSBControllers.backup();
6054	mUSBControllers->push_back(ctrl);
6055
6056	ctrl.queryInterfaceTo(aController.asOutParam());
6057
6058	/* inform the direct session if any */
6059	alock.release();
6060	i_onUSBControllerChange();
6061
6062	return S_OK;
6063	}
6064
6065	HRESULT Machine::getUSBControllerByName(const com::Utf8Str &aName, ComPtr<IUSBController> &aController)
6066	{
6067	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6068
6069	ComObjPtr<USBController> ctrl;
6070
6071	HRESULT rc = i_getUSBControllerByName(aName, ctrl, true /* aSetError */);
6072	if (SUCCEEDED(rc))
6073	ctrl.queryInterfaceTo(aController.asOutParam());
6074
6075	return rc;
6076	}
6077
6078	HRESULT Machine::getUSBControllerCountByType(USBControllerType_T aType,
6079	ULONG *aControllers)
6080	{
6081	if ( (aType <= USBControllerType_Null)
6082	\|\| (aType >= USBControllerType_Last))
6083	return setError(E_INVALIDARG,
6084	tr("Invalid USB controller type: %d"),
6085	aType);
6086
6087	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6088
6089	ComObjPtr<USBController> ctrl;
6090
6091	*aControllers = i_getUSBControllerCountByType(aType);
6092
6093	return S_OK;
6094	}
6095
6096	HRESULT Machine::removeUSBController(const com::Utf8Str &aName)
6097	{
6098
6099	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6100
6101	HRESULT rc = i_checkStateDependency(MutableStateDep);
6102	if (FAILED(rc)) return rc;
6103
6104	ComObjPtr<USBController> ctrl;
6105	rc = i_getUSBControllerByName(aName, ctrl, true /* aSetError */);
6106	if (FAILED(rc)) return rc;
6107
6108	i_setModified(IsModified_USB);
6109	mUSBControllers.backup();
6110
6111	ctrl->i_unshare();
6112
6113	mUSBControllers->remove(ctrl);
6114
6115	/* inform the direct session if any */
6116	alock.release();
6117	i_onUSBControllerChange();
6118
6119	return S_OK;
6120	}
6121
6122	HRESULT Machine::querySavedGuestScreenInfo(ULONG aScreenId,
6123	ULONG *aOriginX,
6124	ULONG *aOriginY,
6125	ULONG *aWidth,
6126	ULONG *aHeight,
6127	BOOL *aEnabled)
6128	{
6129	uint32_t u32OriginX= 0;
6130	uint32_t u32OriginY= 0;
6131	uint32_t u32Width = 0;
6132	uint32_t u32Height = 0;
6133	uint16_t u16Flags = 0;
6134
6135	int vrc = readSavedGuestScreenInfo(mSSData->strStateFilePath, aScreenId,
6136	&u32OriginX, &u32OriginY, &u32Width, &u32Height, &u16Flags);
6137	if (RT_FAILURE(vrc))
6138	{
6139	#ifdef RT_OS_WINDOWS
6140	/* HACK: GUI sets *pfEnabled to 'true' and expects it to stay so if the API fails.
6141	* This works with XPCOM. But Windows COM sets all output parameters to zero.
6142	* So just assign fEnable to TRUE again.
6143	* The right fix would be to change GUI API wrappers to make sure that parameters
6144	* are changed only if API succeeds.
6145	*/
6146	*aEnabled = TRUE;
6147	#endif
6148	return setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
6149	tr("Saved guest size is not available (%Rrc)"),
6150	vrc);
6151	}
6152
6153	*aOriginX = u32OriginX;
6154	*aOriginY = u32OriginY;
6155	*aWidth = u32Width;
6156	*aHeight = u32Height;
6157	*aEnabled = (u16Flags & VBVA_SCREEN_F_DISABLED) == 0;
6158
6159	return S_OK;
6160	}
6161
6162	HRESULT Machine::readSavedThumbnailToArray(ULONG aScreenId, BitmapFormat_T aBitmapFormat,
6163	ULONG aWidth, ULONG aHeight, std::vector<BYTE> &aData)
6164	{
6165	if (aScreenId != 0)
6166	return E_NOTIMPL;
6167
6168	if ( aBitmapFormat != BitmapFormat_BGR0
6169	&& aBitmapFormat != BitmapFormat_BGRA
6170	&& aBitmapFormat != BitmapFormat_RGBA
6171	&& aBitmapFormat != BitmapFormat_PNG)
6172	return setError(E_NOTIMPL,
6173	tr("Unsupported saved thumbnail format 0x%08X"), aBitmapFormat);
6174
6175	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6176
6177	uint8_t *pu8Data = NULL;
6178	uint32_t cbData = 0;
6179	uint32_t u32Width = 0;
6180	uint32_t u32Height = 0;
6181
6182	int vrc = readSavedDisplayScreenshot(mSSData->strStateFilePath, 0 /* u32Type */, &pu8Data, &cbData, &u32Width, &u32Height);
6183
6184	if (RT_FAILURE(vrc))
6185	return setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
6186	tr("Saved thumbnail data is not available (%Rrc)"),
6187	vrc);
6188
6189	HRESULT hr = S_OK;
6190
6191	*aWidth = u32Width;
6192	*aHeight = u32Height;
6193
6194	if (cbData > 0)
6195	{
6196	/* Convert pixels to the format expected by the API caller. */
6197	if (aBitmapFormat == BitmapFormat_BGR0)
6198	{
6199	/* [0] B, [1] G, [2] R, [3] 0. */
6200	aData.resize(cbData);
6201	memcpy(&aData.front(), pu8Data, cbData);
6202	}
6203	else if (aBitmapFormat == BitmapFormat_BGRA)
6204	{
6205	/* [0] B, [1] G, [2] R, [3] A. */
6206	aData.resize(cbData);
6207	for (uint32_t i = 0; i < cbData; i += 4)
6208	{
6209	aData[i] = pu8Data[i];
6210	aData[i + 1] = pu8Data[i + 1];
6211	aData[i + 2] = pu8Data[i + 2];
6212	aData[i + 3] = 0xff;
6213	}
6214	}
6215	else if (aBitmapFormat == BitmapFormat_RGBA)
6216	{
6217	/* [0] R, [1] G, [2] B, [3] A. */
6218	aData.resize(cbData);
6219	for (uint32_t i = 0; i < cbData; i += 4)
6220	{
6221	aData[i] = pu8Data[i + 2];
6222	aData[i + 1] = pu8Data[i + 1];
6223	aData[i + 2] = pu8Data[i];
6224	aData[i + 3] = 0xff;
6225	}
6226	}
6227	else if (aBitmapFormat == BitmapFormat_PNG)
6228	{
6229	uint8_t *pu8PNG = NULL;
6230	uint32_t cbPNG = 0;
6231	uint32_t cxPNG = 0;
6232	uint32_t cyPNG = 0;
6233
6234	vrc = DisplayMakePNG(pu8Data, u32Width, u32Height, &pu8PNG, &cbPNG, &cxPNG, &cyPNG, 0);
6235
6236	if (RT_SUCCESS(vrc))
6237	{
6238	aData.resize(cbPNG);
6239	if (cbPNG)
6240	memcpy(&aData.front(), pu8PNG, cbPNG);
6241	}
6242	else
6243	hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
6244	tr("Could not convert saved thumbnail to PNG (%Rrc)"),
6245	vrc);
6246
6247	RTMemFree(pu8PNG);
6248	}
6249	}
6250
6251	freeSavedDisplayScreenshot(pu8Data);
6252
6253	return hr;
6254	}
6255
6256	HRESULT Machine::querySavedScreenshotInfo(ULONG aScreenId,
6257	ULONG *aWidth,
6258	ULONG *aHeight,
6259	std::vector<BitmapFormat_T> &aBitmapFormats)
6260	{
6261	if (aScreenId != 0)
6262	return E_NOTIMPL;
6263
6264	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6265
6266	uint8_t *pu8Data = NULL;
6267	uint32_t cbData = 0;
6268	uint32_t u32Width = 0;
6269	uint32_t u32Height = 0;
6270
6271	int vrc = readSavedDisplayScreenshot(mSSData->strStateFilePath, 1 /* u32Type */, &pu8Data, &cbData, &u32Width, &u32Height);
6272
6273	if (RT_FAILURE(vrc))
6274	return setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
6275	tr("Saved screenshot data is not available (%Rrc)"),
6276	vrc);
6277
6278	*aWidth = u32Width;
6279	*aHeight = u32Height;
6280	aBitmapFormats.resize(1);
6281	aBitmapFormats[0] = BitmapFormat_PNG;
6282
6283	freeSavedDisplayScreenshot(pu8Data);
6284
6285	return S_OK;
6286	}
6287
6288	HRESULT Machine::readSavedScreenshotToArray(ULONG aScreenId,
6289	BitmapFormat_T aBitmapFormat,
6290	ULONG *aWidth,
6291	ULONG *aHeight,
6292	std::vector<BYTE> &aData)
6293	{
6294	if (aScreenId != 0)
6295	return E_NOTIMPL;
6296
6297	if (aBitmapFormat != BitmapFormat_PNG)
6298	return E_NOTIMPL;
6299
6300	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6301
6302	uint8_t *pu8Data = NULL;
6303	uint32_t cbData = 0;
6304	uint32_t u32Width = 0;
6305	uint32_t u32Height = 0;
6306
6307	int vrc = readSavedDisplayScreenshot(mSSData->strStateFilePath, 1 /* u32Type */, &pu8Data, &cbData, &u32Width, &u32Height);
6308
6309	if (RT_FAILURE(vrc))
6310	return setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
6311	tr("Saved screenshot thumbnail data is not available (%Rrc)"),
6312	vrc);
6313
6314	*aWidth = u32Width;
6315	*aHeight = u32Height;
6316
6317	aData.resize(cbData);
6318	if (cbData)
6319	memcpy(&aData.front(), pu8Data, cbData);
6320
6321	freeSavedDisplayScreenshot(pu8Data);
6322
6323	return S_OK;
6324	}
6325
6326	HRESULT Machine::hotPlugCPU(ULONG aCpu)
6327	{
6328	HRESULT rc = S_OK;
6329	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6330
6331	if (!mHWData->mCPUHotPlugEnabled)
6332	return setError(E_INVALIDARG, tr("CPU hotplug is not enabled"));
6333
6334	if (aCpu >= mHWData->mCPUCount)
6335	return setError(E_INVALIDARG, tr("CPU id exceeds number of possible CPUs [0:%lu]"), mHWData->mCPUCount-1);
6336
6337	if (mHWData->mCPUAttached[aCpu])
6338	return setError(VBOX_E_OBJECT_IN_USE, tr("CPU %lu is already attached"), aCpu);
6339
6340	alock.release();
6341	rc = i_onCPUChange(aCpu, false);
6342	alock.acquire();
6343	if (FAILED(rc)) return rc;
6344
6345	i_setModified(IsModified_MachineData);
6346	mHWData.backup();
6347	mHWData->mCPUAttached[aCpu] = true;
6348
6349	/** Save settings if online - @todo why is this required? -- @bugref{6818} */
6350	if (Global::IsOnline(mData->mMachineState))
6351	i_saveSettings(NULL);
6352
6353	return S_OK;
6354	}
6355
6356	HRESULT Machine::hotUnplugCPU(ULONG aCpu)
6357	{
6358	HRESULT rc = S_OK;
6359
6360	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6361
6362	if (!mHWData->mCPUHotPlugEnabled)
6363	return setError(E_INVALIDARG, tr("CPU hotplug is not enabled"));
6364
6365	if (aCpu >= SchemaDefs::MaxCPUCount)
6366	return setError(E_INVALIDARG,
6367	tr("CPU index exceeds maximum CPU count (must be in range [0:%lu])"),
6368	SchemaDefs::MaxCPUCount);
6369
6370	if (!mHWData->mCPUAttached[aCpu])
6371	return setError(VBOX_E_OBJECT_NOT_FOUND, tr("CPU %lu is not attached"), aCpu);
6372
6373	/* CPU 0 can't be detached */
6374	if (aCpu == 0)
6375	return setError(E_INVALIDARG, tr("It is not possible to detach CPU 0"));
6376
6377	alock.release();
6378	rc = i_onCPUChange(aCpu, true);
6379	alock.acquire();
6380	if (FAILED(rc)) return rc;
6381
6382	i_setModified(IsModified_MachineData);
6383	mHWData.backup();
6384	mHWData->mCPUAttached[aCpu] = false;
6385
6386	/** Save settings if online - @todo why is this required? -- @bugref{6818} */
6387	if (Global::IsOnline(mData->mMachineState))
6388	i_saveSettings(NULL);
6389
6390	return S_OK;
6391	}
6392
6393	HRESULT Machine::getCPUStatus(ULONG aCpu, BOOL *aAttached)
6394	{
6395	*aAttached = false;
6396
6397	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6398
6399	/* If hotplug is enabled the CPU is always enabled. */
6400	if (!mHWData->mCPUHotPlugEnabled)
6401	{
6402	if (aCpu < mHWData->mCPUCount)
6403	*aAttached = true;
6404	}
6405	else
6406	{
6407	if (aCpu < SchemaDefs::MaxCPUCount)
6408	*aAttached = mHWData->mCPUAttached[aCpu];
6409	}
6410
6411	return S_OK;
6412	}
6413
6414	HRESULT Machine::queryLogFilename(ULONG aIdx, com::Utf8Str &aFilename)
6415	{
6416	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6417
6418	Utf8Str log = i_getLogFilename(aIdx);
6419	if (!RTFileExists(log.c_str()))
6420	log.setNull();
6421	aFilename = log;
6422
6423	return S_OK;
6424	}
6425
6426	HRESULT Machine::readLog(ULONG aIdx, LONG64 aOffset, LONG64 aSize, std::vector<BYTE> &aData)
6427	{
6428	if (aSize < 0)
6429	return setError(E_INVALIDARG, tr("The size argument (%lld) is negative"), aSize);
6430
6431	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6432
6433	HRESULT rc = S_OK;
6434	Utf8Str log = i_getLogFilename(aIdx);
6435
6436	/* do not unnecessarily hold the lock while doing something which does
6437	* not need the lock and potentially takes a long time. */
6438	alock.release();
6439
6440	/* Limit the chunk size to 512K. Gives good performance over (XP)COM, and
6441	* keeps the SOAP reply size under 1M for the webservice (we're using
6442	* base64 encoded strings for binary data for years now, avoiding the
6443	* expansion of each byte array element to approx. 25 bytes of XML. */
6444	size_t cbData = (size_t)RT_MIN(aSize, _512K);
6445	aData.resize(cbData);
6446
6447	RTFILE LogFile;
6448	int vrc = RTFileOpen(&LogFile, log.c_str(),
6449	RTFILE_O_OPEN \| RTFILE_O_READ \| RTFILE_O_DENY_NONE);
6450	if (RT_SUCCESS(vrc))
6451	{
6452	vrc = RTFileReadAt(LogFile, aOffset, cbData ? &aData.front() : NULL, cbData, &cbData);
6453	if (RT_SUCCESS(vrc))
6454	aData.resize(cbData);
6455	else
6456	rc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
6457	tr("Could not read log file '%s' (%Rrc)"),
6458	log.c_str(), vrc);
6459	RTFileClose(LogFile);
6460	}
6461	else
6462	rc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
6463	tr("Could not open log file '%s' (%Rrc)"),
6464	log.c_str(), vrc);
6465
6466	if (FAILED(rc))
6467	aData.resize(0);
6468
6469	return rc;
6470	}
6471
6472
6473	/**
6474	* Currently this method doesn't attach device to the running VM,
6475	* just makes sure it's plugged on next VM start.
6476	*/
6477	HRESULT Machine::attachHostPCIDevice(LONG aHostAddress, LONG aDesiredGuestAddress, BOOL /* aTryToUnbind */)
6478	{
6479	// lock scope
6480	{
6481	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6482
6483	HRESULT rc = i_checkStateDependency(MutableStateDep);
6484	if (FAILED(rc)) return rc;
6485
6486	ChipsetType_T aChipset = ChipsetType_PIIX3;
6487	COMGETTER(ChipsetType)(&aChipset);
6488
6489	if (aChipset != ChipsetType_ICH9)
6490	{
6491	return setError(E_INVALIDARG,
6492	tr("Host PCI attachment only supported with ICH9 chipset"));
6493	}
6494
6495	// check if device with this host PCI address already attached
6496	for (HWData::PCIDeviceAssignmentList::const_iterator
6497	it = mHWData->mPCIDeviceAssignments.begin();
6498	it != mHWData->mPCIDeviceAssignments.end();
6499	++it)
6500	{
6501	LONG iHostAddress = -1;
6502	ComPtr<PCIDeviceAttachment> pAttach;
6503	pAttach = *it;
6504	pAttach->COMGETTER(HostAddress)(&iHostAddress);
6505	if (iHostAddress == aHostAddress)
6506	return setError(E_INVALIDARG,
6507	tr("Device with host PCI address already attached to this VM"));
6508	}
6509
6510	ComObjPtr<PCIDeviceAttachment> pda;
6511	char name[32];
6512
6513	RTStrPrintf(name, sizeof(name), "host%02x:%02x.%x", (aHostAddress>>8) & 0xff,
6514	(aHostAddress & 0xf8) >> 3, aHostAddress & 7);
6515	pda.createObject();
6516	pda->init(this, name, aHostAddress, aDesiredGuestAddress, TRUE);
6517	i_setModified(IsModified_MachineData);
6518	mHWData.backup();
6519	mHWData->mPCIDeviceAssignments.push_back(pda);
6520	}
6521
6522	return S_OK;
6523	}
6524
6525	/**
6526	* Currently this method doesn't detach device from the running VM,
6527	* just makes sure it's not plugged on next VM start.
6528	*/
6529	HRESULT Machine::detachHostPCIDevice(LONG aHostAddress)
6530	{
6531	ComObjPtr<PCIDeviceAttachment> pAttach;
6532	bool fRemoved = false;
6533	HRESULT rc;
6534
6535	// lock scope
6536	{
6537	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6538
6539	rc = i_checkStateDependency(MutableStateDep);
6540	if (FAILED(rc)) return rc;
6541
6542	for (HWData::PCIDeviceAssignmentList::const_iterator
6543	it = mHWData->mPCIDeviceAssignments.begin();
6544	it != mHWData->mPCIDeviceAssignments.end();
6545	++it)
6546	{
6547	LONG iHostAddress = -1;
6548	pAttach = *it;
6549	pAttach->COMGETTER(HostAddress)(&iHostAddress);
6550	if (iHostAddress != -1 && iHostAddress == aHostAddress)
6551	{
6552	i_setModified(IsModified_MachineData);
6553	mHWData.backup();
6554	mHWData->mPCIDeviceAssignments.remove(pAttach);
6555	fRemoved = true;
6556	break;
6557	}
6558	}
6559	}
6560
6561
6562	/* Fire event outside of the lock */
6563	if (fRemoved)
6564	{
6565	Assert(!pAttach.isNull());
6566	ComPtr<IEventSource> es;
6567	rc = mParent->COMGETTER(EventSource)(es.asOutParam());
6568	Assert(SUCCEEDED(rc));
6569	Bstr mid;
6570	rc = this->COMGETTER(Id)(mid.asOutParam());
6571	Assert(SUCCEEDED(rc));
6572	::FireHostPCIDevicePlugEvent(es, mid.raw(), false /* unplugged /, true / success */, pAttach, NULL);
6573	}
6574
6575	return fRemoved ? S_OK : setError(VBOX_E_OBJECT_NOT_FOUND,
6576	tr("No host PCI device %08x attached"),
6577	aHostAddress
6578	);
6579	}
6580
6581	HRESULT Machine::getPCIDeviceAssignments(std::vector<ComPtr<IPCIDeviceAttachment> > &aPCIDeviceAssignments)
6582	{
6583	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6584
6585	aPCIDeviceAssignments.resize(mHWData->mPCIDeviceAssignments.size());
6586	size_t i = 0;
6587	for (std::list<ComObjPtr<PCIDeviceAttachment> >::const_iterator
6588	it = mHWData->mPCIDeviceAssignments.begin();
6589	it != mHWData->mPCIDeviceAssignments.end();
6590	++it, ++i)
6591	(*it).queryInterfaceTo(aPCIDeviceAssignments[i].asOutParam());
6592
6593	return S_OK;
6594	}
6595
6596	HRESULT Machine::getBandwidthControl(ComPtr<IBandwidthControl> &aBandwidthControl)
6597	{
6598	mBandwidthControl.queryInterfaceTo(aBandwidthControl.asOutParam());
6599
6600	return S_OK;
6601	}
6602
6603	HRESULT Machine::getTracingEnabled(BOOL *aTracingEnabled)
6604	{
6605	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6606
6607	*aTracingEnabled = mHWData->mDebugging.fTracingEnabled;
6608
6609	return S_OK;
6610	}
6611
6612	HRESULT Machine::setTracingEnabled(BOOL aTracingEnabled)
6613	{
6614	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6615	HRESULT hrc = i_checkStateDependency(MutableStateDep);
6616	if (SUCCEEDED(hrc))
6617	{
6618	hrc = mHWData.backupEx();
6619	if (SUCCEEDED(hrc))
6620	{
6621	i_setModified(IsModified_MachineData);
6622	mHWData->mDebugging.fTracingEnabled = aTracingEnabled != FALSE;
6623	}
6624	}
6625	return hrc;
6626	}
6627
6628	HRESULT Machine::getTracingConfig(com::Utf8Str &aTracingConfig)
6629	{
6630	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6631	aTracingConfig = mHWData->mDebugging.strTracingConfig;
6632	return S_OK;
6633	}
6634
6635	HRESULT Machine::setTracingConfig(const com::Utf8Str &aTracingConfig)
6636	{
6637	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6638	HRESULT hrc = i_checkStateDependency(MutableStateDep);
6639	if (SUCCEEDED(hrc))
6640	{
6641	hrc = mHWData.backupEx();
6642	if (SUCCEEDED(hrc))
6643	{
6644	mHWData->mDebugging.strTracingConfig = aTracingConfig;
6645	if (SUCCEEDED(hrc))
6646	i_setModified(IsModified_MachineData);
6647	}
6648	}
6649	return hrc;
6650	}
6651
6652	HRESULT Machine::getAllowTracingToAccessVM(BOOL *aAllowTracingToAccessVM)
6653	{
6654	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6655
6656	*aAllowTracingToAccessVM = mHWData->mDebugging.fAllowTracingToAccessVM;
6657
6658	return S_OK;
6659	}
6660
6661	HRESULT Machine::setAllowTracingToAccessVM(BOOL aAllowTracingToAccessVM)
6662	{
6663	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6664	HRESULT hrc = i_checkStateDependency(MutableStateDep);
6665	if (SUCCEEDED(hrc))
6666	{
6667	hrc = mHWData.backupEx();
6668	if (SUCCEEDED(hrc))
6669	{
6670	i_setModified(IsModified_MachineData);
6671	mHWData->mDebugging.fAllowTracingToAccessVM = aAllowTracingToAccessVM != FALSE;
6672	}
6673	}
6674	return hrc;
6675	}
6676
6677	HRESULT Machine::getAutostartEnabled(BOOL *aAutostartEnabled)
6678	{
6679	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6680
6681	*aAutostartEnabled = mHWData->mAutostart.fAutostartEnabled;
6682
6683	return S_OK;
6684	}
6685
6686	HRESULT Machine::setAutostartEnabled(BOOL aAutostartEnabled)
6687	{
6688	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6689
6690	HRESULT hrc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
6691	if ( SUCCEEDED(hrc)
6692	&& mHWData->mAutostart.fAutostartEnabled != !!aAutostartEnabled)
6693	{
6694	AutostartDb *autostartDb = mParent->i_getAutostartDb();
6695	int vrc;
6696
6697	if (aAutostartEnabled)
6698	vrc = autostartDb->addAutostartVM(mUserData->s.strName.c_str());
6699	else
6700	vrc = autostartDb->removeAutostartVM(mUserData->s.strName.c_str());
6701
6702	if (RT_SUCCESS(vrc))
6703	{
6704	hrc = mHWData.backupEx();
6705	if (SUCCEEDED(hrc))
6706	{
6707	i_setModified(IsModified_MachineData);
6708	mHWData->mAutostart.fAutostartEnabled = aAutostartEnabled != FALSE;
6709	}
6710	}
6711	else if (vrc == VERR_NOT_SUPPORTED)
6712	hrc = setError(VBOX_E_NOT_SUPPORTED,
6713	tr("The VM autostart feature is not supported on this platform"));
6714	else if (vrc == VERR_PATH_NOT_FOUND)
6715	hrc = setError(E_FAIL,
6716	tr("The path to the autostart database is not set"));
6717	else
6718	hrc = setError(E_UNEXPECTED,
6719	tr("%s machine '%s' to the autostart database failed with %Rrc"),
6720	aAutostartEnabled ? "Adding" : "Removing",
6721	mUserData->s.strName.c_str(), vrc);
6722	}
6723	return hrc;
6724	}
6725
6726	HRESULT Machine::getAutostartDelay(ULONG *aAutostartDelay)
6727	{
6728	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6729
6730	*aAutostartDelay = mHWData->mAutostart.uAutostartDelay;
6731
6732	return S_OK;
6733	}
6734
6735	HRESULT Machine::setAutostartDelay(ULONG aAutostartDelay)
6736	{
6737	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6738	HRESULT hrc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
6739	if (SUCCEEDED(hrc))
6740	{
6741	hrc = mHWData.backupEx();
6742	if (SUCCEEDED(hrc))
6743	{
6744	i_setModified(IsModified_MachineData);
6745	mHWData->mAutostart.uAutostartDelay = aAutostartDelay;
6746	}
6747	}
6748	return hrc;
6749	}
6750
6751	HRESULT Machine::getAutostopType(AutostopType_T *aAutostopType)
6752	{
6753	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6754
6755	*aAutostopType = mHWData->mAutostart.enmAutostopType;
6756
6757	return S_OK;
6758	}
6759
6760	HRESULT Machine::setAutostopType(AutostopType_T aAutostopType)
6761	{
6762	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6763	HRESULT hrc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
6764	if ( SUCCEEDED(hrc)
6765	&& mHWData->mAutostart.enmAutostopType != aAutostopType)
6766	{
6767	AutostartDb *autostartDb = mParent->i_getAutostartDb();
6768	int vrc;
6769
6770	if (aAutostopType != AutostopType_Disabled)
6771	vrc = autostartDb->addAutostopVM(mUserData->s.strName.c_str());
6772	else
6773	vrc = autostartDb->removeAutostopVM(mUserData->s.strName.c_str());
6774
6775	if (RT_SUCCESS(vrc))
6776	{
6777	hrc = mHWData.backupEx();
6778	if (SUCCEEDED(hrc))
6779	{
6780	i_setModified(IsModified_MachineData);
6781	mHWData->mAutostart.enmAutostopType = aAutostopType;
6782	}
6783	}
6784	else if (vrc == VERR_NOT_SUPPORTED)
6785	hrc = setError(VBOX_E_NOT_SUPPORTED,
6786	tr("The VM autostop feature is not supported on this platform"));
6787	else if (vrc == VERR_PATH_NOT_FOUND)
6788	hrc = setError(E_FAIL,
6789	tr("The path to the autostart database is not set"));
6790	else
6791	hrc = setError(E_UNEXPECTED,
6792	tr("%s machine '%s' to the autostop database failed with %Rrc"),
6793	aAutostopType != AutostopType_Disabled ? "Adding" : "Removing",
6794	mUserData->s.strName.c_str(), vrc);
6795	}
6796	return hrc;
6797	}
6798
6799	HRESULT Machine::getDefaultFrontend(com::Utf8Str &aDefaultFrontend)
6800	{
6801	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6802
6803	aDefaultFrontend = mHWData->mDefaultFrontend;
6804
6805	return S_OK;
6806	}
6807
6808	HRESULT Machine::setDefaultFrontend(const com::Utf8Str &aDefaultFrontend)
6809	{
6810	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6811	HRESULT hrc = i_checkStateDependency(MutableOrSavedStateDep);
6812	if (SUCCEEDED(hrc))
6813	{
6814	hrc = mHWData.backupEx();
6815	if (SUCCEEDED(hrc))
6816	{
6817	i_setModified(IsModified_MachineData);
6818	mHWData->mDefaultFrontend = aDefaultFrontend;
6819	}
6820	}
6821	return hrc;
6822	}
6823
6824	HRESULT Machine::getIcon(std::vector<BYTE> &aIcon)
6825	{
6826	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6827	size_t cbIcon = mUserData->s.ovIcon.size();
6828	aIcon.resize(cbIcon);
6829	if (cbIcon)
6830	memcpy(&aIcon.front(), &mUserData->s.ovIcon[0], cbIcon);
6831	return S_OK;
6832	}
6833
6834	HRESULT Machine::setIcon(const std::vector<BYTE> &aIcon)
6835	{
6836	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6837	HRESULT hrc = i_checkStateDependency(MutableOrSavedStateDep);
6838	if (SUCCEEDED(hrc))
6839	{
6840	i_setModified(IsModified_MachineData);
6841	mUserData.backup();
6842	size_t cbIcon = aIcon.size();
6843	mUserData->s.ovIcon.resize(cbIcon);
6844	if (cbIcon)
6845	memcpy(&mUserData->s.ovIcon[0], &aIcon.front(), cbIcon);
6846	}
6847	return hrc;
6848	}
6849
6850	HRESULT Machine::getUSBProxyAvailable(BOOL *aUSBProxyAvailable)
6851	{
6852	#ifdef VBOX_WITH_USB
6853	*aUSBProxyAvailable = true;
6854	#else
6855	*aUSBProxyAvailable = false;
6856	#endif
6857	return S_OK;
6858	}
6859
6860	HRESULT Machine::getVMProcessPriority(VMProcPriority_T *aVMProcessPriority)
6861	{
6862	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6863
6864	*aVMProcessPriority = mUserData->s.enmVMPriority;
6865
6866	return S_OK;
6867	}
6868
6869	HRESULT Machine::setVMProcessPriority(VMProcPriority_T aVMProcessPriority)
6870	{
6871	RT_NOREF(aVMProcessPriority);
6872	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6873	HRESULT hrc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
6874	if (SUCCEEDED(hrc))
6875	{
6876	hrc = mUserData.backupEx();
6877	if (SUCCEEDED(hrc))
6878	{
6879	i_setModified(IsModified_MachineData);
6880	mUserData->s.enmVMPriority = aVMProcessPriority;
6881	}
6882	}
6883	alock.release();
6884	if (SUCCEEDED(hrc))
6885	hrc = i_onVMProcessPriorityChange(aVMProcessPriority);
6886	return hrc;
6887	}
6888
6889	HRESULT Machine::cloneTo(const ComPtr<IMachine> &aTarget, CloneMode_T aMode, const std::vector<CloneOptions_T> &aOptions,
6890	ComPtr<IProgress> &aProgress)
6891	{
6892	ComObjPtr<Progress> pP;
6893	Progress *ppP = pP;
6894	IProgress iP = static_cast<IProgress >(ppP);
6895	IProgress **pProgress = &iP;
6896
6897	IMachine *pTarget = aTarget;
6898
6899	/* Convert the options. */
6900	RTCList<CloneOptions_T> optList;
6901	if (aOptions.size())
6902	for (size_t i = 0; i < aOptions.size(); ++i)
6903	optList.append(aOptions[i]);
6904
6905	if (optList.contains(CloneOptions_Link))
6906	{
6907	if (!i_isSnapshotMachine())
6908	return setError(E_INVALIDARG,
6909	tr("Linked clone can only be created from a snapshot"));
6910	if (aMode != CloneMode_MachineState)
6911	return setError(E_INVALIDARG,
6912	tr("Linked clone can only be created for a single machine state"));
6913	}
6914	AssertReturn(!(optList.contains(CloneOptions_KeepAllMACs) && optList.contains(CloneOptions_KeepNATMACs)), E_INVALIDARG);
6915
6916	MachineCloneVM pWorker = new MachineCloneVM(this, static_cast<Machine>(pTarget), aMode, optList);
6917
6918	HRESULT rc = pWorker->start(pProgress);
6919
6920	pP = static_cast<Progress >(pProgress);
6921	pP.queryInterfaceTo(aProgress.asOutParam());
6922
6923	return rc;
6924
6925	}
6926
6927	HRESULT Machine::moveTo(const com::Utf8Str &aTargetPath,
6928	const com::Utf8Str &aType,
6929	ComPtr<IProgress> &aProgress)
6930	{
6931	LogFlowThisFuncEnter();
6932
6933	ComObjPtr<Progress> ptrProgress;
6934	HRESULT hrc = ptrProgress.createObject();
6935	if (SUCCEEDED(hrc))
6936	{
6937	/* Initialize our worker task */
6938	MachineMoveVM *pTask = NULL;
6939	try
6940	{
6941	pTask = new MachineMoveVM(this, aTargetPath, aType, ptrProgress);
6942	}
6943	catch (std::bad_alloc &)
6944	{
6945	return E_OUTOFMEMORY;
6946	}
6947
6948	hrc = pTask->init();//no exceptions are thrown
6949
6950	if (SUCCEEDED(hrc))
6951	{
6952	hrc = pTask->createThread();
6953	pTask = NULL; /* Consumed by createThread(). */
6954	if (SUCCEEDED(hrc))
6955	ptrProgress.queryInterfaceTo(aProgress.asOutParam());
6956	else
6957	setError(hrc, tr("Failed to create a worker thread for the MachineMoveVM task"));
6958	}
6959	else
6960	delete pTask;
6961	}
6962
6963	LogFlowThisFuncLeave();
6964	return hrc;
6965
6966	}
6967
6968	HRESULT Machine::saveState(ComPtr<IProgress> &aProgress)
6969	{
6970	NOREF(aProgress);
6971	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6972
6973	// This check should always fail.
6974	HRESULT rc = i_checkStateDependency(MutableStateDep);
6975	if (FAILED(rc)) return rc;
6976
6977	AssertFailedReturn(E_NOTIMPL);
6978	}
6979
6980	HRESULT Machine::adoptSavedState(const com::Utf8Str &aSavedStateFile)
6981	{
6982	NOREF(aSavedStateFile);
6983	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6984
6985	// This check should always fail.
6986	HRESULT rc = i_checkStateDependency(MutableStateDep);
6987	if (FAILED(rc)) return rc;
6988
6989	AssertFailedReturn(E_NOTIMPL);
6990	}
6991
6992	HRESULT Machine::discardSavedState(BOOL aFRemoveFile)
6993	{
6994	NOREF(aFRemoveFile);
6995	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6996
6997	// This check should always fail.
6998	HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
6999	if (FAILED(rc)) return rc;
7000
7001	AssertFailedReturn(E_NOTIMPL);
7002	}
7003
7004	// public methods for internal purposes
7005	/////////////////////////////////////////////////////////////////////////////
7006
7007	/**
7008	* Adds the given IsModified_* flag to the dirty flags of the machine.
7009	* This must be called either during i_loadSettings or under the machine write lock.
7010	* @param fl Flag
7011	* @param fAllowStateModification If state modifications are allowed.
7012	*/
7013	void Machine::i_setModified(uint32_t fl, bool fAllowStateModification /* = true */)
7014	{
7015	mData->flModifications \|= fl;
7016	if (fAllowStateModification && i_isStateModificationAllowed())
7017	mData->mCurrentStateModified = true;
7018	}
7019
7020	/**
7021	* Adds the given IsModified_* flag to the dirty flags of the machine, taking
7022	* care of the write locking.
7023	*
7024	* @param fModification The flag to add.
7025	* @param fAllowStateModification If state modifications are allowed.
7026	*/
7027	void Machine::i_setModifiedLock(uint32_t fModification, bool fAllowStateModification /* = true */)
7028	{
7029	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7030	i_setModified(fModification, fAllowStateModification);
7031	}
7032
7033	/**
7034	* Saves the registry entry of this machine to the given configuration node.
7035	*
7036	* @param data Machine registry data.
7037	*
7038	* @note locks this object for reading.
7039	*/
7040	HRESULT Machine::i_saveRegistryEntry(settings::MachineRegistryEntry &data)
7041	{
7042	AutoLimitedCaller autoCaller(this);
7043	AssertComRCReturnRC(autoCaller.rc());
7044
7045	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7046
7047	data.uuid = mData->mUuid;
7048	data.strSettingsFile = mData->m_strConfigFile;
7049
7050	return S_OK;
7051	}
7052
7053	/**
7054	* Calculates the absolute path of the given path taking the directory of the
7055	* machine settings file as the current directory.
7056	*
7057	* @param strPath Path to calculate the absolute path for.
7058	* @param aResult Where to put the result (used only on success, can be the
7059	* same Utf8Str instance as passed in @a aPath).
7060	* @return IPRT result.
7061	*
7062	* @note Locks this object for reading.
7063	*/
7064	int Machine::i_calculateFullPath(const Utf8Str &strPath, Utf8Str &aResult)
7065	{
7066	AutoCaller autoCaller(this);
7067	AssertComRCReturn(autoCaller.rc(), Global::vboxStatusCodeFromCOM(autoCaller.rc()));
7068
7069	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7070
7071	AssertReturn(!mData->m_strConfigFileFull.isEmpty(), VERR_GENERAL_FAILURE);
7072
7073	Utf8Str strSettingsDir = mData->m_strConfigFileFull;
7074
7075	strSettingsDir.stripFilename();
7076	char szFolder[RTPATH_MAX];
7077	size_t cbFolder = sizeof(szFolder);
7078	int vrc = RTPathAbsEx(strSettingsDir.c_str(), strPath.c_str(), RTPATH_STR_F_STYLE_HOST, szFolder, &cbFolder);
7079	if (RT_SUCCESS(vrc))
7080	aResult = szFolder;
7081
7082	return vrc;
7083	}
7084
7085	/**
7086	* Copies strSource to strTarget, making it relative to the machine folder
7087	* if it is a subdirectory thereof, or simply copying it otherwise.
7088	*
7089	* @param strSource Path to evaluate and copy.
7090	* @param strTarget Buffer to receive target path.
7091	*
7092	* @note Locks this object for reading.
7093	*/
7094	void Machine::i_copyPathRelativeToMachine(const Utf8Str &strSource,
7095	Utf8Str &strTarget)
7096	{
7097	AutoCaller autoCaller(this);
7098	AssertComRCReturn(autoCaller.rc(), (void)0);
7099
7100	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7101
7102	AssertReturnVoid(!mData->m_strConfigFileFull.isEmpty());
7103	// use strTarget as a temporary buffer to hold the machine settings dir
7104	strTarget = mData->m_strConfigFileFull;
7105	strTarget.stripFilename();
7106	if (RTPathStartsWith(strSource.c_str(), strTarget.c_str()))
7107	{
7108	// is relative: then append what's left
7109	strTarget = strSource.substr(strTarget.length() + 1); // skip '/'
7110	// for empty paths (only possible for subdirs) use "." to avoid
7111	// triggering default settings for not present config attributes.
7112	if (strTarget.isEmpty())
7113	strTarget = ".";
7114	}
7115	else
7116	// is not relative: then overwrite
7117	strTarget = strSource;
7118	}
7119
7120	/**
7121	* Returns the full path to the machine's log folder in the
7122	* \a aLogFolder argument.
7123	*/
7124	void Machine::i_getLogFolder(Utf8Str &aLogFolder)
7125	{
7126	AutoCaller autoCaller(this);
7127	AssertComRCReturnVoid(autoCaller.rc());
7128
7129	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7130
7131	char szTmp[RTPATH_MAX];
7132	int vrc = RTEnvGetEx(RTENV_DEFAULT, "VBOX_USER_VMLOGDIR", szTmp, sizeof(szTmp), NULL);
7133	if (RT_SUCCESS(vrc))
7134	{
7135	if (szTmp[0] && !mUserData.isNull())
7136	{
7137	char szTmp2[RTPATH_MAX];
7138	vrc = RTPathAbs(szTmp, szTmp2, sizeof(szTmp2));
7139	if (RT_SUCCESS(vrc))
7140	aLogFolder.printf("%s%c%s",
7141	szTmp2,
7142	RTPATH_DELIMITER,
7143	mUserData->s.strName.c_str()); // path/to/logfolder/vmname
7144	}
7145	else
7146	vrc = VERR_PATH_IS_RELATIVE;
7147	}
7148
7149	if (RT_FAILURE(vrc))
7150	{
7151	// fallback if VBOX_USER_LOGHOME is not set or invalid
7152	aLogFolder = mData->m_strConfigFileFull; // path/to/machinesfolder/vmname/vmname.vbox
7153	aLogFolder.stripFilename(); // path/to/machinesfolder/vmname
7154	aLogFolder.append(RTPATH_DELIMITER);
7155	aLogFolder.append("Logs"); // path/to/machinesfolder/vmname/Logs
7156	}
7157	}
7158
7159	/**
7160	* Returns the full path to the machine's log file for an given index.
7161	*/
7162	Utf8Str Machine::i_getLogFilename(ULONG idx)
7163	{
7164	Utf8Str logFolder;
7165	getLogFolder(logFolder);
7166	Assert(logFolder.length());
7167
7168	Utf8Str log;
7169	if (idx == 0)
7170	log.printf("%s%cVBox.log", logFolder.c_str(), RTPATH_DELIMITER);
7171	#if defined(RT_OS_WINDOWS) && defined(VBOX_WITH_HARDENING)
7172	else if (idx == 1)
7173	log.printf("%s%cVBoxHardening.log", logFolder.c_str(), RTPATH_DELIMITER);
7174	else
7175	log.printf("%s%cVBox.log.%u", logFolder.c_str(), RTPATH_DELIMITER, idx - 1);
7176	#else
7177	else
7178	log.printf("%s%cVBox.log.%u", logFolder.c_str(), RTPATH_DELIMITER, idx);
7179	#endif
7180	return log;
7181	}
7182
7183	/**
7184	* Returns the full path to the machine's hardened log file.
7185	*/
7186	Utf8Str Machine::i_getHardeningLogFilename(void)
7187	{
7188	Utf8Str strFilename;
7189	getLogFolder(strFilename);
7190	Assert(strFilename.length());
7191	strFilename.append(RTPATH_SLASH_STR "VBoxHardening.log");
7192	return strFilename;
7193	}
7194
7195	/**
7196	* Returns the default NVRAM filename based on the location of the VM config.
7197	* Note that this is a relative path.
7198	*/
7199	Utf8Str Machine::i_getDefaultNVRAMFilename()
7200	{
7201	AutoCaller autoCaller(this);
7202	AssertComRCReturn(autoCaller.rc(), Utf8Str::Empty);
7203
7204	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7205
7206	if ( mHWData->mFirmwareType == FirmwareType_BIOS
7207	\|\| i_isSnapshotMachine())
7208	return Utf8Str::Empty;
7209
7210	Utf8Str strNVRAMFilePath = mData->m_strConfigFileFull;
7211	strNVRAMFilePath.stripPath();
7212	strNVRAMFilePath.stripSuffix();
7213	strNVRAMFilePath += ".nvram";
7214
7215	return strNVRAMFilePath;
7216	}
7217
7218	/**
7219	* Returns the NVRAM filename for a new snapshot. This intentionally works
7220	* similarly to the saved state file naming. Note that this is usually
7221	* a relative path, unless the snapshot folder is absolute.
7222	*/
7223	Utf8Str Machine::i_getSnapshotNVRAMFilename()
7224	{
7225	AutoCaller autoCaller(this);
7226	AssertComRCReturn(autoCaller.rc(), Utf8Str::Empty);
7227
7228	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7229
7230	if (mHWData->mFirmwareType == FirmwareType_BIOS)
7231	return Utf8Str::Empty;
7232
7233	RTTIMESPEC ts;
7234	RTTimeNow(&ts);
7235	RTTIME time;
7236	RTTimeExplode(&time, &ts);
7237
7238	Utf8Str strNVRAMFilePath = mUserData->s.strSnapshotFolder;
7239	strNVRAMFilePath += RTPATH_DELIMITER;
7240	strNVRAMFilePath.appendPrintf("%04d-%02u-%02uT%02u-%02u-%02u-%09uZ.nvram",
7241	time.i32Year, time.u8Month, time.u8MonthDay,
7242	time.u8Hour, time.u8Minute, time.u8Second, time.u32Nanosecond);
7243
7244	return strNVRAMFilePath;
7245	}
7246
7247	/**
7248	* Composes a unique saved state filename based on the current system time. The filename is
7249	* granular to the second so this will work so long as no more than one snapshot is taken on
7250	* a machine per second.
7251	*
7252	* Before version 4.1, we used this formula for saved state files:
7253	* Utf8StrFmt("%s%c{%RTuuid}.sav", strFullSnapshotFolder.c_str(), RTPATH_DELIMITER, mData->mUuid.raw())
7254	* which no longer works because saved state files can now be shared between the saved state of the
7255	* "saved" machine and an online snapshot, and the following would cause problems:
7256	* 1) save machine
7257	* 2) create online snapshot from that machine state --> reusing saved state file
7258	* 3) save machine again --> filename would be reused, breaking the online snapshot
7259	*
7260	* So instead we now use a timestamp.
7261	*
7262	* @param strStateFilePath
7263	*/
7264
7265	void Machine::i_composeSavedStateFilename(Utf8Str &strStateFilePath)
7266	{
7267	AutoCaller autoCaller(this);
7268	AssertComRCReturnVoid(autoCaller.rc());
7269
7270	{
7271	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7272	i_calculateFullPath(mUserData->s.strSnapshotFolder, strStateFilePath);
7273	}
7274
7275	RTTIMESPEC ts;
7276	RTTimeNow(&ts);
7277	RTTIME time;
7278	RTTimeExplode(&time, &ts);
7279
7280	strStateFilePath += RTPATH_DELIMITER;
7281	strStateFilePath.appendPrintf("%04d-%02u-%02uT%02u-%02u-%02u-%09uZ.sav",
7282	time.i32Year, time.u8Month, time.u8MonthDay,
7283	time.u8Hour, time.u8Minute, time.u8Second, time.u32Nanosecond);
7284	}
7285
7286	/**
7287	* Returns whether at least one USB controller is present for the VM.
7288	*/
7289	bool Machine::i_isUSBControllerPresent()
7290	{
7291	AutoCaller autoCaller(this);
7292	AssertComRCReturn(autoCaller.rc(), false);
7293
7294	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7295
7296	return (mUSBControllers->size() > 0);
7297	}
7298
7299
7300	/**
7301	* @note Locks this object for writing, calls the client process
7302	* (inside the lock).
7303	*/
7304	HRESULT Machine::i_launchVMProcess(IInternalSessionControl *aControl,
7305	const Utf8Str &strFrontend,
7306	const std::vector<com::Utf8Str> &aEnvironmentChanges,
7307	ProgressProxy *aProgress)
7308	{
7309	LogFlowThisFuncEnter();
7310
7311	AssertReturn(aControl, E_FAIL);
7312	AssertReturn(aProgress, E_FAIL);
7313	AssertReturn(!strFrontend.isEmpty(), E_FAIL);
7314
7315	AutoCaller autoCaller(this);
7316	if (FAILED(autoCaller.rc())) return autoCaller.rc();
7317
7318	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7319
7320	if (!mData->mRegistered)
7321	return setError(E_UNEXPECTED,
7322	tr("The machine '%s' is not registered"),
7323	mUserData->s.strName.c_str());
7324
7325	LogFlowThisFunc(("mSession.mState=%s\n", Global::stringifySessionState(mData->mSession.mState)));
7326
7327	/* The process started when launching a VM with separate UI/VM processes is always
7328	* the UI process, i.e. needs special handling as it won't claim the session. */
7329	bool fSeparate = strFrontend.endsWith("separate", Utf8Str::CaseInsensitive);
7330
7331	if (fSeparate)
7332	{
7333	if (mData->mSession.mState != SessionState_Unlocked && mData->mSession.mName != "headless")
7334	return setError(VBOX_E_INVALID_OBJECT_STATE,
7335	tr("The machine '%s' is in a state which is incompatible with launching a separate UI process"),
7336	mUserData->s.strName.c_str());
7337	}
7338	else
7339	{
7340	if ( mData->mSession.mState == SessionState_Locked
7341	\|\| mData->mSession.mState == SessionState_Spawning
7342	\|\| mData->mSession.mState == SessionState_Unlocking)
7343	return setError(VBOX_E_INVALID_OBJECT_STATE,
7344	tr("The machine '%s' is already locked by a session (or being locked or unlocked)"),
7345	mUserData->s.strName.c_str());
7346
7347	/* may not be busy */
7348	AssertReturn(!Global::IsOnlineOrTransient(mData->mMachineState), E_FAIL);
7349	}
7350
7351	/* Hardening logging */
7352	#if defined(RT_OS_WINDOWS) && defined(VBOX_WITH_HARDENING)
7353	Utf8Str strSupHardeningLogArg("--sup-hardening-log=");
7354	{
7355	Utf8Str strHardeningLogFile = i_getHardeningLogFilename();
7356	int vrc2 = RTFileDelete(strHardeningLogFile.c_str());
7357	if (vrc2 == VERR_PATH_NOT_FOUND \|\| vrc2 == VERR_FILE_NOT_FOUND)
7358	{
7359	Utf8Str strStartupLogDir = strHardeningLogFile;
7360	strStartupLogDir.stripFilename();
7361	RTDirCreateFullPath(strStartupLogDir.c_str(), 0755); /** @todo add a variant for creating the path to a
7362	file without stripping the file. */
7363	}
7364	strSupHardeningLogArg.append(strHardeningLogFile);
7365
7366	/* Remove legacy log filename to avoid confusion. */
7367	Utf8Str strOldStartupLogFile;
7368	getLogFolder(strOldStartupLogFile);
7369	strOldStartupLogFile.append(RTPATH_SLASH_STR "VBoxStartup.log");
7370	RTFileDelete(strOldStartupLogFile.c_str());
7371	}
7372	#else
7373	Utf8Str strSupHardeningLogArg;
7374	#endif
7375
7376	Utf8Str strAppOverride;
7377	#ifdef RT_OS_DARWIN /* Avoid Launch Services confusing this with the selector by using a helper app. */
7378	strAppOverride = i_getExtraData(Utf8Str("VBoxInternal2/VirtualBoxVMAppOverride"));
7379	#endif
7380
7381	bool fUseVBoxSDS = false;
7382	Utf8Str strCanonicalName;
7383	if (false)
7384	{ }
7385	#ifdef VBOX_WITH_QTGUI
7386	else if ( !strFrontend.compare("gui", Utf8Str::CaseInsensitive)
7387	\|\| !strFrontend.compare("GUI/Qt", Utf8Str::CaseInsensitive)
7388	\|\| !strFrontend.compare("separate", Utf8Str::CaseInsensitive)
7389	\|\| !strFrontend.compare("gui/separate", Utf8Str::CaseInsensitive)
7390	\|\| !strFrontend.compare("GUI/Qt/separate", Utf8Str::CaseInsensitive))
7391	{
7392	strCanonicalName = "GUI/Qt";
7393	fUseVBoxSDS = true;
7394	}
7395	#endif
7396	#ifdef VBOX_WITH_VBOXSDL
7397	else if ( !strFrontend.compare("sdl", Utf8Str::CaseInsensitive)
7398	\|\| !strFrontend.compare("GUI/SDL", Utf8Str::CaseInsensitive)
7399	\|\| !strFrontend.compare("sdl/separate", Utf8Str::CaseInsensitive)
7400	\|\| !strFrontend.compare("GUI/SDL/separate", Utf8Str::CaseInsensitive))
7401	{
7402	strCanonicalName = "GUI/SDL";
7403	fUseVBoxSDS = true;
7404	}
7405	#endif
7406	#ifdef VBOX_WITH_HEADLESS
7407	else if ( !strFrontend.compare("headless", Utf8Str::CaseInsensitive)
7408	\|\| !strFrontend.compare("capture", Utf8Str::CaseInsensitive)
7409	\|\| !strFrontend.compare("vrdp", Utf8Str::CaseInsensitive) /* Deprecated. Same as headless. */)
7410	{
7411	strCanonicalName = "headless";
7412	}
7413	#endif
7414	else
7415	return setError(E_INVALIDARG, tr("Invalid frontend name: '%s'"), strFrontend.c_str());
7416
7417	Utf8Str idStr = mData->mUuid.toString();
7418	Utf8Str const &strMachineName = mUserData->s.strName;
7419	RTPROCESS pid = NIL_RTPROCESS;
7420
7421	#if !defined(VBOX_WITH_SDS) \|\| !defined(RT_OS_WINDOWS)
7422	RT_NOREF(fUseVBoxSDS);
7423	#else
7424	DWORD idCallerSession = ~(DWORD)0;
7425	if (fUseVBoxSDS)
7426	{
7427	/*
7428	* The VBoxSDS should be used for process launching the VM with
7429	* GUI only if the caller and the VBoxSDS are in different Windows
7430	* sessions and the caller in the interactive one.
7431	*/
7432	fUseVBoxSDS = false;
7433
7434	/* Get windows session of the current process. The process token used
7435	due to several reasons:
7436	1. The token is absent for the current thread except someone set it
7437	for us.
7438	2. Needs to get the id of the session where the process is started.
7439	We only need to do this once, though. */
7440	static DWORD s_idCurrentSession = ~(DWORD)0;
7441	DWORD idCurrentSession = s_idCurrentSession;
7442	if (idCurrentSession == ~(DWORD)0)
7443	{
7444	HANDLE hCurrentProcessToken = NULL;
7445	if (OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY \| TOKEN_READ, &hCurrentProcessToken))
7446	{
7447	DWORD cbIgn = 0;
7448	if (GetTokenInformation(hCurrentProcessToken, TokenSessionId, &idCurrentSession, sizeof(idCurrentSession), &cbIgn))
7449	s_idCurrentSession = idCurrentSession;
7450	else
7451	{
7452	idCurrentSession = ~(DWORD)0;
7453	LogRelFunc(("GetTokenInformation/TokenSessionId on self failed: %u\n", GetLastError()));
7454	}
7455	CloseHandle(hCurrentProcessToken);
7456	}
7457	else
7458	LogRelFunc(("OpenProcessToken/self failed: %u\n", GetLastError()));
7459	}
7460
7461	/* get the caller's session */
7462	HRESULT hrc = CoImpersonateClient();
7463	if (SUCCEEDED(hrc))
7464	{
7465	HANDLE hCallerThreadToken;
7466	if (OpenThreadToken(GetCurrentThread(), TOKEN_QUERY \| TOKEN_READ,
7467	FALSE /* OpenAsSelf - for impersonation at SecurityIdentification level */,
7468	&hCallerThreadToken))
7469	{
7470	SetLastError(NO_ERROR);
7471	DWORD cbIgn = 0;
7472	if (GetTokenInformation(hCallerThreadToken, TokenSessionId, &idCallerSession, sizeof(DWORD), &cbIgn))
7473	{
7474	/* Only need to use SDS if the session ID differs: */
7475	if (idCurrentSession != idCallerSession)
7476	{
7477	fUseVBoxSDS = false;
7478
7479	/* Obtain the groups the access token belongs to so we can see if the session is interactive: */
7480	DWORD cbTokenGroups = 0;
7481	PTOKEN_GROUPS pTokenGroups = NULL;
7482	if ( !GetTokenInformation(hCallerThreadToken, TokenGroups, pTokenGroups, 0, &cbTokenGroups)
7483	&& GetLastError() == ERROR_INSUFFICIENT_BUFFER)
7484	pTokenGroups = (PTOKEN_GROUPS)RTMemTmpAllocZ(cbTokenGroups);
7485	if (GetTokenInformation(hCallerThreadToken, TokenGroups, pTokenGroups, cbTokenGroups, &cbTokenGroups))
7486	{
7487	/* Well-known interactive SID: SECURITY_INTERACTIVE_RID, S-1-5-4: */
7488	SID_IDENTIFIER_AUTHORITY sidIdNTAuthority = SECURITY_NT_AUTHORITY;
7489	PSID pInteractiveSid = NULL;
7490	if (AllocateAndInitializeSid(&sidIdNTAuthority, 1, 4, 0, 0, 0, 0, 0, 0, 0, &pInteractiveSid))
7491	{
7492	/* Iterate over the groups looking for the interactive SID: */
7493	fUseVBoxSDS = false;
7494	for (DWORD dwIndex = 0; dwIndex < pTokenGroups->GroupCount; dwIndex++)
7495	if (EqualSid(pTokenGroups->Groups[dwIndex].Sid, pInteractiveSid))
7496	{
7497	fUseVBoxSDS = true;
7498	break;
7499	}
7500	FreeSid(pInteractiveSid);
7501	}
7502	}
7503	else
7504	LogRelFunc(("GetTokenInformation/TokenGroups failed: %u\n", GetLastError()));
7505	RTMemTmpFree(pTokenGroups);
7506	}
7507	}
7508	else
7509	LogRelFunc(("GetTokenInformation/TokenSessionId failed: %u\n", GetLastError()));
7510	CloseHandle(hCallerThreadToken);
7511	}
7512	else
7513	LogRelFunc(("OpenThreadToken/client failed: %u\n", GetLastError()));
7514	CoRevertToSelf();
7515	}
7516	else
7517	LogRelFunc(("CoImpersonateClient failed: %Rhrc\n", hrc));
7518	}
7519	if (fUseVBoxSDS)
7520	{
7521	/* connect to VBoxSDS */
7522	ComPtr<IVirtualBoxSDS> pVBoxSDS;
7523	HRESULT rc = pVBoxSDS.createLocalObject(CLSID_VirtualBoxSDS);
7524	if (FAILED(rc))
7525	return setError(rc, tr("Failed to start the machine '%s'. A connection to VBoxSDS cannot be established"),
7526	strMachineName.c_str());
7527
7528	/* By default the RPC_C_IMP_LEVEL_IDENTIFY is used for impersonation the client. It allows
7529	ACL checking but restricts an access to system objects e.g. files. Call to CoSetProxyBlanket
7530	elevates the impersonation level up to RPC_C_IMP_LEVEL_IMPERSONATE allowing the VBoxSDS
7531	service to access the files. */
7532	rc = CoSetProxyBlanket(pVBoxSDS,
7533	RPC_C_AUTHN_DEFAULT,
7534	RPC_C_AUTHZ_DEFAULT,
7535	COLE_DEFAULT_PRINCIPAL,
7536	RPC_C_AUTHN_LEVEL_DEFAULT,
7537	RPC_C_IMP_LEVEL_IMPERSONATE,
7538	NULL,
7539	EOAC_DEFAULT);
7540	if (FAILED(rc))
7541	return setError(rc, tr("Failed to start the machine '%s'. CoSetProxyBlanket failed"), strMachineName.c_str());
7542
7543	size_t const cEnvVars = aEnvironmentChanges.size();
7544	com::SafeArray<IN_BSTR> aBstrEnvironmentChanges(cEnvVars);
7545	for (size_t i = 0; i < cEnvVars; i++)
7546	aBstrEnvironmentChanges[i] = Bstr(aEnvironmentChanges[i]).raw();
7547
7548	ULONG uPid = 0;
7549	rc = pVBoxSDS->LaunchVMProcess(Bstr(idStr).raw(), Bstr(strMachineName).raw(), Bstr(strFrontend).raw(),
7550	ComSafeArrayAsInParam(aBstrEnvironmentChanges), Bstr(strSupHardeningLogArg).raw(),
7551	idCallerSession, &uPid);
7552	if (FAILED(rc))
7553	return setError(rc, tr("Failed to start the machine '%s'. Process creation failed"), strMachineName.c_str());
7554	pid = (RTPROCESS)uPid;
7555	}
7556	else
7557	#endif /* VBOX_WITH_VBOXSDS && RT_OS_WINDOWS */
7558	{
7559	int vrc = MachineLaunchVMCommonWorker(idStr, strMachineName, strFrontend, aEnvironmentChanges, strSupHardeningLogArg,
7560	strAppOverride, 0 /fFlags/, NULL /pvExtraData/, pid);
7561	if (RT_FAILURE(vrc))
7562	return setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
7563	tr("Could not launch the VM process for the machine '%s' (%Rrc)"), strMachineName.c_str(), vrc);
7564	}
7565
7566	LogRel(("Launched VM: %u pid: %u (%#x) frontend: %s name: %s\n",
7567	idStr.c_str(), pid, pid, strFrontend.c_str(), strMachineName.c_str()));
7568
7569	if (!fSeparate)
7570	{
7571	/*
7572	* Note that we don't release the lock here before calling the client,
7573	* because it doesn't need to call us back if called with a NULL argument.
7574	* Releasing the lock here is dangerous because we didn't prepare the
7575	* launch data yet, but the client we've just started may happen to be
7576	* too fast and call LockMachine() that will fail (because of PID, etc.),
7577	* so that the Machine will never get out of the Spawning session state.
7578	*/
7579
7580	/* inform the session that it will be a remote one */
7581	LogFlowThisFunc(("Calling AssignMachine (NULL)...\n"));
7582	#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
7583	HRESULT rc = aControl->AssignMachine(NULL, LockType_Write, Bstr::Empty.raw());
7584	#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
7585	HRESULT rc = aControl->AssignMachine(NULL, LockType_Write, NULL);
7586	#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
7587	LogFlowThisFunc(("AssignMachine (NULL) returned %08X\n", rc));
7588
7589	if (FAILED(rc))
7590	{
7591	/* restore the session state */
7592	mData->mSession.mState = SessionState_Unlocked;
7593	alock.release();
7594	mParent->i_addProcessToReap(pid);
7595	/* The failure may occur w/o any error info (from RPC), so provide one */
7596	return setError(VBOX_E_VM_ERROR,
7597	tr("Failed to assign the machine to the session (%Rhrc)"), rc);
7598	}
7599
7600	/* attach launch data to the machine */
7601	Assert(mData->mSession.mPID == NIL_RTPROCESS);
7602	mData->mSession.mRemoteControls.push_back(aControl);
7603	mData->mSession.mProgress = aProgress;
7604	mData->mSession.mPID = pid;
7605	mData->mSession.mState = SessionState_Spawning;
7606	Assert(strCanonicalName.isNotEmpty());
7607	mData->mSession.mName = strCanonicalName;
7608	}
7609	else
7610	{
7611	/* For separate UI process we declare the launch as completed instantly, as the
7612	* actual headless VM start may or may not come. No point in remembering anything
7613	* yet, as what matters for us is when the headless VM gets started. */
7614	aProgress->i_notifyComplete(S_OK);
7615	}
7616
7617	alock.release();
7618	mParent->i_addProcessToReap(pid);
7619
7620	LogFlowThisFuncLeave();
7621	return S_OK;
7622	}
7623
7624	/**
7625	* Returns @c true if the given session machine instance has an open direct
7626	* session (and optionally also for direct sessions which are closing) and
7627	* returns the session control machine instance if so.
7628	*
7629	* Note that when the method returns @c false, the arguments remain unchanged.
7630	*
7631	* @param aMachine Session machine object.
7632	* @param aControl Direct session control object (optional).
7633	* @param aRequireVM If true then only allow VM sessions.
7634	* @param aAllowClosing If true then additionally a session which is currently
7635	* being closed will also be allowed.
7636	*
7637	* @note locks this object for reading.
7638	*/
7639	bool Machine::i_isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
7640	ComPtr<IInternalSessionControl> aControl /= NULL*/,
7641	bool aRequireVM /= false/,
7642	bool aAllowClosing /= false/)
7643	{
7644	AutoLimitedCaller autoCaller(this);
7645	AssertComRCReturn(autoCaller.rc(), false);
7646
7647	/* just return false for inaccessible machines */
7648	if (getObjectState().getState() != ObjectState::Ready)
7649	return false;
7650
7651	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7652
7653	if ( ( mData->mSession.mState == SessionState_Locked
7654	&& (!aRequireVM \|\| mData->mSession.mLockType == LockType_VM))
7655	\|\| (aAllowClosing && mData->mSession.mState == SessionState_Unlocking)
7656	)
7657	{
7658	AssertReturn(!mData->mSession.mMachine.isNull(), false);
7659
7660	aMachine = mData->mSession.mMachine;
7661
7662	if (aControl != NULL)
7663	*aControl = mData->mSession.mDirectControl;
7664
7665	return true;
7666	}
7667
7668	return false;
7669	}
7670
7671	/**
7672	* Returns @c true if the given machine has an spawning direct session.
7673	*
7674	* @note locks this object for reading.
7675	*/
7676	bool Machine::i_isSessionSpawning()
7677	{
7678	AutoLimitedCaller autoCaller(this);
7679	AssertComRCReturn(autoCaller.rc(), false);
7680
7681	/* just return false for inaccessible machines */
7682	if (getObjectState().getState() != ObjectState::Ready)
7683	return false;
7684
7685	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7686
7687	if (mData->mSession.mState == SessionState_Spawning)
7688	return true;
7689
7690	return false;
7691	}
7692
7693	/**
7694	* Called from the client watcher thread to check for unexpected client process
7695	* death during Session_Spawning state (e.g. before it successfully opened a
7696	* direct session).
7697	*
7698	* On Win32 and on OS/2, this method is called only when we've got the
7699	* direct client's process termination notification, so it always returns @c
7700	* true.
7701	*
7702	* On other platforms, this method returns @c true if the client process is
7703	* terminated and @c false if it's still alive.
7704	*
7705	* @note Locks this object for writing.
7706	*/
7707	bool Machine::i_checkForSpawnFailure()
7708	{
7709	AutoCaller autoCaller(this);
7710	if (!autoCaller.isOk())
7711	{
7712	/* nothing to do */
7713	LogFlowThisFunc(("Already uninitialized!\n"));
7714	return true;
7715	}
7716
7717	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7718
7719	if (mData->mSession.mState != SessionState_Spawning)
7720	{
7721	/* nothing to do */
7722	LogFlowThisFunc(("Not spawning any more!\n"));
7723	return true;
7724	}
7725
7726	HRESULT rc = S_OK;
7727
7728	/* PID not yet initialized, skip check. */
7729	if (mData->mSession.mPID == NIL_RTPROCESS)
7730	return false;
7731
7732	RTPROCSTATUS status;
7733	int vrc = RTProcWait(mData->mSession.mPID, RTPROCWAIT_FLAGS_NOBLOCK, &status);
7734
7735	if (vrc != VERR_PROCESS_RUNNING)
7736	{
7737	Utf8Str strExtraInfo;
7738
7739	#if defined(RT_OS_WINDOWS) && defined(VBOX_WITH_HARDENING)
7740	/* If the startup logfile exists and is of non-zero length, tell the
7741	user to look there for more details to encourage them to attach it
7742	when reporting startup issues. */
7743	Utf8Str strHardeningLogFile = i_getHardeningLogFilename();
7744	uint64_t cbStartupLogFile = 0;
7745	int vrc2 = RTFileQuerySizeByPath(strHardeningLogFile.c_str(), &cbStartupLogFile);
7746	if (RT_SUCCESS(vrc2) && cbStartupLogFile > 0)
7747	strExtraInfo.appendPrintf(tr(". More details may be available in '%s'"), strHardeningLogFile.c_str());
7748	#endif
7749
7750	if (RT_SUCCESS(vrc) && status.enmReason == RTPROCEXITREASON_NORMAL)
7751	rc = setError(E_FAIL,
7752	tr("The virtual machine '%s' has terminated unexpectedly during startup with exit code %d (%#x)%s"),
7753	i_getName().c_str(), status.iStatus, status.iStatus, strExtraInfo.c_str());
7754	else if (RT_SUCCESS(vrc) && status.enmReason == RTPROCEXITREASON_SIGNAL)
7755	rc = setError(E_FAIL,
7756	tr("The virtual machine '%s' has terminated unexpectedly during startup because of signal %d%s"),
7757	i_getName().c_str(), status.iStatus, strExtraInfo.c_str());
7758	else if (RT_SUCCESS(vrc) && status.enmReason == RTPROCEXITREASON_ABEND)
7759	rc = setError(E_FAIL,
7760	tr("The virtual machine '%s' has terminated abnormally (iStatus=%#x)%s"),
7761	i_getName().c_str(), status.iStatus, strExtraInfo.c_str());
7762	else
7763	rc = setErrorBoth(E_FAIL, vrc,
7764	tr("The virtual machine '%s' has terminated unexpectedly during startup (%Rrc)%s"),
7765	i_getName().c_str(), vrc, strExtraInfo.c_str());
7766	}
7767
7768	if (FAILED(rc))
7769	{
7770	/* Close the remote session, remove the remote control from the list
7771	* and reset session state to Closed (@note keep the code in sync with
7772	* the relevant part in LockMachine()). */
7773
7774	Assert(mData->mSession.mRemoteControls.size() == 1);
7775	if (mData->mSession.mRemoteControls.size() == 1)
7776	{
7777	ErrorInfoKeeper eik;
7778	mData->mSession.mRemoteControls.front()->Uninitialize();
7779	}
7780
7781	mData->mSession.mRemoteControls.clear();
7782	mData->mSession.mState = SessionState_Unlocked;
7783
7784	/* finalize the progress after setting the state */
7785	if (!mData->mSession.mProgress.isNull())
7786	{
7787	mData->mSession.mProgress->notifyComplete(rc);
7788	mData->mSession.mProgress.setNull();
7789	}
7790
7791	mData->mSession.mPID = NIL_RTPROCESS;
7792
7793	mParent->i_onSessionStateChanged(mData->mUuid, SessionState_Unlocked);
7794	return true;
7795	}
7796
7797	return false;
7798	}
7799
7800	/**
7801	* Checks whether the machine can be registered. If so, commits and saves
7802	* all settings.
7803	*
7804	* @note Must be called from mParent's write lock. Locks this object and
7805	* children for writing.
7806	*/
7807	HRESULT Machine::i_prepareRegister()
7808	{
7809	AssertReturn(mParent->isWriteLockOnCurrentThread(), E_FAIL);
7810
7811	AutoLimitedCaller autoCaller(this);
7812	AssertComRCReturnRC(autoCaller.rc());
7813
7814	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7815
7816	/* wait for state dependents to drop to zero */
7817	i_ensureNoStateDependencies();
7818
7819	if (!mData->mAccessible)
7820	return setError(VBOX_E_INVALID_OBJECT_STATE,
7821	tr("The machine '%s' with UUID {%s} is inaccessible and cannot be registered"),
7822	mUserData->s.strName.c_str(),
7823	mData->mUuid.toString().c_str());
7824
7825	AssertReturn(getObjectState().getState() == ObjectState::Ready, E_FAIL);
7826
7827	if (mData->mRegistered)
7828	return setError(VBOX_E_INVALID_OBJECT_STATE,
7829	tr("The machine '%s' with UUID {%s} is already registered"),
7830	mUserData->s.strName.c_str(),
7831	mData->mUuid.toString().c_str());
7832
7833	HRESULT rc = S_OK;
7834
7835	// Ensure the settings are saved. If we are going to be registered and
7836	// no config file exists yet, create it by calling i_saveSettings() too.
7837	if ( (mData->flModifications)
7838	\|\| (!mData->pMachineConfigFile->fileExists())
7839	)
7840	{
7841	rc = i_saveSettings(NULL);
7842	// no need to check whether VirtualBox.xml needs saving too since
7843	// we can't have a machine XML file rename pending
7844	if (FAILED(rc)) return rc;
7845	}
7846
7847	/* more config checking goes here */
7848
7849	if (SUCCEEDED(rc))
7850	{
7851	/* we may have had implicit modifications we want to fix on success */
7852	i_commit();
7853
7854	mData->mRegistered = true;
7855	}
7856	else
7857	{
7858	/* we may have had implicit modifications we want to cancel on failure*/
7859	i_rollback(false /* aNotify */);
7860	}
7861
7862	return rc;
7863	}
7864
7865	/**
7866	* Increases the number of objects dependent on the machine state or on the
7867	* registered state. Guarantees that these two states will not change at least
7868	* until #i_releaseStateDependency() is called.
7869	*
7870	* Depending on the @a aDepType value, additional state checks may be made.
7871	* These checks will set extended error info on failure. See
7872	* #i_checkStateDependency() for more info.
7873	*
7874	* If this method returns a failure, the dependency is not added and the caller
7875	* is not allowed to rely on any particular machine state or registration state
7876	* value and may return the failed result code to the upper level.
7877	*
7878	* @param aDepType Dependency type to add.
7879	* @param aState Current machine state (NULL if not interested).
7880	* @param aRegistered Current registered state (NULL if not interested).
7881	*
7882	* @note Locks this object for writing.
7883	*/
7884	HRESULT Machine::i_addStateDependency(StateDependency aDepType /* = AnyStateDep */,
7885	MachineState_T aState / = NULL */,
7886	BOOL aRegistered / = NULL */)
7887	{
7888	AutoCaller autoCaller(this);
7889	AssertComRCReturnRC(autoCaller.rc());
7890
7891	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7892
7893	HRESULT rc = i_checkStateDependency(aDepType);
7894	if (FAILED(rc)) return rc;
7895
7896	{
7897	if (mData->mMachineStateChangePending != 0)
7898	{
7899	/* i_ensureNoStateDependencies() is waiting for state dependencies to
7900	* drop to zero so don't add more. It may make sense to wait a bit
7901	* and retry before reporting an error (since the pending state
7902	* transition should be really quick) but let's just assert for
7903	* now to see if it ever happens on practice. */
7904
7905	AssertFailed();
7906
7907	return setError(E_ACCESSDENIED,
7908	tr("Machine state change is in progress. Please retry the operation later."));
7909	}
7910
7911	++mData->mMachineStateDeps;
7912	Assert(mData->mMachineStateDeps != 0 /* overflow */);
7913	}
7914
7915	if (aState)
7916	*aState = mData->mMachineState;
7917	if (aRegistered)
7918	*aRegistered = mData->mRegistered;
7919
7920	return S_OK;
7921	}
7922
7923	/**
7924	* Decreases the number of objects dependent on the machine state.
7925	* Must always complete the #i_addStateDependency() call after the state
7926	* dependency is no more necessary.
7927	*/
7928	void Machine::i_releaseStateDependency()
7929	{
7930	AutoCaller autoCaller(this);
7931	AssertComRCReturnVoid(autoCaller.rc());
7932
7933	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7934
7935	/* releaseStateDependency() w/o addStateDependency()? */
7936	AssertReturnVoid(mData->mMachineStateDeps != 0);
7937	-- mData->mMachineStateDeps;
7938
7939	if (mData->mMachineStateDeps == 0)
7940	{
7941	/* inform i_ensureNoStateDependencies() that there are no more deps */
7942	if (mData->mMachineStateChangePending != 0)
7943	{
7944	Assert(mData->mMachineStateDepsSem != NIL_RTSEMEVENTMULTI);
7945	RTSemEventMultiSignal (mData->mMachineStateDepsSem);
7946	}
7947	}
7948	}
7949
7950	Utf8Str Machine::i_getExtraData(const Utf8Str &strKey)
7951	{
7952	/* start with nothing found */
7953	Utf8Str strResult("");
7954
7955	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7956
7957	settings::StringsMap::const_iterator it = mData->pMachineConfigFile->mapExtraDataItems.find(strKey);
7958	if (it != mData->pMachineConfigFile->mapExtraDataItems.end())
7959	// found:
7960	strResult = it->second; // source is a Utf8Str
7961
7962	return strResult;
7963	}
7964
7965	// protected methods
7966	/////////////////////////////////////////////////////////////////////////////
7967
7968	/**
7969	* Performs machine state checks based on the @a aDepType value. If a check
7970	* fails, this method will set extended error info, otherwise it will return
7971	* S_OK. It is supposed, that on failure, the caller will immediately return
7972	* the return value of this method to the upper level.
7973	*
7974	* When @a aDepType is AnyStateDep, this method always returns S_OK.
7975	*
7976	* When @a aDepType is MutableStateDep, this method returns S_OK only if the
7977	* current state of this machine object allows to change settings of the
7978	* machine (i.e. the machine is not registered, or registered but not running
7979	* and not saved). It is useful to call this method from Machine setters
7980	* before performing any change.
7981	*
7982	* When @a aDepType is MutableOrSavedStateDep, this method behaves the same
7983	* as for MutableStateDep except that if the machine is saved, S_OK is also
7984	* returned. This is useful in setters which allow changing machine
7985	* properties when it is in the saved state.
7986	*
7987	* When @a aDepType is MutableOrRunningStateDep, this method returns S_OK only
7988	* if the current state of this machine object allows to change runtime
7989	* changeable settings of the machine (i.e. the machine is not registered, or
7990	* registered but either running or not running and not saved). It is useful
7991	* to call this method from Machine setters before performing any changes to
7992	* runtime changeable settings.
7993	*
7994	* When @a aDepType is MutableOrSavedOrRunningStateDep, this method behaves
7995	* the same as for MutableOrRunningStateDep except that if the machine is
7996	* saved, S_OK is also returned. This is useful in setters which allow
7997	* changing runtime and saved state changeable machine properties.
7998	*
7999	* @param aDepType Dependency type to check.
8000	*
8001	* @note Non Machine based classes should use #i_addStateDependency() and
8002	* #i_releaseStateDependency() methods or the smart AutoStateDependency
8003	* template.
8004	*
8005	* @note This method must be called from under this object's read or write
8006	* lock.
8007	*/
8008	HRESULT Machine::i_checkStateDependency(StateDependency aDepType)
8009	{
8010	switch (aDepType)
8011	{
8012	case AnyStateDep:
8013	{
8014	break;
8015	}
8016	case MutableStateDep:
8017	{
8018	if ( mData->mRegistered
8019	&& ( !i_isSessionMachine()
8020	\|\| ( mData->mMachineState != MachineState_Aborted
8021	&& mData->mMachineState != MachineState_Teleported
8022	&& mData->mMachineState != MachineState_PoweredOff
8023	)
8024	)
8025	)
8026	return setError(VBOX_E_INVALID_VM_STATE,
8027	tr("The machine is not mutable (state is %s)"),
8028	Global::stringifyMachineState(mData->mMachineState));
8029	break;
8030	}
8031	case MutableOrSavedStateDep:
8032	{
8033	if ( mData->mRegistered
8034	&& ( !i_isSessionMachine()
8035	\|\| ( mData->mMachineState != MachineState_Aborted
8036	&& mData->mMachineState != MachineState_Teleported
8037	&& mData->mMachineState != MachineState_Saved
8038	&& mData->mMachineState != MachineState_PoweredOff
8039	)
8040	)
8041	)
8042	return setError(VBOX_E_INVALID_VM_STATE,
8043	tr("The machine is not mutable or saved (state is %s)"),
8044	Global::stringifyMachineState(mData->mMachineState));
8045	break;
8046	}
8047	case MutableOrRunningStateDep:
8048	{
8049	if ( mData->mRegistered
8050	&& ( !i_isSessionMachine()
8051	\|\| ( mData->mMachineState != MachineState_Aborted
8052	&& mData->mMachineState != MachineState_Teleported
8053	&& mData->mMachineState != MachineState_PoweredOff
8054	&& !Global::IsOnline(mData->mMachineState)
8055	)
8056	)
8057	)
8058	return setError(VBOX_E_INVALID_VM_STATE,
8059	tr("The machine is not mutable or running (state is %s)"),
8060	Global::stringifyMachineState(mData->mMachineState));
8061	break;
8062	}
8063	case MutableOrSavedOrRunningStateDep:
8064	{
8065	if ( mData->mRegistered
8066	&& ( !i_isSessionMachine()
8067	\|\| ( mData->mMachineState != MachineState_Aborted
8068	&& mData->mMachineState != MachineState_Teleported
8069	&& mData->mMachineState != MachineState_Saved
8070	&& mData->mMachineState != MachineState_PoweredOff
8071	&& !Global::IsOnline(mData->mMachineState)
8072	)
8073	)
8074	)
8075	return setError(VBOX_E_INVALID_VM_STATE,
8076	tr("The machine is not mutable, saved or running (state is %s)"),
8077	Global::stringifyMachineState(mData->mMachineState));
8078	break;
8079	}
8080	}
8081
8082	return S_OK;
8083	}
8084
8085	/**
8086	* Helper to initialize all associated child objects and allocate data
8087	* structures.
8088	*
8089	* This method must be called as a part of the object's initialization procedure
8090	* (usually done in the #init() method).
8091	*
8092	* @note Must be called only from #init() or from #i_registeredInit().
8093	*/
8094	HRESULT Machine::initDataAndChildObjects()
8095	{
8096	AutoCaller autoCaller(this);
8097	AssertComRCReturnRC(autoCaller.rc());
8098	AssertComRCReturn( getObjectState().getState() == ObjectState::InInit
8099	\|\| getObjectState().getState() == ObjectState::Limited, E_FAIL);
8100
8101	AssertReturn(!mData->mAccessible, E_FAIL);
8102
8103	/* allocate data structures */
8104	mSSData.allocate();
8105	mUserData.allocate();
8106	mHWData.allocate();
8107	mMediumAttachments.allocate();
8108	mStorageControllers.allocate();
8109	mUSBControllers.allocate();
8110
8111	/* initialize mOSTypeId */
8112	mUserData->s.strOsType = mParent->i_getUnknownOSType()->i_id();
8113
8114	/** @todo r=bird: init() methods never fails, right? Why don't we make them
8115	* return void then! */
8116
8117	/* create associated BIOS settings object */
8118	unconst(mBIOSSettings).createObject();
8119	mBIOSSettings->init(this);
8120
8121	/* create associated record settings object */
8122	unconst(mRecordingSettings).createObject();
8123	mRecordingSettings->init(this);
8124
8125	/* create the graphics adapter object (always present) */
8126	unconst(mGraphicsAdapter).createObject();
8127	mGraphicsAdapter->init(this);
8128
8129	/* create an associated VRDE object (default is disabled) */
8130	unconst(mVRDEServer).createObject();
8131	mVRDEServer->init(this);
8132
8133	/* create associated serial port objects */
8134	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
8135	{
8136	unconst(mSerialPorts[slot]).createObject();
8137	mSerialPorts[slot]->init(this, slot);
8138	}
8139
8140	/* create associated parallel port objects */
8141	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
8142	{
8143	unconst(mParallelPorts[slot]).createObject();
8144	mParallelPorts[slot]->init(this, slot);
8145	}
8146
8147	/* create the audio adapter object (always present, default is disabled) */
8148	unconst(mAudioAdapter).createObject();
8149	mAudioAdapter->init(this);
8150
8151	/* create the USB device filters object (always present) */
8152	unconst(mUSBDeviceFilters).createObject();
8153	mUSBDeviceFilters->init(this);
8154
8155	/* create associated network adapter objects */
8156	mNetworkAdapters.resize(Global::getMaxNetworkAdapters(mHWData->mChipsetType));
8157	for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
8158	{
8159	unconst(mNetworkAdapters[slot]).createObject();
8160	mNetworkAdapters[slot]->init(this, slot);
8161	}
8162
8163	/* create the bandwidth control */
8164	unconst(mBandwidthControl).createObject();
8165	mBandwidthControl->init(this);
8166
8167	return S_OK;
8168	}
8169
8170	/**
8171	* Helper to uninitialize all associated child objects and to free all data
8172	* structures.
8173	*
8174	* This method must be called as a part of the object's uninitialization
8175	* procedure (usually done in the #uninit() method).
8176	*
8177	* @note Must be called only from #uninit() or from #i_registeredInit().
8178	*/
8179	void Machine::uninitDataAndChildObjects()
8180	{
8181	AutoCaller autoCaller(this);
8182	AssertComRCReturnVoid(autoCaller.rc());
8183	AssertComRCReturnVoid( getObjectState().getState() == ObjectState::InUninit
8184	\|\| getObjectState().getState() == ObjectState::Limited);
8185
8186	/* tell all our other child objects we've been uninitialized */
8187	if (mBandwidthControl)
8188	{
8189	mBandwidthControl->uninit();
8190	unconst(mBandwidthControl).setNull();
8191	}
8192
8193	for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
8194	{
8195	if (mNetworkAdapters[slot])
8196	{
8197	mNetworkAdapters[slot]->uninit();
8198	unconst(mNetworkAdapters[slot]).setNull();
8199	}
8200	}
8201
8202	if (mUSBDeviceFilters)
8203	{
8204	mUSBDeviceFilters->uninit();
8205	unconst(mUSBDeviceFilters).setNull();
8206	}
8207
8208	if (mAudioAdapter)
8209	{
8210	mAudioAdapter->uninit();
8211	unconst(mAudioAdapter).setNull();
8212	}
8213
8214	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
8215	{
8216	if (mParallelPorts[slot])
8217	{
8218	mParallelPorts[slot]->uninit();
8219	unconst(mParallelPorts[slot]).setNull();
8220	}
8221	}
8222
8223	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
8224	{
8225	if (mSerialPorts[slot])
8226	{
8227	mSerialPorts[slot]->uninit();
8228	unconst(mSerialPorts[slot]).setNull();
8229	}
8230	}
8231
8232	if (mVRDEServer)
8233	{
8234	mVRDEServer->uninit();
8235	unconst(mVRDEServer).setNull();
8236	}
8237
8238	if (mGraphicsAdapter)
8239	{
8240	mGraphicsAdapter->uninit();
8241	unconst(mGraphicsAdapter).setNull();
8242	}
8243
8244	if (mBIOSSettings)
8245	{
8246	mBIOSSettings->uninit();
8247	unconst(mBIOSSettings).setNull();
8248	}
8249
8250	if (mRecordingSettings)
8251	{
8252	mRecordingSettings->uninit();
8253	unconst(mRecordingSettings).setNull();
8254	}
8255
8256	/* Deassociate media (only when a real Machine or a SnapshotMachine
8257	* instance is uninitialized; SessionMachine instances refer to real
8258	* Machine media). This is necessary for a clean re-initialization of
8259	* the VM after successfully re-checking the accessibility state. Note
8260	* that in case of normal Machine or SnapshotMachine uninitialization (as
8261	* a result of unregistering or deleting the snapshot), outdated media
8262	* attachments will already be uninitialized and deleted, so this
8263	* code will not affect them. */
8264	if ( !mMediumAttachments.isNull()
8265	&& !i_isSessionMachine()
8266	)
8267	{
8268	for (MediumAttachmentList::const_iterator
8269	it = mMediumAttachments->begin();
8270	it != mMediumAttachments->end();
8271	++it)
8272	{
8273	ComObjPtr<Medium> pMedium = (*it)->i_getMedium();
8274	if (pMedium.isNull())
8275	continue;
8276	HRESULT rc = pMedium->i_removeBackReference(mData->mUuid, i_getSnapshotId());
8277	AssertComRC(rc);
8278	}
8279	}
8280
8281	if (!i_isSessionMachine() && !i_isSnapshotMachine())
8282	{
8283	// clean up the snapshots list (Snapshot::uninit() will handle the snapshot's children recursively)
8284	if (mData->mFirstSnapshot)
8285	{
8286	// snapshots tree is protected by machine write lock; strictly
8287	// this isn't necessary here since we're deleting the entire
8288	// machine, but otherwise we assert in Snapshot::uninit()
8289	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
8290	mData->mFirstSnapshot->uninit();
8291	mData->mFirstSnapshot.setNull();
8292	}
8293
8294	mData->mCurrentSnapshot.setNull();
8295	}
8296
8297	/* free data structures (the essential mData structure is not freed here
8298	* since it may be still in use) */
8299	mMediumAttachments.free();
8300	mStorageControllers.free();
8301	mUSBControllers.free();
8302	mHWData.free();
8303	mUserData.free();
8304	mSSData.free();
8305	}
8306
8307	/**
8308	* Returns a pointer to the Machine object for this machine that acts like a
8309	* parent for complex machine data objects such as shared folders, etc.
8310	*
8311	* For primary Machine objects and for SnapshotMachine objects, returns this
8312	* object's pointer itself. For SessionMachine objects, returns the peer
8313	* (primary) machine pointer.
8314	*/
8315	Machine *Machine::i_getMachine()
8316	{
8317	if (i_isSessionMachine())
8318	return (Machine*)mPeer;
8319	return this;
8320	}
8321
8322	/**
8323	* Makes sure that there are no machine state dependents. If necessary, waits
8324	* for the number of dependents to drop to zero.
8325	*
8326	* Make sure this method is called from under this object's write lock to
8327	* guarantee that no new dependents may be added when this method returns
8328	* control to the caller.
8329	*
8330	* @note Locks this object for writing. The lock will be released while waiting
8331	* (if necessary).
8332	*
8333	* @warning To be used only in methods that change the machine state!
8334	*/
8335	void Machine::i_ensureNoStateDependencies()
8336	{
8337	AssertReturnVoid(isWriteLockOnCurrentThread());
8338
8339	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
8340
8341	/* Wait for all state dependents if necessary */
8342	if (mData->mMachineStateDeps != 0)
8343	{
8344	/* lazy semaphore creation */
8345	if (mData->mMachineStateDepsSem == NIL_RTSEMEVENTMULTI)
8346	RTSemEventMultiCreate(&mData->mMachineStateDepsSem);
8347
8348	LogFlowThisFunc(("Waiting for state deps (%d) to drop to zero...\n",
8349	mData->mMachineStateDeps));
8350
8351	++mData->mMachineStateChangePending;
8352
8353	/* reset the semaphore before waiting, the last dependent will signal
8354	* it */
8355	RTSemEventMultiReset(mData->mMachineStateDepsSem);
8356
8357	alock.release();
8358
8359	RTSemEventMultiWait(mData->mMachineStateDepsSem, RT_INDEFINITE_WAIT);
8360
8361	alock.acquire();
8362
8363	-- mData->mMachineStateChangePending;
8364	}
8365	}
8366
8367	/**
8368	* Changes the machine state and informs callbacks.
8369	*
8370	* This method is not intended to fail so it either returns S_OK or asserts (and
8371	* returns a failure).
8372	*
8373	* @note Locks this object for writing.
8374	*/
8375	HRESULT Machine::i_setMachineState(MachineState_T aMachineState)
8376	{
8377	LogFlowThisFuncEnter();
8378	LogFlowThisFunc(("aMachineState=%s\n", Global::stringifyMachineState(aMachineState) ));
8379	Assert(aMachineState != MachineState_Null);
8380
8381	AutoCaller autoCaller(this);
8382	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
8383
8384	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
8385
8386	/* wait for state dependents to drop to zero */
8387	i_ensureNoStateDependencies();
8388
8389	MachineState_T const enmOldState = mData->mMachineState;
8390	if (enmOldState != aMachineState)
8391	{
8392	mData->mMachineState = aMachineState;
8393	RTTimeNow(&mData->mLastStateChange);
8394
8395	#ifdef VBOX_WITH_DTRACE_R3_MAIN
8396	VBOXAPI_MACHINE_STATE_CHANGED(this, aMachineState, enmOldState, mData->mUuid.toStringCurly().c_str());
8397	#endif
8398	mParent->i_onMachineStateChanged(mData->mUuid, aMachineState);
8399	}
8400
8401	LogFlowThisFuncLeave();
8402	return S_OK;
8403	}
8404
8405	/**
8406	* Searches for a shared folder with the given logical name
8407	* in the collection of shared folders.
8408	*
8409	* @param aName logical name of the shared folder
8410	* @param aSharedFolder where to return the found object
8411	* @param aSetError whether to set the error info if the folder is
8412	* not found
8413	* @return
8414	* S_OK when found or VBOX_E_OBJECT_NOT_FOUND when not found
8415	*
8416	* @note
8417	* must be called from under the object's lock!
8418	*/
8419	HRESULT Machine::i_findSharedFolder(const Utf8Str &aName,
8420	ComObjPtr<SharedFolder> &aSharedFolder,
8421	bool aSetError /* = false */)
8422	{
8423	HRESULT rc = VBOX_E_OBJECT_NOT_FOUND;
8424	for (HWData::SharedFolderList::const_iterator
8425	it = mHWData->mSharedFolders.begin();
8426	it != mHWData->mSharedFolders.end();
8427	++it)
8428	{
8429	SharedFolder pSF = it;
8430	AutoCaller autoCaller(pSF);
8431	if (pSF->i_getName() == aName)
8432	{
8433	aSharedFolder = pSF;
8434	rc = S_OK;
8435	break;
8436	}
8437	}
8438
8439	if (aSetError && FAILED(rc))
8440	setError(rc, tr("Could not find a shared folder named '%s'"), aName.c_str());
8441
8442	return rc;
8443	}
8444
8445	/**
8446	* Initializes all machine instance data from the given settings structures
8447	* from XML. The exception is the machine UUID which needs special handling
8448	* depending on the caller's use case, so the caller needs to set that herself.
8449	*
8450	* This gets called in several contexts during machine initialization:
8451	*
8452	* -- When machine XML exists on disk already and needs to be loaded into memory,
8453	* for example, from #i_registeredInit() to load all registered machines on
8454	* VirtualBox startup. In this case, puuidRegistry is NULL because the media
8455	* attached to the machine should be part of some media registry already.
8456	*
8457	* -- During OVF import, when a machine config has been constructed from an
8458	* OVF file. In this case, puuidRegistry is set to the machine UUID to
8459	* ensure that the media listed as attachments in the config (which have
8460	* been imported from the OVF) receive the correct registry ID.
8461	*
8462	* -- During VM cloning.
8463	*
8464	* @param config Machine settings from XML.
8465	* @param puuidRegistry If != NULL, Medium::setRegistryIdIfFirst() gets called with this registry ID
8466	* for each attached medium in the config.
8467	* @return
8468	*/
8469	HRESULT Machine::i_loadMachineDataFromSettings(const settings::MachineConfigFile &config,
8470	const Guid *puuidRegistry)
8471	{
8472	// copy name, description, OS type, teleporter, UTC etc.
8473	mUserData->s = config.machineUserData;
8474
8475	// look up the object by Id to check it is valid
8476	ComObjPtr<GuestOSType> pGuestOSType;
8477	mParent->i_findGuestOSType(mUserData->s.strOsType, pGuestOSType);
8478	if (!pGuestOSType.isNull())
8479	mUserData->s.strOsType = pGuestOSType->i_id();
8480
8481	// stateFile (optional)
8482	if (config.strStateFile.isEmpty())
8483	mSSData->strStateFilePath.setNull();
8484	else
8485	{
8486	Utf8Str stateFilePathFull(config.strStateFile);
8487	int vrc = i_calculateFullPath(stateFilePathFull, stateFilePathFull);
8488	if (RT_FAILURE(vrc))
8489	return setErrorBoth(E_FAIL, vrc,
8490	tr("Invalid saved state file path '%s' (%Rrc)"),
8491	config.strStateFile.c_str(),
8492	vrc);
8493	mSSData->strStateFilePath = stateFilePathFull;
8494	}
8495
8496	// snapshot folder needs special processing so set it again
8497	HRESULT rc = COMSETTER(SnapshotFolder)(Bstr(config.machineUserData.strSnapshotFolder).raw());
8498	if (FAILED(rc)) return rc;
8499
8500	/* Copy the extra data items (config may or may not be the same as
8501	* mData->pMachineConfigFile) if necessary. When loading the XML files
8502	* from disk they are the same, but not for OVF import. */
8503	if (mData->pMachineConfigFile != &config)
8504	mData->pMachineConfigFile->mapExtraDataItems = config.mapExtraDataItems;
8505
8506	/* currentStateModified (optional, default is true) */
8507	mData->mCurrentStateModified = config.fCurrentStateModified;
8508
8509	mData->mLastStateChange = config.timeLastStateChange;
8510
8511	/*
8512	* note: all mUserData members must be assigned prior this point because
8513	* we need to commit changes in order to let mUserData be shared by all
8514	* snapshot machine instances.
8515	*/
8516	mUserData.commitCopy();
8517
8518	// machine registry, if present (must be loaded before snapshots)
8519	if (config.canHaveOwnMediaRegistry())
8520	{
8521	// determine machine folder
8522	Utf8Str strMachineFolder = i_getSettingsFileFull();
8523	strMachineFolder.stripFilename();
8524	rc = mParent->initMedia(i_getId(), // media registry ID == machine UUID
8525	config.mediaRegistry,
8526	strMachineFolder);
8527	if (FAILED(rc)) return rc;
8528	}
8529
8530	/* Snapshot node (optional) */
8531	size_t cRootSnapshots;
8532	if ((cRootSnapshots = config.llFirstSnapshot.size()))
8533	{
8534	// there must be only one root snapshot
8535	Assert(cRootSnapshots == 1);
8536
8537	const settings::Snapshot &snap = config.llFirstSnapshot.front();
8538
8539	rc = i_loadSnapshot(snap,
8540	config.uuidCurrentSnapshot,
8541	NULL); // no parent == first snapshot
8542	if (FAILED(rc)) return rc;
8543	}
8544
8545	// hardware data
8546	rc = i_loadHardware(puuidRegistry, NULL, config.hardwareMachine, &config.debugging, &config.autostart);
8547	if (FAILED(rc)) return rc;
8548
8549	/*
8550	* NOTE: the assignment below must be the last thing to do,
8551	* otherwise it will be not possible to change the settings
8552	* somewhere in the code above because all setters will be
8553	* blocked by i_checkStateDependency(MutableStateDep).
8554	*/
8555
8556	/* set the machine state to Aborted or Saved when appropriate */
8557	if (config.fAborted)
8558	{
8559	mSSData->strStateFilePath.setNull();
8560
8561	/* no need to use i_setMachineState() during init() */
8562	mData->mMachineState = MachineState_Aborted;
8563	}
8564	else if (!mSSData->strStateFilePath.isEmpty())
8565	{
8566	/* no need to use i_setMachineState() during init() */
8567	mData->mMachineState = MachineState_Saved;
8568	}
8569
8570	// after loading settings, we are no longer different from the XML on disk
8571	mData->flModifications = 0;
8572
8573	return S_OK;
8574	}
8575
8576	/**
8577	* Recursively loads all snapshots starting from the given.
8578	*
8579	* @param data snapshot settings.
8580	* @param aCurSnapshotId Current snapshot ID from the settings file.
8581	* @param aParentSnapshot Parent snapshot.
8582	*/
8583	HRESULT Machine::i_loadSnapshot(const settings::Snapshot &data,
8584	const Guid &aCurSnapshotId,
8585	Snapshot *aParentSnapshot)
8586	{
8587	AssertReturn(!i_isSnapshotMachine(), E_FAIL);
8588	AssertReturn(!i_isSessionMachine(), E_FAIL);
8589
8590	HRESULT rc = S_OK;
8591
8592	Utf8Str strStateFile;
8593	if (!data.strStateFile.isEmpty())
8594	{
8595	/* optional */
8596	strStateFile = data.strStateFile;
8597	int vrc = i_calculateFullPath(strStateFile, strStateFile);
8598	if (RT_FAILURE(vrc))
8599	return setErrorBoth(E_FAIL, vrc,
8600	tr("Invalid saved state file path '%s' (%Rrc)"),
8601	strStateFile.c_str(),
8602	vrc);
8603	}
8604
8605	/* create a snapshot machine object */
8606	ComObjPtr<SnapshotMachine> pSnapshotMachine;
8607	pSnapshotMachine.createObject();
8608	rc = pSnapshotMachine->initFromSettings(this,
8609	data.hardware,
8610	&data.debugging,
8611	&data.autostart,
8612	data.uuid.ref(),
8613	strStateFile);
8614	if (FAILED(rc)) return rc;
8615
8616	/* create a snapshot object */
8617	ComObjPtr<Snapshot> pSnapshot;
8618	pSnapshot.createObject();
8619	/* initialize the snapshot */
8620	rc = pSnapshot->init(mParent, // VirtualBox object
8621	data.uuid,
8622	data.strName,
8623	data.strDescription,
8624	data.timestamp,
8625	pSnapshotMachine,
8626	aParentSnapshot);
8627	if (FAILED(rc)) return rc;
8628
8629	/* memorize the first snapshot if necessary */
8630	if (!mData->mFirstSnapshot)
8631	mData->mFirstSnapshot = pSnapshot;
8632
8633	/* memorize the current snapshot when appropriate */
8634	if ( !mData->mCurrentSnapshot
8635	&& pSnapshot->i_getId() == aCurSnapshotId
8636	)
8637	mData->mCurrentSnapshot = pSnapshot;
8638
8639	// now create the children
8640	for (settings::SnapshotsList::const_iterator
8641	it = data.llChildSnapshots.begin();
8642	it != data.llChildSnapshots.end();
8643	++it)
8644	{
8645	const settings::Snapshot &childData = *it;
8646	// recurse
8647	rc = i_loadSnapshot(childData,
8648	aCurSnapshotId,
8649	pSnapshot); // parent = the one we created above
8650	if (FAILED(rc)) return rc;
8651	}
8652
8653	return rc;
8654	}
8655
8656	/**
8657	* Loads settings into mHWData.
8658	*
8659	* @param puuidRegistry Registry ID.
8660	* @param puuidSnapshot Snapshot ID
8661	* @param data Reference to the hardware settings.
8662	* @param pDbg Pointer to the debugging settings.
8663	* @param pAutostart Pointer to the autostart settings.
8664	*/
8665	HRESULT Machine::i_loadHardware(const Guid *puuidRegistry,
8666	const Guid *puuidSnapshot,
8667	const settings::Hardware &data,
8668	const settings::Debugging *pDbg,
8669	const settings::Autostart *pAutostart)
8670	{
8671	AssertReturn(!i_isSessionMachine(), E_FAIL);
8672
8673	HRESULT rc = S_OK;
8674
8675	try
8676	{
8677	ComObjPtr<GuestOSType> pGuestOSType;
8678	mParent->i_findGuestOSType(mUserData->s.strOsType, pGuestOSType);
8679
8680	/* The hardware version attribute (optional). */
8681	mHWData->mHWVersion = data.strVersion;
8682	mHWData->mHardwareUUID = data.uuid;
8683
8684	mHWData->mHWVirtExEnabled = data.fHardwareVirt;
8685	mHWData->mHWVirtExNestedPagingEnabled = data.fNestedPaging;
8686	mHWData->mHWVirtExLargePagesEnabled = data.fLargePages;
8687	mHWData->mHWVirtExVPIDEnabled = data.fVPID;
8688	mHWData->mHWVirtExUXEnabled = data.fUnrestrictedExecution;
8689	mHWData->mHWVirtExForceEnabled = data.fHardwareVirtForce;
8690	mHWData->mHWVirtExUseNativeApi = data.fUseNativeApi;
8691	mHWData->mHWVirtExVirtVmsaveVmload = data.fVirtVmsaveVmload;
8692	mHWData->mPAEEnabled = data.fPAE;
8693	mHWData->mLongMode = data.enmLongMode;
8694	mHWData->mTripleFaultReset = data.fTripleFaultReset;
8695	mHWData->mAPIC = data.fAPIC;
8696	mHWData->mX2APIC = data.fX2APIC;
8697	mHWData->mIBPBOnVMExit = data.fIBPBOnVMExit;
8698	mHWData->mIBPBOnVMEntry = data.fIBPBOnVMEntry;
8699	mHWData->mSpecCtrl = data.fSpecCtrl;
8700	mHWData->mSpecCtrlByHost = data.fSpecCtrlByHost;
8701	mHWData->mL1DFlushOnSched = data.fL1DFlushOnSched;
8702	mHWData->mL1DFlushOnVMEntry = data.fL1DFlushOnVMEntry;
8703	mHWData->mMDSClearOnSched = data.fMDSClearOnSched;
8704	mHWData->mMDSClearOnVMEntry = data.fMDSClearOnVMEntry;
8705	mHWData->mNestedHWVirt = data.fNestedHWVirt;
8706	mHWData->mCPUCount = data.cCPUs;
8707	mHWData->mCPUHotPlugEnabled = data.fCpuHotPlug;
8708	mHWData->mCpuExecutionCap = data.ulCpuExecutionCap;
8709	mHWData->mCpuIdPortabilityLevel = data.uCpuIdPortabilityLevel;
8710	mHWData->mCpuProfile = data.strCpuProfile;
8711
8712	// cpu
8713	if (mHWData->mCPUHotPlugEnabled)
8714	{
8715	for (settings::CpuList::const_iterator
8716	it = data.llCpus.begin();
8717	it != data.llCpus.end();
8718	++it)
8719	{
8720	const settings::Cpu &cpu = *it;
8721
8722	mHWData->mCPUAttached[cpu.ulId] = true;
8723	}
8724	}
8725
8726	// cpuid leafs
8727	for (settings::CpuIdLeafsList::const_iterator
8728	it = data.llCpuIdLeafs.begin();
8729	it != data.llCpuIdLeafs.end();
8730	++it)
8731	{
8732	const settings::CpuIdLeaf &rLeaf= *it;
8733	if ( rLeaf.idx < UINT32_C(0x20)
8734	\|\| rLeaf.idx - UINT32_C(0x80000000) < UINT32_C(0x20)
8735	\|\| rLeaf.idx - UINT32_C(0xc0000000) < UINT32_C(0x10) )
8736	mHWData->mCpuIdLeafList.push_back(rLeaf);
8737	/* else: just ignore */
8738	}
8739
8740	mHWData->mMemorySize = data.ulMemorySizeMB;
8741	mHWData->mPageFusionEnabled = data.fPageFusionEnabled;
8742
8743	// boot order
8744	for (unsigned i = 0; i < RT_ELEMENTS(mHWData->mBootOrder); ++i)
8745	{
8746	settings::BootOrderMap::const_iterator it = data.mapBootOrder.find(i);
8747	if (it == data.mapBootOrder.end())
8748	mHWData->mBootOrder[i] = DeviceType_Null;
8749	else
8750	mHWData->mBootOrder[i] = it->second;
8751	}
8752
8753	mHWData->mFirmwareType = data.firmwareType;
8754	mHWData->mPointingHIDType = data.pointingHIDType;
8755	mHWData->mKeyboardHIDType = data.keyboardHIDType;
8756	mHWData->mChipsetType = data.chipsetType;
8757	mHWData->mParavirtProvider = data.paravirtProvider;
8758	mHWData->mParavirtDebug = data.strParavirtDebug;
8759	mHWData->mEmulatedUSBCardReaderEnabled = data.fEmulatedUSBCardReader;
8760	mHWData->mHPETEnabled = data.fHPETEnabled;
8761
8762	/* GraphicsAdapter */
8763	rc = mGraphicsAdapter->i_loadSettings(data.graphicsAdapter);
8764	if (FAILED(rc)) return rc;
8765
8766	/* VRDEServer */
8767	rc = mVRDEServer->i_loadSettings(data.vrdeSettings);
8768	if (FAILED(rc)) return rc;
8769
8770	/* BIOS */
8771	rc = mBIOSSettings->i_loadSettings(data.biosSettings);
8772	if (FAILED(rc)) return rc;
8773
8774	/* Recording settings */
8775	rc = mRecordingSettings->i_loadSettings(data.recordingSettings);
8776	if (FAILED(rc)) return rc;
8777
8778	// Bandwidth control (must come before network adapters)
8779	rc = mBandwidthControl->i_loadSettings(data.ioSettings);
8780	if (FAILED(rc)) return rc;
8781
8782	/* USB controllers */
8783	for (settings::USBControllerList::const_iterator
8784	it = data.usbSettings.llUSBControllers.begin();
8785	it != data.usbSettings.llUSBControllers.end();
8786	++it)
8787	{
8788	const settings::USBController &settingsCtrl = *it;
8789	ComObjPtr<USBController> newCtrl;
8790
8791	newCtrl.createObject();
8792	newCtrl->init(this, settingsCtrl.strName, settingsCtrl.enmType);
8793	mUSBControllers->push_back(newCtrl);
8794	}
8795
8796	/* USB device filters */
8797	rc = mUSBDeviceFilters->i_loadSettings(data.usbSettings);
8798	if (FAILED(rc)) return rc;
8799
8800	// network adapters (establish array size first and apply defaults, to
8801	// ensure reading the same settings as we saved, since the list skips
8802	// adapters having defaults)
8803	size_t newCount = Global::getMaxNetworkAdapters(mHWData->mChipsetType);
8804	size_t oldCount = mNetworkAdapters.size();
8805	if (newCount > oldCount)
8806	{
8807	mNetworkAdapters.resize(newCount);
8808	for (size_t slot = oldCount; slot < mNetworkAdapters.size(); ++slot)
8809	{
8810	unconst(mNetworkAdapters[slot]).createObject();
8811	mNetworkAdapters[slot]->init(this, (ULONG)slot);
8812	}
8813	}
8814	else if (newCount < oldCount)
8815	mNetworkAdapters.resize(newCount);
8816	for (unsigned i = 0; i < mNetworkAdapters.size(); i++)
8817	mNetworkAdapters[i]->i_applyDefaults(pGuestOSType);
8818	for (settings::NetworkAdaptersList::const_iterator
8819	it = data.llNetworkAdapters.begin();
8820	it != data.llNetworkAdapters.end();
8821	++it)
8822	{
8823	const settings::NetworkAdapter &nic = *it;
8824
8825	/* slot uniqueness is guaranteed by XML Schema */
8826	AssertBreak(nic.ulSlot < mNetworkAdapters.size());
8827	rc = mNetworkAdapters[nic.ulSlot]->i_loadSettings(mBandwidthControl, nic);
8828	if (FAILED(rc)) return rc;
8829	}
8830
8831	// serial ports (establish defaults first, to ensure reading the same
8832	// settings as we saved, since the list skips ports having defaults)
8833	for (unsigned i = 0; i < RT_ELEMENTS(mSerialPorts); i++)
8834	mSerialPorts[i]->i_applyDefaults(pGuestOSType);
8835	for (settings::SerialPortsList::const_iterator
8836	it = data.llSerialPorts.begin();
8837	it != data.llSerialPorts.end();
8838	++it)
8839	{
8840	const settings::SerialPort &s = *it;
8841
8842	AssertBreak(s.ulSlot < RT_ELEMENTS(mSerialPorts));
8843	rc = mSerialPorts[s.ulSlot]->i_loadSettings(s);
8844	if (FAILED(rc)) return rc;
8845	}
8846
8847	// parallel ports (establish defaults first, to ensure reading the same
8848	// settings as we saved, since the list skips ports having defaults)
8849	for (unsigned i = 0; i < RT_ELEMENTS(mParallelPorts); i++)
8850	mParallelPorts[i]->i_applyDefaults();
8851	for (settings::ParallelPortsList::const_iterator
8852	it = data.llParallelPorts.begin();
8853	it != data.llParallelPorts.end();
8854	++it)
8855	{
8856	const settings::ParallelPort &p = *it;
8857
8858	AssertBreak(p.ulSlot < RT_ELEMENTS(mParallelPorts));
8859	rc = mParallelPorts[p.ulSlot]->i_loadSettings(p);
8860	if (FAILED(rc)) return rc;
8861	}
8862
8863	/* AudioAdapter */
8864	rc = mAudioAdapter->i_loadSettings(data.audioAdapter);
8865	if (FAILED(rc)) return rc;
8866
8867	/* storage controllers */
8868	rc = i_loadStorageControllers(data.storage,
8869	puuidRegistry,
8870	puuidSnapshot);
8871	if (FAILED(rc)) return rc;
8872
8873	/* Shared folders */
8874	for (settings::SharedFoldersList::const_iterator
8875	it = data.llSharedFolders.begin();
8876	it != data.llSharedFolders.end();
8877	++it)
8878	{
8879	const settings::SharedFolder &sf = *it;
8880
8881	ComObjPtr<SharedFolder> sharedFolder;
8882	/* Check for double entries. Not allowed! */
8883	rc = i_findSharedFolder(sf.strName, sharedFolder, false /* aSetError */);
8884	if (SUCCEEDED(rc))
8885	return setError(VBOX_E_OBJECT_IN_USE,
8886	tr("Shared folder named '%s' already exists"),
8887	sf.strName.c_str());
8888
8889	/* Create the new shared folder. Don't break on error. This will be
8890	* reported when the machine starts. */
8891	sharedFolder.createObject();
8892	rc = sharedFolder->init(i_getMachine(),
8893	sf.strName,
8894	sf.strHostPath,
8895	RT_BOOL(sf.fWritable),
8896	RT_BOOL(sf.fAutoMount),
8897	sf.strAutoMountPoint,
8898	false /* fFailOnError */);
8899	if (FAILED(rc)) return rc;
8900	mHWData->mSharedFolders.push_back(sharedFolder);
8901	}
8902
8903	// Clipboard
8904	mHWData->mClipboardMode = data.clipboardMode;
8905	mHWData->mClipboardFileTransfersEnabled = data.fClipboardFileTransfersEnabled ? TRUE : FALSE;
8906
8907	// drag'n'drop
8908	mHWData->mDnDMode = data.dndMode;
8909
8910	// guest settings
8911	mHWData->mMemoryBalloonSize = data.ulMemoryBalloonSize;
8912
8913	// IO settings
8914	mHWData->mIOCacheEnabled = data.ioSettings.fIOCacheEnabled;
8915	mHWData->mIOCacheSize = data.ioSettings.ulIOCacheSize;
8916
8917	// Host PCI devices
8918	for (settings::HostPCIDeviceAttachmentList::const_iterator
8919	it = data.pciAttachments.begin();
8920	it != data.pciAttachments.end();
8921	++it)
8922	{
8923	const settings::HostPCIDeviceAttachment &hpda = *it;
8924	ComObjPtr<PCIDeviceAttachment> pda;
8925
8926	pda.createObject();
8927	pda->i_loadSettings(this, hpda);
8928	mHWData->mPCIDeviceAssignments.push_back(pda);
8929	}
8930
8931	/*
8932	* (The following isn't really real hardware, but it lives in HWData
8933	* for reasons of convenience.)
8934	*/
8935
8936	#ifdef VBOX_WITH_GUEST_PROPS
8937	/* Guest properties (optional) */
8938
8939	/* Only load transient guest properties for configs which have saved
8940	* state, because there shouldn't be any for powered off VMs. The same
8941	* logic applies for snapshots, as offline snapshots shouldn't have
8942	* any such properties. They confuse the code in various places.
8943	* Note: can't rely on the machine state, as it isn't set yet. */
8944	bool fSkipTransientGuestProperties = mSSData->strStateFilePath.isEmpty();
8945	/* apologies for the hacky unconst() usage, but this needs hacking
8946	* actually inconsistent settings into consistency, otherwise there
8947	* will be some corner cases where the inconsistency survives
8948	* surprisingly long without getting fixed, especially for snapshots
8949	* as there are no config changes. */
8950	settings::GuestPropertiesList &llGuestProperties = unconst(data.llGuestProperties);
8951	for (settings::GuestPropertiesList::iterator
8952	it = llGuestProperties.begin();
8953	it != llGuestProperties.end();
8954	/nothing/)
8955	{
8956	const settings::GuestProperty &prop = *it;
8957	uint32_t fFlags = GUEST_PROP_F_NILFLAG;
8958	GuestPropValidateFlags(prop.strFlags.c_str(), &fFlags);
8959	if ( fSkipTransientGuestProperties
8960	&& ( fFlags & GUEST_PROP_F_TRANSIENT
8961	\|\| fFlags & GUEST_PROP_F_TRANSRESET))
8962	{
8963	it = llGuestProperties.erase(it);
8964	continue;
8965	}
8966	HWData::GuestProperty property = { prop.strValue, (LONG64) prop.timestamp, fFlags };
8967	mHWData->mGuestProperties[prop.strName] = property;
8968	++it;
8969	}
8970	#endif /* VBOX_WITH_GUEST_PROPS defined */
8971
8972	rc = i_loadDebugging(pDbg);
8973	if (FAILED(rc))
8974	return rc;
8975
8976	mHWData->mAutostart = *pAutostart;
8977
8978	/* default frontend */
8979	mHWData->mDefaultFrontend = data.strDefaultFrontend;
8980	}
8981	catch (std::bad_alloc &)
8982	{
8983	return E_OUTOFMEMORY;
8984	}
8985
8986	AssertComRC(rc);
8987	return rc;
8988	}
8989
8990	/**
8991	* Called from i_loadHardware() to load the debugging settings of the
8992	* machine.
8993	*
8994	* @param pDbg Pointer to the settings.
8995	*/
8996	HRESULT Machine::i_loadDebugging(const settings::Debugging *pDbg)
8997	{
8998	mHWData->mDebugging = *pDbg;
8999	/* no more processing currently required, this will probably change. */
9000	return S_OK;
9001	}
9002
9003	/**
9004	* Called from i_loadMachineDataFromSettings() for the storage controller data, including media.
9005	*
9006	* @param data storage settings.
9007	* @param puuidRegistry media registry ID to set media to or NULL;
9008	* see Machine::i_loadMachineDataFromSettings()
9009	* @param puuidSnapshot snapshot ID
9010	* @return
9011	*/
9012	HRESULT Machine::i_loadStorageControllers(const settings::Storage &data,
9013	const Guid *puuidRegistry,
9014	const Guid *puuidSnapshot)
9015	{
9016	AssertReturn(!i_isSessionMachine(), E_FAIL);
9017
9018	HRESULT rc = S_OK;
9019
9020	for (settings::StorageControllersList::const_iterator
9021	it = data.llStorageControllers.begin();
9022	it != data.llStorageControllers.end();
9023	++it)
9024	{
9025	const settings::StorageController &ctlData = *it;
9026
9027	ComObjPtr<StorageController> pCtl;
9028	/* Try to find one with the name first. */
9029	rc = i_getStorageControllerByName(ctlData.strName, pCtl, false /* aSetError */);
9030	if (SUCCEEDED(rc))
9031	return setError(VBOX_E_OBJECT_IN_USE,
9032	tr("Storage controller named '%s' already exists"),
9033	ctlData.strName.c_str());
9034
9035	pCtl.createObject();
9036	rc = pCtl->init(this,
9037	ctlData.strName,
9038	ctlData.storageBus,
9039	ctlData.ulInstance,
9040	ctlData.fBootable);
9041	if (FAILED(rc)) return rc;
9042
9043	mStorageControllers->push_back(pCtl);
9044
9045	rc = pCtl->COMSETTER(ControllerType)(ctlData.controllerType);
9046	if (FAILED(rc)) return rc;
9047
9048	rc = pCtl->COMSETTER(PortCount)(ctlData.ulPortCount);
9049	if (FAILED(rc)) return rc;
9050
9051	rc = pCtl->COMSETTER(UseHostIOCache)(ctlData.fUseHostIOCache);
9052	if (FAILED(rc)) return rc;
9053
9054	/* Load the attached devices now. */
9055	rc = i_loadStorageDevices(pCtl,
9056	ctlData,
9057	puuidRegistry,
9058	puuidSnapshot);
9059	if (FAILED(rc)) return rc;
9060	}
9061
9062	return S_OK;
9063	}
9064
9065	/**
9066	* Called from i_loadStorageControllers for a controller's devices.
9067	*
9068	* @param aStorageController
9069	* @param data
9070	* @param puuidRegistry media registry ID to set media to or NULL; see
9071	* Machine::i_loadMachineDataFromSettings()
9072	* @param puuidSnapshot pointer to the snapshot ID if this is a snapshot machine
9073	* @return
9074	*/
9075	HRESULT Machine::i_loadStorageDevices(StorageController *aStorageController,
9076	const settings::StorageController &data,
9077	const Guid *puuidRegistry,
9078	const Guid *puuidSnapshot)
9079	{
9080	HRESULT rc = S_OK;
9081
9082	/* paranoia: detect duplicate attachments */
9083	for (settings::AttachedDevicesList::const_iterator
9084	it = data.llAttachedDevices.begin();
9085	it != data.llAttachedDevices.end();
9086	++it)
9087	{
9088	const settings::AttachedDevice &ad = *it;
9089
9090	for (settings::AttachedDevicesList::const_iterator it2 = it;
9091	it2 != data.llAttachedDevices.end();
9092	++it2)
9093	{
9094	if (it == it2)
9095	continue;
9096
9097	const settings::AttachedDevice &ad2 = *it2;
9098
9099	if ( ad.lPort == ad2.lPort
9100	&& ad.lDevice == ad2.lDevice)
9101	{
9102	return setError(E_FAIL,
9103	tr("Duplicate attachments for storage controller '%s', port %d, device %d of the virtual machine '%s'"),
9104	aStorageController->i_getName().c_str(),
9105	ad.lPort,
9106	ad.lDevice,
9107	mUserData->s.strName.c_str());
9108	}
9109	}
9110	}
9111
9112	for (settings::AttachedDevicesList::const_iterator
9113	it = data.llAttachedDevices.begin();
9114	it != data.llAttachedDevices.end();
9115	++it)
9116	{
9117	const settings::AttachedDevice &dev = *it;
9118	ComObjPtr<Medium> medium;
9119
9120	switch (dev.deviceType)
9121	{
9122	case DeviceType_Floppy:
9123	case DeviceType_DVD:
9124	if (dev.strHostDriveSrc.isNotEmpty())
9125	rc = mParent->i_host()->i_findHostDriveByName(dev.deviceType, dev.strHostDriveSrc,
9126	false /* fRefresh */, medium);
9127	else
9128	rc = mParent->i_findRemoveableMedium(dev.deviceType,
9129	dev.uuid,
9130	false /* fRefresh */,
9131	false /* aSetError */,
9132	medium);
9133	if (rc == VBOX_E_OBJECT_NOT_FOUND)
9134	// This is not an error. The host drive or UUID might have vanished, so just go
9135	// ahead without this removeable medium attachment
9136	rc = S_OK;
9137	break;
9138
9139	case DeviceType_HardDisk:
9140	{
9141	/* find a hard disk by UUID */
9142	rc = mParent->i_findHardDiskById(dev.uuid, true /* aDoSetError */, &medium);
9143	if (FAILED(rc))
9144	{
9145	if (i_isSnapshotMachine())
9146	{
9147	// wrap another error message around the "cannot find hard disk" set by findHardDisk
9148	// so the user knows that the bad disk is in a snapshot somewhere
9149	com::ErrorInfo info;
9150	return setError(E_FAIL,
9151	tr("A differencing image of snapshot {%RTuuid} could not be found. %ls"),
9152	puuidSnapshot->raw(),
9153	info.getText().raw());
9154	}
9155	else
9156	return rc;
9157	}
9158
9159	AutoWriteLock hdLock(medium COMMA_LOCKVAL_SRC_POS);
9160
9161	if (medium->i_getType() == MediumType_Immutable)
9162	{
9163	if (i_isSnapshotMachine())
9164	return setError(E_FAIL,
9165	tr("Immutable hard disk '%s' with UUID {%RTuuid} cannot be directly attached to snapshot with UUID {%RTuuid} "
9166	"of the virtual machine '%s' ('%s')"),
9167	medium->i_getLocationFull().c_str(),
9168	dev.uuid.raw(),
9169	puuidSnapshot->raw(),
9170	mUserData->s.strName.c_str(),
9171	mData->m_strConfigFileFull.c_str());
9172
9173	return setError(E_FAIL,
9174	tr("Immutable hard disk '%s' with UUID {%RTuuid} cannot be directly attached to the virtual machine '%s' ('%s')"),
9175	medium->i_getLocationFull().c_str(),
9176	dev.uuid.raw(),
9177	mUserData->s.strName.c_str(),
9178	mData->m_strConfigFileFull.c_str());
9179	}
9180
9181	if (medium->i_getType() == MediumType_MultiAttach)
9182	{
9183	if (i_isSnapshotMachine())
9184	return setError(E_FAIL,
9185	tr("Multi-attach hard disk '%s' with UUID {%RTuuid} cannot be directly attached to snapshot with UUID {%RTuuid} "
9186	"of the virtual machine '%s' ('%s')"),
9187	medium->i_getLocationFull().c_str(),
9188	dev.uuid.raw(),
9189	puuidSnapshot->raw(),
9190	mUserData->s.strName.c_str(),
9191	mData->m_strConfigFileFull.c_str());
9192
9193	return setError(E_FAIL,
9194	tr("Multi-attach hard disk '%s' with UUID {%RTuuid} cannot be directly attached to the virtual machine '%s' ('%s')"),
9195	medium->i_getLocationFull().c_str(),
9196	dev.uuid.raw(),
9197	mUserData->s.strName.c_str(),
9198	mData->m_strConfigFileFull.c_str());
9199	}
9200
9201	if ( !i_isSnapshotMachine()
9202	&& medium->i_getChildren().size() != 0
9203	)
9204	return setError(E_FAIL,
9205	tr("Hard disk '%s' with UUID {%RTuuid} cannot be directly attached to the virtual machine '%s' ('%s') "
9206	"because it has %d differencing child hard disks"),
9207	medium->i_getLocationFull().c_str(),
9208	dev.uuid.raw(),
9209	mUserData->s.strName.c_str(),
9210	mData->m_strConfigFileFull.c_str(),
9211	medium->i_getChildren().size());
9212
9213	if (i_findAttachment(*mMediumAttachments.data(),
9214	medium))
9215	return setError(E_FAIL,
9216	tr("Hard disk '%s' with UUID {%RTuuid} is already attached to the virtual machine '%s' ('%s')"),
9217	medium->i_getLocationFull().c_str(),
9218	dev.uuid.raw(),
9219	mUserData->s.strName.c_str(),
9220	mData->m_strConfigFileFull.c_str());
9221
9222	break;
9223	}
9224
9225	default:
9226	return setError(E_FAIL,
9227	tr("Device '%s' with unknown type is attached to the virtual machine '%s' ('%s')"),
9228	medium->i_getLocationFull().c_str(),
9229	mUserData->s.strName.c_str(),
9230	mData->m_strConfigFileFull.c_str());
9231	}
9232
9233	if (FAILED(rc))
9234	break;
9235
9236	/* Bandwidth groups are loaded at this point. */
9237	ComObjPtr<BandwidthGroup> pBwGroup;
9238
9239	if (!dev.strBwGroup.isEmpty())
9240	{
9241	rc = mBandwidthControl->i_getBandwidthGroupByName(dev.strBwGroup, pBwGroup, false /* aSetError */);
9242	if (FAILED(rc))
9243	return setError(E_FAIL,
9244	tr("Device '%s' with unknown bandwidth group '%s' is attached to the virtual machine '%s' ('%s')"),
9245	medium->i_getLocationFull().c_str(),
9246	dev.strBwGroup.c_str(),
9247	mUserData->s.strName.c_str(),
9248	mData->m_strConfigFileFull.c_str());
9249	pBwGroup->i_reference();
9250	}
9251
9252	const Utf8Str controllerName = aStorageController->i_getName();
9253	ComObjPtr<MediumAttachment> pAttachment;
9254	pAttachment.createObject();
9255	rc = pAttachment->init(this,
9256	medium,
9257	controllerName,
9258	dev.lPort,
9259	dev.lDevice,
9260	dev.deviceType,
9261	false,
9262	dev.fPassThrough,
9263	dev.fTempEject,
9264	dev.fNonRotational,
9265	dev.fDiscard,
9266	dev.fHotPluggable,
9267	pBwGroup.isNull() ? Utf8Str::Empty : pBwGroup->i_getName());
9268	if (FAILED(rc)) break;
9269
9270	/* associate the medium with this machine and snapshot */
9271	if (!medium.isNull())
9272	{
9273	AutoCaller medCaller(medium);
9274	if (FAILED(medCaller.rc())) return medCaller.rc();
9275	AutoWriteLock mlock(medium COMMA_LOCKVAL_SRC_POS);
9276
9277	if (i_isSnapshotMachine())
9278	rc = medium->i_addBackReference(mData->mUuid, *puuidSnapshot);
9279	else
9280	rc = medium->i_addBackReference(mData->mUuid);
9281	/* If the medium->addBackReference fails it sets an appropriate
9282	* error message, so no need to do any guesswork here. */
9283
9284	if (puuidRegistry)
9285	// caller wants registry ID to be set on all attached media (OVF import case)
9286	medium->i_addRegistry(*puuidRegistry);
9287	}
9288
9289	if (FAILED(rc))
9290	break;
9291
9292	/* back up mMediumAttachments to let registeredInit() properly rollback
9293	* on failure (= limited accessibility) */
9294	i_setModified(IsModified_Storage);
9295	mMediumAttachments.backup();
9296	mMediumAttachments->push_back(pAttachment);
9297	}
9298
9299	return rc;
9300	}
9301
9302	/**
9303	* Returns the snapshot with the given UUID or fails of no such snapshot exists.
9304	*
9305	* @param aId snapshot UUID to find (empty UUID refers the first snapshot)
9306	* @param aSnapshot where to return the found snapshot
9307	* @param aSetError true to set extended error info on failure
9308	*/
9309	HRESULT Machine::i_findSnapshotById(const Guid &aId,
9310	ComObjPtr<Snapshot> &aSnapshot,
9311	bool aSetError /* = false */)
9312	{
9313	AutoReadLock chlock(this COMMA_LOCKVAL_SRC_POS);
9314
9315	if (!mData->mFirstSnapshot)
9316	{
9317	if (aSetError)
9318	return setError(E_FAIL, tr("This machine does not have any snapshots"));
9319	return E_FAIL;
9320	}
9321
9322	if (aId.isZero())
9323	aSnapshot = mData->mFirstSnapshot;
9324	else
9325	aSnapshot = mData->mFirstSnapshot->i_findChildOrSelf(aId.ref());
9326
9327	if (!aSnapshot)
9328	{
9329	if (aSetError)
9330	return setError(E_FAIL,
9331	tr("Could not find a snapshot with UUID {%s}"),
9332	aId.toString().c_str());
9333	return E_FAIL;
9334	}
9335
9336	return S_OK;
9337	}
9338
9339	/**
9340	* Returns the snapshot with the given name or fails of no such snapshot.
9341	*
9342	* @param strName snapshot name to find
9343	* @param aSnapshot where to return the found snapshot
9344	* @param aSetError true to set extended error info on failure
9345	*/
9346	HRESULT Machine::i_findSnapshotByName(const Utf8Str &strName,
9347	ComObjPtr<Snapshot> &aSnapshot,
9348	bool aSetError /* = false */)
9349	{
9350	AssertReturn(!strName.isEmpty(), E_INVALIDARG);
9351
9352	AutoReadLock chlock(this COMMA_LOCKVAL_SRC_POS);
9353
9354	if (!mData->mFirstSnapshot)
9355	{
9356	if (aSetError)
9357	return setError(VBOX_E_OBJECT_NOT_FOUND,
9358	tr("This machine does not have any snapshots"));
9359	return VBOX_E_OBJECT_NOT_FOUND;
9360	}
9361
9362	aSnapshot = mData->mFirstSnapshot->i_findChildOrSelf(strName);
9363
9364	if (!aSnapshot)
9365	{
9366	if (aSetError)
9367	return setError(VBOX_E_OBJECT_NOT_FOUND,
9368	tr("Could not find a snapshot named '%s'"), strName.c_str());
9369	return VBOX_E_OBJECT_NOT_FOUND;
9370	}
9371
9372	return S_OK;
9373	}
9374
9375	/**
9376	* Returns a storage controller object with the given name.
9377	*
9378	* @param aName storage controller name to find
9379	* @param aStorageController where to return the found storage controller
9380	* @param aSetError true to set extended error info on failure
9381	*/
9382	HRESULT Machine::i_getStorageControllerByName(const Utf8Str &aName,
9383	ComObjPtr<StorageController> &aStorageController,
9384	bool aSetError /* = false */)
9385	{
9386	AssertReturn(!aName.isEmpty(), E_INVALIDARG);
9387
9388	for (StorageControllerList::const_iterator
9389	it = mStorageControllers->begin();
9390	it != mStorageControllers->end();
9391	++it)
9392	{
9393	if ((*it)->i_getName() == aName)
9394	{
9395	aStorageController = (*it);
9396	return S_OK;
9397	}
9398	}
9399
9400	if (aSetError)
9401	return setError(VBOX_E_OBJECT_NOT_FOUND,
9402	tr("Could not find a storage controller named '%s'"),
9403	aName.c_str());
9404	return VBOX_E_OBJECT_NOT_FOUND;
9405	}
9406
9407	/**
9408	* Returns a USB controller object with the given name.
9409	*
9410	* @param aName USB controller name to find
9411	* @param aUSBController where to return the found USB controller
9412	* @param aSetError true to set extended error info on failure
9413	*/
9414	HRESULT Machine::i_getUSBControllerByName(const Utf8Str &aName,
9415	ComObjPtr<USBController> &aUSBController,
9416	bool aSetError /* = false */)
9417	{
9418	AssertReturn(!aName.isEmpty(), E_INVALIDARG);
9419
9420	for (USBControllerList::const_iterator
9421	it = mUSBControllers->begin();
9422	it != mUSBControllers->end();
9423	++it)
9424	{
9425	if ((*it)->i_getName() == aName)
9426	{
9427	aUSBController = (*it);
9428	return S_OK;
9429	}
9430	}
9431
9432	if (aSetError)
9433	return setError(VBOX_E_OBJECT_NOT_FOUND,
9434	tr("Could not find a storage controller named '%s'"),
9435	aName.c_str());
9436	return VBOX_E_OBJECT_NOT_FOUND;
9437	}
9438
9439	/**
9440	* Returns the number of USB controller instance of the given type.
9441	*
9442	* @param enmType USB controller type.
9443	*/
9444	ULONG Machine::i_getUSBControllerCountByType(USBControllerType_T enmType)
9445	{
9446	ULONG cCtrls = 0;
9447
9448	for (USBControllerList::const_iterator
9449	it = mUSBControllers->begin();
9450	it != mUSBControllers->end();
9451	++it)
9452	{
9453	if ((*it)->i_getControllerType() == enmType)
9454	cCtrls++;
9455	}
9456
9457	return cCtrls;
9458	}
9459
9460	HRESULT Machine::i_getMediumAttachmentsOfController(const Utf8Str &aName,
9461	MediumAttachmentList &atts)
9462	{
9463	AutoCaller autoCaller(this);
9464	if (FAILED(autoCaller.rc())) return autoCaller.rc();
9465
9466	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
9467
9468	for (MediumAttachmentList::const_iterator
9469	it = mMediumAttachments->begin();
9470	it != mMediumAttachments->end();
9471	++it)
9472	{
9473	const ComObjPtr<MediumAttachment> &pAtt = *it;
9474	// should never happen, but deal with NULL pointers in the list.
9475	AssertContinue(!pAtt.isNull());
9476
9477	// getControllerName() needs caller+read lock
9478	AutoCaller autoAttCaller(pAtt);
9479	if (FAILED(autoAttCaller.rc()))
9480	{
9481	atts.clear();
9482	return autoAttCaller.rc();
9483	}
9484	AutoReadLock attLock(pAtt COMMA_LOCKVAL_SRC_POS);
9485
9486	if (pAtt->i_getControllerName() == aName)
9487	atts.push_back(pAtt);
9488	}
9489
9490	return S_OK;
9491	}
9492
9493
9494	/**
9495	* Helper for #i_saveSettings. Cares about renaming the settings directory and
9496	* file if the machine name was changed and about creating a new settings file
9497	* if this is a new machine.
9498	*
9499	* @note Must be never called directly but only from #saveSettings().
9500	*/
9501	HRESULT Machine::i_prepareSaveSettings(bool *pfNeedsGlobalSaveSettings)
9502	{
9503	AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
9504
9505	HRESULT rc = S_OK;
9506
9507	bool fSettingsFileIsNew = !mData->pMachineConfigFile->fileExists();
9508
9509	/// @todo need to handle primary group change, too
9510
9511	/* attempt to rename the settings file if machine name is changed */
9512	if ( mUserData->s.fNameSync
9513	&& mUserData.isBackedUp()
9514	&& ( mUserData.backedUpData()->s.strName != mUserData->s.strName
9515	\|\| mUserData.backedUpData()->s.llGroups.front() != mUserData->s.llGroups.front())
9516	)
9517	{
9518	bool dirRenamed = false;
9519	bool fileRenamed = false;
9520
9521	Utf8Str configFile, newConfigFile;
9522	Utf8Str configFilePrev, newConfigFilePrev;
9523	Utf8Str NVRAMFile, newNVRAMFile;
9524	Utf8Str configDir, newConfigDir;
9525
9526	do
9527	{
9528	int vrc = VINF_SUCCESS;
9529
9530	Utf8Str name = mUserData.backedUpData()->s.strName;
9531	Utf8Str newName = mUserData->s.strName;
9532	Utf8Str group = mUserData.backedUpData()->s.llGroups.front();
9533	if (group == "/")
9534	group.setNull();
9535	Utf8Str newGroup = mUserData->s.llGroups.front();
9536	if (newGroup == "/")
9537	newGroup.setNull();
9538
9539	configFile = mData->m_strConfigFileFull;
9540
9541	/* first, rename the directory if it matches the group and machine name */
9542	Utf8StrFmt groupPlusName("%s%c%s", group.c_str(), RTPATH_DELIMITER, name.c_str());
9543	/** @todo hack, make somehow use of ComposeMachineFilename */
9544	if (mUserData->s.fDirectoryIncludesUUID)
9545	groupPlusName.appendPrintf(" (%RTuuid)", mData->mUuid.raw());
9546	Utf8StrFmt newGroupPlusName("%s%c%s", newGroup.c_str(), RTPATH_DELIMITER, newName.c_str());
9547	/** @todo hack, make somehow use of ComposeMachineFilename */
9548	if (mUserData->s.fDirectoryIncludesUUID)
9549	newGroupPlusName.appendPrintf(" (%RTuuid)", mData->mUuid.raw());
9550	configDir = configFile;
9551	configDir.stripFilename();
9552	newConfigDir = configDir;
9553	if ( configDir.length() >= groupPlusName.length()
9554	&& !RTPathCompare(configDir.substr(configDir.length() - groupPlusName.length(), groupPlusName.length()).c_str(),
9555	groupPlusName.c_str()))
9556	{
9557	newConfigDir = newConfigDir.substr(0, configDir.length() - groupPlusName.length());
9558	Utf8Str newConfigBaseDir(newConfigDir);
9559	newConfigDir.append(newGroupPlusName);
9560	/* consistency: use \ if appropriate on the platform */
9561	RTPathChangeToDosSlashes(newConfigDir.mutableRaw(), false);
9562	/* new dir and old dir cannot be equal here because of 'if'
9563	* above and because name != newName */
9564	Assert(configDir != newConfigDir);
9565	if (!fSettingsFileIsNew)
9566	{
9567	/* perform real rename only if the machine is not new */
9568	vrc = RTPathRename(configDir.c_str(), newConfigDir.c_str(), 0);
9569	if ( vrc == VERR_FILE_NOT_FOUND
9570	\|\| vrc == VERR_PATH_NOT_FOUND)
9571	{
9572	/* create the parent directory, then retry renaming */
9573	Utf8Str parent(newConfigDir);
9574	parent.stripFilename();
9575	(void)RTDirCreateFullPath(parent.c_str(), 0700);
9576	vrc = RTPathRename(configDir.c_str(), newConfigDir.c_str(), 0);
9577	}
9578	if (RT_FAILURE(vrc))
9579	{
9580	rc = setErrorBoth(E_FAIL, vrc,
9581	tr("Could not rename the directory '%s' to '%s' to save the settings file (%Rrc)"),
9582	configDir.c_str(),
9583	newConfigDir.c_str(),
9584	vrc);
9585	break;
9586	}
9587	/* delete subdirectories which are no longer needed */
9588	Utf8Str dir(configDir);
9589	dir.stripFilename();
9590	while (dir != newConfigBaseDir && dir != ".")
9591	{
9592	vrc = RTDirRemove(dir.c_str());
9593	if (RT_FAILURE(vrc))
9594	break;
9595	dir.stripFilename();
9596	}
9597	dirRenamed = true;
9598	}
9599	}
9600
9601	newConfigFile.printf("%s%c%s.vbox", newConfigDir.c_str(), RTPATH_DELIMITER, newName.c_str());
9602
9603	/* then try to rename the settings file itself */
9604	if (newConfigFile != configFile)
9605	{
9606	/* get the path to old settings file in renamed directory */
9607	Assert(mData->m_strConfigFileFull == configFile);
9608	configFile.printf("%s%c%s",
9609	newConfigDir.c_str(),
9610	RTPATH_DELIMITER,
9611	RTPathFilename(mData->m_strConfigFileFull.c_str()));
9612	if (!fSettingsFileIsNew)
9613	{
9614	/* perform real rename only if the machine is not new */
9615	vrc = RTFileRename(configFile.c_str(), newConfigFile.c_str(), 0);
9616	if (RT_FAILURE(vrc))
9617	{
9618	rc = setErrorBoth(E_FAIL, vrc,
9619	tr("Could not rename the settings file '%s' to '%s' (%Rrc)"),
9620	configFile.c_str(),
9621	newConfigFile.c_str(),
9622	vrc);
9623	break;
9624	}
9625	fileRenamed = true;
9626	configFilePrev = configFile;
9627	configFilePrev += "-prev";
9628	newConfigFilePrev = newConfigFile;
9629	newConfigFilePrev += "-prev";
9630	RTFileRename(configFilePrev.c_str(), newConfigFilePrev.c_str(), 0);
9631	NVRAMFile = mBIOSSettings->i_getNonVolatileStorageFile();
9632	if (NVRAMFile.isNotEmpty())
9633	{
9634	// in the NVRAM file path, replace the old directory with the new directory
9635	if (RTPathStartsWith(NVRAMFile.c_str(), configDir.c_str()))
9636	{
9637	Utf8Str strNVRAMFile = NVRAMFile.c_str() + configDir.length();
9638	NVRAMFile = newConfigDir + strNVRAMFile;
9639	}
9640	newNVRAMFile = newConfigFile;
9641	newNVRAMFile.stripSuffix();
9642	newNVRAMFile += ".nvram";
9643	RTFileRename(NVRAMFile.c_str(), newNVRAMFile.c_str(), 0);
9644	}
9645	}
9646	}
9647
9648	// update m_strConfigFileFull amd mConfigFile
9649	mData->m_strConfigFileFull = newConfigFile;
9650	// compute the relative path too
9651	mParent->i_copyPathRelativeToConfig(newConfigFile, mData->m_strConfigFile);
9652
9653	// store the old and new so that VirtualBox::i_saveSettings() can update
9654	// the media registry
9655	if ( mData->mRegistered
9656	&& (configDir != newConfigDir \|\| configFile != newConfigFile))
9657	{
9658	mParent->i_rememberMachineNameChangeForMedia(configDir, newConfigDir);
9659
9660	if (pfNeedsGlobalSaveSettings)
9661	*pfNeedsGlobalSaveSettings = true;
9662	}
9663
9664	// in the saved state file path, replace the old directory with the new directory
9665	if (RTPathStartsWith(mSSData->strStateFilePath.c_str(), configDir.c_str()))
9666	{
9667	Utf8Str strStateFileName = mSSData->strStateFilePath.c_str() + configDir.length();
9668	mSSData->strStateFilePath = newConfigDir + strStateFileName;
9669	}
9670	if (newNVRAMFile.isNotEmpty())
9671	mBIOSSettings->i_updateNonVolatileStorageFile(newNVRAMFile);
9672
9673	// and do the same thing for the saved state file paths of all the online snapshots and NVRAM files of all snapshots
9674	if (mData->mFirstSnapshot)
9675	{
9676	mData->mFirstSnapshot->i_updateSavedStatePaths(configDir.c_str(),
9677	newConfigDir.c_str());
9678	mData->mFirstSnapshot->i_updateNVRAMPaths(configDir.c_str(),
9679	newConfigDir.c_str());
9680	}
9681	}
9682	while (0);
9683
9684	if (FAILED(rc))
9685	{
9686	/* silently try to rename everything back */
9687	if (fileRenamed)
9688	{
9689	RTFileRename(newConfigFilePrev.c_str(), configFilePrev.c_str(), 0);
9690	RTFileRename(newConfigFile.c_str(), configFile.c_str(), 0);
9691	if (NVRAMFile.isNotEmpty() && newNVRAMFile.isNotEmpty())
9692	RTFileRename(newNVRAMFile.c_str(), NVRAMFile.c_str(), 0);
9693	}
9694	if (dirRenamed)
9695	RTPathRename(newConfigDir.c_str(), configDir.c_str(), 0);
9696	}
9697
9698	if (FAILED(rc)) return rc;
9699	}
9700
9701	if (fSettingsFileIsNew)
9702	{
9703	/* create a virgin config file */
9704	int vrc = VINF_SUCCESS;
9705
9706	/* ensure the settings directory exists */
9707	Utf8Str path(mData->m_strConfigFileFull);
9708	path.stripFilename();
9709	if (!RTDirExists(path.c_str()))
9710	{
9711	vrc = RTDirCreateFullPath(path.c_str(), 0700);
9712	if (RT_FAILURE(vrc))
9713	{
9714	return setErrorBoth(E_FAIL, vrc,
9715	tr("Could not create a directory '%s' to save the settings file (%Rrc)"),
9716	path.c_str(),
9717	vrc);
9718	}
9719	}
9720
9721	/* Note: open flags must correlate with RTFileOpen() in lockConfig() */
9722	path = Utf8Str(mData->m_strConfigFileFull);
9723	RTFILE f = NIL_RTFILE;
9724	vrc = RTFileOpen(&f, path.c_str(),
9725	RTFILE_O_READWRITE \| RTFILE_O_CREATE \| RTFILE_O_DENY_WRITE);
9726	if (RT_FAILURE(vrc))
9727	return setErrorBoth(E_FAIL, vrc,
9728	tr("Could not create the settings file '%s' (%Rrc)"),
9729	path.c_str(),
9730	vrc);
9731	RTFileClose(f);
9732	}
9733
9734	return rc;
9735	}
9736
9737	/**
9738	* Saves and commits machine data, user data and hardware data.
9739	*
9740	* Note that on failure, the data remains uncommitted.
9741	*
9742	* @a aFlags may combine the following flags:
9743	*
9744	* - SaveS_ResetCurStateModified: Resets mData->mCurrentStateModified to FALSE.
9745	* Used when saving settings after an operation that makes them 100%
9746	* correspond to the settings from the current snapshot.
9747	* - SaveS_Force: settings will be saved without doing a deep compare of the
9748	* settings structures. This is used when this is called because snapshots
9749	* have changed to avoid the overhead of the deep compare.
9750	*
9751	* @note Must be called from under this object's write lock. Locks children for
9752	* writing.
9753	*
9754	* @param pfNeedsGlobalSaveSettings Optional pointer to a bool that must have been
9755	* initialized to false and that will be set to true by this function if
9756	* the caller must invoke VirtualBox::i_saveSettings() because the global
9757	* settings have changed. This will happen if a machine rename has been
9758	* saved and the global machine and media registries will therefore need
9759	* updating.
9760	* @param aFlags Flags.
9761	*/
9762	HRESULT Machine::i_saveSettings(bool *pfNeedsGlobalSaveSettings,
9763	int aFlags /= 0/)
9764	{
9765	LogFlowThisFuncEnter();
9766
9767	AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
9768
9769	/* make sure child objects are unable to modify the settings while we are
9770	* saving them */
9771	i_ensureNoStateDependencies();
9772
9773	AssertReturn(!i_isSnapshotMachine(),
9774	E_FAIL);
9775
9776	if (!mData->mAccessible)
9777	return setError(VBOX_E_INVALID_VM_STATE,
9778	tr("The machine is not accessible, so cannot save settings"));
9779
9780	HRESULT rc = S_OK;
9781	bool fNeedsWrite = false;
9782
9783	/* First, prepare to save settings. It will care about renaming the
9784	* settings directory and file if the machine name was changed and about
9785	* creating a new settings file if this is a new machine. */
9786	rc = i_prepareSaveSettings(pfNeedsGlobalSaveSettings);
9787	if (FAILED(rc)) return rc;
9788
9789	// keep a pointer to the current settings structures
9790	settings::MachineConfigFile *pOldConfig = mData->pMachineConfigFile;
9791	settings::MachineConfigFile *pNewConfig = NULL;
9792
9793	try
9794	{
9795	// make a fresh one to have everyone write stuff into
9796	pNewConfig = new settings::MachineConfigFile(NULL);
9797	pNewConfig->copyBaseFrom(*mData->pMachineConfigFile);
9798
9799	// now go and copy all the settings data from COM to the settings structures
9800	// (this calls i_saveSettings() on all the COM objects in the machine)
9801	i_copyMachineDataToSettings(*pNewConfig);
9802
9803	if (aFlags & SaveS_ResetCurStateModified)
9804	{
9805	// this gets set by takeSnapshot() (if offline snapshot) and restoreSnapshot()
9806	mData->mCurrentStateModified = FALSE;
9807	fNeedsWrite = true; // always, no need to compare
9808	}
9809	else if (aFlags & SaveS_Force)
9810	{
9811	fNeedsWrite = true; // always, no need to compare
9812	}
9813	else
9814	{
9815	if (!mData->mCurrentStateModified)
9816	{
9817	// do a deep compare of the settings that we just saved with the settings
9818	// previously stored in the config file; this invokes MachineConfigFile::operator==
9819	// which does a deep compare of all the settings, which is expensive but less expensive
9820	// than writing out XML in vain
9821	bool fAnySettingsChanged = !(pNewConfig == pOldConfig);
9822
9823	// could still be modified if any settings changed
9824	mData->mCurrentStateModified = fAnySettingsChanged;
9825
9826	fNeedsWrite = fAnySettingsChanged;
9827	}
9828	else
9829	fNeedsWrite = true;
9830	}
9831
9832	pNewConfig->fCurrentStateModified = !!mData->mCurrentStateModified;
9833
9834	if (fNeedsWrite)
9835	// now spit it all out!
9836	pNewConfig->write(mData->m_strConfigFileFull);
9837
9838	mData->pMachineConfigFile = pNewConfig;
9839	delete pOldConfig;
9840	i_commit();
9841
9842	// after saving settings, we are no longer different from the XML on disk
9843	mData->flModifications = 0;
9844	}
9845	catch (HRESULT err)
9846	{
9847	// we assume that error info is set by the thrower
9848	rc = err;
9849
9850	// restore old config
9851	delete pNewConfig;
9852	mData->pMachineConfigFile = pOldConfig;
9853	}
9854	catch (...)
9855	{
9856	rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
9857	}
9858
9859	if (fNeedsWrite)
9860	{
9861	/* Fire the data change event, even on failure (since we've already
9862	* committed all data). This is done only for SessionMachines because
9863	* mutable Machine instances are always not registered (i.e. private
9864	* to the client process that creates them) and thus don't need to
9865	* inform callbacks. */
9866	if (i_isSessionMachine())
9867	mParent->i_onMachineDataChanged(mData->mUuid);
9868	}
9869
9870	LogFlowThisFunc(("rc=%08X\n", rc));
9871	LogFlowThisFuncLeave();
9872	return rc;
9873	}
9874
9875	/**
9876	* Implementation for saving the machine settings into the given
9877	* settings::MachineConfigFile instance. This copies machine extradata
9878	* from the previous machine config file in the instance data, if any.
9879	*
9880	* This gets called from two locations:
9881	*
9882	* -- Machine::i_saveSettings(), during the regular XML writing;
9883	*
9884	* -- Appliance::buildXMLForOneVirtualSystem(), when a machine gets
9885	* exported to OVF and we write the VirtualBox proprietary XML
9886	* into a <vbox:Machine> tag.
9887	*
9888	* This routine fills all the fields in there, including snapshots, except
9889	* for the following:
9890	*
9891	* -- fCurrentStateModified. There is some special logic associated with that.
9892	*
9893	* The caller can then call MachineConfigFile::write() or do something else
9894	* with it.
9895	*
9896	* Caller must hold the machine lock!
9897	*
9898	* This throws XML errors and HRESULT, so the caller must have a catch block!
9899	*/
9900	void Machine::i_copyMachineDataToSettings(settings::MachineConfigFile &config)
9901	{
9902	// deep copy extradata, being extra careful with self assignment (the STL
9903	// map assignment on Mac OS X clang based Xcode isn't checking)
9904	if (&config != mData->pMachineConfigFile)
9905	config.mapExtraDataItems = mData->pMachineConfigFile->mapExtraDataItems;
9906
9907	config.uuid = mData->mUuid;
9908
9909	// copy name, description, OS type, teleport, UTC etc.
9910	config.machineUserData = mUserData->s;
9911
9912	if ( mData->mMachineState == MachineState_Saved
9913	\|\| mData->mMachineState == MachineState_Restoring
9914	// when doing certain snapshot operations we may or may not have
9915	// a saved state in the current state, so keep everything as is
9916	\|\| ( ( mData->mMachineState == MachineState_Snapshotting
9917	\|\| mData->mMachineState == MachineState_DeletingSnapshot
9918	\|\| mData->mMachineState == MachineState_RestoringSnapshot)
9919	&& (!mSSData->strStateFilePath.isEmpty())
9920	)
9921	)
9922	{
9923	Assert(!mSSData->strStateFilePath.isEmpty());
9924	/* try to make the file name relative to the settings file dir */
9925	i_copyPathRelativeToMachine(mSSData->strStateFilePath, config.strStateFile);
9926	}
9927	else
9928	{
9929	Assert(mSSData->strStateFilePath.isEmpty() \|\| mData->mMachineState == MachineState_Saving);
9930	config.strStateFile.setNull();
9931	}
9932
9933	if (mData->mCurrentSnapshot)
9934	config.uuidCurrentSnapshot = mData->mCurrentSnapshot->i_getId();
9935	else
9936	config.uuidCurrentSnapshot.clear();
9937
9938	config.timeLastStateChange = mData->mLastStateChange;
9939	config.fAborted = (mData->mMachineState == MachineState_Aborted);
9940	/// @todo Live Migration: config.fTeleported = (mData->mMachineState == MachineState_Teleported);
9941
9942	HRESULT rc = i_saveHardware(config.hardwareMachine, &config.debugging, &config.autostart);
9943	if (FAILED(rc)) throw rc;
9944
9945	// save machine's media registry if this is VirtualBox 4.0 or later
9946	if (config.canHaveOwnMediaRegistry())
9947	{
9948	// determine machine folder
9949	Utf8Str strMachineFolder = i_getSettingsFileFull();
9950	strMachineFolder.stripFilename();
9951	mParent->i_saveMediaRegistry(config.mediaRegistry,
9952	i_getId(), // only media with registry ID == machine UUID
9953	strMachineFolder);
9954	// this throws HRESULT
9955	}
9956
9957	// save snapshots
9958	rc = i_saveAllSnapshots(config);
9959	if (FAILED(rc)) throw rc;
9960	}
9961
9962	/**
9963	* Saves all snapshots of the machine into the given machine config file. Called
9964	* from Machine::buildMachineXML() and SessionMachine::deleteSnapshotHandler().
9965	* @param config
9966	* @return
9967	*/
9968	HRESULT Machine::i_saveAllSnapshots(settings::MachineConfigFile &config)
9969	{
9970	AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
9971
9972	HRESULT rc = S_OK;
9973
9974	try
9975	{
9976	config.llFirstSnapshot.clear();
9977
9978	if (mData->mFirstSnapshot)
9979	{
9980	// the settings use a list for "the first snapshot"
9981	config.llFirstSnapshot.push_back(settings::Snapshot::Empty);
9982
9983	// get reference to the snapshot on the list and work on that
9984	// element straight in the list to avoid excessive copying later
9985	rc = mData->mFirstSnapshot->i_saveSnapshot(config.llFirstSnapshot.back());
9986	if (FAILED(rc)) throw rc;
9987	}
9988
9989	// if (mType == IsSessionMachine)
9990	// mParent->onMachineDataChange(mData->mUuid); @todo is this necessary?
9991
9992	}
9993	catch (HRESULT err)
9994	{
9995	/* we assume that error info is set by the thrower */
9996	rc = err;
9997	}
9998	catch (...)
9999	{
10000	rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
10001	}
10002
10003	return rc;
10004	}
10005
10006	/**
10007	* Saves the VM hardware configuration. It is assumed that the
10008	* given node is empty.
10009	*
10010	* @param data Reference to the settings object for the hardware config.
10011	* @param pDbg Pointer to the settings object for the debugging config
10012	* which happens to live in mHWData.
10013	* @param pAutostart Pointer to the settings object for the autostart config
10014	* which happens to live in mHWData.
10015	*/
10016	HRESULT Machine::i_saveHardware(settings::Hardware &data, settings::Debugging *pDbg,
10017	settings::Autostart *pAutostart)
10018	{
10019	HRESULT rc = S_OK;
10020
10021	try
10022	{
10023	/* The hardware version attribute (optional).
10024	Automatically upgrade from 1 to current default hardware version
10025	when there is no saved state. (ugly!) */
10026	if ( mHWData->mHWVersion == "1"
10027	&& mSSData->strStateFilePath.isEmpty()
10028	)
10029	mHWData->mHWVersion.printf("%d", SchemaDefs::DefaultHardwareVersion);
10030
10031	data.strVersion = mHWData->mHWVersion;
10032	data.uuid = mHWData->mHardwareUUID;
10033
10034	// CPU
10035	data.fHardwareVirt = !!mHWData->mHWVirtExEnabled;
10036	data.fNestedPaging = !!mHWData->mHWVirtExNestedPagingEnabled;
10037	data.fLargePages = !!mHWData->mHWVirtExLargePagesEnabled;
10038	data.fVPID = !!mHWData->mHWVirtExVPIDEnabled;
10039	data.fUnrestrictedExecution = !!mHWData->mHWVirtExUXEnabled;
10040	data.fHardwareVirtForce = !!mHWData->mHWVirtExForceEnabled;
10041	data.fUseNativeApi = !!mHWData->mHWVirtExUseNativeApi;
10042	data.fVirtVmsaveVmload = !!mHWData->mHWVirtExVirtVmsaveVmload;
10043	data.fPAE = !!mHWData->mPAEEnabled;
10044	data.enmLongMode = mHWData->mLongMode;
10045	data.fTripleFaultReset = !!mHWData->mTripleFaultReset;
10046	data.fAPIC = !!mHWData->mAPIC;
10047	data.fX2APIC = !!mHWData->mX2APIC;
10048	data.fIBPBOnVMExit = !!mHWData->mIBPBOnVMExit;
10049	data.fIBPBOnVMEntry = !!mHWData->mIBPBOnVMEntry;
10050	data.fSpecCtrl = !!mHWData->mSpecCtrl;
10051	data.fSpecCtrlByHost = !!mHWData->mSpecCtrlByHost;
10052	data.fL1DFlushOnSched = !!mHWData->mL1DFlushOnSched;
10053	data.fL1DFlushOnVMEntry = !!mHWData->mL1DFlushOnVMEntry;
10054	data.fMDSClearOnSched = !!mHWData->mMDSClearOnSched;
10055	data.fMDSClearOnVMEntry = !!mHWData->mMDSClearOnVMEntry;
10056	data.fNestedHWVirt = !!mHWData->mNestedHWVirt;
10057	data.cCPUs = mHWData->mCPUCount;
10058	data.fCpuHotPlug = !!mHWData->mCPUHotPlugEnabled;
10059	data.ulCpuExecutionCap = mHWData->mCpuExecutionCap;
10060	data.uCpuIdPortabilityLevel = mHWData->mCpuIdPortabilityLevel;
10061	data.strCpuProfile = mHWData->mCpuProfile;
10062
10063	data.llCpus.clear();
10064	if (data.fCpuHotPlug)
10065	{
10066	for (unsigned idx = 0; idx < data.cCPUs; ++idx)
10067	{
10068	if (mHWData->mCPUAttached[idx])
10069	{
10070	settings::Cpu cpu;
10071	cpu.ulId = idx;
10072	data.llCpus.push_back(cpu);
10073	}
10074	}
10075	}
10076
10077	/* Standard and Extended CPUID leafs. */
10078	data.llCpuIdLeafs.clear();
10079	data.llCpuIdLeafs = mHWData->mCpuIdLeafList;
10080
10081	// memory
10082	data.ulMemorySizeMB = mHWData->mMemorySize;
10083	data.fPageFusionEnabled = !!mHWData->mPageFusionEnabled;
10084
10085	// firmware
10086	data.firmwareType = mHWData->mFirmwareType;
10087
10088	// HID
10089	data.pointingHIDType = mHWData->mPointingHIDType;
10090	data.keyboardHIDType = mHWData->mKeyboardHIDType;
10091
10092	// chipset
10093	data.chipsetType = mHWData->mChipsetType;
10094
10095	// paravirt
10096	data.paravirtProvider = mHWData->mParavirtProvider;
10097	data.strParavirtDebug = mHWData->mParavirtDebug;
10098
10099	// emulated USB card reader
10100	data.fEmulatedUSBCardReader = !!mHWData->mEmulatedUSBCardReaderEnabled;
10101
10102	// HPET
10103	data.fHPETEnabled = !!mHWData->mHPETEnabled;
10104
10105	// boot order
10106	data.mapBootOrder.clear();
10107	for (unsigned i = 0; i < RT_ELEMENTS(mHWData->mBootOrder); ++i)
10108	data.mapBootOrder[i] = mHWData->mBootOrder[i];
10109
10110	/* VRDEServer settings (optional) */
10111	rc = mVRDEServer->i_saveSettings(data.vrdeSettings);
10112	if (FAILED(rc)) throw rc;
10113
10114	/* BIOS settings (required) */
10115	rc = mBIOSSettings->i_saveSettings(data.biosSettings);
10116	if (FAILED(rc)) throw rc;
10117
10118	/* Recording settings (required) */
10119	rc = mRecordingSettings->i_saveSettings(data.recordingSettings);
10120	if (FAILED(rc)) throw rc;
10121
10122	/* GraphicsAdapter settings (required) */
10123	rc = mGraphicsAdapter->i_saveSettings(data.graphicsAdapter);
10124	if (FAILED(rc)) throw rc;
10125
10126	/* USB Controller (required) */
10127	data.usbSettings.llUSBControllers.clear();
10128	for (USBControllerList::const_iterator
10129	it = mUSBControllers->begin();
10130	it != mUSBControllers->end();
10131	++it)
10132	{
10133	ComObjPtr<USBController> ctrl = *it;
10134	settings::USBController settingsCtrl;
10135
10136	settingsCtrl.strName = ctrl->i_getName();
10137	settingsCtrl.enmType = ctrl->i_getControllerType();
10138
10139	data.usbSettings.llUSBControllers.push_back(settingsCtrl);
10140	}
10141
10142	/* USB device filters (required) */
10143	rc = mUSBDeviceFilters->i_saveSettings(data.usbSettings);
10144	if (FAILED(rc)) throw rc;
10145
10146	/* Network adapters (required) */
10147	size_t uMaxNICs = RT_MIN(Global::getMaxNetworkAdapters(mHWData->mChipsetType), mNetworkAdapters.size());
10148	data.llNetworkAdapters.clear();
10149	/* Write out only the nominal number of network adapters for this
10150	* chipset type. Since Machine::commit() hasn't been called there
10151	* may be extra NIC settings in the vector. */
10152	for (size_t slot = 0; slot < uMaxNICs; ++slot)
10153	{
10154	settings::NetworkAdapter nic;
10155	nic.ulSlot = (uint32_t)slot;
10156	/* paranoia check... must not be NULL, but must not crash either. */
10157	if (mNetworkAdapters[slot])
10158	{
10159	if (mNetworkAdapters[slot]->i_hasDefaults())
10160	continue;
10161
10162	rc = mNetworkAdapters[slot]->i_saveSettings(nic);
10163	if (FAILED(rc)) throw rc;
10164
10165	data.llNetworkAdapters.push_back(nic);
10166	}
10167	}
10168
10169	/* Serial ports */
10170	data.llSerialPorts.clear();
10171	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
10172	{
10173	if (mSerialPorts[slot]->i_hasDefaults())
10174	continue;
10175
10176	settings::SerialPort s;
10177	s.ulSlot = slot;
10178	rc = mSerialPorts[slot]->i_saveSettings(s);
10179	if (FAILED(rc)) return rc;
10180
10181	data.llSerialPorts.push_back(s);
10182	}
10183
10184	/* Parallel ports */
10185	data.llParallelPorts.clear();
10186	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
10187	{
10188	if (mParallelPorts[slot]->i_hasDefaults())
10189	continue;
10190
10191	settings::ParallelPort p;
10192	p.ulSlot = slot;
10193	rc = mParallelPorts[slot]->i_saveSettings(p);
10194	if (FAILED(rc)) return rc;
10195
10196	data.llParallelPorts.push_back(p);
10197	}
10198
10199	/* Audio adapter */
10200	rc = mAudioAdapter->i_saveSettings(data.audioAdapter);
10201	if (FAILED(rc)) return rc;
10202
10203	rc = i_saveStorageControllers(data.storage);
10204	if (FAILED(rc)) return rc;
10205
10206	/* Shared folders */
10207	data.llSharedFolders.clear();
10208	for (HWData::SharedFolderList::const_iterator
10209	it = mHWData->mSharedFolders.begin();
10210	it != mHWData->mSharedFolders.end();
10211	++it)
10212	{
10213	SharedFolder pSF = it;
10214	AutoCaller sfCaller(pSF);
10215	AutoReadLock sfLock(pSF COMMA_LOCKVAL_SRC_POS);
10216	settings::SharedFolder sf;
10217	sf.strName = pSF->i_getName();
10218	sf.strHostPath = pSF->i_getHostPath();
10219	sf.fWritable = !!pSF->i_isWritable();
10220	sf.fAutoMount = !!pSF->i_isAutoMounted();
10221	sf.strAutoMountPoint = pSF->i_getAutoMountPoint();
10222
10223	data.llSharedFolders.push_back(sf);
10224	}
10225
10226	// clipboard
10227	data.clipboardMode = mHWData->mClipboardMode;
10228	data.fClipboardFileTransfersEnabled = RT_BOOL(mHWData->mClipboardFileTransfersEnabled);
10229
10230	// drag'n'drop
10231	data.dndMode = mHWData->mDnDMode;
10232
10233	/* Guest */
10234	data.ulMemoryBalloonSize = mHWData->mMemoryBalloonSize;
10235
10236	// IO settings
10237	data.ioSettings.fIOCacheEnabled = !!mHWData->mIOCacheEnabled;
10238	data.ioSettings.ulIOCacheSize = mHWData->mIOCacheSize;
10239
10240	/* BandwidthControl (required) */
10241	rc = mBandwidthControl->i_saveSettings(data.ioSettings);
10242	if (FAILED(rc)) throw rc;
10243
10244	/* Host PCI devices */
10245	data.pciAttachments.clear();
10246	for (HWData::PCIDeviceAssignmentList::const_iterator
10247	it = mHWData->mPCIDeviceAssignments.begin();
10248	it != mHWData->mPCIDeviceAssignments.end();
10249	++it)
10250	{
10251	ComObjPtr<PCIDeviceAttachment> pda = *it;
10252	settings::HostPCIDeviceAttachment hpda;
10253
10254	rc = pda->i_saveSettings(hpda);
10255	if (FAILED(rc)) throw rc;
10256
10257	data.pciAttachments.push_back(hpda);
10258	}
10259
10260	// guest properties
10261	data.llGuestProperties.clear();
10262	#ifdef VBOX_WITH_GUEST_PROPS
10263	for (HWData::GuestPropertyMap::const_iterator
10264	it = mHWData->mGuestProperties.begin();
10265	it != mHWData->mGuestProperties.end();
10266	++it)
10267	{
10268	HWData::GuestProperty property = it->second;
10269
10270	/* Remove transient guest properties at shutdown unless we
10271	* are saving state. Note that restoring snapshot intentionally
10272	* keeps them, they will be removed if appropriate once the final
10273	* machine state is set (as crashes etc. need to work). */
10274	if ( ( mData->mMachineState == MachineState_PoweredOff
10275	\|\| mData->mMachineState == MachineState_Aborted
10276	\|\| mData->mMachineState == MachineState_Teleported)
10277	&& (property.mFlags & (GUEST_PROP_F_TRANSIENT \| GUEST_PROP_F_TRANSRESET)))
10278	continue;
10279	settings::GuestProperty prop; /// @todo r=bird: some excellent variable name choices here: 'prop' and 'property'; No 'const' clue either.
10280	prop.strName = it->first;
10281	prop.strValue = property.strValue;
10282	prop.timestamp = (uint64_t)property.mTimestamp;
10283	char szFlags[GUEST_PROP_MAX_FLAGS_LEN + 1];
10284	GuestPropWriteFlags(property.mFlags, szFlags);
10285	prop.strFlags = szFlags;
10286
10287	data.llGuestProperties.push_back(prop);
10288	}
10289
10290	/* I presume this doesn't require a backup(). */
10291	mData->mGuestPropertiesModified = FALSE;
10292	#endif /* VBOX_WITH_GUEST_PROPS defined */
10293
10294	*pDbg = mHWData->mDebugging;
10295	*pAutostart = mHWData->mAutostart;
10296
10297	data.strDefaultFrontend = mHWData->mDefaultFrontend;
10298	}
10299	catch (std::bad_alloc &)
10300	{
10301	return E_OUTOFMEMORY;
10302	}
10303
10304	AssertComRC(rc);
10305	return rc;
10306	}
10307
10308	/**
10309	* Saves the storage controller configuration.
10310	*
10311	* @param data storage settings.
10312	*/
10313	HRESULT Machine::i_saveStorageControllers(settings::Storage &data)
10314	{
10315	data.llStorageControllers.clear();
10316
10317	for (StorageControllerList::const_iterator
10318	it = mStorageControllers->begin();
10319	it != mStorageControllers->end();
10320	++it)
10321	{
10322	HRESULT rc;
10323	ComObjPtr<StorageController> pCtl = *it;
10324
10325	settings::StorageController ctl;
10326	ctl.strName = pCtl->i_getName();
10327	ctl.controllerType = pCtl->i_getControllerType();
10328	ctl.storageBus = pCtl->i_getStorageBus();
10329	ctl.ulInstance = pCtl->i_getInstance();
10330	ctl.fBootable = pCtl->i_getBootable();
10331
10332	/* Save the port count. */
10333	ULONG portCount;
10334	rc = pCtl->COMGETTER(PortCount)(&portCount);
10335	ComAssertComRCRet(rc, rc);
10336	ctl.ulPortCount = portCount;
10337
10338	/* Save fUseHostIOCache */
10339	BOOL fUseHostIOCache;
10340	rc = pCtl->COMGETTER(UseHostIOCache)(&fUseHostIOCache);
10341	ComAssertComRCRet(rc, rc);
10342	ctl.fUseHostIOCache = !!fUseHostIOCache;
10343
10344	/* save the devices now. */
10345	rc = i_saveStorageDevices(pCtl, ctl);
10346	ComAssertComRCRet(rc, rc);
10347
10348	data.llStorageControllers.push_back(ctl);
10349	}
10350
10351	return S_OK;
10352	}
10353
10354	/**
10355	* Saves the hard disk configuration.
10356	*/
10357	HRESULT Machine::i_saveStorageDevices(ComObjPtr<StorageController> aStorageController,
10358	settings::StorageController &data)
10359	{
10360	MediumAttachmentList atts;
10361
10362	HRESULT rc = i_getMediumAttachmentsOfController(aStorageController->i_getName(), atts);
10363	if (FAILED(rc)) return rc;
10364
10365	data.llAttachedDevices.clear();
10366	for (MediumAttachmentList::const_iterator
10367	it = atts.begin();
10368	it != atts.end();
10369	++it)
10370	{
10371	settings::AttachedDevice dev;
10372	IMediumAttachment iA = it;
10373	MediumAttachment pAttach = static_cast<MediumAttachment >(iA);
10374	Medium *pMedium = pAttach->i_getMedium();
10375
10376	dev.deviceType = pAttach->i_getType();
10377	dev.lPort = pAttach->i_getPort();
10378	dev.lDevice = pAttach->i_getDevice();
10379	dev.fPassThrough = pAttach->i_getPassthrough();
10380	dev.fHotPluggable = pAttach->i_getHotPluggable();
10381	if (pMedium)
10382	{
10383	if (pMedium->i_isHostDrive())
10384	dev.strHostDriveSrc = pMedium->i_getLocationFull();
10385	else
10386	dev.uuid = pMedium->i_getId();
10387	dev.fTempEject = pAttach->i_getTempEject();
10388	dev.fNonRotational = pAttach->i_getNonRotational();
10389	dev.fDiscard = pAttach->i_getDiscard();
10390	}
10391
10392	dev.strBwGroup = pAttach->i_getBandwidthGroup();
10393
10394	data.llAttachedDevices.push_back(dev);
10395	}
10396
10397	return S_OK;
10398	}
10399
10400	/**
10401	* Saves machine state settings as defined by aFlags
10402	* (SaveSTS_* values).
10403	*
10404	* @param aFlags Combination of SaveSTS_* flags.
10405	*
10406	* @note Locks objects for writing.
10407	*/
10408	HRESULT Machine::i_saveStateSettings(int aFlags)
10409	{
10410	if (aFlags == 0)
10411	return S_OK;
10412
10413	AutoCaller autoCaller(this);
10414	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10415
10416	/* This object's write lock is also necessary to serialize file access
10417	* (prevent concurrent reads and writes) */
10418	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
10419
10420	HRESULT rc = S_OK;
10421
10422	Assert(mData->pMachineConfigFile);
10423
10424	try
10425	{
10426	if (aFlags & SaveSTS_CurStateModified)
10427	mData->pMachineConfigFile->fCurrentStateModified = true;
10428
10429	if (aFlags & SaveSTS_StateFilePath)
10430	{
10431	if (!mSSData->strStateFilePath.isEmpty())
10432	/* try to make the file name relative to the settings file dir */
10433	i_copyPathRelativeToMachine(mSSData->strStateFilePath, mData->pMachineConfigFile->strStateFile);
10434	else
10435	mData->pMachineConfigFile->strStateFile.setNull();
10436	}
10437
10438	if (aFlags & SaveSTS_StateTimeStamp)
10439	{
10440	Assert( mData->mMachineState != MachineState_Aborted
10441	\|\| mSSData->strStateFilePath.isEmpty());
10442
10443	mData->pMachineConfigFile->timeLastStateChange = mData->mLastStateChange;
10444
10445	mData->pMachineConfigFile->fAborted = (mData->mMachineState == MachineState_Aborted);
10446	/// @todo live migration mData->pMachineConfigFile->fTeleported = (mData->mMachineState == MachineState_Teleported);
10447	}
10448
10449	mData->pMachineConfigFile->write(mData->m_strConfigFileFull);
10450	}
10451	catch (...)
10452	{
10453	rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
10454	}
10455
10456	return rc;
10457	}
10458
10459	/**
10460	* Ensures that the given medium is added to a media registry. If this machine
10461	* was created with 4.0 or later, then the machine registry is used. Otherwise
10462	* the global VirtualBox media registry is used.
10463	*
10464	* Caller must NOT hold machine lock, media tree or any medium locks!
10465	*
10466	* @param pMedium
10467	*/
10468	void Machine::i_addMediumToRegistry(ComObjPtr<Medium> &pMedium)
10469	{
10470	/* Paranoia checks: do not hold machine or media tree locks. */
10471	AssertReturnVoid(!isWriteLockOnCurrentThread());
10472	AssertReturnVoid(!mParent->i_getMediaTreeLockHandle().isWriteLockOnCurrentThread());
10473
10474	ComObjPtr<Medium> pBase;
10475	{
10476	AutoReadLock treeLock(&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
10477	pBase = pMedium->i_getBase();
10478	}
10479
10480	/* Paranoia checks: do not hold medium locks. */
10481	AssertReturnVoid(!pMedium->isWriteLockOnCurrentThread());
10482	AssertReturnVoid(!pBase->isWriteLockOnCurrentThread());
10483
10484	// decide which medium registry to use now that the medium is attached:
10485	Guid uuid;
10486	bool fCanHaveOwnMediaRegistry = mData->pMachineConfigFile->canHaveOwnMediaRegistry();
10487	if (fCanHaveOwnMediaRegistry)
10488	// machine XML is VirtualBox 4.0 or higher:
10489	uuid = i_getId(); // machine UUID
10490	else
10491	uuid = mParent->i_getGlobalRegistryId(); // VirtualBox global registry UUID
10492
10493	if (fCanHaveOwnMediaRegistry && pMedium->i_removeRegistry(mParent->i_getGlobalRegistryId()))
10494	mParent->i_markRegistryModified(mParent->i_getGlobalRegistryId());
10495	if (pMedium->i_addRegistry(uuid))
10496	mParent->i_markRegistryModified(uuid);
10497
10498	/* For more complex hard disk structures it can happen that the base
10499	* medium isn't yet associated with any medium registry. Do that now. */
10500	if (pMedium != pBase)
10501	{
10502	/* Tree lock needed by Medium::addRegistry when recursing. */
10503	AutoReadLock treeLock(&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
10504	if (fCanHaveOwnMediaRegistry && pMedium->i_removeRegistryRecursive(mParent->i_getGlobalRegistryId()))
10505	{
10506	treeLock.release();
10507	mParent->i_markRegistryModified(mParent->i_getGlobalRegistryId());
10508	treeLock.acquire();
10509	}
10510	if (pBase->i_addRegistryRecursive(uuid))
10511	{
10512	treeLock.release();
10513	mParent->i_markRegistryModified(uuid);
10514	}
10515	}
10516	}
10517
10518	/**
10519	* Creates differencing hard disks for all normal hard disks attached to this
10520	* machine and a new set of attachments to refer to created disks.
10521	*
10522	* Used when taking a snapshot or when deleting the current state. Gets called
10523	* from SessionMachine::BeginTakingSnapshot() and SessionMachine::restoreSnapshotHandler().
10524	*
10525	* This method assumes that mMediumAttachments contains the original hard disk
10526	* attachments it needs to create diffs for. On success, these attachments will
10527	* be replaced with the created diffs.
10528	*
10529	* Attachments with non-normal hard disks are left as is.
10530	*
10531	* If @a aOnline is @c false then the original hard disks that require implicit
10532	* diffs will be locked for reading. Otherwise it is assumed that they are
10533	* already locked for writing (when the VM was started). Note that in the latter
10534	* case it is responsibility of the caller to lock the newly created diffs for
10535	* writing if this method succeeds.
10536	*
10537	* @param aProgress Progress object to run (must contain at least as
10538	* many operations left as the number of hard disks
10539	* attached).
10540	* @param aWeight Weight of this operation.
10541	* @param aOnline Whether the VM was online prior to this operation.
10542	*
10543	* @note The progress object is not marked as completed, neither on success nor
10544	* on failure. This is a responsibility of the caller.
10545	*
10546	* @note Locks this object and the media tree for writing.
10547	*/
10548	HRESULT Machine::i_createImplicitDiffs(IProgress *aProgress,
10549	ULONG aWeight,
10550	bool aOnline)
10551	{
10552	LogFlowThisFunc(("aOnline=%d\n", aOnline));
10553
10554	ComPtr<IInternalProgressControl> pProgressControl(aProgress);
10555	AssertReturn(!!pProgressControl, E_INVALIDARG);
10556
10557	AutoCaller autoCaller(this);
10558	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10559
10560	AutoMultiWriteLock2 alock(this->lockHandle(),
10561	&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
10562
10563	/* must be in a protective state because we release the lock below */
10564	AssertReturn( mData->mMachineState == MachineState_Snapshotting
10565	\|\| mData->mMachineState == MachineState_OnlineSnapshotting
10566	\|\| mData->mMachineState == MachineState_LiveSnapshotting
10567	\|\| mData->mMachineState == MachineState_RestoringSnapshot
10568	\|\| mData->mMachineState == MachineState_DeletingSnapshot
10569	, E_FAIL);
10570
10571	HRESULT rc = S_OK;
10572
10573	// use appropriate locked media map (online or offline)
10574	MediumLockListMap lockedMediaOffline;
10575	MediumLockListMap *lockedMediaMap;
10576	if (aOnline)
10577	lockedMediaMap = &mData->mSession.mLockedMedia;
10578	else
10579	lockedMediaMap = &lockedMediaOffline;
10580
10581	try
10582	{
10583	if (!aOnline)
10584	{
10585	/* lock all attached hard disks early to detect "in use"
10586	* situations before creating actual diffs */
10587	for (MediumAttachmentList::const_iterator
10588	it = mMediumAttachments->begin();
10589	it != mMediumAttachments->end();
10590	++it)
10591	{
10592	MediumAttachment pAtt = it;
10593	if (pAtt->i_getType() == DeviceType_HardDisk)
10594	{
10595	Medium *pMedium = pAtt->i_getMedium();
10596	Assert(pMedium);
10597
10598	MediumLockList *pMediumLockList(new MediumLockList());
10599	alock.release();
10600	rc = pMedium->i_createMediumLockList(true /* fFailIfInaccessible */,
10601	NULL /* pToLockWrite */,
10602	false /* fMediumLockWriteAll */,
10603	NULL,
10604	*pMediumLockList);
10605	alock.acquire();
10606	if (FAILED(rc))
10607	{
10608	delete pMediumLockList;
10609	throw rc;
10610	}
10611	rc = lockedMediaMap->Insert(pAtt, pMediumLockList);
10612	if (FAILED(rc))
10613	{
10614	throw setError(rc,
10615	tr("Collecting locking information for all attached media failed"));
10616	}
10617	}
10618	}
10619
10620	/* Now lock all media. If this fails, nothing is locked. */
10621	alock.release();
10622	rc = lockedMediaMap->Lock();
10623	alock.acquire();
10624	if (FAILED(rc))
10625	{
10626	throw setError(rc,
10627	tr("Locking of attached media failed"));
10628	}
10629	}
10630
10631	/* remember the current list (note that we don't use backup() since
10632	* mMediumAttachments may be already backed up) */
10633	MediumAttachmentList atts = *mMediumAttachments.data();
10634
10635	/* start from scratch */
10636	mMediumAttachments->clear();
10637
10638	/* go through remembered attachments and create diffs for normal hard
10639	* disks and attach them */
10640	for (MediumAttachmentList::const_iterator
10641	it = atts.begin();
10642	it != atts.end();
10643	++it)
10644	{
10645	MediumAttachment pAtt = it;
10646
10647	DeviceType_T devType = pAtt->i_getType();
10648	Medium *pMedium = pAtt->i_getMedium();
10649
10650	if ( devType != DeviceType_HardDisk
10651	\|\| pMedium == NULL
10652	\|\| pMedium->i_getType() != MediumType_Normal)
10653	{
10654	/* copy the attachment as is */
10655
10656	/** @todo the progress object created in SessionMachine::TakeSnaphot
10657	* only expects operations for hard disks. Later other
10658	* device types need to show up in the progress as well. */
10659	if (devType == DeviceType_HardDisk)
10660	{
10661	if (pMedium == NULL)
10662	pProgressControl->SetNextOperation(Bstr(tr("Skipping attachment without medium")).raw(),
10663	aWeight); // weight
10664	else
10665	pProgressControl->SetNextOperation(BstrFmt(tr("Skipping medium '%s'"),
10666	pMedium->i_getBase()->i_getName().c_str()).raw(),
10667	aWeight); // weight
10668	}
10669
10670	mMediumAttachments->push_back(pAtt);
10671	continue;
10672	}
10673
10674	/* need a diff */
10675	pProgressControl->SetNextOperation(BstrFmt(tr("Creating differencing hard disk for '%s'"),
10676	pMedium->i_getBase()->i_getName().c_str()).raw(),
10677	aWeight); // weight
10678
10679	Utf8Str strFullSnapshotFolder;
10680	i_calculateFullPath(mUserData->s.strSnapshotFolder, strFullSnapshotFolder);
10681
10682	ComObjPtr<Medium> diff;
10683	diff.createObject();
10684	// store the diff in the same registry as the parent
10685	// (this cannot fail here because we can't create implicit diffs for
10686	// unregistered images)
10687	Guid uuidRegistryParent;
10688	bool fInRegistry = pMedium->i_getFirstRegistryMachineId(uuidRegistryParent);
10689	Assert(fInRegistry); NOREF(fInRegistry);
10690	rc = diff->init(mParent,
10691	pMedium->i_getPreferredDiffFormat(),
10692	strFullSnapshotFolder.append(RTPATH_SLASH_STR),
10693	uuidRegistryParent,
10694	DeviceType_HardDisk);
10695	if (FAILED(rc)) throw rc;
10696
10697	/** @todo r=bird: How is the locking and diff image cleaned up if we fail before
10698	* the push_back? Looks like we're going to release medium with the
10699	* wrong kind of lock (general issue with if we fail anywhere at all)
10700	* and an orphaned VDI in the snapshots folder. */
10701
10702	/* update the appropriate lock list */
10703	MediumLockList *pMediumLockList;
10704	rc = lockedMediaMap->Get(pAtt, pMediumLockList);
10705	AssertComRCThrowRC(rc);
10706	if (aOnline)
10707	{
10708	alock.release();
10709	/* The currently attached medium will be read-only, change
10710	* the lock type to read. */
10711	rc = pMediumLockList->Update(pMedium, false);
10712	alock.acquire();
10713	AssertComRCThrowRC(rc);
10714	}
10715
10716	/* release the locks before the potentially lengthy operation */
10717	alock.release();
10718	rc = pMedium->i_createDiffStorage(diff,
10719	pMedium->i_getPreferredDiffVariant(),
10720	pMediumLockList,
10721	NULL /* aProgress */,
10722	true /* aWait */,
10723	false /* aNotify */);
10724	alock.acquire();
10725	if (FAILED(rc)) throw rc;
10726
10727	/* actual lock list update is done in Machine::i_commitMedia */
10728
10729	rc = diff->i_addBackReference(mData->mUuid);
10730	AssertComRCThrowRC(rc);
10731
10732	/* add a new attachment */
10733	ComObjPtr<MediumAttachment> attachment;
10734	attachment.createObject();
10735	rc = attachment->init(this,
10736	diff,
10737	pAtt->i_getControllerName(),
10738	pAtt->i_getPort(),
10739	pAtt->i_getDevice(),
10740	DeviceType_HardDisk,
10741	true /* aImplicit */,
10742	false /* aPassthrough */,
10743	false /* aTempEject */,
10744	pAtt->i_getNonRotational(),
10745	pAtt->i_getDiscard(),
10746	pAtt->i_getHotPluggable(),
10747	pAtt->i_getBandwidthGroup());
10748	if (FAILED(rc)) throw rc;
10749
10750	rc = lockedMediaMap->ReplaceKey(pAtt, attachment);
10751	AssertComRCThrowRC(rc);
10752	mMediumAttachments->push_back(attachment);
10753	}
10754	}
10755	catch (HRESULT aRC) { rc = aRC; }
10756
10757	/* unlock all hard disks we locked when there is no VM */
10758	if (!aOnline)
10759	{
10760	ErrorInfoKeeper eik;
10761
10762	HRESULT rc1 = lockedMediaMap->Clear();
10763	AssertComRC(rc1);
10764	}
10765
10766	return rc;
10767	}
10768
10769	/**
10770	* Deletes implicit differencing hard disks created either by
10771	* #i_createImplicitDiffs() or by #attachDevice() and rolls back
10772	* mMediumAttachments.
10773	*
10774	* Note that to delete hard disks created by #attachDevice() this method is
10775	* called from #i_rollbackMedia() when the changes are rolled back.
10776	*
10777	* @note Locks this object and the media tree for writing.
10778	*/
10779	HRESULT Machine::i_deleteImplicitDiffs(bool aOnline)
10780	{
10781	LogFlowThisFunc(("aOnline=%d\n", aOnline));
10782
10783	AutoCaller autoCaller(this);
10784	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10785
10786	AutoMultiWriteLock2 alock(this->lockHandle(),
10787	&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
10788
10789	/* We absolutely must have backed up state. */
10790	AssertReturn(mMediumAttachments.isBackedUp(), E_FAIL);
10791
10792	/* Check if there are any implicitly created diff images. */
10793	bool fImplicitDiffs = false;
10794	for (MediumAttachmentList::const_iterator
10795	it = mMediumAttachments->begin();
10796	it != mMediumAttachments->end();
10797	++it)
10798	{
10799	const ComObjPtr<MediumAttachment> &pAtt = *it;
10800	if (pAtt->i_isImplicit())
10801	{
10802	fImplicitDiffs = true;
10803	break;
10804	}
10805	}
10806	/* If there is nothing to do, leave early. This saves lots of image locking
10807	* effort. It also avoids a MachineStateChanged event without real reason.
10808	* This is important e.g. when loading a VM config, because there should be
10809	* no events. Otherwise API clients can become thoroughly confused for
10810	* inaccessible VMs (the code for loading VM configs uses this method for
10811	* cleanup if the config makes no sense), as they take such events as an
10812	* indication that the VM is alive, and they would force the VM config to
10813	* be reread, leading to an endless loop. */
10814	if (!fImplicitDiffs)
10815	return S_OK;
10816
10817	HRESULT rc = S_OK;
10818	MachineState_T oldState = mData->mMachineState;
10819
10820	/* will release the lock before the potentially lengthy operation,
10821	* so protect with the special state (unless already protected) */
10822	if ( oldState != MachineState_Snapshotting
10823	&& oldState != MachineState_OnlineSnapshotting
10824	&& oldState != MachineState_LiveSnapshotting
10825	&& oldState != MachineState_RestoringSnapshot
10826	&& oldState != MachineState_DeletingSnapshot
10827	&& oldState != MachineState_DeletingSnapshotOnline
10828	&& oldState != MachineState_DeletingSnapshotPaused
10829	)
10830	i_setMachineState(MachineState_SettingUp);
10831
10832	// use appropriate locked media map (online or offline)
10833	MediumLockListMap lockedMediaOffline;
10834	MediumLockListMap *lockedMediaMap;
10835	if (aOnline)
10836	lockedMediaMap = &mData->mSession.mLockedMedia;
10837	else
10838	lockedMediaMap = &lockedMediaOffline;
10839
10840	try
10841	{
10842	if (!aOnline)
10843	{
10844	/* lock all attached hard disks early to detect "in use"
10845	* situations before deleting actual diffs */
10846	for (MediumAttachmentList::const_iterator
10847	it = mMediumAttachments->begin();
10848	it != mMediumAttachments->end();
10849	++it)
10850	{
10851	MediumAttachment pAtt = it;
10852	if (pAtt->i_getType() == DeviceType_HardDisk)
10853	{
10854	Medium *pMedium = pAtt->i_getMedium();
10855	Assert(pMedium);
10856
10857	MediumLockList *pMediumLockList(new MediumLockList());
10858	alock.release();
10859	rc = pMedium->i_createMediumLockList(true /* fFailIfInaccessible */,
10860	NULL /* pToLockWrite */,
10861	false /* fMediumLockWriteAll */,
10862	NULL,
10863	*pMediumLockList);
10864	alock.acquire();
10865
10866	if (FAILED(rc))
10867	{
10868	delete pMediumLockList;
10869	throw rc;
10870	}
10871
10872	rc = lockedMediaMap->Insert(pAtt, pMediumLockList);
10873	if (FAILED(rc))
10874	throw rc;
10875	}
10876	}
10877
10878	if (FAILED(rc))
10879	throw rc;
10880	} // end of offline
10881
10882	/* Lock lists are now up to date and include implicitly created media */
10883
10884	/* Go through remembered attachments and delete all implicitly created
10885	* diffs and fix up the attachment information */
10886	const MediumAttachmentList &oldAtts = *mMediumAttachments.backedUpData();
10887	MediumAttachmentList implicitAtts;
10888	for (MediumAttachmentList::const_iterator
10889	it = mMediumAttachments->begin();
10890	it != mMediumAttachments->end();
10891	++it)
10892	{
10893	ComObjPtr<MediumAttachment> pAtt = *it;
10894	ComObjPtr<Medium> pMedium = pAtt->i_getMedium();
10895	if (pMedium.isNull())
10896	continue;
10897
10898	// Implicit attachments go on the list for deletion and back references are removed.
10899	if (pAtt->i_isImplicit())
10900	{
10901	/* Deassociate and mark for deletion */
10902	LogFlowThisFunc(("Detaching '%s', pending deletion\n", pAtt->i_getLogName()));
10903	rc = pMedium->i_removeBackReference(mData->mUuid);
10904	if (FAILED(rc))
10905	throw rc;
10906	implicitAtts.push_back(pAtt);
10907	continue;
10908	}
10909
10910	/* Was this medium attached before? */
10911	if (!i_findAttachment(oldAtts, pMedium))
10912	{
10913	/* no: de-associate */
10914	LogFlowThisFunc(("Detaching '%s', no deletion\n", pAtt->i_getLogName()));
10915	rc = pMedium->i_removeBackReference(mData->mUuid);
10916	if (FAILED(rc))
10917	throw rc;
10918	continue;
10919	}
10920	LogFlowThisFunc(("Not detaching '%s'\n", pAtt->i_getLogName()));
10921	}
10922
10923	/* If there are implicit attachments to delete, throw away the lock
10924	* map contents (which will unlock all media) since the medium
10925	* attachments will be rolled back. Below we need to completely
10926	* recreate the lock map anyway since it is infinitely complex to
10927	* do this incrementally (would need reconstructing each attachment
10928	* change, which would be extremely hairy). */
10929	if (implicitAtts.size() != 0)
10930	{
10931	ErrorInfoKeeper eik;
10932
10933	HRESULT rc1 = lockedMediaMap->Clear();
10934	AssertComRC(rc1);
10935	}
10936
10937	/* rollback hard disk changes */
10938	mMediumAttachments.rollback();
10939
10940	MultiResult mrc(S_OK);
10941
10942	// Delete unused implicit diffs.
10943	if (implicitAtts.size() != 0)
10944	{
10945	alock.release();
10946
10947	for (MediumAttachmentList::const_iterator
10948	it = implicitAtts.begin();
10949	it != implicitAtts.end();
10950	++it)
10951	{
10952	// Remove medium associated with this attachment.
10953	ComObjPtr<MediumAttachment> pAtt = *it;
10954	Assert(pAtt);
10955	LogFlowThisFunc(("Deleting '%s'\n", pAtt->i_getLogName()));
10956	ComObjPtr<Medium> pMedium = pAtt->i_getMedium();
10957	Assert(pMedium);
10958
10959	rc = pMedium->i_deleteStorage(NULL /aProgress/, true /aWait/, false /aNotify/);
10960	// continue on delete failure, just collect error messages
10961	AssertMsg(SUCCEEDED(rc), ("rc=%Rhrc it=%s hd=%s\n", rc, pAtt->i_getLogName(),
10962	pMedium->i_getLocationFull().c_str() ));
10963	mrc = rc;
10964	}
10965	// Clear the list of deleted implicit attachments now, while not
10966	// holding the lock, as it will ultimately trigger Medium::uninit()
10967	// calls which assume that the media tree lock isn't held.
10968	implicitAtts.clear();
10969
10970	alock.acquire();
10971
10972	/* if there is a VM recreate media lock map as mentioned above,
10973	* otherwise it is a waste of time and we leave things unlocked */
10974	if (aOnline)
10975	{
10976	const ComObjPtr<SessionMachine> pMachine = mData->mSession.mMachine;
10977	/* must never be NULL, but better safe than sorry */
10978	if (!pMachine.isNull())
10979	{
10980	alock.release();
10981	rc = mData->mSession.mMachine->i_lockMedia();
10982	alock.acquire();
10983	if (FAILED(rc))
10984	throw rc;
10985	}
10986	}
10987	}
10988	}
10989	catch (HRESULT aRC) {rc = aRC;}
10990
10991	if (mData->mMachineState == MachineState_SettingUp)
10992	i_setMachineState(oldState);
10993
10994	/* unlock all hard disks we locked when there is no VM */
10995	if (!aOnline)
10996	{
10997	ErrorInfoKeeper eik;
10998
10999	HRESULT rc1 = lockedMediaMap->Clear();
11000	AssertComRC(rc1);
11001	}
11002
11003	return rc;
11004	}
11005
11006
11007	/**
11008	* Looks through the given list of media attachments for one with the given parameters
11009	* and returns it, or NULL if not found. The list is a parameter so that backup lists
11010	* can be searched as well if needed.
11011	*
11012	* @param ll
11013	* @param aControllerName
11014	* @param aControllerPort
11015	* @param aDevice
11016	* @return
11017	*/
11018	MediumAttachment *Machine::i_findAttachment(const MediumAttachmentList &ll,
11019	const Utf8Str &aControllerName,
11020	LONG aControllerPort,
11021	LONG aDevice)
11022	{
11023	for (MediumAttachmentList::const_iterator
11024	it = ll.begin();
11025	it != ll.end();
11026	++it)
11027	{
11028	MediumAttachment pAttach = it;
11029	if (pAttach->i_matches(aControllerName, aControllerPort, aDevice))
11030	return pAttach;
11031	}
11032
11033	return NULL;
11034	}
11035
11036	/**
11037	* Looks through the given list of media attachments for one with the given parameters
11038	* and returns it, or NULL if not found. The list is a parameter so that backup lists
11039	* can be searched as well if needed.
11040	*
11041	* @param ll
11042	* @param pMedium
11043	* @return
11044	*/
11045	MediumAttachment *Machine::i_findAttachment(const MediumAttachmentList &ll,
11046	ComObjPtr<Medium> pMedium)
11047	{
11048	for (MediumAttachmentList::const_iterator
11049	it = ll.begin();
11050	it != ll.end();
11051	++it)
11052	{
11053	MediumAttachment pAttach = it;
11054	ComObjPtr<Medium> pMediumThis = pAttach->i_getMedium();
11055	if (pMediumThis == pMedium)
11056	return pAttach;
11057	}
11058
11059	return NULL;
11060	}
11061
11062	/**
11063	* Looks through the given list of media attachments for one with the given parameters
11064	* and returns it, or NULL if not found. The list is a parameter so that backup lists
11065	* can be searched as well if needed.
11066	*
11067	* @param ll
11068	* @param id
11069	* @return
11070	*/
11071	MediumAttachment *Machine::i_findAttachment(const MediumAttachmentList &ll,
11072	Guid &id)
11073	{
11074	for (MediumAttachmentList::const_iterator
11075	it = ll.begin();
11076	it != ll.end();
11077	++it)
11078	{
11079	MediumAttachment pAttach = it;
11080	ComObjPtr<Medium> pMediumThis = pAttach->i_getMedium();
11081	if (pMediumThis->i_getId() == id)
11082	return pAttach;
11083	}
11084
11085	return NULL;
11086	}
11087
11088	/**
11089	* Main implementation for Machine::DetachDevice. This also gets called
11090	* from Machine::prepareUnregister() so it has been taken out for simplicity.
11091	*
11092	* @param pAttach Medium attachment to detach.
11093	* @param writeLock Machine write lock which the caller must have locked once.
11094	* This may be released temporarily in here.
11095	* @param pSnapshot If NULL, then the detachment is for the current machine.
11096	* Otherwise this is for a SnapshotMachine, and this must be
11097	* its snapshot.
11098	* @return
11099	*/
11100	HRESULT Machine::i_detachDevice(MediumAttachment *pAttach,
11101	AutoWriteLock &writeLock,
11102	Snapshot *pSnapshot)
11103	{
11104	ComObjPtr<Medium> oldmedium = pAttach->i_getMedium();
11105	DeviceType_T mediumType = pAttach->i_getType();
11106
11107	LogFlowThisFunc(("Entering, medium of attachment is %s\n", oldmedium ? oldmedium->i_getLocationFull().c_str() : "NULL"));
11108
11109	if (pAttach->i_isImplicit())
11110	{
11111	/* attempt to implicitly delete the implicitly created diff */
11112
11113	/// @todo move the implicit flag from MediumAttachment to Medium
11114	/// and forbid any hard disk operation when it is implicit. Or maybe
11115	/// a special media state for it to make it even more simple.
11116
11117	Assert(mMediumAttachments.isBackedUp());
11118
11119	/* will release the lock before the potentially lengthy operation, so
11120	* protect with the special state */
11121	MachineState_T oldState = mData->mMachineState;
11122	i_setMachineState(MachineState_SettingUp);
11123
11124	writeLock.release();
11125
11126	HRESULT rc = oldmedium->i_deleteStorage(NULL /aProgress/,
11127	true /aWait/,
11128	false /aNotify/);
11129
11130	writeLock.acquire();
11131
11132	i_setMachineState(oldState);
11133
11134	if (FAILED(rc)) return rc;
11135	}
11136
11137	i_setModified(IsModified_Storage);
11138	mMediumAttachments.backup();
11139	mMediumAttachments->remove(pAttach);
11140
11141	if (!oldmedium.isNull())
11142	{
11143	// if this is from a snapshot, do not defer detachment to i_commitMedia()
11144	if (pSnapshot)
11145	oldmedium->i_removeBackReference(mData->mUuid, pSnapshot->i_getId());
11146	// else if non-hard disk media, do not defer detachment to i_commitMedia() either
11147	else if (mediumType != DeviceType_HardDisk)
11148	oldmedium->i_removeBackReference(mData->mUuid);
11149	}
11150
11151	return S_OK;
11152	}
11153
11154	/**
11155	* Goes thru all media of the given list and
11156	*
11157	* 1) calls i_detachDevice() on each of them for this machine and
11158	* 2) adds all Medium objects found in the process to the given list,
11159	* depending on cleanupMode.
11160	*
11161	* If cleanupMode is CleanupMode_DetachAllReturnHardDisksOnly, this only
11162	* adds hard disks to the list. If it is CleanupMode_Full, this adds all
11163	* media to the list.
11164	*
11165	* This gets called from Machine::Unregister, both for the actual Machine and
11166	* the SnapshotMachine objects that might be found in the snapshots.
11167	*
11168	* Requires caller and locking. The machine lock must be passed in because it
11169	* will be passed on to i_detachDevice which needs it for temporary unlocking.
11170	*
11171	* @param writeLock Machine lock from top-level caller; this gets passed to
11172	* i_detachDevice.
11173	* @param pSnapshot Must be NULL when called for a "real" Machine or a snapshot
11174	* object if called for a SnapshotMachine.
11175	* @param cleanupMode If DetachAllReturnHardDisksOnly, only hard disk media get
11176	* added to llMedia; if Full, then all media get added;
11177	* otherwise no media get added.
11178	* @param llMedia Caller's list to receive Medium objects which got detached so
11179	* caller can close() them, depending on cleanupMode.
11180	* @return
11181	*/
11182	HRESULT Machine::i_detachAllMedia(AutoWriteLock &writeLock,
11183	Snapshot *pSnapshot,
11184	CleanupMode_T cleanupMode,
11185	MediaList &llMedia)
11186	{
11187	Assert(isWriteLockOnCurrentThread());
11188
11189	HRESULT rc;
11190
11191	// make a temporary list because i_detachDevice invalidates iterators into
11192	// mMediumAttachments
11193	MediumAttachmentList llAttachments2 = *mMediumAttachments.data();
11194
11195	for (MediumAttachmentList::iterator
11196	it = llAttachments2.begin();
11197	it != llAttachments2.end();
11198	++it)
11199	{
11200	ComObjPtr<MediumAttachment> &pAttach = *it;
11201	ComObjPtr<Medium> pMedium = pAttach->i_getMedium();
11202
11203	if (!pMedium.isNull())
11204	{
11205	AutoCaller mac(pMedium);
11206	if (FAILED(mac.rc())) return mac.rc();
11207	AutoReadLock lock(pMedium COMMA_LOCKVAL_SRC_POS);
11208	DeviceType_T devType = pMedium->i_getDeviceType();
11209	if ( ( cleanupMode == CleanupMode_DetachAllReturnHardDisksOnly
11210	&& devType == DeviceType_HardDisk)
11211	\|\| (cleanupMode == CleanupMode_Full)
11212	)
11213	{
11214	llMedia.push_back(pMedium);
11215	ComObjPtr<Medium> pParent = pMedium->i_getParent();
11216	/* Not allowed to keep this lock as below we need the parent
11217	* medium lock, and the lock order is parent to child. */
11218	lock.release();
11219	/*
11220	* Search for medias which are not attached to any machine, but
11221	* in the chain to an attached disk. Mediums are only consided
11222	* if they are:
11223	* - have only one child
11224	* - no references to any machines
11225	* - are of normal medium type
11226	*/
11227	while (!pParent.isNull())
11228	{
11229	AutoCaller mac1(pParent);
11230	if (FAILED(mac1.rc())) return mac1.rc();
11231	AutoReadLock lock1(pParent COMMA_LOCKVAL_SRC_POS);
11232	if (pParent->i_getChildren().size() == 1)
11233	{
11234	if ( pParent->i_getMachineBackRefCount() == 0
11235	&& pParent->i_getType() == MediumType_Normal
11236	&& find(llMedia.begin(), llMedia.end(), pParent) == llMedia.end())
11237	llMedia.push_back(pParent);
11238	}
11239	else
11240	break;
11241	pParent = pParent->i_getParent();
11242	}
11243	}
11244	}
11245
11246	// real machine: then we need to use the proper method
11247	rc = i_detachDevice(pAttach, writeLock, pSnapshot);
11248
11249	if (FAILED(rc))
11250	return rc;
11251	}
11252
11253	return S_OK;
11254	}
11255
11256	/**
11257	* Perform deferred hard disk detachments.
11258	*
11259	* Does nothing if the hard disk attachment data (mMediumAttachments) is not
11260	* changed (not backed up).
11261	*
11262	* If @a aOnline is @c true then this method will also unlock the old hard
11263	* disks for which the new implicit diffs were created and will lock these new
11264	* diffs for writing.
11265	*
11266	* @param aOnline Whether the VM was online prior to this operation.
11267	*
11268	* @note Locks this object for writing!
11269	*/
11270	void Machine::i_commitMedia(bool aOnline /= false/)
11271	{
11272	AutoCaller autoCaller(this);
11273	AssertComRCReturnVoid(autoCaller.rc());
11274
11275	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
11276
11277	LogFlowThisFunc(("Entering, aOnline=%d\n", aOnline));
11278
11279	HRESULT rc = S_OK;
11280
11281	/* no attach/detach operations -- nothing to do */
11282	if (!mMediumAttachments.isBackedUp())
11283	return;
11284
11285	MediumAttachmentList &oldAtts = *mMediumAttachments.backedUpData();
11286	bool fMediaNeedsLocking = false;
11287
11288	/* enumerate new attachments */
11289	for (MediumAttachmentList::const_iterator
11290	it = mMediumAttachments->begin();
11291	it != mMediumAttachments->end();
11292	++it)
11293	{
11294	MediumAttachment pAttach = it;
11295
11296	pAttach->i_commit();
11297
11298	Medium *pMedium = pAttach->i_getMedium();
11299	bool fImplicit = pAttach->i_isImplicit();
11300
11301	LogFlowThisFunc(("Examining current medium '%s' (implicit: %d)\n",
11302	(pMedium) ? pMedium->i_getName().c_str() : "NULL",
11303	fImplicit));
11304
11305	/** @todo convert all this Machine-based voodoo to MediumAttachment
11306	* based commit logic. */
11307	if (fImplicit)
11308	{
11309	/* convert implicit attachment to normal */
11310	pAttach->i_setImplicit(false);
11311
11312	if ( aOnline
11313	&& pMedium
11314	&& pAttach->i_getType() == DeviceType_HardDisk
11315	)
11316	{
11317	/* update the appropriate lock list */
11318	MediumLockList *pMediumLockList;
11319	rc = mData->mSession.mLockedMedia.Get(pAttach, pMediumLockList);
11320	AssertComRC(rc);
11321	if (pMediumLockList)
11322	{
11323	/* unlock if there's a need to change the locking */
11324	if (!fMediaNeedsLocking)
11325	{
11326	rc = mData->mSession.mLockedMedia.Unlock();
11327	AssertComRC(rc);
11328	fMediaNeedsLocking = true;
11329	}
11330	rc = pMediumLockList->Update(pMedium->i_getParent(), false);
11331	AssertComRC(rc);
11332	rc = pMediumLockList->Append(pMedium, true);
11333	AssertComRC(rc);
11334	}
11335	}
11336
11337	continue;
11338	}
11339
11340	if (pMedium)
11341	{
11342	/* was this medium attached before? */
11343	for (MediumAttachmentList::iterator
11344	oldIt = oldAtts.begin();
11345	oldIt != oldAtts.end();
11346	++oldIt)
11347	{
11348	MediumAttachment pOldAttach = oldIt;
11349	if (pOldAttach->i_getMedium() == pMedium)
11350	{
11351	LogFlowThisFunc(("--> medium '%s' was attached before, will not remove\n", pMedium->i_getName().c_str()));
11352
11353	/* yes: remove from old to avoid de-association */
11354	oldAtts.erase(oldIt);
11355	break;
11356	}
11357	}
11358	}
11359	}
11360
11361	/* enumerate remaining old attachments and de-associate from the
11362	* current machine state */
11363	for (MediumAttachmentList::const_iterator
11364	it = oldAtts.begin();
11365	it != oldAtts.end();
11366	++it)
11367	{
11368	MediumAttachment pAttach = it;
11369	Medium *pMedium = pAttach->i_getMedium();
11370
11371	/* Detach only hard disks, since DVD/floppy media is detached
11372	* instantly in MountMedium. */
11373	if (pAttach->i_getType() == DeviceType_HardDisk && pMedium)
11374	{
11375	LogFlowThisFunc(("detaching medium '%s' from machine\n", pMedium->i_getName().c_str()));
11376
11377	/* now de-associate from the current machine state */
11378	rc = pMedium->i_removeBackReference(mData->mUuid);
11379	AssertComRC(rc);
11380
11381	if (aOnline)
11382	{
11383	/* unlock since medium is not used anymore */
11384	MediumLockList *pMediumLockList;
11385	rc = mData->mSession.mLockedMedia.Get(pAttach, pMediumLockList);
11386	if (RT_UNLIKELY(rc == VBOX_E_INVALID_OBJECT_STATE))
11387	{
11388	/* this happens for online snapshots, there the attachment
11389	* is changing, but only to a diff image created under
11390	* the old one, so there is no separate lock list */
11391	Assert(!pMediumLockList);
11392	}
11393	else
11394	{
11395	AssertComRC(rc);
11396	if (pMediumLockList)
11397	{
11398	rc = mData->mSession.mLockedMedia.Remove(pAttach);
11399	AssertComRC(rc);
11400	}
11401	}
11402	}
11403	}
11404	}
11405
11406	/* take media locks again so that the locking state is consistent */
11407	if (fMediaNeedsLocking)
11408	{
11409	Assert(aOnline);
11410	rc = mData->mSession.mLockedMedia.Lock();
11411	AssertComRC(rc);
11412	}
11413
11414	/* commit the hard disk changes */
11415	mMediumAttachments.commit();
11416
11417	if (i_isSessionMachine())
11418	{
11419	/*
11420	* Update the parent machine to point to the new owner.
11421	* This is necessary because the stored parent will point to the
11422	* session machine otherwise and cause crashes or errors later
11423	* when the session machine gets invalid.
11424	*/
11425	/** @todo Change the MediumAttachment class to behave like any other
11426	* class in this regard by creating peer MediumAttachment
11427	* objects for session machines and share the data with the peer
11428	* machine.
11429	*/
11430	for (MediumAttachmentList::const_iterator
11431	it = mMediumAttachments->begin();
11432	it != mMediumAttachments->end();
11433	++it)
11434	(*it)->i_updateParentMachine(mPeer);
11435
11436	/* attach new data to the primary machine and reshare it */
11437	mPeer->mMediumAttachments.attach(mMediumAttachments);
11438	}
11439
11440	return;
11441	}
11442
11443	/**
11444	* Perform deferred deletion of implicitly created diffs.
11445	*
11446	* Does nothing if the hard disk attachment data (mMediumAttachments) is not
11447	* changed (not backed up).
11448	*
11449	* @note Locks this object for writing!
11450	*/
11451	void Machine::i_rollbackMedia()
11452	{
11453	AutoCaller autoCaller(this);
11454	AssertComRCReturnVoid(autoCaller.rc());
11455
11456	// AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
11457	LogFlowThisFunc(("Entering rollbackMedia\n"));
11458
11459	HRESULT rc = S_OK;
11460
11461	/* no attach/detach operations -- nothing to do */
11462	if (!mMediumAttachments.isBackedUp())
11463	return;
11464
11465	/* enumerate new attachments */
11466	for (MediumAttachmentList::const_iterator
11467	it = mMediumAttachments->begin();
11468	it != mMediumAttachments->end();
11469	++it)
11470	{
11471	MediumAttachment pAttach = it;
11472	/* Fix up the backrefs for DVD/floppy media. */
11473	if (pAttach->i_getType() != DeviceType_HardDisk)
11474	{
11475	Medium *pMedium = pAttach->i_getMedium();
11476	if (pMedium)
11477	{
11478	rc = pMedium->i_removeBackReference(mData->mUuid);
11479	AssertComRC(rc);
11480	}
11481	}
11482
11483	(*it)->i_rollback();
11484
11485	pAttach = *it;
11486	/* Fix up the backrefs for DVD/floppy media. */
11487	if (pAttach->i_getType() != DeviceType_HardDisk)
11488	{
11489	Medium *pMedium = pAttach->i_getMedium();
11490	if (pMedium)
11491	{
11492	rc = pMedium->i_addBackReference(mData->mUuid);
11493	AssertComRC(rc);
11494	}
11495	}
11496	}
11497
11498	/** @todo convert all this Machine-based voodoo to MediumAttachment
11499	* based rollback logic. */
11500	i_deleteImplicitDiffs(Global::IsOnline(mData->mMachineState));
11501
11502	return;
11503	}
11504
11505	/**
11506	* Returns true if the settings file is located in the directory named exactly
11507	* as the machine; this means, among other things, that the machine directory
11508	* should be auto-renamed.
11509	*
11510	* @param aSettingsDir if not NULL, the full machine settings file directory
11511	* name will be assigned there.
11512	*
11513	* @note Doesn't lock anything.
11514	* @note Not thread safe (must be called from this object's lock).
11515	*/
11516	bool Machine::i_isInOwnDir(Utf8Str aSettingsDir / = NULL */) const
11517	{
11518	Utf8Str strMachineDirName(mData->m_strConfigFileFull); // path/to/machinesfolder/vmname/vmname.vbox
11519	strMachineDirName.stripFilename(); // path/to/machinesfolder/vmname
11520	if (aSettingsDir)
11521	*aSettingsDir = strMachineDirName;
11522	strMachineDirName.stripPath(); // vmname
11523	Utf8Str strConfigFileOnly(mData->m_strConfigFileFull); // path/to/machinesfolder/vmname/vmname.vbox
11524	strConfigFileOnly.stripPath() // vmname.vbox
11525	.stripSuffix(); // vmname
11526	/** @todo hack, make somehow use of ComposeMachineFilename */
11527	if (mUserData->s.fDirectoryIncludesUUID)
11528	strConfigFileOnly.appendPrintf(" (%RTuuid)", mData->mUuid.raw());
11529
11530	AssertReturn(!strMachineDirName.isEmpty(), false);
11531	AssertReturn(!strConfigFileOnly.isEmpty(), false);
11532
11533	return strMachineDirName == strConfigFileOnly;
11534	}
11535
11536	/**
11537	* Discards all changes to machine settings.
11538	*
11539	* @param aNotify Whether to notify the direct session about changes or not.
11540	*
11541	* @note Locks objects for writing!
11542	*/
11543	void Machine::i_rollback(bool aNotify)
11544	{
11545	AutoCaller autoCaller(this);
11546	AssertComRCReturn(autoCaller.rc(), (void)0);
11547
11548	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
11549
11550	if (!mStorageControllers.isNull())
11551	{
11552	if (mStorageControllers.isBackedUp())
11553	{
11554	/* unitialize all new devices (absent in the backed up list). */
11555	StorageControllerList *backedList = mStorageControllers.backedUpData();
11556	for (StorageControllerList::const_iterator
11557	it = mStorageControllers->begin();
11558	it != mStorageControllers->end();
11559	++it)
11560	{
11561	if ( std::find(backedList->begin(), backedList->end(), *it)
11562	== backedList->end()
11563	)
11564	{
11565	(*it)->uninit();
11566	}
11567	}
11568
11569	/* restore the list */
11570	mStorageControllers.rollback();
11571	}
11572
11573	/* rollback any changes to devices after restoring the list */
11574	if (mData->flModifications & IsModified_Storage)
11575	{
11576	for (StorageControllerList::const_iterator
11577	it = mStorageControllers->begin();
11578	it != mStorageControllers->end();
11579	++it)
11580	{
11581	(*it)->i_rollback();
11582	}
11583	}
11584	}
11585
11586	if (!mUSBControllers.isNull())
11587	{
11588	if (mUSBControllers.isBackedUp())
11589	{
11590	/* unitialize all new devices (absent in the backed up list). */
11591	USBControllerList *backedList = mUSBControllers.backedUpData();
11592	for (USBControllerList::const_iterator
11593	it = mUSBControllers->begin();
11594	it != mUSBControllers->end();
11595	++it)
11596	{
11597	if ( std::find(backedList->begin(), backedList->end(), *it)
11598	== backedList->end()
11599	)
11600	{
11601	(*it)->uninit();
11602	}
11603	}
11604
11605	/* restore the list */
11606	mUSBControllers.rollback();
11607	}
11608
11609	/* rollback any changes to devices after restoring the list */
11610	if (mData->flModifications & IsModified_USB)
11611	{
11612	for (USBControllerList::const_iterator
11613	it = mUSBControllers->begin();
11614	it != mUSBControllers->end();
11615	++it)
11616	{
11617	(*it)->i_rollback();
11618	}
11619	}
11620	}
11621
11622	mUserData.rollback();
11623
11624	mHWData.rollback();
11625
11626	if (mData->flModifications & IsModified_Storage)
11627	i_rollbackMedia();
11628
11629	if (mBIOSSettings)
11630	mBIOSSettings->i_rollback();
11631
11632	if (mRecordingSettings && (mData->flModifications & IsModified_Recording))
11633	mRecordingSettings->i_rollback();
11634
11635	if (mGraphicsAdapter && (mData->flModifications & IsModified_GraphicsAdapter))
11636	mGraphicsAdapter->i_rollback();
11637
11638	if (mVRDEServer && (mData->flModifications & IsModified_VRDEServer))
11639	mVRDEServer->i_rollback();
11640
11641	if (mAudioAdapter && (mData->flModifications & IsModified_AudioAdapter))
11642	mAudioAdapter->i_rollback();
11643
11644	if (mUSBDeviceFilters && (mData->flModifications & IsModified_USB))
11645	mUSBDeviceFilters->i_rollback();
11646
11647	if (mBandwidthControl && (mData->flModifications & IsModified_BandwidthControl))
11648	mBandwidthControl->i_rollback();
11649
11650	if (!mHWData.isNull())
11651	mNetworkAdapters.resize(Global::getMaxNetworkAdapters(mHWData->mChipsetType));
11652	NetworkAdapterVector networkAdapters(mNetworkAdapters.size());
11653	ComPtr<ISerialPort> serialPorts[RT_ELEMENTS(mSerialPorts)];
11654	ComPtr<IParallelPort> parallelPorts[RT_ELEMENTS(mParallelPorts)];
11655
11656	if (mData->flModifications & IsModified_NetworkAdapters)
11657	for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
11658	if ( mNetworkAdapters[slot]
11659	&& mNetworkAdapters[slot]->i_isModified())
11660	{
11661	mNetworkAdapters[slot]->i_rollback();
11662	networkAdapters[slot] = mNetworkAdapters[slot];
11663	}
11664
11665	if (mData->flModifications & IsModified_SerialPorts)
11666	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
11667	if ( mSerialPorts[slot]
11668	&& mSerialPorts[slot]->i_isModified())
11669	{
11670	mSerialPorts[slot]->i_rollback();
11671	serialPorts[slot] = mSerialPorts[slot];
11672	}
11673
11674	if (mData->flModifications & IsModified_ParallelPorts)
11675	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
11676	if ( mParallelPorts[slot]
11677	&& mParallelPorts[slot]->i_isModified())
11678	{
11679	mParallelPorts[slot]->i_rollback();
11680	parallelPorts[slot] = mParallelPorts[slot];
11681	}
11682
11683	if (aNotify)
11684	{
11685	/* inform the direct session about changes */
11686
11687	ComObjPtr<Machine> that = this;
11688	uint32_t flModifications = mData->flModifications;
11689	alock.release();
11690
11691	if (flModifications & IsModified_SharedFolders)
11692	that->i_onSharedFolderChange();
11693
11694	if (flModifications & IsModified_VRDEServer)
11695	that->i_onVRDEServerChange(/* aRestart */ TRUE);
11696	if (flModifications & IsModified_USB)
11697	that->i_onUSBControllerChange();
11698
11699	for (ULONG slot = 0; slot < networkAdapters.size(); ++slot)
11700	if (networkAdapters[slot])
11701	that->i_onNetworkAdapterChange(networkAdapters[slot], FALSE);
11702	for (ULONG slot = 0; slot < RT_ELEMENTS(serialPorts); ++slot)
11703	if (serialPorts[slot])
11704	that->i_onSerialPortChange(serialPorts[slot]);
11705	for (ULONG slot = 0; slot < RT_ELEMENTS(parallelPorts); ++slot)
11706	if (parallelPorts[slot])
11707	that->i_onParallelPortChange(parallelPorts[slot]);
11708
11709	if (flModifications & IsModified_Storage)
11710	{
11711	for (StorageControllerList::const_iterator
11712	it = mStorageControllers->begin();
11713	it != mStorageControllers->end();
11714	++it)
11715	{
11716	that->i_onStorageControllerChange(that->i_getId(), (*it)->i_getName());
11717	}
11718	}
11719
11720
11721	#if 0
11722	if (flModifications & IsModified_BandwidthControl)
11723	that->onBandwidthControlChange();
11724	#endif
11725	}
11726	}
11727
11728	/**
11729	* Commits all the changes to machine settings.
11730	*
11731	* Note that this operation is supposed to never fail.
11732	*
11733	* @note Locks this object and children for writing.
11734	*/
11735	void Machine::i_commit()
11736	{
11737	AutoCaller autoCaller(this);
11738	AssertComRCReturnVoid(autoCaller.rc());
11739
11740	AutoCaller peerCaller(mPeer);
11741	AssertComRCReturnVoid(peerCaller.rc());
11742
11743	AutoMultiWriteLock2 alock(mPeer, this COMMA_LOCKVAL_SRC_POS);
11744
11745	/*
11746	* use safe commit to ensure Snapshot machines (that share mUserData)
11747	* will still refer to a valid memory location
11748	*/
11749	mUserData.commitCopy();
11750
11751	mHWData.commit();
11752
11753	if (mMediumAttachments.isBackedUp())
11754	i_commitMedia(Global::IsOnline(mData->mMachineState));
11755
11756	mBIOSSettings->i_commit();
11757	mRecordingSettings->i_commit();
11758	mGraphicsAdapter->i_commit();
11759	mVRDEServer->i_commit();
11760	mAudioAdapter->i_commit();
11761	mUSBDeviceFilters->i_commit();
11762	mBandwidthControl->i_commit();
11763
11764	/* Since mNetworkAdapters is a list which might have been changed (resized)
11765	* without using the Backupable<> template we need to handle the copying
11766	* of the list entries manually, including the creation of peers for the
11767	* new objects. */
11768	bool commitNetworkAdapters = false;
11769	size_t newSize = Global::getMaxNetworkAdapters(mHWData->mChipsetType);
11770	if (mPeer)
11771	{
11772	/* commit everything, even the ones which will go away */
11773	for (size_t slot = 0; slot < mNetworkAdapters.size(); slot++)
11774	mNetworkAdapters[slot]->i_commit();
11775	/* copy over the new entries, creating a peer and uninit the original */
11776	mPeer->mNetworkAdapters.resize(RT_MAX(newSize, mPeer->mNetworkAdapters.size()));
11777	for (size_t slot = 0; slot < newSize; slot++)
11778	{
11779	/* look if this adapter has a peer device */
11780	ComObjPtr<NetworkAdapter> peer = mNetworkAdapters[slot]->i_getPeer();
11781	if (!peer)
11782	{
11783	/* no peer means the adapter is a newly created one;
11784	* create a peer owning data this data share it with */
11785	peer.createObject();
11786	peer->init(mPeer, mNetworkAdapters[slot], true /* aReshare */);
11787	}
11788	mPeer->mNetworkAdapters[slot] = peer;
11789	}
11790	/* uninit any no longer needed network adapters */
11791	for (size_t slot = newSize; slot < mNetworkAdapters.size(); ++slot)
11792	mNetworkAdapters[slot]->uninit();
11793	for (size_t slot = newSize; slot < mPeer->mNetworkAdapters.size(); ++slot)
11794	{
11795	if (mPeer->mNetworkAdapters[slot])
11796	mPeer->mNetworkAdapters[slot]->uninit();
11797	}
11798	/* Keep the original network adapter count until this point, so that
11799	* discarding a chipset type change will not lose settings. */
11800	mNetworkAdapters.resize(newSize);
11801	mPeer->mNetworkAdapters.resize(newSize);
11802	}
11803	else
11804	{
11805	/* we have no peer (our parent is the newly created machine);
11806	* just commit changes to the network adapters */
11807	commitNetworkAdapters = true;
11808	}
11809	if (commitNetworkAdapters)
11810	for (size_t slot = 0; slot < mNetworkAdapters.size(); ++slot)
11811	mNetworkAdapters[slot]->i_commit();
11812
11813	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
11814	mSerialPorts[slot]->i_commit();
11815	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
11816	mParallelPorts[slot]->i_commit();
11817
11818	bool commitStorageControllers = false;
11819
11820	if (mStorageControllers.isBackedUp())
11821	{
11822	mStorageControllers.commit();
11823
11824	if (mPeer)
11825	{
11826	/* Commit all changes to new controllers (this will reshare data with
11827	* peers for those who have peers) */
11828	StorageControllerList *newList = new StorageControllerList();
11829	for (StorageControllerList::const_iterator
11830	it = mStorageControllers->begin();
11831	it != mStorageControllers->end();
11832	++it)
11833	{
11834	(*it)->i_commit();
11835
11836	/* look if this controller has a peer device */
11837	ComObjPtr<StorageController> peer = (*it)->i_getPeer();
11838	if (!peer)
11839	{
11840	/* no peer means the device is a newly created one;
11841	* create a peer owning data this device share it with */
11842	peer.createObject();
11843	peer->init(mPeer, it, true / aReshare */);
11844	}
11845	else
11846	{
11847	/* remove peer from the old list */
11848	mPeer->mStorageControllers->remove(peer);
11849	}
11850	/* and add it to the new list */
11851	newList->push_back(peer);
11852	}
11853
11854	/* uninit old peer's controllers that are left */
11855	for (StorageControllerList::const_iterator
11856	it = mPeer->mStorageControllers->begin();
11857	it != mPeer->mStorageControllers->end();
11858	++it)
11859	{
11860	(*it)->uninit();
11861	}
11862
11863	/* attach new list of controllers to our peer */
11864	mPeer->mStorageControllers.attach(newList);
11865	}
11866	else
11867	{
11868	/* we have no peer (our parent is the newly created machine);
11869	* just commit changes to devices */
11870	commitStorageControllers = true;
11871	}
11872	}
11873	else
11874	{
11875	/* the list of controllers itself is not changed,
11876	* just commit changes to controllers themselves */
11877	commitStorageControllers = true;
11878	}
11879
11880	if (commitStorageControllers)
11881	{
11882	for (StorageControllerList::const_iterator
11883	it = mStorageControllers->begin();
11884	it != mStorageControllers->end();
11885	++it)
11886	{
11887	(*it)->i_commit();
11888	}
11889	}
11890
11891	bool commitUSBControllers = false;
11892
11893	if (mUSBControllers.isBackedUp())
11894	{
11895	mUSBControllers.commit();
11896
11897	if (mPeer)
11898	{
11899	/* Commit all changes to new controllers (this will reshare data with
11900	* peers for those who have peers) */
11901	USBControllerList *newList = new USBControllerList();
11902	for (USBControllerList::const_iterator
11903	it = mUSBControllers->begin();
11904	it != mUSBControllers->end();
11905	++it)
11906	{
11907	(*it)->i_commit();
11908
11909	/* look if this controller has a peer device */
11910	ComObjPtr<USBController> peer = (*it)->i_getPeer();
11911	if (!peer)
11912	{
11913	/* no peer means the device is a newly created one;
11914	* create a peer owning data this device share it with */
11915	peer.createObject();
11916	peer->init(mPeer, it, true / aReshare */);
11917	}
11918	else
11919	{
11920	/* remove peer from the old list */
11921	mPeer->mUSBControllers->remove(peer);
11922	}
11923	/* and add it to the new list */
11924	newList->push_back(peer);
11925	}
11926
11927	/* uninit old peer's controllers that are left */
11928	for (USBControllerList::const_iterator
11929	it = mPeer->mUSBControllers->begin();
11930	it != mPeer->mUSBControllers->end();
11931	++it)
11932	{
11933	(*it)->uninit();
11934	}
11935
11936	/* attach new list of controllers to our peer */
11937	mPeer->mUSBControllers.attach(newList);
11938	}
11939	else
11940	{
11941	/* we have no peer (our parent is the newly created machine);
11942	* just commit changes to devices */
11943	commitUSBControllers = true;
11944	}
11945	}
11946	else
11947	{
11948	/* the list of controllers itself is not changed,
11949	* just commit changes to controllers themselves */
11950	commitUSBControllers = true;
11951	}
11952
11953	if (commitUSBControllers)
11954	{
11955	for (USBControllerList::const_iterator
11956	it = mUSBControllers->begin();
11957	it != mUSBControllers->end();
11958	++it)
11959	{
11960	(*it)->i_commit();
11961	}
11962	}
11963
11964	if (i_isSessionMachine())
11965	{
11966	/* attach new data to the primary machine and reshare it */
11967	mPeer->mUserData.attach(mUserData);
11968	mPeer->mHWData.attach(mHWData);
11969	/* mmMediumAttachments is reshared by fixupMedia */
11970	// mPeer->mMediumAttachments.attach(mMediumAttachments);
11971	Assert(mPeer->mMediumAttachments.data() == mMediumAttachments.data());
11972	}
11973	}
11974
11975	/**
11976	* Copies all the hardware data from the given machine.
11977	*
11978	* Currently, only called when the VM is being restored from a snapshot. In
11979	* particular, this implies that the VM is not running during this method's
11980	* call.
11981	*
11982	* @note This method must be called from under this object's lock.
11983	*
11984	* @note This method doesn't call #i_commit(), so all data remains backed up and
11985	* unsaved.
11986	*/
11987	void Machine::i_copyFrom(Machine *aThat)
11988	{
11989	AssertReturnVoid(!i_isSnapshotMachine());
11990	AssertReturnVoid(aThat->i_isSnapshotMachine());
11991
11992	AssertReturnVoid(!Global::IsOnline(mData->mMachineState));
11993
11994	mHWData.assignCopy(aThat->mHWData);
11995
11996	// create copies of all shared folders (mHWData after attaching a copy
11997	// contains just references to original objects)
11998	for (HWData::SharedFolderList::iterator
11999	it = mHWData->mSharedFolders.begin();
12000	it != mHWData->mSharedFolders.end();
12001	++it)
12002	{
12003	ComObjPtr<SharedFolder> folder;
12004	folder.createObject();
12005	HRESULT rc = folder->initCopy(i_getMachine(), *it);
12006	AssertComRC(rc);
12007	*it = folder;
12008	}
12009
12010	mBIOSSettings->i_copyFrom(aThat->mBIOSSettings);
12011	mRecordingSettings->i_copyFrom(aThat->mRecordingSettings);
12012	mGraphicsAdapter->i_copyFrom(aThat->mGraphicsAdapter);
12013	mVRDEServer->i_copyFrom(aThat->mVRDEServer);
12014	mAudioAdapter->i_copyFrom(aThat->mAudioAdapter);
12015	mUSBDeviceFilters->i_copyFrom(aThat->mUSBDeviceFilters);
12016	mBandwidthControl->i_copyFrom(aThat->mBandwidthControl);
12017
12018	/* create private copies of all controllers */
12019	mStorageControllers.backup();
12020	mStorageControllers->clear();
12021	for (StorageControllerList::const_iterator
12022	it = aThat->mStorageControllers->begin();
12023	it != aThat->mStorageControllers->end();
12024	++it)
12025	{
12026	ComObjPtr<StorageController> ctrl;
12027	ctrl.createObject();
12028	ctrl->initCopy(this, *it);
12029	mStorageControllers->push_back(ctrl);
12030	}
12031
12032	/* create private copies of all USB controllers */
12033	mUSBControllers.backup();
12034	mUSBControllers->clear();
12035	for (USBControllerList::const_iterator
12036	it = aThat->mUSBControllers->begin();
12037	it != aThat->mUSBControllers->end();
12038	++it)
12039	{
12040	ComObjPtr<USBController> ctrl;
12041	ctrl.createObject();
12042	ctrl->initCopy(this, *it);
12043	mUSBControllers->push_back(ctrl);
12044	}
12045
12046	mNetworkAdapters.resize(aThat->mNetworkAdapters.size());
12047	for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
12048	{
12049	if (mNetworkAdapters[slot].isNotNull())
12050	mNetworkAdapters[slot]->i_copyFrom(aThat->mNetworkAdapters[slot]);
12051	else
12052	{
12053	unconst(mNetworkAdapters[slot]).createObject();
12054	mNetworkAdapters[slot]->initCopy(this, aThat->mNetworkAdapters[slot]);
12055	}
12056	}
12057	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
12058	mSerialPorts[slot]->i_copyFrom(aThat->mSerialPorts[slot]);
12059	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
12060	mParallelPorts[slot]->i_copyFrom(aThat->mParallelPorts[slot]);
12061	}
12062
12063	/**
12064	* Returns whether the given storage controller is hotplug capable.
12065	*
12066	* @returns true if the controller supports hotplugging
12067	* false otherwise.
12068	* @param enmCtrlType The controller type to check for.
12069	*/
12070	bool Machine::i_isControllerHotplugCapable(StorageControllerType_T enmCtrlType)
12071	{
12072	ComPtr<ISystemProperties> systemProperties;
12073	HRESULT rc = mParent->COMGETTER(SystemProperties)(systemProperties.asOutParam());
12074	if (FAILED(rc))
12075	return false;
12076
12077	BOOL aHotplugCapable = FALSE;
12078	systemProperties->GetStorageControllerHotplugCapable(enmCtrlType, &aHotplugCapable);
12079
12080	return RT_BOOL(aHotplugCapable);
12081	}
12082
12083	#ifdef VBOX_WITH_RESOURCE_USAGE_API
12084
12085	void Machine::i_getDiskList(MediaList &list)
12086	{
12087	for (MediumAttachmentList::const_iterator
12088	it = mMediumAttachments->begin();
12089	it != mMediumAttachments->end();
12090	++it)
12091	{
12092	MediumAttachment pAttach = it;
12093	/* just in case */
12094	AssertContinue(pAttach);
12095
12096	AutoCaller localAutoCallerA(pAttach);
12097	if (FAILED(localAutoCallerA.rc())) continue;
12098
12099	AutoReadLock local_alockA(pAttach COMMA_LOCKVAL_SRC_POS);
12100
12101	if (pAttach->i_getType() == DeviceType_HardDisk)
12102	list.push_back(pAttach->i_getMedium());
12103	}
12104	}
12105
12106	void Machine::i_registerMetrics(PerformanceCollector aCollector, Machine aMachine, RTPROCESS pid)
12107	{
12108	AssertReturnVoid(isWriteLockOnCurrentThread());
12109	AssertPtrReturnVoid(aCollector);
12110
12111	pm::CollectorHAL *hal = aCollector->getHAL();
12112	/* Create sub metrics */
12113	pm::SubMetric *cpuLoadUser = new pm::SubMetric("CPU/Load/User",
12114	"Percentage of processor time spent in user mode by the VM process.");
12115	pm::SubMetric *cpuLoadKernel = new pm::SubMetric("CPU/Load/Kernel",
12116	"Percentage of processor time spent in kernel mode by the VM process.");
12117	pm::SubMetric *ramUsageUsed = new pm::SubMetric("RAM/Usage/Used",
12118	"Size of resident portion of VM process in memory.");
12119	pm::SubMetric *diskUsageUsed = new pm::SubMetric("Disk/Usage/Used",
12120	"Actual size of all VM disks combined.");
12121	pm::SubMetric *machineNetRx = new pm::SubMetric("Net/Rate/Rx",
12122	"Network receive rate.");
12123	pm::SubMetric *machineNetTx = new pm::SubMetric("Net/Rate/Tx",
12124	"Network transmit rate.");
12125	/* Create and register base metrics */
12126	pm::BaseMetric *cpuLoad = new pm::MachineCpuLoadRaw(hal, aMachine, pid,
12127	cpuLoadUser, cpuLoadKernel);
12128	aCollector->registerBaseMetric(cpuLoad);
12129	pm::BaseMetric *ramUsage = new pm::MachineRamUsage(hal, aMachine, pid,
12130	ramUsageUsed);
12131	aCollector->registerBaseMetric(ramUsage);
12132	MediaList disks;
12133	i_getDiskList(disks);
12134	pm::BaseMetric *diskUsage = new pm::MachineDiskUsage(hal, aMachine, disks,
12135	diskUsageUsed);
12136	aCollector->registerBaseMetric(diskUsage);
12137
12138	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser, 0));
12139	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
12140	new pm::AggregateAvg()));
12141	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
12142	new pm::AggregateMin()));
12143	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
12144	new pm::AggregateMax()));
12145	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel, 0));
12146	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
12147	new pm::AggregateAvg()));
12148	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
12149	new pm::AggregateMin()));
12150	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
12151	new pm::AggregateMax()));
12152
12153	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed, 0));
12154	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
12155	new pm::AggregateAvg()));
12156	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
12157	new pm::AggregateMin()));
12158	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
12159	new pm::AggregateMax()));
12160
12161	aCollector->registerMetric(new pm::Metric(diskUsage, diskUsageUsed, 0));
12162	aCollector->registerMetric(new pm::Metric(diskUsage, diskUsageUsed,
12163	new pm::AggregateAvg()));
12164	aCollector->registerMetric(new pm::Metric(diskUsage, diskUsageUsed,
12165	new pm::AggregateMin()));
12166	aCollector->registerMetric(new pm::Metric(diskUsage, diskUsageUsed,
12167	new pm::AggregateMax()));
12168
12169
12170	/* Guest metrics collector */
12171	mCollectorGuest = new pm::CollectorGuest(aMachine, pid);
12172	aCollector->registerGuest(mCollectorGuest);
12173	Log7Func(("{%p}: mCollectorGuest=%p\n", this, mCollectorGuest));
12174
12175	/* Create sub metrics */
12176	pm::SubMetric *guestLoadUser = new pm::SubMetric("Guest/CPU/Load/User",
12177	"Percentage of processor time spent in user mode as seen by the guest.");
12178	pm::SubMetric *guestLoadKernel = new pm::SubMetric("Guest/CPU/Load/Kernel",
12179	"Percentage of processor time spent in kernel mode as seen by the guest.");
12180	pm::SubMetric *guestLoadIdle = new pm::SubMetric("Guest/CPU/Load/Idle",
12181	"Percentage of processor time spent idling as seen by the guest.");
12182
12183	/* The total amount of physical ram is fixed now, but we'll support dynamic guest ram configurations in the future. */
12184	pm::SubMetric *guestMemTotal = new pm::SubMetric("Guest/RAM/Usage/Total", "Total amount of physical guest RAM.");
12185	pm::SubMetric *guestMemFree = new pm::SubMetric("Guest/RAM/Usage/Free", "Free amount of physical guest RAM.");
12186	pm::SubMetric *guestMemBalloon = new pm::SubMetric("Guest/RAM/Usage/Balloon", "Amount of ballooned physical guest RAM.");
12187	pm::SubMetric *guestMemShared = new pm::SubMetric("Guest/RAM/Usage/Shared", "Amount of shared physical guest RAM.");
12188	pm::SubMetric *guestMemCache = new pm::SubMetric(
12189	"Guest/RAM/Usage/Cache", "Total amount of guest (disk) cache memory.");
12190
12191	pm::SubMetric *guestPagedTotal = new pm::SubMetric(
12192	"Guest/Pagefile/Usage/Total", "Total amount of space in the page file.");
12193
12194	/* Create and register base metrics */
12195	pm::BaseMetric *machineNetRate = new pm::MachineNetRate(mCollectorGuest, aMachine,
12196	machineNetRx, machineNetTx);
12197	aCollector->registerBaseMetric(machineNetRate);
12198
12199	pm::BaseMetric *guestCpuLoad = new pm::GuestCpuLoad(mCollectorGuest, aMachine,
12200	guestLoadUser, guestLoadKernel, guestLoadIdle);
12201	aCollector->registerBaseMetric(guestCpuLoad);
12202
12203	pm::BaseMetric *guestCpuMem = new pm::GuestRamUsage(mCollectorGuest, aMachine,
12204	guestMemTotal, guestMemFree,
12205	guestMemBalloon, guestMemShared,
12206	guestMemCache, guestPagedTotal);
12207	aCollector->registerBaseMetric(guestCpuMem);
12208
12209	aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetRx, 0));
12210	aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetRx, new pm::AggregateAvg()));
12211	aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetRx, new pm::AggregateMin()));
12212	aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetRx, new pm::AggregateMax()));
12213
12214	aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetTx, 0));
12215	aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetTx, new pm::AggregateAvg()));
12216	aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetTx, new pm::AggregateMin()));
12217	aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetTx, new pm::AggregateMax()));
12218
12219	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadUser, 0));
12220	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadUser, new pm::AggregateAvg()));
12221	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadUser, new pm::AggregateMin()));
12222	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadUser, new pm::AggregateMax()));
12223
12224	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadKernel, 0));
12225	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadKernel, new pm::AggregateAvg()));
12226	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadKernel, new pm::AggregateMin()));
12227	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadKernel, new pm::AggregateMax()));
12228
12229	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadIdle, 0));
12230	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadIdle, new pm::AggregateAvg()));
12231	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadIdle, new pm::AggregateMin()));
12232	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadIdle, new pm::AggregateMax()));
12233
12234	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemTotal, 0));
12235	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemTotal, new pm::AggregateAvg()));
12236	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemTotal, new pm::AggregateMin()));
12237	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemTotal, new pm::AggregateMax()));
12238
12239	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemFree, 0));
12240	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemFree, new pm::AggregateAvg()));
12241	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemFree, new pm::AggregateMin()));
12242	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemFree, new pm::AggregateMax()));
12243
12244	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemBalloon, 0));
12245	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemBalloon, new pm::AggregateAvg()));
12246	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemBalloon, new pm::AggregateMin()));
12247	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemBalloon, new pm::AggregateMax()));
12248
12249	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemShared, 0));
12250	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemShared, new pm::AggregateAvg()));
12251	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemShared, new pm::AggregateMin()));
12252	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemShared, new pm::AggregateMax()));
12253
12254	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemCache, 0));
12255	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemCache, new pm::AggregateAvg()));
12256	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemCache, new pm::AggregateMin()));
12257	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemCache, new pm::AggregateMax()));
12258
12259	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestPagedTotal, 0));
12260	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestPagedTotal, new pm::AggregateAvg()));
12261	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestPagedTotal, new pm::AggregateMin()));
12262	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestPagedTotal, new pm::AggregateMax()));
12263	}
12264
12265	void Machine::i_unregisterMetrics(PerformanceCollector aCollector, Machine aMachine)
12266	{
12267	AssertReturnVoid(isWriteLockOnCurrentThread());
12268
12269	if (aCollector)
12270	{
12271	aCollector->unregisterMetricsFor(aMachine);
12272	aCollector->unregisterBaseMetricsFor(aMachine);
12273	}
12274	}
12275
12276	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
12277
12278
12279	////////////////////////////////////////////////////////////////////////////////
12280
12281	DEFINE_EMPTY_CTOR_DTOR(SessionMachine)
12282
12283	HRESULT SessionMachine::FinalConstruct()
12284	{
12285	LogFlowThisFunc(("\n"));
12286
12287	mClientToken = NULL;
12288
12289	return BaseFinalConstruct();
12290	}
12291
12292	void SessionMachine::FinalRelease()
12293	{
12294	LogFlowThisFunc(("\n"));
12295
12296	Assert(!mClientToken);
12297	/* paranoia, should not hang around any more */
12298	if (mClientToken)
12299	{
12300	delete mClientToken;
12301	mClientToken = NULL;
12302	}
12303
12304	uninit(Uninit::Unexpected);
12305
12306	BaseFinalRelease();
12307	}
12308
12309	/**
12310	* @note Must be called only by Machine::LockMachine() from its own write lock.
12311	*/
12312	HRESULT SessionMachine::init(Machine *aMachine)
12313	{
12314	LogFlowThisFuncEnter();
12315	LogFlowThisFunc(("mName={%s}\n", aMachine->mUserData->s.strName.c_str()));
12316
12317	AssertReturn(aMachine, E_INVALIDARG);
12318
12319	AssertReturn(aMachine->lockHandle()->isWriteLockOnCurrentThread(), E_FAIL);
12320
12321	/* Enclose the state transition NotReady->InInit->Ready */
12322	AutoInitSpan autoInitSpan(this);
12323	AssertReturn(autoInitSpan.isOk(), E_FAIL);
12324
12325	HRESULT rc = S_OK;
12326
12327	RT_ZERO(mAuthLibCtx);
12328
12329	/* create the machine client token */
12330	try
12331	{
12332	mClientToken = new ClientToken(aMachine, this);
12333	if (!mClientToken->isReady())
12334	{
12335	delete mClientToken;
12336	mClientToken = NULL;
12337	rc = E_FAIL;
12338	}
12339	}
12340	catch (std::bad_alloc &)
12341	{
12342	rc = E_OUTOFMEMORY;
12343	}
12344	if (FAILED(rc))
12345	return rc;
12346
12347	/* memorize the peer Machine */
12348	unconst(mPeer) = aMachine;
12349	/* share the parent pointer */
12350	unconst(mParent) = aMachine->mParent;
12351
12352	/* take the pointers to data to share */
12353	mData.share(aMachine->mData);
12354	mSSData.share(aMachine->mSSData);
12355
12356	mUserData.share(aMachine->mUserData);
12357	mHWData.share(aMachine->mHWData);
12358	mMediumAttachments.share(aMachine->mMediumAttachments);
12359
12360	mStorageControllers.allocate();
12361	for (StorageControllerList::const_iterator
12362	it = aMachine->mStorageControllers->begin();
12363	it != aMachine->mStorageControllers->end();
12364	++it)
12365	{
12366	ComObjPtr<StorageController> ctl;
12367	ctl.createObject();
12368	ctl->init(this, *it);
12369	mStorageControllers->push_back(ctl);
12370	}
12371
12372	mUSBControllers.allocate();
12373	for (USBControllerList::const_iterator
12374	it = aMachine->mUSBControllers->begin();
12375	it != aMachine->mUSBControllers->end();
12376	++it)
12377	{
12378	ComObjPtr<USBController> ctl;
12379	ctl.createObject();
12380	ctl->init(this, *it);
12381	mUSBControllers->push_back(ctl);
12382	}
12383
12384	unconst(mBIOSSettings).createObject();
12385	mBIOSSettings->init(this, aMachine->mBIOSSettings);
12386	unconst(mRecordingSettings).createObject();
12387	mRecordingSettings->init(this, aMachine->mRecordingSettings);
12388	/* create another GraphicsAdapter object that will be mutable */
12389	unconst(mGraphicsAdapter).createObject();
12390	mGraphicsAdapter->init(this, aMachine->mGraphicsAdapter);
12391	/* create another VRDEServer object that will be mutable */
12392	unconst(mVRDEServer).createObject();
12393	mVRDEServer->init(this, aMachine->mVRDEServer);
12394	/* create another audio adapter object that will be mutable */
12395	unconst(mAudioAdapter).createObject();
12396	mAudioAdapter->init(this, aMachine->mAudioAdapter);
12397	/* create a list of serial ports that will be mutable */
12398	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
12399	{
12400	unconst(mSerialPorts[slot]).createObject();
12401	mSerialPorts[slot]->init(this, aMachine->mSerialPorts[slot]);
12402	}
12403	/* create a list of parallel ports that will be mutable */
12404	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
12405	{
12406	unconst(mParallelPorts[slot]).createObject();
12407	mParallelPorts[slot]->init(this, aMachine->mParallelPorts[slot]);
12408	}
12409
12410	/* create another USB device filters object that will be mutable */
12411	unconst(mUSBDeviceFilters).createObject();
12412	mUSBDeviceFilters->init(this, aMachine->mUSBDeviceFilters);
12413
12414	/* create a list of network adapters that will be mutable */
12415	mNetworkAdapters.resize(aMachine->mNetworkAdapters.size());
12416	for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
12417	{
12418	unconst(mNetworkAdapters[slot]).createObject();
12419	mNetworkAdapters[slot]->init(this, aMachine->mNetworkAdapters[slot]);
12420	}
12421
12422	/* create another bandwidth control object that will be mutable */
12423	unconst(mBandwidthControl).createObject();
12424	mBandwidthControl->init(this, aMachine->mBandwidthControl);
12425
12426	/* default is to delete saved state on Saved -> PoweredOff transition */
12427	mRemoveSavedState = true;
12428
12429	/* Confirm a successful initialization when it's the case */
12430	autoInitSpan.setSucceeded();
12431
12432	miNATNetworksStarted = 0;
12433
12434	LogFlowThisFuncLeave();
12435	return rc;
12436	}
12437
12438	/**
12439	* Uninitializes this session object. If the reason is other than
12440	* Uninit::Unexpected, then this method MUST be called from #i_checkForDeath()
12441	* or the client watcher code.
12442	*
12443	* @param aReason uninitialization reason
12444	*
12445	* @note Locks mParent + this object for writing.
12446	*/
12447	void SessionMachine::uninit(Uninit::Reason aReason)
12448	{
12449	LogFlowThisFuncEnter();
12450	LogFlowThisFunc(("reason=%d\n", aReason));
12451
12452	/*
12453	* Strongly reference ourselves to prevent this object deletion after
12454	* mData->mSession.mMachine.setNull() below (which can release the last
12455	* reference and call the destructor). Important: this must be done before
12456	* accessing any members (and before AutoUninitSpan that does it as well).
12457	* This self reference will be released as the very last step on return.
12458	*/
12459	ComObjPtr<SessionMachine> selfRef;
12460	if (aReason != Uninit::Unexpected)
12461	selfRef = this;
12462
12463	/* Enclose the state transition Ready->InUninit->NotReady */
12464	AutoUninitSpan autoUninitSpan(this);
12465	if (autoUninitSpan.uninitDone())
12466	{
12467	LogFlowThisFunc(("Already uninitialized\n"));
12468	LogFlowThisFuncLeave();
12469	return;
12470	}
12471
12472	if (autoUninitSpan.initFailed())
12473	{
12474	/* We've been called by init() because it's failed. It's not really
12475	* necessary (nor it's safe) to perform the regular uninit sequence
12476	* below, the following is enough.
12477	*/
12478	LogFlowThisFunc(("Initialization failed.\n"));
12479	/* destroy the machine client token */
12480	if (mClientToken)
12481	{
12482	delete mClientToken;
12483	mClientToken = NULL;
12484	}
12485	uninitDataAndChildObjects();
12486	mData.free();
12487	unconst(mParent) = NULL;
12488	unconst(mPeer) = NULL;
12489	LogFlowThisFuncLeave();
12490	return;
12491	}
12492
12493	MachineState_T lastState;
12494	{
12495	AutoReadLock tempLock(this COMMA_LOCKVAL_SRC_POS);
12496	lastState = mData->mMachineState;
12497	}
12498	NOREF(lastState);
12499
12500	#ifdef VBOX_WITH_USB
12501	// release all captured USB devices, but do this before requesting the locks below
12502	if (aReason == Uninit::Abnormal && Global::IsOnline(lastState))
12503	{
12504	/* Console::captureUSBDevices() is called in the VM process only after
12505	* setting the machine state to Starting or Restoring.
12506	* Console::detachAllUSBDevices() will be called upon successful
12507	* termination. So, we need to release USB devices only if there was
12508	* an abnormal termination of a running VM.
12509	*
12510	* This is identical to SessionMachine::DetachAllUSBDevices except
12511	* for the aAbnormal argument. */
12512	HRESULT rc = mUSBDeviceFilters->i_notifyProxy(false /* aInsertFilters */);
12513	AssertComRC(rc);
12514	NOREF(rc);
12515
12516	USBProxyService *service = mParent->i_host()->i_usbProxyService();
12517	if (service)
12518	service->detachAllDevicesFromVM(this, true /* aDone /, true / aAbnormal */);
12519	}
12520	#endif /* VBOX_WITH_USB */
12521
12522	// we need to lock this object in uninit() because the lock is shared
12523	// with mPeer (as well as data we modify below). mParent lock is needed
12524	// by several calls to it.
12525	AutoMultiWriteLock2 multilock(mParent, this COMMA_LOCKVAL_SRC_POS);
12526
12527	#ifdef VBOX_WITH_RESOURCE_USAGE_API
12528	/*
12529	* It is safe to call Machine::i_unregisterMetrics() here because
12530	* PerformanceCollector::samplerCallback no longer accesses guest methods
12531	* holding the lock.
12532	*/
12533	i_unregisterMetrics(mParent->i_performanceCollector(), mPeer);
12534	/* The guest must be unregistered after its metrics (@bugref{5949}). */
12535	Log7Func(("{%p}: mCollectorGuest=%p\n", this, mCollectorGuest));
12536	if (mCollectorGuest)
12537	{
12538	mParent->i_performanceCollector()->unregisterGuest(mCollectorGuest);
12539	// delete mCollectorGuest; => CollectorGuestManager::destroyUnregistered()
12540	mCollectorGuest = NULL;
12541	}
12542	#endif
12543
12544	if (aReason == Uninit::Abnormal)
12545	{
12546	Log1WarningThisFunc(("ABNORMAL client termination! (wasBusy=%d)\n", Global::IsOnlineOrTransient(lastState)));
12547
12548	/* reset the state to Aborted */
12549	if (mData->mMachineState != MachineState_Aborted)
12550	i_setMachineState(MachineState_Aborted);
12551	}
12552
12553	// any machine settings modified?
12554	if (mData->flModifications)
12555	{
12556	Log1WarningThisFunc(("Discarding unsaved settings changes!\n"));
12557	i_rollback(false /* aNotify */);
12558	}
12559
12560	mData->mSession.mPID = NIL_RTPROCESS;
12561
12562	if (aReason == Uninit::Unexpected)
12563	{
12564	/* Uninitialization didn't come from #i_checkForDeath(), so tell the
12565	* client watcher thread to update the set of machines that have open
12566	* sessions. */
12567	mParent->i_updateClientWatcher();
12568	}
12569
12570	/* uninitialize all remote controls */
12571	if (mData->mSession.mRemoteControls.size())
12572	{
12573	LogFlowThisFunc(("Closing remote sessions (%d):\n",
12574	mData->mSession.mRemoteControls.size()));
12575
12576	/* Always restart a the beginning, since the iterator is invalidated
12577	* by using erase(). */
12578	for (Data::Session::RemoteControlList::iterator
12579	it = mData->mSession.mRemoteControls.begin();
12580	it != mData->mSession.mRemoteControls.end();
12581	it = mData->mSession.mRemoteControls.begin())
12582	{
12583	ComPtr<IInternalSessionControl> pControl = *it;
12584	mData->mSession.mRemoteControls.erase(it);
12585	multilock.release();
12586	LogFlowThisFunc((" Calling remoteControl->Uninitialize()...\n"));
12587	HRESULT rc = pControl->Uninitialize();
12588	LogFlowThisFunc((" remoteControl->Uninitialize() returned %08X\n", rc));
12589	if (FAILED(rc))
12590	Log1WarningThisFunc(("Forgot to close the remote session?\n"));
12591	multilock.acquire();
12592	}
12593	mData->mSession.mRemoteControls.clear();
12594	}
12595
12596	/* Remove all references to the NAT network service. The service will stop
12597	* if all references (also from other VMs) are removed. */
12598	for (; miNATNetworksStarted > 0; miNATNetworksStarted--)
12599	{
12600	for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
12601	{
12602	BOOL enabled;
12603	HRESULT hrc = mNetworkAdapters[slot]->COMGETTER(Enabled)(&enabled);
12604	if ( FAILED(hrc)
12605	\|\| !enabled)
12606	continue;
12607
12608	NetworkAttachmentType_T type;
12609	hrc = mNetworkAdapters[slot]->COMGETTER(AttachmentType)(&type);
12610	if ( SUCCEEDED(hrc)
12611	&& type == NetworkAttachmentType_NATNetwork)
12612	{
12613	Bstr name;
12614	hrc = mNetworkAdapters[slot]->COMGETTER(NATNetwork)(name.asOutParam());
12615	if (SUCCEEDED(hrc))
12616	{
12617	multilock.release();
12618	Utf8Str strName(name);
12619	LogRel(("VM '%s' stops using NAT network '%s'\n",
12620	mUserData->s.strName.c_str(), strName.c_str()));
12621	mParent->i_natNetworkRefDec(strName);
12622	multilock.acquire();
12623	}
12624	}
12625	}
12626	}
12627
12628	/*
12629	* An expected uninitialization can come only from #i_checkForDeath().
12630	* Otherwise it means that something's gone really wrong (for example,
12631	* the Session implementation has released the VirtualBox reference
12632	* before it triggered #OnSessionEnd(), or before releasing IPC semaphore,
12633	* etc). However, it's also possible, that the client releases the IPC
12634	* semaphore correctly (i.e. before it releases the VirtualBox reference),
12635	* but the VirtualBox release event comes first to the server process.
12636	* This case is practically possible, so we should not assert on an
12637	* unexpected uninit, just log a warning.
12638	*/
12639
12640	if (aReason == Uninit::Unexpected)
12641	Log1WarningThisFunc(("Unexpected SessionMachine uninitialization!\n"));
12642
12643	if (aReason != Uninit::Normal)
12644	{
12645	mData->mSession.mDirectControl.setNull();
12646	}
12647	else
12648	{
12649	/* this must be null here (see #OnSessionEnd()) */
12650	Assert(mData->mSession.mDirectControl.isNull());
12651	Assert(mData->mSession.mState == SessionState_Unlocking);
12652	Assert(!mData->mSession.mProgress.isNull());
12653	}
12654	if (mData->mSession.mProgress)
12655	{
12656	if (aReason == Uninit::Normal)
12657	mData->mSession.mProgress->i_notifyComplete(S_OK);
12658	else
12659	mData->mSession.mProgress->i_notifyComplete(E_FAIL,
12660	COM_IIDOF(ISession),
12661	getComponentName(),
12662	tr("The VM session was aborted"));
12663	mData->mSession.mProgress.setNull();
12664	}
12665
12666	if (mConsoleTaskData.mProgress)
12667	{
12668	Assert(aReason == Uninit::Abnormal);
12669	mConsoleTaskData.mProgress->i_notifyComplete(E_FAIL,
12670	COM_IIDOF(ISession),
12671	getComponentName(),
12672	tr("The VM session was aborted"));
12673	mConsoleTaskData.mProgress.setNull();
12674	}
12675
12676	/* remove the association between the peer machine and this session machine */
12677	Assert( (SessionMachine*)mData->mSession.mMachine == this
12678	\|\| aReason == Uninit::Unexpected);
12679
12680	/* reset the rest of session data */
12681	mData->mSession.mLockType = LockType_Null;
12682	mData->mSession.mMachine.setNull();
12683	mData->mSession.mState = SessionState_Unlocked;
12684	mData->mSession.mName.setNull();
12685
12686	/* destroy the machine client token before leaving the exclusive lock */
12687	if (mClientToken)
12688	{
12689	delete mClientToken;
12690	mClientToken = NULL;
12691	}
12692
12693	/* fire an event */
12694	mParent->i_onSessionStateChanged(mData->mUuid, SessionState_Unlocked);
12695
12696	uninitDataAndChildObjects();
12697
12698	/* free the essential data structure last */
12699	mData.free();
12700
12701	/* release the exclusive lock before setting the below two to NULL */
12702	multilock.release();
12703
12704	unconst(mParent) = NULL;
12705	unconst(mPeer) = NULL;
12706
12707	AuthLibUnload(&mAuthLibCtx);
12708
12709	LogFlowThisFuncLeave();
12710	}
12711
12712	// util::Lockable interface
12713	////////////////////////////////////////////////////////////////////////////////
12714
12715	/**
12716	* Overrides VirtualBoxBase::lockHandle() in order to share the lock handle
12717	* with the primary Machine instance (mPeer).
12718	*/
12719	RWLockHandle *SessionMachine::lockHandle() const
12720	{
12721	AssertReturn(mPeer != NULL, NULL);
12722	return mPeer->lockHandle();
12723	}
12724
12725	// IInternalMachineControl methods
12726	////////////////////////////////////////////////////////////////////////////////
12727
12728	/**
12729	* Passes collected guest statistics to performance collector object
12730	*/
12731	HRESULT SessionMachine::reportVmStatistics(ULONG aValidStats, ULONG aCpuUser,
12732	ULONG aCpuKernel, ULONG aCpuIdle,
12733	ULONG aMemTotal, ULONG aMemFree,
12734	ULONG aMemBalloon, ULONG aMemShared,
12735	ULONG aMemCache, ULONG aPageTotal,
12736	ULONG aAllocVMM, ULONG aFreeVMM,
12737	ULONG aBalloonedVMM, ULONG aSharedVMM,
12738	ULONG aVmNetRx, ULONG aVmNetTx)
12739	{
12740	#ifdef VBOX_WITH_RESOURCE_USAGE_API
12741	if (mCollectorGuest)
12742	mCollectorGuest->updateStats(aValidStats, aCpuUser, aCpuKernel, aCpuIdle,
12743	aMemTotal, aMemFree, aMemBalloon, aMemShared,
12744	aMemCache, aPageTotal, aAllocVMM, aFreeVMM,
12745	aBalloonedVMM, aSharedVMM, aVmNetRx, aVmNetTx);
12746
12747	return S_OK;
12748	#else
12749	NOREF(aValidStats);
12750	NOREF(aCpuUser);
12751	NOREF(aCpuKernel);
12752	NOREF(aCpuIdle);
12753	NOREF(aMemTotal);
12754	NOREF(aMemFree);
12755	NOREF(aMemBalloon);
12756	NOREF(aMemShared);
12757	NOREF(aMemCache);
12758	NOREF(aPageTotal);
12759	NOREF(aAllocVMM);
12760	NOREF(aFreeVMM);
12761	NOREF(aBalloonedVMM);
12762	NOREF(aSharedVMM);
12763	NOREF(aVmNetRx);
12764	NOREF(aVmNetTx);
12765	return E_NOTIMPL;
12766	#endif
12767	}
12768
12769	////////////////////////////////////////////////////////////////////////////////
12770	//
12771	// SessionMachine task records
12772	//
12773	////////////////////////////////////////////////////////////////////////////////
12774
12775	/**
12776	* Task record for saving the machine state.
12777	*/
12778	class SessionMachine::SaveStateTask
12779	: public Machine::Task
12780	{
12781	public:
12782	SaveStateTask(SessionMachine *m,
12783	Progress *p,
12784	const Utf8Str &t,
12785	Reason_T enmReason,
12786	const Utf8Str &strStateFilePath)
12787	: Task(m, p, t),
12788	m_enmReason(enmReason),
12789	m_strStateFilePath(strStateFilePath)
12790	{}
12791
12792	private:
12793	void handler()
12794	{
12795	((SessionMachine )(Machine )m_pMachine)->i_saveStateHandler(*this);
12796	}
12797
12798	Reason_T m_enmReason;
12799	Utf8Str m_strStateFilePath;
12800
12801	friend class SessionMachine;
12802	};
12803
12804	/**
12805	* Task thread implementation for SessionMachine::SaveState(), called from
12806	* SessionMachine::taskHandler().
12807	*
12808	* @note Locks this object for writing.
12809	*
12810	* @param task
12811	* @return
12812	*/
12813	void SessionMachine::i_saveStateHandler(SaveStateTask &task)
12814	{
12815	LogFlowThisFuncEnter();
12816
12817	AutoCaller autoCaller(this);
12818	LogFlowThisFunc(("state=%d\n", getObjectState().getState()));
12819	if (FAILED(autoCaller.rc()))
12820	{
12821	/* we might have been uninitialized because the session was accidentally
12822	* closed by the client, so don't assert */
12823	HRESULT rc = setError(E_FAIL,
12824	tr("The session has been accidentally closed"));
12825	task.m_pProgress->i_notifyComplete(rc);
12826	LogFlowThisFuncLeave();
12827	return;
12828	}
12829
12830	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
12831
12832	HRESULT rc = S_OK;
12833
12834	try
12835	{
12836	ComPtr<IInternalSessionControl> directControl;
12837	if (mData->mSession.mLockType == LockType_VM)
12838	directControl = mData->mSession.mDirectControl;
12839	if (directControl.isNull())
12840	throw setError(VBOX_E_INVALID_VM_STATE,
12841	tr("Trying to save state without a running VM"));
12842	alock.release();
12843	BOOL fSuspendedBySave;
12844	rc = directControl->SaveStateWithReason(task.m_enmReason, task.m_pProgress, NULL, Bstr(task.m_strStateFilePath).raw(), task.m_machineStateBackup != MachineState_Paused, &fSuspendedBySave);
12845	Assert(!fSuspendedBySave);
12846	alock.acquire();
12847
12848	AssertStmt( (SUCCEEDED(rc) && mData->mMachineState == MachineState_Saved)
12849	\|\| (FAILED(rc) && mData->mMachineState == MachineState_Saving),
12850	throw E_FAIL);
12851
12852	if (SUCCEEDED(rc))
12853	{
12854	mSSData->strStateFilePath = task.m_strStateFilePath;
12855
12856	/* save all VM settings */
12857	rc = i_saveSettings(NULL);
12858	// no need to check whether VirtualBox.xml needs saving also since
12859	// we can't have a name change pending at this point
12860	}
12861	else
12862	{
12863	// On failure, set the state to the state we had at the beginning.
12864	i_setMachineState(task.m_machineStateBackup);
12865	i_updateMachineStateOnClient();
12866
12867	// Delete the saved state file (might have been already created).
12868	// No need to check whether this is shared with a snapshot here
12869	// because we certainly created a fresh saved state file here.
12870	RTFileDelete(task.m_strStateFilePath.c_str());
12871	}
12872	}
12873	catch (HRESULT aRC) { rc = aRC; }
12874
12875	task.m_pProgress->i_notifyComplete(rc);
12876
12877	LogFlowThisFuncLeave();
12878	}
12879
12880	/**
12881	* @note Locks this object for writing.
12882	*/
12883	HRESULT SessionMachine::saveState(ComPtr<IProgress> &aProgress)
12884	{
12885	return i_saveStateWithReason(Reason_Unspecified, aProgress);
12886	}
12887
12888	HRESULT SessionMachine::i_saveStateWithReason(Reason_T aReason, ComPtr<IProgress> &aProgress)
12889	{
12890	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
12891
12892	HRESULT rc = i_checkStateDependency(MutableOrRunningStateDep);
12893	if (FAILED(rc)) return rc;
12894
12895	if ( mData->mMachineState != MachineState_Running
12896	&& mData->mMachineState != MachineState_Paused
12897	)
12898	return setError(VBOX_E_INVALID_VM_STATE,
12899	tr("Cannot save the execution state as the machine is not running or paused (machine state: %s)"),
12900	Global::stringifyMachineState(mData->mMachineState));
12901
12902	ComObjPtr<Progress> pProgress;
12903	pProgress.createObject();
12904	rc = pProgress->init(i_getVirtualBox(),
12905	static_cast<IMachine >(this) / aInitiator */,
12906	tr("Saving the execution state of the virtual machine"),
12907	FALSE /* aCancelable */);
12908	if (FAILED(rc))
12909	return rc;
12910
12911	Utf8Str strStateFilePath;
12912	i_composeSavedStateFilename(strStateFilePath);
12913
12914	/* create and start the task on a separate thread (note that it will not
12915	* start working until we release alock) */
12916	SaveStateTask *pTask = new SaveStateTask(this, pProgress, "SaveState", aReason, strStateFilePath);
12917	rc = pTask->createThread();
12918	if (FAILED(rc))
12919	return rc;
12920
12921	/* set the state to Saving (expected by Session::SaveStateWithReason()) */
12922	i_setMachineState(MachineState_Saving);
12923	i_updateMachineStateOnClient();
12924
12925	pProgress.queryInterfaceTo(aProgress.asOutParam());
12926
12927	return S_OK;
12928	}
12929
12930	/**
12931	* @note Locks this object for writing.
12932	*/
12933	HRESULT SessionMachine::adoptSavedState(const com::Utf8Str &aSavedStateFile)
12934	{
12935	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
12936
12937	HRESULT rc = i_checkStateDependency(MutableStateDep);
12938	if (FAILED(rc)) return rc;
12939
12940	if ( mData->mMachineState != MachineState_PoweredOff
12941	&& mData->mMachineState != MachineState_Teleported
12942	&& mData->mMachineState != MachineState_Aborted
12943	)
12944	return setError(VBOX_E_INVALID_VM_STATE,
12945	tr("Cannot adopt the saved machine state as the machine is not in Powered Off, Teleported or Aborted state (machine state: %s)"),
12946	Global::stringifyMachineState(mData->mMachineState));
12947
12948	com::Utf8Str stateFilePathFull;
12949	int vrc = i_calculateFullPath(aSavedStateFile, stateFilePathFull);
12950	if (RT_FAILURE(vrc))
12951	return setErrorBoth(VBOX_E_FILE_ERROR, vrc,
12952	tr("Invalid saved state file path '%s' (%Rrc)"),
12953	aSavedStateFile.c_str(),
12954	vrc);
12955
12956	mSSData->strStateFilePath = stateFilePathFull;
12957
12958	/* The below i_setMachineState() will detect the state transition and will
12959	* update the settings file */
12960
12961	return i_setMachineState(MachineState_Saved);
12962	}
12963
12964	/**
12965	* @note Locks this object for writing.
12966	*/
12967	HRESULT SessionMachine::discardSavedState(BOOL aFRemoveFile)
12968	{
12969	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
12970
12971	HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
12972	if (FAILED(rc)) return rc;
12973
12974	if (mData->mMachineState != MachineState_Saved)
12975	return setError(VBOX_E_INVALID_VM_STATE,
12976	tr("Cannot delete the machine state as the machine is not in the saved state (machine state: %s)"),
12977	Global::stringifyMachineState(mData->mMachineState));
12978
12979	mRemoveSavedState = RT_BOOL(aFRemoveFile);
12980
12981	/*
12982	* Saved -> PoweredOff transition will be detected in the SessionMachine
12983	* and properly handled.
12984	*/
12985	rc = i_setMachineState(MachineState_PoweredOff);
12986	return rc;
12987	}
12988
12989
12990	/**
12991	* @note Locks the same as #i_setMachineState() does.
12992	*/
12993	HRESULT SessionMachine::updateState(MachineState_T aState)
12994	{
12995	return i_setMachineState(aState);
12996	}
12997
12998	/**
12999	* @note Locks this object for writing.
13000	*/
13001	HRESULT SessionMachine::beginPowerUp(const ComPtr<IProgress> &aProgress)
13002	{
13003	IProgress *pProgress(aProgress);
13004
13005	LogFlowThisFunc(("aProgress=%p\n", pProgress));
13006
13007	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13008
13009	if (mData->mSession.mState != SessionState_Locked)
13010	return VBOX_E_INVALID_OBJECT_STATE;
13011
13012	if (!mData->mSession.mProgress.isNull())
13013	mData->mSession.mProgress->setOtherProgressObject(pProgress);
13014
13015	/* If we didn't reference the NAT network service yet, add a reference to
13016	* force a start */
13017	if (miNATNetworksStarted < 1)
13018	{
13019	for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
13020	{
13021	BOOL enabled;
13022	HRESULT hrc = mNetworkAdapters[slot]->COMGETTER(Enabled)(&enabled);
13023	if ( FAILED(hrc)
13024	\|\| !enabled)
13025	continue;
13026
13027	NetworkAttachmentType_T type;
13028	hrc = mNetworkAdapters[slot]->COMGETTER(AttachmentType)(&type);
13029	if ( SUCCEEDED(hrc)
13030	&& type == NetworkAttachmentType_NATNetwork)
13031	{
13032	Bstr name;
13033	hrc = mNetworkAdapters[slot]->COMGETTER(NATNetwork)(name.asOutParam());
13034	if (SUCCEEDED(hrc))
13035	{
13036	Utf8Str strName(name);
13037	LogRel(("VM '%s' starts using NAT network '%s'\n",
13038	mUserData->s.strName.c_str(), strName.c_str()));
13039	mPeer->lockHandle()->unlockWrite();
13040	mParent->i_natNetworkRefInc(strName);
13041	#ifdef RT_LOCK_STRICT
13042	mPeer->lockHandle()->lockWrite(RT_SRC_POS);
13043	#else
13044	mPeer->lockHandle()->lockWrite();
13045	#endif
13046	}
13047	}
13048	}
13049	miNATNetworksStarted++;
13050	}
13051
13052	LogFlowThisFunc(("returns S_OK.\n"));
13053	return S_OK;
13054	}
13055
13056	/**
13057	* @note Locks this object for writing.
13058	*/
13059	HRESULT SessionMachine::endPowerUp(LONG aResult)
13060	{
13061	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13062
13063	if (mData->mSession.mState != SessionState_Locked)
13064	return VBOX_E_INVALID_OBJECT_STATE;
13065
13066	/* Finalize the LaunchVMProcess progress object. */
13067	if (mData->mSession.mProgress)
13068	{
13069	mData->mSession.mProgress->notifyComplete((HRESULT)aResult);
13070	mData->mSession.mProgress.setNull();
13071	}
13072
13073	if (SUCCEEDED((HRESULT)aResult))
13074	{
13075	#ifdef VBOX_WITH_RESOURCE_USAGE_API
13076	/* The VM has been powered up successfully, so it makes sense
13077	* now to offer the performance metrics for a running machine
13078	* object. Doing it earlier wouldn't be safe. */
13079	i_registerMetrics(mParent->i_performanceCollector(), mPeer,
13080	mData->mSession.mPID);
13081	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
13082	}
13083
13084	return S_OK;
13085	}
13086
13087	/**
13088	* @note Locks this object for writing.
13089	*/
13090	HRESULT SessionMachine::beginPoweringDown(ComPtr<IProgress> &aProgress)
13091	{
13092	LogFlowThisFuncEnter();
13093
13094	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13095
13096	AssertReturn(mConsoleTaskData.mLastState == MachineState_Null,
13097	E_FAIL);
13098
13099	/* create a progress object to track operation completion */
13100	ComObjPtr<Progress> pProgress;
13101	pProgress.createObject();
13102	pProgress->init(i_getVirtualBox(),
13103	static_cast<IMachine >(this) / aInitiator */,
13104	tr("Stopping the virtual machine"),
13105	FALSE /* aCancelable */);
13106
13107	/* fill in the console task data */
13108	mConsoleTaskData.mLastState = mData->mMachineState;
13109	mConsoleTaskData.mProgress = pProgress;
13110
13111	/* set the state to Stopping (this is expected by Console::PowerDown()) */
13112	i_setMachineState(MachineState_Stopping);
13113
13114	pProgress.queryInterfaceTo(aProgress.asOutParam());
13115
13116	return S_OK;
13117	}
13118
13119	/**
13120	* @note Locks this object for writing.
13121	*/
13122	HRESULT SessionMachine::endPoweringDown(LONG aResult,
13123	const com::Utf8Str &aErrMsg)
13124	{
13125	HRESULT const hrcResult = (HRESULT)aResult;
13126	LogFlowThisFuncEnter();
13127
13128	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13129
13130	AssertReturn( ( (SUCCEEDED(hrcResult) && mData->mMachineState == MachineState_PoweredOff)
13131	\|\| (FAILED(hrcResult) && mData->mMachineState == MachineState_Stopping))
13132	&& mConsoleTaskData.mLastState != MachineState_Null,
13133	E_FAIL);
13134
13135	/*
13136	* On failure, set the state to the state we had when BeginPoweringDown()
13137	* was called (this is expected by Console::PowerDown() and the associated
13138	* task). On success the VM process already changed the state to
13139	* MachineState_PoweredOff, so no need to do anything.
13140	*/
13141	if (FAILED(hrcResult))
13142	i_setMachineState(mConsoleTaskData.mLastState);
13143
13144	/* notify the progress object about operation completion */
13145	Assert(mConsoleTaskData.mProgress);
13146	if (SUCCEEDED(hrcResult))
13147	mConsoleTaskData.mProgress->i_notifyComplete(S_OK);
13148	else
13149	{
13150	if (aErrMsg.length())
13151	mConsoleTaskData.mProgress->i_notifyComplete(hrcResult,
13152	COM_IIDOF(ISession),
13153	getComponentName(),
13154	aErrMsg.c_str());
13155	else
13156	mConsoleTaskData.mProgress->i_notifyComplete(hrcResult);
13157	}
13158
13159	/* clear out the temporary saved state data */
13160	mConsoleTaskData.mLastState = MachineState_Null;
13161	mConsoleTaskData.mProgress.setNull();
13162
13163	LogFlowThisFuncLeave();
13164	return S_OK;
13165	}
13166
13167
13168	/**
13169	* Goes through the USB filters of the given machine to see if the given
13170	* device matches any filter or not.
13171	*
13172	* @note Locks the same as USBController::hasMatchingFilter() does.
13173	*/
13174	HRESULT SessionMachine::runUSBDeviceFilters(const ComPtr<IUSBDevice> &aDevice,
13175	BOOL *aMatched,
13176	ULONG *aMaskedInterfaces)
13177	{
13178	LogFlowThisFunc(("\n"));
13179
13180	#ifdef VBOX_WITH_USB
13181	*aMatched = mUSBDeviceFilters->i_hasMatchingFilter(aDevice, aMaskedInterfaces);
13182	#else
13183	NOREF(aDevice);
13184	NOREF(aMaskedInterfaces);
13185	*aMatched = FALSE;
13186	#endif
13187
13188	return S_OK;
13189	}
13190
13191	/**
13192	* @note Locks the same as Host::captureUSBDevice() does.
13193	*/
13194	HRESULT SessionMachine::captureUSBDevice(const com::Guid &aId, const com::Utf8Str &aCaptureFilename)
13195	{
13196	LogFlowThisFunc(("\n"));
13197
13198	#ifdef VBOX_WITH_USB
13199	/* if captureDeviceForVM() fails, it must have set extended error info */
13200	clearError();
13201	MultiResult rc = mParent->i_host()->i_checkUSBProxyService();
13202	if (FAILED(rc)) return rc;
13203
13204	USBProxyService *service = mParent->i_host()->i_usbProxyService();
13205	AssertReturn(service, E_FAIL);
13206	return service->captureDeviceForVM(this, aId.ref(), aCaptureFilename);
13207	#else
13208	RT_NOREF(aId, aCaptureFilename);
13209	return E_NOTIMPL;
13210	#endif
13211	}
13212
13213	/**
13214	* @note Locks the same as Host::detachUSBDevice() does.
13215	*/
13216	HRESULT SessionMachine::detachUSBDevice(const com::Guid &aId,
13217	BOOL aDone)
13218	{
13219	LogFlowThisFunc(("\n"));
13220
13221	#ifdef VBOX_WITH_USB
13222	USBProxyService *service = mParent->i_host()->i_usbProxyService();
13223	AssertReturn(service, E_FAIL);
13224	return service->detachDeviceFromVM(this, aId.ref(), !!aDone);
13225	#else
13226	NOREF(aId);
13227	NOREF(aDone);
13228	return E_NOTIMPL;
13229	#endif
13230	}
13231
13232	/**
13233	* Inserts all machine filters to the USB proxy service and then calls
13234	* Host::autoCaptureUSBDevices().
13235	*
13236	* Called by Console from the VM process upon VM startup.
13237	*
13238	* @note Locks what called methods lock.
13239	*/
13240	HRESULT SessionMachine::autoCaptureUSBDevices()
13241	{
13242	LogFlowThisFunc(("\n"));
13243
13244	#ifdef VBOX_WITH_USB
13245	HRESULT rc = mUSBDeviceFilters->i_notifyProxy(true /* aInsertFilters */);
13246	AssertComRC(rc);
13247	NOREF(rc);
13248
13249	USBProxyService *service = mParent->i_host()->i_usbProxyService();
13250	AssertReturn(service, E_FAIL);
13251	return service->autoCaptureDevicesForVM(this);
13252	#else
13253	return S_OK;
13254	#endif
13255	}
13256
13257	/**
13258	* Removes all machine filters from the USB proxy service and then calls
13259	* Host::detachAllUSBDevices().
13260	*
13261	* Called by Console from the VM process upon normal VM termination or by
13262	* SessionMachine::uninit() upon abnormal VM termination (from under the
13263	* Machine/SessionMachine lock).
13264	*
13265	* @note Locks what called methods lock.
13266	*/
13267	HRESULT SessionMachine::detachAllUSBDevices(BOOL aDone)
13268	{
13269	LogFlowThisFunc(("\n"));
13270
13271	#ifdef VBOX_WITH_USB
13272	HRESULT rc = mUSBDeviceFilters->i_notifyProxy(false /* aInsertFilters */);
13273	AssertComRC(rc);
13274	NOREF(rc);
13275
13276	USBProxyService *service = mParent->i_host()->i_usbProxyService();
13277	AssertReturn(service, E_FAIL);
13278	return service->detachAllDevicesFromVM(this, !!aDone, false /* aAbnormal */);
13279	#else
13280	NOREF(aDone);
13281	return S_OK;
13282	#endif
13283	}
13284
13285	/**
13286	* @note Locks this object for writing.
13287	*/
13288	HRESULT SessionMachine::onSessionEnd(const ComPtr<ISession> &aSession,
13289	ComPtr<IProgress> &aProgress)
13290	{
13291	LogFlowThisFuncEnter();
13292
13293	LogFlowThisFunc(("callerstate=%d\n", getObjectState().getState()));
13294	/*
13295	* We don't assert below because it might happen that a non-direct session
13296	* informs us it is closed right after we've been uninitialized -- it's ok.
13297	*/
13298
13299	/* get IInternalSessionControl interface */
13300	ComPtr<IInternalSessionControl> control(aSession);
13301
13302	ComAssertRet(!control.isNull(), E_INVALIDARG);
13303
13304	/* Creating a Progress object requires the VirtualBox lock, and
13305	* thus locking it here is required by the lock order rules. */
13306	AutoMultiWriteLock2 alock(mParent, this COMMA_LOCKVAL_SRC_POS);
13307
13308	if (control == mData->mSession.mDirectControl)
13309	{
13310	/* The direct session is being normally closed by the client process
13311	* ----------------------------------------------------------------- */
13312
13313	/* go to the closing state (essential for all open*Session() calls and
13314	* for #i_checkForDeath()) */
13315	Assert(mData->mSession.mState == SessionState_Locked);
13316	mData->mSession.mState = SessionState_Unlocking;
13317
13318	/* set direct control to NULL to release the remote instance */
13319	mData->mSession.mDirectControl.setNull();
13320	LogFlowThisFunc(("Direct control is set to NULL\n"));
13321
13322	if (mData->mSession.mProgress)
13323	{
13324	/* finalize the progress, someone might wait if a frontend
13325	* closes the session before powering on the VM. */
13326	mData->mSession.mProgress->notifyComplete(E_FAIL,
13327	COM_IIDOF(ISession),
13328	getComponentName(),
13329	tr("The VM session was closed before any attempt to power it on"));
13330	mData->mSession.mProgress.setNull();
13331	}
13332
13333	/* Create the progress object the client will use to wait until
13334	* #i_checkForDeath() is called to uninitialize this session object after
13335	* it releases the IPC semaphore.
13336	* Note! Because we're "reusing" mProgress here, this must be a proxy
13337	* object just like for LaunchVMProcess. */
13338	Assert(mData->mSession.mProgress.isNull());
13339	ComObjPtr<ProgressProxy> progress;
13340	progress.createObject();
13341	ComPtr<IUnknown> pPeer(mPeer);
13342	progress->init(mParent, pPeer,
13343	Bstr(tr("Closing session")).raw(),
13344	FALSE /* aCancelable */);
13345	progress.queryInterfaceTo(aProgress.asOutParam());
13346	mData->mSession.mProgress = progress;
13347	}
13348	else
13349	{
13350	/* the remote session is being normally closed */
13351	bool found = false;
13352	for (Data::Session::RemoteControlList::iterator
13353	it = mData->mSession.mRemoteControls.begin();
13354	it != mData->mSession.mRemoteControls.end();
13355	++it)
13356	{
13357	if (control == *it)
13358	{
13359	found = true;
13360	// This MUST be erase(it), not remove(*it) as the latter
13361	// triggers a very nasty use after free due to the place where
13362	// the value "lives".
13363	mData->mSession.mRemoteControls.erase(it);
13364	break;
13365	}
13366	}
13367	ComAssertMsgRet(found, ("The session is not found in the session list!"),
13368	E_INVALIDARG);
13369	}
13370
13371	/* signal the client watcher thread, because the client is going away */
13372	mParent->i_updateClientWatcher();
13373
13374	LogFlowThisFuncLeave();
13375	return S_OK;
13376	}
13377
13378	HRESULT SessionMachine::clipboardAreaRegister(const std::vector<com::Utf8Str> &aParms, ULONG *aID)
13379	{
13380	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
13381	ULONG uID;
13382	int rc = mParent->i_onClipboardAreaRegister(aParms, &uID);
13383	if (RT_SUCCESS(rc))
13384	{
13385	if (aID)
13386	*aID = uID;
13387	return S_OK;
13388	}
13389	return E_FAIL;
13390	#else
13391	RT_NOREF(aParms, aID);
13392	ReturnComNotImplemented();
13393	#endif
13394	}
13395
13396	HRESULT SessionMachine::clipboardAreaUnregister(ULONG aID)
13397	{
13398	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
13399	return mParent->i_onClipboardAreaUnregister(aID);
13400	#else
13401	RT_NOREF(aID);
13402	ReturnComNotImplemented();
13403	#endif
13404	}
13405
13406	HRESULT SessionMachine::clipboardAreaAttach(ULONG aID)
13407	{
13408	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
13409	return mParent->i_onClipboardAreaAttach(aID);
13410	#else
13411	RT_NOREF(aID);
13412	ReturnComNotImplemented();
13413	#endif
13414	}
13415	HRESULT SessionMachine::clipboardAreaDetach(ULONG aID)
13416	{
13417	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
13418	return mParent->i_onClipboardAreaDetach(aID);
13419	#else
13420	RT_NOREF(aID);
13421	ReturnComNotImplemented();
13422	#endif
13423	}
13424
13425	HRESULT SessionMachine::clipboardAreaGetMostRecent(ULONG *aID)
13426	{
13427	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
13428	ULONG uID = mParent->i_onClipboardAreaGetMostRecent();
13429	if (aID)
13430	*aID = uID;
13431	return S_OK;
13432	#else
13433	RT_NOREF(aID);
13434	ReturnComNotImplemented();
13435	#endif
13436	}
13437
13438	HRESULT SessionMachine::clipboardAreaGetRefCount(ULONG aID, ULONG *aRefCount)
13439	{
13440	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
13441	ULONG uRefCount = mParent->i_onClipboardAreaGetRefCount(aID);
13442	if (aRefCount)
13443	*aRefCount = uRefCount;
13444	return S_OK;
13445	#else
13446	RT_NOREF(aID, aRefCount);
13447	ReturnComNotImplemented();
13448	#endif
13449	}
13450
13451	HRESULT SessionMachine::pullGuestProperties(std::vector<com::Utf8Str> &aNames,
13452	std::vector<com::Utf8Str> &aValues,
13453	std::vector<LONG64> &aTimestamps,
13454	std::vector<com::Utf8Str> &aFlags)
13455	{
13456	LogFlowThisFunc(("\n"));
13457
13458	#ifdef VBOX_WITH_GUEST_PROPS
13459	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13460
13461	size_t cEntries = mHWData->mGuestProperties.size();
13462	aNames.resize(cEntries);
13463	aValues.resize(cEntries);
13464	aTimestamps.resize(cEntries);
13465	aFlags.resize(cEntries);
13466
13467	size_t i = 0;
13468	for (HWData::GuestPropertyMap::const_iterator
13469	it = mHWData->mGuestProperties.begin();
13470	it != mHWData->mGuestProperties.end();
13471	++it, ++i)
13472	{
13473	char szFlags[GUEST_PROP_MAX_FLAGS_LEN + 1];
13474	aNames[i] = it->first;
13475	aValues[i] = it->second.strValue;
13476	aTimestamps[i] = it->second.mTimestamp;
13477
13478	/* If it is NULL, keep it NULL. */
13479	if (it->second.mFlags)
13480	{
13481	GuestPropWriteFlags(it->second.mFlags, szFlags);
13482	aFlags[i] = szFlags;
13483	}
13484	else
13485	aFlags[i] = "";
13486	}
13487	return S_OK;
13488	#else
13489	ReturnComNotImplemented();
13490	#endif
13491	}
13492
13493	HRESULT SessionMachine::pushGuestProperty(const com::Utf8Str &aName,
13494	const com::Utf8Str &aValue,
13495	LONG64 aTimestamp,
13496	const com::Utf8Str &aFlags)
13497	{
13498	LogFlowThisFunc(("\n"));
13499
13500	#ifdef VBOX_WITH_GUEST_PROPS
13501	try
13502	{
13503	/*
13504	* Convert input up front.
13505	*/
13506	uint32_t fFlags = GUEST_PROP_F_NILFLAG;
13507	if (aFlags.length())
13508	{
13509	int vrc = GuestPropValidateFlags(aFlags.c_str(), &fFlags);
13510	AssertRCReturn(vrc, E_INVALIDARG);
13511	}
13512
13513	/*
13514	* Now grab the object lock, validate the state and do the update.
13515	*/
13516
13517	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13518
13519	if (!Global::IsOnline(mData->mMachineState))
13520	{
13521	AssertMsgFailedReturn(("%s\n", Global::stringifyMachineState(mData->mMachineState)),
13522	VBOX_E_INVALID_VM_STATE);
13523	}
13524
13525	i_setModified(IsModified_MachineData);
13526	mHWData.backup();
13527
13528	bool fDelete = !aValue.length();
13529	HWData::GuestPropertyMap::iterator it = mHWData->mGuestProperties.find(aName);
13530	if (it != mHWData->mGuestProperties.end())
13531	{
13532	if (!fDelete)
13533	{
13534	it->second.strValue = aValue;
13535	it->second.mTimestamp = aTimestamp;
13536	it->second.mFlags = fFlags;
13537	}
13538	else
13539	mHWData->mGuestProperties.erase(it);
13540
13541	mData->mGuestPropertiesModified = TRUE;
13542	}
13543	else if (!fDelete)
13544	{
13545	HWData::GuestProperty prop;
13546	prop.strValue = aValue;
13547	prop.mTimestamp = aTimestamp;
13548	prop.mFlags = fFlags;
13549
13550	mHWData->mGuestProperties[aName] = prop;
13551	mData->mGuestPropertiesModified = TRUE;
13552	}
13553
13554	alock.release();
13555
13556	mParent->i_onGuestPropertyChanged(mData->mUuid, aName, aValue, aFlags);
13557	}
13558	catch (...)
13559	{
13560	return VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
13561	}
13562	return S_OK;
13563	#else
13564	ReturnComNotImplemented();
13565	#endif
13566	}
13567
13568
13569	HRESULT SessionMachine::lockMedia()
13570	{
13571	AutoMultiWriteLock2 alock(this->lockHandle(),
13572	&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
13573
13574	AssertReturn( mData->mMachineState == MachineState_Starting
13575	\|\| mData->mMachineState == MachineState_Restoring
13576	\|\| mData->mMachineState == MachineState_TeleportingIn, E_FAIL);
13577
13578	clearError();
13579	alock.release();
13580	return i_lockMedia();
13581	}
13582
13583	HRESULT SessionMachine::unlockMedia()
13584	{
13585	HRESULT hrc = i_unlockMedia();
13586	return hrc;
13587	}
13588
13589	HRESULT SessionMachine::ejectMedium(const ComPtr<IMediumAttachment> &aAttachment,
13590	ComPtr<IMediumAttachment> &aNewAttachment)
13591	{
13592	// request the host lock first, since might be calling Host methods for getting host drives;
13593	// next, protect the media tree all the while we're in here, as well as our member variables
13594	AutoMultiWriteLock3 multiLock(mParent->i_host()->lockHandle(),
13595	this->lockHandle(),
13596	&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
13597
13598	IMediumAttachment *iAttach = aAttachment;
13599	ComObjPtr<MediumAttachment> pAttach = static_cast<MediumAttachment *>(iAttach);
13600
13601	Utf8Str ctrlName;
13602	LONG lPort;
13603	LONG lDevice;
13604	bool fTempEject;
13605	{
13606	AutoReadLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
13607
13608	/* Need to query the details first, as the IMediumAttachment reference
13609	* might be to the original settings, which we are going to change. */
13610	ctrlName = pAttach->i_getControllerName();
13611	lPort = pAttach->i_getPort();
13612	lDevice = pAttach->i_getDevice();
13613	fTempEject = pAttach->i_getTempEject();
13614	}
13615
13616	if (!fTempEject)
13617	{
13618	/* Remember previously mounted medium. The medium before taking the
13619	* backup is not necessarily the same thing. */
13620	ComObjPtr<Medium> oldmedium;
13621	oldmedium = pAttach->i_getMedium();
13622
13623	i_setModified(IsModified_Storage);
13624	mMediumAttachments.backup();
13625
13626	// The backup operation makes the pAttach reference point to the
13627	// old settings. Re-get the correct reference.
13628	pAttach = i_findAttachment(*mMediumAttachments.data(),
13629	ctrlName,
13630	lPort,
13631	lDevice);
13632
13633	{
13634	AutoCaller autoAttachCaller(this);
13635	if (FAILED(autoAttachCaller.rc())) return autoAttachCaller.rc();
13636
13637	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
13638	if (!oldmedium.isNull())
13639	oldmedium->i_removeBackReference(mData->mUuid);
13640
13641	pAttach->i_updateMedium(NULL);
13642	pAttach->i_updateEjected();
13643	}
13644
13645	i_setModified(IsModified_Storage);
13646	}
13647	else
13648	{
13649	{
13650	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
13651	pAttach->i_updateEjected();
13652	}
13653	}
13654
13655	pAttach.queryInterfaceTo(aNewAttachment.asOutParam());
13656
13657	return S_OK;
13658	}
13659
13660	HRESULT SessionMachine::authenticateExternal(const std::vector<com::Utf8Str> &aAuthParams,
13661	com::Utf8Str &aResult)
13662	{
13663	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13664
13665	HRESULT hr = S_OK;
13666
13667	if (!mAuthLibCtx.hAuthLibrary)
13668	{
13669	/* Load the external authentication library. */
13670	Bstr authLibrary;
13671	mVRDEServer->COMGETTER(AuthLibrary)(authLibrary.asOutParam());
13672
13673	Utf8Str filename = authLibrary;
13674
13675	int vrc = AuthLibLoad(&mAuthLibCtx, filename.c_str());
13676	if (RT_FAILURE(vrc))
13677	hr = setErrorBoth(E_FAIL, vrc,
13678	tr("Could not load the external authentication library '%s' (%Rrc)"),
13679	filename.c_str(), vrc);
13680	}
13681
13682	/* The auth library might need the machine lock. */
13683	alock.release();
13684
13685	if (FAILED(hr))
13686	return hr;
13687
13688	if (aAuthParams[0] == "VRDEAUTH" && aAuthParams.size() == 7)
13689	{
13690	enum VRDEAuthParams
13691	{
13692	parmUuid = 1,
13693	parmGuestJudgement,
13694	parmUser,
13695	parmPassword,
13696	parmDomain,
13697	parmClientId
13698	};
13699
13700	AuthResult result = AuthResultAccessDenied;
13701
13702	Guid uuid(aAuthParams[parmUuid]);
13703	AuthGuestJudgement guestJudgement = (AuthGuestJudgement)aAuthParams[parmGuestJudgement].toUInt32();
13704	uint32_t u32ClientId = aAuthParams[parmClientId].toUInt32();
13705
13706	result = AuthLibAuthenticate(&mAuthLibCtx,
13707	uuid.raw(), guestJudgement,
13708	aAuthParams[parmUser].c_str(),
13709	aAuthParams[parmPassword].c_str(),
13710	aAuthParams[parmDomain].c_str(),
13711	u32ClientId);
13712
13713	/* Hack: aAuthParams[parmPassword] is const but the code believes in writable memory. */
13714	size_t cbPassword = aAuthParams[parmPassword].length();
13715	if (cbPassword)
13716	{
13717	RTMemWipeThoroughly((void )aAuthParams[parmPassword].c_str(), cbPassword, 10 / cPasses */);
13718	memset((void *)aAuthParams[parmPassword].c_str(), 'x', cbPassword);
13719	}
13720
13721	if (result == AuthResultAccessGranted)
13722	aResult = "granted";
13723	else
13724	aResult = "denied";
13725
13726	LogRel(("AUTH: VRDE authentification for user '%s' result '%s'\n",
13727	aAuthParams[parmUser].c_str(), aResult.c_str()));
13728	}
13729	else if (aAuthParams[0] == "VRDEAUTHDISCONNECT" && aAuthParams.size() == 3)
13730	{
13731	enum VRDEAuthDisconnectParams
13732	{
13733	parmUuid = 1,
13734	parmClientId
13735	};
13736
13737	Guid uuid(aAuthParams[parmUuid]);
13738	uint32_t u32ClientId = 0;
13739	AuthLibDisconnect(&mAuthLibCtx, uuid.raw(), u32ClientId);
13740	}
13741	else
13742	{
13743	hr = E_INVALIDARG;
13744	}
13745
13746	return hr;
13747	}
13748
13749	// public methods only for internal purposes
13750	/////////////////////////////////////////////////////////////////////////////
13751
13752	#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
13753	/**
13754	* Called from the client watcher thread to check for expected or unexpected
13755	* death of the client process that has a direct session to this machine.
13756	*
13757	* On Win32 and on OS/2, this method is called only when we've got the
13758	* mutex (i.e. the client has either died or terminated normally) so it always
13759	* returns @c true (the client is terminated, the session machine is
13760	* uninitialized).
13761	*
13762	* On other platforms, the method returns @c true if the client process has
13763	* terminated normally or abnormally and the session machine was uninitialized,
13764	* and @c false if the client process is still alive.
13765	*
13766	* @note Locks this object for writing.
13767	*/
13768	bool SessionMachine::i_checkForDeath()
13769	{
13770	Uninit::Reason reason;
13771	bool terminated = false;
13772
13773	/* Enclose autoCaller with a block because calling uninit() from under it
13774	* will deadlock. */
13775	{
13776	AutoCaller autoCaller(this);
13777	if (!autoCaller.isOk())
13778	{
13779	/* return true if not ready, to cause the client watcher to exclude
13780	* the corresponding session from watching */
13781	LogFlowThisFunc(("Already uninitialized!\n"));
13782	return true;
13783	}
13784
13785	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13786
13787	/* Determine the reason of death: if the session state is Closing here,
13788	* everything is fine. Otherwise it means that the client did not call
13789	* OnSessionEnd() before it released the IPC semaphore. This may happen
13790	* either because the client process has abnormally terminated, or
13791	* because it simply forgot to call ISession::Close() before exiting. We
13792	* threat the latter also as an abnormal termination (see
13793	* Session::uninit() for details). */
13794	reason = mData->mSession.mState == SessionState_Unlocking ?
13795	Uninit::Normal :
13796	Uninit::Abnormal;
13797
13798	if (mClientToken)
13799	terminated = mClientToken->release();
13800	} /* AutoCaller block */
13801
13802	if (terminated)
13803	uninit(reason);
13804
13805	return terminated;
13806	}
13807
13808	void SessionMachine::i_getTokenId(Utf8Str &strTokenId)
13809	{
13810	LogFlowThisFunc(("\n"));
13811
13812	strTokenId.setNull();
13813
13814	AutoCaller autoCaller(this);
13815	AssertComRCReturnVoid(autoCaller.rc());
13816
13817	Assert(mClientToken);
13818	if (mClientToken)
13819	mClientToken->getId(strTokenId);
13820	}
13821	#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
13822	IToken *SessionMachine::i_getToken()
13823	{
13824	LogFlowThisFunc(("\n"));
13825
13826	AutoCaller autoCaller(this);
13827	AssertComRCReturn(autoCaller.rc(), NULL);
13828
13829	Assert(mClientToken);
13830	if (mClientToken)
13831	return mClientToken->getToken();
13832	else
13833	return NULL;
13834	}
13835	#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
13836
13837	Machine::ClientToken *SessionMachine::i_getClientToken()
13838	{
13839	LogFlowThisFunc(("\n"));
13840
13841	AutoCaller autoCaller(this);
13842	AssertComRCReturn(autoCaller.rc(), NULL);
13843
13844	return mClientToken;
13845	}
13846
13847
13848	/**
13849	* @note Locks this object for reading.
13850	*/
13851	HRESULT SessionMachine::i_onNetworkAdapterChange(INetworkAdapter *networkAdapter, BOOL changeAdapter)
13852	{
13853	LogFlowThisFunc(("\n"));
13854
13855	AutoCaller autoCaller(this);
13856	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
13857
13858	ComPtr<IInternalSessionControl> directControl;
13859	{
13860	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13861	if (mData->mSession.mLockType == LockType_VM)
13862	directControl = mData->mSession.mDirectControl;
13863	}
13864
13865	/* ignore notifications sent after #OnSessionEnd() is called */
13866	if (!directControl)
13867	return S_OK;
13868
13869	return directControl->OnNetworkAdapterChange(networkAdapter, changeAdapter);
13870	}
13871
13872	/**
13873	* @note Locks this object for reading.
13874	*/
13875	HRESULT SessionMachine::i_onNATRedirectRuleChanged(ULONG ulSlot, BOOL aNatRuleRemove, const Utf8Str &aRuleName,
13876	NATProtocol_T aProto, const Utf8Str &aHostIp, LONG aHostPort,
13877	const Utf8Str &aGuestIp, LONG aGuestPort)
13878	{
13879	LogFlowThisFunc(("\n"));
13880
13881	AutoCaller autoCaller(this);
13882	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
13883
13884	ComPtr<IInternalSessionControl> directControl;
13885	{
13886	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13887	if (mData->mSession.mLockType == LockType_VM)
13888	directControl = mData->mSession.mDirectControl;
13889	}
13890
13891	/* ignore notifications sent after #OnSessionEnd() is called */
13892	if (!directControl)
13893	return S_OK;
13894	/*
13895	* instead acting like callback we ask IVirtualBox deliver corresponding event
13896	*/
13897
13898	mParent->i_onNatRedirectChanged(i_getId(), ulSlot, RT_BOOL(aNatRuleRemove), aRuleName, aProto, aHostIp,
13899	(uint16_t)aHostPort, aGuestIp, (uint16_t)aGuestPort);
13900	return S_OK;
13901	}
13902
13903	/**
13904	* @note Locks this object for reading.
13905	*/
13906	HRESULT SessionMachine::i_onAudioAdapterChange(IAudioAdapter *audioAdapter)
13907	{
13908	LogFlowThisFunc(("\n"));
13909
13910	AutoCaller autoCaller(this);
13911	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
13912
13913	ComPtr<IInternalSessionControl> directControl;
13914	{
13915	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13916	if (mData->mSession.mLockType == LockType_VM)
13917	directControl = mData->mSession.mDirectControl;
13918	}
13919
13920	/* ignore notifications sent after #OnSessionEnd() is called */
13921	if (!directControl)
13922	return S_OK;
13923
13924	return directControl->OnAudioAdapterChange(audioAdapter);
13925	}
13926
13927	/**
13928	* @note Locks this object for reading.
13929	*/
13930	HRESULT SessionMachine::i_onSerialPortChange(ISerialPort *serialPort)
13931	{
13932	LogFlowThisFunc(("\n"));
13933
13934	AutoCaller autoCaller(this);
13935	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
13936
13937	ComPtr<IInternalSessionControl> directControl;
13938	{
13939	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13940	if (mData->mSession.mLockType == LockType_VM)
13941	directControl = mData->mSession.mDirectControl;
13942	}
13943
13944	/* ignore notifications sent after #OnSessionEnd() is called */
13945	if (!directControl)
13946	return S_OK;
13947
13948	return directControl->OnSerialPortChange(serialPort);
13949	}
13950
13951	/**
13952	* @note Locks this object for reading.
13953	*/
13954	HRESULT SessionMachine::i_onParallelPortChange(IParallelPort *parallelPort)
13955	{
13956	LogFlowThisFunc(("\n"));
13957
13958	AutoCaller autoCaller(this);
13959	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
13960
13961	ComPtr<IInternalSessionControl> directControl;
13962	{
13963	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13964	if (mData->mSession.mLockType == LockType_VM)
13965	directControl = mData->mSession.mDirectControl;
13966	}
13967
13968	/* ignore notifications sent after #OnSessionEnd() is called */
13969	if (!directControl)
13970	return S_OK;
13971
13972	return directControl->OnParallelPortChange(parallelPort);
13973	}
13974
13975	/**
13976	* @note Locks this object for reading.
13977	*/
13978	HRESULT SessionMachine::i_onStorageControllerChange(const Guid &aMachineId, const Utf8Str &aControllerName)
13979	{
13980	LogFlowThisFunc(("\n"));
13981
13982	AutoCaller autoCaller(this);
13983	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
13984
13985	ComPtr<IInternalSessionControl> directControl;
13986	{
13987	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13988	if (mData->mSession.mLockType == LockType_VM)
13989	directControl = mData->mSession.mDirectControl;
13990	}
13991
13992	mParent->i_onStorageControllerChanged(aMachineId, aControllerName);
13993
13994	/* ignore notifications sent after #OnSessionEnd() is called */
13995	if (!directControl)
13996	return S_OK;
13997
13998	return directControl->OnStorageControllerChange(Bstr(aMachineId.toString()).raw(), Bstr(aControllerName).raw());
13999	}
14000
14001	/**
14002	* @note Locks this object for reading.
14003	*/
14004	HRESULT SessionMachine::i_onMediumChange(IMediumAttachment *aAttachment, BOOL aForce)
14005	{
14006	LogFlowThisFunc(("\n"));
14007
14008	AutoCaller autoCaller(this);
14009	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
14010
14011	ComPtr<IInternalSessionControl> directControl;
14012	{
14013	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14014	if (mData->mSession.mLockType == LockType_VM)
14015	directControl = mData->mSession.mDirectControl;
14016	}
14017
14018	mParent->i_onMediumChanged(aAttachment);
14019
14020	/* ignore notifications sent after #OnSessionEnd() is called */
14021	if (!directControl)
14022	return S_OK;
14023
14024	return directControl->OnMediumChange(aAttachment, aForce);
14025	}
14026
14027	HRESULT SessionMachine::i_onVMProcessPriorityChange(VMProcPriority_T aPriority)
14028	{
14029	LogFlowThisFunc(("\n"));
14030
14031	AutoCaller autoCaller(this);
14032	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
14033
14034	ComPtr<IInternalSessionControl> directControl;
14035	{
14036	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14037	if (mData->mSession.mLockType == LockType_VM)
14038	directControl = mData->mSession.mDirectControl;
14039	}
14040
14041	/* ignore notifications sent after #OnSessionEnd() is called */
14042	if (!directControl)
14043	return S_OK;
14044
14045	return directControl->OnVMProcessPriorityChange(aPriority);
14046	}
14047
14048	/**
14049	* @note Locks this object for reading.
14050	*/
14051	HRESULT SessionMachine::i_onCPUChange(ULONG aCPU, BOOL aRemove)
14052	{
14053	LogFlowThisFunc(("\n"));
14054
14055	AutoCaller autoCaller(this);
14056	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
14057
14058	ComPtr<IInternalSessionControl> directControl;
14059	{
14060	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14061	if (mData->mSession.mLockType == LockType_VM)
14062	directControl = mData->mSession.mDirectControl;
14063	}
14064
14065	/* ignore notifications sent after #OnSessionEnd() is called */
14066	if (!directControl)
14067	return S_OK;
14068
14069	return directControl->OnCPUChange(aCPU, aRemove);
14070	}
14071
14072	HRESULT SessionMachine::i_onCPUExecutionCapChange(ULONG aExecutionCap)
14073	{
14074	LogFlowThisFunc(("\n"));
14075
14076	AutoCaller autoCaller(this);
14077	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
14078
14079	ComPtr<IInternalSessionControl> directControl;
14080	{
14081	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14082	if (mData->mSession.mLockType == LockType_VM)
14083	directControl = mData->mSession.mDirectControl;
14084	}
14085
14086	/* ignore notifications sent after #OnSessionEnd() is called */
14087	if (!directControl)
14088	return S_OK;
14089
14090	return directControl->OnCPUExecutionCapChange(aExecutionCap);
14091	}
14092
14093	/**
14094	* @note Locks this object for reading.
14095	*/
14096	HRESULT SessionMachine::i_onVRDEServerChange(BOOL aRestart)
14097	{
14098	LogFlowThisFunc(("\n"));
14099
14100	AutoCaller autoCaller(this);
14101	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
14102
14103	ComPtr<IInternalSessionControl> directControl;
14104	{
14105	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14106	if (mData->mSession.mLockType == LockType_VM)
14107	directControl = mData->mSession.mDirectControl;
14108	}
14109
14110	/* ignore notifications sent after #OnSessionEnd() is called */
14111	if (!directControl)
14112	return S_OK;
14113
14114	return directControl->OnVRDEServerChange(aRestart);
14115	}
14116
14117	/**
14118	* @note Locks this object for reading.
14119	*/
14120	HRESULT SessionMachine::i_onRecordingChange(BOOL aEnable)
14121	{
14122	LogFlowThisFunc(("\n"));
14123
14124	AutoCaller autoCaller(this);
14125	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
14126
14127	ComPtr<IInternalSessionControl> directControl;
14128	{
14129	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14130	if (mData->mSession.mLockType == LockType_VM)
14131	directControl = mData->mSession.mDirectControl;
14132	}
14133
14134	/* ignore notifications sent after #OnSessionEnd() is called */
14135	if (!directControl)
14136	return S_OK;
14137
14138	return directControl->OnRecordingChange(aEnable);
14139	}
14140
14141	/**
14142	* @note Locks this object for reading.
14143	*/
14144	HRESULT SessionMachine::i_onUSBControllerChange()
14145	{
14146	LogFlowThisFunc(("\n"));
14147
14148	AutoCaller autoCaller(this);
14149	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
14150
14151	ComPtr<IInternalSessionControl> directControl;
14152	{
14153	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14154	if (mData->mSession.mLockType == LockType_VM)
14155	directControl = mData->mSession.mDirectControl;
14156	}
14157
14158	/* ignore notifications sent after #OnSessionEnd() is called */
14159	if (!directControl)
14160	return S_OK;
14161
14162	return directControl->OnUSBControllerChange();
14163	}
14164
14165	/**
14166	* @note Locks this object for reading.
14167	*/
14168	HRESULT SessionMachine::i_onSharedFolderChange()
14169	{
14170	LogFlowThisFunc(("\n"));
14171
14172	AutoCaller autoCaller(this);
14173	AssertComRCReturnRC(autoCaller.rc());
14174
14175	ComPtr<IInternalSessionControl> directControl;
14176	{
14177	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14178	if (mData->mSession.mLockType == LockType_VM)
14179	directControl = mData->mSession.mDirectControl;
14180	}
14181
14182	/* ignore notifications sent after #OnSessionEnd() is called */
14183	if (!directControl)
14184	return S_OK;
14185
14186	return directControl->OnSharedFolderChange(FALSE /* aGlobal */);
14187	}
14188
14189	/**
14190	* @note Locks this object for reading.
14191	*/
14192	HRESULT SessionMachine::i_onClipboardModeChange(ClipboardMode_T aClipboardMode)
14193	{
14194	LogFlowThisFunc(("\n"));
14195
14196	AutoCaller autoCaller(this);
14197	AssertComRCReturnRC(autoCaller.rc());
14198
14199	ComPtr<IInternalSessionControl> directControl;
14200	{
14201	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14202	if (mData->mSession.mLockType == LockType_VM)
14203	directControl = mData->mSession.mDirectControl;
14204	}
14205
14206	/* ignore notifications sent after #OnSessionEnd() is called */
14207	if (!directControl)
14208	return S_OK;
14209
14210	return directControl->OnClipboardModeChange(aClipboardMode);
14211	}
14212
14213	/**
14214	* @note Locks this object for reading.
14215	*/
14216	HRESULT SessionMachine::i_onClipboardFileTransferModeChange(BOOL aEnable)
14217	{
14218	LogFlowThisFunc(("\n"));
14219
14220	AutoCaller autoCaller(this);
14221	AssertComRCReturnRC(autoCaller.rc());
14222
14223	ComPtr<IInternalSessionControl> directControl;
14224	{
14225	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14226	if (mData->mSession.mLockType == LockType_VM)
14227	directControl = mData->mSession.mDirectControl;
14228	}
14229
14230	/* ignore notifications sent after #OnSessionEnd() is called */
14231	if (!directControl)
14232	return S_OK;
14233
14234	return directControl->OnClipboardFileTransferModeChange(aEnable);
14235	}
14236
14237	/**
14238	* @note Locks this object for reading.
14239	*/
14240	HRESULT SessionMachine::i_onDnDModeChange(DnDMode_T aDnDMode)
14241	{
14242	LogFlowThisFunc(("\n"));
14243
14244	AutoCaller autoCaller(this);
14245	AssertComRCReturnRC(autoCaller.rc());
14246
14247	ComPtr<IInternalSessionControl> directControl;
14248	{
14249	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14250	if (mData->mSession.mLockType == LockType_VM)
14251	directControl = mData->mSession.mDirectControl;
14252	}
14253
14254	/* ignore notifications sent after #OnSessionEnd() is called */
14255	if (!directControl)
14256	return S_OK;
14257
14258	return directControl->OnDnDModeChange(aDnDMode);
14259	}
14260
14261	/**
14262	* @note Locks this object for reading.
14263	*/
14264	HRESULT SessionMachine::i_onBandwidthGroupChange(IBandwidthGroup *aBandwidthGroup)
14265	{
14266	LogFlowThisFunc(("\n"));
14267
14268	AutoCaller autoCaller(this);
14269	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
14270
14271	ComPtr<IInternalSessionControl> directControl;
14272	{
14273	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14274	if (mData->mSession.mLockType == LockType_VM)
14275	directControl = mData->mSession.mDirectControl;
14276	}
14277
14278	/* ignore notifications sent after #OnSessionEnd() is called */
14279	if (!directControl)
14280	return S_OK;
14281
14282	return directControl->OnBandwidthGroupChange(aBandwidthGroup);
14283	}
14284
14285	/**
14286	* @note Locks this object for reading.
14287	*/
14288	HRESULT SessionMachine::i_onStorageDeviceChange(IMediumAttachment *aAttachment, BOOL aRemove, BOOL aSilent)
14289	{
14290	LogFlowThisFunc(("\n"));
14291
14292	AutoCaller autoCaller(this);
14293	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
14294
14295	ComPtr<IInternalSessionControl> directControl;
14296	{
14297	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14298	if (mData->mSession.mLockType == LockType_VM)
14299	directControl = mData->mSession.mDirectControl;
14300	}
14301
14302	/* ignore notifications sent after #OnSessionEnd() is called */
14303	if (!directControl)
14304	return S_OK;
14305
14306	return directControl->OnStorageDeviceChange(aAttachment, aRemove, aSilent);
14307	}
14308
14309	/**
14310	* Returns @c true if this machine's USB controller reports it has a matching
14311	* filter for the given USB device and @c false otherwise.
14312	*
14313	* @note locks this object for reading.
14314	*/
14315	bool SessionMachine::i_hasMatchingUSBFilter(const ComObjPtr<HostUSBDevice> &aDevice, ULONG *aMaskedIfs)
14316	{
14317	AutoCaller autoCaller(this);
14318	/* silently return if not ready -- this method may be called after the
14319	* direct machine session has been called */
14320	if (!autoCaller.isOk())
14321	return false;
14322
14323	#ifdef VBOX_WITH_USB
14324	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14325
14326	switch (mData->mMachineState)
14327	{
14328	case MachineState_Starting:
14329	case MachineState_Restoring:
14330	case MachineState_TeleportingIn:
14331	case MachineState_Paused:
14332	case MachineState_Running:
14333	/** @todo Live Migration: snapshoting & teleporting. Need to fend things of
14334	* elsewhere... */
14335	alock.release();
14336	return mUSBDeviceFilters->i_hasMatchingFilter(aDevice, aMaskedIfs);
14337	default: break;
14338	}
14339	#else
14340	NOREF(aDevice);
14341	NOREF(aMaskedIfs);
14342	#endif
14343	return false;
14344	}
14345
14346	/**
14347	* @note The calls shall hold no locks. Will temporarily lock this object for reading.
14348	*/
14349	HRESULT SessionMachine::i_onUSBDeviceAttach(IUSBDevice *aDevice,
14350	IVirtualBoxErrorInfo *aError,
14351	ULONG aMaskedIfs,
14352	const com::Utf8Str &aCaptureFilename)
14353	{
14354	LogFlowThisFunc(("\n"));
14355
14356	AutoCaller autoCaller(this);
14357
14358	/* This notification may happen after the machine object has been
14359	* uninitialized (the session was closed), so don't assert. */
14360	if (FAILED(autoCaller.rc())) return autoCaller.rc();
14361
14362	ComPtr<IInternalSessionControl> directControl;
14363	{
14364	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14365	if (mData->mSession.mLockType == LockType_VM)
14366	directControl = mData->mSession.mDirectControl;
14367	}
14368
14369	/* fail on notifications sent after #OnSessionEnd() is called, it is
14370	* expected by the caller */
14371	if (!directControl)
14372	return E_FAIL;
14373
14374	/* No locks should be held at this point. */
14375	AssertMsg(RTLockValidatorWriteLockGetCount(RTThreadSelf()) == 0, ("%d\n", RTLockValidatorWriteLockGetCount(RTThreadSelf())));
14376	AssertMsg(RTLockValidatorReadLockGetCount(RTThreadSelf()) == 0, ("%d\n", RTLockValidatorReadLockGetCount(RTThreadSelf())));
14377
14378	return directControl->OnUSBDeviceAttach(aDevice, aError, aMaskedIfs, Bstr(aCaptureFilename).raw());
14379	}
14380
14381	/**
14382	* @note The calls shall hold no locks. Will temporarily lock this object for reading.
14383	*/
14384	HRESULT SessionMachine::i_onUSBDeviceDetach(IN_BSTR aId,
14385	IVirtualBoxErrorInfo *aError)
14386	{
14387	LogFlowThisFunc(("\n"));
14388
14389	AutoCaller autoCaller(this);
14390
14391	/* This notification may happen after the machine object has been
14392	* uninitialized (the session was closed), so don't assert. */
14393	if (FAILED(autoCaller.rc())) return autoCaller.rc();
14394
14395	ComPtr<IInternalSessionControl> directControl;
14396	{
14397	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14398	if (mData->mSession.mLockType == LockType_VM)
14399	directControl = mData->mSession.mDirectControl;
14400	}
14401
14402	/* fail on notifications sent after #OnSessionEnd() is called, it is
14403	* expected by the caller */
14404	if (!directControl)
14405	return E_FAIL;
14406
14407	/* No locks should be held at this point. */
14408	AssertMsg(RTLockValidatorWriteLockGetCount(RTThreadSelf()) == 0, ("%d\n", RTLockValidatorWriteLockGetCount(RTThreadSelf())));
14409	AssertMsg(RTLockValidatorReadLockGetCount(RTThreadSelf()) == 0, ("%d\n", RTLockValidatorReadLockGetCount(RTThreadSelf())));
14410
14411	return directControl->OnUSBDeviceDetach(aId, aError);
14412	}
14413
14414	// protected methods
14415	/////////////////////////////////////////////////////////////////////////////
14416
14417	/**
14418	* Deletes the given file if it is no longer in use by either the current machine state
14419	* (if the machine is "saved") or any of the machine's snapshots.
14420	*
14421	* Note: This checks mSSData->strStateFilePath, which is shared by the Machine and SessionMachine
14422	* but is different for each SnapshotMachine. When calling this, the order of calling this
14423	* function on the one hand and changing that variable OR the snapshots tree on the other hand
14424	* is therefore critical. I know, it's all rather messy.
14425	*
14426	* @param strStateFile
14427	* @param pSnapshotToIgnore Passed to Snapshot::sharesSavedStateFile(); this snapshot is ignored in
14428	* the test for whether the saved state file is in use.
14429	*/
14430	void SessionMachine::i_releaseSavedStateFile(const Utf8Str &strStateFile,
14431	Snapshot *pSnapshotToIgnore)
14432	{
14433	// it is safe to delete this saved state file if it is not currently in use by the machine ...
14434	if ( (strStateFile.isNotEmpty())
14435	&& (strStateFile != mSSData->strStateFilePath) // session machine's saved state
14436	)
14437	// ... and it must also not be shared with other snapshots
14438	if ( !mData->mFirstSnapshot
14439	\|\| !mData->mFirstSnapshot->i_sharesSavedStateFile(strStateFile, pSnapshotToIgnore)
14440	// this checks the SnapshotMachine's state file paths
14441	)
14442	RTFileDelete(strStateFile.c_str());
14443	}
14444
14445	/**
14446	* Locks the attached media.
14447	*
14448	* All attached hard disks are locked for writing and DVD/floppy are locked for
14449	* reading. Parents of attached hard disks (if any) are locked for reading.
14450	*
14451	* This method also performs accessibility check of all media it locks: if some
14452	* media is inaccessible, the method will return a failure and a bunch of
14453	* extended error info objects per each inaccessible medium.
14454	*
14455	* Note that this method is atomic: if it returns a success, all media are
14456	* locked as described above; on failure no media is locked at all (all
14457	* succeeded individual locks will be undone).
14458	*
14459	* The caller is responsible for doing the necessary state sanity checks.
14460	*
14461	* The locks made by this method must be undone by calling #unlockMedia() when
14462	* no more needed.
14463	*/
14464	HRESULT SessionMachine::i_lockMedia()
14465	{
14466	AutoCaller autoCaller(this);
14467	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
14468
14469	AutoMultiWriteLock2 alock(this->lockHandle(),
14470	&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
14471
14472	/* bail out if trying to lock things with already set up locking */
14473	AssertReturn(mData->mSession.mLockedMedia.IsEmpty(), E_FAIL);
14474
14475	MultiResult mrc(S_OK);
14476
14477	/* Collect locking information for all medium objects attached to the VM. */
14478	for (MediumAttachmentList::const_iterator
14479	it = mMediumAttachments->begin();
14480	it != mMediumAttachments->end();
14481	++it)
14482	{
14483	MediumAttachment pAtt = it;
14484	DeviceType_T devType = pAtt->i_getType();
14485	Medium *pMedium = pAtt->i_getMedium();
14486
14487	MediumLockList *pMediumLockList(new MediumLockList());
14488	// There can be attachments without a medium (floppy/dvd), and thus
14489	// it's impossible to create a medium lock list. It still makes sense
14490	// to have the empty medium lock list in the map in case a medium is
14491	// attached later.
14492	if (pMedium != NULL)
14493	{
14494	MediumType_T mediumType = pMedium->i_getType();
14495	bool fIsReadOnlyLock = mediumType == MediumType_Readonly
14496	\|\| mediumType == MediumType_Shareable;
14497	bool fIsVitalImage = (devType == DeviceType_HardDisk);
14498
14499	alock.release();
14500	mrc = pMedium->i_createMediumLockList(fIsVitalImage /* fFailIfInaccessible */,
14501	!fIsReadOnlyLock ? pMedium : NULL /* pToLockWrite */,
14502	false /* fMediumLockWriteAll */,
14503	NULL,
14504	*pMediumLockList);
14505	alock.acquire();
14506	if (FAILED(mrc))
14507	{
14508	delete pMediumLockList;
14509	mData->mSession.mLockedMedia.Clear();
14510	break;
14511	}
14512	}
14513
14514	HRESULT rc = mData->mSession.mLockedMedia.Insert(pAtt, pMediumLockList);
14515	if (FAILED(rc))
14516	{
14517	mData->mSession.mLockedMedia.Clear();
14518	mrc = setError(rc,
14519	tr("Collecting locking information for all attached media failed"));
14520	break;
14521	}
14522	}
14523
14524	if (SUCCEEDED(mrc))
14525	{
14526	/* Now lock all media. If this fails, nothing is locked. */
14527	alock.release();
14528	HRESULT rc = mData->mSession.mLockedMedia.Lock();
14529	alock.acquire();
14530	if (FAILED(rc))
14531	{
14532	mrc = setError(rc,
14533	tr("Locking of attached media failed. A possible reason is that one of the media is attached to a running VM"));
14534	}
14535	}
14536
14537	return mrc;
14538	}
14539
14540	/**
14541	* Undoes the locks made by by #lockMedia().
14542	*/
14543	HRESULT SessionMachine::i_unlockMedia()
14544	{
14545	AutoCaller autoCaller(this);
14546	AssertComRCReturn(autoCaller.rc(),autoCaller.rc());
14547
14548	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
14549
14550	/* we may be holding important error info on the current thread;
14551	* preserve it */
14552	ErrorInfoKeeper eik;
14553
14554	HRESULT rc = mData->mSession.mLockedMedia.Clear();
14555	AssertComRC(rc);
14556	return rc;
14557	}
14558
14559	/**
14560	* Helper to change the machine state (reimplementation).
14561	*
14562	* @note Locks this object for writing.
14563	* @note This method must not call i_saveSettings or SaveSettings, otherwise
14564	* it can cause crashes in random places due to unexpectedly committing
14565	* the current settings. The caller is responsible for that. The call
14566	* to saveStateSettings is fine, because this method does not commit.
14567	*/
14568	HRESULT SessionMachine::i_setMachineState(MachineState_T aMachineState)
14569	{
14570	LogFlowThisFuncEnter();
14571	LogFlowThisFunc(("aMachineState=%s\n", Global::stringifyMachineState(aMachineState) ));
14572
14573	AutoCaller autoCaller(this);
14574	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
14575
14576	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
14577
14578	MachineState_T oldMachineState = mData->mMachineState;
14579
14580	AssertMsgReturn(oldMachineState != aMachineState,
14581	("oldMachineState=%s, aMachineState=%s\n",
14582	Global::stringifyMachineState(oldMachineState), Global::stringifyMachineState(aMachineState)),
14583	E_FAIL);
14584
14585	HRESULT rc = S_OK;
14586
14587	int stsFlags = 0;
14588	bool deleteSavedState = false;
14589
14590	/* detect some state transitions */
14591
14592	if ( ( oldMachineState == MachineState_Saved
14593	&& aMachineState == MachineState_Restoring)
14594	\|\| ( ( oldMachineState == MachineState_PoweredOff
14595	\|\| oldMachineState == MachineState_Teleported
14596	\|\| oldMachineState == MachineState_Aborted
14597	)
14598	&& ( aMachineState == MachineState_TeleportingIn
14599	\|\| aMachineState == MachineState_Starting
14600	)
14601	)
14602	)
14603	{
14604	/* The EMT thread is about to start */
14605
14606	/* Nothing to do here for now... */
14607
14608	/// @todo NEWMEDIA don't let mDVDDrive and other children
14609	/// change anything when in the Starting/Restoring state
14610	}
14611	else if ( ( oldMachineState == MachineState_Running
14612	\|\| oldMachineState == MachineState_Paused
14613	\|\| oldMachineState == MachineState_Teleporting
14614	\|\| oldMachineState == MachineState_OnlineSnapshotting
14615	\|\| oldMachineState == MachineState_LiveSnapshotting
14616	\|\| oldMachineState == MachineState_Stuck
14617	\|\| oldMachineState == MachineState_Starting
14618	\|\| oldMachineState == MachineState_Stopping
14619	\|\| oldMachineState == MachineState_Saving
14620	\|\| oldMachineState == MachineState_Restoring
14621	\|\| oldMachineState == MachineState_TeleportingPausedVM
14622	\|\| oldMachineState == MachineState_TeleportingIn
14623	)
14624	&& ( aMachineState == MachineState_PoweredOff
14625	\|\| aMachineState == MachineState_Saved
14626	\|\| aMachineState == MachineState_Teleported
14627	\|\| aMachineState == MachineState_Aborted
14628	)
14629	)
14630	{
14631	/* The EMT thread has just stopped, unlock attached media. Note that as
14632	* opposed to locking that is done from Console, we do unlocking here
14633	* because the VM process may have aborted before having a chance to
14634	* properly unlock all media it locked. */
14635
14636	unlockMedia();
14637	}
14638
14639	if (oldMachineState == MachineState_Restoring)
14640	{
14641	if (aMachineState != MachineState_Saved)
14642	{
14643	/*
14644	* delete the saved state file once the machine has finished
14645	* restoring from it (note that Console sets the state from
14646	* Restoring to Saved if the VM couldn't restore successfully,
14647	* to give the user an ability to fix an error and retry --
14648	* we keep the saved state file in this case)
14649	*/
14650	deleteSavedState = true;
14651	}
14652	}
14653	else if ( oldMachineState == MachineState_Saved
14654	&& ( aMachineState == MachineState_PoweredOff
14655	\|\| aMachineState == MachineState_Aborted
14656	\|\| aMachineState == MachineState_Teleported
14657	)
14658	)
14659	{
14660	/*
14661	* delete the saved state after SessionMachine::ForgetSavedState() is called
14662	* or if the VM process (owning a direct VM session) crashed while the
14663	* VM was Saved
14664	*/
14665
14666	/// @todo (dmik)
14667	// Not sure that deleting the saved state file just because of the
14668	// client death before it attempted to restore the VM is a good
14669	// thing. But when it crashes we need to go to the Aborted state
14670	// which cannot have the saved state file associated... The only
14671	// way to fix this is to make the Aborted condition not a VM state
14672	// but a bool flag: i.e., when a crash occurs, set it to true and
14673	// change the state to PoweredOff or Saved depending on the
14674	// saved state presence.
14675
14676	deleteSavedState = true;
14677	mData->mCurrentStateModified = TRUE;
14678	stsFlags \|= SaveSTS_CurStateModified;
14679	}
14680
14681	if ( aMachineState == MachineState_Starting
14682	\|\| aMachineState == MachineState_Restoring
14683	\|\| aMachineState == MachineState_TeleportingIn
14684	)
14685	{
14686	/* set the current state modified flag to indicate that the current
14687	* state is no more identical to the state in the
14688	* current snapshot */
14689	if (!mData->mCurrentSnapshot.isNull())
14690	{
14691	mData->mCurrentStateModified = TRUE;
14692	stsFlags \|= SaveSTS_CurStateModified;
14693	}
14694	}
14695
14696	if (deleteSavedState)
14697	{
14698	if (mRemoveSavedState)
14699	{
14700	Assert(!mSSData->strStateFilePath.isEmpty());
14701
14702	// it is safe to delete the saved state file if ...
14703	if ( !mData->mFirstSnapshot // ... we have no snapshots or
14704	\|\| !mData->mFirstSnapshot->i_sharesSavedStateFile(mSSData->strStateFilePath, NULL /* pSnapshotToIgnore */)
14705	// ... none of the snapshots share the saved state file
14706	)
14707	RTFileDelete(mSSData->strStateFilePath.c_str());
14708	}
14709
14710	mSSData->strStateFilePath.setNull();
14711	stsFlags \|= SaveSTS_StateFilePath;
14712	}
14713
14714	/* redirect to the underlying peer machine */
14715	mPeer->i_setMachineState(aMachineState);
14716
14717	if ( oldMachineState != MachineState_RestoringSnapshot
14718	&& ( aMachineState == MachineState_PoweredOff
14719	\|\| aMachineState == MachineState_Teleported
14720	\|\| aMachineState == MachineState_Aborted
14721	\|\| aMachineState == MachineState_Saved))
14722	{
14723	/* the machine has stopped execution
14724	* (or the saved state file was adopted) */
14725	stsFlags \|= SaveSTS_StateTimeStamp;
14726	}
14727
14728	if ( ( oldMachineState == MachineState_PoweredOff
14729	\|\| oldMachineState == MachineState_Aborted
14730	\|\| oldMachineState == MachineState_Teleported
14731	)
14732	&& aMachineState == MachineState_Saved)
14733	{
14734	/* the saved state file was adopted */
14735	Assert(!mSSData->strStateFilePath.isEmpty());
14736	stsFlags \|= SaveSTS_StateFilePath;
14737	}
14738
14739	#ifdef VBOX_WITH_GUEST_PROPS
14740	if ( aMachineState == MachineState_PoweredOff
14741	\|\| aMachineState == MachineState_Aborted
14742	\|\| aMachineState == MachineState_Teleported)
14743	{
14744	/* Make sure any transient guest properties get removed from the
14745	* property store on shutdown. */
14746	BOOL fNeedsSaving = mData->mGuestPropertiesModified;
14747
14748	/* remove it from the settings representation */
14749	settings::GuestPropertiesList &llGuestProperties = mData->pMachineConfigFile->hardwareMachine.llGuestProperties;
14750	for (settings::GuestPropertiesList::iterator
14751	it = llGuestProperties.begin();
14752	it != llGuestProperties.end();
14753	/nothing/)
14754	{
14755	const settings::GuestProperty &prop = *it;
14756	if ( prop.strFlags.contains("TRANSRESET", Utf8Str::CaseInsensitive)
14757	\|\| prop.strFlags.contains("TRANSIENT", Utf8Str::CaseInsensitive))
14758	{
14759	it = llGuestProperties.erase(it);
14760	fNeedsSaving = true;
14761	}
14762	else
14763	{
14764	++it;
14765	}
14766	}
14767
14768	/* Additionally remove it from the HWData representation. Required to
14769	* keep everything in sync, as this is what the API keeps using. */
14770	HWData::GuestPropertyMap &llHWGuestProperties = mHWData->mGuestProperties;
14771	for (HWData::GuestPropertyMap::iterator
14772	it = llHWGuestProperties.begin();
14773	it != llHWGuestProperties.end();
14774	/nothing/)
14775	{
14776	uint32_t fFlags = it->second.mFlags;
14777	if (fFlags & (GUEST_PROP_F_TRANSIENT \| GUEST_PROP_F_TRANSRESET))
14778	{
14779	/* iterator where we need to continue after the erase call
14780	* (C++03 is a fact still, and it doesn't return the iterator
14781	* which would allow continuing) */
14782	HWData::GuestPropertyMap::iterator it2 = it;
14783	++it2;
14784	llHWGuestProperties.erase(it);
14785	it = it2;
14786	fNeedsSaving = true;
14787	}
14788	else
14789	{
14790	++it;
14791	}
14792	}
14793
14794	if (fNeedsSaving)
14795	{
14796	mData->mCurrentStateModified = TRUE;
14797	stsFlags \|= SaveSTS_CurStateModified;
14798	}
14799	}
14800	#endif /* VBOX_WITH_GUEST_PROPS */
14801
14802	rc = i_saveStateSettings(stsFlags);
14803
14804	if ( ( oldMachineState != MachineState_PoweredOff
14805	&& oldMachineState != MachineState_Aborted
14806	&& oldMachineState != MachineState_Teleported
14807	)
14808	&& ( aMachineState == MachineState_PoweredOff
14809	\|\| aMachineState == MachineState_Aborted
14810	\|\| aMachineState == MachineState_Teleported
14811	)
14812	)
14813	{
14814	/* we've been shut down for any reason */
14815	/* no special action so far */
14816	}
14817
14818	LogFlowThisFunc(("rc=%Rhrc [%s]\n", rc, Global::stringifyMachineState(mData->mMachineState) ));
14819	LogFlowThisFuncLeave();
14820	return rc;
14821	}
14822
14823	/**
14824	* Sends the current machine state value to the VM process.
14825	*
14826	* @note Locks this object for reading, then calls a client process.
14827	*/
14828	HRESULT SessionMachine::i_updateMachineStateOnClient()
14829	{
14830	AutoCaller autoCaller(this);
14831	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
14832
14833	ComPtr<IInternalSessionControl> directControl;
14834	{
14835	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14836	AssertReturn(!!mData, E_FAIL);
14837	if (mData->mSession.mLockType == LockType_VM)
14838	directControl = mData->mSession.mDirectControl;
14839
14840	/* directControl may be already set to NULL here in #OnSessionEnd()
14841	* called too early by the direct session process while there is still
14842	* some operation (like deleting the snapshot) in progress. The client
14843	* process in this case is waiting inside Session::close() for the
14844	* "end session" process object to complete, while #uninit() called by
14845	* #i_checkForDeath() on the Watcher thread is waiting for the pending
14846	* operation to complete. For now, we accept this inconsistent behavior
14847	* and simply do nothing here. */
14848
14849	if (mData->mSession.mState == SessionState_Unlocking)
14850	return S_OK;
14851	}
14852
14853	/* ignore notifications sent after #OnSessionEnd() is called */
14854	if (!directControl)
14855	return S_OK;
14856
14857	return directControl->UpdateMachineState(mData->mMachineState);
14858	}
14859
14860
14861	/static/
14862	HRESULT Machine::i_setErrorStatic(HRESULT aResultCode, const char *pcszMsg, ...)
14863	{
14864	va_list args;
14865	va_start(args, pcszMsg);
14866	HRESULT rc = setErrorInternal(aResultCode,
14867	getStaticClassIID(),
14868	getStaticComponentName(),
14869	Utf8Str(pcszMsg, args),
14870	false /* aWarning */,
14871	true /* aLogIt */);
14872	va_end(args);
14873	return rc;
14874	}
14875
14876
14877	HRESULT Machine::updateState(MachineState_T aState)
14878	{
14879	NOREF(aState);
14880	ReturnComNotImplemented();
14881	}
14882
14883	HRESULT Machine::beginPowerUp(const ComPtr<IProgress> &aProgress)
14884	{
14885	NOREF(aProgress);
14886	ReturnComNotImplemented();
14887	}
14888
14889	HRESULT Machine::endPowerUp(LONG aResult)
14890	{
14891	NOREF(aResult);
14892	ReturnComNotImplemented();
14893	}
14894
14895	HRESULT Machine::beginPoweringDown(ComPtr<IProgress> &aProgress)
14896	{
14897	NOREF(aProgress);
14898	ReturnComNotImplemented();
14899	}
14900
14901	HRESULT Machine::endPoweringDown(LONG aResult,
14902	const com::Utf8Str &aErrMsg)
14903	{
14904	NOREF(aResult);
14905	NOREF(aErrMsg);
14906	ReturnComNotImplemented();
14907	}
14908
14909	HRESULT Machine::runUSBDeviceFilters(const ComPtr<IUSBDevice> &aDevice,
14910	BOOL *aMatched,
14911	ULONG *aMaskedInterfaces)
14912	{
14913	NOREF(aDevice);
14914	NOREF(aMatched);
14915	NOREF(aMaskedInterfaces);
14916	ReturnComNotImplemented();
14917
14918	}
14919
14920	HRESULT Machine::captureUSBDevice(const com::Guid &aId, const com::Utf8Str &aCaptureFilename)
14921	{
14922	NOREF(aId); NOREF(aCaptureFilename);
14923	ReturnComNotImplemented();
14924	}
14925
14926	HRESULT Machine::detachUSBDevice(const com::Guid &aId,
14927	BOOL aDone)
14928	{
14929	NOREF(aId);
14930	NOREF(aDone);
14931	ReturnComNotImplemented();
14932	}
14933
14934	HRESULT Machine::autoCaptureUSBDevices()
14935	{
14936	ReturnComNotImplemented();
14937	}
14938
14939	HRESULT Machine::detachAllUSBDevices(BOOL aDone)
14940	{
14941	NOREF(aDone);
14942	ReturnComNotImplemented();
14943	}
14944
14945	HRESULT Machine::onSessionEnd(const ComPtr<ISession> &aSession,
14946	ComPtr<IProgress> &aProgress)
14947	{
14948	NOREF(aSession);
14949	NOREF(aProgress);
14950	ReturnComNotImplemented();
14951	}
14952
14953	HRESULT Machine::finishOnlineMergeMedium()
14954	{
14955	ReturnComNotImplemented();
14956	}
14957
14958	HRESULT Machine::clipboardAreaRegister(const std::vector<com::Utf8Str> &aParms, ULONG *aID)
14959	{
14960	RT_NOREF(aParms, aID);
14961	ReturnComNotImplemented();
14962	}
14963
14964	HRESULT Machine::clipboardAreaUnregister(ULONG aID)
14965	{
14966	RT_NOREF(aID);
14967	ReturnComNotImplemented();
14968	}
14969
14970	HRESULT Machine::clipboardAreaAttach(ULONG aID)
14971	{
14972	RT_NOREF(aID);
14973	ReturnComNotImplemented();
14974	}
14975	HRESULT Machine::clipboardAreaDetach(ULONG aID)
14976	{
14977	RT_NOREF(aID);
14978	ReturnComNotImplemented();
14979	}
14980
14981	HRESULT Machine::clipboardAreaGetMostRecent(ULONG *aID)
14982	{
14983	RT_NOREF(aID);
14984	ReturnComNotImplemented();
14985	}
14986
14987	HRESULT Machine::clipboardAreaGetRefCount(ULONG aID, ULONG *aRefCount)
14988	{
14989	RT_NOREF(aID, aRefCount);
14990	ReturnComNotImplemented();
14991	}
14992
14993	HRESULT Machine::pullGuestProperties(std::vector<com::Utf8Str> &aNames,
14994	std::vector<com::Utf8Str> &aValues,
14995	std::vector<LONG64> &aTimestamps,
14996	std::vector<com::Utf8Str> &aFlags)
14997	{
14998	NOREF(aNames);
14999	NOREF(aValues);
15000	NOREF(aTimestamps);
15001	NOREF(aFlags);
15002	ReturnComNotImplemented();
15003	}
15004
15005	HRESULT Machine::pushGuestProperty(const com::Utf8Str &aName,
15006	const com::Utf8Str &aValue,
15007	LONG64 aTimestamp,
15008	const com::Utf8Str &aFlags)
15009	{
15010	NOREF(aName);
15011	NOREF(aValue);
15012	NOREF(aTimestamp);
15013	NOREF(aFlags);
15014	ReturnComNotImplemented();
15015	}
15016
15017	HRESULT Machine::lockMedia()
15018	{
15019	ReturnComNotImplemented();
15020	}
15021
15022	HRESULT Machine::unlockMedia()
15023	{
15024	ReturnComNotImplemented();
15025	}
15026
15027	HRESULT Machine::ejectMedium(const ComPtr<IMediumAttachment> &aAttachment,
15028	ComPtr<IMediumAttachment> &aNewAttachment)
15029	{
15030	NOREF(aAttachment);
15031	NOREF(aNewAttachment);
15032	ReturnComNotImplemented();
15033	}
15034
15035	HRESULT Machine::reportVmStatistics(ULONG aValidStats,
15036	ULONG aCpuUser,
15037	ULONG aCpuKernel,
15038	ULONG aCpuIdle,
15039	ULONG aMemTotal,
15040	ULONG aMemFree,
15041	ULONG aMemBalloon,
15042	ULONG aMemShared,
15043	ULONG aMemCache,
15044	ULONG aPagedTotal,
15045	ULONG aMemAllocTotal,
15046	ULONG aMemFreeTotal,
15047	ULONG aMemBalloonTotal,
15048	ULONG aMemSharedTotal,
15049	ULONG aVmNetRx,
15050	ULONG aVmNetTx)
15051	{
15052	NOREF(aValidStats);
15053	NOREF(aCpuUser);
15054	NOREF(aCpuKernel);
15055	NOREF(aCpuIdle);
15056	NOREF(aMemTotal);
15057	NOREF(aMemFree);
15058	NOREF(aMemBalloon);
15059	NOREF(aMemShared);
15060	NOREF(aMemCache);
15061	NOREF(aPagedTotal);
15062	NOREF(aMemAllocTotal);
15063	NOREF(aMemFreeTotal);
15064	NOREF(aMemBalloonTotal);
15065	NOREF(aMemSharedTotal);
15066	NOREF(aVmNetRx);
15067	NOREF(aVmNetTx);
15068	ReturnComNotImplemented();
15069	}
15070
15071	HRESULT Machine::authenticateExternal(const std::vector<com::Utf8Str> &aAuthParams,
15072	com::Utf8Str &aResult)
15073	{
15074	NOREF(aAuthParams);
15075	NOREF(aResult);
15076	ReturnComNotImplemented();
15077	}
15078
15079	com::Utf8Str Machine::i_controllerNameFromBusType(StorageBus_T aBusType)
15080	{
15081	com::Utf8Str strControllerName = "Unknown";
15082	switch (aBusType)
15083	{
15084	case StorageBus_IDE:
15085	{
15086	strControllerName = "IDE";
15087	break;
15088	}
15089	case StorageBus_SATA:
15090	{
15091	strControllerName = "SATA";
15092	break;
15093	}
15094	case StorageBus_SCSI:
15095	{
15096	strControllerName = "SCSI";
15097	break;
15098	}
15099	case StorageBus_Floppy:
15100	{
15101	strControllerName = "Floppy";
15102	break;
15103	}
15104	case StorageBus_SAS:
15105	{
15106	strControllerName = "SAS";
15107	break;
15108	}
15109	case StorageBus_USB:
15110	{
15111	strControllerName = "USB";
15112	break;
15113	}
15114	default:
15115	break;
15116	}
15117	return strControllerName;
15118	}
15119
15120	HRESULT Machine::applyDefaults(const com::Utf8Str &aFlags)
15121	{
15122	/* it's assumed the machine already registered. If not, it's a problem of the caller */
15123
15124	AutoCaller autoCaller(this);
15125	AssertComRCReturn(autoCaller.rc(),autoCaller.rc());
15126
15127	HRESULT rc = S_OK;
15128
15129	/* get usb device filters from host, before any writes occurred to avoid deadlock */
15130	ComPtr<IUSBDeviceFilters> usbDeviceFilters;
15131	rc = getUSBDeviceFilters(usbDeviceFilters);
15132	if (FAILED(rc)) return rc;
15133
15134	NOREF(aFlags);
15135	com::Utf8Str osTypeId;
15136	ComObjPtr<GuestOSType> osType = NULL;
15137
15138	/* Get the guest os type as a string from the VB. */
15139	rc = getOSTypeId(osTypeId);
15140	if (FAILED(rc)) return rc;
15141
15142	/* Get the os type obj that coresponds, can be used to get
15143	* the defaults for this guest OS. */
15144	rc = mParent->i_findGuestOSType(Bstr(osTypeId), osType);
15145	if (FAILED(rc)) return rc;
15146
15147	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
15148
15149	/* Let the OS type select 64-bit ness. */
15150	mHWData->mLongMode = osType->i_is64Bit()
15151	? settings::Hardware::LongMode_Enabled : settings::Hardware::LongMode_Disabled;
15152
15153	/* Let the OS type enable the X2APIC */
15154	mHWData->mX2APIC = osType->i_recommendedX2APIC();
15155
15156	/* This one covers IOAPICEnabled. */
15157	mBIOSSettings->i_applyDefaults(osType);
15158
15159	/* Initialize default record settings. */
15160	mRecordingSettings->i_applyDefaults();
15161
15162	/* Initialize default BIOS settings here */
15163	/* Hardware virtualization must be ON by default */
15164	mHWData->mAPIC = true;
15165	mHWData->mHWVirtExEnabled = true;
15166
15167	rc = osType->COMGETTER(RecommendedRAM)(&mHWData->mMemorySize);
15168	if (FAILED(rc)) return rc;
15169
15170	/* Graphics stuff. */
15171	GraphicsControllerType_T graphicsController;
15172	rc = osType->COMGETTER(RecommendedGraphicsController)(&graphicsController);
15173	if (FAILED(rc)) return rc;
15174
15175	rc = mGraphicsAdapter->COMSETTER(GraphicsControllerType)(graphicsController);
15176	if (FAILED(rc)) return rc;
15177
15178	ULONG vramSize;
15179	rc = osType->COMGETTER(RecommendedVRAM)(&vramSize);
15180	if (FAILED(rc)) return rc;
15181
15182	rc = mGraphicsAdapter->COMSETTER(VRAMSize)(vramSize);
15183	if (FAILED(rc)) return rc;
15184
15185	BOOL fAccelerate2DVideoEnabled;
15186	rc = osType->COMGETTER(Recommended2DVideoAcceleration)(&fAccelerate2DVideoEnabled);
15187	if (FAILED(rc)) return rc;
15188
15189	rc = mGraphicsAdapter->COMSETTER(Accelerate2DVideoEnabled)(fAccelerate2DVideoEnabled);
15190	if (FAILED(rc)) return rc;
15191
15192	BOOL fAccelerate3DEnabled;
15193	rc = osType->COMGETTER(Recommended3DAcceleration)(&fAccelerate3DEnabled);
15194	if (FAILED(rc)) return rc;
15195
15196	rc = mGraphicsAdapter->COMSETTER(Accelerate3DEnabled)(fAccelerate3DEnabled);
15197	if (FAILED(rc)) return rc;
15198
15199	rc = osType->COMGETTER(RecommendedFirmware)(&mHWData->mFirmwareType);
15200	if (FAILED(rc)) return rc;
15201
15202	rc = osType->COMGETTER(RecommendedPAE)(&mHWData->mPAEEnabled);
15203	if (FAILED(rc)) return rc;
15204
15205	rc = osType->COMGETTER(RecommendedHPET)(&mHWData->mHPETEnabled);
15206	if (FAILED(rc)) return rc;
15207
15208	BOOL mRTCUseUTC;
15209	rc = osType->COMGETTER(RecommendedRTCUseUTC)(&mRTCUseUTC);
15210	if (FAILED(rc)) return rc;
15211
15212	setRTCUseUTC(mRTCUseUTC);
15213	if (FAILED(rc)) return rc;
15214
15215	/* the setter does more than just the assignment, so use it */
15216	ChipsetType_T enmChipsetType;
15217	rc = osType->COMGETTER(RecommendedChipset)(&enmChipsetType);
15218	if (FAILED(rc)) return rc;
15219
15220	rc = COMSETTER(ChipsetType)(enmChipsetType);
15221	if (FAILED(rc)) return rc;
15222
15223	rc = osType->COMGETTER(RecommendedTFReset)(&mHWData->mTripleFaultReset);
15224	if (FAILED(rc)) return rc;
15225
15226	/* Apply network adapters defaults */
15227	for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
15228	mNetworkAdapters[slot]->i_applyDefaults(osType);
15229
15230	/* Apply serial port defaults */
15231	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
15232	mSerialPorts[slot]->i_applyDefaults(osType);
15233
15234	/* Apply parallel port defaults - not OS dependent*/
15235	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
15236	mParallelPorts[slot]->i_applyDefaults();
15237
15238	/* Audio stuff. */
15239	AudioControllerType_T audioController;
15240	rc = osType->COMGETTER(RecommendedAudioController)(&audioController);
15241	if (FAILED(rc)) return rc;
15242
15243	rc = mAudioAdapter->COMSETTER(AudioController)(audioController);
15244	if (FAILED(rc)) return rc;
15245
15246	AudioCodecType_T audioCodec;
15247	rc = osType->COMGETTER(RecommendedAudioCodec)(&audioCodec);
15248	if (FAILED(rc)) return rc;
15249
15250	rc = mAudioAdapter->COMSETTER(AudioCodec)(audioCodec);
15251	if (FAILED(rc)) return rc;
15252
15253	rc = mAudioAdapter->COMSETTER(Enabled)(true);
15254	if (FAILED(rc)) return rc;
15255
15256	rc = mAudioAdapter->COMSETTER(EnabledOut)(true);
15257	if (FAILED(rc)) return rc;
15258
15259	/* Storage Controllers */
15260	StorageControllerType_T hdStorageControllerType;
15261	StorageBus_T hdStorageBusType;
15262	StorageControllerType_T dvdStorageControllerType;
15263	StorageBus_T dvdStorageBusType;
15264	BOOL recommendedFloppy;
15265	ComPtr<IStorageController> floppyController;
15266	ComPtr<IStorageController> hdController;
15267	ComPtr<IStorageController> dvdController;
15268	Utf8Str strFloppyName, strDVDName, strHDName;
15269
15270	/* GUI auto generates controller names using bus type. Do the same*/
15271	strFloppyName = i_controllerNameFromBusType(StorageBus_Floppy);
15272
15273	/* Floppy recommended? add one. */
15274	rc = osType->COMGETTER(RecommendedFloppy(&recommendedFloppy));
15275	if (FAILED(rc)) return rc;
15276	if (recommendedFloppy)
15277	{
15278	rc = addStorageController(strFloppyName,
15279	StorageBus_Floppy,
15280	floppyController);
15281	if (FAILED(rc)) return rc;
15282	}
15283
15284	/* Setup one DVD storage controller. */
15285	rc = osType->COMGETTER(RecommendedDVDStorageController)(&dvdStorageControllerType);
15286	if (FAILED(rc)) return rc;
15287
15288	rc = osType->COMGETTER(RecommendedDVDStorageBus)(&dvdStorageBusType);
15289	if (FAILED(rc)) return rc;
15290
15291	strDVDName = i_controllerNameFromBusType(dvdStorageBusType);
15292
15293	rc = addStorageController(strDVDName,
15294	dvdStorageBusType,
15295	dvdController);
15296	if (FAILED(rc)) return rc;
15297
15298	rc = dvdController->COMSETTER(ControllerType)(dvdStorageControllerType);
15299	if (FAILED(rc)) return rc;
15300
15301	/* Setup one HDD storage controller. */
15302	rc = osType->COMGETTER(RecommendedHDStorageController)(&hdStorageControllerType);
15303	if (FAILED(rc)) return rc;
15304
15305	rc = osType->COMGETTER(RecommendedHDStorageBus)(&hdStorageBusType);
15306	if (FAILED(rc)) return rc;
15307
15308	strHDName = i_controllerNameFromBusType(hdStorageBusType);
15309
15310	if (hdStorageBusType != dvdStorageBusType && hdStorageControllerType != dvdStorageControllerType)
15311	{
15312	rc = addStorageController(strHDName,
15313	hdStorageBusType,
15314	hdController);
15315	if (FAILED(rc)) return rc;
15316
15317	rc = hdController->COMSETTER(ControllerType)(hdStorageControllerType);
15318	if (FAILED(rc)) return rc;
15319	}
15320	else
15321	{
15322	/* The HD controller is the same as DVD: */
15323	hdController = dvdController;
15324	}
15325
15326	/* Limit the AHCI port count if it's used because windows has trouble with
15327	* too many ports and other guest (OS X in particular) may take extra long
15328	* boot: */
15329
15330	// pParent = static_cast<Medium*>(aP)
15331	IStorageController *temp = hdController;
15332	ComObjPtr<StorageController> storageController;
15333	storageController = static_cast<StorageController *>(temp);
15334
15335	// tempHDController = aHDController;
15336	if (hdStorageControllerType == StorageControllerType_IntelAhci)
15337	storageController->COMSETTER(PortCount)(1 + (dvdStorageControllerType == StorageControllerType_IntelAhci));
15338	else if (dvdStorageControllerType == StorageControllerType_IntelAhci)
15339	storageController->COMSETTER(PortCount)(1);
15340
15341	/* USB stuff */
15342
15343	bool ohciEnabled = false;
15344
15345	ComPtr<IUSBController> usbController;
15346	BOOL recommendedUSB3;
15347	BOOL recommendedUSB;
15348	BOOL usbProxyAvailable;
15349
15350	getUSBProxyAvailable(&usbProxyAvailable);
15351	if (FAILED(rc)) return rc;
15352
15353	rc = osType->COMGETTER(RecommendedUSB3)(&recommendedUSB3);
15354	if (FAILED(rc)) return rc;
15355	rc = osType->COMGETTER(RecommendedUSB)(&recommendedUSB);
15356	if (FAILED(rc)) return rc;
15357
15358	if (!usbDeviceFilters.isNull() && recommendedUSB3 && usbProxyAvailable)
15359	{
15360	#ifdef VBOX_WITH_EXTPACK
15361	/* USB 3.0 is only available if the proper ExtPack is installed. */
15362	ExtPackManager *aManager = mParent->i_getExtPackManager();
15363	if (aManager->i_isExtPackUsable(ORACLE_PUEL_EXTPACK_NAME))
15364	{
15365	rc = addUSBController("XHCI", USBControllerType_XHCI, usbController);
15366	if (FAILED(rc)) return rc;
15367
15368	/* xHci includes OHCI */
15369	ohciEnabled = true;
15370	}
15371	#endif
15372	}
15373	if ( !ohciEnabled
15374	&& !usbDeviceFilters.isNull() && recommendedUSB && usbProxyAvailable)
15375	{
15376	rc = addUSBController("OHCI", USBControllerType_OHCI, usbController);
15377	if (FAILED(rc)) return rc;
15378	ohciEnabled = true;
15379
15380	#ifdef VBOX_WITH_EXTPACK
15381	/* USB 2.0 is only available if the proper ExtPack is installed.
15382	* Note. Configuring EHCI here and providing messages about
15383	* the missing extpack isn't exactly clean, but it is a
15384	* necessary evil to patch over legacy compatability issues
15385	* introduced by the new distribution model. */
15386	ExtPackManager *manager = mParent->i_getExtPackManager();
15387	if (manager->i_isExtPackUsable(ORACLE_PUEL_EXTPACK_NAME))
15388	{
15389	rc = addUSBController("EHCI", USBControllerType_EHCI, usbController);
15390	if (FAILED(rc)) return rc;
15391	}
15392	#endif
15393	}
15394
15395	/* Set recommended human interface device types: */
15396	BOOL recommendedUSBHID;
15397	rc = osType->COMGETTER(RecommendedUSBHID)(&recommendedUSBHID);
15398	if (FAILED(rc)) return rc;
15399
15400	if (recommendedUSBHID)
15401	{
15402	mHWData->mKeyboardHIDType = KeyboardHIDType_USBKeyboard;
15403	mHWData->mPointingHIDType = PointingHIDType_USBMouse;
15404	if (!ohciEnabled && !usbDeviceFilters.isNull())
15405	{
15406	rc = addUSBController("OHCI", USBControllerType_OHCI, usbController);
15407	if (FAILED(rc)) return rc;
15408	}
15409	}
15410
15411	BOOL recommendedUSBTablet;
15412	rc = osType->COMGETTER(RecommendedUSBTablet)(&recommendedUSBTablet);
15413	if (FAILED(rc)) return rc;
15414
15415	if (recommendedUSBTablet)
15416	{
15417	mHWData->mPointingHIDType = PointingHIDType_USBTablet;
15418	if (!ohciEnabled && !usbDeviceFilters.isNull())
15419	{
15420	rc = addUSBController("OHCI", USBControllerType_OHCI, usbController);
15421	if (FAILED(rc)) return rc;
15422	}
15423	}
15424	return S_OK;
15425	}
15426
15427	/* This isn't handled entirely by the wrapper generator yet. */
15428	#ifdef VBOX_WITH_XPCOM
15429	NS_DECL_CLASSINFO(SessionMachine)
15430	NS_IMPL_THREADSAFE_ISUPPORTS2_CI(SessionMachine, IMachine, IInternalMachineControl)
15431
15432	NS_DECL_CLASSINFO(SnapshotMachine)
15433	NS_IMPL_THREADSAFE_ISUPPORTS1_CI(SnapshotMachine, IMachine)
15434	#endif

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

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

Download in other formats: