MachineImpl.h@ 85769

Last change on this file since 85769 was 85769, checked in by vboxsync, 4 years ago
Main: bugref:9618 Added Main/API support for AMD-V Virtualized VMSAVE/VMLOAD hardware virtualization feature.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 68.7 KB

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

Download in other formats: