fd11097628afcce554c3f2ece05796b093c04bb3
1 /*
2 * collectd - src/dpdkstat.c
3 * MIT License
4 *
5 * Copyright(c) 2016 Intel Corporation. All rights reserved.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23 * SOFTWARE.
24 *
25 * Authors:
26 * Maryam Tahhan <maryam.tahhan@intel.com>
27 * Harry van Haaren <harry.van.haaren@intel.com>
28 * Taras Chornyi <tarasx.chornyi@intel.com>
29 * Serhiy Pshyk <serhiyx.pshyk@intel.com>
30 * Krzysztof Matczak <krzysztofx.matczak@intel.com>
31 */
33 #include "collectd.h"
35 #include "common.h"
36 #include "utils_dpdk.h"
38 #include <rte_config.h>
39 #include <rte_ethdev.h>
41 #define DPDK_STATS_PLUGIN "dpdkstat"
42 #define DPDK_STATS_NAME "dpdk_collectd_stats"
44 #define DPDK_STATS_TRACE() \
45 DEBUG("%s:%s:%d pid=%u", DPDK_STATS_PLUGIN, __FUNCTION__, __LINE__, getpid())
47 struct dpdk_stats_config_s {
48 cdtime_t interval;
49 uint32_t enabled_port_mask;
50 char port_name[RTE_MAX_ETHPORTS][DATA_MAX_NAME_LEN];
51 };
52 typedef struct dpdk_stats_config_s dpdk_stats_config_t;
54 #define RTE_VERSION_16_07 RTE_VERSION_NUM(16, 7, 0, 16)
56 #if RTE_VERSION < RTE_VERSION_16_07
57 #define DPDK_STATS_XSTAT_GET_VALUE(ctx, index) ctx->xstats[index].value
58 #define DPDK_STATS_XSTAT_GET_NAME(ctx, index) ctx->xstats[index].name
59 #define DPDK_STATS_CTX_GET_XSTAT_SIZE sizeof(struct rte_eth_xstats)
60 #define DPDK_STATS_CTX_INIT(ctx) \
61 do { \
62 ctx->xstats = (struct rte_eth_xstats *)&ctx->raw_data[0]; \
63 } while (0)
64 #else
65 #define DPDK_STATS_XSTAT_GET_VALUE(ctx, index) ctx->xstats[index].value
66 #define DPDK_STATS_XSTAT_GET_NAME(ctx, index) ctx->xnames[index].name
67 #define DPDK_STATS_CTX_GET_XSTAT_SIZE \
68 (sizeof(struct rte_eth_xstat) + sizeof(struct rte_eth_xstat_name))
69 #define DPDK_STATS_CTX_INIT(ctx) \
70 do { \
71 ctx->xstats = (struct rte_eth_xstat *)&ctx->raw_data[0]; \
72 ctx->xnames = \
73 (struct rte_eth_xstat_name *)&ctx \
74 ->raw_data[ctx->stats_count * sizeof(struct rte_eth_xstat)]; \
75 } while (0)
76 #endif
78 struct dpdk_stats_ctx_s {
79 dpdk_stats_config_t config;
80 uint32_t stats_count;
81 uint32_t ports_count;
82 cdtime_t port_read_time[RTE_MAX_ETHPORTS];
83 uint32_t port_stats_count[RTE_MAX_ETHPORTS];
84 #if RTE_VERSION < RTE_VERSION_16_07
85 struct rte_eth_xstats *xstats;
86 #else
87 struct rte_eth_xstat *xstats;
88 struct rte_eth_xstat_name *xnames;
89 #endif
90 char raw_data[];
91 };
92 typedef struct dpdk_stats_ctx_s dpdk_stats_ctx_t;
94 #define DPDK_STATS_CTX_GET(a) ((dpdk_stats_ctx_t *)dpdk_helper_priv_get(a))
96 dpdk_helper_ctx_t *g_hc = NULL;
98 static void dpdk_stats_default_config(void) {
99 dpdk_stats_ctx_t *ec = DPDK_STATS_CTX_GET(g_hc);
101 ec->config.interval = plugin_get_interval();
103 for (int i = 0; i < RTE_MAX_ETHPORTS; i++) {
104 ec->config.port_name[i][0] = 0;
105 }
106 }
108 static int dpdk_stats_preinit(void) {
109 DPDK_STATS_TRACE();
111 if (g_hc != NULL) {
112 /* already initialized if config callback was called before init callback */
113 DEBUG("dpdk_stats_preinit: helper already initialized");
114 return 0;
115 }
117 int ret = dpdk_helper_init(DPDK_STATS_NAME, sizeof(dpdk_stats_ctx_t), &g_hc);
118 if (ret != 0) {
119 char errbuf[ERR_BUF_SIZE];
120 ERROR("%s: failed to initialize %s helper(error: %s)", DPDK_STATS_PLUGIN,
121 DPDK_STATS_NAME, sstrerror(errno, errbuf, sizeof(errbuf)));
122 return ret;
123 }
125 dpdk_stats_default_config();
127 return ret;
128 }
130 static int dpdk_stats_config(oconfig_item_t *ci) {
131 DPDK_STATS_TRACE();
133 int ret = dpdk_stats_preinit();
134 if (ret)
135 return ret;
137 dpdk_stats_ctx_t *ctx = DPDK_STATS_CTX_GET(g_hc);
139 for (int i = 0; i < ci->children_num; i++) {
140 oconfig_item_t *child = ci->children + i;
142 if ((strcasecmp("EnabledPortMask", child->key) == 0) &&
143 (child->values[0].type == OCONFIG_TYPE_NUMBER)) {
144 ctx->config.enabled_port_mask = child->values[0].value.number;
145 DEBUG("%s: Enabled Port Mask 0x%X", DPDK_STATS_PLUGIN,
146 ctx->config.enabled_port_mask);
147 } else if (strcasecmp("EAL", child->key) == 0) {
148 ret = dpdk_helper_eal_config_parse(g_hc, child);
149 if (ret)
150 return ret;
151 }
152 }
154 int port_num = 0;
156 /* parse port names after EnabledPortMask was parsed */
157 for (int i = 0; i < ci->children_num; i++) {
158 oconfig_item_t *child = ci->children + i;
160 if (strcasecmp("PortName", child->key) == 0) {
162 while (!(ctx->config.enabled_port_mask & (1 << port_num)))
163 port_num++;
165 cf_util_get_string_buffer(child, ctx->config.port_name[port_num],
166 sizeof(ctx->config.port_name[port_num]));
167 DEBUG("%s: Port %d Name: %s", DPDK_STATS_PLUGIN, port_num,
168 ctx->config.port_name[port_num]);
170 port_num++;
171 }
172 }
174 return ret;
175 }
177 static int dpdk_helper_stats_get(dpdk_helper_ctx_t *phc) {
178 dpdk_stats_ctx_t *ctx = DPDK_STATS_CTX_GET(phc);
180 /* get stats from DPDK */
182 uint8_t ports_count = rte_eth_dev_count();
183 if (ports_count == 0) {
184 DPDK_CHILD_LOG("%s: No DPDK ports available. "
185 "Check bound devices to DPDK driver.\n",
186 DPDK_STATS_PLUGIN);
187 return -ENODEV;
188 }
190 if (ports_count > RTE_MAX_ETHPORTS)
191 ports_count = RTE_MAX_ETHPORTS;
193 ctx->ports_count = ports_count;
195 int len = 0;
196 int ret = 0;
197 int stats = 0;
199 for (uint8_t i = 0; i < ports_count; i++) {
200 if (!(ctx->config.enabled_port_mask & (1 << i)))
201 continue;
202 ctx->port_read_time[i] = cdtime();
203 len = ctx->port_stats_count[i];
204 ret = rte_eth_xstats_get(i, &ctx->xstats[stats], len);
205 if (ret < 0 || ret != len) {
206 DPDK_CHILD_LOG("%s: Error reading stats (port=%d; len=%d)\n",
207 DPDK_STATS_PLUGIN, i, len);
208 return -1;
209 }
210 #if RTE_VERSION >= RTE_VERSION_16_07
211 ret = rte_eth_xstats_get_names(i, &ctx->xnames[stats], len);
212 if (ret < 0 || ret != len) {
213 DPDK_CHILD_LOG("%s: Error reading stat names (port=%d; len=%d)\n",
214 DPDK_STATS_PLUGIN, i, len);
215 return -1;
216 }
217 #endif
218 stats += len;
219 }
221 assert(stats == ctx->stats_count);
223 return 0;
224 }
226 static int dpdk_helper_stats_count_get(dpdk_helper_ctx_t *phc) {
227 dpdk_stats_ctx_t *ctx = DPDK_STATS_CTX_GET(phc);
229 uint8_t ports = rte_eth_dev_count();
230 if (ports == 0) {
231 DPDK_CHILD_LOG("%s: No DPDK ports available. "
232 "Check bound devices to DPDK driver.\n",
233 DPDK_STATS_PLUGIN);
234 return -ENODEV;
235 }
237 if (ports > RTE_MAX_ETHPORTS)
238 ports = RTE_MAX_ETHPORTS;
240 ctx->ports_count = ports;
242 int len = 0;
243 int stats_count = 0;
245 for (int i = 0; i < ports; i++) {
246 if (!(ctx->config.enabled_port_mask & (1 << i)))
247 continue;
248 #if RTE_VERSION >= RTE_VERSION_16_07
249 len = rte_eth_xstats_get_names(i, NULL, 0);
250 #else
251 len = rte_eth_xstats_get(i, NULL, 0);
252 #endif
253 if (len < 0) {
254 DPDK_CHILD_LOG("%s: Cannot get stats count\n", DPDK_STATS_PLUGIN);
255 return -1;
256 }
257 ctx->port_stats_count[i] = len;
258 stats_count += len;
259 }
261 DPDK_CHILD_LOG("%s:%s:%d stats_count=%d\n", DPDK_STATS_PLUGIN, __FUNCTION__,
262 __LINE__, stats_count);
264 return stats_count;
265 }
267 int dpdk_helper_command_handler(dpdk_helper_ctx_t *phc, enum DPDK_CMD cmd) {
268 /* this function is called from helper context */
269 int ret = 0;
271 if (phc == NULL) {
272 DPDK_CHILD_LOG("%s: Invalid argument(phc)\n", DPDK_STATS_PLUGIN);
273 return -EINVAL;
274 }
276 if (cmd != DPDK_CMD_GET_STATS) {
277 DPDK_CHILD_LOG("%s: Unknown command (cmd=%d)\n", DPDK_STATS_PLUGIN, cmd);
278 return -EINVAL;
279 }
281 dpdk_stats_ctx_t *ctx = DPDK_STATS_CTX_GET(phc);
283 if (ctx->stats_count == 0) {
285 int stats_count = dpdk_helper_stats_count_get(phc);
287 if (stats_count < 0) {
288 return stats_count;
289 }
291 int stats_size = stats_count * DPDK_STATS_CTX_GET_XSTAT_SIZE;
292 ctx->stats_count = stats_count;
294 if ((dpdk_helper_data_size_get(phc) - sizeof(dpdk_stats_ctx_t)) <
295 stats_size) {
296 DPDK_CHILD_LOG(
297 "%s:%s:%d not enough space for stats (available=%d, "
298 "needed=%d)\n",
299 DPDK_STATS_PLUGIN, __FUNCTION__, __LINE__,
300 (int)(dpdk_helper_data_size_get(phc) - sizeof(dpdk_stats_ctx_t)),
301 stats_size);
302 return -ENOBUFS;
303 }
304 }
306 ret = dpdk_helper_stats_get(phc);
308 return ret;
309 }
311 static void dpdk_stats_resolve_cnt_type(char *cnt_type, size_t cnt_type_len,
312 const char *cnt_name) {
313 char *type_end;
314 type_end = strrchr(cnt_name, '_');
316 if ((type_end != NULL) && (strncmp(cnt_name, "rx_", strlen("rx_")) == 0)) {
317 if (strstr(type_end, "bytes") != NULL) {
318 sstrncpy(cnt_type, "if_rx_octets", cnt_type_len);
319 } else if (strstr(type_end, "error") != NULL) {
320 sstrncpy(cnt_type, "if_rx_errors", cnt_type_len);
321 } else if (strstr(type_end, "dropped") != NULL) {
322 sstrncpy(cnt_type, "if_rx_dropped", cnt_type_len);
323 } else if (strstr(type_end, "packets") != NULL) {
324 sstrncpy(cnt_type, "if_rx_packets", cnt_type_len);
325 } else if (strstr(type_end, "_placement") != NULL) {
326 sstrncpy(cnt_type, "if_rx_errors", cnt_type_len);
327 } else if (strstr(type_end, "_buff") != NULL) {
328 sstrncpy(cnt_type, "if_rx_errors", cnt_type_len);
329 } else {
330 /* Does not fit obvious type: use a more generic one */
331 sstrncpy(cnt_type, "derive", cnt_type_len);
332 }
334 } else if ((type_end != NULL) &&
335 (strncmp(cnt_name, "tx_", strlen("tx_"))) == 0) {
336 if (strstr(type_end, "bytes") != NULL) {
337 sstrncpy(cnt_type, "if_tx_octets", cnt_type_len);
338 } else if (strstr(type_end, "error") != NULL) {
339 sstrncpy(cnt_type, "if_tx_errors", cnt_type_len);
340 } else if (strstr(type_end, "dropped") != NULL) {
341 sstrncpy(cnt_type, "if_tx_dropped", cnt_type_len);
342 } else if (strstr(type_end, "packets") != NULL) {
343 sstrncpy(cnt_type, "if_tx_packets", cnt_type_len);
344 } else {
345 /* Does not fit obvious type: use a more generic one */
346 sstrncpy(cnt_type, "derive", cnt_type_len);
347 }
348 } else if ((type_end != NULL) &&
349 (strncmp(cnt_name, "flow_", strlen("flow_"))) == 0) {
351 if (strstr(type_end, "_filters") != NULL) {
352 sstrncpy(cnt_type, "operations", cnt_type_len);
353 } else if (strstr(type_end, "error") != NULL)
354 sstrncpy(cnt_type, "errors", cnt_type_len);
356 } else if ((type_end != NULL) &&
357 (strncmp(cnt_name, "mac_", strlen("mac_"))) == 0) {
358 if (strstr(type_end, "error") != NULL) {
359 sstrncpy(cnt_type, "errors", cnt_type_len);
360 }
361 } else {
362 /* Does not fit obvious type, or strrchr error:
363 * use a more generic type */
364 sstrncpy(cnt_type, "derive", cnt_type_len);
365 }
366 }
368 static void dpdk_stats_counter_submit(const char *plugin_instance,
369 const char *cnt_name, derive_t value,
370 cdtime_t port_read_time) {
371 value_list_t vl = VALUE_LIST_INIT;
372 vl.values = &(value_t){.derive = value};
373 vl.values_len = 1;
374 vl.time = port_read_time;
375 sstrncpy(vl.host, hostname_g, sizeof(vl.host));
376 sstrncpy(vl.plugin, DPDK_STATS_PLUGIN, sizeof(vl.plugin));
377 sstrncpy(vl.plugin_instance, plugin_instance, sizeof(vl.plugin_instance));
378 dpdk_stats_resolve_cnt_type(vl.type, sizeof(vl.type), cnt_name);
379 sstrncpy(vl.type_instance, cnt_name, sizeof(vl.type_instance));
380 plugin_dispatch_values(&vl);
381 }
383 static int dpdk_stats_counters_dispatch(dpdk_helper_ctx_t *phc) {
384 dpdk_stats_ctx_t *ctx = DPDK_STATS_CTX_GET(phc);
386 /* dispatch stats values to collectd */
388 DEBUG("%s:%s:%d ports=%u", DPDK_STATS_PLUGIN, __FUNCTION__, __LINE__,
389 ctx->ports_count);
391 int stats_count = 0;
393 for (int i = 0; i < ctx->ports_count; i++) {
394 if (!(ctx->config.enabled_port_mask & (1 << i)))
395 continue;
397 char dev_name[64];
398 if (ctx->config.port_name[i][0] != 0) {
399 ssnprintf(dev_name, sizeof(dev_name), "%s", ctx->config.port_name[i]);
400 } else {
401 ssnprintf(dev_name, sizeof(dev_name), "port.%d", i);
402 }
404 DEBUG(" === Dispatch stats for port %d (name=%s; stats_count=%d)", i,
405 dev_name, ctx->port_stats_count[i]);
407 for (int j = 0; j < ctx->port_stats_count[i]; j++) {
408 const char *cnt_name = DPDK_STATS_XSTAT_GET_NAME(ctx, stats_count);
409 if (cnt_name == NULL)
410 WARNING("dpdkstat: Invalid counter name");
411 else
412 dpdk_stats_counter_submit(
413 dev_name, cnt_name,
414 (derive_t)DPDK_STATS_XSTAT_GET_VALUE(ctx, stats_count),
415 ctx->port_read_time[i]);
416 stats_count++;
418 assert(stats_count <= ctx->stats_count);
419 }
420 }
422 return 0;
423 }
425 static int dpdk_stats_reinit_helper() {
426 DPDK_STATS_TRACE();
428 dpdk_stats_ctx_t *ctx = DPDK_STATS_CTX_GET(g_hc);
430 size_t data_size = sizeof(dpdk_stats_ctx_t) +
431 (ctx->stats_count * DPDK_STATS_CTX_GET_XSTAT_SIZE);
433 DEBUG("%s:%d helper reinit (new_size=%zu)", __FUNCTION__, __LINE__,
434 data_size);
436 dpdk_stats_ctx_t tmp_ctx;
437 dpdk_eal_config_t tmp_eal;
439 memcpy(&tmp_ctx, ctx, sizeof(dpdk_stats_ctx_t));
440 dpdk_helper_eal_config_get(g_hc, &tmp_eal);
442 dpdk_helper_shutdown(g_hc);
444 g_hc = NULL;
446 int ret;
447 ret = dpdk_helper_init(DPDK_STATS_NAME, data_size, &g_hc);
448 if (ret != 0) {
449 char errbuf[ERR_BUF_SIZE];
450 ERROR("%s: failed to initialize %s helper(error: %s)", DPDK_STATS_PLUGIN,
451 DPDK_STATS_NAME, sstrerror(errno, errbuf, sizeof(errbuf)));
452 return ret;
453 }
455 ctx = DPDK_STATS_CTX_GET(g_hc);
456 memcpy(ctx, &tmp_ctx, sizeof(dpdk_stats_ctx_t));
457 DPDK_STATS_CTX_INIT(ctx);
458 dpdk_helper_eal_config_set(g_hc, &tmp_eal);
460 return ret;
461 }
463 static int dpdk_stats_read(user_data_t *ud) {
464 DPDK_STATS_TRACE();
466 int ret = 0;
468 if (g_hc == NULL) {
469 ERROR("dpdk stats plugin not initialized");
470 return -EINVAL;
471 }
473 dpdk_stats_ctx_t *ctx = DPDK_STATS_CTX_GET(g_hc);
475 int result = 0;
476 ret = dpdk_helper_command(g_hc, DPDK_CMD_GET_STATS, &result,
477 ctx->config.interval);
478 if (ret != 0) {
479 return 0;
480 }
482 if (result == -ENOBUFS) {
483 dpdk_stats_reinit_helper();
484 } else if (result == -ENODEV) {
485 dpdk_helper_shutdown(g_hc);
486 } else if (result == 0) {
487 dpdk_stats_counters_dispatch(g_hc);
488 }
490 return 0;
491 }
493 static int dpdk_stats_init(void) {
494 DPDK_STATS_TRACE();
496 int ret = 0;
498 ret = dpdk_stats_preinit();
499 if (ret != 0) {
500 return ret;
501 }
503 return 0;
504 }
506 static int dpdk_stats_shutdown(void) {
507 DPDK_STATS_TRACE();
509 int ret = 0;
511 ret = dpdk_helper_shutdown(g_hc);
512 g_hc = NULL;
513 if (ret != 0) {
514 ERROR("%s: failed to cleanup %s helper", DPDK_STATS_PLUGIN,
515 DPDK_STATS_NAME);
516 return ret;
517 }
519 return ret;
520 }
522 void module_register(void) {
523 plugin_register_init(DPDK_STATS_PLUGIN, dpdk_stats_init);
524 plugin_register_complex_config(DPDK_STATS_PLUGIN, dpdk_stats_config);
525 plugin_register_complex_read(NULL, DPDK_STATS_PLUGIN, dpdk_stats_read, 0,
526 NULL);
527 plugin_register_shutdown(DPDK_STATS_PLUGIN, dpdk_stats_shutdown);
528 }