Changeset 43445 in vbox for trunk/src/VBox/Main/src-server

Timestamp:

Sep 27, 2012 8:28:59 AM (12 years ago)

Author:

vboxsync

Message:

Main/Metrics: Host network metrics, linux only (#6345)

Location:

trunk/src/VBox/Main/src-server

Files:

• HostImpl.cpp (modified) (16 diffs)
• HostNetworkInterfaceImpl.cpp (modified) (3 diffs)
• Performance.cpp (modified) (4 diffs)
• PerformanceImpl.cpp (modified) (1 diff)
• linux/PerformanceLinux.cpp (modified) (2 diffs)

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

@@ -179 +179 @@
     VirtualBox              *pParent;
 
+    HostNetworkInterfaceList llNetIfs;                  // list of network interfaces
+
 #ifdef VBOX_WITH_USB
     USBDeviceFilterList     llChildren;                 // all USB device filters
@@ -272 +274 @@
     registerMetrics(aParent->performanceCollector());
 #endif /* VBOX_WITH_RESOURCE_USAGE_API */
+    /* Create the list of network interfaces so their metrics get registered. */
+    updateNetIfList();
 
 #if defined (RT_OS_WINDOWS)
@@ -437 +441 @@
 
 #ifdef VBOX_WITH_RESOURCE_USAGE_API
-    unregisterMetrics (m->pParent->performanceCollector());
+    PerformanceCollector *aCollector = m->pParent->performanceCollector();
+    unregisterMetrics (aCollector);
+    HostNetworkInterfaceList::iterator it;
+    for (it = m->llNetIfs.begin(); it != m->llNetIfs.end(); ++it)
+        (*it)->unregisterMetrics(aCollector, this);
 #endif /* VBOX_WITH_RESOURCE_USAGE_API */
+    m->llNetIfs.clear();
 
 #ifdef VBOX_WITH_USB
@@ -584 +593 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+# ifdef VBOX_WITH_HOSTNETIF_API
+    int rc = updateNetIfList();
+    if (rc)
+    {
+        Log(("Failed to get host network interface list with rc=%Rrc\n", rc));
+    }
+
+    SafeIfaceArray<IHostNetworkInterface> networkInterfaces (m->llNetIfs);
+    networkInterfaces.detachTo(ComSafeArrayOutArg(aNetworkInterfaces));
+
+    return S_OK;
+
+# else
     std::list<ComObjPtr<HostNetworkInterface> > list;
-
-# ifdef VBOX_WITH_HOSTNETIF_API
-    int rc = NetIfList(list);
-    if (rc)
-    {
-        Log(("Failed to get host network interface list with rc=%Rrc\n", rc));
-    }
-# else
 
 #  if defined(RT_OS_DARWIN)
@@ -739 +754 @@
     }
 #  endif /* RT_OS_LINUX */
-# endif
-
-    std::list <ComObjPtr<HostNetworkInterface> >::iterator it;
-    for (it = list.begin(); it != list.end(); ++it)
-    {
-        (*it)->setVirtualBox(m->pParent);
-    }
 
     SafeIfaceArray<IHostNetworkInterface> networkInterfaces (list);
@@ -752 +760 @@
     return S_OK;
 
+# endif
 #else
     /* Not implemented / supported on this platform. */
@@ -1391 +1400 @@
         return E_POINTER;
 
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
     *networkInterface = NULL;
     ComObjPtr<HostNetworkInterface> found;
-    std::list <ComObjPtr<HostNetworkInterface> > list;
-    int rc = NetIfList(list);
+    int rc = updateNetIfList();
     if (RT_FAILURE(rc))
     {
@@ -1400 +1410 @@
         return E_FAIL;
     }
-    std::list <ComObjPtr<HostNetworkInterface> >::iterator it;
-    for (it = list.begin(); it != list.end(); ++it)
+    HostNetworkInterfaceList::iterator it;
+    for (it = m->llNetIfs.begin(); it != m->llNetIfs.end(); ++it)
     {
         Bstr n;
@@ -1412 +1422 @@
         return setError(E_INVALIDARG,
                         HostNetworkInterface::tr("The host network interface with the given name could not be found"));
-
-    found->setVirtualBox(m->pParent);
 
     return found.queryInterfaceTo(networkInterface);
@@ -1429 +1437 @@
         return E_POINTER;
 
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
     *networkInterface = NULL;
     ComObjPtr<HostNetworkInterface> found;
-    std::list <ComObjPtr<HostNetworkInterface> > list;
-    int rc = NetIfList(list);
+    int rc = updateNetIfList();
     if (RT_FAILURE(rc))
     {
@@ -1438 +1447 @@
         return E_FAIL;
     }
-    std::list <ComObjPtr<HostNetworkInterface> >::iterator it;
-    for (it = list.begin(); it != list.end(); ++it)
+    HostNetworkInterfaceList::iterator it;
+    for (it = m->llNetIfs.begin(); it != m->llNetIfs.end(); ++it)
     {
         Bstr g;
@@ -1451 +1460 @@
                         HostNetworkInterface::tr("The host network interface with the given GUID could not be found"));
 
-    found->setVirtualBox(m->pParent);
-
     return found.queryInterfaceTo(networkInterface);
 #endif
@@ -1461 +1468 @@
 {
 #ifdef VBOX_WITH_HOSTNETIF_API
-    std::list <ComObjPtr<HostNetworkInterface> > allList;
-    int rc = NetIfList(allList);
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    int rc = updateNetIfList();
     if (RT_FAILURE(rc))
         return E_FAIL;
 
-    std::list <ComObjPtr<HostNetworkInterface> > resultList;
-
-    std::list <ComObjPtr<HostNetworkInterface> >::iterator it;
-    for (it = allList.begin(); it != allList.end(); ++it)
+    HostNetworkInterfaceList resultList;
+
+    HostNetworkInterfaceList::iterator it;
+    for (it = m->llNetIfs.begin(); it != m->llNetIfs.end(); ++it)
     {
         HostNetworkInterfaceType_T t;
@@ -1477 +1485 @@
 
         if (t == type)
-        {
-            (*it)->setVirtualBox(m->pParent);
             resultList.push_back (*it);
-        }
     }
 
@@ -2811 +2816 @@
 #endif /* VBOX_WITH_USB */
 
+HRESULT Host::updateNetIfList()
+{
+#ifdef VBOX_WITH_HOSTNETIF_API
+    AssertReturn(AutoCaller(this).state() == InInit ||
+                 isWriteLockOnCurrentThread(), E_FAIL);
+
+    HostNetworkInterfaceList list, listCopy;
+    int rc = NetIfList(list);
+    if (rc)
+    {
+        Log(("Failed to get host network interface list with rc=%Rrc\n", rc));
+        return E_FAIL;
+    }
+    AssertReturn(m->pParent, E_FAIL);
+    /* Make a copy as the original may be partially destroyed later. */
+    listCopy = list;
+    HostNetworkInterfaceList::iterator itOld, itNew;
+    PerformanceCollector *aCollector = m->pParent->performanceCollector();
+    for (itOld = m->llNetIfs.begin(); itOld != m->llNetIfs.end(); ++itOld)
+    {
+        bool fGone = true;
+        Bstr nameOld;
+        (*itOld)->COMGETTER(Name) (nameOld.asOutParam());
+        for (itNew = listCopy.begin(); itNew != listCopy.end(); ++itNew)
+        {
+            Bstr nameNew;
+            (*itNew)->COMGETTER(Name) (nameNew.asOutParam());
+            if (nameNew == nameOld)
+            {
+                fGone = false;
+                listCopy.erase(itNew);
+                break;
+            }
+        }
+        if (fGone)
+            (*itOld)->unregisterMetrics(aCollector, this);
+    }
+    /* At this point listCopy will contain newly discovered interfaces only. */
+    for (itNew = listCopy.begin(); itNew != listCopy.end(); ++itNew)
+    {
+        (*itNew)->setVirtualBox(m->pParent);
+        (*itNew)->registerMetrics(aCollector, this);
+    }
+    m->llNetIfs = list;
+    return S_OK;
+#else
+    return E_NOTIMPL;
+#endif
+}
+
 #ifdef VBOX_WITH_RESOURCE_USAGE_API
 
@@ -2842 +2897 @@
 
     /* Create and register base metrics */
-    IUnknown *objptr;
-    ComObjPtr<Host> tmp = this;
-    tmp.queryInterfaceTo(&objptr);
-    pm::BaseMetric *cpuLoad = new pm::HostCpuLoadRaw(hal, objptr, cpuLoadUser, cpuLoadKernel,
+    pm::BaseMetric *cpuLoad = new pm::HostCpuLoadRaw(hal, this, cpuLoadUser, cpuLoadKernel,
                                           cpuLoadIdle);
     aCollector->registerBaseMetric (cpuLoad);
-    pm::BaseMetric *cpuMhz = new pm::HostCpuMhz(hal, objptr, cpuMhzSM);
+    pm::BaseMetric *cpuMhz = new pm::HostCpuMhz(hal, this, cpuMhzSM);
     aCollector->registerBaseMetric (cpuMhz);
-    pm::BaseMetric *ramUsage = new pm::HostRamUsage(hal, objptr,
+    pm::BaseMetric *ramUsage = new pm::HostRamUsage(hal, this,
                                                     ramUsageTotal,
                                                     ramUsageUsed,
                                                     ramUsageFree);
     aCollector->registerBaseMetric (ramUsage);
-    pm::BaseMetric *ramVmm = new pm::HostRamVmm(aCollector->getGuestManager(), objptr,
+    pm::BaseMetric *ramVmm = new pm::HostRamVmm(aCollector->getGuestManager(), this,
                                                 ramVMMUsed,
                                                 ramVMMFree,

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

@@ -22 +22 @@
 #include "Logging.h"
 #include "netif.h"
+#include "Performance.h"
+#include "PerformanceImpl.h"
 
 #include <iprt/cpp/utils.h>
@@ -83 +85 @@
 
     return S_OK;
+}
+
+void HostNetworkInterface::registerMetrics(PerformanceCollector *aCollector, ComPtr<IUnknown> objptr)
+{
+    LogFlowThisFunc(("mInterfaceName={%ls}, mGuid={%s}\n",
+                      mInterfaceName.raw(), mGuid.toString().c_str()));
+    pm::CollectorHAL *hal = aCollector->getHAL();
+    /* Create sub metrics */
+    Utf8StrFmt strName("Net/%ls/Load", mInterfaceName.raw());
+    pm::SubMetric *networkLoadRx   = new pm::SubMetric(strName + "/Rx",
+        "Percentage of network interface bandwidth used.");
+    pm::SubMetric *networkLoadTx   = new pm::SubMetric(strName + "/Tx",
+        "Percentage of network interface bandwidth used.");
+
+    /* Create and register base metrics */
+    pm::BaseMetric *networkLoad = new pm::HostNetworkLoadRaw(hal, objptr, strName, Utf8Str(mInterfaceName), networkLoadRx, networkLoadTx);
+    aCollector->registerBaseMetric(networkLoad);
+
+    aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadRx, 0));
+    aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadRx,
+                                              new pm::AggregateAvg()));
+    aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadRx,
+                                              new pm::AggregateMin()));
+    aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadRx,
+                                              new pm::AggregateMax()));
+
+    aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadTx, 0));
+    aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadTx,
+                                              new pm::AggregateAvg()));
+    aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadTx,
+                                              new pm::AggregateMin()));
+    aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadTx,
+                                              new pm::AggregateMax()));
+}
+
+void HostNetworkInterface::unregisterMetrics(PerformanceCollector *aCollector, ComPtr<IUnknown> objptr)
+{
+    LogFlowThisFunc(("mInterfaceName={%ls}, mGuid={%s}\n",
+                      mInterfaceName.raw(), mGuid.toString().c_str()));
+    aCollector->unregisterMetricsFor(objptr);
+    aCollector->unregisterBaseMetricsFor(objptr);
 }
 
@@ -553 +596 @@
     AutoCaller autoCaller(this);
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
+    AssertReturn(mVBox != pVBox, S_OK);
+
     unconst(mVBox) = pVBox;
 

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

@@ -55 +55 @@
 
 int CollectorHAL::getRawHostCpuLoad(uint64_t * /* user */, uint64_t * /* kernel */, uint64_t * /* idle */)
+{
+    return E_NOTIMPL;
+}
+
+int CollectorHAL::getRawHostNetworkLoad(const char * /* name */, uint64_t * /* rx */, uint64_t * /* tx */, uint64_t */* speed */)
 {
     return E_NOTIMPL;
@@ -554 +559 @@
     if (isEnabled())
     {
-        if (nowAt - mLastSampleTaken >= mPeriod * 1000)
+        if (mLastSampleTaken == 0)
         {
             mLastSampleTaken = nowAt;
@@ -561 +566 @@
             return true;
         }
+        /*
+         * We use low resolution timers which may fire just a little bit early.
+         * We compensate for that by jumping into the future by several
+         * milliseconds (see @bugref{6345}).
+         */
+        if (nowAt - mLastSampleTaken + PM_SAMPLER_PRECISION_MS >= mPeriod * 1000)
+        {
+            /*
+             * We don't want the beat to drift. This is why the timestamp of
+             * the last taken sample is not the actual time but the time we
+             * should have taken the measurement at.
+             */
+            mLastSampleTaken += mPeriod * 1000;
+            Log4(("{%p} " LOG_FN_FMT ": Collecting %s for obj(%p)...\n",
+                        this, __PRETTY_FUNCTION__, getName(), (void *)mObject));
+            return true;
+        }
+        Log4(("{%p} " LOG_FN_FMT ": Enabled but too early to collect %s for obj(%p)\n",
+              this, __PRETTY_FUNCTION__, getName(), (void *)mObject));
     }
     return false;
@@ -623 +647 @@
         mKernelPrev = kernel;
         mIdlePrev   = idle;
+    }
+}
+
+void HostNetworkLoadRaw::init(ULONG period, ULONG length)
+{
+    mPeriod = period;
+    mLength = length;
+    mRx->init(mLength);
+    mTx->init(mLength);
+    uint64_t speed;
+    int rc = mHAL->getRawHostNetworkLoad(mInterfaceName.c_str(), &mRxPrev, &mTxPrev, &speed);
+    AssertRC(rc);
+}
+
+void HostNetworkLoadRaw::preCollect(CollectorHints& /* hints */, uint64_t /* iTick */)
+{
+}
+
+void HostNetworkLoadRaw::collect()
+{
+    uint64_t rx, tx, speed;
+
+    int rc = mHAL->getRawHostNetworkLoad(mInterfaceName.c_str(), &rx, &tx, &speed);
+    if (RT_SUCCESS(rc))
+    {
+        uint64_t rxDiff = rx - mRxPrev;
+        uint64_t txDiff = tx - mTxPrev;
+
+        if (RT_UNLIKELY(speed * getPeriod() == 0))
+        {
+            Assert(speed * getPeriod());
+            LogFlowThisFunc(("Impossible! speed=%llu period=%d.\n", speed, getPeriod()));
+            mRx->put(0);
+            mTx->put(0);
+        }
+        else
+        {
+            mRx->put((ULONG)(PM_NETWORK_LOAD_MULTIPLIER * rxDiff / (speed * getPeriod())));
+            mTx->put((ULONG)(PM_NETWORK_LOAD_MULTIPLIER * txDiff / (speed * getPeriod())));
+        }
+
+        mRxPrev = rx;
+        mTxPrev = tx;
     }
 }

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

@@ -66 +66 @@
     "CPU/MHz:min",
     "CPU/MHz:max",
+    "Net/*/Load/Rx",
+    "Net/*/Load/Rx:avg",
+    "Net/*/Load/Rx:min",
+    "Net/*/Load/Rx:max",
+    "Net/*/Load/Tx",
+    "Net/*/Load/Tx:avg",
+    "Net/*/Load/Tx:min",
+    "Net/*/Load/Tx:max",
     "RAM/Usage/Total",
     "RAM/Usage/Total:avg",

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 getRawProcessCpuLoad(RTPROCESS process, uint64_t *user, uint64_t *kernel, uint64_t *total);
 private:
@@ -217 +218 @@
 }
 
-}
-
+int CollectorLinux::getRawHostNetworkLoad(const char *name, uint64_t *rx, uint64_t *tx, uint64_t *speed)
+{
+    int rc = VINF_SUCCESS;
+    char szIfName[/*IFNAMSIZ*/ 16 + 36];
+    long long unsigned int u64Rx, u64Tx, u64Speed;
+
+    RTStrPrintf(szIfName, sizeof(szIfName), "/sys/class/net/%s/statistics/rx_bytes", name);
+    FILE *f = fopen(szIfName, "r");
+    if (f)
+    {
+        if (fscanf(f, "%llu", &u64Rx) == 1)
+            *rx = u64Rx;
+        else
+            rc = VERR_FILE_IO_ERROR;
+        fclose(f);
+        RTStrPrintf(szIfName, sizeof(szIfName), "/sys/class/net/%s/statistics/tx_bytes", name);
+        f = fopen(szIfName, "r");
+        if (f)
+        {
+            if (fscanf(f, "%llu", &u64Tx) == 1)
+                *tx = u64Tx;
+            else
+                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
+            rc = VERR_ACCESS_DENIED;
+    }
+    else
+        rc = VERR_ACCESS_DENIED;
+
+    return rc;
+}
+
+}
+