USBControllerImpl.cpp@ 29532

Last change on this file since 29532 was 28800, checked in by vboxsync, 15 years ago
Automated rebranding to Oracle copyright/license strings via filemuncher
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 35.9 KB

Line
1	/* $Id: USBControllerImpl.cpp 28800 2010-04-27 08:22:32Z vboxsync $ */
2	/** @file
3	* Implementation of IUSBController.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 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 "USBControllerImpl.h"
19
20	#include "Global.h"
21	#include "MachineImpl.h"
22	#include "VirtualBoxImpl.h"
23	#include "HostImpl.h"
24	#ifdef VBOX_WITH_USB
25	# include "USBDeviceImpl.h"
26	# include "HostUSBDeviceImpl.h"
27	# include "USBProxyService.h"
28	#endif
29
30	#include <iprt/string.h>
31	#include <iprt/cpp/utils.h>
32
33	#include <VBox/err.h>
34	#include <VBox/settings.h>
35
36	#include <algorithm>
37
38	#include "AutoStateDep.h"
39	#include "AutoCaller.h"
40	#include "Logging.h"
41
42	// defines
43	/////////////////////////////////////////////////////////////////////////////
44
45	typedef std::list< ComObjPtr<USBDeviceFilter> > DeviceFilterList;
46
47	struct BackupableUSBData
48	{
49	BackupableUSBData()
50	: fEnabled(false),
51	fEnabledEHCI(false)
52	{ }
53
54	BOOL fEnabled;
55	BOOL fEnabledEHCI;
56	};
57
58	struct USBController::Data
59	{
60	Data()
61	: pParent(NULL)
62	{};
63
64	~Data()
65	{};
66
67	/** Parent object. */
68	Machine * const pParent;
69	/** Peer object. */
70	const ComObjPtr<USBController> pPeer;
71
72	Backupable<BackupableUSBData> bd;
73	#ifdef VBOX_WITH_USB
74	// the following fields need special backup/rollback/commit handling,
75	// so they cannot be a part of BackupableData
76	Backupable<DeviceFilterList> llDeviceFilters;
77	#endif
78	};
79
80
81
82	// constructor / destructor
83	/////////////////////////////////////////////////////////////////////////////
84
85	DEFINE_EMPTY_CTOR_DTOR (USBController)
86
87	HRESULT USBController::FinalConstruct()
88	{
89	return S_OK;
90	}
91
92	void USBController::FinalRelease()
93	{
94	uninit();
95	}
96
97	// public initializer/uninitializer for internal purposes only
98	/////////////////////////////////////////////////////////////////////////////
99
100	/**
101	* Initializes the USB controller object.
102	*
103	* @returns COM result indicator.
104	* @param aParent Pointer to our parent object.
105	*/
106	HRESULT USBController::init(Machine *aParent)
107	{
108	LogFlowThisFunc(("aParent=%p\n", aParent));
109
110	ComAssertRet(aParent, E_INVALIDARG);
111
112	/* Enclose the state transition NotReady->InInit->Ready */
113	AutoInitSpan autoInitSpan(this);
114	AssertReturn(autoInitSpan.isOk(), E_FAIL);
115
116	m = new Data();
117
118	unconst(m->pParent) = aParent;
119	/* mPeer is left null */
120
121	m->bd.allocate();
122	#ifdef VBOX_WITH_USB
123	m->llDeviceFilters.allocate();
124	#endif
125
126	/* Confirm a successful initialization */
127	autoInitSpan.setSucceeded();
128
129	return S_OK;
130	}
131
132	/**
133	* Initializes the USB controller object given another USB controller object
134	* (a kind of copy constructor). This object shares data with
135	* the object passed as an argument.
136	*
137	* @returns COM result indicator.
138	* @param aParent Pointer to our parent object.
139	* @param aPeer The object to share.
140	*
141	* @note This object must be destroyed before the original object
142	* it shares data with is destroyed.
143	*/
144	HRESULT USBController::init(Machine aParent, USBController aPeer)
145	{
146	LogFlowThisFunc(("aParent=%p, aPeer=%p\n", aParent, aPeer));
147
148	ComAssertRet(aParent && aPeer, E_INVALIDARG);
149
150	/* Enclose the state transition NotReady->InInit->Ready */
151	AutoInitSpan autoInitSpan(this);
152	AssertReturn(autoInitSpan.isOk(), E_FAIL);
153
154	m = new Data();
155
156	unconst(m->pParent) = aParent;
157	unconst(m->pPeer) = aPeer;
158
159	AutoWriteLock thatlock(aPeer COMMA_LOCKVAL_SRC_POS);
160	m->bd.share(aPeer->m->bd);
161
162	#ifdef VBOX_WITH_USB
163	/* create copies of all filters */
164	m->llDeviceFilters.allocate();
165	DeviceFilterList::const_iterator it = aPeer->m->llDeviceFilters->begin();
166	while (it != aPeer->m->llDeviceFilters->end())
167	{
168	ComObjPtr<USBDeviceFilter> filter;
169	filter.createObject();
170	filter->init (this, *it);
171	m->llDeviceFilters->push_back(filter);
172	++ it;
173	}
174	#endif /* VBOX_WITH_USB */
175
176	/* Confirm a successful initialization */
177	autoInitSpan.setSucceeded();
178
179	return S_OK;
180	}
181
182
183	/**
184	* Initializes the USB controller object given another guest object
185	* (a kind of copy constructor). This object makes a private copy of data
186	* of the original object passed as an argument.
187	*/
188	HRESULT USBController::initCopy(Machine aParent, USBController aPeer)
189	{
190	LogFlowThisFunc(("aParent=%p, aPeer=%p\n", aParent, aPeer));
191
192	ComAssertRet(aParent && aPeer, E_INVALIDARG);
193
194	/* Enclose the state transition NotReady->InInit->Ready */
195	AutoInitSpan autoInitSpan(this);
196	AssertReturn(autoInitSpan.isOk(), E_FAIL);
197
198	m = new Data();
199
200	unconst(m->pParent) = aParent;
201	/* mPeer is left null */
202
203	AutoWriteLock thatlock(aPeer COMMA_LOCKVAL_SRC_POS);
204	m->bd.attachCopy(aPeer->m->bd);
205
206	#ifdef VBOX_WITH_USB
207	/* create private copies of all filters */
208	m->llDeviceFilters.allocate();
209	DeviceFilterList::const_iterator it = aPeer->m->llDeviceFilters->begin();
210	while (it != aPeer->m->llDeviceFilters->end())
211	{
212	ComObjPtr<USBDeviceFilter> filter;
213	filter.createObject();
214	filter->initCopy(this, *it);
215	m->llDeviceFilters->push_back(filter);
216	++ it;
217	}
218	#endif /* VBOX_WITH_USB */
219
220	/* Confirm a successful initialization */
221	autoInitSpan.setSucceeded();
222
223	return S_OK;
224	}
225
226
227	/**
228	* Uninitializes the instance and sets the ready flag to FALSE.
229	* Called either from FinalRelease() or by the parent when it gets destroyed.
230	*/
231	void USBController::uninit()
232	{
233	LogFlowThisFunc(("\n"));
234
235	/* Enclose the state transition Ready->InUninit->NotReady */
236	AutoUninitSpan autoUninitSpan(this);
237	if (autoUninitSpan.uninitDone())
238	return;
239
240	#ifdef VBOX_WITH_USB
241	// uninit all device filters on the list (it's a standard std::list not an ObjectsList
242	// so we must uninit() manually)
243	for (DeviceFilterList::iterator it = m->llDeviceFilters->begin();
244	it != m->llDeviceFilters->end();
245	++it)
246	(*it)->uninit();
247
248	m->llDeviceFilters.free();
249	#endif
250	m->bd.free();
251
252	unconst(m->pPeer) = NULL;
253	unconst(m->pParent) = NULL;
254
255	delete m;
256	m = NULL;
257	}
258
259
260	// IUSBController properties
261	/////////////////////////////////////////////////////////////////////////////
262
263	STDMETHODIMP USBController::COMGETTER(Enabled) (BOOL *aEnabled)
264	{
265	CheckComArgOutPointerValid(aEnabled);
266
267	AutoCaller autoCaller(this);
268	if (FAILED(autoCaller.rc())) return autoCaller.rc();
269
270	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
271
272	*aEnabled = m->bd->fEnabled;
273
274	return S_OK;
275	}
276
277
278	STDMETHODIMP USBController::COMSETTER(Enabled) (BOOL aEnabled)
279	{
280	LogFlowThisFunc(("aEnabled=%RTbool\n", aEnabled));
281
282	AutoCaller autoCaller(this);
283	if (FAILED(autoCaller.rc())) return autoCaller.rc();
284
285	/* the machine needs to be mutable */
286	AutoMutableStateDependency adep(m->pParent);
287	if (FAILED(adep.rc())) return adep.rc();
288
289	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
290
291	if (m->bd->fEnabled != aEnabled)
292	{
293	m->bd.backup();
294	m->bd->fEnabled = aEnabled;
295
296	// leave the lock for safety
297	alock.release();
298
299	AutoWriteLock mlock(m->pParent COMMA_LOCKVAL_SRC_POS);
300	m->pParent->setModified(Machine::IsModified_USB);
301	mlock.release();
302
303	m->pParent->onUSBControllerChange();
304	}
305
306	return S_OK;
307	}
308
309	STDMETHODIMP USBController::COMGETTER(EnabledEhci) (BOOL *aEnabled)
310	{
311	CheckComArgOutPointerValid(aEnabled);
312
313	AutoCaller autoCaller(this);
314	if (FAILED(autoCaller.rc())) return autoCaller.rc();
315
316	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
317
318	*aEnabled = m->bd->fEnabledEHCI;
319
320	return S_OK;
321	}
322
323	STDMETHODIMP USBController::COMSETTER(EnabledEhci) (BOOL aEnabled)
324	{
325	LogFlowThisFunc(("aEnabled=%RTbool\n", aEnabled));
326
327	AutoCaller autoCaller(this);
328	if (FAILED(autoCaller.rc())) return autoCaller.rc();
329
330	/* the machine needs to be mutable */
331	AutoMutableStateDependency adep(m->pParent);
332	if (FAILED(adep.rc())) return adep.rc();
333
334	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
335
336	if (m->bd->fEnabledEHCI != aEnabled)
337	{
338	m->bd.backup();
339	m->bd->fEnabledEHCI = aEnabled;
340
341	// leave the lock for safety
342	alock.release();
343
344	AutoWriteLock mlock(m->pParent COMMA_LOCKVAL_SRC_POS);
345	m->pParent->setModified(Machine::IsModified_USB);
346	mlock.release();
347
348	m->pParent->onUSBControllerChange();
349	}
350
351	return S_OK;
352	}
353
354	STDMETHODIMP USBController::COMGETTER(ProxyAvailable) (BOOL *aEnabled)
355	{
356	CheckComArgOutPointerValid(aEnabled);
357
358	AutoCaller autoCaller(this);
359	if (FAILED(autoCaller.rc())) return autoCaller.rc();
360
361	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
362
363	#ifdef VBOX_WITH_USB
364	*aEnabled = true;
365	#else
366	*aEnabled = false;
367	#endif
368
369	return S_OK;
370	}
371
372	STDMETHODIMP USBController::COMGETTER(USBStandard) (USHORT *aUSBStandard)
373	{
374	CheckComArgOutPointerValid(aUSBStandard);
375
376	AutoCaller autoCaller(this);
377	if (FAILED(autoCaller.rc())) return autoCaller.rc();
378
379	/* not accessing data -- no need to lock */
380
381	/** @todo This is no longer correct */
382	*aUSBStandard = 0x0101;
383
384	return S_OK;
385	}
386
387	#ifndef VBOX_WITH_USB
388	/**
389	* Fake class for build without USB.
390	* We need an empty collection & enum for deviceFilters, that's all.
391	*/
392	class ATL_NO_VTABLE USBDeviceFilter :
393	public VirtualBoxBase,
394	public VirtualBoxSupportErrorInfoImpl<USBDeviceFilter, IUSBDeviceFilter>,
395	public VirtualBoxSupportTranslation<USBDeviceFilter>,
396	public IUSBDeviceFilter
397	{
398	public:
399	DECLARE_NOT_AGGREGATABLE(USBDeviceFilter)
400	DECLARE_PROTECT_FINAL_CONSTRUCT()
401	BEGIN_COM_MAP(USBDeviceFilter)
402	COM_INTERFACE_ENTRY(ISupportErrorInfo)
403	COM_INTERFACE_ENTRY(IUSBDeviceFilter)
404	END_COM_MAP()
405
406	DECLARE_EMPTY_CTOR_DTOR (USBDeviceFilter)
407
408	// IUSBDeviceFilter properties
409	STDMETHOD(COMGETTER(Name)) (BSTR *aName);
410	STDMETHOD(COMSETTER(Name)) (IN_BSTR aName);
411	STDMETHOD(COMGETTER(Active)) (BOOL *aActive);
412	STDMETHOD(COMSETTER(Active)) (BOOL aActive);
413	STDMETHOD(COMGETTER(VendorId)) (BSTR *aVendorId);
414	STDMETHOD(COMSETTER(VendorId)) (IN_BSTR aVendorId);
415	STDMETHOD(COMGETTER(ProductId)) (BSTR *aProductId);
416	STDMETHOD(COMSETTER(ProductId)) (IN_BSTR aProductId);
417	STDMETHOD(COMGETTER(Revision)) (BSTR *aRevision);
418	STDMETHOD(COMSETTER(Revision)) (IN_BSTR aRevision);
419	STDMETHOD(COMGETTER(Manufacturer)) (BSTR *aManufacturer);
420	STDMETHOD(COMSETTER(Manufacturer)) (IN_BSTR aManufacturer);
421	STDMETHOD(COMGETTER(Product)) (BSTR *aProduct);
422	STDMETHOD(COMSETTER(Product)) (IN_BSTR aProduct);
423	STDMETHOD(COMGETTER(SerialNumber)) (BSTR *aSerialNumber);
424	STDMETHOD(COMSETTER(SerialNumber)) (IN_BSTR aSerialNumber);
425	STDMETHOD(COMGETTER(Port)) (BSTR *aPort);
426	STDMETHOD(COMSETTER(Port)) (IN_BSTR aPort);
427	STDMETHOD(COMGETTER(Remote)) (BSTR *aRemote);
428	STDMETHOD(COMSETTER(Remote)) (IN_BSTR aRemote);
429	STDMETHOD(COMGETTER(MaskedInterfaces)) (ULONG *aMaskedIfs);
430	STDMETHOD(COMSETTER(MaskedInterfaces)) (ULONG aMaskedIfs);
431	};
432	#endif /* !VBOX_WITH_USB */
433
434
435	STDMETHODIMP USBController::COMGETTER(DeviceFilters) (ComSafeArrayOut(IUSBDeviceFilter *, aDevicesFilters))
436	{
437	#ifdef VBOX_WITH_USB
438	CheckComArgOutSafeArrayPointerValid(aDevicesFilters);
439
440	AutoCaller autoCaller(this);
441	if (FAILED(autoCaller.rc())) return autoCaller.rc();
442
443	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
444
445	SafeIfaceArray<IUSBDeviceFilter> collection (*m->llDeviceFilters.data());
446	collection.detachTo(ComSafeArrayOutArg(aDevicesFilters));
447
448	return S_OK;
449	#else
450	NOREF(aDevicesFilters);
451	# ifndef RT_OS_WINDOWS
452	NOREF(aDevicesFiltersSize);
453	# endif
454	ReturnComNotImplemented();
455	#endif
456	}
457
458	// IUSBController methods
459	/////////////////////////////////////////////////////////////////////////////
460
461	STDMETHODIMP USBController::CreateDeviceFilter (IN_BSTR aName,
462	IUSBDeviceFilter **aFilter)
463	{
464	#ifdef VBOX_WITH_USB
465	CheckComArgOutPointerValid(aFilter);
466
467	CheckComArgStrNotEmptyOrNull(aName);
468
469	AutoCaller autoCaller(this);
470	if (FAILED(autoCaller.rc())) return autoCaller.rc();
471
472	/* the machine needs to be mutable */
473	AutoMutableStateDependency adep(m->pParent);
474	if (FAILED(adep.rc())) return adep.rc();
475
476	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
477
478	ComObjPtr<USBDeviceFilter> filter;
479	filter.createObject();
480	HRESULT rc = filter->init (this, aName);
481	ComAssertComRCRetRC (rc);
482	rc = filter.queryInterfaceTo(aFilter);
483	AssertComRCReturnRC(rc);
484
485	return S_OK;
486	#else
487	NOREF(aName);
488	NOREF(aFilter);
489	ReturnComNotImplemented();
490	#endif
491	}
492
493	STDMETHODIMP USBController::InsertDeviceFilter(ULONG aPosition,
494	IUSBDeviceFilter *aFilter)
495	{
496	#ifdef VBOX_WITH_USB
497
498	CheckComArgNotNull(aFilter);
499
500	AutoCaller autoCaller(this);
501	if (FAILED(autoCaller.rc())) return autoCaller.rc();
502
503	/* the machine needs to be mutable */
504	AutoMutableStateDependency adep(m->pParent);
505	if (FAILED(adep.rc())) return adep.rc();
506
507	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
508
509	ComObjPtr<USBDeviceFilter> filter = static_cast<USBDeviceFilter*>(aFilter);
510	// @todo r=dj make sure the input object is actually from us
511	// ComObjPtr<USBDeviceFilter> filter = getDependentChild(aFilter);
512	// if (!filter)
513	// return setError (E_INVALIDARG,
514	// tr ("The given USB device filter is not created within "
515	// "this VirtualBox instance"));
516
517	if (filter->mInList)
518	return setError(VBOX_E_INVALID_OBJECT_STATE,
519	tr("The given USB device filter is already in the list"));
520
521	/* backup the list before modification */
522	m->llDeviceFilters.backup();
523
524	/* iterate to the position... */
525	DeviceFilterList::iterator it;
526	if (aPosition < m->llDeviceFilters->size())
527	{
528	it = m->llDeviceFilters->begin();
529	std::advance (it, aPosition);
530	}
531	else
532	it = m->llDeviceFilters->end();
533	/* ...and insert */
534	m->llDeviceFilters->insert (it, filter);
535	filter->mInList = true;
536
537	/* notify the proxy (only when it makes sense) */
538	if (filter->getData().mActive && Global::IsOnline(adep.machineState()))
539	{
540	USBProxyService *service = m->pParent->getVirtualBox()->host()->usbProxyService();
541	ComAssertRet(service, E_FAIL);
542
543	ComAssertRet(filter->getId() == NULL, E_FAIL);
544	filter->getId() = service->insertFilter (&filter->getData().mUSBFilter);
545	}
546
547	alock.release();
548	AutoWriteLock mlock(m->pParent COMMA_LOCKVAL_SRC_POS);
549	m->pParent->setModified(Machine::IsModified_USB);
550	mlock.release();
551
552	return S_OK;
553
554	#else /* VBOX_WITH_USB */
555
556	NOREF(aPosition);
557	NOREF(aFilter);
558	ReturnComNotImplemented();
559
560	#endif /* VBOX_WITH_USB */
561	}
562
563	STDMETHODIMP USBController::RemoveDeviceFilter(ULONG aPosition,
564	IUSBDeviceFilter **aFilter)
565	{
566	#ifdef VBOX_WITH_USB
567
568	CheckComArgOutPointerValid(aFilter);
569
570	AutoCaller autoCaller(this);
571	if (FAILED(autoCaller.rc())) return autoCaller.rc();
572
573	/* the machine needs to be mutable */
574	AutoMutableStateDependency adep(m->pParent);
575	if (FAILED(adep.rc())) return adep.rc();
576
577	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
578
579	if (!m->llDeviceFilters->size())
580	return setError(E_INVALIDARG,
581	tr("The USB device filter list is empty"));
582
583	if (aPosition >= m->llDeviceFilters->size())
584	return setError(E_INVALIDARG,
585	tr("Invalid position: %lu (must be in range [0, %lu])"),
586	aPosition, m->llDeviceFilters->size() - 1);
587
588	/* backup the list before modification */
589	m->llDeviceFilters.backup();
590
591	ComObjPtr<USBDeviceFilter> filter;
592	{
593	/* iterate to the position... */
594	DeviceFilterList::iterator it = m->llDeviceFilters->begin();
595	std::advance (it, aPosition);
596	/* ...get an element from there... */
597	filter = *it;
598	/* ...and remove */
599	filter->mInList = false;
600	m->llDeviceFilters->erase (it);
601	}
602
603	/* cancel sharing (make an independent copy of data) */
604	filter->unshare();
605
606	filter.queryInterfaceTo(aFilter);
607
608	/* notify the proxy (only when it makes sense) */
609	if (filter->getData().mActive && Global::IsOnline(adep.machineState()))
610	{
611	USBProxyService *service = m->pParent->getVirtualBox()->host()->usbProxyService();
612	ComAssertRet(service, E_FAIL);
613
614	ComAssertRet(filter->getId() != NULL, E_FAIL);
615	service->removeFilter(filter->getId());
616	filter->getId() = NULL;
617	}
618
619	alock.release();
620	AutoWriteLock mlock(m->pParent COMMA_LOCKVAL_SRC_POS);
621	m->pParent->setModified(Machine::IsModified_USB);
622	mlock.release();
623
624	return S_OK;
625
626	#else /* VBOX_WITH_USB */
627
628	NOREF(aPosition);
629	NOREF(aFilter);
630	ReturnComNotImplemented();
631
632	#endif /* VBOX_WITH_USB */
633	}
634
635	// public methods only for internal purposes
636	/////////////////////////////////////////////////////////////////////////////
637
638	/**
639	* Loads settings from the given machine node.
640	* May be called once right after this object creation.
641	*
642	* @param aMachineNode <Machine> node.
643	*
644	* @note Does not lock "this" as Machine::loadHardware, which calls this, does not lock either.
645	*/
646	HRESULT USBController::loadSettings(const settings::USBController &data)
647	{
648	AutoCaller autoCaller(this);
649	AssertComRCReturnRC(autoCaller.rc());
650
651	/* Note: we assume that the default values for attributes of optional
652	* nodes are assigned in the Data::Data() constructor and don't do it
653	* here. It implies that this method may only be called after constructing
654	* a new BIOSSettings object while all its data fields are in the default
655	* values. Exceptions are fields whose creation time defaults don't match
656	* values that should be applied when these fields are not explicitly set
657	* in the settings file (for backwards compatibility reasons). This takes
658	* place when a setting of a newly created object must default to A while
659	* the same setting of an object loaded from the old settings file must
660	* default to B. */
661
662	m->bd->fEnabled = data.fEnabled;
663	m->bd->fEnabledEHCI = data.fEnabledEHCI;
664
665	#ifdef VBOX_WITH_USB
666	for (settings::USBDeviceFiltersList::const_iterator it = data.llDeviceFilters.begin();
667	it != data.llDeviceFilters.end();
668	++it)
669	{
670	const settings::USBDeviceFilter &f = *it;
671	ComObjPtr<USBDeviceFilter> pFilter;
672	pFilter.createObject();
673	HRESULT rc = pFilter->init(this, // parent
674	f);
675	if (FAILED(rc)) return rc;
676
677	m->llDeviceFilters->push_back(pFilter);
678	pFilter->mInList = true;
679	}
680	#endif /* VBOX_WITH_USB */
681
682	return S_OK;
683	}
684
685	/**
686	* Saves settings to the given machine node.
687	*
688	* @param aMachineNode <Machine> node.
689	*
690	* @note Locks this object for reading.
691	*/
692	HRESULT USBController::saveSettings(settings::USBController &data)
693	{
694	AutoCaller autoCaller(this);
695	if (FAILED(autoCaller.rc())) return autoCaller.rc();
696
697	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
698
699	data.fEnabled = !!m->bd->fEnabled;
700	data.fEnabledEHCI = !!m->bd->fEnabledEHCI;
701
702	#ifdef VBOX_WITH_USB
703	data.llDeviceFilters.clear();
704
705	for (DeviceFilterList::const_iterator it = m->llDeviceFilters->begin();
706	it != m->llDeviceFilters->end();
707	++it)
708	{
709	AutoWriteLock filterLock(*it COMMA_LOCKVAL_SRC_POS);
710	const USBDeviceFilter::Data &filterData = (*it)->getData();
711
712	Bstr str;
713
714	settings::USBDeviceFilter f;
715	f.strName = filterData.mName;
716	f.fActive = !!filterData.mActive;
717	(*it)->COMGETTER(VendorId)(str.asOutParam());
718	f.strVendorId = str;
719	(*it)->COMGETTER(ProductId)(str.asOutParam());
720	f.strProductId = str;
721	(*it)->COMGETTER (Revision) (str.asOutParam());
722	f.strRevision = str;
723	(*it)->COMGETTER (Manufacturer) (str.asOutParam());
724	f.strManufacturer = str;
725	(*it)->COMGETTER (Product) (str.asOutParam());
726	f.strProduct = str;
727	(*it)->COMGETTER (SerialNumber) (str.asOutParam());
728	f.strSerialNumber = str;
729	(*it)->COMGETTER (Port) (str.asOutParam());
730	f.strPort = str;
731	f.strRemote = filterData.mRemote.string();
732	f.ulMaskedInterfaces = filterData.mMaskedIfs;
733
734	data.llDeviceFilters.push_back(f);
735	}
736	#endif /* VBOX_WITH_USB */
737
738	return S_OK;
739	}
740
741	/** @note Locks objects for writing! */
742	void USBController::rollback()
743	{
744	AutoCaller autoCaller(this);
745	AssertComRCReturnVoid(autoCaller.rc());
746
747	/* we need the machine state */
748	AutoAnyStateDependency adep(m->pParent);
749	AssertComRCReturnVoid(adep.rc());
750
751	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
752
753	m->bd.rollback();
754
755	#ifdef VBOX_WITH_USB
756
757	if (m->llDeviceFilters.isBackedUp())
758	{
759	USBProxyService *service = m->pParent->getVirtualBox()->host()->usbProxyService();
760	Assert(service);
761
762	/* uninitialize all new filters (absent in the backed up list) */
763	DeviceFilterList::const_iterator it = m->llDeviceFilters->begin();
764	DeviceFilterList *backedList = m->llDeviceFilters.backedUpData();
765	while (it != m->llDeviceFilters->end())
766	{
767	if (std::find (backedList->begin(), backedList->end(), *it) ==
768	backedList->end())
769	{
770	/* notify the proxy (only when it makes sense) */
771	if ((*it)->getData().mActive &&
772	Global::IsOnline (adep.machineState()))
773	{
774	USBDeviceFilter filter = it;
775	Assert(filter->getId() != NULL);
776	service->removeFilter(filter->getId());
777	filter->getId() = NULL;
778	}
779
780	(*it)->uninit();
781	}
782	++ it;
783	}
784
785	if (Global::IsOnline (adep.machineState()))
786	{
787	/* find all removed old filters (absent in the new list)
788	* and insert them back to the USB proxy */
789	it = backedList->begin();
790	while (it != backedList->end())
791	{
792	if (std::find (m->llDeviceFilters->begin(), m->llDeviceFilters->end(), *it) ==
793	m->llDeviceFilters->end())
794	{
795	/* notify the proxy (only when necessary) */
796	if ((*it)->getData().mActive)
797	{
798	USBDeviceFilter flt = it; /* resolve ambiguity */
799	Assert(flt->getId() == NULL);
800	flt->getId() = service->insertFilter(&flt->getData().mUSBFilter);
801	}
802	}
803	++ it;
804	}
805	}
806
807	/* restore the list */
808	m->llDeviceFilters.rollback();
809	}
810
811	/* here we don't depend on the machine state any more */
812	adep.release();
813
814	/* rollback any changes to filters after restoring the list */
815	DeviceFilterList::const_iterator it = m->llDeviceFilters->begin();
816	while (it != m->llDeviceFilters->end())
817	{
818	if ((*it)->isModified())
819	{
820	(*it)->rollback();
821	/* call this to notify the USB proxy about changes */
822	onDeviceFilterChange(*it);
823	}
824	++it;
825	}
826
827	#endif /* VBOX_WITH_USB */
828	}
829
830	/**
831	* @note Locks this object for writing, together with the peer object (also
832	* for writing) if there is one.
833	*/
834	void USBController::commit()
835	{
836	/* sanity */
837	AutoCaller autoCaller(this);
838	AssertComRCReturnVoid (autoCaller.rc());
839
840	/* sanity too */
841	AutoCaller peerCaller(m->pPeer);
842	AssertComRCReturnVoid (peerCaller.rc());
843
844	/* lock both for writing since we modify both (mPeer is "master" so locked
845	* first) */
846	AutoMultiWriteLock2 alock(m->pPeer, this COMMA_LOCKVAL_SRC_POS);
847
848	if (m->bd.isBackedUp())
849	{
850	m->bd.commit();
851	if (m->pPeer)
852	{
853	/* attach new data to the peer and reshare it */
854	AutoWriteLock peerlock(m->pPeer COMMA_LOCKVAL_SRC_POS);
855	m->pPeer->m->bd.attach(m->bd);
856	}
857	}
858
859	#ifdef VBOX_WITH_USB
860	bool commitFilters = false;
861
862	if (m->llDeviceFilters.isBackedUp())
863	{
864	m->llDeviceFilters.commit();
865
866	/* apply changes to peer */
867	if (m->pPeer)
868	{
869	AutoWriteLock peerlock(m->pPeer COMMA_LOCKVAL_SRC_POS);
870
871	/* commit all changes to new filters (this will reshare data with
872	* peers for those who have peers) */
873	DeviceFilterList *newList = new DeviceFilterList();
874	DeviceFilterList::const_iterator it = m->llDeviceFilters->begin();
875	while (it != m->llDeviceFilters->end())
876	{
877	(*it)->commit();
878
879	/* look if this filter has a peer filter */
880	ComObjPtr<USBDeviceFilter> peer = (*it)->peer();
881	if (!peer)
882	{
883	/* no peer means the filter is a newly created one;
884	* create a peer owning data this filter share it with */
885	peer.createObject();
886	peer->init(m->pPeer, it, true / aReshare */);
887	}
888	else
889	{
890	/* remove peer from the old list */
891	m->pPeer->m->llDeviceFilters->remove(peer);
892	}
893	/* and add it to the new list */
894	newList->push_back (peer);
895
896	++ it;
897	}
898
899	/* uninit old peer's filters that are left */
900	it = m->pPeer->m->llDeviceFilters->begin();
901	while (it != m->pPeer->m->llDeviceFilters->end())
902	{
903	(*it)->uninit();
904	++ it;
905	}
906
907	/* attach new list of filters to our peer */
908	m->pPeer->m->llDeviceFilters.attach(newList);
909	}
910	else
911	{
912	/* we have no peer (our parent is the newly created machine);
913	* just commit changes to filters */
914	commitFilters = true;
915	}
916	}
917	else
918	{
919	/* the list of filters itself is not changed,
920	* just commit changes to filters themselves */
921	commitFilters = true;
922	}
923
924	if (commitFilters)
925	{
926	DeviceFilterList::const_iterator it = m->llDeviceFilters->begin();
927	while (it != m->llDeviceFilters->end())
928	{
929	(*it)->commit();
930	++ it;
931	}
932	}
933	#endif /* VBOX_WITH_USB */
934	}
935
936	/**
937	* @note Locks this object for writing, together with the peer object
938	* represented by @a aThat (locked for reading).
939	*/
940	void USBController::copyFrom (USBController *aThat)
941	{
942	AssertReturnVoid (aThat != NULL);
943
944	/* sanity */
945	AutoCaller autoCaller(this);
946	AssertComRCReturnVoid (autoCaller.rc());
947
948	/* sanity too */
949	AutoCaller thatCaller (aThat);
950	AssertComRCReturnVoid (thatCaller.rc());
951
952	/* even more sanity */
953	AutoAnyStateDependency adep(m->pParent);
954	AssertComRCReturnVoid (adep.rc());
955	/* Machine::copyFrom() may not be called when the VM is running */
956	AssertReturnVoid (!Global::IsOnline (adep.machineState()));
957
958	/* peer is not modified, lock it for reading (aThat is "master" so locked
959	* first) */
960	AutoReadLock rl(aThat COMMA_LOCKVAL_SRC_POS);
961	AutoWriteLock wl(this COMMA_LOCKVAL_SRC_POS);
962
963	/* this will back up current data */
964	m->bd.assignCopy(aThat->m->bd);
965
966	#ifdef VBOX_WITH_USB
967
968	/* Note that we won't inform the USB proxy about new filters since the VM is
969	* not running when we are here and therefore no need to do so */
970
971	/* create private copies of all filters */
972	m->llDeviceFilters.backup();
973	m->llDeviceFilters->clear();
974	for (DeviceFilterList::const_iterator it = aThat->m->llDeviceFilters->begin();
975	it != aThat->m->llDeviceFilters->end();
976	++ it)
977	{
978	ComObjPtr<USBDeviceFilter> filter;
979	filter.createObject();
980	filter->initCopy (this, *it);
981	m->llDeviceFilters->push_back (filter);
982	}
983
984	#endif /* VBOX_WITH_USB */
985	}
986
987	#ifdef VBOX_WITH_USB
988
989	/**
990	* Called by setter methods of all USB device filters.
991	*
992	* @note Locks nothing.
993	*/
994	HRESULT USBController::onDeviceFilterChange (USBDeviceFilter *aFilter,
995	BOOL aActiveChanged /* = FALSE */)
996	{
997	AutoCaller autoCaller(this);
998	AssertComRCReturnRC(autoCaller.rc());
999
1000	/* we need the machine state */
1001	AutoAnyStateDependency adep(m->pParent);
1002	AssertComRCReturnRC(adep.rc());
1003
1004	/* nothing to do if the machine isn't running */
1005	if (!Global::IsOnline (adep.machineState()))
1006	return S_OK;
1007
1008	/* we don't modify our data fields -- no need to lock */
1009
1010	if (aFilter->mInList && m->pParent->isRegistered())
1011	{
1012	USBProxyService *service = m->pParent->getVirtualBox()->host()->usbProxyService();
1013	ComAssertRet(service, E_FAIL);
1014
1015	if (aActiveChanged)
1016	{
1017	/* insert/remove the filter from the proxy */
1018	if (aFilter->getData().mActive)
1019	{
1020	ComAssertRet(aFilter->getId() == NULL, E_FAIL);
1021	aFilter->getId() = service->insertFilter(&aFilter->getData().mUSBFilter);
1022	}
1023	else
1024	{
1025	ComAssertRet(aFilter->getId() != NULL, E_FAIL);
1026	service->removeFilter(aFilter->getId());
1027	aFilter->getId() = NULL;
1028	}
1029	}
1030	else
1031	{
1032	if (aFilter->getData().mActive)
1033	{
1034	/* update the filter in the proxy */
1035	ComAssertRet(aFilter->getId() != NULL, E_FAIL);
1036	service->removeFilter(aFilter->getId());
1037	aFilter->getId() = service->insertFilter(&aFilter->getData().mUSBFilter);
1038	}
1039	}
1040	}
1041
1042	return S_OK;
1043	}
1044
1045	/**
1046	* Returns true if the given USB device matches to at least one of
1047	* this controller's USB device filters.
1048	*
1049	* A HostUSBDevice specific version.
1050	*
1051	* @note Locks this object for reading.
1052	*/
1053	bool USBController::hasMatchingFilter (const ComObjPtr<HostUSBDevice> &aDevice, ULONG *aMaskedIfs)
1054	{
1055	AutoCaller autoCaller(this);
1056	AssertComRCReturn (autoCaller.rc(), false);
1057
1058	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1059
1060	/* Disabled USB controllers cannot actually work with USB devices */
1061	if (!m->bd->fEnabled)
1062	return false;
1063
1064	/* apply self filters */
1065	for (DeviceFilterList::const_iterator it = m->llDeviceFilters->begin();
1066	it != m->llDeviceFilters->end();
1067	++ it)
1068	{
1069	AutoWriteLock filterLock(*it COMMA_LOCKVAL_SRC_POS);
1070	if (aDevice->isMatch((*it)->getData()))
1071	{
1072	aMaskedIfs = (it)->getData().mMaskedIfs;
1073	return true;
1074	}
1075	}
1076
1077	return false;
1078	}
1079
1080	/**
1081	* Returns true if the given USB device matches to at least one of
1082	* this controller's USB device filters.
1083	*
1084	* A generic version that accepts any IUSBDevice on input.
1085	*
1086	* @note
1087	* This method MUST correlate with HostUSBDevice::isMatch()
1088	* in the sense of the device matching logic.
1089	*
1090	* @note Locks this object for reading.
1091	*/
1092	bool USBController::hasMatchingFilter (IUSBDevice aUSBDevice, ULONG aMaskedIfs)
1093	{
1094	LogFlowThisFuncEnter();
1095
1096	AutoCaller autoCaller(this);
1097	AssertComRCReturn (autoCaller.rc(), false);
1098
1099	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1100
1101	/* Disabled USB controllers cannot actually work with USB devices */
1102	if (!m->bd->fEnabled)
1103	return false;
1104
1105	HRESULT rc = S_OK;
1106
1107	/* query fields */
1108	USBFILTER dev;
1109	USBFilterInit (&dev, USBFILTERTYPE_CAPTURE);
1110
1111	USHORT vendorId = 0;
1112	rc = aUSBDevice->COMGETTER(VendorId) (&vendorId);
1113	ComAssertComRCRet(rc, false);
1114	ComAssertRet(vendorId, false);
1115	int vrc = USBFilterSetNumExact (&dev, USBFILTERIDX_VENDOR_ID, vendorId, true); AssertRC(vrc);
1116
1117	USHORT productId = 0;
1118	rc = aUSBDevice->COMGETTER(ProductId) (&productId);
1119	ComAssertComRCRet(rc, false);
1120	vrc = USBFilterSetNumExact (&dev, USBFILTERIDX_PRODUCT_ID, productId, true); AssertRC(vrc);
1121
1122	USHORT revision;
1123	rc = aUSBDevice->COMGETTER(Revision) (&revision);
1124	ComAssertComRCRet(rc, false);
1125	vrc = USBFilterSetNumExact (&dev, USBFILTERIDX_DEVICE, revision, true); AssertRC(vrc);
1126
1127	Bstr manufacturer;
1128	rc = aUSBDevice->COMGETTER(Manufacturer) (manufacturer.asOutParam());
1129	ComAssertComRCRet(rc, false);
1130	if (!manufacturer.isEmpty())
1131	USBFilterSetStringExact (&dev, USBFILTERIDX_MANUFACTURER_STR, Utf8Str(manufacturer).c_str(), true);
1132
1133	Bstr product;
1134	rc = aUSBDevice->COMGETTER(Product) (product.asOutParam());
1135	ComAssertComRCRet(rc, false);
1136	if (!product.isEmpty())
1137	USBFilterSetStringExact (&dev, USBFILTERIDX_PRODUCT_STR, Utf8Str(product).c_str(), true);
1138
1139	Bstr serialNumber;
1140	rc = aUSBDevice->COMGETTER(SerialNumber) (serialNumber.asOutParam());
1141	ComAssertComRCRet(rc, false);
1142	if (!serialNumber.isEmpty())
1143	USBFilterSetStringExact (&dev, USBFILTERIDX_SERIAL_NUMBER_STR, Utf8Str(serialNumber).c_str(), true);
1144
1145	Bstr address;
1146	rc = aUSBDevice->COMGETTER(Address) (address.asOutParam());
1147	ComAssertComRCRet(rc, false);
1148
1149	USHORT port = 0;
1150	rc = aUSBDevice->COMGETTER(Port)(&port);
1151	ComAssertComRCRet(rc, false);
1152	USBFilterSetNumExact (&dev, USBFILTERIDX_PORT, port, true);
1153
1154	BOOL remote = FALSE;
1155	rc = aUSBDevice->COMGETTER(Remote)(&remote);
1156	ComAssertComRCRet(rc, false);
1157	ComAssertRet(remote == TRUE, false);
1158
1159	bool match = false;
1160
1161	/* apply self filters */
1162	for (DeviceFilterList::const_iterator it = m->llDeviceFilters->begin();
1163	it != m->llDeviceFilters->end();
1164	++ it)
1165	{
1166	AutoWriteLock filterLock(*it COMMA_LOCKVAL_SRC_POS);
1167	const USBDeviceFilter::Data &aData = (*it)->getData();
1168
1169	if (!aData.mActive)
1170	continue;
1171	if (!aData.mRemote.isMatch (remote))
1172	continue;
1173	if (!USBFilterMatch (&aData.mUSBFilter, &dev))
1174	continue;
1175
1176	match = true;
1177	*aMaskedIfs = aData.mMaskedIfs;
1178	break;
1179	}
1180
1181	LogFlowThisFunc(("returns: %d\n", match));
1182	LogFlowThisFuncLeave();
1183
1184	return match;
1185	}
1186
1187	/**
1188	* Notifies the proxy service about all filters as requested by the
1189	* @a aInsertFilters argument.
1190	*
1191	* @param aInsertFilters @c true to insert filters, @c false to remove.
1192	*
1193	* @note Locks this object for reading.
1194	*/
1195	HRESULT USBController::notifyProxy (bool aInsertFilters)
1196	{
1197	LogFlowThisFunc(("aInsertFilters=%RTbool\n", aInsertFilters));
1198
1199	AutoCaller autoCaller(this);
1200	AssertComRCReturn (autoCaller.rc(), false);
1201
1202	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1203
1204	USBProxyService *service = m->pParent->getVirtualBox()->host()->usbProxyService();
1205	AssertReturn(service, E_FAIL);
1206
1207	DeviceFilterList::const_iterator it = m->llDeviceFilters->begin();
1208	while (it != m->llDeviceFilters->end())
1209	{
1210	USBDeviceFilter flt = it; /* resolve ambiguity (for ComPtr below) */
1211
1212	/* notify the proxy (only if the filter is active) */
1213	if (flt->getData().mActive)
1214	{
1215	if (aInsertFilters)
1216	{
1217	AssertReturn(flt->getId() == NULL, E_FAIL);
1218	flt->getId() = service->insertFilter(&flt->getData().mUSBFilter);
1219	}
1220	else
1221	{
1222	/* It's possible that the given filter was not inserted the proxy
1223	* when this method gets called (as a result of an early VM
1224	* process crash for example. So, don't assert that ID != NULL. */
1225	if (flt->getId() != NULL)
1226	{
1227	service->removeFilter(flt->getId());
1228	flt->getId() = NULL;
1229	}
1230	}
1231	}
1232	++ it;
1233	}
1234
1235	return S_OK;
1236	}
1237
1238	Machine* USBController::getMachine()
1239	{
1240	return m->pParent;
1241	}
1242
1243	#endif /* VBOX_WITH_USB */
1244
1245	// private methods
1246	/////////////////////////////////////////////////////////////////////////////
1247	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

source: vbox/trunk/src/VBox/Main/USBControllerImpl.cpp@ 29532

Download in other formats: