VirtualBox

Ignore:
Timestamp:
Jun 13, 2012 5:01:16 PM (13 years ago)
Author:
vboxsync
Message:

VBoxUSB/solaris: locking tweaks and wrap to 130 columns.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/HostDrivers/VBoxUSB/solaris/VBoxUSB-solaris.c

    r40200 r41687  
    108108
    109109/*******************************************************************************
    110 *   Kernel Entry Hook                                                          *
     110*   Kernel Entry Hooks                                                         *
    111111*******************************************************************************/
    112112int VBoxUSBSolarisOpen(dev_t *pDev, int fFlag, int fType, cred_t *pCred);
     
    317317LOCAL inline void vboxUSBSolarisDeQueueURB(vboxusb_urb_t *pUrb, int URBStatus);
    318318LOCAL inline void vboxUSBSolarisNotifyComplete(vboxusb_state_t *pState);
    319 LOCAL int vboxUSBSolarisProcessIOCtl(int iFunction, void *pvState, int Mode, PVBOXUSBREQ pUSBReq, void *pvBuf, size_t *pcbDataOut);
     319LOCAL int vboxUSBSolarisProcessIOCtl(int iFunction, void *pvState, int Mode, PVBOXUSBREQ pUSBReq, void *pvBuf,
     320                                     size_t *pcbDataOut);
    320321LOCAL bool vboxUSBSolarisIsUSBDevice(dev_info_t *pDip);
    321322
     
    555556                                                    char szDevicePath[MAXPATHLEN];
    556557                                                    ddi_pathname(pState->pDip, szDevicePath);
    557                                                     RTStrPrintf(pState->ClientInfo.szClientPath, sizeof(pState->ClientInfo.szClientPath),
    558                                                                 "/devices%s:%s",
    559                                                                 szDevicePath,
    560                                                                 DEVICE_NAME);
     558                                                    RTStrPrintf(pState->ClientInfo.szClientPath,
     559                                                                sizeof(pState->ClientInfo.szClientPath),
     560                                                                "/devices%s:%s", szDevicePath,DEVICE_NAME);
    561561                                                    RTPathStripFilename(szDevicePath);
    562                                                     RTStrPrintf(pState->ClientInfo.szDeviceIdent, sizeof(pState->ClientInfo.szDeviceIdent),
     562                                                    RTStrPrintf(pState->ClientInfo.szDeviceIdent,
     563                                                                sizeof(pState->ClientInfo.szDeviceIdent),
    563564                                                                "%#x:%#x:%d:%s",
    564565                                                                pState->pDevDesc->dev_descr->idVendor,
    565566                                                                pState->pDevDesc->dev_descr->idProduct,
    566                                                                 pState->pDevDesc->dev_descr->bcdDevice,
    567                                                                 szDevicePath);
     567                                                                pState->pDevDesc->dev_descr->bcdDevice, szDevicePath);
    568568                                                    pState->ClientInfo.Instance = instance;
    569569                                                    pState->ClientInfo.pfnSetConsumerCredentials = &vboxUSBSolarisSetConsumerCredentials;
     
    572572                                                    {
    573573                                                        LogRel((DEVICE_NAME ": Captured %s %#x:%#x:%d:%s\n",
    574                                                                 pState->pDevDesc->dev_product ? pState->pDevDesc->dev_product : "<Unnamed USB device>",
     574                                                                pState->pDevDesc->dev_product ? pState->pDevDesc->dev_product
     575                                                                    : "<Unnamed USB device>",
    575576                                                                pState->pDevDesc->dev_descr->idVendor,
    576577                                                                pState->pDevDesc->dev_descr->idProduct,
     
    582583                                                    else
    583584                                                    {
    584                                                         LogRel((DEVICE_NAME ":VBoxUSBMonSolarisRegisterClient failed! rc=%d path=%s instance=%d\n",
    585                                                                 rc, pState->ClientInfo.szClientPath, instance));
     585                                                        LogRel((DEVICE_NAME ":VBoxUSBMonSolarisRegisterClient failed! rc=%d "
     586                                                                "path=%s instance=%d\n", rc, pState->ClientInfo.szClientPath,
     587                                                                instance));
    586588                                                    }
    587589
     
    589591                                                }
    590592                                                else
    591                                                     LogRel((DEVICE_NAME ":VBoxUSBSolarisAttach failed to register hotplug callbacks! rc=%d\n", rc));
     593                                                    LogRel((DEVICE_NAME ":VBoxUSBSolarisAttach failed to register hotplug "
     594                                                            "callbacks! rc=%d\n", rc));
    592595
    593596                                                ddi_remove_minor_node(pState->pDip, NULL);
    594597                                            }
    595598                                            else
    596                                                 LogRel((DEVICE_NAME ":VBoxUSBSolarisAttach ddi_create_minor_node failed! rc=%d\n", rc));
     599                                            {
     600                                                LogRel((DEVICE_NAME ":VBoxUSBSolarisAttach ddi_create_minor_node failed! rc=%d\n",
     601                                                        rc));
     602                                            }
    597603                                        }
    598604                                        else
    599                                             LogRel((DEVICE_NAME ":VBoxUSBSolarisAttach failed to initialize power management! rc=%d\n", rc));
     605                                        {
     606                                            LogRel((DEVICE_NAME ":VBoxUSBSolarisAttach failed to initialize power management! "
     607                                                    "rc=%d\n", rc));
     608                                        }
    600609                                    }
    601610                                    else
    602                                         LogRel((DEVICE_NAME ":VBoxUSBSolarisAttach vboxUSBSolarisInitAllEndPoints failed! rc=%d\n"));
     611                                    {
     612                                        LogRel((DEVICE_NAME ":VBoxUSBSolarisAttach vboxUSBSolarisInitAllEndPoints failed! "
     613                                                "rc=%d\n"));
     614                                    }
    603615                                }
    604616                                else
    605                                     LogRel((DEVICE_NAME ":VBoxUSBSolarisAttach usb_pipe_get_max_bulk_transfer_size failed! rc=%d\n", rc));
     617                                {
     618                                    LogRel((DEVICE_NAME ":VBoxUSBSolarisAttach usb_pipe_get_max_bulk_transfer_size failed! "
     619                                            "rc=%d\n", rc));
     620                                }
    606621
    607622                                usb_fini_serialization(pState->StateMulti);
     
    618633                    }
    619634                    else
    620                         Log((DEVICE_NAME ":VBoxUSBSolarisAttach not a USB device.\n")); /* This would appear on every boot if it were Rel */
     635                    {
     636                        /* This would appear on every boot if it were LogRel() */
     637                        Log((DEVICE_NAME ":VBoxUSBSolarisAttach not a USB device.\n"));
     638                    }
    621639                }
    622640                else
     
    850868    else
    851869    {
    852         LogRel((DEVICE_NAME ":vboxUSBSolarisSetConsumerCredentials failed! Process %u already has client open.\n", pState->Process));
     870        LogRel((DEVICE_NAME ":vboxUSBSolarisSetConsumerCredentials failed! Process %u already has client open.\n",
     871                pState->Process));
    853872        rc = VERR_RESOURCE_BUSY;
    854873    }
     
    891910            LogRel((DEVICE_NAME ":VBoxUSBSolarisOpen No prior information about authorized process.\n"));
    892911        else
    893             LogRel((DEVICE_NAME ":VBoxUSBSolarisOpen Process %d is already using this device instance.\n", pState->Process));
     912            LogRel((DEVICE_NAME ":VBoxUSBSolarisOpen Process %u is already using this device instance.\n", pState->Process));
    894913
    895914        mutex_exit(&pState->Mtx);
     
    10911110    if (IOCPARM_LEN(Cmd) != sizeof(ReqWrap))
    10921111    {
    1093         LogRel((DEVICE_NAME ": VBoxUSBSolarisIOCtl: bad request %#x size=%d expected=%d\n", Cmd, IOCPARM_LEN(Cmd), sizeof(ReqWrap)));
     1112        LogRel((DEVICE_NAME ": VBoxUSBSolarisIOCtl: bad request %#x size=%d expected=%d\n", Cmd, IOCPARM_LEN(Cmd),
     1113                sizeof(ReqWrap)));
    10941114        return ENOTTY;
    10951115    }
     
    11491169    if (RT_UNLIKELY(cbDataOut > ReqWrap.cbData))
    11501170    {
    1151         LogRel((DEVICE_NAME ":VBoxUSBSolarisIOCtl: too much output data %d expected %d Truncating!\n", cbDataOut, ReqWrap.cbData));
     1171        LogRel((DEVICE_NAME ":VBoxUSBSolarisIOCtl: too much output data %d expected %d Truncating!\n", cbDataOut,
     1172                ReqWrap.cbData));
    11521173        cbDataOut = ReqWrap.cbData;
    11531174    }
     
    11691190            if (RT_UNLIKELY(rc))
    11701191            {
    1171                 LogRel((DEVICE_NAME ":VBoxUSBSolarisIOCtl: ddi_copyout failed; pvBuf=%p pArg=%p Cmd=%d. rc=%d\n", pvBuf, pArg, Cmd, rc));
     1192                LogRel((DEVICE_NAME ":VBoxUSBSolarisIOCtl: ddi_copyout failed; pvBuf=%p pArg=%p Cmd=%d. rc=%d\n", pvBuf, pArg,
     1193                        Cmd, rc));
    11721194                rc = EFAULT;
    11731195            }
     
    11761198    else
    11771199    {
    1178         LogRel((DEVICE_NAME ":VBoxUSBSolarisIOCtl: ddi_copyout(1)failed; pReqWrap=%p pArg=%p Cmd=%d. rc=%d\n", &ReqWrap, pArg, Cmd, rc));
     1200        LogRel((DEVICE_NAME ":VBoxUSBSolarisIOCtl: ddi_copyout(1)failed; pReqWrap=%p pArg=%p Cmd=%d. rc=%d\n", &ReqWrap, pArg,
     1201                Cmd, rc));
    11791202        rc = EFAULT;
    11801203    }
     
    15601583            if (!strncmp(ppszCompatible[cCompatible], "usb", 3))
    15611584            {
    1562                 Log((DEVICE_NAME ":vboxUSBSolarisIsUSBDevice verified device as USB. pszCompatible=%s\n", ppszCompatible[cCompatible]));
     1585                Log((DEVICE_NAME ":vboxUSBSolarisIsUSBDevice verified device as USB. pszCompatible=%s\n",
     1586                     ppszCompatible[cCompatible]));
    15631587                ddi_prop_free(ppszCompatible);
    15641588                return true;
     
    15781602    if (pParentDip)
    15791603    {
    1580         rc = ddi_prop_lookup_string_array(DDI_DEV_T_ANY, pParentDip, DDI_PROP_DONTPASS, "compatible", &ppszCompatible, &cCompatible);
     1604        rc = ddi_prop_lookup_string_array(DDI_DEV_T_ANY, pParentDip, DDI_PROP_DONTPASS, "compatible", &ppszCompatible,
     1605                                          &cCompatible);
    15811606        if (RT_LIKELY(rc == DDI_PROP_SUCCESS))
    15821607        {
    15831608            while (cCompatible--)
    15841609            {
    1585                 Log((DEVICE_NAME ":vboxUSBSolarisIsUSBDevice parent compatible[%d]=%s\n", cCompatible, ppszCompatible[cCompatible]));
     1610                Log((DEVICE_NAME ":vboxUSBSolarisIsUSBDevice parent compatible[%d]=%s\n", cCompatible,
     1611                     ppszCompatible[cCompatible]));
    15861612                if (!strncmp(ppszCompatible[cCompatible], "usb", 3))
    15871613                {
     
    16101636 *
    16111637 * @param   pState          The USB device instance.
    1612  * @param   pUrb            Pointer to the VBox USB URB.
     1638 * @param   pUrbReq         Pointer to the VBox USB URB.
    16131639 * @param   Mode            The IOCtl mode.
    16141640 *
     
    16731699            mutex_exit(&pState->Mtx);
    16741700            freemsg(pMsg);
    1675             LogRel((DEVICE_NAME ":vboxUSBSolarisSendUrb OpenPipe failed. pState=%p pUrbReq=%p bEndpoint=%#x enmDir=%#x enmType=%#x cbData=%d pvData=%p rc=%d\n",
    1676                     pState, pUrbReq, pUrbReq->bEndpoint, pUrbReq->enmDir, pUrbReq->enmType, pUrbReq->cbData, pUrbReq->pvData, rc));
     1701            LogRel((DEVICE_NAME ":vboxUSBSolarisSendUrb OpenPipe failed. pState=%p pUrbReq=%p bEndpoint=%#x enmDir=%#x "
     1702                    "enmType=%#x cbData=%d pvData=%p rc=%d\n", pState, pUrbReq, pUrbReq->bEndpoint, pUrbReq->enmDir,
     1703                    pUrbReq->enmType, pUrbReq->cbData, pUrbReq->pvData, rc));
    16771704            return VERR_BAD_PIPE;
    16781705        }
     
    17241751            if (RT_FAILURE(rc))
    17251752            {
     1753                /** @todo We share the state mutex for protecting concurrent accesses to both
     1754                 *        the inflight URB list as well as pUrb->pMsg (data). Probably make this
     1755                 *        more fine grained later by having a different mutex for the URB if
     1756                 *        it's really worth the trouble. */
    17261757                mutex_enter(&pState->Mtx);
    17271758                if (pUrb->pMsg)
     
    17961827    {
    17971828        vboxusb_urb_t *pUrb = list_remove_head(&pState->hLandedUrbs);
     1829
     1830        /*
     1831         * It is safe to access pUrb->pMsg outside the state mutex because this is from the landed URB list
     1832         * and not the inflight URB list.
     1833         */
    17981834        mutex_exit(&pState->Mtx);
    17991835        if (pUrb)
     
    18561892                    }
    18571893
    1858                     Log((DEVICE_NAME ":vboxUSBSolarisReapUrb pvUrbR3=%p pvDataR3=%p cbData=%d\n", pUrbReq->pvUrbR3, pUrbReq->pvData, pUrbReq->cbData));
     1894                    Log((DEVICE_NAME ":vboxUSBSolarisReapUrb pvUrbR3=%p pvDataR3=%p cbData=%d\n", pUrbReq->pvUrbR3,
     1895                         pUrbReq->pvData, pUrbReq->cbData));
    18591896                }
    18601897                else
     
    19932030            else
    19942031            {
    1995                 Log((DEVICE_NAME ":vboxUSBSolarisClearEndPoint not opened to be cleared. Faking success. bEndpoint=%#x.\n", bEndpoint));
     2032                Log((DEVICE_NAME ":vboxUSBSolarisClearEndPoint not opened to be cleared. Faking success. bEndpoint=%#x.\n",
     2033                     bEndpoint));
    19962034                rc = VINF_SUCCESS;
    19972035            }
     
    19992037        else
    20002038        {
    2001             LogRel((DEVICE_NAME ":vboxUSBSolarisClearEndPoint Endpoint missing!! bEndpoint=%#x EndPtIndex=%d.\n", bEndpoint, EndPtIndex));
     2039            LogRel((DEVICE_NAME ":vboxUSBSolarisClearEndPoint Endpoint missing!! bEndpoint=%#x EndPtIndex=%d.\n", bEndpoint,
     2040                    EndPtIndex));
    20022041            rc = VERR_GENERAL_FAILURE;
    20032042        }
     
    23902429            if (RT_FAILURE(rc))
    23912430            {
    2392                 LogRel((DEVICE_NAME ":vboxUSBSolarisInitAllEndPoints: vboxUSBSolarisInitEndPoints uCfgIndex=%d failed. rc=%d\n", uCfgIndex, rc));
     2431                LogRel((DEVICE_NAME ":vboxUSBSolarisInitAllEndPoints: vboxUSBSolarisInitEndPoints uCfgIndex=%d failed. rc=%d\n",
     2432                        uCfgIndex, rc));
    23932433                return rc;
    23942434            }
     
    24312471                if (RT_FAILURE(rc))
    24322472                {
    2433                     LogRel((DEVICE_NAME ":vboxUSBSolarisInitEndPointsForConfig: vboxUSBSolarisInitEndPoint failed! pEp=%p uCfgValue=%u uCfgIndex=%u uInterface=%u, uAlt=%u\n",
    2434                                 uCfgValue, uCfgIndex, uInterface, uAlt));
     2473                    LogRel((DEVICE_NAME ":vboxUSBSolarisInitEndPointsForConfig: vboxUSBSolarisInitEndPoint failed! pEp=%p "
     2474                            "uCfgValue=%u uCfgIndex=%u uInterface=%u, uAlt=%u\n", uCfgValue, uCfgIndex, uInterface, uAlt));
    24352475                    return rc;
    24362476                }
     
    24532493LOCAL int vboxUSBSolarisInitEndPointsForInterfaceAlt(vboxusb_state_t *pState, uint8_t uInterface, uint8_t uAlt)
    24542494{
    2455     LogFunc((DEVICE_NAME ":vboxUSBSolarisInitEndPointsForInterfaceAlt pState=%p uInterface=%d uAlt=%d\n", pState, uInterface, uAlt));
     2495    LogFunc((DEVICE_NAME ":vboxUSBSolarisInitEndPointsForInterfaceAlt pState=%p uInterface=%d uAlt=%d\n", pState, uInterface,
     2496             uAlt));
    24562497
    24572498    /* Doesn't hurt to be paranoid */
     
    24792520                if (RT_FAILURE(rc))
    24802521                {
    2481                     LogRel((DEVICE_NAME ":vboxUSBSolarisInitEndPointsForInterfaceAlt: vboxUSBSolarisInitEndPoint failed! pEp=%p uCfgValue=%u uCfgIndex=%u uInterface=%u, uAlt=%u\n",
    2482                                 uCfgValue, uCfgIndex, uInterface, uAlt));
     2522                    LogRel((DEVICE_NAME ":vboxUSBSolarisInitEndPointsForInterfaceAlt: vboxUSBSolarisInitEndPoint failed! pEp=%p "
     2523                            "uCfgValue=%u uCfgIndex=%u uInterface=%u, uAlt=%u\n", uCfgValue, uCfgIndex, uInterface, uAlt));
    24832524                    return rc;
    24842525                }
     
    25062547 *
    25072548 * @param   pState          The USB device instance.
    2508  * @remarks Requires the state mutex to be held!!
     2549 * @remarks Requires the state mutex to be held.
    25092550 *          Call only from Detach() or similar as callbacks
    25102551 */
     
    25122553{
    25132554    LogFunc((DEVICE_NAME ":vboxUSBSolarisDestroyAllEndPoints pState=%p\n", pState));
     2555
     2556    Assert(mutex_owned(&pState->Mtx));
    25142557    for (unsigned i = 0; i < VBOXUSB_MAX_ENDPOINTS; i++)
    25152558    {
     
    25292572 * @param   pState          The USB device instance.
    25302573 * @param   pEp             The Endpoint.
     2574 * @remarks Requires the state mutex to be held.
    25312575 */
    25322576LOCAL void vboxUSBSolarisDestroyEndPoint(vboxusb_state_t *pState, vboxusb_ep_t *pEp)
     
    25342578    LogFunc((DEVICE_NAME ":vboxUSBSolarisDestroyEndPoint pState=%p pEp=%p\n", pState, pEp));
    25352579
     2580    Assert(mutex_owned(&pState->Mtx));
    25362581    if (pEp->fInitialized == VBOXUSB_EP_INITIALIZED)
    25372582    {
     
    26022647 * @param   pState          The USB device instance.
    26032648 * @param   pEp             The Endpoint.
     2649 * @remarks Requires the device state mutex to be held.
    26042650 *
    26052651 * @returns VBox status code.
     
    26082654{
    26092655//    LogFunc((DEVICE_NAME ":vboxUSBSolarisOpenPipe pState=%p pEp=%p\n", pState, pEp));
     2656
     2657    Assert(mutex_owned(&pState->Mtx));
    26102658
    26112659    /*
     
    26292677     * Open the non-default pipe for the Endpoint.
    26302678     */
     2679    mutex_exit(&pState->Mtx);
    26312680    int rc = usb_pipe_open(pState->pDip, &pEp->EpDesc, &pEp->PipePolicy, USB_FLAGS_NOSLEEP, &pEp->pPipe);
     2681    mutex_enter(&pState->Mtx);
    26322682    if (rc == USB_SUCCESS)
    26332683    {
     
    27152765             * Non-default pipe: close it.
    27162766             */
    2717             Log((DEVICE_NAME ":vboxUSBSolarisClosePipe pipe bmAttributes=%#x bEndpointAddress=%#x\n", pEp->EpDesc.bmAttributes, pEp->EpDesc.bEndpointAddress));
     2767            Log((DEVICE_NAME ":vboxUSBSolarisClosePipe pipe bmAttributes=%#x bEndpointAddress=%#x\n", pEp->EpDesc.bmAttributes,
     2768                 pEp->EpDesc.bEndpointAddress));
    27182769            mutex_exit(&pState->Mtx);
    27192770            usb_pipe_close(pState->pDip, pEp->pPipe, USB_FLAGS_SLEEP, NULL /* callback */, NULL /* callback arg. */);
     
    28062857 * @param   pMsg            Pointer to the allocated request data.
    28072858 *
    2808  * @returns The allocated URB to be used.
     2859 * @returns The allocated URB to be used, or NULL upon failure.
    28092860 */
    28102861LOCAL vboxusb_urb_t *vboxUSBSolarisQueueURB(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq, mblk_t *pMsg)
     
    28362887            && pUrb->enmState != VBOXUSB_URB_STATE_FREE))
    28372888    {
     2889        mutex_exit(&pState->Mtx);
    28382890        pUrb = RTMemAllocZ(sizeof(vboxusb_urb_t));
    28392891        if (RT_UNLIKELY(!pUrb))
    28402892        {
    2841             mutex_exit(&pState->Mtx);
    28422893            LogRel((DEVICE_NAME ":vboxUSBSolarisQueueURB failed to alloc %d bytes.\n", sizeof(vboxusb_urb_t)));
    28432894            return NULL;
    28442895        }
     2896        mutex_enter(&pState->Mtx);
    28452897    }
    28462898    else
     
    28502902         * up each one free 'head'.
    28512903         */
     2904        Assert(pUrb && pUrb->enmState == VBOXUSB_URB_STATE_FREE);
    28522905        list_remove_head(&pState->hUrbs);
    28532906    }
     
    29553008 *
    29563009 * @param   pState          The USB device instance.
    2957  * @remarks Requires the device state mutex to be held!!
     3010 * @remarks Requires the device state mutex to be held.
    29583011 */
    29593012LOCAL inline void vboxUSBSolarisNotifyComplete(vboxusb_state_t *pState)
     
    30013054LOCAL int vboxUSBSolarisCtrlXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb)
    30023055{
    3003     LogFunc((DEVICE_NAME ":vboxUSBSolarisCtrlXfer pState=%p pEp=%p pUrb=%p enmDir=%d cbData=%d\n", pState, pEp, pUrb, pUrb->enmDir, pUrb->cbDataR3));
     3056    LogFunc((DEVICE_NAME ":vboxUSBSolarisCtrlXfer pState=%p pEp=%p pUrb=%p enmDir=%d cbData=%d\n", pState, pEp, pUrb,
     3057             pUrb->enmDir, pUrb->cbDataR3));
    30043058
    30053059    AssertPtrReturn(pUrb->pMsg, VERR_INVALID_PARAMETER);
     
    31063160            pSetupMsg->b_wptr += sizeof(VUSBSETUP);
    31073161
     3162            /*
     3163             * Should be safe to update pMsg here without the state mutex, see vboxUSBSolarisSendURB()
     3164             * and vboxUSBSolarisQueueUURB() as the URB state is (still) not VBOXUSB_URB_STATE_FREE.
     3165             */
    31083166            pUrb->pMsg = pSetupMsg;
    31093167            pUrb->pMsg->b_cont = pReq->ctrl_data;
     
    31153173                && pUrb->pMsg->b_cont == NULL)  /* Concat succeeded */
    31163174            {
    3117                 Log((DEVICE_NAME ":vboxUSBSolarisCtrlXferCompleted prepended header rc=%d cbData=%d.\n", pReq->ctrl_completion_reason,
    3118                        MBLKL(pUrb->pMsg)));
     3175                Log((DEVICE_NAME ":vboxUSBSolarisCtrlXferCompleted prepended header rc=%d cbData=%d.\n",
     3176                     pReq->ctrl_completion_reason, MBLKL(pUrb->pMsg)));
    31193177                Log((DEVICE_NAME ":%.*Rhxd\n", MBLKL(pUrb->pMsg), pUrb->pMsg->b_rptr));
    31203178            }
     
    31293187        }
    31303188        else
    3131             LogRel((DEVICE_NAME ":vboxUSBSolarisCtrlXferCompleted failed to alloc %d bytes for Setup Header.\n", sizeof(VUSBSETUP)));
     3189        {
     3190            LogRel((DEVICE_NAME ":vboxUSBSolarisCtrlXferCompleted failed to alloc %d bytes for Setup Header.\n",
     3191                    sizeof(VUSBSETUP)));
     3192        }
    31323193    }
    31333194    else
     
    31503211LOCAL int vboxUSBSolarisBulkXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb)
    31513212{
    3152     LogFunc((DEVICE_NAME ":vboxUSBSolarisBulkXfer pState=%p pEp=%p pUrb=%p enmDir=%d cbData=%d\n", pState, pEp, pUrb, pUrb->enmDir, pUrb->cbDataR3));
     3213    LogFunc((DEVICE_NAME ":vboxUSBSolarisBulkXfer pState=%p pEp=%p pUrb=%p enmDir=%d cbData=%d\n", pState, pEp, pUrb,
     3214             pUrb->enmDir, pUrb->cbDataR3));
    31533215
    31543216    /*
     
    31563218     */
    31573219    int rc = VINF_SUCCESS;
    3158     usb_bulk_req_t *pReq = usb_alloc_bulk_req(pState->pDip, pUrb->enmDir == VUSBDIRECTION_IN ? pUrb->cbDataR3 : 0, USB_FLAGS_NOSLEEP);
     3220    usb_bulk_req_t *pReq = usb_alloc_bulk_req(pState->pDip, pUrb->enmDir == VUSBDIRECTION_IN ? pUrb->cbDataR3 : 0,
     3221                                              USB_FLAGS_NOSLEEP);
    31593222    if (RT_LIKELY(pReq))
    31603223    {
     
    31883251        else
    31893252        {
    3190             LogRel((DEVICE_NAME ":vboxUSBSolarisBulkXfer usb_pipe_bulk_xfer enmDir=%#x Ep=%#x failed! rc=%d\n", pUrb->enmDir, pUrb->bEndpoint, rc));
     3253            LogRel((DEVICE_NAME ":vboxUSBSolarisBulkXfer usb_pipe_bulk_xfer enmDir=%#x Ep=%#x failed! rc=%d\n", pUrb->enmDir,
     3254                    pUrb->bEndpoint, rc));
    31913255            rc = VERR_PIPE_IO_ERROR;
    31923256        }
     
    32683332LOCAL int vboxUSBSolarisIntrXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb)
    32693333{
    3270     LogFunc((DEVICE_NAME ":vboxUSBSolarisIntrXfer pState=%p pEp=%p pUrb=%p enmDir=%d cbData=%d\n", pState, pEp, pUrb, pUrb->enmDir, pUrb->cbDataR3));
     3334    LogFunc((DEVICE_NAME ":vboxUSBSolarisIntrXfer pState=%p pEp=%p pUrb=%p enmDir=%d cbData=%d\n", pState, pEp, pUrb,
     3335             pUrb->enmDir, pUrb->cbDataR3));
    32713336
    32723337    int rc = VINF_SUCCESS;
     
    33473412            }
    33483413
    3349             Log((DEVICE_NAME ":vboxUSBSolarisIntrXferCompleted rc=%d pMsg=%p enmDir=%#x\n", pReq->intr_completion_reason, pUrb->pMsg,
    3350                    pUrb->enmDir));
     3414            Log((DEVICE_NAME ":vboxUSBSolarisIntrXferCompleted rc=%d pMsg=%p enmDir=%#x\n", pReq->intr_completion_reason,
     3415                 pUrb->pMsg, pUrb->enmDir));
    33513416
    33523417            /*
     
    35333598            if (RT_LIKELY(pReq->isoc_data))
    35343599            {
    3535                 Log((DEVICE_NAME ":vboxUSBSolarisIsocInXferCompleted cIsocInUrbs=%d cbIsocInLandedReqs=%d\n", pEp->cIsocInUrbs, pEp->cbIsocInLandedReqs));
     3600                Log((DEVICE_NAME ":vboxUSBSolarisIsocInXferCompleted cIsocInUrbs=%d cbIsocInLandedReqs=%d\n", pEp->cIsocInUrbs,
     3601                     pEp->cbIsocInLandedReqs));
    35363602
    35373603                mutex_enter(&pState->Mtx);
     
    35483614                        --pEp->cIsocInUrbs;
    35493615                        mutex_exit(&pState->Mtx);
    3550 #if 0
     3616
    35513617                        for (unsigned i = 0; i < pReq->isoc_pkts_count; i++)
    35523618                        {
     
    35543620                            pUrb->aIsocPkts[i].enmStatus = vboxUSBSolarisGetUrbStatus(pReq->isoc_pkt_descr[i].isoc_pkt_status);
    35553621                        }
    3556 #else
    3557                         bcopy(pReq->isoc_pkt_descr, pUrb->aIsocPkts, sizeof(VUSBISOC_PKT_DESC) * pReq->isoc_pkts_count);
    3558 #endif
     3622
    35593623                        pUrb->pMsg = pReq->isoc_data;
    35603624                        pReq->isoc_data = NULL;
     
    35693633                    else
    35703634                    {
    3571                         /* Huh!? cIsocInUrbs is wrong then! Should never happen unless we decide to decrement cIsocInUrbs in Reap time */
     3635                        /* Huh!? cIsocInUrbs is wrong then! Should never happen unless we decide to decrement cIsocInUrbs in
     3636                           Reap time */
    35723637                        pEp->cIsocInUrbs = 0;
    35733638                        LogRel((DEVICE_NAME ":vboxUSBSolarisIsocInXferCompleted Extreme error! Isoc. counter b0rked!\n"));
     
    37253790            mutex_exit(&pState->Mtx);
    37263791            usb_pipe_isoc_xfer(pPipe, pReq, USB_FLAGS_NOSLEEP);
    3727             Log((DEVICE_NAME ":vboxUSBSolarisIsocInXferError resubmitted Isoc. IN request due to immediately unavailable resources.\n"));
     3792            Log((DEVICE_NAME ":vboxUSBSolarisIsocInXferError resubmitted Isoc. IN request due to immediately unavailable "
     3793                 "resources.\n"));
    37283794
    37293795            return;
     
    37413807        default:
    37423808        {
    3743             Log((DEVICE_NAME ":vboxUSBSolarisIsocInXferError stopping Isoc. In. polling due to rc=%d\n", pReq->isoc_completion_reason));
     3809            Log((DEVICE_NAME ":vboxUSBSolarisIsocInXferError stopping Isoc. In. polling due to rc=%d\n",
     3810                 pReq->isoc_completion_reason));
    37443811            pEp->fIsocPolling = false;
    37453812            mutex_exit(&pState->Mtx);
     
    37933860            }
    37943861
    3795             Log((DEVICE_NAME ":vboxUSBSolarisIsocOutXferCompleted cIsocPkts=%d cbData=%d cbActPkt=%d\n", pUrb->cIsocPkts, pUrb->cbDataR3, cbActPkt));
     3862            Log((DEVICE_NAME ":vboxUSBSolarisIsocOutXferCompleted cIsocPkts=%d cbData=%d cbActPkt=%d\n", pUrb->cIsocPkts,
     3863                 pUrb->cbDataR3, cbActPkt));
    37963864
    37973865            if (pReq->isoc_completion_reason == USB_CR_OK)
Note: See TracChangeset for help on using the changeset viewer.

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