Changeset 3664 in vbox for trunk/src

Timestamp:

Jul 17, 2007 4:21:29 AM (18 years ago)

Author:

vboxsync

Message:

ugly state mess hacking.

Location:

trunk/src/VBox/Main

Files:

• HostUSBDeviceImpl.cpp (modified) (12 diffs)
• USBProxyService.cpp (modified) (5 diffs)

trunk/src/VBox/Main/HostUSBDeviceImpl.cpp

@@ -612 +612 @@
                         /* couldn't capture the device, will report an error */
                         wasCapture = true;
-        
+
                         Assert (!mMachine.isNull());
-        
+
                         /// @todo more detailed error message depending on the state?
                         //  probably need some error code/string from the USB proxy itself
-        
+
                         requestRC = E_FAIL;
                         errorText = Utf8StrFmt (
@@ -630 +630 @@
                 {
                     Assert (mMachine.isNull());
-        
+
                     if (mState == USBDeviceState_USBDeviceHeld)
                     {
@@ -674 +674 @@
 
         /*
-         * The device has reappeared while the detach operation is still in 
+         * The device has reappeared while the detach operation is still in
          * progress, just clear the pending operation and leave the machine as is.
          */
@@ -787 +787 @@
         case kDetachingPendingAttach:
         case kDetachingPendingAttachFilters:
+            LogFlowThisFunc (("cancelling reattach in state %d\n", mPendingStateEx));
             mMachine.setNull();
             mPendingStateEx = kNothingPending;
@@ -943 +944 @@
                             bool aIsStrict /* = true */)
 {
-    /* The non-strict checks tries as best as it can to distiguish between 
+    /* The non-strict checks tries as best as it can to distiguish between
        different physical devices of the same product. Unfortunately this
        isn't always possible and we might end up a bit confused in rare cases... */
@@ -1107 +1108 @@
                 case USBDeviceState_USBDeviceAvailable:
                     return false;
-#ifdef __LINUX__ /* Hack for /proc/bus/usb/devices not necessarily putting up a driver. */
+#if defined(RT_OS_LINUX)  /* Hack for /proc/bus/usb/devices not necessarily putting up a driver. */ \
+ || defined(RT_OS_DARWIN) /* We're a bit clueless as to the exact device state, just like linux. */
                 case USBDeviceState_USBDeviceCaptured:
-                    if (!mIsStatePending)
+                    if (    !mIsStatePending
+                        ||  mPendingStateEx != kNothingPending)
                         return false;
                     isImportant = true;
@@ -1134 +1137 @@
                 case USBDeviceState_USBDeviceHeld:
                     return false;
-#ifdef __WIN__
                 case USBDeviceState_USBDeviceCaptured:
                     if (!mIsStatePending)
                         return false;
                     /* no break */
-#endif
                 default:
                     LogFlowThisFunc (("%d -> %d\n",
@@ -1177 +1178 @@
 /**
  *  Checks for timeout of any pending async operation.
- * 
- *  The caller must write lock the object prior to calling 
+ *
+ *  The caller must write lock the object prior to calling
  *  this method.
  */
@@ -1200 +1201 @@
 }
 
-/** 
- *  This method is called by the USB proxy and Host to work the 
+/**
+ *  This method is called by the USB proxy and Host to work the
  *  logical reconnection operation.
- * 
+ *
  *  @param  aStage      kDeatchingPendingDetach, kDeatchingPendingDetachFilters,
  *                      kDetachingPendingAttach or kDetachingPendingAttachFilters.
- * 
+ *
  *  @returns Success indicator.
  */
@@ -1220 +1221 @@
             mIsStatePending = true;
             mPendingSince = RTTimeNanoTS();
+            LogFlowThisFunc (("pending detach\n"));
             break;
 
@@ -1225 +1227 @@
             AssertReturn (mIsStatePending, false);
             AssertReturn (mPendingStateEx == kDetachingPendingDetach, false);
+            LogFlowThisFunc (("pending detach+filters\n"));
             break;
 
@@ -1230 +1233 @@
             AssertReturn (mIsStatePending, false);
             AssertReturn (mPendingStateEx == kDetachingPendingDetach, false);
+            LogFlowThisFunc (("pending attach\n"));
             break;
 
         case kDetachingPendingAttachFilters:
             AssertReturn (mIsStatePending, false);
-            AssertReturn (   mPendingStateEx == kDetachingPendingAttach 
+            AssertReturn (   mPendingStateEx == kDetachingPendingAttach
                           || mPendingStateEx == kDetachingPendingDetachFilters, false);
+            LogFlowThisFunc (("pending attach+filters\n"));
             break;
 

trunk/src/VBox/Main/USBProxyService.cpp

@@ -196 +196 @@
         pDevices = sortDevices (pDevices);
 
-        /* 
+        /*
          * We need to lock the host object for writing because
          * a) the subsequent code may call Host methods that require a write
@@ -202 +202 @@
          * b) we will lock HostUSBDevice objects below and want to make sure
          *    the lock order is always the same (Host, HostUSBDevice, as
-         *    expected by Host) to avoid cross-deadlocks 
+         *    expected by Host) to avoid cross-deadlocks
          */
         AutoLock hostLock (mHost);
@@ -219 +219 @@
                 DevPtr = *It;
 
-            /* 
+            /*
              * Assert that the object is still alive (we still reference it in
-             * the collection and we're the only one who calls uninit() on it 
+             * the collection and we're the only one who calls uninit() on it
              */
             HostUSBDevice::AutoCaller devCaller (DevPtr.isNull() ? NULL : DevPtr);
             AssertComRC (devCaller.rc());
 
-            /* 
+            /*
              * Lock the device object since we will read/write it's
-             * properties. All Host callbacks also imply the object is locked. 
+             * properties. All Host callbacks also imply the object is locked.
              */
             AutoLock devLock (DevPtr.isNull() ? NULL : DevPtr);
@@ -248 +248 @@
             {
                 /*
-                 * The device still there, update the state and move on. The PUSBDEVICE 
+                 * The device still there, update the state and move on. The PUSBDEVICE
                  * structure is eaten by updateDeviceState / HostUSBDevice::updateState().
                  */
@@ -579 +579 @@
     AssertReturn (aDevice->isLockedOnCurrentThread(), false);
 
-    return aDevice->updateState (aUSBDevice);
+    bool fRc = aDevice->updateState (aUSBDevice);
+    /* A little hack to work around state quirks wrt detach/reattach. */
+    if (    !fRc
+        &&  aDevice->isStatePending()
+        &&  (   aDevice->pendingStateEx() == HostUSBDevice::kDetachingPendingAttach
+             || aDevice->pendingStateEx() == HostUSBDevice::kDetachingPendingAttachFilters))
+        fRc = true;
+    return fRc;
 }