src/freebsd_sysctl.c

   1 #include "common.h"
   2
   3 // NEEDED BY: struct vmstat
   4 #include <sys/vmmeter.h>
   5
   6 // FreeBSD calculates load averages once every 5 seconds
   7 #define MIN_LOADAVG_UPDATE_EVERY 5
   8
   9 int do_freebsd_sysctl(int update_every, unsigned long long dt) {
  10     (void)dt;
  11
  12     static int do_cpu = -1, do_cpu_cores = -1, do_interrupts = -1, do_context = -1, do_forks = -1, do_processes = -1,
  13         do_loadavg = -1, do_all_processes = -1;
  14
  15     if(unlikely(do_cpu == -1)) {
  16         do_cpu                  = config_get_boolean("plugin:freebsd:sysctl", "cpu utilization", 1);
  17         do_cpu_cores            = config_get_boolean("plugin:freebsd:sysctl", "per cpu core utilization", 1);
  18         do_interrupts           = config_get_boolean("plugin:freebsd:sysctl", "cpu interrupts", 1);
  19         do_context              = config_get_boolean("plugin:freebsd:sysctl", "context switches", 1);
  20         do_forks                = config_get_boolean("plugin:freebsd:sysctl", "processes started", 1);
  21         do_processes            = config_get_boolean("plugin:freebsd:sysctl", "processes running", 1);
  22         do_loadavg              = config_get_boolean("plugin:freebsd:sysctl", "enable load average", 1);
  23         do_all_processes        = config_get_boolean("plugin:freebsd:sysctl", "enable total processes", 1);
  24     }
  25
  26     RRDSET *st;
  27
  28     int i;
  29
  30 // NEEDED BY: do_loadavg
  31     static unsigned long long last_loadavg_usec = 0;
  32     struct loadavg sysload;
  33
  34 // NEEDED BY: do_cpu, do_cpu_cores
  35     long cp_time[CPUSTATES];
  36
  37 // NEEDED BY: do_cpu_cores
  38     int ncpus;
  39     static long *pcpu_cp_time = NULL;
  40     char cpuid[8]; // no more than 4 digits expected
  41
  42 // NEEDED BY: do_all_processes, do_processes
  43     struct vmtotal vmtotal_data;
  44
  45 // NEEDED BY: do_context, do_forks
  46     u_int u_int_data;
  47
  48 // NEEDED BY: do_interrupts
  49     size_t intrcnt_size;
  50     unsigned long nintr = 0;
  51     static unsigned long *intrcnt = NULL;
  52     unsigned long long totalintr = 0;
  53
  54     // --------------------------------------------------------------------
  55
  56     if(last_loadavg_usec <= dt) {
  57         if(likely(do_loadavg)) {
  58             if (unlikely(GETSYSCTL("vm.loadavg", sysload))) {
  59                 do_loadavg = 0;
  60                 error("DISABLED: system.load");
  61             } else {
  62
  63                 st = rrdset_find_bytype("system", "load");
  64                 if(unlikely(!st)) {
  65                     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);
  66                     rrddim_add(st, "load1", NULL, 1, 1000, RRDDIM_ABSOLUTE);
  67                     rrddim_add(st, "load5", NULL, 1, 1000, RRDDIM_ABSOLUTE);
  68                     rrddim_add(st, "load15", NULL, 1, 1000, RRDDIM_ABSOLUTE);
  69                 }
  70                 else rrdset_next(st);
  71
  72                 rrddim_set(st, "load1", (collected_number) ((double)sysload.ldavg[0] / sysload.fscale * 1000));
  73                 rrddim_set(st, "load5", (collected_number) ((double)sysload.ldavg[1] / sysload.fscale * 1000));
  74                 rrddim_set(st, "load15", (collected_number) ((double)sysload.ldavg[2] / sysload.fscale * 1000));
  75                 rrdset_done(st);
  76             }
  77         }
  78
  79         last_loadavg_usec = st->update_every * 1000000ULL;
  80     }
  81     else last_loadavg_usec -= dt;
  82
  83     // --------------------------------------------------------------------
  84
  85     if(likely(do_all_processes | do_processes)) {
  86         if (unlikely(GETSYSCTL("vm.vmtotal", vmtotal_data))) {
  87             do_all_processes = 0;
  88             error("DISABLED: system.active_processes");
  89             do_processes = 0;
  90             error("DISABLED: system.processes");
  91         } else {
  92             if(likely(do_processes)) {
  93
  94                 st = rrdset_find_bytype("system", "active_processes");
  95                 if(unlikely(!st)) {
  96                     st = rrdset_create("system", "active_processes", NULL, "processes", NULL, "System Active Processes", "processes", 750, update_every, RRDSET_TYPE_LINE);
  97                     rrddim_add(st, "active", NULL, 1, 1, RRDDIM_ABSOLUTE);
  98                 }
  99                 else rrdset_next(st);
 100
 101                 rrddim_set(st, "active", (vmtotal_data.t_rq + vmtotal_data.t_dw + vmtotal_data.t_pw + vmtotal_data.t_sl + vmtotal_data.t_sw));
 102                 rrdset_done(st);
 103             }
 104             if(likely(do_processes)) {
 105
 106                 st = rrdset_find_bytype("system", "processes");
 107                 if(unlikely(!st)) {
 108                     st = rrdset_create("system", "processes", NULL, "processes", NULL, "System Processes", "processes", 600, update_every, RRDSET_TYPE_LINE);
 109
 110                     rrddim_add(st, "running", NULL, 1, 1, RRDDIM_ABSOLUTE);
 111                     rrddim_add(st, "blocked", NULL, -1, 1, RRDDIM_ABSOLUTE);
 112                 }
 113                 else rrdset_next(st);
 114
 115                 rrddim_set(st, "running", vmtotal_data.t_rq);
 116                 rrddim_set(st, "blocked", (vmtotal_data.t_dw + vmtotal_data.t_pw));
 117                 rrdset_done(st);
 118             }
 119
 120         }
 121     }
 122
 123     // --------------------------------------------------------------------
 124
 125     if(likely(do_processes)) {
 126
 127             st = rrdset_find_bytype("system", "processes");
 128             if(unlikely(!st)) {
 129                 st = rrdset_create("system", "processes", NULL, "processes", NULL, "System Processes", "processes", 600, update_every, RRDSET_TYPE_LINE);
 130
 131                 rrddim_add(st, "running", NULL, 1, 1, RRDDIM_ABSOLUTE);
 132                 rrddim_add(st, "blocked", NULL, -1, 1, RRDDIM_ABSOLUTE);
 133             }
 134             else rrdset_next(st);
 135
 136             rrddim_set(st, "running", vmtotal_data.t_rq);
 137             rrddim_set(st, "blocked", (vmtotal_data.t_dw + vmtotal_data.t_pw));
 138             rrdset_done(st);
 139         }
 140
 141     // --------------------------------------------------------------------
 142
 143     if(likely(do_cpu)) {
 144         if (unlikely(CPUSTATES != 5)) {
 145             error("FREEBSD: There are %d CPU states (5 was expected)", CPUSTATES);
 146             do_cpu = 0;
 147             error("DISABLED: system.cpu");
 148         } else {
 149             if (unlikely(GETSYSCTL("kern.cp_time", cp_time))) {
 150                 do_cpu = 0;
 151                 error("DISABLED: system.cpu");
 152             } else {
 153
 154                 st = rrdset_find_bytype("system", "cpu");
 155                 if(unlikely(!st)) {
 156                     st = rrdset_create("system", "cpu", NULL, "cpu", "system.cpu", "Total CPU utilization", "percentage", 100, update_every, RRDSET_TYPE_STACKED);
 157
 158                     rrddim_add(st, "user", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 159                     rrddim_add(st, "nice", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 160                     rrddim_add(st, "system", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 161                     rrddim_add(st, "interrupt", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 162                     rrddim_add(st, "idle", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 163                     rrddim_hide(st, "idle");
 164                 }
 165                 else rrdset_next(st);
 166
 167                 rrddim_set(st, "user", cp_time[0]);
 168                 rrddim_set(st, "nice", cp_time[1]);
 169                 rrddim_set(st, "system", cp_time[2]);
 170                 rrddim_set(st, "interrupt", cp_time[3]);
 171                 rrddim_set(st, "idle", cp_time[4]);
 172                 rrdset_done(st);
 173             }
 174         }
 175     }
 176
 177     // --------------------------------------------------------------------
 178
 179     if(likely(do_cpu_cores)) {
 180         if (unlikely(CPUSTATES != 5)) {
 181             error("FREEBSD: There are %d CPU states (5 was expected)", CPUSTATES);
 182             do_cpu_cores = 0;
 183             error("DISABLED: cpu.cpuXX");
 184         } else {
 185             if (unlikely(GETSYSCTL("kern.smp.cpus", ncpus))) {
 186                 do_cpu_cores = 0;
 187                 error("DISABLED: cpu.cpuXX");
 188             } else {
 189                 pcpu_cp_time = realloc(pcpu_cp_time, sizeof(cp_time) * ncpus);
 190
 191                 for (i = 0; i < ncpus; i++) {
 192                     if (unlikely(getsysctl("kern.cp_times", pcpu_cp_time, sizeof(cp_time) * ncpus))) {
 193                         do_cpu_cores = 0;
 194                         error("DISABLED: cpu.cpuXX");
 195                         break;
 196                     }
 197                     if (unlikely(ncpus > 9999)) {
 198                         error("FREEBSD: There are more than 4 digits in cpu cores number");
 199                         do_cpu_cores = 0;
 200                         error("DISABLED: cpu.cpuXX");
 201                         break;
 202                     }
 203                     snprintfz(cpuid, 8, "cpu%d", i);
 204
 205                     st = rrdset_find_bytype("cpu", cpuid);
 206                     if(unlikely(!st)) {
 207                         st = rrdset_create("cpu", cpuid, NULL, "utilization", "cpu.cpu", "Core utilization", "percentage", 1000, update_every, RRDSET_TYPE_STACKED);
 208
 209                         rrddim_add(st, "user", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 210                         rrddim_add(st, "nice", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 211                         rrddim_add(st, "system", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 212                         rrddim_add(st, "interrupt", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 213                         rrddim_add(st, "idle", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
 214                         rrddim_hide(st, "idle");
 215                     }
 216                     else rrdset_next(st);
 217
 218                     rrddim_set(st, "user", pcpu_cp_time[i * 5 + 0]);
 219                     rrddim_set(st, "nice", pcpu_cp_time[i * 5 + 1]);
 220                     rrddim_set(st, "system", pcpu_cp_time[i * 5 + 2]);
 221                     rrddim_set(st, "interrupt", pcpu_cp_time[i * 5 + 3]);
 222                     rrddim_set(st, "idle", pcpu_cp_time[i * 5 + 4]);
 223                     rrdset_done(st);
 224                 }
 225             }
 226         }
 227     }
 228
 229     // --------------------------------------------------------------------
 230
 231     if(likely(do_interrupts)) {
 232         if (unlikely(sysctlbyname("hw.intrcnt", NULL, &intrcnt_size, NULL, 0) == -1)) {
 233             error("FREEBSD: sysctl(hw.intrcnt...) failed: %s", strerror(errno));
 234             do_interrupts = 0;
 235             error("DISABLED: system.intr");
 236         } else {
 237             nintr = intrcnt_size / sizeof(u_long);
 238             intrcnt = realloc(intrcnt, nintr * sizeof(u_long));
 239             if (unlikely(getsysctl("hw.intrcnt", intrcnt, nintr * sizeof(u_long)))){
 240                 do_interrupts = 0;
 241                 error("DISABLED: system.intr");
 242             } else {
 243                 for (i = 0; i < nintr; i++)
 244                     totalintr += intrcnt[i];
 245
 246                 st = rrdset_find_bytype("system", "intr");
 247                 if(unlikely(!st)) {
 248                     st = rrdset_create("system", "intr", NULL, "interrupts", NULL, "Total Device Interrupts", "interrupts/s", 900, update_every, RRDSET_TYPE_LINE);
 249                     st->isdetail = 1;
 250
 251                     rrddim_add(st, "interrupts", NULL, 1, 1, RRDDIM_INCREMENTAL);
 252                 }
 253                 else rrdset_next(st);
 254
 255                 rrddim_set(st, "interrupts", totalintr);
 256                 rrdset_done(st);
 257             }
 258         }
 259     }
 260
 261     // --------------------------------------------------------------------
 262
 263     if(likely(do_context)) {
 264         if (unlikely(GETSYSCTL("vm.stats.sys.v_swtch", u_int_data))) {
 265             do_context = 0;
 266             error("DISABLED: system.ctxt");
 267         } else {
 268
 269             st = rrdset_find_bytype("system", "ctxt");
 270             if(unlikely(!st)) {
 271                 st = rrdset_create("system", "ctxt", NULL, "processes", NULL, "CPU Context Switches", "context switches/s", 800, update_every, RRDSET_TYPE_LINE);
 272
 273                 rrddim_add(st, "switches", NULL, 1, 1, RRDDIM_INCREMENTAL);
 274             }
 275             else rrdset_next(st);
 276
 277             rrddim_set(st, "switches", u_int_data);
 278             rrdset_done(st);
 279         }
 280     }
 281
 282     // --------------------------------------------------------------------
 283
 284     if(likely(do_forks)) {
 285         if (unlikely(GETSYSCTL("vm.stats.vm.v_forks", u_int_data))) {
 286             do_forks = 0;
 287             error("DISABLED: system.forks");
 288         } else {
 289
 290             st = rrdset_find_bytype("system", "forks");
 291             if(unlikely(!st)) {
 292                 st = rrdset_create("system", "forks", NULL, "processes", NULL, "Started Processes", "processes/s", 700, update_every, RRDSET_TYPE_LINE);
 293                 st->isdetail = 1;
 294
 295                 rrddim_add(st, "started", NULL, 1, 1, RRDDIM_INCREMENTAL);
 296             }
 297             else rrdset_next(st);
 298
 299             rrddim_set(st, "started", u_int_data);
 300             rrdset_done(st);
 301         }
 302     }
 303
 304     return 0;
 305 }