| 1 |
/** |
| 2 |
* collectd - src/lpar.c |
| 3 |
* Copyright (C) 2010 Aurélien Reynaud |
| 4 |
* |
| 5 |
* This program is free software; you can redistribute it and/or modify it |
| 6 |
* under the terms of the GNU General Public License as published by the |
| 7 |
* Free Software Foundation; only version 2 of the License is applicable. |
| 8 |
* |
| 9 |
* This program is distributed in the hope that it will be useful, but |
| 10 |
* WITHOUT ANY WARRANTY; without even the implied warranty of |
| 11 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 12 |
* General Public License for more details. |
| 13 |
* |
| 14 |
* You should have received a copy of the GNU General Public License along |
| 15 |
* with this program; if not, write to the Free Software Foundation, Inc., |
| 16 |
* 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
| 17 |
* |
| 18 |
* Authors: |
| 19 |
* Aurélien Reynaud <collectd at wattapower.net> |
| 20 |
**/ |
| 21 |
|
| 22 |
#include "collectd.h" |
| 23 |
|
| 24 |
#include "plugin.h" |
| 25 |
#include "utils/common/common.h" |
| 26 |
|
| 27 |
#include <libperfstat.h> |
| 28 |
#include <sys/protosw.h> |
| 29 |
#include <sys/utsname.h> |
| 30 |
|
| 31 |
/* XINTFRAC was defined in libperfstat.h somewhere between AIX 5.3 and 6.1 */ |
| 32 |
#ifndef XINTFRAC |
| 33 |
#include <sys/systemcfg.h> |
| 34 |
#define XINTFRAC \ |
| 35 |
((double)(_system_configuration.Xint) / (double)(_system_configuration.Xfrac)) |
| 36 |
#endif |
| 37 |
|
| 38 |
#define CLOCKTICKS_TO_TICKS(cticks) ((cticks) / XINTFRAC) |
| 39 |
|
| 40 |
static const char *config_keys[] = {"CpuPoolStats", "ReportBySerial"}; |
| 41 |
static int config_keys_num = STATIC_ARRAY_SIZE(config_keys); |
| 42 |
|
| 43 |
static bool pool_stats; |
| 44 |
static bool report_by_serial; |
| 45 |
#if PERFSTAT_SUPPORTS_DONATION |
| 46 |
static bool donate_flag; |
| 47 |
#endif |
| 48 |
static char serial[SYS_NMLN]; |
| 49 |
|
| 50 |
static perfstat_partition_total_t lparstats_old; |
| 51 |
|
| 52 |
static int lpar_config(const char *key, const char *value) { |
| 53 |
if (strcasecmp("CpuPoolStats", key) == 0) { |
| 54 |
if (IS_TRUE(value)) |
| 55 |
pool_stats = true; |
| 56 |
else |
| 57 |
pool_stats = false; |
| 58 |
} else if (strcasecmp("ReportBySerial", key) == 0) { |
| 59 |
if (IS_TRUE(value)) |
| 60 |
report_by_serial = true; |
| 61 |
else |
| 62 |
report_by_serial = false; |
| 63 |
} else { |
| 64 |
return -1; |
| 65 |
} |
| 66 |
|
| 67 |
return 0; |
| 68 |
} /* int lpar_config */ |
| 69 |
|
| 70 |
static int lpar_init(void) { |
| 71 |
int status; |
| 72 |
|
| 73 |
/* Retrieve the initial metrics. Returns the number of structures filled. */ |
| 74 |
status = perfstat_partition_total(/* name = */ NULL, /* (must be NULL) */ |
| 75 |
&lparstats_old, |
| 76 |
sizeof(perfstat_partition_total_t), |
| 77 |
/* number = */ 1 /* (must be 1) */); |
| 78 |
if (status != 1) { |
| 79 |
ERROR("lpar plugin: perfstat_partition_total failed: %s (%i)", STRERRNO, |
| 80 |
status); |
| 81 |
return -1; |
| 82 |
} |
| 83 |
|
| 84 |
#if PERFSTAT_SUPPORTS_DONATION |
| 85 |
if (!lparstats_old.type.b.shared_enabled && |
| 86 |
lparstats_old.type.b.donate_enabled) { |
| 87 |
donate_flag = true; |
| 88 |
} |
| 89 |
#endif |
| 90 |
|
| 91 |
if (pool_stats && !lparstats_old.type.b.pool_util_authority) { |
| 92 |
WARNING("lpar plugin: This partition does not have pool authority. " |
| 93 |
"Disabling CPU pool statistics collection."); |
| 94 |
pool_stats = false; |
| 95 |
} |
| 96 |
|
| 97 |
return 0; |
| 98 |
} /* int lpar_init */ |
| 99 |
|
| 100 |
static void lpar_submit(const char *type_instance, double value) { |
| 101 |
value_list_t vl = VALUE_LIST_INIT; |
| 102 |
|
| 103 |
vl.values = &(value_t){.gauge = value}; |
| 104 |
vl.values_len = 1; |
| 105 |
if (report_by_serial) { |
| 106 |
sstrncpy(vl.host, serial, sizeof(vl.host)); |
| 107 |
sstrncpy(vl.plugin_instance, hostname_g, sizeof(vl.plugin)); |
| 108 |
} |
| 109 |
sstrncpy(vl.plugin, "lpar", sizeof(vl.plugin)); |
| 110 |
sstrncpy(vl.type, "vcpu", sizeof(vl.type)); |
| 111 |
sstrncpy(vl.type_instance, type_instance, sizeof(vl.type_instance)); |
| 112 |
|
| 113 |
plugin_dispatch_values(&vl); |
| 114 |
} /* void lpar_submit */ |
| 115 |
|
| 116 |
static int lpar_read(void) { |
| 117 |
perfstat_partition_total_t lparstats; |
| 118 |
int status; |
| 119 |
struct utsname name; |
| 120 |
u_longlong_t ticks; |
| 121 |
u_longlong_t user_ticks, syst_ticks, wait_ticks, idle_ticks; |
| 122 |
u_longlong_t consumed_ticks; |
| 123 |
double entitled_proc_capacity; |
| 124 |
|
| 125 |
/* An LPAR has the same serial number as the physical system it is currently |
| 126 |
running on. It is a convenient way of tracking LPARs as they are moved |
| 127 |
from chassis to chassis through Live Partition Mobility (LPM). */ |
| 128 |
if (uname(&name) != 0) { |
| 129 |
ERROR("lpar plugin: uname failed."); |
| 130 |
return -1; |
| 131 |
} |
| 132 |
sstrncpy(serial, name.machine, sizeof(serial)); |
| 133 |
|
| 134 |
/* Retrieve the current metrics. Returns the number of structures filled. */ |
| 135 |
status = |
| 136 |
perfstat_partition_total(/* name = */ NULL, /* (must be NULL) */ |
| 137 |
&lparstats, sizeof(perfstat_partition_total_t), |
| 138 |
/* number = */ 1 /* (must be 1) */); |
| 139 |
if (status != 1) { |
| 140 |
ERROR("lpar plugin: perfstat_partition_total failed: %s (%i)", STRERRNO, |
| 141 |
status); |
| 142 |
return -1; |
| 143 |
} |
| 144 |
|
| 145 |
/* Number of ticks since we last run. */ |
| 146 |
ticks = lparstats.timebase_last - lparstats_old.timebase_last; |
| 147 |
if (ticks == 0) { |
| 148 |
/* The stats have not been updated. Return now to avoid |
| 149 |
* dividing by zero */ |
| 150 |
return 0; |
| 151 |
} |
| 152 |
|
| 153 |
/* |
| 154 |
* On a shared partition, we're "entitled" to a certain amount of |
| 155 |
* processing power, for example 250/100 of a physical CPU. Processing |
| 156 |
* capacity not used by the partition may be assigned to a different |
| 157 |
* partition by the hypervisor, so "idle" is hopefully a very small |
| 158 |
* number. |
| 159 |
* |
| 160 |
* A dedicated partition may donate its CPUs to another partition and |
| 161 |
* may steal ticks from somewhere else (another partition or maybe the |
| 162 |
* shared pool, I don't know --octo). |
| 163 |
*/ |
| 164 |
|
| 165 |
/* entitled_proc_capacity is in 1/100th of a CPU */ |
| 166 |
entitled_proc_capacity = 0.01 * ((double)lparstats.entitled_proc_capacity); |
| 167 |
lpar_submit("entitled", entitled_proc_capacity); |
| 168 |
|
| 169 |
/* The number of ticks actually spent in the various states */ |
| 170 |
user_ticks = lparstats.puser - lparstats_old.puser; |
| 171 |
syst_ticks = lparstats.psys - lparstats_old.psys; |
| 172 |
wait_ticks = lparstats.pwait - lparstats_old.pwait; |
| 173 |
idle_ticks = lparstats.pidle - lparstats_old.pidle; |
| 174 |
consumed_ticks = user_ticks + syst_ticks + wait_ticks + idle_ticks; |
| 175 |
|
| 176 |
lpar_submit("user", (double)user_ticks / (double)ticks); |
| 177 |
lpar_submit("system", (double)syst_ticks / (double)ticks); |
| 178 |
lpar_submit("wait", (double)wait_ticks / (double)ticks); |
| 179 |
lpar_submit("idle", (double)idle_ticks / (double)ticks); |
| 180 |
|
| 181 |
#if PERFSTAT_SUPPORTS_DONATION |
| 182 |
if (donate_flag) { |
| 183 |
/* donated => ticks given to another partition |
| 184 |
* stolen => ticks received from another partition */ |
| 185 |
u_longlong_t idle_donated_ticks, busy_donated_ticks; |
| 186 |
u_longlong_t idle_stolen_ticks, busy_stolen_ticks; |
| 187 |
|
| 188 |
/* FYI: PURR == Processor Utilization of Resources Register |
| 189 |
* SPURR == Scaled PURR */ |
| 190 |
idle_donated_ticks = |
| 191 |
lparstats.idle_donated_purr - lparstats_old.idle_donated_purr; |
| 192 |
busy_donated_ticks = |
| 193 |
lparstats.busy_donated_purr - lparstats_old.busy_donated_purr; |
| 194 |
idle_stolen_ticks = |
| 195 |
lparstats.idle_stolen_purr - lparstats_old.idle_stolen_purr; |
| 196 |
busy_stolen_ticks = |
| 197 |
lparstats.busy_stolen_purr - lparstats_old.busy_stolen_purr; |
| 198 |
|
| 199 |
lpar_submit("idle_donated", (double)idle_donated_ticks / (double)ticks); |
| 200 |
lpar_submit("busy_donated", (double)busy_donated_ticks / (double)ticks); |
| 201 |
lpar_submit("idle_stolen", (double)idle_stolen_ticks / (double)ticks); |
| 202 |
lpar_submit("busy_stolen", (double)busy_stolen_ticks / (double)ticks); |
| 203 |
|
| 204 |
/* Donated ticks will be accounted for as stolen ticks in other LPARs */ |
| 205 |
consumed_ticks += idle_stolen_ticks + busy_stolen_ticks; |
| 206 |
} |
| 207 |
#endif |
| 208 |
|
| 209 |
lpar_submit("consumed", (double)consumed_ticks / (double)ticks); |
| 210 |
|
| 211 |
if (pool_stats) { |
| 212 |
char typinst[DATA_MAX_NAME_LEN]; |
| 213 |
u_longlong_t pool_idle_cticks; |
| 214 |
double pool_idle_cpus; |
| 215 |
double pool_busy_cpus; |
| 216 |
|
| 217 |
/* We're calculating "busy" from "idle" and the total number of |
| 218 |
* CPUs, because the "busy" member didn't exist in early versions |
| 219 |
* of libperfstat. It was added somewhere between AIX 5.3 ML5 and ML9. */ |
| 220 |
pool_idle_cticks = lparstats.pool_idle_time - lparstats_old.pool_idle_time; |
| 221 |
pool_idle_cpus = |
| 222 |
CLOCKTICKS_TO_TICKS((double)pool_idle_cticks) / (double)ticks; |
| 223 |
pool_busy_cpus = ((double)lparstats.phys_cpus_pool) - pool_idle_cpus; |
| 224 |
if (pool_busy_cpus < 0.0) |
| 225 |
pool_busy_cpus = 0.0; |
| 226 |
|
| 227 |
ssnprintf(typinst, sizeof(typinst), "pool-%X-busy", lparstats.pool_id); |
| 228 |
lpar_submit(typinst, pool_busy_cpus); |
| 229 |
|
| 230 |
ssnprintf(typinst, sizeof(typinst), "pool-%X-idle", lparstats.pool_id); |
| 231 |
lpar_submit(typinst, pool_idle_cpus); |
| 232 |
} |
| 233 |
|
| 234 |
memcpy(&lparstats_old, &lparstats, sizeof(lparstats_old)); |
| 235 |
|
| 236 |
return 0; |
| 237 |
} /* int lpar_read */ |
| 238 |
|
| 239 |
void module_register(void) { |
| 240 |
plugin_register_config("lpar", lpar_config, config_keys, config_keys_num); |
| 241 |
plugin_register_init("lpar", lpar_init); |
| 242 |
plugin_register_read("lpar", lpar_read); |
| 243 |
} /* void module_register */ |