MachineImpl.h@ 5713

Last change on this file since 5713 was 5713, checked in by vboxsync, 17 years ago
Added an maskedInterface property to the USB filters. It is used to hide a set of interface from the guest, which means that on Linux we won't capture those and linux can continue using them.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 33.7 KB

Line
1	/** @file
2	*
3	* VirtualBox COM class declaration
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 innotek GmbH
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 as published by the Free Software Foundation,
13	* in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14	* distribution. VirtualBox OSE is distributed in the hope that it will
15	* be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	#ifndef ____H_MACHINEIMPL
19	#define ____H_MACHINEIMPL
20
21	#include "VirtualBoxBase.h"
22	#include "VirtualBoxXMLUtil.h"
23	#include "ProgressImpl.h"
24	#include "SnapshotImpl.h"
25	#include "VRDPServerImpl.h"
26	#include "DVDDriveImpl.h"
27	#include "FloppyDriveImpl.h"
28	#include "HardDiskAttachmentImpl.h"
29	#include "Collection.h"
30	#include "NetworkAdapterImpl.h"
31	#include "AudioAdapterImpl.h"
32	#include "SerialPortImpl.h"
33	#include "ParallelPortImpl.h"
34	#include "BIOSSettingsImpl.h"
35
36	// generated header
37	#include "SchemaDefs.h"
38
39	#include <VBox/types.h>
40	#include <VBox/cfgldr.h>
41	#include <iprt/file.h>
42	#include <iprt/thread.h>
43
44	#include <list>
45
46	// defines
47	////////////////////////////////////////////////////////////////////////////////
48
49	// helper declarations
50	////////////////////////////////////////////////////////////////////////////////
51
52	class VirtualBox;
53	class Progress;
54	class CombinedProgress;
55	class Keyboard;
56	class Mouse;
57	class Display;
58	class MachineDebugger;
59	class USBController;
60	class Snapshot;
61	class SharedFolder;
62	class HostUSBDevice;
63
64	class SessionMachine;
65
66	// Machine class
67	////////////////////////////////////////////////////////////////////////////////
68
69	class ATL_NO_VTABLE Machine :
70	public VirtualBoxBaseWithChildrenNEXT,
71	public VirtualBoxXMLUtil,
72	public VirtualBoxSupportErrorInfoImpl <Machine, IMachine>,
73	public VirtualBoxSupportTranslation <Machine>,
74	public IMachine
75	{
76	Q_OBJECT
77
78	public:
79
80	/**
81	* Internal machine data.
82	*
83	* Only one instance of this data exists per every machine --
84	* it is shared by the Machine, SessionMachine and all SnapshotMachine
85	* instances associated with the given machine using the util::Shareable
86	* template through the mData variable.
87	*
88	* @note \|const\| members are persistent during lifetime so can be
89	* accessed without locking.
90	*
91	* @note There is no need to lock anything inside init() or uninit()
92	* methods, because they are always serialized (see AutoCaller).
93	*/
94	struct Data
95	{
96	/**
97	* Data structure to hold information about sessions opened for the
98	* given machine.
99	*/
100	struct Session
101	{
102	/** Control of the direct session opened by openSession() */
103	ComPtr <IInternalSessionControl> mDirectControl;
104
105	typedef std::list <ComPtr <IInternalSessionControl> > RemoteControlList;
106
107	/** list of controls of all opened remote sessions */
108	RemoteControlList mRemoteControls;
109
110	/** openRemoteSession() and OnSessionEnd() progress indicator */
111	ComObjPtr <Progress> mProgress;
112
113	/**
114	* PID of the session object that must be passed to openSession()
115	* to finalize the openRemoteSession() request
116	* (i.e., PID of the process created by openRemoteSession())
117	*/
118	RTPROCESS mPid;
119
120	/** Current session state */
121	SessionState_T mState;
122
123	/** Session type string (for indirect sessions) */
124	Bstr mType;
125
126	/** Sesison machine object */
127	ComObjPtr <SessionMachine> mMachine;
128	};
129
130	Data();
131	~Data();
132
133	const Guid mUuid;
134	BOOL mRegistered;
135
136	Bstr mConfigFile;
137	Bstr mConfigFileFull;
138
139	BOOL mAccessible;
140	com::ErrorInfo mAccessError;
141
142	MachineState_T mMachineState;
143	LONG64 mLastStateChange;
144
145	uint32_t mMachineStateDeps;
146	RTSEMEVENT mZeroMachineStateDepsSem;
147	BOOL mWaitingStateDeps;
148
149	BOOL mCurrentStateModified;
150
151	RTFILE mHandleCfgFile;
152
153	Session mSession;
154
155	ComObjPtr <Snapshot> mFirstSnapshot;
156	ComObjPtr <Snapshot> mCurrentSnapshot;
157	};
158
159	/**
160	* Saved state data.
161	*
162	* It's actually only the state file path string, but it needs to be
163	* separate from Data, because Machine and SessionMachine instances
164	* share it, while SnapshotMachine does not.
165	*
166	* The data variable is \|mSSData\|.
167	*/
168	struct SSData
169	{
170	Bstr mStateFilePath;
171	};
172
173	/**
174	* User changeable machine data.
175	*
176	* This data is common for all machine snapshots, i.e. it is shared
177	* by all SnapshotMachine instances associated with the given machine
178	* using the util::Backupable template through the \|mUserData\| variable.
179	*
180	* SessionMachine instances can alter this data and discard changes.
181	*
182	* @note There is no need to lock anything inside init() or uninit()
183	* methods, because they are always serialized (see AutoCaller).
184	*/
185	struct UserData
186	{
187	UserData();
188	~UserData();
189
190	bool operator== (const UserData &that) const
191	{
192	return this == &that \|\|
193	(mName == that.mName &&
194	mNameSync == that.mNameSync &&
195	mDescription == that.mDescription &&
196	mOSTypeId == that.mOSTypeId &&
197	mSnapshotFolderFull == that.mSnapshotFolderFull);
198	}
199
200	Bstr mName;
201	BOOL mNameSync;
202	Bstr mDescription;
203	Bstr mOSTypeId;
204	Bstr mSnapshotFolder;
205	Bstr mSnapshotFolderFull;
206	};
207
208	/**
209	* Hardware data.
210	*
211	* This data is unique for a machine and for every machine snapshot.
212	* Stored using the util::Backupable template in the \|mHWData\| variable.
213	*
214	* SessionMachine instances can alter this data and discard changes.
215	*/
216	struct HWData
217	{
218	HWData();
219	~HWData();
220
221	bool operator== (const HWData &that) const;
222
223	ULONG mMemorySize;
224	ULONG mMemoryBalloonSize;
225	ULONG mStatisticsUpdateInterval;
226	ULONG mVRAMSize;
227	ULONG mMonitorCount;
228	TriStateBool_T mHWVirtExEnabled;
229
230	DeviceType_T mBootOrder [SchemaDefs::MaxBootPosition];
231
232	typedef std::list <ComObjPtr <SharedFolder> > SharedFolderList;
233	SharedFolderList mSharedFolders;
234	ClipboardMode_T mClipboardMode;
235	};
236
237	/**
238	* Hard disk data.
239	*
240	* The usage policy is the same as for HWData, but a separate structure
241	* is necessarym because hard disk data requires different procedures when
242	* taking or discarding snapshots, etc.
243	*
244	* The data variable is \|mHWData\|.
245	*/
246	struct HDData
247	{
248	HDData();
249	~HDData();
250
251	bool operator== (const HDData &that) const;
252
253	typedef std::list <ComObjPtr <HardDiskAttachment> > HDAttachmentList;
254	HDAttachmentList mHDAttachments;
255
256	/**
257	* Right after Machine::fixupHardDisks(true): \|true\| if hard disks
258	* were actually changed, \|false\| otherwise
259	*/
260	bool mHDAttachmentsChanged;
261	};
262
263	enum StateDependency
264	{
265	AnyStateDep = 0, MutableStateDep, MutableOrSavedStateDep
266	};
267
268	/**
269	* Helper class that safely manages the machine state dependency by
270	* calling Machine::addStateDependency() on construction and
271	* Machine::releaseStateDependency() on destruction. Intended for Machine
272	* children. The usage pattern is:
273	*
274	* @code
275	* AutoCaller autoCaller (this);
276	* CheckComRCReturnRC (autoCaller.rc());
277	*
278	* Machine::AutoStateDependency <MutableStateDep> adep (mParent);
279	* CheckComRCReturnRC (stateDep.rc());
280	* ...
281	* // code that depends on the particular machine state
282	* ...
283	* @endcode
284	*
285	* Note that it is more convenient to use the following individual
286	* shortcut classes instead of using this template directly:
287	* AutoAnyStateDependency, AutoMutableStateDependency and
288	* AutoMutableOrSavedStateDependency. The usage pattern is exactly the
289	* same as above except that there is no need to specify the template
290	* argument because it is already done by the shortcut class.
291	*
292	* @param taDepType Dependecy type to manage.
293	*/
294	template <StateDependency taDepType = AnyStateDep>
295	class AutoStateDependency
296	{
297	public:
298
299	AutoStateDependency (Machine *aThat)
300	: mThat (aThat), mRC (S_OK)
301	, mMachineState (MachineState_InvalidMachineState)
302	, mRegistered (FALSE)
303	{
304	Assert (aThat);
305	mRC = aThat->addStateDependency (taDepType, &mMachineState,
306	&mRegistered);
307	}
308	~AutoStateDependency()
309	{
310	if (SUCCEEDED (mRC))
311	mThat->releaseStateDependency();
312	}
313
314	/** Decreases the number of dependencies before the instance is
315	* destroyed. Note that will reset #rc() to E_FAIL. */
316	void release()
317	{
318	AssertReturnVoid (SUCCEEDED (mRC));
319	mThat->releaseStateDependency();
320	mRC = E_FAIL;
321	}
322
323	/** Restores the number of callers after by #release(). #rc() will be
324	* reset to the result of calling addStateDependency() and must be
325	* rechecked to ensure the operation succeeded. */
326	void add()
327	{
328	AssertReturnVoid (!SUCCEEDED (mRC));
329	mRC = mThat->addStateDependency (taDepType, &mMachineState,
330	&mRegistered);
331	}
332
333	/** Returns the result of Machine::addStateDependency(). */
334	HRESULT rc() const { return mRC; }
335
336	/** Shortcut to SUCCEEDED (rc()). */
337	bool isOk() const { return SUCCEEDED (mRC); }
338
339	/** Returns the machine state value as returned by
340	* Machine::addStateDependency(). */
341	MachineState_T machineState() const { return mMachineState; }
342
343	/** Returns the machine state value as returned by
344	* Machine::addStateDependency(). */
345	BOOL machineRegistered() const { return mRegistered; }
346
347	protected:
348
349	Machine *mThat;
350	HRESULT mRC;
351	MachineState_T mMachineState;
352	BOOL mRegistered;
353
354	private:
355
356	DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP (AutoStateDependency)
357	DECLARE_CLS_NEW_DELETE_NOOP (AutoStateDependency)
358	};
359
360	/**
361	* Shortcut to AutoStateDependency <AnyStateDep>.
362	* See AutoStateDependency to get the usage pattern.
363	*
364	* Accepts any machine state and guarantees the state won't change before
365	* this object is destroyed. If the machine state cannot be protected (as
366	* a result of the state change currently in progress), this instance's
367	* #rc() method will indicate a failure, and the caller is not allowed to
368	* rely on any particular machine state and should return the failed
369	* result code to the upper level.
370	*/
371	typedef AutoStateDependency <AnyStateDep> AutoAnyStateDependency;
372
373	/**
374	* Shortcut to AutoStateDependency <MutableStateDep>.
375	* See AutoStateDependency to get the usage pattern.
376	*
377	* Succeeds only if the machine state is in one of the mutable states, and
378	* guarantees the given mutable state won't change before this object is
379	* destroyed. If the machine is not mutable, this instance's #rc() method
380	* will indicate a failure, and the caller is not allowed to rely on any
381	* particular machine state and should return the failed result code to
382	* the upper level.
383	*
384	* Intended to be used within all setter methods of IMachine
385	* children objects (DVDDrive, NetworkAdapter, AudioAdapter, etc.) to
386	* provide data protection and consistency.
387	*/
388	typedef AutoStateDependency <MutableStateDep> AutoMutableStateDependency;
389
390	/**
391	* Shortcut to AutoStateDependency <MutableOrSavedStateDep>.
392	* See AutoStateDependency to get the usage pattern.
393	*
394	* Succeeds only if the machine state is in one of the mutable states, or
395	* if the machine is in the Saved state, and guarantees the given mutable
396	* state won't change before this object is destroyed. If the machine is
397	* not mutable, this instance's #rc() method will indicate a failure, and
398	* the caller is not allowed to rely on any particular machine state and
399	* should return the failed result code to the upper level.
400	*
401	* Intended to be used within setter methods of IMachine
402	* children objects that may also operate on Saved machines.
403	*/
404	typedef AutoStateDependency <MutableOrSavedStateDep> AutoMutableOrSavedStateDependency;
405
406
407	VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (Machine)
408
409	DECLARE_NOT_AGGREGATABLE(Machine)
410
411	DECLARE_PROTECT_FINAL_CONSTRUCT()
412
413	BEGIN_COM_MAP(Machine)
414	COM_INTERFACE_ENTRY(ISupportErrorInfo)
415	COM_INTERFACE_ENTRY(IMachine)
416	END_COM_MAP()
417
418	NS_DECL_ISUPPORTS
419
420	DECLARE_EMPTY_CTOR_DTOR (Machine)
421
422	HRESULT FinalConstruct();
423	void FinalRelease();
424
425	enum InitMode { Init_New, Init_Existing, Init_Registered };
426
427	// public initializer/uninitializer for internal purposes only
428	HRESULT init (VirtualBox *aParent, const BSTR aConfigFile,
429	InitMode aMode, const BSTR aName = NULL,
430	BOOL aNameSync = TRUE, const Guid *aId = NULL);
431	void uninit();
432
433	// IMachine properties
434	STDMETHOD(COMGETTER(Parent))(IVirtualBox **aParent);
435	STDMETHOD(COMGETTER(Accessible)) (BOOL *aAccessible);
436	STDMETHOD(COMGETTER(AccessError)) (IVirtualBoxErrorInfo **aAccessError);
437	STDMETHOD(COMGETTER(Name))(BSTR *aName);
438	STDMETHOD(COMSETTER(Name))(INPTR BSTR aName);
439	STDMETHOD(COMGETTER(Description))(BSTR *aDescription);
440	STDMETHOD(COMSETTER(Description))(INPTR BSTR aDescription);
441	STDMETHOD(COMGETTER(Id))(GUIDPARAMOUT aId);
442	STDMETHOD(COMGETTER(OSTypeId)) (BSTR *aOSTypeId);
443	STDMETHOD(COMSETTER(OSTypeId)) (INPTR BSTR aOSTypeId);
444	STDMETHOD(COMGETTER(MemorySize))(ULONG *memorySize);
445	STDMETHOD(COMSETTER(MemorySize))(ULONG memorySize);
446	STDMETHOD(COMGETTER(MemoryBalloonSize))(ULONG *memoryBalloonSize);
447	STDMETHOD(COMSETTER(MemoryBalloonSize))(ULONG memoryBalloonSize);
448	STDMETHOD(COMGETTER(StatisticsUpdateInterval))(ULONG *statisticsUpdateInterval);
449	STDMETHOD(COMSETTER(StatisticsUpdateInterval))(ULONG statisticsUpdateInterval);
450	STDMETHOD(COMGETTER(VRAMSize))(ULONG *memorySize);
451	STDMETHOD(COMSETTER(VRAMSize))(ULONG memorySize);
452	STDMETHOD(COMGETTER(MonitorCount))(ULONG *monitorCount);
453	STDMETHOD(COMSETTER(MonitorCount))(ULONG monitorCount);
454	STDMETHOD(COMGETTER(BIOSSettings))(IBIOSSettings **biosSettings);
455	STDMETHOD(COMGETTER(HWVirtExEnabled))(TriStateBool_T *enabled);
456	STDMETHOD(COMSETTER(HWVirtExEnabled))(TriStateBool_T enabled);
457	STDMETHOD(COMGETTER(SnapshotFolder))(BSTR *aSavedStateFolder);
458	STDMETHOD(COMSETTER(SnapshotFolder))(INPTR BSTR aSavedStateFolder);
459	STDMETHOD(COMGETTER(HardDiskAttachments))(IHardDiskAttachmentCollection **attachments);
460	STDMETHOD(COMGETTER(VRDPServer))(IVRDPServer **vrdpServer);
461	STDMETHOD(COMGETTER(DVDDrive))(IDVDDrive **dvdDrive);
462	STDMETHOD(COMGETTER(FloppyDrive))(IFloppyDrive **floppyDrive);
463	STDMETHOD(COMGETTER(AudioAdapter))(IAudioAdapter **audioAdapter);
464	STDMETHOD(COMGETTER(USBController))(IUSBController * *a_ppUSBController);
465	STDMETHOD(COMGETTER(SettingsFilePath))(BSTR *filePath);
466	STDMETHOD(COMGETTER(SettingsModified))(BOOL *modified);
467	STDMETHOD(COMGETTER(SessionState))(SessionState_T *aSessionState);
468	STDMETHOD(COMGETTER(SessionType))(BSTR *aSessionType);
469	STDMETHOD(COMGETTER(SessionPid))(ULONG *aSessionPid);
470	STDMETHOD(COMGETTER(State))(MachineState_T *machineState);
471	STDMETHOD(COMGETTER(LastStateChange))(LONG64 *aLastStateChange);
472	STDMETHOD(COMGETTER(StateFilePath)) (BSTR *aStateFilePath);
473	STDMETHOD(COMGETTER(LogFolder)) (BSTR *aLogFolder);
474	STDMETHOD(COMGETTER(CurrentSnapshot)) (ISnapshot **aCurrentSnapshot);
475	STDMETHOD(COMGETTER(SnapshotCount)) (ULONG *aSnapshotCount);
476	STDMETHOD(COMGETTER(CurrentStateModified))(BOOL *aCurrentStateModified);
477	STDMETHOD(COMGETTER(SharedFolders)) (ISharedFolderCollection **aSharedFolders);
478	STDMETHOD(COMGETTER(ClipboardMode)) (ClipboardMode_T *aClipboardMode);
479	STDMETHOD(COMSETTER(ClipboardMode)) (ClipboardMode_T aClipboardMode);
480
481	// IMachine methods
482	STDMETHOD(SetBootOrder)(ULONG aPosition, DeviceType_T aDevice);
483	STDMETHOD(GetBootOrder)(ULONG aPosition, DeviceType_T *aDevice);
484	STDMETHOD(AttachHardDisk)(INPTR GUIDPARAM aId, DiskControllerType_T aCtl, LONG aDev);
485	STDMETHOD(GetHardDisk)(DiskControllerType_T aCtl, LONG aDev, IHardDisk **aHardDisk);
486	STDMETHOD(DetachHardDisk) (DiskControllerType_T aCtl, LONG aDev);
487	STDMETHOD(GetSerialPort) (ULONG slot, ISerialPort **port);
488	STDMETHOD(GetParallelPort) (ULONG slot, IParallelPort **port);
489	STDMETHOD(GetNetworkAdapter) (ULONG slot, INetworkAdapter **adapter);
490	STDMETHOD(GetNextExtraDataKey)(INPTR BSTR aKey, BSTR aNextKey, BSTR aNextValue);
491	STDMETHOD(GetExtraData)(INPTR BSTR aKey, BSTR *aValue);
492	STDMETHOD(SetExtraData)(INPTR BSTR aKey, INPTR BSTR aValue);
493	STDMETHOD(SaveSettings)();
494	STDMETHOD(DiscardSettings)();
495	STDMETHOD(DeleteSettings)();
496	STDMETHOD(GetSnapshot) (INPTR GUIDPARAM aId, ISnapshot **aSnapshot);
497	STDMETHOD(FindSnapshot) (INPTR BSTR aName, ISnapshot **aSnapshot);
498	STDMETHOD(SetCurrentSnapshot) (INPTR GUIDPARAM aId);
499	STDMETHOD(CreateSharedFolder) (INPTR BSTR aName, INPTR BSTR aHostPath);
500	STDMETHOD(RemoveSharedFolder) (INPTR BSTR aName);
501	STDMETHOD(CanShowConsoleWindow) (BOOL *aCanShow);
502	STDMETHOD(ShowConsoleWindow) (ULONG64 *aWinId);
503
504	// public methods only for internal purposes
505
506	/// @todo (dmik) add lock and make non-inlined after revising classes
507	// that use it. Note: they should enter Machine lock to keep the returned
508	// information valid!
509	bool isRegistered() { return !!mData->mRegistered; }
510
511	ComObjPtr <SessionMachine> sessionMachine();
512
513	/**
514	* Returns the VirtualBox object this machine belongs to.
515	*
516	* @note This method doesn't check this object's readiness as it is
517	* intended to be used only by Machine children where it is guaranteed
518	* that this object still exists in memory.
519	*/
520	const ComObjPtr <VirtualBox, ComWeakRef> &virtualBox() const { return mParent; }
521
522	/**
523	* Returns this machine's name.
524	*
525	* @note This method doesn't check this object's readiness as it is
526	* intended to be used only after adding a caller to this object (that
527	* guarantees that the object is ready or at least limited).
528	*/
529	const Guid &uuid() const { return mData->mUuid; }
530
531	/**
532	* Returns this machine's full settings file path.
533	*
534	* @note This method doesn't lock this object or check its readiness as
535	* it is intended to be used only after adding a caller to this object
536	* (that guarantees that the object is ready) and locking it for reading.
537	*/
538	const Bstr &settingsFileFull() const { return mData->mConfigFileFull; }
539
540	/**
541	* Returns this machine's name.
542	*
543	* @note This method doesn't lock this object or check its readiness as
544	* it is intended to be used only after adding a caller to this object
545	* (that guarantees that the object is ready) and locking it for reading.
546	*/
547	const Bstr &name() const { return mUserData->mName; }
548
549	// callback handlers
550	virtual HRESULT onDVDDriveChange() { return S_OK; }
551	virtual HRESULT onFloppyDriveChange() { return S_OK; }
552	virtual HRESULT onNetworkAdapterChange(INetworkAdapter *networkAdapter) { return S_OK; }
553	virtual HRESULT onSerialPortChange(ISerialPort *serialPort) { return S_OK; }
554	virtual HRESULT onParallelPortChange(IParallelPort *ParallelPort) { return S_OK; }
555	virtual HRESULT onVRDPServerChange() { return S_OK; }
556	virtual HRESULT onUSBControllerChange() { return S_OK; }
557	virtual HRESULT onSharedFolderChange() { return S_OK; }
558
559	HRESULT saveRegistryEntry (CFGNODE aEntryNode);
560
561	int calculateFullPath (const char *aPath, Utf8Str &aResult);
562	void calculateRelativePath (const char *aPath, Utf8Str &aResult);
563
564	void getLogFolder (Utf8Str &aLogFolder);
565
566	bool isDVDImageUsed (const Guid &aId, ResourceUsage_T aUsage);
567	bool isFloppyImageUsed (const Guid &aId, ResourceUsage_T aUsage);
568
569	HRESULT openSession (IInternalSessionControl *aControl);
570	HRESULT openRemoteSession (IInternalSessionControl *aControl,
571	INPTR BSTR aType, INPTR BSTR aEnvironment,
572	Progress *aProgress);
573	HRESULT openExistingSession (IInternalSessionControl *aControl);
574
575	HRESULT trySetRegistered (BOOL aRegistered);
576
577	HRESULT getSharedFolder (const BSTR aName,
578	ComObjPtr <SharedFolder> &aSharedFolder,
579	bool aSetError = false)
580	{
581	AutoLock alock (this);
582	return findSharedFolder (aName, aSharedFolder, aSetError);
583	}
584
585	HRESULT addStateDependency (StateDependency aDepType = AnyStateDep,
586	MachineState_T *aState = NULL,
587	BOOL *aRegistered = NULL);
588	void releaseStateDependency();
589
590	// for VirtualBoxSupportErrorInfoImpl
591	static const wchar_t *getComponentName() { return L"Machine"; }
592
593	protected:
594
595	enum InstanceType { IsMachine, IsSessionMachine, IsSnapshotMachine };
596
597	HRESULT registeredInit();
598
599	HRESULT checkStateDependency (StateDependency aDepType);
600
601	inline Machine *machine();
602
603	HRESULT initDataAndChildObjects();
604	void uninitDataAndChildObjects();
605
606	void checkStateDependencies (AutoLock &aLock);
607
608	virtual HRESULT setMachineState (MachineState_T aMachineState);
609
610	HRESULT findSharedFolder (const BSTR aName,
611	ComObjPtr <SharedFolder> &aSharedFolder,
612	bool aSetError = false);
613
614	HRESULT loadSettings (bool aRegistered);
615	HRESULT loadSnapshot (CFGNODE aNode, const Guid &aCurSnapshotId,
616	Snapshot *aParentSnapshot);
617	HRESULT loadHardware (CFGNODE aNode);
618	HRESULT loadHardDisks (CFGNODE aNode, bool aRegistered,
619	const Guid *aSnapshotId = NULL);
620
621	HRESULT openConfigLoader (CFGHANDLE *aLoader, bool aIsNew = false);
622	HRESULT closeConfigLoader (CFGHANDLE aLoader, bool aSaveBeforeClose);
623
624	HRESULT findSnapshotNode (Snapshot *aSnapshot, CFGNODE aMachineNode,
625	CFGNODE aSnapshotsNode, CFGNODE aSnapshotNode);
626
627	HRESULT findSnapshot (const Guid &aId, ComObjPtr <Snapshot> &aSnapshot,
628	bool aSetError = false);
629	HRESULT findSnapshot (const BSTR aName, ComObjPtr <Snapshot> &aSnapshot,
630	bool aSetError = false);
631
632	HRESULT findHardDiskAttachment (const ComObjPtr <HardDisk> &aHd,
633	ComObjPtr <Machine> *aMachine,
634	ComObjPtr <Snapshot> *aSnapshot,
635	ComObjPtr <HardDiskAttachment> *aHda);
636
637	HRESULT prepareSaveSettings (bool &aRenamed, bool &aNew);
638	HRESULT saveSettings (bool aMarkCurStateAsModified = true,
639	bool aInformCallbacksAnyway = false);
640
641	enum
642	{
643	// ops for #saveSnapshotSettings()
644	SaveSS_NoOp = 0x00, SaveSS_AddOp = 0x01,
645	SaveSS_UpdateAttrsOp = 0x02, SaveSS_UpdateAllOp = 0x03,
646	SaveSS_OpMask = 0xF,
647	// flags for #saveSnapshotSettings()
648	SaveSS_UpdateCurStateModified = 0x40,
649	SaveSS_UpdateCurrentId = 0x80,
650	// flags for #saveStateSettings()
651	SaveSTS_CurStateModified = 0x20,
652	SaveSTS_StateFilePath = 0x40,
653	SaveSTS_StateTimeStamp = 0x80,
654	};
655
656	HRESULT saveSnapshotSettings (Snapshot *aSnapshot, int aOpFlags);
657	HRESULT saveSnapshotSettingsWorker (CFGNODE aMachineNode,
658	Snapshot *aSnapshot, int aOpFlags);
659
660	HRESULT saveSnapshot (CFGNODE aNode, Snapshot *aSnapshot, bool aAttrsOnly);
661	HRESULT saveHardware (CFGNODE aNode);
662	HRESULT saveHardDisks (CFGNODE aNode);
663
664	HRESULT saveStateSettings (int aFlags);
665
666	HRESULT wipeOutImmutableDiffs();
667
668	HRESULT fixupHardDisks (bool aCommit);
669
670	HRESULT createSnapshotDiffs (const Guid *aSnapshotId,
671	const Bstr &aFolder,
672	const ComObjPtr <Progress> &aProgress,
673	bool aOnline);
674	HRESULT deleteSnapshotDiffs (const ComObjPtr <Snapshot> &aSnapshot);
675
676	HRESULT lockConfig();
677	HRESULT unlockConfig();
678
679	/** @note This method is not thread safe */
680	BOOL isConfigLocked()
681	{
682	return !!mData && mData->mHandleCfgFile != NIL_RTFILE;
683	}
684
685	bool isInOwnDir (Utf8Str *aSettingsDir = NULL);
686
687	bool isModified();
688	bool isReallyModified (bool aIgnoreUserData = false);
689	void rollback (bool aNotify);
690	HRESULT commit();
691	void copyFrom (Machine *aThat);
692
693	const InstanceType mType;
694
695	const ComObjPtr <Machine, ComWeakRef> mPeer;
696
697	const ComObjPtr <VirtualBox, ComWeakRef> mParent;
698
699	Shareable <Data> mData;
700	Shareable <SSData> mSSData;
701
702	Backupable <UserData> mUserData;
703	Backupable <HWData> mHWData;
704	Backupable <HDData> mHDData;
705
706	// the following fields need special backup/rollback/commit handling,
707	// so they cannot be a part of HWData
708
709	const ComObjPtr <VRDPServer> mVRDPServer;
710	const ComObjPtr <DVDDrive> mDVDDrive;
711	const ComObjPtr <FloppyDrive> mFloppyDrive;
712	const ComObjPtr <SerialPort>
713	mSerialPorts [SchemaDefs::SerialPortCount];
714	const ComObjPtr <ParallelPort>
715	mParallelPorts [SchemaDefs::ParallelPortCount];
716	const ComObjPtr <AudioAdapter> mAudioAdapter;
717	const ComObjPtr <USBController> mUSBController;
718	const ComObjPtr <BIOSSettings> mBIOSSettings;
719	const ComObjPtr <NetworkAdapter>
720	mNetworkAdapters [SchemaDefs::NetworkAdapterCount];
721
722	friend class SessionMachine;
723	friend class SnapshotMachine;
724	};
725
726	// SessionMachine class
727	////////////////////////////////////////////////////////////////////////////////
728
729	/**
730	* @note Notes on locking objects of this class:
731	* SessionMachine shares some data with the primary Machine instance (pointed
732	* to by the \|mPeer\| member). In order to provide data consistency it also
733	* shares its lock handle. This means that whenever you lock a SessionMachine
734	* instance using Auto[Reader]Lock or AutoMultiLock, the corresponding Machine
735	* instance is also locked in the same lock mode. Keep it in mind.
736	*/
737	class ATL_NO_VTABLE SessionMachine :
738	public VirtualBoxSupportTranslation <SessionMachine>,
739	public Machine,
740	public IInternalMachineControl
741	{
742	public:
743
744	VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE(SessionMachine)
745
746	DECLARE_NOT_AGGREGATABLE(SessionMachine)
747
748	DECLARE_PROTECT_FINAL_CONSTRUCT()
749
750	BEGIN_COM_MAP(SessionMachine)
751	COM_INTERFACE_ENTRY(ISupportErrorInfo)
752	COM_INTERFACE_ENTRY(IMachine)
753	COM_INTERFACE_ENTRY(IInternalMachineControl)
754	END_COM_MAP()
755
756	NS_DECL_ISUPPORTS
757
758	DECLARE_EMPTY_CTOR_DTOR (SessionMachine)
759
760	HRESULT FinalConstruct();
761	void FinalRelease();
762
763	// public initializer/uninitializer for internal purposes only
764	HRESULT init (Machine *aMachine);
765	void uninit() { uninit (Uninit::Unexpected); }
766
767	// AutoLock::Lockable interface
768	AutoLock::Handle *lockHandle() const;
769
770	// IInternalMachineControl methods
771	STDMETHOD(UpdateState)(MachineState_T machineState);
772	STDMETHOD(GetIPCId)(BSTR *id);
773	STDMETHOD(RunUSBDeviceFilters) (IUSBDevice aUSBDevice, BOOL aMatched, ULONG *aMaskedIfs);
774	STDMETHOD(CaptureUSBDevice) (INPTR GUIDPARAM aId);
775	STDMETHOD(DetachUSBDevice) (INPTR GUIDPARAM aId, BOOL aDone);
776	STDMETHOD(AutoCaptureUSBDevices)();
777	STDMETHOD(DetachAllUSBDevices)(BOOL aDone);
778	STDMETHOD(OnSessionEnd)(ISession aSession, IProgress *aProgress);
779	STDMETHOD(BeginSavingState) (IProgress aProgress, BSTR aStateFilePath);
780	STDMETHOD(EndSavingState) (BOOL aSuccess);
781	STDMETHOD(AdoptSavedState) (INPTR BSTR aSavedStateFile);
782	STDMETHOD(BeginTakingSnapshot) (IConsole *aInitiator,
783	INPTR BSTR aName, INPTR BSTR aDescription,
784	IProgress aProgress, BSTR aStateFilePath,
785	IProgress **aServerProgress);
786	STDMETHOD(EndTakingSnapshot) (BOOL aSuccess);
787	STDMETHOD(DiscardSnapshot) (IConsole *aInitiator, INPTR GUIDPARAM aId,
788	MachineState_T aMachineState, IProgress *aProgress);
789	STDMETHOD(DiscardCurrentState) (
790	IConsole aInitiator, MachineState_T aMachineState, IProgress **aProgress);
791	STDMETHOD(DiscardCurrentSnapshotAndState) (
792	IConsole aInitiator, MachineState_T aMachineState, IProgress **aProgress);
793
794	// public methods only for internal purposes
795
796	bool checkForDeath();
797
798	#if defined (RT_OS_WINDOWS)
799	HANDLE ipcSem() { return mIPCSem; }
800	#elif defined (RT_OS_OS2)
801	HMTX ipcSem() { return mIPCSem; }
802	#endif
803
804	HRESULT onDVDDriveChange();
805	HRESULT onFloppyDriveChange();
806	HRESULT onNetworkAdapterChange(INetworkAdapter *networkAdapter);
807	HRESULT onSerialPortChange(ISerialPort *serialPort);
808	HRESULT onParallelPortChange(IParallelPort *parallelPort);
809	HRESULT onVRDPServerChange();
810	HRESULT onUSBControllerChange();
811	HRESULT onUSBDeviceAttach (IUSBDevice *aDevice,
812	IVirtualBoxErrorInfo *aError,
813	ULONG aMaskedIfs);
814	HRESULT onUSBDeviceDetach (INPTR GUIDPARAM aId,
815	IVirtualBoxErrorInfo *aError);
816	HRESULT onSharedFolderChange();
817
818	bool hasMatchingUSBFilter (const ComObjPtr <HostUSBDevice> &aDevice, ULONG *aMaskedIfs);
819
820	private:
821
822	struct SnapshotData
823	{
824	SnapshotData() : mLastState (MachineState_InvalidMachineState) {}
825
826	MachineState_T mLastState;
827
828	// used when taking snapshot
829	ComObjPtr <Snapshot> mSnapshot;
830	ComObjPtr <Progress> mServerProgress;
831	ComObjPtr <CombinedProgress> mCombinedProgress;
832
833	// used when saving state
834	Guid mProgressId;
835	Bstr mStateFilePath;
836	};
837
838	struct Uninit {
839	enum Reason { Unexpected, Abnormal, Normal };
840	};
841
842	struct Task;
843	struct TakeSnapshotTask;
844	struct DiscardSnapshotTask;
845	struct DiscardCurrentStateTask;
846
847	friend struct TakeSnapshotTask;
848	friend struct DiscardSnapshotTask;
849	friend struct DiscardCurrentStateTask;
850
851	void uninit (Uninit::Reason aReason);
852
853	HRESULT endSavingState (BOOL aSuccess);
854	HRESULT endTakingSnapshot (BOOL aSuccess);
855
856	typedef std::map <ComObjPtr <Machine>, MachineState_T> AffectedMachines;
857
858	void takeSnapshotHandler (TakeSnapshotTask &aTask);
859	void discardSnapshotHandler (DiscardSnapshotTask &aTask);
860	void discardCurrentStateHandler (DiscardCurrentStateTask &aTask);
861
862	HRESULT setMachineState (MachineState_T aMachineState);
863	HRESULT updateMachineStateOnClient();
864
865	SnapshotData mSnapshotData;
866
867	/** interprocess semaphore handle (id) for this machine */
868	#if defined(RT_OS_WINDOWS)
869	HANDLE mIPCSem;
870	Bstr mIPCSemName;
871	#elif defined(RT_OS_OS2)
872	HMTX mIPCSem;
873	Bstr mIPCSemName;
874	#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
875	int mIPCSem;
876	#else
877	# error "Port me!"
878	#endif
879
880	static DECLCALLBACK(int) taskHandler (RTTHREAD thread, void *pvUser);
881	};
882
883	// SnapshotMachine class
884	////////////////////////////////////////////////////////////////////////////////
885
886	/**
887	* @note Notes on locking objects of this class:
888	* SnapshotMachine shares some data with the primary Machine instance (pointed
889	* to by the \|mPeer\| member). In order to provide data consistency it also
890	* shares its lock handle. This means that whenever you lock a SessionMachine
891	* instance using Auto[Reader]Lock or AutoMultiLock, the corresponding Machine
892	* instance is also locked in the same lock mode. Keep it in mind.
893	*/
894	class ATL_NO_VTABLE SnapshotMachine :
895	public VirtualBoxSupportTranslation <SnapshotMachine>,
896	public Machine
897	{
898	public:
899
900	VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE(SnapshotMachine)
901
902	DECLARE_NOT_AGGREGATABLE(SnapshotMachine)
903
904	DECLARE_PROTECT_FINAL_CONSTRUCT()
905
906	BEGIN_COM_MAP(SnapshotMachine)
907	COM_INTERFACE_ENTRY(ISupportErrorInfo)
908	COM_INTERFACE_ENTRY(IMachine)
909	END_COM_MAP()
910
911	NS_DECL_ISUPPORTS
912
913	DECLARE_EMPTY_CTOR_DTOR (SnapshotMachine)
914
915	HRESULT FinalConstruct();
916	void FinalRelease();
917
918	// public initializer/uninitializer for internal purposes only
919	HRESULT init (SessionMachine *aSessionMachine,
920	INPTR GUIDPARAM aSnapshotId, INPTR BSTR aStateFilePath);
921	HRESULT init (Machine *aMachine, CFGNODE aHWNode, CFGNODE aHDAsNode,
922	INPTR GUIDPARAM aSnapshotId, INPTR BSTR aStateFilePath);
923	void uninit();
924
925	// AutoLock::Lockable interface
926	AutoLock::Handle *lockHandle() const;
927
928	// public methods only for internal purposes
929
930	HRESULT onSnapshotChange (Snapshot *aSnapshot);
931
932	private:
933
934	Guid mSnapshotId;
935
936	friend class Snapshot;
937	};
938
939	////////////////////////////////////////////////////////////////////////////////
940
941	/**
942	* Returns a pointer to the Machine object for this machine that acts like a
943	* parent for complex machine data objects such as shared folders, etc.
944	*
945	* For primary Machine objects and for SnapshotMachine objects, returns this
946	* object's pointer itself. For SessoinMachine objects, returns the peer
947	* (primary) machine pointer.
948	*/
949	inline Machine *Machine::machine()
950	{
951	if (mType == IsSessionMachine)
952	return mPeer;
953	return this;
954	}
955
956	COM_DECL_READONLY_ENUM_AND_COLLECTION (Machine)
957
958	#endif // ____H_MACHINEIMPL

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Main/include/MachineImpl.h@ 5713

Download in other formats: