VirtualBox

source: vbox/trunk/src/VBox/Main/src-server/HostUSBDeviceImpl.cpp@ 69729

Last change on this file since 69729 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: 97.5 KB
Line 
1/* $Id: HostUSBDeviceImpl.cpp 69500 2017-10-28 15:14:05Z vboxsync $ */
2/** @file
3 * VirtualBox IHostUSBDevice COM interface implementation.
4 */
5
6/*
7 * Copyright (C) 2005-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
19#include <iprt/types.h> /* for UINT64_C */
20
21#include "HostUSBDeviceImpl.h"
22#include "MachineImpl.h"
23#include "HostImpl.h"
24#include "VirtualBoxErrorInfoImpl.h"
25#include "USBProxyBackend.h"
26#include "USBIdDatabase.h"
27
28#include "AutoCaller.h"
29#include "Logging.h"
30
31#include <VBox/err.h>
32#include <iprt/cpp/utils.h>
33
34// constructor / destructor
35/////////////////////////////////////////////////////////////////////////////
36
37DEFINE_EMPTY_CTOR_DTOR(HostUSBDevice)
38
39HRESULT HostUSBDevice::FinalConstruct()
40{
41 mUSBProxyBackend = NULL;
42 mUsb = NULL;
43
44 return BaseFinalConstruct();
45}
46
47void HostUSBDevice::FinalRelease()
48{
49 uninit();
50 BaseFinalRelease();
51}
52
53// public initializer/uninitializer for internal purposes only
54/////////////////////////////////////////////////////////////////////////////
55
56/**
57 * Initializes the USB device object.
58 *
59 * @returns COM result indicator
60 * @param aUsb Pointer to the usb device structure for which the object is to be a wrapper.
61 * This structure is now fully owned by the HostUSBDevice object and will be
62 * freed when it is destructed.
63 * @param aUSBProxyBackend Pointer to the USB Proxy Backend object owning the device.
64 */
65HRESULT HostUSBDevice::init(PUSBDEVICE aUsb, USBProxyBackend *aUSBProxyBackend)
66{
67 ComAssertRet(aUsb, E_INVALIDARG);
68
69 /* Enclose the state transition NotReady->InInit->Ready */
70 AutoInitSpan autoInitSpan(this);
71 AssertReturn(autoInitSpan.isOk(), E_FAIL);
72
73 /*
74 * We need a unique ID for this VBoxSVC session.
75 * The UUID isn't stored anywhere.
76 */
77 unconst(mId).create();
78
79 /*
80 * Set the initial device state.
81 */
82 AssertMsgReturn( aUsb->enmState >= USBDEVICESTATE_UNSUPPORTED
83 && aUsb->enmState < USBDEVICESTATE_USED_BY_GUEST, /* used-by-guest is not a legal initial state. */
84 ("%d\n", aUsb->enmState), E_FAIL);
85 mUniState = (HostUSBDeviceState)aUsb->enmState;
86 mUniSubState = kHostUSBDeviceSubState_Default;
87 mPendingUniState = kHostUSBDeviceState_Invalid;
88 mPrevUniState = mUniState;
89 mIsPhysicallyDetached = false;
90
91 /* Other data members */
92 mUSBProxyBackend = aUSBProxyBackend;
93 mUsb = aUsb;
94
95 /* Set the name. */
96 mNameObj = i_getName();
97 mName = mNameObj.c_str();
98
99 /* Confirm the successful initialization */
100 autoInitSpan.setSucceeded();
101
102 return S_OK;
103}
104
105/**
106 * Uninitializes the instance and sets the ready flag to FALSE.
107 * Called either from FinalRelease() or by the parent when it gets destroyed.
108 */
109void HostUSBDevice::uninit()
110{
111 /* Enclose the state transition Ready->InUninit->NotReady */
112 AutoUninitSpan autoUninitSpan(this);
113 if (autoUninitSpan.uninitDone())
114 return;
115
116 if (mUsb != NULL)
117 {
118 USBProxyBackend::freeDevice(mUsb);
119 mUsb = NULL;
120 }
121
122 mUSBProxyBackend = NULL;
123 mUniState = kHostUSBDeviceState_Invalid;
124}
125
126// Wrapped IUSBDevice properties
127/////////////////////////////////////////////////////////////////////////////
128HRESULT HostUSBDevice::getId(com::Guid &aId)
129{
130 /* mId is constant during life time, no need to lock */
131 aId = mId;
132
133 return S_OK;
134}
135
136
137HRESULT HostUSBDevice::getVendorId(USHORT *aVendorId)
138{
139 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
140
141 *aVendorId = mUsb->idVendor;
142
143 return S_OK;
144}
145
146HRESULT HostUSBDevice::getProductId(USHORT *aProductId)
147{
148 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
149
150 *aProductId = mUsb->idProduct;
151
152 return S_OK;
153}
154
155
156HRESULT HostUSBDevice::getRevision(USHORT *aRevision)
157{
158 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
159
160 *aRevision = mUsb->bcdDevice;
161
162 return S_OK;
163}
164
165HRESULT HostUSBDevice::getManufacturer(com::Utf8Str &aManufacturer)
166{
167 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
168
169 aManufacturer = mUsb->pszManufacturer;
170 return S_OK;
171}
172
173
174HRESULT HostUSBDevice::getProduct(com::Utf8Str &aProduct)
175{
176 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
177
178 aProduct = mUsb->pszProduct;
179 return S_OK;
180}
181
182
183HRESULT HostUSBDevice::getSerialNumber(com::Utf8Str &aSerialNumber)
184{
185 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
186
187 aSerialNumber = mUsb->pszSerialNumber;
188
189 return S_OK;
190}
191
192HRESULT HostUSBDevice::getAddress(com::Utf8Str &aAddress)
193{
194 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
195 aAddress = mUsb->pszAddress;
196 return S_OK;
197}
198
199
200HRESULT HostUSBDevice::getPort(USHORT *aPort)
201{
202 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
203
204 *aPort = mUsb->bPort;
205
206 return S_OK;
207}
208
209
210HRESULT HostUSBDevice::getVersion(USHORT *aVersion)
211{
212 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
213
214 *aVersion = (USHORT)(mUsb->bcdUSB >> 8);
215
216 return S_OK;
217}
218
219
220HRESULT HostUSBDevice::getSpeed(USBConnectionSpeed_T *aSpeed)
221{
222 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
223
224 /* If the speed is unknown (which it shouldn't be), make a guess
225 * which will be correct for USB 1 and 3 devices, but may be wrong
226 * for USB 2.0 devices
227 */
228 switch (mUsb->enmSpeed)
229 {
230 case USBDEVICESPEED_LOW: *aSpeed = USBConnectionSpeed_Low; break;
231 case USBDEVICESPEED_FULL: *aSpeed = USBConnectionSpeed_Full; break;
232 case USBDEVICESPEED_HIGH: *aSpeed = USBConnectionSpeed_High; break;
233 case USBDEVICESPEED_SUPER: *aSpeed = USBConnectionSpeed_Super; break;
234// case USBDEVICESPEED_SUPERPLUS: *aSpeed = USBConnectionSpeed_SuperPlus; break;
235 default:
236 switch (mUsb->bcdUSB >> 8)
237 {
238 case 3: *aSpeed = USBConnectionSpeed_Super; break;
239 case 2: *aSpeed = USBConnectionSpeed_High; break;
240 default: *aSpeed = USBConnectionSpeed_Full;
241 }
242 }
243
244 return S_OK;
245}
246
247
248HRESULT HostUSBDevice::getPortVersion(USHORT *aPortVersion)
249{
250 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
251 /* Port version is 2 (EHCI) if and only if the device runs at high speed;
252 * if speed is unknown, fall back to the old and inaccurate method.
253 */
254 if (mUsb->enmSpeed == USBDEVICESPEED_UNKNOWN)
255 *aPortVersion = (USHORT)(mUsb->bcdUSB >> 8);
256 else
257 {
258 switch (mUsb->enmSpeed)
259 {
260 case USBDEVICESPEED_SUPER:
261 *aPortVersion = 3;
262 break;
263 case USBDEVICESPEED_HIGH:
264 *aPortVersion = 2;
265 break;
266 case USBDEVICESPEED_FULL:
267 case USBDEVICESPEED_LOW:
268 case USBDEVICESPEED_VARIABLE:
269 *aPortVersion = 1;
270 break;
271 default:
272 AssertMsgFailed(("Invalid USB speed: %d\n", mUsb->enmSpeed));
273 *aPortVersion = 1;
274 }
275 }
276
277 return S_OK;
278}
279
280
281HRESULT HostUSBDevice::getRemote(BOOL *aRemote)
282{
283 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
284
285 *aRemote = FALSE;
286
287 return S_OK;
288}
289
290
291HRESULT HostUSBDevice::getState(USBDeviceState_T *aState)
292{
293 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
294
295 *aState = i_canonicalState();
296
297 return S_OK;
298}
299
300
301HRESULT HostUSBDevice::getBackend(com::Utf8Str &aBackend)
302{
303 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
304
305 aBackend = mUsb->pszBackend;
306
307 return S_OK;
308}
309
310
311HRESULT HostUSBDevice::getDeviceInfo(std::vector<com::Utf8Str> &aInfo)
312{
313 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
314
315 com::Utf8Str strManufacturer;
316 com::Utf8Str strProduct;
317
318 if (mUsb->pszManufacturer && *mUsb->pszManufacturer)
319 strManufacturer = mUsb->pszManufacturer;
320 else
321 strManufacturer = USBIdDatabase::findVendor(mUsb->idVendor);
322
323 if (mUsb->pszProduct && *mUsb->pszProduct)
324 strProduct = mUsb->pszProduct;
325 else
326 strProduct = USBIdDatabase::findProduct(mUsb->idVendor, mUsb->idProduct);
327
328 aInfo.resize(2);
329 aInfo[0] = strManufacturer;
330 aInfo[1] = strProduct;
331
332 return S_OK;
333}
334
335// public methods only for internal purposes
336////////////////////////////////////////////////////////////////////////////////
337
338/**
339 * @note Locks this object for reading.
340 */
341com::Utf8Str HostUSBDevice::i_getName()
342{
343 Utf8Str name;
344
345 AutoCaller autoCaller(this);
346 AssertComRCReturn(autoCaller.rc(), name);
347
348 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
349
350 bool haveManufacturer = mUsb->pszManufacturer && *mUsb->pszManufacturer;
351 bool haveProduct = mUsb->pszProduct && *mUsb->pszProduct;
352 if (haveManufacturer && haveProduct)
353 name = Utf8StrFmt("%s %s", mUsb->pszManufacturer, mUsb->pszProduct);
354 else
355 {
356 Utf8Str strProduct;
357 Utf8Str strVendor = USBIdDatabase::findVendorAndProduct(mUsb->idVendor, mUsb->idProduct, &strProduct);
358 if ( (strVendor.isNotEmpty() || haveManufacturer)
359 && (strProduct.isNotEmpty() || haveProduct))
360 name = Utf8StrFmt("%s %s", haveManufacturer ? mUsb->pszManufacturer
361 : strVendor.c_str(),
362 haveProduct ? mUsb->pszProduct
363 : strProduct.c_str());
364 else
365 {
366 LogRel(("USB: Unknown USB device detected (idVendor: 0x%04x, idProduct: 0x%04x)\n",
367 mUsb->idVendor, mUsb->idProduct));
368 if (strVendor.isNotEmpty())
369 name = strVendor;
370 else
371 {
372 Assert(strProduct.isEmpty());
373 name = "<unknown>";
374 }
375 }
376 }
377
378 return name;
379}
380
381/**
382 * Requests the USB proxy service capture the device (from the host)
383 * and attach it to a VM.
384 *
385 * As a convenience, this method will operate like attachToVM() if the device
386 * is already held by the proxy. Note that it will then perform IPC to the VM
387 * process, which means it will temporarily release all locks. (Is this a good idea?)
388 *
389 * @param aMachine Machine this device should be attach to.
390 * @param aSetError Whether to set full error message or not to bother.
391 * @param aCaptureFilename The filename to capture the USB traffic to.
392 * @param aMaskedIfs The interfaces to hide from the guest.
393 *
394 * @returns Status indicating whether it was successfully captured and/or attached.
395 * @retval S_OK on success.
396 * @retval E_UNEXPECTED if the device state doesn't permit for any attaching.
397 * @retval E_* as appropriate.
398 */
399HRESULT HostUSBDevice::i_requestCaptureForVM(SessionMachine *aMachine, bool aSetError,
400 const com::Utf8Str &aCaptureFilename, ULONG aMaskedIfs /* = 0*/)
401{
402 /*
403 * Validate preconditions and input.
404 */
405 AssertReturn(aMachine, E_INVALIDARG);
406 AssertReturn(!isWriteLockOnCurrentThread(), E_FAIL);
407 AssertReturn(!aMachine->isWriteLockOnCurrentThread(), E_FAIL);
408
409 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
410 LogFlowThisFunc(("{%s} aMachine=%p aMaskedIfs=%#x\n", mName, aMachine, aMaskedIfs));
411
412 if (aSetError)
413 {
414 if (mUniState == kHostUSBDeviceState_Unsupported)
415 return setError(E_INVALIDARG,
416 tr("USB device '%s' with UUID {%RTuuid} cannot be accessed by guest computers"),
417 mName, mId.raw());
418 if (mUniState == kHostUSBDeviceState_UsedByHost)
419 return setError(E_INVALIDARG,
420 tr("USB device '%s' with UUID {%RTuuid} is being exclusively used by the host computer"),
421 mName, mId.raw());
422 if (mUniState == kHostUSBDeviceState_UsedByVM)
423 {
424 /* Machine::name() requires a read lock */
425 alock.release();
426 AutoReadLock machLock(mMachine COMMA_LOCKVAL_SRC_POS);
427 return setError(E_INVALIDARG,
428 tr("USB device '%s' with UUID {%RTuuid} is already captured by the virtual machine '%s'"),
429 mName, mId.raw(), mMachine->i_getName().c_str());
430 }
431 if (mUniState >= kHostUSBDeviceState_FirstTransitional)
432 return setError(E_INVALIDARG,
433 tr("USB device '%s' with UUID {%RTuuid} is busy with a previous request. Please try again later"),
434 mName, mId.raw());
435 if ( mUniState != kHostUSBDeviceState_Unused
436 && mUniState != kHostUSBDeviceState_HeldByProxy
437 && mUniState != kHostUSBDeviceState_Capturable)
438 return setError(E_INVALIDARG,
439 tr("USB device '%s' with UUID {%RTuuid} is not in the right state for capturing (%s)"),
440 mName, mId.raw(), i_getStateName());
441 }
442
443 AssertReturn( mUniState == kHostUSBDeviceState_HeldByProxy
444 || mUniState == kHostUSBDeviceState_Unused
445 || mUniState == kHostUSBDeviceState_Capturable,
446 E_UNEXPECTED);
447 Assert(mMachine.isNull());
448
449 /*
450 * If it's already held by the proxy, we'll simply call
451 * attachToVM synchronously.
452 */
453 if (mUniState == kHostUSBDeviceState_HeldByProxy)
454 {
455 alock.release();
456 HRESULT hrc = i_attachToVM(aMachine, aCaptureFilename, aMaskedIfs);
457 return hrc;
458 }
459
460 /*
461 * Need to capture the device before it can be used.
462 *
463 * The device will be attached to the VM by the USB proxy service thread
464 * when the request succeeds (i.e. asynchronously).
465 */
466 LogFlowThisFunc(("{%s} capturing the device.\n", mName));
467 if (mUSBProxyBackend->i_isDevReEnumerationRequired())
468 i_setState(kHostUSBDeviceState_Capturing, kHostUSBDeviceState_UsedByVM, kHostUSBDeviceSubState_AwaitingDetach);
469 else
470 i_setState(kHostUSBDeviceState_Capturing, kHostUSBDeviceState_UsedByVM);
471
472 mMachine = aMachine;
473 mMaskedIfs = aMaskedIfs;
474 mCaptureFilename = aCaptureFilename;
475 alock.release();
476 int rc = mUSBProxyBackend->captureDevice(this);
477 if (RT_FAILURE(rc))
478 {
479 alock.acquire();
480 i_failTransition(kHostUSBDeviceState_Invalid);
481 mMachine.setNull();
482 if (rc == VERR_SHARING_VIOLATION)
483 return setError(E_FAIL,
484 tr("USB device '%s' with UUID {%RTuuid} is in use by someone else"),
485 mName, mId.raw());
486 return E_FAIL;
487 }
488
489 return S_OK;
490}
491
492/**
493 * Attempts to attach the USB device to a VM.
494 *
495 * The device must be in the HeldByProxy state or about to exit the
496 * Capturing state.
497 *
498 * This method will make an IPC to the VM process and do the actual
499 * attaching. While in the IPC locks will be abandond.
500 *
501 * @returns Status indicating whether it was successfully attached or not.
502 * @retval S_OK on success.
503 * @retval E_UNEXPECTED if the device state doesn't permit for any attaching.
504 * @retval E_* as appropriate.
505 *
506 * @param aMachine Machine this device should be attach to.
507 * @param aCaptureFilename Filename to capture the USB traffic to.
508 * @param aMaskedIfs The interfaces to hide from the guest.
509 */
510HRESULT HostUSBDevice::i_attachToVM(SessionMachine *aMachine, const com::Utf8Str &aCaptureFilename,
511 ULONG aMaskedIfs /* = 0*/)
512{
513 AssertReturn(!isWriteLockOnCurrentThread(), E_FAIL);
514 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
515 /*
516 * Validate and update the state.
517 */
518 AssertReturn( mUniState == kHostUSBDeviceState_Capturing
519 || mUniState == kHostUSBDeviceState_HeldByProxy
520 || mUniState == kHostUSBDeviceState_AttachingToVM,
521 E_UNEXPECTED);
522 i_setState(kHostUSBDeviceState_AttachingToVM, kHostUSBDeviceState_UsedByVM);
523
524 /*
525 * The VM process will query the object, so grab a reference to ourselves and release the locks.
526 */
527 ComPtr<IUSBDevice> d = this;
528
529 /*
530 * Call the VM process (IPC) and request it to attach the device.
531 *
532 * There are many reasons for this to fail, so, as a consequence we don't
533 * assert the return code as it will crash the daemon and annoy the heck
534 * out of people.
535 */
536 LogFlowThisFunc(("{%s} Calling machine->onUSBDeviceAttach()...\n", mName));
537 alock.release();
538 HRESULT hrc = aMachine->i_onUSBDeviceAttach(d, NULL, aMaskedIfs, aCaptureFilename);
539 LogFlowThisFunc(("{%s} Done machine->onUSBDeviceAttach()=%08X\n", mName, hrc));
540
541 /*
542 * As we re-acquire the lock, we'll have to check if the device was
543 * physically detached while we were busy.
544 */
545 alock.acquire();
546
547 if (SUCCEEDED(hrc))
548 {
549 mMachine = aMachine;
550 if (!mIsPhysicallyDetached)
551 i_setState(kHostUSBDeviceState_UsedByVM);
552 else
553 {
554 alock.release();
555 i_detachFromVM(kHostUSBDeviceState_PhysDetached);
556 hrc = E_UNEXPECTED;
557 }
558 }
559 else
560 {
561 mMachine.setNull();
562 if (!mIsPhysicallyDetached)
563 {
564 i_setState(kHostUSBDeviceState_HeldByProxy);
565 if (hrc == E_UNEXPECTED)
566 hrc = E_FAIL; /* No confusion. */
567 }
568 else
569 {
570 alock.release();
571 i_onPhysicalDetachedInternal();
572 hrc = E_UNEXPECTED;
573 }
574 }
575 return hrc;
576}
577
578
579/**
580 * Detaches the device from the VM.
581 *
582 * This is used for a special scenario in attachToVM() and from
583 * onPhysicalDetachedInternal().
584 *
585 * @param aFinalState The final state (PhysDetached).
586 */
587void HostUSBDevice::i_detachFromVM(HostUSBDeviceState aFinalState)
588{
589 NOREF(aFinalState);
590
591 /*
592 * Assert preconditions.
593 */
594 Assert(aFinalState == kHostUSBDeviceState_PhysDetached);
595 AssertReturnVoid(!isWriteLockOnCurrentThread());
596 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
597 Assert( mUniState == kHostUSBDeviceState_AttachingToVM
598 || mUniState == kHostUSBDeviceState_UsedByVM);
599 Assert(!mMachine.isNull());
600
601 /*
602 * Change the state and abandon the locks. The VM may query
603 * data and we don't want to deadlock - the state protects us,
604 * so, it's not a bit issue here.
605 */
606 i_setState(kHostUSBDeviceState_PhysDetachingFromVM, kHostUSBDeviceState_PhysDetached);
607
608 /*
609 * Call the VM process (IPC) and request it to detach the device.
610 *
611 * There are many reasons for this to fail, so, as a consequence we don't
612 * assert the return code as it will crash the daemon and annoy the heck
613 * out of people.
614 */
615 alock.release();
616 LogFlowThisFunc(("{%s} Calling machine->onUSBDeviceDetach()...\n", mName));
617 HRESULT hrc = mMachine->i_onUSBDeviceDetach(mId.toUtf16().raw(), NULL);
618 LogFlowThisFunc(("{%s} Done machine->onUSBDeviceDetach()=%Rhrc\n", mName, hrc));
619 NOREF(hrc);
620
621 /*
622 * Re-acquire the locks and complete the transition.
623 */
624 alock.acquire();
625 i_advanceTransition();
626}
627
628/**
629 * Called when the VM process to inform us about the device being
630 * detached from it.
631 *
632 * This is NOT called when we detach the device via onUSBDeviceDetach.
633 *
634 *
635 * @param[in] aMachine The machine making the request.
636 * This must be the machine this device is currently attached to.
637 * @param[in] aDone When set to false, the VM just informs us that it's about
638 * to detach this device but hasn't done it just yet.
639 * When set to true, the VM informs us that it has completed
640 * the detaching of this device.
641 * @param[out] aRunFilters Whether to run filters.
642 * @param[in] aAbnormal Set if we're cleaning up after a crashed VM.
643 *
644 * @returns S_OK on success, and E_UNEXPECTED if the device isn't in the right state.
645 *
646 * @note Must be called from under the object write lock.
647 */
648HRESULT HostUSBDevice::i_onDetachFromVM(SessionMachine *aMachine, bool aDone, bool *aRunFilters, bool aAbnormal /*= true*/)
649{
650 LogFlowThisFunc(("{%s} state=%s aDone=%RTbool aAbnormal=%RTbool\n", mName, i_getStateName(), aDone, aAbnormal));
651
652 /*
653 * Validate preconditions.
654 */
655 AssertPtrReturn(aRunFilters, E_INVALIDARG);
656 AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
657 if (!aDone)
658 {
659 if (mUniState != kHostUSBDeviceState_UsedByVM)
660 return setError(E_INVALIDARG,
661 tr("USB device '%s' with UUID {%RTuuid} is busy (state '%s'). Please try again later"),
662 mName, mId.raw(), i_getStateName());
663 }
664 else
665 AssertMsgReturn( mUniState == kHostUSBDeviceState_DetachingFromVM /** @todo capturing for VM
666 ends up here on termination. */
667 || (mUniState == kHostUSBDeviceState_UsedByVM && aAbnormal),
668 ("{%s} %s\n", mName, i_getStateName()), E_UNEXPECTED);
669 AssertMsgReturn((mMachine == aMachine), ("%p != %p\n", (void *)mMachine, aMachine), E_FAIL);
670
671 /*
672 * Change the state.
673 */
674 if (!aDone)
675 {
676 *aRunFilters = i_startTransition(kHostUSBDeviceState_DetachingFromVM, kHostUSBDeviceState_HeldByProxy);
677 /* PORTME: This might require host specific changes if you re-enumerate the device. */
678 }
679 else if (aAbnormal && mUniState == kHostUSBDeviceState_UsedByVM)
680 {
681 /* Fast forward thru the DetachingFromVM state and on to HeldByProxy. */
682 /** @todo need to update the state machine to handle crashed VMs. */
683 i_startTransition(kHostUSBDeviceState_DetachingFromVM, kHostUSBDeviceState_HeldByProxy);
684 *aRunFilters = i_advanceTransition();
685 mMachine.setNull();
686 /* PORTME: ditto / trouble if you depend on the VM process to do anything. */
687 }
688 else
689 {
690 /* normal completion. */
691 Assert(mUniSubState == kHostUSBDeviceSubState_Default); /* PORTME: ditto */
692 *aRunFilters = i_advanceTransition();
693 mMachine.setNull();
694 }
695
696 return S_OK;
697}
698
699/**
700 * Requests the USB proxy service to release the device back to the host.
701 *
702 * This method will ignore (not assert) calls for devices that already
703 * belong to the host because it simplifies the usage a bit.
704 *
705 * @returns COM status code.
706 * @retval S_OK on success.
707 * @retval E_UNEXPECTED on bad state.
708 * @retval E_* as appropriate.
709 *
710 * @note Must be called without holding the object lock.
711 */
712HRESULT HostUSBDevice::i_requestReleaseToHost()
713{
714 /*
715 * Validate preconditions.
716 */
717 AssertReturn(!isWriteLockOnCurrentThread(), E_FAIL);
718 Assert(mMachine.isNull());
719
720 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
721 LogFlowThisFunc(("{%s}\n", mName));
722 if ( mUniState == kHostUSBDeviceState_Unused
723 || mUniState == kHostUSBDeviceState_Capturable)
724 return S_OK;
725 AssertMsgReturn(mUniState == kHostUSBDeviceState_HeldByProxy, ("{%s} %s\n", mName, i_getStateName()), E_UNEXPECTED);
726
727 /*
728 * Try release it.
729 */
730 if (mUSBProxyBackend->i_isDevReEnumerationRequired())
731 i_startTransition(kHostUSBDeviceState_ReleasingToHost, kHostUSBDeviceState_Unused, kHostUSBDeviceSubState_AwaitingDetach);
732 else
733 i_startTransition(kHostUSBDeviceState_ReleasingToHost, kHostUSBDeviceState_Unused);
734
735 alock.release();
736 int rc = mUSBProxyBackend->releaseDevice(this);
737 if (RT_FAILURE(rc))
738 {
739 alock.acquire();
740 i_failTransition(kHostUSBDeviceState_Invalid);
741 return E_FAIL;
742 }
743 return S_OK;
744}
745
746/**
747 * Requests the USB proxy service to capture and hold the device.
748 *
749 * The device must be owned by the host at the time of the call. But for
750 * the callers convenience, calling this method on a device that is already
751 * being held will success without any assertions.
752 *
753 * @returns COM status code.
754 * @retval S_OK on success.
755 * @retval E_UNEXPECTED on bad state.
756 * @retval E_* as appropriate.
757 *
758 * @note Must be called without holding the object lock.
759 */
760HRESULT HostUSBDevice::i_requestHold()
761{
762 /*
763 * Validate preconditions.
764 */
765 AssertReturn(!isWriteLockOnCurrentThread(), E_FAIL);
766 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
767 LogFlowThisFunc(("{%s}\n", mName));
768 AssertMsgReturn( mUniState == kHostUSBDeviceState_Unused
769 || mUniState == kHostUSBDeviceState_Capturable
770 || mUniState == kHostUSBDeviceState_HeldByProxy,
771 ("{%s} %s\n", mName, i_getStateName()),
772 E_UNEXPECTED);
773
774 Assert(mMachine.isNull());
775 mMachine.setNull();
776
777 if (mUniState == kHostUSBDeviceState_HeldByProxy)
778 return S_OK;
779
780 /*
781 * Do the job.
782 */
783 if (mUSBProxyBackend->i_isDevReEnumerationRequired())
784 i_startTransition(kHostUSBDeviceState_Capturing, kHostUSBDeviceState_HeldByProxy, kHostUSBDeviceSubState_AwaitingDetach);
785 else
786 i_startTransition(kHostUSBDeviceState_Capturing, kHostUSBDeviceState_HeldByProxy);
787
788 alock.release();
789 int rc = mUSBProxyBackend->captureDevice(this);
790 if (RT_FAILURE(rc))
791 {
792 alock.acquire();
793 i_failTransition(kHostUSBDeviceState_Invalid);
794 return E_FAIL;
795 }
796 return S_OK;
797}
798
799
800/**
801 * Check a detach detected by the USB Proxy Service to see if
802 * it's a real one or just a logical following a re-enumeration.
803 *
804 * This will work the internal sub state of the device and do time
805 * outs, so it does more than just querying data!
806 *
807 * @returns true if it was actually detached, false if it's just a re-enumeration.
808 */
809bool HostUSBDevice::i_wasActuallyDetached()
810{
811 /*
812 * This only applies to the detach and re-attach states.
813 */
814 switch (mUniState)
815 {
816 case kHostUSBDeviceState_Capturing:
817 case kHostUSBDeviceState_ReleasingToHost:
818 case kHostUSBDeviceState_AttachingToVM:
819 case kHostUSBDeviceState_DetachingFromVM:
820 switch (mUniSubState)
821 {
822 /*
823 * If we're awaiting a detach, the this has now occurred
824 * and the state should be advanced.
825 */
826 case kHostUSBDeviceSubState_AwaitingDetach:
827 i_advanceTransition();
828 return false; /* not physically detached. */
829
830 /*
831 * Check for timeouts.
832 */
833 case kHostUSBDeviceSubState_AwaitingReAttach:
834 {
835#ifndef RT_OS_WINDOWS /* check the implementation details here. */
836 uint64_t elapsedNanoseconds = RTTimeNanoTS() - mLastStateChangeTS;
837 if (elapsedNanoseconds > UINT64_C(60000000000)) /* 60 seconds */
838 {
839 LogRel(("USB: Async operation timed out for device %s (state: %s)\n", mName, i_getStateName()));
840 i_failTransition(kHostUSBDeviceState_PhysDetached);
841 }
842#endif
843 return false; /* not physically detached. */
844 }
845
846 /* not applicable.*/
847 case kHostUSBDeviceSubState_Default:
848 break;
849 }
850 break;
851
852 /* not applicable. */
853 case kHostUSBDeviceState_Unsupported:
854 case kHostUSBDeviceState_UsedByHost:
855 case kHostUSBDeviceState_Capturable:
856 case kHostUSBDeviceState_Unused:
857 case kHostUSBDeviceState_HeldByProxy:
858 case kHostUSBDeviceState_UsedByVM:
859 case kHostUSBDeviceState_PhysDetachingFromVM:
860 case kHostUSBDeviceState_PhysDetached:
861 break;
862
863 default:
864 AssertLogRelMsgFailed(("this=%p %s\n", this, i_getStateName()));
865 break;
866 }
867
868 /* It was detached. */
869 return true;
870}
871
872/**
873 * Notification from the USB Proxy that the device was physically detached.
874 *
875 * If a transition is pending, mIsPhysicallyDetached will be set and
876 * handled when the transition advances forward.
877 *
878 * Otherwise the device will be detached from any VM currently using it - this
879 * involves IPC and will temporarily abandon locks - and all the device data
880 * reset.
881 */
882void HostUSBDevice::i_onPhysicalDetached()
883{
884 AssertReturnVoid(!isWriteLockOnCurrentThread());
885 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
886 LogFlowThisFunc(("{%s}\n", mName));
887
888 mIsPhysicallyDetached = true;
889 if (mUniState < kHostUSBDeviceState_FirstTransitional)
890 {
891 alock.release();
892 i_onPhysicalDetachedInternal();
893 }
894}
895
896
897/**
898 * Do the physical detach work for a device in a stable state or
899 * at a transition state change.
900 *
901 * See onPhysicalDetach() for details.
902 */
903void HostUSBDevice::i_onPhysicalDetachedInternal()
904{
905 AssertReturnVoid(!isWriteLockOnCurrentThread());
906 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
907 LogFlowThisFunc(("{%s}\n", mName));
908 Assert(mIsPhysicallyDetached);
909
910 /*
911 * Do we need to detach it from the VM first?
912 */
913 if ( !mMachine.isNull()
914 && ( mUniState == kHostUSBDeviceState_UsedByVM
915 || mUniState == kHostUSBDeviceState_AttachingToVM))
916 {
917 alock.release();
918 i_detachFromVM(kHostUSBDeviceState_PhysDetached);
919 alock.acquire();
920 }
921 else
922 AssertMsg(mMachine.isNull(), ("%s\n", i_getStateName()));
923
924 /*
925 * Reset the data and enter the final state.
926 */
927 mMachine.setNull();
928 i_setState(kHostUSBDeviceState_PhysDetached);
929}
930
931
932/**
933 * Returns true if this device matches the given filter data.
934 *
935 * @note It is assumed, that the filter data owner is appropriately
936 * locked before calling this method.
937 *
938 * @note
939 * This method MUST correlate with
940 * USBController::hasMatchingFilter (IUSBDevice *)
941 * in the sense of the device matching logic.
942 *
943 * @note Locks this object for reading.
944 */
945bool HostUSBDevice::i_isMatch(const USBDeviceFilter::BackupableUSBDeviceFilterData &aData)
946{
947 AutoCaller autoCaller(this);
948 AssertComRCReturn(autoCaller.rc(), false);
949
950 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
951
952 if (!aData.mData.fActive)
953 return false;
954
955 if (!aData.mRemote.isMatch(FALSE))
956 return false;
957
958 if (!USBFilterMatchDevice(&aData.mUSBFilter, mUsb))
959 return false;
960
961 /* Don't match busy devices with a 100% wildcard filter - this will
962 later become a filter prop (ring-3 only). */
963 if ( mUsb->enmState == USBDEVICESTATE_USED_BY_HOST_CAPTURABLE
964 && !USBFilterHasAnySubstatialCriteria(&aData.mUSBFilter))
965 return false;
966
967 LogFlowThisFunc(("returns true\n"));
968 return true;
969}
970
971/**
972 * Compares this device with a USBDEVICE and decides if the match or which comes first.
973 *
974 * This will take into account device re-attaching and omit the bits
975 * that may change during a device re-enumeration.
976 *
977 * @param aDev2 Device 2.
978 *
979 * @returns < 0 if this should come before aDev2.
980 * @returns 0 if this and aDev2 are equal.
981 * @returns > 0 if this should come after aDev2.
982 *
983 * @note Must be called from under the object write lock.
984 */
985int HostUSBDevice::i_compare(PCUSBDEVICE aDev2)
986{
987 AssertReturn(isWriteLockOnCurrentThread(), -1);
988 //Log3(("%Rfn: %p {%s}\n", __PRETTY_FUNCTION__, this, mName));
989 return i_compare(mUsb, aDev2,
990 mUniSubState == kHostUSBDeviceSubState_AwaitingDetach /* (In case we don't get the detach notice.) */
991 || mUniSubState == kHostUSBDeviceSubState_AwaitingReAttach);
992}
993
994/**
995 * Compares two USBDEVICE structures and decides if the match or which comes first.
996 *
997 * @param aDev1 Device 1.
998 * @param aDev2 Device 2.
999 * @param aIsAwaitingReAttach Whether to omit bits that will change in a device
1000 * re-enumeration (true) or not (false).
1001 *
1002 * @returns < 0 if aDev1 should come before aDev2.
1003 * @returns 0 if aDev1 and aDev2 are equal.
1004 * @returns > 0 if aDev1 should come after aDev2.
1005 */
1006/*static*/
1007int HostUSBDevice::i_compare(PCUSBDEVICE aDev1, PCUSBDEVICE aDev2, bool aIsAwaitingReAttach /*= false */)
1008{
1009 /* Comparing devices from different backends doesn't make any sense and should not happen. */
1010 AssertReturn(!strcmp(aDev1->pszBackend, aDev2->pszBackend), -1);
1011
1012 /*
1013 * Things that stays the same everywhere.
1014 *
1015 * The more uniquely these properties identifies a device the less the chance
1016 * that we mix similar devices during re-enumeration. Bus+port would help
1017 * provide ~99.8% accuracy if the host can provide those attributes.
1018 */
1019 int iDiff = aDev1->idVendor - aDev2->idVendor;
1020 if (iDiff)
1021 return iDiff;
1022
1023 iDiff = aDev1->idProduct - aDev2->idProduct;
1024 if (iDiff)
1025 return iDiff;
1026
1027 iDiff = aDev1->bcdDevice - aDev2->bcdDevice;
1028 if (iDiff)
1029 {
1030 //Log3(("compare: bcdDevice: %#x != %#x\n", aDev1->bcdDevice, aDev2->bcdDevice));
1031 return iDiff;
1032 }
1033
1034#ifdef RT_OS_WINDOWS /* the string query may fail on windows during replugging, ignore serial mismatch if this is the case. */
1035 if ( aDev1->u64SerialHash != aDev2->u64SerialHash
1036 && ( !aIsAwaitingReAttach
1037 || (aDev2->pszSerialNumber && *aDev2->pszSerialNumber)
1038 || (aDev2->pszManufacturer && *aDev2->pszManufacturer)
1039 || (aDev2->pszProduct && *aDev2->pszProduct))
1040 )
1041#else
1042 if (aDev1->u64SerialHash != aDev2->u64SerialHash)
1043#endif
1044 {
1045 //Log3(("compare: u64SerialHash: %#llx != %#llx\n", aDev1->u64SerialHash, aDev2->u64SerialHash));
1046 return aDev1->u64SerialHash < aDev2->u64SerialHash ? -1 : 1;
1047 }
1048
1049 /* The hub/bus + port should help a lot in a re-attach situation. */
1050#ifdef RT_OS_WINDOWS
1051 /* The hub name makes only sense for the host backend. */
1052 if ( !strcmp(aDev1->pszBackend, "host")
1053 && aDev1->pszHubName
1054 && aDev2->pszHubName)
1055 {
1056 iDiff = strcmp(aDev1->pszHubName, aDev2->pszHubName);
1057 if (iDiff)
1058 {
1059 //Log3(("compare: HubName: %s != %s\n", aDev1->pszHubName, aDev2->pszHubName));
1060 return iDiff;
1061 }
1062 }
1063#else
1064 iDiff = aDev1->bBus - aDev2->bBus;
1065 if (iDiff)
1066 {
1067 //Log3(("compare: bBus: %#x != %#x\n", aDev1->bBus, aDev2->bBus));
1068 return iDiff;
1069 }
1070#endif
1071
1072 iDiff = aDev1->bPort - aDev2->bPort; /* shouldn't change anywhere and help pinpoint it very accurately. */
1073 if (iDiff)
1074 {
1075 //Log3(("compare: bPort: %#x != %#x\n", aDev1->bPort, aDev2->bPort));
1076 return iDiff;
1077 }
1078
1079 /*
1080 * Things that usually doesn't stay the same when re-enumerating
1081 * a device. The fewer things in the category the better chance
1082 * that we avoid messing up when more than one device of the same
1083 * kind is attached.
1084 */
1085 if (aIsAwaitingReAttach)
1086 {
1087 //Log3(("aDev1=%p == aDev2=%p\n", aDev1, aDev2));
1088 return 0;
1089 }
1090 /* device number always changes. */
1091 return strcmp(aDev1->pszAddress, aDev2->pszAddress);
1092}
1093
1094/**
1095 * Updates the state of the device.
1096 *
1097 * If this method returns @c true, Host::onUSBDeviceStateChanged() will be
1098 * called to process the state change (complete the state change request,
1099 * inform the VM process etc.).
1100 *
1101 * If this method returns @c false, it is assumed that the given state change
1102 * is "minor": it doesn't require any further action other than update the
1103 * mState field with the actual state value.
1104 *
1105 * Regardless of the return value, this method always takes ownership of the
1106 * new USBDEVICE structure passed in and updates the pNext and pPrev fiends in
1107 * it using the values of the old structure.
1108 *
1109 * @param[in] aDev The current device state as seen by the proxy backend.
1110 * @param[out] aRunFilters Whether the state change should be accompanied by
1111 * running filters on the device.
1112 * @param[out] aIgnoreMachine Machine to ignore when running filters.
1113 *
1114 * @returns Whether the Host object should be bothered with this state change.
1115 *
1116 * @todo Just do everything here, that is, call filter runners and everything that
1117 * works by state change. Using 3 return codes/parameters is just plain ugly.
1118 */
1119bool HostUSBDevice::i_updateState(PCUSBDEVICE aDev, bool *aRunFilters, SessionMachine **aIgnoreMachine)
1120{
1121 *aRunFilters = false;
1122 *aIgnoreMachine = NULL;
1123
1124 /*
1125 * Locking.
1126 */
1127 AssertReturn(!isWriteLockOnCurrentThread(), false);
1128 AutoCaller autoCaller(this);
1129 AssertComRCReturn(autoCaller.rc(), false);
1130 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1131
1132 /*
1133 * Replace the existing structure by the new one.
1134 */
1135 const USBDEVICESTATE enmOldState = mUsb->enmState; NOREF(enmOldState);
1136 if (mUsb != aDev)
1137 {
1138#if defined(RT_OS_WINDOWS)
1139 /* we used this logic of string comparison in HostUSBDevice::compare
1140 * now we need to preserve strings from the old device if the new device has zero strings
1141 * this ensures the device is correctly matched later on
1142 * otherwise we may end up with a phantom misconfigured device instance */
1143 if ((mUniSubState == kHostUSBDeviceSubState_AwaitingDetach /* (In case we don't get the detach notice.) */
1144 || mUniSubState == kHostUSBDeviceSubState_AwaitingReAttach)
1145 && (!aDev->pszSerialNumber || !*aDev->pszSerialNumber)
1146 && (!aDev->pszManufacturer || !*aDev->pszManufacturer)
1147 && (!aDev->pszProduct || !*aDev->pszProduct))
1148 {
1149 aDev->u64SerialHash = mUsb->u64SerialHash;
1150
1151 if (mUsb->pszSerialNumber && *mUsb->pszSerialNumber)
1152 {
1153 if (aDev->pszSerialNumber)
1154 RTStrFree((char *)aDev->pszSerialNumber);
1155
1156 /* since we're going to free old device later on,
1157 * we can just assign the string from it to the new device
1158 * and zero up the string filed for the old device */
1159 aDev->pszSerialNumber = mUsb->pszSerialNumber;
1160 mUsb->pszSerialNumber = NULL;
1161 }
1162
1163 if (mUsb->pszManufacturer && *mUsb->pszManufacturer)
1164 {
1165 if (aDev->pszManufacturer)
1166 RTStrFree((char *)aDev->pszManufacturer);
1167
1168 /* since we're going to free old device later on,
1169 * we can just assign the string from it to the new device
1170 * and zero up the string filed for the old device */
1171 aDev->pszManufacturer = mUsb->pszManufacturer;
1172 mUsb->pszManufacturer = NULL;
1173 }
1174
1175 if (mUsb->pszProduct && *mUsb->pszProduct)
1176 {
1177 if (aDev->pszProduct)
1178 RTStrFree((char *)aDev->pszProduct);
1179
1180 /* since we're going to free old device later on,
1181 * we can just assign the string from it to the new device
1182 * and zero up the string filed for the old device */
1183 aDev->pszProduct = mUsb->pszProduct;
1184 mUsb->pszProduct = NULL;
1185 }
1186 }
1187#endif
1188 aDev->pNext = mUsb->pNext;
1189 aDev->pPrev = mUsb->pPrev;
1190 USBProxyBackend::freeDevice(mUsb);
1191 mUsb = aDev;
1192 }
1193
1194/*
1195 * Defined on hosts where we have a driver that keeps proper device states.
1196 */
1197# if defined(RT_OS_LINUX)
1198# define HOSTUSBDEVICE_FUZZY_STATE 1
1199# else
1200# undef HOSTUSBDEVICE_FUZZY_STATE
1201# endif
1202 /*
1203 * For some hosts we'll have to be pretty careful here because
1204 * they don't always have a clue what is going on. This is
1205 * particularly true on linux and solaris, while windows and
1206 * darwin generally knows a bit more.
1207 */
1208 bool fIsImportant = false;
1209 if (enmOldState != mUsb->enmState)
1210 {
1211 LogFlowThisFunc(("%p {%s} %s\n", this, mName, i_getStateName()));
1212 switch (mUsb->enmState)
1213 {
1214 /*
1215 * Little fuzziness here, except where we fake capture.
1216 */
1217 case USBDEVICESTATE_USED_BY_HOST:
1218 switch (mUniState)
1219 {
1220 /* Host drivers installed, that's fine. */
1221 case kHostUSBDeviceState_Capturable:
1222 case kHostUSBDeviceState_Unused:
1223 LogThisFunc(("{%s} %s -> %s\n", mName, i_getStateName(), i_stateName(kHostUSBDeviceState_UsedByHost)));
1224 *aRunFilters = i_setState(kHostUSBDeviceState_UsedByHost);
1225 break;
1226 case kHostUSBDeviceState_UsedByHost:
1227 break;
1228
1229 /* Can only mean that we've failed capturing it. */
1230 case kHostUSBDeviceState_Capturing:
1231 LogThisFunc(("{%s} capture failed! (#1)\n", mName));
1232 mUSBProxyBackend->captureDeviceCompleted(this, false /* aSuccess */);
1233 *aRunFilters = i_failTransition(kHostUSBDeviceState_UsedByHost);
1234 mMachine.setNull();
1235 break;
1236
1237 /* Guess we've successfully released it. */
1238 case kHostUSBDeviceState_ReleasingToHost:
1239 LogThisFunc(("{%s} %s -> %s\n", mName, i_getStateName(), i_stateName(kHostUSBDeviceState_UsedByHost)));
1240 mUSBProxyBackend->releaseDeviceCompleted(this, true /* aSuccess */);
1241 *aRunFilters = i_setState(kHostUSBDeviceState_UsedByHost);
1242 break;
1243
1244 /* These are IPC states and should be left alone. */
1245 case kHostUSBDeviceState_AttachingToVM:
1246 case kHostUSBDeviceState_DetachingFromVM:
1247 case kHostUSBDeviceState_PhysDetachingFromVM:
1248 LogThisFunc(("{%s} %s - changed to USED_BY_HOST...\n", mName, i_getStateName()));
1249 break;
1250
1251#ifdef HOSTUSBDEVICE_FUZZY_STATE
1252 /* Fake: We can't prevent anyone from grabbing it. */
1253 case kHostUSBDeviceState_HeldByProxy:
1254 LogThisFunc(("{%s} %s -> %s!\n", mName, i_getStateName(), i_stateName(kHostUSBDeviceState_UsedByHost)));
1255 *aRunFilters = i_setState(kHostUSBDeviceState_UsedByHost);
1256 break;
1257 //case kHostUSBDeviceState_UsedByVM:
1258 // /** @todo needs to be detached from the VM. */
1259 // break;
1260#endif
1261 /* Not supposed to happen... */
1262#ifndef HOSTUSBDEVICE_FUZZY_STATE
1263 case kHostUSBDeviceState_HeldByProxy:
1264#endif
1265 case kHostUSBDeviceState_UsedByVM:
1266 case kHostUSBDeviceState_PhysDetached:
1267 case kHostUSBDeviceState_Unsupported:
1268 default:
1269 AssertMsgFailed(("{%s} %s\n", mName, i_getStateName()));
1270 break;
1271 }
1272 break;
1273
1274 /*
1275 * It changed to capturable. Fuzzy hosts might easily
1276 * confuse UsedByVM with this one.
1277 */
1278 case USBDEVICESTATE_USED_BY_HOST_CAPTURABLE:
1279 switch (mUniState)
1280 {
1281 /* No change. */
1282#ifdef HOSTUSBDEVICE_FUZZY_STATE
1283 case kHostUSBDeviceState_HeldByProxy:
1284 case kHostUSBDeviceState_UsedByVM:
1285#endif
1286 case kHostUSBDeviceState_Capturable:
1287 break;
1288
1289 /* Changed! */
1290 case kHostUSBDeviceState_UsedByHost:
1291 fIsImportant = true;
1292 RT_FALL_THRU();
1293 case kHostUSBDeviceState_Unused:
1294 LogThisFunc(("{%s} %s -> %s\n", mName, i_getStateName(), i_stateName(kHostUSBDeviceState_Capturable)));
1295 *aRunFilters = i_setState(kHostUSBDeviceState_Capturable);
1296 break;
1297
1298 /* Can only mean that we've failed capturing it. */
1299 case kHostUSBDeviceState_Capturing:
1300 LogThisFunc(("{%s} capture failed! (#2)\n", mName));
1301 mUSBProxyBackend->captureDeviceCompleted(this, false /* aSuccess */);
1302 *aRunFilters = i_failTransition(kHostUSBDeviceState_Capturable);
1303 mMachine.setNull();
1304 break;
1305
1306 /* Guess we've successfully released it. */
1307 case kHostUSBDeviceState_ReleasingToHost:
1308 LogThisFunc(("{%s} %s -> %s\n", mName, i_getStateName(), i_stateName(kHostUSBDeviceState_Capturable)));
1309 mUSBProxyBackend->releaseDeviceCompleted(this, true /* aSuccess */);
1310 *aRunFilters = i_setState(kHostUSBDeviceState_Capturable);
1311 break;
1312
1313 /* These are IPC states and should be left alone. */
1314 case kHostUSBDeviceState_AttachingToVM:
1315 case kHostUSBDeviceState_DetachingFromVM:
1316 case kHostUSBDeviceState_PhysDetachingFromVM:
1317 LogThisFunc(("{%s} %s - changed to USED_BY_HOST_CAPTURABLE...\n", mName, i_getStateName()));
1318 break;
1319
1320 /* Not supposed to happen*/
1321#ifndef HOSTUSBDEVICE_FUZZY_STATE
1322 case kHostUSBDeviceState_HeldByProxy:
1323 case kHostUSBDeviceState_UsedByVM:
1324#endif
1325 case kHostUSBDeviceState_Unsupported:
1326 case kHostUSBDeviceState_PhysDetached:
1327 default:
1328 AssertMsgFailed(("{%s} %s\n", mName, i_getStateName()));
1329 break;
1330 }
1331 break;
1332
1333
1334 /*
1335 * It changed to capturable. Fuzzy hosts might easily
1336 * confuse UsedByVM and HeldByProxy with this one.
1337 */
1338 case USBDEVICESTATE_UNUSED:
1339 switch (mUniState)
1340 {
1341 /* No change. */
1342#ifdef HOSTUSBDEVICE_FUZZY_STATE
1343 case kHostUSBDeviceState_HeldByProxy:
1344 case kHostUSBDeviceState_UsedByVM:
1345#endif
1346 case kHostUSBDeviceState_Unused:
1347 break;
1348
1349 /* Changed! */
1350 case kHostUSBDeviceState_UsedByHost:
1351 case kHostUSBDeviceState_Capturable:
1352 fIsImportant = true;
1353 LogThisFunc(("{%s} %s -> %s\n", mName, i_getStateName(), i_stateName(kHostUSBDeviceState_Unused)));
1354 *aRunFilters = i_setState(kHostUSBDeviceState_Unused);
1355 break;
1356
1357 /* Can mean that we've failed capturing it, but on windows it is the detach signal. */
1358 case kHostUSBDeviceState_Capturing:
1359#if defined(RT_OS_WINDOWS)
1360 if (mUniSubState == kHostUSBDeviceSubState_AwaitingDetach)
1361 {
1362 LogThisFunc(("{%s} capture advancing thru UNUSED...\n", mName));
1363 *aRunFilters = i_advanceTransition();
1364 }
1365 else
1366#endif
1367 {
1368 LogThisFunc(("{%s} capture failed! (#3)\n", mName));
1369 mUSBProxyBackend->captureDeviceCompleted(this, false /* aSuccess */);
1370 *aRunFilters = i_failTransition(kHostUSBDeviceState_Unused);
1371 mMachine.setNull();
1372 }
1373 break;
1374
1375 /* Guess we've successfully released it. */
1376 case kHostUSBDeviceState_ReleasingToHost:
1377 LogThisFunc(("{%s} %s -> %s\n", mName, i_getStateName(), i_stateName(kHostUSBDeviceState_Unused)));
1378 mUSBProxyBackend->releaseDeviceCompleted(this, true /* aSuccess */);
1379 *aRunFilters = i_setState(kHostUSBDeviceState_Unused);
1380 break;
1381
1382 /* These are IPC states and should be left alone. */
1383 case kHostUSBDeviceState_AttachingToVM:
1384 case kHostUSBDeviceState_DetachingFromVM:
1385 case kHostUSBDeviceState_PhysDetachingFromVM:
1386 LogThisFunc(("{%s} %s - changed to UNUSED...\n", mName, i_getStateName()));
1387 break;
1388
1389 /* Not supposed to happen*/
1390#ifndef HOSTUSBDEVICE_FUZZY_STATE
1391 case kHostUSBDeviceState_HeldByProxy:
1392 case kHostUSBDeviceState_UsedByVM:
1393#endif
1394 case kHostUSBDeviceState_Unsupported:
1395 case kHostUSBDeviceState_PhysDetached:
1396 default:
1397 AssertMsgFailed(("{%s} %s\n", mName, i_getStateName()));
1398 break;
1399 }
1400 break;
1401
1402 /*
1403 * This is pretty straight forward, except that everyone
1404 * might sometimes confuse this and the UsedByVM state.
1405 */
1406 case USBDEVICESTATE_HELD_BY_PROXY:
1407 switch (mUniState)
1408 {
1409 /* No change. */
1410 case kHostUSBDeviceState_HeldByProxy:
1411 break;
1412 case kHostUSBDeviceState_UsedByVM:
1413 LogThisFunc(("{%s} %s - changed to HELD_BY_PROXY...\n", mName, i_getStateName()));
1414 break;
1415
1416 /* Guess we've successfully captured it. */
1417 case kHostUSBDeviceState_Capturing:
1418 LogThisFunc(("{%s} capture succeeded!\n", mName));
1419 mUSBProxyBackend->captureDeviceCompleted(this, true /* aSuccess */);
1420 *aRunFilters = i_advanceTransition(true /* fast forward thru re-attach */);
1421
1422 /* Take action if we're supposed to attach it to a VM. */
1423 if (mUniState == kHostUSBDeviceState_AttachingToVM)
1424 {
1425 alock.release();
1426 i_attachToVM(mMachine, mCaptureFilename, mMaskedIfs);
1427 alock.acquire();
1428 }
1429 break;
1430
1431 /* Can only mean that we've failed capturing it. */
1432 case kHostUSBDeviceState_ReleasingToHost:
1433 LogThisFunc(("{%s} %s failed!\n", mName, i_getStateName()));
1434 mUSBProxyBackend->releaseDeviceCompleted(this, false /* aSuccess */);
1435 *aRunFilters = i_setState(kHostUSBDeviceState_HeldByProxy);
1436 break;
1437
1438 /* These are IPC states and should be left alone. */
1439 case kHostUSBDeviceState_AttachingToVM:
1440 case kHostUSBDeviceState_DetachingFromVM:
1441 case kHostUSBDeviceState_PhysDetachingFromVM:
1442 LogThisFunc(("{%s} %s - changed to HELD_BY_PROXY...\n", mName, i_getStateName()));
1443 break;
1444
1445 /* Not supposed to happen. */
1446 case kHostUSBDeviceState_Unsupported:
1447 case kHostUSBDeviceState_UsedByHost:
1448 case kHostUSBDeviceState_Capturable:
1449 case kHostUSBDeviceState_Unused:
1450 case kHostUSBDeviceState_PhysDetached:
1451 default:
1452 AssertMsgFailed(("{%s} %s\n", mName, i_getStateName()));
1453 break;
1454 }
1455 break;
1456
1457 /*
1458 * This is very straight forward and only Darwin implements it.
1459 */
1460 case USBDEVICESTATE_USED_BY_GUEST:
1461 switch (mUniState)
1462 {
1463 /* No change. */
1464 case kHostUSBDeviceState_HeldByProxy:
1465 LogThisFunc(("{%s} %s - changed to USED_BY_GUEST...\n", mName, i_getStateName()));
1466 break;
1467 case kHostUSBDeviceState_UsedByVM:
1468 break;
1469
1470 /* These are IPC states and should be left alone. */
1471 case kHostUSBDeviceState_AttachingToVM:
1472 case kHostUSBDeviceState_DetachingFromVM:
1473 case kHostUSBDeviceState_PhysDetachingFromVM:
1474 LogThisFunc(("{%s} %s - changed to USED_BY_GUEST...\n", mName, i_getStateName()));
1475 break;
1476
1477 /* Not supposed to happen. */
1478 case kHostUSBDeviceState_Unsupported:
1479 case kHostUSBDeviceState_Capturable:
1480 case kHostUSBDeviceState_Unused:
1481 case kHostUSBDeviceState_UsedByHost:
1482 case kHostUSBDeviceState_PhysDetached:
1483 case kHostUSBDeviceState_ReleasingToHost:
1484 case kHostUSBDeviceState_Capturing:
1485 default:
1486 AssertMsgFailed(("{%s} %s\n", mName, i_getStateName()));
1487 break;
1488 }
1489 break;
1490
1491 /*
1492 * This is not supposed to happen and indicates a bug in the backend!
1493 */
1494 case USBDEVICESTATE_UNSUPPORTED:
1495 AssertMsgFailed(("enmOldState=%d {%s} %s\n", enmOldState, mName, i_getStateName()));
1496 break;
1497 default:
1498 AssertMsgFailed(("enmState=%d {%s} %s\n", mUsb->enmState, mName, i_getStateName()));
1499 break;
1500 }
1501 }
1502 else if ( mUniSubState == kHostUSBDeviceSubState_AwaitingDetach
1503 && i_hasAsyncOperationTimedOut())
1504 {
1505 LogRel(("USB: timeout in %s for {%RTuuid} / {%s}\n", i_getStateName(), mId.raw(), mName));
1506 *aRunFilters = i_failTransition(kHostUSBDeviceState_Invalid);
1507 fIsImportant = true;
1508 }
1509 else
1510 {
1511 LogFlowThisFunc(("%p {%s} %s - no change %d\n", this, mName, i_getStateName(), enmOldState));
1512 /** @todo might have to handle some stuff here too if we cannot make the release/capture
1513 * handling deal with that above ... */
1514 }
1515
1516 return fIsImportant;
1517}
1518
1519
1520/**
1521 * Updates the state of the device, checking for cases which we fake.
1522 *
1523 * See HostUSBDevice::updateState() for details.
1524 *
1525 * @param[in] aDev See HostUSBDevice::updateState().
1526 * @param[out] aRunFilters See HostUSBDevice::updateState()
1527 * @param[out] aIgnoreMachine See HostUSBDevice::updateState()
1528 *
1529 * @returns See HostUSBDevice::updateState()
1530 */
1531bool HostUSBDevice::i_updateStateFake(PCUSBDEVICE aDev, bool *aRunFilters, SessionMachine **aIgnoreMachine)
1532{
1533 Assert(!isWriteLockOnCurrentThread());
1534 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1535 const HostUSBDeviceState enmState = mUniState;
1536 switch (enmState)
1537 {
1538 case kHostUSBDeviceState_Capturing:
1539 case kHostUSBDeviceState_ReleasingToHost:
1540 {
1541 *aIgnoreMachine = mUniState == kHostUSBDeviceState_ReleasingToHost ? mMachine : NULL;
1542 *aRunFilters = i_advanceTransition();
1543 LogThisFunc(("{%s} %s\n", mName, i_getStateName()));
1544
1545 if (mUsb != aDev)
1546 {
1547 aDev->pNext = mUsb->pNext;
1548 aDev->pPrev = mUsb->pPrev;
1549 USBProxyBackend::freeDevice(mUsb);
1550 mUsb = aDev;
1551 }
1552
1553 /* call the completion method */
1554 if (enmState == kHostUSBDeviceState_Capturing)
1555 mUSBProxyBackend->captureDeviceCompleted(this, true /* aSuccess */);
1556 else
1557 mUSBProxyBackend->releaseDeviceCompleted(this, true /* aSuccess */);
1558
1559 /* Take action if we're supposed to attach it to a VM. */
1560 if (mUniState == kHostUSBDeviceState_AttachingToVM)
1561 {
1562 alock.release();
1563 i_attachToVM(mMachine, mCaptureFilename, mMaskedIfs);
1564 }
1565 return true;
1566 }
1567
1568 default:
1569 alock.release();
1570 return i_updateState(aDev, aRunFilters, aIgnoreMachine);
1571 }
1572}
1573
1574
1575/**
1576 * Checks if there is a pending asynchronous operation and whether
1577 * it has timed out or not.
1578 *
1579 * @returns true on timeout, false if not.
1580 *
1581 * @note Caller must have read or write locked the object before calling.
1582 */
1583bool HostUSBDevice::i_hasAsyncOperationTimedOut() const
1584{
1585 switch (mUniSubState)
1586 {
1587#ifndef RT_OS_WINDOWS /* no timeouts on windows yet since I don't have all the details here... */
1588 case kHostUSBDeviceSubState_AwaitingDetach:
1589 case kHostUSBDeviceSubState_AwaitingReAttach:
1590 {
1591 uint64_t elapsedNanoseconds = RTTimeNanoTS() - mLastStateChangeTS;
1592 return elapsedNanoseconds > UINT64_C(60000000000); /* 60 seconds */ /* PORTME */
1593 }
1594#endif
1595 default:
1596 return false;
1597 }
1598}
1599
1600
1601/**
1602 * Translate the state into
1603 *
1604 * @returns
1605 * @param aState
1606 * @param aSubState
1607 * @param aPendingState
1608 */
1609/*static*/ const char *HostUSBDevice::i_stateName(HostUSBDeviceState aState,
1610 HostUSBDeviceState aPendingState /*= kHostUSBDeviceState_Invalid*/,
1611 HostUSBDeviceSubState aSubState /*= kHostUSBDeviceSubState_Default*/)
1612{
1613 switch (aState)
1614 {
1615 case kHostUSBDeviceState_Unsupported:
1616 AssertReturn(aPendingState == kHostUSBDeviceState_Invalid, "Unsupported{bad}");
1617 AssertReturn(aSubState == kHostUSBDeviceSubState_Default, "Unsupported[bad]");
1618 return "Unsupported";
1619
1620 case kHostUSBDeviceState_UsedByHost:
1621 AssertReturn(aPendingState == kHostUSBDeviceState_Invalid, "UsedByHost{bad}");
1622 AssertReturn(aSubState == kHostUSBDeviceSubState_Default, "UsedByHost[bad]");
1623 return "UsedByHost";
1624
1625 case kHostUSBDeviceState_Capturable:
1626 AssertReturn(aPendingState == kHostUSBDeviceState_Invalid, "Capturable{bad}");
1627 AssertReturn(aSubState == kHostUSBDeviceSubState_Default, "Capturable[bad]");
1628 return "Capturable";
1629
1630 case kHostUSBDeviceState_Unused:
1631 AssertReturn(aPendingState == kHostUSBDeviceState_Invalid, "Unused{bad}");
1632 AssertReturn(aSubState == kHostUSBDeviceSubState_Default, "Unused[bad]");
1633 return "Unused";
1634
1635 case kHostUSBDeviceState_HeldByProxy:
1636 AssertReturn(aPendingState == kHostUSBDeviceState_Invalid, "HeldByProxy{bad}");
1637 AssertReturn(aSubState == kHostUSBDeviceSubState_Default, "HeldByProxy[bad]");
1638 return "HeldByProxy";
1639
1640 case kHostUSBDeviceState_UsedByVM:
1641 AssertReturn(aPendingState == kHostUSBDeviceState_Invalid, "UsedByVM{bad}");
1642 AssertReturn(aSubState == kHostUSBDeviceSubState_Default, "UsedByVM[bad]");
1643 return "UsedByVM";
1644
1645 case kHostUSBDeviceState_PhysDetached:
1646 AssertReturn(aPendingState == kHostUSBDeviceState_Invalid, "PhysDetached{bad}");
1647 AssertReturn(aSubState == kHostUSBDeviceSubState_Default, "PhysDetached[bad]");
1648 return "PhysDetached";
1649
1650 case kHostUSBDeviceState_Capturing:
1651 switch (aPendingState)
1652 {
1653 case kHostUSBDeviceState_UsedByVM:
1654 switch (aSubState)
1655 {
1656 case kHostUSBDeviceSubState_Default:
1657 return "CapturingForVM";
1658 case kHostUSBDeviceSubState_AwaitingDetach:
1659 return "CapturingForVM[Detach]";
1660 case kHostUSBDeviceSubState_AwaitingReAttach:
1661 return "CapturingForVM[Attach]";
1662 default:
1663 AssertFailedReturn("CapturingForVM[bad]");
1664 }
1665 break;
1666
1667 case kHostUSBDeviceState_HeldByProxy:
1668 switch (aSubState)
1669 {
1670 case kHostUSBDeviceSubState_Default:
1671 return "CapturingForProxy";
1672 case kHostUSBDeviceSubState_AwaitingDetach:
1673 return "CapturingForProxy[Detach]";
1674 case kHostUSBDeviceSubState_AwaitingReAttach:
1675 return "CapturingForProxy[Attach]";
1676 default:
1677 AssertFailedReturn("CapturingForProxy[bad]");
1678 }
1679 break;
1680
1681 default:
1682 AssertFailedReturn("Capturing{bad}");
1683 }
1684 break;
1685
1686 case kHostUSBDeviceState_ReleasingToHost:
1687 switch (aPendingState)
1688 {
1689 case kHostUSBDeviceState_Unused:
1690 switch (aSubState)
1691 {
1692 case kHostUSBDeviceSubState_Default:
1693 return "ReleasingToHost";
1694 case kHostUSBDeviceSubState_AwaitingDetach:
1695 return "ReleasingToHost[Detach]";
1696 case kHostUSBDeviceSubState_AwaitingReAttach:
1697 return "ReleasingToHost[Attach]";
1698 default:
1699 AssertFailedReturn("ReleasingToHost[bad]");
1700 }
1701 break;
1702 default:
1703 AssertFailedReturn("ReleasingToHost{bad}");
1704 }
1705 break;
1706
1707 case kHostUSBDeviceState_DetachingFromVM:
1708 switch (aPendingState)
1709 {
1710 case kHostUSBDeviceState_HeldByProxy:
1711 switch (aSubState)
1712 {
1713 case kHostUSBDeviceSubState_Default:
1714 return "DetatchingFromVM>Proxy";
1715 case kHostUSBDeviceSubState_AwaitingDetach:
1716 return "DetatchingFromVM>Proxy[Detach]";
1717 case kHostUSBDeviceSubState_AwaitingReAttach:
1718 return "DetatchingFromVM>Proxy[Attach]";
1719 default:
1720 AssertFailedReturn("DetatchingFromVM>Proxy[bad]");
1721 }
1722 break;
1723
1724 case kHostUSBDeviceState_Unused:
1725 switch (aSubState)
1726 {
1727 case kHostUSBDeviceSubState_Default:
1728 return "DetachingFromVM>Host";
1729 case kHostUSBDeviceSubState_AwaitingDetach:
1730 return "DetachingFromVM>Host[Detach]";
1731 case kHostUSBDeviceSubState_AwaitingReAttach:
1732 return "DetachingFromVM>Host[Attach]";
1733 default:
1734 AssertFailedReturn("DetachingFromVM>Host[bad]");
1735 }
1736 break;
1737
1738 default:
1739 AssertFailedReturn("DetachingFromVM{bad}");
1740 }
1741 break;
1742
1743 case kHostUSBDeviceState_AttachingToVM:
1744 switch (aPendingState)
1745 {
1746 case kHostUSBDeviceState_UsedByVM:
1747 switch (aSubState)
1748 {
1749 case kHostUSBDeviceSubState_Default:
1750 return "AttachingToVM";
1751 case kHostUSBDeviceSubState_AwaitingDetach:
1752 return "AttachingToVM[Detach]";
1753 case kHostUSBDeviceSubState_AwaitingReAttach:
1754 return "AttachingToVM[Attach]";
1755 default:
1756 AssertFailedReturn("AttachingToVM[bad]");
1757 }
1758 break;
1759
1760 default:
1761 AssertFailedReturn("AttachingToVM{bad}");
1762 }
1763 break;
1764
1765
1766 case kHostUSBDeviceState_PhysDetachingFromVM:
1767 switch (aPendingState)
1768 {
1769 case kHostUSBDeviceState_PhysDetached:
1770 switch (aSubState)
1771 {
1772 case kHostUSBDeviceSubState_Default:
1773 return "PhysDetachingFromVM";
1774 default:
1775 AssertFailedReturn("AttachingToVM[bad]");
1776 }
1777 break;
1778
1779 default:
1780 AssertFailedReturn("AttachingToVM{bad}");
1781 }
1782 break;
1783
1784 default:
1785 AssertFailedReturn("BadState");
1786
1787 }
1788 /* not reached */
1789}
1790
1791/**
1792 * Set the device state.
1793 *
1794 * This method will verify that the state transition is a legal one
1795 * according to the statemachine. It will also take care of the
1796 * associated house keeping and determine if filters needs to be applied.
1797 *
1798 * @param aNewState The new state.
1799 * @param aNewPendingState The final state of a transition when applicable.
1800 * @param aNewSubState The new sub-state when applicable.
1801 *
1802 * @returns true if filters should be applied to the device, false if not.
1803 *
1804 * @note The caller must own the write lock for this object.
1805 */
1806bool HostUSBDevice::i_setState(HostUSBDeviceState aNewState,
1807 HostUSBDeviceState aNewPendingState /*= kHostUSBDeviceState_Invalid*/,
1808 HostUSBDeviceSubState aNewSubState /*= kHostUSBDeviceSubState_Default*/)
1809{
1810 Assert(isWriteLockOnCurrentThread());
1811 Assert( aNewSubState == kHostUSBDeviceSubState_Default
1812 || aNewSubState == kHostUSBDeviceSubState_AwaitingDetach
1813 || aNewSubState == kHostUSBDeviceSubState_AwaitingReAttach);
1814
1815 /*
1816 * If the state is unchanged, then don't bother going
1817 * thru the validation and setting. This saves a bit of code.
1818 */
1819 if ( aNewState == mUniState
1820 && aNewPendingState == mPendingUniState
1821 && aNewSubState == mUniSubState)
1822 return false;
1823
1824 /*
1825 * Welcome to the switch orgies!
1826 * You're welcome to check out the ones in startTransition(),
1827 * advanceTransition(), failTransition() and i_getStateName() too. Enjoy!
1828 */
1829
1830 bool fFilters = false;
1831 HostUSBDeviceState NewPrevState = mUniState;
1832 switch (mUniState)
1833 {
1834 /*
1835 * Not much can be done with a device in this state.
1836 */
1837 case kHostUSBDeviceState_Unsupported:
1838 switch (aNewState)
1839 {
1840 case kHostUSBDeviceState_PhysDetached:
1841 Assert(aNewPendingState == kHostUSBDeviceState_Invalid);
1842 Assert(aNewSubState == kHostUSBDeviceSubState_Default);
1843 break;
1844 default:
1845 AssertLogRelMsgFailedReturn(("this=%p %s -X-> %s\n", this, i_getStateName(),
1846 i_stateName(aNewState, aNewPendingState, aNewSubState)), false);
1847 }
1848 break;
1849
1850 /*
1851 * Only the host OS (or the user) can make changes
1852 * that'll make a device get out of this state.
1853 */
1854 case kHostUSBDeviceState_UsedByHost:
1855 switch (aNewState)
1856 {
1857 case kHostUSBDeviceState_Capturable:
1858 case kHostUSBDeviceState_Unused:
1859 fFilters = true;
1860 RT_FALL_THRU();
1861 case kHostUSBDeviceState_PhysDetached:
1862 Assert(aNewPendingState == kHostUSBDeviceState_Invalid);
1863 Assert(aNewSubState == kHostUSBDeviceSubState_Default);
1864 break;
1865 default:
1866 AssertLogRelMsgFailedReturn(("this=%p %s -X-> %s\n", this, i_getStateName(),
1867 i_stateName(aNewState, aNewPendingState, aNewSubState)), false);
1868 }
1869 break;
1870
1871 /*
1872 * Now it gets interesting.
1873 */
1874 case kHostUSBDeviceState_Capturable:
1875 switch (aNewState)
1876 {
1877 /* Host changes. */
1878 case kHostUSBDeviceState_Unused:
1879 fFilters = true; /* Wildcard only... */
1880 RT_FALL_THRU();
1881 case kHostUSBDeviceState_UsedByHost:
1882 case kHostUSBDeviceState_PhysDetached:
1883 Assert(aNewPendingState == kHostUSBDeviceState_Invalid);
1884 Assert(aNewSubState == kHostUSBDeviceSubState_Default);
1885 break;
1886
1887 /* VBox actions */
1888 case kHostUSBDeviceState_Capturing:
1889 switch (aNewPendingState)
1890 {
1891 case kHostUSBDeviceState_HeldByProxy:
1892 case kHostUSBDeviceState_UsedByVM:
1893 break;
1894 default:
1895 AssertLogRelMsgFailedReturn(("this=%p %s -X-> %s\n", this, i_getStateName(),
1896 i_stateName(aNewState, aNewPendingState, aNewSubState)), false);
1897 }
1898 break;
1899 default:
1900 AssertLogRelMsgFailedReturn(("this=%p %s -X-> %s\n", this, i_getStateName(),
1901 i_stateName(aNewState, aNewPendingState, aNewSubState)), false);
1902 }
1903 break;
1904
1905 case kHostUSBDeviceState_Unused:
1906 switch (aNewState)
1907 {
1908 /* Host changes. */
1909 case kHostUSBDeviceState_PhysDetached:
1910 case kHostUSBDeviceState_UsedByHost:
1911 case kHostUSBDeviceState_Capturable:
1912 Assert(aNewPendingState == kHostUSBDeviceState_Invalid);
1913 Assert(aNewSubState == kHostUSBDeviceSubState_Default);
1914 break;
1915
1916 /* VBox actions */
1917 case kHostUSBDeviceState_Capturing:
1918 switch (aNewPendingState)
1919 {
1920 case kHostUSBDeviceState_HeldByProxy:
1921 case kHostUSBDeviceState_UsedByVM:
1922 break;
1923 default:
1924 AssertLogRelMsgFailedReturn(("this=%p %s -X-> %s\n", this, i_getStateName(),
1925 i_stateName(aNewState, aNewPendingState, aNewSubState)), false);
1926 }
1927 break;
1928 default:
1929 AssertLogRelMsgFailedReturn(("this=%p %s -X-> %s\n", this, i_getStateName(),
1930 i_stateName(aNewState, aNewPendingState, aNewSubState)), false);
1931 }
1932 break;
1933
1934 /*
1935 * VBox owns this device now, what's next...
1936 */
1937 case kHostUSBDeviceState_HeldByProxy:
1938 switch (aNewState)
1939 {
1940 /* Host changes. */
1941 case kHostUSBDeviceState_PhysDetached:
1942 Assert(aNewPendingState == kHostUSBDeviceState_Invalid);
1943 Assert(aNewSubState == kHostUSBDeviceSubState_Default);
1944 break;
1945
1946 /* VBox actions */
1947 case kHostUSBDeviceState_AttachingToVM:
1948 switch (aNewPendingState)
1949 {
1950 case kHostUSBDeviceState_UsedByVM:
1951 break;
1952 default:
1953 AssertLogRelMsgFailedReturn(("this=%p %s -X-> %s\n", this, i_getStateName(),
1954 i_stateName(aNewState, aNewPendingState, aNewSubState)), false);
1955 }
1956 break;
1957 case kHostUSBDeviceState_ReleasingToHost:
1958 switch (aNewPendingState)
1959 {
1960 case kHostUSBDeviceState_Unused: /* Only this! */
1961 break;
1962 default:
1963 AssertLogRelMsgFailedReturn(("this=%p %s -X-> %s\n", this, i_getStateName(),
1964 i_stateName(aNewState, aNewPendingState, aNewSubState)), false);
1965 }
1966 break;
1967 default:
1968 AssertLogRelMsgFailedReturn(("this=%p %s -X-> %s\n", this, i_getStateName(),
1969 i_stateName(aNewState, aNewPendingState, aNewSubState)), false);
1970 }
1971 break;
1972
1973
1974 case kHostUSBDeviceState_UsedByVM:
1975 switch (aNewState)
1976 {
1977 /* Host changes. */
1978 case kHostUSBDeviceState_PhysDetachingFromVM:
1979 Assert(aNewSubState == kHostUSBDeviceSubState_Default);
1980 Assert(aNewPendingState == kHostUSBDeviceState_PhysDetached);
1981 break;
1982
1983 /* VBox actions */
1984 case kHostUSBDeviceState_DetachingFromVM:
1985 switch (aNewPendingState)
1986 {
1987 case kHostUSBDeviceState_HeldByProxy:
1988 case kHostUSBDeviceState_Unused: /* Only this! */
1989 break;
1990 default:
1991 AssertLogRelMsgFailedReturn(("this=%p %s -X-> %s\n", this, i_getStateName(),
1992 i_stateName(aNewState, aNewPendingState, aNewSubState)), false);
1993 }
1994 break;
1995 default:
1996 AssertLogRelMsgFailedReturn(("this=%p %s -X-> %s\n", this, i_getStateName(),
1997 i_stateName(aNewState, aNewPendingState, aNewSubState)), false);
1998 }
1999 break;
2000
2001 /*
2002 * The final state.
2003 */
2004 case kHostUSBDeviceState_PhysDetached:
2005 switch (mUniState)
2006 {
2007 case kHostUSBDeviceState_Unsupported:
2008 case kHostUSBDeviceState_UsedByHost:
2009 case kHostUSBDeviceState_Capturable:
2010 case kHostUSBDeviceState_Unused:
2011 case kHostUSBDeviceState_HeldByProxy:
2012 case kHostUSBDeviceState_PhysDetachingFromVM:
2013 case kHostUSBDeviceState_DetachingFromVM: // ??
2014 case kHostUSBDeviceState_Capturing:
2015 case kHostUSBDeviceState_ReleasingToHost:
2016 break;
2017
2018 case kHostUSBDeviceState_AttachingToVM: // ??
2019 case kHostUSBDeviceState_UsedByVM:
2020 default:
2021 AssertLogRelMsgFailedReturn(("this=%p %s -X-> %s\n", this, i_getStateName(),
2022 i_stateName(aNewState, aNewPendingState, aNewSubState)), false);
2023 }
2024 break;
2025
2026
2027 /*
2028 * The transitional states.
2029 */
2030 case kHostUSBDeviceState_Capturing:
2031 NewPrevState = mPrevUniState;
2032 switch (aNewState)
2033 {
2034 /* Sub state advance. */
2035 case kHostUSBDeviceState_Capturing:
2036 switch (aNewSubState)
2037 {
2038 case kHostUSBDeviceSubState_AwaitingReAttach:
2039 Assert(mUniSubState == kHostUSBDeviceSubState_AwaitingDetach);
2040 Assert(aNewPendingState == mPendingUniState);
2041 break;
2042 default:
2043 AssertReleaseMsgFailedReturn(("this=%p mUniState=%d\n", this, mUniState), false);
2044 }
2045 break;
2046
2047 /* Host/User/Failure. */
2048 case kHostUSBDeviceState_PhysDetached:
2049 Assert(aNewPendingState == kHostUSBDeviceState_Invalid);
2050 Assert(aNewSubState == kHostUSBDeviceSubState_Default);
2051 break;
2052 case kHostUSBDeviceState_UsedByHost:
2053 case kHostUSBDeviceState_Capturable:
2054 case kHostUSBDeviceState_Unused:
2055 Assert(aNewState == mPrevUniState); /** @todo This is kind of wrong, see i_failTransition. */
2056 Assert(aNewPendingState == kHostUSBDeviceState_Invalid);
2057 Assert(aNewSubState == kHostUSBDeviceSubState_Default);
2058 break;
2059
2060 /* VBox */
2061 case kHostUSBDeviceState_HeldByProxy:
2062 Assert(aNewPendingState == kHostUSBDeviceState_Invalid);
2063 Assert(aNewSubState == kHostUSBDeviceSubState_Default);
2064 Assert( mPendingUniState == kHostUSBDeviceState_HeldByProxy
2065 || mPendingUniState == kHostUSBDeviceState_UsedByVM /* <- failure */ );
2066 break;
2067 case kHostUSBDeviceState_AttachingToVM:
2068 Assert(aNewPendingState == kHostUSBDeviceState_UsedByVM);
2069 NewPrevState = kHostUSBDeviceState_HeldByProxy;
2070 break;
2071
2072 default:
2073 AssertLogRelMsgFailedReturn(("this=%p %s -X-> %s\n", this, i_getStateName(),
2074 i_stateName(aNewState, aNewPendingState, aNewSubState)), false);
2075 }
2076 break;
2077
2078 case kHostUSBDeviceState_ReleasingToHost:
2079 Assert(mPrevUniState == kHostUSBDeviceState_HeldByProxy);
2080 NewPrevState = mPrevUniState;
2081 switch (aNewState)
2082 {
2083 /* Sub state advance. */
2084 case kHostUSBDeviceState_ReleasingToHost:
2085 switch (aNewSubState)
2086 {
2087 case kHostUSBDeviceSubState_AwaitingReAttach:
2088 Assert(mUniSubState == kHostUSBDeviceSubState_AwaitingDetach);
2089 Assert(aNewPendingState == mPendingUniState);
2090 break;
2091 default:
2092 AssertReleaseMsgFailedReturn(("this=%p mUniState=%d\n", this, mUniState), false);
2093 }
2094 break;
2095
2096 /* Host/Failure. */
2097 case kHostUSBDeviceState_PhysDetached:
2098 Assert(aNewPendingState == kHostUSBDeviceState_Invalid);
2099 Assert(aNewSubState == kHostUSBDeviceSubState_Default);
2100 break;
2101 case kHostUSBDeviceState_HeldByProxy:
2102 Assert(aNewPendingState == kHostUSBDeviceState_Invalid);
2103 Assert(aNewSubState == kHostUSBDeviceSubState_Default);
2104 Assert(mPendingUniState == kHostUSBDeviceState_Unused);
2105 break;
2106
2107 /* Success */
2108 case kHostUSBDeviceState_UsedByHost:
2109 case kHostUSBDeviceState_Capturable:
2110 case kHostUSBDeviceState_Unused:
2111 Assert(aNewPendingState == kHostUSBDeviceState_Invalid);
2112 Assert(aNewSubState == kHostUSBDeviceSubState_Default);
2113 Assert(mPendingUniState == kHostUSBDeviceState_Unused);
2114 break;
2115
2116 default:
2117 AssertLogRelMsgFailedReturn(("this=%p %s -X-> %s\n", this, i_getStateName(),
2118 i_stateName(aNewState, aNewPendingState, aNewSubState)), false);
2119 }
2120 break;
2121
2122 case kHostUSBDeviceState_AttachingToVM:
2123 Assert(mPrevUniState == kHostUSBDeviceState_HeldByProxy);
2124 NewPrevState = mPrevUniState;
2125 switch (aNewState)
2126 {
2127 /* Host/Failure. */
2128 case kHostUSBDeviceState_PhysDetachingFromVM:
2129 Assert(aNewPendingState == kHostUSBDeviceState_PhysDetached);
2130 Assert(aNewSubState == kHostUSBDeviceSubState_Default);
2131 break;
2132 case kHostUSBDeviceState_HeldByProxy:
2133 Assert(aNewPendingState == kHostUSBDeviceState_Invalid);
2134 Assert(aNewSubState == kHostUSBDeviceSubState_Default);
2135 Assert(mPendingUniState == kHostUSBDeviceState_UsedByVM);
2136 break;
2137
2138 /* Success */
2139 case kHostUSBDeviceState_UsedByVM:
2140 Assert(aNewPendingState == kHostUSBDeviceState_Invalid);
2141 Assert(aNewSubState == kHostUSBDeviceSubState_Default);
2142 Assert(mPendingUniState == kHostUSBDeviceState_UsedByVM);
2143 break;
2144
2145 default:
2146 AssertLogRelMsgFailedReturn(("this=%p %s -X-> %s\n", this, i_getStateName(),
2147 i_stateName(aNewState, aNewPendingState, aNewSubState)), false);
2148 }
2149 break;
2150
2151 case kHostUSBDeviceState_DetachingFromVM:
2152 Assert(mPrevUniState == kHostUSBDeviceState_UsedByVM);
2153 NewPrevState = mPrevUniState;
2154 switch (aNewState)
2155 {
2156 /* Host/Failure. */
2157 case kHostUSBDeviceState_PhysDetached: //??
2158 Assert(aNewPendingState == kHostUSBDeviceState_Invalid);
2159 Assert(aNewSubState == kHostUSBDeviceSubState_Default);
2160 break;
2161 case kHostUSBDeviceState_PhysDetachingFromVM:
2162 Assert(aNewPendingState == kHostUSBDeviceState_PhysDetached);
2163 Assert(aNewSubState == kHostUSBDeviceSubState_Default);
2164 break;
2165
2166 /* Success */
2167 case kHostUSBDeviceState_HeldByProxy:
2168 Assert(aNewPendingState == kHostUSBDeviceState_Invalid);
2169 Assert(aNewSubState == kHostUSBDeviceSubState_Default);
2170 Assert(mPendingUniState == kHostUSBDeviceState_HeldByProxy);
2171 fFilters = true;
2172 break;
2173
2174 case kHostUSBDeviceState_ReleasingToHost:
2175 Assert(aNewPendingState == kHostUSBDeviceState_Invalid);
2176 Assert(aNewSubState == kHostUSBDeviceSubState_Default);
2177 Assert(mPendingUniState == kHostUSBDeviceState_Unused);
2178 NewPrevState = kHostUSBDeviceState_HeldByProxy;
2179 break;
2180
2181 default:
2182 AssertLogRelMsgFailedReturn(("this=%p %s -X-> %s\n", this, i_getStateName(),
2183 i_stateName(aNewState, aNewPendingState, aNewSubState)), false);
2184 }
2185 break;
2186
2187 case kHostUSBDeviceState_PhysDetachingFromVM:
2188 Assert( mPrevUniState == kHostUSBDeviceState_DetachingFromVM
2189 || mPrevUniState == kHostUSBDeviceState_AttachingToVM
2190 || mPrevUniState == kHostUSBDeviceState_UsedByVM);
2191 NewPrevState = mPrevUniState; /* preserving it is more useful. */
2192 switch (aNewState)
2193 {
2194 case kHostUSBDeviceState_PhysDetached:
2195 Assert(aNewPendingState == kHostUSBDeviceState_Invalid);
2196 Assert(aNewSubState == kHostUSBDeviceSubState_Default);
2197 break;
2198 default:
2199 AssertLogRelMsgFailedReturn(("this=%p %s -X-> %s\n", this, i_getStateName(),
2200 i_stateName(aNewState, aNewPendingState, aNewSubState)), false);
2201 }
2202 break;
2203
2204 default:
2205 AssertReleaseMsgFailedReturn(("this=%p mUniState=%d\n", this, mUniState), false);
2206 }
2207
2208 /*
2209 * Make the state change.
2210 */
2211 if (NewPrevState != mPrevUniState)
2212 LogFlowThisFunc(("%s -> %s (prev: %s -> %s) [%s]\n",
2213 i_getStateName(), i_stateName(aNewState, aNewPendingState, aNewSubState),
2214 i_stateName(mPrevUniState), i_stateName(NewPrevState), mName));
2215 else
2216 LogFlowThisFunc(("%s -> %s (prev: %s) [%s]\n",
2217 i_getStateName(), i_stateName(aNewState, aNewPendingState, aNewSubState),
2218 i_stateName(NewPrevState), mName));
2219 mPrevUniState = NewPrevState;
2220 mUniState = aNewState;
2221 mUniSubState = aNewSubState;
2222 mPendingUniState = aNewPendingState;
2223 mLastStateChangeTS = RTTimeNanoTS();
2224
2225 return fFilters;
2226}
2227
2228
2229/**
2230 * A convenience for entering a transitional state.
2231
2232 * @param aNewState The new state (transitional).
2233 * @param aFinalState The final state of the transition (non-transitional).
2234 * @param aNewSubState The new sub-state when applicable.
2235 *
2236 * @returns Always false because filters are never applied for the start of a transition.
2237 *
2238 * @note The caller must own the write lock for this object.
2239 */
2240bool HostUSBDevice::i_startTransition(HostUSBDeviceState aNewState, HostUSBDeviceState aFinalState,
2241 HostUSBDeviceSubState aNewSubState /*= kHostUSBDeviceSubState_Default*/)
2242{
2243 AssertReturn(isWriteLockOnCurrentThread(), false);
2244 /*
2245 * A quick prevalidation thing. Not really necessary since setState
2246 * verifies this too, but it's very easy here.
2247 */
2248 switch (mUniState)
2249 {
2250 case kHostUSBDeviceState_Unsupported:
2251 case kHostUSBDeviceState_UsedByHost:
2252 case kHostUSBDeviceState_Capturable:
2253 case kHostUSBDeviceState_Unused:
2254 case kHostUSBDeviceState_HeldByProxy:
2255 case kHostUSBDeviceState_UsedByVM:
2256 break;
2257
2258 case kHostUSBDeviceState_DetachingFromVM:
2259 case kHostUSBDeviceState_Capturing:
2260 case kHostUSBDeviceState_ReleasingToHost:
2261 case kHostUSBDeviceState_AttachingToVM:
2262 case kHostUSBDeviceState_PhysDetachingFromVM:
2263 AssertMsgFailedReturn(("this=%p %s is a transitional state.\n", this, i_getStateName()), false);
2264
2265 case kHostUSBDeviceState_PhysDetached:
2266 default:
2267 AssertReleaseMsgFailedReturn(("this=%p mUniState=%d\n", this, mUniState), false);
2268 }
2269
2270 return i_setState(aNewState, aFinalState, aNewSubState);
2271}
2272
2273
2274/**
2275 * A convenience for advancing a transitional state forward.
2276 *
2277 * @param aSkipReAttach Fast forwards thru the re-attach substate if
2278 * applicable.
2279 *
2280 * @returns true if filters should be applied to the device, false if not.
2281 *
2282 * @note The caller must own the write lock for this object.
2283 */
2284bool HostUSBDevice::i_advanceTransition(bool aSkipReAttach /* = false */)
2285{
2286 AssertReturn(isWriteLockOnCurrentThread(), false);
2287 HostUSBDeviceState enmPending = mPendingUniState;
2288 HostUSBDeviceSubState enmSub = mUniSubState;
2289 HostUSBDeviceState enmState = mUniState;
2290 switch (enmState)
2291 {
2292 case kHostUSBDeviceState_Capturing:
2293 switch (enmSub)
2294 {
2295 case kHostUSBDeviceSubState_AwaitingDetach:
2296 enmSub = kHostUSBDeviceSubState_AwaitingReAttach;
2297 break;
2298 case kHostUSBDeviceSubState_AwaitingReAttach:
2299 enmSub = kHostUSBDeviceSubState_Default;
2300 RT_FALL_THRU();
2301 case kHostUSBDeviceSubState_Default:
2302 switch (enmPending)
2303 {
2304 case kHostUSBDeviceState_UsedByVM:
2305 enmState = kHostUSBDeviceState_AttachingToVM;
2306 break;
2307 case kHostUSBDeviceState_HeldByProxy:
2308 enmState = enmPending;
2309 enmPending = kHostUSBDeviceState_Invalid;
2310 break;
2311 default:
2312 AssertMsgFailedReturn(("this=%p invalid pending state %d: %s\n",
2313 this, enmPending, i_getStateName()), false);
2314 }
2315 break;
2316 default:
2317 AssertReleaseMsgFailedReturn(("this=%p mUniState=%d\n", this, mUniState), false);
2318 }
2319 break;
2320
2321 case kHostUSBDeviceState_ReleasingToHost:
2322 switch (enmSub)
2323 {
2324 case kHostUSBDeviceSubState_AwaitingDetach:
2325 enmSub = kHostUSBDeviceSubState_AwaitingReAttach;
2326 break;
2327 case kHostUSBDeviceSubState_AwaitingReAttach:
2328 enmSub = kHostUSBDeviceSubState_Default;
2329 RT_FALL_THRU();
2330 case kHostUSBDeviceSubState_Default:
2331 switch (enmPending)
2332 {
2333 /* Use Unused here since it implies that filters has been applied
2334 and will make sure they aren't applied if the final state really
2335 is Capturable. */
2336 case kHostUSBDeviceState_Unused:
2337 enmState = enmPending;
2338 enmPending = kHostUSBDeviceState_Invalid;
2339 break;
2340 default:
2341 AssertMsgFailedReturn(("this=%p invalid pending state %d: %s\n",
2342 this, enmPending, i_getStateName()), false);
2343 }
2344 break;
2345 default:
2346 AssertReleaseMsgFailedReturn(("this=%p mUniState=%d\n", this, mUniState), false);
2347 }
2348 break;
2349
2350 case kHostUSBDeviceState_AttachingToVM:
2351 switch (enmSub)
2352 {
2353 case kHostUSBDeviceSubState_AwaitingDetach:
2354 enmSub = kHostUSBDeviceSubState_AwaitingReAttach;
2355 break;
2356 case kHostUSBDeviceSubState_AwaitingReAttach:
2357 enmSub = kHostUSBDeviceSubState_Default;
2358 RT_FALL_THRU();
2359 case kHostUSBDeviceSubState_Default:
2360 switch (enmPending)
2361 {
2362 case kHostUSBDeviceState_UsedByVM:
2363 enmState = enmPending;
2364 enmPending = kHostUSBDeviceState_Invalid;
2365 break;
2366 default:
2367 AssertMsgFailedReturn(("this=%p invalid pending state %d: %s\n",
2368 this, enmPending, i_getStateName()), false);
2369 }
2370 break;
2371 default:
2372 AssertReleaseMsgFailedReturn(("this=%p mUniState=%d\n", this, mUniState), false);
2373 }
2374 break;
2375
2376 case kHostUSBDeviceState_DetachingFromVM:
2377 switch (enmSub)
2378 {
2379 case kHostUSBDeviceSubState_AwaitingDetach:
2380 enmSub = kHostUSBDeviceSubState_AwaitingReAttach;
2381 break;
2382 case kHostUSBDeviceSubState_AwaitingReAttach:
2383 enmSub = kHostUSBDeviceSubState_Default;
2384 RT_FALL_THRU();
2385 case kHostUSBDeviceSubState_Default:
2386 switch (enmPending)
2387 {
2388 case kHostUSBDeviceState_HeldByProxy:
2389 enmState = enmPending;
2390 enmPending = kHostUSBDeviceState_Invalid;
2391 break;
2392 case kHostUSBDeviceState_Unused:
2393 enmState = kHostUSBDeviceState_ReleasingToHost;
2394 break;
2395 default:
2396 AssertMsgFailedReturn(("this=%p invalid pending state %d: %s\n",
2397 this, enmPending, i_getStateName()), false);
2398 }
2399 break;
2400 default:
2401 AssertReleaseMsgFailedReturn(("this=%p mUniState=%d\n", this, mUniState), false);
2402 }
2403 break;
2404
2405 case kHostUSBDeviceState_PhysDetachingFromVM:
2406 switch (enmSub)
2407 {
2408 case kHostUSBDeviceSubState_Default:
2409 switch (enmPending)
2410 {
2411 case kHostUSBDeviceState_PhysDetached:
2412 enmState = enmPending;
2413 enmPending = kHostUSBDeviceState_Invalid;
2414 break;
2415 default:
2416 AssertMsgFailedReturn(("this=%p invalid pending state %d: %s\n",
2417 this, enmPending, i_getStateName()), false);
2418 }
2419 break;
2420 default:
2421 AssertReleaseMsgFailedReturn(("this=%p mUniState=%d\n", this, mUniState), false);
2422 }
2423 break;
2424
2425 case kHostUSBDeviceState_Unsupported:
2426 case kHostUSBDeviceState_UsedByHost:
2427 case kHostUSBDeviceState_Capturable:
2428 case kHostUSBDeviceState_Unused:
2429 case kHostUSBDeviceState_HeldByProxy:
2430 case kHostUSBDeviceState_UsedByVM:
2431 AssertMsgFailedReturn(("this=%p %s is not transitional\n", this, i_getStateName()), false);
2432 case kHostUSBDeviceState_PhysDetached:
2433 default:
2434 AssertReleaseMsgFailedReturn(("this=%p mUniState=%d\n", this, enmState), false);
2435
2436 }
2437
2438 bool fRc = i_setState(enmState, enmPending, enmSub);
2439 if (aSkipReAttach && mUniSubState == kHostUSBDeviceSubState_AwaitingReAttach)
2440 fRc |= i_advanceTransition(false /* don't fast forward re-attach */);
2441 return fRc;
2442}
2443
2444/**
2445 * A convenience for failing a transitional state.
2446 *
2447 * @return true if filters should be applied to the device, false if not.
2448 * @param a_enmStateHint USB device state hint. kHostUSBDeviceState_Invalid
2449 * if the caller doesn't have a clue to give.
2450 *
2451 * @note The caller must own the write lock for this object.
2452 */
2453bool HostUSBDevice::i_failTransition(HostUSBDeviceState a_enmStateHint)
2454{
2455 AssertReturn(isWriteLockOnCurrentThread(), false);
2456 HostUSBDeviceSubState enmSub = mUniSubState;
2457 HostUSBDeviceState enmState = mUniState;
2458 switch (enmState)
2459 {
2460 /*
2461 * There are just two cases, either we got back to the
2462 * previous state (assumes Capture+Attach-To-VM updates it)
2463 * or we assume the device has been unplugged (physically).
2464 */
2465 case kHostUSBDeviceState_DetachingFromVM:
2466 case kHostUSBDeviceState_Capturing:
2467 case kHostUSBDeviceState_ReleasingToHost:
2468 case kHostUSBDeviceState_AttachingToVM:
2469 switch (enmSub)
2470 {
2471 case kHostUSBDeviceSubState_AwaitingDetach:
2472 enmSub = kHostUSBDeviceSubState_Default;
2473 RT_FALL_THRU();
2474 case kHostUSBDeviceSubState_Default:
2475 enmState = mPrevUniState;
2476 break;
2477 case kHostUSBDeviceSubState_AwaitingReAttach:
2478 enmSub = kHostUSBDeviceSubState_Default;
2479 if (a_enmStateHint != kHostUSBDeviceState_Invalid)
2480 enmState = mPrevUniState; /** @todo enmState = a_enmStateHint is more correct, but i_setState doesn't like it. It will usually correct itself shortly. */
2481 else
2482 enmState = kHostUSBDeviceState_PhysDetached;
2483 break;
2484 default:
2485 AssertReleaseMsgFailedReturn(("this=%p mUniState=%d\n", this, mUniState), false);
2486 }
2487 break;
2488
2489 case kHostUSBDeviceState_PhysDetachingFromVM:
2490 AssertMsgFailedReturn(("this=%p %s shall not fail\n", this, i_getStateName()), false);
2491
2492 case kHostUSBDeviceState_Unsupported:
2493 case kHostUSBDeviceState_UsedByHost:
2494 case kHostUSBDeviceState_Capturable:
2495 case kHostUSBDeviceState_Unused:
2496 case kHostUSBDeviceState_HeldByProxy:
2497 case kHostUSBDeviceState_UsedByVM:
2498 AssertMsgFailedReturn(("this=%p %s is not transitional\n", this, i_getStateName()), false);
2499 case kHostUSBDeviceState_PhysDetached:
2500 default:
2501 AssertReleaseMsgFailedReturn(("this=%p mUniState=%d\n", this, mUniState), false);
2502
2503 }
2504
2505 return i_setState(enmState, kHostUSBDeviceState_Invalid, enmSub);
2506}
2507
2508
2509/**
2510 * Determines the canonical state of the device.
2511 *
2512 * @returns canonical state.
2513 *
2514 * @note The caller must own the read (or write) lock for this object.
2515 */
2516USBDeviceState_T HostUSBDevice::i_canonicalState() const
2517{
2518 switch (mUniState)
2519 {
2520 /*
2521 * Straight forward.
2522 */
2523 case kHostUSBDeviceState_Unsupported:
2524 return USBDeviceState_NotSupported;
2525
2526 case kHostUSBDeviceState_UsedByHost:
2527 return USBDeviceState_Unavailable;
2528
2529 case kHostUSBDeviceState_Capturable:
2530 return USBDeviceState_Busy;
2531
2532 case kHostUSBDeviceState_Unused:
2533 return USBDeviceState_Available;
2534
2535 case kHostUSBDeviceState_HeldByProxy:
2536 return USBDeviceState_Held;
2537
2538 case kHostUSBDeviceState_UsedByVM:
2539 return USBDeviceState_Captured;
2540
2541 /*
2542 * Pretend we've reached the final state.
2543 */
2544 case kHostUSBDeviceState_Capturing:
2545 Assert( mPendingUniState == kHostUSBDeviceState_UsedByVM
2546 || mPendingUniState == kHostUSBDeviceState_HeldByProxy);
2547 return mPendingUniState == kHostUSBDeviceState_UsedByVM
2548 ? (USBDeviceState_T)USBDeviceState_Captured
2549 : (USBDeviceState_T)USBDeviceState_Held;
2550 /* The cast ^^^^ is because xidl is using different enums for
2551 each of the values. *Very* nice idea... :-) */
2552
2553 case kHostUSBDeviceState_AttachingToVM:
2554 return USBDeviceState_Captured;
2555
2556 /*
2557 * Return the previous state.
2558 */
2559 case kHostUSBDeviceState_ReleasingToHost:
2560 Assert( mPrevUniState == kHostUSBDeviceState_UsedByVM
2561 || mPrevUniState == kHostUSBDeviceState_HeldByProxy);
2562 return mPrevUniState == kHostUSBDeviceState_UsedByVM
2563 ? (USBDeviceState_T)USBDeviceState_Captured
2564 : (USBDeviceState_T)USBDeviceState_Held;
2565 /* The cast ^^^^ is because xidl is using different enums for
2566 each of the values. *Very* nice idea... :-) */
2567
2568 case kHostUSBDeviceState_DetachingFromVM:
2569 return USBDeviceState_Captured;
2570 case kHostUSBDeviceState_PhysDetachingFromVM:
2571 return USBDeviceState_Captured;
2572
2573 case kHostUSBDeviceState_PhysDetached:
2574 default:
2575 AssertReleaseMsgFailedReturn(("this=%p mUniState=%d\n", this, mUniState), USBDeviceState_NotSupported);
2576 }
2577 /* won't ever get here. */
2578}
2579/* vi: set tabstop=4 shiftwidth=4 expandtab: */
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette