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