src/dpdkstat.c

   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  */
  32
  33 #include "collectd.h"
  34
  35 #include "common.h"
  36 #include "utils_dpdk.h"
  37
  38 #include <rte_config.h>
  39 #include <rte_ethdev.h>
  40
  41 #define DPDK_STATS_PLUGIN "dpdkstat"
  42 #define DPDK_STATS_NAME "dpdk_collectd_stats"
  43
  44 #define DPDK_STATS_TRACE()                                                     \
  45   DEBUG("%s:%s:%d pid=%u", DPDK_STATS_PLUGIN, __FUNCTION__, __LINE__, getpid())
  46
  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;
  53
  54 #define RTE_VERSION_16_07 RTE_VERSION_NUM(16, 7, 0, 16)
  55
  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
  77
  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;
  93
  94 typedef enum {
  95   DPDK_STAT_STATE_OKAY = 0,
  96   DPDK_STAT_STATE_CFG_ERR,
  97 } dpdk_stat_cfg_status;
  98
  99 #define DPDK_STATS_CTX_GET(a) ((dpdk_stats_ctx_t *)dpdk_helper_priv_get(a))
 100
 101 dpdk_helper_ctx_t *g_hc = NULL;
 102 static char g_shm_name[DATA_MAX_NAME_LEN] = DPDK_STATS_NAME;
 103 static dpdk_stat_cfg_status g_state = DPDK_STAT_STATE_OKAY;
 104
 105 static int dpdk_stats_reinit_helper();
 106 static void dpdk_stats_default_config(void) {
 107   dpdk_stats_ctx_t *ec = DPDK_STATS_CTX_GET(g_hc);
 108
 109   ec->config.interval = plugin_get_interval();
 110   for (int i = 0; i < RTE_MAX_ETHPORTS; i++) {
 111     ec->config.port_name[i][0] = 0;
 112   }
 113   /* Enable all ports by default */
 114   ec->config.enabled_port_mask = ~0;
 115 }
 116
 117 static int dpdk_stats_preinit(void) {
 118   DPDK_STATS_TRACE();
 119
 120   if (g_hc != NULL) {
 121     /* already initialized if config callback was called before init callback */
 122     DEBUG("dpdk_stats_preinit: helper already initialized");
 123     return 0;
 124   }
 125
 126   int ret = dpdk_helper_init(g_shm_name, sizeof(dpdk_stats_ctx_t), &g_hc);
 127   if (ret != 0) {
 128     char errbuf[ERR_BUF_SIZE];
 129     ERROR("%s: failed to initialize %s helper(error: %s)", DPDK_STATS_PLUGIN,
 130           g_shm_name, sstrerror(errno, errbuf, sizeof(errbuf)));
 131     return ret;
 132   }
 133
 134   dpdk_stats_default_config();
 135   return ret;
 136 }
 137
 138 static int dpdk_stats_config(oconfig_item_t *ci) {
 139   DPDK_STATS_TRACE();
 140
 141   int ret = dpdk_stats_preinit();
 142   if (ret) {
 143     g_state = DPDK_STAT_STATE_CFG_ERR;
 144     return 0;
 145   }
 146
 147   dpdk_stats_ctx_t *ctx = DPDK_STATS_CTX_GET(g_hc);
 148
 149   for (int i = 0; i < ci->children_num; i++) {
 150     oconfig_item_t *child = ci->children + i;
 151
 152     if (strcasecmp("EnabledPortMask", child->key) == 0)
 153       ret = cf_util_get_int(child, (int *)&ctx->config.enabled_port_mask);
 154     else if (strcasecmp("SharedMemObj", child->key) == 0) {
 155       ret = cf_util_get_string_buffer(child, g_shm_name, sizeof(g_shm_name));
 156       if (ret == 0)
 157         ret = dpdk_stats_reinit_helper();
 158     } else if (strcasecmp("EAL", child->key) == 0)
 159       ret = dpdk_helper_eal_config_parse(g_hc, child);
 160     else if (strcasecmp("PortName", child->key) != 0) {
 161       ERROR(DPDK_STATS_PLUGIN ": unrecognized configuration option %s",
 162             child->key);
 163       ret = -1;
 164     }
 165
 166     if (ret != 0) {
 167       g_state = DPDK_STAT_STATE_CFG_ERR;
 168       return 0;
 169     }
 170   }
 171
 172   DEBUG(DPDK_STATS_PLUGIN ": Enabled Port Mask 0x%X",
 173         ctx->config.enabled_port_mask);
 174   DEBUG(DPDK_STATS_PLUGIN ": Shared memory object %s", g_shm_name);
 175
 176   int port_num = 0;
 177
 178   /* parse port names after EnabledPortMask was parsed */
 179   for (int i = 0; i < ci->children_num; i++) {
 180     oconfig_item_t *child = ci->children + i;
 181
 182     if (strcasecmp("PortName", child->key) == 0) {
 183
 184       while (!(ctx->config.enabled_port_mask & (1 << port_num)))
 185         port_num++;
 186
 187       if (cf_util_get_string_buffer(child, ctx->config.port_name[port_num],
 188                                     sizeof(ctx->config.port_name[port_num]))) {
 189         g_state = DPDK_STAT_STATE_CFG_ERR;
 190         return 0;
 191       }
 192
 193       DEBUG(DPDK_STATS_PLUGIN ": Port %d Name: %s", port_num,
 194             ctx->config.port_name[port_num]);
 195
 196       port_num++;
 197     }
 198   }
 199
 200   return 0;
 201 }
 202
 203 static int dpdk_helper_stats_get(dpdk_helper_ctx_t *phc) {
 204   int len = 0;
 205   int ret = 0;
 206   int stats = 0;
 207   dpdk_stats_ctx_t *ctx = DPDK_STATS_CTX_GET(phc);
 208
 209   /* get stats from DPDK */
 210   for (uint8_t i = 0; i < ctx->ports_count; i++) {
 211     if (!(ctx->config.enabled_port_mask & (1 << i)))
 212       continue;
 213
 214     ctx->port_read_time[i] = cdtime();
 215     /* Store available stats array length for port */
 216     len = ctx->port_stats_count[i];
 217
 218     ret = rte_eth_xstats_get(i, &ctx->xstats[stats], len);
 219     if (ret < 0 || ret > len) {
 220       DPDK_CHILD_LOG(DPDK_STATS_PLUGIN
 221                      ": Error reading stats (port=%d; len=%d, ret=%d)\n",
 222                      i, len, ret);
 223       ctx->port_stats_count[i] = 0;
 224       return -1;
 225     }
 226 #if RTE_VERSION >= RTE_VERSION_16_07
 227     ret = rte_eth_xstats_get_names(i, &ctx->xnames[stats], len);
 228     if (ret < 0 || ret > len) {
 229       DPDK_CHILD_LOG(DPDK_STATS_PLUGIN
 230                      ": Error reading stat names (port=%d; len=%d ret=%d)\n",
 231                      i, len, ret);
 232       ctx->port_stats_count[i] = 0;
 233       return -1;
 234     }
 235 #endif
 236     ctx->port_stats_count[i] = ret;
 237     stats += ctx->port_stats_count[i];
 238   }
 239
 240   assert(stats <= ctx->stats_count);
 241   return 0;
 242 }
 243
 244 static int dpdk_helper_stats_count_get(dpdk_helper_ctx_t *phc) {
 245   uint8_t ports = dpdk_helper_eth_dev_count();
 246   if (ports == 0)
 247     return -ENODEV;
 248
 249   dpdk_stats_ctx_t *ctx = DPDK_STATS_CTX_GET(phc);
 250   ctx->ports_count = ports;
 251
 252   int len = 0;
 253   int stats_count = 0;
 254   for (int i = 0; i < ports; i++) {
 255     if (!(ctx->config.enabled_port_mask & (1 << i)))
 256       continue;
 257 #if RTE_VERSION >= RTE_VERSION_16_07
 258     len = rte_eth_xstats_get_names(i, NULL, 0);
 259 #else
 260     len = rte_eth_xstats_get(i, NULL, 0);
 261 #endif
 262     if (len < 0) {
 263       DPDK_CHILD_LOG("%s: Cannot get stats count\n", DPDK_STATS_PLUGIN);
 264       return -1;
 265     }
 266     ctx->port_stats_count[i] = len;
 267     stats_count += len;
 268   }
 269
 270   DPDK_CHILD_LOG("%s:%s:%d stats_count=%d\n", DPDK_STATS_PLUGIN, __FUNCTION__,
 271                  __LINE__, stats_count);
 272
 273   return stats_count;
 274 }
 275
 276 static int dpdk_stats_get_size(dpdk_helper_ctx_t *phc) {
 277   return dpdk_helper_data_size_get(phc) - sizeof(dpdk_stats_ctx_t);
 278 }
 279
 280 int dpdk_helper_command_handler(dpdk_helper_ctx_t *phc, enum DPDK_CMD cmd) {
 281   /* this function is called from helper context */
 282
 283   if (phc == NULL) {
 284     DPDK_CHILD_LOG("%s: Invalid argument(phc)\n", DPDK_STATS_PLUGIN);
 285     return -EINVAL;
 286   }
 287
 288   if (cmd != DPDK_CMD_GET_STATS) {
 289     DPDK_CHILD_LOG("%s: Unknown command (cmd=%d)\n", DPDK_STATS_PLUGIN, cmd);
 290     return -EINVAL;
 291   }
 292
 293   int stats_count = dpdk_helper_stats_count_get(phc);
 294   if (stats_count < 0) {
 295     return stats_count;
 296   }
 297
 298   DPDK_STATS_CTX_GET(phc)->stats_count = stats_count;
 299   int stats_size = stats_count * DPDK_STATS_CTX_GET_XSTAT_SIZE;
 300
 301   if (dpdk_stats_get_size(phc) < stats_size) {
 302     DPDK_CHILD_LOG(
 303         DPDK_STATS_PLUGIN
 304         ":%s:%d not enough space for stats (available=%d, needed=%d)\n",
 305         __FUNCTION__, __LINE__, (int)dpdk_stats_get_size(phc), stats_size);
 306     return -ENOBUFS;
 307   }
 308
 309   return dpdk_helper_stats_get(phc);
 310 }
 311
 312 static void dpdk_stats_resolve_cnt_type(char *cnt_type, size_t cnt_type_len,
 313                                         const char *cnt_name) {
 314   char *type_end;
 315   type_end = strrchr(cnt_name, '_');
 316
 317   if ((type_end != NULL) && (strncmp(cnt_name, "rx_", strlen("rx_")) == 0)) {
 318     if (strstr(type_end, "bytes") != NULL) {
 319       sstrncpy(cnt_type, "if_rx_octets", cnt_type_len);
 320     } else if (strstr(type_end, "error") != NULL) {
 321       sstrncpy(cnt_type, "if_rx_errors", cnt_type_len);
 322     } else if (strstr(type_end, "dropped") != NULL) {
 323       sstrncpy(cnt_type, "if_rx_dropped", cnt_type_len);
 324     } else if (strstr(type_end, "packets") != NULL) {
 325       sstrncpy(cnt_type, "if_rx_packets", cnt_type_len);
 326     } else if (strstr(type_end, "_placement") != NULL) {
 327       sstrncpy(cnt_type, "if_rx_errors", cnt_type_len);
 328     } else if (strstr(type_end, "_buff") != NULL) {
 329       sstrncpy(cnt_type, "if_rx_errors", cnt_type_len);
 330     } else {
 331       /* Does not fit obvious type: use a more generic one */
 332       sstrncpy(cnt_type, "derive", cnt_type_len);
 333     }
 334
 335   } else if ((type_end != NULL) &&
 336              (strncmp(cnt_name, "tx_", strlen("tx_"))) == 0) {
 337     if (strstr(type_end, "bytes") != NULL) {
 338       sstrncpy(cnt_type, "if_tx_octets", cnt_type_len);
 339     } else if (strstr(type_end, "error") != NULL) {
 340       sstrncpy(cnt_type, "if_tx_errors", cnt_type_len);
 341     } else if (strstr(type_end, "dropped") != NULL) {
 342       sstrncpy(cnt_type, "if_tx_dropped", cnt_type_len);
 343     } else if (strstr(type_end, "packets") != NULL) {
 344       sstrncpy(cnt_type, "if_tx_packets", cnt_type_len);
 345     } else {
 346       /* Does not fit obvious type: use a more generic one */
 347       sstrncpy(cnt_type, "derive", cnt_type_len);
 348     }
 349   } else if ((type_end != NULL) &&
 350              (strncmp(cnt_name, "flow_", strlen("flow_"))) == 0) {
 351
 352     if (strstr(type_end, "_filters") != NULL) {
 353       sstrncpy(cnt_type, "operations", cnt_type_len);
 354     } else if (strstr(type_end, "error") != NULL)
 355       sstrncpy(cnt_type, "errors", cnt_type_len);
 356
 357   } else if ((type_end != NULL) &&
 358              (strncmp(cnt_name, "mac_", strlen("mac_"))) == 0) {
 359     if (strstr(type_end, "error") != NULL) {
 360       sstrncpy(cnt_type, "errors", cnt_type_len);
 361     }
 362   } else {
 363     /* Does not fit obvious type, or strrchr error:
 364      *   use a more generic type */
 365     sstrncpy(cnt_type, "derive", cnt_type_len);
 366   }
 367 }
 368
 369 static void dpdk_stats_counter_submit(const char *plugin_instance,
 370                                       const char *cnt_name, derive_t value,
 371                                       cdtime_t port_read_time) {
 372   value_list_t vl = VALUE_LIST_INIT;
 373   vl.values = &(value_t){.derive = value};
 374   vl.values_len = 1;
 375   vl.time = port_read_time;
 376   sstrncpy(vl.host, hostname_g, sizeof(vl.host));
 377   sstrncpy(vl.plugin, DPDK_STATS_PLUGIN, sizeof(vl.plugin));
 378   sstrncpy(vl.plugin_instance, plugin_instance, sizeof(vl.plugin_instance));
 379   dpdk_stats_resolve_cnt_type(vl.type, sizeof(vl.type), cnt_name);
 380   sstrncpy(vl.type_instance, cnt_name, sizeof(vl.type_instance));
 381   plugin_dispatch_values(&vl);
 382 }
 383
 384 static int dpdk_stats_counters_dispatch(dpdk_helper_ctx_t *phc) {
 385   dpdk_stats_ctx_t *ctx = DPDK_STATS_CTX_GET(phc);
 386
 387   /* dispatch stats values to collectd */
 388
 389   DEBUG("%s:%s:%d ports=%u", DPDK_STATS_PLUGIN, __FUNCTION__, __LINE__,
 390         ctx->ports_count);
 391
 392   int stats_count = 0;
 393
 394   for (int i = 0; i < ctx->ports_count; i++) {
 395     if (!(ctx->config.enabled_port_mask & (1 << i)))
 396       continue;
 397
 398     char dev_name[64];
 399     if (ctx->config.port_name[i][0] != 0) {
 400       snprintf(dev_name, sizeof(dev_name), "%s", ctx->config.port_name[i]);
 401     } else {
 402       snprintf(dev_name, sizeof(dev_name), "port.%d", i);
 403     }
 404
 405     DEBUG(" === Dispatch stats for port %d (name=%s; stats_count=%d)", i,
 406           dev_name, ctx->port_stats_count[i]);
 407
 408     for (int j = 0; j < ctx->port_stats_count[i]; j++) {
 409       const char *cnt_name = DPDK_STATS_XSTAT_GET_NAME(ctx, stats_count);
 410       if (cnt_name == NULL)
 411         WARNING("dpdkstat: Invalid counter name");
 412       else
 413         dpdk_stats_counter_submit(
 414             dev_name, cnt_name,
 415             (derive_t)DPDK_STATS_XSTAT_GET_VALUE(ctx, stats_count),
 416             ctx->port_read_time[i]);
 417       stats_count++;
 418
 419       assert(stats_count <= ctx->stats_count);
 420     }
 421   }
 422
 423   return 0;
 424 }
 425
 426 static int dpdk_stats_reinit_helper() {
 427   DPDK_STATS_TRACE();
 428
 429   dpdk_stats_ctx_t *ctx = DPDK_STATS_CTX_GET(g_hc);
 430
 431   size_t data_size = sizeof(dpdk_stats_ctx_t) +
 432                      (ctx->stats_count * DPDK_STATS_CTX_GET_XSTAT_SIZE);
 433
 434   DEBUG("%s:%d helper reinit (new_size=%zu)", __FUNCTION__, __LINE__,
 435         data_size);
 436
 437   dpdk_stats_ctx_t tmp_ctx;
 438   dpdk_eal_config_t tmp_eal;
 439
 440   memcpy(&tmp_ctx, ctx, sizeof(dpdk_stats_ctx_t));
 441   dpdk_helper_eal_config_get(g_hc, &tmp_eal);
 442
 443   dpdk_helper_shutdown(g_hc);
 444
 445   g_hc = NULL;
 446
 447   int ret;
 448   ret = dpdk_helper_init(g_shm_name, data_size, &g_hc);
 449   if (ret != 0) {
 450     char errbuf[ERR_BUF_SIZE];
 451     ERROR("%s: failed to initialize %s helper(error: %s)", DPDK_STATS_PLUGIN,
 452           g_shm_name, sstrerror(errno, errbuf, sizeof(errbuf)));
 453     return ret;
 454   }
 455
 456   ctx = DPDK_STATS_CTX_GET(g_hc);
 457   memcpy(ctx, &tmp_ctx, sizeof(dpdk_stats_ctx_t));
 458   DPDK_STATS_CTX_INIT(ctx);
 459   dpdk_helper_eal_config_set(g_hc, &tmp_eal);
 460
 461   return ret;
 462 }
 463
 464 static int dpdk_stats_read(user_data_t *ud) {
 465   DPDK_STATS_TRACE();
 466
 467   int ret = 0;
 468
 469   if (g_hc == NULL) {
 470     ERROR("dpdk stats plugin not initialized");
 471     return -EINVAL;
 472   }
 473
 474   dpdk_stats_ctx_t *ctx = DPDK_STATS_CTX_GET(g_hc);
 475
 476   int result = 0;
 477   ret = dpdk_helper_command(g_hc, DPDK_CMD_GET_STATS, &result,
 478                             ctx->config.interval);
 479   if (ret != 0) {
 480     return 0;
 481   }
 482
 483   if (result == -ENOBUFS) {
 484     dpdk_stats_reinit_helper();
 485   } else if (result == -ENODEV) {
 486     dpdk_helper_shutdown(g_hc);
 487   } else if (result == 0) {
 488     dpdk_stats_counters_dispatch(g_hc);
 489   }
 490
 491   return 0;
 492 }
 493
 494 static int dpdk_stats_shutdown(void) {
 495   DPDK_STATS_TRACE();
 496
 497   dpdk_helper_shutdown(g_hc);
 498   g_hc = NULL;
 499
 500   return 0;
 501 }
 502
 503 static int dpdk_stats_init(void) {
 504   DPDK_STATS_TRACE();
 505   int ret = 0;
 506
 507   if (g_state != DPDK_STAT_STATE_OKAY) {
 508     dpdk_stats_shutdown();
 509     return -1;
 510   }
 511
 512   ret = dpdk_stats_preinit();
 513   if (ret != 0) {
 514     return ret;
 515   }
 516
 517   return 0;
 518 }
 519
 520 void module_register(void) {
 521   plugin_register_init(DPDK_STATS_PLUGIN, dpdk_stats_init);
 522   plugin_register_complex_config(DPDK_STATS_PLUGIN, dpdk_stats_config);
 523   plugin_register_complex_read(NULL, DPDK_STATS_PLUGIN, dpdk_stats_read, 0,
 524                                NULL);
 525   plugin_register_shutdown(DPDK_STATS_PLUGIN, dpdk_stats_shutdown);
 526 }