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