X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest-pmd%2Futil.c;h=fd98e8b51d0152a59d7290c15a3883d89814c488;hb=c8557ed434213fe11ecd867819823ea6865311d2;hp=418d74e589e7bef46d0a94a94baeed6e26450c3d;hpb=b57b66a97ebfbeb6cd98077db499ecc20ee6fb9d;p=dpdk.git diff --git a/app/test-pmd/util.c b/app/test-pmd/util.c index 418d74e589..fd98e8b51d 100644 --- a/app/test-pmd/util.c +++ b/app/test-pmd/util.c @@ -1,10 +1,11 @@ /* SPDX-License-Identifier: BSD-3-Clause * Copyright(c) 2010-2014 Intel Corporation - * Copyright(c) 2018 Mellanox Technology + * Copyright 2018 Mellanox Technologies, Ltd */ #include +#include #include #include #include @@ -14,12 +15,56 @@ #include "testpmd.h" +#define MAX_STRING_LEN 8192 + +#define MKDUMPSTR(buf, buf_size, cur_len, ...) \ +do { \ + if (cur_len >= buf_size) \ + break; \ + cur_len += snprintf(buf + cur_len, buf_size - cur_len, __VA_ARGS__); \ +} while (0) + static inline void -print_ether_addr(const char *what, const struct rte_ether_addr *eth_addr) +print_ether_addr(const char *what, const struct rte_ether_addr *eth_addr, + char print_buf[], size_t buf_size, size_t *cur_len) { char buf[RTE_ETHER_ADDR_FMT_SIZE]; + rte_ether_format_addr(buf, RTE_ETHER_ADDR_FMT_SIZE, eth_addr); - printf("%s%s", what, buf); + MKDUMPSTR(print_buf, buf_size, *cur_len, "%s%s", what, buf); +} + +static inline bool +is_timestamp_enabled(const struct rte_mbuf *mbuf) +{ + static uint64_t timestamp_rx_dynflag; + int timestamp_rx_dynflag_offset; + + if (timestamp_rx_dynflag == 0) { + timestamp_rx_dynflag_offset = rte_mbuf_dynflag_lookup( + RTE_MBUF_DYNFLAG_RX_TIMESTAMP_NAME, NULL); + if (timestamp_rx_dynflag_offset < 0) + return false; + timestamp_rx_dynflag = RTE_BIT64(timestamp_rx_dynflag_offset); + } + + return (mbuf->ol_flags & timestamp_rx_dynflag) != 0; +} + +static inline rte_mbuf_timestamp_t +get_timestamp(const struct rte_mbuf *mbuf) +{ + static int timestamp_dynfield_offset = -1; + + if (timestamp_dynfield_offset < 0) { + timestamp_dynfield_offset = rte_mbuf_dynfield_lookup( + RTE_MBUF_DYNFIELD_TIMESTAMP_NAME, NULL); + if (timestamp_dynfield_offset < 0) + return 0; + } + + return *RTE_MBUF_DYNFIELD(mbuf, + timestamp_dynfield_offset, rte_mbuf_timestamp_t *); } static inline void @@ -40,83 +85,152 @@ dump_pkt_burst(uint16_t port_id, uint16_t queue, struct rte_mbuf *pkts[], uint32_t vx_vni; const char *reason; int dynf_index; + char print_buf[MAX_STRING_LEN]; + size_t buf_size = MAX_STRING_LEN; + size_t cur_len = 0; if (!nb_pkts) return; - printf("port %u/queue %u: %s %u packets\n", - port_id, queue, - is_rx ? "received" : "sent", - (unsigned int) nb_pkts); + MKDUMPSTR(print_buf, buf_size, cur_len, + "port %u/queue %u: %s %u packets\n", port_id, queue, + is_rx ? "received" : "sent", (unsigned int) nb_pkts); for (i = 0; i < nb_pkts; i++) { + int ret; + struct rte_flow_error error; + struct rte_flow_restore_info info = { 0, }; + mb = pkts[i]; + if (rxq_share > 0) + MKDUMPSTR(print_buf, buf_size, cur_len, "port %u, ", + mb->port); eth_hdr = rte_pktmbuf_read(mb, 0, sizeof(_eth_hdr), &_eth_hdr); eth_type = RTE_BE_TO_CPU_16(eth_hdr->ether_type); - ol_flags = mb->ol_flags; packet_type = mb->packet_type; is_encapsulation = RTE_ETH_IS_TUNNEL_PKT(packet_type); - - print_ether_addr(" src=", ð_hdr->s_addr); - print_ether_addr(" - dst=", ð_hdr->d_addr); - printf(" - type=0x%04x - length=%u - nb_segs=%d", - eth_type, (unsigned int) mb->pkt_len, - (int)mb->nb_segs); - if (ol_flags & PKT_RX_RSS_HASH) { - printf(" - RSS hash=0x%x", (unsigned int) mb->hash.rss); - printf(" - RSS queue=0x%x", (unsigned int) queue); + ret = rte_flow_get_restore_info(port_id, mb, &info, &error); + if (!ret) { + MKDUMPSTR(print_buf, buf_size, cur_len, + "restore info:"); + if (info.flags & RTE_FLOW_RESTORE_INFO_TUNNEL) { + struct port_flow_tunnel *port_tunnel; + + port_tunnel = port_flow_locate_tunnel + (port_id, &info.tunnel); + MKDUMPSTR(print_buf, buf_size, cur_len, + " - tunnel"); + if (port_tunnel) + MKDUMPSTR(print_buf, buf_size, cur_len, + " #%u", port_tunnel->id); + else + MKDUMPSTR(print_buf, buf_size, cur_len, + " %s", "-none-"); + MKDUMPSTR(print_buf, buf_size, cur_len, + " type %s", port_flow_tunnel_type + (&info.tunnel)); + } else { + MKDUMPSTR(print_buf, buf_size, cur_len, + " - no tunnel info"); + } + if (info.flags & RTE_FLOW_RESTORE_INFO_ENCAPSULATED) + MKDUMPSTR(print_buf, buf_size, cur_len, + " - outer header present"); + else + MKDUMPSTR(print_buf, buf_size, cur_len, + " - no outer header"); + if (info.flags & RTE_FLOW_RESTORE_INFO_GROUP_ID) + MKDUMPSTR(print_buf, buf_size, cur_len, + " - miss group %u", info.group_id); + else + MKDUMPSTR(print_buf, buf_size, cur_len, + " - no miss group"); + MKDUMPSTR(print_buf, buf_size, cur_len, "\n"); } - if (ol_flags & PKT_RX_FDIR) { - printf(" - FDIR matched "); - if (ol_flags & PKT_RX_FDIR_ID) - printf("ID=0x%x", - mb->hash.fdir.hi); - else if (ol_flags & PKT_RX_FDIR_FLX) - printf("flex bytes=0x%08x %08x", - mb->hash.fdir.hi, mb->hash.fdir.lo); + print_ether_addr(" src=", ð_hdr->src_addr, + print_buf, buf_size, &cur_len); + print_ether_addr(" - dst=", ð_hdr->dst_addr, + print_buf, buf_size, &cur_len); + MKDUMPSTR(print_buf, buf_size, cur_len, + " - type=0x%04x - length=%u - nb_segs=%d", + eth_type, (unsigned int) mb->pkt_len, + (int)mb->nb_segs); + ol_flags = mb->ol_flags; + if (ol_flags & RTE_MBUF_F_RX_RSS_HASH) { + MKDUMPSTR(print_buf, buf_size, cur_len, + " - RSS hash=0x%x", + (unsigned int) mb->hash.rss); + MKDUMPSTR(print_buf, buf_size, cur_len, + " - RSS queue=0x%x", (unsigned int) queue); + } + if (ol_flags & RTE_MBUF_F_RX_FDIR) { + MKDUMPSTR(print_buf, buf_size, cur_len, + " - FDIR matched "); + if (ol_flags & RTE_MBUF_F_RX_FDIR_ID) + MKDUMPSTR(print_buf, buf_size, cur_len, + "ID=0x%x", mb->hash.fdir.hi); + else if (ol_flags & RTE_MBUF_F_RX_FDIR_FLX) + MKDUMPSTR(print_buf, buf_size, cur_len, + "flex bytes=0x%08x %08x", + mb->hash.fdir.hi, mb->hash.fdir.lo); else - printf("hash=0x%x ID=0x%x ", - mb->hash.fdir.hash, mb->hash.fdir.id); + MKDUMPSTR(print_buf, buf_size, cur_len, + "hash=0x%x ID=0x%x ", + mb->hash.fdir.hash, mb->hash.fdir.id); } - if (ol_flags & PKT_RX_TIMESTAMP) - printf(" - timestamp %"PRIu64" ", mb->timestamp); - if (ol_flags & PKT_RX_QINQ) - printf(" - QinQ VLAN tci=0x%x, VLAN tci outer=0x%x", - mb->vlan_tci, mb->vlan_tci_outer); - else if (ol_flags & PKT_RX_VLAN) - printf(" - VLAN tci=0x%x", mb->vlan_tci); - if (!is_rx && (ol_flags & PKT_TX_DYNF_METADATA)) - printf(" - Tx metadata: 0x%x", - *RTE_FLOW_DYNF_METADATA(mb)); - if (is_rx && (ol_flags & PKT_RX_DYNF_METADATA)) - printf(" - Rx metadata: 0x%x", - *RTE_FLOW_DYNF_METADATA(mb)); + if (is_timestamp_enabled(mb)) + MKDUMPSTR(print_buf, buf_size, cur_len, + " - timestamp %"PRIu64" ", get_timestamp(mb)); + if (ol_flags & RTE_MBUF_F_RX_QINQ) + MKDUMPSTR(print_buf, buf_size, cur_len, + " - QinQ VLAN tci=0x%x, VLAN tci outer=0x%x", + mb->vlan_tci, mb->vlan_tci_outer); + else if (ol_flags & RTE_MBUF_F_RX_VLAN) + MKDUMPSTR(print_buf, buf_size, cur_len, + " - VLAN tci=0x%x", mb->vlan_tci); + if (!is_rx && (ol_flags & RTE_MBUF_DYNFLAG_TX_METADATA)) + MKDUMPSTR(print_buf, buf_size, cur_len, + " - Tx metadata: 0x%x", + *RTE_FLOW_DYNF_METADATA(mb)); + if (is_rx && (ol_flags & RTE_MBUF_DYNFLAG_RX_METADATA)) + MKDUMPSTR(print_buf, buf_size, cur_len, + " - Rx metadata: 0x%x", + *RTE_FLOW_DYNF_METADATA(mb)); for (dynf_index = 0; dynf_index < 64; dynf_index++) { if (dynf_names[dynf_index][0] != '\0') - printf(" - dynf %s: %d", - dynf_names[dynf_index], - !!(ol_flags & (1UL << dynf_index))); + MKDUMPSTR(print_buf, buf_size, cur_len, + " - dynf %s: %d", + dynf_names[dynf_index], + !!(ol_flags & (1UL << dynf_index))); } if (mb->packet_type) { rte_get_ptype_name(mb->packet_type, buf, sizeof(buf)); - printf(" - hw ptype: %s", buf); + MKDUMPSTR(print_buf, buf_size, cur_len, + " - hw ptype: %s", buf); } sw_packet_type = rte_net_get_ptype(mb, &hdr_lens, RTE_PTYPE_ALL_MASK); rte_get_ptype_name(sw_packet_type, buf, sizeof(buf)); - printf(" - sw ptype: %s", buf); + MKDUMPSTR(print_buf, buf_size, cur_len, " - sw ptype: %s", buf); if (sw_packet_type & RTE_PTYPE_L2_MASK) - printf(" - l2_len=%d", hdr_lens.l2_len); + MKDUMPSTR(print_buf, buf_size, cur_len, " - l2_len=%d", + hdr_lens.l2_len); if (sw_packet_type & RTE_PTYPE_L3_MASK) - printf(" - l3_len=%d", hdr_lens.l3_len); + MKDUMPSTR(print_buf, buf_size, cur_len, " - l3_len=%d", + hdr_lens.l3_len); if (sw_packet_type & RTE_PTYPE_L4_MASK) - printf(" - l4_len=%d", hdr_lens.l4_len); + MKDUMPSTR(print_buf, buf_size, cur_len, " - l4_len=%d", + hdr_lens.l4_len); if (sw_packet_type & RTE_PTYPE_TUNNEL_MASK) - printf(" - tunnel_len=%d", hdr_lens.tunnel_len); + MKDUMPSTR(print_buf, buf_size, cur_len, + " - tunnel_len=%d", hdr_lens.tunnel_len); if (sw_packet_type & RTE_PTYPE_INNER_L2_MASK) - printf(" - inner_l2_len=%d", hdr_lens.inner_l2_len); + MKDUMPSTR(print_buf, buf_size, cur_len, + " - inner_l2_len=%d", hdr_lens.inner_l2_len); if (sw_packet_type & RTE_PTYPE_INNER_L3_MASK) - printf(" - inner_l3_len=%d", hdr_lens.inner_l3_len); + MKDUMPSTR(print_buf, buf_size, cur_len, + " - inner_l3_len=%d", hdr_lens.inner_l3_len); if (sw_packet_type & RTE_PTYPE_INNER_L4_MASK) - printf(" - inner_l4_len=%d", hdr_lens.inner_l4_len); + MKDUMPSTR(print_buf, buf_size, cur_len, + " - inner_l4_len=%d", hdr_lens.inner_l4_len); if (is_encapsulation) { struct rte_ipv4_hdr *ipv4_hdr; struct rte_ipv6_hdr *ipv6_hdr; @@ -153,18 +267,32 @@ dump_pkt_burst(uint16_t port_id, uint16_t queue, struct rte_mbuf *pkts[], l2_len + l3_len + l4_len); udp_port = RTE_BE_TO_CPU_16(udp_hdr->dst_port); vx_vni = rte_be_to_cpu_32(vxlan_hdr->vx_vni); - printf(" - VXLAN packet: packet type =%d, " - "Destination UDP port =%d, VNI = %d", - packet_type, udp_port, vx_vni >> 8); + MKDUMPSTR(print_buf, buf_size, cur_len, + " - VXLAN packet: packet type =%d, " + "Destination UDP port =%d, VNI = %d, " + "last_rsvd = %d", packet_type, + udp_port, vx_vni >> 8, vx_vni & 0xff); } } - printf(" - %s queue=0x%x", is_rx ? "Receive" : "Send", - (unsigned int) queue); - printf("\n"); - rte_get_rx_ol_flag_list(mb->ol_flags, buf, sizeof(buf)); - printf(" ol_flags: %s\n", buf); + MKDUMPSTR(print_buf, buf_size, cur_len, + " - %s queue=0x%x", is_rx ? "Receive" : "Send", + (unsigned int) queue); + MKDUMPSTR(print_buf, buf_size, cur_len, "\n"); + if (is_rx) + rte_get_rx_ol_flag_list(mb->ol_flags, buf, sizeof(buf)); + else + rte_get_tx_ol_flag_list(mb->ol_flags, buf, sizeof(buf)); + + MKDUMPSTR(print_buf, buf_size, cur_len, + " ol_flags: %s\n", buf); if (rte_mbuf_check(mb, 1, &reason) < 0) - printf("INVALID mbuf: %s\n", reason); + MKDUMPSTR(print_buf, buf_size, cur_len, + "INVALID mbuf: %s\n", reason); + if (cur_len >= buf_size) + printf("%s ...\n", print_buf); + else + printf("%s", print_buf); + cur_len = 0; } } @@ -200,7 +328,7 @@ tx_pkt_set_md(uint16_t port_id, __rte_unused uint16_t queue, for (i = 0; i < nb_pkts; i++) { *RTE_FLOW_DYNF_METADATA(pkts[i]) = ports[port_id].tx_metadata; - pkts[i]->ol_flags |= PKT_TX_DYNF_METADATA; + pkts[i]->ol_flags |= RTE_MBUF_DYNFLAG_TX_METADATA; } return nb_pkts; } @@ -312,8 +440,23 @@ eth_dev_info_get_print_err(uint16_t port_id, ret = rte_eth_dev_info_get(port_id, dev_info); if (ret != 0) - printf("Error during getting device (port %u) info: %s\n", - port_id, strerror(-ret)); + fprintf(stderr, + "Error during getting device (port %u) info: %s\n", + port_id, strerror(-ret)); + + return ret; +} + +int +eth_dev_conf_get_print_err(uint16_t port_id, struct rte_eth_conf *dev_conf) +{ + int ret; + + ret = rte_eth_dev_conf_get(port_id, dev_conf); + if (ret != 0) + fprintf(stderr, + "Error during getting device configuration (port %u): %s\n", + port_id, strerror(-ret)); return ret; } @@ -329,7 +472,8 @@ eth_set_promisc_mode(uint16_t port, int enable) ret = rte_eth_promiscuous_disable(port); if (ret != 0) - printf("Error during %s promiscuous mode for port %u: %s\n", + fprintf(stderr, + "Error during %s promiscuous mode for port %u: %s\n", enable ? "enabling" : "disabling", port, rte_strerror(-ret)); } @@ -345,7 +489,8 @@ eth_set_allmulticast_mode(uint16_t port, int enable) ret = rte_eth_allmulticast_disable(port); if (ret != 0) - printf("Error during %s all-multicast mode for port %u: %s\n", + fprintf(stderr, + "Error during %s all-multicast mode for port %u: %s\n", enable ? "enabling" : "disabling", port, rte_strerror(-ret)); } @@ -357,7 +502,8 @@ eth_link_get_nowait_print_err(uint16_t port_id, struct rte_eth_link *link) ret = rte_eth_link_get_nowait(port_id, link); if (ret < 0) - printf("Device (port %u) link get (without wait) failed: %s\n", + fprintf(stderr, + "Device (port %u) link get (without wait) failed: %s\n", port_id, rte_strerror(-ret)); return ret; @@ -370,8 +516,9 @@ eth_macaddr_get_print_err(uint16_t port_id, struct rte_ether_addr *mac_addr) ret = rte_eth_macaddr_get(port_id, mac_addr); if (ret != 0) - printf("Error getting device (port %u) mac address: %s\n", - port_id, rte_strerror(-ret)); + fprintf(stderr, + "Error getting device (port %u) mac address: %s\n", + port_id, rte_strerror(-ret)); return ret; }