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

Timestamp:

Oct 12, 2012 9:26:07 AM (12 years ago)

Author:

vboxsync

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

81354

Message:

Main/Metrics: Linux fs/disk metrics, VBoxManage filtering + minor fixes (#6345)

Location:

trunk/src/VBox/Main/src-server

Files:

• HostImpl.cpp (modified) (2 diffs)
• HostNetworkInterfaceImpl.cpp (modified) (1 diff)
• Performance.cpp (modified) (4 diffs)
• darwin/PerformanceDarwin.cpp (modified) (1 diff)
• linux/PerformanceLinux.cpp (modified) (7 diffs)
• os2/PerformanceOs2.cpp (modified) (1 diff)
• solaris/PerformanceSolaris.cpp (modified) (1 diff)
• win/PerformanceWin.cpp (modified) (1 diff)

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

@@ -2884 +2884 @@
 #ifdef VBOX_WITH_RESOURCE_USAGE_API
 
+void Host::registerDiskMetrics(PerformanceCollector *aCollector)
+{
+    pm::CollectorHAL *hal = aCollector->getHAL();
+    /* Create sub metrics */
+    Utf8StrFmt fsNameBase("FS/{%s}/Usage", "/");
+    //Utf8StrFmt fsNameBase("Filesystem/[root]/Usage");
+    pm::SubMetric *fsRootUsageTotal  = new pm::SubMetric(fsNameBase + "/Total",
+        "Root file system size.");
+    pm::SubMetric *fsRootUsageUsed   = new pm::SubMetric(fsNameBase + "/Used",
+        "Root file system space currently occupied.");
+    pm::SubMetric *fsRootUsageFree   = new pm::SubMetric(fsNameBase + "/Free",
+        "Root file system space currently empty.");
+
+    pm::BaseMetric *fsRootUsage = new pm::HostFilesystemUsage(hal, this,
+                                                              fsNameBase, "/",
+                                                              fsRootUsageTotal,
+                                                              fsRootUsageUsed,
+                                                              fsRootUsageFree);
+    aCollector->registerBaseMetric (fsRootUsage);
+
+    aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageTotal, 0));
+    aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageTotal,
+                                              new pm::AggregateAvg()));
+    aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageTotal,
+                                              new pm::AggregateMin()));
+    aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageTotal,
+                                              new pm::AggregateMax()));
+
+    aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageUsed, 0));
+    aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageUsed,
+                                              new pm::AggregateAvg()));
+    aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageUsed,
+                                              new pm::AggregateMin()));
+    aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageUsed,
+                                              new pm::AggregateMax()));
+
+    aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageFree, 0));
+    aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageFree,
+                                              new pm::AggregateAvg()));
+    aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageFree,
+                                              new pm::AggregateMin()));
+    aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageFree,
+                                              new pm::AggregateMax()));
+
+    /* For now we are concerned with the root file system only. */
+    pm::DiskList disks;
+    int rc = pm::getDiskListByFs("/", disks);
+    if (RT_FAILURE(rc) || disks.empty())
+        return;
+    pm::DiskList::iterator it;
+    for (it = disks.begin(); it != disks.end(); ++it)
+    {
+        Utf8StrFmt strName("Disk/%s/Load", it->c_str());
+        pm::SubMetric *fsLoadUtil   = new pm::SubMetric(strName + "/Util",
+            "Percentage of time disk was busy serving I/O requests.");
+        pm::BaseMetric *fsLoad = new pm::HostDiskLoadRaw(hal, this, strName,
+                                                         *it, fsLoadUtil);
+        aCollector->registerBaseMetric (fsLoad);
+
+        aCollector->registerMetric(new pm::Metric(fsLoad, fsLoadUtil, 0));
+        aCollector->registerMetric(new pm::Metric(fsLoad, fsLoadUtil,
+                                                  new pm::AggregateAvg()));
+        aCollector->registerMetric(new pm::Metric(fsLoad, fsLoadUtil,
+                                                  new pm::AggregateMin()));
+        aCollector->registerMetric(new pm::Metric(fsLoad, fsLoadUtil,
+                                                  new pm::AggregateMax()));
+    }
+}
+
 void Host::registerMetrics(PerformanceCollector *aCollector)
 {
@@ -3017 +3086 @@
     aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMShared,
                                               new pm::AggregateMax()));
+    registerDiskMetrics(aCollector);
 }
 

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

@@ -95 +95 @@
     Utf8StrFmt strName("Net/%ls/Load", mShortName.raw());
     pm::SubMetric *networkLoadRx   = new pm::SubMetric(strName + "/Rx",
-        "Percentage of network interface bandwidth used.");
+        "Percentage of network interface receive bandwidth used.");
     pm::SubMetric *networkLoadTx   = new pm::SubMetric(strName + "/Tx",
-        "Percentage of network interface bandwidth used.");
+        "Percentage of network interface transmit bandwidth used.");
 
     /* Create and register base metrics */

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

@@ -64 +64 @@
 }
 
+int CollectorHAL::getRawHostDiskLoad(const char * /* name */, uint64_t * /* disk_ms */, uint64_t * /* total_ms */)
+{
+    return E_NOTIMPL;
+}
+
 int CollectorHAL::getRawProcessCpuLoad(RTPROCESS  /* process */, uint64_t * /* user */, uint64_t * /* kernel */, uint64_t * /* total */)
 {
@@ -70 +75 @@
 
 int CollectorHAL::getHostMemoryUsage(ULONG * /* total */, ULONG * /* used */, ULONG * /* available */)
+{
+    return E_NOTIMPL;
+}
+
+int CollectorHAL::getHostFilesystemUsage(const char * /* name */, ULONG * /* total */, ULONG * /* used */, ULONG * /* available */)
 {
     return E_NOTIMPL;
@@ -705 +715 @@
 }
 
+void HostDiskLoadRaw::init(ULONG period, ULONG length)
+{
+    mPeriod = period;
+    mLength = length;
+    mUtil->init(mLength);
+    int rc = mHAL->getRawHostDiskLoad(mDiskName.c_str(), &mDiskPrev, &mTotalPrev);
+    AssertRC(rc);
+}
+
+void HostDiskLoadRaw::preCollect(CollectorHints& hints, uint64_t /* iTick */)
+{
+    hints.collectHostCpuLoad();
+}
+
+void HostDiskLoadRaw::collect()
+{
+    uint64_t disk, total;
+
+    int rc = mHAL->getRawHostDiskLoad(mDiskName.c_str(), &disk, &total);
+    if (RT_SUCCESS(rc))
+    {
+        uint64_t diskDiff = disk - mDiskPrev;
+        uint64_t totalDiff = total - mTotalPrev;
+
+        if (RT_UNLIKELY(totalDiff == 0))
+        {
+            Assert(totalDiff);
+            LogFlowThisFunc(("Improbable! Less than millisecond passed! Disk=%s\n", mDiskName.c_str()));
+            mUtil->put(0);
+        }
+        else if (diskDiff > totalDiff)
+        {
+            /*
+             * It is possible that the disk spent more time than CPU because
+             * CPU measurements are taken during the pre-collect phase. We try
+             * to compensate for than by adding the extra to the next round of
+             * measurements.
+             */
+            mUtil->put(PM_NETWORK_LOAD_MULTIPLIER);
+            Assert((diskDiff - totalDiff) < mPeriod * 1000);
+            if ((diskDiff - totalDiff) > mPeriod * 1000)
+            {
+                LogRel(("Disk utilization time exceeds CPU time by more"
+                        " than the collection period (%llu ms)\n", diskDiff - totalDiff));
+            }
+            else
+            {
+                disk = mDiskPrev + totalDiff;
+                LogFlowThisFunc(("Moved %u milliseconds to the next period.\n", (unsigned)(diskDiff - totalDiff)));
+            }
+        }
+        else
+        {
+            mUtil->put((ULONG)(PM_NETWORK_LOAD_MULTIPLIER * diskDiff / totalDiff));
+        }
+
+        mDiskPrev = disk;
+        mTotalPrev = total;
+    }
+    else
+        LogFlowThisFunc(("Failed to collect data: %Rrc (%d).\n", rc));
+}
+
 void HostCpuMhz::init(ULONG period, ULONG length)
 {
@@ -738 +811 @@
     ULONG total, used, available;
     int rc = mHAL->getHostMemoryUsage(&total, &used, &available);
+    if (RT_SUCCESS(rc))
+    {
+        mTotal->put(total);
+        mUsed->put(used);
+        mAvailable->put(available);
+
+    }
+}
+
+void HostFilesystemUsage::init(ULONG period, ULONG length)
+{
+    mPeriod = period;
+    mLength = length;
+    mTotal->init(mLength);
+    mUsed->init(mLength);
+    mAvailable->init(mLength);
+}
+
+void HostFilesystemUsage::preCollect(CollectorHints& /* hints */, uint64_t /* iTick */)
+{
+}
+
+void HostFilesystemUsage::collect()
+{
+    ULONG total, used, available;
+    int rc = mHAL->getHostFilesystemUsage(mFsName.c_str(), &total, &used, &available);
     if (RT_SUCCESS(rc))
     {

trunk/src/VBox/Main/src-server/darwin/PerformanceDarwin.cpp

@@ -162 +162 @@
 }
 
+int getDiskListByFs(const char *name, DiskList& list)
+{
+    return VERR_NOT_IMPLEMENTED;
 }
 
+}
+

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

@@ -19 +19 @@
 
 #include <stdio.h>
+#include <unistd.h>
+#include <sys/statvfs.h>
+#include <errno.h>
+#include <mntent.h>
 #include <iprt/alloc.h>
+#include <iprt/cdefs.h>
+#include <iprt/ctype.h>
 #include <iprt/err.h>
 #include <iprt/param.h>
 #include <iprt/string.h>
+#include <iprt/mp.h>
 
 #include <map>
@@ -35 +42 @@
 {
 public:
+    CollectorLinux();
     virtual int preCollect(const CollectorHints& hints, uint64_t /* iTick */);
     virtual int getHostMemoryUsage(ULONG *total, ULONG *used, ULONG *available);
+    virtual int getHostFilesystemUsage(const char *name, ULONG *total, ULONG *used, ULONG *available);
     virtual int getProcessMemoryUsage(RTPROCESS process, ULONG *used);
 
     virtual int getRawHostCpuLoad(uint64_t *user, uint64_t *kernel, uint64_t *idle);
     virtual int getRawHostNetworkLoad(const char *name, uint64_t *rx, uint64_t *tx);
+    virtual int getRawHostDiskLoad(const char *name, uint64_t *disk_ms, uint64_t *total_ms);
     virtual int getRawProcessCpuLoad(RTPROCESS process, uint64_t *user, uint64_t *kernel, uint64_t *total);
 private:
-    virtual int _getRawHostCpuLoad(uint64_t *user, uint64_t *kernel, uint64_t *idle);
+    virtual int _getRawHostCpuLoad();
     int getRawProcessStats(RTPROCESS process, uint64_t *cpuUser, uint64_t *cpuKernel, ULONG *memPagesUsed);
 
@@ -57 +67 @@
     VMProcessMap mProcessStats;
     uint64_t     mUser, mKernel, mIdle;
+    uint64_t     mSingleUser, mSingleKernel, mSingleIdle;
+    uint32_t     mHZ;
 };
 
@@ -65 +77 @@
 
 // Collector HAL for Linux
+
+CollectorLinux::CollectorLinux()
+{
+    long hz = sysconf(_SC_CLK_TCK);
+    if (hz == -1)
+    {
+        LogRel(("CollectorLinux failed to obtain HZ from kernel, assuming 100.\n"));
+        mHZ = 100;
+    }
+    else
+        mHZ = hz;
+    LogFlowThisFunc(("mHZ=%u\n", mHZ));
+}
 
 int CollectorLinux::preCollect(const CollectorHints& hints, uint64_t /* iTick */)
@@ -84 +109 @@
     if (hints.isHostCpuLoadCollected() || mProcessStats.size())
     {
-        _getRawHostCpuLoad(&mUser, &mKernel, &mIdle);
-    }
-    return VINF_SUCCESS;
-}
-
-int CollectorLinux::_getRawHostCpuLoad(uint64_t *user, uint64_t *kernel, uint64_t *idle)
-{
-    int rc = VINF_SUCCESS;
-    ULONG u32user, u32nice, u32kernel, u32idle;
+        _getRawHostCpuLoad();
+    }
+    return VINF_SUCCESS;
+}
+
+int CollectorLinux::_getRawHostCpuLoad()
+{
+    int rc = VINF_SUCCESS;
+    long long unsigned uUser, uNice, uKernel, uIdle, uIowait, uIrq, uSoftirq;
     FILE *f = fopen("/proc/stat", "r");
 
     if (f)
     {
-        if (fscanf(f, "cpu %u %u %u %u", &u32user, &u32nice, &u32kernel, &u32idle) == 4)
-        {
-            *user   = (uint64_t)u32user + u32nice;
-            *kernel = u32kernel;
-            *idle   = u32idle;
+        char szBuf[128];
+        if (fgets(szBuf, sizeof(szBuf), f))
+        {
+            if (sscanf(szBuf, "cpu %llu %llu %llu %llu %llu %llu %llu",
+                       &uUser, &uNice, &uKernel, &uIdle, &uIowait,
+                       &uIrq, &uSoftirq) == 7)
+            {
+                mUser   = uUser + uNice;
+                mKernel = uKernel + uIrq + uSoftirq;
+                mIdle   = uIdle + uIowait;
+            }
+            /* Try to get single CPU stats. */
+            if (fgets(szBuf, sizeof(szBuf), f))
+            {
+                if (sscanf(szBuf, "cpu0 %llu %llu %llu %llu %llu %llu %llu",
+                           &uUser, &uNice, &uKernel, &uIdle, &uIowait,
+                           &uIrq, &uSoftirq) == 7)
+                {
+                    mSingleUser   = uUser + uNice;
+                    mSingleKernel = uKernel + uIrq + uSoftirq;
+                    mSingleIdle   = uIdle + uIowait;
+                }
+                else
+                {
+                    /* Assume that this is not an SMP system. */
+                    Assert(RTMpGetCount() == 1);
+                    mSingleUser   = mUser;
+                    mSingleKernel = mKernel;
+                    mSingleIdle   = mIdle;
+                }
+            }
+            else
+                rc = VERR_FILE_IO_ERROR;
         }
         else
@@ -161 +214 @@
 
     return rc;
+}
+
+int CollectorLinux::getHostFilesystemUsage(const char *path, ULONG *total, ULONG *used, ULONG *available)
+{
+    struct statvfs stats;
+    const unsigned _MB = 1024 * 1024;
+
+    if (statvfs(path, &stats) == -1)
+    {
+        LogRel(("Failed to collect %s filesystem usage: errno=%d.\n", path, errno));
+        return VERR_ACCESS_DENIED;
+    }
+    uint64_t cbBlock = stats.f_frsize ? stats.f_frsize : stats.f_bsize;
+    *total = (ULONG)(cbBlock * stats.f_blocks / _MB);
+    *used  = (ULONG)(cbBlock * (stats.f_blocks - stats.f_bfree) / _MB);
+    *available = (ULONG)(cbBlock * stats.f_bavail / _MB);
+
+    return VINF_SUCCESS;
 }
 
@@ -252 +323 @@
 }
 
-}
-
+int CollectorLinux::getRawHostDiskLoad(const char *name, uint64_t *disk_ms, uint64_t *total_ms)
+{
+    int rc = VINF_SUCCESS;
+    char szIfName[/*IFNAMSIZ*/ 16 + 36];
+    long long unsigned int u64Busy, tmp;
+
+    RTStrPrintf(szIfName, sizeof(szIfName), "/sys/class/block/%s/stat", name);
+    FILE *f = fopen(szIfName, "r");
+    if (f)
+    {
+        if (fscanf(f, "%llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu",
+                   &tmp, &tmp, &tmp, &tmp, &tmp, &tmp, &tmp, &tmp, &tmp, &u64Busy, &tmp) == 11)
+        {
+            *disk_ms   = u64Busy;
+            *total_ms  = (uint64_t)(mSingleUser + mSingleKernel + mSingleIdle) * 1000 / mHZ;
+        }
+        else
+            rc = VERR_FILE_IO_ERROR;
+        fclose(f);
+    }
+    else
+        rc = VERR_ACCESS_DENIED;
+
+    return rc;
+}
+
+static char *getDiskName(char *pszDiskName, size_t cbDiskName, const char *pszDevName)
+{
+    unsigned cbName = 0;
+    unsigned cbDevName = strlen(pszDevName);
+    const char *pszEnd = pszDevName + cbDevName - 1;
+    while (pszEnd > pszDevName && RT_C_IS_DIGIT(*pszEnd))
+        pszEnd--;
+    while (pszEnd > pszDevName && *pszEnd != '/')
+    {
+        cbName++;
+        pszEnd--;
+    }
+    RTStrCopy(pszDiskName, RT_MIN(cbName + 1, cbDiskName), pszEnd + 1);
+    return pszDiskName;
+}
+
+
+int getDiskListByFs(const char *pszPath, DiskList& listDisks)
+{
+    FILE *mtab = setmntent("/etc/mtab", "r");
+    if (mtab)
+    {
+        struct mntent *mntent;
+        while ((mntent = getmntent(mtab)))
+        {
+            if (strcmp(pszPath, mntent->mnt_dir) == 0)
+            {
+                char szDevName[32];
+                listDisks.push_back(RTCString(getDiskName(szDevName, sizeof(szDevName), mntent->mnt_fsname)));
+                break;
+            }
+        }
+        endmntent(mtab);
+    }
+    return VINF_SUCCESS;
+}
+
+}
+

trunk/src/VBox/Main/src-server/os2/PerformanceOs2.cpp

@@ -63 +63 @@
 }
 
+int getDiskListByFs(const char *name, DiskList& list)
+{
+    return VERR_NOT_IMPLEMENTED;
 }
+
+}

trunk/src/VBox/Main/src-server/solaris/PerformanceSolaris.cpp

@@ -329 +329 @@
 }
 
-}
+int getDiskListByFs(const char *name, DiskList& list)
+{
+    return VERR_NOT_IMPLEMENTED;
+}
+
+}

trunk/src/VBox/Main/src-server/win/PerformanceWin.cpp

@@ -350 +350 @@
 }
 
-}
+int getDiskListByFs(const char *name, DiskList& list)
+{
+    return VERR_NOT_IMPLEMENTED;
+}
+
+}