MachineImpl.h@ 81087

Last change on this file since 81087 was 81087, checked in by vboxsync, 5 years ago
Main/Machine+BIOSSettings: bare bones NVRAM logic, many parts missing (no snapshot handling, no move VM handling, no remove VM handling). Main/Settings: adaptions to store NVRAM config in the settings file Frontends/VBoxManage: support enabling and showing state
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 68.8 KB

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

Download in other formats: