src/freebsd_sysctl.c

   1 #include "common.h"
   2
   3 // NEEDED BY: struct vmtotal, struct vmmeter
   4 #include <sys/vmmeter.h>
   5 // NEEDED BY: struct devstat
   6 #include <sys/devicestat.h>
   7 // NEEDED BY: struct xswdev
   8 #include <vm/vm_param.h>
   9 // NEEDED BY: struct semid_kernel, struct shmid_kernel, struct msqid_kernel
  10 #define _KERNEL
  11 #include <sys/sem.h>
  12 #include <sys/shm.h>
  13 #include <sys/msg.h>
  14 #undef _KERNEL
  15 // NEEDED BY: struct sysctl_netisr_workstream, struct sysctl_netisr_work
  16 #include <net/netisr.h>
  17 // NEEDED BY: struct ifaddrs, getifaddrs()
  18 #define _IFI_OQDROPS // It is for FreeNAS only. Most probably in future releases of FreeNAS it will be removed
  19 #include <net/if.h>
  20 #include <ifaddrs.h>
  21 // NEEDED BY do_tcp...
  22 #include <netinet/tcp_var.h>
  23
  24 // NEEDED BY: do_disk_io
  25 #define RRD_TYPE_DISK "disk"
  26
  27 // FreeBSD calculates load averages once every 5 seconds
  28 #define MIN_LOADAVG_UPDATE_EVERY 5
  29
  30 // NEEDED BY: do_bandwidth
  31 #define IFA_DATA(s) (((struct if_data *)ifa->ifa_data)->ifi_ ## s)
  32
  33 int do_freebsd_sysctl(int update_every, usec_t dt) {
  34     (void)dt;
  35
  36     static int do_cpu = -1, do_cpu_cores = -1, do_interrupts = -1, do_context = -1, do_forks = -1, do_processes = -1,
  37         do_loadavg = -1, do_all_processes = -1, do_disk_io = -1, do_swap = -1, do_ram = -1, do_swapio = -1,
  38         do_pgfaults = -1, do_committed = -1, do_ipc_semaphores = -1, do_ipc_shared_mem = -1, do_ipc_msg_queues = -1,
  39         do_dev_intr = -1, do_soft_intr = -1, do_netisr = -1, do_netisr_per_core = -1, do_bandwidth = -1,
  40         do_tcp_sockets = -1, do_tcp_packets = -1, do_tcp_errors = -1, do_tcp_handshake = -1,
  41         do_ecn = -1, do_tcpext_syscookies = -1, do_tcpext_ofo = -1, do_tcpext_connaborts = -1;
  42
  43     if (unlikely(do_cpu == -1)) {
  44         do_cpu                  = config_get_boolean("plugin:freebsd:sysctl", "cpu utilization", 1);
  45         do_cpu_cores            = config_get_boolean("plugin:freebsd:sysctl", "per cpu core utilization", 1);
  46         do_interrupts           = config_get_boolean("plugin:freebsd:sysctl", "cpu interrupts", 1);
  47         do_dev_intr             = config_get_boolean("plugin:freebsd:sysctl", "device interrupts", 1);
  48         do_soft_intr            = config_get_boolean("plugin:freebsd:sysctl", "software interrupts", 1);
  49         do_context              = config_get_boolean("plugin:freebsd:sysctl", "context switches", 1);
  50         do_forks                = config_get_boolean("plugin:freebsd:sysctl", "processes started", 1);
  51         do_processes            = config_get_boolean("plugin:freebsd:sysctl", "processes running", 1);
  52         do_loadavg              = config_get_boolean("plugin:freebsd:sysctl", "enable load average", 1);
  53         do_all_processes        = config_get_boolean("plugin:freebsd:sysctl", "enable total processes", 1);
  54         do_disk_io              = config_get_boolean("plugin:freebsd:sysctl", "stats for all disks", 1);
  55         do_swap                 = config_get_boolean("plugin:freebsd:sysctl", "system swap", 1);
  56         do_ram                  = config_get_boolean("plugin:freebsd:sysctl", "system ram", 1);
  57         do_swapio               = config_get_boolean("plugin:freebsd:sysctl", "swap i/o", 1);
  58         do_pgfaults             = config_get_boolean("plugin:freebsd:sysctl", "memory page faults", 1);
  59         do_committed            = config_get_boolean("plugin:freebsd:sysctl", "committed memory", 1);
  60         do_ipc_semaphores       = config_get_boolean("plugin:freebsd:sysctl", "ipc semaphores", 1);
  61         do_ipc_shared_mem       = config_get_boolean("plugin:freebsd:sysctl", "ipc shared memory", 1);
  62         do_ipc_msg_queues       = config_get_boolean("plugin:freebsd:sysctl", "ipc message queues", 1);
  63         do_netisr               = config_get_boolean("plugin:freebsd:sysctl", "netisr", 1);
  64         do_netisr_per_core      = config_get_boolean("plugin:freebsd:sysctl", "netisr per core", 1);
  65         do_bandwidth            = config_get_boolean("plugin:freebsd:sysctl", "bandwidth", 1);
  66         do_tcp_sockets          = config_get_boolean("plugin:freebsd:sysctl", "ipv4 TCP connections", 1);
  67         do_tcp_packets          = config_get_boolean("plugin:freebsd:sysctl", "ipv4 TCP packets", 1);
  68         do_tcp_errors           = config_get_boolean("plugin:freebsd:sysctl", "ipv4 TCP errors", 1);
  69         do_tcp_handshake        = config_get_boolean("plugin:freebsd:sysctl", "ipv4 TCP handshake issues", 1);
  70         do_ecn                  = config_get_boolean_ondemand("plugin:freebsd:sysctl", "ECN packets", CONFIG_ONDEMAND_ONDEMAND);
  71         do_tcpext_syscookies    = config_get_boolean_ondemand("plugin:freebsd:sysctl", "TCP SYN cookies", CONFIG_ONDEMAND_ONDEMAND);
  72         do_tcpext_ofo           = config_get_boolean_ondemand("plugin:freebsd:sysctl", "TCP out-of-order queue", CONFIG_ONDEMAND_ONDEMAND);
  73         do_tcpext_connaborts    = config_get_boolean_ondemand("plugin:freebsd:sysctl", "TCP connection aborts", CONFIG_ONDEMAND_ONDEMAND);
  74     }
  75
  76     RRDSET *st;
  77     RRDDIM *rd;
  78
  79     int system_pagesize = getpagesize(); // wouldn't it be better to get value directly from hw.pagesize?
  80     int i, n;
  81     void *p;
  82     int common_error = 0;
  83     size_t size;
  84
  85     // NEEDED BY: do_loadavg
  86     static usec_t last_loadavg_usec = 0;
  87     struct loadavg sysload;
  88
  89     // NEEDED BY: do_cpu, do_cpu_cores
  90     long cp_time[CPUSTATES];
  91
  92     // NEEDED BY: du_cpu_cores, do_netisr, do_netisr_per_core
  93     int ncpus;
  94
  95     // NEEDED BY: do_cpu_cores
  96     static long *pcpu_cp_time = NULL;
  97     char cpuid[8]; // no more than 4 digits expected
  98
  99     // NEEDED BY: do_all_processes, do_processes
 100     struct vmtotal vmtotal_data;
 101
 102     // NEEDED BY: do_context, do_forks
 103     u_int u_int_data;
 104
 105     // NEEDED BY: do_interrupts
 106     size_t intrcnt_size;
 107     unsigned long nintr = 0;
 108     static unsigned long *intrcnt = NULL;
 109     static char *intrnames = NULL;
 110     unsigned long long totalintr = 0;
 111
 112     // NEEDED BY: do_disk_io
 113     #define BINTIME_SCALE 5.42101086242752217003726400434970855712890625e-17 // this is 1000/2^64
 114     int numdevs;
 115     static void *devstat_data = NULL;
 116     struct devstat *dstat;
 117     struct cur_dstat {
 118         collected_number duration_read_ms;
 119         collected_number duration_write_ms;
 120         collected_number busy_time_ms;
 121     } cur_dstat;
 122     struct prev_dstat {
 123         collected_number bytes_read;
 124         collected_number bytes_write;
 125         collected_number operations_read;
 126         collected_number operations_write;
 127         collected_number duration_read_ms;
 128         collected_number duration_write_ms;
 129         collected_number busy_time_ms;
 130     } prev_dstat;
 131
 132     // NEEDED BY: do_swap
 133     size_t mibsize;
 134     int mib[3]; // CTL_MAXNAME = 24 maximum mib components (sysctl.h)
 135     struct xswdev xsw;
 136     struct total_xsw {
 137         collected_number bytes_used;
 138         collected_number bytes_total;
 139     } total_xsw = {0, 0};
 140
 141     // NEEDED BY: do_swapio, do_ram
 142     struct vmmeter vmmeter_data;
 143
 144     // NEEDED BY: do_ram
 145     int vfs_bufspace_count;
 146
 147     // NEEDED BY: do_ipc_semaphores
 148     struct ipc_sem {
 149         int semmni;
 150         collected_number sets;
 151         collected_number semaphores;
 152     } ipc_sem = {0, 0, 0};
 153     static struct semid_kernel *ipc_sem_data = NULL;
 154
 155     // NEEDED BY: do_ipc_shared_mem
 156     struct ipc_shm {
 157         u_long shmmni;
 158         collected_number segs;
 159         collected_number segsize;
 160     } ipc_shm = {0, 0, 0};
 161     static struct shmid_kernel *ipc_shm_data = NULL;
 162
 163     // NEEDED BY: do_ipc_msg_queues
 164     struct ipc_msq {
 165         int msgmni;
 166         collected_number queues;
 167         collected_number messages;
 168         collected_number usedsize;
 169         collected_number allocsize;
 170     } ipc_msq = {0, 0, 0, 0, 0};
 171     static struct msqid_kernel *ipc_msq_data = NULL;
 172
 173     // NEEDED BY: do_netisr, do_netisr_per_core
 174     size_t netisr_workstream_size;
 175     size_t netisr_work_size;
 176     unsigned long num_netisr_workstreams = 0, num_netisr_works = 0;
 177     static struct sysctl_netisr_workstream *netisr_workstream = NULL;
 178     static struct sysctl_netisr_work *netisr_work = NULL;
 179     static struct netisr_stats {
 180         collected_number dispatched;
 181         collected_number hybrid_dispatched;
 182         collected_number qdrops;
 183         collected_number queued;
 184     } *netisr_stats = NULL;
 185     char netstat_cpuid[21]; // no more than 4 digits expected
 186
 187     // NEEDED BY: do_bandwidth
 188     struct ifaddrs *ifa, *ifap;
 189     struct iftot {
 190         u_long  ift_ibytes;
 191         u_long  ift_obytes;
 192     } iftot = {0, 0};
 193
 194     // NEEDED BY: do_tcp...
 195     struct tcpstat tcpstat;
 196     uint64_t tcps_states[TCP_NSTATES];
 197
 198     // --------------------------------------------------------------------
 199
 200     if (last_loadavg_usec <= dt) {
 201         if (likely(do_loadavg)) {
 202             if (unlikely(GETSYSCTL("vm.loadavg", sysload))) {
 203                 do_loadavg = 0;
 204                 error("DISABLED: system.load");
 205             } else {
 206
 207                 st = rrdset_find_bytype("system", "load");
 208                 if (unlikely(!st)) {
 209                     st = rrdset_create("system", "load", NULL, "load", NULL, "System Load Average", "load", 100, (update_every < MIN_LOADAVG_UPDATE_EVERY) ? MIN_LOADAVG_UPDATE_EVERY : update_every, RRDSET_TYPE_LINE);
 210                     rrddim_add(st, "load1", NULL, 1, 1000, RRDDIM_ABSOLUTE);
 211                     rrddim_add(st, "load5", NULL, 1, 1000, RRDDIM_ABSOLUTE);
 212                     rrddim_add(st, "load15", NULL, 1, 1000, RRDDIM_ABSOLUTE);
 213                 }
 214                 else rrdset_next(st);
 215
 216                 rrddim_set(st, "load1", (collected_number) ((double)sysload.ldavg[0] / sysload.fscale * 1000));
 217                 rrddim_set(st, "load5", (collected_number) ((double)sysload.ldavg[1] / sysload.fscale * 1000));
 218                 rrddim_set(st, "load15", (collected_number) ((double)sysload.ldavg[2] / sysload.fscale * 1000));
 219                 rrdset_done(st);
 220             }
 221         }
 222
 223         last_loadavg_usec = st->update_every * USEC_PER_SEC;
 224     }
 225     else last_loadavg_usec -= dt;
 226
 227     // --------------------------------------------------------------------
 228
 229     if (likely(do_all_processes | do_processes | do_committed)) {
 230         if (unlikely(GETSYSCTL("vm.vmtotal", vmtotal_data))) {
 231             do_all_processes = 0;
 232             error("DISABLED: system.active_processes");
 233             do_processes = 0;
 234             error("DISABLED: system.processes");
 235             do_committed = 0;
 236             error("DISABLED: mem.committed");
 237         } else {
 238             if (likely(do_all_processes)) {
 239
 240                 st = rrdset_find_bytype("system", "active_processes");
 241                 if (unlikely(!st)) {
 242                     st = rrdset_create("system", "active_processes", NULL, "processes", NULL, "System Active Processes", "processes", 750, update_every, RRDSET_TYPE_LINE);
 243                     rrddim_add(st, "active", NULL, 1, 1, RRDDIM_ABSOLUTE);
 244                 }
 245                 else rrdset_next(st);
 246
 247                 rrddim_set(st, "active", (vmtotal_data.t_rq + vmtotal_data.t_dw + vmtotal_data.t_pw + vmtotal_data.t_sl + vmtotal_data.t_sw));
 248                 rrdset_done(st);
 249             }
 250
 251             // --------------------------------------------------------------------
 252
 253             if (likely(do_processes)) {
 254
 255                 st = rrdset_find_bytype("system", "processes");
 256                 if (unlikely(!st)) {
 257                     st = rrdset_create("system", "processes", NULL, "processes", NULL, "System Processes", "processes", 600, update_every, RRDSET_TYPE_LINE);
 258
 259                     rrddim_add(st, "running", NULL, 1, 1, RRDDIM_ABSOLUTE);
 260                     rrddim_add(st, "blocked", NULL, -1, 1, RRDDIM_ABSOLUTE);
 261                 }
 262                 else rrdset_next(st);
 263
 264                 rrddim_set(st, "running", vmtotal_data.t_rq);
 265                 rrddim_set(st, "blocked", (vmtotal_data.t_dw + vmtotal_data.t_pw));
 266                 rrdset_done(st);
 267             }
 268
 269             // --------------------------------------------------------------------
 270
 271             if (likely(do_committed)) {
 272                 st = rrdset_find("mem.committed");
 273                 if (unlikely(!st)) {
 274                     st = rrdset_create("mem", "committed", NULL, "system", NULL, "Committed (Allocated) Memory", "MB", 5000, update_every, RRDSET_TYPE_AREA);
 275                     st->isdetail = 1;
 276
 277                     rrddim_add(st, "Committed_AS", NULL, system_pagesize, 1024, RRDDIM_ABSOLUTE);
 278                 }
 279                 else rrdset_next(st);
 280
 281                 rrddim_set(st, "Committed_AS", vmtotal_data.t_rm);
 282                 rrdset_done(st);
 283             }
 284         }
 285     }
 286
 287     // --------------------------------------------------------------------
 288
 289     if (likely(do_cpu)) {
 290         if (unlikely(CPUSTATES != 5)) {
 291             error("FREEBSD: There are %d CPU states (5 was expected)", CPUSTATES);
 292             do_cpu = 0;
 293             error("DISABLED: system.cpu");
 294         } else {
 295             if (unlikely(GETSYSCTL("kern.cp_time", cp_time))) {
 296                 do_cpu = 0;
 297                 error("DISABLED: system.cpu");
 298             } else {
 299
 300                 st = rrdset_find_bytype("system", "cpu");
 301                 if (unlikely(!st)) {
 302                     st = rrdset_create("system", "cpu", NULL, "cpu", "system.cpu", "Total CPU utilization", "percentage", 100, update_every, RRDSET_TYPE_STACKED);
 303
 304                     rrddim_add(st, "user", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 305                     rrddim_add(st, "nice", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 306                     rrddim_add(st, "system", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 307                     rrddim_add(st, "interrupt", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 308                     rrddim_add(st, "idle", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 309                     rrddim_hide(st, "idle");
 310                 }
 311                 else rrdset_next(st);
 312
 313                 rrddim_set(st, "user", cp_time[0]);
 314                 rrddim_set(st, "nice", cp_time[1]);
 315                 rrddim_set(st, "system", cp_time[2]);
 316                 rrddim_set(st, "interrupt", cp_time[3]);
 317                 rrddim_set(st, "idle", cp_time[4]);
 318                 rrdset_done(st);
 319             }
 320         }
 321     }
 322
 323     // --------------------------------------------------------------------
 324
 325     if (likely(do_cpu_cores)) {
 326         if (unlikely(CPUSTATES != 5)) {
 327             error("FREEBSD: There are %d CPU states (5 was expected)", CPUSTATES);
 328             do_cpu_cores = 0;
 329             error("DISABLED: cpu.cpuXX");
 330         } else {
 331             if (unlikely(GETSYSCTL("kern.smp.cpus", ncpus))) {
 332                 do_cpu_cores = 0;
 333                 error("DISABLED: cpu.cpuXX");
 334             } else {
 335                 pcpu_cp_time = reallocz(pcpu_cp_time, sizeof(cp_time) * ncpus);
 336
 337                 for (i = 0; i < ncpus; i++) {
 338                     if (unlikely(getsysctl("kern.cp_times", pcpu_cp_time, sizeof(cp_time) * ncpus))) {
 339                         do_cpu_cores = 0;
 340                         error("DISABLED: cpu.cpuXX");
 341                         break;
 342                     }
 343                     if (unlikely(ncpus > 9999)) {
 344                         error("FREEBSD: There are more than 4 digits in cpu cores number");
 345                         do_cpu_cores = 0;
 346                         error("DISABLED: cpu.cpuXX");
 347                         break;
 348                     }
 349                     snprintfz(cpuid, 8, "cpu%d", i);
 350
 351                     st = rrdset_find_bytype("cpu", cpuid);
 352                     if (unlikely(!st)) {
 353                         st = rrdset_create("cpu", cpuid, NULL, "utilization", "cpu.cpu", "Core utilization", "percentage", 1000, update_every, RRDSET_TYPE_STACKED);
 354
 355                         rrddim_add(st, "user", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 356                         rrddim_add(st, "nice", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 357                         rrddim_add(st, "system", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 358                         rrddim_add(st, "interrupt", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 359                         rrddim_add(st, "idle", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 360                         rrddim_hide(st, "idle");
 361                     }
 362                     else rrdset_next(st);
 363
 364                     rrddim_set(st, "user", pcpu_cp_time[i * 5 + 0]);
 365                     rrddim_set(st, "nice", pcpu_cp_time[i * 5 + 1]);
 366                     rrddim_set(st, "system", pcpu_cp_time[i * 5 + 2]);
 367                     rrddim_set(st, "interrupt", pcpu_cp_time[i * 5 + 3]);
 368                     rrddim_set(st, "idle", pcpu_cp_time[i * 5 + 4]);
 369                     rrdset_done(st);
 370                 }
 371             }
 372         }
 373     }
 374
 375     // --------------------------------------------------------------------
 376
 377     if (likely(do_interrupts)) {
 378         if (unlikely(sysctlbyname("hw.intrcnt", NULL, &intrcnt_size, NULL, 0) == -1)) {
 379             error("FREEBSD: sysctl(hw.intrcnt...) failed: %s", strerror(errno));
 380             do_interrupts = 0;
 381             error("DISABLED: system.intr");
 382         } else {
 383             nintr = intrcnt_size / sizeof(u_long);
 384             intrcnt = reallocz(intrcnt, nintr * sizeof(u_long));
 385             if (unlikely(getsysctl("hw.intrcnt", intrcnt, nintr * sizeof(u_long)))){
 386                 do_interrupts = 0;
 387                 error("DISABLED: system.intr");
 388             } else {
 389                 for (i = 0; i < nintr; i++)
 390                     totalintr += intrcnt[i];
 391
 392                 st = rrdset_find_bytype("system", "intr");
 393                 if (unlikely(!st)) {
 394                     st = rrdset_create("system", "intr", NULL, "interrupts", NULL, "Total Hardware Interrupts", "interrupts/s", 900, update_every, RRDSET_TYPE_LINE);
 395                     st->isdetail = 1;
 396
 397                     rrddim_add(st, "interrupts", NULL, 1, 1, RRDDIM_INCREMENTAL);
 398                 }
 399                 else rrdset_next(st);
 400
 401                 rrddim_set(st, "interrupts", totalintr);
 402                 rrdset_done(st);
 403
 404                 // --------------------------------------------------------------------
 405
 406                 size = nintr * (MAXCOMLEN +1);
 407                 intrnames = reallocz(intrnames, size);
 408                 if (unlikely(getsysctl("hw.intrnames", intrnames, size))) {
 409                     do_interrupts = 0;
 410                     error("DISABLED: system.intr");
 411                 } else {
 412                     st = rrdset_find_bytype("system", "interrupts");
 413                     if (unlikely(!st))
 414                         st = rrdset_create("system", "interrupts", NULL, "interrupts", NULL, "System interrupts", "interrupts/s",
 415                                            1000, update_every, RRDSET_TYPE_STACKED);
 416                     else
 417                         rrdset_next(st);
 418
 419                     for (i = 0; i < nintr; i++) {
 420                         p = intrnames + i * (MAXCOMLEN + 1);
 421                         if (unlikely((intrcnt[i] != 0) && (*(char*)p != 0))) {
 422                             rd = rrddim_find(st, p);
 423                             if (unlikely(!rd))
 424                                 rd = rrddim_add(st, p, NULL, 1, 1, RRDDIM_INCREMENTAL);
 425                             rrddim_set_by_pointer(st, rd, intrcnt[i]);
 426                         }
 427                     }
 428                     rrdset_done(st);
 429                 }
 430             }
 431         }
 432     }
 433
 434     // --------------------------------------------------------------------
 435
 436     if (likely(do_dev_intr)) {
 437         if (unlikely(GETSYSCTL("vm.stats.sys.v_intr", u_int_data))) {
 438             do_dev_intr = 0;
 439             error("DISABLED: system.dev_intr");
 440         } else {
 441
 442             st = rrdset_find_bytype("system", "dev_intr");
 443             if (unlikely(!st)) {
 444                 st = rrdset_create("system", "dev_intr", NULL, "interrupts", NULL, "Device Interrupts", "interrupts/s", 1000, update_every, RRDSET_TYPE_LINE);
 445
 446                 rrddim_add(st, "interrupts", NULL, 1, 1, RRDDIM_INCREMENTAL);
 447             }
 448             else rrdset_next(st);
 449
 450             rrddim_set(st, "interrupts", u_int_data);
 451             rrdset_done(st);
 452         }
 453     }
 454
 455     // --------------------------------------------------------------------
 456
 457     if (likely(do_soft_intr)) {
 458         if (unlikely(GETSYSCTL("vm.stats.sys.v_soft", u_int_data))) {
 459             do_soft_intr = 0;
 460             error("DISABLED: system.dev_intr");
 461         } else {
 462
 463             st = rrdset_find_bytype("system", "soft_intr");
 464             if (unlikely(!st)) {
 465                 st = rrdset_create("system", "soft_intr", NULL, "interrupts", NULL, "Software Interrupts", "interrupts/s", 1100, update_every, RRDSET_TYPE_LINE);
 466
 467                 rrddim_add(st, "interrupts", NULL, 1, 1, RRDDIM_INCREMENTAL);
 468             }
 469             else rrdset_next(st);
 470
 471             rrddim_set(st, "interrupts", u_int_data);
 472             rrdset_done(st);
 473         }
 474     }
 475
 476     // --------------------------------------------------------------------
 477
 478     if (likely(do_context)) {
 479         if (unlikely(GETSYSCTL("vm.stats.sys.v_swtch", u_int_data))) {
 480             do_context = 0;
 481             error("DISABLED: system.ctxt");
 482         } else {
 483
 484             st = rrdset_find_bytype("system", "ctxt");
 485             if (unlikely(!st)) {
 486                 st = rrdset_create("system", "ctxt", NULL, "processes", NULL, "CPU Context Switches", "context switches/s", 800, update_every, RRDSET_TYPE_LINE);
 487
 488                 rrddim_add(st, "switches", NULL, 1, 1, RRDDIM_INCREMENTAL);
 489             }
 490             else rrdset_next(st);
 491
 492             rrddim_set(st, "switches", u_int_data);
 493             rrdset_done(st);
 494         }
 495     }
 496
 497     // --------------------------------------------------------------------
 498
 499     if (likely(do_forks)) {
 500         if (unlikely(GETSYSCTL("vm.stats.vm.v_forks", u_int_data))) {
 501             do_forks = 0;
 502             error("DISABLED: system.forks");
 503         } else {
 504
 505             st = rrdset_find_bytype("system", "forks");
 506             if (unlikely(!st)) {
 507                 st = rrdset_create("system", "forks", NULL, "processes", NULL, "Started Processes", "processes/s", 700, update_every, RRDSET_TYPE_LINE);
 508                 st->isdetail = 1;
 509
 510                 rrddim_add(st, "started", NULL, 1, 1, RRDDIM_INCREMENTAL);
 511             }
 512             else rrdset_next(st);
 513
 514             rrddim_set(st, "started", u_int_data);
 515             rrdset_done(st);
 516         }
 517     }
 518
 519     // --------------------------------------------------------------------
 520
 521     if (likely(do_disk_io)) {
 522         if (unlikely(GETSYSCTL("kern.devstat.numdevs", numdevs))) {
 523             do_disk_io = 0;
 524             error("DISABLED: disk.io");
 525         } else {
 526             devstat_data = reallocz(devstat_data, sizeof(long) + sizeof(struct devstat) * numdevs); // there is generation number before devstat structures
 527             if (unlikely(getsysctl("kern.devstat.all", devstat_data, sizeof(long) + sizeof(struct devstat) * numdevs))) {
 528                 do_disk_io = 0;
 529                 error("DISABLED: disk.io");
 530             } else {
 531                 dstat = devstat_data + sizeof(long); // skip generation number
 532                 collected_number total_disk_reads = 0;
 533                 collected_number total_disk_writes = 0;
 534
 535                 for (i = 0; i < numdevs; i++) {
 536                     if (((dstat[i].device_type & DEVSTAT_TYPE_MASK) == DEVSTAT_TYPE_DIRECT) || ((dstat[i].device_type & DEVSTAT_TYPE_MASK) == DEVSTAT_TYPE_STORARRAY)) {
 537
 538                         // --------------------------------------------------------------------
 539
 540                         st = rrdset_find_bytype(RRD_TYPE_DISK, dstat[i].device_name);
 541                         if (unlikely(!st)) {
 542                             st = rrdset_create(RRD_TYPE_DISK, dstat[i].device_name, NULL, dstat[i].device_name, "disk.io", "Disk I/O Bandwidth", "kilobytes/s", 2000, update_every, RRDSET_TYPE_AREA);
 543
 544                             rrddim_add(st, "reads", NULL, 1, 1024, RRDDIM_INCREMENTAL);
 545                             rrddim_add(st, "writes", NULL, -1, 1024, RRDDIM_INCREMENTAL);
 546                         }
 547                         else rrdset_next(st);
 548
 549                         total_disk_reads += dstat[i].bytes[DEVSTAT_READ];
 550                         total_disk_writes += dstat[i].bytes[DEVSTAT_WRITE];
 551                         prev_dstat.bytes_read = rrddim_set(st, "reads", dstat[i].bytes[DEVSTAT_READ]);
 552                         prev_dstat.bytes_write = rrddim_set(st, "writes", dstat[i].bytes[DEVSTAT_WRITE]);
 553                         rrdset_done(st);
 554
 555                         // --------------------------------------------------------------------
 556
 557                         st = rrdset_find_bytype("disk_ops", dstat[i].device_name);
 558                         if (unlikely(!st)) {
 559                             st = rrdset_create("disk_ops", dstat[i].device_name, NULL, dstat[i].device_name, "disk.ops", "Disk Completed I/O Operations", "operations/s", 2001, update_every, RRDSET_TYPE_LINE);
 560                             st->isdetail = 1;
 561
 562                             rrddim_add(st, "reads", NULL, 1, 1, RRDDIM_INCREMENTAL);
 563                             rrddim_add(st, "writes", NULL, -1, 1, RRDDIM_INCREMENTAL);
 564                         }
 565                         else rrdset_next(st);
 566
 567                         prev_dstat.operations_read = rrddim_set(st, "reads", dstat[i].operations[DEVSTAT_READ]);
 568                         prev_dstat.operations_write = rrddim_set(st, "writes", dstat[i].operations[DEVSTAT_WRITE]);
 569                         rrdset_done(st);
 570
 571                         // --------------------------------------------------------------------
 572
 573                         st = rrdset_find_bytype("disk_qops", dstat[i].device_name);
 574                         if (unlikely(!st)) {
 575                             st = rrdset_create("disk_qops", dstat[i].device_name, NULL, dstat[i].device_name, "disk.qops", "Disk Current I/O Operations", "operations", 2002, update_every, RRDSET_TYPE_LINE);
 576                             st->isdetail = 1;
 577
 578                             rrddim_add(st, "operations", NULL, 1, 1, RRDDIM_ABSOLUTE);
 579                         }
 580                         else rrdset_next(st);
 581
 582                         rrddim_set(st, "operations", dstat[i].start_count - dstat[i].end_count);
 583                         rrdset_done(st);
 584
 585                         // --------------------------------------------------------------------
 586
 587                         st = rrdset_find_bytype("disk_util", dstat[i].device_name);
 588                         if (unlikely(!st)) {
 589                             st = rrdset_create("disk_util", dstat[i].device_name, NULL, dstat[i].device_name, "disk.util", "Disk Utilization Time", "% of time working", 2004, update_every, RRDSET_TYPE_AREA);
 590                             st->isdetail = 1;
 591
 592                             rrddim_add(st, "utilization", NULL, 1, 10, RRDDIM_INCREMENTAL);
 593                         }
 594                         else rrdset_next(st);
 595
 596                         cur_dstat.busy_time_ms = dstat[i].busy_time.sec * 1000 + dstat[i].busy_time.frac * BINTIME_SCALE;
 597                         prev_dstat.busy_time_ms = rrddim_set(st, "utilization", cur_dstat.busy_time_ms);
 598                         rrdset_done(st);
 599
 600                         // --------------------------------------------------------------------
 601
 602                         st = rrdset_find_bytype("disk_iotime", dstat[i].device_name);
 603                         if (unlikely(!st)) {
 604                             st = rrdset_create("disk_iotime", dstat[i].device_name, NULL, dstat[i].device_name, "disk.iotime", "Disk Total I/O Time", "milliseconds/s", 2022, update_every, RRDSET_TYPE_LINE);
 605                             st->isdetail = 1;
 606
 607                             rrddim_add(st, "reads", NULL, 1, 1, RRDDIM_INCREMENTAL);
 608                             rrddim_add(st, "writes", NULL, -1, 1, RRDDIM_INCREMENTAL);
 609                         }
 610                         else rrdset_next(st);
 611
 612                         cur_dstat.duration_read_ms = dstat[i].duration[DEVSTAT_READ].sec * 1000 + dstat[i].duration[DEVSTAT_READ].frac * BINTIME_SCALE;
 613                         cur_dstat.duration_write_ms = dstat[i].duration[DEVSTAT_WRITE].sec * 1000 + dstat[i].duration[DEVSTAT_READ].frac * BINTIME_SCALE;
 614                         prev_dstat.duration_read_ms = rrddim_set(st, "reads", cur_dstat.duration_read_ms);
 615                         prev_dstat.duration_write_ms = rrddim_set(st, "writes", cur_dstat.duration_write_ms);
 616                         rrdset_done(st);
 617
 618                         // --------------------------------------------------------------------
 619                         // calculate differential charts
 620                         // only if this is not the first time we run
 621
 622                         if (likely(dt)) {
 623
 624                             // --------------------------------------------------------------------
 625
 626                             st = rrdset_find_bytype("disk_await", dstat[i].device_name);
 627                             if (unlikely(!st)) {
 628                                 st = rrdset_create("disk_await", dstat[i].device_name, NULL, dstat[i].device_name, "disk.await", "Average Completed I/O Operation Time", "ms per operation", 2005, update_every, RRDSET_TYPE_LINE);
 629                                 st->isdetail = 1;
 630
 631                                 rrddim_add(st, "reads", NULL, 1, 1, RRDDIM_ABSOLUTE);
 632                                 rrddim_add(st, "writes", NULL, -1, 1, RRDDIM_ABSOLUTE);
 633                             }
 634                             else rrdset_next(st);
 635
 636                             rrddim_set(st, "reads", (dstat[i].operations[DEVSTAT_READ] - prev_dstat.operations_read) ?
 637                                 (cur_dstat.duration_read_ms - prev_dstat.duration_read_ms) / (dstat[i].operations[DEVSTAT_READ] - prev_dstat.operations_read) : 0);
 638                             rrddim_set(st, "writes", (dstat[i].operations[DEVSTAT_WRITE] - prev_dstat.operations_write) ?
 639                                 (cur_dstat.duration_write_ms - prev_dstat.duration_write_ms) / (dstat[i].operations[DEVSTAT_WRITE] - prev_dstat.operations_write) : 0);
 640                             rrdset_done(st);
 641
 642                             // --------------------------------------------------------------------
 643
 644                             st = rrdset_find_bytype("disk_avgsz", dstat[i].device_name);
 645                             if (unlikely(!st)) {
 646                                 st = rrdset_create("disk_avgsz", dstat[i].device_name, NULL, dstat[i].device_name, "disk.avgsz", "Average Completed I/O Operation Bandwidth", "kilobytes per operation", 2006, update_every, RRDSET_TYPE_AREA);
 647                                 st->isdetail = 1;
 648
 649                                 rrddim_add(st, "reads", NULL, 1, 1024, RRDDIM_ABSOLUTE);
 650                                 rrddim_add(st, "writes", NULL, -1, 1024, RRDDIM_ABSOLUTE);
 651                             }
 652                             else rrdset_next(st);
 653
 654                             rrddim_set(st, "reads", (dstat[i].operations[DEVSTAT_READ] - prev_dstat.operations_read) ?
 655                                 (dstat[i].bytes[DEVSTAT_READ] - prev_dstat.bytes_read) / (dstat[i].operations[DEVSTAT_READ] - prev_dstat.operations_read) : 0);
 656                             rrddim_set(st, "writes", (dstat[i].operations[DEVSTAT_WRITE] - prev_dstat.operations_write) ?
 657                                 (dstat[i].bytes[DEVSTAT_WRITE] - prev_dstat.bytes_write) / (dstat[i].operations[DEVSTAT_WRITE] - prev_dstat.operations_write) : 0);
 658                             rrdset_done(st);
 659
 660                             // --------------------------------------------------------------------
 661
 662                             st = rrdset_find_bytype("disk_svctm", dstat[i].device_name);
 663                             if (unlikely(!st)) {
 664                                 st = rrdset_create("disk_svctm", dstat[i].device_name, NULL, dstat[i].device_name, "disk.svctm", "Average Service Time", "ms per operation", 2007, update_every, RRDSET_TYPE_LINE);
 665                                 st->isdetail = 1;
 666
 667                                 rrddim_add(st, "svctm", NULL, 1, 1, RRDDIM_ABSOLUTE);
 668                             }
 669                             else rrdset_next(st);
 670
 671                             rrddim_set(st, "svctm", ((dstat[i].operations[DEVSTAT_READ] - prev_dstat.operations_read) + (dstat[i].operations[DEVSTAT_WRITE] - prev_dstat.operations_write)) ?
 672                                 (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);
 673                             rrdset_done(st);
 674                         }
 675                     }
 676
 677                     // --------------------------------------------------------------------
 678
 679                     st = rrdset_find_bytype("system", "io");
 680                     if (unlikely(!st)) {
 681                         st = rrdset_create("system", "io", NULL, "disk", NULL, "Disk I/O", "kilobytes/s", 150, update_every, RRDSET_TYPE_AREA);
 682                         rrddim_add(st, "in",  NULL,  1, 1024, RRDDIM_INCREMENTAL);
 683                         rrddim_add(st, "out", NULL, -1, 1024, RRDDIM_INCREMENTAL);
 684                     }
 685                     else rrdset_next(st);
 686
 687                     rrddim_set(st, "in", total_disk_reads);
 688                     rrddim_set(st, "out", total_disk_writes);
 689                     rrdset_done(st);
 690                 }
 691             }
 692         }
 693     }
 694
 695     // --------------------------------------------------------------------
 696
 697
 698     if (likely(do_swap)) {
 699         mibsize = sizeof mib / sizeof mib[0];
 700         if (unlikely(sysctlnametomib("vm.swap_info", mib, &mibsize) == -1)) {
 701             error("FREEBSD: sysctl(%s...) failed: %s", "vm.swap_info", strerror(errno));
 702             do_swap = 0;
 703             error("DISABLED: system.swap");
 704         } else {
 705             for (i = 0; ; i++) {
 706                 mib[mibsize] = i;
 707                 size = sizeof(xsw);
 708                 if (unlikely(sysctl(mib, mibsize + 1, &xsw, &size, NULL, 0) == -1 )) {
 709                     if (unlikely(errno != ENOENT)) {
 710                         error("FREEBSD: sysctl(%s...) failed: %s", "vm.swap_info", strerror(errno));
 711                         do_swap = 0;
 712                         error("DISABLED: system.swap");
 713                     } else {
 714                         if (unlikely(size != sizeof(xsw))) {
 715                             error("FREEBSD: sysctl(%s...) expected %lu, got %lu", "vm.swap_info", (unsigned long)sizeof(xsw), (unsigned long)size);
 716                             do_swap = 0;
 717                             error("DISABLED: system.swap");
 718                         } else break;
 719                     }
 720                 }
 721                 total_xsw.bytes_used += xsw.xsw_used;
 722                 total_xsw.bytes_total += xsw.xsw_nblks;
 723             }
 724
 725             if (likely(do_swap)) {
 726                 st = rrdset_find("system.swap");
 727                 if (unlikely(!st)) {
 728                     st = rrdset_create("system", "swap", NULL, "swap", NULL, "System Swap", "MB", 201, update_every, RRDSET_TYPE_STACKED);
 729                     st->isdetail = 1;
 730
 731                     rrddim_add(st, "free",    NULL, system_pagesize, 1048576, RRDDIM_ABSOLUTE);
 732                     rrddim_add(st, "used",    NULL, system_pagesize, 1048576, RRDDIM_ABSOLUTE);
 733                 }
 734                 else rrdset_next(st);
 735
 736                 rrddim_set(st, "used", total_xsw.bytes_used);
 737                 rrddim_set(st, "free", total_xsw.bytes_total - total_xsw.bytes_used);
 738                 rrdset_done(st);
 739             }
 740         }
 741     }
 742
 743     // --------------------------------------------------------------------
 744
 745     if (likely(do_ram)) {
 746         if (unlikely(GETSYSCTL("vm.stats.vm.v_active_count",    vmmeter_data.v_active_count) ||
 747                      GETSYSCTL("vm.stats.vm.v_inactive_count",  vmmeter_data.v_inactive_count) ||
 748                      GETSYSCTL("vm.stats.vm.v_wire_count",      vmmeter_data.v_wire_count) ||
 749                      GETSYSCTL("vm.stats.vm.v_cache_count",     vmmeter_data.v_cache_count) ||
 750                      GETSYSCTL("vfs.bufspace",                  vfs_bufspace_count) ||
 751                      GETSYSCTL("vm.stats.vm.v_free_count",      vmmeter_data.v_free_count))) {
 752             do_ram = 0;
 753             error("DISABLED: system.ram");
 754         } else {
 755             st = rrdset_find("system.ram");
 756             if (unlikely(!st)) {
 757                 st = rrdset_create("system", "ram", NULL, "ram", NULL, "System RAM", "MB", 200, update_every, RRDSET_TYPE_STACKED);
 758
 759                 rrddim_add(st, "active",    NULL, system_pagesize, 1048576, RRDDIM_ABSOLUTE);
 760                 rrddim_add(st, "inactive",  NULL, system_pagesize, 1048576, RRDDIM_ABSOLUTE);
 761                 rrddim_add(st, "wired",     NULL, system_pagesize, 1048576, RRDDIM_ABSOLUTE);
 762                 rrddim_add(st, "cache",     NULL, system_pagesize, 1048576, RRDDIM_ABSOLUTE);
 763                 rrddim_add(st, "buffers",   NULL, 1, 1048576, RRDDIM_ABSOLUTE);
 764                 rrddim_add(st, "free",      NULL, system_pagesize, 1048576, RRDDIM_ABSOLUTE);
 765             }
 766             else rrdset_next(st);
 767
 768             rrddim_set(st, "active",    vmmeter_data.v_active_count);
 769             rrddim_set(st, "inactive",  vmmeter_data.v_inactive_count);
 770             rrddim_set(st, "wired",     vmmeter_data.v_wire_count);
 771             rrddim_set(st, "cache",     vmmeter_data.v_cache_count);
 772             rrddim_set(st, "buffers",   vfs_bufspace_count);
 773             rrddim_set(st, "free",      vmmeter_data.v_free_count);
 774             rrdset_done(st);
 775         }
 776     }
 777
 778     // --------------------------------------------------------------------
 779
 780     if (likely(do_swapio)) {
 781         if (unlikely(GETSYSCTL("vm.stats.vm.v_swappgsin", vmmeter_data.v_swappgsin) || GETSYSCTL("vm.stats.vm.v_swappgsout", vmmeter_data.v_swappgsout))) {
 782             do_swapio = 0;
 783             error("DISABLED: system.swapio");
 784         } else {
 785             st = rrdset_find("system.swapio");
 786             if (unlikely(!st)) {
 787                 st = rrdset_create("system", "swapio", NULL, "swap", NULL, "Swap I/O", "kilobytes/s", 250, update_every, RRDSET_TYPE_AREA);
 788
 789                 rrddim_add(st, "in",  NULL, system_pagesize, 1024, RRDDIM_INCREMENTAL);
 790                 rrddim_add(st, "out", NULL, -system_pagesize, 1024, RRDDIM_INCREMENTAL);
 791             }
 792             else rrdset_next(st);
 793
 794             rrddim_set(st, "in", vmmeter_data.v_swappgsin);
 795             rrddim_set(st, "out", vmmeter_data.v_swappgsout);
 796             rrdset_done(st);
 797         }
 798     }
 799
 800     // --------------------------------------------------------------------
 801
 802     if (likely(do_pgfaults)) {
 803         if (unlikely(GETSYSCTL("vm.stats.vm.v_vm_faults",   vmmeter_data.v_vm_faults) ||
 804                      GETSYSCTL("vm.stats.vm.v_io_faults",   vmmeter_data.v_io_faults) ||
 805                      GETSYSCTL("vm.stats.vm.v_cow_faults",  vmmeter_data.v_cow_faults) ||
 806                      GETSYSCTL("vm.stats.vm.v_cow_optim",   vmmeter_data.v_cow_optim) ||
 807                      GETSYSCTL("vm.stats.vm.v_intrans",     vmmeter_data.v_intrans))) {
 808             do_pgfaults = 0;
 809             error("DISABLED: mem.pgfaults");
 810         } else {
 811             st = rrdset_find("mem.pgfaults");
 812             if (unlikely(!st)) {
 813                 st = rrdset_create("mem", "pgfaults", NULL, "system", NULL, "Memory Page Faults", "page faults/s", 500, update_every, RRDSET_TYPE_LINE);
 814                 st->isdetail = 1;
 815
 816                 rrddim_add(st, "memory", NULL, 1, 1, RRDDIM_INCREMENTAL);
 817                 rrddim_add(st, "io_requiring", NULL, 1, 1, RRDDIM_INCREMENTAL);
 818                 rrddim_add(st, "cow", NULL, 1, 1, RRDDIM_INCREMENTAL);
 819                 rrddim_add(st, "cow_optimized", NULL, 1, 1, RRDDIM_INCREMENTAL);
 820                 rrddim_add(st, "in_transit", NULL, 1, 1, RRDDIM_INCREMENTAL);
 821             }
 822             else rrdset_next(st);
 823
 824             rrddim_set(st, "memory", vmmeter_data.v_vm_faults);
 825             rrddim_set(st, "io_requiring", vmmeter_data.v_io_faults);
 826             rrddim_set(st, "cow", vmmeter_data.v_cow_faults);
 827             rrddim_set(st, "cow_optimized", vmmeter_data.v_cow_optim);
 828             rrddim_set(st, "in_transit", vmmeter_data.v_intrans);
 829             rrdset_done(st);
 830         }
 831     }
 832
 833     // --------------------------------------------------------------------
 834
 835     if (likely(do_ipc_semaphores)) {
 836         if (unlikely(GETSYSCTL("kern.ipc.semmni", ipc_sem.semmni))) {
 837             do_ipc_semaphores = 0;
 838             error("DISABLED: system.ipc_semaphores");
 839             error("DISABLED: system.ipc_semaphore_arrays");
 840         } else {
 841             ipc_sem_data = reallocz(ipc_sem_data, sizeof(struct semid_kernel) * ipc_sem.semmni);
 842             if (unlikely(getsysctl("kern.ipc.sema", ipc_sem_data, sizeof(struct semid_kernel) * ipc_sem.semmni))) {
 843                 do_ipc_semaphores = 0;
 844                 error("DISABLED: system.ipc_semaphores");
 845                 error("DISABLED: system.ipc_semaphore_arrays");
 846             } else {
 847                 for (i = 0; i < ipc_sem.semmni; i++) {
 848                     if (unlikely(ipc_sem_data[i].u.sem_perm.mode & SEM_ALLOC)) {
 849                         ipc_sem.sets += 1;
 850                         ipc_sem.semaphores += ipc_sem_data[i].u.sem_nsems;
 851                     }
 852                 }
 853
 854                 // --------------------------------------------------------------------
 855
 856                 st = rrdset_find("system.ipc_semaphores");
 857                 if (unlikely(!st)) {
 858                     st = rrdset_create("system", "ipc_semaphores", NULL, "ipc semaphores", NULL, "IPC Semaphores", "semaphores", 1000, rrd_update_every, RRDSET_TYPE_AREA);
 859                     rrddim_add(st, "semaphores", NULL, 1, 1, RRDDIM_ABSOLUTE);
 860                 }
 861                 else rrdset_next(st);
 862
 863                 rrddim_set(st, "semaphores", ipc_sem.semaphores);
 864                 rrdset_done(st);
 865
 866                 // --------------------------------------------------------------------
 867
 868                 st = rrdset_find("system.ipc_semaphore_arrays");
 869                 if (unlikely(!st)) {
 870                     st = rrdset_create("system", "ipc_semaphore_arrays", NULL, "ipc semaphores", NULL, "IPC Semaphore Arrays", "arrays", 1000, rrd_update_every, RRDSET_TYPE_AREA);
 871                     rrddim_add(st, "arrays", NULL, 1, 1, RRDDIM_ABSOLUTE);
 872                 }
 873                 else rrdset_next(st);
 874
 875                 rrddim_set(st, "arrays", ipc_sem.sets);
 876                 rrdset_done(st);
 877             }
 878         }
 879     }
 880
 881     // --------------------------------------------------------------------
 882
 883     if (likely(do_ipc_shared_mem)) {
 884         if (unlikely(GETSYSCTL("kern.ipc.shmmni", ipc_shm.shmmni))) {
 885             do_ipc_shared_mem = 0;
 886             error("DISABLED: system.ipc_shared_mem_segs");
 887             error("DISABLED: system.ipc_shared_mem_size");
 888         } else {
 889             ipc_shm_data = reallocz(ipc_shm_data, sizeof(struct shmid_kernel) * ipc_shm.shmmni);
 890             if (unlikely(getsysctl("kern.ipc.shmsegs", ipc_shm_data, sizeof(struct shmid_kernel) * ipc_shm.shmmni))) {
 891                 do_ipc_shared_mem = 0;
 892                 error("DISABLED: system.ipc_shared_mem_segs");
 893                 error("DISABLED: system.ipc_shared_mem_size");
 894             } else {
 895                 for (i = 0; i < ipc_shm.shmmni; i++) {
 896                     if (unlikely(ipc_shm_data[i].u.shm_perm.mode & 0x0800)) {
 897                         ipc_shm.segs += 1;
 898                         ipc_shm.segsize += ipc_shm_data[i].u.shm_segsz;
 899                     }
 900                 }
 901
 902                 // --------------------------------------------------------------------
 903
 904                 st = rrdset_find("system.ipc_shared_mem_segs");
 905                 if (unlikely(!st)) {
 906                     st = rrdset_create("system", "ipc_shared_mem_segs", NULL, "ipc shared memory", NULL, "IPC Shared Memory Segments", "segments", 1000, rrd_update_every, RRDSET_TYPE_AREA);
 907                     rrddim_add(st, "segments", NULL, 1, 1, RRDDIM_ABSOLUTE);
 908                 }
 909                 else rrdset_next(st);
 910
 911                 rrddim_set(st, "segments", ipc_shm.segs);
 912                 rrdset_done(st);
 913
 914                 // --------------------------------------------------------------------
 915
 916                 st = rrdset_find("system.ipc_shared_mem_size");
 917                 if (unlikely(!st)) {
 918                     st = rrdset_create("system", "ipc_shared_mem_size", NULL, "ipc shared memory", NULL, "IPC Shared Memory Segments Size", "kilobytes", 1000, rrd_update_every, RRDSET_TYPE_AREA);
 919                     rrddim_add(st, "allocated", NULL, 1, 1024, RRDDIM_ABSOLUTE);
 920                 }
 921                 else rrdset_next(st);
 922
 923                 rrddim_set(st, "allocated", ipc_shm.segsize);
 924                 rrdset_done(st);
 925             }
 926         }
 927     }
 928
 929     // --------------------------------------------------------------------
 930
 931     if (likely(do_ipc_msg_queues)) {
 932         if (unlikely(GETSYSCTL("kern.ipc.msgmni", ipc_msq.msgmni))) {
 933             do_ipc_msg_queues = 0;
 934             error("DISABLED: system.ipc_msq_queues");
 935             error("DISABLED: system.ipc_msq_messages");
 936             error("DISABLED: system.ipc_msq_size");
 937         } else {
 938             ipc_msq_data = reallocz(ipc_msq_data, sizeof(struct msqid_kernel) * ipc_msq.msgmni);
 939             if (unlikely(getsysctl("kern.ipc.msqids", ipc_msq_data, sizeof(struct msqid_kernel) * ipc_msq.msgmni))) {
 940                 do_ipc_msg_queues = 0;
 941                 error("DISABLED: system.ipc_msq_queues");
 942                 error("DISABLED: system.ipc_msq_messages");
 943                 error("DISABLED: system.ipc_msq_size");
 944             } else {
 945                 for (i = 0; i < ipc_msq.msgmni; i++) {
 946                     if (unlikely(ipc_msq_data[i].u.msg_qbytes != 0)) {
 947                         ipc_msq.queues += 1;
 948                         ipc_msq.messages += ipc_msq_data[i].u.msg_qnum;
 949                         ipc_msq.usedsize += ipc_msq_data[i].u.msg_cbytes;
 950                         ipc_msq.allocsize += ipc_msq_data[i].u.msg_qbytes;
 951                     }
 952                 }
 953
 954                 // --------------------------------------------------------------------
 955
 956                 st = rrdset_find("system.ipc_msq_queues");
 957                 if (unlikely(!st)) {
 958                     st = rrdset_create("system", "ipc_msq_queues", NULL, "ipc message queues", NULL, "Number of IPC Message Queues", "queues", 990, rrd_update_every, RRDSET_TYPE_AREA);
 959                     rrddim_add(st, "queues", NULL, 1, 1, RRDDIM_ABSOLUTE);
 960                 }
 961                 else rrdset_next(st);
 962
 963                 rrddim_set(st, "queues", ipc_msq.queues);
 964                 rrdset_done(st);
 965
 966                 // --------------------------------------------------------------------
 967
 968                 st = rrdset_find("system.ipc_msq_messages");
 969                 if (unlikely(!st)) {
 970                     st = rrdset_create("system", "ipc_msq_messages", NULL, "ipc message queues", NULL, "Number of Messages in IPC Message Queues", "messages", 1000, rrd_update_every, RRDSET_TYPE_AREA);
 971                     rrddim_add(st, "messages", NULL, 1, 1, RRDDIM_ABSOLUTE);
 972                 }
 973                 else rrdset_next(st);
 974
 975                 rrddim_set(st, "messages", ipc_msq.messages);
 976                 rrdset_done(st);
 977
 978                 // --------------------------------------------------------------------
 979
 980                 st = rrdset_find("system.ipc_msq_size");
 981                 if (unlikely(!st)) {
 982                     st = rrdset_create("system", "ipc_msq_size", NULL, "ipc message queues", NULL, "Size of IPC Message Queues", "bytes", 1100, rrd_update_every, RRDSET_TYPE_LINE);
 983                     rrddim_add(st, "allocated", NULL, 1, 1, RRDDIM_ABSOLUTE);
 984                     rrddim_add(st, "used", NULL, 1, 1, RRDDIM_ABSOLUTE);
 985                 }
 986                 else rrdset_next(st);
 987
 988                 rrddim_set(st, "allocated", ipc_msq.allocsize);
 989                 rrddim_set(st, "used", ipc_msq.usedsize);
 990                 rrdset_done(st);
 991
 992             }
 993         }
 994     }
 995
 996     // --------------------------------------------------------------------
 997
 998     if (likely(do_netisr || do_netisr_per_core)) {
 999         if (unlikely(GETSYSCTL("kern.smp.cpus", ncpus))) {
1000             common_error = 1;
1001         } else if (unlikely(ncpus > 9999)) {
1002             error("FREEBSD: There are more than 4 digits in cpu cores number");
1003             common_error = 1;
1004         } else if (unlikely(sysctlbyname("net.isr.workstream", NULL, &netisr_workstream_size, NULL, 0) == -1)) {
1005             error("FREEBSD: sysctl(net.isr.workstream...) failed: %s", strerror(errno));
1006             common_error = 1;
1007         } else if (unlikely(sysctlbyname("net.isr.work", NULL, &netisr_work_size, NULL, 0) == -1)) {
1008             error("FREEBSD: sysctl(net.isr.work...) failed: %s", strerror(errno));
1009             common_error = 1;
1010         } else {
1011             num_netisr_workstreams = netisr_workstream_size / sizeof(struct sysctl_netisr_workstream);
1012             netisr_workstream = reallocz(netisr_workstream, num_netisr_workstreams * sizeof(struct sysctl_netisr_workstream));
1013             if (unlikely(getsysctl("net.isr.workstream", netisr_workstream, num_netisr_workstreams * sizeof(struct sysctl_netisr_workstream)))){
1014                 common_error = 1;
1015             } else {
1016                 num_netisr_works = netisr_work_size / sizeof(struct sysctl_netisr_work);
1017                 netisr_work = reallocz(netisr_work, num_netisr_works * sizeof(struct sysctl_netisr_work));
1018                 if (unlikely(getsysctl("net.isr.work", netisr_work, num_netisr_works * sizeof(struct sysctl_netisr_work)))){
1019                     common_error = 1;
1020                 }
1021             }
1022         }
1023         if (unlikely(common_error)) {
1024             do_netisr = 0;
1025             error("DISABLED: system.softnet_stat");
1026             do_netisr_per_core = 0;
1027             error("DISABLED: system.cpuX_softnet_stat");
1028             common_error = 0;
1029         } else {
1030             netisr_stats = reallocz(netisr_stats, (ncpus + 1) * sizeof(struct netisr_stats));
1031             bzero(netisr_stats, (ncpus + 1) * sizeof(struct netisr_stats));
1032             for (i = 0; i < num_netisr_workstreams; i++) {
1033                 for (n = 0; n < num_netisr_works; n++) {
1034                     if (netisr_workstream[i].snws_wsid == netisr_work[n].snw_wsid) {
1035                         netisr_stats[netisr_workstream[i].snws_cpu].dispatched += netisr_work[n].snw_dispatched;
1036                         netisr_stats[netisr_workstream[i].snws_cpu].hybrid_dispatched += netisr_work[n].snw_hybrid_dispatched;
1037                         netisr_stats[netisr_workstream[i].snws_cpu].qdrops += netisr_work[n].snw_qdrops;
1038                         netisr_stats[netisr_workstream[i].snws_cpu].queued += netisr_work[n].snw_queued;
1039                     }
1040                 }
1041             }
1042             for (i = 0; i < ncpus; i++) {
1043                 netisr_stats[ncpus].dispatched += netisr_stats[i].dispatched;
1044                 netisr_stats[ncpus].hybrid_dispatched += netisr_stats[i].hybrid_dispatched;
1045                 netisr_stats[ncpus].qdrops += netisr_stats[i].qdrops;
1046                 netisr_stats[ncpus].queued += netisr_stats[i].queued;
1047             }
1048         }
1049     }
1050
1051     // --------------------------------------------------------------------
1052
1053     if (likely(do_netisr)) {
1054         st = rrdset_find_bytype("system", "softnet_stat");
1055         if (unlikely(!st)) {
1056             st = rrdset_create("system", "softnet_stat", NULL, "softnet_stat", NULL, "System softnet_stat", "events/s", 955, update_every, RRDSET_TYPE_LINE);
1057             rrddim_add(st, "dispatched", NULL, 1, 1, RRDDIM_INCREMENTAL);
1058             rrddim_add(st, "hybrid_dispatched", NULL, 1, 1, RRDDIM_INCREMENTAL);
1059             rrddim_add(st, "qdrops", NULL, 1, 1, RRDDIM_INCREMENTAL);
1060             rrddim_add(st, "queued", NULL, 1, 1, RRDDIM_INCREMENTAL);
1061         }
1062         else rrdset_next(st);
1063
1064         rrddim_set(st, "dispatched", netisr_stats[ncpus].dispatched);
1065         rrddim_set(st, "hybrid_dispatched", netisr_stats[ncpus].hybrid_dispatched);
1066         rrddim_set(st, "qdrops", netisr_stats[ncpus].qdrops);
1067         rrddim_set(st, "queued", netisr_stats[ncpus].queued);
1068         rrdset_done(st);
1069     }
1070
1071     // --------------------------------------------------------------------
1072
1073     if (likely(do_netisr_per_core)) {
1074         for (i = 0; i < ncpus ;i++) {
1075             snprintfz(netstat_cpuid, 21, "cpu%d_softnet_stat", i);
1076
1077             st = rrdset_find_bytype("cpu", netstat_cpuid);
1078             if (unlikely(!st)) {
1079                 st = rrdset_create("cpu", netstat_cpuid, NULL, "softnet_stat", NULL, "Per CPU netisr statistics", "events/s", 1101 + i, update_every, RRDSET_TYPE_LINE);
1080                 rrddim_add(st, "dispatched", NULL, 1, 1, RRDDIM_INCREMENTAL);
1081                 rrddim_add(st, "hybrid_dispatched", NULL, 1, 1, RRDDIM_INCREMENTAL);
1082                 rrddim_add(st, "qdrops", NULL, 1, 1, RRDDIM_INCREMENTAL);
1083                 rrddim_add(st, "queued", NULL, 1, 1, RRDDIM_INCREMENTAL);
1084             }
1085             else rrdset_next(st);
1086
1087             rrddim_set(st, "dispatched", netisr_stats[i].dispatched);
1088             rrddim_set(st, "hybrid_dispatched", netisr_stats[i].hybrid_dispatched);
1089             rrddim_set(st, "qdrops", netisr_stats[i].qdrops);
1090             rrddim_set(st, "queued", netisr_stats[i].queued);
1091             rrdset_done(st);
1092         }
1093     }
1094
1095     // --------------------------------------------------------------------
1096
1097     if (likely(do_bandwidth)) {
1098         if (unlikely(getifaddrs(&ifap))) {
1099             error("FREEBSD: getifaddrs()");
1100             do_bandwidth = 0;
1101             error("DISABLED: system.ipv4");
1102         } else {
1103             iftot.ift_ibytes = iftot.ift_obytes = 0;
1104             for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
1105                 if (ifa->ifa_addr->sa_family != AF_INET)
1106                         continue;
1107                 iftot.ift_ibytes += IFA_DATA(ibytes);
1108                 iftot.ift_obytes += IFA_DATA(obytes);
1109             }
1110
1111             st = rrdset_find("system.ipv4");
1112             if (unlikely(!st)) {
1113                 st = rrdset_create("system", "ipv4", NULL, "network", NULL, "IPv4 Bandwidth", "kilobits/s", 500, update_every, RRDSET_TYPE_AREA);
1114
1115                 rrddim_add(st, "InOctets", "received", 8, 1024, RRDDIM_INCREMENTAL);
1116                 rrddim_add(st, "OutOctets", "sent", -8, 1024, RRDDIM_INCREMENTAL);
1117             }
1118             else rrdset_next(st);
1119
1120             rrddim_set(st, "InOctets", iftot.ift_ibytes);
1121             rrddim_set(st, "OutOctets", iftot.ift_obytes);
1122             rrdset_done(st);
1123
1124             // --------------------------------------------------------------------
1125
1126             iftot.ift_ibytes = iftot.ift_obytes = 0;
1127             for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
1128                 if (ifa->ifa_addr->sa_family != AF_INET6)
1129                         continue;
1130                 iftot.ift_ibytes += IFA_DATA(ibytes);
1131                 iftot.ift_obytes += IFA_DATA(obytes);
1132             }
1133
1134             st = rrdset_find("system.ipv6");
1135             if (unlikely(!st)) {
1136                 st = rrdset_create("system", "ipv6", NULL, "network", NULL, "IPv6 Bandwidth", "kilobits/s", 500, update_every, RRDSET_TYPE_AREA);
1137
1138                 rrddim_add(st, "received", NULL, 8, 1024, RRDDIM_INCREMENTAL);
1139                 rrddim_add(st, "sent", NULL, -8, 1024, RRDDIM_INCREMENTAL);
1140             }
1141             else rrdset_next(st);
1142
1143             rrddim_set(st, "sent", iftot.ift_obytes);
1144             rrddim_set(st, "received", iftot.ift_ibytes);
1145             rrdset_done(st);
1146
1147             for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
1148                 if (ifa->ifa_addr->sa_family != AF_LINK)
1149                         continue;
1150
1151                 // --------------------------------------------------------------------
1152
1153                 st = rrdset_find_bytype("net", ifa->ifa_name);
1154                 if (unlikely(!st)) {
1155                     st = rrdset_create("net", ifa->ifa_name, NULL, ifa->ifa_name, "net.net", "Bandwidth", "kilobits/s", 7000, update_every, RRDSET_TYPE_AREA);
1156
1157                     rrddim_add(st, "received", NULL, 8, 1024, RRDDIM_INCREMENTAL);
1158                     rrddim_add(st, "sent", NULL, -8, 1024, RRDDIM_INCREMENTAL);
1159                 }
1160                 else rrdset_next(st);
1161
1162                 rrddim_set(st, "received", IFA_DATA(ibytes));
1163                 rrddim_set(st, "sent", IFA_DATA(obytes));
1164                 rrdset_done(st);
1165
1166                 // --------------------------------------------------------------------
1167
1168                 st = rrdset_find_bytype("net_packets", ifa->ifa_name);
1169                 if (unlikely(!st)) {
1170                     st = rrdset_create("net_packets", ifa->ifa_name, NULL, ifa->ifa_name, "net.packets", "Packets", "packets/s", 7001, update_every, RRDSET_TYPE_LINE);
1171                     st->isdetail = 1;
1172
1173                     rrddim_add(st, "received", NULL, 1, 1, RRDDIM_INCREMENTAL);
1174                     rrddim_add(st, "sent", NULL, -1, 1, RRDDIM_INCREMENTAL);
1175                     rrddim_add(st, "multicast_received", NULL, 1, 1, RRDDIM_INCREMENTAL);
1176                     rrddim_add(st, "multicast_sent", NULL, -1, 1, RRDDIM_INCREMENTAL);
1177                 }
1178                 else rrdset_next(st);
1179
1180                 rrddim_set(st, "received", IFA_DATA(ipackets));
1181                 rrddim_set(st, "sent", IFA_DATA(opackets));
1182                 rrddim_set(st, "multicast_received", IFA_DATA(imcasts));
1183                 rrddim_set(st, "multicast_sent", IFA_DATA(omcasts));
1184                 rrdset_done(st);
1185
1186                 // --------------------------------------------------------------------
1187
1188                 st = rrdset_find_bytype("net_errors", ifa->ifa_name);
1189                 if (unlikely(!st)) {
1190                     st = rrdset_create("net_errors", ifa->ifa_name, NULL, ifa->ifa_name, "net.errors", "Interface Errors", "errors/s", 7002, update_every, RRDSET_TYPE_LINE);
1191                     st->isdetail = 1;
1192
1193                     rrddim_add(st, "inbound", NULL, 1, 1, RRDDIM_INCREMENTAL);
1194                     rrddim_add(st, "outbound", NULL, -1, 1, RRDDIM_INCREMENTAL);
1195                 }
1196                 else rrdset_next(st);
1197
1198                 rrddim_set(st, "inbound", IFA_DATA(ierrors));
1199                 rrddim_set(st, "outbound", IFA_DATA(oerrors));
1200                 rrdset_done(st);
1201
1202                 // --------------------------------------------------------------------
1203
1204                 st = rrdset_find_bytype("net_drops", ifa->ifa_name);
1205                 if (unlikely(!st)) {
1206                     st = rrdset_create("net_drops", ifa->ifa_name, NULL, ifa->ifa_name, "net.drops", "Interface Drops", "drops/s", 7003, update_every, RRDSET_TYPE_LINE);
1207                     st->isdetail = 1;
1208
1209                     rrddim_add(st, "inbound", NULL, 1, 1, RRDDIM_INCREMENTAL);
1210                     rrddim_add(st, "outbound", NULL, -1, 1, RRDDIM_INCREMENTAL);
1211                 }
1212                 else rrdset_next(st);
1213
1214                 rrddim_set(st, "inbound", IFA_DATA(iqdrops));
1215                 rrddim_set(st, "outbound", IFA_DATA(oqdrops));
1216                 rrdset_done(st);
1217
1218                 // --------------------------------------------------------------------
1219
1220                 st = rrdset_find_bytype("net_events", ifa->ifa_name);
1221                 if (unlikely(!st)) {
1222                     st = rrdset_create("net_events", ifa->ifa_name, NULL, ifa->ifa_name, "net.events", "Network Interface Events", "events/s", 7006, update_every, RRDSET_TYPE_LINE);
1223                     st->isdetail = 1;
1224
1225                     rrddim_add(st, "frames", NULL, 1, 1, RRDDIM_INCREMENTAL);
1226                     rrddim_add(st, "collisions", NULL, -1, 1, RRDDIM_INCREMENTAL);
1227                     rrddim_add(st, "carrier", NULL, -1, 1, RRDDIM_INCREMENTAL);
1228                 }
1229                 else rrdset_next(st);
1230
1231                 rrddim_set(st, "collisions", IFA_DATA(collisions));
1232                 rrdset_done(st);
1233             }
1234
1235             freeifaddrs(ifap);
1236         }
1237     }
1238
1239     // --------------------------------------------------------------------
1240
1241     // see http://net-snmp.sourceforge.net/docs/mibs/tcp.html
1242     if (likely(do_tcp_sockets)) {
1243         if (unlikely(GETSYSCTL("net.inet.tcp.states", tcps_states))) {
1244             do_tcp_sockets = 0;
1245             error("DISABLED: ipv4.tcpsock");
1246         } else {
1247             if (likely(do_tcp_sockets)) {
1248                 st = rrdset_find("ipv4.tcpsock");
1249                 if (unlikely(!st)) {
1250                     st = rrdset_create("ipv4", "tcpsock", NULL, "tcp", NULL, "IPv4 TCP Connections",
1251                                        "active connections", 2500, update_every, RRDSET_TYPE_LINE);
1252
1253                     rrddim_add(st, "CurrEstab", "connections", 1, 1, RRDDIM_ABSOLUTE);
1254                 } else
1255                     rrdset_next(st);
1256
1257                 rrddim_set(st, "CurrEstab", tcps_states[TCPS_ESTABLISHED]);
1258                 rrdset_done(st);
1259             }
1260         }
1261     }
1262
1263     // --------------------------------------------------------------------
1264
1265     // see http://net-snmp.sourceforge.net/docs/mibs/tcp.html
1266     if (likely(do_tcp_packets || do_tcp_errors || do_tcp_handshake || do_tcpext_connaborts || do_tcpext_ofo || do_tcpext_syscookies || do_ecn)) {
1267         if (unlikely(GETSYSCTL("net.inet.tcp.stats", tcpstat))){
1268             do_tcp_packets = 0;
1269             error("DISABLED: ipv4.tcppackets");
1270             do_tcp_errors = 0;
1271             error("DISABLED: ipv4.tcperrors");
1272             do_tcp_handshake = 0;
1273             error("DISABLED: ipv4.tcphandshake");
1274             do_tcpext_connaborts = 0;
1275             error("DISABLED: ipv4.tcpconnaborts");
1276             do_tcpext_ofo = 0;
1277             error("DISABLED: ipv4.tcpofo");
1278             do_tcpext_syscookies = 0;
1279             error("DISABLED: ipv4.tcpsyncookies");
1280             do_ecn = 0;
1281             error("DISABLED: ipv4.ecnpkts");
1282         } else {
1283             if (likely(do_tcp_packets)) {
1284                 st = rrdset_find("ipv4.tcppackets");
1285                 if (unlikely(!st)) {
1286                     st = rrdset_create("ipv4", "tcppackets", NULL, "tcp", NULL, "IPv4 TCP Packets",
1287                                        "packets/s",
1288                                        2600, update_every, RRDSET_TYPE_LINE);
1289
1290                     rrddim_add(st, "InSegs", "received", 1, 1, RRDDIM_INCREMENTAL);
1291                     rrddim_add(st, "OutSegs", "sent", -1, 1, RRDDIM_INCREMENTAL);
1292                 } else
1293                     rrdset_next(st);
1294
1295                 rrddim_set(st, "InSegs", tcpstat.tcps_rcvtotal);
1296                 rrddim_set(st, "OutSegs", tcpstat.tcps_sndtotal);
1297                 rrdset_done(st);
1298             }
1299
1300             // --------------------------------------------------------------------
1301
1302             if (likely(do_tcp_errors)) {
1303                 st = rrdset_find("ipv4.tcperrors");
1304                 if (unlikely(!st)) {
1305                     st = rrdset_create("ipv4", "tcperrors", NULL, "tcp", NULL, "IPv4 TCP Errors",
1306                                        "packets/s",
1307                                        2700, update_every, RRDSET_TYPE_LINE);
1308                     st->isdetail = 1;
1309
1310                     rrddim_add(st, "InErrs", NULL, 1, 1, RRDDIM_INCREMENTAL);
1311                     rrddim_add(st, "InCsumErrors", NULL, 1, 1, RRDDIM_INCREMENTAL);
1312                     rrddim_add(st, "RetransSegs", NULL, -1, 1, RRDDIM_INCREMENTAL);
1313                 } else
1314                     rrdset_next(st);
1315
1316                 rrddim_set(st, "InErrs", tcpstat.tcps_rcvbadoff + tcpstat.tcps_rcvreassfull + tcpstat.tcps_rcvshort);
1317                 rrddim_set(st, "InCsumErrors", tcpstat.tcps_rcvbadsum);
1318                 rrddim_set(st, "RetransSegs", tcpstat.tcps_sndrexmitpack);
1319                 rrdset_done(st);
1320             }
1321
1322             // --------------------------------------------------------------------
1323
1324             if (likely(do_tcp_handshake)) {
1325                 st = rrdset_find("ipv4.tcphandshake");
1326                 if (unlikely(!st)) {
1327                     st = rrdset_create("ipv4", "tcphandshake", NULL, "tcp", NULL,
1328                                        "IPv4 TCP Handshake Issues",
1329                                        "events/s", 2900, update_every, RRDSET_TYPE_LINE);
1330                     st->isdetail = 1;
1331
1332                     rrddim_add(st, "EstabResets", NULL, 1, 1, RRDDIM_INCREMENTAL);
1333                     rrddim_add(st, "ActiveOpens", NULL, 1, 1, RRDDIM_INCREMENTAL);
1334                     rrddim_add(st, "PassiveOpens", NULL, 1, 1, RRDDIM_INCREMENTAL);
1335                     rrddim_add(st, "AttemptFails", NULL, 1, 1, RRDDIM_INCREMENTAL);
1336                 } else
1337                     rrdset_next(st);
1338
1339                 rrddim_set(st, "EstabResets", tcpstat.tcps_drops);
1340                 rrddim_set(st, "ActiveOpens", tcpstat.tcps_connattempt);
1341                 rrddim_set(st, "PassiveOpens", tcpstat.tcps_accepts);
1342                 rrddim_set(st, "AttemptFails", tcpstat.tcps_conndrops);
1343                 rrdset_done(st);
1344             }
1345
1346             // --------------------------------------------------------------------
1347
1348             if (do_tcpext_connaborts == CONFIG_ONDEMAND_YES || (do_tcpext_connaborts == CONFIG_ONDEMAND_ONDEMAND && (tcpstat.tcps_rcvpackafterwin || tcpstat.tcps_rcvafterclose || tcpstat.tcps_rcvmemdrop || tcpstat.tcps_persistdrop || tcpstat.tcps_finwait2_drops))) {
1349                 do_tcpext_connaborts = CONFIG_ONDEMAND_YES;
1350                 st = rrdset_find("ipv4.tcpconnaborts");
1351                 if (unlikely(!st)) {
1352                     st = rrdset_create("ipv4", "tcpconnaborts", NULL, "tcp", NULL, "TCP Connection Aborts", "connections/s", 3010, update_every, RRDSET_TYPE_LINE);
1353
1354                     rrddim_add(st, "TCPAbortOnData",    "baddata",     1, 1, RRDDIM_INCREMENTAL);
1355                     rrddim_add(st, "TCPAbortOnClose",   "userclosed",  1, 1, RRDDIM_INCREMENTAL);
1356                     rrddim_add(st, "TCPAbortOnMemory",  "nomemory",    1, 1, RRDDIM_INCREMENTAL);
1357                     rrddim_add(st, "TCPAbortOnTimeout", "timeout",     1, 1, RRDDIM_INCREMENTAL);
1358                     rrddim_add(st, "TCPAbortOnLinger",  "linger",      1, 1, RRDDIM_INCREMENTAL);
1359                 }
1360                 else rrdset_next(st);
1361
1362                 rrddim_set(st, "TCPAbortOnData",    tcpstat.tcps_rcvpackafterwin);
1363                 rrddim_set(st, "TCPAbortOnClose",   tcpstat.tcps_rcvafterclose);
1364                 rrddim_set(st, "TCPAbortOnMemory",  tcpstat.tcps_rcvmemdrop);
1365                 rrddim_set(st, "TCPAbortOnTimeout", tcpstat.tcps_persistdrop);
1366                 rrddim_set(st, "TCPAbortOnLinger",  tcpstat.tcps_finwait2_drops);
1367                 rrdset_done(st);
1368             }
1369
1370             // --------------------------------------------------------------------
1371
1372             if (do_tcpext_ofo == CONFIG_ONDEMAND_YES || (do_tcpext_ofo == CONFIG_ONDEMAND_ONDEMAND && tcpstat.tcps_rcvoopack)) {
1373                 do_tcpext_ofo = CONFIG_ONDEMAND_YES;
1374                 st = rrdset_find("ipv4.tcpofo");
1375                 if (unlikely(!st)) {
1376                     st = rrdset_create("ipv4", "tcpofo", NULL, "tcp", NULL, "TCP Out-Of-Order Queue", "packets/s", 3050, update_every, RRDSET_TYPE_LINE);
1377
1378                     rrddim_add(st, "TCPOFOQueue", "inqueue",  1, 1, RRDDIM_INCREMENTAL);
1379                 }
1380                 else rrdset_next(st);
1381
1382                 rrddim_set(st, "TCPOFOQueue",   tcpstat.tcps_rcvoopack);
1383                 rrdset_done(st);
1384             }
1385
1386             // --------------------------------------------------------------------
1387
1388             if (do_tcpext_syscookies == CONFIG_ONDEMAND_YES || (do_tcpext_syscookies == CONFIG_ONDEMAND_ONDEMAND && (tcpstat.tcps_sc_sendcookie || tcpstat.tcps_sc_recvcookie || tcpstat.tcps_sc_zonefail))) {
1389                 do_tcpext_syscookies = CONFIG_ONDEMAND_YES;
1390
1391                 st = rrdset_find("ipv4.tcpsyncookies");
1392                 if (unlikely(!st)) {
1393                     st = rrdset_create("ipv4", "tcpsyncookies", NULL, "tcp", NULL, "TCP SYN Cookies", "packets/s", 3100, update_every, RRDSET_TYPE_LINE);
1394
1395                     rrddim_add(st, "SyncookiesRecv",   "received",  1, 1, RRDDIM_INCREMENTAL);
1396                     rrddim_add(st, "SyncookiesSent",   "sent",     -1, 1, RRDDIM_INCREMENTAL);
1397                     rrddim_add(st, "SyncookiesFailed", "failed",   -1, 1, RRDDIM_INCREMENTAL);
1398                 }
1399                 else rrdset_next(st);
1400
1401                 rrddim_set(st, "SyncookiesRecv",   tcpstat.tcps_sc_recvcookie);
1402                 rrddim_set(st, "SyncookiesSent",   tcpstat.tcps_sc_sendcookie);
1403                 rrddim_set(st, "SyncookiesFailed", tcpstat.tcps_sc_zonefail);
1404                 rrdset_done(st);
1405             }
1406
1407             // --------------------------------------------------------------------
1408
1409             if (do_ecn == CONFIG_ONDEMAND_YES || (do_ecn == CONFIG_ONDEMAND_ONDEMAND && (tcpstat.tcps_ecn_ce || tcpstat.tcps_ecn_ect0 || tcpstat.tcps_ecn_ect1))) {
1410                 do_ecn = CONFIG_ONDEMAND_YES;
1411                 st = rrdset_find("ipv4.ecnpkts");
1412                 if (unlikely(!st)) {
1413                     st = rrdset_create("ipv4", "ecnpkts", NULL, "ecn", NULL, "IPv4 ECN Statistics", "packets/s", 8700, update_every, RRDSET_TYPE_LINE);
1414                     st->isdetail = 1;
1415
1416                     rrddim_add(st, "InCEPkts", "CEP", 1, 1, RRDDIM_INCREMENTAL);
1417                     rrddim_add(st, "InNoECTPkts", "NoECTP", -1, 1, RRDDIM_INCREMENTAL);
1418                     rrddim_add(st, "InECT0Pkts", "ECTP0", 1, 1, RRDDIM_INCREMENTAL);
1419                     rrddim_add(st, "InECT1Pkts", "ECTP1", 1, 1, RRDDIM_INCREMENTAL);
1420                 }
1421                 else rrdset_next(st);
1422
1423                 rrddim_set(st, "InCEPkts", tcpstat.tcps_ecn_ce);
1424                 rrddim_set(st, "InNoECTPkts", tcpstat.tcps_ecn_ce - (tcpstat.tcps_ecn_ect0 + tcpstat.tcps_ecn_ect1));
1425                 rrddim_set(st, "InECT0Pkts", tcpstat.tcps_ecn_ect0);
1426                 rrddim_set(st, "InECT1Pkts", tcpstat.tcps_ecn_ect1);
1427                 rrdset_done(st);
1428             }
1429
1430         }
1431     }
1432
1433     return 0;
1434 }