MachineImpl.h@ 55977

Last change on this file since 55977 was 55977, checked in by vboxsync, 10 years ago
Main/Snapshot: add a parameter to IMachine.takeSnapshot, returning the snapshot UUID, which is useful for finding the snapshot reliably (using the non-unique name is error prone), plus the necessary code adaptions everywhere. Frontends/VBoxManage: add a feature for creating unique snapshot names (by appending a number or timestamp).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 67.6 KB

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

Download in other formats: