VirtualBox

Changeset 50234 in vbox for trunk/src/VBox/Devices/USB/win


Ignore:
Timestamp:
Jan 24, 2014 10:48:13 PM (11 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
91835
Message:

USB/Proxy: More code cleanup and finish a few todos, also some new ones so it doesn't get boring

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Devices/USB/win/USBProxyDevice-win.cpp

    r50233 r50234  
    8383*******************************************************************************/
    8484static int usbProxyWinSetInterface(PUSBPROXYDEV p, int ifnum, int setting);
    85 static DECLCALLBACK(int) usbProxyWinAsyncIoThread(RTTHREAD ThreadSelf, void *lpParameter);
     85
     86/**
     87 * Converts the given Windows error code to VBox handling unplugged devices.
     88 *
     89 * @returns VBox status code.
     90 * @param   pProxDev    The USB proxy device instance.
     91 * @param   dwErr       Windows error code.
     92 */
     93static int usbProxyWinHandleUnpluggedDevice(PUSBPROXYDEV pProxyDev, DWORD dwErr)
     94{
     95    PPRIV_USBW32 pPriv = USBPROXYDEV_2_DATA(pProxyDev, PPRIV_USBW32);
     96
     97    if (   dwErr == ERROR_INVALID_HANDLE_STATE
     98        || dwErr == ERROR_BAD_COMMAND)
     99    {
     100        Log(("usbproxy: device %x unplugged!!\n", pPriv->hDev));
     101        pProxyDev->fDetached = true;
     102    }
     103    else
     104        AssertMsgFailed(("lasterr=%d\n", dwErr));
     105    return RTErrConvertFromWin32(dwErr);
     106}
    86107
    87108/**
     
    279300    cbReturned = 0;
    280301    if (DeviceIoControl(pPriv->hDev, SUPUSB_IOCTL_USB_SET_CONFIG, &in, sizeof(in), NULL, 0, &cbReturned, NULL))
    281         return 1;
    282 
    283     if (   GetLastError() == ERROR_INVALID_HANDLE_STATE
    284         || GetLastError() == ERROR_BAD_COMMAND)
    285     {
    286         Log(("usbproxy: device %p unplugged!!\n", pPriv->hDev));
    287         pProxyDev->fDetached = true;
    288     }
    289     else
    290         AssertMsgFailed(("lasterr=%u\n", GetLastError()));
    291 
    292     return 0;
     302        return VINF_SUCCESS;
     303
     304    return usbProxyWinHandleUnpluggedDevice(pProxyDev, GetLastError());
    293305}
    294306
     
    305317
    306318    Assert(pPriv);
    307     return true;
     319    return VINF_SUCCESS;
    308320}
    309321
     
    314326
    315327    Assert(pPriv);
    316     return true;
     328    return VINF_SUCCESS;
    317329}
    318330
     
    336348    cbReturned = 0;
    337349    if (DeviceIoControl(pPriv->hDev, SUPUSB_IOCTL_USB_SELECT_INTERFACE, &in, sizeof(in), NULL, 0, &cbReturned, NULL))
    338         return true;
    339 
    340     if (    GetLastError() == ERROR_INVALID_HANDLE_STATE
    341         ||  GetLastError() == ERROR_BAD_COMMAND)
    342     {
    343         Log(("usbproxy: device %x unplugged!!\n", pPriv->hDev));
    344         pProxyDev->fDetached = true;
    345     }
    346     else
    347         AssertMsgFailed(("lasterr=%d\n", GetLastError()));
    348     return 0;
     350        return VINF_SUCCESS;
     351
     352    return usbProxyWinHandleUnpluggedDevice(pProxyDev, GetLastError());
    349353}
    350354
     
    352356 * Clears the halted endpoint 'ep'.
    353357 */
    354 static DECLCALLBACK(bool) usbProxyWinClearHaltedEndPt(PUSBPROXYDEV pProxyDev, unsigned int ep)
     358static DECLCALLBACK(int) usbProxyWinClearHaltedEndPt(PUSBPROXYDEV pProxyDev, unsigned int ep)
    355359{
    356360    PPRIV_USBW32 pPriv = USBPROXYDEV_2_DATA(pProxyDev, PPRIV_USBW32);
     
    365369    cbReturned = 0;
    366370    if (DeviceIoControl(pPriv->hDev, SUPUSB_IOCTL_USB_CLEAR_ENDPOINT, &in, sizeof(in), NULL, 0, &cbReturned, NULL))
    367         return true;
    368 
    369     if (    GetLastError() == ERROR_INVALID_HANDLE_STATE
    370         ||  GetLastError() == ERROR_BAD_COMMAND)
    371     {
    372         Log(("usbproxy: device %x unplugged!!\n", pPriv->hDev));
    373         pProxyDev->fDetached = true;
    374     }
    375     else
    376         AssertMsgFailed(("lasterr=%d\n", GetLastError()));
    377     return 0;
     371        return VINF_SUCCESS;
     372
     373    return usbProxyWinHandleUnpluggedDevice(pProxyDev, GetLastError());
    378374}
    379375
     
    397393        return VINF_SUCCESS;
    398394
    399     rc = GetLastError();
    400     if (    rc == ERROR_INVALID_HANDLE_STATE
    401         ||  rc == ERROR_BAD_COMMAND)
    402     {
    403         Log(("usbproxy: device %x unplugged!!\n", pPriv->hDev));
    404         pProxyDev->fDetached = true;
    405     }
    406     else
    407         AssertMsgFailed(("lasterr=%d\n", rc));
    408     return RTErrConvertFromWin32(rc);
     395    return usbProxyWinHandleUnpluggedDevice(pProxyDev, GetLastError());
    409396}
    410397
     
    412399 * @copydoc USBPROXYBACK::pfnUrbQueue
    413400 */
    414 static DECLCALLBACK(int) usbProxyWinUrbQueue(PVUSBURB pUrb)
    415 {
    416     PUSBPROXYDEV    pProxyDev = PDMINS_2_DATA(pUrb->pUsbIns, PUSBPROXYDEV);
     401static DECLCALLBACK(int) usbProxyWinUrbQueue(PUSBPROXYDEV pProxyDev, PVUSBURB pUrb)
     402{
    417403    PPRIV_USBW32 pPriv = USBPROXYDEV_2_DATA(pProxyDev, PPRIV_USBW32);
    418404    Assert(pPriv);
     
    424410    PQUEUED_URB pQUrbWin = (PQUEUED_URB)RTMemAllocZ(sizeof(QUEUED_URB));
    425411    if (!pQUrbWin)
    426         return false;
     412        return VERR_NO_MEMORY;
    427413
    428414    switch (pUrb->enmType)
     
    443429        default:
    444430            AssertMsgFailed(("Invalid type %d\n", pUrb->enmType));
    445             return false;
     431            return VERR_INVALID_PARAMETER;
    446432    }
    447433
     
    460446        default:
    461447            AssertMsgFailed(("Invalid direction %d\n", pUrb->enmDir));
    462             return false;
     448            return VERR_INVALID_PARAMETER;
    463449    }
    464450
     
    474460        pQUrbWin->urbwin.flags = USBSUP_FLAG_SHORT_OK;
    475461
     462    int rc = VINF_SUCCESS;
    476463    pQUrbWin->overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
    477464    if (pQUrbWin->overlapped.hEvent != INVALID_HANDLE_VALUE)
     
    492479            RTCritSectLeave(&pPriv->CritSect);
    493480            SetEvent(pPriv->hEventWakeup);
    494             return true;
     481            return VINF_SUCCESS;
    495482        }
    496483        else
     
    500487                || dwErr == ERROR_BAD_COMMAND)
    501488            {
    502                 PUSBPROXYDEV pProxyDev = PDMINS_2_DATA(pQUrbWin->urb->pUsbIns, PUSBPROXYDEV);
    503489                Log(("usbproxy: device %p unplugged!!\n", pPriv->hDev));
    504490                pProxyDev->fDetached = true;
     
    506492            else
    507493                AssertMsgFailed(("dwErr=%X urbwin.error=%d (submit urb)\n", dwErr, pQUrbWin->urbwin.error));
     494            rc = RTErrConvertFromWin32(dwErr);
    508495            CloseHandle(pQUrbWin->overlapped.hEvent);
    509496            pQUrbWin->overlapped.hEvent = INVALID_HANDLE_VALUE;
     
    514501    {
    515502        AssertMsgFailed(("FAILED!!, hEvent(0x%p)\n", pQUrbWin->overlapped.hEvent));
     503        rc = VERR_NO_MEMORY;
    516504    }
    517505#endif
     
    519507    Assert(pQUrbWin->overlapped.hEvent == INVALID_HANDLE_VALUE);
    520508    RTMemFree(pQUrbWin);
    521     return false;
     509    return rc;
    522510}
    523511
     
    587575        RTCritSectEnter(&pPriv->CritSect);
    588576
    589         /* Ensure we've got sufficient space in the arrays.
    590          * Do it inside the lock to ensure we do not concur
    591          * with the usbProxyWinAsyncIoThread */
     577        /* Ensure we've got sufficient space in the arrays. */
    592578        if (pPriv->cQueuedUrbs + pPriv->cPendingUrbs + 1 > pPriv->cAllocatedUrbs)
    593579        {
     
    719705 *          exactly what the guest wants to do.
    720706 */
    721 static DECLCALLBACK(void) usbProxyWinUrbCancel(PVUSBURB pUrb)
    722 {
    723     PUSBPROXYDEV      pProxyDev = PDMINS_2_DATA(pUrb->pUsbIns, PUSBPROXYDEV);
     707static DECLCALLBACK(int) usbProxyWinUrbCancel(PUSBPROXYDEV pProxyDev, PVUSBURB pUrb)
     708{
    724709    PPRIV_USBW32      pPriv = USBPROXYDEV_2_DATA(pProxyDev, PPRIV_USBW32);
    725710    PQUEUED_URB       pQUrbWin  = (PQUEUED_URB)pUrb->Dev.pvPrivate;
    726     int                     rc;
    727711    USBSUP_CLEAR_ENDPOINT   in;
    728712    DWORD                   cbReturned;
    729     Assert(pQUrbWin);
     713
     714    AssertPtrReturn(pQUrbWin, VERR_INVALID_PARAMETER);
    730715
    731716    in.bEndpoint = pUrb->EndPt | (pUrb->enmDir == VUSBDIRECTION_IN ? 0x80 : 0);
     
    734719    cbReturned = 0;
    735720    if (DeviceIoControl(pPriv->hDev, SUPUSB_IOCTL_USB_ABORT_ENDPOINT, &in, sizeof(in), NULL, 0, &cbReturned, NULL))
    736         return;
    737 
    738     rc = GetLastError();
    739     if (    rc == ERROR_INVALID_HANDLE_STATE
    740         ||  rc == ERROR_BAD_COMMAND)
     721        return VINF_SUCCESS;
     722
     723    DWORD dwErr = GetLastError();
     724    if (    dwErr == ERROR_INVALID_HANDLE_STATE
     725        ||  dwErr == ERROR_BAD_COMMAND)
    741726    {
    742727        Log(("usbproxy: device %x unplugged!!\n", pPriv->hDev));
    743728        pProxyDev->fDetached = true;
     729        return VINF_SUCCESS; /* Fake success and deal with the unplugged device elsewhere. */
    744730    }
    745731    else
Note: See TracChangeset for help on using the changeset viewer.

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