MachineImpl.h@ 60765

Last change on this file since 60765 was 60765, checked in by vboxsync, 9 years ago
API: stop using ATL and use a vastly smaller lookalike instead, plus a lot of cleanups
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 68.8 KB

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

Download in other formats: