Changeset 98288 in vbox for trunk/src/VBox/Main/src-server/linux

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

Location:

trunk/src/VBox/Main/src-server/linux

Files:

• HostDnsServiceLinux.cpp (modified) (5 diffs)
• HostHardwareLinux.cpp (modified) (25 diffs)
• HostPowerLinux.cpp (modified) (2 diffs)
• NetIf-linux.cpp (modified) (4 diffs)
• PerformanceLinux.cpp (modified) (17 diffs)
• USBGetDevices.cpp (modified) (41 diffs)
• USBProxyBackendLinux.cpp (modified) (10 diffs)

trunk/src/VBox/Main/src-server/linux/HostDnsServiceLinux.cpp

@@ -185 +185 @@
      */
     int aiStopPair[2];
-    int rc = socketpair(AF_LOCAL, SOCK_DGRAM | SOCK_CLOEXEC, 0, aiStopPair);
+    int iRc = socketpair(AF_LOCAL, SOCK_DGRAM | SOCK_CLOEXEC, 0, aiStopPair);
     int iErr = errno;
-    AssertLogRelMsgReturn(rc == 0, ("socketpair: failed (%d: %s)\n", iErr, strerror(iErr)), RTErrConvertFromErrno(iErr));
+    AssertLogRelMsgReturn(iRc == 0, ("socketpair: failed (%d: %s)\n", iErr, strerror(iErr)), RTErrConvertFromErrno(iErr));
 
     m_fdShutdown = aiStopPair[0];
@@ -241 +241 @@
          * Wait for something to happen.
          */
-        rc = poll(aFdPolls, RT_ELEMENTS(aFdPolls), -1 /*infinite timeout*/);
-        if (rc == -1)
+        iRc = poll(aFdPolls, RT_ELEMENTS(aFdPolls), -1 /*infinite timeout*/);
+        if (iRc == -1)
         {
             if (errno != EINTR)
             {
-                LogRelMax(32, ("HostDnsServiceLinux::monitorThreadProc: poll failed %d: errno=%d\n", rc, errno));
+                LogRelMax(32, ("HostDnsServiceLinux::monitorThreadProc: poll failed %d: errno=%d\n", iRc, errno));
                 RTThreadSleep(1);
             }
             continue;
         }
-        Log5Func(("poll returns %d: [0]=%#x [1]=%#x\n", rc, aFdPolls[1].revents, aFdPolls[0].revents));
+        Log5Func(("poll returns %d: [0]=%#x [1]=%#x\n", iRc, aFdPolls[1].revents, aFdPolls[0].revents));
 
         AssertMsgBreakStmt(   (aFdPolls[0].revents & (POLLERR | POLLNVAL)) == 0 /* (ok for fd=-1 too, revents=0 then) */
@@ -322 +322 @@
                         if (iWdFileNew != -1)
                         {
-                            rc = inotify_rm_watch(iNotifyFd, iWdFileNew);
-                            AssertMsg(rc >= 0, ("%d/%d\n", rc, errno));
+                            iRc = inotify_rm_watch(iNotifyFd, iWdFileNew);
+                            AssertMsg(iRc >= 0, ("%d/%d\n", iRc, errno));
                             iWdFileNew = -1;
                         }
@@ -350 +350 @@
                             if (iWdFileNew >= 0)
                             {
-                                rc = inotify_rm_watch(iNotifyFd, iWdFileNew);
-                                Log5Func(("dir: moved / created / deleted: dropped file watch (%d - rc=%d/err=%d)\n",
-                                          iWdFileNew, rc, errno));
+                                iRc = inotify_rm_watch(iNotifyFd, iWdFileNew);
+                                Log5Func(("dir: moved / created / deleted: dropped file watch (%d - iRc=%d/err=%d)\n",
+                                          iWdFileNew, iRc, errno));
                                 iWdFileNew = -1;
                             }
                             if (iWdSymDirNew >= 0)
                             {
-                                rc = inotify_rm_watch(iNotifyFd, iWdSymDirNew);
-                                Log5Func(("dir: moved / created / deleted: dropped symlinked dir watch (%d - %s/%s - rc=%d/err=%d)\n",
-                                          iWdSymDirNew, szRealResolvConf, &szRealResolvConf[offRealResolvConfName], rc, errno));
+                                iRc = inotify_rm_watch(iNotifyFd, iWdSymDirNew);
+                                Log5Func(("dir: moved / created / deleted: dropped symlinked dir watch (%d - %s/%s - iRc=%d/err=%d)\n",
+                                          iWdSymDirNew, szRealResolvConf, &szRealResolvConf[offRealResolvConfName], iRc, errno));
                                 iWdSymDirNew = -1;
                                 offRealResolvConfName = 0;
@@ -397 +397 @@
                         if (iWdFileNew >= 0)
                         {
-                            rc = inotify_rm_watch(iNotifyFd, iWdFileNew);
-                            Log5Func(("symdir: moved / created / deleted: drop file watch (%d - rc=%d/err=%d)\n",
-                                      iWdFileNew, rc, errno));
+                            iRc = inotify_rm_watch(iNotifyFd, iWdFileNew);
+                            Log5Func(("symdir: moved / created / deleted: drop file watch (%d - iRc=%d/err=%d)\n",
+                                      iWdFileNew, iRc, errno));
                             iWdFileNew = -1;
                         }

trunk/src/VBox/Main/src-server/linux/HostHardwareLinux.cpp

@@ -148 +148 @@
     AssertReturn(Number <= 7, false);
     RTFILE File;
-    int rc = RTFileOpen(&File, pcszNode, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_NON_BLOCK);
-    if (RT_SUCCESS(rc))
+    int vrc = RTFileOpen(&File, pcszNode, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_NON_BLOCK);
+    if (RT_SUCCESS(vrc))
     {
         int rcIoCtl;
-        rc = RTFileIoCtl(File, FDGETDRVTYP, pszName, 0, &rcIoCtl);
+        vrc = RTFileIoCtl(File, FDGETDRVTYP, pszName, 0, &rcIoCtl);
         RTFileClose(File);
-        if (RT_SUCCESS(rc) && rcIoCtl >= 0)
+        if (RT_SUCCESS(vrc) && rcIoCtl >= 0)
             return true;
     }
@@ -310 +310 @@
 
     RTFILE hFile = NIL_RTFILE;
-    int rc = RTFileOpen(&hFile, pcszNode, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_NON_BLOCK);
-    if (RT_SUCCESS(rc))
+    int vrc = RTFileOpen(&hFile, pcszNode, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_NON_BLOCK);
+    if (RT_SUCCESS(vrc))
     {
         int                             rcIoCtl          = 0;
@@ -323 +323 @@
         CdromCommandReq.data_direction = CGC_DATA_READ;
         CdromCommandReq.timeout        = 5000;  /* ms */
-        rc = RTFileIoCtl(hFile, CDROM_SEND_PACKET, &CdromCommandReq, 0, &rcIoCtl);
-        if (RT_SUCCESS(rc) && rcIoCtl < 0)
-            rc = RTErrConvertFromErrno(-CdromCommandReq.stat);
+        vrc = RTFileIoCtl(hFile, CDROM_SEND_PACKET, &CdromCommandReq, 0, &rcIoCtl);
+        if (RT_SUCCESS(vrc) && rcIoCtl < 0)
+            vrc = RTErrConvertFromErrno(-CdromCommandReq.stat);
         RTFileClose(hFile);
 
-        if (RT_SUCCESS(rc))
+        if (RT_SUCCESS(vrc))
         {
             if (pbType)
@@ -347 +347 @@
         }
     }
-    LogRelFlowFunc(("returning %Rrc\n", rc));
-    return rc;
+    LogRelFlowFunc(("returning %Rrc\n", vrc));
+    return vrc;
 }
 
@@ -432 +432 @@
     AssertPtrReturn(pcszNode, false);
     RTFILE File;
-    int rc = RTFileOpen(&File, pcszNode, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_NON_BLOCK);
-    if (RT_SUCCESS(rc))
+    int vrc = RTFileOpen(&File, pcszNode, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_NON_BLOCK);
+    if (RT_SUCCESS(vrc))
     {
         int rcIoCtl;
-        rc = RTFileIoCtl(File, NVME_IOCTL_ID, NULL, 0, &rcIoCtl);
+        vrc = RTFileIoCtl(File, NVME_IOCTL_ID, NULL, 0, &rcIoCtl);
         RTFileClose(File);
-        if (RT_SUCCESS(rc) && rcIoCtl >= 0)
+        if (RT_SUCCESS(vrc) && rcIoCtl >= 0)
             return true;
     }
@@ -520 +520 @@
 {
     LogFlowThisFunc(("entered\n"));
-    int rc;
+    int vrc;
     try
     {
@@ -527 +527 @@
          * environment variable. */
         bool fSuccess = false;  /* Have we succeeded in finding anything yet? */
-        rc = getDriveInfoFromEnv("VBOX_CDROM", &mDVDList, true /* isDVD */, &fSuccess);
+        vrc = getDriveInfoFromEnv("VBOX_CDROM", &mDVDList, true /* isDVD */, &fSuccess);
         setNoProbe(false);
-        if (RT_SUCCESS(rc) && (!fSuccess || testing()))
-            rc = getDriveInfoFromSysfs(&mDVDList, DVD, &fSuccess);
-        if (RT_SUCCESS(rc) && testing())
+        if (RT_SUCCESS(vrc) && (!fSuccess || testing()))
+            vrc = getDriveInfoFromSysfs(&mDVDList, DVD, &fSuccess);
+        if (RT_SUCCESS(vrc) && testing())
         {
             setNoProbe(true);
-            rc = getDriveInfoFromSysfs(&mDVDList, DVD, &fSuccess);
+            vrc = getDriveInfoFromSysfs(&mDVDList, DVD, &fSuccess);
         }
     }
     catch (std::bad_alloc &e)
     {
-        rc = VERR_NO_MEMORY;
-    }
-    LogFlowThisFunc(("rc=%Rrc\n", rc));
-    return rc;
+        vrc = VERR_NO_MEMORY;
+    }
+    LogFlowThisFunc(("vrc=%Rrc\n", vrc));
+    return vrc;
 }
 
@@ -548 +548 @@
 {
     LogFlowThisFunc(("entered\n"));
-    int rc;
+    int vrc;
     try
     {
         mFloppyList.clear();
         bool fSuccess = false;  /* Have we succeeded in finding anything yet? */
-        rc = getDriveInfoFromEnv("VBOX_FLOPPY", &mFloppyList, false /* isDVD */, &fSuccess);
+        vrc = getDriveInfoFromEnv("VBOX_FLOPPY", &mFloppyList, false /* isDVD */, &fSuccess);
         setNoProbe(false);
-        if (RT_SUCCESS(rc) && (!fSuccess || testing()))
-            rc = getDriveInfoFromSysfs(&mFloppyList, Floppy, &fSuccess);
-        if (RT_SUCCESS(rc) && testing())
+        if (RT_SUCCESS(vrc) && (!fSuccess || testing()))
+            vrc = getDriveInfoFromSysfs(&mFloppyList, Floppy, &fSuccess);
+        if (RT_SUCCESS(vrc) && testing())
         {
             setNoProbe(true);
-            rc = getDriveInfoFromSysfs(&mFloppyList, Floppy, &fSuccess);
+            vrc = getDriveInfoFromSysfs(&mFloppyList, Floppy, &fSuccess);
         }
     }
     catch (std::bad_alloc &)
     {
-        rc = VERR_NO_MEMORY;
-    }
-    LogFlowThisFunc(("rc=%Rrc\n", rc));
-    return rc;
+        vrc = VERR_NO_MEMORY;
+    }
+    LogFlowThisFunc(("vrc=%Rrc\n", vrc));
+    return vrc;
 }
 
@@ -617 +617 @@
     AssertPtrNullReturn(pfSuccess, VERR_INVALID_POINTER);
     LogFlowFunc(("pcszVar=%s, pList=%p, isDVD=%d, pfSuccess=%p\n", pcszVar, pList, isDVD, pfSuccess));
-    int rc = VINF_SUCCESS;
+    int vrc = VINF_SUCCESS;
     bool success = false;
     char *pszFreeMe = RTEnvDupEx(RTENV_DEFAULT, pcszVar);
@@ -645 +645 @@
     catch (std::bad_alloc &)
     {
-        rc = VERR_NO_MEMORY;
+        vrc = VERR_NO_MEMORY;
     }
     RTStrFree(pszFreeMe);
-    LogFlowFunc(("rc=%Rrc, success=%d\n", rc, success));
-    return rc;
+    LogFlowFunc(("vrc=%Rrc, success=%d\n", vrc, success));
+    return vrc;
 }
 
@@ -696 +696 @@
     {
         dev_t dev = 0;
-        int rc = RTLinuxSysFsReadDevNumFile(&dev, "block/%s/dev", mpcszName);
-        if (RT_FAILURE(rc) || dev == 0)
+        int vrc = RTLinuxSysFsReadDevNumFile(&dev, "block/%s/dev", mpcszName);
+        if (RT_FAILURE(vrc) || dev == 0)
         {
             misConsistent = false;
             return false;
         }
-        rc = RTLinuxCheckDevicePath(dev, RTFS_TYPE_DEV_BLOCK, mszNode, sizeof(mszNode), "%s", mpcszName);
-        return RT_SUCCESS(rc);
+        vrc = RTLinuxCheckDevicePath(dev, RTFS_TYPE_DEV_BLOCK, mszNode, sizeof(mszNode), "%s", mpcszName);
+        return RT_SUCCESS(vrc);
     }
 
@@ -714 +714 @@
     {
         int64_t type = 0;
-        int rc = RTLinuxSysFsReadIntFile(10, &type, "block/%s/device/type", mpcszName);
-        if (RT_SUCCESS(rc) && type != TYPE_ROM)
+        int vrc = RTLinuxSysFsReadIntFile(10, &type, "block/%s/device/type", mpcszName);
+        if (RT_SUCCESS(vrc) && type != TYPE_ROM)
             return;
         if (type == TYPE_ROM)
         {
             char szVendor[128];
-            rc = RTLinuxSysFsReadStrFile(szVendor, sizeof(szVendor), NULL, "block/%s/device/vendor", mpcszName);
-            if (RT_SUCCESS(rc))
+            vrc = RTLinuxSysFsReadStrFile(szVendor, sizeof(szVendor), NULL, "block/%s/device/vendor", mpcszName);
+            if (RT_SUCCESS(vrc))
             {
                 char szModel[128];
-                rc = RTLinuxSysFsReadStrFile(szModel, sizeof(szModel), NULL, "block/%s/device/model", mpcszName);
-                if (RT_SUCCESS(rc))
+                vrc = RTLinuxSysFsReadStrFile(szModel, sizeof(szModel), NULL, "block/%s/device/model", mpcszName);
+                if (RT_SUCCESS(vrc))
                 {
                     misValid = true;
@@ -747 +747 @@
         char szVendor[128] = "";
         char szModel[128] = "";
-        int rc = cdromDoInquiry(mszNode, &bType, szVendor, sizeof(szVendor), szModel, sizeof(szModel));
-        if (RT_SUCCESS(rc) && bType == TYPE_ROM)
+        int vrc = cdromDoInquiry(mszNode, &bType, szVendor, sizeof(szVendor), szModel, sizeof(szModel));
+        if (RT_SUCCESS(vrc) && bType == TYPE_ROM)
         {
             misValid = true;
@@ -772 +772 @@
         if (!noProbe())
             fHaveName = floppyGetName(mszNode, mpcszName[2] - '0', szName);
-        int rc = RTLinuxSysFsGetLinkDest(szDriver, sizeof(szDriver), NULL, "block/%s/%s",
-                                         mpcszName, "device/driver");
-        if (RT_SUCCESS(rc))
+        int vrc = RTLinuxSysFsGetLinkDest(szDriver, sizeof(szDriver), NULL, "block/%s/%s", mpcszName, "device/driver");
+        if (RT_SUCCESS(vrc))
         {
             if (RTStrCmp(szDriver, "floppy"))
@@ -795 +794 @@
          */
         int64_t type = 0;
-        int rc = RTLinuxSysFsReadIntFile(10, &type, "block/%s/device/type", mpcszName);
-        if (!RT_SUCCESS(rc) || type != TYPE_DISK)
+        int vrc = RTLinuxSysFsReadIntFile(10, &type, "block/%s/device/type", mpcszName);
+        if (!RT_SUCCESS(vrc) || type != TYPE_DISK)
         {
             if (noProbe() || !probeNVME(mszNode))
             {
                 char szDriver[16];
-                rc = RTLinuxSysFsGetLinkDest(szDriver, sizeof(szDriver), NULL, "block/%s/%s",
-                                                 mpcszName, "device/device/driver");
-                if (RT_FAILURE(rc) || RTStrCmp(szDriver, "nvme"))
-                        return;
+                vrc = RTLinuxSysFsGetLinkDest(szDriver, sizeof(szDriver), NULL, "block/%s/%s", mpcszName, "device/device/driver");
+                if (RT_FAILURE(vrc) || RTStrCmp(szDriver, "nvme"))
+                    return;
             }
         }
@@ -810 +808 @@
         char szModel[128];
         size_t cbRead = 0;
-        rc = RTLinuxSysFsReadStrFile(szVendor, sizeof(szVendor), &cbRead, "block/%s/device/vendor", mpcszName);
+        vrc = RTLinuxSysFsReadStrFile(szVendor, sizeof(szVendor), &cbRead, "block/%s/device/vendor", mpcszName);
         szVendor[cbRead] = '\0';
         /* Assume the model is always present. Vendor is not present for NVME disks */
         cbRead = 0;
-        rc = RTLinuxSysFsReadStrFile(szModel, sizeof(szModel), &cbRead, "block/%s/device/model", mpcszName);
+        vrc = RTLinuxSysFsReadStrFile(szModel, sizeof(szModel), &cbRead, "block/%s/device/model", mpcszName);
         szModel[cbRead] = '\0';
-        if (RT_SUCCESS(rc))
+        if (RT_SUCCESS(vrc))
         {
             misValid = true;
@@ -870 +868 @@
     unsigned cFound = 0;
     RTDIR hDir = NIL_RTDIR;
-    int rc = RTDirOpen(&hDir, "/sys/block");
+    int vrc = RTDirOpen(&hDir, "/sys/block");
     /* This might mean that sysfs semantics have changed */
-    AssertReturn(rc != VERR_FILE_NOT_FOUND, VINF_SUCCESS);
-    if (RT_SUCCESS(rc))
+    AssertReturn(vrc != VERR_FILE_NOT_FOUND, VINF_SUCCESS);
+    if (RT_SUCCESS(vrc))
     {
         for (;;)
         {
             RTDIRENTRY entry;
-            rc = RTDirRead(hDir, &entry, NULL);
-            Assert(rc != VERR_BUFFER_OVERFLOW);  /* Should never happen... */
-            if (RT_FAILURE(rc))  /* Including overflow and no more files */
+            vrc = RTDirRead(hDir, &entry, NULL);
+            Assert(vrc != VERR_BUFFER_OVERFLOW);  /* Should never happen... */
+            if (RT_FAILURE(vrc))  /* Including overflow and no more files */
                 break;
             if (entry.szName[0] == '.')
@@ -895 +893 @@
             catch (std::bad_alloc &e)
             {
-                rc = VERR_NO_MEMORY;
+                vrc = VERR_NO_MEMORY;
                 break;
             }
@@ -902 +900 @@
         RTDirClose(hDir);
     }
-    if (rc == VERR_NO_MORE_FILES)
-        rc = VINF_SUCCESS;
-    else if (RT_FAILURE(rc))
+    if (vrc == VERR_NO_MORE_FILES)
+        vrc = VINF_SUCCESS;
+    else if (RT_FAILURE(vrc))
         /* Clean up again */
         while (cFound-- > 0)
@@ -910 +908 @@
     if (pfSuccess)
         *pfSuccess = fSuccess;
-    LogFlow (("rc=%Rrc, fSuccess=%u\n", rc, (unsigned)fSuccess));
-    return rc;
+    LogFlow (("vrc=%Rrc, fSuccess=%u\n", vrc, (unsigned)fSuccess));
+    return vrc;
 }
 
@@ -1181 +1179 @@
 #  endif
 
-    int rc = iwInit(&mWatches);
-    if (RT_SUCCESS(rc))
-    {
-        rc = iwAddWatch(&mWatches, mpcszDevicesRoot);
-        if (RT_SUCCESS(rc))
-            rc = pipeCreateSimple(&mhWakeupPipeR, &mhWakeupPipeW);
-    }
-    mStatus = rc;
-    if (RT_FAILURE(rc))
+    int vrc = iwInit(&mWatches);
+    if (RT_SUCCESS(vrc))
+    {
+        vrc = iwAddWatch(&mWatches, mpcszDevicesRoot);
+        if (RT_SUCCESS(vrc))
+            vrc = pipeCreateSimple(&mhWakeupPipeR, &mhWakeupPipeW);
+    }
+    mStatus = vrc;
+    if (RT_FAILURE(vrc))
         term();
 }
@@ -1247 +1245 @@
 int hotplugInotifyImpl::Wait(RTMSINTERVAL aMillies)
 {
-    int rc;
-
     AssertRCReturn(mStatus, VERR_WRONG_ORDER);
     bool fEntered = ASMAtomicCmpXchgU32(&mfWaiting, 1, 0);
@@ -1255 +1251 @@
     VECTOR_PTR(char *) vecpchDevs;
     VEC_INIT_PTR(&vecpchDevs, char *, RTStrFree);
-    rc = readFilePaths(mpcszDevicesRoot, &vecpchDevs, false);
-    if (RT_SUCCESS(rc))
+    int vrc = readFilePaths(mpcszDevicesRoot, &vecpchDevs, false);
+    if (RT_SUCCESS(vrc))
     {
         char **ppszEntry;
         VEC_FOR_EACH(&vecpchDevs, char *, ppszEntry)
-            if (RT_FAILURE(rc = iwAddWatch(&mWatches, *ppszEntry)))
+            if (RT_FAILURE(vrc = iwAddWatch(&mWatches, *ppszEntry)))
                 break;
 
-        if (RT_SUCCESS(rc))
+        if (RT_SUCCESS(vrc))
         {
             struct pollfd pollFD[MAX_POLLID];
@@ -1275 +1271 @@
             {
                 Assert(errno > 0);
-                rc = RTErrConvertFromErrno(errno);
+                vrc = RTErrConvertFromErrno(errno);
             }
             else if (pollFD[RPIPE_ID].revents)
             {
-                rc = drainWakeupPipe();
-                if (RT_SUCCESS(rc))
-                    rc = VERR_INTERRUPTED;
+                vrc = drainWakeupPipe();
+                if (RT_SUCCESS(vrc))
+                    vrc = VERR_INTERRUPTED;
             }
             else if ((pollFD[INOTIFY_ID].revents))
             {
                 if (cPolled == 1)
-                    rc = drainInotify();
+                    vrc = drainInotify();
                 else
-                    AssertFailedStmt(rc = VERR_INTERNAL_ERROR);
+                    AssertFailedStmt(vrc = VERR_INTERNAL_ERROR);
             }
             else
             {
                 if (errno == 0 && cPolled == 0)
-                    rc = VERR_TIMEOUT;
+                    vrc = VERR_TIMEOUT;
                 else
-                    AssertFailedStmt(rc = VERR_INTERNAL_ERROR);
+                    AssertFailedStmt(vrc = VERR_INTERNAL_ERROR);
             }
         }
@@ -1302 +1298 @@
     mfWaiting = 0;
     VEC_CLEANUP_PTR(&vecpchDevs);
-    return rc;
+    return vrc;
 }
 

trunk/src/VBox/Main/src-server/linux/HostPowerLinux.cpp

@@ -59 +59 @@
 {
     DBusError error;
-    int rc;
 
-    rc = RTDBusLoadLib();
-    if (RT_FAILURE(rc))
+    int vrc = RTDBusLoadLib();
+    if (RT_FAILURE(vrc))
     {
         LogRel(("HostPowerServiceLinux: DBus library not found.  Service not available.\n"));
@@ -92 +91 @@
 
     /* Create the new worker thread. */
-    rc = RTThreadCreate(&mThread, HostPowerServiceLinux::powerChangeNotificationThread, this, 0 /* cbStack */,
-                        RTTHREADTYPE_MSG_PUMP, RTTHREADFLAGS_WAITABLE, "MainPower");
-    if (RT_FAILURE(rc))
+    vrc = RTThreadCreate(&mThread, HostPowerServiceLinux::powerChangeNotificationThread, this, 0 /* cbStack */,
+                         RTTHREADTYPE_MSG_PUMP, RTTHREADFLAGS_WAITABLE, "MainPower");
+    if (RT_FAILURE(vrc))
     {
-        LogRel(("HostPowerServiceLinux: RTThreadCreate failed with %Rrc\n", rc));
+        LogRel(("HostPowerServiceLinux: RTThreadCreate failed with %Rrc\n", vrc));
         dbus_connection_unref(mpConnection);
     }

trunk/src/VBox/Main/src-server/linux/NetIf-linux.cpp

@@ -126 +126 @@
     {
         /* Failed to get speed via sysfs, go to plan B. */
-        int rc = NetIfAdpCtlOut(pszName, "speed", szBuf, sizeof(szBuf));
-        if (RT_SUCCESS(rc))
+        int vrc = NetIfAdpCtlOut(pszName, "speed", szBuf, sizeof(szBuf));
+        if (RT_SUCCESS(vrc))
             uSpeed = RTStrToUInt32(szBuf);
     }
@@ -230 +230 @@
 {
     char szDefaultIface[256];
-    int rc = getDefaultIfaceName(szDefaultIface, sizeof(szDefaultIface));
-    if (RT_FAILURE(rc))
+    int vrc = getDefaultIfaceName(szDefaultIface, sizeof(szDefaultIface));
+    if (RT_FAILURE(vrc))
     {
         Log(("NetIfList: Failed to find default interface.\n"));
@@ -253 +253 @@
                 NETIFINFO Info;
                 RT_ZERO(Info);
-                rc = getInterfaceInfo(sock, pszName, &Info);
-                if (RT_FAILURE(rc))
+                vrc = getInterfaceInfo(sock, pszName, &Info);
+                if (RT_FAILURE(vrc))
                     break;
                 if (Info.enmMediumType == NETIF_T_ETHERNET)
@@ -282 +282 @@
     }
     else
-        rc = VERR_INTERNAL_ERROR;
-
-    return rc;
+        vrc = VERR_INTERNAL_ERROR;
+
+    return vrc;
 }
 
 int NetIfGetConfigByName(PNETIFINFO pInfo)
 {
-    int rc = VINF_SUCCESS;
     int sock = socket(AF_INET, SOCK_DGRAM, 0);
     if (sock < 0)
         return VERR_NOT_IMPLEMENTED;
-    rc = getInterfaceInfo(sock, pInfo->szShortName, pInfo);
+    int vrc = getInterfaceInfo(sock, pInfo->szShortName, pInfo);
     close(sock);
-    return rc;
+    return vrc;
 }
 

trunk/src/VBox/Main/src-server/linux/PerformanceLinux.cpp

@@ -114 +114 @@
 
     uint64_t cb;
-    int rc = RTSystemQueryTotalRam(&cb);
-    if (RT_FAILURE(rc))
+    int vrc = RTSystemQueryTotalRam(&cb);
+    if (RT_FAILURE(vrc))
         mTotalRAM = 0;
     else
@@ -130 +130 @@
     {
         VMProcessStats vmStats;
-        int rc = getRawProcessStats(*it, &vmStats.cpuUser, &vmStats.cpuKernel, &vmStats.pagesUsed);
+        int vrc = getRawProcessStats(*it, &vmStats.cpuUser, &vmStats.cpuKernel, &vmStats.pagesUsed);
         /* On failure, do NOT stop. Just skip the entry. Having the stats for
          * one (probably broken) process frozen/zero is a minor issue compared
          * to not updating many process stats and the host cpu stats. */
-        if (RT_SUCCESS(rc))
+        if (RT_SUCCESS(vrc))
             mProcessStats[*it] = vmStats;
     }
@@ -146 +146 @@
 int CollectorLinux::_getRawHostCpuLoad()
 {
-    int rc = VINF_SUCCESS;
+    int vrc = VINF_SUCCESS;
     long long unsigned uUser, uNice, uKernel, uIdle, uIowait, uIrq, uSoftirq;
     FILE *f = fopen("/proc/stat", "r");
@@ -184 +184 @@
             }
             else
-                rc = VERR_FILE_IO_ERROR;
+                vrc = VERR_FILE_IO_ERROR;
         }
         else
-            rc = VERR_FILE_IO_ERROR;
+            vrc = VERR_FILE_IO_ERROR;
         fclose(f);
     }
     else
-        rc = VERR_ACCESS_DENIED;
-
-    return rc;
+        vrc = VERR_ACCESS_DENIED;
+
+    return vrc;
 }
 
@@ -223 +223 @@
     AssertReturn(mTotalRAM, VERR_INTERNAL_ERROR);
     uint64_t cb;
-    int rc = RTSystemQueryAvailableRam(&cb);
-    if (RT_SUCCESS(rc))
+    int vrc = RTSystemQueryAvailableRam(&cb);
+    if (RT_SUCCESS(vrc))
     {
         *total = mTotalRAM;
@@ -230 +230 @@
         *used = *total - *available;
     }
-    return rc;
+    return vrc;
 }
 
@@ -257 +257 @@
     Assert(pszPath);
 
-    int rc = VINF_SUCCESS;
+    int vrc = VINF_SUCCESS;
     if (!RTLinuxSysFsExists(pszPath))
-        rc = VERR_FILE_NOT_FOUND;
+        vrc = VERR_FILE_NOT_FOUND;
     else
     {
         int64_t cSize = 0;
-        rc = RTLinuxSysFsReadIntFile(0, &cSize, pszPath);
-        if (RT_SUCCESS(rc))
+        vrc = RTLinuxSysFsReadIntFile(0, &cSize, pszPath);
+        if (RT_SUCCESS(vrc))
             *size = cSize * 512;
     }
     RTStrFree(pszPath);
-    return rc;
+    return vrc;
 }
 
@@ -286 +286 @@
 int CollectorLinux::getRawProcessStats(RTPROCESS process, uint64_t *cpuUser, uint64_t *cpuKernel, ULONG *memPagesUsed)
 {
-    int rc = VINF_SUCCESS;
+    int vrc = VINF_SUCCESS;
     char *pszName;
     pid_t pid2;
@@ -316 +316 @@
         }
         else
-            rc = VERR_FILE_IO_ERROR;
+            vrc = VERR_FILE_IO_ERROR;
         fclose(f);
     }
     else
-        rc = VERR_ACCESS_DENIED;
-
-    return rc;
+        vrc = VERR_ACCESS_DENIED;
+
+    return vrc;
 }
 
@@ -334 +334 @@
 
     int64_t cSize = 0;
-    int rc = RTLinuxSysFsReadIntFile(0, &cSize, szIfName);
-    if (RT_FAILURE(rc))
-        return rc;
+    int vrc = RTLinuxSysFsReadIntFile(0, &cSize, szIfName);
+    if (RT_FAILURE(vrc))
+        return vrc;
 
     *rx = cSize;
@@ -344 +344 @@
         return VERR_FILE_NOT_FOUND;
 
-    rc = RTLinuxSysFsReadIntFile(0, &cSize, szIfName);
-    if (RT_FAILURE(rc))
-        return rc;
+    vrc = RTLinuxSysFsReadIntFile(0, &cSize, szIfName);
+    if (RT_FAILURE(vrc))
+        return vrc;
 
     *tx = cSize;
@@ -355 +355 @@
 {
 #if 0
-    int rc = VINF_SUCCESS;
+    int vrc = VINF_SUCCESS;
     char szIfName[/*IFNAMSIZ*/ 16 + 36];
     long long unsigned int u64Busy, tmp;
@@ -370 +370 @@
         }
         else
-            rc = VERR_FILE_IO_ERROR;
+            vrc = VERR_FILE_IO_ERROR;
         fclose(f);
     }
     else
-        rc = VERR_ACCESS_DENIED;
+        vrc = VERR_ACCESS_DENIED;
 #else
-    int rc = VERR_MISSING;
+    int vrc = VERR_MISSING;
     FILE *f = fopen("/proc/diskstats", "r");
     if (f)
@@ -406 +406 @@
                     *disk_ms   = u64Busy;
                     *total_ms  = (uint64_t)(mSingleUser + mSingleKernel + mSingleIdle) * 1000 / mHZ;
-                    rc = VINF_SUCCESS;
+                    vrc = VINF_SUCCESS;
                 }
                 else
-                    rc = VERR_FILE_IO_ERROR;
+                    vrc = VERR_FILE_IO_ERROR;
                 break;
             }
@@ -417 +417 @@
 #endif
 
-    return rc;
+    return vrc;
 }
 
@@ -525 +525 @@
 {
     char szVolInfo[RTPATH_MAX];
-    int rc = RTPathAppPrivateArch(szVolInfo,
-                                  sizeof(szVolInfo) - sizeof("/" VBOXVOLINFO_NAME " ") - strlen(pcszVolume));
-    if (RT_FAILURE(rc))
-    {
-        LogRel(("VolInfo: Failed to get program path, rc=%Rrc\n", rc));
+    int vrc = RTPathAppPrivateArch(szVolInfo, sizeof(szVolInfo) - sizeof("/" VBOXVOLINFO_NAME " ") - strlen(pcszVolume));
+    if (RT_FAILURE(vrc))
+    {
+        LogRel(("VolInfo: Failed to get program path, vrc=%Rrc\n", vrc));
         return;
     }
@@ -568 +567 @@
                 char szFsName[1024];
                 /* Try to resolve symbolic link if necessary. Yes, we access the file system here! */
-                int rc = RTPathReal(mntent->mnt_fsname, szFsName, sizeof(szFsName));
-                if (RT_FAILURE(rc))
+                int vrc = RTPathReal(mntent->mnt_fsname, szFsName, sizeof(szFsName));
+                if (RT_FAILURE(vrc))
                     continue; /* something got wrong, just ignore this path */
                 /* check against the actual mtab entry, NOT the real path as /dev/mapper/xyz is

trunk/src/VBox/Main/src-server/linux/USBGetDevices.cpp

@@ -293 +293 @@
         }
 
-        int rc = usbfsReadSkipSuffix(&pszNext);
-        if (RT_FAILURE(rc))
-            return rc;
+        int vrc = usbfsReadSkipSuffix(&pszNext);
+        if (RT_FAILURE(vrc))
+            return vrc;
 
         *ppszNext = pszNext;
@@ -379 +379 @@
          * Validate and skip stuff following the number.
          */
-        int rc = usbfsReadSkipSuffix(&pszNext);
-        if (RT_FAILURE(rc))
-            return rc;
+        int vrc = usbfsReadSkipSuffix(&pszNext);
+        if (RT_FAILURE(vrc))
+            return vrc;
         *ppszNext = pszNext;
 
@@ -471 +471 @@
 /** Just a worker for USBProxyServiceLinux::getDevices that avoids some code duplication. */
 static int usbfsAddDeviceToChain(PUSBDEVICE pDev, PUSBDEVICE *ppFirst, PUSBDEVICE **pppNext, const char *pszUsbfsRoot,
-                                 bool fUnsupportedDevicesToo, int rc)
+                                 bool fUnsupportedDevicesToo, int vrc)
 {
     /* usbDeterminState requires the address. */
@@ -495 +495 @@
         {
             deviceFree(pDevNew);
-            rc = VERR_NO_MEMORY;
+            vrc = VERR_NO_MEMORY;
         }
     }
     else
     {
-        rc = VERR_NO_MEMORY;
+        vrc = VERR_NO_MEMORY;
         deviceFreeMembers(pDev);
     }
 
-    return rc;
+    return vrc;
 }
 
@@ -535 +535 @@
     PUSBDEVICE pFirst = NULL;
     FILE *pFile = NULL;
-    int rc;
-    rc = usbfsOpenDevicesFile(pszUsbfsRoot, &pFile);
-    if (RT_SUCCESS(rc))
+    int vrc = usbfsOpenDevicesFile(pszUsbfsRoot, &pFile);
+    if (RT_SUCCESS(vrc))
     {
         PUSBDEVICE     *ppNext = NULL;
@@ -547 +546 @@
 
         /* Set close on exit and hope no one is racing us. */
-        rc = fcntl(fileno(pFile), F_SETFD, FD_CLOEXEC) >= 0
-           ? VINF_SUCCESS
-           : RTErrConvertFromErrno(errno);
-        while (     RT_SUCCESS(rc)
-               &&   fgets(szLine, sizeof(szLine), pFile))
+        vrc = fcntl(fileno(pFile), F_SETFD, FD_CLOEXEC) >= 0
+            ? VINF_SUCCESS
+            : RTErrConvertFromErrno(errno);
+        while (   RT_SUCCESS(vrc)
+               && fgets(szLine, sizeof(szLine), pFile))
         {
             char   *psz;
@@ -596 +595 @@
                     AssertMsg(cHits >= 3 || cHits == 0, ("cHits=%d\n", cHits));
                     if (cHits >= 3)
-                        rc = usbfsAddDeviceToChain(&Dev, &pFirst, &ppNext, pszUsbfsRoot, fUnsupportedDevicesToo, rc);
+                        vrc = usbfsAddDeviceToChain(&Dev, &pFirst, &ppNext, pszUsbfsRoot, fUnsupportedDevicesToo, vrc);
                     else
                         deviceFreeMembers(&Dev);
@@ -606 +605 @@
 
                     /* parse the line. */
-                    while (*psz && RT_SUCCESS(rc))
+                    while (*psz && RT_SUCCESS(vrc))
                     {
                         if (PREFIX("Bus="))
-                            rc = usbfsRead8(pszValue, 10, &Dev.bBus, &psz);
+                            vrc = usbfsRead8(pszValue, 10, &Dev.bBus, &psz);
                         else if (PREFIX("Port="))
-                            rc = usbfsRead8(pszValue, 10, &Dev.bPort, &psz);
+                            vrc = usbfsRead8(pszValue, 10, &Dev.bPort, &psz);
                         else if (PREFIX("Spd="))
-                            rc = usbfsReadSpeed(pszValue, &Dev.enmSpeed, &psz);
+                            vrc = usbfsReadSpeed(pszValue, &Dev.enmSpeed, &psz);
                         else if (PREFIX("Dev#="))
-                            rc = usbfsRead8(pszValue, 10, &Dev.bDevNum, &psz);
+                            vrc = usbfsRead8(pszValue, 10, &Dev.bDevNum, &psz);
                         else
                             psz = usbfsReadSkip(psz);
@@ -644 +643 @@
                  */
                 case 'D':
-                    while (*psz && RT_SUCCESS(rc))
+                    while (*psz && RT_SUCCESS(vrc))
                     {
                         if (PREFIX("Ver="))
-                            rc = usbfsReadBCD(pszValue, 16, &Dev.bcdUSB, &psz);
+                            vrc = usbfsReadBCD(pszValue, 16, &Dev.bcdUSB, &psz);
                         else if (PREFIX("Cls="))
                         {
-                            rc = usbfsRead8(pszValue, 16, &Dev.bDeviceClass, &psz);
-                            if (RT_SUCCESS(rc) && Dev.bDeviceClass == 9 /* HUB */)
+                            vrc = usbfsRead8(pszValue, 16, &Dev.bDeviceClass, &psz);
+                            if (RT_SUCCESS(vrc) && Dev.bDeviceClass == 9 /* HUB */)
                                 Dev.enmState = USBDEVICESTATE_UNSUPPORTED;
                         }
                         else if (PREFIX("Sub="))
-                            rc = usbfsRead8(pszValue, 16, &Dev.bDeviceSubClass, &psz);
+                            vrc = usbfsRead8(pszValue, 16, &Dev.bDeviceSubClass, &psz);
                         else if (PREFIX("Prot="))
-                            rc = usbfsRead8(pszValue, 16, &Dev.bDeviceProtocol, &psz);
+                            vrc = usbfsRead8(pszValue, 16, &Dev.bDeviceProtocol, &psz);
                         //else if (PREFIX("MxPS="))
-                        //    rc = usbRead16(pszValue, 10, &Dev.wMaxPacketSize, &psz);
+                        //    vrc = usbRead16(pszValue, 10, &Dev.wMaxPacketSize, &psz);
                         else if (PREFIX("#Cfgs="))
-                            rc = usbfsRead8(pszValue, 10, &Dev.bNumConfigurations, &psz);
+                            vrc = usbfsRead8(pszValue, 10, &Dev.bNumConfigurations, &psz);
                         else
                             psz = usbfsReadSkip(psz);
@@ -677 +676 @@
                  */
                 case 'P':
-                    while (*psz && RT_SUCCESS(rc))
+                    while (*psz && RT_SUCCESS(vrc))
                     {
                         if (PREFIX("Vendor="))
-                            rc = usbfsRead16(pszValue, 16, &Dev.idVendor, &psz);
+                            vrc = usbfsRead16(pszValue, 16, &Dev.idVendor, &psz);
                         else if (PREFIX("ProdID="))
-                            rc = usbfsRead16(pszValue, 16, &Dev.idProduct, &psz);
+                            vrc = usbfsRead16(pszValue, 16, &Dev.idProduct, &psz);
                         else if (PREFIX("Rev="))
-                            rc = usbfsReadBCD(pszValue, 16, &Dev.bcdDevice, &psz);
+                            vrc = usbfsReadBCD(pszValue, 16, &Dev.bcdDevice, &psz);
                         else
                             psz = usbfsReadSkip(psz);
@@ -697 +696 @@
                 case 'S':
                     if (PREFIX("Manufacturer="))
-                        rc = usbfsReadStr(pszValue, &Dev.pszManufacturer);
+                        vrc = usbfsReadStr(pszValue, &Dev.pszManufacturer);
                     else if (PREFIX("Product="))
-                        rc = usbfsReadStr(pszValue, &Dev.pszProduct);
+                        vrc = usbfsReadStr(pszValue, &Dev.pszProduct);
                     else if (PREFIX("SerialNumber="))
                     {
-                        rc = usbfsReadStr(pszValue, &Dev.pszSerialNumber);
-                        if (RT_SUCCESS(rc))
+                        vrc = usbfsReadStr(pszValue, &Dev.pszSerialNumber);
+                        if (RT_SUCCESS(vrc))
                             Dev.u64SerialHash = USBLibHashSerial(pszValue);
                     }
@@ -735 +734 @@
                 {
                     /* Check for thing we don't support.  */
-                    while (*psz && RT_SUCCESS(rc))
+                    while (*psz && RT_SUCCESS(vrc))
                     {
                         if (PREFIX("Driver="))
                         {
                             const char *pszDriver = NULL;
-                            rc = usbfsReadStr(pszValue, &pszDriver);
+                            vrc = usbfsReadStr(pszValue, &pszDriver);
                             if (   !pszDriver
                                 || !*pszDriver
@@ -756 +755 @@
                         {
                             uint8_t bInterfaceClass;
-                            rc = usbfsRead8(pszValue, 16, &bInterfaceClass, &psz);
-                            if (RT_SUCCESS(rc) && bInterfaceClass == 9 /* HUB */)
+                            vrc = usbfsRead8(pszValue, 16, &bInterfaceClass, &psz);
+                            if (RT_SUCCESS(vrc) && bInterfaceClass == 9 /* HUB */)
                                 Dev.enmState = USBDEVICESTATE_UNSUPPORTED;
                         }
@@ -789 +788 @@
         AssertMsg(cHits >= 3 || cHits == 0, ("cHits=%d\n", cHits));
         if (cHits >= 3)
-            rc = usbfsAddDeviceToChain(&Dev, &pFirst, &ppNext, pszUsbfsRoot, fUnsupportedDevicesToo, rc);
+            vrc = usbfsAddDeviceToChain(&Dev, &pFirst, &ppNext, pszUsbfsRoot, fUnsupportedDevicesToo, vrc);
 
         /*
          * Success?
          */
-        if (RT_FAILURE(rc))
+        if (RT_FAILURE(vrc))
         {
             while (pFirst)
@@ -804 +803 @@
         }
     }
-    if (RT_FAILURE(rc))
-        LogFlow(("USBProxyServiceLinux::getDevices: rc=%Rrc\n", rc));
+    if (RT_FAILURE(vrc))
+        LogFlow(("USBProxyServiceLinux::getDevices: vrc=%Rrc\n", vrc));
     return pFirst;
 }
@@ -892 +891 @@
 
     int64_t device;
-    int rc = RTLinuxSysFsReadIntFile(10, &device, "%s/devnum", pszNode);
-    if (RT_FAILURE(rc))
+    int vrc = RTLinuxSysFsReadIntFile(10, &device, "%s/devnum", pszNode);
+    if (RT_FAILURE(vrc))
         return VINF_SUCCESS;
 
@@ -901 +900 @@
 
     char szDevPath[RTPATH_MAX];
-    rc = RTLinuxCheckDevicePath(devnum, RTFS_TYPE_DEV_CHAR,
-                                szDevPath, sizeof(szDevPath),
-                                "%s/%.3d/%.3d",
-                                pszDevicesRoot, bus, device);
-    if (RT_FAILURE(rc))
+    vrc = RTLinuxCheckDevicePath(devnum, RTFS_TYPE_DEV_CHAR, szDevPath, sizeof(szDevPath),
+                                 "%s/%.3d/%.3d", pszDevicesRoot, bus, device);
+    if (RT_FAILURE(vrc))
         return VINF_SUCCESS;
 
@@ -911 +908 @@
     if (usbsysfsInitDevInfo(&info, szDevPath, pszNode))
     {
-        rc = VEC_PUSH_BACK_OBJ(pvecDevInfo, USBDeviceInfo, &info);
-        if (RT_SUCCESS(rc))
+        vrc = VEC_PUSH_BACK_OBJ(pvecDevInfo, USBDeviceInfo, &info);
+        if (RT_SUCCESS(vrc))
             return VINF_SUCCESS;
     }
@@ -991 +988 @@
     if (pszDup)
     {
-        int rc = VEC_PUSH_BACK_PTR(&pInfo->mvecpszInterfaces, char *, pszDup);
-        if (RT_SUCCESS(rc))
+        int vrc = VEC_PUSH_BACK_PTR(&pInfo->mvecpszInterfaces, char *, pszDup);
+        if (RT_SUCCESS(vrc))
             return VINF_SUCCESS;
         RTStrFree(pszDup);
@@ -1010 +1007 @@
 {
     struct dirent entry, *pResult;
-    int err, rc;
+    int err;
 
 #if RT_GNUC_PREREQ(4, 6)
@@ -1033 +1030 @@
         if (!pszPathCopy)
             return VERR_NO_MEMORY;
-        if (RT_FAILURE(rc = VEC_PUSH_BACK_PTR(pvecpchDevs, char *, pszPathCopy)))
-            return rc;
+        int vrc = VEC_PUSH_BACK_PTR(pvecpchDevs, char *, pszPathCopy);
+        if (RT_FAILURE(vrc))
+            return vrc;
     }
     return RTErrConvertFromErrno(err);
@@ -1058 +1056 @@
     if (!pDir)
         return RTErrConvertFromErrno(errno);
-    int rc = usbsysfsReadFilePathsFromDir(pszPath, pDir, pvecpchDevs);
-    if (closedir(pDir) < 0 && RT_SUCCESS(rc))
-        rc = RTErrConvertFromErrno(errno);
-    return rc;
+    int vrc = usbsysfsReadFilePathsFromDir(pszPath, pDir, pvecpchDevs);
+    if (closedir(pDir) < 0 && RT_SUCCESS(vrc))
+        vrc = RTErrConvertFromErrno(errno);
+    return vrc;
 }
 
@@ -1081 +1079 @@
     LogFlowFunc (("pvecDevInfo=%p\n", pvecDevInfo));
 
-    int rc = usbsysfsReadFilePaths("/sys/bus/usb/devices", pvecpchDevs);
-    if (RT_FAILURE(rc))
-        return rc;
+    int vrc = usbsysfsReadFilePaths("/sys/bus/usb/devices", pvecpchDevs);
+    if (RT_FAILURE(vrc))
+        return vrc;
 
     char **ppszEntry;
     VEC_FOR_EACH(pvecpchDevs, char *, ppszEntry)
     {
-        rc = usbsysfsAddIfDevice(pszDevicesRoot, *ppszEntry, pvecDevInfo);
-        if (RT_FAILURE(rc))
-            return rc;
+        vrc = usbsysfsAddIfDevice(pszDevicesRoot, *ppszEntry, pvecDevInfo);
+        if (RT_FAILURE(vrc))
+            return vrc;
     }
 
@@ -1097 +1095 @@
         VEC_FOR_EACH(pvecpchDevs, char *, ppszEntry)
         {
-            rc = usbsysfsAddIfInterfaceOf(*ppszEntry, pInfo);
-            if (RT_FAILURE(rc))
-                return rc;
+            vrc = usbsysfsAddIfInterfaceOf(*ppszEntry, pInfo);
+            if (RT_FAILURE(vrc))
+                return vrc;
         }
     return VINF_SUCCESS;
@@ -1112 +1110 @@
     LogFlowFunc(("entered\n"));
     VEC_INIT_PTR(&vecpchDevs, char *, RTStrFree);
-    int rc = usbsysfsEnumerateHostDevicesWorker(pszDevicesRoot, pvecDevInfo, &vecpchDevs);
+    int vrc = usbsysfsEnumerateHostDevicesWorker(pszDevicesRoot, pvecDevInfo, &vecpchDevs);
     VEC_CLEANUP_PTR(&vecpchDevs);
-    LogFlowFunc(("rc=%Rrc\n", rc));
-    return rc;
+    LogFlowFunc(("vrc=%Rrc\n", vrc));
+    return vrc;
 }
 
@@ -1185 +1183 @@
                             ? pchDot  + 1
                             : pchDash + 1;
-    int rc = RTStrToUInt8Full(pszLastPort, 10, pu8Port);
-    if (rc != VINF_SUCCESS)
-    {
-        Log(("usbGetPortFromSysfsPath(%s): failed [3], rc=%Rrc\n", pszPath, rc));
+    int vrc = RTStrToUInt8Full(pszLastPort, 10, pu8Port);
+    if (vrc != VINF_SUCCESS)
+    {
+        Log(("usbGetPortFromSysfsPath(%s): failed [3], vrc=%Rrc\n", pszPath, vrc));
         return VERR_INVALID_PARAMETER;
     }
@@ -1219 +1217 @@
 
     pszBuf = RTStrStripL(pszBuf);
-    int rc = RTStrToInt32Ex(pszBuf, &pszNext, 16, &i32);
-    if (   RT_FAILURE(rc)
-        || rc == VWRN_NUMBER_TOO_BIG
+    int vrc = RTStrToInt32Ex(pszBuf, &pszNext, 16, &i32);
+    if (   RT_FAILURE(vrc)
+        || vrc == VWRN_NUMBER_TOO_BIG
         || i32 < 0)
         return VERR_NUMBER_TOO_BIG;
@@ -1229 +1227 @@
             return VERR_NUMBER_TOO_BIG;
         int32_t i32Lo;
-        rc = RTStrToInt32Ex(pszNext+1, &pszNext, 16, &i32Lo);
-        if (   RT_FAILURE(rc)
-            || rc == VWRN_NUMBER_TOO_BIG
+        vrc = RTStrToInt32Ex(pszNext+1, &pszNext, 16, &i32Lo);
+        if (   RT_FAILURE(vrc)
+            || vrc == VWRN_NUMBER_TOO_BIG
             || i32Lo > 255
             || i32Lo < 0)
@@ -1252 +1250 @@
  * @returns uint8_t value of the given property.
  * @param   uBase       The base of the number in the sysfs property.
- * @param   bDef        The default to set on error.
+ * @param   fDef        The default to set on error.
  * @param   pszFormat   The format string for the property.
  * @param   ...         Arguments for the format string.
  */
-static uint8_t usbsysfsReadDevicePropertyU8Def(unsigned uBase, uint8_t bDef, const char *pszFormat, ...)
+static uint8_t usbsysfsReadDevicePropertyU8Def(unsigned uBase, uint8_t fDef, const char *pszFormat, ...)
 {
     int64_t i64Tmp = 0;
@@ -1262 +1260 @@
     va_list va;
     va_start(va, pszFormat);
-    int rc = RTLinuxSysFsReadIntFileV(uBase, &i64Tmp, pszFormat, va);
+    int vrc = RTLinuxSysFsReadIntFileV(uBase, &i64Tmp, pszFormat, va);
     va_end(va);
-    if (RT_SUCCESS(rc))
+    if (RT_SUCCESS(vrc))
         return (uint8_t)i64Tmp;
-    else
-        return bDef;
+    return fDef;
 }
 
@@ -1287 +1284 @@
     va_list va;
     va_start(va, pszFormat);
-    int rc = RTLinuxSysFsReadIntFileV(uBase, &i64Tmp, pszFormat, va);
+    int vrc = RTLinuxSysFsReadIntFileV(uBase, &i64Tmp, pszFormat, va);
     va_end(va);
-    if (RT_SUCCESS(rc))
+    if (RT_SUCCESS(vrc))
         return (uint16_t)i64Tmp;
-    else
-        return u16Def;
+    return u16Def;
 }
 
@@ -1298 +1294 @@
 static void usbsysfsFillInDevice(USBDEVICE *pDev, USBDeviceInfo *pInfo)
 {
-    int rc;
+    int vrc;
     const char *pszSysfsPath = pInfo->mSysfsPath;
 
@@ -1319 +1315 @@
 
     /* For simplicity, we just do strcmps on the next one. */
-    rc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/speed", pszSysfsPath);
-    if (RT_FAILURE(rc) || cchRead == sizeof(szBuf))
+    vrc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/speed", pszSysfsPath);
+    if (RT_FAILURE(vrc) || cchRead == sizeof(szBuf))
         pDev->enmState = USBDEVICESTATE_UNSUPPORTED;
     else
@@ -1329 +1325 @@
                        : USBDEVICESPEED_UNKNOWN;
 
-    rc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/version", pszSysfsPath);
-    if (RT_FAILURE(rc) || cchRead == sizeof(szBuf))
+    vrc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/version", pszSysfsPath);
+    if (RT_FAILURE(vrc) || cchRead == sizeof(szBuf))
         pDev->enmState = USBDEVICESTATE_UNSUPPORTED;
     else
     {
-        rc = usbsysfsConvertStrToBCD(szBuf, &pDev->bcdUSB);
-        if (RT_FAILURE(rc))
+        vrc = usbsysfsConvertStrToBCD(szBuf, &pDev->bcdUSB);
+        if (RT_FAILURE(vrc))
         {
             pDev->enmState = USBDEVICESTATE_UNSUPPORTED;
@@ -1342 +1338 @@
     }
 
-    rc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/bcdDevice", pszSysfsPath);
-    if (RT_FAILURE(rc) || cchRead == sizeof(szBuf))
+    vrc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/bcdDevice", pszSysfsPath);
+    if (RT_FAILURE(vrc) || cchRead == sizeof(szBuf))
         pDev->bcdDevice = UINT16_MAX;
     else
     {
-        rc = usbsysfsConvertStrToBCD(szBuf, &pDev->bcdDevice);
-        if (RT_FAILURE(rc))
+        vrc = usbsysfsConvertStrToBCD(szBuf, &pDev->bcdDevice);
+        if (RT_FAILURE(vrc))
             pDev->bcdDevice = UINT16_MAX;
     }
 
     /* Now do things that need string duplication */
-    rc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/product", pszSysfsPath);
-    if (RT_SUCCESS(rc) && cchRead < sizeof(szBuf))
+    vrc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/product", pszSysfsPath);
+    if (RT_SUCCESS(vrc) && cchRead < sizeof(szBuf))
     {
         USBLibPurgeEncoding(szBuf);
@@ -1360 +1356 @@
     }
 
-    rc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/serial", pszSysfsPath);
-    if (RT_SUCCESS(rc) && cchRead < sizeof(szBuf))
+    vrc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/serial", pszSysfsPath);
+    if (RT_SUCCESS(vrc) && cchRead < sizeof(szBuf))
     {
         USBLibPurgeEncoding(szBuf);
@@ -1368 +1364 @@
     }
 
-    rc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/manufacturer", pszSysfsPath);
-    if (RT_SUCCESS(rc) && cchRead < sizeof(szBuf))
+    vrc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/manufacturer", pszSysfsPath);
+    if (RT_SUCCESS(vrc) && cchRead < sizeof(szBuf))
     {
         USBLibPurgeEncoding(szBuf);
@@ -1383 +1379 @@
     VEC_FOR_EACH(&pInfo->mvecpszInterfaces, char *, ppszIf)
     {
-        rc = RTLinuxSysFsGetLinkDest(szBuf, sizeof(szBuf), NULL, "%s/driver", *ppszIf);
-        if (RT_SUCCESS(rc) && pDev->enmState != USBDEVICESTATE_UNSUPPORTED)
+        vrc = RTLinuxSysFsGetLinkDest(szBuf, sizeof(szBuf), NULL, "%s/driver", *ppszIf);
+        if (RT_SUCCESS(vrc) && pDev->enmState != USBDEVICESTATE_UNSUPPORTED)
             pDev->enmState = (strcmp(szBuf, "hub") == 0)
                            ? USBDEVICESTATE_UNSUPPORTED
@@ -1416 +1412 @@
     VECTOR_OBJ(USBDeviceInfo) vecDevInfo;
     USBDeviceInfo *pInfo;
-    int rc;
 
     VEC_INIT_OBJ(&vecDevInfo, USBDeviceInfo, usbsysfsCleanupDevInfo);
-    rc = usbsysfsEnumerateHostDevices(pszDevicesRoot, &vecDevInfo);
-    if (RT_FAILURE(rc))
+    int vrc = usbsysfsEnumerateHostDevices(pszDevicesRoot, &vecDevInfo);
+    if (RT_FAILURE(vrc))
         return NULL;
     VEC_FOR_EACH(&vecDevInfo, USBDeviceInfo, pInfo)
@@ -1426 +1421 @@
         USBDEVICE *pDev = (USBDEVICE *)RTMemAllocZ(sizeof(USBDEVICE));
         if (!pDev)
-            rc = VERR_NO_MEMORY;
-        if (RT_SUCCESS(rc))
+            vrc = VERR_NO_MEMORY;
+        if (RT_SUCCESS(vrc))
             usbsysfsFillInDevice(pDev, pInfo);
-        if (   RT_SUCCESS(rc)
+        if (   RT_SUCCESS(vrc)
             && (   pDev->enmState != USBDEVICESTATE_UNSUPPORTED
                 || fUnsupportedDevicesToo)
@@ -1445 +1440 @@
         else
             deviceFree(pDev);
-        if (RT_FAILURE(rc))
+        if (RT_FAILURE(vrc))
             break;
     }
-    if (RT_FAILURE(rc))
+    if (RT_FAILURE(vrc))
         deviceListFree(&pFirst);
 

trunk/src/VBox/Main/src-server/linux/USBProxyBackendLinux.cpp

@@ -99 +99 @@
 
     const char *pcszDevicesRoot;
-    int rc = USBProxyLinuxChooseMethod(&mUsingUsbfsDevices, &pcszDevicesRoot);
-    if (RT_SUCCESS(rc))
+    int vrc = USBProxyLinuxChooseMethod(&mUsingUsbfsDevices, &pcszDevicesRoot);
+    if (RT_SUCCESS(vrc))
     {
         mDevicesRoot = pcszDevicesRoot;
-        rc = mUsingUsbfsDevices ? initUsbfs() : initSysfs();
+        vrc = mUsingUsbfsDevices ? initUsbfs() : initSysfs();
         /* For the day when we have VBoxSVC release logging... */
-        LogRel((RT_SUCCESS(rc) ? "Successfully initialised host USB using %s\n"
-                               : "Failed to initialise host USB using %s\n",
+        LogRel((RT_SUCCESS(vrc) ? "Successfully initialised host USB using %s\n"
+                                : "Failed to initialise host USB using %s\n",
                 mUsingUsbfsDevices ? "USBFS" : "sysfs"));
     }
 
-    return rc;
+    return vrc;
 }
 
@@ -146 +146 @@
      * Open the devices file.
      */
-    int rc;
+    int vrc;
     char *pszDevices = RTPathJoinA(mDevicesRoot.c_str(), "devices");
     if (pszDevices)
     {
-        rc = RTFileOpen(&mhFile, pszDevices, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
-        if (RT_SUCCESS(rc))
+        vrc = RTFileOpen(&mhFile, pszDevices, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
+        if (RT_SUCCESS(vrc))
         {
-            rc = RTPipeCreate(&mhWakeupPipeR, &mhWakeupPipeW, 0 /*fFlags*/);
-            if (RT_SUCCESS(rc))
+            vrc = RTPipeCreate(&mhWakeupPipeR, &mhWakeupPipeW, 0 /*fFlags*/);
+            if (RT_SUCCESS(vrc))
             {
                 /*
                  * Start the poller thread.
                  */
-                rc = start();
-                if (RT_SUCCESS(rc))
+                vrc = start();
+                if (RT_SUCCESS(vrc))
                 {
                     RTStrFree(pszDevices);
@@ -172 +172 @@
             }
             else
-                Log(("USBProxyBackendLinux::USBProxyBackendLinux: RTFilePipe failed with rc=%Rrc\n", rc));
+                Log(("USBProxyBackendLinux::USBProxyBackendLinux: RTFilePipe failed with vrc=%Rrc\n", vrc));
             RTFileClose(mhFile);
         }
@@ -180 +180 @@
     else
     {
-        rc = VERR_NO_MEMORY;
+        vrc = VERR_NO_MEMORY;
         Log(("USBProxyBackendLinux::USBProxyBackendLinux: out of memory!\n"));
     }
 
-    LogFlowThisFunc(("returns failure!!! (rc=%Rrc)\n", rc));
-    return rc;
+    LogFlowThisFunc(("returns failure!!! (vrc=%Rrc)\n", vrc));
+    return vrc;
 }
 
@@ -207 +207 @@
         return VERR_NO_MEMORY;
     }
-    int rc = mpWaiter->getStatus();
-    if (RT_SUCCESS(rc) || rc == VERR_TIMEOUT || rc == VERR_TRY_AGAIN)
-        rc = start();
-    else if (rc == VERR_NOT_SUPPORTED)
+    int vrc = mpWaiter->getStatus();
+    if (RT_SUCCESS(vrc) || vrc == VERR_TIMEOUT || vrc == VERR_TRY_AGAIN)
+        vrc = start();
+    else if (vrc == VERR_NOT_SUPPORTED)
         /* This can legitimately happen if hal or DBus are not running, but of
          * course we can't start in this case. */
-        rc = VINF_SUCCESS;
-    return rc;
+        vrc = VINF_SUCCESS;
+    return vrc;
 
 #else  /* !VBOX_USB_WITH_SYSFS */
@@ -307 +307 @@
 int USBProxyBackendLinux::wait(RTMSINTERVAL aMillies)
 {
-    int rc;
+    int vrc;
     if (mUsingUsbfsDevices)
-        rc = waitUsbfs(aMillies);
+        vrc = waitUsbfs(aMillies);
     else
-        rc = waitSysfs(aMillies);
-    return rc;
+        vrc = waitSysfs(aMillies);
+    return vrc;
 }
 
@@ -338 +338 @@
     PollFds[1].events    = POLLIN | POLLERR | POLLHUP;
 
-    int rc = poll(&PollFds[0], 2, aMillies);
-    if (rc == 0)
+    int iRc = poll(&PollFds[0], 2, aMillies);
+    if (iRc == 0)
         return VERR_TIMEOUT;
-    if (rc > 0)
+    if (iRc > 0)
     {
         /* drain the pipe */
@@ -347 +347 @@
         {
             char szBuf[WAKE_UP_STRING_LEN];
-            rc = RTPipeReadBlocking(mhWakeupPipeR, szBuf, sizeof(szBuf), NULL);
-            AssertRC(rc);
+            int vrc2 = RTPipeReadBlocking(mhWakeupPipeR, szBuf, sizeof(szBuf), NULL);
+            AssertRC(vrc2);
         }
         return VINF_SUCCESS;
@@ -359 +359 @@
 {
 #ifdef VBOX_USB_WITH_SYSFS
-    int rc = mpWaiter->Wait(aMillies);
-    if (rc == VERR_TRY_AGAIN)
+    int vrc = mpWaiter->Wait(aMillies);
+    if (vrc == VERR_TRY_AGAIN)
     {
         RTThreadYield();
-        rc = VINF_SUCCESS;
-    }
-    return rc;
+        vrc = VINF_SUCCESS;
+    }
+    return vrc;
 #else  /* !VBOX_USB_WITH_SYSFS */
     return USBProxyService::wait(aMillies);
@@ -386 +386 @@
     }
 #endif /* VBOX_USB_WITH_SYSFS */
-    int rc = RTPipeWriteBlocking(mhWakeupPipeW, WAKE_UP_STRING, WAKE_UP_STRING_LEN, NULL);
-    if (RT_SUCCESS(rc))
+    int vrc = RTPipeWriteBlocking(mhWakeupPipeW, WAKE_UP_STRING, WAKE_UP_STRING_LEN, NULL);
+    if (RT_SUCCESS(vrc))
         RTPipeFlush(mhWakeupPipeW);
-    LogFlowFunc(("returning %Rrc\n", rc));
-    return rc;
+    LogFlowFunc(("returning %Rrc\n", vrc));
+    return vrc;
 }