#define COLLECTD_CPU_STATE_INTERRUPT 5
#define COLLECTD_CPU_STATE_SOFTIRQ 6
#define COLLECTD_CPU_STATE_STEAL 7
-#define COLLECTD_CPU_STATE_IDLE 8
-#define COLLECTD_CPU_STATE_ACTIVE 9 /* sum of (!idle) */
-#define COLLECTD_CPU_STATE_MAX 10 /* #states */
+#define COLLECTD_CPU_STATE_GUEST 8
+#define COLLECTD_CPU_STATE_GUEST_NICE 9
+#define COLLECTD_CPU_STATE_IDLE 10
+#define COLLECTD_CPU_STATE_ACTIVE 11 /* sum of (!idle) */
+#define COLLECTD_CPU_STATE_MAX 12 /* #states */
#if HAVE_STATGRAB_H
#include <statgrab.h>
#error "No applicable input method."
#endif
-static const char *cpu_state_names[] = {"user", "system", "wait", "nice",
- "swap", "interrupt", "softirq", "steal",
- "idle", "active"};
+static const char *cpu_state_names[] = {
+ "user", "system", "wait", "nice", "swap", "interrupt",
+ "softirq", "steal", "guest", "guest_nice", "idle", "active"};
#ifdef PROCESSOR_CPU_LOAD_INFO
static mach_port_t port_host;
/* #endif KERNEL_LINUX */
#elif defined(HAVE_LIBKSTAT)
+#if HAVE_KSTAT_H
+#include <kstat.h>
+#endif
/* colleague tells me that Sun doesn't sell systems with more than 100 or so
* CPUs.. */
#define MAX_NUMCPU 256
struct cpu_state_s {
value_to_rate_state_t conv;
gauge_t rate;
- _Bool has_value;
+ bool has_value;
};
typedef struct cpu_state_s cpu_state_t;
-static cpu_state_t *cpu_states = NULL;
-static size_t cpu_states_num = 0; /* #cpu_states allocated */
+static cpu_state_t *cpu_states;
+static size_t cpu_states_num; /* #cpu_states allocated */
/* Highest CPU number in the current iteration. Used by the dispatch logic to
* determine how many CPUs there were. Reset to 0 by cpu_reset(). */
-static size_t global_cpu_num = 0;
-
-static _Bool report_by_cpu = 1;
-static _Bool report_by_state = 1;
-static _Bool report_percent = 0;
-static _Bool report_num_cpu = 0;
-
-static const char *config_keys[] = {"ReportByCpu", "ReportByState",
- "ReportNumCpu", "ValuesPercentage"};
+static size_t global_cpu_num;
+
+static bool report_by_cpu = true;
+static bool report_by_state = true;
+static bool report_percent;
+static bool report_num_cpu;
+static bool report_guest;
+static bool subtract_guest = true;
+
+static const char *config_keys[] = {"ReportByCpu", "ReportByState",
+ "ReportNumCpu", "ValuesPercentage",
+ "ReportGuestState", "SubtractGuestState"};
static int config_keys_num = STATIC_ARRAY_SIZE(config_keys);
static int cpu_config(char const *key, char const *value) /* {{{ */
{
if (strcasecmp(key, "ReportByCpu") == 0)
- report_by_cpu = IS_TRUE(value) ? 1 : 0;
+ report_by_cpu = IS_TRUE(value);
else if (strcasecmp(key, "ValuesPercentage") == 0)
- report_percent = IS_TRUE(value) ? 1 : 0;
+ report_percent = IS_TRUE(value);
else if (strcasecmp(key, "ReportByState") == 0)
- report_by_state = IS_TRUE(value) ? 1 : 0;
+ report_by_state = IS_TRUE(value);
else if (strcasecmp(key, "ReportNumCpu") == 0)
- report_num_cpu = IS_TRUE(value) ? 1 : 0;
+ report_num_cpu = IS_TRUE(value);
+ else if (strcasecmp(key, "ReportGuestState") == 0)
+ report_guest = IS_TRUE(value);
+ else if (strcasecmp(key, "SubtractGuestState") == 0)
+ subtract_guest = IS_TRUE(value);
else
return -1;
status = sysctl(mib, STATIC_ARRAY_SIZE(mib), &numcpu, &numcpu_size, NULL, 0);
if (status == -1) {
- char errbuf[1024];
- WARNING("cpu plugin: sysctl: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
+ WARNING("cpu plugin: sysctl: %s", STRERRNO);
return -1;
}
/* #endif CAN_USE_SYSCTL */
numcpu_size = sizeof(numcpu);
if (sysctlbyname("hw.ncpu", &numcpu, &numcpu_size, NULL, 0) < 0) {
- char errbuf[1024];
- WARNING("cpu plugin: sysctlbyname(hw.ncpu): %s",
- sstrerror(errno, errbuf, sizeof(errbuf)));
+ WARNING("cpu plugin: sysctlbyname(hw.ncpu): %s", STRERRNO);
return -1;
}
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)));
+ WARNING("cpu plugin: sysctlbyname(kern.smp.maxcpus): %s", STRERRNO);
return -1;
}
#else
sizeof(vl.type_instance));
if (cpu_num >= 0) {
- ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%i", cpu_num);
+ snprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%i", cpu_num);
}
plugin_dispatch_values(&vl);
}
}
if (!isnan(this_cpu_states[COLLECTD_CPU_STATE_ACTIVE].rate))
- this_cpu_states[COLLECTD_CPU_STATE_ACTIVE].has_value = 1;
+ this_cpu_states[COLLECTD_CPU_STATE_ACTIVE].has_value = true;
RATE_ADD(sum_by_state[COLLECTD_CPU_STATE_ACTIVE],
this_cpu_states[COLLECTD_CPU_STATE_ACTIVE].rate);
perfstat_cpu_total_t cputotal = {0};
if (!perfstat_cpu_total(NULL, &cputotal, sizeof(cputotal), 1)) {
- char errbuf[1024];
- WARNING("cpu plugin: perfstat_cpu_total: %s",
- sstrerror(errno, errbuf, sizeof(errbuf)));
+ WARNING("cpu plugin: perfstat_cpu_total: %s", STRERRNO);
return;
}
static void cpu_reset(void) /* {{{ */
{
for (size_t i = 0; i < cpu_states_num; i++)
- cpu_states[i].has_value = 0;
+ cpu_states[i].has_value = false;
global_cpu_num = 0;
} /* }}} void cpu_reset */
static void cpu_commit(void) /* {{{ */
{
gauge_t global_rates[COLLECTD_CPU_STATE_MAX] = {
- NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN /* Batman! */
+ NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN /* Batman! */
};
if (report_num_cpu)
for (size_t cpu_num = 0; cpu_num < global_cpu_num; cpu_num++) {
cpu_state_t *this_cpu_states = get_cpu_state(cpu_num, 0);
- gauge_t local_rates[COLLECTD_CPU_STATE_MAX] = {NAN, NAN, NAN, NAN, NAN,
- NAN, NAN, NAN, NAN, NAN};
+ gauge_t local_rates[COLLECTD_CPU_STATE_MAX] = {
+ NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN};
for (size_t state = 0; state < COLLECTD_CPU_STATE_MAX; state++)
if (this_cpu_states[state].has_value)
return status;
s->rate = rate;
- s->has_value = 1;
+ s->has_value = true;
return 0;
} /* }}} int cpu_stage */
FILE *fh;
char buf[1024];
- char *fields[9];
+ char *fields[11];
int numfields;
if ((fh = fopen("/proc/stat", "r")) == NULL) {
- char errbuf[1024];
- ERROR("cpu plugin: fopen (/proc/stat) failed: %s",
- sstrerror(errno, errbuf, sizeof(errbuf)));
+ ERROR("cpu plugin: fopen (/proc/stat) failed: %s", STRERRNO);
return -1;
}
if ((buf[3] < '0') || (buf[3] > '9'))
continue;
- numfields = strsplit(buf, fields, 9);
+ numfields = strsplit(buf, fields, STATIC_ARRAY_SIZE(fields));
if (numfields < 5)
continue;
cpu = atoi(fields[0] + 3);
- cpu_stage(cpu, COLLECTD_CPU_STATE_USER, (derive_t)atoll(fields[1]), now);
- cpu_stage(cpu, COLLECTD_CPU_STATE_NICE, (derive_t)atoll(fields[2]), now);
+ /* Do not stage User and Nice immediately: we may need to alter them later:
+ */
+ long long user_value = atoll(fields[1]);
+ long long nice_value = atoll(fields[2]);
cpu_stage(cpu, COLLECTD_CPU_STATE_SYSTEM, (derive_t)atoll(fields[3]), now);
cpu_stage(cpu, COLLECTD_CPU_STATE_IDLE, (derive_t)atoll(fields[4]), now);
now);
cpu_stage(cpu, COLLECTD_CPU_STATE_SOFTIRQ, (derive_t)atoll(fields[7]),
now);
+ }
- if (numfields >= 9)
- cpu_stage(cpu, COLLECTD_CPU_STATE_STEAL, (derive_t)atoll(fields[8]),
- now);
+ if (numfields >= 9) { /* Steal (since Linux 2.6.11) */
+ cpu_stage(cpu, COLLECTD_CPU_STATE_STEAL, (derive_t)atoll(fields[8]), now);
}
+
+ if (numfields >= 10) { /* Guest (since Linux 2.6.24) */
+ if (report_guest) {
+ long long value = atoll(fields[9]);
+ cpu_stage(cpu, COLLECTD_CPU_STATE_GUEST, (derive_t)value, now);
+ /* Guest is included in User; optionally subtract Guest from User: */
+ if (subtract_guest) {
+ user_value -= value;
+ if (user_value < 0)
+ user_value = 0;
+ }
+ }
+ }
+
+ if (numfields >= 11) { /* Guest_nice (since Linux 2.6.33) */
+ if (report_guest) {
+ long long value = atoll(fields[10]);
+ cpu_stage(cpu, COLLECTD_CPU_STATE_GUEST_NICE, (derive_t)value, now);
+ /* Guest_nice is included in Nice; optionally subtract Guest_nice from
+ Nice: */
+ if (subtract_guest) {
+ nice_value -= value;
+ if (nice_value < 0)
+ nice_value = 0;
+ }
+ }
+ }
+
+ /* Eventually stage User and Nice: */
+ cpu_stage(cpu, COLLECTD_CPU_STATE_USER, (derive_t)user_value, now);
+ cpu_stage(cpu, COLLECTD_CPU_STATE_NICE, (derive_t)nice_value, now);
}
fclose(fh);
/* }}} #endif defined(KERNEL_LINUX) */
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)));
+ ERROR("cpu plugin: sysctl failed: %s.", STRERRNO);
return -1;
}
}
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)));
+ ERROR("cpu plugin: sysctl failed: %s.", STRERRNO);
return -1;
}
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)));
+ ERROR("cpu plugin: sysctlbyname failed: %s.", STRERRNO);
return -1;
}
cpuinfo_size = sizeof(cpuinfo);
if (sysctlbyname("kern.cp_time", &cpuinfo, &cpuinfo_size, NULL, 0) < 0) {
- char errbuf[1024];
- ERROR("cpu plugin: sysctlbyname failed: %s.",
- sstrerror(errno, errbuf, sizeof(errbuf)));
+ ERROR("cpu plugin: sysctlbyname failed: %s.", STRERRNO);
return -1;
}
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)));
+ WARNING("cpu plugin: perfstat_cpu: %s", STRERRNO);
return -1;
}
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)));
+ WARNING("cpu plugin: perfstat_cpu: %s", STRERRNO);
return -1;
}
projects / collectd.git / blobdiff