X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;ds=inline;f=app%2Ftest-pmd%2Ftestpmd.c;h=97ae52e17ecdd8661c9bf2dac088d75d987b807b;hb=ded0d2c0aaca537e282f3ab9b0691148b87c1c26;hp=3b568efd79217ba7113096432150d0a2c7158fe3;hpb=91c78e090eed7a2cfcc7945d8bc14532ce273e43;p=dpdk.git diff --git a/app/test-pmd/testpmd.c b/app/test-pmd/testpmd.c index 3b568efd79..97ae52e17e 100644 --- a/app/test-pmd/testpmd.c +++ b/app/test-pmd/testpmd.c @@ -9,7 +9,9 @@ #include #include #include +#ifndef RTE_EXEC_ENV_WINDOWS #include +#endif #include #include #include @@ -46,20 +48,23 @@ #include #include #include -#ifdef RTE_LIBRTE_IXGBE_PMD +#ifdef RTE_NET_IXGBE #include #endif -#ifdef RTE_LIBRTE_PDUMP +#ifdef RTE_LIB_PDUMP #include #endif #include #include -#ifdef RTE_LIBRTE_BITRATESTATS +#ifdef RTE_LIB_BITRATESTATS #include #endif -#ifdef RTE_LIBRTE_LATENCY_STATS +#ifdef RTE_LIB_LATENCYSTATS #include #endif +#ifdef RTE_EXEC_ENV_WINDOWS +#include +#endif #include "testpmd.h" @@ -83,7 +88,7 @@ uint16_t verbose_level = 0; /**< Silent by default. */ int testpmd_logtype; /**< Log type for testpmd logs */ -/* use master core for command line ? */ +/* use main core for command line ? */ uint8_t interactive = 0; uint8_t auto_start = 0; uint8_t tx_first; @@ -240,14 +245,13 @@ uint32_t tx_pkt_times_intra; /**< Timings for send scheduling in TXONLY mode, time between packets. */ uint16_t nb_pkt_per_burst = DEF_PKT_BURST; /**< Number of packets per burst. */ +uint16_t nb_pkt_flowgen_clones; /**< Number of Tx packet clones to send in flowgen mode. */ +int nb_flows_flowgen = 1024; /**< Number of flows in flowgen mode. */ uint16_t mb_mempool_cache = DEF_MBUF_CACHE; /**< Size of mbuf mempool cache. */ /* current configuration is in DCB or not,0 means it is not in DCB mode */ uint8_t dcb_config = 0; -/* Whether the dcb is in testing status */ -uint8_t dcb_test = 0; - /* * Configurable number of RX/TX queues. */ @@ -419,13 +423,13 @@ int do_mlockall = 0; * NIC bypass mode configuration options. */ -#if defined RTE_LIBRTE_IXGBE_PMD && defined RTE_LIBRTE_IXGBE_BYPASS +#if defined RTE_NET_IXGBE && defined RTE_LIBRTE_IXGBE_BYPASS /* The NIC bypass watchdog timeout. */ uint32_t bypass_timeout = RTE_PMD_IXGBE_BYPASS_TMT_OFF; #endif -#ifdef RTE_LIBRTE_LATENCY_STATS +#ifdef RTE_LIB_LATENCYSTATS /* * Set when latency stats is enabled in the commandline @@ -443,8 +447,11 @@ lcoreid_t latencystats_lcore_id = -1; * Ethernet device configuration. */ struct rte_eth_rxmode rx_mode = { - .max_rx_pkt_len = RTE_ETHER_MAX_LEN, - /**< Default maximum frame length. */ + /* Default maximum frame length. + * Zero is converted to "RTE_ETHER_MTU + PMD Ethernet overhead" + * in init_config(). + */ + .max_rx_pkt_len = 0, }; struct rte_eth_txmode tx_mode = { @@ -476,15 +483,6 @@ struct rte_fdir_conf fdir_conf = { volatile int test_done = 1; /* stop packet forwarding when set to 1. */ -struct queue_stats_mappings tx_queue_stats_mappings_array[MAX_TX_QUEUE_STATS_MAPPINGS]; -struct queue_stats_mappings rx_queue_stats_mappings_array[MAX_RX_QUEUE_STATS_MAPPINGS]; - -struct queue_stats_mappings *tx_queue_stats_mappings = tx_queue_stats_mappings_array; -struct queue_stats_mappings *rx_queue_stats_mappings = rx_queue_stats_mappings_array; - -uint16_t nb_tx_queue_stats_mappings = 0; -uint16_t nb_rx_queue_stats_mappings = 0; - /* * Display zero values by default for xstats */ @@ -503,7 +501,7 @@ uint8_t record_burst_stats; unsigned int num_sockets = 0; unsigned int socket_ids[RTE_MAX_NUMA_NODES]; -#ifdef RTE_LIBRTE_BITRATESTATS +#ifdef RTE_LIB_BITRATESTATS /* Bitrate statistics */ struct rte_stats_bitrates *bitrate_data; lcoreid_t bitrate_lcore_id; @@ -518,10 +516,69 @@ uint8_t gro_flush_cycles = GRO_DEFAULT_FLUSH_CYCLES; */ enum rte_eth_rx_mq_mode rx_mq_mode = ETH_MQ_RX_VMDQ_DCB_RSS; +/* + * Used to set forced link speed + */ +uint32_t eth_link_speed; + +/* + * ID of the current process in multi-process, used to + * configure the queues to be polled. + */ +int proc_id; + +/* + * Number of processes in multi-process, used to + * configure the queues to be polled. + */ +unsigned int num_procs = 1; + +static int +eth_dev_configure_mp(uint16_t port_id, uint16_t nb_rx_q, uint16_t nb_tx_q, + const struct rte_eth_conf *dev_conf) +{ + if (is_proc_primary()) + return rte_eth_dev_configure(port_id, nb_rx_q, nb_tx_q, + dev_conf); + return 0; +} + +static int +eth_dev_start_mp(uint16_t port_id) +{ + if (is_proc_primary()) + return rte_eth_dev_start(port_id); + + return 0; +} + +static int +eth_dev_stop_mp(uint16_t port_id) +{ + if (is_proc_primary()) + return rte_eth_dev_stop(port_id); + + return 0; +} + +static void +mempool_free_mp(struct rte_mempool *mp) +{ + if (is_proc_primary()) + rte_mempool_free(mp); +} + +static int +eth_dev_set_mtu_mp(uint16_t port_id, uint16_t mtu) +{ + if (is_proc_primary()) + return rte_eth_dev_set_mtu(port_id, mtu); + + return 0; +} + /* Forward function declarations */ static void setup_attached_port(portid_t pi); -static void map_port_queue_stats_mapping_registers(portid_t pi, - struct rte_port *port); static void check_all_ports_link_status(uint32_t port_mask); static int eth_event_callback(portid_t port_id, enum rte_eth_event_type type, @@ -581,7 +638,7 @@ set_default_fwd_lcores_config(void) } socket_ids[num_sockets++] = sock_num; } - if (i == rte_get_master_lcore()) + if (i == rte_get_main_lcore()) continue; fwd_lcores_cpuids[nb_lc++] = i; } @@ -634,6 +691,7 @@ set_def_fwd_config(void) set_default_fwd_ports_config(); } +#ifndef RTE_EXEC_ENV_WINDOWS /* extremely pessimistic estimation of memory required to create a mempool */ static int calc_mem_size(uint32_t nb_mbufs, uint32_t mbuf_sz, size_t pgsz, size_t *out) @@ -856,16 +914,23 @@ dma_unmap_cb(struct rte_mempool *mp __rte_unused, void *opaque __rte_unused, int ret; RTE_ETH_FOREACH_DEV(pid) { - struct rte_eth_dev *dev = - &rte_eth_devices[pid]; + struct rte_eth_dev_info dev_info; + + ret = eth_dev_info_get_print_err(pid, &dev_info); + if (ret != 0) { + TESTPMD_LOG(DEBUG, + "unable to get device info for port %d on addr 0x%p," + "mempool unmapping will not be performed\n", + pid, memhdr->addr); + continue; + } - ret = rte_dev_dma_unmap(dev->device, memhdr->addr, 0, - memhdr->len); + ret = rte_dev_dma_unmap(dev_info.device, memhdr->addr, 0, memhdr->len); if (ret) { TESTPMD_LOG(DEBUG, "unable to DMA unmap addr 0x%p " "for device %s\n", - memhdr->addr, dev->data->name); + memhdr->addr, dev_info.device->name); } } ret = rte_extmem_unregister(memhdr->addr, memhdr->len); @@ -891,19 +956,26 @@ dma_map_cb(struct rte_mempool *mp __rte_unused, void *opaque __rte_unused, return; } RTE_ETH_FOREACH_DEV(pid) { - struct rte_eth_dev *dev = - &rte_eth_devices[pid]; + struct rte_eth_dev_info dev_info; - ret = rte_dev_dma_map(dev->device, memhdr->addr, 0, - memhdr->len); + ret = eth_dev_info_get_print_err(pid, &dev_info); + if (ret != 0) { + TESTPMD_LOG(DEBUG, + "unable to get device info for port %d on addr 0x%p," + "mempool mapping will not be performed\n", + pid, memhdr->addr); + continue; + } + ret = rte_dev_dma_map(dev_info.device, memhdr->addr, 0, memhdr->len); if (ret) { TESTPMD_LOG(DEBUG, "unable to DMA map addr 0x%p " "for device %s\n", - memhdr->addr, dev->data->name); + memhdr->addr, dev_info.device->name); } } } +#endif static unsigned int setup_extbuf(uint32_t nb_mbufs, uint16_t mbuf_sz, unsigned int socket_id, @@ -974,10 +1046,20 @@ mbuf_pool_create(uint16_t mbuf_seg_size, unsigned nb_mbuf, { char pool_name[RTE_MEMPOOL_NAMESIZE]; struct rte_mempool *rte_mp = NULL; +#ifndef RTE_EXEC_ENV_WINDOWS uint32_t mb_size; mb_size = sizeof(struct rte_mbuf) + mbuf_seg_size; +#endif mbuf_poolname_build(socket_id, pool_name, sizeof(pool_name), size_idx); + if (!is_proc_primary()) { + rte_mp = rte_mempool_lookup(pool_name); + if (rte_mp == NULL) + rte_exit(EXIT_FAILURE, + "Get mbuf pool for socket %u failed: %s\n", + socket_id, rte_strerror(rte_errno)); + return rte_mp; + } TESTPMD_LOG(INFO, "create a new mbuf pool <%s>: n=%u, size=%u, socket=%u\n", @@ -993,6 +1075,7 @@ mbuf_pool_create(uint16_t mbuf_seg_size, unsigned nb_mbuf, mb_mempool_cache, 0, mbuf_seg_size, socket_id); break; } +#ifndef RTE_EXEC_ENV_WINDOWS case MP_ALLOC_ANON: { rte_mp = rte_mempool_create_empty(pool_name, nb_mbuf, @@ -1033,6 +1116,7 @@ mbuf_pool_create(uint16_t mbuf_seg_size, unsigned nb_mbuf, heap_socket); break; } +#endif case MP_ALLOC_XBUF: { struct rte_pktmbuf_extmem *ext_mem; @@ -1059,7 +1143,9 @@ mbuf_pool_create(uint16_t mbuf_seg_size, unsigned nb_mbuf, } } +#ifndef RTE_EXEC_ENV_WINDOWS err: +#endif if (rte_mp == NULL) { rte_exit(EXIT_FAILURE, "Creation of mbuf pool for socket %u failed: %s\n", @@ -1081,10 +1167,8 @@ check_socket_id(const unsigned int socket_id) if (new_socket_id(socket_id)) { if (!warning_once && numa_support) - printf("Warning: NUMA should be configured manually by" - " using --port-numa-config and" - " --ring-numa-config parameters along with" - " --numa.\n"); + fprintf(stderr, + "Warning: NUMA should be configured manually by using --port-numa-config and --ring-numa-config parameters along with --numa.\n"); warning_once = 1; return -1; } @@ -1131,11 +1215,9 @@ check_nb_rxq(queueid_t rxq) allowed_max_rxq = get_allowed_max_nb_rxq(&pid); if (rxq > allowed_max_rxq) { - printf("Fail: input rxq (%u) can't be greater " - "than max_rx_queues (%u) of port %u\n", - rxq, - allowed_max_rxq, - pid); + fprintf(stderr, + "Fail: input rxq (%u) can't be greater than max_rx_queues (%u) of port %u\n", + rxq, allowed_max_rxq, pid); return -1; } return 0; @@ -1181,11 +1263,9 @@ check_nb_txq(queueid_t txq) allowed_max_txq = get_allowed_max_nb_txq(&pid); if (txq > allowed_max_txq) { - printf("Fail: input txq (%u) can't be greater " - "than max_tx_queues (%u) of port %u\n", - txq, - allowed_max_txq, - pid); + fprintf(stderr, + "Fail: input txq (%u) can't be greater than max_tx_queues (%u) of port %u\n", + txq, allowed_max_txq, pid); return -1; } return 0; @@ -1256,21 +1336,17 @@ check_nb_rxd(queueid_t rxd) allowed_max_rxd = get_allowed_max_nb_rxd(&pid); if (rxd > allowed_max_rxd) { - printf("Fail: input rxd (%u) can't be greater " - "than max_rxds (%u) of port %u\n", - rxd, - allowed_max_rxd, - pid); + fprintf(stderr, + "Fail: input rxd (%u) can't be greater than max_rxds (%u) of port %u\n", + rxd, allowed_max_rxd, pid); return -1; } allowed_min_rxd = get_allowed_min_nb_rxd(&pid); if (rxd < allowed_min_rxd) { - printf("Fail: input rxd (%u) can't be less " - "than min_rxds (%u) of port %u\n", - rxd, - allowed_min_rxd, - pid); + fprintf(stderr, + "Fail: input rxd (%u) can't be less than min_rxds (%u) of port %u\n", + rxd, allowed_min_rxd, pid); return -1; } @@ -1341,21 +1417,17 @@ check_nb_txd(queueid_t txd) allowed_max_txd = get_allowed_max_nb_txd(&pid); if (txd > allowed_max_txd) { - printf("Fail: input txd (%u) can't be greater " - "than max_txds (%u) of port %u\n", - txd, - allowed_max_txd, - pid); + fprintf(stderr, + "Fail: input txd (%u) can't be greater than max_txds (%u) of port %u\n", + txd, allowed_max_txd, pid); return -1; } allowed_min_txd = get_allowed_min_nb_txd(&pid); if (txd < allowed_min_txd) { - printf("Fail: input txd (%u) can't be less " - "than min_txds (%u) of port %u\n", - txd, - allowed_min_txd, - pid); + fprintf(stderr, + "Fail: input txd (%u) can't be less than min_txds (%u) of port %u\n", + txd, allowed_min_txd, pid); return -1; } return 0; @@ -1401,31 +1473,82 @@ check_nb_hairpinq(queueid_t hairpinq) allowed_max_hairpinq = get_allowed_max_nb_hairpinq(&pid); if (hairpinq > allowed_max_hairpinq) { - printf("Fail: input hairpin (%u) can't be greater " - "than max_hairpin_queues (%u) of port %u\n", - hairpinq, allowed_max_hairpinq, pid); + fprintf(stderr, + "Fail: input hairpin (%u) can't be greater than max_hairpin_queues (%u) of port %u\n", + hairpinq, allowed_max_hairpinq, pid); return -1; } return 0; } +static void +init_config_port_offloads(portid_t pid, uint32_t socket_id) +{ + struct rte_port *port = &ports[pid]; + uint16_t data_size; + int ret; + int i; + + port->dev_conf.txmode = tx_mode; + port->dev_conf.rxmode = rx_mode; + + ret = eth_dev_info_get_print_err(pid, &port->dev_info); + if (ret != 0) + rte_exit(EXIT_FAILURE, "rte_eth_dev_info_get() failed\n"); + + ret = update_jumbo_frame_offload(pid); + if (ret != 0) + fprintf(stderr, + "Updating jumbo frame offload failed for port %u\n", + pid); + + if (!(port->dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MBUF_FAST_FREE)) + port->dev_conf.txmode.offloads &= + ~DEV_TX_OFFLOAD_MBUF_FAST_FREE; + + /* Apply Rx offloads configuration */ + for (i = 0; i < port->dev_info.max_rx_queues; i++) + port->rx_conf[i].offloads = port->dev_conf.rxmode.offloads; + /* Apply Tx offloads configuration */ + for (i = 0; i < port->dev_info.max_tx_queues; i++) + port->tx_conf[i].offloads = port->dev_conf.txmode.offloads; + + if (eth_link_speed) + port->dev_conf.link_speeds = eth_link_speed; + + /* set flag to initialize port/queue */ + port->need_reconfig = 1; + port->need_reconfig_queues = 1; + port->socket_id = socket_id; + port->tx_metadata = 0; + + /* + * Check for maximum number of segments per MTU. + * Accordingly update the mbuf data size. + */ + if (port->dev_info.rx_desc_lim.nb_mtu_seg_max != UINT16_MAX && + port->dev_info.rx_desc_lim.nb_mtu_seg_max != 0) { + data_size = rx_mode.max_rx_pkt_len / + port->dev_info.rx_desc_lim.nb_mtu_seg_max; + + if ((data_size + RTE_PKTMBUF_HEADROOM) > mbuf_data_size[0]) { + mbuf_data_size[0] = data_size + RTE_PKTMBUF_HEADROOM; + TESTPMD_LOG(WARNING, + "Configured mbuf size of the first segment %hu\n", + mbuf_data_size[0]); + } + } +} + static void init_config(void) { portid_t pid; - struct rte_port *port; struct rte_mempool *mbp; unsigned int nb_mbuf_per_pool; lcoreid_t lc_id; - uint8_t port_per_socket[RTE_MAX_NUMA_NODES]; struct rte_gro_param gro_param; uint32_t gso_types; - uint16_t data_size; - bool warning = 0; - int k; - int ret; - - memset(port_per_socket,0,RTE_MAX_NUMA_NODES); /* Configuration of logical cores. */ fwd_lcores = rte_zmalloc("testpmd: fwd_lcores", @@ -1447,25 +1570,12 @@ init_config(void) } RTE_ETH_FOREACH_DEV(pid) { - port = &ports[pid]; - /* Apply default TxRx configuration for all ports */ - port->dev_conf.txmode = tx_mode; - port->dev_conf.rxmode = rx_mode; - - ret = eth_dev_info_get_print_err(pid, &port->dev_info); - if (ret != 0) - rte_exit(EXIT_FAILURE, - "rte_eth_dev_info_get() failed\n"); + uint32_t socket_id; - if (!(port->dev_info.tx_offload_capa & - DEV_TX_OFFLOAD_MBUF_FAST_FREE)) - port->dev_conf.txmode.offloads &= - ~DEV_TX_OFFLOAD_MBUF_FAST_FREE; if (numa_support) { - if (port_numa[pid] != NUMA_NO_CONFIG) - port_per_socket[port_numa[pid]]++; - else { - uint32_t socket_id = rte_eth_dev_socket_id(pid); + socket_id = port_numa[pid]; + if (port_numa[pid] == NUMA_NO_CONFIG) { + socket_id = rte_eth_dev_socket_id(pid); /* * if socket_id is invalid, @@ -1473,45 +1583,14 @@ init_config(void) */ if (check_socket_id(socket_id) < 0) socket_id = socket_ids[0]; - port_per_socket[socket_id]++; - } - } - - /* Apply Rx offloads configuration */ - for (k = 0; k < port->dev_info.max_rx_queues; k++) - port->rx_conf[k].offloads = - port->dev_conf.rxmode.offloads; - /* Apply Tx offloads configuration */ - for (k = 0; k < port->dev_info.max_tx_queues; k++) - port->tx_conf[k].offloads = - port->dev_conf.txmode.offloads; - - /* set flag to initialize port/queue */ - port->need_reconfig = 1; - port->need_reconfig_queues = 1; - port->tx_metadata = 0; - - /* Check for maximum number of segments per MTU. Accordingly - * update the mbuf data size. - */ - if (port->dev_info.rx_desc_lim.nb_mtu_seg_max != UINT16_MAX && - port->dev_info.rx_desc_lim.nb_mtu_seg_max != 0) { - data_size = rx_mode.max_rx_pkt_len / - port->dev_info.rx_desc_lim.nb_mtu_seg_max; - - if ((data_size + RTE_PKTMBUF_HEADROOM) > - mbuf_data_size[0]) { - mbuf_data_size[0] = data_size + - RTE_PKTMBUF_HEADROOM; - warning = 1; } + } else { + socket_id = (socket_num == UMA_NO_CONFIG) ? + 0 : socket_num; } + /* Apply default TxRx configuration for all ports */ + init_config_port_offloads(pid, socket_id); } - - if (warning) - TESTPMD_LOG(WARNING, - "Configured mbuf size of the first segment %hu\n", - mbuf_data_size[0]); /* * Create pools of mbuf. * If NUMA support is disabled, create a single pool of mbuf in @@ -1573,10 +1652,6 @@ init_config(void) fwd_lcores[lc_id]->gso_ctx.flag = 0; } - /* Configuration of packet forwarding streams. */ - if (init_fwd_streams() < 0) - rte_exit(EXIT_FAILURE, "FAIL from init_fwd_streams()\n"); - fwd_config_setup(); /* create a gro context for each lcore */ @@ -1598,21 +1673,8 @@ init_config(void) void reconfig(portid_t new_port_id, unsigned socket_id) { - struct rte_port *port; - int ret; - /* Reconfiguration of Ethernet ports. */ - port = &ports[new_port_id]; - - ret = eth_dev_info_get_print_err(new_port_id, &port->dev_info); - if (ret != 0) - return; - - /* set flag to initialize port/queue */ - port->need_reconfig = 1; - port->need_reconfig_queues = 1; - port->socket_id = socket_id; - + init_config_port_offloads(new_port_id, socket_id); init_port_config(); } @@ -1629,15 +1691,15 @@ init_fwd_streams(void) RTE_ETH_FOREACH_DEV(pid) { port = &ports[pid]; if (nb_rxq > port->dev_info.max_rx_queues) { - printf("Fail: nb_rxq(%d) is greater than " - "max_rx_queues(%d)\n", nb_rxq, - port->dev_info.max_rx_queues); + fprintf(stderr, + "Fail: nb_rxq(%d) is greater than max_rx_queues(%d)\n", + nb_rxq, port->dev_info.max_rx_queues); return -1; } if (nb_txq > port->dev_info.max_tx_queues) { - printf("Fail: nb_txq(%d) is greater than " - "max_tx_queues(%d)\n", nb_txq, - port->dev_info.max_tx_queues); + fprintf(stderr, + "Fail: nb_txq(%d) is greater than max_tx_queues(%d)\n", + nb_txq, port->dev_info.max_tx_queues); return -1; } if (numa_support) { @@ -1664,7 +1726,8 @@ init_fwd_streams(void) q = RTE_MAX(nb_rxq, nb_txq); if (q == 0) { - printf("Fail: Cannot allocate fwd streams as number of queues is 0\n"); + fprintf(stderr, + "Fail: Cannot allocate fwd streams as number of queues is 0\n"); return -1; } nb_fwd_streams_new = (streamid_t)(nb_ports * q); @@ -1798,6 +1861,8 @@ fwd_stream_stats_display(streamid_t stream_id) " Rx- bad outer L4 checksum: %-14"PRIu64"\n", fs->rx_bad_ip_csum, fs->rx_bad_l4_csum, fs->rx_bad_outer_l4_csum); + printf(" RX- bad outer IP checksum: %-14"PRIu64"\n", + fs->rx_bad_outer_ip_csum); } else { printf("\n"); } @@ -1820,6 +1885,7 @@ fwd_stats_display(void) uint64_t rx_bad_ip_csum; uint64_t rx_bad_l4_csum; uint64_t rx_bad_outer_l4_csum; + uint64_t rx_bad_outer_ip_csum; } ports_stats[RTE_MAX_ETHPORTS]; uint64_t total_rx_dropped = 0; uint64_t total_tx_dropped = 0; @@ -1852,13 +1918,13 @@ fwd_stats_display(void) ports_stats[fs->rx_port].rx_bad_l4_csum += fs->rx_bad_l4_csum; ports_stats[fs->rx_port].rx_bad_outer_l4_csum += fs->rx_bad_outer_l4_csum; + ports_stats[fs->rx_port].rx_bad_outer_ip_csum += + fs->rx_bad_outer_ip_csum; if (record_core_cycles) fwd_cycles += fs->core_cycles; } for (i = 0; i < cur_fwd_config.nb_fwd_ports; i++) { - uint8_t j; - pt_id = fwd_ports_ids[i]; port = &ports[pt_id]; @@ -1881,88 +1947,37 @@ fwd_stats_display(void) printf("\n %s Forward statistics for port %-2d %s\n", fwd_stats_border, pt_id, fwd_stats_border); - if (!port->rx_queue_stats_mapping_enabled && - !port->tx_queue_stats_mapping_enabled) { - printf(" RX-packets: %-14"PRIu64 - " RX-dropped: %-14"PRIu64 - "RX-total: %-"PRIu64"\n", - stats.ipackets, stats.imissed, - stats.ipackets + stats.imissed); - - if (cur_fwd_eng == &csum_fwd_engine) - printf(" Bad-ipcsum: %-14"PRIu64 - " Bad-l4csum: %-14"PRIu64 - "Bad-outer-l4csum: %-14"PRIu64"\n", - ports_stats[pt_id].rx_bad_ip_csum, - ports_stats[pt_id].rx_bad_l4_csum, - ports_stats[pt_id].rx_bad_outer_l4_csum); - if (stats.ierrors + stats.rx_nombuf > 0) { - printf(" RX-error: %-"PRIu64"\n", - stats.ierrors); - printf(" RX-nombufs: %-14"PRIu64"\n", - stats.rx_nombuf); - } - - printf(" TX-packets: %-14"PRIu64 - " TX-dropped: %-14"PRIu64 - "TX-total: %-"PRIu64"\n", - stats.opackets, ports_stats[pt_id].tx_dropped, - stats.opackets + ports_stats[pt_id].tx_dropped); - } else { - printf(" RX-packets: %14"PRIu64 - " RX-dropped:%14"PRIu64 - " RX-total:%14"PRIu64"\n", - stats.ipackets, stats.imissed, - stats.ipackets + stats.imissed); - - if (cur_fwd_eng == &csum_fwd_engine) - printf(" Bad-ipcsum:%14"PRIu64 - " Bad-l4csum:%14"PRIu64 - " Bad-outer-l4csum: %-14"PRIu64"\n", - ports_stats[pt_id].rx_bad_ip_csum, - ports_stats[pt_id].rx_bad_l4_csum, - ports_stats[pt_id].rx_bad_outer_l4_csum); - if ((stats.ierrors + stats.rx_nombuf) > 0) { - printf(" RX-error:%"PRIu64"\n", stats.ierrors); - printf(" RX-nombufs: %14"PRIu64"\n", - stats.rx_nombuf); - } + printf(" RX-packets: %-14"PRIu64" RX-dropped: %-14"PRIu64 + "RX-total: %-"PRIu64"\n", stats.ipackets, stats.imissed, + stats.ipackets + stats.imissed); - printf(" TX-packets: %14"PRIu64 - " TX-dropped:%14"PRIu64 - " TX-total:%14"PRIu64"\n", - stats.opackets, ports_stats[pt_id].tx_dropped, - stats.opackets + ports_stats[pt_id].tx_dropped); + if (cur_fwd_eng == &csum_fwd_engine) { + printf(" Bad-ipcsum: %-14"PRIu64 + " Bad-l4csum: %-14"PRIu64 + "Bad-outer-l4csum: %-14"PRIu64"\n", + ports_stats[pt_id].rx_bad_ip_csum, + ports_stats[pt_id].rx_bad_l4_csum, + ports_stats[pt_id].rx_bad_outer_l4_csum); + printf(" Bad-outer-ipcsum: %-14"PRIu64"\n", + ports_stats[pt_id].rx_bad_outer_ip_csum); + } + if (stats.ierrors + stats.rx_nombuf > 0) { + printf(" RX-error: %-"PRIu64"\n", stats.ierrors); + printf(" RX-nombufs: %-14"PRIu64"\n", stats.rx_nombuf); } + printf(" TX-packets: %-14"PRIu64" TX-dropped: %-14"PRIu64 + "TX-total: %-"PRIu64"\n", + stats.opackets, ports_stats[pt_id].tx_dropped, + stats.opackets + ports_stats[pt_id].tx_dropped); + if (record_burst_stats) { if (ports_stats[pt_id].rx_stream) pkt_burst_stats_display("RX", &ports_stats[pt_id].rx_stream->rx_burst_stats); if (ports_stats[pt_id].tx_stream) pkt_burst_stats_display("TX", - &ports_stats[pt_id].tx_stream->tx_burst_stats); - } - - if (port->rx_queue_stats_mapping_enabled) { - printf("\n"); - for (j = 0; j < RTE_ETHDEV_QUEUE_STAT_CNTRS; j++) { - printf(" Stats reg %2d RX-packets:%14"PRIu64 - " RX-errors:%14"PRIu64 - " RX-bytes:%14"PRIu64"\n", - j, stats.q_ipackets[j], - stats.q_errors[j], stats.q_ibytes[j]); - } - printf("\n"); - } - if (port->tx_queue_stats_mapping_enabled) { - for (j = 0; j < RTE_ETHDEV_QUEUE_STAT_CNTRS; j++) { - printf(" Stats reg %2d TX-packets:%14"PRIu64 - " TX-bytes:%14" - PRIu64"\n", - j, stats.q_opackets[j], - stats.q_obytes[j]); - } + &ports_stats[pt_id].tx_stream->tx_burst_stats); } printf(" %s--------------------------------%s\n", @@ -2023,6 +2038,7 @@ fwd_stats_reset(void) fs->rx_bad_ip_csum = 0; fs->rx_bad_l4_csum = 0; fs->rx_bad_outer_l4_csum = 0; + fs->rx_bad_outer_ip_csum = 0; memset(&fs->rx_burst_stats, 0, sizeof(fs->rx_burst_stats)); memset(&fs->tx_burst_stats, 0, sizeof(fs->tx_burst_stats)); @@ -2043,6 +2059,11 @@ flush_fwd_rx_queues(void) uint64_t prev_tsc = 0, diff_tsc, cur_tsc, timer_tsc = 0; uint64_t timer_period; + if (num_procs > 1) { + printf("multi-process not support for flushing fwd Rx queues, skip the below lines and return.\n"); + return; + } + /* convert to number of cycles */ timer_period = rte_get_timer_hz(); /* 1 second timeout */ @@ -2081,7 +2102,7 @@ run_pkt_fwd_on_lcore(struct fwd_lcore *fc, packet_fwd_t pkt_fwd) struct fwd_stream **fsm; streamid_t nb_fs; streamid_t sm_id; -#ifdef RTE_LIBRTE_BITRATESTATS +#ifdef RTE_LIB_BITRATESTATS uint64_t tics_per_1sec; uint64_t tics_datum; uint64_t tics_current; @@ -2096,7 +2117,7 @@ run_pkt_fwd_on_lcore(struct fwd_lcore *fc, packet_fwd_t pkt_fwd) do { for (sm_id = 0; sm_id < nb_fs; sm_id++) (*pkt_fwd)(fsm[sm_id]); -#ifdef RTE_LIBRTE_BITRATESTATS +#ifdef RTE_LIB_BITRATESTATS if (bitrate_enabled != 0 && bitrate_lcore_id == rte_lcore_id()) { tics_current = rte_rdtsc(); @@ -2109,7 +2130,7 @@ run_pkt_fwd_on_lcore(struct fwd_lcore *fc, packet_fwd_t pkt_fwd) } } #endif -#ifdef RTE_LIBRTE_LATENCY_STATS +#ifdef RTE_LIB_LATENCYSTATS if (latencystats_enabled != 0 && latencystats_lcore_id == rte_lcore_id()) rte_latencystats_update(); @@ -2168,8 +2189,9 @@ launch_packet_forwarding(lcore_function_t *pkt_fwd_on_lcore) diag = rte_eal_remote_launch(pkt_fwd_on_lcore, fwd_lcores[i], lc_id); if (diag != 0) - printf("launch lcore %u failed - diag=%d\n", - lc_id, diag); + fprintf(stderr, + "launch lcore %u failed - diag=%d\n", + lc_id, diag); } } } @@ -2182,9 +2204,7 @@ start_packet_forwarding(int with_tx_first) { port_fwd_begin_t port_fwd_begin; port_fwd_end_t port_fwd_end; - struct rte_port *port; unsigned int i; - portid_t pt_id; if (strcmp(cur_fwd_eng->fwd_mode_name, "rxonly") == 0 && !nb_rxq) rte_exit(EXIT_FAILURE, "rxq are 0, cannot use rxonly fwd mode\n"); @@ -2200,31 +2220,13 @@ start_packet_forwarding(int with_tx_first) cur_fwd_eng->fwd_mode_name); if (all_ports_started() == 0) { - printf("Not all ports were started\n"); + fprintf(stderr, "Not all ports were started\n"); return; } if (test_done == 0) { - printf("Packet forwarding already started\n"); + fprintf(stderr, "Packet forwarding already started\n"); return; } - - - if(dcb_test) { - for (i = 0; i < nb_fwd_ports; i++) { - pt_id = fwd_ports_ids[i]; - port = &ports[pt_id]; - if (!port->dcb_flag) { - printf("In DCB mode, all forwarding ports must " - "be configured in this mode.\n"); - return; - } - } - if (nb_fwd_lcores == 1) { - printf("In DCB mode,the nb forwarding cores " - "should be larger than 1.\n"); - return; - } - } test_done = 0; fwd_config_setup(); @@ -2236,11 +2238,6 @@ start_packet_forwarding(int with_tx_first) rxtx_config_display(); fwd_stats_reset(); - for (i = 0; i < cur_fwd_config.nb_fwd_ports; i++) { - pt_id = fwd_ports_ids[i]; - port = &ports[pt_id]; - map_port_queue_stats_mapping_registers(pt_id, port); - } if (with_tx_first) { port_fwd_begin = tx_only_engine.port_fwd_begin; if (port_fwd_begin != NULL) { @@ -2270,7 +2267,7 @@ stop_packet_forwarding(void) int i; if (test_done) { - printf("Packet forwarding not started\n"); + fprintf(stderr, "Packet forwarding not started\n"); return; } printf("Telling cores to stop..."); @@ -2296,14 +2293,14 @@ void dev_set_link_up(portid_t pid) { if (rte_eth_dev_set_link_up(pid) < 0) - printf("\nSet link up fail.\n"); + fprintf(stderr, "\nSet link up fail.\n"); } void dev_set_link_down(portid_t pid) { if (rte_eth_dev_set_link_down(pid) < 0) - printf("\nSet link down fail.\n"); + fprintf(stderr, "\nSet link down fail.\n"); } static int @@ -2424,10 +2421,10 @@ setup_hairpin_queues(portid_t pi, portid_t p_pi, uint16_t cnt_pi) if (rte_atomic16_cmpset(&(port->port_status), RTE_PORT_HANDLING, RTE_PORT_STOPPED) == 0) - printf("Port %d can not be set back " - "to stopped\n", pi); - printf("Fail to configure port %d hairpin " - "queues\n", pi); + fprintf(stderr, + "Port %d can not be set back to stopped\n", pi); + fprintf(stderr, "Fail to configure port %d hairpin queues\n", + pi); /* try to reconfigure queues next time */ port->need_reconfig_queues = 1; return -1; @@ -2447,10 +2444,10 @@ setup_hairpin_queues(portid_t pi, portid_t p_pi, uint16_t cnt_pi) if (rte_atomic16_cmpset(&(port->port_status), RTE_PORT_HANDLING, RTE_PORT_STOPPED) == 0) - printf("Port %d can not be set back " - "to stopped\n", pi); - printf("Fail to configure port %d hairpin " - "queues\n", pi); + fprintf(stderr, + "Port %d can not be set back to stopped\n", pi); + fprintf(stderr, "Fail to configure port %d hairpin queues\n", + pi); /* try to reconfigure queues next time */ port->need_reconfig_queues = 1; return -1; @@ -2458,6 +2455,51 @@ setup_hairpin_queues(portid_t pi, portid_t p_pi, uint16_t cnt_pi) return 0; } +/* Configure the Rx with optional split. */ +int +rx_queue_setup(uint16_t port_id, uint16_t rx_queue_id, + uint16_t nb_rx_desc, unsigned int socket_id, + struct rte_eth_rxconf *rx_conf, struct rte_mempool *mp) +{ + union rte_eth_rxseg rx_useg[MAX_SEGS_BUFFER_SPLIT] = {}; + unsigned int i, mp_n; + int ret; + + if (rx_pkt_nb_segs <= 1 || + (rx_conf->offloads & RTE_ETH_RX_OFFLOAD_BUFFER_SPLIT) == 0) { + rx_conf->rx_seg = NULL; + rx_conf->rx_nseg = 0; + ret = rte_eth_rx_queue_setup(port_id, rx_queue_id, + nb_rx_desc, socket_id, + rx_conf, mp); + return ret; + } + for (i = 0; i < rx_pkt_nb_segs; i++) { + struct rte_eth_rxseg_split *rx_seg = &rx_useg[i].split; + struct rte_mempool *mpx; + /* + * Use last valid pool for the segments with number + * exceeding the pool index. + */ + mp_n = (i > mbuf_data_size_n) ? mbuf_data_size_n - 1 : i; + mpx = mbuf_pool_find(socket_id, mp_n); + /* Handle zero as mbuf data buffer size. */ + rx_seg->length = rx_pkt_seg_lengths[i] ? + rx_pkt_seg_lengths[i] : + mbuf_data_size[mp_n]; + rx_seg->offset = i < rx_pkt_nb_offs ? + rx_pkt_seg_offsets[i] : 0; + rx_seg->mp = mpx ? mpx : mp; + } + rx_conf->rx_nseg = rx_pkt_nb_segs; + rx_conf->rx_seg = rx_useg; + ret = rte_eth_rx_queue_setup(port_id, rx_queue_id, nb_rx_desc, + socket_id, rx_conf, NULL); + rx_conf->rx_seg = NULL; + rx_conf->rx_nseg = 0; + return ret; +} + int start_port(portid_t pid) { @@ -2471,14 +2513,11 @@ start_port(portid_t pid) int peer_pi; queueid_t qi; struct rte_port *port; - struct rte_ether_addr mac_addr; struct rte_eth_hairpin_cap cap; if (port_id_is_invalid(pid, ENABLED_WARN)) return 0; - if(dcb_config) - dcb_test = 1; RTE_ETH_FOREACH_DEV(pi) { if (pid != pi && pid != (portid_t)RTE_PORT_ALL) continue; @@ -2487,7 +2526,7 @@ start_port(portid_t pid) port = &ports[pi]; if (rte_atomic16_cmpset(&(port->port_status), RTE_PORT_STOPPED, RTE_PORT_HANDLING) == 0) { - printf("Port %d is now not stopped\n", pi); + fprintf(stderr, "Port %d is now not stopped\n", pi); continue; } @@ -2497,8 +2536,9 @@ start_port(portid_t pid) if (flow_isolate_all) { int ret = port_flow_isolate(pi, 1); if (ret) { - printf("Failed to apply isolated" - " mode on port %d\n", pi); + fprintf(stderr, + "Failed to apply isolated mode on port %d\n", + pi); return -1; } } @@ -2507,26 +2547,29 @@ start_port(portid_t pid) port->socket_id); if (nb_hairpinq > 0 && rte_eth_dev_hairpin_capability_get(pi, &cap)) { - printf("Port %d doesn't support hairpin " - "queues\n", pi); + fprintf(stderr, + "Port %d doesn't support hairpin queues\n", + pi); return -1; } /* configure port */ - diag = rte_eth_dev_configure(pi, nb_rxq + nb_hairpinq, + diag = eth_dev_configure_mp(pi, nb_rxq + nb_hairpinq, nb_txq + nb_hairpinq, &(port->dev_conf)); if (diag != 0) { if (rte_atomic16_cmpset(&(port->port_status), RTE_PORT_HANDLING, RTE_PORT_STOPPED) == 0) - printf("Port %d can not be set back " - "to stopped\n", pi); - printf("Fail to configure port %d\n", pi); + fprintf(stderr, + "Port %d can not be set back to stopped\n", + pi); + fprintf(stderr, "Fail to configure port %d\n", + pi); /* try to reconfigure port next time */ port->need_reconfig = 1; return -1; } } - if (port->need_reconfig_queues > 0) { + if (port->need_reconfig_queues > 0 && is_proc_primary()) { port->need_reconfig_queues = 0; /* setup tx queues */ for (qi = 0; qi < nb_txq; qi++) { @@ -2549,10 +2592,12 @@ start_port(portid_t pid) if (rte_atomic16_cmpset(&(port->port_status), RTE_PORT_HANDLING, RTE_PORT_STOPPED) == 0) - printf("Port %d can not be set back " - "to stopped\n", pi); - printf("Fail to configure port %d tx queues\n", - pi); + fprintf(stderr, + "Port %d can not be set back to stopped\n", + pi); + fprintf(stderr, + "Fail to configure port %d tx queues\n", + pi); /* try to reconfigure queues next time */ port->need_reconfig_queues = 1; return -1; @@ -2565,14 +2610,13 @@ start_port(portid_t pid) mbuf_pool_find (rxring_numa[pi], 0); if (mp == NULL) { - printf("Failed to setup RX queue:" - "No mempool allocation" - " on the socket %d\n", + fprintf(stderr, + "Failed to setup RX queue: No mempool allocation on the socket %d\n", rxring_numa[pi]); return -1; } - diag = rte_eth_rx_queue_setup(pi, qi, + diag = rx_queue_setup(pi, qi, port->nb_rx_desc[qi], rxring_numa[pi], &(port->rx_conf[qi]), @@ -2582,13 +2626,12 @@ start_port(portid_t pid) mbuf_pool_find (port->socket_id, 0); if (mp == NULL) { - printf("Failed to setup RX queue:" - "No mempool allocation" - " on the socket %d\n", + fprintf(stderr, + "Failed to setup RX queue: No mempool allocation on the socket %d\n", port->socket_id); return -1; } - diag = rte_eth_rx_queue_setup(pi, qi, + diag = rx_queue_setup(pi, qi, port->nb_rx_desc[qi], port->socket_id, &(port->rx_conf[qi]), @@ -2601,10 +2644,12 @@ start_port(portid_t pid) if (rte_atomic16_cmpset(&(port->port_status), RTE_PORT_HANDLING, RTE_PORT_STOPPED) == 0) - printf("Port %d can not be set back " - "to stopped\n", pi); - printf("Fail to configure port %d rx queues\n", - pi); + fprintf(stderr, + "Port %d can not be set back to stopped\n", + pi); + fprintf(stderr, + "Fail to configure port %d rx queues\n", + pi); /* try to reconfigure queues next time */ port->need_reconfig_queues = 1; return -1; @@ -2618,35 +2663,37 @@ start_port(portid_t pid) diag = rte_eth_dev_set_ptypes(pi, RTE_PTYPE_UNKNOWN, NULL, 0); if (diag < 0) - printf( - "Port %d: Failed to disable Ptype parsing\n", - pi); + fprintf(stderr, + "Port %d: Failed to disable Ptype parsing\n", + pi); } p_pi = pi; cnt_pi++; /* start port */ - if (rte_eth_dev_start(pi) < 0) { - printf("Fail to start port %d\n", pi); + diag = eth_dev_start_mp(pi); + if (diag < 0) { + fprintf(stderr, "Fail to start port %d: %s\n", + pi, rte_strerror(-diag)); /* Fail to setup rx queue, return */ if (rte_atomic16_cmpset(&(port->port_status), RTE_PORT_HANDLING, RTE_PORT_STOPPED) == 0) - printf("Port %d can not be set back to " - "stopped\n", pi); + fprintf(stderr, + "Port %d can not be set back to stopped\n", + pi); continue; } if (rte_atomic16_cmpset(&(port->port_status), RTE_PORT_HANDLING, RTE_PORT_STARTED) == 0) - printf("Port %d can not be set into started\n", pi); + fprintf(stderr, "Port %d can not be set into started\n", + pi); - if (eth_macaddr_get_print_err(pi, &mac_addr) == 0) - printf("Port %d: %02X:%02X:%02X:%02X:%02X:%02X\n", pi, - mac_addr.addr_bytes[0], mac_addr.addr_bytes[1], - mac_addr.addr_bytes[2], mac_addr.addr_bytes[3], - mac_addr.addr_bytes[4], mac_addr.addr_bytes[5]); + if (eth_macaddr_get_print_err(pi, &port->eth_addr) == 0) + printf("Port %d: " RTE_ETHER_ADDR_PRT_FMT "\n", pi, + RTE_ETHER_ADDR_BYTES(&port->eth_addr)); /* at least one port started, need checking link status */ need_check_link_status = 1; @@ -2657,7 +2704,7 @@ start_port(portid_t pid) if (need_check_link_status == 1 && !no_link_check) check_all_ports_link_status(RTE_PORT_ALL); else if (need_check_link_status == 0) - printf("Please stop the ports first\n"); + fprintf(stderr, "Please stop the ports first\n"); if (hairpin_mode & 0xf) { uint16_t i; @@ -2676,10 +2723,10 @@ start_port(portid_t pid) continue; diag = rte_eth_hairpin_bind(pi, peer_pl[j]); if (diag < 0) { - printf("Error during binding hairpin" - " Tx port %u to %u: %s\n", - pi, peer_pl[j], - rte_strerror(-diag)); + fprintf(stderr, + "Error during binding hairpin Tx port %u to %u: %s\n", + pi, peer_pl[j], + rte_strerror(-diag)); return -1; } } @@ -2693,10 +2740,10 @@ start_port(portid_t pid) continue; diag = rte_eth_hairpin_bind(peer_pl[j], pi); if (diag < 0) { - printf("Error during binding hairpin" - " Tx port %u to %u: %s\n", - peer_pl[j], pi, - rte_strerror(-diag)); + fprintf(stderr, + "Error during binding hairpin Tx port %u to %u: %s\n", + peer_pl[j], pi, + rte_strerror(-diag)); return -1; } } @@ -2716,11 +2763,6 @@ stop_port(portid_t pid) portid_t peer_pl[RTE_MAX_ETHPORTS]; int peer_pi; - if (dcb_test) { - dcb_test = 0; - dcb_config = 0; - } - if (port_id_is_invalid(pid, ENABLED_WARN)) return; @@ -2731,12 +2773,16 @@ stop_port(portid_t pid) continue; if (port_is_forwarding(pi) != 0 && test_done == 0) { - printf("Please remove port %d from forwarding configuration.\n", pi); + fprintf(stderr, + "Please remove port %d from forwarding configuration.\n", + pi); continue; } if (port_is_bonding_slave(pi)) { - printf("Please remove port %d from bonded device.\n", pi); + fprintf(stderr, + "Please remove port %d from bonded device.\n", + pi); continue; } @@ -2761,11 +2807,17 @@ stop_port(portid_t pid) } } - rte_eth_dev_stop(pi); + if (port->flow_list) + port_flow_flush(pi); + + if (eth_dev_stop_mp(pi) != 0) + RTE_LOG(ERR, EAL, "rte_eth_dev_stop failed for port %u\n", + pi); if (rte_atomic16_cmpset(&(port->port_status), RTE_PORT_HANDLING, RTE_PORT_STOPPED) == 0) - printf("Port %d can not be set into stopped\n", pi); + fprintf(stderr, "Port %d can not be set into stopped\n", + pi); need_check_link_status = 1; } if (need_check_link_status && !no_link_check) @@ -2812,24 +2864,30 @@ close_port(portid_t pid) continue; if (port_is_forwarding(pi) != 0 && test_done == 0) { - printf("Please remove port %d from forwarding configuration.\n", pi); + fprintf(stderr, + "Please remove port %d from forwarding configuration.\n", + pi); continue; } if (port_is_bonding_slave(pi)) { - printf("Please remove port %d from bonded device.\n", pi); + fprintf(stderr, + "Please remove port %d from bonded device.\n", + pi); continue; } port = &ports[pi]; if (rte_atomic16_cmpset(&(port->port_status), RTE_PORT_CLOSED, RTE_PORT_CLOSED) == 1) { - printf("Port %d is already closed\n", pi); + fprintf(stderr, "Port %d is already closed\n", pi); continue; } - port_flow_flush(pi); - rte_eth_dev_close(pi); + if (is_proc_primary()) { + port_flow_flush(pi); + rte_eth_dev_close(pi); + } } remove_invalid_ports(); @@ -2848,7 +2906,8 @@ reset_port(portid_t pid) if ((pid == (portid_t)RTE_PORT_ALL && !all_ports_stopped()) || (pid != (portid_t)RTE_PORT_ALL && !port_is_stopped(pid))) { - printf("Can not reset port(s), please stop port(s) first.\n"); + fprintf(stderr, + "Can not reset port(s), please stop port(s) first.\n"); return; } @@ -2859,14 +2918,16 @@ reset_port(portid_t pid) continue; if (port_is_forwarding(pi) != 0 && test_done == 0) { - printf("Please remove port %d from forwarding " - "configuration.\n", pi); + fprintf(stderr, + "Please remove port %d from forwarding configuration.\n", + pi); continue; } if (port_is_bonding_slave(pi)) { - printf("Please remove port %d from bonded device.\n", - pi); + fprintf(stderr, + "Please remove port %d from bonded device.\n", + pi); continue; } @@ -2876,7 +2937,8 @@ reset_port(portid_t pid) port->need_reconfig = 1; port->need_reconfig_queues = 1; } else { - printf("Failed to reset port %d. diag=%d\n", pi, diag); + fprintf(stderr, "Failed to reset port %d. diag=%d\n", + pi, diag); } } @@ -2892,7 +2954,7 @@ attach_port(char *identifier) printf("Attaching a new port...\n"); if (identifier == NULL) { - printf("Invalid parameters are specified\n"); + fprintf(stderr, "Invalid parameters are specified\n"); return; } @@ -2933,7 +2995,8 @@ setup_attached_port(portid_t pi) reconfig(pi, socket_id); ret = rte_eth_promiscuous_enable(pi); if (ret != 0) - printf("Error during enabling promiscuous mode for port %u: %s - ignore\n", + fprintf(stderr, + "Error during enabling promiscuous mode for port %u: %s - ignore\n", pi, rte_strerror(-ret)); ports_ids[nb_ports++] = pi; @@ -2952,7 +3015,7 @@ detach_device(struct rte_device *dev) portid_t sibling; if (dev == NULL) { - printf("Device already removed\n"); + fprintf(stderr, "Device already removed\n"); return; } @@ -2961,7 +3024,8 @@ detach_device(struct rte_device *dev) RTE_ETH_FOREACH_DEV_OF(sibling, dev) { if (ports[sibling].port_status != RTE_PORT_CLOSED) { if (ports[sibling].port_status != RTE_PORT_STOPPED) { - printf("Port %u not stopped\n", sibling); + fprintf(stderr, "Port %u not stopped\n", + sibling); return; } port_flow_flush(sibling); @@ -2983,18 +3047,28 @@ detach_device(struct rte_device *dev) void detach_port_device(portid_t port_id) { + int ret; + struct rte_eth_dev_info dev_info; + if (port_id_is_invalid(port_id, ENABLED_WARN)) return; if (ports[port_id].port_status != RTE_PORT_CLOSED) { if (ports[port_id].port_status != RTE_PORT_STOPPED) { - printf("Port not stopped\n"); + fprintf(stderr, "Port not stopped\n"); return; } - printf("Port was not closed\n"); + fprintf(stderr, "Port was not closed\n"); } - detach_device(rte_eth_devices[port_id].device); + ret = eth_dev_info_get_print_err(port_id, &dev_info); + if (ret != 0) { + TESTPMD_LOG(ERR, + "Failed to get device info for port %d, not detaching\n", + port_id); + return; + } + detach_device(dev_info.device); } void @@ -3008,17 +3082,17 @@ detach_devargs(char *identifier) memset(&da, 0, sizeof(da)); if (rte_devargs_parsef(&da, "%s", identifier)) { - printf("cannot parse identifier\n"); - if (da.args) - free(da.args); + fprintf(stderr, "cannot parse identifier\n"); return; } RTE_ETH_FOREACH_MATCHING_DEV(port_id, identifier, &iterator) { if (ports[port_id].port_status != RTE_PORT_CLOSED) { if (ports[port_id].port_status != RTE_PORT_STOPPED) { - printf("Port %u not stopped\n", port_id); + fprintf(stderr, "Port %u not stopped\n", + port_id); rte_eth_iterator_cleanup(&iterator); + rte_devargs_reset(&da); return; } port_flow_flush(port_id); @@ -3028,6 +3102,7 @@ detach_devargs(char *identifier) if (rte_eal_hotplug_remove(da.bus->name, da.name) != 0) { TESTPMD_LOG(ERR, "Failed to detach device %s(%s)\n", da.name, da.bus->name); + rte_devargs_reset(&da); return; } @@ -3036,6 +3111,7 @@ detach_devargs(char *identifier) printf("Device %s is detached\n", identifier); printf("Now total ports is %d\n", nb_ports); printf("Done\n"); + rte_devargs_reset(&da); } void @@ -3048,6 +3124,7 @@ pmd_test_exit(void) if (test_done == 0) stop_packet_forwarding(); +#ifndef RTE_EXEC_ENV_WINDOWS for (i = 0 ; i < RTE_DIM(mempools) ; i++) { if (mempools[i]) { if (mp_alloc_type == MP_ALLOC_ANON) @@ -3055,6 +3132,7 @@ pmd_test_exit(void) NULL); } } +#endif if (ports != NULL) { no_link_check = 1; RTE_ETH_FOREACH_DEV(pt_id) { @@ -3094,7 +3172,7 @@ pmd_test_exit(void) } for (i = 0 ; i < RTE_DIM(mempools) ; i++) { if (mempools[i]) - rte_mempool_free(mempools[i]); + mempool_free_mp(mempools[i]); } printf("\nBye...\n"); @@ -3130,7 +3208,8 @@ check_all_ports_link_status(uint32_t port_mask) if (ret < 0) { all_ports_up = 0; if (print_flag == 1) - printf("Port %u link get failed: %s\n", + fprintf(stderr, + "Port %u link get failed: %s\n", portid, rte_strerror(-ret)); continue; } @@ -3172,7 +3251,8 @@ rmv_port_callback(void *arg) int need_to_start = 0; int org_no_link_check = no_link_check; portid_t port_id = (intptr_t)arg; - struct rte_device *dev; + struct rte_eth_dev_info dev_info; + int ret; RTE_ETH_VALID_PORTID_OR_RET(port_id); @@ -3184,11 +3264,16 @@ rmv_port_callback(void *arg) stop_port(port_id); no_link_check = org_no_link_check; - /* Save rte_device pointer before closing ethdev port */ - dev = rte_eth_devices[port_id].device; - close_port(port_id); - detach_device(dev); /* might be already removed or have more ports */ - + ret = eth_dev_info_get_print_err(port_id, &dev_info); + if (ret != 0) + TESTPMD_LOG(ERR, + "Failed to get device info for port %d, not detaching\n", + port_id); + else { + struct rte_device *device = dev_info.device; + close_port(port_id); + detach_device(device); /* might be already removed or have more ports */ + } if (need_to_start) start_packet_forwarding(0); } @@ -3202,7 +3287,8 @@ eth_event_callback(portid_t port_id, enum rte_eth_event_type type, void *param, RTE_SET_USED(ret_param); if (type >= RTE_ETH_EVENT_MAX) { - fprintf(stderr, "\nPort %" PRIu16 ": %s called upon invalid event %d\n", + fprintf(stderr, + "\nPort %" PRIu16 ": %s called upon invalid event %d\n", port_id, __func__, type); fflush(stderr); } else if (event_print_mask & (UINT32_C(1) << type)) { @@ -3221,7 +3307,8 @@ eth_event_callback(portid_t port_id, enum rte_eth_event_type type, void *param, break; if (rte_eal_alarm_set(100000, rmv_port_callback, (void *)(intptr_t)port_id)) - fprintf(stderr, "Could not set up deferred device removal\n"); + fprintf(stderr, + "Could not set up deferred device removal\n"); break; case RTE_ETH_EVENT_DESTROY: ports[port_id].port_status = RTE_PORT_CLOSED; @@ -3305,84 +3392,6 @@ dev_event_callback(const char *device_name, enum rte_dev_event_type type, } } -static int -set_tx_queue_stats_mapping_registers(portid_t port_id, struct rte_port *port) -{ - uint16_t i; - int diag; - uint8_t mapping_found = 0; - - for (i = 0; i < nb_tx_queue_stats_mappings; i++) { - if ((tx_queue_stats_mappings[i].port_id == port_id) && - (tx_queue_stats_mappings[i].queue_id < nb_txq )) { - diag = rte_eth_dev_set_tx_queue_stats_mapping(port_id, - tx_queue_stats_mappings[i].queue_id, - tx_queue_stats_mappings[i].stats_counter_id); - if (diag != 0) - return diag; - mapping_found = 1; - } - } - if (mapping_found) - port->tx_queue_stats_mapping_enabled = 1; - return 0; -} - -static int -set_rx_queue_stats_mapping_registers(portid_t port_id, struct rte_port *port) -{ - uint16_t i; - int diag; - uint8_t mapping_found = 0; - - for (i = 0; i < nb_rx_queue_stats_mappings; i++) { - if ((rx_queue_stats_mappings[i].port_id == port_id) && - (rx_queue_stats_mappings[i].queue_id < nb_rxq )) { - diag = rte_eth_dev_set_rx_queue_stats_mapping(port_id, - rx_queue_stats_mappings[i].queue_id, - rx_queue_stats_mappings[i].stats_counter_id); - if (diag != 0) - return diag; - mapping_found = 1; - } - } - if (mapping_found) - port->rx_queue_stats_mapping_enabled = 1; - return 0; -} - -static void -map_port_queue_stats_mapping_registers(portid_t pi, struct rte_port *port) -{ - int diag = 0; - - diag = set_tx_queue_stats_mapping_registers(pi, port); - if (diag != 0) { - if (diag == -ENOTSUP) { - port->tx_queue_stats_mapping_enabled = 0; - printf("TX queue stats mapping not supported port id=%d\n", pi); - } - else - rte_exit(EXIT_FAILURE, - "set_tx_queue_stats_mapping_registers " - "failed for port id=%d diag=%d\n", - pi, diag); - } - - diag = set_rx_queue_stats_mapping_registers(pi, port); - if (diag != 0) { - if (diag == -ENOTSUP) { - port->rx_queue_stats_mapping_enabled = 0; - printf("RX queue stats mapping not supported port id=%d\n", pi); - } - else - rte_exit(EXIT_FAILURE, - "set_rx_queue_stats_mapping_registers " - "failed for port id=%d diag=%d\n", - pi, diag); - } -} - static void rxtx_port_config(struct rte_port *port) { @@ -3440,6 +3449,82 @@ rxtx_port_config(struct rte_port *port) } } +/* + * Helper function to arrange max_rx_pktlen value and JUMBO_FRAME offload, + * MTU is also aligned if JUMBO_FRAME offload is not set. + * + * port->dev_info should be set before calling this function. + * + * return 0 on success, negative on error + */ +int +update_jumbo_frame_offload(portid_t portid) +{ + struct rte_port *port = &ports[portid]; + uint32_t eth_overhead; + uint64_t rx_offloads; + int ret; + bool on; + + /* Update the max_rx_pkt_len to have MTU as RTE_ETHER_MTU */ + if (port->dev_info.max_mtu != UINT16_MAX && + port->dev_info.max_rx_pktlen > port->dev_info.max_mtu) + eth_overhead = port->dev_info.max_rx_pktlen - + port->dev_info.max_mtu; + else + eth_overhead = RTE_ETHER_HDR_LEN + RTE_ETHER_CRC_LEN; + + rx_offloads = port->dev_conf.rxmode.offloads; + + /* Default config value is 0 to use PMD specific overhead */ + if (port->dev_conf.rxmode.max_rx_pkt_len == 0) + port->dev_conf.rxmode.max_rx_pkt_len = RTE_ETHER_MTU + eth_overhead; + + if (port->dev_conf.rxmode.max_rx_pkt_len <= RTE_ETHER_MTU + eth_overhead) { + rx_offloads &= ~DEV_RX_OFFLOAD_JUMBO_FRAME; + on = false; + } else { + if ((port->dev_info.rx_offload_capa & DEV_RX_OFFLOAD_JUMBO_FRAME) == 0) { + fprintf(stderr, + "Frame size (%u) is not supported by port %u\n", + port->dev_conf.rxmode.max_rx_pkt_len, + portid); + return -1; + } + rx_offloads |= DEV_RX_OFFLOAD_JUMBO_FRAME; + on = true; + } + + if (rx_offloads != port->dev_conf.rxmode.offloads) { + uint16_t qid; + + port->dev_conf.rxmode.offloads = rx_offloads; + + /* Apply JUMBO_FRAME offload configuration to Rx queue(s) */ + for (qid = 0; qid < port->dev_info.nb_rx_queues; qid++) { + if (on) + port->rx_conf[qid].offloads |= DEV_RX_OFFLOAD_JUMBO_FRAME; + else + port->rx_conf[qid].offloads &= ~DEV_RX_OFFLOAD_JUMBO_FRAME; + } + } + + /* If JUMBO_FRAME is set MTU conversion done by ethdev layer, + * if unset do it here + */ + if ((rx_offloads & DEV_RX_OFFLOAD_JUMBO_FRAME) == 0) { + ret = eth_dev_set_mtu_mp(portid, + port->dev_conf.rxmode.max_rx_pkt_len - eth_overhead); + if (ret) + fprintf(stderr, + "Failed to set MTU to %u for port %u\n", + port->dev_conf.rxmode.max_rx_pkt_len - eth_overhead, + portid); + } + + return 0; +} + void init_port_config(void) { @@ -3479,18 +3564,13 @@ init_port_config(void) if (ret != 0) return; - map_port_queue_stats_mapping_registers(pid, port); -#if defined RTE_LIBRTE_IXGBE_PMD && defined RTE_LIBRTE_IXGBE_BYPASS +#if defined RTE_NET_IXGBE && defined RTE_LIBRTE_IXGBE_BYPASS rte_pmd_ixgbe_bypass_init(pid); #endif - if (lsc_interrupt && - (rte_eth_devices[pid].data->dev_flags & - RTE_ETH_DEV_INTR_LSC)) + if (lsc_interrupt && (*port->dev_info.dev_flags & RTE_ETH_DEV_INTR_LSC)) port->dev_conf.intr_conf.lsc = 1; - if (rmv_interrupt && - (rte_eth_devices[pid].data->dev_flags & - RTE_ETH_DEV_INTR_RMV)) + if (rmv_interrupt && (*port->dev_info.dev_flags & RTE_ETH_DEV_INTR_RMV)) port->dev_conf.intr_conf.rmv = 1; } } @@ -3514,10 +3594,19 @@ void clear_port_slave_flag(portid_t slave_pid) uint8_t port_is_bonding_slave(portid_t slave_pid) { struct rte_port *port; + struct rte_eth_dev_info dev_info; + int ret; port = &ports[slave_pid]; - if ((rte_eth_devices[slave_pid].data->dev_flags & - RTE_ETH_DEV_BONDED_SLAVE) || (port->slave_flag == 1)) + ret = eth_dev_info_get_print_err(slave_pid, &dev_info); + if (ret != 0) { + TESTPMD_LOG(ERR, + "Failed to get device info for port id %d," + "cannot determine if the port is a bonded slave", + slave_pid); + return 0; + } + if ((*dev_info.dev_flags & RTE_ETH_DEV_BONDED_SLAVE) || (port->slave_flag == 1)) return 1; return 0; } @@ -3620,11 +3709,13 @@ init_port_dcb_config(portid_t pid, int retval; uint16_t i; + if (num_procs > 1) { + printf("The multi-process feature doesn't support dcb.\n"); + return -ENOTSUP; + } rte_port = &ports[pid]; memset(&port_conf, 0, sizeof(struct rte_eth_conf)); - /* Enter DCB configuration status */ - dcb_config = 1; port_conf.rxmode = rte_port->dev_conf.rxmode; port_conf.txmode = rte_port->dev_conf.txmode; @@ -3649,8 +3740,9 @@ init_port_dcb_config(portid_t pid, */ if (dcb_mode == DCB_VT_ENABLED && rte_port->dev_info.vmdq_pool_base > 0) { - printf("VMDQ_DCB multi-queue mode is nonsensical" - " for port %d.", pid); + fprintf(stderr, + "VMDQ_DCB multi-queue mode is nonsensical for port %d.\n", + pid); return -1; } @@ -3690,10 +3782,11 @@ init_port_dcb_config(portid_t pid, if (retval != 0) return retval; - map_port_queue_stats_mapping_registers(pid, rte_port); - rte_port->dcb_flag = 1; + /* Enter DCB configuration status */ + dcb_config = 1; + return 0; } @@ -3747,13 +3840,13 @@ static void signal_handler(int signum) { if (signum == SIGINT || signum == SIGTERM) { - printf("\nSignal %d received, preparing to exit...\n", - signum); -#ifdef RTE_LIBRTE_PDUMP + fprintf(stderr, "\nSignal %d received, preparing to exit...\n", + signum); +#ifdef RTE_LIB_PDUMP /* uninitialize packet capture framework */ rte_pdump_uninit(); #endif -#ifdef RTE_LIBRTE_LATENCY_STATS +#ifdef RTE_LIB_LATENCYSTATS if (latencystats_enabled != 0) rte_latencystats_uninit(); #endif @@ -3761,8 +3854,10 @@ signal_handler(int signum) /* Set flag to indicate the force termination. */ f_quit = 1; /* exit with the expected status */ +#ifndef RTE_EXEC_ENV_WINDOWS signal(signum, SIG_DFL); kill(getpid(), signum); +#endif } } @@ -3787,15 +3882,11 @@ main(int argc, char** argv) rte_exit(EXIT_FAILURE, "Cannot init EAL: %s\n", rte_strerror(rte_errno)); - if (rte_eal_process_type() == RTE_PROC_SECONDARY) - rte_exit(EXIT_FAILURE, - "Secondary process type not supported.\n"); - ret = register_eth_event_callback(); if (ret != 0) rte_exit(EXIT_FAILURE, "Cannot register for ethdev events"); -#ifdef RTE_LIBRTE_PDUMP +#ifdef RTE_LIB_PDUMP /* initialize packet capture framework */ rte_pdump_init(); #endif @@ -3818,10 +3909,10 @@ main(int argc, char** argv) "Check the core mask argument\n"); /* Bitrate/latency stats disabled by default */ -#ifdef RTE_LIBRTE_BITRATESTATS +#ifdef RTE_LIB_BITRATESTATS bitrate_enabled = 0; #endif -#ifdef RTE_LIBRTE_LATENCY_STATS +#ifdef RTE_LIB_LATENCYSTATS latencystats_enabled = 0; #endif @@ -3837,28 +3928,31 @@ main(int argc, char** argv) if (argc > 1) launch_args_parse(argc, argv); +#ifndef RTE_EXEC_ENV_WINDOWS if (do_mlockall && mlockall(MCL_CURRENT | MCL_FUTURE)) { TESTPMD_LOG(NOTICE, "mlockall() failed with error \"%s\"\n", strerror(errno)); } +#endif if (tx_first && interactive) rte_exit(EXIT_FAILURE, "--tx-first cannot be used on " "interactive mode.\n"); if (tx_first && lsc_interrupt) { - printf("Warning: lsc_interrupt needs to be off when " - " using tx_first. Disabling.\n"); + fprintf(stderr, + "Warning: lsc_interrupt needs to be off when using tx_first. Disabling.\n"); lsc_interrupt = 0; } if (!nb_rxq && !nb_txq) - printf("Warning: Either rx or tx queues should be non-zero\n"); + fprintf(stderr, + "Warning: Either rx or tx queues should be non-zero\n"); if (nb_rxq > 1 && nb_rxq > nb_txq) - printf("Warning: nb_rxq=%d enables RSS configuration, " - "but nb_txq=%d will prevent to fully test it.\n", - nb_rxq, nb_txq); + fprintf(stderr, + "Warning: nb_rxq=%d enables RSS configuration, but nb_txq=%d will prevent to fully test it.\n", + nb_rxq, nb_txq); init_config(); @@ -3893,26 +3987,28 @@ main(int argc, char** argv) RTE_ETH_FOREACH_DEV(port_id) { ret = rte_eth_promiscuous_enable(port_id); if (ret != 0) - printf("Error during enabling promiscuous mode for port %u: %s - ignore\n", + fprintf(stderr, + "Error during enabling promiscuous mode for port %u: %s - ignore\n", port_id, rte_strerror(-ret)); } /* Init metrics library */ rte_metrics_init(rte_socket_id()); -#ifdef RTE_LIBRTE_LATENCY_STATS +#ifdef RTE_LIB_LATENCYSTATS if (latencystats_enabled != 0) { int ret = rte_latencystats_init(1, NULL); if (ret) - printf("Warning: latencystats init()" - " returned error %d\n", ret); - printf("Latencystats running on lcore %d\n", + fprintf(stderr, + "Warning: latencystats init() returned error %d\n", + ret); + fprintf(stderr, "Latencystats running on lcore %d\n", latencystats_lcore_id); } #endif /* Setup bitrate stats */ -#ifdef RTE_LIBRTE_BITRATESTATS +#ifdef RTE_LIB_BITRATESTATS if (bitrate_enabled != 0) { bitrate_data = rte_stats_bitrate_create(); if (bitrate_data == NULL) @@ -3922,7 +4018,7 @@ main(int argc, char** argv) } #endif -#ifdef RTE_LIBRTE_CMDLINE +#ifdef RTE_LIB_CMDLINE if (strlen(cmdline_filename) != 0) cmdline_read_from_file(cmdline_filename); @@ -3961,7 +4057,7 @@ main(int argc, char** argv) } /* Sleep to avoid unnecessary checks */ prev_time = cur_time; - sleep(1); + rte_delay_us_sleep(US_PER_S); } }