src/freebsd_sysctl.c

   1 #include "common.h"
   2
   3 // NEEDED BY: struct vmtotal, struct vmmeter
   4 #include <sys/vmmeter.h>
   5 // NEEDED BY: struct devstat
   6 #include <sys/devicestat.h>
   7 // NEEDED BY: struct xswdev
   8 #include <vm/vm_param.h>
   9 // NEEDED BY: struct semid_kernel, struct shmid_kernel, struct msqid_kernel
  10 #define _KERNEL
  11 #include <sys/sem.h>
  12 #include <sys/shm.h>
  13 #include <sys/msg.h>
  14 #undef _KERNEL
  15 // NEEDED BY: struct sysctl_netisr_workstream, struct sysctl_netisr_work
  16 #include <net/netisr.h>
  17 // NEEDED BY: struct ifaddrs, getifaddrs()
  18 #define _IFI_OQDROPS // It is for FreeNAS only. Most probably in future releases of FreeNAS it will be removed
  19 #include <net/if.h>
  20 #include <ifaddrs.h>
  21 // NEEDED BY do_tcp...
  22 #include <netinet/tcp_var.h>
  23 // NEEDED BY do_udp..., do_ip...
  24 #include <netinet/ip_var.h>
  25 // NEEDED BY do_udp...
  26 #include <netinet/udp.h>
  27 #include <netinet/udp_var.h>
  28 // NEEDED BY do_icmp...
  29 #include <netinet/ip.h>
  30 #include <netinet/ip_icmp.h>
  31 #include <netinet/icmp_var.h>
  32 // NEEDED BY do_ip6...
  33 #include <netinet6/ip6_var.h>
  34 // NEEDED BY do_icmp6...
  35 #include <netinet/icmp6.h>
  36
  37 // NEEDED BY: do_disk_io
  38 #define RRD_TYPE_DISK "disk"
  39
  40 // FreeBSD calculates load averages once every 5 seconds
  41 #define MIN_LOADAVG_UPDATE_EVERY 5
  42
  43 // NEEDED BY: do_bandwidth
  44 #define IFA_DATA(s) (((struct if_data *)ifa->ifa_data)->ifi_ ## s)
  45
  46 int do_freebsd_sysctl(int update_every, usec_t dt) {
  47     (void)dt;
  48
  49     static int do_cpu = -1, do_cpu_cores = -1, do_interrupts = -1, do_context = -1, do_forks = -1, do_processes = -1,
  50         do_loadavg = -1, do_all_processes = -1, do_disk_io = -1, do_swap = -1, do_ram = -1, do_swapio = -1,
  51         do_pgfaults = -1, do_committed = -1, do_ipc_semaphores = -1, do_ipc_shared_mem = -1, do_ipc_msg_queues = -1,
  52         do_dev_intr = -1, do_soft_intr = -1, do_netisr = -1, do_netisr_per_core = -1, do_bandwidth = -1,
  53         do_tcp_sockets = -1, do_tcp_packets = -1, do_tcp_errors = -1, do_tcp_handshake = -1,
  54         do_ecn = -1, do_tcpext_syscookies = -1, do_tcpext_ofo = -1, do_tcpext_connaborts = -1,
  55         do_udp_packets = -1, do_udp_errors = -1, do_icmp_packets = -1, do_icmpmsg = -1,
  56         do_ip_packets = -1, do_ip_fragsout = -1, do_ip_fragsin = -1, do_ip_errors = -1,
  57         do_ip6_packets = -1, do_ip6_fragsout = -1, do_ip6_fragsin = -1, do_ip6_errors = -1,
  58         do_icmp6 = -1, do_icmp6_redir = -1, do_icmp6_errors = -1, do_icmp6_echos = -1, do_icmp6_router = -1,
  59         do_icmp6_neighbor = -1, do_icmp6_types = -1;
  60
  61     if (unlikely(do_cpu == -1)) {
  62         do_cpu                  = config_get_boolean("plugin:freebsd:sysctl", "cpu utilization", 1);
  63         do_cpu_cores            = config_get_boolean("plugin:freebsd:sysctl", "per cpu core utilization", 1);
  64         do_interrupts           = config_get_boolean("plugin:freebsd:sysctl", "cpu interrupts", 1);
  65         do_dev_intr             = config_get_boolean("plugin:freebsd:sysctl", "device interrupts", 1);
  66         do_soft_intr            = config_get_boolean("plugin:freebsd:sysctl", "software interrupts", 1);
  67         do_context              = config_get_boolean("plugin:freebsd:sysctl", "context switches", 1);
  68         do_forks                = config_get_boolean("plugin:freebsd:sysctl", "processes started", 1);
  69         do_processes            = config_get_boolean("plugin:freebsd:sysctl", "processes running", 1);
  70         do_loadavg              = config_get_boolean("plugin:freebsd:sysctl", "enable load average", 1);
  71         do_all_processes        = config_get_boolean("plugin:freebsd:sysctl", "enable total processes", 1);
  72         do_disk_io              = config_get_boolean("plugin:freebsd:sysctl", "stats for all disks", 1);
  73         do_swap                 = config_get_boolean("plugin:freebsd:sysctl", "system swap", 1);
  74         do_ram                  = config_get_boolean("plugin:freebsd:sysctl", "system ram", 1);
  75         do_swapio               = config_get_boolean("plugin:freebsd:sysctl", "swap i/o", 1);
  76         do_pgfaults             = config_get_boolean("plugin:freebsd:sysctl", "memory page faults", 1);
  77         do_committed            = config_get_boolean("plugin:freebsd:sysctl", "committed memory", 1);
  78         do_ipc_semaphores       = config_get_boolean("plugin:freebsd:sysctl", "ipc semaphores", 1);
  79         do_ipc_shared_mem       = config_get_boolean("plugin:freebsd:sysctl", "ipc shared memory", 1);
  80         do_ipc_msg_queues       = config_get_boolean("plugin:freebsd:sysctl", "ipc message queues", 1);
  81         do_netisr               = config_get_boolean("plugin:freebsd:sysctl", "netisr", 1);
  82         do_netisr_per_core      = config_get_boolean("plugin:freebsd:sysctl", "netisr per core", 1);
  83         do_bandwidth            = config_get_boolean("plugin:freebsd:sysctl", "bandwidth", 1);
  84         do_tcp_sockets          = config_get_boolean("plugin:freebsd:sysctl", "ipv4 TCP connections", 1);
  85         do_tcp_packets          = config_get_boolean("plugin:freebsd:sysctl", "ipv4 TCP packets", 1);
  86         do_tcp_errors           = config_get_boolean("plugin:freebsd:sysctl", "ipv4 TCP errors", 1);
  87         do_tcp_handshake        = config_get_boolean("plugin:freebsd:sysctl", "ipv4 TCP handshake issues", 1);
  88         do_ecn                  = config_get_boolean_ondemand("plugin:freebsd:sysctl", "ECN packets", CONFIG_ONDEMAND_ONDEMAND);
  89         do_tcpext_syscookies    = config_get_boolean_ondemand("plugin:freebsd:sysctl", "TCP SYN cookies", CONFIG_ONDEMAND_ONDEMAND);
  90         do_tcpext_ofo           = config_get_boolean_ondemand("plugin:freebsd:sysctl", "TCP out-of-order queue", CONFIG_ONDEMAND_ONDEMAND);
  91         do_tcpext_connaborts    = config_get_boolean_ondemand("plugin:freebsd:sysctl", "TCP connection aborts", CONFIG_ONDEMAND_ONDEMAND);
  92         do_udp_packets          = config_get_boolean("plugin:freebsd:sysctl", "ipv4 UDP packets", 1);
  93         do_udp_errors           = config_get_boolean("plugin:freebsd:sysctl", "ipv4 UDP errors", 1);
  94         do_ip_packets           = config_get_boolean("plugin:freebsd:sysctl", "ipv4 packets", 1);
  95         do_ip_fragsout          = config_get_boolean("plugin:freebsd:sysctl", "ipv4 fragments sent", 1);
  96         do_ip_fragsin           = config_get_boolean("plugin:freebsd:sysctl", "ipv4 fragments assembly", 1);
  97         do_ip_errors            = config_get_boolean("plugin:freebsd:sysctl", "ipv4 errors", 1);
  98         do_ip6_packets          = config_get_boolean_ondemand("plugin:freebsd:sysctl", "ipv6 packets", CONFIG_ONDEMAND_ONDEMAND);
  99         do_ip6_fragsout         = config_get_boolean_ondemand("plugin:freebsd:sysctl", "ipv6 fragments sent", CONFIG_ONDEMAND_ONDEMAND);
 100         do_ip6_fragsin          = config_get_boolean_ondemand("plugin:freebsd:sysctl", "ipv6 fragments assembly", CONFIG_ONDEMAND_ONDEMAND);
 101         do_ip6_errors           = config_get_boolean_ondemand("plugin:freebsd:sysctl", "ipv6 errors", CONFIG_ONDEMAND_ONDEMAND);
 102         do_icmp6             = config_get_boolean_ondemand("plugin:freebsd:sysctl", "icmp", CONFIG_ONDEMAND_ONDEMAND);
 103         do_icmp6_redir       = config_get_boolean_ondemand("plugin:freebsd:sysctl", "icmp redirects", CONFIG_ONDEMAND_ONDEMAND);
 104         do_icmp6_errors      = config_get_boolean_ondemand("plugin:freebsd:sysctl", "icmp errors", CONFIG_ONDEMAND_ONDEMAND);
 105         do_icmp6_echos       = config_get_boolean_ondemand("plugin:freebsd:sysctl", "icmp echos", CONFIG_ONDEMAND_ONDEMAND);
 106         do_icmp6_router      = config_get_boolean_ondemand("plugin:freebsd:sysctl", "icmp router", CONFIG_ONDEMAND_ONDEMAND);
 107         do_icmp6_neighbor    = config_get_boolean_ondemand("plugin:freebsd:sysctl", "icmp neighbor", CONFIG_ONDEMAND_ONDEMAND);
 108         do_icmp6_types       = config_get_boolean_ondemand("plugin:freebsd:sysctl", "icmp types", CONFIG_ONDEMAND_ONDEMAND);
 109     }
 110
 111     RRDSET *st;
 112     RRDDIM *rd;
 113
 114     int system_pagesize = getpagesize(); // wouldn't it be better to get value directly from hw.pagesize?
 115     int i, n;
 116     void *p;
 117     int common_error = 0;
 118     size_t size;
 119
 120     // NEEDED BY: do_loadavg
 121     static usec_t last_loadavg_usec = 0;
 122     struct loadavg sysload;
 123
 124     // NEEDED BY: do_cpu, do_cpu_cores
 125     long cp_time[CPUSTATES];
 126
 127     // NEEDED BY: du_cpu_cores, do_netisr, do_netisr_per_core
 128     int ncpus;
 129
 130     // NEEDED BY: do_cpu_cores
 131     static long *pcpu_cp_time = NULL;
 132     char cpuid[8]; // no more than 4 digits expected
 133
 134     // NEEDED BY: do_all_processes, do_processes
 135     struct vmtotal vmtotal_data;
 136
 137     // NEEDED BY: do_context, do_forks
 138     u_int u_int_data;
 139
 140     // NEEDED BY: do_interrupts
 141     size_t intrcnt_size;
 142     unsigned long nintr = 0;
 143     static unsigned long *intrcnt = NULL;
 144     static char *intrnames = NULL;
 145     unsigned long long totalintr = 0;
 146
 147     // NEEDED BY: do_disk_io
 148     #define BINTIME_SCALE 5.42101086242752217003726400434970855712890625e-17 // this is 1000/2^64
 149     int numdevs;
 150     static void *devstat_data = NULL;
 151     struct devstat *dstat;
 152     struct cur_dstat {
 153         collected_number duration_read_ms;
 154         collected_number duration_write_ms;
 155         collected_number busy_time_ms;
 156     } cur_dstat;
 157     struct prev_dstat {
 158         collected_number bytes_read;
 159         collected_number bytes_write;
 160         collected_number operations_read;
 161         collected_number operations_write;
 162         collected_number duration_read_ms;
 163         collected_number duration_write_ms;
 164         collected_number busy_time_ms;
 165     } prev_dstat;
 166
 167     // NEEDED BY: do_swap
 168     size_t mibsize;
 169     int mib[3]; // CTL_MAXNAME = 24 maximum mib components (sysctl.h)
 170     struct xswdev xsw;
 171     struct total_xsw {
 172         collected_number bytes_used;
 173         collected_number bytes_total;
 174     } total_xsw = {0, 0};
 175
 176     // NEEDED BY: do_swapio, do_ram
 177     struct vmmeter vmmeter_data;
 178
 179     // NEEDED BY: do_ram
 180     int vfs_bufspace_count;
 181
 182     // NEEDED BY: do_ipc_semaphores
 183     struct ipc_sem {
 184         int semmni;
 185         collected_number sets;
 186         collected_number semaphores;
 187     } ipc_sem = {0, 0, 0};
 188     static struct semid_kernel *ipc_sem_data = NULL;
 189
 190     // NEEDED BY: do_ipc_shared_mem
 191     struct ipc_shm {
 192         u_long shmmni;
 193         collected_number segs;
 194         collected_number segsize;
 195     } ipc_shm = {0, 0, 0};
 196     static struct shmid_kernel *ipc_shm_data = NULL;
 197
 198     // NEEDED BY: do_ipc_msg_queues
 199     struct ipc_msq {
 200         int msgmni;
 201         collected_number queues;
 202         collected_number messages;
 203         collected_number usedsize;
 204         collected_number allocsize;
 205     } ipc_msq = {0, 0, 0, 0, 0};
 206     static struct msqid_kernel *ipc_msq_data = NULL;
 207
 208     // NEEDED BY: do_netisr, do_netisr_per_core
 209     size_t netisr_workstream_size;
 210     size_t netisr_work_size;
 211     unsigned long num_netisr_workstreams = 0, num_netisr_works = 0;
 212     static struct sysctl_netisr_workstream *netisr_workstream = NULL;
 213     static struct sysctl_netisr_work *netisr_work = NULL;
 214     static struct netisr_stats {
 215         collected_number dispatched;
 216         collected_number hybrid_dispatched;
 217         collected_number qdrops;
 218         collected_number queued;
 219     } *netisr_stats = NULL;
 220     char netstat_cpuid[21]; // no more than 4 digits expected
 221
 222     // NEEDED BY: do_bandwidth
 223     struct ifaddrs *ifa, *ifap;
 224     struct iftot {
 225         u_long  ift_ibytes;
 226         u_long  ift_obytes;
 227     } iftot = {0, 0};
 228
 229     // NEEDED BY: do_tcp...
 230     struct tcpstat tcpstat;
 231     uint64_t tcps_states[TCP_NSTATES];
 232
 233     // NEEDED BY: do_udp...
 234     struct udpstat udpstat;
 235
 236     // NEEDED BY: do_icmp...
 237     struct icmpstat icmpstat;
 238     struct icmp_total {
 239         u_long  msgs_in;
 240         u_long  msgs_out;
 241     } icmp_total = {0, 0};
 242
 243     // NEEDED BY: do_ip...
 244     struct ipstat ipstat;
 245
 246     // NEEDED BY: do_ip6...
 247     struct ip6stat ip6stat;
 248
 249     // NEEDED BY: do_icmp6...
 250     struct icmp6stat icmp6stat;
 251     struct icmp6_total {
 252         u_long  msgs_in;
 253         u_long  msgs_out;
 254     } icmp6_total = {0, 0};
 255
 256     // --------------------------------------------------------------------
 257
 258     if (last_loadavg_usec <= dt) {
 259         if (likely(do_loadavg)) {
 260             if (unlikely(GETSYSCTL("vm.loadavg", sysload))) {
 261                 do_loadavg = 0;
 262                 error("DISABLED: system.load");
 263             } else {
 264
 265                 st = rrdset_find_bytype("system", "load");
 266                 if (unlikely(!st)) {
 267                     st = rrdset_create("system", "load", NULL, "load", NULL, "System Load Average", "load", 100, (update_every < MIN_LOADAVG_UPDATE_EVERY) ? MIN_LOADAVG_UPDATE_EVERY : update_every, RRDSET_TYPE_LINE);
 268                     rrddim_add(st, "load1", NULL, 1, 1000, RRDDIM_ABSOLUTE);
 269                     rrddim_add(st, "load5", NULL, 1, 1000, RRDDIM_ABSOLUTE);
 270                     rrddim_add(st, "load15", NULL, 1, 1000, RRDDIM_ABSOLUTE);
 271                 }
 272                 else rrdset_next(st);
 273
 274                 rrddim_set(st, "load1", (collected_number) ((double)sysload.ldavg[0] / sysload.fscale * 1000));
 275                 rrddim_set(st, "load5", (collected_number) ((double)sysload.ldavg[1] / sysload.fscale * 1000));
 276                 rrddim_set(st, "load15", (collected_number) ((double)sysload.ldavg[2] / sysload.fscale * 1000));
 277                 rrdset_done(st);
 278             }
 279         }
 280
 281         last_loadavg_usec = st->update_every * USEC_PER_SEC;
 282     }
 283     else last_loadavg_usec -= dt;
 284
 285     // --------------------------------------------------------------------
 286
 287     if (likely(do_all_processes | do_processes | do_committed)) {
 288         if (unlikely(GETSYSCTL("vm.vmtotal", vmtotal_data))) {
 289             do_all_processes = 0;
 290             error("DISABLED: system.active_processes");
 291             do_processes = 0;
 292             error("DISABLED: system.processes");
 293             do_committed = 0;
 294             error("DISABLED: mem.committed");
 295         } else {
 296             if (likely(do_all_processes)) {
 297
 298                 st = rrdset_find_bytype("system", "active_processes");
 299                 if (unlikely(!st)) {
 300                     st = rrdset_create("system", "active_processes", NULL, "processes", NULL, "System Active Processes", "processes", 750, update_every, RRDSET_TYPE_LINE);
 301                     rrddim_add(st, "active", NULL, 1, 1, RRDDIM_ABSOLUTE);
 302                 }
 303                 else rrdset_next(st);
 304
 305                 rrddim_set(st, "active", (vmtotal_data.t_rq + vmtotal_data.t_dw + vmtotal_data.t_pw + vmtotal_data.t_sl + vmtotal_data.t_sw));
 306                 rrdset_done(st);
 307             }
 308
 309             // --------------------------------------------------------------------
 310
 311             if (likely(do_processes)) {
 312
 313                 st = rrdset_find_bytype("system", "processes");
 314                 if (unlikely(!st)) {
 315                     st = rrdset_create("system", "processes", NULL, "processes", NULL, "System Processes", "processes", 600, update_every, RRDSET_TYPE_LINE);
 316
 317                     rrddim_add(st, "running", NULL, 1, 1, RRDDIM_ABSOLUTE);
 318                     rrddim_add(st, "blocked", NULL, -1, 1, RRDDIM_ABSOLUTE);
 319                 }
 320                 else rrdset_next(st);
 321
 322                 rrddim_set(st, "running", vmtotal_data.t_rq);
 323                 rrddim_set(st, "blocked", (vmtotal_data.t_dw + vmtotal_data.t_pw));
 324                 rrdset_done(st);
 325             }
 326
 327             // --------------------------------------------------------------------
 328
 329             if (likely(do_committed)) {
 330                 st = rrdset_find("mem.committed");
 331                 if (unlikely(!st)) {
 332                     st = rrdset_create("mem", "committed", NULL, "system", NULL, "Committed (Allocated) Memory", "MB", 5000, update_every, RRDSET_TYPE_AREA);
 333                     st->isdetail = 1;
 334
 335                     rrddim_add(st, "Committed_AS", NULL, system_pagesize, 1048576, RRDDIM_ABSOLUTE);
 336                 }
 337                 else rrdset_next(st);
 338
 339                 rrddim_set(st, "Committed_AS", vmtotal_data.t_rm);
 340                 rrdset_done(st);
 341             }
 342         }
 343     }
 344
 345     // --------------------------------------------------------------------
 346
 347     if (likely(do_cpu)) {
 348         if (unlikely(CPUSTATES != 5)) {
 349             error("FREEBSD: There are %d CPU states (5 was expected)", CPUSTATES);
 350             do_cpu = 0;
 351             error("DISABLED: system.cpu");
 352         } else {
 353             if (unlikely(GETSYSCTL("kern.cp_time", cp_time))) {
 354                 do_cpu = 0;
 355                 error("DISABLED: system.cpu");
 356             } else {
 357
 358                 st = rrdset_find_bytype("system", "cpu");
 359                 if (unlikely(!st)) {
 360                     st = rrdset_create("system", "cpu", NULL, "cpu", "system.cpu", "Total CPU utilization", "percentage", 100, update_every, RRDSET_TYPE_STACKED);
 361
 362                     rrddim_add(st, "user", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 363                     rrddim_add(st, "nice", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 364                     rrddim_add(st, "system", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 365                     rrddim_add(st, "interrupt", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 366                     rrddim_add(st, "idle", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 367                     rrddim_hide(st, "idle");
 368                 }
 369                 else rrdset_next(st);
 370
 371                 rrddim_set(st, "user", cp_time[0]);
 372                 rrddim_set(st, "nice", cp_time[1]);
 373                 rrddim_set(st, "system", cp_time[2]);
 374                 rrddim_set(st, "interrupt", cp_time[3]);
 375                 rrddim_set(st, "idle", cp_time[4]);
 376                 rrdset_done(st);
 377             }
 378         }
 379     }
 380
 381     // --------------------------------------------------------------------
 382
 383     if (likely(do_cpu_cores)) {
 384         if (unlikely(CPUSTATES != 5)) {
 385             error("FREEBSD: There are %d CPU states (5 was expected)", CPUSTATES);
 386             do_cpu_cores = 0;
 387             error("DISABLED: cpu.cpuXX");
 388         } else {
 389             if (unlikely(GETSYSCTL("kern.smp.cpus", ncpus))) {
 390                 do_cpu_cores = 0;
 391                 error("DISABLED: cpu.cpuXX");
 392             } else {
 393                 pcpu_cp_time = reallocz(pcpu_cp_time, sizeof(cp_time) * ncpus);
 394
 395                 for (i = 0; i < ncpus; i++) {
 396                     if (unlikely(getsysctl("kern.cp_times", pcpu_cp_time, sizeof(cp_time) * ncpus))) {
 397                         do_cpu_cores = 0;
 398                         error("DISABLED: cpu.cpuXX");
 399                         break;
 400                     }
 401                     if (unlikely(ncpus > 9999)) {
 402                         error("FREEBSD: There are more than 4 digits in cpu cores number");
 403                         do_cpu_cores = 0;
 404                         error("DISABLED: cpu.cpuXX");
 405                         break;
 406                     }
 407                     snprintfz(cpuid, 8, "cpu%d", i);
 408
 409                     st = rrdset_find_bytype("cpu", cpuid);
 410                     if (unlikely(!st)) {
 411                         st = rrdset_create("cpu", cpuid, NULL, "utilization", "cpu.cpu", "Core utilization", "percentage", 1000, update_every, RRDSET_TYPE_STACKED);
 412
 413                         rrddim_add(st, "user", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 414                         rrddim_add(st, "nice", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 415                         rrddim_add(st, "system", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 416                         rrddim_add(st, "interrupt", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 417                         rrddim_add(st, "idle", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 418                         rrddim_hide(st, "idle");
 419                     }
 420                     else rrdset_next(st);
 421
 422                     rrddim_set(st, "user", pcpu_cp_time[i * 5 + 0]);
 423                     rrddim_set(st, "nice", pcpu_cp_time[i * 5 + 1]);
 424                     rrddim_set(st, "system", pcpu_cp_time[i * 5 + 2]);
 425                     rrddim_set(st, "interrupt", pcpu_cp_time[i * 5 + 3]);
 426                     rrddim_set(st, "idle", pcpu_cp_time[i * 5 + 4]);
 427                     rrdset_done(st);
 428                 }
 429             }
 430         }
 431     }
 432
 433     // --------------------------------------------------------------------
 434
 435     if (likely(do_interrupts)) {
 436         if (unlikely(sysctlbyname("hw.intrcnt", NULL, &intrcnt_size, NULL, 0) == -1)) {
 437             error("FREEBSD: sysctl(hw.intrcnt...) failed: %s", strerror(errno));
 438             do_interrupts = 0;
 439             error("DISABLED: system.intr");
 440         } else {
 441             nintr = intrcnt_size / sizeof(u_long);
 442             intrcnt = reallocz(intrcnt, nintr * sizeof(u_long));
 443             if (unlikely(getsysctl("hw.intrcnt", intrcnt, nintr * sizeof(u_long)))){
 444                 do_interrupts = 0;
 445                 error("DISABLED: system.intr");
 446             } else {
 447                 for (i = 0; i < nintr; i++)
 448                     totalintr += intrcnt[i];
 449
 450                 st = rrdset_find_bytype("system", "intr");
 451                 if (unlikely(!st)) {
 452                     st = rrdset_create("system", "intr", NULL, "interrupts", NULL, "Total Hardware Interrupts", "interrupts/s", 900, update_every, RRDSET_TYPE_LINE);
 453                     st->isdetail = 1;
 454
 455                     rrddim_add(st, "interrupts", NULL, 1, 1, RRDDIM_INCREMENTAL);
 456                 }
 457                 else rrdset_next(st);
 458
 459                 rrddim_set(st, "interrupts", totalintr);
 460                 rrdset_done(st);
 461
 462                 // --------------------------------------------------------------------
 463
 464                 size = nintr * (MAXCOMLEN +1);
 465                 intrnames = reallocz(intrnames, size);
 466                 if (unlikely(getsysctl("hw.intrnames", intrnames, size))) {
 467                     do_interrupts = 0;
 468                     error("DISABLED: system.intr");
 469                 } else {
 470                     st = rrdset_find_bytype("system", "interrupts");
 471                     if (unlikely(!st))
 472                         st = rrdset_create("system", "interrupts", NULL, "interrupts", NULL, "System interrupts", "interrupts/s",
 473                                            1000, update_every, RRDSET_TYPE_STACKED);
 474                     else
 475                         rrdset_next(st);
 476
 477                     for (i = 0; i < nintr; i++) {
 478                         p = intrnames + i * (MAXCOMLEN + 1);
 479                         if (unlikely((intrcnt[i] != 0) && (*(char*)p != 0))) {
 480                             rd = rrddim_find(st, p);
 481                             if (unlikely(!rd))
 482                                 rd = rrddim_add(st, p, NULL, 1, 1, RRDDIM_INCREMENTAL);
 483                             rrddim_set_by_pointer(st, rd, intrcnt[i]);
 484                         }
 485                     }
 486                     rrdset_done(st);
 487                 }
 488             }
 489         }
 490     }
 491
 492     // --------------------------------------------------------------------
 493
 494     if (likely(do_dev_intr)) {
 495         if (unlikely(GETSYSCTL("vm.stats.sys.v_intr", u_int_data))) {
 496             do_dev_intr = 0;
 497             error("DISABLED: system.dev_intr");
 498         } else {
 499
 500             st = rrdset_find_bytype("system", "dev_intr");
 501             if (unlikely(!st)) {
 502                 st = rrdset_create("system", "dev_intr", NULL, "interrupts", NULL, "Device Interrupts", "interrupts/s", 1000, update_every, RRDSET_TYPE_LINE);
 503
 504                 rrddim_add(st, "interrupts", NULL, 1, 1, RRDDIM_INCREMENTAL);
 505             }
 506             else rrdset_next(st);
 507
 508             rrddim_set(st, "interrupts", u_int_data);
 509             rrdset_done(st);
 510         }
 511     }
 512
 513     // --------------------------------------------------------------------
 514
 515     if (likely(do_soft_intr)) {
 516         if (unlikely(GETSYSCTL("vm.stats.sys.v_soft", u_int_data))) {
 517             do_soft_intr = 0;
 518             error("DISABLED: system.dev_intr");
 519         } else {
 520
 521             st = rrdset_find_bytype("system", "soft_intr");
 522             if (unlikely(!st)) {
 523                 st = rrdset_create("system", "soft_intr", NULL, "interrupts", NULL, "Software Interrupts", "interrupts/s", 1100, update_every, RRDSET_TYPE_LINE);
 524
 525                 rrddim_add(st, "interrupts", NULL, 1, 1, RRDDIM_INCREMENTAL);
 526             }
 527             else rrdset_next(st);
 528
 529             rrddim_set(st, "interrupts", u_int_data);
 530             rrdset_done(st);
 531         }
 532     }
 533
 534     // --------------------------------------------------------------------
 535
 536     if (likely(do_context)) {
 537         if (unlikely(GETSYSCTL("vm.stats.sys.v_swtch", u_int_data))) {
 538             do_context = 0;
 539             error("DISABLED: system.ctxt");
 540         } else {
 541
 542             st = rrdset_find_bytype("system", "ctxt");
 543             if (unlikely(!st)) {
 544                 st = rrdset_create("system", "ctxt", NULL, "processes", NULL, "CPU Context Switches", "context switches/s", 800, update_every, RRDSET_TYPE_LINE);
 545
 546                 rrddim_add(st, "switches", NULL, 1, 1, RRDDIM_INCREMENTAL);
 547             }
 548             else rrdset_next(st);
 549
 550             rrddim_set(st, "switches", u_int_data);
 551             rrdset_done(st);
 552         }
 553     }
 554
 555     // --------------------------------------------------------------------
 556
 557     if (likely(do_forks)) {
 558         if (unlikely(GETSYSCTL("vm.stats.vm.v_forks", u_int_data))) {
 559             do_forks = 0;
 560             error("DISABLED: system.forks");
 561         } else {
 562
 563             st = rrdset_find_bytype("system", "forks");
 564             if (unlikely(!st)) {
 565                 st = rrdset_create("system", "forks", NULL, "processes", NULL, "Started Processes", "processes/s", 700, update_every, RRDSET_TYPE_LINE);
 566                 st->isdetail = 1;
 567
 568                 rrddim_add(st, "started", NULL, 1, 1, RRDDIM_INCREMENTAL);
 569             }
 570             else rrdset_next(st);
 571
 572             rrddim_set(st, "started", u_int_data);
 573             rrdset_done(st);
 574         }
 575     }
 576
 577     // --------------------------------------------------------------------
 578
 579     if (likely(do_disk_io)) {
 580         if (unlikely(GETSYSCTL("kern.devstat.numdevs", numdevs))) {
 581             do_disk_io = 0;
 582             error("DISABLED: disk.io");
 583         } else {
 584             devstat_data = reallocz(devstat_data, sizeof(long) + sizeof(struct devstat) * numdevs); // there is generation number before devstat structures
 585             if (unlikely(getsysctl("kern.devstat.all", devstat_data, sizeof(long) + sizeof(struct devstat) * numdevs))) {
 586                 do_disk_io = 0;
 587                 error("DISABLED: disk.io");
 588             } else {
 589                 dstat = devstat_data + sizeof(long); // skip generation number
 590                 collected_number total_disk_reads = 0;
 591                 collected_number total_disk_writes = 0;
 592
 593                 for (i = 0; i < numdevs; i++) {
 594                     if (((dstat[i].device_type & DEVSTAT_TYPE_MASK) == DEVSTAT_TYPE_DIRECT) || ((dstat[i].device_type & DEVSTAT_TYPE_MASK) == DEVSTAT_TYPE_STORARRAY)) {
 595
 596                         // --------------------------------------------------------------------
 597
 598                         st = rrdset_find_bytype(RRD_TYPE_DISK, dstat[i].device_name);
 599                         if (unlikely(!st)) {
 600                             st = rrdset_create(RRD_TYPE_DISK, dstat[i].device_name, NULL, dstat[i].device_name, "disk.io", "Disk I/O Bandwidth", "kilobytes/s", 2000, update_every, RRDSET_TYPE_AREA);
 601
 602                             rrddim_add(st, "reads", NULL, 1, 1024, RRDDIM_INCREMENTAL);
 603                             rrddim_add(st, "writes", NULL, -1, 1024, RRDDIM_INCREMENTAL);
 604                         }
 605                         else rrdset_next(st);
 606
 607                         total_disk_reads += dstat[i].bytes[DEVSTAT_READ];
 608                         total_disk_writes += dstat[i].bytes[DEVSTAT_WRITE];
 609                         prev_dstat.bytes_read = rrddim_set(st, "reads", dstat[i].bytes[DEVSTAT_READ]);
 610                         prev_dstat.bytes_write = rrddim_set(st, "writes", dstat[i].bytes[DEVSTAT_WRITE]);
 611                         rrdset_done(st);
 612
 613                         // --------------------------------------------------------------------
 614
 615                         st = rrdset_find_bytype("disk_ops", dstat[i].device_name);
 616                         if (unlikely(!st)) {
 617                             st = rrdset_create("disk_ops", dstat[i].device_name, NULL, dstat[i].device_name, "disk.ops", "Disk Completed I/O Operations", "operations/s", 2001, update_every, RRDSET_TYPE_LINE);
 618                             st->isdetail = 1;
 619
 620                             rrddim_add(st, "reads", NULL, 1, 1, RRDDIM_INCREMENTAL);
 621                             rrddim_add(st, "writes", NULL, -1, 1, RRDDIM_INCREMENTAL);
 622                         }
 623                         else rrdset_next(st);
 624
 625                         prev_dstat.operations_read = rrddim_set(st, "reads", dstat[i].operations[DEVSTAT_READ]);
 626                         prev_dstat.operations_write = rrddim_set(st, "writes", dstat[i].operations[DEVSTAT_WRITE]);
 627                         rrdset_done(st);
 628
 629                         // --------------------------------------------------------------------
 630
 631                         st = rrdset_find_bytype("disk_qops", dstat[i].device_name);
 632                         if (unlikely(!st)) {
 633                             st = rrdset_create("disk_qops", dstat[i].device_name, NULL, dstat[i].device_name, "disk.qops", "Disk Current I/O Operations", "operations", 2002, update_every, RRDSET_TYPE_LINE);
 634                             st->isdetail = 1;
 635
 636                             rrddim_add(st, "operations", NULL, 1, 1, RRDDIM_ABSOLUTE);
 637                         }
 638                         else rrdset_next(st);
 639
 640                         rrddim_set(st, "operations", dstat[i].start_count - dstat[i].end_count);
 641                         rrdset_done(st);
 642
 643                         // --------------------------------------------------------------------
 644
 645                         st = rrdset_find_bytype("disk_util", dstat[i].device_name);
 646                         if (unlikely(!st)) {
 647                             st = rrdset_create("disk_util", dstat[i].device_name, NULL, dstat[i].device_name, "disk.util", "Disk Utilization Time", "% of time working", 2004, update_every, RRDSET_TYPE_AREA);
 648                             st->isdetail = 1;
 649
 650                             rrddim_add(st, "utilization", NULL, 1, 10, RRDDIM_INCREMENTAL);
 651                         }
 652                         else rrdset_next(st);
 653
 654                         cur_dstat.busy_time_ms = dstat[i].busy_time.sec * 1000 + dstat[i].busy_time.frac * BINTIME_SCALE;
 655                         prev_dstat.busy_time_ms = rrddim_set(st, "utilization", cur_dstat.busy_time_ms);
 656                         rrdset_done(st);
 657
 658                         // --------------------------------------------------------------------
 659
 660                         st = rrdset_find_bytype("disk_iotime", dstat[i].device_name);
 661                         if (unlikely(!st)) {
 662                             st = rrdset_create("disk_iotime", dstat[i].device_name, NULL, dstat[i].device_name, "disk.iotime", "Disk Total I/O Time", "milliseconds/s", 2022, update_every, RRDSET_TYPE_LINE);
 663                             st->isdetail = 1;
 664
 665                             rrddim_add(st, "reads", NULL, 1, 1, RRDDIM_INCREMENTAL);
 666                             rrddim_add(st, "writes", NULL, -1, 1, RRDDIM_INCREMENTAL);
 667                         }
 668                         else rrdset_next(st);
 669
 670                         cur_dstat.duration_read_ms = dstat[i].duration[DEVSTAT_READ].sec * 1000 + dstat[i].duration[DEVSTAT_READ].frac * BINTIME_SCALE;
 671                         cur_dstat.duration_write_ms = dstat[i].duration[DEVSTAT_WRITE].sec * 1000 + dstat[i].duration[DEVSTAT_READ].frac * BINTIME_SCALE;
 672                         prev_dstat.duration_read_ms = rrddim_set(st, "reads", cur_dstat.duration_read_ms);
 673                         prev_dstat.duration_write_ms = rrddim_set(st, "writes", cur_dstat.duration_write_ms);
 674                         rrdset_done(st);
 675
 676                         // --------------------------------------------------------------------
 677                         // calculate differential charts
 678                         // only if this is not the first time we run
 679
 680                         if (likely(dt)) {
 681
 682                             // --------------------------------------------------------------------
 683
 684                             st = rrdset_find_bytype("disk_await", dstat[i].device_name);
 685                             if (unlikely(!st)) {
 686                                 st = rrdset_create("disk_await", dstat[i].device_name, NULL, dstat[i].device_name, "disk.await", "Average Completed I/O Operation Time", "ms per operation", 2005, update_every, RRDSET_TYPE_LINE);
 687                                 st->isdetail = 1;
 688
 689                                 rrddim_add(st, "reads", NULL, 1, 1, RRDDIM_ABSOLUTE);
 690                                 rrddim_add(st, "writes", NULL, -1, 1, RRDDIM_ABSOLUTE);
 691                             }
 692                             else rrdset_next(st);
 693
 694                             rrddim_set(st, "reads", (dstat[i].operations[DEVSTAT_READ] - prev_dstat.operations_read) ?
 695                                 (cur_dstat.duration_read_ms - prev_dstat.duration_read_ms) / (dstat[i].operations[DEVSTAT_READ] - prev_dstat.operations_read) : 0);
 696                             rrddim_set(st, "writes", (dstat[i].operations[DEVSTAT_WRITE] - prev_dstat.operations_write) ?
 697                                 (cur_dstat.duration_write_ms - prev_dstat.duration_write_ms) / (dstat[i].operations[DEVSTAT_WRITE] - prev_dstat.operations_write) : 0);
 698                             rrdset_done(st);
 699
 700                             // --------------------------------------------------------------------
 701
 702                             st = rrdset_find_bytype("disk_avgsz", dstat[i].device_name);
 703                             if (unlikely(!st)) {
 704                                 st = rrdset_create("disk_avgsz", dstat[i].device_name, NULL, dstat[i].device_name, "disk.avgsz", "Average Completed I/O Operation Bandwidth", "kilobytes per operation", 2006, update_every, RRDSET_TYPE_AREA);
 705                                 st->isdetail = 1;
 706
 707                                 rrddim_add(st, "reads", NULL, 1, 1024, RRDDIM_ABSOLUTE);
 708                                 rrddim_add(st, "writes", NULL, -1, 1024, RRDDIM_ABSOLUTE);
 709                             }
 710                             else rrdset_next(st);
 711
 712                             rrddim_set(st, "reads", (dstat[i].operations[DEVSTAT_READ] - prev_dstat.operations_read) ?
 713                                 (dstat[i].bytes[DEVSTAT_READ] - prev_dstat.bytes_read) / (dstat[i].operations[DEVSTAT_READ] - prev_dstat.operations_read) : 0);
 714                             rrddim_set(st, "writes", (dstat[i].operations[DEVSTAT_WRITE] - prev_dstat.operations_write) ?
 715                                 (dstat[i].bytes[DEVSTAT_WRITE] - prev_dstat.bytes_write) / (dstat[i].operations[DEVSTAT_WRITE] - prev_dstat.operations_write) : 0);
 716                             rrdset_done(st);
 717
 718                             // --------------------------------------------------------------------
 719
 720                             st = rrdset_find_bytype("disk_svctm", dstat[i].device_name);
 721                             if (unlikely(!st)) {
 722                                 st = rrdset_create("disk_svctm", dstat[i].device_name, NULL, dstat[i].device_name, "disk.svctm", "Average Service Time", "ms per operation", 2007, update_every, RRDSET_TYPE_LINE);
 723                                 st->isdetail = 1;
 724
 725                                 rrddim_add(st, "svctm", NULL, 1, 1, RRDDIM_ABSOLUTE);
 726                             }
 727                             else rrdset_next(st);
 728
 729                             rrddim_set(st, "svctm", ((dstat[i].operations[DEVSTAT_READ] - prev_dstat.operations_read) + (dstat[i].operations[DEVSTAT_WRITE] - prev_dstat.operations_write)) ?
 730                                 (cur_dstat.busy_time_ms - prev_dstat.busy_time_ms) / ((dstat[i].operations[DEVSTAT_READ] - prev_dstat.operations_read) + (dstat[i].operations[DEVSTAT_WRITE] - prev_dstat.operations_write)) : 0);
 731                             rrdset_done(st);
 732                         }
 733                     }
 734
 735                     // --------------------------------------------------------------------
 736
 737                     st = rrdset_find_bytype("system", "io");
 738                     if (unlikely(!st)) {
 739                         st = rrdset_create("system", "io", NULL, "disk", NULL, "Disk I/O", "kilobytes/s", 150, update_every, RRDSET_TYPE_AREA);
 740                         rrddim_add(st, "in",  NULL,  1, 1024, RRDDIM_INCREMENTAL);
 741                         rrddim_add(st, "out", NULL, -1, 1024, RRDDIM_INCREMENTAL);
 742                     }
 743                     else rrdset_next(st);
 744
 745                     rrddim_set(st, "in", total_disk_reads);
 746                     rrddim_set(st, "out", total_disk_writes);
 747                     rrdset_done(st);
 748                 }
 749             }
 750         }
 751     }
 752
 753     // --------------------------------------------------------------------
 754
 755
 756     if (likely(do_swap)) {
 757         mibsize = sizeof mib / sizeof mib[0];
 758         if (unlikely(sysctlnametomib("vm.swap_info", mib, &mibsize) == -1)) {
 759             error("FREEBSD: sysctl(%s...) failed: %s", "vm.swap_info", strerror(errno));
 760             do_swap = 0;
 761             error("DISABLED: system.swap");
 762         } else {
 763             for (i = 0; ; i++) {
 764                 mib[mibsize] = i;
 765                 size = sizeof(xsw);
 766                 if (unlikely(sysctl(mib, mibsize + 1, &xsw, &size, NULL, 0) == -1 )) {
 767                     if (unlikely(errno != ENOENT)) {
 768                         error("FREEBSD: sysctl(%s...) failed: %s", "vm.swap_info", strerror(errno));
 769                         do_swap = 0;
 770                         error("DISABLED: system.swap");
 771                     } else {
 772                         if (unlikely(size != sizeof(xsw))) {
 773                             error("FREEBSD: sysctl(%s...) expected %lu, got %lu", "vm.swap_info", (unsigned long)sizeof(xsw), (unsigned long)size);
 774                             do_swap = 0;
 775                             error("DISABLED: system.swap");
 776                         } else break;
 777                     }
 778                 }
 779                 total_xsw.bytes_used += xsw.xsw_used;
 780                 total_xsw.bytes_total += xsw.xsw_nblks;
 781             }
 782
 783             if (likely(do_swap)) {
 784                 st = rrdset_find("system.swap");
 785                 if (unlikely(!st)) {
 786                     st = rrdset_create("system", "swap", NULL, "swap", NULL, "System Swap", "MB", 201, update_every, RRDSET_TYPE_STACKED);
 787                     st->isdetail = 1;
 788
 789                     rrddim_add(st, "free",    NULL, system_pagesize, 1048576, RRDDIM_ABSOLUTE);
 790                     rrddim_add(st, "used",    NULL, system_pagesize, 1048576, RRDDIM_ABSOLUTE);
 791                 }
 792                 else rrdset_next(st);
 793
 794                 rrddim_set(st, "used", total_xsw.bytes_used);
 795                 rrddim_set(st, "free", total_xsw.bytes_total - total_xsw.bytes_used);
 796                 rrdset_done(st);
 797             }
 798         }
 799     }
 800
 801     // --------------------------------------------------------------------
 802
 803     if (likely(do_ram)) {
 804         if (unlikely(GETSYSCTL("vm.stats.vm.v_active_count",    vmmeter_data.v_active_count) ||
 805                      GETSYSCTL("vm.stats.vm.v_inactive_count",  vmmeter_data.v_inactive_count) ||
 806                      GETSYSCTL("vm.stats.vm.v_wire_count",      vmmeter_data.v_wire_count) ||
 807                      GETSYSCTL("vm.stats.vm.v_cache_count",     vmmeter_data.v_cache_count) ||
 808                      GETSYSCTL("vfs.bufspace",                  vfs_bufspace_count) ||
 809                      GETSYSCTL("vm.stats.vm.v_free_count",      vmmeter_data.v_free_count))) {
 810             do_ram = 0;
 811             error("DISABLED: system.ram");
 812         } else {
 813             st = rrdset_find("system.ram");
 814             if (unlikely(!st)) {
 815                 st = rrdset_create("system", "ram", NULL, "ram", NULL, "System RAM", "MB", 200, update_every, RRDSET_TYPE_STACKED);
 816
 817                 rrddim_add(st, "active",    NULL, system_pagesize, 1048576, RRDDIM_ABSOLUTE);
 818                 rrddim_add(st, "inactive",  NULL, system_pagesize, 1048576, RRDDIM_ABSOLUTE);
 819                 rrddim_add(st, "wired",     NULL, system_pagesize, 1048576, RRDDIM_ABSOLUTE);
 820                 rrddim_add(st, "cache",     NULL, system_pagesize, 1048576, RRDDIM_ABSOLUTE);
 821                 rrddim_add(st, "buffers",   NULL, 1, 1048576, RRDDIM_ABSOLUTE);
 822                 rrddim_add(st, "free",      NULL, system_pagesize, 1048576, RRDDIM_ABSOLUTE);
 823             }
 824             else rrdset_next(st);
 825
 826             rrddim_set(st, "active",    vmmeter_data.v_active_count);
 827             rrddim_set(st, "inactive",  vmmeter_data.v_inactive_count);
 828             rrddim_set(st, "wired",     vmmeter_data.v_wire_count);
 829             rrddim_set(st, "cache",     vmmeter_data.v_cache_count);
 830             rrddim_set(st, "buffers",   vfs_bufspace_count);
 831             rrddim_set(st, "free",      vmmeter_data.v_free_count);
 832             rrdset_done(st);
 833         }
 834     }
 835
 836     // --------------------------------------------------------------------
 837
 838     if (likely(do_swapio)) {
 839         if (unlikely(GETSYSCTL("vm.stats.vm.v_swappgsin", vmmeter_data.v_swappgsin) || GETSYSCTL("vm.stats.vm.v_swappgsout", vmmeter_data.v_swappgsout))) {
 840             do_swapio = 0;
 841             error("DISABLED: system.swapio");
 842         } else {
 843             st = rrdset_find("system.swapio");
 844             if (unlikely(!st)) {
 845                 st = rrdset_create("system", "swapio", NULL, "swap", NULL, "Swap I/O", "kilobytes/s", 250, update_every, RRDSET_TYPE_AREA);
 846
 847                 rrddim_add(st, "in",  NULL, system_pagesize, 1024, RRDDIM_INCREMENTAL);
 848                 rrddim_add(st, "out", NULL, -system_pagesize, 1024, RRDDIM_INCREMENTAL);
 849             }
 850             else rrdset_next(st);
 851
 852             rrddim_set(st, "in", vmmeter_data.v_swappgsin);
 853             rrddim_set(st, "out", vmmeter_data.v_swappgsout);
 854             rrdset_done(st);
 855         }
 856     }
 857
 858     // --------------------------------------------------------------------
 859
 860     if (likely(do_pgfaults)) {
 861         if (unlikely(GETSYSCTL("vm.stats.vm.v_vm_faults",   vmmeter_data.v_vm_faults) ||
 862                      GETSYSCTL("vm.stats.vm.v_io_faults",   vmmeter_data.v_io_faults) ||
 863                      GETSYSCTL("vm.stats.vm.v_cow_faults",  vmmeter_data.v_cow_faults) ||
 864                      GETSYSCTL("vm.stats.vm.v_cow_optim",   vmmeter_data.v_cow_optim) ||
 865                      GETSYSCTL("vm.stats.vm.v_intrans",     vmmeter_data.v_intrans))) {
 866             do_pgfaults = 0;
 867             error("DISABLED: mem.pgfaults");
 868         } else {
 869             st = rrdset_find("mem.pgfaults");
 870             if (unlikely(!st)) {
 871                 st = rrdset_create("mem", "pgfaults", NULL, "system", NULL, "Memory Page Faults", "page faults/s", 500, update_every, RRDSET_TYPE_LINE);
 872                 st->isdetail = 1;
 873
 874                 rrddim_add(st, "memory", NULL, 1, 1, RRDDIM_INCREMENTAL);
 875                 rrddim_add(st, "io_requiring", NULL, 1, 1, RRDDIM_INCREMENTAL);
 876                 rrddim_add(st, "cow", NULL, 1, 1, RRDDIM_INCREMENTAL);
 877                 rrddim_add(st, "cow_optimized", NULL, 1, 1, RRDDIM_INCREMENTAL);
 878                 rrddim_add(st, "in_transit", NULL, 1, 1, RRDDIM_INCREMENTAL);
 879             }
 880             else rrdset_next(st);
 881
 882             rrddim_set(st, "memory", vmmeter_data.v_vm_faults);
 883             rrddim_set(st, "io_requiring", vmmeter_data.v_io_faults);
 884             rrddim_set(st, "cow", vmmeter_data.v_cow_faults);
 885             rrddim_set(st, "cow_optimized", vmmeter_data.v_cow_optim);
 886             rrddim_set(st, "in_transit", vmmeter_data.v_intrans);
 887             rrdset_done(st);
 888         }
 889     }
 890
 891     // --------------------------------------------------------------------
 892
 893     if (likely(do_ipc_semaphores)) {
 894         if (unlikely(GETSYSCTL("kern.ipc.semmni", ipc_sem.semmni))) {
 895             do_ipc_semaphores = 0;
 896             error("DISABLED: system.ipc_semaphores");
 897             error("DISABLED: system.ipc_semaphore_arrays");
 898         } else {
 899             ipc_sem_data = reallocz(ipc_sem_data, sizeof(struct semid_kernel) * ipc_sem.semmni);
 900             if (unlikely(getsysctl("kern.ipc.sema", ipc_sem_data, sizeof(struct semid_kernel) * ipc_sem.semmni))) {
 901                 do_ipc_semaphores = 0;
 902                 error("DISABLED: system.ipc_semaphores");
 903                 error("DISABLED: system.ipc_semaphore_arrays");
 904             } else {
 905                 for (i = 0; i < ipc_sem.semmni; i++) {
 906                     if (unlikely(ipc_sem_data[i].u.sem_perm.mode & SEM_ALLOC)) {
 907                         ipc_sem.sets += 1;
 908                         ipc_sem.semaphores += ipc_sem_data[i].u.sem_nsems;
 909                     }
 910                 }
 911
 912                 // --------------------------------------------------------------------
 913
 914                 st = rrdset_find("system.ipc_semaphores");
 915                 if (unlikely(!st)) {
 916                     st = rrdset_create("system", "ipc_semaphores", NULL, "ipc semaphores", NULL, "IPC Semaphores", "semaphores", 1000, rrd_update_every, RRDSET_TYPE_AREA);
 917                     rrddim_add(st, "semaphores", NULL, 1, 1, RRDDIM_ABSOLUTE);
 918                 }
 919                 else rrdset_next(st);
 920
 921                 rrddim_set(st, "semaphores", ipc_sem.semaphores);
 922                 rrdset_done(st);
 923
 924                 // --------------------------------------------------------------------
 925
 926                 st = rrdset_find("system.ipc_semaphore_arrays");
 927                 if (unlikely(!st)) {
 928                     st = rrdset_create("system", "ipc_semaphore_arrays", NULL, "ipc semaphores", NULL, "IPC Semaphore Arrays", "arrays", 1000, rrd_update_every, RRDSET_TYPE_AREA);
 929                     rrddim_add(st, "arrays", NULL, 1, 1, RRDDIM_ABSOLUTE);
 930                 }
 931                 else rrdset_next(st);
 932
 933                 rrddim_set(st, "arrays", ipc_sem.sets);
 934                 rrdset_done(st);
 935             }
 936         }
 937     }
 938
 939     // --------------------------------------------------------------------
 940
 941     if (likely(do_ipc_shared_mem)) {
 942         if (unlikely(GETSYSCTL("kern.ipc.shmmni", ipc_shm.shmmni))) {
 943             do_ipc_shared_mem = 0;
 944             error("DISABLED: system.ipc_shared_mem_segs");
 945             error("DISABLED: system.ipc_shared_mem_size");
 946         } else {
 947             ipc_shm_data = reallocz(ipc_shm_data, sizeof(struct shmid_kernel) * ipc_shm.shmmni);
 948             if (unlikely(getsysctl("kern.ipc.shmsegs", ipc_shm_data, sizeof(struct shmid_kernel) * ipc_shm.shmmni))) {
 949                 do_ipc_shared_mem = 0;
 950                 error("DISABLED: system.ipc_shared_mem_segs");
 951                 error("DISABLED: system.ipc_shared_mem_size");
 952             } else {
 953                 for (i = 0; i < ipc_shm.shmmni; i++) {
 954                     if (unlikely(ipc_shm_data[i].u.shm_perm.mode & 0x0800)) {
 955                         ipc_shm.segs += 1;
 956                         ipc_shm.segsize += ipc_shm_data[i].u.shm_segsz;
 957                     }
 958                 }
 959
 960                 // --------------------------------------------------------------------
 961
 962                 st = rrdset_find("system.ipc_shared_mem_segs");
 963                 if (unlikely(!st)) {
 964                     st = rrdset_create("system", "ipc_shared_mem_segs", NULL, "ipc shared memory", NULL, "IPC Shared Memory Segments", "segments", 1000, rrd_update_every, RRDSET_TYPE_AREA);
 965                     rrddim_add(st, "segments", NULL, 1, 1, RRDDIM_ABSOLUTE);
 966                 }
 967                 else rrdset_next(st);
 968
 969                 rrddim_set(st, "segments", ipc_shm.segs);
 970                 rrdset_done(st);
 971
 972                 // --------------------------------------------------------------------
 973
 974                 st = rrdset_find("system.ipc_shared_mem_size");
 975                 if (unlikely(!st)) {
 976                     st = rrdset_create("system", "ipc_shared_mem_size", NULL, "ipc shared memory", NULL, "IPC Shared Memory Segments Size", "kilobytes", 1000, rrd_update_every, RRDSET_TYPE_AREA);
 977                     rrddim_add(st, "allocated", NULL, 1, 1024, RRDDIM_ABSOLUTE);
 978                 }
 979                 else rrdset_next(st);
 980
 981                 rrddim_set(st, "allocated", ipc_shm.segsize);
 982                 rrdset_done(st);
 983             }
 984         }
 985     }
 986
 987     // --------------------------------------------------------------------
 988
 989     if (likely(do_ipc_msg_queues)) {
 990         if (unlikely(GETSYSCTL("kern.ipc.msgmni", ipc_msq.msgmni))) {
 991             do_ipc_msg_queues = 0;
 992             error("DISABLED: system.ipc_msq_queues");
 993             error("DISABLED: system.ipc_msq_messages");
 994             error("DISABLED: system.ipc_msq_size");
 995         } else {
 996             ipc_msq_data = reallocz(ipc_msq_data, sizeof(struct msqid_kernel) * ipc_msq.msgmni);
 997             if (unlikely(getsysctl("kern.ipc.msqids", ipc_msq_data, sizeof(struct msqid_kernel) * ipc_msq.msgmni))) {
 998                 do_ipc_msg_queues = 0;
 999                 error("DISABLED: system.ipc_msq_queues");
1000                 error("DISABLED: system.ipc_msq_messages");
1001                 error("DISABLED: system.ipc_msq_size");
1002             } else {
1003                 for (i = 0; i < ipc_msq.msgmni; i++) {
1004                     if (unlikely(ipc_msq_data[i].u.msg_qbytes != 0)) {
1005                         ipc_msq.queues += 1;
1006                         ipc_msq.messages += ipc_msq_data[i].u.msg_qnum;
1007                         ipc_msq.usedsize += ipc_msq_data[i].u.msg_cbytes;
1008                         ipc_msq.allocsize += ipc_msq_data[i].u.msg_qbytes;
1009                     }
1010                 }
1011
1012                 // --------------------------------------------------------------------
1013
1014                 st = rrdset_find("system.ipc_msq_queues");
1015                 if (unlikely(!st)) {
1016                     st = rrdset_create("system", "ipc_msq_queues", NULL, "ipc message queues", NULL, "Number of IPC Message Queues", "queues", 990, rrd_update_every, RRDSET_TYPE_AREA);
1017                     rrddim_add(st, "queues", NULL, 1, 1, RRDDIM_ABSOLUTE);
1018                 }
1019                 else rrdset_next(st);
1020
1021                 rrddim_set(st, "queues", ipc_msq.queues);
1022                 rrdset_done(st);
1023
1024                 // --------------------------------------------------------------------
1025
1026                 st = rrdset_find("system.ipc_msq_messages");
1027                 if (unlikely(!st)) {
1028                     st = rrdset_create("system", "ipc_msq_messages", NULL, "ipc message queues", NULL, "Number of Messages in IPC Message Queues", "messages", 1000, rrd_update_every, RRDSET_TYPE_AREA);
1029                     rrddim_add(st, "messages", NULL, 1, 1, RRDDIM_ABSOLUTE);
1030                 }
1031                 else rrdset_next(st);
1032
1033                 rrddim_set(st, "messages", ipc_msq.messages);
1034                 rrdset_done(st);
1035
1036                 // --------------------------------------------------------------------
1037
1038                 st = rrdset_find("system.ipc_msq_size");
1039                 if (unlikely(!st)) {
1040                     st = rrdset_create("system", "ipc_msq_size", NULL, "ipc message queues", NULL, "Size of IPC Message Queues", "bytes", 1100, rrd_update_every, RRDSET_TYPE_LINE);
1041                     rrddim_add(st, "allocated", NULL, 1, 1, RRDDIM_ABSOLUTE);
1042                     rrddim_add(st, "used", NULL, 1, 1, RRDDIM_ABSOLUTE);
1043                 }
1044                 else rrdset_next(st);
1045
1046                 rrddim_set(st, "allocated", ipc_msq.allocsize);
1047                 rrddim_set(st, "used", ipc_msq.usedsize);
1048                 rrdset_done(st);
1049
1050             }
1051         }
1052     }
1053
1054     // --------------------------------------------------------------------
1055
1056     if (likely(do_netisr || do_netisr_per_core)) {
1057         if (unlikely(GETSYSCTL("kern.smp.cpus", ncpus))) {
1058             common_error = 1;
1059         } else if (unlikely(ncpus > 9999)) {
1060             error("FREEBSD: There are more than 4 digits in cpu cores number");
1061             common_error = 1;
1062         } else if (unlikely(sysctlbyname("net.isr.workstream", NULL, &netisr_workstream_size, NULL, 0) == -1)) {
1063             error("FREEBSD: sysctl(net.isr.workstream...) failed: %s", strerror(errno));
1064             common_error = 1;
1065         } else if (unlikely(sysctlbyname("net.isr.work", NULL, &netisr_work_size, NULL, 0) == -1)) {
1066             error("FREEBSD: sysctl(net.isr.work...) failed: %s", strerror(errno));
1067             common_error = 1;
1068         } else {
1069             num_netisr_workstreams = netisr_workstream_size / sizeof(struct sysctl_netisr_workstream);
1070             netisr_workstream = reallocz(netisr_workstream, num_netisr_workstreams * sizeof(struct sysctl_netisr_workstream));
1071             if (unlikely(getsysctl("net.isr.workstream", netisr_workstream, num_netisr_workstreams * sizeof(struct sysctl_netisr_workstream)))){
1072                 common_error = 1;
1073             } else {
1074                 num_netisr_works = netisr_work_size / sizeof(struct sysctl_netisr_work);
1075                 netisr_work = reallocz(netisr_work, num_netisr_works * sizeof(struct sysctl_netisr_work));
1076                 if (unlikely(getsysctl("net.isr.work", netisr_work, num_netisr_works * sizeof(struct sysctl_netisr_work)))){
1077                     common_error = 1;
1078                 }
1079             }
1080         }
1081         if (unlikely(common_error)) {
1082             do_netisr = 0;
1083             error("DISABLED: system.softnet_stat");
1084             do_netisr_per_core = 0;
1085             error("DISABLED: system.cpuX_softnet_stat");
1086             common_error = 0;
1087         } else {
1088             netisr_stats = reallocz(netisr_stats, (ncpus + 1) * sizeof(struct netisr_stats));
1089             bzero(netisr_stats, (ncpus + 1) * sizeof(struct netisr_stats));
1090             for (i = 0; i < num_netisr_workstreams; i++) {
1091                 for (n = 0; n < num_netisr_works; n++) {
1092                     if (netisr_workstream[i].snws_wsid == netisr_work[n].snw_wsid) {
1093                         netisr_stats[netisr_workstream[i].snws_cpu].dispatched += netisr_work[n].snw_dispatched;
1094                         netisr_stats[netisr_workstream[i].snws_cpu].hybrid_dispatched += netisr_work[n].snw_hybrid_dispatched;
1095                         netisr_stats[netisr_workstream[i].snws_cpu].qdrops += netisr_work[n].snw_qdrops;
1096                         netisr_stats[netisr_workstream[i].snws_cpu].queued += netisr_work[n].snw_queued;
1097                     }
1098                 }
1099             }
1100             for (i = 0; i < ncpus; i++) {
1101                 netisr_stats[ncpus].dispatched += netisr_stats[i].dispatched;
1102                 netisr_stats[ncpus].hybrid_dispatched += netisr_stats[i].hybrid_dispatched;
1103                 netisr_stats[ncpus].qdrops += netisr_stats[i].qdrops;
1104                 netisr_stats[ncpus].queued += netisr_stats[i].queued;
1105             }
1106         }
1107     }
1108
1109     // --------------------------------------------------------------------
1110
1111     if (likely(do_netisr)) {
1112         st = rrdset_find_bytype("system", "softnet_stat");
1113         if (unlikely(!st)) {
1114             st = rrdset_create("system", "softnet_stat", NULL, "softnet_stat", NULL, "System softnet_stat", "events/s", 955, update_every, RRDSET_TYPE_LINE);
1115             rrddim_add(st, "dispatched", NULL, 1, 1, RRDDIM_INCREMENTAL);
1116             rrddim_add(st, "hybrid_dispatched", NULL, 1, 1, RRDDIM_INCREMENTAL);
1117             rrddim_add(st, "qdrops", NULL, 1, 1, RRDDIM_INCREMENTAL);
1118             rrddim_add(st, "queued", NULL, 1, 1, RRDDIM_INCREMENTAL);
1119         }
1120         else rrdset_next(st);
1121
1122         rrddim_set(st, "dispatched", netisr_stats[ncpus].dispatched);
1123         rrddim_set(st, "hybrid_dispatched", netisr_stats[ncpus].hybrid_dispatched);
1124         rrddim_set(st, "qdrops", netisr_stats[ncpus].qdrops);
1125         rrddim_set(st, "queued", netisr_stats[ncpus].queued);
1126         rrdset_done(st);
1127     }
1128
1129     // --------------------------------------------------------------------
1130
1131     if (likely(do_netisr_per_core)) {
1132         for (i = 0; i < ncpus ;i++) {
1133             snprintfz(netstat_cpuid, 21, "cpu%d_softnet_stat", i);
1134
1135             st = rrdset_find_bytype("cpu", netstat_cpuid);
1136             if (unlikely(!st)) {
1137                 st = rrdset_create("cpu", netstat_cpuid, NULL, "softnet_stat", NULL, "Per CPU netisr statistics", "events/s", 1101 + i, update_every, RRDSET_TYPE_LINE);
1138                 rrddim_add(st, "dispatched", NULL, 1, 1, RRDDIM_INCREMENTAL);
1139                 rrddim_add(st, "hybrid_dispatched", NULL, 1, 1, RRDDIM_INCREMENTAL);
1140                 rrddim_add(st, "qdrops", NULL, 1, 1, RRDDIM_INCREMENTAL);
1141                 rrddim_add(st, "queued", NULL, 1, 1, RRDDIM_INCREMENTAL);
1142             }
1143             else rrdset_next(st);
1144
1145             rrddim_set(st, "dispatched", netisr_stats[i].dispatched);
1146             rrddim_set(st, "hybrid_dispatched", netisr_stats[i].hybrid_dispatched);
1147             rrddim_set(st, "qdrops", netisr_stats[i].qdrops);
1148             rrddim_set(st, "queued", netisr_stats[i].queued);
1149             rrdset_done(st);
1150         }
1151     }
1152
1153     // --------------------------------------------------------------------
1154
1155     if (likely(do_bandwidth)) {
1156         if (unlikely(getifaddrs(&ifap))) {
1157             error("FREEBSD: getifaddrs()");
1158             do_bandwidth = 0;
1159             error("DISABLED: system.ipv4");
1160         } else {
1161             iftot.ift_ibytes = iftot.ift_obytes = 0;
1162             for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
1163                 if (ifa->ifa_addr->sa_family != AF_INET)
1164                         continue;
1165                 iftot.ift_ibytes += IFA_DATA(ibytes);
1166                 iftot.ift_obytes += IFA_DATA(obytes);
1167             }
1168
1169             st = rrdset_find("system.ipv4");
1170             if (unlikely(!st)) {
1171                 st = rrdset_create("system", "ipv4", NULL, "network", NULL, "IPv4 Bandwidth", "kilobits/s", 500, update_every, RRDSET_TYPE_AREA);
1172
1173                 rrddim_add(st, "InOctets", "received", 8, 1024, RRDDIM_INCREMENTAL);
1174                 rrddim_add(st, "OutOctets", "sent", -8, 1024, RRDDIM_INCREMENTAL);
1175             }
1176             else rrdset_next(st);
1177
1178             rrddim_set(st, "InOctets", iftot.ift_ibytes);
1179             rrddim_set(st, "OutOctets", iftot.ift_obytes);
1180             rrdset_done(st);
1181
1182             // --------------------------------------------------------------------
1183
1184             iftot.ift_ibytes = iftot.ift_obytes = 0;
1185             for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
1186                 if (ifa->ifa_addr->sa_family != AF_INET6)
1187                         continue;
1188                 iftot.ift_ibytes += IFA_DATA(ibytes);
1189                 iftot.ift_obytes += IFA_DATA(obytes);
1190             }
1191
1192             st = rrdset_find("system.ipv6");
1193             if (unlikely(!st)) {
1194                 st = rrdset_create("system", "ipv6", NULL, "network", NULL, "IPv6 Bandwidth", "kilobits/s", 500, update_every, RRDSET_TYPE_AREA);
1195
1196                 rrddim_add(st, "received", NULL, 8, 1024, RRDDIM_INCREMENTAL);
1197                 rrddim_add(st, "sent", NULL, -8, 1024, RRDDIM_INCREMENTAL);
1198             }
1199             else rrdset_next(st);
1200
1201             rrddim_set(st, "sent", iftot.ift_obytes);
1202             rrddim_set(st, "received", iftot.ift_ibytes);
1203             rrdset_done(st);
1204
1205             for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
1206                 if (ifa->ifa_addr->sa_family != AF_LINK)
1207                         continue;
1208
1209                 // --------------------------------------------------------------------
1210
1211                 st = rrdset_find_bytype("net", ifa->ifa_name);
1212                 if (unlikely(!st)) {
1213                     st = rrdset_create("net", ifa->ifa_name, NULL, ifa->ifa_name, "net.net", "Bandwidth", "kilobits/s", 7000, update_every, RRDSET_TYPE_AREA);
1214
1215                     rrddim_add(st, "received", NULL, 8, 1024, RRDDIM_INCREMENTAL);
1216                     rrddim_add(st, "sent", NULL, -8, 1024, RRDDIM_INCREMENTAL);
1217                 }
1218                 else rrdset_next(st);
1219
1220                 rrddim_set(st, "received", IFA_DATA(ibytes));
1221                 rrddim_set(st, "sent", IFA_DATA(obytes));
1222                 rrdset_done(st);
1223
1224                 // --------------------------------------------------------------------
1225
1226                 st = rrdset_find_bytype("net_packets", ifa->ifa_name);
1227                 if (unlikely(!st)) {
1228                     st = rrdset_create("net_packets", ifa->ifa_name, NULL, ifa->ifa_name, "net.packets", "Packets", "packets/s", 7001, update_every, RRDSET_TYPE_LINE);
1229                     st->isdetail = 1;
1230
1231                     rrddim_add(st, "received", NULL, 1, 1, RRDDIM_INCREMENTAL);
1232                     rrddim_add(st, "sent", NULL, -1, 1, RRDDIM_INCREMENTAL);
1233                     rrddim_add(st, "multicast_received", NULL, 1, 1, RRDDIM_INCREMENTAL);
1234                     rrddim_add(st, "multicast_sent", NULL, -1, 1, RRDDIM_INCREMENTAL);
1235                 }
1236                 else rrdset_next(st);
1237
1238                 rrddim_set(st, "received", IFA_DATA(ipackets));
1239                 rrddim_set(st, "sent", IFA_DATA(opackets));
1240                 rrddim_set(st, "multicast_received", IFA_DATA(imcasts));
1241                 rrddim_set(st, "multicast_sent", IFA_DATA(omcasts));
1242                 rrdset_done(st);
1243
1244                 // --------------------------------------------------------------------
1245
1246                 st = rrdset_find_bytype("net_errors", ifa->ifa_name);
1247                 if (unlikely(!st)) {
1248                     st = rrdset_create("net_errors", ifa->ifa_name, NULL, ifa->ifa_name, "net.errors", "Interface Errors", "errors/s", 7002, update_every, RRDSET_TYPE_LINE);
1249                     st->isdetail = 1;
1250
1251                     rrddim_add(st, "inbound", NULL, 1, 1, RRDDIM_INCREMENTAL);
1252                     rrddim_add(st, "outbound", NULL, -1, 1, RRDDIM_INCREMENTAL);
1253                 }
1254                 else rrdset_next(st);
1255
1256                 rrddim_set(st, "inbound", IFA_DATA(ierrors));
1257                 rrddim_set(st, "outbound", IFA_DATA(oerrors));
1258                 rrdset_done(st);
1259
1260                 // --------------------------------------------------------------------
1261
1262                 st = rrdset_find_bytype("net_drops", ifa->ifa_name);
1263                 if (unlikely(!st)) {
1264                     st = rrdset_create("net_drops", ifa->ifa_name, NULL, ifa->ifa_name, "net.drops", "Interface Drops", "drops/s", 7003, update_every, RRDSET_TYPE_LINE);
1265                     st->isdetail = 1;
1266
1267                     rrddim_add(st, "inbound", NULL, 1, 1, RRDDIM_INCREMENTAL);
1268                     rrddim_add(st, "outbound", NULL, -1, 1, RRDDIM_INCREMENTAL);
1269                 }
1270                 else rrdset_next(st);
1271
1272                 rrddim_set(st, "inbound", IFA_DATA(iqdrops));
1273                 rrddim_set(st, "outbound", IFA_DATA(oqdrops));
1274                 rrdset_done(st);
1275
1276                 // --------------------------------------------------------------------
1277
1278                 st = rrdset_find_bytype("net_events", ifa->ifa_name);
1279                 if (unlikely(!st)) {
1280                     st = rrdset_create("net_events", ifa->ifa_name, NULL, ifa->ifa_name, "net.events", "Network Interface Events", "events/s", 7006, update_every, RRDSET_TYPE_LINE);
1281                     st->isdetail = 1;
1282
1283                     rrddim_add(st, "frames", NULL, 1, 1, RRDDIM_INCREMENTAL);
1284                     rrddim_add(st, "collisions", NULL, -1, 1, RRDDIM_INCREMENTAL);
1285                     rrddim_add(st, "carrier", NULL, -1, 1, RRDDIM_INCREMENTAL);
1286                 }
1287                 else rrdset_next(st);
1288
1289                 rrddim_set(st, "collisions", IFA_DATA(collisions));
1290                 rrdset_done(st);
1291             }
1292
1293             freeifaddrs(ifap);
1294         }
1295     }
1296
1297     // --------------------------------------------------------------------
1298
1299     // see http://net-snmp.sourceforge.net/docs/mibs/tcp.html
1300     if (likely(do_tcp_sockets)) {
1301         if (unlikely(GETSYSCTL("net.inet.tcp.states", tcps_states))) {
1302             do_tcp_sockets = 0;
1303             error("DISABLED: ipv4.tcpsock");
1304         } else {
1305             if (likely(do_tcp_sockets)) {
1306                 st = rrdset_find("ipv4.tcpsock");
1307                 if (unlikely(!st)) {
1308                     st = rrdset_create("ipv4", "tcpsock", NULL, "tcp", NULL, "IPv4 TCP Connections",
1309                                        "active connections", 2500, update_every, RRDSET_TYPE_LINE);
1310
1311                     rrddim_add(st, "CurrEstab", "connections", 1, 1, RRDDIM_ABSOLUTE);
1312                 } else
1313                     rrdset_next(st);
1314
1315                 rrddim_set(st, "CurrEstab", tcps_states[TCPS_ESTABLISHED]);
1316                 rrdset_done(st);
1317             }
1318         }
1319     }
1320
1321     // --------------------------------------------------------------------
1322
1323     // see http://net-snmp.sourceforge.net/docs/mibs/tcp.html
1324     if (likely(do_tcp_packets || do_tcp_errors || do_tcp_handshake || do_tcpext_connaborts || do_tcpext_ofo || do_tcpext_syscookies || do_ecn)) {
1325         if (unlikely(GETSYSCTL("net.inet.tcp.stats", tcpstat))){
1326             do_tcp_packets = 0;
1327             error("DISABLED: ipv4.tcppackets");
1328             do_tcp_errors = 0;
1329             error("DISABLED: ipv4.tcperrors");
1330             do_tcp_handshake = 0;
1331             error("DISABLED: ipv4.tcphandshake");
1332             do_tcpext_connaborts = 0;
1333             error("DISABLED: ipv4.tcpconnaborts");
1334             do_tcpext_ofo = 0;
1335             error("DISABLED: ipv4.tcpofo");
1336             do_tcpext_syscookies = 0;
1337             error("DISABLED: ipv4.tcpsyncookies");
1338             do_ecn = 0;
1339             error("DISABLED: ipv4.ecnpkts");
1340         } else {
1341             if (likely(do_tcp_packets)) {
1342                 st = rrdset_find("ipv4.tcppackets");
1343                 if (unlikely(!st)) {
1344                     st = rrdset_create("ipv4", "tcppackets", NULL, "tcp", NULL, "IPv4 TCP Packets",
1345                                        "packets/s",
1346                                        2600, update_every, RRDSET_TYPE_LINE);
1347
1348                     rrddim_add(st, "InSegs", "received", 1, 1, RRDDIM_INCREMENTAL);
1349                     rrddim_add(st, "OutSegs", "sent", -1, 1, RRDDIM_INCREMENTAL);
1350                 } else
1351                     rrdset_next(st);
1352
1353                 rrddim_set(st, "InSegs", tcpstat.tcps_rcvtotal);
1354                 rrddim_set(st, "OutSegs", tcpstat.tcps_sndtotal);
1355                 rrdset_done(st);
1356             }
1357
1358             // --------------------------------------------------------------------
1359
1360             if (likely(do_tcp_errors)) {
1361                 st = rrdset_find("ipv4.tcperrors");
1362                 if (unlikely(!st)) {
1363                     st = rrdset_create("ipv4", "tcperrors", NULL, "tcp", NULL, "IPv4 TCP Errors",
1364                                        "packets/s",
1365                                        2700, update_every, RRDSET_TYPE_LINE);
1366                     st->isdetail = 1;
1367
1368                     rrddim_add(st, "InErrs", NULL, 1, 1, RRDDIM_INCREMENTAL);
1369                     rrddim_add(st, "InCsumErrors", NULL, 1, 1, RRDDIM_INCREMENTAL);
1370                     rrddim_add(st, "RetransSegs", NULL, -1, 1, RRDDIM_INCREMENTAL);
1371                 } else
1372                     rrdset_next(st);
1373
1374                 rrddim_set(st, "InErrs", tcpstat.tcps_rcvbadoff + tcpstat.tcps_rcvreassfull + tcpstat.tcps_rcvshort);
1375                 rrddim_set(st, "InCsumErrors", tcpstat.tcps_rcvbadsum);
1376                 rrddim_set(st, "RetransSegs", tcpstat.tcps_sndrexmitpack);
1377                 rrdset_done(st);
1378             }
1379
1380             // --------------------------------------------------------------------
1381
1382             if (likely(do_tcp_handshake)) {
1383                 st = rrdset_find("ipv4.tcphandshake");
1384                 if (unlikely(!st)) {
1385                     st = rrdset_create("ipv4", "tcphandshake", NULL, "tcp", NULL,
1386                                        "IPv4 TCP Handshake Issues",
1387                                        "events/s", 2900, update_every, RRDSET_TYPE_LINE);
1388                     st->isdetail = 1;
1389
1390                     rrddim_add(st, "EstabResets", NULL, 1, 1, RRDDIM_INCREMENTAL);
1391                     rrddim_add(st, "ActiveOpens", NULL, 1, 1, RRDDIM_INCREMENTAL);
1392                     rrddim_add(st, "PassiveOpens", NULL, 1, 1, RRDDIM_INCREMENTAL);
1393                     rrddim_add(st, "AttemptFails", NULL, 1, 1, RRDDIM_INCREMENTAL);
1394                 } else
1395                     rrdset_next(st);
1396
1397                 rrddim_set(st, "EstabResets", tcpstat.tcps_drops);
1398                 rrddim_set(st, "ActiveOpens", tcpstat.tcps_connattempt);
1399                 rrddim_set(st, "PassiveOpens", tcpstat.tcps_accepts);
1400                 rrddim_set(st, "AttemptFails", tcpstat.tcps_conndrops);
1401                 rrdset_done(st);
1402             }
1403
1404             // --------------------------------------------------------------------
1405
1406             if (do_tcpext_connaborts == CONFIG_ONDEMAND_YES || (do_tcpext_connaborts == CONFIG_ONDEMAND_ONDEMAND && (tcpstat.tcps_rcvpackafterwin || tcpstat.tcps_rcvafterclose || tcpstat.tcps_rcvmemdrop || tcpstat.tcps_persistdrop || tcpstat.tcps_finwait2_drops))) {
1407                 do_tcpext_connaborts = CONFIG_ONDEMAND_YES;
1408                 st = rrdset_find("ipv4.tcpconnaborts");
1409                 if (unlikely(!st)) {
1410                     st = rrdset_create("ipv4", "tcpconnaborts", NULL, "tcp", NULL, "TCP Connection Aborts", "connections/s", 3010, update_every, RRDSET_TYPE_LINE);
1411
1412                     rrddim_add(st, "TCPAbortOnData",    "baddata",     1, 1, RRDDIM_INCREMENTAL);
1413                     rrddim_add(st, "TCPAbortOnClose",   "userclosed",  1, 1, RRDDIM_INCREMENTAL);
1414                     rrddim_add(st, "TCPAbortOnMemory",  "nomemory",    1, 1, RRDDIM_INCREMENTAL);
1415                     rrddim_add(st, "TCPAbortOnTimeout", "timeout",     1, 1, RRDDIM_INCREMENTAL);
1416                     rrddim_add(st, "TCPAbortOnLinger",  "linger",      1, 1, RRDDIM_INCREMENTAL);
1417                 }
1418                 else rrdset_next(st);
1419
1420                 rrddim_set(st, "TCPAbortOnData",    tcpstat.tcps_rcvpackafterwin);
1421                 rrddim_set(st, "TCPAbortOnClose",   tcpstat.tcps_rcvafterclose);
1422                 rrddim_set(st, "TCPAbortOnMemory",  tcpstat.tcps_rcvmemdrop);
1423                 rrddim_set(st, "TCPAbortOnTimeout", tcpstat.tcps_persistdrop);
1424                 rrddim_set(st, "TCPAbortOnLinger",  tcpstat.tcps_finwait2_drops);
1425                 rrdset_done(st);
1426             }
1427
1428             // --------------------------------------------------------------------
1429
1430             if (do_tcpext_ofo == CONFIG_ONDEMAND_YES || (do_tcpext_ofo == CONFIG_ONDEMAND_ONDEMAND && tcpstat.tcps_rcvoopack)) {
1431                 do_tcpext_ofo = CONFIG_ONDEMAND_YES;
1432                 st = rrdset_find("ipv4.tcpofo");
1433                 if (unlikely(!st)) {
1434                     st = rrdset_create("ipv4", "tcpofo", NULL, "tcp", NULL, "TCP Out-Of-Order Queue", "packets/s", 3050, update_every, RRDSET_TYPE_LINE);
1435
1436                     rrddim_add(st, "TCPOFOQueue", "inqueue",  1, 1, RRDDIM_INCREMENTAL);
1437                 }
1438                 else rrdset_next(st);
1439
1440                 rrddim_set(st, "TCPOFOQueue",   tcpstat.tcps_rcvoopack);
1441                 rrdset_done(st);
1442             }
1443
1444             // --------------------------------------------------------------------
1445
1446             if (do_tcpext_syscookies == CONFIG_ONDEMAND_YES || (do_tcpext_syscookies == CONFIG_ONDEMAND_ONDEMAND && (tcpstat.tcps_sc_sendcookie || tcpstat.tcps_sc_recvcookie || tcpstat.tcps_sc_zonefail))) {
1447                 do_tcpext_syscookies = CONFIG_ONDEMAND_YES;
1448
1449                 st = rrdset_find("ipv4.tcpsyncookies");
1450                 if (unlikely(!st)) {
1451                     st = rrdset_create("ipv4", "tcpsyncookies", NULL, "tcp", NULL, "TCP SYN Cookies", "packets/s", 3100, update_every, RRDSET_TYPE_LINE);
1452
1453                     rrddim_add(st, "SyncookiesRecv",   "received",  1, 1, RRDDIM_INCREMENTAL);
1454                     rrddim_add(st, "SyncookiesSent",   "sent",     -1, 1, RRDDIM_INCREMENTAL);
1455                     rrddim_add(st, "SyncookiesFailed", "failed",   -1, 1, RRDDIM_INCREMENTAL);
1456                 }
1457                 else rrdset_next(st);
1458
1459                 rrddim_set(st, "SyncookiesRecv",   tcpstat.tcps_sc_recvcookie);
1460                 rrddim_set(st, "SyncookiesSent",   tcpstat.tcps_sc_sendcookie);
1461                 rrddim_set(st, "SyncookiesFailed", tcpstat.tcps_sc_zonefail);
1462                 rrdset_done(st);
1463             }
1464
1465             // --------------------------------------------------------------------
1466
1467             if (do_ecn == CONFIG_ONDEMAND_YES || (do_ecn == CONFIG_ONDEMAND_ONDEMAND && (tcpstat.tcps_ecn_ce || tcpstat.tcps_ecn_ect0 || tcpstat.tcps_ecn_ect1))) {
1468                 do_ecn = CONFIG_ONDEMAND_YES;
1469                 st = rrdset_find("ipv4.ecnpkts");
1470                 if (unlikely(!st)) {
1471                     st = rrdset_create("ipv4", "ecnpkts", NULL, "ecn", NULL, "IPv4 ECN Statistics", "packets/s", 8700, update_every, RRDSET_TYPE_LINE);
1472                     st->isdetail = 1;
1473
1474                     rrddim_add(st, "InCEPkts", "CEP", 1, 1, RRDDIM_INCREMENTAL);
1475                     rrddim_add(st, "InNoECTPkts", "NoECTP", -1, 1, RRDDIM_INCREMENTAL);
1476                     rrddim_add(st, "InECT0Pkts", "ECTP0", 1, 1, RRDDIM_INCREMENTAL);
1477                     rrddim_add(st, "InECT1Pkts", "ECTP1", 1, 1, RRDDIM_INCREMENTAL);
1478                 }
1479                 else rrdset_next(st);
1480
1481                 rrddim_set(st, "InCEPkts", tcpstat.tcps_ecn_ce);
1482                 rrddim_set(st, "InNoECTPkts", tcpstat.tcps_ecn_ce - (tcpstat.tcps_ecn_ect0 + tcpstat.tcps_ecn_ect1));
1483                 rrddim_set(st, "InECT0Pkts", tcpstat.tcps_ecn_ect0);
1484                 rrddim_set(st, "InECT1Pkts", tcpstat.tcps_ecn_ect1);
1485                 rrdset_done(st);
1486             }
1487
1488         }
1489     }
1490
1491     // --------------------------------------------------------------------
1492
1493     // see http://net-snmp.sourceforge.net/docs/mibs/udp.html
1494     if (likely(do_udp_packets || do_udp_errors)) {
1495         if (unlikely(GETSYSCTL("net.inet.udp.stats", udpstat))) {
1496             do_udp_packets = 0;
1497             error("DISABLED: ipv4.udppackets");
1498             do_udp_errors = 0;
1499             error("DISABLED: ipv4.udperrors");
1500         } else {
1501             if (likely(do_udp_packets)) {
1502                 st = rrdset_find("ipv4.udppackets");
1503                 if (unlikely(!st)) {
1504                     st = rrdset_create("ipv4", "udppackets", NULL, "udp", NULL, "IPv4 UDP Packets",
1505                                        "packets/s", 2601, update_every, RRDSET_TYPE_LINE);
1506
1507                     rrddim_add(st, "InDatagrams", "received", 1, 1, RRDDIM_INCREMENTAL);
1508                     rrddim_add(st, "OutDatagrams", "sent", -1, 1, RRDDIM_INCREMENTAL);
1509                 } else
1510                     rrdset_next(st);
1511
1512                 rrddim_set(st, "InDatagrams", udpstat.udps_ipackets);
1513                 rrddim_set(st, "OutDatagrams", udpstat.udps_opackets);
1514                 rrdset_done(st);
1515             }
1516
1517             // --------------------------------------------------------------------
1518
1519             if (likely(do_udp_errors)) {
1520                 st = rrdset_find("ipv4.udperrors");
1521                 if (unlikely(!st)) {
1522                     st = rrdset_create("ipv4", "udperrors", NULL, "udp", NULL, "IPv4 UDP Errors", "events/s",
1523                                        2701, update_every, RRDSET_TYPE_LINE);
1524                     st->isdetail = 1;
1525
1526                     rrddim_add(st, "RcvbufErrors", NULL, 1, 1, RRDDIM_INCREMENTAL);
1527                     rrddim_add(st, "InErrors", NULL, 1, 1, RRDDIM_INCREMENTAL);
1528                     rrddim_add(st, "NoPorts", NULL, 1, 1, RRDDIM_INCREMENTAL);
1529                     rrddim_add(st, "InCsumErrors", NULL, 1, 1, RRDDIM_INCREMENTAL);
1530                     rrddim_add(st, "IgnoredMulti", NULL, 1, 1, RRDDIM_INCREMENTAL);
1531                 } else
1532                     rrdset_next(st);
1533
1534                 rrddim_set(st, "InErrors", udpstat.udps_hdrops + udpstat.udps_badlen);
1535                 rrddim_set(st, "NoPorts", udpstat.udps_noport);
1536                 rrddim_set(st, "RcvbufErrors", udpstat.udps_fullsock);
1537                 rrddim_set(st, "InCsumErrors", udpstat.udps_badsum + udpstat.udps_nosum);
1538                 rrddim_set(st, "IgnoredMulti", udpstat.udps_filtermcast);
1539                 rrdset_done(st);
1540             }
1541         }
1542     }
1543
1544     // --------------------------------------------------------------------
1545
1546     if (likely(do_icmp_packets || do_icmpmsg)) {
1547         if (unlikely(GETSYSCTL("net.inet.icmp.stats", icmpstat))) {
1548             do_icmp_packets = 0;
1549             error("DISABLED: ipv4.icmp");
1550             error("DISABLED: ipv4.icmp_errors");
1551             do_icmpmsg = 0;
1552             error("DISABLED: ipv4.icmpmsg");
1553         } else {
1554             for (i = 0; i <= ICMP_MAXTYPE; i++) {
1555                 icmp_total.msgs_in += icmpstat.icps_inhist[i];
1556                 icmp_total.msgs_out += icmpstat.icps_outhist[i];
1557             }
1558             icmp_total.msgs_in += icmpstat.icps_badcode + icmpstat.icps_badlen + icmpstat.icps_checksum + icmpstat.icps_tooshort;
1559
1560             // --------------------------------------------------------------------
1561
1562             if (likely(do_icmp_packets)) {
1563                 st = rrdset_find("ipv4.icmp");
1564                 if (unlikely(!st)) {
1565                     st = rrdset_create("ipv4", "icmp", NULL, "icmp", NULL, "IPv4 ICMP Packets", "packets/s",
1566                                        2602,
1567                                        update_every, RRDSET_TYPE_LINE);
1568
1569                     rrddim_add(st, "InMsgs", "received", 1, 1, RRDDIM_INCREMENTAL);
1570                     rrddim_add(st, "OutMsgs", "sent", -1, 1, RRDDIM_INCREMENTAL);
1571                 } else
1572                     rrdset_next(st);
1573
1574                 rrddim_set(st, "InMsgs", icmp_total.msgs_in);
1575                 rrddim_set(st, "OutMsgs", icmp_total.msgs_out);
1576
1577                 rrdset_done(st);
1578
1579                 // --------------------------------------------------------------------
1580
1581                 st = rrdset_find("ipv4.icmp_errors");
1582                 if (unlikely(!st)) {
1583                     st = rrdset_create("ipv4", "icmp_errors", NULL, "icmp", NULL, "IPv4 ICMP Errors",
1584                                        "packets/s",
1585                                        2603, update_every, RRDSET_TYPE_LINE);
1586
1587                     rrddim_add(st, "InErrors", NULL, 1, 1, RRDDIM_INCREMENTAL);
1588                     rrddim_add(st, "OutErrors", NULL, -1, 1, RRDDIM_INCREMENTAL);
1589                     rrddim_add(st, "InCsumErrors", NULL, 1, 1, RRDDIM_INCREMENTAL);
1590                 } else
1591                     rrdset_next(st);
1592
1593                 rrddim_set(st, "InErrors", icmpstat.icps_badcode + icmpstat.icps_badlen + icmpstat.icps_checksum + icmpstat.icps_tooshort);
1594                 rrddim_set(st, "OutErrors", icmpstat.icps_error);
1595                 rrddim_set(st, "InCsumErrors", icmpstat.icps_checksum);
1596
1597                 rrdset_done(st);
1598             }
1599
1600             // --------------------------------------------------------------------
1601
1602             if (likely(do_icmpmsg)) {
1603                 st = rrdset_find("ipv4.icmpmsg");
1604                 if (unlikely(!st)) {
1605                     st = rrdset_create("ipv4", "icmpmsg", NULL, "icmp", NULL, "IPv4 ICMP Messsages",
1606                                        "packets/s", 2604, update_every, RRDSET_TYPE_LINE);
1607
1608                     rrddim_add(st, "InEchoReps", NULL, 1, 1, RRDDIM_INCREMENTAL);
1609                     rrddim_add(st, "OutEchoReps", NULL, -1, 1, RRDDIM_INCREMENTAL);
1610                     rrddim_add(st, "InEchos", NULL, 1, 1, RRDDIM_INCREMENTAL);
1611                     rrddim_add(st, "OutEchos", NULL, -1, 1, RRDDIM_INCREMENTAL);
1612                 } else
1613                     rrdset_next(st);
1614
1615                     rrddim_set(st, "InEchoReps", icmpstat.icps_inhist[ICMP_ECHOREPLY]);
1616                     rrddim_set(st, "OutEchoReps", icmpstat.icps_outhist[ICMP_ECHOREPLY]);
1617                     rrddim_set(st, "InEchos", icmpstat.icps_inhist[ICMP_ECHO]);
1618                     rrddim_set(st, "OutEchos", icmpstat.icps_outhist[ICMP_ECHO]);
1619
1620                 rrdset_done(st);
1621             }
1622         }
1623     }
1624
1625     // --------------------------------------------------------------------
1626
1627     // see also http://net-snmp.sourceforge.net/docs/mibs/ip.html
1628     if (likely(do_ip_packets || do_ip_fragsout || do_ip_fragsin || do_ip_errors)) {
1629         if (unlikely(GETSYSCTL("net.inet.ip.stats", ipstat))) {
1630             do_ip_packets = 0;
1631             error("DISABLED: ipv4.packets");
1632             do_ip_fragsout = 0;
1633             error("DISABLED: ipv4.fragsout");
1634             do_ip_fragsin = 0;
1635             error("DISABLED: ipv4.fragsin");
1636             do_ip_errors = 0;
1637             error("DISABLED: ipv4.errors");
1638         } else {
1639             if (likely(do_ip_packets)) {
1640                 st = rrdset_find("ipv4.packets");
1641                 if (unlikely(!st)) {
1642                     st = rrdset_create("ipv4", "packets", NULL, "packets", NULL, "IPv4 Packets", "packets/s",
1643                                        3000, update_every, RRDSET_TYPE_LINE);
1644
1645                     rrddim_add(st, "InReceives", "received", 1, 1, RRDDIM_INCREMENTAL);
1646                     rrddim_add(st, "OutRequests", "sent", -1, 1, RRDDIM_INCREMENTAL);
1647                     rrddim_add(st, "ForwDatagrams", "forwarded", 1, 1, RRDDIM_INCREMENTAL);
1648                     rrddim_add(st, "InDelivers", "delivered", 1, 1, RRDDIM_INCREMENTAL);
1649                 } else
1650                     rrdset_next(st);
1651
1652                 rrddim_set(st, "OutRequests", ipstat.ips_localout);
1653                 rrddim_set(st, "InReceives", ipstat.ips_total);
1654                 rrddim_set(st, "ForwDatagrams", ipstat.ips_forward);
1655                 rrddim_set(st, "InDelivers", ipstat.ips_delivered);
1656                 rrdset_done(st);
1657             }
1658
1659             // --------------------------------------------------------------------
1660
1661             if (likely(do_ip_fragsout)) {
1662                 st = rrdset_find("ipv4.fragsout");
1663                 if (unlikely(!st)) {
1664                     st = rrdset_create("ipv4", "fragsout", NULL, "fragments", NULL, "IPv4 Fragments Sent",
1665                                        "packets/s", 3010, update_every, RRDSET_TYPE_LINE);
1666                     st->isdetail = 1;
1667
1668                     rrddim_add(st, "FragOKs", "ok", 1, 1, RRDDIM_INCREMENTAL);
1669                     rrddim_add(st, "FragFails", "failed", -1, 1, RRDDIM_INCREMENTAL);
1670                     rrddim_add(st, "FragCreates", "created", 1, 1, RRDDIM_INCREMENTAL);
1671                 } else
1672                     rrdset_next(st);
1673
1674                 rrddim_set(st, "FragOKs", ipstat.ips_fragmented);
1675                 rrddim_set(st, "FragFails", ipstat.ips_cantfrag);
1676                 rrddim_set(st, "FragCreates", ipstat.ips_ofragments);
1677                 rrdset_done(st);
1678             }
1679
1680             // --------------------------------------------------------------------
1681
1682             if (likely(do_ip_fragsin)) {
1683                 st = rrdset_find("ipv4.fragsin");
1684                 if (unlikely(!st)) {
1685                     st = rrdset_create("ipv4", "fragsin", NULL, "fragments", NULL,
1686                                        "IPv4 Fragments Reassembly",
1687                                        "packets/s", 3011, update_every, RRDSET_TYPE_LINE);
1688                     st->isdetail = 1;
1689
1690                     rrddim_add(st, "ReasmOKs", "ok", 1, 1, RRDDIM_INCREMENTAL);
1691                     rrddim_add(st, "ReasmFails", "failed", -1, 1, RRDDIM_INCREMENTAL);
1692                     rrddim_add(st, "ReasmReqds", "all", 1, 1, RRDDIM_INCREMENTAL);
1693                 } else
1694                     rrdset_next(st);
1695
1696                 rrddim_set(st, "ReasmOKs", ipstat.ips_fragments);
1697                 rrddim_set(st, "ReasmFails", ipstat.ips_fragdropped);
1698                 rrddim_set(st, "ReasmReqds", ipstat.ips_reassembled);
1699                 rrdset_done(st);
1700             }
1701
1702             // --------------------------------------------------------------------
1703
1704             if (likely(do_ip_errors)) {
1705                 st = rrdset_find("ipv4.errors");
1706                 if (unlikely(!st)) {
1707                     st = rrdset_create("ipv4", "errors", NULL, "errors", NULL, "IPv4 Errors", "packets/s",
1708                                        3002,
1709                                        update_every, RRDSET_TYPE_LINE);
1710                     st->isdetail = 1;
1711
1712                     rrddim_add(st, "InDiscards", NULL, 1, 1, RRDDIM_INCREMENTAL);
1713                     rrddim_add(st, "OutDiscards", NULL, -1, 1, RRDDIM_INCREMENTAL);
1714
1715                     rrddim_add(st, "InHdrErrors", NULL, 1, 1, RRDDIM_INCREMENTAL);
1716                     rrddim_add(st, "OutNoRoutes", NULL, -1, 1, RRDDIM_INCREMENTAL);
1717
1718                     rrddim_add(st, "InAddrErrors", NULL, 1, 1, RRDDIM_INCREMENTAL);
1719                     rrddim_add(st, "InUnknownProtos", NULL, 1, 1, RRDDIM_INCREMENTAL);
1720                 } else
1721                     rrdset_next(st);
1722
1723                 rrddim_set(st, "InDiscards", ipstat.ips_badsum + ipstat.ips_tooshort + ipstat.ips_toosmall + ipstat.ips_toolong);
1724                 rrddim_set(st, "OutDiscards", ipstat.ips_odropped);
1725                 rrddim_set(st, "InHdrErrors", ipstat.ips_badhlen + ipstat.ips_badlen + ipstat.ips_badoptions + ipstat.ips_badvers);
1726                 rrddim_set(st, "InAddrErrors", ipstat.ips_badaddr);
1727                 rrddim_set(st, "InUnknownProtos", ipstat.ips_noproto);
1728                 rrddim_set(st, "OutNoRoutes", ipstat.ips_noroute);
1729                 rrdset_done(st);
1730             }
1731         }
1732     }
1733
1734     // --------------------------------------------------------------------
1735
1736     if (likely(do_ip6_packets || do_ip6_fragsout || do_ip6_fragsin || do_ip6_errors)) {
1737         if (unlikely(GETSYSCTL("net.inet6.ip6.stats", ip6stat))) {
1738             do_ip6_packets = 0;
1739             error("DISABLED: ipv6.packets");
1740             do_ip6_fragsout = 0;
1741             error("DISABLED: ipv6.fragsout");
1742             do_ip6_fragsin = 0;
1743             error("DISABLED: ipv6.fragsin");
1744             do_ip6_errors = 0;
1745             error("DISABLED: ipv6.errors");
1746         } else {
1747             if (do_ip6_packets == CONFIG_ONDEMAND_YES || (do_ip6_packets == CONFIG_ONDEMAND_ONDEMAND &&
1748                                                           (ip6stat.ip6s_localout || ip6stat.ip6s_total ||
1749                                                            ip6stat.ip6s_forward || ip6stat.ip6s_delivered))) {
1750                 do_ip6_packets = CONFIG_ONDEMAND_YES;
1751                 st = rrdset_find("ipv6.packets");
1752                 if (unlikely(!st)) {
1753                     st = rrdset_create("ipv6", "packets", NULL, "packets", NULL, "IPv6 Packets", "packets/s", 3000,
1754                                        update_every, RRDSET_TYPE_LINE);
1755
1756                     rrddim_add(st, "received", NULL, 1, 1, RRDDIM_INCREMENTAL);
1757                     rrddim_add(st, "sent", NULL, -1, 1, RRDDIM_INCREMENTAL);
1758                     rrddim_add(st, "forwarded", NULL, 1, 1, RRDDIM_INCREMENTAL);
1759                     rrddim_add(st, "delivers", NULL, -1, 1, RRDDIM_INCREMENTAL);
1760                 } else
1761                     rrdset_next(st);
1762
1763                 rrddim_set(st, "sent", ip6stat.ip6s_localout);
1764                 rrddim_set(st, "received", ip6stat.ip6s_total);
1765                 rrddim_set(st, "forwarded", ip6stat.ip6s_forward);
1766                 rrddim_set(st, "delivers", ip6stat.ip6s_delivered);
1767                 rrdset_done(st);
1768             }
1769
1770             // --------------------------------------------------------------------
1771
1772             if (do_ip6_fragsout == CONFIG_ONDEMAND_YES || (do_ip6_fragsout == CONFIG_ONDEMAND_ONDEMAND &&
1773                                                            (ip6stat.ip6s_fragmented || ip6stat.ip6s_cantfrag ||
1774                                                             ip6stat.ip6s_ofragments))) {
1775                 do_ip6_fragsout = CONFIG_ONDEMAND_YES;
1776                 st = rrdset_find("ipv6.fragsout");
1777                 if (unlikely(!st)) {
1778                     st = rrdset_create("ipv6", "fragsout", NULL, "fragments", NULL, "IPv6 Fragments Sent",
1779                                        "packets/s", 3010, update_every, RRDSET_TYPE_LINE);
1780                     st->isdetail = 1;
1781
1782                     rrddim_add(st, "ok", NULL, 1, 1, RRDDIM_INCREMENTAL);
1783                     rrddim_add(st, "failed", NULL, -1, 1, RRDDIM_INCREMENTAL);
1784                     rrddim_add(st, "all", NULL, 1, 1, RRDDIM_INCREMENTAL);
1785                 } else
1786                     rrdset_next(st);
1787
1788                 rrddim_set(st, "ok", ip6stat.ip6s_fragmented);
1789                 rrddim_set(st, "failed", ip6stat.ip6s_cantfrag);
1790                 rrddim_set(st, "all", ip6stat.ip6s_ofragments);
1791                 rrdset_done(st);
1792             }
1793
1794             // --------------------------------------------------------------------
1795
1796             if (do_ip6_fragsin == CONFIG_ONDEMAND_YES || (do_ip6_fragsin == CONFIG_ONDEMAND_ONDEMAND &&
1797                                                           (ip6stat.ip6s_reassembled || ip6stat.ip6s_fragdropped ||
1798                                                            ip6stat.ip6s_fragtimeout || ip6stat.ip6s_fragments))) {
1799                 do_ip6_fragsin = CONFIG_ONDEMAND_YES;
1800                 st = rrdset_find("ipv6.fragsin");
1801                 if (unlikely(!st)) {
1802                     st = rrdset_create("ipv6", "fragsin", NULL, "fragments", NULL, "IPv6 Fragments Reassembly",
1803                                        "packets/s", 3011, update_every, RRDSET_TYPE_LINE);
1804                     st->isdetail = 1;
1805
1806                     rrddim_add(st, "ok", NULL, 1, 1, RRDDIM_INCREMENTAL);
1807                     rrddim_add(st, "failed", NULL, -1, 1, RRDDIM_INCREMENTAL);
1808                     rrddim_add(st, "timeout", NULL, -1, 1, RRDDIM_INCREMENTAL);
1809                     rrddim_add(st, "all", NULL, 1, 1, RRDDIM_INCREMENTAL);
1810                 } else
1811                     rrdset_next(st);
1812
1813                 rrddim_set(st, "ok", ip6stat.ip6s_reassembled);
1814                 rrddim_set(st, "failed", ip6stat.ip6s_fragdropped);
1815                 rrddim_set(st, "timeout", ip6stat.ip6s_fragtimeout);
1816                 rrddim_set(st, "all", ip6stat.ip6s_fragments);
1817                 rrdset_done(st);
1818             }
1819
1820             // --------------------------------------------------------------------
1821
1822             if (do_ip6_errors == CONFIG_ONDEMAND_YES || (do_ip6_errors == CONFIG_ONDEMAND_ONDEMAND && (
1823                     ip6stat.ip6s_toosmall ||
1824                     ip6stat.ip6s_odropped ||
1825                     ip6stat.ip6s_badoptions ||
1826                     ip6stat.ip6s_badvers ||
1827                     ip6stat.ip6s_exthdrtoolong ||
1828                     ip6stat.ip6s_sources_none ||
1829                     ip6stat.ip6s_tooshort ||
1830                     ip6stat.ip6s_cantforward ||
1831                     ip6stat.ip6s_noroute))) {
1832                 do_ip6_errors = CONFIG_ONDEMAND_YES;
1833                 st = rrdset_find("ipv6.errors");
1834                 if (unlikely(!st)) {
1835                     st = rrdset_create("ipv6", "errors", NULL, "errors", NULL, "IPv6 Errors", "packets/s", 3002,
1836                                        update_every, RRDSET_TYPE_LINE);
1837                     st->isdetail = 1;
1838
1839                     rrddim_add(st, "InDiscards", NULL, 1, 1, RRDDIM_INCREMENTAL);
1840                     rrddim_add(st, "OutDiscards", NULL, -1, 1, RRDDIM_INCREMENTAL);
1841
1842                     rrddim_add(st, "InHdrErrors", NULL, 1, 1, RRDDIM_INCREMENTAL);
1843                     rrddim_add(st, "InAddrErrors", NULL, 1, 1, RRDDIM_INCREMENTAL);
1844                     rrddim_add(st, "InTruncatedPkts", NULL, 1, 1, RRDDIM_INCREMENTAL);
1845                     rrddim_add(st, "InNoRoutes", NULL, 1, 1, RRDDIM_INCREMENTAL);
1846
1847                     rrddim_add(st, "OutNoRoutes", NULL, -1, 1, RRDDIM_INCREMENTAL);
1848                 } else
1849                     rrdset_next(st);
1850
1851                 rrddim_set(st, "InDiscards", ip6stat.ip6s_toosmall);
1852                 rrddim_set(st, "OutDiscards", ip6stat.ip6s_odropped);
1853
1854                 rrddim_set(st, "InHdrErrors",
1855                            ip6stat.ip6s_badoptions + ip6stat.ip6s_badvers + ip6stat.ip6s_exthdrtoolong);
1856                 rrddim_set(st, "InAddrErrors", ip6stat.ip6s_sources_none);
1857                 rrddim_set(st, "InTruncatedPkts", ip6stat.ip6s_tooshort);
1858                 rrddim_set(st, "InNoRoutes", ip6stat.ip6s_cantforward);
1859
1860                 rrddim_set(st, "OutNoRoutes", ip6stat.ip6s_noroute);
1861                 rrdset_done(st);
1862             }
1863         }
1864     }
1865
1866     // --------------------------------------------------------------------
1867
1868     if (likely(do_icmp6 || do_icmp6_redir || do_icmp6_errors || do_icmp6_echos || do_icmp6_router || do_icmp6_neighbor || do_icmp6_types)) {
1869         if (unlikely(GETSYSCTL("net.inet6.icmp6.stats", icmp6stat))) {
1870             do_icmp6 = 0;
1871             error("DISABLED: ipv6.icmp");
1872         } else {
1873             for (i = 0; i <= ICMP6_MAXTYPE; i++) {
1874                 icmp6_total.msgs_in += icmp6stat.icp6s_inhist[i];
1875                 icmp6_total.msgs_out += icmp6stat.icp6s_outhist[i];
1876             }
1877             icmp6_total.msgs_in += icmp6stat.icp6s_badcode + icmp6stat.icp6s_badlen + icmp6stat.icp6s_checksum + icmp6stat.icp6s_tooshort;
1878             if (do_icmp6 == CONFIG_ONDEMAND_YES || (do_icmp6 == CONFIG_ONDEMAND_ONDEMAND && (icmp6_total.msgs_in || icmp6_total.msgs_out))) {
1879                 do_icmp6 = CONFIG_ONDEMAND_YES;
1880                 st = rrdset_find("ipv6.icmp");
1881                 if (unlikely(!st)) {
1882                     st = rrdset_create("ipv6", "icmp", NULL, "icmp", NULL, "IPv6 ICMP Messages",
1883                                        "messages/s", 10000, update_every, RRDSET_TYPE_LINE);
1884
1885                     rrddim_add(st, "received", NULL, 1, 1, RRDDIM_INCREMENTAL);
1886                     rrddim_add(st, "sent", NULL, -1, 1, RRDDIM_INCREMENTAL);
1887                 } else
1888                     rrdset_next(st);
1889
1890                 rrddim_set(st, "sent", icmp6_total.msgs_in);
1891                 rrddim_set(st, "received", icmp6_total.msgs_out);
1892                 rrdset_done(st);
1893             }
1894
1895             // --------------------------------------------------------------------
1896
1897             if (do_icmp6_redir == CONFIG_ONDEMAND_YES || (do_icmp6_redir == CONFIG_ONDEMAND_ONDEMAND && (icmp6stat.icp6s_inhist[ND_REDIRECT] || icmp6stat.icp6s_outhist[ND_REDIRECT]))) {
1898                 do_icmp6_redir = CONFIG_ONDEMAND_YES;
1899                 st = rrdset_find("ipv6.icmpredir");
1900                 if (unlikely(!st)) {
1901                     st = rrdset_create("ipv6", "icmpredir", NULL, "icmp", NULL, "IPv6 ICMP Redirects",
1902                                        "redirects/s", 10050, update_every, RRDSET_TYPE_LINE);
1903
1904                     rrddim_add(st, "received", NULL, 1, 1, RRDDIM_INCREMENTAL);
1905                     rrddim_add(st, "sent", NULL, -1, 1, RRDDIM_INCREMENTAL);
1906                 } else
1907                     rrdset_next(st);
1908
1909                 rrddim_set(st, "sent", icmp6stat.icp6s_inhist[ND_REDIRECT]);
1910                 rrddim_set(st, "received", icmp6stat.icp6s_outhist[ND_REDIRECT]);
1911                 rrdset_done(st);
1912             }
1913
1914             // --------------------------------------------------------------------
1915
1916             if (do_icmp6_errors == CONFIG_ONDEMAND_YES || (do_icmp6_errors == CONFIG_ONDEMAND_ONDEMAND && (
1917                                                                             icmp6stat.icp6s_badcode ||
1918                                                                             icmp6stat.icp6s_badlen ||
1919                                                                             icmp6stat.icp6s_checksum ||
1920                                                                             icmp6stat.icp6s_tooshort ||
1921                                                                             icmp6stat.icp6s_error ||
1922                                                                             icmp6stat.icp6s_inhist[ICMP6_DST_UNREACH] ||
1923                                                                             icmp6stat.icp6s_inhist[ICMP6_TIME_EXCEEDED] ||
1924                                                                             icmp6stat.icp6s_inhist[ICMP6_PARAM_PROB] ||
1925                                                                             icmp6stat.icp6s_outhist[ICMP6_DST_UNREACH] ||
1926                                                                             icmp6stat.icp6s_outhist[ICMP6_TIME_EXCEEDED] ||
1927                                                                             icmp6stat.icp6s_outhist[ICMP6_PARAM_PROB]))) {
1928                 do_icmp6_errors = CONFIG_ONDEMAND_YES;
1929                 st = rrdset_find("ipv6.icmperrors");
1930                 if (unlikely(!st)) {
1931                     st = rrdset_create("ipv6", "icmperrors", NULL, "icmp", NULL, "IPv6 ICMP Errors", "errors/s", 10100, update_every, RRDSET_TYPE_LINE);
1932
1933                     rrddim_add(st, "InErrors", NULL, 1, 1, RRDDIM_INCREMENTAL);
1934                     rrddim_add(st, "OutErrors", NULL, -1, 1, RRDDIM_INCREMENTAL);
1935
1936                     rrddim_add(st, "InCsumErrors", NULL, 1, 1, RRDDIM_INCREMENTAL);
1937                     rrddim_add(st, "InDestUnreachs", NULL, 1, 1, RRDDIM_INCREMENTAL);
1938                     rrddim_add(st, "InPktTooBigs", NULL, 1, 1, RRDDIM_INCREMENTAL);
1939                     rrddim_add(st, "InTimeExcds", NULL, 1, 1, RRDDIM_INCREMENTAL);
1940                     rrddim_add(st, "InParmProblems", NULL, 1, 1, RRDDIM_INCREMENTAL);
1941                     rrddim_add(st, "OutDestUnreachs", NULL, -1, 1, RRDDIM_INCREMENTAL);
1942                     rrddim_add(st, "OutTimeExcds", NULL, -1, 1, RRDDIM_INCREMENTAL);
1943                     rrddim_add(st, "OutParmProblems", NULL, -1, 1, RRDDIM_INCREMENTAL);
1944                 } else
1945                     rrdset_next(st);
1946
1947                 rrddim_set(st, "InErrors", icmp6stat.icp6s_badcode + icmp6stat.icp6s_badlen + icmp6stat.icp6s_checksum + icmp6stat.icp6s_tooshort);
1948                 rrddim_set(st, "OutErrors", icmp6stat.icp6s_error);
1949                 rrddim_set(st, "InCsumErrors", icmp6stat.icp6s_checksum);
1950                 rrddim_set(st, "InDestUnreachs", icmp6stat.icp6s_inhist[ICMP6_DST_UNREACH]);
1951                 rrddim_set(st, "InPktTooBigs", icmp6stat.icp6s_badlen);
1952                 rrddim_set(st, "InTimeExcds", icmp6stat.icp6s_inhist[ICMP6_TIME_EXCEEDED]);
1953                 rrddim_set(st, "InParmProblems", icmp6stat.icp6s_inhist[ICMP6_PARAM_PROB]);
1954                 rrddim_set(st, "OutDestUnreachs", icmp6stat.icp6s_outhist[ICMP6_DST_UNREACH]);
1955                 rrddim_set(st, "OutTimeExcds", icmp6stat.icp6s_outhist[ICMP6_TIME_EXCEEDED]);
1956                 rrddim_set(st, "OutParmProblems", icmp6stat.icp6s_outhist[ICMP6_PARAM_PROB]);
1957                 rrdset_done(st);
1958             }
1959
1960             // --------------------------------------------------------------------
1961
1962             if (do_icmp6_echos == CONFIG_ONDEMAND_YES || (do_icmp6_echos == CONFIG_ONDEMAND_ONDEMAND && (
1963                                                                  icmp6stat.icp6s_inhist[ICMP6_ECHO_REQUEST] ||
1964                                                                  icmp6stat.icp6s_outhist[ICMP6_ECHO_REQUEST] ||
1965                                                                  icmp6stat.icp6s_inhist[ICMP6_ECHO_REPLY] ||
1966                                                                  icmp6stat.icp6s_outhist[ICMP6_ECHO_REPLY]))) {
1967                 do_icmp6_echos = CONFIG_ONDEMAND_YES;
1968                 st = rrdset_find("ipv6.icmpechos");
1969                 if (unlikely(!st)) {
1970                     st = rrdset_create("ipv6", "icmpechos", NULL, "icmp", NULL, "IPv6 ICMP Echo", "messages/s", 10200, update_every, RRDSET_TYPE_LINE);
1971
1972                     rrddim_add(st, "InEchos", NULL, 1, 1, RRDDIM_INCREMENTAL);
1973                     rrddim_add(st, "OutEchos", NULL, -1, 1, RRDDIM_INCREMENTAL);
1974                     rrddim_add(st, "InEchoReplies", NULL, 1, 1, RRDDIM_INCREMENTAL);
1975                     rrddim_add(st, "OutEchoReplies", NULL, -1, 1, RRDDIM_INCREMENTAL);
1976                 } else
1977                     rrdset_next(st);
1978
1979                 rrddim_set(st, "InEchos", icmp6stat.icp6s_inhist[ICMP6_ECHO_REQUEST]);
1980                 rrddim_set(st, "OutEchos", icmp6stat.icp6s_outhist[ICMP6_ECHO_REQUEST]);
1981                 rrddim_set(st, "InEchoReplies", icmp6stat.icp6s_inhist[ICMP6_ECHO_REPLY]);
1982                 rrddim_set(st, "OutEchoReplies", icmp6stat.icp6s_outhist[ICMP6_ECHO_REPLY]);
1983                 rrdset_done(st);
1984             }
1985
1986             // --------------------------------------------------------------------
1987
1988             if (do_icmp6_router == CONFIG_ONDEMAND_YES || (do_icmp6_router == CONFIG_ONDEMAND_ONDEMAND && (
1989                                                                     icmp6stat.icp6s_inhist[ND_ROUTER_SOLICIT] ||
1990                                                                     icmp6stat.icp6s_outhist[ND_ROUTER_SOLICIT] ||
1991                                                                     icmp6stat.icp6s_inhist[ND_ROUTER_ADVERT] ||
1992                                                                     icmp6stat.icp6s_outhist[ND_ROUTER_ADVERT]))) {
1993                 do_icmp6_router = CONFIG_ONDEMAND_YES;
1994                 st = rrdset_find("ipv6.icmprouter");
1995                 if (unlikely(!st)) {
1996                     st = rrdset_create("ipv6", "icmprouter", NULL, "icmp", NULL, "IPv6 Router Messages", "messages/s", 10400, update_every, RRDSET_TYPE_LINE);
1997
1998                     rrddim_add(st, "InSolicits", NULL, 1, 1, RRDDIM_INCREMENTAL);
1999                     rrddim_add(st, "OutSolicits", NULL, -1, 1, RRDDIM_INCREMENTAL);
2000                     rrddim_add(st, "InAdvertisements", NULL, 1, 1, RRDDIM_INCREMENTAL);
2001                     rrddim_add(st, "OutAdvertisements", NULL, -1, 1, RRDDIM_INCREMENTAL);
2002                 } else
2003                     rrdset_next(st);
2004
2005                 rrddim_set(st, "InSolicits", icmp6stat.icp6s_inhist[ND_ROUTER_SOLICIT]);
2006                 rrddim_set(st, "OutSolicits", icmp6stat.icp6s_outhist[ND_ROUTER_SOLICIT]);
2007                 rrddim_set(st, "InAdvertisements", icmp6stat.icp6s_inhist[ND_ROUTER_ADVERT]);
2008                 rrddim_set(st, "OutAdvertisements", icmp6stat.icp6s_outhist[ND_ROUTER_ADVERT]);
2009                 rrdset_done(st);
2010             }
2011
2012             // --------------------------------------------------------------------
2013
2014             if (do_icmp6_neighbor == CONFIG_ONDEMAND_YES || (do_icmp6_neighbor == CONFIG_ONDEMAND_ONDEMAND && (
2015                                                                     icmp6stat.icp6s_inhist[ND_NEIGHBOR_SOLICIT] ||
2016                                                                     icmp6stat.icp6s_outhist[ND_NEIGHBOR_SOLICIT] ||
2017                                                                     icmp6stat.icp6s_inhist[ND_NEIGHBOR_ADVERT] ||
2018                                                                     icmp6stat.icp6s_outhist[ND_NEIGHBOR_ADVERT]))) {
2019                 do_icmp6_neighbor = CONFIG_ONDEMAND_YES;
2020                 st = rrdset_find("ipv6.icmpneighbor");
2021                 if (unlikely(!st)) {
2022                     st = rrdset_create("ipv6", "icmpneighbor", NULL, "icmp", NULL, "IPv6 Neighbor Messages", "messages/s", 10500, update_every, RRDSET_TYPE_LINE);
2023
2024                     rrddim_add(st, "InSolicits", NULL, 1, 1, RRDDIM_INCREMENTAL);
2025                     rrddim_add(st, "OutSolicits", NULL, -1, 1, RRDDIM_INCREMENTAL);
2026                     rrddim_add(st, "InAdvertisements", NULL, 1, 1, RRDDIM_INCREMENTAL);
2027                     rrddim_add(st, "OutAdvertisements", NULL, -1, 1, RRDDIM_INCREMENTAL);
2028                 } else
2029                     rrdset_next(st);
2030
2031                 rrddim_set(st, "InSolicits", icmp6stat.icp6s_inhist[ND_NEIGHBOR_SOLICIT]);
2032                 rrddim_set(st, "OutSolicits", icmp6stat.icp6s_outhist[ND_NEIGHBOR_SOLICIT]);
2033                 rrddim_set(st, "InAdvertisements", icmp6stat.icp6s_inhist[ND_NEIGHBOR_ADVERT]);
2034                 rrddim_set(st, "OutAdvertisements", icmp6stat.icp6s_outhist[ND_NEIGHBOR_ADVERT]);
2035                 rrdset_done(st);
2036             }
2037
2038             // --------------------------------------------------------------------
2039
2040             if (do_icmp6_types == CONFIG_ONDEMAND_YES || (do_icmp6_types == CONFIG_ONDEMAND_ONDEMAND && (
2041                                                                     icmp6stat.icp6s_inhist[1] ||
2042                                                                     icmp6stat.icp6s_inhist[128] ||
2043                                                                     icmp6stat.icp6s_inhist[129] ||
2044                                                                     icmp6stat.icp6s_inhist[136] ||
2045                                                                     icmp6stat.icp6s_outhist[1] ||
2046                                                                     icmp6stat.icp6s_outhist[128] ||
2047                                                                     icmp6stat.icp6s_outhist[129] ||
2048                                                                     icmp6stat.icp6s_outhist[133] ||
2049                                                                     icmp6stat.icp6s_outhist[135] ||
2050                                                                     icmp6stat.icp6s_outhist[136]))) {
2051                 do_icmp6_types = CONFIG_ONDEMAND_YES;
2052                 st = rrdset_find("ipv6.icmptypes");
2053                 if (unlikely(!st)) {
2054                     st = rrdset_create("ipv6", "icmptypes", NULL, "icmp", NULL, "IPv6 ICMP Types",
2055                                        "messages/s", 10700, update_every, RRDSET_TYPE_LINE);
2056
2057                     rrddim_add(st, "InType1", NULL, 1, 1, RRDDIM_INCREMENTAL);
2058                     rrddim_add(st, "InType128", NULL, 1, 1, RRDDIM_INCREMENTAL);
2059                     rrddim_add(st, "InType129", NULL, 1, 1, RRDDIM_INCREMENTAL);
2060                     rrddim_add(st, "InType136", NULL, 1, 1, RRDDIM_INCREMENTAL);
2061                     rrddim_add(st, "OutType1", NULL, -1, 1, RRDDIM_INCREMENTAL);
2062                     rrddim_add(st, "OutType128", NULL, -1, 1, RRDDIM_INCREMENTAL);
2063                     rrddim_add(st, "OutType129", NULL, -1, 1, RRDDIM_INCREMENTAL);
2064                     rrddim_add(st, "OutType133", NULL, -1, 1, RRDDIM_INCREMENTAL);
2065                     rrddim_add(st, "OutType135", NULL, -1, 1, RRDDIM_INCREMENTAL);
2066                     rrddim_add(st, "OutType143", NULL, -1, 1, RRDDIM_INCREMENTAL);
2067                 } else
2068                     rrdset_next(st);
2069
2070                 rrddim_set(st, "InType1", icmp6stat.icp6s_inhist[1]);
2071                 rrddim_set(st, "InType128", icmp6stat.icp6s_inhist[128]);
2072                 rrddim_set(st, "InType129", icmp6stat.icp6s_inhist[129]);
2073                 rrddim_set(st, "InType136", icmp6stat.icp6s_inhist[136]);
2074                 rrddim_set(st, "OutType1", icmp6stat.icp6s_outhist[1]);
2075                 rrddim_set(st, "OutType128", icmp6stat.icp6s_outhist[128]);
2076                 rrddim_set(st, "OutType129", icmp6stat.icp6s_outhist[129]);
2077                 rrddim_set(st, "OutType133", icmp6stat.icp6s_outhist[133]);
2078                 rrddim_set(st, "OutType135", icmp6stat.icp6s_outhist[135]);
2079                 rrddim_set(st, "OutType143", icmp6stat.icp6s_outhist[143]);
2080                 rrdset_done(st);
2081             }
2082         }
2083     }
2084
2085     return 0;
2086 }