MachineImpl.h@ 58383

Last change on this file since 58383 was 58383, checked in by vboxsync, 9 years ago
Main: an option to use VRDE auth library from VBoxSVC (not enabled)
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 68.1 KB

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

Download in other formats: