MachineImpl.h@ 94735

Last change on this file since 94735 was 94735, checked in by vboxsync, 3 years ago
Main/MachineImpl: First part of the full VM encryption integration, creating an encrypted VM works now, bugref:9955
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 71.1 KB

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

Download in other formats: