src/freebsd_sysctl.c

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