MachineImpl.h@ 80612

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

Download in other formats: