diff --git a/src/cpu.c b/src/cpu.c
index aab1739b3fbeb41de3339e30b4843e55fbd41504..12071a2ca8bae25cf86f25782a682ad1bf898846 100644 (file)
--- a/src/cpu.c
+++ b/src/cpu.c
/**
* collectd - src/cpu.c
- * Copyright (C) 2005-2007 Florian octo Forster
+ * Copyright (C) 2005-2010 Florian octo Forster
+ * Copyright (C) 2008 Oleg King
+ * Copyright (C) 2009 Simon Kuhnle
+ * Copyright (C) 2009 Manuel Sanmartin
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
*
* Authors:
* Florian octo Forster <octo at verplant.org>
+ * Oleg King <king2 at kaluga.ru>
+ * Simon Kuhnle <simon at blarzwurst.de>
+ * Manuel Sanmartin
**/
#include "collectd.h"
# include <sys/sysinfo.h>
#endif /* HAVE_LIBKSTAT */
-#ifdef HAVE_SYSCTLBYNAME
+#if (defined(HAVE_SYSCTL) && HAVE_SYSCTL) \
+ || (defined(HAVE_SYSCTLBYNAME) && HAVE_SYSCTLBYNAME)
# ifdef HAVE_SYS_SYSCTL_H
# include <sys/sysctl.h>
# endif
# define CP_IDLE 4
# define CPUSTATES 5
# endif
-#endif /* HAVE_SYSCTLBYNAME */
-
-#ifdef __OpenBSD__
-# ifdef HAVE_SYS_SYSCTL_H
-# include <sys/sysctl.h>
+#endif /* HAVE_SYSCTL || HAVE_SYSCTLBYNAME */
+
+#if HAVE_SYSCTL
+# if defined(CTL_HW) && defined(HW_NCPU) \
+ && defined(CTL_KERN) && defined(KERN_CPTIME) && defined(CPUSTATES)
+# define CAN_USE_SYSCTL 1
+# else
+# define CAN_USE_SYSCTL 0
# endif
-
-# ifdef HAVE_SYS_DKSTAT_H
-# include <sys/dkstat.h>
-# endif
-#endif /* __OpenBSD__ */
+#else
+# define CAN_USE_SYSCTL 0
+#endif
#if HAVE_STATGRAB_H
# include <statgrab.h>
#endif
+# ifdef HAVE_PERFSTAT
+# include <sys/protosw.h>
+# include <libperfstat.h>
+# endif /* HAVE_PERFSTAT */
+
#if !PROCESSOR_CPU_LOAD_INFO && !KERNEL_LINUX && !HAVE_LIBKSTAT \
- && !HAVE_SYSCTLBYNAME && !HAVE_LIBSTATGRAB && !__OpenBSD__
+ && !CAN_USE_SYSCTL && !HAVE_SYSCTLBYNAME && !HAVE_LIBSTATGRAB && !HAVE_PERFSTAT
# error "No applicable input method."
#endif
static int numcpu;
/* #endif HAVE_LIBKSTAT */
-#elif defined(HAVE_SYSCTLBYNAME) || __OpenBSD__
+#elif CAN_USE_SYSCTL
+static int numcpu;
+/* #endif CAN_USE_SYSCTL */
+
+#elif defined(HAVE_SYSCTLBYNAME)
static int numcpu;
+# ifdef HAVE_SYSCTL_KERN_CP_TIMES
+static int maxcpu;
+# endif /* HAVE_SYSCTL_KERN_CP_TIMES */
/* #endif HAVE_SYSCTLBYNAME */
#elif defined(HAVE_LIBSTATGRAB)
/* no variables needed */
-#endif /* HAVE_LIBSTATGRAB */
+/* #endif HAVE_LIBSTATGRAB */
+
+#elif defined(HAVE_PERFSTAT)
+static perfstat_cpu_t *perfcpu;
+static int numcpu;
+static int pnumcpu;
+#endif /* HAVE_PERFSTAT */
static int init (void)
{
DEBUG ("host_processors returned %i %s", (int) cpu_list_len, cpu_list_len == 1 ? "processor" : "processors");
INFO ("cpu plugin: Found %i processor%s.", (int) cpu_list_len, cpu_list_len == 1 ? "" : "s");
- cpu_temp_retry_max = 86400 / interval_g;
+ cpu_temp_retry_max = 86400 / CDTIME_T_TO_TIME_T (interval_g);
/* #endif PROCESSOR_CPU_LOAD_INFO */
#elif defined(HAVE_LIBKSTAT)
ksp[numcpu++] = ksp_chain;
/* #endif HAVE_LIBKSTAT */
-#elif defined (HAVE_SYSCTLBYNAME)
+#elif CAN_USE_SYSCTL
size_t numcpu_size;
+ int mib[2] = {CTL_HW, HW_NCPU};
+ int status;
+ numcpu = 0;
numcpu_size = sizeof (numcpu);
- if (sysctlbyname ("hw.ncpu", &numcpu, &numcpu_size, NULL, 0) < 0)
+ status = sysctl (mib, STATIC_ARRAY_SIZE (mib),
+ &numcpu, &numcpu_size, NULL, 0);
+ if (status == -1)
{
char errbuf[1024];
- WARNING ("cpu plugin: sysctlbyname: %s",
+ WARNING ("cpu plugin: sysctl: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
+/* #endif CAN_USE_SYSCTL */
- if (numcpu != 1)
- NOTICE ("cpu: Only one processor supported when using `sysctlbyname' (found %i)", numcpu);
-/* #endif HAVE_SYSCTLBYNAME */
-
-#elif defined __OpenBSD__
+#elif defined (HAVE_SYSCTLBYNAME)
size_t numcpu_size;
- int mib[2] = {CTL_HW, HW_NCPU};
numcpu_size = sizeof (numcpu);
- if (sysctl (mib, 2, &numcpu, &numcpu_size, NULL, 0) < 0)
+ if (sysctlbyname ("hw.ncpu", &numcpu, &numcpu_size, NULL, 0) < 0)
{
char errbuf[1024];
- WARNING ("cpu plugin: sysctl: %s",
+ WARNING ("cpu plugin: sysctlbyname(hw.ncpu): %s",
+ sstrerror (errno, errbuf, sizeof (errbuf)));
+ return (-1);
+ }
+
+#ifdef HAVE_SYSCTL_KERN_CP_TIMES
+ numcpu_size = sizeof (maxcpu);
+
+ if (sysctlbyname("kern.smp.maxcpus", &maxcpu, &numcpu_size, NULL, 0) < 0)
+ {
+ char errbuf[1024];
+ WARNING ("cpu plugin: sysctlbyname(kern.smp.maxcpus): %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
-/* #endif __OpenBSD__ */
+#else
+ if (numcpu != 1)
+ NOTICE ("cpu: Only one processor supported when using `sysctlbyname' (found %i)", numcpu);
+#endif
+/* #endif HAVE_SYSCTLBYNAME */
#elif defined(HAVE_LIBSTATGRAB)
/* nothing to initialize */
-#endif /* HAVE_LIBSTATGRAB */
+/* #endif HAVE_LIBSTATGRAB */
+
+#elif defined(HAVE_PERFSTAT)
+ /* nothing to initialize */
+#endif /* HAVE_PERFSTAT */
return (0);
} /* int init */
-static void submit (int cpu_num, const char *type_instance, counter_t value)
+static void submit (int cpu_num, const char *type_instance, derive_t value)
{
value_t values[1];
value_list_t vl = VALUE_LIST_INIT;
- values[0].counter = value;
+ values[0].derive = value;
vl.values = values;
vl.values_len = 1;
sstrncpy (vl.host, hostname_g, sizeof (vl.host));
sstrncpy (vl.plugin, "cpu", sizeof (vl.plugin));
- ssnprintf (vl.plugin_instance, sizeof (vl.type_instance),
+ ssnprintf (vl.plugin_instance, sizeof (vl.plugin_instance),
"%i", cpu_num);
sstrncpy (vl.type, "cpu", sizeof (vl.type));
sstrncpy (vl.type_instance, type_instance, sizeof (vl.type_instance));
continue;
}
- submit (cpu, "user", (counter_t) cpu_info.cpu_ticks[CPU_STATE_USER]);
- submit (cpu, "nice", (counter_t) cpu_info.cpu_ticks[CPU_STATE_NICE]);
- submit (cpu, "system", (counter_t) cpu_info.cpu_ticks[CPU_STATE_SYSTEM]);
- submit (cpu, "idle", (counter_t) cpu_info.cpu_ticks[CPU_STATE_IDLE]);
+ submit (cpu, "user", (derive_t) cpu_info.cpu_ticks[CPU_STATE_USER]);
+ submit (cpu, "nice", (derive_t) cpu_info.cpu_ticks[CPU_STATE_NICE]);
+ submit (cpu, "system", (derive_t) cpu_info.cpu_ticks[CPU_STATE_SYSTEM]);
+ submit (cpu, "idle", (derive_t) cpu_info.cpu_ticks[CPU_STATE_IDLE]);
#endif /* PROCESSOR_CPU_LOAD_INFO */
#if PROCESSOR_TEMPERATURE
/*
#elif defined(KERNEL_LINUX)
int cpu;
- counter_t user, nice, syst, idle;
- counter_t wait, intr, sitr; /* sitr == soft interrupt */
+ derive_t user, nice, syst, idle;
+ derive_t wait, intr, sitr; /* sitr == soft interrupt */
FILE *fh;
char buf[1024];
#elif defined(HAVE_LIBKSTAT)
int cpu;
- counter_t user, syst, idle, wait;
+ derive_t user, syst, idle, wait;
static cpu_stat_t cs;
if (kc == NULL)
if (kstat_read (kc, ksp[cpu], &cs) == -1)
continue; /* error message? */
- idle = (counter_t) cs.cpu_sysinfo.cpu[CPU_IDLE];
- user = (counter_t) cs.cpu_sysinfo.cpu[CPU_USER];
- syst = (counter_t) cs.cpu_sysinfo.cpu[CPU_KERNEL];
- wait = (counter_t) cs.cpu_sysinfo.cpu[CPU_WAIT];
+ idle = (derive_t) cs.cpu_sysinfo.cpu[CPU_IDLE];
+ user = (derive_t) cs.cpu_sysinfo.cpu[CPU_USER];
+ syst = (derive_t) cs.cpu_sysinfo.cpu[CPU_KERNEL];
+ wait = (derive_t) cs.cpu_sysinfo.cpu[CPU_WAIT];
submit (ksp[cpu]->ks_instance, "user", user);
submit (ksp[cpu]->ks_instance, "system", syst);
}
/* #endif defined(HAVE_LIBKSTAT) */
-#elif defined __OpenBSD__
- int64_t cpuinfo[numcpu][CPUSTATES];
+#elif CAN_USE_SYSCTL
+ uint64_t cpuinfo[numcpu][CPUSTATES];
size_t cpuinfo_size;
+ int status;
int i;
- if (numcpu > 1) {
- cpuinfo_size = CPUSTATES * sizeof(int64_t);
+ if (numcpu < 1)
+ {
+ ERROR ("cpu plugin: Could not determine number of "
+ "installed CPUs using sysctl(3).");
+ return (-1);
+ }
+ memset (cpuinfo, 0, sizeof (cpuinfo));
+
+#if defined(KERN_CPTIME2)
+ if (numcpu > 1) {
for (i = 0; i < numcpu; i++) {
int mib[] = {CTL_KERN, KERN_CPTIME2, i};
- if (sysctl(mib, 3, cpuinfo[i], &cpuinfo_size, NULL, 0) < 0) {
+ cpuinfo_size = sizeof (cpuinfo[0]);
+
+ status = sysctl (mib, STATIC_ARRAY_SIZE (mib),
+ cpuinfo[i], &cpuinfo_size, NULL, 0);
+ if (status == -1) {
char errbuf[1024];
ERROR ("cpu plugin: sysctl failed: %s.",
sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
}
- } else {
+ }
+ else
+#endif /* defined(KERN_CPTIME2) */
+ {
int mib[] = {CTL_KERN, KERN_CPTIME};
long cpuinfo_tmp[CPUSTATES];
cpuinfo_size = sizeof(cpuinfo_tmp);
- if (sysctl(mib, 2, &cpuinfo_tmp, &cpuinfo_size, NULL, 0) < 0)
+ status = sysctl (mib, STATIC_ARRAY_SIZE (mib),
+ &cpuinfo_tmp, &cpuinfo_size, NULL, 0);
+ if (status == -1)
{
char errbuf[1024];
ERROR ("cpu plugin: sysctl failed: %s.",
sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
+
for(i = 0; i < CPUSTATES; i++) {
cpuinfo[0][i] = cpuinfo_tmp[i];
}
}
+ for (i = 0; i < numcpu; i++) {
+ submit (i, "user", cpuinfo[i][CP_USER]);
+ submit (i, "nice", cpuinfo[i][CP_NICE]);
+ submit (i, "system", cpuinfo[i][CP_SYS]);
+ submit (i, "idle", cpuinfo[i][CP_IDLE]);
+ submit (i, "interrupt", cpuinfo[i][CP_INTR]);
+ }
+/* #endif CAN_USE_SYSCTL */
+#elif defined(HAVE_SYSCTLBYNAME) && defined(HAVE_SYSCTL_KERN_CP_TIMES)
+ long cpuinfo[maxcpu][CPUSTATES];
+ size_t cpuinfo_size;
+ int i;
+
+ memset (cpuinfo, 0, sizeof (cpuinfo));
+
+ cpuinfo_size = sizeof (cpuinfo);
+ if (sysctlbyname("kern.cp_times", &cpuinfo, &cpuinfo_size, NULL, 0) < 0)
+ {
+ char errbuf[1024];
+ ERROR ("cpu plugin: sysctlbyname failed: %s.",
+ sstrerror (errno, errbuf, sizeof (errbuf)));
+ return (-1);
+ }
+
for (i = 0; i < numcpu; i++) {
submit (i, "user", cpuinfo[i][CP_USER]);
submit (i, "nice", cpuinfo[i][CP_NICE]);
submit (i, "idle", cpuinfo[i][CP_IDLE]);
submit (i, "interrupt", cpuinfo[i][CP_INTR]);
}
-/* #endif __OpenBSD__ */
-
+/* #endif HAVE_SYSCTL_KERN_CP_TIMES */
#elif defined(HAVE_SYSCTLBYNAME)
long cpuinfo[CPUSTATES];
size_t cpuinfo_size;
/* #endif HAVE_SYSCTLBYNAME */
#elif defined(HAVE_LIBSTATGRAB)
- sg_cpu_stats *cs;
- cs = sg_get_cpu_stats ();
-
- if (cs == NULL)
- {
- ERROR ("cpu plugin: sg_get_cpu_stats failed.");
- return (-1);
- }
-
- submit (0, "idle", (counter_t) cs->idle);
- submit (0, "nice", (counter_t) cs->nice);
- submit (0, "swap", (counter_t) cs->swap);
- submit (0, "system", (counter_t) cs->kernel);
- submit (0, "user", (counter_t) cs->user);
- submit (0, "wait", (counter_t) cs->iowait);
-#endif /* HAVE_LIBSTATGRAB */
+ sg_cpu_stats *cs;
+ cs = sg_get_cpu_stats ();
+
+ if (cs == NULL)
+ {
+ ERROR ("cpu plugin: sg_get_cpu_stats failed.");
+ return (-1);
+ }
+
+ submit (0, "idle", (derive_t) cs->idle);
+ submit (0, "nice", (derive_t) cs->nice);
+ submit (0, "swap", (derive_t) cs->swap);
+ submit (0, "system", (derive_t) cs->kernel);
+ submit (0, "user", (derive_t) cs->user);
+ submit (0, "wait", (derive_t) cs->iowait);
+/* #endif HAVE_LIBSTATGRAB */
+
+#elif defined(HAVE_PERFSTAT)
+ perfstat_id_t id;
+ int i, cpus;
+
+ numcpu = perfstat_cpu(NULL, NULL, sizeof(perfstat_cpu_t), 0);
+ if(numcpu == -1)
+ {
+ char errbuf[1024];
+ WARNING ("cpu plugin: perfstat_cpu: %s",
+ sstrerror (errno, errbuf, sizeof (errbuf)));
+ return (-1);
+ }
+
+ if (pnumcpu != numcpu || perfcpu == NULL)
+ {
+ if (perfcpu != NULL)
+ free(perfcpu);
+ perfcpu = malloc(numcpu * sizeof(perfstat_cpu_t));
+ }
+ pnumcpu = numcpu;
+
+ id.name[0] = '\0';
+ if ((cpus = perfstat_cpu(&id, perfcpu, sizeof(perfstat_cpu_t), numcpu)) < 0)
+ {
+ char errbuf[1024];
+ WARNING ("cpu plugin: perfstat_cpu: %s",
+ sstrerror (errno, errbuf, sizeof (errbuf)));
+ return (-1);
+ }
+
+ for (i = 0; i < cpus; i++)
+ {
+ submit (i, "idle", (derive_t) perfcpu[i].idle);
+ submit (i, "system", (derive_t) perfcpu[i].sys);
+ submit (i, "user", (derive_t) perfcpu[i].user);
+ submit (i, "wait", (derive_t) perfcpu[i].wait);
+ }
+#endif /* HAVE_PERFSTAT */
return (0);
}