Changeset 43507 in vbox for trunk/src/VBox

Timestamp:

Oct 2, 2012 1:22:31 PM (12 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

81089

Message:

Main/Metrics: Alternative way to get link speed for old kernels (#6345)

Location:

trunk/src/VBox/Main

Files:

• include/HostNetworkInterfaceImpl.h (modified) (1 diff)
• include/Performance.h (modified) (3 diffs)
• include/netif.h (modified) (2 diffs)
• src-server/HostNetworkInterfaceImpl.cpp (modified) (3 diffs)
• src-server/Performance.cpp (modified) (6 diffs)
• src-server/generic/NetIf-generic.cpp (modified) (1 diff)
• src-server/linux/NetIf-linux.cpp (modified) (1 diff)
• src-server/linux/PerformanceLinux.cpp (modified) (3 diffs)
• testcase/tstCollector.cpp (modified) (4 diffs)

trunk/src/VBox/Main/include/HostNetworkInterfaceImpl.h

@@ -110 +110 @@
         HostNetworkInterfaceMediumType_T mediumType;
         HostNetworkInterfaceStatus_T status;
+        ULONG speedMbytes;
     } m;
 

trunk/src/VBox/Main/include/Performance.h

@@ -361 +361 @@
         /** Returns CPU usage counters in platform-specific units. */
         virtual int getRawHostCpuLoad(uint64_t *user, uint64_t *kernel, uint64_t *idle);
-        /** Returns received and transmitted bytes as well as link speed. */
-        virtual int getRawHostNetworkLoad(const char *name, uint64_t *rx, uint64_t *tx, uint64_t *speed);
+        /** Returns received and transmitted bytes. */
+        virtual int getRawHostNetworkLoad(const char *name, uint64_t *rx, uint64_t *tx);
         /** Returns process' CPU usage counter in platform-specific units. */
         virtual int getRawProcessCpuLoad(RTPROCESS process, uint64_t *user, uint64_t *kernel, uint64_t *total);
@@ -496 +496 @@
     {
     public:
-        HostNetworkLoadRaw(CollectorHAL *hal, ComPtr<IUnknown> object, com::Utf8Str name, com::Utf8Str ifname, SubMetric *rx, SubMetric *tx)
-            : BaseMetric(hal, name, object), mInterfaceName(ifname), mRx(rx), mTx(tx), mRxPrev(0), mTxPrev(0), mRc(VINF_SUCCESS) {};
+        HostNetworkLoadRaw(CollectorHAL *hal, ComPtr<IUnknown> object, com::Utf8Str name, com::Utf8Str ifname, uint32_t speed, SubMetric *rx, SubMetric *tx)
+            : BaseMetric(hal, name, object), mInterfaceName(ifname), mRx(rx), mTx(tx), mRxPrev(0), mTxPrev(0), mRc(VINF_SUCCESS) { mSpeed = (uint64_t)speed * (1000000/8); /* Convert to bytes/sec */ };
         ~HostNetworkLoadRaw() { delete mRx; delete mTx; };
 
@@ -515 +515 @@
         uint64_t      mRxPrev;
         uint64_t      mTxPrev;
+        uint64_t      mSpeed;
         int           mRc;
     };

trunk/src/VBox/Main/include/netif.h

@@ -72 +72 @@
     NETIFTYPE      enmMediumType;
     NETIFSTATUS    enmStatus;
+    uint32_t       uSpeedMbytes;
     RTUUID         Uuid;
     char           szShortName[VBOXNET_MAX_SHORT_NAME];
@@ -92 +93 @@
 int NetIfGetConfigByName(PNETIFINFO pInfo);
 int NetIfDhcpRediscover(VirtualBox *pVbox, HostNetworkInterface * pIf);
+int NetIfAdpCtlOut(const char * pcszName, const char * pcszCmd, char *pszBuffer, size_t cBufSize);
 
 DECLINLINE(Bstr) composeIPv6Address(PRTNETADDRIPV6 aAddrPtr)

trunk/src/VBox/Main/src-server/HostNetworkInterfaceImpl.cpp

@@ -100 +100 @@
 
     /* Create and register base metrics */
-    pm::BaseMetric *networkLoad = new pm::HostNetworkLoadRaw(hal, objptr, strName, Utf8Str(mInterfaceName), networkLoadRx, networkLoadTx);
+    pm::BaseMetric *networkLoad = new pm::HostNetworkLoadRaw(hal, objptr, strName, Utf8Str(mInterfaceName), m.speedMbytes, networkLoadRx, networkLoadTx);
     aCollector->registerBaseMetric(networkLoad);
 
@@ -149 +149 @@
         m.mediumType = info.enmMediumType;
         m.status = info.enmStatus;
-
 #endif /* !RT_OS_WINDOWS */
+        m.speedMbytes = info.uSpeedMbytes;
         return S_OK;
     }
@@ -201 +201 @@
     m.status = pIf->enmStatus;
 #endif /* !RT_OS_WINDOWS */
+    m.speedMbytes = pIf->uSpeedMbytes;
 
     /* Confirm a successful initialization */

trunk/src/VBox/Main/src-server/Performance.cpp

@@ -59 +59 @@
 }
 
-int CollectorHAL::getRawHostNetworkLoad(const char * /* name */, uint64_t * /* rx */, uint64_t * /* tx */, uint64_t */* speed */)
+int CollectorHAL::getRawHostNetworkLoad(const char * /* name */, uint64_t * /* rx */, uint64_t * /* tx */)
 {
     return E_NOTIMPL;
@@ -656 +656 @@
     mRx->init(mLength);
     mTx->init(mLength);
-    uint64_t speed;
-    int rc = mHAL->getRawHostNetworkLoad(mInterfaceName.c_str(), &mRxPrev, &mTxPrev, &speed);
+    int rc = mHAL->getRawHostNetworkLoad(mInterfaceName.c_str(), &mRxPrev, &mTxPrev);
     AssertRC(rc);
 }
@@ -670 +669 @@
         if (SUCCEEDED(hrc))
         {
-            LogRel(("Failed to collect network metrics for %s: %Rrc (%d).", mInterfaceName.c_str(), mRc, mRc));
+            LogRel(("Failed to collect network metrics for %s: %Rrc (%d).\n", mInterfaceName.c_str(), mRc, mRc));
             mRc = VINF_SUCCESS;
         }
@@ -678 +677 @@
 void HostNetworkLoadRaw::collect()
 {
-    uint64_t rx, tx, speed;
-
-    mRc = mHAL->getRawHostNetworkLoad(mInterfaceName.c_str(), &rx, &tx, &speed);
+    uint64_t rx, tx;
+
+    mRc = mHAL->getRawHostNetworkLoad(mInterfaceName.c_str(), &rx, &tx);
     if (RT_SUCCESS(mRc))
     {
@@ -686 +685 @@
         uint64_t txDiff = tx - mTxPrev;
 
-        if (RT_UNLIKELY(speed * getPeriod() == 0))
-        {
-            Assert(speed * getPeriod());
-            LogFlowThisFunc(("Impossible! speed=%llu period=%d.\n", speed, getPeriod()));
+        if (RT_UNLIKELY(mSpeed * getPeriod() == 0))
+        {
+            Assert(mSpeed * getPeriod());
+            LogFlowThisFunc(("Impossible! speed=%llu period=%d.\n", mSpeed, getPeriod()));
             mRx->put(0);
             mTx->put(0);
@@ -695 +694 @@
         else
         {
-            mRx->put((ULONG)(PM_NETWORK_LOAD_MULTIPLIER * rxDiff / (speed * getPeriod())));
-            mTx->put((ULONG)(PM_NETWORK_LOAD_MULTIPLIER * txDiff / (speed * getPeriod())));
+            mRx->put((ULONG)(PM_NETWORK_LOAD_MULTIPLIER * rxDiff / (mSpeed * getPeriod())));
+            mTx->put((ULONG)(PM_NETWORK_LOAD_MULTIPLIER * txDiff / (mSpeed * getPeriod())));
         }
 

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

@@ -77 +77 @@
     Utf8Str strName(interfaceName);
     return NetIfAdpCtl(strName.c_str(), pszAddr, pszOption, pszMask);
+}
+
+int NetIfAdpCtlOut(const char * pcszName, const char * pcszCmd, char *pszBuffer, size_t cBufSize)
+{
+    char szAdpCtl[RTPATH_MAX];
+    int rc = RTPathExecDir(szAdpCtl, sizeof(szAdpCtl) - sizeof("/" VBOXNETADPCTL_NAME " ") - strlen(pcszCmd));
+    if (RT_FAILURE(rc))
+    {
+        LogRel(("NetIfAdpCtlStream: Failed to get program path, rc=%Rrc\n", rc));
+        return VERR_INVALID_PARAMETER;
+    }
+    strcat(szAdpCtl, "/" VBOXNETADPCTL_NAME " ");
+    if (pcszName && strlen(pcszName) <= RTPATH_MAX - strlen(szAdpCtl) - 1 - strlen(pcszCmd))
+    {
+        strcat(szAdpCtl, pcszName);
+        strcat(szAdpCtl, " ");
+        strcat(szAdpCtl, pcszCmd);
+    }
+    else
+    {
+        LogRel(("NetIfAdpCtlStream: Command line is too long: %s%s %s\n", szAdpCtl, pcszName, pcszCmd));
+        return VERR_INVALID_PARAMETER;
+    }
+    if (strlen(szAdpCtl) < RTPATH_MAX - sizeof(" 2>&1"))
+        strcat(szAdpCtl, " 2>&1");
+    FILE *fp = popen(szAdpCtl, "r");
+    if (fp)
+    {
+        if (fgets(pszBuffer, cBufSize, fp))
+        {
+            if (!strncmp(VBOXNETADPCTL_NAME ":", pszBuffer, sizeof(VBOXNETADPCTL_NAME)))
+            {
+                LogRel(("NetIfAdpCtlStream: %s", pszBuffer));
+                rc = VERR_INTERNAL_ERROR;
+            }
+        }
+        else
+        {
+            LogRel(("NetIfAdpCtlStream: No output from " VBOXNETADPCTL_NAME));
+            rc = VERR_INTERNAL_ERROR;
+        }
+        pclose(fp);
+    }
+    return rc;
 }
 

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

@@ -149 +149 @@
             fclose(fp);
         }
+        /*
+         * I wish I could do simple ioctl here, but older kernels require root
+         * privileges for any ethtool commands.
+         */
+        char szBuf[256];
+        /* First, we try to retrieve the speed via sysfs. */
+        RTStrPrintf(szBuf, sizeof(szBuf), "/sys/class/net/%s/speed", pszName);
+        fp = fopen(szBuf, "r");
+        if (fp && fscanf(fp, "%u", &pInfo->uSpeedMbytes) == 1)
+            fclose(fp);
+        else
+        {
+            /* Failed to get speed via sysfs, go to plan B. */
+            int rc = NetIfAdpCtlOut(pszName, "info", szBuf, sizeof(szBuf));
+            if (RT_SUCCESS(rc))
+            {
+                pInfo->uSpeedMbytes = RTStrToUInt32(szBuf);
+            }
+            else
+                return rc;
+        }
     }
     return VINF_SUCCESS;

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

@@ -40 +40 @@
 
     virtual int getRawHostCpuLoad(uint64_t *user, uint64_t *kernel, uint64_t *idle);
-    virtual int getRawHostNetworkLoad(const char *name, uint64_t *rx, uint64_t *tx, uint64_t *speed);
+    virtual int getRawHostNetworkLoad(const char *name, uint64_t *rx, uint64_t *tx);
     virtual int getRawProcessCpuLoad(RTPROCESS process, uint64_t *user, uint64_t *kernel, uint64_t *total);
 private:
@@ -218 +218 @@
 }
 
-int CollectorLinux::getRawHostNetworkLoad(const char *name, uint64_t *rx, uint64_t *tx, uint64_t *speed)
+int CollectorLinux::getRawHostNetworkLoad(const char *name, uint64_t *rx, uint64_t *tx)
 {
     int rc = VINF_SUCCESS;
@@ -242 +242 @@
                 rc = VERR_FILE_IO_ERROR;
             fclose(f);
-            RTStrPrintf(szIfName, sizeof(szIfName), "/sys/class/net/%s/speed", name);
-            f = fopen(szIfName, "r");
-            if (f)
-            {
-                if (fscanf(f, "%llu", &u64Speed) == 1)
-                    *speed = u64Speed * (1000000/8); /* Convert to bytes/sec */
-                else
-                    rc = VERR_FILE_IO_ERROR;
-                fclose(f);
-            }
-            else
-                rc = VERR_ACCESS_DENIED;
         }
         else

trunk/src/VBox/Main/testcase/tstCollector.cpp

@@ -145 +145 @@
 {
     pm::CollectorHints hints;
-    uint64_t hostRxStart, hostTxStart, speedStart;
-    uint64_t hostRxStop, hostTxStop, speedStop;
+    uint64_t hostRxStart, hostTxStart;
+    uint64_t hostRxStop, hostTxStop, speed = 125000000; /* Assume 1Gbit/s */
 
     RTPrintf("\ntstCollector: TESTING - Network load, sleeping for 5 sec...\n");
@@ -156 +156 @@
         return 1;
     }
-    rc = collector->getRawHostNetworkLoad("eth0", &hostRxStart, &hostTxStart, &speedStart);
+    rc = collector->getRawHostNetworkLoad("eth0", &hostRxStart, &hostTxStart);
     if (RT_FAILURE(rc))
     {
@@ -171 +171 @@
         return 1;
     }
-    rc = collector->getRawHostNetworkLoad("eth0", &hostRxStop, &hostTxStop, &speedStop);
+    rc = collector->getRawHostNetworkLoad("eth0", &hostRxStop, &hostTxStop);
     if (RT_FAILURE(rc))
     {
@@ -177 +177 @@
         return 1;
     }
-    if (speedStart != speedStop)
-        RTPrintf("tstCollector: getRawHostNetworkLoad() returned different bandwidth (%llu != %llu)\n", speedStart, speedStop);
     RTPrintf("tstCollector: host network speed = %llu bytes/sec (%llu mbit/sec)\n",
-             speedStop, speedStop/(1000000/8));
+             speed, speed/(1000000/8));
     RTPrintf("tstCollector: host network rx    = %llu bytes/sec (%llu mbit/sec, %d %%*100)\n",
              (hostRxStop - hostRxStart)/5, (hostRxStop - hostRxStart)/(5000000/8),
-             (hostRxStop - hostRxStart) * 10000 / (speedStop * 5));
+             (hostRxStop - hostRxStart) * 10000 / (speed * 5));
     RTPrintf("tstCollector: host network tx    = %llu bytes/sec (%llu mbit/sec, %d %%*100)\n",
              (hostTxStop - hostTxStart)/5, (hostTxStop - hostTxStart)/(5000000/8),
-             (hostTxStop - hostTxStart) * 10000 / (speedStop * 5));
+             (hostTxStop - hostTxStart) * 10000 / (speed * 5));
 
     return 0;