ConsoleImpl.h@ 48819

最後變更在這個檔案從48819是 48528,由 vboxsync 提交於 12 年前
Change implementation for turning a reset into a power off to prevent the VM from executing while the power down thread is not running
屬性 svn:eol-style 設為 `native` 屬性 svn:keywords 設為 `Author Date Id Revision`
檔案大小: 38.3 KB

行
1	/* $Id: ConsoleImpl.h 48528 2013-09-18 20:39:01Z vboxsync $ */
2	/** @file
3	* VBox Console COM Class definition
4	*/
5
6	/*
7	* Copyright (C) 2005-2013 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.alldomusa.eu.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 ____H_CONSOLEIMPL
19	#define ____H_CONSOLEIMPL
20
21	#include "VirtualBoxBase.h"
22	#include "VBox/com/array.h"
23	#include "EventImpl.h"
24
25	class Guest;
26	class Keyboard;
27	class Mouse;
28	class Display;
29	class MachineDebugger;
30	class TeleporterStateSrc;
31	class OUSBDevice;
32	class RemoteUSBDevice;
33	class SharedFolder;
34	class VRDEServerInfo;
35	class EmulatedUSB;
36	class AudioSniffer;
37	class Nvram;
38	class EmWebcam;
39	#ifdef VBOX_WITH_USB_CARDREADER
40	class UsbCardReader;
41	#endif
42	class ConsoleVRDPServer;
43	class VMMDev;
44	class Progress;
45	class BusAssignmentManager;
46	COM_STRUCT_OR_CLASS(IEventListener);
47	#ifdef VBOX_WITH_EXTPACK
48	class ExtPackManager;
49	#endif
50	class VMMDevMouseInterface;
51	class DisplayMouseInterface;
52
53	#include <VBox/RemoteDesktop/VRDE.h>
54	#include <VBox/vmm/pdmdrv.h>
55	#ifdef VBOX_WITH_GUEST_PROPS
56	# include <VBox/HostServices/GuestPropertySvc.h> /* For the property notification callback */
57	#endif
58
59	#ifdef RT_OS_WINDOWS
60	# include "../src-server/win/VBoxComEvents.h"
61	#endif
62
63	struct VUSBIRHCONFIG;
64	typedef struct VUSBIRHCONFIG *PVUSBIRHCONFIG;
65
66	#include <list>
67	#include <vector>
68
69	// defines
70	///////////////////////////////////////////////////////////////////////////////
71
72	/**
73	* Checks the availability of the underlying VM device driver corresponding
74	* to the COM interface (IKeyboard, IMouse, IDisplay, etc.). When the driver is
75	* not available (NULL), sets error info and returns returns E_ACCESSDENIED.
76	* The translatable error message is defined in null context.
77	*
78	* Intended to used only within Console children (i.e. Keyboard, Mouse,
79	* Display, etc.).
80	*
81	* @param drv driver pointer to check (compare it with NULL)
82	*/
83	#define CHECK_CONSOLE_DRV(drv) \
84	do { \
85	if (!(drv)) \
86	return setError(E_ACCESSDENIED, tr("The console is not powered up")); \
87	} while (0)
88
89	// Console
90	///////////////////////////////////////////////////////////////////////////////
91
92	class ConsoleMouseInterface
93	{
94	public:
95	virtual VMMDevMouseInterface *getVMMDevMouseInterface() = 0;
96	virtual DisplayMouseInterface *getDisplayMouseInterface() = 0;
97	virtual void onMouseCapabilityChange(BOOL supportsAbsolute,
98	BOOL supportsRelative,
99	BOOL supportsMT,
100	BOOL needsHostCursor) = 0;
101	};
102
103	/** IConsole implementation class */
104	class ATL_NO_VTABLE Console :
105	public VirtualBoxBase,
106	VBOX_SCRIPTABLE_IMPL(IConsole), public ConsoleMouseInterface
107	{
108	Q_OBJECT
109
110	public:
111
112	VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(Console, IConsole)
113
114	DECLARE_NOT_AGGREGATABLE(Console)
115
116	DECLARE_PROTECT_FINAL_CONSTRUCT()
117
118	BEGIN_COM_MAP(Console)
119	VBOX_DEFAULT_INTERFACE_ENTRIES(IConsole)
120	END_COM_MAP()
121
122	Console();
123	~Console();
124
125	HRESULT FinalConstruct();
126	void FinalRelease();
127
128	// public initializers/uninitializers for internal purposes only
129	HRESULT init(IMachine aMachine, IInternalMachineControl aControl, LockType_T aLockType);
130	void uninit();
131
132	// IConsole properties
133	STDMETHOD(COMGETTER(Machine))(IMachine **aMachine);
134	STDMETHOD(COMGETTER(State))(MachineState_T *aMachineState);
135	STDMETHOD(COMGETTER(Guest))(IGuest **aGuest);
136	STDMETHOD(COMGETTER(Keyboard))(IKeyboard **aKeyboard);
137	STDMETHOD(COMGETTER(Mouse))(IMouse **aMouse);
138	STDMETHOD(COMGETTER(Display))(IDisplay **aDisplay);
139	STDMETHOD(COMGETTER(Debugger))(IMachineDebugger **aDebugger);
140	STDMETHOD(COMGETTER(USBDevices))(ComSafeArrayOut(IUSBDevice *, aUSBDevices));
141	STDMETHOD(COMGETTER(RemoteUSBDevices))(ComSafeArrayOut(IHostUSBDevice *, aRemoteUSBDevices));
142	STDMETHOD(COMGETTER(VRDEServerInfo))(IVRDEServerInfo **aVRDEServerInfo);
143	STDMETHOD(COMGETTER(SharedFolders))(ComSafeArrayOut(ISharedFolder *, aSharedFolders));
144	STDMETHOD(COMGETTER(EventSource)) (IEventSource ** aEventSource);
145	STDMETHOD(COMGETTER(AttachedPCIDevices))(ComSafeArrayOut(IPCIDeviceAttachment *, aAttachments));
146	STDMETHOD(COMGETTER(UseHostClipboard))(BOOL *aUseHostClipboard);
147	STDMETHOD(COMSETTER(UseHostClipboard))(BOOL aUseHostClipboard);
148	STDMETHOD(COMGETTER(EmulatedUSB))(IEmulatedUSB **aEmulatedUSB);
149
150	// IConsole methods
151	STDMETHOD(PowerUp)(IProgress **aProgress);
152	STDMETHOD(PowerUpPaused)(IProgress **aProgress);
153	STDMETHOD(PowerDown)(IProgress **aProgress);
154	STDMETHOD(Reset)();
155	STDMETHOD(Pause)();
156	STDMETHOD(Resume)();
157	STDMETHOD(PowerButton)();
158	STDMETHOD(SleepButton)();
159	STDMETHOD(GetPowerButtonHandled)(BOOL *aHandled);
160	STDMETHOD(GetGuestEnteredACPIMode)(BOOL *aEntered);
161	STDMETHOD(SaveState)(IProgress **aProgress);
162	STDMETHOD(AdoptSavedState)(IN_BSTR aSavedStateFile);
163	STDMETHOD(DiscardSavedState)(BOOL aRemoveFile);
164	STDMETHOD(GetDeviceActivity)(DeviceType_T aDeviceType,
165	DeviceActivity_T *aDeviceActivity);
166	STDMETHOD(AttachUSBDevice)(IN_BSTR aId);
167	STDMETHOD(DetachUSBDevice)(IN_BSTR aId, IUSBDevice **aDevice);
168	STDMETHOD(FindUSBDeviceByAddress)(IN_BSTR aAddress, IUSBDevice **aDevice);
169	STDMETHOD(FindUSBDeviceById)(IN_BSTR aId, IUSBDevice **aDevice);
170	STDMETHOD(CreateSharedFolder)(IN_BSTR aName, IN_BSTR aHostPath, BOOL aWritable, BOOL aAutoMount);
171	STDMETHOD(RemoveSharedFolder)(IN_BSTR aName);
172	STDMETHOD(TakeSnapshot)(IN_BSTR aName, IN_BSTR aDescription,
173	IProgress **aProgress);
174	STDMETHOD(DeleteSnapshot)(IN_BSTR aId, IProgress **aProgress);
175	STDMETHOD(DeleteSnapshotAndAllChildren)(IN_BSTR aId, IProgress **aProgress);
176	STDMETHOD(DeleteSnapshotRange)(IN_BSTR aStartId, IN_BSTR aEndId, IProgress **aProgress);
177	STDMETHOD(RestoreSnapshot)(ISnapshot aSnapshot, IProgress *aProgress);
178	STDMETHOD(Teleport)(IN_BSTR aHostname, ULONG aPort, IN_BSTR aPassword, ULONG aMaxDowntime, IProgress **aProgress);
179
180	// public methods for internal purposes only
181
182	/*
183	* Note: the following methods do not increase refcount. intended to be
184	* called only by the VM execution thread.
185	*/
186
187	Guest *getGuest() const { return mGuest; }
188	Keyboard *getKeyboard() const { return mKeyboard; }
189	Mouse *getMouse() const { return mMouse; }
190	Display *getDisplay() const { return mDisplay; }
191	MachineDebugger *getMachineDebugger() const { return mDebugger; }
192	AudioSniffer *getAudioSniffer() const { return mAudioSniffer; }
193
194	const ComPtr<IMachine> &machine() const { return mMachine; }
195
196	bool useHostClipboard() { return mfUseHostClipboard; }
197
198	/** Method is called only from ConsoleVRDPServer */
199	IVRDEServer *getVRDEServer() const { return mVRDEServer; }
200
201	ConsoleVRDPServer *consoleVRDPServer() const { return mConsoleVRDPServer; }
202
203	HRESULT updateMachineState(MachineState_T aMachineState);
204
205	// events from IInternalSessionControl
206	HRESULT onNetworkAdapterChange(INetworkAdapter *aNetworkAdapter, BOOL changeAdapter);
207	HRESULT onSerialPortChange(ISerialPort *aSerialPort);
208	HRESULT onParallelPortChange(IParallelPort *aParallelPort);
209	HRESULT onStorageControllerChange();
210	HRESULT onMediumChange(IMediumAttachment *aMediumAttachment, BOOL aForce);
211	HRESULT onCPUChange(ULONG aCPU, BOOL aRemove);
212	HRESULT onCPUExecutionCapChange(ULONG aExecutionCap);
213	HRESULT onClipboardModeChange(ClipboardMode_T aClipboardMode);
214	HRESULT onDragAndDropModeChange(DragAndDropMode_T aDragAndDropMode);
215	HRESULT onVRDEServerChange(BOOL aRestart);
216	HRESULT onVideoCaptureChange();
217	HRESULT onUSBControllerChange();
218	HRESULT onSharedFolderChange(BOOL aGlobal);
219	HRESULT onUSBDeviceAttach(IUSBDevice aDevice, IVirtualBoxErrorInfo aError, ULONG aMaskedIfs);
220	HRESULT onUSBDeviceDetach(IN_BSTR aId, IVirtualBoxErrorInfo *aError);
221	HRESULT onBandwidthGroupChange(IBandwidthGroup *aBandwidthGroup);
222	HRESULT onStorageDeviceChange(IMediumAttachment *aMediumAttachment, BOOL aRemove, BOOL aSilent);
223
224	HRESULT getGuestProperty(IN_BSTR aKey, BSTR aValue, LONG64 aTimestamp, BSTR *aFlags);
225	HRESULT setGuestProperty(IN_BSTR aKey, IN_BSTR aValue, IN_BSTR aFlags);
226	HRESULT enumerateGuestProperties(IN_BSTR aPatterns,
227	ComSafeArrayOut(BSTR, aNames),
228	ComSafeArrayOut(BSTR, aValues),
229	ComSafeArrayOut(LONG64, aTimestamps),
230	ComSafeArrayOut(BSTR, aFlags));
231	HRESULT onlineMergeMedium(IMediumAttachment *aMediumAttachment,
232	ULONG aSourceIdx, ULONG aTargetIdx,
233	IProgress *aProgress);
234	int hgcmLoadService(const char pszServiceLibrary, const char pszServiceName);
235	VMMDev *getVMMDev() { return m_pVMMDev; }
236	AudioSniffer *getAudioSniffer() { return mAudioSniffer; }
237	#ifdef VBOX_WITH_EXTPACK
238	ExtPackManager *getExtPackManager();
239	#endif
240	EventSource *getEventSource() { return mEventSource; }
241	#ifdef VBOX_WITH_USB_CARDREADER
242	UsbCardReader *getUsbCardReader() { return mUsbCardReader; }
243	#endif
244	EmWebcam *getEmWebcam() { return mEmWebcam; }
245
246	int VRDPClientLogon(uint32_t u32ClientId, const char pszUser, const char pszPassword, const char *pszDomain);
247	void VRDPClientStatusChange(uint32_t u32ClientId, const char *pszStatus);
248	void VRDPClientConnect(uint32_t u32ClientId);
249	void VRDPClientDisconnect(uint32_t u32ClientId, uint32_t fu32Intercepted);
250	void VRDPInterceptAudio(uint32_t u32ClientId);
251	void VRDPInterceptUSB(uint32_t u32ClientId, void **ppvIntercept);
252	void VRDPInterceptClipboard(uint32_t u32ClientId);
253
254	void processRemoteUSBDevices(uint32_t u32ClientId, VRDEUSBDEVICEDESC *pDevList, uint32_t cbDevList, bool fDescExt);
255	void reportVmStatistics(ULONG aValidStats, ULONG aCpuUser,
256	ULONG aCpuKernel, ULONG aCpuIdle,
257	ULONG aMemTotal, ULONG aMemFree,
258	ULONG aMemBalloon, ULONG aMemShared,
259	ULONG aMemCache, ULONG aPageTotal,
260	ULONG aAllocVMM, ULONG aFreeVMM,
261	ULONG aBalloonedVMM, ULONG aSharedVMM,
262	ULONG aVmNetRx, ULONG aVmNetTx)
263	{
264	mControl->ReportVmStatistics(aValidStats, aCpuUser, aCpuKernel, aCpuIdle,
265	aMemTotal, aMemFree, aMemBalloon, aMemShared,
266	aMemCache, aPageTotal, aAllocVMM, aFreeVMM,
267	aBalloonedVMM, aSharedVMM, aVmNetRx, aVmNetTx);
268	}
269	void enableVMMStatistics(BOOL aEnable);
270
271	HRESULT pause(Reason_T aReason);
272	HRESULT resume(Reason_T aReason);
273	HRESULT saveState(Reason_T aReason, IProgress **aProgress);
274
275	// callback callers (partly; for some events console callbacks are notified
276	// directly from IInternalSessionControl event handlers declared above)
277	void onMousePointerShapeChange(bool fVisible, bool fAlpha,
278	uint32_t xHot, uint32_t yHot,
279	uint32_t width, uint32_t height,
280	ComSafeArrayIn(uint8_t, aShape));
281	void onMouseCapabilityChange(BOOL supportsAbsolute, BOOL supportsRelative,
282	BOOL supportsMT, BOOL needsHostCursor);
283	void onStateChange(MachineState_T aMachineState);
284	void onAdditionsStateChange();
285	void onAdditionsOutdated();
286	void onKeyboardLedsChange(bool fNumLock, bool fCapsLock, bool fScrollLock);
287	void onUSBDeviceStateChange(IUSBDevice *aDevice, bool aAttached,
288	IVirtualBoxErrorInfo *aError);
289	void onRuntimeError(BOOL aFatal, IN_BSTR aErrorID, IN_BSTR aMessage);
290	HRESULT onShowWindow(BOOL aCheck, BOOL aCanShow, LONG64 aWinId);
291	void onVRDEServerInfoChange();
292
293	static const PDMDRVREG DrvStatusReg;
294
295	static HRESULT setErrorStatic(HRESULT aResultCode, const char *pcsz, ...);
296	HRESULT setInvalidMachineStateError();
297
298	static const char *convertControllerTypeToDev(StorageControllerType_T enmCtrlType);
299	static HRESULT convertBusPortDeviceToLun(StorageBus_T enmBus, LONG port, LONG device, unsigned &uLun);
300	// Called from event listener
301	HRESULT onNATRedirectRuleChange(ULONG ulInstance, BOOL aNatRuleRemove,
302	NATProtocol_T aProto, IN_BSTR aHostIp, LONG aHostPort, IN_BSTR aGuestIp, LONG aGuestPort);
303
304	// Mouse interface
305	VMMDevMouseInterface *getVMMDevMouseInterface();
306	DisplayMouseInterface *getDisplayMouseInterface();
307
308	private:
309
310	/**
311	* Base template for AutoVMCaller and SafeVMPtr. Template arguments
312	* have the same meaning as arguments of Console::addVMCaller().
313	*/
314	template <bool taQuiet = false, bool taAllowNullVM = false>
315	class AutoVMCallerBase
316	{
317	public:
318	AutoVMCallerBase(Console *aThat) : mThat(aThat), mRC(S_OK)
319	{
320	Assert(aThat);
321	mRC = aThat->addVMCaller(taQuiet, taAllowNullVM);
322	}
323	~AutoVMCallerBase()
324	{
325	if (SUCCEEDED(mRC))
326	mThat->releaseVMCaller();
327	}
328	/** Decreases the number of callers before the instance is destroyed. */
329	void releaseCaller()
330	{
331	AssertReturnVoid(SUCCEEDED(mRC));
332	mThat->releaseVMCaller();
333	mRC = E_FAIL;
334	}
335	/** Restores the number of callers after by #release(). #rc() must be
336	* rechecked to ensure the operation succeeded. */
337	void addYY()
338	{
339	AssertReturnVoid(!SUCCEEDED(mRC));
340	mRC = mThat->addVMCaller(taQuiet, taAllowNullVM);
341	}
342	/** Returns the result of Console::addVMCaller() */
343	HRESULT rc() const { return mRC; }
344	/** Shortcut to SUCCEEDED(rc()) */
345	bool isOk() const { return SUCCEEDED(mRC); }
346	protected:
347	Console *mThat;
348	HRESULT mRC;
349	private:
350	DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(AutoVMCallerBase)
351	};
352
353	#if 0
354	/**
355	* Helper class that protects sections of code using the mpUVM pointer by
356	* automatically calling addVMCaller() on construction and
357	* releaseVMCaller() on destruction. Intended for Console methods dealing
358	* with mpUVM. The usage pattern is:
359	* <code>
360	* AutoVMCaller autoVMCaller(this);
361	* if (FAILED(autoVMCaller.rc())) return autoVMCaller.rc();
362	* ...
363	* VMR3ReqCall (mpUVM, ...
364	* </code>
365	*
366	* @note Temporarily locks the argument for writing.
367	*
368	* @sa SafeVMPtr, SafeVMPtrQuiet
369	* @obsolete Use SafeVMPtr
370	*/
371	typedef AutoVMCallerBase<false, false> AutoVMCaller;
372	#endif
373
374	/**
375	* Same as AutoVMCaller but doesn't set extended error info on failure.
376	*
377	* @note Temporarily locks the argument for writing.
378	* @obsolete Use SafeVMPtrQuiet
379	*/
380	typedef AutoVMCallerBase<true, false> AutoVMCallerQuiet;
381
382	/**
383	* Same as AutoVMCaller but allows a null VM pointer (to trigger an error
384	* instead of assertion).
385	*
386	* @note Temporarily locks the argument for writing.
387	* @obsolete Use SafeVMPtr
388	*/
389	typedef AutoVMCallerBase<false, true> AutoVMCallerWeak;
390
391	/**
392	* Same as AutoVMCaller but doesn't set extended error info on failure
393	* and allows a null VM pointer (to trigger an error instead of
394	* assertion).
395	*
396	* @note Temporarily locks the argument for writing.
397	* @obsolete Use SafeVMPtrQuiet
398	*/
399	typedef AutoVMCallerBase<true, true> AutoVMCallerQuietWeak;
400
401	/**
402	* Base template for SafeVMPtr and SafeVMPtrQuiet.
403	*/
404	template<bool taQuiet = false>
405	class SafeVMPtrBase : public AutoVMCallerBase<taQuiet, true>
406	{
407	typedef AutoVMCallerBase<taQuiet, true> Base;
408	public:
409	SafeVMPtrBase(Console *aThat) : Base(aThat), mpUVM(NULL)
410	{
411	if (SUCCEEDED(Base::mRC))
412	Base::mRC = aThat->safeVMPtrRetainer(&mpUVM, taQuiet);
413	}
414	~SafeVMPtrBase()
415	{
416	if (SUCCEEDED(Base::mRC))
417	release();
418	}
419	/** Direct PUVM access. */
420	PUVM rawUVM() const { return mpUVM; }
421	/** Release the handles. */
422	void release()
423	{
424	AssertReturnVoid(SUCCEEDED(Base::mRC));
425	Base::mThat->safeVMPtrReleaser(&mpUVM);
426	Base::releaseCaller();
427	}
428
429	private:
430	PUVM mpUVM;
431	DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(SafeVMPtrBase)
432	};
433
434	public:
435
436	/*
437	* Helper class that safely manages the Console::mpUVM pointer
438	* by calling addVMCaller() on construction and releaseVMCaller() on
439	* destruction. Intended for Console children. The usage pattern is:
440	* <code>
441	* Console::SafeVMPtr ptrVM(mParent);
442	* if (!ptrVM.isOk())
443	* return ptrVM.rc();
444	* ...
445	* VMR3ReqCall(ptrVM.rawUVM(), ...
446	* ...
447	* printf("%p\n", ptrVM.rawUVM());
448	* </code>
449	*
450	* @note Temporarily locks the argument for writing.
451	*
452	* @sa SafeVMPtrQuiet, AutoVMCaller
453	*/
454	typedef SafeVMPtrBase<false> SafeVMPtr;
455
456	/**
457	* A deviation of SafeVMPtr that doesn't set the error info on failure.
458	* Intended for pieces of code that don't need to return the VM access
459	* failure to the caller. The usage pattern is:
460	* <code>
461	* Console::SafeVMPtrQuiet pVM(mParent);
462	* if (pVM.rc())
463	* VMR3ReqCall(pVM, ...
464	* return S_OK;
465	* </code>
466	*
467	* @note Temporarily locks the argument for writing.
468	*
469	* @sa SafeVMPtr, AutoVMCaller
470	*/
471	typedef SafeVMPtrBase<true> SafeVMPtrQuiet;
472
473	class SharedFolderData
474	{
475	public:
476	SharedFolderData()
477	{ }
478
479	SharedFolderData(const Utf8Str &aHostPath,
480	bool aWritable,
481	bool aAutoMount)
482	: m_strHostPath(aHostPath),
483	m_fWritable(aWritable),
484	m_fAutoMount(aAutoMount)
485	{ }
486
487	// copy constructor
488	SharedFolderData(const SharedFolderData& aThat)
489	: m_strHostPath(aThat.m_strHostPath),
490	m_fWritable(aThat.m_fWritable),
491	m_fAutoMount(aThat.m_fAutoMount)
492	{ }
493
494	Utf8Str m_strHostPath;
495	bool m_fWritable;
496	bool m_fAutoMount;
497	};
498
499	typedef std::map<Utf8Str, ComObjPtr<SharedFolder> > SharedFolderMap;
500	typedef std::map<Utf8Str, SharedFolderData> SharedFolderDataMap;
501	typedef std::map<Utf8Str, ComPtr<IMediumAttachment> > MediumAttachmentMap;
502
503	private:
504
505	typedef std::list <ComObjPtr<OUSBDevice> > USBDeviceList;
506	typedef std::list <ComObjPtr<RemoteUSBDevice> > RemoteUSBDeviceList;
507
508	HRESULT addVMCaller(bool aQuiet = false, bool aAllowNullVM = false);
509	void releaseVMCaller();
510	HRESULT safeVMPtrRetainer(PUVM *a_ppUVM, bool aQuiet);
511	void safeVMPtrReleaser(PUVM *a_ppUVM);
512
513	HRESULT consoleInitReleaseLog(const ComPtr<IMachine> aMachine);
514
515	HRESULT powerUp(IProgress **aProgress, bool aPaused);
516	HRESULT powerDown(IProgress *aProgress = NULL);
517
518	/* Note: FreeBSD needs this whether netflt is used or not. */
519	#if ((defined(RT_OS_LINUX) && !defined(VBOX_WITH_NETFLT)) \|\| defined(RT_OS_FREEBSD))
520	HRESULT attachToTapInterface(INetworkAdapter *networkAdapter);
521	HRESULT detachFromTapInterface(INetworkAdapter *networkAdapter);
522	#endif
523	HRESULT powerDownHostInterfaces();
524
525	HRESULT setMachineState(MachineState_T aMachineState, bool aUpdateServer = true);
526	HRESULT setMachineStateLocally(MachineState_T aMachineState)
527	{
528	return setMachineState(aMachineState, false /* aUpdateServer */);
529	}
530
531	HRESULT findSharedFolder(const Utf8Str &strName,
532	ComObjPtr<SharedFolder> &aSharedFolder,
533	bool aSetError = false);
534
535	HRESULT fetchSharedFolders(BOOL aGlobal);
536	bool findOtherSharedFolder(const Utf8Str &straName,
537	SharedFolderDataMap::const_iterator &aIt);
538
539	HRESULT createSharedFolder(const Utf8Str &strName, const SharedFolderData &aData);
540	HRESULT removeSharedFolder(const Utf8Str &strName);
541
542	static DECLCALLBACK(int) configConstructor(PUVM pUVM, PVM pVM, void *pvConsole);
543	int configConstructorInner(PUVM pUVM, PVM pVM, AutoWriteLock *pAlock);
544	int configCfgmOverlay(PCFGMNODE pRoot, IVirtualBox pVirtualBox, IMachine pMachine);
545	int configDumpAPISettingsTweaks(IVirtualBox pVirtualBox, IMachine pMachine);
546
547	int configGraphicsController(PCFGMNODE pDevices, const char *pcszDevice,
548	BusAssignmentManager *pBusMgr,
549	const ComPtr<IMachine> &pMachine,
550	const ComPtr<IBIOSSettings> &biosSettings,
551	bool fHMEnabled);
552	int configMediumAttachment(PCFGMNODE pCtlInst,
553	const char *pcszDevice,
554	unsigned uInstance,
555	StorageBus_T enmBus,
556	bool fUseHostIOCache,
557	bool fBuiltinIoCache,
558	bool fSetupMerge,
559	unsigned uMergeSource,
560	unsigned uMergeTarget,
561	IMediumAttachment *pMediumAtt,
562	MachineState_T aMachineState,
563	HRESULT *phrc,
564	bool fAttachDetach,
565	bool fForceUnmount,
566	bool fHotplug,
567	PUVM pUVM,
568	DeviceType_T *paLedDevType);
569	int configMedium(PCFGMNODE pLunL0,
570	bool fPassthrough,
571	DeviceType_T enmType,
572	bool fUseHostIOCache,
573	bool fBuiltinIoCache,
574	bool fSetupMerge,
575	unsigned uMergeSource,
576	unsigned uMergeTarget,
577	const char *pcszBwGroup,
578	bool fDiscard,
579	IMedium *pMedium,
580	MachineState_T aMachineState,
581	HRESULT *phrc);
582	static DECLCALLBACK(int) reconfigureMediumAttachment(Console *pConsole,
583	PUVM pUVM,
584	const char *pcszDevice,
585	unsigned uInstance,
586	StorageBus_T enmBus,
587	bool fUseHostIOCache,
588	bool fBuiltinIoCache,
589	bool fSetupMerge,
590	unsigned uMergeSource,
591	unsigned uMergeTarget,
592	IMediumAttachment *aMediumAtt,
593	MachineState_T aMachineState,
594	HRESULT *phrc);
595	static DECLCALLBACK(int) changeRemovableMedium(Console *pThis,
596	PUVM pUVM,
597	const char *pcszDevice,
598	unsigned uInstance,
599	StorageBus_T enmBus,
600	bool fUseHostIOCache,
601	IMediumAttachment *aMediumAtt,
602	bool fForce);
603
604	HRESULT attachRawPCIDevices(PUVM pUVM, BusAssignmentManager *BusMgr, PCFGMNODE pDevices);
605	void attachStatusDriver(PCFGMNODE pCtlInst, PPDMLED *papLeds,
606	uint64_t uFirst, uint64_t uLast,
607	Console::MediumAttachmentMap *pmapMediumAttachments,
608	const char *pcszDevice, unsigned uInstance);
609
610	int configNetwork(const char *pszDevice, unsigned uInstance, unsigned uLun,
611	INetworkAdapter *aNetworkAdapter, PCFGMNODE pCfg,
612	PCFGMNODE pLunL0, PCFGMNODE pInst,
613	bool fAttachDetach, bool fIgnoreConnectFailure);
614
615	static DECLCALLBACK(int) configGuestProperties(void *pvConsole, PUVM pUVM);
616	static DECLCALLBACK(int) configGuestControl(void *pvConsole);
617	static DECLCALLBACK(void) vmstateChangeCallback(PUVM pUVM, VMSTATE enmState, VMSTATE enmOldState, void *pvUser);
618	static DECLCALLBACK(int) unplugCpu(Console *pThis, PUVM pUVM, VMCPUID idCpu);
619	static DECLCALLBACK(int) plugCpu(Console *pThis, PUVM pUVM, VMCPUID idCpu);
620	HRESULT doMediumChange(IMediumAttachment *aMediumAttachment, bool fForce, PUVM pUVM);
621	HRESULT doCPURemove(ULONG aCpu, PUVM pUVM);
622	HRESULT doCPUAdd(ULONG aCpu, PUVM pUVM);
623
624	HRESULT doNetworkAdapterChange(PUVM pUVM, const char *pszDevice, unsigned uInstance,
625	unsigned uLun, INetworkAdapter *aNetworkAdapter);
626	static DECLCALLBACK(int) changeNetworkAttachment(Console pThis, PUVM pUVM, const char pszDevice,
627	unsigned uInstance, unsigned uLun,
628	INetworkAdapter *aNetworkAdapter);
629
630	void changeClipboardMode(ClipboardMode_T aClipboardMode);
631	void changeDragAndDropMode(DragAndDropMode_T aDragAndDropMode);
632
633	#ifdef VBOX_WITH_USB
634	HRESULT attachUSBDevice(IUSBDevice *aHostDevice, ULONG aMaskedIfs);
635	HRESULT detachUSBDevice(const ComObjPtr<OUSBDevice> &aHostDevice);
636
637	static DECLCALLBACK(int) usbAttachCallback(Console that, PUVM pUVM, IUSBDevice aHostDevice, PCRTUUID aUuid,
638	bool aRemote, const char aAddress, void pvRemoteBackend, USHORT aPortVersion, ULONG aMaskedIfs);
639	static DECLCALLBACK(int) usbDetachCallback(Console *that, PUVM pUVM, PCRTUUID aUuid);
640	#endif
641
642	static DECLCALLBACK(int) attachStorageDevice(Console *pThis,
643	PUVM pUVM,
644	const char *pcszDevice,
645	unsigned uInstance,
646	StorageBus_T enmBus,
647	bool fUseHostIOCache,
648	IMediumAttachment *aMediumAtt,
649	bool fSilent);
650	static DECLCALLBACK(int) detachStorageDevice(Console *pThis,
651	PUVM pUVM,
652	const char *pcszDevice,
653	unsigned uInstance,
654	StorageBus_T enmBus,
655	IMediumAttachment *aMediumAtt,
656	bool fSilent);
657	HRESULT doStorageDeviceAttach(IMediumAttachment *aMediumAttachment, PUVM pUVM, bool fSilent);
658	HRESULT doStorageDeviceDetach(IMediumAttachment *aMediumAttachment, PUVM pUVM, bool fSilent);
659
660	static DECLCALLBACK(int) fntTakeSnapshotWorker(RTTHREAD Thread, void *pvUser);
661
662	static DECLCALLBACK(int) stateProgressCallback(PUVM pUVM, unsigned uPercent, void *pvUser);
663
664	static DECLCALLBACK(void) genericVMSetErrorCallback(PUVM pUVM, void *pvUser, int rc, RT_SRC_POS_DECL,
665	const char *pszErrorFmt, va_list va);
666
667	void setVMRuntimeErrorCallbackF(uint32_t fFatal, const char pszErrorId, const char pszFormat, ...);
668	static DECLCALLBACK(void) setVMRuntimeErrorCallback(PUVM pUVM, void *pvUser, uint32_t fFatal,
669	const char pszErrorId, const char pszFormat, va_list va);
670
671	HRESULT captureUSBDevices(PUVM pUVM);
672	void detachAllUSBDevices(bool aDone);
673
674	static DECLCALLBACK(int) powerUpThread(RTTHREAD Thread, void *pvUser);
675	static DECLCALLBACK(int) saveStateThread(RTTHREAD Thread, void *pvUser);
676	static DECLCALLBACK(int) powerDownThread(RTTHREAD Thread, void *pvUser);
677
678	static DECLCALLBACK(int) vmm2User_SaveState(PCVMM2USERMETHODS pThis, PUVM pUVM);
679	static DECLCALLBACK(void) vmm2User_NotifyEmtInit(PCVMM2USERMETHODS pThis, PUVM pUVM, PUVMCPU pUVCpu);
680	static DECLCALLBACK(void) vmm2User_NotifyEmtTerm(PCVMM2USERMETHODS pThis, PUVM pUVM, PUVMCPU pUVCpu);
681	static DECLCALLBACK(void) vmm2User_NotifyPdmtInit(PCVMM2USERMETHODS pThis, PUVM pUVM);
682	static DECLCALLBACK(void) vmm2User_NotifyPdmtTerm(PCVMM2USERMETHODS pThis, PUVM pUVM);
683	static DECLCALLBACK(void) vmm2User_NotifyResetTurnedIntoPowerOff(PCVMM2USERMETHODS pThis, PUVM pUVM);
684
685	static DECLCALLBACK(void ) drvStatus_QueryInterface(PPDMIBASE pInterface, const char pszIID);
686	static DECLCALLBACK(void) drvStatus_UnitChanged(PPDMILEDCONNECTORS pInterface, unsigned iLUN);
687	static DECLCALLBACK(int) drvStatus_MediumEjected(PPDMIMEDIANOTIFY pInterface, unsigned iLUN);
688	static DECLCALLBACK(void) drvStatus_Destruct(PPDMDRVINS pDrvIns);
689	static DECLCALLBACK(int) drvStatus_Construct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags);
690
691	int mcAudioRefs;
692	volatile uint32_t mcVRDPClients;
693	uint32_t mu32SingleRDPClientId; /* The id of a connected client in the single connection mode. */
694	volatile bool mcGuestCredentialsProvided;
695
696	static const char *sSSMConsoleUnit;
697	static uint32_t sSSMConsoleVer;
698
699	HRESULT loadDataFromSavedState();
700	int loadStateFileExecInternal(PSSMHANDLE pSSM, uint32_t u32Version);
701
702	static DECLCALLBACK(void) saveStateFileExec(PSSMHANDLE pSSM, void *pvUser);
703	static DECLCALLBACK(int) loadStateFileExec(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass);
704
705	#ifdef VBOX_WITH_GUEST_PROPS
706	static DECLCALLBACK(int) doGuestPropNotification(void pvExtension, uint32_t, void pvParms, uint32_t cbParms);
707	HRESULT doEnumerateGuestProperties(CBSTR aPatterns,
708	ComSafeArrayOut(BSTR, aNames),
709	ComSafeArrayOut(BSTR, aValues),
710	ComSafeArrayOut(LONG64, aTimestamps),
711	ComSafeArrayOut(BSTR, aFlags));
712
713	void guestPropertiesHandleVMReset(void);
714	bool guestPropertiesVRDPEnabled(void);
715	void guestPropertiesVRDPUpdateLogon(uint32_t u32ClientId, const char pszUser, const char pszDomain);
716	void guestPropertiesVRDPUpdateActiveClient(uint32_t u32ClientId);
717	void guestPropertiesVRDPUpdateClientAttach(uint32_t u32ClientId, bool fAttached);
718	void guestPropertiesVRDPUpdateNameChange(uint32_t u32ClientId, const char *pszName);
719	void guestPropertiesVRDPUpdateIPAddrChange(uint32_t u32ClientId, const char *pszIPAddr);
720	void guestPropertiesVRDPUpdateLocationChange(uint32_t u32ClientId, const char *pszLocation);
721	void guestPropertiesVRDPUpdateOtherInfoChange(uint32_t u32ClientId, const char *pszOtherInfo);
722	void guestPropertiesVRDPUpdateDisconnect(uint32_t u32ClientId);
723	#endif
724
725	bool isResetTurnedIntoPowerOff(void);
726
727	/** @name Teleporter support
728	* @{ */
729	static DECLCALLBACK(int) teleporterSrcThreadWrapper(RTTHREAD hThread, void *pvUser);
730	HRESULT teleporterSrc(TeleporterStateSrc *pState);
731	HRESULT teleporterSrcReadACK(TeleporterStateSrc pState, const char pszWhich, const char *pszNAckMsg = NULL);
732	HRESULT teleporterSrcSubmitCommand(TeleporterStateSrc pState, const char pszCommand, bool fWaitForAck = true);
733	HRESULT teleporterTrg(PUVM pUVM, IMachine pMachine, Utf8Str pErrorMsg, bool fStartPaused,
734	Progress pProgress, bool pfPowerOffOnFailure);
735	static DECLCALLBACK(int) teleporterTrgServeConnection(RTSOCKET Sock, void *pvUser);
736	/** @} */
737
738	bool mSavedStateDataLoaded : 1;
739
740	const ComPtr<IMachine> mMachine;
741	const ComPtr<IInternalMachineControl> mControl;
742
743	const ComPtr<IVRDEServer> mVRDEServer;
744
745	ConsoleVRDPServer * const mConsoleVRDPServer;
746	bool mfVRDEChangeInProcess;
747	bool mfVRDEChangePending;
748
749	const ComObjPtr<Guest> mGuest;
750	const ComObjPtr<Keyboard> mKeyboard;
751	const ComObjPtr<Mouse> mMouse;
752	const ComObjPtr<Display> mDisplay;
753	const ComObjPtr<MachineDebugger> mDebugger;
754	const ComObjPtr<VRDEServerInfo> mVRDEServerInfo;
755	/** This can safely be used without holding any locks.
756	* An AutoCaller suffices to prevent it being destroy while in use and
757	* internally there is a lock providing the necessary serialization. */
758	const ComObjPtr<EventSource> mEventSource;
759	#ifdef VBOX_WITH_EXTPACK
760	const ComObjPtr<ExtPackManager> mptrExtPackManager;
761	#endif
762	const ComObjPtr<EmulatedUSB> mEmulatedUSB;
763
764	USBDeviceList mUSBDevices;
765	RemoteUSBDeviceList mRemoteUSBDevices;
766
767	SharedFolderDataMap m_mapGlobalSharedFolders;
768	SharedFolderDataMap m_mapMachineSharedFolders;
769	SharedFolderMap m_mapSharedFolders; // the console instances
770
771	/** The user mode VM handle. */
772	PUVM mpUVM;
773	/** Holds the number of "readonly" mpUVM callers (users). */
774	uint32_t mVMCallers;
775	/** Semaphore posted when the number of mpUVM callers drops to zero. */
776	RTSEMEVENT mVMZeroCallersSem;
777	/** true when Console has entered the mpUVM destruction phase. */
778	bool mVMDestroying : 1;
779	/** true when power down is initiated by vmstateChangeCallback (EMT). */
780	bool mVMPoweredOff : 1;
781	/** true when vmstateChangeCallback shouldn't initiate a power down. */
782	bool mVMIsAlreadyPoweringOff : 1;
783	/** true if we already showed the snapshot folder size warning. */
784	bool mfSnapshotFolderSizeWarningShown : 1;
785	/** true if we already showed the snapshot folder ext4/xfs bug warning. */
786	bool mfSnapshotFolderExt4WarningShown : 1;
787	/** true if we already listed the disk type of the snapshot folder. */
788	bool mfSnapshotFolderDiskTypeShown : 1;
789	/** true if a USB controller is available (i.e. USB devices can be attached). */
790	bool mfVMHasUsbController : 1;
791	/** true if the VM power off was caused by reset. */
792	bool mfPowerOffCausedByReset : 1;
793
794	/** Pointer to the VMM -> User (that's us) callbacks. */
795	struct MYVMM2USERMETHODS : public VMM2USERMETHODS
796	{
797	Console *pConsole;
798	} *mpVmm2UserMethods;
799
800	/** The current network attachment type in the VM.
801	* This doesn't have to match the network attachment type maintained in the
802	* NetworkAdapter. This is needed to change the network attachment
803	* dynamically.
804	*/
805	typedef std::vector<NetworkAttachmentType_T> NetworkAttachmentTypeVector;
806	NetworkAttachmentTypeVector meAttachmentType;
807
808	VMMDev * m_pVMMDev;
809	AudioSniffer * const mAudioSniffer;
810	Nvram * const mNvram;
811	EmWebcam * const mEmWebcam;
812	#ifdef VBOX_WITH_USB_CARDREADER
813	UsbCardReader * const mUsbCardReader;
814	#endif
815	BusAssignmentManager* mBusMgr;
816
817	enum
818	{
819	iLedFloppy = 0,
820	cLedFloppy = 2,
821	iLedIde = iLedFloppy + cLedFloppy,
822	cLedIde = 4,
823	iLedSata = iLedIde + cLedIde,
824	cLedSata = 30,
825	iLedScsi = iLedSata + cLedSata,
826	cLedScsi = 16,
827	iLedSas = iLedScsi + cLedScsi,
828	cLedSas = 8,
829	cLedStorage = cLedFloppy + cLedIde + cLedSata + cLedScsi + cLedSas
830	};
831	DeviceType_T maStorageDevType[cLedStorage];
832	PPDMLED mapStorageLeds[cLedStorage];
833	PPDMLED mapNetworkLeds[36]; /*< @todo adapt this to the maximum network card count /
834	PPDMLED mapSharedFolderLed;
835	PPDMLED mapUSBLed[2];
836
837	MediumAttachmentMap mapMediumAttachments;
838
839	/* Note: FreeBSD needs this whether netflt is used or not. */
840	#if ((defined(RT_OS_LINUX) && !defined(VBOX_WITH_NETFLT)) \|\| defined(RT_OS_FREEBSD))
841	Utf8Str maTAPDeviceName[8];
842	RTFILE maTapFD[8];
843	#endif
844
845	bool mVMStateChangeCallbackDisabled;
846
847	bool mfUseHostClipboard;
848
849	/** Local machine state value. */
850	MachineState_T mMachineState;
851
852	/** Pointer to the progress object of a live cancelable task.
853	*
854	* This is currently only used by Console::Teleport(), but is intended to later
855	* be used by the live snapshot code path as well. Actions like
856	* Console::PowerDown, which automatically cancels out the running snapshot /
857	* teleportation operation, will cancel the teleportation / live snapshot
858	* operation before starting. */
859	ComObjPtr<Progress> mptrCancelableProgress;
860
861	/* The purpose of caching of some events is probably in order to
862	automatically fire them at new event listeners. However, there is no
863	(longer?) any code making use of this... */
864	#ifdef CONSOLE_WITH_EVENT_CACHE
865	struct
866	{
867	/** OnMousePointerShapeChange() cache */
868	struct
869	{
870	bool valid;
871	bool visible;
872	bool alpha;
873	uint32_t xHot;
874	uint32_t yHot;
875	uint32_t width;
876	uint32_t height;
877	com::SafeArray<BYTE> shape;
878	} mpsc;
879
880	/** OnMouseCapabilityChange() cache */
881	struct
882	{
883	bool valid;
884	BOOL supportsAbsolute;
885	BOOL supportsRelative;
886	BOOL needsHostCursor;
887	} mcc;
888
889	/** OnKeyboardLedsChange() cache */
890	struct
891	{
892	bool valid;
893	bool numLock;
894	bool capsLock;
895	bool scrollLock;
896	} klc;
897
898	void clear()
899	{
900	RT_ZERO(mcc);
901	RT_ZERO(klc);
902
903	/* We cannot RT_ZERO mpsc because of shape's vtable. */
904	mpsc.shape.setNull();
905	mpsc.valid = mpsc.visible = mpsc.alpha = false;
906	mpsc.xHot = mpsc.yHot = mpsc.width = mpsc.height = 0;
907	}
908	} mCallbackData;
909	#endif
910	ComPtr<IEventListener> mVmListener;
911
912	friend struct VMTask;
913	};
914
915	#endif // !____H_CONSOLEIMPL
916	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/VBox/Main/include/ConsoleImpl.h@ 48819

以其他格式下載: