Changeset 59091 in vbox for trunk/src/VBox

Timestamp:

Dec 11, 2015 2:29:16 PM (9 years ago)

Author:

vboxsync

Message:

USB/Solaris: Rewrite, cleanup and numerous bug fixes to get the Apple iPhone working.

Location:

trunk/src/VBox

Files:

• Devices/USB/solaris/USBProxyDevice-solaris.cpp (modified) (34 diffs)
• HostDrivers/VBoxUSB/solaris/USBLib-solaris.cpp (modified) (2 diffs)
• HostDrivers/VBoxUSB/solaris/VBoxUSB-solaris.c (modified) (239 diffs)
• HostDrivers/VBoxUSB/solaris/VBoxUSBMon-solaris.c (modified) (56 diffs)
• HostDrivers/VBoxUSB/solaris/include/usbai_private.h (modified) (5 diffs)
• Main/src-server/solaris/USBProxyServiceSolaris.cpp (modified) (1 diff)

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

@@ -212 +212 @@
     if (RT_UNLIKELY(pDevSol->hFile == NIL_RTFILE))
     {
-        LogFlow((USBPROXY ":usbProxySolarisIOCtl connection to driver gone!\n"));
+        LogFlow((USBPROXY ":usbProxySolarisIOCtl: Connection to driver gone!\n"));
         return VERR_VUSB_DEVICE_NOT_ATTACHED;
     }
@@ -232 +232 @@
                 pDevSol->pProxyDev->fDetached = true;
                 usbProxySolarisCloseFile(pDevSol);
-                LogRel((USBPROXY ":Command %#x failed, USB Device '%s' disconnected!\n", Function, pDevSol->pProxyDev->pUsbIns->pszName));
+                LogRel((USBPROXY ": Command %#x failed, USB Device '%s' disconnected!\n", Function,
+                        pDevSol->pProxyDev->pUsbIns->pszName));
             }
             else
-                LogRel((USBPROXY ":Command %#x failed. Req.rc=%Rrc\n", Function, Req.rc));
+                LogRel((USBPROXY ": Command %#x failed. Req.rc=%Rrc\n", Function, Req.rc));
         }
 
@@ -241 +242 @@
     }
 
-    LogRel((USBPROXY ":Function %#x failed. rc=%Rrc\n", Function, rc));
+    LogRel((USBPROXY ": Function %#x failed. rc=%Rrc\n", Function, rc));
     return rc;
 }
@@ -268 +269 @@
     {
         if (rc != VERR_VUSB_DEVICE_NOT_ATTACHED)
-            LogRel((USBPROXY ":Failed to get configuration. rc=%Rrc\n", rc));
+            LogRel((USBPROXY ": Failed to get configuration. rc=%Rrc\n", rc));
 
         pDevSol->pProxyDev->iActiveCfg = -1;
@@ -290 +291 @@
     PUSBPROXYDEVSOL pDevSol = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVSOL);
 
-    LogFlowFunc((USBPROXY ":usbProxySolarisOpen pProxyDev=%p pszAddress=%s pvBackend=%p\n", pProxyDev, pszAddress, pvBackend));
+    LogFlowFunc((USBPROXY ":usbProxySolarisOpen: pProxyDev=%p pszAddress=%s pvBackend=%p\n", pProxyDev, pszAddress, pvBackend));
 
     /*
@@ -351 +352 @@
                                 else
                                 {
-                                    LogRel((USBPROXY ":version mismatch! driver v%d.%d expecting ~v%d.%d\n", GetVersionReq.u32Major,
+                                    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;
@@ -357 +358 @@
                             }
                             else
-                                LogRel((USBPROXY ":failed to query driver version. rc=%Rrc\n", rc));
+                                LogRel((USBPROXY ": Failed to query driver version. rc=%Rrc\n", rc));
 
                             RTFileClose(pDevSol->hFile);
@@ -364 +365 @@
                         }
                         else
-                            LogRel((USBPROXY ":failed to open device. rc=%Rrc pszDevicePath=%s\n", rc, pDevSol->pszDevicePath));
+                            LogRel((USBPROXY ": Failed to open device. rc=%Rrc pszDevicePath=%s\n", rc, pDevSol->pszDevicePath));
 
                         RTStrFree(pDevSol->pszDevicePath);
@@ -371 +372 @@
                     else
                     {
-                        LogRel((USBPROXY ":failed to get client info. rc=%Rrc pszDevicePath=%s\n", rc, pDevSol->pszDevicePath));
+                        LogRel((USBPROXY ": Failed to get client info. rc=%Rrc szDeviceIdent=%s\n", rc, szDeviceIdent));
                         if (rc == VERR_NOT_FOUND)
                             rc = VERR_OPEN_FAILED;
@@ -382 +383 @@
             }
             else
-                LogRel((USBPROXY ":RTCritSectInit failed. rc=%Rrc pszAddress=%s\n", rc, pszAddress));
+                LogRel((USBPROXY ": RTCritSectInit failed. rc=%Rrc pszAddress=%s\n", rc, pszAddress));
         }
         else
-            LogRel((USBPROXY ":RTStrAPrintf failed. rc=%Rrc pszAddress=%s\n", rc, pszAddress));
+            LogRel((USBPROXY ": RTStrAPrintf failed. rc=%Rrc pszAddress=%s\n", rc, pszAddress));
     }
     else
-        LogRel((USBPROXY ":USBLibInit failed. rc=%Rrc\n", rc));
+        LogRel((USBPROXY ": USBLibInit failed. rc=%Rrc\n", rc));
 
     USBLibTerm();
@@ -451 +452 @@
 static DECLCALLBACK(int) usbProxySolarisReset(PUSBPROXYDEV pProxyDev, bool fRootHubReset)
 {
-    LogFlowFunc((USBPROXY ":usbProxySolarisReset pProxyDev=%s fRootHubReset=%d\n", pProxyDev->pUsbIns->pszName, fRootHubReset));
+    LogFlowFunc((USBPROXY ": usbProxySolarisReset: pProxyDev=%s fRootHubReset=%d\n", pProxyDev->pUsbIns->pszName, fRootHubReset));
 
     /** Pass all resets to the device. The Trekstor USB (1.1) stick requires this to work. */
@@ -466 +467 @@
     }
     else if (rc != VERR_VUSB_DEVICE_NOT_ATTACHED)
-        LogRel((USBPROXY ":usbProxySolarisReset failed. rc=%d\n", rc));
+        LogRel((USBPROXY ": usbProxySolarisReset: Failed! rc=%d\n", rc));
 
     return rc;
@@ -484 +485 @@
 static DECLCALLBACK(int) usbProxySolarisSetConfig(PUSBPROXYDEV pProxyDev, int iCfg)
 {
-    LogFlowFunc((USBPROXY ":usbProxySolarisSetConfig: pProxyDev=%p iCfg=%#x\n", pProxyDev, iCfg));
+    LogFlowFunc((USBPROXY ": usbProxySolarisSetConfig: pProxyDev=%p iCfg=%#x\n", pProxyDev, iCfg));
 
     PUSBPROXYDEVSOL pDevSol = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVSOL);
@@ -494 +495 @@
     if (   RT_FAILURE(rc)
         && rc != VERR_VUSB_DEVICE_NOT_ATTACHED)
-        LogRel((USBPROXY ":usbProxySolarisSetConfig failed to switch configuration. rc=%Rrc\n", rc));
+        LogRel((USBPROXY ": usbProxySolarisSetConfig: Failed! rc=%Rrc\n", rc));
 
     return rc;
@@ -533 +534 @@
  * @returns success indicator.
  */
-static DECLCALLBACK(int) usbProxySolarisSetInterface(PUSBPROXYDEV pProxyDev, int iIf, int iAlt)
-{
-    LogFlowFunc((USBPROXY ":usbProxySolarisSetInterface: pProxyDev=%p iIf=%d iAlt=%d\n", pProxyDev, iIf, iAlt));
+static DECLCALLBACK(int) usbProxySolarisSetInterface(PUSBPROXYDEV pProxyDev, int bIf, int bAlt)
+{
+    LogFlowFunc((USBPROXY ": usbProxySolarisSetInterface: pProxyDev=%p bIf=%#x iAlt=%#x\n", pProxyDev, bIf, bAlt));
 
     PUSBPROXYDEVSOL pDevSol = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVSOL);
@@ -541 +542 @@
 
     VBOXUSBREQ_SET_INTERFACE SetInterfaceReq;
-    SetInterfaceReq.bInterface = iIf;
-    SetInterfaceReq.bAlternate = iAlt;
+    SetInterfaceReq.bInterface = bIf;
+    SetInterfaceReq.bAlternate = bAlt;
     int rc = usbProxySolarisIOCtl(pDevSol, VBOXUSB_IOCTL_SET_INTERFACE, &SetInterfaceReq, sizeof(SetInterfaceReq));
     if (   RT_FAILURE(rc)
         && rc != VERR_VUSB_DEVICE_NOT_ATTACHED)
-        LogRel((USBPROXY ":usbProxySolarisSetInterface failed to set interface. rc=%Rrc\n", rc));
+        LogRel((USBPROXY ": usbProxySolarisSetInterface: Failed! rc=%Rrc\n", rc));
 
     return rc;
@@ -557 +558 @@
 static DECLCALLBACK(int) usbProxySolarisClearHaltedEp(PUSBPROXYDEV pProxyDev, unsigned int EndPt)
 {
-    LogFlowFunc((USBPROXY ":usbProxySolarisClearHaltedEp pProxyDev=%p EndPt=%#x\n", pProxyDev, EndPt));
+    LogFlowFunc((USBPROXY ": usbProxySolarisClearHaltedEp: pProxyDev=%p EndPt=%#x\n", pProxyDev, EndPt));
 
     PUSBPROXYDEVSOL pDevSol = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVSOL);
@@ -567 +568 @@
     if (   RT_FAILURE(rc)
         && rc != VERR_VUSB_DEVICE_NOT_ATTACHED)
-        LogRel((USBPROXY ":usbProxySolarisClearHaltedEp failed! rc=%Rrc\n", rc));
+        LogRel((USBPROXY ": usbProxySolarisClearHaltedEp: Failed! rc=%Rrc\n", rc));
 
     return rc;
@@ -580 +581 @@
     PUSBPROXYDEVSOL pDevSol = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVSOL);
 
-    LogFlowFunc((USBPROXY ": usbProxySolarisUrbQueue: pProxyDev=%s pUrb=%p EndPt=%#x enmDir=%d cbData=%d pvData=%p\n",
-             pProxyDev->pUsbIns->pszName, pUrb, pUrb->EndPt, pUrb->enmDir, pUrb->cbData, pUrb->abData));
+    LogFlowFunc((USBPROXY ": usbProxySolarisUrbQueue: pProxyDev=%s pUrb=%p pszDesc=%s EndPt=%#x enmDir=%d cbData=%d pvData=%p\n",
+             pProxyDev->pUsbIns->pszName, pUrb, pUrb->pszDesc, pUrb->EndPt, pUrb->enmDir, pUrb->cbData, pUrb->abData));
 
     PUSBPROXYURBSOL pUrbSol = usbProxySolarisUrbAlloc(pDevSol);
     if (RT_UNLIKELY(!pUrbSol))
     {
-        LogRel((USBPROXY ":usbProxySolarisUrbQueue: Failed to allocate URB.\n"));
+        LogRel((USBPROXY ": usbProxySolarisUrbQueue: Failed to allocate URB\n"));
         return VERR_NO_MEMORY;
     }
@@ -605 +606 @@
     UrbReq.fShortOk     = !pUrb->fShortNotOk;
     UrbReq.cbData       = pUrb->cbData;
-    UrbReq.pvData       = pUrb->abData;
+    UrbReq.pvData       = &pUrb->abData[0];
+
+    Log6((USBPROXY ": Sending: EndPt=%#x Dir=%d cbData=%u\n", pUrb->EndPt, pUrb->enmDir, pUrb->cbData));
+
     if (pUrb->enmType == VUSBXFERTYPE_ISOC)
     {
@@ -621 +625 @@
     {
         if (pUrb->enmType == VUSBXFERTYPE_ISOC)
-            LogFlow((USBPROXY ":usbProxySolarisUrbQueue success cbData=%d.\n", pUrb->cbData));
+            LogFlow((USBPROXY ":usbProxySolarisUrbQueue: Success cbData=%d\n", pUrb->cbData));
         pUrb->Dev.pvPrivate = pUrbSol;
         return VINF_SUCCESS;
@@ -627 +631 @@
 
     if (rc != VERR_VUSB_DEVICE_NOT_ATTACHED)
-        LogRel((USBPROXY ":usbProxySolarisUrbQueue Failed!! pProxyDev=%s pUrb=%p EndPt=%#x bEndpoint=%#x enmType=%d enmDir=%d cbData=%u rc=%Rrc\n",
-             pProxyDev->pUsbIns->pszName, pUrb, pUrb->EndPt, UrbReq.bEndpoint, pUrb->enmType, pUrb->enmDir, pUrb->cbData, rc));
+    {
+        LogRel((USBPROXY ": usbProxySolarisUrbQueue: Failed! pProxyDev=%s pUrb=%p EndPt=%#x bEndpoint=%#x enmType=%d "
+                "enmDir=%d cbData=%u rc=%Rrc\n", pProxyDev->pUsbIns->pszName, pUrb, pUrb->EndPt,
+                UrbReq.bEndpoint, pUrb->enmType, pUrb->enmDir, pUrb->cbData, rc));
+    }
 
     return rc;
@@ -647 +654 @@
     AssertPtrReturn(pDevSol, VERR_INVALID_POINTER);
 
-    LogFlowFunc((USBPROXY ":usbProxySolarisUrbCancel pUrb=%p pUrbSol=%p pDevSol=%p\n", pUrb, pUrbSol, pUrbSol->pDevSol));
+    LogFlowFunc((USBPROXY ": usbProxySolarisUrbCancel: pUrb=%p pUrbSol=%p pDevSol=%p\n", pUrb, pUrbSol, pUrbSol->pDevSol));
 
     /* Aborting the control pipe isn't supported, pretend success. */
@@ -658 +665 @@
     if (   RT_FAILURE(rc)
         && rc != VERR_VUSB_DEVICE_NOT_ATTACHED)
-        LogRel((USBPROXY ":usbProxySolarisUrbCancel failed to abort pipe. rc=%Rrc\n", rc));
-
-    LogFlow((USBPROXY ":usbProxySolarisUrbCancel: rc=%Rrc.\n", rc));
+        LogRel((USBPROXY ": usbProxySolarisUrbCancel: Failed to abort pipe. rc=%Rrc\n", rc));
+
+    LogFlow((USBPROXY ": usbProxySolarisUrbCancel: returns rc=%Rrc\n", rc));
     return rc;
 }
@@ -675 +682 @@
 static DECLCALLBACK(PVUSBURB) usbProxySolarisUrbReap(PUSBPROXYDEV pProxyDev, RTMSINTERVAL cMillies)
 {
-    //LogFlowFunc((USBPROXY ":usbProxySolarisUrbReap pProxyDev=%p cMillies=%u\n", pProxyDev, cMillies));
+    LogFlowFunc((USBPROXY ":usbProxySolarisUrbReap pProxyDev=%p cMillies=%u\n", pProxyDev, cMillies));
 
     PUSBPROXYDEVSOL pDevSol = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVSOL);
@@ -693 +700 @@
         {
             int cMilliesWait = cMillies == RT_INDEFINITE_WAIT ? -1 : (int)cMillies;
-            struct pollfd pfd[2];
-
-            pfd[0].fd = RTFileToNative(pDevSol->hFile);
-            pfd[0].events = POLLIN;
-            pfd[0].revents = 0;
-
-            pfd[1].fd = RTPipeToNative(pDevSol->hPipeWakeupR);
-            pfd[1].events = POLLIN;
-            pfd[1].revents = 0;
-
-            int rc = poll(&pfd[0], 2, cMilliesWait);
+
+            struct pollfd aFd[2];
+            size_t const  cFds = RT_ELEMENTS(aFd);
+
+            aFd[0].fd      = RTFileToNative(pDevSol->hFile);
+            aFd[0].events  = POLLIN;
+            aFd[0].revents = 0;
+
+            aFd[1].fd      = RTPipeToNative(pDevSol->hPipeWakeupR);
+            aFd[1].events  = POLLIN;
+            aFd[1].revents = 0;
+
+            int rc = poll(&aFd[0], cFds, cMilliesWait);
             if (rc > 0)
             {
-                if (pfd[0].revents & POLLHUP)
+                if (aFd[0].revents & POLLHUP)
                 {
-                    LogRel((USBPROXY ":Reaping failed, USB Device '%s' disconnected!\n", pDevSol->pProxyDev->pUsbIns->pszName));
+                    LogRel((USBPROXY ": USB Device '%s' disconnected!\n", pDevSol->pProxyDev->pUsbIns->pszName));
                     pProxyDev->fDetached = true;
                     usbProxySolarisCloseFile(pDevSol);
                 }
 
-                if (pfd[1].revents & POLLIN)
+                if (aFd[1].revents & POLLIN)
                 {
                     /* Got woken up, drain pipe. */
@@ -725 +734 @@
                      * immediately to the caller.
                      */
-                    if (!(pfd[0].revents & POLLIN))
+                    if (!(aFd[0].revents & POLLIN))
                         return NULL;
                 }
-
                 break;
             }
-
-            if (rc == 0)
-            {
-                //LogFlow((USBPROXY ":usbProxySolarisUrbReap: Timed out\n"));
+            else if (rc == 0)
                 return NULL;
-            }
-            else if (rc != EAGAIN)
+            else if (errno != EAGAIN)
             {
                 LogFlow((USBPROXY ":usbProxySolarisUrbReap Poll rc=%d errno=%d\n", rc, errno));
@@ -751 +755 @@
      */
     PVUSBURB pUrb = NULL;
-    while (pDevSol->pTaxingHead)
+    while (    pDevSol->pTaxingHead
+           && !pUrb)
     {
         RTCritSectEnter(&pDevSol->CritSect);
@@ -761 +766 @@
             if (pUrb)
             {
+                /*
+                 * Remove it from the taxing list and move it to the free list.
+                 */
                 pUrb->Dev.pvPrivate = NULL;
                 usbProxySolarisUrbFree(pDevSol, pUrbSol);
@@ -779 +787 @@
 static PVUSBURB usbProxySolarisUrbComplete(PUSBPROXYDEVSOL pDevSol)
 {
-    LogFlowFunc((USBPROXY ":usbProxySolarisUrbComplete pDevSol=%p\n", pDevSol));
+    LogFlowFunc((USBPROXY ": usbProxySolarisUrbComplete: pDevSol=%p\n", pDevSol));
 
     VBOXUSBREQ_URB UrbReq;
@@ -809 +817 @@
                     }
 
-                    LogFlow((USBPROXY ":usbProxySolarisUrbComplete ISOC cbData=%d cbActPktSum=%d\n", pUrb->cbData, cbData));
+                    LogFlow((USBPROXY ":usbProxySolarisUrbComplete: Isoc cbData=%d cbActPktSum=%d\n", pUrb->cbData, cbData));
                     pUrb->cbData = cbData;
                     pUrb->enmStatus = UrbReq.enmStatus;
@@ -835 +843 @@
 
                 /*
-                 * Link it into the taxing list.
+                 * Add to the tail of the taxing list.
                  */
                 pUrbSol->pNext = NULL;
@@ -847 +855 @@
                 RTCritSectLeave(&pDevSol->CritSect);
 
-                LogFlow((USBPROXY "usbProxySolarisUrbComplete: cb=%d EndPt=%#x enmDir=%d enmStatus=%s (%d) \n",
-                         pUrb->cbData, pUrb->EndPt, pUrb->enmDir, pUrb->enmStatus == VUSBSTATUS_OK ? "OK" : "** Failed **", pUrb->enmStatus));
-//                if (pUrb->cbData < 2049)
-//                    LogFlow((USBPROXY "%.*Rhxd\n", pUrb->cbData, pUrb->abData));
+                Log6((USBPROXY ": Reaping: EndPt=%#x Dir=%d cbData=%u\n", pUrb->EndPt, pUrb->enmDir, pUrb->cbData));
+                if (pUrb->cbData < 1024)
+                    Log6(("%.*Rhxd\n", pUrb->cbData, pUrb->abData));
                 return pUrb;
             }
@@ -858 +865 @@
     {
         if (rc != VERR_VUSB_DEVICE_NOT_ATTACHED)
-            LogRel((USBPROXY ":Reaping URB failed. rc=%Rrc\n", rc));
+            LogRel((USBPROXY ": Reaping URB failed. rc=%Rrc\n", rc));
     }
 

trunk/src/VBox/HostDrivers/VBoxUSB/solaris/USBLib-solaris.cpp

@@ -210 +210 @@
     LogFlow((USBLIBR3 ":USBLibResetDevice pszDevicePath=%s\n", pszDevicePath));
 
-    size_t cbReq = sizeof(VBOXUSBREQ_RESET_DEVICE) + strlen(pszDevicePath);
+    size_t cbPath = strlen(pszDevicePath) + 1;
+    size_t cbReq  = sizeof(VBOXUSBREQ_RESET_DEVICE) + cbPath;
     VBOXUSBREQ_RESET_DEVICE *pReq = (VBOXUSBREQ_RESET_DEVICE *)RTMemTmpAllocZ(cbReq);
     if (RT_UNLIKELY(!pReq))
@@ -216 +217 @@
 
     pReq->fReattach = fReattach;
-    strcpy(pReq->szDevicePath, pszDevicePath);
+    if (strlcpy(pReq->szDevicePath, pszDevicePath, cbPath) >= cbPath)
+    {
+        LogRel((USBLIBR3 ":USBLibResetDevice buffer overflow. cbPath=%u pszDevicePath=%s\n", cbPath, pszDevicePath));
+        return VERR_BUFFER_OVERFLOW;
+    }
 
     int rc = usblibDoIOCtl(VBOXUSBMON_IOCTL_RESET_DEVICE, pReq, cbReq);

trunk/src/VBox/HostDrivers/VBoxUSB/solaris/VBoxUSB-solaris.c

@@ -45 +45 @@
 #include <iprt/path.h>
 #include <iprt/thread.h>
+#include <iprt/dbg.h>
 
 #define USBDRV_MAJOR_VER    2
@@ -51 +52 @@
 #include <sys/strsun.h>
 #include "usbai_private.h"
-#include <sys/archsystm.h>
-#include <sys/disp.h>
-
-/** @todo review the locking here, verify assumptions about code executed
- *        without the vboxusb_state_t::Mtx mutex */
 
 
@@ -66 +62 @@
 #define DEVICE_DESC_DRV                                 "VirtualBox USB"
 
-/** Endpoint states */
+/** Endpoint states. */
 #define VBOXUSB_EP_INITIALIZED                          0xa1fa1fa
 #define VBOXUSB_EP_STATE_NONE                           RT_BIT(0)
 #define VBOXUSB_EP_STATE_CLOSED                         RT_BIT(1)
 #define VBOXUSB_EP_STATE_OPENED                         RT_BIT(2)
-/** Polling states */
-#define VBOXUSB_POLL_OFF                                RT_BIT(0)
-#define VBOXUSB_POLL_ON                                 RT_BIT(1)
-#define VBOXUSB_POLL_REAP_PENDING                       RT_BIT(2)
-#define VBOXUSB_POLL_DEV_UNPLUGGED                      RT_BIT(3)
 
 /** -=-=-=-=-=-=- Standard Specifics -=-=-=-=-=-=- */
-/** Max. supported endpoints */
+/** Max. supported endpoints. */
 #define VBOXUSB_MAX_ENDPOINTS                           32
-/** Size of USB Ctrl Xfer Header */
-#define VBOXUSB_CTRL_XFER_SIZE                          0x08
+/** Size of USB Ctrl Xfer Header in bytes. */
+#define VBOXUSB_CTRL_XFER_SIZE                          8
 /**
  * USB2.0 (Sec. 9-13) Bits 10..0 is the max packet size; for high speed Isoc/Intr, bits 12..11 is
@@ -87 +78 @@
  */
 #define VBOXUSB_PKT_SIZE(pkt)                          (pkt & 0x07FF) * (1 + ((pkt >> 11) & 3))
-/** Endpoint Xfer Type */
+/** Endpoint Xfer Type. */
 #define VBOXUSB_XFER_TYPE(endp)                        ((endp)->EpDesc.bmAttributes & USB_EP_ATTR_MASK)
-/** Endpoint Xfer Direction */
+/** Endpoint Xfer Direction. */
 #define VBOXUSB_XFER_DIR(endp)                         ((endp)->EpDesc.bEndpointAddress & USB_EP_DIR_IN)
+/** Create an Endpoint index from an Endpoint address. */
+#define VBOXUSB_GET_EP_INDEX(epaddr)                   (((epaddr) & USB_EP_NUM_MASK) + \
+                                                       (((epaddr) & USB_EP_DIR_MASK) ? 16 : 0))
+
 
 /** -=-=-=-=-=-=- Tunable Parameters -=-=-=-=-=-=- */
@@ -96 +91 @@
 #define VBOXUSB_DRAIN_TIME                              20
 /** Ctrl Xfer timeout in seconds. */
-#define VBOXUSB_CTRL_XFER_TIMEOUT                       10
-/** Bulk Xfer timeout in seconds. */
-#define VBOXUSB_BULK_XFER_TIMEOUT                       10
-/** Intr Xfer timeout in seconds. */
-#define VBOXUSB_INTR_XFER_TIMEOUT                       10
+#define VBOXUSB_CTRL_XFER_TIMEOUT                       15
 /** Maximum URB queue length. */
-#define VBOXUSB_URB_QUEUE_SIZE                          64
-/** Maximum asynchronous requests per pipe */
+#define VBOXUSB_URB_QUEUE_SIZE                         512
+/** Maximum asynchronous requests per pipe. */
 #define VBOXUSB_MAX_PIPE_ASYNC_REQS                     2
 
-/** For enabling global symbols while debugging  **/
+/** For enabling global symbols while debugging. **/
 #if defined(DEBUG_ramshankar)
 # define LOCAL
@@ -201 +192 @@
 typedef struct vboxusb_ep_t
 {
-    uint_t                  fInitialized;    /* Whether this Endpoint is initialized */
-    uint_t                  EpState;         /* Endpoint state */
-    usb_ep_descr_t          EpDesc;          /* Endpoint descriptor */
-    uchar_t                 uCfgValue;       /* Configuration value */
-    uchar_t                 uInterface;      /* Interface number */
-    uchar_t                 uAlt;            /* Alternate number */
-    usb_pipe_handle_t       pPipe;           /* Endpoint pipe handle */
-    usb_pipe_policy_t       PipePolicy;      /* Endpoint policy */
-    bool                    fIsocPolling;    /* Whether Isoc. IN polling is enabled */
-    list_t                  hIsocInUrbs;     /* Isoc. IN inflight URBs */
-    uint16_t                cIsocInUrbs;     /* Number of Isoc. IN inflight URBs */
+    bool                    fInitialized;        /* Whether this Endpoint is initialized */
+    uint_t                  EpState;             /* Endpoint state */
+    usb_ep_descr_t          EpDesc;              /* Endpoint descriptor */
+    usb_pipe_handle_t       pPipe;               /* Endpoint pipe handle */
+    usb_pipe_policy_t       PipePolicy;          /* Endpoint policy */
+    bool                    fIsocPolling;        /* Whether Isoc. IN polling is enabled */
+    list_t                  hIsocInUrbs;         /* Isoc. IN inflight URBs */
+    uint16_t                cIsocInUrbs;         /* Number of Isoc. IN inflight URBs */
     list_t                  hIsocInLandedReqs;   /* Isoc. IN landed requests */
     uint16_t                cbIsocInLandedReqs;  /* Cumulative size of landed Isoc. IN requests */
-    size_t                  cbMaxIsocData;   /* Maximum size of Isoc. IN landed buffer */
+    size_t                  cbMaxIsocData;       /* Maximum size of Isoc. IN landed buffer */
 } vboxusb_ep_t;
 
@@ -222 +210 @@
 typedef struct vboxusb_isoc_req_t
 {
-    mblk_t                 *pMsg;            /* Pointer to the data buffer */
-    uint32_t                cIsocPkts;       /* Number of Isoc pkts */
-    VUSBISOC_PKT_DESC       aIsocPkts[8];    /* Array of Isoc pkt descriptors */
+    mblk_t                 *pMsg;                /* Pointer to the data buffer */
+    uint32_t                cIsocPkts;           /* Number of Isoc pkts */
+    VUSBISOC_PKT_DESC       aIsocPkts[8];        /* Array of Isoc pkt descriptors */
     list_node_t             hListLink;
 } vboxusb_isoc_req_t;
@@ -243 +231 @@
 typedef struct vboxusb_urb_t
 {
-    void                   *pvUrbR3;         /* Userspace URB address (untouched, returned while reaping) */
-    uint8_t                 bEndpoint;       /* Endpoint address */
-    VUSBXFERTYPE            enmType;         /* Xfer type */
-    VUSBDIRECTION           enmDir;          /* Xfer direction */
-    VUSBSTATUS              enmStatus;       /* URB status */
-    bool                    fShortOk;        /* Whether receiving less data than requested is acceptable. */
-    RTR3PTR                 pvDataR3;        /* Userspace address of the original data buffer */
-    size_t                  cbDataR3;        /* Size of the data buffer */
-    mblk_t                 *pMsg;            /* Pointer to the data buffer */
-    uint32_t                cIsocPkts;       /* Number of Isoc pkts */
-    VUSBISOC_PKT_DESC       aIsocPkts[8];    /* Array of Isoc pkt descriptors */
-    VBOXUSB_URB_STATE       enmState;        /* Whether free/in-flight etc. */
-    struct vboxusb_state_t *pState;          /* Pointer to the device instance */
-    list_node_t             hListLink;       /* List node link handle */
+    void                   *pvUrbR3;             /* Userspace URB address (untouched, returned while reaping) */
+    uint8_t                 bEndpoint;           /* Endpoint address */
+    VUSBXFERTYPE            enmType;             /* Xfer type */
+    VUSBDIRECTION           enmDir;              /* Xfer direction */
+    VUSBSTATUS              enmStatus;           /* URB status */
+    bool                    fShortOk;            /* Whether receiving less data than requested is acceptable */
+    RTR3PTR                 pvDataR3;            /* Userspace address of the original data buffer */
+    size_t                  cbDataR3;            /* Size of the data buffer */
+    mblk_t                 *pMsg;                /* Pointer to the data buffer */
+    uint32_t                cIsocPkts;           /* Number of Isoc pkts */
+    VUSBISOC_PKT_DESC       aIsocPkts[8];        /* Array of Isoc pkt descriptors */
+    VBOXUSB_URB_STATE       enmState;            /* URB state (free/in-flight/landed). */
+    struct vboxusb_state_t *pState;              /* Pointer to the device instance */
+    list_node_t             hListLink;           /* List node link handle */
 } vboxusb_urb_t;
 
@@ -264 +252 @@
 typedef struct vboxusb_power_t
 {
-    uint_t                  PowerStates;     /* Bit mask of the power states */
-    int                     PowerBusy;       /* Busy counter */
-    bool                    fPowerWakeup;    /* Whether remote power wakeup is enabled */
-    bool                    fPowerRaise;     /* Whether to raise the power level */
-    uint8_t                 PowerLevel;      /* Current power level */
+    uint_t                  PowerStates;         /* Bit mask of the power states */
+    int                     PowerBusy;           /* Busy reference counter */
+    bool                    fPowerWakeup;        /* Whether remote power wakeup is enabled */
+    bool                    fPowerRaise;         /* Whether to raise the power level */
+    uint8_t                 PowerLevel;          /* Current power level */
 } vboxusb_power_t;
 
@@ -276 +264 @@
 typedef struct vboxusb_state_t
 {
-    dev_info_t             *pDip;            /* Per instance device info. */
-    usb_client_dev_data_t  *pDevDesc;        /* Parsed & complete device descriptor */
-    uint8_t                 DevState;        /* Current USB Device state */
-    bool                    fClosed;         /* Whether the device (default control pipe) is closed */
-    bool                    fRestoreCfg;     /* Whether we changed configs to restore while tearing down */
-    bool                    fGetCfgReqDone;  /* First GET_CONFIG request has been circumvented */
-    kmutex_t                Mtx;             /* Mutex state protection */
-    usb_serialization_t     StateMulti;      /* State serialization */
-    size_t                  cbMaxBulkXfer;   /* Maximum bulk xfer size */
-    vboxusb_ep_t            aEps[VBOXUSB_MAX_ENDPOINTS]; /* All endpoints structures */
-    list_t                  hUrbs;           /* Handle to list of free/inflight URBs */
-    list_t                  hLandedUrbs;     /* Handle to list of landed URBs */
-    uint16_t                cInflightUrbs;   /* Number of inflight URBs. */
-    pollhead_t              PollHead;        /* Handle to pollhead for waking polling processes  */
-    int                     fPoll;           /* Polling status flag */
-    RTPROCESS               Process;         /* The process (id) of the session */
-    VBOXUSBREQ_CLIENT_INFO  ClientInfo;      /* Registration data */
-    vboxusb_power_t        *pPower;          /* Power Management */
+    dev_info_t             *pDip;                /* Per instance device info. */
+    usb_client_dev_data_t  *pDevDesc;            /* Parsed & complete device descriptor */
+    uint8_t                 DevState;            /* Current USB Device state */
+    bool                    fDefaultPipeOpen;    /* Whether the device (default control pipe) is closed */
+    bool                    fPollPending;        /* Whether the userland process' poll is pending */
+    kmutex_t                Mtx;                 /* Mutex state protection */
+    usb_serialization_t     StateMulti;          /* State serialization */
+    size_t                  cbMaxBulkXfer;       /* Maximum bulk xfer size */
+    vboxusb_ep_t            aEps[VBOXUSB_MAX_ENDPOINTS]; /* Array of all endpoints structures */
+    list_t                  hFreeUrbs;           /* List of free URBs */
+    list_t                  hInflightUrbs;       /* List of inflight URBs */
+    list_t                  hLandedUrbs;         /* List of landed URBs */
+    uint32_t                cFreeUrbs;           /* Number of free URBs */
+    uint32_t                cInflightUrbs;       /* Number of inflight URBs */
+    uint32_t                cLandedUrbs;         /* Number of landed URBs */
+    pollhead_t              PollHead;            /* Handle to pollhead for waking polling processes  */
+    RTPROCESS               Process;             /* The process (pid) of the user session */
+    VBOXUSBREQ_CLIENT_INFO  ClientInfo;          /* Registration data */
+    vboxusb_power_t        *pPower;              /* Power Management */
+    char                    szMfg[255];          /* Parsed manufacturer string */
+    char                    szProduct[255];      /* Parsed product string */
 } vboxusb_state_t;
+AssertCompileMemberSize(vboxusb_state_t, szMfg,     USB_MAXSTRINGLEN);
+AssertCompileMemberSize(vboxusb_state_t, szProduct, USB_MAXSTRINGLEN);
 
 
@@ -300 +293 @@
 *   Internal Functions                                                                                                           *
 *********************************************************************************************************************************/
-LOCAL int vboxUSBSolarisInitEndPoint(vboxusb_state_t *pState, usb_ep_data_t *pEpData, uchar_t uCfgValue,
-                                uchar_t uInterface, uchar_t uAlt);
-LOCAL int vboxUSBSolarisInitAllEndPoints(vboxusb_state_t *pState);
-LOCAL int vboxUSBSolarisInitEndPointsForConfig(vboxusb_state_t *pState, uint8_t uCfgIndex);
-LOCAL int vboxUSBSolarisInitEndPointsForInterfaceAlt(vboxusb_state_t *pState, uint8_t uInterface, uint8_t uAlt);
-LOCAL void vboxUSBSolarisDestroyAllEndPoints(vboxusb_state_t *pState);
-LOCAL void vboxUSBSolarisDestroyEndPoint(vboxusb_state_t *pState, vboxusb_ep_t *pEp);
-LOCAL void vboxUSBSolarisCloseAllPipes(vboxusb_state_t *pState, bool fControlPipe);
-LOCAL int vboxUSBSolarisOpenPipe(vboxusb_state_t *pState, vboxusb_ep_t *pEp);
-LOCAL void vboxUSBSolarisClosePipe(vboxusb_state_t *pState, vboxusb_ep_t *pEp);
-LOCAL int vboxUSBSolarisCtrlXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb);
-LOCAL void vboxUSBSolarisCtrlXferCompleted(usb_pipe_handle_t pPipe, usb_ctrl_req_t *pReq);
-LOCAL int vboxUSBSolarisBulkXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *purb);
-LOCAL void vboxUSBSolarisBulkXferCompleted(usb_pipe_handle_t pPipe, usb_bulk_req_t *pReq);
-LOCAL int vboxUSBSolarisIntrXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb);
-LOCAL void vboxUSBSolarisIntrXferCompleted(usb_pipe_handle_t pPipe, usb_intr_req_t *pReq);
-LOCAL int vboxUSBSolarisIsocXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb);
-LOCAL void vboxUSBSolarisIsocInXferCompleted(usb_pipe_handle_t pPipe, usb_isoc_req_t *pReq);
-LOCAL void vboxUSBSolarisIsocInXferError(usb_pipe_handle_t pPipe, usb_isoc_req_t *pReq);
-LOCAL void vboxUSBSolarisIsocOutXferCompleted(usb_pipe_handle_t pPipe, usb_isoc_req_t *pReq);
-LOCAL vboxusb_urb_t *vboxUSBSolarisGetIsocInURB(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq);
-LOCAL vboxusb_urb_t *vboxUSBSolarisQueueURB(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq, mblk_t *pMsg);
-LOCAL inline void vboxUSBSolarisConcatMsg(vboxusb_urb_t *pUrb);
-LOCAL inline VUSBSTATUS vboxUSBSolarisGetUrbStatus(usb_cr_t Status);
-LOCAL inline void vboxUSBSolarisDeQueueURB(vboxusb_urb_t *pUrb, int URBStatus);
-LOCAL inline void vboxUSBSolarisNotifyComplete(vboxusb_state_t *pState);
-LOCAL int vboxUSBSolarisProcessIOCtl(int iFunction, void *pvState, int Mode, PVBOXUSBREQ pUSBReq, void *pvBuf,
-                                     size_t *pcbDataOut);
-LOCAL bool vboxUSBSolarisIsUSBDevice(dev_info_t *pDip);
+LOCAL int    vboxUsbSolarisInitEp(vboxusb_state_t *pState, usb_ep_data_t *pEpData);
+LOCAL int    vboxUsbSolarisInitEpsForCfg(vboxusb_state_t *pState);
+LOCAL int    vboxUsbSolarisInitEpsForIfAlt(vboxusb_state_t *pState, uint8_t bIf, uint8_t bAlt);
+LOCAL void   vboxUsbSolarisDestroyAllEps(vboxusb_state_t *pState);
+LOCAL void   vboxUsbSolarisDestroyEp(vboxusb_state_t *pState, vboxusb_ep_t *pEp);
+LOCAL void   vboxUsbSolarisCloseAllPipes(vboxusb_state_t *pState, bool fControlPipe);
+LOCAL int    vboxUsbSolarisOpenPipe(vboxusb_state_t *pState, vboxusb_ep_t *pEp);
+LOCAL void   vboxUsbSolarisClosePipe(vboxusb_state_t *pState, vboxusb_ep_t *pEp);
+LOCAL int    vboxUsbSolarisCtrlXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb);
+LOCAL void   vboxUsbSolarisCtrlXferCompleted(usb_pipe_handle_t pPipe, usb_ctrl_req_t *pReq);
+LOCAL int    vboxUsbSolarisBulkXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *purb);
+LOCAL void   vboxUsbSolarisBulkXferCompleted(usb_pipe_handle_t pPipe, usb_bulk_req_t *pReq);
+LOCAL int    vboxUsbSolarisIntrXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb);
+LOCAL void   vboxUsbSolarisIntrXferCompleted(usb_pipe_handle_t pPipe, usb_intr_req_t *pReq);
+LOCAL int    vboxUsbSolarisIsocXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb);
+LOCAL void   vboxUsbSolarisIsocInXferCompleted(usb_pipe_handle_t pPipe, usb_isoc_req_t *pReq);
+LOCAL void   vboxUsbSolarisIsocInXferError(usb_pipe_handle_t pPipe, usb_isoc_req_t *pReq);
+LOCAL void   vboxUsbSolarisIsocOutXferCompleted(usb_pipe_handle_t pPipe, usb_isoc_req_t *pReq);
+LOCAL vboxusb_urb_t  *vboxUsbSolarisGetIsocInUrb(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq);
+LOCAL vboxusb_urb_t  *vboxUsbSolarisQueueUrb(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq, mblk_t *pMsg);
+LOCAL VUSBSTATUS      vboxUsbSolarisGetUrbStatus(usb_cr_t Status);
+LOCAL void   vboxUsbSolarisConcatMsg(vboxusb_urb_t *pUrb);
+LOCAL void   vboxUsbSolarisDeQueueUrb(vboxusb_urb_t *pUrb, int URBStatus);
+LOCAL void   vboxUsbSolarisNotifyComplete(vboxusb_state_t *pState);
+LOCAL int    vboxUsbSolarisProcessIOCtl(int iFunction, void *pvState, int Mode, PVBOXUSBREQ pUSBReq, void *pvBuf,
+                                        size_t *pcbDataOut);
+LOCAL bool   vboxUsbSolarisIsUSBDevice(dev_info_t *pDip);
 
 /** @name Device Operation Hooks
  * @{ */
-LOCAL int vboxUSBSolarisSendURB(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq, int Mode);
-LOCAL int vboxUSBSolarisReapURB(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq, int Mode);
-LOCAL int vboxUSBSolarisClearEndPoint(vboxusb_state_t *pState, uint8_t bEndpoint);
-LOCAL int vboxUSBSolarisSetConfig(vboxusb_state_t *pState, uint8_t bCfgValue);
-LOCAL int vboxUSBSolarisGetConfig(vboxusb_state_t *pState, uint8_t *pCfgValue);
-LOCAL int vboxUSBSolarisSetInterface(vboxusb_state_t *pState, uint8_t uInterface, uint8_t uAlt);
-LOCAL int vboxUSBSolarisCloseDevice(vboxusb_state_t *pState, VBOXUSB_RESET_LEVEL enmReset);
-LOCAL int vboxUSBSolarisAbortPipe(vboxusb_state_t *pState, uint8_t bEndpoint);
-LOCAL int vboxUSBSolarisGetConfigIndex(vboxusb_state_t *pState, uint_t uCfgValue);
+LOCAL int    vboxUsbSolarisSendUrb(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq, int Mode);
+LOCAL int    vboxUsbSolarisReapUrb(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq, int Mode);
+LOCAL int    vboxUsbSolarisClearEndPoint(vboxusb_state_t *pState, uint8_t bEndpoint);
+LOCAL int    vboxUsbSolarisSetConfig(vboxusb_state_t *pState, uint8_t bCfgValue);
+LOCAL int    vboxUsbSolarisGetConfig(vboxusb_state_t *pState, uint8_t *pCfgValue);
+LOCAL int    vboxUsbSolarisSetInterface(vboxusb_state_t *pState, uint8_t bIf, uint8_t bAlt);
+LOCAL int    vboxUsbSolarisCloseDevice(vboxusb_state_t *pState, VBOXUSB_RESET_LEVEL enmReset);
+LOCAL int    vboxUsbSolarisAbortPipe(vboxusb_state_t *pState, uint8_t bEndpoint);
+LOCAL int    vboxUsbSolarisGetConfigIndex(vboxusb_state_t *pState, uint_t bCfgValue);
 /** @} */
 
 /** @name Hotplug & Power Management Hooks
  * @{ */
-LOCAL inline void vboxUSBSolarisNotifyHotplug(vboxusb_state_t *pState);
-LOCAL int vboxUSBSolarisDeviceDisconnected(dev_info_t *pDip);
-LOCAL int vboxUSBSolarisDeviceReconnected(dev_info_t *pDip);
-
-LOCAL int vboxUSBSolarisInitPower(vboxusb_state_t *pState);
-LOCAL void vboxUSBSolarisDestroyPower(vboxusb_state_t *pState);
-LOCAL int vboxUSBSolarisDeviceSuspend(vboxusb_state_t *pState);
-LOCAL void vboxUSBSolarisDeviceResume(vboxusb_state_t *pState);
-LOCAL void vboxUSBSolarisDeviceRestore(vboxusb_state_t *pState);
-LOCAL void vboxUSBSolarisPowerBusy(vboxusb_state_t *pState);
-LOCAL void vboxUSBSolarisPowerIdle(vboxusb_state_t *pState);
+LOCAL void   vboxUsbSolarisNotifyUnplug(vboxusb_state_t *pState);
+LOCAL int    vboxUsbSolarisDeviceDisconnected(dev_info_t *pDip);
+LOCAL int    vboxUsbSolarisDeviceReconnected(dev_info_t *pDip);
+
+LOCAL int    vboxUsbSolarisInitPower(vboxusb_state_t *pState);
+LOCAL void   vboxUsbSolarisDestroyPower(vboxusb_state_t *pState);
+LOCAL int    vboxUsbSolarisDeviceSuspend(vboxusb_state_t *pState);
+LOCAL void   vboxUsbSolarisDeviceResume(vboxusb_state_t *pState);
+LOCAL void   vboxUsbSolarisDeviceRestore(vboxusb_state_t *pState);
+LOCAL void   vboxUsbSolarisPowerBusy(vboxusb_state_t *pState);
+LOCAL void   vboxUsbSolarisPowerIdle(vboxusb_state_t *pState);
 /** @} */
 
 /** @name Monitor Hooks
  * @{ */
-int VBoxUSBMonSolarisRegisterClient(dev_info_t *pClientDip, PVBOXUSB_CLIENT_INFO pClientInfo);
-int VBoxUSBMonSolarisUnregisterClient(dev_info_t *pClientDip);
+int          VBoxUSBMonSolarisRegisterClient(dev_info_t *pClientDip, PVBOXUSB_CLIENT_INFO pClientInfo);
+int          VBoxUSBMonSolarisUnregisterClient(dev_info_t *pClientDip);
 /** @} */
 
 /** @name Callbacks from Monitor
  * @{ */
-LOCAL int vboxUSBSolarisSetConsumerCredentials(RTPROCESS Process, int Instance, void *pvReserved);
+LOCAL int    vboxUsbSolarisSetConsumerCredentials(RTPROCESS Process, int Instance, void *pvReserved);
 /** @} */
 
@@ -377 +368 @@
 
 /** The default endpoint descriptor */
-static usb_ep_descr_t g_VBoxUSBSolarisDefaultEpDesc = {7, 5, 0, USB_EP_ATTR_CONTROL, 8, 0};
-
-/** Hotplug events */
-static usb_event_t g_VBoxUSBSolarisEvents =
-{
-    vboxUSBSolarisDeviceDisconnected,
-    vboxUSBSolarisDeviceReconnected,
-    NULL,                             /* presuspend */
-    NULL                              /* postresume */
-};
+static usb_ep_descr_t g_VBoxUSBSolarisDefaultEpDesc = { 7, 5, 0, USB_EP_ATTR_CONTROL, 8, 0 };
+
+/** Size of the usb_ep_data_t struct (used to index into data). */
+static size_t g_cbUsbEpData       = ~0UL;
+
+/** The offset of usb_ep_data_t::ep_desc. */
+static size_t g_offUsbEpDataDescr = ~0UL;
+
+
+#ifdef LOG_ENABLED
+/**
+ * Gets the description of an Endpoint's transfer type.
+ *
+ * @param pEp       The Endpoint.
+ * @returns The type of the Endpoint.
+ */
+static const char *vboxUsbSolarisEpType(vboxusb_ep_t *pEp)
+{
+    uint8_t uType = VBOXUSB_XFER_TYPE(pEp);
+    switch (uType)
+    {
+        case 0:  return "CTRL";
+        case 1:  return "ISOC";
+        case 2:  return "BULK";
+        default: return "INTR";
+    }
+}
+
+
+/**
+ * Gets the description of an Endpoint's direction.
+ *
+ * @param pEp       The Endpoint.
+ * @returns The direction of the Endpoint.
+ */
+static const char *vboxUsbSolarisEpDir(vboxusb_ep_t *pEp)
+{
+    return VBOXUSB_XFER_DIR(pEp) == USB_EP_DIR_IN ? "IN " : "OUT";
+}
+#endif
+
+
+/**
+ * Caches device strings from the parsed device descriptors.
+ *
+ * @param   pState          The USB device instance.
+ *
+ * @remarks Must only be called after usb_get_dev_data().
+ */
+static void vboxUsbSolarisGetDeviceStrings(vboxusb_state_t *pState)
+{
+    AssertReturnVoid(pState);
+    AssertReturnVoid(pState->pDevDesc);
+
+    if (pState->pDevDesc->dev_product)
+        strlcpy(&pState->szMfg[0], pState->pDevDesc->dev_mfg, sizeof(pState->szMfg));
+    else
+        strlcpy(&pState->szMfg[0], "<Unknown Manufacturer>", sizeof(pState->szMfg));
+
+    if (pState->pDevDesc->dev_product)
+        strlcpy(&pState->szProduct[0], pState->pDevDesc->dev_product, sizeof(pState->szProduct));
+    else
+        strlcpy(&pState->szProduct[0], "<Unnamed USB device>", sizeof(pState->szProduct));
+}
+
+
+/**
+ * Queries the necessary symbols at runtime.
+ *
+ * @returns VBox status code.
+ */
+LOCAL int vboxUsbSolarisQuerySymbols(void)
+{
+    RTDBGKRNLINFO hKrnlDbgInfo;
+    int rc = RTR0DbgKrnlInfoOpen(&hKrnlDbgInfo, 0 /* fFlags */);
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Query and sanitize the size of usb_ep_data_t struct.
+         */
+        size_t cbPrevUsbEpData = g_cbUsbEpData;
+        rc = RTR0DbgKrnlInfoQuerySize(hKrnlDbgInfo, "usba", "usb_ep_data_t", &g_cbUsbEpData);
+        if (RT_FAILURE(rc))
+        {
+            LogRel(("Failed to query size of \"usb_ep_data_t\" in the \"usba\" module, rc=%Rrc\n", rc));
+            return rc;
+        }
+        if (g_cbUsbEpData > _4K)
+        {
+            LogRel(("Size of \"usb_ep_data_t\" (%u bytes) seems implausible, too paranoid to continue\n", g_cbUsbEpData));
+            return VERR_MISMATCH;
+        }
+
+        /*
+         * Query and sanitizie the offset of usb_ep_data_t::ep_descr.
+         */
+        size_t offPrevUsbEpDataDescr = g_offUsbEpDataDescr;
+        rc = RTR0DbgKrnlInfoQueryMember(hKrnlDbgInfo, "usba", "usb_ep_data_t", "ep_descr", &g_offUsbEpDataDescr);
+        if (RT_FAILURE(rc))
+        {
+            LogRel(("Failed to query offset of usb_ep_data_t::ep_descr, rc=%Rrc\n", rc));
+            return rc;
+        }
+        if (g_offUsbEpDataDescr > _4K - sizeof(usb_ep_descr_t))
+        {
+            LogRel(("Offset of \"ep_desrc\" (%u) seems implausible, too paranoid to continue\n", g_offUsbEpDataDescr));
+            return VERR_MISMATCH;
+        }
+
+        /*
+         * Log only when it changes / first time, since _init() seems to be called often (e.g. on failed attaches).
+         * cmn_err, CE_CONT and '!' is used to not show the message on console during boot each time.
+         */
+        if (   cbPrevUsbEpData       != g_cbUsbEpData
+            || offPrevUsbEpDataDescr != g_offUsbEpDataDescr)
+        {
+            cmn_err(CE_CONT, "!usba_ep_data_t is %lu bytes\n", g_cbUsbEpData);
+            cmn_err(CE_CONT, "!usba_ep_data_t::ep_descr @ 0x%lx (%ld)\n", g_offUsbEpDataDescr, g_offUsbEpDataDescr);
+        }
+
+        RTR0DbgKrnlInfoRelease(hKrnlDbgInfo);
+    }
+}
 
 
@@ -394 +498 @@
 int _init(void)
 {
-    LogFunc((DEVICE_NAME ":_init\n"));
+    LogFunc((DEVICE_NAME ": _init\n"));
 
     /*
@@ -403 +507 @@
         pModCtl->mod_loadflags |= MOD_NOAUTOUNLOAD;
     else
-        LogRel((DEVICE_NAME ":failed to disable autounloading!\n"));
+        LogRel((DEVICE_NAME ": _init: failed to disable autounloading!\n"));
 
     /*
@@ -411 +515 @@
     if (RT_SUCCESS(rc))
     {
+        rc = vboxUsbSolarisQuerySymbols();
+        if (RT_FAILURE(rc))
+            return EINVAL;
+
         rc = ddi_soft_state_init(&g_pVBoxUSBSolarisState, sizeof(vboxusb_state_t), 4 /* pre-alloc */);
         if (!rc)
@@ -418 +526 @@
                 return rc;
 
-            LogRel((DEVICE_NAME ":mod_install failed! rc=%d\n", rc));
+            LogRel((DEVICE_NAME ": _init: mod_install failed! rc=%d\n", rc));
             ddi_soft_state_fini(&g_pVBoxUSBSolarisState);
         }
         else
-            LogRel((DEVICE_NAME ":failed to initialize soft state.\n"));
+            LogRel((DEVICE_NAME ": _init: failed to initialize soft state\n"));
 
         RTR0Term();
     }
     else
-        LogRel((DEVICE_NAME ":RTR0Init failed! rc=%d\n", rc));
+        LogRel((DEVICE_NAME ": _init: RTR0Init failed! rc=%d\n", rc));
     return RTErrConvertToErrno(rc);
 }
@@ -436 +544 @@
     int rc;
 
-    LogFunc((DEVICE_NAME ":_fini\n"));
+    LogFunc((DEVICE_NAME ": _fini\n"));
 
     rc = mod_remove(&g_VBoxUSBSolarisModLinkage);
@@ -451 +559 @@
 int _info(struct modinfo *pModInfo)
 {
-    LogFunc((DEVICE_NAME ":_info\n"));
+    LogFunc((DEVICE_NAME ": _info\n"));
 
     return mod_info(&g_VBoxUSBSolarisModLinkage, pModInfo);
@@ -463 +571 @@
  * @param   enmCmd          Attach type (ddi_attach_cmd_t)
  *
- * @returns corresponding solaris error code.
+ * @returns Solaris error code.
  */
 int VBoxUSBSolarisAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd)
 {
-    LogFunc((DEVICE_NAME ":VBoxUSBSolarisAttach pDip=%p enmCmd=%d\n", pDip, enmCmd));
+    LogFunc((DEVICE_NAME ": VBoxUSBSolarisAttach: pDip=%p enmCmd=%d\n", pDip, enmCmd));
 
     int rc;
@@ -483 +591 @@
                 if (RT_LIKELY(pState))
                 {
-                    pState->pDip = pDip;
-                    pState->pDevDesc = NULL;
-                    pState->fClosed = false;
-                    pState->fRestoreCfg = false;
-                    pState->fGetCfgReqDone = false;
+                    pState->pDip             = pDip;
+                    pState->pDevDesc         = NULL;
+                    pState->fPollPending     = false;
+                    pState->cInflightUrbs    = 0;
+                    pState->cFreeUrbs        = 0;
+                    pState->cLandedUrbs      = 0;
+                    pState->Process          = NIL_RTPROCESS;
+                    pState->pPower           = NULL;
                     bzero(pState->aEps, sizeof(pState->aEps));
-                    list_create(&pState->hUrbs, sizeof(vboxusb_urb_t), offsetof(vboxusb_urb_t, hListLink));
+                    list_create(&pState->hFreeUrbs, sizeof(vboxusb_urb_t), offsetof(vboxusb_urb_t, hListLink));
+                    list_create(&pState->hInflightUrbs, sizeof(vboxusb_urb_t), offsetof(vboxusb_urb_t, hListLink));
                     list_create(&pState->hLandedUrbs, sizeof(vboxusb_urb_t), offsetof(vboxusb_urb_t, hListLink));
-                    pState->cInflightUrbs = 0;
-                    pState->fPoll = VBOXUSB_POLL_OFF;
-                    pState->Process = NIL_RTPROCESS;
-                    pState->pPower = NULL;
 
                     /*
@@ -500 +608 @@
                      * a non-USB device. So check if we are really binding to a USB device or not.
                      */
-                    if (vboxUSBSolarisIsUSBDevice(pState->pDip))
+                    if (vboxUsbSolarisIsUSBDevice(pState->pDip))
                     {
                         /*
@@ -508 +616 @@
                         if (rc == USB_SUCCESS)
                         {
+                            pState->fDefaultPipeOpen = true;
+
                             /*
                              * Parse out the entire descriptor.
@@ -514 +624 @@
                             if (rc == USB_SUCCESS)
                             {
+                                /*
+                                 * Cache some device descriptor strings.
+                                 */
+                                vboxUsbSolarisGetDeviceStrings(pState);
 #ifdef DEBUG_ramshankar
                                 usb_print_descr_tree(pState->pDip, pState->pDevDesc);
@@ -530 +644 @@
                                 if (rc == USB_SUCCESS)
                                 {
-                                    Log((DEVICE_NAME ":VBoxUSBSolarisAttach cbMaxBulkXfer=%d\n", pState->cbMaxBulkXfer));
+                                    Log((DEVICE_NAME ": VBoxUSBSolarisAttach: cbMaxBulkXfer=%d\n", pState->cbMaxBulkXfer));
 
                                     /*
-                                     * Initialize all endpoints.
+                                     * Initialize the default endpoint.
                                      */
-                                    rc = vboxUSBSolarisInitAllEndPoints(pState);
+                                    rc = vboxUsbSolarisInitEp(pState, NULL /* pEp */);
                                     if (RT_SUCCESS(rc))
                                     {
@@ -546 +660 @@
                                          * Initialize power management for the device.
                                          */
-                                        rc = vboxUSBSolarisInitPower(pState);
+                                        rc = vboxUsbSolarisInitPower(pState);
                                         if (RT_SUCCESS(rc))
                                         {
                                             /*
-                                             * Update endpoints (descriptors) for the current config.
+                                             * Initialize endpoints for the current config.
                                              */
-                                            vboxUSBSolarisInitEndPointsForConfig(pState, usb_get_current_cfgidx(pState->pDip));
+                                            rc = vboxUsbSolarisInitEpsForCfg(pState);
+                                            AssertRC(rc);
 
                                             /*
@@ -564 +679 @@
                                                  * Register hotplug callbacks.
                                                  */
-                                                rc = usb_register_event_cbs(pState->pDip, &g_VBoxUSBSolarisEvents, 0 /* flags */);
+                                                rc = usb_register_hotplug_cbs(pState->pDip, &vboxUsbSolarisDeviceDisconnected,
+                                                                              &vboxUsbSolarisDeviceReconnected);
                                                 if (RT_LIKELY(rc == USB_SUCCESS))
                                                 {
@@ -575 +691 @@
                                                     RTStrPrintf(pState->ClientInfo.szClientPath,
                                                                 sizeof(pState->ClientInfo.szClientPath),
-                                                                "/devices%s:%s", szDevicePath,DEVICE_NAME);
-                                                    RTPathStripFilename(szDevicePath);
+                                                                "/devices%s:%s", szDevicePath, DEVICE_NAME);
                                                     RTStrPrintf(pState->ClientInfo.szDeviceIdent,
                                                                 sizeof(pState->ClientInfo.szDeviceIdent),
@@ -584 +699 @@
                                                                 pState->pDevDesc->dev_descr->bcdDevice, szDevicePath);
                                                     pState->ClientInfo.Instance = instance;
-                                                    pState->ClientInfo.pfnSetConsumerCredentials = &vboxUSBSolarisSetConsumerCredentials;
+                                                    pState->ClientInfo.pfnSetConsumerCredentials = &vboxUsbSolarisSetConsumerCredentials;
                                                     rc = VBoxUSBMonSolarisRegisterClient(pState->pDip, &pState->ClientInfo);
                                                     if (RT_SUCCESS(rc))
                                                     {
-                                                        LogRel((DEVICE_NAME ": Captured %s %#x:%#x:%d:%s\n",
-                                                                pState->pDevDesc->dev_product ? pState->pDevDesc->dev_product
-                                                                    : "<Unnamed USB device>",
-                                                                pState->pDevDesc->dev_descr->idVendor,
-                                                                pState->pDevDesc->dev_descr->idProduct,
-                                                                pState->pDevDesc->dev_descr->bcdDevice,
-                                                                pState->ClientInfo.szClientPath));
-
+                                                        LogRel((DEVICE_NAME ": Captured %s %s (Ident=%s)\n", pState->szMfg,
+                                                                pState->szProduct, pState->ClientInfo.szDeviceIdent));
                                                         return DDI_SUCCESS;
                                                     }
-                                                    else
-                                                    {
-                                                        LogRel((DEVICE_NAME ":VBoxUSBMonSolarisRegisterClient failed! rc=%d "
-                                                                "path=%s instance=%d\n", rc, pState->ClientInfo.szClientPath,
-                                                                instance));
-                                                    }
-
-                                                    usb_unregister_event_cbs(pState->pDip, &g_VBoxUSBSolarisEvents);
+
+                                                    LogRel((DEVICE_NAME ": VBoxUSBMonSolarisRegisterClient failed! rc=%d "
+                                                            "path=%s instance=%d\n", rc, pState->ClientInfo.szClientPath,
+                                                            instance));
+
+                                                    usb_unregister_hotplug_cbs(pState->pDip);
                                                 }
                                                 else
-                                                    LogRel((DEVICE_NAME ":VBoxUSBSolarisAttach failed to register hotplug "
-                                                            "callbacks! rc=%d\n", rc));
+                                                    LogRel((DEVICE_NAME ": VBoxUSBSolarisAttach: Failed to register hotplug callbacks! rc=%d\n", rc));
 
                                                 ddi_remove_minor_node(pState->pDip, NULL);
                                             }
                                             else
-                                            {
-                                                LogRel((DEVICE_NAME ":VBoxUSBSolarisAttach ddi_create_minor_node failed! rc=%d\n",
-                                                        rc));
-                                            }
+                                                LogRel((DEVICE_NAME ": VBoxUSBSolarisAttach: ddi_create_minor_node failed! rc=%d\n", rc));
+
+                                            mutex_enter(&pState->Mtx);
+                                            vboxUsbSolarisDestroyPower(pState);
+                                            mutex_exit(&pState->Mtx);
                                         }
                                         else
-                                        {
-                                            LogRel((DEVICE_NAME ":VBoxUSBSolarisAttach failed to initialize power management! "
-                                                    "rc=%d\n", rc));
-                                        }
+                                            LogRel((DEVICE_NAME ": VBoxUSBSolarisAttach: Failed to init power management! rc=%d\n", rc));
                                     }
                                     else
-                                    {
-                                        LogRel((DEVICE_NAME ":VBoxUSBSolarisAttach vboxUSBSolarisInitAllEndPoints failed! "
-                                                "rc=%d\n"));
-                                    }
+                                        LogRel((DEVICE_NAME ": VBoxUSBSolarisAttach: vboxUsbSolarisInitEp failed! rc=%d\n", rc));
                                 }
                                 else
-                                {
-                                    LogRel((DEVICE_NAME ":VBoxUSBSolarisAttach usb_pipe_get_max_bulk_transfer_size failed! "
-                                            "rc=%d\n", rc));
-                                }
+                                    LogRel((DEVICE_NAME ": VBoxUSBSolarisAttach: usb_pipe_get_max_bulk_transfer_size failed! rc=%d\n", rc));
 
                                 usb_fini_serialization(pState->StateMulti);
@@ -642 +740 @@
                             }
                             else
-                                LogRel((DEVICE_NAME ":VBoxUSBSolarisAttach failed to get device descriptor. rc=%d\n", rc));
+                                LogRel((DEVICE_NAME ": VBoxUSBSolarisAttach: Failed to get device descriptor. rc=%d\n", rc));
 
                             usb_client_detach(pState->pDip, NULL);
                         }
                         else
-                            LogRel((DEVICE_NAME ":VBoxUSBSolarisAttach usb_client_attach failed! rc=%d\n", rc));
+                            LogRel((DEVICE_NAME ": VBoxUSBSolarisAttach: usb_client_attach failed! rc=%d\n", rc));
                     }
                     else
                     {
                         /* This would appear on every boot if it were LogRel() */
-                        Log((DEVICE_NAME ":VBoxUSBSolarisAttach not a USB device.\n"));
+                        Log((DEVICE_NAME ": VBoxUSBSolarisAttach: Not a USB device\n"));
                     }
                 }
                 else
-                    LogRel((DEVICE_NAME ":VBoxUSBSolarisAttach failed to get soft state\n", sizeof(*pState)));
+                    LogRel((DEVICE_NAME ": VBoxUSBSolarisAttach: Failed to get soft state\n", sizeof(*pState)));
 
                 ddi_soft_state_free(g_pVBoxUSBSolarisState, instance);
             }
             else
-                LogRel((DEVICE_NAME ":VBoxUSBSolarisAttach failed to alloc soft state. rc=%d\n", rc));
+                LogRel((DEVICE_NAME ": VBoxUSBSolarisAttach: Failed to alloc soft state. rc=%d\n", rc));
 
             return DDI_FAILURE;
@@ -671 +769 @@
             if (RT_UNLIKELY(!pState))
             {
-                LogRel((DEVICE_NAME ":VBoxUSBSolarisAttach DDI_RESUME: failed to get soft state on detach.\n"));
+                LogRel((DEVICE_NAME ": VBoxUSBSolarisAttach: DDI_RESUME failed to get soft state on detach\n"));
                 return DDI_FAILURE;
             }
 
-            vboxUSBSolarisDeviceResume(pState);
+            vboxUsbSolarisDeviceResume(pState);
             return DDI_SUCCESS;
         }
@@ -691 +789 @@
  * @param   enmCmd          Attach type (ddi_attach_cmd_t)
  *
- * @returns corresponding solaris error code.
+ * @returns Solaris error code.
  */
 int VBoxUSBSolarisDetach(dev_info_t *pDip, ddi_detach_cmd_t enmCmd)
 {
-    LogFunc((DEVICE_NAME ":VBoxUSBSolarisDetach pDip=%p enmCmd=%d\n", pDip, enmCmd));
+    LogFunc((DEVICE_NAME ": VBoxUSBSolarisDetach: pDip=%p enmCmd=%d\n", pDip, enmCmd));
 
     int instance = ddi_get_instance(pDip);
@@ -701 +799 @@
     if (RT_UNLIKELY(!pState))
     {
-        LogRel((DEVICE_NAME ":VBoxUSBSolarisDetach failed to get soft state on detach.\n"));
+        LogRel((DEVICE_NAME ": VBoxUSBSolarisDetach: Failed to get soft state on detach\n"));
         return DDI_FAILURE;
     }
@@ -718 +816 @@
              * Notify userland if any that we're gone (while resetting device held by us).
              */
-            vboxUSBSolarisNotifyHotplug(pState);
+            mutex_enter(&pState->Mtx);
+            pState->DevState = USB_DEV_DISCONNECTED;
+            vboxUsbSolarisNotifyUnplug(pState);
+            mutex_exit(&pState->Mtx);
+
 
             /*
@@ -724 +826 @@
              * would otherwise block on the mutex.
              */
-            usb_unregister_event_cbs(pDip, &g_VBoxUSBSolarisEvents);
-
+            usb_unregister_hotplug_cbs(pDip);
 
             /*
              * Serialize: paranoid; drain other driver activity.
              */
-            usb_serialize_access(pState->StateMulti, USB_WAIT, 0);
+            usb_serialize_access(pState->StateMulti, USB_WAIT, 0 /* timeout */);
             usb_release_access(pState->StateMulti);
             mutex_enter(&pState->Mtx);
 
             /*
-             * Close all endpoints.
+             * Close all pipes.
              */
-            vboxUSBSolarisCloseAllPipes(pState, true /* ControlPipe */);
-            pState->fClosed = true;
+            vboxUsbSolarisCloseAllPipes(pState, true /* ControlPipe */);
+            Assert(!pState->fDefaultPipeOpen);
 
             /*
-             * Deinitialize power, destroy endpoints.
+             * Deinitialize power, destroy all endpoints.
              */
-            vboxUSBSolarisDestroyPower(pState);
-            vboxUSBSolarisDestroyAllEndPoints(pState);
+            vboxUsbSolarisDestroyPower(pState);
+            vboxUsbSolarisDestroyAllEps(pState);
 
             /*
-             * Free up all URBs.
+             * Free up all URB lists.
              */
             vboxusb_urb_t *pUrb = NULL;
-            while ((pUrb = list_remove_head(&pState->hUrbs)) != NULL)
+            while ((pUrb = list_remove_head(&pState->hFreeUrbs)) != NULL)
             {
                 if (pUrb->pMsg)
@@ -756 +857 @@
                 RTMemFree(pUrb);
             }
-
+            while ((pUrb = list_remove_head(&pState->hInflightUrbs)) != NULL)
+            {
+                if (pUrb->pMsg)
+                    freemsg(pUrb->pMsg);
+                RTMemFree(pUrb);
+            }
             while ((pUrb = list_remove_head(&pState->hLandedUrbs)) != NULL)
             {
@@ -763 +869 @@
                 RTMemFree(pUrb);
             }
+            pState->cFreeUrbs     = 0;
+            pState->cLandedUrbs   = 0;
             pState->cInflightUrbs = 0;
-            list_destroy(&pState->hUrbs);
+            list_destroy(&pState->hFreeUrbs);
+            list_destroy(&pState->hInflightUrbs);
             list_destroy(&pState->hLandedUrbs);
 
@@ -784 +893 @@
             ddi_remove_minor_node(pState->pDip, NULL);
 
-            LogRel((DEVICE_NAME ": Released %s %s\n",
-                    pState->pDevDesc->dev_product ? pState->pDevDesc->dev_product : "<Unnamed USB device>",
+            LogRel((DEVICE_NAME ": Released %s %s (Ident=%s)\n", pState->szMfg, pState->szProduct,
                     pState->ClientInfo.szDeviceIdent));
 
             ddi_soft_state_free(g_pVBoxUSBSolarisState, instance);
             pState = NULL;
-
             return DDI_SUCCESS;
         }
@@ -796 +903 @@
         case DDI_SUSPEND:
         {
-            int rc = vboxUSBSolarisDeviceSuspend(pState);
+            int rc = vboxUsbSolarisDeviceSuspend(pState);
             if (RT_SUCCESS(rc))
                 return DDI_SUCCESS;
@@ -817 +924 @@
  * @param   ppvResult       Where to store the requested info.
  *
- * @returns corresponding solaris error code.
+ * @returns Solaris error code.
  */
 int VBoxUSBSolarisGetInfo(dev_info_t *pDip, ddi_info_cmd_t enmCmd, void *pvArg, void **ppvResult)
 {
-    LogFunc((DEVICE_NAME ":VBoxUSBSolarisGetInfo\n"));
+    LogFunc((DEVICE_NAME ": VBoxUSBSolarisGetInfo\n"));
 
     vboxusb_state_t *pState = NULL;
@@ -840 +947 @@
             }
             else
-                LogRel((DEVICE_NAME ":VBoxUSBSolarisGetInfo failed to get device state.\n"));
+                LogRel((DEVICE_NAME ": VBoxUSBSolarisGetInfo: Failed to get device state\n"));
             return DDI_FAILURE;
         }
@@ -857 +964 @@
 
 /**
- * Callback invoked from the Monitor driver when a VM process tries to access
- * this client instance. This determines which VM process will be allowed to
- * open and access the USB device.
+ * Callback invoked from the VirtualBox USB Monitor driver when a VM process
+ * tries to access this USB client instance.
+ *
+ * This determines which VM process will be allowed to open and access this USB
+ * device.
  *
  * @returns  VBox status code.
@@ -868 +977 @@
  * @param    pvReserved     Reserved for future, unused.
  */
-LOCAL int vboxUSBSolarisSetConsumerCredentials(RTPROCESS Process, int Instance, void *pvReserved)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisSetConsumerCredentials Process=%u Instance=%d\n", Process, Instance));
+LOCAL int vboxUsbSolarisSetConsumerCredentials(RTPROCESS Process, int Instance, void *pvReserved)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisSetConsumerCredentials: Process=%u Instance=%d\n", Process, Instance));
     vboxusb_state_t *pState = ddi_get_soft_state(g_pVBoxUSBSolarisState, Instance);
     if (!pState)
     {
-        LogRel((DEVICE_NAME ":vboxUSBSolarisSetConsumerCredentials failed to get device state for instance %d\n", Instance));
+        LogRel((DEVICE_NAME ": vboxUsbSolarisSetConsumerCredentials: Failed to get device state for instance %d\n", Instance));
         return VERR_INVALID_STATE;
     }
@@ -885 +994 @@
     else
     {
-        LogRel((DEVICE_NAME ":vboxUSBSolarisSetConsumerCredentials failed! Process %u already has client open.\n",
+        LogRel((DEVICE_NAME ": vboxUsbSolarisSetConsumerCredentials: Failed! Process %u already has client open\n",
                 pState->Process));
         rc = VERR_RESOURCE_BUSY;
@@ -898 +1007 @@
 int VBoxUSBSolarisOpen(dev_t *pDev, int fFlag, int fType, cred_t *pCred)
 {
-    LogFunc((DEVICE_NAME ":VBoxUSBSolarisOpen pDev=%p fFlag=%d fType=%d pCred=%p\n", pDev, fFlag, fType, pCred));
+    LogFunc((DEVICE_NAME ": VBoxUSBSolarisOpen: pDev=%p fFlag=%d fType=%d pCred=%p\n", pDev, fFlag, fType, pCred));
 
     /*
@@ -913 +1022 @@
     if (!pState)
     {
-        LogRel((DEVICE_NAME ":VBoxUSBSolarisOpen failed to get device state for instance %d\n", instance));
+        LogRel((DEVICE_NAME ": VBoxUSBSolarisOpen: Failed to get device state for instance %d\n", instance));
         return ENXIO;
     }
@@ -925 +1034 @@
     {
         if (pState->Process == NIL_RTPROCESS)
-            LogRel((DEVICE_NAME ":VBoxUSBSolarisOpen No prior information about authorized process.\n"));
+            LogRel((DEVICE_NAME ": VBoxUSBSolarisOpen: No prior information about authorized process\n"));
         else
-            LogRel((DEVICE_NAME ":VBoxUSBSolarisOpen Process %u is already using this device instance.\n", pState->Process));
+            LogRel((DEVICE_NAME ": VBoxUSBSolarisOpen: Process %u is already using this device instance\n", pState->Process));
 
         mutex_exit(&pState->Mtx);
@@ -933 +1042 @@
     }
 
-    pState->fPoll = VBOXUSB_POLL_ON;
-
     mutex_exit(&pState->Mtx);
 
@@ -946 +1053 @@
 int VBoxUSBSolarisClose(dev_t Dev, int fFlag, int fType, cred_t *pCred)
 {
-    LogFunc((DEVICE_NAME ":VBoxUSBSolarisClose Dev=%d fFlag=%d fType=%d pCred=%p\n", Dev, fFlag, fType, pCred));
+    LogFunc((DEVICE_NAME ": VBoxUSBSolarisClose: Dev=%d fFlag=%d fType=%d pCred=%p\n", Dev, fFlag, fType, pCred));
 
     int instance = getminor((dev_t)Dev);
@@ -952 +1059 @@
     if (RT_UNLIKELY(!pState))
     {
-        LogRel((DEVICE_NAME ":VBoxUSBSolarisClose failed to get device state for instance %d\n", instance));
+        LogRel((DEVICE_NAME ": VBoxUSBSolarisClose: Failed to get device state for instance %d\n", instance));
         return ENXIO;
     }
 
     mutex_enter(&pState->Mtx);
-    pState->fPoll = VBOXUSB_POLL_OFF;
-    pState->Process = NIL_RTPROCESS;
+    pState->fPollPending  = false;
+    pState->Process       = NIL_RTPROCESS;
     mutex_exit(&pState->Mtx);
 
@@ -967 +1074 @@
 int VBoxUSBSolarisRead(dev_t Dev, struct uio *pUio, cred_t *pCred)
 {
-    LogFunc((DEVICE_NAME ":VBoxUSBSolarisRead\n"));
+    LogFunc((DEVICE_NAME ": VBoxUSBSolarisRead\n"));
     return ENOTSUP;
 }
@@ -974 +1081 @@
 int VBoxUSBSolarisWrite(dev_t Dev, struct uio *pUio, cred_t *pCred)
 {
-    LogFunc((DEVICE_NAME ":VBoxUSBSolarisWrite\n"));
+    LogFunc((DEVICE_NAME ": VBoxUSBSolarisWrite\n"));
     return ENOTSUP;
 }
@@ -981 +1088 @@
 int VBoxUSBSolarisPoll(dev_t Dev, short fEvents, int fAnyYet, short *pReqEvents, struct pollhead **ppPollHead)
 {
-    LogFunc((DEVICE_NAME ":VBoxUSBSolarisPoll Dev=%d fEvents=%d fAnyYet=%d pReqEvents=%p\n", Dev, fEvents, fAnyYet, pReqEvents));
+    LogFunc((DEVICE_NAME ": VBoxUSBSolarisPoll: Dev=%d fEvents=%d fAnyYet=%d pReqEvents=%p\n", Dev, fEvents, fAnyYet, pReqEvents));
 
     /*
@@ -990 +1097 @@
     if (RT_UNLIKELY(!pState))
     {
-        LogRel((DEVICE_NAME ":VBoxUSBSolarisPoll: no state data for %d\n", instance));
+        LogRel((DEVICE_NAME ": VBoxUSBSolarisPoll: No state data for %d\n", instance));
         return ENXIO;
     }
@@ -997 +1104 @@
 
     /*
-     * "fEvents" HAS to be POLLIN. We won't bother to test it. The caller
-     * must always requests input events. Disconnect event (POLLHUP) is invalid in "fEvents".
+     * Disconnect event (POLLHUP) is invalid in "fEvents".
      */
-    fEvents = 0;
-    if (pState->fPoll & VBOXUSB_POLL_DEV_UNPLUGGED)
-    {
-        fEvents |= POLLHUP;
-        pState->fPoll &= ~VBOXUSB_POLL_DEV_UNPLUGGED;
-    }
-
-    if (pState->fPoll & VBOXUSB_POLL_REAP_PENDING)
-    {
-        fEvents |= POLLIN;
-        pState->fPoll &= ~VBOXUSB_POLL_REAP_PENDING;
-    }
-
-    if (   !fEvents
-        && !fAnyYet)
-    {
-        *ppPollHead = &pState->PollHead;
-    }
-
-    *pReqEvents = fEvents;
+    if (pState->DevState == USB_DEV_DISCONNECTED)
+        *pReqEvents |= POLLHUP;
+    else if (pState->cLandedUrbs)
+        *pReqEvents |= POLLIN;
+    else
+    {
+        *pReqEvents = 0;
+        if (!fAnyYet)
+        {
+            *ppPollHead = &pState->PollHead;
+            pState->fPollPending = true;
+        }
+    }
 
     mutex_exit(&pState->Mtx);
@@ -1029 +1128 @@
 int VBoxUSBSolarisPower(dev_info_t *pDip, int Component, int Level)
 {
-    LogFunc((DEVICE_NAME ":VBoxUSBSolarisPower pDip=%p Component=%d Level=%d\n", pDip, Component, Level));
+    LogFunc((DEVICE_NAME ": VBoxUSBSolarisPower: pDip=%p Component=%d Level=%d\n", pDip, Component, Level));
 
     int instance = ddi_get_instance(pDip);
@@ -1035 +1134 @@
     if (RT_UNLIKELY(!pState))
     {
-        LogRel((DEVICE_NAME ":VBoxUSBSolarisPower Failed! missing state.\n"));
+        LogRel((DEVICE_NAME ": VBoxUSBSolarisPower: Failed! State Gone\n"));
         return DDI_FAILURE;
     }
@@ -1065 +1164 @@
                     pState->pPower->PowerLevel = USB_DEV_OS_PWR_OFF;
                     mutex_exit(&pState->Mtx);
-                    rc = usb_set_device_pwrlvl3(pDip);
+                    rc = USB_SUCCESS; /* usb_set_device_pwrlvl3(pDip); */
                     mutex_enter(&pState->Mtx);
                     break;
@@ -1077 +1176 @@
                     pState->pPower->PowerLevel = USB_DEV_OS_FULL_PWR;
                     mutex_exit(&pState->Mtx);
-                    rc = usb_set_device_pwrlvl0(pDip);
+                    rc = USB_SUCCESS; /* usb_set_device_pwrlvl0(pDip); */
                     mutex_enter(&pState->Mtx);
                     break;
@@ -1087 +1186 @@
         }
         else
-            Log((DEVICE_NAME ":USB_DEV_PWRSTATE_OK failed.\n"));
+            Log((DEVICE_NAME ": VBoxUSBSolarisPower: USB_DEV_PWRSTATE_OK failed\n"));
     }
     else
@@ -1108 +1207 @@
 int VBoxUSBSolarisIOCtl(dev_t Dev, int Cmd, intptr_t pArg, int Mode, cred_t *pCred, int *pVal)
 {
-/*    LogFunc((DEVICE_NAME ":VBoxUSBSolarisIOCtl Dev=%d Cmd=%d pArg=%p Mode=%d\n", Dev, Cmd, pArg)); */
+    /* LogFunc((DEVICE_NAME ": VBoxUSBSolarisIOCtl: Dev=%d Cmd=%d pArg=%p Mode=%d\n", Dev, Cmd, pArg)); */
 
     /*
@@ -1117 +1216 @@
     if (RT_UNLIKELY(!pState))
     {
-        LogRel((DEVICE_NAME ":VBoxUSBSolarisIOCtl: no state data for %d\n", instance));
+        LogRel((DEVICE_NAME ": VBoxUSBSolarisIOCtl: No state data for %d\n", instance));
         return EINVAL;
     }
@@ -1127 +1226 @@
     if (IOCPARM_LEN(Cmd) != sizeof(ReqWrap))
     {
-        LogRel((DEVICE_NAME ": VBoxUSBSolarisIOCtl: bad request %#x size=%d expected=%d\n", Cmd, IOCPARM_LEN(Cmd),
+        LogRel((DEVICE_NAME ": VBoxUSBSolarisIOCtl: Bad request %#x size=%d expected=%d\n", Cmd, IOCPARM_LEN(Cmd),
                 sizeof(ReqWrap)));
         return ENOTTY;
@@ -1135 +1234 @@
     if (RT_UNLIKELY(rc))
     {
-        LogRel((DEVICE_NAME ": VBoxUSBSolarisIOCtl: ddi_copyin failed to read header pArg=%p Cmd=%d. rc=%d.\n", pArg, Cmd, rc));
+        LogRel((DEVICE_NAME ": VBoxUSBSolarisIOCtl: ddi_copyin failed to read header pArg=%p Cmd=%d. rc=%d\n", pArg, Cmd, rc));
         return EINVAL;
     }
@@ -1141 +1240 @@
     if (ReqWrap.u32Magic != VBOXUSB_MAGIC)
     {
-        LogRel((DEVICE_NAME ": VBoxUSBSolarisIOCtl: bad magic %#x; pArg=%p Cmd=%d.\n", ReqWrap.u32Magic, pArg, Cmd));
+        LogRel((DEVICE_NAME ": VBoxUSBSolarisIOCtl: Bad magic %#x; pArg=%p Cmd=%d\n", ReqWrap.u32Magic, pArg, Cmd));
         return EINVAL;
     }
@@ -1147 +1246 @@
                     || ReqWrap.cbData > _1M*16))
     {
-        LogRel((DEVICE_NAME ": VBoxUSBSolarisIOCtl: bad size %#x; pArg=%p Cmd=%d.\n", ReqWrap.cbData, pArg, Cmd));
+        LogRel((DEVICE_NAME ": VBoxUSBSolarisIOCtl: Bad size %#x; pArg=%p Cmd=%d\n", ReqWrap.cbData, pArg, Cmd));
         return EINVAL;
     }
@@ -1157 +1256 @@
     if (RT_UNLIKELY(!pvBuf))
     {
-        LogRel((DEVICE_NAME ":VBoxUSBSolarisIOCtl: RTMemTmpAlloc failed to alloc %d bytes.\n", ReqWrap.cbData));
+        LogRel((DEVICE_NAME ": VBoxUSBSolarisIOCtl: RTMemTmpAlloc failed to alloc %d bytes\n", ReqWrap.cbData));
         return ENOMEM;
     }
@@ -1165 +1264 @@
     {
         RTMemTmpFree(pvBuf);
-        LogRel((DEVICE_NAME ":VBoxUSBSolarisIOCtl: ddi_copyin failed; pvBuf=%p pArg=%p Cmd=%d. rc=%d\n", pvBuf, pArg, Cmd, rc));
+        LogRel((DEVICE_NAME ": VBoxUSBSolarisIOCtl: ddi_copyin failed! pvBuf=%p pArg=%p Cmd=%d. rc=%d\n", pvBuf, pArg, Cmd, rc));
         return EFAULT;
     }
@@ -1172 +1271 @@
     {
         RTMemTmpFree(pvBuf);
-        LogRel((DEVICE_NAME ":VBoxUSBSolarisIOCtl: invalid request pvBuf=%p cbData=%d\n", pvBuf, ReqWrap.cbData));
+        LogRel((DEVICE_NAME ": VBoxUSBSolarisIOCtl: Invalid request! pvBuf=%p cbData=%d\n", pvBuf, ReqWrap.cbData));
         return EINVAL;
     }
@@ -1180 +1279 @@
      */
     size_t cbDataOut = 0;
-    rc = vboxUSBSolarisProcessIOCtl(Cmd, pState, Mode, &ReqWrap, pvBuf, &cbDataOut);
+    rc = vboxUsbSolarisProcessIOCtl(Cmd, pState, Mode, &ReqWrap, pvBuf, &cbDataOut);
     ReqWrap.rc = rc;
     rc = 0;
@@ -1186 +1285 @@
     if (RT_UNLIKELY(cbDataOut > ReqWrap.cbData))
     {
-        LogRel((DEVICE_NAME ":VBoxUSBSolarisIOCtl: too much output data %d expected %d Truncating!\n", cbDataOut,
+        LogRel((DEVICE_NAME ": VBoxUSBSolarisIOCtl: Too much output data %d expected %d Truncating!\n", cbDataOut,
                 ReqWrap.cbData));
         cbDataOut = ReqWrap.cbData;
@@ -1207 +1306 @@
             if (RT_UNLIKELY(rc))
             {
-                LogRel((DEVICE_NAME ":VBoxUSBSolarisIOCtl: ddi_copyout failed; pvBuf=%p pArg=%p Cmd=%d. rc=%d\n", pvBuf, pArg,
+                LogRel((DEVICE_NAME ": VBoxUSBSolarisIOCtl: ddi_copyout failed! pvBuf=%p pArg=%p Cmd=%d. rc=%d\n", pvBuf, pArg,
                         Cmd, rc));
                 rc = EFAULT;
@@ -1215 +1314 @@
     else
     {
-        LogRel((DEVICE_NAME ":VBoxUSBSolarisIOCtl: ddi_copyout(1)failed; pReqWrap=%p pArg=%p Cmd=%d. rc=%d\n", &ReqWrap, pArg,
+        LogRel((DEVICE_NAME ": VBoxUSBSolarisIOCtl: ddi_copyout(1)failed! pReqWrap=%p pArg=%p Cmd=%d. rc=%d\n", &ReqWrap, pArg,
                 Cmd, rc));
         rc = EFAULT;
@@ -1238 +1337 @@
  * @param   pcbDataOut          Where to store the IOCtl OUT data size.
  */
-LOCAL int vboxUSBSolarisProcessIOCtl(int iFunction, void *pvState, int Mode, PVBOXUSBREQ pUSBReq, void *pvBuf, size_t *pcbDataOut)
-{
-//    LogFunc((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl iFunction=%d pvState=%p pUSBReq=%p\n", iFunction, pvState, pUSBReq));
+LOCAL int vboxUsbSolarisProcessIOCtl(int iFunction, void *pvState, int Mode, PVBOXUSBREQ pUSBReq, void *pvBuf,
+                                     size_t *pcbDataOut)
+{
+    /* LogFunc((DEVICE_NAME ": vboxUsbSolarisProcessIOCtl: iFunction=%d pvState=%p pUSBReq=%p\n", iFunction, pvState, pUSBReq)); */
 
     AssertPtrReturn(pvState, VERR_INVALID_PARAMETER);
@@ -1251 +1351 @@
         if (cbData < (cbMin)) \
         { \
-            LogRel((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl: " mnemonic ": cbData=%#zx (%zu) min is %#zx (%zu)\n", \
+            LogRel((DEVICE_NAME ": vboxUsbSolarisProcessIOCtl: " mnemonic ": cbData=%#zx (%zu) min is %#zx (%zu)\n", \
                  cbData, cbData, (size_t)(cbMin), (size_t)(cbMin))); \
             return VERR_BUFFER_OVERFLOW; \
@@ -1257 +1357 @@
         if ((cbMin) != 0 && !VALID_PTR(pvBuf)) \
         { \
-            LogRel((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl: " mnemonic ": Invalid pointer %p\n", pvBuf)); \
+            LogRel((DEVICE_NAME ": vboxUsbSolarisProcessIOCtl: " mnemonic ": Invalid pointer %p\n", pvBuf)); \
             return VERR_INVALID_PARAMETER; \
         } \
@@ -1269 +1369 @@
 
             PVBOXUSBREQ_URB pUrbReq = (PVBOXUSBREQ_URB)pvBuf;
-            rc = vboxUSBSolarisSendURB(pState, pUrbReq, Mode);
+            rc = vboxUsbSolarisSendUrb(pState, pUrbReq, Mode);
             *pcbDataOut = 0;
-            Log((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl: SEND_URB returned %d\n", rc));
+            Log((DEVICE_NAME ": vboxUsbSolarisProcessIOCtl: SEND_URB returned %d\n", rc));
             break;
         }
@@ -1280 +1380 @@
 
             PVBOXUSBREQ_URB pUrbReq = (PVBOXUSBREQ_URB)pvBuf;
-            rc = vboxUSBSolarisReapURB(pState, pUrbReq, Mode);
+            rc = vboxUsbSolarisReapUrb(pState, pUrbReq, Mode);
             *pcbDataOut = sizeof(VBOXUSBREQ_URB);
-            Log((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl: REAP_URB returned %d\n", rc));
+            Log((DEVICE_NAME ": vboxUsbSolarisProcessIOCtl: REAP_URB returned %d\n", rc));
             break;
         }
@@ -1291 +1391 @@
 
             PVBOXUSBREQ_CLEAR_EP pClearEpReq = (PVBOXUSBREQ_CLEAR_EP)pvBuf;
-            rc = vboxUSBSolarisClearEndPoint(pState, pClearEpReq->bEndpoint);
+            rc = vboxUsbSolarisClearEndPoint(pState, pClearEpReq->bEndpoint);
             *pcbDataOut = 0;
-            Log((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl: CLEAR_EP returned %d\n", rc));
+            Log((DEVICE_NAME ": vboxUsbSolarisProcessIOCtl: CLEAR_EP returned %d\n", rc));
             break;
         }
@@ -1302 +1402 @@
 
             PVBOXUSBREQ_SET_CONFIG pSetCfgReq = (PVBOXUSBREQ_SET_CONFIG)pvBuf;
-            rc = vboxUSBSolarisSetConfig(pState, pSetCfgReq->bConfigValue);
+            rc = vboxUsbSolarisSetConfig(pState, pSetCfgReq->bConfigValue);
             *pcbDataOut = 0;
-            Log((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl: SET_CONFIG returned %d\n", rc));
+            Log((DEVICE_NAME ": vboxUsbSolarisProcessIOCtl: SET_CONFIG returned %d\n", rc));
             break;
         }
@@ -1313 +1413 @@
 
             PVBOXUSBREQ_SET_INTERFACE pSetInterfaceReq = (PVBOXUSBREQ_SET_INTERFACE)pvBuf;
-            rc = vboxUSBSolarisSetInterface(pState, pSetInterfaceReq->bInterface, pSetInterfaceReq->bAlternate);
+            rc = vboxUsbSolarisSetInterface(pState, pSetInterfaceReq->bInterface, pSetInterfaceReq->bAlternate);
             *pcbDataOut = 0;
-            Log((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl: SET_INTERFACE returned %d\n", rc));
+            Log((DEVICE_NAME ": vboxUsbSolarisProcessIOCtl: SET_INTERFACE returned %d\n", rc));
             break;
         }
@@ -1324 +1424 @@
 
             PVBOXUSBREQ_CLOSE_DEVICE pCloseDeviceReq = (PVBOXUSBREQ_CLOSE_DEVICE)pvBuf;
-            rc = vboxUSBSolarisCloseDevice(pState, pCloseDeviceReq->ResetLevel);
+            if (   pCloseDeviceReq->ResetLevel != VBOXUSB_RESET_LEVEL_REATTACH
+                || (Mode & FKIOCTL))
+            {
+                rc = vboxUsbSolarisCloseDevice(pState, pCloseDeviceReq->ResetLevel);
+            }
+            else
+            {
+                /* Userland IOCtls are not allowed to perform a reattach of the device. */
+                rc = VERR_NOT_SUPPORTED;
+            }
             *pcbDataOut = 0;
-            Log((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl: CLOSE_DEVICE returned %d\n", rc));
+            Log((DEVICE_NAME ": vboxUsbSolarisProcessIOCtl: CLOSE_DEVICE returned %d\n", rc));
             break;
         }
@@ -1335 +1444 @@
 
             PVBOXUSBREQ_ABORT_PIPE pAbortPipeReq = (PVBOXUSBREQ_ABORT_PIPE)pvBuf;
-            rc = vboxUSBSolarisAbortPipe(pState, pAbortPipeReq->bEndpoint);
+            rc = vboxUsbSolarisAbortPipe(pState, pAbortPipeReq->bEndpoint);
             *pcbDataOut = 0;
-            Log((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl: ABORT_PIPE returned %d\n", rc));
+            Log((DEVICE_NAME ": vboxUsbSolarisProcessIOCtl: ABORT_PIPE returned %d\n", rc));
             break;
         }
@@ -1346 +1455 @@
 
             PVBOXUSBREQ_GET_CONFIG pGetCfgReq = (PVBOXUSBREQ_GET_CONFIG)pvBuf;
-            rc = vboxUSBSolarisGetConfig(pState, &pGetCfgReq->bConfigValue);
+            rc = vboxUsbSolarisGetConfig(pState, &pGetCfgReq->bConfigValue);
             *pcbDataOut = sizeof(VBOXUSBREQ_GET_CONFIG);
-            Log((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl: GET_CONFIG returned %d\n", rc));
+            Log((DEVICE_NAME ": vboxUsbSolarisProcessIOCtl: GET_CONFIG returned %d\n", rc));
             break;
         }
@@ -1361 +1470 @@
             *pcbDataOut = sizeof(VBOXUSBREQ_GET_VERSION);
             rc = VINF_SUCCESS;
-            Log((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl: GET_VERSION returned %d\n", rc));
+            Log((DEVICE_NAME ": vboxUsbSolarisProcessIOCtl: GET_VERSION returned %d\n", rc));
             break;
         }
@@ -1367 +1476 @@
         default:
         {
-            LogRel((DEVICE_NAME ":solarisUSBProcessIOCtl: Unknown request %#x\n", iFunction));
+            LogRel((DEVICE_NAME ": vboxUsbSolarisProcessIOCtl: Unknown request %#x\n", iFunction));
             rc = VERR_NOT_SUPPORTED;
             *pcbDataOut = 0;
@@ -1380 +1489 @@
 
 /**
- * Initialize device power management functions.
+ * Initializes device power management.
  *
  * @param   pState          The USB device instance.
@@ -1386 +1495 @@
  * @returns VBox status code.
  */
-LOCAL int vboxUSBSolarisInitPower(vboxusb_state_t *pState)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisInitPower pState=%p\n", pState));
+LOCAL int vboxUsbSolarisInitPower(vboxusb_state_t *pState)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisInitPower: pState=%p\n", pState));
 
     int rc = usb_handle_remote_wakeup(pState->pDip, USB_REMOTE_WAKEUP_ENABLE);
     if (rc == USB_SUCCESS)
     {
-        vboxusb_power_t *pPower = RTMemAlloc(sizeof(vboxusb_power_t));
+        vboxusb_power_t *pPower = RTMemAllocZ(sizeof(vboxusb_power_t));
         if (RT_LIKELY(pPower))
         {
@@ -1413 +1522 @@
                 if (rc != DDI_SUCCESS)
                 {
-                    LogRel((DEVICE_NAME ":vboxUSBSolarisInitPower failed to raise power level usb(%#x,%#x).\n",
+                    LogRel((DEVICE_NAME ": vboxUsbSolarisInitPower: Failed to raise power level usb(%#x,%#x)\n",
                             pState->pDevDesc->dev_descr->idVendor, pState->pDevDesc->dev_descr->idProduct));
                 }
             }
             else
-                Log((DEVICE_NAME ":vboxUSBSolarisInitPower failed to create power components.\n"));
+                Log((DEVICE_NAME ": vboxUsbSolarisInitPower: Failed to create power components\n"));
 
             return VINF_SUCCESS;
@@ -1427 +1536 @@
     else
     {
-        Log((DEVICE_NAME ":vboxUSBSolarisInitPower failed to enable remote wakeup. No PM.\n"));
+        Log((DEVICE_NAME ": vboxUsbSolarisInitPower: Failed to enable remote wakeup, No PM!\n"));
         rc = VINF_SUCCESS;
     }
@@ -1436 +1545 @@
 
 /**
- * Destroy device power management functions.
+ * Destroys device power management.
  *
  * @param   pState          The USB device instance.
@@ -1443 +1552 @@
  * @returns VBox status code.
  */
-LOCAL void vboxUSBSolarisDestroyPower(vboxusb_state_t *pState)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisDestroyPower pState=%p\n", pState));
+LOCAL void vboxUsbSolarisDestroyPower(vboxusb_state_t *pState)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisDestroyPower: pState=%p\n", pState));
 
     if (pState->pPower)
     {
         mutex_exit(&pState->Mtx);
-        vboxUSBSolarisPowerBusy(pState);
+        vboxUsbSolarisPowerBusy(pState);
         mutex_enter(&pState->Mtx);
 
@@ -1460 +1569 @@
             rc = pm_raise_power(pState->pDip, 0 /* component */, USB_DEV_OS_FULL_PWR);
             if (rc != DDI_SUCCESS)
-                Log((DEVICE_NAME ":vboxUSBSolarisDestroyPower raising power failed! rc=%d\n", rc));
+                Log((DEVICE_NAME ": vboxUsbSolarisDestroyPower: Raising power failed! rc=%d\n", rc));
 
             rc = usb_handle_remote_wakeup(pState->pDip, USB_REMOTE_WAKEUP_DISABLE);
             if (rc != DDI_SUCCESS)
-                Log((DEVICE_NAME ":vboxUSBSolarisDestroyPower failed to disable remote wakeup.\n"));
+                Log((DEVICE_NAME ": vboxUsbSolarisDestroyPower: Failed to disable remote wakeup\n"));
         }
         else
@@ -1471 +1580 @@
         rc = pm_lower_power(pState->pDip, 0 /* component */, USB_DEV_OS_PWR_OFF);
         if (rc != DDI_SUCCESS)
-            Log((DEVICE_NAME ":vboxUSBSolarisDestroyPower lowering power failed! rc=%d\n", rc));
-
-        vboxUSBSolarisPowerIdle(pState);
+            Log((DEVICE_NAME ": vboxUsbSolarisDestroyPower: Lowering power failed! rc=%d\n", rc));
+
+        vboxUsbSolarisPowerIdle(pState);
         mutex_enter(&pState->Mtx);
         RTMemFree(pState->pPower);
@@ -1482 +1591 @@
 
 /**
- * Convert Solaris' USBA URB status to VBox's USB URB status.
+ * Converts Solaris' USBA URB status to VBox's USB URB status.
  *
  * @param   Status          Solaris USBA USB URB status.
@@ -1488 +1597 @@
  * @returns VBox USB URB status.
  */
-LOCAL inline VUSBSTATUS vboxUSBSolarisGetUrbStatus(usb_cr_t Status)
+LOCAL VUSBSTATUS vboxUsbSolarisGetUrbStatus(usb_cr_t Status)
 {
     switch (Status)
@@ -1522 +1631 @@
 
 /**
- * Convert Solaris' USBA error code to VBox's error code.
+ * Converts Solaris' USBA error code to VBox's error code.
  *
  * @param   UsbRc           Solaris USBA error code.
@@ -1528 +1637 @@
  * @returns VBox error code.
  */
-static inline int vboxUSBSolarisToVBoxRC(int UsbRc)
+static int vboxUsbSolarisToVBoxRC(int UsbRc)
 {
     switch (UsbRc)
@@ -1557 +1666 @@
 
 /**
- * Convert Solaris' USBA device state to VBox's error code.
+ * Converts Solaris' USBA device state to VBox's error code.
  *
  * @param   uDeviceState        The USB device state to convert.
@@ -1563 +1672 @@
  * @returns VBox error code.
  */
-static inline int vboxUSBSolarisDeviceState(uint8_t uDeviceState)
+static int vboxUsbSolarisDeviceState(uint8_t uDeviceState)
 {
     switch (uDeviceState)
@@ -1577 +1686 @@
 
 /**
- * Check if the device is a USB device.
+ * Checks if the device is a USB device.
  *
  * @param   pDip            Pointer to this device info. structure.
@@ -1583 +1692 @@
  * @returns If this is really a USB device returns true, otherwise false.
  */
-LOCAL bool vboxUSBSolarisIsUSBDevice(dev_info_t *pDip)
+LOCAL bool vboxUsbSolarisIsUSBDevice(dev_info_t *pDip)
 {
     int rc = DDI_FAILURE;
@@ -1597 +1706 @@
         while (cCompatible--)
         {
-            Log((DEVICE_NAME ":vboxUSBSolarisIsUSBDevice compatible[%d]=%s\n", cCompatible, ppszCompatible[cCompatible]));
+            Log((DEVICE_NAME ": vboxUsbSolarisIsUSBDevice: Compatible[%d]=%s\n", cCompatible, ppszCompatible[cCompatible]));
             if (!strncmp(ppszCompatible[cCompatible], "usb", 3))
             {
-                Log((DEVICE_NAME ":vboxUSBSolarisIsUSBDevice verified device as USB. pszCompatible=%s\n",
+                Log((DEVICE_NAME ": vboxUsbSolarisIsUSBDevice: Verified device as USB. pszCompatible=%s\n",
                      ppszCompatible[cCompatible]));
                 ddi_prop_free(ppszCompatible);
@@ -1611 +1720 @@
     }
     else
-        Log((DEVICE_NAME ":vboxUSBSolarisIsUSBDevice USB property lookup failed. rc=%d\n", rc));
+        Log((DEVICE_NAME ": vboxUsbSolarisIsUSBDevice: USB property lookup failed, rc=%d\n", rc));
 
     /*
@@ -1625 +1734 @@
             while (cCompatible--)
             {
-                Log((DEVICE_NAME ":vboxUSBSolarisIsUSBDevice parent compatible[%d]=%s\n", cCompatible,
+                Log((DEVICE_NAME ": vboxUsbSolarisIsUSBDevice: Parent compatible[%d]=%s\n", cCompatible,
                      ppszCompatible[cCompatible]));
                 if (!strncmp(ppszCompatible[cCompatible], "usb", 3))
                 {
-                    Log((DEVICE_NAME ":vboxUSBSolarisIsUSBDevice verified device as USB. parent pszCompatible=%s\n",
+                    Log((DEVICE_NAME ": vboxUsbSolarisIsUSBDevice: Verified device as USB. parent pszCompatible=%s\n",
                             ppszCompatible[cCompatible]));
                     ddi_prop_free(ppszCompatible);
@@ -1640 +1749 @@
         }
         else
-            Log((DEVICE_NAME ":vboxUSBSolarisIsUSBDevice USB parent property lookup failed. rc=%d\n", rc));
+            Log((DEVICE_NAME ": vboxUsbSolarisIsUSBDevice: USB parent property lookup failed. rc=%d\n", rc));
     }
     else
-        Log((DEVICE_NAME ":vboxUSBSolarisIsUSBDevice failed to obtain parent device for property lookup.\n"));
+        Log((DEVICE_NAME ": vboxUsbSolarisIsUSBDevice: Failed to obtain parent device for property lookup\n"));
 
     return false;
@@ -1650 +1759 @@
 
 /**
- * Submit a URB.
+ * Submits a URB.
  *
  * @param   pState          The USB device instance.
@@ -1658 +1767 @@
  * @returns VBox error code.
  */
-LOCAL int vboxUSBSolarisSendURB(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq, int Mode)
-{
-    uchar_t EndPtIndex = usb_get_ep_index(pUrbReq->bEndpoint);
-    vboxusb_ep_t *pEp = &pState->aEps[EndPtIndex];
+LOCAL int vboxUsbSolarisSendUrb(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq, int Mode)
+{
+    int iEpIndex = VBOXUSB_GET_EP_INDEX(pUrbReq->bEndpoint);
+    Assert(iEpIndex >= 0 && iEpIndex < RT_ELEMENTS(pState->aEps));
+    vboxusb_ep_t *pEp = &pState->aEps[iEpIndex];
     AssertPtrReturn(pEp, VERR_INVALID_POINTER);
-
-    /* LogFunc((DEVICE_NAME ":vboxUSBSolarisSendUrb pState=%p pUrbReq=%p bEndpoint=%#x[%d] enmDir=%#x enmType=%#x cbData=%d pvData=%p\n",
-            pState, pUrbReq, pUrbReq->bEndpoint, EndPtIndex, pUrbReq->enmDir, pUrbReq->enmType, pUrbReq->cbData, pUrbReq->pvData)); */
+    Assert(pUrbReq);
+
+#if 0
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisSendUrb: pState=%p pUrbReq=%p bEndpoint=%#x[%d] enmDir=%#x enmType=%#x "
+             "cbData=%d pvData=%p\n", pState, pUrbReq, pUrbReq->bEndpoint, iEpIndex, pUrbReq->enmDir,
+             pUrbReq->enmType, pUrbReq->cbData, pUrbReq->pvData));
+#endif
 
     if (RT_UNLIKELY(!pUrbReq->pvData))
     {
-        LogRel((DEVICE_NAME ":vboxUSBSolarisSendUrb Invalid request. No data.\n"));
+        LogRel((DEVICE_NAME ": vboxUsbSolarisSendUrb: Invalid request - No data\n"));
         return VERR_INVALID_POINTER;
     }
@@ -1685 +1799 @@
         if (RT_UNLIKELY(!pMsg))
         {
-            LogRel((DEVICE_NAME ":vboxUSBSolarisSendUrb: failed to allocate %d bytes\n", pUrbReq->cbData));
+            LogRel((DEVICE_NAME ": vboxUsbSolarisSendUrb: Failed to allocate %u bytes\n", pUrbReq->cbData));
             return VERR_NO_MEMORY;
         }
@@ -1692 +1806 @@
         if (RT_UNLIKELY(rc))
         {
-            LogRel((DEVICE_NAME ":vboxUSBSolarisSendUrb: ddi_copyin failed! rc=%d\n", rc));
+            LogRel((DEVICE_NAME ": vboxUsbSolarisSendUrb: ddi_copyin failed! rc=%d\n", rc));
             freemsg(pMsg);
             return VERR_NO_MEMORY;
@@ -1701 +1815 @@
 
     mutex_enter(&pState->Mtx);
-    rc = vboxUSBSolarisDeviceState(pState->DevState);
-
-    if (pState->fClosed)    /* Required for Isoc. IN Xfers which don't Xfer through the pipe after polling starts */
+    rc = vboxUsbSolarisDeviceState(pState->DevState);
+    if (!pState->fDefaultPipeOpen)    /* Required for Isoc. IN Xfers which don't Xfer through the pipe after polling starts */
         rc = VERR_VUSB_DEVICE_NOT_ATTACHED;
-
     if (RT_SUCCESS(rc))
     {
@@ -1711 +1823 @@
          * Open the pipe if needed.
          */
-        rc = vboxUSBSolarisOpenPipe(pState, pEp);
+        rc = vboxUsbSolarisOpenPipe(pState, pEp);
         if (RT_UNLIKELY(RT_FAILURE(rc)))
         {
             mutex_exit(&pState->Mtx);
             freemsg(pMsg);
-            LogRel((DEVICE_NAME ":vboxUSBSolarisSendUrb OpenPipe failed. pState=%p pUrbReq=%p bEndpoint=%#x enmDir=%#x "
+            LogRel((DEVICE_NAME ": vboxUsbSolarisSendUrb: OpenPipe failed! pState=%p pUrbReq=%p bEndpoint=%#x enmDir=%#x "
                     "enmType=%#x cbData=%d pvData=%p rc=%d\n", pState, pUrbReq, pUrbReq->bEndpoint, pUrbReq->enmDir,
                     pUrbReq->enmType, pUrbReq->cbData, pUrbReq->pvData, rc));
@@ -1726 +1838 @@
         vboxusb_urb_t *pUrb = NULL;
         if (   pUrbReq->enmType == VUSBXFERTYPE_ISOC
-            && pUrbReq->enmDir == VUSBDIRECTION_IN)
-            pUrb = vboxUSBSolarisGetIsocInURB(pState, pUrbReq);
+            && pUrbReq->enmDir  == VUSBDIRECTION_IN)
+            pUrb = vboxUsbSolarisGetIsocInUrb(pState, pUrbReq);
         else
-            pUrb = vboxUSBSolarisQueueURB(pState, pUrbReq, pMsg);
+            pUrb = vboxUsbSolarisQueueUrb(pState, pUrbReq, pMsg);
 
         if (RT_LIKELY(pUrb))
@@ -1737 +1849 @@
                 case VUSBXFERTYPE_MSG:
                 {
-                    rc = vboxUSBSolarisCtrlXfer(pState, pEp, pUrb);
+                    rc = vboxUsbSolarisCtrlXfer(pState, pEp, pUrb);
                     break;
                 }
@@ -1743 +1855 @@
                 case VUSBXFERTYPE_BULK:
                 {
-                    rc = vboxUSBSolarisBulkXfer(pState, pEp, pUrb);
+                    rc = vboxUsbSolarisBulkXfer(pState, pEp, pUrb);
                     break;
                 }
@@ -1749 +1861 @@
                 case VUSBXFERTYPE_INTR:
                 {
-                    rc = vboxUSBSolarisIntrXfer(pState, pEp, pUrb);
+                    rc = vboxUsbSolarisIntrXfer(pState, pEp, pUrb);
                     break;
                 }
@@ -1755 +1867 @@
                 case VUSBXFERTYPE_ISOC:
                 {
-                    rc = vboxUSBSolarisIsocXfer(pState, pEp, pUrb);
+                    rc = vboxUsbSolarisIsocXfer(pState, pEp, pUrb);
                     break;
                 }
@@ -1761 +1873 @@
                 default:
                 {
+                    LogRelMax(5, (DEVICE_NAME ": vboxUsbSolarisSendUrb: URB type unsupported %d\n", pUrb->enmType));
                     rc = VERR_NOT_SUPPORTED;
                     break;
@@ -1768 +1881 @@
             if (RT_FAILURE(rc))
             {
-                /** @todo We share the state mutex for protecting concurrent accesses to both
-                 *        the inflight URB list as well as pUrb->pMsg (data). Probably make this
-                 *        more fine grained later by having a different mutex for the URB if
-                 *        it's really worth the trouble. */
                 mutex_enter(&pState->Mtx);
-                if (pUrb->pMsg)
-                {
-                    freemsg(pUrb->pMsg);
-                    pUrb->pMsg = NULL;
-                }
+                freemsg(pUrb->pMsg);
+                pUrb->pMsg = NULL;
+                pMsg = NULL;
 
                 if (   pUrb->enmType == VUSBXFERTYPE_ISOC
@@ -1787 +1894 @@
                 else
                 {
-                    pUrb->pMsg = NULL;
+                    /*
+                     * Xfer failed, move URB back to the free list.
+                     */
+                    list_remove(&pState->hInflightUrbs, pUrb);
+                    Assert(pState->cInflightUrbs > 0);
+                    --pState->cInflightUrbs;
+
                     pUrb->enmState = VBOXUSB_URB_STATE_FREE;
+                    Assert(!pUrb->pMsg);
+                    list_insert_head(&pState->hFreeUrbs, pUrb);
+                    ++pState->cFreeUrbs;
                 }
                 mutex_exit(&pState->Mtx);
@@ -1795 +1911 @@
         else
         {
-            LogRel((DEVICE_NAME ":vboxUSBSolarisSendUrb failed to queue URB.\n"));
+            LogRel((DEVICE_NAME ": vboxUsbSolarisSendUrb: Failed to queue URB\n"));
             rc = VERR_NO_MEMORY;
-        }
-
-        if (   RT_FAILURE(rc)
-            && pUrb)
-        {
-            if (   pUrb->enmType != VUSBXFERTYPE_ISOC
-                || pUrb->enmDir  != VUSBDIRECTION_IN)
-            {
-                mutex_enter(&pState->Mtx);
-                pState->cInflightUrbs--;
-                mutex_exit(&pState->Mtx);
-            }
+            freemsg(pMsg);
         }
     }
@@ -1822 +1927 @@
 
 /**
- * Reap a completed/error'd URB.
+ * Reaps a completed URB.
  *
  * @param   pState          The USB device instance.
@@ -1830 +1935 @@
  * @returns VBox error code.
  */
-LOCAL int vboxUSBSolarisReapURB(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq, int Mode)
-{
-//    LogFunc((DEVICE_NAME ":vboxUSBSolarisReapUrb pState=%p pUrbReq=%p\n", pState, pUrbReq));
+LOCAL int vboxUsbSolarisReapUrb(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq, int Mode)
+{
+    /* LogFunc((DEVICE_NAME ": vboxUsbSolarisReapUrb: pState=%p pUrbReq=%p\n", pState, pUrbReq)); */
 
     AssertPtrReturn(pUrbReq, VERR_INVALID_POINTER);
@@ -1838 +1943 @@
     int rc = VINF_SUCCESS;
     mutex_enter(&pState->Mtx);
-    rc = vboxUSBSolarisDeviceState(pState->DevState);
-    if (pState->fClosed)
+    rc = vboxUsbSolarisDeviceState(pState->DevState);
+    if (!pState->fDefaultPipeOpen)
         rc = VERR_VUSB_DEVICE_NOT_ATTACHED;
     if (RT_SUCCESS(rc))
     {
         vboxusb_urb_t *pUrb = list_remove_head(&pState->hLandedUrbs);
+        if (pUrb)
+        {
+            Assert(pState->cLandedUrbs > 0);
+            --pState->cLandedUrbs;
+        }
 
         /*
@@ -1860 +1970 @@
             pUrbReq->enmDir    = pUrb->enmDir;
             pUrbReq->enmStatus = pUrb->enmStatus;
+            pUrbReq->pvData    = (void *)pUrb->pvDataR3;
+            pUrbReq->cbData    = pUrb->cbDataR3;
 
             if (RT_LIKELY(pUrb->pMsg))
             {
                 /*
-                 * Chain copy the message back into the user buffer.
+                 * Copy the message back into the user buffer.
                  */
                 if (RT_LIKELY(pUrb->pvDataR3 != NIL_RTR3PTR))
                 {
-                    size_t cbData = RT_MIN(msgdsize(pUrb->pMsg), pUrb->cbDataR3);
+                    Assert(!pUrb->pMsg->b_cont);      /* We really should have a single message block always. */
+                    size_t cbData = RT_MIN(MBLKL(pUrb->pMsg), pUrb->cbDataR3);
                     pUrbReq->cbData = cbData;
-                    pUrbReq->pvData = (void *)pUrb->pvDataR3;
-
-                    /*
-                     * Paranoia: we should have a single message block almost always.
-                     */
-                    if (RT_LIKELY(   !pUrb->pMsg->b_cont
-                                  && cbData))
+
+                    if (RT_LIKELY(cbData))
                     {
                         rc = ddi_copyout(pUrb->pMsg->b_rptr, (void *)pUrbReq->pvData, cbData, Mode);
                         if (RT_UNLIKELY(rc))
                         {
-                            LogRel((DEVICE_NAME ":vboxUSBSolarisReapUrb ddi_copyout failed! rc=%d\n", rc));
+                            LogRel((DEVICE_NAME ": vboxUsbSolarisReapUrb: ddi_copyout failed! rc=%d\n", rc));
                             pUrbReq->enmStatus = VUSBSTATUS_INVALID;
                         }
                     }
-                    else
-                    {
-                        RTR3PTR pvDataR3 = pUrb->pvDataR3;
-                        mblk_t *pMsg = pUrb->pMsg;
-                        while (pMsg)
-                        {
-                            size_t cbMsg = MBLKL(pMsg);
-                            if (cbMsg > 0)
-                            {
-                                rc = ddi_copyout(pMsg->b_rptr, (void *)pvDataR3, cbMsg, Mode);
-                                if (RT_UNLIKELY(rc != 0))
-                                {
-                                    LogRel((DEVICE_NAME ":vboxUSBSolarisReapUrb ddi_copyout (2) failed! rc=%d\n", rc));
-                                    pUrbReq->enmStatus = VUSBSTATUS_INVALID;
-                                    break;
-                                }
-                            }
-
-                            pMsg = pMsg->b_cont;
-                            pvDataR3 += cbMsg;
-                            if ((pvDataR3 - pUrb->pvDataR3) >= cbData)
-                                break;
-                        }
-                    }
-
-                    Log((DEVICE_NAME ":vboxUSBSolarisReapUrb pvUrbR3=%p pvDataR3=%p cbData=%d\n", pUrbReq->pvUrbR3,
+
+                    Log((DEVICE_NAME ": vboxUsbSolarisReapUrb: pvUrbR3=%p pvDataR3=%p cbData=%d\n", pUrbReq->pvUrbR3,
                          pUrbReq->pvData, pUrbReq->cbData));
                 }
@@ -1917 +2001 @@
                     pUrbReq->cbData = 0;
                     rc = VERR_INVALID_POINTER;
-                    Log((DEVICE_NAME ":vboxUSBSolarisReapUrb missing pvDataR3!!\n"));
+                    LogRel((DEVICE_NAME ": vboxUsbSolarisReapUrb: Missing pvDataR3!!\n"));
                 }
 
                 /*
-                 * Free buffer allocated in VBOXUSB_IOCTL_SEND_URB.
+                 * Free buffer allocated in vboxUsbSolarisSendUrb or vboxUsbSolaris[Ctrl|Bulk|Intr]Xfer().
                  */
                 freemsg(pUrb->pMsg);
@@ -1928 +2012 @@
             else
             {
-                if (pUrb->enmType == VUSBXFERTYPE_ISOC)
+                if (   pUrb->enmType == VUSBXFERTYPE_ISOC
+                    && pUrb->enmDir == VUSBDIRECTION_IN)
                 {
-                    if (pUrb->enmDir == VUSBDIRECTION_OUT)
-                        pUrbReq->cbData = pUrb->cbDataR3;
-                    else
-                    {
-                        pUrbReq->enmStatus = VUSBSTATUS_INVALID;
-                        pUrbReq->cbData = 0;
-                    }
-                }
-                else
-                {
-                    Log((DEVICE_NAME ":vboxUSBSolarisReapUrb missing message.\n"));
+                    pUrbReq->enmStatus = VUSBSTATUS_INVALID;
                     pUrbReq->cbData = 0;
                 }
@@ -1970 +2045 @@
             {
                 /*
-                 * Add URB back to the head of the free/inflight list.
+                 * Add URB back to the free list.
                  */
+                Assert(!pUrb->pMsg);
                 pUrb->cbDataR3 = 0;
                 pUrb->pvDataR3 = NIL_RTR3PTR;
                 pUrb->enmState = VBOXUSB_URB_STATE_FREE;
                 mutex_enter(&pState->Mtx);
-                list_insert_head(&pState->hUrbs, pUrb);
+                list_insert_head(&pState->hFreeUrbs, pUrb);
+                ++pState->cFreeUrbs;
                 mutex_exit(&pState->Mtx);
             }
         }
         else
+        {
             pUrbReq->pvUrbR3 = NULL;
+            pUrbReq->cbData  = 0;
+            pUrbReq->pvData  = NULL;
+            pUrbReq->enmStatus = VUSBSTATUS_INVALID;
+        }
     }
     else
@@ -1991 +2073 @@
 
 /**
- * Clear a pipe (CLEAR_FEATURE).
+ * Clears a pipe (CLEAR_FEATURE).
  *
  * @param   pState          The USB device instance.
@@ -1998 +2080 @@
  * @returns VBox error code.
  */
-LOCAL int vboxUSBSolarisClearEndPoint(vboxusb_state_t *pState, uint8_t bEndpoint)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisClearEndPoint pState=%p bEndpoint=%#x\n", pState, bEndpoint));
-
-    /*
-     * Serialize access: single threaded per Endpoint, one request at a time.
-     */
+LOCAL int vboxUsbSolarisClearEndPoint(vboxusb_state_t *pState, uint8_t bEndpoint)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisClearEndPoint: pState=%p bEndpoint=%#x\n", pState, bEndpoint));
+
     mutex_enter(&pState->Mtx);
-    int rc = vboxUSBSolarisDeviceState(pState->DevState);
+    int rc = vboxUsbSolarisDeviceState(pState->DevState);
     if (RT_SUCCESS(rc))
     {
-        uchar_t EndPtIndex = usb_get_ep_index(bEndpoint);
-        vboxusb_ep_t *pEp = &pState->aEps[EndPtIndex];
+        int iEpIndex = VBOXUSB_GET_EP_INDEX(bEndpoint);
+        Assert(iEpIndex >= 0 && iEpIndex < RT_ELEMENTS(pState->aEps));
+        vboxusb_ep_t *pEp = &pState->aEps[iEpIndex];
         if (RT_LIKELY(pEp))
         {
@@ -2019 +2099 @@
             {
                 mutex_exit(&pState->Mtx);
-#if 0
-                /*
-                 * Asynchronous clear pipe.
-                 */
-                rc = usb_clr_feature(pState->pDip, USB_DEV_REQ_RCPT_EP, USB_EP_HALT, bEndpoint,
-                                        USB_FLAGS_NOSLEEP, /* Asynchronous */
-                                        NULL,              /* Completion callback */
-                                        NULL);             /* Exception callback */
-#endif
+
                 /*
                  * Synchronous reset pipe.
@@ -2038 +2110 @@
                 mutex_enter(&pState->Mtx);
 
-                Log((DEVICE_NAME ":vboxUSBSolarisClearEndPoint bEndpoint=%#x[%d] returns %d\n", bEndpoint, EndPtIndex, rc));
+                Log((DEVICE_NAME ": vboxUsbSolarisClearEndPoint: bEndpoint=%#x[%d] returns %d\n", bEndpoint, iEpIndex, rc));
 
                 rc = VINF_SUCCESS;
@@ -2044 +2116 @@
             else
             {
-                Log((DEVICE_NAME ":vboxUSBSolarisClearEndPoint not opened to be cleared. Faking success. bEndpoint=%#x.\n",
+                Log((DEVICE_NAME ": vboxUsbSolarisClearEndPoint: Not opened to be cleared. Faking success. bEndpoint=%#x\n",
                      bEndpoint));
                 rc = VINF_SUCCESS;
@@ -2051 +2123 @@
         else
         {
-            LogRel((DEVICE_NAME ":vboxUSBSolarisClearEndPoint Endpoint missing!! bEndpoint=%#x EndPtIndex=%d.\n", bEndpoint,
-                    EndPtIndex));
+            LogRel((DEVICE_NAME ": vboxUsbSolarisClearEndPoint: Endpoint missing! bEndpoint=%#x[%d]\n", bEndpoint, iEpIndex));
             rc = VERR_GENERAL_FAILURE;
         }
     }
     else
-        Log((DEVICE_NAME ":vboxUSBSolarisClearEndPoint device state=%d not online.\n", pState->DevState));
+        Log((DEVICE_NAME ": vboxUsbSolarisClearEndPoint: Device not online, state=%d\n", pState->DevState));
 
     mutex_exit(&pState->Mtx);
@@ -2065 +2136 @@
 
 /**
- * Set configuration (SET_CONFIGURATION)
+ * Sets configuration (SET_CONFIGURATION)
  *
  * @param   pState          The USB device instance.
- * @param   bCfgValue       The Configuration value.
+ * @param   bConfig         The Configuration.
  *
  * @returns VBox error code.
  */
-LOCAL int vboxUSBSolarisSetConfig(vboxusb_state_t *pState, uint8_t bCfgValue)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisSetConfig pState=%p bCfgValue=%#x\n", pState, bCfgValue));
-
-    /*
-     * Serialize access: single threaded per Endpoint, one request at a time.
-     */
+LOCAL int vboxUsbSolarisSetConfig(vboxusb_state_t *pState, uint8_t bConfig)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisSetConfig: pState=%p bConfig=%u\n", pState, bConfig));
+
     mutex_enter(&pState->Mtx);
-    int rc = vboxUSBSolarisDeviceState(pState->DevState);
+    int rc = vboxUsbSolarisDeviceState(pState->DevState);
     if (RT_SUCCESS(rc))
     {
-        vboxUSBSolarisCloseAllPipes(pState, false /* ControlPipe */);
-        int iCfgIndex = vboxUSBSolarisGetConfigIndex(pState, bCfgValue);
-
-        if (iCfgIndex >= 0)
+        vboxUsbSolarisCloseAllPipes(pState, false /* ControlPipe */);
+        int iCfgIndex = vboxUsbSolarisGetConfigIndex(pState, bConfig);
+
+        if (   iCfgIndex >= 0
+            && iCfgIndex < pState->pDevDesc->dev_n_cfg)
         {
             /*
@@ -2097 +2166 @@
             if (rc == USB_SUCCESS)
             {
-                pState->fRestoreCfg = true;
-                vboxUSBSolarisInitEndPointsForConfig(pState, iCfgIndex);
+                int rc2 = vboxUsbSolarisInitEpsForCfg(pState);
+                AssertRC(rc2); NOREF(rc2);
                 rc = VINF_SUCCESS;
             }
             else
             {
-                LogRel((DEVICE_NAME ":vboxUSBSolarisSetConfig usb_set_cfg failed for iCfgIndex=%#x bCfgValue=%#x rc=%d\n",
-                            iCfgIndex, bCfgValue, rc));
-                rc = vboxUSBSolarisToVBoxRC(rc);
+                LogRel((DEVICE_NAME ": vboxUsbSolarisSetConfig: usb_set_cfg failed for iCfgIndex=%#x bConfig=%u rc=%d\n",
+                            iCfgIndex, bConfig, rc));
+                rc = vboxUsbSolarisToVBoxRC(rc);
             }
         }
         else
         {
-            LogRel((DEVICE_NAME ":vboxUSBSolarisSetConfig invalid iCfgIndex=%d bCfgValue=%#x\n", iCfgIndex, bCfgValue));
-            rc = VERR_INVALID_HANDLE;
+            LogRel((DEVICE_NAME ": vboxUsbSolarisSetConfig: Invalid iCfgIndex=%d bConfig=%u\n", iCfgIndex, bConfig));
+            rc = VERR_OUT_OF_RANGE;
         }
     }
@@ -2122 +2191 @@
 
 /**
- * Get configuration (GET_CONFIGURATION)
+ * Gets configuration (GET_CONFIGURATION)
  *
  * @param   pState          The USB device instance.
- * @param   pCfgValue       Where to store the configuration value.
+ * @param   pbConfig        Where to store the Configuration.
  *
  * @returns VBox error code.
  */
-LOCAL int vboxUSBSolarisGetConfig(vboxusb_state_t *pState, uint8_t *pCfgValue)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisGetConfig pState=%p pCfgValue=%p\n", pState, pCfgValue));
-    AssertPtrReturn(pCfgValue, VERR_INVALID_POINTER);
-
-    /*
-     * Solaris keeps the currently active configuration for the first time. Thus for the first request
-     * we simply pass the cached configuration back to the user.
-     */
-    if (!pState->fGetCfgReqDone)
-    {
-        pState->fGetCfgReqDone = true;
-        AssertPtrReturn(pState->pDevDesc, VERR_GENERAL_FAILURE);
-        usb_cfg_data_t *pCurrCfg = pState->pDevDesc->dev_curr_cfg;
-        if (pCurrCfg)
-        {
-            *pCfgValue = pCurrCfg->cfg_descr.bConfigurationValue;
-            Log((DEVICE_NAME ":vboxUSBSolarisGetConfig cached config returned. CfgValue=%d\n", *pCfgValue));
-            return VINF_SUCCESS;
-        }
-    }
+LOCAL int vboxUsbSolarisGetConfig(vboxusb_state_t *pState, uint8_t *pbConfig)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisGetConfig: pState=%p pbConfig=%p\n", pState, pbConfig));
+    AssertPtrReturn(pbConfig, VERR_INVALID_POINTER);
 
     /*
      * Get Config synchronously.
      */
-    uint_t bCfgValue;
-    int rc = usb_get_cfg(pState->pDip, &bCfgValue, USB_FLAGS_SLEEP);
+    uint_t bConfig;
+    int rc = usb_get_cfg(pState->pDip, &bConfig, USB_FLAGS_SLEEP);
     if (RT_LIKELY(rc == USB_SUCCESS))
     {
-        *pCfgValue = bCfgValue;
+        *pbConfig = bConfig;
         rc = VINF_SUCCESS;
     }
     else
     {
-        LogRel((DEVICE_NAME ":vboxUSBSolarisGetConfig failed. rc=%d\n", rc));
-        rc = vboxUSBSolarisToVBoxRC(rc);
-    }
-
-    Log((DEVICE_NAME ":vboxUSBSolarisGetConfig returns %d CfgValue=%d\n", rc, *pCfgValue));
+        LogRel((DEVICE_NAME ": vboxUsbSolarisGetConfig: Failed, rc=%d\n", rc));
+        rc = vboxUsbSolarisToVBoxRC(rc);
+    }
+
+    Log((DEVICE_NAME ": vboxUsbSolarisGetConfig: Returns %d bConfig=%u\n", rc, *pbConfig));
     return rc;
 }
@@ -2173 +2225 @@
 
 /**
- * Set interface (SET_INTERFACE)
+ * Sets interface (SET_INTERFACE) and alternate.
  *
  * @param   pState          The USB device instance.
- * @param   uInterface      The Interface number.
- * @param   uAlt            The Alternate setting number.
+ * @param   bIf             The Interface.
+ * @param   bAlt            The Alternate setting.
  *
  * @returns VBox error code.
  */
-LOCAL int vboxUSBSolarisSetInterface(vboxusb_state_t *pState, uint8_t uInterface, uint8_t uAlt)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisSetInterface pState=%p uInterface=%#x uAlt=%#x\n", pState, uInterface, uAlt));
-
-    /*
-     * Serialize access: single threaded per Endpoint, one request at a time.
-     */
+LOCAL int vboxUsbSolarisSetInterface(vboxusb_state_t *pState, uint8_t bIf, uint8_t bAlt)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisSetInterface: pState=%p bIf=%#x bAlt=%#x\n", pState, bIf, bAlt));
+
     mutex_enter(&pState->Mtx);
-    int rc = vboxUSBSolarisDeviceState(pState->DevState);
+    int rc = vboxUsbSolarisDeviceState(pState->DevState);
     if (RT_SUCCESS(rc))
     {
-        vboxUSBSolarisCloseAllPipes(pState, false /* ControlPipe */);
-
         /*
          * Set Interface & Alt setting synchronously.
          */
         mutex_exit(&pState->Mtx);
-        rc = usb_set_alt_if(pState->pDip, uInterface, uAlt, USB_FLAGS_SLEEP, NULL /* callback */, NULL /* callback data */);
+        rc = usb_set_alt_if(pState->pDip, bIf, bAlt, USB_FLAGS_SLEEP, NULL /* callback */, NULL /* callback data */);
         mutex_enter(&pState->Mtx);
 
         if (rc == USB_SUCCESS)
         {
-            vboxUSBSolarisInitEndPointsForInterfaceAlt(pState, uInterface, uAlt);
+            Log((DEVICE_NAME ": vboxUsbSolarisSetInterface: Success, bIf=%#x bAlt=%#x\n", bIf, bAlt, rc));
+            int rc2 = vboxUsbSolarisInitEpsForIfAlt(pState, bIf, bAlt);
+            AssertRC(rc2); NOREF(rc2);
             rc = VINF_SUCCESS;
         }
         else
         {
-            LogRel((DEVICE_NAME ":vboxUSBSolarisSetInterface usb_set_alt_if failed for uInterface=%#x bAlt=%#x rc=%d\n",
-                        uInterface, uAlt, rc));
-            rc = vboxUSBSolarisToVBoxRC(rc);
+            LogRel((DEVICE_NAME ": vboxUsbSolarisSetInterface: usb_set_alt_if failed for bIf=%#x bAlt=%#x rc=%d\n", bIf, bAlt, rc));
+            rc = vboxUsbSolarisToVBoxRC(rc);
         }
     }
@@ -2221 +2269 @@
 
 /**
- * Close the USB device and reset it if required.
+ * Closes the USB device and optionally resets it.
  *
  * @param   pState          The USB device instance.
@@ -2228 +2276 @@
  * @returns VBox error code.
  */
-LOCAL int vboxUSBSolarisCloseDevice(vboxusb_state_t *pState, VBOXUSB_RESET_LEVEL enmReset)
-{
-    Log((DEVICE_NAME ":vboxUSBSolarisCloseDevice pState=%p enmReset=%d\n", pState, enmReset));
-
-    /*
-     * Serialize access: single threaded per Endpoint, one request at a time.
-     */
+LOCAL int vboxUsbSolarisCloseDevice(vboxusb_state_t *pState, VBOXUSB_RESET_LEVEL enmReset)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisCloseDevice: pState=%p enmReset=%d\n", pState, enmReset));
+
     mutex_enter(&pState->Mtx);
-    int rc = vboxUSBSolarisDeviceState(pState->DevState);
+    int rc = vboxUsbSolarisDeviceState(pState->DevState);
 
     if (enmReset == VBOXUSB_RESET_LEVEL_CLOSE)
-    {
-        vboxUSBSolarisCloseAllPipes(pState, true /* ControlPipe */);
-        pState->fClosed = true;
-    }
+        vboxUsbSolarisCloseAllPipes(pState, true /* ControlPipe */);
     else
-        vboxUSBSolarisCloseAllPipes(pState, false /* ControlPipe */);
-
+        vboxUsbSolarisCloseAllPipes(pState, false /* ControlPipe */);
 
     mutex_exit(&pState->Mtx);
@@ -2266 +2307 @@
         }
 
-        rc = vboxUSBSolarisToVBoxRC(rc);
-    }
-
-    Log((DEVICE_NAME ":vboxUSBSolarisCloseDevice returns %d\n", rc));
+        rc = vboxUsbSolarisToVBoxRC(rc);
+    }
+
+    Log((DEVICE_NAME ": vboxUsbSolarisCloseDevice: Returns %d\n", rc));
     return rc;
 }
@@ -2275 +2316 @@
 
 /**
- * Abort pending requests and reset the pipe.
+ * Aborts pending requests and reset the pipe.
  *
  * @param   pState          The USB device instance.
@@ -2282 +2323 @@
  * @returns VBox error code.
  */
-LOCAL int vboxUSBSolarisAbortPipe(vboxusb_state_t *pState, uint8_t bEndpoint)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisAbortPipe pState=%p bEndpoint=%#x\n", pState, bEndpoint));
-
-    /*
-     * Serialize access: single threaded per Endpoint, one request at a time.
-     */
+LOCAL int vboxUsbSolarisAbortPipe(vboxusb_state_t *pState, uint8_t bEndpoint)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisAbortPipe: pState=%p bEndpoint=%#x\n", pState, bEndpoint));
+
     mutex_enter(&pState->Mtx);
-    int rc = vboxUSBSolarisDeviceState(pState->DevState);
+    int rc = vboxUsbSolarisDeviceState(pState->DevState);
     if (RT_SUCCESS(rc))
     {
-        uchar_t EndPtIndex = usb_get_ep_index(bEndpoint);
-        vboxusb_ep_t *pEp = &pState->aEps[EndPtIndex];
+        int iEpIndex = VBOXUSB_GET_EP_INDEX(bEndpoint);
+        Assert(iEpIndex >= 0 && iEpIndex < RT_ELEMENTS(pState->aEps));
+        vboxusb_ep_t *pEp = &pState->aEps[iEpIndex];
         if (RT_LIKELY(pEp))
         {
@@ -2300 +2339 @@
             {
                 /*
-                 * Default Endpoint; aborting requests not supported, fake success.
+                 * Aborting requests not supported for the default control pipe.
                  */
                 if ((pEp->EpDesc.bEndpointAddress & USB_EP_NUM_MASK) == 0)
                 {
                     mutex_exit(&pState->Mtx);
-                    LogRel((DEVICE_NAME ":vboxUSBSolarisAbortPipe Cannot reset control pipe.\n"));
+                    LogRel((DEVICE_NAME ": vboxUsbSolarisAbortPipe: Cannot reset default control pipe\n"));
                     return VERR_NOT_SUPPORTED;
                 }
 
-                /*
-                 * Serialize access: single threaded per Endpoint, one request at a time.
-                 */
                 mutex_exit(&pState->Mtx);
                 usb_pipe_reset(pState->pDip, pEp->pPipe,
-                                USB_FLAGS_SLEEP, /* Synchronous */
-                                NULL,            /* Completion callback */
-                                NULL);           /* Callback data */
+                               USB_FLAGS_SLEEP,  /* Synchronous */
+                               NULL,             /* Completion callback */
+                               NULL);            /* Callback's parameter */
 
                 /*
                  * Allow pending async requests to complete.
                  */
+                /** @todo this is most likely not required. */
                 rc = usb_pipe_drain_reqs(pState->pDip, pEp->pPipe,
                                 USB_FLAGS_SLEEP, /* Synchronous */
                                 5,               /* Timeout (seconds) */
                                 NULL,            /* Completion callback */
-                                NULL);           /* Callback data*/
+                                NULL);           /* Callback's parameter */
 
                 mutex_enter(&pState->Mtx);
 
-                Log((DEVICE_NAME ":usb_pipe_drain_reqs returns %d\n", rc));
-                rc = vboxUSBSolarisToVBoxRC(rc);
+                Log((DEVICE_NAME ": vboxUsbSolarisAbortPipe: usb_pipe_drain_reqs returns %d\n", rc));
+                rc = vboxUsbSolarisToVBoxRC(rc);
             }
             else
             {
-                LogRel((DEVICE_NAME ":vboxUSBSolarisAbortPipe pipe not open. bEndpoint=%#x\n", bEndpoint));
+                LogRel((DEVICE_NAME ": vboxUsbSolarisAbortPipe: pipe not open. bEndpoint=%#x\n", bEndpoint));
                 rc = VERR_PIPE_IO_ERROR;
             }
@@ -2340 +2377 @@
         else
         {
-            LogRel((DEVICE_NAME ":vboxUSBSolarisAbortPipe invalid pipe index %d bEndpoint=%#x\n", EndPtIndex, bEndpoint));
+            LogRel((DEVICE_NAME ": vboxUsbSolarisAbortPipe: Invalid pipe bEndpoint=%#x[%d]\n", bEndpoint, iEpIndex));
             rc = VERR_INVALID_HANDLE;
         }
@@ -2347 +2384 @@
     mutex_exit(&pState->Mtx);
 
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisAbortPipe returns %d\n", rc));
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisAbortPipe: Returns %d\n", rc));
     return rc;
 }
@@ -2353 +2390 @@
 
 /**
- * Initialize an endpoint.
+ * Initializes an Endpoint.
  *
  * @param   pState          The USB device instance.
- * @param   pEpData         The Endpoint data.
- * @param   uCfgValue       The Configuration value.
- * @param   uInterface      The Interface.
- * @param   uAlt            The Alternate setting.
+ * @param   pEpData         The Endpoint data (NULL implies the default
+ *                          endpoint).
  *
  * @returns VBox error code.
  */
-LOCAL int vboxUSBSolarisInitEndPoint(vboxusb_state_t *pState, usb_ep_data_t *pEpData, uchar_t uCfgValue,
-                                     uchar_t uInterface, uchar_t uAlt)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisInitEndPoint pState=%p pEpData=%p CfgVal=%d Iface=%d Alt=%d", pState,
-                    pEpData, uCfgValue, uInterface, uAlt));
+LOCAL int vboxUsbSolarisInitEp(vboxusb_state_t *pState, usb_ep_data_t *pEpData)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisInitEp: pState=%p pEpData=%p", pState, pEpData));
 
     /*
@@ -2374 +2407 @@
     usb_ep_descr_t *pEpDesc = NULL;
     vboxusb_ep_t *pEp = NULL;
-    int EpIndex = 0;
+    int iEpIndex;
     if (!pEpData)
     {
-        EpIndex = 0;
+        iEpIndex = 0;
         pEpDesc = &g_VBoxUSBSolarisDefaultEpDesc;
     }
     else
     {
-        EpIndex = usb_get_ep_index(pEpData->ep_descr.bEndpointAddress);
-        pEpDesc = &pEpData->ep_descr;
-    }
-
-    pEp = &pState->aEps[EpIndex];
-    AssertRelease(pEp);
+        iEpIndex = VBOXUSB_GET_EP_INDEX(pEpData->ep_descr.bEndpointAddress);
+        pEpDesc  = (usb_ep_descr_t *)((uint8_t *)pEpData + g_offUsbEpDataDescr);
+    }
+
+    Assert(iEpIndex >= 0 && iEpIndex < RT_ELEMENTS(pState->aEps));
+    pEp = &pState->aEps[iEpIndex];
 
     /*
-     * Initialize the endpoint data structure.
+     * Initialize the endpoint.
      */
     pEp->EpDesc = *pEpDesc;
-    pEp->uCfgValue = uCfgValue;
-    pEp->uInterface = uInterface;
-    pEp->uAlt = uAlt;
-    if (pEp->fInitialized != VBOXUSB_EP_INITIALIZED)
+    if (!pEp->fInitialized)
     {
         pEp->pPipe = NULL;
@@ -2408 +2438 @@
         pEp->cbIsocInLandedReqs = 0;
         pEp->cbMaxIsocData = 0;
-        pEp->fInitialized = VBOXUSB_EP_INITIALIZED;
-    }
-    Log((DEVICE_NAME ":vboxUSBSolarisInitEndPoint done. %s:[%d] bEndpoint=%#x\n", !pEpData ? "Default " : "Endpoint",
-                    EpIndex, pEp->EpDesc.bEndpointAddress));
+        pEp->fInitialized = true;
+    }
+
+    Log((DEVICE_NAME ": vboxUsbSolarisInitEp: Success, %s[%2d] %s %s bEndpoint=%#x\n", !pEpData ? "Default " : "Endpoint",
+         iEpIndex, vboxUsbSolarisEpType(pEp), vboxUsbSolarisEpDir(pEp), pEp->EpDesc.bEndpointAddress));
     return VINF_SUCCESS;
 }
@@ -2417 +2448 @@
 
 /**
- * Initialize all Endpoint structures.
+ * Initializes Endpoints for the current configuration, all interfaces and
+ * alternate setting 0 for each interface.
  *
  * @param   pState          The USB device instance.
@@ -2423 +2455 @@
  * @returns VBox status code.
  */
-LOCAL int vboxUSBSolarisInitAllEndPoints(vboxusb_state_t *pState)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisInitAllEndPoints pState=%p\n", pState));
-
-    /*
-     * Initialize all Endpoints for all Alternate settings of all Interfaces of all Configs.
-     */
-    int rc = vboxUSBSolarisInitEndPoint(pState, NULL /* pEp */, 0 /* uCfgValue */, 0 /* uInterface */, 0 /* uAlt */);
-
-    if (RT_SUCCESS(rc))
-    {
-        /*
-         * Initialize all Endpoints for all Alternate settings of all Interfaces of all Configs.
-         */
-        for (uchar_t uCfgIndex = 0; uCfgIndex < pState->pDevDesc->dev_n_cfg; uCfgIndex++)
-        {
-            rc = vboxUSBSolarisInitEndPointsForConfig(pState, uCfgIndex);
-            if (RT_FAILURE(rc))
+LOCAL int vboxUsbSolarisInitEpsForCfg(vboxusb_state_t *pState)
+{
+    uint_t uCfgIndex = usb_get_current_cfgidx(pState->pDip);
+    if (uCfgIndex >= pState->pDevDesc->dev_n_cfg)
+    {
+        LogRel((DEVICE_NAME ": vboxUsbSolarisInitEpsForCfg: Invalid current config index %u\n", uCfgIndex));
+        return VERR_OUT_OF_RANGE;
+    }
+
+    usb_cfg_data_t *pConfig = &pState->pDevDesc->dev_cfg[uCfgIndex];
+    uchar_t bConfig = pConfig->cfg_descr.bConfigurationValue;
+
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisInitEpsForCfg: pState=%p bConfig=%u uCfgIndex=%u\n", pState, bConfig, uCfgIndex));
+
+    const uint_t cIfs = pConfig->cfg_n_if;
+    for (uchar_t uIf = 0; uIf < cIfs; uIf++)
+    {
+        usb_if_data_t *pIf = &pConfig->cfg_if[uIf];
+        const uint_t cAlts = pIf->if_n_alt;
+        for (uchar_t uAlt = 0; uAlt < cAlts; uAlt++)
+        {
+            usb_alt_if_data_t *pAlt = &pIf->if_alt[uAlt];
+            if (pAlt->altif_descr.bAlternateSetting == 0)   /* Refer USB 2.0 spec 9.6.5 "Interface" */
             {
-                LogRel((DEVICE_NAME ":vboxUSBSolarisInitAllEndPoints: vboxUSBSolarisInitEndPoints uCfgIndex=%d failed. rc=%d\n",
-                        uCfgIndex, rc));
-                return rc;
+                const uint_t cEps = pAlt->altif_n_ep;
+                for (uchar_t uEp = 0; uEp < cEps; uEp++)
+                {
+                    uint8_t       *pbEpData = (uint8_t *)&pAlt->altif_ep[0];
+                    usb_ep_data_t *pEpData  = (usb_ep_data_t *)(pbEpData + uEp * g_cbUsbEpData);
+                    int rc = vboxUsbSolarisInitEp(pState, pEpData);
+                    if (RT_FAILURE(rc))
+                    {
+                        LogRel((DEVICE_NAME ": vboxUsbSolarisInitEpsForCfg: Failed to init endpoint! "
+                                "bConfig=%u bIf=%#x bAlt=%#x\n", bConfig, pAlt->altif_descr.bInterfaceNumber,
+                                pAlt->altif_descr.bAlternateSetting));
+                        return rc;
+                    }
+                }
+                break;  /* move on to next interface. */
             }
         }
     }
-    else
-        LogRel((DEVICE_NAME ":vboxUSBSolarisInitAllEndPoints default Endpoint initialization failed!\n"));
-
-    return rc;
-}
-
-
-/**
- * Initialize Endpoints structures for the given Config.
- *
- * @param   pState          The USB device instance.
- * @param   uCfgIndex       The current Config. index.
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Initializes Endpoints for the given Interface & Alternate setting.
+ *
+ * @param   pState   The USB device instance.
+ * @param   bIf      The Interface.
+ * @param   bAlt     The Alterate.
  *
  * @returns VBox status code.
  */
-LOCAL int vboxUSBSolarisInitEndPointsForConfig(vboxusb_state_t *pState, uint8_t uCfgIndex)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisInitEndPointsForConfig pState=%p uCfgIndex=%d\n", pState, uCfgIndex));
-    usb_cfg_data_t *pConfig = &pState->pDevDesc->dev_cfg[uCfgIndex];
-    uchar_t uCfgValue = pConfig->cfg_descr.bConfigurationValue;
-
-    for (uchar_t uInterface = 0; uInterface < pConfig->cfg_n_if; uInterface++)
-    {
-        usb_if_data_t *pInterface = &pConfig->cfg_if[uInterface];
-
-        for (uchar_t uAlt = 0; uAlt < pInterface->if_n_alt; uAlt++)
-        {
-            usb_alt_if_data_t *pAlt = &pInterface->if_alt[uAlt];
-
-            for (uchar_t uEp = 0; uEp < pAlt->altif_n_ep; uEp++)
-            {
-                usb_ep_data_t *pEpData = &pAlt->altif_ep[uEp];
-
-                int rc = vboxUSBSolarisInitEndPoint(pState, pEpData, uCfgValue, uInterface, uAlt);
-                if (RT_FAILURE(rc))
-                {
-                    LogRel((DEVICE_NAME ":vboxUSBSolarisInitEndPointsForConfig: vboxUSBSolarisInitEndPoint failed! pEp=%p "
-                            "uCfgValue=%u uCfgIndex=%u uInterface=%u, uAlt=%u\n", uCfgValue, uCfgIndex, uInterface, uAlt));
-                    return rc;
-                }
-            }
-        }
-    }
-    return VINF_SUCCESS;
-}
-
-
-/**
- * Initialize Endpoints structures for the given Interface & Alternate setting.
- *
- * @param   pState          The USB device instance.
- * @param   uInterface      The interface being switched to.
- * @param   uAlt            The alt being switched to.
- *
- * @returns VBox status code.
- */
-LOCAL int vboxUSBSolarisInitEndPointsForInterfaceAlt(vboxusb_state_t *pState, uint8_t uInterface, uint8_t uAlt)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisInitEndPointsForInterfaceAlt pState=%p uInterface=%d uAlt=%d\n", pState, uInterface,
-             uAlt));
+LOCAL int vboxUsbSolarisInitEpsForIfAlt(vboxusb_state_t *pState, uint8_t bIf, uint8_t bAlt)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisInitEpsForIfAlt: pState=%p bIf=%d uAlt=%d\n", pState, bIf, bAlt));
 
     /* Doesn't hurt to be paranoid */
     uint_t uCfgIndex = usb_get_current_cfgidx(pState->pDip);
-    if (RT_UNLIKELY(uCfgIndex >= pState->pDevDesc->dev_n_cfg))
-    {
-        LogRel((DEVICE_NAME ":vboxUSBSolarisInitEndPointsForInterfaceAlt invalid current config index %d\n", uCfgIndex));
-        return VERR_GENERAL_FAILURE;
+    if (uCfgIndex >= pState->pDevDesc->dev_n_cfg)
+    {
+        LogRel((DEVICE_NAME ": vboxUsbSolarisInitEpsForIfAlt: Invalid current config index %d\n", uCfgIndex));
+        return VERR_OUT_OF_RANGE;
     }
 
     usb_cfg_data_t *pConfig = &pState->pDevDesc->dev_cfg[uCfgIndex];
-    uchar_t uCfgValue = pConfig->cfg_descr.bConfigurationValue;
-    usb_if_data_t *pInterface = &pConfig->cfg_if[uInterface];
-
-    int rc = VINF_SUCCESS;
-    if (RT_LIKELY(pInterface))
-    {
-        usb_alt_if_data_t *pAlt = &pInterface->if_alt[uAlt];
-        if (RT_LIKELY(pAlt))
-        {
-            for (uchar_t uEp = 0; uEp < pAlt->altif_n_ep; uEp++)
+    for (uchar_t uIf = 0; uIf < pConfig->cfg_n_if; uIf++)
+    {
+        usb_if_data_t *pInterface = &pConfig->cfg_if[uIf];
+        const uint_t cAlts = pInterface->if_n_alt;
+        for (uchar_t uAlt = 0; uAlt < cAlts; uAlt++)
+        {
+            usb_alt_if_data_t *pAlt = &pInterface->if_alt[uAlt];
+            if (   pAlt->altif_descr.bInterfaceNumber  == bIf
+                && pAlt->altif_descr.bAlternateSetting == bAlt)
             {
-                usb_ep_data_t *pEpData = &pAlt->altif_ep[uEp];
-                rc = vboxUSBSolarisInitEndPoint(pState, pEpData, uCfgValue, uInterface, uAlt);
-                if (RT_FAILURE(rc))
+                const uint_t cEps = pAlt->altif_n_ep;
+                for (uchar_t uEp = 0; uEp < cEps; uEp++)
                 {
-                    LogRel((DEVICE_NAME ":vboxUSBSolarisInitEndPointsForInterfaceAlt: vboxUSBSolarisInitEndPoint failed! pEp=%p "
-                            "uCfgValue=%u uCfgIndex=%u uInterface=%u, uAlt=%u\n", uCfgValue, uCfgIndex, uInterface, uAlt));
-                    return rc;
+                    uint8_t       *pbEpData = (uint8_t *)&pAlt->altif_ep[0];
+                    usb_ep_data_t *pEpData  = (usb_ep_data_t *)(pbEpData + uEp * g_cbUsbEpData);
+                    int rc = vboxUsbSolarisInitEp(pState, pEpData);
+                    if (RT_FAILURE(rc))
+                    {
+                        uint8_t bCfgValue = pConfig->cfg_descr.bConfigurationValue;
+                        LogRel((DEVICE_NAME ": vboxUsbSolarisInitEpsForIfAlt: Failed to init endpoint! "
+                                "bCfgValue=%u bIf=%#x bAlt=%#x\n", bCfgValue, bIf, bAlt));
+                        return rc;
+                    }
                 }
+                return VINF_SUCCESS;
             }
         }
-        else
-        {
-            LogRel((DEVICE_NAME ":vboxUSBSolarisInitEndPointsForInterfaceAlt missing alternate.\n"));
-            rc = VERR_INVALID_POINTER;
-        }
-    }
-    else
-    {
-        LogRel((DEVICE_NAME ":vboxUSBSolarisInitEndPointsForInterfaceAlt missing interface.\n"));
-        rc = VERR_INVALID_POINTER;
-    }
-
-    Log((DEVICE_NAME ":vboxUSBSolarisInitEndPointsForInterfaceAlt returns %d\n", rc));
-    return rc;
-}
-
-
-/**
- * Destroy all Endpoint Xfer structures.
+    }
+    return VERR_NOT_FOUND;
+}
+
+
+/**
+ * Destroys all Endpoints.
  *
  * @param   pState          The USB device instance.
+ *
  * @remarks Requires the state mutex to be held.
  *          Call only from Detach() or similar as callbacks
  */
-LOCAL void vboxUSBSolarisDestroyAllEndPoints(vboxusb_state_t *pState)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisDestroyAllEndPoints pState=%p\n", pState));
+LOCAL void vboxUsbSolarisDestroyAllEps(vboxusb_state_t *pState)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisDestroyAllEps: pState=%p\n", pState));
 
     Assert(mutex_owned(&pState->Mtx));
@@ -2571 +2571 @@
     {
         vboxusb_ep_t *pEp = &pState->aEps[i];
-        if (pEp)
-        {
-            vboxUSBSolarisDestroyEndPoint(pState, pEp);
-            pEp = NULL;
-        }
-    }
-}
-
-
-/**
- * Destroy an Endpoint.
+        if (pEp->fInitialized)
+            vboxUsbSolarisDestroyEp(pState, pEp);
+    }
+}
+
+
+/**
+ * Destroys an Endpoint.
  *
  * @param   pState          The USB device instance.
  * @param   pEp             The Endpoint.
+ *
  * @remarks Requires the state mutex to be held.
  */
-LOCAL void vboxUSBSolarisDestroyEndPoint(vboxusb_state_t *pState, vboxusb_ep_t *pEp)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisDestroyEndPoint pState=%p pEp=%p\n", pState, pEp));
-
+LOCAL void vboxUsbSolarisDestroyEp(vboxusb_state_t *pState, vboxusb_ep_t *pEp)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisDestroyEp: pState=%p pEp=%p\n", pState, pEp));
+
+    Assert(pEp->fInitialized);
     Assert(mutex_owned(&pState->Mtx));
-    if (pEp->fInitialized == VBOXUSB_EP_INITIALIZED)
-    {
-        vboxusb_urb_t *pUrb = list_remove_head(&pEp->hIsocInUrbs);
-        while (pUrb)
-        {
-            if (pUrb->pMsg)
-                freemsg(pUrb->pMsg);
-            RTMemFree(pUrb);
-            pUrb = list_remove_head(&pEp->hIsocInUrbs);
-        }
-        pEp->cIsocInUrbs = 0;
-        list_destroy(&pEp->hIsocInUrbs);
-
-        vboxusb_isoc_req_t *pIsocReq = list_remove_head(&pEp->hIsocInLandedReqs);
-        while (pIsocReq)
-        {
-            kmem_free(pIsocReq, sizeof(vboxusb_isoc_req_t));
-            pIsocReq = list_remove_head(&pEp->hIsocInLandedReqs);
-        }
-        pEp->cbIsocInLandedReqs = 0;
-        list_destroy(&pEp->hIsocInLandedReqs);
-
-        pEp->fInitialized = 0;
-    }
-}
-
-
-/**
- * Close all non-default Endpoints and drains the default pipe.
+    vboxusb_urb_t *pUrb = list_remove_head(&pEp->hIsocInUrbs);
+    while (pUrb)
+    {
+        if (pUrb->pMsg)
+            freemsg(pUrb->pMsg);
+        RTMemFree(pUrb);
+        pUrb = list_remove_head(&pEp->hIsocInUrbs);
+    }
+    pEp->cIsocInUrbs = 0;
+    list_destroy(&pEp->hIsocInUrbs);
+
+    vboxusb_isoc_req_t *pIsocReq = list_remove_head(&pEp->hIsocInLandedReqs);
+    while (pIsocReq)
+    {
+        kmem_free(pIsocReq, sizeof(vboxusb_isoc_req_t));
+        pIsocReq = list_remove_head(&pEp->hIsocInLandedReqs);
+    }
+    pEp->cbIsocInLandedReqs = 0;
+    list_destroy(&pEp->hIsocInLandedReqs);
+
+    pEp->fInitialized = false;
+}
+
+
+/**
+ * Closes all non-default pipes and drains the default pipe.
  *
  * @param   pState          The USB device instance.
@@ -2627 +2623 @@
  * @remarks Requires the device state mutex to be held.
  */
-LOCAL void vboxUSBSolarisCloseAllPipes(vboxusb_state_t *pState, bool fDefault)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisCloseAllPipes pState=%p\n", pState));
+LOCAL void vboxUsbSolarisCloseAllPipes(vboxusb_state_t *pState, bool fDefault)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisCloseAllPipes: pState=%p\n", pState));
 
     for (int i = 1; i < VBOXUSB_MAX_ENDPOINTS; i++)
@@ -2637 +2633 @@
             && pEp->pPipe)
         {
-            Log((DEVICE_NAME ":vboxUSBSolarisCloseAllPipes closing[%d]\n", i));
-            vboxUSBSolarisClosePipe(pState, pEp);
+            Log((DEVICE_NAME ": vboxUsbSolarisCloseAllPipes: Closing[%d]\n", i));
+            vboxUsbSolarisClosePipe(pState, pEp);
         }
     }
@@ -2648 +2644 @@
             && pEp->pPipe)
         {
-            vboxUSBSolarisClosePipe(pState, pEp);
-            Log((DEVICE_NAME ":vboxUSBSolarisCloseAllPipes closed default pipe.\n"));
-        }
-    }
-}
-
-
-/**
- * Open the pipe for an Endpoint.
+            vboxUsbSolarisClosePipe(pState, pEp);
+            Log((DEVICE_NAME ": vboxUsbSolarisCloseAllPipes: Closed default pipe\n"));
+        }
+    }
+}
+
+
+/**
+ * Opens the pipe associated with an Endpoint.
  *
  * @param   pState          The USB device instance.
@@ -2664 +2660 @@
  * @returns VBox status code.
  */
-LOCAL int vboxUSBSolarisOpenPipe(vboxusb_state_t *pState, vboxusb_ep_t *pEp)
+LOCAL int vboxUsbSolarisOpenPipe(vboxusb_state_t *pState, vboxusb_ep_t *pEp)
 {
     Assert(mutex_owned(&pState->Mtx));
@@ -2674 +2670 @@
         return VINF_SUCCESS;
 
-
     /*
      * Default Endpoint; already opened just copy the pipe handle.
@@ -2682 +2677 @@
         pEp->pPipe = pState->pDevDesc->dev_default_ph;
         pEp->EpState |= VBOXUSB_EP_STATE_OPENED;
-        Log((DEVICE_NAME ":vboxUSBSolarisOpenPipe default pipe opened.\n"));
+        Log((DEVICE_NAME ": vboxUsbSolarisOpenPipe: Default pipe opened\n"));
         return VINF_SUCCESS;
     }
@@ -2694 +2689 @@
     if (rc == USB_SUCCESS)
     {
-        LogFunc((DEVICE_NAME ":vboxUSBSolarisOpenPipe: Opened pipe. pState=%p pEp=%p\n", pState, pEp));
+        LogFunc((DEVICE_NAME ": vboxUsbSolarisOpenPipe: Opened pipe, pState=%p pEp=%p\n", pState, pEp));
         usb_pipe_set_private(pEp->pPipe, (usb_opaque_t)pEp);
 
@@ -2719 +2714 @@
                 pEp->cbMaxIsocData = 400 * cbMax * 8;
             }
-            Log((DEVICE_NAME ":vboxUSBSolarisOpenPipe pEp=%p cbMaxIsocData=%u\n", pEp->cbMaxIsocData));
+            Log((DEVICE_NAME ": vboxUsbSolarisOpenPipe: bEndpoint=%#x cbMaxIsocData=%u\n", pEp->EpDesc.bEndpointAddress,
+                 pEp->cbMaxIsocData));
         }
 
@@ -2727 +2723 @@
     else
     {
-        LogRel((DEVICE_NAME ":vboxUSBSolarisOpenPipe failed! rc=%d pState=%p pEp=%p\n", rc, pState, pEp));
+        LogRel((DEVICE_NAME ": vboxUsbSolarisOpenPipe: Failed! rc=%d pState=%p pEp=%p\n", rc, pState, pEp));
         rc = VERR_BAD_PIPE;
     }
@@ -2736 +2732 @@
 
 /**
- * Close the pipe of the Endpoint.
+ * Closes the pipe associated with an Endpoint.
  *
  * @param   pState          The USB device instance.
@@ -2743 +2739 @@
  * @remarks Requires the device state mutex to be held.
  */
-LOCAL void vboxUSBSolarisClosePipe(vboxusb_state_t *pState, vboxusb_ep_t *pEp)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisClosePipe pState=%p pEp=%p\n", pState, pEp));
+LOCAL void vboxUsbSolarisClosePipe(vboxusb_state_t *pState, vboxusb_ep_t *pEp)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisClosePipe: pState=%p pEp=%p\n", pState, pEp));
     AssertPtr(pEp);
 
@@ -2760 +2756 @@
             usb_pipe_drain_reqs(pState->pDip, pEp->pPipe, 0, USB_FLAGS_SLEEP, NULL /* callback */, NULL /* callback arg. */);
             mutex_enter(&pState->Mtx);
-            Log((DEVICE_NAME ":vboxUSBSolarisClosePipe closed default pipe\n"));
+            Log((DEVICE_NAME ": vboxUsbSolarisClosePipe: Closed default pipe\n"));
+            pState->fDefaultPipeOpen = false;
         }
         else
@@ -2778 +2775 @@
              * Non-default pipe: close it.
              */
-            Log((DEVICE_NAME ":vboxUSBSolarisClosePipe pipe bmAttributes=%#x bEndpointAddress=%#x\n", pEp->EpDesc.bmAttributes,
+            Log((DEVICE_NAME ": vboxUsbSolarisClosePipe: Pipe bmAttributes=%#x bEndpoint=%#x\n", pEp->EpDesc.bmAttributes,
                  pEp->EpDesc.bEndpointAddress));
             mutex_exit(&pState->Mtx);
@@ -2790 +2787 @@
         pEp->pPipe = NULL;
 
-        Log((DEVICE_NAME ":vboxUSBSolarisClosePipe successful. pEp=%p\n", pEp));
+        Log((DEVICE_NAME ": vboxUsbSolarisClosePipe: Success, bEndpoint=%#x\n", pEp->EpDesc.bEndpointAddress));
     }
 
@@ -2798 +2795 @@
 
 /**
- * Find the Configuration index for the passed in Configuration value.
+ * Finds the Configuration index for the passed in Configuration value.
  *
  * @param   pState          The USB device instance.
- * @param   uCfgValue       The Configuration value.
+ * @param   bConfig         The Configuration.
  *
  * @returns The configuration index if found, otherwise -1.
  */
-LOCAL int vboxUSBSolarisGetConfigIndex(vboxusb_state_t *pState, uint_t uCfgValue)
+LOCAL int vboxUsbSolarisGetConfigIndex(vboxusb_state_t *pState, uint_t bConfig)
 {
     for (int CfgIndex = 0; CfgIndex < pState->pDevDesc->dev_n_cfg; CfgIndex++)
     {
         usb_cfg_data_t *pConfig = &pState->pDevDesc->dev_cfg[CfgIndex];
-        if (pConfig->cfg_descr.bConfigurationValue == uCfgValue)
+        if (pConfig->cfg_descr.bConfigurationValue == bConfig)
             return CfgIndex;
     }
@@ -2826 +2823 @@
  * @returns The allocated Isoc. In URB to be used.
  */
-LOCAL vboxusb_urb_t *vboxUSBSolarisGetIsocInURB(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq)
+LOCAL vboxusb_urb_t *vboxUsbSolarisGetIsocInUrb(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq)
 {
     /*
@@ -2856 +2853 @@
     }
     else
-        LogRel((DEVICE_NAME ":vboxUSBSolarisGetIsocInURB failed to alloc %d bytes.\n", sizeof(vboxusb_urb_t)));
+        LogRel((DEVICE_NAME ": vboxUsbSolarisGetIsocInUrb: Failed to alloc %d bytes\n", sizeof(vboxusb_urb_t)));
     return pUrb;
 }
@@ -2870 +2867 @@
  * @returns The allocated URB to be used, or NULL upon failure.
  */
-LOCAL vboxusb_urb_t *vboxUSBSolarisQueueURB(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq, mblk_t *pMsg)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisQueueURB pState=%p pUrbReq=%p\n", pState, pUrbReq));
+LOCAL vboxusb_urb_t *vboxUsbSolarisQueueUrb(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq, mblk_t *pMsg)
+{
+    Assert(pUrbReq);
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisQueueUrb: pState=%p pUrbReq=%p\n", pState, pUrbReq));
 
     mutex_enter(&pState->Mtx);
 
     /*
-     * Discard oldest queued URB if we've queued max URBs and none of them have completed.
+     * Grab a URB from the free list.
      */
-    if (pState->cInflightUrbs >= VBOXUSB_URB_QUEUE_SIZE)
-    {
-        vboxusb_urb_t *pUrb = list_head(&pState->hUrbs);
-        if (RT_LIKELY(pUrb))
-        {
-            if (pUrb->pMsg)
-            {
-                freemsg(pUrb->pMsg);
-                pUrb->pMsg = NULL;
-            }
-            pUrb->enmState = VBOXUSB_URB_STATE_FREE;
-        }
-    }
-
-    vboxusb_urb_t *pUrb = list_head(&pState->hUrbs);
-    if (   !pUrb
-        || (   pUrb
-            && pUrb->enmState != VBOXUSB_URB_STATE_FREE))
-    {
+    vboxusb_urb_t *pUrb = list_remove_head(&pState->hFreeUrbs);
+    if (pUrb)
+    {
+        Assert(pUrb->enmState == VBOXUSB_URB_STATE_FREE);
+        Assert(!pUrb->pMsg);
+        Assert(pState->cFreeUrbs > 0);
+        --pState->cFreeUrbs;
+    }
+    else
+    {
+        /*
+         * We can't discard "old" URBs. For instance, INTR IN URBs that don't complete as
+         * they don't have a timeout can essentially take arbitrarily long to complete depending
+         * on the device and it's not safe to discard them in case they -do- complete. However,
+         * we also have to reasonably assume a device doesn't have too many pending URBs always.
+         *
+         * Thus we just use a large queue and simply refuse further transfers. This is not
+         * a situation which normally ever happens as usually there are at most than 4 or 5 URBs
+         * in-flight until we reap them.
+         */
+        uint32_t const cTotalUrbs = pState->cInflightUrbs + pState->cFreeUrbs + pState->cLandedUrbs;
+        if (cTotalUrbs >= VBOXUSB_URB_QUEUE_SIZE)
+        {
+            mutex_exit(&pState->Mtx);
+            LogRelMax(5, (DEVICE_NAME ": vboxUsbSolarisQueueUrb: Max queue size %u reached, refusing further transfers",
+                          cTotalUrbs));
+            return NULL;
+        }
+
+        /*
+         * Allocate a new URB as we have no free URBs.
+         */
         mutex_exit(&pState->Mtx);
         pUrb = RTMemAllocZ(sizeof(vboxusb_urb_t));
         if (RT_UNLIKELY(!pUrb))
         {
-            LogRel((DEVICE_NAME ":vboxUSBSolarisQueueURB failed to alloc %d bytes.\n", sizeof(vboxusb_urb_t)));
+            LogRel((DEVICE_NAME ": vboxUsbSolarisQueueUrb: Failed to alloc %d bytes\n", sizeof(vboxusb_urb_t)));
             return NULL;
         }
         mutex_enter(&pState->Mtx);
     }
-    else
-    {
-        /*
-         * Remove from head and move to tail so that when several URBs are reaped continuously we get to use
-         * up each one free 'head'.
-         */
-        Assert(pUrb && pUrb->enmState == VBOXUSB_URB_STATE_FREE);
-        list_remove_head(&pState->hUrbs);
-    }
-
-    list_insert_tail(&pState->hUrbs, pUrb);
+
+    /*
+     * Add the URB to the inflight list.
+     */
+    list_insert_tail(&pState->hInflightUrbs, pUrb);
     ++pState->cInflightUrbs;
 
-    pUrb->enmState = VBOXUSB_URB_STATE_INFLIGHT;
-
-    Assert(pUrb->pMsg == NULL);
-    pUrb->pState = pState;
-    Log((DEVICE_NAME ":vboxUSBSolarisQueueURB cInflightUrbs=%d\n", pState->cInflightUrbs));
-
-    if (RT_LIKELY(pUrbReq))
-    {
-        pUrb->pvUrbR3   = pUrbReq->pvUrbR3;
-        pUrb->bEndpoint = pUrbReq->bEndpoint;
-        pUrb->enmType   = pUrbReq->enmType;
-        pUrb->enmDir    = pUrbReq->enmDir;
-        pUrb->enmStatus = pUrbReq->enmStatus;
-        pUrb->fShortOk  = pUrbReq->fShortOk;
-        pUrb->pvDataR3  = (RTR3PTR)pUrbReq->pvData;
-        pUrb->cbDataR3  = pUrbReq->cbData;
-        pUrb->cIsocPkts = pUrbReq->cIsocPkts;
-
-        if (pUrbReq->enmType == VUSBXFERTYPE_ISOC)
-        {
-            for (unsigned i = 0; i < pUrbReq->cIsocPkts; i++)
-                pUrb->aIsocPkts[i].cbPkt = pUrbReq->aIsocPkts[i].cbPkt;
-        }
-
-        pUrb->pMsg = pMsg;
+    Assert(!pUrb->pMsg);
+    pUrb->pMsg      = pMsg;
+    pUrb->pState    = pState;
+    pUrb->enmState  = VBOXUSB_URB_STATE_INFLIGHT;
+    pUrb->pvUrbR3   = pUrbReq->pvUrbR3;
+    pUrb->bEndpoint = pUrbReq->bEndpoint;
+    pUrb->enmType   = pUrbReq->enmType;
+    pUrb->enmDir    = pUrbReq->enmDir;
+    pUrb->enmStatus = pUrbReq->enmStatus;
+    pUrb->fShortOk  = pUrbReq->fShortOk;
+    pUrb->pvDataR3  = (RTR3PTR)pUrbReq->pvData;
+    pUrb->cbDataR3  = pUrbReq->cbData;
+    pUrb->cIsocPkts = pUrbReq->cIsocPkts;
+    if (pUrbReq->enmType == VUSBXFERTYPE_ISOC)
+    {
+        for (unsigned i = 0; i < pUrbReq->cIsocPkts; i++)
+            pUrb->aIsocPkts[i].cbPkt = pUrbReq->aIsocPkts[i].cbPkt;
     }
 
     mutex_exit(&pState->Mtx);
-
     return pUrb;
 }
@@ -2961 +2957 @@
  * @remarks All pipes could be closed at this point (e.g. Device disconnected during inflight URBs)
  */
-LOCAL inline void vboxUSBSolarisDeQueueURB(vboxusb_urb_t *pUrb, int URBStatus)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisDeQueue pUrb=%p\n", pUrb));
+LOCAL void vboxUsbSolarisDeQueueUrb(vboxusb_urb_t *pUrb, int URBStatus)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisDeQueue: pUrb=%p\n", pUrb));
     AssertPtrReturnVoid(pUrb);
 
-    pUrb->enmStatus = vboxUSBSolarisGetUrbStatus(URBStatus);
+    pUrb->enmStatus = vboxUsbSolarisGetUrbStatus(URBStatus);
+    if (pUrb->enmStatus != VUSBSTATUS_OK)
+        Log((DEVICE_NAME ": vboxUsbSolarisDeQueueUrb: URB failed! URBStatus=%d bEndpoint=%#x\n", URBStatus, pUrb->bEndpoint));
 
     vboxusb_state_t *pState = pUrb->pState;
@@ -2975 +2973 @@
 
         /*
-         * Remove it from the inflight list & move it to landed list.
+         * Remove it from the inflight list & move it to the landed list.
          */
-        list_remove(&pState->hUrbs, pUrb);
+        list_remove(&pState->hInflightUrbs, pUrb);
+        Assert(pState->cInflightUrbs > 0);
         --pState->cInflightUrbs;
+
         list_insert_tail(&pState->hLandedUrbs, pUrb);
-
-        vboxUSBSolarisNotifyComplete(pUrb->pState);
+        ++pState->cLandedUrbs;
+
+        vboxUsbSolarisNotifyComplete(pUrb->pState);
         mutex_exit(&pState->Mtx);
-    }
-    else
-    {
-        Log((DEVICE_NAME ":vboxUSBSolarisDeQueue State Gone.\n"));
-        freemsg(pUrb->pMsg);
-        pUrb->pMsg = NULL;
-        pUrb->enmStatus = VUSBSTATUS_INVALID;
-    }
+        return;
+    }
+
+    /* Well, let's at least not leak memory... */
+    freemsg(pUrb->pMsg);
+    pUrb->pMsg = NULL;
+    pUrb->enmStatus = VUSBSTATUS_INVALID;
+
+    LogRel((DEVICE_NAME ": vboxUsbSolarisDeQueue: State Gone\n"));
 }
 
@@ -2999 +3001 @@
  * @param   pUrb                The URB to move.
  */
-LOCAL inline void vboxUSBSolarisConcatMsg(vboxusb_urb_t *pUrb)
+LOCAL void vboxUsbSolarisConcatMsg(vboxusb_urb_t *pUrb)
 {
     /*
@@ -3013 +3015 @@
             pUrb->pMsg = pFullMsg;
         }
-    }
-}
-
-
-/**
- * User process poll wake up wrapper for asynchronous URB completion.
+        else
+            LogRel((DEVICE_NAME ": vboxUsbSolarisConcatMsg: Failed. Expect glitches due to truncated data!\n"));
+    }
+}
+
+
+/**
+ * Wakes up a user process signalling URB completion.
  *
  * @param   pState          The USB device instance.
  * @remarks Requires the device state mutex to be held.
  */
-LOCAL inline void vboxUSBSolarisNotifyComplete(vboxusb_state_t *pState)
-{
-    if (pState->fPoll & VBOXUSB_POLL_ON)
+LOCAL void vboxUsbSolarisNotifyComplete(vboxusb_state_t *pState)
+{
+    if (pState->fPollPending)
     {
         pollhead_t *pPollHead = &pState->PollHead;
-        pState->fPoll |= VBOXUSB_POLL_REAP_PENDING;
+        pState->fPollPending = false;
         mutex_exit(&pState->Mtx);
         pollwakeup(pPollHead, POLLIN);
@@ -3037 +3041 @@
 
 /**
- * User process poll wake up wrapper for hotplug events.
+ * Wakes up a user process signalling a device unplug events.
  *
  * @param   pState          The USB device instance.
  * @remarks Requires the device state mutex to be held.
  */
-LOCAL inline void vboxUSBSolarisNotifyHotplug(vboxusb_state_t *pState)
-{
-    if (pState->fPoll & VBOXUSB_POLL_ON)
+LOCAL void vboxUsbSolarisNotifyUnplug(vboxusb_state_t *pState)
+{
+    if (pState->fPollPending)
     {
         pollhead_t *pPollHead = &pState->PollHead;
-        pState->fPoll |= VBOXUSB_POLL_DEV_UNPLUGGED;
+        pState->fPollPending = false;
         mutex_exit(&pState->Mtx);
         pollwakeup(pPollHead, POLLHUP);
@@ -3056 +3060 @@
 
 /**
- * Perform a Control Xfer.
+ * Performs a Control Xfer.
  *
  * @param   pState          The USB device instance.
@@ -3063 +3067 @@
  *
  * @returns VBox status code.
- * @remarks Any errors, the caller should free pUrb->pMsg.
- */
-LOCAL int vboxUSBSolarisCtrlXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisCtrlXfer pState=%p pEp=%p pUrb=%p enmDir=%d cbData=%d\n", pState, pEp, pUrb,
+ */
+LOCAL int vboxUsbSolarisCtrlXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisCtrlXfer: pState=%p pEp=%p pUrb=%p enmDir=%d cbData=%d\n", pState, pEp, pUrb,
              pUrb->enmDir, pUrb->cbDataR3));
 
     AssertPtrReturn(pUrb->pMsg, VERR_INVALID_PARAMETER);
-    uchar_t *pSetupData = pUrb->pMsg->b_rptr;
-    size_t cbData = pUrb->cbDataR3 > VBOXUSB_CTRL_XFER_SIZE ? pUrb->cbDataR3 - VBOXUSB_CTRL_XFER_SIZE : 0;
+    const size_t cbData = pUrb->cbDataR3 > VBOXUSB_CTRL_XFER_SIZE ? pUrb->cbDataR3 - VBOXUSB_CTRL_XFER_SIZE : 0;
 
     /*
      * Allocate a wrapper request.
      */
-    int rc = VINF_SUCCESS;
-    usb_ctrl_req_t *pReq = usb_alloc_ctrl_req(pState->pDip, cbData, USB_FLAGS_NOSLEEP);
+    usb_ctrl_req_t *pReq = usb_alloc_ctrl_req(pState->pDip, cbData, USB_FLAGS_SLEEP);
     if (RT_LIKELY(pReq))
     {
+        uchar_t *pSetupData = pUrb->pMsg->b_rptr;
+
         /*
          * Initialize the Ctrl Xfer Header.
@@ -3093 +3096 @@
             && cbData)
         {
-            pUrb->pMsg->b_rptr += VBOXUSB_CTRL_XFER_SIZE;
-            bcopy(pUrb->pMsg->b_rptr, pReq->ctrl_data->b_wptr, cbData);
+            bcopy(pSetupData + VBOXUSB_CTRL_XFER_SIZE, pReq->ctrl_data->b_wptr, cbData);
             pReq->ctrl_data->b_wptr += cbData;
         }
@@ -3104 +3106 @@
          * Initialize callbacks and timeouts.
          */
-        usb_req_attrs_t fAttributes = USB_ATTRS_AUTOCLEARING;
-        if (   pUrb->enmDir == VUSBDIRECTION_IN
-            && pUrb->fShortOk)
-        {
-            fAttributes |= USB_ATTRS_SHORT_XFER_OK;
-        }
-        pReq->ctrl_cb             = vboxUSBSolarisCtrlXferCompleted;
-        pReq->ctrl_exc_cb         = vboxUSBSolarisCtrlXferCompleted;
+        pReq->ctrl_cb             = vboxUsbSolarisCtrlXferCompleted;
+        pReq->ctrl_exc_cb         = vboxUsbSolarisCtrlXferCompleted;
         pReq->ctrl_timeout        = VBOXUSB_CTRL_XFER_TIMEOUT;
-        pReq->ctrl_attributes     = fAttributes;
-
+        pReq->ctrl_attributes     = USB_ATTRS_AUTOCLEARING | USB_ATTRS_SHORT_XFER_OK;
         pReq->ctrl_client_private = (usb_opaque_t)pUrb;
-
-        LogFunc((DEVICE_NAME ":vboxUSBSolarisCtrlXfer ctrl_wLength=%#RX16 cbData=%#zx fShortOk=%RTbool\n", pReq->ctrl_wLength,
-                 cbData, !!(fAttributes & USB_ATTRS_SHORT_XFER_OK)));
-        Log((DEVICE_NAME ":vboxUSBSolarisCtrlXfer %.*Rhxd\n", VBOXUSB_CTRL_XFER_SIZE, pSetupData));
 
         /*
          * Submit the request.
          */
-        rc = usb_pipe_ctrl_xfer(pEp->pPipe, pReq, USB_FLAGS_NOSLEEP);
-
+        int rc = usb_pipe_ctrl_xfer(pEp->pPipe, pReq, USB_FLAGS_NOSLEEP);
         if (RT_LIKELY(rc == USB_SUCCESS))
             return VINF_SUCCESS;
-        else
-        {
-            LogRel((DEVICE_NAME ":vboxUSBSolarisCtrlXfer usb_pipe_ctrl_xfer failed! rc=%d\n", rc));
-            rc = VERR_PIPE_IO_ERROR;
-        }
+
+        LogRel((DEVICE_NAME ": vboxUsbSolarisCtrlXfer: Request failed! bEndpoint=%#x rc=%d\n", pUrb->bEndpoint, rc));
 
         usb_free_ctrl_req(pReq);
-    }
-    else
-    {
-        LogRel((DEVICE_NAME ":vboxUSBSolarisCtrlXfer failed to alloc request.\n"));
-        rc = VERR_NO_MEMORY;
-    }
-
-    return rc;
+        return VERR_PIPE_IO_ERROR;
+    }
+
+    LogRel((DEVICE_NAME ": vboxUsbSolarisCtrlXfer: Failed to alloc request for %u bytes\n", cbData));
+    return VERR_NO_MEMORY;
 }
 
@@ -3152 +3136 @@
  * @param   pReq             The Ctrl request.
  */
-LOCAL void vboxUSBSolarisCtrlXferCompleted(usb_pipe_handle_t pPipe, usb_ctrl_req_t *pReq)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisCtrlXferCompleted pPipe=%p pReq=%p\n", pPipe, pReq));
+LOCAL void vboxUsbSolarisCtrlXferCompleted(usb_pipe_handle_t pPipe, usb_ctrl_req_t *pReq)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisCtrlXferCompleted: pPipe=%p pReq=%p\n", pPipe, pReq));
+    Assert(pReq);
+    Assert(!(pReq->ctrl_cb_flags & USB_CB_INTR_CONTEXT));
 
     vboxusb_urb_t *pUrb   = (vboxusb_urb_t *)pReq->ctrl_client_private;
@@ -3161 +3147 @@
         /*
          * Funky stuff: We need to reconstruct the header for control transfers.
-         * Let us chain along the data and while we dequeue the URB we attempt to
-         * concatenate the entire message there.
+         * Let us chain along the data and concatenate the entire message.
          */
         mblk_t *pSetupMsg = allocb(sizeof(VUSBSETUP), BPRI_MED);
@@ -3169 +3154 @@
             VUSBSETUP SetupData;
             SetupData.bmRequestType = pReq->ctrl_bmRequestType;
-            SetupData.bRequest = pReq->ctrl_bRequest;
-            SetupData.wValue = pReq->ctrl_wValue;
-            SetupData.wIndex = pReq->ctrl_wIndex;
-            SetupData.wLength = pReq->ctrl_wLength;
+            SetupData.bRequest      = pReq->ctrl_bRequest;
+            SetupData.wValue        = pReq->ctrl_wValue;
+            SetupData.wIndex        = pReq->ctrl_wIndex;
+            SetupData.wLength       = pReq->ctrl_wLength;
+
             bcopy(&SetupData, pSetupMsg->b_wptr, sizeof(VUSBSETUP));
             pSetupMsg->b_wptr += sizeof(VUSBSETUP);
 
             /*
-             * Should be safe to update pMsg here without the state mutex, see vboxUSBSolarisSendURB()
-             * and vboxUSBSolarisQueueURB() as the URB state is (still) not VBOXUSB_URB_STATE_FREE.
+             * Should be safe to update pMsg here without the state mutex as typically nobody else
+             * touches this URB in the inflight list.
+             *
+             * The reason we choose to use vboxUsbSolarisConcatMsg here is that we don't assume the
+             * message returned by Solaris is one contiguous chunk in 'pMsg->b_rptr'.
              */
+            Assert(!pUrb->pMsg);
             pUrb->pMsg = pSetupMsg;
             pUrb->pMsg->b_cont = pReq->ctrl_data;
             pReq->ctrl_data = NULL;
-            vboxUSBSolarisConcatMsg(pUrb);
-
-#ifdef DEBUG_ramshankar
-            if (   pUrb->pMsg
-                && pUrb->pMsg->b_cont == NULL)  /* Concat succeeded */
-            {
-                Log((DEVICE_NAME ":vboxUSBSolarisCtrlXferCompleted prepended header rc=%d cbData=%d.\n",
-                     pReq->ctrl_completion_reason, MBLKL(pUrb->pMsg)));
-                Log((DEVICE_NAME ":%.*Rhxd\n", MBLKL(pUrb->pMsg), pUrb->pMsg->b_rptr));
-            }
-#endif
-
-            /*
-             * Update the URB and move to landed list for reaping.
-             */
-            vboxUSBSolarisDeQueueURB(pUrb, pReq->ctrl_completion_reason);
+            vboxUsbSolarisConcatMsg(pUrb);
         }
         else
-        {
-            LogRel((DEVICE_NAME ":vboxUSBSolarisCtrlXferCompleted failed to alloc %d bytes for Setup Header.\n",
-                    sizeof(VUSBSETUP)));
-        }
+            LogRel((DEVICE_NAME ": vboxUsbSolarisCtrlXferCompleted: Failed to alloc %u bytes for header\n", sizeof(VUSBSETUP)));
+
+        /*
+         * Update the URB and move to landed list for reaping.
+         */
+        vboxUsbSolarisDeQueueUrb(pUrb, pReq->ctrl_completion_reason);
     }
     else
-        LogRel((DEVICE_NAME ":vboxUSBSolarisCtrlXferCompleted Extreme error! missing private data.\n"));
+        LogRel((DEVICE_NAME ": vboxUsbSolarisCtrlXferCompleted: Extreme error! missing private data\n"));
 
     usb_free_ctrl_req(pReq);
@@ -3214 +3191 @@
 
 /**
- * Perform a Bulk Xfer.
+ * Performs a Bulk Xfer.
  *
  * @param   pState          The USB device instance.
@@ -3223 +3200 @@
  * @remarks Any errors, the caller should free pUrb->pMsg.
  */
-LOCAL int vboxUSBSolarisBulkXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisBulkXfer pState=%p pEp=%p pUrb=%p enmDir=%d cbData=%d\n", pState, pEp, pUrb,
+LOCAL int vboxUsbSolarisBulkXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisBulkXfer: pState=%p pEp=%p pUrb=%p enmDir=%d cbData=%d\n", pState, pEp, pUrb,
              pUrb->enmDir, pUrb->cbDataR3));
 
@@ -3231 +3208 @@
      * Allocate a wrapper request.
      */
-    int rc = VINF_SUCCESS;
-    usb_bulk_req_t *pReq = usb_alloc_bulk_req(pState->pDip, pUrb->enmDir == VUSBDIRECTION_IN ? pUrb->cbDataR3 : 0,
-                                              USB_FLAGS_NOSLEEP);
+    size_t const cbAlloc = pUrb->enmDir == VUSBDIRECTION_IN ? pUrb->cbDataR3 : 0;
+    usb_bulk_req_t *pReq = usb_alloc_bulk_req(pState->pDip, cbAlloc, USB_FLAGS_SLEEP);
     if (RT_LIKELY(pReq))
     {
@@ -3241 +3217 @@
         usb_req_attrs_t fAttributes = USB_ATTRS_AUTOCLEARING;
         if (pUrb->enmDir == VUSBDIRECTION_OUT)
+        {
             pReq->bulk_data = pUrb->pMsg;
+            pUrb->pMsg = NULL;
+        }
         else if (   pUrb->enmDir == VUSBDIRECTION_IN
                  && pUrb->fShortOk)
@@ -3248 +3227 @@
         }
 
+        Assert(!pUrb->pMsg);
         pReq->bulk_len            = pUrb->cbDataR3;
-        pReq->bulk_cb             = vboxUSBSolarisBulkXferCompleted;
-        pReq->bulk_exc_cb         = vboxUSBSolarisBulkXferCompleted;
-        pReq->bulk_timeout        = VBOXUSB_BULK_XFER_TIMEOUT;
+        pReq->bulk_cb             = vboxUsbSolarisBulkXferCompleted;
+        pReq->bulk_exc_cb         = vboxUsbSolarisBulkXferCompleted;
+        pReq->bulk_timeout        = 0;
         pReq->bulk_attributes     = fAttributes;
         pReq->bulk_client_private = (usb_opaque_t)pUrb;
@@ -3258 +3238 @@
         if (RT_UNLIKELY(pUrb->cbDataR3 > pState->cbMaxBulkXfer))
         {
-            LogRel((DEVICE_NAME ":vboxUSBSolarisBulkXfer requesting %d bytes when only %d bytes supported by device\n",
+            LogRel((DEVICE_NAME ": vboxUsbSolarisBulkXfer: Requesting %d bytes when only %d bytes supported by device\n",
                         pUrb->cbDataR3, pState->cbMaxBulkXfer));
         }
@@ -3265 +3245 @@
          * Submit the request.
          */
-        rc = usb_pipe_bulk_xfer(pEp->pPipe, pReq, USB_FLAGS_NOSLEEP);
-
+        int rc = usb_pipe_bulk_xfer(pEp->pPipe, pReq, USB_FLAGS_NOSLEEP);
         if (RT_LIKELY(rc == USB_SUCCESS))
             return VINF_SUCCESS;
-        else
-        {
-            LogRel((DEVICE_NAME ":vboxUSBSolarisBulkXfer usb_pipe_bulk_xfer enmDir=%#x Ep=%#x failed! rc=%d\n", pUrb->enmDir,
-                    pUrb->bEndpoint, rc));
-            rc = VERR_PIPE_IO_ERROR;
-        }
-
-        if (pUrb->enmDir == VUSBDIRECTION_OUT) /* pUrb->pMsg freed by caller */
-            pReq->bulk_data = NULL;
+
+        LogRel((DEVICE_NAME ": vboxUsbSolarisBulkXfer: Request failed! Ep=%#x rc=%d cbData=%u\n", pUrb->bEndpoint, rc,
+                pReq->bulk_len));
 
         usb_free_bulk_req(pReq);
-    }
-    else
-    {
-        LogRel((DEVICE_NAME ":vboxUSBSolarisBulkXfer failed to alloc bulk request.\n"));
-        rc = VERR_NO_MEMORY;
-    }
-
-    return rc;
+        return VERR_PIPE_IO_ERROR;
+    }
+
+    LogRel((DEVICE_NAME ": vboxUsbSolarisBulkXfer: Failed to alloc bulk request\n"));
+    return VERR_NO_MEMORY;
 }
 
@@ -3297 +3267 @@
  * @param   pReq            The Bulk request.
  */
-LOCAL void vboxUSBSolarisBulkXferCompleted(usb_pipe_handle_t pPipe, usb_bulk_req_t *pReq)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisBulkXferCompleted pPipe=%p pReq=%p\n", pPipe, pReq));
+LOCAL void vboxUsbSolarisBulkXferCompleted(usb_pipe_handle_t pPipe, usb_bulk_req_t *pReq)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisBulkXferCompleted: pPipe=%p pReq=%p\n", pPipe, pReq));
+
+    Assert(pReq);
+    Assert(!(pReq->bulk_cb_flags & USB_CB_INTR_CONTEXT));
 
     vboxusb_ep_t *pEp = (vboxusb_ep_t *)usb_pipe_get_private(pPipe);
@@ -3307 +3280 @@
         if (RT_LIKELY(pUrb))
         {
-            if (pUrb->enmDir == VUSBDIRECTION_OUT)
+            Assert(!pUrb->pMsg);
+            if (   pUrb->enmDir == VUSBDIRECTION_IN
+                && pReq->bulk_data)
+            {
+                pUrb->pMsg = pReq->bulk_data;
                 pReq->bulk_data = NULL;
-            else
-            {
-                if (pReq->bulk_completion_reason == USB_CR_OK)
-                {
-                    pUrb->pMsg = pReq->bulk_data;
-                    pReq->bulk_data = NULL;
-                    vboxUSBSolarisConcatMsg(pUrb);
-                }
+                vboxUsbSolarisConcatMsg(pUrb);
             }
-
-            Log((DEVICE_NAME ":vboxUSBSolarisBulkXferCompleted %s. rc=%d cbData=%d\n",
-                    pReq->bulk_completion_reason != USB_CR_OK ? "failed URB" : "success",
-                    pReq->bulk_completion_reason, pUrb->pMsg ? MBLKL(pUrb->pMsg) : 0));
 
             /*
              * Update the URB and move to tail for reaping.
              */
-            vboxUSBSolarisDeQueueURB(pUrb, pReq->bulk_completion_reason);
-            usb_free_bulk_req(pReq);
-            return;
+            vboxUsbSolarisDeQueueUrb(pUrb, pReq->bulk_completion_reason);
         }
         else
-            LogRel((DEVICE_NAME ":vboxUSBSolarisBulkXferCompleted Extreme error! private request data missing.\n"));
+            LogRel((DEVICE_NAME ": vboxUsbSolarisBulkXferCompleted: Extreme error! private request data missing!\n"));
     }
     else
-        Log((DEVICE_NAME ":vboxUSBSolarisBulkXferCompleted Pipe Gone.\n"));
+        Log((DEVICE_NAME ": vboxUsbSolarisBulkXferCompleted: Pipe Gone!\n"));
 
     usb_free_bulk_req(pReq);
@@ -3341 +3305 @@
 
 /**
- * Perform an Interrupt Xfer.
+ * Performs an Interrupt Xfer.
  *
  * @param   pState          The USB device instance.
@@ -3350 +3314 @@
  * @remarks Any errors, the caller should free pUrb->pMsg.
  */
-LOCAL int vboxUSBSolarisIntrXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisIntrXfer pState=%p pEp=%p pUrb=%p enmDir=%d cbData=%d\n", pState, pEp, pUrb,
+LOCAL int vboxUsbSolarisIntrXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisIntrXfer: pState=%p pEp=%p pUrb=%p enmDir=%d cbData=%d\n", pState, pEp, pUrb,
              pUrb->enmDir, pUrb->cbDataR3));
 
-    int rc = VINF_SUCCESS;
-    usb_intr_req_t *pReq = usb_alloc_intr_req(pState->pDip, 0 /* length */, USB_FLAGS_NOSLEEP);
+    usb_intr_req_t *pReq = usb_alloc_intr_req(pState->pDip, 0 /* length */, USB_FLAGS_SLEEP);
     if (RT_LIKELY(pReq))
     {
@@ -3362 +3325 @@
          * Initialize Intr Xfer, callbacks & timeouts.
          */
+        usb_req_attrs_t fAttributes = USB_ATTRS_AUTOCLEARING;
         if (pUrb->enmDir == VUSBDIRECTION_OUT)
         {
-            pReq->intr_data       = pUrb->pMsg;
-            pReq->intr_attributes = USB_ATTRS_AUTOCLEARING;
+            pReq->intr_data = pUrb->pMsg;
+            pUrb->pMsg = NULL;
         }
         else
         {
             Assert(pUrb->enmDir == VUSBDIRECTION_IN);
-            pReq->intr_data       = NULL;
-            pReq->intr_attributes = USB_ATTRS_AUTOCLEARING | USB_ATTRS_ONE_XFER | (pUrb->fShortOk ? USB_ATTRS_SHORT_XFER_OK : 0);
-        }
-
+            fAttributes |= USB_ATTRS_ONE_XFER;
+            if (pUrb->fShortOk)
+                fAttributes |= USB_ATTRS_SHORT_XFER_OK;
+        }
+
+        Assert(!pUrb->pMsg);
         pReq->intr_len            = pUrb->cbDataR3; /* Not pEp->EpDesc.wMaxPacketSize */
-        pReq->intr_cb             = vboxUSBSolarisIntrXferCompleted;
-        pReq->intr_exc_cb         = vboxUSBSolarisIntrXferCompleted;
-        pReq->intr_timeout        = VBOXUSB_INTR_XFER_TIMEOUT;
+        pReq->intr_cb             = vboxUsbSolarisIntrXferCompleted;
+        pReq->intr_exc_cb         = vboxUsbSolarisIntrXferCompleted;
+        pReq->intr_timeout        = 0;
+        pReq->intr_attributes     = fAttributes;
         pReq->intr_client_private = (usb_opaque_t)pUrb;
 
@@ -3383 +3350 @@
          * Submit the request.
          */
-        rc = usb_pipe_intr_xfer(pEp->pPipe, pReq, USB_FLAGS_NOSLEEP);
-
+        int rc = usb_pipe_intr_xfer(pEp->pPipe, pReq, USB_FLAGS_NOSLEEP);
         if (RT_LIKELY(rc == USB_SUCCESS))
             return VINF_SUCCESS;
-        else
-        {
-            LogRel((DEVICE_NAME ":vboxUSBSolarisIntrXfer usb_pipe_intr_xfer failed! rc=%d\n", rc));
-            rc = VERR_PIPE_IO_ERROR;
-        }
-
-        pReq->intr_data = NULL;
+
+        LogRel((DEVICE_NAME ": vboxUsbSolarisIntrXfer: usb_pipe_intr_xfer failed! rc=%d bEndpoint=%#x\n", rc, pUrb->bEndpoint));
+
         usb_free_intr_req(pReq);
-    }
-    else
-    {
-        LogRel((DEVICE_NAME ":vboxUSBSolarisIntrXfer failed to alloc intr request.\n"));
-        rc = VERR_NO_MEMORY;
-    }
-
-    return rc;
+        return VERR_PIPE_IO_ERROR;
+    }
+
+    LogRel((DEVICE_NAME ": vboxUsbSolarisIntrXfer: Failed to alloc intr request\n"));
+    return VERR_NO_MEMORY;
 }
 
@@ -3412 +3371 @@
  * @param   pReq            The Intr request.
  */
-LOCAL void vboxUSBSolarisIntrXferCompleted(usb_pipe_handle_t pPipe, usb_intr_req_t *pReq)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisIntrXferCompleted pPipe=%p pReq=%p\n", pPipe, pReq));
-
-    vboxusb_ep_t *pEp = (vboxusb_ep_t *)usb_pipe_get_private(pPipe);
-    if (RT_LIKELY(pEp))
-    {
-        vboxusb_urb_t *pUrb = (vboxusb_urb_t *)pReq->intr_client_private;
-        if (RT_LIKELY(pUrb))
-        {
-            if (pUrb->enmDir == VUSBDIRECTION_OUT)
-                pReq->intr_data = NULL;
-            else
-            {
-                if (pReq->intr_completion_reason == USB_CR_OK)
-                {
-                    pUrb->pMsg = pReq->intr_data;
-                    pReq->intr_data = NULL;
-                }
-            }
-
-            Log((DEVICE_NAME ":vboxUSBSolarisIntrXferCompleted rc=%d pMsg=%p enmDir=%#x\n", pReq->intr_completion_reason,
-                 pUrb->pMsg, pUrb->enmDir));
-
-            /*
-             * Update the URB and move to landed list for reaping.
-             */
-            vboxUSBSolarisDeQueueURB(pUrb, pReq->intr_completion_reason);
-            usb_free_intr_req(pReq);
-            return;
-        }
-        else
-            LogRel((DEVICE_NAME ":vboxUSBSolarisIntrXferCompleted Extreme error! private request data missing.\n"));
+LOCAL void vboxUsbSolarisIntrXferCompleted(usb_pipe_handle_t pPipe, usb_intr_req_t *pReq)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisIntrXferCompleted: pPipe=%p pReq=%p\n", pPipe, pReq));
+
+    Assert(pReq);
+    Assert(!(pReq->intr_cb_flags & USB_CB_INTR_CONTEXT));
+
+    vboxusb_urb_t *pUrb = (vboxusb_urb_t *)pReq->intr_client_private;
+    if (RT_LIKELY(pUrb))
+    {
+        if (   pUrb->enmDir == VUSBDIRECTION_IN
+            && pReq->intr_data)
+        {
+            pUrb->pMsg = pReq->intr_data;
+            pReq->intr_data = NULL;
+            vboxUsbSolarisConcatMsg(pUrb);
+        }
+
+        /*
+         * Update the URB and move to landed list for reaping.
+         */
+        vboxUsbSolarisDeQueueUrb(pUrb, pReq->intr_completion_reason);
     }
     else
-        Log((DEVICE_NAME ":vboxUSBSolarisIntrXferCompleted Pipe Gone.\n"));
+        LogRel((DEVICE_NAME ": vboxUsbSolarisIntrXferCompleted: Extreme error! private request data missing\n"));
 
     usb_free_intr_req(pReq);
@@ -3454 +3402 @@
 
 /**
- * Perform an Isochronous Xfer.
+ * Performs an Isochronous Xfer.
  *
  * @param   pState          The USB device instance.
@@ -3463 +3411 @@
  * @remarks Any errors, the caller should free pUrb->pMsg.
  */
-LOCAL int vboxUSBSolarisIsocXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb)
-{
-//    LogFunc((DEVICE_NAME ":vboxUSBSolarisIsocXfer pState=%p pEp=%p pUrb=%p\n", pState, pEp, pUrb));
+LOCAL int vboxUsbSolarisIsocXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb)
+{
+    /* LogFunc((DEVICE_NAME ": vboxUsbSolarisIsocXfer: pState=%p pEp=%p pUrb=%p\n", pState, pEp, pUrb)); */
 
     /*
@@ -3474 +3422 @@
     if (pUrb->enmDir == VUSBDIRECTION_IN)
     {
-        Log((DEVICE_NAME ":vboxUSBSolarisIsocXfer Isoc. In queueing.\n"));
+        Log((DEVICE_NAME ": vboxUsbSolarisIsocXfer: Isoc. IN - Queueing\n"));
 
         mutex_enter(&pState->Mtx);
@@ -3485 +3433 @@
             {
                 mutex_exit(&pState->Mtx);
-                Log((DEVICE_NAME ":vboxUSBSolarisIsocXfer Max Isoc. data %d bytes queued\n", pEp->cbMaxIsocData));
+                Log((DEVICE_NAME ": vboxUsbSolarisIsocXfer: Max Isoc. data %d bytes queued\n", pEp->cbMaxIsocData));
                 return VERR_TOO_MUCH_DATA;
             }
@@ -3500 +3448 @@
     int rc = VINF_SUCCESS;
     usb_isoc_req_t *pReq = usb_alloc_isoc_req(pState->pDip, pUrb->cIsocPkts, cbData, USB_FLAGS_NOSLEEP);
-    Log((DEVICE_NAME ":vboxUSBSolarisIsocXfer enmDir=%#x cIsocPkts=%d aIsocPkts[0]=%d cbDataR3=%d\n", pUrb->enmDir,
+    Log((DEVICE_NAME ": vboxUsbSolarisIsocXfer: enmDir=%#x cIsocPkts=%d aIsocPkts[0]=%d cbDataR3=%d\n", pUrb->enmDir,
                     pUrb->cIsocPkts, pUrb->aIsocPkts[0].cbPkt, pUrb->cbDataR3));
     if (RT_LIKELY(pReq))
@@ -3514 +3462 @@
             pReq->isoc_data           = pUrb->pMsg;
             pReq->isoc_attributes     = USB_ATTRS_AUTOCLEARING | USB_ATTRS_ISOC_XFER_ASAP;
-            pReq->isoc_cb             = vboxUSBSolarisIsocOutXferCompleted;
-            pReq->isoc_exc_cb         = vboxUSBSolarisIsocOutXferCompleted;
+            pReq->isoc_cb             = vboxUsbSolarisIsocOutXferCompleted;
+            pReq->isoc_exc_cb         = vboxUsbSolarisIsocOutXferCompleted;
             pReq->isoc_client_private = (usb_opaque_t)pUrb;
         }
@@ -3521 +3469 @@
         {
             pReq->isoc_attributes     = USB_ATTRS_AUTOCLEARING | USB_ATTRS_ISOC_XFER_ASAP | USB_ATTRS_SHORT_XFER_OK;
-            pReq->isoc_cb             = vboxUSBSolarisIsocInXferCompleted;
-            pReq->isoc_exc_cb         = vboxUSBSolarisIsocInXferError;
+            pReq->isoc_cb             = vboxUsbSolarisIsocInXferCompleted;
+            pReq->isoc_exc_cb         = vboxUsbSolarisIsocInXferError;
             pReq->isoc_client_private = (usb_opaque_t)pState;
         }
@@ -3550 +3498 @@
         else
         {
-            LogRel((DEVICE_NAME ":vboxUSBSolarisIsocXfer usb_pipe_isoc_xfer failed! rc=%d\n", rc));
+            LogRel((DEVICE_NAME ": vboxUsbSolarisIsocXfer: usb_pipe_isoc_xfer failed! rc=%d\n", rc));
             rc = VERR_PIPE_IO_ERROR;
 
@@ -3567 +3515 @@
         }
 
-        if (pUrb->enmDir == VUSBDIRECTION_OUT) /* pUrb->pMsg freed by caller */
-            pReq->isoc_data = NULL;
+        if (pUrb->enmDir == VUSBDIRECTION_OUT)
+        {
+            freemsg(pUrb->pMsg);
+            pUrb->pMsg = NULL;
+        }
 
         usb_free_isoc_req(pReq);
@@ -3574 +3525 @@
     else
     {
-        LogRel((DEVICE_NAME ":vboxUSBSolarisIsocXfer failed to alloc isoc req for %d packets\n", pUrb->cIsocPkts));
+        LogRel((DEVICE_NAME ": vboxUsbSolarisIsocXfer: Failed to alloc isoc req for %d packets\n", pUrb->cIsocPkts));
         rc = VERR_NO_MEMORY;
     }
@@ -3590 +3541 @@
  * @remarks Completion callback executes in interrupt context!
  */
-LOCAL void vboxUSBSolarisIsocInXferCompleted(usb_pipe_handle_t pPipe, usb_isoc_req_t *pReq)
-{
-//    LogFunc((DEVICE_NAME ":vboxUSBSolarisIsocInXferCompleted pPipe=%p pReq=%p\n", pPipe, pReq));
+LOCAL void vboxUsbSolarisIsocInXferCompleted(usb_pipe_handle_t pPipe, usb_isoc_req_t *pReq)
+{
+    /* LogFunc((DEVICE_NAME ": vboxUsbSolarisIsocInXferCompleted: pPipe=%p pReq=%p\n", pPipe, pReq)); */
 
     vboxusb_state_t *pState = (vboxusb_state_t *)pReq->isoc_client_private;
@@ -3607 +3558 @@
             if (pReq->isoc_error_count == pReq->isoc_pkts_count)
             {
-                Log((DEVICE_NAME ":vboxUSBSolarisIsocInXferCompleted stopping polling! Too many errors.\n"));
+                Log((DEVICE_NAME ": vboxUsbSolarisIsocInXferCompleted: Stopping polling! Too many errors\n"));
                 mutex_exit(&pState->Mtx);
                 usb_pipe_stop_isoc_polling(pPipe, USB_FLAGS_NOSLEEP);
@@ -3615 +3566 @@
 #endif
 
+            /** @todo Query and verify this at runtime. */
             AssertCompile(sizeof(VUSBISOC_PKT_DESC) == sizeof(usb_isoc_pkt_descr_t));
-
             if (RT_LIKELY(pReq->isoc_data))
             {
-                Log((DEVICE_NAME ":vboxUSBSolarisIsocInXferCompleted cIsocInUrbs=%d cbIsocInLandedReqs=%d\n", pEp->cIsocInUrbs,
+                Log((DEVICE_NAME ": vboxUsbSolarisIsocInXferCompleted: cIsocInUrbs=%d cbIsocInLandedReqs=%d\n", pEp->cIsocInUrbs,
                      pEp->cbIsocInLandedReqs));
 
@@ -3639 +3590 @@
                         {
                             pUrb->aIsocPkts[i].cbActPkt = pReq->isoc_pkt_descr[i].isoc_pkt_actual_length;
-                            pUrb->aIsocPkts[i].enmStatus = vboxUSBSolarisGetUrbStatus(pReq->isoc_pkt_descr[i].isoc_pkt_status);
+                            pUrb->aIsocPkts[i].enmStatus = vboxUsbSolarisGetUrbStatus(pReq->isoc_pkt_descr[i].isoc_pkt_status);
                         }
 
@@ -3650 +3601 @@
                         mutex_enter(&pState->Mtx);
                         list_insert_tail(&pState->hLandedUrbs, pUrb);
-                        vboxUSBSolarisNotifyComplete(pState);
+                        ++pState->cLandedUrbs;
+                        vboxUsbSolarisNotifyComplete(pState);
                     }
                     else
@@ -3657 +3609 @@
                            Reap time */
                         pEp->cIsocInUrbs = 0;
-                        LogRel((DEVICE_NAME ":vboxUSBSolarisIsocInXferCompleted Extreme error! Isoc. counter b0rked!\n"));
+                        LogRel((DEVICE_NAME ": vboxUsbSolarisIsocInXferCompleted: Extreme error! Isoc. counter borked!\n"));
                     }
 
@@ -3665 +3617 @@
                 }
 
-#if 0
-                /*
-                 * If the maximum buffer size is reached, discard the oldest data.
-                 */
-                if (pEp->cbIsocInLandedReqs + MBLKL(pReq->isoc_data) > pEp->cbMaxIsocData)
-                {
-                    vboxusb_isoc_req_t *pOldReq = list_remove_head(&pEp->hIsocInLandedReqs);
-                    if (RT_LIKELY(pOldReq))
-                    {
-                        pEp->cbIsocInLandedReqs -= MBLKL(pOldReq->pMsg);
-                        kmem_free(pOldReq, sizeof(vboxusb_isoc_req_t));
-                    }
-                }
-
                 mutex_exit(&pState->Mtx);
-
-                /*
-                 * Buffer incoming data if the guest has not yet queued any Input URBs.
-                 */
-                Log((DEVICE_NAME ":vboxUSBSolarisIsocInXferCompleted Buffering\n"));
-                vboxusb_isoc_req_t *pIsocReq = kmem_alloc(sizeof(vboxusb_isoc_req_t), KM_NOSLEEP);
-                if (RT_LIKELY(pIsocReq))
-                {
-                    pIsocReq->pMsg = pReq->isoc_data;
-                    pReq->isoc_data = NULL;
-                    pIsocReq->cIsocPkts = pReq->isoc_pkts_count;
-#if 0
-                    for (unsigned i = 0; i < pReq->isoc_pkts_count; i++)
-                    {
-                        pIsocReq->aIsocPkts[i].cbActPkt = pReq->isoc_pkt_descr[i].isoc_pkt_actual_length;
-                        pIsocReq->aIsocPkts[i].enmStatus = vboxUSBSolarisGetUrbStatus(pReq->isoc_pkt_descr[i].isoc_pkt_status);
-                    }
-#else
-                    bcopy(pReq->isoc_pkt_descr, pIsocReq->aIsocPkts, pReq->isoc_pkts_count * sizeof(VUSBISOC_PKT_DESC));
-#endif
-
-                    mutex_enter(&pState->Mtx);
-                    list_insert_tail(&pEp->hIsocInLandedReqs, pIsocReq);
-                    pEp->cbIsocInLandedReqs += MBLKL(pIsocReq->pMsg);
-                    mutex_exit(&pState->Mtx);
-                }
-                else
-                {
-                    LogRel((DEVICE_NAME ":vboxUSBSolarisIsocInXferCompleted failed to alloc %d bytes for Isoc. queueing\n",
-                            sizeof(vboxusb_isoc_req_t)));
-                }
-
-                /*
-                 * Drain the input URB buffer with the device buffer, queueing them with the landed URBs.
-                 */
-                mutex_enter(&pState->Mtx);
-                while (pEp->cIsocInUrbs)
-                {
-                    vboxusb_urb_t *pUrb = list_remove_head(&pEp->hIsocInUrbs);
-                    if (RT_UNLIKELY(!pUrb))
-                        break;
-
-                    vboxusb_isoc_req_t *pBuffReq = list_remove_head(&pEp->hIsocInLandedReqs);
-                    if (!pBuffReq)
-                    {
-                        list_insert_head(&pEp->hIsocInUrbs, pUrb);
-                        break;
-                    }
-
-                    --pEp->cIsocInUrbs;
-                    pEp->cbIsocInLandedReqs -= MBLKL(pBuffReq->pMsg);
-                    mutex_exit(&pState->Mtx);
-
-#if 0
-                    for (unsigned i = 0; i < pBuffReq->cIsocPkts; i++)
-                    {
-                        pUrb->aIsocPkts[i].cbActPkt = pBuffReq->aIsocPkts[i].cbActPkt;
-                        pUrb->aIsocPkts[i].enmStatus = pBuffReq->aIsocPkts[i].enmStatus;
-                    }
-#else
-                    bcopy(pBuffReq->aIsocPkts, pUrb->aIsocPkts, pBuffReq->cIsocPkts * sizeof(VUSBISOC_PKT_DESC));
-#endif
-                    pUrb->pMsg = pBuffReq->pMsg;
-                    pBuffReq->pMsg = NULL;
-                    kmem_free(pBuffReq, sizeof(vboxusb_isoc_req_t));
-
-                    /*
-                     * Move to landed list
-                     */
-                    mutex_enter(&pState->Mtx);
-                    list_insert_tail(&pState->hLandedUrbs, pUrb);
-                    vboxUSBSolarisNotifyComplete(pState);
-                }
-#endif
-
-                mutex_exit(&pState->Mtx);
-                usb_free_isoc_req(pReq);
-                return;
             }
             else
-                LogRel((DEVICE_NAME ":vboxUSBSolarisIsocInXferCompleted data missing.\n"));
+                LogRel((DEVICE_NAME ": vboxUsbSolarisIsocInXferCompleted: Data missing\n"));
         }
         else
-            LogRel((DEVICE_NAME ":vboxUSBSolarisIsocInXferCompleted Pipe Gone.\n"));
+            LogRel((DEVICE_NAME ": vboxUsbSolarisIsocInXferCompleted: Pipe Gone\n"));
     }
     else
-        Log((DEVICE_NAME ":vboxUSBSolarisIsocInXferCompleted State Gone.\n"));
+        Log((DEVICE_NAME ": vboxUsbSolarisIsocInXferCompleted: State Gone\n"));
 
     usb_free_isoc_req(pReq);
@@ -3779 +3639 @@
  * @remarks Completion callback executes in interrupt context!
  */
-LOCAL void vboxUSBSolarisIsocInXferError(usb_pipe_handle_t pPipe, usb_isoc_req_t *pReq)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisIsocInXferError pPipe=%p pReq=%p\n", pPipe, pReq));
+LOCAL void vboxUsbSolarisIsocInXferError(usb_pipe_handle_t pPipe, usb_isoc_req_t *pReq)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisIsocInXferError: pPipe=%p pReq=%p\n", pPipe, pReq));
 
     vboxusb_state_t *pState = (vboxusb_state_t *)pReq->isoc_client_private;
     if (RT_UNLIKELY(!pState))
     {
-        Log((DEVICE_NAME ":vboxUSBSolarisIsocInXferError State Gone.\n"));
+        Log((DEVICE_NAME ": vboxUsbSolarisIsocInXferError: State Gone\n"));
         usb_free_isoc_req(pReq);
         return;
@@ -3795 +3655 @@
     if (RT_UNLIKELY(!pEp))
     {
-        Log((DEVICE_NAME ":vboxUSBSolarisIsocInXferError Pipe Gone.\n"));
+        Log((DEVICE_NAME ": vboxUsbSolarisIsocInXferError: Pipe Gone\n"));
         mutex_exit(&pState->Mtx);
         usb_free_isoc_req(pReq);
@@ -3811 +3671 @@
             mutex_exit(&pState->Mtx);
             usb_pipe_isoc_xfer(pPipe, pReq, USB_FLAGS_NOSLEEP);
-            Log((DEVICE_NAME ":vboxUSBSolarisIsocInXferError resubmitted Isoc. IN request due to immediately unavailable "
-                 "resources.\n"));
-
+            Log((DEVICE_NAME ": vboxUsbSolarisIsocInXferError: Resubmitted Isoc. IN request due to unavailable resources\n"));
             return;
         }
@@ -3828 +3686 @@
         default:
         {
-            Log((DEVICE_NAME ":vboxUSBSolarisIsocInXferError stopping Isoc. In. polling due to rc=%d\n",
+            Log((DEVICE_NAME ": vboxUsbSolarisIsocInXferError: Stopping Isoc. IN polling due to rc=%d\n",
                  pReq->isoc_completion_reason));
             pEp->fIsocPolling = false;
@@ -3846 +3704 @@
     {
         --pEp->cIsocInUrbs;
-        Log((DEVICE_NAME ":vboxUSBSolarisIsocInXferError Deleting last queued URB as it failed.\n"));
+        Log((DEVICE_NAME ": vboxUsbSolarisIsocInXferError: Deleting last queued URB as it failed\n"));
         freemsg(pUrb->pMsg);
         RTMemFree(pUrb);
-        vboxUSBSolarisNotifyComplete(pState);
+        vboxUsbSolarisNotifyComplete(pState);
     }
 
@@ -3863 +3721 @@
  * @remarks Completion callback executes in interrupt context!
  */
-LOCAL void vboxUSBSolarisIsocOutXferCompleted(usb_pipe_handle_t pPipe, usb_isoc_req_t *pReq)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisIsocOutXferCompleted pPipe=%p pReq=%p\n", pPipe, pReq));
+LOCAL void vboxUsbSolarisIsocOutXferCompleted(usb_pipe_handle_t pPipe, usb_isoc_req_t *pReq)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisIsocOutXferCompleted: pPipe=%p pReq=%p\n", pPipe, pReq));
 
     vboxusb_ep_t *pEp = (vboxusb_ep_t *)usb_pipe_get_private(pPipe);
@@ -3878 +3736 @@
                 cbActPkt += pReq->isoc_pkt_descr[i].isoc_pkt_actual_length;
                 pUrb->aIsocPkts[i].cbActPkt = pReq->isoc_pkt_descr[i].isoc_pkt_actual_length;
-                pUrb->aIsocPkts[i].enmStatus = vboxUSBSolarisGetUrbStatus(pReq->isoc_pkt_descr[i].isoc_pkt_status);
+                pUrb->aIsocPkts[i].enmStatus = vboxUsbSolarisGetUrbStatus(pReq->isoc_pkt_descr[i].isoc_pkt_status);
             }
 
-            Log((DEVICE_NAME ":vboxUSBSolarisIsocOutXferCompleted cIsocPkts=%d cbData=%d cbActPkt=%d\n", pUrb->cIsocPkts,
+            Log((DEVICE_NAME ": vboxUsbSolarisIsocOutXferCompleted: cIsocPkts=%d cbData=%d cbActPkt=%d\n", pUrb->cIsocPkts,
                  pUrb->cbDataR3, cbActPkt));
 
@@ -3900 +3758 @@
              * Update the URB and move to landed list for reaping.
              */
-            vboxUSBSolarisDeQueueURB(pUrb, pReq->isoc_completion_reason);
-            usb_free_isoc_req(pReq);
-            return;
+            vboxUsbSolarisDeQueueUrb(pUrb, pReq->isoc_completion_reason);
         }
         else
-            Log((DEVICE_NAME ":vboxUSBSolarisIsocOutXferCompleted missing private data!?! Dropping OUT pUrb.\n"));
+            Log((DEVICE_NAME ": vboxUsbSolarisIsocOutXferCompleted: Missing private data!?! Dropping OUT pUrb\n"));
     }
     else
-        Log((DEVICE_NAME ":vboxUSBSolarisIsocOutXferCompleted Pipe Gone.\n"));
+        Log((DEVICE_NAME ": vboxUsbSolarisIsocOutXferCompleted: Pipe Gone\n"));
 
     usb_free_isoc_req(pReq);
@@ -3921 +3777 @@
  * @returns Solaris USB error code.
  */
-LOCAL int vboxUSBSolarisDeviceDisconnected(dev_info_t *pDip)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisDeviceDisconnected pDip=%p\n", pDip));
+LOCAL int vboxUsbSolarisDeviceDisconnected(dev_info_t *pDip)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisDeviceDisconnected: pDip=%p\n", pDip));
 
     int instance = ddi_get_instance(pDip);
@@ -3938 +3794 @@
         pState->DevState = USB_DEV_DISCONNECTED;
 
-        vboxUSBSolarisCloseAllPipes(pState, true /* ControlPipe */);
-        vboxUSBSolarisNotifyHotplug(pState);
+        vboxUsbSolarisCloseAllPipes(pState, true /* ControlPipe */);
+        vboxUsbSolarisNotifyUnplug(pState);
 
         mutex_exit(&pState->Mtx);
@@ -3947 +3803 @@
     }
 
-    LogRel((DEVICE_NAME ":vboxUSBSolarisDeviceDisconnected failed to get device state!\n"));
+    LogRel((DEVICE_NAME ": vboxUsbSolarisDeviceDisconnected: Failed to get device state!\n"));
     return USB_FAILURE;
 }
@@ -3959 +3815 @@
  * @returns Solaris USB error code.
  */
-LOCAL int vboxUSBSolarisDeviceReconnected(dev_info_t *pDip)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisDeviceReconnected pDip=%p\n", pDip));
+LOCAL int vboxUsbSolarisDeviceReconnected(dev_info_t *pDip)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisDeviceReconnected: pDip=%p\n", pDip));
 
     int instance = ddi_get_instance(pDip);
@@ -3968 +3824 @@
     if (RT_LIKELY(pState))
     {
-        vboxUSBSolarisDeviceRestore(pState);
+        vboxUsbSolarisDeviceRestore(pState);
         return USB_SUCCESS;
     }
 
-    LogRel((DEVICE_NAME ":vboxUSBSolarisDeviceReconnected failed to get device state!\n"));
+    LogRel((DEVICE_NAME ": vboxUsbSolarisDeviceReconnected: Failed to get device state!\n"));
     return USB_FAILURE;
 }
@@ -3978 +3834 @@
 
 /**
- * Restore device state after a reconnect or resume.
+ * Restores device state after a reconnect or resume.
  *
  * @param   pState          The USB device instance.
  */
-LOCAL void vboxUSBSolarisDeviceRestore(vboxusb_state_t *pState)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisDeviceRestore pState=%p\n", pState));
+LOCAL void vboxUsbSolarisDeviceRestore(vboxusb_state_t *pState)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisDeviceRestore: pState=%p\n", pState));
     AssertPtrReturnVoid(pState);
 
@@ -3990 +3846 @@
      * Raise device power.
      */
-    vboxUSBSolarisPowerBusy(pState);
+    vboxUsbSolarisPowerBusy(pState);
     int rc = pm_raise_power(pState->pDip, 0 /* component */, USB_DEV_OS_FULL_PWR);
 
@@ -4010 +3866 @@
 
         /* Do we need to inform userland here? */
-        vboxUSBSolarisPowerIdle(pState);
-        Log((DEVICE_NAME ":vboxUSBSolarisDeviceRestore not the same device.\n"));
+        vboxUsbSolarisPowerIdle(pState);
+        Log((DEVICE_NAME ": vboxUsbSolarisDeviceRestore: Not the same device\n"));
         return;
     }
@@ -4029 +3885 @@
     usb_release_access(pState->StateMulti);
 
-    vboxUSBSolarisPowerIdle(pState);
-}
-
-
-/**
- * Restore device state after a reconnect or resume.
+    vboxUsbSolarisPowerIdle(pState);
+}
+
+
+/**
+ * Restores device state after a reconnect or resume.
  *
  * @param   pState          The USB device instance.
@@ -4040 +3896 @@
  * @returns VBox status code.
  */
-LOCAL int vboxUSBSolarisDeviceSuspend(vboxusb_state_t *pState)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisDeviceSuspend pState=%p\n", pState));
+LOCAL int vboxUsbSolarisDeviceSuspend(vboxusb_state_t *pState)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisDeviceSuspend: pState=%p\n", pState));
 
     int rc = VERR_VUSB_DEVICE_IS_SUSPENDED;
@@ -4051 +3907 @@
         case USB_DEV_SUSPENDED:
         {
-            LogRel((DEVICE_NAME ":vboxUSBSolarisDeviceSuspend: Invalid device state %d\n", pState->DevState));
+            LogRel((DEVICE_NAME ": vboxUsbSolarisDeviceSuspend: Invalid device state %d\n", pState->DevState));
             break;
         }
@@ -4062 +3918 @@
             pState->DevState = USB_DEV_DISCONNECTED;
 
+            /** @todo this doesn't make sense when for e.g. an INTR IN URB with infinite
+             *        timeout is pending on the device. Fix suspend logic later. */
             /*
              * Drain pending URBs.
@@ -4081 +3939 @@
             {
                 pState->DevState = PreviousState;
-                LogRel((DEVICE_NAME ":Cannot suspend, still have %d inflight URBs.\n", pState->cInflightUrbs));
+                LogRel((DEVICE_NAME ": Cannot suspend %s %s (Ident=%s), %d inflight URBs\n", pState->szMfg, pState->szProduct,
+                        pState->ClientInfo.szDeviceIdent, pState->cInflightUrbs));
 
                 mutex_exit(&pState->Mtx);
@@ -4097 +3956 @@
             mutex_enter(&pState->Mtx);
 
-            vboxUSBSolarisCloseAllPipes(pState, true /* default pipe */);
-            vboxUSBSolarisNotifyHotplug(pState);
+            vboxUsbSolarisCloseAllPipes(pState, true /* default pipe */);
+            vboxUsbSolarisNotifyUnplug(pState);
 
             mutex_exit(&pState->Mtx);
             usb_release_access(pState->StateMulti);
+
+            LogRel((DEVICE_NAME ": Suspended %s %s (Ident=%s)\n", pState->szMfg, pState->szProduct,
+                    pState->ClientInfo.szDeviceIdent));
             return VINF_SUCCESS;
         }
@@ -4107 +3969 @@
 
     mutex_exit(&pState->Mtx);
-    Log((DEVICE_NAME ":vboxUSBSolarisDeviceSuspend returns %d\n", rc));
+    Log((DEVICE_NAME ": vboxUsbSolarisDeviceSuspend: Returns %d\n", rc));
     return rc;
 }
@@ -4113 +3975 @@
 
 /**
- * Restore device state after a reconnect or resume.
+ * Restores device state after a reconnect or resume.
  *
  * @param   pState          The USB device instance.
  */
-LOCAL void vboxUSBSolarisDeviceResume(vboxusb_state_t *pState)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisDeviceResume pState=%p\n", pState));
-    return vboxUSBSolarisDeviceRestore(pState);
-}
-
-
-/**
- * Flag the PM component as busy so the system will not manage it's power.
+LOCAL void vboxUsbSolarisDeviceResume(vboxusb_state_t *pState)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisDeviceResume: pState=%p\n", pState));
+    return vboxUsbSolarisDeviceRestore(pState);
+}
+
+
+/**
+ * Flags the PM component as busy so the system will not manage it's power.
  *
  * @param   pState          The USB device instance.
  */
-LOCAL void vboxUSBSolarisPowerBusy(vboxusb_state_t *pState)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisPowerBusy pState=%p\n", pState));
+LOCAL void vboxUsbSolarisPowerBusy(vboxusb_state_t *pState)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisPowerBusy: pState=%p\n", pState));
     AssertPtrReturnVoid(pState);
 
@@ -4143 +4005 @@
         if (rc != DDI_SUCCESS)
         {
-            Log((DEVICE_NAME ":vboxUSBSolarisPowerBusy busy component failed! rc=%d\n", rc));
+            Log((DEVICE_NAME ": vboxUsbSolarisPowerBusy: Busy component failed! rc=%d\n", rc));
             mutex_enter(&pState->Mtx);
             pState->pPower->PowerBusy--;
@@ -4155 +4017 @@
 
 /**
- * Flag the PM component as idle so its power managed by the system.
+ * Flags the PM component as idle so its power managed by the system.
  *
  * @param   pState          The USB device instance.
  */
-LOCAL void vboxUSBSolarisPowerIdle(vboxusb_state_t *pState)
-{
-    LogFunc((DEVICE_NAME ":vboxUSBSolarisPowerIdle pState=%p\n", pState));
+LOCAL void vboxUsbSolarisPowerIdle(vboxusb_state_t *pState)
+{
+    LogFunc((DEVICE_NAME ": vboxUsbSolarisPowerIdle: pState=%p\n", pState));
     AssertPtrReturnVoid(pState);
 
@@ -4175 +4037 @@
         }
         else
-            Log((DEVICE_NAME ":vboxUSBSolarisPowerIdle idle component failed! rc=%d\n", rc));
-    }
-}
-
+            Log((DEVICE_NAME ": vboxUsbSolarisPowerIdle: Idle component failed! rc=%d\n", rc));
+    }
+}
+

trunk/src/VBox/HostDrivers/VBoxUSB/solaris/VBoxUSBMon-solaris.c

@@ -172 +172 @@
 /** Global Mutex. */
 static kmutex_t g_VBoxUSBMonSolarisMtx;
-/** Number of userland clients that have kept us open. */
-static uint64_t g_cVBoxUSBMonSolarisClient = 0;
 /** Global list of client drivers registered with us. */
 vboxusbmon_client_t *g_pVBoxUSBMonSolarisClients = NULL;
@@ -204 +202 @@
     int rc;
 
-    LogFunc((DEVICE_NAME ":_init\n"));
+    LogFunc((DEVICE_NAME ": _init\n"));
 
     g_pDip = NULL;
@@ -215 +213 @@
         pModCtl->mod_loadflags |= MOD_NOAUTOUNLOAD;
     else
-        LogRel((DEVICE_NAME ":failed to disable autounloading!\n"));
+        LogRel((DEVICE_NAME ": _init: Failed to disable autounloading!\n"));
 
     /*
@@ -237 +235 @@
                     return rc;
 
-                LogRel((DEVICE_NAME ":mod_install failed! rc=%d\n", rc));
+                LogRel((DEVICE_NAME ": _init: mod_install failed! rc=%d\n", rc));
                 ddi_soft_state_fini(&g_pVBoxUSBMonSolarisState);
             }
             else
-                LogRel((DEVICE_NAME ":ddi_soft_state_init failed! rc=%d\n", rc));
+                LogRel((DEVICE_NAME ": _init: ddi_soft_state_init failed! rc=%d\n", rc));
         }
         else
-            LogRel((DEVICE_NAME ":VBoxUSBFilterInit failed! rc=%d\n", rc));
+            LogRel((DEVICE_NAME ": _init: VBoxUSBFilterInit failed! rc=%d\n", rc));
 
         mutex_destroy(&g_VBoxUSBMonSolarisMtx);
@@ -250 +248 @@
     }
     else
-        LogRel((DEVICE_NAME ":RTR0Init failed! rc=%d\n", rc));
+        LogRel((DEVICE_NAME ": _init: RTR0Init failed! rc=%d\n", rc));
 
     return -1;
@@ -260 +258 @@
     int rc;
 
-    LogFunc((DEVICE_NAME ":_fini\n"));
+    LogFunc((DEVICE_NAME ": _fini\n"));
 
     rc = mod_remove(&g_VBoxUSBMonSolarisModLinkage);
@@ -277 +275 @@
 int _info(struct modinfo *pModInfo)
 {
-    LogFunc((DEVICE_NAME ":_info\n"));
+    LogFunc((DEVICE_NAME ": _info\n"));
 
     return mod_info(&g_VBoxUSBMonSolarisModLinkage, pModInfo);
@@ -293 +291 @@
 static int VBoxUSBMonSolarisAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd)
 {
-    LogFunc((DEVICE_NAME ":VBoxUSBMonSolarisAttach pDip=%p enmCmd=%d\n", pDip, enmCmd));
+    LogFunc((DEVICE_NAME ": VBoxUSBMonSolarisAttach: pDip=%p enmCmd=%d\n", pDip, enmCmd));
     switch (enmCmd)
     {
@@ -300 +298 @@
             if (RT_UNLIKELY(g_pDip))
             {
-                LogRel((DEVICE_NAME ":VBoxUSBMonSolarisAttach global instance already initialized.\n"));
+                LogRel((DEVICE_NAME ": VBoxUSBMonSolarisAttach: Global instance already initialized\n"));
                 return DDI_FAILURE;
             }
@@ -310 +308 @@
             if (rc == DDI_SUCCESS)
             {
-                ddi_report_dev(pDip);
-                return rc;
+                rc = usb_register_dev_driver(g_pDip, VBoxUSBMonSolarisElectDriver);
+                if (rc == DDI_SUCCESS)
+                {
+                    ddi_report_dev(pDip);
+                    return DDI_SUCCESS;
+                }
+
+                LogRel((DEVICE_NAME ": VBoxUSBMonSolarisAttach: Failed to register driver election callback! rc=%d\n", rc));
             }
             else
-                LogRel((DEVICE_NAME ":VBoxUSBMonSolarisAttach ddi_create_minor_node failed! rc=%d\n", rc));
+                LogRel((DEVICE_NAME ": VBoxUSBMonSolarisAttach: ddi_create_minor_node failed! rc=%d\n", rc));
             return DDI_FAILURE;
         }
@@ -340 +344 @@
 static int VBoxUSBMonSolarisDetach(dev_info_t *pDip, ddi_detach_cmd_t enmCmd)
 {
-    LogFunc((DEVICE_NAME ":VBoxUSBMonSolarisDetach\n"));
+    LogFunc((DEVICE_NAME ": VBoxUSBMonSolarisDetach\n"));
 
     switch (enmCmd)
@@ -359 +363 @@
             mutex_exit(&g_VBoxUSBMonSolarisMtx);
 
+            usb_unregister_dev_driver(g_pDip);
+
             ddi_remove_minor_node(pDip, NULL);
             g_pDip = NULL;
@@ -390 +396 @@
     int rc = DDI_SUCCESS;
 
-    LogFunc((DEVICE_NAME ":VBoxUSBMonSolarisGetInfo\n"));
+    LogFunc((DEVICE_NAME ": VBoxUSBMonSolarisGetInfo\n"));
 
     switch (enmCmd)
@@ -415 +421 @@
     unsigned iOpenInstance;
 
-    LogFunc((DEVICE_NAME ":VBoxUSBMonSolarisOpen\n"));
+    LogFunc((DEVICE_NAME ": VBoxUSBMonSolarisOpen\n"));
 
     /*
@@ -428 +434 @@
     if (!g_pDip)
     {
-        LogRel((DEVICE_NAME ":VBoxUSBMonSolarisOpen invalid state for opening.\n"));
+        LogRel((DEVICE_NAME ": VBoxUSBMonSolarisOpen: Invalid state for opening\n"));
         return ENXIO;
     }
-
-    mutex_enter(&g_VBoxUSBMonSolarisMtx);
-    if (!g_cVBoxUSBMonSolarisClient)
-    {
-        mutex_exit(&g_VBoxUSBMonSolarisMtx);
-        int rc = usb_register_dev_driver(g_pDip, VBoxUSBMonSolarisElectDriver);
-        if (RT_UNLIKELY(rc != DDI_SUCCESS))
-        {
-            LogRel((DEVICE_NAME ":Failed to register driver election callback with USBA rc=%d\n", rc));
-            return EINVAL;
-        }
-        Log((DEVICE_NAME ":Successfully registered election callback with USBA\n"));
-        mutex_enter(&g_VBoxUSBMonSolarisMtx);
-    }
-    g_cVBoxUSBMonSolarisClient++;
-    mutex_exit(&g_VBoxUSBMonSolarisMtx);
 
     for (iOpenInstance = 0; iOpenInstance < 4096; iOpenInstance++)
@@ -459 +449 @@
     if (!pState)
     {
-        LogRel((DEVICE_NAME ":VBoxUSBMonSolarisOpen: too many open instances."));
-        mutex_enter(&g_VBoxUSBMonSolarisMtx);
-        g_cVBoxUSBMonSolarisClient--;
-        mutex_exit(&g_VBoxUSBMonSolarisMtx);
+        LogRel((DEVICE_NAME ": VBoxUSBMonSolarisOpen: Too many open instances"));
         return ENXIO;
     }
@@ -479 +466 @@
 {
     vboxusbmon_state_t *pState = NULL;
-
-    LogFunc((DEVICE_NAME ":VBoxUSBMonSolarisClose\n"));
+    LogFunc((DEVICE_NAME ": VBoxUSBMonSolarisClose\n"));
 
     pState = ddi_get_soft_state(g_pVBoxUSBMonSolarisState, getminor(Dev));
     if (!pState)
     {
-        LogRel((DEVICE_NAME ":VBoxUSBMonSolarisClose: failed to get pState.\n"));
+        LogRel((DEVICE_NAME ": VBoxUSBMonSolarisClose: Failed to get state\n"));
         return EFAULT;
     }
-
-    mutex_enter(&g_VBoxUSBMonSolarisMtx);
-    g_cVBoxUSBMonSolarisClient--;
-    if (!g_cVBoxUSBMonSolarisClient)
-    {
-        if (RT_LIKELY(g_pDip))
-        {
-            mutex_exit(&g_VBoxUSBMonSolarisMtx);
-            usb_unregister_dev_driver(g_pDip);
-            Log((DEVICE_NAME ":Successfully deregistered driver election callback\n"));
-        }
-        else
-        {
-            mutex_exit(&g_VBoxUSBMonSolarisMtx);
-            LogRel((DEVICE_NAME ":Extreme error! Missing device info during close.\n"));
-        }
-    }
-    else
-        mutex_exit(&g_VBoxUSBMonSolarisMtx);
 
     /*
@@ -526 +493 @@
 static int VBoxUSBMonSolarisRead(dev_t Dev, struct uio *pUio, cred_t *pCred)
 {
-    LogFunc((DEVICE_NAME ":VBoxUSBMonSolarisRead\n"));
+    LogFunc((DEVICE_NAME ": VBoxUSBMonSolarisRead\n"));
     return 0;
 }
@@ -533 +500 @@
 static int VBoxUSBMonSolarisWrite(dev_t Dev, struct uio *pUio, cred_t *pCred)
 {
-    LogFunc((DEVICE_NAME ":VBoxUSBMonSolarisWrite\n"));
+    LogFunc((DEVICE_NAME ": VBoxUSBMonSolarisWrite\n"));
     return 0;
 }
@@ -548 +515 @@
 static int VBoxUSBMonSolarisIOCtl(dev_t Dev, int Cmd, intptr_t pArg, int Mode, cred_t *pCred, int *pVal)
 {
-    LogFunc((DEVICE_NAME ":VBoxUSBMonSolarisIOCtl Dev=%d Cmd=%d pArg=%p Mode=%d\n", Dev, Cmd, pArg));
+    LogFunc((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: Dev=%d Cmd=%d pArg=%p Mode=%d\n", Dev, Cmd, pArg));
 
     /*
@@ -556 +523 @@
     if (!pState)
     {
-        LogRel((DEVICE_NAME ":VBoxUSBMonSolarisIOCtl: no state data for %d\n", getminor(Dev)));
+        LogRel((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: No state data for minor instance %d\n", getminor(Dev)));
         return EINVAL;
     }
@@ -567 +534 @@
     if (IOCPARM_LEN(Cmd) != sizeof(ReqWrap))
     {
-        LogRel((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: bad request %#x size=%d expected=%d\n", Cmd, IOCPARM_LEN(Cmd), sizeof(ReqWrap)));
+        LogRel((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: bad request %#x size=%d expected=%d\n", Cmd, IOCPARM_LEN(Cmd),
+                sizeof(ReqWrap)));
         return ENOTTY;
     }
@@ -574 +542 @@
     if (RT_UNLIKELY(rc))
     {
-        LogRel((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: ddi_copyin failed to read header pArg=%p Cmd=%d. rc=%d.\n", pArg, Cmd, rc));
+        LogRel((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: ddi_copyin failed to read header pArg=%p Cmd=%d. rc=%d\n", pArg, Cmd, rc));
         return EINVAL;
     }
@@ -580 +548 @@
     if (ReqWrap.u32Magic != VBOXUSBMON_MAGIC)
     {
-        LogRel((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: bad magic %#x; pArg=%p Cmd=%d.\n", ReqWrap.u32Magic, pArg, Cmd));
+        LogRel((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: Bad magic %#x; pArg=%p Cmd=%d\n", ReqWrap.u32Magic, pArg, Cmd));
         return EINVAL;
     }
@@ -586 +554 @@
                     || ReqWrap.cbData > _1M*16))
     {
-        LogRel((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: bad size %#x; pArg=%p Cmd=%d.\n", ReqWrap.cbData, pArg, Cmd));
+        LogRel((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: Bad size %#x; pArg=%p Cmd=%d\n", ReqWrap.cbData, pArg, Cmd));
         return EINVAL;
     }
@@ -596 +564 @@
     if (RT_UNLIKELY(!pvBuf))
     {
-        LogRel((DEVICE_NAME ":VBoxUSBMonSolarisIOCtl: RTMemTmpAlloc failed to alloc %d bytes.\n", ReqWrap.cbData));
+        LogRel((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: RTMemTmpAlloc failed to alloc %d bytes\n", ReqWrap.cbData));
         return ENOMEM;
     }
@@ -604 +572 @@
     {
         RTMemTmpFree(pvBuf);
-        LogRel((DEVICE_NAME ":VBoxUSBMonSolarisIOCtl: ddi_copyin failed; pvBuf=%p pArg=%p Cmd=%d. rc=%d\n", pvBuf, pArg, Cmd, rc));
+        LogRel((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: ddi_copyin failed; pvBuf=%p pArg=%p Cmd=%d. rc=%d\n", pvBuf, pArg, Cmd,
+                rc));
         return EFAULT;
     }
@@ -611 +580 @@
     {
         RTMemTmpFree(pvBuf);
-        LogRel((DEVICE_NAME ":VBoxUSBMonSolarisIOCtl: pvBuf invalid pointer %p\n", pvBuf));
+        LogRel((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: pvBuf Invalid pointer %p\n", pvBuf));
         return EINVAL;
     }
-    Log((DEVICE_NAME ":VBoxUSBMonSolarisIOCtl: pid=%d.\n", (int)RTProcSelf()));
+    Log((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: pid=%d\n", (int)RTProcSelf()));
 
     /*
@@ -626 +595 @@
     if (RT_UNLIKELY(cbDataReturned > ReqWrap.cbData))
     {
-        LogRel((DEVICE_NAME ":VBoxUSBMonSolarisIOCtl: too much output data %d expected %d\n", cbDataReturned, ReqWrap.cbData));
+        LogRel((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: Too much output data %d expected %d\n", cbDataReturned, ReqWrap.cbData));
         cbDataReturned = ReqWrap.cbData;
     }
@@ -646 +615 @@
             if (RT_UNLIKELY(rc))
             {
-                LogRel((DEVICE_NAME ":VBoxUSBMonSolarisIOCtl: ddi_copyout failed; pvBuf=%p pArg=%p Cmd=%d. rc=%d\n", pvBuf, pArg, Cmd, rc));
+                LogRel((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: ddi_copyout failed; pvBuf=%p pArg=%p Cmd=%d. rc=%d\n", pvBuf,
+                        pArg, Cmd, rc));
                 rc = EFAULT;
             }
@@ -653 +623 @@
     else
     {
-        LogRel((DEVICE_NAME ":VBoxUSBMonSolarisIOCtl: ddi_copyout(1) failed pArg=%p Cmd=%d\n", pArg, Cmd));
+        LogRel((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: ddi_copyout(1) failed pArg=%p Cmd=%d\n", pArg, Cmd));
         rc = EFAULT;
     }
@@ -679 +649 @@
 static int vboxUSBMonSolarisProcessIOCtl(int iFunction, void *pvState, void *pvData, size_t cbData, size_t *pcbReturnedData)
 {
-    LogFunc((DEVICE_NAME ":solarisUSBProcessIOCtl iFunction=%d pvBuf=%p cbBuf=%zu\n", iFunction, pvData, cbData));
+    LogFunc((DEVICE_NAME ": vboxUSBMonSolarisProcessIOCtl: iFunction=%d pvBuf=%p cbBuf=%zu\n", iFunction, pvData, cbData));
 
     AssertPtrReturn(pvState, VERR_INVALID_POINTER);
@@ -709 +679 @@
             PUSBFILTER pFilter = (PUSBFILTER)&pReq->Filter;
 
-            Log(("vboxUSBMonSolarisProcessIOCtl: idVendor=%#x idProduct=%#x bcdDevice=%#x bDeviceClass=%#x bDeviceSubClass=%#x bDeviceProtocol=%#x bBus=%#x bPort=%#x\n",
+            Log(("vboxUSBMonSolarisProcessIOCtl: idVendor=%#x idProduct=%#x bcdDevice=%#x bDeviceClass=%#x "
+                 "bDeviceSubClass=%#x bDeviceProtocol=%#x bBus=%#x bPort=%#x\n",
                       USBFilterGetNum(pFilter, USBFILTERIDX_VENDOR_ID),
                       USBFilterGetNum(pFilter, USBFILTERIDX_PRODUCT_ID),
@@ -727 +698 @@
             rc = VBoxUSBFilterAdd(pFilter, pState->Process, &pReq->uId);
             *pcbReturnedData = cbData;
-            Log((DEVICE_NAME ":vboxUSBMonSolarisProcessIOCtl: ADD_FILTER (Process:%d) returned %d\n", pState->Process, rc));
+            Log((DEVICE_NAME ": vboxUSBMonSolarisProcessIOCtl: ADD_FILTER (Process:%d) returned %d\n", pState->Process, rc));
             break;
         }
@@ -738 +709 @@
             rc = VBoxUSBFilterRemove(pState->Process, (uintptr_t)pReq->uId);
             *pcbReturnedData = 0;
-            Log((DEVICE_NAME ":vboxUSBMonSolarisProcessIOCtl: REMOVE_FILTER (Process:%d) returned %d\n", pState->Process, rc));
+            Log((DEVICE_NAME ": vboxUSBMonSolarisProcessIOCtl: REMOVE_FILTER (Process:%d) returned %d\n", pState->Process, rc));
             break;
         }
@@ -749 +720 @@
             rc = vboxUSBMonSolarisResetDevice(pReq->szDevicePath, pReq->fReattach);
             *pcbReturnedData = 0;
-            Log((DEVICE_NAME ":vboxUSBMonSolarisProcessIOCtl: RESET_DEVICE (Process:%d) returned %d\n", pState->Process, rc));
+            Log((DEVICE_NAME ": vboxUSBMonSolarisProcessIOCtl: RESET_DEVICE (Process:%d) returned %d\n", pState->Process, rc));
             break;
         }
@@ -760 +731 @@
             rc = vboxUSBMonSolarisClientInfo(pState, pReq);
             *pcbReturnedData = cbData;
-            Log((DEVICE_NAME ":vboxUSBMonSolarisProcessIOCtl: CLIENT_INFO (Process:%d) returned %d\n", pState->Process, rc));
+            Log((DEVICE_NAME ": vboxUSBMonSolarisProcessIOCtl: CLIENT_INFO (Process:%d) returned %d\n", pState->Process, rc));
             break;
         }
@@ -773 +744 @@
             *pcbReturnedData = sizeof(VBOXUSBREQ_GET_VERSION);
             rc = VINF_SUCCESS;
-            Log((DEVICE_NAME ":vboxUSBMonSolarisProcessIOCtl: GET_VERSION returned %d\n", rc));
+            Log((DEVICE_NAME ": vboxUSBMonSolarisProcessIOCtl: GET_VERSION returned %d\n", rc));
             break;
         }
@@ -779 +750 @@
         default:
         {
-            LogRel((DEVICE_NAME ":vboxUSBMonSolarisProcessIOCtl: Unknown request (Process:%d) %#x\n", pState->Process, iFunction));
+            LogRel((DEVICE_NAME ": vboxUSBMonSolarisProcessIOCtl: Unknown request (Process:%d) %#x\n", pState->Process,
+                    iFunction));
             *pcbReturnedData = 0;
             rc = VERR_NOT_SUPPORTED;
@@ -793 +765 @@
     int rc = VERR_GENERAL_FAILURE;
 
-    LogFunc((DEVICE_NAME ":vboxUSBMonSolarisResetDevice pszDevicePath=%s fReattach=%d\n", pszDevicePath, fReattach));
+    LogFunc((DEVICE_NAME ": vboxUSBMonSolarisResetDevice: pszDevicePath=%s fReattach=%d\n", pszDevicePath, fReattach));
 
     /*
@@ -812 +784 @@
             if (!pTmpDeviceInfo)
             {
-                LogRel((DEVICE_NAME ":vboxUSBMonSolarisResetDevice failed to get parent device info for %s\n", pszDevicePath));
+                LogRel((DEVICE_NAME ":vboxUSBMonSolarisResetDevice: Failed to get parent device info for %s\n", pszDevicePath));
                 return VERR_GENERAL_FAILURE;
             }
@@ -826 +798 @@
          */
         rc = usb_reset_device(pDeviceInfo, fReattach ? USB_RESET_LVL_REATTACH : USB_RESET_LVL_DEFAULT);
-        Log((DEVICE_NAME ":usb_reset_device for %s level=%s returned %d\n", pszDevicePath, fReattach ? "ReAttach" : "Default", rc));
+        Log((DEVICE_NAME ": vboxUSBMonSolarisResetDevice: usb_reset_device for %s level=%s rc=%d\n", pszDevicePath,
+             fReattach ? "ReAttach" : "Default", rc));
+
         switch (rc)
         {
@@ -842 +816 @@
     {
         rc = VERR_INVALID_HANDLE;
-        LogRel((DEVICE_NAME ":vboxUSBMonSolarisResetDevice Cannot obtain device info for %s\n", pszDevicePath));
+        LogRel((DEVICE_NAME ": vboxUSBMonSolarisResetDevice: Cannot obtain device info for %s\n", pszDevicePath));
     }
 
@@ -859 +833 @@
 static int vboxUSBMonSolarisClientInfo(vboxusbmon_state_t *pState, PVBOXUSB_CLIENT_INFO pClientInfo)
 {
-    LogFunc((DEVICE_NAME ":vboxUSBMonSolarisClientInfo pState=%p pClientInfo=%p\n", pState, pClientInfo));
+    LogFunc((DEVICE_NAME ": vboxUSBMonSolarisClientInfo: pState=%p pClientInfo=%p\n", pState, pClientInfo));
 
     AssertPtrReturn(pState, VERR_INVALID_POINTER);
@@ -882 +856 @@
                 rc = pCur->Info.pfnSetConsumerCredentials(pState->Process, pCur->Info.Instance, NULL /* pvReserved */);
                 if (RT_FAILURE(rc))
-                    LogRel((DEVICE_NAME ":vboxUSBMonSolarisClientInfo pfnSetConsumerCredentials failed. rc=%d\n", rc));
+                    LogRel((DEVICE_NAME ": vboxUSBMonSolarisClientInfo: pfnSetConsumerCredentials failed! rc=%d\n", rc));
             }
             else
@@ -889 +863 @@
             mutex_exit(&g_VBoxUSBMonSolarisMtx);
 
-            Log((DEVICE_NAME ":vboxUSBMonSolarisClientInfo found. %s rc=%d\n", pClientInfo->szDeviceIdent, rc));
+            Log((DEVICE_NAME ": vboxUSBMonSolarisClientInfo: Found %s, rc=%d\n", pClientInfo->szDeviceIdent, rc));
             return rc;
         }
@@ -898 +872 @@
     mutex_exit(&g_VBoxUSBMonSolarisMtx);
 
-    LogRel((DEVICE_NAME ":vboxUSBMonSolarisClientInfo Failed to find client %s\n", pClientInfo->szDeviceIdent));
+    LogRel((DEVICE_NAME ": vboxUSBMonSolarisClientInfo: Failed to find client %s\n", pClientInfo->szDeviceIdent));
     return VERR_NOT_FOUND;
 }
@@ -910 +884 @@
 int VBoxUSBMonSolarisRegisterClient(dev_info_t *pClientDip, PVBOXUSB_CLIENT_INFO pClientInfo)
 {
-    LogFunc((DEVICE_NAME ":VBoxUSBMonSolarisRegisterClient pClientDip=%p pClientInfo=%p\n", pClientDip, pClientInfo));
+    LogFunc((DEVICE_NAME ": VBoxUSBMonSolarisRegisterClient: pClientDip=%p pClientInfo=%p\n", pClientDip, pClientInfo));
     AssertPtrReturn(pClientInfo, VERR_INVALID_PARAMETER);
 
@@ -929 +903 @@
             mutex_exit(&g_VBoxUSBMonSolarisMtx);
 
-            Log((DEVICE_NAME ":VBoxUSBMonSolarisRegisterClient registered. %d %s %s\n",
-                        pClient->Info.Instance, pClient->Info.szClientPath, pClient->Info.szDeviceIdent));
-
+            Log((DEVICE_NAME ": Client registered (ClientPath=%s Ident=%s)\n", pClient->Info.szClientPath,
+                 pClient->Info.szDeviceIdent));
             return VINF_SUCCESS;
         }
@@ -947 +920 @@
 int VBoxUSBMonSolarisUnregisterClient(dev_info_t *pClientDip)
 {
-    LogFunc((DEVICE_NAME ":VBoxUSBMonSolarisUnregisterClient pClientDip=%p\n", pClientDip));
+    LogFunc((DEVICE_NAME ": VBoxUSBMonSolarisUnregisterClient: pClientDip=%p\n", pClientDip));
     AssertReturn(pClientDip, VERR_INVALID_PARAMETER);
 
@@ -967 +940 @@
                 mutex_exit(&g_VBoxUSBMonSolarisMtx);
 
-                Log((DEVICE_NAME ":VBoxUSBMonSolarisUnregisterClient unregistered. %d %s %s\n",
-                            pCur->Info.Instance, pCur->Info.szClientPath, pCur->Info.szDeviceIdent));
+                Log((DEVICE_NAME ": Client unregistered (ClientPath=%s Ident=%s)\n", pCur->Info.szClientPath,
+                     pCur->Info.szDeviceIdent));
                 RTMemFree(pCur);
-                pCur = NULL;
                 return VINF_SUCCESS;
             }
@@ -979 +951 @@
         mutex_exit(&g_VBoxUSBMonSolarisMtx);
 
-        LogRel((DEVICE_NAME ":VBoxUSBMonSolarisUnregisterClient Failed to find registered client %p\n", pClientDip));
+        LogRel((DEVICE_NAME ": VBoxUSBMonSolarisUnregisterClient: Failed to find registered client %p\n", pClientDip));
         return VERR_NOT_FOUND;
     }
@@ -1001 +973 @@
                                 char **ppszDrv, void *pvReserved)
 {
-    LogFunc((DEVICE_NAME ":VBoxUSBMonSolarisElectDriver pDevDesc=%p pDevStrings=%p pszDevicePath=%s Bus=%d Port=%d\n", pDevDesc,
+    LogFunc((DEVICE_NAME ": VBoxUSBMonSolarisElectDriver: pDevDesc=%p pDevStrings=%p pszDevicePath=%s Bus=%d Port=%d\n", pDevDesc,
             pDevStrings, pszDevicePath, Bus, Port));
 
@@ -1027 +999 @@
     USBFilterSetMustBePresent(&Filter, USBFILTERIDX_BUS, false /* fMustBePresent */);
 
-    Log((DEVICE_NAME ":VBoxUSBMonSolarisElectDriver: idVendor=%#x idProduct=%#x bcdDevice=%#x bDeviceClass=%#x bDeviceSubClass=%#x bDeviceProtocol=%#x bBus=%#x bPort=%#x\n",
+    Log((DEVICE_NAME ": VBoxUSBMonSolarisElectDriver: idVendor=%#x idProduct=%#x bcdDevice=%#x bDeviceClass=%#x "
+         "bDeviceSubClass=%#x bDeviceProtocol=%#x bBus=%#x bPort=%#x\n",
               USBFilterGetNum(&Filter, USBFILTERIDX_VENDOR_ID),
               USBFilterGetNum(&Filter, USBFILTERIDX_PRODUCT_ID),
@@ -1036 +1009 @@
               USBFilterGetNum(&Filter, USBFILTERIDX_BUS),
               USBFilterGetNum(&Filter, USBFILTERIDX_PORT)));
-    Log((DEVICE_NAME ":VBoxUSBMonSolarisElectDriver: Manufacturer=%s Product=%s Serial=%s\n",
+    Log((DEVICE_NAME ": VBoxUSBMonSolarisElectDriver: Manufacturer=%s Product=%s Serial=%s\n",
               USBFilterGetString(&Filter, USBFILTERIDX_MANUFACTURER_STR)  ? USBFilterGetString(&Filter, USBFILTERIDX_MANUFACTURER_STR)  : "<null>",
               USBFilterGetString(&Filter, USBFILTERIDX_PRODUCT_STR)       ? USBFilterGetString(&Filter, USBFILTERIDX_PRODUCT_STR)       : "<null>",
@@ -1049 +1022 @@
     if (Owner == NIL_RTPROCESS)
     {
-        Log((DEVICE_NAME ":No matching filters, device %#x:%#x uninteresting.\n", pDevDesc->idVendor, pDevDesc->idProduct));
+        Log((DEVICE_NAME ": VBoxUSBMonSolarisElectDriver: No matching filters, device %#x:%#x uninteresting\n",
+             pDevDesc->idVendor, pDevDesc->idProduct));
         return USB_FAILURE;
     }
 
     *ppszDrv = ddi_strdup(VBOXUSB_DRIVER_NAME, KM_SLEEP);
-    LogRel((DEVICE_NAME ": Capturing %s %#x:%#x:%s\n", pDevStrings->usb_product ? pDevStrings->usb_product : "<Unnamed USB device>",
-                    pDevDesc->idVendor, pDevDesc->idProduct, pszDevicePath));
+    LogRel((DEVICE_NAME ": Capturing %s %s %#x:%#x:%s Bus=%d Port=%d\n",
+            pDevStrings->usb_mfg ? pDevStrings->usb_mfg : "<Unknown Manufacturer>",
+            pDevStrings->usb_product ? pDevStrings->usb_product : "<Unnamed USB device>",
+            pDevDesc->idVendor, pDevDesc->idProduct, pszDevicePath, Bus, Port));
     return USB_SUCCESS;
 }

trunk/src/VBox/HostDrivers/VBoxUSB/solaris/include/usbai_private.h

@@ -24 +24 @@
  */
 
-#ifndef _SYS_USB_USBA_USBAI_PRIVATE_H
-#define _SYS_USB_USBA_USBAI_PRIVATE_H
-
+#ifndef    _SYS_USB_USBA_USBAI_PRIVATE_H
+#define    _SYS_USB_USBA_USBAI_PRIVATE_H
 
 /*
@@ -34 +33 @@
  *
  * Status key:
- *      C = Remove from Sun client drivers before removing from this file
- *      D = May be needed by legacy (DDK) drivers.
+ *    C = Remove from Sun client drivers before removing from this file
+ *    D = May be needed by legacy (DDK) drivers.
  */
 
-#ifdef  __cplusplus
+#ifdef    __cplusplus
 extern "C" {
 #endif
@@ -51 +50 @@
 
 /*
- * **************************************************************************
- * Error and status definitions, and reporting functions
- * **************************************************************************
- */
-
-
-/*
- * convenience functions to get string corresponding to value
- * usb_cb_flags_name requires a workbuffer of sufficient length
- * for the concatenation of all strings as usb_cb_flags_t is a bit
- * mask
- *
- * Status: C and D
- */
-const char      *usb_str_cr(usb_cr_t cr);
-char            *usb_str_cb_flags(usb_cb_flags_t cb_flags,
-                char *buffer, size_t length);
-const char      *usb_str_pipe_state(usb_pipe_state_t state);
-const char      *usb_str_dev_state(int state);
-const char      *usb_str_rval(int rval);
-
-/* function convert a USB return value to an errno */
-int             usb_rval2errno(int rval);
-
-/*
- * **************************************************************************
- * Transfer-related definitions and functions
- * **************************************************************************
- */
-
-/* Status C and D for whole section. */
-
-/* Serialize callbacks per interface or device. */
-#define USB_FLAGS_SERIALIZED_CB 0x8000
-
-/* default timeout for control requests (in seconds) */
-#define USB_PIPE_TIMEOUT        3
-
-/*
- * usb_pipe_sync_ctrl_xfer():
- *      for simple synchronous control transactions this wrapper function
- *      will perform the allocation, xfer, and deallocation.
- *      USB_ATTRS_AUTOCLEARING will be enabled
- *
- * ARGUMENTS:
- *      dip             - pointer to clients devinfo.
- *      pipe_handle     - control pipe pipehandle (obtained via usb_pipe_open().
- *      bmRequestType   - characteristics of request.
- *      bRequest        - specific request.
- *      wValue          - varies according to request.
- *      wIndex          - index or offset.
- *      wLength         - number of bytes to xfer.
- *      data            - pointer to pointer to data
- *                        IN: HCD will allocate data
- *                        OUT: clients driver allocates data.
- *      attrs           - required request attributes.
- *      completion_reason - completion status.
- *      cb_flags        - request completions flags.
- *      flags           - none.
- *
- * RETURN VALUES:
- *      USB_SUCCESS     - request successfully executed.
- *      USB_FAILURE     - request failed.
- *
- * NOTES:
- * - in the case of failure, the client should check completion_reason and
- *   and cb_flags and determine further recovery action
- * - the client should check data and if non-zero, free the data on
- *   completion
- */
-int usb_pipe_sync_ctrl_xfer(
-        dev_info_t      *dip,
-        usb_pipe_handle_t pipe_handle,
-        uchar_t         bmRequestType,
-        uchar_t         bRequest,
-        uint16_t        wValue,
-        uint16_t        wIndex,
-        uint16_t        wLength,
-        mblk_t          **data,
-        usb_req_attrs_t attrs,
-        usb_cr_t        *completion_reason,
-        usb_cb_flags_t  *cb_flags,
-        usb_flags_t     flags);
-
-/*
- * **************************************************************************
- * Event registration / pre-suspend and post-resume handling
- * **************************************************************************
- */
-
-/* Status: C and D for whole section. */
-
-/*
- * Event registration info for both hotplug and pre-suspend/post-resume
- * callbacks.  Eventually pre-suspend and post-resume callbacks will not be
- * needed, so this is for this OS release only and will go away in a
- * subsequent release.
- */
-typedef struct usb_event {
-        /* device disconnected/unplugged */
-        int     (*disconnect_event_handler)(dev_info_t *dip);
-
-        /* device reconnected */
-        int     (*reconnect_event_handler)(dev_info_t *dip);
-
-        /* notification that system is about to checkpoint */
-        int     (*pre_suspend_event_handler)(dev_info_t *dip);
-
-        /* notification that system resumed after a checkpoint */
-        int     (*post_resume_event_handler)(dev_info_t *dip);
-} usb_event_t;
-
-/*
- * Event callbacks
- *      the callbacks should always return USB_SUCCESS.
- */
-int usb_register_event_cbs(
-        dev_info_t      *dip,
-        usb_event_t     *usb_evt_data,
-        usb_flags_t     flags);
-
-void usb_unregister_event_cbs(
-        dev_info_t      *dip,
-        usb_event_t     *usb_evt_data);
-
-/*
- * USB CPR support
- *      A client driver must call this function in pre-suspend event handler
- *      to inform the USBA framework that it can't suspend because
- *      driver instance or device could not be quiesced.
- */
-void usb_fail_checkpoint(
-        dev_info_t      *dip,
-        usb_flags_t     flags);
-
-
-/*
- * **************************************************************************
- * Logging functions remaining Contracted Consolidation Private
- * **************************************************************************
- */
-
-/* Status: C and D for whole section. */
-
-/*
  * Usb logging, debug and console message handling.
  */
 typedef struct usb_log_handle *usb_log_handle_t;
 
-#define USB_LOG_L0      0       /* warnings, console & syslog buffer */
-#define USB_LOG_L1      1       /* errors, syslog buffer */
-#define USB_LOG_L2      2       /* recoverable errors, debug only */
-#define USB_LOG_L3      3       /* interesting data, debug only */
-#define USB_LOG_L4      4       /* tracing, debug only */
+#define    USB_LOG_L0    0    /* warnings, console & syslog buffer */
+#define    USB_LOG_L1    1    /* errors, syslog buffer */
+#define    USB_LOG_L2    2    /* recoverable errors, debug only */
+#define    USB_LOG_L3    3    /* interesting data, debug only */
+#define    USB_LOG_L4    4    /* tracing, debug only */
 
-#ifdef DEBUG
-#define USB_DPRINTF_L4  usb_dprintf4
-#define USB_DPRINTF_L3  usb_dprintf3
+#define    USB_CHK_BASIC  0             /* Empty mask.    Basics always done. */
+#define    USB_CHK_SERIAL 0x00000001    /* Compare device serial numbers. */
+#define    USB_CHK_CFG    0x00000002    /* Compare raw config clouds. */
+#define    USB_CHK_VIDPID 0x00000004    /* Compare product and vendor ID. */
+#define    USB_CHK_ALL    0xFFFFFFFF    /* Perform maximum checking. */
 
-/*PRINTFLIKE3*/
-void usb_dprintf4(
-        uint_t          mask,
-        usb_log_handle_t handle,
-        char            *fmt, ...);
-/*PRINTFLIKE3*/
-void usb_dprintf3(
-        uint_t          mask,
-        usb_log_handle_t handle,
-        char            *fmt, ...);
-#else
-#define USB_DPRINTF_L4 0 &&
-#define USB_DPRINTF_L3 0 &&
-#endif
-
-#define USB_DPRINTF_L2  usb_dprintf2
-#define USB_DPRINTF_L1  usb_dprintf1
-#define USB_DPRINTF_L0  usb_dprintf0
-
-/*PRINTFLIKE3*/
-void usb_dprintf2(
-        uint_t          mask,
-        usb_log_handle_t handle,
-        char            *fmt, ...);
-/*PRINTFLIKE3*/
-void usb_dprintf1(
-        uint_t          mask,
-        usb_log_handle_t handle,
-        char            *fmt, ...);
-/*PRINTFLIKE3*/
-void usb_dprintf0(
-        uint_t          mask,
-        usb_log_handle_t handle,
-        char            *fmt, ...);
-
-usb_log_handle_t usb_alloc_log_hdl(
-        dev_info_t      *dip,
-        char            *name,
-        uint_t          *errlevel,
-        uint_t          *mask,
-        uint_t          *instance_filter,
-        usb_flags_t     flags);
-
-/* free the log handle */
-void usb_free_log_hdl(
-        usb_log_handle_t handle);
-
-/* log message */
-/*PRINTFLIKE4*/
-int usb_log(
-        usb_log_handle_t handle,
-        uint_t          level,
-        uint_t          mask,
-        char            *fmt, ...);
-
-/*
- * usb_check_same_device:
- *      Check if the device connected to the port is the same as
- *      the previous device that was in the port.  The previous device is
- *      represented by the dip on record for the port.  Print a message
- *      if the device is different.  If device_string arg is not NULL, it is
- *      included in the message.  Can block.
- *
- * Arguments:
- *      dip                     - pointer to devinfo of the client
- *      log_handle              - handle to which messages are logged
- *      log_level               - one of USB_LOG_*
- *      log_mask                - logging mask
- *      check_mask              - one mask containing things to check:
- *                                      USB_CHK_BASIC: empty mask;
- *                                              these checks are always done.
- *                                      USB_CHK_SERIAL: check match on device
- *                                              serial number.
- *                                      USB_CHK_CFG: compare config clouds
- *                                              byte by byte
- *                                      USB_CHK_VIDPID: compare product
- *                                              and vendor ID
- *                                      USB_CHK_ALL: perform all checks
- *
- *                              NOTE: descr length and content always checked
- *      device_string           - Device string to appear in error message
- *
- * return values:
- *      USB_SUCCESS:            same device
- *      USB_INVALID_VERSION     not same device
- *      USB_FAILURE:            Failure processing request
- *      USB_INVALID_ARG:        dip is invalid
- */
-
-/* Checking bits for checks made by usb_check_same_device */
-#define USB_CHK_BASIC   0               /* Empty mask.  Basics always done. */
-#define USB_CHK_SERIAL  0x00000001      /* Compare device serial numbers. */
-#define USB_CHK_CFG     0x00000002      /* Compare raw config clouds. */
-#define USB_CHK_VIDPID  0x00000004      /* Compare product and vendor ID. */
-#define USB_CHK_ALL     0xFFFFFFFF      /* Perform maximum checking. */
-
-int usb_check_same_device(
-        dev_info_t              *dip,
-        usb_log_handle_t        log_handle,
-        int                     log_level,
-        int                     log_mask,
-        uint_t                  check_mask,
-        char                    *device_string);
-
-/*
- * **************************************************************************
- * Power management functions remaining Contracted Consolidation Private
- * **************************************************************************
- */
-
-/*
- * usb wrapper around pm_raise_power & pm_lower_power to allow for
- * non blocking behavior
- *
- * Arguments:
- *      dip             - pointer to devinfo node of client.
- *      comp            - component.
- *      level           - power level.
- *      flags           - USB_FLAGS_SLEEP:
- *                              wait for completion.
- *      cb              - function called on completion, may be NULL.
- *      arg             - callback argument.
- *      rval            - USB_SUCCESS or USB_FAILURE.
- *
- * Return Values:
- *      USB_SUCCESS     -  if no USB_FLAGS_SLEEP has been specified, the request
- *                         has been queued for async execution. If
- *                         USB_FLAGS_SLEEP has been specified, the raising or
- *                         lowering of power
- *                         succeeded.
- *      USB_FAILURE     -  request could not be queued or raising or lowering
- *                         of power failed.
- */
-
-/* Status: C and D */
-int usb_req_raise_power(
-        dev_info_t      *dip,
-        int             comp,
-        int             level,
-        void            (*cb)(void *arg, int rval),
-        void            *arg,
-        usb_flags_t     flags);
-
-/* Status: D */
-int usb_req_lower_power(
-        dev_info_t      *dip,
-        int             comp,
-        int             level,
-        void            (*cb)(void *arg, int rval),
-        void            *arg,
-        usb_flags_t     flags);
-
-/*
- * USB wrapper functions to set usb device power level.
- * Note : Power levels indicated here are USB power levels
- * and not OS power levels.
- *
- * Note that these were never implemented, and are noops.  However, they are
- * included here as the skeleton driver in DDK 0.8 and 0.9 mentioned them.
- *
- * Status: C and D.
- */
-int usb_set_device_pwrlvl0(
-        dev_info_t      *dip);
-int usb_set_device_pwrlvl1(
-        dev_info_t      *dip);
-int usb_set_device_pwrlvl2(
-        dev_info_t      *dip);
-int usb_set_device_pwrlvl3(
-        dev_info_t      *dip);
-
+int usb_check_same_device(dev_info_t        *dip,
+                          usb_log_handle_t   log_handle,
+                          int                log_level,
+                          int                log_mask,
+                          uint_t             check_mask,
+                          char              *device_string);
 
 /*
@@ -392 +83 @@
 /*
  * opaque serialization handle.
- *      Used by all usb_serialization routines.
+ *    Used by all usb_serialization routines.
  *
- *      This handle is opaque to the client driver.
+ *    This handle is opaque to the client driver.
  */
-typedef struct usb_serialization        *usb_serialization_t;
+typedef struct usb_serialization *usb_serialization_t;
 
 /*
  * usb_init_serialization
- *      setup for serialization
+ *    setup for serialization
  *
  * ARGUMENTS:
- *      s_dip           - devinfo pointer
- *      flag            - USB_INIT_SER_CHECK_SAME_THREAD
- *                        when set, usb_release_access() will
- *                        verify that the same thread releases
- *                        access. If not, a console warning will
- *                        be issued but access will be released
- *                        anyways.
+ *    s_dip        - devinfo pointer
+ *    flag         - USB_INIT_SER_CHECK_SAME_THREAD
+ *                   when set, usb_release_access() will verify that the same
+ *                   thread releases access. If not, a console warning will
+ *                   be issued but access will be released anyways.
  *
  * RETURNS:
- *      usb_serialization handle
+ *    usb_serialization handle
  *
  */
-usb_serialization_t usb_init_serialization(
-        dev_info_t      *s_dip,
-        uint_t          flag);
+usb_serialization_t usb_init_serialization(dev_info_t    *s_dip,
+                                           uint_t         flag);
 
-#define USB_INIT_SER_CHECK_SAME_THREAD  1
+#define    USB_INIT_SER_CHECK_SAME_THREAD    1
 
 /* fini for serialization */
-void usb_fini_serialization(
-        usb_serialization_t usb_serp);
+void usb_fini_serialization(usb_serialization_t usb_serp);
 
 /*
- * Various ways of calling usb_serialize_access.  These correspond to
+ * Various ways of calling usb_serialize_access. These correspond to
  * their cv_*wait* function counterparts for usb_serialize_access.
  */
-#define USB_WAIT                0
-#define USB_WAIT_SIG            1
-#define USB_TIMEDWAIT           2
-#define USB_TIMEDWAIT_SIG       3
+#define USB_WAIT            0
+#define USB_WAIT_SIG        1
+#define USB_TIMEDWAIT       2
+#define USB_TIMEDWAIT_SIG   3
 
 /*
  * usb_serialize_access:
- *      acquire serialized access
- * ARGUMENTS:
- *      usb_serp        - usb_serialization handle
- *      how_to_wait     - Which cv_*wait* function to wait for condition.
- *                              USB_WAIT:               use cv_wait
- *                              USB_WAIT_SIG:           use cv_wait_sig
- *                              USB_TIMEDWAIT:          use cv_timedwait
- *                              USB_TIMEDWAIT_SIG:      use cv_timedwait_sig
- *      delta_timeout   - Time in ms from current time to timeout.  Checked
- *                        only if USB_TIMEDWAIT or USB_TIMEDWAIT_SIG
- *                        specified in how_to_wait.
- * RETURNS:
- *      Same as values returned by cv_*wait* functions,
- *      except for when how_to_wait == USB_WAIT, where 0 is always returned.
- *      For calls where a timeout or signal could be expected, use this value
- *      to tell whether a kill(2) signal or timeout occurred.
- */
-int usb_serialize_access(
-        usb_serialization_t     usb_serp,
-        uint_t                  how_to_wait,
-        uint_t                  delta_timeout);
-
-/*
- * usb_try_serialize_access:
- *      try acquiring serialized access
+ *    acquire serialized access
  *
  * ARGUMENTS:
- *      usb_serp        - usb_serialization handle
- *      flag            - unused
- *
+ *    usb_serp      - usb_serialization handle
+ *    how_to_wait   - Which cv_*wait* function to wait for condition.
+ *       USB_WAIT:           use cv_wait
+ *       USB_WAIT_SIG:       use cv_wait_sig
+ *       USB_TIMEDWAIT:      use cv_timedwait
+ *       USB_TIMEDWAIT_SIG:  use cv_timedwait_sig
+ *    delta_timeout - Time in ms from current time to timeout.  Checked
+ *                    only if USB_TIMEDWAIT or USB_TIMEDWAIT_SIG
+ *                    specified in how_to_wait.
  * RETURNS:
- *      USB_SUCCESS     - access has been acquired
- *      USB_FAILURE     - access has not been acquired
+ *    Same as values returned by cv_*wait* functions,
+ *    except for when how_to_wait == USB_WAIT, where 0 is always returned.
+ *    For calls where a timeout or signal could be expected, use this value
+ *    to tell whether a kill(2) signal or timeout occurred.
  */
-int usb_try_serialize_access(usb_serialization_t usb_serp, uint_t flag);
+int usb_serialize_access(usb_serialization_t    usb_serp,
+                         uint_t                 how_to_wait,
+                         uint_t                 delta_timeout);
 
 /*
  * usb_release_access:
- *      release serialized access
+ *    release serialized access
  *
  * ARGUMENTS:
- *      usb_serp        - usb_serialization handle
+ *    usb_serp    - usb_serialization handle
  */
 void usb_release_access(usb_serialization_t usb_serp);
-
-
-/*
- * **************************************************************************
- * Asynchronous functions remaining Contracted Consolidation Private
- * **************************************************************************
- */
-
-/* This whole section: status: C and D. */
-
-/* For async_req functions. */
-#define USB_FLAGS_NOQUEUE       0x200
-
-/*
- * Issue a request to the asynchronous request service
- * All async request functions return USB_SUCCESS or USB_FAILURE
- * Arguments:
- *      dip             - pointer to devinfo node
- *      func            - pointer of function to execute asynchronously
- *      arg             - argument to function
- *      flag            - USB_FLAGS_SLEEP or USB_FLAGS_NOSLEEP or
- *                        USB_FLAGS_NOQUEUE
- * Return Values:
- *      USB_SUCCESS     - function was scheduled
- *      USB_FAILURE     - function could not be scheduled
- *
- * Flag combinations:
- *      SLEEP           - block waiting for resources. always succeeds
- *      NOSLEEP         - do not wait for resources, may fail.
- *      NOSLEEP+NOQUEUE - do not wait for resources, do not queue
- *      SLEEP+NOQUEUE   - block waiting for resources but may still fail
- *                        if no thread available
- */
-int usb_async_req(
-        dev_info_t      *dip,
-        void            (*func)(void *),
-        void            *arg,
-        usb_flags_t     flag);
-
-
-/*
- * index for getting to usb_pipehandle_list in usba_device
- */
-uchar_t usb_get_ep_index(uint8_t ep_addr);
-
-/*
- * **************************************************************************
- * USB device driver registration and callback functions remaining
- * Contracted Project Private (for VirtualBox USB Device Capture)
- * **************************************************************************
- */
-
-#if 0       /* Uncomment this section if usbai.h doesn't have this these bits (required for snv < 123) */
-
-/*
- * getting the device strings of manufacturer, product and serial number
- */
-typedef struct usb_dev_str {
-        char    *usb_mfg;       /* manufacturer string */
-        char    *usb_product;   /* product string */
-        char    *usb_serialno;  /* serial number string */
-} usb_dev_str_t;
-
-/*
- * It is the callback function type for capture driver.
- * Arguments:
- *      dev_descr       - pointer to device descriptor
- *      dev_str         - pointer to device strings
- *      path            - pointer to device physical path
- *      bus             - USB bus address
- *      port            - USB port number
- *      drv             - capture driver name.
- *                        It is returned by the callback func.
- * Return Values:
- *      USB_SUCCESS     - VirtualBox will capture the device
- *      USB_FAILURE     - VirtualBox will not capture the device
- */
-typedef int (*usb_dev_driver_callback_t)(
-        usb_dev_descr_t *dev_descr,
-        usb_dev_str_t   *dev_str,
-        char            *path,
-        int             bus,
-        int             port,
-        char            **drv,
-        void            *reserved);
-
-/*
- * Register the callback function in the usba.
- * Argument:
- *      dip             - client driver's devinfo pointer
- *      cb              - callback function
- *
- * Return Values:
- *      USB_SUCCESS     - the registration was successful
- *      USB_FAILURE     - the registration failed
- */
-int usb_register_dev_driver(
-        dev_info_t                      *dip,
-        usb_dev_driver_callback_t       cb);
-
-/*
- * Unregister the callback function in the usba.
- */
-void usb_unregister_dev_driver(dev_info_t *dip);
-#endif
-
-
-#ifdef ALLOCB_TEST
-#define allocb(s, p) usba_test_allocb(s, p)
-mblk_t *usba_test_allocb(size_t, uint_t);
-#endif /* ALLOCB_TEST */
-
-/* create an USB style M_CTL message */
-mblk_t *usba_mk_mctl(struct iocblk, void *, size_t);
 
 #ifdef __cplusplus
@@ -599 +158 @@
 #endif
 
-#endif  /* _SYS_USB_USBA_USBAI_PRIVATE_H */
+#endif    /* _SYS_USB_USBA_USBAI_PRIVATE_H */
+

trunk/src/VBox/Main/src-server/solaris/USBProxyServiceSolaris.cpp

@@ -262 +262 @@
                 pCur->bPort = 0;
 
-            char pathBuf[PATH_MAX];
-            RTStrPrintf(pathBuf, sizeof(pathBuf), "%s", pszDevicePath);
-            RTPathStripFilename(pathBuf);
-
             char szBuf[PATH_MAX + 48];
-            RTStrPrintf(szBuf, sizeof(szBuf), "%#x:%#x:%d:%s", pCur->idVendor, pCur->idProduct, pCur->bcdDevice, pathBuf);
+            RTStrPrintf(szBuf, sizeof(szBuf), "%#x:%#x:%d:%s", pCur->idVendor, pCur->idProduct, pCur->bcdDevice, pszDevicePath);
             pCur->pszAddress = RTStrDup(szBuf);