net/bnxt: add TCAM table processing for search and alloc
[dpdk.git] / 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_LOG_REGISTER(metrics_log_level, lib.metrics, ERR);
529
530 RTE_INIT(metrics_ctor)
531 {
532 #ifdef RTE_LIBRTE_TELEMETRY
533         rte_telemetry_legacy_register("ports_all_stat_values", DATA_NOT_REQ,
534                         handle_ports_all_stats_values);
535         rte_telemetry_legacy_register("global_stat_values", DATA_NOT_REQ,
536                         handle_global_stats_values);
537         rte_telemetry_legacy_register("ports_stats_values_by_name", DATA_REQ,
538                         handle_ports_stats_values_by_name);
539 #endif
540 }