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

Timestamp:

Nov 7, 2012 1:11:51 PM (12 years ago)

Author:

vboxsync

Message:

Main/Metrics: Disk and filesystem metrics for Solaris (#6345)

Location:

trunk/src/VBox/Main/src-server

Files:

• HostImpl.cpp (modified) (1 diff)
• Performance.cpp (modified) (1 diff)
• linux/PerformanceLinux.cpp (modified) (2 diffs)
• solaris/PerformanceSolaris.cpp (modified) (8 diffs)

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

@@ -2930 +2930 @@
     /* For now we are concerned with the root file system only. */
     pm::DiskList disks;
-    int rc = pm::getDiskListByFs("/", disks);
+    int rc = hal->getDiskListByFs("/", disks);
     if (RT_FAILURE(rc) || disks.empty())
         return;

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

@@ -85 +85 @@
 
 int CollectorHAL::getProcessMemoryUsage(RTPROCESS /* process */, ULONG * /* used */)
+{
+    return E_NOTIMPL;
+}
+
+int CollectorHAL::getDiskListByFs(const char * /* name */, DiskList& /* list */)
 {
     return E_NOTIMPL;

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

@@ -55 +55 @@
     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);
+
+    virtual int getDiskListByFs(const char *name, DiskList& list);
 private:
     virtual int _getRawHostCpuLoad();
@@ -394 +396 @@
 }
 
-int getDiskListByFs(const char *pszPath, DiskList& listDisks)
+int CollectorLinux::getDiskListByFs(const char *pszPath, DiskList& listDisks)
 {
     FILE *mtab = setmntent("/etc/mtab", "r");

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

@@ -27 +27 @@
 #include <sys/sysinfo.h>
 #include <sys/time.h>
+#include <sys/types.h>
+#include <sys/statvfs.h>
 
 #include <iprt/ctype.h>
@@ -33 +35 @@
 #include <iprt/alloc.h>
 #include <iprt/param.h>
+#include <iprt/path.h>
 #include <VBox/log.h>
 #include "Performance.h"
 
+#include <dlfcn.h>
+
+#include <libzfs.h>
+#include <libnvpair.h>
+
+#include <map>
+
 namespace pm {
+
+    typedef libzfs_handle_t *(*PFNZFSINIT)(void);
+    typedef zfs_handle_t *(*PFNZFSOPEN)(libzfs_handle_t *, const char *, int);
+    typedef void (*PFNZFSCLOSE)(zfs_handle_t *);
+    typedef uint64_t (*PFNZFSPROPGETINT)(zfs_handle_t *, zfs_prop_t);
+    typedef zpool_handle_t *(*PFNZPOOLOPEN)(libzfs_handle_t *, const char *);
+    typedef void (*PFNZPOOLCLOSE)(zpool_handle_t *);
+    typedef nvlist_t *(*PFNZPOOLGETCONFIG)(zpool_handle_t *, nvlist_t **);
+    typedef char *(*PFNZPOOLVDEVNAME)(libzfs_handle_t *, zpool_handle_t *, nvlist_t *, boolean_t);
+
+    typedef std::map<RTCString,RTCString> FsMap;
 
 class CollectorSolaris : public CollectorHAL
@@ -44 +65 @@
     virtual ~CollectorSolaris();
     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);
+
+    virtual int getDiskListByFs(const char *name, DiskList& list);
 private:
     static uint32_t getInstance(const char *pszIfaceName, char *pszDevName);
+    uint64_t getZfsTotal(uint64_t cbTotal, const char *szFsType, const char *szFsName);
+    void updateFilesystemMap(void);
+    RTCString physToInstName(const char *pcszPhysName);
+
     kstat_ctl_t *mKC;
     kstat_t     *mSysPages;
     kstat_t     *mZFSCache;
+
+    void             *mZfsSo;
+    libzfs_handle_t  *mZfsLib;
+    PFNZFSINIT        mZfsInit;
+    PFNZFSOPEN        mZfsOpen;
+    PFNZFSCLOSE       mZfsClose;
+    PFNZFSPROPGETINT  mZfsPropGetInt;
+    PFNZPOOLOPEN      mZpoolOpen;
+    PFNZPOOLCLOSE     mZpoolClose;
+    PFNZPOOLGETCONFIG mZpoolGetConfig;
+    PFNZPOOLVDEVNAME  mZpoolVdevName;
+
+    FsMap             mFsMap;
 };
 
@@ -67 +109 @@
     : mKC(0),
       mSysPages(0),
-      mZFSCache(0)
+      mZFSCache(0),
+      mZfsLib(0)
 {
     if ((mKC = kstat_open()) == 0)
@@ -85 +128 @@
         Log(("kstat_lookup(system_pages) -> %d\n", errno));
     }
+
+    /* Try to load libzfs dynamically, it may be missing. */
+    mZfsSo = dlopen("libzfs.so", RTLD_LAZY);
+    if (mZfsSo)
+    {
+        mZfsInit        =        (PFNZFSINIT)dlsym(mZfsSo, "libzfs_init");
+        mZfsOpen        =        (PFNZFSOPEN)dlsym(mZfsSo, "zfs_open");
+        mZfsClose       =       (PFNZFSCLOSE)dlsym(mZfsSo, "zfs_close");
+        mZfsPropGetInt  =  (PFNZFSPROPGETINT)dlsym(mZfsSo, "zfs_prop_get_int");
+        mZpoolOpen      =      (PFNZPOOLOPEN)dlsym(mZfsSo, "zpool_open");
+        mZpoolClose     =     (PFNZPOOLCLOSE)dlsym(mZfsSo, "zpool_close");
+        mZpoolGetConfig = (PFNZPOOLGETCONFIG)dlsym(mZfsSo, "zpool_get_config");
+        mZpoolVdevName  =  (PFNZPOOLVDEVNAME)dlsym(mZfsSo, "zpool_vdev_name");
+
+        if (mZfsInit && mZfsOpen && mZfsClose && mZfsPropGetInt
+            && mZpoolOpen && mZpoolClose && mZpoolGetConfig && mZpoolVdevName)
+            mZfsLib = mZfsInit();
+        else
+            LogRel(("Incompatible libzfs? libzfs_init=%p zfs_open=%p zfs_close=%p zfs_prop_get_int=%p\n",
+                    mZfsInit, mZfsOpen, mZfsClose, mZfsPropGetInt));
+    }
+
+    updateFilesystemMap();
 }
 
@@ -91 +157 @@
     if (mKC)
         kstat_close(mKC);
+    if (mZfsSo)
+        dlclose(mZfsSo);
 }
 
@@ -300 +368 @@
         {
             LogFlowThisFunc(("m=%s i=%u n=%s\n", szModule, uInstance, name));
-            ksAdapter = kstat_lookup(mKC, szModule, uInstance, name);
+            ksAdapter = kstat_lookup(mKC, szModule, uInstance, (char *)name);
             if (ksAdapter == 0)
             {
@@ -329 +397 @@
 }
 
-int getDiskListByFs(const char *name, DiskList& list)
-{
-    return VERR_NOT_IMPLEMENTED;
-}
-
-}
+int CollectorSolaris::getRawHostDiskLoad(const char *name, uint64_t *disk_ms, uint64_t *total_ms)
+{
+    int rc = VINF_SUCCESS;
+    AssertReturn(strlen(name) < KSTAT_STRLEN, VERR_INVALID_PARAMETER);
+    LogFlowThisFunc(("n=%s\n", name));
+    kstat_t *ksDisk = kstat_lookup(mKC, NULL, -1, (char *)name);
+    if (ksDisk != 0)
+    {
+        if (kstat_read(mKC, ksDisk, 0) == -1)
+        {
+            LogRel(("kstat_read(%s) -> %d\n", name, errno));
+            rc = VERR_INTERNAL_ERROR;
+        }
+        else
+        {
+            kstat_io_t *ksIo = KSTAT_IO_PTR(ksDisk);
+            /*
+             * We do not care for wrap possibility here, although we may
+             * reconsider in about 300 years (9223372036854775807 ns).
+             */
+            *disk_ms = ksIo->rtime / 1000000;
+            *total_ms = ksDisk->ks_snaptime / 1000000;
+        }
+    }
+    else
+    {
+        LogRel(("kstat_lookup(%s) -> %d\n", name, errno));
+        rc = VERR_INTERNAL_ERROR;
+    }
+
+    return rc;
+}
+
+uint64_t CollectorSolaris::getZfsTotal(uint64_t cbTotal, const char *szFsType, const char *szFsName)
+{
+    if (strcmp(szFsType, "zfs"))
+        return cbTotal;
+    FsMap::iterator it = mFsMap.find(szFsName);
+    if (it == mFsMap.end())
+        return cbTotal;
+
+    char *pszDataset = strdup(it->second.c_str());
+    char *pszEnd = pszDataset + strlen(pszDataset);
+    uint64_t uAvail = 0;
+    while (pszEnd)
+    {
+        zfs_handle_t *hDataset;
+
+        *pszEnd = 0;
+        hDataset = mZfsOpen(mZfsLib, pszDataset, ZFS_TYPE_DATASET);
+        if (!hDataset)
+            break;
+
+        if (uAvail == 0)
+        {
+            uAvail = mZfsPropGetInt(hDataset, ZFS_PROP_REFQUOTA);
+            if (uAvail == 0)
+                uAvail = UINT64_MAX;
+        }
+
+        uint64_t uQuota = mZfsPropGetInt(hDataset, ZFS_PROP_QUOTA);
+        if (uQuota && uAvail > uQuota)
+            uAvail = uQuota;
+
+        pszEnd = strrchr(pszDataset, '/');
+        if (!pszEnd)
+        {
+            uint64_t uPoolSize = mZfsPropGetInt(hDataset, ZFS_PROP_USED) +
+                                 mZfsPropGetInt(hDataset, ZFS_PROP_AVAILABLE);
+            if (uAvail > uPoolSize)
+                uAvail = uPoolSize;
+        }
+        mZfsClose(hDataset);
+    }
+    free(pszDataset);
+
+    return uAvail ? uAvail : cbTotal;
+}
+
+int CollectorSolaris::getHostFilesystemUsage(const char *path, ULONG *total, ULONG *used, ULONG *available)
+{
+    struct statvfs64 stats;
+    const unsigned _MB = 1024 * 1024;
+
+    if (statvfs64(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)(getZfsTotal(cbBlock * stats.f_blocks, stats.f_basetype, path) / _MB);
+    LogRel(("f_blocks=%llu.\n", stats.f_blocks));
+    *used  = (ULONG)(cbBlock * (stats.f_blocks - stats.f_bfree) / _MB);
+    *available = (ULONG)(cbBlock * stats.f_bavail / _MB);
+
+    return VINF_SUCCESS;
+}
+
+RTCString CollectorSolaris::physToInstName(const char *pcszPhysName)
+{
+    FILE *fp = fopen("/etc/path_to_inst", "r");
+    if (!fp)
+        return RTCString();
+
+    RTCString strInstName;
+    size_t cbName = strlen(pcszPhysName);
+    char szBuf[RTPATH_MAX];
+    while (fgets(szBuf, sizeof(szBuf), fp))
+    {
+        if (szBuf[0] == '"' && strncmp(szBuf + 1, pcszPhysName, cbName) == 0)
+        {
+            char *pszDriver, *pszInstance;
+            pszDriver = strrchr(szBuf, '"');
+            if (pszDriver)
+            {
+                *pszDriver = '\0';
+                pszDriver = strrchr(szBuf, '"');
+                if (pszDriver)
+                {
+                    *pszDriver++ = '\0';
+                    pszInstance = strrchr(szBuf, ' ');
+                    if (pszInstance)
+                    {
+                        *pszInstance = '\0';
+                        pszInstance = strrchr(szBuf, ' ');
+                        if (pszInstance)
+                        {
+                            *pszInstance++ = '\0';
+                            strInstName = pszDriver;
+                            strInstName += pszInstance;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    fclose(fp);
+
+    return strInstName;
+}
+
+int CollectorSolaris::getDiskListByFs(const char *name, DiskList& list)
+{
+    FsMap::iterator it = mFsMap.find(name);
+    if (it == mFsMap.end())
+        return VERR_INVALID_PARAMETER;
+
+    RTCString strName = it->second.substr(0, it->second.find("/"));
+    if (mZpoolOpen && mZpoolClose && mZpoolGetConfig)
+    {
+        zpool_handle_t *zh = mZpoolOpen(mZfsLib, strName.c_str());
+        if (zh)
+        {
+            unsigned int cChildren;
+            nvlist_t **nvChildren, *nvRoot, *nvConfig = mZpoolGetConfig(zh, NULL);
+            Assert(!nvlist_lookup_nvlist(nvConfig, ZPOOL_CONFIG_VDEV_TREE, &nvRoot));
+            if (!nvlist_lookup_nvlist_array(nvRoot, ZPOOL_CONFIG_CHILDREN, &nvChildren, &cChildren))
+            {
+                for (unsigned int i = 0; i < cChildren; ++i)
+                {
+                    uint64_t fHole = 0;
+                    uint64_t fLog  = 0;
+
+                    nvlist_lookup_uint64(nvChildren[i], ZPOOL_CONFIG_IS_HOLE, &fHole);
+                    nvlist_lookup_uint64(nvChildren[i], ZPOOL_CONFIG_IS_LOG,  &fLog);
+
+                    if (!fHole && !fLog)
+                    {
+                        char *pszChildName = mZpoolVdevName(mZfsLib, zh, nvChildren[i], _B_FALSE);
+                        Assert(pszChildName);
+                        RTCString strDevPath("/dev/dsk/");
+                        strDevPath += pszChildName;
+                        char szLink[RTPATH_MAX];
+                        if (readlink(strDevPath.c_str(), szLink, sizeof(szLink)) != -1)
+                        {
+                            char *pszStart, *pszEnd;
+                            pszStart = strstr(szLink, "/devices/");
+                            pszEnd = strrchr(szLink, ':');
+                            if (pszStart && pszEnd)
+                            {
+                                pszStart += 8; // Skip "/devices"
+                                *pszEnd = '\0'; // Trim partition
+                                list.push_back(physToInstName(pszStart));
+                            }
+                        }
+                        free(pszChildName);
+                    }
+                }
+            }
+            mZpoolClose(zh);
+        }
+    }
+    else
+        list.push_back(RTCString(name));
+    return VINF_SUCCESS;
+}
+
+void CollectorSolaris::updateFilesystemMap(void)
+{
+    FILE *fp = fopen("/etc/mnttab", "r");
+    if (fp)
+    {
+        struct mnttab Entry;
+        int rc = 0;
+        resetmnttab(fp);
+        while ((rc = getmntent(fp, &Entry)) == 0)
+            mFsMap[Entry.mnt_mountp] = Entry.mnt_special;
+        fclose(fp);
+        if (rc != -1)
+            LogRel(("Error while reading mnttab: %d\n", rc));
+    }
+}
+
+}