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_LIB_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
rte_metrics_tel_reg_port_ethdev_to_metrics(uint16_t port_id)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
rte_metrics_tel_reg_all_ethdev(int * metrics_register_done,int * reg_index_list)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
rte_metrics_tel_update_metrics_ethdev(uint16_t port_id,int reg_start_index)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
rte_metrics_tel_format_port(uint32_t pid,json_t * ports,uint32_t * metric_ids,int num_metric_ids)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 ret = -ENOMEM;
174 goto fail;
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
rte_metrics_tel_encode_json_format(struct telemetry_encode_param * ep,char ** json_buffer)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
rte_metrics_tel_get_ports_stats_json(struct telemetry_encode_param * ep,int * reg_index,char ** json_buffer)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
rte_metrics_tel_get_port_stats_ids(struct telemetry_encode_param * ep)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
rte_metrics_tel_stat_names_to_ids(const char * const * stat_names,uint32_t * stat_ids,int num_stat_names)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
rte_metrics_tel_extract_data(struct telemetry_encode_param * ep,json_t * data)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
rte_metrics_tel_initial_metrics_setup(void)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
handle_ports_all_stats_values(const char * cmd __rte_unused,const char * params __rte_unused,char * buffer,int buf_len)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
handle_global_stats_values(const char * cmd __rte_unused,const char * params __rte_unused,char * buffer,int buf_len)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
handle_ports_stats_values_by_name(const char * cmd __rte_unused,const char * params,char * buffer,int buf_len)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_LOG_REGISTER(metrics_log_level, lib.metrics, ERR);
530
RTE_INIT(metrics_ctor)531 RTE_INIT(metrics_ctor)
532 {
533 #ifdef RTE_LIB_TELEMETRY
534 rte_telemetry_legacy_register("ports_all_stat_values", DATA_NOT_REQ,
535 handle_ports_all_stats_values);
536 rte_telemetry_legacy_register("global_stat_values", DATA_NOT_REQ,
537 handle_global_stats_values);
538 rte_telemetry_legacy_register("ports_stats_values_by_name", DATA_REQ,
539 handle_ports_stats_values_by_name);
540 #endif
541 }
542