src/xencpu.c

   1 /**
   2  * collectd - src/xencpu.c
   3  * Copyright (C) 2016       Pavel Rochnyak
   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  *   Pavel Rochnyak <pavel2000 ngs.ru>
  20  **/
  21
  22 #include "collectd.h"
  23
  24 #include "common.h"
  25 #include "plugin.h"
  26
  27 #include <xenctrl.h>
  28
  29 #ifdef XENCTRL_HAS_XC_INTERFACE
  30
  31 // Xen-4.1+
  32 #define XC_INTERFACE_INIT_ARGS NULL, NULL, 0
  33 xc_interface *xc_handle;
  34
  35 #else /* XENCTRL_HAS_XC_INTERFACE */
  36
  37 // For xen-3.4/xen-4.0
  38 #include <string.h>
  39 #define xc_strerror(xc_interface, errcode) strerror(errcode)
  40 #define XC_INTERFACE_INIT_ARGS
  41 typedef int xc_interface;
  42 xc_interface xc_handle = 0;
  43
  44 #endif /* XENCTRL_HAS_XC_INTERFACE */
  45
  46 uint32_t num_cpus = 0;
  47 xc_cpuinfo_t *cpu_info;
  48 static value_to_rate_state_t *cpu_states;
  49
  50 static int xencpu_init(void) {
  51   xc_handle = xc_interface_open(XC_INTERFACE_INIT_ARGS);
  52   if (!xc_handle) {
  53     ERROR("xencpu: xc_interface_open() failed");
  54     return (-1);
  55   }
  56
  57   xc_physinfo_t *physinfo;
  58
  59   physinfo = calloc(1, sizeof(xc_physinfo_t));
  60   if (physinfo == NULL) {
  61     ERROR("xencpu plugin: calloc() for physinfo failed.");
  62     xc_interface_close(xc_handle);
  63     return (ENOMEM);
  64   }
  65
  66   if (xc_physinfo(xc_handle, physinfo) < 0) {
  67     ERROR("xencpu plugin: xc_physinfo() failed");
  68     xc_interface_close(xc_handle);
  69     free(physinfo);
  70     return (-1);
  71   }
  72
  73   num_cpus = physinfo->nr_cpus;
  74   free(physinfo);
  75
  76   INFO("xencpu plugin: Found %" PRIu32 " processors.", num_cpus);
  77
  78   cpu_info = calloc(num_cpus, sizeof(xc_cpuinfo_t));
  79   if (cpu_info == NULL) {
  80     ERROR("xencpu plugin: calloc() for num_cpus failed.");
  81     xc_interface_close(xc_handle);
  82     return (ENOMEM);
  83   }
  84
  85   cpu_states = calloc(num_cpus, sizeof(value_to_rate_state_t));
  86   if (cpu_states == NULL) {
  87     ERROR("xencpu plugin: calloc() for cpu_states failed.");
  88     xc_interface_close(xc_handle);
  89     free(cpu_info);
  90     return (ENOMEM);
  91   }
  92
  93   return (0);
  94 } /* static int xencpu_init */
  95
  96 static int xencpu_shutdown(void) {
  97   free(cpu_states);
  98   free(cpu_info);
  99   xc_interface_close(xc_handle);
 100
 101   return 0;
 102 } /* static int xencpu_shutdown */
 103
 104 static void submit_value(int cpu_num, gauge_t percent) {
 105   value_t values[1];
 106   value_list_t vl = VALUE_LIST_INIT;
 107
 108   values[0].gauge = percent;
 109
 110   vl.values = values;
 111   vl.values_len = 1;
 112
 113   sstrncpy(vl.host, hostname_g, sizeof(vl.host));
 114   sstrncpy(vl.plugin, "xencpu", sizeof(vl.plugin));
 115   sstrncpy(vl.type, "percent", sizeof(vl.type));
 116   sstrncpy(vl.type_instance, "load", sizeof(vl.type_instance));
 117
 118   if (cpu_num >= 0) {
 119     ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%i", cpu_num);
 120   }
 121   plugin_dispatch_values(&vl);
 122 } /* static void submit_value */
 123
 124 static int xencpu_read(void) {
 125   cdtime_t now = cdtime();
 126
 127   int rc, nr_cpus;
 128
 129   rc = xc_getcpuinfo(xc_handle, num_cpus, cpu_info, &nr_cpus);
 130   if (rc < 0) {
 131     ERROR("xencpu: xc_getcpuinfo() Failed: %d %s\n", rc,
 132           xc_strerror(xc_handle, errno));
 133     return (-1);
 134   }
 135
 136   int status;
 137   for (int cpu = 0; cpu < nr_cpus; cpu++) {
 138     gauge_t rate = NAN;
 139     value_t value = {.derive = cpu_info[cpu].idletime};
 140
 141     status = value_to_rate(&rate, value, DS_TYPE_DERIVE, now, &cpu_states[cpu]);
 142     if (status == 0) {
 143       submit_value(cpu, 100 - rate / 10000000);
 144     }
 145   }
 146
 147   return (0);
 148 } /* static int xencpu_read */
 149
 150 void module_register(void) {
 151   plugin_register_init("xencpu", xencpu_init);
 152   plugin_register_read("xencpu", xencpu_read);
 153   plugin_register_shutdown("xencpu", xencpu_shutdown);
 154 } /* void module_register */