MachineImpl.h@ 13221

Last change on this file since 13221 was 13221, checked in by vboxsync, 16 years ago

Enabled VPID (VT-x tagged TLB); default off

Added machine & machine debugger property
Added -vtxvpid option to VBoxManage

Property svn:eol-style set to native
Property svn:keywords set to Author Date Id Revision

File size: 36.8 KB

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

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

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

Download in other formats: