ConsoleImpl.cpp@ 45772

Last change on this file since 45772 was 45757, checked in by vboxsync, 12 years ago
Main: more debugging
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 333.9 KB

Line
1	/* $Id: ConsoleImpl.cpp 45757 2013-04-26 07:00:59Z vboxsync $ */
2	/** @file
3	* VBox Console COM Class implementation
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.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	/** @todo Move the TAP mess back into the driver! */
19	#if defined(RT_OS_WINDOWS)
20	#elif defined(RT_OS_LINUX)
21	# include <errno.h>
22	# include <sys/ioctl.h>
23	# include <sys/poll.h>
24	# include <sys/fcntl.h>
25	# include <sys/types.h>
26	# include <sys/wait.h>
27	# include <net/if.h>
28	# include <linux/if_tun.h>
29	# include <stdio.h>
30	# include <stdlib.h>
31	# include <string.h>
32	#elif defined(RT_OS_FREEBSD)
33	# include <errno.h>
34	# include <sys/ioctl.h>
35	# include <sys/poll.h>
36	# include <sys/fcntl.h>
37	# include <sys/types.h>
38	# include <sys/wait.h>
39	# include <stdio.h>
40	# include <stdlib.h>
41	# include <string.h>
42	#elif defined(RT_OS_SOLARIS)
43	# include <iprt/coredumper.h>
44	#endif
45
46	#include "ConsoleImpl.h"
47
48	#include "Global.h"
49	#include "VirtualBoxErrorInfoImpl.h"
50	#include "GuestImpl.h"
51	#include "KeyboardImpl.h"
52	#include "MouseImpl.h"
53	#include "DisplayImpl.h"
54	#include "MachineDebuggerImpl.h"
55	#include "USBDeviceImpl.h"
56	#include "RemoteUSBDeviceImpl.h"
57	#include "SharedFolderImpl.h"
58	#include "AudioSnifferInterface.h"
59	#include "Nvram.h"
60	#ifdef VBOX_WITH_USB_VIDEO
61	# include "UsbWebcamInterface.h"
62	#endif
63	#ifdef VBOX_WITH_USB_CARDREADER
64	# include "UsbCardReader.h"
65	#endif
66	#include "ProgressImpl.h"
67	#include "ConsoleVRDPServer.h"
68	#include "VMMDev.h"
69	#ifdef VBOX_WITH_EXTPACK
70	# include "ExtPackManagerImpl.h"
71	#endif
72	#include "BusAssignmentManager.h"
73
74	#include "VBoxEvents.h"
75	#include "AutoCaller.h"
76	#include "Logging.h"
77
78	#include <VBox/com/array.h>
79	#include "VBox/com/ErrorInfo.h"
80	#include <VBox/com/listeners.h>
81
82	#include <iprt/asm.h>
83	#include <iprt/buildconfig.h>
84	#include <iprt/cpp/utils.h>
85	#include <iprt/dir.h>
86	#include <iprt/file.h>
87	#include <iprt/ldr.h>
88	#include <iprt/path.h>
89	#include <iprt/process.h>
90	#include <iprt/string.h>
91	#include <iprt/system.h>
92
93	#include <VBox/vmm/vmapi.h>
94	#include <VBox/vmm/vmm.h>
95	#include <VBox/vmm/pdmapi.h>
96	#include <VBox/vmm/pdmasynccompletion.h>
97	#include <VBox/vmm/pdmnetifs.h>
98	#ifdef VBOX_WITH_USB
99	# include <VBox/vmm/pdmusb.h>
100	#endif
101	#ifdef VBOX_WITH_NETSHAPER
102	# include <VBox/vmm/pdmnetshaper.h>
103	#endif /* VBOX_WITH_NETSHAPER */
104	#include <VBox/vmm/mm.h>
105	#include <VBox/vmm/ftm.h>
106	#include <VBox/vmm/ssm.h>
107	#include <VBox/err.h>
108	#include <VBox/param.h>
109	#include <VBox/vusb.h>
110
111	#include <VBox/VMMDev.h>
112
113	#include <VBox/HostServices/VBoxClipboardSvc.h>
114	#include <VBox/HostServices/DragAndDropSvc.h>
115	#ifdef VBOX_WITH_GUEST_PROPS
116	# include <VBox/HostServices/GuestPropertySvc.h>
117	# include <VBox/com/array.h>
118	#endif
119
120	#include <set>
121	#include <algorithm>
122	#include <memory> // for auto_ptr
123	#include <vector>
124
125
126	// VMTask and friends
127	////////////////////////////////////////////////////////////////////////////////
128
129	/**
130	* Task structure for asynchronous VM operations.
131	*
132	* Once created, the task structure adds itself as a Console caller. This means:
133	*
134	* 1. The user must check for #rc() before using the created structure
135	* (e.g. passing it as a thread function argument). If #rc() returns a
136	* failure, the Console object may not be used by the task (see
137	* Console::addCaller() for more details).
138	* 2. On successful initialization, the structure keeps the Console caller
139	* until destruction (to ensure Console remains in the Ready state and won't
140	* be accidentally uninitialized). Forgetting to delete the created task
141	* will lead to Console::uninit() stuck waiting for releasing all added
142	* callers.
143	*
144	* If \a aUsesVMPtr parameter is true, the task structure will also add itself
145	* as a Console::mpUVM caller with the same meaning as above. See
146	* Console::addVMCaller() for more info.
147	*/
148	struct VMTask
149	{
150	VMTask(Console *aConsole,
151	Progress *aProgress,
152	const ComPtr<IProgress> &aServerProgress,
153	bool aUsesVMPtr)
154	: mConsole(aConsole),
155	mConsoleCaller(aConsole),
156	mProgress(aProgress),
157	mServerProgress(aServerProgress),
158	mpUVM(NULL),
159	mRC(E_FAIL),
160	mpSafeVMPtr(NULL)
161	{
162	AssertReturnVoid(aConsole);
163	mRC = mConsoleCaller.rc();
164	if (FAILED(mRC))
165	return;
166	if (aUsesVMPtr)
167	{
168	mpSafeVMPtr = new Console::SafeVMPtr(aConsole);
169	if (mpSafeVMPtr->isOk())
170	mpUVM = mpSafeVMPtr->rawUVM();
171	else
172	mRC = mpSafeVMPtr->rc();
173	}
174	}
175
176	~VMTask()
177	{
178	releaseVMCaller();
179	}
180
181	HRESULT rc() const { return mRC; }
182	bool isOk() const { return SUCCEEDED(rc()); }
183
184	/** Releases the VM caller before destruction. Not normally necessary. */
185	void releaseVMCaller()
186	{
187	if (mpSafeVMPtr)
188	{
189	delete mpSafeVMPtr;
190	mpSafeVMPtr = NULL;
191	}
192	}
193
194	const ComObjPtr<Console> mConsole;
195	AutoCaller mConsoleCaller;
196	const ComObjPtr<Progress> mProgress;
197	Utf8Str mErrorMsg;
198	const ComPtr<IProgress> mServerProgress;
199	PUVM mpUVM;
200
201	private:
202	HRESULT mRC;
203	Console::SafeVMPtr *mpSafeVMPtr;
204	};
205
206	struct VMTakeSnapshotTask : public VMTask
207	{
208	VMTakeSnapshotTask(Console *aConsole,
209	Progress *aProgress,
210	IN_BSTR aName,
211	IN_BSTR aDescription)
212	: VMTask(aConsole, aProgress, NULL /* aServerProgress */,
213	false /* aUsesVMPtr */),
214	bstrName(aName),
215	bstrDescription(aDescription),
216	lastMachineState(MachineState_Null)
217	{}
218
219	Bstr bstrName,
220	bstrDescription;
221	Bstr bstrSavedStateFile; // received from BeginTakeSnapshot()
222	MachineState_T lastMachineState;
223	bool fTakingSnapshotOnline;
224	ULONG ulMemSize;
225	};
226
227	struct VMPowerUpTask : public VMTask
228	{
229	VMPowerUpTask(Console *aConsole,
230	Progress *aProgress)
231	: VMTask(aConsole, aProgress, NULL /* aServerProgress */,
232	false /* aUsesVMPtr */),
233	mConfigConstructor(NULL),
234	mStartPaused(false),
235	mTeleporterEnabled(FALSE),
236	mEnmFaultToleranceState(FaultToleranceState_Inactive)
237	{}
238
239	PFNCFGMCONSTRUCTOR mConfigConstructor;
240	Utf8Str mSavedStateFile;
241	Console::SharedFolderDataMap mSharedFolders;
242	bool mStartPaused;
243	BOOL mTeleporterEnabled;
244	FaultToleranceState_T mEnmFaultToleranceState;
245
246	/* array of progress objects for hard disk reset operations */
247	typedef std::list<ComPtr<IProgress> > ProgressList;
248	ProgressList hardDiskProgresses;
249	};
250
251	struct VMPowerDownTask : public VMTask
252	{
253	VMPowerDownTask(Console *aConsole,
254	const ComPtr<IProgress> &aServerProgress)
255	: VMTask(aConsole, NULL /* aProgress */, aServerProgress,
256	true /* aUsesVMPtr */)
257	{}
258	};
259
260	struct VMSaveTask : public VMTask
261	{
262	VMSaveTask(Console *aConsole,
263	const ComPtr<IProgress> &aServerProgress,
264	const Utf8Str &aSavedStateFile,
265	MachineState_T aMachineStateBefore)
266	: VMTask(aConsole, NULL /* aProgress */, aServerProgress,
267	true /* aUsesVMPtr */),
268	mSavedStateFile(aSavedStateFile),
269	mMachineStateBefore(aMachineStateBefore)
270	{}
271
272	Utf8Str mSavedStateFile;
273	/* The local machine state we had before. Required if something fails */
274	MachineState_T mMachineStateBefore;
275	};
276
277	// Handler for global events
278	////////////////////////////////////////////////////////////////////////////////
279	inline static const char *networkAdapterTypeToName(NetworkAdapterType_T adapterType);
280
281	class VmEventListener {
282	public:
283	VmEventListener()
284	{}
285
286
287	HRESULT init(Console *aConsole)
288	{
289	mConsole = aConsole;
290	return S_OK;
291	}
292
293	void uninit()
294	{
295	}
296
297	virtual ~VmEventListener()
298	{
299	}
300
301	STDMETHOD(HandleEvent)(VBoxEventType_T aType, IEvent * aEvent)
302	{
303	switch(aType)
304	{
305	case VBoxEventType_OnNATRedirect:
306	{
307	Bstr id;
308	ComPtr<IMachine> pMachine = mConsole->machine();
309	ComPtr<INATRedirectEvent> pNREv = aEvent;
310	HRESULT rc = E_FAIL;
311	Assert(pNREv);
312
313	Bstr interestedId;
314	rc = pMachine->COMGETTER(Id)(interestedId.asOutParam());
315	AssertComRC(rc);
316	rc = pNREv->COMGETTER(MachineId)(id.asOutParam());
317	AssertComRC(rc);
318	if (id != interestedId)
319	break;
320	/* now we can operate with redirects */
321	NATProtocol_T proto;
322	pNREv->COMGETTER(Proto)(&proto);
323	BOOL fRemove;
324	pNREv->COMGETTER(Remove)(&fRemove);
325	bool fUdp = (proto == NATProtocol_UDP);
326	Bstr hostIp, guestIp;
327	LONG hostPort, guestPort;
328	pNREv->COMGETTER(HostIP)(hostIp.asOutParam());
329	pNREv->COMGETTER(HostPort)(&hostPort);
330	pNREv->COMGETTER(GuestIP)(guestIp.asOutParam());
331	pNREv->COMGETTER(GuestPort)(&guestPort);
332	ULONG ulSlot;
333	rc = pNREv->COMGETTER(Slot)(&ulSlot);
334	AssertComRC(rc);
335	if (FAILED(rc))
336	break;
337	mConsole->onNATRedirectRuleChange(ulSlot, fRemove, proto, hostIp.raw(), hostPort, guestIp.raw(), guestPort);
338	}
339	break;
340
341	case VBoxEventType_OnHostPCIDevicePlug:
342	{
343	// handle if needed
344	break;
345	}
346
347	default:
348	AssertFailed();
349	}
350	return S_OK;
351	}
352	private:
353	Console *mConsole;
354	};
355
356	typedef ListenerImpl<VmEventListener, Console*> VmEventListenerImpl;
357
358
359	VBOX_LISTENER_DECLARE(VmEventListenerImpl)
360
361
362	// constructor / destructor
363	/////////////////////////////////////////////////////////////////////////////
364
365	Console::Console()
366	: mSavedStateDataLoaded(false)
367	, mConsoleVRDPServer(NULL)
368	, mpUVM(NULL)
369	, mVMCallers(0)
370	, mVMZeroCallersSem(NIL_RTSEMEVENT)
371	, mVMDestroying(false)
372	, mVMPoweredOff(false)
373	, mVMIsAlreadyPoweringOff(false)
374	, mfSnapshotFolderSizeWarningShown(false)
375	, mfSnapshotFolderExt4WarningShown(false)
376	, mfSnapshotFolderDiskTypeShown(false)
377	, mpVmm2UserMethods(NULL)
378	, m_pVMMDev(NULL)
379	, mAudioSniffer(NULL)
380	, mNvram(NULL)
381	#ifdef VBOX_WITH_USB_VIDEO
382	, mEmWebcam(NULL)
383	#endif
384	#ifdef VBOX_WITH_USB_CARDREADER
385	, mUsbCardReader(NULL)
386	#endif
387	, mBusMgr(NULL)
388	, mVMStateChangeCallbackDisabled(false)
389	, mfUseHostClipboard(true)
390	, mMachineState(MachineState_PoweredOff)
391	{
392	}
393
394	Console::~Console()
395	{}
396
397	HRESULT Console::FinalConstruct()
398	{
399	LogFlowThisFunc(("\n"));
400
401	memset(mapStorageLeds, 0, sizeof(mapStorageLeds));
402	memset(mapNetworkLeds, 0, sizeof(mapNetworkLeds));
403	memset(&mapUSBLed, 0, sizeof(mapUSBLed));
404	memset(&mapSharedFolderLed, 0, sizeof(mapSharedFolderLed));
405
406	for (unsigned i = 0; i < RT_ELEMENTS(maStorageDevType); ++i)
407	maStorageDevType[i] = DeviceType_Null;
408
409	MYVMM2USERMETHODS pVmm2UserMethods = (MYVMM2USERMETHODS )RTMemAllocZ(sizeof(mpVmm2UserMethods) + sizeof(Console ));
410	if (!pVmm2UserMethods)
411	return E_OUTOFMEMORY;
412	pVmm2UserMethods->u32Magic = VMM2USERMETHODS_MAGIC;
413	pVmm2UserMethods->u32Version = VMM2USERMETHODS_VERSION;
414	pVmm2UserMethods->pfnSaveState = Console::vmm2User_SaveState;
415	pVmm2UserMethods->pfnNotifyEmtInit = Console::vmm2User_NotifyEmtInit;
416	pVmm2UserMethods->pfnNotifyEmtTerm = Console::vmm2User_NotifyEmtTerm;
417	pVmm2UserMethods->pfnNotifyPdmtInit = Console::vmm2User_NotifyPdmtInit;
418	pVmm2UserMethods->pfnNotifyPdmtTerm = Console::vmm2User_NotifyPdmtTerm;
419	pVmm2UserMethods->u32EndMagic = VMM2USERMETHODS_MAGIC;
420	pVmm2UserMethods->pConsole = this;
421	mpVmm2UserMethods = pVmm2UserMethods;
422
423	return BaseFinalConstruct();
424	}
425
426	void Console::FinalRelease()
427	{
428	LogFlowThisFunc(("\n"));
429
430	uninit();
431
432	BaseFinalRelease();
433	}
434
435	// public initializer/uninitializer for internal purposes only
436	/////////////////////////////////////////////////////////////////////////////
437
438	HRESULT Console::init(IMachine aMachine, IInternalMachineControl aControl, LockType_T aLockType)
439	{
440	AssertReturn(aMachine && aControl, E_INVALIDARG);
441
442	/* Enclose the state transition NotReady->InInit->Ready */
443	AutoInitSpan autoInitSpan(this);
444	AssertReturn(autoInitSpan.isOk(), E_FAIL);
445
446	LogFlowThisFuncEnter();
447	LogFlowThisFunc(("aMachine=%p, aControl=%p\n", aMachine, aControl));
448
449	HRESULT rc = E_FAIL;
450
451	unconst(mMachine) = aMachine;
452	unconst(mControl) = aControl;
453
454	/* Cache essential properties and objects, and create child objects */
455
456	rc = mMachine->COMGETTER(State)(&mMachineState);
457	AssertComRCReturnRC(rc);
458
459	#ifdef VBOX_WITH_EXTPACK
460	unconst(mptrExtPackManager).createObject();
461	rc = mptrExtPackManager->initExtPackManager(NULL, VBOXEXTPACKCTX_VM_PROCESS);
462	AssertComRCReturnRC(rc);
463	#endif
464
465	// Event source may be needed by other children
466	unconst(mEventSource).createObject();
467	rc = mEventSource->init(static_cast<IConsole*>(this));
468	AssertComRCReturnRC(rc);
469
470	mcAudioRefs = 0;
471	mcVRDPClients = 0;
472	mu32SingleRDPClientId = 0;
473	mcGuestCredentialsProvided = false;
474
475	/* Now the VM specific parts */
476	if (aLockType == LockType_VM)
477	{
478	rc = mMachine->COMGETTER(VRDEServer)(unconst(mVRDEServer).asOutParam());
479	AssertComRCReturnRC(rc);
480
481	unconst(mGuest).createObject();
482	rc = mGuest->init(this);
483	AssertComRCReturnRC(rc);
484
485	unconst(mKeyboard).createObject();
486	rc = mKeyboard->init(this);
487	AssertComRCReturnRC(rc);
488
489	unconst(mMouse).createObject();
490	rc = mMouse->init(this);
491	AssertComRCReturnRC(rc);
492
493	unconst(mDisplay).createObject();
494	rc = mDisplay->init(this);
495	AssertComRCReturnRC(rc);
496
497	unconst(mVRDEServerInfo).createObject();
498	rc = mVRDEServerInfo->init(this);
499	AssertComRCReturnRC(rc);
500
501	/* Grab global and machine shared folder lists */
502
503	rc = fetchSharedFolders(true /* aGlobal */);
504	AssertComRCReturnRC(rc);
505	rc = fetchSharedFolders(false /* aGlobal */);
506	AssertComRCReturnRC(rc);
507
508	/* Create other child objects */
509
510	unconst(mConsoleVRDPServer) = new ConsoleVRDPServer(this);
511	AssertReturn(mConsoleVRDPServer, E_FAIL);
512
513	/* Figure out size of meAttachmentType vector */
514	ComPtr<IVirtualBox> pVirtualBox;
515	rc = aMachine->COMGETTER(Parent)(pVirtualBox.asOutParam());
516	AssertComRC(rc);
517	ComPtr<ISystemProperties> pSystemProperties;
518	if (pVirtualBox)
519	pVirtualBox->COMGETTER(SystemProperties)(pSystemProperties.asOutParam());
520	ChipsetType_T chipsetType = ChipsetType_PIIX3;
521	aMachine->COMGETTER(ChipsetType)(&chipsetType);
522	ULONG maxNetworkAdapters = 0;
523	if (pSystemProperties)
524	pSystemProperties->GetMaxNetworkAdapters(chipsetType, &maxNetworkAdapters);
525	meAttachmentType.resize(maxNetworkAdapters);
526	for (ULONG slot = 0; slot < maxNetworkAdapters; ++slot)
527	meAttachmentType[slot] = NetworkAttachmentType_Null;
528
529	// VirtualBox 4.0: We no longer initialize the VMMDev instance here,
530	// which starts the HGCM thread. Instead, this is now done in the
531	// power-up thread when a VM is actually being powered up to avoid
532	// having HGCM threads all over the place every time a session is
533	// opened, even if that session will not run a VM.
534	// unconst(m_pVMMDev) = new VMMDev(this);
535	// AssertReturn(mVMMDev, E_FAIL);
536
537	unconst(mAudioSniffer) = new AudioSniffer(this);
538	AssertReturn(mAudioSniffer, E_FAIL);
539
540	FirmwareType_T enmFirmwareType;
541	mMachine->COMGETTER(FirmwareType)(&enmFirmwareType);
542	if ( enmFirmwareType == FirmwareType_EFI
543	\|\| enmFirmwareType == FirmwareType_EFI32
544	\|\| enmFirmwareType == FirmwareType_EFI64
545	\|\| enmFirmwareType == FirmwareType_EFIDUAL)
546	{
547	unconst(mNvram) = new Nvram(this);
548	AssertReturn(mNvram, E_FAIL);
549	}
550
551	#ifdef VBOX_WITH_USB_VIDEO
552	unconst(mEmWebcam) = new EmWebcam(this);
553	AssertReturn(mEmWebcam, E_FAIL);
554	#endif
555	#ifdef VBOX_WITH_USB_CARDREADER
556	unconst(mUsbCardReader) = new UsbCardReader(this);
557	AssertReturn(mUsbCardReader, E_FAIL);
558	#endif
559
560	/* VirtualBox events registration. */
561	{
562	ComPtr<IEventSource> pES;
563	rc = pVirtualBox->COMGETTER(EventSource)(pES.asOutParam());
564	AssertComRC(rc);
565	ComObjPtr<VmEventListenerImpl> aVmListener;
566	aVmListener.createObject();
567	aVmListener->init(new VmEventListener(), this);
568	mVmListener = aVmListener;
569	com::SafeArray<VBoxEventType_T> eventTypes;
570	eventTypes.push_back(VBoxEventType_OnNATRedirect);
571	eventTypes.push_back(VBoxEventType_OnHostPCIDevicePlug);
572	rc = pES->RegisterListener(aVmListener, ComSafeArrayAsInParam(eventTypes), true);
573	AssertComRC(rc);
574	}
575	}
576
577	/* Confirm a successful initialization when it's the case */
578	autoInitSpan.setSucceeded();
579
580	#ifdef VBOX_WITH_EXTPACK
581	/* Let the extension packs have a go at things (hold no locks). */
582	if (SUCCEEDED(rc))
583	mptrExtPackManager->callAllConsoleReadyHooks(this);
584	#endif
585
586	LogFlowThisFuncLeave();
587
588	return S_OK;
589	}
590
591	/**
592	* Uninitializes the Console object.
593	*/
594	void Console::uninit()
595	{
596	LogFlowThisFuncEnter();
597
598	/* Enclose the state transition Ready->InUninit->NotReady */
599	AutoUninitSpan autoUninitSpan(this);
600	if (autoUninitSpan.uninitDone())
601	{
602	LogFlowThisFunc(("Already uninitialized.\n"));
603	LogFlowThisFuncLeave();
604	return;
605	}
606
607	LogFlowThisFunc(("initFailed()=%d\n", autoUninitSpan.initFailed()));
608	if (mVmListener)
609	{
610	ComPtr<IEventSource> pES;
611	ComPtr<IVirtualBox> pVirtualBox;
612	HRESULT rc = mMachine->COMGETTER(Parent)(pVirtualBox.asOutParam());
613	AssertComRC(rc);
614	if (SUCCEEDED(rc) && !pVirtualBox.isNull())
615	{
616	rc = pVirtualBox->COMGETTER(EventSource)(pES.asOutParam());
617	AssertComRC(rc);
618	if (!pES.isNull())
619	{
620	rc = pES->UnregisterListener(mVmListener);
621	AssertComRC(rc);
622	}
623	}
624	mVmListener.setNull();
625	}
626
627	/* power down the VM if necessary */
628	if (mpUVM)
629	{
630	powerDown();
631	Assert(mpUVM == NULL);
632	}
633
634	if (mVMZeroCallersSem != NIL_RTSEMEVENT)
635	{
636	RTSemEventDestroy(mVMZeroCallersSem);
637	mVMZeroCallersSem = NIL_RTSEMEVENT;
638	}
639
640	if (mpVmm2UserMethods)
641	{
642	RTMemFree((void *)mpVmm2UserMethods);
643	mpVmm2UserMethods = NULL;
644	}
645
646	if (mNvram)
647	{
648	delete mNvram;
649	unconst(mNvram) = NULL;
650	}
651
652	#ifdef VBOX_WITH_USB_VIDEO
653	if (mEmWebcam)
654	{
655	delete mEmWebcam;
656	unconst(mEmWebcam) = NULL;
657	}
658	#endif
659
660	#ifdef VBOX_WITH_USB_CARDREADER
661	if (mUsbCardReader)
662	{
663	delete mUsbCardReader;
664	unconst(mUsbCardReader) = NULL;
665	}
666	#endif
667
668	if (mAudioSniffer)
669	{
670	delete mAudioSniffer;
671	unconst(mAudioSniffer) = NULL;
672	}
673
674	// if the VM had a VMMDev with an HGCM thread, then remove that here
675	if (m_pVMMDev)
676	{
677	delete m_pVMMDev;
678	unconst(m_pVMMDev) = NULL;
679	}
680
681	if (mBusMgr)
682	{
683	mBusMgr->Release();
684	mBusMgr = NULL;
685	}
686
687	m_mapGlobalSharedFolders.clear();
688	m_mapMachineSharedFolders.clear();
689	m_mapSharedFolders.clear(); // console instances
690
691	mRemoteUSBDevices.clear();
692	mUSBDevices.clear();
693
694	if (mVRDEServerInfo)
695	{
696	mVRDEServerInfo->uninit();
697	unconst(mVRDEServerInfo).setNull();
698	}
699
700	if (mDebugger)
701	{
702	mDebugger->uninit();
703	unconst(mDebugger).setNull();
704	}
705
706	if (mDisplay)
707	{
708	mDisplay->uninit();
709	unconst(mDisplay).setNull();
710	}
711
712	if (mMouse)
713	{
714	mMouse->uninit();
715	unconst(mMouse).setNull();
716	}
717
718	if (mKeyboard)
719	{
720	mKeyboard->uninit();
721	unconst(mKeyboard).setNull();
722	}
723
724	if (mGuest)
725	{
726	mGuest->uninit();
727	unconst(mGuest).setNull();
728	}
729
730	if (mConsoleVRDPServer)
731	{
732	delete mConsoleVRDPServer;
733	unconst(mConsoleVRDPServer) = NULL;
734	}
735
736	unconst(mVRDEServer).setNull();
737
738	unconst(mControl).setNull();
739	unconst(mMachine).setNull();
740
741	// we don't perform uninit() as it's possible that some pending event refers to this source
742	unconst(mEventSource).setNull();
743
744	#ifdef CONSOLE_WITH_EVENT_CACHE
745	mCallbackData.clear();
746	#endif
747
748	LogFlowThisFuncLeave();
749	}
750
751	#ifdef VBOX_WITH_GUEST_PROPS
752
753	/**
754	* Handles guest properties on a VM reset.
755	*
756	* We must delete properties that are flagged TRANSRESET.
757	*
758	* @todo r=bird: Would be more efficient if we added a request to the HGCM
759	* service to do this instead of detouring thru VBoxSVC.
760	* (IMachine::SetGuestProperty ends up in VBoxSVC, which in turns calls
761	* back into the VM process and the HGCM service.)
762	*/
763	void Console::guestPropertiesHandleVMReset(void)
764	{
765	com::SafeArray<BSTR> arrNames;
766	com::SafeArray<BSTR> arrValues;
767	com::SafeArray<LONG64> arrTimestamps;
768	com::SafeArray<BSTR> arrFlags;
769	HRESULT hrc = enumerateGuestProperties(Bstr("*").raw(),
770	ComSafeArrayAsOutParam(arrNames),
771	ComSafeArrayAsOutParam(arrValues),
772	ComSafeArrayAsOutParam(arrTimestamps),
773	ComSafeArrayAsOutParam(arrFlags));
774	if (SUCCEEDED(hrc))
775	{
776	for (size_t i = 0; i < arrFlags.size(); i++)
777	{
778	/* Delete all properties which have the flag "TRANSRESET". */
779	if (Utf8Str(arrFlags[i]).contains("TRANSRESET", Utf8Str::CaseInsensitive))
780	{
781	hrc = mMachine->DeleteGuestProperty(arrNames[i]);
782	if (FAILED(hrc))
783	LogRel(("RESET: Could not delete transient property \"%ls\", rc=%Rhrc\n",
784	arrNames[i], hrc));
785	}
786	}
787	}
788	else
789	LogRel(("RESET: Unable to enumerate guest properties, rc=%Rhrc\n", hrc));
790	}
791
792	bool Console::guestPropertiesVRDPEnabled(void)
793	{
794	Bstr value;
795	HRESULT hrc = mMachine->GetExtraData(Bstr("VBoxInternal2/EnableGuestPropertiesVRDP").raw(),
796	value.asOutParam());
797	if ( hrc == S_OK
798	&& value == "1")
799	return true;
800	return false;
801	}
802
803	void Console::guestPropertiesVRDPUpdateLogon(uint32_t u32ClientId, const char pszUser, const char pszDomain)
804	{
805	if (!guestPropertiesVRDPEnabled())
806	return;
807
808	LogFlowFunc(("\n"));
809
810	char szPropNm[256];
811	Bstr bstrReadOnlyGuest(L"RDONLYGUEST");
812
813	RTStrPrintf(szPropNm, sizeof(szPropNm), "/VirtualBox/HostInfo/VRDP/Client/%u/Name", u32ClientId);
814	Bstr clientName;
815	mVRDEServerInfo->COMGETTER(ClientName)(clientName.asOutParam());
816
817	mMachine->SetGuestProperty(Bstr(szPropNm).raw(),
818	clientName.raw(),
819	bstrReadOnlyGuest.raw());
820
821	RTStrPrintf(szPropNm, sizeof(szPropNm), "/VirtualBox/HostInfo/VRDP/Client/%u/User", u32ClientId);
822	mMachine->SetGuestProperty(Bstr(szPropNm).raw(),
823	Bstr(pszUser).raw(),
824	bstrReadOnlyGuest.raw());
825
826	RTStrPrintf(szPropNm, sizeof(szPropNm), "/VirtualBox/HostInfo/VRDP/Client/%u/Domain", u32ClientId);
827	mMachine->SetGuestProperty(Bstr(szPropNm).raw(),
828	Bstr(pszDomain).raw(),
829	bstrReadOnlyGuest.raw());
830
831	char szClientId[64];
832	RTStrPrintf(szClientId, sizeof(szClientId), "%u", u32ClientId);
833	mMachine->SetGuestProperty(Bstr("/VirtualBox/HostInfo/VRDP/LastConnectedClient").raw(),
834	Bstr(szClientId).raw(),
835	bstrReadOnlyGuest.raw());
836
837	return;
838	}
839
840	void Console::guestPropertiesVRDPUpdateActiveClient(uint32_t u32ClientId)
841	{
842	if (!guestPropertiesVRDPEnabled())
843	return;
844
845	LogFlowFunc(("%d\n", u32ClientId));
846
847	Bstr bstrFlags(L"RDONLYGUEST,TRANSIENT");
848
849	char szClientId[64];
850	RTStrPrintf(szClientId, sizeof(szClientId), "%u", u32ClientId);
851
852	mMachine->SetGuestProperty(Bstr("/VirtualBox/HostInfo/VRDP/ActiveClient").raw(),
853	Bstr(szClientId).raw(),
854	bstrFlags.raw());
855
856	return;
857	}
858
859	void Console::guestPropertiesVRDPUpdateNameChange(uint32_t u32ClientId, const char *pszName)
860	{
861	if (!guestPropertiesVRDPEnabled())
862	return;
863
864	LogFlowFunc(("\n"));
865
866	char szPropNm[256];
867	Bstr bstrReadOnlyGuest(L"RDONLYGUEST");
868
869	RTStrPrintf(szPropNm, sizeof(szPropNm), "/VirtualBox/HostInfo/VRDP/Client/%u/Name", u32ClientId);
870	Bstr clientName(pszName);
871
872	mMachine->SetGuestProperty(Bstr(szPropNm).raw(),
873	clientName.raw(),
874	bstrReadOnlyGuest.raw());
875
876	}
877
878	void Console::guestPropertiesVRDPUpdateIPAddrChange(uint32_t u32ClientId, const char *pszIPAddr)
879	{
880	if (!guestPropertiesVRDPEnabled())
881	return;
882
883	LogFlowFunc(("\n"));
884
885	char szPropNm[256];
886	Bstr bstrReadOnlyGuest(L"RDONLYGUEST");
887
888	RTStrPrintf(szPropNm, sizeof(szPropNm), "/VirtualBox/HostInfo/VRDP/Client/%u/IPAddr", u32ClientId);
889	Bstr clientIPAddr(pszIPAddr);
890
891	mMachine->SetGuestProperty(Bstr(szPropNm).raw(),
892	clientIPAddr.raw(),
893	bstrReadOnlyGuest.raw());
894
895	}
896
897	void Console::guestPropertiesVRDPUpdateLocationChange(uint32_t u32ClientId, const char *pszLocation)
898	{
899	if (!guestPropertiesVRDPEnabled())
900	return;
901
902	LogFlowFunc(("\n"));
903
904	char szPropNm[256];
905	Bstr bstrReadOnlyGuest(L"RDONLYGUEST");
906
907	RTStrPrintf(szPropNm, sizeof(szPropNm), "/VirtualBox/HostInfo/VRDP/Client/%u/Location", u32ClientId);
908	Bstr clientLocation(pszLocation);
909
910	mMachine->SetGuestProperty(Bstr(szPropNm).raw(),
911	clientLocation.raw(),
912	bstrReadOnlyGuest.raw());
913
914	}
915
916	void Console::guestPropertiesVRDPUpdateOtherInfoChange(uint32_t u32ClientId, const char *pszOtherInfo)
917	{
918	if (!guestPropertiesVRDPEnabled())
919	return;
920
921	LogFlowFunc(("\n"));
922
923	char szPropNm[256];
924	Bstr bstrReadOnlyGuest(L"RDONLYGUEST");
925
926	RTStrPrintf(szPropNm, sizeof(szPropNm), "/VirtualBox/HostInfo/VRDP/Client/%u/OtherInfo", u32ClientId);
927	Bstr clientOtherInfo(pszOtherInfo);
928
929	mMachine->SetGuestProperty(Bstr(szPropNm).raw(),
930	clientOtherInfo.raw(),
931	bstrReadOnlyGuest.raw());
932
933	}
934
935	void Console::guestPropertiesVRDPUpdateClientAttach(uint32_t u32ClientId, bool fAttached)
936	{
937	if (!guestPropertiesVRDPEnabled())
938	return;
939
940	LogFlowFunc(("\n"));
941
942	Bstr bstrReadOnlyGuest(L"RDONLYGUEST");
943
944	char szPropNm[256];
945	RTStrPrintf(szPropNm, sizeof(szPropNm), "/VirtualBox/HostInfo/VRDP/Client/%u/Attach", u32ClientId);
946
947	Bstr bstrValue = fAttached? "1": "0";
948
949	mMachine->SetGuestProperty(Bstr(szPropNm).raw(),
950	bstrValue.raw(),
951	bstrReadOnlyGuest.raw());
952	}
953
954	void Console::guestPropertiesVRDPUpdateDisconnect(uint32_t u32ClientId)
955	{
956	if (!guestPropertiesVRDPEnabled())
957	return;
958
959	LogFlowFunc(("\n"));
960
961	Bstr bstrReadOnlyGuest(L"RDONLYGUEST");
962
963	char szPropNm[256];
964	RTStrPrintf(szPropNm, sizeof(szPropNm), "/VirtualBox/HostInfo/VRDP/Client/%u/Name", u32ClientId);
965	mMachine->SetGuestProperty(Bstr(szPropNm).raw(), NULL,
966	bstrReadOnlyGuest.raw());
967
968	RTStrPrintf(szPropNm, sizeof(szPropNm), "/VirtualBox/HostInfo/VRDP/Client/%u/User", u32ClientId);
969	mMachine->SetGuestProperty(Bstr(szPropNm).raw(), NULL,
970	bstrReadOnlyGuest.raw());
971
972	RTStrPrintf(szPropNm, sizeof(szPropNm), "/VirtualBox/HostInfo/VRDP/Client/%u/Domain", u32ClientId);
973	mMachine->SetGuestProperty(Bstr(szPropNm).raw(), NULL,
974	bstrReadOnlyGuest.raw());
975
976	RTStrPrintf(szPropNm, sizeof(szPropNm), "/VirtualBox/HostInfo/VRDP/Client/%u/Attach", u32ClientId);
977	mMachine->SetGuestProperty(Bstr(szPropNm).raw(), NULL,
978	bstrReadOnlyGuest.raw());
979
980	char szClientId[64];
981	RTStrPrintf(szClientId, sizeof(szClientId), "%d", u32ClientId);
982	mMachine->SetGuestProperty(Bstr("/VirtualBox/HostInfo/VRDP/LastDisconnectedClient").raw(),
983	Bstr(szClientId).raw(),
984	bstrReadOnlyGuest.raw());
985
986	return;
987	}
988
989	#endif /* VBOX_WITH_GUEST_PROPS */
990
991	#ifdef VBOX_WITH_EXTPACK
992	/**
993	* Used by VRDEServer and others to talke to the extension pack manager.
994	*
995	* @returns The extension pack manager.
996	*/
997	ExtPackManager *Console::getExtPackManager()
998	{
999	return mptrExtPackManager;
1000	}
1001	#endif
1002
1003
1004	int Console::VRDPClientLogon(uint32_t u32ClientId, const char pszUser, const char pszPassword, const char *pszDomain)
1005	{
1006	LogFlowFuncEnter();
1007	LogFlowFunc(("%d, %s, %s, %s\n", u32ClientId, pszUser, pszPassword, pszDomain));
1008
1009	AutoCaller autoCaller(this);
1010	if (!autoCaller.isOk())
1011	{
1012	/* Console has been already uninitialized, deny request */
1013	LogRel(("AUTH: Access denied (Console uninitialized).\n"));
1014	LogFlowFuncLeave();
1015	return VERR_ACCESS_DENIED;
1016	}
1017
1018	Bstr id;
1019	HRESULT hrc = mMachine->COMGETTER(Id)(id.asOutParam());
1020	Guid uuid = Guid(id);
1021
1022	AssertComRCReturn(hrc, VERR_ACCESS_DENIED);
1023
1024	AuthType_T authType = AuthType_Null;
1025	hrc = mVRDEServer->COMGETTER(AuthType)(&authType);
1026	AssertComRCReturn(hrc, VERR_ACCESS_DENIED);
1027
1028	ULONG authTimeout = 0;
1029	hrc = mVRDEServer->COMGETTER(AuthTimeout)(&authTimeout);
1030	AssertComRCReturn(hrc, VERR_ACCESS_DENIED);
1031
1032	AuthResult result = AuthResultAccessDenied;
1033	AuthGuestJudgement guestJudgement = AuthGuestNotAsked;
1034
1035	LogFlowFunc(("Auth type %d\n", authType));
1036
1037	LogRel(("AUTH: User: [%s]. Domain: [%s]. Authentication type: [%s]\n",
1038	pszUser, pszDomain,
1039	authType == AuthType_Null?
1040	"Null":
1041	(authType == AuthType_External?
1042	"External":
1043	(authType == AuthType_Guest?
1044	"Guest":
1045	"INVALID"
1046	)
1047	)
1048	));
1049
1050	switch (authType)
1051	{
1052	case AuthType_Null:
1053	{
1054	result = AuthResultAccessGranted;
1055	break;
1056	}
1057
1058	case AuthType_External:
1059	{
1060	/* Call the external library. */
1061	result = mConsoleVRDPServer->Authenticate(uuid, guestJudgement, pszUser, pszPassword, pszDomain, u32ClientId);
1062
1063	if (result != AuthResultDelegateToGuest)
1064	{
1065	break;
1066	}
1067
1068	LogRel(("AUTH: Delegated to guest.\n"));
1069
1070	LogFlowFunc(("External auth asked for guest judgement\n"));
1071	} /* pass through */
1072
1073	case AuthType_Guest:
1074	{
1075	guestJudgement = AuthGuestNotReacted;
1076
1077	// @todo r=dj locking required here for m_pVMMDev?
1078	PPDMIVMMDEVPORT pDevPort;
1079	if ( (m_pVMMDev)
1080	&& ((pDevPort = m_pVMMDev->getVMMDevPort()))
1081	)
1082	{
1083	/* Issue the request to guest. Assume that the call does not require EMT. It should not. */
1084
1085	/* Ask the guest to judge these credentials. */
1086	uint32_t u32GuestFlags = VMMDEV_SETCREDENTIALS_JUDGE;
1087
1088	int rc = pDevPort->pfnSetCredentials(pDevPort, pszUser, pszPassword, pszDomain, u32GuestFlags);
1089
1090	if (RT_SUCCESS(rc))
1091	{
1092	/* Wait for guest. */
1093	rc = m_pVMMDev->WaitCredentialsJudgement(authTimeout, &u32GuestFlags);
1094
1095	if (RT_SUCCESS(rc))
1096	{
1097	switch (u32GuestFlags & (VMMDEV_CREDENTIALS_JUDGE_OK \| VMMDEV_CREDENTIALS_JUDGE_DENY \| VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT))
1098	{
1099	case VMMDEV_CREDENTIALS_JUDGE_DENY: guestJudgement = AuthGuestAccessDenied; break;
1100	case VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT: guestJudgement = AuthGuestNoJudgement; break;
1101	case VMMDEV_CREDENTIALS_JUDGE_OK: guestJudgement = AuthGuestAccessGranted; break;
1102	default:
1103	LogFlowFunc(("Invalid guest flags %08X!!!\n", u32GuestFlags)); break;
1104	}
1105	}
1106	else
1107	{
1108	LogFlowFunc(("Wait for credentials judgement rc = %Rrc!!!\n", rc));
1109	}
1110
1111	LogFlowFunc(("Guest judgement %d\n", guestJudgement));
1112	}
1113	else
1114	{
1115	LogFlowFunc(("Could not set credentials rc = %Rrc!!!\n", rc));
1116	}
1117	}
1118
1119	if (authType == AuthType_External)
1120	{
1121	LogRel(("AUTH: Guest judgement %d.\n", guestJudgement));
1122	LogFlowFunc(("External auth called again with guest judgement = %d\n", guestJudgement));
1123	result = mConsoleVRDPServer->Authenticate(uuid, guestJudgement, pszUser, pszPassword, pszDomain, u32ClientId);
1124	}
1125	else
1126	{
1127	switch (guestJudgement)
1128	{
1129	case AuthGuestAccessGranted:
1130	result = AuthResultAccessGranted;
1131	break;
1132	default:
1133	result = AuthResultAccessDenied;
1134	break;
1135	}
1136	}
1137	} break;
1138
1139	default:
1140	AssertFailed();
1141	}
1142
1143	LogFlowFunc(("Result = %d\n", result));
1144	LogFlowFuncLeave();
1145
1146	if (result != AuthResultAccessGranted)
1147	{
1148	/* Reject. */
1149	LogRel(("AUTH: Access denied.\n"));
1150	return VERR_ACCESS_DENIED;
1151	}
1152
1153	LogRel(("AUTH: Access granted.\n"));
1154
1155	/* Multiconnection check must be made after authentication, so bad clients would not interfere with a good one. */
1156	BOOL allowMultiConnection = FALSE;
1157	hrc = mVRDEServer->COMGETTER(AllowMultiConnection)(&allowMultiConnection);
1158	AssertComRCReturn(hrc, VERR_ACCESS_DENIED);
1159
1160	BOOL reuseSingleConnection = FALSE;
1161	hrc = mVRDEServer->COMGETTER(ReuseSingleConnection)(&reuseSingleConnection);
1162	AssertComRCReturn(hrc, VERR_ACCESS_DENIED);
1163
1164	LogFlowFunc(("allowMultiConnection %d, reuseSingleConnection = %d, mcVRDPClients = %d, mu32SingleRDPClientId = %d\n", allowMultiConnection, reuseSingleConnection, mcVRDPClients, mu32SingleRDPClientId));
1165
1166	if (allowMultiConnection == FALSE)
1167	{
1168	/* Note: the 'mcVRDPClients' variable is incremented in ClientConnect callback, which is called when the client
1169	* is successfully connected, that is after the ClientLogon callback. Therefore the mcVRDPClients
1170	* value is 0 for first client.
1171	*/
1172	if (mcVRDPClients != 0)
1173	{
1174	Assert(mcVRDPClients == 1);
1175	/* There is a client already.
1176	* If required drop the existing client connection and let the connecting one in.
1177	*/
1178	if (reuseSingleConnection)
1179	{
1180	LogRel(("AUTH: Multiple connections are not enabled. Disconnecting existing client.\n"));
1181	mConsoleVRDPServer->DisconnectClient(mu32SingleRDPClientId, false);
1182	}
1183	else
1184	{
1185	/* Reject. */
1186	LogRel(("AUTH: Multiple connections are not enabled. Access denied.\n"));
1187	return VERR_ACCESS_DENIED;
1188	}
1189	}
1190
1191	/* Save the connected client id. From now on it will be necessary to disconnect this one. */
1192	mu32SingleRDPClientId = u32ClientId;
1193	}
1194
1195	#ifdef VBOX_WITH_GUEST_PROPS
1196	guestPropertiesVRDPUpdateLogon(u32ClientId, pszUser, pszDomain);
1197	#endif /* VBOX_WITH_GUEST_PROPS */
1198
1199	/* Check if the successfully verified credentials are to be sent to the guest. */
1200	BOOL fProvideGuestCredentials = FALSE;
1201
1202	Bstr value;
1203	hrc = mMachine->GetExtraData(Bstr("VRDP/ProvideGuestCredentials").raw(),
1204	value.asOutParam());
1205	if (SUCCEEDED(hrc) && value == "1")
1206	{
1207	/* Provide credentials only if there are no logged in users. */
1208	Bstr noLoggedInUsersValue;
1209	LONG64 ul64Timestamp = 0;
1210	Bstr flags;
1211
1212	hrc = getGuestProperty(Bstr("/VirtualBox/GuestInfo/OS/NoLoggedInUsers").raw(),
1213	noLoggedInUsersValue.asOutParam(), &ul64Timestamp, flags.asOutParam());
1214
1215	if (SUCCEEDED(hrc) && noLoggedInUsersValue != Bstr("false"))
1216	{
1217	/* And only if there are no connected clients. */
1218	if (ASMAtomicCmpXchgBool(&mcGuestCredentialsProvided, true, false))
1219	{
1220	fProvideGuestCredentials = TRUE;
1221	}
1222	}
1223	}
1224
1225	// @todo r=dj locking required here for m_pVMMDev?
1226	if ( fProvideGuestCredentials
1227	&& m_pVMMDev)
1228	{
1229	uint32_t u32GuestFlags = VMMDEV_SETCREDENTIALS_GUESTLOGON;
1230
1231	int rc = m_pVMMDev->getVMMDevPort()->pfnSetCredentials(m_pVMMDev->getVMMDevPort(),
1232	pszUser, pszPassword, pszDomain, u32GuestFlags);
1233	AssertRC(rc);
1234	}
1235
1236	return VINF_SUCCESS;
1237	}
1238
1239	void Console::VRDPClientStatusChange(uint32_t u32ClientId, const char *pszStatus)
1240	{
1241	LogFlowFuncEnter();
1242
1243	AutoCaller autoCaller(this);
1244	AssertComRCReturnVoid(autoCaller.rc());
1245
1246	LogFlowFunc(("%s\n", pszStatus));
1247
1248	#ifdef VBOX_WITH_GUEST_PROPS
1249	/* Parse the status string. */
1250	if (RTStrICmp(pszStatus, "ATTACH") == 0)
1251	{
1252	guestPropertiesVRDPUpdateClientAttach(u32ClientId, true);
1253	}
1254	else if (RTStrICmp(pszStatus, "DETACH") == 0)
1255	{
1256	guestPropertiesVRDPUpdateClientAttach(u32ClientId, false);
1257	}
1258	else if (RTStrNICmp(pszStatus, "NAME=", strlen("NAME=")) == 0)
1259	{
1260	guestPropertiesVRDPUpdateNameChange(u32ClientId, pszStatus + strlen("NAME="));
1261	}
1262	else if (RTStrNICmp(pszStatus, "CIPA=", strlen("CIPA=")) == 0)
1263	{
1264	guestPropertiesVRDPUpdateIPAddrChange(u32ClientId, pszStatus + strlen("CIPA="));
1265	}
1266	else if (RTStrNICmp(pszStatus, "CLOCATION=", strlen("CLOCATION=")) == 0)
1267	{
1268	guestPropertiesVRDPUpdateLocationChange(u32ClientId, pszStatus + strlen("CLOCATION="));
1269	}
1270	else if (RTStrNICmp(pszStatus, "COINFO=", strlen("COINFO=")) == 0)
1271	{
1272	guestPropertiesVRDPUpdateOtherInfoChange(u32ClientId, pszStatus + strlen("COINFO="));
1273	}
1274	#endif
1275
1276	LogFlowFuncLeave();
1277	}
1278
1279	void Console::VRDPClientConnect(uint32_t u32ClientId)
1280	{
1281	LogFlowFuncEnter();
1282
1283	AutoCaller autoCaller(this);
1284	AssertComRCReturnVoid(autoCaller.rc());
1285
1286	uint32_t u32Clients = ASMAtomicIncU32(&mcVRDPClients);
1287	VMMDev *pDev;
1288	PPDMIVMMDEVPORT pPort;
1289	if ( (u32Clients == 1)
1290	&& ((pDev = getVMMDev()))
1291	&& ((pPort = pDev->getVMMDevPort()))
1292	)
1293	{
1294	pPort->pfnVRDPChange(pPort,
1295	true,
1296	VRDP_EXPERIENCE_LEVEL_FULL); // @todo configurable
1297	}
1298
1299	NOREF(u32ClientId);
1300	mDisplay->VideoAccelVRDP(true);
1301
1302	#ifdef VBOX_WITH_GUEST_PROPS
1303	guestPropertiesVRDPUpdateActiveClient(u32ClientId);
1304	#endif /* VBOX_WITH_GUEST_PROPS */
1305
1306	LogFlowFuncLeave();
1307	return;
1308	}
1309
1310	void Console::VRDPClientDisconnect(uint32_t u32ClientId,
1311	uint32_t fu32Intercepted)
1312	{
1313	LogFlowFuncEnter();
1314
1315	AutoCaller autoCaller(this);
1316	AssertComRCReturnVoid(autoCaller.rc());
1317
1318	AssertReturnVoid(mConsoleVRDPServer);
1319
1320	uint32_t u32Clients = ASMAtomicDecU32(&mcVRDPClients);
1321	VMMDev *pDev;
1322	PPDMIVMMDEVPORT pPort;
1323
1324	if ( (u32Clients == 0)
1325	&& ((pDev = getVMMDev()))
1326	&& ((pPort = pDev->getVMMDevPort()))
1327	)
1328	{
1329	pPort->pfnVRDPChange(pPort,
1330	false,
1331	0);
1332	}
1333
1334	mDisplay->VideoAccelVRDP(false);
1335
1336	if (fu32Intercepted & VRDE_CLIENT_INTERCEPT_USB)
1337	{
1338	mConsoleVRDPServer->USBBackendDelete(u32ClientId);
1339	}
1340
1341	if (fu32Intercepted & VRDE_CLIENT_INTERCEPT_CLIPBOARD)
1342	{
1343	mConsoleVRDPServer->ClipboardDelete(u32ClientId);
1344	}
1345
1346	if (fu32Intercepted & VRDE_CLIENT_INTERCEPT_AUDIO)
1347	{
1348	mcAudioRefs--;
1349
1350	if (mcAudioRefs <= 0)
1351	{
1352	if (mAudioSniffer)
1353	{
1354	PPDMIAUDIOSNIFFERPORT port = mAudioSniffer->getAudioSnifferPort();
1355	if (port)
1356	{
1357	port->pfnSetup(port, false, false);
1358	}
1359	}
1360	}
1361	}
1362
1363	Bstr uuid;
1364	HRESULT hrc = mMachine->COMGETTER(Id)(uuid.asOutParam());
1365	AssertComRC(hrc);
1366
1367	AuthType_T authType = AuthType_Null;
1368	hrc = mVRDEServer->COMGETTER(AuthType)(&authType);
1369	AssertComRC(hrc);
1370
1371	if (authType == AuthType_External)
1372	mConsoleVRDPServer->AuthDisconnect(uuid, u32ClientId);
1373
1374	#ifdef VBOX_WITH_GUEST_PROPS
1375	guestPropertiesVRDPUpdateDisconnect(u32ClientId);
1376	if (u32Clients == 0)
1377	guestPropertiesVRDPUpdateActiveClient(0);
1378	#endif /* VBOX_WITH_GUEST_PROPS */
1379
1380	if (u32Clients == 0)
1381	mcGuestCredentialsProvided = false;
1382
1383	LogFlowFuncLeave();
1384	return;
1385	}
1386
1387	void Console::VRDPInterceptAudio(uint32_t u32ClientId)
1388	{
1389	LogFlowFuncEnter();
1390
1391	AutoCaller autoCaller(this);
1392	AssertComRCReturnVoid(autoCaller.rc());
1393
1394	LogFlowFunc(("mAudioSniffer %p, u32ClientId %d.\n",
1395	mAudioSniffer, u32ClientId));
1396	NOREF(u32ClientId);
1397
1398	++mcAudioRefs;
1399
1400	if (mcAudioRefs == 1)
1401	{
1402	if (mAudioSniffer)
1403	{
1404	PPDMIAUDIOSNIFFERPORT port = mAudioSniffer->getAudioSnifferPort();
1405	if (port)
1406	{
1407	port->pfnSetup(port, true, true);
1408	}
1409	}
1410	}
1411
1412	LogFlowFuncLeave();
1413	return;
1414	}
1415
1416	void Console::VRDPInterceptUSB(uint32_t u32ClientId, void **ppvIntercept)
1417	{
1418	LogFlowFuncEnter();
1419
1420	AutoCaller autoCaller(this);
1421	AssertComRCReturnVoid(autoCaller.rc());
1422
1423	AssertReturnVoid(mConsoleVRDPServer);
1424
1425	mConsoleVRDPServer->USBBackendCreate(u32ClientId, ppvIntercept);
1426
1427	LogFlowFuncLeave();
1428	return;
1429	}
1430
1431	void Console::VRDPInterceptClipboard(uint32_t u32ClientId)
1432	{
1433	LogFlowFuncEnter();
1434
1435	AutoCaller autoCaller(this);
1436	AssertComRCReturnVoid(autoCaller.rc());
1437
1438	AssertReturnVoid(mConsoleVRDPServer);
1439
1440	mConsoleVRDPServer->ClipboardCreate(u32ClientId);
1441
1442	LogFlowFuncLeave();
1443	return;
1444	}
1445
1446
1447	//static
1448	const char *Console::sSSMConsoleUnit = "ConsoleData";
1449	//static
1450	uint32_t Console::sSSMConsoleVer = 0x00010001;
1451
1452	inline static const char *networkAdapterTypeToName(NetworkAdapterType_T adapterType)
1453	{
1454	switch (adapterType)
1455	{
1456	case NetworkAdapterType_Am79C970A:
1457	case NetworkAdapterType_Am79C973:
1458	return "pcnet";
1459	#ifdef VBOX_WITH_E1000
1460	case NetworkAdapterType_I82540EM:
1461	case NetworkAdapterType_I82543GC:
1462	case NetworkAdapterType_I82545EM:
1463	return "e1000";
1464	#endif
1465	#ifdef VBOX_WITH_VIRTIO
1466	case NetworkAdapterType_Virtio:
1467	return "virtio-net";
1468	#endif
1469	default:
1470	AssertFailed();
1471	return "unknown";
1472	}
1473	return NULL;
1474	}
1475
1476	/**
1477	* Loads various console data stored in the saved state file.
1478	* This method does validation of the state file and returns an error info
1479	* when appropriate.
1480	*
1481	* The method does nothing if the machine is not in the Saved file or if
1482	* console data from it has already been loaded.
1483	*
1484	* @note The caller must lock this object for writing.
1485	*/
1486	HRESULT Console::loadDataFromSavedState()
1487	{
1488	if (mMachineState != MachineState_Saved \|\| mSavedStateDataLoaded)
1489	return S_OK;
1490
1491	Bstr savedStateFile;
1492	HRESULT rc = mMachine->COMGETTER(StateFilePath)(savedStateFile.asOutParam());
1493	if (FAILED(rc))
1494	return rc;
1495
1496	PSSMHANDLE ssm;
1497	int vrc = SSMR3Open(Utf8Str(savedStateFile).c_str(), 0, &ssm);
1498	if (RT_SUCCESS(vrc))
1499	{
1500	uint32_t version = 0;
1501	vrc = SSMR3Seek(ssm, sSSMConsoleUnit, 0 /* iInstance */, &version);
1502	if (SSM_VERSION_MAJOR(version) == SSM_VERSION_MAJOR(sSSMConsoleVer))
1503	{
1504	if (RT_SUCCESS(vrc))
1505	vrc = loadStateFileExecInternal(ssm, version);
1506	else if (vrc == VERR_SSM_UNIT_NOT_FOUND)
1507	vrc = VINF_SUCCESS;
1508	}
1509	else
1510	vrc = VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
1511
1512	SSMR3Close(ssm);
1513	}
1514
1515	if (RT_FAILURE(vrc))
1516	rc = setError(VBOX_E_FILE_ERROR,
1517	tr("The saved state file '%ls' is invalid (%Rrc). Delete the saved state and try again"),
1518	savedStateFile.raw(), vrc);
1519
1520	mSavedStateDataLoaded = true;
1521
1522	return rc;
1523	}
1524
1525	/**
1526	* Callback handler to save various console data to the state file,
1527	* called when the user saves the VM state.
1528	*
1529	* @param pvUser pointer to Console
1530	*
1531	* @note Locks the Console object for reading.
1532	*/
1533	//static
1534	DECLCALLBACK(void)
1535	Console::saveStateFileExec(PSSMHANDLE pSSM, void *pvUser)
1536	{
1537	LogFlowFunc(("\n"));
1538
1539	Console that = static_cast<Console >(pvUser);
1540	AssertReturnVoid(that);
1541
1542	AutoCaller autoCaller(that);
1543	AssertComRCReturnVoid(autoCaller.rc());
1544
1545	AutoReadLock alock(that COMMA_LOCKVAL_SRC_POS);
1546
1547	int vrc = SSMR3PutU32(pSSM, (uint32_t)that->m_mapSharedFolders.size());
1548	AssertRC(vrc);
1549
1550	for (SharedFolderMap::const_iterator it = that->m_mapSharedFolders.begin();
1551	it != that->m_mapSharedFolders.end();
1552	++it)
1553	{
1554	SharedFolder pSF = (it).second;
1555	AutoCaller sfCaller(pSF);
1556	AutoReadLock sfLock(pSF COMMA_LOCKVAL_SRC_POS);
1557
1558	Utf8Str name = pSF->getName();
1559	vrc = SSMR3PutU32(pSSM, (uint32_t)name.length() + 1 /* term. 0 */);
1560	AssertRC(vrc);
1561	vrc = SSMR3PutStrZ(pSSM, name.c_str());
1562	AssertRC(vrc);
1563
1564	Utf8Str hostPath = pSF->getHostPath();
1565	vrc = SSMR3PutU32(pSSM, (uint32_t)hostPath.length() + 1 /* term. 0 */);
1566	AssertRC(vrc);
1567	vrc = SSMR3PutStrZ(pSSM, hostPath.c_str());
1568	AssertRC(vrc);
1569
1570	vrc = SSMR3PutBool(pSSM, !!pSF->isWritable());
1571	AssertRC(vrc);
1572
1573	vrc = SSMR3PutBool(pSSM, !!pSF->isAutoMounted());
1574	AssertRC(vrc);
1575	}
1576
1577	return;
1578	}
1579
1580	/**
1581	* Callback handler to load various console data from the state file.
1582	* Called when the VM is being restored from the saved state.
1583	*
1584	* @param pvUser pointer to Console
1585	* @param uVersion Console unit version.
1586	* Should match sSSMConsoleVer.
1587	* @param uPass The data pass.
1588	*
1589	* @note Should locks the Console object for writing, if necessary.
1590	*/
1591	//static
1592	DECLCALLBACK(int)
1593	Console::loadStateFileExec(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass)
1594	{
1595	LogFlowFunc(("\n"));
1596
1597	if (SSM_VERSION_MAJOR_CHANGED(uVersion, sSSMConsoleVer))
1598	return VERR_VERSION_MISMATCH;
1599	Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
1600
1601	Console that = static_cast<Console >(pvUser);
1602	AssertReturn(that, VERR_INVALID_PARAMETER);
1603
1604	/* Currently, nothing to do when we've been called from VMR3Load. /
1605	return SSMR3SkipToEndOfUnit(pSSM);
1606	}
1607
1608	/**
1609	* Method to load various console data from the state file.
1610	* Called from #loadDataFromSavedState.
1611	*
1612	* @param pvUser pointer to Console
1613	* @param u32Version Console unit version.
1614	* Should match sSSMConsoleVer.
1615	*
1616	* @note Locks the Console object for writing.
1617	*/
1618	int
1619	Console::loadStateFileExecInternal(PSSMHANDLE pSSM, uint32_t u32Version)
1620	{
1621	AutoCaller autoCaller(this);
1622	AssertComRCReturn(autoCaller.rc(), VERR_ACCESS_DENIED);
1623
1624	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1625
1626	AssertReturn(m_mapSharedFolders.size() == 0, VERR_INTERNAL_ERROR);
1627
1628	uint32_t size = 0;
1629	int vrc = SSMR3GetU32(pSSM, &size);
1630	AssertRCReturn(vrc, vrc);
1631
1632	for (uint32_t i = 0; i < size; ++i)
1633	{
1634	Utf8Str strName;
1635	Utf8Str strHostPath;
1636	bool writable = true;
1637	bool autoMount = false;
1638
1639	uint32_t szBuf = 0;
1640	char *buf = NULL;
1641
1642	vrc = SSMR3GetU32(pSSM, &szBuf);
1643	AssertRCReturn(vrc, vrc);
1644	buf = new char[szBuf];
1645	vrc = SSMR3GetStrZ(pSSM, buf, szBuf);
1646	AssertRC(vrc);
1647	strName = buf;
1648	delete[] buf;
1649
1650	vrc = SSMR3GetU32(pSSM, &szBuf);
1651	AssertRCReturn(vrc, vrc);
1652	buf = new char[szBuf];
1653	vrc = SSMR3GetStrZ(pSSM, buf, szBuf);
1654	AssertRC(vrc);
1655	strHostPath = buf;
1656	delete[] buf;
1657
1658	if (u32Version > 0x00010000)
1659	SSMR3GetBool(pSSM, &writable);
1660
1661	if (u32Version > 0x00010000) // ???
1662	SSMR3GetBool(pSSM, &autoMount);
1663
1664	ComObjPtr<SharedFolder> pSharedFolder;
1665	pSharedFolder.createObject();
1666	HRESULT rc = pSharedFolder->init(this,
1667	strName,
1668	strHostPath,
1669	writable,
1670	autoMount,
1671	false /* fFailOnError */);
1672	AssertComRCReturn(rc, VERR_INTERNAL_ERROR);
1673
1674	m_mapSharedFolders.insert(std::make_pair(strName, pSharedFolder));
1675	}
1676
1677	return VINF_SUCCESS;
1678	}
1679
1680	#ifdef VBOX_WITH_GUEST_PROPS
1681
1682	// static
1683	DECLCALLBACK(int) Console::doGuestPropNotification(void *pvExtension,
1684	uint32_t u32Function,
1685	void *pvParms,
1686	uint32_t cbParms)
1687	{
1688	using namespace guestProp;
1689
1690	Assert(u32Function == 0); NOREF(u32Function);
1691
1692	/*
1693	* No locking, as this is purely a notification which does not make any
1694	* changes to the object state.
1695	*/
1696	PHOSTCALLBACKDATA pCBData = reinterpret_cast<PHOSTCALLBACKDATA>(pvParms);
1697	AssertReturn(sizeof(HOSTCALLBACKDATA) == cbParms, VERR_INVALID_PARAMETER);
1698	AssertReturn(HOSTCALLBACKMAGIC == pCBData->u32Magic, VERR_INVALID_PARAMETER);
1699	LogFlow(("Console::doGuestPropNotification: pCBData={.pcszName=%s, .pcszValue=%s, .pcszFlags=%s}\n",
1700	pCBData->pcszName, pCBData->pcszValue, pCBData->pcszFlags));
1701
1702	int rc;
1703	Bstr name(pCBData->pcszName);
1704	Bstr value(pCBData->pcszValue);
1705	Bstr flags(pCBData->pcszFlags);
1706	ComObjPtr<Console> pConsole = reinterpret_cast<Console *>(pvExtension);
1707	HRESULT hrc = pConsole->mControl->PushGuestProperty(name.raw(),
1708	value.raw(),
1709	pCBData->u64Timestamp,
1710	flags.raw());
1711	if (SUCCEEDED(hrc))
1712	rc = VINF_SUCCESS;
1713	else
1714	{
1715	LogFlow(("Console::doGuestPropNotification: hrc=%Rhrc pCBData={.pcszName=%s, .pcszValue=%s, .pcszFlags=%s}\n",
1716	hrc, pCBData->pcszName, pCBData->pcszValue, pCBData->pcszFlags));
1717	rc = Global::vboxStatusCodeFromCOM(hrc);
1718	}
1719	return rc;
1720	}
1721
1722	HRESULT Console::doEnumerateGuestProperties(CBSTR aPatterns,
1723	ComSafeArrayOut(BSTR, aNames),
1724	ComSafeArrayOut(BSTR, aValues),
1725	ComSafeArrayOut(LONG64, aTimestamps),
1726	ComSafeArrayOut(BSTR, aFlags))
1727	{
1728	AssertReturn(m_pVMMDev, E_FAIL);
1729
1730	using namespace guestProp;
1731
1732	VBOXHGCMSVCPARM parm[3];
1733
1734	Utf8Str utf8Patterns(aPatterns);
1735	parm[0].type = VBOX_HGCM_SVC_PARM_PTR;
1736	parm[0].u.pointer.addr = (void*)utf8Patterns.c_str();
1737	parm[0].u.pointer.size = (uint32_t)utf8Patterns.length() + 1;
1738
1739	/*
1740	* Now things get slightly complicated. Due to a race with the guest adding
1741	* properties, there is no good way to know how much to enlarge a buffer for
1742	* the service to enumerate into. We choose a decent starting size and loop a
1743	* few times, each time retrying with the size suggested by the service plus
1744	* one Kb.
1745	*/
1746	size_t cchBuf = 4096;
1747	Utf8Str Utf8Buf;
1748	int vrc = VERR_BUFFER_OVERFLOW;
1749	for (unsigned i = 0; i < 10 && (VERR_BUFFER_OVERFLOW == vrc); ++i)
1750	{
1751	try
1752	{
1753	Utf8Buf.reserve(cchBuf + 1024);
1754	}
1755	catch(...)
1756	{
1757	return E_OUTOFMEMORY;
1758	}
1759	parm[1].type = VBOX_HGCM_SVC_PARM_PTR;
1760	parm[1].u.pointer.addr = Utf8Buf.mutableRaw();
1761	parm[1].u.pointer.size = (uint32_t)cchBuf + 1024;
1762	vrc = m_pVMMDev->hgcmHostCall("VBoxGuestPropSvc", ENUM_PROPS_HOST, 3,
1763	&parm[0]);
1764	Utf8Buf.jolt();
1765	if (parm[2].type != VBOX_HGCM_SVC_PARM_32BIT)
1766	return setError(E_FAIL, tr("Internal application error"));
1767	cchBuf = parm[2].u.uint32;
1768	}
1769	if (VERR_BUFFER_OVERFLOW == vrc)
1770	return setError(E_UNEXPECTED,
1771	tr("Temporary failure due to guest activity, please retry"));
1772
1773	/*
1774	* Finally we have to unpack the data returned by the service into the safe
1775	* arrays supplied by the caller. We start by counting the number of entries.
1776	*/
1777	const char *pszBuf
1778	= reinterpret_cast<const char *>(parm[1].u.pointer.addr);
1779	unsigned cEntries = 0;
1780	/* The list is terminated by a zero-length string at the end of a set
1781	* of four strings. */
1782	for (size_t i = 0; strlen(pszBuf + i) != 0; )
1783	{
1784	/* We are counting sets of four strings. */
1785	for (unsigned j = 0; j < 4; ++j)
1786	i += strlen(pszBuf + i) + 1;
1787	++cEntries;
1788	}
1789
1790	/*
1791	* And now we create the COM safe arrays and fill them in.
1792	*/
1793	com::SafeArray<BSTR> names(cEntries);
1794	com::SafeArray<BSTR> values(cEntries);
1795	com::SafeArray<LONG64> timestamps(cEntries);
1796	com::SafeArray<BSTR> flags(cEntries);
1797	size_t iBuf = 0;
1798	/* Rely on the service to have formated the data correctly. */
1799	for (unsigned i = 0; i < cEntries; ++i)
1800	{
1801	size_t cchName = strlen(pszBuf + iBuf);
1802	Bstr(pszBuf + iBuf).detachTo(&names[i]);
1803	iBuf += cchName + 1;
1804	size_t cchValue = strlen(pszBuf + iBuf);
1805	Bstr(pszBuf + iBuf).detachTo(&values[i]);
1806	iBuf += cchValue + 1;
1807	size_t cchTimestamp = strlen(pszBuf + iBuf);
1808	timestamps[i] = RTStrToUInt64(pszBuf + iBuf);
1809	iBuf += cchTimestamp + 1;
1810	size_t cchFlags = strlen(pszBuf + iBuf);
1811	Bstr(pszBuf + iBuf).detachTo(&flags[i]);
1812	iBuf += cchFlags + 1;
1813	}
1814	names.detachTo(ComSafeArrayOutArg(aNames));
1815	values.detachTo(ComSafeArrayOutArg(aValues));
1816	timestamps.detachTo(ComSafeArrayOutArg(aTimestamps));
1817	flags.detachTo(ComSafeArrayOutArg(aFlags));
1818	return S_OK;
1819	}
1820
1821	#endif /* VBOX_WITH_GUEST_PROPS */
1822
1823
1824	// IConsole properties
1825	/////////////////////////////////////////////////////////////////////////////
1826
1827	STDMETHODIMP Console::COMGETTER(Machine)(IMachine **aMachine)
1828	{
1829	CheckComArgOutPointerValid(aMachine);
1830
1831	AutoCaller autoCaller(this);
1832	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1833
1834	/* mMachine is constant during life time, no need to lock */
1835	mMachine.queryInterfaceTo(aMachine);
1836
1837	/* callers expect to get a valid reference, better fail than crash them */
1838	if (mMachine.isNull())
1839	return E_FAIL;
1840
1841	return S_OK;
1842	}
1843
1844	STDMETHODIMP Console::COMGETTER(State)(MachineState_T *aMachineState)
1845	{
1846	CheckComArgOutPointerValid(aMachineState);
1847
1848	AutoCaller autoCaller(this);
1849	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1850
1851	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1852
1853	/* we return our local state (since it's always the same as on the server) */
1854	*aMachineState = mMachineState;
1855
1856	return S_OK;
1857	}
1858
1859	STDMETHODIMP Console::COMGETTER(Guest)(IGuest **aGuest)
1860	{
1861	CheckComArgOutPointerValid(aGuest);
1862
1863	AutoCaller autoCaller(this);
1864	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1865
1866	/* mGuest is constant during life time, no need to lock */
1867	mGuest.queryInterfaceTo(aGuest);
1868
1869	return S_OK;
1870	}
1871
1872	STDMETHODIMP Console::COMGETTER(Keyboard)(IKeyboard **aKeyboard)
1873	{
1874	CheckComArgOutPointerValid(aKeyboard);
1875
1876	AutoCaller autoCaller(this);
1877	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1878
1879	/* mKeyboard is constant during life time, no need to lock */
1880	mKeyboard.queryInterfaceTo(aKeyboard);
1881
1882	return S_OK;
1883	}
1884
1885	STDMETHODIMP Console::COMGETTER(Mouse)(IMouse **aMouse)
1886	{
1887	CheckComArgOutPointerValid(aMouse);
1888
1889	AutoCaller autoCaller(this);
1890	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1891
1892	/* mMouse is constant during life time, no need to lock */
1893	mMouse.queryInterfaceTo(aMouse);
1894
1895	return S_OK;
1896	}
1897
1898	STDMETHODIMP Console::COMGETTER(Display)(IDisplay **aDisplay)
1899	{
1900	CheckComArgOutPointerValid(aDisplay);
1901
1902	AutoCaller autoCaller(this);
1903	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1904
1905	/* mDisplay is constant during life time, no need to lock */
1906	mDisplay.queryInterfaceTo(aDisplay);
1907
1908	return S_OK;
1909	}
1910
1911	STDMETHODIMP Console::COMGETTER(Debugger)(IMachineDebugger **aDebugger)
1912	{
1913	CheckComArgOutPointerValid(aDebugger);
1914
1915	AutoCaller autoCaller(this);
1916	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1917
1918	/* we need a write lock because of the lazy mDebugger initialization*/
1919	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1920
1921	/* check if we have to create the debugger object */
1922	if (!mDebugger)
1923	{
1924	unconst(mDebugger).createObject();
1925	mDebugger->init(this);
1926	}
1927
1928	mDebugger.queryInterfaceTo(aDebugger);
1929
1930	return S_OK;
1931	}
1932
1933	STDMETHODIMP Console::COMGETTER(USBDevices)(ComSafeArrayOut(IUSBDevice *, aUSBDevices))
1934	{
1935	CheckComArgOutSafeArrayPointerValid(aUSBDevices);
1936
1937	AutoCaller autoCaller(this);
1938	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1939
1940	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1941
1942	SafeIfaceArray<IUSBDevice> collection(mUSBDevices);
1943	collection.detachTo(ComSafeArrayOutArg(aUSBDevices));
1944
1945	return S_OK;
1946	}
1947
1948	STDMETHODIMP Console::COMGETTER(RemoteUSBDevices)(ComSafeArrayOut(IHostUSBDevice *, aRemoteUSBDevices))
1949	{
1950	CheckComArgOutSafeArrayPointerValid(aRemoteUSBDevices);
1951
1952	AutoCaller autoCaller(this);
1953	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1954
1955	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1956
1957	SafeIfaceArray<IHostUSBDevice> collection(mRemoteUSBDevices);
1958	collection.detachTo(ComSafeArrayOutArg(aRemoteUSBDevices));
1959
1960	return S_OK;
1961	}
1962
1963	STDMETHODIMP Console::COMGETTER(VRDEServerInfo)(IVRDEServerInfo **aVRDEServerInfo)
1964	{
1965	CheckComArgOutPointerValid(aVRDEServerInfo);
1966
1967	AutoCaller autoCaller(this);
1968	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1969
1970	/* mVRDEServerInfo is constant during life time, no need to lock */
1971	mVRDEServerInfo.queryInterfaceTo(aVRDEServerInfo);
1972
1973	return S_OK;
1974	}
1975
1976	STDMETHODIMP
1977	Console::COMGETTER(SharedFolders)(ComSafeArrayOut(ISharedFolder *, aSharedFolders))
1978	{
1979	CheckComArgOutSafeArrayPointerValid(aSharedFolders);
1980
1981	AutoCaller autoCaller(this);
1982	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1983
1984	/* loadDataFromSavedState() needs a write lock */
1985	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1986
1987	/* Read console data stored in the saved state file (if not yet done) */
1988	HRESULT rc = loadDataFromSavedState();
1989	if (FAILED(rc)) return rc;
1990
1991	SafeIfaceArray<ISharedFolder> sf(m_mapSharedFolders);
1992	sf.detachTo(ComSafeArrayOutArg(aSharedFolders));
1993
1994	return S_OK;
1995	}
1996
1997
1998	STDMETHODIMP Console::COMGETTER(EventSource)(IEventSource ** aEventSource)
1999	{
2000	CheckComArgOutPointerValid(aEventSource);
2001
2002	AutoCaller autoCaller(this);
2003	HRESULT hrc = autoCaller.rc();
2004	if (SUCCEEDED(hrc))
2005	{
2006	// no need to lock - lifetime constant
2007	mEventSource.queryInterfaceTo(aEventSource);
2008	}
2009
2010	return hrc;
2011	}
2012
2013	STDMETHODIMP Console::COMGETTER(AttachedPCIDevices)(ComSafeArrayOut(IPCIDeviceAttachment *, aAttachments))
2014	{
2015	CheckComArgOutSafeArrayPointerValid(aAttachments);
2016
2017	AutoCaller autoCaller(this);
2018	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2019
2020	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2021
2022	if (mBusMgr)
2023	mBusMgr->listAttachedPCIDevices(ComSafeArrayOutArg(aAttachments));
2024	else
2025	{
2026	com::SafeIfaceArray<IPCIDeviceAttachment> result((size_t)0);
2027	result.detachTo(ComSafeArrayOutArg(aAttachments));
2028	}
2029
2030	return S_OK;
2031	}
2032
2033	STDMETHODIMP Console::COMGETTER(UseHostClipboard)(BOOL *aUseHostClipboard)
2034	{
2035	CheckComArgOutPointerValid(aUseHostClipboard);
2036
2037	AutoCaller autoCaller(this);
2038	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2039
2040	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2041
2042	*aUseHostClipboard = mfUseHostClipboard;
2043
2044	return S_OK;
2045	}
2046
2047	STDMETHODIMP Console::COMSETTER(UseHostClipboard)(BOOL aUseHostClipboard)
2048	{
2049	AutoCaller autoCaller(this);
2050	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2051
2052	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2053
2054	mfUseHostClipboard = !!aUseHostClipboard;
2055
2056	return S_OK;
2057	}
2058
2059	// IConsole methods
2060	/////////////////////////////////////////////////////////////////////////////
2061
2062
2063	STDMETHODIMP Console::PowerUp(IProgress **aProgress)
2064	{
2065	return powerUp(aProgress, false /* aPaused */);
2066	}
2067
2068	STDMETHODIMP Console::PowerUpPaused(IProgress **aProgress)
2069	{
2070	return powerUp(aProgress, true /* aPaused */);
2071	}
2072
2073	STDMETHODIMP Console::PowerDown(IProgress **aProgress)
2074	{
2075	LogFlowThisFuncEnter();
2076	LogFlowThisFunc(("mMachineState=%d\n", mMachineState));
2077
2078	CheckComArgOutPointerValid(aProgress);
2079
2080	AutoCaller autoCaller(this);
2081	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2082
2083	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2084
2085	switch (mMachineState)
2086	{
2087	case MachineState_Running:
2088	case MachineState_Paused:
2089	case MachineState_Stuck:
2090	break;
2091
2092	/* Try cancel the teleportation. */
2093	case MachineState_Teleporting:
2094	case MachineState_TeleportingPausedVM:
2095	if (!mptrCancelableProgress.isNull())
2096	{
2097	HRESULT hrc = mptrCancelableProgress->Cancel();
2098	if (SUCCEEDED(hrc))
2099	break;
2100	}
2101	return setError(VBOX_E_INVALID_VM_STATE, tr("Cannot power down at this point in a teleportation"));
2102
2103	/* Try cancel the live snapshot. */
2104	case MachineState_LiveSnapshotting:
2105	if (!mptrCancelableProgress.isNull())
2106	{
2107	HRESULT hrc = mptrCancelableProgress->Cancel();
2108	if (SUCCEEDED(hrc))
2109	break;
2110	}
2111	return setError(VBOX_E_INVALID_VM_STATE, tr("Cannot power down at this point in a live snapshot"));
2112
2113	/* Try cancel the FT sync. */
2114	case MachineState_FaultTolerantSyncing:
2115	if (!mptrCancelableProgress.isNull())
2116	{
2117	HRESULT hrc = mptrCancelableProgress->Cancel();
2118	if (SUCCEEDED(hrc))
2119	break;
2120	}
2121	return setError(VBOX_E_INVALID_VM_STATE, tr("Cannot power down at this point in a fault tolerant sync"));
2122
2123	/* extra nice error message for a common case */
2124	case MachineState_Saved:
2125	return setError(VBOX_E_INVALID_VM_STATE, tr("Cannot power down a saved virtual machine"));
2126	case MachineState_Stopping:
2127	return setError(VBOX_E_INVALID_VM_STATE, tr("The virtual machine is being powered down"));
2128	default:
2129	return setError(VBOX_E_INVALID_VM_STATE,
2130	tr("Invalid machine state: %s (must be Running, Paused or Stuck)"),
2131	Global::stringifyMachineState(mMachineState));
2132	}
2133
2134	LogFlowThisFunc(("Initiating SHUTDOWN request...\n"));
2135
2136	/* memorize the current machine state */
2137	MachineState_T lastMachineState = mMachineState;
2138
2139	HRESULT rc = S_OK;
2140	bool fBeganPowerDown = false;
2141
2142	do
2143	{
2144	ComPtr<IProgress> pProgress;
2145
2146	/*
2147	* request a progress object from the server
2148	* (this will set the machine state to Stopping on the server to block
2149	* others from accessing this machine)
2150	*/
2151	rc = mControl->BeginPoweringDown(pProgress.asOutParam());
2152	if (FAILED(rc))
2153	break;
2154
2155	fBeganPowerDown = true;
2156
2157	/* sync the state with the server */
2158	setMachineStateLocally(MachineState_Stopping);
2159
2160	/* setup task object and thread to carry out the operation asynchronously */
2161	std::auto_ptr<VMPowerDownTask> task(new VMPowerDownTask(this, pProgress));
2162	AssertBreakStmt(task->isOk(), rc = E_FAIL);
2163
2164	int vrc = RTThreadCreate(NULL, Console::powerDownThread,
2165	(void *) task.get(), 0,
2166	RTTHREADTYPE_MAIN_WORKER, 0,
2167	"VMPwrDwn");
2168	if (RT_FAILURE(vrc))
2169	{
2170	rc = setError(E_FAIL, "Could not create VMPowerDown thread (%Rrc)", vrc);
2171	break;
2172	}
2173
2174	/* task is now owned by powerDownThread(), so release it */
2175	task.release();
2176
2177	/* pass the progress to the caller */
2178	pProgress.queryInterfaceTo(aProgress);
2179	}
2180	while (0);
2181
2182	if (FAILED(rc))
2183	{
2184	/* preserve existing error info */
2185	ErrorInfoKeeper eik;
2186
2187	if (fBeganPowerDown)
2188	{
2189	/*
2190	* cancel the requested power down procedure.
2191	* This will reset the machine state to the state it had right
2192	* before calling mControl->BeginPoweringDown().
2193	*/
2194	mControl->EndPoweringDown(eik.getResultCode(), eik.getText().raw()); }
2195
2196	setMachineStateLocally(lastMachineState);
2197	}
2198
2199	LogFlowThisFunc(("rc=%Rhrc\n", rc));
2200	LogFlowThisFuncLeave();
2201
2202	return rc;
2203	}
2204
2205	STDMETHODIMP Console::Reset()
2206	{
2207	LogFlowThisFuncEnter();
2208	LogFlowThisFunc(("mMachineState=%d\n", mMachineState));
2209
2210	AutoCaller autoCaller(this);
2211	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2212
2213	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2214
2215	if ( mMachineState != MachineState_Running
2216	&& mMachineState != MachineState_Teleporting
2217	&& mMachineState != MachineState_LiveSnapshotting
2218	/** @todo r=bird: This should be allowed on paused VMs as well. Later. */
2219	)
2220	return setInvalidMachineStateError();
2221
2222	/* protect mpUVM */
2223	SafeVMPtr ptrVM(this);
2224	if (!ptrVM.isOk())
2225	return ptrVM.rc();
2226
2227	/* release the lock before a VMR3* call (EMT will call us back)! */
2228	alock.release();
2229
2230	int vrc = VMR3Reset(ptrVM.rawUVM());
2231
2232	HRESULT rc = RT_SUCCESS(vrc) ? S_OK :
2233	setError(VBOX_E_VM_ERROR,
2234	tr("Could not reset the machine (%Rrc)"),
2235	vrc);
2236
2237	LogFlowThisFunc(("mMachineState=%d, rc=%Rhrc\n", mMachineState, rc));
2238	LogFlowThisFuncLeave();
2239	return rc;
2240	}
2241
2242	/static/ DECLCALLBACK(int) Console::unplugCpu(Console *pThis, PUVM pUVM, VMCPUID idCpu)
2243	{
2244	LogFlowFunc(("pThis=%p pVM=%p idCpu=%u\n", pThis, pUVM, idCpu));
2245
2246	AssertReturn(pThis, VERR_INVALID_PARAMETER);
2247
2248	int vrc = PDMR3DeviceDetach(pUVM, "acpi", 0, idCpu, 0);
2249	Log(("UnplugCpu: rc=%Rrc\n", vrc));
2250
2251	return vrc;
2252	}
2253
2254	HRESULT Console::doCPURemove(ULONG aCpu, PUVM pUVM)
2255	{
2256	HRESULT rc = S_OK;
2257
2258	LogFlowThisFuncEnter();
2259	LogFlowThisFunc(("mMachineState=%d\n", mMachineState));
2260
2261	AutoCaller autoCaller(this);
2262	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2263
2264	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2265
2266	AssertReturn(m_pVMMDev, E_FAIL);
2267	PPDMIVMMDEVPORT pVmmDevPort = m_pVMMDev->getVMMDevPort();
2268	AssertReturn(pVmmDevPort, E_FAIL);
2269
2270	if ( mMachineState != MachineState_Running
2271	&& mMachineState != MachineState_Teleporting
2272	&& mMachineState != MachineState_LiveSnapshotting
2273	)
2274	return setInvalidMachineStateError();
2275
2276	/* Check if the CPU is present */
2277	BOOL fCpuAttached;
2278	rc = mMachine->GetCPUStatus(aCpu, &fCpuAttached);
2279	if (FAILED(rc))
2280	return rc;
2281	if (!fCpuAttached)
2282	return setError(E_FAIL, tr("CPU %d is not attached"), aCpu);
2283
2284	/* Leave the lock before any EMT/VMMDev call. */
2285	alock.release();
2286	bool fLocked = true;
2287
2288	/* Check if the CPU is unlocked */
2289	PPDMIBASE pBase;
2290	int vrc = PDMR3QueryDeviceLun(pUVM, "acpi", 0, aCpu, &pBase);
2291	if (RT_SUCCESS(vrc))
2292	{
2293	Assert(pBase);
2294	PPDMIACPIPORT pApicPort = PDMIBASE_QUERY_INTERFACE(pBase, PDMIACPIPORT);
2295
2296	/* Notify the guest if possible. */
2297	uint32_t idCpuCore, idCpuPackage;
2298	vrc = VMR3GetCpuCoreAndPackageIdFromCpuId(pUVM, aCpu, &idCpuCore, &idCpuPackage); AssertRC(vrc);
2299	if (RT_SUCCESS(vrc))
2300	vrc = pVmmDevPort->pfnCpuHotUnplug(pVmmDevPort, idCpuCore, idCpuPackage);
2301	if (RT_SUCCESS(vrc))
2302	{
2303	unsigned cTries = 100;
2304	do
2305	{
2306	/* It will take some time until the event is processed in the guest. Wait... */
2307	vrc = pApicPort ? pApicPort->pfnGetCpuStatus(pApicPort, aCpu, &fLocked) : VERR_INVALID_POINTER;
2308	if (RT_SUCCESS(vrc) && !fLocked)
2309	break;
2310
2311	/* Sleep a bit */
2312	RTThreadSleep(100);
2313	} while (cTries-- > 0);
2314	}
2315	else if (vrc == VERR_CPU_HOTPLUG_NOT_MONITORED_BY_GUEST)
2316	{
2317	/* Query one time. It is possible that the user ejected the CPU. */
2318	vrc = pApicPort ? pApicPort->pfnGetCpuStatus(pApicPort, aCpu, &fLocked) : VERR_INVALID_POINTER;
2319	}
2320	}
2321
2322	/* If the CPU was unlocked we can detach it now. */
2323	if (RT_SUCCESS(vrc) && !fLocked)
2324	{
2325	/*
2326	* Call worker in EMT, that's faster and safer than doing everything
2327	* using VMR3ReqCall.
2328	*/
2329	PVMREQ pReq;
2330	vrc = VMR3ReqCallU(pUVM, 0, &pReq, 0 /* no wait! */, VMREQFLAGS_VBOX_STATUS,
2331	(PFNRT)Console::unplugCpu, 3,
2332	this, pUVM, (VMCPUID)aCpu);
2333	if (vrc == VERR_TIMEOUT \|\| RT_SUCCESS(vrc))
2334	{
2335	vrc = VMR3ReqWait(pReq, RT_INDEFINITE_WAIT);
2336	AssertRC(vrc);
2337	if (RT_SUCCESS(vrc))
2338	vrc = pReq->iStatus;
2339	}
2340	VMR3ReqFree(pReq);
2341
2342	if (RT_SUCCESS(vrc))
2343	{
2344	/* Detach it from the VM */
2345	vrc = VMR3HotUnplugCpu(pUVM, aCpu);
2346	AssertRC(vrc);
2347	}
2348	else
2349	rc = setError(VBOX_E_VM_ERROR,
2350	tr("Hot-Remove failed (rc=%Rrc)"), vrc);
2351	}
2352	else
2353	rc = setError(VBOX_E_VM_ERROR,
2354	tr("Hot-Remove was aborted because the CPU may still be used by the guest"), VERR_RESOURCE_BUSY);
2355
2356	LogFlowThisFunc(("mMachineState=%d, rc=%Rhrc\n", mMachineState, rc));
2357	LogFlowThisFuncLeave();
2358	return rc;
2359	}
2360
2361	/static/ DECLCALLBACK(int) Console::plugCpu(Console *pThis, PUVM pUVM, VMCPUID idCpu)
2362	{
2363	LogFlowFunc(("pThis=%p uCpu=%u\n", pThis, idCpu));
2364
2365	AssertReturn(pThis, VERR_INVALID_PARAMETER);
2366
2367	int rc = VMR3HotPlugCpu(pUVM, idCpu);
2368	AssertRC(rc);
2369
2370	PCFGMNODE pInst = CFGMR3GetChild(CFGMR3GetRootU(pUVM), "Devices/acpi/0/");
2371	AssertRelease(pInst);
2372	/* nuke anything which might have been left behind. */
2373	CFGMR3RemoveNode(CFGMR3GetChildF(pInst, "LUN#%u", idCpu));
2374
2375	#define RC_CHECK() do { if (RT_FAILURE(rc)) { AssertReleaseRC(rc); break; } } while (0)
2376
2377	PCFGMNODE pLunL0;
2378	PCFGMNODE pCfg;
2379	rc = CFGMR3InsertNodeF(pInst, &pLunL0, "LUN#%u", idCpu); RC_CHECK();
2380	rc = CFGMR3InsertString(pLunL0, "Driver", "ACPICpu"); RC_CHECK();
2381	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
2382
2383	/*
2384	* Attach the driver.
2385	*/
2386	PPDMIBASE pBase;
2387	rc = PDMR3DeviceAttach(pUVM, "acpi", 0, idCpu, 0, &pBase); RC_CHECK();
2388
2389	Log(("PlugCpu: rc=%Rrc\n", rc));
2390
2391	CFGMR3Dump(pInst);
2392
2393	#undef RC_CHECK
2394
2395	return VINF_SUCCESS;
2396	}
2397
2398	HRESULT Console::doCPUAdd(ULONG aCpu, PUVM pUVM)
2399	{
2400	HRESULT rc = S_OK;
2401
2402	LogFlowThisFuncEnter();
2403	LogFlowThisFunc(("mMachineState=%d\n", mMachineState));
2404
2405	AutoCaller autoCaller(this);
2406	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2407
2408	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2409
2410	if ( mMachineState != MachineState_Running
2411	&& mMachineState != MachineState_Teleporting
2412	&& mMachineState != MachineState_LiveSnapshotting
2413	/** @todo r=bird: This should be allowed on paused VMs as well. Later. */
2414	)
2415	return setInvalidMachineStateError();
2416
2417	AssertReturn(m_pVMMDev, E_FAIL);
2418	PPDMIVMMDEVPORT pDevPort = m_pVMMDev->getVMMDevPort();
2419	AssertReturn(pDevPort, E_FAIL);
2420
2421	/* Check if the CPU is present */
2422	BOOL fCpuAttached;
2423	rc = mMachine->GetCPUStatus(aCpu, &fCpuAttached);
2424	if (FAILED(rc)) return rc;
2425
2426	if (fCpuAttached)
2427	return setError(E_FAIL,
2428	tr("CPU %d is already attached"), aCpu);
2429
2430	/*
2431	* Call worker in EMT, that's faster and safer than doing everything
2432	* using VMR3ReqCall. Note that we separate VMR3ReqCall from VMR3ReqWait
2433	* here to make requests from under the lock in order to serialize them.
2434	*/
2435	PVMREQ pReq;
2436	int vrc = VMR3ReqCallU(pUVM, 0, &pReq, 0 /* no wait! */, VMREQFLAGS_VBOX_STATUS,
2437	(PFNRT)Console::plugCpu, 3,
2438	this, pUVM, aCpu);
2439
2440	/* release the lock before a VMR3* call (EMT will call us back)! */
2441	alock.release();
2442
2443	if (vrc == VERR_TIMEOUT \|\| RT_SUCCESS(vrc))
2444	{
2445	vrc = VMR3ReqWait(pReq, RT_INDEFINITE_WAIT);
2446	AssertRC(vrc);
2447	if (RT_SUCCESS(vrc))
2448	vrc = pReq->iStatus;
2449	}
2450	VMR3ReqFree(pReq);
2451
2452	rc = RT_SUCCESS(vrc) ? S_OK :
2453	setError(VBOX_E_VM_ERROR,
2454	tr("Could not add CPU to the machine (%Rrc)"),
2455	vrc);
2456
2457	if (RT_SUCCESS(vrc))
2458	{
2459	/* Notify the guest if possible. */
2460	uint32_t idCpuCore, idCpuPackage;
2461	vrc = VMR3GetCpuCoreAndPackageIdFromCpuId(pUVM, aCpu, &idCpuCore, &idCpuPackage); AssertRC(vrc);
2462	if (RT_SUCCESS(vrc))
2463	vrc = pDevPort->pfnCpuHotPlug(pDevPort, idCpuCore, idCpuPackage);
2464	/** @todo warning if the guest doesn't support it */
2465	}
2466
2467	LogFlowThisFunc(("mMachineState=%d, rc=%Rhrc\n", mMachineState, rc));
2468	LogFlowThisFuncLeave();
2469	return rc;
2470	}
2471
2472	STDMETHODIMP Console::Pause()
2473	{
2474	LogFlowThisFuncEnter();
2475
2476	AutoCaller autoCaller(this);
2477	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2478
2479	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2480
2481	switch (mMachineState)
2482	{
2483	case MachineState_Running:
2484	case MachineState_Teleporting:
2485	case MachineState_LiveSnapshotting:
2486	break;
2487
2488	case MachineState_Paused:
2489	case MachineState_TeleportingPausedVM:
2490	case MachineState_Saving:
2491	return setError(VBOX_E_INVALID_VM_STATE, tr("Already paused"));
2492
2493	default:
2494	return setInvalidMachineStateError();
2495	}
2496
2497	/* get the VM handle. */
2498	SafeVMPtr ptrVM(this);
2499	if (!ptrVM.isOk())
2500	return ptrVM.rc();
2501
2502	LogFlowThisFunc(("Sending PAUSE request...\n"));
2503
2504	/* release the lock before a VMR3* call (EMT will call us back)! */
2505	alock.release();
2506
2507	int vrc = VMR3Suspend(ptrVM.rawUVM());
2508
2509	HRESULT hrc = S_OK;
2510	if (RT_FAILURE(vrc))
2511	hrc = setError(VBOX_E_VM_ERROR, tr("Could not suspend the machine execution (%Rrc)"), vrc);
2512
2513	LogFlowThisFunc(("hrc=%Rhrc\n", hrc));
2514	LogFlowThisFuncLeave();
2515	return hrc;
2516	}
2517
2518	STDMETHODIMP Console::Resume()
2519	{
2520	LogFlowThisFuncEnter();
2521
2522	AutoCaller autoCaller(this);
2523	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2524
2525	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2526
2527	if (mMachineState != MachineState_Paused)
2528	return setError(VBOX_E_INVALID_VM_STATE,
2529	tr("Cannot resume the machine as it is not paused (machine state: %s)"),
2530	Global::stringifyMachineState(mMachineState));
2531
2532	/* get the VM handle. */
2533	SafeVMPtr ptrVM(this);
2534	if (!ptrVM.isOk())
2535	return ptrVM.rc();
2536
2537	LogFlowThisFunc(("Sending RESUME request...\n"));
2538
2539	/* release the lock before a VMR3* call (EMT will call us back)! */
2540	alock.release();
2541
2542	#ifdef VBOX_WITH_EXTPACK
2543	int vrc = mptrExtPackManager->callAllVmPowerOnHooks(this, VMR3GetVM(ptrVM.rawUVM())); /** @todo called a few times too many... */
2544	#else
2545	int vrc = VINF_SUCCESS;
2546	#endif
2547	if (RT_SUCCESS(vrc))
2548	{
2549	if (VMR3GetStateU(ptrVM.rawUVM()) == VMSTATE_CREATED)
2550	vrc = VMR3PowerOn(ptrVM.rawUVM()); /* (PowerUpPaused) */
2551	else
2552	vrc = VMR3Resume(ptrVM.rawUVM());
2553	}
2554
2555	HRESULT rc = RT_SUCCESS(vrc) ? S_OK :
2556	setError(VBOX_E_VM_ERROR,
2557	tr("Could not resume the machine execution (%Rrc)"),
2558	vrc);
2559
2560	LogFlowThisFunc(("rc=%Rhrc\n", rc));
2561	LogFlowThisFuncLeave();
2562	return rc;
2563	}
2564
2565	STDMETHODIMP Console::PowerButton()
2566	{
2567	LogFlowThisFuncEnter();
2568
2569	AutoCaller autoCaller(this);
2570	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2571
2572	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2573
2574	if ( mMachineState != MachineState_Running
2575	&& mMachineState != MachineState_Teleporting
2576	&& mMachineState != MachineState_LiveSnapshotting
2577	)
2578	return setInvalidMachineStateError();
2579
2580	/* get the VM handle. */
2581	SafeVMPtr ptrVM(this);
2582	if (!ptrVM.isOk())
2583	return ptrVM.rc();
2584
2585	// no need to release lock, as there are no cross-thread callbacks
2586
2587	/* get the acpi device interface and press the button. */
2588	PPDMIBASE pBase;
2589	int vrc = PDMR3QueryDeviceLun(ptrVM.rawUVM(), "acpi", 0, 0, &pBase);
2590	if (RT_SUCCESS(vrc))
2591	{
2592	Assert(pBase);
2593	PPDMIACPIPORT pPort = PDMIBASE_QUERY_INTERFACE(pBase, PDMIACPIPORT);
2594	if (pPort)
2595	vrc = pPort->pfnPowerButtonPress(pPort);
2596	else
2597	vrc = VERR_PDM_MISSING_INTERFACE;
2598	}
2599
2600	HRESULT rc = RT_SUCCESS(vrc) ? S_OK :
2601	setError(VBOX_E_PDM_ERROR,
2602	tr("Controlled power off failed (%Rrc)"),
2603	vrc);
2604
2605	LogFlowThisFunc(("rc=%Rhrc\n", rc));
2606	LogFlowThisFuncLeave();
2607	return rc;
2608	}
2609
2610	STDMETHODIMP Console::GetPowerButtonHandled(BOOL *aHandled)
2611	{
2612	LogFlowThisFuncEnter();
2613
2614	CheckComArgOutPointerValid(aHandled);
2615
2616	*aHandled = FALSE;
2617
2618	AutoCaller autoCaller(this);
2619
2620	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2621
2622	if ( mMachineState != MachineState_Running
2623	&& mMachineState != MachineState_Teleporting
2624	&& mMachineState != MachineState_LiveSnapshotting
2625	)
2626	return setInvalidMachineStateError();
2627
2628	/* get the VM handle. */
2629	SafeVMPtr ptrVM(this);
2630	if (!ptrVM.isOk())
2631	return ptrVM.rc();
2632
2633	// no need to release lock, as there are no cross-thread callbacks
2634
2635	/* get the acpi device interface and check if the button press was handled. */
2636	PPDMIBASE pBase;
2637	int vrc = PDMR3QueryDeviceLun(ptrVM.rawUVM(), "acpi", 0, 0, &pBase);
2638	if (RT_SUCCESS(vrc))
2639	{
2640	Assert(pBase);
2641	PPDMIACPIPORT pPort = PDMIBASE_QUERY_INTERFACE(pBase, PDMIACPIPORT);
2642	if (pPort)
2643	{
2644	bool fHandled = false;
2645	vrc = pPort->pfnGetPowerButtonHandled(pPort, &fHandled);
2646	if (RT_SUCCESS(vrc))
2647	*aHandled = fHandled;
2648	}
2649	else
2650	vrc = VERR_PDM_MISSING_INTERFACE;
2651	}
2652
2653	HRESULT rc = RT_SUCCESS(vrc) ? S_OK :
2654	setError(VBOX_E_PDM_ERROR,
2655	tr("Checking if the ACPI Power Button event was handled by the guest OS failed (%Rrc)"),
2656	vrc);
2657
2658	LogFlowThisFunc(("rc=%Rhrc\n", rc));
2659	LogFlowThisFuncLeave();
2660	return rc;
2661	}
2662
2663	STDMETHODIMP Console::GetGuestEnteredACPIMode(BOOL *aEntered)
2664	{
2665	LogFlowThisFuncEnter();
2666
2667	CheckComArgOutPointerValid(aEntered);
2668
2669	*aEntered = FALSE;
2670
2671	AutoCaller autoCaller(this);
2672
2673	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2674
2675	if ( mMachineState != MachineState_Running
2676	&& mMachineState != MachineState_Teleporting
2677	&& mMachineState != MachineState_LiveSnapshotting
2678	)
2679	return setError(VBOX_E_INVALID_VM_STATE,
2680	tr("Invalid machine state %s when checking if the guest entered the ACPI mode)"),
2681	Global::stringifyMachineState(mMachineState));
2682
2683	/* get the VM handle. */
2684	SafeVMPtr ptrVM(this);
2685	if (!ptrVM.isOk())
2686	return ptrVM.rc();
2687
2688	// no need to release lock, as there are no cross-thread callbacks
2689
2690	/* get the acpi device interface and query the information. */
2691	PPDMIBASE pBase;
2692	int vrc = PDMR3QueryDeviceLun(ptrVM.rawUVM(), "acpi", 0, 0, &pBase);
2693	if (RT_SUCCESS(vrc))
2694	{
2695	Assert(pBase);
2696	PPDMIACPIPORT pPort = PDMIBASE_QUERY_INTERFACE(pBase, PDMIACPIPORT);
2697	if (pPort)
2698	{
2699	bool fEntered = false;
2700	vrc = pPort->pfnGetGuestEnteredACPIMode(pPort, &fEntered);
2701	if (RT_SUCCESS(vrc))
2702	*aEntered = fEntered;
2703	}
2704	else
2705	vrc = VERR_PDM_MISSING_INTERFACE;
2706	}
2707
2708	LogFlowThisFuncLeave();
2709	return S_OK;
2710	}
2711
2712	STDMETHODIMP Console::SleepButton()
2713	{
2714	LogFlowThisFuncEnter();
2715
2716	AutoCaller autoCaller(this);
2717	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2718
2719	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2720
2721	if (mMachineState != MachineState_Running) /** @todo Live Migration: ??? */
2722	return setInvalidMachineStateError();
2723
2724	/* get the VM handle. */
2725	SafeVMPtr ptrVM(this);
2726	if (!ptrVM.isOk())
2727	return ptrVM.rc();
2728
2729	// no need to release lock, as there are no cross-thread callbacks
2730
2731	/* get the acpi device interface and press the sleep button. */
2732	PPDMIBASE pBase;
2733	int vrc = PDMR3QueryDeviceLun(ptrVM.rawUVM(), "acpi", 0, 0, &pBase);
2734	if (RT_SUCCESS(vrc))
2735	{
2736	Assert(pBase);
2737	PPDMIACPIPORT pPort = PDMIBASE_QUERY_INTERFACE(pBase, PDMIACPIPORT);
2738	if (pPort)
2739	vrc = pPort->pfnSleepButtonPress(pPort);
2740	else
2741	vrc = VERR_PDM_MISSING_INTERFACE;
2742	}
2743
2744	HRESULT rc = RT_SUCCESS(vrc) ? S_OK :
2745	setError(VBOX_E_PDM_ERROR,
2746	tr("Sending sleep button event failed (%Rrc)"),
2747	vrc);
2748
2749	LogFlowThisFunc(("rc=%Rhrc\n", rc));
2750	LogFlowThisFuncLeave();
2751	return rc;
2752	}
2753
2754	STDMETHODIMP Console::SaveState(IProgress **aProgress)
2755	{
2756	LogFlowThisFuncEnter();
2757	LogFlowThisFunc(("mMachineState=%d\n", mMachineState));
2758
2759	CheckComArgOutPointerValid(aProgress);
2760
2761	AutoCaller autoCaller(this);
2762	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2763
2764	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2765
2766	if ( mMachineState != MachineState_Running
2767	&& mMachineState != MachineState_Paused)
2768	{
2769	return setError(VBOX_E_INVALID_VM_STATE,
2770	tr("Cannot save the execution state as the machine is not running or paused (machine state: %s)"),
2771	Global::stringifyMachineState(mMachineState));
2772	}
2773
2774	/* memorize the current machine state */
2775	MachineState_T lastMachineState = mMachineState;
2776
2777	if (mMachineState == MachineState_Running)
2778	{
2779	/* get the VM handle. */
2780	SafeVMPtr ptrVM(this);
2781	if (!ptrVM.isOk())
2782	return ptrVM.rc();
2783
2784	/* release the lock before a VMR3* call (EMT will call us back)! */
2785	alock.release();
2786	int vrc = VMR3Suspend(ptrVM.rawUVM());
2787	alock.acquire();
2788
2789	HRESULT hrc = S_OK;
2790	if (RT_FAILURE(vrc))
2791	hrc = setError(VBOX_E_VM_ERROR, tr("Could not suspend the machine execution (%Rrc)"), vrc);
2792	if (FAILED(hrc))
2793	return hrc;
2794	}
2795
2796	HRESULT rc = S_OK;
2797	bool fBeganSavingState = false;
2798	bool fTaskCreationFailed = false;
2799
2800	do
2801	{
2802	ComPtr<IProgress> pProgress;
2803	Bstr stateFilePath;
2804
2805	/*
2806	* request a saved state file path from the server
2807	* (this will set the machine state to Saving on the server to block
2808	* others from accessing this machine)
2809	*/
2810	rc = mControl->BeginSavingState(pProgress.asOutParam(),
2811	stateFilePath.asOutParam());
2812	if (FAILED(rc))
2813	break;
2814
2815	fBeganSavingState = true;
2816
2817	/* sync the state with the server */
2818	setMachineStateLocally(MachineState_Saving);
2819
2820	/* ensure the directory for the saved state file exists */
2821	{
2822	Utf8Str dir = stateFilePath;
2823	dir.stripFilename();
2824	if (!RTDirExists(dir.c_str()))
2825	{
2826	int vrc = RTDirCreateFullPath(dir.c_str(), 0700);
2827	if (RT_FAILURE(vrc))
2828	{
2829	rc = setError(VBOX_E_FILE_ERROR,
2830	tr("Could not create a directory '%s' to save the state to (%Rrc)"),
2831	dir.c_str(), vrc);
2832	break;
2833	}
2834	}
2835	}
2836
2837	/* Create a task object early to ensure mpUVM protection is successful. */
2838	std::auto_ptr<VMSaveTask> task(new VMSaveTask(this, pProgress,
2839	stateFilePath,
2840	lastMachineState));
2841	rc = task->rc();
2842	/*
2843	* If we fail here it means a PowerDown() call happened on another
2844	* thread while we were doing Pause() (which releases the Console lock).
2845	* We assign PowerDown() a higher precedence than SaveState(),
2846	* therefore just return the error to the caller.
2847	*/
2848	if (FAILED(rc))
2849	{
2850	fTaskCreationFailed = true;
2851	break;
2852	}
2853
2854	/* create a thread to wait until the VM state is saved */
2855	int vrc = RTThreadCreate(NULL, Console::saveStateThread, (void *)task.get(),
2856	0, RTTHREADTYPE_MAIN_WORKER, 0, "VMSave");
2857	if (RT_FAILURE(vrc))
2858	{
2859	rc = setError(E_FAIL, "Could not create VMSave thread (%Rrc)", vrc);
2860	break;
2861	}
2862
2863	/* task is now owned by saveStateThread(), so release it */
2864	task.release();
2865
2866	/* return the progress to the caller */
2867	pProgress.queryInterfaceTo(aProgress);
2868	} while (0);
2869
2870	if (FAILED(rc) && !fTaskCreationFailed)
2871	{
2872	/* preserve existing error info */
2873	ErrorInfoKeeper eik;
2874
2875	if (fBeganSavingState)
2876	{
2877	/*
2878	* cancel the requested save state procedure.
2879	* This will reset the machine state to the state it had right
2880	* before calling mControl->BeginSavingState().
2881	*/
2882	mControl->EndSavingState(eik.getResultCode(), eik.getText().raw());
2883	}
2884
2885	if (lastMachineState == MachineState_Running)
2886	{
2887	/* restore the paused state if appropriate */
2888	setMachineStateLocally(MachineState_Paused);
2889	/* restore the running state if appropriate */
2890	SafeVMPtr ptrVM(this);
2891	if (ptrVM.isOk())
2892	{
2893	alock.release();
2894	VMR3Resume(ptrVM.rawUVM());
2895	alock.acquire();
2896	}
2897	}
2898	else
2899	setMachineStateLocally(lastMachineState);
2900	}
2901
2902	LogFlowThisFunc(("rc=%Rhrc\n", rc));
2903	LogFlowThisFuncLeave();
2904	return rc;
2905	}
2906
2907	STDMETHODIMP Console::AdoptSavedState(IN_BSTR aSavedStateFile)
2908	{
2909	CheckComArgStrNotEmptyOrNull(aSavedStateFile);
2910
2911	AutoCaller autoCaller(this);
2912	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2913
2914	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2915
2916	if ( mMachineState != MachineState_PoweredOff
2917	&& mMachineState != MachineState_Teleported
2918	&& mMachineState != MachineState_Aborted
2919	)
2920	return setError(VBOX_E_INVALID_VM_STATE,
2921	tr("Cannot adopt the saved machine state as the machine is not in Powered Off, Teleported or Aborted state (machine state: %s)"),
2922	Global::stringifyMachineState(mMachineState));
2923
2924	return mControl->AdoptSavedState(aSavedStateFile);
2925	}
2926
2927	STDMETHODIMP Console::DiscardSavedState(BOOL aRemoveFile)
2928	{
2929	AutoCaller autoCaller(this);
2930	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2931
2932	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2933
2934	if (mMachineState != MachineState_Saved)
2935	return setError(VBOX_E_INVALID_VM_STATE,
2936	tr("Cannot delete the machine state as the machine is not in the saved state (machine state: %s)"),
2937	Global::stringifyMachineState(mMachineState));
2938
2939	HRESULT rc = mControl->SetRemoveSavedStateFile(aRemoveFile);
2940	if (FAILED(rc)) return rc;
2941
2942	/*
2943	* Saved -> PoweredOff transition will be detected in the SessionMachine
2944	* and properly handled.
2945	*/
2946	rc = setMachineState(MachineState_PoweredOff);
2947
2948	return rc;
2949	}
2950
2951	/** read the value of a LED. */
2952	inline uint32_t readAndClearLed(PPDMLED pLed)
2953	{
2954	if (!pLed)
2955	return 0;
2956	uint32_t u32 = pLed->Actual.u32 \| pLed->Asserted.u32;
2957	pLed->Asserted.u32 = 0;
2958	return u32;
2959	}
2960
2961	STDMETHODIMP Console::GetDeviceActivity(DeviceType_T aDeviceType,
2962	DeviceActivity_T *aDeviceActivity)
2963	{
2964	CheckComArgNotNull(aDeviceActivity);
2965
2966	AutoCaller autoCaller(this);
2967	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2968
2969	/*
2970	* Note: we don't lock the console object here because
2971	* readAndClearLed() should be thread safe.
2972	*/
2973
2974	/* Get LED array to read */
2975	PDMLEDCORE SumLed = {0};
2976	switch (aDeviceType)
2977	{
2978	case DeviceType_Floppy:
2979	case DeviceType_DVD:
2980	case DeviceType_HardDisk:
2981	{
2982	for (unsigned i = 0; i < RT_ELEMENTS(mapStorageLeds); ++i)
2983	if (maStorageDevType[i] == aDeviceType)
2984	SumLed.u32 \|= readAndClearLed(mapStorageLeds[i]);
2985	break;
2986	}
2987
2988	case DeviceType_Network:
2989	{
2990	for (unsigned i = 0; i < RT_ELEMENTS(mapNetworkLeds); ++i)
2991	SumLed.u32 \|= readAndClearLed(mapNetworkLeds[i]);
2992	break;
2993	}
2994
2995	case DeviceType_USB:
2996	{
2997	for (unsigned i = 0; i < RT_ELEMENTS(mapUSBLed); ++i)
2998	SumLed.u32 \|= readAndClearLed(mapUSBLed[i]);
2999	break;
3000	}
3001
3002	case DeviceType_SharedFolder:
3003	{
3004	SumLed.u32 \|= readAndClearLed(mapSharedFolderLed);
3005	break;
3006	}
3007
3008	default:
3009	return setError(E_INVALIDARG,
3010	tr("Invalid device type: %d"),
3011	aDeviceType);
3012	}
3013
3014	/* Compose the result */
3015	switch (SumLed.u32 & (PDMLED_READING \| PDMLED_WRITING))
3016	{
3017	case 0:
3018	*aDeviceActivity = DeviceActivity_Idle;
3019	break;
3020	case PDMLED_READING:
3021	*aDeviceActivity = DeviceActivity_Reading;
3022	break;
3023	case PDMLED_WRITING:
3024	case PDMLED_READING \| PDMLED_WRITING:
3025	*aDeviceActivity = DeviceActivity_Writing;
3026	break;
3027	}
3028
3029	return S_OK;
3030	}
3031
3032	STDMETHODIMP Console::AttachUSBDevice(IN_BSTR aId)
3033	{
3034	#ifdef VBOX_WITH_USB
3035	AutoCaller autoCaller(this);
3036	if (FAILED(autoCaller.rc())) return autoCaller.rc();
3037
3038	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3039
3040	if ( mMachineState != MachineState_Running
3041	&& mMachineState != MachineState_Paused)
3042	return setError(VBOX_E_INVALID_VM_STATE,
3043	tr("Cannot attach a USB device to the machine which is not running or paused (machine state: %s)"),
3044	Global::stringifyMachineState(mMachineState));
3045
3046	/* Get the VM handle. */
3047	SafeVMPtr ptrVM(this);
3048	if (!ptrVM.isOk())
3049	return ptrVM.rc();
3050
3051	/* Don't proceed unless we've found the usb controller. */
3052	PPDMIBASE pBase = NULL;
3053	int vrc = PDMR3QueryLun(ptrVM.rawUVM(), "usb-ohci", 0, 0, &pBase);
3054	if (RT_FAILURE(vrc))
3055	return setError(VBOX_E_PDM_ERROR,
3056	tr("The virtual machine does not have a USB controller"));
3057
3058	/* release the lock because the USB Proxy service may call us back
3059	* (via onUSBDeviceAttach()) */
3060	alock.release();
3061
3062	/* Request the device capture */
3063	return mControl->CaptureUSBDevice(aId);
3064
3065	#else /* !VBOX_WITH_USB */
3066	return setError(VBOX_E_PDM_ERROR,
3067	tr("The virtual machine does not have a USB controller"));
3068	#endif /* !VBOX_WITH_USB */
3069	}
3070
3071	STDMETHODIMP Console::DetachUSBDevice(IN_BSTR aId, IUSBDevice **aDevice)
3072	{
3073	#ifdef VBOX_WITH_USB
3074	CheckComArgOutPointerValid(aDevice);
3075
3076	AutoCaller autoCaller(this);
3077	if (FAILED(autoCaller.rc())) return autoCaller.rc();
3078
3079	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3080
3081	/* Find it. */
3082	ComObjPtr<OUSBDevice> pUSBDevice;
3083	USBDeviceList::iterator it = mUSBDevices.begin();
3084	Guid uuid(aId);
3085	while (it != mUSBDevices.end())
3086	{
3087	if ((*it)->id() == uuid)
3088	{
3089	pUSBDevice = *it;
3090	break;
3091	}
3092	++it;
3093	}
3094
3095	if (!pUSBDevice)
3096	return setError(E_INVALIDARG,
3097	tr("USB device with UUID {%RTuuid} is not attached to this machine"),
3098	Guid(aId).raw());
3099
3100	/* Remove the device from the collection, it is re-added below for failures */
3101	mUSBDevices.erase(it);
3102
3103	/*
3104	* Inform the USB device and USB proxy about what's cooking.
3105	*/
3106	alock.release();
3107	HRESULT rc = mControl->DetachUSBDevice(aId, false /* aDone */);
3108	if (FAILED(rc))
3109	{
3110	/* Re-add the device to the collection */
3111	alock.acquire();
3112	mUSBDevices.push_back(pUSBDevice);
3113	return rc;
3114	}
3115
3116	/* Request the PDM to detach the USB device. */
3117	rc = detachUSBDevice(pUSBDevice);
3118	if (SUCCEEDED(rc))
3119	{
3120	/* Request the device release. Even if it fails, the device will
3121	* remain as held by proxy, which is OK for us (the VM process). */
3122	rc = mControl->DetachUSBDevice(aId, true /* aDone */);
3123	}
3124	else
3125	{
3126	/* Re-add the device to the collection */
3127	alock.acquire();
3128	mUSBDevices.push_back(pUSBDevice);
3129	}
3130
3131	return rc;
3132
3133
3134	#else /* !VBOX_WITH_USB */
3135	return setError(VBOX_E_PDM_ERROR,
3136	tr("The virtual machine does not have a USB controller"));
3137	#endif /* !VBOX_WITH_USB */
3138	}
3139
3140	STDMETHODIMP Console::FindUSBDeviceByAddress(IN_BSTR aAddress, IUSBDevice **aDevice)
3141	{
3142	#ifdef VBOX_WITH_USB
3143	CheckComArgStrNotEmptyOrNull(aAddress);
3144	CheckComArgOutPointerValid(aDevice);
3145
3146	*aDevice = NULL;
3147
3148	SafeIfaceArray<IUSBDevice> devsvec;
3149	HRESULT rc = COMGETTER(USBDevices)(ComSafeArrayAsOutParam(devsvec));
3150	if (FAILED(rc)) return rc;
3151
3152	for (size_t i = 0; i < devsvec.size(); ++i)
3153	{
3154	Bstr address;
3155	rc = devsvec[i]->COMGETTER(Address)(address.asOutParam());
3156	if (FAILED(rc)) return rc;
3157	if (address == aAddress)
3158	{
3159	ComObjPtr<OUSBDevice> pUSBDevice;
3160	pUSBDevice.createObject();
3161	pUSBDevice->init(devsvec[i]);
3162	return pUSBDevice.queryInterfaceTo(aDevice);
3163	}
3164	}
3165
3166	return setErrorNoLog(VBOX_E_OBJECT_NOT_FOUND,
3167	tr("Could not find a USB device with address '%ls'"),
3168	aAddress);
3169
3170	#else /* !VBOX_WITH_USB */
3171	return E_NOTIMPL;
3172	#endif /* !VBOX_WITH_USB */
3173	}
3174
3175	STDMETHODIMP Console::FindUSBDeviceById(IN_BSTR aId, IUSBDevice **aDevice)
3176	{
3177	#ifdef VBOX_WITH_USB
3178	CheckComArgExpr(aId, Guid(aId).isValid());
3179	CheckComArgOutPointerValid(aDevice);
3180
3181	*aDevice = NULL;
3182
3183	SafeIfaceArray<IUSBDevice> devsvec;
3184	HRESULT rc = COMGETTER(USBDevices)(ComSafeArrayAsOutParam(devsvec));
3185	if (FAILED(rc)) return rc;
3186
3187	for (size_t i = 0; i < devsvec.size(); ++i)
3188	{
3189	Bstr id;
3190	rc = devsvec[i]->COMGETTER(Id)(id.asOutParam());
3191	if (FAILED(rc)) return rc;
3192	if (id == aId)
3193	{
3194	ComObjPtr<OUSBDevice> pUSBDevice;
3195	pUSBDevice.createObject();
3196	pUSBDevice->init(devsvec[i]);
3197	return pUSBDevice.queryInterfaceTo(aDevice);
3198	}
3199	}
3200
3201	return setErrorNoLog(VBOX_E_OBJECT_NOT_FOUND,
3202	tr("Could not find a USB device with uuid {%RTuuid}"),
3203	Guid(aId).raw());
3204
3205	#else /* !VBOX_WITH_USB */
3206	return E_NOTIMPL;
3207	#endif /* !VBOX_WITH_USB */
3208	}
3209
3210	STDMETHODIMP
3211	Console::CreateSharedFolder(IN_BSTR aName, IN_BSTR aHostPath, BOOL aWritable, BOOL aAutoMount)
3212	{
3213	CheckComArgStrNotEmptyOrNull(aName);
3214	CheckComArgStrNotEmptyOrNull(aHostPath);
3215
3216	LogFlowThisFunc(("Entering for '%ls' -> '%ls'\n", aName, aHostPath));
3217
3218	AutoCaller autoCaller(this);
3219	if (FAILED(autoCaller.rc())) return autoCaller.rc();
3220
3221	Utf8Str strName(aName);
3222	Utf8Str strHostPath(aHostPath);
3223
3224	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3225
3226	/// @todo see @todo in AttachUSBDevice() about the Paused state
3227	if (mMachineState == MachineState_Saved)
3228	return setError(VBOX_E_INVALID_VM_STATE,
3229	tr("Cannot create a transient shared folder on the machine in the saved state"));
3230	if ( mMachineState != MachineState_PoweredOff
3231	&& mMachineState != MachineState_Teleported
3232	&& mMachineState != MachineState_Aborted
3233	&& mMachineState != MachineState_Running
3234	&& mMachineState != MachineState_Paused
3235	)
3236	return setError(VBOX_E_INVALID_VM_STATE,
3237	tr("Cannot create a transient shared folder on the machine while it is changing the state (machine state: %s)"),
3238	Global::stringifyMachineState(mMachineState));
3239
3240	ComObjPtr<SharedFolder> pSharedFolder;
3241	HRESULT rc = findSharedFolder(strName, pSharedFolder, false /* aSetError */);
3242	if (SUCCEEDED(rc))
3243	return setError(VBOX_E_FILE_ERROR,
3244	tr("Shared folder named '%s' already exists"),
3245	strName.c_str());
3246
3247	pSharedFolder.createObject();
3248	rc = pSharedFolder->init(this,
3249	strName,
3250	strHostPath,
3251	!!aWritable,
3252	!!aAutoMount,
3253	true /* fFailOnError */);
3254	if (FAILED(rc)) return rc;
3255
3256	/* If the VM is online and supports shared folders, share this folder
3257	* under the specified name. (Ignore any failure to obtain the VM handle.) */
3258	SafeVMPtrQuiet ptrVM(this);
3259	if ( ptrVM.isOk()
3260	&& m_pVMMDev
3261	&& m_pVMMDev->isShFlActive()
3262	)
3263	{
3264	/* first, remove the machine or the global folder if there is any */
3265	SharedFolderDataMap::const_iterator it;
3266	if (findOtherSharedFolder(aName, it))
3267	{
3268	rc = removeSharedFolder(aName);
3269	if (FAILED(rc))
3270	return rc;
3271	}
3272
3273	/* second, create the given folder */
3274	rc = createSharedFolder(aName, SharedFolderData(aHostPath, !!aWritable, !!aAutoMount));
3275	if (FAILED(rc))
3276	return rc;
3277	}
3278
3279	m_mapSharedFolders.insert(std::make_pair(aName, pSharedFolder));
3280
3281	/* Notify console callbacks after the folder is added to the list. */
3282	alock.release();
3283	fireSharedFolderChangedEvent(mEventSource, Scope_Session);
3284
3285	LogFlowThisFunc(("Leaving for '%ls' -> '%ls'\n", aName, aHostPath));
3286
3287	return rc;
3288	}
3289
3290	STDMETHODIMP Console::RemoveSharedFolder(IN_BSTR aName)
3291	{
3292	CheckComArgStrNotEmptyOrNull(aName);
3293
3294	AutoCaller autoCaller(this);
3295	if (FAILED(autoCaller.rc())) return autoCaller.rc();
3296
3297	LogFlowThisFunc(("Entering for '%ls'\n", aName));
3298
3299	Utf8Str strName(aName);
3300
3301	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3302
3303	/// @todo see @todo in AttachUSBDevice() about the Paused state
3304	if (mMachineState == MachineState_Saved)
3305	return setError(VBOX_E_INVALID_VM_STATE,
3306	tr("Cannot remove a transient shared folder from the machine in the saved state"));
3307	if ( mMachineState != MachineState_PoweredOff
3308	&& mMachineState != MachineState_Teleported
3309	&& mMachineState != MachineState_Aborted
3310	&& mMachineState != MachineState_Running
3311	&& mMachineState != MachineState_Paused
3312	)
3313	return setError(VBOX_E_INVALID_VM_STATE,
3314	tr("Cannot remove a transient shared folder from the machine while it is changing the state (machine state: %s)"),
3315	Global::stringifyMachineState(mMachineState));
3316
3317	ComObjPtr<SharedFolder> pSharedFolder;
3318	HRESULT rc = findSharedFolder(aName, pSharedFolder, true /* aSetError */);
3319	if (FAILED(rc)) return rc;
3320
3321	/* protect the VM handle (if not NULL) */
3322	SafeVMPtrQuiet ptrVM(this);
3323	if ( ptrVM.isOk()
3324	&& m_pVMMDev
3325	&& m_pVMMDev->isShFlActive()
3326	)
3327	{
3328	/* if the VM is online and supports shared folders, UNshare this
3329	* folder. */
3330
3331	/* first, remove the given folder */
3332	rc = removeSharedFolder(strName);
3333	if (FAILED(rc)) return rc;
3334
3335	/* first, remove the machine or the global folder if there is any */
3336	SharedFolderDataMap::const_iterator it;
3337	if (findOtherSharedFolder(strName, it))
3338	{
3339	rc = createSharedFolder(strName, it->second);
3340	/* don't check rc here because we need to remove the console
3341	* folder from the collection even on failure */
3342	}
3343	}
3344
3345	m_mapSharedFolders.erase(strName);
3346
3347	/* Notify console callbacks after the folder is removed from the list. */
3348	alock.release();
3349	fireSharedFolderChangedEvent(mEventSource, Scope_Session);
3350
3351	LogFlowThisFunc(("Leaving for '%ls'\n", aName));
3352
3353	return rc;
3354	}
3355
3356	STDMETHODIMP Console::TakeSnapshot(IN_BSTR aName,
3357	IN_BSTR aDescription,
3358	IProgress **aProgress)
3359	{
3360	LogFlowThisFuncEnter();
3361	LogFlowThisFunc(("aName='%ls' mMachineState=%d\n", aName, mMachineState));
3362
3363	CheckComArgStrNotEmptyOrNull(aName);
3364	CheckComArgOutPointerValid(aProgress);
3365
3366	AutoCaller autoCaller(this);
3367	if (FAILED(autoCaller.rc())) return autoCaller.rc();
3368
3369	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3370
3371	if (Global::IsTransient(mMachineState))
3372	return setError(VBOX_E_INVALID_VM_STATE,
3373	tr("Cannot take a snapshot of the machine while it is changing the state (machine state: %s)"),
3374	Global::stringifyMachineState(mMachineState));
3375
3376	HRESULT rc = S_OK;
3377
3378	/* prepare the progress object:
3379	a) count the no. of hard disk attachments to get a matching no. of progress sub-operations */
3380	ULONG cOperations = 2; // always at least setting up + finishing up
3381	ULONG ulTotalOperationsWeight = 2; // one each for setting up + finishing up
3382	SafeIfaceArray<IMediumAttachment> aMediumAttachments;
3383	rc = mMachine->COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(aMediumAttachments));
3384	if (FAILED(rc))
3385	return setError(rc, tr("Cannot get medium attachments of the machine"));
3386
3387	ULONG ulMemSize;
3388	rc = mMachine->COMGETTER(MemorySize)(&ulMemSize);
3389	if (FAILED(rc))
3390	return rc;
3391
3392	for (size_t i = 0;
3393	i < aMediumAttachments.size();
3394	++i)
3395	{
3396	DeviceType_T type;
3397	rc = aMediumAttachments[i]->COMGETTER(Type)(&type);
3398	if (FAILED(rc))
3399	return rc;
3400
3401	if (type == DeviceType_HardDisk)
3402	{
3403	++cOperations;
3404
3405	// assume that creating a diff image takes as long as saving a 1MB state
3406	// (note, the same value must be used in SessionMachine::BeginTakingSnapshot() on the server!)
3407	ulTotalOperationsWeight += 1;
3408	}
3409	}
3410
3411	// b) one extra sub-operations for online snapshots OR offline snapshots that have a saved state (needs to be copied)
3412	bool const fTakingSnapshotOnline = Global::IsOnline(mMachineState);
3413
3414	LogFlowFunc(("fTakingSnapshotOnline = %d, mMachineState = %d\n", fTakingSnapshotOnline, mMachineState));
3415
3416	if (fTakingSnapshotOnline)
3417	{
3418	++cOperations;
3419	ulTotalOperationsWeight += ulMemSize;
3420	}
3421
3422	// finally, create the progress object
3423	ComObjPtr<Progress> pProgress;
3424	pProgress.createObject();
3425	rc = pProgress->init(static_cast<IConsole *>(this),
3426	Bstr(tr("Taking a snapshot of the virtual machine")).raw(),
3427	(mMachineState >= MachineState_FirstOnline)
3428	&& (mMachineState <= MachineState_LastOnline) /* aCancelable */,
3429	cOperations,
3430	ulTotalOperationsWeight,
3431	Bstr(tr("Setting up snapshot operation")).raw(), // first sub-op description
3432	1); // ulFirstOperationWeight
3433
3434	if (FAILED(rc))
3435	return rc;
3436
3437	VMTakeSnapshotTask *pTask;
3438	if (!(pTask = new VMTakeSnapshotTask(this, pProgress, aName, aDescription)))
3439	return E_OUTOFMEMORY;
3440
3441	Assert(pTask->mProgress);
3442
3443	try
3444	{
3445	mptrCancelableProgress = pProgress;
3446
3447	/*
3448	* If we fail here it means a PowerDown() call happened on another
3449	* thread while we were doing Pause() (which releases the Console lock).
3450	* We assign PowerDown() a higher precedence than TakeSnapshot(),
3451	* therefore just return the error to the caller.
3452	*/
3453	rc = pTask->rc();
3454	if (FAILED(rc)) throw rc;
3455
3456	pTask->ulMemSize = ulMemSize;
3457
3458	/* memorize the current machine state */
3459	pTask->lastMachineState = mMachineState;
3460	pTask->fTakingSnapshotOnline = fTakingSnapshotOnline;
3461
3462	int vrc = RTThreadCreate(NULL,
3463	Console::fntTakeSnapshotWorker,
3464	(void *)pTask,
3465	0,
3466	RTTHREADTYPE_MAIN_WORKER,
3467	0,
3468	"TakeSnap");
3469	if (FAILED(vrc))
3470	throw setError(E_FAIL,
3471	tr("Could not create VMTakeSnap thread (%Rrc)"),
3472	vrc);
3473
3474	pTask->mProgress.queryInterfaceTo(aProgress);
3475	}
3476	catch (HRESULT erc)
3477	{
3478	delete pTask;
3479	rc = erc;
3480	mptrCancelableProgress.setNull();
3481	}
3482
3483	LogFlowThisFunc(("rc=%Rhrc\n", rc));
3484	LogFlowThisFuncLeave();
3485	return rc;
3486	}
3487
3488	STDMETHODIMP Console::DeleteSnapshot(IN_BSTR aId, IProgress **aProgress)
3489	{
3490	CheckComArgExpr(aId, Guid(aId).isValid());
3491	CheckComArgOutPointerValid(aProgress);
3492
3493	AutoCaller autoCaller(this);
3494	if (FAILED(autoCaller.rc())) return autoCaller.rc();
3495
3496	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3497
3498	if (Global::IsTransient(mMachineState))
3499	return setError(VBOX_E_INVALID_VM_STATE,
3500	tr("Cannot delete a snapshot of the machine while it is changing the state (machine state: %s)"),
3501	Global::stringifyMachineState(mMachineState));
3502
3503	MachineState_T machineState = MachineState_Null;
3504	HRESULT rc = mControl->DeleteSnapshot(this, aId, aId, FALSE /* fDeleteAllChildren */, &machineState, aProgress);
3505	if (FAILED(rc)) return rc;
3506
3507	setMachineStateLocally(machineState);
3508	return S_OK;
3509	}
3510
3511	STDMETHODIMP Console::DeleteSnapshotAndAllChildren(IN_BSTR aId, IProgress **aProgress)
3512	{
3513	CheckComArgExpr(aId, Guid(aId).isValid());
3514	CheckComArgOutPointerValid(aProgress);
3515
3516	AutoCaller autoCaller(this);
3517	if (FAILED(autoCaller.rc())) return autoCaller.rc();
3518
3519	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3520
3521	if (Global::IsTransient(mMachineState))
3522	return setError(VBOX_E_INVALID_VM_STATE,
3523	tr("Cannot delete a snapshot of the machine while it is changing the state (machine state: %s)"),
3524	Global::stringifyMachineState(mMachineState));
3525
3526	MachineState_T machineState = MachineState_Null;
3527	HRESULT rc = mControl->DeleteSnapshot(this, aId, aId, TRUE /* fDeleteAllChildren */, &machineState, aProgress);
3528	if (FAILED(rc)) return rc;
3529
3530	setMachineStateLocally(machineState);
3531	return S_OK;
3532	}
3533
3534	STDMETHODIMP Console::DeleteSnapshotRange(IN_BSTR aStartId, IN_BSTR aEndId, IProgress **aProgress)
3535	{
3536	CheckComArgExpr(aStartId, Guid(aStartId).isValid());
3537	CheckComArgExpr(aEndId, Guid(aEndId).isValid());
3538	CheckComArgOutPointerValid(aProgress);
3539
3540	AutoCaller autoCaller(this);
3541	if (FAILED(autoCaller.rc())) return autoCaller.rc();
3542
3543	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3544
3545	if (Global::IsTransient(mMachineState))
3546	return setError(VBOX_E_INVALID_VM_STATE,
3547	tr("Cannot delete a snapshot of the machine while it is changing the state (machine state: %s)"),
3548	Global::stringifyMachineState(mMachineState));
3549
3550	MachineState_T machineState = MachineState_Null;
3551	HRESULT rc = mControl->DeleteSnapshot(this, aStartId, aEndId, FALSE /* fDeleteAllChildren */, &machineState, aProgress);
3552	if (FAILED(rc)) return rc;
3553
3554	setMachineStateLocally(machineState);
3555	return S_OK;
3556	}
3557
3558	STDMETHODIMP Console::RestoreSnapshot(ISnapshot aSnapshot, IProgress *aProgress)
3559	{
3560	AutoCaller autoCaller(this);
3561	if (FAILED(autoCaller.rc())) return autoCaller.rc();
3562
3563	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3564
3565	if (Global::IsOnlineOrTransient(mMachineState))
3566	return setError(VBOX_E_INVALID_VM_STATE,
3567	tr("Cannot delete the current state of the running machine (machine state: %s)"),
3568	Global::stringifyMachineState(mMachineState));
3569
3570	MachineState_T machineState = MachineState_Null;
3571	HRESULT rc = mControl->RestoreSnapshot(this, aSnapshot, &machineState, aProgress);
3572	if (FAILED(rc)) return rc;
3573
3574	setMachineStateLocally(machineState);
3575	return S_OK;
3576	}
3577
3578	// Non-interface public methods
3579	/////////////////////////////////////////////////////////////////////////////
3580
3581	/static/
3582	HRESULT Console::setErrorStatic(HRESULT aResultCode, const char *pcsz, ...)
3583	{
3584	va_list args;
3585	va_start(args, pcsz);
3586	HRESULT rc = setErrorInternal(aResultCode,
3587	getStaticClassIID(),
3588	getStaticComponentName(),
3589	Utf8Str(pcsz, args),
3590	false /* aWarning */,
3591	true /* aLogIt */);
3592	va_end(args);
3593	return rc;
3594	}
3595
3596	HRESULT Console::setInvalidMachineStateError()
3597	{
3598	return setError(VBOX_E_INVALID_VM_STATE,
3599	tr("Invalid machine state: %s"),
3600	Global::stringifyMachineState(mMachineState));
3601	}
3602
3603
3604	/* static */
3605	const char *Console::convertControllerTypeToDev(StorageControllerType_T enmCtrlType)
3606	{
3607	switch (enmCtrlType)
3608	{
3609	case StorageControllerType_LsiLogic:
3610	return "lsilogicscsi";
3611	case StorageControllerType_BusLogic:
3612	return "buslogic";
3613	case StorageControllerType_LsiLogicSas:
3614	return "lsilogicsas";
3615	case StorageControllerType_IntelAhci:
3616	return "ahci";
3617	case StorageControllerType_PIIX3:
3618	case StorageControllerType_PIIX4:
3619	case StorageControllerType_ICH6:
3620	return "piix3ide";
3621	case StorageControllerType_I82078:
3622	return "i82078";
3623	default:
3624	return NULL;
3625	}
3626	}
3627
3628	HRESULT Console::convertBusPortDeviceToLun(StorageBus_T enmBus, LONG port, LONG device, unsigned &uLun)
3629	{
3630	switch (enmBus)
3631	{
3632	case StorageBus_IDE:
3633	case StorageBus_Floppy:
3634	{
3635	AssertMsgReturn(port < 2 && port >= 0, ("%d\n", port), E_INVALIDARG);
3636	AssertMsgReturn(device < 2 && device >= 0, ("%d\n", device), E_INVALIDARG);
3637	uLun = 2 * port + device;
3638	return S_OK;
3639	}
3640	case StorageBus_SATA:
3641	case StorageBus_SCSI:
3642	case StorageBus_SAS:
3643	{
3644	uLun = port;
3645	return S_OK;
3646	}
3647	default:
3648	uLun = 0;
3649	AssertMsgFailedReturn(("%d\n", enmBus), E_INVALIDARG);
3650	}
3651	}
3652
3653	// private methods
3654	/////////////////////////////////////////////////////////////////////////////
3655
3656	/**
3657	* Process a medium change.
3658	*
3659	* @param aMediumAttachment The medium attachment with the new medium state.
3660	* @param fForce Force medium chance, if it is locked or not.
3661	* @param pUVM Safe VM handle.
3662	*
3663	* @note Locks this object for writing.
3664	*/
3665	HRESULT Console::doMediumChange(IMediumAttachment *aMediumAttachment, bool fForce, PUVM pUVM)
3666	{
3667	AutoCaller autoCaller(this);
3668	AssertComRCReturnRC(autoCaller.rc());
3669
3670	/* We will need to release the write lock before calling EMT */
3671	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3672
3673	HRESULT rc = S_OK;
3674	const char *pszDevice = NULL;
3675
3676	SafeIfaceArray<IStorageController> ctrls;
3677	rc = mMachine->COMGETTER(StorageControllers)(ComSafeArrayAsOutParam(ctrls));
3678	AssertComRC(rc);
3679	IMedium *pMedium;
3680	rc = aMediumAttachment->COMGETTER(Medium)(&pMedium);
3681	AssertComRC(rc);
3682	Bstr mediumLocation;
3683	if (pMedium)
3684	{
3685	rc = pMedium->COMGETTER(Location)(mediumLocation.asOutParam());
3686	AssertComRC(rc);
3687	}
3688
3689	Bstr attCtrlName;
3690	rc = aMediumAttachment->COMGETTER(Controller)(attCtrlName.asOutParam());
3691	AssertComRC(rc);
3692	ComPtr<IStorageController> pStorageController;
3693	for (size_t i = 0; i < ctrls.size(); ++i)
3694	{
3695	Bstr ctrlName;
3696	rc = ctrls[i]->COMGETTER(Name)(ctrlName.asOutParam());
3697	AssertComRC(rc);
3698	if (attCtrlName == ctrlName)
3699	{
3700	pStorageController = ctrls[i];
3701	break;
3702	}
3703	}
3704	if (pStorageController.isNull())
3705	return setError(E_FAIL,
3706	tr("Could not find storage controller '%ls'"), attCtrlName.raw());
3707
3708	StorageControllerType_T enmCtrlType;
3709	rc = pStorageController->COMGETTER(ControllerType)(&enmCtrlType);
3710	AssertComRC(rc);
3711	pszDevice = convertControllerTypeToDev(enmCtrlType);
3712
3713	StorageBus_T enmBus;
3714	rc = pStorageController->COMGETTER(Bus)(&enmBus);
3715	AssertComRC(rc);
3716	ULONG uInstance;
3717	rc = pStorageController->COMGETTER(Instance)(&uInstance);
3718	AssertComRC(rc);
3719	BOOL fUseHostIOCache;
3720	rc = pStorageController->COMGETTER(UseHostIOCache)(&fUseHostIOCache);
3721	AssertComRC(rc);
3722
3723	/*
3724	* Call worker in EMT, that's faster and safer than doing everything
3725	* using VMR3ReqCall. Note that we separate VMR3ReqCall from VMR3ReqWait
3726	* here to make requests from under the lock in order to serialize them.
3727	*/
3728	PVMREQ pReq;
3729	int vrc = VMR3ReqCallU(pUVM,
3730	VMCPUID_ANY,
3731	&pReq,
3732	0 /* no wait! */,
3733	VMREQFLAGS_VBOX_STATUS,
3734	(PFNRT)Console::changeRemovableMedium,
3735	8,
3736	this,
3737	pUVM,
3738	pszDevice,
3739	uInstance,
3740	enmBus,
3741	fUseHostIOCache,
3742	aMediumAttachment,
3743	fForce);
3744
3745	/* release the lock before waiting for a result (EMT will call us back!) */
3746	alock.release();
3747
3748	if (vrc == VERR_TIMEOUT \|\| RT_SUCCESS(vrc))
3749	{
3750	vrc = VMR3ReqWait(pReq, RT_INDEFINITE_WAIT);
3751	AssertRC(vrc);
3752	if (RT_SUCCESS(vrc))
3753	vrc = pReq->iStatus;
3754	}
3755	VMR3ReqFree(pReq);
3756
3757	if (RT_SUCCESS(vrc))
3758	{
3759	LogFlowThisFunc(("Returns S_OK\n"));
3760	return S_OK;
3761	}
3762
3763	if (pMedium)
3764	return setError(E_FAIL,
3765	tr("Could not mount the media/drive '%ls' (%Rrc)"),
3766	mediumLocation.raw(), vrc);
3767
3768	return setError(E_FAIL,
3769	tr("Could not unmount the currently mounted media/drive (%Rrc)"),
3770	vrc);
3771	}
3772
3773	/**
3774	* Performs the medium change in EMT.
3775	*
3776	* @returns VBox status code.
3777	*
3778	* @param pThis Pointer to the Console object.
3779	* @param pUVM The VM handle.
3780	* @param pcszDevice The PDM device name.
3781	* @param uInstance The PDM device instance.
3782	* @param uLun The PDM LUN number of the drive.
3783	* @param fHostDrive True if this is a host drive attachment.
3784	* @param pszPath The path to the media / drive which is now being mounted / captured.
3785	* If NULL no media or drive is attached and the LUN will be configured with
3786	* the default block driver with no media. This will also be the state if
3787	* mounting / capturing the specified media / drive fails.
3788	* @param pszFormat Medium format string, usually "RAW".
3789	* @param fPassthrough Enables using passthrough mode of the host DVD drive if applicable.
3790	*
3791	* @thread EMT
3792	*/
3793	DECLCALLBACK(int) Console::changeRemovableMedium(Console *pConsole,
3794	PUVM pUVM,
3795	const char *pcszDevice,
3796	unsigned uInstance,
3797	StorageBus_T enmBus,
3798	bool fUseHostIOCache,
3799	IMediumAttachment *aMediumAtt,
3800	bool fForce)
3801	{
3802	LogFlowFunc(("pConsole=%p uInstance=%u pszDevice=%p:{%s} enmBus=%u, aMediumAtt=%p, fForce=%d\n",
3803	pConsole, uInstance, pcszDevice, pcszDevice, enmBus, aMediumAtt, fForce));
3804
3805	AssertReturn(pConsole, VERR_INVALID_PARAMETER);
3806
3807	AutoCaller autoCaller(pConsole);
3808	AssertComRCReturn(autoCaller.rc(), VERR_ACCESS_DENIED);
3809
3810	/*
3811	* Suspend the VM first.
3812	*
3813	* The VM must not be running since it might have pending I/O to
3814	* the drive which is being changed.
3815	*/
3816	bool fResume;
3817	VMSTATE enmVMState = VMR3GetStateU(pUVM);
3818	switch (enmVMState)
3819	{
3820	case VMSTATE_RESETTING:
3821	case VMSTATE_RUNNING:
3822	{
3823	LogFlowFunc(("Suspending the VM...\n"));
3824	/* disable the callback to prevent Console-level state change */
3825	pConsole->mVMStateChangeCallbackDisabled = true;
3826	int rc = VMR3Suspend(pUVM);
3827	pConsole->mVMStateChangeCallbackDisabled = false;
3828	AssertRCReturn(rc, rc);
3829	fResume = true;
3830	break;
3831	}
3832
3833	case VMSTATE_SUSPENDED:
3834	case VMSTATE_CREATED:
3835	case VMSTATE_OFF:
3836	fResume = false;
3837	break;
3838
3839	case VMSTATE_RUNNING_LS:
3840	case VMSTATE_RUNNING_FT:
3841	return setErrorInternal(VBOX_E_INVALID_VM_STATE,
3842	COM_IIDOF(IConsole),
3843	getStaticComponentName(),
3844	(enmVMState == VMSTATE_RUNNING_LS) ? Utf8Str(tr("Cannot change drive during live migration")) : Utf8Str(tr("Cannot change drive during fault tolerant syncing")),
3845	false /aWarning/,
3846	true /aLogIt/);
3847
3848	default:
3849	AssertMsgFailedReturn(("enmVMState=%d\n", enmVMState), VERR_ACCESS_DENIED);
3850	}
3851
3852	/* Determine the base path for the device instance. */
3853	PCFGMNODE pCtlInst;
3854	pCtlInst = CFGMR3GetChildF(CFGMR3GetRootU(pUVM), "Devices/%s/%u/", pcszDevice, uInstance);
3855	AssertReturn(pCtlInst, VERR_INTERNAL_ERROR);
3856
3857	int rc = VINF_SUCCESS;
3858	int rcRet = VINF_SUCCESS;
3859
3860	rcRet = pConsole->configMediumAttachment(pCtlInst,
3861	pcszDevice,
3862	uInstance,
3863	enmBus,
3864	fUseHostIOCache,
3865	false /* fSetupMerge */,
3866	false /* fBuiltinIOCache */,
3867	0 /* uMergeSource */,
3868	0 /* uMergeTarget */,
3869	aMediumAtt,
3870	pConsole->mMachineState,
3871	NULL /* phrc */,
3872	true /* fAttachDetach */,
3873	fForce /* fForceUnmount */,
3874	false /* fHotplug */,
3875	pUVM,
3876	NULL /* paLedDevType */);
3877	/** @todo this dumps everything attached to this device instance, which
3878	* is more than necessary. Dumping the changed LUN would be enough. */
3879	CFGMR3Dump(pCtlInst);
3880
3881	/*
3882	* Resume the VM if necessary.
3883	*/
3884	if (fResume)
3885	{
3886	LogFlowFunc(("Resuming the VM...\n"));
3887	/* disable the callback to prevent Console-level state change */
3888	pConsole->mVMStateChangeCallbackDisabled = true;
3889	rc = VMR3Resume(pUVM);
3890	pConsole->mVMStateChangeCallbackDisabled = false;
3891	AssertRC(rc);
3892	if (RT_FAILURE(rc))
3893	{
3894	/* too bad, we failed. try to sync the console state with the VMM state */
3895	vmstateChangeCallback(pUVM, VMSTATE_SUSPENDED, enmVMState, pConsole);
3896	}
3897	/// @todo (r=dmik) if we failed with drive mount, then the VMR3Resume
3898	// error (if any) will be hidden from the caller. For proper reporting
3899	// of such multiple errors to the caller we need to enhance the
3900	// IVirtualBoxError interface. For now, give the first error the higher
3901	// priority.
3902	if (RT_SUCCESS(rcRet))
3903	rcRet = rc;
3904	}
3905
3906	LogFlowFunc(("Returning %Rrc\n", rcRet));
3907	return rcRet;
3908	}
3909
3910
3911	/**
3912	* Attach a new storage device to the VM.
3913	*
3914	* @param aMediumAttachment The medium attachment which is added.
3915	* @param pUVM Safe VM handle.
3916	* @param fSilent Flag whether to notify the guest about the attached device.
3917	*
3918	* @note Locks this object for writing.
3919	*/
3920	HRESULT Console::doStorageDeviceAttach(IMediumAttachment *aMediumAttachment, PUVM pUVM, bool fSilent)
3921	{
3922	AutoCaller autoCaller(this);
3923	AssertComRCReturnRC(autoCaller.rc());
3924
3925	/* We will need to release the write lock before calling EMT */
3926	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3927
3928	HRESULT rc = S_OK;
3929	const char *pszDevice = NULL;
3930
3931	SafeIfaceArray<IStorageController> ctrls;
3932	rc = mMachine->COMGETTER(StorageControllers)(ComSafeArrayAsOutParam(ctrls));
3933	AssertComRC(rc);
3934	IMedium *pMedium;
3935	rc = aMediumAttachment->COMGETTER(Medium)(&pMedium);
3936	AssertComRC(rc);
3937	Bstr mediumLocation;
3938	if (pMedium)
3939	{
3940	rc = pMedium->COMGETTER(Location)(mediumLocation.asOutParam());
3941	AssertComRC(rc);
3942	}
3943
3944	Bstr attCtrlName;
3945	rc = aMediumAttachment->COMGETTER(Controller)(attCtrlName.asOutParam());
3946	AssertComRC(rc);
3947	ComPtr<IStorageController> pStorageController;
3948	for (size_t i = 0; i < ctrls.size(); ++i)
3949	{
3950	Bstr ctrlName;
3951	rc = ctrls[i]->COMGETTER(Name)(ctrlName.asOutParam());
3952	AssertComRC(rc);
3953	if (attCtrlName == ctrlName)
3954	{
3955	pStorageController = ctrls[i];
3956	break;
3957	}
3958	}
3959	if (pStorageController.isNull())
3960	return setError(E_FAIL,
3961	tr("Could not find storage controller '%ls'"), attCtrlName.raw());
3962
3963	StorageControllerType_T enmCtrlType;
3964	rc = pStorageController->COMGETTER(ControllerType)(&enmCtrlType);
3965	AssertComRC(rc);
3966	pszDevice = convertControllerTypeToDev(enmCtrlType);
3967
3968	StorageBus_T enmBus;
3969	rc = pStorageController->COMGETTER(Bus)(&enmBus);
3970	AssertComRC(rc);
3971	ULONG uInstance;
3972	rc = pStorageController->COMGETTER(Instance)(&uInstance);
3973	AssertComRC(rc);
3974	BOOL fUseHostIOCache;
3975	rc = pStorageController->COMGETTER(UseHostIOCache)(&fUseHostIOCache);
3976	AssertComRC(rc);
3977
3978	/*
3979	* Call worker in EMT, that's faster and safer than doing everything
3980	* using VMR3ReqCall. Note that we separate VMR3ReqCall from VMR3ReqWait
3981	* here to make requests from under the lock in order to serialize them.
3982	*/
3983	PVMREQ pReq;
3984	int vrc = VMR3ReqCallU(pUVM,
3985	VMCPUID_ANY,
3986	&pReq,
3987	0 /* no wait! */,
3988	VMREQFLAGS_VBOX_STATUS,
3989	(PFNRT)Console::attachStorageDevice,
3990	8,
3991	this,
3992	pUVM,
3993	pszDevice,
3994	uInstance,
3995	enmBus,
3996	fUseHostIOCache,
3997	aMediumAttachment,
3998	fSilent);
3999
4000	/* release the lock before waiting for a result (EMT will call us back!) */
4001	alock.release();
4002
4003	if (vrc == VERR_TIMEOUT \|\| RT_SUCCESS(vrc))
4004	{
4005	vrc = VMR3ReqWait(pReq, RT_INDEFINITE_WAIT);
4006	AssertRC(vrc);
4007	if (RT_SUCCESS(vrc))
4008	vrc = pReq->iStatus;
4009	}
4010	VMR3ReqFree(pReq);
4011
4012	if (RT_SUCCESS(vrc))
4013	{
4014	LogFlowThisFunc(("Returns S_OK\n"));
4015	return S_OK;
4016	}
4017
4018	if (!pMedium)
4019	return setError(E_FAIL,
4020	tr("Could not mount the media/drive '%ls' (%Rrc)"),
4021	mediumLocation.raw(), vrc);
4022
4023	return setError(E_FAIL,
4024	tr("Could not unmount the currently mounted media/drive (%Rrc)"),
4025	vrc);
4026	}
4027
4028
4029	/**
4030	* Performs the storage attach operation in EMT.
4031	*
4032	* @returns VBox status code.
4033	*
4034	* @param pThis Pointer to the Console object.
4035	* @param pUVM The VM handle.
4036	* @param pcszDevice The PDM device name.
4037	* @param uInstance The PDM device instance.
4038	* @param fSilent Flag whether to inform the guest about the attached device.
4039	*
4040	* @thread EMT
4041	*/
4042	DECLCALLBACK(int) Console::attachStorageDevice(Console *pConsole,
4043	PUVM pUVM,
4044	const char *pcszDevice,
4045	unsigned uInstance,
4046	StorageBus_T enmBus,
4047	bool fUseHostIOCache,
4048	IMediumAttachment *aMediumAtt,
4049	bool fSilent)
4050	{
4051	LogFlowFunc(("pConsole=%p uInstance=%u pszDevice=%p:{%s} enmBus=%u, aMediumAtt=%p\n",
4052	pConsole, uInstance, pcszDevice, pcszDevice, enmBus, aMediumAtt));
4053
4054	AssertReturn(pConsole, VERR_INVALID_PARAMETER);
4055
4056	AutoCaller autoCaller(pConsole);
4057	AssertComRCReturn(autoCaller.rc(), VERR_ACCESS_DENIED);
4058
4059	/*
4060	* Suspend the VM first.
4061	*
4062	* The VM must not be running since it might have pending I/O to
4063	* the drive which is being changed.
4064	*/
4065	bool fResume;
4066	VMSTATE enmVMState = VMR3GetStateU(pUVM);
4067	switch (enmVMState)
4068	{
4069	case VMSTATE_RESETTING:
4070	case VMSTATE_RUNNING:
4071	{
4072	LogFlowFunc(("Suspending the VM...\n"));
4073	/* disable the callback to prevent Console-level state change */
4074	pConsole->mVMStateChangeCallbackDisabled = true;
4075	int rc = VMR3Suspend(pUVM);
4076	pConsole->mVMStateChangeCallbackDisabled = false;
4077	AssertRCReturn(rc, rc);
4078	fResume = true;
4079	break;
4080	}
4081
4082	case VMSTATE_SUSPENDED:
4083	case VMSTATE_CREATED:
4084	case VMSTATE_OFF:
4085	fResume = false;
4086	break;
4087
4088	case VMSTATE_RUNNING_LS:
4089	case VMSTATE_RUNNING_FT:
4090	return setErrorInternal(VBOX_E_INVALID_VM_STATE,
4091	COM_IIDOF(IConsole),
4092	getStaticComponentName(),
4093	(enmVMState == VMSTATE_RUNNING_LS) ? Utf8Str(tr("Cannot change drive during live migration")) : Utf8Str(tr("Cannot change drive during fault tolerant syncing")),
4094	false /aWarning/,
4095	true /aLogIt/);
4096
4097	default:
4098	AssertMsgFailedReturn(("enmVMState=%d\n", enmVMState), VERR_ACCESS_DENIED);
4099	}
4100
4101	/* Determine the base path for the device instance. */
4102	PCFGMNODE pCtlInst;
4103	pCtlInst = CFGMR3GetChildF(CFGMR3GetRootU(pUVM), "Devices/%s/%u/", pcszDevice, uInstance);
4104	AssertReturn(pCtlInst, VERR_INTERNAL_ERROR);
4105
4106	int rc = VINF_SUCCESS;
4107	int rcRet = VINF_SUCCESS;
4108
4109	rcRet = pConsole->configMediumAttachment(pCtlInst,
4110	pcszDevice,
4111	uInstance,
4112	enmBus,
4113	fUseHostIOCache,
4114	false /* fSetupMerge */,
4115	false /* fBuiltinIOCache */,
4116	0 /* uMergeSource */,
4117	0 /* uMergeTarget */,
4118	aMediumAtt,
4119	pConsole->mMachineState,
4120	NULL /* phrc */,
4121	true /* fAttachDetach */,
4122	false /* fForceUnmount */,
4123	!fSilent /* fHotplug */,
4124	pUVM,
4125	NULL /* paLedDevType */);
4126	/** @todo this dumps everything attached to this device instance, which
4127	* is more than necessary. Dumping the changed LUN would be enough. */
4128	CFGMR3Dump(pCtlInst);
4129
4130	/*
4131	* Resume the VM if necessary.
4132	*/
4133	if (fResume)
4134	{
4135	LogFlowFunc(("Resuming the VM...\n"));
4136	/* disable the callback to prevent Console-level state change */
4137	pConsole->mVMStateChangeCallbackDisabled = true;
4138	rc = VMR3Resume(pUVM);
4139	pConsole->mVMStateChangeCallbackDisabled = false;
4140	AssertRC(rc);
4141	if (RT_FAILURE(rc))
4142	{
4143	/* too bad, we failed. try to sync the console state with the VMM state */
4144	vmstateChangeCallback(pUVM, VMSTATE_SUSPENDED, enmVMState, pConsole);
4145	}
4146	/** @todo if we failed with drive mount, then the VMR3Resume
4147	* error (if any) will be hidden from the caller. For proper reporting
4148	* of such multiple errors to the caller we need to enhance the
4149	* IVirtualBoxError interface. For now, give the first error the higher
4150	* priority.
4151	*/
4152	if (RT_SUCCESS(rcRet))
4153	rcRet = rc;
4154	}
4155
4156	LogFlowFunc(("Returning %Rrc\n", rcRet));
4157	return rcRet;
4158	}
4159
4160	/**
4161	* Attach a new storage device to the VM.
4162	*
4163	* @param aMediumAttachment The medium attachment which is added.
4164	* @param pUVM Safe VM handle.
4165	* @param fSilent Flag whether to notify the guest about the detached device.
4166	*
4167	* @note Locks this object for writing.
4168	*/
4169	HRESULT Console::doStorageDeviceDetach(IMediumAttachment *aMediumAttachment, PUVM pUVM, bool fSilent)
4170	{
4171	AutoCaller autoCaller(this);
4172	AssertComRCReturnRC(autoCaller.rc());
4173
4174	/* We will need to release the write lock before calling EMT */
4175	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4176
4177	HRESULT rc = S_OK;
4178	const char *pszDevice = NULL;
4179
4180	SafeIfaceArray<IStorageController> ctrls;
4181	rc = mMachine->COMGETTER(StorageControllers)(ComSafeArrayAsOutParam(ctrls));
4182	AssertComRC(rc);
4183	IMedium *pMedium;
4184	rc = aMediumAttachment->COMGETTER(Medium)(&pMedium);
4185	AssertComRC(rc);
4186	Bstr mediumLocation;
4187	if (pMedium)
4188	{
4189	rc = pMedium->COMGETTER(Location)(mediumLocation.asOutParam());
4190	AssertComRC(rc);
4191	}
4192
4193	Bstr attCtrlName;
4194	rc = aMediumAttachment->COMGETTER(Controller)(attCtrlName.asOutParam());
4195	AssertComRC(rc);
4196	ComPtr<IStorageController> pStorageController;
4197	for (size_t i = 0; i < ctrls.size(); ++i)
4198	{
4199	Bstr ctrlName;
4200	rc = ctrls[i]->COMGETTER(Name)(ctrlName.asOutParam());
4201	AssertComRC(rc);
4202	if (attCtrlName == ctrlName)
4203	{
4204	pStorageController = ctrls[i];
4205	break;
4206	}
4207	}
4208	if (pStorageController.isNull())
4209	return setError(E_FAIL,
4210	tr("Could not find storage controller '%ls'"), attCtrlName.raw());
4211
4212	StorageControllerType_T enmCtrlType;
4213	rc = pStorageController->COMGETTER(ControllerType)(&enmCtrlType);
4214	AssertComRC(rc);
4215	pszDevice = convertControllerTypeToDev(enmCtrlType);
4216
4217	StorageBus_T enmBus;
4218	rc = pStorageController->COMGETTER(Bus)(&enmBus);
4219	AssertComRC(rc);
4220	ULONG uInstance;
4221	rc = pStorageController->COMGETTER(Instance)(&uInstance);
4222	AssertComRC(rc);
4223
4224	/*
4225	* Call worker in EMT, that's faster and safer than doing everything
4226	* using VMR3ReqCall. Note that we separate VMR3ReqCall from VMR3ReqWait
4227	* here to make requests from under the lock in order to serialize them.
4228	*/
4229	PVMREQ pReq;
4230	int vrc = VMR3ReqCallU(pUVM,
4231	VMCPUID_ANY,
4232	&pReq,
4233	0 /* no wait! */,
4234	VMREQFLAGS_VBOX_STATUS,
4235	(PFNRT)Console::detachStorageDevice,
4236	7,
4237	this,
4238	pUVM,
4239	pszDevice,
4240	uInstance,
4241	enmBus,
4242	aMediumAttachment,
4243	fSilent);
4244
4245	/* release the lock before waiting for a result (EMT will call us back!) */
4246	alock.release();
4247
4248	if (vrc == VERR_TIMEOUT \|\| RT_SUCCESS(vrc))
4249	{
4250	vrc = VMR3ReqWait(pReq, RT_INDEFINITE_WAIT);
4251	AssertRC(vrc);
4252	if (RT_SUCCESS(vrc))
4253	vrc = pReq->iStatus;
4254	}
4255	VMR3ReqFree(pReq);
4256
4257	if (RT_SUCCESS(vrc))
4258	{
4259	LogFlowThisFunc(("Returns S_OK\n"));
4260	return S_OK;
4261	}
4262
4263	if (!pMedium)
4264	return setError(E_FAIL,
4265	tr("Could not mount the media/drive '%ls' (%Rrc)"),
4266	mediumLocation.raw(), vrc);
4267
4268	return setError(E_FAIL,
4269	tr("Could not unmount the currently mounted media/drive (%Rrc)"),
4270	vrc);
4271	}
4272
4273	/**
4274	* Performs the storage detach operation in EMT.
4275	*
4276	* @returns VBox status code.
4277	*
4278	* @param pThis Pointer to the Console object.
4279	* @param pUVM The VM handle.
4280	* @param pcszDevice The PDM device name.
4281	* @param uInstance The PDM device instance.
4282	* @param fSilent Flag whether to notify the guest about the detached device.
4283	*
4284	* @thread EMT
4285	*/
4286	DECLCALLBACK(int) Console::detachStorageDevice(Console *pConsole,
4287	PUVM pUVM,
4288	const char *pcszDevice,
4289	unsigned uInstance,
4290	StorageBus_T enmBus,
4291	IMediumAttachment *pMediumAtt,
4292	bool fSilent)
4293	{
4294	LogFlowFunc(("pConsole=%p uInstance=%u pszDevice=%p:{%s} enmBus=%u, pMediumAtt=%p\n",
4295	pConsole, uInstance, pcszDevice, pcszDevice, enmBus, pMediumAtt));
4296
4297	AssertReturn(pConsole, VERR_INVALID_PARAMETER);
4298
4299	AutoCaller autoCaller(pConsole);
4300	AssertComRCReturn(autoCaller.rc(), VERR_ACCESS_DENIED);
4301
4302	/*
4303	* Suspend the VM first.
4304	*
4305	* The VM must not be running since it might have pending I/O to
4306	* the drive which is being changed.
4307	*/
4308	bool fResume;
4309	VMSTATE enmVMState = VMR3GetStateU(pUVM);
4310	switch (enmVMState)
4311	{
4312	case VMSTATE_RESETTING:
4313	case VMSTATE_RUNNING:
4314	{
4315	LogFlowFunc(("Suspending the VM...\n"));
4316	/* disable the callback to prevent Console-level state change */
4317	pConsole->mVMStateChangeCallbackDisabled = true;
4318	int rc = VMR3Suspend(pUVM);
4319	pConsole->mVMStateChangeCallbackDisabled = false;
4320	AssertRCReturn(rc, rc);
4321	fResume = true;
4322	break;
4323	}
4324
4325	case VMSTATE_SUSPENDED:
4326	case VMSTATE_CREATED:
4327	case VMSTATE_OFF:
4328	fResume = false;
4329	break;
4330
4331	case VMSTATE_RUNNING_LS:
4332	case VMSTATE_RUNNING_FT:
4333	return setErrorInternal(VBOX_E_INVALID_VM_STATE,
4334	COM_IIDOF(IConsole),
4335	getStaticComponentName(),
4336	(enmVMState == VMSTATE_RUNNING_LS) ? Utf8Str(tr("Cannot change drive during live migration")) : Utf8Str(tr("Cannot change drive during fault tolerant syncing")),
4337	false /aWarning/,
4338	true /aLogIt/);
4339
4340	default:
4341	AssertMsgFailedReturn(("enmVMState=%d\n", enmVMState), VERR_ACCESS_DENIED);
4342	}
4343
4344	/* Determine the base path for the device instance. */
4345	PCFGMNODE pCtlInst;
4346	pCtlInst = CFGMR3GetChildF(CFGMR3GetRootU(pUVM), "Devices/%s/%u/", pcszDevice, uInstance);
4347	AssertReturn(pCtlInst, VERR_INTERNAL_ERROR);
4348
4349	#define H() AssertMsgReturn(!FAILED(hrc), ("hrc=%Rhrc\n", hrc), VERR_GENERAL_FAILURE)
4350
4351	HRESULT hrc;
4352	int rc = VINF_SUCCESS;
4353	int rcRet = VINF_SUCCESS;
4354	unsigned uLUN;
4355	LONG lDev;
4356	LONG lPort;
4357	DeviceType_T lType;
4358	PCFGMNODE pLunL0 = NULL;
4359	PCFGMNODE pCfg = NULL;
4360
4361	hrc = pMediumAtt->COMGETTER(Device)(&lDev); H();
4362	hrc = pMediumAtt->COMGETTER(Port)(&lPort); H();
4363	hrc = pMediumAtt->COMGETTER(Type)(&lType); H();
4364	hrc = Console::convertBusPortDeviceToLun(enmBus, lPort, lDev, uLUN); H();
4365
4366	#undef H
4367
4368	/* First check if the LUN really exists. */
4369	pLunL0 = CFGMR3GetChildF(pCtlInst, "LUN#%u", uLUN);
4370	if (pLunL0)
4371	{
4372	uint32_t fFlags = 0;
4373
4374	if (fSilent)
4375	fFlags \|= PDM_TACH_FLAGS_NOT_HOT_PLUG;
4376
4377	rc = PDMR3DeviceDetach(pUVM, pcszDevice, uInstance, uLUN, fFlags);
4378	if (rc == VERR_PDM_NO_DRIVER_ATTACHED_TO_LUN)
4379	rc = VINF_SUCCESS;
4380	AssertRCReturn(rc, rc);
4381	CFGMR3RemoveNode(pLunL0);
4382
4383	Utf8Str devicePath = Utf8StrFmt("%s/%u/LUN#%u", pcszDevice, uInstance, uLUN);
4384	pConsole->mapMediumAttachments.erase(devicePath);
4385
4386	}
4387	else
4388	AssertFailedReturn(VERR_INTERNAL_ERROR);
4389
4390	CFGMR3Dump(pCtlInst);
4391
4392	/*
4393	* Resume the VM if necessary.
4394	*/
4395	if (fResume)
4396	{
4397	LogFlowFunc(("Resuming the VM...\n"));
4398	/* disable the callback to prevent Console-level state change */
4399	pConsole->mVMStateChangeCallbackDisabled = true;
4400	rc = VMR3Resume(pUVM);
4401	pConsole->mVMStateChangeCallbackDisabled = false;
4402	AssertRC(rc);
4403	if (RT_FAILURE(rc))
4404	{
4405	/* too bad, we failed. try to sync the console state with the VMM state */
4406	vmstateChangeCallback(pUVM, VMSTATE_SUSPENDED, enmVMState, pConsole);
4407	}
4408	/** @todo: if we failed with drive mount, then the VMR3Resume
4409	* error (if any) will be hidden from the caller. For proper reporting
4410	* of such multiple errors to the caller we need to enhance the
4411	* IVirtualBoxError interface. For now, give the first error the higher
4412	* priority.
4413	*/
4414	if (RT_SUCCESS(rcRet))
4415	rcRet = rc;
4416	}
4417
4418	LogFlowFunc(("Returning %Rrc\n", rcRet));
4419	return rcRet;
4420	}
4421
4422	/**
4423	* Called by IInternalSessionControl::OnNetworkAdapterChange().
4424	*
4425	* @note Locks this object for writing.
4426	*/
4427	HRESULT Console::onNetworkAdapterChange(INetworkAdapter *aNetworkAdapter, BOOL changeAdapter)
4428	{
4429	LogFlowThisFunc(("\n"));
4430
4431	AutoCaller autoCaller(this);
4432	AssertComRCReturnRC(autoCaller.rc());
4433
4434	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4435
4436	HRESULT rc = S_OK;
4437
4438	/* don't trigger network change if the VM isn't running */
4439	SafeVMPtrQuiet ptrVM(this);
4440	if (ptrVM.isOk())
4441	{
4442	/* Get the properties we need from the adapter */
4443	BOOL fCableConnected, fTraceEnabled;
4444	rc = aNetworkAdapter->COMGETTER(CableConnected)(&fCableConnected);
4445	AssertComRC(rc);
4446	if (SUCCEEDED(rc))
4447	{
4448	rc = aNetworkAdapter->COMGETTER(TraceEnabled)(&fTraceEnabled);
4449	AssertComRC(rc);
4450	}
4451	if (SUCCEEDED(rc))
4452	{
4453	ULONG ulInstance;
4454	rc = aNetworkAdapter->COMGETTER(Slot)(&ulInstance);
4455	AssertComRC(rc);
4456	if (SUCCEEDED(rc))
4457	{
4458	/*
4459	* Find the adapter instance, get the config interface and update
4460	* the link state.
4461	*/
4462	NetworkAdapterType_T adapterType;
4463	rc = aNetworkAdapter->COMGETTER(AdapterType)(&adapterType);
4464	AssertComRC(rc);
4465	const char *pszAdapterName = networkAdapterTypeToName(adapterType);
4466
4467	// prevent cross-thread deadlocks, don't need the lock any more
4468	alock.release();
4469
4470	PPDMIBASE pBase;
4471	int vrc = PDMR3QueryDeviceLun(ptrVM.rawUVM(), pszAdapterName, ulInstance, 0, &pBase);
4472	if (RT_SUCCESS(vrc))
4473	{
4474	Assert(pBase);
4475	PPDMINETWORKCONFIG pINetCfg;
4476	pINetCfg = PDMIBASE_QUERY_INTERFACE(pBase, PDMINETWORKCONFIG);
4477	if (pINetCfg)
4478	{
4479	Log(("Console::onNetworkAdapterChange: setting link state to %d\n",
4480	fCableConnected));
4481	vrc = pINetCfg->pfnSetLinkState(pINetCfg,
4482	fCableConnected ? PDMNETWORKLINKSTATE_UP
4483	: PDMNETWORKLINKSTATE_DOWN);
4484	ComAssertRC(vrc);
4485	}
4486	if (RT_SUCCESS(vrc) && changeAdapter)
4487	{
4488	VMSTATE enmVMState = VMR3GetStateU(ptrVM.rawUVM());
4489	if ( enmVMState == VMSTATE_RUNNING /** @todo LiveMigration: Forbid or deal correctly with the _LS variants */
4490	\|\| enmVMState == VMSTATE_SUSPENDED)
4491	{
4492	if (fTraceEnabled && fCableConnected && pINetCfg)
4493	{
4494	vrc = pINetCfg->pfnSetLinkState(pINetCfg, PDMNETWORKLINKSTATE_DOWN);
4495	ComAssertRC(vrc);
4496	}
4497
4498	rc = doNetworkAdapterChange(ptrVM.rawUVM(), pszAdapterName, ulInstance, 0, aNetworkAdapter);
4499
4500	if (fTraceEnabled && fCableConnected && pINetCfg)
4501	{
4502	vrc = pINetCfg->pfnSetLinkState(pINetCfg, PDMNETWORKLINKSTATE_UP);
4503	ComAssertRC(vrc);
4504	}
4505	}
4506	}
4507	}
4508	else if (vrc == VERR_PDM_DEVICE_INSTANCE_NOT_FOUND)
4509	return setError(E_FAIL,
4510	tr("The network adapter #%u is not enabled"), ulInstance);
4511	else
4512	ComAssertRC(vrc);
4513
4514	if (RT_FAILURE(vrc))
4515	rc = E_FAIL;
4516
4517	alock.acquire();
4518	}
4519	}
4520	ptrVM.release();
4521	}
4522
4523	// definitely don't need the lock any more
4524	alock.release();
4525
4526	/* notify console callbacks on success */
4527	if (SUCCEEDED(rc))
4528	fireNetworkAdapterChangedEvent(mEventSource, aNetworkAdapter);
4529
4530	LogFlowThisFunc(("Leaving rc=%#x\n", rc));
4531	return rc;
4532	}
4533
4534	/**
4535	* Called by IInternalSessionControl::OnNATEngineChange().
4536	*
4537	* @note Locks this object for writing.
4538	*/
4539	HRESULT Console::onNATRedirectRuleChange(ULONG ulInstance, BOOL aNatRuleRemove,
4540	NATProtocol_T aProto, IN_BSTR aHostIP, LONG aHostPort, IN_BSTR aGuestIP, LONG aGuestPort)
4541	{
4542	LogFlowThisFunc(("\n"));
4543
4544	AutoCaller autoCaller(this);
4545	AssertComRCReturnRC(autoCaller.rc());
4546
4547	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4548
4549	HRESULT rc = S_OK;
4550
4551	/* don't trigger nat engine change if the VM isn't running */
4552	SafeVMPtrQuiet ptrVM(this);
4553	if (ptrVM.isOk())
4554	{
4555	do
4556	{
4557	ComPtr<INetworkAdapter> pNetworkAdapter;
4558	rc = machine()->GetNetworkAdapter(ulInstance, pNetworkAdapter.asOutParam());
4559	if ( FAILED(rc)
4560	\|\| pNetworkAdapter.isNull())
4561	break;
4562
4563	/*
4564	* Find the adapter instance, get the config interface and update
4565	* the link state.
4566	*/
4567	NetworkAdapterType_T adapterType;
4568	rc = pNetworkAdapter->COMGETTER(AdapterType)(&adapterType);
4569	if (FAILED(rc))
4570	{
4571	AssertComRC(rc);
4572	rc = E_FAIL;
4573	break;
4574	}
4575
4576	const char *pszAdapterName = networkAdapterTypeToName(adapterType);
4577	PPDMIBASE pBase;
4578	int vrc = PDMR3QueryLun(ptrVM.rawUVM(), pszAdapterName, ulInstance, 0, &pBase);
4579	if (RT_FAILURE(vrc))
4580	{
4581	ComAssertRC(vrc);
4582	rc = E_FAIL;
4583	break;
4584	}
4585
4586	NetworkAttachmentType_T attachmentType;
4587	rc = pNetworkAdapter->COMGETTER(AttachmentType)(&attachmentType);
4588	if ( FAILED(rc)
4589	\|\| attachmentType != NetworkAttachmentType_NAT)
4590	{
4591	rc = E_FAIL;
4592	break;
4593	}
4594
4595	/* look down for PDMINETWORKNATCONFIG interface */
4596	PPDMINETWORKNATCONFIG pNetNatCfg = NULL;
4597	while (pBase)
4598	{
4599	pNetNatCfg = (PPDMINETWORKNATCONFIG)pBase->pfnQueryInterface(pBase, PDMINETWORKNATCONFIG_IID);
4600	if (pNetNatCfg)
4601	break;
4602	/** @todo r=bird: This stinks! */
4603	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pBase);
4604	pBase = pDrvIns->pDownBase;
4605	}
4606	if (!pNetNatCfg)
4607	break;
4608
4609	bool fUdp = aProto == NATProtocol_UDP;
4610	vrc = pNetNatCfg->pfnRedirectRuleCommand(pNetNatCfg, !!aNatRuleRemove, fUdp,
4611	Utf8Str(aHostIP).c_str(), aHostPort, Utf8Str(aGuestIP).c_str(),
4612	aGuestPort);
4613	if (RT_FAILURE(vrc))
4614	rc = E_FAIL;
4615	} while (0); /* break loop */
4616	ptrVM.release();
4617	}
4618
4619	LogFlowThisFunc(("Leaving rc=%#x\n", rc));
4620	return rc;
4621	}
4622
4623
4624	/**
4625	* Process a network adaptor change.
4626	*
4627	* @returns COM status code.
4628	*
4629	* @parma pUVM The VM handle (caller hold this safely).
4630	* @param pszDevice The PDM device name.
4631	* @param uInstance The PDM device instance.
4632	* @param uLun The PDM LUN number of the drive.
4633	* @param aNetworkAdapter The network adapter whose attachment needs to be changed
4634	*/
4635	HRESULT Console::doNetworkAdapterChange(PUVM pUVM,
4636	const char *pszDevice,
4637	unsigned uInstance,
4638	unsigned uLun,
4639	INetworkAdapter *aNetworkAdapter)
4640	{
4641	LogFlowThisFunc(("pszDevice=%p:{%s} uInstance=%u uLun=%u aNetworkAdapter=%p\n",
4642	pszDevice, pszDevice, uInstance, uLun, aNetworkAdapter));
4643
4644	AutoCaller autoCaller(this);
4645	AssertComRCReturnRC(autoCaller.rc());
4646
4647	/*
4648	* Call worker in EMT, that's faster and safer than doing everything
4649	* using VM3ReqCall. Note that we separate VMR3ReqCall from VMR3ReqWait
4650	* here to make requests from under the lock in order to serialize them.
4651	*/
4652	PVMREQ pReq;
4653	int vrc = VMR3ReqCallU(pUVM, 0 /idDstCpu/, &pReq, 0 /* no wait! */, VMREQFLAGS_VBOX_STATUS,
4654	(PFNRT)Console::changeNetworkAttachment, 6,
4655	this, pUVM, pszDevice, uInstance, uLun, aNetworkAdapter);
4656
4657	if (vrc == VERR_TIMEOUT \|\| RT_SUCCESS(vrc))
4658	{
4659	vrc = VMR3ReqWait(pReq, RT_INDEFINITE_WAIT);
4660	AssertRC(vrc);
4661	if (RT_SUCCESS(vrc))
4662	vrc = pReq->iStatus;
4663	}
4664	VMR3ReqFree(pReq);
4665
4666	if (RT_SUCCESS(vrc))
4667	{
4668	LogFlowThisFunc(("Returns S_OK\n"));
4669	return S_OK;
4670	}
4671
4672	return setError(E_FAIL,
4673	tr("Could not change the network adaptor attachement type (%Rrc)"),
4674	vrc);
4675	}
4676
4677
4678	/**
4679	* Performs the Network Adaptor change in EMT.
4680	*
4681	* @returns VBox status code.
4682	*
4683	* @param pThis Pointer to the Console object.
4684	* @param pUVM The VM handle.
4685	* @param pszDevice The PDM device name.
4686	* @param uInstance The PDM device instance.
4687	* @param uLun The PDM LUN number of the drive.
4688	* @param aNetworkAdapter The network adapter whose attachment needs to be changed
4689	*
4690	* @thread EMT
4691	* @note Locks the Console object for writing.
4692	*/
4693	DECLCALLBACK(int) Console::changeNetworkAttachment(Console *pThis,
4694	PUVM pUVM,
4695	const char *pszDevice,
4696	unsigned uInstance,
4697	unsigned uLun,
4698	INetworkAdapter *aNetworkAdapter)
4699	{
4700	LogFlowFunc(("pThis=%p pszDevice=%p:{%s} uInstance=%u uLun=%u aNetworkAdapter=%p\n",
4701	pThis, pszDevice, pszDevice, uInstance, uLun, aNetworkAdapter));
4702
4703	AssertReturn(pThis, VERR_INVALID_PARAMETER);
4704
4705	AutoCaller autoCaller(pThis);
4706	AssertComRCReturn(autoCaller.rc(), VERR_ACCESS_DENIED);
4707
4708	ComPtr<IVirtualBox> pVirtualBox;
4709	pThis->mMachine->COMGETTER(Parent)(pVirtualBox.asOutParam());
4710	ComPtr<ISystemProperties> pSystemProperties;
4711	if (pVirtualBox)
4712	pVirtualBox->COMGETTER(SystemProperties)(pSystemProperties.asOutParam());
4713	ChipsetType_T chipsetType = ChipsetType_PIIX3;
4714	pThis->mMachine->COMGETTER(ChipsetType)(&chipsetType);
4715	ULONG maxNetworkAdapters = 0;
4716	if (pSystemProperties)
4717	pSystemProperties->GetMaxNetworkAdapters(chipsetType, &maxNetworkAdapters);
4718	AssertMsg( ( !strcmp(pszDevice, "pcnet")
4719	\|\| !strcmp(pszDevice, "e1000")
4720	\|\| !strcmp(pszDevice, "virtio-net"))
4721	&& uLun == 0
4722	&& uInstance < maxNetworkAdapters,
4723	("pszDevice=%s uLun=%d uInstance=%d\n", pszDevice, uLun, uInstance));
4724	Log(("pszDevice=%s uLun=%d uInstance=%d\n", pszDevice, uLun, uInstance));
4725
4726	/*
4727	* Suspend the VM first.
4728	*
4729	* The VM must not be running since it might have pending I/O to
4730	* the drive which is being changed.
4731	*/
4732	bool fResume;
4733	VMSTATE enmVMState = VMR3GetStateU(pUVM);
4734	switch (enmVMState)
4735	{
4736	case VMSTATE_RESETTING:
4737	case VMSTATE_RUNNING:
4738	{
4739	LogFlowFunc(("Suspending the VM...\n"));
4740	/* disable the callback to prevent Console-level state change */
4741	pThis->mVMStateChangeCallbackDisabled = true;
4742	int rc = VMR3Suspend(pUVM);
4743	pThis->mVMStateChangeCallbackDisabled = false;
4744	AssertRCReturn(rc, rc);
4745	fResume = true;
4746	break;
4747	}
4748
4749	case VMSTATE_SUSPENDED:
4750	case VMSTATE_CREATED:
4751	case VMSTATE_OFF:
4752	fResume = false;
4753	break;
4754
4755	default:
4756	AssertLogRelMsgFailedReturn(("enmVMState=%d\n", enmVMState), VERR_ACCESS_DENIED);
4757	}
4758
4759	int rc = VINF_SUCCESS;
4760	int rcRet = VINF_SUCCESS;
4761
4762	PCFGMNODE pCfg = NULL; /* /Devices/Dev/.../Config/ */
4763	PCFGMNODE pLunL0 = NULL; /* /Devices/Dev/0/LUN#0/ */
4764	PCFGMNODE pInst = CFGMR3GetChildF(CFGMR3GetRootU(pUVM), "Devices/%s/%d/", pszDevice, uInstance);
4765	AssertRelease(pInst);
4766
4767	rcRet = pThis->configNetwork(pszDevice, uInstance, uLun, aNetworkAdapter, pCfg, pLunL0, pInst,
4768	true /fAttachDetach/, false /fIgnoreConnectFailure/);
4769
4770	/*
4771	* Resume the VM if necessary.
4772	*/
4773	if (fResume)
4774	{
4775	LogFlowFunc(("Resuming the VM...\n"));
4776	/* disable the callback to prevent Console-level state change */
4777	pThis->mVMStateChangeCallbackDisabled = true;
4778	rc = VMR3Resume(pUVM);
4779	pThis->mVMStateChangeCallbackDisabled = false;
4780	AssertRC(rc);
4781	if (RT_FAILURE(rc))
4782	{
4783	/* too bad, we failed. try to sync the console state with the VMM state */
4784	vmstateChangeCallback(pUVM, VMSTATE_SUSPENDED, enmVMState, pThis);
4785	}
4786	/// @todo (r=dmik) if we failed with drive mount, then the VMR3Resume
4787	// error (if any) will be hidden from the caller. For proper reporting
4788	// of such multiple errors to the caller we need to enhance the
4789	// IVirtualBoxError interface. For now, give the first error the higher
4790	// priority.
4791	if (RT_SUCCESS(rcRet))
4792	rcRet = rc;
4793	}
4794
4795	LogFlowFunc(("Returning %Rrc\n", rcRet));
4796	return rcRet;
4797	}
4798
4799
4800	/**
4801	* Called by IInternalSessionControl::OnSerialPortChange().
4802	*/
4803	HRESULT Console::onSerialPortChange(ISerialPort *aSerialPort)
4804	{
4805	LogFlowThisFunc(("\n"));
4806
4807	AutoCaller autoCaller(this);
4808	AssertComRCReturnRC(autoCaller.rc());
4809
4810	fireSerialPortChangedEvent(mEventSource, aSerialPort);
4811
4812	LogFlowThisFunc(("Leaving rc=%#x\n", S_OK));
4813	return S_OK;
4814	}
4815
4816	/**
4817	* Called by IInternalSessionControl::OnParallelPortChange().
4818	*/
4819	HRESULT Console::onParallelPortChange(IParallelPort *aParallelPort)
4820	{
4821	LogFlowThisFunc(("\n"));
4822
4823	AutoCaller autoCaller(this);
4824	AssertComRCReturnRC(autoCaller.rc());
4825
4826	fireParallelPortChangedEvent(mEventSource, aParallelPort);
4827
4828	LogFlowThisFunc(("Leaving rc=%#x\n", S_OK));
4829	return S_OK;
4830	}
4831
4832	/**
4833	* Called by IInternalSessionControl::OnStorageControllerChange().
4834	*/
4835	HRESULT Console::onStorageControllerChange()
4836	{
4837	LogFlowThisFunc(("\n"));
4838
4839	AutoCaller autoCaller(this);
4840	AssertComRCReturnRC(autoCaller.rc());
4841
4842	fireStorageControllerChangedEvent(mEventSource);
4843
4844	LogFlowThisFunc(("Leaving rc=%#x\n", S_OK));
4845	return S_OK;
4846	}
4847
4848	/**
4849	* Called by IInternalSessionControl::OnMediumChange().
4850	*/
4851	HRESULT Console::onMediumChange(IMediumAttachment *aMediumAttachment, BOOL aForce)
4852	{
4853	LogFlowThisFunc(("\n"));
4854
4855	AutoCaller autoCaller(this);
4856	AssertComRCReturnRC(autoCaller.rc());
4857
4858	HRESULT rc = S_OK;
4859
4860	/* don't trigger medium change if the VM isn't running */
4861	SafeVMPtrQuiet ptrVM(this);
4862	if (ptrVM.isOk())
4863	{
4864	rc = doMediumChange(aMediumAttachment, !!aForce, ptrVM.rawUVM());
4865	ptrVM.release();
4866	}
4867
4868	/* notify console callbacks on success */
4869	if (SUCCEEDED(rc))
4870	fireMediumChangedEvent(mEventSource, aMediumAttachment);
4871
4872	LogFlowThisFunc(("Leaving rc=%#x\n", rc));
4873	return rc;
4874	}
4875
4876	/**
4877	* Called by IInternalSessionControl::OnCPUChange().
4878	*
4879	* @note Locks this object for writing.
4880	*/
4881	HRESULT Console::onCPUChange(ULONG aCPU, BOOL aRemove)
4882	{
4883	LogFlowThisFunc(("\n"));
4884
4885	AutoCaller autoCaller(this);
4886	AssertComRCReturnRC(autoCaller.rc());
4887
4888	HRESULT rc = S_OK;
4889
4890	/* don't trigger CPU change if the VM isn't running */
4891	SafeVMPtrQuiet ptrVM(this);
4892	if (ptrVM.isOk())
4893	{
4894	if (aRemove)
4895	rc = doCPURemove(aCPU, ptrVM.rawUVM());
4896	else
4897	rc = doCPUAdd(aCPU, ptrVM.rawUVM());
4898	ptrVM.release();
4899	}
4900
4901	/* notify console callbacks on success */
4902	if (SUCCEEDED(rc))
4903	fireCPUChangedEvent(mEventSource, aCPU, aRemove);
4904
4905	LogFlowThisFunc(("Leaving rc=%#x\n", rc));
4906	return rc;
4907	}
4908
4909	/**
4910	* Called by IInternalSessionControl::OnCpuExecutionCapChange().
4911	*
4912	* @note Locks this object for writing.
4913	*/
4914	HRESULT Console::onCPUExecutionCapChange(ULONG aExecutionCap)
4915	{
4916	LogFlowThisFunc(("\n"));
4917
4918	AutoCaller autoCaller(this);
4919	AssertComRCReturnRC(autoCaller.rc());
4920
4921	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4922
4923	HRESULT rc = S_OK;
4924
4925	/* don't trigger the CPU priority change if the VM isn't running */
4926	SafeVMPtrQuiet ptrVM(this);
4927	if (ptrVM.isOk())
4928	{
4929	if ( mMachineState == MachineState_Running
4930	\|\| mMachineState == MachineState_Teleporting
4931	\|\| mMachineState == MachineState_LiveSnapshotting
4932	)
4933	{
4934	/* No need to call in the EMT thread. */
4935	rc = VMR3SetCpuExecutionCap(ptrVM.rawUVM(), aExecutionCap);
4936	}
4937	else
4938	rc = setInvalidMachineStateError();
4939	ptrVM.release();
4940	}
4941
4942	/* notify console callbacks on success */
4943	if (SUCCEEDED(rc))
4944	{
4945	alock.release();
4946	fireCPUExecutionCapChangedEvent(mEventSource, aExecutionCap);
4947	}
4948
4949	LogFlowThisFunc(("Leaving rc=%#x\n", rc));
4950	return rc;
4951	}
4952
4953	/**
4954	* Called by IInternalSessionControl::OnClipboardModeChange().
4955	*
4956	* @note Locks this object for writing.
4957	*/
4958	HRESULT Console::onClipboardModeChange(ClipboardMode_T aClipboardMode)
4959	{
4960	LogFlowThisFunc(("\n"));
4961
4962	AutoCaller autoCaller(this);
4963	AssertComRCReturnRC(autoCaller.rc());
4964
4965	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4966
4967	HRESULT rc = S_OK;
4968
4969	/* don't trigger the Clipboard mode change if the VM isn't running */
4970	SafeVMPtrQuiet ptrVM(this);
4971	if (ptrVM.isOk())
4972	{
4973	if ( mMachineState == MachineState_Running
4974	\|\| mMachineState == MachineState_Teleporting
4975	\|\| mMachineState == MachineState_LiveSnapshotting)
4976	changeClipboardMode(aClipboardMode);
4977	else
4978	rc = setInvalidMachineStateError();
4979	ptrVM.release();
4980	}
4981
4982	/* notify console callbacks on success */
4983	if (SUCCEEDED(rc))
4984	{
4985	alock.release();
4986	fireClipboardModeChangedEvent(mEventSource, aClipboardMode);
4987	}
4988
4989	LogFlowThisFunc(("Leaving rc=%#x\n", rc));
4990	return rc;
4991	}
4992
4993	/**
4994	* Called by IInternalSessionControl::OnDragAndDropModeChange().
4995	*
4996	* @note Locks this object for writing.
4997	*/
4998	HRESULT Console::onDragAndDropModeChange(DragAndDropMode_T aDragAndDropMode)
4999	{
5000	LogFlowThisFunc(("\n"));
5001
5002	AutoCaller autoCaller(this);
5003	AssertComRCReturnRC(autoCaller.rc());
5004
5005	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5006
5007	HRESULT rc = S_OK;
5008
5009	/* don't trigger the Drag'n'drop mode change if the VM isn't running */
5010	SafeVMPtrQuiet ptrVM(this);
5011	if (ptrVM.isOk())
5012	{
5013	if ( mMachineState == MachineState_Running
5014	\|\| mMachineState == MachineState_Teleporting
5015	\|\| mMachineState == MachineState_LiveSnapshotting)
5016	changeDragAndDropMode(aDragAndDropMode);
5017	else
5018	rc = setInvalidMachineStateError();
5019	ptrVM.release();
5020	}
5021
5022	/* notify console callbacks on success */
5023	if (SUCCEEDED(rc))
5024	{
5025	alock.release();
5026	fireDragAndDropModeChangedEvent(mEventSource, aDragAndDropMode);
5027	}
5028
5029	LogFlowThisFunc(("Leaving rc=%#x\n", rc));
5030	return rc;
5031	}
5032
5033	/**
5034	* Called by IInternalSessionControl::OnVRDEServerChange().
5035	*
5036	* @note Locks this object for writing.
5037	*/
5038	HRESULT Console::onVRDEServerChange(BOOL aRestart)
5039	{
5040	AutoCaller autoCaller(this);
5041	AssertComRCReturnRC(autoCaller.rc());
5042
5043	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5044
5045	HRESULT rc = S_OK;
5046
5047	if ( mVRDEServer
5048	&& ( mMachineState == MachineState_Running
5049	\|\| mMachineState == MachineState_Teleporting
5050	\|\| mMachineState == MachineState_LiveSnapshotting
5051	)
5052	)
5053	{
5054	BOOL vrdpEnabled = FALSE;
5055
5056	rc = mVRDEServer->COMGETTER(Enabled)(&vrdpEnabled);
5057	ComAssertComRCRetRC(rc);
5058
5059	if (aRestart)
5060	{
5061	/* VRDP server may call this Console object back from other threads (VRDP INPUT or OUTPUT). */
5062	alock.release();
5063
5064	if (vrdpEnabled)
5065	{
5066	// If there was no VRDP server started the 'stop' will do nothing.
5067	// However if a server was started and this notification was called,
5068	// we have to restart the server.
5069	mConsoleVRDPServer->Stop();
5070
5071	if (RT_FAILURE(mConsoleVRDPServer->Launch()))
5072	rc = E_FAIL;
5073	else
5074	mConsoleVRDPServer->EnableConnections();
5075	}
5076	else
5077	{
5078	mConsoleVRDPServer->Stop();
5079	}
5080
5081	alock.acquire();
5082	}
5083	}
5084
5085	/* notify console callbacks on success */
5086	if (SUCCEEDED(rc))
5087	{
5088	alock.release();
5089	fireVRDEServerChangedEvent(mEventSource);
5090	}
5091
5092	return rc;
5093	}
5094
5095	void Console::onVRDEServerInfoChange()
5096	{
5097	AutoCaller autoCaller(this);
5098	AssertComRCReturnVoid(autoCaller.rc());
5099
5100	fireVRDEServerInfoChangedEvent(mEventSource);
5101	}
5102
5103
5104	/**
5105	* Called by IInternalSessionControl::OnUSBControllerChange().
5106	*/
5107	HRESULT Console::onUSBControllerChange()
5108	{
5109	LogFlowThisFunc(("\n"));
5110
5111	AutoCaller autoCaller(this);
5112	AssertComRCReturnRC(autoCaller.rc());
5113
5114	fireUSBControllerChangedEvent(mEventSource);
5115
5116	return S_OK;
5117	}
5118
5119	/**
5120	* Called by IInternalSessionControl::OnSharedFolderChange().
5121	*
5122	* @note Locks this object for writing.
5123	*/
5124	HRESULT Console::onSharedFolderChange(BOOL aGlobal)
5125	{
5126	LogFlowThisFunc(("aGlobal=%RTbool\n", aGlobal));
5127
5128	AutoCaller autoCaller(this);
5129	AssertComRCReturnRC(autoCaller.rc());
5130
5131	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5132
5133	HRESULT rc = fetchSharedFolders(aGlobal);
5134
5135	/* notify console callbacks on success */
5136	if (SUCCEEDED(rc))
5137	{
5138	alock.release();
5139	fireSharedFolderChangedEvent(mEventSource, aGlobal ? (Scope_T)Scope_Global : (Scope_T)Scope_Machine);
5140	}
5141
5142	return rc;
5143	}
5144
5145	/**
5146	* Called by IInternalSessionControl::OnUSBDeviceAttach() or locally by
5147	* processRemoteUSBDevices() after IInternalMachineControl::RunUSBDeviceFilters()
5148	* returns TRUE for a given remote USB device.
5149	*
5150	* @return S_OK if the device was attached to the VM.
5151	* @return failure if not attached.
5152	*
5153	* @param aDevice
5154	* The device in question.
5155	* @param aMaskedIfs
5156	* The interfaces to hide from the guest.
5157	*
5158	* @note Locks this object for writing.
5159	*/
5160	HRESULT Console::onUSBDeviceAttach(IUSBDevice aDevice, IVirtualBoxErrorInfo aError, ULONG aMaskedIfs)
5161	{
5162	#ifdef VBOX_WITH_USB
5163	LogFlowThisFunc(("aDevice=%p aError=%p\n", aDevice, aError));
5164
5165	AutoCaller autoCaller(this);
5166	ComAssertComRCRetRC(autoCaller.rc());
5167
5168	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5169
5170	/* Get the VM pointer (we don't need error info, since it's a callback). */
5171	SafeVMPtrQuiet ptrVM(this);
5172	if (!ptrVM.isOk())
5173	{
5174	/* The VM may be no more operational when this message arrives
5175	* (e.g. it may be Saving or Stopping or just PoweredOff) --
5176	* autoVMCaller.rc() will return a failure in this case. */
5177	LogFlowThisFunc(("Attach request ignored (mMachineState=%d).\n",
5178	mMachineState));
5179	return ptrVM.rc();
5180	}
5181
5182	if (aError != NULL)
5183	{
5184	/* notify callbacks about the error */
5185	alock.release();
5186	onUSBDeviceStateChange(aDevice, true /* aAttached */, aError);
5187	return S_OK;
5188	}
5189
5190	/* Don't proceed unless there's at least one USB hub. */
5191	if (!PDMR3UsbHasHub(ptrVM.rawUVM()))
5192	{
5193	LogFlowThisFunc(("Attach request ignored (no USB controller).\n"));
5194	return E_FAIL;
5195	}
5196
5197	alock.release();
5198	HRESULT rc = attachUSBDevice(aDevice, aMaskedIfs);
5199	if (FAILED(rc))
5200	{
5201	/* take the current error info */
5202	com::ErrorInfoKeeper eik;
5203	/* the error must be a VirtualBoxErrorInfo instance */
5204	ComPtr<IVirtualBoxErrorInfo> pError = eik.takeError();
5205	Assert(!pError.isNull());
5206	if (!pError.isNull())
5207	{
5208	/* notify callbacks about the error */
5209	onUSBDeviceStateChange(aDevice, true /* aAttached */, pError);
5210	}
5211	}
5212
5213	return rc;
5214
5215	#else /* !VBOX_WITH_USB */
5216	return E_FAIL;
5217	#endif /* !VBOX_WITH_USB */
5218	}
5219
5220	/**
5221	* Called by IInternalSessionControl::OnUSBDeviceDetach() and locally by
5222	* processRemoteUSBDevices().
5223	*
5224	* @note Locks this object for writing.
5225	*/
5226	HRESULT Console::onUSBDeviceDetach(IN_BSTR aId,
5227	IVirtualBoxErrorInfo *aError)
5228	{
5229	#ifdef VBOX_WITH_USB
5230	Guid Uuid(aId);
5231	LogFlowThisFunc(("aId={%RTuuid} aError=%p\n", Uuid.raw(), aError));
5232
5233	AutoCaller autoCaller(this);
5234	AssertComRCReturnRC(autoCaller.rc());
5235
5236	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5237
5238	/* Find the device. */
5239	ComObjPtr<OUSBDevice> pUSBDevice;
5240	USBDeviceList::iterator it = mUSBDevices.begin();
5241	while (it != mUSBDevices.end())
5242	{
5243	LogFlowThisFunc(("it={%RTuuid}\n", (*it)->id().raw()));
5244	if ((*it)->id() == Uuid)
5245	{
5246	pUSBDevice = *it;
5247	break;
5248	}
5249	++it;
5250	}
5251
5252
5253	if (pUSBDevice.isNull())
5254	{
5255	LogFlowThisFunc(("USB device not found.\n"));
5256
5257	/* The VM may be no more operational when this message arrives
5258	* (e.g. it may be Saving or Stopping or just PoweredOff). Use
5259	* AutoVMCaller to detect it -- AutoVMCaller::rc() will return a
5260	* failure in this case. */
5261
5262	AutoVMCallerQuiet autoVMCaller(this);
5263	if (FAILED(autoVMCaller.rc()))
5264	{
5265	LogFlowThisFunc(("Detach request ignored (mMachineState=%d).\n",
5266	mMachineState));
5267	return autoVMCaller.rc();
5268	}
5269
5270	/* the device must be in the list otherwise */
5271	AssertFailedReturn(E_FAIL);
5272	}
5273
5274	if (aError != NULL)
5275	{
5276	/* notify callback about an error */
5277	alock.release();
5278	onUSBDeviceStateChange(pUSBDevice, false /* aAttached */, aError);
5279	return S_OK;
5280	}
5281
5282	/* Remove the device from the collection, it is re-added below for failures */
5283	mUSBDevices.erase(it);
5284
5285	alock.release();
5286	HRESULT rc = detachUSBDevice(pUSBDevice);
5287	if (FAILED(rc))
5288	{
5289	/* Re-add the device to the collection */
5290	alock.acquire();
5291	mUSBDevices.push_back(pUSBDevice);
5292	alock.release();
5293	/* take the current error info */
5294	com::ErrorInfoKeeper eik;
5295	/* the error must be a VirtualBoxErrorInfo instance */
5296	ComPtr<IVirtualBoxErrorInfo> pError = eik.takeError();
5297	Assert(!pError.isNull());
5298	if (!pError.isNull())
5299	{
5300	/* notify callbacks about the error */
5301	onUSBDeviceStateChange(pUSBDevice, false /* aAttached */, pError);
5302	}
5303	}
5304
5305	return rc;
5306
5307	#else /* !VBOX_WITH_USB */
5308	return E_FAIL;
5309	#endif /* !VBOX_WITH_USB */
5310	}
5311
5312	/**
5313	* Called by IInternalSessionControl::OnBandwidthGroupChange().
5314	*
5315	* @note Locks this object for writing.
5316	*/
5317	HRESULT Console::onBandwidthGroupChange(IBandwidthGroup *aBandwidthGroup)
5318	{
5319	LogFlowThisFunc(("\n"));
5320
5321	AutoCaller autoCaller(this);
5322	AssertComRCReturnRC(autoCaller.rc());
5323
5324	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5325
5326	HRESULT rc = S_OK;
5327
5328	/* don't trigger the CPU priority change if the VM isn't running */
5329	SafeVMPtrQuiet ptrVM(this);
5330	if (ptrVM.isOk())
5331	{
5332	if ( mMachineState == MachineState_Running
5333	\|\| mMachineState == MachineState_Teleporting
5334	\|\| mMachineState == MachineState_LiveSnapshotting
5335	)
5336	{
5337	/* No need to call in the EMT thread. */
5338	LONG64 cMax;
5339	Bstr strName;
5340	BandwidthGroupType_T enmType;
5341	rc = aBandwidthGroup->COMGETTER(Name)(strName.asOutParam());
5342	if (SUCCEEDED(rc))
5343	rc = aBandwidthGroup->COMGETTER(MaxBytesPerSec)(&cMax);
5344	if (SUCCEEDED(rc))
5345	rc = aBandwidthGroup->COMGETTER(Type)(&enmType);
5346
5347	if (SUCCEEDED(rc))
5348	{
5349	int vrc = VINF_SUCCESS;
5350	if (enmType == BandwidthGroupType_Disk)
5351	vrc = PDMR3AsyncCompletionBwMgrSetMaxForFile(ptrVM.rawUVM(), Utf8Str(strName).c_str(), cMax);
5352	#ifdef VBOX_WITH_NETSHAPER
5353	else if (enmType == BandwidthGroupType_Network)
5354	vrc = PDMR3NsBwGroupSetLimit(ptrVM.rawUVM(), Utf8Str(strName).c_str(), cMax);
5355	else
5356	rc = E_NOTIMPL;
5357	#endif /* VBOX_WITH_NETSHAPER */
5358	AssertRC(vrc);
5359	}
5360	}
5361	else
5362	rc = setInvalidMachineStateError();
5363	ptrVM.release();
5364	}
5365
5366	/* notify console callbacks on success */
5367	if (SUCCEEDED(rc))
5368	{
5369	alock.release();
5370	fireBandwidthGroupChangedEvent(mEventSource, aBandwidthGroup);
5371	}
5372
5373	LogFlowThisFunc(("Leaving rc=%#x\n", rc));
5374	return rc;
5375	}
5376
5377	/**
5378	* Called by IInternalSessionControl::OnStorageDeviceChange().
5379	*
5380	* @note Locks this object for writing.
5381	*/
5382	HRESULT Console::onStorageDeviceChange(IMediumAttachment *aMediumAttachment, BOOL aRemove, BOOL aSilent)
5383	{
5384	LogFlowThisFunc(("\n"));
5385
5386	AutoCaller autoCaller(this);
5387	AssertComRCReturnRC(autoCaller.rc());
5388
5389	HRESULT rc = S_OK;
5390
5391	/* don't trigger medium change if the VM isn't running */
5392	SafeVMPtrQuiet ptrVM(this);
5393	if (ptrVM.isOk())
5394	{
5395	if (aRemove)
5396	rc = doStorageDeviceDetach(aMediumAttachment, ptrVM.rawUVM(), aSilent);
5397	else
5398	rc = doStorageDeviceAttach(aMediumAttachment, ptrVM.rawUVM(), aSilent);
5399	ptrVM.release();
5400	}
5401
5402	/* notify console callbacks on success */
5403	if (SUCCEEDED(rc))
5404	fireStorageDeviceChangedEvent(mEventSource, aMediumAttachment, aRemove, aSilent);
5405
5406	LogFlowThisFunc(("Leaving rc=%#x\n", rc));
5407	return rc;
5408	}
5409
5410	/**
5411	* @note Temporarily locks this object for writing.
5412	*/
5413	HRESULT Console::getGuestProperty(IN_BSTR aName, BSTR *aValue,
5414	LONG64 aTimestamp, BSTR aFlags)
5415	{
5416	#ifndef VBOX_WITH_GUEST_PROPS
5417	ReturnComNotImplemented();
5418	#else /* VBOX_WITH_GUEST_PROPS */
5419	if (!VALID_PTR(aName))
5420	return E_INVALIDARG;
5421	if (!VALID_PTR(aValue))
5422	return E_POINTER;
5423	if ((aTimestamp != NULL) && !VALID_PTR(aTimestamp))
5424	return E_POINTER;
5425	if ((aFlags != NULL) && !VALID_PTR(aFlags))
5426	return E_POINTER;
5427
5428	AutoCaller autoCaller(this);
5429	AssertComRCReturnRC(autoCaller.rc());
5430
5431	/* protect mpUVM (if not NULL) */
5432	SafeVMPtrQuiet ptrVM(this);
5433	if (FAILED(ptrVM.rc()))
5434	return ptrVM.rc();
5435
5436	/* Note: validity of mVMMDev which is bound to uninit() is guaranteed by
5437	* ptrVM, so there is no need to hold a lock of this */
5438
5439	HRESULT rc = E_UNEXPECTED;
5440	using namespace guestProp;
5441
5442	try
5443	{
5444	VBOXHGCMSVCPARM parm[4];
5445	Utf8Str Utf8Name = aName;
5446	char szBuffer[MAX_VALUE_LEN + MAX_FLAGS_LEN];
5447
5448	parm[0].type = VBOX_HGCM_SVC_PARM_PTR;
5449	parm[0].u.pointer.addr = (void*)Utf8Name.c_str();
5450	/* The + 1 is the null terminator */
5451	parm[0].u.pointer.size = (uint32_t)Utf8Name.length() + 1;
5452	parm[1].type = VBOX_HGCM_SVC_PARM_PTR;
5453	parm[1].u.pointer.addr = szBuffer;
5454	parm[1].u.pointer.size = sizeof(szBuffer);
5455	int vrc = m_pVMMDev->hgcmHostCall("VBoxGuestPropSvc", GET_PROP_HOST,
5456	4, &parm[0]);
5457	/* The returned string should never be able to be greater than our buffer */
5458	AssertLogRel(vrc != VERR_BUFFER_OVERFLOW);
5459	AssertLogRel(RT_FAILURE(vrc) \|\| VBOX_HGCM_SVC_PARM_64BIT == parm[2].type);
5460	if (RT_SUCCESS(vrc) \|\| (VERR_NOT_FOUND == vrc))
5461	{
5462	rc = S_OK;
5463	if (vrc != VERR_NOT_FOUND)
5464	{
5465	Utf8Str strBuffer(szBuffer);
5466	strBuffer.cloneTo(aValue);
5467
5468	if (aTimestamp)
5469	*aTimestamp = parm[2].u.uint64;
5470
5471	if (aFlags)
5472	{
5473	size_t iFlags = strBuffer.length() + 1;
5474	Utf8Str(szBuffer + iFlags).cloneTo(aFlags);
5475	}
5476	}
5477	else
5478	aValue = NULL;
5479	}
5480	else
5481	rc = setError(E_UNEXPECTED,
5482	tr("The service call failed with the error %Rrc"),
5483	vrc);
5484	}
5485	catch(std::bad_alloc & /e/)
5486	{
5487	rc = E_OUTOFMEMORY;
5488	}
5489	return rc;
5490	#endif /* VBOX_WITH_GUEST_PROPS */
5491	}
5492
5493	/**
5494	* @note Temporarily locks this object for writing.
5495	*/
5496	HRESULT Console::setGuestProperty(IN_BSTR aName, IN_BSTR aValue, IN_BSTR aFlags)
5497	{
5498	#ifndef VBOX_WITH_GUEST_PROPS
5499	ReturnComNotImplemented();
5500	#else /* VBOX_WITH_GUEST_PROPS */
5501	if (!RT_VALID_PTR(aName))
5502	/** @todo replace hardcoded constants with E_INVALIDARG once testboxes has
5503	* been debugged. */
5504	return setError(0x80face00, tr("Name cannot be NULL or an invalid pointer"));
5505	if (aValue != NULL && !RT_VALID_PTR(aValue))
5506	return setError(0x80face01, tr("Invalid value pointer"));
5507	if (aFlags != NULL && !RT_VALID_PTR(aFlags))
5508	return setError(0x80face02, tr("Invalid flags pointer"));
5509
5510	AutoCaller autoCaller(this);
5511	AssertComRCReturnRC(autoCaller.rc());
5512
5513	/* protect mpUVM (if not NULL) */
5514	SafeVMPtrQuiet ptrVM(this);
5515	if (FAILED(ptrVM.rc()))
5516	{
5517	LogRel(("Console::setGuestProperty1: %ls -> %Rhrc\n", aName, ptrVM.rc())); /* !REMOVE ME! Debugging testboxes! */
5518	return ptrVM.rc();
5519	}
5520
5521	/* Note: validity of mVMMDev which is bound to uninit() is guaranteed by
5522	* ptrVM, so there is no need to hold a lock of this */
5523
5524	using namespace guestProp;
5525
5526	VBOXHGCMSVCPARM parm[3];
5527
5528	Utf8Str Utf8Name = aName;
5529	parm[0].type = VBOX_HGCM_SVC_PARM_PTR;
5530	parm[0].u.pointer.addr = (void*)Utf8Name.c_str();
5531	/* The + 1 is the null terminator */
5532	parm[0].u.pointer.size = (uint32_t)Utf8Name.length() + 1;
5533
5534	Utf8Str Utf8Value;
5535	if (aValue != NULL)
5536	{
5537	Utf8Value = aValue;
5538	parm[1].type = VBOX_HGCM_SVC_PARM_PTR;
5539	parm[1].u.pointer.addr = (void *)Utf8Value.c_str();
5540	/* The + 1 is the null terminator */
5541	parm[1].u.pointer.size = (uint32_t)Utf8Value.length() + 1;
5542	}
5543
5544	Utf8Str Utf8Flags;
5545	if (aFlags != NULL)
5546	{
5547	Utf8Flags = aFlags;
5548	parm[2].type = VBOX_HGCM_SVC_PARM_PTR;
5549	parm[2].u.pointer.addr = (void*)Utf8Flags.c_str();
5550	/* The + 1 is the null terminator */
5551	parm[2].u.pointer.size = (uint32_t)Utf8Flags.length() + 1;
5552	}
5553
5554	int vrc;
5555	if (aValue != NULL && aFlags != NULL)
5556	vrc = m_pVMMDev->hgcmHostCall("VBoxGuestPropSvc", SET_PROP_HOST,
5557	3, &parm[0]);
5558	else if (aValue != NULL)
5559	vrc = m_pVMMDev->hgcmHostCall("VBoxGuestPropSvc", SET_PROP_VALUE_HOST,
5560	2, &parm[0]);
5561	else
5562	vrc = m_pVMMDev->hgcmHostCall("VBoxGuestPropSvc", DEL_PROP_HOST,
5563	1, &parm[0]);
5564	HRESULT hrc;
5565	if (RT_SUCCESS(vrc))
5566	hrc = S_OK;
5567	else
5568	{
5569	LogRel(("Console::setGuestProperty2: %ls -> %Rrc\n", aName, vrc)); /* !REMOVE ME! Debugging testboxes! */
5570	hrc = setError(E_UNEXPECTED, tr("The service call failed with the error %Rrc"), vrc);
5571	}
5572	return hrc;
5573	#endif /* VBOX_WITH_GUEST_PROPS */
5574	}
5575
5576
5577	/**
5578	* @note Temporarily locks this object for writing.
5579	*/
5580	HRESULT Console::enumerateGuestProperties(IN_BSTR aPatterns,
5581	ComSafeArrayOut(BSTR, aNames),
5582	ComSafeArrayOut(BSTR, aValues),
5583	ComSafeArrayOut(LONG64, aTimestamps),
5584	ComSafeArrayOut(BSTR, aFlags))
5585	{
5586	#ifndef VBOX_WITH_GUEST_PROPS
5587	ReturnComNotImplemented();
5588	#else /* VBOX_WITH_GUEST_PROPS */
5589	if (!VALID_PTR(aPatterns) && (aPatterns != NULL))
5590	return E_POINTER;
5591	if (ComSafeArrayOutIsNull(aNames))
5592	return E_POINTER;
5593	if (ComSafeArrayOutIsNull(aValues))
5594	return E_POINTER;
5595	if (ComSafeArrayOutIsNull(aTimestamps))
5596	return E_POINTER;
5597	if (ComSafeArrayOutIsNull(aFlags))
5598	return E_POINTER;
5599
5600	AutoCaller autoCaller(this);
5601	AssertComRCReturnRC(autoCaller.rc());
5602
5603	/* protect mpUVM (if not NULL) */
5604	AutoVMCallerWeak autoVMCaller(this);
5605	if (FAILED(autoVMCaller.rc()))
5606	return autoVMCaller.rc();
5607
5608	/* Note: validity of mVMMDev which is bound to uninit() is guaranteed by
5609	* autoVMCaller, so there is no need to hold a lock of this */
5610
5611	return doEnumerateGuestProperties(aPatterns, ComSafeArrayOutArg(aNames),
5612	ComSafeArrayOutArg(aValues),
5613	ComSafeArrayOutArg(aTimestamps),
5614	ComSafeArrayOutArg(aFlags));
5615	#endif /* VBOX_WITH_GUEST_PROPS */
5616	}
5617
5618
5619	/*
5620	* Internal: helper function for connecting progress reporting
5621	*/
5622	static int onlineMergeMediumProgress(void *pvUser, unsigned uPercentage)
5623	{
5624	HRESULT rc = S_OK;
5625	IProgress pProgress = static_cast<IProgress >(pvUser);
5626	if (pProgress)
5627	rc = pProgress->SetCurrentOperationProgress(uPercentage);
5628	return SUCCEEDED(rc) ? VINF_SUCCESS : VERR_GENERAL_FAILURE;
5629	}
5630
5631	/**
5632	* @note Temporarily locks this object for writing. bird: And/or reading?
5633	*/
5634	HRESULT Console::onlineMergeMedium(IMediumAttachment *aMediumAttachment,
5635	ULONG aSourceIdx, ULONG aTargetIdx,
5636	IMedium aSource, IMedium aTarget,
5637	BOOL aMergeForward,
5638	IMedium *aParentForTarget,
5639	ComSafeArrayIn(IMedium *, aChildrenToReparent),
5640	IProgress *aProgress)
5641	{
5642	AutoCaller autoCaller(this);
5643	AssertComRCReturnRC(autoCaller.rc());
5644
5645	HRESULT rc = S_OK;
5646	int vrc = VINF_SUCCESS;
5647
5648	/* Get the VM - must be done before the read-locking. */
5649	SafeVMPtr ptrVM(this);
5650	if (!ptrVM.isOk())
5651	return ptrVM.rc();
5652
5653	/* We will need to release the lock before doing the actual merge */
5654	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5655
5656	/* paranoia - we don't want merges to happen while teleporting etc. */
5657	switch (mMachineState)
5658	{
5659	case MachineState_DeletingSnapshotOnline:
5660	case MachineState_DeletingSnapshotPaused:
5661	break;
5662
5663	default:
5664	return setInvalidMachineStateError();
5665	}
5666
5667	/** @todo AssertComRC -> AssertComRCReturn! Could potentially end up
5668	* using uninitialized variables here. */
5669	BOOL fBuiltinIOCache;
5670	rc = mMachine->COMGETTER(IOCacheEnabled)(&fBuiltinIOCache);
5671	AssertComRC(rc);
5672	SafeIfaceArray<IStorageController> ctrls;
5673	rc = mMachine->COMGETTER(StorageControllers)(ComSafeArrayAsOutParam(ctrls));
5674	AssertComRC(rc);
5675	LONG lDev;
5676	rc = aMediumAttachment->COMGETTER(Device)(&lDev);
5677	AssertComRC(rc);
5678	LONG lPort;
5679	rc = aMediumAttachment->COMGETTER(Port)(&lPort);
5680	AssertComRC(rc);
5681	IMedium *pMedium;
5682	rc = aMediumAttachment->COMGETTER(Medium)(&pMedium);
5683	AssertComRC(rc);
5684	Bstr mediumLocation;
5685	if (pMedium)
5686	{
5687	rc = pMedium->COMGETTER(Location)(mediumLocation.asOutParam());
5688	AssertComRC(rc);
5689	}
5690
5691	Bstr attCtrlName;
5692	rc = aMediumAttachment->COMGETTER(Controller)(attCtrlName.asOutParam());
5693	AssertComRC(rc);
5694	ComPtr<IStorageController> pStorageController;
5695	for (size_t i = 0; i < ctrls.size(); ++i)
5696	{
5697	Bstr ctrlName;
5698	rc = ctrls[i]->COMGETTER(Name)(ctrlName.asOutParam());
5699	AssertComRC(rc);
5700	if (attCtrlName == ctrlName)
5701	{
5702	pStorageController = ctrls[i];
5703	break;
5704	}
5705	}
5706	if (pStorageController.isNull())
5707	return setError(E_FAIL,
5708	tr("Could not find storage controller '%ls'"),
5709	attCtrlName.raw());
5710
5711	StorageControllerType_T enmCtrlType;
5712	rc = pStorageController->COMGETTER(ControllerType)(&enmCtrlType);
5713	AssertComRC(rc);
5714	const char *pcszDevice = convertControllerTypeToDev(enmCtrlType);
5715
5716	StorageBus_T enmBus;
5717	rc = pStorageController->COMGETTER(Bus)(&enmBus);
5718	AssertComRC(rc);
5719	ULONG uInstance;
5720	rc = pStorageController->COMGETTER(Instance)(&uInstance);
5721	AssertComRC(rc);
5722	BOOL fUseHostIOCache;
5723	rc = pStorageController->COMGETTER(UseHostIOCache)(&fUseHostIOCache);
5724	AssertComRC(rc);
5725
5726	unsigned uLUN;
5727	rc = Console::convertBusPortDeviceToLun(enmBus, lPort, lDev, uLUN);
5728	AssertComRCReturnRC(rc);
5729
5730	alock.release();
5731
5732	/* Pause the VM, as it might have pending IO on this drive */
5733	VMSTATE enmVMState = VMR3GetStateU(ptrVM.rawUVM());
5734	if (mMachineState == MachineState_DeletingSnapshotOnline)
5735	{
5736	LogFlowFunc(("Suspending the VM...\n"));
5737	/* disable the callback to prevent Console-level state change */
5738	mVMStateChangeCallbackDisabled = true;
5739	int vrc2 = VMR3Suspend(ptrVM.rawUVM());
5740	mVMStateChangeCallbackDisabled = false;
5741	AssertRCReturn(vrc2, E_FAIL);
5742	}
5743
5744	vrc = VMR3ReqCallWaitU(ptrVM.rawUVM(),
5745	VMCPUID_ANY,
5746	(PFNRT)reconfigureMediumAttachment,
5747	13,
5748	this,
5749	ptrVM.rawUVM(),
5750	pcszDevice,
5751	uInstance,
5752	enmBus,
5753	fUseHostIOCache,
5754	fBuiltinIOCache,
5755	true /* fSetupMerge */,
5756	aSourceIdx,
5757	aTargetIdx,
5758	aMediumAttachment,
5759	mMachineState,
5760	&rc);
5761	/* error handling is after resuming the VM */
5762
5763	if (mMachineState == MachineState_DeletingSnapshotOnline)
5764	{
5765	LogFlowFunc(("Resuming the VM...\n"));
5766	/* disable the callback to prevent Console-level state change */
5767	mVMStateChangeCallbackDisabled = true;
5768	int vrc2 = VMR3Resume(ptrVM.rawUVM());
5769	mVMStateChangeCallbackDisabled = false;
5770	if (RT_FAILURE(vrc2))
5771	{
5772	/* too bad, we failed. try to sync the console state with the VMM state */
5773	AssertLogRelRC(vrc2);
5774	vmstateChangeCallback(ptrVM.rawUVM(), VMSTATE_SUSPENDED, enmVMState, this);
5775	}
5776	}
5777
5778	if (RT_FAILURE(vrc))
5779	return setError(E_FAIL, tr("%Rrc"), vrc);
5780	if (FAILED(rc))
5781	return rc;
5782
5783	PPDMIBASE pIBase = NULL;
5784	PPDMIMEDIA pIMedium = NULL;
5785	vrc = PDMR3QueryDriverOnLun(ptrVM.rawUVM(), pcszDevice, uInstance, uLUN, "VD", &pIBase);
5786	if (RT_SUCCESS(vrc))
5787	{
5788	if (pIBase)
5789	{
5790	pIMedium = (PPDMIMEDIA)pIBase->pfnQueryInterface(pIBase, PDMIMEDIA_IID);
5791	if (!pIMedium)
5792	return setError(E_FAIL, tr("could not query medium interface of controller"));
5793	}
5794	else
5795	return setError(E_FAIL, tr("could not query base interface of controller"));
5796	}
5797
5798	/* Finally trigger the merge. */
5799	vrc = pIMedium->pfnMerge(pIMedium, onlineMergeMediumProgress, aProgress);
5800	if (RT_FAILURE(vrc))
5801	return setError(E_FAIL, tr("Failed to perform an online medium merge (%Rrc)"), vrc);
5802
5803	/* Pause the VM, as it might have pending IO on this drive */
5804	enmVMState = VMR3GetStateU(ptrVM.rawUVM());
5805	if (mMachineState == MachineState_DeletingSnapshotOnline)
5806	{
5807	LogFlowFunc(("Suspending the VM...\n"));
5808	/* disable the callback to prevent Console-level state change */
5809	mVMStateChangeCallbackDisabled = true;
5810	int vrc2 = VMR3Suspend(ptrVM.rawUVM());
5811	mVMStateChangeCallbackDisabled = false;
5812	AssertRCReturn(vrc2, E_FAIL);
5813	}
5814
5815	/* Update medium chain and state now, so that the VM can continue. */
5816	rc = mControl->FinishOnlineMergeMedium(aMediumAttachment, aSource, aTarget,
5817	aMergeForward, aParentForTarget,
5818	ComSafeArrayInArg(aChildrenToReparent));
5819
5820	vrc = VMR3ReqCallWaitU(ptrVM.rawUVM(),
5821	VMCPUID_ANY,
5822	(PFNRT)reconfigureMediumAttachment,
5823	13,
5824	this,
5825	ptrVM.rawUVM(),
5826	pcszDevice,
5827	uInstance,
5828	enmBus,
5829	fUseHostIOCache,
5830	fBuiltinIOCache,
5831	false /* fSetupMerge */,
5832	0 /* uMergeSource */,
5833	0 /* uMergeTarget */,
5834	aMediumAttachment,
5835	mMachineState,
5836	&rc);
5837	/* error handling is after resuming the VM */
5838
5839	if (mMachineState == MachineState_DeletingSnapshotOnline)
5840	{
5841	LogFlowFunc(("Resuming the VM...\n"));
5842	/* disable the callback to prevent Console-level state change */
5843	mVMStateChangeCallbackDisabled = true;
5844	int vrc2 = VMR3Resume(ptrVM.rawUVM());
5845	mVMStateChangeCallbackDisabled = false;
5846	AssertRC(vrc2);
5847	if (RT_FAILURE(vrc2))
5848	{
5849	/* too bad, we failed. try to sync the console state with the VMM state */
5850	vmstateChangeCallback(ptrVM.rawUVM(), VMSTATE_SUSPENDED, enmVMState, this);
5851	}
5852	}
5853
5854	if (RT_FAILURE(vrc))
5855	return setError(E_FAIL, tr("%Rrc"), vrc);
5856	if (FAILED(rc))
5857	return rc;
5858
5859	return rc;
5860	}
5861
5862
5863	/**
5864	* Merely passes the call to Guest::enableVMMStatistics().
5865	*/
5866	void Console::enableVMMStatistics(BOOL aEnable)
5867	{
5868	if (mGuest)
5869	mGuest->enableVMMStatistics(aEnable);
5870	}
5871
5872	/**
5873	* Gets called by Session::UpdateMachineState()
5874	* (IInternalSessionControl::updateMachineState()).
5875	*
5876	* Must be called only in certain cases (see the implementation).
5877	*
5878	* @note Locks this object for writing.
5879	*/
5880	HRESULT Console::updateMachineState(MachineState_T aMachineState)
5881	{
5882	AutoCaller autoCaller(this);
5883	AssertComRCReturnRC(autoCaller.rc());
5884
5885	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5886
5887	AssertReturn( mMachineState == MachineState_Saving
5888	\|\| mMachineState == MachineState_LiveSnapshotting
5889	\|\| mMachineState == MachineState_RestoringSnapshot
5890	\|\| mMachineState == MachineState_DeletingSnapshot
5891	\|\| mMachineState == MachineState_DeletingSnapshotOnline
5892	\|\| mMachineState == MachineState_DeletingSnapshotPaused
5893	, E_FAIL);
5894
5895	return setMachineStateLocally(aMachineState);
5896	}
5897
5898	#ifdef CONSOLE_WITH_EVENT_CACHE
5899	/**
5900	* @note Locks this object for writing.
5901	*/
5902	#endif
5903	void Console::onMousePointerShapeChange(bool fVisible, bool fAlpha,
5904	uint32_t xHot, uint32_t yHot,
5905	uint32_t width, uint32_t height,
5906	ComSafeArrayIn(BYTE,pShape))
5907	{
5908	#if 0
5909	LogFlowThisFuncEnter();
5910	LogFlowThisFunc(("fVisible=%d, fAlpha=%d, xHot = %d, yHot = %d, width=%d, height=%d, shape=%p\n",
5911	fVisible, fAlpha, xHot, yHot, width, height, pShape));
5912	#endif
5913
5914	AutoCaller autoCaller(this);
5915	AssertComRCReturnVoid(autoCaller.rc());
5916
5917	#ifdef CONSOLE_WITH_EVENT_CACHE
5918	{
5919	/* We need a write lock because we alter the cached callback data */
5920	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5921
5922	/* Save the callback arguments */
5923	mCallbackData.mpsc.visible = fVisible;
5924	mCallbackData.mpsc.alpha = fAlpha;
5925	mCallbackData.mpsc.xHot = xHot;
5926	mCallbackData.mpsc.yHot = yHot;
5927	mCallbackData.mpsc.width = width;
5928	mCallbackData.mpsc.height = height;
5929
5930	/* start with not valid */
5931	bool wasValid = mCallbackData.mpsc.valid;
5932	mCallbackData.mpsc.valid = false;
5933
5934	com::SafeArray<BYTE> aShape(ComSafeArrayInArg(pShape));
5935	if (aShape.size() != 0)
5936	mCallbackData.mpsc.shape.initFrom(aShape);
5937	else
5938	mCallbackData.mpsc.shape.resize(0);
5939	mCallbackData.mpsc.valid = true;
5940	}
5941	#endif
5942
5943	fireMousePointerShapeChangedEvent(mEventSource, fVisible, fAlpha, xHot, yHot, width, height, ComSafeArrayInArg(pShape));
5944
5945	#if 0
5946	LogFlowThisFuncLeave();
5947	#endif
5948	}
5949
5950	#ifdef CONSOLE_WITH_EVENT_CACHE
5951	/**
5952	* @note Locks this object for writing.
5953	*/
5954	#endif
5955	void Console::onMouseCapabilityChange(BOOL supportsAbsolute, BOOL supportsRelative, BOOL needsHostCursor)
5956	{
5957	LogFlowThisFunc(("supportsAbsolute=%d supportsRelative=%d needsHostCursor=%d\n",
5958	supportsAbsolute, supportsRelative, needsHostCursor));
5959
5960	AutoCaller autoCaller(this);
5961	AssertComRCReturnVoid(autoCaller.rc());
5962
5963	#ifdef CONSOLE_WITH_EVENT_CACHE
5964	{
5965	/* We need a write lock because we alter the cached callback data */
5966	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5967
5968	/* save the callback arguments */
5969	mCallbackData.mcc.supportsAbsolute = supportsAbsolute;
5970	mCallbackData.mcc.supportsRelative = supportsRelative;
5971	mCallbackData.mcc.needsHostCursor = needsHostCursor;
5972	mCallbackData.mcc.valid = true;
5973	}
5974	#endif
5975
5976	fireMouseCapabilityChangedEvent(mEventSource, supportsAbsolute, supportsRelative, needsHostCursor);
5977	}
5978
5979	void Console::onStateChange(MachineState_T machineState)
5980	{
5981	AutoCaller autoCaller(this);
5982	AssertComRCReturnVoid(autoCaller.rc());
5983	fireStateChangedEvent(mEventSource, machineState);
5984	}
5985
5986	void Console::onAdditionsStateChange()
5987	{
5988	AutoCaller autoCaller(this);
5989	AssertComRCReturnVoid(autoCaller.rc());
5990
5991	fireAdditionsStateChangedEvent(mEventSource);
5992	}
5993
5994	/**
5995	* @remarks This notification only is for reporting an incompatible
5996	* Guest Additions interface, not the Guest Additions version!
5997	*
5998	* The user will be notified inside the guest if new Guest
5999	* Additions are available (via VBoxTray/VBoxClient).
6000	*/
6001	void Console::onAdditionsOutdated()
6002	{
6003	AutoCaller autoCaller(this);
6004	AssertComRCReturnVoid(autoCaller.rc());
6005
6006	/** @todo implement this */
6007	}
6008
6009	#ifdef CONSOLE_WITH_EVENT_CACHE
6010	/**
6011	* @note Locks this object for writing.
6012	*/
6013	#endif
6014	void Console::onKeyboardLedsChange(bool fNumLock, bool fCapsLock, bool fScrollLock)
6015	{
6016	AutoCaller autoCaller(this);
6017	AssertComRCReturnVoid(autoCaller.rc());
6018
6019	#ifdef CONSOLE_WITH_EVENT_CACHE
6020	{
6021	/* We need a write lock because we alter the cached callback data */
6022	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6023
6024	/* save the callback arguments */
6025	mCallbackData.klc.numLock = fNumLock;
6026	mCallbackData.klc.capsLock = fCapsLock;
6027	mCallbackData.klc.scrollLock = fScrollLock;
6028	mCallbackData.klc.valid = true;
6029	}
6030	#endif
6031
6032	fireKeyboardLedsChangedEvent(mEventSource, fNumLock, fCapsLock, fScrollLock);
6033	}
6034
6035	void Console::onUSBDeviceStateChange(IUSBDevice *aDevice, bool aAttached,
6036	IVirtualBoxErrorInfo *aError)
6037	{
6038	AutoCaller autoCaller(this);
6039	AssertComRCReturnVoid(autoCaller.rc());
6040
6041	fireUSBDeviceStateChangedEvent(mEventSource, aDevice, aAttached, aError);
6042	}
6043
6044	void Console::onRuntimeError(BOOL aFatal, IN_BSTR aErrorID, IN_BSTR aMessage)
6045	{
6046	AutoCaller autoCaller(this);
6047	AssertComRCReturnVoid(autoCaller.rc());
6048
6049	fireRuntimeErrorEvent(mEventSource, aFatal, aErrorID, aMessage);
6050	}
6051
6052	HRESULT Console::onShowWindow(BOOL aCheck, BOOL aCanShow, LONG64 aWinId)
6053	{
6054	AssertReturn(aCanShow, E_POINTER);
6055	AssertReturn(aWinId, E_POINTER);
6056
6057	*aCanShow = FALSE;
6058	*aWinId = 0;
6059
6060	AutoCaller autoCaller(this);
6061	AssertComRCReturnRC(autoCaller.rc());
6062
6063	VBoxEventDesc evDesc;
6064	if (aCheck)
6065	{
6066	evDesc.init(mEventSource, VBoxEventType_OnCanShowWindow);
6067	BOOL fDelivered = evDesc.fire(5000); /* Wait up to 5 secs for delivery */
6068	//Assert(fDelivered);
6069	if (fDelivered)
6070	{
6071	ComPtr<IEvent> pEvent;
6072	evDesc.getEvent(pEvent.asOutParam());
6073	// bit clumsy
6074	ComPtr<ICanShowWindowEvent> pCanShowEvent = pEvent;
6075	if (pCanShowEvent)
6076	{
6077	BOOL fVetoed = FALSE;
6078	pCanShowEvent->IsVetoed(&fVetoed);
6079	*aCanShow = !fVetoed;
6080	}
6081	else
6082	{
6083	AssertFailed();
6084	*aCanShow = TRUE;
6085	}
6086	}
6087	else
6088	*aCanShow = TRUE;
6089	}
6090	else
6091	{
6092	evDesc.init(mEventSource, VBoxEventType_OnShowWindow, INT64_C(0));
6093	BOOL fDelivered = evDesc.fire(5000); /* Wait up to 5 secs for delivery */
6094	//Assert(fDelivered);
6095	if (fDelivered)
6096	{
6097	ComPtr<IEvent> pEvent;
6098	evDesc.getEvent(pEvent.asOutParam());
6099	ComPtr<IShowWindowEvent> pShowEvent = pEvent;
6100	if (pShowEvent)
6101	{
6102	LONG64 iEvWinId = 0;
6103	pShowEvent->COMGETTER(WinId)(&iEvWinId);
6104	if (iEvWinId != 0 && *aWinId == 0)
6105	*aWinId = iEvWinId;
6106	}
6107	else
6108	AssertFailed();
6109	}
6110	}
6111
6112	return S_OK;
6113	}
6114
6115	// private methods
6116	////////////////////////////////////////////////////////////////////////////////
6117
6118	/**
6119	* Increases the usage counter of the mpUVM pointer.
6120	*
6121	* Guarantees that VMR3Destroy() will not be called on it at least until
6122	* releaseVMCaller() is called.
6123	*
6124	* If this method returns a failure, the caller is not allowed to use mpUVM and
6125	* may return the failed result code to the upper level. This method sets the
6126	* extended error info on failure if \a aQuiet is false.
6127	*
6128	* Setting \a aQuiet to true is useful for methods that don't want to return
6129	* the failed result code to the caller when this method fails (e.g. need to
6130	* silently check for the mpUVM availability).
6131	*
6132	* When mpUVM is NULL but \a aAllowNullVM is true, a corresponding error will be
6133	* returned instead of asserting. Having it false is intended as a sanity check
6134	* for methods that have checked mMachineState and expect mpUVM NOT to be
6135	* NULL.
6136	*
6137	* @param aQuiet true to suppress setting error info
6138	* @param aAllowNullVM true to accept mpUVM being NULL and return a failure
6139	* (otherwise this method will assert if mpUVM is NULL)
6140	*
6141	* @note Locks this object for writing.
6142	*/
6143	HRESULT Console::addVMCaller(bool aQuiet /* = false */,
6144	bool aAllowNullVM /* = false */)
6145	{
6146	AutoCaller autoCaller(this);
6147	/** @todo Fix race during console/VM reference destruction, refer @bugref{6318}
6148	* comment 25. */
6149	if (FAILED(autoCaller.rc()))
6150	return autoCaller.rc();
6151
6152	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6153
6154	if (mVMDestroying)
6155	{
6156	/* powerDown() is waiting for all callers to finish */
6157	return aQuiet ? E_ACCESSDENIED : setError(E_ACCESSDENIED,
6158	tr("The virtual machine is being powered down"));
6159	}
6160
6161	if (mpUVM == NULL)
6162	{
6163	Assert(aAllowNullVM == true);
6164
6165	/* The machine is not powered up */
6166	return aQuiet ? E_ACCESSDENIED : setError(E_ACCESSDENIED,
6167	tr("The virtual machine is not powered up"));
6168	}
6169
6170	++mVMCallers;
6171
6172	return S_OK;
6173	}
6174
6175	/**
6176	* Decreases the usage counter of the mpUVM pointer.
6177	*
6178	* Must always complete the addVMCaller() call after the mpUVM pointer is no
6179	* more necessary.
6180	*
6181	* @note Locks this object for writing.
6182	*/
6183	void Console::releaseVMCaller()
6184	{
6185	AutoCaller autoCaller(this);
6186	AssertComRCReturnVoid(autoCaller.rc());
6187
6188	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6189
6190	AssertReturnVoid(mpUVM != NULL);
6191
6192	Assert(mVMCallers > 0);
6193	--mVMCallers;
6194
6195	if (mVMCallers == 0 && mVMDestroying)
6196	{
6197	/* inform powerDown() there are no more callers */
6198	RTSemEventSignal(mVMZeroCallersSem);
6199	}
6200	}
6201
6202
6203	HRESULT Console::safeVMPtrRetainer(PUVM *a_ppUVM, bool a_Quiet)
6204	{
6205	*a_ppUVM = NULL;
6206
6207	AutoCaller autoCaller(this);
6208	AssertComRCReturnRC(autoCaller.rc());
6209	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6210
6211	/*
6212	* Repeat the checks done by addVMCaller.
6213	*/
6214	if (mVMDestroying) /* powerDown() is waiting for all callers to finish */
6215	return a_Quiet
6216	? E_ACCESSDENIED
6217	: setError(E_ACCESSDENIED, tr("The virtual machine is being powered down"));
6218	PUVM pUVM = mpUVM;
6219	if (!pUVM)
6220	return a_Quiet
6221	? E_ACCESSDENIED
6222	: setError(E_ACCESSDENIED, tr("The virtual machine is powered off"));
6223
6224	/*
6225	* Retain a reference to the user mode VM handle and get the global handle.
6226	*/
6227	uint32_t cRefs = VMR3RetainUVM(pUVM);
6228	if (cRefs == UINT32_MAX)
6229	return a_Quiet
6230	? E_ACCESSDENIED
6231	: setError(E_ACCESSDENIED, tr("The virtual machine is powered off"));
6232
6233	/* done */
6234	*a_ppUVM = pUVM;
6235	return S_OK;
6236	}
6237
6238	void Console::safeVMPtrReleaser(PUVM *a_ppUVM)
6239	{
6240	if (*a_ppUVM)
6241	VMR3ReleaseUVM(*a_ppUVM);
6242	*a_ppUVM = NULL;
6243	}
6244
6245
6246	/**
6247	* Initialize the release logging facility. In case something
6248	* goes wrong, there will be no release logging. Maybe in the future
6249	* we can add some logic to use different file names in this case.
6250	* Note that the logic must be in sync with Machine::DeleteSettings().
6251	*/
6252	HRESULT Console::consoleInitReleaseLog(const ComPtr<IMachine> aMachine)
6253	{
6254	HRESULT hrc = S_OK;
6255
6256	Bstr logFolder;
6257	hrc = aMachine->COMGETTER(LogFolder)(logFolder.asOutParam());
6258	if (FAILED(hrc))
6259	return hrc;
6260
6261	Utf8Str logDir = logFolder;
6262
6263	/* make sure the Logs folder exists */
6264	Assert(logDir.length());
6265	if (!RTDirExists(logDir.c_str()))
6266	RTDirCreateFullPath(logDir.c_str(), 0700);
6267
6268	Utf8Str logFile = Utf8StrFmt("%s%cVBox.log",
6269	logDir.c_str(), RTPATH_DELIMITER);
6270	Utf8Str pngFile = Utf8StrFmt("%s%cVBox.png",
6271	logDir.c_str(), RTPATH_DELIMITER);
6272
6273	/*
6274	* Age the old log files
6275	* Rename .(n-1) to .(n), .(n-2) to .(n-1), ..., and the last log file to .1
6276	* Overwrite target files in case they exist.
6277	*/
6278	ComPtr<IVirtualBox> pVirtualBox;
6279	aMachine->COMGETTER(Parent)(pVirtualBox.asOutParam());
6280	ComPtr<ISystemProperties> pSystemProperties;
6281	pVirtualBox->COMGETTER(SystemProperties)(pSystemProperties.asOutParam());
6282	ULONG cHistoryFiles = 3;
6283	pSystemProperties->COMGETTER(LogHistoryCount)(&cHistoryFiles);
6284	if (cHistoryFiles)
6285	{
6286	for (int i = cHistoryFiles-1; i >= 0; i--)
6287	{
6288	Utf8Str *files[] = { &logFile, &pngFile };
6289	Utf8Str oldName, newName;
6290
6291	for (unsigned int j = 0; j < RT_ELEMENTS(files); ++j)
6292	{
6293	if (i > 0)
6294	oldName = Utf8StrFmt("%s.%d", files[j]->c_str(), i);
6295	else
6296	oldName = *files[j];
6297	newName = Utf8StrFmt("%s.%d", files[j]->c_str(), i + 1);
6298	/* If the old file doesn't exist, delete the new file (if it
6299	* exists) to provide correct rotation even if the sequence is
6300	* broken */
6301	if ( RTFileRename(oldName.c_str(), newName.c_str(), RTFILEMOVE_FLAGS_REPLACE)
6302	== VERR_FILE_NOT_FOUND)
6303	RTFileDelete(newName.c_str());
6304	}
6305	}
6306	}
6307
6308	char szError[RTPATH_MAX + 128];
6309	int vrc = com::VBoxLogRelCreate("VM", logFile.c_str(),
6310	RTLOGFLAGS_PREFIX_TIME_PROG \| RTLOGFLAGS_RESTRICT_GROUPS,
6311	"all all.restrict -default.restrict",
6312	"VBOX_RELEASE_LOG", RTLOGDEST_FILE,
6313	32768 /* cMaxEntriesPerGroup */,
6314	0 /* cHistory /, 0 / uHistoryFileTime */,
6315	0 /* uHistoryFileSize */, szError, sizeof(szError));
6316	if (RT_FAILURE(vrc))
6317	hrc = setError(E_FAIL, tr("Failed to open release log (%s, %Rrc)"),
6318	szError, vrc);
6319
6320	/* If we've made any directory changes, flush the directory to increase
6321	the likelihood that the log file will be usable after a system panic.
6322
6323	Tip: Try 'export VBOX_RELEASE_LOG_FLAGS=flush' if the last bits of the log
6324	is missing. Just don't have too high hopes for this to help. */
6325	if (SUCCEEDED(hrc) \|\| cHistoryFiles)
6326	RTDirFlush(logDir.c_str());
6327
6328	return hrc;
6329	}
6330
6331	/**
6332	* Common worker for PowerUp and PowerUpPaused.
6333	*
6334	* @returns COM status code.
6335	*
6336	* @param aProgress Where to return the progress object.
6337	* @param aPaused true if PowerUpPaused called.
6338	*/
6339	HRESULT Console::powerUp(IProgress **aProgress, bool aPaused)
6340	{
6341
6342	LogFlowThisFuncEnter();
6343	LogFlowThisFunc(("mMachineState=%d\n", mMachineState));
6344
6345	CheckComArgOutPointerValid(aProgress);
6346
6347	AutoCaller autoCaller(this);
6348	if (FAILED(autoCaller.rc())) return autoCaller.rc();
6349
6350	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6351
6352	HRESULT rc = S_OK;
6353	ComObjPtr<Progress> pPowerupProgress;
6354	bool fBeganPoweringUp = false;
6355
6356	LONG cOperations = 1;
6357	LONG ulTotalOperationsWeight = 1;
6358
6359	try
6360	{
6361
6362	if (Global::IsOnlineOrTransient(mMachineState))
6363	throw setError(VBOX_E_INVALID_VM_STATE,
6364	tr("The virtual machine is already running or busy (machine state: %s)"),
6365	Global::stringifyMachineState(mMachineState));
6366
6367	/* Set up release logging as early as possible after the check if
6368	* there is already a running VM which we shouldn't disturb. */
6369	rc = consoleInitReleaseLog(mMachine);
6370	if (FAILED(rc))
6371	throw rc;
6372
6373	/* test and clear the TeleporterEnabled property */
6374	BOOL fTeleporterEnabled;
6375	rc = mMachine->COMGETTER(TeleporterEnabled)(&fTeleporterEnabled);
6376	if (FAILED(rc))
6377	throw rc;
6378
6379	#if 0 /** @todo we should save it afterwards, but that isn't necessarily a good idea. Find a better place for this (VBoxSVC). */
6380	if (fTeleporterEnabled)
6381	{
6382	rc = mMachine->COMSETTER(TeleporterEnabled)(FALSE);
6383	if (FAILED(rc))
6384	throw rc;
6385	}
6386	#endif
6387
6388	/* test the FaultToleranceState property */
6389	FaultToleranceState_T enmFaultToleranceState;
6390	rc = mMachine->COMGETTER(FaultToleranceState)(&enmFaultToleranceState);
6391	if (FAILED(rc))
6392	throw rc;
6393	BOOL fFaultToleranceSyncEnabled = (enmFaultToleranceState == FaultToleranceState_Standby);
6394
6395	/* Create a progress object to track progress of this operation. Must
6396	* be done as early as possible (together with BeginPowerUp()) as this
6397	* is vital for communicating as much as possible early powerup
6398	* failure information to the API caller */
6399	pPowerupProgress.createObject();
6400	Bstr progressDesc;
6401	if (mMachineState == MachineState_Saved)
6402	progressDesc = tr("Restoring virtual machine");
6403	else if (fTeleporterEnabled)
6404	progressDesc = tr("Teleporting virtual machine");
6405	else if (fFaultToleranceSyncEnabled)
6406	progressDesc = tr("Fault Tolerance syncing of remote virtual machine");
6407	else
6408	progressDesc = tr("Starting virtual machine");
6409
6410	/* Check all types of shared folders and compose a single list */
6411	SharedFolderDataMap sharedFolders;
6412	{
6413	/* first, insert global folders */
6414	for (SharedFolderDataMap::const_iterator it = m_mapGlobalSharedFolders.begin();
6415	it != m_mapGlobalSharedFolders.end();
6416	++it)
6417	{
6418	const SharedFolderData &d = it->second;
6419	sharedFolders[it->first] = d;
6420	}
6421
6422	/* second, insert machine folders */
6423	for (SharedFolderDataMap::const_iterator it = m_mapMachineSharedFolders.begin();
6424	it != m_mapMachineSharedFolders.end();
6425	++it)
6426	{
6427	const SharedFolderData &d = it->second;
6428	sharedFolders[it->first] = d;
6429	}
6430
6431	/* third, insert console folders */
6432	for (SharedFolderMap::const_iterator it = m_mapSharedFolders.begin();
6433	it != m_mapSharedFolders.end();
6434	++it)
6435	{
6436	SharedFolder *pSF = it->second;
6437	AutoCaller sfCaller(pSF);
6438	AutoReadLock sfLock(pSF COMMA_LOCKVAL_SRC_POS);
6439	sharedFolders[it->first] = SharedFolderData(pSF->getHostPath(),
6440	pSF->isWritable(),
6441	pSF->isAutoMounted());
6442	}
6443	}
6444
6445	Bstr savedStateFile;
6446
6447	/*
6448	* Saved VMs will have to prove that their saved states seem kosher.
6449	*/
6450	if (mMachineState == MachineState_Saved)
6451	{
6452	rc = mMachine->COMGETTER(StateFilePath)(savedStateFile.asOutParam());
6453	if (FAILED(rc))
6454	throw rc;
6455	ComAssertRet(!savedStateFile.isEmpty(), E_FAIL);
6456	int vrc = SSMR3ValidateFile(Utf8Str(savedStateFile).c_str(), false /* fChecksumIt */);
6457	if (RT_FAILURE(vrc))
6458	throw setError(VBOX_E_FILE_ERROR,
6459	tr("VM cannot start because the saved state file '%ls' is invalid (%Rrc). Delete the saved state prior to starting the VM"),
6460	savedStateFile.raw(), vrc);
6461	}
6462
6463	/* Setup task object and thread to carry out the operaton
6464	* Asycnhronously */
6465	std::auto_ptr<VMPowerUpTask> task(new VMPowerUpTask(this, pPowerupProgress));
6466	ComAssertComRCRetRC(task->rc());
6467
6468	task->mConfigConstructor = configConstructor;
6469	task->mSharedFolders = sharedFolders;
6470	task->mStartPaused = aPaused;
6471	if (mMachineState == MachineState_Saved)
6472	task->mSavedStateFile = savedStateFile;
6473	task->mTeleporterEnabled = fTeleporterEnabled;
6474	task->mEnmFaultToleranceState = enmFaultToleranceState;
6475
6476	/* Reset differencing hard disks for which autoReset is true,
6477	* but only if the machine has no snapshots OR the current snapshot
6478	* is an OFFLINE snapshot; otherwise we would reset the current
6479	* differencing image of an ONLINE snapshot which contains the disk
6480	* state of the machine while it was previously running, but without
6481	* the corresponding machine state, which is equivalent to powering
6482	* off a running machine and not good idea
6483	*/
6484	ComPtr<ISnapshot> pCurrentSnapshot;
6485	rc = mMachine->COMGETTER(CurrentSnapshot)(pCurrentSnapshot.asOutParam());
6486	if (FAILED(rc))
6487	throw rc;
6488
6489	BOOL fCurrentSnapshotIsOnline = false;
6490	if (pCurrentSnapshot)
6491	{
6492	rc = pCurrentSnapshot->COMGETTER(Online)(&fCurrentSnapshotIsOnline);
6493	if (FAILED(rc))
6494	throw rc;
6495	}
6496
6497	if (!fCurrentSnapshotIsOnline)
6498	{
6499	LogFlowThisFunc(("Looking for immutable images to reset\n"));
6500
6501	com::SafeIfaceArray<IMediumAttachment> atts;
6502	rc = mMachine->COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(atts));
6503	if (FAILED(rc))
6504	throw rc;
6505
6506	for (size_t i = 0;
6507	i < atts.size();
6508	++i)
6509	{
6510	DeviceType_T devType;
6511	rc = atts[i]->COMGETTER(Type)(&devType);
6512	/** @todo later applies to floppies as well */
6513	if (devType == DeviceType_HardDisk)
6514	{
6515	ComPtr<IMedium> pMedium;
6516	rc = atts[i]->COMGETTER(Medium)(pMedium.asOutParam());
6517	if (FAILED(rc))
6518	throw rc;
6519
6520	/* needs autoreset? */
6521	BOOL autoReset = FALSE;
6522	rc = pMedium->COMGETTER(AutoReset)(&autoReset);
6523	if (FAILED(rc))
6524	throw rc;
6525
6526	if (autoReset)
6527	{
6528	ComPtr<IProgress> pResetProgress;
6529	rc = pMedium->Reset(pResetProgress.asOutParam());
6530	if (FAILED(rc))
6531	throw rc;
6532
6533	/* save for later use on the powerup thread */
6534	task->hardDiskProgresses.push_back(pResetProgress);
6535	}
6536	}
6537	}
6538	}
6539	else
6540	LogFlowThisFunc(("Machine has a current snapshot which is online, skipping immutable images reset\n"));
6541
6542	/* setup task object and thread to carry out the operation
6543	* asynchronously */
6544
6545	#ifdef VBOX_WITH_EXTPACK
6546	mptrExtPackManager->dumpAllToReleaseLog();
6547	#endif
6548
6549	#ifdef RT_OS_SOLARIS
6550	/* setup host core dumper for the VM */
6551	Bstr value;
6552	HRESULT hrc = mMachine->GetExtraData(Bstr("VBoxInternal2/CoreDumpEnabled").raw(), value.asOutParam());
6553	if (SUCCEEDED(hrc) && value == "1")
6554	{
6555	Bstr coreDumpDir, coreDumpReplaceSys, coreDumpLive;
6556	mMachine->GetExtraData(Bstr("VBoxInternal2/CoreDumpDir").raw(), coreDumpDir.asOutParam());
6557	mMachine->GetExtraData(Bstr("VBoxInternal2/CoreDumpReplaceSystemDump").raw(), coreDumpReplaceSys.asOutParam());
6558	mMachine->GetExtraData(Bstr("VBoxInternal2/CoreDumpLive").raw(), coreDumpLive.asOutParam());
6559
6560	uint32_t fCoreFlags = 0;
6561	if ( coreDumpReplaceSys.isEmpty() == false
6562	&& Utf8Str(coreDumpReplaceSys).toUInt32() == 1)
6563	fCoreFlags \|= RTCOREDUMPER_FLAGS_REPLACE_SYSTEM_DUMP;
6564
6565	if ( coreDumpLive.isEmpty() == false
6566	&& Utf8Str(coreDumpLive).toUInt32() == 1)
6567	fCoreFlags \|= RTCOREDUMPER_FLAGS_LIVE_CORE;
6568
6569	Utf8Str strDumpDir(coreDumpDir);
6570	const char *pszDumpDir = strDumpDir.c_str();
6571	if ( pszDumpDir
6572	&& *pszDumpDir == '\0')
6573	pszDumpDir = NULL;
6574
6575	int vrc;
6576	if ( pszDumpDir
6577	&& !RTDirExists(pszDumpDir))
6578	{
6579	/*
6580	* Try create the directory.
6581	*/
6582	vrc = RTDirCreateFullPath(pszDumpDir, 0700);
6583	if (RT_FAILURE(vrc))
6584	throw setError(E_FAIL, "Failed to setup CoreDumper. Couldn't create dump directory '%s' (%Rrc)\n", pszDumpDir, vrc);
6585	}
6586
6587	vrc = RTCoreDumperSetup(pszDumpDir, fCoreFlags);
6588	if (RT_FAILURE(vrc))
6589	throw setError(E_FAIL, "Failed to setup CoreDumper (%Rrc)", vrc);
6590	else
6591	LogRel(("CoreDumper setup successful. pszDumpDir=%s fFlags=%#x\n", pszDumpDir ? pszDumpDir : ".", fCoreFlags));
6592	}
6593	#endif
6594
6595
6596	// If there is immutable drive the process that.
6597	VMPowerUpTask::ProgressList progresses(task->hardDiskProgresses);
6598	if (aProgress && progresses.size() > 0){
6599
6600	for (VMPowerUpTask::ProgressList::const_iterator it = progresses.begin(); it != progresses.end(); ++it)
6601	{
6602	++cOperations;
6603	ulTotalOperationsWeight += 1;
6604	}
6605	rc = pPowerupProgress->init(static_cast<IConsole *>(this),
6606	progressDesc.raw(),
6607	TRUE, // Cancelable
6608	cOperations,
6609	ulTotalOperationsWeight,
6610	Bstr(tr("Starting Hard Disk operations")).raw(),
6611	1,
6612	NULL);
6613	AssertComRCReturnRC(rc);
6614	}
6615	else if ( mMachineState == MachineState_Saved
6616	\|\| (!fTeleporterEnabled && !fFaultToleranceSyncEnabled))
6617	{
6618	rc = pPowerupProgress->init(static_cast<IConsole *>(this),
6619	progressDesc.raw(),
6620	FALSE /* aCancelable */);
6621	}
6622	else if (fTeleporterEnabled)
6623	{
6624	rc = pPowerupProgress->init(static_cast<IConsole *>(this),
6625	progressDesc.raw(),
6626	TRUE /* aCancelable */,
6627	3 /* cOperations */,
6628	10 /* ulTotalOperationsWeight */,
6629	Bstr(tr("Teleporting virtual machine")).raw(),
6630	1 /* ulFirstOperationWeight */,
6631	NULL);
6632	}
6633	else if (fFaultToleranceSyncEnabled)
6634	{
6635	rc = pPowerupProgress->init(static_cast<IConsole *>(this),
6636	progressDesc.raw(),
6637	TRUE /* aCancelable */,
6638	3 /* cOperations */,
6639	10 /* ulTotalOperationsWeight */,
6640	Bstr(tr("Fault Tolerance syncing of remote virtual machine")).raw(),
6641	1 /* ulFirstOperationWeight */,
6642	NULL);
6643	}
6644
6645	if (FAILED(rc))
6646	throw rc;
6647
6648	/* Tell VBoxSVC and Machine about the progress object so they can
6649	combine/proxy it to any openRemoteSession caller. */
6650	LogFlowThisFunc(("Calling BeginPowerUp...\n"));
6651	rc = mControl->BeginPowerUp(pPowerupProgress);
6652	if (FAILED(rc))
6653	{
6654	LogFlowThisFunc(("BeginPowerUp failed\n"));
6655	throw rc;
6656	}
6657	fBeganPoweringUp = true;
6658
6659	LogFlowThisFunc(("Checking if canceled...\n"));
6660	BOOL fCanceled;
6661	rc = pPowerupProgress->COMGETTER(Canceled)(&fCanceled);
6662	if (FAILED(rc))
6663	throw rc;
6664
6665	if (fCanceled)
6666	{
6667	LogFlowThisFunc(("Canceled in BeginPowerUp\n"));
6668	throw setError(E_FAIL, tr("Powerup was canceled"));
6669	}
6670	LogFlowThisFunc(("Not canceled yet.\n"));
6671
6672	/** @todo this code prevents starting a VM with unavailable bridged
6673	* networking interface. The only benefit is a slightly better error
6674	* message, which should be moved to the driver code. This is the
6675	* only reason why I left the code in for now. The driver allows
6676	* unavailable bridged networking interfaces in certain circumstances,
6677	* and this is sabotaged by this check. The VM will initially have no
6678	* network connectivity, but the user can fix this at runtime. */
6679	#if 0
6680	/* the network cards will undergo a quick consistency check */
6681	for (ULONG slot = 0;
6682	slot < maxNetworkAdapters;
6683	++slot)
6684	{
6685	ComPtr<INetworkAdapter> pNetworkAdapter;
6686	mMachine->GetNetworkAdapter(slot, pNetworkAdapter.asOutParam());
6687	BOOL enabled = FALSE;
6688	pNetworkAdapter->COMGETTER(Enabled)(&enabled);
6689	if (!enabled)
6690	continue;
6691
6692	NetworkAttachmentType_T netattach;
6693	pNetworkAdapter->COMGETTER(AttachmentType)(&netattach);
6694	switch (netattach)
6695	{
6696	case NetworkAttachmentType_Bridged:
6697	{
6698	/* a valid host interface must have been set */
6699	Bstr hostif;
6700	pNetworkAdapter->COMGETTER(HostInterface)(hostif.asOutParam());
6701	if (hostif.isEmpty())
6702	{
6703	throw setError(VBOX_E_HOST_ERROR,
6704	tr("VM cannot start because host interface networking requires a host interface name to be set"));
6705	}
6706	ComPtr<IVirtualBox> pVirtualBox;
6707	mMachine->COMGETTER(Parent)(pVirtualBox.asOutParam());
6708	ComPtr<IHost> pHost;
6709	pVirtualBox->COMGETTER(Host)(pHost.asOutParam());
6710	ComPtr<IHostNetworkInterface> pHostInterface;
6711	if (!SUCCEEDED(pHost->FindHostNetworkInterfaceByName(hostif.raw(),
6712	pHostInterface.asOutParam())))
6713	{
6714	throw setError(VBOX_E_HOST_ERROR,
6715	tr("VM cannot start because the host interface '%ls' does not exist"),
6716	hostif.raw());
6717	}
6718	break;
6719	}
6720	default:
6721	break;
6722	}
6723	}
6724	#endif // 0
6725
6726	/* Read console data stored in the saved state file (if not yet done) */
6727	rc = loadDataFromSavedState();
6728	if (FAILED(rc))
6729	throw rc;
6730
6731	/* setup task object and thread to carry out the operation
6732	* asynchronously */
6733	if (aProgress){
6734	rc = pPowerupProgress.queryInterfaceTo(aProgress);
6735	AssertComRCReturnRC(rc);
6736	}
6737
6738	int vrc = RTThreadCreate(NULL, Console::powerUpThread,
6739	(void *)task.get(), 0,
6740	RTTHREADTYPE_MAIN_WORKER, 0, "VMPwrUp");
6741	if (RT_FAILURE(vrc))
6742	throw setError(E_FAIL, "Could not create VMPowerUp thread (%Rrc)", vrc);
6743
6744	/* task is now owned by powerUpThread(), so release it */
6745	task.release();
6746
6747	/* finally, set the state: no right to fail in this method afterwards
6748	* since we've already started the thread and it is now responsible for
6749	* any error reporting and appropriate state change! */
6750	if (mMachineState == MachineState_Saved)
6751	setMachineState(MachineState_Restoring);
6752	else if (fTeleporterEnabled)
6753	setMachineState(MachineState_TeleportingIn);
6754	else if (enmFaultToleranceState == FaultToleranceState_Standby)
6755	setMachineState(MachineState_FaultTolerantSyncing);
6756	else
6757	setMachineState(MachineState_Starting);
6758	}
6759	catch (HRESULT aRC) { rc = aRC; }
6760
6761	if (FAILED(rc) && fBeganPoweringUp)
6762	{
6763
6764	/* The progress object will fetch the current error info */
6765	if (!pPowerupProgress.isNull())
6766	pPowerupProgress->notifyComplete(rc);
6767
6768	/* Save the error info across the IPC below. Can't be done before the
6769	* progress notification above, as saving the error info deletes it
6770	* from the current context, and thus the progress object wouldn't be
6771	* updated correctly. */
6772	ErrorInfoKeeper eik;
6773
6774	/* signal end of operation */
6775	mControl->EndPowerUp(rc);
6776	}
6777
6778	LogFlowThisFunc(("mMachineState=%d, rc=%Rhrc\n", mMachineState, rc));
6779	LogFlowThisFuncLeave();
6780	return rc;
6781	}
6782
6783	/**
6784	* Internal power off worker routine.
6785	*
6786	* This method may be called only at certain places with the following meaning
6787	* as shown below:
6788	*
6789	* - if the machine state is either Running or Paused, a normal
6790	* Console-initiated powerdown takes place (e.g. PowerDown());
6791	* - if the machine state is Saving, saveStateThread() has successfully done its
6792	* job;
6793	* - if the machine state is Starting or Restoring, powerUpThread() has failed
6794	* to start/load the VM;
6795	* - if the machine state is Stopping, the VM has powered itself off (i.e. not
6796	* as a result of the powerDown() call).
6797	*
6798	* Calling it in situations other than the above will cause unexpected behavior.
6799	*
6800	* Note that this method should be the only one that destroys mpUVM and sets it
6801	* to NULL.
6802	*
6803	* @param aProgress Progress object to run (may be NULL).
6804	*
6805	* @note Locks this object for writing.
6806	*
6807	* @note Never call this method from a thread that called addVMCaller() or
6808	* instantiated an AutoVMCaller object; first call releaseVMCaller() or
6809	* release(). Otherwise it will deadlock.
6810	*/
6811	HRESULT Console::powerDown(IProgress aProgress /= NULL*/)
6812	{
6813	LogFlowThisFuncEnter();
6814
6815	AutoCaller autoCaller(this);
6816	AssertComRCReturnRC(autoCaller.rc());
6817
6818	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6819
6820	/* Total # of steps for the progress object. Must correspond to the
6821	* number of "advance percent count" comments in this method! */
6822	enum { StepCount = 7 };
6823	/* current step */
6824	ULONG step = 0;
6825
6826	HRESULT rc = S_OK;
6827	int vrc = VINF_SUCCESS;
6828
6829	/* sanity */
6830	Assert(mVMDestroying == false);
6831
6832	PUVM pUVM = mpUVM; Assert(pUVM != NULL);
6833	uint32_t cRefs = VMR3RetainUVM(pUVM); Assert(cRefs != UINT32_MAX);
6834
6835	AssertMsg( mMachineState == MachineState_Running
6836	\|\| mMachineState == MachineState_Paused
6837	\|\| mMachineState == MachineState_Stuck
6838	\|\| mMachineState == MachineState_Starting
6839	\|\| mMachineState == MachineState_Stopping
6840	\|\| mMachineState == MachineState_Saving
6841	\|\| mMachineState == MachineState_Restoring
6842	\|\| mMachineState == MachineState_TeleportingPausedVM
6843	\|\| mMachineState == MachineState_FaultTolerantSyncing
6844	\|\| mMachineState == MachineState_TeleportingIn
6845	, ("Invalid machine state: %s\n", Global::stringifyMachineState(mMachineState)));
6846
6847	LogRel(("Console::powerDown(): A request to power off the VM has been issued (mMachineState=%s, InUninit=%d)\n",
6848	Global::stringifyMachineState(mMachineState), autoCaller.state() == InUninit));
6849
6850	/* Check if we need to power off the VM. In case of mVMPoweredOff=true, the
6851	* VM has already powered itself off in vmstateChangeCallback() and is just
6852	* notifying Console about that. In case of Starting or Restoring,
6853	* powerUpThread() is calling us on failure, so the VM is already off at
6854	* that point. */
6855	if ( !mVMPoweredOff
6856	&& ( mMachineState == MachineState_Starting
6857	\|\| mMachineState == MachineState_Restoring
6858	\|\| mMachineState == MachineState_FaultTolerantSyncing
6859	\|\| mMachineState == MachineState_TeleportingIn)
6860	)
6861	mVMPoweredOff = true;
6862
6863	/*
6864	* Go to Stopping state if not already there.
6865	*
6866	* Note that we don't go from Saving/Restoring to Stopping because
6867	* vmstateChangeCallback() needs it to set the state to Saved on
6868	* VMSTATE_TERMINATED. In terms of protecting from inappropriate operations
6869	* while leaving the lock below, Saving or Restoring should be fine too.
6870	* Ditto for TeleportingPausedVM -> Teleported.
6871	*/
6872	if ( mMachineState != MachineState_Saving
6873	&& mMachineState != MachineState_Restoring
6874	&& mMachineState != MachineState_Stopping
6875	&& mMachineState != MachineState_TeleportingIn
6876	&& mMachineState != MachineState_TeleportingPausedVM
6877	&& mMachineState != MachineState_FaultTolerantSyncing
6878	)
6879	setMachineState(MachineState_Stopping);
6880
6881	/* ----------------------------------------------------------------------
6882	* DONE with necessary state changes, perform the power down actions (it's
6883	* safe to release the object lock now if needed)
6884	* ---------------------------------------------------------------------- */
6885
6886	/* Stop the VRDP server to prevent new clients connection while VM is being
6887	* powered off. */
6888	if (mConsoleVRDPServer)
6889	{
6890	LogFlowThisFunc(("Stopping VRDP server...\n"));
6891
6892	/* Leave the lock since EMT will call us back as addVMCaller()
6893	* in updateDisplayData(). */
6894	alock.release();
6895
6896	mConsoleVRDPServer->Stop();
6897
6898	alock.acquire();
6899	}
6900
6901	/* advance percent count */
6902	if (aProgress)
6903	aProgress->SetCurrentOperationProgress(99 * (++step) / StepCount );
6904
6905
6906	/* ----------------------------------------------------------------------
6907	* Now, wait for all mpUVM callers to finish their work if there are still
6908	* some on other threads. NO methods that need mpUVM (or initiate other calls
6909	* that need it) may be called after this point
6910	* ---------------------------------------------------------------------- */
6911
6912	/* go to the destroying state to prevent from adding new callers */
6913	mVMDestroying = true;
6914
6915	if (mVMCallers > 0)
6916	{
6917	/* lazy creation */
6918	if (mVMZeroCallersSem == NIL_RTSEMEVENT)
6919	RTSemEventCreate(&mVMZeroCallersSem);
6920
6921	LogFlowThisFunc(("Waiting for mpUVM callers (%d) to drop to zero...\n", mVMCallers));
6922
6923	alock.release();
6924
6925	RTSemEventWait(mVMZeroCallersSem, RT_INDEFINITE_WAIT);
6926
6927	alock.acquire();
6928	}
6929
6930	/* advance percent count */
6931	if (aProgress)
6932	aProgress->SetCurrentOperationProgress(99 * (++step) / StepCount );
6933
6934	vrc = VINF_SUCCESS;
6935
6936	/*
6937	* Power off the VM if not already done that.
6938	* Leave the lock since EMT will call vmstateChangeCallback.
6939	*
6940	* Note that VMR3PowerOff() may fail here (invalid VMSTATE) if the
6941	* VM-(guest-)initiated power off happened in parallel a ms before this
6942	* call. So far, we let this error pop up on the user's side.
6943	*/
6944	if (!mVMPoweredOff)
6945	{
6946	LogFlowThisFunc(("Powering off the VM...\n"));
6947	alock.release();
6948	vrc = VMR3PowerOff(pUVM);
6949	#ifdef VBOX_WITH_EXTPACK
6950	mptrExtPackManager->callAllVmPowerOffHooks(this, VMR3GetVM(pUVM));
6951	#endif
6952	alock.acquire();
6953	}
6954
6955	/* advance percent count */
6956	if (aProgress)
6957	aProgress->SetCurrentOperationProgress(99 * (++step) / StepCount );
6958
6959	#ifdef VBOX_WITH_HGCM
6960	/* Shutdown HGCM services before destroying the VM. */
6961	if (m_pVMMDev)
6962	{
6963	LogFlowThisFunc(("Shutdown HGCM...\n"));
6964
6965	/* Leave the lock since EMT will call us back as addVMCaller() */
6966	alock.release();
6967
6968	m_pVMMDev->hgcmShutdown();
6969
6970	alock.acquire();
6971	}
6972
6973	/* advance percent count */
6974	if (aProgress)
6975	aProgress->SetCurrentOperationProgress(99 * (++step) / StepCount);
6976
6977	#endif /* VBOX_WITH_HGCM */
6978
6979	LogFlowThisFunc(("Ready for VM destruction.\n"));
6980
6981	/* If we are called from Console::uninit(), then try to destroy the VM even
6982	* on failure (this will most likely fail too, but what to do?..) */
6983	if (RT_SUCCESS(vrc) \|\| autoCaller.state() == InUninit)
6984	{
6985	/* If the machine has an USB controller, release all USB devices
6986	* (symmetric to the code in captureUSBDevices()) */
6987	bool fHasUSBController = false;
6988	{
6989	PPDMIBASE pBase;
6990	vrc = PDMR3QueryLun(pUVM, "usb-ohci", 0, 0, &pBase);
6991	if (RT_SUCCESS(vrc))
6992	{
6993	fHasUSBController = true;
6994	alock.release();
6995	detachAllUSBDevices(false /* aDone */);
6996	alock.acquire();
6997	}
6998	}
6999
7000	/* Now we've got to destroy the VM as well. (mpUVM is not valid beyond
7001	* this point). We release the lock before calling VMR3Destroy() because
7002	* it will result into calling destructors of drivers associated with
7003	* Console children which may in turn try to lock Console (e.g. by
7004	* instantiating SafeVMPtr to access mpUVM). It's safe here because
7005	* mVMDestroying is set which should prevent any activity. */
7006
7007	/* Set mpUVM to NULL early just in case if some old code is not using
7008	* addVMCaller()/releaseVMCaller(). (We have our own ref on pUVM.) */
7009	VMR3ReleaseUVM(mpUVM);
7010	mpUVM = NULL;
7011
7012	LogFlowThisFunc(("Destroying the VM...\n"));
7013
7014	alock.release();
7015
7016	vrc = VMR3Destroy(pUVM);
7017
7018	/* take the lock again */
7019	alock.acquire();
7020
7021	/* advance percent count */
7022	if (aProgress)
7023	aProgress->SetCurrentOperationProgress(99 * (++step) / StepCount);
7024
7025	if (RT_SUCCESS(vrc))
7026	{
7027	LogFlowThisFunc(("Machine has been destroyed (mMachineState=%d)\n",
7028	mMachineState));
7029	/* Note: the Console-level machine state change happens on the
7030	* VMSTATE_TERMINATE state change in vmstateChangeCallback(). If
7031	* powerDown() is called from EMT (i.e. from vmstateChangeCallback()
7032	* on receiving VM-initiated VMSTATE_OFF), VMSTATE_TERMINATE hasn't
7033	* occurred yet. This is okay, because mMachineState is already
7034	* Stopping in this case, so any other attempt to call PowerDown()
7035	* will be rejected. */
7036	}
7037	else
7038	{
7039	/* bad bad bad, but what to do? (Give Console our UVM ref.) */
7040	mpUVM = pUVM;
7041	pUVM = NULL;
7042	rc = setError(VBOX_E_VM_ERROR,
7043	tr("Could not destroy the machine. (Error: %Rrc)"),
7044	vrc);
7045	}
7046
7047	/* Complete the detaching of the USB devices. */
7048	if (fHasUSBController)
7049	{
7050	alock.release();
7051	detachAllUSBDevices(true /* aDone */);
7052	alock.acquire();
7053	}
7054
7055	/* advance percent count */
7056	if (aProgress)
7057	aProgress->SetCurrentOperationProgress(99 * (++step) / StepCount);
7058	}
7059	else
7060	{
7061	rc = setError(VBOX_E_VM_ERROR,
7062	tr("Could not power off the machine. (Error: %Rrc)"),
7063	vrc);
7064	}
7065
7066	/*
7067	* Finished with the destruction.
7068	*
7069	* Note that if something impossible happened and we've failed to destroy
7070	* the VM, mVMDestroying will remain true and mMachineState will be
7071	* something like Stopping, so most Console methods will return an error
7072	* to the caller.
7073	*/
7074	if (mpUVM != NULL)
7075	VMR3ReleaseUVM(pUVM);
7076	else
7077	mVMDestroying = false;
7078
7079	#ifdef CONSOLE_WITH_EVENT_CACHE
7080	if (SUCCEEDED(rc))
7081	mCallbackData.clear();
7082	#endif
7083
7084	LogFlowThisFuncLeave();
7085	return rc;
7086	}
7087
7088	/**
7089	* @note Locks this object for writing.
7090	*/
7091	HRESULT Console::setMachineState(MachineState_T aMachineState,
7092	bool aUpdateServer /* = true */)
7093	{
7094	AutoCaller autoCaller(this);
7095	AssertComRCReturnRC(autoCaller.rc());
7096
7097	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7098
7099	HRESULT rc = S_OK;
7100
7101	if (mMachineState != aMachineState)
7102	{
7103	LogThisFunc(("machineState=%s -> %s aUpdateServer=%RTbool\n",
7104	Global::stringifyMachineState(mMachineState), Global::stringifyMachineState(aMachineState), aUpdateServer));
7105	mMachineState = aMachineState;
7106
7107	/// @todo (dmik)
7108	// possibly, we need to redo onStateChange() using the dedicated
7109	// Event thread, like it is done in VirtualBox. This will make it
7110	// much safer (no deadlocks possible if someone tries to use the
7111	// console from the callback), however, listeners will lose the
7112	// ability to synchronously react to state changes (is it really
7113	// necessary??)
7114	LogFlowThisFunc(("Doing onStateChange()...\n"));
7115	onStateChange(aMachineState);
7116	LogFlowThisFunc(("Done onStateChange()\n"));
7117
7118	if (aUpdateServer)
7119	{
7120	/* Server notification MUST be done from under the lock; otherwise
7121	* the machine state here and on the server might go out of sync
7122	* which can lead to various unexpected results (like the machine
7123	* state being >= MachineState_Running on the server, while the
7124	* session state is already SessionState_Unlocked at the same time
7125	* there).
7126	*
7127	* Cross-lock conditions should be carefully watched out: calling
7128	* UpdateState we will require Machine and SessionMachine locks
7129	* (remember that here we're holding the Console lock here, and also
7130	* all locks that have been acquire by the thread before calling
7131	* this method).
7132	*/
7133	LogFlowThisFunc(("Doing mControl->UpdateState()...\n"));
7134	rc = mControl->UpdateState(aMachineState);
7135	LogFlowThisFunc(("mControl->UpdateState()=%Rhrc\n", rc));
7136	}
7137	}
7138
7139	return rc;
7140	}
7141
7142	/**
7143	* Searches for a shared folder with the given logical name
7144	* in the collection of shared folders.
7145	*
7146	* @param aName logical name of the shared folder
7147	* @param aSharedFolder where to return the found object
7148	* @param aSetError whether to set the error info if the folder is
7149	* not found
7150	* @return
7151	* S_OK when found or E_INVALIDARG when not found
7152	*
7153	* @note The caller must lock this object for writing.
7154	*/
7155	HRESULT Console::findSharedFolder(const Utf8Str &strName,
7156	ComObjPtr<SharedFolder> &aSharedFolder,
7157	bool aSetError /* = false */)
7158	{
7159	/* sanity check */
7160	AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
7161
7162	SharedFolderMap::const_iterator it = m_mapSharedFolders.find(strName);
7163	if (it != m_mapSharedFolders.end())
7164	{
7165	aSharedFolder = it->second;
7166	return S_OK;
7167	}
7168
7169	if (aSetError)
7170	setError(VBOX_E_FILE_ERROR,
7171	tr("Could not find a shared folder named '%s'."),
7172	strName.c_str());
7173
7174	return VBOX_E_FILE_ERROR;
7175	}
7176
7177	/**
7178	* Fetches the list of global or machine shared folders from the server.
7179	*
7180	* @param aGlobal true to fetch global folders.
7181	*
7182	* @note The caller must lock this object for writing.
7183	*/
7184	HRESULT Console::fetchSharedFolders(BOOL aGlobal)
7185	{
7186	/* sanity check */
7187	AssertReturn(AutoCaller(this).state() == InInit \|\|
7188	isWriteLockOnCurrentThread(), E_FAIL);
7189
7190	LogFlowThisFunc(("Entering\n"));
7191
7192	/* Check if we're online and keep it that way. */
7193	SafeVMPtrQuiet ptrVM(this);
7194	AutoVMCallerQuietWeak autoVMCaller(this);
7195	bool const online = ptrVM.isOk()
7196	&& m_pVMMDev
7197	&& m_pVMMDev->isShFlActive();
7198
7199	HRESULT rc = S_OK;
7200
7201	try
7202	{
7203	if (aGlobal)
7204	{
7205	/// @todo grab & process global folders when they are done
7206	}
7207	else
7208	{
7209	SharedFolderDataMap oldFolders;
7210	if (online)
7211	oldFolders = m_mapMachineSharedFolders;
7212
7213	m_mapMachineSharedFolders.clear();
7214
7215	SafeIfaceArray<ISharedFolder> folders;
7216	rc = mMachine->COMGETTER(SharedFolders)(ComSafeArrayAsOutParam(folders));
7217	if (FAILED(rc)) throw rc;
7218
7219	for (size_t i = 0; i < folders.size(); ++i)
7220	{
7221	ComPtr<ISharedFolder> pSharedFolder = folders[i];
7222
7223	Bstr bstrName;
7224	Bstr bstrHostPath;
7225	BOOL writable;
7226	BOOL autoMount;
7227
7228	rc = pSharedFolder->COMGETTER(Name)(bstrName.asOutParam());
7229	if (FAILED(rc)) throw rc;
7230	Utf8Str strName(bstrName);
7231
7232	rc = pSharedFolder->COMGETTER(HostPath)(bstrHostPath.asOutParam());
7233	if (FAILED(rc)) throw rc;
7234	Utf8Str strHostPath(bstrHostPath);
7235
7236	rc = pSharedFolder->COMGETTER(Writable)(&writable);
7237	if (FAILED(rc)) throw rc;
7238
7239	rc = pSharedFolder->COMGETTER(AutoMount)(&autoMount);
7240	if (FAILED(rc)) throw rc;
7241
7242	m_mapMachineSharedFolders.insert(std::make_pair(strName,
7243	SharedFolderData(strHostPath, !!writable, !!autoMount)));
7244
7245	/* send changes to HGCM if the VM is running */
7246	if (online)
7247	{
7248	SharedFolderDataMap::iterator it = oldFolders.find(strName);
7249	if ( it == oldFolders.end()
7250	\|\| it->second.m_strHostPath != strHostPath)
7251	{
7252	/* a new machine folder is added or
7253	* the existing machine folder is changed */
7254	if (m_mapSharedFolders.find(strName) != m_mapSharedFolders.end())
7255	; /* the console folder exists, nothing to do */
7256	else
7257	{
7258	/* remove the old machine folder (when changed)
7259	* or the global folder if any (when new) */
7260	if ( it != oldFolders.end()
7261	\|\| m_mapGlobalSharedFolders.find(strName) != m_mapGlobalSharedFolders.end()
7262	)
7263	{
7264	rc = removeSharedFolder(strName);
7265	if (FAILED(rc)) throw rc;
7266	}
7267
7268	/* create the new machine folder */
7269	rc = createSharedFolder(strName,
7270	SharedFolderData(strHostPath, !!writable, !!autoMount));
7271	if (FAILED(rc)) throw rc;
7272	}
7273	}
7274	/* forget the processed (or identical) folder */
7275	if (it != oldFolders.end())
7276	oldFolders.erase(it);
7277	}
7278	}
7279
7280	/* process outdated (removed) folders */
7281	if (online)
7282	{
7283	for (SharedFolderDataMap::const_iterator it = oldFolders.begin();
7284	it != oldFolders.end(); ++it)
7285	{
7286	if (m_mapSharedFolders.find(it->first) != m_mapSharedFolders.end())
7287	; /* the console folder exists, nothing to do */
7288	else
7289	{
7290	/* remove the outdated machine folder */
7291	rc = removeSharedFolder(it->first);
7292	if (FAILED(rc)) throw rc;
7293
7294	/* create the global folder if there is any */
7295	SharedFolderDataMap::const_iterator git =
7296	m_mapGlobalSharedFolders.find(it->first);
7297	if (git != m_mapGlobalSharedFolders.end())
7298	{
7299	rc = createSharedFolder(git->first, git->second);
7300	if (FAILED(rc)) throw rc;
7301	}
7302	}
7303	}
7304	}
7305	}
7306	}
7307	catch (HRESULT rc2)
7308	{
7309	if (online)
7310	setVMRuntimeErrorCallbackF(0, "BrokenSharedFolder",
7311	N_("Broken shared folder!"));
7312	}
7313
7314	LogFlowThisFunc(("Leaving\n"));
7315
7316	return rc;
7317	}
7318
7319	/**
7320	* Searches for a shared folder with the given name in the list of machine
7321	* shared folders and then in the list of the global shared folders.
7322	*
7323	* @param aName Name of the folder to search for.
7324	* @param aIt Where to store the pointer to the found folder.
7325	* @return @c true if the folder was found and @c false otherwise.
7326	*
7327	* @note The caller must lock this object for reading.
7328	*/
7329	bool Console::findOtherSharedFolder(const Utf8Str &strName,
7330	SharedFolderDataMap::const_iterator &aIt)
7331	{
7332	/* sanity check */
7333	AssertReturn(isWriteLockOnCurrentThread(), false);
7334
7335	/* first, search machine folders */
7336	aIt = m_mapMachineSharedFolders.find(strName);
7337	if (aIt != m_mapMachineSharedFolders.end())
7338	return true;
7339
7340	/* second, search machine folders */
7341	aIt = m_mapGlobalSharedFolders.find(strName);
7342	if (aIt != m_mapGlobalSharedFolders.end())
7343	return true;
7344
7345	return false;
7346	}
7347
7348	/**
7349	* Calls the HGCM service to add a shared folder definition.
7350	*
7351	* @param aName Shared folder name.
7352	* @param aHostPath Shared folder path.
7353	*
7354	* @note Must be called from under AutoVMCaller and when mpUVM != NULL!
7355	* @note Doesn't lock anything.
7356	*/
7357	HRESULT Console::createSharedFolder(const Utf8Str &strName, const SharedFolderData &aData)
7358	{
7359	ComAssertRet(strName.isNotEmpty(), E_FAIL);
7360	ComAssertRet(aData.m_strHostPath.isNotEmpty(), E_FAIL);
7361
7362	/* sanity checks */
7363	AssertReturn(mpUVM, E_FAIL);
7364	AssertReturn(m_pVMMDev && m_pVMMDev->isShFlActive(), E_FAIL);
7365
7366	VBOXHGCMSVCPARM parms[SHFL_CPARMS_ADD_MAPPING];
7367	SHFLSTRING pFolderName, pMapName;
7368	size_t cbString;
7369
7370	Bstr value;
7371	HRESULT hrc = mMachine->GetExtraData(BstrFmt("VBoxInternal2/SharedFoldersEnableSymlinksCreate/%s",
7372	strName.c_str()).raw(),
7373	value.asOutParam());
7374	bool fSymlinksCreate = hrc == S_OK && value == "1";
7375
7376	Log(("Adding shared folder '%s' -> '%s'\n", strName.c_str(), aData.m_strHostPath.c_str()));
7377
7378	// check whether the path is valid and exists
7379	char hostPathFull[RTPATH_MAX];
7380	int vrc = RTPathAbsEx(NULL,
7381	aData.m_strHostPath.c_str(),
7382	hostPathFull,
7383	sizeof(hostPathFull));
7384
7385	bool fMissing = false;
7386	if (RT_FAILURE(vrc))
7387	return setError(E_INVALIDARG,
7388	tr("Invalid shared folder path: '%s' (%Rrc)"),
7389	aData.m_strHostPath.c_str(), vrc);
7390	if (!RTPathExists(hostPathFull))
7391	fMissing = true;
7392
7393	/* Check whether the path is full (absolute) */
7394	if (RTPathCompare(aData.m_strHostPath.c_str(), hostPathFull) != 0)
7395	return setError(E_INVALIDARG,
7396	tr("Shared folder path '%s' is not absolute"),
7397	aData.m_strHostPath.c_str());
7398
7399	// now that we know the path is good, give it to HGCM
7400
7401	Bstr bstrName(strName);
7402	Bstr bstrHostPath(aData.m_strHostPath);
7403
7404	cbString = (bstrHostPath.length() + 1) * sizeof(RTUTF16);
7405	if (cbString >= UINT16_MAX)
7406	return setError(E_INVALIDARG, tr("The name is too long"));
7407	pFolderName = (SHFLSTRING*)RTMemAllocZ(sizeof(SHFLSTRING) + cbString);
7408	Assert(pFolderName);
7409	memcpy(pFolderName->String.ucs2, bstrHostPath.raw(), cbString);
7410
7411	pFolderName->u16Size = (uint16_t)cbString;
7412	pFolderName->u16Length = (uint16_t)cbString - sizeof(RTUTF16);
7413
7414	parms[0].type = VBOX_HGCM_SVC_PARM_PTR;
7415	parms[0].u.pointer.addr = pFolderName;
7416	parms[0].u.pointer.size = sizeof(SHFLSTRING) + (uint16_t)cbString;
7417
7418	cbString = (bstrName.length() + 1) * sizeof(RTUTF16);
7419	if (cbString >= UINT16_MAX)
7420	{
7421	RTMemFree(pFolderName);
7422	return setError(E_INVALIDARG, tr("The host path is too long"));
7423	}
7424	pMapName = (SHFLSTRING*)RTMemAllocZ(sizeof(SHFLSTRING) + cbString);
7425	Assert(pMapName);
7426	memcpy(pMapName->String.ucs2, bstrName.raw(), cbString);
7427
7428	pMapName->u16Size = (uint16_t)cbString;
7429	pMapName->u16Length = (uint16_t)cbString - sizeof(RTUTF16);
7430
7431	parms[1].type = VBOX_HGCM_SVC_PARM_PTR;
7432	parms[1].u.pointer.addr = pMapName;
7433	parms[1].u.pointer.size = sizeof(SHFLSTRING) + (uint16_t)cbString;
7434
7435	parms[2].type = VBOX_HGCM_SVC_PARM_32BIT;
7436	parms[2].u.uint32 = (aData.m_fWritable ? SHFL_ADD_MAPPING_F_WRITABLE : 0)
7437	\| (aData.m_fAutoMount ? SHFL_ADD_MAPPING_F_AUTOMOUNT : 0)
7438	\| (fSymlinksCreate ? SHFL_ADD_MAPPING_F_CREATE_SYMLINKS : 0)
7439	\| (fMissing ? SHFL_ADD_MAPPING_F_MISSING : 0)
7440	;
7441
7442	vrc = m_pVMMDev->hgcmHostCall("VBoxSharedFolders",
7443	SHFL_FN_ADD_MAPPING,
7444	SHFL_CPARMS_ADD_MAPPING, &parms[0]);
7445	RTMemFree(pFolderName);
7446	RTMemFree(pMapName);
7447
7448	if (RT_FAILURE(vrc))
7449	return setError(E_FAIL,
7450	tr("Could not create a shared folder '%s' mapped to '%s' (%Rrc)"),
7451	strName.c_str(), aData.m_strHostPath.c_str(), vrc);
7452
7453	if (fMissing)
7454	return setError(E_INVALIDARG,
7455	tr("Shared folder path '%s' does not exist on the host"),
7456	aData.m_strHostPath.c_str());
7457
7458	return S_OK;
7459	}
7460
7461	/**
7462	* Calls the HGCM service to remove the shared folder definition.
7463	*
7464	* @param aName Shared folder name.
7465	*
7466	* @note Must be called from under AutoVMCaller and when mpUVM != NULL!
7467	* @note Doesn't lock anything.
7468	*/
7469	HRESULT Console::removeSharedFolder(const Utf8Str &strName)
7470	{
7471	ComAssertRet(strName.isNotEmpty(), E_FAIL);
7472
7473	/* sanity checks */
7474	AssertReturn(mpUVM, E_FAIL);
7475	AssertReturn(m_pVMMDev && m_pVMMDev->isShFlActive(), E_FAIL);
7476
7477	VBOXHGCMSVCPARM parms;
7478	SHFLSTRING *pMapName;
7479	size_t cbString;
7480
7481	Log(("Removing shared folder '%s'\n", strName.c_str()));
7482
7483	Bstr bstrName(strName);
7484	cbString = (bstrName.length() + 1) * sizeof(RTUTF16);
7485	if (cbString >= UINT16_MAX)
7486	return setError(E_INVALIDARG, tr("The name is too long"));
7487	pMapName = (SHFLSTRING *) RTMemAllocZ(sizeof(SHFLSTRING) + cbString);
7488	Assert(pMapName);
7489	memcpy(pMapName->String.ucs2, bstrName.raw(), cbString);
7490
7491	pMapName->u16Size = (uint16_t)cbString;
7492	pMapName->u16Length = (uint16_t)cbString - sizeof(RTUTF16);
7493
7494	parms.type = VBOX_HGCM_SVC_PARM_PTR;
7495	parms.u.pointer.addr = pMapName;
7496	parms.u.pointer.size = sizeof(SHFLSTRING) + (uint16_t)cbString;
7497
7498	int vrc = m_pVMMDev->hgcmHostCall("VBoxSharedFolders",
7499	SHFL_FN_REMOVE_MAPPING,
7500	1, &parms);
7501	RTMemFree(pMapName);
7502	if (RT_FAILURE(vrc))
7503	return setError(E_FAIL,
7504	tr("Could not remove the shared folder '%s' (%Rrc)"),
7505	strName.c_str(), vrc);
7506
7507	return S_OK;
7508	}
7509
7510	/** @callback_method_impl{FNVMATSTATE}
7511	*
7512	* @note Locks the Console object for writing.
7513	* @remarks The @a pUVM parameter can be NULL in one case where powerUpThread()
7514	* calls after the VM was destroyed.
7515	*/
7516	DECLCALLBACK(void) Console::vmstateChangeCallback(PUVM pUVM, VMSTATE enmState, VMSTATE enmOldState, void *pvUser)
7517	{
7518	LogFlowFunc(("Changing state from %s to %s (pUVM=%p)\n",
7519	VMR3GetStateName(enmOldState), VMR3GetStateName(enmState), pUVM));
7520
7521	Console that = static_cast<Console >(pvUser);
7522	AssertReturnVoid(that);
7523
7524	AutoCaller autoCaller(that);
7525
7526	/* Note that we must let this method proceed even if Console::uninit() has
7527	* been already called. In such case this VMSTATE change is a result of:
7528	* 1) powerDown() called from uninit() itself, or
7529	* 2) VM-(guest-)initiated power off. */
7530	AssertReturnVoid( autoCaller.isOk()
7531	\|\| autoCaller.state() == InUninit);
7532
7533	switch (enmState)
7534	{
7535	/*
7536	* The VM has terminated
7537	*/
7538	case VMSTATE_OFF:
7539	{
7540	AutoWriteLock alock(that COMMA_LOCKVAL_SRC_POS);
7541
7542	if (that->mVMStateChangeCallbackDisabled)
7543	break;
7544
7545	/* Do we still think that it is running? It may happen if this is a
7546	* VM-(guest-)initiated shutdown/poweroff.
7547	*/
7548	if ( that->mMachineState != MachineState_Stopping
7549	&& that->mMachineState != MachineState_Saving
7550	&& that->mMachineState != MachineState_Restoring
7551	&& that->mMachineState != MachineState_TeleportingIn
7552	&& that->mMachineState != MachineState_FaultTolerantSyncing
7553	&& that->mMachineState != MachineState_TeleportingPausedVM
7554	&& !that->mVMIsAlreadyPoweringOff
7555	)
7556	{
7557	LogFlowFunc(("VM has powered itself off but Console still thinks it is running. Notifying.\n"));
7558
7559	/* prevent powerDown() from calling VMR3PowerOff() again */
7560	Assert(that->mVMPoweredOff == false);
7561	that->mVMPoweredOff = true;
7562
7563	/*
7564	* request a progress object from the server
7565	* (this will set the machine state to Stopping on the server
7566	* to block others from accessing this machine)
7567	*/
7568	ComPtr<IProgress> pProgress;
7569	HRESULT rc = that->mControl->BeginPoweringDown(pProgress.asOutParam());
7570	AssertComRC(rc);
7571
7572	/* sync the state with the server */
7573	that->setMachineStateLocally(MachineState_Stopping);
7574
7575	/* Setup task object and thread to carry out the operation
7576	* asynchronously (if we call powerDown() right here but there
7577	* is one or more mpUVM callers (added with addVMCaller()) we'll
7578	* deadlock).
7579	*/
7580	std::auto_ptr<VMPowerDownTask> task(new VMPowerDownTask(that, pProgress));
7581
7582	/* If creating a task failed, this can currently mean one of
7583	* two: either Console::uninit() has been called just a ms
7584	* before (so a powerDown() call is already on the way), or
7585	* powerDown() itself is being already executed. Just do
7586	* nothing.
7587	*/
7588	if (!task->isOk())
7589	{
7590	LogFlowFunc(("Console is already being uninitialized.\n"));
7591	break;
7592	}
7593
7594	int vrc = RTThreadCreate(NULL, Console::powerDownThread,
7595	(void *)task.get(), 0,
7596	RTTHREADTYPE_MAIN_WORKER, 0,
7597	"VMPwrDwn");
7598	AssertMsgRCBreak(vrc, ("Could not create VMPowerDown thread (%Rrc)\n", vrc));
7599
7600	/* task is now owned by powerDownThread(), so release it */
7601	task.release();
7602	}
7603	break;
7604	}
7605
7606	/* The VM has been completely destroyed.
7607	*
7608	* Note: This state change can happen at two points:
7609	* 1) At the end of VMR3Destroy() if it was not called from EMT.
7610	* 2) At the end of vmR3EmulationThread if VMR3Destroy() was
7611	* called by EMT.
7612	*/
7613	case VMSTATE_TERMINATED:
7614	{
7615	AutoWriteLock alock(that COMMA_LOCKVAL_SRC_POS);
7616
7617	if (that->mVMStateChangeCallbackDisabled)
7618	break;
7619
7620	/* Terminate host interface networking. If pUVM is NULL, we've been
7621	* manually called from powerUpThread() either before calling
7622	* VMR3Create() or after VMR3Create() failed, so no need to touch
7623	* networking.
7624	*/
7625	if (pUVM)
7626	that->powerDownHostInterfaces();
7627
7628	/* From now on the machine is officially powered down or remains in
7629	* the Saved state.
7630	*/
7631	switch (that->mMachineState)
7632	{
7633	default:
7634	AssertFailed();
7635	/* fall through */
7636	case MachineState_Stopping:
7637	/* successfully powered down */
7638	that->setMachineState(MachineState_PoweredOff);
7639	break;
7640	case MachineState_Saving:
7641	/* successfully saved */
7642	that->setMachineState(MachineState_Saved);
7643	break;
7644	case MachineState_Starting:
7645	/* failed to start, but be patient: set back to PoweredOff
7646	* (for similarity with the below) */
7647	that->setMachineState(MachineState_PoweredOff);
7648	break;
7649	case MachineState_Restoring:
7650	/* failed to load the saved state file, but be patient: set
7651	* back to Saved (to preserve the saved state file) */
7652	that->setMachineState(MachineState_Saved);
7653	break;
7654	case MachineState_TeleportingIn:
7655	/* Teleportation failed or was canceled. Back to powered off. */
7656	that->setMachineState(MachineState_PoweredOff);
7657	break;
7658	case MachineState_TeleportingPausedVM:
7659	/* Successfully teleported the VM. */
7660	that->setMachineState(MachineState_Teleported);
7661	break;
7662	case MachineState_FaultTolerantSyncing:
7663	/* Fault tolerant sync failed or was canceled. Back to powered off. */
7664	that->setMachineState(MachineState_PoweredOff);
7665	break;
7666	}
7667	break;
7668	}
7669
7670	case VMSTATE_RESETTING:
7671	{
7672	#ifdef VBOX_WITH_GUEST_PROPS
7673	/* Do not take any read/write locks here! */
7674	that->guestPropertiesHandleVMReset();
7675	#endif
7676	break;
7677	}
7678
7679	case VMSTATE_SUSPENDED:
7680	{
7681	AutoWriteLock alock(that COMMA_LOCKVAL_SRC_POS);
7682
7683	if (that->mVMStateChangeCallbackDisabled)
7684	break;
7685
7686	switch (that->mMachineState)
7687	{
7688	case MachineState_Teleporting:
7689	that->setMachineState(MachineState_TeleportingPausedVM);
7690	break;
7691
7692	case MachineState_LiveSnapshotting:
7693	that->setMachineState(MachineState_Saving);
7694	break;
7695
7696	case MachineState_TeleportingPausedVM:
7697	case MachineState_Saving:
7698	case MachineState_Restoring:
7699	case MachineState_Stopping:
7700	case MachineState_TeleportingIn:
7701	case MachineState_FaultTolerantSyncing:
7702	/* The worker thread handles the transition. */
7703	break;
7704
7705	default:
7706	AssertMsgFailed(("%s\n", Global::stringifyMachineState(that->mMachineState)));
7707	case MachineState_Running:
7708	that->setMachineState(MachineState_Paused);
7709	break;
7710
7711	case MachineState_Paused:
7712	/* Nothing to do. */
7713	break;
7714	}
7715	break;
7716	}
7717
7718	case VMSTATE_SUSPENDED_LS:
7719	case VMSTATE_SUSPENDED_EXT_LS:
7720	{
7721	AutoWriteLock alock(that COMMA_LOCKVAL_SRC_POS);
7722	if (that->mVMStateChangeCallbackDisabled)
7723	break;
7724	switch (that->mMachineState)
7725	{
7726	case MachineState_Teleporting:
7727	that->setMachineState(MachineState_TeleportingPausedVM);
7728	break;
7729
7730	case MachineState_LiveSnapshotting:
7731	that->setMachineState(MachineState_Saving);
7732	break;
7733
7734	case MachineState_TeleportingPausedVM:
7735	case MachineState_Saving:
7736	/* ignore */
7737	break;
7738
7739	default:
7740	AssertMsgFailed(("%s/%s -> %s\n", Global::stringifyMachineState(that->mMachineState), VMR3GetStateName(enmOldState), VMR3GetStateName(enmState) ));
7741	that->setMachineState(MachineState_Paused);
7742	break;
7743	}
7744	break;
7745	}
7746
7747	case VMSTATE_RUNNING:
7748	{
7749	if ( enmOldState == VMSTATE_POWERING_ON
7750	\|\| enmOldState == VMSTATE_RESUMING
7751	\|\| enmOldState == VMSTATE_RUNNING_FT)
7752	{
7753	AutoWriteLock alock(that COMMA_LOCKVAL_SRC_POS);
7754
7755	if (that->mVMStateChangeCallbackDisabled)
7756	break;
7757
7758	Assert( ( ( that->mMachineState == MachineState_Starting
7759	\|\| that->mMachineState == MachineState_Paused)
7760	&& enmOldState == VMSTATE_POWERING_ON)
7761	\|\| ( ( that->mMachineState == MachineState_Restoring
7762	\|\| that->mMachineState == MachineState_TeleportingIn
7763	\|\| that->mMachineState == MachineState_Paused
7764	\|\| that->mMachineState == MachineState_Saving
7765	)
7766	&& enmOldState == VMSTATE_RESUMING)
7767	\|\| ( that->mMachineState == MachineState_FaultTolerantSyncing
7768	&& enmOldState == VMSTATE_RUNNING_FT));
7769
7770	that->setMachineState(MachineState_Running);
7771	}
7772
7773	break;
7774	}
7775
7776	case VMSTATE_RUNNING_LS:
7777	AssertMsg( that->mMachineState == MachineState_LiveSnapshotting
7778	\|\| that->mMachineState == MachineState_Teleporting,
7779	("%s/%s -> %s\n", Global::stringifyMachineState(that->mMachineState), VMR3GetStateName(enmOldState), VMR3GetStateName(enmState) ));
7780	break;
7781
7782	case VMSTATE_RUNNING_FT:
7783	AssertMsg(that->mMachineState == MachineState_FaultTolerantSyncing,
7784	("%s/%s -> %s\n", Global::stringifyMachineState(that->mMachineState), VMR3GetStateName(enmOldState), VMR3GetStateName(enmState) ));
7785	break;
7786
7787	case VMSTATE_FATAL_ERROR:
7788	{
7789	AutoWriteLock alock(that COMMA_LOCKVAL_SRC_POS);
7790
7791	if (that->mVMStateChangeCallbackDisabled)
7792	break;
7793
7794	/* Fatal errors are only for running VMs. */
7795	Assert(Global::IsOnline(that->mMachineState));
7796
7797	/* Note! 'Pause' is used here in want of something better. There
7798	* are currently only two places where fatal errors might be
7799	* raised, so it is not worth adding a new externally
7800	* visible state for this yet. */
7801	that->setMachineState(MachineState_Paused);
7802	break;
7803	}
7804
7805	case VMSTATE_GURU_MEDITATION:
7806	{
7807	AutoWriteLock alock(that COMMA_LOCKVAL_SRC_POS);
7808
7809	if (that->mVMStateChangeCallbackDisabled)
7810	break;
7811
7812	/* Guru are only for running VMs */
7813	Assert(Global::IsOnline(that->mMachineState));
7814
7815	that->setMachineState(MachineState_Stuck);
7816	break;
7817	}
7818
7819	default: /* shut up gcc */
7820	break;
7821	}
7822	}
7823
7824	/**
7825	* Changes the clipboard mode.
7826	*
7827	* @param aClipboardMode new clipboard mode.
7828	*/
7829	void Console::changeClipboardMode(ClipboardMode_T aClipboardMode)
7830	{
7831	VMMDev *pVMMDev = m_pVMMDev;
7832	Assert(pVMMDev);
7833
7834	VBOXHGCMSVCPARM parm;
7835	parm.type = VBOX_HGCM_SVC_PARM_32BIT;
7836
7837	switch (aClipboardMode)
7838	{
7839	default:
7840	case ClipboardMode_Disabled:
7841	LogRel(("Shared clipboard mode: Off\n"));
7842	parm.u.uint32 = VBOX_SHARED_CLIPBOARD_MODE_OFF;
7843	break;
7844	case ClipboardMode_GuestToHost:
7845	LogRel(("Shared clipboard mode: Guest to Host\n"));
7846	parm.u.uint32 = VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST;
7847	break;
7848	case ClipboardMode_HostToGuest:
7849	LogRel(("Shared clipboard mode: Host to Guest\n"));
7850	parm.u.uint32 = VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST;
7851	break;
7852	case ClipboardMode_Bidirectional:
7853	LogRel(("Shared clipboard mode: Bidirectional\n"));
7854	parm.u.uint32 = VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL;
7855	break;
7856	}
7857
7858	pVMMDev->hgcmHostCall("VBoxSharedClipboard", VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE, 1, &parm);
7859	}
7860
7861	/**
7862	* Changes the drag'n_drop mode.
7863	*
7864	* @param aDragAndDropMode new drag'n'drop mode.
7865	*/
7866	void Console::changeDragAndDropMode(DragAndDropMode_T aDragAndDropMode)
7867	{
7868	VMMDev *pVMMDev = m_pVMMDev;
7869	Assert(pVMMDev);
7870
7871	VBOXHGCMSVCPARM parm;
7872	parm.type = VBOX_HGCM_SVC_PARM_32BIT;
7873
7874	switch (aDragAndDropMode)
7875	{
7876	default:
7877	case DragAndDropMode_Disabled:
7878	LogRel(("Drag'n'drop mode: Off\n"));
7879	parm.u.uint32 = VBOX_DRAG_AND_DROP_MODE_OFF;
7880	break;
7881	case DragAndDropMode_GuestToHost:
7882	LogRel(("Drag'n'drop mode: Guest to Host\n"));
7883	parm.u.uint32 = VBOX_DRAG_AND_DROP_MODE_GUEST_TO_HOST;
7884	break;
7885	case DragAndDropMode_HostToGuest:
7886	LogRel(("Drag'n'drop mode: Host to Guest\n"));
7887	parm.u.uint32 = VBOX_DRAG_AND_DROP_MODE_HOST_TO_GUEST;
7888	break;
7889	case DragAndDropMode_Bidirectional:
7890	LogRel(("Drag'n'drop mode: Bidirectional\n"));
7891	parm.u.uint32 = VBOX_DRAG_AND_DROP_MODE_BIDIRECTIONAL;
7892	break;
7893	}
7894
7895	pVMMDev->hgcmHostCall("VBoxDragAndDropSvc", DragAndDropSvc::HOST_DND_SET_MODE, 1, &parm);
7896	}
7897
7898	#ifdef VBOX_WITH_USB
7899	/**
7900	* Sends a request to VMM to attach the given host device.
7901	* After this method succeeds, the attached device will appear in the
7902	* mUSBDevices collection.
7903	*
7904	* @param aHostDevice device to attach
7905	*
7906	* @note Synchronously calls EMT.
7907	*/
7908	HRESULT Console::attachUSBDevice(IUSBDevice *aHostDevice, ULONG aMaskedIfs)
7909	{
7910	AssertReturn(aHostDevice, E_FAIL);
7911	AssertReturn(!isWriteLockOnCurrentThread(), E_FAIL);
7912
7913	HRESULT hrc;
7914
7915	/*
7916	* Get the address and the Uuid, and call the pfnCreateProxyDevice roothub
7917	* method in EMT (using usbAttachCallback()).
7918	*/
7919	Bstr BstrAddress;
7920	hrc = aHostDevice->COMGETTER(Address)(BstrAddress.asOutParam());
7921	ComAssertComRCRetRC(hrc);
7922
7923	Utf8Str Address(BstrAddress);
7924
7925	Bstr id;
7926	hrc = aHostDevice->COMGETTER(Id)(id.asOutParam());
7927	ComAssertComRCRetRC(hrc);
7928	Guid uuid(id);
7929
7930	BOOL fRemote = FALSE;
7931	hrc = aHostDevice->COMGETTER(Remote)(&fRemote);
7932	ComAssertComRCRetRC(hrc);
7933
7934	/* Get the VM handle. */
7935	SafeVMPtr ptrVM(this);
7936	if (!ptrVM.isOk())
7937	return ptrVM.rc();
7938
7939	LogFlowThisFunc(("Proxying USB device '%s' {%RTuuid}...\n",
7940	Address.c_str(), uuid.raw()));
7941
7942	void *pvRemoteBackend = NULL;
7943	if (fRemote)
7944	{
7945	RemoteUSBDevice pRemoteUSBDevice = static_cast<RemoteUSBDevice >(aHostDevice);
7946	pvRemoteBackend = consoleVRDPServer()->USBBackendRequestPointer(pRemoteUSBDevice->clientId(), &uuid);
7947	if (!pvRemoteBackend)
7948	return E_INVALIDARG; /* The clientId is invalid then. */
7949	}
7950
7951	USHORT portVersion = 1;
7952	hrc = aHostDevice->COMGETTER(PortVersion)(&portVersion);
7953	AssertComRCReturnRC(hrc);
7954	Assert(portVersion == 1 \|\| portVersion == 2);
7955
7956	int vrc = VMR3ReqCallWaitU(ptrVM.rawUVM(), 0 /* idDstCpu (saved state, see #6232) */,
7957	(PFNRT)usbAttachCallback, 9,
7958	this, ptrVM.rawUVM(), aHostDevice, uuid.raw(), fRemote,
7959	Address.c_str(), pvRemoteBackend, portVersion, aMaskedIfs);
7960
7961	if (RT_SUCCESS(vrc))
7962	{
7963	/* Create a OUSBDevice and add it to the device list */
7964	ComObjPtr<OUSBDevice> pUSBDevice;
7965	pUSBDevice.createObject();
7966	hrc = pUSBDevice->init(aHostDevice);
7967	AssertComRC(hrc);
7968
7969	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7970	mUSBDevices.push_back(pUSBDevice);
7971	LogFlowFunc(("Attached device {%RTuuid}\n", pUSBDevice->id().raw()));
7972
7973	/* notify callbacks */
7974	alock.release();
7975	onUSBDeviceStateChange(pUSBDevice, true /* aAttached */, NULL);
7976	}
7977	else
7978	{
7979	LogWarningThisFunc(("Failed to create proxy device for '%s' {%RTuuid} (%Rrc)\n",
7980	Address.c_str(), uuid.raw(), vrc));
7981
7982	switch (vrc)
7983	{
7984	case VERR_VUSB_NO_PORTS:
7985	hrc = setError(E_FAIL, tr("Failed to attach the USB device. (No available ports on the USB controller)."));
7986	break;
7987	case VERR_VUSB_USBFS_PERMISSION:
7988	hrc = setError(E_FAIL, tr("Not permitted to open the USB device, check usbfs options"));
7989	break;
7990	default:
7991	hrc = setError(E_FAIL, tr("Failed to create a proxy device for the USB device. (Error: %Rrc)"), vrc);
7992	break;
7993	}
7994	}
7995
7996	return hrc;
7997	}
7998
7999	/**
8000	* USB device attach callback used by AttachUSBDevice().
8001	* Note that AttachUSBDevice() doesn't return until this callback is executed,
8002	* so we don't use AutoCaller and don't care about reference counters of
8003	* interface pointers passed in.
8004	*
8005	* @thread EMT
8006	* @note Locks the console object for writing.
8007	*/
8008	//static
8009	DECLCALLBACK(int)
8010	Console::usbAttachCallback(Console that, PUVM pUVM, IUSBDevice aHostDevice, PCRTUUID aUuid, bool aRemote,
8011	const char aAddress, void pvRemoteBackend, USHORT aPortVersion, ULONG aMaskedIfs)
8012	{
8013	LogFlowFuncEnter();
8014	LogFlowFunc(("that={%p} aUuid={%RTuuid}\n", that, aUuid));
8015
8016	AssertReturn(that && aUuid, VERR_INVALID_PARAMETER);
8017	AssertReturn(!that->isWriteLockOnCurrentThread(), VERR_GENERAL_FAILURE);
8018
8019	int vrc = PDMR3UsbCreateProxyDevice(pUVM, aUuid, aRemote, aAddress, pvRemoteBackend,
8020	aPortVersion == 1 ? VUSB_STDVER_11 : VUSB_STDVER_20, aMaskedIfs);
8021	LogFlowFunc(("vrc=%Rrc\n", vrc));
8022	LogFlowFuncLeave();
8023	return vrc;
8024	}
8025
8026	/**
8027	* Sends a request to VMM to detach the given host device. After this method
8028	* succeeds, the detached device will disappear from the mUSBDevices
8029	* collection.
8030	*
8031	* @param aHostDevice device to attach
8032	*
8033	* @note Synchronously calls EMT.
8034	*/
8035	HRESULT Console::detachUSBDevice(const ComObjPtr<OUSBDevice> &aHostDevice)
8036	{
8037	AssertReturn(!isWriteLockOnCurrentThread(), E_FAIL);
8038
8039	/* Get the VM handle. */
8040	SafeVMPtr ptrVM(this);
8041	if (!ptrVM.isOk())
8042	return ptrVM.rc();
8043
8044	/* if the device is attached, then there must at least one USB hub. */
8045	AssertReturn(PDMR3UsbHasHub(ptrVM.rawUVM()), E_FAIL);
8046
8047	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
8048	LogFlowThisFunc(("Detaching USB proxy device {%RTuuid}...\n",
8049	aHostDevice->id().raw()));
8050
8051	/*
8052	* If this was a remote device, release the backend pointer.
8053	* The pointer was requested in usbAttachCallback.
8054	*/
8055	BOOL fRemote = FALSE;
8056
8057	HRESULT hrc2 = aHostDevice->COMGETTER(Remote)(&fRemote);
8058	if (FAILED(hrc2))
8059	setErrorStatic(hrc2, "GetRemote() failed");
8060
8061	PCRTUUID pUuid = aHostDevice->id().raw();
8062	if (fRemote)
8063	{
8064	Guid guid(*pUuid);
8065	consoleVRDPServer()->USBBackendReleasePointer(&guid);
8066	}
8067
8068	alock.release();
8069	int vrc = VMR3ReqCallWaitU(ptrVM.rawUVM(), 0 /* idDstCpu (saved state, see #6232) */,
8070	(PFNRT)usbDetachCallback, 5,
8071	this, ptrVM.rawUVM(), pUuid);
8072	if (RT_SUCCESS(vrc))
8073	{
8074	LogFlowFunc(("Detached device {%RTuuid}\n", pUuid));
8075
8076	/* notify callbacks */
8077	onUSBDeviceStateChange(aHostDevice, false /* aAttached */, NULL);
8078	}
8079
8080	ComAssertRCRet(vrc, E_FAIL);
8081
8082	return S_OK;
8083	}
8084
8085	/**
8086	* USB device detach callback used by DetachUSBDevice().
8087	*
8088	* Note that DetachUSBDevice() doesn't return until this callback is executed,
8089	* so we don't use AutoCaller and don't care about reference counters of
8090	* interface pointers passed in.
8091	*
8092	* @thread EMT
8093	*/
8094	//static
8095	DECLCALLBACK(int)
8096	Console::usbDetachCallback(Console *that, PUVM pUVM, PCRTUUID aUuid)
8097	{
8098	LogFlowFuncEnter();
8099	LogFlowFunc(("that={%p} aUuid={%RTuuid}\n", that, aUuid));
8100
8101	AssertReturn(that && aUuid, VERR_INVALID_PARAMETER);
8102	AssertReturn(!that->isWriteLockOnCurrentThread(), VERR_GENERAL_FAILURE);
8103
8104	int vrc = PDMR3UsbDetachDevice(pUVM, aUuid);
8105
8106	LogFlowFunc(("vrc=%Rrc\n", vrc));
8107	LogFlowFuncLeave();
8108	return vrc;
8109	}
8110	#endif /* VBOX_WITH_USB */
8111
8112	/* Note: FreeBSD needs this whether netflt is used or not. */
8113	#if ((defined(RT_OS_LINUX) && !defined(VBOX_WITH_NETFLT)) \|\| defined(RT_OS_FREEBSD))
8114	/**
8115	* Helper function to handle host interface device creation and attachment.
8116	*
8117	* @param networkAdapter the network adapter which attachment should be reset
8118	* @return COM status code
8119	*
8120	* @note The caller must lock this object for writing.
8121	*
8122	* @todo Move this back into the driver!
8123	*/
8124	HRESULT Console::attachToTapInterface(INetworkAdapter *networkAdapter)
8125	{
8126	LogFlowThisFunc(("\n"));
8127	/* sanity check */
8128	AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
8129
8130	# ifdef VBOX_STRICT
8131	/* paranoia */
8132	NetworkAttachmentType_T attachment;
8133	networkAdapter->COMGETTER(AttachmentType)(&attachment);
8134	Assert(attachment == NetworkAttachmentType_Bridged);
8135	# endif /* VBOX_STRICT */
8136
8137	HRESULT rc = S_OK;
8138
8139	ULONG slot = 0;
8140	rc = networkAdapter->COMGETTER(Slot)(&slot);
8141	AssertComRC(rc);
8142
8143	# ifdef RT_OS_LINUX
8144	/*
8145	* Allocate a host interface device
8146	*/
8147	int rcVBox = RTFileOpen(&maTapFD[slot], "/dev/net/tun",
8148	RTFILE_O_READWRITE \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE \| RTFILE_O_INHERIT);
8149	if (RT_SUCCESS(rcVBox))
8150	{
8151	/*
8152	* Set/obtain the tap interface.
8153	*/
8154	struct ifreq IfReq;
8155	memset(&IfReq, 0, sizeof(IfReq));
8156	/* The name of the TAP interface we are using */
8157	Bstr tapDeviceName;
8158	rc = networkAdapter->COMGETTER(BridgedInterface)(tapDeviceName.asOutParam());
8159	if (FAILED(rc))
8160	tapDeviceName.setNull(); /* Is this necessary? */
8161	if (tapDeviceName.isEmpty())
8162	{
8163	LogRel(("No TAP device name was supplied.\n"));
8164	rc = setError(E_FAIL, tr("No TAP device name was supplied for the host networking interface"));
8165	}
8166
8167	if (SUCCEEDED(rc))
8168	{
8169	/* If we are using a static TAP device then try to open it. */
8170	Utf8Str str(tapDeviceName);
8171	if (str.length() <= sizeof(IfReq.ifr_name))
8172	strcpy(IfReq.ifr_name, str.c_str());
8173	else
8174	memcpy(IfReq.ifr_name, str.c_str(), sizeof(IfReq.ifr_name) - 1); /** @todo bitch about names which are too long... */
8175	IfReq.ifr_flags = IFF_TAP \| IFF_NO_PI;
8176	rcVBox = ioctl(maTapFD[slot], TUNSETIFF, &IfReq);
8177	if (rcVBox != 0)
8178	{
8179	LogRel(("Failed to open the host network interface %ls\n", tapDeviceName.raw()));
8180	rc = setError(E_FAIL,
8181	tr("Failed to open the host network interface %ls"),
8182	tapDeviceName.raw());
8183	}
8184	}
8185	if (SUCCEEDED(rc))
8186	{
8187	/*
8188	* Make it pollable.
8189	*/
8190	if (fcntl(maTapFD[slot], F_SETFL, O_NONBLOCK) != -1)
8191	{
8192	Log(("attachToTapInterface: %RTfile %ls\n", maTapFD[slot], tapDeviceName.raw()));
8193	/*
8194	* Here is the right place to communicate the TAP file descriptor and
8195	* the host interface name to the server if/when it becomes really
8196	* necessary.
8197	*/
8198	maTAPDeviceName[slot] = tapDeviceName;
8199	rcVBox = VINF_SUCCESS;
8200	}
8201	else
8202	{
8203	int iErr = errno;
8204
8205	LogRel(("Configuration error: Failed to configure /dev/net/tun non blocking. Error: %s\n", strerror(iErr)));
8206	rcVBox = VERR_HOSTIF_BLOCKING;
8207	rc = setError(E_FAIL,
8208	tr("could not set up the host networking device for non blocking access: %s"),
8209	strerror(errno));
8210	}
8211	}
8212	}
8213	else
8214	{
8215	LogRel(("Configuration error: Failed to open /dev/net/tun rc=%Rrc\n", rcVBox));
8216	switch (rcVBox)
8217	{
8218	case VERR_ACCESS_DENIED:
8219	/* will be handled by our caller */
8220	rc = rcVBox;
8221	break;
8222	default:
8223	rc = setError(E_FAIL,
8224	tr("Could not set up the host networking device: %Rrc"),
8225	rcVBox);
8226	break;
8227	}
8228	}
8229
8230	# elif defined(RT_OS_FREEBSD)
8231	/*
8232	* Set/obtain the tap interface.
8233	*/
8234	/* The name of the TAP interface we are using */
8235	Bstr tapDeviceName;
8236	rc = networkAdapter->COMGETTER(BridgedInterface)(tapDeviceName.asOutParam());
8237	if (FAILED(rc))
8238	tapDeviceName.setNull(); /* Is this necessary? */
8239	if (tapDeviceName.isEmpty())
8240	{
8241	LogRel(("No TAP device name was supplied.\n"));
8242	rc = setError(E_FAIL, tr("No TAP device name was supplied for the host networking interface"));
8243	}
8244	char szTapdev[1024] = "/dev/";
8245	/* If we are using a static TAP device then try to open it. */
8246	Utf8Str str(tapDeviceName);
8247	if (str.length() + strlen(szTapdev) <= sizeof(szTapdev))
8248	strcat(szTapdev, str.c_str());
8249	else
8250	memcpy(szTapdev + strlen(szTapdev), str.c_str(),
8251	sizeof(szTapdev) - strlen(szTapdev) - 1); /** @todo bitch about names which are too long... */
8252	int rcVBox = RTFileOpen(&maTapFD[slot], szTapdev,
8253	RTFILE_O_READWRITE \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE \| RTFILE_O_INHERIT \| RTFILE_O_NON_BLOCK);
8254
8255	if (RT_SUCCESS(rcVBox))
8256	maTAPDeviceName[slot] = tapDeviceName;
8257	else
8258	{
8259	switch (rcVBox)
8260	{
8261	case VERR_ACCESS_DENIED:
8262	/* will be handled by our caller */
8263	rc = rcVBox;
8264	break;
8265	default:
8266	rc = setError(E_FAIL,
8267	tr("Failed to open the host network interface %ls"),
8268	tapDeviceName.raw());
8269	break;
8270	}
8271	}
8272	# else
8273	# error "huh?"
8274	# endif
8275	/* in case of failure, cleanup. */
8276	if (RT_FAILURE(rcVBox) && SUCCEEDED(rc))
8277	{
8278	LogRel(("General failure attaching to host interface\n"));
8279	rc = setError(E_FAIL,
8280	tr("General failure attaching to host interface"));
8281	}
8282	LogFlowThisFunc(("rc=%d\n", rc));
8283	return rc;
8284	}
8285
8286
8287	/**
8288	* Helper function to handle detachment from a host interface
8289	*
8290	* @param networkAdapter the network adapter which attachment should be reset
8291	* @return COM status code
8292	*
8293	* @note The caller must lock this object for writing.
8294	*
8295	* @todo Move this back into the driver!
8296	*/
8297	HRESULT Console::detachFromTapInterface(INetworkAdapter *networkAdapter)
8298	{
8299	/* sanity check */
8300	LogFlowThisFunc(("\n"));
8301	AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
8302
8303	HRESULT rc = S_OK;
8304	# ifdef VBOX_STRICT
8305	/* paranoia */
8306	NetworkAttachmentType_T attachment;
8307	networkAdapter->COMGETTER(AttachmentType)(&attachment);
8308	Assert(attachment == NetworkAttachmentType_Bridged);
8309	# endif /* VBOX_STRICT */
8310
8311	ULONG slot = 0;
8312	rc = networkAdapter->COMGETTER(Slot)(&slot);
8313	AssertComRC(rc);
8314
8315	/* is there an open TAP device? */
8316	if (maTapFD[slot] != NIL_RTFILE)
8317	{
8318	/*
8319	* Close the file handle.
8320	*/
8321	Bstr tapDeviceName, tapTerminateApplication;
8322	bool isStatic = true;
8323	rc = networkAdapter->COMGETTER(BridgedInterface)(tapDeviceName.asOutParam());
8324	if (FAILED(rc) \|\| tapDeviceName.isEmpty())
8325	{
8326	/* If the name is empty, this is a dynamic TAP device, so close it now,
8327	so that the termination script can remove the interface. Otherwise we still
8328	need the FD to pass to the termination script. */
8329	isStatic = false;
8330	int rcVBox = RTFileClose(maTapFD[slot]);
8331	AssertRC(rcVBox);
8332	maTapFD[slot] = NIL_RTFILE;
8333	}
8334	if (isStatic)
8335	{
8336	/* If we are using a static TAP device, we close it now, after having called the
8337	termination script. */
8338	int rcVBox = RTFileClose(maTapFD[slot]);
8339	AssertRC(rcVBox);
8340	}
8341	/* the TAP device name and handle are no longer valid */
8342	maTapFD[slot] = NIL_RTFILE;
8343	maTAPDeviceName[slot] = "";
8344	}
8345	LogFlowThisFunc(("returning %d\n", rc));
8346	return rc;
8347	}
8348	#endif /* (RT_OS_LINUX \|\| RT_OS_FREEBSD) && !VBOX_WITH_NETFLT */
8349
8350	/**
8351	* Called at power down to terminate host interface networking.
8352	*
8353	* @note The caller must lock this object for writing.
8354	*/
8355	HRESULT Console::powerDownHostInterfaces()
8356	{
8357	LogFlowThisFunc(("\n"));
8358
8359	/* sanity check */
8360	AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
8361
8362	/*
8363	* host interface termination handling
8364	*/
8365	HRESULT rc = S_OK;
8366	ComPtr<IVirtualBox> pVirtualBox;
8367	mMachine->COMGETTER(Parent)(pVirtualBox.asOutParam());
8368	ComPtr<ISystemProperties> pSystemProperties;
8369	if (pVirtualBox)
8370	pVirtualBox->COMGETTER(SystemProperties)(pSystemProperties.asOutParam());
8371	ChipsetType_T chipsetType = ChipsetType_PIIX3;
8372	mMachine->COMGETTER(ChipsetType)(&chipsetType);
8373	ULONG maxNetworkAdapters = 0;
8374	if (pSystemProperties)
8375	pSystemProperties->GetMaxNetworkAdapters(chipsetType, &maxNetworkAdapters);
8376
8377	for (ULONG slot = 0; slot < maxNetworkAdapters; slot++)
8378	{
8379	ComPtr<INetworkAdapter> pNetworkAdapter;
8380	rc = mMachine->GetNetworkAdapter(slot, pNetworkAdapter.asOutParam());
8381	if (FAILED(rc)) break;
8382
8383	BOOL enabled = FALSE;
8384	pNetworkAdapter->COMGETTER(Enabled)(&enabled);
8385	if (!enabled)
8386	continue;
8387
8388	NetworkAttachmentType_T attachment;
8389	pNetworkAdapter->COMGETTER(AttachmentType)(&attachment);
8390	if (attachment == NetworkAttachmentType_Bridged)
8391	{
8392	#if ((defined(RT_OS_LINUX) \|\| defined(RT_OS_FREEBSD)) && !defined(VBOX_WITH_NETFLT))
8393	HRESULT rc2 = detachFromTapInterface(pNetworkAdapter);
8394	if (FAILED(rc2) && SUCCEEDED(rc))
8395	rc = rc2;
8396	#endif /* (RT_OS_LINUX \|\| RT_OS_FREEBSD) && !VBOX_WITH_NETFLT */
8397	}
8398	}
8399
8400	return rc;
8401	}
8402
8403
8404	/**
8405	* Process callback handler for VMR3LoadFromFile, VMR3LoadFromStream, VMR3Save
8406	* and VMR3Teleport.
8407	*
8408	* @param pUVM The user mode VM handle.
8409	* @param uPercent Completion percentage (0-100).
8410	* @param pvUser Pointer to an IProgress instance.
8411	* @return VINF_SUCCESS.
8412	*/
8413	/static/
8414	DECLCALLBACK(int) Console::stateProgressCallback(PUVM pUVM, unsigned uPercent, void *pvUser)
8415	{
8416	IProgress pProgress = static_cast<IProgress >(pvUser);
8417
8418	/* update the progress object */
8419	if (pProgress)
8420	pProgress->SetCurrentOperationProgress(uPercent);
8421
8422	NOREF(pUVM);
8423	return VINF_SUCCESS;
8424	}
8425
8426	/**
8427	* @copydoc FNVMATERROR
8428	*
8429	* @remarks Might be some tiny serialization concerns with access to the string
8430	* object here...
8431	*/
8432	/static/ DECLCALLBACK(void)
8433	Console::genericVMSetErrorCallback(PUVM pUVM, void *pvUser, int rc, RT_SRC_POS_DECL,
8434	const char *pszErrorFmt, va_list va)
8435	{
8436	Utf8Str pErrorText = (Utf8Str )pvUser;
8437	AssertPtr(pErrorText);
8438
8439	/* We ignore RT_SRC_POS_DECL arguments to avoid confusion of end-users. */
8440	va_list va2;
8441	va_copy(va2, va);
8442
8443	/* Append to any the existing error message. */
8444	if (pErrorText->length())
8445	*pErrorText = Utf8StrFmt("%s.\n%N (%Rrc)", pErrorText->c_str(),
8446	pszErrorFmt, &va2, rc, rc);
8447	else
8448	*pErrorText = Utf8StrFmt("%N (%Rrc)", pszErrorFmt, &va2, rc, rc);
8449
8450	va_end(va2);
8451
8452	NOREF(pUVM);
8453	}
8454
8455	/**
8456	* VM runtime error callback function.
8457	* See VMSetRuntimeError for the detailed description of parameters.
8458	*
8459	* @param pUVM The user mode VM handle. Ignored, so passing NULL
8460	* is fine.
8461	* @param pvUser The user argument, pointer to the Console instance.
8462	* @param fFlags The action flags. See VMSETRTERR_FLAGS_*.
8463	* @param pszErrorId Error ID string.
8464	* @param pszFormat Error message format string.
8465	* @param va Error message arguments.
8466	* @thread EMT.
8467	*/
8468	/* static */ DECLCALLBACK(void)
8469	Console::setVMRuntimeErrorCallback(PUVM pUVM, void *pvUser, uint32_t fFlags,
8470	const char *pszErrorId,
8471	const char *pszFormat, va_list va)
8472	{
8473	bool const fFatal = !!(fFlags & VMSETRTERR_FLAGS_FATAL);
8474	LogFlowFuncEnter();
8475
8476	Console that = static_cast<Console >(pvUser);
8477	AssertReturnVoid(that);
8478
8479	Utf8Str message(pszFormat, va);
8480
8481	LogRel(("Console: VM runtime error: fatal=%RTbool, errorID=%s message=\"%s\"\n",
8482	fFatal, pszErrorId, message.c_str()));
8483
8484	that->onRuntimeError(BOOL(fFatal), Bstr(pszErrorId).raw(), Bstr(message).raw());
8485
8486	LogFlowFuncLeave(); NOREF(pUVM);
8487	}
8488
8489	/**
8490	* Captures USB devices that match filters of the VM.
8491	* Called at VM startup.
8492	*
8493	* @param pUVM The VM handle.
8494	*/
8495	HRESULT Console::captureUSBDevices(PUVM pUVM)
8496	{
8497	LogFlowThisFunc(("\n"));
8498
8499	/* sanity check */
8500	AssertReturn(!isWriteLockOnCurrentThread(), E_FAIL);
8501	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
8502
8503	/* If the machine has an USB controller, ask the USB proxy service to
8504	* capture devices */
8505	PPDMIBASE pBase;
8506	int vrc = PDMR3QueryLun(pUVM, "usb-ohci", 0, 0, &pBase);
8507	if (RT_SUCCESS(vrc))
8508	{
8509	/* release the lock before calling Host in VBoxSVC since Host may call
8510	* us back from under its lock (e.g. onUSBDeviceAttach()) which would
8511	* produce an inter-process dead-lock otherwise. */
8512	alock.release();
8513
8514	HRESULT hrc = mControl->AutoCaptureUSBDevices();
8515	ComAssertComRCRetRC(hrc);
8516	}
8517	else if ( vrc == VERR_PDM_DEVICE_NOT_FOUND
8518	\|\| vrc == VERR_PDM_DEVICE_INSTANCE_NOT_FOUND)
8519	vrc = VINF_SUCCESS;
8520	else
8521	AssertRC(vrc);
8522
8523	return RT_SUCCESS(vrc) ? S_OK : E_FAIL;
8524	}
8525
8526
8527	/**
8528	* Detach all USB device which are attached to the VM for the
8529	* purpose of clean up and such like.
8530	*/
8531	void Console::detachAllUSBDevices(bool aDone)
8532	{
8533	LogFlowThisFunc(("aDone=%RTbool\n", aDone));
8534
8535	/* sanity check */
8536	AssertReturnVoid(!isWriteLockOnCurrentThread());
8537	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
8538
8539	mUSBDevices.clear();
8540
8541	/* release the lock before calling Host in VBoxSVC since Host may call
8542	* us back from under its lock (e.g. onUSBDeviceAttach()) which would
8543	* produce an inter-process dead-lock otherwise. */
8544	alock.release();
8545
8546	mControl->DetachAllUSBDevices(aDone);
8547	}
8548
8549	/**
8550	* @note Locks this object for writing.
8551	*/
8552	void Console::processRemoteUSBDevices(uint32_t u32ClientId, VRDEUSBDEVICEDESC *pDevList, uint32_t cbDevList, bool fDescExt)
8553	{
8554	LogFlowThisFuncEnter();
8555	LogFlowThisFunc(("u32ClientId = %d, pDevList=%p, cbDevList = %d, fDescExt = %d\n", u32ClientId, pDevList, cbDevList, fDescExt));
8556
8557	AutoCaller autoCaller(this);
8558	if (!autoCaller.isOk())
8559	{
8560	/* Console has been already uninitialized, deny request */
8561	AssertMsgFailed(("Console is already uninitialized\n"));
8562	LogFlowThisFunc(("Console is already uninitialized\n"));
8563	LogFlowThisFuncLeave();
8564	return;
8565	}
8566
8567	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
8568
8569	/*
8570	* Mark all existing remote USB devices as dirty.
8571	*/
8572	for (RemoteUSBDeviceList::iterator it = mRemoteUSBDevices.begin();
8573	it != mRemoteUSBDevices.end();
8574	++it)
8575	{
8576	(*it)->dirty(true);
8577	}
8578
8579	/*
8580	* Process the pDevList and add devices those are not already in the mRemoteUSBDevices list.
8581	*/
8582	/** @todo (sunlover) REMOTE_USB Strict validation of the pDevList. */
8583	VRDEUSBDEVICEDESC *e = pDevList;
8584
8585	/* The cbDevList condition must be checked first, because the function can
8586	* receive pDevList = NULL and cbDevList = 0 on client disconnect.
8587	*/
8588	while (cbDevList >= 2 && e->oNext)
8589	{
8590	/* Sanitize incoming strings in case they aren't valid UTF-8. */
8591	if (e->oManufacturer)
8592	RTStrPurgeEncoding((char *)e + e->oManufacturer);
8593	if (e->oProduct)
8594	RTStrPurgeEncoding((char *)e + e->oProduct);
8595	if (e->oSerialNumber)
8596	RTStrPurgeEncoding((char *)e + e->oSerialNumber);
8597
8598	LogFlowThisFunc(("vendor %04X, product %04X, name = %s\n",
8599	e->idVendor, e->idProduct,
8600	e->oProduct? (char *)e + e->oProduct: ""));
8601
8602	bool fNewDevice = true;
8603
8604	for (RemoteUSBDeviceList::iterator it = mRemoteUSBDevices.begin();
8605	it != mRemoteUSBDevices.end();
8606	++it)
8607	{
8608	if ((*it)->devId() == e->id
8609	&& (*it)->clientId() == u32ClientId)
8610	{
8611	/* The device is already in the list. */
8612	(*it)->dirty(false);
8613	fNewDevice = false;
8614	break;
8615	}
8616	}
8617
8618	if (fNewDevice)
8619	{
8620	LogRel(("Remote USB: ++++ Vendor %04X. Product %04X. Name = [%s].\n",
8621	e->idVendor, e->idProduct, e->oProduct? (char *)e + e->oProduct: ""));
8622
8623	/* Create the device object and add the new device to list. */
8624	ComObjPtr<RemoteUSBDevice> pUSBDevice;
8625	pUSBDevice.createObject();
8626	pUSBDevice->init(u32ClientId, e, fDescExt);
8627
8628	mRemoteUSBDevices.push_back(pUSBDevice);
8629
8630	/* Check if the device is ok for current USB filters. */
8631	BOOL fMatched = FALSE;
8632	ULONG fMaskedIfs = 0;
8633
8634	HRESULT hrc = mControl->RunUSBDeviceFilters(pUSBDevice, &fMatched, &fMaskedIfs);
8635
8636	AssertComRC(hrc);
8637
8638	LogFlowThisFunc(("USB filters return %d %#x\n", fMatched, fMaskedIfs));
8639
8640	if (fMatched)
8641	{
8642	alock.release();
8643	hrc = onUSBDeviceAttach(pUSBDevice, NULL, fMaskedIfs);
8644	alock.acquire();
8645
8646	/// @todo (r=dmik) warning reporting subsystem
8647
8648	if (hrc == S_OK)
8649	{
8650	LogFlowThisFunc(("Device attached\n"));
8651	pUSBDevice->captured(true);
8652	}
8653	}
8654	}
8655
8656	if (cbDevList < e->oNext)
8657	{
8658	LogWarningThisFunc(("cbDevList %d > oNext %d\n",
8659	cbDevList, e->oNext));
8660	break;
8661	}
8662
8663	cbDevList -= e->oNext;
8664
8665	e = (VRDEUSBDEVICEDESC )((uint8_t )e + e->oNext);
8666	}
8667
8668	/*
8669	* Remove dirty devices, that is those which are not reported by the server anymore.
8670	*/
8671	for (;;)
8672	{
8673	ComObjPtr<RemoteUSBDevice> pUSBDevice;
8674
8675	RemoteUSBDeviceList::iterator it = mRemoteUSBDevices.begin();
8676	while (it != mRemoteUSBDevices.end())
8677	{
8678	if ((*it)->dirty())
8679	{
8680	pUSBDevice = *it;
8681	break;
8682	}
8683
8684	++it;
8685	}
8686
8687	if (!pUSBDevice)
8688	{
8689	break;
8690	}
8691
8692	USHORT vendorId = 0;
8693	pUSBDevice->COMGETTER(VendorId)(&vendorId);
8694
8695	USHORT productId = 0;
8696	pUSBDevice->COMGETTER(ProductId)(&productId);
8697
8698	Bstr product;
8699	pUSBDevice->COMGETTER(Product)(product.asOutParam());
8700
8701	LogRel(("Remote USB: ---- Vendor %04X. Product %04X. Name = [%ls].\n",
8702	vendorId, productId, product.raw()));
8703
8704	/* Detach the device from VM. */
8705	if (pUSBDevice->captured())
8706	{
8707	Bstr uuid;
8708	pUSBDevice->COMGETTER(Id)(uuid.asOutParam());
8709	alock.release();
8710	onUSBDeviceDetach(uuid.raw(), NULL);
8711	alock.acquire();
8712	}
8713
8714	/* And remove it from the list. */
8715	mRemoteUSBDevices.erase(it);
8716	}
8717
8718	LogFlowThisFuncLeave();
8719	}
8720
8721	/**
8722	* Progress cancelation callback for fault tolerance VM poweron
8723	*/
8724	static void faultToleranceProgressCancelCallback(void *pvUser)
8725	{
8726	PUVM pUVM = (PUVM)pvUser;
8727
8728	if (pUVM)
8729	FTMR3CancelStandby(pUVM);
8730	}
8731
8732	/**
8733	* Thread function which starts the VM (also from saved state) and
8734	* track progress.
8735	*
8736	* @param Thread The thread id.
8737	* @param pvUser Pointer to a VMPowerUpTask structure.
8738	* @return VINF_SUCCESS (ignored).
8739	*
8740	* @note Locks the Console object for writing.
8741	*/
8742	/static/
8743	DECLCALLBACK(int) Console::powerUpThread(RTTHREAD Thread, void *pvUser)
8744	{
8745	LogFlowFuncEnter();
8746
8747	std::auto_ptr<VMPowerUpTask> task(static_cast<VMPowerUpTask *>(pvUser));
8748	AssertReturn(task.get(), VERR_INVALID_PARAMETER);
8749
8750	AssertReturn(!task->mConsole.isNull(), VERR_INVALID_PARAMETER);
8751	AssertReturn(!task->mProgress.isNull(), VERR_INVALID_PARAMETER);
8752
8753	VirtualBoxBase::initializeComForThread();
8754
8755	HRESULT rc = S_OK;
8756	int vrc = VINF_SUCCESS;
8757
8758	/* Set up a build identifier so that it can be seen from core dumps what
8759	* exact build was used to produce the core. */
8760	static char saBuildID[40];
8761	RTStrPrintf(saBuildID, sizeof(saBuildID), "%s%s%s%s VirtualBox %s r%u %s%s%s%s",
8762	"BU", "IL", "DI", "D", RTBldCfgVersion(), RTBldCfgRevision(), "BU", "IL", "DI", "D");
8763
8764	ComObjPtr<Console> pConsole = task->mConsole;
8765
8766	/* Note: no need to use addCaller() because VMPowerUpTask does that */
8767
8768	/* The lock is also used as a signal from the task initiator (which
8769	* releases it only after RTThreadCreate()) that we can start the job */
8770	AutoWriteLock alock(pConsole COMMA_LOCKVAL_SRC_POS);
8771
8772	/* sanity */
8773	Assert(pConsole->mpUVM == NULL);
8774
8775	try
8776	{
8777	// Create the VMM device object, which starts the HGCM thread; do this only
8778	// once for the console, for the pathological case that the same console
8779	// object is used to power up a VM twice. VirtualBox 4.0: we now do that
8780	// here instead of the Console constructor (see Console::init())
8781	if (!pConsole->m_pVMMDev)
8782	{
8783	pConsole->m_pVMMDev = new VMMDev(pConsole);
8784	AssertReturn(pConsole->m_pVMMDev, E_FAIL);
8785	}
8786
8787	/* wait for auto reset ops to complete so that we can successfully lock
8788	* the attached hard disks by calling LockMedia() below */
8789	for (VMPowerUpTask::ProgressList::const_iterator
8790	it = task->hardDiskProgresses.begin();
8791	it != task->hardDiskProgresses.end(); ++it)
8792	{
8793	HRESULT rc2 = (*it)->WaitForCompletion(-1);
8794	AssertComRC(rc2);
8795
8796	rc = task->mProgress->SetNextOperation(BstrFmt(tr("Disk Image Reset Operation - Immutable Image")).raw(), 1);
8797	AssertComRCReturnRC(rc);
8798	}
8799
8800	/*
8801	* Lock attached media. This method will also check their accessibility.
8802	* If we're a teleporter, we'll have to postpone this action so we can
8803	* migrate between local processes.
8804	*
8805	* Note! The media will be unlocked automatically by
8806	* SessionMachine::setMachineState() when the VM is powered down.
8807	*/
8808	if ( !task->mTeleporterEnabled
8809	&& task->mEnmFaultToleranceState != FaultToleranceState_Standby)
8810	{
8811	rc = pConsole->mControl->LockMedia();
8812	if (FAILED(rc)) throw rc;
8813	}
8814
8815	/* Create the VRDP server. In case of headless operation, this will
8816	* also create the framebuffer, required at VM creation.
8817	*/
8818	ConsoleVRDPServer *server = pConsole->consoleVRDPServer();
8819	Assert(server);
8820
8821	/* Does VRDP server call Console from the other thread?
8822	* Not sure (and can change), so release the lock just in case.
8823	*/
8824	alock.release();
8825	vrc = server->Launch();
8826	alock.acquire();
8827
8828	if (vrc == VERR_NET_ADDRESS_IN_USE)
8829	{
8830	Utf8Str errMsg;
8831	Bstr bstr;
8832	pConsole->mVRDEServer->GetVRDEProperty(Bstr("TCP/Ports").raw(), bstr.asOutParam());
8833	Utf8Str ports = bstr;
8834	errMsg = Utf8StrFmt(tr("VirtualBox Remote Desktop Extension server can't bind to the port: %s"),
8835	ports.c_str());
8836	LogRel(("VRDE: Warning: failed to launch VRDE server (%Rrc): '%s'\n",
8837	vrc, errMsg.c_str()));
8838	}
8839	else if (vrc == VINF_NOT_SUPPORTED)
8840	{
8841	/* This means that the VRDE is not installed. */
8842	LogRel(("VRDE: VirtualBox Remote Desktop Extension is not available.\n"));
8843	}
8844	else if (RT_FAILURE(vrc))
8845	{
8846	/* Fail, if the server is installed but can't start. */
8847	Utf8Str errMsg;
8848	switch (vrc)
8849	{
8850	case VERR_FILE_NOT_FOUND:
8851	{
8852	/* VRDE library file is missing. */
8853	errMsg = Utf8StrFmt(tr("Could not find the VirtualBox Remote Desktop Extension library."));
8854	break;
8855	}
8856	default:
8857	errMsg = Utf8StrFmt(tr("Failed to launch Remote Desktop Extension server (%Rrc)"),
8858	vrc);
8859	}
8860	LogRel(("VRDE: Failed: (%Rrc), error message: '%s'\n",
8861	vrc, errMsg.c_str()));
8862	throw setErrorStatic(E_FAIL, errMsg.c_str());
8863	}
8864
8865	ComPtr<IMachine> pMachine = pConsole->machine();
8866	ULONG cCpus = 1;
8867	pMachine->COMGETTER(CPUCount)(&cCpus);
8868
8869	/*
8870	* Create the VM
8871	*
8872	* Note! Release the lock since EMT will call Console. It's safe because
8873	* mMachineState is either Starting or Restoring state here.
8874	*/
8875	alock.release();
8876
8877	PVM pVM;
8878	vrc = VMR3Create(cCpus,
8879	pConsole->mpVmm2UserMethods,
8880	Console::genericVMSetErrorCallback,
8881	&task->mErrorMsg,
8882	task->mConfigConstructor,
8883	static_cast<Console *>(pConsole),
8884	&pVM, NULL);
8885
8886	alock.acquire();
8887
8888	/* Enable client connections to the server. */
8889	pConsole->consoleVRDPServer()->EnableConnections();
8890
8891	if (RT_SUCCESS(vrc))
8892	{
8893	do
8894	{
8895	/*
8896	* Register our load/save state file handlers
8897	*/
8898	vrc = SSMR3RegisterExternal(pConsole->mpUVM, sSSMConsoleUnit, 0 /iInstance/, sSSMConsoleVer, 0 /* cbGuess */,
8899	NULL, NULL, NULL,
8900	NULL, saveStateFileExec, NULL,
8901	NULL, loadStateFileExec, NULL,
8902	static_cast<Console *>(pConsole));
8903	AssertRCBreak(vrc);
8904
8905	vrc = static_cast<Console *>(pConsole)->getDisplay()->registerSSM(pConsole->mpUVM);
8906	AssertRC(vrc);
8907	if (RT_FAILURE(vrc))
8908	break;
8909
8910	/*
8911	* Synchronize debugger settings
8912	*/
8913	MachineDebugger *machineDebugger = pConsole->getMachineDebugger();
8914	if (machineDebugger)
8915	machineDebugger->flushQueuedSettings();
8916
8917	/*
8918	* Shared Folders
8919	*/
8920	if (pConsole->m_pVMMDev->isShFlActive())
8921	{
8922	/* Does the code below call Console from the other thread?
8923	* Not sure, so release the lock just in case. */
8924	alock.release();
8925
8926	for (SharedFolderDataMap::const_iterator it = task->mSharedFolders.begin();
8927	it != task->mSharedFolders.end();
8928	++it)
8929	{
8930	const SharedFolderData &d = it->second;
8931	rc = pConsole->createSharedFolder(it->first, d);
8932	if (FAILED(rc))
8933	{
8934	ErrorInfoKeeper eik;
8935	pConsole->setVMRuntimeErrorCallbackF(0, "BrokenSharedFolder",
8936	N_("The shared folder '%s' could not be set up: %ls.\n"
8937	"The shared folder setup will not be complete. It is recommended to power down the virtual "
8938	"machine and fix the shared folder settings while the machine is not running"),
8939	it->first.c_str(), eik.getText().raw());
8940	}
8941	}
8942	if (FAILED(rc))
8943	rc = S_OK; // do not fail with broken shared folders
8944
8945	/* acquire the lock again */
8946	alock.acquire();
8947	}
8948
8949	/* release the lock before a lengthy operation */
8950	alock.release();
8951
8952	/*
8953	* Capture USB devices.
8954	*/
8955	rc = pConsole->captureUSBDevices(pConsole->mpUVM);
8956	if (FAILED(rc))
8957	break;
8958
8959	/* Load saved state? */
8960	if (task->mSavedStateFile.length())
8961	{
8962	LogFlowFunc(("Restoring saved state from '%s'...\n",
8963	task->mSavedStateFile.c_str()));
8964
8965	vrc = VMR3LoadFromFile(pConsole->mpUVM,
8966	task->mSavedStateFile.c_str(),
8967	Console::stateProgressCallback,
8968	static_cast<IProgress *>(task->mProgress));
8969
8970	if (RT_SUCCESS(vrc))
8971	{
8972	if (task->mStartPaused)
8973	/* done */
8974	pConsole->setMachineState(MachineState_Paused);
8975	else
8976	{
8977	/* Start/Resume the VM execution */
8978	#ifdef VBOX_WITH_EXTPACK
8979	vrc = pConsole->mptrExtPackManager->callAllVmPowerOnHooks(pConsole, pVM);
8980	#endif
8981	if (RT_SUCCESS(vrc))
8982	vrc = VMR3Resume(pConsole->mpUVM);
8983	AssertLogRelRC(vrc);
8984	}
8985	}
8986
8987	/* Power off in case we failed loading or resuming the VM */
8988	if (RT_FAILURE(vrc))
8989	{
8990	int vrc2 = VMR3PowerOff(pConsole->mpUVM); AssertLogRelRC(vrc2);
8991	#ifdef VBOX_WITH_EXTPACK
8992	pConsole->mptrExtPackManager->callAllVmPowerOffHooks(pConsole, pVM);
8993	#endif
8994	}
8995	}
8996	else if (task->mTeleporterEnabled)
8997	{
8998	/* -> ConsoleImplTeleporter.cpp */
8999	bool fPowerOffOnFailure;
9000	rc = pConsole->teleporterTrg(pConsole->mpUVM, pMachine, &task->mErrorMsg, task->mStartPaused,
9001	task->mProgress, &fPowerOffOnFailure);
9002	if (FAILED(rc) && fPowerOffOnFailure)
9003	{
9004	ErrorInfoKeeper eik;
9005	int vrc2 = VMR3PowerOff(pConsole->mpUVM); AssertLogRelRC(vrc2);
9006	#ifdef VBOX_WITH_EXTPACK
9007	pConsole->mptrExtPackManager->callAllVmPowerOffHooks(pConsole, pVM);
9008	#endif
9009	}
9010	}
9011	else if (task->mEnmFaultToleranceState != FaultToleranceState_Inactive)
9012	{
9013	/*
9014	* Get the config.
9015	*/
9016	ULONG uPort;
9017	ULONG uInterval;
9018	Bstr bstrAddress, bstrPassword;
9019
9020	rc = pMachine->COMGETTER(FaultTolerancePort)(&uPort);
9021	if (SUCCEEDED(rc))
9022	{
9023	rc = pMachine->COMGETTER(FaultToleranceSyncInterval)(&uInterval);
9024	if (SUCCEEDED(rc))
9025	rc = pMachine->COMGETTER(FaultToleranceAddress)(bstrAddress.asOutParam());
9026	if (SUCCEEDED(rc))
9027	rc = pMachine->COMGETTER(FaultTolerancePassword)(bstrPassword.asOutParam());
9028	}
9029	if (task->mProgress->setCancelCallback(faultToleranceProgressCancelCallback, pConsole->mpUVM))
9030	{
9031	if (SUCCEEDED(rc))
9032	{
9033	Utf8Str strAddress(bstrAddress);
9034	const char *pszAddress = strAddress.isEmpty() ? NULL : strAddress.c_str();
9035	Utf8Str strPassword(bstrPassword);
9036	const char *pszPassword = strPassword.isEmpty() ? NULL : strPassword.c_str();
9037
9038	/* Power on the FT enabled VM. */
9039	#ifdef VBOX_WITH_EXTPACK
9040	vrc = pConsole->mptrExtPackManager->callAllVmPowerOnHooks(pConsole, pVM);
9041	#endif
9042	if (RT_SUCCESS(vrc))
9043	vrc = FTMR3PowerOn(pConsole->mpUVM,
9044	task->mEnmFaultToleranceState == FaultToleranceState_Master /* fMaster */,
9045	uInterval,
9046	pszAddress,
9047	uPort,
9048	pszPassword);
9049	AssertLogRelRC(vrc);
9050	}
9051	task->mProgress->setCancelCallback(NULL, NULL);
9052	}
9053	else
9054	rc = E_FAIL;
9055	}
9056	else if (task->mStartPaused)
9057	/* done */
9058	pConsole->setMachineState(MachineState_Paused);
9059	else
9060	{
9061	/* Power on the VM (i.e. start executing) */
9062	#ifdef VBOX_WITH_EXTPACK
9063	vrc = pConsole->mptrExtPackManager->callAllVmPowerOnHooks(pConsole, pVM);
9064	#endif
9065	if (RT_SUCCESS(vrc))
9066	vrc = VMR3PowerOn(pConsole->mpUVM);
9067	AssertLogRelRC(vrc);
9068	}
9069
9070	/* acquire the lock again */
9071	alock.acquire();
9072	}
9073	while (0);
9074
9075	/* On failure, destroy the VM */
9076	if (FAILED(rc) \|\| RT_FAILURE(vrc))
9077	{
9078	/* preserve existing error info */
9079	ErrorInfoKeeper eik;
9080
9081	/* powerDown() will call VMR3Destroy() and do all necessary
9082	* cleanup (VRDP, USB devices) */
9083	alock.release();
9084	HRESULT rc2 = pConsole->powerDown();
9085	alock.acquire();
9086	AssertComRC(rc2);
9087	}
9088	else
9089	{
9090	/*
9091	* Deregister the VMSetError callback. This is necessary as the
9092	* pfnVMAtError() function passed to VMR3Create() is supposed to
9093	* be sticky but our error callback isn't.
9094	*/
9095	alock.release();
9096	VMR3AtErrorDeregister(pConsole->mpUVM, Console::genericVMSetErrorCallback, &task->mErrorMsg);
9097	/** @todo register another VMSetError callback? */
9098	alock.acquire();
9099	}
9100	}
9101	else
9102	{
9103	/*
9104	* If VMR3Create() failed it has released the VM memory.
9105	*/
9106	VMR3ReleaseUVM(pConsole->mpUVM);
9107	pConsole->mpUVM = NULL;
9108	}
9109
9110	if (SUCCEEDED(rc) && RT_FAILURE(vrc))
9111	{
9112	/* If VMR3Create() or one of the other calls in this function fail,
9113	* an appropriate error message has been set in task->mErrorMsg.
9114	* However since that happens via a callback, the rc status code in
9115	* this function is not updated.
9116	*/
9117	if (!task->mErrorMsg.length())
9118	{
9119	/* If the error message is not set but we've got a failure,
9120	* convert the VBox status code into a meaningful error message.
9121	* This becomes unused once all the sources of errors set the
9122	* appropriate error message themselves.
9123	*/
9124	AssertMsgFailed(("Missing error message during powerup for status code %Rrc\n", vrc));
9125	task->mErrorMsg = Utf8StrFmt(tr("Failed to start VM execution (%Rrc)"),
9126	vrc);
9127	}
9128
9129	/* Set the error message as the COM error.
9130	* Progress::notifyComplete() will pick it up later. */
9131	throw setErrorStatic(E_FAIL, task->mErrorMsg.c_str());
9132	}
9133	}
9134	catch (HRESULT aRC) { rc = aRC; }
9135
9136	if ( pConsole->mMachineState == MachineState_Starting
9137	\|\| pConsole->mMachineState == MachineState_Restoring
9138	\|\| pConsole->mMachineState == MachineState_TeleportingIn
9139	)
9140	{
9141	/* We are still in the Starting/Restoring state. This means one of:
9142	*
9143	* 1) we failed before VMR3Create() was called;
9144	* 2) VMR3Create() failed.
9145	*
9146	* In both cases, there is no need to call powerDown(), but we still
9147	* need to go back to the PoweredOff/Saved state. Reuse
9148	* vmstateChangeCallback() for that purpose.
9149	*/
9150
9151	/* preserve existing error info */
9152	ErrorInfoKeeper eik;
9153
9154	Assert(pConsole->mpUVM == NULL);
9155	vmstateChangeCallback(NULL, VMSTATE_TERMINATED, VMSTATE_CREATING, pConsole);
9156	}
9157
9158	/*
9159	* Evaluate the final result. Note that the appropriate mMachineState value
9160	* is already set by vmstateChangeCallback() in all cases.
9161	*/
9162
9163	/* release the lock, don't need it any more */
9164	alock.release();
9165
9166	if (SUCCEEDED(rc))
9167	{
9168	/* Notify the progress object of the success */
9169	task->mProgress->notifyComplete(S_OK);
9170	}
9171	else
9172	{
9173	/* The progress object will fetch the current error info */
9174	task->mProgress->notifyComplete(rc);
9175	LogRel(("Power up failed (vrc=%Rrc, rc=%Rhrc (%#08X))\n", vrc, rc, rc));
9176	}
9177
9178	/* Notify VBoxSVC and any waiting openRemoteSession progress object. */
9179	pConsole->mControl->EndPowerUp(rc);
9180
9181	#if defined(RT_OS_WINDOWS)
9182	/* uninitialize COM */
9183	CoUninitialize();
9184	#endif
9185
9186	LogFlowFuncLeave();
9187
9188	return VINF_SUCCESS;
9189	}
9190
9191
9192	/**
9193	* Reconfigures a medium attachment (part of taking or deleting an online snapshot).
9194	*
9195	* @param pConsole Reference to the console object.
9196	* @param pUVM The VM handle.
9197	* @param lInstance The instance of the controller.
9198	* @param pcszDevice The name of the controller type.
9199	* @param enmBus The storage bus type of the controller.
9200	* @param fSetupMerge Whether to set up a medium merge
9201	* @param uMergeSource Merge source image index
9202	* @param uMergeTarget Merge target image index
9203	* @param aMediumAtt The medium attachment.
9204	* @param aMachineState The current machine state.
9205	* @param phrc Where to store com error - only valid if we return VERR_GENERAL_FAILURE.
9206	* @return VBox status code.
9207	*/
9208	/* static */
9209	DECLCALLBACK(int) Console::reconfigureMediumAttachment(Console *pConsole,
9210	PUVM pUVM,
9211	const char *pcszDevice,
9212	unsigned uInstance,
9213	StorageBus_T enmBus,
9214	bool fUseHostIOCache,
9215	bool fBuiltinIOCache,
9216	bool fSetupMerge,
9217	unsigned uMergeSource,
9218	unsigned uMergeTarget,
9219	IMediumAttachment *aMediumAtt,
9220	MachineState_T aMachineState,
9221	HRESULT *phrc)
9222	{
9223	LogFlowFunc(("pUVM=%p aMediumAtt=%p phrc=%p\n", pUVM, aMediumAtt, phrc));
9224
9225	int rc;
9226	HRESULT hrc;
9227	Bstr bstr;
9228	*phrc = S_OK;
9229	#define RC_CHECK() do { if (RT_FAILURE(rc)) { AssertMsgFailed(("rc=%Rrc\n", rc)); return rc; } } while (0)
9230	#define H() do { if (FAILED(hrc)) { AssertMsgFailed(("hrc=%Rhrc (%#x)\n", hrc, hrc)); *phrc = hrc; return VERR_GENERAL_FAILURE; } } while (0)
9231
9232	/* Ignore attachments other than hard disks, since at the moment they are
9233	* not subject to snapshotting in general. */
9234	DeviceType_T lType;
9235	hrc = aMediumAtt->COMGETTER(Type)(&lType); H();
9236	if (lType != DeviceType_HardDisk)
9237	return VINF_SUCCESS;
9238
9239	/* Determine the base path for the device instance. */
9240	PCFGMNODE pCtlInst;
9241	pCtlInst = CFGMR3GetChildF(CFGMR3GetRootU(pUVM), "Devices/%s/%u/", pcszDevice, uInstance);
9242	AssertReturn(pCtlInst, VERR_INTERNAL_ERROR);
9243
9244	/* Update the device instance configuration. */
9245	rc = pConsole->configMediumAttachment(pCtlInst,
9246	pcszDevice,
9247	uInstance,
9248	enmBus,
9249	fUseHostIOCache,
9250	fBuiltinIOCache,
9251	fSetupMerge,
9252	uMergeSource,
9253	uMergeTarget,
9254	aMediumAtt,
9255	aMachineState,
9256	phrc,
9257	true /* fAttachDetach */,
9258	false /* fForceUnmount */,
9259	false /* fHotplug */,
9260	pUVM,
9261	NULL /* paLedDevType */);
9262	/** @todo this dumps everything attached to this device instance, which
9263	* is more than necessary. Dumping the changed LUN would be enough. */
9264	CFGMR3Dump(pCtlInst);
9265	RC_CHECK();
9266
9267	#undef RC_CHECK
9268	#undef H
9269
9270	LogFlowFunc(("Returns success\n"));
9271	return VINF_SUCCESS;
9272	}
9273
9274	/**
9275	* Progress cancelation callback employed by Console::fntTakeSnapshotWorker.
9276	*/
9277	static void takesnapshotProgressCancelCallback(void *pvUser)
9278	{
9279	PUVM pUVM = (PUVM)pvUser;
9280	SSMR3Cancel(pUVM);
9281	}
9282
9283	/**
9284	* Worker thread created by Console::TakeSnapshot.
9285	* @param Thread The current thread (ignored).
9286	* @param pvUser The task.
9287	* @return VINF_SUCCESS (ignored).
9288	*/
9289	/static/
9290	DECLCALLBACK(int) Console::fntTakeSnapshotWorker(RTTHREAD Thread, void *pvUser)
9291	{
9292	VMTakeSnapshotTask pTask = (VMTakeSnapshotTask)pvUser;
9293
9294	// taking a snapshot consists of the following:
9295
9296	// 1) creating a diff image for each virtual hard disk, into which write operations go after
9297	// the snapshot has been created (done in VBoxSVC, in SessionMachine::BeginTakingSnapshot)
9298	// 2) creating a Snapshot object with the state of the machine (hardware + storage,
9299	// done in VBoxSVC, also in SessionMachine::BeginTakingSnapshot)
9300	// 3) saving the state of the virtual machine (here, in the VM process, if the machine is online)
9301
9302	Console *that = pTask->mConsole;
9303	bool fBeganTakingSnapshot = false;
9304	bool fSuspenededBySave = false;
9305
9306	AutoCaller autoCaller(that);
9307	if (FAILED(autoCaller.rc()))
9308	{
9309	that->mptrCancelableProgress.setNull();
9310	return autoCaller.rc();
9311	}
9312
9313	AutoWriteLock alock(that COMMA_LOCKVAL_SRC_POS);
9314
9315	HRESULT rc = S_OK;
9316
9317	try
9318	{
9319	/* STEP 1 + 2:
9320	* request creating the diff images on the server and create the snapshot object
9321	* (this will set the machine state to Saving on the server to block
9322	* others from accessing this machine)
9323	*/
9324	rc = that->mControl->BeginTakingSnapshot(that,
9325	pTask->bstrName.raw(),
9326	pTask->bstrDescription.raw(),
9327	pTask->mProgress,
9328	pTask->fTakingSnapshotOnline,
9329	pTask->bstrSavedStateFile.asOutParam());
9330	if (FAILED(rc))
9331	throw rc;
9332
9333	fBeganTakingSnapshot = true;
9334
9335	/* Check sanity: for offline snapshots there must not be a saved state
9336	* file name. All other combinations are valid (even though online
9337	* snapshots without saved state file seems inconsistent - there are
9338	* some exotic use cases, which need to be explicitly enabled, see the
9339	* code of SessionMachine::BeginTakingSnapshot. */
9340	if ( !pTask->fTakingSnapshotOnline
9341	&& !pTask->bstrSavedStateFile.isEmpty())
9342	throw setErrorStatic(E_FAIL, "Invalid state of saved state file");
9343
9344	/* sync the state with the server */
9345	if (pTask->lastMachineState == MachineState_Running)
9346	that->setMachineStateLocally(MachineState_LiveSnapshotting);
9347	else
9348	that->setMachineStateLocally(MachineState_Saving);
9349
9350	// STEP 3: save the VM state (if online)
9351	if (pTask->fTakingSnapshotOnline)
9352	{
9353	int vrc;
9354	SafeVMPtr ptrVM(that);
9355	if (!ptrVM.isOk())
9356	throw ptrVM.rc();
9357
9358	pTask->mProgress->SetNextOperation(Bstr(tr("Saving the machine state")).raw(),
9359	pTask->ulMemSize); // operation weight, same as computed when setting up progress object
9360	if (!pTask->bstrSavedStateFile.isEmpty())
9361	{
9362	Utf8Str strSavedStateFile(pTask->bstrSavedStateFile);
9363
9364	pTask->mProgress->setCancelCallback(takesnapshotProgressCancelCallback, ptrVM.rawUVM());
9365
9366	alock.release();
9367	LogFlowFunc(("VMR3Save...\n"));
9368	vrc = VMR3Save(ptrVM.rawUVM(),
9369	strSavedStateFile.c_str(),
9370	true /fContinueAfterwards/,
9371	Console::stateProgressCallback,
9372	static_cast<IProgress *>(pTask->mProgress),
9373	&fSuspenededBySave);
9374	alock.acquire();
9375	if (RT_FAILURE(vrc))
9376	throw setErrorStatic(E_FAIL,
9377	tr("Failed to save the machine state to '%s' (%Rrc)"),
9378	strSavedStateFile.c_str(), vrc);
9379
9380	pTask->mProgress->setCancelCallback(NULL, NULL);
9381	}
9382	else
9383	LogRel(("Console: skipped saving state as part of online snapshot\n"));
9384
9385	if (!pTask->mProgress->notifyPointOfNoReturn())
9386	throw setErrorStatic(E_FAIL, tr("Canceled"));
9387	that->mptrCancelableProgress.setNull();
9388
9389	// STEP 4: reattach hard disks
9390	LogFlowFunc(("Reattaching new differencing hard disks...\n"));
9391
9392	pTask->mProgress->SetNextOperation(Bstr(tr("Reconfiguring medium attachments")).raw(),
9393	1); // operation weight, same as computed when setting up progress object
9394
9395	com::SafeIfaceArray<IMediumAttachment> atts;
9396	rc = that->mMachine->COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(atts));
9397	if (FAILED(rc))
9398	throw rc;
9399
9400	for (size_t i = 0;
9401	i < atts.size();
9402	++i)
9403	{
9404	ComPtr<IStorageController> pStorageController;
9405	Bstr controllerName;
9406	ULONG lInstance;
9407	StorageControllerType_T enmController;
9408	StorageBus_T enmBus;
9409	BOOL fUseHostIOCache;
9410
9411	/*
9412	* We can't pass a storage controller object directly
9413	* (g++ complains about not being able to pass non POD types through '...')
9414	* so we have to query needed values here and pass them.
9415	*/
9416	rc = atts[i]->COMGETTER(Controller)(controllerName.asOutParam());
9417	if (FAILED(rc))
9418	throw rc;
9419
9420	rc = that->mMachine->GetStorageControllerByName(controllerName.raw(),
9421	pStorageController.asOutParam());
9422	if (FAILED(rc))
9423	throw rc;
9424
9425	rc = pStorageController->COMGETTER(ControllerType)(&enmController);
9426	if (FAILED(rc))
9427	throw rc;
9428	rc = pStorageController->COMGETTER(Instance)(&lInstance);
9429	if (FAILED(rc))
9430	throw rc;
9431	rc = pStorageController->COMGETTER(Bus)(&enmBus);
9432	if (FAILED(rc))
9433	throw rc;
9434	rc = pStorageController->COMGETTER(UseHostIOCache)(&fUseHostIOCache);
9435	if (FAILED(rc))
9436	throw rc;
9437
9438	const char *pcszDevice = Console::convertControllerTypeToDev(enmController);
9439
9440	BOOL fBuiltinIOCache;
9441	rc = that->mMachine->COMGETTER(IOCacheEnabled)(&fBuiltinIOCache);
9442	if (FAILED(rc))
9443	throw rc;
9444
9445	/*
9446	* don't release the lock since reconfigureMediumAttachment
9447	* isn't going to need the Console lock.
9448	*/
9449	vrc = VMR3ReqCallWaitU(ptrVM.rawUVM(),
9450	VMCPUID_ANY,
9451	(PFNRT)reconfigureMediumAttachment,
9452	13,
9453	that,
9454	ptrVM.rawUVM(),
9455	pcszDevice,
9456	lInstance,
9457	enmBus,
9458	fUseHostIOCache,
9459	fBuiltinIOCache,
9460	false /* fSetupMerge */,
9461	0 /* uMergeSource */,
9462	0 /* uMergeTarget */,
9463	atts[i],
9464	that->mMachineState,
9465	&rc);
9466	if (RT_FAILURE(vrc))
9467	throw setErrorStatic(E_FAIL, Console::tr("%Rrc"), vrc);
9468	if (FAILED(rc))
9469	throw rc;
9470	}
9471	}
9472
9473	/*
9474	* finalize the requested snapshot object.
9475	* This will reset the machine state to the state it had right
9476	* before calling mControl->BeginTakingSnapshot().
9477	*/
9478	rc = that->mControl->EndTakingSnapshot(TRUE /aSuccess/);
9479	// do not throw rc here because we can't call EndTakingSnapshot() twice
9480	LogFlowFunc(("EndTakingSnapshot -> %Rhrc [mMachineState=%s]\n", rc, Global::stringifyMachineState(that->mMachineState)));
9481	}
9482	catch (HRESULT rcThrown)
9483	{
9484	/* preserve existing error info */
9485	ErrorInfoKeeper eik;
9486
9487	if (fBeganTakingSnapshot)
9488	that->mControl->EndTakingSnapshot(FALSE /aSuccess/);
9489
9490	rc = rcThrown;
9491	LogFunc(("Caught %Rhrc [mMachineState=%s]\n", rc, Global::stringifyMachineState(that->mMachineState)));
9492	}
9493	Assert(alock.isWriteLockOnCurrentThread());
9494
9495	if (FAILED(rc)) /* Must come before calling setMachineState. */
9496	pTask->mProgress->notifyComplete(rc);
9497
9498	/*
9499	* Fix up the machine state.
9500	*
9501	* For live snapshots we do all the work, for the two other variations we
9502	* just update the local copy.
9503	*/
9504	MachineState_T enmMachineState;
9505	that->mMachine->COMGETTER(State)(&enmMachineState);
9506	if ( that->mMachineState == MachineState_LiveSnapshotting
9507	\|\| that->mMachineState == MachineState_Saving)
9508	{
9509
9510	if (!pTask->fTakingSnapshotOnline)
9511	that->setMachineStateLocally(pTask->lastMachineState);
9512	else if (SUCCEEDED(rc))
9513	{
9514	Assert( pTask->lastMachineState == MachineState_Running
9515	\|\| pTask->lastMachineState == MachineState_Paused);
9516	Assert(that->mMachineState == MachineState_Saving);
9517	if (pTask->lastMachineState == MachineState_Running)
9518	{
9519	LogFlowFunc(("VMR3Resume...\n"));
9520	SafeVMPtr ptrVM(that);
9521	alock.release();
9522	int vrc = VMR3Resume(ptrVM.rawUVM());
9523	alock.acquire();
9524	if (RT_FAILURE(vrc))
9525	{
9526	rc = setErrorStatic(VBOX_E_VM_ERROR, tr("Could not resume the machine execution (%Rrc)"), vrc);
9527	pTask->mProgress->notifyComplete(rc);
9528	if (that->mMachineState == MachineState_Saving)
9529	that->setMachineStateLocally(MachineState_Paused);
9530	}
9531	}
9532	else
9533	that->setMachineStateLocally(MachineState_Paused);
9534	}
9535	else
9536	{
9537	/** @todo this could probably be made more generic and reused elsewhere. */
9538	/* paranoid cleanup on for a failed online snapshot. */
9539	VMSTATE enmVMState = VMR3GetStateU(that->mpUVM);
9540	switch (enmVMState)
9541	{
9542	case VMSTATE_RUNNING:
9543	case VMSTATE_RUNNING_LS:
9544	case VMSTATE_DEBUGGING:
9545	case VMSTATE_DEBUGGING_LS:
9546	case VMSTATE_POWERING_OFF:
9547	case VMSTATE_POWERING_OFF_LS:
9548	case VMSTATE_RESETTING:
9549	case VMSTATE_RESETTING_LS:
9550	Assert(!fSuspenededBySave);
9551	that->setMachineState(MachineState_Running);
9552	break;
9553
9554	case VMSTATE_GURU_MEDITATION:
9555	case VMSTATE_GURU_MEDITATION_LS:
9556	that->setMachineState(MachineState_Stuck);
9557	break;
9558
9559	case VMSTATE_FATAL_ERROR:
9560	case VMSTATE_FATAL_ERROR_LS:
9561	if (pTask->lastMachineState == MachineState_Paused)
9562	that->setMachineStateLocally(pTask->lastMachineState);
9563	else
9564	that->setMachineState(MachineState_Paused);
9565	break;
9566
9567	default:
9568	AssertMsgFailed(("%s\n", VMR3GetStateName(enmVMState)));
9569	case VMSTATE_SUSPENDED:
9570	case VMSTATE_SUSPENDED_LS:
9571	case VMSTATE_SUSPENDING:
9572	case VMSTATE_SUSPENDING_LS:
9573	case VMSTATE_SUSPENDING_EXT_LS:
9574	if (fSuspenededBySave)
9575	{
9576	Assert(pTask->lastMachineState == MachineState_Running);
9577	LogFlowFunc(("VMR3Resume (on failure)...\n"));
9578	SafeVMPtr ptrVM(that);
9579	alock.release();
9580	int vrc = VMR3Resume(ptrVM.rawUVM()); AssertLogRelRC(vrc);
9581	alock.acquire();
9582	if (RT_FAILURE(vrc))
9583	that->setMachineState(MachineState_Paused);
9584	}
9585	else if (pTask->lastMachineState == MachineState_Paused)
9586	that->setMachineStateLocally(pTask->lastMachineState);
9587	else
9588	that->setMachineState(MachineState_Paused);
9589	break;
9590	}
9591
9592	}
9593	}
9594	/else: somebody else has change the state... Leave it. /
9595
9596	/* check the remote state to see that we got it right. */
9597	that->mMachine->COMGETTER(State)(&enmMachineState);
9598	AssertLogRelMsg(that->mMachineState == enmMachineState,
9599	("mMachineState=%s enmMachineState=%s\n", Global::stringifyMachineState(that->mMachineState),
9600	Global::stringifyMachineState(enmMachineState) ));
9601
9602
9603	if (SUCCEEDED(rc)) /* The failure cases are handled above. */
9604	pTask->mProgress->notifyComplete(rc);
9605
9606	delete pTask;
9607
9608	LogFlowFuncLeave();
9609	return VINF_SUCCESS;
9610	}
9611
9612	/**
9613	* Thread for executing the saved state operation.
9614	*
9615	* @param Thread The thread handle.
9616	* @param pvUser Pointer to a VMSaveTask structure.
9617	* @return VINF_SUCCESS (ignored).
9618	*
9619	* @note Locks the Console object for writing.
9620	*/
9621	/static/
9622	DECLCALLBACK(int) Console::saveStateThread(RTTHREAD Thread, void *pvUser)
9623	{
9624	LogFlowFuncEnter();
9625
9626	std::auto_ptr<VMSaveTask> task(static_cast<VMSaveTask*>(pvUser));
9627	AssertReturn(task.get(), VERR_INVALID_PARAMETER);
9628
9629	Assert(task->mSavedStateFile.length());
9630	Assert(task->mProgress.isNull());
9631	Assert(!task->mServerProgress.isNull());
9632
9633	const ComObjPtr<Console> &that = task->mConsole;
9634	Utf8Str errMsg;
9635	HRESULT rc = S_OK;
9636
9637	LogFlowFunc(("Saving the state to '%s'...\n", task->mSavedStateFile.c_str()));
9638
9639	bool fSuspenededBySave;
9640	int vrc = VMR3Save(task->mpUVM,
9641	task->mSavedStateFile.c_str(),
9642	false, /fContinueAfterwards/
9643	Console::stateProgressCallback,
9644	static_cast<IProgress *>(task->mServerProgress),
9645	&fSuspenededBySave);
9646	if (RT_FAILURE(vrc))
9647	{
9648	errMsg = Utf8StrFmt(Console::tr("Failed to save the machine state to '%s' (%Rrc)"),
9649	task->mSavedStateFile.c_str(), vrc);
9650	rc = E_FAIL;
9651	}
9652	Assert(!fSuspenededBySave);
9653
9654	/* lock the console once we're going to access it */
9655	AutoWriteLock thatLock(that COMMA_LOCKVAL_SRC_POS);
9656
9657	/* synchronize the state with the server */
9658	if (SUCCEEDED(rc))
9659	{
9660	/*
9661	* The machine has been successfully saved, so power it down
9662	* (vmstateChangeCallback() will set state to Saved on success).
9663	* Note: we release the task's VM caller, otherwise it will
9664	* deadlock.
9665	*/
9666	task->releaseVMCaller();
9667	thatLock.release();
9668	rc = that->powerDown();
9669	thatLock.acquire();
9670	}
9671
9672	/*
9673	* If we failed, reset the local machine state.
9674	*/
9675	if (FAILED(rc))
9676	that->setMachineStateLocally(task->mMachineStateBefore);
9677
9678	/*
9679	* Finalize the requested save state procedure. In case of failure it will
9680	* reset the machine state to the state it had right before calling
9681	* mControl->BeginSavingState(). This must be the last thing because it
9682	* will set the progress to completed, and that means that the frontend
9683	* can immediately uninit the associated console object.
9684	*/
9685	that->mControl->EndSavingState(rc, Bstr(errMsg).raw());
9686
9687	LogFlowFuncLeave();
9688	return VINF_SUCCESS;
9689	}
9690
9691	/**
9692	* Thread for powering down the Console.
9693	*
9694	* @param Thread The thread handle.
9695	* @param pvUser Pointer to the VMTask structure.
9696	* @return VINF_SUCCESS (ignored).
9697	*
9698	* @note Locks the Console object for writing.
9699	*/
9700	/static/
9701	DECLCALLBACK(int) Console::powerDownThread(RTTHREAD Thread, void *pvUser)
9702	{
9703	LogFlowFuncEnter();
9704
9705	std::auto_ptr<VMPowerDownTask> task(static_cast<VMPowerDownTask *>(pvUser));
9706	AssertReturn(task.get(), VERR_INVALID_PARAMETER);
9707
9708	AssertReturn(task->isOk(), VERR_GENERAL_FAILURE);
9709
9710	Assert(task->mProgress.isNull());
9711
9712	const ComObjPtr<Console> &that = task->mConsole;
9713
9714	/* Note: no need to use addCaller() to protect Console because VMTask does
9715	* that */
9716
9717	/* wait until the method tat started us returns */
9718	AutoWriteLock thatLock(that COMMA_LOCKVAL_SRC_POS);
9719
9720	/* release VM caller to avoid the powerDown() deadlock */
9721	task->releaseVMCaller();
9722
9723	thatLock.release();
9724
9725	that->powerDown(task->mServerProgress);
9726
9727	/* complete the operation */
9728	that->mControl->EndPoweringDown(S_OK, Bstr().raw());
9729
9730	LogFlowFuncLeave();
9731	return VINF_SUCCESS;
9732	}
9733
9734
9735	/**
9736	* @interface_method_impl{VMM2USERMETHODS,pfnSaveState}
9737	*/
9738	/static/ DECLCALLBACK(int)
9739	Console::vmm2User_SaveState(PCVMM2USERMETHODS pThis, PUVM pUVM)
9740	{
9741	Console pConsole = ((MYVMM2USERMETHODS )pThis)->pConsole;
9742	NOREF(pUVM);
9743
9744	/*
9745	* For now, just call SaveState. We should probably try notify the GUI so
9746	* it can pop up a progress object and stuff.
9747	*/
9748	HRESULT hrc = pConsole->SaveState(NULL);
9749	return SUCCEEDED(hrc) ? VINF_SUCCESS : Global::vboxStatusCodeFromCOM(hrc);
9750	}
9751
9752	/**
9753	* @interface_method_impl{VMM2USERMETHODS,pfnNotifyEmtInit}
9754	*/
9755	/static/ DECLCALLBACK(void)
9756	Console::vmm2User_NotifyEmtInit(PCVMM2USERMETHODS pThis, PUVM pUVM, PUVMCPU pUVCpu)
9757	{
9758	NOREF(pThis); NOREF(pUVM); NOREF(pUVCpu);
9759	VirtualBoxBase::initializeComForThread();
9760	}
9761
9762	/**
9763	* @interface_method_impl{VMM2USERMETHODS,pfnNotifyEmtTerm}
9764	*/
9765	/static/ DECLCALLBACK(void)
9766	Console::vmm2User_NotifyEmtTerm(PCVMM2USERMETHODS pThis, PUVM pUVM, PUVMCPU pUVCpu)
9767	{
9768	NOREF(pThis); NOREF(pUVM); NOREF(pUVCpu);
9769	VirtualBoxBase::uninitializeComForThread();
9770	}
9771
9772	/**
9773	* @interface_method_impl{VMM2USERMETHODS,pfnNotifyPdmtInit}
9774	*/
9775	/static/ DECLCALLBACK(void)
9776	Console::vmm2User_NotifyPdmtInit(PCVMM2USERMETHODS pThis, PUVM pUVM)
9777	{
9778	NOREF(pThis); NOREF(pUVM);
9779	VirtualBoxBase::initializeComForThread();
9780	}
9781
9782	/**
9783	* @interface_method_impl{VMM2USERMETHODS,pfnNotifyPdmtTerm}
9784	*/
9785	/static/ DECLCALLBACK(void)
9786	Console::vmm2User_NotifyPdmtTerm(PCVMM2USERMETHODS pThis, PUVM pUVM)
9787	{
9788	NOREF(pThis); NOREF(pUVM);
9789	VirtualBoxBase::uninitializeComForThread();
9790	}
9791
9792
9793
9794
9795	/**
9796	* The Main status driver instance data.
9797	*/
9798	typedef struct DRVMAINSTATUS
9799	{
9800	/** The LED connectors. */
9801	PDMILEDCONNECTORS ILedConnectors;
9802	/** Pointer to the LED ports interface above us. */
9803	PPDMILEDPORTS pLedPorts;
9804	/** Pointer to the array of LED pointers. */
9805	PPDMLED *papLeds;
9806	/** The unit number corresponding to the first entry in the LED array. */
9807	RTUINT iFirstLUN;
9808	/** The unit number corresponding to the last entry in the LED array.
9809	* (The size of the LED array is iLastLUN - iFirstLUN + 1.) */
9810	RTUINT iLastLUN;
9811	/** Pointer to the driver instance. */
9812	PPDMDRVINS pDrvIns;
9813	/** The Media Notify interface. */
9814	PDMIMEDIANOTIFY IMediaNotify;
9815	/** Map for translating PDM storage controller/LUN information to
9816	* IMediumAttachment references. */
9817	Console::MediumAttachmentMap *pmapMediumAttachments;
9818	/** Device name+instance for mapping */
9819	char *pszDeviceInstance;
9820	/** Pointer to the Console object, for driver triggered activities. */
9821	Console *pConsole;
9822	} DRVMAINSTATUS, *PDRVMAINSTATUS;
9823
9824
9825	/**
9826	* Notification about a unit which have been changed.
9827	*
9828	* The driver must discard any pointers to data owned by
9829	* the unit and requery it.
9830	*
9831	* @param pInterface Pointer to the interface structure containing the called function pointer.
9832	* @param iLUN The unit number.
9833	*/
9834	DECLCALLBACK(void) Console::drvStatus_UnitChanged(PPDMILEDCONNECTORS pInterface, unsigned iLUN)
9835	{
9836	PDRVMAINSTATUS pThis = (PDRVMAINSTATUS)((uintptr_t)pInterface - RT_OFFSETOF(DRVMAINSTATUS, ILedConnectors));
9837	if (iLUN >= pThis->iFirstLUN && iLUN <= pThis->iLastLUN)
9838	{
9839	PPDMLED pLed;
9840	int rc = pThis->pLedPorts->pfnQueryStatusLed(pThis->pLedPorts, iLUN, &pLed);
9841	if (RT_FAILURE(rc))
9842	pLed = NULL;
9843	ASMAtomicWritePtr(&pThis->papLeds[iLUN - pThis->iFirstLUN], pLed);
9844	Log(("drvStatus_UnitChanged: iLUN=%d pLed=%p\n", iLUN, pLed));
9845	}
9846	}
9847
9848
9849	/**
9850	* Notification about a medium eject.
9851	*
9852	* @returns VBox status.
9853	* @param pInterface Pointer to the interface structure containing the called function pointer.
9854	* @param uLUN The unit number.
9855	*/
9856	DECLCALLBACK(int) Console::drvStatus_MediumEjected(PPDMIMEDIANOTIFY pInterface, unsigned uLUN)
9857	{
9858	PDRVMAINSTATUS pThis = (PDRVMAINSTATUS)((uintptr_t)pInterface - RT_OFFSETOF(DRVMAINSTATUS, IMediaNotify));
9859	PPDMDRVINS pDrvIns = pThis->pDrvIns;
9860	LogFunc(("uLUN=%d\n", uLUN));
9861	if (pThis->pmapMediumAttachments)
9862	{
9863	AutoWriteLock alock(pThis->pConsole COMMA_LOCKVAL_SRC_POS);
9864
9865	ComPtr<IMediumAttachment> pMediumAtt;
9866	Utf8Str devicePath = Utf8StrFmt("%s/LUN#%u", pThis->pszDeviceInstance, uLUN);
9867	Console::MediumAttachmentMap::const_iterator end = pThis->pmapMediumAttachments->end();
9868	Console::MediumAttachmentMap::const_iterator it = pThis->pmapMediumAttachments->find(devicePath);
9869	if (it != end)
9870	pMediumAtt = it->second;
9871	Assert(!pMediumAtt.isNull());
9872	if (!pMediumAtt.isNull())
9873	{
9874	IMedium *pMedium = NULL;
9875	HRESULT rc = pMediumAtt->COMGETTER(Medium)(&pMedium);
9876	AssertComRC(rc);
9877	if (SUCCEEDED(rc) && pMedium)
9878	{
9879	BOOL fHostDrive = FALSE;
9880	rc = pMedium->COMGETTER(HostDrive)(&fHostDrive);
9881	AssertComRC(rc);
9882	if (!fHostDrive)
9883	{
9884	alock.release();
9885
9886	ComPtr<IMediumAttachment> pNewMediumAtt;
9887	rc = pThis->pConsole->mControl->EjectMedium(pMediumAtt, pNewMediumAtt.asOutParam());
9888	if (SUCCEEDED(rc))
9889	fireMediumChangedEvent(pThis->pConsole->mEventSource, pNewMediumAtt);
9890
9891	alock.acquire();
9892	if (pNewMediumAtt != pMediumAtt)
9893	{
9894	pThis->pmapMediumAttachments->erase(devicePath);
9895	pThis->pmapMediumAttachments->insert(std::make_pair(devicePath, pNewMediumAtt));
9896	}
9897	}
9898	}
9899	}
9900	}
9901	return VINF_SUCCESS;
9902	}
9903
9904
9905	/**
9906	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
9907	*/
9908	DECLCALLBACK(void ) Console::drvStatus_QueryInterface(PPDMIBASE pInterface, const char pszIID)
9909	{
9910	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
9911	PDRVMAINSTATUS pThis = PDMINS_2_DATA(pDrvIns, PDRVMAINSTATUS);
9912	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
9913	PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDCONNECTORS, &pThis->ILedConnectors);
9914	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMEDIANOTIFY, &pThis->IMediaNotify);
9915	return NULL;
9916	}
9917
9918
9919	/**
9920	* Destruct a status driver instance.
9921	*
9922	* @returns VBox status.
9923	* @param pDrvIns The driver instance data.
9924	*/
9925	DECLCALLBACK(void) Console::drvStatus_Destruct(PPDMDRVINS pDrvIns)
9926	{
9927	PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
9928	PDRVMAINSTATUS pThis = PDMINS_2_DATA(pDrvIns, PDRVMAINSTATUS);
9929	LogFlowFunc(("iInstance=%d\n", pDrvIns->iInstance));
9930
9931	if (pThis->papLeds)
9932	{
9933	unsigned iLed = pThis->iLastLUN - pThis->iFirstLUN + 1;
9934	while (iLed-- > 0)
9935	ASMAtomicWriteNullPtr(&pThis->papLeds[iLed]);
9936	}
9937	}
9938
9939
9940	/**
9941	* Construct a status driver instance.
9942	*
9943	* @copydoc FNPDMDRVCONSTRUCT
9944	*/
9945	DECLCALLBACK(int) Console::drvStatus_Construct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
9946	{
9947	PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
9948	PDRVMAINSTATUS pThis = PDMINS_2_DATA(pDrvIns, PDRVMAINSTATUS);
9949	LogFlowFunc(("iInstance=%d\n", pDrvIns->iInstance));
9950
9951	/*
9952	* Validate configuration.
9953	*/
9954	if (!CFGMR3AreValuesValid(pCfg, "papLeds\0pmapMediumAttachments\0DeviceInstance\0pConsole\0First\0Last\0"))
9955	return VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES;
9956	AssertMsgReturn(PDMDrvHlpNoAttach(pDrvIns) == VERR_PDM_NO_ATTACHED_DRIVER,
9957	("Configuration error: Not possible to attach anything to this driver!\n"),
9958	VERR_PDM_DRVINS_NO_ATTACH);
9959
9960	/*
9961	* Data.
9962	*/
9963	pDrvIns->IBase.pfnQueryInterface = Console::drvStatus_QueryInterface;
9964	pThis->ILedConnectors.pfnUnitChanged = Console::drvStatus_UnitChanged;
9965	pThis->IMediaNotify.pfnEjected = Console::drvStatus_MediumEjected;
9966	pThis->pDrvIns = pDrvIns;
9967	pThis->pszDeviceInstance = NULL;
9968
9969	/*
9970	* Read config.
9971	*/
9972	int rc = CFGMR3QueryPtr(pCfg, "papLeds", (void **)&pThis->papLeds);
9973	if (RT_FAILURE(rc))
9974	{
9975	AssertMsgFailed(("Configuration error: Failed to query the \"papLeds\" value! rc=%Rrc\n", rc));
9976	return rc;
9977	}
9978
9979	rc = CFGMR3QueryPtrDef(pCfg, "pmapMediumAttachments", (void **)&pThis->pmapMediumAttachments, NULL);
9980	if (RT_FAILURE(rc))
9981	{
9982	AssertMsgFailed(("Configuration error: Failed to query the \"pmapMediumAttachments\" value! rc=%Rrc\n", rc));
9983	return rc;
9984	}
9985	if (pThis->pmapMediumAttachments)
9986	{
9987	rc = CFGMR3QueryStringAlloc(pCfg, "DeviceInstance", &pThis->pszDeviceInstance);
9988	if (RT_FAILURE(rc))
9989	{
9990	AssertMsgFailed(("Configuration error: Failed to query the \"DeviceInstance\" value! rc=%Rrc\n", rc));
9991	return rc;
9992	}
9993	rc = CFGMR3QueryPtr(pCfg, "pConsole", (void **)&pThis->pConsole);
9994	if (RT_FAILURE(rc))
9995	{
9996	AssertMsgFailed(("Configuration error: Failed to query the \"pConsole\" value! rc=%Rrc\n", rc));
9997	return rc;
9998	}
9999	}
10000
10001	rc = CFGMR3QueryU32(pCfg, "First", &pThis->iFirstLUN);
10002	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
10003	pThis->iFirstLUN = 0;
10004	else if (RT_FAILURE(rc))
10005	{
10006	AssertMsgFailed(("Configuration error: Failed to query the \"First\" value! rc=%Rrc\n", rc));
10007	return rc;
10008	}
10009
10010	rc = CFGMR3QueryU32(pCfg, "Last", &pThis->iLastLUN);
10011	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
10012	pThis->iLastLUN = 0;
10013	else if (RT_FAILURE(rc))
10014	{
10015	AssertMsgFailed(("Configuration error: Failed to query the \"Last\" value! rc=%Rrc\n", rc));
10016	return rc;
10017	}
10018	if (pThis->iFirstLUN > pThis->iLastLUN)
10019	{
10020	AssertMsgFailed(("Configuration error: Invalid unit range %u-%u\n", pThis->iFirstLUN, pThis->iLastLUN));
10021	return VERR_GENERAL_FAILURE;
10022	}
10023
10024	/*
10025	* Get the ILedPorts interface of the above driver/device and
10026	* query the LEDs we want.
10027	*/
10028	pThis->pLedPorts = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMILEDPORTS);
10029	AssertMsgReturn(pThis->pLedPorts, ("Configuration error: No led ports interface above!\n"),
10030	VERR_PDM_MISSING_INTERFACE_ABOVE);
10031
10032	for (unsigned i = pThis->iFirstLUN; i <= pThis->iLastLUN; ++i)
10033	Console::drvStatus_UnitChanged(&pThis->ILedConnectors, i);
10034
10035	return VINF_SUCCESS;
10036	}
10037
10038
10039	/**
10040	* Console status driver (LED) registration record.
10041	*/
10042	const PDMDRVREG Console::DrvStatusReg =
10043	{
10044	/* u32Version */
10045	PDM_DRVREG_VERSION,
10046	/* szName */
10047	"MainStatus",
10048	/* szRCMod */
10049	"",
10050	/* szR0Mod */
10051	"",
10052	/* pszDescription */
10053	"Main status driver (Main as in the API).",
10054	/* fFlags */
10055	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
10056	/* fClass. */
10057	PDM_DRVREG_CLASS_STATUS,
10058	/* cMaxInstances */
10059	~0U,
10060	/* cbInstance */
10061	sizeof(DRVMAINSTATUS),
10062	/* pfnConstruct */
10063	Console::drvStatus_Construct,
10064	/* pfnDestruct */
10065	Console::drvStatus_Destruct,
10066	/* pfnRelocate */
10067	NULL,
10068	/* pfnIOCtl */
10069	NULL,
10070	/* pfnPowerOn */
10071	NULL,
10072	/* pfnReset */
10073	NULL,
10074	/* pfnSuspend */
10075	NULL,
10076	/* pfnResume */
10077	NULL,
10078	/* pfnAttach */
10079	NULL,
10080	/* pfnDetach */
10081	NULL,
10082	/* pfnPowerOff */
10083	NULL,
10084	/* pfnSoftReset */
10085	NULL,
10086	/* u32EndVersion */
10087	PDM_DRVREG_VERSION
10088	};
10089
10090	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

source: vbox/trunk/src/VBox/Main/src-client/ConsoleImpl.cpp@ 45772

Download in other formats: