Changeset 49814 in vbox for trunk/src/VBox/Devices/USB

Timestamp:

Dec 6, 2013 9:38:28 PM (11 years ago)

Author:

vboxsync

Message:

Devices/USB: First part of the rework, move most of the work to dedicated threads to improve performance

Location:

trunk/src/VBox/Devices/USB

Files:

• DevOHCI.cpp (modified) (25 diffs)
• DrvVUSBRootHub.cpp (modified) (4 diffs)
• USBProxyDevice.cpp (modified) (2 diffs)
• USBProxyDevice.h (modified) (1 diff)
• VUSBDevice.cpp (modified) (4 diffs)
• VUSBInternal.h (modified) (6 diffs)
• VUSBUrb.cpp (modified) (7 diffs)
• darwin/USBProxyDevice-darwin.cpp (modified) (2 diffs)
• linux/USBProxyDevice-linux.cpp (modified) (8 diffs)
• solaris/USBProxyDevice-solaris.cpp (modified) (8 diffs)
• vrdp/USBProxyDevice-vrdp.cpp (modified) (2 diffs)
• win/USBProxyDevice-win.cpp (modified) (10 diffs)

trunk/src/VBox/Devices/USB/DevOHCI.cpp

@@ -91 +91 @@
 #include <iprt/asm.h>
 #include <iprt/asm-math.h>
+#include <iprt/semaphore.h>
+#include <iprt/critsect.h>
 #ifdef IN_RING3
 # include <iprt/alloca.h>
@@ -359 +361 @@
 
     uint32_t            Alignment3;     /**< Align size on a 8 byte boundary. */
+
+    /** The framer thread. */
+    R3PTRTYPE(PPDMTHREAD) hThreadFrame;
+    /** Event semaphore to interact with the framer thread. */
+    R3PTRTYPE(RTSEMEVENT) hSemEventFrame;
+    /** Flag whether the framer thread should processing frames. */
+    volatile bool         fBusStarted;
+    /** Alignment. */
+    uint32_t              Alignment5;
+    /** How long to wait until the next frame. */
+    uint64_t              nsWait;
+    /** Critical section to synchronize the framer and URB completion handler. */
+    RTCRITSECT            CritSect;
+
 } OHCI;
 
@@ -785 +801 @@
     int level = 0;
 
+#ifdef IN_RING3
+    PDMCritSectEnter(ohci->pDevInsR3->pCritSectRoR3, VERR_IGNORED);
+#endif
+
     if (    (ohci->intr & OHCI_INTR_MASTER_INTERRUPT_ENABLED)
         &&  (ohci->intr_status & ohci->intr)
@@ -798 +818 @@
               (val >> 6) & 1, (val >> 30) & 1, msg)); NOREF(val); NOREF(msg);
     }
+
+#ifdef IN_RING3
+    PDMCritSectLeave(ohci->pDevInsR3->pCritSectRoR3);
+#endif
 }
 
@@ -1082 +1106 @@
      * any more when a reset has been signaled.
      */
+    RTCritSectEnter(&pThis->CritSect);
     pThis->RootHub.pIRhConn->pfnCancelAllUrbs(pThis->RootHub.pIRhConn);
+    RTCritSectLeave(&pThis->CritSect);
 
     /*
@@ -2431 +2457 @@
     LogFlow(("%s: ohciRhXferCompletion: EdAddr=%#010RX32 cTds=%d TdAddr0=%#010RX32\n",
              pUrb->pszDesc, pUrb->Hci.EdAddr, pUrb->Hci.cTds, pUrb->Hci.paTds[0].TdAddr));
-    Assert(PDMCritSectIsOwner(pThis->pDevInsR3->pCritSectRoR3));
-
+
+    RTCritSectEnter(&pThis->CritSect);
     pThis->fIdle = false;   /* Mark as active */
 
@@ -2456 +2482 @@
              pUrb->pszDesc, pUrb->Hci.EdAddr, pUrb->Hci.cTds, pUrb->Hci.paTds[0].TdAddr, cFmAge));
         STAM_COUNTER_INC(&pThis->StatDroppedUrbs);
+        RTCritSectLeave(&pThis->CritSect);
         return;
     }
@@ -2475 +2502 @@
         NOREF(fHasBeenCanceled);
         STAM_COUNTER_INC(&pThis->StatDroppedUrbs);
+        RTCritSectLeave(&pThis->CritSect);
         return;
     }
@@ -2489 +2517 @@
     /* finally write back the endpoint descriptor. */
     ohciWriteEd(pThis, pUrb->Hci.EdAddr, &Ed);
+    RTCritSectLeave(&pThis->CritSect);
 }
 
@@ -2506 +2535 @@
 {
     POHCI pThis = VUSBIROOTHUBPORT_2_OHCI(pInterface);
-    Assert(PDMCritSectIsOwner(pThis->pDevInsR3->pCritSectRoR3));
 
     /*
@@ -2523 +2551 @@
     }
 
+    RTCritSectEnter(&pThis->CritSect);
+
+    bool fRetire = false;
     /*
      * Check if the TDs still are valid.
@@ -2532 +2563 @@
     {
         Log(("%s: ohciRhXferError: TdAddr0=%#x canceled!\n", pUrb->pszDesc, TdAddr));
-        return true;
-    }
-
-    /*
-     * Get and update the error counter.
-     */
-    POHCITD     pTd = (POHCITD)&pUrb->Hci.paTds[0].TdCopy[0];
-    unsigned    cErrs = (pTd->hwinfo & TD_HWINFO_ERRORS) >> TD_ERRORS_SHIFT;
-    pTd->hwinfo &= ~TD_HWINFO_ERRORS;
-    cErrs++;
-    pTd->hwinfo |= (cErrs % TD_ERRORS_MAX) << TD_ERRORS_SHIFT;
-    ohciWriteTd(pThis, TdAddr, pTd, "ohciRhXferError");
-
-    if (cErrs >= TD_ERRORS_MAX - 1)
-    {
-        Log2(("%s: ohciRhXferError: too many errors, giving up!\n", pUrb->pszDesc));
-        return true;
-    }
-    Log2(("%s: ohciRhXferError: cErrs=%d: retrying...\n", pUrb->pszDesc, cErrs));
-    return false;
+        fRetire = true;
+    }
+    else
+    {
+        /*
+         * Get and update the error counter.
+         */
+        POHCITD     pTd = (POHCITD)&pUrb->Hci.paTds[0].TdCopy[0];
+        unsigned    cErrs = (pTd->hwinfo & TD_HWINFO_ERRORS) >> TD_ERRORS_SHIFT;
+        pTd->hwinfo &= ~TD_HWINFO_ERRORS;
+        cErrs++;
+        pTd->hwinfo |= (cErrs % TD_ERRORS_MAX) << TD_ERRORS_SHIFT;
+        ohciWriteTd(pThis, TdAddr, pTd, "ohciRhXferError");
+
+        if (cErrs >= TD_ERRORS_MAX - 1)
+        {
+            Log2(("%s: ohciRhXferError: too many errors, giving up!\n", pUrb->pszDesc));
+            fRetire = true;
+        }
+        else
+            Log2(("%s: ohciRhXferError: cErrs=%d: retrying...\n", pUrb->pszDesc, cErrs));
+    }
+
+    RTCritSectLeave(&pThis->CritSect);
+    return fRetire;
 }
 
@@ -3530 +3566 @@
     Assert(u32FrameRate <= OHCI_DEFAULT_TIMER_FREQ);
 
-
     pThis->cTicksPerFrame = pThis->u64TimerHz / u32FrameRate;
     if (!pThis->cTicksPerFrame)
         pThis->cTicksPerFrame = 1;
     pThis->cTicksPerUsbTick   = pThis->u64TimerHz >= VUSB_BUS_HZ ? pThis->u64TimerHz / VUSB_BUS_HZ : 1;
+    pThis->nsWait             = RT_NS_1SEC / u32FrameRate;
     pThis->uFrameRate         = u32FrameRate;
 }
@@ -3643 +3679 @@
 
     /*
-     * Update HcFmRemaining.FRT and re-arm the timer.
+     * Update HcFmRemaining.FRT and update start of frame time.
      */
     pThis->frt = pThis->fit;
-#if 1 /* This is required for making the quickcam work on the mac. Should really look
-         into that adaptive polling stuff... */
     pThis->SofTime += pThis->cTicksPerFrame;
-    const uint64_t u64Now = TMTimerGet(pThis->CTX_SUFF(pEndOfFrameTimer));
-    if (pThis->SofTime + pThis->cTicksPerFrame < u64Now)
-        pThis->SofTime = u64Now - pThis->cTicksPerFrame / 2;
-#else
-    pThis->SofTime = TMTimerGet(pThis->CTX_SUFF(pEndOfFrameTimer));
-#endif
-    TMTimerSet(pThis->CTX_SUFF(pEndOfFrameTimer), pThis->SofTime + pThis->cTicksPerFrame);
 
     /*
@@ -3664 +3691 @@
                         ||  pThis->hcca < ~OHCI_HCCA_MASK);
 
-#if 0 /* moved down for higher speed. */
+#if 1
     /*
      * Update the HCCA.
@@ -3713 +3740 @@
         ohciUndoBulkList(pThis);    /* If list disabled but not empty, abort endpoints. */
 
-#if 1
+#if 0
     /*
      * Update the HCCA after processing the lists and everything. A bit experimental.
@@ -3772 +3799 @@
     }
     if (uNewFrameRate != pThis->uFrameRate)
-    {
         ohciCalcTimerIntervals(pThis, uNewFrameRate);
-        if (uNewFrameRate == OHCI_DEFAULT_TIMER_FREQ)
-        {
-            /* If we're switching back to full speed, re-program the timer immediately to minimize latency. */
-            TMTimerSet(pThis->CTX_SUFF(pEndOfFrameTimer), pThis->SofTime + pThis->cTicksPerFrame);
-        }
-    }
 }
 
@@ -3792 +3812 @@
 }
 
+static DECLCALLBACK(int) ohciR3ThreadFrame(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
+{
+    int rc = VINF_SUCCESS;
+    POHCI pThis = (POHCI)pThread->pvUser;
+    uint64_t tsNanoStart = 0;
+
+    if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
+        return VINF_SUCCESS;
+
+    while (pThread->enmState == PDMTHREADSTATE_RUNNING)
+    {
+        while (   !ASMAtomicReadBool(&pThis->fBusStarted)
+               && pThread->enmState == PDMTHREADSTATE_RUNNING
+               && RT_SUCCESS(rc))
+            rc = RTSemEventWait(pThis->hSemEventFrame, RT_INDEFINITE_WAIT);
+
+        AssertLogRelMsgReturn(RT_SUCCESS(rc) || rc == VERR_TIMEOUT, ("%Rrc\n", rc), rc);
+        if (RT_UNLIKELY(pThread->enmState != PDMTHREADSTATE_RUNNING))
+            break;
+
+        tsNanoStart = RTTimeNanoTS();
+
+        RTCritSectEnter(&pThis->CritSect);
+
+        /* Reset idle detection flag */
+        pThis->fIdle = true;
+
+        /* Frame boundary, so do EOF stuff here. */
+        bump_frame_number(pThis);
+        if ( (pThis->dqic != 0x7) && (pThis->dqic != 0))
+            pThis->dqic--;
+
+        /* Clean up any URBs that have been removed. */
+        ohciCancelOrphanedURBs(pThis);
+
+        /* Start the next frame. */
+        ohciStartOfFrame(pThis);
+
+        RTCritSectLeave(&pThis->CritSect);
+
+        /* Wait for the next round. */
+        RTMSINTERVAL msWait = (RTMSINTERVAL)(((RTTimeNanoTS() + pThis->nsWait) - tsNanoStart) / 1000000);
+        rc = RTSemEventWait(pThis->hSemEventFrame, msWait);
+    }
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Unblock the framer thread so it can respond to a state change.
+ *
+ * @returns VBox status code.
+ * @param   pDevIns     The device instance.
+ * @param   pThread     The send thread.
+ */
+static DECLCALLBACK(int) ohciR3ThreadFrameWakeup(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
+{
+    POHCI pThis = PDMINS_2_DATA(pDevIns, POHCI);
+    return RTSemEventSignal(pThis->hSemEventFrame);
+}
+
 /**
  * Do frame processing on frame boundary
@@ -3799 +3880 @@
     POHCI pThis = (POHCI)pvUser;
     STAM_PROFILE_START(&pThis->StatTimer, a);
-
-    /* Reset idle detection flag */
-    pThis->fIdle = true;
-
-    VUSBIRhReapAsyncUrbs(pThis->RootHub.pIRhConn, 0);
-
-    /* Frame boundary, so do EOF stuff here */
-    bump_frame_number(pThis);
-    if ( (pThis->dqic != 0x7) && (pThis->dqic != 0) )
-        pThis->dqic--;
-
-    /* Clean up any URBs that have been removed */
-    ohciCancelOrphanedURBs(pThis);
-
-    /* Start the next frame */
-    ohciStartOfFrame(pThis);
-
     STAM_PROFILE_STOP(&pThis->StatTimer, a);
 }
@@ -3826 +3890 @@
 {
     VUSBIDevPowerOn(pThis->RootHub.pIDev);
-    bump_frame_number(pThis);
     pThis->dqic = 0x7;
 
     Log(("ohci: %s: Bus started\n", pThis->PciDev.name));
 
-    pThis->SofTime = TMTimerGet(pThis->CTX_SUFF(pEndOfFrameTimer)) - pThis->cTicksPerFrame;
-    pThis->fIdle = false;   /* Assume we won't be idle */
-    ohciStartOfFrame(pThis);
+    pThis->SofTime = PDMDevHlpTMTimeVirtGet(pThis->CTX_SUFF(pDevIns));
+    ASMAtomicXchgBool(&pThis->fBusStarted, true);
+    RTSemEventSignal(pThis->hSemEventFrame);
 }
 
@@ -3841 +3904 @@
 static void ohciBusStop(POHCI pThis)
 {
-    if (pThis->CTX_SUFF(pEndOfFrameTimer))
-        TMTimerStop(pThis->CTX_SUFF(pEndOfFrameTimer));
+    ASMAtomicXchgBool(&pThis->fBusStarted, false);
+    RTSemEventSignal(pThis->hSemEventFrame);
     VUSBIDevPowerOff(pThis->RootHub.pIDev);
 }
@@ -4368 +4431 @@
          * Being in USB operational state guarantees SofTime was set already.
          */
-        uint64_t tks = TMTimerGet(pThis->CTX_SUFF(pEndOfFrameTimer)) - pThis->SofTime;
+        uint64_t tks = PDMDevHlpTMTimeVirtGet(pThis->CTX_SUFF(pDevIns)) - pThis->SofTime;
         if (tks < pThis->cTicksPerFrame)  /* avoid muldiv if possible */
         {
@@ -5019 +5082 @@
                 pRh->aPorts[i].pDev = pDev;
             }
-            else /* Reap URBs one last time to make sure the lists are empty. */
-                VUSBIRhReapAsyncUrbs(pRh->pIRhConn, 0);
         }
     }
@@ -5449 +5510 @@
 static DECLCALLBACK(int) ohciR3Destruct(PPDMDEVINS pDevIns)
 {
+    POHCI pThis = PDMINS_2_DATA(pDevIns, POHCI);
     PDMDEV_CHECK_VERSIONS_RETURN_QUIET(pDevIns);
+
+    /*
+     * Destroy event sempahores.
+     */
+    RTSemEventDestroy(pThis->hSemEventFrame);
+    RTCritSectDelete(&pThis->CritSect);
 
     /*
@@ -5593 +5661 @@
     Log(("ohci: cTicksPerFrame=%RU64 cTicksPerUsbTick=%RU64\n",
          pThis->cTicksPerFrame, pThis->cTicksPerUsbTick));
+
+    pThis->fBusStarted = false;
+
+    rc = RTSemEventCreate(&pThis->hSemEventFrame);
+    AssertRCReturn(rc, rc);
+
+    /*
+     * Initialize the critical section without the lock validator.
+     * This is necessary because USB devices attached to this controller
+     * will be detached in the save state callback with the
+     * per device PDM critical section held. If there are still URBs pending
+     * for this device they will get reaped and cause a lock validator error
+     * because they will take this critical section.
+     *
+     * The framer thread on the other hand will first take this critical section
+     * during a run and might take the PDM critical section when issuing an interrupt.
+     * Normally this is a real deadlock issue but we make sure
+     * that the framer thread is not running when the save state handler is called.
+     */
+    rc = RTCritSectInitEx(&pThis->CritSect, RTCRITSECT_FLAGS_NO_LOCK_VAL,
+                          NIL_RTLOCKVALCLASS, RTLOCKVAL_SUB_CLASS_USER, "OhciCritSect");
+    if (RT_FAILURE(rc))
+        return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
+                                   N_("OHCI: Failed to create critical section"));
+
+    rc = PDMDevHlpThreadCreate(pDevIns, &pThis->hThreadFrame, pThis, ohciR3ThreadFrame,
+                               ohciR3ThreadFrameWakeup, 0, RTTHREADTYPE_IO, "OhciFramer");
+    if (RT_FAILURE(rc))
+        return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
+                                   N_("OHCI: Failed to create worker thread"));
 
     /*

trunk/src/VBox/Devices/USB/DrvVUSBRootHub.cpp

@@ -585 +585 @@
      */
     LogFlow(("vusbRhCancelUrbsEp: pRh=%p pUrb=%p\n", pRh));
+
+    /* Tear down reaper thread on the device. */
+    PVUSBDEV pDev = pUrb->VUsb.pDev;
+    int rc = vusbDevUrbIoThreadDestroy(pDev);
+    if (RT_FAILURE(rc))
+        return rc;
+
     vusbUrbCancel(pUrb, CANCELMODE_UNDO);
 
@@ -597 +604 @@
         vusbUrbRipe(pRipe);
     }
-    return VINF_SUCCESS;
+
+    rc = vusbDevUrbIoThreadCreate(pDev);
+    return rc;
 }
 
@@ -604 +613 @@
 {
     PVUSBROOTHUB pRh = VUSBIROOTHUBCONNECTOR_2_VUSBROOTHUB(pInterface);
+
+    /*
+     * Tear down all reaper threads first to avoid concurrency issues.
+     * pfnUrbReap is not thread safe.
+     */
+    PVUSBDEV pDev = pRh->pDevices;
+    while (pDev)
+    {
+        int rc = vusbDevUrbIoThreadDestroy(pDev);
+        AssertRC(rc); /* Should not fail. */
+        pDev = pDev->pNext;
+    }
 
     /*
@@ -635 +656 @@
             vusbUrbRipe(pRipe);
         }
+    }
+
+    /*
+     * Create the reaper threads again.
+     */
+    pDev = pRh->pDevices;
+    while (pDev)
+    {
+        int rc = vusbDevUrbIoThreadCreate(pDev);
+        AssertRC(rc); /** @todo: What if this fails? */
+        pDev = pDev->pNext;
     }
 }

trunk/src/VBox/Devices/USB/USBProxyDevice.cpp

@@ -696 +696 @@
         pUrb->enmStatus = VUSBSTATUS_DNR;
     return pUrb;
+}
+
+
+/**
+ * @copydoc PDMUSBREG::pfnWakeup
+ *
+ * USB Device Proxy: Call OS specific code.
+ */
+static DECLCALLBACK(int) usbProxyDevWakeup(PPDMUSBINS pUsbIns)
+{
+    PUSBPROXYDEV pProxyDev = PDMINS_2_DATA(pUsbIns, PUSBPROXYDEV);
+
+    return pProxyDev->pOps->pfnWakeup(pProxyDev);
 }
 
@@ -1124 +1137 @@
     /* pfnUrbReap */
     usbProxyDevUrbReap,
+    /* pfnWakeup */
+    usbProxyDevWakeup,
 
     /* u32TheEnd */

trunk/src/VBox/Devices/USB/USBProxyDevice.h

@@ -129 +129 @@
      */
     PVUSBURB (* pfnUrbReap)(PUSBPROXYDEV pProxyDev, RTMSINTERVAL cMillies);
+
+    /**
+     * Kicks the thread waiting in pfnUrbReap to make it return.
+     *
+     * @returns VBox status code.
+     * @param   pProxyDev   The device.
+     */
+    int (* pfnWakeup)(PUSBPROXYDEV pProxyDev);
 
     /** Dummy entry for making sure we've got all members initialized. */

trunk/src/VBox/Devices/USB/VUSBDevice.cpp

@@ -1116 +1116 @@
 
 
+static DECLCALLBACK(int) vusbDevUrbIoThread(RTTHREAD hThread, void *pvUser)
+{
+    PVUSBDEV pDev = (PVUSBDEV)pvUser;
+
+    /* Notify the starter that we are up and running. */
+    RTThreadUserSignal(hThread);
+
+    LogFlowFunc(("Entering work loop\n"));
+
+    while (!ASMAtomicReadBool(&pDev->fTerminate))
+    {
+        if (pDev->enmState != VUSB_DEVICE_STATE_RESET)
+            vusbUrbDoReapAsyncDev(pDev, RT_INDEFINITE_WAIT);
+
+        /* Woken up or there is an URB to queue. */
+        PRTQUEUEATOMICITEM pHead = RTQueueAtomicRemoveAll(&pDev->QueueUrb);
+        while (pHead)
+        {
+            PVUSBURB pUrb = RT_FROM_MEMBER(pHead, VUSBURB, Dev.QueueItem);
+
+            pHead = pHead->pNext;
+
+            LogFlow(("%s: Queuing URB\n", pUrb->pszDesc));
+            int rc = pUrb->pUsbIns->pReg->pfnUrbQueue(pUrb->pUsbIns, pUrb);
+            if (RT_FAILURE(rc))
+            {
+                LogFlow(("%s: Queuing URB failed with %Rrc\n", pUrb->pszDesc, rc));
+
+                /*
+                 * The device was detached, so we fail everything.
+                 * (We should really detach and destroy the device, but we'll have to wait till Main reacts.)
+                 */
+                if (rc == VERR_VUSB_DEVICE_NOT_ATTACHED)
+                    rc = vusbUrbSubmitHardError(pUrb);
+
+                /*
+                 * We don't increment error count if async URBs are in flight, in
+                 * this case we just assume we need to throttle back, this also
+                 * makes sure we don't halt bulk endpoints at the wrong time.
+                 */
+                else if (   RT_FAILURE(rc)
+                         && !pDev->aPipes[pUrb->EndPt].async
+                         /* && pUrb->enmType == VUSBXFERTYPE_BULK ?? */
+                         && !vusbUrbErrorRh(pUrb))
+                {
+                    /* don't retry it anymore. */
+                    pUrb->enmState = VUSBURBSTATE_REAPED;
+                    pUrb->enmStatus = VUSBSTATUS_CRC;
+                    vusbUrbCompletionRh(pUrb);
+                }
+            }
+        }
+    }
+
+    return VINF_SUCCESS;
+}
+
+int vusbDevUrbIoThreadWakeup(PVUSBDEV pDev)
+{
+    ASMAtomicXchgBool(&pDev->fWokenUp, true);
+    return pDev->pUsbIns->pReg->pfnWakeup(pDev->pUsbIns);
+}
+
+/**
+ * Create the URB I/O thread.
+ *
+ * @returns VBox status code.
+ * @param   pDev    The VUSB device.
+ */
+int vusbDevUrbIoThreadCreate(PVUSBDEV pDev)
+{
+    int rc = VINF_SUCCESS;
+
+    ASMAtomicXchgBool(&pDev->fTerminate, false);
+    rc = RTThreadCreateF(&pDev->hUrbIoThread, vusbDevUrbIoThread, pDev, 0, RTTHREADTYPE_IO,
+                         RTTHREADFLAGS_WAITABLE, "USBDevIo-%d", pDev->i16Port);
+    if (RT_SUCCESS(rc))
+    {
+        /* Wait for it to become active. */
+        rc = RTThreadUserWait(pDev->hUrbIoThread, RT_INDEFINITE_WAIT);
+    }
+
+    return rc;
+}
+
+/**
+ * Destro the URB I/O thread.
+ *
+ * @returns VBox status code.
+ * @param   pDev    The VUSB device.
+ */
+int vusbDevUrbIoThreadDestroy(PVUSBDEV pDev)
+{
+    int rc = VINF_SUCCESS;
+    int rcThread = VINF_SUCCESS;
+
+    ASMAtomicXchgBool(&pDev->fTerminate, true);
+    vusbDevUrbIoThreadWakeup(pDev);
+
+    rc = RTThreadWait(pDev->hUrbIoThread, RT_INDEFINITE_WAIT, &rcThread);
+    if (RT_SUCCESS(rc))
+        rc = rcThread;
+
+    return rc;
+}
+
+
 /**
  * Detaches a device from the hub it's attached to.
@@ -1182 +1289 @@
         }
     }
+
+    /* Destroy I/O thread. */
+    vusbDevUrbIoThreadDestroy(pDev);
 
     /*
@@ -1576 +1686 @@
     pDev->pvResetArgs = NULL;
     pDev->pResetTimer = NULL;
+    RTQueueAtomicInit(&pDev->QueueUrb);
 
     /*
@@ -1619 +1730 @@
     AssertMsgReturn(pDev->paIfStates, ("RTMemAllocZ(%d) failed\n", cbIface), VERR_NO_MEMORY);
 
+    rc = vusbDevUrbIoThreadCreate(pDev);
+    AssertRCReturn(rc, rc);
+
     return VINF_SUCCESS;
 }

trunk/src/VBox/Devices/USB/VUSBInternal.h

@@ -29 +29 @@
 #include <VBox/vmm/stam.h>
 #include <iprt/assert.h>
+#include <iprt/queueatomic.h>
 
 RT_C_DECLS_BEGIN
@@ -122 +123 @@
     PVUSBCTRLEXTRA      pCtrl;
     /** Count of active async transfers. */
-    uint8_t             async;
+    volatile uint32_t   async;
     /** The periodic read-ahead buffer thread. */
     RTTHREAD            ReadAheadThread;
@@ -214 +215 @@
     /** The reset timer handle. */
     PTMTIMER            pResetTimer;
+    /** URB submit and reap thread. */
+    RTTHREAD            hUrbIoThread;
+    /** Queue of URBs to submit. */
+    RTQUEUEATOMIC       QueueUrb;
+    /** Flag whether the URB I/O thread should terminate. */
+    bool volatile       fTerminate;
+    /** Flag whether the I/O thread was woken up. */
+    bool volatile       fWokenUp;
 #if HC_ARCH_BITS == 32
     /** Align the size to a 8 byte boundary. */
@@ -434 +443 @@
 void vusbUrbTrace(PVUSBURB pUrb, const char *pszMsg, bool fComplete);
 void vusbUrbDoReapAsync(PVUSBURB pHead, RTMSINTERVAL cMillies);
+void vusbUrbDoReapAsyncDev(PVUSBDEV pDev, RTMSINTERVAL cMillies);
 void vusbUrbCancel(PVUSBURB pUrb, CANCELMODE mode);
 void vusbUrbRipe(PVUSBURB pUrb);
 void vusbUrbCompletionRh(PVUSBURB pUrb);
+int vusbUrbSubmitHardError(PVUSBURB pUrb);
+int vusbUrbErrorRh(PVUSBURB pUrb);
+int vusbDevUrbIoThreadWakeup(PVUSBDEV pDev);
+int vusbDevUrbIoThreadCreate(PVUSBDEV pDev);
+int vusbDevUrbIoThreadDestroy(PVUSBDEV pDev);
 
 void vusbUrbCompletionReadAhead(PVUSBURB pUrb);
@@ -448 +463 @@
 DECLINLINE(void) vusbUrbUnlink(PVUSBURB pUrb)
 {
+    PVUSBROOTHUB pRh = vusbDevGetRh(pUrb->VUsb.pDev);
+
+    RTCritSectEnter(&pRh->CritSect);
     *pUrb->VUsb.ppPrev = pUrb->VUsb.pNext;
     if (pUrb->VUsb.pNext)
@@ -453 +471 @@
     pUrb->VUsb.pNext = NULL;
     pUrb->VUsb.ppPrev = NULL;
+    RTCritSectLeave(&pRh->CritSect);
 }
 

trunk/src/VBox/Devices/USB/VUSBUrb.cpp

@@ -986 +986 @@
  * @param   pUrb    The URB in question.
  */
-static int vusbUrbErrorRh(PVUSBURB pUrb)
+int vusbUrbErrorRh(PVUSBURB pUrb)
 {
     PVUSBDEV pDev = pUrb->VUsb.pDev;
@@ -1205 +1205 @@
     }
 
-    int rc = pUrb->pUsbIns->pReg->pfnUrbQueue(pUrb->pUsbIns, pUrb);
-    if (RT_FAILURE(rc))
-    {
-        LogFlow(("%s: vusbUrbQueueAsyncRh: returns %Rrc (queue_urb)\n", pUrb->pszDesc, rc));
-        return rc;
-    }
-
-    pDev->aPipes[pUrb->EndPt].async++;
+    ASMAtomicIncU32(&pDev->aPipes[pUrb->EndPt].async);
 
     /* Queue the pUrb on the roothub */
@@ -1223 +1216 @@
     RTCritSectLeave(&pRh->CritSect);
 
-    return rc;
+    RTQueueAtomicInsert(&pDev->QueueUrb, &pUrb->Dev.QueueItem);
+    vusbDevUrbIoThreadWakeup(pDev);
+
+    return VINF_SUCCESS;
 }
 
@@ -1799 +1795 @@
  * @param   pUrb    The URB.
  */
-static int vusbUrbSubmitHardError(PVUSBURB pUrb)
+int vusbUrbSubmitHardError(PVUSBURB pUrb)
 {
     /* FIXME: Find out the correct return code from the spec */
@@ -1927 +1923 @@
      */
     else if (   RT_FAILURE(rc)
-             && !pDev->aPipes[pUrb->EndPt].async
+             && !ASMAtomicReadU32(&pDev->aPipes[pUrb->EndPt].async)
              /* && pUrb->enmType == VUSBXFERTYPE_BULK ?? */
              && !vusbUrbErrorRh(pUrb))
@@ -1986 +1982 @@
 }
 
+/**
+ * Reap URBs on a per device level.
+ *
+ * @returns nothing.
+ * @param   pDev        The device instance to reap URBs for.
+ * @param   cMillies    Number of milliseconds to block in each reap operation.
+ *                      Use 0 to not block at all.
+ */
+void vusbUrbDoReapAsyncDev(PVUSBDEV pDev, RTMSINTERVAL cMillies)
+{
+    Assert(pDev->enmState != VUSB_DEVICE_STATE_RESET);
+
+    /*
+     * Reap most URBs pending on a single device.
+     */
+    PVUSBURB pRipe;
+
+    /**
+     * This is workaround for race(should be fixed) detach on one EMT thread and frame boundary timer on other
+     * and leaked URBs (shouldn't be affected by leaked URBs).
+     */
+
+    if (ASMAtomicXchgBool(&pDev->fWokenUp, false))
+        return;
+
+    Assert(pDev->pUsbIns);
+    while (   pDev->pUsbIns
+           && ((pRipe = pDev->pUsbIns->pReg->pfnUrbReap(pDev->pUsbIns, cMillies)) != NULL))
+    {
+        vusbUrbAssert(pRipe);
+        vusbUrbRipe(pRipe);
+        if (ASMAtomicXchgBool(&pDev->fWokenUp, false))
+            break;
+    }
+}
 
 /**
@@ -1993 +2024 @@
 {
     Assert(pUrb->VUsb.pDev->aPipes);
-    pUrb->VUsb.pDev->aPipes[pUrb->EndPt].async--;
+    ASMAtomicDecU32(&pUrb->VUsb.pDev->aPipes[pUrb->EndPt].async);
 
     if (pUrb->enmState == VUSBURBSTATE_REAPED)

trunk/src/VBox/Devices/USB/darwin/USBProxyDevice-darwin.cpp

@@ -1872 +1872 @@
 
 
+static int usbProxyDarwinUrbReap(PUSBPROXYDEV pProxyDev, RTMSINTERVAL cMillies)
+{
+    PUSBPROXYDEVOSX pDevOsX = (PUSBPROXYDEVOSX)pProxyDev->Backend.pv;
+
+    CFRunLoopStop(g_pRunLoopMode);
+    return VINF_SUCCESS;
+}
+
+
 /**
  * The Darwin USB Proxy Backend.
@@ -1890 +1899 @@
     usbProxyDarwinUrbCancel,
     usbProxyDarwinUrbReap,
+    usbProxyDarwinWakeup,
     0
 };

trunk/src/VBox/Devices/USB/linux/USBProxyDevice-linux.cpp

@@ -33 +33 @@
 #include <iprt/stdint.h>
 #include <iprt/err.h>
+#include <iprt/pipe.h>
 
 #include <sys/types.h>
@@ -153 +154 @@
     /** Are we using sysfs to find the active configuration? */
     bool                fUsingSysfs;
+    /** Pipe handle for waiking up - writing end. */
+    RTPIPE              hPipeWakeupW;
+    /** Pipe handle for waiking up - reading end. */
+    RTPIPE              hPipeWakeupR;
     /** The device node/sysfs path of the device.
      * Used to figure out the configuration after a reset. */
@@ -657 +662 @@
     if (RT_SUCCESS(rc))
     {
-        /*
-         * Allocate and initialize the linux backend data.
-         */
-        PUSBPROXYDEVLNX pDevLnx = (PUSBPROXYDEVLNX)RTMemAllocZVar(sizeof(*pDevLnx) + cchPath);
-        if (pDevLnx)
-        {
-            pDevLnx->fUsingSysfs = fUsingSysfs;
-            memcpy(&pDevLnx->szPath[0], pszPath, cchPath);
-            pDevLnx->szPath[cchPath] = '\0';
-            pDevLnx->hFile = hFile;
-            rc = RTCritSectInit(&pDevLnx->CritSect);
-            if (RT_SUCCESS(rc))
+            /*
+             * Allocate and initialize the linux backend data.
+             */
+            PUSBPROXYDEVLNX pDevLnx = (PUSBPROXYDEVLNX)RTMemAllocZVar(sizeof(*pDevLnx) + cchPath);
+            if (pDevLnx)
             {
-                pProxyDev->Backend.pv = pDevLnx;
-
-                LogFlow(("usbProxyLinuxOpen(%p, %s): returns successfully File=%RTfile iActiveCfg=%d\n",
-                         pProxyDev, pszAddress, pDevLnx->hFile, pProxyDev->iActiveCfg));
-
-                return VINF_SUCCESS;
+
+                rc = RTPipeCreate(&pDevLnx->hPipeWakeupR, &pDevLnx->hPipeWakeupW, 0);
+                if (RT_SUCCESS(rc))
+                {
+                    pDevLnx->fUsingSysfs = fUsingSysfs;
+                    memcpy(&pDevLnx->szPath[0], pszPath, cchPath);
+                    pDevLnx->szPath[cchPath] = '\0';
+                    pDevLnx->hFile = hFile;
+                    rc = RTCritSectInit(&pDevLnx->CritSect);
+                    if (RT_SUCCESS(rc))
+                    {
+                        pProxyDev->Backend.pv = pDevLnx;
+
+                        LogFlow(("usbProxyLinuxOpen(%p, %s): returns successfully File=%RTfile iActiveCfg=%d\n",
+                                 pProxyDev, pszAddress, pDevLnx->hFile, pProxyDev->iActiveCfg));
+
+                        return VINF_SUCCESS;
+                    }
+                    RTPipeClose(pDevLnx->hPipeWakeupR);
+                    RTPipeClose(pDevLnx->hPipeWakeupW);
+                }
+
+                RTMemFree(pDevLnx);
             }
-
-            RTMemFree(pDevLnx);
-        }
-        else
-            rc = VERR_NO_MEMORY;
+            else
+                rc = VERR_NO_MEMORY;
+
         RTFileClose(hFile);
     }
@@ -814 +827 @@
     RTFileClose(pDevLnx->hFile);
     pDevLnx->hFile = NIL_RTFILE;
+
+    RTPipeClose(pDevLnx->hPipeWakeupR);
+    RTPipeClose(pDevLnx->hPipeWakeupW);
 
     RTMemFree(pDevLnx);
@@ -1745 +1761 @@
          */
         if (!pDevLnx->pInFlightHead)
+        {
+            int cMilliesWait = cMillies == RT_INDEFINITE_WAIT ? -1 : cMillies;
+
+            LogFlow(("Nothing in flight, going to sleep\n"));
+
+            struct pollfd pfd;
+
+            pfd.fd = RTPipeToNative(pDevLnx->hPipeWakeupR);
+            pfd.events = POLLIN | POLLHUP;
+            pfd.revents = 0;
+
+            int rc = poll(&pfd, 1, cMilliesWait);
+            Log(("usbProxyLinuxUrbReap: poll rc = %d\n", rc));
+            if (rc >= 1)
+            {
+                /* Drain pipe. */
+               uint8_t bRead;
+               size_t cbIgnored = 0;
+               RTPipeRead(pDevLnx->hPipeWakeupR, &bRead, 1, &cbIgnored);
+            }
             return NULL;
+        }
 
         /*
@@ -1756 +1793 @@
         if (cMillies)
         {
+            int cMilliesWait = cMillies == RT_INDEFINITE_WAIT ? -1 : cMillies;
 
             for (;;)
             {
-                struct pollfd pfd;
-                pfd.fd = RTFileToNative(pDevLnx->hFile);
-                pfd.events = POLLOUT | POLLWRNORM /* completed async */
-                           | POLLERR | POLLHUP    /* disconnected */;
-                pfd.revents = 0;
-                int rc = poll(&pfd, 1, cMillies);
+                struct pollfd pfd[2];
+                pfd[0].fd = RTFileToNative(pDevLnx->hFile);
+                pfd[0].events = POLLOUT | POLLWRNORM /* completed async */
+                              | POLLERR | POLLHUP    /* disconnected */;
+                pfd[0].revents = 0;
+
+                pfd[1].fd = RTPipeToNative(pDevLnx->hPipeWakeupR);
+                pfd[1].events = POLLIN | POLLHUP;
+                pfd[1].revents = 0;
+
+                int rc = poll(&pfd[0], 2, cMilliesWait);
                 Log(("usbProxyLinuxUrbReap: poll rc = %d\n", rc));
                 if (rc >= 1)
+                {
+                    /* If the pipe caused the return drain it. */
+                    if (pfd[1].revents & POLLIN)
+                    {
+                        uint8_t bRead;
+                        size_t cbIgnored = 0;
+                        RTPipeRead(pDevLnx->hPipeWakeupR, &bRead, 1, &cbIgnored);
+                    }
                     break;
+                }
                 if (rc >= 0 /*|| errno == ETIMEOUT*/)
                 {
@@ -1947 +1999 @@
 
 
+static DECLCALLBACK(int) usbProxyLinuxWakeup(PUSBPROXYDEV pProxyDev)
+{
+    PUSBPROXYDEVLNX pDevLnx = (PUSBPROXYDEVLNX)pProxyDev->Backend.pv;
+    size_t cbIgnored;
+
+    LogFlowFunc(("pProxyDev=%p\n", pProxyDev));
+
+    return RTPipeWrite(pDevLnx->hPipeWakeupW, "", 1, &cbIgnored);
+}
+
 /**
  * The Linux USB Proxy Backend.
@@ -1965 +2027 @@
     usbProxyLinuxUrbCancel,
     usbProxyLinuxUrbReap,
+    usbProxyLinuxWakeup,
     0
 };

trunk/src/VBox/Devices/USB/solaris/USBProxyDevice-solaris.cpp

@@ -38 +38 @@
 #include <iprt/file.h>
 #include <iprt/mem.h>
+#include <iprt/pipe.h>
 #include "../USBProxyDevice.h"
 #include <VBox/usblib.h>
@@ -91 +92 @@
     /** The tail of the landed solaris URBs. */
     PUSBPROXYURBSOL                pTaxingTail;
+    /** Pipe handle for waiking up - writing end. */
+    RTPIPE                         hPipeWakeupW;
+    /** Pipe handle for waiking up - reading end. */
+    RTPIPE                         hPipeWakeupR;
 } USBPROXYDEVSOL, *PUSBPROXYDEVSOL;
 
@@ -309 +314 @@
                     pProxyDev->Backend.pv = pDevSol;
 
-                    int Instance;
-                    char *pszDevicePath = NULL;
-                    rc = USBLibGetClientInfo(szDeviceIdent, &pszDevicePath, &Instance);
+                    /*
+                     * Create wakeup pipe.
+                     */
+                    rc = RTPipeCreate(&pDevLnx->hPipeWakeupR, &pDevLnx->hPipeWakeupW, 0);
                     if (RT_SUCCESS(rc))
                     {
-                        pDevSol->pszDevicePath = pszDevicePath;
-
-                        /*
-                         * Open the client driver.
-                         */
-                        RTFILE hFile;
-                        rc = RTFileOpen(&hFile, pDevSol->pszDevicePath, RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
+                        int Instance;
+                        char *pszDevicePath = NULL;
+                        rc = USBLibGetClientInfo(szDeviceIdent, &pszDevicePath, &Instance);
                         if (RT_SUCCESS(rc))
                         {
-                            pDevSol->hFile = hFile;
-                            pDevSol->pProxyDev = pProxyDev;
+                            pDevSol->pszDevicePath = pszDevicePath;
 
                             /*
-                             * Verify client driver version.
+                             * Open the client driver.
                              */
-                            VBOXUSBREQ_GET_VERSION GetVersionReq;
-                            bzero(&GetVersionReq, sizeof(GetVersionReq));
-                            rc = usbProxySolarisIOCtl(pDevSol, VBOXUSB_IOCTL_GET_VERSION, &GetVersionReq, sizeof(GetVersionReq));
+                            RTFILE hFile;
+                            rc = RTFileOpen(&hFile, pDevSol->pszDevicePath, RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
                             if (RT_SUCCESS(rc))
                             {
-                                if (   GetVersionReq.u32Major == VBOXUSB_VERSION_MAJOR
-                                    && GetVersionReq.u32Minor >= VBOXUSB_VERSION_MINOR)
+                                pDevSol->hFile = hFile;
+                                pDevSol->pProxyDev = pProxyDev;
+
+                                /*
+                                 * Verify client driver version.
+                                 */
+                                VBOXUSBREQ_GET_VERSION GetVersionReq;
+                                bzero(&GetVersionReq, sizeof(GetVersionReq));
+                                rc = usbProxySolarisIOCtl(pDevSol, VBOXUSB_IOCTL_GET_VERSION, &GetVersionReq, sizeof(GetVersionReq));
+                                if (RT_SUCCESS(rc))
                                 {
-                                    /*
-                                     * Try & get the current cached config from Solaris.
-                                     */
-                                    usbProxySolarisGetActiveConfig(pDevSol);
-                                    return VINF_SUCCESS;
+                                    if (   GetVersionReq.u32Major == VBOXUSB_VERSION_MAJOR
+                                        && GetVersionReq.u32Minor >= VBOXUSB_VERSION_MINOR)
+                                    {
+                                        /*
+                                         * Try & get the current cached config from Solaris.
+                                         */
+                                        usbProxySolarisGetActiveConfig(pDevSol);
+                                        return VINF_SUCCESS;
+                                    }
+                                    else
+                                    {
+                                        LogRel((USBPROXY ":version mismatch! driver v%d.%d expecting ~v%d.%d\n", GetVersionReq.u32Major,
+                                                GetVersionReq.u32Minor, VBOXUSB_VERSION_MAJOR, VBOXUSB_VERSION_MINOR));
+                                        rc = VERR_VERSION_MISMATCH;
+                                    }
                                 }
                                 else
                                 {
-                                    LogRel((USBPROXY ":version mismatch! driver v%d.%d expecting ~v%d.%d\n", GetVersionReq.u32Major,
-                                            GetVersionReq.u32Minor, VBOXUSB_VERSION_MAJOR, VBOXUSB_VERSION_MINOR));
-                                    rc = VERR_VERSION_MISMATCH;
+                                    LogRel((USBPROXY ":failed to query driver version. rc=%Rrc\n", rc));
                                 }
+
+                                RTFileClose(pDevSol->hFile);
+                                pDevSol->hFile = NIL_RTFILE;
+                                pDevSol->pProxyDev = NULL;
                             }
                             else
-                            {
-                                LogRel((USBPROXY ":failed to query driver version. rc=%Rrc\n", rc));
-                            }
-
-                            RTFileClose(pDevSol->hFile);
-                            pDevSol->hFile = NIL_RTFILE;
-                            pDevSol->pProxyDev = NULL;
+                                LogRel((USBPROXY ":failed to open device. rc=%Rrc pszDevicePath=%s\n", rc, pDevSol->pszDevicePath));
+
+                            RTStrFree(pDevSol->pszDevicePath);
+                            pDevSol->pszDevicePath = NULL;
                         }
                         else
-                            LogRel((USBPROXY ":failed to open device. rc=%Rrc pszDevicePath=%s\n", rc, pDevSol->pszDevicePath));
-
-                        RTStrFree(pDevSol->pszDevicePath);
-                        pDevSol->pszDevicePath = NULL;
-                    }
-                    else
-                    {
-                        LogRel((USBPROXY ":failed to get client info. rc=%Rrc pszDevicePath=%s\n", rc, pDevSol->pszDevicePath));
-                        if (rc == VERR_NOT_FOUND)
-                            rc = VERR_OPEN_FAILED;
+                        {
+                            LogRel((USBPROXY ":failed to get client info. rc=%Rrc pszDevicePath=%s\n", rc, pDevSol->pszDevicePath));
+                            if (rc == VERR_NOT_FOUND)
+                                rc = VERR_OPEN_FAILED;
+                        }
+                        RTPipeClose(pDevLnx->hPipeWakeupR);
+                        RTPipeClose(pDevLnx->hPipeWakeupW);
                     }
 
@@ -431 +445 @@
         RTMemFree(pUrbSol);
     }
+
+    RTPipeClose(pDevLnx->hPipeWakeupR);
+    RTPipeClose(pDevLnx->hPipeWakeupW);
 
     RTStrFree(pDevSol->pszDevicePath);
@@ -703 +720 @@
         for (;;)
         {
-            struct pollfd pfd;
-            pfd.fd = RTFileToNative(pDevSol->hFile);
-            pfd.events = POLLIN;
-            pfd.revents = 0;
-            int rc = poll(&pfd, 1, cMillies);
+            int cMilliesWait = cMillies == RT_INDEFINITE_WAIT ? -1 : cMillies;
+            struct pollfd pfd[2];
+
+            pfd[0].fd = RTFileToNative(pDevSol->hFile);
+            pfd[0].events = POLLIN;
+            pfd[0].revents = 0;
+
+            pfd[1].fd = RTPipeToNative(pDevSol->hWakeupPipeR);
+            pfd[1].events = POLLIN;
+            pfd[1].revents = 0;
+
+            int rc = poll(&pfd, 2, cMilliesWait);
             if (rc > 0)
             {
-                if (pfd.revents & POLLHUP)
+                if (pfd[0].revents & POLLHUP)
                 {
                     LogRel((USBPROXY ":Reaping failed, USB Device '%s' disconnected!\n", pDevSol->pProxyDev->pUsbIns->pszName));
@@ -716 +740 @@
                     usbProxySolarisCloseFile(pDevSol);
                 }
+
+                if (pfd[1].revents & POLLIN)
+                {
+                    /* Got woken up, drain pipe. */
+                    uint8_t bRead;
+                    size_t cbIgnored = 0;
+                    RTPipeRead(pDevLnx->hPipeWakeupR, &bRead, 1, &cbIgnored);
+
+                    /*
+                     * It is possible that we got woken up and have an URB pending
+                     * for completion. Do it on the way out. Otherwise return
+                     * immediately to the caller.
+                     */
+                    if (!(pfd[0].revents & POLLIN))
+                        return NULL;
+                }
+
                 break;
             }
@@ -852 +893 @@
 
 
+static DECLCALLBACK(int) usbProxySolarisWakeup(PUSBPROXYDEV pProxyDev)
+{
+    PUSBPROXYDEVSOL pDevSol = (PUSBPROXYDEVSOL)pProxyDev->Backend.pv;
+    size_t cbIgnored;
+
+    LogFlowFunc(("pProxyDev=%p\n", pProxyDev));
+
+    return RTPipeWrite(pDevSol->hPipeWakeupW, "", 1, &cbIgnored);
+}
+
 
 /**
@@ -871 +922 @@
     usbProxySolarisUrbCancel,
     usbProxySolarisUrbReap,
+    usbProxySolarisWakeup,
     0
 };

trunk/src/VBox/Devices/USB/vrdp/USBProxyDevice-vrdp.cpp

@@ -260 +260 @@
 
     pDevVrdp->pCallback->pfnCancelURB (pDevVrdp->pDevice, (PREMOTEUSBQURB)pUrb->Dev.pvPrivate);
+}
+
+static int usbProxyVrdpWakeup(PUSBPROXYDEV pProxyDev)
+{
+    LogFlow(("usbProxyVrdpWakeup: pProxyDev=%s\n", pProxyDev->pUsbIns->pszName));
+
+    PUSBPROXYDEVVRDP pDevVrdp = (PUSBPROXYDEVVRDP)pProxyDev->Backend.pv;
+
+    return pDevVrdp->pCallback->pfnWakeup (pDevVrdp->pDevice);
 }
 
@@ -280 +289 @@
     usbProxyVrdpUrbCancel,
     usbProxyVrdpUrbReap,
+    usbProxyVrdpWakeup,
     0
 };

trunk/src/VBox/Devices/USB/win/USBProxyDevice-win.cpp

@@ -69 +69 @@
     /** Array of handles, this is parallel to paQueuedUrbs. */
     PHANDLE         paHandles;
-    /** The number of pending URBs. */
+    /* Event sempahore to wakeup the reaper thead. */
+    HANDLE          hEventWakeup;
+    /** Number of queued URBs waiting to get into the handle list. */
     unsigned        cPendingUrbs;
-    /** Array of pointers to the pending URB structures. */
+    /** Array of pending URBs. */
     PQUEUED_URB     aPendingUrbs[64];
-    /* Thread handle for async io handling. */
-    RTTHREAD        hThreadAsyncIo;
-    /* Event semaphore for signalling the arrival of a new URB */
-    HANDLE          hEventAsyncIo;
-    /* Event semaphore for signalling thread termination */
-    HANDLE          hEventAsyncTerm;
-    /* Set when the async io thread is started. */
-    bool            fThreadAsyncIoActive;
 } PRIV_USBW32, *PPRIV_USBW32;
 
@@ -156 +150 @@
                             rc = RTCritSectInit(&pPriv->CritSect);
                             AssertRC(rc);
-                            pPriv->hEventAsyncIo    = CreateEvent(NULL, FALSE, FALSE, NULL);
-                            Assert(pPriv->hEventAsyncIo);
-                            pPriv->hEventAsyncTerm  = CreateEvent(NULL, FALSE, FALSE, NULL);
-                            Assert(pPriv->hEventAsyncTerm);
-                            rc = RTThreadCreate(&pPriv->hThreadAsyncIo, usbProxyWinAsyncIoThread, pPriv, 128 * _1K, RTTHREADTYPE_IO, 0, "USBAsyncIo");
-                            Assert(pPriv->hThreadAsyncIo);
+                            pPriv->hEventWakeup     = CreateEvent(NULL, FALSE, FALSE, NULL);
+                            Assert(pPriv->hEventWakeup);
+
+                            pPriv->paHandles[0] = pPriv->hEventWakeup;
 
                             return VINF_SUCCESS;
@@ -236 +228 @@
     }
 
-    /* Terminate async thread (which will clean up hEventAsyncTerm) */
-    SetEvent(pPriv->hEventAsyncTerm);
-    CloseHandle(pPriv->hEventAsyncIo);
+    CloseHandle(pPriv->hEventWakeup);
     RTCritSectDelete(&pPriv->CritSect);
 
@@ -498 +488 @@
 
     pQUrbWin->overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
-    if (    pQUrbWin->overlapped.hEvent != INVALID_HANDLE_VALUE
-        &&  pPriv->cPendingUrbs < RT_ELEMENTS(pPriv->aPendingUrbs))
-    {
-        while (!pPriv->fThreadAsyncIoActive)
-            RTThreadSleep(1);
-
-        RTCritSectEnter(&pPriv->CritSect);
-        do
-        {
-            /* Ensure we've got sufficient space in the arrays.
-             * Do it inside the lock to ensure we do not concur
-             * with the usbProxyWinAsyncIoThread */
-            if (pPriv->cQueuedUrbs + 1 > pPriv->cAllocatedUrbs)
-            {
-                unsigned cNewMax = pPriv->cAllocatedUrbs + 32;
-                void *pv = RTMemRealloc(pPriv->paHandles, sizeof(pPriv->paHandles[0]) * cNewMax);
-                if (!pv)
-                {
-                    AssertMsgFailed(("RTMemRealloc failed for paHandles[%d]", cNewMax));
-                    break;
-                }
-                pPriv->paHandles = (PHANDLE)pv;
-
-                pv = RTMemRealloc(pPriv->paQueuedUrbs, sizeof(pPriv->paQueuedUrbs[0]) * cNewMax);
-                if (!pv)
-                {
-                    AssertMsgFailed(("RTMemRealloc failed for paQueuedUrbs[%d]", cNewMax));
-                    break;
-                }
-                pPriv->paQueuedUrbs = (PQUEUED_URB *)pv;
-                pPriv->cAllocatedUrbs = cNewMax;
-            }
-
-            pUrb->Dev.pvPrivate = pQUrbWin;
-            pPriv->aPendingUrbs[pPriv->cPendingUrbs] = pQUrbWin;
+    if (pQUrbWin->overlapped.hEvent != INVALID_HANDLE_VALUE)
+    {
+        pUrb->Dev.pvPrivate = pQUrbWin;
+
+        if (   DeviceIoControl(pPriv->hDev, SUPUSB_IOCTL_SEND_URB,
+                               &pQUrbWin->urbwin, sizeof(pQUrbWin->urbwin),
+                               &pQUrbWin->urbwin, sizeof(pQUrbWin->urbwin),
+                               &pQUrbWin->cbReturned, &pQUrbWin->overlapped)
+            || GetLastError() == ERROR_IO_PENDING)
+        {
+            /* insert into the queue */
+            RTCritSectEnter(&pPriv->CritSect);
+            unsigned j = pPriv->cPendingUrbs;
+            pPriv->aPendingUrbs[j] = pQUrbWin;
             pPriv->cPendingUrbs++;
             RTCritSectLeave(&pPriv->CritSect);
-            SetEvent(pPriv->hEventAsyncIo);
+            SetEvent(pPriv->hEventWakeup);
             return true;
-        } while (0);
-
-        RTCritSectLeave(&pPriv->CritSect);
+        }
+        else
+        {
+            DWORD dwErr = GetLastError();
+            if (   dwErr == ERROR_INVALID_HANDLE_STATE
+                || dwErr == ERROR_BAD_COMMAND)
+            {
+                PUSBPROXYDEV pProxyDev = PDMINS_2_DATA(pQUrbWin->urb->pUsbIns, PUSBPROXYDEV);
+                Log(("usbproxy: device %p unplugged!!\n", pPriv->hDev));
+                pProxyDev->fDetached = true;
+            }
+            else
+                AssertMsgFailed(("dwErr=%X urbwin.error=%d (submit urb)\n", dwErr, pQUrbWin->urbwin.error));
+            CloseHandle(pQUrbWin->overlapped.hEvent);
+            pQUrbWin->overlapped.hEvent = INVALID_HANDLE_VALUE;
+        }
     }
 #ifdef DEBUG_misha
     else
     {
-        AssertMsgFailed(("FAILED!!, hEvent(0x%p), cPendingUrbs(%d)\n", pQUrbWin->overlapped.hEvent, pPriv->cPendingUrbs));
+        AssertMsgFailed(("FAILED!!, hEvent(0x%p)\n", pQUrbWin->overlapped.hEvent));
     }
 #endif
@@ -598 +580 @@
      * WaitForMultipleObjects will fail.
      */
-    if (pPriv->cQueuedUrbs <= 0)
-    {
-        if (cMillies != 0)
-        {
-            /* Wait for the URBs to be queued if there are some pending */
-            while (pPriv->cPendingUrbs)
-                RTThreadSleep(1);
-            if (pPriv->cQueuedUrbs <= 0)
-                return NULL;
-        }
-        else
-            return NULL;
+    if (   pPriv->cQueuedUrbs <= 0
+        && pPriv->cPendingUrbs == 0)
+    {
+        if (   cMillies != 0
+            && pPriv->cPendingUrbs == 0)
+        {
+            /* Wait for the wakeup call. */
+            DWORD cMilliesWait = cMillies == RT_INDEFINITE_WAIT ? INFINITE : cMillies;
+            DWORD rc = WaitForMultipleObjects(1, &pPriv->hEventWakeup, FALSE, cMilliesWait);
+        }
+
+        return NULL;
+    }
+
+again:
+    /* Check for pending URBs. */
+    if (pPriv->cPendingUrbs)
+    {
+        RTCritSectEnter(&pPriv->CritSect);
+
+        /* Ensure we've got sufficient space in the arrays.
+         * Do it inside the lock to ensure we do not concur
+         * with the usbProxyWinAsyncIoThread */
+        if (pPriv->cQueuedUrbs + pPriv->cPendingUrbs + 1 > pPriv->cAllocatedUrbs)
+        {
+            unsigned cNewMax = pPriv->cAllocatedUrbs + pPriv->cPendingUrbs + 1;
+            void *pv = RTMemRealloc(pPriv->paHandles, sizeof(pPriv->paHandles[0]) * (cNewMax + 1)); /* One extra for the wakeup event. */
+            if (!pv)
+            {
+                AssertMsgFailed(("RTMemRealloc failed for paHandles[%d]", cNewMax));
+                //break;
+            }
+            pPriv->paHandles = (PHANDLE)pv;
+
+            pv = RTMemRealloc(pPriv->paQueuedUrbs, sizeof(pPriv->paQueuedUrbs[0]) * cNewMax);
+            if (!pv)
+            {
+                AssertMsgFailed(("RTMemRealloc failed for paQueuedUrbs[%d]", cNewMax));
+                //break;
+            }
+            pPriv->paQueuedUrbs = (PQUEUED_URB *)pv;
+            pPriv->cAllocatedUrbs = cNewMax;
+        }
+
+        /* Copy the pending URBs over. */
+        for (unsigned i = 0; i < pPriv->cPendingUrbs; i++)
+        {
+            pPriv->paHandles[pPriv->cQueuedUrbs + i] = pPriv->aPendingUrbs[i]->overlapped.hEvent;
+            pPriv->paQueuedUrbs[pPriv->cQueuedUrbs + i] = pPriv->aPendingUrbs[i];
+        }
+        pPriv->cQueuedUrbs += pPriv->cPendingUrbs;
+        pPriv->cPendingUrbs = 0;
+        pPriv->paHandles[pPriv->cQueuedUrbs] = pPriv->hEventWakeup;
+        pPriv->paHandles[pPriv->cQueuedUrbs + 1] = INVALID_HANDLE_VALUE;
+
+        RTCritSectLeave(&pPriv->CritSect);
     }
 
@@ -623 +649 @@
      */
     unsigned cQueuedUrbs = ASMAtomicReadU32((volatile uint32_t *)&pPriv->cQueuedUrbs);
+    DWORD cMilliesWait = cMillies == RT_INDEFINITE_WAIT ? INFINITE : cMillies;
     PVUSBURB pUrb = NULL;
-    DWORD rc = WaitForMultipleObjects(cQueuedUrbs, pPriv->paHandles, FALSE, cMillies);
+    DWORD rc = WaitForMultipleObjects(cQueuedUrbs + 1, pPriv->paHandles, FALSE, cMilliesWait);
+
+    /* If the wakeup event fired return immediately. */
+    if (rc == WAIT_OBJECT_0 + cQueuedUrbs)
+    {
+        if (pPriv->cPendingUrbs)
+            goto again;
+        return NULL;
+    }
+
     if (rc >= WAIT_OBJECT_0 && rc < WAIT_OBJECT_0 + cQueuedUrbs)
     {
@@ -645 +681 @@
             }
         }
-        pPriv->paHandles[cQueuedUrbs] = INVALID_HANDLE_VALUE;
+        pPriv->paHandles[cQueuedUrbs] = pPriv->hEventWakeup;
+        pPriv->paHandles[cQueuedUrbs + 1] = INVALID_HANDLE_VALUE;
         pPriv->paQueuedUrbs[cQueuedUrbs] = NULL;
         RTCritSectLeave(&pPriv->CritSect);
@@ -684 +721 @@
 }
 
-/* Thread to handle async URB queueing. */
-static DECLCALLBACK(int) usbProxyWinAsyncIoThread(RTTHREAD ThreadSelf, void *lpParameter)
-{
-    PPRIV_USBW32    pPriv = (PPRIV_USBW32)lpParameter;
-    HANDLE          hEventWait[2];
-
-    hEventWait[0] = pPriv->hEventAsyncIo;
-    hEventWait[1] = pPriv->hEventAsyncTerm;
-
-    Log(("usbProxyWinAsyncIoThread: start\n"));
-    pPriv->fThreadAsyncIoActive = true;
-
-    while (true)
-    {
-        DWORD ret = WaitForMultipleObjects(2, hEventWait, FALSE /* wait for any */, INFINITE);
-
-        if (ret == WAIT_OBJECT_0)
-        {
-            /*
-             * Submit pending URBs.
-             */
-            RTCritSectEnter(&pPriv->CritSect);
-
-            for (unsigned i = 0; i < pPriv->cPendingUrbs; i++)
-            {
-                PQUEUED_URB pQUrbWin = pPriv->aPendingUrbs[i];
-
-                Assert(pQUrbWin);
-                if (pQUrbWin)
-                {
-                    if (   DeviceIoControl(pPriv->hDev, SUPUSB_IOCTL_SEND_URB,
-                                           &pQUrbWin->urbwin, sizeof(pQUrbWin->urbwin),
-                                           &pQUrbWin->urbwin, sizeof(pQUrbWin->urbwin),
-                                           &pQUrbWin->cbReturned, &pQUrbWin->overlapped)
-                        || GetLastError() == ERROR_IO_PENDING)
-                    {
-                        /* insert into the queue */
-                        unsigned j = pPriv->cQueuedUrbs;
-                        pPriv->paQueuedUrbs[j] = pQUrbWin;
-                        pPriv->paHandles[j] = pQUrbWin->overlapped.hEvent;
-                        /* do an atomic increment to allow usbProxyWinUrbReap thread get it outside a lock,
-                         * being sure that pPriv->paHandles contains cQueuedUrbs valid handles */
-                        ASMAtomicIncU32((uint32_t volatile *)&pPriv->cQueuedUrbs);
-                    }
-                    else
-                    {
-                        DWORD dwErr = GetLastError();
-                        if (   dwErr == ERROR_INVALID_HANDLE_STATE
-                            || dwErr == ERROR_BAD_COMMAND)
-                        {
-                            PUSBPROXYDEV pProxyDev = PDMINS_2_DATA(pQUrbWin->urb->pUsbIns, PUSBPROXYDEV);
-                            Log(("usbproxy: device %p unplugged!!\n", pPriv->hDev));
-                            pProxyDev->fDetached = true;
-                        }
-                        else
-                            AssertMsgFailed(("dwErr=%X urbwin.error=%d (submit urb)\n", dwErr, pQUrbWin->urbwin.error));
-                        CloseHandle(pQUrbWin->overlapped.hEvent);
-                        pQUrbWin->overlapped.hEvent = INVALID_HANDLE_VALUE;
-                    }
-                }
-                pPriv->aPendingUrbs[i] = 0;
-            }
-            pPriv->cPendingUrbs = 0;
-            RTCritSectLeave(&pPriv->CritSect);
-        }
-        else
-        if (ret == WAIT_OBJECT_0 + 1)
-        {
-            Log(("usbProxyWinAsyncIoThread: terminating\n"));
-            CloseHandle(hEventWait[1]);
-            break;
-        }
-        else
-        {
-            Log(("usbProxyWinAsyncIoThread: unexpected return code %x\n", ret));
-            break;
-        }
-    }
-    return 0;
-}
 
 /**
@@ -803 +760 @@
 }
 
+static int usbProxyWinWakeup(PUSBPROXYDEV pProxyDev)
+{
+    PPRIV_USBW32 pPriv = (PPRIV_USBW32)pProxyDev->Backend.pv;
+
+    SetEvent(pPriv->hEventWakeup);
+    return VINF_SUCCESS;
+}
 
 /**
@@ -822 +786 @@
     usbProxyWinUrbCancel,
     usbProxyWinUrbReap,
+    usbProxyWinWakeup,
     0
 };