src/cpu.c

   1 /**
   2  * collectd - src/cpu.c
   3  * Copyright (C) 2005-2009  Florian octo Forster
   4  * Copyright (C) 2008       Oleg King
   5  * Copyright (C) 2009       Simon Kuhnle
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the
   9  * Free Software Foundation; only version 2 of the License is applicable.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  19  *
  20  * Authors:
  21  *   Florian octo Forster <octo at verplant.org>
  22  *   Oleg King <king2 at kaluga.ru>
  23  *   Simon Kuhnle <simon at blarzwurst.de>
  24  **/
  25
  26 #include "collectd.h"
  27 #include "common.h"
  28 #include "plugin.h"
  29
  30 #ifdef HAVE_MACH_KERN_RETURN_H
  31 # include <mach/kern_return.h>
  32 #endif
  33 #ifdef HAVE_MACH_MACH_INIT_H
  34 # include <mach/mach_init.h>
  35 #endif
  36 #ifdef HAVE_MACH_HOST_PRIV_H
  37 # include <mach/host_priv.h>
  38 #endif
  39 #if HAVE_MACH_MACH_ERROR_H
  40 #  include <mach/mach_error.h>
  41 #endif
  42 #ifdef HAVE_MACH_PROCESSOR_INFO_H
  43 # include <mach/processor_info.h>
  44 #endif
  45 #ifdef HAVE_MACH_PROCESSOR_H
  46 # include <mach/processor.h>
  47 #endif
  48 #ifdef HAVE_MACH_VM_MAP_H
  49 # include <mach/vm_map.h>
  50 #endif
  51
  52 #ifdef HAVE_LIBKSTAT
  53 # include <sys/sysinfo.h>
  54 #endif /* HAVE_LIBKSTAT */
  55
  56 #if (defined(HAVE_SYSCTL) && HAVE_SYSCTL) \
  57         || (defined(HAVE_SYSCTLBYNAME) && HAVE_SYSCTLBYNAME)
  58 # ifdef HAVE_SYS_SYSCTL_H
  59 #  include <sys/sysctl.h>
  60 # endif
  61
  62 # ifdef HAVE_SYS_DKSTAT_H
  63 #  include <sys/dkstat.h>
  64 # endif
  65
  66 # if !defined(CP_USER) || !defined(CP_NICE) || !defined(CP_SYS) || !defined(CP_INTR) || !defined(CP_IDLE) || !defined(CPUSTATES)
  67 #  define CP_USER   0
  68 #  define CP_NICE   1
  69 #  define CP_SYS    2
  70 #  define CP_INTR   3
  71 #  define CP_IDLE   4
  72 #  define CPUSTATES 5
  73 # endif
  74 #endif /* HAVE_SYSCTL || HAVE_SYSCTLBYNAME */
  75
  76 #if HAVE_SYSCTL
  77 # if defined(CTL_HW) && defined(HW_NCPU) \
  78         && defined(CTL_KERN) && defined(KERN_CPTIME) && defined(CPUSTATES)
  79 #  define CAN_USE_SYSCTL 1
  80 # else
  81 #  define CAN_USE_SYSCTL 0
  82 # endif
  83 #else
  84 # define CAN_USE_SYSCTL 0
  85 #endif
  86
  87 #if HAVE_STATGRAB_H
  88 # include <statgrab.h>
  89 #endif
  90
  91 #if !PROCESSOR_CPU_LOAD_INFO && !KERNEL_LINUX && !HAVE_LIBKSTAT \
  92         && !CAN_USE_SYSCTL && !HAVE_SYSCTLBYNAME && !HAVE_LIBSTATGRAB
  93 # error "No applicable input method."
  94 #endif
  95
  96 #ifdef PROCESSOR_CPU_LOAD_INFO
  97 static mach_port_t port_host;
  98 static processor_port_array_t cpu_list;
  99 static mach_msg_type_number_t cpu_list_len;
 100
 101 #if PROCESSOR_TEMPERATURE
 102 static int cpu_temp_retry_counter = 0;
 103 static int cpu_temp_retry_step    = 1;
 104 static int cpu_temp_retry_max     = 1;
 105 #endif /* PROCESSOR_TEMPERATURE */
 106 /* #endif PROCESSOR_CPU_LOAD_INFO */
 107
 108 #elif defined(KERNEL_LINUX)
 109 /* no variables needed */
 110 /* #endif KERNEL_LINUX */
 111
 112 #elif defined(HAVE_LIBKSTAT)
 113 /* colleague tells me that Sun doesn't sell systems with more than 100 or so CPUs.. */
 114 # define MAX_NUMCPU 256
 115 extern kstat_ctl_t *kc;
 116 static kstat_t *ksp[MAX_NUMCPU];
 117 static int numcpu;
 118 /* #endif HAVE_LIBKSTAT */
 119
 120 #elif CAN_USE_SYSCTL
 121 static int numcpu;
 122 /* #endif CAN_USE_SYSCTL */
 123
 124 #elif defined(HAVE_SYSCTLBYNAME)
 125 static int numcpu;
 126 /* #endif HAVE_SYSCTLBYNAME */
 127
 128 #elif defined(HAVE_LIBSTATGRAB)
 129 /* no variables needed */
 130 #endif /* HAVE_LIBSTATGRAB */
 131
 132 static int init (void)
 133 {
 134 #if PROCESSOR_CPU_LOAD_INFO || PROCESSOR_TEMPERATURE
 135         kern_return_t status;
 136
 137         port_host = mach_host_self ();
 138
 139         /* FIXME: Free `cpu_list' if it's not NULL */
 140         if ((status = host_processors (port_host, &cpu_list, &cpu_list_len)) != KERN_SUCCESS)
 141         {
 142                 ERROR ("cpu plugin: host_processors returned %i", (int) status);
 143                 cpu_list_len = 0;
 144                 return (-1);
 145         }
 146
 147         DEBUG ("host_processors returned %i %s", (int) cpu_list_len, cpu_list_len == 1 ? "processor" : "processors");
 148         INFO ("cpu plugin: Found %i processor%s.", (int) cpu_list_len, cpu_list_len == 1 ? "" : "s");
 149
 150         cpu_temp_retry_max = 86400 / interval_g;
 151 /* #endif PROCESSOR_CPU_LOAD_INFO */
 152
 153 #elif defined(HAVE_LIBKSTAT)
 154         kstat_t *ksp_chain;
 155
 156         numcpu = 0;
 157
 158         if (kc == NULL)
 159                 return (-1);
 160
 161         /* Solaris doesn't count linear.. *sigh* */
 162         for (numcpu = 0, ksp_chain = kc->kc_chain;
 163                         (numcpu < MAX_NUMCPU) && (ksp_chain != NULL);
 164                         ksp_chain = ksp_chain->ks_next)
 165                 if (strncmp (ksp_chain->ks_module, "cpu_stat", 8) == 0)
 166                         ksp[numcpu++] = ksp_chain;
 167 /* #endif HAVE_LIBKSTAT */
 168
 169 #elif CAN_USE_SYSCTL
 170         size_t numcpu_size;
 171         int mib[2] = {CTL_HW, HW_NCPU};
 172         int status;
 173
 174         numcpu = 0;
 175         numcpu_size = sizeof (numcpu);
 176
 177         status = sysctl (mib, STATIC_ARRAY_SIZE (mib),
 178                         &numcpu, &numcpu_size, NULL, 0);
 179         if (status == -1)
 180         {
 181                 char errbuf[1024];
 182                 WARNING ("cpu plugin: sysctl: %s",
 183                                 sstrerror (errno, errbuf, sizeof (errbuf)));
 184                 return (-1);
 185         }
 186 /* #endif CAN_USE_SYSCTL */
 187
 188 #elif defined (HAVE_SYSCTLBYNAME)
 189         size_t numcpu_size;
 190
 191         numcpu_size = sizeof (numcpu);
 192
 193         if (sysctlbyname ("hw.ncpu", &numcpu, &numcpu_size, NULL, 0) < 0)
 194         {
 195                 char errbuf[1024];
 196                 WARNING ("cpu plugin: sysctlbyname: %s",
 197                                 sstrerror (errno, errbuf, sizeof (errbuf)));
 198                 return (-1);
 199         }
 200
 201         if (numcpu != 1)
 202                 NOTICE ("cpu: Only one processor supported when using `sysctlbyname' (found %i)", numcpu);
 203 /* #endif HAVE_SYSCTLBYNAME */
 204
 205 #elif defined(HAVE_LIBSTATGRAB)
 206         /* nothing to initialize */
 207 #endif /* HAVE_LIBSTATGRAB */
 208
 209         return (0);
 210 } /* int init */
 211
 212 static void submit (int cpu_num, const char *type_instance, counter_t value)
 213 {
 214         value_t values[1];
 215         value_list_t vl = VALUE_LIST_INIT;
 216
 217         values[0].counter = value;
 218
 219         vl.values = values;
 220         vl.values_len = 1;
 221         sstrncpy (vl.host, hostname_g, sizeof (vl.host));
 222         sstrncpy (vl.plugin, "cpu", sizeof (vl.plugin));
 223         ssnprintf (vl.plugin_instance, sizeof (vl.type_instance),
 224                         "%i", cpu_num);
 225         sstrncpy (vl.type, "cpu", sizeof (vl.type));
 226         sstrncpy (vl.type_instance, type_instance, sizeof (vl.type_instance));
 227
 228         plugin_dispatch_values (&vl);
 229 }
 230
 231 static int cpu_read (void)
 232 {
 233 #if PROCESSOR_CPU_LOAD_INFO || PROCESSOR_TEMPERATURE
 234         int cpu;
 235
 236         kern_return_t status;
 237
 238 #if PROCESSOR_CPU_LOAD_INFO
 239         processor_cpu_load_info_data_t cpu_info;
 240         mach_msg_type_number_t         cpu_info_len;
 241 #endif
 242 #if PROCESSOR_TEMPERATURE
 243         processor_info_data_t          cpu_temp;
 244         mach_msg_type_number_t         cpu_temp_len;
 245 #endif
 246
 247         host_t cpu_host;
 248
 249         for (cpu = 0; cpu < cpu_list_len; cpu++)
 250         {
 251 #if PROCESSOR_CPU_LOAD_INFO
 252                 cpu_host = 0;
 253                 cpu_info_len = PROCESSOR_BASIC_INFO_COUNT;
 254
 255                 if ((status = processor_info (cpu_list[cpu],
 256                                                 PROCESSOR_CPU_LOAD_INFO, &cpu_host,
 257                                                 (processor_info_t) &cpu_info, &cpu_info_len)) != KERN_SUCCESS)
 258                 {
 259                         ERROR ("cpu plugin: processor_info failed with status %i", (int) status);
 260                         continue;
 261                 }
 262
 263                 if (cpu_info_len < CPU_STATE_MAX)
 264                 {
 265                         ERROR ("cpu plugin: processor_info returned only %i elements..", cpu_info_len);
 266                         continue;
 267                 }
 268
 269                 submit (cpu, "user", (counter_t) cpu_info.cpu_ticks[CPU_STATE_USER]);
 270                 submit (cpu, "nice", (counter_t) cpu_info.cpu_ticks[CPU_STATE_NICE]);
 271                 submit (cpu, "system", (counter_t) cpu_info.cpu_ticks[CPU_STATE_SYSTEM]);
 272                 submit (cpu, "idle", (counter_t) cpu_info.cpu_ticks[CPU_STATE_IDLE]);
 273 #endif /* PROCESSOR_CPU_LOAD_INFO */
 274 #if PROCESSOR_TEMPERATURE
 275                 /*
 276                  * Not all Apple computers do have this ability. To minimize
 277                  * the messages sent to the syslog we do an exponential
 278                  * stepback if `processor_info' fails. We still try ~once a day
 279                  * though..
 280                  */
 281                 if (cpu_temp_retry_counter > 0)
 282                 {
 283                         cpu_temp_retry_counter--;
 284                         continue;
 285                 }
 286
 287                 cpu_temp_len = PROCESSOR_INFO_MAX;
 288
 289                 status = processor_info (cpu_list[cpu],
 290                                 PROCESSOR_TEMPERATURE,
 291                                 &cpu_host,
 292                                 cpu_temp, &cpu_temp_len);
 293                 if (status != KERN_SUCCESS)
 294                 {
 295                         ERROR ("cpu plugin: processor_info failed: %s",
 296                                         mach_error_string (status));
 297
 298                         cpu_temp_retry_counter = cpu_temp_retry_step;
 299                         cpu_temp_retry_step *= 2;
 300                         if (cpu_temp_retry_step > cpu_temp_retry_max)
 301                                 cpu_temp_retry_step = cpu_temp_retry_max;
 302
 303                         continue;
 304                 }
 305
 306                 if (cpu_temp_len != 1)
 307                 {
 308                         DEBUG ("processor_info (PROCESSOR_TEMPERATURE) returned %i elements..?",
 309                                         (int) cpu_temp_len);
 310                         continue;
 311                 }
 312
 313                 cpu_temp_retry_counter = 0;
 314                 cpu_temp_retry_step    = 1;
 315
 316                 DEBUG ("cpu_temp = %i", (int) cpu_temp);
 317 #endif /* PROCESSOR_TEMPERATURE */
 318         }
 319 /* #endif PROCESSOR_CPU_LOAD_INFO */
 320
 321 #elif defined(KERNEL_LINUX)
 322         int cpu;
 323         counter_t user, nice, syst, idle;
 324         counter_t wait, intr, sitr; /* sitr == soft interrupt */
 325         FILE *fh;
 326         char buf[1024];
 327
 328         char *fields[9];
 329         int numfields;
 330
 331         if ((fh = fopen ("/proc/stat", "r")) == NULL)
 332         {
 333                 char errbuf[1024];
 334                 ERROR ("cpu plugin: fopen (/proc/stat) failed: %s",
 335                                 sstrerror (errno, errbuf, sizeof (errbuf)));
 336                 return (-1);
 337         }
 338
 339         while (fgets (buf, 1024, fh) != NULL)
 340         {
 341                 if (strncmp (buf, "cpu", 3))
 342                         continue;
 343                 if ((buf[3] < '0') || (buf[3] > '9'))
 344                         continue;
 345
 346                 numfields = strsplit (buf, fields, 9);
 347                 if (numfields < 5)
 348                         continue;
 349
 350                 cpu = atoi (fields[0] + 3);
 351                 user = atoll (fields[1]);
 352                 nice = atoll (fields[2]);
 353                 syst = atoll (fields[3]);
 354                 idle = atoll (fields[4]);
 355
 356                 submit (cpu, "user", user);
 357                 submit (cpu, "nice", nice);
 358                 submit (cpu, "system", syst);
 359                 submit (cpu, "idle", idle);
 360
 361                 if (numfields >= 8)
 362                 {
 363                         wait = atoll (fields[5]);
 364                         intr = atoll (fields[6]);
 365                         sitr = atoll (fields[7]);
 366
 367                         submit (cpu, "wait", wait);
 368                         submit (cpu, "interrupt", intr);
 369                         submit (cpu, "softirq", sitr);
 370
 371                         if (numfields >= 9)
 372                                 submit (cpu, "steal", atoll (fields[8]));
 373                 }
 374         }
 375
 376         fclose (fh);
 377 /* #endif defined(KERNEL_LINUX) */
 378
 379 #elif defined(HAVE_LIBKSTAT)
 380         int cpu;
 381         counter_t user, syst, idle, wait;
 382         static cpu_stat_t cs;
 383
 384         if (kc == NULL)
 385                 return (-1);
 386
 387         for (cpu = 0; cpu < numcpu; cpu++)
 388         {
 389                 if (kstat_read (kc, ksp[cpu], &cs) == -1)
 390                         continue; /* error message? */
 391
 392                 idle = (counter_t) cs.cpu_sysinfo.cpu[CPU_IDLE];
 393                 user = (counter_t) cs.cpu_sysinfo.cpu[CPU_USER];
 394                 syst = (counter_t) cs.cpu_sysinfo.cpu[CPU_KERNEL];
 395                 wait = (counter_t) cs.cpu_sysinfo.cpu[CPU_WAIT];
 396
 397                 submit (ksp[cpu]->ks_instance, "user", user);
 398                 submit (ksp[cpu]->ks_instance, "system", syst);
 399                 submit (ksp[cpu]->ks_instance, "idle", idle);
 400                 submit (ksp[cpu]->ks_instance, "wait", wait);
 401         }
 402 /* #endif defined(HAVE_LIBKSTAT) */
 403
 404 #elif CAN_USE_SYSCTL
 405         uint64_t cpuinfo[numcpu][CPUSTATES];
 406         size_t cpuinfo_size;
 407         int status;
 408         int i;
 409
 410         if (numcpu < 1)
 411         {
 412                 ERROR ("cpu plugin: Could not determine number of "
 413                                 "installed CPUs using sysctl(3).");
 414                 return (-1);
 415         }
 416
 417         memset (cpuinfo, 0, sizeof (cpuinfo));
 418
 419 #if defined(KERN_CPTIME2)
 420         if (numcpu > 1) {
 421                 for (i = 0; i < numcpu; i++) {
 422                         int mib[] = {CTL_KERN, KERN_CPTIME2, i};
 423
 424                         cpuinfo_size = sizeof (cpuinfo[0]);
 425
 426                         status = sysctl (mib, STATIC_ARRAY_SIZE (mib),
 427                                         cpuinfo[i], &cpuinfo_size, NULL, 0);
 428                         if (status == -1) {
 429                                 char errbuf[1024];
 430                                 ERROR ("cpu plugin: sysctl failed: %s.",
 431                                                 sstrerror (errno, errbuf, sizeof (errbuf)));
 432                                 return (-1);
 433                         }
 434                 }
 435         }
 436         else
 437 #endif /* defined(KERN_CPTIME2) */
 438         {
 439                 int mib[] = {CTL_KERN, KERN_CPTIME};
 440                 long cpuinfo_tmp[CPUSTATES];
 441
 442                 cpuinfo_size = sizeof(cpuinfo_tmp);
 443
 444                 status = sysctl (mib, STATIC_ARRAY_SIZE (mib),
 445                                         &cpuinfo_tmp, &cpuinfo_size, NULL, 0);
 446                 if (status == -1)
 447                 {
 448                         char errbuf[1024];
 449                         ERROR ("cpu plugin: sysctl failed: %s.",
 450                                         sstrerror (errno, errbuf, sizeof (errbuf)));
 451                         return (-1);
 452                 }
 453
 454                 for(i = 0; i < CPUSTATES; i++) {
 455                         cpuinfo[0][i] = cpuinfo_tmp[i];
 456                 }
 457         }
 458
 459         for (i = 0; i < numcpu; i++) {
 460                 submit (i, "user",      cpuinfo[i][CP_USER]);
 461                 submit (i, "nice",      cpuinfo[i][CP_NICE]);
 462                 submit (i, "system",    cpuinfo[i][CP_SYS]);
 463                 submit (i, "idle",      cpuinfo[i][CP_IDLE]);
 464                 submit (i, "interrupt", cpuinfo[i][CP_INTR]);
 465         }
 466 /* #endif CAN_USE_SYSCTL */
 467
 468 #elif defined(HAVE_SYSCTLBYNAME)
 469         long cpuinfo[CPUSTATES];
 470         size_t cpuinfo_size;
 471
 472         cpuinfo_size = sizeof (cpuinfo);
 473
 474         if (sysctlbyname("kern.cp_time", &cpuinfo, &cpuinfo_size, NULL, 0) < 0)
 475         {
 476                 char errbuf[1024];
 477                 ERROR ("cpu plugin: sysctlbyname failed: %s.",
 478                                 sstrerror (errno, errbuf, sizeof (errbuf)));
 479                 return (-1);
 480         }
 481
 482         submit (0, "user", cpuinfo[CP_USER]);
 483         submit (0, "nice", cpuinfo[CP_NICE]);
 484         submit (0, "system", cpuinfo[CP_SYS]);
 485         submit (0, "idle", cpuinfo[CP_IDLE]);
 486         submit (0, "interrupt", cpuinfo[CP_INTR]);
 487 /* #endif HAVE_SYSCTLBYNAME */
 488
 489 #elif defined(HAVE_LIBSTATGRAB)
 490         sg_cpu_stats *cs;
 491         cs = sg_get_cpu_stats ();
 492
 493         if (cs == NULL)
 494         {
 495                 ERROR ("cpu plugin: sg_get_cpu_stats failed.");
 496                 return (-1);
 497         }
 498
 499         submit (0, "idle",   (counter_t) cs->idle);
 500         submit (0, "nice",   (counter_t) cs->nice);
 501         submit (0, "swap",   (counter_t) cs->swap);
 502         submit (0, "system", (counter_t) cs->kernel);
 503         submit (0, "user",   (counter_t) cs->user);
 504         submit (0, "wait",   (counter_t) cs->iowait);
 505 #endif /* HAVE_LIBSTATGRAB */
 506
 507         return (0);
 508 }
 509
 510 void module_register (void)
 511 {
 512         plugin_register_init ("cpu", init);
 513         plugin_register_read ("cpu", cpu_read);
 514 } /* void module_register */