MachineImpl.h@ 62014

Last change on this file since 62014 was 62014, checked in by vboxsync, 9 years ago
Main/Machine: add a stub for an aux settings file (which will be an additional file, for the current state and each snapshot), meant for stuff which needs to be saved potentially frequently while the VM is running. It should cover what aren't true settings, in the sense of not being subject to the usual saveSettings/discardSettings machinery. Usually rather bulky stuff.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 68.9 KB

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

Download in other formats: