USBProxyBackend.cpp@ 70823

Last change on this file since 70823 was 69500, checked in by vboxsync, 7 years ago
*: scm --update-copyright-year
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 18.9 KB

Line
1	/* $Id: USBProxyBackend.cpp 69500 2017-10-28 15:14:05Z vboxsync $ */
2	/** @file
3	* VirtualBox USB Proxy Service (base) class.
4	*/
5
6	/*
7	* Copyright (C) 2006-2017 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 "USBProxyBackend.h"
19	#include "USBProxyService.h"
20	#include "HostUSBDeviceImpl.h"
21	#include "HostImpl.h"
22	#include "MachineImpl.h"
23	#include "VirtualBoxImpl.h"
24
25	#include "AutoCaller.h"
26	#include "Logging.h"
27
28	#include <VBox/com/array.h>
29	#include <VBox/err.h>
30	#include <iprt/asm.h>
31	#include <iprt/semaphore.h>
32	#include <iprt/thread.h>
33	#include <iprt/mem.h>
34	#include <iprt/string.h>
35
36
37	/**
38	* Empty constructor.
39	*/
40	USBProxyBackend::USBProxyBackend()
41	{
42	LogFlowThisFunc(("\n"));
43	}
44
45
46	/**
47	* Empty destructor.
48	*/
49	USBProxyBackend::~USBProxyBackend()
50	{
51	}
52
53
54	HRESULT USBProxyBackend::FinalConstruct()
55	{
56	return BaseFinalConstruct();
57	}
58
59	void USBProxyBackend::FinalRelease()
60	{
61	uninit();
62	BaseFinalRelease();
63	}
64
65	/**
66	* Stub needed as long as the class isn't virtual
67	*/
68	int USBProxyBackend::init(USBProxyService *pUsbProxyService, const com::Utf8Str &strId,
69	const com::Utf8Str &strAddress, bool fLoadingSettings)
70	{
71	RT_NOREF1(fLoadingSettings);
72
73	m_pUsbProxyService = pUsbProxyService;
74	mThread = NIL_RTTHREAD;
75	mTerminate = false;
76	unconst(m_strId) = strId;
77	m_cRefs = 0;
78	unconst(m_strAddress) = strAddress;
79
80	unconst(m_strBackend) = Utf8Str::Empty;
81
82	return VINF_SUCCESS;
83	}
84
85
86	void USBProxyBackend::uninit()
87	{
88	LogFlowThisFunc(("\n"));
89	Assert(mThread == NIL_RTTHREAD);
90	mTerminate = true;
91	m_pUsbProxyService = NULL;
92	m_llDevices.clear();
93	}
94
95	/**
96	* Query if the service is active and working.
97	*
98	* @returns true if the service is up running.
99	* @returns false if the service isn't running.
100	*/
101	bool USBProxyBackend::isActive(void)
102	{
103	return mThread != NIL_RTTHREAD;
104	}
105
106
107	/**
108	* Returns the ID of the instance.
109	*
110	* @returns ID string for the instance.
111	*/
112	const com::Utf8Str &USBProxyBackend::i_getId()
113	{
114	return m_strId;
115	}
116
117
118	/**
119	* Returns the address of the instance.
120	*
121	* @returns ID string for the instance.
122	*/
123	const com::Utf8Str &USBProxyBackend::i_getAddress()
124	{
125	return m_strAddress;
126	}
127
128
129	/**
130	* Returns the backend of the instance.
131	*
132	* @returns ID string for the instance.
133	*/
134	const com::Utf8Str &USBProxyBackend::i_getBackend()
135	{
136	return m_strBackend;
137	}
138
139	/**
140	* Returns the current reference counter for the backend.
141	*/
142	uint32_t USBProxyBackend::i_getRefCount()
143	{
144	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
145	return m_cRefs;
146	}
147
148
149	/**
150	* A filter was inserted / loaded.
151	*
152	* @param aFilter Pointer to the inserted filter.
153	* @return ID of the inserted filter
154	*/
155	void *USBProxyBackend::insertFilter(PCUSBFILTER aFilter)
156	{
157	// return non-NULL to fake success.
158	NOREF(aFilter);
159	return (void *)1;
160	}
161
162
163	/**
164	* A filter was removed.
165	*
166	* @param aId ID of the filter to remove
167	*/
168	void USBProxyBackend::removeFilter(void *aId)
169	{
170	NOREF(aId);
171	}
172
173
174	/**
175	* A VM is trying to capture a device, do necessary preparations.
176	*
177	* @returns VBox status code.
178	* @param aDevice The device in question.
179	*/
180	int USBProxyBackend::captureDevice(HostUSBDevice *aDevice)
181	{
182	NOREF(aDevice);
183	return VERR_NOT_IMPLEMENTED;
184	}
185
186
187	/**
188	* Notification that an async captureDevice() operation completed.
189	*
190	* This is used by the proxy to release temporary filters.
191	*
192	* @returns VBox status code.
193	* @param aDevice The device in question.
194	* @param aSuccess Whether it succeeded or failed.
195	*/
196	void USBProxyBackend::captureDeviceCompleted(HostUSBDevice *aDevice, bool aSuccess)
197	{
198	NOREF(aDevice);
199	NOREF(aSuccess);
200
201	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
202	incRef();
203	}
204
205
206	/**
207	* A VM is releasing a device back to the host.
208	*
209	* @returns VBox status code.
210	* @param aDevice The device in question.
211	*/
212	int USBProxyBackend::releaseDevice(HostUSBDevice *aDevice)
213	{
214	NOREF(aDevice);
215	return VERR_NOT_IMPLEMENTED;
216	}
217
218
219	/**
220	* Notification that an async releaseDevice() operation completed.
221	*
222	* This is used by the proxy to release temporary filters.
223	*
224	* @returns VBox status code.
225	* @param aDevice The device in question.
226	* @param aSuccess Whether it succeeded or failed.
227	*/
228	void USBProxyBackend::releaseDeviceCompleted(HostUSBDevice *aDevice, bool aSuccess)
229	{
230	NOREF(aDevice);
231	NOREF(aSuccess);
232
233	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
234	decRef();
235	}
236
237
238	bool USBProxyBackend::isFakeUpdateRequired()
239	{
240	return false;
241	}
242
243	/**
244	* Returns whether devices reported by this backend go through a de/re-attach
245	* and device re-enumeration cycle when they are captured or released.
246	*/
247	bool USBProxyBackend::i_isDevReEnumerationRequired()
248	{
249	return false;
250	}
251
252	// Internals
253	/////////////////////////////////////////////////////////////////////////////
254
255
256	/**
257	* Starts the service.
258	*
259	* @returns VBox status code.
260	*/
261	int USBProxyBackend::start(void)
262	{
263	int rc = VINF_SUCCESS;
264	if (mThread == NIL_RTTHREAD)
265	{
266	/*
267	* Force update before starting the poller thread.
268	*/
269	rc = wait(0);
270	if (rc == VERR_TIMEOUT \|\| rc == VERR_INTERRUPTED \|\| RT_SUCCESS(rc))
271	{
272	PUSBDEVICE pDevices = getDevices();
273	updateDeviceList(pDevices);
274
275	/*
276	* Create the poller thread which will look for changes.
277	*/
278	mTerminate = false;
279	rc = RTThreadCreate(&mThread, USBProxyBackend::serviceThread, this,
280	0, RTTHREADTYPE_INFREQUENT_POLLER, RTTHREADFLAGS_WAITABLE, "USBPROXY");
281	AssertRC(rc);
282	if (RT_SUCCESS(rc))
283	LogFlowThisFunc(("started mThread=%RTthrd\n", mThread));
284	else
285	mThread = NIL_RTTHREAD;
286	}
287	}
288	else
289	LogFlowThisFunc(("already running, mThread=%RTthrd\n", mThread));
290	return rc;
291	}
292
293
294	/**
295	* Stops the service.
296	*
297	* @returns VBox status code.
298	*/
299	int USBProxyBackend::stop(void)
300	{
301	int rc = VINF_SUCCESS;
302	if (mThread != NIL_RTTHREAD)
303	{
304	/*
305	* Mark the thread for termination and kick it.
306	*/
307	ASMAtomicXchgSize(&mTerminate, true);
308	rc = interruptWait();
309	AssertRC(rc);
310
311	/*
312	* Wait for the thread to finish and then update the state.
313	*/
314	rc = RTThreadWait(mThread, 60000, NULL);
315	if (rc == VERR_INVALID_HANDLE)
316	rc = VINF_SUCCESS;
317	if (RT_SUCCESS(rc))
318	{
319	LogFlowThisFunc(("stopped mThread=%RTthrd\n", mThread));
320	mThread = NIL_RTTHREAD;
321	mTerminate = false;
322	}
323	else
324	AssertRC(rc);
325	}
326	else
327	LogFlowThisFunc(("not active\n"));
328
329	/* Make sure there is no device from us in the list anymore. */
330	updateDeviceList(NULL);
331
332	return rc;
333	}
334
335
336	/**
337	* The service thread created by start().
338	*
339	* @param Thread The thread handle.
340	* @param pvUser Pointer to the USBProxyBackend instance.
341	*/
342	/static/ DECLCALLBACK(int) USBProxyBackend::serviceThread(RTTHREAD /* Thread /, void pvUser)
343	{
344	USBProxyBackend pThis = (USBProxyBackend )pvUser;
345	LogFlowFunc(("pThis=%p\n", pThis));
346	pThis->serviceThreadInit();
347	int rc = VINF_SUCCESS;
348
349	/*
350	* Processing loop.
351	*/
352	for (;;)
353	{
354	rc = pThis->wait(RT_INDEFINITE_WAIT);
355	if (RT_FAILURE(rc) && rc != VERR_INTERRUPTED && rc != VERR_TIMEOUT)
356	break;
357	if (pThis->mTerminate)
358	break;
359
360	PUSBDEVICE pDevices = pThis->getDevices();
361	pThis->updateDeviceList(pDevices);
362	}
363
364	pThis->serviceThreadTerm();
365	LogFlowFunc(("returns %Rrc\n", rc));
366	return rc;
367	}
368
369
370	/**
371	* First call made on the service thread, use it to do
372	* thread initialization.
373	*
374	* The default implementation in USBProxyBackend just a dummy stub.
375	*/
376	void USBProxyBackend::serviceThreadInit(void)
377	{
378	}
379
380
381	/**
382	* Last call made on the service thread, use it to do
383	* thread termination.
384	*/
385	void USBProxyBackend::serviceThreadTerm(void)
386	{
387	}
388
389
390	/**
391	* Wait for a change in the USB devices attached to the host.
392	*
393	* The default implementation in USBProxyBackend just a dummy stub.
394	*
395	* @returns VBox status code. VERR_INTERRUPTED and VERR_TIMEOUT are considered
396	* harmless, while all other error status are fatal.
397	* @param aMillies Number of milliseconds to wait.
398	*/
399	int USBProxyBackend::wait(RTMSINTERVAL aMillies)
400	{
401	return RTThreadSleep(RT_MIN(aMillies, 250));
402	}
403
404
405	/**
406	* Interrupt any wait() call in progress.
407	*
408	* The default implementation in USBProxyBackend just a dummy stub.
409	*
410	* @returns VBox status code.
411	*/
412	int USBProxyBackend::interruptWait(void)
413	{
414	return VERR_NOT_IMPLEMENTED;
415	}
416
417
418	/**
419	* Get a list of USB device currently attached to the host.
420	*
421	* The default implementation in USBProxyBackend just a dummy stub.
422	*
423	* @returns Pointer to a list of USB devices.
424	* The list nodes are freed individually by calling freeDevice().
425	*/
426	PUSBDEVICE USBProxyBackend::getDevices(void)
427	{
428	return NULL;
429	}
430
431
432	/**
433	* Increments the reference counter.
434	*
435	* @returns New reference count value.
436	*/
437	uint32_t USBProxyBackend::incRef()
438	{
439	Assert(isWriteLockOnCurrentThread());
440
441	return ++m_cRefs;
442	}
443
444	/**
445	* Decrements the reference counter.
446	*
447	* @returns New reference count value.
448	*/
449	uint32_t USBProxyBackend::decRef()
450	{
451	Assert(isWriteLockOnCurrentThread());
452
453	return --m_cRefs;
454	}
455
456
457	/**
458	* Free all the members of a USB device returned by getDevice().
459	*
460	* @param pDevice Pointer to the device.
461	*/
462	/static/ void
463	USBProxyBackend::freeDeviceMembers(PUSBDEVICE pDevice)
464	{
465	RTStrFree((char *)pDevice->pszManufacturer);
466	pDevice->pszManufacturer = NULL;
467	RTStrFree((char *)pDevice->pszProduct);
468	pDevice->pszProduct = NULL;
469	RTStrFree((char *)pDevice->pszSerialNumber);
470	pDevice->pszSerialNumber = NULL;
471
472	RTStrFree((char *)pDevice->pszAddress);
473	pDevice->pszAddress = NULL;
474	RTStrFree((char *)pDevice->pszBackend);
475	pDevice->pszBackend = NULL;
476	#ifdef RT_OS_WINDOWS
477	RTStrFree(pDevice->pszAltAddress);
478	pDevice->pszAltAddress = NULL;
479	RTStrFree(pDevice->pszHubName);
480	pDevice->pszHubName = NULL;
481	#elif defined(RT_OS_SOLARIS)
482	RTStrFree(pDevice->pszDevicePath);
483	pDevice->pszDevicePath = NULL;
484	#endif
485	}
486
487
488	/**
489	* Free one USB device returned by getDevice().
490	*
491	* @param pDevice Pointer to the device.
492	*/
493	/static/ void
494	USBProxyBackend::freeDevice(PUSBDEVICE pDevice)
495	{
496	freeDeviceMembers(pDevice);
497	RTMemFree(pDevice);
498	}
499
500	void USBProxyBackend::deviceAdded(ComObjPtr<HostUSBDevice> &aDevice, PUSBDEVICE pDev)
501	{
502	/* Nothing to do. */
503	NOREF(aDevice);
504	NOREF(pDev);
505	}
506
507	/**
508	* Initializes a filter with the data from the specified device.
509	*
510	* @param aFilter The filter to fill.
511	* @param aDevice The device to fill it with.
512	*/
513	/static/ void
514	USBProxyBackend::initFilterFromDevice(PUSBFILTER aFilter, HostUSBDevice *aDevice)
515	{
516	PCUSBDEVICE pDev = aDevice->i_getUsbData();
517	int vrc;
518
519	vrc = USBFilterSetNumExact(aFilter, USBFILTERIDX_VENDOR_ID, pDev->idVendor, true); AssertRC(vrc);
520	vrc = USBFilterSetNumExact(aFilter, USBFILTERIDX_PRODUCT_ID, pDev->idProduct, true); AssertRC(vrc);
521	vrc = USBFilterSetNumExact(aFilter, USBFILTERIDX_DEVICE_REV, pDev->bcdDevice, true); AssertRC(vrc);
522	vrc = USBFilterSetNumExact(aFilter, USBFILTERIDX_DEVICE_CLASS, pDev->bDeviceClass, true); AssertRC(vrc);
523	vrc = USBFilterSetNumExact(aFilter, USBFILTERIDX_DEVICE_SUB_CLASS, pDev->bDeviceSubClass, true); AssertRC(vrc);
524	vrc = USBFilterSetNumExact(aFilter, USBFILTERIDX_DEVICE_PROTOCOL, pDev->bDeviceProtocol, true); AssertRC(vrc);
525	vrc = USBFilterSetNumExact(aFilter, USBFILTERIDX_PORT, pDev->bPort, false); AssertRC(vrc);
526	vrc = USBFilterSetNumExact(aFilter, USBFILTERIDX_BUS, pDev->bBus, false); AssertRC(vrc);
527	if (pDev->pszSerialNumber)
528	{
529	vrc = USBFilterSetStringExact(aFilter, USBFILTERIDX_SERIAL_NUMBER_STR, pDev->pszSerialNumber,
530	true /fMustBePresent/, true /fPurge/);
531	AssertRC(vrc);
532	}
533	if (pDev->pszProduct)
534	{
535	vrc = USBFilterSetStringExact(aFilter, USBFILTERIDX_PRODUCT_STR, pDev->pszProduct,
536	true /fMustBePresent/, true /fPurge/);
537	AssertRC(vrc);
538	}
539	if (pDev->pszManufacturer)
540	{
541	vrc = USBFilterSetStringExact(aFilter, USBFILTERIDX_MANUFACTURER_STR, pDev->pszManufacturer,
542	true /fMustBePresent/, true /fPurge/);
543	AssertRC(vrc);
544	}
545	}
546
547	HRESULT USBProxyBackend::getName(com::Utf8Str &aName)
548	{
549	/* strId is constant during life time, no need to lock */
550	aName = m_strId;
551	return S_OK;
552	}
553
554	HRESULT USBProxyBackend::getType(com::Utf8Str &aType)
555	{
556	aType = Utf8Str::Empty;
557	return S_OK;
558	}
559
560	/**
561	* Sort a list of USB devices.
562	*
563	* @returns Pointer to the head of the sorted doubly linked list.
564	* @param pDevices Head pointer (can be both singly and doubly linked list).
565	*/
566	static PUSBDEVICE sortDevices(PUSBDEVICE pDevices)
567	{
568	PUSBDEVICE pHead = NULL;
569	PUSBDEVICE pTail = NULL;
570	while (pDevices)
571	{
572	/* unlink head */
573	PUSBDEVICE pDev = pDevices;
574	pDevices = pDev->pNext;
575	if (pDevices)
576	pDevices->pPrev = NULL;
577
578	/* find location. */
579	PUSBDEVICE pCur = pTail;
580	while ( pCur
581	&& HostUSBDevice::i_compare(pCur, pDev) > 0)
582	pCur = pCur->pPrev;
583
584	/* insert (after pCur) */
585	pDev->pPrev = pCur;
586	if (pCur)
587	{
588	pDev->pNext = pCur->pNext;
589	pCur->pNext = pDev;
590	if (pDev->pNext)
591	pDev->pNext->pPrev = pDev;
592	else
593	pTail = pDev;
594	}
595	else
596	{
597	pDev->pNext = pHead;
598	if (pHead)
599	pHead->pPrev = pDev;
600	else
601	pTail = pDev;
602	pHead = pDev;
603	}
604	}
605
606	LogFlowFuncLeave();
607	return pHead;
608	}
609
610
611	/**
612	* Process any relevant changes in the attached USB devices.
613	*
614	* This is called from any available USB proxy backends service thread when they discover
615	* a change.
616	*/
617	void USBProxyBackend::updateDeviceList(PUSBDEVICE pDevices)
618	{
619	LogFlowThisFunc(("\n"));
620
621	pDevices = sortDevices(pDevices);
622
623	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
624
625	/*
626	* Compare previous list with the new list of devices
627	* and merge in any changes while notifying Host.
628	*/
629	HostUSBDeviceList::iterator it = this->m_llDevices.begin();
630	while ( it != m_llDevices.end()
631	\|\| pDevices)
632	{
633	ComObjPtr<HostUSBDevice> pHostDevice;
634
635	if (it != m_llDevices.end())
636	pHostDevice = *it;
637
638	/*
639	* Assert that the object is still alive (we still reference it in
640	* the collection and we're the only one who calls uninit() on it.
641	*/
642	AutoCaller devCaller(pHostDevice.isNull() ? NULL : pHostDevice);
643	AssertComRC(devCaller.rc());
644
645	/*
646	* Lock the device object since we will read/write its
647	* properties. All Host callbacks also imply the object is locked.
648	*/
649	AutoWriteLock devLock(pHostDevice.isNull() ? NULL : pHostDevice
650	COMMA_LOCKVAL_SRC_POS);
651
652	/* We should never get devices from other backends here. */
653	Assert(pHostDevice.isNull() \|\| pHostDevice->i_getUsbProxyBackend() == this);
654
655	/*
656	* Compare.
657	*/
658	int iDiff;
659	if (pHostDevice.isNull())
660	iDiff = 1;
661	else
662	{
663	if (!pDevices)
664	iDiff = -1;
665	else
666	iDiff = pHostDevice->i_compare(pDevices);
667	}
668	if (!iDiff)
669	{
670	/*
671	* The device still there, update the state and move on. The PUSBDEVICE
672	* structure is eaten by updateDeviceState / HostUSBDevice::updateState().
673	*/
674	PUSBDEVICE pCur = pDevices;
675	pDevices = pDevices->pNext;
676	pCur->pPrev = pCur->pNext = NULL;
677
678	devLock.release();
679	alock.release();
680	m_pUsbProxyService->i_updateDeviceState(pHostDevice, pCur, isFakeUpdateRequired());
681	alock.acquire();
682	++it;
683	}
684	else
685	{
686	if (iDiff > 0)
687	{
688	/*
689	* Head of pDevices was attached.
690	*/
691	PUSBDEVICE pNew = pDevices;
692	pDevices = pDevices->pNext;
693	pNew->pPrev = pNew->pNext = NULL;
694
695	ComObjPtr<HostUSBDevice> NewObj;
696	NewObj.createObject();
697	NewObj->init(pNew, this);
698	LogFlowThisFunc(("attached %p {%s} %s / %p:{.idVendor=%#06x, .idProduct=%#06x, .pszProduct=\"%s\", .pszManufacturer=\"%s\"}\n",
699	(HostUSBDevice *)NewObj,
700	NewObj->i_getName().c_str(),
701	NewObj->i_getStateName(),
702	pNew,
703	pNew->idVendor,
704	pNew->idProduct,
705	pNew->pszProduct,
706	pNew->pszManufacturer));
707
708	m_llDevices.insert(it, NewObj);
709
710	devLock.release();
711	alock.release();
712	/* Do any backend specific work. */
713	deviceAdded(NewObj, pNew);
714	m_pUsbProxyService->i_deviceAdded(NewObj, pNew);
715	alock.acquire();
716	}
717	else
718	{
719	/*
720	* Check if the device was actually detached or logically detached
721	* as the result of a re-enumeration.
722	*/
723	if (!pHostDevice->i_wasActuallyDetached())
724	++it;
725	else
726	{
727	it = m_llDevices.erase(it);
728	devLock.release();
729	alock.release();
730	m_pUsbProxyService->i_deviceRemoved(pHostDevice);
731	LogFlowThisFunc(("detached %p {%s}\n",
732	(HostUSBDevice *)pHostDevice,
733	pHostDevice->i_getName().c_str()));
734
735	/* from now on, the object is no more valid,
736	* uninitialize to avoid abuse */
737	devCaller.release();
738	pHostDevice->uninit();
739	alock.acquire();
740	}
741	}
742	}
743	} /* while */
744
745	LogFlowThisFunc(("returns void\n"));
746	}
747
748	/* 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/USBProxyBackend.cpp@ 70823

Download in other formats: