MachineImpl.h@ 68133

Last change on this file since 68133 was 68133, checked in by vboxsync, 7 years ago
Unattended: Moved the createUnattendedInstaller method from IMachine to IVirtualBox as we will be needing it without a virtual machine in a new-vm-from-installation-iso wizard.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 68.4 KB

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

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

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

Download in other formats: