VirtualBox

Ignore:
Timestamp:
Jan 25, 2023 1:14:53 AM (23 months ago)
Author:
vboxsync
Message:

Main/src-server: rc -> hrc/vrc. Enabled scm rc checks. bugref:10223

Location:
trunk/src/VBox/Main/src-server/solaris
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Main/src-server/solaris/DynLoadLibSolaris.cpp

    r98103 r98292  
    6262        return g_hLibDlpi != NIL_RTLDRMOD;
    6363    g_fCheckedForLibDlpi = true;
    64     int rc = RTLdrLoad(LIB_DLPI, &hLibDlpi);
    65     if (RT_SUCCESS(rc))
     64    int vrc = RTLdrLoad(LIB_DLPI, &hLibDlpi);
     65    if (RT_SUCCESS(vrc))
    6666    {
    6767        /*
     
    6969         * open the VNIC/link which requires root permissions :/
    7070         */
    71         rc  = RTLdrGetSymbol(hLibDlpi, "dlpi_walk", (void **)&g_pfnLibDlpiWalk);
    72         rc |= RTLdrGetSymbol(hLibDlpi, "dlpi_close", (void **)&g_pfnLibDlpiClose);
    73         rc |= RTLdrGetSymbol(hLibDlpi, "dlpi_open", (void **)&g_pfnLibDlpiOpen);
    74         if (RT_SUCCESS(rc))
     71        vrc  = RTLdrGetSymbol(hLibDlpi, "dlpi_walk", (void **)&g_pfnLibDlpiWalk);
     72        vrc |= RTLdrGetSymbol(hLibDlpi, "dlpi_close", (void **)&g_pfnLibDlpiClose);
     73        vrc |= RTLdrGetSymbol(hLibDlpi, "dlpi_open", (void **)&g_pfnLibDlpiOpen);
     74        if (RT_SUCCESS(vrc))
    7575        {
    7676            g_hLibDlpi = hLibDlpi;
  • trunk/src/VBox/Main/src-server/solaris/NetIf-solaris.cpp

    r98103 r98292  
    461461        RT_ZERO(IfNum);
    462462        IfNum.lifn_family = AF_INET;
    463         int rc = ioctl(Sock, SIOCGLIFNUM, &IfNum);
    464         if (!rc)
     463        int iRc = ioctl(Sock, SIOCGLIFNUM, &IfNum);
     464        if (!iRc)
    465465        {
    466466            int cIfaces = RT_MIN(1024, IfNum.lifn_count); /* sane limit */
     
    474474                IfConfig.lifc_len = (int)cbIfaces;
    475475                IfConfig.lifc_buf = (caddr_t)paIfaces;
    476                 rc = ioctl(Sock, SIOCGLIFCONF, &IfConfig);
    477                 if (!rc)
     476                iRc = ioctl(Sock, SIOCGLIFCONF, &IfConfig);
     477                if (!iRc)
    478478                {
    479479                    for (int i = 0; i < cIfaces; i++)
     
    486486
    487487#if 0
    488                         rc = ioctl(Sock, SIOCGLIFADDR, &(paIfaces[i]));
    489                         if (rc >= 0)
     488                        iRc = ioctl(Sock, SIOCGLIFADDR, &(paIfaces[i]));
     489                        if (iRc >= 0)
    490490                        {
    491491                            memcpy(Info.IPAddress.au8, ((struct sockaddr *)&paIfaces[i].lifr_addr)->sa_data,
     
    501501                             * address this way, so we just use all zeros there.
    502502                             */
    503                             rc = ioctl(Sock, SIOCGARP, &ArpReq);
    504                             if (rc >= 0)
     503                            iRc = ioctl(Sock, SIOCGARP, &ArpReq);
     504                            if (iRc >= 0)
    505505                                memcpy(&Info.MACAddress, ArpReq.arp_ha.sa_data, sizeof(Info.MACAddress));
    506506
  • trunk/src/VBox/Main/src-server/solaris/PerformanceSolaris.cpp

    r98103 r98292  
    181181
    182182    uint64_t cb;
    183     int rc = RTSystemQueryTotalRam(&cb);
    184     if (RT_FAILURE(rc))
     183    int vrc = RTSystemQueryTotalRam(&cb);
     184    if (RT_FAILURE(vrc))
    185185        totalRAM = 0;
    186186    else
     
    201201int CollectorSolaris::getRawHostCpuLoad(uint64_t *user, uint64_t *kernel, uint64_t *idle)
    202202{
    203     int rc = VINF_SUCCESS;
    204203    kstat_t *ksp;
    205204    uint64_t tmpUser, tmpKernel, tmpIdle;
     
    237236    if (idle)   *idle   = tmpIdle;
    238237
    239     return rc;
     238    return VINF_SUCCESS;
    240239}
    241240
    242241int CollectorSolaris::getRawProcessCpuLoad(RTPROCESS process, uint64_t *user, uint64_t *kernel, uint64_t *total)
    243242{
    244     int rc = VINF_SUCCESS;
     243    int vrc = VINF_SUCCESS;
    245244    char *pszName;
    246245    prusage_t prusage;
     
    275274        {
    276275            Log(("read() -> %d\n", errno));
    277             rc = VERR_FILE_IO_ERROR;
     276            vrc = VERR_FILE_IO_ERROR;
    278277        }
    279278        close(h);
     
    282281    {
    283282        Log(("open() -> %d\n", errno));
    284         rc = VERR_ACCESS_DENIED;
    285     }
    286 
    287     return rc;
     283        vrc = VERR_ACCESS_DENIED;
     284    }
     285
     286    return vrc;
    288287}
    289288
     
    292291    AssertReturn(totalRAM, VERR_INTERNAL_ERROR);
    293292    uint64_t cb;
    294     int rc = RTSystemQueryAvailableRam(&cb);
    295     if (RT_SUCCESS(rc))
     293    int vrc = RTSystemQueryAvailableRam(&cb);
     294    if (RT_SUCCESS(vrc))
    296295    {
    297296        *total = totalRAM;
     
    299298        *used = *total - *available;
    300299    }
    301     return rc;
     300    return vrc;
    302301}
    303302
    304303int CollectorSolaris::getProcessMemoryUsage(RTPROCESS process, ULONG *used)
    305304{
    306     int rc = VINF_SUCCESS;
     305    int vrc = VINF_SUCCESS;
    307306    char *pszName = NULL;
    308307    psinfo_t psinfo;
     
    327326        {
    328327            Log(("read() -> %d\n", errno));
    329             rc = VERR_FILE_IO_ERROR;
     328            vrc = VERR_FILE_IO_ERROR;
    330329        }
    331330        close(h);
     
    334333    {
    335334        Log(("open() -> %d\n", errno));
    336         rc = VERR_ACCESS_DENIED;
    337     }
    338 
    339     return rc;
     335        vrc = VERR_ACCESS_DENIED;
     336    }
     337
     338    return vrc;
    340339}
    341340
     
    471470int CollectorSolaris::getRawHostDiskLoad(const char *name, uint64_t *disk_ms, uint64_t *total_ms)
    472471{
    473     int rc = VINF_SUCCESS;
     472    int vrc = VINF_SUCCESS;
    474473    AssertReturn(strlen(name) < KSTAT_STRLEN, VERR_INVALID_PARAMETER);
    475474    LogFlowThisFunc(("n=%s\n", name));
     
    480479        {
    481480            LogRel(("kstat_read(%s) -> %d\n", name, errno));
    482             rc = VERR_INTERNAL_ERROR;
     481            vrc = VERR_INTERNAL_ERROR;
    483482        }
    484483        else
     
    496495    {
    497496        LogRel(("kstat_lookup(%s) -> %d\n", name, errno));
    498         rc = VERR_INTERNAL_ERROR;
    499     }
    500 
    501     return rc;
     497        vrc = VERR_INTERNAL_ERROR;
     498    }
     499
     500    return vrc;
    502501}
    503502
     
    568567int CollectorSolaris::getHostDiskSize(const char *name, uint64_t *size)
    569568{
    570     int rc = VINF_SUCCESS;
     569    int vrc = VINF_SUCCESS;
    571570    AssertReturn(strlen(name) + 5 < KSTAT_STRLEN, VERR_INVALID_PARAMETER);
    572571    LogFlowThisFunc(("n=%s\n", name));
     
    580579        {
    581580            LogRel(("kstat_read(%s) -> %d\n", name, errno));
    582             rc = VERR_INTERNAL_ERROR;
     581            vrc = VERR_INTERNAL_ERROR;
    583582        }
    584583        else
     
    596595    {
    597596        LogRel(("kstat_lookup(%s) -> %d\n", szName, errno));
    598         rc = VERR_INTERNAL_ERROR;
    599     }
    600 
    601 
    602     return rc;
     597        vrc = VERR_INTERNAL_ERROR;
     598    }
     599
     600
     601    return vrc;
    603602}
    604603
     
    731730    {
    732731        struct mnttab Entry;
    733         int rc = 0;
     732        int iRc = 0;
    734733        resetmnttab(fp);
    735         while ((rc = getmntent(fp, &Entry)) == 0)
     734        while ((iRc = getmntent(fp, &Entry)) == 0)
    736735            mFsMap[Entry.mnt_mountp] = Entry.mnt_special;
    737736        fclose(fp);
    738         if (rc != -1)
    739             LogRel(("Error while reading mnttab: %d\n", rc));
    740     }
    741 }
    742 
    743 }
     737        if (iRc != -1)
     738            LogRel(("Error while reading mnttab: %d\n", iRc));
     739    }
     740}
     741
     742}
  • trunk/src/VBox/Main/src-server/solaris/USBProxyBackendSolaris.cpp

    r98103 r98292  
    9191     * Create semaphore.
    9292     */
    93     int rc = RTSemEventCreate(&mNotifyEventSem);
    94     if (RT_FAILURE(rc))
    95         return rc;
     93    int vrc = RTSemEventCreate(&mNotifyEventSem);
     94    if (RT_FAILURE(vrc))
     95        return vrc;
    9696
    9797    /*
    9898     * Initialize the USB library.
    9999     */
    100     rc = USBLibInit();
    101     if (RT_FAILURE(rc))
     100    vrc = USBLibInit();
     101    if (RT_FAILURE(vrc))
    102102    {
    103103        /* mNotifyEventSem will be destroyed in uninit */
    104         return rc;
     104        return vrc;
    105105    }
    106106
     
    209209    int *pInt = NULL;
    210210    char *pStr = NULL;
    211     int rc = DI_WALK_CONTINUE;
     211    int iRc = DI_WALK_CONTINUE;
    212212    if (di_prop_lookup_ints(DDI_DEV_T_ANY, Node, "interface", &pInt) < 0)
    213213    {
     
    337337                pList->pTail = pList->pHead = pCur;
    338338
    339             rc = DI_WALK_CONTINUE;
     339            iRc = DI_WALK_CONTINUE;
    340340        } while (0);
    341341
     
    344344            solarisFreeUSBDevice(pCur);
    345345    }
    346     return rc;
     346    return iRc;
    347347}
    348348
     
    393393
    394394    PUSBDEVICE pDev = aDevice->i_getUsbData();
    395     int rc = USBLibResetDevice(pDev->pszDevicePath, true);
    396     if (RT_SUCCESS(rc))
     395    int vrc = USBLibResetDevice(pDev->pszDevicePath, true);
     396    if (RT_SUCCESS(vrc))
    397397        aDevice->i_setBackendUserData(pvId);
    398398    else
     
    401401        pvId = NULL;
    402402    }
    403     LogFlowThisFunc(("returns %Rrc pvId=%p\n", rc, pvId));
    404     return rc;
     403    LogFlowThisFunc(("returns %Rrc pvId=%p\n", vrc, pvId));
     404    return vrc;
    405405}
    406406
     
    449449
    450450    PUSBDEVICE pDev = aDevice->i_getUsbData();
    451     int rc = USBLibResetDevice(pDev->pszDevicePath, true /* Re-attach */);
    452     if (RT_SUCCESS(rc))
     451    int vrc = USBLibResetDevice(pDev->pszDevicePath, true /* Re-attach */);
     452    if (RT_SUCCESS(vrc))
    453453        aDevice->i_setBackendUserData(pvId);
    454454    else
     
    457457        pvId = NULL;
    458458    }
    459     LogFlowThisFunc(("returns %Rrc pvId=%p\n", rc, pvId));
    460     return rc;
     459    LogFlowThisFunc(("returns %Rrc pvId=%p\n", vrc, pvId));
     460    return vrc;
    461461}
    462462
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