Adding upstream version 7.0.14-dfsg.upstream/7.0.14-dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 918 insertions, 0 deletions

diff --git a/src/VBox/Devices/USB/solaris/USBProxyDevice-solaris.cpp b/src/VBox/Devices/USB/solaris/USBProxyDevice-solaris.cpp
new file mode 100644
index 00000000..dc342240
--- /dev/null
+++ b/src/VBox/Devices/USB/solaris/USBProxyDevice-solaris.cpp
@@ -0,0 +1,918 @@
+/* $Id: USBProxyDevice-solaris.cpp $ */
+/** @file
+ * USB device proxy - the Solaris backend.
+ */
+
+/*
+ * Copyright (C) 2009-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#define LOG_GROUP LOG_GROUP_DRV_USBPROXY
+#include <sys/poll.h>
+#include <errno.h>
+#include <strings.h>
+#include <limits.h>
+
+#include <VBox/log.h>
+#include <VBox/err.h>
+#include <VBox/vmm/pdm.h>
+
+#include <iprt/string.h>
+#include <iprt/critsect.h>
+#include <iprt/time.h>
+#include <iprt/file.h>
+#include <iprt/mem.h>
+#include <iprt/pipe.h>
+#include "../USBProxyDevice.h"
+#include <VBox/usblib.h>
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+/** Log Prefix. */
+#define USBPROXY              "USBProxy"
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+/**
+ * Wrapper around the solaris urb request structure.
+ * This is required to track in-flight and landed URBs.
+ */
+typedef struct USBPROXYURBSOL
+{
+    /** Pointer to the Solaris device. */
+    struct USBPROXYDEVSOL         *pDevSol;
+    /** Pointer to the VUSB URB (set to NULL if canceled). */
+    PVUSBURB                       pVUsbUrb;
+    /** Pointer to the next solaris URB. */
+    struct USBPROXYURBSOL         *pNext;
+    /** Pointer to the previous solaris URB. */
+    struct USBPROXYURBSOL         *pPrev;
+} USBPROXYURBSOL, *PUSBPROXYURBSOL;
+
+/**
+ * Data for the solaris usb proxy backend.
+ */
+typedef struct USBPROXYDEVSOL
+{
+    /** Path of the USB device in the devices tree (persistent). */
+    char                          *pszDevicePath;
+    /** The connection to the client driver. */
+    RTFILE                         hFile;
+    /** Pointer to the proxy device instance. */
+    PUSBPROXYDEV                   pProxyDev;
+    /** Critical section protecting the two lists. */
+    RTCRITSECT                     CritSect;
+    /** The list of free solaris URBs. Singly linked. */
+    PUSBPROXYURBSOL                pFreeHead;
+    /** The list of active solaris URBs. Doubly linked.
+     * We must maintain this so we can properly reap URBs of a detached device.
+     * Only the split head will appear in this list. */
+    PUSBPROXYURBSOL                pInFlightHead;
+    /** The list of landed solaris URBs. Doubly linked.
+     * Only the split head will appear in this list. */
+    PUSBPROXYURBSOL                pTaxingHead;
+    /** The tail of the landed solaris URBs. */
+    PUSBPROXYURBSOL                pTaxingTail;
+    /** Pipe handle for waking up - writing end. */
+    RTPIPE                         hPipeWakeupW;
+    /** Pipe handle for waking up - reading end. */
+    RTPIPE                         hPipeWakeupR;
+} USBPROXYDEVSOL, *PUSBPROXYDEVSOL;
+
+static PVUSBURB usbProxySolarisUrbComplete(PUSBPROXYDEVSOL pDevSol);
+
+
+/**
+ * Allocates a Solaris URB request structure.
+ *
+ * @returns Pointer to an active URB request.
+ * @returns NULL on failure.
+ *
+ * @param   pDevSol         The solaris USB device.
+ */
+static PUSBPROXYURBSOL usbProxySolarisUrbAlloc(PUSBPROXYDEVSOL pDevSol)
+{
+    PUSBPROXYURBSOL pUrbSol;
+
+    RTCritSectEnter(&pDevSol->CritSect);
+
+    /*
+     * Try remove a Solaris URB from the free list, if none there allocate a new one.
+     */
+    pUrbSol = pDevSol->pFreeHead;
+    if (pUrbSol)
+        pDevSol->pFreeHead = pUrbSol->pNext;
+    else
+    {
+        RTCritSectLeave(&pDevSol->CritSect);
+        pUrbSol = (PUSBPROXYURBSOL)RTMemAlloc(sizeof(*pUrbSol));
+        if (!pUrbSol)
+            return NULL;
+        RTCritSectEnter(&pDevSol->CritSect);
+    }
+    pUrbSol->pVUsbUrb = NULL;
+    pUrbSol->pDevSol = pDevSol;
+
+    /*
+     * Link it into the active list
+     */
+    pUrbSol->pPrev = NULL;
+    pUrbSol->pNext = pDevSol->pInFlightHead;
+    if (pUrbSol->pNext)
+        pUrbSol->pNext->pPrev = pUrbSol;
+    pDevSol->pInFlightHead = pUrbSol;
+
+    RTCritSectLeave(&pDevSol->CritSect);
+    return pUrbSol;
+}
+
+
+/**
+ * Frees a Solaris URB request structure.
+ *
+ * @param   pDevSol         The Solaris USB device.
+ * @param   pUrbSol         The Solaris URB to free.
+ */
+static void usbProxySolarisUrbFree(PUSBPROXYDEVSOL pDevSol, PUSBPROXYURBSOL pUrbSol)
+{
+    RTCritSectEnter(&pDevSol->CritSect);
+
+    /*
+     * Remove from the active or taxing list.
+     */
+    if (pUrbSol->pNext)
+        pUrbSol->pNext->pPrev   = pUrbSol->pPrev;
+    else if (pDevSol->pTaxingTail == pUrbSol)
+        pDevSol->pTaxingTail    = pUrbSol->pPrev;
+
+    if (pUrbSol->pPrev)
+        pUrbSol->pPrev->pNext   = pUrbSol->pNext;
+    else if (pDevSol->pTaxingHead == pUrbSol)
+        pDevSol->pTaxingHead    = pUrbSol->pNext;
+    else if (pDevSol->pInFlightHead == pUrbSol)
+        pDevSol->pInFlightHead  = pUrbSol->pNext;
+    else
+        AssertFailed();
+
+    /*
+     * Link it into the free list.
+     */
+    pUrbSol->pPrev = NULL;
+    pUrbSol->pNext = pDevSol->pFreeHead;
+    pDevSol->pFreeHead = pUrbSol;
+
+    pUrbSol->pVUsbUrb = NULL;
+    pUrbSol->pDevSol = NULL;
+
+    RTCritSectLeave(&pDevSol->CritSect);
+}
+
+
+/*
+ * Close the connection to the USB client driver.
+ *
+ * This is required because our userland enumeration relies on drivers/device trees
+ * to recognize active devices, and hence if this device is unplugged we should no
+ * longer keep the client driver loaded.
+ */
+static void usbProxySolarisCloseFile(PUSBPROXYDEVSOL pDevSol)
+{
+    RTFileClose(pDevSol->hFile);
+    pDevSol->hFile = NIL_RTFILE;
+}
+
+
+/**
+ * The client driver IOCtl Wrapper function.
+ *
+ * @returns VBox status code.
+ * @param   pDevSol         The Solaris device instance.
+ * @param   Function        The Function.
+ * @param   pvData          Opaque pointer to the data.
+ * @param   cbData          Size of the data pointed to by pvData.
+ */
+static int usbProxySolarisIOCtl(PUSBPROXYDEVSOL pDevSol, unsigned Function, void *pvData, size_t cbData)
+{
+    if (RT_UNLIKELY(pDevSol->hFile == NIL_RTFILE))
+    {
+        LogFlow((USBPROXY ":usbProxySolarisIOCtl: Connection to driver gone!\n"));
+        return VERR_VUSB_DEVICE_NOT_ATTACHED;
+    }
+
+    VBOXUSBREQ Req;
+    Req.u32Magic = VBOXUSB_MAGIC;
+    Req.rc = -1;
+    Req.cbData = cbData;
+    Req.pvDataR3 = pvData;
+
+    int Ret = -1;
+    int rc = RTFileIoCtl(pDevSol->hFile, Function, &Req, sizeof(Req), &Ret);
+    if (RT_SUCCESS(rc))
+    {
+        if (RT_FAILURE(Req.rc))
+        {
+            if (Req.rc == VERR_VUSB_DEVICE_NOT_ATTACHED)
+            {
+                pDevSol->pProxyDev->fDetached = true;
+                usbProxySolarisCloseFile(pDevSol);
+                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));
+        }
+
+        return Req.rc;
+    }
+
+    LogRel((USBPROXY ": Function %#x failed. rc=%Rrc\n", Function, rc));
+    return rc;
+}
+
+
+/**
+ * Get the active configuration from the device. The first time this is called
+ * our client driver would returned the cached configuration since the device is first plugged in.
+ * Subsequent get configuration requests are passed on to the device.
+ *
+ * @returns VBox status code.
+ * @param   pDevSol         The Solaris device instance.
+ *
+ */
+static inline int usbProxySolarisGetActiveConfig(PUSBPROXYDEVSOL pDevSol)
+{
+    VBOXUSBREQ_GET_CONFIG GetConfigReq;
+    bzero(&GetConfigReq, sizeof(GetConfigReq));
+    int rc = usbProxySolarisIOCtl(pDevSol, VBOXUSB_IOCTL_GET_CONFIG, &GetConfigReq, sizeof(GetConfigReq));
+    if (RT_SUCCESS(rc))
+    {
+        pDevSol->pProxyDev->iActiveCfg = GetConfigReq.bConfigValue;
+        pDevSol->pProxyDev->cIgnoreSetConfigs = 0;
+    }
+    else
+    {
+        if (rc != VERR_VUSB_DEVICE_NOT_ATTACHED)
+            LogRel((USBPROXY ": Failed to get configuration. rc=%Rrc\n", rc));
+
+        pDevSol->pProxyDev->iActiveCfg = -1;
+        pDevSol->pProxyDev->cIgnoreSetConfigs = 0;
+    }
+    return rc;
+}
+
+
+/**
+ * Opens the USB device.
+ *
+ * @returns VBox status code.
+ * @param   pProxyDev       The device instance.
+ * @param   pszAddress      The unique device identifier.
+ *                          The format of this string is "VendorId:ProducIt:Release:StaticPath".
+ */
+static DECLCALLBACK(int) usbProxySolarisOpen(PUSBPROXYDEV pProxyDev, const char *pszAddress)
+{
+    PUSBPROXYDEVSOL pDevSol = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVSOL);
+
+    LogFlowFunc((USBPROXY ":usbProxySolarisOpen: pProxyDev=%p pszAddress=%s\n", pProxyDev, pszAddress));
+
+    /*
+     * Initialize our USB R3 lib.
+     */
+    int rc = USBLibInit();
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Allocate and initialize the solaris backend data.
+         */
+        AssertCompile(PATH_MAX >= MAXPATHLEN);
+        char szDeviceIdent[PATH_MAX+48];
+        rc = RTStrPrintf(szDeviceIdent, sizeof(szDeviceIdent), "%s", pszAddress);
+        if (RT_SUCCESS(rc))
+        {
+            rc = RTCritSectInit(&pDevSol->CritSect);
+            if (RT_SUCCESS(rc))
+            {
+                /*
+                 * Create wakeup pipe.
+                 */
+                rc = RTPipeCreate(&pDevSol->hPipeWakeupR, &pDevSol->hPipeWakeupW, 0);
+                if (RT_SUCCESS(rc))
+                {
+                    int Instance;
+                    char *pszDevicePath = NULL;
+                    rc = USBLibGetClientInfo(szDeviceIdent, &pszDevicePath, &Instance);
+                    if (RT_SUCCESS(rc))
+                    {
+                        pDevSol->pszDevicePath = pszDevicePath;
+
+                        /*
+                         * Open the client driver.
+                         */
+                        RTFILE hFile;
+                        rc = RTFileOpen(&hFile, pDevSol->pszDevicePath, RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
+                        if (RT_SUCCESS(rc))
+                        {
+                            pDevSol->hFile = hFile;
+                            pDevSol->pProxyDev = pProxyDev;
+
+                            /*
+                             * Verify client driver version.
+                             */
+                            VBOXUSBREQ_GET_VERSION GetVersionReq;
+                            bzero(&GetVersionReq, sizeof(GetVersionReq));
+                            rc = usbProxySolarisIOCtl(pDevSol, VBOXUSB_IOCTL_GET_VERSION, &GetVersionReq, sizeof(GetVersionReq));
+                            if (RT_SUCCESS(rc))
+                            {
+                                if (   GetVersionReq.u32Major == VBOXUSB_VERSION_MAJOR
+                                    && GetVersionReq.u32Minor >= VBOXUSB_VERSION_MINOR)
+                                {
+                                    /*
+                                     * Try & get the current cached config from Solaris.
+                                     */
+                                    usbProxySolarisGetActiveConfig(pDevSol);
+                                    return VINF_SUCCESS;
+                                }
+                                else
+                                {
+                                    LogRel((USBPROXY ": Version mismatch, Driver v%d.%d expecting ~v%d.%d\n", GetVersionReq.u32Major,
+                                            GetVersionReq.u32Minor, VBOXUSB_VERSION_MAJOR, VBOXUSB_VERSION_MINOR));
+                                    rc = VERR_VERSION_MISMATCH;
+                                }
+                            }
+                            else
+                                LogRel((USBPROXY ": Failed to query driver version. rc=%Rrc\n", rc));
+
+                            RTFileClose(pDevSol->hFile);
+                            pDevSol->hFile = NIL_RTFILE;
+                            pDevSol->pProxyDev = NULL;
+                        }
+                        else
+                            LogRel((USBPROXY ": Failed to open device. rc=%Rrc pszDevicePath=%s\n", rc, pDevSol->pszDevicePath));
+
+                        RTStrFree(pDevSol->pszDevicePath);
+                        pDevSol->pszDevicePath = NULL;
+                    }
+                    else
+                    {
+                        LogRel((USBPROXY ": Failed to get client info. rc=%Rrc szDeviceIdent=%s\n", rc, szDeviceIdent));
+                        if (rc == VERR_NOT_FOUND)
+                            rc = VERR_OPEN_FAILED;
+                    }
+                    RTPipeClose(pDevSol->hPipeWakeupR);
+                    RTPipeClose(pDevSol->hPipeWakeupW);
+                }
+
+                RTCritSectDelete(&pDevSol->CritSect);
+            }
+            else
+                LogRel((USBPROXY ": RTCritSectInit failed. rc=%Rrc pszAddress=%s\n", rc, pszAddress));
+        }
+        else
+            LogRel((USBPROXY ": RTStrAPrintf failed. rc=%Rrc pszAddress=%s\n", rc, pszAddress));
+    }
+    else
+        LogRel((USBPROXY ": USBLibInit failed. rc=%Rrc\n", rc));
+
+    USBLibTerm();
+    return rc;
+}
+
+
+/**
+ * Close the USB device.
+ *
+ * @param   pProxyDev   The device instance.
+ */
+static DECLCALLBACK(void) usbProxySolarisClose(PUSBPROXYDEV pProxyDev)
+{
+    LogFlow((USBPROXY ":usbProxySolarisClose: pProxyDev=%p\n", pProxyDev));
+
+    PUSBPROXYDEVSOL pDevSol = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVSOL);
+
+    /* Close the device (do not re-enumerate). */
+    VBOXUSBREQ_CLOSE_DEVICE CloseReq;
+    CloseReq.ResetLevel = VBOXUSB_RESET_LEVEL_CLOSE;
+    usbProxySolarisIOCtl(pDevSol, VBOXUSB_IOCTL_CLOSE_DEVICE, &CloseReq, sizeof(CloseReq));
+
+    pProxyDev->fDetached = true;
+    usbProxySolarisCloseFile(pDevSol);
+
+    /*
+     * Now we can close it and free all the resources.
+     */
+    RTCritSectDelete(&pDevSol->CritSect);
+
+    PUSBPROXYURBSOL pUrbSol = NULL;
+    while ((pUrbSol = pDevSol->pInFlightHead) != NULL)
+    {
+        pDevSol->pInFlightHead = pUrbSol->pNext;
+        RTMemFree(pUrbSol);
+    }
+
+    while ((pUrbSol = pDevSol->pFreeHead) != NULL)
+    {
+        pDevSol->pFreeHead = pUrbSol->pNext;
+        RTMemFree(pUrbSol);
+    }
+
+    RTPipeClose(pDevSol->hPipeWakeupR);
+    RTPipeClose(pDevSol->hPipeWakeupW);
+
+    RTStrFree(pDevSol->pszDevicePath);
+    pDevSol->pszDevicePath = NULL;
+
+    USBLibTerm();
+}
+
+
+/**
+ * Reset the device.
+ *
+ * @returns VBox status code.
+ * @param   pProxyDev           The device to reset.
+ * @param   fRootHubReset       Is this a root hub reset or device specific reset request.
+ */
+static DECLCALLBACK(int) usbProxySolarisReset(PUSBPROXYDEV pProxyDev, bool 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. */
+    PUSBPROXYDEVSOL pDevSol = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVSOL);
+
+    /* Soft reset the device. */
+    VBOXUSBREQ_CLOSE_DEVICE CloseReq;
+    CloseReq.ResetLevel = VBOXUSB_RESET_LEVEL_SOFT;
+    int rc = usbProxySolarisIOCtl(pDevSol, VBOXUSB_IOCTL_CLOSE_DEVICE, &CloseReq, sizeof(CloseReq));
+    if (RT_SUCCESS(rc))
+    {
+        /* Get the active config. Solaris USBA sets a default config. */
+        usbProxySolarisGetActiveConfig(pDevSol);
+    }
+    else if (rc != VERR_VUSB_DEVICE_NOT_ATTACHED)
+        LogRel((USBPROXY ": usbProxySolarisReset: Failed! rc=%d\n", rc));
+
+    return rc;
+}
+
+
+/**
+ * Set the active configuration.
+ *
+ * The caller makes sure that it's not called first time after open or reset
+ * with the active interface.
+ *
+ * @returns success indicator.
+ * @param   pProxyDev       The device instance data.
+ * @param   iCfg            The configuration value to set.
+ */
+static DECLCALLBACK(int) usbProxySolarisSetConfig(PUSBPROXYDEV pProxyDev, int iCfg)
+{
+    LogFlowFunc((USBPROXY ": usbProxySolarisSetConfig: pProxyDev=%p iCfg=%#x\n", pProxyDev, iCfg));
+
+    PUSBPROXYDEVSOL pDevSol = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVSOL);
+    AssertPtrReturn(pDevSol, VERR_INVALID_POINTER);
+
+    VBOXUSBREQ_SET_CONFIG SetConfigReq;
+    SetConfigReq.bConfigValue = iCfg;
+    int rc = usbProxySolarisIOCtl(pDevSol, VBOXUSB_IOCTL_SET_CONFIG, &SetConfigReq, sizeof(SetConfigReq));
+    if (   RT_FAILURE(rc)
+        && rc != VERR_VUSB_DEVICE_NOT_ATTACHED)
+        LogRel((USBPROXY ": usbProxySolarisSetConfig: Failed! rc=%Rrc\n", rc));
+
+    return rc;
+}
+
+
+/**
+ * Claims an interface.
+ *
+ * This is a stub on Solaris since we release/claim all interfaces at
+ * as and when required with endpoint opens.
+ *
+ * @returns success indicator (always true).
+ */
+static DECLCALLBACK(int) usbProxySolarisClaimInterface(PUSBPROXYDEV pProxyDev, int iIf)
+{
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Releases an interface.
+ *
+ * This is a stub on Solaris since we release/claim all interfaces at
+ * as and when required with endpoint opens.
+ *
+ * @returns success indicator.
+ */
+static DECLCALLBACK(int) usbProxySolarisReleaseInterface(PUSBPROXYDEV pProxyDev, int iIf)
+{
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Specify an alternate setting for the specified interface of the current configuration.
+ *
+ * @returns success indicator.
+ */
+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);
+    AssertPtrReturn(pDevSol, VERR_INVALID_POINTER);
+
+    VBOXUSBREQ_SET_INTERFACE SetInterfaceReq;
+    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! rc=%Rrc\n", rc));
+
+    return rc;
+}
+
+
+/**
+ * Clears the halted endpoint 'EndPt'.
+ */
+static DECLCALLBACK(int) usbProxySolarisClearHaltedEp(PUSBPROXYDEV pProxyDev, unsigned int EndPt)
+{
+    LogFlowFunc((USBPROXY ": usbProxySolarisClearHaltedEp: pProxyDev=%p EndPt=%#x\n", pProxyDev, EndPt));
+
+    PUSBPROXYDEVSOL pDevSol = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVSOL);
+    AssertPtrReturn(pDevSol, VERR_INVALID_POINTER);
+
+    VBOXUSBREQ_CLEAR_EP ClearEpReq;
+    ClearEpReq.bEndpoint = EndPt;
+    int rc = usbProxySolarisIOCtl(pDevSol, VBOXUSB_IOCTL_CLEAR_EP, &ClearEpReq, sizeof(ClearEpReq));
+    if (   RT_FAILURE(rc)
+        && rc != VERR_VUSB_DEVICE_NOT_ATTACHED)
+        LogRel((USBPROXY ": usbProxySolarisClearHaltedEp: Failed! rc=%Rrc\n", rc));
+
+    return rc;
+}
+
+
+/**
+ * @interface_method_impl{USBPROXYBACK,pfnUrbQueue}
+ */
+static DECLCALLBACK(int) usbProxySolarisUrbQueue(PUSBPROXYDEV pProxyDev, PVUSBURB pUrb)
+{
+    PUSBPROXYDEVSOL pDevSol = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVSOL);
+
+    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"));
+        return VERR_NO_MEMORY;
+    }
+
+    pUrbSol->pVUsbUrb = pUrb;
+    pUrbSol->pDevSol = pDevSol;
+
+    uint8_t EndPt = pUrb->EndPt;
+    if (EndPt)
+        EndPt |= pUrb->enmDir == VUSBDIRECTION_IN ? VUSB_DIR_TO_HOST : VUSB_DIR_TO_DEVICE;
+
+    VBOXUSBREQ_URB UrbReq;
+    UrbReq.pvUrbR3      = pUrbSol;
+    UrbReq.bEndpoint    = EndPt;
+    UrbReq.enmType      = pUrb->enmType;
+    UrbReq.enmDir       = pUrb->enmDir;
+    UrbReq.enmStatus    = pUrb->enmStatus;
+    UrbReq.fShortOk     = !pUrb->fShortNotOk;
+    UrbReq.cbData       = pUrb->cbData;
+    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)
+    {
+        UrbReq.cIsocPkts = pUrb->cIsocPkts;
+        for (unsigned i = 0; i < pUrb->cIsocPkts; i++)
+        {
+            UrbReq.aIsocPkts[i].cbPkt = pUrb->aIsocPkts[i].cb;
+            UrbReq.aIsocPkts[i].cbActPkt = 0;
+            UrbReq.aIsocPkts[i].enmStatus = VUSBSTATUS_INVALID;
+        }
+    }
+
+    int rc = usbProxySolarisIOCtl(pDevSol, VBOXUSB_IOCTL_SEND_URB, &UrbReq, sizeof(UrbReq));
+    if (RT_SUCCESS(rc))
+    {
+        if (pUrb->enmType == VUSBXFERTYPE_ISOC)
+            LogFlow((USBPROXY ":usbProxySolarisUrbQueue: Success cbData=%d\n", pUrb->cbData));
+        pUrb->Dev.pvPrivate = pUrbSol;
+        return VINF_SUCCESS;
+    }
+
+    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));
+    }
+
+    return rc;
+}
+
+
+/**
+ * Cancels a URB.
+ *
+ * The URB requires reaping, so we don't change its state.
+ * @remark  There isn't any way to cancel a specific asynchronous request
+ *          on Solaris. So we just abort pending URBs on the pipe.
+ */
+static DECLCALLBACK(int) usbProxySolarisUrbCancel(PUSBPROXYDEV pProxyDev, PVUSBURB pUrb)
+{
+    PUSBPROXYURBSOL pUrbSol = (PUSBPROXYURBSOL)pUrb->Dev.pvPrivate;
+    PUSBPROXYDEVSOL pDevSol = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVSOL);
+    AssertPtrReturn(pDevSol, VERR_INVALID_POINTER);
+
+    LogFlowFunc((USBPROXY ": usbProxySolarisUrbCancel: pUrb=%p pUrbSol=%p pDevSol=%p\n", pUrb, pUrbSol, pUrbSol->pDevSol));
+
+    /* Aborting the control pipe isn't supported, pretend success. */
+    if (!pUrb->EndPt)
+        return VINF_SUCCESS;
+
+    VBOXUSBREQ_ABORT_PIPE AbortPipeReq;
+    AbortPipeReq.bEndpoint = pUrb->EndPt | (pUrb->enmDir == VUSBDIRECTION_IN ? VUSB_DIR_TO_HOST : VUSB_DIR_TO_DEVICE);
+    int rc = usbProxySolarisIOCtl(pDevSol, VBOXUSB_IOCTL_ABORT_PIPE, &AbortPipeReq, sizeof(AbortPipeReq));
+    if (   RT_FAILURE(rc)
+        && rc != VERR_VUSB_DEVICE_NOT_ATTACHED)
+        LogRel((USBPROXY ": usbProxySolarisUrbCancel: Failed to abort pipe. rc=%Rrc\n", rc));
+
+    LogFlow((USBPROXY ": usbProxySolarisUrbCancel: returns rc=%Rrc\n", rc));
+    return rc;
+}
+
+
+/**
+ * Reap URBs in-flight on a device.
+ *
+ * @returns Pointer to a completed URB.
+ * @returns NULL if no URB was completed.
+ * @param   pProxyDev   The device.
+ * @param   cMillies    Number of milliseconds to wait. Use 0 to not wait at all.
+ */
+static DECLCALLBACK(PVUSBURB) usbProxySolarisUrbReap(PUSBPROXYDEV pProxyDev, RTMSINTERVAL cMillies)
+{
+    LogFlowFunc((USBPROXY ":usbProxySolarisUrbReap pProxyDev=%p cMillies=%u\n", pProxyDev, cMillies));
+
+    PUSBPROXYDEVSOL pDevSol = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVSOL);
+
+    /*
+     * Don't block if nothing is in the air.
+     */
+    if (!pDevSol->pInFlightHead)
+        return NULL;
+
+    /*
+     * Deque URBs inflight or those landed.
+     */
+    if (cMillies > 0)
+    {
+        for (;;)
+        {
+            int cMilliesWait = cMillies == RT_INDEFINITE_WAIT ? -1 : (int)cMillies;
+
+            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 (aFd[0].revents & POLLHUP)
+                {
+                    LogRel((USBPROXY ": USB Device '%s' disconnected!\n", pDevSol->pProxyDev->pUsbIns->pszName));
+                    pProxyDev->fDetached = true;
+                    usbProxySolarisCloseFile(pDevSol);
+                }
+
+                if (aFd[1].revents & POLLIN)
+                {
+                    /* Got woken up, drain pipe. */
+                    uint8_t bRead;
+                    size_t cbIgnored = 0;
+                    RTPipeRead(pDevSol->hPipeWakeupR, &bRead, 1, &cbIgnored);
+
+                    /*
+                     * It is possible that we got woken up and have an URB pending
+                     * for completion. Do it on the way out. Otherwise return
+                     * immediately to the caller.
+                     */
+                    if (!(aFd[0].revents & POLLIN))
+                        return NULL;
+                }
+                break;
+            }
+            else if (rc == 0)
+                return NULL;
+            else if (errno != EAGAIN)
+            {
+                LogFlow((USBPROXY ":usbProxySolarisUrbReap Poll rc=%d errno=%d\n", rc, errno));
+                return NULL;
+            }
+        }
+    }
+
+    usbProxySolarisUrbComplete(pDevSol);
+
+    /*
+     * Any URBs pending delivery?
+     */
+    PVUSBURB pUrb = NULL;
+    while (    pDevSol->pTaxingHead
+           && !pUrb)
+    {
+        RTCritSectEnter(&pDevSol->CritSect);
+
+        PUSBPROXYURBSOL pUrbSol = pDevSol->pTaxingHead;
+        if (pUrbSol)
+        {
+            pUrb = pUrbSol->pVUsbUrb;
+            if (pUrb)
+            {
+                /*
+                 * Remove it from the taxing list and move it to the free list.
+                 */
+                pUrb->Dev.pvPrivate = NULL;
+                usbProxySolarisUrbFree(pDevSol, pUrbSol);
+            }
+        }
+        RTCritSectLeave(&pDevSol->CritSect);
+    }
+
+    return pUrb;
+}
+
+
+/**
+ * Reads a completed/error'd URB from the client driver (no waiting).
+ *
+ * @param   pDevSol         The Solaris device instance.
+ */
+static PVUSBURB usbProxySolarisUrbComplete(PUSBPROXYDEVSOL pDevSol)
+{
+    LogFlowFunc((USBPROXY ": usbProxySolarisUrbComplete: pDevSol=%p\n", pDevSol));
+
+    VBOXUSBREQ_URB UrbReq;
+    bzero(&UrbReq, sizeof(UrbReq));
+
+    int rc = usbProxySolarisIOCtl(pDevSol, VBOXUSB_IOCTL_REAP_URB, &UrbReq, sizeof(UrbReq));
+    if (RT_SUCCESS(rc))
+    {
+        if (UrbReq.pvUrbR3)
+        {
+            PUSBPROXYURBSOL pUrbSol = (PUSBPROXYURBSOL)UrbReq.pvUrbR3;
+            PVUSBURB pUrb           = pUrbSol->pVUsbUrb;
+            if (RT_LIKELY(pUrb))
+            {
+                Assert(pUrb->u32Magic == VUSBURB_MAGIC);
+
+                /*
+                 * Update the URB.
+                 */
+                if (   pUrb->enmType == VUSBXFERTYPE_ISOC
+                    && pUrb->enmDir == VUSBDIRECTION_IN)
+                {
+                    size_t cbData = 0;
+                    for (unsigned i = 0; i < UrbReq.cIsocPkts; i++)
+                    {
+                        pUrb->aIsocPkts[i].cb = UrbReq.aIsocPkts[i].cbActPkt;
+                        cbData += UrbReq.aIsocPkts[i].cbActPkt;
+                        pUrb->aIsocPkts[i].enmStatus = UrbReq.aIsocPkts[i].enmStatus;
+                    }
+
+                    LogFlow((USBPROXY ":usbProxySolarisUrbComplete: Isoc cbData=%d cbActPktSum=%d\n", pUrb->cbData, cbData));
+                    pUrb->cbData = cbData;
+                    pUrb->enmStatus = UrbReq.enmStatus;
+                }
+                else
+                {
+                    pUrb->cbData    = UrbReq.cbData;
+                    pUrb->enmStatus = UrbReq.enmStatus;
+                }
+
+                RTCritSectEnter(&pDevSol->CritSect);
+
+                /*
+                 * Remove from the active list.
+                 */
+                if (pUrbSol->pNext)
+                    pUrbSol->pNext->pPrev = pUrbSol->pPrev;
+                if (pUrbSol->pPrev)
+                    pUrbSol->pPrev->pNext = pUrbSol->pNext;
+                else
+                {
+                    Assert(pDevSol->pInFlightHead == pUrbSol);
+                    pDevSol->pInFlightHead = pUrbSol->pNext;
+                }
+
+                /*
+                 * Add to the tail of the taxing list.
+                 */
+                pUrbSol->pNext = NULL;
+                pUrbSol->pPrev = pDevSol->pTaxingTail;
+                if (pDevSol->pTaxingTail)
+                    pDevSol->pTaxingTail->pNext = pUrbSol;
+                else
+                    pDevSol->pTaxingHead = pUrbSol;
+                pDevSol->pTaxingTail = pUrbSol;
+
+                RTCritSectLeave(&pDevSol->CritSect);
+
+                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;
+            }
+        }
+    }
+    else
+    {
+        if (rc != VERR_VUSB_DEVICE_NOT_ATTACHED)
+            LogRel((USBPROXY ": Reaping URB failed. rc=%Rrc\n", rc));
+    }
+
+    return NULL;
+}
+
+
+static DECLCALLBACK(int) usbProxySolarisWakeup(PUSBPROXYDEV pProxyDev)
+{
+    PUSBPROXYDEVSOL pDevSol = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVSOL);
+    size_t cbIgnored;
+
+    LogFlowFunc(("pProxyDev=%p\n", pProxyDev));
+
+    return RTPipeWrite(pDevSol->hPipeWakeupW, "", 1, &cbIgnored);
+}
+
+
+/**
+ * The Solaris USB Proxy Backend.
+ */
+extern const USBPROXYBACK g_USBProxyDeviceHost =
+{
+    /* pszName */
+    "host",
+    /* cbBackend */
+    sizeof(USBPROXYDEVSOL),
+    usbProxySolarisOpen,
+    NULL,
+    usbProxySolarisClose,
+    usbProxySolarisReset,
+    usbProxySolarisSetConfig,
+    usbProxySolarisClaimInterface,
+    usbProxySolarisReleaseInterface,
+    usbProxySolarisSetInterface,
+    usbProxySolarisClearHaltedEp,
+    usbProxySolarisUrbQueue,
+    usbProxySolarisUrbCancel,
+    usbProxySolarisUrbReap,
+    usbProxySolarisWakeup,
+    0
+};
+