X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Flpar.c;h=4d534476f62c76754433b2c73d313967595e5843;hb=6e0ffb3d9edba6a4b819ace076aea0e9b5fcea51;hp=cf9f94b78405ae108a8be074d59dfd20248049c3;hpb=2254a769156fd0461e2fc5e33dedf17c16c53057;p=collectd.git diff --git a/src/lpar.c b/src/lpar.c index cf9f94b7..4d534476 100644 --- a/src/lpar.c +++ b/src/lpar.c @@ -16,73 +16,41 @@ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * * Authors: - * Aurelien Reynaud + * Aurélien Reynaud **/ #include "collectd.h" #include "common.h" #include "plugin.h" + #include #include -#include #include +/* XINTFRAC was defined in libperfstat.h somewhere between AIX 5.3 and 6.1 */ #ifndef XINTFRAC +# include # define XINTFRAC ((double)(_system_configuration.Xint) / \ (double)(_system_configuration.Xfrac)) #endif -/* Max length of the type instance string */ -#define TYPE_INST_LEN (sizeof("lpar--total") + 2*sizeof(int) + 1) +#define CLOCKTICKS_TO_TICKS(cticks) ((cticks) / XINTFRAC) static const char *config_keys[] = { - "CpuPoolStats" + "CpuPoolStats", + "ReportBySerial" }; static int config_keys_num = STATIC_ARRAY_SIZE (config_keys); -static int pool_stats = 0; - -/* As an LPAR can be moved transparently across physical systems - * through Live Partition Mobility (LPM), and the resources we are - * monitoring are tied to the underlying hardware, we need to keep - * track on which physical server we are currently on. This is done - * through the plugin instance which holds the chassis' serial. - */ -static char plugin_inst[SYS_NMLN]; - -static u_longlong_t last_time_base; -static u_longlong_t last_pcpu_user, - last_pcpu_sys, - last_pcpu_idle, - last_pcpu_wait; -static u_longlong_t last_pool_idle_time = 0; -static u_longlong_t last_idle_donated_purr = 0, - last_busy_donated_purr = 0, - last_busy_stolen_purr = 0, - last_idle_stolen_purr = 0; -static int donate_flag = 0; - - -/* Save the current values for the next iteration */ -static void save_last_values (perfstat_partition_total_t *lparstats) -{ - last_time_base = lparstats->timebase_last; - last_pcpu_user = lparstats->puser; - last_pcpu_sys = lparstats->psys; - last_pcpu_idle = lparstats->pidle; - last_pcpu_wait = lparstats->pwait; - - if (donate_flag) - { - last_idle_donated_purr = lparstats->idle_donated_purr; - last_busy_donated_purr = lparstats->busy_donated_purr; - last_busy_stolen_purr = lparstats->busy_stolen_purr; - last_idle_stolen_purr = lparstats->idle_stolen_purr; - } +static _Bool pool_stats = 0; +static _Bool report_by_serial = 0; +#if PERFSTAT_SUPPORTS_DONATION +static _Bool donate_flag = 0; +#endif +static char serial[SYS_NMLN]; - last_pool_idle_time = lparstats->pool_idle_time; -} +static perfstat_partition_total_t lparstats_old; static int lpar_config (const char *key, const char *value) { @@ -93,6 +61,13 @@ static int lpar_config (const char *key, const char *value) else pool_stats = 0; } + else if (strcasecmp ("ReportBySerial", key) == 0) + { + if (IS_TRUE (value)) + report_by_serial = 1; + else + report_by_serial = 0; + } else { return (-1); @@ -103,23 +78,35 @@ static int lpar_config (const char *key, const char *value) static int lpar_init (void) { - perfstat_partition_total_t lparstats; + int status; - /* retrieve the initial metrics */ - if (!perfstat_partition_total (NULL, &lparstats, - sizeof (perfstat_partition_total_t), 1)) + /* Retrieve the initial metrics. Returns the number of structures filled. */ + status = perfstat_partition_total (/* name = */ NULL, /* (must be NULL) */ + &lparstats_old, sizeof (perfstat_partition_total_t), + /* number = */ 1 /* (must be 1) */); + if (status != 1) { - ERROR ("lpar plugin: perfstat_partition_total failed."); + char errbuf[1024]; + ERROR ("lpar plugin: perfstat_partition_total failed: %s (%i)", + sstrerror (errno, errbuf, sizeof (errbuf)), + status); return (-1); } - if (!lparstats.type.b.shared_enabled && lparstats.type.b.donate_enabled) +#if PERFSTAT_SUPPORTS_DONATION + if (!lparstats_old.type.b.shared_enabled + && lparstats_old.type.b.donate_enabled) { donate_flag = 1; } +#endif - /* save the initial data */ - save_last_values (&lparstats); + if (pool_stats && !lparstats_old.type.b.pool_util_authority) + { + WARNING ("lpar plugin: This partition does not have pool authority. " + "Disabling CPU pool statistics collection."); + pool_stats = 0; + } return (0); } /* int lpar_init */ @@ -133,98 +120,143 @@ static void lpar_submit (const char *type_instance, double value) vl.values = values; vl.values_len = 1; - sstrncpy (vl.host, hostname_g, sizeof (vl.host)); + if (report_by_serial) + { + sstrncpy (vl.host, serial, sizeof (vl.host)); + sstrncpy (vl.plugin_instance, hostname_g, sizeof (vl.plugin)); + } + else + { + sstrncpy (vl.host, hostname_g, sizeof (vl.host)); + } sstrncpy (vl.plugin, "lpar", sizeof (vl.plugin)); - sstrncpy (vl.plugin_instance, plugin_inst, sizeof (vl.plugin)); - sstrncpy (vl.type, "lpar_pcpu", sizeof (vl.type)); + sstrncpy (vl.type, "vcpu", sizeof (vl.type)); sstrncpy (vl.type_instance, type_instance, sizeof (vl.type_instance)); plugin_dispatch_values (&vl); -} +} /* void lpar_submit */ static int lpar_read (void) { - u_longlong_t dlt_pcpu_user, dlt_pcpu_sys, dlt_pcpu_idle, dlt_pcpu_wait; - u_longlong_t delta_time_base; perfstat_partition_total_t lparstats; + int status; struct utsname name; - - /* retrieve the current physical server's id and build the plugin - instance's name */ + u_longlong_t ticks; + u_longlong_t user_ticks, syst_ticks, wait_ticks, idle_ticks; + u_longlong_t consumed_ticks; + double entitled_proc_capacity; + + /* An LPAR has the same serial number as the physical system it is currently + running on. It is a convenient way of tracking LPARs as they are moved + from chassis to chassis through Live Partition Mobility (LPM). */ if (uname (&name) != 0) { ERROR ("lpar plugin: uname failed."); return (-1); } - sstrncpy (plugin_inst, name.machine, sizeof (plugin_inst)); + sstrncpy (serial, name.machine, sizeof (serial)); - /* retrieve the current metrics */ - if (!perfstat_partition_total (NULL, &lparstats, - sizeof (perfstat_partition_total_t), 1)) + /* Retrieve the current metrics. Returns the number of structures filled. */ + status = perfstat_partition_total (/* name = */ NULL, /* (must be NULL) */ + &lparstats, sizeof (perfstat_partition_total_t), + /* number = */ 1 /* (must be 1) */); + if (status != 1) { - ERROR ("lpar plugin: perfstat_partition_total failed."); + char errbuf[1024]; + ERROR ("lpar plugin: perfstat_partition_total failed: %s (%i)", + sstrerror (errno, errbuf, sizeof (errbuf)), + status); return (-1); } - delta_time_base = lparstats.timebase_last - last_time_base; - if (delta_time_base == 0) + /* Number of ticks since we last run. */ + ticks = lparstats.timebase_last - lparstats_old.timebase_last; + if (ticks == 0) { - /* The system stats have not been updated since last time */ + /* The stats have not been updated. Return now to avoid + * dividing by zero */ return (0); } - dlt_pcpu_user = lparstats.puser - last_pcpu_user; - dlt_pcpu_sys = lparstats.psys - last_pcpu_sys; - dlt_pcpu_idle = lparstats.pidle - last_pcpu_idle; - dlt_pcpu_wait = lparstats.pwait - last_pcpu_wait; - - lpar_submit ("user", (double)dlt_pcpu_user / delta_time_base); - lpar_submit ("sys", (double)dlt_pcpu_sys / delta_time_base); - lpar_submit ("wait", (double)dlt_pcpu_wait / delta_time_base); - lpar_submit ("idle", (double)dlt_pcpu_idle / delta_time_base); - lpar_submit ("ent", (double)lparstats.entitled_proc_capacity / 100.0); - lpar_submit ("max", (double)lparstats.max_proc_capacity / 100.0); - lpar_submit ("min", (double)lparstats.min_proc_capacity / 100.0); - + /* + * On a shared partition, we're "entitled" to a certain amount of + * processing power, for example 250/100 of a physical CPU. Processing + * capacity not used by the partition may be assigned to a different + * partition by the hypervisor, so "idle" is hopefully a very small + * number. + * + * A dedicated partition may donate its CPUs to another partition and + * may steal ticks from somewhere else (another partition or maybe the + * shared pool, I don't know --octo). + */ + + /* entitled_proc_capacity is in 1/100th of a CPU */ + entitled_proc_capacity = 0.01 * ((double) lparstats.entitled_proc_capacity); + lpar_submit ("entitled", entitled_proc_capacity); + + /* The number of ticks actually spent in the various states */ + user_ticks = lparstats.puser - lparstats_old.puser; + syst_ticks = lparstats.psys - lparstats_old.psys; + wait_ticks = lparstats.pwait - lparstats_old.pwait; + idle_ticks = lparstats.pidle - lparstats_old.pidle; + consumed_ticks = user_ticks + syst_ticks + wait_ticks + idle_ticks; + + lpar_submit ("user", (double) user_ticks / (double) ticks); + lpar_submit ("system", (double) syst_ticks / (double) ticks); + lpar_submit ("wait", (double) wait_ticks / (double) ticks); + lpar_submit ("idle", (double) idle_ticks / (double) ticks); + +#if PERFSTAT_SUPPORTS_DONATION if (donate_flag) { - u_longlong_t dlt_busy_stolen, dlt_idle_stolen; - u_longlong_t dlt_idle_donated, dlt_busy_donated; - - dlt_idle_donated = lparstats.idle_donated_purr - last_idle_donated_purr; - dlt_busy_donated = lparstats.busy_donated_purr - last_busy_donated_purr; - dlt_idle_stolen = lparstats.idle_stolen_purr - last_idle_stolen_purr; - dlt_busy_stolen = lparstats.busy_stolen_purr - last_busy_stolen_purr; - - lpar_submit ("idle_donated", (double)dlt_idle_donated / delta_time_base); - lpar_submit ("busy_donated", (double)dlt_busy_donated / delta_time_base); - lpar_submit ("idle_stolen", (double)dlt_idle_stolen / delta_time_base); - lpar_submit ("busy_stolen", (double)dlt_busy_stolen / delta_time_base); + /* donated => ticks given to another partition + * stolen => ticks received from another partition */ + u_longlong_t idle_donated_ticks, busy_donated_ticks; + u_longlong_t idle_stolen_ticks, busy_stolen_ticks; + + /* FYI: PURR == Processor Utilization of Resources Register + * SPURR == Scaled PURR */ + idle_donated_ticks = lparstats.idle_donated_purr - lparstats_old.idle_donated_purr; + busy_donated_ticks = lparstats.busy_donated_purr - lparstats_old.busy_donated_purr; + idle_stolen_ticks = lparstats.idle_stolen_purr - lparstats_old.idle_stolen_purr; + busy_stolen_ticks = lparstats.busy_stolen_purr - lparstats_old.busy_stolen_purr; + + lpar_submit ("idle_donated", (double) idle_donated_ticks / (double) ticks); + lpar_submit ("busy_donated", (double) busy_donated_ticks / (double) ticks); + lpar_submit ("idle_stolen", (double) idle_stolen_ticks / (double) ticks); + lpar_submit ("busy_stolen", (double) busy_stolen_ticks / (double) ticks); + + /* Donated ticks will be accounted for as stolen ticks in other LPARs */ + consumed_ticks += idle_stolen_ticks + busy_stolen_ticks; } +#endif + + lpar_submit ("consumed", (double) consumed_ticks / (double) ticks); if (pool_stats) { - if (!lparstats.type.b.pool_util_authority) - { - WARNING ("lpar plugin: this system does not have pool authority."); - } - else - { - u_longlong_t dlt_pit; - double total, idle; - char type[TYPE_INST_LEN]; - - dlt_pit = lparstats.pool_idle_time - last_pool_idle_time; - total = (double)lparstats.phys_cpus_pool; - idle = (double)dlt_pit / XINTFRAC / (double)delta_time_base; - ssnprintf (type, sizeof(type), "pool-%X-total", lparstats.pool_id); - lpar_submit (type, total); - ssnprintf (type, sizeof(type), "pool-%X-used", lparstats.pool_id); - lpar_submit (type, total - idle); - } + char typinst[DATA_MAX_NAME_LEN]; + u_longlong_t pool_idle_cticks; + double pool_idle_cpus; + double pool_busy_cpus; + + /* We're calculating "busy" from "idle" and the total number of + * CPUs, because the "busy" member didn't exist in early versions + * of libperfstat. It was added somewhere between AIX 5.3 ML5 and ML9. */ + pool_idle_cticks = lparstats.pool_idle_time - lparstats_old.pool_idle_time; + pool_idle_cpus = CLOCKTICKS_TO_TICKS ((double) pool_idle_cticks) / (double) ticks; + pool_busy_cpus = ((double) lparstats.phys_cpus_pool) - pool_idle_cpus; + if (pool_busy_cpus < 0.0) + pool_busy_cpus = 0.0; + + ssnprintf (typinst, sizeof (typinst), "pool-%X-busy", lparstats.pool_id); + lpar_submit (typinst, pool_busy_cpus); + + ssnprintf (typinst, sizeof (typinst), "pool-%X-idle", lparstats.pool_id); + lpar_submit (typinst, pool_idle_cpus); } - save_last_values (&lparstats); + memcpy (&lparstats_old, &lparstats, sizeof (lparstats_old)); return (0); } /* int lpar_read */ @@ -237,5 +269,5 @@ void module_register (void) plugin_register_read ("lpar", lpar_read); } /* void module_register */ -/* vim: set sw=2 sts=2 ts=8 : */ +/* vim: set sw=8 noet : */