MachineImpl.h@ 66311

Last change on this file since 66311 was 66126, checked in by vboxsync, 8 years ago
Main/Machine+Snapshot+Appliance+StorageController: eliminate the one-member struct MediaData, as a preparation for later eliminating the Backupable<> template use in combination with anything containing a ComObjPtr (since these are not handled in a sensible way when creating a session or a snapshot anyway, needing more effort to fix than do right from the beginning). Additionally a lot of iterator loop cleanups, making proper use of scoping and const_iterator whenever possible. Also take the opportunity to improve the readability of some quite long lines. No behavior change intended.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 68.5 KB

Line
1	/* $Id: MachineImpl.h 66126 2017-03-16 14:06:27Z 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	#ifdef VBOX_WITH_UNATTENDED
44	# include "UnattendedImpl.h"
45	#endif
46
47	// generated header
48	#include "SchemaDefs.h"
49
50	#include "VBox/com/ErrorInfo.h"
51
52	#include <iprt/file.h>
53	#include <iprt/thread.h>
54	#include <iprt/time.h>
55
56	#include <list>
57	#include <vector>
58
59	#include "MachineWrap.h"
60
61	/** @todo r=klaus after moving the various Machine settings structs to
62	* MachineImpl.cpp it should be possible to eliminate this include. */
63	#include <VBox/settings.h>
64
65	// defines
66	////////////////////////////////////////////////////////////////////////////////
67
68	// helper declarations
69	////////////////////////////////////////////////////////////////////////////////
70
71	class Progress;
72	class ProgressProxy;
73	class Keyboard;
74	class Mouse;
75	class Display;
76	class MachineDebugger;
77	class USBController;
78	class USBDeviceFilters;
79	class Snapshot;
80	class SharedFolder;
81	class HostUSBDevice;
82	class StorageController;
83	class SessionMachine;
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	ChipsetType_T i_getChipsetType() const { return mHWData->mChipsetType; }
490	ParavirtProvider_T i_getParavirtProvider() const { return mHWData->mParavirtProvider; }
491	Utf8Str i_getParavirtDebug() const { return mHWData->mParavirtDebug; }
492
493	void i_setModified(uint32_t fl, bool fAllowStateModification = true);
494	void i_setModifiedLock(uint32_t fl, bool fAllowStateModification = true);
495
496	bool i_isStateModificationAllowed() const { return mData->m_fAllowStateModification; }
497	void i_allowStateModification() { mData->m_fAllowStateModification = true; }
498	void i_disallowStateModification() { mData->m_fAllowStateModification = false; }
499
500	const StringsList &i_getGroups() const { return mUserData->s.llGroups; }
501
502	// callback handlers
503	virtual HRESULT i_onNetworkAdapterChange(INetworkAdapter * /* networkAdapter /, BOOL / changeAdapter */) { return S_OK; }
504	virtual HRESULT i_onNATRedirectRuleChange(ULONG /* slot /, BOOL / fRemove / , IN_BSTR / name */,
505	NATProtocol_T /* protocol /, IN_BSTR / host ip /, LONG / host port */,
506	IN_BSTR /* guest port /, LONG / guest port */ ) { return S_OK; }
507	virtual HRESULT i_onSerialPortChange(ISerialPort * /* serialPort */) { return S_OK; }
508	virtual HRESULT i_onParallelPortChange(IParallelPort * /* parallelPort */) { return S_OK; }
509	virtual HRESULT i_onVRDEServerChange(BOOL /* aRestart */) { return S_OK; }
510	virtual HRESULT i_onUSBControllerChange() { return S_OK; }
511	virtual HRESULT i_onStorageControllerChange() { return S_OK; }
512	virtual HRESULT i_onCPUChange(ULONG /* aCPU /, BOOL / aRemove */) { return S_OK; }
513	virtual HRESULT i_onCPUExecutionCapChange(ULONG /* aExecutionCap */) { return S_OK; }
514	virtual HRESULT i_onMediumChange(IMediumAttachment * /* mediumAttachment /, BOOL / force */) { return S_OK; }
515	virtual HRESULT i_onSharedFolderChange() { return S_OK; }
516	virtual HRESULT i_onClipboardModeChange(ClipboardMode_T /* aClipboardMode */) { return S_OK; }
517	virtual HRESULT i_onDnDModeChange(DnDMode_T /* aDnDMode */) { return S_OK; }
518	virtual HRESULT i_onBandwidthGroupChange(IBandwidthGroup * /* aBandwidthGroup */) { return S_OK; }
519	virtual HRESULT i_onStorageDeviceChange(IMediumAttachment * /* mediumAttachment /, BOOL / remove */,
520	BOOL /* silent */) { return S_OK; }
521	virtual HRESULT i_onVideoCaptureChange() { return S_OK; }
522
523	HRESULT i_saveRegistryEntry(settings::MachineRegistryEntry &data);
524
525	int i_calculateFullPath(const Utf8Str &strPath, Utf8Str &aResult);
526	void i_copyPathRelativeToMachine(const Utf8Str &strSource, Utf8Str &strTarget);
527
528	void i_getLogFolder(Utf8Str &aLogFolder);
529	Utf8Str i_getLogFilename(ULONG idx);
530	Utf8Str i_getHardeningLogFilename(void);
531
532	void i_composeSavedStateFilename(Utf8Str &strStateFilePath);
533
534	void i_getDefaultVideoCaptureFile(Utf8Str &strFile);
535
536	bool i_isUSBControllerPresent();
537
538	HRESULT i_launchVMProcess(IInternalSessionControl *aControl,
539	const Utf8Str &strType,
540	const Utf8Str &strEnvironment,
541	ProgressProxy *aProgress);
542
543	HRESULT i_getDirectControl(ComPtr<IInternalSessionControl> *directControl)
544	{
545	HRESULT rc;
546	*directControl = mData->mSession.mDirectControl;
547
548	if (!*directControl)
549	rc = E_ACCESSDENIED;
550	else
551	rc = S_OK;
552
553	return rc;
554	}
555
556	bool i_isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
557	ComPtr<IInternalSessionControl> *aControl = NULL,
558	bool aRequireVM = false,
559	bool aAllowClosing = false);
560	bool i_isSessionSpawning();
561
562	bool i_isSessionOpenOrClosing(ComObjPtr<SessionMachine> &aMachine,
563	ComPtr<IInternalSessionControl> *aControl = NULL)
564	{ return i_isSessionOpen(aMachine, aControl, false /* aRequireVM /, true / aAllowClosing */); }
565
566	bool i_isSessionOpenVM(ComObjPtr<SessionMachine> &aMachine,
567	ComPtr<IInternalSessionControl> *aControl = NULL)
568	{ return i_isSessionOpen(aMachine, aControl, true /* aRequireVM /, false / aAllowClosing */); }
569
570	bool i_checkForSpawnFailure();
571
572	HRESULT i_prepareRegister();
573
574	HRESULT i_getSharedFolder(CBSTR aName,
575	ComObjPtr<SharedFolder> &aSharedFolder,
576	bool aSetError = false)
577	{
578	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
579	return i_findSharedFolder(aName, aSharedFolder, aSetError);
580	}
581
582	HRESULT i_addStateDependency(StateDependency aDepType = AnyStateDep,
583	MachineState_T *aState = NULL,
584	BOOL *aRegistered = NULL);
585	void i_releaseStateDependency();
586
587	HRESULT i_getStorageControllerByName(const Utf8Str &aName,
588	ComObjPtr<StorageController> &aStorageController,
589	bool aSetError = false);
590
591	HRESULT i_getMediumAttachmentsOfController(const Utf8Str &aName,
592	MediumAttachmentList &aAttachments);
593
594	HRESULT i_getUSBControllerByName(const Utf8Str &aName,
595	ComObjPtr<USBController> &aUSBController,
596	bool aSetError = false);
597
598	HRESULT i_getBandwidthGroup(const Utf8Str &strBandwidthGroup,
599	ComObjPtr<BandwidthGroup> &pBandwidthGroup,
600	bool fSetError = false)
601	{
602	return mBandwidthControl->i_getBandwidthGroupByName(strBandwidthGroup,
603	pBandwidthGroup,
604	fSetError);
605	}
606
607	static HRESULT i_setErrorStatic(HRESULT aResultCode, const char *pcszMsg, ...);
608
609	protected:
610
611	class ClientToken;
612
613	HRESULT i_checkStateDependency(StateDependency aDepType);
614
615	Machine *i_getMachine();
616
617	void i_ensureNoStateDependencies();
618
619	virtual HRESULT i_setMachineState(MachineState_T aMachineState);
620
621	HRESULT i_findSharedFolder(const Utf8Str &aName,
622	ComObjPtr<SharedFolder> &aSharedFolder,
623	bool aSetError = false);
624
625	HRESULT i_loadSettings(bool aRegistered);
626	HRESULT i_loadMachineDataFromSettings(const settings::MachineConfigFile &config,
627	const Guid *puuidRegistry);
628	HRESULT i_loadSnapshot(const settings::Snapshot &data,
629	const Guid &aCurSnapshotId,
630	Snapshot *aParentSnapshot);
631	HRESULT i_loadHardware(const Guid *puuidRegistry,
632	const Guid *puuidSnapshot,
633	const settings::Hardware &data,
634	const settings::Debugging *pDbg,
635	const settings::Autostart *pAutostart);
636	HRESULT i_loadDebugging(const settings::Debugging *pDbg);
637	HRESULT i_loadAutostart(const settings::Autostart *pAutostart);
638	HRESULT i_loadStorageControllers(const settings::Storage &data,
639	const Guid *puuidRegistry,
640	const Guid *puuidSnapshot);
641	HRESULT i_loadStorageDevices(StorageController *aStorageController,
642	const settings::StorageController &data,
643	const Guid *puuidRegistry,
644	const Guid *puuidSnapshot);
645
646	HRESULT i_findSnapshotById(const Guid &aId,
647	ComObjPtr<Snapshot> &aSnapshot,
648	bool aSetError = false);
649	HRESULT i_findSnapshotByName(const Utf8Str &strName,
650	ComObjPtr<Snapshot> &aSnapshot,
651	bool aSetError = false);
652
653	ULONG i_getUSBControllerCountByType(USBControllerType_T enmType);
654
655	enum
656	{
657	/* flags for #saveSettings() */
658	SaveS_ResetCurStateModified = 0x01,
659	SaveS_Force = 0x04,
660	/* flags for #saveStateSettings() */
661	SaveSTS_CurStateModified = 0x20,
662	SaveSTS_StateFilePath = 0x40,
663	SaveSTS_StateTimeStamp = 0x80
664	};
665
666	HRESULT i_prepareSaveSettings(bool *pfNeedsGlobalSaveSettings);
667	HRESULT i_saveSettings(bool *pfNeedsGlobalSaveSettings, int aFlags = 0);
668
669	void i_copyMachineDataToSettings(settings::MachineConfigFile &config);
670	HRESULT i_saveAllSnapshots(settings::MachineConfigFile &config);
671	HRESULT i_saveHardware(settings::Hardware &data, settings::Debugging *pDbg,
672	settings::Autostart *pAutostart);
673	HRESULT i_saveStorageControllers(settings::Storage &data);
674	HRESULT i_saveStorageDevices(ComObjPtr<StorageController> aStorageController,
675	settings::StorageController &data);
676	HRESULT i_saveStateSettings(int aFlags);
677
678	void i_addMediumToRegistry(ComObjPtr<Medium> &pMedium);
679
680	HRESULT i_createImplicitDiffs(IProgress *aProgress,
681	ULONG aWeight,
682	bool aOnline);
683	HRESULT i_deleteImplicitDiffs(bool aOnline);
684
685	MediumAttachment* i_findAttachment(const MediumAttachmentList &ll,
686	const Utf8Str &aControllerName,
687	LONG aControllerPort,
688	LONG aDevice);
689	MediumAttachment* i_findAttachment(const MediumAttachmentList &ll,
690	ComObjPtr<Medium> pMedium);
691	MediumAttachment* i_findAttachment(const MediumAttachmentList &ll,
692	Guid &id);
693
694	HRESULT i_detachDevice(MediumAttachment *pAttach,
695	AutoWriteLock &writeLock,
696	Snapshot *pSnapshot);
697
698	HRESULT i_detachAllMedia(AutoWriteLock &writeLock,
699	Snapshot *pSnapshot,
700	CleanupMode_T cleanupMode,
701	MediaList &llMedia);
702
703	void i_commitMedia(bool aOnline = false);
704	void i_rollbackMedia();
705
706	bool i_isInOwnDir(Utf8Str *aSettingsDir = NULL) const;
707
708	void i_rollback(bool aNotify);
709	void i_commit();
710	void i_copyFrom(Machine *aThat);
711	bool i_isControllerHotplugCapable(StorageControllerType_T enmCtrlType);
712
713	Utf8Str i_getExtraData(const Utf8Str &strKey);
714
715	#ifdef VBOX_WITH_GUEST_PROPS
716	HRESULT i_getGuestPropertyFromService(const com::Utf8Str &aName, com::Utf8Str &aValue,
717	LONG64 *aTimestamp, com::Utf8Str &aFlags) const;
718	HRESULT i_setGuestPropertyToService(const com::Utf8Str &aName, const com::Utf8Str &aValue,
719	const com::Utf8Str &aFlags, bool fDelete);
720	HRESULT i_getGuestPropertyFromVM(const com::Utf8Str &aName, com::Utf8Str &aValue,
721	LONG64 *aTimestamp, com::Utf8Str &aFlags) const;
722	HRESULT i_setGuestPropertyToVM(const com::Utf8Str &aName, const com::Utf8Str &aValue,
723	const com::Utf8Str &aFlags, bool fDelete);
724	HRESULT i_enumerateGuestPropertiesInService(const com::Utf8Str &aPatterns,
725	std::vector<com::Utf8Str> &aNames,
726	std::vector<com::Utf8Str> &aValues,
727	std::vector<LONG64> &aTimestamps,
728	std::vector<com::Utf8Str> &aFlags);
729	HRESULT i_enumerateGuestPropertiesOnVM(const com::Utf8Str &aPatterns,
730	std::vector<com::Utf8Str> &aNames,
731	std::vector<com::Utf8Str> &aValues,
732	std::vector<LONG64> &aTimestamps,
733	std::vector<com::Utf8Str> &aFlags);
734
735	#endif /* VBOX_WITH_GUEST_PROPS */
736
737	#ifdef VBOX_WITH_RESOURCE_USAGE_API
738	void i_getDiskList(MediaList &list);
739	void i_registerMetrics(PerformanceCollector aCollector, Machine aMachine, RTPROCESS pid);
740
741	pm::CollectorGuest *mCollectorGuest;
742	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
743
744	Machine * const mPeer;
745
746	VirtualBox * const mParent;
747
748	Shareable<Data> mData;
749	Shareable<SSData> mSSData;
750
751	Backupable<UserData> mUserData;
752	Backupable<HWData> mHWData;
753
754	/**
755	* Hard disk and other media data.
756	*
757	* The usage policy is the same as for mHWData, but a separate field
758	* is necessary because hard disk data requires different procedures when
759	* taking or deleting snapshots, etc.
760	*
761	* @todo r=klaus change this to a regular list and use the normal way to
762	* handle the settings when creating a session or taking a snapshot.
763	* Same thing applies to mStorageControllers and mUSBControllers.
764	*/
765	Backupable<MediumAttachmentList> mMediumAttachments;
766
767	// the following fields need special backup/rollback/commit handling,
768	// so they cannot be a part of HWData
769
770	const ComObjPtr<VRDEServer> mVRDEServer;
771	const ComObjPtr<SerialPort> mSerialPorts[SchemaDefs::SerialPortCount];
772	const ComObjPtr<ParallelPort> mParallelPorts[SchemaDefs::ParallelPortCount];
773	const ComObjPtr<AudioAdapter> mAudioAdapter;
774	const ComObjPtr<USBDeviceFilters> mUSBDeviceFilters;
775	const ComObjPtr<BIOSSettings> mBIOSSettings;
776	const ComObjPtr<BandwidthControl> mBandwidthControl;
777	#ifdef VBOX_WITH_UNATTENDED
778	const ComObjPtr<Unattended> mUnattended;
779	#endif
780
781	typedef std::vector<ComObjPtr<NetworkAdapter> > NetworkAdapterVector;
782	NetworkAdapterVector mNetworkAdapters;
783
784	typedef std::list<ComObjPtr<StorageController> > StorageControllerList;
785	Backupable<StorageControllerList> mStorageControllers;
786
787	typedef std::list<ComObjPtr<USBController> > USBControllerList;
788	Backupable<USBControllerList> mUSBControllers;
789
790	uint64_t uRegistryNeedsSaving;
791
792	/**
793	* Abstract base class for all Machine or SessionMachine related
794	* asynchronous tasks. This is necessary since RTThreadCreate cannot call
795	* a (non-static) method as its thread function, so instead we have it call
796	* the static Machine::taskHandler, which then calls the handler() method
797	* in here (implemented by the subclasses).
798	*/
799	class Task : public ThreadTask
800	{
801	public:
802	Task(Machine m, Progress p, const Utf8Str &t)
803	: ThreadTask(t),
804	m_pMachine(m),
805	m_machineCaller(m),
806	m_pProgress(p),
807	m_machineStateBackup(m->mData->mMachineState) // save the current machine state
808	{}
809	virtual ~Task(){}
810
811	void modifyBackedUpState(MachineState_T s)
812	{
813	const_cast<MachineState_T >(&m_machineStateBackup) = s;
814	}
815
816	ComObjPtr<Machine> m_pMachine;
817	AutoCaller m_machineCaller;
818	ComObjPtr<Progress> m_pProgress;
819	const MachineState_T m_machineStateBackup;
820	};
821
822	class DeleteConfigTask;
823	void i_deleteConfigHandler(DeleteConfigTask &task);
824
825	friend class SessionMachine;
826	friend class SnapshotMachine;
827	friend class Appliance;
828	friend class VirtualBox;
829
830	friend class MachineCloneVM;
831
832	private:
833	// wrapped IMachine properties
834	HRESULT getParent(ComPtr<IVirtualBox> &aParent);
835	HRESULT getIcon(std::vector<BYTE> &aIcon);
836	HRESULT setIcon(const std::vector<BYTE> &aIcon);
837	HRESULT getAccessible(BOOL *aAccessible);
838	HRESULT getAccessError(ComPtr<IVirtualBoxErrorInfo> &aAccessError);
839	HRESULT getName(com::Utf8Str &aName);
840	HRESULT setName(const com::Utf8Str &aName);
841	HRESULT getDescription(com::Utf8Str &aDescription);
842	HRESULT setDescription(const com::Utf8Str &aDescription);
843	HRESULT getId(com::Guid &aId);
844	HRESULT getGroups(std::vector<com::Utf8Str> &aGroups);
845	HRESULT setGroups(const std::vector<com::Utf8Str> &aGroups);
846	HRESULT getOSTypeId(com::Utf8Str &aOSTypeId);
847	HRESULT setOSTypeId(const com::Utf8Str &aOSTypeId);
848	HRESULT getHardwareVersion(com::Utf8Str &aHardwareVersion);
849	HRESULT setHardwareVersion(const com::Utf8Str &aHardwareVersion);
850	HRESULT getHardwareUUID(com::Guid &aHardwareUUID);
851	HRESULT setHardwareUUID(const com::Guid &aHardwareUUID);
852	HRESULT getCPUCount(ULONG *aCPUCount);
853	HRESULT setCPUCount(ULONG aCPUCount);
854	HRESULT getCPUHotPlugEnabled(BOOL *aCPUHotPlugEnabled);
855	HRESULT setCPUHotPlugEnabled(BOOL aCPUHotPlugEnabled);
856	HRESULT getCPUExecutionCap(ULONG *aCPUExecutionCap);
857	HRESULT setCPUExecutionCap(ULONG aCPUExecutionCap);
858	HRESULT getCPUIDPortabilityLevel(ULONG *aCPUIDPortabilityLevel);
859	HRESULT setCPUIDPortabilityLevel(ULONG aCPUIDPortabilityLevel);
860	HRESULT getCPUProfile(com::Utf8Str &aCPUProfile);
861	HRESULT setCPUProfile(const com::Utf8Str &aCPUProfile);
862	HRESULT getMemorySize(ULONG *aMemorySize);
863	HRESULT setMemorySize(ULONG aMemorySize);
864	HRESULT getMemoryBalloonSize(ULONG *aMemoryBalloonSize);
865	HRESULT setMemoryBalloonSize(ULONG aMemoryBalloonSize);
866	HRESULT getPageFusionEnabled(BOOL *aPageFusionEnabled);
867	HRESULT setPageFusionEnabled(BOOL aPageFusionEnabled);
868	HRESULT getGraphicsControllerType(GraphicsControllerType_T *aGraphicsControllerType);
869	HRESULT setGraphicsControllerType(GraphicsControllerType_T aGraphicsControllerType);
870	HRESULT getVRAMSize(ULONG *aVRAMSize);
871	HRESULT setVRAMSize(ULONG aVRAMSize);
872	HRESULT getAccelerate3DEnabled(BOOL *aAccelerate3DEnabled);
873	HRESULT setAccelerate3DEnabled(BOOL aAccelerate3DEnabled);
874	HRESULT getAccelerate2DVideoEnabled(BOOL *aAccelerate2DVideoEnabled);
875	HRESULT setAccelerate2DVideoEnabled(BOOL aAccelerate2DVideoEnabled);
876	HRESULT getMonitorCount(ULONG *aMonitorCount);
877	HRESULT setMonitorCount(ULONG aMonitorCount);
878	HRESULT getVideoCaptureEnabled(BOOL *aVideoCaptureEnabled);
879	HRESULT setVideoCaptureEnabled(BOOL aVideoCaptureEnabled);
880	HRESULT getVideoCaptureScreens(std::vector<BOOL> &aVideoCaptureScreens);
881	HRESULT setVideoCaptureScreens(const std::vector<BOOL> &aVideoCaptureScreens);
882	HRESULT getVideoCaptureFile(com::Utf8Str &aVideoCaptureFile);
883	HRESULT setVideoCaptureFile(const com::Utf8Str &aVideoCaptureFile);
884	HRESULT getVideoCaptureWidth(ULONG *aVideoCaptureWidth);
885	HRESULT setVideoCaptureWidth(ULONG aVideoCaptureWidth);
886	HRESULT getVideoCaptureHeight(ULONG *aVideoCaptureHeight);
887	HRESULT setVideoCaptureHeight(ULONG aVideoCaptureHeight);
888	HRESULT getVideoCaptureRate(ULONG *aVideoCaptureRate);
889	HRESULT setVideoCaptureRate(ULONG aVideoCaptureRate);
890	HRESULT getVideoCaptureFPS(ULONG *aVideoCaptureFPS);
891	HRESULT setVideoCaptureFPS(ULONG aVideoCaptureFPS);
892	HRESULT getVideoCaptureMaxTime(ULONG *aVideoCaptureMaxTime);
893	HRESULT setVideoCaptureMaxTime(ULONG aVideoCaptureMaxTime);
894	HRESULT getVideoCaptureMaxFileSize(ULONG *aVideoCaptureMaxFileSize);
895	HRESULT setVideoCaptureMaxFileSize(ULONG aVideoCaptureMaxFileSize);
896	HRESULT getVideoCaptureOptions(com::Utf8Str &aVideoCaptureOptions);
897	HRESULT setVideoCaptureOptions(const com::Utf8Str &aVideoCaptureOptions);
898	HRESULT getBIOSSettings(ComPtr<IBIOSSettings> &aBIOSSettings);
899	HRESULT getFirmwareType(FirmwareType_T *aFirmwareType);
900	HRESULT setFirmwareType(FirmwareType_T aFirmwareType);
901	HRESULT getPointingHIDType(PointingHIDType_T *aPointingHIDType);
902	HRESULT setPointingHIDType(PointingHIDType_T aPointingHIDType);
903	HRESULT getKeyboardHIDType(KeyboardHIDType_T *aKeyboardHIDType);
904	HRESULT setKeyboardHIDType(KeyboardHIDType_T aKeyboardHIDType);
905	HRESULT getHPETEnabled(BOOL *aHPETEnabled);
906	HRESULT setHPETEnabled(BOOL aHPETEnabled);
907	HRESULT getChipsetType(ChipsetType_T *aChipsetType);
908	HRESULT setChipsetType(ChipsetType_T aChipsetType);
909	HRESULT getSnapshotFolder(com::Utf8Str &aSnapshotFolder);
910	HRESULT setSnapshotFolder(const com::Utf8Str &aSnapshotFolder);
911	HRESULT getVRDEServer(ComPtr<IVRDEServer> &aVRDEServer);
912	HRESULT getEmulatedUSBCardReaderEnabled(BOOL *aEmulatedUSBCardReaderEnabled);
913	HRESULT setEmulatedUSBCardReaderEnabled(BOOL aEmulatedUSBCardReaderEnabled);
914	HRESULT getMediumAttachments(std::vector<ComPtr<IMediumAttachment> > &aMediumAttachments);
915	HRESULT getUSBControllers(std::vector<ComPtr<IUSBController> > &aUSBControllers);
916	HRESULT getUSBDeviceFilters(ComPtr<IUSBDeviceFilters> &aUSBDeviceFilters);
917	HRESULT getAudioAdapter(ComPtr<IAudioAdapter> &aAudioAdapter);
918	HRESULT getStorageControllers(std::vector<ComPtr<IStorageController> > &aStorageControllers);
919	HRESULT getSettingsFilePath(com::Utf8Str &aSettingsFilePath);
920	HRESULT getSettingsAuxFilePath(com::Utf8Str &aSettingsAuxFilePath);
921	HRESULT getSettingsModified(BOOL *aSettingsModified);
922	HRESULT getSessionState(SessionState_T *aSessionState);
923	HRESULT getSessionType(SessionType_T *aSessionType);
924	HRESULT getSessionName(com::Utf8Str &aSessionType);
925	HRESULT getSessionPID(ULONG *aSessionPID);
926	HRESULT getState(MachineState_T *aState);
927	HRESULT getLastStateChange(LONG64 *aLastStateChange);
928	HRESULT getStateFilePath(com::Utf8Str &aStateFilePath);
929	HRESULT getLogFolder(com::Utf8Str &aLogFolder);
930	HRESULT getCurrentSnapshot(ComPtr<ISnapshot> &aCurrentSnapshot);
931	HRESULT getSnapshotCount(ULONG *aSnapshotCount);
932	HRESULT getCurrentStateModified(BOOL *aCurrentStateModified);
933	HRESULT getSharedFolders(std::vector<ComPtr<ISharedFolder> > &aSharedFolders);
934	HRESULT getClipboardMode(ClipboardMode_T *aClipboardMode);
935	HRESULT setClipboardMode(ClipboardMode_T aClipboardMode);
936	HRESULT getDnDMode(DnDMode_T *aDnDMode);
937	HRESULT setDnDMode(DnDMode_T aDnDMode);
938	HRESULT getTeleporterEnabled(BOOL *aTeleporterEnabled);
939	HRESULT setTeleporterEnabled(BOOL aTeleporterEnabled);
940	HRESULT getTeleporterPort(ULONG *aTeleporterPort);
941	HRESULT setTeleporterPort(ULONG aTeleporterPort);
942	HRESULT getTeleporterAddress(com::Utf8Str &aTeleporterAddress);
943	HRESULT setTeleporterAddress(const com::Utf8Str &aTeleporterAddress);
944	HRESULT getTeleporterPassword(com::Utf8Str &aTeleporterPassword);
945	HRESULT setTeleporterPassword(const com::Utf8Str &aTeleporterPassword);
946	HRESULT getParavirtProvider(ParavirtProvider_T *aParavirtProvider);
947	HRESULT setParavirtProvider(ParavirtProvider_T aParavirtProvider);
948	HRESULT getParavirtDebug(com::Utf8Str &aParavirtDebug);
949	HRESULT setParavirtDebug(const com::Utf8Str &aParavirtDebug);
950	HRESULT getFaultToleranceState(FaultToleranceState_T *aFaultToleranceState);
951	HRESULT setFaultToleranceState(FaultToleranceState_T aFaultToleranceState);
952	HRESULT getFaultTolerancePort(ULONG *aFaultTolerancePort);
953	HRESULT setFaultTolerancePort(ULONG aFaultTolerancePort);
954	HRESULT getFaultToleranceAddress(com::Utf8Str &aFaultToleranceAddress);
955	HRESULT setFaultToleranceAddress(const com::Utf8Str &aFaultToleranceAddress);
956	HRESULT getFaultTolerancePassword(com::Utf8Str &aFaultTolerancePassword);
957	HRESULT setFaultTolerancePassword(const com::Utf8Str &aFaultTolerancePassword);
958	HRESULT getFaultToleranceSyncInterval(ULONG *aFaultToleranceSyncInterval);
959	HRESULT setFaultToleranceSyncInterval(ULONG aFaultToleranceSyncInterval);
960	HRESULT getRTCUseUTC(BOOL *aRTCUseUTC);
961	HRESULT setRTCUseUTC(BOOL aRTCUseUTC);
962	HRESULT getIOCacheEnabled(BOOL *aIOCacheEnabled);
963	HRESULT setIOCacheEnabled(BOOL aIOCacheEnabled);
964	HRESULT getIOCacheSize(ULONG *aIOCacheSize);
965	HRESULT setIOCacheSize(ULONG aIOCacheSize);
966	HRESULT getPCIDeviceAssignments(std::vector<ComPtr<IPCIDeviceAttachment> > &aPCIDeviceAssignments);
967	HRESULT getBandwidthControl(ComPtr<IBandwidthControl> &aBandwidthControl);
968	HRESULT getTracingEnabled(BOOL *aTracingEnabled);
969	HRESULT setTracingEnabled(BOOL aTracingEnabled);
970	HRESULT getTracingConfig(com::Utf8Str &aTracingConfig);
971	HRESULT setTracingConfig(const com::Utf8Str &aTracingConfig);
972	HRESULT getAllowTracingToAccessVM(BOOL *aAllowTracingToAccessVM);
973	HRESULT setAllowTracingToAccessVM(BOOL aAllowTracingToAccessVM);
974	HRESULT getAutostartEnabled(BOOL *aAutostartEnabled);
975	HRESULT setAutostartEnabled(BOOL aAutostartEnabled);
976	HRESULT getAutostartDelay(ULONG *aAutostartDelay);
977	HRESULT setAutostartDelay(ULONG aAutostartDelay);
978	HRESULT getAutostopType(AutostopType_T *aAutostopType);
979	HRESULT setAutostopType(AutostopType_T aAutostopType);
980	HRESULT getDefaultFrontend(com::Utf8Str &aDefaultFrontend);
981	HRESULT setDefaultFrontend(const com::Utf8Str &aDefaultFrontend);
982	HRESULT getUSBProxyAvailable(BOOL *aUSBProxyAvailable);
983	HRESULT getVMProcessPriority(com::Utf8Str &aVMProcessPriority);
984	HRESULT setVMProcessPriority(const com::Utf8Str &aVMProcessPriority);
985	HRESULT getUnattended(ComPtr<IUnattended> &aUnattended);
986
987	// wrapped IMachine methods
988	HRESULT lockMachine(const ComPtr<ISession> &aSession,
989	LockType_T aLockType);
990	HRESULT launchVMProcess(const ComPtr<ISession> &aSession,
991	const com::Utf8Str &aType,
992	const com::Utf8Str &aEnvironment,
993	ComPtr<IProgress> &aProgress);
994	HRESULT setBootOrder(ULONG aPosition,
995	DeviceType_T aDevice);
996	HRESULT getBootOrder(ULONG aPosition,
997	DeviceType_T *aDevice);
998	HRESULT attachDevice(const com::Utf8Str &aName,
999	LONG aControllerPort,
1000	LONG aDevice,
1001	DeviceType_T aType,
1002	const ComPtr<IMedium> &aMedium);
1003	HRESULT attachDeviceWithoutMedium(const com::Utf8Str &aName,
1004	LONG aControllerPort,
1005	LONG aDevice,
1006	DeviceType_T aType);
1007	HRESULT detachDevice(const com::Utf8Str &aName,
1008	LONG aControllerPort,
1009	LONG aDevice);
1010	HRESULT passthroughDevice(const com::Utf8Str &aName,
1011	LONG aControllerPort,
1012	LONG aDevice,
1013	BOOL aPassthrough);
1014	HRESULT temporaryEjectDevice(const com::Utf8Str &aName,
1015	LONG aControllerPort,
1016	LONG aDevice,
1017	BOOL aTemporaryEject);
1018	HRESULT nonRotationalDevice(const com::Utf8Str &aName,
1019	LONG aControllerPort,
1020	LONG aDevice,
1021	BOOL aNonRotational);
1022	HRESULT setAutoDiscardForDevice(const com::Utf8Str &aName,
1023	LONG aControllerPort,
1024	LONG aDevice,
1025	BOOL aDiscard);
1026	HRESULT setHotPluggableForDevice(const com::Utf8Str &aName,
1027	LONG aControllerPort,
1028	LONG aDevice,
1029	BOOL aHotPluggable);
1030	HRESULT setBandwidthGroupForDevice(const com::Utf8Str &aName,
1031	LONG aControllerPort,
1032	LONG aDevice,
1033	const ComPtr<IBandwidthGroup> &aBandwidthGroup);
1034	HRESULT setNoBandwidthGroupForDevice(const com::Utf8Str &aName,
1035	LONG aControllerPort,
1036	LONG aDevice);
1037	HRESULT unmountMedium(const com::Utf8Str &aName,
1038	LONG aControllerPort,
1039	LONG aDevice,
1040	BOOL aForce);
1041	HRESULT mountMedium(const com::Utf8Str &aName,
1042	LONG aControllerPort,
1043	LONG aDevice,
1044	const ComPtr<IMedium> &aMedium,
1045	BOOL aForce);
1046	HRESULT getMedium(const com::Utf8Str &aName,
1047	LONG aControllerPort,
1048	LONG aDevice,
1049	ComPtr<IMedium> &aMedium);
1050	HRESULT getMediumAttachmentsOfController(const com::Utf8Str &aName,
1051	std::vector<ComPtr<IMediumAttachment> > &aMediumAttachments);
1052	HRESULT getMediumAttachment(const com::Utf8Str &aName,
1053	LONG aControllerPort,
1054	LONG aDevice,
1055	ComPtr<IMediumAttachment> &aAttachment);
1056	HRESULT attachHostPCIDevice(LONG aHostAddress,
1057	LONG aDesiredGuestAddress,
1058	BOOL aTryToUnbind);
1059	HRESULT detachHostPCIDevice(LONG aHostAddress);
1060	HRESULT getNetworkAdapter(ULONG aSlot,
1061	ComPtr<INetworkAdapter> &aAdapter);
1062	HRESULT addStorageController(const com::Utf8Str &aName,
1063	StorageBus_T aConnectionType,
1064	ComPtr<IStorageController> &aController);
1065	HRESULT getStorageControllerByName(const com::Utf8Str &aName,
1066	ComPtr<IStorageController> &aStorageController);
1067	HRESULT getStorageControllerByInstance(StorageBus_T aConnectionType,
1068	ULONG aInstance,
1069	ComPtr<IStorageController> &aStorageController);
1070	HRESULT removeStorageController(const com::Utf8Str &aName);
1071	HRESULT setStorageControllerBootable(const com::Utf8Str &aName,
1072	BOOL aBootable);
1073	HRESULT addUSBController(const com::Utf8Str &aName,
1074	USBControllerType_T aType,
1075	ComPtr<IUSBController> &aController);
1076	HRESULT removeUSBController(const com::Utf8Str &aName);
1077	HRESULT getUSBControllerByName(const com::Utf8Str &aName,
1078	ComPtr<IUSBController> &aController);
1079	HRESULT getUSBControllerCountByType(USBControllerType_T aType,
1080	ULONG *aControllers);
1081	HRESULT getSerialPort(ULONG aSlot,
1082	ComPtr<ISerialPort> &aPort);
1083	HRESULT getParallelPort(ULONG aSlot,
1084	ComPtr<IParallelPort> &aPort);
1085	HRESULT getExtraDataKeys(std::vector<com::Utf8Str> &aKeys);
1086	HRESULT getExtraData(const com::Utf8Str &aKey,
1087	com::Utf8Str &aValue);
1088	HRESULT setExtraData(const com::Utf8Str &aKey,
1089	const com::Utf8Str &aValue);
1090	HRESULT getCPUProperty(CPUPropertyType_T aProperty,
1091	BOOL *aValue);
1092	HRESULT setCPUProperty(CPUPropertyType_T aProperty,
1093	BOOL aValue);
1094	HRESULT getCPUIDLeaf(ULONG aId,
1095	ULONG *aValEax,
1096	ULONG *aValEbx,
1097	ULONG *aValEcx,
1098	ULONG *aValEdx);
1099	HRESULT setCPUIDLeaf(ULONG aId,
1100	ULONG aValEax,
1101	ULONG aValEbx,
1102	ULONG aValEcx,
1103	ULONG aValEdx);
1104	HRESULT removeCPUIDLeaf(ULONG aId);
1105	HRESULT removeAllCPUIDLeaves();
1106	HRESULT getHWVirtExProperty(HWVirtExPropertyType_T aProperty,
1107	BOOL *aValue);
1108	HRESULT setHWVirtExProperty(HWVirtExPropertyType_T aProperty,
1109	BOOL aValue);
1110	HRESULT setSettingsFilePath(const com::Utf8Str &aSettingsFilePath,
1111	ComPtr<IProgress> &aProgress);
1112	HRESULT saveSettings();
1113	HRESULT discardSettings();
1114	HRESULT unregister(AutoCaller &aAutoCaller,
1115	CleanupMode_T aCleanupMode,
1116	std::vector<ComPtr<IMedium> > &aMedia);
1117	HRESULT deleteConfig(const std::vector<ComPtr<IMedium> > &aMedia,
1118	ComPtr<IProgress> &aProgress);
1119	HRESULT exportTo(const ComPtr<IAppliance> &aAppliance,
1120	const com::Utf8Str &aLocation,
1121	ComPtr<IVirtualSystemDescription> &aDescription);
1122	HRESULT findSnapshot(const com::Utf8Str &aNameOrId,
1123	ComPtr<ISnapshot> &aSnapshot);
1124	HRESULT createSharedFolder(const com::Utf8Str &aName,
1125	const com::Utf8Str &aHostPath,
1126	BOOL aWritable,
1127	BOOL aAutomount);
1128	HRESULT removeSharedFolder(const com::Utf8Str &aName);
1129	HRESULT canShowConsoleWindow(BOOL *aCanShow);
1130	HRESULT showConsoleWindow(LONG64 *aWinId);
1131	HRESULT getGuestProperty(const com::Utf8Str &aName,
1132	com::Utf8Str &aValue,
1133	LONG64 *aTimestamp,
1134	com::Utf8Str &aFlags);
1135	HRESULT getGuestPropertyValue(const com::Utf8Str &aProperty,
1136	com::Utf8Str &aValue);
1137	HRESULT getGuestPropertyTimestamp(const com::Utf8Str &aProperty,
1138	LONG64 *aValue);
1139	HRESULT setGuestProperty(const com::Utf8Str &aProperty,
1140	const com::Utf8Str &aValue,
1141	const com::Utf8Str &aFlags);
1142	HRESULT setGuestPropertyValue(const com::Utf8Str &aProperty,
1143	const com::Utf8Str &aValue);
1144	HRESULT deleteGuestProperty(const com::Utf8Str &aName);
1145	HRESULT enumerateGuestProperties(const com::Utf8Str &aPatterns,
1146	std::vector<com::Utf8Str> &aNames,
1147	std::vector<com::Utf8Str> &aValues,
1148	std::vector<LONG64> &aTimestamps,
1149	std::vector<com::Utf8Str> &aFlags);
1150	HRESULT querySavedGuestScreenInfo(ULONG aScreenId,
1151	ULONG *aOriginX,
1152	ULONG *aOriginY,
1153	ULONG *aWidth,
1154	ULONG *aHeight,
1155	BOOL *aEnabled);
1156	HRESULT readSavedThumbnailToArray(ULONG aScreenId,
1157	BitmapFormat_T aBitmapFormat,
1158	ULONG *aWidth,
1159	ULONG *aHeight,
1160	std::vector<BYTE> &aData);
1161	HRESULT querySavedScreenshotInfo(ULONG aScreenId,
1162	ULONG *aWidth,
1163	ULONG *aHeight,
1164	std::vector<BitmapFormat_T> &aBitmapFormats);
1165	HRESULT readSavedScreenshotToArray(ULONG aScreenId,
1166	BitmapFormat_T aBitmapFormat,
1167	ULONG *aWidth,
1168	ULONG *aHeight,
1169	std::vector<BYTE> &aData);
1170
1171	HRESULT hotPlugCPU(ULONG aCpu);
1172	HRESULT hotUnplugCPU(ULONG aCpu);
1173	HRESULT getCPUStatus(ULONG aCpu,
1174	BOOL *aAttached);
1175	HRESULT getEffectiveParavirtProvider(ParavirtProvider_T *aParavirtProvider);
1176	HRESULT queryLogFilename(ULONG aIdx,
1177	com::Utf8Str &aFilename);
1178	HRESULT readLog(ULONG aIdx,
1179	LONG64 aOffset,
1180	LONG64 aSize,
1181	std::vector<BYTE> &aData);
1182	HRESULT cloneTo(const ComPtr<IMachine> &aTarget,
1183	CloneMode_T aMode,
1184	const std::vector<CloneOptions_T> &aOptions,
1185	ComPtr<IProgress> &aProgress);
1186	HRESULT saveState(ComPtr<IProgress> &aProgress);
1187	HRESULT adoptSavedState(const com::Utf8Str &aSavedStateFile);
1188	HRESULT discardSavedState(BOOL aFRemoveFile);
1189	HRESULT takeSnapshot(const com::Utf8Str &aName,
1190	const com::Utf8Str &aDescription,
1191	BOOL aPause,
1192	com::Guid &aId,
1193	ComPtr<IProgress> &aProgress);
1194	HRESULT deleteSnapshot(const com::Guid &aId,
1195	ComPtr<IProgress> &aProgress);
1196	HRESULT deleteSnapshotAndAllChildren(const com::Guid &aId,
1197	ComPtr<IProgress> &aProgress);
1198	HRESULT deleteSnapshotRange(const com::Guid &aStartId,
1199	const com::Guid &aEndId,
1200	ComPtr<IProgress> &aProgress);
1201	HRESULT restoreSnapshot(const ComPtr<ISnapshot> &aSnapshot,
1202	ComPtr<IProgress> &aProgress);
1203	HRESULT applyDefaults(const com::Utf8Str &aFlags);
1204
1205	// wrapped IInternalMachineControl properties
1206
1207	// wrapped IInternalMachineControl methods
1208	HRESULT updateState(MachineState_T aState);
1209	HRESULT beginPowerUp(const ComPtr<IProgress> &aProgress);
1210	HRESULT endPowerUp(LONG aResult);
1211	HRESULT beginPoweringDown(ComPtr<IProgress> &aProgress);
1212	HRESULT endPoweringDown(LONG aResult,
1213	const com::Utf8Str &aErrMsg);
1214	HRESULT runUSBDeviceFilters(const ComPtr<IUSBDevice> &aDevice,
1215	BOOL *aMatched,
1216	ULONG *aMaskedInterfaces);
1217	HRESULT captureUSBDevice(const com::Guid &aId,
1218	const com::Utf8Str &aCaptureFilename);
1219	HRESULT detachUSBDevice(const com::Guid &aId,
1220	BOOL aDone);
1221	HRESULT autoCaptureUSBDevices();
1222	HRESULT detachAllUSBDevices(BOOL aDone);
1223	HRESULT onSessionEnd(const ComPtr<ISession> &aSession,
1224	ComPtr<IProgress> &aProgress);
1225	HRESULT finishOnlineMergeMedium();
1226	HRESULT pullGuestProperties(std::vector<com::Utf8Str> &aNames,
1227	std::vector<com::Utf8Str> &aValues,
1228	std::vector<LONG64> &aTimestamps,
1229	std::vector<com::Utf8Str> &aFlags);
1230	HRESULT pushGuestProperty(const com::Utf8Str &aName,
1231	const com::Utf8Str &aValue,
1232	LONG64 aTimestamp,
1233	const com::Utf8Str &aFlags);
1234	HRESULT lockMedia();
1235	HRESULT unlockMedia();
1236	HRESULT ejectMedium(const ComPtr<IMediumAttachment> &aAttachment,
1237	ComPtr<IMediumAttachment> &aNewAttachment);
1238	HRESULT reportVmStatistics(ULONG aValidStats,
1239	ULONG aCpuUser,
1240	ULONG aCpuKernel,
1241	ULONG aCpuIdle,
1242	ULONG aMemTotal,
1243	ULONG aMemFree,
1244	ULONG aMemBalloon,
1245	ULONG aMemShared,
1246	ULONG aMemCache,
1247	ULONG aPagedTotal,
1248	ULONG aMemAllocTotal,
1249	ULONG aMemFreeTotal,
1250	ULONG aMemBalloonTotal,
1251	ULONG aMemSharedTotal,
1252	ULONG aVmNetRx,
1253	ULONG aVmNetTx);
1254	HRESULT authenticateExternal(const std::vector<com::Utf8Str> &aAuthParams,
1255	com::Utf8Str &aResult);
1256	};
1257
1258	// SessionMachine class
1259	////////////////////////////////////////////////////////////////////////////////
1260
1261	/**
1262	* @note Notes on locking objects of this class:
1263	* SessionMachine shares some data with the primary Machine instance (pointed
1264	* to by the \|mPeer\| member). In order to provide data consistency it also
1265	* shares its lock handle. This means that whenever you lock a SessionMachine
1266	* instance using Auto[Reader]Lock or AutoMultiLock, the corresponding Machine
1267	* instance is also locked in the same lock mode. Keep it in mind.
1268	*/
1269	class ATL_NO_VTABLE SessionMachine :
1270	public Machine
1271	{
1272	public:
1273	VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(SessionMachine, IMachine)
1274
1275	DECLARE_NOT_AGGREGATABLE(SessionMachine)
1276
1277	DECLARE_PROTECT_FINAL_CONSTRUCT()
1278
1279	BEGIN_COM_MAP(SessionMachine)
1280	COM_INTERFACE_ENTRY(ISupportErrorInfo)
1281	COM_INTERFACE_ENTRY(IMachine)
1282	COM_INTERFACE_ENTRY2(IDispatch, IMachine)
1283	COM_INTERFACE_ENTRY(IInternalMachineControl)
1284	VBOX_TWEAK_INTERFACE_ENTRY(IMachine)
1285	END_COM_MAP()
1286
1287	DECLARE_EMPTY_CTOR_DTOR(SessionMachine)
1288
1289	HRESULT FinalConstruct();
1290	void FinalRelease();
1291
1292	struct Uninit
1293	{
1294	enum Reason { Unexpected, Abnormal, Normal };
1295	};
1296
1297	// public initializer/uninitializer for internal purposes only
1298	HRESULT init(Machine *aMachine);
1299	void uninit() { uninit(Uninit::Unexpected); }
1300	void uninit(Uninit::Reason aReason);
1301
1302
1303	// util::Lockable interface
1304	RWLockHandle *lockHandle() const;
1305
1306	// public methods only for internal purposes
1307
1308	virtual bool i_isSessionMachine() const
1309	{
1310	return true;
1311	}
1312
1313	#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
1314	bool i_checkForDeath();
1315
1316	void i_getTokenId(Utf8Str &strTokenId);
1317	#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
1318	IToken *i_getToken();
1319	#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
1320	// getClientToken must be only used by callers who can guarantee that
1321	// the object cannot be deleted in the mean time, i.e. have a caller/lock.
1322	ClientToken *i_getClientToken();
1323
1324	HRESULT i_onNetworkAdapterChange(INetworkAdapter *networkAdapter, BOOL changeAdapter);
1325	HRESULT i_onNATRedirectRuleChange(ULONG ulSlot, BOOL aNatRuleRemove, IN_BSTR aRuleName,
1326	NATProtocol_T aProto, IN_BSTR aHostIp, LONG aHostPort,
1327	IN_BSTR aGuestIp, LONG aGuestPort);
1328	HRESULT i_onStorageControllerChange();
1329	HRESULT i_onMediumChange(IMediumAttachment *aMediumAttachment, BOOL aForce);
1330	HRESULT i_onSerialPortChange(ISerialPort *serialPort);
1331	HRESULT i_onParallelPortChange(IParallelPort *parallelPort);
1332	HRESULT i_onCPUChange(ULONG aCPU, BOOL aRemove);
1333	HRESULT i_onVRDEServerChange(BOOL aRestart);
1334	HRESULT i_onVideoCaptureChange();
1335	HRESULT i_onUSBControllerChange();
1336	HRESULT i_onUSBDeviceAttach(IUSBDevice *aDevice,
1337	IVirtualBoxErrorInfo *aError,
1338	ULONG aMaskedIfs,
1339	const com::Utf8Str &aCaptureFilename);
1340	HRESULT i_onUSBDeviceDetach(IN_BSTR aId,
1341	IVirtualBoxErrorInfo *aError);
1342	HRESULT i_onSharedFolderChange();
1343	HRESULT i_onClipboardModeChange(ClipboardMode_T aClipboardMode);
1344	HRESULT i_onDnDModeChange(DnDMode_T aDnDMode);
1345	HRESULT i_onBandwidthGroupChange(IBandwidthGroup *aBandwidthGroup);
1346	HRESULT i_onStorageDeviceChange(IMediumAttachment *aMediumAttachment, BOOL aRemove, BOOL aSilent);
1347	HRESULT i_onCPUExecutionCapChange(ULONG aCpuExecutionCap);
1348
1349	bool i_hasMatchingUSBFilter(const ComObjPtr<HostUSBDevice> &aDevice, ULONG *aMaskedIfs);
1350
1351	HRESULT i_lockMedia();
1352	HRESULT i_unlockMedia();
1353
1354	HRESULT i_saveStateWithReason(Reason_T aReason, ComPtr<IProgress> &aProgress);
1355
1356	private:
1357
1358	// wrapped IInternalMachineControl properties
1359
1360	// wrapped IInternalMachineControl methods
1361	HRESULT setRemoveSavedStateFile(BOOL aRemove);
1362	HRESULT updateState(MachineState_T aState);
1363	HRESULT beginPowerUp(const ComPtr<IProgress> &aProgress);
1364	HRESULT endPowerUp(LONG aResult);
1365	HRESULT beginPoweringDown(ComPtr<IProgress> &aProgress);
1366	HRESULT endPoweringDown(LONG aResult,
1367	const com::Utf8Str &aErrMsg);
1368	HRESULT runUSBDeviceFilters(const ComPtr<IUSBDevice> &aDevice,
1369	BOOL *aMatched,
1370	ULONG *aMaskedInterfaces);
1371	HRESULT captureUSBDevice(const com::Guid &aId, const com::Utf8Str &aCaptureFilename);
1372	HRESULT detachUSBDevice(const com::Guid &aId,
1373	BOOL aDone);
1374	HRESULT autoCaptureUSBDevices();
1375	HRESULT detachAllUSBDevices(BOOL aDone);
1376	HRESULT onSessionEnd(const ComPtr<ISession> &aSession,
1377	ComPtr<IProgress> &aProgress);
1378	HRESULT finishOnlineMergeMedium();
1379	HRESULT pullGuestProperties(std::vector<com::Utf8Str> &aNames,
1380	std::vector<com::Utf8Str> &aValues,
1381	std::vector<LONG64> &aTimestamps,
1382	std::vector<com::Utf8Str> &aFlags);
1383	HRESULT pushGuestProperty(const com::Utf8Str &aName,
1384	const com::Utf8Str &aValue,
1385	LONG64 aTimestamp,
1386	const com::Utf8Str &aFlags);
1387	HRESULT lockMedia();
1388	HRESULT unlockMedia();
1389	HRESULT ejectMedium(const ComPtr<IMediumAttachment> &aAttachment,
1390	ComPtr<IMediumAttachment> &aNewAttachment);
1391	HRESULT reportVmStatistics(ULONG aValidStats,
1392	ULONG aCpuUser,
1393	ULONG aCpuKernel,
1394	ULONG aCpuIdle,
1395	ULONG aMemTotal,
1396	ULONG aMemFree,
1397	ULONG aMemBalloon,
1398	ULONG aMemShared,
1399	ULONG aMemCache,
1400	ULONG aPagedTotal,
1401	ULONG aMemAllocTotal,
1402	ULONG aMemFreeTotal,
1403	ULONG aMemBalloonTotal,
1404	ULONG aMemSharedTotal,
1405	ULONG aVmNetRx,
1406	ULONG aVmNetTx);
1407	HRESULT authenticateExternal(const std::vector<com::Utf8Str> &aAuthParams,
1408	com::Utf8Str &aResult);
1409
1410
1411	struct ConsoleTaskData
1412	{
1413	ConsoleTaskData()
1414	: mLastState(MachineState_Null),
1415	mDeleteSnapshotInfo(NULL)
1416	{ }
1417
1418	MachineState_T mLastState;
1419	ComObjPtr<Progress> mProgress;
1420
1421	// used when deleting online snaphshot
1422	void *mDeleteSnapshotInfo;
1423	};
1424
1425	class SaveStateTask;
1426	class SnapshotTask;
1427	class TakeSnapshotTask;
1428	class DeleteSnapshotTask;
1429	class RestoreSnapshotTask;
1430
1431	void i_saveStateHandler(SaveStateTask &aTask);
1432
1433	// Override some functionality for SessionMachine, this is where the
1434	// real action happens (the Machine methods are just dummies).
1435	HRESULT saveState(ComPtr<IProgress> &aProgress);
1436	HRESULT adoptSavedState(const com::Utf8Str &aSavedStateFile);
1437	HRESULT discardSavedState(BOOL aFRemoveFile);
1438	HRESULT takeSnapshot(const com::Utf8Str &aName,
1439	const com::Utf8Str &aDescription,
1440	BOOL aPause,
1441	com::Guid &aId,
1442	ComPtr<IProgress> &aProgress);
1443	HRESULT deleteSnapshot(const com::Guid &aId,
1444	ComPtr<IProgress> &aProgress);
1445	HRESULT deleteSnapshotAndAllChildren(const com::Guid &aId,
1446	ComPtr<IProgress> &aProgress);
1447	HRESULT deleteSnapshotRange(const com::Guid &aStartId,
1448	const com::Guid &aEndId,
1449	ComPtr<IProgress> &aProgress);
1450	HRESULT restoreSnapshot(const ComPtr<ISnapshot> &aSnapshot,
1451	ComPtr<IProgress> &aProgress);
1452
1453	void i_releaseSavedStateFile(const Utf8Str &strSavedStateFile, Snapshot *pSnapshotToIgnore);
1454
1455	void i_takeSnapshotHandler(TakeSnapshotTask &aTask);
1456	static void i_takeSnapshotProgressCancelCallback(void *pvUser);
1457	HRESULT i_finishTakingSnapshot(TakeSnapshotTask &aTask, AutoWriteLock &alock, bool aSuccess);
1458	HRESULT i_deleteSnapshot(const com::Guid &aStartId,
1459	const com::Guid &aEndId,
1460	BOOL aDeleteAllChildren,
1461	ComPtr<IProgress> &aProgress);
1462	void i_deleteSnapshotHandler(DeleteSnapshotTask &aTask);
1463	void i_restoreSnapshotHandler(RestoreSnapshotTask &aTask);
1464
1465	HRESULT i_prepareDeleteSnapshotMedium(const ComObjPtr<Medium> &aHD,
1466	const Guid &machineId,
1467	const Guid &snapshotId,
1468	bool fOnlineMergePossible,
1469	MediumLockList *aVMMALockList,
1470	ComObjPtr<Medium> &aSource,
1471	ComObjPtr<Medium> &aTarget,
1472	bool &fMergeForward,
1473	ComObjPtr<Medium> &pParentForTarget,
1474	MediumLockList * &aChildrenToReparent,
1475	bool &fNeedOnlineMerge,
1476	MediumLockList * &aMediumLockList,
1477	ComPtr<IToken> &aHDLockToken);
1478	void i_cancelDeleteSnapshotMedium(const ComObjPtr<Medium> &aHD,
1479	const ComObjPtr<Medium> &aSource,
1480	MediumLockList *aChildrenToReparent,
1481	bool fNeedsOnlineMerge,
1482	MediumLockList *aMediumLockList,
1483	const ComPtr<IToken> &aHDLockToken,
1484	const Guid &aMediumId,
1485	const Guid &aSnapshotId);
1486	HRESULT i_onlineMergeMedium(const ComObjPtr<MediumAttachment> &aMediumAttachment,
1487	const ComObjPtr<Medium> &aSource,
1488	const ComObjPtr<Medium> &aTarget,
1489	bool fMergeForward,
1490	const ComObjPtr<Medium> &pParentForTarget,
1491	MediumLockList *aChildrenToReparent,
1492	MediumLockList *aMediumLockList,
1493	ComObjPtr<Progress> &aProgress,
1494	bool *pfNeedsMachineSaveSettings);
1495
1496	HRESULT i_setMachineState(MachineState_T aMachineState);
1497	HRESULT i_updateMachineStateOnClient();
1498
1499	bool mRemoveSavedState;
1500
1501	ConsoleTaskData mConsoleTaskData;
1502
1503	/** client token for this machine */
1504	ClientToken *mClientToken;
1505
1506	int miNATNetworksStarted;
1507
1508	AUTHLIBRARYCONTEXT mAuthLibCtx;
1509	};
1510
1511	// SnapshotMachine class
1512	////////////////////////////////////////////////////////////////////////////////
1513
1514	/**
1515	* @note Notes on locking objects of this class:
1516	* SnapshotMachine shares some data with the primary Machine instance (pointed
1517	* to by the \|mPeer\| member). In order to provide data consistency it also
1518	* shares its lock handle. This means that whenever you lock a SessionMachine
1519	* instance using Auto[Reader]Lock or AutoMultiLock, the corresponding Machine
1520	* instance is also locked in the same lock mode. Keep it in mind.
1521	*/
1522	class ATL_NO_VTABLE SnapshotMachine :
1523	public Machine
1524	{
1525	public:
1526	VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(SnapshotMachine, IMachine)
1527
1528	DECLARE_NOT_AGGREGATABLE(SnapshotMachine)
1529
1530	DECLARE_PROTECT_FINAL_CONSTRUCT()
1531
1532	BEGIN_COM_MAP(SnapshotMachine)
1533	COM_INTERFACE_ENTRY(ISupportErrorInfo)
1534	COM_INTERFACE_ENTRY(IMachine)
1535	COM_INTERFACE_ENTRY2(IDispatch, IMachine)
1536	VBOX_TWEAK_INTERFACE_ENTRY(IMachine)
1537	END_COM_MAP()
1538
1539	DECLARE_EMPTY_CTOR_DTOR(SnapshotMachine)
1540
1541	HRESULT FinalConstruct();
1542	void FinalRelease();
1543
1544	// public initializer/uninitializer for internal purposes only
1545	HRESULT init(SessionMachine *aSessionMachine,
1546	IN_GUID aSnapshotId,
1547	const Utf8Str &aStateFilePath);
1548	HRESULT initFromSettings(Machine *aMachine,
1549	const settings::Hardware &hardware,
1550	const settings::Debugging *pDbg,
1551	const settings::Autostart *pAutostart,
1552	IN_GUID aSnapshotId,
1553	const Utf8Str &aStateFilePath);
1554	void uninit();
1555
1556	// util::Lockable interface
1557	RWLockHandle *lockHandle() const;
1558
1559	// public methods only for internal purposes
1560
1561	virtual bool i_isSnapshotMachine() const
1562	{
1563	return true;
1564	}
1565
1566	HRESULT i_onSnapshotChange(Snapshot *aSnapshot);
1567
1568	// unsafe inline public methods for internal purposes only (ensure there is
1569	// a caller and a read lock before calling them!)
1570
1571	const Guid& i_getSnapshotId() const { return mSnapshotId; }
1572
1573	private:
1574
1575	Guid mSnapshotId;
1576	/** This field replaces mPeer for SessionMachine instances, as having
1577	* a peer reference is plain meaningless and causes many subtle problems
1578	* with saving settings and the like. */
1579	Machine * const mMachine;
1580
1581	friend class Snapshot;
1582	};
1583
1584	// third party methods that depend on SnapshotMachine definition
1585
1586	inline const Guid &Machine::i_getSnapshotId() const
1587	{
1588	return (i_isSnapshotMachine())
1589	? static_cast<const SnapshotMachine*>(this)->i_getSnapshotId()
1590	: Guid::Empty;
1591	}
1592
1593
1594	#endif // ____H_MACHINEIMPL
1595	/* 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@ 66311

Download in other formats: