MachineImpl.h@ 57832

Last change on this file since 57832 was 57832, checked in by vboxsync, 9 years ago
Main,GUI: positioned the VBoxStartup.log as the 2nd log that can be retrieved via IMachine::queryLogFilename on windows.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 67.8 KB

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

Download in other formats: