New upstream version 1.7.0+dfsgupstream/1.7.0+dfsg

1 files changed, 47 insertions, 1236 deletions

diff --git a/src/freebsd_sysctl.c b/src/freebsd_sysctl.c
index 965c1cbbf..d2f0eaa82 100644
--- a/src/freebsd_sysctl.c
+++ b/src/freebsd_sysctl.c
@@ -1,8 +1,6 @@
 #include "common.h"
 
 #include <sys/vmmeter.h>
-#include <sys/devicestat.h>
-#include <sys/mount.h>
 #include <vm/vm_param.h>
 
 #define _KERNEL
@@ -12,8 +10,6 @@
 #undef _KERNEL
 
 #include <net/netisr.h>
-#include <net/if.h>
-#include <ifaddrs.h>
 
 #include <netinet/ip.h>
 #include <netinet/ip_var.h>
@@ -29,12 +25,6 @@
 // --------------------------------------------------------------------------------------------------------------------
 // common definitions and variables
 
-#define KILO_FACTOR 1024
-#define MEGA_FACTOR 1048576     // 1024 * 1024
-#define GIGA_FACTOR 1073741824  // 1024 * 1024 * 1024
-
-#define MAX_INT_DIGITS 10 // maximum number of digits for int
-
 int system_pagesize = PAGE_SIZE;
 int number_of_cpus = 1;
 
@@ -311,8 +301,10 @@ int do_kern_cp_times(int update_every, usec_t dt) {
         static int mib[2] = {0, 0};
         long cp_time[CPUSTATES];
         static long *pcpu_cp_time = NULL;
+        static int old_number_of_cpus = 0;
 
-        pcpu_cp_time = reallocz(pcpu_cp_time, sizeof(cp_time) * number_of_cpus);
+        if(unlikely(number_of_cpus != old_number_of_cpus))
+            pcpu_cp_time = reallocz(pcpu_cp_time, sizeof(cp_time) * number_of_cpus);
         if (unlikely(GETSYSCTL_WSIZE("kern.cp_times", mib, pcpu_cp_time, sizeof(cp_time) * number_of_cpus))) {
             error("DISABLED: cpu.cpuXX charts");
             error("DISABLED: kern.cp_times module");
@@ -331,12 +323,10 @@ int do_kern_cp_times(int update_every, usec_t dt) {
                 RRDDIM *rd_interrupt;
                 RRDDIM *rd_idle;
             } *all_cpu_charts = NULL;
-            static int old_number_of_cpus = 0;
 
             if(unlikely(number_of_cpus > old_number_of_cpus)) {
                 all_cpu_charts = reallocz(all_cpu_charts, sizeof(struct cpu_chart) * number_of_cpus);
                 memset(&all_cpu_charts[old_number_of_cpus], 0, sizeof(struct cpu_chart) * (number_of_cpus - old_number_of_cpus));
-                old_number_of_cpus = number_of_cpus;
             }
 
             for (i = 0; i < number_of_cpus; i++) {
@@ -375,6 +365,8 @@ int do_kern_cp_times(int update_every, usec_t dt) {
                 rrdset_done(all_cpu_charts[i].st);
             }
         }
+
+        old_number_of_cpus = number_of_cpus;
     }
 
     return 0;
@@ -386,7 +378,7 @@ int do_kern_cp_times(int update_every, usec_t dt) {
 int do_hw_intcnt(int update_every, usec_t dt) {
     (void)dt;
     static int mib_hw_intrcnt[2] = {0, 0};
-    size_t intrcnt_size = sizeof(mib_hw_intrcnt);
+    size_t intrcnt_size = 0;
     unsigned long i;
 
     if (unlikely(GETSYSCTL_SIZE("hw.intrcnt", mib_hw_intrcnt, intrcnt_size))) {
@@ -396,11 +388,13 @@ int do_hw_intcnt(int update_every, usec_t dt) {
         return 1;
     } else {
         unsigned long nintr = 0;
+        static unsigned long old_nintr = 0;
         static unsigned long *intrcnt = NULL;
         unsigned long long totalintr = 0;
 
         nintr = intrcnt_size / sizeof(u_long);
-        intrcnt = reallocz(intrcnt, nintr * sizeof(u_long));
+        if (unlikely(nintr != old_nintr))
+            intrcnt = reallocz(intrcnt, nintr * sizeof(u_long));
         if (unlikely(GETSYSCTL_WSIZE("hw.intrcnt", mib_hw_intrcnt, intrcnt, nintr * sizeof(u_long)))) {
             error("DISABLED: system.intr chart");
             error("DISABLED: system.interrupts chart");
@@ -443,7 +437,8 @@ int do_hw_intcnt(int update_every, usec_t dt) {
             static char *intrnames = NULL;
 
             size = nintr * (MAXCOMLEN + 1);
-            intrnames = reallocz(intrnames, size);
+            if (unlikely(nintr != old_nintr))
+                intrnames = reallocz(intrnames, size);
             if (unlikely(GETSYSCTL_WSIZE("hw.intrnames", mib_hw_intrnames, intrnames, size))) {
                 error("DISABLED: system.intr chart");
                 error("DISABLED: system.interrupts chart");
@@ -484,6 +479,8 @@ int do_hw_intcnt(int update_every, usec_t dt) {
                 rrdset_done(st_interrupts);
             }
         }
+
+        old_nintr = nintr;
     }
 
     return 0;
@@ -931,8 +928,12 @@ int do_kern_ipc_sem(int update_every, usec_t dt) {
         return 1;
     } else {
         static struct semid_kernel *ipc_sem_data = NULL;
+        static int old_semmni = 0;
 
-        ipc_sem_data = reallocz(ipc_sem_data, sizeof(struct semid_kernel) * ipc_sem.semmni);
+        if (unlikely(ipc_sem.semmni != old_semmni)) {
+            ipc_sem_data = reallocz(ipc_sem_data, sizeof(struct semid_kernel) * ipc_sem.semmni);
+            old_semmni = ipc_sem.semmni;
+        }
         if (unlikely(GETSYSCTL_WSIZE("kern.ipc.sema", mib_sema, ipc_sem_data, sizeof(struct semid_kernel) * ipc_sem.semmni))) {
             error("DISABLED: system.ipc_semaphores chart");
             error("DISABLED: system.ipc_semaphore_arrays chart");
@@ -1019,8 +1020,12 @@ int do_kern_ipc_shm(int update_every, usec_t dt) {
         return 1;
     } else {
         static struct shmid_kernel *ipc_shm_data = NULL;
+        static u_long old_shmmni = 0;
 
-        ipc_shm_data = reallocz(ipc_shm_data, sizeof(struct shmid_kernel) * ipc_shm.shmmni);
+        if (unlikely(ipc_shm.shmmni != old_shmmni)) {
+            ipc_shm_data = reallocz(ipc_shm_data, sizeof(struct shmid_kernel) * ipc_shm.shmmni);
+            old_shmmni = ipc_shm.shmmni;
+        }
         if (unlikely(
                 GETSYSCTL_WSIZE("kern.ipc.shmsegs", mib_shmsegs, ipc_shm_data, sizeof(struct shmid_kernel) * ipc_shm.shmmni))) {
             error("DISABLED: system.ipc_shared_mem_segs chart");
@@ -1111,8 +1116,12 @@ int do_kern_ipc_msq(int update_every, usec_t dt) {
         return 1;
     } else {
         static struct msqid_kernel *ipc_msq_data = NULL;
+        static int old_msgmni = 0;
 
-        ipc_msq_data = reallocz(ipc_msq_data, sizeof(struct msqid_kernel) * ipc_msq.msgmni);
+        if (unlikely(ipc_msq.msgmni != old_msgmni)) {
+            ipc_msq_data = reallocz(ipc_msq_data, sizeof(struct msqid_kernel) * ipc_msq.msgmni);
+            old_msgmni = ipc_msq.msgmni;
+        }
         if (unlikely(
                 GETSYSCTL_WSIZE("kern.ipc.msqids", mib_msqids, ipc_msq_data, sizeof(struct msqid_kernel) * ipc_msq.msgmni))) {
             error("DISABLED: system.ipc_msq_queues chart");
@@ -1259,7 +1268,7 @@ int do_net_isr(int update_every, usec_t dt) {
 
     static int mib_workstream[3] = {0, 0, 0}, mib_work[3] = {0, 0, 0};
     int common_error = 0;
-    size_t netisr_workstream_size = sizeof(mib_workstream), netisr_work_size = sizeof(mib_work);
+    size_t netisr_workstream_size = 0, netisr_work_size = 0;
     unsigned long num_netisr_workstreams = 0, num_netisr_works = 0;
     static struct sysctl_netisr_workstream *netisr_workstream = NULL;
     static struct sysctl_netisr_work *netisr_work = NULL;
@@ -1276,14 +1285,25 @@ int do_net_isr(int update_every, usec_t dt) {
         } else if (unlikely(GETSYSCTL_SIZE("net.isr.work", mib_work, netisr_work_size))) {
             common_error = 1;
         } else {
+            static size_t old_netisr_workstream_size = 0;
+
             num_netisr_workstreams = netisr_workstream_size / sizeof(struct sysctl_netisr_workstream);
-            netisr_workstream = reallocz(netisr_workstream, num_netisr_workstreams * sizeof(struct sysctl_netisr_workstream));
+            if (unlikely(netisr_workstream_size != old_netisr_workstream_size)) {
+                netisr_workstream = reallocz(netisr_workstream,
+                                             num_netisr_workstreams * sizeof(struct sysctl_netisr_workstream));
+                old_netisr_workstream_size = netisr_workstream_size;
+            }
             if (unlikely(GETSYSCTL_WSIZE("net.isr.workstream", mib_workstream, netisr_workstream,
                                            num_netisr_workstreams * sizeof(struct sysctl_netisr_workstream)))){
                 common_error = 1;
             } else {
+                static size_t old_netisr_work_size = 0;
+
                 num_netisr_works = netisr_work_size / sizeof(struct sysctl_netisr_work);
-                netisr_work = reallocz(netisr_work, num_netisr_works * sizeof(struct sysctl_netisr_work));
+                if (unlikely(netisr_work_size != old_netisr_work_size)) {
+                    netisr_work = reallocz(netisr_work, num_netisr_works * sizeof(struct sysctl_netisr_work));
+                    old_netisr_work_size = netisr_work_size;
+                }
                 if (unlikely(GETSYSCTL_WSIZE("net.isr.work", mib_work, netisr_work,
                                                num_netisr_works * sizeof(struct sysctl_netisr_work)))){
                     common_error = 1;
@@ -1301,8 +1321,12 @@ int do_net_isr(int update_every, usec_t dt) {
         } else {
             unsigned long i, n;
             int j;
+            static int old_number_of_cpus = 0;
 
-            netisr_stats = reallocz(netisr_stats, (number_of_cpus + 1) * sizeof(struct netisr_stats));
+            if (unlikely(number_of_cpus != old_number_of_cpus)) {
+                netisr_stats = reallocz(netisr_stats, (number_of_cpus + 1) * sizeof(struct netisr_stats));
+                old_number_of_cpus = number_of_cpus;
+            }
             memset(netisr_stats, 0, (number_of_cpus + 1) * sizeof(struct netisr_stats));
             for (i = 0; i < num_netisr_workstreams; i++) {
                 for (n = 0; n < num_netisr_works; n++) {
@@ -2749,1216 +2773,3 @@ int do_net_inet6_icmp6_stats(int update_every, usec_t dt) {
 
     return 0;
 }
-
-// --------------------------------------------------------------------------------------------------------------------
-// getmntinfo
-
-int do_getmntinfo(int update_every, usec_t dt) {
-    (void)dt;
-
-#define DELAULT_EXLUDED_PATHS "/proc/*"
-// taken from gnulib/mountlist.c and shortened to FreeBSD related fstypes
-#define DEFAULT_EXCLUDED_FILESYSTEMS "autofs procfs subfs devfs none"
-#define CONFIG_SECTION_GETMNTINFO "plugin:freebsd:getmntinfo"
-
-    static int do_space = -1, do_inodes = -1;
-
-    if (unlikely(do_space == -1)) {
-        do_space  = config_get_boolean_ondemand(CONFIG_SECTION_GETMNTINFO, "space usage for all disks",  CONFIG_BOOLEAN_AUTO);
-        do_inodes = config_get_boolean_ondemand(CONFIG_SECTION_GETMNTINFO, "inodes usage for all disks", CONFIG_BOOLEAN_AUTO);
-    }
-
-    if (likely(do_space || do_inodes)) {
-        struct statfs *mntbuf;
-        int mntsize;
-
-        // there is no mount info in sysctl MIBs
-        if (unlikely(!(mntsize = getmntinfo(&mntbuf, MNT_NOWAIT)))) {
-            error("FREEBSD: getmntinfo() failed");
-            do_space = 0;
-            error("DISABLED: disk_space.* charts");
-            do_inodes = 0;
-            error("DISABLED: disk_inodes.* charts");
-            error("DISABLED: getmntinfo module");
-            return 1;
-        } else {
-            // Data to be stored in DICTIONARY mount_points.
-            // This DICTIONARY is used to lookup the settings of the mount point on each iteration.
-            struct mount_point_metadata {
-                int do_space;
-                int do_inodes;
-
-                size_t collected; // the number of times this has been collected
-
-                // charts and dimensions
-
-                RRDSET *st_space;
-                RRDDIM *rd_space_used;
-                RRDDIM *rd_space_avail;
-                RRDDIM *rd_space_reserved;
-
-                RRDSET *st_inodes;
-                RRDDIM *rd_inodes_used;
-                RRDDIM *rd_inodes_avail;
-            };
-            static DICTIONARY *mount_points = NULL;
-            static SIMPLE_PATTERN *excluded_mountpoints = NULL;
-            static SIMPLE_PATTERN *excluded_filesystems = NULL;
-            int i;
-
-            if(unlikely(!mount_points)) {
-
-                excluded_mountpoints = simple_pattern_create(
-                        config_get(CONFIG_SECTION_GETMNTINFO, "exclude space metrics on paths",
-                                   DELAULT_EXLUDED_PATHS),
-                        SIMPLE_PATTERN_EXACT
-                );
-
-                excluded_filesystems = simple_pattern_create(
-                        config_get(CONFIG_SECTION_GETMNTINFO, "exclude space metrics on filesystems",
-                                   DEFAULT_EXCLUDED_FILESYSTEMS),
-                        SIMPLE_PATTERN_EXACT
-                );
-
-                mount_points = dictionary_create(DICTIONARY_FLAG_SINGLE_THREADED);
-            }
-
-            for (i = 0; i < mntsize; i++) {
-
-                char title[4096 + 1];
-                int def_space, def_inodes, iter_space, iter_inodes;
-
-                struct mount_point_metadata *m = dictionary_get(mount_points, mntbuf[i].f_mntonname);
-                if(unlikely(!m)) {
-                    char var_name[4096 + 1];
-                    snprintfz(var_name, 4096, "%s:%s", CONFIG_SECTION_GETMNTINFO, mntbuf[i].f_mntonname);
-
-                    def_space = do_space;
-                    def_inodes = do_space;
-
-                    if(unlikely(simple_pattern_matches(excluded_mountpoints, mntbuf[i].f_mntonname))) {
-                        def_space = CONFIG_BOOLEAN_NO;
-                        def_inodes = CONFIG_BOOLEAN_NO;
-                    }
-
-                    if(unlikely(simple_pattern_matches(excluded_filesystems, mntbuf[i].f_fstypename))) {
-                        def_space = CONFIG_BOOLEAN_NO;
-                        def_inodes = CONFIG_BOOLEAN_NO;
-                    }
-
-                    iter_space  = config_get_boolean_ondemand(var_name, "space usage",  def_space);
-                    iter_inodes = config_get_boolean_ondemand(var_name, "inodes usage", def_inodes);
-
-                    struct mount_point_metadata mp = {
-                            .do_space = iter_space,
-                            .do_inodes = iter_inodes,
-
-                            .collected = 0,
-
-                            .st_space = NULL,
-                            .rd_space_avail = NULL,
-                            .rd_space_used = NULL,
-                            .rd_space_reserved = NULL,
-
-                            .st_inodes = NULL,
-                            .rd_inodes_avail = NULL,
-                            .rd_inodes_used = NULL,
-                    };
-
-                    m = dictionary_set(mount_points, mntbuf[i].f_mntonname, &mp, sizeof(struct mount_point_metadata));
-                }
-
-                if(unlikely(m->do_space == CONFIG_BOOLEAN_NO && m->do_inodes == CONFIG_BOOLEAN_NO))
-                    continue;
-
-                if(unlikely(mntbuf[i].f_flags & MNT_RDONLY && !m->collected))
-                    continue;
-
-                // --------------------------------------------------------------------------
-
-                int rendered = 0;
-
-                if (m->do_space == CONFIG_BOOLEAN_YES || (m->do_space == CONFIG_BOOLEAN_AUTO && (mntbuf[i].f_blocks > 2))) {
-                    if (unlikely(!m->st_space)) {
-                        snprintfz(title, 4096, "Disk Space Usage for %s [%s]",
-                                  mntbuf[i].f_mntonname, mntbuf[i].f_mntfromname);
-                        m->st_space = rrdset_create_localhost("disk_space",
-                                                              mntbuf[i].f_mntonname,
-                                                              NULL,
-                                                              mntbuf[i].f_mntonname,
-                                                              "disk.space",
-                                                              title,
-                                                              "GB",
-                                                              2023,
-                                                              update_every,
-                                                              RRDSET_TYPE_STACKED
-                        );
-
-                        m->rd_space_avail    = rrddim_add(m->st_space, "avail", NULL,
-                                                          mntbuf[i].f_bsize, GIGA_FACTOR, RRD_ALGORITHM_ABSOLUTE);
-                        m->rd_space_used     = rrddim_add(m->st_space, "used", NULL,
-                                                          mntbuf[i].f_bsize, GIGA_FACTOR, RRD_ALGORITHM_ABSOLUTE);
-                        m->rd_space_reserved = rrddim_add(m->st_space, "reserved_for_root", "reserved for root",
-                                                          mntbuf[i].f_bsize, GIGA_FACTOR, RRD_ALGORITHM_ABSOLUTE);
-                    } else
-                        rrdset_next(m->st_space);
-
-                    rrddim_set_by_pointer(m->st_space, m->rd_space_avail,    (collected_number) mntbuf[i].f_bavail);
-                    rrddim_set_by_pointer(m->st_space, m->rd_space_used,     (collected_number) (mntbuf[i].f_blocks -
-                                                                                                 mntbuf[i].f_bfree));
-                    rrddim_set_by_pointer(m->st_space, m->rd_space_reserved, (collected_number) (mntbuf[i].f_bfree -
-                                                                                                 mntbuf[i].f_bavail));
-                    rrdset_done(m->st_space);
-
-                    rendered++;
-                }
-
-                // --------------------------------------------------------------------------
-
-                if (m->do_inodes == CONFIG_BOOLEAN_YES || (m->do_inodes == CONFIG_BOOLEAN_AUTO && (mntbuf[i].f_files > 1))) {
-                    if (unlikely(!m->st_inodes)) {
-                        snprintfz(title, 4096, "Disk Files (inodes) Usage for %s [%s]",
-                                  mntbuf[i].f_mntonname, mntbuf[i].f_mntfromname);
-                        m->st_inodes = rrdset_create_localhost("disk_inodes",
-                                                               mntbuf[i].f_mntonname,
-                                                               NULL,
-                                                               mntbuf[i].f_mntonname,
-                                                               "disk.inodes",
-                                                               title,
-                                                               "Inodes",
-                                                               2024,
-                                                               update_every,
-                                                               RRDSET_TYPE_STACKED
-                        );
-
-                        m->rd_inodes_avail = rrddim_add(m->st_inodes, "avail", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
-                        m->rd_inodes_used  = rrddim_add(m->st_inodes, "used",  NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
-                    } else
-                        rrdset_next(m->st_inodes);
-
-                    rrddim_set_by_pointer(m->st_inodes, m->rd_inodes_avail, (collected_number) mntbuf[i].f_ffree);
-                    rrddim_set_by_pointer(m->st_inodes, m->rd_inodes_used,  (collected_number) (mntbuf[i].f_files -
-                                                                                                mntbuf[i].f_ffree));
-                    rrdset_done(m->st_inodes);
-
-                    rendered++;
-                }
-
-                if(likely(rendered))
-                    m->collected++;
-            }
-        }
-    } else {
-        error("DISABLED: getmntinfo module");
-        return 1;
-    }
-
-    return 0;
-}
-
-// --------------------------------------------------------------------------------------------------------------------
-// getifaddrs
-
-int do_getifaddrs(int update_every, usec_t dt) {
-    (void)dt;
-
-#define DELAULT_EXLUDED_INTERFACES "lo*"
-#define CONFIG_SECTION_GETIFADDRS "plugin:freebsd:getifaddrs"
-
-    static int do_bandwidth_ipv4 = -1, do_bandwidth_ipv6 = -1, do_bandwidth = -1, do_packets = -1,
-               do_errors = -1, do_drops = -1, do_events = -1;
-
-    if (unlikely(do_bandwidth_ipv4 == -1)) {
-        do_bandwidth_ipv4 = config_get_boolean_ondemand(CONFIG_SECTION_GETIFADDRS, "total bandwidth for ipv4 interfaces",
-                                                        CONFIG_BOOLEAN_AUTO);
-        do_bandwidth_ipv6 = config_get_boolean_ondemand(CONFIG_SECTION_GETIFADDRS, "total bandwidth for ipv6 interfaces",
-                                                        CONFIG_BOOLEAN_AUTO);
-        do_bandwidth      = config_get_boolean_ondemand(CONFIG_SECTION_GETIFADDRS, "bandwidth for all interfaces",
-                                                        CONFIG_BOOLEAN_AUTO);
-        do_packets        = config_get_boolean_ondemand(CONFIG_SECTION_GETIFADDRS, "packets for all interfaces",
-                                                        CONFIG_BOOLEAN_AUTO);
-        do_errors         = config_get_boolean_ondemand(CONFIG_SECTION_GETIFADDRS, "errors for all interfaces",
-                                                        CONFIG_BOOLEAN_AUTO);
-        do_drops          = config_get_boolean_ondemand(CONFIG_SECTION_GETIFADDRS, "drops for all interfaces",
-                                                        CONFIG_BOOLEAN_AUTO);
-        do_events         = config_get_boolean_ondemand(CONFIG_SECTION_GETIFADDRS, "collisions for all interfaces",
-                                                        CONFIG_BOOLEAN_AUTO);
-    }
-
-    if (likely(do_bandwidth_ipv4 || do_bandwidth_ipv6 || do_bandwidth || do_packets || do_errors ||
-               do_drops || do_events)) {
-        struct ifaddrs *ifap;
-
-        if (unlikely(getifaddrs(&ifap))) {
-            error("FREEBSD: getifaddrs() failed");
-            do_bandwidth_ipv4 = 0;
-            error("DISABLED: system.ipv4 chart");
-            do_bandwidth_ipv6 = 0;
-            error("DISABLED: system.ipv6 chart");
-            do_bandwidth = 0;
-            error("DISABLED: net.* charts");
-            do_packets = 0;
-            error("DISABLED: net_packets.* charts");
-            do_errors = 0;
-            error("DISABLED: net_errors.* charts");
-            do_drops = 0;
-            error("DISABLED: net_drops.* charts");
-            do_events = 0;
-            error("DISABLED: net_events.* charts");
-            error("DISABLED: getifaddrs module");
-            return 1;
-        } else {
-            #define IFA_DATA(s) (((struct if_data *)ifa->ifa_data)->ifi_ ## s)
-            struct ifaddrs *ifa;
-            struct iftot {
-                u_long  ift_ibytes;
-                u_long  ift_obytes;
-            } iftot = {0, 0};
-
-            // --------------------------------------------------------------------
-
-            if (likely(do_bandwidth_ipv4)) {
-                iftot.ift_ibytes = iftot.ift_obytes = 0;
-                for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
-                    if (ifa->ifa_addr->sa_family != AF_INET)
-                        continue;
-                    iftot.ift_ibytes += IFA_DATA(ibytes);
-                    iftot.ift_obytes += IFA_DATA(obytes);
-                }
-
-                static RRDSET *st = NULL;
-                static RRDDIM *rd_in = NULL, *rd_out = NULL;
-
-                if (unlikely(!st)) {
-                    st = rrdset_create_localhost("system",
-                                                 "ipv4",
-                                                 NULL,
-                                                 "network",
-                                                 NULL,
-                                                 "IPv4 Bandwidth",
-                                                 "kilobits/s",
-                                                 500,
-                                                 update_every,
-                                                 RRDSET_TYPE_AREA
-                    );
-
-                    rd_in  = rrddim_add(st, "InOctets",  "received", 8, KILO_FACTOR, RRD_ALGORITHM_INCREMENTAL);
-                    rd_out = rrddim_add(st, "OutOctets", "sent",    -8, KILO_FACTOR, RRD_ALGORITHM_INCREMENTAL);
-                } else
-                    rrdset_next(st);
-
-                rrddim_set_by_pointer(st, rd_in,  iftot.ift_ibytes);
-                rrddim_set_by_pointer(st, rd_out, iftot.ift_obytes);
-                rrdset_done(st);
-            }
-
-            // --------------------------------------------------------------------
-
-            if (likely(do_bandwidth_ipv6)) {
-                iftot.ift_ibytes = iftot.ift_obytes = 0;
-                for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
-                    if (ifa->ifa_addr->sa_family != AF_INET6)
-                        continue;
-                    iftot.ift_ibytes += IFA_DATA(ibytes);
-                    iftot.ift_obytes += IFA_DATA(obytes);
-                }
-
-                static RRDSET *st = NULL;
-                static RRDDIM *rd_in = NULL, *rd_out = NULL;
-
-                if (unlikely(!st)) {
-                    st = rrdset_create_localhost("system",
-                                                 "ipv6",
-                                                 NULL,
-                                                 "network",
-                                                 NULL,
-                                                 "IPv6 Bandwidth",
-                                                 "kilobits/s",
-                                                 500,
-                                                 update_every,
-                                                 RRDSET_TYPE_AREA
-                    );
-
-                    rd_in  = rrddim_add(st, "received", NULL,  8, KILO_FACTOR, RRD_ALGORITHM_INCREMENTAL);
-                    rd_out = rrddim_add(st, "sent",     NULL, -8, KILO_FACTOR, RRD_ALGORITHM_INCREMENTAL);
-                } else
-                    rrdset_next(st);
-
-                rrddim_set_by_pointer(st, rd_in,  iftot.ift_ibytes);
-                rrddim_set_by_pointer(st, rd_out, iftot.ift_obytes);
-                rrdset_done(st);
-            }
-
-            // --------------------------------------------------------------------
-
-            // Data to be stored in DICTIONARY interfaces.
-            // This DICTIONARY is used to lookup the settings of the interfaces on each iteration.
-            struct interfaces_metadata {
-                int do_bandwidth;
-                int do_packets;
-                int do_errors;
-                int do_drops;
-                int do_events;
-
-                // charts and dimensions
-
-                RRDSET *st_bandwidth;
-                RRDDIM *rd_bandwidth_in;
-                RRDDIM *rd_bandwidth_out;
-
-                RRDSET *st_packets;
-                RRDDIM *rd_packets_in;
-                RRDDIM *rd_packets_out;
-                RRDDIM *rd_packets_m_in;
-                RRDDIM *rd_packets_m_out;
-
-                RRDSET *st_errors;
-                RRDDIM *rd_errors_in;
-                RRDDIM *rd_errors_out;
-
-                RRDSET *st_drops;
-                RRDDIM *rd_drops_in;
-                RRDDIM *rd_drops_out;
-
-                RRDSET *st_events;
-                RRDDIM *rd_events_coll;
-            };
-            static DICTIONARY *interfaces = NULL;
-            static SIMPLE_PATTERN *excluded_interfaces = NULL;
-
-            if(unlikely(!interfaces)) {
-
-                excluded_interfaces = simple_pattern_create(
-                        config_get(CONFIG_SECTION_GETIFADDRS, "disable by default interfaces matching",
-                                   DELAULT_EXLUDED_INTERFACES)
-                        , SIMPLE_PATTERN_EXACT
-                );
-
-                interfaces = dictionary_create(DICTIONARY_FLAG_SINGLE_THREADED);
-            }
-
-            for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
-                if (ifa->ifa_addr->sa_family != AF_LINK)
-                    continue;
-
-                int def_bandwidth, def_packets, def_errors, def_drops, def_events,
-                    iter_bandwidth, iter_packets, iter_errors, iter_drops, iter_events;
-
-                struct interfaces_metadata *ifm = dictionary_get(interfaces, ifa->ifa_name);
-                if(unlikely(!ifm)) {
-                    char var_name[4096 + 1];
-                    snprintfz(var_name, 4096, "%s:%s", CONFIG_SECTION_GETIFADDRS, ifa->ifa_name);
-
-                    def_bandwidth = do_bandwidth;
-                    def_packets   = do_packets;
-                    def_errors    = do_errors;
-                    def_drops     = do_drops;
-                    def_events    = do_events;
-
-                    if(unlikely(simple_pattern_matches(excluded_interfaces, ifa->ifa_name))) {
-                        def_bandwidth = CONFIG_BOOLEAN_NO;
-                        def_packets   = CONFIG_BOOLEAN_NO;
-                        def_errors    = CONFIG_BOOLEAN_NO;
-                        def_drops     = CONFIG_BOOLEAN_NO;
-                        def_events    = CONFIG_BOOLEAN_NO;
-                    }
-
-                    iter_bandwidth = config_get_boolean_ondemand(var_name, "bandwidth", def_bandwidth);
-                    iter_packets   = config_get_boolean_ondemand(var_name, "packets",   def_packets);
-                    iter_errors    = config_get_boolean_ondemand(var_name, "errors",    def_errors);
-                    iter_drops     = config_get_boolean_ondemand(var_name, "drops",     def_drops);
-                    iter_events    = config_get_boolean_ondemand(var_name, "events",    def_events);
-
-                    struct interfaces_metadata ifmp = {
-                            .do_bandwidth = iter_bandwidth,
-                            .do_packets   = iter_packets,
-                            .do_errors    = iter_errors,
-                            .do_drops     = iter_drops,
-                            .do_events    = iter_events,
-
-                            .st_bandwidth = NULL,
-                            .rd_bandwidth_in = NULL,
-                            .rd_bandwidth_out = NULL,
-
-                            .st_packets = NULL,
-                            .rd_packets_in = NULL,
-                            .rd_packets_out = NULL,
-                            .rd_packets_m_in = NULL,
-                            .rd_packets_m_out = NULL,
-
-                            .st_errors = NULL,
-                            .rd_errors_in = NULL,
-                            .rd_errors_out = NULL,
-
-                            .st_drops = NULL,
-                            .rd_drops_in = NULL,
-                            .rd_drops_out = NULL,
-
-                            .st_events = NULL,
-                            .rd_events_coll = NULL,
-                    };
-
-                    ifm = dictionary_set(interfaces, ifa->ifa_name, &ifmp, sizeof(struct interfaces_metadata));
-                }
-
-                // --------------------------------------------------------------------
-
-                if (ifm->do_bandwidth == CONFIG_BOOLEAN_YES || (ifm->do_bandwidth == CONFIG_BOOLEAN_AUTO &&
-                        (IFA_DATA(ibytes) || IFA_DATA(obytes)))) {
-                    if (unlikely(!ifm->st_bandwidth)) {
-                        ifm->st_bandwidth = rrdset_create_localhost("net",
-                                                                    ifa->ifa_name,
-                                                                    NULL,
-                                                                    ifa->ifa_name,
-                                                                    "net.net",
-                                                                    "Bandwidth",
-                                                                    "kilobits/s",
-                                                                    7000,
-                                                                    update_every,
-                                                                    RRDSET_TYPE_AREA
-                        );
-
-                        ifm->rd_bandwidth_in  = rrddim_add(ifm->st_bandwidth, "received", NULL,  8, KILO_FACTOR,
-                                                           RRD_ALGORITHM_INCREMENTAL);
-                        ifm->rd_bandwidth_out = rrddim_add(ifm->st_bandwidth, "sent",     NULL, -8, KILO_FACTOR,
-                                                           RRD_ALGORITHM_INCREMENTAL);
-                    } else
-                        rrdset_next(ifm->st_bandwidth);
-
-                    rrddim_set_by_pointer(ifm->st_bandwidth, ifm->rd_bandwidth_in,  IFA_DATA(ibytes));
-                    rrddim_set_by_pointer(ifm->st_bandwidth, ifm->rd_bandwidth_out, IFA_DATA(obytes));
-                    rrdset_done(ifm->st_bandwidth);
-                }
-
-                // --------------------------------------------------------------------
-
-                if (ifm->do_packets == CONFIG_BOOLEAN_YES || (ifm->do_packets == CONFIG_BOOLEAN_AUTO &&
-                        (IFA_DATA(ipackets) || IFA_DATA(opackets) || IFA_DATA(imcasts) || IFA_DATA(omcasts)))) {
-                    if (unlikely(!ifm->st_packets)) {
-                        ifm->st_packets = rrdset_create_localhost("net_packets",
-                                                                  ifa->ifa_name,
-                                                                  NULL,
-                                                                  ifa->ifa_name,
-                                                                  "net.packets",
-                                                                  "Packets",
-                                                                  "packets/s",
-                                                                  7001,
-                                                                  update_every,
-                                                                  RRDSET_TYPE_LINE
-                        );
-
-                        rrdset_flag_set(ifm->st_packets, RRDSET_FLAG_DETAIL);
-
-                        ifm->rd_packets_in    = rrddim_add(ifm->st_packets, "received",           NULL,  1, 1,
-                                                           RRD_ALGORITHM_INCREMENTAL);
-                        ifm->rd_packets_out   = rrddim_add(ifm->st_packets, "sent",               NULL, -1, 1,
-                                                           RRD_ALGORITHM_INCREMENTAL);
-                        ifm->rd_packets_m_in  = rrddim_add(ifm->st_packets, "multicast_received", NULL,  1, 1,
-                                                           RRD_ALGORITHM_INCREMENTAL);
-                        ifm->rd_packets_m_out = rrddim_add(ifm->st_packets, "multicast_sent",     NULL, -1, 1,
-                                                           RRD_ALGORITHM_INCREMENTAL);
-                    } else
-                        rrdset_next(ifm->st_packets);
-
-                    rrddim_set_by_pointer(ifm->st_packets, ifm->rd_packets_in,    IFA_DATA(ipackets));
-                    rrddim_set_by_pointer(ifm->st_packets, ifm->rd_packets_out,   IFA_DATA(opackets));
-                    rrddim_set_by_pointer(ifm->st_packets, ifm->rd_packets_m_in,  IFA_DATA(imcasts));
-                    rrddim_set_by_pointer(ifm->st_packets, ifm->rd_packets_m_out, IFA_DATA(omcasts));
-                    rrdset_done(ifm->st_packets);
-                }
-
-                // --------------------------------------------------------------------
-
-                if (ifm->do_errors == CONFIG_BOOLEAN_YES || (ifm->do_errors == CONFIG_BOOLEAN_AUTO &&
-                        (IFA_DATA(ierrors) || IFA_DATA(oerrors)))) {
-                    if (unlikely(!ifm->st_errors)) {
-                        ifm->st_errors = rrdset_create_localhost("net_errors",
-                                                                 ifa->ifa_name,
-                                                                 NULL,
-                                                                 ifa->ifa_name,
-                                                                 "net.errors",
-                                                                 "Interface Errors",
-                                                                 "errors/s",
-                                                                 7002,
-                                                                 update_every,
-                                                                 RRDSET_TYPE_LINE
-                        );
-
-                        rrdset_flag_set(ifm->st_errors, RRDSET_FLAG_DETAIL);
-
-                        ifm->rd_errors_in  = rrddim_add(ifm->st_errors, "inbound",  NULL,  1, 1, RRD_ALGORITHM_INCREMENTAL);
-                        ifm->rd_errors_out = rrddim_add(ifm->st_errors, "outbound", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
-                    } else
-                        rrdset_next(ifm->st_errors);
-
-                    rrddim_set_by_pointer(ifm->st_errors, ifm->rd_errors_in,  IFA_DATA(ierrors));
-                    rrddim_set_by_pointer(ifm->st_errors, ifm->rd_errors_out, IFA_DATA(oerrors));
-                    rrdset_done(ifm->st_errors);
-                }
-                // --------------------------------------------------------------------
-
-                if (ifm->do_drops == CONFIG_BOOLEAN_YES || (ifm->do_drops == CONFIG_BOOLEAN_AUTO &&
-                        (IFA_DATA(iqdrops) || IFA_DATA(oqdrops)))) {
-                    if (unlikely(!ifm->st_drops)) {
-                        ifm->st_drops = rrdset_create_localhost("net_drops",
-                                                                ifa->ifa_name,
-                                                                NULL,
-                                                                ifa->ifa_name,
-                                                                "net.drops",
-                                                                "Interface Drops",
-                                                                "drops/s",
-                                                                7003,
-                                                                update_every,
-                                                                RRDSET_TYPE_LINE
-                        );
-
-                        rrdset_flag_set(ifm->st_drops, RRDSET_FLAG_DETAIL);
-
-                        ifm->rd_drops_in  = rrddim_add(ifm->st_drops, "inbound",  NULL,  1, 1, RRD_ALGORITHM_INCREMENTAL);
-#if __FreeBSD__ >= 11
-                        ifm->rd_drops_out = rrddim_add(ifm->st_drops, "outbound", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
-#endif
-                    } else
-                        rrdset_next(ifm->st_drops);
-
-                    rrddim_set_by_pointer(ifm->st_drops, ifm->rd_drops_in,  IFA_DATA(iqdrops));
-#if __FreeBSD__ >= 11
-                    rrddim_set_by_pointer(ifm->st_drops, ifm->rd_drops_out, IFA_DATA(oqdrops));
-#endif
-                    rrdset_done(ifm->st_drops);
-                }
-
-                // --------------------------------------------------------------------
-
-                if (ifm->do_events == CONFIG_BOOLEAN_YES || (ifm->do_events == CONFIG_BOOLEAN_AUTO &&
-                                                             IFA_DATA(collisions))) {
-                    if (unlikely(!ifm->st_events)) {
-                        ifm->st_events = rrdset_create_localhost("net_events",
-                                                                 ifa->ifa_name,
-                                                                 NULL,
-                                                                 ifa->ifa_name,
-                                                                 "net.events",
-                                                                 "Network Interface Events",
-                                                                 "events/s",
-                                                                 7006,
-                                                                 update_every,
-                                                                 RRDSET_TYPE_LINE
-                        );
-
-                        rrdset_flag_set(ifm->st_events, RRDSET_FLAG_DETAIL);
-
-                        ifm->rd_events_coll = rrddim_add(ifm->st_events, "collisions", NULL, -1, 1,
-                                                         RRD_ALGORITHM_INCREMENTAL);
-                    } else
-                        rrdset_next(ifm->st_events);
-
-                    rrddim_set_by_pointer(ifm->st_events, ifm->rd_events_coll, IFA_DATA(collisions));
-                    rrdset_done(ifm->st_events);
-                }
-            }
-
-            freeifaddrs(ifap);
-        }
-    } else {
-        error("DISABLED: getifaddrs module");
-        return 1;
-    }
-
-    return 0;
-}
-
-// --------------------------------------------------------------------------------------------------------------------
-// kern.devstat
-
-int do_kern_devstat(int update_every, usec_t dt) {
-
-#define DELAULT_EXLUDED_DISKS ""
-#define CONFIG_SECTION_KERN_DEVSTAT "plugin:freebsd:kern.devstat"
-#define BINTIME_SCALE 5.42101086242752217003726400434970855712890625e-17 // this is 1000/2^64
-
-    static int enable_pass_devices = -1, do_system_io = -1, do_io = -1, do_ops = -1, do_qops = -1, do_util = -1,
-               do_iotime = -1, do_await = -1, do_avagsz = -1, do_svctm = -1;
-
-    if (unlikely(enable_pass_devices == -1)) {
-        enable_pass_devices = config_get_boolean_ondemand(CONFIG_SECTION_KERN_DEVSTAT,
-                                                          "performance metrics for pass devices", CONFIG_BOOLEAN_AUTO);
-
-        do_system_io = config_get_boolean_ondemand(CONFIG_SECTION_KERN_DEVSTAT, "total bandwidth for all disks",
-                                                   CONFIG_BOOLEAN_YES);
-
-        do_io     = config_get_boolean_ondemand(CONFIG_SECTION_KERN_DEVSTAT, "bandwidth for all disks",
-                                                CONFIG_BOOLEAN_AUTO);
-        do_ops    = config_get_boolean_ondemand(CONFIG_SECTION_KERN_DEVSTAT, "operations for all disks",
-                                                CONFIG_BOOLEAN_AUTO);
-        do_qops   = config_get_boolean_ondemand(CONFIG_SECTION_KERN_DEVSTAT, "queued operations for all disks",
-                                                CONFIG_BOOLEAN_AUTO);
-        do_util   = config_get_boolean_ondemand(CONFIG_SECTION_KERN_DEVSTAT, "utilization percentage for all disks",
-                                                CONFIG_BOOLEAN_AUTO);
-        do_iotime = config_get_boolean_ondemand(CONFIG_SECTION_KERN_DEVSTAT, "i/o time for all disks",
-                                                CONFIG_BOOLEAN_AUTO);
-        do_await  = config_get_boolean_ondemand(CONFIG_SECTION_KERN_DEVSTAT, "average completed i/o time for all disks",
-                                                CONFIG_BOOLEAN_AUTO);
-        do_avagsz = config_get_boolean_ondemand(CONFIG_SECTION_KERN_DEVSTAT, "average completed i/o bandwidth for all disks",
-                                                CONFIG_BOOLEAN_AUTO);
-        do_svctm  = config_get_boolean_ondemand(CONFIG_SECTION_KERN_DEVSTAT, "average service time for all disks",
-                                                CONFIG_BOOLEAN_AUTO);
-    }
-
-    if (likely(do_system_io || do_io || do_ops || do_qops || do_util || do_iotime || do_await || do_avagsz || do_svctm)) {
-        static int mib_numdevs[3] = {0, 0, 0};
-        int numdevs;
-        int common_error = 0;
-
-        if (unlikely(GETSYSCTL_SIMPLE("kern.devstat.numdevs", mib_numdevs, numdevs))) {
-            common_error = 1;
-        } else {
-            static int mib_devstat[3] = {0, 0, 0};
-            static void *devstat_data = NULL;
-
-            devstat_data = reallocz(devstat_data, sizeof(long) + sizeof(struct devstat) * numdevs); // there is generation number before devstat structures
-            if (unlikely(GETSYSCTL_WSIZE("kern.devstat.all", mib_devstat, devstat_data,
-                                         sizeof(long) + sizeof(struct devstat) * numdevs))) {
-                common_error = 1;
-            } else {
-                struct devstat *dstat;
-                int i;
-                collected_number total_disk_kbytes_read = 0;
-                collected_number total_disk_kbytes_write = 0;
-
-                // Data to be stored in DICTIONARY disks.
-                // This DICTIONARY is used to lookup the settings of the disks on each iteration.
-                struct disks_metadata {
-                    int do_io;
-                    int do_ops;
-                    int do_qops;
-                    int do_util;
-                    int do_iotime;
-                    int do_await;
-                    int do_avagsz;
-                    int do_svctm;
-
-
-                    // data for differential charts
-
-                    struct prev_dstat {
-                        collected_number bytes_read;
-                        collected_number bytes_write;
-                        collected_number operations_read;
-                        collected_number operations_write;
-                        collected_number duration_read_ms;
-                        collected_number duration_write_ms;
-                        collected_number busy_time_ms;
-                    } prev_dstat;
-
-                    // charts and dimensions
-
-                    RRDSET *st_io;
-                    RRDDIM *rd_io_in;
-                    RRDDIM *rd_io_out;
-
-                    RRDSET *st_ops;
-                    RRDDIM *rd_ops_in;
-                    RRDDIM *rd_ops_out;
-
-                    RRDSET *st_qops;
-                    RRDDIM *rd_qops;
-
-                    RRDSET *st_util;
-                    RRDDIM *rd_util;
-
-                    RRDSET *st_iotime;
-                    RRDDIM *rd_iotime_in;
-                    RRDDIM *rd_iotime_out;
-
-                    RRDSET *st_await;
-                    RRDDIM *rd_await_in;
-                    RRDDIM *rd_await_out;
-
-                    RRDSET *st_avagsz;
-                    RRDDIM *rd_avagsz_in;
-                    RRDDIM *rd_avagsz_out;
-
-                    RRDSET *st_svctm;
-                    RRDDIM *rd_svctm;
-
-                };
-                static DICTIONARY *disks = NULL;
-                static SIMPLE_PATTERN *excluded_disks = NULL;
-
-                if(unlikely(!disks)) {
-
-                    excluded_disks = simple_pattern_create(
-                            config_get(CONFIG_SECTION_KERN_DEVSTAT, "disable by default disks matching",
-                                       DELAULT_EXLUDED_DISKS)
-                            , SIMPLE_PATTERN_EXACT
-                    );
-
-                    disks = dictionary_create(DICTIONARY_FLAG_SINGLE_THREADED);
-                }
-
-                dstat = devstat_data + sizeof(long); // skip generation number
-
-                for (i = 0; i < numdevs; i++) {
-                    if (likely(do_system_io)) {
-                        if (((dstat[i].device_type & DEVSTAT_TYPE_MASK) == DEVSTAT_TYPE_DIRECT) || ((dstat[i].device_type & DEVSTAT_TYPE_MASK) == DEVSTAT_TYPE_STORARRAY)) {
-                            total_disk_kbytes_read += dstat[i].bytes[DEVSTAT_READ] / KILO_FACTOR;
-                            total_disk_kbytes_write += dstat[i].bytes[DEVSTAT_WRITE] / KILO_FACTOR;
-                        }
-                    }
-
-                    if (unlikely(!enable_pass_devices))
-                        if ((dstat[i].device_type & DEVSTAT_TYPE_PASS) == DEVSTAT_TYPE_PASS)
-                            continue;
-
-                    if (((dstat[i].device_type & DEVSTAT_TYPE_MASK) == DEVSTAT_TYPE_DIRECT) || ((dstat[i].device_type & DEVSTAT_TYPE_MASK) == DEVSTAT_TYPE_STORARRAY)) {
-                        char disk[DEVSTAT_NAME_LEN + MAX_INT_DIGITS + 1];
-                        int def_io, def_ops, def_qops, def_util, def_iotime, def_await, def_avagsz, def_svctm,
-                            iter_io, iter_ops, iter_qops, iter_util, iter_iotime, iter_await, iter_avagsz, iter_svctm;
-                        struct cur_dstat {
-                            collected_number duration_read_ms;
-                            collected_number duration_write_ms;
-                            collected_number busy_time_ms;
-                        } cur_dstat;
-
-                        sprintf(disk, "%s%d", dstat[i].device_name, dstat[i].unit_number);
-
-                        struct disks_metadata *dm = dictionary_get(disks, disk);
-                        if(unlikely(!dm)) {
-                            char var_name[4096 + 1];
-                            snprintfz(var_name, 4096, "%s:%s", CONFIG_SECTION_KERN_DEVSTAT, disk);
-
-                            def_io     = do_io;
-                            def_ops    = do_ops;
-                            def_qops   = do_qops;
-                            def_util   = do_util;
-                            def_iotime = do_iotime;
-                            def_await  = do_await;
-                            def_avagsz = do_avagsz;
-                            def_svctm  = do_svctm;
-
-                            if(unlikely(simple_pattern_matches(excluded_disks, disk))) {
-                                def_io     = CONFIG_BOOLEAN_NO;
-                                def_ops    = CONFIG_BOOLEAN_NO;
-                                def_qops   = CONFIG_BOOLEAN_NO;
-                                def_util   = CONFIG_BOOLEAN_NO;
-                                def_iotime = CONFIG_BOOLEAN_NO;
-                                def_await  = CONFIG_BOOLEAN_NO;
-                                def_avagsz = CONFIG_BOOLEAN_NO;
-                                def_svctm  = CONFIG_BOOLEAN_NO;
-                            }
-
-                            iter_io     = config_get_boolean_ondemand(var_name, "bandwidth",                  def_io);
-                            iter_ops    = config_get_boolean_ondemand(var_name, "operations",                 def_ops);
-                            iter_qops   = config_get_boolean_ondemand(var_name, "queued operations",          def_qops);
-                            iter_util   = config_get_boolean_ondemand(var_name, "utilization percentage",     def_util);
-                            iter_iotime = config_get_boolean_ondemand(var_name, "i/o time",                   def_iotime);
-                            iter_await  = config_get_boolean_ondemand(var_name, "average completed i/o time", def_await);
-                            iter_avagsz = config_get_boolean_ondemand(var_name, "average completed i/o bandwidth",
-                                                                                                              def_avagsz);
-                            iter_svctm  = config_get_boolean_ondemand(var_name, "average service time",       def_svctm);
-
-                            struct disks_metadata dmp = {
-                                    .do_io     = iter_io,
-                                    .do_ops    = iter_ops,
-                                    .do_qops   = iter_qops,
-                                    .do_util   = iter_util,
-                                    .do_iotime = iter_iotime,
-                                    .do_await  = iter_await,
-                                    .do_avagsz = iter_avagsz,
-                                    .do_svctm  = iter_svctm,
-
-                                    .st_io = NULL,
-                                    .rd_io_in = NULL,
-                                    .rd_io_out = NULL,
-
-                                    .st_ops = NULL,
-                                    .rd_ops_in = NULL,
-                                    .rd_ops_out = NULL,
-
-                                    .st_qops = NULL,
-                                    .rd_qops = NULL,
-
-                                    .st_util = NULL,
-                                    .rd_util = NULL,
-
-                                    .st_iotime = NULL,
-                                    .rd_iotime_in = NULL,
-                                    .rd_iotime_out = NULL,
-
-                                    .st_await = NULL,
-                                    .rd_await_in = NULL,
-                                    .rd_await_out = NULL,
-
-                                    .st_avagsz = NULL,
-                                    .rd_avagsz_in = NULL,
-                                    .rd_avagsz_out = NULL,
-
-                                    .st_svctm = NULL,
-                                    .rd_svctm = NULL,
-                            };
-
-                            // initialise data for differential charts
-
-                            dmp.prev_dstat.bytes_read        = dstat[i].bytes[DEVSTAT_READ];
-                            dmp.prev_dstat.bytes_write       = dstat[i].bytes[DEVSTAT_WRITE];
-                            dmp.prev_dstat.operations_read   = dstat[i].operations[DEVSTAT_READ];
-                            dmp.prev_dstat.operations_write  = dstat[i].operations[DEVSTAT_WRITE];
-                            dmp.prev_dstat.duration_read_ms  = dstat[i].duration[DEVSTAT_READ].sec * 1000
-                                                               + dstat[i].duration[DEVSTAT_READ].frac * BINTIME_SCALE;
-                            dmp.prev_dstat.duration_write_ms = dstat[i].duration[DEVSTAT_WRITE].sec * 1000
-                                                               + dstat[i].duration[DEVSTAT_READ].frac * BINTIME_SCALE;
-                            dmp.prev_dstat.busy_time_ms      = dstat[i].busy_time.sec * 1000
-                                                               + dstat[i].busy_time.frac * BINTIME_SCALE;
-
-                            dm = dictionary_set(disks, disk, &dmp, sizeof(struct disks_metadata));
-                        }
-
-                        cur_dstat.duration_read_ms  = dstat[i].duration[DEVSTAT_READ].sec * 1000
-                                                      + dstat[i].duration[DEVSTAT_READ].frac * BINTIME_SCALE;
-                        cur_dstat.duration_write_ms = dstat[i].duration[DEVSTAT_WRITE].sec * 1000
-                                                      + dstat[i].duration[DEVSTAT_READ].frac * BINTIME_SCALE;
-                        cur_dstat.busy_time_ms = dstat[i].busy_time.sec * 1000 + dstat[i].busy_time.frac * BINTIME_SCALE;
-
-                        // --------------------------------------------------------------------
-
-                        if(dm->do_io == CONFIG_BOOLEAN_YES || (dm->do_io == CONFIG_BOOLEAN_AUTO &&
-                                (dstat[i].bytes[DEVSTAT_READ] || dstat[i].bytes[DEVSTAT_WRITE]))) {
-                            if (unlikely(!dm->st_io)) {
-                                dm->st_io = rrdset_create_localhost("disk",
-                                                                    disk,
-                                                                    NULL,
-                                                                    disk,
-                                                                    "disk.io",
-                                                                    "Disk I/O Bandwidth",
-                                                                    "kilobytes/s",
-                                                                    2000,
-                                                                    update_every,
-                                                                    RRDSET_TYPE_AREA
-                                );
-
-                                dm->rd_io_in  = rrddim_add(dm->st_io, "reads",  NULL,  1, KILO_FACTOR,
-                                                          RRD_ALGORITHM_INCREMENTAL);
-                                dm->rd_io_out = rrddim_add(dm->st_io, "writes", NULL, -1, KILO_FACTOR,
-                                                           RRD_ALGORITHM_INCREMENTAL);
-                            } else
-                                rrdset_next(dm->st_io);
-
-                            rrddim_set_by_pointer(dm->st_io, dm->rd_io_in,  dstat[i].bytes[DEVSTAT_READ]);
-                            rrddim_set_by_pointer(dm->st_io, dm->rd_io_out, dstat[i].bytes[DEVSTAT_WRITE]);
-                            rrdset_done(dm->st_io);
-                        }
-
-                        // --------------------------------------------------------------------
-
-                        if(dm->do_ops == CONFIG_BOOLEAN_YES || (dm->do_ops == CONFIG_BOOLEAN_AUTO &&
-                                (dstat[i].operations[DEVSTAT_READ] || dstat[i].operations[DEVSTAT_WRITE]))) {
-                            if (unlikely(!dm->st_ops)) {
-                                dm->st_ops = rrdset_create_localhost("disk_ops",
-                                                                     disk,
-                                                                     NULL,
-                                                                     disk,
-                                                                     "disk.ops",
-                                                                     "Disk Completed I/O Operations",
-                                                                     "operations/s",
-                                                                     2001,
-                                                                     update_every,
-                                                                     RRDSET_TYPE_LINE
-                                );
-
-                                rrdset_flag_set(dm->st_ops, RRDSET_FLAG_DETAIL);
-
-                                dm->rd_ops_in = rrddim_add(dm->st_ops, "reads", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
-                                dm->rd_ops_out = rrddim_add(dm->st_ops, "writes", NULL, -1, 1,
-                                                            RRD_ALGORITHM_INCREMENTAL);
-                            } else
-                                rrdset_next(dm->st_ops);
-
-                            rrddim_set_by_pointer(dm->st_ops, dm->rd_ops_in, dstat[i].operations[DEVSTAT_READ]);
-                            rrddim_set_by_pointer(dm->st_ops, dm->rd_ops_out, dstat[i].operations[DEVSTAT_WRITE]);
-                            rrdset_done(dm->st_ops);
-                        }
-
-                        // --------------------------------------------------------------------
-
-                        if(dm->do_qops == CONFIG_BOOLEAN_YES || (dm->do_qops == CONFIG_BOOLEAN_AUTO &&
-                                (dstat[i].start_count || dstat[i].end_count))) {
-                            if (unlikely(!dm->st_qops)) {
-                                dm->st_qops = rrdset_create_localhost("disk_qops",
-                                                                      disk,
-                                                                      NULL,
-                                                                      disk,
-                                                                      "disk.qops",
-                                                                      "Disk Current I/O Operations",
-                                                                      "operations",
-                                                                      2002,
-                                                                      update_every,
-                                                                      RRDSET_TYPE_LINE
-                                );
-
-                                rrdset_flag_set(dm->st_qops, RRDSET_FLAG_DETAIL);
-
-                                dm->rd_qops = rrddim_add(dm->st_qops, "operations", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
-                            } else
-                                rrdset_next(dm->st_qops);
-
-                            rrddim_set_by_pointer(dm->st_qops, dm->rd_qops, dstat[i].start_count - dstat[i].end_count);
-                            rrdset_done(dm->st_qops);
-                        }
-
-                        // --------------------------------------------------------------------
-
-                        if(dm->do_util == CONFIG_BOOLEAN_YES || (dm->do_util == CONFIG_BOOLEAN_AUTO &&
-                                                                 cur_dstat.busy_time_ms)) {
-                            if (unlikely(!dm->st_util)) {
-                                dm->st_util = rrdset_create_localhost("disk_util",
-                                                                      disk,
-                                                                      NULL,
-                                                                      disk,
-                                                                      "disk.util",
-                                                                      "Disk Utilization Time",
-                                                                      "% of time working",
-                                                                      2004,
-                                                                      update_every,
-                                                                      RRDSET_TYPE_AREA
-                                );
-
-                                rrdset_flag_set(dm->st_util, RRDSET_FLAG_DETAIL);
-
-                                dm->rd_util = rrddim_add(dm->st_util, "utilization", NULL, 1, 10,
-                                                         RRD_ALGORITHM_INCREMENTAL);
-                            } else
-                                rrdset_next(dm->st_util);
-
-                            rrddim_set_by_pointer(dm->st_util, dm->rd_util, cur_dstat.busy_time_ms);
-                            rrdset_done(dm->st_util);
-                        }
-
-                        // --------------------------------------------------------------------
-
-                        if(dm->do_iotime == CONFIG_BOOLEAN_YES || (dm->do_iotime == CONFIG_BOOLEAN_AUTO &&
-                                (cur_dstat.duration_read_ms || cur_dstat.duration_write_ms))) {
-                            if (unlikely(!dm->st_iotime)) {
-                                dm->st_iotime = rrdset_create_localhost("disk_iotime",
-                                                                        disk,
-                                                                        NULL,
-                                                                        disk,
-                                                                        "disk.iotime",
-                                                                        "Disk Total I/O Time",
-                                                                        "milliseconds/s",
-                                                                        2022,
-                                                                        update_every,
-                                                                        RRDSET_TYPE_LINE
-                                );
-
-                                rrdset_flag_set(dm->st_iotime, RRDSET_FLAG_DETAIL);
-
-                                dm->rd_iotime_in  = rrddim_add(dm->st_iotime, "reads",  NULL,  1, 1,
-                                                               RRD_ALGORITHM_INCREMENTAL);
-                                dm->rd_iotime_out = rrddim_add(dm->st_iotime, "writes", NULL, -1, 1,
-                                                               RRD_ALGORITHM_INCREMENTAL);
-                            } else
-                                rrdset_next(dm->st_iotime);
-
-                            rrddim_set_by_pointer(dm->st_iotime, dm->rd_iotime_in,  cur_dstat.duration_read_ms);
-                            rrddim_set_by_pointer(dm->st_iotime, dm->rd_iotime_out, cur_dstat.duration_write_ms);
-                            rrdset_done(dm->st_iotime);
-                        }
-
-                        // --------------------------------------------------------------------
-                        // calculate differential charts
-                        // only if this is not the first time we run
-
-                        if (likely(dt)) {
-
-                            // --------------------------------------------------------------------
-
-                            if(dm->do_await == CONFIG_BOOLEAN_YES || (dm->do_await == CONFIG_BOOLEAN_AUTO &&
-                                    (dstat[i].operations[DEVSTAT_READ] || dstat[i].operations[DEVSTAT_WRITE]))) {
-                                if (unlikely(!dm->st_await)) {
-                                    dm->st_await = rrdset_create_localhost("disk_await",
-                                                                           disk,
-                                                                           NULL,
-                                                                           disk,
-                                                                           "disk.await",
-                                                                           "Average Completed I/O Operation Time",
-                                                                           "ms per operation",
-                                                                           2005,
-                                                                           update_every,
-                                                                           RRDSET_TYPE_LINE
-                                    );
-
-                                    rrdset_flag_set(dm->st_await, RRDSET_FLAG_DETAIL);
-
-                                    dm->rd_await_in  = rrddim_add(dm->st_await, "reads",  NULL,  1, 1,
-                                                                  RRD_ALGORITHM_ABSOLUTE);
-                                    dm->rd_await_out = rrddim_add(dm->st_await, "writes", NULL, -1, 1,
-                                                                  RRD_ALGORITHM_ABSOLUTE);
-                                } else
-                                    rrdset_next(dm->st_await);
-
-                                rrddim_set_by_pointer(dm->st_await, dm->rd_await_in,
-                                                      (dstat[i].operations[DEVSTAT_READ] -
-                                                       dm->prev_dstat.operations_read) ?
-                                                      (cur_dstat.duration_read_ms - dm->prev_dstat.duration_read_ms) /
-                                                      (dstat[i].operations[DEVSTAT_READ] -
-                                                       dm->prev_dstat.operations_read) :
-                                                      0);
-                                rrddim_set_by_pointer(dm->st_await, dm->rd_await_out,
-                                                      (dstat[i].operations[DEVSTAT_WRITE] -
-                                                       dm->prev_dstat.operations_write) ?
-                                                      (cur_dstat.duration_write_ms - dm->prev_dstat.duration_write_ms) /
-                                                      (dstat[i].operations[DEVSTAT_WRITE] -
-                                                       dm->prev_dstat.operations_write) :
-                                                      0);
-                                rrdset_done(dm->st_await);
-                            }
-
-                            // --------------------------------------------------------------------
-
-                            if(dm->do_avagsz == CONFIG_BOOLEAN_YES || (dm->do_avagsz == CONFIG_BOOLEAN_AUTO &&
-                                    (dstat[i].operations[DEVSTAT_READ] || dstat[i].operations[DEVSTAT_WRITE]))) {
-                                if (unlikely(!dm->st_avagsz)) {
-                                    dm->st_avagsz = rrdset_create_localhost("disk_avgsz",
-                                                                            disk,
-                                                                            NULL,
-                                                                            disk,
-                                                                            "disk.avgsz",
-                                                                            "Average Completed I/O Operation Bandwidth",
-                                                                            "kilobytes per operation",
-                                                                            2006,
-                                                                            update_every,
-                                                                            RRDSET_TYPE_AREA
-                                    );
-
-                                    rrdset_flag_set(dm->st_avagsz, RRDSET_FLAG_DETAIL);
-
-                                    dm->rd_avagsz_in  = rrddim_add(dm->st_avagsz, "reads",  NULL,  1, KILO_FACTOR,
-                                                                  RRD_ALGORITHM_ABSOLUTE);
-                                    dm->rd_avagsz_out = rrddim_add(dm->st_avagsz, "writes", NULL, -1, KILO_FACTOR,
-                                                                   RRD_ALGORITHM_ABSOLUTE);
-                                } else
-                                    rrdset_next(dm->st_avagsz);
-
-                                rrddim_set_by_pointer(dm->st_avagsz, dm->rd_avagsz_in,
-                                                      (dstat[i].operations[DEVSTAT_READ] -
-                                                       dm->prev_dstat.operations_read) ?
-                                                      (dstat[i].bytes[DEVSTAT_READ] - dm->prev_dstat.bytes_read) /
-                                                      (dstat[i].operations[DEVSTAT_READ] -
-                                                       dm->prev_dstat.operations_read) :
-                                                      0);
-                                rrddim_set_by_pointer(dm->st_avagsz, dm->rd_avagsz_out,
-                                                      (dstat[i].operations[DEVSTAT_WRITE] -
-                                                       dm->prev_dstat.operations_write) ?
-                                                      (dstat[i].bytes[DEVSTAT_WRITE] - dm->prev_dstat.bytes_write) /
-                                                      (dstat[i].operations[DEVSTAT_WRITE] -
-                                                       dm->prev_dstat.operations_write) :
-                                                      0);
-                                rrdset_done(dm->st_avagsz);
-                            }
-
-                            // --------------------------------------------------------------------
-
-                            if(dm->do_svctm == CONFIG_BOOLEAN_YES || (dm->do_svctm == CONFIG_BOOLEAN_AUTO &&
-                                    (dstat[i].operations[DEVSTAT_READ] || dstat[i].operations[DEVSTAT_WRITE]))) {
-                                if (unlikely(!dm->st_svctm)) {
-                                    dm->st_svctm = rrdset_create_localhost("disk_svctm",
-                                                                           disk,
-                                                                           NULL,
-                                                                           disk,
-                                                                           "disk.svctm",
-                                                                           "Average Service Time",
-                                                                           "ms per operation",
-                                                                           2007,
-                                                                           update_every,
-                                                                           RRDSET_TYPE_LINE
-                                    );
-
-                                    rrdset_flag_set(dm->st_svctm, RRDSET_FLAG_DETAIL);
-
-                                    dm->rd_svctm = rrddim_add(dm->st_svctm, "svctm", NULL, 1, 1,
-                                                              RRD_ALGORITHM_ABSOLUTE);
-                                } else
-                                    rrdset_next(dm->st_svctm);
-
-                                rrddim_set_by_pointer(dm->st_svctm, dm->rd_svctm,
-                                    ((dstat[i].operations[DEVSTAT_READ] - dm->prev_dstat.operations_read) +
-                                     (dstat[i].operations[DEVSTAT_WRITE] - dm->prev_dstat.operations_write)) ?
-                                    (cur_dstat.busy_time_ms - dm->prev_dstat.busy_time_ms) /
-                                    ((dstat[i].operations[DEVSTAT_READ] - dm->prev_dstat.operations_read) +
-                                     (dstat[i].operations[DEVSTAT_WRITE] - dm->prev_dstat.operations_write)) :
-                                    0);
-                                rrdset_done(dm->st_svctm);
-                            }
-
-                            // --------------------------------------------------------------------
-
-                            dm->prev_dstat.bytes_read        = dstat[i].bytes[DEVSTAT_READ];
-                            dm->prev_dstat.bytes_write       = dstat[i].bytes[DEVSTAT_WRITE];
-                            dm->prev_dstat.operations_read   = dstat[i].operations[DEVSTAT_READ];
-                            dm->prev_dstat.operations_write  = dstat[i].operations[DEVSTAT_WRITE];
-                            dm->prev_dstat.duration_read_ms  = cur_dstat.duration_read_ms;
-                            dm->prev_dstat.duration_write_ms = cur_dstat.duration_write_ms;
-                            dm->prev_dstat.busy_time_ms      = cur_dstat.busy_time_ms;
-                        }
-                    }
-                }
-
-                // --------------------------------------------------------------------
-
-                if (likely(do_system_io)) {
-                    static RRDSET *st = NULL;
-                    static RRDDIM *rd_in = NULL, *rd_out = NULL;
-
-                    if (unlikely(!st)) {
-                        st = rrdset_create_localhost("system",
-                                                     "io",
-                                                     NULL,
-                                                     "disk",
-                                                     NULL,
-                                                     "Disk I/O",
-                                                     "kilobytes/s",
-                                                     150,
-                                                     update_every,
-                                                     RRDSET_TYPE_AREA
-                        );
-
-                        rd_in  = rrddim_add(st, "in",  NULL,  1, 1, RRD_ALGORITHM_INCREMENTAL);
-                        rd_out = rrddim_add(st, "out", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
-                    } else
-                        rrdset_next(st);
-
-                    rrddim_set_by_pointer(st, rd_in,  total_disk_kbytes_read);
-                    rrddim_set_by_pointer(st, rd_out, total_disk_kbytes_write);
-                    rrdset_done(st);
-                }
-            }
-        }
-        if (unlikely(common_error)) {
-            do_system_io = 0;
-            error("DISABLED: system.io chart");
-            do_io = 0;
-            error("DISABLED: disk.* charts");
-            do_ops = 0;
-            error("DISABLED: disk_ops.* charts");
-            do_qops = 0;
-            error("DISABLED: disk_qops.* charts");
-            do_util = 0;
-            error("DISABLED: disk_util.* charts");
-            do_iotime = 0;
-            error("DISABLED: disk_iotime.* charts");
-            do_await = 0;
-            error("DISABLED: disk_await.* charts");
-            do_avagsz = 0;
-            error("DISABLED: disk_avgsz.* charts");
-            do_svctm = 0;
-            error("DISABLED: disk_svctm.* charts");
-            error("DISABLED: kern.devstat module");
-            return 1;
-        }
-    } else {
-        error("DISABLED: kern.devstat module");
-        return 1;
-    }
-
-    return 0;
-}