VirtualBox

Ignore:
Timestamp:
Jan 24, 2023 3:32:43 PM (2 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
155493
Message:

Main/src-server: rc -> hrc/vrc (partial). bugref:10223

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Main/src-server/generic/USBProxyBackendUsbIp.cpp

    r98103 r98288  
    297297                               const com::Utf8Str &strAddress, bool fLoadingSettings)
    298298{
    299     int rc = VINF_SUCCESS;
     299    int vrc = VINF_SUCCESS;
    300300
    301301    USBProxyBackend::init(pUsbProxyService, strId, strAddress, fLoadingSettings);
     
    322322
    323323    /* Setup wakeup pipe and poll set first. */
    324     rc = RTSemFastMutexCreate(&m->hMtxDevices);
    325     if (RT_SUCCESS(rc))
    326     {
    327         rc = RTPipeCreate(&m->hWakeupPipeR, &m->hWakeupPipeW, 0);
    328         if (RT_SUCCESS(rc))
    329         {
    330             rc = RTPollSetCreate(&m->hPollSet);
    331             if (RT_SUCCESS(rc))
     324    vrc = RTSemFastMutexCreate(&m->hMtxDevices);
     325    if (RT_SUCCESS(vrc))
     326    {
     327        vrc = RTPipeCreate(&m->hWakeupPipeR, &m->hWakeupPipeW, 0);
     328        if (RT_SUCCESS(vrc))
     329        {
     330            vrc = RTPollSetCreate(&m->hPollSet);
     331            if (RT_SUCCESS(vrc))
    332332            {
    333                 rc = RTPollSetAddPipe(m->hPollSet, m->hWakeupPipeR,
    334                                       RTPOLL_EVT_READ, USBIP_POLL_ID_PIPE);
    335                 if (RT_SUCCESS(rc))
     333                vrc = RTPollSetAddPipe(m->hPollSet, m->hWakeupPipeR, RTPOLL_EVT_READ, USBIP_POLL_ID_PIPE);
     334                if (RT_SUCCESS(vrc))
    336335                {
    337336                    /*
     
    344343                     * reachable.
    345344                     */
    346                     rc = reconnect();
    347                     if (RT_SUCCESS(rc) || fLoadingSettings)
    348                         rc = start(); /* Start service thread. */
     345                    vrc = reconnect();
     346                    if (RT_SUCCESS(vrc) || fLoadingSettings)
     347                        vrc = start(); /* Start service thread. */
    349348                }
    350349
    351                 if (RT_FAILURE(rc))
     350                if (RT_FAILURE(vrc))
    352351                {
    353352                    RTPollSetRemove(m->hPollSet, USBIP_POLL_ID_PIPE);
     
    358357            }
    359358
    360             if (RT_FAILURE(rc))
     359            if (RT_FAILURE(vrc))
    361360            {
    362361                int rc2 = RTPipeClose(m->hWakeupPipeR);
     
    367366            }
    368367        }
    369         if (RT_FAILURE(rc))
     368        if (RT_FAILURE(vrc))
    370369        {
    371370            RTSemFastMutexDestroy(m->hMtxDevices);
     
    374373    }
    375374
    376     return rc;
     375    return vrc;
    377376}
    378377
     
    397396        disconnect();
    398397
    399         int rc = RTPollSetRemove(m->hPollSet, USBIP_POLL_ID_PIPE);
    400         AssertRC(rc);
    401         rc = RTPollSetDestroy(m->hPollSet);
    402         AssertRC(rc);
    403         rc = RTPipeClose(m->hWakeupPipeR);
    404         AssertRC(rc);
    405         rc = RTPipeClose(m->hWakeupPipeW);
    406         AssertRC(rc);
     398        int vrc = RTPollSetRemove(m->hPollSet, USBIP_POLL_ID_PIPE);
     399        AssertRC(vrc);
     400        vrc = RTPollSetDestroy(m->hPollSet);
     401        AssertRC(vrc);
     402        vrc = RTPipeClose(m->hWakeupPipeR);
     403        AssertRC(vrc);
     404        vrc = RTPipeClose(m->hWakeupPipeW);
     405        AssertRC(vrc);
    407406
    408407        m->hPollSet = NIL_RTPOLLSET;
     
    468467int USBProxyBackendUsbIp::wait(RTMSINTERVAL aMillies)
    469468{
    470     int rc = VINF_SUCCESS;
     469    int vrc = VINF_SUCCESS;
    471470    bool fDeviceListChangedOrWokenUp = false;
    472471
     
    483482        && m->enmRecvState == kUsbIpRecvState_None)
    484483    {
    485         rc = startListExportedDevicesReq();
    486         if (RT_FAILURE(rc))
     484        vrc = startListExportedDevicesReq();
     485        if (RT_FAILURE(vrc))
    487486            disconnect();
    488487    }
     
    496495    while (   !fDeviceListChangedOrWokenUp
    497496           && (aMillies == RT_INDEFINITE_WAIT || aMillies > 0)
    498            && RT_SUCCESS(rc))
     497           && RT_SUCCESS(vrc))
    499498    {
    500499        RTMSINTERVAL msWait = aMillies;
     
    507506            msWait = RT_MIN(3000, aMillies);
    508507
    509         rc = RTPoll(m->hPollSet, msWait, &fEventsRecv, &uIdReady);
    510         if (RT_SUCCESS(rc))
     508        vrc = RTPoll(m->hPollSet, msWait, &fEventsRecv, &uIdReady);
     509        if (RT_SUCCESS(vrc))
    511510        {
    512511            if (uIdReady == USBIP_POLL_ID_PIPE)
     
    516515                size_t cbRead = 0;
    517516
    518                 rc = RTPipeRead(m->hWakeupPipeR, &bRead, 1, &cbRead);
    519                 Assert(RT_SUCCESS(rc) && cbRead == 1);
     517                vrc = RTPipeRead(m->hWakeupPipeR, &bRead, 1, &cbRead);
     518                Assert(RT_SUCCESS(vrc) && cbRead == 1);
    520519                fDeviceListChangedOrWokenUp = true;
    521520            }
     
    523522            {
    524523                if (fEventsRecv & RTPOLL_EVT_READ)
    525                     rc = receiveData();
    526                 if (   RT_SUCCESS(rc)
     524                    vrc = receiveData();
     525                if (   RT_SUCCESS(vrc)
    527526                    && (fEventsRecv & RTPOLL_EVT_ERROR))
    528                     rc = VERR_NET_SHUTDOWN;
     527                    vrc = VERR_NET_SHUTDOWN;
    529528
    530529                /*
     
    549548
    550549                /* Current USB/IP server closes the connection after each request, don't abort but try again. */
    551                 if (rc == VERR_NET_SHUTDOWN || rc == VERR_BROKEN_PIPE || rc == VERR_NET_CONNECTION_RESET_BY_PEER)
     550                if (vrc == VERR_NET_SHUTDOWN || vrc == VERR_BROKEN_PIPE || vrc == VERR_NET_CONNECTION_RESET_BY_PEER)
    552551                {
    553552                    Log(("USB/IP: Lost connection to host \"%s\", trying to reconnect...\n", m->pszHost));
    554553                    disconnect();
    555                     rc = VINF_SUCCESS;
     554                    vrc = VINF_SUCCESS;
    556555                }
    557556            }
     
    559558            {
    560559                AssertMsgFailed(("Invalid poll ID returned\n"));
    561                 rc = VERR_INVALID_STATE;
     560                vrc = VERR_INVALID_STATE;
    562561            }
    563562            aMillies -= (RTMSINTERVAL)(RTTimeMilliTS() - msPollStart);
    564563        }
    565         else if (rc == VERR_TIMEOUT)
     564        else if (vrc == VERR_TIMEOUT)
    566565        {
    567566            aMillies -= msWait;
     
    571570                if (m->hSocket == NIL_RTSOCKET)
    572571                {
    573                     rc = reconnect();
    574                     if (RT_SUCCESS(rc))
    575                         rc = startListExportedDevicesReq();
    576                     else if (   rc == VERR_NET_SHUTDOWN
    577                              || rc == VERR_BROKEN_PIPE
    578                              || rc == VERR_NET_CONNECTION_RESET_BY_PEER
    579                              || rc == VERR_NET_CONNECTION_REFUSED)
     572                    vrc = reconnect();
     573                    if (RT_SUCCESS(vrc))
     574                        vrc = startListExportedDevicesReq();
     575                    else if (   vrc == VERR_NET_SHUTDOWN
     576                             || vrc == VERR_BROKEN_PIPE
     577                             || vrc == VERR_NET_CONNECTION_RESET_BY_PEER
     578                             || vrc == VERR_NET_CONNECTION_REFUSED)
    580579                    {
    581580                        if (hasDevListChanged(m->pHead))
    582581                            fDeviceListChangedOrWokenUp = true;
    583                         rc = VINF_SUCCESS;
     582                        vrc = VINF_SUCCESS;
    584583                    }
    585584                }
     
    588587    }
    589588
    590     LogFlowFunc(("return rc=%Rrc\n", rc));
    591     return rc;
     589    LogFlowFunc(("return vrc=%Rrc\n", vrc));
     590    return vrc;
    592591}
    593592
     
    599598    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    600599
    601     int rc = RTPipeWriteBlocking(m->hWakeupPipeW, "", 1, NULL);
    602     if (RT_SUCCESS(rc))
     600    int vrc = RTPipeWriteBlocking(m->hWakeupPipeW, "", 1, NULL);
     601    if (RT_SUCCESS(vrc))
    603602        RTPipeFlush(m->hWakeupPipeW);
    604     LogFlowFunc(("returning %Rrc\n", rc));
    605     return rc;
     603    LogFlowFunc(("returning %Rrc\n", vrc));
     604    return vrc;
    606605}
    607606
     
    705704    if (m->hSocket != NIL_RTSOCKET)
    706705    {
    707         int rc = RTPollSetRemove(m->hPollSet, USBIP_POLL_ID_SOCKET);
    708         NOREF(rc);
    709         Assert(RT_SUCCESS(rc) || rc == VERR_POLL_HANDLE_ID_NOT_FOUND);
     706        int vrc = RTPollSetRemove(m->hPollSet, USBIP_POLL_ID_SOCKET);
     707        NOREF(vrc);
     708        Assert(RT_SUCCESS(vrc) || vrc == VERR_POLL_HANDLE_ID_NOT_FOUND);
    710709
    711710        RTTcpClientCloseEx(m->hSocket, false /*fGracefulShutdown*/);
     
    730729
    731730    /* Connect to the USB/IP host. */
    732     int rc = RTTcpClientConnect(m->pszHost, m->uPort, &m->hSocket);
    733     if (RT_SUCCESS(rc))
    734     {
    735         rc = RTTcpSetSendCoalescing(m->hSocket, false);
    736         if (RT_FAILURE(rc))
    737             LogRelMax(5, ("USB/IP: Disabling send coalescing failed (rc=%Rrc), continuing nevertheless but expect increased latency\n", rc));
    738 
    739         rc = RTPollSetAddSocket(m->hPollSet, m->hSocket, RTPOLL_EVT_READ | RTPOLL_EVT_ERROR,
    740                                 USBIP_POLL_ID_SOCKET);
    741         if (RT_FAILURE(rc))
     731    int vrc = RTTcpClientConnect(m->pszHost, m->uPort, &m->hSocket);
     732    if (RT_SUCCESS(vrc))
     733    {
     734        vrc = RTTcpSetSendCoalescing(m->hSocket, false);
     735        if (RT_FAILURE(vrc))
     736            LogRelMax(5, ("USB/IP: Disabling send coalescing failed (vrc=%Rrc), continuing nevertheless but expect increased latency\n", vrc));
     737
     738        vrc = RTPollSetAddSocket(m->hPollSet, m->hSocket, RTPOLL_EVT_READ | RTPOLL_EVT_ERROR, USBIP_POLL_ID_SOCKET);
     739        if (RT_FAILURE(vrc))
    742740        {
    743741            RTTcpClientCloseEx(m->hSocket, false /*fGracefulShutdown*/);
     
    763761    }
    764762
    765     LogFlowFunc(("returns rc=%Rrc\n", rc));
    766     return rc;
     763    LogFlowFunc(("returns vrc=%Rrc\n", vrc));
     764    return vrc;
    767765}
    768766
     
    774772int USBProxyBackendUsbIp::startListExportedDevicesReq()
    775773{
    776     int rc = VINF_SUCCESS;
     774    int vrc = VINF_SUCCESS;
    777775
    778776    LogFlowFunc(("\n"));
     
    784782    Assert(m->enmRecvState == kUsbIpRecvState_None);
    785783    if (m->enmRecvState != kUsbIpRecvState_None)
    786         rc = reconnect();
    787 
    788     if (RT_SUCCESS(rc))
     784        vrc = reconnect();
     785
     786    if (RT_SUCCESS(vrc))
    789787    {
    790788        /* Send of the request. */
     
    794792        ReqDevList.i32Status  = RT_H2N_S32(0);
    795793
    796         rc = RTTcpWrite(m->hSocket, &ReqDevList, sizeof(ReqDevList));
    797         if (RT_SUCCESS(rc))
     794        vrc = RTTcpWrite(m->hSocket, &ReqDevList, sizeof(ReqDevList));
     795        if (RT_SUCCESS(vrc))
    798796            advanceState(kUsbIpRecvState_Hdr);
    799797    }
    800798
    801     LogFlowFunc(("returns rc=%Rrc\n", rc));
    802     return rc;
     799    LogFlowFunc(("returns vrc=%Rrc\n", vrc));
     800    return vrc;
    803801}
    804802
     
    852850int USBProxyBackendUsbIp::receiveData()
    853851{
    854     int rc = VINF_SUCCESS;
     852    int vrc = VINF_SUCCESS;
    855853    size_t cbRecvd = 0;
    856854
     
    859857    do
    860858    {
    861         rc = RTTcpReadNB(m->hSocket, m->pbRecvBuf, m->cbResidualRecv, &cbRecvd);
    862 
    863         LogFlowFunc(("RTTcpReadNB(%#p, %#p, %zu, %zu) -> %Rrc\n",
    864                      m->hSocket, m->pbRecvBuf, m->cbResidualRecv, cbRecvd, rc));
    865 
    866         if (   rc == VINF_SUCCESS
     859        vrc = RTTcpReadNB(m->hSocket, m->pbRecvBuf, m->cbResidualRecv, &cbRecvd);
     860
     861        LogFlowFunc(("RTTcpReadNB(%#p, %#p, %zu, %zu) -> %Rrc\n", m->hSocket, m->pbRecvBuf, m->cbResidualRecv, cbRecvd, vrc));
     862
     863        if (   vrc == VINF_SUCCESS
    867864            && cbRecvd > 0)
    868865        {
     
    872869            if (!m->cbResidualRecv)
    873870            {
    874                 rc = processData();
    875                 if (   RT_SUCCESS(rc)
     871                vrc = processData();
     872                if (   RT_SUCCESS(vrc)
    876873                    && m->enmRecvState == kUsbIpRecvState_None)
    877874                    break;
    878875            }
    879876        }
    880         else if (rc == VINF_TRY_AGAIN)
     877        else if (vrc == VINF_TRY_AGAIN)
    881878            Assert(!cbRecvd);
    882879
    883     } while (rc == VINF_SUCCESS && cbRecvd > 0);
    884 
    885     if (rc == VINF_TRY_AGAIN)
    886         rc = VINF_SUCCESS;
    887 
    888     LogFlowFunc(("returns rc=%Rrc\n", rc));
    889     return rc;
     880    } while (vrc == VINF_SUCCESS && cbRecvd > 0);
     881
     882    if (vrc == VINF_TRY_AGAIN)
     883        vrc = VINF_SUCCESS;
     884
     885    LogFlowFunc(("returns vrc=%Rrc\n", vrc));
     886    return vrc;
    890887}
    891888
     
    897894int USBProxyBackendUsbIp::processData()
    898895{
    899     int rc = VINF_SUCCESS;
     896    int vrc = VINF_SUCCESS;
    900897
    901898    switch (m->enmRecvState)
     
    924921                advanceState(kUsbIpRecvState_None);
    925922                disconnect();
    926                 rc = VERR_NET_SHUTDOWN;
     923                vrc = VERR_NET_SHUTDOWN;
    927924            }
    928925            break;
     
    932929            /* Create a new device and add it to the list. */
    933930            usbProxyBackendUsbIpExportedDeviceN2H(&m->Scratch.ExportedDevice);
    934             rc = addDeviceToList(&m->Scratch.ExportedDevice);
    935             if (RT_SUCCESS(rc))
     931            vrc = addDeviceToList(&m->Scratch.ExportedDevice);
     932            if (RT_SUCCESS(vrc))
    936933            {
    937934                m->cInterfacesLeft = m->Scratch.ExportedDevice.bNumInterfaces;
     
    974971    }
    975972
    976     return rc;
     973    return vrc;
    977974}
    978975
     
    986983int USBProxyBackendUsbIp::addDeviceToList(PUsbIpExportedDevice pDev)
    987984{
    988     int rc = VINF_SUCCESS;
     985    int vrc = VINF_SUCCESS;
    989986    PUSBDEVICE pNew = (PUSBDEVICE)RTMemAllocZ(sizeof(USBDEVICE));
    990987    if (!pNew)
     
    10551052    }
    10561053    else
    1057         rc = VERR_NO_STR_MEMORY;
    1058 
    1059     if (RT_FAILURE(rc))
     1054        vrc = VERR_NO_STR_MEMORY;
     1055
     1056    if (RT_FAILURE(vrc))
    10601057    {
    10611058        if (pNew->pszManufacturer)
     
    10701067    }
    10711068
    1072     return rc;
     1069    return vrc;
    10731070}
    10741071
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