1 files changed, 220 insertions, 0 deletions

diff --git a/collectors/proc.plugin/proc_spl_kstat_zfs.c b/collectors/proc.plugin/proc_spl_kstat_zfs.c
index 32ff36b76..ce95c2d35 100644
--- a/collectors/proc.plugin/proc_spl_kstat_zfs.c
+++ b/collectors/proc.plugin/proc_spl_kstat_zfs.c
@@ -4,6 +4,10 @@
 #include "zfs_common.h"
 
 #define ZFS_PROC_ARCSTATS "/proc/spl/kstat/zfs/arcstats"
+#define ZFS_PROC_POOLS "/proc/spl/kstat/zfs"
+
+#define STATE_SIZE 8
+#define MAX_CHART_ID 256
 
 extern struct arcstats arcstats;
 
@@ -194,3 +198,219 @@ int do_proc_spl_kstat_zfs_arcstats(int update_every, usec_t dt) {
 
     return 0;
 }
+
+struct zfs_pool {
+    RRDSET *st;
+
+    RRDDIM *rd_online;
+    RRDDIM *rd_degraded;
+    RRDDIM *rd_faulted;
+    RRDDIM *rd_offline;
+    RRDDIM *rd_removed;
+    RRDDIM *rd_unavail;
+
+    int updated;
+    int disabled;
+
+    int online;
+    int degraded;
+    int faulted;
+    int offline;
+    int removed;
+    int unavail;
+};
+
+struct deleted_zfs_pool {
+    char *name;
+    struct deleted_zfs_pool *next;
+} *deleted_zfs_pools = NULL;
+
+DICTIONARY *zfs_pools = NULL;
+
+void disable_zfs_pool_state(struct zfs_pool *pool)
+{
+    if (pool->st)
+        rrdset_is_obsolete(pool->st);
+
+    pool->st = NULL;
+
+    pool->rd_online = NULL;
+    pool->rd_degraded = NULL;
+    pool->rd_faulted = NULL;
+    pool->rd_offline = NULL;
+    pool->rd_removed = NULL;
+    pool->rd_unavail = NULL;
+
+    pool->disabled = 1;
+}
+
+int update_zfs_pool_state_chart(char *name, void *pool_p, void *update_every_p)
+{
+    struct zfs_pool *pool = (struct zfs_pool *)pool_p;
+    int update_every = *(int *)update_every_p;
+
+    if (pool->updated) {
+        pool->updated = 0;
+
+        if (!pool->disabled) {
+            if (unlikely(!pool->st)) {
+                char chart_id[MAX_CHART_ID + 1];
+                snprintf(chart_id, MAX_CHART_ID, "state_%s", name);
+
+                pool->st = rrdset_create_localhost(
+                    "zfspool",
+                    chart_id,
+                    NULL,
+                    name,
+                    "zfspool.state",
+                    "ZFS pool state",
+                    "boolean",
+                    PLUGIN_PROC_NAME,
+                    ZFS_PROC_POOLS,
+                    NETDATA_CHART_PRIO_ZFS_POOL_STATE,
+                    update_every,
+                    RRDSET_TYPE_LINE);
+
+                pool->rd_online = rrddim_add(pool->st, "online", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
+                pool->rd_degraded = rrddim_add(pool->st, "degraded", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
+                pool->rd_faulted = rrddim_add(pool->st, "faulted", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
+                pool->rd_offline = rrddim_add(pool->st, "offline", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
+                pool->rd_removed = rrddim_add(pool->st, "removed", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
+                pool->rd_unavail = rrddim_add(pool->st, "unavail", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
+            } else
+                rrdset_next(pool->st);
+
+            rrddim_set_by_pointer(pool->st, pool->rd_online, pool->online);
+            rrddim_set_by_pointer(pool->st, pool->rd_degraded, pool->degraded);
+            rrddim_set_by_pointer(pool->st, pool->rd_faulted, pool->faulted);
+            rrddim_set_by_pointer(pool->st, pool->rd_offline, pool->offline);
+            rrddim_set_by_pointer(pool->st, pool->rd_removed, pool->removed);
+            rrddim_set_by_pointer(pool->st, pool->rd_unavail, pool->unavail);
+            rrdset_done(pool->st);
+        }
+    } else {
+        disable_zfs_pool_state(pool);
+        struct deleted_zfs_pool *new = calloc(1, sizeof(struct deleted_zfs_pool));
+        new->name = strdupz(name);
+        new->next = deleted_zfs_pools;
+        deleted_zfs_pools = new;
+    }
+
+    return 0;
+}
+
+int do_proc_spl_kstat_zfs_pool_state(int update_every, usec_t dt)
+{
+    (void)dt;
+
+    static int do_zfs_pool_state = -1;
+    static char *dirname = NULL;
+
+    int pool_found = 0, state_file_found = 0;
+
+    if (unlikely(do_zfs_pool_state == -1)) {
+        char filename[FILENAME_MAX + 1];
+        snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/proc/spl/kstat/zfs");
+        dirname = config_get("plugin:proc:" ZFS_PROC_POOLS, "directory to monitor", filename);
+
+        zfs_pools = dictionary_create(DICTIONARY_FLAG_SINGLE_THREADED);
+
+        do_zfs_pool_state = 1;
+    }
+
+    if (likely(do_zfs_pool_state)) {
+        DIR *dir = opendir(dirname);
+        if (unlikely(!dir)) {
+            error("Cannot read directory '%s'", dirname);
+            return 1;
+        }
+
+        struct dirent *de = NULL;
+        while (likely(de = readdir(dir))) {
+            if (likely(
+                    de->d_type == DT_DIR && ((de->d_name[0] == '.' && de->d_name[1] == '\0') ||
+                                             (de->d_name[0] == '.' && de->d_name[1] == '.' && de->d_name[2] == '\0'))))
+                continue;
+
+            if (unlikely(de->d_type == DT_LNK || de->d_type == DT_DIR)) {
+                pool_found = 1;
+
+                struct zfs_pool *pool = dictionary_get(zfs_pools, de->d_name);
+
+                if (unlikely(!pool)) {
+                    struct zfs_pool new_zfs_pool = {};
+                    pool = dictionary_set(zfs_pools, de->d_name, &new_zfs_pool, sizeof(struct zfs_pool));
+                };
+
+                pool->updated = 1;
+
+                if (pool->disabled) {
+                    state_file_found = 1;
+                    continue;
+                }
+                
+                pool->online = 0;
+                pool->degraded = 0;
+                pool->faulted = 0;
+                pool->offline = 0;
+                pool->removed = 0;
+                pool->unavail = 0;
+
+                char filename[FILENAME_MAX + 1];
+                snprintfz(
+                    filename, FILENAME_MAX, "%s%s/%s/state", netdata_configured_host_prefix, dirname, de->d_name);
+
+                char state[STATE_SIZE + 1];
+                int ret = read_file(filename, state, STATE_SIZE);
+
+                if (!ret) {
+                    state_file_found = 1;
+
+                    // ZFS pool states are described at https://openzfs.github.io/openzfs-docs/man/8/zpoolconcepts.8.html?#Device_Failure_and_Recovery
+                    if (!strcmp(state, "ONLINE\n")) {
+                        pool->online = 1;
+                    } else if (!strcmp(state, "DEGRADED\n")) {
+                        pool->degraded = 1;
+                    } else if (!strcmp(state, "FAULTED\n")) {
+                        pool->faulted = 1;
+                    } else if (!strcmp(state, "OFFLINE\n")) {
+                        pool->offline = 1;
+                    } else if (!strcmp(state, "REMOVED\n")) {
+                        pool->removed = 1;
+                    } else if (!strcmp(state, "UNAVAIL\n")) {
+                        pool->unavail = 1;
+                    } else {
+                        disable_zfs_pool_state(pool);
+
+                        char *c = strchr(state, '\n');
+                        if (c)
+                            *c = '\0';
+                        error("ZFS POOLS: Undefined state %s for zpool %s, disabling the chart", state, de->d_name);
+                    }
+                }
+            }
+        }
+
+        closedir(dir);
+    }
+
+    if (do_zfs_pool_state && pool_found && !state_file_found) {
+        info("ZFS POOLS: State files not found. Disabling the module.");
+        do_zfs_pool_state = 0;
+    }
+
+    if (do_zfs_pool_state)
+        dictionary_get_all_name_value(zfs_pools, update_zfs_pool_state_chart, &update_every);
+
+    while (deleted_zfs_pools) {
+        struct deleted_zfs_pool *current_pool = deleted_zfs_pools;
+        dictionary_del(zfs_pools, current_pool->name);
+
+        deleted_zfs_pools = deleted_zfs_pools->next;
+        
+        freez(current_pool->name);
+        freez(current_pool);
+    }
+
+    return 0;
+}