MachineImpl.h@ 98102

Last change on this file since 98102 was 96888, checked in by vboxsync, 2 years ago
Main,FE/VBoxManage: Implement possiblity to configure some of the guest debugging facilities to make it more accessible, bugref:1098
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 73.3 KB

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

Download in other formats: