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