processes plugin: Implement the "CollectDelayAccounting" option.
[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   char type[DATA_MAX_NAME_LEN];
47   char type_instance[DATA_MAX_NAME_LEN];
48 };
49 typedef struct value_map_s value_map_t;
50
51 static char **interfaces = NULL;
52 static size_t interfaces_num = 0;
53
54 static c_avl_tree_t *value_map = NULL;
55
56 static _Bool collect_mapped_only = 0;
57
58 static int ethstat_add_interface(const oconfig_item_t *ci) /* {{{ */
59 {
60   char **tmp;
61   int status;
62
63   tmp = realloc(interfaces, sizeof(*interfaces) * (interfaces_num + 1));
64   if (tmp == NULL)
65     return -1;
66   interfaces = tmp;
67   interfaces[interfaces_num] = NULL;
68
69   status = cf_util_get_string(ci, interfaces + interfaces_num);
70   if (status != 0)
71     return status;
72
73   interfaces_num++;
74   INFO("ethstat plugin: Registered interface %s",
75        interfaces[interfaces_num - 1]);
76
77   return 0;
78 } /* }}} int ethstat_add_interface */
79
80 static int ethstat_add_map(const oconfig_item_t *ci) /* {{{ */
81 {
82   value_map_t *map;
83   int status;
84   char *key;
85
86   if ((ci->values_num < 2) || (ci->values_num > 3) ||
87       (ci->values[0].type != OCONFIG_TYPE_STRING) ||
88       (ci->values[1].type != OCONFIG_TYPE_STRING) ||
89       ((ci->values_num == 3) && (ci->values[2].type != OCONFIG_TYPE_STRING))) {
90     ERROR("ethstat plugin: The %s option requires "
91           "two or three string arguments.",
92           ci->key);
93     return -1;
94   }
95
96   key = strdup(ci->values[0].value.string);
97   if (key == NULL) {
98     ERROR("ethstat plugin: strdup(3) failed.");
99     return ENOMEM;
100   }
101
102   map = calloc(1, sizeof(*map));
103   if (map == NULL) {
104     sfree(key);
105     ERROR("ethstat plugin: calloc failed.");
106     return ENOMEM;
107   }
108
109   sstrncpy(map->type, ci->values[1].value.string, sizeof(map->type));
110   if (ci->values_num == 3)
111     sstrncpy(map->type_instance, ci->values[2].value.string,
112              sizeof(map->type_instance));
113
114   if (value_map == NULL) {
115     value_map = c_avl_create((int (*)(const void *, const void *))strcmp);
116     if (value_map == NULL) {
117       sfree(map);
118       sfree(key);
119       ERROR("ethstat plugin: c_avl_create() failed.");
120       return -1;
121     }
122   }
123
124   status = c_avl_insert(value_map,
125                         /* key = */ key,
126                         /* value = */ map);
127   if (status != 0) {
128     if (status > 0)
129       ERROR("ethstat plugin: Multiple mappings for \"%s\".", key);
130     else
131       ERROR("ethstat plugin: c_avl_insert(\"%s\") failed.", key);
132
133     sfree(map);
134     sfree(key);
135     return -1;
136   }
137
138   return 0;
139 } /* }}} int ethstat_add_map */
140
141 static int ethstat_config(oconfig_item_t *ci) /* {{{ */
142 {
143   for (int i = 0; i < ci->children_num; i++) {
144     oconfig_item_t *child = ci->children + i;
145
146     if (strcasecmp("Interface", child->key) == 0)
147       ethstat_add_interface(child);
148     else if (strcasecmp("Map", child->key) == 0)
149       ethstat_add_map(child);
150     else if (strcasecmp("MappedOnly", child->key) == 0)
151       (void)cf_util_get_boolean(child, &collect_mapped_only);
152     else
153       WARNING("ethstat plugin: The config option \"%s\" is unknown.",
154               child->key);
155   }
156
157   return 0;
158 } /* }}} */
159
160 static void ethstat_submit_value(const char *device, const char *type_instance,
161                                  derive_t value) {
162   static c_complain_t complain_no_map = C_COMPLAIN_INIT_STATIC;
163
164   value_list_t vl = VALUE_LIST_INIT;
165   value_map_t *map = NULL;
166
167   if (value_map != NULL)
168     c_avl_get(value_map, type_instance, (void *)&map);
169
170   /* If the "MappedOnly" option is specified, ignore unmapped values. */
171   if (collect_mapped_only && (map == NULL)) {
172     if (value_map == NULL)
173       c_complain(
174           LOG_WARNING, &complain_no_map,
175           "ethstat plugin: The \"MappedOnly\" option has been set to true, "
176           "but no mapping has been configured. All values will be ignored!");
177     return;
178   }
179
180   vl.values = &(value_t){.derive = value};
181   vl.values_len = 1;
182
183   sstrncpy(vl.plugin, "ethstat", sizeof(vl.plugin));
184   sstrncpy(vl.plugin_instance, device, sizeof(vl.plugin_instance));
185   if (map != NULL) {
186     sstrncpy(vl.type, map->type, sizeof(vl.type));
187     sstrncpy(vl.type_instance, map->type_instance, sizeof(vl.type_instance));
188   } else {
189     sstrncpy(vl.type, "derive", sizeof(vl.type));
190     sstrncpy(vl.type_instance, type_instance, sizeof(vl.type_instance));
191   }
192
193   plugin_dispatch_values(&vl);
194 }
195
196 static int ethstat_read_interface(char *device) {
197   int fd;
198   struct ethtool_gstrings *strings;
199   struct ethtool_stats *stats;
200   size_t n_stats;
201   size_t strings_size;
202   size_t stats_size;
203   int status;
204
205   fd = socket(AF_INET, SOCK_DGRAM, /* protocol = */ 0);
206   if (fd < 0) {
207     ERROR("ethstat plugin: Failed to open control socket: %s", STRERRNO);
208     return 1;
209   }
210
211   struct ethtool_drvinfo drvinfo = {.cmd = ETHTOOL_GDRVINFO};
212
213   struct ifreq req = {.ifr_data = (void *)&drvinfo};
214
215   sstrncpy(req.ifr_name, device, sizeof(req.ifr_name));
216
217   status = ioctl(fd, SIOCETHTOOL, &req);
218   if (status < 0) {
219     close(fd);
220     ERROR("ethstat plugin: Failed to get driver information "
221           "from %s: %s",
222           device, STRERRNO);
223     return -1;
224   }
225
226   n_stats = (size_t)drvinfo.n_stats;
227   if (n_stats < 1) {
228     close(fd);
229     ERROR("ethstat plugin: No stats available for %s", device);
230     return -1;
231   }
232
233   strings_size = sizeof(struct ethtool_gstrings) + (n_stats * ETH_GSTRING_LEN);
234   stats_size = sizeof(struct ethtool_stats) + (n_stats * sizeof(uint64_t));
235
236   strings = malloc(strings_size);
237   stats = malloc(stats_size);
238   if ((strings == NULL) || (stats == NULL)) {
239     close(fd);
240     sfree(strings);
241     sfree(stats);
242     ERROR("ethstat plugin: malloc failed.");
243     return -1;
244   }
245
246   strings->cmd = ETHTOOL_GSTRINGS;
247   strings->string_set = ETH_SS_STATS;
248   strings->len = n_stats;
249   req.ifr_data = (void *)strings;
250   status = ioctl(fd, SIOCETHTOOL, &req);
251   if (status < 0) {
252     close(fd);
253     free(strings);
254     free(stats);
255     ERROR("ethstat plugin: Cannot get strings from %s: %s", device, STRERRNO);
256     return -1;
257   }
258
259   stats->cmd = ETHTOOL_GSTATS;
260   stats->n_stats = n_stats;
261   req.ifr_data = (void *)stats;
262   status = ioctl(fd, SIOCETHTOOL, &req);
263   if (status < 0) {
264     close(fd);
265     free(strings);
266     free(stats);
267     ERROR("ethstat plugin: Reading statistics from %s failed: %s", device,
268           STRERRNO);
269     return -1;
270   }
271
272   for (size_t i = 0; i < n_stats; i++) {
273     char *stat_name;
274
275     stat_name = (void *)&strings->data[i * ETH_GSTRING_LEN];
276     /* Remove leading spaces in key name */
277     while (isspace((int)*stat_name))
278       stat_name++;
279
280     DEBUG("ethstat plugin: device = \"%s\": %s = %" PRIu64, device, stat_name,
281           (uint64_t)stats->data[i]);
282     ethstat_submit_value(device, stat_name, (derive_t)stats->data[i]);
283   }
284
285   close(fd);
286   sfree(strings);
287   sfree(stats);
288
289   return 0;
290 } /* }}} ethstat_read_interface */
291
292 static int ethstat_read(void) {
293   for (size_t i = 0; i < interfaces_num; i++)
294     ethstat_read_interface(interfaces[i]);
295
296   return 0;
297 }
298
299 static int ethstat_shutdown(void) {
300   void *key = NULL;
301   void *value = NULL;
302
303   if (value_map == NULL)
304     return 0;
305
306   while (c_avl_pick(value_map, &key, &value) == 0) {
307     sfree(key);
308     sfree(value);
309   }
310
311   c_avl_destroy(value_map);
312   value_map = NULL;
313
314   return 0;
315 }
316
317 void module_register(void) {
318   plugin_register_complex_config("ethstat", ethstat_config);
319   plugin_register_read("ethstat", ethstat_read);
320   plugin_register_shutdown("ethstat", ethstat_shutdown);
321 }