src/ethstat.c

   1 /**
   2  * collectd - src/ethstat.c
   3  * Copyright (C) 2011       Cyril Feraudet
   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; either version 2 of the License, or (at your
   8  * option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  18  *
  19  * Authors:
  20  *   Cyril Feraudet <cyril at feraudet.com>
  21  **/
  22
  23 #include "collectd.h"
  24 #include "common.h"
  25 #include "plugin.h"
  26 #include "configfile.h"
  27 #include "utils_avltree.h"
  28
  29 #if HAVE_SYS_IOCTL_H
  30 # include <sys/ioctl.h>
  31 #endif
  32 #if HAVE_NET_IF_H
  33 # include <net/if.h>
  34 #endif
  35 #if HAVE_LINUX_SOCKIOS_H
  36 # include <linux/sockios.h>
  37 #endif
  38 #if HAVE_LINUX_ETHTOOL_H
  39 # include <linux/ethtool.h>
  40 #endif
  41
  42 struct value_map_s
  43 {
  44   char type[DATA_MAX_NAME_LEN];
  45   char type_instance[DATA_MAX_NAME_LEN];
  46 };
  47 typedef struct value_map_s value_map_t;
  48
  49 static char **interfaces = NULL;
  50 static size_t interfaces_num = 0;
  51
  52 static c_avl_tree_t *value_map = NULL;
  53
  54 static int ethstat_add_interface (const oconfig_item_t *ci) /* {{{ */
  55 {
  56   char **tmp;
  57   int status;
  58
  59   tmp = realloc (interfaces,
  60       sizeof (*interfaces) * (interfaces_num + 1));
  61   if (tmp == NULL)
  62     return (-1);
  63   interfaces = tmp;
  64
  65   status = cf_util_get_string (ci, interfaces + interfaces_num);
  66   if (status != 0)
  67     return (status);
  68
  69   interfaces_num++;
  70   INFO("ethstat plugin: Registred interface %s",
  71       interfaces[interfaces_num - 1]);
  72
  73   return (0);
  74 } /* }}} int ethstat_add_interface */
  75
  76 static int ethstat_add_map (const oconfig_item_t *ci) /* {{{ */
  77 {
  78   value_map_t *map;
  79   int status;
  80
  81   if ((ci->values_num < 2)
  82       || (ci->values_num > 3)
  83       || (ci->values[0].type != OCONFIG_TYPE_STRING)
  84       || (ci->values[1].type != OCONFIG_TYPE_STRING)
  85       || ((ci->values_num == 3)
  86         && (ci->values[2].type != OCONFIG_TYPE_STRING)))
  87   {
  88     ERROR ("ethstat plugin: The %s option requires "
  89         "two or three string arguments.", ci->key);
  90     return (-1);
  91   }
  92
  93   map = malloc (sizeof (*map));
  94   if (map == NULL)
  95   {
  96     ERROR ("ethstat plugin: malloc(3) failed.");
  97     return (ENOMEM);
  98   }
  99   memset (map, 0, sizeof (*map));
 100
 101   sstrncpy (map->type, ci->values[1].value.string, sizeof (map->type));
 102   if (ci->values_num == 2)
 103     sstrncpy (map->type_instance, ci->values[2].value.string,
 104         sizeof (map->type_instance));
 105
 106   if (value_map == NULL)
 107   {
 108     value_map = c_avl_create ((void *) strcmp);
 109     if (value_map == NULL)
 110     {
 111       sfree (map);
 112       ERROR ("ethstat plugin: c_avl_create() failed.");
 113       return (-1);
 114     }
 115   }
 116
 117   status = c_avl_insert (value_map,
 118       /* key = */ ci->values[0].value.string,
 119       /* value = */ map);
 120   if (status != 0)
 121   {
 122     sfree (map);
 123     if (status > 0)
 124       ERROR ("ethstat plugin: Multiple mappings for \"%s\".",
 125           ci->values[0].value.string);
 126     else
 127       ERROR ("ethstat plugin: c_avl_insert(\"%s\") failed.",
 128           ci->values[0].value.string);
 129     return (-1);
 130   }
 131
 132   return (0);
 133 } /* }}} int ethstat_add_map */
 134
 135 static int ethstat_config (oconfig_item_t *ci) /* {{{ */
 136 {
 137   int i;
 138
 139   for (i = 0; i < ci->children_num; i++)
 140   {
 141     oconfig_item_t *child = ci->children + i;
 142
 143     if (strcasecmp ("Interface", child->key) == 0)
 144       ethstat_add_interface (child);
 145     else if (strcasecmp ("Map", child->key) == 0)
 146       ethstat_add_map (child);
 147     else
 148       WARNING ("ethstat plugin: The config option \"%s\" is unknown.",
 149           child->key);
 150   }
 151
 152   return (0);
 153 } /* }}} */
 154
 155 static void ethstat_submit_value (const char *device,
 156                 const char *type_instance, derive_t value)
 157 {
 158         value_t values[1];
 159         value_list_t vl = VALUE_LIST_INIT;
 160         value_map_t *map = NULL;
 161
 162         if (value_map != NULL)
 163           c_avl_get (value_map, type_instance, (void *) &map);
 164
 165         values[0].derive = value;
 166         vl.values = values;
 167         vl.values_len = 1;
 168
 169         sstrncpy (vl.host, hostname_g, sizeof (vl.host));
 170         sstrncpy (vl.plugin, "ethstat", sizeof (vl.plugin));
 171         sstrncpy (vl.plugin_instance, device, sizeof (vl.plugin_instance));
 172         if (map != NULL)
 173         {
 174           sstrncpy (vl.type, map->type, sizeof (vl.type));
 175           sstrncpy (vl.type_instance, map->type_instance,
 176               sizeof (vl.type_instance));
 177         }
 178         else
 179         {
 180           sstrncpy (vl.type, "derive", sizeof (vl.type));
 181           sstrncpy (vl.type_instance, type_instance, sizeof (vl.type_instance));
 182         }
 183
 184         plugin_dispatch_values (&vl);
 185 }
 186
 187 static int ethstat_read_interface (char *device)
 188 {
 189         int fd;
 190         struct ifreq req;
 191         struct ethtool_drvinfo drvinfo;
 192         struct ethtool_gstrings *strings;
 193         struct ethtool_stats *stats;
 194         size_t n_stats;
 195         size_t strings_size;
 196         size_t stats_size;
 197         size_t i;
 198         int status;
 199
 200         memset (&req, 0, sizeof (req));
 201         sstrncpy(req.ifr_name, device, sizeof (req.ifr_name));
 202
 203         fd = socket(AF_INET, SOCK_DGRAM, /* protocol = */ 0);
 204         if (fd < 0)
 205         {
 206                 char errbuf[1024];
 207                 ERROR("ethstat plugin: Failed to open control socket: %s",
 208                                 sstrerror (errno, errbuf, sizeof (errbuf)));
 209                 return 1;
 210         }
 211
 212         memset (&drvinfo, 0, sizeof (drvinfo));
 213         drvinfo.cmd = ETHTOOL_GDRVINFO;
 214         req.ifr_data = (void *) &drvinfo;
 215         status = ioctl (fd, SIOCETHTOOL, &req);
 216         if (status < 0)
 217         {
 218                 char errbuf[1024];
 219                 close (fd);
 220                 ERROR ("ethstat plugin: Failed to get driver information "
 221                                 "from %s: %s", device,
 222                                 sstrerror (errno, errbuf, sizeof (errbuf)));
 223                 return (-1);
 224         }
 225
 226         n_stats = (size_t) drvinfo.n_stats;
 227         if (n_stats < 1)
 228         {
 229                 close (fd);
 230                 ERROR("ethstat plugin: No stats available for %s", device);
 231                 return (-1);
 232         }
 233
 234         strings_size = sizeof (struct ethtool_gstrings)
 235                 + (n_stats * ETH_GSTRING_LEN);
 236         stats_size = sizeof (struct ethtool_stats)
 237                 + (n_stats * sizeof (uint64_t));
 238
 239         strings = malloc (strings_size);
 240         stats = malloc (stats_size);
 241         if ((strings == NULL) || (stats == NULL))
 242         {
 243                 close (fd);
 244                 sfree (strings);
 245                 sfree (stats);
 246                 ERROR("ethstat plugin: malloc(3) failed.");
 247                 return (-1);
 248         }
 249
 250         strings->cmd = ETHTOOL_GSTRINGS;
 251         strings->string_set = ETH_SS_STATS;
 252         strings->len = n_stats;
 253         req.ifr_data = (void *) strings;
 254         status = ioctl (fd, SIOCETHTOOL, &req);
 255         if (status < 0)
 256         {
 257                 char errbuf[1024];
 258                 close (fd);
 259                 free (strings);
 260                 free (stats);
 261                 ERROR ("ethstat plugin: Cannot get strings from %s: %s",
 262                                 device,
 263                                 sstrerror (errno, errbuf, sizeof (errbuf)));
 264                 return (-1);
 265         }
 266
 267         stats->cmd = ETHTOOL_GSTATS;
 268         stats->n_stats = n_stats;
 269         req.ifr_data = (void *) stats;
 270         status = ioctl (fd, SIOCETHTOOL, &req);
 271         if (status < 0)
 272         {
 273                 char errbuf[1024];
 274                 close (fd);
 275                 free(strings);
 276                 free(stats);
 277                 ERROR("ethstat plugin: Reading statistics from %s failed: %s",
 278                                 device,
 279                                 sstrerror (errno, errbuf, sizeof (errbuf)));
 280                 return (-1);
 281         }
 282
 283         for (i = 0; i < n_stats; i++)
 284         {
 285                 const char *stat_name;
 286
 287                 stat_name = (void *) &strings->data[i * ETH_GSTRING_LEN],
 288                 DEBUG("ethstat plugin: device = \"%s\": %s = %"PRIu64,
 289                                 device, stat_name,
 290                                 (uint64_t) stats->data[i]);
 291                 ethstat_submit_value (device,
 292                                 stat_name, (derive_t) stats->data[i]);
 293         }
 294
 295         close (fd);
 296         sfree (strings);
 297         sfree (stats);
 298
 299         return (0);
 300 } /* }}} ethstat_read_interface */
 301
 302 static int ethstat_read(void)
 303 {
 304         size_t i;
 305
 306         for (i = 0; i < interfaces_num; i++)
 307                 ethstat_read_interface (interfaces[i]);
 308
 309         return 0;
 310 }
 311
 312 void module_register (void)
 313 {
 314         plugin_register_complex_config ("ethstat", ethstat_config);
 315         plugin_register_read ("ethstat", ethstat_read);
 316 }
 317
 318 /* vim: set sw=2 sts=2 et fdm=marker : */