MachineImpl.cpp@ 33223

Last change on this file since 33223 was 33140, checked in by vboxsync, 14 years ago
Main: have Machine::MountMedium() behave like AttachDevice (use IMedium* pointer instead of UUID); add missing saveSettings calls there
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 382.9 KB

Line
1	/* $Id: MachineImpl.cpp 33140 2010-10-14 16:20:15Z vboxsync $ */
2	/** @file
3	* Implementation of IMachine in VBoxSVC.
4	*/
5
6	/*
7	* Copyright (C) 2006-2010 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	/* Make sure all the stdint.h macros are included - must come first! */
19	#ifndef __STDC_LIMIT_MACROS
20	# define __STDC_LIMIT_MACROS
21	#endif
22	#ifndef __STDC_CONSTANT_MACROS
23	# define __STDC_CONSTANT_MACROS
24	#endif
25
26	#ifdef VBOX_WITH_SYS_V_IPC_SESSION_WATCHER
27	# include <errno.h>
28	# include <sys/types.h>
29	# include <sys/stat.h>
30	# include <sys/ipc.h>
31	# include <sys/sem.h>
32	#endif
33
34	#include "Logging.h"
35	#include "VirtualBoxImpl.h"
36	#include "MachineImpl.h"
37	#include "ProgressImpl.h"
38	#include "ProgressProxyImpl.h"
39	#include "MediumAttachmentImpl.h"
40	#include "MediumImpl.h"
41	#include "MediumLock.h"
42	#include "USBControllerImpl.h"
43	#include "HostImpl.h"
44	#include "SharedFolderImpl.h"
45	#include "GuestOSTypeImpl.h"
46	#include "VirtualBoxErrorInfoImpl.h"
47	#include "GuestImpl.h"
48	#include "StorageControllerImpl.h"
49	#include "DisplayImpl.h"
50	#include "DisplayUtils.h"
51
52	#ifdef VBOX_WITH_USB
53	# include "USBProxyService.h"
54	#endif
55
56	#include "AutoCaller.h"
57	#include "Performance.h"
58
59	#include <iprt/asm.h>
60	#include <iprt/path.h>
61	#include <iprt/dir.h>
62	#include <iprt/env.h>
63	#include <iprt/lockvalidator.h>
64	#include <iprt/process.h>
65	#include <iprt/cpp/utils.h>
66	#include <iprt/cpp/xml.h> /* xml::XmlFileWriter::s_pszSuff. /
67	#include <iprt/string.h>
68
69	#include <VBox/com/array.h>
70
71	#include <VBox/err.h>
72	#include <VBox/param.h>
73	#include <VBox/settings.h>
74	#include <VBox/ssm.h>
75
76	#ifdef VBOX_WITH_GUEST_PROPS
77	# include <VBox/HostServices/GuestPropertySvc.h>
78	# include <VBox/com/array.h>
79	#endif
80
81	#include "VBox/com/MultiResult.h"
82
83	#include <algorithm>
84
85	#include <typeinfo>
86
87	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_OS2)
88	# define HOSTSUFF_EXE ".exe"
89	#else /* !RT_OS_WINDOWS */
90	# define HOSTSUFF_EXE ""
91	#endif /* !RT_OS_WINDOWS */
92
93	// defines / prototypes
94	/////////////////////////////////////////////////////////////////////////////
95
96	/////////////////////////////////////////////////////////////////////////////
97	// Machine::Data structure
98	/////////////////////////////////////////////////////////////////////////////
99
100	Machine::Data::Data()
101	{
102	mRegistered = FALSE;
103	pMachineConfigFile = NULL;
104	flModifications = 0;
105	mAccessible = FALSE;
106	/* mUuid is initialized in Machine::init() */
107
108	mMachineState = MachineState_PoweredOff;
109	RTTimeNow(&mLastStateChange);
110
111	mMachineStateDeps = 0;
112	mMachineStateDepsSem = NIL_RTSEMEVENTMULTI;
113	mMachineStateChangePending = 0;
114
115	mCurrentStateModified = TRUE;
116	mGuestPropertiesModified = FALSE;
117
118	mSession.mPid = NIL_RTPROCESS;
119	mSession.mState = SessionState_Unlocked;
120	}
121
122	Machine::Data::~Data()
123	{
124	if (mMachineStateDepsSem != NIL_RTSEMEVENTMULTI)
125	{
126	RTSemEventMultiDestroy(mMachineStateDepsSem);
127	mMachineStateDepsSem = NIL_RTSEMEVENTMULTI;
128	}
129	if (pMachineConfigFile)
130	{
131	delete pMachineConfigFile;
132	pMachineConfigFile = NULL;
133	}
134	}
135
136	/////////////////////////////////////////////////////////////////////////////
137	// Machine::HWData structure
138	/////////////////////////////////////////////////////////////////////////////
139
140	Machine::HWData::HWData()
141	{
142	/* default values for a newly created machine */
143	mHWVersion = "2"; /** @todo get the default from the schema if that is possible. */
144	mMemorySize = 128;
145	mCPUCount = 1;
146	mCPUHotPlugEnabled = false;
147	mMemoryBalloonSize = 0;
148	mPageFusionEnabled = false;
149	mVRAMSize = 8;
150	mAccelerate3DEnabled = false;
151	mAccelerate2DVideoEnabled = false;
152	mMonitorCount = 1;
153	mHWVirtExEnabled = true;
154	mHWVirtExNestedPagingEnabled = true;
155	#if HC_ARCH_BITS == 64
156	/* Default value decision pending. */
157	mHWVirtExLargePagesEnabled = false;
158	#else
159	/* Not supported on 32 bits hosts. */
160	mHWVirtExLargePagesEnabled = false;
161	#endif
162	mHWVirtExVPIDEnabled = true;
163	mHWVirtExForceEnabled = false;
164	#if defined(RT_OS_DARWIN) \|\| defined(RT_OS_WINDOWS)
165	mHWVirtExExclusive = false;
166	#else
167	mHWVirtExExclusive = true;
168	#endif
169	#if HC_ARCH_BITS == 64 \|\| defined(RT_OS_WINDOWS) \|\| defined(RT_OS_DARWIN)
170	mPAEEnabled = true;
171	#else
172	mPAEEnabled = false;
173	#endif
174	mSyntheticCpu = false;
175	mHpetEnabled = false;
176
177	/* default boot order: floppy - DVD - HDD */
178	mBootOrder[0] = DeviceType_Floppy;
179	mBootOrder[1] = DeviceType_DVD;
180	mBootOrder[2] = DeviceType_HardDisk;
181	for (size_t i = 3; i < RT_ELEMENTS(mBootOrder); ++i)
182	mBootOrder[i] = DeviceType_Null;
183
184	mClipboardMode = ClipboardMode_Bidirectional;
185	mGuestPropertyNotificationPatterns = "";
186
187	mFirmwareType = FirmwareType_BIOS;
188	mKeyboardHidType = KeyboardHidType_PS2Keyboard;
189	mPointingHidType = PointingHidType_PS2Mouse;
190	mChipsetType = ChipsetType_PIIX3;
191
192	for (size_t i = 0; i < RT_ELEMENTS(mCPUAttached); i++)
193	mCPUAttached[i] = false;
194
195	mIoCacheEnabled = true;
196	mIoCacheSize = 5; /* 5MB */
197
198	/* Maximum CPU execution cap by default. */
199	mCpuExecutionCap = 100;
200	}
201
202	Machine::HWData::~HWData()
203	{
204	}
205
206	/////////////////////////////////////////////////////////////////////////////
207	// Machine::HDData structure
208	/////////////////////////////////////////////////////////////////////////////
209
210	Machine::MediaData::MediaData()
211	{
212	}
213
214	Machine::MediaData::~MediaData()
215	{
216	}
217
218	/////////////////////////////////////////////////////////////////////////////
219	// Machine class
220	/////////////////////////////////////////////////////////////////////////////
221
222	// constructor / destructor
223	/////////////////////////////////////////////////////////////////////////////
224
225	Machine::Machine()
226	: mGuestHAL(NULL),
227	mPeer(NULL),
228	mParent(NULL)
229	{}
230
231	Machine::~Machine()
232	{}
233
234	HRESULT Machine::FinalConstruct()
235	{
236	LogFlowThisFunc(("\n"));
237	return S_OK;
238	}
239
240	void Machine::FinalRelease()
241	{
242	LogFlowThisFunc(("\n"));
243	uninit();
244	}
245
246	/**
247	* Initializes a new machine instance; this init() variant creates a new, empty machine.
248	* This gets called from VirtualBox::CreateMachine() or VirtualBox::CreateLegacyMachine().
249	*
250	* @param aParent Associated parent object
251	* @param strConfigFile Local file system path to the VM settings file (can
252	* be relative to the VirtualBox config directory).
253	* @param strName name for the machine
254	* @param aId UUID for the new machine.
255	* @param aOsType Optional OS Type of this machine.
256	* @param aOverride \|TRUE\| to override VM config file existence checks.
257	* \|FALSE\| refuses to overwrite existing VM configs.
258	* @param aNameSync \|TRUE\| to automatically sync settings dir and file
259	* name with the machine name. \|FALSE\| is used for legacy
260	* machines where the file name is specified by the
261	* user and should never change.
262	*
263	* @return Success indicator. if not S_OK, the machine object is invalid
264	*/
265	HRESULT Machine::init(VirtualBox *aParent,
266	const Utf8Str &strConfigFile,
267	const Utf8Str &strName,
268	const Guid &aId,
269	GuestOSType aOsType / = NULL */,
270	BOOL aOverride /* = FALSE */,
271	BOOL aNameSync /* = TRUE */)
272	{
273	LogFlowThisFuncEnter();
274	LogFlowThisFunc(("(Init_New) aConfigFile='%s'\n", strConfigFile.c_str()));
275
276	/* Enclose the state transition NotReady->InInit->Ready */
277	AutoInitSpan autoInitSpan(this);
278	AssertReturn(autoInitSpan.isOk(), E_FAIL);
279
280	HRESULT rc = initImpl(aParent, strConfigFile);
281	if (FAILED(rc)) return rc;
282
283	rc = tryCreateMachineConfigFile(aOverride);
284	if (FAILED(rc)) return rc;
285
286	if (SUCCEEDED(rc))
287	{
288	// create an empty machine config
289	mData->pMachineConfigFile = new settings::MachineConfigFile(NULL);
290
291	rc = initDataAndChildObjects();
292	}
293
294	if (SUCCEEDED(rc))
295	{
296	// set to true now to cause uninit() to call uninitDataAndChildObjects() on failure
297	mData->mAccessible = TRUE;
298
299	unconst(mData->mUuid) = aId;
300
301	mUserData->s.strName = strName;
302	mUserData->s.fNameSync = !!aNameSync;
303
304	/* initialize the default snapshots folder
305	* (note: depends on the name value set above!) */
306	rc = COMSETTER(SnapshotFolder)(NULL);
307	AssertComRC(rc);
308
309	if (aOsType)
310	{
311	/* Store OS type */
312	mUserData->s.strOsType = aOsType->id();
313
314	/* Apply BIOS defaults */
315	mBIOSSettings->applyDefaults(aOsType);
316
317	/* Apply network adapters defaults */
318	for (ULONG slot = 0; slot < RT_ELEMENTS(mNetworkAdapters); ++slot)
319	mNetworkAdapters[slot]->applyDefaults(aOsType);
320
321	/* Apply serial port defaults */
322	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
323	mSerialPorts[slot]->applyDefaults(aOsType);
324	}
325
326	/* commit all changes made during the initialization */
327	commit();
328	}
329
330	/* Confirm a successful initialization when it's the case */
331	if (SUCCEEDED(rc))
332	{
333	if (mData->mAccessible)
334	autoInitSpan.setSucceeded();
335	else
336	autoInitSpan.setLimited();
337	}
338
339	LogFlowThisFunc(("mName='%s', mRegistered=%RTbool, mAccessible=%RTbool, rc=%08X\n",
340	!!mUserData ? mUserData->s.strName.c_str() : "NULL",
341	mData->mRegistered,
342	mData->mAccessible,
343	rc));
344
345	LogFlowThisFuncLeave();
346
347	return rc;
348	}
349
350	/**
351	* Initializes a new instance with data from machine XML (formerly Init_Registered).
352	* Gets called in two modes:
353	*
354	* -- from VirtualBox::initMachines() during VirtualBox startup; in that case, the
355	* UUID is specified and we mark the machine as "registered";
356	*
357	* -- from the public VirtualBox::OpenMachine() API, in which case the UUID is NULL
358	* and the machine remains unregistered until RegisterMachine() is called.
359	*
360	* @param aParent Associated parent object
361	* @param aConfigFile Local file system path to the VM settings file (can
362	* be relative to the VirtualBox config directory).
363	* @param aId UUID of the machine or NULL (see above).
364	*
365	* @return Success indicator. if not S_OK, the machine object is invalid
366	*/
367	HRESULT Machine::init(VirtualBox *aParent,
368	const Utf8Str &strConfigFile,
369	const Guid *aId)
370	{
371	LogFlowThisFuncEnter();
372	LogFlowThisFunc(("(Init_Registered) aConfigFile='%s\n", strConfigFile.c_str()));
373
374	/* Enclose the state transition NotReady->InInit->Ready */
375	AutoInitSpan autoInitSpan(this);
376	AssertReturn(autoInitSpan.isOk(), E_FAIL);
377
378	HRESULT rc = initImpl(aParent, strConfigFile);
379	if (FAILED(rc)) return rc;
380
381	if (aId)
382	{
383	// loading a registered VM:
384	unconst(mData->mUuid) = *aId;
385	mData->mRegistered = TRUE;
386	// now load the settings from XML:
387	rc = registeredInit();
388	// this calls initDataAndChildObjects() and loadSettings()
389	}
390	else
391	{
392	// opening an unregistered VM (VirtualBox::OpenMachine()):
393	rc = initDataAndChildObjects();
394
395	if (SUCCEEDED(rc))
396	{
397	// set to true now to cause uninit() to call uninitDataAndChildObjects() on failure
398	mData->mAccessible = TRUE;
399
400	try
401	{
402	// load and parse machine XML; this will throw on XML or logic errors
403	mData->pMachineConfigFile = new settings::MachineConfigFile(&mData->m_strConfigFileFull);
404
405	// use UUID from machine config
406	unconst(mData->mUuid) = mData->pMachineConfigFile->uuid;
407
408	rc = loadMachineDataFromSettings(*mData->pMachineConfigFile,
409	NULL /* puuidRegistry */);
410	if (FAILED(rc)) throw rc;
411
412	commit();
413	}
414	catch (HRESULT err)
415	{
416	/* we assume that error info is set by the thrower */
417	rc = err;
418	}
419	catch (...)
420	{
421	rc = VirtualBox::handleUnexpectedExceptions(RT_SRC_POS);
422	}
423	}
424	}
425
426	/* Confirm a successful initialization when it's the case */
427	if (SUCCEEDED(rc))
428	{
429	if (mData->mAccessible)
430	autoInitSpan.setSucceeded();
431	else
432	{
433	autoInitSpan.setLimited();
434
435	// uninit media from this machine's media registry, or else
436	// reloading the settings will fail
437	mParent->unregisterMachineMedia(getId());
438	}
439	}
440
441	LogFlowThisFunc(("mName='%s', mRegistered=%RTbool, mAccessible=%RTbool "
442	"rc=%08X\n",
443	!!mUserData ? mUserData->s.strName.c_str() : "NULL",
444	mData->mRegistered, mData->mAccessible, rc));
445
446	LogFlowThisFuncLeave();
447
448	return rc;
449	}
450
451	/**
452	* Initializes a new instance from a machine config that is already in memory
453	* (import OVF case). Since we are importing, the UUID in the machine
454	* config is ignored and we always generate a fresh one.
455	*
456	* @param strName Name for the new machine; this overrides what is specified in config and is used
457	* for the settings file as well.
458	* @param config Machine configuration loaded and parsed from XML.
459	*
460	* @return Success indicator. if not S_OK, the machine object is invalid
461	*/
462	HRESULT Machine::init(VirtualBox *aParent,
463	const Utf8Str &strName,
464	const settings::MachineConfigFile &config)
465	{
466	LogFlowThisFuncEnter();
467
468	/* Enclose the state transition NotReady->InInit->Ready */
469	AutoInitSpan autoInitSpan(this);
470	AssertReturn(autoInitSpan.isOk(), E_FAIL);
471
472	Utf8Str strConfigFile;
473	aParent->getDefaultMachineFolder(strConfigFile);
474	strConfigFile.append(RTPATH_DELIMITER);
475	strConfigFile.append(strName);
476	strConfigFile.append(RTPATH_DELIMITER);
477	strConfigFile.append(strName);
478	strConfigFile.append(".vbox");
479
480	HRESULT rc = initImpl(aParent, strConfigFile);
481	if (FAILED(rc)) return rc;
482
483	rc = tryCreateMachineConfigFile(FALSE /* aOverride */);
484	if (FAILED(rc)) return rc;
485
486	rc = initDataAndChildObjects();
487
488	if (SUCCEEDED(rc))
489	{
490	// set to true now to cause uninit() to call uninitDataAndChildObjects() on failure
491	mData->mAccessible = TRUE;
492
493	// create empty machine config for instance data
494	mData->pMachineConfigFile = new settings::MachineConfigFile(NULL);
495
496	// generate fresh UUID, ignore machine config
497	unconst(mData->mUuid).create();
498
499	rc = loadMachineDataFromSettings(config,
500	&mData->mUuid); // puuidRegistry: initialize media with this registry ID
501
502	// override VM name as well, it may be different
503	mUserData->s.strName = strName;
504
505	/* commit all changes made during the initialization */
506	if (SUCCEEDED(rc))
507	commit();
508	}
509
510	/* Confirm a successful initialization when it's the case */
511	if (SUCCEEDED(rc))
512	{
513	if (mData->mAccessible)
514	autoInitSpan.setSucceeded();
515	else
516	{
517	autoInitSpan.setLimited();
518
519	// uninit media from this machine's media registry, or else
520	// reloading the settings will fail
521	mParent->unregisterMachineMedia(getId());
522	}
523	}
524
525	LogFlowThisFunc(("mName='%s', mRegistered=%RTbool, mAccessible=%RTbool "
526	"rc=%08X\n",
527	!!mUserData ? mUserData->s.strName.c_str() : "NULL",
528	mData->mRegistered, mData->mAccessible, rc));
529
530	LogFlowThisFuncLeave();
531
532	return rc;
533	}
534
535	/**
536	* Shared code between the various init() implementations.
537	* @param aParent
538	* @return
539	*/
540	HRESULT Machine::initImpl(VirtualBox *aParent,
541	const Utf8Str &strConfigFile)
542	{
543	LogFlowThisFuncEnter();
544
545	AssertReturn(aParent, E_INVALIDARG);
546	AssertReturn(!strConfigFile.isEmpty(), E_INVALIDARG);
547
548	HRESULT rc = S_OK;
549
550	/* share the parent weakly */
551	unconst(mParent) = aParent;
552
553	/* allocate the essential machine data structure (the rest will be
554	* allocated later by initDataAndChildObjects() */
555	mData.allocate();
556
557	/* memorize the config file name (as provided) */
558	mData->m_strConfigFile = strConfigFile;
559
560	/* get the full file name */
561	int vrc1 = mParent->calculateFullPath(strConfigFile, mData->m_strConfigFileFull);
562	if (RT_FAILURE(vrc1))
563	return setError(VBOX_E_FILE_ERROR,
564	tr("Invalid machine settings file name '%s' (%Rrc)"),
565	strConfigFile.c_str(),
566	vrc1);
567
568	LogFlowThisFuncLeave();
569
570	return rc;
571	}
572
573	/**
574	* Tries to create a machine settings file in the path stored in the machine
575	* instance data. Used when a new machine is created to fail gracefully if
576	* the settings file could not be written (e.g. because machine dir is read-only).
577	* @return
578	*/
579	HRESULT Machine::tryCreateMachineConfigFile(BOOL aOverride)
580	{
581	HRESULT rc = S_OK;
582
583	// when we create a new machine, we must be able to create the settings file
584	RTFILE f = NIL_RTFILE;
585	int vrc = RTFileOpen(&f, mData->m_strConfigFileFull.c_str(), RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE);
586	if ( RT_SUCCESS(vrc)
587	\|\| vrc == VERR_SHARING_VIOLATION
588	)
589	{
590	if (RT_SUCCESS(vrc))
591	RTFileClose(f);
592	if (!aOverride)
593	rc = setError(VBOX_E_FILE_ERROR,
594	tr("Machine settings file '%s' already exists"),
595	mData->m_strConfigFileFull.c_str());
596	else
597	{
598	/* try to delete the config file, as otherwise the creation
599	* of a new settings file will fail. */
600	int vrc2 = RTFileDelete(mData->m_strConfigFileFull.c_str());
601	if (RT_FAILURE(vrc2))
602	rc = setError(VBOX_E_FILE_ERROR,
603	tr("Could not delete the existing settings file '%s' (%Rrc)"),
604	mData->m_strConfigFileFull.c_str(), vrc2);
605	}
606	}
607	else if ( vrc != VERR_FILE_NOT_FOUND
608	&& vrc != VERR_PATH_NOT_FOUND
609	)
610	rc = setError(VBOX_E_FILE_ERROR,
611	tr("Invalid machine settings file name '%s' (%Rrc)"),
612	mData->m_strConfigFileFull.c_str(),
613	vrc);
614	return rc;
615	}
616
617	/**
618	* Initializes the registered machine by loading the settings file.
619	* This method is separated from #init() in order to make it possible to
620	* retry the operation after VirtualBox startup instead of refusing to
621	* startup the whole VirtualBox server in case if the settings file of some
622	* registered VM is invalid or inaccessible.
623	*
624	* @note Must be always called from this object's write lock
625	* (unless called from #init() that doesn't need any locking).
626	* @note Locks the mUSBController method for writing.
627	* @note Subclasses must not call this method.
628	*/
629	HRESULT Machine::registeredInit()
630	{
631	AssertReturn(!isSessionMachine(), E_FAIL);
632	AssertReturn(!isSnapshotMachine(), E_FAIL);
633	AssertReturn(!mData->mUuid.isEmpty(), E_FAIL);
634	AssertReturn(!mData->mAccessible, E_FAIL);
635
636	HRESULT rc = initDataAndChildObjects();
637
638	if (SUCCEEDED(rc))
639	{
640	/* Temporarily reset the registered flag in order to let setters
641	* potentially called from loadSettings() succeed (isMutable() used in
642	* all setters will return FALSE for a Machine instance if mRegistered
643	* is TRUE). */
644	mData->mRegistered = FALSE;
645
646	try
647	{
648	// load and parse machine XML; this will throw on XML or logic errors
649	mData->pMachineConfigFile = new settings::MachineConfigFile(&mData->m_strConfigFileFull);
650
651	if (mData->mUuid != mData->pMachineConfigFile->uuid)
652	throw setError(E_FAIL,
653	tr("Machine UUID {%RTuuid} in '%s' doesn't match its UUID {%s} in the registry file '%s'"),
654	mData->pMachineConfigFile->uuid.raw(),
655	mData->m_strConfigFileFull.c_str(),
656	mData->mUuid.toString().c_str(),
657	mParent->settingsFilePath().c_str());
658
659	rc = loadMachineDataFromSettings(*mData->pMachineConfigFile,
660	NULL /* const Guid puuidRegistry /);
661	if (FAILED(rc)) throw rc;
662	}
663	catch (HRESULT err)
664	{
665	/* we assume that error info is set by the thrower */
666	rc = err;
667	}
668	catch (...)
669	{
670	rc = VirtualBox::handleUnexpectedExceptions(RT_SRC_POS);
671	}
672
673	/* Restore the registered flag (even on failure) */
674	mData->mRegistered = TRUE;
675	}
676
677	if (SUCCEEDED(rc))
678	{
679	/* Set mAccessible to TRUE only if we successfully locked and loaded
680	* the settings file */
681	mData->mAccessible = TRUE;
682
683	/* commit all changes made during loading the settings file */
684	commit(); // @todo r=dj why do we need a commit during init?!? this is very expensive
685	}
686	else
687	{
688	/* If the machine is registered, then, instead of returning a
689	* failure, we mark it as inaccessible and set the result to
690	* success to give it a try later */
691
692	/* fetch the current error info */
693	mData->mAccessError = com::ErrorInfo();
694	LogWarning(("Machine {%RTuuid} is inaccessible! [%ls]\n",
695	mData->mUuid.raw(),
696	mData->mAccessError.getText().raw()));
697
698	/* rollback all changes */
699	rollback(false /* aNotify */);
700
701	// uninit media from this machine's media registry, or else
702	// reloading the settings will fail
703	mParent->unregisterMachineMedia(getId());
704
705	/* uninitialize the common part to make sure all data is reset to
706	* default (null) values */
707	uninitDataAndChildObjects();
708
709	rc = S_OK;
710	}
711
712	return rc;
713	}
714
715	/**
716	* Uninitializes the instance.
717	* Called either from FinalRelease() or by the parent when it gets destroyed.
718	*
719	* @note The caller of this method must make sure that this object
720	* a) doesn't have active callers on the current thread and b) is not locked
721	* by the current thread; otherwise uninit() will hang either a) due to
722	* AutoUninitSpan waiting for a number of calls to drop to zero or b) due to
723	* a dead-lock caused by this thread waiting for all callers on the other
724	* threads are done but preventing them from doing so by holding a lock.
725	*/
726	void Machine::uninit()
727	{
728	LogFlowThisFuncEnter();
729
730	Assert(!isWriteLockOnCurrentThread());
731
732	/* Enclose the state transition Ready->InUninit->NotReady */
733	AutoUninitSpan autoUninitSpan(this);
734	if (autoUninitSpan.uninitDone())
735	return;
736
737	Assert(!isSnapshotMachine());
738	Assert(!isSessionMachine());
739	Assert(!!mData);
740
741	LogFlowThisFunc(("initFailed()=%d\n", autoUninitSpan.initFailed()));
742	LogFlowThisFunc(("mRegistered=%d\n", mData->mRegistered));
743
744	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
745
746	if (!mData->mSession.mMachine.isNull())
747	{
748	/* Theoretically, this can only happen if the VirtualBox server has been
749	* terminated while there were clients running that owned open direct
750	* sessions. Since in this case we are definitely called by
751	* VirtualBox::uninit(), we may be sure that SessionMachine::uninit()
752	* won't happen on the client watcher thread (because it does
753	* VirtualBox::addCaller() for the duration of the
754	* SessionMachine::checkForDeath() call, so that VirtualBox::uninit()
755	* cannot happen until the VirtualBox caller is released). This is
756	* important, because SessionMachine::uninit() cannot correctly operate
757	* after we return from this method (it expects the Machine instance is
758	* still valid). We'll call it ourselves below.
759	*/
760	LogWarningThisFunc(("Session machine is not NULL (%p), the direct session is still open!\n",
761	(SessionMachine*)mData->mSession.mMachine));
762
763	if (Global::IsOnlineOrTransient(mData->mMachineState))
764	{
765	LogWarningThisFunc(("Setting state to Aborted!\n"));
766	/* set machine state using SessionMachine reimplementation */
767	static_cast<Machine*>(mData->mSession.mMachine)->setMachineState(MachineState_Aborted);
768	}
769
770	/*
771	* Uninitialize SessionMachine using public uninit() to indicate
772	* an unexpected uninitialization.
773	*/
774	mData->mSession.mMachine->uninit();
775	/* SessionMachine::uninit() must set mSession.mMachine to null */
776	Assert(mData->mSession.mMachine.isNull());
777	}
778
779	// uninit media from this machine's media registry, if they're still there
780	mParent->unregisterMachineMedia(getId());
781
782	/* the lock is no more necessary (SessionMachine is uninitialized) */
783	alock.leave();
784
785	// has machine been modified?
786	if (mData->flModifications)
787	{
788	LogWarningThisFunc(("Discarding unsaved settings changes!\n"));
789	rollback(false /* aNotify */);
790	}
791
792	if (mData->mAccessible)
793	uninitDataAndChildObjects();
794
795	/* free the essential data structure last */
796	mData.free();
797
798	LogFlowThisFuncLeave();
799	}
800
801	// IMachine properties
802	/////////////////////////////////////////////////////////////////////////////
803
804	STDMETHODIMP Machine::COMGETTER(Parent)(IVirtualBox **aParent)
805	{
806	CheckComArgOutPointerValid(aParent);
807
808	AutoLimitedCaller autoCaller(this);
809	if (FAILED(autoCaller.rc())) return autoCaller.rc();
810
811	/* mParent is constant during life time, no need to lock */
812	ComObjPtr<VirtualBox> pVirtualBox(mParent);
813	pVirtualBox.queryInterfaceTo(aParent);
814
815	return S_OK;
816	}
817
818	STDMETHODIMP Machine::COMGETTER(Accessible)(BOOL *aAccessible)
819	{
820	CheckComArgOutPointerValid(aAccessible);
821
822	AutoLimitedCaller autoCaller(this);
823	if (FAILED(autoCaller.rc())) return autoCaller.rc();
824
825	LogFlowThisFunc(("ENTER\n"));
826
827	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
828
829	HRESULT rc = S_OK;
830
831	if (!mData->mAccessible)
832	{
833	/* try to initialize the VM once more if not accessible */
834
835	AutoReinitSpan autoReinitSpan(this);
836	AssertReturn(autoReinitSpan.isOk(), E_FAIL);
837
838	#ifdef DEBUG
839	LogFlowThisFunc(("Dumping media backreferences\n"));
840	mParent->dumpAllBackRefs();
841	#endif
842
843	if (mData->pMachineConfigFile)
844	{
845	// reset the XML file to force loadSettings() (called from registeredInit())
846	// to parse it again; the file might have changed
847	delete mData->pMachineConfigFile;
848	mData->pMachineConfigFile = NULL;
849	}
850
851	rc = registeredInit();
852
853	if (SUCCEEDED(rc) && mData->mAccessible)
854	{
855	autoReinitSpan.setSucceeded();
856
857	/* make sure interesting parties will notice the accessibility
858	* state change */
859	mParent->onMachineStateChange(mData->mUuid, mData->mMachineState);
860	mParent->onMachineDataChange(mData->mUuid);
861	}
862	}
863
864	if (SUCCEEDED(rc))
865	*aAccessible = mData->mAccessible;
866
867	LogFlowThisFuncLeave();
868
869	return rc;
870	}
871
872	STDMETHODIMP Machine::COMGETTER(AccessError)(IVirtualBoxErrorInfo **aAccessError)
873	{
874	CheckComArgOutPointerValid(aAccessError);
875
876	AutoLimitedCaller autoCaller(this);
877	if (FAILED(autoCaller.rc())) return autoCaller.rc();
878
879	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
880
881	if (mData->mAccessible \|\| !mData->mAccessError.isBasicAvailable())
882	{
883	/* return shortly */
884	aAccessError = NULL;
885	return S_OK;
886	}
887
888	HRESULT rc = S_OK;
889
890	ComObjPtr<VirtualBoxErrorInfo> errorInfo;
891	rc = errorInfo.createObject();
892	if (SUCCEEDED(rc))
893	{
894	errorInfo->init(mData->mAccessError.getResultCode(),
895	mData->mAccessError.getInterfaceID().ref(),
896	Utf8Str(mData->mAccessError.getComponent()).c_str(),
897	Utf8Str(mData->mAccessError.getText()));
898	rc = errorInfo.queryInterfaceTo(aAccessError);
899	}
900
901	return rc;
902	}
903
904	STDMETHODIMP Machine::COMGETTER(Name)(BSTR *aName)
905	{
906	CheckComArgOutPointerValid(aName);
907
908	AutoCaller autoCaller(this);
909	if (FAILED(autoCaller.rc())) return autoCaller.rc();
910
911	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
912
913	mUserData->s.strName.cloneTo(aName);
914
915	return S_OK;
916	}
917
918	STDMETHODIMP Machine::COMSETTER(Name)(IN_BSTR aName)
919	{
920	CheckComArgStrNotEmptyOrNull(aName);
921
922	AutoCaller autoCaller(this);
923	if (FAILED(autoCaller.rc())) return autoCaller.rc();
924
925	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
926
927	HRESULT rc = checkStateDependency(MutableStateDep);
928	if (FAILED(rc)) return rc;
929
930	setModified(IsModified_MachineData);
931	mUserData.backup();
932	mUserData->s.strName = aName;
933
934	return S_OK;
935	}
936
937	STDMETHODIMP Machine::COMGETTER(Description)(BSTR *aDescription)
938	{
939	CheckComArgOutPointerValid(aDescription);
940
941	AutoCaller autoCaller(this);
942	if (FAILED(autoCaller.rc())) return autoCaller.rc();
943
944	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
945
946	mUserData->s.strDescription.cloneTo(aDescription);
947
948	return S_OK;
949	}
950
951	STDMETHODIMP Machine::COMSETTER(Description)(IN_BSTR aDescription)
952	{
953	AutoCaller autoCaller(this);
954	if (FAILED(autoCaller.rc())) return autoCaller.rc();
955
956	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
957
958	HRESULT rc = checkStateDependency(MutableStateDep);
959	if (FAILED(rc)) return rc;
960
961	setModified(IsModified_MachineData);
962	mUserData.backup();
963	mUserData->s.strDescription = aDescription;
964
965	return S_OK;
966	}
967
968	STDMETHODIMP Machine::COMGETTER(Id)(BSTR *aId)
969	{
970	CheckComArgOutPointerValid(aId);
971
972	AutoLimitedCaller autoCaller(this);
973	if (FAILED(autoCaller.rc())) return autoCaller.rc();
974
975	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
976
977	mData->mUuid.toUtf16().cloneTo(aId);
978
979	return S_OK;
980	}
981
982	STDMETHODIMP Machine::COMGETTER(OSTypeId)(BSTR *aOSTypeId)
983	{
984	CheckComArgOutPointerValid(aOSTypeId);
985
986	AutoCaller autoCaller(this);
987	if (FAILED(autoCaller.rc())) return autoCaller.rc();
988
989	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
990
991	mUserData->s.strOsType.cloneTo(aOSTypeId);
992
993	return S_OK;
994	}
995
996	STDMETHODIMP Machine::COMSETTER(OSTypeId)(IN_BSTR aOSTypeId)
997	{
998	CheckComArgStrNotEmptyOrNull(aOSTypeId);
999
1000	AutoCaller autoCaller(this);
1001	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1002
1003	/* look up the object by Id to check it is valid */
1004	ComPtr<IGuestOSType> guestOSType;
1005	HRESULT rc = mParent->GetGuestOSType(aOSTypeId, guestOSType.asOutParam());
1006	if (FAILED(rc)) return rc;
1007
1008	/* when setting, always use the "etalon" value for consistency -- lookup
1009	* by ID is case-insensitive and the input value may have different case */
1010	Bstr osTypeId;
1011	rc = guestOSType->COMGETTER(Id)(osTypeId.asOutParam());
1012	if (FAILED(rc)) return rc;
1013
1014	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1015
1016	rc = checkStateDependency(MutableStateDep);
1017	if (FAILED(rc)) return rc;
1018
1019	setModified(IsModified_MachineData);
1020	mUserData.backup();
1021	mUserData->s.strOsType = osTypeId;
1022
1023	return S_OK;
1024	}
1025
1026
1027	STDMETHODIMP Machine::COMGETTER(FirmwareType)(FirmwareType_T *aFirmwareType)
1028	{
1029	CheckComArgOutPointerValid(aFirmwareType);
1030
1031	AutoCaller autoCaller(this);
1032	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1033
1034	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1035
1036	*aFirmwareType = mHWData->mFirmwareType;
1037
1038	return S_OK;
1039	}
1040
1041	STDMETHODIMP Machine::COMSETTER(FirmwareType)(FirmwareType_T aFirmwareType)
1042	{
1043	AutoCaller autoCaller(this);
1044	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1045	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1046
1047	int rc = checkStateDependency(MutableStateDep);
1048	if (FAILED(rc)) return rc;
1049
1050	setModified(IsModified_MachineData);
1051	mHWData.backup();
1052	mHWData->mFirmwareType = aFirmwareType;
1053
1054	return S_OK;
1055	}
1056
1057	STDMETHODIMP Machine::COMGETTER(KeyboardHidType)(KeyboardHidType_T *aKeyboardHidType)
1058	{
1059	CheckComArgOutPointerValid(aKeyboardHidType);
1060
1061	AutoCaller autoCaller(this);
1062	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1063
1064	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1065
1066	*aKeyboardHidType = mHWData->mKeyboardHidType;
1067
1068	return S_OK;
1069	}
1070
1071	STDMETHODIMP Machine::COMSETTER(KeyboardHidType)(KeyboardHidType_T aKeyboardHidType)
1072	{
1073	AutoCaller autoCaller(this);
1074	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1075	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1076
1077	int rc = checkStateDependency(MutableStateDep);
1078	if (FAILED(rc)) return rc;
1079
1080	setModified(IsModified_MachineData);
1081	mHWData.backup();
1082	mHWData->mKeyboardHidType = aKeyboardHidType;
1083
1084	return S_OK;
1085	}
1086
1087	STDMETHODIMP Machine::COMGETTER(PointingHidType)(PointingHidType_T *aPointingHidType)
1088	{
1089	CheckComArgOutPointerValid(aPointingHidType);
1090
1091	AutoCaller autoCaller(this);
1092	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1093
1094	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1095
1096	*aPointingHidType = mHWData->mPointingHidType;
1097
1098	return S_OK;
1099	}
1100
1101	STDMETHODIMP Machine::COMSETTER(PointingHidType)(PointingHidType_T aPointingHidType)
1102	{
1103	AutoCaller autoCaller(this);
1104	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1105	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1106
1107	int rc = checkStateDependency(MutableStateDep);
1108	if (FAILED(rc)) return rc;
1109
1110	setModified(IsModified_MachineData);
1111	mHWData.backup();
1112	mHWData->mPointingHidType = aPointingHidType;
1113
1114	return S_OK;
1115	}
1116
1117	STDMETHODIMP Machine::COMGETTER(ChipsetType)(ChipsetType_T *aChipsetType)
1118	{
1119	CheckComArgOutPointerValid(aChipsetType);
1120
1121	AutoCaller autoCaller(this);
1122	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1123
1124	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1125
1126	*aChipsetType = mHWData->mChipsetType;
1127
1128	return S_OK;
1129	}
1130
1131	STDMETHODIMP Machine::COMSETTER(ChipsetType)(ChipsetType_T aChipsetType)
1132	{
1133	AutoCaller autoCaller(this);
1134	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1135	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1136
1137	int rc = checkStateDependency(MutableStateDep);
1138	if (FAILED(rc)) return rc;
1139
1140	setModified(IsModified_MachineData);
1141	mHWData.backup();
1142	mHWData->mChipsetType = aChipsetType;
1143
1144	return S_OK;
1145	}
1146
1147	STDMETHODIMP Machine::COMGETTER(HardwareVersion)(BSTR *aHWVersion)
1148	{
1149	if (!aHWVersion)
1150	return E_POINTER;
1151
1152	AutoCaller autoCaller(this);
1153	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1154
1155	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1156
1157	mHWData->mHWVersion.cloneTo(aHWVersion);
1158
1159	return S_OK;
1160	}
1161
1162	STDMETHODIMP Machine::COMSETTER(HardwareVersion)(IN_BSTR aHWVersion)
1163	{
1164	/* check known version */
1165	Utf8Str hwVersion = aHWVersion;
1166	if ( hwVersion.compare("1") != 0
1167	&& hwVersion.compare("2") != 0)
1168	return setError(E_INVALIDARG,
1169	tr("Invalid hardware version: %ls\n"), aHWVersion);
1170
1171	AutoCaller autoCaller(this);
1172	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1173
1174	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1175
1176	HRESULT rc = checkStateDependency(MutableStateDep);
1177	if (FAILED(rc)) return rc;
1178
1179	setModified(IsModified_MachineData);
1180	mHWData.backup();
1181	mHWData->mHWVersion = hwVersion;
1182
1183	return S_OK;
1184	}
1185
1186	STDMETHODIMP Machine::COMGETTER(HardwareUUID)(BSTR *aUUID)
1187	{
1188	CheckComArgOutPointerValid(aUUID);
1189
1190	AutoCaller autoCaller(this);
1191	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1192
1193	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1194
1195	if (!mHWData->mHardwareUUID.isEmpty())
1196	mHWData->mHardwareUUID.toUtf16().cloneTo(aUUID);
1197	else
1198	mData->mUuid.toUtf16().cloneTo(aUUID);
1199
1200	return S_OK;
1201	}
1202
1203	STDMETHODIMP Machine::COMSETTER(HardwareUUID)(IN_BSTR aUUID)
1204	{
1205	Guid hardwareUUID(aUUID);
1206	if (hardwareUUID.isEmpty())
1207	return E_INVALIDARG;
1208
1209	AutoCaller autoCaller(this);
1210	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1211
1212	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1213
1214	HRESULT rc = checkStateDependency(MutableStateDep);
1215	if (FAILED(rc)) return rc;
1216
1217	setModified(IsModified_MachineData);
1218	mHWData.backup();
1219	if (hardwareUUID == mData->mUuid)
1220	mHWData->mHardwareUUID.clear();
1221	else
1222	mHWData->mHardwareUUID = hardwareUUID;
1223
1224	return S_OK;
1225	}
1226
1227	STDMETHODIMP Machine::COMGETTER(MemorySize)(ULONG *memorySize)
1228	{
1229	if (!memorySize)
1230	return E_POINTER;
1231
1232	AutoCaller autoCaller(this);
1233	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1234
1235	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1236
1237	*memorySize = mHWData->mMemorySize;
1238
1239	return S_OK;
1240	}
1241
1242	STDMETHODIMP Machine::COMSETTER(MemorySize)(ULONG memorySize)
1243	{
1244	/* check RAM limits */
1245	if ( memorySize < MM_RAM_MIN_IN_MB
1246	\|\| memorySize > MM_RAM_MAX_IN_MB
1247	)
1248	return setError(E_INVALIDARG,
1249	tr("Invalid RAM size: %lu MB (must be in range [%lu, %lu] MB)"),
1250	memorySize, MM_RAM_MIN_IN_MB, MM_RAM_MAX_IN_MB);
1251
1252	AutoCaller autoCaller(this);
1253	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1254
1255	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1256
1257	HRESULT rc = checkStateDependency(MutableStateDep);
1258	if (FAILED(rc)) return rc;
1259
1260	setModified(IsModified_MachineData);
1261	mHWData.backup();
1262	mHWData->mMemorySize = memorySize;
1263
1264	return S_OK;
1265	}
1266
1267	STDMETHODIMP Machine::COMGETTER(CPUCount)(ULONG *CPUCount)
1268	{
1269	if (!CPUCount)
1270	return E_POINTER;
1271
1272	AutoCaller autoCaller(this);
1273	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1274
1275	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1276
1277	*CPUCount = mHWData->mCPUCount;
1278
1279	return S_OK;
1280	}
1281
1282	STDMETHODIMP Machine::COMSETTER(CPUCount)(ULONG CPUCount)
1283	{
1284	/* check CPU limits */
1285	if ( CPUCount < SchemaDefs::MinCPUCount
1286	\|\| CPUCount > SchemaDefs::MaxCPUCount
1287	)
1288	return setError(E_INVALIDARG,
1289	tr("Invalid virtual CPU count: %lu (must be in range [%lu, %lu])"),
1290	CPUCount, SchemaDefs::MinCPUCount, SchemaDefs::MaxCPUCount);
1291
1292	AutoCaller autoCaller(this);
1293	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1294
1295	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1296
1297	/* We cant go below the current number of CPUs if hotplug is enabled*/
1298	if (mHWData->mCPUHotPlugEnabled)
1299	{
1300	for (unsigned idx = CPUCount; idx < SchemaDefs::MaxCPUCount; idx++)
1301	{
1302	if (mHWData->mCPUAttached[idx])
1303	return setError(E_INVALIDARG,
1304	tr(": %lu (must be higher than or equal to %lu)"),
1305	CPUCount, idx+1);
1306	}
1307	}
1308
1309	HRESULT rc = checkStateDependency(MutableStateDep);
1310	if (FAILED(rc)) return rc;
1311
1312	setModified(IsModified_MachineData);
1313	mHWData.backup();
1314	mHWData->mCPUCount = CPUCount;
1315
1316	return S_OK;
1317	}
1318
1319	STDMETHODIMP Machine::COMGETTER(CPUExecutionCap)(ULONG *aExecutionCap)
1320	{
1321	if (!aExecutionCap)
1322	return E_POINTER;
1323
1324	AutoCaller autoCaller(this);
1325	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1326
1327	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1328
1329	*aExecutionCap = mHWData->mCpuExecutionCap;
1330
1331	return S_OK;
1332	}
1333
1334	STDMETHODIMP Machine::COMSETTER(CPUExecutionCap)(ULONG aExecutionCap)
1335	{
1336	HRESULT rc = S_OK;
1337
1338	/* check throttle limits */
1339	if ( aExecutionCap < 1
1340	\|\| aExecutionCap > 100
1341	)
1342	return setError(E_INVALIDARG,
1343	tr("Invalid CPU execution cap value: %lu (must be in range [%lu, %lu])"),
1344	aExecutionCap, 1, 100);
1345
1346	AutoCaller autoCaller(this);
1347	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1348
1349	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1350
1351	alock.release();
1352	rc = onCPUExecutionCapChange(aExecutionCap);
1353	alock.acquire();
1354	if (FAILED(rc)) return rc;
1355
1356	setModified(IsModified_MachineData);
1357	mHWData.backup();
1358	mHWData->mCpuExecutionCap = aExecutionCap;
1359
1360	/* Save settings if online - todo why is this required?? */
1361	if (Global::IsOnline(mData->mMachineState))
1362	saveSettings(NULL);
1363
1364	return S_OK;
1365	}
1366
1367
1368	STDMETHODIMP Machine::COMGETTER(CPUHotPlugEnabled)(BOOL *enabled)
1369	{
1370	if (!enabled)
1371	return E_POINTER;
1372
1373	AutoCaller autoCaller(this);
1374	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1375
1376	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1377
1378	*enabled = mHWData->mCPUHotPlugEnabled;
1379
1380	return S_OK;
1381	}
1382
1383	STDMETHODIMP Machine::COMSETTER(CPUHotPlugEnabled)(BOOL enabled)
1384	{
1385	HRESULT rc = S_OK;
1386
1387	AutoCaller autoCaller(this);
1388	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1389
1390	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1391
1392	rc = checkStateDependency(MutableStateDep);
1393	if (FAILED(rc)) return rc;
1394
1395	if (mHWData->mCPUHotPlugEnabled != enabled)
1396	{
1397	if (enabled)
1398	{
1399	setModified(IsModified_MachineData);
1400	mHWData.backup();
1401
1402	/* Add the amount of CPUs currently attached */
1403	for (unsigned i = 0; i < mHWData->mCPUCount; i++)
1404	{
1405	mHWData->mCPUAttached[i] = true;
1406	}
1407	}
1408	else
1409	{
1410	/*
1411	* We can disable hotplug only if the amount of maximum CPUs is equal
1412	* to the amount of attached CPUs
1413	*/
1414	unsigned cCpusAttached = 0;
1415	unsigned iHighestId = 0;
1416
1417	for (unsigned i = 0; i < SchemaDefs::MaxCPUCount; i++)
1418	{
1419	if (mHWData->mCPUAttached[i])
1420	{
1421	cCpusAttached++;
1422	iHighestId = i;
1423	}
1424	}
1425
1426	if ( (cCpusAttached != mHWData->mCPUCount)
1427	\|\| (iHighestId >= mHWData->mCPUCount))
1428	return setError(E_INVALIDARG,
1429	tr("CPU hotplugging can't be disabled because the maximum number of CPUs is not equal to the amount of CPUs attached\n"));
1430
1431	setModified(IsModified_MachineData);
1432	mHWData.backup();
1433	}
1434	}
1435
1436	mHWData->mCPUHotPlugEnabled = enabled;
1437
1438	return rc;
1439	}
1440
1441	STDMETHODIMP Machine::COMGETTER(HpetEnabled)(BOOL *enabled)
1442	{
1443	CheckComArgOutPointerValid(enabled);
1444
1445	AutoCaller autoCaller(this);
1446	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1447	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1448
1449	*enabled = mHWData->mHpetEnabled;
1450
1451	return S_OK;
1452	}
1453
1454	STDMETHODIMP Machine::COMSETTER(HpetEnabled)(BOOL enabled)
1455	{
1456	HRESULT rc = S_OK;
1457
1458	AutoCaller autoCaller(this);
1459	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1460	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1461
1462	rc = checkStateDependency(MutableStateDep);
1463	if (FAILED(rc)) return rc;
1464
1465	setModified(IsModified_MachineData);
1466	mHWData.backup();
1467
1468	mHWData->mHpetEnabled = enabled;
1469
1470	return rc;
1471	}
1472
1473	STDMETHODIMP Machine::COMGETTER(VRAMSize)(ULONG *memorySize)
1474	{
1475	if (!memorySize)
1476	return E_POINTER;
1477
1478	AutoCaller autoCaller(this);
1479	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1480
1481	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1482
1483	*memorySize = mHWData->mVRAMSize;
1484
1485	return S_OK;
1486	}
1487
1488	STDMETHODIMP Machine::COMSETTER(VRAMSize)(ULONG memorySize)
1489	{
1490	/* check VRAM limits */
1491	if (memorySize < SchemaDefs::MinGuestVRAM \|\|
1492	memorySize > SchemaDefs::MaxGuestVRAM)
1493	return setError(E_INVALIDARG,
1494	tr("Invalid VRAM size: %lu MB (must be in range [%lu, %lu] MB)"),
1495	memorySize, SchemaDefs::MinGuestVRAM, SchemaDefs::MaxGuestVRAM);
1496
1497	AutoCaller autoCaller(this);
1498	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1499
1500	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1501
1502	HRESULT rc = checkStateDependency(MutableStateDep);
1503	if (FAILED(rc)) return rc;
1504
1505	setModified(IsModified_MachineData);
1506	mHWData.backup();
1507	mHWData->mVRAMSize = memorySize;
1508
1509	return S_OK;
1510	}
1511
1512	/** @todo this method should not be public */
1513	STDMETHODIMP Machine::COMGETTER(MemoryBalloonSize)(ULONG *memoryBalloonSize)
1514	{
1515	if (!memoryBalloonSize)
1516	return E_POINTER;
1517
1518	AutoCaller autoCaller(this);
1519	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1520
1521	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1522
1523	*memoryBalloonSize = mHWData->mMemoryBalloonSize;
1524
1525	return S_OK;
1526	}
1527
1528	/**
1529	* Set the memory balloon size.
1530	*
1531	* This method is also called from IGuest::COMSETTER(MemoryBalloonSize) so
1532	* we have to make sure that we never call IGuest from here.
1533	*/
1534	STDMETHODIMP Machine::COMSETTER(MemoryBalloonSize)(ULONG memoryBalloonSize)
1535	{
1536	/* This must match GMMR0Init; currently we only support memory ballooning on all 64-bit hosts except Mac OS X */
1537	#if HC_ARCH_BITS == 64 && (defined(RT_OS_WINDOWS) \|\| defined(RT_OS_SOLARIS) \|\| defined(RT_OS_LINUX) \|\| defined(RT_OS_FREEBSD))
1538	/* check limits */
1539	if (memoryBalloonSize >= VMMDEV_MAX_MEMORY_BALLOON(mHWData->mMemorySize))
1540	return setError(E_INVALIDARG,
1541	tr("Invalid memory balloon size: %lu MB (must be in range [%lu, %lu] MB)"),
1542	memoryBalloonSize, 0, VMMDEV_MAX_MEMORY_BALLOON(mHWData->mMemorySize));
1543
1544	AutoCaller autoCaller(this);
1545	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1546
1547	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1548
1549	setModified(IsModified_MachineData);
1550	mHWData.backup();
1551	mHWData->mMemoryBalloonSize = memoryBalloonSize;
1552
1553	return S_OK;
1554	#else
1555	NOREF(memoryBalloonSize);
1556	return setError(E_NOTIMPL, tr("Memory ballooning is only supported on 64-bit hosts"));
1557	#endif
1558	}
1559
1560	STDMETHODIMP Machine::COMGETTER(PageFusionEnabled) (BOOL *enabled)
1561	{
1562	if (!enabled)
1563	return E_POINTER;
1564
1565	AutoCaller autoCaller(this);
1566	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1567
1568	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1569
1570	*enabled = mHWData->mPageFusionEnabled;
1571	return S_OK;
1572	}
1573
1574	STDMETHODIMP Machine::COMSETTER(PageFusionEnabled) (BOOL enabled)
1575	{
1576	#ifdef VBOX_WITH_PAGE_SHARING
1577	AutoCaller autoCaller(this);
1578	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1579
1580	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1581
1582	/** @todo must support changes for running vms and keep this in sync with IGuest. */
1583	setModified(IsModified_MachineData);
1584	mHWData.backup();
1585	mHWData->mPageFusionEnabled = enabled;
1586	return S_OK;
1587	#else
1588	NOREF(enabled);
1589	return setError(E_NOTIMPL, tr("Page fusion is only supported on 64-bit hosts"));
1590	#endif
1591	}
1592
1593	STDMETHODIMP Machine::COMGETTER(Accelerate3DEnabled)(BOOL *enabled)
1594	{
1595	if (!enabled)
1596	return E_POINTER;
1597
1598	AutoCaller autoCaller(this);
1599	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1600
1601	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1602
1603	*enabled = mHWData->mAccelerate3DEnabled;
1604
1605	return S_OK;
1606	}
1607
1608	STDMETHODIMP Machine::COMSETTER(Accelerate3DEnabled)(BOOL enable)
1609	{
1610	AutoCaller autoCaller(this);
1611	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1612
1613	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1614
1615	HRESULT rc = checkStateDependency(MutableStateDep);
1616	if (FAILED(rc)) return rc;
1617
1618	/** @todo check validity! */
1619
1620	setModified(IsModified_MachineData);
1621	mHWData.backup();
1622	mHWData->mAccelerate3DEnabled = enable;
1623
1624	return S_OK;
1625	}
1626
1627
1628	STDMETHODIMP Machine::COMGETTER(Accelerate2DVideoEnabled)(BOOL *enabled)
1629	{
1630	if (!enabled)
1631	return E_POINTER;
1632
1633	AutoCaller autoCaller(this);
1634	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1635
1636	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1637
1638	*enabled = mHWData->mAccelerate2DVideoEnabled;
1639
1640	return S_OK;
1641	}
1642
1643	STDMETHODIMP Machine::COMSETTER(Accelerate2DVideoEnabled)(BOOL enable)
1644	{
1645	AutoCaller autoCaller(this);
1646	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1647
1648	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1649
1650	HRESULT rc = checkStateDependency(MutableStateDep);
1651	if (FAILED(rc)) return rc;
1652
1653	/** @todo check validity! */
1654
1655	setModified(IsModified_MachineData);
1656	mHWData.backup();
1657	mHWData->mAccelerate2DVideoEnabled = enable;
1658
1659	return S_OK;
1660	}
1661
1662	STDMETHODIMP Machine::COMGETTER(MonitorCount)(ULONG *monitorCount)
1663	{
1664	if (!monitorCount)
1665	return E_POINTER;
1666
1667	AutoCaller autoCaller(this);
1668	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1669
1670	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1671
1672	*monitorCount = mHWData->mMonitorCount;
1673
1674	return S_OK;
1675	}
1676
1677	STDMETHODIMP Machine::COMSETTER(MonitorCount)(ULONG monitorCount)
1678	{
1679	/* make sure monitor count is a sensible number */
1680	if (monitorCount < 1 \|\| monitorCount > SchemaDefs::MaxGuestMonitors)
1681	return setError(E_INVALIDARG,
1682	tr("Invalid monitor count: %lu (must be in range [%lu, %lu])"),
1683	monitorCount, 1, SchemaDefs::MaxGuestMonitors);
1684
1685	AutoCaller autoCaller(this);
1686	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1687
1688	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1689
1690	HRESULT rc = checkStateDependency(MutableStateDep);
1691	if (FAILED(rc)) return rc;
1692
1693	setModified(IsModified_MachineData);
1694	mHWData.backup();
1695	mHWData->mMonitorCount = monitorCount;
1696
1697	return S_OK;
1698	}
1699
1700	STDMETHODIMP Machine::COMGETTER(BIOSSettings)(IBIOSSettings **biosSettings)
1701	{
1702	if (!biosSettings)
1703	return E_POINTER;
1704
1705	AutoCaller autoCaller(this);
1706	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1707
1708	/* mBIOSSettings is constant during life time, no need to lock */
1709	mBIOSSettings.queryInterfaceTo(biosSettings);
1710
1711	return S_OK;
1712	}
1713
1714	STDMETHODIMP Machine::GetCPUProperty(CPUPropertyType_T property, BOOL *aVal)
1715	{
1716	if (!aVal)
1717	return E_POINTER;
1718
1719	AutoCaller autoCaller(this);
1720	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1721
1722	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1723
1724	switch(property)
1725	{
1726	case CPUPropertyType_PAE:
1727	*aVal = mHWData->mPAEEnabled;
1728	break;
1729
1730	case CPUPropertyType_Synthetic:
1731	*aVal = mHWData->mSyntheticCpu;
1732	break;
1733
1734	default:
1735	return E_INVALIDARG;
1736	}
1737	return S_OK;
1738	}
1739
1740	STDMETHODIMP Machine::SetCPUProperty(CPUPropertyType_T property, BOOL aVal)
1741	{
1742	AutoCaller autoCaller(this);
1743	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1744
1745	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1746
1747	HRESULT rc = checkStateDependency(MutableStateDep);
1748	if (FAILED(rc)) return rc;
1749
1750	switch(property)
1751	{
1752	case CPUPropertyType_PAE:
1753	setModified(IsModified_MachineData);
1754	mHWData.backup();
1755	mHWData->mPAEEnabled = !!aVal;
1756	break;
1757
1758	case CPUPropertyType_Synthetic:
1759	setModified(IsModified_MachineData);
1760	mHWData.backup();
1761	mHWData->mSyntheticCpu = !!aVal;
1762	break;
1763
1764	default:
1765	return E_INVALIDARG;
1766	}
1767	return S_OK;
1768	}
1769
1770	STDMETHODIMP Machine::GetCPUIDLeaf(ULONG aId, ULONG aValEax, ULONG aValEbx, ULONG aValEcx, ULONG aValEdx)
1771	{
1772	CheckComArgOutPointerValid(aValEax);
1773	CheckComArgOutPointerValid(aValEbx);
1774	CheckComArgOutPointerValid(aValEcx);
1775	CheckComArgOutPointerValid(aValEdx);
1776
1777	AutoCaller autoCaller(this);
1778	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1779
1780	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1781
1782	switch(aId)
1783	{
1784	case 0x0:
1785	case 0x1:
1786	case 0x2:
1787	case 0x3:
1788	case 0x4:
1789	case 0x5:
1790	case 0x6:
1791	case 0x7:
1792	case 0x8:
1793	case 0x9:
1794	case 0xA:
1795	if (mHWData->mCpuIdStdLeafs[aId].ulId != aId)
1796	return setError(E_INVALIDARG, tr("CpuId override leaf %#x is not set"), aId);
1797
1798	*aValEax = mHWData->mCpuIdStdLeafs[aId].ulEax;
1799	*aValEbx = mHWData->mCpuIdStdLeafs[aId].ulEbx;
1800	*aValEcx = mHWData->mCpuIdStdLeafs[aId].ulEcx;
1801	*aValEdx = mHWData->mCpuIdStdLeafs[aId].ulEdx;
1802	break;
1803
1804	case 0x80000000:
1805	case 0x80000001:
1806	case 0x80000002:
1807	case 0x80000003:
1808	case 0x80000004:
1809	case 0x80000005:
1810	case 0x80000006:
1811	case 0x80000007:
1812	case 0x80000008:
1813	case 0x80000009:
1814	case 0x8000000A:
1815	if (mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulId != aId)
1816	return setError(E_INVALIDARG, tr("CpuId override leaf %#x is not set"), aId);
1817
1818	*aValEax = mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEax;
1819	*aValEbx = mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEbx;
1820	*aValEcx = mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEcx;
1821	*aValEdx = mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEdx;
1822	break;
1823
1824	default:
1825	return setError(E_INVALIDARG, tr("CpuId override leaf %#x is out of range"), aId);
1826	}
1827	return S_OK;
1828	}
1829
1830	STDMETHODIMP Machine::SetCPUIDLeaf(ULONG aId, ULONG aValEax, ULONG aValEbx, ULONG aValEcx, ULONG aValEdx)
1831	{
1832	AutoCaller autoCaller(this);
1833	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1834
1835	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1836
1837	HRESULT rc = checkStateDependency(MutableStateDep);
1838	if (FAILED(rc)) return rc;
1839
1840	switch(aId)
1841	{
1842	case 0x0:
1843	case 0x1:
1844	case 0x2:
1845	case 0x3:
1846	case 0x4:
1847	case 0x5:
1848	case 0x6:
1849	case 0x7:
1850	case 0x8:
1851	case 0x9:
1852	case 0xA:
1853	AssertCompile(RT_ELEMENTS(mHWData->mCpuIdStdLeafs) == 0xA);
1854	AssertRelease(aId < RT_ELEMENTS(mHWData->mCpuIdStdLeafs));
1855	setModified(IsModified_MachineData);
1856	mHWData.backup();
1857	mHWData->mCpuIdStdLeafs[aId].ulId = aId;
1858	mHWData->mCpuIdStdLeafs[aId].ulEax = aValEax;
1859	mHWData->mCpuIdStdLeafs[aId].ulEbx = aValEbx;
1860	mHWData->mCpuIdStdLeafs[aId].ulEcx = aValEcx;
1861	mHWData->mCpuIdStdLeafs[aId].ulEdx = aValEdx;
1862	break;
1863
1864	case 0x80000000:
1865	case 0x80000001:
1866	case 0x80000002:
1867	case 0x80000003:
1868	case 0x80000004:
1869	case 0x80000005:
1870	case 0x80000006:
1871	case 0x80000007:
1872	case 0x80000008:
1873	case 0x80000009:
1874	case 0x8000000A:
1875	AssertCompile(RT_ELEMENTS(mHWData->mCpuIdExtLeafs) == 0xA);
1876	AssertRelease(aId - 0x80000000 < RT_ELEMENTS(mHWData->mCpuIdExtLeafs));
1877	setModified(IsModified_MachineData);
1878	mHWData.backup();
1879	mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulId = aId;
1880	mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEax = aValEax;
1881	mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEbx = aValEbx;
1882	mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEcx = aValEcx;
1883	mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEdx = aValEdx;
1884	break;
1885
1886	default:
1887	return setError(E_INVALIDARG, tr("CpuId override leaf %#x is out of range"), aId);
1888	}
1889	return S_OK;
1890	}
1891
1892	STDMETHODIMP Machine::RemoveCPUIDLeaf(ULONG aId)
1893	{
1894	AutoCaller autoCaller(this);
1895	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1896
1897	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1898
1899	HRESULT rc = checkStateDependency(MutableStateDep);
1900	if (FAILED(rc)) return rc;
1901
1902	switch(aId)
1903	{
1904	case 0x0:
1905	case 0x1:
1906	case 0x2:
1907	case 0x3:
1908	case 0x4:
1909	case 0x5:
1910	case 0x6:
1911	case 0x7:
1912	case 0x8:
1913	case 0x9:
1914	case 0xA:
1915	AssertCompile(RT_ELEMENTS(mHWData->mCpuIdStdLeafs) == 0xA);
1916	AssertRelease(aId < RT_ELEMENTS(mHWData->mCpuIdStdLeafs));
1917	setModified(IsModified_MachineData);
1918	mHWData.backup();
1919	/* Invalidate leaf. */
1920	mHWData->mCpuIdStdLeafs[aId].ulId = UINT32_MAX;
1921	break;
1922
1923	case 0x80000000:
1924	case 0x80000001:
1925	case 0x80000002:
1926	case 0x80000003:
1927	case 0x80000004:
1928	case 0x80000005:
1929	case 0x80000006:
1930	case 0x80000007:
1931	case 0x80000008:
1932	case 0x80000009:
1933	case 0x8000000A:
1934	AssertCompile(RT_ELEMENTS(mHWData->mCpuIdExtLeafs) == 0xA);
1935	AssertRelease(aId - 0x80000000 < RT_ELEMENTS(mHWData->mCpuIdExtLeafs));
1936	setModified(IsModified_MachineData);
1937	mHWData.backup();
1938	/* Invalidate leaf. */
1939	mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulId = UINT32_MAX;
1940	break;
1941
1942	default:
1943	return setError(E_INVALIDARG, tr("CpuId override leaf %#x is out of range"), aId);
1944	}
1945	return S_OK;
1946	}
1947
1948	STDMETHODIMP Machine::RemoveAllCPUIDLeaves()
1949	{
1950	AutoCaller autoCaller(this);
1951	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1952
1953	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1954
1955	HRESULT rc = checkStateDependency(MutableStateDep);
1956	if (FAILED(rc)) return rc;
1957
1958	setModified(IsModified_MachineData);
1959	mHWData.backup();
1960
1961	/* Invalidate all standard leafs. */
1962	for (unsigned i = 0; i < RT_ELEMENTS(mHWData->mCpuIdStdLeafs); i++)
1963	mHWData->mCpuIdStdLeafs[i].ulId = UINT32_MAX;
1964
1965	/* Invalidate all extended leafs. */
1966	for (unsigned i = 0; i < RT_ELEMENTS(mHWData->mCpuIdExtLeafs); i++)
1967	mHWData->mCpuIdExtLeafs[i].ulId = UINT32_MAX;
1968
1969	return S_OK;
1970	}
1971
1972	STDMETHODIMP Machine::GetHWVirtExProperty(HWVirtExPropertyType_T property, BOOL *aVal)
1973	{
1974	if (!aVal)
1975	return E_POINTER;
1976
1977	AutoCaller autoCaller(this);
1978	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1979
1980	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1981
1982	switch(property)
1983	{
1984	case HWVirtExPropertyType_Enabled:
1985	*aVal = mHWData->mHWVirtExEnabled;
1986	break;
1987
1988	case HWVirtExPropertyType_Exclusive:
1989	*aVal = mHWData->mHWVirtExExclusive;
1990	break;
1991
1992	case HWVirtExPropertyType_VPID:
1993	*aVal = mHWData->mHWVirtExVPIDEnabled;
1994	break;
1995
1996	case HWVirtExPropertyType_NestedPaging:
1997	*aVal = mHWData->mHWVirtExNestedPagingEnabled;
1998	break;
1999
2000	case HWVirtExPropertyType_LargePages:
2001	*aVal = mHWData->mHWVirtExLargePagesEnabled;
2002	break;
2003
2004	case HWVirtExPropertyType_Force:
2005	*aVal = mHWData->mHWVirtExForceEnabled;
2006	break;
2007
2008	default:
2009	return E_INVALIDARG;
2010	}
2011	return S_OK;
2012	}
2013
2014	STDMETHODIMP Machine::SetHWVirtExProperty(HWVirtExPropertyType_T property, BOOL aVal)
2015	{
2016	AutoCaller autoCaller(this);
2017	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2018
2019	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2020
2021	HRESULT rc = checkStateDependency(MutableStateDep);
2022	if (FAILED(rc)) return rc;
2023
2024	switch(property)
2025	{
2026	case HWVirtExPropertyType_Enabled:
2027	setModified(IsModified_MachineData);
2028	mHWData.backup();
2029	mHWData->mHWVirtExEnabled = !!aVal;
2030	break;
2031
2032	case HWVirtExPropertyType_Exclusive:
2033	setModified(IsModified_MachineData);
2034	mHWData.backup();
2035	mHWData->mHWVirtExExclusive = !!aVal;
2036	break;
2037
2038	case HWVirtExPropertyType_VPID:
2039	setModified(IsModified_MachineData);
2040	mHWData.backup();
2041	mHWData->mHWVirtExVPIDEnabled = !!aVal;
2042	break;
2043
2044	case HWVirtExPropertyType_NestedPaging:
2045	setModified(IsModified_MachineData);
2046	mHWData.backup();
2047	mHWData->mHWVirtExNestedPagingEnabled = !!aVal;
2048	break;
2049
2050	case HWVirtExPropertyType_LargePages:
2051	setModified(IsModified_MachineData);
2052	mHWData.backup();
2053	mHWData->mHWVirtExLargePagesEnabled = !!aVal;
2054	break;
2055
2056	case HWVirtExPropertyType_Force:
2057	setModified(IsModified_MachineData);
2058	mHWData.backup();
2059	mHWData->mHWVirtExForceEnabled = !!aVal;
2060	break;
2061
2062	default:
2063	return E_INVALIDARG;
2064	}
2065
2066	return S_OK;
2067	}
2068
2069	STDMETHODIMP Machine::COMGETTER(SnapshotFolder)(BSTR *aSnapshotFolder)
2070	{
2071	CheckComArgOutPointerValid(aSnapshotFolder);
2072
2073	AutoCaller autoCaller(this);
2074	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2075
2076	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2077
2078	mUserData->m_strSnapshotFolderFull.cloneTo(aSnapshotFolder);
2079
2080	return S_OK;
2081	}
2082
2083	STDMETHODIMP Machine::COMSETTER(SnapshotFolder)(IN_BSTR aSnapshotFolder)
2084	{
2085	/* @todo (r=dmik):
2086	* 1. Allow to change the name of the snapshot folder containing snapshots
2087	* 2. Rename the folder on disk instead of just changing the property
2088	* value (to be smart and not to leave garbage). Note that it cannot be
2089	* done here because the change may be rolled back. Thus, the right
2090	* place is #saveSettings().
2091	*/
2092
2093	AutoCaller autoCaller(this);
2094	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2095
2096	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2097
2098	HRESULT rc = checkStateDependency(MutableStateDep);
2099	if (FAILED(rc)) return rc;
2100
2101	if (!mData->mCurrentSnapshot.isNull())
2102	return setError(E_FAIL,
2103	tr("The snapshot folder of a machine with snapshots cannot be changed (please delete all snapshots first)"));
2104
2105	Utf8Str strSnapshotFolder0(aSnapshotFolder); // keep original
2106	Utf8Str strSnapshotFolder(strSnapshotFolder0);
2107
2108	if (strSnapshotFolder.isEmpty())
2109	{
2110	if (isInOwnDir())
2111	/* the default snapshots folder is 'Snapshots' in the machine dir */
2112	strSnapshotFolder = "Snapshots";
2113	else
2114	/* the default snapshots folder is {UUID}, for backwards
2115	* compatibility and to resolve conflicts */
2116	strSnapshotFolder = Utf8StrFmt("{%RTuuid}", mData->mUuid.raw());
2117	}
2118
2119	int vrc = calculateFullPath(strSnapshotFolder, strSnapshotFolder);
2120	if (RT_FAILURE(vrc))
2121	return setError(E_FAIL,
2122	tr("Invalid snapshot folder '%ls' (%Rrc)"),
2123	aSnapshotFolder, vrc);
2124
2125	setModified(IsModified_MachineData);
2126	mUserData.backup();
2127	mUserData->s.strSnapshotFolder = strSnapshotFolder0;
2128	mUserData->m_strSnapshotFolderFull = strSnapshotFolder;
2129
2130	return S_OK;
2131	}
2132
2133	STDMETHODIMP Machine::COMGETTER(MediumAttachments)(ComSafeArrayOut(IMediumAttachment*, aAttachments))
2134	{
2135	if (ComSafeArrayOutIsNull(aAttachments))
2136	return E_POINTER;
2137
2138	AutoCaller autoCaller(this);
2139	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2140
2141	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2142
2143	SafeIfaceArray<IMediumAttachment> attachments(mMediaData->mAttachments);
2144	attachments.detachTo(ComSafeArrayOutArg(aAttachments));
2145
2146	return S_OK;
2147	}
2148
2149	STDMETHODIMP Machine::COMGETTER(VRDPServer)(IVRDPServer **vrdpServer)
2150	{
2151	#ifdef VBOX_WITH_VRDP
2152	if (!vrdpServer)
2153	return E_POINTER;
2154
2155	AutoCaller autoCaller(this);
2156	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2157
2158	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2159
2160	Assert(!!mVRDPServer);
2161	mVRDPServer.queryInterfaceTo(vrdpServer);
2162
2163	return S_OK;
2164	#else
2165	NOREF(vrdpServer);
2166	ReturnComNotImplemented();
2167	#endif
2168	}
2169
2170	STDMETHODIMP Machine::COMGETTER(AudioAdapter)(IAudioAdapter **audioAdapter)
2171	{
2172	if (!audioAdapter)
2173	return E_POINTER;
2174
2175	AutoCaller autoCaller(this);
2176	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2177
2178	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2179
2180	mAudioAdapter.queryInterfaceTo(audioAdapter);
2181	return S_OK;
2182	}
2183
2184	STDMETHODIMP Machine::COMGETTER(USBController)(IUSBController **aUSBController)
2185	{
2186	#ifdef VBOX_WITH_VUSB
2187	CheckComArgOutPointerValid(aUSBController);
2188
2189	AutoCaller autoCaller(this);
2190	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2191	MultiResult rc(S_OK);
2192
2193	# ifdef VBOX_WITH_USB
2194	rc = mParent->host()->checkUSBProxyService();
2195	if (FAILED(rc)) return rc;
2196	# endif
2197
2198	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2199
2200	return rc = mUSBController.queryInterfaceTo(aUSBController);
2201	#else
2202	/* Note: The GUI depends on this method returning E_NOTIMPL with no
2203	* extended error info to indicate that USB is simply not available
2204	* (w/o treting it as a failure), for example, as in OSE */
2205	NOREF(aUSBController);
2206	ReturnComNotImplemented();
2207	#endif /* VBOX_WITH_VUSB */
2208	}
2209
2210	STDMETHODIMP Machine::COMGETTER(SettingsFilePath)(BSTR *aFilePath)
2211	{
2212	CheckComArgOutPointerValid(aFilePath);
2213
2214	AutoLimitedCaller autoCaller(this);
2215	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2216
2217	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2218
2219	mData->m_strConfigFileFull.cloneTo(aFilePath);
2220	return S_OK;
2221	}
2222
2223	STDMETHODIMP Machine::COMGETTER(SettingsModified)(BOOL *aModified)
2224	{
2225	CheckComArgOutPointerValid(aModified);
2226
2227	AutoCaller autoCaller(this);
2228	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2229
2230	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2231
2232	HRESULT rc = checkStateDependency(MutableStateDep);
2233	if (FAILED(rc)) return rc;
2234
2235	if (!mData->pMachineConfigFile->fileExists())
2236	// this is a new machine, and no config file exists yet:
2237	*aModified = TRUE;
2238	else
2239	*aModified = (mData->flModifications != 0);
2240
2241	return S_OK;
2242	}
2243
2244	STDMETHODIMP Machine::COMGETTER(SessionState)(SessionState_T *aSessionState)
2245	{
2246	CheckComArgOutPointerValid(aSessionState);
2247
2248	AutoCaller autoCaller(this);
2249	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2250
2251	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2252
2253	*aSessionState = mData->mSession.mState;
2254
2255	return S_OK;
2256	}
2257
2258	STDMETHODIMP Machine::COMGETTER(SessionType)(BSTR *aSessionType)
2259	{
2260	CheckComArgOutPointerValid(aSessionType);
2261
2262	AutoCaller autoCaller(this);
2263	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2264
2265	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2266
2267	mData->mSession.mType.cloneTo(aSessionType);
2268
2269	return S_OK;
2270	}
2271
2272	STDMETHODIMP Machine::COMGETTER(SessionPid)(ULONG *aSessionPid)
2273	{
2274	CheckComArgOutPointerValid(aSessionPid);
2275
2276	AutoCaller autoCaller(this);
2277	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2278
2279	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2280
2281	*aSessionPid = mData->mSession.mPid;
2282
2283	return S_OK;
2284	}
2285
2286	STDMETHODIMP Machine::COMGETTER(State)(MachineState_T *machineState)
2287	{
2288	if (!machineState)
2289	return E_POINTER;
2290
2291	AutoCaller autoCaller(this);
2292	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2293
2294	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2295
2296	*machineState = mData->mMachineState;
2297
2298	return S_OK;
2299	}
2300
2301	STDMETHODIMP Machine::COMGETTER(LastStateChange)(LONG64 *aLastStateChange)
2302	{
2303	CheckComArgOutPointerValid(aLastStateChange);
2304
2305	AutoCaller autoCaller(this);
2306	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2307
2308	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2309
2310	*aLastStateChange = RTTimeSpecGetMilli(&mData->mLastStateChange);
2311
2312	return S_OK;
2313	}
2314
2315	STDMETHODIMP Machine::COMGETTER(StateFilePath)(BSTR *aStateFilePath)
2316	{
2317	CheckComArgOutPointerValid(aStateFilePath);
2318
2319	AutoCaller autoCaller(this);
2320	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2321
2322	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2323
2324	mSSData->mStateFilePath.cloneTo(aStateFilePath);
2325
2326	return S_OK;
2327	}
2328
2329	STDMETHODIMP Machine::COMGETTER(LogFolder)(BSTR *aLogFolder)
2330	{
2331	CheckComArgOutPointerValid(aLogFolder);
2332
2333	AutoCaller autoCaller(this);
2334	AssertComRCReturnRC(autoCaller.rc());
2335
2336	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2337
2338	Utf8Str logFolder;
2339	getLogFolder(logFolder);
2340
2341	Bstr (logFolder).cloneTo(aLogFolder);
2342
2343	return S_OK;
2344	}
2345
2346	STDMETHODIMP Machine::COMGETTER(CurrentSnapshot) (ISnapshot **aCurrentSnapshot)
2347	{
2348	CheckComArgOutPointerValid(aCurrentSnapshot);
2349
2350	AutoCaller autoCaller(this);
2351	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2352
2353	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2354
2355	mData->mCurrentSnapshot.queryInterfaceTo(aCurrentSnapshot);
2356
2357	return S_OK;
2358	}
2359
2360	STDMETHODIMP Machine::COMGETTER(SnapshotCount)(ULONG *aSnapshotCount)
2361	{
2362	CheckComArgOutPointerValid(aSnapshotCount);
2363
2364	AutoCaller autoCaller(this);
2365	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2366
2367	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2368
2369	*aSnapshotCount = mData->mFirstSnapshot.isNull()
2370	? 0
2371	: mData->mFirstSnapshot->getAllChildrenCount() + 1;
2372
2373	return S_OK;
2374	}
2375
2376	STDMETHODIMP Machine::COMGETTER(CurrentStateModified)(BOOL *aCurrentStateModified)
2377	{
2378	CheckComArgOutPointerValid(aCurrentStateModified);
2379
2380	AutoCaller autoCaller(this);
2381	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2382
2383	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2384
2385	/* Note: for machines with no snapshots, we always return FALSE
2386	* (mData->mCurrentStateModified will be TRUE in this case, for historical
2387	* reasons :) */
2388
2389	*aCurrentStateModified = mData->mFirstSnapshot.isNull()
2390	? FALSE
2391	: mData->mCurrentStateModified;
2392
2393	return S_OK;
2394	}
2395
2396	STDMETHODIMP Machine::COMGETTER(SharedFolders)(ComSafeArrayOut(ISharedFolder *, aSharedFolders))
2397	{
2398	CheckComArgOutSafeArrayPointerValid(aSharedFolders);
2399
2400	AutoCaller autoCaller(this);
2401	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2402
2403	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2404
2405	SafeIfaceArray<ISharedFolder> folders(mHWData->mSharedFolders);
2406	folders.detachTo(ComSafeArrayOutArg(aSharedFolders));
2407
2408	return S_OK;
2409	}
2410
2411	STDMETHODIMP Machine::COMGETTER(ClipboardMode)(ClipboardMode_T *aClipboardMode)
2412	{
2413	CheckComArgOutPointerValid(aClipboardMode);
2414
2415	AutoCaller autoCaller(this);
2416	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2417
2418	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2419
2420	*aClipboardMode = mHWData->mClipboardMode;
2421
2422	return S_OK;
2423	}
2424
2425	STDMETHODIMP
2426	Machine::COMSETTER(ClipboardMode)(ClipboardMode_T aClipboardMode)
2427	{
2428	AutoCaller autoCaller(this);
2429	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2430
2431	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2432
2433	HRESULT rc = checkStateDependency(MutableStateDep);
2434	if (FAILED(rc)) return rc;
2435
2436	setModified(IsModified_MachineData);
2437	mHWData.backup();
2438	mHWData->mClipboardMode = aClipboardMode;
2439
2440	return S_OK;
2441	}
2442
2443	STDMETHODIMP
2444	Machine::COMGETTER(GuestPropertyNotificationPatterns)(BSTR *aPatterns)
2445	{
2446	CheckComArgOutPointerValid(aPatterns);
2447
2448	AutoCaller autoCaller(this);
2449	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2450
2451	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2452
2453	try
2454	{
2455	mHWData->mGuestPropertyNotificationPatterns.cloneTo(aPatterns);
2456	}
2457	catch (...)
2458	{
2459	return VirtualBox::handleUnexpectedExceptions(RT_SRC_POS);
2460	}
2461
2462	return S_OK;
2463	}
2464
2465	STDMETHODIMP
2466	Machine::COMSETTER(GuestPropertyNotificationPatterns)(IN_BSTR aPatterns)
2467	{
2468	AutoCaller autoCaller(this);
2469	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2470
2471	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2472
2473	HRESULT rc = checkStateDependency(MutableStateDep);
2474	if (FAILED(rc)) return rc;
2475
2476	setModified(IsModified_MachineData);
2477	mHWData.backup();
2478	mHWData->mGuestPropertyNotificationPatterns = aPatterns;
2479	return rc;
2480	}
2481
2482	STDMETHODIMP
2483	Machine::COMGETTER(StorageControllers)(ComSafeArrayOut(IStorageController *, aStorageControllers))
2484	{
2485	CheckComArgOutSafeArrayPointerValid(aStorageControllers);
2486
2487	AutoCaller autoCaller(this);
2488	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2489
2490	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2491
2492	SafeIfaceArray<IStorageController> ctrls(*mStorageControllers.data());
2493	ctrls.detachTo(ComSafeArrayOutArg(aStorageControllers));
2494
2495	return S_OK;
2496	}
2497
2498	STDMETHODIMP
2499	Machine::COMGETTER(TeleporterEnabled)(BOOL *aEnabled)
2500	{
2501	CheckComArgOutPointerValid(aEnabled);
2502
2503	AutoCaller autoCaller(this);
2504	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2505
2506	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2507
2508	*aEnabled = mUserData->s.fTeleporterEnabled;
2509
2510	return S_OK;
2511	}
2512
2513	STDMETHODIMP Machine::COMSETTER(TeleporterEnabled)(BOOL aEnabled)
2514	{
2515	AutoCaller autoCaller(this);
2516	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2517
2518	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2519
2520	/* Only allow it to be set to true when PoweredOff or Aborted.
2521	(Clearing it is always permitted.) */
2522	if ( aEnabled
2523	&& mData->mRegistered
2524	&& ( !isSessionMachine()
2525	\|\| ( mData->mMachineState != MachineState_PoweredOff
2526	&& mData->mMachineState != MachineState_Teleported
2527	&& mData->mMachineState != MachineState_Aborted
2528	)
2529	)
2530	)
2531	return setError(VBOX_E_INVALID_VM_STATE,
2532	tr("The machine is not powered off (state is %s)"),
2533	Global::stringifyMachineState(mData->mMachineState));
2534
2535	setModified(IsModified_MachineData);
2536	mUserData.backup();
2537	mUserData->s.fTeleporterEnabled = !!aEnabled;
2538
2539	return S_OK;
2540	}
2541
2542	STDMETHODIMP Machine::COMGETTER(TeleporterPort)(ULONG *aPort)
2543	{
2544	CheckComArgOutPointerValid(aPort);
2545
2546	AutoCaller autoCaller(this);
2547	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2548
2549	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2550
2551	*aPort = (ULONG)mUserData->s.uTeleporterPort;
2552
2553	return S_OK;
2554	}
2555
2556	STDMETHODIMP Machine::COMSETTER(TeleporterPort)(ULONG aPort)
2557	{
2558	if (aPort >= _64K)
2559	return setError(E_INVALIDARG, tr("Invalid port number %d"), aPort);
2560
2561	AutoCaller autoCaller(this);
2562	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2563
2564	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2565
2566	HRESULT rc = checkStateDependency(MutableStateDep);
2567	if (FAILED(rc)) return rc;
2568
2569	setModified(IsModified_MachineData);
2570	mUserData.backup();
2571	mUserData->s.uTeleporterPort = (uint32_t)aPort;
2572
2573	return S_OK;
2574	}
2575
2576	STDMETHODIMP Machine::COMGETTER(TeleporterAddress)(BSTR *aAddress)
2577	{
2578	CheckComArgOutPointerValid(aAddress);
2579
2580	AutoCaller autoCaller(this);
2581	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2582
2583	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2584
2585	mUserData->s.strTeleporterAddress.cloneTo(aAddress);
2586
2587	return S_OK;
2588	}
2589
2590	STDMETHODIMP Machine::COMSETTER(TeleporterAddress)(IN_BSTR aAddress)
2591	{
2592	AutoCaller autoCaller(this);
2593	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2594
2595	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2596
2597	HRESULT rc = checkStateDependency(MutableStateDep);
2598	if (FAILED(rc)) return rc;
2599
2600	setModified(IsModified_MachineData);
2601	mUserData.backup();
2602	mUserData->s.strTeleporterAddress = aAddress;
2603
2604	return S_OK;
2605	}
2606
2607	STDMETHODIMP Machine::COMGETTER(TeleporterPassword)(BSTR *aPassword)
2608	{
2609	CheckComArgOutPointerValid(aPassword);
2610
2611	AutoCaller autoCaller(this);
2612	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2613
2614	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2615
2616	mUserData->s.strTeleporterPassword.cloneTo(aPassword);
2617
2618	return S_OK;
2619	}
2620
2621	STDMETHODIMP Machine::COMSETTER(TeleporterPassword)(IN_BSTR aPassword)
2622	{
2623	AutoCaller autoCaller(this);
2624	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2625
2626	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2627
2628	HRESULT rc = checkStateDependency(MutableStateDep);
2629	if (FAILED(rc)) return rc;
2630
2631	setModified(IsModified_MachineData);
2632	mUserData.backup();
2633	mUserData->s.strTeleporterPassword = aPassword;
2634
2635	return S_OK;
2636	}
2637
2638	STDMETHODIMP Machine::COMGETTER(FaultToleranceState)(FaultToleranceState_T *aState)
2639	{
2640	CheckComArgOutPointerValid(aState);
2641
2642	AutoCaller autoCaller(this);
2643	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2644
2645	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2646
2647	*aState = mUserData->s.enmFaultToleranceState;
2648	return S_OK;
2649	}
2650
2651	STDMETHODIMP Machine::COMSETTER(FaultToleranceState)(FaultToleranceState_T aState)
2652	{
2653	AutoCaller autoCaller(this);
2654	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2655
2656	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2657
2658	/* @todo deal with running state change. */
2659	HRESULT rc = checkStateDependency(MutableStateDep);
2660	if (FAILED(rc)) return rc;
2661
2662	setModified(IsModified_MachineData);
2663	mUserData.backup();
2664	mUserData->s.enmFaultToleranceState = aState;
2665	return S_OK;
2666	}
2667
2668	STDMETHODIMP Machine::COMGETTER(FaultToleranceAddress)(BSTR *aAddress)
2669	{
2670	CheckComArgOutPointerValid(aAddress);
2671
2672	AutoCaller autoCaller(this);
2673	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2674
2675	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2676
2677	mUserData->s.strFaultToleranceAddress.cloneTo(aAddress);
2678	return S_OK;
2679	}
2680
2681	STDMETHODIMP Machine::COMSETTER(FaultToleranceAddress)(IN_BSTR aAddress)
2682	{
2683	AutoCaller autoCaller(this);
2684	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2685
2686	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2687
2688	/* @todo deal with running state change. */
2689	HRESULT rc = checkStateDependency(MutableStateDep);
2690	if (FAILED(rc)) return rc;
2691
2692	setModified(IsModified_MachineData);
2693	mUserData.backup();
2694	mUserData->s.strFaultToleranceAddress = aAddress;
2695	return S_OK;
2696	}
2697
2698	STDMETHODIMP Machine::COMGETTER(FaultTolerancePort)(ULONG *aPort)
2699	{
2700	CheckComArgOutPointerValid(aPort);
2701
2702	AutoCaller autoCaller(this);
2703	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2704
2705	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2706
2707	*aPort = mUserData->s.uFaultTolerancePort;
2708	return S_OK;
2709	}
2710
2711	STDMETHODIMP Machine::COMSETTER(FaultTolerancePort)(ULONG aPort)
2712	{
2713	AutoCaller autoCaller(this);
2714	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2715
2716	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2717
2718	/* @todo deal with running state change. */
2719	HRESULT rc = checkStateDependency(MutableStateDep);
2720	if (FAILED(rc)) return rc;
2721
2722	setModified(IsModified_MachineData);
2723	mUserData.backup();
2724	mUserData->s.uFaultTolerancePort = aPort;
2725	return S_OK;
2726	}
2727
2728	STDMETHODIMP Machine::COMGETTER(FaultTolerancePassword)(BSTR *aPassword)
2729	{
2730	CheckComArgOutPointerValid(aPassword);
2731
2732	AutoCaller autoCaller(this);
2733	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2734
2735	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2736
2737	mUserData->s.strFaultTolerancePassword.cloneTo(aPassword);
2738
2739	return S_OK;
2740	}
2741
2742	STDMETHODIMP Machine::COMSETTER(FaultTolerancePassword)(IN_BSTR aPassword)
2743	{
2744	AutoCaller autoCaller(this);
2745	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2746
2747	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2748
2749	/* @todo deal with running state change. */
2750	HRESULT rc = checkStateDependency(MutableStateDep);
2751	if (FAILED(rc)) return rc;
2752
2753	setModified(IsModified_MachineData);
2754	mUserData.backup();
2755	mUserData->s.strFaultTolerancePassword = aPassword;
2756
2757	return S_OK;
2758	}
2759
2760	STDMETHODIMP Machine::COMGETTER(FaultToleranceSyncInterval)(ULONG *aInterval)
2761	{
2762	CheckComArgOutPointerValid(aInterval);
2763
2764	AutoCaller autoCaller(this);
2765	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2766
2767	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2768
2769	*aInterval = mUserData->s.uFaultToleranceInterval;
2770	return S_OK;
2771	}
2772
2773	STDMETHODIMP Machine::COMSETTER(FaultToleranceSyncInterval)(ULONG aInterval)
2774	{
2775	AutoCaller autoCaller(this);
2776	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2777
2778	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2779
2780	/* @todo deal with running state change. */
2781	HRESULT rc = checkStateDependency(MutableStateDep);
2782	if (FAILED(rc)) return rc;
2783
2784	setModified(IsModified_MachineData);
2785	mUserData.backup();
2786	mUserData->s.uFaultToleranceInterval = aInterval;
2787	return S_OK;
2788	}
2789
2790	STDMETHODIMP Machine::COMGETTER(RTCUseUTC)(BOOL *aEnabled)
2791	{
2792	CheckComArgOutPointerValid(aEnabled);
2793
2794	AutoCaller autoCaller(this);
2795	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2796
2797	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2798
2799	*aEnabled = mUserData->s.fRTCUseUTC;
2800
2801	return S_OK;
2802	}
2803
2804	STDMETHODIMP Machine::COMSETTER(RTCUseUTC)(BOOL aEnabled)
2805	{
2806	AutoCaller autoCaller(this);
2807	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2808
2809	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2810
2811	/* Only allow it to be set to true when PoweredOff or Aborted.
2812	(Clearing it is always permitted.) */
2813	if ( aEnabled
2814	&& mData->mRegistered
2815	&& ( !isSessionMachine()
2816	\|\| ( mData->mMachineState != MachineState_PoweredOff
2817	&& mData->mMachineState != MachineState_Teleported
2818	&& mData->mMachineState != MachineState_Aborted
2819	)
2820	)
2821	)
2822	return setError(VBOX_E_INVALID_VM_STATE,
2823	tr("The machine is not powered off (state is %s)"),
2824	Global::stringifyMachineState(mData->mMachineState));
2825
2826	setModified(IsModified_MachineData);
2827	mUserData.backup();
2828	mUserData->s.fRTCUseUTC = !!aEnabled;
2829
2830	return S_OK;
2831	}
2832
2833	STDMETHODIMP Machine::COMGETTER(IoCacheEnabled)(BOOL *aEnabled)
2834	{
2835	CheckComArgOutPointerValid(aEnabled);
2836
2837	AutoCaller autoCaller(this);
2838	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2839
2840	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2841
2842	*aEnabled = mHWData->mIoCacheEnabled;
2843
2844	return S_OK;
2845	}
2846
2847	STDMETHODIMP Machine::COMSETTER(IoCacheEnabled)(BOOL aEnabled)
2848	{
2849	AutoCaller autoCaller(this);
2850	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2851
2852	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2853
2854	HRESULT rc = checkStateDependency(MutableStateDep);
2855	if (FAILED(rc)) return rc;
2856
2857	setModified(IsModified_MachineData);
2858	mHWData.backup();
2859	mHWData->mIoCacheEnabled = aEnabled;
2860
2861	return S_OK;
2862	}
2863
2864	STDMETHODIMP Machine::COMGETTER(IoCacheSize)(ULONG *aIoCacheSize)
2865	{
2866	CheckComArgOutPointerValid(aIoCacheSize);
2867
2868	AutoCaller autoCaller(this);
2869	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2870
2871	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2872
2873	*aIoCacheSize = mHWData->mIoCacheSize;
2874
2875	return S_OK;
2876	}
2877
2878	STDMETHODIMP Machine::COMSETTER(IoCacheSize)(ULONG aIoCacheSize)
2879	{
2880	AutoCaller autoCaller(this);
2881	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2882
2883	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2884
2885	HRESULT rc = checkStateDependency(MutableStateDep);
2886	if (FAILED(rc)) return rc;
2887
2888	setModified(IsModified_MachineData);
2889	mHWData.backup();
2890	mHWData->mIoCacheSize = aIoCacheSize;
2891
2892	return S_OK;
2893	}
2894
2895
2896	/**
2897	* @note Locks objects!
2898	*/
2899	STDMETHODIMP Machine::LockMachine(ISession *aSession,
2900	LockType_T lockType)
2901	{
2902	CheckComArgNotNull(aSession);
2903
2904	AutoCaller autoCaller(this);
2905	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2906
2907	/* check the session state */
2908	SessionState_T state;
2909	HRESULT rc = aSession->COMGETTER(State)(&state);
2910	if (FAILED(rc)) return rc;
2911
2912	if (state != SessionState_Unlocked)
2913	return setError(VBOX_E_INVALID_OBJECT_STATE,
2914	tr("The given session is busy"));
2915
2916	// get the client's IInternalSessionControl interface
2917	ComPtr<IInternalSessionControl> pSessionControl = aSession;
2918	ComAssertMsgRet(!!pSessionControl, ("No IInternalSessionControl interface"),
2919	E_INVALIDARG);
2920
2921	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2922
2923	if (!mData->mRegistered)
2924	return setError(E_UNEXPECTED,
2925	tr("The machine '%s' is not registered"),
2926	mUserData->s.strName.c_str());
2927
2928	LogFlowThisFunc(("mSession.mState=%s\n", Global::stringifySessionState(mData->mSession.mState)));
2929
2930	SessionState_T oldState = mData->mSession.mState;
2931	/* Hack: in case the session is closing and there is a progress object
2932	* which allows waiting for the session to be closed, take the opportunity
2933	* and do a limited wait (max. 1 second). This helps a lot when the system
2934	* is busy and thus session closing can take a little while. */
2935	if ( mData->mSession.mState == SessionState_Unlocking
2936	&& mData->mSession.mProgress)
2937	{
2938	alock.release();
2939	mData->mSession.mProgress->WaitForCompletion(1000);
2940	alock.acquire();
2941	LogFlowThisFunc(("after waiting: mSession.mState=%s\n", Global::stringifySessionState(mData->mSession.mState)));
2942	}
2943
2944	// try again now
2945	if ( (mData->mSession.mState == SessionState_Locked) // machine is write-locked already (i.e. session machine exists)
2946	&& (lockType == LockType_Shared) // caller wants a shared link to the existing session that holds the write lock:
2947	)
2948	{
2949	// OK, share the session... we are now dealing with three processes:
2950	// 1) VBoxSVC (where this code runs);
2951	// 2) process C: the caller's client process (who wants a shared session);
2952	// 3) process W: the process which already holds the write lock on the machine (write-locking session)
2953
2954	// copy pointers to W (the write-locking session) before leaving lock (these must not be NULL)
2955	ComPtr<IInternalSessionControl> pSessionW = mData->mSession.mDirectControl;
2956	ComAssertRet(!pSessionW.isNull(), E_FAIL);
2957	ComObjPtr<SessionMachine> pSessionMachine = mData->mSession.mMachine;
2958	AssertReturn(!pSessionMachine.isNull(), E_FAIL);
2959
2960	/*
2961	* Leave the lock before calling the client process. It's safe here
2962	* since the only thing to do after we get the lock again is to add
2963	* the remote control to the list (which doesn't directly influence
2964	* anything).
2965	*/
2966	alock.leave();
2967
2968	// get the console of the session holding the write lock (this is a remote call)
2969	ComPtr<IConsole> pConsoleW;
2970	LogFlowThisFunc(("Calling GetRemoteConsole()...\n"));
2971	rc = pSessionW->GetRemoteConsole(pConsoleW.asOutParam());
2972	LogFlowThisFunc(("GetRemoteConsole() returned %08X\n", rc));
2973	if (FAILED(rc))
2974	// the failure may occur w/o any error info (from RPC), so provide one
2975	return setError(VBOX_E_VM_ERROR,
2976	tr("Failed to get a console object from the direct session (%Rrc)"), rc);
2977
2978	ComAssertRet(!pConsoleW.isNull(), E_FAIL);
2979
2980	// share the session machine and W's console with the caller's session
2981	LogFlowThisFunc(("Calling AssignRemoteMachine()...\n"));
2982	rc = pSessionControl->AssignRemoteMachine(pSessionMachine, pConsoleW);
2983	LogFlowThisFunc(("AssignRemoteMachine() returned %08X\n", rc));
2984
2985	if (FAILED(rc))
2986	// the failure may occur w/o any error info (from RPC), so provide one
2987	return setError(VBOX_E_VM_ERROR,
2988	tr("Failed to assign the machine to the session (%Rrc)"), rc);
2989	alock.enter();
2990
2991	// need to revalidate the state after entering the lock again
2992	if (mData->mSession.mState != SessionState_Locked)
2993	{
2994	pSessionControl->Uninitialize();
2995	return setError(VBOX_E_INVALID_SESSION_STATE,
2996	tr("The machine '%s' was unlocked unexpectedly while attempting to share its session"),
2997	mUserData->s.strName.c_str());
2998	}
2999
3000	// add the caller's session to the list
3001	mData->mSession.mRemoteControls.push_back(pSessionControl);
3002	}
3003	else if ( mData->mSession.mState == SessionState_Locked
3004	\|\| mData->mSession.mState == SessionState_Unlocking
3005	)
3006	{
3007	// sharing not permitted, or machine still unlocking:
3008	return setError(VBOX_E_INVALID_OBJECT_STATE,
3009	tr("The machine '%s' is already locked for a session (or being unlocked)"),
3010	mUserData->s.strName.c_str());
3011	}
3012	else
3013	{
3014	// machine is not locked: then write-lock the machine (create the session machine)
3015
3016	// must not be busy
3017	AssertReturn(!Global::IsOnlineOrTransient(mData->mMachineState), E_FAIL);
3018
3019	// get the caller's session PID
3020	RTPROCESS pid = NIL_RTPROCESS;
3021	AssertCompile(sizeof(ULONG) == sizeof(RTPROCESS));
3022	pSessionControl->GetPID((ULONG*)&pid);
3023	Assert(pid != NIL_RTPROCESS);
3024
3025	bool fLaunchingVMProcess = (mData->mSession.mState == SessionState_Spawning);
3026
3027	if (fLaunchingVMProcess)
3028	{
3029	// this machine is awaiting for a spawning session to be opened:
3030	// then the calling process must be the one that got started by
3031	// launchVMProcess()
3032
3033	LogFlowThisFunc(("mSession.mPid=%d(0x%x)\n", mData->mSession.mPid, mData->mSession.mPid));
3034	LogFlowThisFunc(("session.pid=%d(0x%x)\n", pid, pid));
3035
3036	if (mData->mSession.mPid != pid)
3037	return setError(E_ACCESSDENIED,
3038	tr("An unexpected process (PID=0x%08X) has tried to lock the "
3039	"machine '%s', while only the process started by launchVMProcess (PID=0x%08X) is allowed"),
3040	pid, mUserData->s.strName.c_str(), mData->mSession.mPid);
3041	}
3042
3043	// create the mutable SessionMachine from the current machine
3044	ComObjPtr<SessionMachine> sessionMachine;
3045	sessionMachine.createObject();
3046	rc = sessionMachine->init(this);
3047	AssertComRC(rc);
3048
3049	/* NOTE: doing return from this function after this point but
3050	* before the end is forbidden since it may call SessionMachine::uninit()
3051	* (through the ComObjPtr's destructor) which requests the VirtualBox write
3052	* lock while still holding the Machine lock in alock so that a deadlock
3053	* is possible due to the wrong lock order. */
3054
3055	if (SUCCEEDED(rc))
3056	{
3057	/*
3058	* Set the session state to Spawning to protect against subsequent
3059	* attempts to open a session and to unregister the machine after
3060	* we leave the lock.
3061	*/
3062	SessionState_T origState = mData->mSession.mState;
3063	mData->mSession.mState = SessionState_Spawning;
3064
3065	/*
3066	* Leave the lock before calling the client process -- it will call
3067	* Machine/SessionMachine methods. Leaving the lock here is quite safe
3068	* because the state is Spawning, so that openRemotesession() and
3069	* openExistingSession() calls will fail. This method, called before we
3070	* enter the lock again, will fail because of the wrong PID.
3071	*
3072	* Note that mData->mSession.mRemoteControls accessed outside
3073	* the lock may not be modified when state is Spawning, so it's safe.
3074	*/
3075	alock.leave();
3076
3077	LogFlowThisFunc(("Calling AssignMachine()...\n"));
3078	rc = pSessionControl->AssignMachine(sessionMachine);
3079	LogFlowThisFunc(("AssignMachine() returned %08X\n", rc));
3080
3081	/* The failure may occur w/o any error info (from RPC), so provide one */
3082	if (FAILED(rc))
3083	setError(VBOX_E_VM_ERROR,
3084	tr("Failed to assign the machine to the session (%Rrc)"), rc);
3085
3086	if ( SUCCEEDED(rc)
3087	&& fLaunchingVMProcess
3088	)
3089	{
3090	/* complete the remote session initialization */
3091
3092	/* get the console from the direct session */
3093	ComPtr<IConsole> console;
3094	rc = pSessionControl->GetRemoteConsole(console.asOutParam());
3095	ComAssertComRC(rc);
3096
3097	if (SUCCEEDED(rc) && !console)
3098	{
3099	ComAssert(!!console);
3100	rc = E_FAIL;
3101	}
3102
3103	/* assign machine & console to the remote session */
3104	if (SUCCEEDED(rc))
3105	{
3106	/*
3107	* after openRemoteSession(), the first and the only
3108	* entry in remoteControls is that remote session
3109	*/
3110	LogFlowThisFunc(("Calling AssignRemoteMachine()...\n"));
3111	rc = mData->mSession.mRemoteControls.front()->AssignRemoteMachine(sessionMachine, console);
3112	LogFlowThisFunc(("AssignRemoteMachine() returned %08X\n", rc));
3113
3114	/* The failure may occur w/o any error info (from RPC), so provide one */
3115	if (FAILED(rc))
3116	setError(VBOX_E_VM_ERROR,
3117	tr("Failed to assign the machine to the remote session (%Rrc)"), rc);
3118	}
3119
3120	if (FAILED(rc))
3121	pSessionControl->Uninitialize();
3122	}
3123
3124	/* enter the lock again */
3125	alock.enter();
3126
3127	/* Restore the session state */
3128	mData->mSession.mState = origState;
3129	}
3130
3131	// finalize spawning anyway (this is why we don't return on errors above)
3132	if (fLaunchingVMProcess)
3133	{
3134	/* Note that the progress object is finalized later */
3135	/** @todo Consider checking mData->mSession.mProgress for cancellation
3136	* around here. */
3137
3138	/* We don't reset mSession.mPid here because it is necessary for
3139	* SessionMachine::uninit() to reap the child process later. */
3140
3141	if (FAILED(rc))
3142	{
3143	/* Close the remote session, remove the remote control from the list
3144	* and reset session state to Closed (@note keep the code in sync
3145	* with the relevant part in openSession()). */
3146
3147	Assert(mData->mSession.mRemoteControls.size() == 1);
3148	if (mData->mSession.mRemoteControls.size() == 1)
3149	{
3150	ErrorInfoKeeper eik;
3151	mData->mSession.mRemoteControls.front()->Uninitialize();
3152	}
3153
3154	mData->mSession.mRemoteControls.clear();
3155	mData->mSession.mState = SessionState_Unlocked;
3156	}
3157	}
3158	else
3159	{
3160	/* memorize PID of the directly opened session */
3161	if (SUCCEEDED(rc))
3162	mData->mSession.mPid = pid;
3163	}
3164
3165	if (SUCCEEDED(rc))
3166	{
3167	/* memorize the direct session control and cache IUnknown for it */
3168	mData->mSession.mDirectControl = pSessionControl;
3169	mData->mSession.mState = SessionState_Locked;
3170	/* associate the SessionMachine with this Machine */
3171	mData->mSession.mMachine = sessionMachine;
3172
3173	/* request an IUnknown pointer early from the remote party for later
3174	* identity checks (it will be internally cached within mDirectControl
3175	* at least on XPCOM) */
3176	ComPtr<IUnknown> unk = mData->mSession.mDirectControl;
3177	NOREF(unk);
3178	}
3179
3180	/* Leave the lock since SessionMachine::uninit() locks VirtualBox which
3181	* would break the lock order */
3182	alock.leave();
3183
3184	/* uninitialize the created session machine on failure */
3185	if (FAILED(rc))
3186	sessionMachine->uninit();
3187
3188	}
3189
3190	if (SUCCEEDED(rc))
3191	{
3192	/*
3193	* tell the client watcher thread to update the set of
3194	* machines that have open sessions
3195	*/
3196	mParent->updateClientWatcher();
3197
3198	if (oldState != SessionState_Locked)
3199	/* fire an event */
3200	mParent->onSessionStateChange(getId(), SessionState_Locked);
3201	}
3202
3203	return rc;
3204	}
3205
3206	/**
3207	* @note Locks objects!
3208	*/
3209	STDMETHODIMP Machine::LaunchVMProcess(ISession *aSession,
3210	IN_BSTR aType,
3211	IN_BSTR aEnvironment,
3212	IProgress **aProgress)
3213	{
3214	CheckComArgNotNull(aSession);
3215	CheckComArgStrNotEmptyOrNull(aType);
3216	CheckComArgOutSafeArrayPointerValid(aProgress);
3217
3218	AutoCaller autoCaller(this);
3219	if (FAILED(autoCaller.rc())) return autoCaller.rc();
3220
3221	/* check the session state */
3222	SessionState_T state;
3223	HRESULT rc = aSession->COMGETTER(State)(&state);
3224	if (FAILED(rc)) return rc;
3225
3226	if (state != SessionState_Unlocked)
3227	return setError(VBOX_E_INVALID_OBJECT_STATE,
3228	tr("The given session is busy"));
3229
3230	/* get the IInternalSessionControl interface */
3231	ComPtr<IInternalSessionControl> control = aSession;
3232	ComAssertMsgRet(!!control, ("No IInternalSessionControl interface"),
3233	E_INVALIDARG);
3234
3235	/* get the teleporter enable state for the progress object init. */
3236	BOOL fTeleporterEnabled;
3237	rc = COMGETTER(TeleporterEnabled)(&fTeleporterEnabled);
3238	if (FAILED(rc))
3239	return rc;
3240
3241	/* create a progress object */
3242	ComObjPtr<ProgressProxy> progress;
3243	progress.createObject();
3244	rc = progress->init(mParent,
3245	static_cast<IMachine*>(this),
3246	Bstr(tr("Spawning session")).raw(),
3247	TRUE /* aCancelable */,
3248	fTeleporterEnabled ? 20 : 10 /* uTotalOperationsWeight */,
3249	Bstr(tr("Spawning session")).raw(),
3250	2 /* uFirstOperationWeight */,
3251	fTeleporterEnabled ? 3 : 1 /* cOtherProgressObjectOperations */);
3252	if (SUCCEEDED(rc))
3253	{
3254	rc = openRemoteSession(control, aType, aEnvironment, progress);
3255	if (SUCCEEDED(rc))
3256	{
3257	progress.queryInterfaceTo(aProgress);
3258
3259	/* signal the client watcher thread */
3260	mParent->updateClientWatcher();
3261
3262	/* fire an event */
3263	mParent->onSessionStateChange(getId(), SessionState_Spawning);
3264	}
3265	}
3266
3267	return rc;
3268	}
3269
3270	STDMETHODIMP Machine::SetBootOrder(ULONG aPosition, DeviceType_T aDevice)
3271	{
3272	if (aPosition < 1 \|\| aPosition > SchemaDefs::MaxBootPosition)
3273	return setError(E_INVALIDARG,
3274	tr("Invalid boot position: %lu (must be in range [1, %lu])"),
3275	aPosition, SchemaDefs::MaxBootPosition);
3276
3277	if (aDevice == DeviceType_USB)
3278	return setError(E_NOTIMPL,
3279	tr("Booting from USB device is currently not supported"));
3280
3281	AutoCaller autoCaller(this);
3282	if (FAILED(autoCaller.rc())) return autoCaller.rc();
3283
3284	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3285
3286	HRESULT rc = checkStateDependency(MutableStateDep);
3287	if (FAILED(rc)) return rc;
3288
3289	setModified(IsModified_MachineData);
3290	mHWData.backup();
3291	mHWData->mBootOrder[aPosition - 1] = aDevice;
3292
3293	return S_OK;
3294	}
3295
3296	STDMETHODIMP Machine::GetBootOrder(ULONG aPosition, DeviceType_T *aDevice)
3297	{
3298	if (aPosition < 1 \|\| aPosition > SchemaDefs::MaxBootPosition)
3299	return setError(E_INVALIDARG,
3300	tr("Invalid boot position: %lu (must be in range [1, %lu])"),
3301	aPosition, SchemaDefs::MaxBootPosition);
3302
3303	AutoCaller autoCaller(this);
3304	if (FAILED(autoCaller.rc())) return autoCaller.rc();
3305
3306	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3307
3308	*aDevice = mHWData->mBootOrder[aPosition - 1];
3309
3310	return S_OK;
3311	}
3312
3313	STDMETHODIMP Machine::AttachDevice(IN_BSTR aControllerName,
3314	LONG aControllerPort,
3315	LONG aDevice,
3316	DeviceType_T aType,
3317	IMedium *aMedium)
3318	{
3319	LogFlowThisFunc(("aControllerName=\"%ls\" aControllerPort=%d aDevice=%d aType=%d aId=\"%ls\"\n",
3320	aControllerName, aControllerPort, aDevice, aType, aMedium));
3321
3322	CheckComArgStrNotEmptyOrNull(aControllerName);
3323
3324	AutoCaller autoCaller(this);
3325	if (FAILED(autoCaller.rc())) return autoCaller.rc();
3326
3327	// if this becomes true then we need to call saveSettings in the end
3328	// @todo r=dj there is no error handling so far...
3329	bool fNeedsMachineSaveSettings = false,
3330	fNeedsGlobalSaveSettings = false;
3331
3332	// request the host lock first, since might be calling Host methods for getting host drives;
3333	// next, protect the media tree all the while we're in here, as well as our member variables
3334	AutoMultiWriteLock2 alock(mParent->host()->lockHandle(),
3335	this->lockHandle() COMMA_LOCKVAL_SRC_POS);
3336	AutoWriteLock treeLock(&mParent->getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
3337
3338	HRESULT rc = checkStateDependency(MutableStateDep);
3339	if (FAILED(rc)) return rc;
3340
3341	/// @todo NEWMEDIA implicit machine registration
3342	if (!mData->mRegistered)
3343	return setError(VBOX_E_INVALID_OBJECT_STATE,
3344	tr("Cannot attach storage devices to an unregistered machine"));
3345
3346	AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
3347
3348	if (Global::IsOnlineOrTransient(mData->mMachineState))
3349	return setError(VBOX_E_INVALID_VM_STATE,
3350	tr("Invalid machine state: %s"),
3351	Global::stringifyMachineState(mData->mMachineState));
3352
3353	/* Check for an existing controller. */
3354	ComObjPtr<StorageController> ctl;
3355	rc = getStorageControllerByName(aControllerName, ctl, true /* aSetError */);
3356	if (FAILED(rc)) return rc;
3357
3358	// check that the port and device are not out of range
3359	rc = ctl->checkPortAndDeviceValid(aControllerPort, aDevice);
3360	if (FAILED(rc)) return rc;
3361
3362	/* check if the device slot is already busy */
3363	MediumAttachment *pAttachTemp;
3364	if ((pAttachTemp = findAttachment(mMediaData->mAttachments,
3365	aControllerName,
3366	aControllerPort,
3367	aDevice)))
3368	{
3369	Medium *pMedium = pAttachTemp->getMedium();
3370	if (pMedium)
3371	{
3372	AutoReadLock mediumLock(pMedium COMMA_LOCKVAL_SRC_POS);
3373	return setError(VBOX_E_OBJECT_IN_USE,
3374	tr("Medium '%s' is already attached to port %d, device %d of controller '%ls' of this virtual machine"),
3375	pMedium->getLocationFull().c_str(),
3376	aControllerPort,
3377	aDevice,
3378	aControllerName);
3379	}
3380	else
3381	return setError(VBOX_E_OBJECT_IN_USE,
3382	tr("Device is already attached to port %d, device %d of controller '%ls' of this virtual machine"),
3383	aControllerPort, aDevice, aControllerName);
3384	}
3385
3386	ComObjPtr<Medium> medium = static_cast<Medium*>(aMedium);
3387	if (aMedium && medium.isNull())
3388	return setError(E_INVALIDARG, "The given medium pointer is invalid");
3389
3390	AutoCaller mediumCaller(medium);
3391	if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
3392
3393	AutoWriteLock mediumLock(medium COMMA_LOCKVAL_SRC_POS);
3394
3395	if ( (pAttachTemp = findAttachment(mMediaData->mAttachments, medium))
3396	&& !medium.isNull()
3397	)
3398	return setError(VBOX_E_OBJECT_IN_USE,
3399	tr("Medium '%s' is already attached to this virtual machine"),
3400	medium->getLocationFull().c_str());
3401
3402	bool fIndirect = false;
3403	if (!medium.isNull())
3404	fIndirect = medium->isReadOnly();
3405	bool associate = true;
3406
3407	do
3408	{
3409	if ( aType == DeviceType_HardDisk
3410	&& mMediaData.isBackedUp())
3411	{
3412	const MediaData::AttachmentList &oldAtts = mMediaData.backedUpData()->mAttachments;
3413
3414	/* check if the medium was attached to the VM before we started
3415	* changing attachments in which case the attachment just needs to
3416	* be restored */
3417	if ((pAttachTemp = findAttachment(oldAtts, medium)))
3418	{
3419	AssertReturn(!fIndirect, E_FAIL);
3420
3421	/* see if it's the same bus/channel/device */
3422	if (pAttachTemp->matches(aControllerName, aControllerPort, aDevice))
3423	{
3424	/* the simplest case: restore the whole attachment
3425	* and return, nothing else to do */
3426	mMediaData->mAttachments.push_back(pAttachTemp);
3427	return S_OK;
3428	}
3429
3430	/* bus/channel/device differ; we need a new attachment object,
3431	* but don't try to associate it again */
3432	associate = false;
3433	break;
3434	}
3435	}
3436
3437	/* go further only if the attachment is to be indirect */
3438	if (!fIndirect)
3439	break;
3440
3441	/* perform the so called smart attachment logic for indirect
3442	* attachments. Note that smart attachment is only applicable to base
3443	* hard disks. */
3444
3445	if (medium->getParent().isNull())
3446	{
3447	/* first, investigate the backup copy of the current hard disk
3448	* attachments to make it possible to re-attach existing diffs to
3449	* another device slot w/o losing their contents */
3450	if (mMediaData.isBackedUp())
3451	{
3452	const MediaData::AttachmentList &oldAtts = mMediaData.backedUpData()->mAttachments;
3453
3454	MediaData::AttachmentList::const_iterator foundIt = oldAtts.end();
3455	uint32_t foundLevel = 0;
3456
3457	for (MediaData::AttachmentList::const_iterator it = oldAtts.begin();
3458	it != oldAtts.end();
3459	++it)
3460	{
3461	uint32_t level = 0;
3462	MediumAttachment pAttach = it;
3463	ComObjPtr<Medium> pMedium = pAttach->getMedium();
3464	Assert(!pMedium.isNull() \|\| pAttach->getType() != DeviceType_HardDisk);
3465	if (pMedium.isNull())
3466	continue;
3467
3468	if (pMedium->getBase(&level) == medium)
3469	{
3470	/* skip the hard disk if its currently attached (we
3471	* cannot attach the same hard disk twice) */
3472	if (findAttachment(mMediaData->mAttachments,
3473	pMedium))
3474	continue;
3475
3476	/* matched device, channel and bus (i.e. attached to the
3477	* same place) will win and immediately stop the search;
3478	* otherwise the attachment that has the youngest
3479	* descendant of medium will be used
3480	*/
3481	if (pAttach->matches(aControllerName, aControllerPort, aDevice))
3482	{
3483	/* the simplest case: restore the whole attachment
3484	* and return, nothing else to do */
3485	mMediaData->mAttachments.push_back(*it);
3486	return S_OK;
3487	}
3488	else if ( foundIt == oldAtts.end()
3489	\|\| level > foundLevel /* prefer younger */
3490	)
3491	{
3492	foundIt = it;
3493	foundLevel = level;
3494	}
3495	}
3496	}
3497
3498	if (foundIt != oldAtts.end())
3499	{
3500	/* use the previously attached hard disk */
3501	medium = (*foundIt)->getMedium();
3502	mediumCaller.attach(medium);
3503	if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
3504	mediumLock.attach(medium);
3505	/* not implicit, doesn't require association with this VM */
3506	fIndirect = false;
3507	associate = false;
3508	/* go right to the MediumAttachment creation */
3509	break;
3510	}
3511	}
3512
3513	/* must give up the medium lock and medium tree lock as below we
3514	* go over snapshots, which needs a lock with higher lock order. */
3515	mediumLock.release();
3516	treeLock.release();
3517
3518	/* then, search through snapshots for the best diff in the given
3519	* hard disk's chain to base the new diff on */
3520
3521	ComObjPtr<Medium> base;
3522	ComObjPtr<Snapshot> snap = mData->mCurrentSnapshot;
3523	while (snap)
3524	{
3525	AutoReadLock snapLock(snap COMMA_LOCKVAL_SRC_POS);
3526
3527	const MediaData::AttachmentList &snapAtts = snap->getSnapshotMachine()->mMediaData->mAttachments;
3528
3529	MediumAttachment *pAttachFound = NULL;
3530	uint32_t foundLevel = 0;
3531
3532	for (MediaData::AttachmentList::const_iterator it = snapAtts.begin();
3533	it != snapAtts.end();
3534	++it)
3535	{
3536	MediumAttachment pAttach = it;
3537	ComObjPtr<Medium> pMedium = pAttach->getMedium();
3538	Assert(!pMedium.isNull() \|\| pAttach->getType() != DeviceType_HardDisk);
3539	if (pMedium.isNull())
3540	continue;
3541
3542	uint32_t level = 0;
3543	if (pMedium->getBase(&level) == medium)
3544	{
3545	/* matched device, channel and bus (i.e. attached to the
3546	* same place) will win and immediately stop the search;
3547	* otherwise the attachment that has the youngest
3548	* descendant of medium will be used
3549	*/
3550	if ( pAttach->getDevice() == aDevice
3551	&& pAttach->getPort() == aControllerPort
3552	&& pAttach->getControllerName() == aControllerName
3553	)
3554	{
3555	pAttachFound = pAttach;
3556	break;
3557	}
3558	else if ( !pAttachFound
3559	\|\| level > foundLevel /* prefer younger */
3560	)
3561	{
3562	pAttachFound = pAttach;
3563	foundLevel = level;
3564	}
3565	}
3566	}
3567
3568	if (pAttachFound)
3569	{
3570	base = pAttachFound->getMedium();
3571	break;
3572	}
3573
3574	snap = snap->getParent();
3575	}
3576
3577	/* re-lock medium tree and the medium, as we need it below */
3578	treeLock.acquire();
3579	mediumLock.acquire();
3580
3581	/* found a suitable diff, use it as a base */
3582	if (!base.isNull())
3583	{
3584	medium = base;
3585	mediumCaller.attach(medium);
3586	if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
3587	mediumLock.attach(medium);
3588	}
3589	}
3590
3591	ComObjPtr<Medium> diff;
3592	diff.createObject();
3593	rc = diff->init(mParent,
3594	medium->getPreferredDiffFormat(),
3595	Utf8Str(mUserData->m_strSnapshotFolderFull).append(RTPATH_SLASH_STR),
3596	medium->getFirstRegistryMachineId(), // store this diff in the same registry as the parent
3597	&fNeedsGlobalSaveSettings);
3598	if (FAILED(rc)) return rc;
3599
3600	/* Apply the normal locking logic to the entire chain. */
3601	MediumLockList *pMediumLockList(new MediumLockList());
3602	rc = diff->createMediumLockList(true /* fFailIfInaccessible */,
3603	true /* fMediumLockWrite */,
3604	medium,
3605	*pMediumLockList);
3606	if (SUCCEEDED(rc))
3607	{
3608	rc = pMediumLockList->Lock();
3609	if (FAILED(rc))
3610	setError(rc,
3611	tr("Could not lock medium when creating diff '%s'"),
3612	diff->getLocationFull().c_str());
3613	else
3614	{
3615	/* will leave the lock before the potentially lengthy operation, so
3616	* protect with the special state */
3617	MachineState_T oldState = mData->mMachineState;
3618	setMachineState(MachineState_SettingUp);
3619
3620	mediumLock.leave();
3621	treeLock.leave();
3622	alock.leave();
3623
3624	rc = medium->createDiffStorage(diff,
3625	MediumVariant_Standard,
3626	pMediumLockList,
3627	NULL /* aProgress */,
3628	true /* aWait */,
3629	&fNeedsGlobalSaveSettings);
3630
3631	alock.enter();
3632	treeLock.enter();
3633	mediumLock.enter();
3634
3635	setMachineState(oldState);
3636	}
3637	}
3638
3639	/* Unlock the media and free the associated memory. */
3640	delete pMediumLockList;
3641
3642	if (FAILED(rc)) return rc;
3643
3644	/* use the created diff for the actual attachment */
3645	medium = diff;
3646	mediumCaller.attach(medium);
3647	if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
3648	mediumLock.attach(medium);
3649	}
3650	while (0);
3651
3652	ComObjPtr<MediumAttachment> attachment;
3653	attachment.createObject();
3654	rc = attachment->init(this,
3655	medium,
3656	aControllerName,
3657	aControllerPort,
3658	aDevice,
3659	aType,
3660	fIndirect,
3661	0 /* No bandwidth limit */);
3662	if (FAILED(rc)) return rc;
3663
3664	if (associate && !medium.isNull())
3665	{
3666	// as the last step, associate the medium to the VM
3667	rc = medium->addBackReference(mData->mUuid);
3668	// here we can fail because of Deleting, or being in process of creating a Diff
3669	if (FAILED(rc)) return rc;
3670
3671	// and decide which medium registry to use now that the medium is attached:
3672	if (mData->pMachineConfigFile->canHaveOwnMediaRegistry())
3673	// machine XML is VirtualBox 4.0 or higher:
3674	medium->addRegistry(getId(), // machine UUID
3675	&fNeedsMachineSaveSettings);
3676	else
3677	medium->addRegistry(mParent->getGlobalRegistryId(), // VirtualBox global registry UUID
3678	&fNeedsGlobalSaveSettings);
3679	}
3680
3681	/* success: finally remember the attachment */
3682	setModified(IsModified_Storage);
3683	mMediaData.backup();
3684	mMediaData->mAttachments.push_back(attachment);
3685
3686	if (fNeedsMachineSaveSettings)
3687	saveSettings(&fNeedsGlobalSaveSettings, SaveS_Force);
3688
3689	if (fNeedsGlobalSaveSettings)
3690	{
3691	// save the global settings; for that we should hold only the VirtualBox lock
3692	mediumLock.release();
3693	treeLock.leave();
3694	alock.release();
3695
3696	AutoWriteLock vboxLock(mParent COMMA_LOCKVAL_SRC_POS);
3697	mParent->saveSettings();
3698	}
3699
3700	return rc;
3701	}
3702
3703	STDMETHODIMP Machine::DetachDevice(IN_BSTR aControllerName, LONG aControllerPort,
3704	LONG aDevice)
3705	{
3706	CheckComArgStrNotEmptyOrNull(aControllerName);
3707
3708	LogFlowThisFunc(("aControllerName=\"%ls\" aControllerPort=%ld aDevice=%ld\n",
3709	aControllerName, aControllerPort, aDevice));
3710
3711	AutoCaller autoCaller(this);
3712	if (FAILED(autoCaller.rc())) return autoCaller.rc();
3713
3714	bool fNeedsSaveSettings = false;
3715
3716	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3717
3718	HRESULT rc = checkStateDependency(MutableStateDep);
3719	if (FAILED(rc)) return rc;
3720
3721	AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
3722
3723	if (Global::IsOnlineOrTransient(mData->mMachineState))
3724	return setError(VBOX_E_INVALID_VM_STATE,
3725	tr("Invalid machine state: %s"),
3726	Global::stringifyMachineState(mData->mMachineState));
3727
3728	MediumAttachment *pAttach = findAttachment(mMediaData->mAttachments,
3729	aControllerName,
3730	aControllerPort,
3731	aDevice);
3732	if (!pAttach)
3733	return setError(VBOX_E_OBJECT_NOT_FOUND,
3734	tr("No storage device attached to device slot %d on port %d of controller '%ls'"),
3735	aDevice, aControllerPort, aControllerName);
3736
3737	rc = detachDevice(pAttach, alock, NULL /* pSnapshot */, &fNeedsSaveSettings);
3738
3739	if (fNeedsSaveSettings)
3740	{
3741	bool fNeedsGlobalSaveSettings = false;
3742	saveSettings(&fNeedsGlobalSaveSettings);
3743
3744	if (fNeedsGlobalSaveSettings)
3745	{
3746	// save the global settings; for that we should hold only the VirtualBox lock
3747	alock.release();
3748	AutoWriteLock vboxlock(this COMMA_LOCKVAL_SRC_POS);
3749	mParent->saveSettings();
3750	}
3751	}
3752
3753	return S_OK;
3754	}
3755
3756	STDMETHODIMP Machine::PassthroughDevice(IN_BSTR aControllerName, LONG aControllerPort,
3757	LONG aDevice, BOOL aPassthrough)
3758	{
3759	CheckComArgStrNotEmptyOrNull(aControllerName);
3760
3761	LogFlowThisFunc(("aControllerName=\"%ls\" aControllerPort=%ld aDevice=%ld aPassthrough=%d\n",
3762	aControllerName, aControllerPort, aDevice, aPassthrough));
3763
3764	AutoCaller autoCaller(this);
3765	if (FAILED(autoCaller.rc())) return autoCaller.rc();
3766
3767	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3768
3769	HRESULT rc = checkStateDependency(MutableStateDep);
3770	if (FAILED(rc)) return rc;
3771
3772	AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
3773
3774	if (Global::IsOnlineOrTransient(mData->mMachineState))
3775	return setError(VBOX_E_INVALID_VM_STATE,
3776	tr("Invalid machine state: %s"),
3777	Global::stringifyMachineState(mData->mMachineState));
3778
3779	MediumAttachment *pAttach = findAttachment(mMediaData->mAttachments,
3780	aControllerName,
3781	aControllerPort,
3782	aDevice);
3783	if (!pAttach)
3784	return setError(VBOX_E_OBJECT_NOT_FOUND,
3785	tr("No storage device attached to device slot %d on port %d of controller '%ls'"),
3786	aDevice, aControllerPort, aControllerName);
3787
3788
3789	setModified(IsModified_Storage);
3790	mMediaData.backup();
3791
3792	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
3793
3794	if (pAttach->getType() != DeviceType_DVD)
3795	return setError(E_INVALIDARG,
3796	tr("Setting passthrough rejected as the device attached to device slot %d on port %d of controller '%ls' is not a DVD"),
3797	aDevice, aControllerPort, aControllerName);
3798	pAttach->updatePassthrough(!!aPassthrough);
3799
3800	return S_OK;
3801	}
3802
3803	STDMETHODIMP Machine::MountMedium(IN_BSTR aControllerName,
3804	LONG aControllerPort,
3805	LONG aDevice,
3806	IMedium *aMedium,
3807	BOOL aForce)
3808	{
3809	int rc = S_OK;
3810	LogFlowThisFunc(("aControllerName=\"%ls\" aControllerPort=%ld aDevice=%ld aForce=%d\n",
3811	aControllerName, aControllerPort, aDevice, aForce));
3812
3813	CheckComArgStrNotEmptyOrNull(aControllerName);
3814
3815	AutoCaller autoCaller(this);
3816	if (FAILED(autoCaller.rc())) return autoCaller.rc();
3817
3818	// request the host lock first, since might be calling Host methods for getting host drives;
3819	// next, protect the media tree all the while we're in here, as well as our member variables
3820	AutoMultiWriteLock3 multiLock(mParent->host()->lockHandle(),
3821	this->lockHandle(),
3822	&mParent->getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
3823
3824	ComObjPtr<MediumAttachment> pAttach = findAttachment(mMediaData->mAttachments,
3825	aControllerName,
3826	aControllerPort,
3827	aDevice);
3828	if (pAttach.isNull())
3829	return setError(VBOX_E_OBJECT_NOT_FOUND,
3830	tr("No drive attached to device slot %d on port %d of controller '%ls'"),
3831	aDevice, aControllerPort, aControllerName);
3832
3833	/* Remember previously mounted medium. The medium before taking the
3834	* backup is not necessarily the same thing. */
3835	ComObjPtr<Medium> oldmedium;
3836	oldmedium = pAttach->getMedium();
3837
3838	ComObjPtr<Medium> pMedium = static_cast<Medium*>(aMedium);
3839	if (aMedium && pMedium.isNull())
3840	return setError(E_INVALIDARG, "The given medium pointer is invalid");
3841
3842	AutoCaller mediumCaller(pMedium);
3843	if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
3844
3845	AutoWriteLock mediumLock(pMedium COMMA_LOCKVAL_SRC_POS);
3846	if (pMedium)
3847	{
3848	DeviceType_T mediumType = pAttach->getType();
3849	switch (mediumType)
3850	{
3851	case DeviceType_DVD:
3852	case DeviceType_Floppy:
3853	break;
3854
3855	default:
3856	return setError(VBOX_E_INVALID_OBJECT_STATE,
3857	tr("The device at port %d, device %d of controller '%ls' of this virtual machine is not removeable"),
3858	aControllerPort,
3859	aDevice,
3860	aControllerName);
3861	}
3862	}
3863
3864	setModified(IsModified_Storage);
3865	mMediaData.backup();
3866
3867	bool fNeedsMachineSaveSettings = false,
3868	fNeedsGlobalSaveSettings = false;
3869
3870	{
3871	// The backup operation makes the pAttach reference point to the
3872	// old settings. Re-get the correct reference.
3873	pAttach = findAttachment(mMediaData->mAttachments,
3874	aControllerName,
3875	aControllerPort,
3876	aDevice);
3877	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
3878	if (!oldmedium.isNull())
3879	oldmedium->removeBackReference(mData->mUuid);
3880	if (!pMedium.isNull())
3881	{
3882	pMedium->addBackReference(mData->mUuid);
3883
3884	// and decide which medium registry to use now that the medium is attached:
3885	if (mData->pMachineConfigFile->canHaveOwnMediaRegistry())
3886	// machine XML is VirtualBox 4.0 or higher: machine UUID
3887	pMedium->addRegistry(getId(),
3888	&fNeedsMachineSaveSettings);
3889	else
3890	// VirtualBox global registry UUID
3891	pMedium->addRegistry(mParent->getGlobalRegistryId(),
3892	&fNeedsGlobalSaveSettings);
3893	}
3894
3895	pAttach->updateMedium(pMedium);
3896	}
3897
3898	setModified(IsModified_Storage);
3899
3900	mediumLock.release();
3901	multiLock.release();
3902	rc = onMediumChange(pAttach, aForce);
3903	multiLock.acquire();
3904	mediumLock.acquire();
3905
3906	/* On error roll back this change only. */
3907	if (FAILED(rc))
3908	{
3909	if (!pMedium.isNull())
3910	pMedium->removeBackReference(mData->mUuid);
3911	pAttach = findAttachment(mMediaData->mAttachments,
3912	aControllerName,
3913	aControllerPort,
3914	aDevice);
3915	/* If the attachment is gone in the meantime, bail out. */
3916	if (pAttach.isNull())
3917	return rc;
3918	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
3919	if (!oldmedium.isNull())
3920	oldmedium->addBackReference(mData->mUuid);
3921	pAttach->updateMedium(oldmedium);
3922	}
3923
3924	mediumLock.release();
3925	multiLock.release();
3926
3927	if (fNeedsMachineSaveSettings)
3928	{
3929	AutoWriteLock machineLock(this COMMA_LOCKVAL_SRC_POS);
3930	saveSettings(&fNeedsGlobalSaveSettings, SaveS_Force);
3931	}
3932
3933	if (fNeedsGlobalSaveSettings)
3934	{
3935	// save the global settings; for that we should hold only the VirtualBox lock
3936	AutoWriteLock vboxLock(mParent COMMA_LOCKVAL_SRC_POS);
3937	mParent->saveSettings();
3938	}
3939
3940	return rc;
3941	}
3942
3943	STDMETHODIMP Machine::GetMedium(IN_BSTR aControllerName,
3944	LONG aControllerPort,
3945	LONG aDevice,
3946	IMedium **aMedium)
3947	{
3948	LogFlowThisFunc(("aControllerName=\"%ls\" aControllerPort=%ld aDevice=%ld\n",
3949	aControllerName, aControllerPort, aDevice));
3950
3951	CheckComArgStrNotEmptyOrNull(aControllerName);
3952	CheckComArgOutPointerValid(aMedium);
3953
3954	AutoCaller autoCaller(this);
3955	if (FAILED(autoCaller.rc())) return autoCaller.rc();
3956
3957	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3958
3959	*aMedium = NULL;
3960
3961	ComObjPtr<MediumAttachment> pAttach = findAttachment(mMediaData->mAttachments,
3962	aControllerName,
3963	aControllerPort,
3964	aDevice);
3965	if (pAttach.isNull())
3966	return setError(VBOX_E_OBJECT_NOT_FOUND,
3967	tr("No storage device attached to device slot %d on port %d of controller '%ls'"),
3968	aDevice, aControllerPort, aControllerName);
3969
3970	pAttach->getMedium().queryInterfaceTo(aMedium);
3971
3972	return S_OK;
3973	}
3974
3975	STDMETHODIMP Machine::GetSerialPort(ULONG slot, ISerialPort **port)
3976	{
3977	CheckComArgOutPointerValid(port);
3978	CheckComArgExpr(slot, slot < RT_ELEMENTS(mSerialPorts));
3979
3980	AutoCaller autoCaller(this);
3981	if (FAILED(autoCaller.rc())) return autoCaller.rc();
3982
3983	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3984
3985	mSerialPorts[slot].queryInterfaceTo(port);
3986
3987	return S_OK;
3988	}
3989
3990	STDMETHODIMP Machine::GetParallelPort(ULONG slot, IParallelPort **port)
3991	{
3992	CheckComArgOutPointerValid(port);
3993	CheckComArgExpr(slot, slot < RT_ELEMENTS(mParallelPorts));
3994
3995	AutoCaller autoCaller(this);
3996	if (FAILED(autoCaller.rc())) return autoCaller.rc();
3997
3998	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3999
4000	mParallelPorts[slot].queryInterfaceTo(port);
4001
4002	return S_OK;
4003	}
4004
4005	STDMETHODIMP Machine::GetNetworkAdapter(ULONG slot, INetworkAdapter **adapter)
4006	{
4007	CheckComArgOutPointerValid(adapter);
4008	CheckComArgExpr(slot, slot < RT_ELEMENTS(mNetworkAdapters));
4009
4010	AutoCaller autoCaller(this);
4011	if (FAILED(autoCaller.rc())) return autoCaller.rc();
4012
4013	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4014
4015	mNetworkAdapters[slot].queryInterfaceTo(adapter);
4016
4017	return S_OK;
4018	}
4019
4020	STDMETHODIMP Machine::GetExtraDataKeys(ComSafeArrayOut(BSTR, aKeys))
4021	{
4022	if (ComSafeArrayOutIsNull(aKeys))
4023	return E_POINTER;
4024
4025	AutoCaller autoCaller(this);
4026	if (FAILED(autoCaller.rc())) return autoCaller.rc();
4027
4028	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4029
4030	com::SafeArray<BSTR> saKeys(mData->pMachineConfigFile->mapExtraDataItems.size());
4031	int i = 0;
4032	for (settings::StringsMap::const_iterator it = mData->pMachineConfigFile->mapExtraDataItems.begin();
4033	it != mData->pMachineConfigFile->mapExtraDataItems.end();
4034	++it, ++i)
4035	{
4036	const Utf8Str &strKey = it->first;
4037	strKey.cloneTo(&saKeys[i]);
4038	}
4039	saKeys.detachTo(ComSafeArrayOutArg(aKeys));
4040
4041	return S_OK;
4042	}
4043
4044	/**
4045	* @note Locks this object for reading.
4046	*/
4047	STDMETHODIMP Machine::GetExtraData(IN_BSTR aKey,
4048	BSTR *aValue)
4049	{
4050	CheckComArgStrNotEmptyOrNull(aKey);
4051	CheckComArgOutPointerValid(aValue);
4052
4053	AutoCaller autoCaller(this);
4054	if (FAILED(autoCaller.rc())) return autoCaller.rc();
4055
4056	/* start with nothing found */
4057	Bstr bstrResult("");
4058
4059	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4060
4061	settings::StringsMap::const_iterator it = mData->pMachineConfigFile->mapExtraDataItems.find(Utf8Str(aKey));
4062	if (it != mData->pMachineConfigFile->mapExtraDataItems.end())
4063	// found:
4064	bstrResult = it->second; // source is a Utf8Str
4065
4066	/* return the result to caller (may be empty) */
4067	bstrResult.cloneTo(aValue);
4068
4069	return S_OK;
4070	}
4071
4072	/**
4073	* @note Locks mParent for writing + this object for writing.
4074	*/
4075	STDMETHODIMP Machine::SetExtraData(IN_BSTR aKey, IN_BSTR aValue)
4076	{
4077	CheckComArgStrNotEmptyOrNull(aKey);
4078
4079	AutoCaller autoCaller(this);
4080	if (FAILED(autoCaller.rc())) return autoCaller.rc();
4081
4082	Utf8Str strKey(aKey);
4083	Utf8Str strValue(aValue);
4084	Utf8Str strOldValue; // empty
4085
4086	// locking note: we only hold the read lock briefly to look up the old value,
4087	// then release it and call the onExtraCanChange callbacks. There is a small
4088	// chance of a race insofar as the callback might be called twice if two callers
4089	// change the same key at the same time, but that's a much better solution
4090	// than the deadlock we had here before. The actual changing of the extradata
4091	// is then performed under the write lock and race-free.
4092
4093	// look up the old value first; if nothing's changed then we need not do anything
4094	{
4095	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); // hold read lock only while looking up
4096	settings::StringsMap::const_iterator it = mData->pMachineConfigFile->mapExtraDataItems.find(strKey);
4097	if (it != mData->pMachineConfigFile->mapExtraDataItems.end())
4098	strOldValue = it->second;
4099	}
4100
4101	bool fChanged;
4102	if ((fChanged = (strOldValue != strValue)))
4103	{
4104	// ask for permission from all listeners outside the locks;
4105	// onExtraDataCanChange() only briefly requests the VirtualBox
4106	// lock to copy the list of callbacks to invoke
4107	Bstr error;
4108	Bstr bstrValue(aValue);
4109
4110	if (!mParent->onExtraDataCanChange(mData->mUuid, aKey, bstrValue.raw(), error))
4111	{
4112	const char *sep = error.isEmpty() ? "" : ": ";
4113	CBSTR err = error.raw();
4114	LogWarningFunc(("Someone vetoed! Change refused%s%ls\n",
4115	sep, err));
4116	return setError(E_ACCESSDENIED,
4117	tr("Could not set extra data because someone refused the requested change of '%ls' to '%ls'%s%ls"),
4118	aKey,
4119	bstrValue.raw(),
4120	sep,
4121	err);
4122	}
4123
4124	// data is changing and change not vetoed: then write it out under the lock
4125	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4126
4127	if (isSnapshotMachine())
4128	{
4129	HRESULT rc = checkStateDependency(MutableStateDep);
4130	if (FAILED(rc)) return rc;
4131	}
4132
4133	if (strValue.isEmpty())
4134	mData->pMachineConfigFile->mapExtraDataItems.erase(strKey);
4135	else
4136	mData->pMachineConfigFile->mapExtraDataItems[strKey] = strValue;
4137	// creates a new key if needed
4138
4139	bool fNeedsGlobalSaveSettings = false;
4140	saveSettings(&fNeedsGlobalSaveSettings);
4141
4142	if (fNeedsGlobalSaveSettings)
4143	{
4144	// save the global settings; for that we should hold only the VirtualBox lock
4145	alock.release();
4146	AutoWriteLock vboxlock(mParent COMMA_LOCKVAL_SRC_POS);
4147	mParent->saveSettings();
4148	}
4149	}
4150
4151	// fire notification outside the lock
4152	if (fChanged)
4153	mParent->onExtraDataChange(mData->mUuid, aKey, aValue);
4154
4155	return S_OK;
4156	}
4157
4158	STDMETHODIMP Machine::SaveSettings()
4159	{
4160	AutoCaller autoCaller(this);
4161	if (FAILED(autoCaller.rc())) return autoCaller.rc();
4162
4163	AutoWriteLock mlock(this COMMA_LOCKVAL_SRC_POS);
4164
4165	/* when there was auto-conversion, we want to save the file even if
4166	* the VM is saved */
4167	HRESULT rc = checkStateDependency(MutableStateDep);
4168	if (FAILED(rc)) return rc;
4169
4170	/* the settings file path may never be null */
4171	ComAssertRet(!mData->m_strConfigFileFull.isEmpty(), E_FAIL);
4172
4173	/* save all VM data excluding snapshots */
4174	bool fNeedsGlobalSaveSettings = false;
4175	rc = saveSettings(&fNeedsGlobalSaveSettings);
4176	mlock.release();
4177
4178	if (SUCCEEDED(rc) && fNeedsGlobalSaveSettings)
4179	{
4180	// save the global settings; for that we should hold only the VirtualBox lock
4181	AutoWriteLock vlock(mParent COMMA_LOCKVAL_SRC_POS);
4182	rc = mParent->saveSettings();
4183	}
4184
4185	return rc;
4186	}
4187
4188	STDMETHODIMP Machine::DiscardSettings()
4189	{
4190	AutoCaller autoCaller(this);
4191	if (FAILED(autoCaller.rc())) return autoCaller.rc();
4192
4193	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4194
4195	HRESULT rc = checkStateDependency(MutableStateDep);
4196	if (FAILED(rc)) return rc;
4197
4198	/*
4199	* during this rollback, the session will be notified if data has
4200	* been actually changed
4201	*/
4202	rollback(true /* aNotify */);
4203
4204	return S_OK;
4205	}
4206
4207	/** @note Locks objects! */
4208	STDMETHODIMP Machine::Unregister(CleanupMode_T cleanupMode,
4209	ComSafeArrayOut(IMedium*, aMedia))
4210	{
4211	// use AutoLimitedCaller because this call is valid on inaccessible machines as well
4212	AutoLimitedCaller autoCaller(this);
4213	AssertComRCReturnRC(autoCaller.rc());
4214
4215	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4216
4217	Guid id(getId());
4218
4219	if (mData->mSession.mState != SessionState_Unlocked)
4220	return setError(VBOX_E_INVALID_OBJECT_STATE,
4221	tr("Cannot unregister the machine '%s' while it is locked"),
4222	mUserData->s.strName.c_str());
4223
4224	// wait for state dependants to drop to zero
4225	ensureNoStateDependencies();
4226
4227	if (!mData->mAccessible)
4228	{
4229	// inaccessible maschines can only be unregistered; uninitialize ourselves
4230	// here because currently there may be no unregistered that are inaccessible
4231	// (this state combination is not supported). Note releasing the caller and
4232	// leaving the lock before alling uninit()
4233	alock.leave();
4234	autoCaller.release();
4235
4236	uninit();
4237
4238	mParent->unregisterMachine(this, id);
4239	// calls VirtualBox::saveSettings()
4240
4241	return S_OK;
4242	}
4243
4244	HRESULT rc = S_OK;
4245
4246	// discard saved state
4247	if (mData->mMachineState == MachineState_Saved)
4248	{
4249	// add the saved state file to the list of files the caller should delete
4250	Assert(!mSSData->mStateFilePath.isEmpty());
4251	mData->llFilesToDelete.push_back(mSSData->mStateFilePath);
4252
4253	mSSData->mStateFilePath.setNull();
4254
4255	// unconditionally set the machine state to powered off, we now
4256	// know no session has locked the machine
4257	mData->mMachineState = MachineState_PoweredOff;
4258	}
4259
4260	size_t cSnapshots = 0;
4261	if (mData->mFirstSnapshot)
4262	cSnapshots = mData->mFirstSnapshot->getAllChildrenCount() + 1;
4263	if (cSnapshots && cleanupMode == CleanupMode_UnregisterOnly)
4264	// fail now before we start detaching media
4265	return setError(VBOX_E_INVALID_OBJECT_STATE,
4266	tr("Cannot unregister the machine '%s' because it has %d snapshots"),
4267	mUserData->s.strName.c_str(), cSnapshots);
4268
4269	// this list collects the medium objects from all medium attachments
4270	// which got detached from the machine and its snapshots, in the following
4271	// order:
4272	// 1) media from machine attachments (these have the "leaf" attachments with snapshots
4273	// and must be closed first, or closing the parents will fail because they will
4274	// children);
4275	// 2) media from the youngest snapshots followed those from the parent snapshots until
4276	// the root ("first") snapshot of the machine
4277	// This order allows for closing the media on this list from the beginning to the end
4278	// without getting "media in use" errors.
4279	MediaList llMedia;
4280
4281	if ( !mMediaData.isNull() // can be NULL if machine is inaccessible
4282	&& mMediaData->mAttachments.size()
4283	)
4284	{
4285	// we have media attachments: detach them all and add the Medium objects to our list
4286	if (cleanupMode != CleanupMode_UnregisterOnly)
4287	detachAllMedia(alock, NULL /* pSnapshot */, cleanupMode, llMedia);
4288	else
4289	return setError(VBOX_E_INVALID_OBJECT_STATE,
4290	tr("Cannot unregister the machine '%s' because it has %d media attachments"),
4291	mUserData->s.strName.c_str(), mMediaData->mAttachments.size());
4292	}
4293
4294	if (cSnapshots)
4295	{
4296	// autoCleanup must be true here, or we would have failed above
4297
4298	// add the media from the medium attachments of the snapshots to llMedia
4299	// as well, after the "main" machine media; Snapshot::uninitRecursively()
4300	// calls Machine::detachAllMedia() for the snapshot machine, recursing
4301	// into the children first
4302
4303	// Snapshot::beginDeletingSnapshot() asserts if the machine state is not this
4304	MachineState_T oldState = mData->mMachineState;
4305	mData->mMachineState = MachineState_DeletingSnapshot;
4306
4307	// make a copy of the first snapshot so the refcount does not drop to 0
4308	// in beginDeletingSnapshot, which sets pFirstSnapshot to 0 (that hangs
4309	// because of the AutoCaller voodoo)
4310	ComObjPtr<Snapshot> pFirstSnapshot = mData->mFirstSnapshot;
4311
4312	// GO!
4313	pFirstSnapshot->uninitRecursively(alock, cleanupMode, llMedia, mData->llFilesToDelete);
4314
4315	mData->mMachineState = oldState;
4316	}
4317
4318	if (FAILED(rc))
4319	{
4320	rollbackMedia();
4321	return rc;
4322	}
4323
4324	// commit all the media changes made above
4325	commitMedia();
4326
4327	mData->mRegistered = false;
4328
4329	// machine lock no longer needed
4330	alock.release();
4331
4332	// return media to caller
4333	SafeIfaceArray<IMedium> sfaMedia(llMedia);
4334	sfaMedia.detachTo(ComSafeArrayOutArg(aMedia));
4335
4336	mParent->unregisterMachine(this, id);
4337	// calls VirtualBox::saveSettings()
4338
4339	return S_OK;
4340	}
4341
4342	struct Machine::DeleteTask
4343	{
4344	ComObjPtr<Machine> pMachine;
4345	std::list<Utf8Str> llFilesToDelete;
4346	ComObjPtr<Progress> pProgress;
4347	bool fNeedsGlobalSaveSettings;
4348	};
4349
4350	STDMETHODIMP Machine::Delete(ComSafeArrayIn(IMedium, aMedia), IProgress *aProgress)
4351	{
4352	LogFlowFuncEnter();
4353
4354	AutoCaller autoCaller(this);
4355	if (FAILED(autoCaller.rc())) return autoCaller.rc();
4356
4357	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4358
4359	HRESULT rc = checkStateDependency(MutableStateDep);
4360	if (FAILED(rc)) return rc;
4361
4362	if (mData->mRegistered)
4363	return setError(VBOX_E_INVALID_VM_STATE,
4364	tr("Cannot delete settings of a registered machine"));
4365
4366	DeleteTask *pTask = new DeleteTask;
4367	pTask->pMachine = this;
4368	com::SafeIfaceArray<IMedium> sfaMedia(ComSafeArrayInArg(aMedia));
4369
4370	// collect files to delete
4371	pTask->llFilesToDelete = mData->llFilesToDelete; // saved states pushed here by Unregister()
4372
4373	pTask->fNeedsGlobalSaveSettings = false;
4374	for (size_t i = 0; i < sfaMedia.size(); ++i)
4375	{
4376	IMedium *pIMedium(sfaMedia[i]);
4377	Medium pMedium = static_cast<Medium>(pIMedium);
4378	AutoCaller mediumAutoCaller(pMedium);
4379	if (FAILED(mediumAutoCaller.rc())) return mediumAutoCaller.rc();
4380
4381	Utf8Str bstrLocation = pMedium->getLocationFull();
4382	// close the medium now; if that succeeds, then that means the medium is no longer
4383	// in use and we can add it to the list of files to delete
4384	rc = pMedium->close(&pTask->fNeedsGlobalSaveSettings,
4385	mediumAutoCaller);
4386	if (SUCCEEDED(rc))
4387	pTask->llFilesToDelete.push_back(bstrLocation);
4388	}
4389	if (mData->pMachineConfigFile->fileExists())
4390	pTask->llFilesToDelete.push_back(mData->m_strConfigFileFull);
4391
4392	pTask->pProgress.createObject();
4393	pTask->pProgress->init(getVirtualBox(),
4394	static_cast<IMachine>(this) / aInitiator */,
4395	Bstr(tr("Deleting files")).raw(),
4396	true /* fCancellable */,
4397	pTask->llFilesToDelete.size() + 1, // cOperations
4398	BstrFmt(tr("Deleting '%s'"), pTask->llFilesToDelete.front().c_str()).raw());
4399
4400	int vrc = RTThreadCreate(NULL,
4401	Machine::deleteThread,
4402	(void*)pTask,
4403	0,
4404	RTTHREADTYPE_MAIN_WORKER,
4405	0,
4406	"MachineDelete");
4407
4408	pTask->pProgress.queryInterfaceTo(aProgress);
4409
4410	if (RT_FAILURE(vrc))
4411	{
4412	delete pTask;
4413	return setError(E_FAIL, "Could not create MachineDelete thread (%Rrc)", vrc);
4414	}
4415
4416	LogFlowFuncLeave();
4417
4418	return S_OK;
4419	}
4420
4421	/**
4422	* Static task wrapper passed to RTThreadCreate() in Machine::Delete() which then
4423	* calls Machine::deleteTaskWorker() on the actual machine object.
4424	* @param Thread
4425	* @param pvUser
4426	* @return
4427	*/
4428	/static/
4429	DECLCALLBACK(int) Machine::deleteThread(RTTHREAD Thread, void *pvUser)
4430	{
4431	LogFlowFuncEnter();
4432
4433	DeleteTask pTask = (DeleteTask)pvUser;
4434	Assert(pTask);
4435	Assert(pTask->pMachine);
4436	Assert(pTask->pProgress);
4437
4438	HRESULT rc = pTask->pMachine->deleteTaskWorker(*pTask);
4439	pTask->pProgress->notifyComplete(rc);
4440
4441	delete pTask;
4442
4443	LogFlowFuncLeave();
4444
4445	NOREF(Thread);
4446
4447	return VINF_SUCCESS;
4448	}
4449
4450	/**
4451	* Task thread implementation for Machine::Delete(), called from Machine::deleteThread().
4452	* @param task
4453	* @return
4454	*/
4455	HRESULT Machine::deleteTaskWorker(DeleteTask &task)
4456	{
4457	AutoCaller autoCaller(this);
4458	if (FAILED(autoCaller.rc())) return autoCaller.rc();
4459
4460	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4461
4462	ULONG uLogHistoryCount = 3;
4463	ComPtr<ISystemProperties> systemProperties;
4464	mParent->COMGETTER(SystemProperties)(systemProperties.asOutParam());
4465	if (!systemProperties.isNull())
4466	systemProperties->COMGETTER(LogHistoryCount)(&uLogHistoryCount);
4467
4468	// delete the files pushed on the task list by Machine::Delete()
4469	// (this includes saved states of the machine and snapshots and
4470	// medium storage files from the IMedium list passed in, and the
4471	// machine XML file)
4472	std::list<Utf8Str>::const_iterator it = task.llFilesToDelete.begin();
4473	while (it != task.llFilesToDelete.end())
4474	{
4475	const Utf8Str &strFile = *it;
4476	LogFunc(("Deleting file %s\n", strFile.c_str()));
4477	RTFileDelete(strFile.c_str());
4478
4479	++it;
4480	if (it == task.llFilesToDelete.end())
4481	{
4482	task.pProgress->SetNextOperation(Bstr(tr("Cleaning up machine directory")).raw(), 1);
4483	break;
4484	}
4485
4486	task.pProgress->SetNextOperation(BstrFmt(tr("Deleting '%s'"), it->c_str()).raw(), 1);
4487	}
4488
4489	/* delete the settings only when the file actually exists */
4490	if (mData->pMachineConfigFile->fileExists())
4491	{
4492	/* Delete any backup or uncommitted XML files. Ignore failures.
4493	See the fSafe parameter of xml::XmlFileWriter::write for details. */
4494	/** @todo Find a way to avoid referring directly to iprt/xml.h here. */
4495	Utf8Str otherXml = Utf8StrFmt("%s%s", mData->m_strConfigFileFull.c_str(), xml::XmlFileWriter::s_pszTmpSuff);
4496	RTFileDelete(otherXml.c_str());
4497	otherXml = Utf8StrFmt("%s%s", mData->m_strConfigFileFull.c_str(), xml::XmlFileWriter::s_pszPrevSuff);
4498	RTFileDelete(otherXml.c_str());
4499
4500	/* delete the Logs folder, nothing important should be left
4501	* there (we don't check for errors because the user might have
4502	* some private files there that we don't want to delete) */
4503	Utf8Str logFolder;
4504	getLogFolder(logFolder);
4505	Assert(logFolder.length());
4506	if (RTDirExists(logFolder.c_str()))
4507	{
4508	/* Delete all VBox.log[.N] files from the Logs folder
4509	* (this must be in sync with the rotation logic in
4510	* Console::powerUpThread()). Also, delete the VBox.png[.N]
4511	* files that may have been created by the GUI. */
4512	Utf8Str log = Utf8StrFmt("%s%cVBox.log",
4513	logFolder.c_str(), RTPATH_DELIMITER);
4514	RTFileDelete(log.c_str());
4515	log = Utf8StrFmt("%s%cVBox.png",
4516	logFolder.c_str(), RTPATH_DELIMITER);
4517	RTFileDelete(log.c_str());
4518	for (int i = uLogHistoryCount; i > 0; i--)
4519	{
4520	log = Utf8StrFmt("%s%cVBox.log.%d",
4521	logFolder.c_str(), RTPATH_DELIMITER, i);
4522	RTFileDelete(log.c_str());
4523	log = Utf8StrFmt("%s%cVBox.png.%d",
4524	logFolder.c_str(), RTPATH_DELIMITER, i);
4525	RTFileDelete(log.c_str());
4526	}
4527
4528	RTDirRemove(logFolder.c_str());
4529	}
4530
4531	/* delete the Snapshots folder, nothing important should be left
4532	* there (we don't check for errors because the user might have
4533	* some private files there that we don't want to delete) */
4534	Assert(mUserData->m_strSnapshotFolderFull.length());
4535	if (RTDirExists(mUserData->m_strSnapshotFolderFull.c_str()))
4536	RTDirRemove(mUserData->m_strSnapshotFolderFull.c_str());
4537
4538	/* delete the directory that contains the settings file, but only
4539	* if it matches the VM name (i.e. a structure created by default in
4540	* prepareSaveSettings()) */
4541	{
4542	Utf8Str settingsDir;
4543	if (isInOwnDir(&settingsDir))
4544	RTDirRemove(settingsDir.c_str());
4545	}
4546	}
4547
4548	alock.release();
4549
4550	if (task.fNeedsGlobalSaveSettings)
4551	{
4552	AutoWriteLock vboxlock(mParent COMMA_LOCKVAL_SRC_POS);
4553	mParent->saveSettings();
4554	}
4555
4556	return S_OK;
4557	}
4558
4559	STDMETHODIMP Machine::GetSnapshot(IN_BSTR aId, ISnapshot **aSnapshot)
4560	{
4561	CheckComArgOutPointerValid(aSnapshot);
4562
4563	AutoCaller autoCaller(this);
4564	if (FAILED(autoCaller.rc())) return autoCaller.rc();
4565
4566	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4567
4568	Guid uuid(aId);
4569	/* Todo: fix this properly by perhaps introducing an isValid method for the Guid class */
4570	if ( (aId)
4571	&& (*aId != '\0') // an empty Bstr means "get root snapshot", so don't fail on that
4572	&& (uuid.isEmpty()))
4573	{
4574	RTUUID uuidTemp;
4575	/* Either it's a null UUID or the conversion failed. (null uuid has a special meaning in findSnapshot) */
4576	if (RT_FAILURE(RTUuidFromUtf16(&uuidTemp, aId)))
4577	return setError(E_FAIL,
4578	tr("Could not find a snapshot with UUID {%ls}"),
4579	aId);
4580	}
4581
4582	ComObjPtr<Snapshot> snapshot;
4583
4584	HRESULT rc = findSnapshot(uuid, snapshot, true /* aSetError */);
4585	snapshot.queryInterfaceTo(aSnapshot);
4586
4587	return rc;
4588	}
4589
4590	STDMETHODIMP Machine::FindSnapshot(IN_BSTR aName, ISnapshot **aSnapshot)
4591	{
4592	CheckComArgStrNotEmptyOrNull(aName);
4593	CheckComArgOutPointerValid(aSnapshot);
4594
4595	AutoCaller autoCaller(this);
4596	if (FAILED(autoCaller.rc())) return autoCaller.rc();
4597
4598	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4599
4600	ComObjPtr<Snapshot> snapshot;
4601
4602	HRESULT rc = findSnapshot(aName, snapshot, true /* aSetError */);
4603	snapshot.queryInterfaceTo(aSnapshot);
4604
4605	return rc;
4606	}
4607
4608	STDMETHODIMP Machine::SetCurrentSnapshot(IN_BSTR /* aId */)
4609	{
4610	/// @todo (dmik) don't forget to set
4611	// mData->mCurrentStateModified to FALSE
4612
4613	return setError(E_NOTIMPL, "Not implemented");
4614	}
4615
4616	STDMETHODIMP Machine::CreateSharedFolder(IN_BSTR aName, IN_BSTR aHostPath, BOOL aWritable, BOOL aAutoMount)
4617	{
4618	CheckComArgStrNotEmptyOrNull(aName);
4619	CheckComArgStrNotEmptyOrNull(aHostPath);
4620
4621	AutoCaller autoCaller(this);
4622	if (FAILED(autoCaller.rc())) return autoCaller.rc();
4623
4624	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4625
4626	HRESULT rc = checkStateDependency(MutableStateDep);
4627	if (FAILED(rc)) return rc;
4628
4629	ComObjPtr<SharedFolder> sharedFolder;
4630	rc = findSharedFolder(aName, sharedFolder, false /* aSetError */);
4631	if (SUCCEEDED(rc))
4632	return setError(VBOX_E_OBJECT_IN_USE,
4633	tr("Shared folder named '%ls' already exists"),
4634	aName);
4635
4636	sharedFolder.createObject();
4637	rc = sharedFolder->init(getMachine(), aName, aHostPath, aWritable, aAutoMount);
4638	if (FAILED(rc)) return rc;
4639
4640	setModified(IsModified_SharedFolders);
4641	mHWData.backup();
4642	mHWData->mSharedFolders.push_back(sharedFolder);
4643
4644	/* inform the direct session if any */
4645	alock.leave();
4646	onSharedFolderChange();
4647
4648	return S_OK;
4649	}
4650
4651	STDMETHODIMP Machine::RemoveSharedFolder(IN_BSTR aName)
4652	{
4653	CheckComArgStrNotEmptyOrNull(aName);
4654
4655	AutoCaller autoCaller(this);
4656	if (FAILED(autoCaller.rc())) return autoCaller.rc();
4657
4658	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4659
4660	HRESULT rc = checkStateDependency(MutableStateDep);
4661	if (FAILED(rc)) return rc;
4662
4663	ComObjPtr<SharedFolder> sharedFolder;
4664	rc = findSharedFolder(aName, sharedFolder, true /* aSetError */);
4665	if (FAILED(rc)) return rc;
4666
4667	setModified(IsModified_SharedFolders);
4668	mHWData.backup();
4669	mHWData->mSharedFolders.remove(sharedFolder);
4670
4671	/* inform the direct session if any */
4672	alock.leave();
4673	onSharedFolderChange();
4674
4675	return S_OK;
4676	}
4677
4678	STDMETHODIMP Machine::CanShowConsoleWindow(BOOL *aCanShow)
4679	{
4680	CheckComArgOutPointerValid(aCanShow);
4681
4682	/* start with No */
4683	*aCanShow = FALSE;
4684
4685	AutoCaller autoCaller(this);
4686	AssertComRCReturnRC(autoCaller.rc());
4687
4688	ComPtr<IInternalSessionControl> directControl;
4689	{
4690	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4691
4692	if (mData->mSession.mState != SessionState_Locked)
4693	return setError(VBOX_E_INVALID_VM_STATE,
4694	tr("Machine is not locked for session (session state: %s)"),
4695	Global::stringifySessionState(mData->mSession.mState));
4696
4697	directControl = mData->mSession.mDirectControl;
4698	}
4699
4700	/* ignore calls made after #OnSessionEnd() is called */
4701	if (!directControl)
4702	return S_OK;
4703
4704	LONG64 dummy;
4705	return directControl->OnShowWindow(TRUE /* aCheck */, aCanShow, &dummy);
4706	}
4707
4708	STDMETHODIMP Machine::ShowConsoleWindow(LONG64 *aWinId)
4709	{
4710	CheckComArgOutPointerValid(aWinId);
4711
4712	AutoCaller autoCaller(this);
4713	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
4714
4715	ComPtr<IInternalSessionControl> directControl;
4716	{
4717	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4718
4719	if (mData->mSession.mState != SessionState_Locked)
4720	return setError(E_FAIL,
4721	tr("Machine is not locked for session (session state: %s)"),
4722	Global::stringifySessionState(mData->mSession.mState));
4723
4724	directControl = mData->mSession.mDirectControl;
4725	}
4726
4727	/* ignore calls made after #OnSessionEnd() is called */
4728	if (!directControl)
4729	return S_OK;
4730
4731	BOOL dummy;
4732	return directControl->OnShowWindow(FALSE /* aCheck */, &dummy, aWinId);
4733	}
4734
4735	#ifdef VBOX_WITH_GUEST_PROPS
4736	/**
4737	* Look up a guest property in VBoxSVC's internal structures.
4738	*/
4739	HRESULT Machine::getGuestPropertyFromService(IN_BSTR aName,
4740	BSTR *aValue,
4741	LONG64 *aTimestamp,
4742	BSTR *aFlags) const
4743	{
4744	using namespace guestProp;
4745
4746	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4747	Utf8Str strName(aName);
4748	HWData::GuestPropertyList::const_iterator it;
4749
4750	for (it = mHWData->mGuestProperties.begin();
4751	it != mHWData->mGuestProperties.end(); ++it)
4752	{
4753	if (it->strName == strName)
4754	{
4755	char szFlags[MAX_FLAGS_LEN + 1];
4756	it->strValue.cloneTo(aValue);
4757	*aTimestamp = it->mTimestamp;
4758	writeFlags(it->mFlags, szFlags);
4759	Bstr(szFlags).cloneTo(aFlags);
4760	break;
4761	}
4762	}
4763	return S_OK;
4764	}
4765
4766	/**
4767	* Query the VM that a guest property belongs to for the property.
4768	* @returns E_ACCESSDENIED if the VM process is not available or not
4769	* currently handling queries and the lookup should then be done in
4770	* VBoxSVC.
4771	*/
4772	HRESULT Machine::getGuestPropertyFromVM(IN_BSTR aName,
4773	BSTR *aValue,
4774	LONG64 *aTimestamp,
4775	BSTR *aFlags) const
4776	{
4777	HRESULT rc;
4778	ComPtr<IInternalSessionControl> directControl;
4779	directControl = mData->mSession.mDirectControl;
4780
4781	/* fail if we were called after #OnSessionEnd() is called. This is a
4782	* silly race condition. */
4783
4784	if (!directControl)
4785	rc = E_ACCESSDENIED;
4786	else
4787	rc = directControl->AccessGuestProperty(aName, NULL, NULL,
4788	false /* isSetter */,
4789	aValue, aTimestamp, aFlags);
4790	return rc;
4791	}
4792	#endif // VBOX_WITH_GUEST_PROPS
4793
4794	STDMETHODIMP Machine::GetGuestProperty(IN_BSTR aName,
4795	BSTR *aValue,
4796	LONG64 *aTimestamp,
4797	BSTR *aFlags)
4798	{
4799	#ifndef VBOX_WITH_GUEST_PROPS
4800	ReturnComNotImplemented();
4801	#else // VBOX_WITH_GUEST_PROPS
4802	CheckComArgStrNotEmptyOrNull(aName);
4803	CheckComArgOutPointerValid(aValue);
4804	CheckComArgOutPointerValid(aTimestamp);
4805	CheckComArgOutPointerValid(aFlags);
4806
4807	AutoCaller autoCaller(this);
4808	if (FAILED(autoCaller.rc())) return autoCaller.rc();
4809
4810	HRESULT rc = getGuestPropertyFromVM(aName, aValue, aTimestamp, aFlags);
4811	if (rc == E_ACCESSDENIED)
4812	/* The VM is not running or the service is not (yet) accessible */
4813	rc = getGuestPropertyFromService(aName, aValue, aTimestamp, aFlags);
4814	return rc;
4815	#endif // VBOX_WITH_GUEST_PROPS
4816	}
4817
4818	STDMETHODIMP Machine::GetGuestPropertyValue(IN_BSTR aName, BSTR *aValue)
4819	{
4820	LONG64 dummyTimestamp;
4821	Bstr dummyFlags;
4822	return GetGuestProperty(aName, aValue, &dummyTimestamp, dummyFlags.asOutParam());
4823	}
4824
4825	STDMETHODIMP Machine::GetGuestPropertyTimestamp(IN_BSTR aName, LONG64 *aTimestamp)
4826	{
4827	Bstr dummyValue;
4828	Bstr dummyFlags;
4829	return GetGuestProperty(aName, dummyValue.asOutParam(), aTimestamp, dummyFlags.asOutParam());
4830	}
4831
4832	#ifdef VBOX_WITH_GUEST_PROPS
4833	/**
4834	* Set a guest property in VBoxSVC's internal structures.
4835	*/
4836	HRESULT Machine::setGuestPropertyToService(IN_BSTR aName, IN_BSTR aValue,
4837	IN_BSTR aFlags)
4838	{
4839	using namespace guestProp;
4840
4841	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4842	HRESULT rc = S_OK;
4843	HWData::GuestProperty property;
4844	property.mFlags = NILFLAG;
4845	bool found = false;
4846
4847	rc = checkStateDependency(MutableStateDep);
4848	if (FAILED(rc)) return rc;
4849
4850	try
4851	{
4852	Utf8Str utf8Name(aName);
4853	Utf8Str utf8Flags(aFlags);
4854	uint32_t fFlags = NILFLAG;
4855	if ( (aFlags != NULL)
4856	&& RT_FAILURE(validateFlags(utf8Flags.c_str(), &fFlags))
4857	)
4858	return setError(E_INVALIDARG,
4859	tr("Invalid flag values: '%ls'"),
4860	aFlags);
4861
4862	/** @todo r=bird: see efficiency rant in PushGuestProperty. (Yeah, I
4863	* know, this is simple and do an OK job atm.) */
4864	HWData::GuestPropertyList::iterator it;
4865	for (it = mHWData->mGuestProperties.begin();
4866	it != mHWData->mGuestProperties.end(); ++it)
4867	if (it->strName == utf8Name)
4868	{
4869	property = *it;
4870	if (it->mFlags & (RDONLYHOST))
4871	rc = setError(E_ACCESSDENIED,
4872	tr("The property '%ls' cannot be changed by the host"),
4873	aName);
4874	else
4875	{
4876	setModified(IsModified_MachineData);
4877	mHWData.backup(); // @todo r=dj backup in a loop?!?
4878
4879	/* The backup() operation invalidates our iterator, so
4880	* get a new one. */
4881	for (it = mHWData->mGuestProperties.begin();
4882	it->strName != utf8Name;
4883	++it)
4884	;
4885	mHWData->mGuestProperties.erase(it);
4886	}
4887	found = true;
4888	break;
4889	}
4890	if (found && SUCCEEDED(rc))
4891	{
4892	if (*aValue)
4893	{
4894	RTTIMESPEC time;
4895	property.strValue = aValue;
4896	property.mTimestamp = RTTimeSpecGetNano(RTTimeNow(&time));
4897	if (aFlags != NULL)
4898	property.mFlags = fFlags;
4899	mHWData->mGuestProperties.push_back(property);
4900	}
4901	}
4902	else if (SUCCEEDED(rc) && *aValue)
4903	{
4904	RTTIMESPEC time;
4905	setModified(IsModified_MachineData);
4906	mHWData.backup();
4907	property.strName = aName;
4908	property.strValue = aValue;
4909	property.mTimestamp = RTTimeSpecGetNano(RTTimeNow(&time));
4910	property.mFlags = fFlags;
4911	mHWData->mGuestProperties.push_back(property);
4912	}
4913	if ( SUCCEEDED(rc)
4914	&& ( mHWData->mGuestPropertyNotificationPatterns.isEmpty()
4915	\|\| RTStrSimplePatternMultiMatch(mHWData->mGuestPropertyNotificationPatterns.c_str(),
4916	RTSTR_MAX,
4917	utf8Name.c_str(),
4918	RTSTR_MAX,
4919	NULL)
4920	)
4921	)
4922	{
4923	/** @todo r=bird: Why aren't we leaving the lock here? The
4924	* same code in PushGuestProperty does... */
4925	mParent->onGuestPropertyChange(mData->mUuid, aName, aValue, aFlags);
4926	}
4927	}
4928	catch (std::bad_alloc &)
4929	{
4930	rc = E_OUTOFMEMORY;
4931	}
4932
4933	return rc;
4934	}
4935
4936	/**
4937	* Set a property on the VM that that property belongs to.
4938	* @returns E_ACCESSDENIED if the VM process is not available or not
4939	* currently handling queries and the setting should then be done in
4940	* VBoxSVC.
4941	*/
4942	HRESULT Machine::setGuestPropertyToVM(IN_BSTR aName, IN_BSTR aValue,
4943	IN_BSTR aFlags)
4944	{
4945	HRESULT rc;
4946
4947	try {
4948	ComPtr<IInternalSessionControl> directControl =
4949	mData->mSession.mDirectControl;
4950
4951	BSTR dummy = NULL; /* will not be changed (setter) */
4952	LONG64 dummy64;
4953	if (!directControl)
4954	rc = E_ACCESSDENIED;
4955	else
4956	rc = directControl->AccessGuestProperty
4957	(aName,
4958	/** @todo Fix when adding DeleteGuestProperty(),
4959	see defect. */
4960	aValue ? aValue : NULL, aFlags, true / isSetter */,
4961	&dummy, &dummy64, &dummy);
4962	}
4963	catch (std::bad_alloc &)
4964	{
4965	rc = E_OUTOFMEMORY;
4966	}
4967
4968	return rc;
4969	}
4970	#endif // VBOX_WITH_GUEST_PROPS
4971
4972	STDMETHODIMP Machine::SetGuestProperty(IN_BSTR aName, IN_BSTR aValue,
4973	IN_BSTR aFlags)
4974	{
4975	#ifndef VBOX_WITH_GUEST_PROPS
4976	ReturnComNotImplemented();
4977	#else // VBOX_WITH_GUEST_PROPS
4978	CheckComArgStrNotEmptyOrNull(aName);
4979	if ((aFlags != NULL) && !VALID_PTR(aFlags))
4980	return E_INVALIDARG;
4981	AutoCaller autoCaller(this);
4982	if (FAILED(autoCaller.rc())) return autoCaller.rc();
4983
4984	HRESULT rc = setGuestPropertyToVM(aName, aValue, aFlags);
4985	if (rc == E_ACCESSDENIED)
4986	/* The VM is not running or the service is not (yet) accessible */
4987	rc = setGuestPropertyToService(aName, aValue, aFlags);
4988	return rc;
4989	#endif // VBOX_WITH_GUEST_PROPS
4990	}
4991
4992	STDMETHODIMP Machine::SetGuestPropertyValue(IN_BSTR aName, IN_BSTR aValue)
4993	{
4994	return SetGuestProperty(aName, aValue, NULL);
4995	}
4996
4997	#ifdef VBOX_WITH_GUEST_PROPS
4998	/**
4999	* Enumerate the guest properties in VBoxSVC's internal structures.
5000	*/
5001	HRESULT Machine::enumerateGuestPropertiesInService
5002	(IN_BSTR aPatterns, ComSafeArrayOut(BSTR, aNames),
5003	ComSafeArrayOut(BSTR, aValues),
5004	ComSafeArrayOut(LONG64, aTimestamps),
5005	ComSafeArrayOut(BSTR, aFlags))
5006	{
5007	using namespace guestProp;
5008
5009	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5010	Utf8Str strPatterns(aPatterns);
5011
5012	/*
5013	* Look for matching patterns and build up a list.
5014	*/
5015	HWData::GuestPropertyList propList;
5016	for (HWData::GuestPropertyList::iterator it = mHWData->mGuestProperties.begin();
5017	it != mHWData->mGuestProperties.end();
5018	++it)
5019	if ( strPatterns.isEmpty()
5020	\|\| RTStrSimplePatternMultiMatch(strPatterns.c_str(),
5021	RTSTR_MAX,
5022	it->strName.c_str(),
5023	RTSTR_MAX,
5024	NULL)
5025	)
5026	propList.push_back(*it);
5027
5028	/*
5029	* And build up the arrays for returning the property information.
5030	*/
5031	size_t cEntries = propList.size();
5032	SafeArray<BSTR> names(cEntries);
5033	SafeArray<BSTR> values(cEntries);
5034	SafeArray<LONG64> timestamps(cEntries);
5035	SafeArray<BSTR> flags(cEntries);
5036	size_t iProp = 0;
5037	for (HWData::GuestPropertyList::iterator it = propList.begin();
5038	it != propList.end();
5039	++it)
5040	{
5041	char szFlags[MAX_FLAGS_LEN + 1];
5042	it->strName.cloneTo(&names[iProp]);
5043	it->strValue.cloneTo(&values[iProp]);
5044	timestamps[iProp] = it->mTimestamp;
5045	writeFlags(it->mFlags, szFlags);
5046	Bstr(szFlags).cloneTo(&flags[iProp]);
5047	++iProp;
5048	}
5049	names.detachTo(ComSafeArrayOutArg(aNames));
5050	values.detachTo(ComSafeArrayOutArg(aValues));
5051	timestamps.detachTo(ComSafeArrayOutArg(aTimestamps));
5052	flags.detachTo(ComSafeArrayOutArg(aFlags));
5053	return S_OK;
5054	}
5055
5056	/**
5057	* Enumerate the properties managed by a VM.
5058	* @returns E_ACCESSDENIED if the VM process is not available or not
5059	* currently handling queries and the setting should then be done in
5060	* VBoxSVC.
5061	*/
5062	HRESULT Machine::enumerateGuestPropertiesOnVM
5063	(IN_BSTR aPatterns, ComSafeArrayOut(BSTR, aNames),
5064	ComSafeArrayOut(BSTR, aValues),
5065	ComSafeArrayOut(LONG64, aTimestamps),
5066	ComSafeArrayOut(BSTR, aFlags))
5067	{
5068	HRESULT rc;
5069	ComPtr<IInternalSessionControl> directControl;
5070	directControl = mData->mSession.mDirectControl;
5071
5072	if (!directControl)
5073	rc = E_ACCESSDENIED;
5074	else
5075	rc = directControl->EnumerateGuestProperties
5076	(aPatterns, ComSafeArrayOutArg(aNames),
5077	ComSafeArrayOutArg(aValues),
5078	ComSafeArrayOutArg(aTimestamps),
5079	ComSafeArrayOutArg(aFlags));
5080	return rc;
5081	}
5082	#endif // VBOX_WITH_GUEST_PROPS
5083
5084	STDMETHODIMP Machine::EnumerateGuestProperties(IN_BSTR aPatterns,
5085	ComSafeArrayOut(BSTR, aNames),
5086	ComSafeArrayOut(BSTR, aValues),
5087	ComSafeArrayOut(LONG64, aTimestamps),
5088	ComSafeArrayOut(BSTR, aFlags))
5089	{
5090	#ifndef VBOX_WITH_GUEST_PROPS
5091	ReturnComNotImplemented();
5092	#else // VBOX_WITH_GUEST_PROPS
5093	if (!VALID_PTR(aPatterns) && (aPatterns != NULL))
5094	return E_POINTER;
5095
5096	CheckComArgOutSafeArrayPointerValid(aNames);
5097	CheckComArgOutSafeArrayPointerValid(aValues);
5098	CheckComArgOutSafeArrayPointerValid(aTimestamps);
5099	CheckComArgOutSafeArrayPointerValid(aFlags);
5100
5101	AutoCaller autoCaller(this);
5102	if (FAILED(autoCaller.rc())) return autoCaller.rc();
5103
5104	HRESULT rc = enumerateGuestPropertiesOnVM
5105	(aPatterns, ComSafeArrayOutArg(aNames),
5106	ComSafeArrayOutArg(aValues),
5107	ComSafeArrayOutArg(aTimestamps),
5108	ComSafeArrayOutArg(aFlags));
5109	if (rc == E_ACCESSDENIED)
5110	/* The VM is not running or the service is not (yet) accessible */
5111	rc = enumerateGuestPropertiesInService
5112	(aPatterns, ComSafeArrayOutArg(aNames),
5113	ComSafeArrayOutArg(aValues),
5114	ComSafeArrayOutArg(aTimestamps),
5115	ComSafeArrayOutArg(aFlags));
5116	return rc;
5117	#endif // VBOX_WITH_GUEST_PROPS
5118	}
5119
5120	STDMETHODIMP Machine::GetMediumAttachmentsOfController(IN_BSTR aName,
5121	ComSafeArrayOut(IMediumAttachment*, aAttachments))
5122	{
5123	MediaData::AttachmentList atts;
5124
5125	HRESULT rc = getMediumAttachmentsOfController(aName, atts);
5126	if (FAILED(rc)) return rc;
5127
5128	SafeIfaceArray<IMediumAttachment> attachments(atts);
5129	attachments.detachTo(ComSafeArrayOutArg(aAttachments));
5130
5131	return S_OK;
5132	}
5133
5134	STDMETHODIMP Machine::GetMediumAttachment(IN_BSTR aControllerName,
5135	LONG aControllerPort,
5136	LONG aDevice,
5137	IMediumAttachment **aAttachment)
5138	{
5139	LogFlowThisFunc(("aControllerName=\"%ls\" aControllerPort=%d aDevice=%d\n",
5140	aControllerName, aControllerPort, aDevice));
5141
5142	CheckComArgStrNotEmptyOrNull(aControllerName);
5143	CheckComArgOutPointerValid(aAttachment);
5144
5145	AutoCaller autoCaller(this);
5146	if (FAILED(autoCaller.rc())) return autoCaller.rc();
5147
5148	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5149
5150	*aAttachment = NULL;
5151
5152	ComObjPtr<MediumAttachment> pAttach = findAttachment(mMediaData->mAttachments,
5153	aControllerName,
5154	aControllerPort,
5155	aDevice);
5156	if (pAttach.isNull())
5157	return setError(VBOX_E_OBJECT_NOT_FOUND,
5158	tr("No storage device attached to device slot %d on port %d of controller '%ls'"),
5159	aDevice, aControllerPort, aControllerName);
5160
5161	pAttach.queryInterfaceTo(aAttachment);
5162
5163	return S_OK;
5164	}
5165
5166	STDMETHODIMP Machine::AddStorageController(IN_BSTR aName,
5167	StorageBus_T aConnectionType,
5168	IStorageController **controller)
5169	{
5170	CheckComArgStrNotEmptyOrNull(aName);
5171
5172	if ( (aConnectionType <= StorageBus_Null)
5173	\|\| (aConnectionType > StorageBus_SAS))
5174	return setError(E_INVALIDARG,
5175	tr("Invalid connection type: %d"),
5176	aConnectionType);
5177
5178	AutoCaller autoCaller(this);
5179	if (FAILED(autoCaller.rc())) return autoCaller.rc();
5180
5181	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5182
5183	HRESULT rc = checkStateDependency(MutableStateDep);
5184	if (FAILED(rc)) return rc;
5185
5186	/* try to find one with the name first. */
5187	ComObjPtr<StorageController> ctrl;
5188
5189	rc = getStorageControllerByName(aName, ctrl, false /* aSetError */);
5190	if (SUCCEEDED(rc))
5191	return setError(VBOX_E_OBJECT_IN_USE,
5192	tr("Storage controller named '%ls' already exists"),
5193	aName);
5194
5195	ctrl.createObject();
5196
5197	/* get a new instance number for the storage controller */
5198	ULONG ulInstance = 0;
5199	for (StorageControllerList::const_iterator it = mStorageControllers->begin();
5200	it != mStorageControllers->end();
5201	++it)
5202	{
5203	if ((*it)->getStorageBus() == aConnectionType)
5204	{
5205	ULONG ulCurInst = (*it)->getInstance();
5206
5207	if (ulCurInst >= ulInstance)
5208	ulInstance = ulCurInst + 1;
5209	}
5210	}
5211
5212	rc = ctrl->init(this, aName, aConnectionType, ulInstance);
5213	if (FAILED(rc)) return rc;
5214
5215	setModified(IsModified_Storage);
5216	mStorageControllers.backup();
5217	mStorageControllers->push_back(ctrl);
5218
5219	ctrl.queryInterfaceTo(controller);
5220
5221	/* inform the direct session if any */
5222	alock.leave();
5223	onStorageControllerChange();
5224
5225	return S_OK;
5226	}
5227
5228	STDMETHODIMP Machine::GetStorageControllerByName(IN_BSTR aName,
5229	IStorageController **aStorageController)
5230	{
5231	CheckComArgStrNotEmptyOrNull(aName);
5232
5233	AutoCaller autoCaller(this);
5234	if (FAILED(autoCaller.rc())) return autoCaller.rc();
5235
5236	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5237
5238	ComObjPtr<StorageController> ctrl;
5239
5240	HRESULT rc = getStorageControllerByName(aName, ctrl, true /* aSetError */);
5241	if (SUCCEEDED(rc))
5242	ctrl.queryInterfaceTo(aStorageController);
5243
5244	return rc;
5245	}
5246
5247	STDMETHODIMP Machine::GetStorageControllerByInstance(ULONG aInstance,
5248	IStorageController **aStorageController)
5249	{
5250	AutoCaller autoCaller(this);
5251	if (FAILED(autoCaller.rc())) return autoCaller.rc();
5252
5253	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5254
5255	for (StorageControllerList::const_iterator it = mStorageControllers->begin();
5256	it != mStorageControllers->end();
5257	++it)
5258	{
5259	if ((*it)->getInstance() == aInstance)
5260	{
5261	(*it).queryInterfaceTo(aStorageController);
5262	return S_OK;
5263	}
5264	}
5265
5266	return setError(VBOX_E_OBJECT_NOT_FOUND,
5267	tr("Could not find a storage controller with instance number '%lu'"),
5268	aInstance);
5269	}
5270
5271	STDMETHODIMP Machine::RemoveStorageController(IN_BSTR aName)
5272	{
5273	CheckComArgStrNotEmptyOrNull(aName);
5274
5275	AutoCaller autoCaller(this);
5276	if (FAILED(autoCaller.rc())) return autoCaller.rc();
5277
5278	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5279
5280	HRESULT rc = checkStateDependency(MutableStateDep);
5281	if (FAILED(rc)) return rc;
5282
5283	ComObjPtr<StorageController> ctrl;
5284	rc = getStorageControllerByName(aName, ctrl, true /* aSetError */);
5285	if (FAILED(rc)) return rc;
5286
5287	/* We can remove the controller only if there is no device attached. */
5288	/* check if the device slot is already busy */
5289	for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
5290	it != mMediaData->mAttachments.end();
5291	++it)
5292	{
5293	if ((*it)->getControllerName() == aName)
5294	return setError(VBOX_E_OBJECT_IN_USE,
5295	tr("Storage controller named '%ls' has still devices attached"),
5296	aName);
5297	}
5298
5299	/* We can remove it now. */
5300	setModified(IsModified_Storage);
5301	mStorageControllers.backup();
5302
5303	ctrl->unshare();
5304
5305	mStorageControllers->remove(ctrl);
5306
5307	/* inform the direct session if any */
5308	alock.leave();
5309	onStorageControllerChange();
5310
5311	return S_OK;
5312	}
5313
5314	STDMETHODIMP Machine::QuerySavedGuestSize(ULONG uScreenId, ULONG puWidth, ULONG puHeight)
5315	{
5316	LogFlowThisFunc(("\n"));
5317
5318	CheckComArgNotNull(puWidth);
5319	CheckComArgNotNull(puHeight);
5320
5321	uint32_t u32Width = 0;
5322	uint32_t u32Height = 0;
5323
5324	int vrc = readSavedGuestSize(mSSData->mStateFilePath, uScreenId, &u32Width, &u32Height);
5325	if (RT_FAILURE(vrc))
5326	return setError(VBOX_E_IPRT_ERROR,
5327	tr("Saved guest size is not available (%Rrc)"),
5328	vrc);
5329
5330	*puWidth = u32Width;
5331	*puHeight = u32Height;
5332
5333	return S_OK;
5334	}
5335
5336	STDMETHODIMP Machine::QuerySavedThumbnailSize(ULONG aScreenId, ULONG aSize, ULONG aWidth, ULONG *aHeight)
5337	{
5338	LogFlowThisFunc(("\n"));
5339
5340	CheckComArgNotNull(aSize);
5341	CheckComArgNotNull(aWidth);
5342	CheckComArgNotNull(aHeight);
5343
5344	if (aScreenId != 0)
5345	return E_NOTIMPL;
5346
5347	AutoCaller autoCaller(this);
5348	if (FAILED(autoCaller.rc())) return autoCaller.rc();
5349
5350	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5351
5352	uint8_t *pu8Data = NULL;
5353	uint32_t cbData = 0;
5354	uint32_t u32Width = 0;
5355	uint32_t u32Height = 0;
5356
5357	int vrc = readSavedDisplayScreenshot(mSSData->mStateFilePath, 0 /* u32Type */, &pu8Data, &cbData, &u32Width, &u32Height);
5358
5359	if (RT_FAILURE(vrc))
5360	return setError(VBOX_E_IPRT_ERROR,
5361	tr("Saved screenshot data is not available (%Rrc)"),
5362	vrc);
5363
5364	*aSize = cbData;
5365	*aWidth = u32Width;
5366	*aHeight = u32Height;
5367
5368	freeSavedDisplayScreenshot(pu8Data);
5369
5370	return S_OK;
5371	}
5372
5373	STDMETHODIMP Machine::ReadSavedThumbnailToArray(ULONG aScreenId, BOOL aBGR, ULONG aWidth, ULONG aHeight, ComSafeArrayOut(BYTE, aData))
5374	{
5375	LogFlowThisFunc(("\n"));
5376
5377	CheckComArgNotNull(aWidth);
5378	CheckComArgNotNull(aHeight);
5379	CheckComArgOutSafeArrayPointerValid(aData);
5380
5381	if (aScreenId != 0)
5382	return E_NOTIMPL;
5383
5384	AutoCaller autoCaller(this);
5385	if (FAILED(autoCaller.rc())) return autoCaller.rc();
5386
5387	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5388
5389	uint8_t *pu8Data = NULL;
5390	uint32_t cbData = 0;
5391	uint32_t u32Width = 0;
5392	uint32_t u32Height = 0;
5393
5394	int vrc = readSavedDisplayScreenshot(mSSData->mStateFilePath, 0 /* u32Type */, &pu8Data, &cbData, &u32Width, &u32Height);
5395
5396	if (RT_FAILURE(vrc))
5397	return setError(VBOX_E_IPRT_ERROR,
5398	tr("Saved screenshot data is not available (%Rrc)"),
5399	vrc);
5400
5401	*aWidth = u32Width;
5402	*aHeight = u32Height;
5403
5404	com::SafeArray<BYTE> bitmap(cbData);
5405	/* Convert pixels to format expected by the API caller. */
5406	if (aBGR)
5407	{
5408	/* [0] B, [1] G, [2] R, [3] A. */
5409	for (unsigned i = 0; i < cbData; i += 4)
5410	{
5411	bitmap[i] = pu8Data[i];
5412	bitmap[i + 1] = pu8Data[i + 1];
5413	bitmap[i + 2] = pu8Data[i + 2];
5414	bitmap[i + 3] = 0xff;
5415	}
5416	}
5417	else
5418	{
5419	/* [0] R, [1] G, [2] B, [3] A. */
5420	for (unsigned i = 0; i < cbData; i += 4)
5421	{
5422	bitmap[i] = pu8Data[i + 2];
5423	bitmap[i + 1] = pu8Data[i + 1];
5424	bitmap[i + 2] = pu8Data[i];
5425	bitmap[i + 3] = 0xff;
5426	}
5427	}
5428	bitmap.detachTo(ComSafeArrayOutArg(aData));
5429
5430	freeSavedDisplayScreenshot(pu8Data);
5431
5432	return S_OK;
5433	}
5434
5435
5436	STDMETHODIMP Machine::ReadSavedThumbnailPNGToArray(ULONG aScreenId, ULONG aWidth, ULONG aHeight, ComSafeArrayOut(BYTE, aData))
5437	{
5438	LogFlowThisFunc(("\n"));
5439
5440	CheckComArgNotNull(aWidth);
5441	CheckComArgNotNull(aHeight);
5442	CheckComArgOutSafeArrayPointerValid(aData);
5443
5444	if (aScreenId != 0)
5445	return E_NOTIMPL;
5446
5447	AutoCaller autoCaller(this);
5448	if (FAILED(autoCaller.rc())) return autoCaller.rc();
5449
5450	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5451
5452	uint8_t *pu8Data = NULL;
5453	uint32_t cbData = 0;
5454	uint32_t u32Width = 0;
5455	uint32_t u32Height = 0;
5456
5457	int vrc = readSavedDisplayScreenshot(mSSData->mStateFilePath, 0 /* u32Type */, &pu8Data, &cbData, &u32Width, &u32Height);
5458
5459	if (RT_FAILURE(vrc))
5460	return setError(VBOX_E_IPRT_ERROR,
5461	tr("Saved screenshot data is not available (%Rrc)"),
5462	vrc);
5463
5464	*aWidth = u32Width;
5465	*aHeight = u32Height;
5466
5467	uint8_t *pu8PNG = NULL;
5468	uint32_t cbPNG = 0;
5469	uint32_t cxPNG = 0;
5470	uint32_t cyPNG = 0;
5471
5472	DisplayMakePNG(pu8Data, u32Width, u32Height, &pu8PNG, &cbPNG, &cxPNG, &cyPNG, 0);
5473
5474	com::SafeArray<BYTE> screenData(cbPNG);
5475	screenData.initFrom(pu8PNG, cbPNG);
5476	RTMemFree(pu8PNG);
5477
5478	screenData.detachTo(ComSafeArrayOutArg(aData));
5479
5480	freeSavedDisplayScreenshot(pu8Data);
5481
5482	return S_OK;
5483	}
5484
5485	STDMETHODIMP Machine::QuerySavedScreenshotPNGSize(ULONG aScreenId, ULONG aSize, ULONG aWidth, ULONG *aHeight)
5486	{
5487	LogFlowThisFunc(("\n"));
5488
5489	CheckComArgNotNull(aSize);
5490	CheckComArgNotNull(aWidth);
5491	CheckComArgNotNull(aHeight);
5492
5493	if (aScreenId != 0)
5494	return E_NOTIMPL;
5495
5496	AutoCaller autoCaller(this);
5497	if (FAILED(autoCaller.rc())) return autoCaller.rc();
5498
5499	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5500
5501	uint8_t *pu8Data = NULL;
5502	uint32_t cbData = 0;
5503	uint32_t u32Width = 0;
5504	uint32_t u32Height = 0;
5505
5506	int vrc = readSavedDisplayScreenshot(mSSData->mStateFilePath, 1 /* u32Type */, &pu8Data, &cbData, &u32Width, &u32Height);
5507
5508	if (RT_FAILURE(vrc))
5509	return setError(VBOX_E_IPRT_ERROR,
5510	tr("Saved screenshot data is not available (%Rrc)"),
5511	vrc);
5512
5513	*aSize = cbData;
5514	*aWidth = u32Width;
5515	*aHeight = u32Height;
5516
5517	freeSavedDisplayScreenshot(pu8Data);
5518
5519	return S_OK;
5520	}
5521
5522	STDMETHODIMP Machine::ReadSavedScreenshotPNGToArray(ULONG aScreenId, ULONG aWidth, ULONG aHeight, ComSafeArrayOut(BYTE, aData))
5523	{
5524	LogFlowThisFunc(("\n"));
5525
5526	CheckComArgNotNull(aWidth);
5527	CheckComArgNotNull(aHeight);
5528	CheckComArgOutSafeArrayPointerValid(aData);
5529
5530	if (aScreenId != 0)
5531	return E_NOTIMPL;
5532
5533	AutoCaller autoCaller(this);
5534	if (FAILED(autoCaller.rc())) return autoCaller.rc();
5535
5536	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5537
5538	uint8_t *pu8Data = NULL;
5539	uint32_t cbData = 0;
5540	uint32_t u32Width = 0;
5541	uint32_t u32Height = 0;
5542
5543	int vrc = readSavedDisplayScreenshot(mSSData->mStateFilePath, 1 /* u32Type */, &pu8Data, &cbData, &u32Width, &u32Height);
5544
5545	if (RT_FAILURE(vrc))
5546	return setError(VBOX_E_IPRT_ERROR,
5547	tr("Saved screenshot thumbnail data is not available (%Rrc)"),
5548	vrc);
5549
5550	*aWidth = u32Width;
5551	*aHeight = u32Height;
5552
5553	com::SafeArray<BYTE> png(cbData);
5554	png.initFrom(pu8Data, cbData);
5555	png.detachTo(ComSafeArrayOutArg(aData));
5556
5557	freeSavedDisplayScreenshot(pu8Data);
5558
5559	return S_OK;
5560	}
5561
5562	STDMETHODIMP Machine::HotPlugCPU(ULONG aCpu)
5563	{
5564	HRESULT rc = S_OK;
5565	LogFlowThisFunc(("\n"));
5566
5567	AutoCaller autoCaller(this);
5568	if (FAILED(autoCaller.rc())) return autoCaller.rc();
5569
5570	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5571
5572	if (!mHWData->mCPUHotPlugEnabled)
5573	return setError(E_INVALIDARG, tr("CPU hotplug is not enabled"));
5574
5575	if (aCpu >= mHWData->mCPUCount)
5576	return setError(E_INVALIDARG, tr("CPU id exceeds number of possible CPUs [0:%lu]"), mHWData->mCPUCount-1);
5577
5578	if (mHWData->mCPUAttached[aCpu])
5579	return setError(VBOX_E_OBJECT_IN_USE, tr("CPU %lu is already attached"), aCpu);
5580
5581	alock.release();
5582	rc = onCPUChange(aCpu, false);
5583	alock.acquire();
5584	if (FAILED(rc)) return rc;
5585
5586	setModified(IsModified_MachineData);
5587	mHWData.backup();
5588	mHWData->mCPUAttached[aCpu] = true;
5589
5590	/* Save settings if online */
5591	if (Global::IsOnline(mData->mMachineState))
5592	saveSettings(NULL);
5593
5594	return S_OK;
5595	}
5596
5597	STDMETHODIMP Machine::HotUnplugCPU(ULONG aCpu)
5598	{
5599	HRESULT rc = S_OK;
5600	LogFlowThisFunc(("\n"));
5601
5602	AutoCaller autoCaller(this);
5603	if (FAILED(autoCaller.rc())) return autoCaller.rc();
5604
5605	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5606
5607	if (!mHWData->mCPUHotPlugEnabled)
5608	return setError(E_INVALIDARG, tr("CPU hotplug is not enabled"));
5609
5610	if (aCpu >= SchemaDefs::MaxCPUCount)
5611	return setError(E_INVALIDARG,
5612	tr("CPU index exceeds maximum CPU count (must be in range [0:%lu])"),
5613	SchemaDefs::MaxCPUCount);
5614
5615	if (!mHWData->mCPUAttached[aCpu])
5616	return setError(VBOX_E_OBJECT_NOT_FOUND, tr("CPU %lu is not attached"), aCpu);
5617
5618	/* CPU 0 can't be detached */
5619	if (aCpu == 0)
5620	return setError(E_INVALIDARG, tr("It is not possible to detach CPU 0"));
5621
5622	alock.release();
5623	rc = onCPUChange(aCpu, true);
5624	alock.acquire();
5625	if (FAILED(rc)) return rc;
5626
5627	setModified(IsModified_MachineData);
5628	mHWData.backup();
5629	mHWData->mCPUAttached[aCpu] = false;
5630
5631	/* Save settings if online */
5632	if (Global::IsOnline(mData->mMachineState))
5633	saveSettings(NULL);
5634
5635	return S_OK;
5636	}
5637
5638	STDMETHODIMP Machine::GetCPUStatus(ULONG aCpu, BOOL *aCpuAttached)
5639	{
5640	LogFlowThisFunc(("\n"));
5641
5642	CheckComArgNotNull(aCpuAttached);
5643
5644	*aCpuAttached = false;
5645
5646	AutoCaller autoCaller(this);
5647	if (FAILED(autoCaller.rc())) return autoCaller.rc();
5648
5649	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5650
5651	/* If hotplug is enabled the CPU is always enabled. */
5652	if (!mHWData->mCPUHotPlugEnabled)
5653	{
5654	if (aCpu < mHWData->mCPUCount)
5655	*aCpuAttached = true;
5656	}
5657	else
5658	{
5659	if (aCpu < SchemaDefs::MaxCPUCount)
5660	*aCpuAttached = mHWData->mCPUAttached[aCpu];
5661	}
5662
5663	return S_OK;
5664	}
5665
5666	STDMETHODIMP Machine::QueryLogFilename(ULONG aIdx, BSTR *aName)
5667	{
5668	CheckComArgOutPointerValid(aName);
5669
5670	AutoCaller autoCaller(this);
5671	if (FAILED(autoCaller.rc())) return autoCaller.rc();
5672
5673	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5674
5675	Utf8Str log = queryLogFilename(aIdx);
5676	if (!RTFileExists(log.c_str()))
5677	log.setNull();
5678	log.cloneTo(aName);
5679
5680	return S_OK;
5681	}
5682
5683	STDMETHODIMP Machine::ReadLog(ULONG aIdx, LONG64 aOffset, LONG64 aSize, ComSafeArrayOut(BYTE, aData))
5684	{
5685	LogFlowThisFunc(("\n"));
5686	CheckComArgOutSafeArrayPointerValid(aData);
5687	if (aSize < 0)
5688	return setError(E_INVALIDARG, tr("The size argument (%lld) is negative"), aSize);
5689
5690	AutoCaller autoCaller(this);
5691	if (FAILED(autoCaller.rc())) return autoCaller.rc();
5692
5693	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5694
5695	HRESULT rc = S_OK;
5696	Utf8Str log = queryLogFilename(aIdx);
5697
5698	/* do not unnecessarily hold the lock while doing something which does
5699	* not need the lock and potentially takes a long time. */
5700	alock.release();
5701
5702	/* Limit the chunk size to 32K for now, as that gives better performance
5703	* over (XP)COM, and keeps the SOAP reply size under 1M for the webservice.
5704	* One byte expands to approx. 25 bytes of breathtaking XML. */
5705	size_t cbData = (size_t)RT_MIN(aSize, 32768);
5706	com::SafeArray<BYTE> logData(cbData);
5707
5708	RTFILE LogFile;
5709	int vrc = RTFileOpen(&LogFile, log.c_str(),
5710	RTFILE_O_OPEN \| RTFILE_O_READ \| RTFILE_O_DENY_NONE);
5711	if (RT_SUCCESS(vrc))
5712	{
5713	vrc = RTFileReadAt(LogFile, aOffset, logData.raw(), cbData, &cbData);
5714	if (RT_SUCCESS(vrc))
5715	logData.resize(cbData);
5716	else
5717	rc = setError(VBOX_E_IPRT_ERROR,
5718	tr("Could not read log file '%s' (%Rrc)"),
5719	log.c_str(), vrc);
5720	RTFileClose(LogFile);
5721	}
5722	else
5723	rc = setError(VBOX_E_IPRT_ERROR,
5724	tr("Could not open log file '%s' (%Rrc)"),
5725	log.c_str(), vrc);
5726
5727	if (FAILED(rc))
5728	logData.resize(0);
5729	logData.detachTo(ComSafeArrayOutArg(aData));
5730
5731	return rc;
5732	}
5733
5734
5735	// public methods for internal purposes
5736	/////////////////////////////////////////////////////////////////////////////
5737
5738	/**
5739	* Adds the given IsModified_* flag to the dirty flags of the machine.
5740	* This must be called either during loadSettings or under the machine write lock.
5741	* @param fl
5742	*/
5743	void Machine::setModified(uint32_t fl)
5744	{
5745	mData->flModifications \|= fl;
5746	}
5747
5748	/**
5749	* Saves the registry entry of this machine to the given configuration node.
5750	*
5751	* @param aEntryNode Node to save the registry entry to.
5752	*
5753	* @note locks this object for reading.
5754	*/
5755	HRESULT Machine::saveRegistryEntry(settings::MachineRegistryEntry &data)
5756	{
5757	AutoLimitedCaller autoCaller(this);
5758	AssertComRCReturnRC(autoCaller.rc());
5759
5760	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5761
5762	data.uuid = mData->mUuid;
5763	data.strSettingsFile = mData->m_strConfigFile;
5764
5765	return S_OK;
5766	}
5767
5768	/**
5769	* Calculates the absolute path of the given path taking the directory of the
5770	* machine settings file as the current directory.
5771	*
5772	* @param aPath Path to calculate the absolute path for.
5773	* @param aResult Where to put the result (used only on success, can be the
5774	* same Utf8Str instance as passed in @a aPath).
5775	* @return IPRT result.
5776	*
5777	* @note Locks this object for reading.
5778	*/
5779	int Machine::calculateFullPath(const Utf8Str &strPath, Utf8Str &aResult)
5780	{
5781	AutoCaller autoCaller(this);
5782	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
5783
5784	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5785
5786	AssertReturn(!mData->m_strConfigFileFull.isEmpty(), VERR_GENERAL_FAILURE);
5787
5788	Utf8Str strSettingsDir = mData->m_strConfigFileFull;
5789
5790	strSettingsDir.stripFilename();
5791	char folder[RTPATH_MAX];
5792	int vrc = RTPathAbsEx(strSettingsDir.c_str(), strPath.c_str(), folder, sizeof(folder));
5793	if (RT_SUCCESS(vrc))
5794	aResult = folder;
5795
5796	return vrc;
5797	}
5798
5799	/**
5800	* Copies strSource to strTarget, making it relative to the machine folder
5801	* if it is a subdirectory thereof, or simply copying it otherwise.
5802	*
5803	* @param strSource Path to evalue and copy.
5804	* @param strTarget Buffer to receive target path.
5805	*
5806	* @note Locks this object for reading.
5807	*/
5808	void Machine::copyPathRelativeToMachine(const Utf8Str &strSource,
5809	Utf8Str &strTarget)
5810	{
5811	AutoCaller autoCaller(this);
5812	AssertComRCReturn(autoCaller.rc(), (void)0);
5813
5814	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5815
5816	AssertReturnVoid(!mData->m_strConfigFileFull.isEmpty());
5817	// use strTarget as a temporary buffer to hold the machine settings dir
5818	strTarget = mData->m_strConfigFileFull;
5819	strTarget.stripFilename();
5820	if (RTPathStartsWith(strSource.c_str(), strTarget.c_str()))
5821	// is relative: then append what's left
5822	strTarget.append(strSource.c_str() + strTarget.length()); // include '/'
5823	else
5824	// is not relative: then overwrite
5825	strTarget = strSource;
5826	}
5827
5828	/**
5829	* Returns the full path to the machine's log folder in the
5830	* \a aLogFolder argument.
5831	*/
5832	void Machine::getLogFolder(Utf8Str &aLogFolder)
5833	{
5834	AutoCaller autoCaller(this);
5835	AssertComRCReturnVoid(autoCaller.rc());
5836
5837	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5838
5839	Utf8Str settingsDir;
5840	if (isInOwnDir(&settingsDir))
5841	/* Log folder is <Machines>/<VM_Name>/Logs */
5842	aLogFolder = settingsDir;
5843	else
5844	{
5845	/* Log folder is <Machines>/<VM_SnapshotFolder>/Logs */
5846	Assert(!mUserData->m_strSnapshotFolderFull.isEmpty());
5847	aLogFolder = mUserData->m_strSnapshotFolderFull;
5848	}
5849
5850	aLogFolder.append(RTPATH_DELIMITER);
5851	aLogFolder.append("Logs");
5852	}
5853
5854	/**
5855	* Returns the full path to the machine's log file for an given index.
5856	*/
5857	Utf8Str Machine::queryLogFilename(ULONG idx)
5858	{
5859	Utf8Str logFolder;
5860	getLogFolder(logFolder);
5861	Assert(logFolder.length());
5862	Utf8Str log;
5863	if (idx == 0)
5864	log = Utf8StrFmt("%s%cVBox.log",
5865	logFolder.c_str(), RTPATH_DELIMITER);
5866	else
5867	log = Utf8StrFmt("%s%cVBox.log.%d",
5868	logFolder.c_str(), RTPATH_DELIMITER, idx);
5869	return log;
5870	}
5871
5872	/**
5873	* @note Locks this object for writing, calls the client process
5874	* (inside the lock).
5875	*/
5876	HRESULT Machine::openRemoteSession(IInternalSessionControl *aControl,
5877	IN_BSTR aType,
5878	IN_BSTR aEnvironment,
5879	ProgressProxy *aProgress)
5880	{
5881	LogFlowThisFuncEnter();
5882
5883	AssertReturn(aControl, E_FAIL);
5884	AssertReturn(aProgress, E_FAIL);
5885
5886	AutoCaller autoCaller(this);
5887	if (FAILED(autoCaller.rc())) return autoCaller.rc();
5888
5889	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5890
5891	if (!mData->mRegistered)
5892	return setError(E_UNEXPECTED,
5893	tr("The machine '%s' is not registered"),
5894	mUserData->s.strName.c_str());
5895
5896	LogFlowThisFunc(("mSession.mState=%s\n", Global::stringifySessionState(mData->mSession.mState)));
5897
5898	if ( mData->mSession.mState == SessionState_Locked
5899	\|\| mData->mSession.mState == SessionState_Spawning
5900	\|\| mData->mSession.mState == SessionState_Unlocking)
5901	return setError(VBOX_E_INVALID_OBJECT_STATE,
5902	tr("The machine '%s' is already locked by a session (or being locked or unlocked)"),
5903	mUserData->s.strName.c_str());
5904
5905	/* may not be busy */
5906	AssertReturn(!Global::IsOnlineOrTransient(mData->mMachineState), E_FAIL);
5907
5908	/* get the path to the executable */
5909	char szPath[RTPATH_MAX];
5910	RTPathAppPrivateArch(szPath, RTPATH_MAX);
5911	size_t sz = strlen(szPath);
5912	szPath[sz++] = RTPATH_DELIMITER;
5913	szPath[sz] = 0;
5914	char *cmd = szPath + sz;
5915	sz = RTPATH_MAX - sz;
5916
5917	int vrc = VINF_SUCCESS;
5918	RTPROCESS pid = NIL_RTPROCESS;
5919
5920	RTENV env = RTENV_DEFAULT;
5921
5922	if (aEnvironment != NULL && *aEnvironment)
5923	{
5924	char *newEnvStr = NULL;
5925
5926	do
5927	{
5928	/* clone the current environment */
5929	int vrc2 = RTEnvClone(&env, RTENV_DEFAULT);
5930	AssertRCBreakStmt(vrc2, vrc = vrc2);
5931
5932	newEnvStr = RTStrDup(Utf8Str(aEnvironment).c_str());
5933	AssertPtrBreakStmt(newEnvStr, vrc = vrc2);
5934
5935	/* put new variables to the environment
5936	* (ignore empty variable names here since RTEnv API
5937	* intentionally doesn't do that) */
5938	char *var = newEnvStr;
5939	for (char p = newEnvStr; p; ++p)
5940	{
5941	if (p == '\n' && (p == newEnvStr \|\| (p - 1) != '\\'))
5942	{
5943	*p = '\0';
5944	if (*var)
5945	{
5946	char *val = strchr(var, '=');
5947	if (val)
5948	{
5949	*val++ = '\0';
5950	vrc2 = RTEnvSetEx(env, var, val);
5951	}
5952	else
5953	vrc2 = RTEnvUnsetEx(env, var);
5954	if (RT_FAILURE(vrc2))
5955	break;
5956	}
5957	var = p + 1;
5958	}
5959	}
5960	if (RT_SUCCESS(vrc2) && *var)
5961	vrc2 = RTEnvPutEx(env, var);
5962
5963	AssertRCBreakStmt(vrc2, vrc = vrc2);
5964	}
5965	while (0);
5966
5967	if (newEnvStr != NULL)
5968	RTStrFree(newEnvStr);
5969	}
5970
5971	Utf8Str strType(aType);
5972
5973	/* Qt is default */
5974	#ifdef VBOX_WITH_QTGUI
5975	if (strType == "gui" \|\| strType == "GUI/Qt")
5976	{
5977	# ifdef RT_OS_DARWIN /* Avoid Launch Services confusing this with the selector by using a helper app. */
5978	const char VirtualBox_exe[] = "../Resources/VirtualBoxVM.app/Contents/MacOS/VirtualBoxVM";
5979	# else
5980	const char VirtualBox_exe[] = "VirtualBox" HOSTSUFF_EXE;
5981	# endif
5982	Assert(sz >= sizeof(VirtualBox_exe));
5983	strcpy(cmd, VirtualBox_exe);
5984
5985	Utf8Str idStr = mData->mUuid.toString();
5986	const char * args[] = {szPath, "--comment", mUserData->s.strName.c_str(), "--startvm", idStr.c_str(), "--no-startvm-errormsgbox", 0 };
5987	vrc = RTProcCreate(szPath, args, env, 0, &pid);
5988	}
5989	#else /* !VBOX_WITH_QTGUI */
5990	if (0)
5991	;
5992	#endif /* VBOX_WITH_QTGUI */
5993
5994	else
5995
5996	#ifdef VBOX_WITH_VBOXSDL
5997	if (strType == "sdl" \|\| strType == "GUI/SDL")
5998	{
5999	const char VBoxSDL_exe[] = "VBoxSDL" HOSTSUFF_EXE;
6000	Assert(sz >= sizeof(VBoxSDL_exe));
6001	strcpy(cmd, VBoxSDL_exe);
6002
6003	Utf8Str idStr = mData->mUuid.toString();
6004	const char * args[] = {szPath, "--comment", mUserData->s.strName.c_str(), "--startvm", idStr.c_str(), 0 };
6005	vrc = RTProcCreate(szPath, args, env, 0, &pid);
6006	}
6007	#else /* !VBOX_WITH_VBOXSDL */
6008	if (0)
6009	;
6010	#endif /* !VBOX_WITH_VBOXSDL */
6011
6012	else
6013
6014	#ifdef VBOX_WITH_HEADLESS
6015	if ( strType == "headless"
6016	\|\| strType == "capture"
6017	#ifdef VBOX_WITH_VRDP
6018	\|\| strType == "vrdp"
6019	#endif
6020	)
6021	{
6022	const char VBoxHeadless_exe[] = "VBoxHeadless" HOSTSUFF_EXE;
6023	Assert(sz >= sizeof(VBoxHeadless_exe));
6024	strcpy(cmd, VBoxHeadless_exe);
6025
6026	Utf8Str idStr = mData->mUuid.toString();
6027	/* Leave space for 2 args, as "headless" needs --vrdp off on non-OSE. */
6028	const char * args[] = {szPath, "--comment", mUserData->s.strName.c_str(), "--startvm", idStr.c_str(), 0, 0, 0 };
6029	#ifdef VBOX_WITH_VRDP
6030	if (strType == "headless")
6031	{
6032	unsigned pos = RT_ELEMENTS(args) - 3;
6033	args[pos++] = "--vrdp";
6034	args[pos] = "off";
6035	}
6036	#endif
6037	if (strType == "capture")
6038	{
6039	unsigned pos = RT_ELEMENTS(args) - 3;
6040	args[pos] = "--capture";
6041	}
6042	vrc = RTProcCreate(szPath, args, env, 0, &pid);
6043	}
6044	#else /* !VBOX_WITH_HEADLESS */
6045	if (0)
6046	;
6047	#endif /* !VBOX_WITH_HEADLESS */
6048	else
6049	{
6050	RTEnvDestroy(env);
6051	return setError(E_INVALIDARG,
6052	tr("Invalid session type: '%s'"),
6053	strType.c_str());
6054	}
6055
6056	RTEnvDestroy(env);
6057
6058	if (RT_FAILURE(vrc))
6059	return setError(VBOX_E_IPRT_ERROR,
6060	tr("Could not launch a process for the machine '%s' (%Rrc)"),
6061	mUserData->s.strName.c_str(), vrc);
6062
6063	LogFlowThisFunc(("launched.pid=%d(0x%x)\n", pid, pid));
6064
6065	/*
6066	* Note that we don't leave the lock here before calling the client,
6067	* because it doesn't need to call us back if called with a NULL argument.
6068	* Leaving the lock herer is dangerous because we didn't prepare the
6069	* launch data yet, but the client we've just started may happen to be
6070	* too fast and call openSession() that will fail (because of PID, etc.),
6071	* so that the Machine will never get out of the Spawning session state.
6072	*/
6073
6074	/* inform the session that it will be a remote one */
6075	LogFlowThisFunc(("Calling AssignMachine (NULL)...\n"));
6076	HRESULT rc = aControl->AssignMachine(NULL);
6077	LogFlowThisFunc(("AssignMachine (NULL) returned %08X\n", rc));
6078
6079	if (FAILED(rc))
6080	{
6081	/* restore the session state */
6082	mData->mSession.mState = SessionState_Unlocked;
6083	/* The failure may occur w/o any error info (from RPC), so provide one */
6084	return setError(VBOX_E_VM_ERROR,
6085	tr("Failed to assign the machine to the session (%Rrc)"), rc);
6086	}
6087
6088	/* attach launch data to the machine */
6089	Assert(mData->mSession.mPid == NIL_RTPROCESS);
6090	mData->mSession.mRemoteControls.push_back (aControl);
6091	mData->mSession.mProgress = aProgress;
6092	mData->mSession.mPid = pid;
6093	mData->mSession.mState = SessionState_Spawning;
6094	mData->mSession.mType = strType;
6095
6096	LogFlowThisFuncLeave();
6097	return S_OK;
6098	}
6099
6100	/**
6101	* Returns @c true if the given machine has an open direct session and returns
6102	* the session machine instance and additional session data (on some platforms)
6103	* if so.
6104	*
6105	* Note that when the method returns @c false, the arguments remain unchanged.
6106	*
6107	* @param aMachine Session machine object.
6108	* @param aControl Direct session control object (optional).
6109	* @param aIPCSem Mutex IPC semaphore handle for this machine (optional).
6110	*
6111	* @note locks this object for reading.
6112	*/
6113	#if defined(RT_OS_WINDOWS)
6114	bool Machine::isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
6115	ComPtr<IInternalSessionControl> aControl /= NULL*/,
6116	HANDLE aIPCSem /= NULL*/,
6117	bool aAllowClosing /= false/)
6118	#elif defined(RT_OS_OS2)
6119	bool Machine::isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
6120	ComPtr<IInternalSessionControl> aControl /= NULL*/,
6121	HMTX aIPCSem /= NULL*/,
6122	bool aAllowClosing /= false/)
6123	#else
6124	bool Machine::isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
6125	ComPtr<IInternalSessionControl> aControl /= NULL*/,
6126	bool aAllowClosing /= false/)
6127	#endif
6128	{
6129	AutoLimitedCaller autoCaller(this);
6130	AssertComRCReturn(autoCaller.rc(), false);
6131
6132	/* just return false for inaccessible machines */
6133	if (autoCaller.state() != Ready)
6134	return false;
6135
6136	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6137
6138	if ( mData->mSession.mState == SessionState_Locked
6139	\|\| (aAllowClosing && mData->mSession.mState == SessionState_Unlocking)
6140	)
6141	{
6142	AssertReturn(!mData->mSession.mMachine.isNull(), false);
6143
6144	aMachine = mData->mSession.mMachine;
6145
6146	if (aControl != NULL)
6147	*aControl = mData->mSession.mDirectControl;
6148
6149	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_OS2)
6150	/* Additional session data */
6151	if (aIPCSem != NULL)
6152	*aIPCSem = aMachine->mIPCSem;
6153	#endif
6154	return true;
6155	}
6156
6157	return false;
6158	}
6159
6160	/**
6161	* Returns @c true if the given machine has an spawning direct session and
6162	* returns and additional session data (on some platforms) if so.
6163	*
6164	* Note that when the method returns @c false, the arguments remain unchanged.
6165	*
6166	* @param aPID PID of the spawned direct session process.
6167	*
6168	* @note locks this object for reading.
6169	*/
6170	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_OS2)
6171	bool Machine::isSessionSpawning(RTPROCESS aPID /= NULL*/)
6172	#else
6173	bool Machine::isSessionSpawning()
6174	#endif
6175	{
6176	AutoLimitedCaller autoCaller(this);
6177	AssertComRCReturn(autoCaller.rc(), false);
6178
6179	/* just return false for inaccessible machines */
6180	if (autoCaller.state() != Ready)
6181	return false;
6182
6183	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6184
6185	if (mData->mSession.mState == SessionState_Spawning)
6186	{
6187	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_OS2)
6188	/* Additional session data */
6189	if (aPID != NULL)
6190	{
6191	AssertReturn(mData->mSession.mPid != NIL_RTPROCESS, false);
6192	*aPID = mData->mSession.mPid;
6193	}
6194	#endif
6195	return true;
6196	}
6197
6198	return false;
6199	}
6200
6201	/**
6202	* Called from the client watcher thread to check for unexpected client process
6203	* death during Session_Spawning state (e.g. before it successfully opened a
6204	* direct session).
6205	*
6206	* On Win32 and on OS/2, this method is called only when we've got the
6207	* direct client's process termination notification, so it always returns @c
6208	* true.
6209	*
6210	* On other platforms, this method returns @c true if the client process is
6211	* terminated and @c false if it's still alive.
6212	*
6213	* @note Locks this object for writing.
6214	*/
6215	bool Machine::checkForSpawnFailure()
6216	{
6217	AutoCaller autoCaller(this);
6218	if (!autoCaller.isOk())
6219	{
6220	/* nothing to do */
6221	LogFlowThisFunc(("Already uninitialized!\n"));
6222	return true;
6223	}
6224
6225	/* VirtualBox::addProcessToReap() needs a write lock */
6226	AutoMultiWriteLock2 alock(mParent, this COMMA_LOCKVAL_SRC_POS);
6227
6228	if (mData->mSession.mState != SessionState_Spawning)
6229	{
6230	/* nothing to do */
6231	LogFlowThisFunc(("Not spawning any more!\n"));
6232	return true;
6233	}
6234
6235	HRESULT rc = S_OK;
6236
6237	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_OS2)
6238
6239	/* the process was already unexpectedly terminated, we just need to set an
6240	* error and finalize session spawning */
6241	rc = setError(E_FAIL,
6242	tr("The virtual machine '%ls' has terminated unexpectedly during startup"),
6243	getName().c_str());
6244	#else
6245
6246	/* PID not yet initialized, skip check. */
6247	if (mData->mSession.mPid == NIL_RTPROCESS)
6248	return false;
6249
6250	RTPROCSTATUS status;
6251	int vrc = ::RTProcWait(mData->mSession.mPid, RTPROCWAIT_FLAGS_NOBLOCK,
6252	&status);
6253
6254	if (vrc != VERR_PROCESS_RUNNING)
6255	{
6256	if (RT_SUCCESS(vrc) && status.enmReason == RTPROCEXITREASON_NORMAL)
6257	rc = setError(E_FAIL,
6258	tr("The virtual machine '%s' has terminated unexpectedly during startup with exit code %d"),
6259	getName().c_str(), status.iStatus);
6260	else if (RT_SUCCESS(vrc) && status.enmReason == RTPROCEXITREASON_SIGNAL)
6261	rc = setError(E_FAIL,
6262	tr("The virtual machine '%s' has terminated unexpectedly during startup because of signal %d"),
6263	getName().c_str(), status.iStatus);
6264	else if (RT_SUCCESS(vrc) && status.enmReason == RTPROCEXITREASON_ABEND)
6265	rc = setError(E_FAIL,
6266	tr("The virtual machine '%s' has terminated abnormally"),
6267	getName().c_str(), status.iStatus);
6268	else
6269	rc = setError(E_FAIL,
6270	tr("The virtual machine '%s' has terminated unexpectedly during startup (%Rrc)"),
6271	getName().c_str(), rc);
6272	}
6273
6274	#endif
6275
6276	if (FAILED(rc))
6277	{
6278	/* Close the remote session, remove the remote control from the list
6279	* and reset session state to Closed (@note keep the code in sync with
6280	* the relevant part in checkForSpawnFailure()). */
6281
6282	Assert(mData->mSession.mRemoteControls.size() == 1);
6283	if (mData->mSession.mRemoteControls.size() == 1)
6284	{
6285	ErrorInfoKeeper eik;
6286	mData->mSession.mRemoteControls.front()->Uninitialize();
6287	}
6288
6289	mData->mSession.mRemoteControls.clear();
6290	mData->mSession.mState = SessionState_Unlocked;
6291
6292	/* finalize the progress after setting the state */
6293	if (!mData->mSession.mProgress.isNull())
6294	{
6295	mData->mSession.mProgress->notifyComplete(rc);
6296	mData->mSession.mProgress.setNull();
6297	}
6298
6299	mParent->addProcessToReap(mData->mSession.mPid);
6300	mData->mSession.mPid = NIL_RTPROCESS;
6301
6302	mParent->onSessionStateChange(mData->mUuid, SessionState_Unlocked);
6303	return true;
6304	}
6305
6306	return false;
6307	}
6308
6309	/**
6310	* Checks whether the machine can be registered. If so, commits and saves
6311	* all settings.
6312	*
6313	* @note Must be called from mParent's write lock. Locks this object and
6314	* children for writing.
6315	*/
6316	HRESULT Machine::prepareRegister()
6317	{
6318	AssertReturn(mParent->isWriteLockOnCurrentThread(), E_FAIL);
6319
6320	AutoLimitedCaller autoCaller(this);
6321	AssertComRCReturnRC(autoCaller.rc());
6322
6323	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6324
6325	/* wait for state dependants to drop to zero */
6326	ensureNoStateDependencies();
6327
6328	if (!mData->mAccessible)
6329	return setError(VBOX_E_INVALID_OBJECT_STATE,
6330	tr("The machine '%s' with UUID {%s} is inaccessible and cannot be registered"),
6331	mUserData->s.strName.c_str(),
6332	mData->mUuid.toString().c_str());
6333
6334	AssertReturn(autoCaller.state() == Ready, E_FAIL);
6335
6336	if (mData->mRegistered)
6337	return setError(VBOX_E_INVALID_OBJECT_STATE,
6338	tr("The machine '%s' with UUID {%s} is already registered"),
6339	mUserData->s.strName.c_str(),
6340	mData->mUuid.toString().c_str());
6341
6342	HRESULT rc = S_OK;
6343
6344	// Ensure the settings are saved. If we are going to be registered and
6345	// no config file exists yet, create it by calling saveSettings() too.
6346	if ( (mData->flModifications)
6347	\|\| (!mData->pMachineConfigFile->fileExists())
6348	)
6349	{
6350	rc = saveSettings(NULL);
6351	// no need to check whether VirtualBox.xml needs saving too since
6352	// we can't have a machine XML file rename pending
6353	if (FAILED(rc)) return rc;
6354	}
6355
6356	/* more config checking goes here */
6357
6358	if (SUCCEEDED(rc))
6359	{
6360	/* we may have had implicit modifications we want to fix on success */
6361	commit();
6362
6363	mData->mRegistered = true;
6364	}
6365	else
6366	{
6367	/* we may have had implicit modifications we want to cancel on failure*/
6368	rollback(false /* aNotify */);
6369	}
6370
6371	return rc;
6372	}
6373
6374	/**
6375	* Increases the number of objects dependent on the machine state or on the
6376	* registered state. Guarantees that these two states will not change at least
6377	* until #releaseStateDependency() is called.
6378	*
6379	* Depending on the @a aDepType value, additional state checks may be made.
6380	* These checks will set extended error info on failure. See
6381	* #checkStateDependency() for more info.
6382	*
6383	* If this method returns a failure, the dependency is not added and the caller
6384	* is not allowed to rely on any particular machine state or registration state
6385	* value and may return the failed result code to the upper level.
6386	*
6387	* @param aDepType Dependency type to add.
6388	* @param aState Current machine state (NULL if not interested).
6389	* @param aRegistered Current registered state (NULL if not interested).
6390	*
6391	* @note Locks this object for writing.
6392	*/
6393	HRESULT Machine::addStateDependency(StateDependency aDepType /* = AnyStateDep */,
6394	MachineState_T aState / = NULL */,
6395	BOOL aRegistered / = NULL */)
6396	{
6397	AutoCaller autoCaller(this);
6398	AssertComRCReturnRC(autoCaller.rc());
6399
6400	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6401
6402	HRESULT rc = checkStateDependency(aDepType);
6403	if (FAILED(rc)) return rc;
6404
6405	{
6406	if (mData->mMachineStateChangePending != 0)
6407	{
6408	/* ensureNoStateDependencies() is waiting for state dependencies to
6409	* drop to zero so don't add more. It may make sense to wait a bit
6410	* and retry before reporting an error (since the pending state
6411	* transition should be really quick) but let's just assert for
6412	* now to see if it ever happens on practice. */
6413
6414	AssertFailed();
6415
6416	return setError(E_ACCESSDENIED,
6417	tr("Machine state change is in progress. Please retry the operation later."));
6418	}
6419
6420	++mData->mMachineStateDeps;
6421	Assert(mData->mMachineStateDeps != 0 /* overflow */);
6422	}
6423
6424	if (aState)
6425	*aState = mData->mMachineState;
6426	if (aRegistered)
6427	*aRegistered = mData->mRegistered;
6428
6429	return S_OK;
6430	}
6431
6432	/**
6433	* Decreases the number of objects dependent on the machine state.
6434	* Must always complete the #addStateDependency() call after the state
6435	* dependency is no more necessary.
6436	*/
6437	void Machine::releaseStateDependency()
6438	{
6439	AutoCaller autoCaller(this);
6440	AssertComRCReturnVoid(autoCaller.rc());
6441
6442	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6443
6444	/* releaseStateDependency() w/o addStateDependency()? */
6445	AssertReturnVoid(mData->mMachineStateDeps != 0);
6446	-- mData->mMachineStateDeps;
6447
6448	if (mData->mMachineStateDeps == 0)
6449	{
6450	/* inform ensureNoStateDependencies() that there are no more deps */
6451	if (mData->mMachineStateChangePending != 0)
6452	{
6453	Assert(mData->mMachineStateDepsSem != NIL_RTSEMEVENTMULTI);
6454	RTSemEventMultiSignal (mData->mMachineStateDepsSem);
6455	}
6456	}
6457	}
6458
6459	// protected methods
6460	/////////////////////////////////////////////////////////////////////////////
6461
6462	/**
6463	* Performs machine state checks based on the @a aDepType value. If a check
6464	* fails, this method will set extended error info, otherwise it will return
6465	* S_OK. It is supposed, that on failure, the caller will immedieately return
6466	* the return value of this method to the upper level.
6467	*
6468	* When @a aDepType is AnyStateDep, this method always returns S_OK.
6469	*
6470	* When @a aDepType is MutableStateDep, this method returns S_OK only if the
6471	* current state of this machine object allows to change settings of the
6472	* machine (i.e. the machine is not registered, or registered but not running
6473	* and not saved). It is useful to call this method from Machine setters
6474	* before performing any change.
6475	*
6476	* When @a aDepType is MutableOrSavedStateDep, this method behaves the same
6477	* as for MutableStateDep except that if the machine is saved, S_OK is also
6478	* returned. This is useful in setters which allow changing machine
6479	* properties when it is in the saved state.
6480	*
6481	* @param aDepType Dependency type to check.
6482	*
6483	* @note Non Machine based classes should use #addStateDependency() and
6484	* #releaseStateDependency() methods or the smart AutoStateDependency
6485	* template.
6486	*
6487	* @note This method must be called from under this object's read or write
6488	* lock.
6489	*/
6490	HRESULT Machine::checkStateDependency(StateDependency aDepType)
6491	{
6492	switch (aDepType)
6493	{
6494	case AnyStateDep:
6495	{
6496	break;
6497	}
6498	case MutableStateDep:
6499	{
6500	if ( mData->mRegistered
6501	&& ( !isSessionMachine() /** @todo This was just convered raw; Check if Running and Paused should actually be included here... (Live Migration) */
6502	\|\| ( mData->mMachineState != MachineState_Paused
6503	&& mData->mMachineState != MachineState_Running
6504	&& mData->mMachineState != MachineState_Aborted
6505	&& mData->mMachineState != MachineState_Teleported
6506	&& mData->mMachineState != MachineState_PoweredOff
6507	)
6508	)
6509	)
6510	return setError(VBOX_E_INVALID_VM_STATE,
6511	tr("The machine is not mutable (state is %s)"),
6512	Global::stringifyMachineState(mData->mMachineState));
6513	break;
6514	}
6515	case MutableOrSavedStateDep:
6516	{
6517	if ( mData->mRegistered
6518	&& ( !isSessionMachine() /** @todo This was just convered raw; Check if Running and Paused should actually be included here... (Live Migration) */
6519	\|\| ( mData->mMachineState != MachineState_Paused
6520	&& mData->mMachineState != MachineState_Running
6521	&& mData->mMachineState != MachineState_Aborted
6522	&& mData->mMachineState != MachineState_Teleported
6523	&& mData->mMachineState != MachineState_Saved
6524	&& mData->mMachineState != MachineState_PoweredOff
6525	)
6526	)
6527	)
6528	return setError(VBOX_E_INVALID_VM_STATE,
6529	tr("The machine is not mutable (state is %s)"),
6530	Global::stringifyMachineState(mData->mMachineState));
6531	break;
6532	}
6533	}
6534
6535	return S_OK;
6536	}
6537
6538	/**
6539	* Helper to initialize all associated child objects and allocate data
6540	* structures.
6541	*
6542	* This method must be called as a part of the object's initialization procedure
6543	* (usually done in the #init() method).
6544	*
6545	* @note Must be called only from #init() or from #registeredInit().
6546	*/
6547	HRESULT Machine::initDataAndChildObjects()
6548	{
6549	AutoCaller autoCaller(this);
6550	AssertComRCReturnRC(autoCaller.rc());
6551	AssertComRCReturn(autoCaller.state() == InInit \|\|
6552	autoCaller.state() == Limited, E_FAIL);
6553
6554	AssertReturn(!mData->mAccessible, E_FAIL);
6555
6556	/* allocate data structures */
6557	mSSData.allocate();
6558	mUserData.allocate();
6559	mHWData.allocate();
6560	mMediaData.allocate();
6561	mStorageControllers.allocate();
6562
6563	/* initialize mOSTypeId */
6564	mUserData->s.strOsType = mParent->getUnknownOSType()->id();
6565
6566	/* create associated BIOS settings object */
6567	unconst(mBIOSSettings).createObject();
6568	mBIOSSettings->init(this);
6569
6570	#ifdef VBOX_WITH_VRDP
6571	/* create an associated VRDPServer object (default is disabled) */
6572	unconst(mVRDPServer).createObject();
6573	mVRDPServer->init(this);
6574	#endif
6575
6576	/* create associated serial port objects */
6577	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); slot++)
6578	{
6579	unconst(mSerialPorts[slot]).createObject();
6580	mSerialPorts[slot]->init(this, slot);
6581	}
6582
6583	/* create associated parallel port objects */
6584	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); slot++)
6585	{
6586	unconst(mParallelPorts[slot]).createObject();
6587	mParallelPorts[slot]->init(this, slot);
6588	}
6589
6590	/* create the audio adapter object (always present, default is disabled) */
6591	unconst(mAudioAdapter).createObject();
6592	mAudioAdapter->init(this);
6593
6594	/* create the USB controller object (always present, default is disabled) */
6595	unconst(mUSBController).createObject();
6596	mUSBController->init(this);
6597
6598	/* create associated network adapter objects */
6599	for (ULONG slot = 0; slot < RT_ELEMENTS(mNetworkAdapters); slot ++)
6600	{
6601	unconst(mNetworkAdapters[slot]).createObject();
6602	mNetworkAdapters[slot]->init(this, slot);
6603	}
6604
6605	return S_OK;
6606	}
6607
6608	/**
6609	* Helper to uninitialize all associated child objects and to free all data
6610	* structures.
6611	*
6612	* This method must be called as a part of the object's uninitialization
6613	* procedure (usually done in the #uninit() method).
6614	*
6615	* @note Must be called only from #uninit() or from #registeredInit().
6616	*/
6617	void Machine::uninitDataAndChildObjects()
6618	{
6619	AutoCaller autoCaller(this);
6620	AssertComRCReturnVoid(autoCaller.rc());
6621	AssertComRCReturnVoid( autoCaller.state() == InUninit
6622	\|\| autoCaller.state() == Limited);
6623
6624	/* uninit all children using addDependentChild()/removeDependentChild()
6625	* in their init()/uninit() methods */
6626	uninitDependentChildren();
6627
6628	/* tell all our other child objects we've been uninitialized */
6629
6630	for (ULONG slot = 0; slot < RT_ELEMENTS(mNetworkAdapters); slot++)
6631	{
6632	if (mNetworkAdapters[slot])
6633	{
6634	mNetworkAdapters[slot]->uninit();
6635	unconst(mNetworkAdapters[slot]).setNull();
6636	}
6637	}
6638
6639	if (mUSBController)
6640	{
6641	mUSBController->uninit();
6642	unconst(mUSBController).setNull();
6643	}
6644
6645	if (mAudioAdapter)
6646	{
6647	mAudioAdapter->uninit();
6648	unconst(mAudioAdapter).setNull();
6649	}
6650
6651	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); slot++)
6652	{
6653	if (mParallelPorts[slot])
6654	{
6655	mParallelPorts[slot]->uninit();
6656	unconst(mParallelPorts[slot]).setNull();
6657	}
6658	}
6659
6660	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); slot++)
6661	{
6662	if (mSerialPorts[slot])
6663	{
6664	mSerialPorts[slot]->uninit();
6665	unconst(mSerialPorts[slot]).setNull();
6666	}
6667	}
6668
6669	#ifdef VBOX_WITH_VRDP
6670	if (mVRDPServer)
6671	{
6672	mVRDPServer->uninit();
6673	unconst(mVRDPServer).setNull();
6674	}
6675	#endif
6676
6677	if (mBIOSSettings)
6678	{
6679	mBIOSSettings->uninit();
6680	unconst(mBIOSSettings).setNull();
6681	}
6682
6683	/* Deassociate hard disks (only when a real Machine or a SnapshotMachine
6684	* instance is uninitialized; SessionMachine instances refer to real
6685	* Machine hard disks). This is necessary for a clean re-initialization of
6686	* the VM after successfully re-checking the accessibility state. Note
6687	* that in case of normal Machine or SnapshotMachine uninitialization (as
6688	* a result of unregistering or deleting the snapshot), outdated hard
6689	* disk attachments will already be uninitialized and deleted, so this
6690	* code will not affect them. */
6691	if ( !!mMediaData
6692	&& (!isSessionMachine())
6693	)
6694	{
6695	for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
6696	it != mMediaData->mAttachments.end();
6697	++it)
6698	{
6699	ComObjPtr<Medium> hd = (*it)->getMedium();
6700	if (hd.isNull())
6701	continue;
6702	HRESULT rc = hd->removeBackReference(mData->mUuid, getSnapshotId());
6703	AssertComRC(rc);
6704	}
6705	}
6706
6707	if (!isSessionMachine() && !isSnapshotMachine())
6708	{
6709	// clean up the snapshots list (Snapshot::uninit() will handle the snapshot's children recursively)
6710	if (mData->mFirstSnapshot)
6711	{
6712	// snapshots tree is protected by media write lock; strictly
6713	// this isn't necessary here since we're deleting the entire
6714	// machine, but otherwise we assert in Snapshot::uninit()
6715	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6716	mData->mFirstSnapshot->uninit();
6717	mData->mFirstSnapshot.setNull();
6718	}
6719
6720	mData->mCurrentSnapshot.setNull();
6721	}
6722
6723	/* free data structures (the essential mData structure is not freed here
6724	* since it may be still in use) */
6725	mMediaData.free();
6726	mStorageControllers.free();
6727	mHWData.free();
6728	mUserData.free();
6729	mSSData.free();
6730	}
6731
6732	/**
6733	* Returns a pointer to the Machine object for this machine that acts like a
6734	* parent for complex machine data objects such as shared folders, etc.
6735	*
6736	* For primary Machine objects and for SnapshotMachine objects, returns this
6737	* object's pointer itself. For SessoinMachine objects, returns the peer
6738	* (primary) machine pointer.
6739	*/
6740	Machine* Machine::getMachine()
6741	{
6742	if (isSessionMachine())
6743	return (Machine*)mPeer;
6744	return this;
6745	}
6746
6747	/**
6748	* Makes sure that there are no machine state dependants. If necessary, waits
6749	* for the number of dependants to drop to zero.
6750	*
6751	* Make sure this method is called from under this object's write lock to
6752	* guarantee that no new dependants may be added when this method returns
6753	* control to the caller.
6754	*
6755	* @note Locks this object for writing. The lock will be released while waiting
6756	* (if necessary).
6757	*
6758	* @warning To be used only in methods that change the machine state!
6759	*/
6760	void Machine::ensureNoStateDependencies()
6761	{
6762	AssertReturnVoid(isWriteLockOnCurrentThread());
6763
6764	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6765
6766	/* Wait for all state dependants if necessary */
6767	if (mData->mMachineStateDeps != 0)
6768	{
6769	/* lazy semaphore creation */
6770	if (mData->mMachineStateDepsSem == NIL_RTSEMEVENTMULTI)
6771	RTSemEventMultiCreate(&mData->mMachineStateDepsSem);
6772
6773	LogFlowThisFunc(("Waiting for state deps (%d) to drop to zero...\n",
6774	mData->mMachineStateDeps));
6775
6776	++mData->mMachineStateChangePending;
6777
6778	/* reset the semaphore before waiting, the last dependant will signal
6779	* it */
6780	RTSemEventMultiReset(mData->mMachineStateDepsSem);
6781
6782	alock.leave();
6783
6784	RTSemEventMultiWait(mData->mMachineStateDepsSem, RT_INDEFINITE_WAIT);
6785
6786	alock.enter();
6787
6788	-- mData->mMachineStateChangePending;
6789	}
6790	}
6791
6792	/**
6793	* Changes the machine state and informs callbacks.
6794	*
6795	* This method is not intended to fail so it either returns S_OK or asserts (and
6796	* returns a failure).
6797	*
6798	* @note Locks this object for writing.
6799	*/
6800	HRESULT Machine::setMachineState(MachineState_T aMachineState)
6801	{
6802	LogFlowThisFuncEnter();
6803	LogFlowThisFunc(("aMachineState=%s\n", Global::stringifyMachineState(aMachineState) ));
6804
6805	AutoCaller autoCaller(this);
6806	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
6807
6808	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6809
6810	/* wait for state dependants to drop to zero */
6811	ensureNoStateDependencies();
6812
6813	if (mData->mMachineState != aMachineState)
6814	{
6815	mData->mMachineState = aMachineState;
6816
6817	RTTimeNow(&mData->mLastStateChange);
6818
6819	mParent->onMachineStateChange(mData->mUuid, aMachineState);
6820	}
6821
6822	LogFlowThisFuncLeave();
6823	return S_OK;
6824	}
6825
6826	/**
6827	* Searches for a shared folder with the given logical name
6828	* in the collection of shared folders.
6829	*
6830	* @param aName logical name of the shared folder
6831	* @param aSharedFolder where to return the found object
6832	* @param aSetError whether to set the error info if the folder is
6833	* not found
6834	* @return
6835	* S_OK when found or VBOX_E_OBJECT_NOT_FOUND when not found
6836	*
6837	* @note
6838	* must be called from under the object's lock!
6839	*/
6840	HRESULT Machine::findSharedFolder(CBSTR aName,
6841	ComObjPtr<SharedFolder> &aSharedFolder,
6842	bool aSetError /* = false */)
6843	{
6844	bool found = false;
6845	for (HWData::SharedFolderList::const_iterator it = mHWData->mSharedFolders.begin();
6846	!found && it != mHWData->mSharedFolders.end();
6847	++it)
6848	{
6849	AutoWriteLock alock(*it COMMA_LOCKVAL_SRC_POS);
6850	found = (*it)->getName() == aName;
6851	if (found)
6852	aSharedFolder = *it;
6853	}
6854
6855	HRESULT rc = found ? S_OK : VBOX_E_OBJECT_NOT_FOUND;
6856
6857	if (aSetError && !found)
6858	setError(rc, tr("Could not find a shared folder named '%ls'"), aName);
6859
6860	return rc;
6861	}
6862
6863	/**
6864	* Initializes all machine instance data from the given settings structures
6865	* from XML. The exception is the machine UUID which needs special handling
6866	* depending on the caller's use case, so the caller needs to set that herself.
6867	*
6868	* This gets called in several contexts during machine initialization:
6869	*
6870	* -- When machine XML exists on disk already and needs to be loaded into memory,
6871	* for example, from registeredInit() to load all registered machines on
6872	* VirtualBox startup. In this case, puuidRegistry is NULL because the media
6873	* attached to the machine should be part of some media registry already.
6874	*
6875	* -- During OVF import, when a machine config has been constructed from an
6876	* OVF file. In this case, puuidRegistry is set to the machine UUID to
6877	* ensure that the media listed as attachments in the config (which have
6878	* been imported from the OVF) receive the correct registry ID.
6879	*
6880	* @param config Machine settings from XML.
6881	* @param puuidRegistry If != NULL, Medium::setRegistryIdIfFirst() gets called with this registry ID for each attached medium in the config.
6882	* @return
6883	*/
6884	HRESULT Machine::loadMachineDataFromSettings(const settings::MachineConfigFile &config,
6885	const Guid *puuidRegistry)
6886	{
6887	// copy name, description, OS type, teleporter, UTC etc.
6888	mUserData->s = config.machineUserData;
6889
6890	// look up the object by Id to check it is valid
6891	ComPtr<IGuestOSType> guestOSType;
6892	HRESULT rc = mParent->GetGuestOSType(Bstr(mUserData->s.strOsType).raw(),
6893	guestOSType.asOutParam());
6894	if (FAILED(rc)) return rc;
6895
6896	// stateFile (optional)
6897	if (config.strStateFile.isEmpty())
6898	mSSData->mStateFilePath.setNull();
6899	else
6900	{
6901	Utf8Str stateFilePathFull(config.strStateFile);
6902	int vrc = calculateFullPath(stateFilePathFull, stateFilePathFull);
6903	if (RT_FAILURE(vrc))
6904	return setError(E_FAIL,
6905	tr("Invalid saved state file path '%s' (%Rrc)"),
6906	config.strStateFile.c_str(),
6907	vrc);
6908	mSSData->mStateFilePath = stateFilePathFull;
6909	}
6910
6911	// snapshot folder needs special processing so set it again
6912	rc = COMSETTER(SnapshotFolder)(Bstr(config.machineUserData.strSnapshotFolder).raw());
6913	if (FAILED(rc)) return rc;
6914
6915	/* currentStateModified (optional, default is true) */
6916	mData->mCurrentStateModified = config.fCurrentStateModified;
6917
6918	mData->mLastStateChange = config.timeLastStateChange;
6919
6920	/*
6921	* note: all mUserData members must be assigned prior this point because
6922	* we need to commit changes in order to let mUserData be shared by all
6923	* snapshot machine instances.
6924	*/
6925	mUserData.commitCopy();
6926
6927	// machine registry, if present (must be loaded before snapshots)
6928	if (config.canHaveOwnMediaRegistry())
6929	{
6930	rc = mParent->initMedia(getId(), // media registry ID == machine UUID
6931	config.mediaRegistry);
6932	if (FAILED(rc)) return rc;
6933	}
6934
6935	/* Snapshot node (optional) */
6936	size_t cRootSnapshots;
6937	if ((cRootSnapshots = config.llFirstSnapshot.size()))
6938	{
6939	// there must be only one root snapshot
6940	Assert(cRootSnapshots == 1);
6941
6942	const settings::Snapshot &snap = config.llFirstSnapshot.front();
6943
6944	rc = loadSnapshot(snap,
6945	config.uuidCurrentSnapshot,
6946	NULL); // no parent == first snapshot
6947	if (FAILED(rc)) return rc;
6948	}
6949
6950	// hardware data
6951	rc = loadHardware(config.hardwareMachine);
6952	if (FAILED(rc)) return rc;
6953
6954	// load storage controllers
6955	rc = loadStorageControllers(config.storageMachine,
6956	puuidRegistry,
6957	NULL /* puuidSnapshot */);
6958	if (FAILED(rc)) return rc;
6959
6960	/*
6961	* NOTE: the assignment below must be the last thing to do,
6962	* otherwise it will be not possible to change the settings
6963	* somewehere in the code above because all setters will be
6964	* blocked by checkStateDependency(MutableStateDep).
6965	*/
6966
6967	/* set the machine state to Aborted or Saved when appropriate */
6968	if (config.fAborted)
6969	{
6970	Assert(!mSSData->mStateFilePath.isEmpty());
6971	mSSData->mStateFilePath.setNull();
6972
6973	/* no need to use setMachineState() during init() */
6974	mData->mMachineState = MachineState_Aborted;
6975	}
6976	else if (!mSSData->mStateFilePath.isEmpty())
6977	{
6978	/* no need to use setMachineState() during init() */
6979	mData->mMachineState = MachineState_Saved;
6980	}
6981
6982	// after loading settings, we are no longer different from the XML on disk
6983	mData->flModifications = 0;
6984
6985	return S_OK;
6986	}
6987
6988	/**
6989	* Recursively loads all snapshots starting from the given.
6990	*
6991	* @param aNode <Snapshot> node.
6992	* @param aCurSnapshotId Current snapshot ID from the settings file.
6993	* @param aParentSnapshot Parent snapshot.
6994	*/
6995	HRESULT Machine::loadSnapshot(const settings::Snapshot &data,
6996	const Guid &aCurSnapshotId,
6997	Snapshot *aParentSnapshot)
6998	{
6999	AssertReturn(!isSnapshotMachine(), E_FAIL);
7000	AssertReturn(!isSessionMachine(), E_FAIL);
7001
7002	HRESULT rc = S_OK;
7003
7004	Utf8Str strStateFile;
7005	if (!data.strStateFile.isEmpty())
7006	{
7007	/* optional */
7008	strStateFile = data.strStateFile;
7009	int vrc = calculateFullPath(strStateFile, strStateFile);
7010	if (RT_FAILURE(vrc))
7011	return setError(E_FAIL,
7012	tr("Invalid saved state file path '%s' (%Rrc)"),
7013	strStateFile.c_str(),
7014	vrc);
7015	}
7016
7017	/* create a snapshot machine object */
7018	ComObjPtr<SnapshotMachine> pSnapshotMachine;
7019	pSnapshotMachine.createObject();
7020	rc = pSnapshotMachine->init(this,
7021	data.hardware,
7022	data.storage,
7023	data.uuid.ref(),
7024	strStateFile);
7025	if (FAILED(rc)) return rc;
7026
7027	/* create a snapshot object */
7028	ComObjPtr<Snapshot> pSnapshot;
7029	pSnapshot.createObject();
7030	/* initialize the snapshot */
7031	rc = pSnapshot->init(mParent, // VirtualBox object
7032	data.uuid,
7033	data.strName,
7034	data.strDescription,
7035	data.timestamp,
7036	pSnapshotMachine,
7037	aParentSnapshot);
7038	if (FAILED(rc)) return rc;
7039
7040	/* memorize the first snapshot if necessary */
7041	if (!mData->mFirstSnapshot)
7042	mData->mFirstSnapshot = pSnapshot;
7043
7044	/* memorize the current snapshot when appropriate */
7045	if ( !mData->mCurrentSnapshot
7046	&& pSnapshot->getId() == aCurSnapshotId
7047	)
7048	mData->mCurrentSnapshot = pSnapshot;
7049
7050	// now create the children
7051	for (settings::SnapshotsList::const_iterator it = data.llChildSnapshots.begin();
7052	it != data.llChildSnapshots.end();
7053	++it)
7054	{
7055	const settings::Snapshot &childData = *it;
7056	// recurse
7057	rc = loadSnapshot(childData,
7058	aCurSnapshotId,
7059	pSnapshot); // parent = the one we created above
7060	if (FAILED(rc)) return rc;
7061	}
7062
7063	return rc;
7064	}
7065
7066	/**
7067	* @param aNode <Hardware> node.
7068	*/
7069	HRESULT Machine::loadHardware(const settings::Hardware &data)
7070	{
7071	AssertReturn(!isSessionMachine(), E_FAIL);
7072
7073	HRESULT rc = S_OK;
7074
7075	try
7076	{
7077	/* The hardware version attribute (optional). */
7078	mHWData->mHWVersion = data.strVersion;
7079	mHWData->mHardwareUUID = data.uuid;
7080
7081	mHWData->mHWVirtExEnabled = data.fHardwareVirt;
7082	mHWData->mHWVirtExExclusive = data.fHardwareVirtExclusive;
7083	mHWData->mHWVirtExNestedPagingEnabled = data.fNestedPaging;
7084	mHWData->mHWVirtExLargePagesEnabled = data.fLargePages;
7085	mHWData->mHWVirtExVPIDEnabled = data.fVPID;
7086	mHWData->mHWVirtExForceEnabled = data.fHardwareVirtForce;
7087	mHWData->mPAEEnabled = data.fPAE;
7088	mHWData->mSyntheticCpu = data.fSyntheticCpu;
7089
7090	mHWData->mCPUCount = data.cCPUs;
7091	mHWData->mCPUHotPlugEnabled = data.fCpuHotPlug;
7092	mHWData->mCpuExecutionCap = data.ulCpuExecutionCap;
7093
7094	// cpu
7095	if (mHWData->mCPUHotPlugEnabled)
7096	{
7097	for (settings::CpuList::const_iterator it = data.llCpus.begin();
7098	it != data.llCpus.end();
7099	++it)
7100	{
7101	const settings::Cpu &cpu = *it;
7102
7103	mHWData->mCPUAttached[cpu.ulId] = true;
7104	}
7105	}
7106
7107	// cpuid leafs
7108	for (settings::CpuIdLeafsList::const_iterator it = data.llCpuIdLeafs.begin();
7109	it != data.llCpuIdLeafs.end();
7110	++it)
7111	{
7112	const settings::CpuIdLeaf &leaf = *it;
7113
7114	switch (leaf.ulId)
7115	{
7116	case 0x0:
7117	case 0x1:
7118	case 0x2:
7119	case 0x3:
7120	case 0x4:
7121	case 0x5:
7122	case 0x6:
7123	case 0x7:
7124	case 0x8:
7125	case 0x9:
7126	case 0xA:
7127	mHWData->mCpuIdStdLeafs[leaf.ulId] = leaf;
7128	break;
7129
7130	case 0x80000000:
7131	case 0x80000001:
7132	case 0x80000002:
7133	case 0x80000003:
7134	case 0x80000004:
7135	case 0x80000005:
7136	case 0x80000006:
7137	case 0x80000007:
7138	case 0x80000008:
7139	case 0x80000009:
7140	case 0x8000000A:
7141	mHWData->mCpuIdExtLeafs[leaf.ulId - 0x80000000] = leaf;
7142	break;
7143
7144	default:
7145	/* just ignore */
7146	break;
7147	}
7148	}
7149
7150	mHWData->mMemorySize = data.ulMemorySizeMB;
7151	mHWData->mPageFusionEnabled = data.fPageFusionEnabled;
7152
7153	// boot order
7154	for (size_t i = 0;
7155	i < RT_ELEMENTS(mHWData->mBootOrder);
7156	i++)
7157	{
7158	settings::BootOrderMap::const_iterator it = data.mapBootOrder.find(i);
7159	if (it == data.mapBootOrder.end())
7160	mHWData->mBootOrder[i] = DeviceType_Null;
7161	else
7162	mHWData->mBootOrder[i] = it->second;
7163	}
7164
7165	mHWData->mVRAMSize = data.ulVRAMSizeMB;
7166	mHWData->mMonitorCount = data.cMonitors;
7167	mHWData->mAccelerate3DEnabled = data.fAccelerate3D;
7168	mHWData->mAccelerate2DVideoEnabled = data.fAccelerate2DVideo;
7169	mHWData->mFirmwareType = data.firmwareType;
7170	mHWData->mPointingHidType = data.pointingHidType;
7171	mHWData->mKeyboardHidType = data.keyboardHidType;
7172	mHWData->mChipsetType = data.chipsetType;
7173	mHWData->mHpetEnabled = data.fHpetEnabled;
7174
7175	#ifdef VBOX_WITH_VRDP
7176	/* RemoteDisplay */
7177	rc = mVRDPServer->loadSettings(data.vrdpSettings);
7178	if (FAILED(rc)) return rc;
7179	#endif
7180
7181	/* BIOS */
7182	rc = mBIOSSettings->loadSettings(data.biosSettings);
7183	if (FAILED(rc)) return rc;
7184
7185	/* USB Controller */
7186	rc = mUSBController->loadSettings(data.usbController);
7187	if (FAILED(rc)) return rc;
7188
7189	// network adapters
7190	for (settings::NetworkAdaptersList::const_iterator it = data.llNetworkAdapters.begin();
7191	it != data.llNetworkAdapters.end();
7192	++it)
7193	{
7194	const settings::NetworkAdapter &nic = *it;
7195
7196	/* slot unicity is guaranteed by XML Schema */
7197	AssertBreak(nic.ulSlot < RT_ELEMENTS(mNetworkAdapters));
7198	rc = mNetworkAdapters[nic.ulSlot]->loadSettings(nic);
7199	if (FAILED(rc)) return rc;
7200	}
7201
7202	// serial ports
7203	for (settings::SerialPortsList::const_iterator it = data.llSerialPorts.begin();
7204	it != data.llSerialPorts.end();
7205	++it)
7206	{
7207	const settings::SerialPort &s = *it;
7208
7209	AssertBreak(s.ulSlot < RT_ELEMENTS(mSerialPorts));
7210	rc = mSerialPorts[s.ulSlot]->loadSettings(s);
7211	if (FAILED(rc)) return rc;
7212	}
7213
7214	// parallel ports (optional)
7215	for (settings::ParallelPortsList::const_iterator it = data.llParallelPorts.begin();
7216	it != data.llParallelPorts.end();
7217	++it)
7218	{
7219	const settings::ParallelPort &p = *it;
7220
7221	AssertBreak(p.ulSlot < RT_ELEMENTS(mParallelPorts));
7222	rc = mParallelPorts[p.ulSlot]->loadSettings(p);
7223	if (FAILED(rc)) return rc;
7224	}
7225
7226	/* AudioAdapter */
7227	rc = mAudioAdapter->loadSettings(data.audioAdapter);
7228	if (FAILED(rc)) return rc;
7229
7230	for (settings::SharedFoldersList::const_iterator it = data.llSharedFolders.begin();
7231	it != data.llSharedFolders.end();
7232	++it)
7233	{
7234	const settings::SharedFolder &sf = *it;
7235	rc = CreateSharedFolder(Bstr(sf.strName).raw(),
7236	Bstr(sf.strHostPath).raw(),
7237	sf.fWritable, sf.fAutoMount);
7238	if (FAILED(rc)) return rc;
7239	}
7240
7241	// Clipboard
7242	mHWData->mClipboardMode = data.clipboardMode;
7243
7244	// guest settings
7245	mHWData->mMemoryBalloonSize = data.ulMemoryBalloonSize;
7246
7247	// IO settings
7248	mHWData->mIoCacheEnabled = data.ioSettings.fIoCacheEnabled;
7249	mHWData->mIoCacheSize = data.ioSettings.ulIoCacheSize;
7250
7251	#ifdef VBOX_WITH_GUEST_PROPS
7252	/* Guest properties (optional) */
7253	for (settings::GuestPropertiesList::const_iterator it = data.llGuestProperties.begin();
7254	it != data.llGuestProperties.end();
7255	++it)
7256	{
7257	const settings::GuestProperty &prop = *it;
7258	uint32_t fFlags = guestProp::NILFLAG;
7259	guestProp::validateFlags(prop.strFlags.c_str(), &fFlags);
7260	HWData::GuestProperty property = { prop.strName, prop.strValue, prop.timestamp, fFlags };
7261	mHWData->mGuestProperties.push_back(property);
7262	}
7263
7264	mHWData->mGuestPropertyNotificationPatterns = data.strNotificationPatterns;
7265	#endif /* VBOX_WITH_GUEST_PROPS defined */
7266	}
7267	catch(std::bad_alloc &)
7268	{
7269	return E_OUTOFMEMORY;
7270	}
7271
7272	AssertComRC(rc);
7273	return rc;
7274	}
7275
7276	/**
7277	* Called from loadMachineDataFromSettings() for the storage controller data, including media.
7278	*
7279	* @param data
7280	* @param puuidRegistry media registry ID to set media to or NULL; see Machine::loadMachineDataFromSettings()
7281	* @param puuidSnapshot
7282	* @return
7283	*/
7284	HRESULT Machine::loadStorageControllers(const settings::Storage &data,
7285	const Guid *puuidRegistry,
7286	const Guid *puuidSnapshot)
7287	{
7288	AssertReturn(!isSessionMachine(), E_FAIL);
7289
7290	HRESULT rc = S_OK;
7291
7292	for (settings::StorageControllersList::const_iterator it = data.llStorageControllers.begin();
7293	it != data.llStorageControllers.end();
7294	++it)
7295	{
7296	const settings::StorageController &ctlData = *it;
7297
7298	ComObjPtr<StorageController> pCtl;
7299	/* Try to find one with the name first. */
7300	rc = getStorageControllerByName(ctlData.strName, pCtl, false /* aSetError */);
7301	if (SUCCEEDED(rc))
7302	return setError(VBOX_E_OBJECT_IN_USE,
7303	tr("Storage controller named '%s' already exists"),
7304	ctlData.strName.c_str());
7305
7306	pCtl.createObject();
7307	rc = pCtl->init(this,
7308	ctlData.strName,
7309	ctlData.storageBus,
7310	ctlData.ulInstance);
7311	if (FAILED(rc)) return rc;
7312
7313	mStorageControllers->push_back(pCtl);
7314
7315	rc = pCtl->COMSETTER(ControllerType)(ctlData.controllerType);
7316	if (FAILED(rc)) return rc;
7317
7318	rc = pCtl->COMSETTER(PortCount)(ctlData.ulPortCount);
7319	if (FAILED(rc)) return rc;
7320
7321	rc = pCtl->COMSETTER(UseHostIOCache)(ctlData.fUseHostIOCache);
7322	if (FAILED(rc)) return rc;
7323
7324	/* Set IDE emulation settings (only for AHCI controller). */
7325	if (ctlData.controllerType == StorageControllerType_IntelAhci)
7326	{
7327	if ( (FAILED(rc = pCtl->SetIDEEmulationPort(0, ctlData.lIDE0MasterEmulationPort)))
7328	\|\| (FAILED(rc = pCtl->SetIDEEmulationPort(1, ctlData.lIDE0SlaveEmulationPort)))
7329	\|\| (FAILED(rc = pCtl->SetIDEEmulationPort(2, ctlData.lIDE1MasterEmulationPort)))
7330	\|\| (FAILED(rc = pCtl->SetIDEEmulationPort(3, ctlData.lIDE1SlaveEmulationPort)))
7331	)
7332	return rc;
7333	}
7334
7335	/* Load the attached devices now. */
7336	rc = loadStorageDevices(pCtl,
7337	ctlData,
7338	puuidRegistry,
7339	puuidSnapshot);
7340	if (FAILED(rc)) return rc;
7341	}
7342
7343	return S_OK;
7344	}
7345
7346	/**
7347	* Called from loadStorageControllers for a controller's devices.
7348	*
7349	* @param aStorageController
7350	* @param data
7351	* @param puuidRegistry media registry ID to set media to or NULL; see Machine::loadMachineDataFromSettings()
7352	* @param aSnapshotId pointer to the snapshot ID if this is a snapshot machine
7353	* @return
7354	*/
7355	HRESULT Machine::loadStorageDevices(StorageController *aStorageController,
7356	const settings::StorageController &data,
7357	const Guid *puuidRegistry,
7358	const Guid *puuidSnapshot)
7359	{
7360	HRESULT rc = S_OK;
7361
7362	/* paranoia: detect duplicate attachments */
7363	for (settings::AttachedDevicesList::const_iterator it = data.llAttachedDevices.begin();
7364	it != data.llAttachedDevices.end();
7365	++it)
7366	{
7367	const settings::AttachedDevice &ad = *it;
7368
7369	for (settings::AttachedDevicesList::const_iterator it2 = it;
7370	it2 != data.llAttachedDevices.end();
7371	++it2)
7372	{
7373	if (it == it2)
7374	continue;
7375
7376	const settings::AttachedDevice &ad2 = *it2;
7377
7378	if ( ad.lPort == ad2.lPort
7379	&& ad.lDevice == ad2.lDevice)
7380	{
7381	return setError(E_FAIL,
7382	tr("Duplicate attachments for storage controller '%s', port %d, device %d of the virtual machine '%s'"),
7383	aStorageController->getName().c_str(),
7384	ad.lPort,
7385	ad.lDevice,
7386	mUserData->s.strName.c_str());
7387	}
7388	}
7389	}
7390
7391	for (settings::AttachedDevicesList::const_iterator it = data.llAttachedDevices.begin();
7392	it != data.llAttachedDevices.end();
7393	++it)
7394	{
7395	const settings::AttachedDevice &dev = *it;
7396	ComObjPtr<Medium> medium;
7397
7398	switch (dev.deviceType)
7399	{
7400	case DeviceType_Floppy:
7401	case DeviceType_DVD:
7402	rc = mParent->findRemoveableMedium(dev.deviceType, dev.uuid, false /* fRefresh */, medium);
7403	if (FAILED(rc))
7404	return rc;
7405	break;
7406
7407	case DeviceType_HardDisk:
7408	{
7409	/* find a hard disk by UUID */
7410	rc = mParent->findHardDisk(&dev.uuid, Utf8Str::Empty, true /* aDoSetError */, &medium);
7411	if (FAILED(rc))
7412	{
7413	if (isSnapshotMachine())
7414	{
7415	// wrap another error message around the "cannot find hard disk" set by findHardDisk
7416	// so the user knows that the bad disk is in a snapshot somewhere
7417	com::ErrorInfo info;
7418	return setError(E_FAIL,
7419	tr("A differencing image of snapshot {%RTuuid} could not be found. %ls"),
7420	puuidSnapshot->raw(),
7421	info.getText().raw());
7422	}
7423	else
7424	return rc;
7425	}
7426
7427	AutoWriteLock hdLock(medium COMMA_LOCKVAL_SRC_POS);
7428
7429	if (medium->getType() == MediumType_Immutable)
7430	{
7431	if (isSnapshotMachine())
7432	return setError(E_FAIL,
7433	tr("Immutable hard disk '%s' with UUID {%RTuuid} cannot be directly attached to snapshot with UUID {%RTuuid} "
7434	"of the virtual machine '%s' ('%s')"),
7435	medium->getLocationFull().c_str(),
7436	dev.uuid.raw(),
7437	puuidSnapshot->raw(),
7438	mUserData->s.strName.c_str(),
7439	mData->m_strConfigFileFull.c_str());
7440
7441	return setError(E_FAIL,
7442	tr("Immutable hard disk '%s' with UUID {%RTuuid} cannot be directly attached to the virtual machine '%s' ('%s')"),
7443	medium->getLocationFull().c_str(),
7444	dev.uuid.raw(),
7445	mUserData->s.strName.c_str(),
7446	mData->m_strConfigFileFull.c_str());
7447	}
7448
7449	if ( !isSnapshotMachine()
7450	&& medium->getChildren().size() != 0
7451	)
7452	return setError(E_FAIL,
7453	tr("Hard disk '%s' with UUID {%RTuuid} cannot be directly attached to the virtual machine '%s' ('%s') "
7454	"because it has %d differencing child hard disks"),
7455	medium->getLocationFull().c_str(),
7456	dev.uuid.raw(),
7457	mUserData->s.strName.c_str(),
7458	mData->m_strConfigFileFull.c_str(),
7459	medium->getChildren().size());
7460
7461	if (findAttachment(mMediaData->mAttachments,
7462	medium))
7463	return setError(E_FAIL,
7464	tr("Hard disk '%s' with UUID {%RTuuid} is already attached to the virtual machine '%s' ('%s')"),
7465	medium->getLocationFull().c_str(),
7466	dev.uuid.raw(),
7467	mUserData->s.strName.c_str(),
7468	mData->m_strConfigFileFull.c_str());
7469
7470	break;
7471	}
7472
7473	default:
7474	return setError(E_FAIL,
7475	tr("Device '%s' with unknown type is attached to the virtual machine '%s' ('%s')"),
7476	medium->getLocationFull().c_str(),
7477	mUserData->s.strName.c_str(),
7478	mData->m_strConfigFileFull.c_str());
7479	}
7480
7481	if (FAILED(rc))
7482	break;
7483
7484	const Bstr controllerName = aStorageController->getName();
7485	ComObjPtr<MediumAttachment> pAttachment;
7486	pAttachment.createObject();
7487	rc = pAttachment->init(this,
7488	medium,
7489	controllerName,
7490	dev.lPort,
7491	dev.lDevice,
7492	dev.deviceType,
7493	dev.fPassThrough,
7494	dev.ulBandwidthLimit);
7495	if (FAILED(rc)) break;
7496
7497	/* associate the medium with this machine and snapshot */
7498	if (!medium.isNull())
7499	{
7500	if (isSnapshotMachine())
7501	rc = medium->addBackReference(mData->mUuid, *puuidSnapshot);
7502	else
7503	rc = medium->addBackReference(mData->mUuid);
7504
7505	if (puuidRegistry)
7506	// caller wants registry ID to be set on all attached media (OVF import case)
7507	medium->addRegistry(*puuidRegistry,
7508	NULL /* pfNeedsSaveSettings */);
7509	}
7510
7511	if (FAILED(rc))
7512	break;
7513
7514	/* back up mMediaData to let registeredInit() properly rollback on failure
7515	* (= limited accessibility) */
7516	setModified(IsModified_Storage);
7517	mMediaData.backup();
7518	mMediaData->mAttachments.push_back(pAttachment);
7519	}
7520
7521	return rc;
7522	}
7523
7524	/**
7525	* Returns the snapshot with the given UUID or fails of no such snapshot exists.
7526	*
7527	* @param aId snapshot UUID to find (empty UUID refers the first snapshot)
7528	* @param aSnapshot where to return the found snapshot
7529	* @param aSetError true to set extended error info on failure
7530	*/
7531	HRESULT Machine::findSnapshot(const Guid &aId,
7532	ComObjPtr<Snapshot> &aSnapshot,
7533	bool aSetError /* = false */)
7534	{
7535	AutoReadLock chlock(this COMMA_LOCKVAL_SRC_POS);
7536
7537	if (!mData->mFirstSnapshot)
7538	{
7539	if (aSetError)
7540	return setError(E_FAIL,
7541	tr("This machine does not have any snapshots"));
7542	return E_FAIL;
7543	}
7544
7545	if (aId.isEmpty())
7546	aSnapshot = mData->mFirstSnapshot;
7547	else
7548	aSnapshot = mData->mFirstSnapshot->findChildOrSelf(aId.ref());
7549
7550	if (!aSnapshot)
7551	{
7552	if (aSetError)
7553	return setError(E_FAIL,
7554	tr("Could not find a snapshot with UUID {%s}"),
7555	aId.toString().c_str());
7556	return E_FAIL;
7557	}
7558
7559	return S_OK;
7560	}
7561
7562	/**
7563	* Returns the snapshot with the given name or fails of no such snapshot.
7564	*
7565	* @param aName snapshot name to find
7566	* @param aSnapshot where to return the found snapshot
7567	* @param aSetError true to set extended error info on failure
7568	*/
7569	HRESULT Machine::findSnapshot(IN_BSTR aName,
7570	ComObjPtr<Snapshot> &aSnapshot,
7571	bool aSetError /* = false */)
7572	{
7573	AssertReturn(aName, E_INVALIDARG);
7574
7575	AutoReadLock chlock(this COMMA_LOCKVAL_SRC_POS);
7576
7577	if (!mData->mFirstSnapshot)
7578	{
7579	if (aSetError)
7580	return setError(VBOX_E_OBJECT_NOT_FOUND,
7581	tr("This machine does not have any snapshots"));
7582	return VBOX_E_OBJECT_NOT_FOUND;
7583	}
7584
7585	aSnapshot = mData->mFirstSnapshot->findChildOrSelf(aName);
7586
7587	if (!aSnapshot)
7588	{
7589	if (aSetError)
7590	return setError(VBOX_E_OBJECT_NOT_FOUND,
7591	tr("Could not find a snapshot named '%ls'"), aName);
7592	return VBOX_E_OBJECT_NOT_FOUND;
7593	}
7594
7595	return S_OK;
7596	}
7597
7598	/**
7599	* Returns a storage controller object with the given name.
7600	*
7601	* @param aName storage controller name to find
7602	* @param aStorageController where to return the found storage controller
7603	* @param aSetError true to set extended error info on failure
7604	*/
7605	HRESULT Machine::getStorageControllerByName(const Utf8Str &aName,
7606	ComObjPtr<StorageController> &aStorageController,
7607	bool aSetError /* = false */)
7608	{
7609	AssertReturn(!aName.isEmpty(), E_INVALIDARG);
7610
7611	for (StorageControllerList::const_iterator it = mStorageControllers->begin();
7612	it != mStorageControllers->end();
7613	++it)
7614	{
7615	if ((*it)->getName() == aName)
7616	{
7617	aStorageController = (*it);
7618	return S_OK;
7619	}
7620	}
7621
7622	if (aSetError)
7623	return setError(VBOX_E_OBJECT_NOT_FOUND,
7624	tr("Could not find a storage controller named '%s'"),
7625	aName.c_str());
7626	return VBOX_E_OBJECT_NOT_FOUND;
7627	}
7628
7629	HRESULT Machine::getMediumAttachmentsOfController(CBSTR aName,
7630	MediaData::AttachmentList &atts)
7631	{
7632	AutoCaller autoCaller(this);
7633	if (FAILED(autoCaller.rc())) return autoCaller.rc();
7634
7635	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7636
7637	for (MediaData::AttachmentList::iterator it = mMediaData->mAttachments.begin();
7638	it != mMediaData->mAttachments.end();
7639	++it)
7640	{
7641	const ComObjPtr<MediumAttachment> &pAtt = *it;
7642
7643	// should never happen, but deal with NULL pointers in the list.
7644	AssertStmt(!pAtt.isNull(), continue);
7645
7646	// getControllerName() needs caller+read lock
7647	AutoCaller autoAttCaller(pAtt);
7648	if (FAILED(autoAttCaller.rc()))
7649	{
7650	atts.clear();
7651	return autoAttCaller.rc();
7652	}
7653	AutoReadLock attLock(pAtt COMMA_LOCKVAL_SRC_POS);
7654
7655	if (pAtt->getControllerName() == aName)
7656	atts.push_back(pAtt);
7657	}
7658
7659	return S_OK;
7660	}
7661
7662	/**
7663	* Helper for #saveSettings. Cares about renaming the settings directory and
7664	* file if the machine name was changed and about creating a new settings file
7665	* if this is a new machine.
7666	*
7667	* @note Must be never called directly but only from #saveSettings().
7668	*/
7669	HRESULT Machine::prepareSaveSettings(bool *pfNeedsGlobalSaveSettings)
7670	{
7671	AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
7672
7673	HRESULT rc = S_OK;
7674
7675	bool fSettingsFileIsNew = !mData->pMachineConfigFile->fileExists();
7676
7677	/* attempt to rename the settings file if machine name is changed */
7678	if ( mUserData->s.fNameSync
7679	&& mUserData.isBackedUp()
7680	&& mUserData.backedUpData()->s.strName != mUserData->s.strName
7681	)
7682	{
7683	bool dirRenamed = false;
7684	bool fileRenamed = false;
7685
7686	Utf8Str configFile, newConfigFile;
7687	Utf8Str configDir, newConfigDir;
7688
7689	do
7690	{
7691	int vrc = VINF_SUCCESS;
7692
7693	Utf8Str name = mUserData.backedUpData()->s.strName;
7694	Utf8Str newName = mUserData->s.strName;
7695
7696	configFile = mData->m_strConfigFileFull;
7697
7698	/* first, rename the directory if it matches the machine name */
7699	configDir = configFile;
7700	configDir.stripFilename();
7701	newConfigDir = configDir;
7702	if (!strcmp(RTPathFilename(configDir.c_str()), name.c_str()))
7703	{
7704	newConfigDir.stripFilename();
7705	newConfigDir.append(RTPATH_DELIMITER);
7706	newConfigDir.append(newName);
7707	/* new dir and old dir cannot be equal here because of 'if'
7708	* above and because name != newName */
7709	Assert(configDir != newConfigDir);
7710	if (!fSettingsFileIsNew)
7711	{
7712	/* perform real rename only if the machine is not new */
7713	vrc = RTPathRename(configDir.c_str(), newConfigDir.c_str(), 0);
7714	if (RT_FAILURE(vrc))
7715	{
7716	rc = setError(E_FAIL,
7717	tr("Could not rename the directory '%s' to '%s' to save the settings file (%Rrc)"),
7718	configDir.c_str(),
7719	newConfigDir.c_str(),
7720	vrc);
7721	break;
7722	}
7723	dirRenamed = true;
7724	}
7725	}
7726
7727	newConfigFile = Utf8StrFmt("%s%c%s.vbox",
7728	newConfigDir.c_str(), RTPATH_DELIMITER, newName.c_str());
7729
7730	/* then try to rename the settings file itself */
7731	if (newConfigFile != configFile)
7732	{
7733	/* get the path to old settings file in renamed directory */
7734	configFile = Utf8StrFmt("%s%c%s",
7735	newConfigDir.c_str(),
7736	RTPATH_DELIMITER,
7737	RTPathFilename(configFile.c_str()));
7738	if (!fSettingsFileIsNew)
7739	{
7740	/* perform real rename only if the machine is not new */
7741	vrc = RTFileRename(configFile.c_str(), newConfigFile.c_str(), 0);
7742	if (RT_FAILURE(vrc))
7743	{
7744	rc = setError(E_FAIL,
7745	tr("Could not rename the settings file '%s' to '%s' (%Rrc)"),
7746	configFile.c_str(),
7747	newConfigFile.c_str(),
7748	vrc);
7749	break;
7750	}
7751	fileRenamed = true;
7752	}
7753	}
7754
7755	/* update m_strConfigFileFull amd mConfigFile */
7756	mData->m_strConfigFileFull = newConfigFile;
7757	// compute the relative path too
7758	mParent->copyPathRelativeToConfig(newConfigFile, mData->m_strConfigFile);
7759
7760	// store the old and new so that VirtualBox::saveSettings() can update
7761	// the media registry
7762	if ( mData->mRegistered
7763	&& configDir != newConfigDir)
7764	{
7765	mParent->rememberMachineNameChangeForMedia(configDir, newConfigDir);
7766
7767	if (pfNeedsGlobalSaveSettings)
7768	*pfNeedsGlobalSaveSettings = true;
7769	}
7770
7771	/* update the snapshot folder */
7772	if (RTPathStartsWith(mUserData->m_strSnapshotFolderFull.c_str(),
7773	configDir.c_str()))
7774	{
7775	mUserData->m_strSnapshotFolderFull = Utf8StrFmt("%s%s",
7776	newConfigDir.c_str(),
7777	mUserData->m_strSnapshotFolderFull.c_str() + configDir.length());
7778	copyPathRelativeToMachine(mUserData->m_strSnapshotFolderFull,
7779	mUserData->s.strSnapshotFolder);
7780	}
7781
7782	/* update the saved state file path */
7783	Utf8Str path = mSSData->mStateFilePath;
7784	if (RTPathStartsWith(path.c_str(), configDir.c_str()))
7785	mSSData->mStateFilePath = Utf8StrFmt("%s%s",
7786	newConfigDir.c_str(),
7787	path.c_str() + configDir.length());
7788
7789	/* Update saved state file paths of all online snapshots.
7790	* Note that saveSettings() will recognize name change
7791	* and will save all snapshots in this case. */
7792	if (mData->mFirstSnapshot)
7793	mData->mFirstSnapshot->updateSavedStatePaths(configDir.c_str(),
7794	newConfigDir.c_str());
7795	}
7796	while (0);
7797
7798	if (FAILED(rc))
7799	{
7800	/* silently try to rename everything back */
7801	if (fileRenamed)
7802	RTFileRename(newConfigFile.c_str(), configFile.c_str(), 0);
7803	if (dirRenamed)
7804	RTPathRename(newConfigDir.c_str(), configDir.c_str(), 0);
7805	}
7806
7807	if (FAILED(rc)) return rc;
7808	}
7809
7810	if (fSettingsFileIsNew)
7811	{
7812	/* create a virgin config file */
7813	int vrc = VINF_SUCCESS;
7814
7815	/* ensure the settings directory exists */
7816	Utf8Str path(mData->m_strConfigFileFull);
7817	path.stripFilename();
7818	if (!RTDirExists(path.c_str()))
7819	{
7820	vrc = RTDirCreateFullPath(path.c_str(), 0777);
7821	if (RT_FAILURE(vrc))
7822	{
7823	return setError(E_FAIL,
7824	tr("Could not create a directory '%s' to save the settings file (%Rrc)"),
7825	path.c_str(),
7826	vrc);
7827	}
7828	}
7829
7830	/* Note: open flags must correlate with RTFileOpen() in lockConfig() */
7831	path = Utf8Str(mData->m_strConfigFileFull);
7832	RTFILE f = NIL_RTFILE;
7833	vrc = RTFileOpen(&f, path.c_str(),
7834	RTFILE_O_READWRITE \| RTFILE_O_CREATE \| RTFILE_O_DENY_WRITE);
7835	if (RT_FAILURE(vrc))
7836	return setError(E_FAIL,
7837	tr("Could not create the settings file '%s' (%Rrc)"),
7838	path.c_str(),
7839	vrc);
7840	RTFileClose(f);
7841	}
7842
7843	return rc;
7844	}
7845
7846	/**
7847	* Saves and commits machine data, user data and hardware data.
7848	*
7849	* Note that on failure, the data remains uncommitted.
7850	*
7851	* @a aFlags may combine the following flags:
7852	*
7853	* - SaveS_ResetCurStateModified: Resets mData->mCurrentStateModified to FALSE.
7854	* Used when saving settings after an operation that makes them 100%
7855	* correspond to the settings from the current snapshot.
7856	* - SaveS_InformCallbacksAnyway: Callbacks will be informed even if
7857	* #isReallyModified() returns false. This is necessary for cases when we
7858	* change machine data directly, not through the backup()/commit() mechanism.
7859	* - SaveS_Force: settings will be saved without doing a deep compare of the
7860	* settings structures. This is used when this is called because snapshots
7861	* have changed to avoid the overhead of the deep compare.
7862	*
7863	* @note Must be called from under this object's write lock. Locks children for
7864	* writing.
7865	*
7866	* @param pfNeedsGlobalSaveSettings Optional pointer to a bool that must have been
7867	* initialized to false and that will be set to true by this function if
7868	* the caller must invoke VirtualBox::saveSettings() because the global
7869	* settings have changed. This will happen if a machine rename has been
7870	* saved and the global machine and media registries will therefore need
7871	* updating.
7872	*/
7873	HRESULT Machine::saveSettings(bool *pfNeedsGlobalSaveSettings,
7874	int aFlags /= 0/)
7875	{
7876	LogFlowThisFuncEnter();
7877
7878	AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
7879
7880	/* make sure child objects are unable to modify the settings while we are
7881	* saving them */
7882	ensureNoStateDependencies();
7883
7884	AssertReturn(!isSnapshotMachine(),
7885	E_FAIL);
7886
7887	HRESULT rc = S_OK;
7888	bool fNeedsWrite = false;
7889
7890	/* First, prepare to save settings. It will care about renaming the
7891	* settings directory and file if the machine name was changed and about
7892	* creating a new settings file if this is a new machine. */
7893	rc = prepareSaveSettings(pfNeedsGlobalSaveSettings);
7894	if (FAILED(rc)) return rc;
7895
7896	// keep a pointer to the current settings structures
7897	settings::MachineConfigFile *pOldConfig = mData->pMachineConfigFile;
7898	settings::MachineConfigFile *pNewConfig = NULL;
7899
7900	try
7901	{
7902	// make a fresh one to have everyone write stuff into
7903	pNewConfig = new settings::MachineConfigFile(NULL);
7904	pNewConfig->copyBaseFrom(*mData->pMachineConfigFile);
7905
7906	// now go and copy all the settings data from COM to the settings structures
7907	// (this calles saveSettings() on all the COM objects in the machine)
7908	copyMachineDataToSettings(*pNewConfig);
7909
7910	if (aFlags & SaveS_ResetCurStateModified)
7911	{
7912	// this gets set by takeSnapshot() (if offline snapshot) and restoreSnapshot()
7913	mData->mCurrentStateModified = FALSE;
7914	fNeedsWrite = true; // always, no need to compare
7915	}
7916	else if (aFlags & SaveS_Force)
7917	{
7918	fNeedsWrite = true; // always, no need to compare
7919	}
7920	else
7921	{
7922	if (!mData->mCurrentStateModified)
7923	{
7924	// do a deep compare of the settings that we just saved with the settings
7925	// previously stored in the config file; this invokes MachineConfigFile::operator==
7926	// which does a deep compare of all the settings, which is expensive but less expensive
7927	// than writing out XML in vain
7928	bool fAnySettingsChanged = (pNewConfig == pOldConfig);
7929
7930	// could still be modified if any settings changed
7931	mData->mCurrentStateModified = fAnySettingsChanged;
7932
7933	fNeedsWrite = fAnySettingsChanged;
7934	}
7935	else
7936	fNeedsWrite = true;
7937	}
7938
7939	pNewConfig->fCurrentStateModified = !!mData->mCurrentStateModified;
7940
7941	if (fNeedsWrite)
7942	// now spit it all out!
7943	pNewConfig->write(mData->m_strConfigFileFull);
7944
7945	mData->pMachineConfigFile = pNewConfig;
7946	delete pOldConfig;
7947	commit();
7948
7949	// after saving settings, we are no longer different from the XML on disk
7950	mData->flModifications = 0;
7951	}
7952	catch (HRESULT err)
7953	{
7954	// we assume that error info is set by the thrower
7955	rc = err;
7956
7957	// restore old config
7958	delete pNewConfig;
7959	mData->pMachineConfigFile = pOldConfig;
7960	}
7961	catch (...)
7962	{
7963	rc = VirtualBox::handleUnexpectedExceptions(RT_SRC_POS);
7964	}
7965
7966	if (fNeedsWrite \|\| (aFlags & SaveS_InformCallbacksAnyway))
7967	{
7968	/* Fire the data change event, even on failure (since we've already
7969	* committed all data). This is done only for SessionMachines because
7970	* mutable Machine instances are always not registered (i.e. private
7971	* to the client process that creates them) and thus don't need to
7972	* inform callbacks. */
7973	if (isSessionMachine())
7974	mParent->onMachineDataChange(mData->mUuid);
7975	}
7976
7977	LogFlowThisFunc(("rc=%08X\n", rc));
7978	LogFlowThisFuncLeave();
7979	return rc;
7980	}
7981
7982	/**
7983	* Implementation for saving the machine settings into the given
7984	* settings::MachineConfigFile instance. This copies machine extradata
7985	* from the previous machine config file in the instance data, if any.
7986	*
7987	* This gets called from two locations:
7988	*
7989	* -- Machine::saveSettings(), during the regular XML writing;
7990	*
7991	* -- Appliance::buildXMLForOneVirtualSystem(), when a machine gets
7992	* exported to OVF and we write the VirtualBox proprietary XML
7993	* into a <vbox:Machine> tag.
7994	*
7995	* This routine fills all the fields in there, including snapshots, except
7996	* for the following:
7997	*
7998	* -- fCurrentStateModified. There is some special logic associated with that.
7999	*
8000	* The caller can then call MachineConfigFile::write() or do something else
8001	* with it.
8002	*
8003	* Caller must hold the machine lock!
8004	*
8005	* This throws XML errors and HRESULT, so the caller must have a catch block!
8006	*/
8007	void Machine::copyMachineDataToSettings(settings::MachineConfigFile &config)
8008	{
8009	// deep copy extradata
8010	config.mapExtraDataItems = mData->pMachineConfigFile->mapExtraDataItems;
8011
8012	config.uuid = mData->mUuid;
8013
8014	// copy name, description, OS type, teleport, UTC etc.
8015	config.machineUserData = mUserData->s;
8016
8017	if ( mData->mMachineState == MachineState_Saved
8018	\|\| mData->mMachineState == MachineState_Restoring
8019	// when deleting a snapshot we may or may not have a saved state in the current state,
8020	// so let's not assert here please
8021	\|\| ( ( mData->mMachineState == MachineState_DeletingSnapshot
8022	\|\| mData->mMachineState == MachineState_DeletingSnapshotOnline
8023	\|\| mData->mMachineState == MachineState_DeletingSnapshotPaused)
8024	&& (!mSSData->mStateFilePath.isEmpty())
8025	)
8026	)
8027	{
8028	Assert(!mSSData->mStateFilePath.isEmpty());
8029	/* try to make the file name relative to the settings file dir */
8030	copyPathRelativeToMachine(mSSData->mStateFilePath, config.strStateFile);
8031	}
8032	else
8033	{
8034	Assert(mSSData->mStateFilePath.isEmpty());
8035	config.strStateFile.setNull();
8036	}
8037
8038	if (mData->mCurrentSnapshot)
8039	config.uuidCurrentSnapshot = mData->mCurrentSnapshot->getId();
8040	else
8041	config.uuidCurrentSnapshot.clear();
8042
8043	config.timeLastStateChange = mData->mLastStateChange;
8044	config.fAborted = (mData->mMachineState == MachineState_Aborted);
8045	/// @todo Live Migration: config.fTeleported = (mData->mMachineState == MachineState_Teleported);
8046
8047	HRESULT rc = saveHardware(config.hardwareMachine);
8048	if (FAILED(rc)) throw rc;
8049
8050	rc = saveStorageControllers(config.storageMachine);
8051	if (FAILED(rc)) throw rc;
8052
8053	// save machine's media registry if this is VirtualBox 4.0 or later
8054	if (config.canHaveOwnMediaRegistry())
8055	mParent->saveMediaRegistry(config.mediaRegistry,
8056	getId()); // only media with registry ID == machine UUID
8057	// this throws HRESULT
8058
8059	// save snapshots
8060	rc = saveAllSnapshots(config);
8061	if (FAILED(rc)) throw rc;
8062	}
8063
8064	/**
8065	* Saves all snapshots of the machine into the given machine config file. Called
8066	* from Machine::buildMachineXML() and SessionMachine::deleteSnapshotHandler().
8067	* @param config
8068	* @return
8069	*/
8070	HRESULT Machine::saveAllSnapshots(settings::MachineConfigFile &config)
8071	{
8072	AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
8073
8074	HRESULT rc = S_OK;
8075
8076	try
8077	{
8078	config.llFirstSnapshot.clear();
8079
8080	if (mData->mFirstSnapshot)
8081	{
8082	settings::Snapshot snapNew;
8083	config.llFirstSnapshot.push_back(snapNew);
8084
8085	// get reference to the fresh copy of the snapshot on the list and
8086	// work on that copy directly to avoid excessive copying later
8087	settings::Snapshot &snap = config.llFirstSnapshot.front();
8088
8089	rc = mData->mFirstSnapshot->saveSnapshot(snap, false /aAttrsOnly/);
8090	if (FAILED(rc)) throw rc;
8091	}
8092
8093	// if (mType == IsSessionMachine)
8094	// mParent->onMachineDataChange(mData->mUuid); @todo is this necessary?
8095
8096	}
8097	catch (HRESULT err)
8098	{
8099	/* we assume that error info is set by the thrower */
8100	rc = err;
8101	}
8102	catch (...)
8103	{
8104	rc = VirtualBox::handleUnexpectedExceptions(RT_SRC_POS);
8105	}
8106
8107	return rc;
8108	}
8109
8110	/**
8111	* Saves the VM hardware configuration. It is assumed that the
8112	* given node is empty.
8113	*
8114	* @param aNode <Hardware> node to save the VM hardware confguration to.
8115	*/
8116	HRESULT Machine::saveHardware(settings::Hardware &data)
8117	{
8118	HRESULT rc = S_OK;
8119
8120	try
8121	{
8122	/* The hardware version attribute (optional).
8123	Automatically upgrade from 1 to 2 when there is no saved state. (ugly!) */
8124	if ( mHWData->mHWVersion == "1"
8125	&& mSSData->mStateFilePath.isEmpty()
8126	)
8127	mHWData->mHWVersion = "2"; /** @todo Is this safe, to update mHWVersion here? If not some other point needs to be found where this can be done. */
8128
8129	data.strVersion = mHWData->mHWVersion;
8130	data.uuid = mHWData->mHardwareUUID;
8131
8132	// CPU
8133	data.fHardwareVirt = !!mHWData->mHWVirtExEnabled;
8134	data.fHardwareVirtExclusive = !!mHWData->mHWVirtExExclusive;
8135	data.fNestedPaging = !!mHWData->mHWVirtExNestedPagingEnabled;
8136	data.fLargePages = !!mHWData->mHWVirtExLargePagesEnabled;
8137	data.fVPID = !!mHWData->mHWVirtExVPIDEnabled;
8138	data.fHardwareVirtForce = !!mHWData->mHWVirtExForceEnabled;
8139	data.fPAE = !!mHWData->mPAEEnabled;
8140	data.fSyntheticCpu = !!mHWData->mSyntheticCpu;
8141
8142	/* Standard and Extended CPUID leafs. */
8143	data.llCpuIdLeafs.clear();
8144	for (unsigned idx = 0; idx < RT_ELEMENTS(mHWData->mCpuIdStdLeafs); idx++)
8145	{
8146	if (mHWData->mCpuIdStdLeafs[idx].ulId != UINT32_MAX)
8147	data.llCpuIdLeafs.push_back(mHWData->mCpuIdStdLeafs[idx]);
8148	}
8149	for (unsigned idx = 0; idx < RT_ELEMENTS(mHWData->mCpuIdExtLeafs); idx++)
8150	{
8151	if (mHWData->mCpuIdExtLeafs[idx].ulId != UINT32_MAX)
8152	data.llCpuIdLeafs.push_back(mHWData->mCpuIdExtLeafs[idx]);
8153	}
8154
8155	data.cCPUs = mHWData->mCPUCount;
8156	data.fCpuHotPlug = !!mHWData->mCPUHotPlugEnabled;
8157	data.ulCpuExecutionCap = mHWData->mCpuExecutionCap;
8158
8159	data.llCpus.clear();
8160	if (data.fCpuHotPlug)
8161	{
8162	for (unsigned idx = 0; idx < data.cCPUs; idx++)
8163	{
8164	if (mHWData->mCPUAttached[idx])
8165	{
8166	settings::Cpu cpu;
8167	cpu.ulId = idx;
8168	data.llCpus.push_back(cpu);
8169	}
8170	}
8171	}
8172
8173	// memory
8174	data.ulMemorySizeMB = mHWData->mMemorySize;
8175	data.fPageFusionEnabled = !!mHWData->mPageFusionEnabled;
8176
8177	// firmware
8178	data.firmwareType = mHWData->mFirmwareType;
8179
8180	// HID
8181	data.pointingHidType = mHWData->mPointingHidType;
8182	data.keyboardHidType = mHWData->mKeyboardHidType;
8183
8184	// chipset
8185	data.chipsetType = mHWData->mChipsetType;
8186
8187	// HPET
8188	data.fHpetEnabled = !!mHWData->mHpetEnabled;
8189
8190	// boot order
8191	data.mapBootOrder.clear();
8192	for (size_t i = 0;
8193	i < RT_ELEMENTS(mHWData->mBootOrder);
8194	++i)
8195	data.mapBootOrder[i] = mHWData->mBootOrder[i];
8196
8197	// display
8198	data.ulVRAMSizeMB = mHWData->mVRAMSize;
8199	data.cMonitors = mHWData->mMonitorCount;
8200	data.fAccelerate3D = !!mHWData->mAccelerate3DEnabled;
8201	data.fAccelerate2DVideo = !!mHWData->mAccelerate2DVideoEnabled;
8202
8203	#ifdef VBOX_WITH_VRDP
8204	/* VRDP settings (optional) */
8205	rc = mVRDPServer->saveSettings(data.vrdpSettings);
8206	if (FAILED(rc)) throw rc;
8207	#endif
8208
8209	/* BIOS (required) */
8210	rc = mBIOSSettings->saveSettings(data.biosSettings);
8211	if (FAILED(rc)) throw rc;
8212
8213	/* USB Controller (required) */
8214	rc = mUSBController->saveSettings(data.usbController);
8215	if (FAILED(rc)) throw rc;
8216
8217	/* Network adapters (required) */
8218	data.llNetworkAdapters.clear();
8219	for (ULONG slot = 0;
8220	slot < RT_ELEMENTS(mNetworkAdapters);
8221	++slot)
8222	{
8223	settings::NetworkAdapter nic;
8224	nic.ulSlot = slot;
8225	rc = mNetworkAdapters[slot]->saveSettings(nic);
8226	if (FAILED(rc)) throw rc;
8227
8228	data.llNetworkAdapters.push_back(nic);
8229	}
8230
8231	/* Serial ports */
8232	data.llSerialPorts.clear();
8233	for (ULONG slot = 0;
8234	slot < RT_ELEMENTS(mSerialPorts);
8235	++slot)
8236	{
8237	settings::SerialPort s;
8238	s.ulSlot = slot;
8239	rc = mSerialPorts[slot]->saveSettings(s);
8240	if (FAILED(rc)) return rc;
8241
8242	data.llSerialPorts.push_back(s);
8243	}
8244
8245	/* Parallel ports */
8246	data.llParallelPorts.clear();
8247	for (ULONG slot = 0;
8248	slot < RT_ELEMENTS(mParallelPorts);
8249	++slot)
8250	{
8251	settings::ParallelPort p;
8252	p.ulSlot = slot;
8253	rc = mParallelPorts[slot]->saveSettings(p);
8254	if (FAILED(rc)) return rc;
8255
8256	data.llParallelPorts.push_back(p);
8257	}
8258
8259	/* Audio adapter */
8260	rc = mAudioAdapter->saveSettings(data.audioAdapter);
8261	if (FAILED(rc)) return rc;
8262
8263	/* Shared folders */
8264	data.llSharedFolders.clear();
8265	for (HWData::SharedFolderList::const_iterator it = mHWData->mSharedFolders.begin();
8266	it != mHWData->mSharedFolders.end();
8267	++it)
8268	{
8269	ComObjPtr<SharedFolder> pFolder = *it;
8270	settings::SharedFolder sf;
8271	sf.strName = pFolder->getName();
8272	sf.strHostPath = pFolder->getHostPath();
8273	sf.fWritable = !!pFolder->isWritable();
8274	sf.fAutoMount = !!pFolder->isAutoMounted();
8275
8276	data.llSharedFolders.push_back(sf);
8277	}
8278
8279	// clipboard
8280	data.clipboardMode = mHWData->mClipboardMode;
8281
8282	/* Guest */
8283	data.ulMemoryBalloonSize = mHWData->mMemoryBalloonSize;
8284
8285	// IO settings
8286	data.ioSettings.fIoCacheEnabled = !!mHWData->mIoCacheEnabled;
8287	data.ioSettings.ulIoCacheSize = mHWData->mIoCacheSize;
8288
8289	// guest properties
8290	data.llGuestProperties.clear();
8291	#ifdef VBOX_WITH_GUEST_PROPS
8292	for (HWData::GuestPropertyList::const_iterator it = mHWData->mGuestProperties.begin();
8293	it != mHWData->mGuestProperties.end();
8294	++it)
8295	{
8296	HWData::GuestProperty property = *it;
8297
8298	/* Remove transient guest properties at shutdown unless we
8299	* are saving state */
8300	if ( ( mData->mMachineState == MachineState_PoweredOff
8301	\|\| mData->mMachineState == MachineState_Aborted
8302	\|\| mData->mMachineState == MachineState_Teleported)
8303	&& property.mFlags & guestProp::TRANSIENT)
8304	continue;
8305	settings::GuestProperty prop;
8306	prop.strName = property.strName;
8307	prop.strValue = property.strValue;
8308	prop.timestamp = property.mTimestamp;
8309	char szFlags[guestProp::MAX_FLAGS_LEN + 1];
8310	guestProp::writeFlags(property.mFlags, szFlags);
8311	prop.strFlags = szFlags;
8312
8313	data.llGuestProperties.push_back(prop);
8314	}
8315
8316	data.strNotificationPatterns = mHWData->mGuestPropertyNotificationPatterns;
8317	/* I presume this doesn't require a backup(). */
8318	mData->mGuestPropertiesModified = FALSE;
8319	#endif /* VBOX_WITH_GUEST_PROPS defined */
8320	}
8321	catch(std::bad_alloc &)
8322	{
8323	return E_OUTOFMEMORY;
8324	}
8325
8326	AssertComRC(rc);
8327	return rc;
8328	}
8329
8330	/**
8331	* Saves the storage controller configuration.
8332	*
8333	* @param aNode <StorageControllers> node to save the VM hardware confguration to.
8334	*/
8335	HRESULT Machine::saveStorageControllers(settings::Storage &data)
8336	{
8337	data.llStorageControllers.clear();
8338
8339	for (StorageControllerList::const_iterator it = mStorageControllers->begin();
8340	it != mStorageControllers->end();
8341	++it)
8342	{
8343	HRESULT rc;
8344	ComObjPtr<StorageController> pCtl = *it;
8345
8346	settings::StorageController ctl;
8347	ctl.strName = pCtl->getName();
8348	ctl.controllerType = pCtl->getControllerType();
8349	ctl.storageBus = pCtl->getStorageBus();
8350	ctl.ulInstance = pCtl->getInstance();
8351
8352	/* Save the port count. */
8353	ULONG portCount;
8354	rc = pCtl->COMGETTER(PortCount)(&portCount);
8355	ComAssertComRCRet(rc, rc);
8356	ctl.ulPortCount = portCount;
8357
8358	/* Save fUseHostIOCache */
8359	BOOL fUseHostIOCache;
8360	rc = pCtl->COMGETTER(UseHostIOCache)(&fUseHostIOCache);
8361	ComAssertComRCRet(rc, rc);
8362	ctl.fUseHostIOCache = !!fUseHostIOCache;
8363
8364	/* Save IDE emulation settings. */
8365	if (ctl.controllerType == StorageControllerType_IntelAhci)
8366	{
8367	if ( (FAILED(rc = pCtl->GetIDEEmulationPort(0, (LONG*)&ctl.lIDE0MasterEmulationPort)))
8368	\|\| (FAILED(rc = pCtl->GetIDEEmulationPort(1, (LONG*)&ctl.lIDE0SlaveEmulationPort)))
8369	\|\| (FAILED(rc = pCtl->GetIDEEmulationPort(2, (LONG*)&ctl.lIDE1MasterEmulationPort)))
8370	\|\| (FAILED(rc = pCtl->GetIDEEmulationPort(3, (LONG*)&ctl.lIDE1SlaveEmulationPort)))
8371	)
8372	ComAssertComRCRet(rc, rc);
8373	}
8374
8375	/* save the devices now. */
8376	rc = saveStorageDevices(pCtl, ctl);
8377	ComAssertComRCRet(rc, rc);
8378
8379	data.llStorageControllers.push_back(ctl);
8380	}
8381
8382	return S_OK;
8383	}
8384
8385	/**
8386	* Saves the hard disk confguration.
8387	*/
8388	HRESULT Machine::saveStorageDevices(ComObjPtr<StorageController> aStorageController,
8389	settings::StorageController &data)
8390	{
8391	MediaData::AttachmentList atts;
8392
8393	HRESULT rc = getMediumAttachmentsOfController(Bstr(aStorageController->getName()).raw(), atts);
8394	if (FAILED(rc)) return rc;
8395
8396	data.llAttachedDevices.clear();
8397	for (MediaData::AttachmentList::const_iterator it = atts.begin();
8398	it != atts.end();
8399	++it)
8400	{
8401	settings::AttachedDevice dev;
8402
8403	MediumAttachment pAttach = it;
8404	Medium *pMedium = pAttach->getMedium();
8405
8406	dev.deviceType = pAttach->getType();
8407	dev.lPort = pAttach->getPort();
8408	dev.lDevice = pAttach->getDevice();
8409	if (pMedium)
8410	{
8411	if (pMedium->isHostDrive())
8412	dev.strHostDriveSrc = pMedium->getLocation();
8413	else
8414	dev.uuid = pMedium->getId();
8415	dev.fPassThrough = pAttach->getPassthrough();
8416	}
8417
8418	data.llAttachedDevices.push_back(dev);
8419	}
8420
8421	return S_OK;
8422	}
8423
8424	/**
8425	* Saves machine state settings as defined by aFlags
8426	* (SaveSTS_* values).
8427	*
8428	* @param aFlags Combination of SaveSTS_* flags.
8429	*
8430	* @note Locks objects for writing.
8431	*/
8432	HRESULT Machine::saveStateSettings(int aFlags)
8433	{
8434	if (aFlags == 0)
8435	return S_OK;
8436
8437	AutoCaller autoCaller(this);
8438	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
8439
8440	/* This object's write lock is also necessary to serialize file access
8441	* (prevent concurrent reads and writes) */
8442	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
8443
8444	HRESULT rc = S_OK;
8445
8446	Assert(mData->pMachineConfigFile);
8447
8448	try
8449	{
8450	if (aFlags & SaveSTS_CurStateModified)
8451	mData->pMachineConfigFile->fCurrentStateModified = true;
8452
8453	if (aFlags & SaveSTS_StateFilePath)
8454	{
8455	if (!mSSData->mStateFilePath.isEmpty())
8456	/* try to make the file name relative to the settings file dir */
8457	copyPathRelativeToMachine(mSSData->mStateFilePath, mData->pMachineConfigFile->strStateFile);
8458	else
8459	mData->pMachineConfigFile->strStateFile.setNull();
8460	}
8461
8462	if (aFlags & SaveSTS_StateTimeStamp)
8463	{
8464	Assert( mData->mMachineState != MachineState_Aborted
8465	\|\| mSSData->mStateFilePath.isEmpty());
8466
8467	mData->pMachineConfigFile->timeLastStateChange = mData->mLastStateChange;
8468
8469	mData->pMachineConfigFile->fAborted = (mData->mMachineState == MachineState_Aborted);
8470	//@todo live migration mData->pMachineConfigFile->fTeleported = (mData->mMachineState == MachineState_Teleported);
8471	}
8472
8473	mData->pMachineConfigFile->write(mData->m_strConfigFileFull);
8474	}
8475	catch (...)
8476	{
8477	rc = VirtualBox::handleUnexpectedExceptions(RT_SRC_POS);
8478	}
8479
8480	return rc;
8481	}
8482
8483	/**
8484	* Creates differencing hard disks for all normal hard disks attached to this
8485	* machine and a new set of attachments to refer to created disks.
8486	*
8487	* Used when taking a snapshot or when deleting the current state. Gets called
8488	* from SessionMachine::BeginTakingSnapshot() and SessionMachine::restoreSnapshotHandler().
8489	*
8490	* This method assumes that mMediaData contains the original hard disk attachments
8491	* it needs to create diffs for. On success, these attachments will be replaced
8492	* with the created diffs. On failure, #deleteImplicitDiffs() is implicitly
8493	* called to delete created diffs which will also rollback mMediaData and restore
8494	* whatever was backed up before calling this method.
8495	*
8496	* Attachments with non-normal hard disks are left as is.
8497	*
8498	* If @a aOnline is @c false then the original hard disks that require implicit
8499	* diffs will be locked for reading. Otherwise it is assumed that they are
8500	* already locked for writing (when the VM was started). Note that in the latter
8501	* case it is responsibility of the caller to lock the newly created diffs for
8502	* writing if this method succeeds.
8503	*
8504	* @param aProgress Progress object to run (must contain at least as
8505	* many operations left as the number of hard disks
8506	* attached).
8507	* @param aOnline Whether the VM was online prior to this operation.
8508	* @param pfNeedsSaveSettings Optional pointer to a bool that must have been initialized to false and that will be set to true
8509	* by this function if the caller should invoke VirtualBox::saveSettings() because the global settings have changed.
8510	*
8511	* @note The progress object is not marked as completed, neither on success nor
8512	* on failure. This is a responsibility of the caller.
8513	*
8514	* @note Locks this object for writing.
8515	*/
8516	HRESULT Machine::createImplicitDiffs(IProgress *aProgress,
8517	ULONG aWeight,
8518	bool aOnline,
8519	bool *pfNeedsSaveSettings)
8520	{
8521	LogFlowThisFunc(("aOnline=%d\n", aOnline));
8522
8523	AutoCaller autoCaller(this);
8524	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
8525
8526	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
8527
8528	/* must be in a protective state because we leave the lock below */
8529	AssertReturn( mData->mMachineState == MachineState_Saving
8530	\|\| mData->mMachineState == MachineState_LiveSnapshotting
8531	\|\| mData->mMachineState == MachineState_RestoringSnapshot
8532	\|\| mData->mMachineState == MachineState_DeletingSnapshot
8533	, E_FAIL);
8534
8535	HRESULT rc = S_OK;
8536
8537	MediumLockListMap lockedMediaOffline;
8538	MediumLockListMap *lockedMediaMap;
8539	if (aOnline)
8540	lockedMediaMap = &mData->mSession.mLockedMedia;
8541	else
8542	lockedMediaMap = &lockedMediaOffline;
8543
8544	try
8545	{
8546	if (!aOnline)
8547	{
8548	/* lock all attached hard disks early to detect "in use"
8549	* situations before creating actual diffs */
8550	for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
8551	it != mMediaData->mAttachments.end();
8552	++it)
8553	{
8554	MediumAttachment* pAtt = *it;
8555	if (pAtt->getType() == DeviceType_HardDisk)
8556	{
8557	Medium* pMedium = pAtt->getMedium();
8558	Assert(pMedium);
8559
8560	MediumLockList *pMediumLockList(new MediumLockList());
8561	rc = pMedium->createMediumLockList(true /* fFailIfInaccessible */,
8562	false /* fMediumLockWrite */,
8563	NULL,
8564	*pMediumLockList);
8565	if (FAILED(rc))
8566	{
8567	delete pMediumLockList;
8568	throw rc;
8569	}
8570	rc = lockedMediaMap->Insert(pAtt, pMediumLockList);
8571	if (FAILED(rc))
8572	{
8573	throw setError(rc,
8574	tr("Collecting locking information for all attached media failed"));
8575	}
8576	}
8577	}
8578
8579	/* Now lock all media. If this fails, nothing is locked. */
8580	rc = lockedMediaMap->Lock();
8581	if (FAILED(rc))
8582	{
8583	throw setError(rc,
8584	tr("Locking of attached media failed"));
8585	}
8586	}
8587
8588	/* remember the current list (note that we don't use backup() since
8589	* mMediaData may be already backed up) */
8590	MediaData::AttachmentList atts = mMediaData->mAttachments;
8591
8592	/* start from scratch */
8593	mMediaData->mAttachments.clear();
8594
8595	/* go through remembered attachments and create diffs for normal hard
8596	* disks and attach them */
8597	for (MediaData::AttachmentList::const_iterator it = atts.begin();
8598	it != atts.end();
8599	++it)
8600	{
8601	MediumAttachment* pAtt = *it;
8602
8603	DeviceType_T devType = pAtt->getType();
8604	Medium* pMedium = pAtt->getMedium();
8605
8606	if ( devType != DeviceType_HardDisk
8607	\|\| pMedium == NULL
8608	\|\| pMedium->getType() != MediumType_Normal)
8609	{
8610	/* copy the attachment as is */
8611
8612	/** @todo the progress object created in Console::TakeSnaphot
8613	* only expects operations for hard disks. Later other
8614	* device types need to show up in the progress as well. */
8615	if (devType == DeviceType_HardDisk)
8616	{
8617	if (pMedium == NULL)
8618	aProgress->SetNextOperation(Bstr(tr("Skipping attachment without medium")).raw(),
8619	aWeight); // weight
8620	else
8621	aProgress->SetNextOperation(BstrFmt(tr("Skipping medium '%s'"),
8622	pMedium->getBase()->getName().c_str()).raw(),
8623	aWeight); // weight
8624	}
8625
8626	mMediaData->mAttachments.push_back(pAtt);
8627	continue;
8628	}
8629
8630	/* need a diff */
8631	aProgress->SetNextOperation(BstrFmt(tr("Creating differencing hard disk for '%s'"),
8632	pMedium->getBase()->getName().c_str()).raw(),
8633	aWeight); // weight
8634
8635	ComObjPtr<Medium> diff;
8636	diff.createObject();
8637	rc = diff->init(mParent,
8638	pMedium->getPreferredDiffFormat(),
8639	Utf8Str(mUserData->m_strSnapshotFolderFull).append(RTPATH_SLASH_STR),
8640	pMedium->getFirstRegistryMachineId(), // store the diff in the same registry as the parent
8641	pfNeedsSaveSettings);
8642	if (FAILED(rc)) throw rc;
8643
8644	/** @todo r=bird: How is the locking and diff image cleaned up if we fail before
8645	* the push_back? Looks like we're going to leave medium with the
8646	* wrong kind of lock (general issue with if we fail anywhere at all)
8647	* and an orphaned VDI in the snapshots folder. */
8648
8649	/* update the appropriate lock list */
8650	MediumLockList *pMediumLockList;
8651	rc = lockedMediaMap->Get(pAtt, pMediumLockList);
8652	AssertComRCThrowRC(rc);
8653	if (aOnline)
8654	{
8655	rc = pMediumLockList->Update(pMedium, false);
8656	AssertComRCThrowRC(rc);
8657	}
8658
8659	/* leave the lock before the potentially lengthy operation */
8660	alock.leave();
8661	rc = pMedium->createDiffStorage(diff, MediumVariant_Standard,
8662	pMediumLockList,
8663	NULL /* aProgress */,
8664	true /* aWait */,
8665	pfNeedsSaveSettings);
8666	alock.enter();
8667	if (FAILED(rc)) throw rc;
8668
8669	rc = lockedMediaMap->Unlock();
8670	AssertComRCThrowRC(rc);
8671	rc = pMediumLockList->Append(diff, true);
8672	AssertComRCThrowRC(rc);
8673	rc = lockedMediaMap->Lock();
8674	AssertComRCThrowRC(rc);
8675
8676	rc = diff->addBackReference(mData->mUuid);
8677	AssertComRCThrowRC(rc);
8678
8679	/* add a new attachment */
8680	ComObjPtr<MediumAttachment> attachment;
8681	attachment.createObject();
8682	rc = attachment->init(this,
8683	diff,
8684	pAtt->getControllerName(),
8685	pAtt->getPort(),
8686	pAtt->getDevice(),
8687	DeviceType_HardDisk,
8688	true /* aImplicit */,
8689	0 /* No bandwidth limit */);
8690	if (FAILED(rc)) throw rc;
8691
8692	rc = lockedMediaMap->ReplaceKey(pAtt, attachment);
8693	AssertComRCThrowRC(rc);
8694	mMediaData->mAttachments.push_back(attachment);
8695	}
8696	}
8697	catch (HRESULT aRC) { rc = aRC; }
8698
8699	/* unlock all hard disks we locked */
8700	if (!aOnline)
8701	{
8702	ErrorInfoKeeper eik;
8703
8704	rc = lockedMediaMap->Clear();
8705	AssertComRC(rc);
8706	}
8707
8708	if (FAILED(rc))
8709	{
8710	MultiResult mrc = rc;
8711
8712	mrc = deleteImplicitDiffs(pfNeedsSaveSettings);
8713	}
8714
8715	return rc;
8716	}
8717
8718	/**
8719	* Deletes implicit differencing hard disks created either by
8720	* #createImplicitDiffs() or by #AttachMedium() and rolls back mMediaData.
8721	*
8722	* Note that to delete hard disks created by #AttachMedium() this method is
8723	* called from #fixupMedia() when the changes are rolled back.
8724	*
8725	* @param pfNeedsSaveSettings Optional pointer to a bool that must have been initialized to false and that will be set to true
8726	* by this function if the caller should invoke VirtualBox::saveSettings() because the global settings have changed.
8727	*
8728	* @note Locks this object for writing.
8729	*/
8730	HRESULT Machine::deleteImplicitDiffs(bool *pfNeedsSaveSettings)
8731	{
8732	AutoCaller autoCaller(this);
8733	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
8734
8735	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
8736	LogFlowThisFuncEnter();
8737
8738	AssertReturn(mMediaData.isBackedUp(), E_FAIL);
8739
8740	HRESULT rc = S_OK;
8741
8742	MediaData::AttachmentList implicitAtts;
8743
8744	const MediaData::AttachmentList &oldAtts = mMediaData.backedUpData()->mAttachments;
8745
8746	/* enumerate new attachments */
8747	for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
8748	it != mMediaData->mAttachments.end();
8749	++it)
8750	{
8751	ComObjPtr<Medium> hd = (*it)->getMedium();
8752	if (hd.isNull())
8753	continue;
8754
8755	if ((*it)->isImplicit())
8756	{
8757	/* deassociate and mark for deletion */
8758	LogFlowThisFunc(("Detaching '%s', pending deletion\n", (*it)->getLogName()));
8759	rc = hd->removeBackReference(mData->mUuid);
8760	AssertComRC(rc);
8761	implicitAtts.push_back(*it);
8762	continue;
8763	}
8764
8765	/* was this hard disk attached before? */
8766	if (!findAttachment(oldAtts, hd))
8767	{
8768	/* no: de-associate */
8769	LogFlowThisFunc(("Detaching '%s', no deletion\n", (*it)->getLogName()));
8770	rc = hd->removeBackReference(mData->mUuid);
8771	AssertComRC(rc);
8772	continue;
8773	}
8774	LogFlowThisFunc(("Not detaching '%s'\n", (*it)->getLogName()));
8775	}
8776
8777	/* rollback hard disk changes */
8778	mMediaData.rollback();
8779
8780	MultiResult mrc(S_OK);
8781
8782	/* delete unused implicit diffs */
8783	if (implicitAtts.size() != 0)
8784	{
8785	/* will leave the lock before the potentially lengthy
8786	* operation, so protect with the special state (unless already
8787	* protected) */
8788	MachineState_T oldState = mData->mMachineState;
8789	if ( oldState != MachineState_Saving
8790	&& oldState != MachineState_LiveSnapshotting
8791	&& oldState != MachineState_RestoringSnapshot
8792	&& oldState != MachineState_DeletingSnapshot
8793	&& oldState != MachineState_DeletingSnapshotOnline
8794	&& oldState != MachineState_DeletingSnapshotPaused
8795	)
8796	setMachineState(MachineState_SettingUp);
8797
8798	alock.leave();
8799
8800	for (MediaData::AttachmentList::const_iterator it = implicitAtts.begin();
8801	it != implicitAtts.end();
8802	++it)
8803	{
8804	LogFlowThisFunc(("Deleting '%s'\n", (*it)->getLogName()));
8805	ComObjPtr<Medium> hd = (*it)->getMedium();
8806
8807	rc = hd->deleteStorage(NULL /aProgress/, true /aWait/,
8808	pfNeedsSaveSettings);
8809	AssertMsg(SUCCEEDED(rc), ("rc=%Rhrc it=%s hd=%s\n", rc, (*it)->getLogName(), hd->getLocationFull().c_str() ));
8810	mrc = rc;
8811	}
8812
8813	alock.enter();
8814
8815	if (mData->mMachineState == MachineState_SettingUp)
8816	{
8817	setMachineState(oldState);
8818	}
8819	}
8820
8821	return mrc;
8822	}
8823
8824	/**
8825	* Looks through the given list of media attachments for one with the given parameters
8826	* and returns it, or NULL if not found. The list is a parameter so that backup lists
8827	* can be searched as well if needed.
8828	*
8829	* @param list
8830	* @param aControllerName
8831	* @param aControllerPort
8832	* @param aDevice
8833	* @return
8834	*/
8835	MediumAttachment* Machine::findAttachment(const MediaData::AttachmentList &ll,
8836	IN_BSTR aControllerName,
8837	LONG aControllerPort,
8838	LONG aDevice)
8839	{
8840	for (MediaData::AttachmentList::const_iterator it = ll.begin();
8841	it != ll.end();
8842	++it)
8843	{
8844	MediumAttachment pAttach = it;
8845	if (pAttach->matches(aControllerName, aControllerPort, aDevice))
8846	return pAttach;
8847	}
8848
8849	return NULL;
8850	}
8851
8852	/**
8853	* Looks through the given list of media attachments for one with the given parameters
8854	* and returns it, or NULL if not found. The list is a parameter so that backup lists
8855	* can be searched as well if needed.
8856	*
8857	* @param list
8858	* @param aControllerName
8859	* @param aControllerPort
8860	* @param aDevice
8861	* @return
8862	*/
8863	MediumAttachment* Machine::findAttachment(const MediaData::AttachmentList &ll,
8864	ComObjPtr<Medium> pMedium)
8865	{
8866	for (MediaData::AttachmentList::const_iterator it = ll.begin();
8867	it != ll.end();
8868	++it)
8869	{
8870	MediumAttachment pAttach = it;
8871	ComObjPtr<Medium> pMediumThis = pAttach->getMedium();
8872	if (pMediumThis == pMedium)
8873	return pAttach;
8874	}
8875
8876	return NULL;
8877	}
8878
8879	/**
8880	* Looks through the given list of media attachments for one with the given parameters
8881	* and returns it, or NULL if not found. The list is a parameter so that backup lists
8882	* can be searched as well if needed.
8883	*
8884	* @param list
8885	* @param aControllerName
8886	* @param aControllerPort
8887	* @param aDevice
8888	* @return
8889	*/
8890	MediumAttachment* Machine::findAttachment(const MediaData::AttachmentList &ll,
8891	Guid &id)
8892	{
8893	for (MediaData::AttachmentList::const_iterator it = ll.begin();
8894	it != ll.end();
8895	++it)
8896	{
8897	MediumAttachment pAttach = it;
8898	ComObjPtr<Medium> pMediumThis = pAttach->getMedium();
8899	if (pMediumThis->getId() == id)
8900	return pAttach;
8901	}
8902
8903	return NULL;
8904	}
8905
8906	/**
8907	* Main implementation for Machine::DetachDevice. This also gets called
8908	* from Machine::prepareUnregister() so it has been taken out for simplicity.
8909	*
8910	* @param pAttach Medium attachment to detach.
8911	* @param writeLock Machine write lock which the caller must have locked once. This may be released temporarily in here.
8912	* @param pSnapshot If NULL, then the detachment is for the current machine. Otherwise this is for a SnapshotMachine, and this must be its snapshot.
8913	* @param pfNeedsSaveSettings Optional pointer to a bool that must have been initialized to false and that will be set to true
8914	* by this function if the caller should invoke VirtualBox::saveSettings() because the global settings have changed.
8915	* @return
8916	*/
8917	HRESULT Machine::detachDevice(MediumAttachment *pAttach,
8918	AutoWriteLock &writeLock,
8919	Snapshot *pSnapshot,
8920	bool *pfNeedsSaveSettings)
8921	{
8922	ComObjPtr<Medium> oldmedium = pAttach->getMedium();
8923	DeviceType_T mediumType = pAttach->getType();
8924
8925	LogFlowThisFunc(("Entering, medium of attachment is %s\n", oldmedium ? oldmedium->getLocationFull().c_str() : "NULL"));
8926
8927	if (pAttach->isImplicit())
8928	{
8929	/* attempt to implicitly delete the implicitly created diff */
8930
8931	/// @todo move the implicit flag from MediumAttachment to Medium
8932	/// and forbid any hard disk operation when it is implicit. Or maybe
8933	/// a special media state for it to make it even more simple.
8934
8935	Assert(mMediaData.isBackedUp());
8936
8937	/* will leave the lock before the potentially lengthy operation, so
8938	* protect with the special state */
8939	MachineState_T oldState = mData->mMachineState;
8940	setMachineState(MachineState_SettingUp);
8941
8942	writeLock.release();
8943
8944	HRESULT rc = oldmedium->deleteStorage(NULL /aProgress/, true /aWait/,
8945	pfNeedsSaveSettings);
8946
8947	writeLock.acquire();
8948
8949	setMachineState(oldState);
8950
8951	if (FAILED(rc)) return rc;
8952	}
8953
8954	setModified(IsModified_Storage);
8955	mMediaData.backup();
8956
8957	// we cannot use erase (it) below because backup() above will create
8958	// a copy of the list and make this copy active, but the iterator
8959	// still refers to the original and is not valid for the copy
8960	mMediaData->mAttachments.remove(pAttach);
8961
8962	if (!oldmedium.isNull())
8963	{
8964	// if this is from a snapshot, do not defer detachment to commitMedia()
8965	if (pSnapshot)
8966	oldmedium->removeBackReference(mData->mUuid, pSnapshot->getId());
8967	// else if non-hard disk media, do not defer detachment to commitMedia() either
8968	else if (mediumType != DeviceType_HardDisk)
8969	oldmedium->removeBackReference(mData->mUuid);
8970	}
8971
8972	return S_OK;
8973	}
8974
8975	/**
8976	* Goes thru all medium attachments of the list and calls detachDevice() on each
8977	* of them and attaches all Medium objects found in the process to the given list,
8978	* depending on cleanupMode.
8979	*
8980	* This gets called from Machine::Unregister, both for the actual Machine and
8981	* the SnapshotMachine objects that might be found in the snapshots.
8982	*
8983	* Requires caller and locking.
8984	*
8985	* @param writeLock Machine lock from top-level caller; this gets passed to detachDevice.
8986	* @param pSnapshot Must be NULL when called for a "real" Machine or a snapshot object if called for a SnapshotMachine.
8987	* @param cleanupMode If DetachAllReturnHardDisksOnly, only hard disk media get added to llMedia; if Full, then all media get added;
8988	* otherwise no media get added.
8989	* @param llMedia Caller's list to receive Medium objects which got detached so caller can close() them, depending on cleanupMode.
8990	* @return
8991	*/
8992	HRESULT Machine::detachAllMedia(AutoWriteLock &writeLock,
8993	Snapshot *pSnapshot,
8994	CleanupMode_T cleanupMode,
8995	MediaList &llMedia)
8996	{
8997	Assert(isWriteLockOnCurrentThread());
8998
8999	HRESULT rc;
9000
9001	// make a temporary list because detachDevice invalidates iterators into
9002	// mMediaData->mAttachments
9003	MediaData::AttachmentList llAttachments2 = mMediaData->mAttachments;
9004
9005	for (MediaData::AttachmentList::iterator it = llAttachments2.begin();
9006	it != llAttachments2.end();
9007	++it)
9008	{
9009	ComObjPtr<MediumAttachment> pAttach = *it;
9010	ComObjPtr<Medium> pMedium = pAttach->getMedium();
9011
9012	if (!pMedium.isNull())
9013	{
9014	DeviceType_T devType = pMedium->getDeviceType();
9015	if ( ( cleanupMode == CleanupMode_DetachAllReturnHardDisksOnly
9016	&& devType == DeviceType_HardDisk)
9017	\|\| (cleanupMode == CleanupMode_Full)
9018	)
9019	llMedia.push_back(pMedium);
9020	}
9021
9022	// real machine: then we need to use the proper method
9023	rc = detachDevice(pAttach,
9024	writeLock,
9025	pSnapshot,
9026	NULL /* pfNeedsSaveSettings */);
9027
9028	if (FAILED(rc))
9029	return rc;
9030	}
9031
9032	return S_OK;
9033	}
9034
9035	/**
9036	* Perform deferred hard disk detachments.
9037	*
9038	* Does nothing if the hard disk attachment data (mMediaData) is not changed (not
9039	* backed up).
9040	*
9041	* If @a aOnline is @c true then this method will also unlock the old hard disks
9042	* for which the new implicit diffs were created and will lock these new diffs for
9043	* writing.
9044	*
9045	* @param aOnline Whether the VM was online prior to this operation.
9046	*
9047	* @note Locks this object for writing!
9048	*/
9049	void Machine::commitMedia(bool aOnline /= false/)
9050	{
9051	AutoCaller autoCaller(this);
9052	AssertComRCReturnVoid(autoCaller.rc());
9053
9054	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
9055
9056	LogFlowThisFunc(("Entering, aOnline=%d\n", aOnline));
9057
9058	HRESULT rc = S_OK;
9059
9060	/* no attach/detach operations -- nothing to do */
9061	if (!mMediaData.isBackedUp())
9062	return;
9063
9064	MediaData::AttachmentList &oldAtts = mMediaData.backedUpData()->mAttachments;
9065	bool fMediaNeedsLocking = false;
9066
9067	/* enumerate new attachments */
9068	for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
9069	it != mMediaData->mAttachments.end();
9070	++it)
9071	{
9072	MediumAttachment pAttach = it;
9073
9074	pAttach->commit();
9075
9076	Medium* pMedium = pAttach->getMedium();
9077	bool fImplicit = pAttach->isImplicit();
9078
9079	LogFlowThisFunc(("Examining current medium '%s' (implicit: %d)\n",
9080	(pMedium) ? pMedium->getName().c_str() : "NULL",
9081	fImplicit));
9082
9083	/** @todo convert all this Machine-based voodoo to MediumAttachment
9084	* based commit logic. */
9085	if (fImplicit)
9086	{
9087	/* convert implicit attachment to normal */
9088	pAttach->setImplicit(false);
9089
9090	if ( aOnline
9091	&& pMedium
9092	&& pAttach->getType() == DeviceType_HardDisk
9093	)
9094	{
9095	ComObjPtr<Medium> parent = pMedium->getParent();
9096	AutoWriteLock parentLock(parent COMMA_LOCKVAL_SRC_POS);
9097
9098	/* update the appropriate lock list */
9099	MediumLockList *pMediumLockList;
9100	rc = mData->mSession.mLockedMedia.Get(pAttach, pMediumLockList);
9101	AssertComRC(rc);
9102	if (pMediumLockList)
9103	{
9104	/* unlock if there's a need to change the locking */
9105	if (!fMediaNeedsLocking)
9106	{
9107	rc = mData->mSession.mLockedMedia.Unlock();
9108	AssertComRC(rc);
9109	fMediaNeedsLocking = true;
9110	}
9111	rc = pMediumLockList->Update(parent, false);
9112	AssertComRC(rc);
9113	rc = pMediumLockList->Append(pMedium, true);
9114	AssertComRC(rc);
9115	}
9116	}
9117
9118	continue;
9119	}
9120
9121	if (pMedium)
9122	{
9123	/* was this medium attached before? */
9124	for (MediaData::AttachmentList::iterator oldIt = oldAtts.begin();
9125	oldIt != oldAtts.end();
9126	++oldIt)
9127	{
9128	MediumAttachment pOldAttach = oldIt;
9129	if (pOldAttach->getMedium() == pMedium)
9130	{
9131	LogFlowThisFunc(("--> medium '%s' was attached before, will not remove\n", pMedium->getName().c_str()));
9132
9133	/* yes: remove from old to avoid de-association */
9134	oldAtts.erase(oldIt);
9135	break;
9136	}
9137	}
9138	}
9139	}
9140
9141	/* enumerate remaining old attachments and de-associate from the
9142	* current machine state */
9143	for (MediaData::AttachmentList::const_iterator it = oldAtts.begin();
9144	it != oldAtts.end();
9145	++it)
9146	{
9147	MediumAttachment pAttach = it;
9148	Medium* pMedium = pAttach->getMedium();
9149
9150	/* Detach only hard disks, since DVD/floppy media is detached
9151	* instantly in MountMedium. */
9152	if (pAttach->getType() == DeviceType_HardDisk && pMedium)
9153	{
9154	LogFlowThisFunc(("detaching medium '%s' from machine\n", pMedium->getName().c_str()));
9155
9156	/* now de-associate from the current machine state */
9157	rc = pMedium->removeBackReference(mData->mUuid);
9158	AssertComRC(rc);
9159
9160	if (aOnline)
9161	{
9162	/* unlock since medium is not used anymore */
9163	MediumLockList *pMediumLockList;
9164	rc = mData->mSession.mLockedMedia.Get(pAttach, pMediumLockList);
9165	AssertComRC(rc);
9166	if (pMediumLockList)
9167	{
9168	rc = mData->mSession.mLockedMedia.Remove(pAttach);
9169	AssertComRC(rc);
9170	}
9171	}
9172	}
9173	}
9174
9175	/* take media locks again so that the locking state is consistent */
9176	if (fMediaNeedsLocking)
9177	{
9178	Assert(aOnline);
9179	rc = mData->mSession.mLockedMedia.Lock();
9180	AssertComRC(rc);
9181	}
9182
9183	/* commit the hard disk changes */
9184	mMediaData.commit();
9185
9186	if (isSessionMachine())
9187	{
9188	/* attach new data to the primary machine and reshare it */
9189	mPeer->mMediaData.attach(mMediaData);
9190	}
9191
9192	return;
9193	}
9194
9195	/**
9196	* Perform deferred deletion of implicitly created diffs.
9197	*
9198	* Does nothing if the hard disk attachment data (mMediaData) is not changed (not
9199	* backed up).
9200	*
9201	* @param pfNeedsSaveSettings Optional pointer to a bool that must have been initialized to false and that will be set to true
9202	* by this function if the caller should invoke VirtualBox::saveSettings() because the global settings have changed.
9203	*
9204	* @note Locks this object for writing!
9205	*/
9206	void Machine::rollbackMedia()
9207	{
9208	AutoCaller autoCaller(this);
9209	AssertComRCReturnVoid (autoCaller.rc());
9210
9211	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
9212
9213	LogFlowThisFunc(("Entering\n"));
9214
9215	HRESULT rc = S_OK;
9216
9217	/* no attach/detach operations -- nothing to do */
9218	if (!mMediaData.isBackedUp())
9219	return;
9220
9221	/* enumerate new attachments */
9222	for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
9223	it != mMediaData->mAttachments.end();
9224	++it)
9225	{
9226	MediumAttachment pAttach = it;
9227	/* Fix up the backrefs for DVD/floppy media. */
9228	if (pAttach->getType() != DeviceType_HardDisk)
9229	{
9230	Medium* pMedium = pAttach->getMedium();
9231	if (pMedium)
9232	{
9233	rc = pMedium->removeBackReference(mData->mUuid);
9234	AssertComRC(rc);
9235	}
9236	}
9237
9238	(*it)->rollback();
9239
9240	pAttach = *it;
9241	/* Fix up the backrefs for DVD/floppy media. */
9242	if (pAttach->getType() != DeviceType_HardDisk)
9243	{
9244	Medium* pMedium = pAttach->getMedium();
9245	if (pMedium)
9246	{
9247	rc = pMedium->addBackReference(mData->mUuid);
9248	AssertComRC(rc);
9249	}
9250	}
9251	}
9252
9253	/** @todo convert all this Machine-based voodoo to MediumAttachment
9254	* based rollback logic. */
9255	// @todo r=dj the below totally fails if this gets called from Machine::rollback(),
9256	// which gets called if Machine::registeredInit() fails...
9257	deleteImplicitDiffs(NULL /pfNeedsSaveSettings/);
9258
9259	return;
9260	}
9261
9262	/**
9263	* Returns true if the settings file is located in the directory named exactly
9264	* as the machine. This will be true if the machine settings structure was
9265	* created by default in #openConfigLoader().
9266	*
9267	* @param aSettingsDir if not NULL, the full machine settings file directory
9268	* name will be assigned there.
9269	*
9270	* @note Doesn't lock anything.
9271	* @note Not thread safe (must be called from this object's lock).
9272	*/
9273	bool Machine::isInOwnDir(Utf8Str aSettingsDir / = NULL */) const
9274	{
9275	Utf8Str settingsDir = mData->m_strConfigFileFull;
9276	settingsDir.stripFilename();
9277	Utf8Str strDirName = RTPathFilename(settingsDir.c_str());
9278
9279	AssertReturn(!strDirName.isEmpty(), false);
9280
9281	/* if we don't rename anything on name change, return false shorlty */
9282	if (!mUserData->s.fNameSync)
9283	return false;
9284
9285	if (aSettingsDir)
9286	*aSettingsDir = settingsDir;
9287
9288	return strDirName == mUserData->s.strName;
9289	}
9290
9291	/**
9292	* Discards all changes to machine settings.
9293	*
9294	* @param aNotify Whether to notify the direct session about changes or not.
9295	*
9296	* @note Locks objects for writing!
9297	*/
9298	void Machine::rollback(bool aNotify)
9299	{
9300	AutoCaller autoCaller(this);
9301	AssertComRCReturn(autoCaller.rc(), (void)0);
9302
9303	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
9304
9305	if (!mStorageControllers.isNull())
9306	{
9307	if (mStorageControllers.isBackedUp())
9308	{
9309	/* unitialize all new devices (absent in the backed up list). */
9310	StorageControllerList::const_iterator it = mStorageControllers->begin();
9311	StorageControllerList *backedList = mStorageControllers.backedUpData();
9312	while (it != mStorageControllers->end())
9313	{
9314	if ( std::find(backedList->begin(), backedList->end(), *it)
9315	== backedList->end()
9316	)
9317	{
9318	(*it)->uninit();
9319	}
9320	++it;
9321	}
9322
9323	/* restore the list */
9324	mStorageControllers.rollback();
9325	}
9326
9327	/* rollback any changes to devices after restoring the list */
9328	if (mData->flModifications & IsModified_Storage)
9329	{
9330	StorageControllerList::const_iterator it = mStorageControllers->begin();
9331	while (it != mStorageControllers->end())
9332	{
9333	(*it)->rollback();
9334	++it;
9335	}
9336	}
9337	}
9338
9339	mUserData.rollback();
9340
9341	mHWData.rollback();
9342
9343	if (mData->flModifications & IsModified_Storage)
9344	rollbackMedia();
9345
9346	if (mBIOSSettings)
9347	mBIOSSettings->rollback();
9348
9349	#ifdef VBOX_WITH_VRDP
9350	if (mVRDPServer && (mData->flModifications & IsModified_VRDPServer))
9351	mVRDPServer->rollback();
9352	#endif
9353
9354	if (mAudioAdapter)
9355	mAudioAdapter->rollback();
9356
9357	if (mUSBController && (mData->flModifications & IsModified_USB))
9358	mUSBController->rollback();
9359
9360	ComPtr<INetworkAdapter> networkAdapters[RT_ELEMENTS(mNetworkAdapters)];
9361	ComPtr<ISerialPort> serialPorts[RT_ELEMENTS(mSerialPorts)];
9362	ComPtr<IParallelPort> parallelPorts[RT_ELEMENTS(mParallelPorts)];
9363
9364	if (mData->flModifications & IsModified_NetworkAdapters)
9365	for (ULONG slot = 0; slot < RT_ELEMENTS(mNetworkAdapters); slot++)
9366	if ( mNetworkAdapters[slot]
9367	&& mNetworkAdapters[slot]->isModified())
9368	{
9369	mNetworkAdapters[slot]->rollback();
9370	networkAdapters[slot] = mNetworkAdapters[slot];
9371	}
9372
9373	if (mData->flModifications & IsModified_SerialPorts)
9374	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); slot++)
9375	if ( mSerialPorts[slot]
9376	&& mSerialPorts[slot]->isModified())
9377	{
9378	mSerialPorts[slot]->rollback();
9379	serialPorts[slot] = mSerialPorts[slot];
9380	}
9381
9382	if (mData->flModifications & IsModified_ParallelPorts)
9383	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); slot++)
9384	if ( mParallelPorts[slot]
9385	&& mParallelPorts[slot]->isModified())
9386	{
9387	mParallelPorts[slot]->rollback();
9388	parallelPorts[slot] = mParallelPorts[slot];
9389	}
9390
9391	if (aNotify)
9392	{
9393	/* inform the direct session about changes */
9394
9395	ComObjPtr<Machine> that = this;
9396	uint32_t flModifications = mData->flModifications;
9397	alock.leave();
9398
9399	if (flModifications & IsModified_SharedFolders)
9400	that->onSharedFolderChange();
9401
9402	if (flModifications & IsModified_VRDPServer)
9403	that->onVRDPServerChange(/* aRestart */ TRUE);
9404	if (flModifications & IsModified_USB)
9405	that->onUSBControllerChange();
9406
9407	for (ULONG slot = 0; slot < RT_ELEMENTS(networkAdapters); slot ++)
9408	if (networkAdapters[slot])
9409	that->onNetworkAdapterChange(networkAdapters[slot], FALSE);
9410	for (ULONG slot = 0; slot < RT_ELEMENTS(serialPorts); slot ++)
9411	if (serialPorts[slot])
9412	that->onSerialPortChange(serialPorts[slot]);
9413	for (ULONG slot = 0; slot < RT_ELEMENTS(parallelPorts); slot ++)
9414	if (parallelPorts[slot])
9415	that->onParallelPortChange(parallelPorts[slot]);
9416
9417	if (flModifications & IsModified_Storage)
9418	that->onStorageControllerChange();
9419	}
9420	}
9421
9422	/**
9423	* Commits all the changes to machine settings.
9424	*
9425	* Note that this operation is supposed to never fail.
9426	*
9427	* @note Locks this object and children for writing.
9428	*/
9429	void Machine::commit()
9430	{
9431	AutoCaller autoCaller(this);
9432	AssertComRCReturnVoid(autoCaller.rc());
9433
9434	AutoCaller peerCaller(mPeer);
9435	AssertComRCReturnVoid(peerCaller.rc());
9436
9437	AutoMultiWriteLock2 alock(mPeer, this COMMA_LOCKVAL_SRC_POS);
9438
9439	/*
9440	* use safe commit to ensure Snapshot machines (that share mUserData)
9441	* will still refer to a valid memory location
9442	*/
9443	mUserData.commitCopy();
9444
9445	mHWData.commit();
9446
9447	if (mMediaData.isBackedUp())
9448	commitMedia();
9449
9450	mBIOSSettings->commit();
9451	#ifdef VBOX_WITH_VRDP
9452	mVRDPServer->commit();
9453	#endif
9454	mAudioAdapter->commit();
9455	mUSBController->commit();
9456
9457	for (ULONG slot = 0; slot < RT_ELEMENTS(mNetworkAdapters); slot++)
9458	mNetworkAdapters[slot]->commit();
9459	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); slot++)
9460	mSerialPorts[slot]->commit();
9461	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); slot++)
9462	mParallelPorts[slot]->commit();
9463
9464	bool commitStorageControllers = false;
9465
9466	if (mStorageControllers.isBackedUp())
9467	{
9468	mStorageControllers.commit();
9469
9470	if (mPeer)
9471	{
9472	AutoWriteLock peerlock(mPeer COMMA_LOCKVAL_SRC_POS);
9473
9474	/* Commit all changes to new controllers (this will reshare data with
9475	* peers for thos who have peers) */
9476	StorageControllerList *newList = new StorageControllerList();
9477	StorageControllerList::const_iterator it = mStorageControllers->begin();
9478	while (it != mStorageControllers->end())
9479	{
9480	(*it)->commit();
9481
9482	/* look if this controller has a peer device */
9483	ComObjPtr<StorageController> peer = (*it)->getPeer();
9484	if (!peer)
9485	{
9486	/* no peer means the device is a newly created one;
9487	* create a peer owning data this device share it with */
9488	peer.createObject();
9489	peer->init(mPeer, it, true / aReshare */);
9490	}
9491	else
9492	{
9493	/* remove peer from the old list */
9494	mPeer->mStorageControllers->remove(peer);
9495	}
9496	/* and add it to the new list */
9497	newList->push_back(peer);
9498
9499	++it;
9500	}
9501
9502	/* uninit old peer's controllers that are left */
9503	it = mPeer->mStorageControllers->begin();
9504	while (it != mPeer->mStorageControllers->end())
9505	{
9506	(*it)->uninit();
9507	++it;
9508	}
9509
9510	/* attach new list of controllers to our peer */
9511	mPeer->mStorageControllers.attach(newList);
9512	}
9513	else
9514	{
9515	/* we have no peer (our parent is the newly created machine);
9516	* just commit changes to devices */
9517	commitStorageControllers = true;
9518	}
9519	}
9520	else
9521	{
9522	/* the list of controllers itself is not changed,
9523	* just commit changes to controllers themselves */
9524	commitStorageControllers = true;
9525	}
9526
9527	if (commitStorageControllers)
9528	{
9529	StorageControllerList::const_iterator it = mStorageControllers->begin();
9530	while (it != mStorageControllers->end())
9531	{
9532	(*it)->commit();
9533	++it;
9534	}
9535	}
9536
9537	if (isSessionMachine())
9538	{
9539	/* attach new data to the primary machine and reshare it */
9540	mPeer->mUserData.attach(mUserData);
9541	mPeer->mHWData.attach(mHWData);
9542	/* mMediaData is reshared by fixupMedia */
9543	// mPeer->mMediaData.attach(mMediaData);
9544	Assert(mPeer->mMediaData.data() == mMediaData.data());
9545	}
9546	}
9547
9548	/**
9549	* Copies all the hardware data from the given machine.
9550	*
9551	* Currently, only called when the VM is being restored from a snapshot. In
9552	* particular, this implies that the VM is not running during this method's
9553	* call.
9554	*
9555	* @note This method must be called from under this object's lock.
9556	*
9557	* @note This method doesn't call #commit(), so all data remains backed up and
9558	* unsaved.
9559	*/
9560	void Machine::copyFrom(Machine *aThat)
9561	{
9562	AssertReturnVoid(!isSnapshotMachine());
9563	AssertReturnVoid(aThat->isSnapshotMachine());
9564
9565	AssertReturnVoid(!Global::IsOnline(mData->mMachineState));
9566
9567	mHWData.assignCopy(aThat->mHWData);
9568
9569	// create copies of all shared folders (mHWData after attiching a copy
9570	// contains just references to original objects)
9571	for (HWData::SharedFolderList::iterator it = mHWData->mSharedFolders.begin();
9572	it != mHWData->mSharedFolders.end();
9573	++it)
9574	{
9575	ComObjPtr<SharedFolder> folder;
9576	folder.createObject();
9577	HRESULT rc = folder->initCopy(getMachine(), *it);
9578	AssertComRC(rc);
9579	*it = folder;
9580	}
9581
9582	mBIOSSettings->copyFrom(aThat->mBIOSSettings);
9583	#ifdef VBOX_WITH_VRDP
9584	mVRDPServer->copyFrom(aThat->mVRDPServer);
9585	#endif
9586	mAudioAdapter->copyFrom(aThat->mAudioAdapter);
9587	mUSBController->copyFrom(aThat->mUSBController);
9588
9589	/* create private copies of all controllers */
9590	mStorageControllers.backup();
9591	mStorageControllers->clear();
9592	for (StorageControllerList::iterator it = aThat->mStorageControllers->begin();
9593	it != aThat->mStorageControllers->end();
9594	++it)
9595	{
9596	ComObjPtr<StorageController> ctrl;
9597	ctrl.createObject();
9598	ctrl->initCopy(this, *it);
9599	mStorageControllers->push_back(ctrl);
9600	}
9601
9602	for (ULONG slot = 0; slot < RT_ELEMENTS(mNetworkAdapters); slot++)
9603	mNetworkAdapters[slot]->copyFrom(aThat->mNetworkAdapters[slot]);
9604	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); slot++)
9605	mSerialPorts[slot]->copyFrom(aThat->mSerialPorts[slot]);
9606	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); slot++)
9607	mParallelPorts[slot]->copyFrom(aThat->mParallelPorts[slot]);
9608	}
9609
9610	#ifdef VBOX_WITH_RESOURCE_USAGE_API
9611
9612	void Machine::registerMetrics(PerformanceCollector aCollector, Machine aMachine, RTPROCESS pid)
9613	{
9614	AssertReturnVoid(isWriteLockOnCurrentThread());
9615	AssertPtrReturnVoid(aCollector);
9616
9617	pm::CollectorHAL *hal = aCollector->getHAL();
9618	/* Create sub metrics */
9619	pm::SubMetric *cpuLoadUser = new pm::SubMetric("CPU/Load/User",
9620	"Percentage of processor time spent in user mode by the VM process.");
9621	pm::SubMetric *cpuLoadKernel = new pm::SubMetric("CPU/Load/Kernel",
9622	"Percentage of processor time spent in kernel mode by the VM process.");
9623	pm::SubMetric *ramUsageUsed = new pm::SubMetric("RAM/Usage/Used",
9624	"Size of resident portion of VM process in memory.");
9625	/* Create and register base metrics */
9626	pm::BaseMetric *cpuLoad = new pm::MachineCpuLoadRaw(hal, aMachine, pid,
9627	cpuLoadUser, cpuLoadKernel);
9628	aCollector->registerBaseMetric(cpuLoad);
9629	pm::BaseMetric *ramUsage = new pm::MachineRamUsage(hal, aMachine, pid,
9630	ramUsageUsed);
9631	aCollector->registerBaseMetric(ramUsage);
9632
9633	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser, 0));
9634	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
9635	new pm::AggregateAvg()));
9636	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
9637	new pm::AggregateMin()));
9638	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
9639	new pm::AggregateMax()));
9640	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel, 0));
9641	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
9642	new pm::AggregateAvg()));
9643	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
9644	new pm::AggregateMin()));
9645	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
9646	new pm::AggregateMax()));
9647
9648	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed, 0));
9649	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
9650	new pm::AggregateAvg()));
9651	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
9652	new pm::AggregateMin()));
9653	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
9654	new pm::AggregateMax()));
9655
9656
9657	/* Guest metrics */
9658	mGuestHAL = new pm::CollectorGuestHAL(this, hal);
9659
9660	/* Create sub metrics */
9661	pm::SubMetric *guestLoadUser = new pm::SubMetric("Guest/CPU/Load/User",
9662	"Percentage of processor time spent in user mode as seen by the guest.");
9663	pm::SubMetric *guestLoadKernel = new pm::SubMetric("Guest/CPU/Load/Kernel",
9664	"Percentage of processor time spent in kernel mode as seen by the guest.");
9665	pm::SubMetric *guestLoadIdle = new pm::SubMetric("Guest/CPU/Load/Idle",
9666	"Percentage of processor time spent idling as seen by the guest.");
9667
9668	/* The total amount of physical ram is fixed now, but we'll support dynamic guest ram configurations in the future. */
9669	pm::SubMetric *guestMemTotal = new pm::SubMetric("Guest/RAM/Usage/Total", "Total amount of physical guest RAM.");
9670	pm::SubMetric *guestMemFree = new pm::SubMetric("Guest/RAM/Usage/Free", "Free amount of physical guest RAM.");
9671	pm::SubMetric *guestMemBalloon = new pm::SubMetric("Guest/RAM/Usage/Balloon", "Amount of ballooned physical guest RAM.");
9672	pm::SubMetric *guestMemShared = new pm::SubMetric("Guest/RAM/Usage/Shared", "Amount of shared physical guest RAM.");
9673	pm::SubMetric *guestMemCache = new pm::SubMetric("Guest/RAM/Usage/Cache", "Total amount of guest (disk) cache memory.");
9674
9675	pm::SubMetric *guestPagedTotal = new pm::SubMetric("Guest/Pagefile/Usage/Total", "Total amount of space in the page file.");
9676
9677	/* Create and register base metrics */
9678	pm::BaseMetric *guestCpuLoad = new pm::GuestCpuLoad(mGuestHAL, aMachine, guestLoadUser, guestLoadKernel, guestLoadIdle);
9679	aCollector->registerBaseMetric(guestCpuLoad);
9680
9681	pm::BaseMetric *guestCpuMem = new pm::GuestRamUsage(mGuestHAL, aMachine, guestMemTotal, guestMemFree, guestMemBalloon, guestMemShared,
9682	guestMemCache, guestPagedTotal);
9683	aCollector->registerBaseMetric(guestCpuMem);
9684
9685	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadUser, 0));
9686	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadUser, new pm::AggregateAvg()));
9687	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadUser, new pm::AggregateMin()));
9688	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadUser, new pm::AggregateMax()));
9689
9690	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadKernel, 0));
9691	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadKernel, new pm::AggregateAvg()));
9692	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadKernel, new pm::AggregateMin()));
9693	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadKernel, new pm::AggregateMax()));
9694
9695	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadIdle, 0));
9696	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadIdle, new pm::AggregateAvg()));
9697	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadIdle, new pm::AggregateMin()));
9698	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadIdle, new pm::AggregateMax()));
9699
9700	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemTotal, 0));
9701	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemTotal, new pm::AggregateAvg()));
9702	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemTotal, new pm::AggregateMin()));
9703	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemTotal, new pm::AggregateMax()));
9704
9705	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemFree, 0));
9706	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemFree, new pm::AggregateAvg()));
9707	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemFree, new pm::AggregateMin()));
9708	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemFree, new pm::AggregateMax()));
9709
9710	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemBalloon, 0));
9711	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemBalloon, new pm::AggregateAvg()));
9712	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemBalloon, new pm::AggregateMin()));
9713	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemBalloon, new pm::AggregateMax()));
9714
9715	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemShared, 0));
9716	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemShared, new pm::AggregateAvg()));
9717	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemShared, new pm::AggregateMin()));
9718	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemShared, new pm::AggregateMax()));
9719
9720	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemCache, 0));
9721	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemCache, new pm::AggregateAvg()));
9722	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemCache, new pm::AggregateMin()));
9723	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemCache, new pm::AggregateMax()));
9724
9725	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestPagedTotal, 0));
9726	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestPagedTotal, new pm::AggregateAvg()));
9727	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestPagedTotal, new pm::AggregateMin()));
9728	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestPagedTotal, new pm::AggregateMax()));
9729	}
9730
9731	void Machine::unregisterMetrics(PerformanceCollector aCollector, Machine aMachine)
9732	{
9733	AssertReturnVoid(isWriteLockOnCurrentThread());
9734
9735	if (aCollector)
9736	{
9737	aCollector->unregisterMetricsFor(aMachine);
9738	aCollector->unregisterBaseMetricsFor(aMachine);
9739	}
9740
9741	if (mGuestHAL)
9742	{
9743	delete mGuestHAL;
9744	mGuestHAL = NULL;
9745	}
9746	}
9747
9748	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
9749
9750
9751	////////////////////////////////////////////////////////////////////////////////
9752
9753	DEFINE_EMPTY_CTOR_DTOR(SessionMachine)
9754
9755	HRESULT SessionMachine::FinalConstruct()
9756	{
9757	LogFlowThisFunc(("\n"));
9758
9759	#if defined(RT_OS_WINDOWS)
9760	mIPCSem = NULL;
9761	#elif defined(RT_OS_OS2)
9762	mIPCSem = NULLHANDLE;
9763	#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
9764	mIPCSem = -1;
9765	#else
9766	# error "Port me!"
9767	#endif
9768
9769	return S_OK;
9770	}
9771
9772	void SessionMachine::FinalRelease()
9773	{
9774	LogFlowThisFunc(("\n"));
9775
9776	uninit(Uninit::Unexpected);
9777	}
9778
9779	/**
9780	* @note Must be called only by Machine::openSession() from its own write lock.
9781	*/
9782	HRESULT SessionMachine::init(Machine *aMachine)
9783	{
9784	LogFlowThisFuncEnter();
9785	LogFlowThisFunc(("mName={%s}\n", aMachine->mUserData->s.strName.c_str()));
9786
9787	AssertReturn(aMachine, E_INVALIDARG);
9788
9789	AssertReturn(aMachine->lockHandle()->isWriteLockOnCurrentThread(), E_FAIL);
9790
9791	/* Enclose the state transition NotReady->InInit->Ready */
9792	AutoInitSpan autoInitSpan(this);
9793	AssertReturn(autoInitSpan.isOk(), E_FAIL);
9794
9795	/* create the interprocess semaphore */
9796	#if defined(RT_OS_WINDOWS)
9797	mIPCSemName = aMachine->mData->m_strConfigFileFull;
9798	for (size_t i = 0; i < mIPCSemName.length(); i++)
9799	if (mIPCSemName.raw()[i] == '\\')
9800	mIPCSemName.raw()[i] = '/';
9801	mIPCSem = ::CreateMutex(NULL, FALSE, mIPCSemName.raw());
9802	ComAssertMsgRet(mIPCSem,
9803	("Cannot create IPC mutex '%ls', err=%d",
9804	mIPCSemName.raw(), ::GetLastError()),
9805	E_FAIL);
9806	#elif defined(RT_OS_OS2)
9807	Utf8Str ipcSem = Utf8StrFmt("\\SEM32\\VBOX\\VM\\{%RTuuid}",
9808	aMachine->mData->mUuid.raw());
9809	mIPCSemName = ipcSem;
9810	APIRET arc = ::DosCreateMutexSem((PSZ)ipcSem.raw(), &mIPCSem, 0, FALSE);
9811	ComAssertMsgRet(arc == NO_ERROR,
9812	("Cannot create IPC mutex '%s', arc=%ld",
9813	ipcSem.raw(), arc),
9814	E_FAIL);
9815	#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
9816	# ifdef VBOX_WITH_NEW_SYS_V_KEYGEN
9817	# if defined(RT_OS_FREEBSD) && (HC_ARCH_BITS == 64)
9818	/** @todo Check that this still works correctly. */
9819	AssertCompileSize(key_t, 8);
9820	# else
9821	AssertCompileSize(key_t, 4);
9822	# endif
9823	key_t key;
9824	mIPCSem = -1;
9825	mIPCKey = "0";
9826	for (uint32_t i = 0; i < 1 << 24; i++)
9827	{
9828	key = ((uint32_t)'V' << 24) \| i;
9829	int sem = ::semget(key, 1, S_IRUSR \| S_IWUSR \| IPC_CREAT \| IPC_EXCL);
9830	if (sem >= 0 \|\| (errno != EEXIST && errno != EACCES))
9831	{
9832	mIPCSem = sem;
9833	if (sem >= 0)
9834	mIPCKey = BstrFmt("%u", key);
9835	break;
9836	}
9837	}
9838	# else /* !VBOX_WITH_NEW_SYS_V_KEYGEN */
9839	Utf8Str semName = aMachine->mData->m_strConfigFileFull;
9840	char *pszSemName = NULL;
9841	RTStrUtf8ToCurrentCP(&pszSemName, semName);
9842	key_t key = ::ftok(pszSemName, 'V');
9843	RTStrFree(pszSemName);
9844
9845	mIPCSem = ::semget(key, 1, S_IRWXU \| S_IRWXG \| S_IRWXO \| IPC_CREAT);
9846	# endif /* !VBOX_WITH_NEW_SYS_V_KEYGEN */
9847
9848	int errnoSave = errno;
9849	if (mIPCSem < 0 && errnoSave == ENOSYS)
9850	{
9851	setError(E_FAIL,
9852	tr("Cannot create IPC semaphore. Most likely your host kernel lacks "
9853	"support for SysV IPC. Check the host kernel configuration for "
9854	"CONFIG_SYSVIPC=y"));
9855	return E_FAIL;
9856	}
9857	/* ENOSPC can also be the result of VBoxSVC crashes without properly freeing
9858	* the IPC semaphores */
9859	if (mIPCSem < 0 && errnoSave == ENOSPC)
9860	{
9861	#ifdef RT_OS_LINUX
9862	setError(E_FAIL,
9863	tr("Cannot create IPC semaphore because the system limit for the "
9864	"maximum number of semaphore sets (SEMMNI), or the system wide "
9865	"maximum number of sempahores (SEMMNS) would be exceeded. The "
9866	"current set of SysV IPC semaphores can be determined from "
9867	"the file /proc/sysvipc/sem"));
9868	#else
9869	setError(E_FAIL,
9870	tr("Cannot create IPC semaphore because the system-imposed limit "
9871	"on the maximum number of allowed semaphores or semaphore "
9872	"identifiers system-wide would be exceeded"));
9873	#endif
9874	return E_FAIL;
9875	}
9876	ComAssertMsgRet(mIPCSem >= 0, ("Cannot create IPC semaphore, errno=%d", errnoSave),
9877	E_FAIL);
9878	/* set the initial value to 1 */
9879	int rv = ::semctl(mIPCSem, 0, SETVAL, 1);
9880	ComAssertMsgRet(rv == 0, ("Cannot init IPC semaphore, errno=%d", errno),
9881	E_FAIL);
9882	#else
9883	# error "Port me!"
9884	#endif
9885
9886	/* memorize the peer Machine */
9887	unconst(mPeer) = aMachine;
9888	/* share the parent pointer */
9889	unconst(mParent) = aMachine->mParent;
9890
9891	/* take the pointers to data to share */
9892	mData.share(aMachine->mData);
9893	mSSData.share(aMachine->mSSData);
9894
9895	mUserData.share(aMachine->mUserData);
9896	mHWData.share(aMachine->mHWData);
9897	mMediaData.share(aMachine->mMediaData);
9898
9899	mStorageControllers.allocate();
9900	for (StorageControllerList::const_iterator it = aMachine->mStorageControllers->begin();
9901	it != aMachine->mStorageControllers->end();
9902	++it)
9903	{
9904	ComObjPtr<StorageController> ctl;
9905	ctl.createObject();
9906	ctl->init(this, *it);
9907	mStorageControllers->push_back(ctl);
9908	}
9909
9910	unconst(mBIOSSettings).createObject();
9911	mBIOSSettings->init(this, aMachine->mBIOSSettings);
9912	#ifdef VBOX_WITH_VRDP
9913	/* create another VRDPServer object that will be mutable */
9914	unconst(mVRDPServer).createObject();
9915	mVRDPServer->init(this, aMachine->mVRDPServer);
9916	#endif
9917	/* create another audio adapter object that will be mutable */
9918	unconst(mAudioAdapter).createObject();
9919	mAudioAdapter->init(this, aMachine->mAudioAdapter);
9920	/* create a list of serial ports that will be mutable */
9921	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); slot++)
9922	{
9923	unconst(mSerialPorts[slot]).createObject();
9924	mSerialPorts[slot]->init(this, aMachine->mSerialPorts[slot]);
9925	}
9926	/* create a list of parallel ports that will be mutable */
9927	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); slot++)
9928	{
9929	unconst(mParallelPorts[slot]).createObject();
9930	mParallelPorts[slot]->init(this, aMachine->mParallelPorts[slot]);
9931	}
9932	/* create another USB controller object that will be mutable */
9933	unconst(mUSBController).createObject();
9934	mUSBController->init(this, aMachine->mUSBController);
9935
9936	/* create a list of network adapters that will be mutable */
9937	for (ULONG slot = 0; slot < RT_ELEMENTS(mNetworkAdapters); slot++)
9938	{
9939	unconst(mNetworkAdapters[slot]).createObject();
9940	mNetworkAdapters[slot]->init(this, aMachine->mNetworkAdapters[slot]);
9941	}
9942
9943	/* default is to delete saved state on Saved -> PoweredOff transition */
9944	mRemoveSavedState = true;
9945
9946	/* Confirm a successful initialization when it's the case */
9947	autoInitSpan.setSucceeded();
9948
9949	LogFlowThisFuncLeave();
9950	return S_OK;
9951	}
9952
9953	/**
9954	* Uninitializes this session object. If the reason is other than
9955	* Uninit::Unexpected, then this method MUST be called from #checkForDeath().
9956	*
9957	* @param aReason uninitialization reason
9958	*
9959	* @note Locks mParent + this object for writing.
9960	*/
9961	void SessionMachine::uninit(Uninit::Reason aReason)
9962	{
9963	LogFlowThisFuncEnter();
9964	LogFlowThisFunc(("reason=%d\n", aReason));
9965
9966	/*
9967	* Strongly reference ourselves to prevent this object deletion after
9968	* mData->mSession.mMachine.setNull() below (which can release the last
9969	* reference and call the destructor). Important: this must be done before
9970	* accessing any members (and before AutoUninitSpan that does it as well).
9971	* This self reference will be released as the very last step on return.
9972	*/
9973	ComObjPtr<SessionMachine> selfRef = this;
9974
9975	/* Enclose the state transition Ready->InUninit->NotReady */
9976	AutoUninitSpan autoUninitSpan(this);
9977	if (autoUninitSpan.uninitDone())
9978	{
9979	LogFlowThisFunc(("Already uninitialized\n"));
9980	LogFlowThisFuncLeave();
9981	return;
9982	}
9983
9984	if (autoUninitSpan.initFailed())
9985	{
9986	/* We've been called by init() because it's failed. It's not really
9987	* necessary (nor it's safe) to perform the regular uninit sequense
9988	* below, the following is enough.
9989	*/
9990	LogFlowThisFunc(("Initialization failed.\n"));
9991	#if defined(RT_OS_WINDOWS)
9992	if (mIPCSem)
9993	::CloseHandle(mIPCSem);
9994	mIPCSem = NULL;
9995	#elif defined(RT_OS_OS2)
9996	if (mIPCSem != NULLHANDLE)
9997	::DosCloseMutexSem(mIPCSem);
9998	mIPCSem = NULLHANDLE;
9999	#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
10000	if (mIPCSem >= 0)
10001	::semctl(mIPCSem, 0, IPC_RMID);
10002	mIPCSem = -1;
10003	# ifdef VBOX_WITH_NEW_SYS_V_KEYGEN
10004	mIPCKey = "0";
10005	# endif /* VBOX_WITH_NEW_SYS_V_KEYGEN */
10006	#else
10007	# error "Port me!"
10008	#endif
10009	uninitDataAndChildObjects();
10010	mData.free();
10011	unconst(mParent) = NULL;
10012	unconst(mPeer) = NULL;
10013	LogFlowThisFuncLeave();
10014	return;
10015	}
10016
10017	MachineState_T lastState;
10018	{
10019	AutoReadLock tempLock(this COMMA_LOCKVAL_SRC_POS);
10020	lastState = mData->mMachineState;
10021	}
10022	NOREF(lastState);
10023
10024	#ifdef VBOX_WITH_USB
10025	// release all captured USB devices, but do this before requesting the locks below
10026	if (aReason == Uninit::Abnormal && Global::IsOnline(lastState))
10027	{
10028	/* Console::captureUSBDevices() is called in the VM process only after
10029	* setting the machine state to Starting or Restoring.
10030	* Console::detachAllUSBDevices() will be called upon successful
10031	* termination. So, we need to release USB devices only if there was
10032	* an abnormal termination of a running VM.
10033	*
10034	* This is identical to SessionMachine::DetachAllUSBDevices except
10035	* for the aAbnormal argument. */
10036	HRESULT rc = mUSBController->notifyProxy(false /* aInsertFilters */);
10037	AssertComRC(rc);
10038	NOREF(rc);
10039
10040	USBProxyService *service = mParent->host()->usbProxyService();
10041	if (service)
10042	service->detachAllDevicesFromVM(this, true /* aDone /, true / aAbnormal */);
10043	}
10044	#endif /* VBOX_WITH_USB */
10045
10046	// we need to lock this object in uninit() because the lock is shared
10047	// with mPeer (as well as data we modify below). mParent->addProcessToReap()
10048	// and others need mParent lock, and USB needs host lock.
10049	AutoMultiWriteLock3 multilock(mParent, mParent->host(), this COMMA_LOCKVAL_SRC_POS);
10050
10051	// Trigger async cleanup tasks, avoid doing things here which are not
10052	// vital to be done immediately and maybe need more locks. This calls
10053	// Machine::unregisterMetrics().
10054	mParent->onMachineUninit(mPeer);
10055
10056	if (aReason == Uninit::Abnormal)
10057	{
10058	LogWarningThisFunc(("ABNORMAL client termination! (wasBusy=%d)\n",
10059	Global::IsOnlineOrTransient(lastState)));
10060
10061	/* reset the state to Aborted */
10062	if (mData->mMachineState != MachineState_Aborted)
10063	setMachineState(MachineState_Aborted);
10064	}
10065
10066	// any machine settings modified?
10067	if (mData->flModifications)
10068	{
10069	LogWarningThisFunc(("Discarding unsaved settings changes!\n"));
10070	rollback(false /* aNotify */);
10071	}
10072
10073	Assert(mSnapshotData.mStateFilePath.isEmpty() \|\| !mSnapshotData.mSnapshot);
10074	if (!mSnapshotData.mStateFilePath.isEmpty())
10075	{
10076	LogWarningThisFunc(("canceling failed save state request!\n"));
10077	endSavingState(FALSE /* aSuccess */);
10078	}
10079	else if (!mSnapshotData.mSnapshot.isNull())
10080	{
10081	LogWarningThisFunc(("canceling untaken snapshot!\n"));
10082
10083	/* delete all differencing hard disks created (this will also attach
10084	* their parents back by rolling back mMediaData) */
10085	rollbackMedia();
10086	/* delete the saved state file (it might have been already created) */
10087	if (mSnapshotData.mSnapshot->stateFilePath().length())
10088	RTFileDelete(mSnapshotData.mSnapshot->stateFilePath().c_str());
10089
10090	mSnapshotData.mSnapshot->uninit();
10091	}
10092
10093	if (!mData->mSession.mType.isEmpty())
10094	{
10095	/* mType is not null when this machine's process has been started by
10096	* Machine::launchVMProcess(), therefore it is our child. We
10097	* need to queue the PID to reap the process (and avoid zombies on
10098	* Linux). */
10099	Assert(mData->mSession.mPid != NIL_RTPROCESS);
10100	mParent->addProcessToReap(mData->mSession.mPid);
10101	}
10102
10103	mData->mSession.mPid = NIL_RTPROCESS;
10104
10105	if (aReason == Uninit::Unexpected)
10106	{
10107	/* Uninitialization didn't come from #checkForDeath(), so tell the
10108	* client watcher thread to update the set of machines that have open
10109	* sessions. */
10110	mParent->updateClientWatcher();
10111	}
10112
10113	/* uninitialize all remote controls */
10114	if (mData->mSession.mRemoteControls.size())
10115	{
10116	LogFlowThisFunc(("Closing remote sessions (%d):\n",
10117	mData->mSession.mRemoteControls.size()));
10118
10119	Data::Session::RemoteControlList::iterator it =
10120	mData->mSession.mRemoteControls.begin();
10121	while (it != mData->mSession.mRemoteControls.end())
10122	{
10123	LogFlowThisFunc((" Calling remoteControl->Uninitialize()...\n"));
10124	HRESULT rc = (*it)->Uninitialize();
10125	LogFlowThisFunc((" remoteControl->Uninitialize() returned %08X\n", rc));
10126	if (FAILED(rc))
10127	LogWarningThisFunc(("Forgot to close the remote session?\n"));
10128	++it;
10129	}
10130	mData->mSession.mRemoteControls.clear();
10131	}
10132
10133	/*
10134	* An expected uninitialization can come only from #checkForDeath().
10135	* Otherwise it means that something's got really wrong (for examlple,
10136	* the Session implementation has released the VirtualBox reference
10137	* before it triggered #OnSessionEnd(), or before releasing IPC semaphore,
10138	* etc). However, it's also possible, that the client releases the IPC
10139	* semaphore correctly (i.e. before it releases the VirtualBox reference),
10140	* but the VirtualBox release event comes first to the server process.
10141	* This case is practically possible, so we should not assert on an
10142	* unexpected uninit, just log a warning.
10143	*/
10144
10145	if ((aReason == Uninit::Unexpected))
10146	LogWarningThisFunc(("Unexpected SessionMachine uninitialization!\n"));
10147
10148	if (aReason != Uninit::Normal)
10149	{
10150	mData->mSession.mDirectControl.setNull();
10151	}
10152	else
10153	{
10154	/* this must be null here (see #OnSessionEnd()) */
10155	Assert(mData->mSession.mDirectControl.isNull());
10156	Assert(mData->mSession.mState == SessionState_Unlocking);
10157	Assert(!mData->mSession.mProgress.isNull());
10158	}
10159	if (mData->mSession.mProgress)
10160	{
10161	if (aReason == Uninit::Normal)
10162	mData->mSession.mProgress->notifyComplete(S_OK);
10163	else
10164	mData->mSession.mProgress->notifyComplete(E_FAIL,
10165	COM_IIDOF(ISession),
10166	getComponentName(),
10167	tr("The VM session was aborted"));
10168	mData->mSession.mProgress.setNull();
10169	}
10170
10171	/* remove the association between the peer machine and this session machine */
10172	Assert( (SessionMachine*)mData->mSession.mMachine == this
10173	\|\| aReason == Uninit::Unexpected);
10174
10175	/* reset the rest of session data */
10176	mData->mSession.mMachine.setNull();
10177	mData->mSession.mState = SessionState_Unlocked;
10178	mData->mSession.mType.setNull();
10179
10180	/* close the interprocess semaphore before leaving the exclusive lock */
10181	#if defined(RT_OS_WINDOWS)
10182	if (mIPCSem)
10183	::CloseHandle(mIPCSem);
10184	mIPCSem = NULL;
10185	#elif defined(RT_OS_OS2)
10186	if (mIPCSem != NULLHANDLE)
10187	::DosCloseMutexSem(mIPCSem);
10188	mIPCSem = NULLHANDLE;
10189	#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
10190	if (mIPCSem >= 0)
10191	::semctl(mIPCSem, 0, IPC_RMID);
10192	mIPCSem = -1;
10193	# ifdef VBOX_WITH_NEW_SYS_V_KEYGEN
10194	mIPCKey = "0";
10195	# endif /* VBOX_WITH_NEW_SYS_V_KEYGEN */
10196	#else
10197	# error "Port me!"
10198	#endif
10199
10200	/* fire an event */
10201	mParent->onSessionStateChange(mData->mUuid, SessionState_Unlocked);
10202
10203	uninitDataAndChildObjects();
10204
10205	/* free the essential data structure last */
10206	mData.free();
10207
10208	#if 1 /** @todo Please review this change! (bird) */
10209	/* drop the exclusive lock before setting the below two to NULL */
10210	multilock.release();
10211	#else
10212	/* leave the exclusive lock before setting the below two to NULL */
10213	multilock.leave();
10214	#endif
10215
10216	unconst(mParent) = NULL;
10217	unconst(mPeer) = NULL;
10218
10219	LogFlowThisFuncLeave();
10220	}
10221
10222	// util::Lockable interface
10223	////////////////////////////////////////////////////////////////////////////////
10224
10225	/**
10226	* Overrides VirtualBoxBase::lockHandle() in order to share the lock handle
10227	* with the primary Machine instance (mPeer).
10228	*/
10229	RWLockHandle *SessionMachine::lockHandle() const
10230	{
10231	AssertReturn(mPeer != NULL, NULL);
10232	return mPeer->lockHandle();
10233	}
10234
10235	// IInternalMachineControl methods
10236	////////////////////////////////////////////////////////////////////////////////
10237
10238	/**
10239	* @note Locks this object for writing.
10240	*/
10241	STDMETHODIMP SessionMachine::SetRemoveSavedStateFile(BOOL aRemove)
10242	{
10243	AutoCaller autoCaller(this);
10244	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10245
10246	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
10247
10248	mRemoveSavedState = aRemove;
10249
10250	return S_OK;
10251	}
10252
10253	/**
10254	* @note Locks the same as #setMachineState() does.
10255	*/
10256	STDMETHODIMP SessionMachine::UpdateState(MachineState_T aMachineState)
10257	{
10258	return setMachineState(aMachineState);
10259	}
10260
10261	/**
10262	* @note Locks this object for reading.
10263	*/
10264	STDMETHODIMP SessionMachine::GetIPCId(BSTR *aId)
10265	{
10266	AutoCaller autoCaller(this);
10267	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10268
10269	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
10270
10271	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_OS2)
10272	mIPCSemName.cloneTo(aId);
10273	return S_OK;
10274	#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
10275	# ifdef VBOX_WITH_NEW_SYS_V_KEYGEN
10276	mIPCKey.cloneTo(aId);
10277	# else /* !VBOX_WITH_NEW_SYS_V_KEYGEN */
10278	mData->m_strConfigFileFull.cloneTo(aId);
10279	# endif /* !VBOX_WITH_NEW_SYS_V_KEYGEN */
10280	return S_OK;
10281	#else
10282	# error "Port me!"
10283	#endif
10284	}
10285
10286	/**
10287	* @note Locks this object for writing.
10288	*/
10289	STDMETHODIMP SessionMachine::BeginPowerUp(IProgress *aProgress)
10290	{
10291	LogFlowThisFunc(("aProgress=%p\n", aProgress));
10292	AutoCaller autoCaller(this);
10293	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10294
10295	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
10296
10297	if (mData->mSession.mState != SessionState_Locked)
10298	return VBOX_E_INVALID_OBJECT_STATE;
10299
10300	if (!mData->mSession.mProgress.isNull())
10301	mData->mSession.mProgress->setOtherProgressObject(aProgress);
10302
10303	LogFlowThisFunc(("returns S_OK.\n"));
10304	return S_OK;
10305	}
10306
10307
10308	/**
10309	* @note Locks this object for writing.
10310	*/
10311	STDMETHODIMP SessionMachine::EndPowerUp(LONG iResult)
10312	{
10313	AutoCaller autoCaller(this);
10314	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10315
10316	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
10317
10318	if (mData->mSession.mState != SessionState_Locked)
10319	return VBOX_E_INVALID_OBJECT_STATE;
10320
10321	/* Finalize the openRemoteSession progress object. */
10322	if (mData->mSession.mProgress)
10323	{
10324	mData->mSession.mProgress->notifyComplete((HRESULT)iResult);
10325	mData->mSession.mProgress.setNull();
10326	}
10327
10328	if (SUCCEEDED((HRESULT)iResult))
10329	{
10330	#ifdef VBOX_WITH_RESOURCE_USAGE_API
10331	/* The VM has been powered up successfully, so it makes sense
10332	* now to offer the performance metrics for a running machine
10333	* object. Doing it earlier wouldn't be safe. */
10334	registerMetrics(mParent->performanceCollector(), mPeer,
10335	mData->mSession.mPid);
10336	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
10337	}
10338
10339	return S_OK;
10340	}
10341
10342	/**
10343	* Goes through the USB filters of the given machine to see if the given
10344	* device matches any filter or not.
10345	*
10346	* @note Locks the same as USBController::hasMatchingFilter() does.
10347	*/
10348	STDMETHODIMP SessionMachine::RunUSBDeviceFilters(IUSBDevice *aUSBDevice,
10349	BOOL *aMatched,
10350	ULONG *aMaskedIfs)
10351	{
10352	LogFlowThisFunc(("\n"));
10353
10354	CheckComArgNotNull(aUSBDevice);
10355	CheckComArgOutPointerValid(aMatched);
10356
10357	AutoCaller autoCaller(this);
10358	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10359
10360	#ifdef VBOX_WITH_USB
10361	*aMatched = mUSBController->hasMatchingFilter(aUSBDevice, aMaskedIfs);
10362	#else
10363	NOREF(aUSBDevice);
10364	NOREF(aMaskedIfs);
10365	*aMatched = FALSE;
10366	#endif
10367
10368	return S_OK;
10369	}
10370
10371	/**
10372	* @note Locks the same as Host::captureUSBDevice() does.
10373	*/
10374	STDMETHODIMP SessionMachine::CaptureUSBDevice(IN_BSTR aId)
10375	{
10376	LogFlowThisFunc(("\n"));
10377
10378	AutoCaller autoCaller(this);
10379	AssertComRCReturnRC(autoCaller.rc());
10380
10381	#ifdef VBOX_WITH_USB
10382	/* if captureDeviceForVM() fails, it must have set extended error info */
10383	MultiResult rc = mParent->host()->checkUSBProxyService();
10384	if (FAILED(rc)) return rc;
10385
10386	USBProxyService *service = mParent->host()->usbProxyService();
10387	AssertReturn(service, E_FAIL);
10388	return service->captureDeviceForVM(this, Guid(aId).ref());
10389	#else
10390	NOREF(aId);
10391	return E_NOTIMPL;
10392	#endif
10393	}
10394
10395	/**
10396	* @note Locks the same as Host::detachUSBDevice() does.
10397	*/
10398	STDMETHODIMP SessionMachine::DetachUSBDevice(IN_BSTR aId, BOOL aDone)
10399	{
10400	LogFlowThisFunc(("\n"));
10401
10402	AutoCaller autoCaller(this);
10403	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10404
10405	#ifdef VBOX_WITH_USB
10406	USBProxyService *service = mParent->host()->usbProxyService();
10407	AssertReturn(service, E_FAIL);
10408	return service->detachDeviceFromVM(this, Guid(aId).ref(), !!aDone);
10409	#else
10410	NOREF(aId);
10411	NOREF(aDone);
10412	return E_NOTIMPL;
10413	#endif
10414	}
10415
10416	/**
10417	* Inserts all machine filters to the USB proxy service and then calls
10418	* Host::autoCaptureUSBDevices().
10419	*
10420	* Called by Console from the VM process upon VM startup.
10421	*
10422	* @note Locks what called methods lock.
10423	*/
10424	STDMETHODIMP SessionMachine::AutoCaptureUSBDevices()
10425	{
10426	LogFlowThisFunc(("\n"));
10427
10428	AutoCaller autoCaller(this);
10429	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10430
10431	#ifdef VBOX_WITH_USB
10432	HRESULT rc = mUSBController->notifyProxy(true /* aInsertFilters */);
10433	AssertComRC(rc);
10434	NOREF(rc);
10435
10436	USBProxyService *service = mParent->host()->usbProxyService();
10437	AssertReturn(service, E_FAIL);
10438	return service->autoCaptureDevicesForVM(this);
10439	#else
10440	return S_OK;
10441	#endif
10442	}
10443
10444	/**
10445	* Removes all machine filters from the USB proxy service and then calls
10446	* Host::detachAllUSBDevices().
10447	*
10448	* Called by Console from the VM process upon normal VM termination or by
10449	* SessionMachine::uninit() upon abnormal VM termination (from under the
10450	* Machine/SessionMachine lock).
10451	*
10452	* @note Locks what called methods lock.
10453	*/
10454	STDMETHODIMP SessionMachine::DetachAllUSBDevices(BOOL aDone)
10455	{
10456	LogFlowThisFunc(("\n"));
10457
10458	AutoCaller autoCaller(this);
10459	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10460
10461	#ifdef VBOX_WITH_USB
10462	HRESULT rc = mUSBController->notifyProxy(false /* aInsertFilters */);
10463	AssertComRC(rc);
10464	NOREF(rc);
10465
10466	USBProxyService *service = mParent->host()->usbProxyService();
10467	AssertReturn(service, E_FAIL);
10468	return service->detachAllDevicesFromVM(this, !!aDone, false /* aAbnormal */);
10469	#else
10470	NOREF(aDone);
10471	return S_OK;
10472	#endif
10473	}
10474
10475	/**
10476	* @note Locks this object for writing.
10477	*/
10478	STDMETHODIMP SessionMachine::OnSessionEnd(ISession *aSession,
10479	IProgress **aProgress)
10480	{
10481	LogFlowThisFuncEnter();
10482
10483	AssertReturn(aSession, E_INVALIDARG);
10484	AssertReturn(aProgress, E_INVALIDARG);
10485
10486	AutoCaller autoCaller(this);
10487
10488	LogFlowThisFunc(("callerstate=%d\n", autoCaller.state()));
10489	/*
10490	* We don't assert below because it might happen that a non-direct session
10491	* informs us it is closed right after we've been uninitialized -- it's ok.
10492	*/
10493	if (FAILED(autoCaller.rc())) return autoCaller.rc();
10494
10495	/* get IInternalSessionControl interface */
10496	ComPtr<IInternalSessionControl> control(aSession);
10497
10498	ComAssertRet(!control.isNull(), E_INVALIDARG);
10499
10500	/* Creating a Progress object requires the VirtualBox lock, and
10501	* thus locking it here is required by the lock order rules. */
10502	AutoMultiWriteLock2 alock(mParent->lockHandle(), this->lockHandle() COMMA_LOCKVAL_SRC_POS);
10503
10504	if (control == mData->mSession.mDirectControl)
10505	{
10506	ComAssertRet(aProgress, E_POINTER);
10507
10508	/* The direct session is being normally closed by the client process
10509	* ----------------------------------------------------------------- */
10510
10511	/* go to the closing state (essential for all open*Session() calls and
10512	* for #checkForDeath()) */
10513	Assert(mData->mSession.mState == SessionState_Locked);
10514	mData->mSession.mState = SessionState_Unlocking;
10515
10516	/* set direct control to NULL to release the remote instance */
10517	mData->mSession.mDirectControl.setNull();
10518	LogFlowThisFunc(("Direct control is set to NULL\n"));
10519
10520	if (mData->mSession.mProgress)
10521	{
10522	/* finalize the progress, someone might wait if a frontend
10523	* closes the session before powering on the VM. */
10524	mData->mSession.mProgress->notifyComplete(E_FAIL,
10525	COM_IIDOF(ISession),
10526	getComponentName(),
10527	tr("The VM session was closed before any attempt to power it on"));
10528	mData->mSession.mProgress.setNull();
10529	}
10530
10531	/* Create the progress object the client will use to wait until
10532	* #checkForDeath() is called to uninitialize this session object after
10533	* it releases the IPC semaphore.
10534	* Note! Because we're "reusing" mProgress here, this must be a proxy
10535	* object just like for openRemoteSession. */
10536	Assert(mData->mSession.mProgress.isNull());
10537	ComObjPtr<ProgressProxy> progress;
10538	progress.createObject();
10539	ComPtr<IUnknown> pPeer(mPeer);
10540	progress->init(mParent, pPeer,
10541	Bstr(tr("Closing session")).raw(),
10542	FALSE /* aCancelable */);
10543	progress.queryInterfaceTo(aProgress);
10544	mData->mSession.mProgress = progress;
10545	}
10546	else
10547	{
10548	/* the remote session is being normally closed */
10549	Data::Session::RemoteControlList::iterator it =
10550	mData->mSession.mRemoteControls.begin();
10551	while (it != mData->mSession.mRemoteControls.end())
10552	{
10553	if (control == *it)
10554	break;
10555	++it;
10556	}
10557	BOOL found = it != mData->mSession.mRemoteControls.end();
10558	ComAssertMsgRet(found, ("The session is not found in the session list!"),
10559	E_INVALIDARG);
10560	mData->mSession.mRemoteControls.remove(*it);
10561	}
10562
10563	LogFlowThisFuncLeave();
10564	return S_OK;
10565	}
10566
10567	/**
10568	* @note Locks this object for writing.
10569	*/
10570	STDMETHODIMP SessionMachine::BeginSavingState(IProgress aProgress, BSTR aStateFilePath)
10571	{
10572	LogFlowThisFuncEnter();
10573
10574	AssertReturn(aProgress, E_INVALIDARG);
10575	AssertReturn(aStateFilePath, E_POINTER);
10576
10577	AutoCaller autoCaller(this);
10578	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10579
10580	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
10581
10582	AssertReturn( mData->mMachineState == MachineState_Paused
10583	&& mSnapshotData.mLastState == MachineState_Null
10584	&& mSnapshotData.mProgressId.isEmpty()
10585	&& mSnapshotData.mStateFilePath.isEmpty(),
10586	E_FAIL);
10587
10588	/* memorize the progress ID and add it to the global collection */
10589	Bstr progressId;
10590	HRESULT rc = aProgress->COMGETTER(Id)(progressId.asOutParam());
10591	AssertComRCReturn(rc, rc);
10592	rc = mParent->addProgress(aProgress);
10593	AssertComRCReturn(rc, rc);
10594
10595	Bstr stateFilePath;
10596	/* stateFilePath is null when the machine is not running */
10597	if (mData->mMachineState == MachineState_Paused)
10598	{
10599	stateFilePath = Utf8StrFmt("%s%c{%RTuuid}.sav",
10600	mUserData->m_strSnapshotFolderFull.c_str(),
10601	RTPATH_DELIMITER, mData->mUuid.raw());
10602	}
10603
10604	/* fill in the snapshot data */
10605	mSnapshotData.mLastState = mData->mMachineState;
10606	mSnapshotData.mProgressId = Guid(progressId);
10607	mSnapshotData.mStateFilePath = stateFilePath;
10608
10609	/* set the state to Saving (this is expected by Console::SaveState()) */
10610	setMachineState(MachineState_Saving);
10611
10612	stateFilePath.cloneTo(aStateFilePath);
10613
10614	return S_OK;
10615	}
10616
10617	/**
10618	* @note Locks mParent + this object for writing.
10619	*/
10620	STDMETHODIMP SessionMachine::EndSavingState(BOOL aSuccess)
10621	{
10622	LogFlowThisFunc(("\n"));
10623
10624	AutoCaller autoCaller(this);
10625	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10626
10627	/* endSavingState() need mParent lock */
10628	AutoMultiWriteLock2 alock(mParent, this COMMA_LOCKVAL_SRC_POS);
10629
10630	AssertReturn( mData->mMachineState == MachineState_Saving
10631	&& mSnapshotData.mLastState != MachineState_Null
10632	&& !mSnapshotData.mProgressId.isEmpty()
10633	&& !mSnapshotData.mStateFilePath.isEmpty(),
10634	E_FAIL);
10635
10636	/*
10637	* on success, set the state to Saved;
10638	* on failure, set the state to the state we had when BeginSavingState() was
10639	* called (this is expected by Console::SaveState() and
10640	* Console::saveStateThread())
10641	*/
10642	if (aSuccess)
10643	setMachineState(MachineState_Saved);
10644	else
10645	setMachineState(mSnapshotData.mLastState);
10646
10647	return endSavingState(aSuccess);
10648	}
10649
10650	/**
10651	* @note Locks this object for writing.
10652	*/
10653	STDMETHODIMP SessionMachine::AdoptSavedState(IN_BSTR aSavedStateFile)
10654	{
10655	LogFlowThisFunc(("\n"));
10656
10657	CheckComArgStrNotEmptyOrNull(aSavedStateFile);
10658
10659	AutoCaller autoCaller(this);
10660	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10661
10662	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
10663
10664	AssertReturn( mData->mMachineState == MachineState_PoweredOff
10665	\|\| mData->mMachineState == MachineState_Teleported
10666	\|\| mData->mMachineState == MachineState_Aborted
10667	, E_FAIL); /** @todo setError. */
10668
10669	Utf8Str stateFilePathFull = aSavedStateFile;
10670	int vrc = calculateFullPath(stateFilePathFull, stateFilePathFull);
10671	if (RT_FAILURE(vrc))
10672	return setError(VBOX_E_FILE_ERROR,
10673	tr("Invalid saved state file path '%ls' (%Rrc)"),
10674	aSavedStateFile,
10675	vrc);
10676
10677	mSSData->mStateFilePath = stateFilePathFull;
10678
10679	/* The below setMachineState() will detect the state transition and will
10680	* update the settings file */
10681
10682	return setMachineState(MachineState_Saved);
10683	}
10684
10685	STDMETHODIMP SessionMachine::PullGuestProperties(ComSafeArrayOut(BSTR, aNames),
10686	ComSafeArrayOut(BSTR, aValues),
10687	ComSafeArrayOut(LONG64, aTimestamps),
10688	ComSafeArrayOut(BSTR, aFlags))
10689	{
10690	LogFlowThisFunc(("\n"));
10691
10692	#ifdef VBOX_WITH_GUEST_PROPS
10693	using namespace guestProp;
10694
10695	AutoCaller autoCaller(this);
10696	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10697
10698	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
10699
10700	AssertReturn(!ComSafeArrayOutIsNull(aNames), E_POINTER);
10701	AssertReturn(!ComSafeArrayOutIsNull(aValues), E_POINTER);
10702	AssertReturn(!ComSafeArrayOutIsNull(aTimestamps), E_POINTER);
10703	AssertReturn(!ComSafeArrayOutIsNull(aFlags), E_POINTER);
10704
10705	size_t cEntries = mHWData->mGuestProperties.size();
10706	com::SafeArray<BSTR> names(cEntries);
10707	com::SafeArray<BSTR> values(cEntries);
10708	com::SafeArray<LONG64> timestamps(cEntries);
10709	com::SafeArray<BSTR> flags(cEntries);
10710	unsigned i = 0;
10711	for (HWData::GuestPropertyList::iterator it = mHWData->mGuestProperties.begin();
10712	it != mHWData->mGuestProperties.end();
10713	++it)
10714	{
10715	char szFlags[MAX_FLAGS_LEN + 1];
10716	it->strName.cloneTo(&names[i]);
10717	it->strValue.cloneTo(&values[i]);
10718	timestamps[i] = it->mTimestamp;
10719	/* If it is NULL, keep it NULL. */
10720	if (it->mFlags)
10721	{
10722	writeFlags(it->mFlags, szFlags);
10723	Bstr(szFlags).cloneTo(&flags[i]);
10724	}
10725	else
10726	flags[i] = NULL;
10727	++i;
10728	}
10729	names.detachTo(ComSafeArrayOutArg(aNames));
10730	values.detachTo(ComSafeArrayOutArg(aValues));
10731	timestamps.detachTo(ComSafeArrayOutArg(aTimestamps));
10732	flags.detachTo(ComSafeArrayOutArg(aFlags));
10733	return S_OK;
10734	#else
10735	ReturnComNotImplemented();
10736	#endif
10737	}
10738
10739	STDMETHODIMP SessionMachine::PushGuestProperty(IN_BSTR aName,
10740	IN_BSTR aValue,
10741	LONG64 aTimestamp,
10742	IN_BSTR aFlags)
10743	{
10744	LogFlowThisFunc(("\n"));
10745
10746	#ifdef VBOX_WITH_GUEST_PROPS
10747	using namespace guestProp;
10748
10749	CheckComArgStrNotEmptyOrNull(aName);
10750	if (aValue != NULL && (!VALID_PTR(aValue) \|\| !VALID_PTR(aFlags)))
10751	return E_POINTER; /* aValue can be NULL to indicate deletion */
10752
10753	try
10754	{
10755	/*
10756	* Convert input up front.
10757	*/
10758	Utf8Str utf8Name(aName);
10759	uint32_t fFlags = NILFLAG;
10760	if (aFlags)
10761	{
10762	Utf8Str utf8Flags(aFlags);
10763	int vrc = validateFlags(utf8Flags.c_str(), &fFlags);
10764	AssertRCReturn(vrc, E_INVALIDARG);
10765	}
10766
10767	/*
10768	* Now grab the object lock, validate the state and do the update.
10769	*/
10770	AutoCaller autoCaller(this);
10771	if (FAILED(autoCaller.rc())) return autoCaller.rc();
10772
10773	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
10774
10775	switch (mData->mMachineState)
10776	{
10777	case MachineState_Paused:
10778	case MachineState_Running:
10779	case MachineState_Teleporting:
10780	case MachineState_TeleportingPausedVM:
10781	case MachineState_LiveSnapshotting:
10782	case MachineState_DeletingSnapshotOnline:
10783	case MachineState_DeletingSnapshotPaused:
10784	case MachineState_Saving:
10785	break;
10786
10787	default:
10788	#ifndef DEBUG_sunlover
10789	AssertMsgFailedReturn(("%s\n", Global::stringifyMachineState(mData->mMachineState)),
10790	VBOX_E_INVALID_VM_STATE);
10791	#else
10792	return VBOX_E_INVALID_VM_STATE;
10793	#endif
10794	}
10795
10796	setModified(IsModified_MachineData);
10797	mHWData.backup();
10798
10799	/** @todo r=bird: The careful memory handling doesn't work out here because
10800	* the catch block won't undo any damange we've done. So, if push_back throws
10801	* bad_alloc then you've lost the value.
10802	*
10803	* Another thing. Doing a linear search here isn't extremely efficient, esp.
10804	* since values that changes actually bubbles to the end of the list. Using
10805	* something that has an efficient lookup and can tollerate a bit of updates
10806	* would be nice. RTStrSpace is one suggestion (it's not perfect). Some
10807	* combination of RTStrCache (for sharing names and getting uniqueness into
10808	* the bargain) and hash/tree is another. */
10809	for (HWData::GuestPropertyList::iterator iter = mHWData->mGuestProperties.begin();
10810	iter != mHWData->mGuestProperties.end();
10811	++iter)
10812	if (utf8Name == iter->strName)
10813	{
10814	mHWData->mGuestProperties.erase(iter);
10815	mData->mGuestPropertiesModified = TRUE;
10816	break;
10817	}
10818	if (aValue != NULL)
10819	{
10820	HWData::GuestProperty property = { aName, aValue, aTimestamp, fFlags };
10821	mHWData->mGuestProperties.push_back(property);
10822	mData->mGuestPropertiesModified = TRUE;
10823	}
10824
10825	/*
10826	* Send a callback notification if appropriate
10827	*/
10828	if ( mHWData->mGuestPropertyNotificationPatterns.isEmpty()
10829	\|\| RTStrSimplePatternMultiMatch(mHWData->mGuestPropertyNotificationPatterns.c_str(),
10830	RTSTR_MAX,
10831	utf8Name.c_str(),
10832	RTSTR_MAX, NULL)
10833	)
10834	{
10835	alock.leave();
10836
10837	mParent->onGuestPropertyChange(mData->mUuid,
10838	aName,
10839	aValue,
10840	aFlags);
10841	}
10842	}
10843	catch (...)
10844	{
10845	return VirtualBox::handleUnexpectedExceptions(RT_SRC_POS);
10846	}
10847	return S_OK;
10848	#else
10849	ReturnComNotImplemented();
10850	#endif
10851	}
10852
10853	// public methods only for internal purposes
10854	/////////////////////////////////////////////////////////////////////////////
10855
10856	/**
10857	* Called from the client watcher thread to check for expected or unexpected
10858	* death of the client process that has a direct session to this machine.
10859	*
10860	* On Win32 and on OS/2, this method is called only when we've got the
10861	* mutex (i.e. the client has either died or terminated normally) so it always
10862	* returns @c true (the client is terminated, the session machine is
10863	* uninitialized).
10864	*
10865	* On other platforms, the method returns @c true if the client process has
10866	* terminated normally or abnormally and the session machine was uninitialized,
10867	* and @c false if the client process is still alive.
10868	*
10869	* @note Locks this object for writing.
10870	*/
10871	bool SessionMachine::checkForDeath()
10872	{
10873	Uninit::Reason reason;
10874	bool terminated = false;
10875
10876	/* Enclose autoCaller with a block because calling uninit() from under it
10877	* will deadlock. */
10878	{
10879	AutoCaller autoCaller(this);
10880	if (!autoCaller.isOk())
10881	{
10882	/* return true if not ready, to cause the client watcher to exclude
10883	* the corresponding session from watching */
10884	LogFlowThisFunc(("Already uninitialized!\n"));
10885	return true;
10886	}
10887
10888	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
10889
10890	/* Determine the reason of death: if the session state is Closing here,
10891	* everything is fine. Otherwise it means that the client did not call
10892	* OnSessionEnd() before it released the IPC semaphore. This may happen
10893	* either because the client process has abnormally terminated, or
10894	* because it simply forgot to call ISession::Close() before exiting. We
10895	* threat the latter also as an abnormal termination (see
10896	* Session::uninit() for details). */
10897	reason = mData->mSession.mState == SessionState_Unlocking ?
10898	Uninit::Normal :
10899	Uninit::Abnormal;
10900
10901	#if defined(RT_OS_WINDOWS)
10902
10903	AssertMsg(mIPCSem, ("semaphore must be created"));
10904
10905	/* release the IPC mutex */
10906	::ReleaseMutex(mIPCSem);
10907
10908	terminated = true;
10909
10910	#elif defined(RT_OS_OS2)
10911
10912	AssertMsg(mIPCSem, ("semaphore must be created"));
10913
10914	/* release the IPC mutex */
10915	::DosReleaseMutexSem(mIPCSem);
10916
10917	terminated = true;
10918
10919	#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
10920
10921	AssertMsg(mIPCSem >= 0, ("semaphore must be created"));
10922
10923	int val = ::semctl(mIPCSem, 0, GETVAL);
10924	if (val > 0)
10925	{
10926	/* the semaphore is signaled, meaning the session is terminated */
10927	terminated = true;
10928	}
10929
10930	#else
10931	# error "Port me!"
10932	#endif
10933
10934	} /* AutoCaller block */
10935
10936	if (terminated)
10937	uninit(reason);
10938
10939	return terminated;
10940	}
10941
10942	/**
10943	* @note Locks this object for reading.
10944	*/
10945	HRESULT SessionMachine::onNetworkAdapterChange(INetworkAdapter *networkAdapter, BOOL changeAdapter)
10946	{
10947	LogFlowThisFunc(("\n"));
10948
10949	AutoCaller autoCaller(this);
10950	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10951
10952	ComPtr<IInternalSessionControl> directControl;
10953	{
10954	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
10955	directControl = mData->mSession.mDirectControl;
10956	}
10957
10958	/* ignore notifications sent after #OnSessionEnd() is called */
10959	if (!directControl)
10960	return S_OK;
10961
10962	return directControl->OnNetworkAdapterChange(networkAdapter, changeAdapter);
10963	}
10964
10965	/**
10966	* @note Locks this object for reading.
10967	*/
10968	HRESULT SessionMachine::onSerialPortChange(ISerialPort *serialPort)
10969	{
10970	LogFlowThisFunc(("\n"));
10971
10972	AutoCaller autoCaller(this);
10973	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10974
10975	ComPtr<IInternalSessionControl> directControl;
10976	{
10977	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
10978	directControl = mData->mSession.mDirectControl;
10979	}
10980
10981	/* ignore notifications sent after #OnSessionEnd() is called */
10982	if (!directControl)
10983	return S_OK;
10984
10985	return directControl->OnSerialPortChange(serialPort);
10986	}
10987
10988	/**
10989	* @note Locks this object for reading.
10990	*/
10991	HRESULT SessionMachine::onParallelPortChange(IParallelPort *parallelPort)
10992	{
10993	LogFlowThisFunc(("\n"));
10994
10995	AutoCaller autoCaller(this);
10996	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10997
10998	ComPtr<IInternalSessionControl> directControl;
10999	{
11000	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
11001	directControl = mData->mSession.mDirectControl;
11002	}
11003
11004	/* ignore notifications sent after #OnSessionEnd() is called */
11005	if (!directControl)
11006	return S_OK;
11007
11008	return directControl->OnParallelPortChange(parallelPort);
11009	}
11010
11011	/**
11012	* @note Locks this object for reading.
11013	*/
11014	HRESULT SessionMachine::onStorageControllerChange()
11015	{
11016	LogFlowThisFunc(("\n"));
11017
11018	AutoCaller autoCaller(this);
11019	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
11020
11021	ComPtr<IInternalSessionControl> directControl;
11022	{
11023	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
11024	directControl = mData->mSession.mDirectControl;
11025	}
11026
11027	/* ignore notifications sent after #OnSessionEnd() is called */
11028	if (!directControl)
11029	return S_OK;
11030
11031	return directControl->OnStorageControllerChange();
11032	}
11033
11034	/**
11035	* @note Locks this object for reading.
11036	*/
11037	HRESULT SessionMachine::onMediumChange(IMediumAttachment *aAttachment, BOOL aForce)
11038	{
11039	LogFlowThisFunc(("\n"));
11040
11041	AutoCaller autoCaller(this);
11042	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
11043
11044	ComPtr<IInternalSessionControl> directControl;
11045	{
11046	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
11047	directControl = mData->mSession.mDirectControl;
11048	}
11049
11050	/* ignore notifications sent after #OnSessionEnd() is called */
11051	if (!directControl)
11052	return S_OK;
11053
11054	return directControl->OnMediumChange(aAttachment, aForce);
11055	}
11056
11057	/**
11058	* @note Locks this object for reading.
11059	*/
11060	HRESULT SessionMachine::onCPUChange(ULONG aCPU, BOOL aRemove)
11061	{
11062	LogFlowThisFunc(("\n"));
11063
11064	AutoCaller autoCaller(this);
11065	AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
11066
11067	ComPtr<IInternalSessionControl> directControl;
11068	{
11069	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
11070	directControl = mData->mSession.mDirectControl;
11071	}
11072
11073	/* ignore notifications sent after #OnSessionEnd() is called */
11074	if (!directControl)
11075	return S_OK;
11076
11077	return directControl->OnCPUChange(aCPU, aRemove);
11078	}
11079
11080	HRESULT SessionMachine::onCPUExecutionCapChange(ULONG aExecutionCap)
11081	{
11082	LogFlowThisFunc(("\n"));
11083
11084	AutoCaller autoCaller(this);
11085	AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
11086
11087	ComPtr<IInternalSessionControl> directControl;
11088	{
11089	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
11090	directControl = mData->mSession.mDirectControl;
11091	}
11092
11093	/* ignore notifications sent after #OnSessionEnd() is called */
11094	if (!directControl)
11095	return S_OK;
11096
11097	return directControl->OnCPUExecutionCapChange(aExecutionCap);
11098	}
11099
11100	/**
11101	* @note Locks this object for reading.
11102	*/
11103	HRESULT SessionMachine::onVRDPServerChange(BOOL aRestart)
11104	{
11105	LogFlowThisFunc(("\n"));
11106
11107	AutoCaller autoCaller(this);
11108	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
11109
11110	ComPtr<IInternalSessionControl> directControl;
11111	{
11112	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
11113	directControl = mData->mSession.mDirectControl;
11114	}
11115
11116	/* ignore notifications sent after #OnSessionEnd() is called */
11117	if (!directControl)
11118	return S_OK;
11119
11120	return directControl->OnVRDPServerChange(aRestart);
11121	}
11122
11123	/**
11124	* @note Locks this object for reading.
11125	*/
11126	HRESULT SessionMachine::onUSBControllerChange()
11127	{
11128	LogFlowThisFunc(("\n"));
11129
11130	AutoCaller autoCaller(this);
11131	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
11132
11133	ComPtr<IInternalSessionControl> directControl;
11134	{
11135	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
11136	directControl = mData->mSession.mDirectControl;
11137	}
11138
11139	/* ignore notifications sent after #OnSessionEnd() is called */
11140	if (!directControl)
11141	return S_OK;
11142
11143	return directControl->OnUSBControllerChange();
11144	}
11145
11146	/**
11147	* @note Locks this object for reading.
11148	*/
11149	HRESULT SessionMachine::onSharedFolderChange()
11150	{
11151	LogFlowThisFunc(("\n"));
11152
11153	AutoCaller autoCaller(this);
11154	AssertComRCReturnRC(autoCaller.rc());
11155
11156	ComPtr<IInternalSessionControl> directControl;
11157	{
11158	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
11159	directControl = mData->mSession.mDirectControl;
11160	}
11161
11162	/* ignore notifications sent after #OnSessionEnd() is called */
11163	if (!directControl)
11164	return S_OK;
11165
11166	return directControl->OnSharedFolderChange(FALSE /* aGlobal */);
11167	}
11168
11169	/**
11170	* Returns @c true if this machine's USB controller reports it has a matching
11171	* filter for the given USB device and @c false otherwise.
11172	*
11173	* @note Caller must have requested machine read lock.
11174	*/
11175	bool SessionMachine::hasMatchingUSBFilter(const ComObjPtr<HostUSBDevice> &aDevice, ULONG *aMaskedIfs)
11176	{
11177	AutoCaller autoCaller(this);
11178	/* silently return if not ready -- this method may be called after the
11179	* direct machine session has been called */
11180	if (!autoCaller.isOk())
11181	return false;
11182
11183
11184	#ifdef VBOX_WITH_USB
11185	switch (mData->mMachineState)
11186	{
11187	case MachineState_Starting:
11188	case MachineState_Restoring:
11189	case MachineState_TeleportingIn:
11190	case MachineState_Paused:
11191	case MachineState_Running:
11192	/** @todo Live Migration: snapshoting & teleporting. Need to fend things of
11193	* elsewhere... */
11194	return mUSBController->hasMatchingFilter(aDevice, aMaskedIfs);
11195	default: break;
11196	}
11197	#else
11198	NOREF(aDevice);
11199	NOREF(aMaskedIfs);
11200	#endif
11201	return false;
11202	}
11203
11204	/**
11205	* @note The calls shall hold no locks. Will temporarily lock this object for reading.
11206	*/
11207	HRESULT SessionMachine::onUSBDeviceAttach(IUSBDevice *aDevice,
11208	IVirtualBoxErrorInfo *aError,
11209	ULONG aMaskedIfs)
11210	{
11211	LogFlowThisFunc(("\n"));
11212
11213	AutoCaller autoCaller(this);
11214
11215	/* This notification may happen after the machine object has been
11216	* uninitialized (the session was closed), so don't assert. */
11217	if (FAILED(autoCaller.rc())) return autoCaller.rc();
11218
11219	ComPtr<IInternalSessionControl> directControl;
11220	{
11221	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
11222	directControl = mData->mSession.mDirectControl;
11223	}
11224
11225	/* fail on notifications sent after #OnSessionEnd() is called, it is
11226	* expected by the caller */
11227	if (!directControl)
11228	return E_FAIL;
11229
11230	/* No locks should be held at this point. */
11231	AssertMsg(RTLockValidatorWriteLockGetCount(RTThreadSelf()) == 0, ("%d\n", RTLockValidatorWriteLockGetCount(RTThreadSelf())));
11232	AssertMsg(RTLockValidatorReadLockGetCount(RTThreadSelf()) == 0, ("%d\n", RTLockValidatorReadLockGetCount(RTThreadSelf())));
11233
11234	return directControl->OnUSBDeviceAttach(aDevice, aError, aMaskedIfs);
11235	}
11236
11237	/**
11238	* @note The calls shall hold no locks. Will temporarily lock this object for reading.
11239	*/
11240	HRESULT SessionMachine::onUSBDeviceDetach(IN_BSTR aId,
11241	IVirtualBoxErrorInfo *aError)
11242	{
11243	LogFlowThisFunc(("\n"));
11244
11245	AutoCaller autoCaller(this);
11246
11247	/* This notification may happen after the machine object has been
11248	* uninitialized (the session was closed), so don't assert. */
11249	if (FAILED(autoCaller.rc())) return autoCaller.rc();
11250
11251	ComPtr<IInternalSessionControl> directControl;
11252	{
11253	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
11254	directControl = mData->mSession.mDirectControl;
11255	}
11256
11257	/* fail on notifications sent after #OnSessionEnd() is called, it is
11258	* expected by the caller */
11259	if (!directControl)
11260	return E_FAIL;
11261
11262	/* No locks should be held at this point. */
11263	AssertMsg(RTLockValidatorWriteLockGetCount(RTThreadSelf()) == 0, ("%d\n", RTLockValidatorWriteLockGetCount(RTThreadSelf())));
11264	AssertMsg(RTLockValidatorReadLockGetCount(RTThreadSelf()) == 0, ("%d\n", RTLockValidatorReadLockGetCount(RTThreadSelf())));
11265
11266	return directControl->OnUSBDeviceDetach(aId, aError);
11267	}
11268
11269	// protected methods
11270	/////////////////////////////////////////////////////////////////////////////
11271
11272	/**
11273	* Helper method to finalize saving the state.
11274	*
11275	* @note Must be called from under this object's lock.
11276	*
11277	* @param aSuccess TRUE if the snapshot has been taken successfully
11278	*
11279	* @note Locks mParent + this objects for writing.
11280	*/
11281	HRESULT SessionMachine::endSavingState(BOOL aSuccess)
11282	{
11283	LogFlowThisFuncEnter();
11284
11285	AutoCaller autoCaller(this);
11286	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
11287
11288	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
11289
11290	HRESULT rc = S_OK;
11291
11292	if (aSuccess)
11293	{
11294	mSSData->mStateFilePath = mSnapshotData.mStateFilePath;
11295
11296	/* save all VM settings */
11297	rc = saveSettings(NULL);
11298	// no need to check whether VirtualBox.xml needs saving also since
11299	// we can't have a name change pending at this point
11300	}
11301	else
11302	{
11303	/* delete the saved state file (it might have been already created) */
11304	RTFileDelete(mSnapshotData.mStateFilePath.c_str());
11305	}
11306
11307	/* remove the completed progress object */
11308	mParent->removeProgress(mSnapshotData.mProgressId.ref());
11309
11310	/* clear out the temporary saved state data */
11311	mSnapshotData.mLastState = MachineState_Null;
11312	mSnapshotData.mProgressId.clear();
11313	mSnapshotData.mStateFilePath.setNull();
11314
11315	LogFlowThisFuncLeave();
11316	return rc;
11317	}
11318
11319	/**
11320	* Locks the attached media.
11321	*
11322	* All attached hard disks are locked for writing and DVD/floppy are locked for
11323	* reading. Parents of attached hard disks (if any) are locked for reading.
11324	*
11325	* This method also performs accessibility check of all media it locks: if some
11326	* media is inaccessible, the method will return a failure and a bunch of
11327	* extended error info objects per each inaccessible medium.
11328	*
11329	* Note that this method is atomic: if it returns a success, all media are
11330	* locked as described above; on failure no media is locked at all (all
11331	* succeeded individual locks will be undone).
11332	*
11333	* This method is intended to be called when the machine is in Starting or
11334	* Restoring state and asserts otherwise.
11335	*
11336	* The locks made by this method must be undone by calling #unlockMedia() when
11337	* no more needed.
11338	*/
11339	HRESULT SessionMachine::lockMedia()
11340	{
11341	AutoCaller autoCaller(this);
11342	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
11343
11344	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
11345
11346	AssertReturn( mData->mMachineState == MachineState_Starting
11347	\|\| mData->mMachineState == MachineState_Restoring
11348	\|\| mData->mMachineState == MachineState_TeleportingIn, E_FAIL);
11349	/* bail out if trying to lock things with already set up locking */
11350	AssertReturn(mData->mSession.mLockedMedia.IsEmpty(), E_FAIL);
11351
11352	MultiResult mrc(S_OK);
11353
11354	/* Collect locking information for all medium objects attached to the VM. */
11355	for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
11356	it != mMediaData->mAttachments.end();
11357	++it)
11358	{
11359	MediumAttachment* pAtt = *it;
11360	DeviceType_T devType = pAtt->getType();
11361	Medium *pMedium = pAtt->getMedium();
11362
11363	MediumLockList *pMediumLockList(new MediumLockList());
11364	// There can be attachments without a medium (floppy/dvd), and thus
11365	// it's impossible to create a medium lock list. It still makes sense
11366	// to have the empty medium lock list in the map in case a medium is
11367	// attached later.
11368	if (pMedium != NULL)
11369	{
11370	MediumType_T mediumType = pMedium->getType();
11371	bool fIsReadOnlyImage = devType == DeviceType_DVD
11372	\|\| mediumType == MediumType_Shareable;
11373	bool fIsVitalImage = (devType == DeviceType_HardDisk);
11374
11375	mrc = pMedium->createMediumLockList(fIsVitalImage /* fFailIfInaccessible */,
11376	!fIsReadOnlyImage /* fMediumLockWrite */,
11377	NULL,
11378	*pMediumLockList);
11379	if (FAILED(mrc))
11380	{
11381	delete pMediumLockList;
11382	mData->mSession.mLockedMedia.Clear();
11383	break;
11384	}
11385	}
11386
11387	HRESULT rc = mData->mSession.mLockedMedia.Insert(pAtt, pMediumLockList);
11388	if (FAILED(rc))
11389	{
11390	mData->mSession.mLockedMedia.Clear();
11391	mrc = setError(rc,
11392	tr("Collecting locking information for all attached media failed"));
11393	break;
11394	}
11395	}
11396
11397	if (SUCCEEDED(mrc))
11398	{
11399	/* Now lock all media. If this fails, nothing is locked. */
11400	HRESULT rc = mData->mSession.mLockedMedia.Lock();
11401	if (FAILED(rc))
11402	{
11403	mrc = setError(rc,
11404	tr("Locking of attached media failed"));
11405	}
11406	}
11407
11408	return mrc;
11409	}
11410
11411	/**
11412	* Undoes the locks made by by #lockMedia().
11413	*/
11414	void SessionMachine::unlockMedia()
11415	{
11416	AutoCaller autoCaller(this);
11417	AssertComRCReturnVoid(autoCaller.rc());
11418
11419	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
11420
11421	/* we may be holding important error info on the current thread;
11422	* preserve it */
11423	ErrorInfoKeeper eik;
11424
11425	HRESULT rc = mData->mSession.mLockedMedia.Clear();
11426	AssertComRC(rc);
11427	}
11428
11429	/**
11430	* Helper to change the machine state (reimplementation).
11431	*
11432	* @note Locks this object for writing.
11433	*/
11434	HRESULT SessionMachine::setMachineState(MachineState_T aMachineState)
11435	{
11436	LogFlowThisFuncEnter();
11437	LogFlowThisFunc(("aMachineState=%s\n", Global::stringifyMachineState(aMachineState) ));
11438
11439	AutoCaller autoCaller(this);
11440	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
11441
11442	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
11443
11444	MachineState_T oldMachineState = mData->mMachineState;
11445
11446	AssertMsgReturn(oldMachineState != aMachineState,
11447	("oldMachineState=%s, aMachineState=%s\n",
11448	Global::stringifyMachineState(oldMachineState), Global::stringifyMachineState(aMachineState)),
11449	E_FAIL);
11450
11451	HRESULT rc = S_OK;
11452
11453	int stsFlags = 0;
11454	bool deleteSavedState = false;
11455
11456	/* detect some state transitions */
11457
11458	if ( ( oldMachineState == MachineState_Saved
11459	&& aMachineState == MachineState_Restoring)
11460	\|\| ( ( oldMachineState == MachineState_PoweredOff
11461	\|\| oldMachineState == MachineState_Teleported
11462	\|\| oldMachineState == MachineState_Aborted
11463	)
11464	&& ( aMachineState == MachineState_TeleportingIn
11465	\|\| aMachineState == MachineState_Starting
11466	)
11467	)
11468	)
11469	{
11470	/* The EMT thread is about to start */
11471
11472	/* Nothing to do here for now... */
11473
11474	/// @todo NEWMEDIA don't let mDVDDrive and other children
11475	/// change anything when in the Starting/Restoring state
11476	}
11477	else if ( ( oldMachineState == MachineState_Running
11478	\|\| oldMachineState == MachineState_Paused
11479	\|\| oldMachineState == MachineState_Teleporting
11480	\|\| oldMachineState == MachineState_LiveSnapshotting
11481	\|\| oldMachineState == MachineState_Stuck
11482	\|\| oldMachineState == MachineState_Starting
11483	\|\| oldMachineState == MachineState_Stopping
11484	\|\| oldMachineState == MachineState_Saving
11485	\|\| oldMachineState == MachineState_Restoring
11486	\|\| oldMachineState == MachineState_TeleportingPausedVM
11487	\|\| oldMachineState == MachineState_TeleportingIn
11488	)
11489	&& ( aMachineState == MachineState_PoweredOff
11490	\|\| aMachineState == MachineState_Saved
11491	\|\| aMachineState == MachineState_Teleported
11492	\|\| aMachineState == MachineState_Aborted
11493	)
11494	/* ignore PoweredOff->Saving->PoweredOff transition when taking a
11495	* snapshot */
11496	&& ( mSnapshotData.mSnapshot.isNull()
11497	\|\| mSnapshotData.mLastState >= MachineState_Running /** @todo Live Migration: clean up (lazy bird) */
11498	)
11499	)
11500	{
11501	/* The EMT thread has just stopped, unlock attached media. Note that as
11502	* opposed to locking that is done from Console, we do unlocking here
11503	* because the VM process may have aborted before having a chance to
11504	* properly unlock all media it locked. */
11505
11506	unlockMedia();
11507	}
11508
11509	if (oldMachineState == MachineState_Restoring)
11510	{
11511	if (aMachineState != MachineState_Saved)
11512	{
11513	/*
11514	* delete the saved state file once the machine has finished
11515	* restoring from it (note that Console sets the state from
11516	* Restoring to Saved if the VM couldn't restore successfully,
11517	* to give the user an ability to fix an error and retry --
11518	* we keep the saved state file in this case)
11519	*/
11520	deleteSavedState = true;
11521	}
11522	}
11523	else if ( oldMachineState == MachineState_Saved
11524	&& ( aMachineState == MachineState_PoweredOff
11525	\|\| aMachineState == MachineState_Aborted
11526	\|\| aMachineState == MachineState_Teleported
11527	)
11528	)
11529	{
11530	/*
11531	* delete the saved state after Console::ForgetSavedState() is called
11532	* or if the VM process (owning a direct VM session) crashed while the
11533	* VM was Saved
11534	*/
11535
11536	/// @todo (dmik)
11537	// Not sure that deleting the saved state file just because of the
11538	// client death before it attempted to restore the VM is a good
11539	// thing. But when it crashes we need to go to the Aborted state
11540	// which cannot have the saved state file associated... The only
11541	// way to fix this is to make the Aborted condition not a VM state
11542	// but a bool flag: i.e., when a crash occurs, set it to true and
11543	// change the state to PoweredOff or Saved depending on the
11544	// saved state presence.
11545
11546	deleteSavedState = true;
11547	mData->mCurrentStateModified = TRUE;
11548	stsFlags \|= SaveSTS_CurStateModified;
11549	}
11550
11551	if ( aMachineState == MachineState_Starting
11552	\|\| aMachineState == MachineState_Restoring
11553	\|\| aMachineState == MachineState_TeleportingIn
11554	)
11555	{
11556	/* set the current state modified flag to indicate that the current
11557	* state is no more identical to the state in the
11558	* current snapshot */
11559	if (!mData->mCurrentSnapshot.isNull())
11560	{
11561	mData->mCurrentStateModified = TRUE;
11562	stsFlags \|= SaveSTS_CurStateModified;
11563	}
11564	}
11565
11566	if (deleteSavedState)
11567	{
11568	if (mRemoveSavedState)
11569	{
11570	Assert(!mSSData->mStateFilePath.isEmpty());
11571	RTFileDelete(mSSData->mStateFilePath.c_str());
11572	}
11573	mSSData->mStateFilePath.setNull();
11574	stsFlags \|= SaveSTS_StateFilePath;
11575	}
11576
11577	/* redirect to the underlying peer machine */
11578	mPeer->setMachineState(aMachineState);
11579
11580	if ( aMachineState == MachineState_PoweredOff
11581	\|\| aMachineState == MachineState_Teleported
11582	\|\| aMachineState == MachineState_Aborted
11583	\|\| aMachineState == MachineState_Saved)
11584	{
11585	/* the machine has stopped execution
11586	* (or the saved state file was adopted) */
11587	stsFlags \|= SaveSTS_StateTimeStamp;
11588	}
11589
11590	if ( ( oldMachineState == MachineState_PoweredOff
11591	\|\| oldMachineState == MachineState_Aborted
11592	\|\| oldMachineState == MachineState_Teleported
11593	)
11594	&& aMachineState == MachineState_Saved)
11595	{
11596	/* the saved state file was adopted */
11597	Assert(!mSSData->mStateFilePath.isEmpty());
11598	stsFlags \|= SaveSTS_StateFilePath;
11599	}
11600
11601	#ifdef VBOX_WITH_GUEST_PROPS
11602	if ( aMachineState == MachineState_PoweredOff
11603	\|\| aMachineState == MachineState_Aborted
11604	\|\| aMachineState == MachineState_Teleported)
11605	{
11606	/* Make sure any transient guest properties get removed from the
11607	* property store on shutdown. */
11608
11609	HWData::GuestPropertyList::iterator it;
11610	BOOL fNeedsSaving = mData->mGuestPropertiesModified;
11611	if (!fNeedsSaving)
11612	for (it = mHWData->mGuestProperties.begin();
11613	it != mHWData->mGuestProperties.end(); ++it)
11614	if (it->mFlags & guestProp::TRANSIENT)
11615	{
11616	fNeedsSaving = true;
11617	break;
11618	}
11619	if (fNeedsSaving)
11620	{
11621	mData->mCurrentStateModified = TRUE;
11622	stsFlags \|= SaveSTS_CurStateModified;
11623	SaveSettings(); // @todo r=dj why the public method? why first SaveSettings and then saveStateSettings?
11624	}
11625	}
11626	#endif
11627
11628	rc = saveStateSettings(stsFlags);
11629
11630	if ( ( oldMachineState != MachineState_PoweredOff
11631	&& oldMachineState != MachineState_Aborted
11632	&& oldMachineState != MachineState_Teleported
11633	)
11634	&& ( aMachineState == MachineState_PoweredOff
11635	\|\| aMachineState == MachineState_Aborted
11636	\|\| aMachineState == MachineState_Teleported
11637	)
11638	)
11639	{
11640	/* we've been shut down for any reason */
11641	/* no special action so far */
11642	}
11643
11644	LogFlowThisFunc(("rc=%Rhrc [%s]\n", rc, Global::stringifyMachineState(mData->mMachineState) ));
11645	LogFlowThisFuncLeave();
11646	return rc;
11647	}
11648
11649	/**
11650	* Sends the current machine state value to the VM process.
11651	*
11652	* @note Locks this object for reading, then calls a client process.
11653	*/
11654	HRESULT SessionMachine::updateMachineStateOnClient()
11655	{
11656	AutoCaller autoCaller(this);
11657	AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
11658
11659	ComPtr<IInternalSessionControl> directControl;
11660	{
11661	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
11662	AssertReturn(!!mData, E_FAIL);
11663	directControl = mData->mSession.mDirectControl;
11664
11665	/* directControl may be already set to NULL here in #OnSessionEnd()
11666	* called too early by the direct session process while there is still
11667	* some operation (like deleting the snapshot) in progress. The client
11668	* process in this case is waiting inside Session::close() for the
11669	* "end session" process object to complete, while #uninit() called by
11670	* #checkForDeath() on the Watcher thread is waiting for the pending
11671	* operation to complete. For now, we accept this inconsitent behavior
11672	* and simply do nothing here. */
11673
11674	if (mData->mSession.mState == SessionState_Unlocking)
11675	return S_OK;
11676
11677	AssertReturn(!directControl.isNull(), E_FAIL);
11678	}
11679
11680	return directControl->UpdateMachineState(mData->mMachineState);
11681	}

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

source: vbox/trunk/src/VBox/Main/MachineImpl.cpp@ 33223

Download in other formats: