1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2010-2017 Intel Corporation
11 #include <sys/queue.h>
17 #include <rte_common.h>
18 #include <rte_debug.h>
19 #include <rte_ethdev.h>
20 #include <rte_malloc.h>
21 #include <rte_memory.h>
22 #include <rte_memzone.h>
23 #include <rte_launch.h>
24 #include <rte_tailq.h>
25 #include <rte_per_lcore.h>
26 #include <rte_lcore.h>
28 #include <rte_atomic.h>
29 #include <rte_branch_prediction.h>
30 #include <rte_string_fns.h>
31 #include <rte_metrics.h>
32 #include <rte_cycles.h>
33 #ifdef RTE_LIBRTE_SECURITY
34 #include <rte_security.h>
36 #include <rte_cryptodev.h>
38 #include <rte_hexdump.h>
40 /* Maximum long option length for option parsing. */
41 #define MAX_LONG_OPT_SZ 64
42 #define RTE_LOGTYPE_APP RTE_LOGTYPE_USER1
44 #define MAX_STRING_LEN 256
46 #define STATS_BDR_FMT "========================================"
47 #define STATS_BDR_STR(w, s) printf("%.*s%s%.*s\n", w, \
48 STATS_BDR_FMT, s, w, STATS_BDR_FMT)
50 /**< mask of enabled ports */
51 static uint32_t enabled_port_mask
;
53 static uint32_t enable_stats
;
54 /**< Enable xstats. */
55 static uint32_t enable_xstats
;
56 /**< Enable collectd format*/
57 static uint32_t enable_collectd_format
;
58 /**< FD to send collectd format messages to STDOUT*/
60 /**< Host id process is running on */
61 static char host_id
[MAX_LONG_OPT_SZ
];
62 /**< Enable metrics. */
63 static uint32_t enable_metrics
;
64 /**< Enable stats reset. */
65 static uint32_t reset_stats
;
66 /**< Enable xstats reset. */
67 static uint32_t reset_xstats
;
68 /**< Enable memory info. */
69 static uint32_t mem_info
;
70 /**< Enable displaying xstat name. */
71 static uint32_t enable_xstats_name
;
72 static char *xstats_name
;
74 /**< Enable xstats by ids. */
75 #define MAX_NB_XSTATS_IDS 1024
76 static uint32_t nb_xstats_ids
;
77 static uint64_t xstats_ids
[MAX_NB_XSTATS_IDS
];
80 static char bdr_str
[MAX_STRING_LEN
];
82 /**< Enable show port. */
83 static uint32_t enable_shw_port
;
84 /**< Enable show tm. */
85 static uint32_t enable_shw_tm
;
86 /**< Enable show crypto. */
87 static uint32_t enable_shw_crypto
;
88 /**< Enable show ring. */
89 static uint32_t enable_shw_ring
;
90 static char *ring_name
;
91 /**< Enable show mempool. */
92 static uint32_t enable_shw_mempool
;
93 static char *mempool_name
;
94 /**< Enable iter mempool. */
95 static uint32_t enable_iter_mempool
;
96 static char *mempool_iter_name
;
100 proc_info_usage(const char *prgname
)
102 printf("%s [EAL options] -- -p PORTMASK\n"
103 " -m to display DPDK memory zones, segments and TAILQ information\n"
104 " -p PORTMASK: hexadecimal bitmask of ports to retrieve stats for\n"
105 " --stats: to display port statistics, enabled by default\n"
106 " --xstats: to display extended port statistics, disabled by "
108 " --metrics: to display derived metrics of the ports, disabled by "
110 " --xstats-name NAME: to display single xstat id by NAME\n"
111 " --xstats-ids IDLIST: to display xstat values by id. "
112 "The argument is comma-separated list of xstat ids to print out.\n"
113 " --stats-reset: to reset port statistics\n"
114 " --xstats-reset: to reset port extended statistics\n"
115 " --collectd-format: to print statistics to STDOUT in expected by collectd format\n"
116 " --host-id STRING: host id used to identify the system process is running on\n"
117 " --show-port: to display ports information\n"
118 " --show-tm: to display traffic manager information for ports\n"
119 " --show-crypto: to display crypto information\n"
120 " --show-ring[=name]: to display ring information\n"
121 " --show-mempool[=name]: to display mempool information\n"
122 " --iter-mempool=name: iterate mempool elements to display content\n",
127 * Parse the portmask provided at run time.
130 parse_portmask(const char *portmask
)
137 /* parse hexadecimal string */
138 pm
= strtoul(portmask
, &end
, 16);
139 if ((portmask
[0] == '\0') || (end
== NULL
) || (*end
!= '\0') ||
141 printf("%s ERROR parsing the port mask\n", __func__
);
153 * Parse ids value list into array
156 parse_xstats_ids(char *list
, uint64_t *ids
, int limit
) {
163 token
= strtok_r(list
, ",", &ctx
);
164 while (token
!= NULL
) {
165 ids
[length
] = strtoull(token
, &endptr
, 10);
173 token
= strtok_r(NULL
, ",", &ctx
);
180 proc_info_preparse_args(int argc
, char **argv
)
182 char *prgname
= argv
[0];
185 for (i
= 0; i
< argc
; i
++) {
186 /* Print stats or xstats to STDOUT in collectd format */
187 if (!strncmp(argv
[i
], "--collectd-format", MAX_LONG_OPT_SZ
)) {
188 enable_collectd_format
= 1;
189 stdout_fd
= dup(STDOUT_FILENO
);
190 close(STDOUT_FILENO
);
192 if (!strncmp(argv
[i
], "--host-id", MAX_LONG_OPT_SZ
)) {
193 if ((i
+ 1) == argc
) {
194 printf("Invalid host id or not specified\n");
195 proc_info_usage(prgname
);
198 strlcpy(host_id
, argv
[i
+ 1], sizeof(host_id
));
202 if (!strlen(host_id
)) {
203 int err
= gethostname(host_id
, MAX_LONG_OPT_SZ
-1);
206 strlcpy(host_id
, "unknown", sizeof(host_id
));
212 /* Parse the argument given in the command line of the application */
214 proc_info_parse_args(int argc
, char **argv
)
218 char *prgname
= argv
[0];
219 static struct option long_option
[] = {
220 {"stats", 0, NULL
, 0},
221 {"stats-reset", 0, NULL
, 0},
222 {"xstats", 0, NULL
, 0},
223 {"metrics", 0, NULL
, 0},
224 {"xstats-reset", 0, NULL
, 0},
225 {"xstats-name", required_argument
, NULL
, 1},
226 {"collectd-format", 0, NULL
, 0},
227 {"xstats-ids", 1, NULL
, 1},
228 {"host-id", 0, NULL
, 0},
229 {"show-port", 0, NULL
, 0},
230 {"show-tm", 0, NULL
, 0},
231 {"show-crypto", 0, NULL
, 0},
232 {"show-ring", optional_argument
, NULL
, 0},
233 {"show-mempool", optional_argument
, NULL
, 0},
234 {"iter-mempool", required_argument
, NULL
, 0},
239 proc_info_usage(prgname
);
241 /* Parse command line */
242 while ((opt
= getopt_long(argc
, argv
, "p:m",
243 long_option
, &option_index
)) != EOF
) {
247 enabled_port_mask
= parse_portmask(optarg
);
248 if (enabled_port_mask
== 0) {
249 printf("invalid portmask\n");
250 proc_info_usage(prgname
);
259 if (!strncmp(long_option
[option_index
].name
, "stats",
263 else if (!strncmp(long_option
[option_index
].name
, "xstats",
266 else if (!strncmp(long_option
[option_index
].name
,
271 if (!strncmp(long_option
[option_index
].name
, "stats-reset",
275 else if (!strncmp(long_option
[option_index
].name
, "xstats-reset",
278 else if (!strncmp(long_option
[option_index
].name
,
279 "show-port", MAX_LONG_OPT_SZ
))
281 else if (!strncmp(long_option
[option_index
].name
,
282 "show-tm", MAX_LONG_OPT_SZ
))
284 else if (!strncmp(long_option
[option_index
].name
,
285 "show-crypto", MAX_LONG_OPT_SZ
))
286 enable_shw_crypto
= 1;
287 else if (!strncmp(long_option
[option_index
].name
,
288 "show-ring", MAX_LONG_OPT_SZ
)) {
291 } else if (!strncmp(long_option
[option_index
].name
,
292 "show-mempool", MAX_LONG_OPT_SZ
)) {
293 enable_shw_mempool
= 1;
294 mempool_name
= optarg
;
295 } else if (!strncmp(long_option
[option_index
].name
,
296 "iter-mempool", MAX_LONG_OPT_SZ
)) {
297 enable_iter_mempool
= 1;
298 mempool_iter_name
= optarg
;
302 /* Print xstat single value given by name*/
303 if (!strncmp(long_option
[option_index
].name
,
304 "xstats-name", MAX_LONG_OPT_SZ
)) {
305 enable_xstats_name
= 1;
306 xstats_name
= optarg
;
307 printf("name:%s:%s\n",
308 long_option
[option_index
].name
,
310 } else if (!strncmp(long_option
[option_index
].name
,
313 nb_xstats_ids
= parse_xstats_ids(optarg
,
314 xstats_ids
, MAX_NB_XSTATS_IDS
);
316 if (nb_xstats_ids
<= 0) {
317 printf("xstats-id list parse error.\n");
324 proc_info_usage(prgname
);
332 meminfo_display(void)
334 printf("----------- MEMORY_SEGMENTS -----------\n");
335 rte_dump_physmem_layout(stdout
);
336 printf("--------- END_MEMORY_SEGMENTS ---------\n");
338 printf("------------ MEMORY_ZONES -------------\n");
339 rte_memzone_dump(stdout
);
340 printf("---------- END_MEMORY_ZONES -----------\n");
342 printf("------------- TAIL_QUEUES -------------\n");
343 rte_dump_tailq(stdout
);
344 printf("---------- END_TAIL_QUEUES ------------\n");
348 nic_stats_display(uint16_t port_id
)
350 struct rte_eth_stats stats
;
353 static const char *nic_stats_border
= "########################";
355 rte_eth_stats_get(port_id
, &stats
);
356 printf("\n %s NIC statistics for port %-2d %s\n",
357 nic_stats_border
, port_id
, nic_stats_border
);
359 printf(" RX-packets: %-10"PRIu64
" RX-errors: %-10"PRIu64
360 " RX-bytes: %-10"PRIu64
"\n", stats
.ipackets
, stats
.ierrors
,
362 printf(" RX-nombuf: %-10"PRIu64
"\n", stats
.rx_nombuf
);
363 printf(" TX-packets: %-10"PRIu64
" TX-errors: %-10"PRIu64
364 " TX-bytes: %-10"PRIu64
"\n", stats
.opackets
, stats
.oerrors
,
368 for (i
= 0; i
< RTE_ETHDEV_QUEUE_STAT_CNTRS
; i
++) {
369 printf(" Stats reg %2d RX-packets: %-10"PRIu64
370 " RX-errors: %-10"PRIu64
371 " RX-bytes: %-10"PRIu64
"\n",
372 i
, stats
.q_ipackets
[i
], stats
.q_errors
[i
], stats
.q_ibytes
[i
]);
376 for (i
= 0; i
< RTE_ETHDEV_QUEUE_STAT_CNTRS
; i
++) {
377 printf(" Stats reg %2d TX-packets: %-10"PRIu64
378 " TX-bytes: %-10"PRIu64
"\n",
379 i
, stats
.q_opackets
[i
], stats
.q_obytes
[i
]);
382 printf(" %s############################%s\n",
383 nic_stats_border
, nic_stats_border
);
387 nic_stats_clear(uint16_t port_id
)
389 printf("\n Clearing NIC stats for port %d\n", port_id
);
390 rte_eth_stats_reset(port_id
);
391 printf("\n NIC statistics for port %d cleared\n", port_id
);
394 static void collectd_resolve_cnt_type(char *cnt_type
, size_t cnt_type_len
,
395 const char *cnt_name
) {
396 char *type_end
= strrchr(cnt_name
, '_');
398 if ((type_end
!= NULL
) &&
399 (strncmp(cnt_name
, "rx_", strlen("rx_")) == 0)) {
400 if (strncmp(type_end
, "_errors", strlen("_errors")) == 0)
401 strlcpy(cnt_type
, "if_rx_errors", cnt_type_len
);
402 else if (strncmp(type_end
, "_dropped", strlen("_dropped")) == 0)
403 strlcpy(cnt_type
, "if_rx_dropped", cnt_type_len
);
404 else if (strncmp(type_end
, "_bytes", strlen("_bytes")) == 0)
405 strlcpy(cnt_type
, "if_rx_octets", cnt_type_len
);
406 else if (strncmp(type_end
, "_packets", strlen("_packets")) == 0)
407 strlcpy(cnt_type
, "if_rx_packets", cnt_type_len
);
408 else if (strncmp(type_end
, "_placement",
409 strlen("_placement")) == 0)
410 strlcpy(cnt_type
, "if_rx_errors", cnt_type_len
);
411 else if (strncmp(type_end
, "_buff", strlen("_buff")) == 0)
412 strlcpy(cnt_type
, "if_rx_errors", cnt_type_len
);
414 /* Does not fit obvious type: use a more generic one */
415 strlcpy(cnt_type
, "derive", cnt_type_len
);
416 } else if ((type_end
!= NULL
) &&
417 (strncmp(cnt_name
, "tx_", strlen("tx_"))) == 0) {
418 if (strncmp(type_end
, "_errors", strlen("_errors")) == 0)
419 strlcpy(cnt_type
, "if_tx_errors", cnt_type_len
);
420 else if (strncmp(type_end
, "_dropped", strlen("_dropped")) == 0)
421 strlcpy(cnt_type
, "if_tx_dropped", cnt_type_len
);
422 else if (strncmp(type_end
, "_bytes", strlen("_bytes")) == 0)
423 strlcpy(cnt_type
, "if_tx_octets", cnt_type_len
);
424 else if (strncmp(type_end
, "_packets", strlen("_packets")) == 0)
425 strlcpy(cnt_type
, "if_tx_packets", cnt_type_len
);
427 /* Does not fit obvious type: use a more generic one */
428 strlcpy(cnt_type
, "derive", cnt_type_len
);
429 } else if ((type_end
!= NULL
) &&
430 (strncmp(cnt_name
, "flow_", strlen("flow_"))) == 0) {
431 if (strncmp(type_end
, "_filters", strlen("_filters")) == 0)
432 strlcpy(cnt_type
, "operations", cnt_type_len
);
433 else if (strncmp(type_end
, "_errors", strlen("_errors")) == 0)
434 strlcpy(cnt_type
, "errors", cnt_type_len
);
435 else if (strncmp(type_end
, "_filters", strlen("_filters")) == 0)
436 strlcpy(cnt_type
, "filter_result", cnt_type_len
);
437 } else if ((type_end
!= NULL
) &&
438 (strncmp(cnt_name
, "mac_", strlen("mac_"))) == 0) {
439 if (strncmp(type_end
, "_errors", strlen("_errors")) == 0)
440 strlcpy(cnt_type
, "errors", cnt_type_len
);
442 /* Does not fit obvious type, or strrchr error: */
443 /* use a more generic type */
444 strlcpy(cnt_type
, "derive", cnt_type_len
);
449 nic_xstats_by_name_display(uint16_t port_id
, char *name
)
453 printf("###### NIC statistics for port %-2d, statistic name '%s':\n",
456 if (rte_eth_xstats_get_id_by_name(port_id
, name
, &id
) == 0)
457 printf("%s: %"PRIu64
"\n", name
, id
);
459 printf("Statistic not found...\n");
464 nic_xstats_by_ids_display(uint16_t port_id
, uint64_t *ids
, int len
)
466 struct rte_eth_xstat_name
*xstats_names
;
469 static const char *nic_stats_border
= "########################";
471 values
= malloc(sizeof(*values
) * len
);
472 if (values
== NULL
) {
473 printf("Cannot allocate memory for xstats\n");
477 xstats_names
= malloc(sizeof(struct rte_eth_xstat_name
) * len
);
478 if (xstats_names
== NULL
) {
479 printf("Cannot allocate memory for xstat names\n");
484 if (len
!= rte_eth_xstats_get_names_by_id(
485 port_id
, xstats_names
, len
, ids
)) {
486 printf("Cannot get xstat names\n");
490 printf("###### NIC extended statistics for port %-2d #########\n",
492 printf("%s############################\n", nic_stats_border
);
493 ret
= rte_eth_xstats_get_by_id(port_id
, ids
, values
, len
);
494 if (ret
< 0 || ret
> len
) {
495 printf("Cannot get xstats\n");
499 for (i
= 0; i
< len
; i
++)
500 printf("%s: %"PRIu64
"\n",
501 xstats_names
[i
].name
,
504 printf("%s############################\n", nic_stats_border
);
511 nic_xstats_display(uint16_t port_id
)
513 struct rte_eth_xstat_name
*xstats_names
;
516 static const char *nic_stats_border
= "########################";
518 len
= rte_eth_xstats_get_names_by_id(port_id
, NULL
, 0, NULL
);
520 printf("Cannot get xstats count\n");
523 values
= malloc(sizeof(*values
) * len
);
524 if (values
== NULL
) {
525 printf("Cannot allocate memory for xstats\n");
529 xstats_names
= malloc(sizeof(struct rte_eth_xstat_name
) * len
);
530 if (xstats_names
== NULL
) {
531 printf("Cannot allocate memory for xstat names\n");
535 if (len
!= rte_eth_xstats_get_names_by_id(
536 port_id
, xstats_names
, len
, NULL
)) {
537 printf("Cannot get xstat names\n");
541 printf("###### NIC extended statistics for port %-2d #########\n",
543 printf("%s############################\n",
545 ret
= rte_eth_xstats_get_by_id(port_id
, NULL
, values
, len
);
546 if (ret
< 0 || ret
> len
) {
547 printf("Cannot get xstats\n");
551 for (i
= 0; i
< len
; i
++) {
552 if (enable_collectd_format
) {
553 char counter_type
[MAX_STRING_LEN
];
554 char buf
[MAX_STRING_LEN
];
557 collectd_resolve_cnt_type(counter_type
,
558 sizeof(counter_type
),
559 xstats_names
[i
].name
);
560 n
= snprintf(buf
, MAX_STRING_LEN
,
561 "PUTVAL %s/dpdkstat-port.%u/%s-%s N:%"
562 PRIu64
"\n", host_id
, port_id
, counter_type
,
563 xstats_names
[i
].name
, values
[i
]);
564 if (n
> sizeof(buf
) - 1)
566 ret
= write(stdout_fd
, buf
, n
);
570 printf("%s: %"PRIu64
"\n", xstats_names
[i
].name
,
575 printf("%s############################\n",
583 nic_xstats_clear(uint16_t port_id
)
587 printf("\n Clearing NIC xstats for port %d\n", port_id
);
588 ret
= rte_eth_xstats_reset(port_id
);
590 printf("\n Error clearing xstats for port %d: %s\n", port_id
,
595 printf("\n NIC extended statistics for port %d cleared\n", port_id
);
599 metrics_display(int port_id
)
601 struct rte_metric_value
*metrics
;
602 struct rte_metric_name
*names
;
604 static const char *nic_stats_border
= "########################";
606 len
= rte_metrics_get_names(NULL
, 0);
608 printf("Cannot get metrics count\n");
612 printf("No metrics to display (none have been registered)\n");
616 metrics
= rte_malloc("proc_info_metrics",
617 sizeof(struct rte_metric_value
) * len
, 0);
618 if (metrics
== NULL
) {
619 printf("Cannot allocate memory for metrics\n");
623 names
= rte_malloc(NULL
, sizeof(struct rte_metric_name
) * len
, 0);
625 printf("Cannot allocate memory for metrcis names\n");
630 if (len
!= rte_metrics_get_names(names
, len
)) {
631 printf("Cannot get metrics names\n");
637 if (port_id
== RTE_METRICS_GLOBAL
)
638 printf("###### Non port specific metrics #########\n");
640 printf("###### metrics for port %-2d #########\n", port_id
);
641 printf("%s############################\n", nic_stats_border
);
642 ret
= rte_metrics_get_values(port_id
, metrics
, len
);
643 if (ret
< 0 || ret
> len
) {
644 printf("Cannot get metrics values\n");
651 for (i
= 0; i
< len
; i
++)
652 printf("%s: %"PRIu64
"\n", names
[i
].name
, metrics
[i
].value
);
654 printf("%s############################\n", nic_stats_border
);
665 snprintf(bdr_str
, MAX_STRING_LEN
, " show - Port PMD %"PRIu64
,
667 STATS_BDR_STR(10, bdr_str
);
669 RTE_ETH_FOREACH_DEV(i
) {
671 struct rte_eth_link link
;
672 struct rte_eth_dev_info dev_info
;
673 struct rte_eth_rxq_info queue_info
;
674 struct rte_eth_rss_conf rss_conf
;
676 memset(&rss_conf
, 0, sizeof(rss_conf
));
678 snprintf(bdr_str
, MAX_STRING_LEN
, " Port (%u)", i
);
679 STATS_BDR_STR(5, bdr_str
);
680 printf(" - generic config\n");
682 printf("\t -- Socket %d\n", rte_eth_dev_socket_id(i
));
683 ret
= rte_eth_link_get(i
, &link
);
685 printf("Link get failed (port %u): %s\n",
686 i
, rte_strerror(-ret
));
688 printf("\t -- link speed %d duplex %d,"
689 " auto neg %d status %d\n",
695 printf("\t -- promiscuous (%d)\n",
696 rte_eth_promiscuous_get(i
));
697 ret
= rte_eth_dev_get_mtu(i
, &mtu
);
699 printf("\t -- mtu (%d)\n", mtu
);
701 ret
= rte_eth_dev_info_get(i
, &dev_info
);
703 printf("Error during getting device (port %u) info: %s\n",
708 printf(" - queue\n");
709 for (j
= 0; j
< dev_info
.nb_rx_queues
; j
++) {
710 ret
= rte_eth_rx_queue_info_get(i
, j
, &queue_info
);
712 printf("\t -- queue %d rx scatter %d"
714 " offloads 0x%"PRIx64
715 " mempool socket %d\n",
717 queue_info
.scattered_rx
,
719 queue_info
.conf
.offloads
,
720 queue_info
.mp
->socket_id
);
724 ret
= rte_eth_dev_rss_hash_conf_get(i
, &rss_conf
);
726 if (rss_conf
.rss_key
) {
728 printf("\t -- RSS len %u key (hex):",
729 rss_conf
.rss_key_len
);
730 for (k
= 0; k
< rss_conf
.rss_key_len
; k
++)
731 printf(" %x", rss_conf
.rss_key
[k
]);
732 printf("\t -- hf 0x%"PRIx64
"\n",
737 printf(" - cyrpto context\n");
738 #ifdef RTE_LIBRTE_SECURITY
739 void *p_ctx
= rte_eth_dev_get_sec_ctx(i
);
740 printf("\t -- security context - %p\n", p_ctx
);
743 printf("\t -- size %u\n",
744 rte_security_session_get_size(p_ctx
));
745 const struct rte_security_capability
*s_cap
=
746 rte_security_capabilities_get(p_ctx
);
748 printf("\t -- action (0x%x), protocol (0x%x),"
749 " offload flags (0x%x)\n",
753 printf("\t -- capabilities - oper type %x\n",
754 s_cap
->crypto_capabilities
->op
);
760 STATS_BDR_STR(50, "");
764 display_nodecap_info(int is_leaf
, struct rte_tm_node_capabilities
*cap
)
770 printf("\t -- nonleaf sched max:\n"
771 "\t\t + children (%u)\n"
772 "\t\t + sp priorities (%u)\n"
773 "\t\t + wfq children per group (%u)\n"
774 "\t\t + wfq groups (%u)\n"
775 "\t\t + wfq weight (%u)\n",
776 cap
->nonleaf
.sched_n_children_max
,
777 cap
->nonleaf
.sched_sp_n_priorities_max
,
778 cap
->nonleaf
.sched_wfq_n_children_per_group_max
,
779 cap
->nonleaf
.sched_wfq_n_groups_max
,
780 cap
->nonleaf
.sched_wfq_weight_max
);
782 printf("\t -- leaf cman support:\n"
783 "\t\t + wred pkt mode (%d)\n"
784 "\t\t + wred byte mode (%d)\n"
785 "\t\t + head drop (%d)\n"
786 "\t\t + wred context private (%d)\n"
787 "\t\t + wred context shared (%u)\n",
788 cap
->leaf
.cman_wred_packet_mode_supported
,
789 cap
->leaf
.cman_wred_byte_mode_supported
,
790 cap
->leaf
.cman_head_drop_supported
,
791 cap
->leaf
.cman_wred_context_private_supported
,
792 cap
->leaf
.cman_wred_context_shared_n_max
);
797 display_levelcap_info(int is_leaf
, struct rte_tm_level_capabilities
*cap
)
803 printf("\t -- shaper private: (%d) dual rate (%d)\n",
804 cap
->nonleaf
.shaper_private_supported
,
805 cap
->nonleaf
.shaper_private_dual_rate_supported
);
806 printf("\t -- shaper share: (%u)\n",
807 cap
->nonleaf
.shaper_shared_n_max
);
808 printf("\t -- non leaf sched MAX:\n"
809 "\t\t + children (%u)\n"
811 "\t\t + wfq children per group (%u)\n"
812 "\t\t + wfq groups (%u)\n"
813 "\t\t + wfq weight (%u)\n",
814 cap
->nonleaf
.sched_n_children_max
,
815 cap
->nonleaf
.sched_sp_n_priorities_max
,
816 cap
->nonleaf
.sched_wfq_n_children_per_group_max
,
817 cap
->nonleaf
.sched_wfq_n_groups_max
,
818 cap
->nonleaf
.sched_wfq_weight_max
);
820 printf("\t -- shaper private: (%d) dual rate (%d)\n",
821 cap
->leaf
.shaper_private_supported
,
822 cap
->leaf
.shaper_private_dual_rate_supported
);
823 printf("\t -- shaper share: (%u)\n",
824 cap
->leaf
.shaper_shared_n_max
);
825 printf(" -- leaf cman support:\n"
826 "\t\t + wred pkt mode (%d)\n"
827 "\t\t + wred byte mode (%d)\n"
828 "\t\t + head drop (%d)\n"
829 "\t\t + wred context private (%d)\n"
830 "\t\t + wred context shared (%u)\n",
831 cap
->leaf
.cman_wred_packet_mode_supported
,
832 cap
->leaf
.cman_wred_byte_mode_supported
,
833 cap
->leaf
.cman_head_drop_supported
,
834 cap
->leaf
.cman_wred_context_private_supported
,
835 cap
->leaf
.cman_wred_context_shared_n_max
);
842 int ret
= 0, check_for_leaf
= 0, is_leaf
= 0;
846 snprintf(bdr_str
, MAX_STRING_LEN
, " show - TM PMD %"PRIu64
,
848 STATS_BDR_STR(10, bdr_str
);
850 RTE_ETH_FOREACH_DEV(i
) {
851 struct rte_eth_dev_info dev_info
;
852 struct rte_tm_capabilities cap
;
853 struct rte_tm_error error
;
854 struct rte_tm_node_capabilities capnode
;
855 struct rte_tm_level_capabilities caplevel
;
856 uint32_t n_leaf_nodes
= 0;
858 memset(&cap
, 0, sizeof(cap
));
859 memset(&error
, 0, sizeof(error
));
861 ret
= rte_eth_dev_info_get(i
, &dev_info
);
863 printf("Error during getting device (port %u) info: %s\n",
868 printf(" - Generic for port (%u)\n"
869 "\t -- driver name %s\n"
870 "\t -- max vf (%u)\n"
871 "\t -- max tx queues (%u)\n"
872 "\t -- number of tx queues (%u)\n",
874 dev_info
.driver_name
,
876 dev_info
.max_tx_queues
,
877 dev_info
.nb_tx_queues
);
879 ret
= rte_tm_capabilities_get(i
, &cap
, &error
);
883 printf(" - MAX: nodes (%u) levels (%u) children (%u)\n",
886 cap
.sched_n_children_max
);
888 printf(" - identical nodes: non leaf (%d) leaf (%d)\n",
889 cap
.non_leaf_nodes_identical
,
890 cap
.leaf_nodes_identical
);
892 printf(" - Shaper MAX:\n"
894 "\t -- private (%u) private dual (%d)\n"
895 "\t -- shared (%u) shared dual (%u)\n",
897 cap
.shaper_private_n_max
,
898 cap
.shaper_private_dual_rate_n_max
,
899 cap
.shaper_shared_n_max
,
900 cap
.shaper_shared_dual_rate_n_max
);
902 printf(" - mark support:\n");
903 printf("\t -- vlan dei: GREEN (%d) YELLOW (%d) RED (%d)\n",
904 cap
.mark_vlan_dei_supported
[RTE_COLOR_GREEN
],
905 cap
.mark_vlan_dei_supported
[RTE_COLOR_YELLOW
],
906 cap
.mark_vlan_dei_supported
[RTE_COLOR_RED
]);
907 printf("\t -- ip ecn tcp: GREEN (%d) YELLOW (%d) RED (%d)\n",
908 cap
.mark_ip_ecn_tcp_supported
[RTE_COLOR_GREEN
],
909 cap
.mark_ip_ecn_tcp_supported
[RTE_COLOR_YELLOW
],
910 cap
.mark_ip_ecn_tcp_supported
[RTE_COLOR_RED
]);
911 printf("\t -- ip ecn sctp: GREEN (%d) YELLOW (%d) RED (%d)\n",
912 cap
.mark_ip_ecn_sctp_supported
[RTE_COLOR_GREEN
],
913 cap
.mark_ip_ecn_sctp_supported
[RTE_COLOR_YELLOW
],
914 cap
.mark_ip_ecn_sctp_supported
[RTE_COLOR_RED
]);
915 printf("\t -- ip dscp: GREEN (%d) YELLOW (%d) RED (%d)\n",
916 cap
.mark_ip_dscp_supported
[RTE_COLOR_GREEN
],
917 cap
.mark_ip_dscp_supported
[RTE_COLOR_YELLOW
],
918 cap
.mark_ip_dscp_supported
[RTE_COLOR_RED
]);
920 printf(" - mask stats (0x%"PRIx64
")"
921 " dynamic update (0x%"PRIx64
")\n",
923 cap
.dynamic_update_mask
);
925 printf(" - sched MAX:\n"
927 "\t -- sp levels (%u)\n"
928 "\t -- wfq children per group (%u)\n"
929 "\t -- wfq groups (%u)\n"
930 "\t -- wfq weight (%u)\n",
931 cap
.sched_sp_n_priorities_max
,
932 cap
.sched_sp_n_priorities_max
,
933 cap
.sched_wfq_n_children_per_group_max
,
934 cap
.sched_wfq_n_groups_max
,
935 cap
.sched_wfq_weight_max
);
937 printf(" - CMAN support:\n"
938 "\t -- WRED mode: pkt (%d) byte (%d)\n"
939 "\t -- head drop (%d)\n",
940 cap
.cman_wred_packet_mode_supported
,
941 cap
.cman_wred_byte_mode_supported
,
942 cap
.cman_head_drop_supported
);
943 printf("\t -- MAX WRED CONTEXT:"
944 " total (%u) private (%u) shared (%u)\n",
945 cap
.cman_wred_context_n_max
,
946 cap
.cman_wred_context_private_n_max
,
947 cap
.cman_wred_context_shared_n_max
);
949 for (j
= 0; j
< cap
.n_nodes_max
; j
++) {
950 memset(&capnode
, 0, sizeof(capnode
));
951 ret
= rte_tm_node_capabilities_get(i
, j
,
958 printf(" NODE %u\n", j
);
959 printf("\t - shaper private: (%d) dual rate (%d)\n",
960 capnode
.shaper_private_supported
,
961 capnode
.shaper_private_dual_rate_supported
);
962 printf("\t - shaper shared max: (%u)\n",
963 capnode
.shaper_shared_n_max
);
964 printf("\t - stats mask %"PRIx64
"\n",
967 ret
= rte_tm_node_type_get(i
, j
, &is_leaf
, &error
);
971 display_nodecap_info(is_leaf
, &capnode
);
974 for (j
= 0; j
< cap
.n_levels_max
; j
++) {
975 memset(&caplevel
, 0, sizeof(caplevel
));
976 ret
= rte_tm_level_capabilities_get(i
, j
,
981 printf(" - Level %u\n", j
);
982 printf("\t -- node MAX: %u non leaf %u leaf %u\n",
983 caplevel
.n_nodes_max
,
984 caplevel
.n_nodes_nonleaf_max
,
985 caplevel
.n_nodes_leaf_max
);
986 printf("\t -- indetical: non leaf %u leaf %u\n",
987 caplevel
.non_leaf_nodes_identical
,
988 caplevel
.leaf_nodes_identical
);
990 for (k
= 0; k
< caplevel
.n_nodes_max
; k
++) {
991 ret
= rte_tm_node_type_get(i
, k
,
996 display_levelcap_info(is_leaf
, &caplevel
);
1000 if (check_for_leaf
) {
1001 ret
= rte_tm_get_number_of_leaf_nodes(i
,
1002 &n_leaf_nodes
, &error
);
1004 printf(" - leaf nodes (%u)\n", n_leaf_nodes
);
1007 for (j
= 0; j
< n_leaf_nodes
; j
++) {
1008 struct rte_tm_node_stats stats
;
1009 memset(&stats
, 0, sizeof(stats
));
1011 ret
= rte_tm_node_stats_read(i
, j
,
1012 &stats
, &cap
.stats_mask
, 0, &error
);
1016 printf(" - STATS for node (%u)\n", j
);
1017 printf(" -- pkts (%"PRIu64
") bytes (%"PRIu64
")\n",
1018 stats
.n_pkts
, stats
.n_bytes
);
1020 ret
= rte_tm_node_type_get(i
, j
, &is_leaf
, &error
);
1021 if (ret
|| (!is_leaf
))
1024 printf(" -- leaf queued:"
1025 " pkts (%"PRIu64
") bytes (%"PRIu64
")\n",
1026 stats
.leaf
.n_pkts_queued
,
1027 stats
.leaf
.n_bytes_queued
);
1028 printf(" - dropped:\n"
1030 " pkts (%"PRIu64
") bytes (%"PRIu64
")\n"
1032 " pkts (%"PRIu64
") bytes (%"PRIu64
")\n"
1034 " pkts (%"PRIu64
") bytes (%"PRIu64
")\n",
1035 stats
.leaf
.n_pkts_dropped
[RTE_COLOR_GREEN
],
1036 stats
.leaf
.n_bytes_dropped
[RTE_COLOR_GREEN
],
1037 stats
.leaf
.n_pkts_dropped
[RTE_COLOR_YELLOW
],
1038 stats
.leaf
.n_bytes_dropped
[RTE_COLOR_YELLOW
],
1039 stats
.leaf
.n_pkts_dropped
[RTE_COLOR_RED
],
1040 stats
.leaf
.n_bytes_dropped
[RTE_COLOR_RED
]);
1044 STATS_BDR_STR(50, "");
1048 display_crypto_feature_info(uint64_t x
)
1053 printf("\t -- feature flags\n");
1054 printf("\t\t + symmetric (%c), asymmetric (%c)\n"
1055 "\t\t + symmetric operation chaining (%c)\n",
1056 (x
& RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO
) ? 'y' : 'n',
1057 (x
& RTE_CRYPTODEV_FF_ASYMMETRIC_CRYPTO
) ? 'y' : 'n',
1058 (x
& RTE_CRYPTODEV_FF_SYM_OPERATION_CHAINING
) ? 'y' : 'n');
1059 printf("\t\t + CPU: SSE (%c), AVX (%c), AVX2 (%c), AVX512 (%c)\n",
1060 (x
& RTE_CRYPTODEV_FF_CPU_SSE
) ? 'y' : 'n',
1061 (x
& RTE_CRYPTODEV_FF_CPU_AVX
) ? 'y' : 'n',
1062 (x
& RTE_CRYPTODEV_FF_CPU_AVX2
) ? 'y' : 'n',
1063 (x
& RTE_CRYPTODEV_FF_CPU_AVX512
) ? 'y' : 'n');
1064 printf("\t\t + AESNI: CPU (%c), HW (%c)\n",
1065 (x
& RTE_CRYPTODEV_FF_CPU_AESNI
) ? 'y' : 'n',
1066 (x
& RTE_CRYPTODEV_FF_HW_ACCELERATED
) ? 'y' : 'n');
1067 printf("\t\t + INLINE (%c)\n",
1068 (x
& RTE_CRYPTODEV_FF_SECURITY
) ? 'y' : 'n');
1069 printf("\t\t + ARM: NEON (%c), CE (%c)\n",
1070 (x
& RTE_CRYPTODEV_FF_CPU_NEON
) ? 'y' : 'n',
1071 (x
& RTE_CRYPTODEV_FF_CPU_ARM_CE
) ? 'y' : 'n');
1072 printf("\t -- buffer offload\n");
1073 printf("\t\t + IN_PLACE_SGL (%c)\n",
1074 (x
& RTE_CRYPTODEV_FF_IN_PLACE_SGL
) ? 'y' : 'n');
1075 printf("\t\t + OOP_SGL_IN_SGL_OUT (%c)\n",
1076 (x
& RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT
) ? 'y' : 'n');
1077 printf("\t\t + OOP_SGL_IN_LB_OUT (%c)\n",
1078 (x
& RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT
) ? 'y' : 'n');
1079 printf("\t\t + OOP_LB_IN_SGL_OUT (%c)\n",
1080 (x
& RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT
) ? 'y' : 'n');
1081 printf("\t\t + OOP_LB_IN_LB_OUT (%c)\n",
1082 (x
& RTE_CRYPTODEV_FF_OOP_LB_IN_LB_OUT
) ? 'y' : 'n');
1088 uint8_t crypto_dev_count
= rte_cryptodev_count(), i
;
1090 snprintf(bdr_str
, MAX_STRING_LEN
, " show - CRYPTO PMD %"PRIu64
,
1092 STATS_BDR_STR(10, bdr_str
);
1094 for (i
= 0; i
< crypto_dev_count
; i
++) {
1095 struct rte_cryptodev_info dev_info
;
1096 struct rte_cryptodev_stats stats
;
1098 rte_cryptodev_info_get(i
, &dev_info
);
1100 printf(" - device (%u)\n", i
);
1101 printf("\t -- name (%s)\n"
1102 "\t -- driver (%s)\n"
1103 "\t -- id (%u) on socket (%d)\n"
1104 "\t -- queue pairs (%d)\n",
1105 rte_cryptodev_name_get(i
),
1106 dev_info
.driver_name
,
1108 dev_info
.device
->numa_node
,
1109 rte_cryptodev_queue_pair_count(i
));
1111 display_crypto_feature_info(dev_info
.feature_flags
);
1113 memset(&stats
, 0, sizeof(0));
1114 if (rte_cryptodev_stats_get(i
, &stats
) == 0) {
1115 printf("\t -- stats\n");
1116 printf("\t\t + enqueue count (%"PRIu64
")"
1117 " error (%"PRIu64
")\n",
1118 stats
.enqueued_count
,
1119 stats
.enqueue_err_count
);
1120 printf("\t\t + dequeue count (%"PRIu64
")"
1121 " error (%"PRIu64
")\n",
1122 stats
.dequeued_count
,
1123 stats
.dequeue_err_count
);
1127 STATS_BDR_STR(50, "");
1131 show_ring(char *name
)
1133 snprintf(bdr_str
, MAX_STRING_LEN
, " show - RING %"PRIu64
,
1135 STATS_BDR_STR(10, bdr_str
);
1138 struct rte_ring
*ptr
= rte_ring_lookup(name
);
1140 printf(" - Name (%s) on socket (%d)\n"
1142 "\t -- Single Producer Enqueue (%u)\n"
1143 "\t -- Single Consmer Dequeue (%u)\n",
1145 ptr
->memzone
->socket_id
,
1146 ptr
->flags
& RING_F_SP_ENQ
,
1147 ptr
->flags
& RING_F_SC_DEQ
);
1148 printf(" - size (%u) mask (0x%x) capacity (%u)\n",
1152 printf(" - count (%u) free count (%u)\n",
1153 rte_ring_count(ptr
),
1154 rte_ring_free_count(ptr
));
1155 printf(" - full (%d) empty (%d)\n",
1157 rte_ring_empty(ptr
));
1159 STATS_BDR_STR(50, "");
1164 rte_ring_list_dump(stdout
);
1165 STATS_BDR_STR(50, "");
1169 show_mempool(char *name
)
1173 snprintf(bdr_str
, MAX_STRING_LEN
, " show - MEMPOOL %"PRIu64
,
1175 STATS_BDR_STR(10, bdr_str
);
1178 struct rte_mempool
*ptr
= rte_mempool_lookup(name
);
1181 printf(" - Name: %s on socket %d\n"
1183 "\t -- No spread (%c)\n"
1184 "\t -- No cache align (%c)\n"
1185 "\t -- SP put (%c), SC get (%c)\n"
1186 "\t -- Pool created (%c)\n"
1187 "\t -- No IOVA config (%c)\n",
1190 (flags
& MEMPOOL_F_NO_SPREAD
) ? 'y' : 'n',
1191 (flags
& MEMPOOL_F_NO_CACHE_ALIGN
) ? 'y' : 'n',
1192 (flags
& MEMPOOL_F_SP_PUT
) ? 'y' : 'n',
1193 (flags
& MEMPOOL_F_SC_GET
) ? 'y' : 'n',
1194 (flags
& MEMPOOL_F_POOL_CREATED
) ? 'y' : 'n',
1195 (flags
& MEMPOOL_F_NO_IOVA_CONTIG
) ? 'y' : 'n');
1196 printf(" - Size %u Cache %u element %u\n"
1197 " - header %u trailer %u\n"
1198 " - private data size %u\n",
1204 ptr
->private_data_size
);
1205 printf(" - memezone - socket %d\n",
1206 ptr
->mz
->socket_id
);
1207 printf(" - Count: avail (%u), in use (%u)\n",
1208 rte_mempool_avail_count(ptr
),
1209 rte_mempool_in_use_count(ptr
));
1211 STATS_BDR_STR(50, "");
1216 rte_mempool_list_dump(stdout
);
1217 STATS_BDR_STR(50, "");
1221 mempool_itr_obj(struct rte_mempool
*mp
, void *opaque
,
1222 void *obj
, unsigned int obj_idx
)
1224 printf(" - obj_idx %u opaque %p obj %p\n",
1225 obj_idx
, opaque
, obj
);
1228 rte_hexdump(stdout
, " Obj Content",
1229 obj
, (mp
->elt_size
> 256)?256:mp
->elt_size
);
1233 iter_mempool(char *name
)
1235 snprintf(bdr_str
, MAX_STRING_LEN
, " iter - MEMPOOL %"PRIu64
,
1237 STATS_BDR_STR(10, bdr_str
);
1240 struct rte_mempool
*ptr
= rte_mempool_lookup(name
);
1242 /* iterate each object */
1243 uint32_t ret
= rte_mempool_obj_iter(ptr
,
1244 mempool_itr_obj
, NULL
);
1245 printf("\n - iterated %u objects\n", ret
);
1246 STATS_BDR_STR(50, "");
1251 STATS_BDR_STR(50, "");
1255 main(int argc
, char **argv
)
1259 char c_flag
[] = "-c1";
1260 char n_flag
[] = "-n4";
1261 char mp_flag
[] = "--proc-type=secondary";
1262 char *argp
[argc
+ 3];
1265 /* preparse app arguments */
1266 ret
= proc_info_preparse_args(argc
, argv
);
1268 printf("Failed to parse arguments\n");
1277 for (i
= 1; i
< argc
; i
++)
1278 argp
[i
+ 3] = argv
[i
];
1282 ret
= rte_eal_init(argc
, argp
);
1284 rte_panic("Cannot init EAL\n");
1289 if (!rte_eal_primary_proc_alive(NULL
))
1290 rte_exit(EXIT_FAILURE
, "No primary DPDK process is running.\n");
1292 /* parse app arguments */
1293 ret
= proc_info_parse_args(argc
, argv
);
1295 rte_exit(EXIT_FAILURE
, "Invalid argument\n");
1302 nb_ports
= rte_eth_dev_count_avail();
1304 rte_exit(EXIT_FAILURE
, "No Ethernet ports - bye\n");
1306 /* If no port mask was specified*/
1307 if (enabled_port_mask
== 0)
1308 enabled_port_mask
= 0xffff;
1310 RTE_ETH_FOREACH_DEV(i
) {
1311 if (enabled_port_mask
& (1 << i
)) {
1313 nic_stats_display(i
);
1314 else if (enable_xstats
)
1315 nic_xstats_display(i
);
1316 else if (reset_stats
)
1318 else if (reset_xstats
)
1319 nic_xstats_clear(i
);
1320 else if (enable_xstats_name
)
1321 nic_xstats_by_name_display(i
, xstats_name
);
1322 else if (nb_xstats_ids
> 0)
1323 nic_xstats_by_ids_display(i
, xstats_ids
,
1325 else if (enable_metrics
)
1330 /* print port independent stats */
1332 metrics_display(RTE_METRICS_GLOBAL
);
1334 /* show information for PMD */
1335 if (enable_shw_port
)
1339 if (enable_shw_crypto
)
1341 if (enable_shw_ring
)
1342 show_ring(ring_name
);
1343 if (enable_shw_mempool
)
1344 show_mempool(mempool_name
);
1345 if (enable_iter_mempool
)
1346 iter_mempool(mempool_iter_name
);
1348 ret
= rte_eal_cleanup();
1350 printf("Error from rte_eal_cleanup(), %d\n", ret
);
1352 strlcpy(bdr_str
, " ", MAX_STRING_LEN
);
1353 STATS_BDR_STR(50, bdr_str
);