MachineImpl.h@ 78897

Last change on this file since 78897 was 78897, checked in by vboxsync, 6 years ago
Shared Clipboard/URI: Update.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 69.5 KB

Line
1	/* $Id: MachineImpl.h 78897 2019-05-31 15:23:14Z 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 getFaultToleranceState(FaultToleranceState_T *aFaultToleranceState);
945	HRESULT setFaultToleranceState(FaultToleranceState_T aFaultToleranceState);
946	HRESULT getFaultTolerancePort(ULONG *aFaultTolerancePort);
947	HRESULT setFaultTolerancePort(ULONG aFaultTolerancePort);
948	HRESULT getFaultToleranceAddress(com::Utf8Str &aFaultToleranceAddress);
949	HRESULT setFaultToleranceAddress(const com::Utf8Str &aFaultToleranceAddress);
950	HRESULT getFaultTolerancePassword(com::Utf8Str &aFaultTolerancePassword);
951	HRESULT setFaultTolerancePassword(const com::Utf8Str &aFaultTolerancePassword);
952	HRESULT getFaultToleranceSyncInterval(ULONG *aFaultToleranceSyncInterval);
953	HRESULT setFaultToleranceSyncInterval(ULONG aFaultToleranceSyncInterval);
954	HRESULT getRTCUseUTC(BOOL *aRTCUseUTC);
955	HRESULT setRTCUseUTC(BOOL aRTCUseUTC);
956	HRESULT getIOCacheEnabled(BOOL *aIOCacheEnabled);
957	HRESULT setIOCacheEnabled(BOOL aIOCacheEnabled);
958	HRESULT getIOCacheSize(ULONG *aIOCacheSize);
959	HRESULT setIOCacheSize(ULONG aIOCacheSize);
960	HRESULT getPCIDeviceAssignments(std::vector<ComPtr<IPCIDeviceAttachment> > &aPCIDeviceAssignments);
961	HRESULT getBandwidthControl(ComPtr<IBandwidthControl> &aBandwidthControl);
962	HRESULT getTracingEnabled(BOOL *aTracingEnabled);
963	HRESULT setTracingEnabled(BOOL aTracingEnabled);
964	HRESULT getTracingConfig(com::Utf8Str &aTracingConfig);
965	HRESULT setTracingConfig(const com::Utf8Str &aTracingConfig);
966	HRESULT getAllowTracingToAccessVM(BOOL *aAllowTracingToAccessVM);
967	HRESULT setAllowTracingToAccessVM(BOOL aAllowTracingToAccessVM);
968	HRESULT getAutostartEnabled(BOOL *aAutostartEnabled);
969	HRESULT setAutostartEnabled(BOOL aAutostartEnabled);
970	HRESULT getAutostartDelay(ULONG *aAutostartDelay);
971	HRESULT setAutostartDelay(ULONG aAutostartDelay);
972	HRESULT getAutostopType(AutostopType_T *aAutostopType);
973	HRESULT setAutostopType(AutostopType_T aAutostopType);
974	HRESULT getDefaultFrontend(com::Utf8Str &aDefaultFrontend);
975	HRESULT setDefaultFrontend(const com::Utf8Str &aDefaultFrontend);
976	HRESULT getUSBProxyAvailable(BOOL *aUSBProxyAvailable);
977	HRESULT getVMProcessPriority(VMProcPriority_T *aVMProcessPriority);
978	HRESULT setVMProcessPriority(VMProcPriority_T aVMProcessPriority);
979
980	// wrapped IMachine methods
981	HRESULT lockMachine(const ComPtr<ISession> &aSession,
982	LockType_T aLockType);
983	HRESULT launchVMProcess(const ComPtr<ISession> &aSession,
984	const com::Utf8Str &aType,
985	const com::Utf8Str &aEnvironment,
986	ComPtr<IProgress> &aProgress);
987	HRESULT setBootOrder(ULONG aPosition,
988	DeviceType_T aDevice);
989	HRESULT getBootOrder(ULONG aPosition,
990	DeviceType_T *aDevice);
991	HRESULT attachDevice(const com::Utf8Str &aName,
992	LONG aControllerPort,
993	LONG aDevice,
994	DeviceType_T aType,
995	const ComPtr<IMedium> &aMedium);
996	HRESULT attachDeviceWithoutMedium(const com::Utf8Str &aName,
997	LONG aControllerPort,
998	LONG aDevice,
999	DeviceType_T aType);
1000	HRESULT detachDevice(const com::Utf8Str &aName,
1001	LONG aControllerPort,
1002	LONG aDevice);
1003	HRESULT passthroughDevice(const com::Utf8Str &aName,
1004	LONG aControllerPort,
1005	LONG aDevice,
1006	BOOL aPassthrough);
1007	HRESULT temporaryEjectDevice(const com::Utf8Str &aName,
1008	LONG aControllerPort,
1009	LONG aDevice,
1010	BOOL aTemporaryEject);
1011	HRESULT nonRotationalDevice(const com::Utf8Str &aName,
1012	LONG aControllerPort,
1013	LONG aDevice,
1014	BOOL aNonRotational);
1015	HRESULT setAutoDiscardForDevice(const com::Utf8Str &aName,
1016	LONG aControllerPort,
1017	LONG aDevice,
1018	BOOL aDiscard);
1019	HRESULT setHotPluggableForDevice(const com::Utf8Str &aName,
1020	LONG aControllerPort,
1021	LONG aDevice,
1022	BOOL aHotPluggable);
1023	HRESULT setBandwidthGroupForDevice(const com::Utf8Str &aName,
1024	LONG aControllerPort,
1025	LONG aDevice,
1026	const ComPtr<IBandwidthGroup> &aBandwidthGroup);
1027	HRESULT setNoBandwidthGroupForDevice(const com::Utf8Str &aName,
1028	LONG aControllerPort,
1029	LONG aDevice);
1030	HRESULT unmountMedium(const com::Utf8Str &aName,
1031	LONG aControllerPort,
1032	LONG aDevice,
1033	BOOL aForce);
1034	HRESULT mountMedium(const com::Utf8Str &aName,
1035	LONG aControllerPort,
1036	LONG aDevice,
1037	const ComPtr<IMedium> &aMedium,
1038	BOOL aForce);
1039	HRESULT getMedium(const com::Utf8Str &aName,
1040	LONG aControllerPort,
1041	LONG aDevice,
1042	ComPtr<IMedium> &aMedium);
1043	HRESULT getMediumAttachmentsOfController(const com::Utf8Str &aName,
1044	std::vector<ComPtr<IMediumAttachment> > &aMediumAttachments);
1045	HRESULT getMediumAttachment(const com::Utf8Str &aName,
1046	LONG aControllerPort,
1047	LONG aDevice,
1048	ComPtr<IMediumAttachment> &aAttachment);
1049	HRESULT attachHostPCIDevice(LONG aHostAddress,
1050	LONG aDesiredGuestAddress,
1051	BOOL aTryToUnbind);
1052	HRESULT detachHostPCIDevice(LONG aHostAddress);
1053	HRESULT getNetworkAdapter(ULONG aSlot,
1054	ComPtr<INetworkAdapter> &aAdapter);
1055	HRESULT addStorageController(const com::Utf8Str &aName,
1056	StorageBus_T aConnectionType,
1057	ComPtr<IStorageController> &aController);
1058	HRESULT getStorageControllerByName(const com::Utf8Str &aName,
1059	ComPtr<IStorageController> &aStorageController);
1060	HRESULT getStorageControllerByInstance(StorageBus_T aConnectionType,
1061	ULONG aInstance,
1062	ComPtr<IStorageController> &aStorageController);
1063	HRESULT removeStorageController(const com::Utf8Str &aName);
1064	HRESULT setStorageControllerBootable(const com::Utf8Str &aName,
1065	BOOL aBootable);
1066	HRESULT addUSBController(const com::Utf8Str &aName,
1067	USBControllerType_T aType,
1068	ComPtr<IUSBController> &aController);
1069	HRESULT removeUSBController(const com::Utf8Str &aName);
1070	HRESULT getUSBControllerByName(const com::Utf8Str &aName,
1071	ComPtr<IUSBController> &aController);
1072	HRESULT getUSBControllerCountByType(USBControllerType_T aType,
1073	ULONG *aControllers);
1074	HRESULT getSerialPort(ULONG aSlot,
1075	ComPtr<ISerialPort> &aPort);
1076	HRESULT getParallelPort(ULONG aSlot,
1077	ComPtr<IParallelPort> &aPort);
1078	HRESULT getExtraDataKeys(std::vector<com::Utf8Str> &aKeys);
1079	HRESULT getExtraData(const com::Utf8Str &aKey,
1080	com::Utf8Str &aValue);
1081	HRESULT setExtraData(const com::Utf8Str &aKey,
1082	const com::Utf8Str &aValue);
1083	HRESULT getCPUProperty(CPUPropertyType_T aProperty,
1084	BOOL *aValue);
1085	HRESULT setCPUProperty(CPUPropertyType_T aProperty,
1086	BOOL aValue);
1087	HRESULT getCPUIDLeafByOrdinal(ULONG aOrdinal,
1088	ULONG *aIdx,
1089	ULONG *aSubIdx,
1090	ULONG *aValEax,
1091	ULONG *aValEbx,
1092	ULONG *aValEcx,
1093	ULONG *aValEdx);
1094	HRESULT getCPUIDLeaf(ULONG aIdx, ULONG aSubIdx,
1095	ULONG *aValEax,
1096	ULONG *aValEbx,
1097	ULONG *aValEcx,
1098	ULONG *aValEdx);
1099	HRESULT setCPUIDLeaf(ULONG aIdx, ULONG aSubIdx,
1100	ULONG aValEax,
1101	ULONG aValEbx,
1102	ULONG aValEcx,
1103	ULONG aValEdx);
1104	HRESULT removeCPUIDLeaf(ULONG aIdx, ULONG aSubIdx);
1105	HRESULT removeAllCPUIDLeaves();
1106	HRESULT getHWVirtExProperty(HWVirtExPropertyType_T aProperty,
1107	BOOL *aValue);
1108	HRESULT setHWVirtExProperty(HWVirtExPropertyType_T aProperty,
1109	BOOL aValue);
1110	HRESULT setSettingsFilePath(const com::Utf8Str &aSettingsFilePath,
1111	ComPtr<IProgress> &aProgress);
1112	HRESULT saveSettings();
1113	HRESULT discardSettings();
1114	HRESULT unregister(AutoCaller &aAutoCaller,
1115	CleanupMode_T aCleanupMode,
1116	std::vector<ComPtr<IMedium> > &aMedia);
1117	HRESULT deleteConfig(const std::vector<ComPtr<IMedium> > &aMedia,
1118	ComPtr<IProgress> &aProgress);
1119	HRESULT exportTo(const ComPtr<IAppliance> &aAppliance,
1120	const com::Utf8Str &aLocation,
1121	ComPtr<IVirtualSystemDescription> &aDescription);
1122	HRESULT findSnapshot(const com::Utf8Str &aNameOrId,
1123	ComPtr<ISnapshot> &aSnapshot);
1124	HRESULT createSharedFolder(const com::Utf8Str &aName,
1125	const com::Utf8Str &aHostPath,
1126	BOOL aWritable,
1127	BOOL aAutomount,
1128	const com::Utf8Str &aAutoMountPoint);
1129	HRESULT removeSharedFolder(const com::Utf8Str &aName);
1130	HRESULT canShowConsoleWindow(BOOL *aCanShow);
1131	HRESULT showConsoleWindow(LONG64 *aWinId);
1132	HRESULT getGuestProperty(const com::Utf8Str &aName,
1133	com::Utf8Str &aValue,
1134	LONG64 *aTimestamp,
1135	com::Utf8Str &aFlags);
1136	HRESULT getGuestPropertyValue(const com::Utf8Str &aProperty,
1137	com::Utf8Str &aValue);
1138	HRESULT getGuestPropertyTimestamp(const com::Utf8Str &aProperty,
1139	LONG64 *aValue);
1140	HRESULT setGuestProperty(const com::Utf8Str &aProperty,
1141	const com::Utf8Str &aValue,
1142	const com::Utf8Str &aFlags);
1143	HRESULT setGuestPropertyValue(const com::Utf8Str &aProperty,
1144	const com::Utf8Str &aValue);
1145	HRESULT deleteGuestProperty(const com::Utf8Str &aName);
1146	HRESULT enumerateGuestProperties(const com::Utf8Str &aPatterns,
1147	std::vector<com::Utf8Str> &aNames,
1148	std::vector<com::Utf8Str> &aValues,
1149	std::vector<LONG64> &aTimestamps,
1150	std::vector<com::Utf8Str> &aFlags);
1151	HRESULT querySavedGuestScreenInfo(ULONG aScreenId,
1152	ULONG *aOriginX,
1153	ULONG *aOriginY,
1154	ULONG *aWidth,
1155	ULONG *aHeight,
1156	BOOL *aEnabled);
1157	HRESULT readSavedThumbnailToArray(ULONG aScreenId,
1158	BitmapFormat_T aBitmapFormat,
1159	ULONG *aWidth,
1160	ULONG *aHeight,
1161	std::vector<BYTE> &aData);
1162	HRESULT querySavedScreenshotInfo(ULONG aScreenId,
1163	ULONG *aWidth,
1164	ULONG *aHeight,
1165	std::vector<BitmapFormat_T> &aBitmapFormats);
1166	HRESULT readSavedScreenshotToArray(ULONG aScreenId,
1167	BitmapFormat_T aBitmapFormat,
1168	ULONG *aWidth,
1169	ULONG *aHeight,
1170	std::vector<BYTE> &aData);
1171
1172	HRESULT hotPlugCPU(ULONG aCpu);
1173	HRESULT hotUnplugCPU(ULONG aCpu);
1174	HRESULT getCPUStatus(ULONG aCpu,
1175	BOOL *aAttached);
1176	HRESULT getEffectiveParavirtProvider(ParavirtProvider_T *aParavirtProvider);
1177	HRESULT queryLogFilename(ULONG aIdx,
1178	com::Utf8Str &aFilename);
1179	HRESULT readLog(ULONG aIdx,
1180	LONG64 aOffset,
1181	LONG64 aSize,
1182	std::vector<BYTE> &aData);
1183	HRESULT cloneTo(const ComPtr<IMachine> &aTarget,
1184	CloneMode_T aMode,
1185	const std::vector<CloneOptions_T> &aOptions,
1186	ComPtr<IProgress> &aProgress);
1187	HRESULT moveTo(const com::Utf8Str &aTargetPath,
1188	const com::Utf8Str &aType,
1189	ComPtr<IProgress> &aProgress);
1190	HRESULT saveState(ComPtr<IProgress> &aProgress);
1191	HRESULT adoptSavedState(const com::Utf8Str &aSavedStateFile);
1192	HRESULT discardSavedState(BOOL aFRemoveFile);
1193	HRESULT takeSnapshot(const com::Utf8Str &aName,
1194	const com::Utf8Str &aDescription,
1195	BOOL aPause,
1196	com::Guid &aId,
1197	ComPtr<IProgress> &aProgress);
1198	HRESULT deleteSnapshot(const com::Guid &aId,
1199	ComPtr<IProgress> &aProgress);
1200	HRESULT deleteSnapshotAndAllChildren(const com::Guid &aId,
1201	ComPtr<IProgress> &aProgress);
1202	HRESULT deleteSnapshotRange(const com::Guid &aStartId,
1203	const com::Guid &aEndId,
1204	ComPtr<IProgress> &aProgress);
1205	HRESULT restoreSnapshot(const ComPtr<ISnapshot> &aSnapshot,
1206	ComPtr<IProgress> &aProgress);
1207	HRESULT applyDefaults(const com::Utf8Str &aFlags);
1208
1209	// wrapped IInternalMachineControl properties
1210
1211	// wrapped IInternalMachineControl methods
1212	HRESULT updateState(MachineState_T aState);
1213	HRESULT beginPowerUp(const ComPtr<IProgress> &aProgress);
1214	HRESULT endPowerUp(LONG aResult);
1215	HRESULT beginPoweringDown(ComPtr<IProgress> &aProgress);
1216	HRESULT endPoweringDown(LONG aResult,
1217	const com::Utf8Str &aErrMsg);
1218	HRESULT runUSBDeviceFilters(const ComPtr<IUSBDevice> &aDevice,
1219	BOOL *aMatched,
1220	ULONG *aMaskedInterfaces);
1221	HRESULT captureUSBDevice(const com::Guid &aId,
1222	const com::Utf8Str &aCaptureFilename);
1223	HRESULT detachUSBDevice(const com::Guid &aId,
1224	BOOL aDone);
1225	HRESULT autoCaptureUSBDevices();
1226	HRESULT detachAllUSBDevices(BOOL aDone);
1227	HRESULT onSessionEnd(const ComPtr<ISession> &aSession,
1228	ComPtr<IProgress> &aProgress);
1229	HRESULT finishOnlineMergeMedium();
1230	HRESULT clipboardAreaRegister(const std::vector<com::Utf8Str> &aParms, ULONG *aID);
1231	HRESULT clipboardAreaUnregister(ULONG aID);
1232	HRESULT clipboardAreaAttach(ULONG aID);
1233	HRESULT clipboardAreaDetach(ULONG aID);
1234	HRESULT clipboardAreaGetMostRecent(ULONG *aID);
1235	HRESULT clipboardAreaGetRefCount(ULONG aID, ULONG *aRefCount);
1236	HRESULT pullGuestProperties(std::vector<com::Utf8Str> &aNames,
1237	std::vector<com::Utf8Str> &aValues,
1238	std::vector<LONG64> &aTimestamps,
1239	std::vector<com::Utf8Str> &aFlags);
1240	HRESULT pushGuestProperty(const com::Utf8Str &aName,
1241	const com::Utf8Str &aValue,
1242	LONG64 aTimestamp,
1243	const com::Utf8Str &aFlags);
1244	HRESULT lockMedia();
1245	HRESULT unlockMedia();
1246	HRESULT ejectMedium(const ComPtr<IMediumAttachment> &aAttachment,
1247	ComPtr<IMediumAttachment> &aNewAttachment);
1248	HRESULT reportVmStatistics(ULONG aValidStats,
1249	ULONG aCpuUser,
1250	ULONG aCpuKernel,
1251	ULONG aCpuIdle,
1252	ULONG aMemTotal,
1253	ULONG aMemFree,
1254	ULONG aMemBalloon,
1255	ULONG aMemShared,
1256	ULONG aMemCache,
1257	ULONG aPagedTotal,
1258	ULONG aMemAllocTotal,
1259	ULONG aMemFreeTotal,
1260	ULONG aMemBalloonTotal,
1261	ULONG aMemSharedTotal,
1262	ULONG aVmNetRx,
1263	ULONG aVmNetTx);
1264	HRESULT authenticateExternal(const std::vector<com::Utf8Str> &aAuthParams,
1265	com::Utf8Str &aResult);
1266	};
1267
1268	// SessionMachine class
1269	////////////////////////////////////////////////////////////////////////////////
1270
1271	/**
1272	* @note Notes on locking objects of this class:
1273	* SessionMachine shares some data with the primary Machine instance (pointed
1274	* to by the \|mPeer\| member). In order to provide data consistency it also
1275	* shares its lock handle. This means that whenever you lock a SessionMachine
1276	* instance using Auto[Reader]Lock or AutoMultiLock, the corresponding Machine
1277	* instance is also locked in the same lock mode. Keep it in mind.
1278	*/
1279	class ATL_NO_VTABLE SessionMachine :
1280	public Machine
1281	{
1282	public:
1283	VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(SessionMachine, IMachine)
1284
1285	DECLARE_NOT_AGGREGATABLE(SessionMachine)
1286
1287	DECLARE_PROTECT_FINAL_CONSTRUCT()
1288
1289	BEGIN_COM_MAP(SessionMachine)
1290	COM_INTERFACE_ENTRY(ISupportErrorInfo)
1291	COM_INTERFACE_ENTRY(IMachine)
1292	COM_INTERFACE_ENTRY2(IDispatch, IMachine)
1293	COM_INTERFACE_ENTRY(IInternalMachineControl)
1294	VBOX_TWEAK_INTERFACE_ENTRY(IMachine)
1295	END_COM_MAP()
1296
1297	DECLARE_EMPTY_CTOR_DTOR(SessionMachine)
1298
1299	HRESULT FinalConstruct();
1300	void FinalRelease();
1301
1302	struct Uninit
1303	{
1304	enum Reason { Unexpected, Abnormal, Normal };
1305	};
1306
1307	// public initializer/uninitializer for internal purposes only
1308	HRESULT init(Machine *aMachine);
1309	void uninit() { uninit(Uninit::Unexpected); }
1310	void uninit(Uninit::Reason aReason);
1311
1312
1313	// util::Lockable interface
1314	RWLockHandle *lockHandle() const;
1315
1316	// public methods only for internal purposes
1317
1318	virtual bool i_isSessionMachine() const
1319	{
1320	return true;
1321	}
1322
1323	#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
1324	bool i_checkForDeath();
1325
1326	void i_getTokenId(Utf8Str &strTokenId);
1327	#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
1328	IToken *i_getToken();
1329	#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
1330	// getClientToken must be only used by callers who can guarantee that
1331	// the object cannot be deleted in the mean time, i.e. have a caller/lock.
1332	ClientToken *i_getClientToken();
1333
1334	HRESULT i_onNetworkAdapterChange(INetworkAdapter *networkAdapter, BOOL changeAdapter);
1335	HRESULT i_onNATRedirectRuleChange(ULONG ulSlot, BOOL aNatRuleRemove, IN_BSTR aRuleName,
1336	NATProtocol_T aProto, IN_BSTR aHostIp, LONG aHostPort,
1337	IN_BSTR aGuestIp, LONG aGuestPort);
1338	HRESULT i_onStorageControllerChange(const com::Guid &aMachineId, const com::Utf8Str &aControllerName);
1339	HRESULT i_onMediumChange(IMediumAttachment *aMediumAttachment, BOOL aForce);
1340	HRESULT i_onVMProcessPriorityChange(VMProcPriority_T aPriority);
1341	HRESULT i_onAudioAdapterChange(IAudioAdapter *audioAdapter);
1342	HRESULT i_onSerialPortChange(ISerialPort *serialPort);
1343	HRESULT i_onParallelPortChange(IParallelPort *parallelPort);
1344	HRESULT i_onCPUChange(ULONG aCPU, BOOL aRemove);
1345	HRESULT i_onVRDEServerChange(BOOL aRestart);
1346	HRESULT i_onRecordingChange(BOOL aEnable);
1347	HRESULT i_onUSBControllerChange();
1348	HRESULT i_onUSBDeviceAttach(IUSBDevice *aDevice,
1349	IVirtualBoxErrorInfo *aError,
1350	ULONG aMaskedIfs,
1351	const com::Utf8Str &aCaptureFilename);
1352	HRESULT i_onUSBDeviceDetach(IN_BSTR aId,
1353	IVirtualBoxErrorInfo *aError);
1354	HRESULT i_onSharedFolderChange();
1355	HRESULT i_onClipboardModeChange(ClipboardMode_T aClipboardMode);
1356	HRESULT i_onDnDModeChange(DnDMode_T aDnDMode);
1357	HRESULT i_onBandwidthGroupChange(IBandwidthGroup *aBandwidthGroup);
1358	HRESULT i_onStorageDeviceChange(IMediumAttachment *aMediumAttachment, BOOL aRemove, BOOL aSilent);
1359	HRESULT i_onCPUExecutionCapChange(ULONG aCpuExecutionCap);
1360
1361	bool i_hasMatchingUSBFilter(const ComObjPtr<HostUSBDevice> &aDevice, ULONG *aMaskedIfs);
1362
1363	HRESULT i_lockMedia();
1364	HRESULT i_unlockMedia();
1365
1366	HRESULT i_saveStateWithReason(Reason_T aReason, ComPtr<IProgress> &aProgress);
1367
1368	private:
1369
1370	// wrapped IInternalMachineControl properties
1371
1372	// wrapped IInternalMachineControl methods
1373	HRESULT setRemoveSavedStateFile(BOOL aRemove);
1374	HRESULT updateState(MachineState_T aState);
1375	HRESULT beginPowerUp(const ComPtr<IProgress> &aProgress);
1376	HRESULT endPowerUp(LONG aResult);
1377	HRESULT beginPoweringDown(ComPtr<IProgress> &aProgress);
1378	HRESULT endPoweringDown(LONG aResult,
1379	const com::Utf8Str &aErrMsg);
1380	HRESULT runUSBDeviceFilters(const ComPtr<IUSBDevice> &aDevice,
1381	BOOL *aMatched,
1382	ULONG *aMaskedInterfaces);
1383	HRESULT captureUSBDevice(const com::Guid &aId, const com::Utf8Str &aCaptureFilename);
1384	HRESULT detachUSBDevice(const com::Guid &aId,
1385	BOOL aDone);
1386	HRESULT autoCaptureUSBDevices();
1387	HRESULT detachAllUSBDevices(BOOL aDone);
1388	HRESULT onSessionEnd(const ComPtr<ISession> &aSession,
1389	ComPtr<IProgress> &aProgress);
1390	HRESULT finishOnlineMergeMedium();
1391	HRESULT clipboardAreaRegister(const std::vector<com::Utf8Str> &aParms, ULONG *aID);
1392	HRESULT clipboardAreaUnregister(ULONG aID);
1393	HRESULT clipboardAreaAttach(ULONG aID);
1394	HRESULT clipboardAreaDetach(ULONG aID);
1395	HRESULT clipboardAreaGetMostRecent(ULONG *aID);
1396	HRESULT clipboardAreaGetRefCount(ULONG aID, ULONG *aRefCount);
1397	HRESULT pullGuestProperties(std::vector<com::Utf8Str> &aNames,
1398	std::vector<com::Utf8Str> &aValues,
1399	std::vector<LONG64> &aTimestamps,
1400	std::vector<com::Utf8Str> &aFlags);
1401	HRESULT pushGuestProperty(const com::Utf8Str &aName,
1402	const com::Utf8Str &aValue,
1403	LONG64 aTimestamp,
1404	const com::Utf8Str &aFlags);
1405	HRESULT lockMedia();
1406	HRESULT unlockMedia();
1407	HRESULT ejectMedium(const ComPtr<IMediumAttachment> &aAttachment,
1408	ComPtr<IMediumAttachment> &aNewAttachment);
1409	HRESULT reportVmStatistics(ULONG aValidStats,
1410	ULONG aCpuUser,
1411	ULONG aCpuKernel,
1412	ULONG aCpuIdle,
1413	ULONG aMemTotal,
1414	ULONG aMemFree,
1415	ULONG aMemBalloon,
1416	ULONG aMemShared,
1417	ULONG aMemCache,
1418	ULONG aPagedTotal,
1419	ULONG aMemAllocTotal,
1420	ULONG aMemFreeTotal,
1421	ULONG aMemBalloonTotal,
1422	ULONG aMemSharedTotal,
1423	ULONG aVmNetRx,
1424	ULONG aVmNetTx);
1425	HRESULT authenticateExternal(const std::vector<com::Utf8Str> &aAuthParams,
1426	com::Utf8Str &aResult);
1427
1428
1429	struct ConsoleTaskData
1430	{
1431	ConsoleTaskData()
1432	: mLastState(MachineState_Null),
1433	mDeleteSnapshotInfo(NULL)
1434	{ }
1435
1436	MachineState_T mLastState;
1437	ComObjPtr<Progress> mProgress;
1438
1439	// used when deleting online snaphshot
1440	void *mDeleteSnapshotInfo;
1441	};
1442
1443	class SaveStateTask;
1444	class SnapshotTask;
1445	class TakeSnapshotTask;
1446	class DeleteSnapshotTask;
1447	class RestoreSnapshotTask;
1448
1449	void i_saveStateHandler(SaveStateTask &aTask);
1450
1451	// Override some functionality for SessionMachine, this is where the
1452	// real action happens (the Machine methods are just dummies).
1453	HRESULT saveState(ComPtr<IProgress> &aProgress);
1454	HRESULT adoptSavedState(const com::Utf8Str &aSavedStateFile);
1455	HRESULT discardSavedState(BOOL aFRemoveFile);
1456	HRESULT takeSnapshot(const com::Utf8Str &aName,
1457	const com::Utf8Str &aDescription,
1458	BOOL aPause,
1459	com::Guid &aId,
1460	ComPtr<IProgress> &aProgress);
1461	HRESULT deleteSnapshot(const com::Guid &aId,
1462	ComPtr<IProgress> &aProgress);
1463	HRESULT deleteSnapshotAndAllChildren(const com::Guid &aId,
1464	ComPtr<IProgress> &aProgress);
1465	HRESULT deleteSnapshotRange(const com::Guid &aStartId,
1466	const com::Guid &aEndId,
1467	ComPtr<IProgress> &aProgress);
1468	HRESULT restoreSnapshot(const ComPtr<ISnapshot> &aSnapshot,
1469	ComPtr<IProgress> &aProgress);
1470
1471	void i_releaseSavedStateFile(const Utf8Str &strSavedStateFile, Snapshot *pSnapshotToIgnore);
1472
1473	void i_takeSnapshotHandler(TakeSnapshotTask &aTask);
1474	static void i_takeSnapshotProgressCancelCallback(void *pvUser);
1475	HRESULT i_finishTakingSnapshot(TakeSnapshotTask &aTask, AutoWriteLock &alock, bool aSuccess);
1476	HRESULT i_deleteSnapshot(const com::Guid &aStartId,
1477	const com::Guid &aEndId,
1478	BOOL aDeleteAllChildren,
1479	ComPtr<IProgress> &aProgress);
1480	void i_deleteSnapshotHandler(DeleteSnapshotTask &aTask);
1481	void i_restoreSnapshotHandler(RestoreSnapshotTask &aTask);
1482
1483	HRESULT i_prepareDeleteSnapshotMedium(const ComObjPtr<Medium> &aHD,
1484	const Guid &machineId,
1485	const Guid &snapshotId,
1486	bool fOnlineMergePossible,
1487	MediumLockList *aVMMALockList,
1488	ComObjPtr<Medium> &aSource,
1489	ComObjPtr<Medium> &aTarget,
1490	bool &fMergeForward,
1491	ComObjPtr<Medium> &pParentForTarget,
1492	MediumLockList * &aChildrenToReparent,
1493	bool &fNeedOnlineMerge,
1494	MediumLockList * &aMediumLockList,
1495	ComPtr<IToken> &aHDLockToken);
1496	void i_cancelDeleteSnapshotMedium(const ComObjPtr<Medium> &aHD,
1497	const ComObjPtr<Medium> &aSource,
1498	MediumLockList *aChildrenToReparent,
1499	bool fNeedsOnlineMerge,
1500	MediumLockList *aMediumLockList,
1501	const ComPtr<IToken> &aHDLockToken,
1502	const Guid &aMediumId,
1503	const Guid &aSnapshotId);
1504	HRESULT i_onlineMergeMedium(const ComObjPtr<MediumAttachment> &aMediumAttachment,
1505	const ComObjPtr<Medium> &aSource,
1506	const ComObjPtr<Medium> &aTarget,
1507	bool fMergeForward,
1508	const ComObjPtr<Medium> &pParentForTarget,
1509	MediumLockList *aChildrenToReparent,
1510	MediumLockList *aMediumLockList,
1511	ComObjPtr<Progress> &aProgress,
1512	bool *pfNeedsMachineSaveSettings);
1513
1514	HRESULT i_setMachineState(MachineState_T aMachineState);
1515	HRESULT i_updateMachineStateOnClient();
1516
1517	bool mRemoveSavedState;
1518
1519	ConsoleTaskData mConsoleTaskData;
1520
1521	/** client token for this machine */
1522	ClientToken *mClientToken;
1523
1524	int miNATNetworksStarted;
1525
1526	AUTHLIBRARYCONTEXT mAuthLibCtx;
1527	};
1528
1529	// SnapshotMachine class
1530	////////////////////////////////////////////////////////////////////////////////
1531
1532	/**
1533	* @note Notes on locking objects of this class:
1534	* SnapshotMachine shares some data with the primary Machine instance (pointed
1535	* to by the \|mPeer\| member). In order to provide data consistency it also
1536	* shares its lock handle. This means that whenever you lock a SessionMachine
1537	* instance using Auto[Reader]Lock or AutoMultiLock, the corresponding Machine
1538	* instance is also locked in the same lock mode. Keep it in mind.
1539	*/
1540	class ATL_NO_VTABLE SnapshotMachine :
1541	public Machine
1542	{
1543	public:
1544	VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(SnapshotMachine, IMachine)
1545
1546	DECLARE_NOT_AGGREGATABLE(SnapshotMachine)
1547
1548	DECLARE_PROTECT_FINAL_CONSTRUCT()
1549
1550	BEGIN_COM_MAP(SnapshotMachine)
1551	COM_INTERFACE_ENTRY(ISupportErrorInfo)
1552	COM_INTERFACE_ENTRY(IMachine)
1553	COM_INTERFACE_ENTRY2(IDispatch, IMachine)
1554	VBOX_TWEAK_INTERFACE_ENTRY(IMachine)
1555	END_COM_MAP()
1556
1557	DECLARE_EMPTY_CTOR_DTOR(SnapshotMachine)
1558
1559	HRESULT FinalConstruct();
1560	void FinalRelease();
1561
1562	// public initializer/uninitializer for internal purposes only
1563	HRESULT init(SessionMachine *aSessionMachine,
1564	IN_GUID aSnapshotId,
1565	const Utf8Str &aStateFilePath);
1566	HRESULT initFromSettings(Machine *aMachine,
1567	const settings::Hardware &hardware,
1568	const settings::Debugging *pDbg,
1569	const settings::Autostart *pAutostart,
1570	IN_GUID aSnapshotId,
1571	const Utf8Str &aStateFilePath);
1572	void uninit();
1573
1574	// util::Lockable interface
1575	RWLockHandle *lockHandle() const;
1576
1577	// public methods only for internal purposes
1578
1579	virtual bool i_isSnapshotMachine() const
1580	{
1581	return true;
1582	}
1583
1584	HRESULT i_onSnapshotChange(Snapshot *aSnapshot);
1585
1586	// unsafe inline public methods for internal purposes only (ensure there is
1587	// a caller and a read lock before calling them!)
1588
1589	const Guid& i_getSnapshotId() const { return mSnapshotId; }
1590
1591	private:
1592
1593	Guid mSnapshotId;
1594	/** This field replaces mPeer for SessionMachine instances, as having
1595	* a peer reference is plain meaningless and causes many subtle problems
1596	* with saving settings and the like. */
1597	Machine * const mMachine;
1598
1599	friend class Snapshot;
1600	};
1601
1602	// third party methods that depend on SnapshotMachine definition
1603
1604	inline const Guid &Machine::i_getSnapshotId() const
1605	{
1606	return (i_isSnapshotMachine())
1607	? static_cast<const SnapshotMachine*>(this)->i_getSnapshotId()
1608	: Guid::Empty;
1609	}
1610
1611
1612	#endif /* !MAIN_INCLUDED_MachineImpl_h */
1613	/* 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@ 78897

Download in other formats: