lib/librte_metrics/rte_metrics_telemetry.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2020 Intel Corporation
   3  */
   4
   5 #include <jansson.h>
   6
   7 #include <rte_ethdev.h>
   8 #include <rte_string_fns.h>
   9 #ifdef RTE_LIBRTE_TELEMETRY
  10 #include <rte_telemetry_legacy.h>
  11 #endif
  12
  13 #include "rte_metrics.h"
  14 #include "rte_metrics_telemetry.h"
  15
  16 int metrics_log_level;
  17
  18 /* Logging Macros */
  19 #define METRICS_LOG(level, fmt, args...) \
  20         rte_log(RTE_LOG_ ##level, metrics_log_level, "%s(): "fmt "\n", \
  21                 __func__, ##args)
  22
  23 #define METRICS_LOG_ERR(fmt, args...) \
  24         METRICS_LOG(ERR, fmt, ## args)
  25
  26 #define METRICS_LOG_WARN(fmt, args...) \
  27         METRICS_LOG(WARNING, fmt, ## args)
  28
  29 static int32_t
  30 rte_metrics_tel_reg_port_ethdev_to_metrics(uint16_t port_id)
  31 {
  32         int ret,  num_xstats, i;
  33         struct rte_eth_xstat_name *eth_xstats_names;
  34         const char **xstats_names;
  35
  36         num_xstats = rte_eth_xstats_get(port_id, NULL, 0);
  37         if (num_xstats < 0) {
  38                 METRICS_LOG_ERR("rte_eth_xstats_get(%u) failed: %d",
  39                                 port_id, num_xstats);
  40                 return -EPERM;
  41         }
  42
  43         xstats_names = malloc(sizeof(*xstats_names) * num_xstats);
  44         eth_xstats_names = malloc(sizeof(struct rte_eth_xstat_name)
  45                         * num_xstats);
  46         if (eth_xstats_names == NULL || xstats_names == NULL) {
  47                 METRICS_LOG_ERR("Failed to malloc memory for xstats_names");
  48                 ret = -ENOMEM;
  49                 goto free_xstats;
  50         }
  51
  52         if (rte_eth_xstats_get_names(port_id,
  53                         eth_xstats_names, num_xstats) != num_xstats) {
  54                 METRICS_LOG_ERR("rte_eth_xstats_get_names(%u) len %d failed",
  55                                 port_id, num_xstats);
  56                 ret = -EPERM;
  57                 goto free_xstats;
  58         }
  59
  60         for (i = 0; i < num_xstats; i++)
  61                 xstats_names[i] = eth_xstats_names[i].name;
  62         ret = rte_metrics_reg_names(xstats_names, num_xstats);
  63         if (ret < 0)
  64                 METRICS_LOG_ERR("rte_metrics_reg_names failed - metrics may already be registered");
  65
  66 free_xstats:
  67         free(eth_xstats_names);
  68         free(xstats_names);
  69         return ret;
  70 }
  71
  72 int32_t
  73 rte_metrics_tel_reg_all_ethdev(int *metrics_register_done, int *reg_index_list)
  74 {
  75         struct driver_index {
  76                 const void *dev_ops;
  77                 int reg_index;
  78         } drv_idx[RTE_MAX_ETHPORTS] = { {0} };
  79         int ret, nb_drv_idx = 0;
  80         uint16_t d;
  81
  82         rte_metrics_init(rte_socket_id());
  83         RTE_ETH_FOREACH_DEV(d) {
  84                 int i;
  85                 /* Different device types have different numbers of stats, so
  86                  * first check if the stats for this type of device have
  87                  * already been registered
  88                  */
  89                 for (i = 0; i < nb_drv_idx; i++) {
  90                         if (rte_eth_devices[d].dev_ops == drv_idx[i].dev_ops) {
  91                                 reg_index_list[d] = drv_idx[i].reg_index;
  92                                 break;
  93                         }
  94                 }
  95                 if (i < nb_drv_idx)
  96                         continue; /* we found a match, go to next port */
  97
  98                 /* No match, register a new set of xstats for this port */
  99                 ret = rte_metrics_tel_reg_port_ethdev_to_metrics(d);
 100                 if (ret < 0) {
 101                         METRICS_LOG_ERR("Failed to register ethdev to metrics");
 102                         return ret;
 103                 }
 104                 reg_index_list[d] = ret;
 105                 drv_idx[nb_drv_idx].dev_ops = rte_eth_devices[d].dev_ops;
 106                 drv_idx[nb_drv_idx].reg_index = ret;
 107                 nb_drv_idx++;
 108         }
 109         *metrics_register_done = 1;
 110         return 0;
 111 }
 112
 113 static int32_t
 114 rte_metrics_tel_update_metrics_ethdev(uint16_t port_id, int reg_start_index)
 115 {
 116         int ret, num_xstats, i;
 117         struct rte_eth_xstat *eth_xstats;
 118
 119         num_xstats = rte_eth_xstats_get(port_id, NULL, 0);
 120         if (num_xstats < 0) {
 121                 METRICS_LOG_ERR("rte_eth_xstats_get(%u) failed: %d", port_id,
 122                                 num_xstats);
 123                 return -EPERM;
 124         }
 125         eth_xstats = malloc(sizeof(struct rte_eth_xstat) * num_xstats);
 126         if (eth_xstats == NULL) {
 127                 METRICS_LOG_ERR("Failed to malloc memory for xstats");
 128                 return -ENOMEM;
 129         }
 130         ret = rte_eth_xstats_get(port_id, eth_xstats, num_xstats);
 131         if (ret < 0 || ret > num_xstats) {
 132                 free(eth_xstats);
 133                 METRICS_LOG_ERR("rte_eth_xstats_get(%u) len%i failed: %d",
 134                                 port_id, num_xstats, ret);
 135                 return -EPERM;
 136         }
 137
 138         uint64_t xstats_values[num_xstats];
 139         for (i = 0; i < num_xstats; i++)
 140                 xstats_values[i] = eth_xstats[i].value;
 141         if (rte_metrics_update_values(port_id, reg_start_index, xstats_values,
 142                         num_xstats) < 0) {
 143                 METRICS_LOG_ERR("Could not update metrics values");
 144                 free(eth_xstats);
 145                 return -EPERM;
 146         }
 147         free(eth_xstats);
 148         return 0;
 149 }
 150
 151 static int32_t
 152 rte_metrics_tel_format_port(uint32_t pid, json_t *ports,
 153         uint32_t *metric_ids, int num_metric_ids)
 154 {
 155         struct rte_metric_value *metrics = NULL;
 156         struct rte_metric_name *names = NULL;
 157         int num_metrics, i, ret = -EPERM; /* most error cases return EPERM */
 158         json_t *port, *stats;
 159
 160         num_metrics = rte_metrics_get_names(NULL, 0);
 161         if (num_metrics < 0) {
 162                 METRICS_LOG_ERR("Cannot get metrics count");
 163                 return -EINVAL;
 164         } else if (num_metrics == 0) {
 165                 METRICS_LOG_ERR("No metrics to display (none have been registered)");
 166                 return -EPERM;
 167         }
 168
 169         metrics = malloc(sizeof(struct rte_metric_value) * num_metrics);
 170         names = malloc(sizeof(struct rte_metric_name) * num_metrics);
 171         if (metrics == NULL || names == NULL) {
 172                 METRICS_LOG_ERR("Cannot allocate memory");
 173                 return -ENOMEM;
 174         }
 175
 176         if (rte_metrics_get_names(names, num_metrics) != num_metrics ||
 177                         rte_metrics_get_values(pid, metrics, num_metrics)
 178                                 != num_metrics) {
 179                 METRICS_LOG_ERR("Error getting metrics");
 180                 goto fail;
 181         }
 182
 183         stats = json_array();
 184         if (stats == NULL) {
 185                 METRICS_LOG_ERR("Could not create stats JSON object");
 186                 goto fail;
 187         }
 188
 189         for (i = 0; i < num_metrics; i++) {
 190                 int32_t j;
 191                 for (j = 0; j < num_metric_ids; j++)
 192                         if (metrics[i].key == metric_ids[j])
 193                                 break;
 194
 195                 if (num_metric_ids > 0 && j == num_metric_ids)
 196                         continue; /* can't find this id */
 197
 198                 json_t *stat = json_pack("{s,s,s,I}",
 199                                 "name", names[metrics[i].key].name,
 200                                 "value", metrics[i].value);
 201                 if (stat == NULL || json_array_append_new(stats, stat) < 0) {
 202                         METRICS_LOG_ERR("Format stat with id: %u failed",
 203                                         metrics[i].key);
 204                         goto fail;
 205                 }
 206         }
 207
 208         port = json_pack("{s,i,s,o}", "port", pid, "stats",
 209                         json_array_size(stats) ? stats : json_null());
 210         if (port == NULL || json_array_append_new(ports, port) < 0) {
 211                 METRICS_LOG_ERR("Error creating port and adding to ports");
 212                 goto fail;
 213         }
 214
 215         free(metrics);
 216         free(names);
 217         return 0;
 218
 219 fail:
 220         free(metrics);
 221         free(names);
 222         return ret;
 223 }
 224
 225 int32_t
 226 rte_metrics_tel_encode_json_format(struct telemetry_encode_param *ep,
 227                 char **json_buffer)
 228 {
 229         json_t *root, *ports;
 230         int ret, i;
 231
 232         ports = json_array();
 233         if (ports == NULL) {
 234                 METRICS_LOG_ERR("Could not create ports JSON array");
 235                 return -EPERM;
 236         }
 237
 238         if (ep->type == PORT_STATS) {
 239                 if (ep->pp.num_port_ids <= 0) {
 240                         METRICS_LOG_ERR("Please provide port/metric ids");
 241                         return -EINVAL;
 242                 }
 243
 244                 for (i = 0; i < ep->pp.num_port_ids; i++) {
 245                         ret = rte_metrics_tel_format_port(ep->pp.port_ids[i],
 246                                         ports, &ep->pp.metric_ids[0],
 247                                         ep->pp.num_metric_ids);
 248                         if (ret < 0) {
 249                                 METRICS_LOG_ERR("Format port in JSON failed");
 250                                 return ret;
 251                         }
 252                 }
 253         } else if (ep->type == GLOBAL_STATS) {
 254                 /* Request Global Metrics */
 255                 ret = rte_metrics_tel_format_port(RTE_METRICS_GLOBAL,
 256                                 ports, NULL, 0);
 257                 if (ret < 0) {
 258                         METRICS_LOG_ERR("Request Global Metrics Failed");
 259                         return ret;
 260                 }
 261         } else {
 262                 METRICS_LOG_ERR("Invalid metrics type in encode params");
 263                 return -EINVAL;
 264         }
 265
 266         root = json_pack("{s,s,s,o}", "status_code", "Status OK: 200",
 267                         "data", ports);
 268         if (root == NULL) {
 269                 METRICS_LOG_ERR("Root, Status or data field cannot be set");
 270                 return -EPERM;
 271         }
 272
 273         *json_buffer = json_dumps(root, JSON_INDENT(2));
 274         json_decref(root);
 275         return 0;
 276 }
 277
 278 int32_t
 279 rte_metrics_tel_get_ports_stats_json(struct telemetry_encode_param *ep,
 280                 int *reg_index, char **json_buffer)
 281 {
 282         int ret, i;
 283         uint32_t port_id;
 284
 285         for (i = 0; i < ep->pp.num_port_ids; i++) {
 286                 port_id = ep->pp.port_ids[i];
 287                 if (!rte_eth_dev_is_valid_port(port_id)) {
 288                         METRICS_LOG_ERR("Port: %d invalid", port_id);
 289                         return -EINVAL;
 290                 }
 291
 292                 ret = rte_metrics_tel_update_metrics_ethdev(port_id,
 293                                 reg_index[i]);
 294                 if (ret < 0) {
 295                         METRICS_LOG_ERR("Failed to update ethdev metrics");
 296                         return ret;
 297                 }
 298         }
 299
 300         ret = rte_metrics_tel_encode_json_format(ep, json_buffer);
 301         if (ret < 0) {
 302                 METRICS_LOG_ERR("JSON encode function failed");
 303                 return ret;
 304         }
 305         return 0;
 306 }
 307
 308 int32_t
 309 rte_metrics_tel_get_port_stats_ids(struct telemetry_encode_param *ep)
 310 {
 311         int p, num_port_ids = 0;
 312
 313         RTE_ETH_FOREACH_DEV(p) {
 314                 ep->pp.port_ids[num_port_ids] = p;
 315                 num_port_ids++;
 316         }
 317
 318         if (!num_port_ids) {
 319                 METRICS_LOG_ERR("No active ports");
 320                 return -EINVAL;
 321         }
 322
 323         ep->pp.num_port_ids = num_port_ids;
 324         ep->pp.num_metric_ids = 0;
 325         ep->type = PORT_STATS;
 326         return 0;
 327 }
 328
 329 static int32_t
 330 rte_metrics_tel_stat_names_to_ids(const char * const *stat_names,
 331         uint32_t *stat_ids, int num_stat_names)
 332 {
 333         struct rte_metric_name *names;
 334         int num_metrics;
 335         int i, j, nb_stat_ids = 0;
 336
 337         num_metrics = rte_metrics_get_names(NULL, 0);
 338         if (num_metrics <= 0) {
 339                 METRICS_LOG_ERR("Error getting metrics count - no metrics may be registered");
 340                 return -EPERM;
 341         }
 342
 343         names = malloc(sizeof(struct rte_metric_name) * num_metrics);
 344         if (names == NULL) {
 345                 METRICS_LOG_ERR("Cannot allocate memory for names");
 346                 return -ENOMEM;
 347         }
 348
 349         if (rte_metrics_get_names(names, num_metrics) != num_metrics) {
 350                 METRICS_LOG_ERR("Cannot get metrics names");
 351                 free(names);
 352                 return -EPERM;
 353         }
 354
 355         for (i = 0; i < num_stat_names; i++) {
 356                 for (j = 0; j < num_metrics; j++) {
 357                         if (strcmp(stat_names[i], names[j].name) == 0) {
 358                                 stat_ids[nb_stat_ids++] = j;
 359                                 break;
 360                         }
 361                 }
 362                 if (j == num_metrics) {
 363                         METRICS_LOG_WARN("Invalid stat name %s\n",
 364                                         stat_names[i]);
 365                         free(names);
 366                         return -EINVAL;
 367                 }
 368         }
 369
 370         free(names);
 371         return 0;
 372 }
 373
 374 int32_t
 375 rte_metrics_tel_extract_data(struct telemetry_encode_param *ep, json_t *data)
 376 {
 377         int ret;
 378         json_t *port_ids_json = json_object_get(data, "ports");
 379         json_t *stat_names_json = json_object_get(data, "stats");
 380         uint64_t num_stat_names = json_array_size(stat_names_json);
 381         const char *stat_names[num_stat_names];
 382         size_t index;
 383         json_t *value;
 384
 385         memset(ep, 0, sizeof(*ep));
 386         ep->pp.num_port_ids = json_array_size(port_ids_json);
 387         ep->pp.num_metric_ids = num_stat_names;
 388         if (!json_is_object(data) || !json_is_array(port_ids_json) ||
 389                         !json_is_array(stat_names_json)) {
 390                 METRICS_LOG_WARN("Invalid data provided for this command");
 391                 return -EINVAL;
 392         }
 393
 394         json_array_foreach(port_ids_json, index, value) {
 395                 if (!json_is_integer(value)) {
 396                         METRICS_LOG_WARN("Port ID given is not valid");
 397                         return -EINVAL;
 398                 }
 399                 ep->pp.port_ids[index] = json_integer_value(value);
 400                 if (rte_eth_dev_is_valid_port(ep->pp.port_ids[index]) < 1)
 401                         return -EINVAL;
 402         }
 403         json_array_foreach(stat_names_json, index, value) {
 404                 if (!json_is_string(value)) {
 405                         METRICS_LOG_WARN("Stat Name given is not a string");
 406                         return -EINVAL;
 407                 }
 408                 stat_names[index] = json_string_value(value);
 409         }
 410
 411         ret = rte_metrics_tel_stat_names_to_ids(stat_names, ep->pp.metric_ids,
 412                         num_stat_names);
 413         if (ret < 0) {
 414                 METRICS_LOG_ERR("Could not convert stat names to IDs");
 415                 return ret;
 416         }
 417
 418         ep->type = PORT_STATS;
 419         return 0;
 420 }
 421
 422 static int
 423 rte_metrics_tel_initial_metrics_setup(void)
 424 {
 425         int ret;
 426         rte_metrics_init(rte_socket_id());
 427
 428         if (!tel_met_data.metrics_register_done) {
 429                 ret = rte_metrics_tel_reg_all_ethdev(
 430                         &tel_met_data.metrics_register_done,
 431                         tel_met_data.reg_index);
 432                 if (ret < 0)
 433                         return ret;
 434         }
 435         return 0;
 436 }
 437
 438 static int
 439 handle_ports_all_stats_values(const char *cmd __rte_unused,
 440                 const char *params __rte_unused,
 441                 char *buffer, int buf_len)
 442 {
 443         struct telemetry_encode_param ep;
 444         int ret, used = 0;
 445         char *json_buffer = NULL;
 446
 447         ret = rte_metrics_tel_initial_metrics_setup();
 448         if (ret < 0)
 449                 return ret;
 450
 451         memset(&ep, 0, sizeof(ep));
 452         ret = rte_metrics_tel_get_port_stats_ids(&ep);
 453         if (ret < 0)
 454                 return ret;
 455
 456         ret = rte_metrics_tel_get_ports_stats_json(&ep, tel_met_data.reg_index,
 457                         &json_buffer);
 458         if (ret < 0)
 459                 return ret;
 460
 461         used += strlcpy(buffer, json_buffer, buf_len);
 462         return used;
 463 }
 464
 465 static int
 466 handle_global_stats_values(const char *cmd __rte_unused,
 467                 const char *params __rte_unused,
 468                 char *buffer, int buf_len)
 469 {
 470         char *json_buffer = NULL;
 471         struct telemetry_encode_param ep = { .type = GLOBAL_STATS };
 472         int ret, used = 0;
 473
 474         ret = rte_metrics_tel_initial_metrics_setup();
 475         if (ret < 0)
 476                 return ret;
 477
 478         ret = rte_metrics_tel_encode_json_format(&ep, &json_buffer);
 479         if (ret < 0) {
 480                 METRICS_LOG_ERR("JSON encode function failed");
 481                 return ret;
 482         }
 483         used += strlcpy(buffer, json_buffer, buf_len);
 484         return used;
 485 }
 486
 487 static int
 488 handle_ports_stats_values_by_name(const char *cmd __rte_unused,
 489                 const char *params,
 490                 char *buffer, int buf_len)
 491 {
 492         char *json_buffer = NULL;
 493         struct telemetry_encode_param ep;
 494         int ret, used = 0;
 495         json_t *data;
 496         json_error_t error;
 497
 498         ret = rte_metrics_tel_initial_metrics_setup();
 499         if (ret < 0)
 500                 return ret;
 501
 502         data = json_loads(params, 0, &error);
 503         if (!data) {
 504                 METRICS_LOG_WARN("Could not load JSON object from data passed in : %s",
 505                                 error.text);
 506                 return -EPERM;
 507         } else if (!json_is_object(data)) {
 508                 METRICS_LOG_WARN("JSON Request data is not a JSON object");
 509                 json_decref(data);
 510                 return -EINVAL;
 511         }
 512
 513         ret = rte_metrics_tel_extract_data(&ep, data);
 514         if (ret < 0) {
 515                 METRICS_LOG_ERR("Extract data function failed");
 516                 return ret;
 517         }
 518
 519         ret = rte_metrics_tel_encode_json_format(&ep, &json_buffer);
 520         if (ret < 0) {
 521                 METRICS_LOG_ERR("JSON encode function failed");
 522                 return ret;
 523         }
 524         used += strlcpy(buffer, json_buffer, buf_len);
 525         return used;
 526 }
 527
 528 RTE_INIT(metrics_ctor)
 529 {
 530 #ifdef RTE_LIBRTE_TELEMETRY
 531         rte_telemetry_legacy_register("ports_all_stat_values", DATA_NOT_REQ,
 532                         handle_ports_all_stats_values);
 533         rte_telemetry_legacy_register("global_stat_values", DATA_NOT_REQ,
 534                         handle_global_stats_values);
 535         rte_telemetry_legacy_register("ports_stats_values_by_name", DATA_REQ,
 536                         handle_ports_stats_values_by_name);
 537 #endif
 538         metrics_log_level = rte_log_register("lib.metrics");
 539         if (metrics_log_level >= 0)
 540                 rte_log_set_level(metrics_log_level, RTE_LOG_ERR);
 541 }