USBProxyService.cpp@ 55747

Last change on this file since 55747 was 53062, checked in by vboxsync, 10 years ago
USB: Integrate USB sniffer. Make it possible to specify a file to dump the traffic to when attaching a USB device with VBoxManage
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 38.1 KB

Line
1	/* $Id: USBProxyService.cpp 53062 2014-10-15 12:34:18Z vboxsync $ */
2	/** @file
3	* VirtualBox USB Proxy Service (base) class.
4	*/
5
6	/*
7	* Copyright (C) 2006-2014 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	#include "USBProxyService.h"
19	#include "HostUSBDeviceImpl.h"
20	#include "HostImpl.h"
21	#include "MachineImpl.h"
22	#include "VirtualBoxImpl.h"
23
24	#include "AutoCaller.h"
25	#include "Logging.h"
26
27	#include <VBox/com/array.h>
28	#include <VBox/err.h>
29	#include <iprt/asm.h>
30	#include <iprt/semaphore.h>
31	#include <iprt/thread.h>
32	#include <iprt/mem.h>
33	#include <iprt/string.h>
34
35
36	/**
37	* Initialize data members.
38	*/
39	USBProxyService::USBProxyService(Host *aHost)
40	: mHost(aHost), mThread(NIL_RTTHREAD), mTerminate(false), mLastError(VINF_SUCCESS), mDevices()
41	{
42	LogFlowThisFunc(("aHost=%p\n", aHost));
43	}
44
45
46	/**
47	* Stub needed as long as the class isn't virtual
48	*/
49	HRESULT USBProxyService::init(void)
50	{
51	return S_OK;
52	}
53
54
55	/**
56	* Empty destructor.
57	*/
58	USBProxyService::~USBProxyService()
59	{
60	LogFlowThisFunc(("\n"));
61	Assert(mThread == NIL_RTTHREAD);
62	mDevices.clear();
63	mTerminate = true;
64	mHost = NULL;
65	}
66
67
68	/**
69	* Query if the service is active and working.
70	*
71	* @returns true if the service is up running.
72	* @returns false if the service isn't running.
73	*/
74	bool USBProxyService::isActive(void)
75	{
76	return mThread != NIL_RTTHREAD;
77	}
78
79
80	/**
81	* Get last error.
82	* Can be used to check why the proxy !isActive() upon construction.
83	*
84	* @returns VBox status code.
85	*/
86	int USBProxyService::getLastError(void)
87	{
88	return mLastError;
89	}
90
91
92	/**
93	* Get last error message.
94	* Can be used to check why the proxy !isActive() upon construction as an
95	* extension to getLastError(). May return a NULL error.
96	*
97	* @param
98	* @returns VBox status code.
99	*/
100	HRESULT USBProxyService::getLastErrorMessage(BSTR *aError)
101	{
102	AssertPtrReturn(aError, E_POINTER);
103	mLastErrorMessage.cloneTo(aError);
104	return S_OK;
105	}
106
107
108	/**
109	* We're using the Host object lock.
110	*
111	* This is just a temporary measure until all the USB refactoring is
112	* done, probably... For now it help avoiding deadlocks we don't have
113	* time to fix.
114	*
115	* @returns Lock handle.
116	*/
117	RWLockHandle *USBProxyService::lockHandle() const
118	{
119	return mHost->lockHandle();
120	}
121
122
123	/**
124	* Gets the collection of USB devices, slave of Host::USBDevices.
125	*
126	* This is an interface for the HostImpl::USBDevices property getter.
127	*
128	*
129	* @param aUSBDevices Where to store the pointer to the collection.
130	*
131	* @returns COM status code.
132	*
133	* @remarks The caller must own the write lock of the host object.
134	*/
135	HRESULT USBProxyService::getDeviceCollection(std::vector<ComPtr<IHostUSBDevice> > &aUSBDevices)
136	{
137	AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
138
139	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
140
141	aUSBDevices.resize(mDevices.size());
142	size_t i = 0;
143	for (HostUSBDeviceList::const_iterator it = mDevices.begin(); it != mDevices.end(); ++it, ++i)
144	aUSBDevices[i] = *it;
145
146	return S_OK;
147	}
148
149
150	/**
151	* Request capture of a specific device.
152	*
153	* This is in an interface for SessionMachine::CaptureUSBDevice(), which is
154	* an internal worker used by Console::AttachUSBDevice() from the VM process.
155	*
156	* When the request is completed, SessionMachine::onUSBDeviceAttach() will
157	* be called for the given machine object.
158	*
159	*
160	* @param aMachine The machine to attach the device to.
161	* @param aId The UUID of the USB device to capture and attach.
162	*
163	* @returns COM status code and error info.
164	*
165	* @remarks This method may operate synchronously as well as asynchronously. In the
166	* former case it will temporarily abandon locks because of IPC.
167	*/
168	HRESULT USBProxyService::captureDeviceForVM(SessionMachine *aMachine, IN_GUID aId, const com::Utf8Str &aCaptureFilename)
169	{
170	ComAssertRet(aMachine, E_INVALIDARG);
171	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
172
173	/*
174	* Translate the device id into a device object.
175	*/
176	ComObjPtr<HostUSBDevice> pHostDevice = findDeviceById(aId);
177	if (pHostDevice.isNull())
178	return setError(E_INVALIDARG,
179	tr("The USB device with UUID {%RTuuid} is not currently attached to the host"), Guid(aId).raw());
180
181	/*
182	* Try to capture the device
183	*/
184	alock.release();
185	return pHostDevice->i_requestCaptureForVM(aMachine, true /* aSetError */, aCaptureFilename);
186	}
187
188
189	/**
190	* Notification from VM process about USB device detaching progress.
191	*
192	* This is in an interface for SessionMachine::DetachUSBDevice(), which is
193	* an internal worker used by Console::DetachUSBDevice() from the VM process.
194	*
195	* @param aMachine The machine which is sending the notification.
196	* @param aId The UUID of the USB device is concerns.
197	* @param aDone \a false for the pre-action notification (necessary
198	* for advancing the device state to avoid confusing
199	* the guest).
200	* \a true for the post-action notification. The device
201	* will be subjected to all filters except those of
202	* of \a Machine.
203	*
204	* @returns COM status code.
205	*
206	* @remarks When \a aDone is \a true this method may end up doing IPC to other
207	* VMs when running filters. In these cases it will temporarily
208	* abandon its locks.
209	*/
210	HRESULT USBProxyService::detachDeviceFromVM(SessionMachine *aMachine, IN_GUID aId, bool aDone)
211	{
212	LogFlowThisFunc(("aMachine=%p{%s} aId={%RTuuid} aDone=%RTbool\n",
213	aMachine,
214	aMachine->i_getName().c_str(),
215	Guid(aId).raw(),
216	aDone));
217
218	// get a list of all running machines while we're outside the lock
219	// (getOpenedMachines requests locks which are incompatible with the lock of the machines list)
220	SessionMachinesList llOpenedMachines;
221	mHost->i_parent()->i_getOpenedMachines(llOpenedMachines);
222
223	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
224
225	ComObjPtr<HostUSBDevice> pHostDevice = findDeviceById(aId);
226	ComAssertRet(!pHostDevice.isNull(), E_FAIL);
227	AutoWriteLock devLock(pHostDevice COMMA_LOCKVAL_SRC_POS);
228
229	/*
230	* Work the state machine.
231	*/
232	LogFlowThisFunc(("id={%RTuuid} state=%s aDone=%RTbool name={%s}\n",
233	pHostDevice->i_getId().raw(), pHostDevice->i_getStateName(), aDone, pHostDevice->i_getName().c_str()));
234	bool fRunFilters = false;
235	HRESULT hrc = pHostDevice->i_onDetachFromVM(aMachine, aDone, &fRunFilters);
236
237	/*
238	* Run filters if necessary.
239	*/
240	if ( SUCCEEDED(hrc)
241	&& fRunFilters)
242	{
243	Assert(aDone && pHostDevice->i_getUnistate() == kHostUSBDeviceState_HeldByProxy && pHostDevice->i_getMachine().isNull());
244	devLock.release();
245	alock.release();
246	HRESULT hrc2 = runAllFiltersOnDevice(pHostDevice, llOpenedMachines, aMachine);
247	ComAssertComRC(hrc2);
248	}
249	return hrc;
250	}
251
252
253	/**
254	* Apply filters for the machine to all eligible USB devices.
255	*
256	* This is in an interface for SessionMachine::CaptureUSBDevice(), which
257	* is an internal worker used by Console::AutoCaptureUSBDevices() from the
258	* VM process at VM startup.
259	*
260	* Matching devices will be attached to the VM and may result IPC back
261	* to the VM process via SessionMachine::onUSBDeviceAttach() depending
262	* on whether the device needs to be captured or not. If capture is
263	* required, SessionMachine::onUSBDeviceAttach() will be called
264	* asynchronously by the USB proxy service thread.
265	*
266	* @param aMachine The machine to capture devices for.
267	*
268	* @returns COM status code, perhaps with error info.
269	*
270	* @remarks Temporarily locks this object, the machine object and some USB
271	* device, and the called methods will lock similar objects.
272	*/
273	HRESULT USBProxyService::autoCaptureDevicesForVM(SessionMachine *aMachine)
274	{
275	LogFlowThisFunc(("aMachine=%p{%s}\n",
276	aMachine,
277	aMachine->i_getName().c_str()));
278
279	/*
280	* Make a copy of the list because we cannot hold the lock protecting it.
281	* (This will not make copies of any HostUSBDevice objects, only reference them.)
282	*/
283	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
284	HostUSBDeviceList ListCopy = mDevices;
285	alock.release();
286
287	for (HostUSBDeviceList::iterator it = ListCopy.begin();
288	it != ListCopy.end();
289	++it)
290	{
291	ComObjPtr<HostUSBDevice> device = *it;
292	AutoReadLock devLock(device COMMA_LOCKVAL_SRC_POS);
293	if ( device->i_getUnistate() == kHostUSBDeviceState_HeldByProxy
294	\|\| device->i_getUnistate() == kHostUSBDeviceState_Unused
295	\|\| device->i_getUnistate() == kHostUSBDeviceState_Capturable)
296	{
297	devLock.release();
298	runMachineFilters(aMachine, device);
299	}
300	}
301
302	return S_OK;
303	}
304
305
306	/**
307	* Detach all USB devices currently attached to a VM.
308	*
309	* This is in an interface for SessionMachine::DetachAllUSBDevices(), which
310	* is an internal worker used by Console::powerDown() from the VM process
311	* at VM startup, and SessionMachine::uninit() at VM abend.
312	*
313	* This is, like #detachDeviceFromVM(), normally a two stage journey
314	* where \a aDone indicates where we are. In addition we may be called
315	* to clean up VMs that have abended, in which case there will be no
316	* preparatory call. Filters will be applied to the devices in the final
317	* call with the risk that we have to do some IPC when attaching them
318	* to other VMs.
319	*
320	* @param aMachine The machine to detach devices from.
321	*
322	* @returns COM status code, perhaps with error info.
323	*
324	* @remarks Write locks the host object and may temporarily abandon
325	* its locks to perform IPC.
326	*/
327	HRESULT USBProxyService::detachAllDevicesFromVM(SessionMachine *aMachine, bool aDone, bool aAbnormal)
328	{
329	// get a list of all running machines while we're outside the lock
330	// (getOpenedMachines requests locks which are incompatible with the host object lock)
331	SessionMachinesList llOpenedMachines;
332	mHost->i_parent()->i_getOpenedMachines(llOpenedMachines);
333
334	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
335
336	/*
337	* Make a copy of the device list (not the HostUSBDevice objects, just
338	* the list) since we may end up performing IPC and temporarily have
339	* to abandon locks when applying filters.
340	*/
341	HostUSBDeviceList ListCopy = mDevices;
342
343	for (HostUSBDeviceList::iterator it = ListCopy.begin();
344	it != ListCopy.end();
345	++it)
346	{
347	ComObjPtr<HostUSBDevice> pHostDevice = *it;
348	AutoWriteLock devLock(pHostDevice COMMA_LOCKVAL_SRC_POS);
349	if (pHostDevice->i_getMachine() == aMachine)
350	{
351	/*
352	* Same procedure as in detachUSBDevice().
353	*/
354	bool fRunFilters = false;
355	HRESULT hrc = pHostDevice->i_onDetachFromVM(aMachine, aDone, &fRunFilters, aAbnormal);
356	if ( SUCCEEDED(hrc)
357	&& fRunFilters)
358	{
359	Assert( aDone
360	&& pHostDevice->i_getUnistate() == kHostUSBDeviceState_HeldByProxy
361	&& pHostDevice->i_getMachine().isNull());
362	devLock.release();
363	alock.release();
364	HRESULT hrc2 = runAllFiltersOnDevice(pHostDevice, llOpenedMachines, aMachine);
365	ComAssertComRC(hrc2);
366	alock.acquire();
367	}
368	}
369	}
370
371	return S_OK;
372	}
373
374
375	/**
376	* Runs all the filters on the specified device.
377	*
378	* All filters mean global and active VM, with the exception of those
379	* belonging to \a aMachine. If a global ignore filter matched or if
380	* none of the filters matched, the device will be released back to
381	* the host.
382	*
383	* The device calling us here will be in the HeldByProxy, Unused, or
384	* Capturable state. The caller is aware that locks held might have
385	* to be abandond because of IPC and that the device might be in
386	* almost any state upon return.
387	*
388	*
389	* @returns COM status code (only parameter & state checks will fail).
390	* @param aDevice The USB device to apply filters to.
391	* @param aIgnoreMachine The machine to ignore filters from (we've just
392	* detached the device from this machine).
393	*
394	* @note The caller is expected to own no locks.
395	*/
396	HRESULT USBProxyService::runAllFiltersOnDevice(ComObjPtr<HostUSBDevice> &aDevice,
397	SessionMachinesList &llOpenedMachines,
398	SessionMachine *aIgnoreMachine)
399	{
400	LogFlowThisFunc(("{%s} ignoring=%p\n", aDevice->i_getName().c_str(), aIgnoreMachine));
401
402	/*
403	* Verify preconditions.
404	*/
405	AssertReturn(!isWriteLockOnCurrentThread(), E_FAIL);
406	AssertReturn(!aDevice->isWriteLockOnCurrentThread(), E_FAIL);
407	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
408	AutoWriteLock devLock(aDevice COMMA_LOCKVAL_SRC_POS);
409	AssertMsgReturn(aDevice->i_isCapturableOrHeld(), ("{%s} %s\n", aDevice->i_getName().c_str(),
410	aDevice->i_getStateName()), E_FAIL);
411
412	/*
413	* Get the lists we'll iterate.
414	*/
415	Host::USBDeviceFilterList globalFilters;
416
417	mHost->i_getUSBFilters(&globalFilters);
418
419	/*
420	* Run global filters filters first.
421	*/
422	bool fHoldIt = false;
423	for (Host::USBDeviceFilterList::const_iterator it = globalFilters.begin();
424	it != globalFilters.end();
425	++it)
426	{
427	AutoWriteLock filterLock(*it COMMA_LOCKVAL_SRC_POS);
428	const HostUSBDeviceFilter::Data &data = (*it)->i_getData();
429	if (aDevice->i_isMatch(data))
430	{
431	USBDeviceFilterAction_T action = USBDeviceFilterAction_Null;
432	(*it)->COMGETTER(Action)(&action);
433	if (action == USBDeviceFilterAction_Ignore)
434	{
435	/*
436	* Release the device to the host and we're done.
437	*/
438	filterLock.release();
439	devLock.release();
440	alock.release();
441	aDevice->i_requestReleaseToHost();
442	return S_OK;
443	}
444	if (action == USBDeviceFilterAction_Hold)
445	{
446	/*
447	* A device held by the proxy needs to be subjected
448	* to the machine filters.
449	*/
450	fHoldIt = true;
451	break;
452	}
453	AssertMsgFailed(("action=%d\n", action));
454	}
455	}
456	globalFilters.clear();
457
458	/*
459	* Run the per-machine filters.
460	*/
461	for (SessionMachinesList::const_iterator it = llOpenedMachines.begin();
462	it != llOpenedMachines.end();
463	++it)
464	{
465	ComObjPtr<SessionMachine> pMachine = *it;
466
467	/* Skip the machine the device was just detached from. */
468	if ( aIgnoreMachine
469	&& pMachine == aIgnoreMachine)
470	continue;
471
472	/* runMachineFilters takes care of checking the machine state. */
473	devLock.release();
474	alock.release();
475	if (runMachineFilters(pMachine, aDevice))
476	{
477	LogFlowThisFunc(("{%s} attached to %p\n", aDevice->i_getName().c_str(), (void *)pMachine));
478	return S_OK;
479	}
480	alock.acquire();
481	devLock.acquire();
482	}
483
484	/*
485	* No matching machine, so request hold or release depending
486	* on global filter match.
487	*/
488	devLock.release();
489	alock.release();
490	if (fHoldIt)
491	aDevice->i_requestHold();
492	else
493	aDevice->i_requestReleaseToHost();
494	return S_OK;
495	}
496
497
498	/**
499	* Runs the USB filters of the machine on the device.
500	*
501	* If a match is found we will request capture for VM. This may cause
502	* us to temporary abandon locks while doing IPC.
503	*
504	* @param aMachine Machine whose filters are to be run.
505	* @param aDevice The USB device in question.
506	* @returns @c true if the device has been or is being attached to the VM, @c false otherwise.
507	*
508	* @note Locks several objects temporarily for reading or writing.
509	*/
510	bool USBProxyService::runMachineFilters(SessionMachine *aMachine, ComObjPtr<HostUSBDevice> &aDevice)
511	{
512	LogFlowThisFunc(("{%s} aMachine=%p \n", aDevice->i_getName().c_str(), aMachine));
513
514	/*
515	* Validate preconditions.
516	*/
517	AssertReturn(aMachine, false);
518	AssertReturn(!isWriteLockOnCurrentThread(), false);
519	AssertReturn(!aMachine->isWriteLockOnCurrentThread(), false);
520	AssertReturn(!aDevice->isWriteLockOnCurrentThread(), false);
521	/* Let HostUSBDevice::requestCaptureToVM() validate the state. */
522
523	/*
524	* Do the job.
525	*/
526	ULONG ulMaskedIfs;
527	if (aMachine->i_hasMatchingUSBFilter(aDevice, &ulMaskedIfs))
528	{
529	/* try to capture the device */
530	HRESULT hrc = aDevice->i_requestCaptureForVM(aMachine, false /* aSetError */, Utf8Str(), ulMaskedIfs);
531	return SUCCEEDED(hrc)
532	\|\| hrc == E_UNEXPECTED /* bad device state, give up */;
533	}
534
535	return false;
536	}
537
538
539	/**
540	* A filter was inserted / loaded.
541	*
542	* @param aFilter Pointer to the inserted filter.
543	* @return ID of the inserted filter
544	*/
545	void *USBProxyService::insertFilter(PCUSBFILTER aFilter)
546	{
547	// return non-NULL to fake success.
548	NOREF(aFilter);
549	return (void *)1;
550	}
551
552
553	/**
554	* A filter was removed.
555	*
556	* @param aId ID of the filter to remove
557	*/
558	void USBProxyService::removeFilter(void *aId)
559	{
560	NOREF(aId);
561	}
562
563
564	/**
565	* A VM is trying to capture a device, do necessary preparations.
566	*
567	* @returns VBox status code.
568	* @param aDevice The device in question.
569	*/
570	int USBProxyService::captureDevice(HostUSBDevice *aDevice)
571	{
572	NOREF(aDevice);
573	return VERR_NOT_IMPLEMENTED;
574	}
575
576
577	/**
578	* Notification that an async captureDevice() operation completed.
579	*
580	* This is used by the proxy to release temporary filters.
581	*
582	* @returns VBox status code.
583	* @param aDevice The device in question.
584	* @param aSuccess Whether it succeeded or failed.
585	*/
586	void USBProxyService::captureDeviceCompleted(HostUSBDevice *aDevice, bool aSuccess)
587	{
588	NOREF(aDevice);
589	NOREF(aSuccess);
590	}
591
592
593	/**
594	* The device is going to be detached from a VM.
595	*
596	* @param aDevice The device in question.
597	*
598	* @todo unused
599	*/
600	void USBProxyService::detachingDevice(HostUSBDevice *aDevice)
601	{
602	NOREF(aDevice);
603	}
604
605
606	/**
607	* A VM is releasing a device back to the host.
608	*
609	* @returns VBox status code.
610	* @param aDevice The device in question.
611	*/
612	int USBProxyService::releaseDevice(HostUSBDevice *aDevice)
613	{
614	NOREF(aDevice);
615	return VERR_NOT_IMPLEMENTED;
616	}
617
618
619	/**
620	* Notification that an async releaseDevice() operation completed.
621	*
622	* This is used by the proxy to release temporary filters.
623	*
624	* @returns VBox status code.
625	* @param aDevice The device in question.
626	* @param aSuccess Whether it succeeded or failed.
627	*/
628	void USBProxyService::releaseDeviceCompleted(HostUSBDevice *aDevice, bool aSuccess)
629	{
630	NOREF(aDevice);
631	NOREF(aSuccess);
632	}
633
634
635	// Internals
636	/////////////////////////////////////////////////////////////////////////////
637
638
639	/**
640	* Starts the service.
641	*
642	* @returns VBox status.
643	*/
644	int USBProxyService::start(void)
645	{
646	int rc = VINF_SUCCESS;
647	if (mThread == NIL_RTTHREAD)
648	{
649	/*
650	* Force update before starting the poller thread.
651	*/
652	rc = wait(0);
653	if (rc == VERR_TIMEOUT \|\| rc == VERR_INTERRUPTED \|\| RT_SUCCESS(rc))
654	{
655	processChanges();
656
657	/*
658	* Create the poller thread which will look for changes.
659	*/
660	mTerminate = false;
661	rc = RTThreadCreate(&mThread, USBProxyService::serviceThread, this,
662	0, RTTHREADTYPE_INFREQUENT_POLLER, RTTHREADFLAGS_WAITABLE, "USBPROXY");
663	AssertRC(rc);
664	if (RT_SUCCESS(rc))
665	LogFlowThisFunc(("started mThread=%RTthrd\n", mThread));
666	else
667	mThread = NIL_RTTHREAD;
668	}
669	mLastError = rc;
670	}
671	else
672	LogFlowThisFunc(("already running, mThread=%RTthrd\n", mThread));
673	return rc;
674	}
675
676
677	/**
678	* Stops the service.
679	*
680	* @returns VBox status.
681	*/
682	int USBProxyService::stop(void)
683	{
684	int rc = VINF_SUCCESS;
685	if (mThread != NIL_RTTHREAD)
686	{
687	/*
688	* Mark the thread for termination and kick it.
689	*/
690	ASMAtomicXchgSize(&mTerminate, true);
691	rc = interruptWait();
692	AssertRC(rc);
693
694	/*
695	* Wait for the thread to finish and then update the state.
696	*/
697	rc = RTThreadWait(mThread, 60000, NULL);
698	if (rc == VERR_INVALID_HANDLE)
699	rc = VINF_SUCCESS;
700	if (RT_SUCCESS(rc))
701	{
702	LogFlowThisFunc(("stopped mThread=%RTthrd\n", mThread));
703	mThread = NIL_RTTHREAD;
704	mTerminate = false;
705	}
706	else
707	{
708	AssertRC(rc);
709	mLastError = rc;
710	}
711	}
712	else
713	LogFlowThisFunc(("not active\n"));
714
715	return rc;
716	}
717
718
719	/**
720	* The service thread created by start().
721	*
722	* @param Thread The thread handle.
723	* @param pvUser Pointer to the USBProxyService instance.
724	*/
725	/static/ DECLCALLBACK(int) USBProxyService::serviceThread(RTTHREAD /* Thread /, void pvUser)
726	{
727	USBProxyService pThis = (USBProxyService )pvUser;
728	LogFlowFunc(("pThis=%p\n", pThis));
729	pThis->serviceThreadInit();
730	int rc = VINF_SUCCESS;
731
732	/*
733	* Processing loop.
734	*/
735	for (;;)
736	{
737	rc = pThis->wait(RT_INDEFINITE_WAIT);
738	if (RT_FAILURE(rc) && rc != VERR_INTERRUPTED && rc != VERR_TIMEOUT)
739	break;
740	if (pThis->mTerminate)
741	break;
742	pThis->processChanges();
743	}
744
745	pThis->serviceThreadTerm();
746	LogFlowFunc(("returns %Rrc\n", rc));
747	return rc;
748	}
749
750
751	/**
752	* First call made on the service thread, use it to do
753	* thread initialization.
754	*
755	* The default implementation in USBProxyService just a dummy stub.
756	*/
757	void USBProxyService::serviceThreadInit(void)
758	{
759	}
760
761
762	/**
763	* Last call made on the service thread, use it to do
764	* thread termination.
765	*/
766	void USBProxyService::serviceThreadTerm(void)
767	{
768	}
769
770
771	/**
772	* Wait for a change in the USB devices attached to the host.
773	*
774	* The default implementation in USBProxyService just a dummy stub.
775	*
776	* @returns VBox status code. VERR_INTERRUPTED and VERR_TIMEOUT are considered
777	* harmless, while all other error status are fatal.
778	* @param aMillies Number of milliseconds to wait.
779	*/
780	int USBProxyService::wait(RTMSINTERVAL aMillies)
781	{
782	return RTThreadSleep(RT_MIN(aMillies, 250));
783	}
784
785
786	/**
787	* Interrupt any wait() call in progress.
788	*
789	* The default implementation in USBProxyService just a dummy stub.
790	*
791	* @returns VBox status.
792	*/
793	int USBProxyService::interruptWait(void)
794	{
795	return VERR_NOT_IMPLEMENTED;
796	}
797
798
799	/**
800	* Sort a list of USB devices.
801	*
802	* @returns Pointer to the head of the sorted doubly linked list.
803	* @param aDevices Head pointer (can be both singly and doubly linked list).
804	*/
805	static PUSBDEVICE sortDevices(PUSBDEVICE pDevices)
806	{
807	PUSBDEVICE pHead = NULL;
808	PUSBDEVICE pTail = NULL;
809	while (pDevices)
810	{
811	/* unlink head */
812	PUSBDEVICE pDev = pDevices;
813	pDevices = pDev->pNext;
814	if (pDevices)
815	pDevices->pPrev = NULL;
816
817	/* find location. */
818	PUSBDEVICE pCur = pTail;
819	while ( pCur
820	&& HostUSBDevice::i_compare(pCur, pDev) > 0)
821	pCur = pCur->pPrev;
822
823	/* insert (after pCur) */
824	pDev->pPrev = pCur;
825	if (pCur)
826	{
827	pDev->pNext = pCur->pNext;
828	pCur->pNext = pDev;
829	if (pDev->pNext)
830	pDev->pNext->pPrev = pDev;
831	else
832	pTail = pDev;
833	}
834	else
835	{
836	pDev->pNext = pHead;
837	if (pHead)
838	pHead->pPrev = pDev;
839	else
840	pTail = pDev;
841	pHead = pDev;
842	}
843	}
844
845	LogFlowFuncLeave();
846	return pHead;
847	}
848
849
850	/**
851	* Process any relevant changes in the attached USB devices.
852	*
853	* Except for the first call, this is always running on the service thread.
854	*/
855	void USBProxyService::processChanges(void)
856	{
857	LogFlowThisFunc(("\n"));
858
859	/*
860	* Get the sorted list of USB devices.
861	*/
862	PUSBDEVICE pDevices = getDevices();
863	pDevices = sortDevices(pDevices);
864
865	// get a list of all running machines while we're outside the lock
866	// (getOpenedMachines requests higher priority locks)
867	SessionMachinesList llOpenedMachines;
868	mHost->i_parent()->i_getOpenedMachines(llOpenedMachines);
869
870	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
871
872	/*
873	* Compare previous list with the new list of devices
874	* and merge in any changes while notifying Host.
875	*/
876	HostUSBDeviceList::iterator it = this->mDevices.begin();
877	while ( it != mDevices.end()
878	\|\| pDevices)
879	{
880	ComObjPtr<HostUSBDevice> pHostDevice;
881
882	if (it != mDevices.end())
883	pHostDevice = *it;
884
885	/*
886	* Assert that the object is still alive (we still reference it in
887	* the collection and we're the only one who calls uninit() on it.
888	*/
889	AutoCaller devCaller(pHostDevice.isNull() ? NULL : pHostDevice);
890	AssertComRC(devCaller.rc());
891
892	/*
893	* Lock the device object since we will read/write its
894	* properties. All Host callbacks also imply the object is locked.
895	*/
896	AutoWriteLock devLock(pHostDevice.isNull() ? NULL : pHostDevice
897	COMMA_LOCKVAL_SRC_POS);
898
899	/*
900	* Compare.
901	*/
902	int iDiff;
903	if (pHostDevice.isNull())
904	iDiff = 1;
905	else
906	{
907	if (!pDevices)
908	iDiff = -1;
909	else
910	iDiff = pHostDevice->i_compare(pDevices);
911	}
912	if (!iDiff)
913	{
914	/*
915	* The device still there, update the state and move on. The PUSBDEVICE
916	* structure is eaten by updateDeviceState / HostUSBDevice::updateState().
917	*/
918	PUSBDEVICE pCur = pDevices;
919	pDevices = pDevices->pNext;
920	pCur->pPrev = pCur->pNext = NULL;
921
922	bool fRunFilters = false;
923	SessionMachine *pIgnoreMachine = NULL;
924	devLock.release();
925	alock.release();
926	if (updateDeviceState(pHostDevice, pCur, &fRunFilters, &pIgnoreMachine))
927	deviceChanged(pHostDevice,
928	(fRunFilters ? &llOpenedMachines : NULL),
929	pIgnoreMachine);
930	alock.acquire();
931	it++;
932	}
933	else
934	{
935	if (iDiff > 0)
936	{
937	/*
938	* Head of pDevices was attached.
939	*/
940	PUSBDEVICE pNew = pDevices;
941	pDevices = pDevices->pNext;
942	pNew->pPrev = pNew->pNext = NULL;
943
944	ComObjPtr<HostUSBDevice> NewObj;
945	NewObj.createObject();
946	NewObj->init(pNew, this);
947	Log(("USBProxyService::processChanges: attached %p {%s} %s / %p:{.idVendor=%#06x, .idProduct=%#06x, .pszProduct=\"%s\", .pszManufacturer=\"%s\"}\n",
948	(HostUSBDevice *)NewObj,
949	NewObj->i_getName().c_str(),
950	NewObj->i_getStateName(),
951	pNew,
952	pNew->idVendor,
953	pNew->idProduct,
954	pNew->pszProduct,
955	pNew->pszManufacturer));
956
957	mDevices.insert(it, NewObj);
958
959	devLock.release();
960	alock.release();
961	deviceAdded(NewObj, llOpenedMachines, pNew);
962	alock.acquire();
963	}
964	else
965	{
966	/*
967	* Check if the device was actually detached or logically detached
968	* as the result of a re-enumeration.
969	*/
970	if (!pHostDevice->i_wasActuallyDetached())
971	it++;
972	else
973	{
974	it = mDevices.erase(it);
975	devLock.release();
976	alock.release();
977	deviceRemoved(pHostDevice);
978	Log(("USBProxyService::processChanges: detached %p {%s}\n",
979	(HostUSBDevice *)pHostDevice,
980	pHostDevice->i_getName().c_str()));
981
982	/* from now on, the object is no more valid,
983	* uninitialize to avoid abuse */
984	devCaller.release();
985	pHostDevice->uninit();
986	alock.acquire();
987	}
988	}
989	}
990	} /* while */
991
992	LogFlowThisFunc(("returns void\n"));
993	}
994
995
996	/**
997	* Get a list of USB device currently attached to the host.
998	*
999	* The default implementation in USBProxyService just a dummy stub.
1000	*
1001	* @returns Pointer to a list of USB devices.
1002	* The list nodes are freed individually by calling freeDevice().
1003	*/
1004	PUSBDEVICE USBProxyService::getDevices(void)
1005	{
1006	return NULL;
1007	}
1008
1009
1010	/**
1011	* Performs the required actions when a device has been added.
1012	*
1013	* This means things like running filters and subsequent capturing and
1014	* VM attaching. This may result in IPC and temporary lock abandonment.
1015	*
1016	* @param aDevice The device in question.
1017	* @param aUSBDevice The USB device structure.
1018	*/
1019	void USBProxyService::deviceAdded(ComObjPtr<HostUSBDevice> &aDevice,
1020	SessionMachinesList &llOpenedMachines,
1021	PUSBDEVICE aUSBDevice)
1022	{
1023	/*
1024	* Validate preconditions.
1025	*/
1026	AssertReturnVoid(!isWriteLockOnCurrentThread());
1027	AssertReturnVoid(!aDevice->isWriteLockOnCurrentThread());
1028	AutoReadLock devLock(aDevice COMMA_LOCKVAL_SRC_POS);
1029	LogFlowThisFunc(("aDevice=%p name={%s} state=%s id={%RTuuid}\n",
1030	(HostUSBDevice *)aDevice,
1031	aDevice->i_getName().c_str(),
1032	aDevice->i_getStateName(),
1033	aDevice->i_getId().raw()));
1034
1035	/*
1036	* Run filters on the device.
1037	*/
1038	if (aDevice->i_isCapturableOrHeld())
1039	{
1040	devLock.release();
1041	HRESULT rc = runAllFiltersOnDevice(aDevice, llOpenedMachines, NULL /* aIgnoreMachine */);
1042	AssertComRC(rc);
1043	}
1044
1045	NOREF(aUSBDevice);
1046	}
1047
1048
1049	/**
1050	* Remove device notification hook for the OS specific code.
1051	*
1052	* This is means things like
1053	*
1054	* @param aDevice The device in question.
1055	*/
1056	void USBProxyService::deviceRemoved(ComObjPtr<HostUSBDevice> &aDevice)
1057	{
1058	/*
1059	* Validate preconditions.
1060	*/
1061	AssertReturnVoid(!isWriteLockOnCurrentThread());
1062	AssertReturnVoid(!aDevice->isWriteLockOnCurrentThread());
1063	AutoWriteLock devLock(aDevice COMMA_LOCKVAL_SRC_POS);
1064	LogFlowThisFunc(("aDevice=%p name={%s} state=%s id={%RTuuid}\n",
1065	(HostUSBDevice *)aDevice,
1066	aDevice->i_getName().c_str(),
1067	aDevice->i_getStateName(),
1068	aDevice->i_getId().raw()));
1069
1070	/*
1071	* Detach the device from any machine currently using it,
1072	* reset all data and uninitialize the device object.
1073	*/
1074	devLock.release();
1075	aDevice->i_onPhysicalDetached();
1076	}
1077
1078
1079	/**
1080	* Implement fake capture, ++.
1081	*
1082	* @returns true if there is a state change.
1083	* @param pDevice The device in question.
1084	* @param pUSBDevice The USB device structure for the last enumeration.
1085	* @param aRunFilters Whether or not to run filters.
1086	*/
1087	bool USBProxyService::updateDeviceStateFake(HostUSBDevice aDevice, PUSBDEVICE aUSBDevice, bool aRunFilters,
1088	SessionMachine **aIgnoreMachine)
1089	{
1090	*aRunFilters = false;
1091	*aIgnoreMachine = NULL;
1092	AssertReturn(aDevice, false);
1093	AssertReturn(!aDevice->isWriteLockOnCurrentThread(), false);
1094
1095	/*
1096	* Just hand it to the device, it knows best what needs to be done.
1097	*/
1098	return aDevice->i_updateStateFake(aUSBDevice, aRunFilters, aIgnoreMachine);
1099	}
1100
1101
1102	/**
1103	* Updates the device state.
1104	*
1105	* This is responsible for calling HostUSBDevice::updateState().
1106	*
1107	* @returns true if there is a state change.
1108	* @param aDevice The device in question.
1109	* @param aUSBDevice The USB device structure for the last enumeration.
1110	* @param aRunFilters Whether or not to run filters.
1111	* @param aIgnoreMachine Machine to ignore when running filters.
1112	*/
1113	bool USBProxyService::updateDeviceState(HostUSBDevice aDevice, PUSBDEVICE aUSBDevice, bool aRunFilters,
1114	SessionMachine **aIgnoreMachine)
1115	{
1116	AssertReturn(aDevice, false);
1117	AssertReturn(!aDevice->isWriteLockOnCurrentThread(), false);
1118
1119	return aDevice->i_updateState(aUSBDevice, aRunFilters, aIgnoreMachine);
1120	}
1121
1122
1123	/**
1124	* Handle a device which state changed in some significant way.
1125	*
1126	* This means things like running filters and subsequent capturing and
1127	* VM attaching. This may result in IPC and temporary lock abandonment.
1128	*
1129	* @param aDevice The device.
1130	* @param pllOpenedMachines list of running session machines (VirtualBox::getOpenedMachines()); if NULL, we don't run filters
1131	* @param aIgnoreMachine Machine to ignore when running filters.
1132	*/
1133	void USBProxyService::deviceChanged(ComObjPtr<HostUSBDevice> &aDevice, SessionMachinesList *pllOpenedMachines,
1134	SessionMachine *aIgnoreMachine)
1135	{
1136	/*
1137	* Validate preconditions.
1138	*/
1139	AssertReturnVoid(!isWriteLockOnCurrentThread());
1140	AssertReturnVoid(!aDevice->isWriteLockOnCurrentThread());
1141	AutoReadLock devLock(aDevice COMMA_LOCKVAL_SRC_POS);
1142	LogFlowThisFunc(("aDevice=%p name={%s} state=%s id={%RTuuid} aRunFilters=%RTbool aIgnoreMachine=%p\n",
1143	(HostUSBDevice *)aDevice,
1144	aDevice->i_getName().c_str(),
1145	aDevice->i_getStateName(),
1146	aDevice->i_getId().raw(),
1147	(pllOpenedMachines != NULL), // used to be "bool aRunFilters"
1148	aIgnoreMachine));
1149	devLock.release();
1150
1151	/*
1152	* Run filters if requested to do so.
1153	*/
1154	if (pllOpenedMachines)
1155	{
1156	HRESULT rc = runAllFiltersOnDevice(aDevice, *pllOpenedMachines, aIgnoreMachine);
1157	AssertComRC(rc);
1158	}
1159	}
1160
1161
1162
1163	/**
1164	* Free all the members of a USB device returned by getDevice().
1165	*
1166	* @param pDevice Pointer to the device.
1167	*/
1168	/static/ void
1169	USBProxyService::freeDeviceMembers(PUSBDEVICE pDevice)
1170	{
1171	RTStrFree((char *)pDevice->pszManufacturer);
1172	pDevice->pszManufacturer = NULL;
1173	RTStrFree((char *)pDevice->pszProduct);
1174	pDevice->pszProduct = NULL;
1175	RTStrFree((char *)pDevice->pszSerialNumber);
1176	pDevice->pszSerialNumber = NULL;
1177
1178	RTStrFree((char *)pDevice->pszAddress);
1179	pDevice->pszAddress = NULL;
1180	#ifdef RT_OS_WINDOWS
1181	RTStrFree(pDevice->pszAltAddress);
1182	pDevice->pszAltAddress = NULL;
1183	RTStrFree(pDevice->pszHubName);
1184	pDevice->pszHubName = NULL;
1185	#elif defined(RT_OS_SOLARIS)
1186	RTStrFree(pDevice->pszDevicePath);
1187	pDevice->pszDevicePath = NULL;
1188	#endif
1189	}
1190
1191
1192	/**
1193	* Free one USB device returned by getDevice().
1194	*
1195	* @param pDevice Pointer to the device.
1196	*/
1197	/static/ void
1198	USBProxyService::freeDevice(PUSBDEVICE pDevice)
1199	{
1200	freeDeviceMembers(pDevice);
1201	RTMemFree(pDevice);
1202	}
1203
1204
1205	/**
1206	* Initializes a filter with the data from the specified device.
1207	*
1208	* @param aFilter The filter to fill.
1209	* @param aDevice The device to fill it with.
1210	*/
1211	/static/ void
1212	USBProxyService::initFilterFromDevice(PUSBFILTER aFilter, HostUSBDevice *aDevice)
1213	{
1214	PCUSBDEVICE pDev = aDevice->mUsb;
1215	int vrc;
1216
1217	vrc = USBFilterSetNumExact(aFilter, USBFILTERIDX_VENDOR_ID, pDev->idVendor, true); AssertRC(vrc);
1218	vrc = USBFilterSetNumExact(aFilter, USBFILTERIDX_PRODUCT_ID, pDev->idProduct, true); AssertRC(vrc);
1219	vrc = USBFilterSetNumExact(aFilter, USBFILTERIDX_DEVICE_REV, pDev->bcdDevice, true); AssertRC(vrc);
1220	vrc = USBFilterSetNumExact(aFilter, USBFILTERIDX_DEVICE_CLASS, pDev->bDeviceClass, true); AssertRC(vrc);
1221	vrc = USBFilterSetNumExact(aFilter, USBFILTERIDX_DEVICE_SUB_CLASS, pDev->bDeviceSubClass, true); AssertRC(vrc);
1222	vrc = USBFilterSetNumExact(aFilter, USBFILTERIDX_DEVICE_PROTOCOL, pDev->bDeviceProtocol, true); AssertRC(vrc);
1223	vrc = USBFilterSetNumExact(aFilter, USBFILTERIDX_PORT, pDev->bPort, true); AssertRC(vrc);
1224	vrc = USBFilterSetNumExact(aFilter, USBFILTERIDX_BUS, pDev->bBus, true); AssertRC(vrc);
1225	if (pDev->pszSerialNumber)
1226	{
1227	vrc = USBFilterSetStringExact(aFilter, USBFILTERIDX_SERIAL_NUMBER_STR, pDev->pszSerialNumber, true);
1228	AssertRC(vrc);
1229	}
1230	if (pDev->pszProduct)
1231	{
1232	vrc = USBFilterSetStringExact(aFilter, USBFILTERIDX_PRODUCT_STR, pDev->pszProduct, true);
1233	AssertRC(vrc);
1234	}
1235	if (pDev->pszManufacturer)
1236	{
1237	vrc = USBFilterSetStringExact(aFilter, USBFILTERIDX_MANUFACTURER_STR, pDev->pszManufacturer, true);
1238	AssertRC(vrc);
1239	}
1240	}
1241
1242
1243	/**
1244	* Searches the list of devices (mDevices) for the given device.
1245	*
1246	*
1247	* @returns Smart pointer to the device on success, NULL otherwise.
1248	* @param aId The UUID of the device we're looking for.
1249	*/
1250	ComObjPtr<HostUSBDevice> USBProxyService::findDeviceById(IN_GUID aId)
1251	{
1252	Guid Id(aId);
1253	ComObjPtr<HostUSBDevice> Dev;
1254	for (HostUSBDeviceList::iterator it = mDevices.begin();
1255	it != mDevices.end();
1256	++it)
1257	if ((*it)->i_getId() == Id)
1258	{
1259	Dev = (*it);
1260	break;
1261	}
1262
1263	return Dev;
1264	}
1265
1266	/static/
1267	HRESULT USBProxyService::setError(HRESULT aResultCode, const char *aText, ...)
1268	{
1269	va_list va;
1270	va_start(va, aText);
1271	HRESULT rc = VirtualBoxBase::setErrorInternal(aResultCode,
1272	COM_IIDOF(IHost),
1273	"USBProxyService",
1274	Utf8StrFmt(aText, va),
1275	false /* aWarning*/,
1276	true /* aLogIt*/);
1277	va_end(va);
1278	return rc;
1279	}
1280
1281	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

source: vbox/trunk/src/VBox/Main/src-server/USBProxyService.cpp@ 55747

Download in other formats: