MachineImpl.h@ 56268

Last change on this file since 56268 was 56035, checked in by vboxsync, 10 years ago
Main/Machine+USBController+StorageController: Mix of deleting useless functionality, fixing of missing sanity checks and adding some additional functionality. The removed functionality is the possibility to specify patters of guest properties which will trigger notifications, which wasn't useful as it is per VM, sabotaging other API clients (e.g. the VM process assumes it gets the notifications it needs). The storage controller setters were lacking a lot of state and consistency sanity checking, which is now fixed. Both the USB and storage controllers can now be renamed (no API client uses this functionality though), all with very pessimistic assumptions (only when the VM is powered off).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 67.3 KB

Line
1	/* $Id: MachineImpl.h 56035 2015-05-22 16:03:35Z vboxsync $ */
2	/** @file
3	* Implementation of IMachine in VBoxSVC - Header.
4	*/
5
6	/*
7	* Copyright (C) 2006-2015 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	#ifndef ____H_MACHINEIMPL
19	#define ____H_MACHINEIMPL
20
21	#include "VirtualBoxBase.h"
22	#include "SnapshotImpl.h"
23	#include "ProgressImpl.h"
24	#include "VRDEServerImpl.h"
25	#include "MediumAttachmentImpl.h"
26	#include "PCIDeviceAttachmentImpl.h"
27	#include "MediumLock.h"
28	#include "NetworkAdapterImpl.h"
29	#include "AudioAdapterImpl.h"
30	#include "SerialPortImpl.h"
31	#include "ParallelPortImpl.h"
32	#include "BIOSSettingsImpl.h"
33	#include "StorageControllerImpl.h" // required for MachineImpl.h to compile on Windows
34	#include "USBControllerImpl.h" // required for MachineImpl.h to compile on Windows
35	#include "BandwidthControlImpl.h"
36	#include "BandwidthGroupImpl.h"
37	#include "VBox/settings.h"
38	#ifdef VBOX_WITH_RESOURCE_USAGE_API
39	#include "Performance.h"
40	#include "PerformanceImpl.h"
41	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
42
43	// generated header
44	#include "SchemaDefs.h"
45
46	#include "VBox/com/ErrorInfo.h"
47
48	#include <iprt/file.h>
49	#include <iprt/thread.h>
50	#include <iprt/time.h>
51
52	#include <list>
53	#include <vector>
54
55	#include "MachineWrap.h"
56
57	// defines
58	////////////////////////////////////////////////////////////////////////////////
59
60	// helper declarations
61	////////////////////////////////////////////////////////////////////////////////
62
63	class Progress;
64	class ProgressProxy;
65	class Keyboard;
66	class Mouse;
67	class Display;
68	class MachineDebugger;
69	class USBController;
70	class USBDeviceFilters;
71	class Snapshot;
72	class SharedFolder;
73	class HostUSBDevice;
74	class StorageController;
75	class SessionMachine;
76
77	namespace settings
78	{
79	class MachineConfigFile;
80	struct Snapshot;
81	struct Hardware;
82	struct Storage;
83	struct StorageController;
84	struct MachineRegistryEntry;
85	}
86
87	// Machine class
88	////////////////////////////////////////////////////////////////////////////////
89	//
90	class ATL_NO_VTABLE Machine :
91	public MachineWrap
92	{
93
94	public:
95
96	enum StateDependency
97	{
98	AnyStateDep = 0,
99	MutableStateDep,
100	MutableOrSavedStateDep,
101	MutableOrRunningStateDep,
102	MutableOrSavedOrRunningStateDep,
103	};
104
105	/**
106	* Internal machine data.
107	*
108	* Only one instance of this data exists per every machine -- it is shared
109	* by the Machine, SessionMachine and all SnapshotMachine instances
110	* associated with the given machine using the util::Shareable template
111	* through the mData variable.
112	*
113	* @note \|const\| members are persistent during lifetime so can be
114	* accessed without locking.
115	*
116	* @note There is no need to lock anything inside init() or uninit()
117	* methods, because they are always serialized (see AutoCaller).
118	*/
119	struct Data
120	{
121	/**
122	* Data structure to hold information about sessions opened for the
123	* given machine.
124	*/
125	struct Session
126	{
127	/** Type of lock which created this session */
128	LockType_T mLockType;
129
130	/** Control of the direct session opened by lockMachine() */
131	ComPtr<IInternalSessionControl> mDirectControl;
132
133	typedef std::list<ComPtr<IInternalSessionControl> > RemoteControlList;
134
135	/** list of controls of all opened remote sessions */
136	RemoteControlList mRemoteControls;
137
138	/** launchVMProcess() and OnSessionEnd() progress indicator */
139	ComObjPtr<ProgressProxy> mProgress;
140
141	/**
142	* PID of the session object that must be passed to openSession()
143	* to finalize the launchVMProcess() request (i.e., PID of the
144	* process created by launchVMProcess())
145	*/
146	RTPROCESS mPID;
147
148	/** Current session state */
149	SessionState_T mState;
150
151	/** Session name string (of the primary session) */
152	Utf8Str mName;
153
154	/** Session machine object */
155	ComObjPtr<SessionMachine> mMachine;
156
157	/** Medium object lock collection. */
158	MediumLockListMap mLockedMedia;
159	};
160
161	Data();
162	~Data();
163
164	const Guid mUuid;
165	BOOL mRegistered;
166
167	Utf8Str m_strConfigFile;
168	Utf8Str m_strConfigFileFull;
169
170	// machine settings XML file
171	settings::MachineConfigFile *pMachineConfigFile;
172	uint32_t flModifications;
173	bool m_fAllowStateModification;
174
175	BOOL mAccessible;
176	com::ErrorInfo mAccessError;
177
178	MachineState_T mMachineState;
179	RTTIMESPEC mLastStateChange;
180
181	/* Note: These are guarded by VirtualBoxBase::stateLockHandle() */
182	uint32_t mMachineStateDeps;
183	RTSEMEVENTMULTI mMachineStateDepsSem;
184	uint32_t mMachineStateChangePending;
185
186	BOOL mCurrentStateModified;
187	/** Guest properties have been modified and need saving since the
188	* machine was started, or there are transient properties which need
189	* deleting and the machine is being shut down. */
190	BOOL mGuestPropertiesModified;
191
192	Session mSession;
193
194	ComObjPtr<Snapshot> mFirstSnapshot;
195	ComObjPtr<Snapshot> mCurrentSnapshot;
196
197	// list of files to delete in Delete(); this list is filled by Unregister()
198	std::list<Utf8Str> llFilesToDelete;
199	};
200
201	/**
202	* Saved state data.
203	*
204	* It's actually only the state file path string, but it needs to be
205	* separate from Data, because Machine and SessionMachine instances
206	* share it, while SnapshotMachine does not.
207	*
208	* The data variable is \|mSSData\|.
209	*/
210	struct SSData
211	{
212	Utf8Str strStateFilePath;
213	};
214
215	/**
216	* User changeable machine data.
217	*
218	* This data is common for all machine snapshots, i.e. it is shared
219	* by all SnapshotMachine instances associated with the given machine
220	* using the util::Backupable template through the \|mUserData\| variable.
221	*
222	* SessionMachine instances can alter this data and discard changes.
223	*
224	* @note There is no need to lock anything inside init() or uninit()
225	* methods, because they are always serialized (see AutoCaller).
226	*/
227	struct UserData
228	{
229	settings::MachineUserData s;
230	typedef std::vector<uint8_t> IconBlob;
231	IconBlob mIcon;
232	};
233
234	/**
235	* Hardware data.
236	*
237	* This data is unique for a machine and for every machine snapshot.
238	* Stored using the util::Backupable template in the \|mHWData\| variable.
239	*
240	* SessionMachine instances can alter this data and discard changes.
241	*/
242	struct HWData
243	{
244	/**
245	* Data structure to hold information about a guest property.
246	*/
247	struct GuestProperty {
248	/** Property value */
249	Utf8Str strValue;
250	/** Property timestamp */
251	LONG64 mTimestamp;
252	/** Property flags */
253	ULONG mFlags;
254	};
255
256	HWData();
257	~HWData();
258
259	Bstr mHWVersion;
260	Guid mHardwareUUID; /*< If Null, use mData.mUuid. /
261	ULONG mMemorySize;
262	ULONG mMemoryBalloonSize;
263	BOOL mPageFusionEnabled;
264	GraphicsControllerType_T mGraphicsControllerType;
265	ULONG mVRAMSize;
266	ULONG mVideoCaptureWidth;
267	ULONG mVideoCaptureHeight;
268	ULONG mVideoCaptureRate;
269	ULONG mVideoCaptureFPS;
270	ULONG mVideoCaptureMaxTime;
271	ULONG mVideoCaptureMaxFileSize;
272	Utf8Str mVideoCaptureOptions;
273	Utf8Str mVideoCaptureFile;
274	BOOL mVideoCaptureEnabled;
275	BOOL maVideoCaptureScreens[SchemaDefs::MaxGuestMonitors];
276	ULONG mMonitorCount;
277	BOOL mHWVirtExEnabled;
278	BOOL mHWVirtExNestedPagingEnabled;
279	BOOL mHWVirtExLargePagesEnabled;
280	BOOL mHWVirtExVPIDEnabled;
281	BOOL mHWVirtExUXEnabled;
282	BOOL mHWVirtExForceEnabled;
283	BOOL mAccelerate2DVideoEnabled;
284	BOOL mPAEEnabled;
285	settings::Hardware::LongModeType mLongMode;
286	BOOL mTripleFaultReset;
287	ULONG mCPUCount;
288	BOOL mCPUHotPlugEnabled;
289	ULONG mCpuExecutionCap;
290	uint32_t mCpuIdPortabilityLevel;
291	BOOL mAccelerate3DEnabled;
292	BOOL mHPETEnabled;
293
294	BOOL mCPUAttached[SchemaDefs::MaxCPUCount];
295
296	settings::CpuIdLeaf mCpuIdStdLeafs[11];
297	settings::CpuIdLeaf mCpuIdExtLeafs[11];
298
299	DeviceType_T mBootOrder[SchemaDefs::MaxBootPosition];
300
301	typedef std::list<ComObjPtr<SharedFolder> > SharedFolderList;
302	SharedFolderList mSharedFolders;
303
304	ClipboardMode_T mClipboardMode;
305	DnDMode_T mDnDMode;
306
307	typedef std::map<Utf8Str, GuestProperty> GuestPropertyMap;
308	GuestPropertyMap mGuestProperties;
309
310	FirmwareType_T mFirmwareType;
311	KeyboardHIDType_T mKeyboardHIDType;
312	PointingHIDType_T mPointingHIDType;
313	ChipsetType_T mChipsetType;
314	ParavirtProvider_T mParavirtProvider;
315	BOOL mEmulatedUSBCardReaderEnabled;
316
317	BOOL mIOCacheEnabled;
318	ULONG mIOCacheSize;
319
320	typedef std::list<ComObjPtr<PCIDeviceAttachment> > PCIDeviceAssignmentList;
321	PCIDeviceAssignmentList mPCIDeviceAssignments;
322
323	settings::Debugging mDebugging;
324	settings::Autostart mAutostart;
325
326	Utf8Str mDefaultFrontend;
327	};
328
329	/**
330	* Hard disk and other media data.
331	*
332	* The usage policy is the same as for HWData, but a separate structure
333	* is necessary because hard disk data requires different procedures when
334	* taking or deleting snapshots, etc.
335	*
336	* The data variable is \|mMediaData\|.
337	*/
338	struct MediaData
339	{
340	MediaData();
341	~MediaData();
342
343	typedef std::list<ComObjPtr<MediumAttachment> > AttachmentList;
344	AttachmentList mAttachments;
345	};
346
347	DECLARE_EMPTY_CTOR_DTOR(Machine)
348
349	HRESULT FinalConstruct();
350	void FinalRelease();
351
352	// public initializer/uninitializer for internal purposes only:
353
354	// initializer for creating a new, empty machine
355	HRESULT init(VirtualBox *aParent,
356	const Utf8Str &strConfigFile,
357	const Utf8Str &strName,
358	const StringsList &llGroups,
359	GuestOSType *aOsType,
360	const Guid &aId,
361	bool fForceOverwrite,
362	bool fDirectoryIncludesUUID);
363
364	// initializer for loading existing machine XML (either registered or not)
365	HRESULT initFromSettings(VirtualBox *aParent,
366	const Utf8Str &strConfigFile,
367	const Guid *aId);
368
369	// initializer for machine config in memory (OVF import)
370	HRESULT init(VirtualBox *aParent,
371	const Utf8Str &strName,
372	const settings::MachineConfigFile &config);
373
374	void uninit();
375
376	#ifdef VBOX_WITH_RESOURCE_USAGE_API
377	// Needed from VirtualBox, for the delayed metrics cleanup.
378	void i_unregisterMetrics(PerformanceCollector aCollector, Machine aMachine);
379	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
380
381	protected:
382	HRESULT initImpl(VirtualBox *aParent,
383	const Utf8Str &strConfigFile);
384	HRESULT initDataAndChildObjects();
385	HRESULT i_registeredInit();
386	HRESULT i_tryCreateMachineConfigFile(bool fForceOverwrite);
387	void uninitDataAndChildObjects();
388
389	public:
390
391
392	// public methods only for internal purposes
393
394	virtual bool i_isSnapshotMachine() const
395	{
396	return false;
397	}
398
399	virtual bool i_isSessionMachine() const
400	{
401	return false;
402	}
403
404	/**
405	* Override of the default locking class to be used for validating lock
406	* order with the standard member lock handle.
407	*/
408	virtual VBoxLockingClass getLockingClass() const
409	{
410	return LOCKCLASS_MACHINEOBJECT;
411	}
412
413	/// @todo (dmik) add lock and make non-inlined after revising classes
414	// that use it. Note: they should enter Machine lock to keep the returned
415	// information valid!
416	bool i_isRegistered() { return !!mData->mRegistered; }
417
418	// unsafe inline public methods for internal purposes only (ensure there is
419	// a caller and a read lock before calling them!)
420
421	/**
422	* Returns the VirtualBox object this machine belongs to.
423	*
424	* @note This method doesn't check this object's readiness. Intended to be
425	* used by ready Machine children (whose readiness is bound to the parent's
426	* one) or after doing addCaller() manually.
427	*/
428	VirtualBox* i_getVirtualBox() const { return mParent; }
429
430	/**
431	* Checks if this machine is accessible, without attempting to load the
432	* config file.
433	*
434	* @note This method doesn't check this object's readiness. Intended to be
435	* used by ready Machine children (whose readiness is bound to the parent's
436	* one) or after doing addCaller() manually.
437	*/
438	bool i_isAccessible() const { return !!mData->mAccessible; }
439
440	/**
441	* Returns this machine ID.
442	*
443	* @note This method doesn't check this object's readiness. Intended to be
444	* used by ready Machine children (whose readiness is bound to the parent's
445	* one) or after adding a caller manually.
446	*/
447	const Guid& i_getId() const { return mData->mUuid; }
448
449	/**
450	* Returns the snapshot ID this machine represents or an empty UUID if this
451	* instance is not SnapshotMachine.
452	*
453	* @note This method doesn't check this object's readiness. Intended to be
454	* used by ready Machine children (whose readiness is bound to the parent's
455	* one) or after adding a caller manually.
456	*/
457	inline const Guid& i_getSnapshotId() const;
458
459	/**
460	* Returns this machine's full settings file path.
461	*
462	* @note This method doesn't lock this object or check its readiness.
463	* Intended to be used only after doing addCaller() manually and locking it
464	* for reading.
465	*/
466	const Utf8Str& i_getSettingsFileFull() const { return mData->m_strConfigFileFull; }
467
468	/**
469	* Returns this machine name.
470	*
471	* @note This method doesn't lock this object or check its readiness.
472	* Intended to be used only after doing addCaller() manually and locking it
473	* for reading.
474	*/
475	const Utf8Str& i_getName() const { return mUserData->s.strName; }
476
477	enum
478	{
479	IsModified_MachineData = 0x0001,
480	IsModified_Storage = 0x0002,
481	IsModified_NetworkAdapters = 0x0008,
482	IsModified_SerialPorts = 0x0010,
483	IsModified_ParallelPorts = 0x0020,
484	IsModified_VRDEServer = 0x0040,
485	IsModified_AudioAdapter = 0x0080,
486	IsModified_USB = 0x0100,
487	IsModified_BIOS = 0x0200,
488	IsModified_SharedFolders = 0x0400,
489	IsModified_Snapshots = 0x0800,
490	IsModified_BandwidthControl = 0x1000
491	};
492
493	/**
494	* Returns various information about this machine.
495	*
496	* @note This method doesn't lock this object or check its readiness.
497	* Intended to be used only after doing addCaller() manually and locking it
498	* for reading.
499	*/
500	ChipsetType_T i_getChipsetType() const { return mHWData->mChipsetType; }
501	ParavirtProvider_T i_getParavirtProvider() const { return mHWData->mParavirtProvider; }
502
503	void i_setModified(uint32_t fl, bool fAllowStateModification = true);
504	void i_setModifiedLock(uint32_t fl, bool fAllowStateModification = true);
505
506	bool i_isStateModificationAllowed() const { return mData->m_fAllowStateModification; }
507	void i_allowStateModification() { mData->m_fAllowStateModification = true; }
508	void i_disallowStateModification() { mData->m_fAllowStateModification = false; }
509
510	const StringsList &i_getGroups() const { return mUserData->s.llGroups; }
511
512	// callback handlers
513	virtual HRESULT i_onNetworkAdapterChange(INetworkAdapter * /* networkAdapter /, BOOL / changeAdapter */) { return S_OK; }
514	virtual HRESULT i_onNATRedirectRuleChange(ULONG /* slot /, BOOL / fRemove / , IN_BSTR / name */,
515	NATProtocol_T /* protocol /, IN_BSTR / host ip /, LONG / host port */,
516	IN_BSTR /* guest port /, LONG / guest port */ ) { return S_OK; }
517	virtual HRESULT i_onSerialPortChange(ISerialPort * /* serialPort */) { return S_OK; }
518	virtual HRESULT i_onParallelPortChange(IParallelPort * /* parallelPort */) { return S_OK; }
519	virtual HRESULT i_onVRDEServerChange(BOOL /* aRestart */) { return S_OK; }
520	virtual HRESULT i_onUSBControllerChange() { return S_OK; }
521	virtual HRESULT i_onStorageControllerChange() { return S_OK; }
522	virtual HRESULT i_onCPUChange(ULONG /* aCPU /, BOOL / aRemove */) { return S_OK; }
523	virtual HRESULT i_onCPUExecutionCapChange(ULONG /* aExecutionCap */) { return S_OK; }
524	virtual HRESULT i_onMediumChange(IMediumAttachment * /* mediumAttachment /, BOOL / force */) { return S_OK; }
525	virtual HRESULT i_onSharedFolderChange() { return S_OK; }
526	virtual HRESULT i_onClipboardModeChange(ClipboardMode_T /* aClipboardMode */) { return S_OK; }
527	virtual HRESULT i_onDnDModeChange(DnDMode_T /* aDnDMode */) { return S_OK; }
528	virtual HRESULT i_onBandwidthGroupChange(IBandwidthGroup * /* aBandwidthGroup */) { return S_OK; }
529	virtual HRESULT i_onStorageDeviceChange(IMediumAttachment * /* mediumAttachment /, BOOL / remove */,
530	BOOL /* silent */) { return S_OK; }
531	virtual HRESULT i_onVideoCaptureChange() { return S_OK; }
532
533	HRESULT i_saveRegistryEntry(settings::MachineRegistryEntry &data);
534
535	int i_calculateFullPath(const Utf8Str &strPath, Utf8Str &aResult);
536	void i_copyPathRelativeToMachine(const Utf8Str &strSource, Utf8Str &strTarget);
537
538	void i_getLogFolder(Utf8Str &aLogFolder);
539	Utf8Str i_queryLogFilename(ULONG idx);
540	Utf8Str i_getStartupLogFilename(void);
541
542	void i_composeSavedStateFilename(Utf8Str &strStateFilePath);
543
544	void i_getDefaultVideoCaptureFile(Utf8Str &strFile);
545
546	bool i_isUSBControllerPresent();
547
548	HRESULT i_launchVMProcess(IInternalSessionControl *aControl,
549	const Utf8Str &strType,
550	const Utf8Str &strEnvironment,
551	ProgressProxy *aProgress);
552
553	HRESULT i_getDirectControl(ComPtr<IInternalSessionControl> *directControl)
554	{
555	HRESULT rc;
556	*directControl = mData->mSession.mDirectControl;
557
558	if (!*directControl)
559	rc = E_ACCESSDENIED;
560	else
561	rc = S_OK;
562
563	return rc;
564	}
565
566	bool i_isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
567	ComPtr<IInternalSessionControl> *aControl = NULL,
568	bool aAllowClosing = false);
569	bool i_isSessionSpawning();
570
571	bool i_isSessionOpenOrClosing(ComObjPtr<SessionMachine> &aMachine,
572	ComPtr<IInternalSessionControl> *aControl = NULL)
573	{ return i_isSessionOpen(aMachine, aControl, true /* aAllowClosing */); }
574
575	bool i_checkForSpawnFailure();
576
577	HRESULT i_prepareRegister();
578
579	HRESULT i_getSharedFolder(CBSTR aName,
580	ComObjPtr<SharedFolder> &aSharedFolder,
581	bool aSetError = false)
582	{
583	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
584	return i_findSharedFolder(aName, aSharedFolder, aSetError);
585	}
586
587	HRESULT i_addStateDependency(StateDependency aDepType = AnyStateDep,
588	MachineState_T *aState = NULL,
589	BOOL *aRegistered = NULL);
590	void i_releaseStateDependency();
591
592	HRESULT i_getStorageControllerByName(const Utf8Str &aName,
593	ComObjPtr<StorageController> &aStorageController,
594	bool aSetError = false);
595
596	HRESULT i_getUSBControllerByName(const Utf8Str &aName,
597	ComObjPtr<USBController> &aUSBController,
598	bool aSetError = false);
599
600	HRESULT i_getBandwidthGroup(const Utf8Str &strBandwidthGroup,
601	ComObjPtr<BandwidthGroup> &pBandwidthGroup,
602	bool fSetError = false)
603	{
604	return mBandwidthControl->i_getBandwidthGroupByName(strBandwidthGroup,
605	pBandwidthGroup,
606	fSetError);
607	}
608
609	static HRESULT i_setErrorStatic(HRESULT aResultCode, const char *pcszMsg, ...);
610
611	protected:
612
613	class ClientToken;
614
615	HRESULT i_checkStateDependency(StateDependency aDepType);
616
617	Machine *i_getMachine();
618
619	void i_ensureNoStateDependencies();
620
621	virtual HRESULT i_setMachineState(MachineState_T aMachineState);
622
623	HRESULT i_findSharedFolder(const Utf8Str &aName,
624	ComObjPtr<SharedFolder> &aSharedFolder,
625	bool aSetError = false);
626
627	HRESULT i_loadSettings(bool aRegistered);
628	HRESULT i_loadMachineDataFromSettings(const settings::MachineConfigFile &config,
629	const Guid *puuidRegistry);
630	HRESULT i_loadSnapshot(const settings::Snapshot &data,
631	const Guid &aCurSnapshotId,
632	Snapshot *aParentSnapshot);
633	HRESULT i_loadHardware(const settings::Hardware &data, const settings::Debugging *pDbg,
634	const settings::Autostart *pAutostart);
635	HRESULT i_loadDebugging(const settings::Debugging *pDbg);
636	HRESULT i_loadAutostart(const settings::Autostart *pAutostart);
637	HRESULT i_loadStorageControllers(const settings::Storage &data,
638	const Guid *puuidRegistry,
639	const Guid *puuidSnapshot);
640	HRESULT i_loadStorageDevices(StorageController *aStorageController,
641	const settings::StorageController &data,
642	const Guid *puuidRegistry,
643	const Guid *puuidSnapshot);
644
645	HRESULT i_findSnapshotById(const Guid &aId,
646	ComObjPtr<Snapshot> &aSnapshot,
647	bool aSetError = false);
648	HRESULT i_findSnapshotByName(const Utf8Str &strName,
649	ComObjPtr<Snapshot> &aSnapshot,
650	bool aSetError = false);
651
652	HRESULT i_getMediumAttachmentsOfController(const Utf8Str &aName,
653	MediaData::AttachmentList &aAttachments);
654
655	ULONG i_getUSBControllerCountByType(USBControllerType_T enmType);
656
657	enum
658	{
659	/* flags for #saveSettings() */
660	SaveS_ResetCurStateModified = 0x01,
661	SaveS_InformCallbacksAnyway = 0x02,
662	SaveS_Force = 0x04,
663	/* flags for #saveStateSettings() */
664	SaveSTS_CurStateModified = 0x20,
665	SaveSTS_StateFilePath = 0x40,
666	SaveSTS_StateTimeStamp = 0x80
667	};
668
669	HRESULT i_prepareSaveSettings(bool *pfNeedsGlobalSaveSettings);
670	HRESULT i_saveSettings(bool *pfNeedsGlobalSaveSettings, int aFlags = 0);
671
672	void i_copyMachineDataToSettings(settings::MachineConfigFile &config);
673	HRESULT i_saveAllSnapshots(settings::MachineConfigFile &config);
674	HRESULT i_saveHardware(settings::Hardware &data, settings::Debugging *pDbg,
675	settings::Autostart *pAutostart);
676	HRESULT i_saveStorageControllers(settings::Storage &data);
677	HRESULT i_saveStorageDevices(ComObjPtr<StorageController> aStorageController,
678	settings::StorageController &data);
679	HRESULT i_saveStateSettings(int aFlags);
680
681	void i_addMediumToRegistry(ComObjPtr<Medium> &pMedium);
682
683	HRESULT i_createImplicitDiffs(IProgress *aProgress,
684	ULONG aWeight,
685	bool aOnline);
686	HRESULT i_deleteImplicitDiffs(bool aOnline);
687
688	MediumAttachment* i_findAttachment(const MediaData::AttachmentList &ll,
689	IN_BSTR aControllerName,
690	LONG aControllerPort,
691	LONG aDevice);
692	MediumAttachment* i_findAttachment(const MediaData::AttachmentList &ll,
693	ComObjPtr<Medium> pMedium);
694	MediumAttachment* i_findAttachment(const MediaData::AttachmentList &ll,
695	Guid &id);
696
697	HRESULT i_detachDevice(MediumAttachment *pAttach,
698	AutoWriteLock &writeLock,
699	Snapshot *pSnapshot);
700
701	HRESULT i_detachAllMedia(AutoWriteLock &writeLock,
702	Snapshot *pSnapshot,
703	CleanupMode_T cleanupMode,
704	MediaList &llMedia);
705
706	void i_commitMedia(bool aOnline = false);
707	void i_rollbackMedia();
708
709	bool i_isInOwnDir(Utf8Str *aSettingsDir = NULL) const;
710
711	void i_rollback(bool aNotify);
712	void i_commit();
713	void i_copyFrom(Machine *aThat);
714	bool i_isControllerHotplugCapable(StorageControllerType_T enmCtrlType);
715
716	Utf8Str i_getExtraData(const Utf8Str &strKey);
717
718	#ifdef VBOX_WITH_GUEST_PROPS
719	HRESULT i_getGuestPropertyFromService(const com::Utf8Str &aName, com::Utf8Str &aValue,
720	LONG64 *aTimestamp, com::Utf8Str &aFlags) const;
721	HRESULT i_setGuestPropertyToService(const com::Utf8Str &aName, const com::Utf8Str &aValue,
722	const com::Utf8Str &aFlags, bool fDelete);
723	HRESULT i_getGuestPropertyFromVM(const com::Utf8Str &aName, com::Utf8Str &aValue,
724	LONG64 *aTimestamp, com::Utf8Str &aFlags) const;
725	HRESULT i_setGuestPropertyToVM(const com::Utf8Str &aName, const com::Utf8Str &aValue,
726	const com::Utf8Str &aFlags, bool fDelete);
727	HRESULT i_enumerateGuestPropertiesInService(const com::Utf8Str &aPatterns,
728	std::vector<com::Utf8Str> &aNames,
729	std::vector<com::Utf8Str> &aValues,
730	std::vector<LONG64> &aTimestamps,
731	std::vector<com::Utf8Str> &aFlags);
732	HRESULT i_enumerateGuestPropertiesOnVM(const com::Utf8Str &aPatterns,
733	std::vector<com::Utf8Str> &aNames,
734	std::vector<com::Utf8Str> &aValues,
735	std::vector<LONG64> &aTimestamps,
736	std::vector<com::Utf8Str> &aFlags);
737
738	#endif /* VBOX_WITH_GUEST_PROPS */
739
740	#ifdef VBOX_WITH_RESOURCE_USAGE_API
741	void i_getDiskList(MediaList &list);
742	void i_registerMetrics(PerformanceCollector aCollector, Machine aMachine, RTPROCESS pid);
743
744	pm::CollectorGuest *mCollectorGuest;
745	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
746
747	Machine * const mPeer;
748
749	VirtualBox * const mParent;
750
751	Shareable<Data> mData;
752	Shareable<SSData> mSSData;
753
754	Backupable<UserData> mUserData;
755	Backupable<HWData> mHWData;
756	Backupable<MediaData> mMediaData;
757
758	// the following fields need special backup/rollback/commit handling,
759	// so they cannot be a part of HWData
760
761	const ComObjPtr<VRDEServer> mVRDEServer;
762	const ComObjPtr<SerialPort> mSerialPorts[SchemaDefs::SerialPortCount];
763	const ComObjPtr<ParallelPort> mParallelPorts[SchemaDefs::ParallelPortCount];
764	const ComObjPtr<AudioAdapter> mAudioAdapter;
765	const ComObjPtr<USBDeviceFilters> mUSBDeviceFilters;
766	const ComObjPtr<BIOSSettings> mBIOSSettings;
767	const ComObjPtr<BandwidthControl> mBandwidthControl;
768
769	typedef std::vector<ComObjPtr<NetworkAdapter> > NetworkAdapterVector;
770	NetworkAdapterVector mNetworkAdapters;
771
772	typedef std::list<ComObjPtr<StorageController> > StorageControllerList;
773	Backupable<StorageControllerList> mStorageControllers;
774
775	typedef std::list<ComObjPtr<USBController> > USBControllerList;
776	Backupable<USBControllerList> mUSBControllers;
777
778	uint64_t uRegistryNeedsSaving;
779
780	/**
781	* Abstract base class for all Machine or SessionMachine related
782	* asynchronous tasks. This is necessary since RTThreadCreate cannot call
783	* a (non-static) method as its thread function, so instead we have it call
784	* the static Machine::taskHandler, which then calls the handler() method
785	* in here (implemented by the subclasses).
786	*/
787	struct Task
788	{
789	Task(Machine m, Progress p, const Utf8Str &t)
790	: m_pMachine(m),
791	m_machineCaller(m),
792	m_pProgress(p),
793	m_strTaskName(t),
794	m_machineStateBackup(m->mData->mMachineState) // save the current machine state
795	{}
796
797	HRESULT createThread()
798	{
799	int vrc = RTThreadCreate(NULL,
800	taskHandler,
801	(void *)this,
802	0,
803	RTTHREADTYPE_MAIN_WORKER,
804	0,
805	m_strTaskName.c_str());
806	if (RT_FAILURE(vrc))
807	{
808	HRESULT rc = Machine::i_setErrorStatic(E_FAIL, Machine::tr("Could not create thread \"%s\" (%Rrc)"), m_strTaskName.c_str(), vrc);
809	delete this;
810	return rc;
811	}
812	return S_OK;
813	}
814
815	void modifyBackedUpState(MachineState_T s)
816	{
817	const_cast<MachineState_T >(&m_machineStateBackup) = s;
818	}
819
820	virtual void handler() = 0;
821
822	ComObjPtr<Machine> m_pMachine;
823	AutoCaller m_machineCaller;
824	ComObjPtr<Progress> m_pProgress;
825	Utf8Str m_strTaskName;
826	const MachineState_T m_machineStateBackup;
827	};
828
829	struct DeleteConfigTask;
830	void i_deleteConfigHandler(DeleteConfigTask &task);
831
832	static DECLCALLBACK(int) taskHandler(RTTHREAD thread, void *pvUser);
833
834	friend class SessionMachine;
835	friend class SnapshotMachine;
836	friend class Appliance;
837	friend class VirtualBox;
838
839	friend class MachineCloneVM;
840
841	private:
842	// wrapped IMachine properties
843	HRESULT getParent(ComPtr<IVirtualBox> &aParent);
844	HRESULT getIcon(std::vector<BYTE> &aIcon);
845	HRESULT setIcon(const std::vector<BYTE> &aIcon);
846	HRESULT getAccessible(BOOL *aAccessible);
847	HRESULT getAccessError(ComPtr<IVirtualBoxErrorInfo> &aAccessError);
848	HRESULT getName(com::Utf8Str &aName);
849	HRESULT setName(const com::Utf8Str &aName);
850	HRESULT getDescription(com::Utf8Str &aDescription);
851	HRESULT setDescription(const com::Utf8Str &aDescription);
852	HRESULT getId(com::Guid &aId);
853	HRESULT getGroups(std::vector<com::Utf8Str> &aGroups);
854	HRESULT setGroups(const std::vector<com::Utf8Str> &aGroups);
855	HRESULT getOSTypeId(com::Utf8Str &aOSTypeId);
856	HRESULT setOSTypeId(const com::Utf8Str &aOSTypeId);
857	HRESULT getHardwareVersion(com::Utf8Str &aHardwareVersion);
858	HRESULT setHardwareVersion(const com::Utf8Str &aHardwareVersion);
859	HRESULT getHardwareUUID(com::Guid &aHardwareUUID);
860	HRESULT setHardwareUUID(const com::Guid &aHardwareUUID);
861	HRESULT getCPUCount(ULONG *aCPUCount);
862	HRESULT setCPUCount(ULONG aCPUCount);
863	HRESULT getCPUHotPlugEnabled(BOOL *aCPUHotPlugEnabled);
864	HRESULT setCPUHotPlugEnabled(BOOL aCPUHotPlugEnabled);
865	HRESULT getCPUExecutionCap(ULONG *aCPUExecutionCap);
866	HRESULT setCPUExecutionCap(ULONG aCPUExecutionCap);
867	HRESULT getCPUIDPortabilityLevel(ULONG *aCPUIDPortabilityLevel);
868	HRESULT setCPUIDPortabilityLevel(ULONG aCPUIDPortabilityLevel);
869	HRESULT getMemorySize(ULONG *aMemorySize);
870	HRESULT setMemorySize(ULONG aMemorySize);
871	HRESULT getMemoryBalloonSize(ULONG *aMemoryBalloonSize);
872	HRESULT setMemoryBalloonSize(ULONG aMemoryBalloonSize);
873	HRESULT getPageFusionEnabled(BOOL *aPageFusionEnabled);
874	HRESULT setPageFusionEnabled(BOOL aPageFusionEnabled);
875	HRESULT getGraphicsControllerType(GraphicsControllerType_T *aGraphicsControllerType);
876	HRESULT setGraphicsControllerType(GraphicsControllerType_T aGraphicsControllerType);
877	HRESULT getVRAMSize(ULONG *aVRAMSize);
878	HRESULT setVRAMSize(ULONG aVRAMSize);
879	HRESULT getAccelerate3DEnabled(BOOL *aAccelerate3DEnabled);
880	HRESULT setAccelerate3DEnabled(BOOL aAccelerate3DEnabled);
881	HRESULT getAccelerate2DVideoEnabled(BOOL *aAccelerate2DVideoEnabled);
882	HRESULT setAccelerate2DVideoEnabled(BOOL aAccelerate2DVideoEnabled);
883	HRESULT getMonitorCount(ULONG *aMonitorCount);
884	HRESULT setMonitorCount(ULONG aMonitorCount);
885	HRESULT getVideoCaptureEnabled(BOOL *aVideoCaptureEnabled);
886	HRESULT setVideoCaptureEnabled(BOOL aVideoCaptureEnabled);
887	HRESULT getVideoCaptureScreens(std::vector<BOOL> &aVideoCaptureScreens);
888	HRESULT setVideoCaptureScreens(const std::vector<BOOL> &aVideoCaptureScreens);
889	HRESULT getVideoCaptureFile(com::Utf8Str &aVideoCaptureFile);
890	HRESULT setVideoCaptureFile(const com::Utf8Str &aVideoCaptureFile);
891	HRESULT getVideoCaptureWidth(ULONG *aVideoCaptureWidth);
892	HRESULT setVideoCaptureWidth(ULONG aVideoCaptureWidth);
893	HRESULT getVideoCaptureHeight(ULONG *aVideoCaptureHeight);
894	HRESULT setVideoCaptureHeight(ULONG aVideoCaptureHeight);
895	HRESULT getVideoCaptureRate(ULONG *aVideoCaptureRate);
896	HRESULT setVideoCaptureRate(ULONG aVideoCaptureRate);
897	HRESULT getVideoCaptureFPS(ULONG *aVideoCaptureFPS);
898	HRESULT setVideoCaptureFPS(ULONG aVideoCaptureFPS);
899	HRESULT getVideoCaptureMaxTime(ULONG *aVideoCaptureMaxTime);
900	HRESULT setVideoCaptureMaxTime(ULONG aVideoCaptureMaxTime);
901	HRESULT getVideoCaptureMaxFileSize(ULONG *aVideoCaptureMaxFileSize);
902	HRESULT setVideoCaptureMaxFileSize(ULONG aVideoCaptureMaxFileSize);
903	HRESULT getVideoCaptureOptions(com::Utf8Str &aVideoCaptureOptions);
904	HRESULT setVideoCaptureOptions(const com::Utf8Str &aVideoCaptureOptions);
905	HRESULT getBIOSSettings(ComPtr<IBIOSSettings> &aBIOSSettings);
906	HRESULT getFirmwareType(FirmwareType_T *aFirmwareType);
907	HRESULT setFirmwareType(FirmwareType_T aFirmwareType);
908	HRESULT getPointingHIDType(PointingHIDType_T *aPointingHIDType);
909	HRESULT setPointingHIDType(PointingHIDType_T aPointingHIDType);
910	HRESULT getKeyboardHIDType(KeyboardHIDType_T *aKeyboardHIDType);
911	HRESULT setKeyboardHIDType(KeyboardHIDType_T aKeyboardHIDType);
912	HRESULT getHPETEnabled(BOOL *aHPETEnabled);
913	HRESULT setHPETEnabled(BOOL aHPETEnabled);
914	HRESULT getChipsetType(ChipsetType_T *aChipsetType);
915	HRESULT setChipsetType(ChipsetType_T aChipsetType);
916	HRESULT getSnapshotFolder(com::Utf8Str &aSnapshotFolder);
917	HRESULT setSnapshotFolder(const com::Utf8Str &aSnapshotFolder);
918	HRESULT getVRDEServer(ComPtr<IVRDEServer> &aVRDEServer);
919	HRESULT getEmulatedUSBCardReaderEnabled(BOOL *aEmulatedUSBCardReaderEnabled);
920	HRESULT setEmulatedUSBCardReaderEnabled(BOOL aEmulatedUSBCardReaderEnabled);
921	HRESULT getMediumAttachments(std::vector<ComPtr<IMediumAttachment> > &aMediumAttachments);
922	HRESULT getUSBControllers(std::vector<ComPtr<IUSBController> > &aUSBControllers);
923	HRESULT getUSBDeviceFilters(ComPtr<IUSBDeviceFilters> &aUSBDeviceFilters);
924	HRESULT getAudioAdapter(ComPtr<IAudioAdapter> &aAudioAdapter);
925	HRESULT getStorageControllers(std::vector<ComPtr<IStorageController> > &aStorageControllers);
926	HRESULT getSettingsFilePath(com::Utf8Str &aSettingsFilePath);
927	HRESULT getSettingsModified(BOOL *aSettingsModified);
928	HRESULT getSessionState(SessionState_T *aSessionState);
929	HRESULT getSessionType(SessionType_T *aSessionType);
930	HRESULT getSessionName(com::Utf8Str &aSessionType);
931	HRESULT getSessionPID(ULONG *aSessionPID);
932	HRESULT getState(MachineState_T *aState);
933	HRESULT getLastStateChange(LONG64 *aLastStateChange);
934	HRESULT getStateFilePath(com::Utf8Str &aStateFilePath);
935	HRESULT getLogFolder(com::Utf8Str &aLogFolder);
936	HRESULT getCurrentSnapshot(ComPtr<ISnapshot> &aCurrentSnapshot);
937	HRESULT getSnapshotCount(ULONG *aSnapshotCount);
938	HRESULT getCurrentStateModified(BOOL *aCurrentStateModified);
939	HRESULT getSharedFolders(std::vector<ComPtr<ISharedFolder> > &aSharedFolders);
940	HRESULT getClipboardMode(ClipboardMode_T *aClipboardMode);
941	HRESULT setClipboardMode(ClipboardMode_T aClipboardMode);
942	HRESULT getDnDMode(DnDMode_T *aDnDMode);
943	HRESULT setDnDMode(DnDMode_T aDnDMode);
944	HRESULT getTeleporterEnabled(BOOL *aTeleporterEnabled);
945	HRESULT setTeleporterEnabled(BOOL aTeleporterEnabled);
946	HRESULT getTeleporterPort(ULONG *aTeleporterPort);
947	HRESULT setTeleporterPort(ULONG aTeleporterPort);
948	HRESULT getTeleporterAddress(com::Utf8Str &aTeleporterAddress);
949	HRESULT setTeleporterAddress(const com::Utf8Str &aTeleporterAddress);
950	HRESULT getTeleporterPassword(com::Utf8Str &aTeleporterPassword);
951	HRESULT setTeleporterPassword(const com::Utf8Str &aTeleporterPassword);
952	HRESULT getParavirtProvider(ParavirtProvider_T *aParavirtProvider);
953	HRESULT setParavirtProvider(ParavirtProvider_T aParavirtProvider);
954	HRESULT getFaultToleranceState(FaultToleranceState_T *aFaultToleranceState);
955	HRESULT setFaultToleranceState(FaultToleranceState_T aFaultToleranceState);
956	HRESULT getFaultTolerancePort(ULONG *aFaultTolerancePort);
957	HRESULT setFaultTolerancePort(ULONG aFaultTolerancePort);
958	HRESULT getFaultToleranceAddress(com::Utf8Str &aFaultToleranceAddress);
959	HRESULT setFaultToleranceAddress(const com::Utf8Str &aFaultToleranceAddress);
960	HRESULT getFaultTolerancePassword(com::Utf8Str &aFaultTolerancePassword);
961	HRESULT setFaultTolerancePassword(const com::Utf8Str &aFaultTolerancePassword);
962	HRESULT getFaultToleranceSyncInterval(ULONG *aFaultToleranceSyncInterval);
963	HRESULT setFaultToleranceSyncInterval(ULONG aFaultToleranceSyncInterval);
964	HRESULT getRTCUseUTC(BOOL *aRTCUseUTC);
965	HRESULT setRTCUseUTC(BOOL aRTCUseUTC);
966	HRESULT getIOCacheEnabled(BOOL *aIOCacheEnabled);
967	HRESULT setIOCacheEnabled(BOOL aIOCacheEnabled);
968	HRESULT getIOCacheSize(ULONG *aIOCacheSize);
969	HRESULT setIOCacheSize(ULONG aIOCacheSize);
970	HRESULT getPCIDeviceAssignments(std::vector<ComPtr<IPCIDeviceAttachment> > &aPCIDeviceAssignments);
971	HRESULT getBandwidthControl(ComPtr<IBandwidthControl> &aBandwidthControl);
972	HRESULT getTracingEnabled(BOOL *aTracingEnabled);
973	HRESULT setTracingEnabled(BOOL aTracingEnabled);
974	HRESULT getTracingConfig(com::Utf8Str &aTracingConfig);
975	HRESULT setTracingConfig(const com::Utf8Str &aTracingConfig);
976	HRESULT getAllowTracingToAccessVM(BOOL *aAllowTracingToAccessVM);
977	HRESULT setAllowTracingToAccessVM(BOOL aAllowTracingToAccessVM);
978	HRESULT getAutostartEnabled(BOOL *aAutostartEnabled);
979	HRESULT setAutostartEnabled(BOOL aAutostartEnabled);
980	HRESULT getAutostartDelay(ULONG *aAutostartDelay);
981	HRESULT setAutostartDelay(ULONG aAutostartDelay);
982	HRESULT getAutostopType(AutostopType_T *aAutostopType);
983	HRESULT setAutostopType(AutostopType_T aAutostopType);
984	HRESULT getDefaultFrontend(com::Utf8Str &aDefaultFrontend);
985	HRESULT setDefaultFrontend(const com::Utf8Str &aDefaultFrontend);
986	HRESULT getUSBProxyAvailable(BOOL *aUSBProxyAvailable);
987
988	// wrapped IMachine methods
989	HRESULT lockMachine(const ComPtr<ISession> &aSession,
990	LockType_T aLockType);
991	HRESULT launchVMProcess(const ComPtr<ISession> &aSession,
992	const com::Utf8Str &aType,
993	const com::Utf8Str &aEnvironment,
994	ComPtr<IProgress> &aProgress);
995	HRESULT setBootOrder(ULONG aPosition,
996	DeviceType_T aDevice);
997	HRESULT getBootOrder(ULONG aPosition,
998	DeviceType_T *aDevice);
999	HRESULT attachDevice(const com::Utf8Str &aName,
1000	LONG aControllerPort,
1001	LONG aDevice,
1002	DeviceType_T aType,
1003	const ComPtr<IMedium> &aMedium);
1004	HRESULT attachDeviceWithoutMedium(const com::Utf8Str &aName,
1005	LONG aControllerPort,
1006	LONG aDevice,
1007	DeviceType_T aType);
1008	HRESULT detachDevice(const com::Utf8Str &aName,
1009	LONG aControllerPort,
1010	LONG aDevice);
1011	HRESULT passthroughDevice(const com::Utf8Str &aName,
1012	LONG aControllerPort,
1013	LONG aDevice,
1014	BOOL aPassthrough);
1015	HRESULT temporaryEjectDevice(const com::Utf8Str &aName,
1016	LONG aControllerPort,
1017	LONG aDevice,
1018	BOOL aTemporaryEject);
1019	HRESULT nonRotationalDevice(const com::Utf8Str &aName,
1020	LONG aControllerPort,
1021	LONG aDevice,
1022	BOOL aNonRotational);
1023	HRESULT setAutoDiscardForDevice(const com::Utf8Str &aName,
1024	LONG aControllerPort,
1025	LONG aDevice,
1026	BOOL aDiscard);
1027	HRESULT setHotPluggableForDevice(const com::Utf8Str &aName,
1028	LONG aControllerPort,
1029	LONG aDevice,
1030	BOOL aHotPluggable);
1031	HRESULT setBandwidthGroupForDevice(const com::Utf8Str &aName,
1032	LONG aControllerPort,
1033	LONG aDevice,
1034	const ComPtr<IBandwidthGroup> &aBandwidthGroup);
1035	HRESULT setNoBandwidthGroupForDevice(const com::Utf8Str &aName,
1036	LONG aControllerPort,
1037	LONG aDevice);
1038	HRESULT unmountMedium(const com::Utf8Str &aName,
1039	LONG aControllerPort,
1040	LONG aDevice,
1041	BOOL aForce);
1042	HRESULT mountMedium(const com::Utf8Str &aName,
1043	LONG aControllerPort,
1044	LONG aDevice,
1045	const ComPtr<IMedium> &aMedium,
1046	BOOL aForce);
1047	HRESULT getMedium(const com::Utf8Str &aName,
1048	LONG aControllerPort,
1049	LONG aDevice,
1050	ComPtr<IMedium> &aMedium);
1051	HRESULT getMediumAttachmentsOfController(const com::Utf8Str &aName,
1052	std::vector<ComPtr<IMediumAttachment> > &aMediumAttachments);
1053	HRESULT getMediumAttachment(const com::Utf8Str &aName,
1054	LONG aControllerPort,
1055	LONG aDevice,
1056	ComPtr<IMediumAttachment> &aAttachment);
1057	HRESULT attachHostPCIDevice(LONG aHostAddress,
1058	LONG aDesiredGuestAddress,
1059	BOOL aTryToUnbind);
1060	HRESULT detachHostPCIDevice(LONG aHostAddress);
1061	HRESULT getNetworkAdapter(ULONG aSlot,
1062	ComPtr<INetworkAdapter> &aAdapter);
1063	HRESULT addStorageController(const com::Utf8Str &aName,
1064	StorageBus_T aConnectionType,
1065	ComPtr<IStorageController> &aController);
1066	HRESULT getStorageControllerByName(const com::Utf8Str &aName,
1067	ComPtr<IStorageController> &aStorageController);
1068	HRESULT getStorageControllerByInstance(StorageBus_T aConnectionType,
1069	ULONG aInstance,
1070	ComPtr<IStorageController> &aStorageController);
1071	HRESULT removeStorageController(const com::Utf8Str &aName);
1072	HRESULT setStorageControllerBootable(const com::Utf8Str &aName,
1073	BOOL aBootable);
1074	HRESULT addUSBController(const com::Utf8Str &aName,
1075	USBControllerType_T aType,
1076	ComPtr<IUSBController> &aController);
1077	HRESULT removeUSBController(const com::Utf8Str &aName);
1078	HRESULT getUSBControllerByName(const com::Utf8Str &aName,
1079	ComPtr<IUSBController> &aController);
1080	HRESULT getUSBControllerCountByType(USBControllerType_T aType,
1081	ULONG *aControllers);
1082	HRESULT getSerialPort(ULONG aSlot,
1083	ComPtr<ISerialPort> &aPort);
1084	HRESULT getParallelPort(ULONG aSlot,
1085	ComPtr<IParallelPort> &aPort);
1086	HRESULT getExtraDataKeys(std::vector<com::Utf8Str> &aKeys);
1087	HRESULT getExtraData(const com::Utf8Str &aKey,
1088	com::Utf8Str &aValue);
1089	HRESULT setExtraData(const com::Utf8Str &aKey,
1090	const com::Utf8Str &aValue);
1091	HRESULT getCPUProperty(CPUPropertyType_T aProperty,
1092	BOOL *aValue);
1093	HRESULT setCPUProperty(CPUPropertyType_T aProperty,
1094	BOOL aValue);
1095	HRESULT getCPUIDLeaf(ULONG aId,
1096	ULONG *aValEax,
1097	ULONG *aValEbx,
1098	ULONG *aValEcx,
1099	ULONG *aValEdx);
1100	HRESULT setCPUIDLeaf(ULONG aId,
1101	ULONG aValEax,
1102	ULONG aValEbx,
1103	ULONG aValEcx,
1104	ULONG aValEdx);
1105	HRESULT removeCPUIDLeaf(ULONG aId);
1106	HRESULT removeAllCPUIDLeaves();
1107	HRESULT getHWVirtExProperty(HWVirtExPropertyType_T aProperty,
1108	BOOL *aValue);
1109	HRESULT setHWVirtExProperty(HWVirtExPropertyType_T aProperty,
1110	BOOL aValue);
1111	HRESULT setSettingsFilePath(const com::Utf8Str &aSettingsFilePath,
1112	ComPtr<IProgress> &aProgress);
1113	HRESULT saveSettings();
1114	HRESULT discardSettings();
1115	HRESULT unregister(AutoCaller &aAutoCaller,
1116	CleanupMode_T aCleanupMode,
1117	std::vector<ComPtr<IMedium> > &aMedia);
1118	HRESULT deleteConfig(const std::vector<ComPtr<IMedium> > &aMedia,
1119	ComPtr<IProgress> &aProgress);
1120	HRESULT exportTo(const ComPtr<IAppliance> &aAppliance,
1121	const com::Utf8Str &aLocation,
1122	ComPtr<IVirtualSystemDescription> &aDescription);
1123	HRESULT findSnapshot(const com::Utf8Str &aNameOrId,
1124	ComPtr<ISnapshot> &aSnapshot);
1125	HRESULT createSharedFolder(const com::Utf8Str &aName,
1126	const com::Utf8Str &aHostPath,
1127	BOOL aWritable,
1128	BOOL aAutomount);
1129	HRESULT removeSharedFolder(const com::Utf8Str &aName);
1130	HRESULT canShowConsoleWindow(BOOL *aCanShow);
1131	HRESULT showConsoleWindow(LONG64 *aWinId);
1132	HRESULT getGuestProperty(const com::Utf8Str &aName,
1133	com::Utf8Str &aValue,
1134	LONG64 *aTimestamp,
1135	com::Utf8Str &aFlags);
1136	HRESULT getGuestPropertyValue(const com::Utf8Str &aProperty,
1137	com::Utf8Str &aValue);
1138	HRESULT getGuestPropertyTimestamp(const com::Utf8Str &aProperty,
1139	LONG64 *aValue);
1140	HRESULT setGuestProperty(const com::Utf8Str &aProperty,
1141	const com::Utf8Str &aValue,
1142	const com::Utf8Str &aFlags);
1143	HRESULT setGuestPropertyValue(const com::Utf8Str &aProperty,
1144	const com::Utf8Str &aValue);
1145	HRESULT deleteGuestProperty(const com::Utf8Str &aName);
1146	HRESULT enumerateGuestProperties(const com::Utf8Str &aPatterns,
1147	std::vector<com::Utf8Str> &aNames,
1148	std::vector<com::Utf8Str> &aValues,
1149	std::vector<LONG64> &aTimestamps,
1150	std::vector<com::Utf8Str> &aFlags);
1151	HRESULT querySavedGuestScreenInfo(ULONG aScreenId,
1152	ULONG *aOriginX,
1153	ULONG *aOriginY,
1154	ULONG *aWidth,
1155	ULONG *aHeight,
1156	BOOL *aEnabled);
1157	HRESULT readSavedThumbnailToArray(ULONG aScreenId,
1158	BitmapFormat_T aBitmapFormat,
1159	ULONG *aWidth,
1160	ULONG *aHeight,
1161	std::vector<BYTE> &aData);
1162	HRESULT querySavedScreenshotInfo(ULONG aScreenId,
1163	ULONG *aWidth,
1164	ULONG *aHeight,
1165	std::vector<BitmapFormat_T> &aBitmapFormats);
1166	HRESULT readSavedScreenshotToArray(ULONG aScreenId,
1167	BitmapFormat_T aBitmapFormat,
1168	ULONG *aWidth,
1169	ULONG *aHeight,
1170	std::vector<BYTE> &aData);
1171
1172	HRESULT hotPlugCPU(ULONG aCpu);
1173	HRESULT hotUnplugCPU(ULONG aCpu);
1174	HRESULT getCPUStatus(ULONG aCpu,
1175	BOOL *aAttached);
1176	HRESULT getEffectiveParavirtProvider(ParavirtProvider_T *aParavirtProvider);
1177	HRESULT queryLogFilename(ULONG aIdx,
1178	com::Utf8Str &aFilename);
1179	HRESULT readLog(ULONG aIdx,
1180	LONG64 aOffset,
1181	LONG64 aSize,
1182	std::vector<BYTE> &aData);
1183	HRESULT cloneTo(const ComPtr<IMachine> &aTarget,
1184	CloneMode_T aMode,
1185	const std::vector<CloneOptions_T> &aOptions,
1186	ComPtr<IProgress> &aProgress);
1187	HRESULT saveState(ComPtr<IProgress> &aProgress);
1188	HRESULT adoptSavedState(const com::Utf8Str &aSavedStateFile);
1189	HRESULT discardSavedState(BOOL aFRemoveFile);
1190	HRESULT takeSnapshot(const com::Utf8Str &aName,
1191	const com::Utf8Str &aDescription,
1192	BOOL aPause,
1193	com::Guid &aId,
1194	ComPtr<IProgress> &aProgress);
1195	HRESULT deleteSnapshot(const com::Guid &aId,
1196	ComPtr<IProgress> &aProgress);
1197	HRESULT deleteSnapshotAndAllChildren(const com::Guid &aId,
1198	ComPtr<IProgress> &aProgress);
1199	HRESULT deleteSnapshotRange(const com::Guid &aStartId,
1200	const com::Guid &aEndId,
1201	ComPtr<IProgress> &aProgress);
1202	HRESULT restoreSnapshot(const ComPtr<ISnapshot> &aSnapshot,
1203	ComPtr<IProgress> &aProgress);
1204
1205	// wrapped IInternalMachineControl properties
1206
1207	// wrapped IInternalMachineControl methods
1208	HRESULT updateState(MachineState_T aState);
1209	HRESULT beginPowerUp(const ComPtr<IProgress> &aProgress);
1210	HRESULT endPowerUp(LONG aResult);
1211	HRESULT beginPoweringDown(ComPtr<IProgress> &aProgress);
1212	HRESULT endPoweringDown(LONG aResult,
1213	const com::Utf8Str &aErrMsg);
1214	HRESULT runUSBDeviceFilters(const ComPtr<IUSBDevice> &aDevice,
1215	BOOL *aMatched,
1216	ULONG *aMaskedInterfaces);
1217	HRESULT captureUSBDevice(const com::Guid &aId,
1218	const com::Utf8Str &aCaptureFilename);
1219	HRESULT detachUSBDevice(const com::Guid &aId,
1220	BOOL aDone);
1221	HRESULT autoCaptureUSBDevices();
1222	HRESULT detachAllUSBDevices(BOOL aDone);
1223	HRESULT onSessionEnd(const ComPtr<ISession> &aSession,
1224	ComPtr<IProgress> &aProgress);
1225	HRESULT finishOnlineMergeMedium();
1226	HRESULT pullGuestProperties(std::vector<com::Utf8Str> &aNames,
1227	std::vector<com::Utf8Str> &aValues,
1228	std::vector<LONG64> &aTimestamps,
1229	std::vector<com::Utf8Str> &aFlags);
1230	HRESULT pushGuestProperty(const com::Utf8Str &aName,
1231	const com::Utf8Str &aValue,
1232	LONG64 aTimestamp,
1233	const com::Utf8Str &aFlags);
1234	HRESULT lockMedia();
1235	HRESULT unlockMedia();
1236	HRESULT ejectMedium(const ComPtr<IMediumAttachment> &aAttachment,
1237	ComPtr<IMediumAttachment> &aNewAttachment);
1238	HRESULT reportVmStatistics(ULONG aValidStats,
1239	ULONG aCpuUser,
1240	ULONG aCpuKernel,
1241	ULONG aCpuIdle,
1242	ULONG aMemTotal,
1243	ULONG aMemFree,
1244	ULONG aMemBalloon,
1245	ULONG aMemShared,
1246	ULONG aMemCache,
1247	ULONG aPagedTotal,
1248	ULONG aMemAllocTotal,
1249	ULONG aMemFreeTotal,
1250	ULONG aMemBalloonTotal,
1251	ULONG aMemSharedTotal,
1252	ULONG aVmNetRx,
1253	ULONG aVmNetTx);
1254	};
1255
1256	// SessionMachine class
1257	////////////////////////////////////////////////////////////////////////////////
1258
1259	/**
1260	* @note Notes on locking objects of this class:
1261	* SessionMachine shares some data with the primary Machine instance (pointed
1262	* to by the \|mPeer\| member). In order to provide data consistency it also
1263	* shares its lock handle. This means that whenever you lock a SessionMachine
1264	* instance using Auto[Reader]Lock or AutoMultiLock, the corresponding Machine
1265	* instance is also locked in the same lock mode. Keep it in mind.
1266	*/
1267	class ATL_NO_VTABLE SessionMachine :
1268	public Machine
1269	{
1270	public:
1271	VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(SessionMachine, IMachine)
1272
1273	DECLARE_NOT_AGGREGATABLE(SessionMachine)
1274
1275	DECLARE_PROTECT_FINAL_CONSTRUCT()
1276
1277	BEGIN_COM_MAP(SessionMachine)
1278	VBOX_DEFAULT_INTERFACE_ENTRIES(IMachine)
1279	COM_INTERFACE_ENTRY(IInternalMachineControl)
1280	END_COM_MAP()
1281
1282	DECLARE_EMPTY_CTOR_DTOR(SessionMachine)
1283
1284	HRESULT FinalConstruct();
1285	void FinalRelease();
1286
1287	struct Uninit
1288	{
1289	enum Reason { Unexpected, Abnormal, Normal };
1290	};
1291
1292	// public initializer/uninitializer for internal purposes only
1293	HRESULT init(Machine *aMachine);
1294	void uninit() { uninit(Uninit::Unexpected); }
1295	void uninit(Uninit::Reason aReason);
1296
1297
1298	// util::Lockable interface
1299	RWLockHandle *lockHandle() const;
1300
1301	// public methods only for internal purposes
1302
1303	virtual bool i_isSessionMachine() const
1304	{
1305	return true;
1306	}
1307
1308	#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
1309	bool i_checkForDeath();
1310
1311	void i_getTokenId(Utf8Str &strTokenId);
1312	#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
1313	IToken *i_getToken();
1314	#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
1315	// getClientToken must be only used by callers who can guarantee that
1316	// the object cannot be deleted in the mean time, i.e. have a caller/lock.
1317	ClientToken *i_getClientToken();
1318
1319	HRESULT i_onNetworkAdapterChange(INetworkAdapter *networkAdapter, BOOL changeAdapter);
1320	HRESULT i_onNATRedirectRuleChange(ULONG ulSlot, BOOL aNatRuleRemove, IN_BSTR aRuleName,
1321	NATProtocol_T aProto, IN_BSTR aHostIp, LONG aHostPort,
1322	IN_BSTR aGuestIp, LONG aGuestPort);
1323	HRESULT i_onStorageControllerChange();
1324	HRESULT i_onMediumChange(IMediumAttachment *aMediumAttachment, BOOL aForce);
1325	HRESULT i_onSerialPortChange(ISerialPort *serialPort);
1326	HRESULT i_onParallelPortChange(IParallelPort *parallelPort);
1327	HRESULT i_onCPUChange(ULONG aCPU, BOOL aRemove);
1328	HRESULT i_onVRDEServerChange(BOOL aRestart);
1329	HRESULT i_onVideoCaptureChange();
1330	HRESULT i_onUSBControllerChange();
1331	HRESULT i_onUSBDeviceAttach(IUSBDevice *aDevice,
1332	IVirtualBoxErrorInfo *aError,
1333	ULONG aMaskedIfs,
1334	const com::Utf8Str &aCaptureFilename);
1335	HRESULT i_onUSBDeviceDetach(IN_BSTR aId,
1336	IVirtualBoxErrorInfo *aError);
1337	HRESULT i_onSharedFolderChange();
1338	HRESULT i_onClipboardModeChange(ClipboardMode_T aClipboardMode);
1339	HRESULT i_onDnDModeChange(DnDMode_T aDnDMode);
1340	HRESULT i_onBandwidthGroupChange(IBandwidthGroup *aBandwidthGroup);
1341	HRESULT i_onStorageDeviceChange(IMediumAttachment *aMediumAttachment, BOOL aRemove, BOOL aSilent);
1342	HRESULT i_onCPUExecutionCapChange(ULONG aCpuExecutionCap);
1343
1344	bool i_hasMatchingUSBFilter(const ComObjPtr<HostUSBDevice> &aDevice, ULONG *aMaskedIfs);
1345
1346	HRESULT i_lockMedia();
1347	HRESULT i_unlockMedia();
1348
1349	HRESULT i_saveStateWithReason(Reason_T aReason, ComPtr<IProgress> &aProgress);
1350
1351	private:
1352
1353	// wrapped IInternalMachineControl properties
1354
1355	// wrapped IInternalMachineControl methods
1356	HRESULT setRemoveSavedStateFile(BOOL aRemove);
1357	HRESULT updateState(MachineState_T aState);
1358	HRESULT beginPowerUp(const ComPtr<IProgress> &aProgress);
1359	HRESULT endPowerUp(LONG aResult);
1360	HRESULT beginPoweringDown(ComPtr<IProgress> &aProgress);
1361	HRESULT endPoweringDown(LONG aResult,
1362	const com::Utf8Str &aErrMsg);
1363	HRESULT runUSBDeviceFilters(const ComPtr<IUSBDevice> &aDevice,
1364	BOOL *aMatched,
1365	ULONG *aMaskedInterfaces);
1366	HRESULT captureUSBDevice(const com::Guid &aId, const com::Utf8Str &aCaptureFilename);
1367	HRESULT detachUSBDevice(const com::Guid &aId,
1368	BOOL aDone);
1369	HRESULT autoCaptureUSBDevices();
1370	HRESULT detachAllUSBDevices(BOOL aDone);
1371	HRESULT onSessionEnd(const ComPtr<ISession> &aSession,
1372	ComPtr<IProgress> &aProgress);
1373	HRESULT finishOnlineMergeMedium();
1374	HRESULT pullGuestProperties(std::vector<com::Utf8Str> &aNames,
1375	std::vector<com::Utf8Str> &aValues,
1376	std::vector<LONG64> &aTimestamps,
1377	std::vector<com::Utf8Str> &aFlags);
1378	HRESULT pushGuestProperty(const com::Utf8Str &aName,
1379	const com::Utf8Str &aValue,
1380	LONG64 aTimestamp,
1381	const com::Utf8Str &aFlags);
1382	HRESULT lockMedia();
1383	HRESULT unlockMedia();
1384	HRESULT ejectMedium(const ComPtr<IMediumAttachment> &aAttachment,
1385	ComPtr<IMediumAttachment> &aNewAttachment);
1386	HRESULT reportVmStatistics(ULONG aValidStats,
1387	ULONG aCpuUser,
1388	ULONG aCpuKernel,
1389	ULONG aCpuIdle,
1390	ULONG aMemTotal,
1391	ULONG aMemFree,
1392	ULONG aMemBalloon,
1393	ULONG aMemShared,
1394	ULONG aMemCache,
1395	ULONG aPagedTotal,
1396	ULONG aMemAllocTotal,
1397	ULONG aMemFreeTotal,
1398	ULONG aMemBalloonTotal,
1399	ULONG aMemSharedTotal,
1400	ULONG aVmNetRx,
1401	ULONG aVmNetTx);
1402
1403
1404	struct ConsoleTaskData
1405	{
1406	ConsoleTaskData()
1407	: mLastState(MachineState_Null),
1408	mDeleteSnapshotInfo(NULL)
1409	{ }
1410
1411	MachineState_T mLastState;
1412	ComObjPtr<Progress> mProgress;
1413
1414	// used when deleting online snaphshot
1415	void *mDeleteSnapshotInfo;
1416	};
1417
1418	struct SaveStateTask;
1419	struct SnapshotTask;
1420	struct TakeSnapshotTask;
1421	struct DeleteSnapshotTask;
1422	struct RestoreSnapshotTask;
1423
1424	friend struct TakeSnapshotTask;
1425	friend struct DeleteSnapshotTask;
1426	friend struct RestoreSnapshotTask;
1427
1428	void i_saveStateHandler(SaveStateTask &aTask);
1429
1430	// Override some functionality for SessionMachine, this is where the
1431	// real action happens (the Machine methods are just dummies).
1432	HRESULT saveState(ComPtr<IProgress> &aProgress);
1433	HRESULT adoptSavedState(const com::Utf8Str &aSavedStateFile);
1434	HRESULT discardSavedState(BOOL aFRemoveFile);
1435	HRESULT takeSnapshot(const com::Utf8Str &aName,
1436	const com::Utf8Str &aDescription,
1437	BOOL aPause,
1438	com::Guid &aId,
1439	ComPtr<IProgress> &aProgress);
1440	HRESULT deleteSnapshot(const com::Guid &aId,
1441	ComPtr<IProgress> &aProgress);
1442	HRESULT deleteSnapshotAndAllChildren(const com::Guid &aId,
1443	ComPtr<IProgress> &aProgress);
1444	HRESULT deleteSnapshotRange(const com::Guid &aStartId,
1445	const com::Guid &aEndId,
1446	ComPtr<IProgress> &aProgress);
1447	HRESULT restoreSnapshot(const ComPtr<ISnapshot> &aSnapshot,
1448	ComPtr<IProgress> &aProgress);
1449
1450	void i_releaseSavedStateFile(const Utf8Str &strSavedStateFile, Snapshot *pSnapshotToIgnore);
1451
1452	void i_takeSnapshotHandler(TakeSnapshotTask &aTask);
1453	static void i_takeSnapshotProgressCancelCallback(void *pvUser);
1454	HRESULT i_finishTakingSnapshot(TakeSnapshotTask &aTask, AutoWriteLock &alock, bool aSuccess);
1455	HRESULT i_deleteSnapshot(const com::Guid &aStartId,
1456	const com::Guid &aEndId,
1457	BOOL aDeleteAllChildren,
1458	ComPtr<IProgress> &aProgress);
1459	void i_deleteSnapshotHandler(DeleteSnapshotTask &aTask);
1460	void i_restoreSnapshotHandler(RestoreSnapshotTask &aTask);
1461
1462	HRESULT i_prepareDeleteSnapshotMedium(const ComObjPtr<Medium> &aHD,
1463	const Guid &machineId,
1464	const Guid &snapshotId,
1465	bool fOnlineMergePossible,
1466	MediumLockList *aVMMALockList,
1467	ComObjPtr<Medium> &aSource,
1468	ComObjPtr<Medium> &aTarget,
1469	bool &fMergeForward,
1470	ComObjPtr<Medium> &pParentForTarget,
1471	MediumLockList * &aChildrenToReparent,
1472	bool &fNeedOnlineMerge,
1473	MediumLockList * &aMediumLockList,
1474	ComPtr<IToken> &aHDLockToken);
1475	void i_cancelDeleteSnapshotMedium(const ComObjPtr<Medium> &aHD,
1476	const ComObjPtr<Medium> &aSource,
1477	MediumLockList *aChildrenToReparent,
1478	bool fNeedsOnlineMerge,
1479	MediumLockList *aMediumLockList,
1480	const ComPtr<IToken> &aHDLockToken,
1481	const Guid &aMediumId,
1482	const Guid &aSnapshotId);
1483	HRESULT i_onlineMergeMedium(const ComObjPtr<MediumAttachment> &aMediumAttachment,
1484	const ComObjPtr<Medium> &aSource,
1485	const ComObjPtr<Medium> &aTarget,
1486	bool fMergeForward,
1487	const ComObjPtr<Medium> &pParentForTarget,
1488	MediumLockList *aChildrenToReparent,
1489	MediumLockList *aMediumLockList,
1490	ComObjPtr<Progress> &aProgress,
1491	bool *pfNeedsMachineSaveSettings);
1492
1493	HRESULT i_setMachineState(MachineState_T aMachineState);
1494	HRESULT i_updateMachineStateOnClient();
1495
1496	bool mRemoveSavedState;
1497
1498	ConsoleTaskData mConsoleTaskData;
1499
1500	/** client token for this machine */
1501	ClientToken *mClientToken;
1502
1503	int miNATNetworksStarted;
1504	};
1505
1506	// SnapshotMachine class
1507	////////////////////////////////////////////////////////////////////////////////
1508
1509	/**
1510	* @note Notes on locking objects of this class:
1511	* SnapshotMachine shares some data with the primary Machine instance (pointed
1512	* to by the \|mPeer\| member). In order to provide data consistency it also
1513	* shares its lock handle. This means that whenever you lock a SessionMachine
1514	* instance using Auto[Reader]Lock or AutoMultiLock, the corresponding Machine
1515	* instance is also locked in the same lock mode. Keep it in mind.
1516	*/
1517	class ATL_NO_VTABLE SnapshotMachine :
1518	public Machine
1519	{
1520	public:
1521	VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(SnapshotMachine, IMachine)
1522
1523	DECLARE_NOT_AGGREGATABLE(SnapshotMachine)
1524
1525	DECLARE_PROTECT_FINAL_CONSTRUCT()
1526
1527	BEGIN_COM_MAP(SnapshotMachine)
1528	VBOX_DEFAULT_INTERFACE_ENTRIES(IMachine)
1529	END_COM_MAP()
1530
1531	DECLARE_EMPTY_CTOR_DTOR(SnapshotMachine)
1532
1533	HRESULT FinalConstruct();
1534	void FinalRelease();
1535
1536	// public initializer/uninitializer for internal purposes only
1537	HRESULT init(SessionMachine *aSessionMachine,
1538	IN_GUID aSnapshotId,
1539	const Utf8Str &aStateFilePath);
1540	HRESULT initFromSettings(Machine *aMachine,
1541	const settings::Hardware &hardware,
1542	const settings::Debugging *pDbg,
1543	const settings::Autostart *pAutostart,
1544	const settings::Storage &storage,
1545	IN_GUID aSnapshotId,
1546	const Utf8Str &aStateFilePath);
1547	void uninit();
1548
1549	// util::Lockable interface
1550	RWLockHandle *lockHandle() const;
1551
1552	// public methods only for internal purposes
1553
1554	virtual bool i_isSnapshotMachine() const
1555	{
1556	return true;
1557	}
1558
1559	HRESULT i_onSnapshotChange(Snapshot *aSnapshot);
1560
1561	// unsafe inline public methods for internal purposes only (ensure there is
1562	// a caller and a read lock before calling them!)
1563
1564	const Guid& i_getSnapshotId() const { return mSnapshotId; }
1565
1566	private:
1567
1568	Guid mSnapshotId;
1569	/** This field replaces mPeer for SessionMachine instances, as having
1570	* a peer reference is plain meaningless and causes many subtle problems
1571	* with saving settings and the like. */
1572	Machine * const mMachine;
1573
1574	friend class Snapshot;
1575	};
1576
1577	// third party methods that depend on SnapshotMachine definition
1578
1579	inline const Guid &Machine::i_getSnapshotId() const
1580	{
1581	return (i_isSnapshotMachine())
1582	? static_cast<const SnapshotMachine*>(this)->i_getSnapshotId()
1583	: Guid::Empty;
1584	}
1585
1586
1587	#endif // ____H_MACHINEIMPL
1588	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

source: vbox/trunk/src/VBox/Main/include/MachineImpl.h@ 56268

Download in other formats: