MachineImpl.h@ 61042

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

Download in other formats: