ConsoleImpl.cpp@ 46284

Last change on this file since 46284 was 45890, checked in by vboxsync, 12 years ago
Main: warnings
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 333.6 KB

Line
1	/* $Id: ConsoleImpl.cpp 45890 2013-05-03 09:57:44Z 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(), RT_BOOL(aSilent));
5397	else
5398	rc = doStorageDeviceAttach(aMediumAttachment, ptrVM.rawUVM(), RT_BOOL(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	return setError(E_INVALIDARG, tr("Name cannot be NULL or an invalid pointer"));
5503	if (aValue != NULL && !RT_VALID_PTR(aValue))
5504	return setError(E_INVALIDARG, tr("Invalid value pointer"));
5505	if (aFlags != NULL && !RT_VALID_PTR(aFlags))
5506	return setError(E_INVALIDARG, tr("Invalid flags pointer"));
5507
5508	AutoCaller autoCaller(this);
5509	AssertComRCReturnRC(autoCaller.rc());
5510
5511	/* protect mpUVM (if not NULL) */
5512	SafeVMPtrQuiet ptrVM(this);
5513	if (FAILED(ptrVM.rc()))
5514	return ptrVM.rc();
5515
5516	/* Note: validity of mVMMDev which is bound to uninit() is guaranteed by
5517	* ptrVM, so there is no need to hold a lock of this */
5518
5519	using namespace guestProp;
5520
5521	VBOXHGCMSVCPARM parm[3];
5522
5523	Utf8Str Utf8Name = aName;
5524	parm[0].type = VBOX_HGCM_SVC_PARM_PTR;
5525	parm[0].u.pointer.addr = (void*)Utf8Name.c_str();
5526	/* The + 1 is the null terminator */
5527	parm[0].u.pointer.size = (uint32_t)Utf8Name.length() + 1;
5528
5529	Utf8Str Utf8Value;
5530	if (aValue != NULL)
5531	{
5532	Utf8Value = aValue;
5533	parm[1].type = VBOX_HGCM_SVC_PARM_PTR;
5534	parm[1].u.pointer.addr = (void *)Utf8Value.c_str();
5535	/* The + 1 is the null terminator */
5536	parm[1].u.pointer.size = (uint32_t)Utf8Value.length() + 1;
5537	}
5538
5539	Utf8Str Utf8Flags;
5540	if (aFlags != NULL)
5541	{
5542	Utf8Flags = aFlags;
5543	parm[2].type = VBOX_HGCM_SVC_PARM_PTR;
5544	parm[2].u.pointer.addr = (void*)Utf8Flags.c_str();
5545	/* The + 1 is the null terminator */
5546	parm[2].u.pointer.size = (uint32_t)Utf8Flags.length() + 1;
5547	}
5548
5549	int vrc;
5550	if (aValue != NULL && aFlags != NULL)
5551	vrc = m_pVMMDev->hgcmHostCall("VBoxGuestPropSvc", SET_PROP_HOST,
5552	3, &parm[0]);
5553	else if (aValue != NULL)
5554	vrc = m_pVMMDev->hgcmHostCall("VBoxGuestPropSvc", SET_PROP_VALUE_HOST,
5555	2, &parm[0]);
5556	else
5557	vrc = m_pVMMDev->hgcmHostCall("VBoxGuestPropSvc", DEL_PROP_HOST,
5558	1, &parm[0]);
5559	HRESULT hrc;
5560	if (RT_SUCCESS(vrc))
5561	hrc = S_OK;
5562	else
5563	hrc = setError(E_UNEXPECTED, tr("The service call failed with the error %Rrc"), vrc);
5564	return hrc;
5565	#endif /* VBOX_WITH_GUEST_PROPS */
5566	}
5567
5568
5569	/**
5570	* @note Temporarily locks this object for writing.
5571	*/
5572	HRESULT Console::enumerateGuestProperties(IN_BSTR aPatterns,
5573	ComSafeArrayOut(BSTR, aNames),
5574	ComSafeArrayOut(BSTR, aValues),
5575	ComSafeArrayOut(LONG64, aTimestamps),
5576	ComSafeArrayOut(BSTR, aFlags))
5577	{
5578	#ifndef VBOX_WITH_GUEST_PROPS
5579	ReturnComNotImplemented();
5580	#else /* VBOX_WITH_GUEST_PROPS */
5581	if (!VALID_PTR(aPatterns) && (aPatterns != NULL))
5582	return E_POINTER;
5583	if (ComSafeArrayOutIsNull(aNames))
5584	return E_POINTER;
5585	if (ComSafeArrayOutIsNull(aValues))
5586	return E_POINTER;
5587	if (ComSafeArrayOutIsNull(aTimestamps))
5588	return E_POINTER;
5589	if (ComSafeArrayOutIsNull(aFlags))
5590	return E_POINTER;
5591
5592	AutoCaller autoCaller(this);
5593	AssertComRCReturnRC(autoCaller.rc());
5594
5595	/* protect mpUVM (if not NULL) */
5596	AutoVMCallerWeak autoVMCaller(this);
5597	if (FAILED(autoVMCaller.rc()))
5598	return autoVMCaller.rc();
5599
5600	/* Note: validity of mVMMDev which is bound to uninit() is guaranteed by
5601	* autoVMCaller, so there is no need to hold a lock of this */
5602
5603	return doEnumerateGuestProperties(aPatterns, ComSafeArrayOutArg(aNames),
5604	ComSafeArrayOutArg(aValues),
5605	ComSafeArrayOutArg(aTimestamps),
5606	ComSafeArrayOutArg(aFlags));
5607	#endif /* VBOX_WITH_GUEST_PROPS */
5608	}
5609
5610
5611	/*
5612	* Internal: helper function for connecting progress reporting
5613	*/
5614	static int onlineMergeMediumProgress(void *pvUser, unsigned uPercentage)
5615	{
5616	HRESULT rc = S_OK;
5617	IProgress pProgress = static_cast<IProgress >(pvUser);
5618	if (pProgress)
5619	rc = pProgress->SetCurrentOperationProgress(uPercentage);
5620	return SUCCEEDED(rc) ? VINF_SUCCESS : VERR_GENERAL_FAILURE;
5621	}
5622
5623	/**
5624	* @note Temporarily locks this object for writing. bird: And/or reading?
5625	*/
5626	HRESULT Console::onlineMergeMedium(IMediumAttachment *aMediumAttachment,
5627	ULONG aSourceIdx, ULONG aTargetIdx,
5628	IMedium aSource, IMedium aTarget,
5629	BOOL aMergeForward,
5630	IMedium *aParentForTarget,
5631	ComSafeArrayIn(IMedium *, aChildrenToReparent),
5632	IProgress *aProgress)
5633	{
5634	AutoCaller autoCaller(this);
5635	AssertComRCReturnRC(autoCaller.rc());
5636
5637	HRESULT rc = S_OK;
5638	int vrc = VINF_SUCCESS;
5639
5640	/* Get the VM - must be done before the read-locking. */
5641	SafeVMPtr ptrVM(this);
5642	if (!ptrVM.isOk())
5643	return ptrVM.rc();
5644
5645	/* We will need to release the lock before doing the actual merge */
5646	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5647
5648	/* paranoia - we don't want merges to happen while teleporting etc. */
5649	switch (mMachineState)
5650	{
5651	case MachineState_DeletingSnapshotOnline:
5652	case MachineState_DeletingSnapshotPaused:
5653	break;
5654
5655	default:
5656	return setInvalidMachineStateError();
5657	}
5658
5659	/** @todo AssertComRC -> AssertComRCReturn! Could potentially end up
5660	* using uninitialized variables here. */
5661	BOOL fBuiltinIOCache;
5662	rc = mMachine->COMGETTER(IOCacheEnabled)(&fBuiltinIOCache);
5663	AssertComRC(rc);
5664	SafeIfaceArray<IStorageController> ctrls;
5665	rc = mMachine->COMGETTER(StorageControllers)(ComSafeArrayAsOutParam(ctrls));
5666	AssertComRC(rc);
5667	LONG lDev;
5668	rc = aMediumAttachment->COMGETTER(Device)(&lDev);
5669	AssertComRC(rc);
5670	LONG lPort;
5671	rc = aMediumAttachment->COMGETTER(Port)(&lPort);
5672	AssertComRC(rc);
5673	IMedium *pMedium;
5674	rc = aMediumAttachment->COMGETTER(Medium)(&pMedium);
5675	AssertComRC(rc);
5676	Bstr mediumLocation;
5677	if (pMedium)
5678	{
5679	rc = pMedium->COMGETTER(Location)(mediumLocation.asOutParam());
5680	AssertComRC(rc);
5681	}
5682
5683	Bstr attCtrlName;
5684	rc = aMediumAttachment->COMGETTER(Controller)(attCtrlName.asOutParam());
5685	AssertComRC(rc);
5686	ComPtr<IStorageController> pStorageController;
5687	for (size_t i = 0; i < ctrls.size(); ++i)
5688	{
5689	Bstr ctrlName;
5690	rc = ctrls[i]->COMGETTER(Name)(ctrlName.asOutParam());
5691	AssertComRC(rc);
5692	if (attCtrlName == ctrlName)
5693	{
5694	pStorageController = ctrls[i];
5695	break;
5696	}
5697	}
5698	if (pStorageController.isNull())
5699	return setError(E_FAIL,
5700	tr("Could not find storage controller '%ls'"),
5701	attCtrlName.raw());
5702
5703	StorageControllerType_T enmCtrlType;
5704	rc = pStorageController->COMGETTER(ControllerType)(&enmCtrlType);
5705	AssertComRC(rc);
5706	const char *pcszDevice = convertControllerTypeToDev(enmCtrlType);
5707
5708	StorageBus_T enmBus;
5709	rc = pStorageController->COMGETTER(Bus)(&enmBus);
5710	AssertComRC(rc);
5711	ULONG uInstance;
5712	rc = pStorageController->COMGETTER(Instance)(&uInstance);
5713	AssertComRC(rc);
5714	BOOL fUseHostIOCache;
5715	rc = pStorageController->COMGETTER(UseHostIOCache)(&fUseHostIOCache);
5716	AssertComRC(rc);
5717
5718	unsigned uLUN;
5719	rc = Console::convertBusPortDeviceToLun(enmBus, lPort, lDev, uLUN);
5720	AssertComRCReturnRC(rc);
5721
5722	alock.release();
5723
5724	/* Pause the VM, as it might have pending IO on this drive */
5725	VMSTATE enmVMState = VMR3GetStateU(ptrVM.rawUVM());
5726	if (mMachineState == MachineState_DeletingSnapshotOnline)
5727	{
5728	LogFlowFunc(("Suspending the VM...\n"));
5729	/* disable the callback to prevent Console-level state change */
5730	mVMStateChangeCallbackDisabled = true;
5731	int vrc2 = VMR3Suspend(ptrVM.rawUVM());
5732	mVMStateChangeCallbackDisabled = false;
5733	AssertRCReturn(vrc2, E_FAIL);
5734	}
5735
5736	vrc = VMR3ReqCallWaitU(ptrVM.rawUVM(),
5737	VMCPUID_ANY,
5738	(PFNRT)reconfigureMediumAttachment,
5739	13,
5740	this,
5741	ptrVM.rawUVM(),
5742	pcszDevice,
5743	uInstance,
5744	enmBus,
5745	fUseHostIOCache,
5746	fBuiltinIOCache,
5747	true /* fSetupMerge */,
5748	aSourceIdx,
5749	aTargetIdx,
5750	aMediumAttachment,
5751	mMachineState,
5752	&rc);
5753	/* error handling is after resuming the VM */
5754
5755	if (mMachineState == MachineState_DeletingSnapshotOnline)
5756	{
5757	LogFlowFunc(("Resuming the VM...\n"));
5758	/* disable the callback to prevent Console-level state change */
5759	mVMStateChangeCallbackDisabled = true;
5760	int vrc2 = VMR3Resume(ptrVM.rawUVM());
5761	mVMStateChangeCallbackDisabled = false;
5762	if (RT_FAILURE(vrc2))
5763	{
5764	/* too bad, we failed. try to sync the console state with the VMM state */
5765	AssertLogRelRC(vrc2);
5766	vmstateChangeCallback(ptrVM.rawUVM(), VMSTATE_SUSPENDED, enmVMState, this);
5767	}
5768	}
5769
5770	if (RT_FAILURE(vrc))
5771	return setError(E_FAIL, tr("%Rrc"), vrc);
5772	if (FAILED(rc))
5773	return rc;
5774
5775	PPDMIBASE pIBase = NULL;
5776	PPDMIMEDIA pIMedium = NULL;
5777	vrc = PDMR3QueryDriverOnLun(ptrVM.rawUVM(), pcszDevice, uInstance, uLUN, "VD", &pIBase);
5778	if (RT_SUCCESS(vrc))
5779	{
5780	if (pIBase)
5781	{
5782	pIMedium = (PPDMIMEDIA)pIBase->pfnQueryInterface(pIBase, PDMIMEDIA_IID);
5783	if (!pIMedium)
5784	return setError(E_FAIL, tr("could not query medium interface of controller"));
5785	}
5786	else
5787	return setError(E_FAIL, tr("could not query base interface of controller"));
5788	}
5789
5790	/* Finally trigger the merge. */
5791	vrc = pIMedium->pfnMerge(pIMedium, onlineMergeMediumProgress, aProgress);
5792	if (RT_FAILURE(vrc))
5793	return setError(E_FAIL, tr("Failed to perform an online medium merge (%Rrc)"), vrc);
5794
5795	/* Pause the VM, as it might have pending IO on this drive */
5796	enmVMState = VMR3GetStateU(ptrVM.rawUVM());
5797	if (mMachineState == MachineState_DeletingSnapshotOnline)
5798	{
5799	LogFlowFunc(("Suspending the VM...\n"));
5800	/* disable the callback to prevent Console-level state change */
5801	mVMStateChangeCallbackDisabled = true;
5802	int vrc2 = VMR3Suspend(ptrVM.rawUVM());
5803	mVMStateChangeCallbackDisabled = false;
5804	AssertRCReturn(vrc2, E_FAIL);
5805	}
5806
5807	/* Update medium chain and state now, so that the VM can continue. */
5808	rc = mControl->FinishOnlineMergeMedium(aMediumAttachment, aSource, aTarget,
5809	aMergeForward, aParentForTarget,
5810	ComSafeArrayInArg(aChildrenToReparent));
5811
5812	vrc = VMR3ReqCallWaitU(ptrVM.rawUVM(),
5813	VMCPUID_ANY,
5814	(PFNRT)reconfigureMediumAttachment,
5815	13,
5816	this,
5817	ptrVM.rawUVM(),
5818	pcszDevice,
5819	uInstance,
5820	enmBus,
5821	fUseHostIOCache,
5822	fBuiltinIOCache,
5823	false /* fSetupMerge */,
5824	0 /* uMergeSource */,
5825	0 /* uMergeTarget */,
5826	aMediumAttachment,
5827	mMachineState,
5828	&rc);
5829	/* error handling is after resuming the VM */
5830
5831	if (mMachineState == MachineState_DeletingSnapshotOnline)
5832	{
5833	LogFlowFunc(("Resuming the VM...\n"));
5834	/* disable the callback to prevent Console-level state change */
5835	mVMStateChangeCallbackDisabled = true;
5836	int vrc2 = VMR3Resume(ptrVM.rawUVM());
5837	mVMStateChangeCallbackDisabled = false;
5838	AssertRC(vrc2);
5839	if (RT_FAILURE(vrc2))
5840	{
5841	/* too bad, we failed. try to sync the console state with the VMM state */
5842	vmstateChangeCallback(ptrVM.rawUVM(), VMSTATE_SUSPENDED, enmVMState, this);
5843	}
5844	}
5845
5846	if (RT_FAILURE(vrc))
5847	return setError(E_FAIL, tr("%Rrc"), vrc);
5848	if (FAILED(rc))
5849	return rc;
5850
5851	return rc;
5852	}
5853
5854
5855	/**
5856	* Merely passes the call to Guest::enableVMMStatistics().
5857	*/
5858	void Console::enableVMMStatistics(BOOL aEnable)
5859	{
5860	if (mGuest)
5861	mGuest->enableVMMStatistics(aEnable);
5862	}
5863
5864	/**
5865	* Gets called by Session::UpdateMachineState()
5866	* (IInternalSessionControl::updateMachineState()).
5867	*
5868	* Must be called only in certain cases (see the implementation).
5869	*
5870	* @note Locks this object for writing.
5871	*/
5872	HRESULT Console::updateMachineState(MachineState_T aMachineState)
5873	{
5874	AutoCaller autoCaller(this);
5875	AssertComRCReturnRC(autoCaller.rc());
5876
5877	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5878
5879	AssertReturn( mMachineState == MachineState_Saving
5880	\|\| mMachineState == MachineState_LiveSnapshotting
5881	\|\| mMachineState == MachineState_RestoringSnapshot
5882	\|\| mMachineState == MachineState_DeletingSnapshot
5883	\|\| mMachineState == MachineState_DeletingSnapshotOnline
5884	\|\| mMachineState == MachineState_DeletingSnapshotPaused
5885	, E_FAIL);
5886
5887	return setMachineStateLocally(aMachineState);
5888	}
5889
5890	#ifdef CONSOLE_WITH_EVENT_CACHE
5891	/**
5892	* @note Locks this object for writing.
5893	*/
5894	#endif
5895	void Console::onMousePointerShapeChange(bool fVisible, bool fAlpha,
5896	uint32_t xHot, uint32_t yHot,
5897	uint32_t width, uint32_t height,
5898	ComSafeArrayIn(BYTE,pShape))
5899	{
5900	#if 0
5901	LogFlowThisFuncEnter();
5902	LogFlowThisFunc(("fVisible=%d, fAlpha=%d, xHot = %d, yHot = %d, width=%d, height=%d, shape=%p\n",
5903	fVisible, fAlpha, xHot, yHot, width, height, pShape));
5904	#endif
5905
5906	AutoCaller autoCaller(this);
5907	AssertComRCReturnVoid(autoCaller.rc());
5908
5909	#ifdef CONSOLE_WITH_EVENT_CACHE
5910	{
5911	/* We need a write lock because we alter the cached callback data */
5912	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5913
5914	/* Save the callback arguments */
5915	mCallbackData.mpsc.visible = fVisible;
5916	mCallbackData.mpsc.alpha = fAlpha;
5917	mCallbackData.mpsc.xHot = xHot;
5918	mCallbackData.mpsc.yHot = yHot;
5919	mCallbackData.mpsc.width = width;
5920	mCallbackData.mpsc.height = height;
5921
5922	/* start with not valid */
5923	bool wasValid = mCallbackData.mpsc.valid;
5924	mCallbackData.mpsc.valid = false;
5925
5926	com::SafeArray<BYTE> aShape(ComSafeArrayInArg(pShape));
5927	if (aShape.size() != 0)
5928	mCallbackData.mpsc.shape.initFrom(aShape);
5929	else
5930	mCallbackData.mpsc.shape.resize(0);
5931	mCallbackData.mpsc.valid = true;
5932	}
5933	#endif
5934
5935	fireMousePointerShapeChangedEvent(mEventSource, fVisible, fAlpha, xHot, yHot, width, height, ComSafeArrayInArg(pShape));
5936
5937	#if 0
5938	LogFlowThisFuncLeave();
5939	#endif
5940	}
5941
5942	#ifdef CONSOLE_WITH_EVENT_CACHE
5943	/**
5944	* @note Locks this object for writing.
5945	*/
5946	#endif
5947	void Console::onMouseCapabilityChange(BOOL supportsAbsolute, BOOL supportsRelative, BOOL needsHostCursor)
5948	{
5949	LogFlowThisFunc(("supportsAbsolute=%d supportsRelative=%d needsHostCursor=%d\n",
5950	supportsAbsolute, supportsRelative, needsHostCursor));
5951
5952	AutoCaller autoCaller(this);
5953	AssertComRCReturnVoid(autoCaller.rc());
5954
5955	#ifdef CONSOLE_WITH_EVENT_CACHE
5956	{
5957	/* We need a write lock because we alter the cached callback data */
5958	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5959
5960	/* save the callback arguments */
5961	mCallbackData.mcc.supportsAbsolute = supportsAbsolute;
5962	mCallbackData.mcc.supportsRelative = supportsRelative;
5963	mCallbackData.mcc.needsHostCursor = needsHostCursor;
5964	mCallbackData.mcc.valid = true;
5965	}
5966	#endif
5967
5968	fireMouseCapabilityChangedEvent(mEventSource, supportsAbsolute, supportsRelative, needsHostCursor);
5969	}
5970
5971	void Console::onStateChange(MachineState_T machineState)
5972	{
5973	AutoCaller autoCaller(this);
5974	AssertComRCReturnVoid(autoCaller.rc());
5975	fireStateChangedEvent(mEventSource, machineState);
5976	}
5977
5978	void Console::onAdditionsStateChange()
5979	{
5980	AutoCaller autoCaller(this);
5981	AssertComRCReturnVoid(autoCaller.rc());
5982
5983	fireAdditionsStateChangedEvent(mEventSource);
5984	}
5985
5986	/**
5987	* @remarks This notification only is for reporting an incompatible
5988	* Guest Additions interface, not the Guest Additions version!
5989	*
5990	* The user will be notified inside the guest if new Guest
5991	* Additions are available (via VBoxTray/VBoxClient).
5992	*/
5993	void Console::onAdditionsOutdated()
5994	{
5995	AutoCaller autoCaller(this);
5996	AssertComRCReturnVoid(autoCaller.rc());
5997
5998	/** @todo implement this */
5999	}
6000
6001	#ifdef CONSOLE_WITH_EVENT_CACHE
6002	/**
6003	* @note Locks this object for writing.
6004	*/
6005	#endif
6006	void Console::onKeyboardLedsChange(bool fNumLock, bool fCapsLock, bool fScrollLock)
6007	{
6008	AutoCaller autoCaller(this);
6009	AssertComRCReturnVoid(autoCaller.rc());
6010
6011	#ifdef CONSOLE_WITH_EVENT_CACHE
6012	{
6013	/* We need a write lock because we alter the cached callback data */
6014	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6015
6016	/* save the callback arguments */
6017	mCallbackData.klc.numLock = fNumLock;
6018	mCallbackData.klc.capsLock = fCapsLock;
6019	mCallbackData.klc.scrollLock = fScrollLock;
6020	mCallbackData.klc.valid = true;
6021	}
6022	#endif
6023
6024	fireKeyboardLedsChangedEvent(mEventSource, fNumLock, fCapsLock, fScrollLock);
6025	}
6026
6027	void Console::onUSBDeviceStateChange(IUSBDevice *aDevice, bool aAttached,
6028	IVirtualBoxErrorInfo *aError)
6029	{
6030	AutoCaller autoCaller(this);
6031	AssertComRCReturnVoid(autoCaller.rc());
6032
6033	fireUSBDeviceStateChangedEvent(mEventSource, aDevice, aAttached, aError);
6034	}
6035
6036	void Console::onRuntimeError(BOOL aFatal, IN_BSTR aErrorID, IN_BSTR aMessage)
6037	{
6038	AutoCaller autoCaller(this);
6039	AssertComRCReturnVoid(autoCaller.rc());
6040
6041	fireRuntimeErrorEvent(mEventSource, aFatal, aErrorID, aMessage);
6042	}
6043
6044	HRESULT Console::onShowWindow(BOOL aCheck, BOOL aCanShow, LONG64 aWinId)
6045	{
6046	AssertReturn(aCanShow, E_POINTER);
6047	AssertReturn(aWinId, E_POINTER);
6048
6049	*aCanShow = FALSE;
6050	*aWinId = 0;
6051
6052	AutoCaller autoCaller(this);
6053	AssertComRCReturnRC(autoCaller.rc());
6054
6055	VBoxEventDesc evDesc;
6056	if (aCheck)
6057	{
6058	evDesc.init(mEventSource, VBoxEventType_OnCanShowWindow);
6059	BOOL fDelivered = evDesc.fire(5000); /* Wait up to 5 secs for delivery */
6060	//Assert(fDelivered);
6061	if (fDelivered)
6062	{
6063	ComPtr<IEvent> pEvent;
6064	evDesc.getEvent(pEvent.asOutParam());
6065	// bit clumsy
6066	ComPtr<ICanShowWindowEvent> pCanShowEvent = pEvent;
6067	if (pCanShowEvent)
6068	{
6069	BOOL fVetoed = FALSE;
6070	pCanShowEvent->IsVetoed(&fVetoed);
6071	*aCanShow = !fVetoed;
6072	}
6073	else
6074	{
6075	AssertFailed();
6076	*aCanShow = TRUE;
6077	}
6078	}
6079	else
6080	*aCanShow = TRUE;
6081	}
6082	else
6083	{
6084	evDesc.init(mEventSource, VBoxEventType_OnShowWindow, INT64_C(0));
6085	BOOL fDelivered = evDesc.fire(5000); /* Wait up to 5 secs for delivery */
6086	//Assert(fDelivered);
6087	if (fDelivered)
6088	{
6089	ComPtr<IEvent> pEvent;
6090	evDesc.getEvent(pEvent.asOutParam());
6091	ComPtr<IShowWindowEvent> pShowEvent = pEvent;
6092	if (pShowEvent)
6093	{
6094	LONG64 iEvWinId = 0;
6095	pShowEvent->COMGETTER(WinId)(&iEvWinId);
6096	if (iEvWinId != 0 && *aWinId == 0)
6097	*aWinId = iEvWinId;
6098	}
6099	else
6100	AssertFailed();
6101	}
6102	}
6103
6104	return S_OK;
6105	}
6106
6107	// private methods
6108	////////////////////////////////////////////////////////////////////////////////
6109
6110	/**
6111	* Increases the usage counter of the mpUVM pointer.
6112	*
6113	* Guarantees that VMR3Destroy() will not be called on it at least until
6114	* releaseVMCaller() is called.
6115	*
6116	* If this method returns a failure, the caller is not allowed to use mpUVM and
6117	* may return the failed result code to the upper level. This method sets the
6118	* extended error info on failure if \a aQuiet is false.
6119	*
6120	* Setting \a aQuiet to true is useful for methods that don't want to return
6121	* the failed result code to the caller when this method fails (e.g. need to
6122	* silently check for the mpUVM availability).
6123	*
6124	* When mpUVM is NULL but \a aAllowNullVM is true, a corresponding error will be
6125	* returned instead of asserting. Having it false is intended as a sanity check
6126	* for methods that have checked mMachineState and expect mpUVM NOT to be
6127	* NULL.
6128	*
6129	* @param aQuiet true to suppress setting error info
6130	* @param aAllowNullVM true to accept mpUVM being NULL and return a failure
6131	* (otherwise this method will assert if mpUVM is NULL)
6132	*
6133	* @note Locks this object for writing.
6134	*/
6135	HRESULT Console::addVMCaller(bool aQuiet /* = false */,
6136	bool aAllowNullVM /* = false */)
6137	{
6138	AutoCaller autoCaller(this);
6139	/** @todo Fix race during console/VM reference destruction, refer @bugref{6318}
6140	* comment 25. */
6141	if (FAILED(autoCaller.rc()))
6142	return autoCaller.rc();
6143
6144	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6145
6146	if (mVMDestroying)
6147	{
6148	/* powerDown() is waiting for all callers to finish */
6149	return aQuiet ? E_ACCESSDENIED : setError(E_ACCESSDENIED,
6150	tr("The virtual machine is being powered down"));
6151	}
6152
6153	if (mpUVM == NULL)
6154	{
6155	Assert(aAllowNullVM == true);
6156
6157	/* The machine is not powered up */
6158	return aQuiet ? E_ACCESSDENIED : setError(E_ACCESSDENIED,
6159	tr("The virtual machine is not powered up"));
6160	}
6161
6162	++mVMCallers;
6163
6164	return S_OK;
6165	}
6166
6167	/**
6168	* Decreases the usage counter of the mpUVM pointer.
6169	*
6170	* Must always complete the addVMCaller() call after the mpUVM pointer is no
6171	* more necessary.
6172	*
6173	* @note Locks this object for writing.
6174	*/
6175	void Console::releaseVMCaller()
6176	{
6177	AutoCaller autoCaller(this);
6178	AssertComRCReturnVoid(autoCaller.rc());
6179
6180	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6181
6182	AssertReturnVoid(mpUVM != NULL);
6183
6184	Assert(mVMCallers > 0);
6185	--mVMCallers;
6186
6187	if (mVMCallers == 0 && mVMDestroying)
6188	{
6189	/* inform powerDown() there are no more callers */
6190	RTSemEventSignal(mVMZeroCallersSem);
6191	}
6192	}
6193
6194
6195	HRESULT Console::safeVMPtrRetainer(PUVM *a_ppUVM, bool a_Quiet)
6196	{
6197	*a_ppUVM = NULL;
6198
6199	AutoCaller autoCaller(this);
6200	AssertComRCReturnRC(autoCaller.rc());
6201	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6202
6203	/*
6204	* Repeat the checks done by addVMCaller.
6205	*/
6206	if (mVMDestroying) /* powerDown() is waiting for all callers to finish */
6207	return a_Quiet
6208	? E_ACCESSDENIED
6209	: setError(E_ACCESSDENIED, tr("The virtual machine is being powered down"));
6210	PUVM pUVM = mpUVM;
6211	if (!pUVM)
6212	return a_Quiet
6213	? E_ACCESSDENIED
6214	: setError(E_ACCESSDENIED, tr("The virtual machine is powered off"));
6215
6216	/*
6217	* Retain a reference to the user mode VM handle and get the global handle.
6218	*/
6219	uint32_t cRefs = VMR3RetainUVM(pUVM);
6220	if (cRefs == UINT32_MAX)
6221	return a_Quiet
6222	? E_ACCESSDENIED
6223	: setError(E_ACCESSDENIED, tr("The virtual machine is powered off"));
6224
6225	/* done */
6226	*a_ppUVM = pUVM;
6227	return S_OK;
6228	}
6229
6230	void Console::safeVMPtrReleaser(PUVM *a_ppUVM)
6231	{
6232	if (*a_ppUVM)
6233	VMR3ReleaseUVM(*a_ppUVM);
6234	*a_ppUVM = NULL;
6235	}
6236
6237
6238	/**
6239	* Initialize the release logging facility. In case something
6240	* goes wrong, there will be no release logging. Maybe in the future
6241	* we can add some logic to use different file names in this case.
6242	* Note that the logic must be in sync with Machine::DeleteSettings().
6243	*/
6244	HRESULT Console::consoleInitReleaseLog(const ComPtr<IMachine> aMachine)
6245	{
6246	HRESULT hrc = S_OK;
6247
6248	Bstr logFolder;
6249	hrc = aMachine->COMGETTER(LogFolder)(logFolder.asOutParam());
6250	if (FAILED(hrc))
6251	return hrc;
6252
6253	Utf8Str logDir = logFolder;
6254
6255	/* make sure the Logs folder exists */
6256	Assert(logDir.length());
6257	if (!RTDirExists(logDir.c_str()))
6258	RTDirCreateFullPath(logDir.c_str(), 0700);
6259
6260	Utf8Str logFile = Utf8StrFmt("%s%cVBox.log",
6261	logDir.c_str(), RTPATH_DELIMITER);
6262	Utf8Str pngFile = Utf8StrFmt("%s%cVBox.png",
6263	logDir.c_str(), RTPATH_DELIMITER);
6264
6265	/*
6266	* Age the old log files
6267	* Rename .(n-1) to .(n), .(n-2) to .(n-1), ..., and the last log file to .1
6268	* Overwrite target files in case they exist.
6269	*/
6270	ComPtr<IVirtualBox> pVirtualBox;
6271	aMachine->COMGETTER(Parent)(pVirtualBox.asOutParam());
6272	ComPtr<ISystemProperties> pSystemProperties;
6273	pVirtualBox->COMGETTER(SystemProperties)(pSystemProperties.asOutParam());
6274	ULONG cHistoryFiles = 3;
6275	pSystemProperties->COMGETTER(LogHistoryCount)(&cHistoryFiles);
6276	if (cHistoryFiles)
6277	{
6278	for (int i = cHistoryFiles-1; i >= 0; i--)
6279	{
6280	Utf8Str *files[] = { &logFile, &pngFile };
6281	Utf8Str oldName, newName;
6282
6283	for (unsigned int j = 0; j < RT_ELEMENTS(files); ++j)
6284	{
6285	if (i > 0)
6286	oldName = Utf8StrFmt("%s.%d", files[j]->c_str(), i);
6287	else
6288	oldName = *files[j];
6289	newName = Utf8StrFmt("%s.%d", files[j]->c_str(), i + 1);
6290	/* If the old file doesn't exist, delete the new file (if it
6291	* exists) to provide correct rotation even if the sequence is
6292	* broken */
6293	if ( RTFileRename(oldName.c_str(), newName.c_str(), RTFILEMOVE_FLAGS_REPLACE)
6294	== VERR_FILE_NOT_FOUND)
6295	RTFileDelete(newName.c_str());
6296	}
6297	}
6298	}
6299
6300	char szError[RTPATH_MAX + 128];
6301	int vrc = com::VBoxLogRelCreate("VM", logFile.c_str(),
6302	RTLOGFLAGS_PREFIX_TIME_PROG \| RTLOGFLAGS_RESTRICT_GROUPS,
6303	"all all.restrict -default.restrict",
6304	"VBOX_RELEASE_LOG", RTLOGDEST_FILE,
6305	32768 /* cMaxEntriesPerGroup */,
6306	0 /* cHistory /, 0 / uHistoryFileTime */,
6307	0 /* uHistoryFileSize */, szError, sizeof(szError));
6308	if (RT_FAILURE(vrc))
6309	hrc = setError(E_FAIL, tr("Failed to open release log (%s, %Rrc)"),
6310	szError, vrc);
6311
6312	/* If we've made any directory changes, flush the directory to increase
6313	the likelihood that the log file will be usable after a system panic.
6314
6315	Tip: Try 'export VBOX_RELEASE_LOG_FLAGS=flush' if the last bits of the log
6316	is missing. Just don't have too high hopes for this to help. */
6317	if (SUCCEEDED(hrc) \|\| cHistoryFiles)
6318	RTDirFlush(logDir.c_str());
6319
6320	return hrc;
6321	}
6322
6323	/**
6324	* Common worker for PowerUp and PowerUpPaused.
6325	*
6326	* @returns COM status code.
6327	*
6328	* @param aProgress Where to return the progress object.
6329	* @param aPaused true if PowerUpPaused called.
6330	*/
6331	HRESULT Console::powerUp(IProgress **aProgress, bool aPaused)
6332	{
6333
6334	LogFlowThisFuncEnter();
6335	LogFlowThisFunc(("mMachineState=%d\n", mMachineState));
6336
6337	CheckComArgOutPointerValid(aProgress);
6338
6339	AutoCaller autoCaller(this);
6340	if (FAILED(autoCaller.rc())) return autoCaller.rc();
6341
6342	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6343
6344	HRESULT rc = S_OK;
6345	ComObjPtr<Progress> pPowerupProgress;
6346	bool fBeganPoweringUp = false;
6347
6348	LONG cOperations = 1;
6349	LONG ulTotalOperationsWeight = 1;
6350
6351	try
6352	{
6353
6354	if (Global::IsOnlineOrTransient(mMachineState))
6355	throw setError(VBOX_E_INVALID_VM_STATE,
6356	tr("The virtual machine is already running or busy (machine state: %s)"),
6357	Global::stringifyMachineState(mMachineState));
6358
6359	/* Set up release logging as early as possible after the check if
6360	* there is already a running VM which we shouldn't disturb. */
6361	rc = consoleInitReleaseLog(mMachine);
6362	if (FAILED(rc))
6363	throw rc;
6364
6365	/* test and clear the TeleporterEnabled property */
6366	BOOL fTeleporterEnabled;
6367	rc = mMachine->COMGETTER(TeleporterEnabled)(&fTeleporterEnabled);
6368	if (FAILED(rc))
6369	throw rc;
6370
6371	#if 0 /** @todo we should save it afterwards, but that isn't necessarily a good idea. Find a better place for this (VBoxSVC). */
6372	if (fTeleporterEnabled)
6373	{
6374	rc = mMachine->COMSETTER(TeleporterEnabled)(FALSE);
6375	if (FAILED(rc))
6376	throw rc;
6377	}
6378	#endif
6379
6380	/* test the FaultToleranceState property */
6381	FaultToleranceState_T enmFaultToleranceState;
6382	rc = mMachine->COMGETTER(FaultToleranceState)(&enmFaultToleranceState);
6383	if (FAILED(rc))
6384	throw rc;
6385	BOOL fFaultToleranceSyncEnabled = (enmFaultToleranceState == FaultToleranceState_Standby);
6386
6387	/* Create a progress object to track progress of this operation. Must
6388	* be done as early as possible (together with BeginPowerUp()) as this
6389	* is vital for communicating as much as possible early powerup
6390	* failure information to the API caller */
6391	pPowerupProgress.createObject();
6392	Bstr progressDesc;
6393	if (mMachineState == MachineState_Saved)
6394	progressDesc = tr("Restoring virtual machine");
6395	else if (fTeleporterEnabled)
6396	progressDesc = tr("Teleporting virtual machine");
6397	else if (fFaultToleranceSyncEnabled)
6398	progressDesc = tr("Fault Tolerance syncing of remote virtual machine");
6399	else
6400	progressDesc = tr("Starting virtual machine");
6401
6402	/* Check all types of shared folders and compose a single list */
6403	SharedFolderDataMap sharedFolders;
6404	{
6405	/* first, insert global folders */
6406	for (SharedFolderDataMap::const_iterator it = m_mapGlobalSharedFolders.begin();
6407	it != m_mapGlobalSharedFolders.end();
6408	++it)
6409	{
6410	const SharedFolderData &d = it->second;
6411	sharedFolders[it->first] = d;
6412	}
6413
6414	/* second, insert machine folders */
6415	for (SharedFolderDataMap::const_iterator it = m_mapMachineSharedFolders.begin();
6416	it != m_mapMachineSharedFolders.end();
6417	++it)
6418	{
6419	const SharedFolderData &d = it->second;
6420	sharedFolders[it->first] = d;
6421	}
6422
6423	/* third, insert console folders */
6424	for (SharedFolderMap::const_iterator it = m_mapSharedFolders.begin();
6425	it != m_mapSharedFolders.end();
6426	++it)
6427	{
6428	SharedFolder *pSF = it->second;
6429	AutoCaller sfCaller(pSF);
6430	AutoReadLock sfLock(pSF COMMA_LOCKVAL_SRC_POS);
6431	sharedFolders[it->first] = SharedFolderData(pSF->getHostPath(),
6432	pSF->isWritable(),
6433	pSF->isAutoMounted());
6434	}
6435	}
6436
6437	Bstr savedStateFile;
6438
6439	/*
6440	* Saved VMs will have to prove that their saved states seem kosher.
6441	*/
6442	if (mMachineState == MachineState_Saved)
6443	{
6444	rc = mMachine->COMGETTER(StateFilePath)(savedStateFile.asOutParam());
6445	if (FAILED(rc))
6446	throw rc;
6447	ComAssertRet(!savedStateFile.isEmpty(), E_FAIL);
6448	int vrc = SSMR3ValidateFile(Utf8Str(savedStateFile).c_str(), false /* fChecksumIt */);
6449	if (RT_FAILURE(vrc))
6450	throw setError(VBOX_E_FILE_ERROR,
6451	tr("VM cannot start because the saved state file '%ls' is invalid (%Rrc). Delete the saved state prior to starting the VM"),
6452	savedStateFile.raw(), vrc);
6453	}
6454
6455	/* Setup task object and thread to carry out the operaton
6456	* Asycnhronously */
6457	std::auto_ptr<VMPowerUpTask> task(new VMPowerUpTask(this, pPowerupProgress));
6458	ComAssertComRCRetRC(task->rc());
6459
6460	task->mConfigConstructor = configConstructor;
6461	task->mSharedFolders = sharedFolders;
6462	task->mStartPaused = aPaused;
6463	if (mMachineState == MachineState_Saved)
6464	task->mSavedStateFile = savedStateFile;
6465	task->mTeleporterEnabled = fTeleporterEnabled;
6466	task->mEnmFaultToleranceState = enmFaultToleranceState;
6467
6468	/* Reset differencing hard disks for which autoReset is true,
6469	* but only if the machine has no snapshots OR the current snapshot
6470	* is an OFFLINE snapshot; otherwise we would reset the current
6471	* differencing image of an ONLINE snapshot which contains the disk
6472	* state of the machine while it was previously running, but without
6473	* the corresponding machine state, which is equivalent to powering
6474	* off a running machine and not good idea
6475	*/
6476	ComPtr<ISnapshot> pCurrentSnapshot;
6477	rc = mMachine->COMGETTER(CurrentSnapshot)(pCurrentSnapshot.asOutParam());
6478	if (FAILED(rc))
6479	throw rc;
6480
6481	BOOL fCurrentSnapshotIsOnline = false;
6482	if (pCurrentSnapshot)
6483	{
6484	rc = pCurrentSnapshot->COMGETTER(Online)(&fCurrentSnapshotIsOnline);
6485	if (FAILED(rc))
6486	throw rc;
6487	}
6488
6489	if (!fCurrentSnapshotIsOnline)
6490	{
6491	LogFlowThisFunc(("Looking for immutable images to reset\n"));
6492
6493	com::SafeIfaceArray<IMediumAttachment> atts;
6494	rc = mMachine->COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(atts));
6495	if (FAILED(rc))
6496	throw rc;
6497
6498	for (size_t i = 0;
6499	i < atts.size();
6500	++i)
6501	{
6502	DeviceType_T devType;
6503	rc = atts[i]->COMGETTER(Type)(&devType);
6504	/** @todo later applies to floppies as well */
6505	if (devType == DeviceType_HardDisk)
6506	{
6507	ComPtr<IMedium> pMedium;
6508	rc = atts[i]->COMGETTER(Medium)(pMedium.asOutParam());
6509	if (FAILED(rc))
6510	throw rc;
6511
6512	/* needs autoreset? */
6513	BOOL autoReset = FALSE;
6514	rc = pMedium->COMGETTER(AutoReset)(&autoReset);
6515	if (FAILED(rc))
6516	throw rc;
6517
6518	if (autoReset)
6519	{
6520	ComPtr<IProgress> pResetProgress;
6521	rc = pMedium->Reset(pResetProgress.asOutParam());
6522	if (FAILED(rc))
6523	throw rc;
6524
6525	/* save for later use on the powerup thread */
6526	task->hardDiskProgresses.push_back(pResetProgress);
6527	}
6528	}
6529	}
6530	}
6531	else
6532	LogFlowThisFunc(("Machine has a current snapshot which is online, skipping immutable images reset\n"));
6533
6534	/* setup task object and thread to carry out the operation
6535	* asynchronously */
6536
6537	#ifdef VBOX_WITH_EXTPACK
6538	mptrExtPackManager->dumpAllToReleaseLog();
6539	#endif
6540
6541	#ifdef RT_OS_SOLARIS
6542	/* setup host core dumper for the VM */
6543	Bstr value;
6544	HRESULT hrc = mMachine->GetExtraData(Bstr("VBoxInternal2/CoreDumpEnabled").raw(), value.asOutParam());
6545	if (SUCCEEDED(hrc) && value == "1")
6546	{
6547	Bstr coreDumpDir, coreDumpReplaceSys, coreDumpLive;
6548	mMachine->GetExtraData(Bstr("VBoxInternal2/CoreDumpDir").raw(), coreDumpDir.asOutParam());
6549	mMachine->GetExtraData(Bstr("VBoxInternal2/CoreDumpReplaceSystemDump").raw(), coreDumpReplaceSys.asOutParam());
6550	mMachine->GetExtraData(Bstr("VBoxInternal2/CoreDumpLive").raw(), coreDumpLive.asOutParam());
6551
6552	uint32_t fCoreFlags = 0;
6553	if ( coreDumpReplaceSys.isEmpty() == false
6554	&& Utf8Str(coreDumpReplaceSys).toUInt32() == 1)
6555	fCoreFlags \|= RTCOREDUMPER_FLAGS_REPLACE_SYSTEM_DUMP;
6556
6557	if ( coreDumpLive.isEmpty() == false
6558	&& Utf8Str(coreDumpLive).toUInt32() == 1)
6559	fCoreFlags \|= RTCOREDUMPER_FLAGS_LIVE_CORE;
6560
6561	Utf8Str strDumpDir(coreDumpDir);
6562	const char *pszDumpDir = strDumpDir.c_str();
6563	if ( pszDumpDir
6564	&& *pszDumpDir == '\0')
6565	pszDumpDir = NULL;
6566
6567	int vrc;
6568	if ( pszDumpDir
6569	&& !RTDirExists(pszDumpDir))
6570	{
6571	/*
6572	* Try create the directory.
6573	*/
6574	vrc = RTDirCreateFullPath(pszDumpDir, 0700);
6575	if (RT_FAILURE(vrc))
6576	throw setError(E_FAIL, "Failed to setup CoreDumper. Couldn't create dump directory '%s' (%Rrc)\n", pszDumpDir, vrc);
6577	}
6578
6579	vrc = RTCoreDumperSetup(pszDumpDir, fCoreFlags);
6580	if (RT_FAILURE(vrc))
6581	throw setError(E_FAIL, "Failed to setup CoreDumper (%Rrc)", vrc);
6582	else
6583	LogRel(("CoreDumper setup successful. pszDumpDir=%s fFlags=%#x\n", pszDumpDir ? pszDumpDir : ".", fCoreFlags));
6584	}
6585	#endif
6586
6587
6588	// If there is immutable drive the process that.
6589	VMPowerUpTask::ProgressList progresses(task->hardDiskProgresses);
6590	if (aProgress && progresses.size() > 0){
6591
6592	for (VMPowerUpTask::ProgressList::const_iterator it = progresses.begin(); it != progresses.end(); ++it)
6593	{
6594	++cOperations;
6595	ulTotalOperationsWeight += 1;
6596	}
6597	rc = pPowerupProgress->init(static_cast<IConsole *>(this),
6598	progressDesc.raw(),
6599	TRUE, // Cancelable
6600	cOperations,
6601	ulTotalOperationsWeight,
6602	Bstr(tr("Starting Hard Disk operations")).raw(),
6603	1,
6604	NULL);
6605	AssertComRCReturnRC(rc);
6606	}
6607	else if ( mMachineState == MachineState_Saved
6608	\|\| (!fTeleporterEnabled && !fFaultToleranceSyncEnabled))
6609	{
6610	rc = pPowerupProgress->init(static_cast<IConsole *>(this),
6611	progressDesc.raw(),
6612	FALSE /* aCancelable */);
6613	}
6614	else if (fTeleporterEnabled)
6615	{
6616	rc = pPowerupProgress->init(static_cast<IConsole *>(this),
6617	progressDesc.raw(),
6618	TRUE /* aCancelable */,
6619	3 /* cOperations */,
6620	10 /* ulTotalOperationsWeight */,
6621	Bstr(tr("Teleporting virtual machine")).raw(),
6622	1 /* ulFirstOperationWeight */,
6623	NULL);
6624	}
6625	else if (fFaultToleranceSyncEnabled)
6626	{
6627	rc = pPowerupProgress->init(static_cast<IConsole *>(this),
6628	progressDesc.raw(),
6629	TRUE /* aCancelable */,
6630	3 /* cOperations */,
6631	10 /* ulTotalOperationsWeight */,
6632	Bstr(tr("Fault Tolerance syncing of remote virtual machine")).raw(),
6633	1 /* ulFirstOperationWeight */,
6634	NULL);
6635	}
6636
6637	if (FAILED(rc))
6638	throw rc;
6639
6640	/* Tell VBoxSVC and Machine about the progress object so they can
6641	combine/proxy it to any openRemoteSession caller. */
6642	LogFlowThisFunc(("Calling BeginPowerUp...\n"));
6643	rc = mControl->BeginPowerUp(pPowerupProgress);
6644	if (FAILED(rc))
6645	{
6646	LogFlowThisFunc(("BeginPowerUp failed\n"));
6647	throw rc;
6648	}
6649	fBeganPoweringUp = true;
6650
6651	LogFlowThisFunc(("Checking if canceled...\n"));
6652	BOOL fCanceled;
6653	rc = pPowerupProgress->COMGETTER(Canceled)(&fCanceled);
6654	if (FAILED(rc))
6655	throw rc;
6656
6657	if (fCanceled)
6658	{
6659	LogFlowThisFunc(("Canceled in BeginPowerUp\n"));
6660	throw setError(E_FAIL, tr("Powerup was canceled"));
6661	}
6662	LogFlowThisFunc(("Not canceled yet.\n"));
6663
6664	/** @todo this code prevents starting a VM with unavailable bridged
6665	* networking interface. The only benefit is a slightly better error
6666	* message, which should be moved to the driver code. This is the
6667	* only reason why I left the code in for now. The driver allows
6668	* unavailable bridged networking interfaces in certain circumstances,
6669	* and this is sabotaged by this check. The VM will initially have no
6670	* network connectivity, but the user can fix this at runtime. */
6671	#if 0
6672	/* the network cards will undergo a quick consistency check */
6673	for (ULONG slot = 0;
6674	slot < maxNetworkAdapters;
6675	++slot)
6676	{
6677	ComPtr<INetworkAdapter> pNetworkAdapter;
6678	mMachine->GetNetworkAdapter(slot, pNetworkAdapter.asOutParam());
6679	BOOL enabled = FALSE;
6680	pNetworkAdapter->COMGETTER(Enabled)(&enabled);
6681	if (!enabled)
6682	continue;
6683
6684	NetworkAttachmentType_T netattach;
6685	pNetworkAdapter->COMGETTER(AttachmentType)(&netattach);
6686	switch (netattach)
6687	{
6688	case NetworkAttachmentType_Bridged:
6689	{
6690	/* a valid host interface must have been set */
6691	Bstr hostif;
6692	pNetworkAdapter->COMGETTER(HostInterface)(hostif.asOutParam());
6693	if (hostif.isEmpty())
6694	{
6695	throw setError(VBOX_E_HOST_ERROR,
6696	tr("VM cannot start because host interface networking requires a host interface name to be set"));
6697	}
6698	ComPtr<IVirtualBox> pVirtualBox;
6699	mMachine->COMGETTER(Parent)(pVirtualBox.asOutParam());
6700	ComPtr<IHost> pHost;
6701	pVirtualBox->COMGETTER(Host)(pHost.asOutParam());
6702	ComPtr<IHostNetworkInterface> pHostInterface;
6703	if (!SUCCEEDED(pHost->FindHostNetworkInterfaceByName(hostif.raw(),
6704	pHostInterface.asOutParam())))
6705	{
6706	throw setError(VBOX_E_HOST_ERROR,
6707	tr("VM cannot start because the host interface '%ls' does not exist"),
6708	hostif.raw());
6709	}
6710	break;
6711	}
6712	default:
6713	break;
6714	}
6715	}
6716	#endif // 0
6717
6718	/* Read console data stored in the saved state file (if not yet done) */
6719	rc = loadDataFromSavedState();
6720	if (FAILED(rc))
6721	throw rc;
6722
6723	/* setup task object and thread to carry out the operation
6724	* asynchronously */
6725	if (aProgress){
6726	rc = pPowerupProgress.queryInterfaceTo(aProgress);
6727	AssertComRCReturnRC(rc);
6728	}
6729
6730	int vrc = RTThreadCreate(NULL, Console::powerUpThread,
6731	(void *)task.get(), 0,
6732	RTTHREADTYPE_MAIN_WORKER, 0, "VMPwrUp");
6733	if (RT_FAILURE(vrc))
6734	throw setError(E_FAIL, "Could not create VMPowerUp thread (%Rrc)", vrc);
6735
6736	/* task is now owned by powerUpThread(), so release it */
6737	task.release();
6738
6739	/* finally, set the state: no right to fail in this method afterwards
6740	* since we've already started the thread and it is now responsible for
6741	* any error reporting and appropriate state change! */
6742	if (mMachineState == MachineState_Saved)
6743	setMachineState(MachineState_Restoring);
6744	else if (fTeleporterEnabled)
6745	setMachineState(MachineState_TeleportingIn);
6746	else if (enmFaultToleranceState == FaultToleranceState_Standby)
6747	setMachineState(MachineState_FaultTolerantSyncing);
6748	else
6749	setMachineState(MachineState_Starting);
6750	}
6751	catch (HRESULT aRC) { rc = aRC; }
6752
6753	if (FAILED(rc) && fBeganPoweringUp)
6754	{
6755
6756	/* The progress object will fetch the current error info */
6757	if (!pPowerupProgress.isNull())
6758	pPowerupProgress->notifyComplete(rc);
6759
6760	/* Save the error info across the IPC below. Can't be done before the
6761	* progress notification above, as saving the error info deletes it
6762	* from the current context, and thus the progress object wouldn't be
6763	* updated correctly. */
6764	ErrorInfoKeeper eik;
6765
6766	/* signal end of operation */
6767	mControl->EndPowerUp(rc);
6768	}
6769
6770	LogFlowThisFunc(("mMachineState=%d, rc=%Rhrc\n", mMachineState, rc));
6771	LogFlowThisFuncLeave();
6772	return rc;
6773	}
6774
6775	/**
6776	* Internal power off worker routine.
6777	*
6778	* This method may be called only at certain places with the following meaning
6779	* as shown below:
6780	*
6781	* - if the machine state is either Running or Paused, a normal
6782	* Console-initiated powerdown takes place (e.g. PowerDown());
6783	* - if the machine state is Saving, saveStateThread() has successfully done its
6784	* job;
6785	* - if the machine state is Starting or Restoring, powerUpThread() has failed
6786	* to start/load the VM;
6787	* - if the machine state is Stopping, the VM has powered itself off (i.e. not
6788	* as a result of the powerDown() call).
6789	*
6790	* Calling it in situations other than the above will cause unexpected behavior.
6791	*
6792	* Note that this method should be the only one that destroys mpUVM and sets it
6793	* to NULL.
6794	*
6795	* @param aProgress Progress object to run (may be NULL).
6796	*
6797	* @note Locks this object for writing.
6798	*
6799	* @note Never call this method from a thread that called addVMCaller() or
6800	* instantiated an AutoVMCaller object; first call releaseVMCaller() or
6801	* release(). Otherwise it will deadlock.
6802	*/
6803	HRESULT Console::powerDown(IProgress aProgress /= NULL*/)
6804	{
6805	LogFlowThisFuncEnter();
6806
6807	AutoCaller autoCaller(this);
6808	AssertComRCReturnRC(autoCaller.rc());
6809
6810	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6811
6812	/* Total # of steps for the progress object. Must correspond to the
6813	* number of "advance percent count" comments in this method! */
6814	enum { StepCount = 7 };
6815	/* current step */
6816	ULONG step = 0;
6817
6818	HRESULT rc = S_OK;
6819	int vrc = VINF_SUCCESS;
6820
6821	/* sanity */
6822	Assert(mVMDestroying == false);
6823
6824	PUVM pUVM = mpUVM; Assert(pUVM != NULL);
6825	uint32_t cRefs = VMR3RetainUVM(pUVM); Assert(cRefs != UINT32_MAX);
6826
6827	AssertMsg( mMachineState == MachineState_Running
6828	\|\| mMachineState == MachineState_Paused
6829	\|\| mMachineState == MachineState_Stuck
6830	\|\| mMachineState == MachineState_Starting
6831	\|\| mMachineState == MachineState_Stopping
6832	\|\| mMachineState == MachineState_Saving
6833	\|\| mMachineState == MachineState_Restoring
6834	\|\| mMachineState == MachineState_TeleportingPausedVM
6835	\|\| mMachineState == MachineState_FaultTolerantSyncing
6836	\|\| mMachineState == MachineState_TeleportingIn
6837	, ("Invalid machine state: %s\n", Global::stringifyMachineState(mMachineState)));
6838
6839	LogRel(("Console::powerDown(): A request to power off the VM has been issued (mMachineState=%s, InUninit=%d)\n",
6840	Global::stringifyMachineState(mMachineState), autoCaller.state() == InUninit));
6841
6842	/* Check if we need to power off the VM. In case of mVMPoweredOff=true, the
6843	* VM has already powered itself off in vmstateChangeCallback() and is just
6844	* notifying Console about that. In case of Starting or Restoring,
6845	* powerUpThread() is calling us on failure, so the VM is already off at
6846	* that point. */
6847	if ( !mVMPoweredOff
6848	&& ( mMachineState == MachineState_Starting
6849	\|\| mMachineState == MachineState_Restoring
6850	\|\| mMachineState == MachineState_FaultTolerantSyncing
6851	\|\| mMachineState == MachineState_TeleportingIn)
6852	)
6853	mVMPoweredOff = true;
6854
6855	/*
6856	* Go to Stopping state if not already there.
6857	*
6858	* Note that we don't go from Saving/Restoring to Stopping because
6859	* vmstateChangeCallback() needs it to set the state to Saved on
6860	* VMSTATE_TERMINATED. In terms of protecting from inappropriate operations
6861	* while leaving the lock below, Saving or Restoring should be fine too.
6862	* Ditto for TeleportingPausedVM -> Teleported.
6863	*/
6864	if ( mMachineState != MachineState_Saving
6865	&& mMachineState != MachineState_Restoring
6866	&& mMachineState != MachineState_Stopping
6867	&& mMachineState != MachineState_TeleportingIn
6868	&& mMachineState != MachineState_TeleportingPausedVM
6869	&& mMachineState != MachineState_FaultTolerantSyncing
6870	)
6871	setMachineState(MachineState_Stopping);
6872
6873	/* ----------------------------------------------------------------------
6874	* DONE with necessary state changes, perform the power down actions (it's
6875	* safe to release the object lock now if needed)
6876	* ---------------------------------------------------------------------- */
6877
6878	/* Stop the VRDP server to prevent new clients connection while VM is being
6879	* powered off. */
6880	if (mConsoleVRDPServer)
6881	{
6882	LogFlowThisFunc(("Stopping VRDP server...\n"));
6883
6884	/* Leave the lock since EMT will call us back as addVMCaller()
6885	* in updateDisplayData(). */
6886	alock.release();
6887
6888	mConsoleVRDPServer->Stop();
6889
6890	alock.acquire();
6891	}
6892
6893	/* advance percent count */
6894	if (aProgress)
6895	aProgress->SetCurrentOperationProgress(99 * (++step) / StepCount );
6896
6897
6898	/* ----------------------------------------------------------------------
6899	* Now, wait for all mpUVM callers to finish their work if there are still
6900	* some on other threads. NO methods that need mpUVM (or initiate other calls
6901	* that need it) may be called after this point
6902	* ---------------------------------------------------------------------- */
6903
6904	/* go to the destroying state to prevent from adding new callers */
6905	mVMDestroying = true;
6906
6907	if (mVMCallers > 0)
6908	{
6909	/* lazy creation */
6910	if (mVMZeroCallersSem == NIL_RTSEMEVENT)
6911	RTSemEventCreate(&mVMZeroCallersSem);
6912
6913	LogFlowThisFunc(("Waiting for mpUVM callers (%d) to drop to zero...\n", mVMCallers));
6914
6915	alock.release();
6916
6917	RTSemEventWait(mVMZeroCallersSem, RT_INDEFINITE_WAIT);
6918
6919	alock.acquire();
6920	}
6921
6922	/* advance percent count */
6923	if (aProgress)
6924	aProgress->SetCurrentOperationProgress(99 * (++step) / StepCount );
6925
6926	vrc = VINF_SUCCESS;
6927
6928	/*
6929	* Power off the VM if not already done that.
6930	* Leave the lock since EMT will call vmstateChangeCallback.
6931	*
6932	* Note that VMR3PowerOff() may fail here (invalid VMSTATE) if the
6933	* VM-(guest-)initiated power off happened in parallel a ms before this
6934	* call. So far, we let this error pop up on the user's side.
6935	*/
6936	if (!mVMPoweredOff)
6937	{
6938	LogFlowThisFunc(("Powering off the VM...\n"));
6939	alock.release();
6940	vrc = VMR3PowerOff(pUVM);
6941	#ifdef VBOX_WITH_EXTPACK
6942	mptrExtPackManager->callAllVmPowerOffHooks(this, VMR3GetVM(pUVM));
6943	#endif
6944	alock.acquire();
6945	}
6946
6947	/* advance percent count */
6948	if (aProgress)
6949	aProgress->SetCurrentOperationProgress(99 * (++step) / StepCount );
6950
6951	#ifdef VBOX_WITH_HGCM
6952	/* Shutdown HGCM services before destroying the VM. */
6953	if (m_pVMMDev)
6954	{
6955	LogFlowThisFunc(("Shutdown HGCM...\n"));
6956
6957	/* Leave the lock since EMT will call us back as addVMCaller() */
6958	alock.release();
6959
6960	m_pVMMDev->hgcmShutdown();
6961
6962	alock.acquire();
6963	}
6964
6965	/* advance percent count */
6966	if (aProgress)
6967	aProgress->SetCurrentOperationProgress(99 * (++step) / StepCount);
6968
6969	#endif /* VBOX_WITH_HGCM */
6970
6971	LogFlowThisFunc(("Ready for VM destruction.\n"));
6972
6973	/* If we are called from Console::uninit(), then try to destroy the VM even
6974	* on failure (this will most likely fail too, but what to do?..) */
6975	if (RT_SUCCESS(vrc) \|\| autoCaller.state() == InUninit)
6976	{
6977	/* If the machine has an USB controller, release all USB devices
6978	* (symmetric to the code in captureUSBDevices()) */
6979	bool fHasUSBController = false;
6980	{
6981	PPDMIBASE pBase;
6982	vrc = PDMR3QueryLun(pUVM, "usb-ohci", 0, 0, &pBase);
6983	if (RT_SUCCESS(vrc))
6984	{
6985	fHasUSBController = true;
6986	alock.release();
6987	detachAllUSBDevices(false /* aDone */);
6988	alock.acquire();
6989	}
6990	}
6991
6992	/* Now we've got to destroy the VM as well. (mpUVM is not valid beyond
6993	* this point). We release the lock before calling VMR3Destroy() because
6994	* it will result into calling destructors of drivers associated with
6995	* Console children which may in turn try to lock Console (e.g. by
6996	* instantiating SafeVMPtr to access mpUVM). It's safe here because
6997	* mVMDestroying is set which should prevent any activity. */
6998
6999	/* Set mpUVM to NULL early just in case if some old code is not using
7000	* addVMCaller()/releaseVMCaller(). (We have our own ref on pUVM.) */
7001	VMR3ReleaseUVM(mpUVM);
7002	mpUVM = NULL;
7003
7004	LogFlowThisFunc(("Destroying the VM...\n"));
7005
7006	alock.release();
7007
7008	vrc = VMR3Destroy(pUVM);
7009
7010	/* take the lock again */
7011	alock.acquire();
7012
7013	/* advance percent count */
7014	if (aProgress)
7015	aProgress->SetCurrentOperationProgress(99 * (++step) / StepCount);
7016
7017	if (RT_SUCCESS(vrc))
7018	{
7019	LogFlowThisFunc(("Machine has been destroyed (mMachineState=%d)\n",
7020	mMachineState));
7021	/* Note: the Console-level machine state change happens on the
7022	* VMSTATE_TERMINATE state change in vmstateChangeCallback(). If
7023	* powerDown() is called from EMT (i.e. from vmstateChangeCallback()
7024	* on receiving VM-initiated VMSTATE_OFF), VMSTATE_TERMINATE hasn't
7025	* occurred yet. This is okay, because mMachineState is already
7026	* Stopping in this case, so any other attempt to call PowerDown()
7027	* will be rejected. */
7028	}
7029	else
7030	{
7031	/* bad bad bad, but what to do? (Give Console our UVM ref.) */
7032	mpUVM = pUVM;
7033	pUVM = NULL;
7034	rc = setError(VBOX_E_VM_ERROR,
7035	tr("Could not destroy the machine. (Error: %Rrc)"),
7036	vrc);
7037	}
7038
7039	/* Complete the detaching of the USB devices. */
7040	if (fHasUSBController)
7041	{
7042	alock.release();
7043	detachAllUSBDevices(true /* aDone */);
7044	alock.acquire();
7045	}
7046
7047	/* advance percent count */
7048	if (aProgress)
7049	aProgress->SetCurrentOperationProgress(99 * (++step) / StepCount);
7050	}
7051	else
7052	{
7053	rc = setError(VBOX_E_VM_ERROR,
7054	tr("Could not power off the machine. (Error: %Rrc)"),
7055	vrc);
7056	}
7057
7058	/*
7059	* Finished with the destruction.
7060	*
7061	* Note that if something impossible happened and we've failed to destroy
7062	* the VM, mVMDestroying will remain true and mMachineState will be
7063	* something like Stopping, so most Console methods will return an error
7064	* to the caller.
7065	*/
7066	if (mpUVM != NULL)
7067	VMR3ReleaseUVM(pUVM);
7068	else
7069	mVMDestroying = false;
7070
7071	#ifdef CONSOLE_WITH_EVENT_CACHE
7072	if (SUCCEEDED(rc))
7073	mCallbackData.clear();
7074	#endif
7075
7076	LogFlowThisFuncLeave();
7077	return rc;
7078	}
7079
7080	/**
7081	* @note Locks this object for writing.
7082	*/
7083	HRESULT Console::setMachineState(MachineState_T aMachineState,
7084	bool aUpdateServer /* = true */)
7085	{
7086	AutoCaller autoCaller(this);
7087	AssertComRCReturnRC(autoCaller.rc());
7088
7089	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7090
7091	HRESULT rc = S_OK;
7092
7093	if (mMachineState != aMachineState)
7094	{
7095	LogThisFunc(("machineState=%s -> %s aUpdateServer=%RTbool\n",
7096	Global::stringifyMachineState(mMachineState), Global::stringifyMachineState(aMachineState), aUpdateServer));
7097	mMachineState = aMachineState;
7098
7099	/// @todo (dmik)
7100	// possibly, we need to redo onStateChange() using the dedicated
7101	// Event thread, like it is done in VirtualBox. This will make it
7102	// much safer (no deadlocks possible if someone tries to use the
7103	// console from the callback), however, listeners will lose the
7104	// ability to synchronously react to state changes (is it really
7105	// necessary??)
7106	LogFlowThisFunc(("Doing onStateChange()...\n"));
7107	onStateChange(aMachineState);
7108	LogFlowThisFunc(("Done onStateChange()\n"));
7109
7110	if (aUpdateServer)
7111	{
7112	/* Server notification MUST be done from under the lock; otherwise
7113	* the machine state here and on the server might go out of sync
7114	* which can lead to various unexpected results (like the machine
7115	* state being >= MachineState_Running on the server, while the
7116	* session state is already SessionState_Unlocked at the same time
7117	* there).
7118	*
7119	* Cross-lock conditions should be carefully watched out: calling
7120	* UpdateState we will require Machine and SessionMachine locks
7121	* (remember that here we're holding the Console lock here, and also
7122	* all locks that have been acquire by the thread before calling
7123	* this method).
7124	*/
7125	LogFlowThisFunc(("Doing mControl->UpdateState()...\n"));
7126	rc = mControl->UpdateState(aMachineState);
7127	LogFlowThisFunc(("mControl->UpdateState()=%Rhrc\n", rc));
7128	}
7129	}
7130
7131	return rc;
7132	}
7133
7134	/**
7135	* Searches for a shared folder with the given logical name
7136	* in the collection of shared folders.
7137	*
7138	* @param aName logical name of the shared folder
7139	* @param aSharedFolder where to return the found object
7140	* @param aSetError whether to set the error info if the folder is
7141	* not found
7142	* @return
7143	* S_OK when found or E_INVALIDARG when not found
7144	*
7145	* @note The caller must lock this object for writing.
7146	*/
7147	HRESULT Console::findSharedFolder(const Utf8Str &strName,
7148	ComObjPtr<SharedFolder> &aSharedFolder,
7149	bool aSetError /* = false */)
7150	{
7151	/* sanity check */
7152	AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
7153
7154	SharedFolderMap::const_iterator it = m_mapSharedFolders.find(strName);
7155	if (it != m_mapSharedFolders.end())
7156	{
7157	aSharedFolder = it->second;
7158	return S_OK;
7159	}
7160
7161	if (aSetError)
7162	setError(VBOX_E_FILE_ERROR,
7163	tr("Could not find a shared folder named '%s'."),
7164	strName.c_str());
7165
7166	return VBOX_E_FILE_ERROR;
7167	}
7168
7169	/**
7170	* Fetches the list of global or machine shared folders from the server.
7171	*
7172	* @param aGlobal true to fetch global folders.
7173	*
7174	* @note The caller must lock this object for writing.
7175	*/
7176	HRESULT Console::fetchSharedFolders(BOOL aGlobal)
7177	{
7178	/* sanity check */
7179	AssertReturn(AutoCaller(this).state() == InInit \|\|
7180	isWriteLockOnCurrentThread(), E_FAIL);
7181
7182	LogFlowThisFunc(("Entering\n"));
7183
7184	/* Check if we're online and keep it that way. */
7185	SafeVMPtrQuiet ptrVM(this);
7186	AutoVMCallerQuietWeak autoVMCaller(this);
7187	bool const online = ptrVM.isOk()
7188	&& m_pVMMDev
7189	&& m_pVMMDev->isShFlActive();
7190
7191	HRESULT rc = S_OK;
7192
7193	try
7194	{
7195	if (aGlobal)
7196	{
7197	/// @todo grab & process global folders when they are done
7198	}
7199	else
7200	{
7201	SharedFolderDataMap oldFolders;
7202	if (online)
7203	oldFolders = m_mapMachineSharedFolders;
7204
7205	m_mapMachineSharedFolders.clear();
7206
7207	SafeIfaceArray<ISharedFolder> folders;
7208	rc = mMachine->COMGETTER(SharedFolders)(ComSafeArrayAsOutParam(folders));
7209	if (FAILED(rc)) throw rc;
7210
7211	for (size_t i = 0; i < folders.size(); ++i)
7212	{
7213	ComPtr<ISharedFolder> pSharedFolder = folders[i];
7214
7215	Bstr bstrName;
7216	Bstr bstrHostPath;
7217	BOOL writable;
7218	BOOL autoMount;
7219
7220	rc = pSharedFolder->COMGETTER(Name)(bstrName.asOutParam());
7221	if (FAILED(rc)) throw rc;
7222	Utf8Str strName(bstrName);
7223
7224	rc = pSharedFolder->COMGETTER(HostPath)(bstrHostPath.asOutParam());
7225	if (FAILED(rc)) throw rc;
7226	Utf8Str strHostPath(bstrHostPath);
7227
7228	rc = pSharedFolder->COMGETTER(Writable)(&writable);
7229	if (FAILED(rc)) throw rc;
7230
7231	rc = pSharedFolder->COMGETTER(AutoMount)(&autoMount);
7232	if (FAILED(rc)) throw rc;
7233
7234	m_mapMachineSharedFolders.insert(std::make_pair(strName,
7235	SharedFolderData(strHostPath, !!writable, !!autoMount)));
7236
7237	/* send changes to HGCM if the VM is running */
7238	if (online)
7239	{
7240	SharedFolderDataMap::iterator it = oldFolders.find(strName);
7241	if ( it == oldFolders.end()
7242	\|\| it->second.m_strHostPath != strHostPath)
7243	{
7244	/* a new machine folder is added or
7245	* the existing machine folder is changed */
7246	if (m_mapSharedFolders.find(strName) != m_mapSharedFolders.end())
7247	; /* the console folder exists, nothing to do */
7248	else
7249	{
7250	/* remove the old machine folder (when changed)
7251	* or the global folder if any (when new) */
7252	if ( it != oldFolders.end()
7253	\|\| m_mapGlobalSharedFolders.find(strName) != m_mapGlobalSharedFolders.end()
7254	)
7255	{
7256	rc = removeSharedFolder(strName);
7257	if (FAILED(rc)) throw rc;
7258	}
7259
7260	/* create the new machine folder */
7261	rc = createSharedFolder(strName,
7262	SharedFolderData(strHostPath, !!writable, !!autoMount));
7263	if (FAILED(rc)) throw rc;
7264	}
7265	}
7266	/* forget the processed (or identical) folder */
7267	if (it != oldFolders.end())
7268	oldFolders.erase(it);
7269	}
7270	}
7271
7272	/* process outdated (removed) folders */
7273	if (online)
7274	{
7275	for (SharedFolderDataMap::const_iterator it = oldFolders.begin();
7276	it != oldFolders.end(); ++it)
7277	{
7278	if (m_mapSharedFolders.find(it->first) != m_mapSharedFolders.end())
7279	; /* the console folder exists, nothing to do */
7280	else
7281	{
7282	/* remove the outdated machine folder */
7283	rc = removeSharedFolder(it->first);
7284	if (FAILED(rc)) throw rc;
7285
7286	/* create the global folder if there is any */
7287	SharedFolderDataMap::const_iterator git =
7288	m_mapGlobalSharedFolders.find(it->first);
7289	if (git != m_mapGlobalSharedFolders.end())
7290	{
7291	rc = createSharedFolder(git->first, git->second);
7292	if (FAILED(rc)) throw rc;
7293	}
7294	}
7295	}
7296	}
7297	}
7298	}
7299	catch (HRESULT rc2)
7300	{
7301	if (online)
7302	setVMRuntimeErrorCallbackF(0, "BrokenSharedFolder",
7303	N_("Broken shared folder!"));
7304	}
7305
7306	LogFlowThisFunc(("Leaving\n"));
7307
7308	return rc;
7309	}
7310
7311	/**
7312	* Searches for a shared folder with the given name in the list of machine
7313	* shared folders and then in the list of the global shared folders.
7314	*
7315	* @param aName Name of the folder to search for.
7316	* @param aIt Where to store the pointer to the found folder.
7317	* @return @c true if the folder was found and @c false otherwise.
7318	*
7319	* @note The caller must lock this object for reading.
7320	*/
7321	bool Console::findOtherSharedFolder(const Utf8Str &strName,
7322	SharedFolderDataMap::const_iterator &aIt)
7323	{
7324	/* sanity check */
7325	AssertReturn(isWriteLockOnCurrentThread(), false);
7326
7327	/* first, search machine folders */
7328	aIt = m_mapMachineSharedFolders.find(strName);
7329	if (aIt != m_mapMachineSharedFolders.end())
7330	return true;
7331
7332	/* second, search machine folders */
7333	aIt = m_mapGlobalSharedFolders.find(strName);
7334	if (aIt != m_mapGlobalSharedFolders.end())
7335	return true;
7336
7337	return false;
7338	}
7339
7340	/**
7341	* Calls the HGCM service to add a shared folder definition.
7342	*
7343	* @param aName Shared folder name.
7344	* @param aHostPath Shared folder path.
7345	*
7346	* @note Must be called from under AutoVMCaller and when mpUVM != NULL!
7347	* @note Doesn't lock anything.
7348	*/
7349	HRESULT Console::createSharedFolder(const Utf8Str &strName, const SharedFolderData &aData)
7350	{
7351	ComAssertRet(strName.isNotEmpty(), E_FAIL);
7352	ComAssertRet(aData.m_strHostPath.isNotEmpty(), E_FAIL);
7353
7354	/* sanity checks */
7355	AssertReturn(mpUVM, E_FAIL);
7356	AssertReturn(m_pVMMDev && m_pVMMDev->isShFlActive(), E_FAIL);
7357
7358	VBOXHGCMSVCPARM parms[SHFL_CPARMS_ADD_MAPPING];
7359	SHFLSTRING pFolderName, pMapName;
7360	size_t cbString;
7361
7362	Bstr value;
7363	HRESULT hrc = mMachine->GetExtraData(BstrFmt("VBoxInternal2/SharedFoldersEnableSymlinksCreate/%s",
7364	strName.c_str()).raw(),
7365	value.asOutParam());
7366	bool fSymlinksCreate = hrc == S_OK && value == "1";
7367
7368	Log(("Adding shared folder '%s' -> '%s'\n", strName.c_str(), aData.m_strHostPath.c_str()));
7369
7370	// check whether the path is valid and exists
7371	char hostPathFull[RTPATH_MAX];
7372	int vrc = RTPathAbsEx(NULL,
7373	aData.m_strHostPath.c_str(),
7374	hostPathFull,
7375	sizeof(hostPathFull));
7376
7377	bool fMissing = false;
7378	if (RT_FAILURE(vrc))
7379	return setError(E_INVALIDARG,
7380	tr("Invalid shared folder path: '%s' (%Rrc)"),
7381	aData.m_strHostPath.c_str(), vrc);
7382	if (!RTPathExists(hostPathFull))
7383	fMissing = true;
7384
7385	/* Check whether the path is full (absolute) */
7386	if (RTPathCompare(aData.m_strHostPath.c_str(), hostPathFull) != 0)
7387	return setError(E_INVALIDARG,
7388	tr("Shared folder path '%s' is not absolute"),
7389	aData.m_strHostPath.c_str());
7390
7391	// now that we know the path is good, give it to HGCM
7392
7393	Bstr bstrName(strName);
7394	Bstr bstrHostPath(aData.m_strHostPath);
7395
7396	cbString = (bstrHostPath.length() + 1) * sizeof(RTUTF16);
7397	if (cbString >= UINT16_MAX)
7398	return setError(E_INVALIDARG, tr("The name is too long"));
7399	pFolderName = (SHFLSTRING*)RTMemAllocZ(sizeof(SHFLSTRING) + cbString);
7400	Assert(pFolderName);
7401	memcpy(pFolderName->String.ucs2, bstrHostPath.raw(), cbString);
7402
7403	pFolderName->u16Size = (uint16_t)cbString;
7404	pFolderName->u16Length = (uint16_t)cbString - sizeof(RTUTF16);
7405
7406	parms[0].type = VBOX_HGCM_SVC_PARM_PTR;
7407	parms[0].u.pointer.addr = pFolderName;
7408	parms[0].u.pointer.size = sizeof(SHFLSTRING) + (uint16_t)cbString;
7409
7410	cbString = (bstrName.length() + 1) * sizeof(RTUTF16);
7411	if (cbString >= UINT16_MAX)
7412	{
7413	RTMemFree(pFolderName);
7414	return setError(E_INVALIDARG, tr("The host path is too long"));
7415	}
7416	pMapName = (SHFLSTRING*)RTMemAllocZ(sizeof(SHFLSTRING) + cbString);
7417	Assert(pMapName);
7418	memcpy(pMapName->String.ucs2, bstrName.raw(), cbString);
7419
7420	pMapName->u16Size = (uint16_t)cbString;
7421	pMapName->u16Length = (uint16_t)cbString - sizeof(RTUTF16);
7422
7423	parms[1].type = VBOX_HGCM_SVC_PARM_PTR;
7424	parms[1].u.pointer.addr = pMapName;
7425	parms[1].u.pointer.size = sizeof(SHFLSTRING) + (uint16_t)cbString;
7426
7427	parms[2].type = VBOX_HGCM_SVC_PARM_32BIT;
7428	parms[2].u.uint32 = (aData.m_fWritable ? SHFL_ADD_MAPPING_F_WRITABLE : 0)
7429	\| (aData.m_fAutoMount ? SHFL_ADD_MAPPING_F_AUTOMOUNT : 0)
7430	\| (fSymlinksCreate ? SHFL_ADD_MAPPING_F_CREATE_SYMLINKS : 0)
7431	\| (fMissing ? SHFL_ADD_MAPPING_F_MISSING : 0)
7432	;
7433
7434	vrc = m_pVMMDev->hgcmHostCall("VBoxSharedFolders",
7435	SHFL_FN_ADD_MAPPING,
7436	SHFL_CPARMS_ADD_MAPPING, &parms[0]);
7437	RTMemFree(pFolderName);
7438	RTMemFree(pMapName);
7439
7440	if (RT_FAILURE(vrc))
7441	return setError(E_FAIL,
7442	tr("Could not create a shared folder '%s' mapped to '%s' (%Rrc)"),
7443	strName.c_str(), aData.m_strHostPath.c_str(), vrc);
7444
7445	if (fMissing)
7446	return setError(E_INVALIDARG,
7447	tr("Shared folder path '%s' does not exist on the host"),
7448	aData.m_strHostPath.c_str());
7449
7450	return S_OK;
7451	}
7452
7453	/**
7454	* Calls the HGCM service to remove the shared folder definition.
7455	*
7456	* @param aName Shared folder name.
7457	*
7458	* @note Must be called from under AutoVMCaller and when mpUVM != NULL!
7459	* @note Doesn't lock anything.
7460	*/
7461	HRESULT Console::removeSharedFolder(const Utf8Str &strName)
7462	{
7463	ComAssertRet(strName.isNotEmpty(), E_FAIL);
7464
7465	/* sanity checks */
7466	AssertReturn(mpUVM, E_FAIL);
7467	AssertReturn(m_pVMMDev && m_pVMMDev->isShFlActive(), E_FAIL);
7468
7469	VBOXHGCMSVCPARM parms;
7470	SHFLSTRING *pMapName;
7471	size_t cbString;
7472
7473	Log(("Removing shared folder '%s'\n", strName.c_str()));
7474
7475	Bstr bstrName(strName);
7476	cbString = (bstrName.length() + 1) * sizeof(RTUTF16);
7477	if (cbString >= UINT16_MAX)
7478	return setError(E_INVALIDARG, tr("The name is too long"));
7479	pMapName = (SHFLSTRING *) RTMemAllocZ(sizeof(SHFLSTRING) + cbString);
7480	Assert(pMapName);
7481	memcpy(pMapName->String.ucs2, bstrName.raw(), cbString);
7482
7483	pMapName->u16Size = (uint16_t)cbString;
7484	pMapName->u16Length = (uint16_t)cbString - sizeof(RTUTF16);
7485
7486	parms.type = VBOX_HGCM_SVC_PARM_PTR;
7487	parms.u.pointer.addr = pMapName;
7488	parms.u.pointer.size = sizeof(SHFLSTRING) + (uint16_t)cbString;
7489
7490	int vrc = m_pVMMDev->hgcmHostCall("VBoxSharedFolders",
7491	SHFL_FN_REMOVE_MAPPING,
7492	1, &parms);
7493	RTMemFree(pMapName);
7494	if (RT_FAILURE(vrc))
7495	return setError(E_FAIL,
7496	tr("Could not remove the shared folder '%s' (%Rrc)"),
7497	strName.c_str(), vrc);
7498
7499	return S_OK;
7500	}
7501
7502	/** @callback_method_impl{FNVMATSTATE}
7503	*
7504	* @note Locks the Console object for writing.
7505	* @remarks The @a pUVM parameter can be NULL in one case where powerUpThread()
7506	* calls after the VM was destroyed.
7507	*/
7508	DECLCALLBACK(void) Console::vmstateChangeCallback(PUVM pUVM, VMSTATE enmState, VMSTATE enmOldState, void *pvUser)
7509	{
7510	LogFlowFunc(("Changing state from %s to %s (pUVM=%p)\n",
7511	VMR3GetStateName(enmOldState), VMR3GetStateName(enmState), pUVM));
7512
7513	Console that = static_cast<Console >(pvUser);
7514	AssertReturnVoid(that);
7515
7516	AutoCaller autoCaller(that);
7517
7518	/* Note that we must let this method proceed even if Console::uninit() has
7519	* been already called. In such case this VMSTATE change is a result of:
7520	* 1) powerDown() called from uninit() itself, or
7521	* 2) VM-(guest-)initiated power off. */
7522	AssertReturnVoid( autoCaller.isOk()
7523	\|\| autoCaller.state() == InUninit);
7524
7525	switch (enmState)
7526	{
7527	/*
7528	* The VM has terminated
7529	*/
7530	case VMSTATE_OFF:
7531	{
7532	AutoWriteLock alock(that COMMA_LOCKVAL_SRC_POS);
7533
7534	if (that->mVMStateChangeCallbackDisabled)
7535	break;
7536
7537	/* Do we still think that it is running? It may happen if this is a
7538	* VM-(guest-)initiated shutdown/poweroff.
7539	*/
7540	if ( that->mMachineState != MachineState_Stopping
7541	&& that->mMachineState != MachineState_Saving
7542	&& that->mMachineState != MachineState_Restoring
7543	&& that->mMachineState != MachineState_TeleportingIn
7544	&& that->mMachineState != MachineState_FaultTolerantSyncing
7545	&& that->mMachineState != MachineState_TeleportingPausedVM
7546	&& !that->mVMIsAlreadyPoweringOff
7547	)
7548	{
7549	LogFlowFunc(("VM has powered itself off but Console still thinks it is running. Notifying.\n"));
7550
7551	/* prevent powerDown() from calling VMR3PowerOff() again */
7552	Assert(that->mVMPoweredOff == false);
7553	that->mVMPoweredOff = true;
7554
7555	/*
7556	* request a progress object from the server
7557	* (this will set the machine state to Stopping on the server
7558	* to block others from accessing this machine)
7559	*/
7560	ComPtr<IProgress> pProgress;
7561	HRESULT rc = that->mControl->BeginPoweringDown(pProgress.asOutParam());
7562	AssertComRC(rc);
7563
7564	/* sync the state with the server */
7565	that->setMachineStateLocally(MachineState_Stopping);
7566
7567	/* Setup task object and thread to carry out the operation
7568	* asynchronously (if we call powerDown() right here but there
7569	* is one or more mpUVM callers (added with addVMCaller()) we'll
7570	* deadlock).
7571	*/
7572	std::auto_ptr<VMPowerDownTask> task(new VMPowerDownTask(that, pProgress));
7573
7574	/* If creating a task failed, this can currently mean one of
7575	* two: either Console::uninit() has been called just a ms
7576	* before (so a powerDown() call is already on the way), or
7577	* powerDown() itself is being already executed. Just do
7578	* nothing.
7579	*/
7580	if (!task->isOk())
7581	{
7582	LogFlowFunc(("Console is already being uninitialized.\n"));
7583	break;
7584	}
7585
7586	int vrc = RTThreadCreate(NULL, Console::powerDownThread,
7587	(void *)task.get(), 0,
7588	RTTHREADTYPE_MAIN_WORKER, 0,
7589	"VMPwrDwn");
7590	AssertMsgRCBreak(vrc, ("Could not create VMPowerDown thread (%Rrc)\n", vrc));
7591
7592	/* task is now owned by powerDownThread(), so release it */
7593	task.release();
7594	}
7595	break;
7596	}
7597
7598	/* The VM has been completely destroyed.
7599	*
7600	* Note: This state change can happen at two points:
7601	* 1) At the end of VMR3Destroy() if it was not called from EMT.
7602	* 2) At the end of vmR3EmulationThread if VMR3Destroy() was
7603	* called by EMT.
7604	*/
7605	case VMSTATE_TERMINATED:
7606	{
7607	AutoWriteLock alock(that COMMA_LOCKVAL_SRC_POS);
7608
7609	if (that->mVMStateChangeCallbackDisabled)
7610	break;
7611
7612	/* Terminate host interface networking. If pUVM is NULL, we've been
7613	* manually called from powerUpThread() either before calling
7614	* VMR3Create() or after VMR3Create() failed, so no need to touch
7615	* networking.
7616	*/
7617	if (pUVM)
7618	that->powerDownHostInterfaces();
7619
7620	/* From now on the machine is officially powered down or remains in
7621	* the Saved state.
7622	*/
7623	switch (that->mMachineState)
7624	{
7625	default:
7626	AssertFailed();
7627	/* fall through */
7628	case MachineState_Stopping:
7629	/* successfully powered down */
7630	that->setMachineState(MachineState_PoweredOff);
7631	break;
7632	case MachineState_Saving:
7633	/* successfully saved */
7634	that->setMachineState(MachineState_Saved);
7635	break;
7636	case MachineState_Starting:
7637	/* failed to start, but be patient: set back to PoweredOff
7638	* (for similarity with the below) */
7639	that->setMachineState(MachineState_PoweredOff);
7640	break;
7641	case MachineState_Restoring:
7642	/* failed to load the saved state file, but be patient: set
7643	* back to Saved (to preserve the saved state file) */
7644	that->setMachineState(MachineState_Saved);
7645	break;
7646	case MachineState_TeleportingIn:
7647	/* Teleportation failed or was canceled. Back to powered off. */
7648	that->setMachineState(MachineState_PoweredOff);
7649	break;
7650	case MachineState_TeleportingPausedVM:
7651	/* Successfully teleported the VM. */
7652	that->setMachineState(MachineState_Teleported);
7653	break;
7654	case MachineState_FaultTolerantSyncing:
7655	/* Fault tolerant sync failed or was canceled. Back to powered off. */
7656	that->setMachineState(MachineState_PoweredOff);
7657	break;
7658	}
7659	break;
7660	}
7661
7662	case VMSTATE_RESETTING:
7663	{
7664	#ifdef VBOX_WITH_GUEST_PROPS
7665	/* Do not take any read/write locks here! */
7666	that->guestPropertiesHandleVMReset();
7667	#endif
7668	break;
7669	}
7670
7671	case VMSTATE_SUSPENDED:
7672	{
7673	AutoWriteLock alock(that COMMA_LOCKVAL_SRC_POS);
7674
7675	if (that->mVMStateChangeCallbackDisabled)
7676	break;
7677
7678	switch (that->mMachineState)
7679	{
7680	case MachineState_Teleporting:
7681	that->setMachineState(MachineState_TeleportingPausedVM);
7682	break;
7683
7684	case MachineState_LiveSnapshotting:
7685	that->setMachineState(MachineState_Saving);
7686	break;
7687
7688	case MachineState_TeleportingPausedVM:
7689	case MachineState_Saving:
7690	case MachineState_Restoring:
7691	case MachineState_Stopping:
7692	case MachineState_TeleportingIn:
7693	case MachineState_FaultTolerantSyncing:
7694	/* The worker thread handles the transition. */
7695	break;
7696
7697	default:
7698	AssertMsgFailed(("%s\n", Global::stringifyMachineState(that->mMachineState)));
7699	case MachineState_Running:
7700	that->setMachineState(MachineState_Paused);
7701	break;
7702
7703	case MachineState_Paused:
7704	/* Nothing to do. */
7705	break;
7706	}
7707	break;
7708	}
7709
7710	case VMSTATE_SUSPENDED_LS:
7711	case VMSTATE_SUSPENDED_EXT_LS:
7712	{
7713	AutoWriteLock alock(that COMMA_LOCKVAL_SRC_POS);
7714	if (that->mVMStateChangeCallbackDisabled)
7715	break;
7716	switch (that->mMachineState)
7717	{
7718	case MachineState_Teleporting:
7719	that->setMachineState(MachineState_TeleportingPausedVM);
7720	break;
7721
7722	case MachineState_LiveSnapshotting:
7723	that->setMachineState(MachineState_Saving);
7724	break;
7725
7726	case MachineState_TeleportingPausedVM:
7727	case MachineState_Saving:
7728	/* ignore */
7729	break;
7730
7731	default:
7732	AssertMsgFailed(("%s/%s -> %s\n", Global::stringifyMachineState(that->mMachineState), VMR3GetStateName(enmOldState), VMR3GetStateName(enmState) ));
7733	that->setMachineState(MachineState_Paused);
7734	break;
7735	}
7736	break;
7737	}
7738
7739	case VMSTATE_RUNNING:
7740	{
7741	if ( enmOldState == VMSTATE_POWERING_ON
7742	\|\| enmOldState == VMSTATE_RESUMING
7743	\|\| enmOldState == VMSTATE_RUNNING_FT)
7744	{
7745	AutoWriteLock alock(that COMMA_LOCKVAL_SRC_POS);
7746
7747	if (that->mVMStateChangeCallbackDisabled)
7748	break;
7749
7750	Assert( ( ( that->mMachineState == MachineState_Starting
7751	\|\| that->mMachineState == MachineState_Paused)
7752	&& enmOldState == VMSTATE_POWERING_ON)
7753	\|\| ( ( that->mMachineState == MachineState_Restoring
7754	\|\| that->mMachineState == MachineState_TeleportingIn
7755	\|\| that->mMachineState == MachineState_Paused
7756	\|\| that->mMachineState == MachineState_Saving
7757	)
7758	&& enmOldState == VMSTATE_RESUMING)
7759	\|\| ( that->mMachineState == MachineState_FaultTolerantSyncing
7760	&& enmOldState == VMSTATE_RUNNING_FT));
7761
7762	that->setMachineState(MachineState_Running);
7763	}
7764
7765	break;
7766	}
7767
7768	case VMSTATE_RUNNING_LS:
7769	AssertMsg( that->mMachineState == MachineState_LiveSnapshotting
7770	\|\| that->mMachineState == MachineState_Teleporting,
7771	("%s/%s -> %s\n", Global::stringifyMachineState(that->mMachineState), VMR3GetStateName(enmOldState), VMR3GetStateName(enmState) ));
7772	break;
7773
7774	case VMSTATE_RUNNING_FT:
7775	AssertMsg(that->mMachineState == MachineState_FaultTolerantSyncing,
7776	("%s/%s -> %s\n", Global::stringifyMachineState(that->mMachineState), VMR3GetStateName(enmOldState), VMR3GetStateName(enmState) ));
7777	break;
7778
7779	case VMSTATE_FATAL_ERROR:
7780	{
7781	AutoWriteLock alock(that COMMA_LOCKVAL_SRC_POS);
7782
7783	if (that->mVMStateChangeCallbackDisabled)
7784	break;
7785
7786	/* Fatal errors are only for running VMs. */
7787	Assert(Global::IsOnline(that->mMachineState));
7788
7789	/* Note! 'Pause' is used here in want of something better. There
7790	* are currently only two places where fatal errors might be
7791	* raised, so it is not worth adding a new externally
7792	* visible state for this yet. */
7793	that->setMachineState(MachineState_Paused);
7794	break;
7795	}
7796
7797	case VMSTATE_GURU_MEDITATION:
7798	{
7799	AutoWriteLock alock(that COMMA_LOCKVAL_SRC_POS);
7800
7801	if (that->mVMStateChangeCallbackDisabled)
7802	break;
7803
7804	/* Guru are only for running VMs */
7805	Assert(Global::IsOnline(that->mMachineState));
7806
7807	that->setMachineState(MachineState_Stuck);
7808	break;
7809	}
7810
7811	default: /* shut up gcc */
7812	break;
7813	}
7814	}
7815
7816	/**
7817	* Changes the clipboard mode.
7818	*
7819	* @param aClipboardMode new clipboard mode.
7820	*/
7821	void Console::changeClipboardMode(ClipboardMode_T aClipboardMode)
7822	{
7823	VMMDev *pVMMDev = m_pVMMDev;
7824	Assert(pVMMDev);
7825
7826	VBOXHGCMSVCPARM parm;
7827	parm.type = VBOX_HGCM_SVC_PARM_32BIT;
7828
7829	switch (aClipboardMode)
7830	{
7831	default:
7832	case ClipboardMode_Disabled:
7833	LogRel(("Shared clipboard mode: Off\n"));
7834	parm.u.uint32 = VBOX_SHARED_CLIPBOARD_MODE_OFF;
7835	break;
7836	case ClipboardMode_GuestToHost:
7837	LogRel(("Shared clipboard mode: Guest to Host\n"));
7838	parm.u.uint32 = VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST;
7839	break;
7840	case ClipboardMode_HostToGuest:
7841	LogRel(("Shared clipboard mode: Host to Guest\n"));
7842	parm.u.uint32 = VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST;
7843	break;
7844	case ClipboardMode_Bidirectional:
7845	LogRel(("Shared clipboard mode: Bidirectional\n"));
7846	parm.u.uint32 = VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL;
7847	break;
7848	}
7849
7850	pVMMDev->hgcmHostCall("VBoxSharedClipboard", VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE, 1, &parm);
7851	}
7852
7853	/**
7854	* Changes the drag'n_drop mode.
7855	*
7856	* @param aDragAndDropMode new drag'n'drop mode.
7857	*/
7858	void Console::changeDragAndDropMode(DragAndDropMode_T aDragAndDropMode)
7859	{
7860	VMMDev *pVMMDev = m_pVMMDev;
7861	Assert(pVMMDev);
7862
7863	VBOXHGCMSVCPARM parm;
7864	parm.type = VBOX_HGCM_SVC_PARM_32BIT;
7865
7866	switch (aDragAndDropMode)
7867	{
7868	default:
7869	case DragAndDropMode_Disabled:
7870	LogRel(("Drag'n'drop mode: Off\n"));
7871	parm.u.uint32 = VBOX_DRAG_AND_DROP_MODE_OFF;
7872	break;
7873	case DragAndDropMode_GuestToHost:
7874	LogRel(("Drag'n'drop mode: Guest to Host\n"));
7875	parm.u.uint32 = VBOX_DRAG_AND_DROP_MODE_GUEST_TO_HOST;
7876	break;
7877	case DragAndDropMode_HostToGuest:
7878	LogRel(("Drag'n'drop mode: Host to Guest\n"));
7879	parm.u.uint32 = VBOX_DRAG_AND_DROP_MODE_HOST_TO_GUEST;
7880	break;
7881	case DragAndDropMode_Bidirectional:
7882	LogRel(("Drag'n'drop mode: Bidirectional\n"));
7883	parm.u.uint32 = VBOX_DRAG_AND_DROP_MODE_BIDIRECTIONAL;
7884	break;
7885	}
7886
7887	pVMMDev->hgcmHostCall("VBoxDragAndDropSvc", DragAndDropSvc::HOST_DND_SET_MODE, 1, &parm);
7888	}
7889
7890	#ifdef VBOX_WITH_USB
7891	/**
7892	* Sends a request to VMM to attach the given host device.
7893	* After this method succeeds, the attached device will appear in the
7894	* mUSBDevices collection.
7895	*
7896	* @param aHostDevice device to attach
7897	*
7898	* @note Synchronously calls EMT.
7899	*/
7900	HRESULT Console::attachUSBDevice(IUSBDevice *aHostDevice, ULONG aMaskedIfs)
7901	{
7902	AssertReturn(aHostDevice, E_FAIL);
7903	AssertReturn(!isWriteLockOnCurrentThread(), E_FAIL);
7904
7905	HRESULT hrc;
7906
7907	/*
7908	* Get the address and the Uuid, and call the pfnCreateProxyDevice roothub
7909	* method in EMT (using usbAttachCallback()).
7910	*/
7911	Bstr BstrAddress;
7912	hrc = aHostDevice->COMGETTER(Address)(BstrAddress.asOutParam());
7913	ComAssertComRCRetRC(hrc);
7914
7915	Utf8Str Address(BstrAddress);
7916
7917	Bstr id;
7918	hrc = aHostDevice->COMGETTER(Id)(id.asOutParam());
7919	ComAssertComRCRetRC(hrc);
7920	Guid uuid(id);
7921
7922	BOOL fRemote = FALSE;
7923	hrc = aHostDevice->COMGETTER(Remote)(&fRemote);
7924	ComAssertComRCRetRC(hrc);
7925
7926	/* Get the VM handle. */
7927	SafeVMPtr ptrVM(this);
7928	if (!ptrVM.isOk())
7929	return ptrVM.rc();
7930
7931	LogFlowThisFunc(("Proxying USB device '%s' {%RTuuid}...\n",
7932	Address.c_str(), uuid.raw()));
7933
7934	void *pvRemoteBackend = NULL;
7935	if (fRemote)
7936	{
7937	RemoteUSBDevice pRemoteUSBDevice = static_cast<RemoteUSBDevice >(aHostDevice);
7938	pvRemoteBackend = consoleVRDPServer()->USBBackendRequestPointer(pRemoteUSBDevice->clientId(), &uuid);
7939	if (!pvRemoteBackend)
7940	return E_INVALIDARG; /* The clientId is invalid then. */
7941	}
7942
7943	USHORT portVersion = 1;
7944	hrc = aHostDevice->COMGETTER(PortVersion)(&portVersion);
7945	AssertComRCReturnRC(hrc);
7946	Assert(portVersion == 1 \|\| portVersion == 2);
7947
7948	int vrc = VMR3ReqCallWaitU(ptrVM.rawUVM(), 0 /* idDstCpu (saved state, see #6232) */,
7949	(PFNRT)usbAttachCallback, 9,
7950	this, ptrVM.rawUVM(), aHostDevice, uuid.raw(), fRemote,
7951	Address.c_str(), pvRemoteBackend, portVersion, aMaskedIfs);
7952
7953	if (RT_SUCCESS(vrc))
7954	{
7955	/* Create a OUSBDevice and add it to the device list */
7956	ComObjPtr<OUSBDevice> pUSBDevice;
7957	pUSBDevice.createObject();
7958	hrc = pUSBDevice->init(aHostDevice);
7959	AssertComRC(hrc);
7960
7961	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7962	mUSBDevices.push_back(pUSBDevice);
7963	LogFlowFunc(("Attached device {%RTuuid}\n", pUSBDevice->id().raw()));
7964
7965	/* notify callbacks */
7966	alock.release();
7967	onUSBDeviceStateChange(pUSBDevice, true /* aAttached */, NULL);
7968	}
7969	else
7970	{
7971	LogWarningThisFunc(("Failed to create proxy device for '%s' {%RTuuid} (%Rrc)\n",
7972	Address.c_str(), uuid.raw(), vrc));
7973
7974	switch (vrc)
7975	{
7976	case VERR_VUSB_NO_PORTS:
7977	hrc = setError(E_FAIL, tr("Failed to attach the USB device. (No available ports on the USB controller)."));
7978	break;
7979	case VERR_VUSB_USBFS_PERMISSION:
7980	hrc = setError(E_FAIL, tr("Not permitted to open the USB device, check usbfs options"));
7981	break;
7982	default:
7983	hrc = setError(E_FAIL, tr("Failed to create a proxy device for the USB device. (Error: %Rrc)"), vrc);
7984	break;
7985	}
7986	}
7987
7988	return hrc;
7989	}
7990
7991	/**
7992	* USB device attach callback used by AttachUSBDevice().
7993	* Note that AttachUSBDevice() doesn't return until this callback is executed,
7994	* so we don't use AutoCaller and don't care about reference counters of
7995	* interface pointers passed in.
7996	*
7997	* @thread EMT
7998	* @note Locks the console object for writing.
7999	*/
8000	//static
8001	DECLCALLBACK(int)
8002	Console::usbAttachCallback(Console that, PUVM pUVM, IUSBDevice aHostDevice, PCRTUUID aUuid, bool aRemote,
8003	const char aAddress, void pvRemoteBackend, USHORT aPortVersion, ULONG aMaskedIfs)
8004	{
8005	LogFlowFuncEnter();
8006	LogFlowFunc(("that={%p} aUuid={%RTuuid}\n", that, aUuid));
8007
8008	AssertReturn(that && aUuid, VERR_INVALID_PARAMETER);
8009	AssertReturn(!that->isWriteLockOnCurrentThread(), VERR_GENERAL_FAILURE);
8010
8011	int vrc = PDMR3UsbCreateProxyDevice(pUVM, aUuid, aRemote, aAddress, pvRemoteBackend,
8012	aPortVersion == 1 ? VUSB_STDVER_11 : VUSB_STDVER_20, aMaskedIfs);
8013	LogFlowFunc(("vrc=%Rrc\n", vrc));
8014	LogFlowFuncLeave();
8015	return vrc;
8016	}
8017
8018	/**
8019	* Sends a request to VMM to detach the given host device. After this method
8020	* succeeds, the detached device will disappear from the mUSBDevices
8021	* collection.
8022	*
8023	* @param aHostDevice device to attach
8024	*
8025	* @note Synchronously calls EMT.
8026	*/
8027	HRESULT Console::detachUSBDevice(const ComObjPtr<OUSBDevice> &aHostDevice)
8028	{
8029	AssertReturn(!isWriteLockOnCurrentThread(), E_FAIL);
8030
8031	/* Get the VM handle. */
8032	SafeVMPtr ptrVM(this);
8033	if (!ptrVM.isOk())
8034	return ptrVM.rc();
8035
8036	/* if the device is attached, then there must at least one USB hub. */
8037	AssertReturn(PDMR3UsbHasHub(ptrVM.rawUVM()), E_FAIL);
8038
8039	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
8040	LogFlowThisFunc(("Detaching USB proxy device {%RTuuid}...\n",
8041	aHostDevice->id().raw()));
8042
8043	/*
8044	* If this was a remote device, release the backend pointer.
8045	* The pointer was requested in usbAttachCallback.
8046	*/
8047	BOOL fRemote = FALSE;
8048
8049	HRESULT hrc2 = aHostDevice->COMGETTER(Remote)(&fRemote);
8050	if (FAILED(hrc2))
8051	setErrorStatic(hrc2, "GetRemote() failed");
8052
8053	PCRTUUID pUuid = aHostDevice->id().raw();
8054	if (fRemote)
8055	{
8056	Guid guid(*pUuid);
8057	consoleVRDPServer()->USBBackendReleasePointer(&guid);
8058	}
8059
8060	alock.release();
8061	int vrc = VMR3ReqCallWaitU(ptrVM.rawUVM(), 0 /* idDstCpu (saved state, see #6232) */,
8062	(PFNRT)usbDetachCallback, 5,
8063	this, ptrVM.rawUVM(), pUuid);
8064	if (RT_SUCCESS(vrc))
8065	{
8066	LogFlowFunc(("Detached device {%RTuuid}\n", pUuid));
8067
8068	/* notify callbacks */
8069	onUSBDeviceStateChange(aHostDevice, false /* aAttached */, NULL);
8070	}
8071
8072	ComAssertRCRet(vrc, E_FAIL);
8073
8074	return S_OK;
8075	}
8076
8077	/**
8078	* USB device detach callback used by DetachUSBDevice().
8079	*
8080	* Note that DetachUSBDevice() doesn't return until this callback is executed,
8081	* so we don't use AutoCaller and don't care about reference counters of
8082	* interface pointers passed in.
8083	*
8084	* @thread EMT
8085	*/
8086	//static
8087	DECLCALLBACK(int)
8088	Console::usbDetachCallback(Console *that, PUVM pUVM, PCRTUUID aUuid)
8089	{
8090	LogFlowFuncEnter();
8091	LogFlowFunc(("that={%p} aUuid={%RTuuid}\n", that, aUuid));
8092
8093	AssertReturn(that && aUuid, VERR_INVALID_PARAMETER);
8094	AssertReturn(!that->isWriteLockOnCurrentThread(), VERR_GENERAL_FAILURE);
8095
8096	int vrc = PDMR3UsbDetachDevice(pUVM, aUuid);
8097
8098	LogFlowFunc(("vrc=%Rrc\n", vrc));
8099	LogFlowFuncLeave();
8100	return vrc;
8101	}
8102	#endif /* VBOX_WITH_USB */
8103
8104	/* Note: FreeBSD needs this whether netflt is used or not. */
8105	#if ((defined(RT_OS_LINUX) && !defined(VBOX_WITH_NETFLT)) \|\| defined(RT_OS_FREEBSD))
8106	/**
8107	* Helper function to handle host interface device creation and attachment.
8108	*
8109	* @param networkAdapter the network adapter which attachment should be reset
8110	* @return COM status code
8111	*
8112	* @note The caller must lock this object for writing.
8113	*
8114	* @todo Move this back into the driver!
8115	*/
8116	HRESULT Console::attachToTapInterface(INetworkAdapter *networkAdapter)
8117	{
8118	LogFlowThisFunc(("\n"));
8119	/* sanity check */
8120	AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
8121
8122	# ifdef VBOX_STRICT
8123	/* paranoia */
8124	NetworkAttachmentType_T attachment;
8125	networkAdapter->COMGETTER(AttachmentType)(&attachment);
8126	Assert(attachment == NetworkAttachmentType_Bridged);
8127	# endif /* VBOX_STRICT */
8128
8129	HRESULT rc = S_OK;
8130
8131	ULONG slot = 0;
8132	rc = networkAdapter->COMGETTER(Slot)(&slot);
8133	AssertComRC(rc);
8134
8135	# ifdef RT_OS_LINUX
8136	/*
8137	* Allocate a host interface device
8138	*/
8139	int rcVBox = RTFileOpen(&maTapFD[slot], "/dev/net/tun",
8140	RTFILE_O_READWRITE \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE \| RTFILE_O_INHERIT);
8141	if (RT_SUCCESS(rcVBox))
8142	{
8143	/*
8144	* Set/obtain the tap interface.
8145	*/
8146	struct ifreq IfReq;
8147	memset(&IfReq, 0, sizeof(IfReq));
8148	/* The name of the TAP interface we are using */
8149	Bstr tapDeviceName;
8150	rc = networkAdapter->COMGETTER(BridgedInterface)(tapDeviceName.asOutParam());
8151	if (FAILED(rc))
8152	tapDeviceName.setNull(); /* Is this necessary? */
8153	if (tapDeviceName.isEmpty())
8154	{
8155	LogRel(("No TAP device name was supplied.\n"));
8156	rc = setError(E_FAIL, tr("No TAP device name was supplied for the host networking interface"));
8157	}
8158
8159	if (SUCCEEDED(rc))
8160	{
8161	/* If we are using a static TAP device then try to open it. */
8162	Utf8Str str(tapDeviceName);
8163	if (str.length() <= sizeof(IfReq.ifr_name))
8164	strcpy(IfReq.ifr_name, str.c_str());
8165	else
8166	memcpy(IfReq.ifr_name, str.c_str(), sizeof(IfReq.ifr_name) - 1); /** @todo bitch about names which are too long... */
8167	IfReq.ifr_flags = IFF_TAP \| IFF_NO_PI;
8168	rcVBox = ioctl(maTapFD[slot], TUNSETIFF, &IfReq);
8169	if (rcVBox != 0)
8170	{
8171	LogRel(("Failed to open the host network interface %ls\n", tapDeviceName.raw()));
8172	rc = setError(E_FAIL,
8173	tr("Failed to open the host network interface %ls"),
8174	tapDeviceName.raw());
8175	}
8176	}
8177	if (SUCCEEDED(rc))
8178	{
8179	/*
8180	* Make it pollable.
8181	*/
8182	if (fcntl(maTapFD[slot], F_SETFL, O_NONBLOCK) != -1)
8183	{
8184	Log(("attachToTapInterface: %RTfile %ls\n", maTapFD[slot], tapDeviceName.raw()));
8185	/*
8186	* Here is the right place to communicate the TAP file descriptor and
8187	* the host interface name to the server if/when it becomes really
8188	* necessary.
8189	*/
8190	maTAPDeviceName[slot] = tapDeviceName;
8191	rcVBox = VINF_SUCCESS;
8192	}
8193	else
8194	{
8195	int iErr = errno;
8196
8197	LogRel(("Configuration error: Failed to configure /dev/net/tun non blocking. Error: %s\n", strerror(iErr)));
8198	rcVBox = VERR_HOSTIF_BLOCKING;
8199	rc = setError(E_FAIL,
8200	tr("could not set up the host networking device for non blocking access: %s"),
8201	strerror(errno));
8202	}
8203	}
8204	}
8205	else
8206	{
8207	LogRel(("Configuration error: Failed to open /dev/net/tun rc=%Rrc\n", rcVBox));
8208	switch (rcVBox)
8209	{
8210	case VERR_ACCESS_DENIED:
8211	/* will be handled by our caller */
8212	rc = rcVBox;
8213	break;
8214	default:
8215	rc = setError(E_FAIL,
8216	tr("Could not set up the host networking device: %Rrc"),
8217	rcVBox);
8218	break;
8219	}
8220	}
8221
8222	# elif defined(RT_OS_FREEBSD)
8223	/*
8224	* Set/obtain the tap interface.
8225	*/
8226	/* The name of the TAP interface we are using */
8227	Bstr tapDeviceName;
8228	rc = networkAdapter->COMGETTER(BridgedInterface)(tapDeviceName.asOutParam());
8229	if (FAILED(rc))
8230	tapDeviceName.setNull(); /* Is this necessary? */
8231	if (tapDeviceName.isEmpty())
8232	{
8233	LogRel(("No TAP device name was supplied.\n"));
8234	rc = setError(E_FAIL, tr("No TAP device name was supplied for the host networking interface"));
8235	}
8236	char szTapdev[1024] = "/dev/";
8237	/* If we are using a static TAP device then try to open it. */
8238	Utf8Str str(tapDeviceName);
8239	if (str.length() + strlen(szTapdev) <= sizeof(szTapdev))
8240	strcat(szTapdev, str.c_str());
8241	else
8242	memcpy(szTapdev + strlen(szTapdev), str.c_str(),
8243	sizeof(szTapdev) - strlen(szTapdev) - 1); /** @todo bitch about names which are too long... */
8244	int rcVBox = RTFileOpen(&maTapFD[slot], szTapdev,
8245	RTFILE_O_READWRITE \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE \| RTFILE_O_INHERIT \| RTFILE_O_NON_BLOCK);
8246
8247	if (RT_SUCCESS(rcVBox))
8248	maTAPDeviceName[slot] = tapDeviceName;
8249	else
8250	{
8251	switch (rcVBox)
8252	{
8253	case VERR_ACCESS_DENIED:
8254	/* will be handled by our caller */
8255	rc = rcVBox;
8256	break;
8257	default:
8258	rc = setError(E_FAIL,
8259	tr("Failed to open the host network interface %ls"),
8260	tapDeviceName.raw());
8261	break;
8262	}
8263	}
8264	# else
8265	# error "huh?"
8266	# endif
8267	/* in case of failure, cleanup. */
8268	if (RT_FAILURE(rcVBox) && SUCCEEDED(rc))
8269	{
8270	LogRel(("General failure attaching to host interface\n"));
8271	rc = setError(E_FAIL,
8272	tr("General failure attaching to host interface"));
8273	}
8274	LogFlowThisFunc(("rc=%d\n", rc));
8275	return rc;
8276	}
8277
8278
8279	/**
8280	* Helper function to handle detachment from a host interface
8281	*
8282	* @param networkAdapter the network adapter which attachment should be reset
8283	* @return COM status code
8284	*
8285	* @note The caller must lock this object for writing.
8286	*
8287	* @todo Move this back into the driver!
8288	*/
8289	HRESULT Console::detachFromTapInterface(INetworkAdapter *networkAdapter)
8290	{
8291	/* sanity check */
8292	LogFlowThisFunc(("\n"));
8293	AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
8294
8295	HRESULT rc = S_OK;
8296	# ifdef VBOX_STRICT
8297	/* paranoia */
8298	NetworkAttachmentType_T attachment;
8299	networkAdapter->COMGETTER(AttachmentType)(&attachment);
8300	Assert(attachment == NetworkAttachmentType_Bridged);
8301	# endif /* VBOX_STRICT */
8302
8303	ULONG slot = 0;
8304	rc = networkAdapter->COMGETTER(Slot)(&slot);
8305	AssertComRC(rc);
8306
8307	/* is there an open TAP device? */
8308	if (maTapFD[slot] != NIL_RTFILE)
8309	{
8310	/*
8311	* Close the file handle.
8312	*/
8313	Bstr tapDeviceName, tapTerminateApplication;
8314	bool isStatic = true;
8315	rc = networkAdapter->COMGETTER(BridgedInterface)(tapDeviceName.asOutParam());
8316	if (FAILED(rc) \|\| tapDeviceName.isEmpty())
8317	{
8318	/* If the name is empty, this is a dynamic TAP device, so close it now,
8319	so that the termination script can remove the interface. Otherwise we still
8320	need the FD to pass to the termination script. */
8321	isStatic = false;
8322	int rcVBox = RTFileClose(maTapFD[slot]);
8323	AssertRC(rcVBox);
8324	maTapFD[slot] = NIL_RTFILE;
8325	}
8326	if (isStatic)
8327	{
8328	/* If we are using a static TAP device, we close it now, after having called the
8329	termination script. */
8330	int rcVBox = RTFileClose(maTapFD[slot]);
8331	AssertRC(rcVBox);
8332	}
8333	/* the TAP device name and handle are no longer valid */
8334	maTapFD[slot] = NIL_RTFILE;
8335	maTAPDeviceName[slot] = "";
8336	}
8337	LogFlowThisFunc(("returning %d\n", rc));
8338	return rc;
8339	}
8340	#endif /* (RT_OS_LINUX \|\| RT_OS_FREEBSD) && !VBOX_WITH_NETFLT */
8341
8342	/**
8343	* Called at power down to terminate host interface networking.
8344	*
8345	* @note The caller must lock this object for writing.
8346	*/
8347	HRESULT Console::powerDownHostInterfaces()
8348	{
8349	LogFlowThisFunc(("\n"));
8350
8351	/* sanity check */
8352	AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
8353
8354	/*
8355	* host interface termination handling
8356	*/
8357	HRESULT rc = S_OK;
8358	ComPtr<IVirtualBox> pVirtualBox;
8359	mMachine->COMGETTER(Parent)(pVirtualBox.asOutParam());
8360	ComPtr<ISystemProperties> pSystemProperties;
8361	if (pVirtualBox)
8362	pVirtualBox->COMGETTER(SystemProperties)(pSystemProperties.asOutParam());
8363	ChipsetType_T chipsetType = ChipsetType_PIIX3;
8364	mMachine->COMGETTER(ChipsetType)(&chipsetType);
8365	ULONG maxNetworkAdapters = 0;
8366	if (pSystemProperties)
8367	pSystemProperties->GetMaxNetworkAdapters(chipsetType, &maxNetworkAdapters);
8368
8369	for (ULONG slot = 0; slot < maxNetworkAdapters; slot++)
8370	{
8371	ComPtr<INetworkAdapter> pNetworkAdapter;
8372	rc = mMachine->GetNetworkAdapter(slot, pNetworkAdapter.asOutParam());
8373	if (FAILED(rc)) break;
8374
8375	BOOL enabled = FALSE;
8376	pNetworkAdapter->COMGETTER(Enabled)(&enabled);
8377	if (!enabled)
8378	continue;
8379
8380	NetworkAttachmentType_T attachment;
8381	pNetworkAdapter->COMGETTER(AttachmentType)(&attachment);
8382	if (attachment == NetworkAttachmentType_Bridged)
8383	{
8384	#if ((defined(RT_OS_LINUX) \|\| defined(RT_OS_FREEBSD)) && !defined(VBOX_WITH_NETFLT))
8385	HRESULT rc2 = detachFromTapInterface(pNetworkAdapter);
8386	if (FAILED(rc2) && SUCCEEDED(rc))
8387	rc = rc2;
8388	#endif /* (RT_OS_LINUX \|\| RT_OS_FREEBSD) && !VBOX_WITH_NETFLT */
8389	}
8390	}
8391
8392	return rc;
8393	}
8394
8395
8396	/**
8397	* Process callback handler for VMR3LoadFromFile, VMR3LoadFromStream, VMR3Save
8398	* and VMR3Teleport.
8399	*
8400	* @param pUVM The user mode VM handle.
8401	* @param uPercent Completion percentage (0-100).
8402	* @param pvUser Pointer to an IProgress instance.
8403	* @return VINF_SUCCESS.
8404	*/
8405	/static/
8406	DECLCALLBACK(int) Console::stateProgressCallback(PUVM pUVM, unsigned uPercent, void *pvUser)
8407	{
8408	IProgress pProgress = static_cast<IProgress >(pvUser);
8409
8410	/* update the progress object */
8411	if (pProgress)
8412	pProgress->SetCurrentOperationProgress(uPercent);
8413
8414	NOREF(pUVM);
8415	return VINF_SUCCESS;
8416	}
8417
8418	/**
8419	* @copydoc FNVMATERROR
8420	*
8421	* @remarks Might be some tiny serialization concerns with access to the string
8422	* object here...
8423	*/
8424	/static/ DECLCALLBACK(void)
8425	Console::genericVMSetErrorCallback(PUVM pUVM, void *pvUser, int rc, RT_SRC_POS_DECL,
8426	const char *pszErrorFmt, va_list va)
8427	{
8428	Utf8Str pErrorText = (Utf8Str )pvUser;
8429	AssertPtr(pErrorText);
8430
8431	/* We ignore RT_SRC_POS_DECL arguments to avoid confusion of end-users. */
8432	va_list va2;
8433	va_copy(va2, va);
8434
8435	/* Append to any the existing error message. */
8436	if (pErrorText->length())
8437	*pErrorText = Utf8StrFmt("%s.\n%N (%Rrc)", pErrorText->c_str(),
8438	pszErrorFmt, &va2, rc, rc);
8439	else
8440	*pErrorText = Utf8StrFmt("%N (%Rrc)", pszErrorFmt, &va2, rc, rc);
8441
8442	va_end(va2);
8443
8444	NOREF(pUVM);
8445	}
8446
8447	/**
8448	* VM runtime error callback function.
8449	* See VMSetRuntimeError for the detailed description of parameters.
8450	*
8451	* @param pUVM The user mode VM handle. Ignored, so passing NULL
8452	* is fine.
8453	* @param pvUser The user argument, pointer to the Console instance.
8454	* @param fFlags The action flags. See VMSETRTERR_FLAGS_*.
8455	* @param pszErrorId Error ID string.
8456	* @param pszFormat Error message format string.
8457	* @param va Error message arguments.
8458	* @thread EMT.
8459	*/
8460	/* static */ DECLCALLBACK(void)
8461	Console::setVMRuntimeErrorCallback(PUVM pUVM, void *pvUser, uint32_t fFlags,
8462	const char *pszErrorId,
8463	const char *pszFormat, va_list va)
8464	{
8465	bool const fFatal = !!(fFlags & VMSETRTERR_FLAGS_FATAL);
8466	LogFlowFuncEnter();
8467
8468	Console that = static_cast<Console >(pvUser);
8469	AssertReturnVoid(that);
8470
8471	Utf8Str message(pszFormat, va);
8472
8473	LogRel(("Console: VM runtime error: fatal=%RTbool, errorID=%s message=\"%s\"\n",
8474	fFatal, pszErrorId, message.c_str()));
8475
8476	that->onRuntimeError(BOOL(fFatal), Bstr(pszErrorId).raw(), Bstr(message).raw());
8477
8478	LogFlowFuncLeave(); NOREF(pUVM);
8479	}
8480
8481	/**
8482	* Captures USB devices that match filters of the VM.
8483	* Called at VM startup.
8484	*
8485	* @param pUVM The VM handle.
8486	*/
8487	HRESULT Console::captureUSBDevices(PUVM pUVM)
8488	{
8489	LogFlowThisFunc(("\n"));
8490
8491	/* sanity check */
8492	AssertReturn(!isWriteLockOnCurrentThread(), E_FAIL);
8493	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
8494
8495	/* If the machine has an USB controller, ask the USB proxy service to
8496	* capture devices */
8497	PPDMIBASE pBase;
8498	int vrc = PDMR3QueryLun(pUVM, "usb-ohci", 0, 0, &pBase);
8499	if (RT_SUCCESS(vrc))
8500	{
8501	/* release the lock before calling Host in VBoxSVC since Host may call
8502	* us back from under its lock (e.g. onUSBDeviceAttach()) which would
8503	* produce an inter-process dead-lock otherwise. */
8504	alock.release();
8505
8506	HRESULT hrc = mControl->AutoCaptureUSBDevices();
8507	ComAssertComRCRetRC(hrc);
8508	}
8509	else if ( vrc == VERR_PDM_DEVICE_NOT_FOUND
8510	\|\| vrc == VERR_PDM_DEVICE_INSTANCE_NOT_FOUND)
8511	vrc = VINF_SUCCESS;
8512	else
8513	AssertRC(vrc);
8514
8515	return RT_SUCCESS(vrc) ? S_OK : E_FAIL;
8516	}
8517
8518
8519	/**
8520	* Detach all USB device which are attached to the VM for the
8521	* purpose of clean up and such like.
8522	*/
8523	void Console::detachAllUSBDevices(bool aDone)
8524	{
8525	LogFlowThisFunc(("aDone=%RTbool\n", aDone));
8526
8527	/* sanity check */
8528	AssertReturnVoid(!isWriteLockOnCurrentThread());
8529	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
8530
8531	mUSBDevices.clear();
8532
8533	/* release the lock before calling Host in VBoxSVC since Host may call
8534	* us back from under its lock (e.g. onUSBDeviceAttach()) which would
8535	* produce an inter-process dead-lock otherwise. */
8536	alock.release();
8537
8538	mControl->DetachAllUSBDevices(aDone);
8539	}
8540
8541	/**
8542	* @note Locks this object for writing.
8543	*/
8544	void Console::processRemoteUSBDevices(uint32_t u32ClientId, VRDEUSBDEVICEDESC *pDevList, uint32_t cbDevList, bool fDescExt)
8545	{
8546	LogFlowThisFuncEnter();
8547	LogFlowThisFunc(("u32ClientId = %d, pDevList=%p, cbDevList = %d, fDescExt = %d\n", u32ClientId, pDevList, cbDevList, fDescExt));
8548
8549	AutoCaller autoCaller(this);
8550	if (!autoCaller.isOk())
8551	{
8552	/* Console has been already uninitialized, deny request */
8553	AssertMsgFailed(("Console is already uninitialized\n"));
8554	LogFlowThisFunc(("Console is already uninitialized\n"));
8555	LogFlowThisFuncLeave();
8556	return;
8557	}
8558
8559	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
8560
8561	/*
8562	* Mark all existing remote USB devices as dirty.
8563	*/
8564	for (RemoteUSBDeviceList::iterator it = mRemoteUSBDevices.begin();
8565	it != mRemoteUSBDevices.end();
8566	++it)
8567	{
8568	(*it)->dirty(true);
8569	}
8570
8571	/*
8572	* Process the pDevList and add devices those are not already in the mRemoteUSBDevices list.
8573	*/
8574	/** @todo (sunlover) REMOTE_USB Strict validation of the pDevList. */
8575	VRDEUSBDEVICEDESC *e = pDevList;
8576
8577	/* The cbDevList condition must be checked first, because the function can
8578	* receive pDevList = NULL and cbDevList = 0 on client disconnect.
8579	*/
8580	while (cbDevList >= 2 && e->oNext)
8581	{
8582	/* Sanitize incoming strings in case they aren't valid UTF-8. */
8583	if (e->oManufacturer)
8584	RTStrPurgeEncoding((char *)e + e->oManufacturer);
8585	if (e->oProduct)
8586	RTStrPurgeEncoding((char *)e + e->oProduct);
8587	if (e->oSerialNumber)
8588	RTStrPurgeEncoding((char *)e + e->oSerialNumber);
8589
8590	LogFlowThisFunc(("vendor %04X, product %04X, name = %s\n",
8591	e->idVendor, e->idProduct,
8592	e->oProduct? (char *)e + e->oProduct: ""));
8593
8594	bool fNewDevice = true;
8595
8596	for (RemoteUSBDeviceList::iterator it = mRemoteUSBDevices.begin();
8597	it != mRemoteUSBDevices.end();
8598	++it)
8599	{
8600	if ((*it)->devId() == e->id
8601	&& (*it)->clientId() == u32ClientId)
8602	{
8603	/* The device is already in the list. */
8604	(*it)->dirty(false);
8605	fNewDevice = false;
8606	break;
8607	}
8608	}
8609
8610	if (fNewDevice)
8611	{
8612	LogRel(("Remote USB: ++++ Vendor %04X. Product %04X. Name = [%s].\n",
8613	e->idVendor, e->idProduct, e->oProduct? (char *)e + e->oProduct: ""));
8614
8615	/* Create the device object and add the new device to list. */
8616	ComObjPtr<RemoteUSBDevice> pUSBDevice;
8617	pUSBDevice.createObject();
8618	pUSBDevice->init(u32ClientId, e, fDescExt);
8619
8620	mRemoteUSBDevices.push_back(pUSBDevice);
8621
8622	/* Check if the device is ok for current USB filters. */
8623	BOOL fMatched = FALSE;
8624	ULONG fMaskedIfs = 0;
8625
8626	HRESULT hrc = mControl->RunUSBDeviceFilters(pUSBDevice, &fMatched, &fMaskedIfs);
8627
8628	AssertComRC(hrc);
8629
8630	LogFlowThisFunc(("USB filters return %d %#x\n", fMatched, fMaskedIfs));
8631
8632	if (fMatched)
8633	{
8634	alock.release();
8635	hrc = onUSBDeviceAttach(pUSBDevice, NULL, fMaskedIfs);
8636	alock.acquire();
8637
8638	/// @todo (r=dmik) warning reporting subsystem
8639
8640	if (hrc == S_OK)
8641	{
8642	LogFlowThisFunc(("Device attached\n"));
8643	pUSBDevice->captured(true);
8644	}
8645	}
8646	}
8647
8648	if (cbDevList < e->oNext)
8649	{
8650	LogWarningThisFunc(("cbDevList %d > oNext %d\n",
8651	cbDevList, e->oNext));
8652	break;
8653	}
8654
8655	cbDevList -= e->oNext;
8656
8657	e = (VRDEUSBDEVICEDESC )((uint8_t )e + e->oNext);
8658	}
8659
8660	/*
8661	* Remove dirty devices, that is those which are not reported by the server anymore.
8662	*/
8663	for (;;)
8664	{
8665	ComObjPtr<RemoteUSBDevice> pUSBDevice;
8666
8667	RemoteUSBDeviceList::iterator it = mRemoteUSBDevices.begin();
8668	while (it != mRemoteUSBDevices.end())
8669	{
8670	if ((*it)->dirty())
8671	{
8672	pUSBDevice = *it;
8673	break;
8674	}
8675
8676	++it;
8677	}
8678
8679	if (!pUSBDevice)
8680	{
8681	break;
8682	}
8683
8684	USHORT vendorId = 0;
8685	pUSBDevice->COMGETTER(VendorId)(&vendorId);
8686
8687	USHORT productId = 0;
8688	pUSBDevice->COMGETTER(ProductId)(&productId);
8689
8690	Bstr product;
8691	pUSBDevice->COMGETTER(Product)(product.asOutParam());
8692
8693	LogRel(("Remote USB: ---- Vendor %04X. Product %04X. Name = [%ls].\n",
8694	vendorId, productId, product.raw()));
8695
8696	/* Detach the device from VM. */
8697	if (pUSBDevice->captured())
8698	{
8699	Bstr uuid;
8700	pUSBDevice->COMGETTER(Id)(uuid.asOutParam());
8701	alock.release();
8702	onUSBDeviceDetach(uuid.raw(), NULL);
8703	alock.acquire();
8704	}
8705
8706	/* And remove it from the list. */
8707	mRemoteUSBDevices.erase(it);
8708	}
8709
8710	LogFlowThisFuncLeave();
8711	}
8712
8713	/**
8714	* Progress cancelation callback for fault tolerance VM poweron
8715	*/
8716	static void faultToleranceProgressCancelCallback(void *pvUser)
8717	{
8718	PUVM pUVM = (PUVM)pvUser;
8719
8720	if (pUVM)
8721	FTMR3CancelStandby(pUVM);
8722	}
8723
8724	/**
8725	* Thread function which starts the VM (also from saved state) and
8726	* track progress.
8727	*
8728	* @param Thread The thread id.
8729	* @param pvUser Pointer to a VMPowerUpTask structure.
8730	* @return VINF_SUCCESS (ignored).
8731	*
8732	* @note Locks the Console object for writing.
8733	*/
8734	/static/
8735	DECLCALLBACK(int) Console::powerUpThread(RTTHREAD Thread, void *pvUser)
8736	{
8737	LogFlowFuncEnter();
8738
8739	std::auto_ptr<VMPowerUpTask> task(static_cast<VMPowerUpTask *>(pvUser));
8740	AssertReturn(task.get(), VERR_INVALID_PARAMETER);
8741
8742	AssertReturn(!task->mConsole.isNull(), VERR_INVALID_PARAMETER);
8743	AssertReturn(!task->mProgress.isNull(), VERR_INVALID_PARAMETER);
8744
8745	VirtualBoxBase::initializeComForThread();
8746
8747	HRESULT rc = S_OK;
8748	int vrc = VINF_SUCCESS;
8749
8750	/* Set up a build identifier so that it can be seen from core dumps what
8751	* exact build was used to produce the core. */
8752	static char saBuildID[40];
8753	RTStrPrintf(saBuildID, sizeof(saBuildID), "%s%s%s%s VirtualBox %s r%u %s%s%s%s",
8754	"BU", "IL", "DI", "D", RTBldCfgVersion(), RTBldCfgRevision(), "BU", "IL", "DI", "D");
8755
8756	ComObjPtr<Console> pConsole = task->mConsole;
8757
8758	/* Note: no need to use addCaller() because VMPowerUpTask does that */
8759
8760	/* The lock is also used as a signal from the task initiator (which
8761	* releases it only after RTThreadCreate()) that we can start the job */
8762	AutoWriteLock alock(pConsole COMMA_LOCKVAL_SRC_POS);
8763
8764	/* sanity */
8765	Assert(pConsole->mpUVM == NULL);
8766
8767	try
8768	{
8769	// Create the VMM device object, which starts the HGCM thread; do this only
8770	// once for the console, for the pathological case that the same console
8771	// object is used to power up a VM twice. VirtualBox 4.0: we now do that
8772	// here instead of the Console constructor (see Console::init())
8773	if (!pConsole->m_pVMMDev)
8774	{
8775	pConsole->m_pVMMDev = new VMMDev(pConsole);
8776	AssertReturn(pConsole->m_pVMMDev, E_FAIL);
8777	}
8778
8779	/* wait for auto reset ops to complete so that we can successfully lock
8780	* the attached hard disks by calling LockMedia() below */
8781	for (VMPowerUpTask::ProgressList::const_iterator
8782	it = task->hardDiskProgresses.begin();
8783	it != task->hardDiskProgresses.end(); ++it)
8784	{
8785	HRESULT rc2 = (*it)->WaitForCompletion(-1);
8786	AssertComRC(rc2);
8787
8788	rc = task->mProgress->SetNextOperation(BstrFmt(tr("Disk Image Reset Operation - Immutable Image")).raw(), 1);
8789	AssertComRCReturnRC(rc);
8790	}
8791
8792	/*
8793	* Lock attached media. This method will also check their accessibility.
8794	* If we're a teleporter, we'll have to postpone this action so we can
8795	* migrate between local processes.
8796	*
8797	* Note! The media will be unlocked automatically by
8798	* SessionMachine::setMachineState() when the VM is powered down.
8799	*/
8800	if ( !task->mTeleporterEnabled
8801	&& task->mEnmFaultToleranceState != FaultToleranceState_Standby)
8802	{
8803	rc = pConsole->mControl->LockMedia();
8804	if (FAILED(rc)) throw rc;
8805	}
8806
8807	/* Create the VRDP server. In case of headless operation, this will
8808	* also create the framebuffer, required at VM creation.
8809	*/
8810	ConsoleVRDPServer *server = pConsole->consoleVRDPServer();
8811	Assert(server);
8812
8813	/* Does VRDP server call Console from the other thread?
8814	* Not sure (and can change), so release the lock just in case.
8815	*/
8816	alock.release();
8817	vrc = server->Launch();
8818	alock.acquire();
8819
8820	if (vrc == VERR_NET_ADDRESS_IN_USE)
8821	{
8822	Utf8Str errMsg;
8823	Bstr bstr;
8824	pConsole->mVRDEServer->GetVRDEProperty(Bstr("TCP/Ports").raw(), bstr.asOutParam());
8825	Utf8Str ports = bstr;
8826	errMsg = Utf8StrFmt(tr("VirtualBox Remote Desktop Extension server can't bind to the port: %s"),
8827	ports.c_str());
8828	LogRel(("VRDE: Warning: failed to launch VRDE server (%Rrc): '%s'\n",
8829	vrc, errMsg.c_str()));
8830	}
8831	else if (vrc == VINF_NOT_SUPPORTED)
8832	{
8833	/* This means that the VRDE is not installed. */
8834	LogRel(("VRDE: VirtualBox Remote Desktop Extension is not available.\n"));
8835	}
8836	else if (RT_FAILURE(vrc))
8837	{
8838	/* Fail, if the server is installed but can't start. */
8839	Utf8Str errMsg;
8840	switch (vrc)
8841	{
8842	case VERR_FILE_NOT_FOUND:
8843	{
8844	/* VRDE library file is missing. */
8845	errMsg = Utf8StrFmt(tr("Could not find the VirtualBox Remote Desktop Extension library."));
8846	break;
8847	}
8848	default:
8849	errMsg = Utf8StrFmt(tr("Failed to launch Remote Desktop Extension server (%Rrc)"),
8850	vrc);
8851	}
8852	LogRel(("VRDE: Failed: (%Rrc), error message: '%s'\n",
8853	vrc, errMsg.c_str()));
8854	throw setErrorStatic(E_FAIL, errMsg.c_str());
8855	}
8856
8857	ComPtr<IMachine> pMachine = pConsole->machine();
8858	ULONG cCpus = 1;
8859	pMachine->COMGETTER(CPUCount)(&cCpus);
8860
8861	/*
8862	* Create the VM
8863	*
8864	* Note! Release the lock since EMT will call Console. It's safe because
8865	* mMachineState is either Starting or Restoring state here.
8866	*/
8867	alock.release();
8868
8869	PVM pVM;
8870	vrc = VMR3Create(cCpus,
8871	pConsole->mpVmm2UserMethods,
8872	Console::genericVMSetErrorCallback,
8873	&task->mErrorMsg,
8874	task->mConfigConstructor,
8875	static_cast<Console *>(pConsole),
8876	&pVM, NULL);
8877
8878	alock.acquire();
8879
8880	/* Enable client connections to the server. */
8881	pConsole->consoleVRDPServer()->EnableConnections();
8882
8883	if (RT_SUCCESS(vrc))
8884	{
8885	do
8886	{
8887	/*
8888	* Register our load/save state file handlers
8889	*/
8890	vrc = SSMR3RegisterExternal(pConsole->mpUVM, sSSMConsoleUnit, 0 /iInstance/, sSSMConsoleVer, 0 /* cbGuess */,
8891	NULL, NULL, NULL,
8892	NULL, saveStateFileExec, NULL,
8893	NULL, loadStateFileExec, NULL,
8894	static_cast<Console *>(pConsole));
8895	AssertRCBreak(vrc);
8896
8897	vrc = static_cast<Console *>(pConsole)->getDisplay()->registerSSM(pConsole->mpUVM);
8898	AssertRC(vrc);
8899	if (RT_FAILURE(vrc))
8900	break;
8901
8902	/*
8903	* Synchronize debugger settings
8904	*/
8905	MachineDebugger *machineDebugger = pConsole->getMachineDebugger();
8906	if (machineDebugger)
8907	machineDebugger->flushQueuedSettings();
8908
8909	/*
8910	* Shared Folders
8911	*/
8912	if (pConsole->m_pVMMDev->isShFlActive())
8913	{
8914	/* Does the code below call Console from the other thread?
8915	* Not sure, so release the lock just in case. */
8916	alock.release();
8917
8918	for (SharedFolderDataMap::const_iterator it = task->mSharedFolders.begin();
8919	it != task->mSharedFolders.end();
8920	++it)
8921	{
8922	const SharedFolderData &d = it->second;
8923	rc = pConsole->createSharedFolder(it->first, d);
8924	if (FAILED(rc))
8925	{
8926	ErrorInfoKeeper eik;
8927	pConsole->setVMRuntimeErrorCallbackF(0, "BrokenSharedFolder",
8928	N_("The shared folder '%s' could not be set up: %ls.\n"
8929	"The shared folder setup will not be complete. It is recommended to power down the virtual "
8930	"machine and fix the shared folder settings while the machine is not running"),
8931	it->first.c_str(), eik.getText().raw());
8932	}
8933	}
8934	if (FAILED(rc))
8935	rc = S_OK; // do not fail with broken shared folders
8936
8937	/* acquire the lock again */
8938	alock.acquire();
8939	}
8940
8941	/* release the lock before a lengthy operation */
8942	alock.release();
8943
8944	/*
8945	* Capture USB devices.
8946	*/
8947	rc = pConsole->captureUSBDevices(pConsole->mpUVM);
8948	if (FAILED(rc))
8949	break;
8950
8951	/* Load saved state? */
8952	if (task->mSavedStateFile.length())
8953	{
8954	LogFlowFunc(("Restoring saved state from '%s'...\n",
8955	task->mSavedStateFile.c_str()));
8956
8957	vrc = VMR3LoadFromFile(pConsole->mpUVM,
8958	task->mSavedStateFile.c_str(),
8959	Console::stateProgressCallback,
8960	static_cast<IProgress *>(task->mProgress));
8961
8962	if (RT_SUCCESS(vrc))
8963	{
8964	if (task->mStartPaused)
8965	/* done */
8966	pConsole->setMachineState(MachineState_Paused);
8967	else
8968	{
8969	/* Start/Resume the VM execution */
8970	#ifdef VBOX_WITH_EXTPACK
8971	vrc = pConsole->mptrExtPackManager->callAllVmPowerOnHooks(pConsole, pVM);
8972	#endif
8973	if (RT_SUCCESS(vrc))
8974	vrc = VMR3Resume(pConsole->mpUVM);
8975	AssertLogRelRC(vrc);
8976	}
8977	}
8978
8979	/* Power off in case we failed loading or resuming the VM */
8980	if (RT_FAILURE(vrc))
8981	{
8982	int vrc2 = VMR3PowerOff(pConsole->mpUVM); AssertLogRelRC(vrc2);
8983	#ifdef VBOX_WITH_EXTPACK
8984	pConsole->mptrExtPackManager->callAllVmPowerOffHooks(pConsole, pVM);
8985	#endif
8986	}
8987	}
8988	else if (task->mTeleporterEnabled)
8989	{
8990	/* -> ConsoleImplTeleporter.cpp */
8991	bool fPowerOffOnFailure;
8992	rc = pConsole->teleporterTrg(pConsole->mpUVM, pMachine, &task->mErrorMsg, task->mStartPaused,
8993	task->mProgress, &fPowerOffOnFailure);
8994	if (FAILED(rc) && fPowerOffOnFailure)
8995	{
8996	ErrorInfoKeeper eik;
8997	int vrc2 = VMR3PowerOff(pConsole->mpUVM); AssertLogRelRC(vrc2);
8998	#ifdef VBOX_WITH_EXTPACK
8999	pConsole->mptrExtPackManager->callAllVmPowerOffHooks(pConsole, pVM);
9000	#endif
9001	}
9002	}
9003	else if (task->mEnmFaultToleranceState != FaultToleranceState_Inactive)
9004	{
9005	/*
9006	* Get the config.
9007	*/
9008	ULONG uPort;
9009	ULONG uInterval;
9010	Bstr bstrAddress, bstrPassword;
9011
9012	rc = pMachine->COMGETTER(FaultTolerancePort)(&uPort);
9013	if (SUCCEEDED(rc))
9014	{
9015	rc = pMachine->COMGETTER(FaultToleranceSyncInterval)(&uInterval);
9016	if (SUCCEEDED(rc))
9017	rc = pMachine->COMGETTER(FaultToleranceAddress)(bstrAddress.asOutParam());
9018	if (SUCCEEDED(rc))
9019	rc = pMachine->COMGETTER(FaultTolerancePassword)(bstrPassword.asOutParam());
9020	}
9021	if (task->mProgress->setCancelCallback(faultToleranceProgressCancelCallback, pConsole->mpUVM))
9022	{
9023	if (SUCCEEDED(rc))
9024	{
9025	Utf8Str strAddress(bstrAddress);
9026	const char *pszAddress = strAddress.isEmpty() ? NULL : strAddress.c_str();
9027	Utf8Str strPassword(bstrPassword);
9028	const char *pszPassword = strPassword.isEmpty() ? NULL : strPassword.c_str();
9029
9030	/* Power on the FT enabled VM. */
9031	#ifdef VBOX_WITH_EXTPACK
9032	vrc = pConsole->mptrExtPackManager->callAllVmPowerOnHooks(pConsole, pVM);
9033	#endif
9034	if (RT_SUCCESS(vrc))
9035	vrc = FTMR3PowerOn(pConsole->mpUVM,
9036	task->mEnmFaultToleranceState == FaultToleranceState_Master /* fMaster */,
9037	uInterval,
9038	pszAddress,
9039	uPort,
9040	pszPassword);
9041	AssertLogRelRC(vrc);
9042	}
9043	task->mProgress->setCancelCallback(NULL, NULL);
9044	}
9045	else
9046	rc = E_FAIL;
9047	}
9048	else if (task->mStartPaused)
9049	/* done */
9050	pConsole->setMachineState(MachineState_Paused);
9051	else
9052	{
9053	/* Power on the VM (i.e. start executing) */
9054	#ifdef VBOX_WITH_EXTPACK
9055	vrc = pConsole->mptrExtPackManager->callAllVmPowerOnHooks(pConsole, pVM);
9056	#endif
9057	if (RT_SUCCESS(vrc))
9058	vrc = VMR3PowerOn(pConsole->mpUVM);
9059	AssertLogRelRC(vrc);
9060	}
9061
9062	/* acquire the lock again */
9063	alock.acquire();
9064	}
9065	while (0);
9066
9067	/* On failure, destroy the VM */
9068	if (FAILED(rc) \|\| RT_FAILURE(vrc))
9069	{
9070	/* preserve existing error info */
9071	ErrorInfoKeeper eik;
9072
9073	/* powerDown() will call VMR3Destroy() and do all necessary
9074	* cleanup (VRDP, USB devices) */
9075	alock.release();
9076	HRESULT rc2 = pConsole->powerDown();
9077	alock.acquire();
9078	AssertComRC(rc2);
9079	}
9080	else
9081	{
9082	/*
9083	* Deregister the VMSetError callback. This is necessary as the
9084	* pfnVMAtError() function passed to VMR3Create() is supposed to
9085	* be sticky but our error callback isn't.
9086	*/
9087	alock.release();
9088	VMR3AtErrorDeregister(pConsole->mpUVM, Console::genericVMSetErrorCallback, &task->mErrorMsg);
9089	/** @todo register another VMSetError callback? */
9090	alock.acquire();
9091	}
9092	}
9093	else
9094	{
9095	/*
9096	* If VMR3Create() failed it has released the VM memory.
9097	*/
9098	VMR3ReleaseUVM(pConsole->mpUVM);
9099	pConsole->mpUVM = NULL;
9100	}
9101
9102	if (SUCCEEDED(rc) && RT_FAILURE(vrc))
9103	{
9104	/* If VMR3Create() or one of the other calls in this function fail,
9105	* an appropriate error message has been set in task->mErrorMsg.
9106	* However since that happens via a callback, the rc status code in
9107	* this function is not updated.
9108	*/
9109	if (!task->mErrorMsg.length())
9110	{
9111	/* If the error message is not set but we've got a failure,
9112	* convert the VBox status code into a meaningful error message.
9113	* This becomes unused once all the sources of errors set the
9114	* appropriate error message themselves.
9115	*/
9116	AssertMsgFailed(("Missing error message during powerup for status code %Rrc\n", vrc));
9117	task->mErrorMsg = Utf8StrFmt(tr("Failed to start VM execution (%Rrc)"),
9118	vrc);
9119	}
9120
9121	/* Set the error message as the COM error.
9122	* Progress::notifyComplete() will pick it up later. */
9123	throw setErrorStatic(E_FAIL, task->mErrorMsg.c_str());
9124	}
9125	}
9126	catch (HRESULT aRC) { rc = aRC; }
9127
9128	if ( pConsole->mMachineState == MachineState_Starting
9129	\|\| pConsole->mMachineState == MachineState_Restoring
9130	\|\| pConsole->mMachineState == MachineState_TeleportingIn
9131	)
9132	{
9133	/* We are still in the Starting/Restoring state. This means one of:
9134	*
9135	* 1) we failed before VMR3Create() was called;
9136	* 2) VMR3Create() failed.
9137	*
9138	* In both cases, there is no need to call powerDown(), but we still
9139	* need to go back to the PoweredOff/Saved state. Reuse
9140	* vmstateChangeCallback() for that purpose.
9141	*/
9142
9143	/* preserve existing error info */
9144	ErrorInfoKeeper eik;
9145
9146	Assert(pConsole->mpUVM == NULL);
9147	vmstateChangeCallback(NULL, VMSTATE_TERMINATED, VMSTATE_CREATING, pConsole);
9148	}
9149
9150	/*
9151	* Evaluate the final result. Note that the appropriate mMachineState value
9152	* is already set by vmstateChangeCallback() in all cases.
9153	*/
9154
9155	/* release the lock, don't need it any more */
9156	alock.release();
9157
9158	if (SUCCEEDED(rc))
9159	{
9160	/* Notify the progress object of the success */
9161	task->mProgress->notifyComplete(S_OK);
9162	}
9163	else
9164	{
9165	/* The progress object will fetch the current error info */
9166	task->mProgress->notifyComplete(rc);
9167	LogRel(("Power up failed (vrc=%Rrc, rc=%Rhrc (%#08X))\n", vrc, rc, rc));
9168	}
9169
9170	/* Notify VBoxSVC and any waiting openRemoteSession progress object. */
9171	pConsole->mControl->EndPowerUp(rc);
9172
9173	#if defined(RT_OS_WINDOWS)
9174	/* uninitialize COM */
9175	CoUninitialize();
9176	#endif
9177
9178	LogFlowFuncLeave();
9179
9180	return VINF_SUCCESS;
9181	}
9182
9183
9184	/**
9185	* Reconfigures a medium attachment (part of taking or deleting an online snapshot).
9186	*
9187	* @param pConsole Reference to the console object.
9188	* @param pUVM The VM handle.
9189	* @param lInstance The instance of the controller.
9190	* @param pcszDevice The name of the controller type.
9191	* @param enmBus The storage bus type of the controller.
9192	* @param fSetupMerge Whether to set up a medium merge
9193	* @param uMergeSource Merge source image index
9194	* @param uMergeTarget Merge target image index
9195	* @param aMediumAtt The medium attachment.
9196	* @param aMachineState The current machine state.
9197	* @param phrc Where to store com error - only valid if we return VERR_GENERAL_FAILURE.
9198	* @return VBox status code.
9199	*/
9200	/* static */
9201	DECLCALLBACK(int) Console::reconfigureMediumAttachment(Console *pConsole,
9202	PUVM pUVM,
9203	const char *pcszDevice,
9204	unsigned uInstance,
9205	StorageBus_T enmBus,
9206	bool fUseHostIOCache,
9207	bool fBuiltinIOCache,
9208	bool fSetupMerge,
9209	unsigned uMergeSource,
9210	unsigned uMergeTarget,
9211	IMediumAttachment *aMediumAtt,
9212	MachineState_T aMachineState,
9213	HRESULT *phrc)
9214	{
9215	LogFlowFunc(("pUVM=%p aMediumAtt=%p phrc=%p\n", pUVM, aMediumAtt, phrc));
9216
9217	int rc;
9218	HRESULT hrc;
9219	Bstr bstr;
9220	*phrc = S_OK;
9221	#define RC_CHECK() do { if (RT_FAILURE(rc)) { AssertMsgFailed(("rc=%Rrc\n", rc)); return rc; } } while (0)
9222	#define H() do { if (FAILED(hrc)) { AssertMsgFailed(("hrc=%Rhrc (%#x)\n", hrc, hrc)); *phrc = hrc; return VERR_GENERAL_FAILURE; } } while (0)
9223
9224	/* Ignore attachments other than hard disks, since at the moment they are
9225	* not subject to snapshotting in general. */
9226	DeviceType_T lType;
9227	hrc = aMediumAtt->COMGETTER(Type)(&lType); H();
9228	if (lType != DeviceType_HardDisk)
9229	return VINF_SUCCESS;
9230
9231	/* Determine the base path for the device instance. */
9232	PCFGMNODE pCtlInst;
9233	pCtlInst = CFGMR3GetChildF(CFGMR3GetRootU(pUVM), "Devices/%s/%u/", pcszDevice, uInstance);
9234	AssertReturn(pCtlInst, VERR_INTERNAL_ERROR);
9235
9236	/* Update the device instance configuration. */
9237	rc = pConsole->configMediumAttachment(pCtlInst,
9238	pcszDevice,
9239	uInstance,
9240	enmBus,
9241	fUseHostIOCache,
9242	fBuiltinIOCache,
9243	fSetupMerge,
9244	uMergeSource,
9245	uMergeTarget,
9246	aMediumAtt,
9247	aMachineState,
9248	phrc,
9249	true /* fAttachDetach */,
9250	false /* fForceUnmount */,
9251	false /* fHotplug */,
9252	pUVM,
9253	NULL /* paLedDevType */);
9254	/** @todo this dumps everything attached to this device instance, which
9255	* is more than necessary. Dumping the changed LUN would be enough. */
9256	CFGMR3Dump(pCtlInst);
9257	RC_CHECK();
9258
9259	#undef RC_CHECK
9260	#undef H
9261
9262	LogFlowFunc(("Returns success\n"));
9263	return VINF_SUCCESS;
9264	}
9265
9266	/**
9267	* Progress cancelation callback employed by Console::fntTakeSnapshotWorker.
9268	*/
9269	static void takesnapshotProgressCancelCallback(void *pvUser)
9270	{
9271	PUVM pUVM = (PUVM)pvUser;
9272	SSMR3Cancel(pUVM);
9273	}
9274
9275	/**
9276	* Worker thread created by Console::TakeSnapshot.
9277	* @param Thread The current thread (ignored).
9278	* @param pvUser The task.
9279	* @return VINF_SUCCESS (ignored).
9280	*/
9281	/static/
9282	DECLCALLBACK(int) Console::fntTakeSnapshotWorker(RTTHREAD Thread, void *pvUser)
9283	{
9284	VMTakeSnapshotTask pTask = (VMTakeSnapshotTask)pvUser;
9285
9286	// taking a snapshot consists of the following:
9287
9288	// 1) creating a diff image for each virtual hard disk, into which write operations go after
9289	// the snapshot has been created (done in VBoxSVC, in SessionMachine::BeginTakingSnapshot)
9290	// 2) creating a Snapshot object with the state of the machine (hardware + storage,
9291	// done in VBoxSVC, also in SessionMachine::BeginTakingSnapshot)
9292	// 3) saving the state of the virtual machine (here, in the VM process, if the machine is online)
9293
9294	Console *that = pTask->mConsole;
9295	bool fBeganTakingSnapshot = false;
9296	bool fSuspenededBySave = false;
9297
9298	AutoCaller autoCaller(that);
9299	if (FAILED(autoCaller.rc()))
9300	{
9301	that->mptrCancelableProgress.setNull();
9302	return autoCaller.rc();
9303	}
9304
9305	AutoWriteLock alock(that COMMA_LOCKVAL_SRC_POS);
9306
9307	HRESULT rc = S_OK;
9308
9309	try
9310	{
9311	/* STEP 1 + 2:
9312	* request creating the diff images on the server and create the snapshot object
9313	* (this will set the machine state to Saving on the server to block
9314	* others from accessing this machine)
9315	*/
9316	rc = that->mControl->BeginTakingSnapshot(that,
9317	pTask->bstrName.raw(),
9318	pTask->bstrDescription.raw(),
9319	pTask->mProgress,
9320	pTask->fTakingSnapshotOnline,
9321	pTask->bstrSavedStateFile.asOutParam());
9322	if (FAILED(rc))
9323	throw rc;
9324
9325	fBeganTakingSnapshot = true;
9326
9327	/* Check sanity: for offline snapshots there must not be a saved state
9328	* file name. All other combinations are valid (even though online
9329	* snapshots without saved state file seems inconsistent - there are
9330	* some exotic use cases, which need to be explicitly enabled, see the
9331	* code of SessionMachine::BeginTakingSnapshot. */
9332	if ( !pTask->fTakingSnapshotOnline
9333	&& !pTask->bstrSavedStateFile.isEmpty())
9334	throw setErrorStatic(E_FAIL, "Invalid state of saved state file");
9335
9336	/* sync the state with the server */
9337	if (pTask->lastMachineState == MachineState_Running)
9338	that->setMachineStateLocally(MachineState_LiveSnapshotting);
9339	else
9340	that->setMachineStateLocally(MachineState_Saving);
9341
9342	// STEP 3: save the VM state (if online)
9343	if (pTask->fTakingSnapshotOnline)
9344	{
9345	int vrc;
9346	SafeVMPtr ptrVM(that);
9347	if (!ptrVM.isOk())
9348	throw ptrVM.rc();
9349
9350	pTask->mProgress->SetNextOperation(Bstr(tr("Saving the machine state")).raw(),
9351	pTask->ulMemSize); // operation weight, same as computed when setting up progress object
9352	if (!pTask->bstrSavedStateFile.isEmpty())
9353	{
9354	Utf8Str strSavedStateFile(pTask->bstrSavedStateFile);
9355
9356	pTask->mProgress->setCancelCallback(takesnapshotProgressCancelCallback, ptrVM.rawUVM());
9357
9358	alock.release();
9359	LogFlowFunc(("VMR3Save...\n"));
9360	vrc = VMR3Save(ptrVM.rawUVM(),
9361	strSavedStateFile.c_str(),
9362	true /fContinueAfterwards/,
9363	Console::stateProgressCallback,
9364	static_cast<IProgress *>(pTask->mProgress),
9365	&fSuspenededBySave);
9366	alock.acquire();
9367	if (RT_FAILURE(vrc))
9368	throw setErrorStatic(E_FAIL,
9369	tr("Failed to save the machine state to '%s' (%Rrc)"),
9370	strSavedStateFile.c_str(), vrc);
9371
9372	pTask->mProgress->setCancelCallback(NULL, NULL);
9373	}
9374	else
9375	LogRel(("Console: skipped saving state as part of online snapshot\n"));
9376
9377	if (!pTask->mProgress->notifyPointOfNoReturn())
9378	throw setErrorStatic(E_FAIL, tr("Canceled"));
9379	that->mptrCancelableProgress.setNull();
9380
9381	// STEP 4: reattach hard disks
9382	LogFlowFunc(("Reattaching new differencing hard disks...\n"));
9383
9384	pTask->mProgress->SetNextOperation(Bstr(tr("Reconfiguring medium attachments")).raw(),
9385	1); // operation weight, same as computed when setting up progress object
9386
9387	com::SafeIfaceArray<IMediumAttachment> atts;
9388	rc = that->mMachine->COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(atts));
9389	if (FAILED(rc))
9390	throw rc;
9391
9392	for (size_t i = 0;
9393	i < atts.size();
9394	++i)
9395	{
9396	ComPtr<IStorageController> pStorageController;
9397	Bstr controllerName;
9398	ULONG lInstance;
9399	StorageControllerType_T enmController;
9400	StorageBus_T enmBus;
9401	BOOL fUseHostIOCache;
9402
9403	/*
9404	* We can't pass a storage controller object directly
9405	* (g++ complains about not being able to pass non POD types through '...')
9406	* so we have to query needed values here and pass them.
9407	*/
9408	rc = atts[i]->COMGETTER(Controller)(controllerName.asOutParam());
9409	if (FAILED(rc))
9410	throw rc;
9411
9412	rc = that->mMachine->GetStorageControllerByName(controllerName.raw(),
9413	pStorageController.asOutParam());
9414	if (FAILED(rc))
9415	throw rc;
9416
9417	rc = pStorageController->COMGETTER(ControllerType)(&enmController);
9418	if (FAILED(rc))
9419	throw rc;
9420	rc = pStorageController->COMGETTER(Instance)(&lInstance);
9421	if (FAILED(rc))
9422	throw rc;
9423	rc = pStorageController->COMGETTER(Bus)(&enmBus);
9424	if (FAILED(rc))
9425	throw rc;
9426	rc = pStorageController->COMGETTER(UseHostIOCache)(&fUseHostIOCache);
9427	if (FAILED(rc))
9428	throw rc;
9429
9430	const char *pcszDevice = Console::convertControllerTypeToDev(enmController);
9431
9432	BOOL fBuiltinIOCache;
9433	rc = that->mMachine->COMGETTER(IOCacheEnabled)(&fBuiltinIOCache);
9434	if (FAILED(rc))
9435	throw rc;
9436
9437	/*
9438	* don't release the lock since reconfigureMediumAttachment
9439	* isn't going to need the Console lock.
9440	*/
9441	vrc = VMR3ReqCallWaitU(ptrVM.rawUVM(),
9442	VMCPUID_ANY,
9443	(PFNRT)reconfigureMediumAttachment,
9444	13,
9445	that,
9446	ptrVM.rawUVM(),
9447	pcszDevice,
9448	lInstance,
9449	enmBus,
9450	fUseHostIOCache,
9451	fBuiltinIOCache,
9452	false /* fSetupMerge */,
9453	0 /* uMergeSource */,
9454	0 /* uMergeTarget */,
9455	atts[i],
9456	that->mMachineState,
9457	&rc);
9458	if (RT_FAILURE(vrc))
9459	throw setErrorStatic(E_FAIL, Console::tr("%Rrc"), vrc);
9460	if (FAILED(rc))
9461	throw rc;
9462	}
9463	}
9464
9465	/*
9466	* finalize the requested snapshot object.
9467	* This will reset the machine state to the state it had right
9468	* before calling mControl->BeginTakingSnapshot().
9469	*/
9470	rc = that->mControl->EndTakingSnapshot(TRUE /aSuccess/);
9471	// do not throw rc here because we can't call EndTakingSnapshot() twice
9472	LogFlowFunc(("EndTakingSnapshot -> %Rhrc [mMachineState=%s]\n", rc, Global::stringifyMachineState(that->mMachineState)));
9473	}
9474	catch (HRESULT rcThrown)
9475	{
9476	/* preserve existing error info */
9477	ErrorInfoKeeper eik;
9478
9479	if (fBeganTakingSnapshot)
9480	that->mControl->EndTakingSnapshot(FALSE /aSuccess/);
9481
9482	rc = rcThrown;
9483	LogFunc(("Caught %Rhrc [mMachineState=%s]\n", rc, Global::stringifyMachineState(that->mMachineState)));
9484	}
9485	Assert(alock.isWriteLockOnCurrentThread());
9486
9487	if (FAILED(rc)) /* Must come before calling setMachineState. */
9488	pTask->mProgress->notifyComplete(rc);
9489
9490	/*
9491	* Fix up the machine state.
9492	*
9493	* For live snapshots we do all the work, for the two other variations we
9494	* just update the local copy.
9495	*/
9496	MachineState_T enmMachineState;
9497	that->mMachine->COMGETTER(State)(&enmMachineState);
9498	if ( that->mMachineState == MachineState_LiveSnapshotting
9499	\|\| that->mMachineState == MachineState_Saving)
9500	{
9501
9502	if (!pTask->fTakingSnapshotOnline)
9503	that->setMachineStateLocally(pTask->lastMachineState);
9504	else if (SUCCEEDED(rc))
9505	{
9506	Assert( pTask->lastMachineState == MachineState_Running
9507	\|\| pTask->lastMachineState == MachineState_Paused);
9508	Assert(that->mMachineState == MachineState_Saving);
9509	if (pTask->lastMachineState == MachineState_Running)
9510	{
9511	LogFlowFunc(("VMR3Resume...\n"));
9512	SafeVMPtr ptrVM(that);
9513	alock.release();
9514	int vrc = VMR3Resume(ptrVM.rawUVM());
9515	alock.acquire();
9516	if (RT_FAILURE(vrc))
9517	{
9518	rc = setErrorStatic(VBOX_E_VM_ERROR, tr("Could not resume the machine execution (%Rrc)"), vrc);
9519	pTask->mProgress->notifyComplete(rc);
9520	if (that->mMachineState == MachineState_Saving)
9521	that->setMachineStateLocally(MachineState_Paused);
9522	}
9523	}
9524	else
9525	that->setMachineStateLocally(MachineState_Paused);
9526	}
9527	else
9528	{
9529	/** @todo this could probably be made more generic and reused elsewhere. */
9530	/* paranoid cleanup on for a failed online snapshot. */
9531	VMSTATE enmVMState = VMR3GetStateU(that->mpUVM);
9532	switch (enmVMState)
9533	{
9534	case VMSTATE_RUNNING:
9535	case VMSTATE_RUNNING_LS:
9536	case VMSTATE_DEBUGGING:
9537	case VMSTATE_DEBUGGING_LS:
9538	case VMSTATE_POWERING_OFF:
9539	case VMSTATE_POWERING_OFF_LS:
9540	case VMSTATE_RESETTING:
9541	case VMSTATE_RESETTING_LS:
9542	Assert(!fSuspenededBySave);
9543	that->setMachineState(MachineState_Running);
9544	break;
9545
9546	case VMSTATE_GURU_MEDITATION:
9547	case VMSTATE_GURU_MEDITATION_LS:
9548	that->setMachineState(MachineState_Stuck);
9549	break;
9550
9551	case VMSTATE_FATAL_ERROR:
9552	case VMSTATE_FATAL_ERROR_LS:
9553	if (pTask->lastMachineState == MachineState_Paused)
9554	that->setMachineStateLocally(pTask->lastMachineState);
9555	else
9556	that->setMachineState(MachineState_Paused);
9557	break;
9558
9559	default:
9560	AssertMsgFailed(("%s\n", VMR3GetStateName(enmVMState)));
9561	case VMSTATE_SUSPENDED:
9562	case VMSTATE_SUSPENDED_LS:
9563	case VMSTATE_SUSPENDING:
9564	case VMSTATE_SUSPENDING_LS:
9565	case VMSTATE_SUSPENDING_EXT_LS:
9566	if (fSuspenededBySave)
9567	{
9568	Assert(pTask->lastMachineState == MachineState_Running);
9569	LogFlowFunc(("VMR3Resume (on failure)...\n"));
9570	SafeVMPtr ptrVM(that);
9571	alock.release();
9572	int vrc = VMR3Resume(ptrVM.rawUVM()); AssertLogRelRC(vrc);
9573	alock.acquire();
9574	if (RT_FAILURE(vrc))
9575	that->setMachineState(MachineState_Paused);
9576	}
9577	else if (pTask->lastMachineState == MachineState_Paused)
9578	that->setMachineStateLocally(pTask->lastMachineState);
9579	else
9580	that->setMachineState(MachineState_Paused);
9581	break;
9582	}
9583
9584	}
9585	}
9586	/else: somebody else has change the state... Leave it. /
9587
9588	/* check the remote state to see that we got it right. */
9589	that->mMachine->COMGETTER(State)(&enmMachineState);
9590	AssertLogRelMsg(that->mMachineState == enmMachineState,
9591	("mMachineState=%s enmMachineState=%s\n", Global::stringifyMachineState(that->mMachineState),
9592	Global::stringifyMachineState(enmMachineState) ));
9593
9594
9595	if (SUCCEEDED(rc)) /* The failure cases are handled above. */
9596	pTask->mProgress->notifyComplete(rc);
9597
9598	delete pTask;
9599
9600	LogFlowFuncLeave();
9601	return VINF_SUCCESS;
9602	}
9603
9604	/**
9605	* Thread for executing the saved state operation.
9606	*
9607	* @param Thread The thread handle.
9608	* @param pvUser Pointer to a VMSaveTask structure.
9609	* @return VINF_SUCCESS (ignored).
9610	*
9611	* @note Locks the Console object for writing.
9612	*/
9613	/static/
9614	DECLCALLBACK(int) Console::saveStateThread(RTTHREAD Thread, void *pvUser)
9615	{
9616	LogFlowFuncEnter();
9617
9618	std::auto_ptr<VMSaveTask> task(static_cast<VMSaveTask*>(pvUser));
9619	AssertReturn(task.get(), VERR_INVALID_PARAMETER);
9620
9621	Assert(task->mSavedStateFile.length());
9622	Assert(task->mProgress.isNull());
9623	Assert(!task->mServerProgress.isNull());
9624
9625	const ComObjPtr<Console> &that = task->mConsole;
9626	Utf8Str errMsg;
9627	HRESULT rc = S_OK;
9628
9629	LogFlowFunc(("Saving the state to '%s'...\n", task->mSavedStateFile.c_str()));
9630
9631	bool fSuspenededBySave;
9632	int vrc = VMR3Save(task->mpUVM,
9633	task->mSavedStateFile.c_str(),
9634	false, /fContinueAfterwards/
9635	Console::stateProgressCallback,
9636	static_cast<IProgress *>(task->mServerProgress),
9637	&fSuspenededBySave);
9638	if (RT_FAILURE(vrc))
9639	{
9640	errMsg = Utf8StrFmt(Console::tr("Failed to save the machine state to '%s' (%Rrc)"),
9641	task->mSavedStateFile.c_str(), vrc);
9642	rc = E_FAIL;
9643	}
9644	Assert(!fSuspenededBySave);
9645
9646	/* lock the console once we're going to access it */
9647	AutoWriteLock thatLock(that COMMA_LOCKVAL_SRC_POS);
9648
9649	/* synchronize the state with the server */
9650	if (SUCCEEDED(rc))
9651	{
9652	/*
9653	* The machine has been successfully saved, so power it down
9654	* (vmstateChangeCallback() will set state to Saved on success).
9655	* Note: we release the task's VM caller, otherwise it will
9656	* deadlock.
9657	*/
9658	task->releaseVMCaller();
9659	thatLock.release();
9660	rc = that->powerDown();
9661	thatLock.acquire();
9662	}
9663
9664	/*
9665	* If we failed, reset the local machine state.
9666	*/
9667	if (FAILED(rc))
9668	that->setMachineStateLocally(task->mMachineStateBefore);
9669
9670	/*
9671	* Finalize the requested save state procedure. In case of failure it will
9672	* reset the machine state to the state it had right before calling
9673	* mControl->BeginSavingState(). This must be the last thing because it
9674	* will set the progress to completed, and that means that the frontend
9675	* can immediately uninit the associated console object.
9676	*/
9677	that->mControl->EndSavingState(rc, Bstr(errMsg).raw());
9678
9679	LogFlowFuncLeave();
9680	return VINF_SUCCESS;
9681	}
9682
9683	/**
9684	* Thread for powering down the Console.
9685	*
9686	* @param Thread The thread handle.
9687	* @param pvUser Pointer to the VMTask structure.
9688	* @return VINF_SUCCESS (ignored).
9689	*
9690	* @note Locks the Console object for writing.
9691	*/
9692	/static/
9693	DECLCALLBACK(int) Console::powerDownThread(RTTHREAD Thread, void *pvUser)
9694	{
9695	LogFlowFuncEnter();
9696
9697	std::auto_ptr<VMPowerDownTask> task(static_cast<VMPowerDownTask *>(pvUser));
9698	AssertReturn(task.get(), VERR_INVALID_PARAMETER);
9699
9700	AssertReturn(task->isOk(), VERR_GENERAL_FAILURE);
9701
9702	Assert(task->mProgress.isNull());
9703
9704	const ComObjPtr<Console> &that = task->mConsole;
9705
9706	/* Note: no need to use addCaller() to protect Console because VMTask does
9707	* that */
9708
9709	/* wait until the method tat started us returns */
9710	AutoWriteLock thatLock(that COMMA_LOCKVAL_SRC_POS);
9711
9712	/* release VM caller to avoid the powerDown() deadlock */
9713	task->releaseVMCaller();
9714
9715	thatLock.release();
9716
9717	that->powerDown(task->mServerProgress);
9718
9719	/* complete the operation */
9720	that->mControl->EndPoweringDown(S_OK, Bstr().raw());
9721
9722	LogFlowFuncLeave();
9723	return VINF_SUCCESS;
9724	}
9725
9726
9727	/**
9728	* @interface_method_impl{VMM2USERMETHODS,pfnSaveState}
9729	*/
9730	/static/ DECLCALLBACK(int)
9731	Console::vmm2User_SaveState(PCVMM2USERMETHODS pThis, PUVM pUVM)
9732	{
9733	Console pConsole = ((MYVMM2USERMETHODS )pThis)->pConsole;
9734	NOREF(pUVM);
9735
9736	/*
9737	* For now, just call SaveState. We should probably try notify the GUI so
9738	* it can pop up a progress object and stuff.
9739	*/
9740	HRESULT hrc = pConsole->SaveState(NULL);
9741	return SUCCEEDED(hrc) ? VINF_SUCCESS : Global::vboxStatusCodeFromCOM(hrc);
9742	}
9743
9744	/**
9745	* @interface_method_impl{VMM2USERMETHODS,pfnNotifyEmtInit}
9746	*/
9747	/static/ DECLCALLBACK(void)
9748	Console::vmm2User_NotifyEmtInit(PCVMM2USERMETHODS pThis, PUVM pUVM, PUVMCPU pUVCpu)
9749	{
9750	NOREF(pThis); NOREF(pUVM); NOREF(pUVCpu);
9751	VirtualBoxBase::initializeComForThread();
9752	}
9753
9754	/**
9755	* @interface_method_impl{VMM2USERMETHODS,pfnNotifyEmtTerm}
9756	*/
9757	/static/ DECLCALLBACK(void)
9758	Console::vmm2User_NotifyEmtTerm(PCVMM2USERMETHODS pThis, PUVM pUVM, PUVMCPU pUVCpu)
9759	{
9760	NOREF(pThis); NOREF(pUVM); NOREF(pUVCpu);
9761	VirtualBoxBase::uninitializeComForThread();
9762	}
9763
9764	/**
9765	* @interface_method_impl{VMM2USERMETHODS,pfnNotifyPdmtInit}
9766	*/
9767	/static/ DECLCALLBACK(void)
9768	Console::vmm2User_NotifyPdmtInit(PCVMM2USERMETHODS pThis, PUVM pUVM)
9769	{
9770	NOREF(pThis); NOREF(pUVM);
9771	VirtualBoxBase::initializeComForThread();
9772	}
9773
9774	/**
9775	* @interface_method_impl{VMM2USERMETHODS,pfnNotifyPdmtTerm}
9776	*/
9777	/static/ DECLCALLBACK(void)
9778	Console::vmm2User_NotifyPdmtTerm(PCVMM2USERMETHODS pThis, PUVM pUVM)
9779	{
9780	NOREF(pThis); NOREF(pUVM);
9781	VirtualBoxBase::uninitializeComForThread();
9782	}
9783
9784
9785
9786
9787	/**
9788	* The Main status driver instance data.
9789	*/
9790	typedef struct DRVMAINSTATUS
9791	{
9792	/** The LED connectors. */
9793	PDMILEDCONNECTORS ILedConnectors;
9794	/** Pointer to the LED ports interface above us. */
9795	PPDMILEDPORTS pLedPorts;
9796	/** Pointer to the array of LED pointers. */
9797	PPDMLED *papLeds;
9798	/** The unit number corresponding to the first entry in the LED array. */
9799	RTUINT iFirstLUN;
9800	/** The unit number corresponding to the last entry in the LED array.
9801	* (The size of the LED array is iLastLUN - iFirstLUN + 1.) */
9802	RTUINT iLastLUN;
9803	/** Pointer to the driver instance. */
9804	PPDMDRVINS pDrvIns;
9805	/** The Media Notify interface. */
9806	PDMIMEDIANOTIFY IMediaNotify;
9807	/** Map for translating PDM storage controller/LUN information to
9808	* IMediumAttachment references. */
9809	Console::MediumAttachmentMap *pmapMediumAttachments;
9810	/** Device name+instance for mapping */
9811	char *pszDeviceInstance;
9812	/** Pointer to the Console object, for driver triggered activities. */
9813	Console *pConsole;
9814	} DRVMAINSTATUS, *PDRVMAINSTATUS;
9815
9816
9817	/**
9818	* Notification about a unit which have been changed.
9819	*
9820	* The driver must discard any pointers to data owned by
9821	* the unit and requery it.
9822	*
9823	* @param pInterface Pointer to the interface structure containing the called function pointer.
9824	* @param iLUN The unit number.
9825	*/
9826	DECLCALLBACK(void) Console::drvStatus_UnitChanged(PPDMILEDCONNECTORS pInterface, unsigned iLUN)
9827	{
9828	PDRVMAINSTATUS pThis = (PDRVMAINSTATUS)((uintptr_t)pInterface - RT_OFFSETOF(DRVMAINSTATUS, ILedConnectors));
9829	if (iLUN >= pThis->iFirstLUN && iLUN <= pThis->iLastLUN)
9830	{
9831	PPDMLED pLed;
9832	int rc = pThis->pLedPorts->pfnQueryStatusLed(pThis->pLedPorts, iLUN, &pLed);
9833	if (RT_FAILURE(rc))
9834	pLed = NULL;
9835	ASMAtomicWritePtr(&pThis->papLeds[iLUN - pThis->iFirstLUN], pLed);
9836	Log(("drvStatus_UnitChanged: iLUN=%d pLed=%p\n", iLUN, pLed));
9837	}
9838	}
9839
9840
9841	/**
9842	* Notification about a medium eject.
9843	*
9844	* @returns VBox status.
9845	* @param pInterface Pointer to the interface structure containing the called function pointer.
9846	* @param uLUN The unit number.
9847	*/
9848	DECLCALLBACK(int) Console::drvStatus_MediumEjected(PPDMIMEDIANOTIFY pInterface, unsigned uLUN)
9849	{
9850	PDRVMAINSTATUS pThis = (PDRVMAINSTATUS)((uintptr_t)pInterface - RT_OFFSETOF(DRVMAINSTATUS, IMediaNotify));
9851	PPDMDRVINS pDrvIns = pThis->pDrvIns;
9852	LogFunc(("uLUN=%d\n", uLUN));
9853	if (pThis->pmapMediumAttachments)
9854	{
9855	AutoWriteLock alock(pThis->pConsole COMMA_LOCKVAL_SRC_POS);
9856
9857	ComPtr<IMediumAttachment> pMediumAtt;
9858	Utf8Str devicePath = Utf8StrFmt("%s/LUN#%u", pThis->pszDeviceInstance, uLUN);
9859	Console::MediumAttachmentMap::const_iterator end = pThis->pmapMediumAttachments->end();
9860	Console::MediumAttachmentMap::const_iterator it = pThis->pmapMediumAttachments->find(devicePath);
9861	if (it != end)
9862	pMediumAtt = it->second;
9863	Assert(!pMediumAtt.isNull());
9864	if (!pMediumAtt.isNull())
9865	{
9866	IMedium *pMedium = NULL;
9867	HRESULT rc = pMediumAtt->COMGETTER(Medium)(&pMedium);
9868	AssertComRC(rc);
9869	if (SUCCEEDED(rc) && pMedium)
9870	{
9871	BOOL fHostDrive = FALSE;
9872	rc = pMedium->COMGETTER(HostDrive)(&fHostDrive);
9873	AssertComRC(rc);
9874	if (!fHostDrive)
9875	{
9876	alock.release();
9877
9878	ComPtr<IMediumAttachment> pNewMediumAtt;
9879	rc = pThis->pConsole->mControl->EjectMedium(pMediumAtt, pNewMediumAtt.asOutParam());
9880	if (SUCCEEDED(rc))
9881	fireMediumChangedEvent(pThis->pConsole->mEventSource, pNewMediumAtt);
9882
9883	alock.acquire();
9884	if (pNewMediumAtt != pMediumAtt)
9885	{
9886	pThis->pmapMediumAttachments->erase(devicePath);
9887	pThis->pmapMediumAttachments->insert(std::make_pair(devicePath, pNewMediumAtt));
9888	}
9889	}
9890	}
9891	}
9892	}
9893	return VINF_SUCCESS;
9894	}
9895
9896
9897	/**
9898	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
9899	*/
9900	DECLCALLBACK(void ) Console::drvStatus_QueryInterface(PPDMIBASE pInterface, const char pszIID)
9901	{
9902	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
9903	PDRVMAINSTATUS pThis = PDMINS_2_DATA(pDrvIns, PDRVMAINSTATUS);
9904	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
9905	PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDCONNECTORS, &pThis->ILedConnectors);
9906	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMEDIANOTIFY, &pThis->IMediaNotify);
9907	return NULL;
9908	}
9909
9910
9911	/**
9912	* Destruct a status driver instance.
9913	*
9914	* @returns VBox status.
9915	* @param pDrvIns The driver instance data.
9916	*/
9917	DECLCALLBACK(void) Console::drvStatus_Destruct(PPDMDRVINS pDrvIns)
9918	{
9919	PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
9920	PDRVMAINSTATUS pThis = PDMINS_2_DATA(pDrvIns, PDRVMAINSTATUS);
9921	LogFlowFunc(("iInstance=%d\n", pDrvIns->iInstance));
9922
9923	if (pThis->papLeds)
9924	{
9925	unsigned iLed = pThis->iLastLUN - pThis->iFirstLUN + 1;
9926	while (iLed-- > 0)
9927	ASMAtomicWriteNullPtr(&pThis->papLeds[iLed]);
9928	}
9929	}
9930
9931
9932	/**
9933	* Construct a status driver instance.
9934	*
9935	* @copydoc FNPDMDRVCONSTRUCT
9936	*/
9937	DECLCALLBACK(int) Console::drvStatus_Construct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
9938	{
9939	PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
9940	PDRVMAINSTATUS pThis = PDMINS_2_DATA(pDrvIns, PDRVMAINSTATUS);
9941	LogFlowFunc(("iInstance=%d\n", pDrvIns->iInstance));
9942
9943	/*
9944	* Validate configuration.
9945	*/
9946	if (!CFGMR3AreValuesValid(pCfg, "papLeds\0pmapMediumAttachments\0DeviceInstance\0pConsole\0First\0Last\0"))
9947	return VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES;
9948	AssertMsgReturn(PDMDrvHlpNoAttach(pDrvIns) == VERR_PDM_NO_ATTACHED_DRIVER,
9949	("Configuration error: Not possible to attach anything to this driver!\n"),
9950	VERR_PDM_DRVINS_NO_ATTACH);
9951
9952	/*
9953	* Data.
9954	*/
9955	pDrvIns->IBase.pfnQueryInterface = Console::drvStatus_QueryInterface;
9956	pThis->ILedConnectors.pfnUnitChanged = Console::drvStatus_UnitChanged;
9957	pThis->IMediaNotify.pfnEjected = Console::drvStatus_MediumEjected;
9958	pThis->pDrvIns = pDrvIns;
9959	pThis->pszDeviceInstance = NULL;
9960
9961	/*
9962	* Read config.
9963	*/
9964	int rc = CFGMR3QueryPtr(pCfg, "papLeds", (void **)&pThis->papLeds);
9965	if (RT_FAILURE(rc))
9966	{
9967	AssertMsgFailed(("Configuration error: Failed to query the \"papLeds\" value! rc=%Rrc\n", rc));
9968	return rc;
9969	}
9970
9971	rc = CFGMR3QueryPtrDef(pCfg, "pmapMediumAttachments", (void **)&pThis->pmapMediumAttachments, NULL);
9972	if (RT_FAILURE(rc))
9973	{
9974	AssertMsgFailed(("Configuration error: Failed to query the \"pmapMediumAttachments\" value! rc=%Rrc\n", rc));
9975	return rc;
9976	}
9977	if (pThis->pmapMediumAttachments)
9978	{
9979	rc = CFGMR3QueryStringAlloc(pCfg, "DeviceInstance", &pThis->pszDeviceInstance);
9980	if (RT_FAILURE(rc))
9981	{
9982	AssertMsgFailed(("Configuration error: Failed to query the \"DeviceInstance\" value! rc=%Rrc\n", rc));
9983	return rc;
9984	}
9985	rc = CFGMR3QueryPtr(pCfg, "pConsole", (void **)&pThis->pConsole);
9986	if (RT_FAILURE(rc))
9987	{
9988	AssertMsgFailed(("Configuration error: Failed to query the \"pConsole\" value! rc=%Rrc\n", rc));
9989	return rc;
9990	}
9991	}
9992
9993	rc = CFGMR3QueryU32(pCfg, "First", &pThis->iFirstLUN);
9994	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
9995	pThis->iFirstLUN = 0;
9996	else if (RT_FAILURE(rc))
9997	{
9998	AssertMsgFailed(("Configuration error: Failed to query the \"First\" value! rc=%Rrc\n", rc));
9999	return rc;
10000	}
10001
10002	rc = CFGMR3QueryU32(pCfg, "Last", &pThis->iLastLUN);
10003	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
10004	pThis->iLastLUN = 0;
10005	else if (RT_FAILURE(rc))
10006	{
10007	AssertMsgFailed(("Configuration error: Failed to query the \"Last\" value! rc=%Rrc\n", rc));
10008	return rc;
10009	}
10010	if (pThis->iFirstLUN > pThis->iLastLUN)
10011	{
10012	AssertMsgFailed(("Configuration error: Invalid unit range %u-%u\n", pThis->iFirstLUN, pThis->iLastLUN));
10013	return VERR_GENERAL_FAILURE;
10014	}
10015
10016	/*
10017	* Get the ILedPorts interface of the above driver/device and
10018	* query the LEDs we want.
10019	*/
10020	pThis->pLedPorts = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMILEDPORTS);
10021	AssertMsgReturn(pThis->pLedPorts, ("Configuration error: No led ports interface above!\n"),
10022	VERR_PDM_MISSING_INTERFACE_ABOVE);
10023
10024	for (unsigned i = pThis->iFirstLUN; i <= pThis->iLastLUN; ++i)
10025	Console::drvStatus_UnitChanged(&pThis->ILedConnectors, i);
10026
10027	return VINF_SUCCESS;
10028	}
10029
10030
10031	/**
10032	* Console status driver (LED) registration record.
10033	*/
10034	const PDMDRVREG Console::DrvStatusReg =
10035	{
10036	/* u32Version */
10037	PDM_DRVREG_VERSION,
10038	/* szName */
10039	"MainStatus",
10040	/* szRCMod */
10041	"",
10042	/* szR0Mod */
10043	"",
10044	/* pszDescription */
10045	"Main status driver (Main as in the API).",
10046	/* fFlags */
10047	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
10048	/* fClass. */
10049	PDM_DRVREG_CLASS_STATUS,
10050	/* cMaxInstances */
10051	~0U,
10052	/* cbInstance */
10053	sizeof(DRVMAINSTATUS),
10054	/* pfnConstruct */
10055	Console::drvStatus_Construct,
10056	/* pfnDestruct */
10057	Console::drvStatus_Destruct,
10058	/* pfnRelocate */
10059	NULL,
10060	/* pfnIOCtl */
10061	NULL,
10062	/* pfnPowerOn */
10063	NULL,
10064	/* pfnReset */
10065	NULL,
10066	/* pfnSuspend */
10067	NULL,
10068	/* pfnResume */
10069	NULL,
10070	/* pfnAttach */
10071	NULL,
10072	/* pfnDetach */
10073	NULL,
10074	/* pfnPowerOff */
10075	NULL,
10076	/* pfnSoftReset */
10077	NULL,
10078	/* u32EndVersion */
10079	PDM_DRVREG_VERSION
10080	};
10081
10082	/* 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@ 46284

Download in other formats: