X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest-pmd%2Ftestpmd.c;h=06885ceba19d7d97c44c56d677190ddb8fa55725;hb=102b7329507e95d13e82bbad5565bc93e352951e;hp=ad730a3956208e68974270280eada2a927c5204e;hpb=7b7e5ba79e085d27533abe69135d3b9ac5091cf8;p=dpdk.git diff --git a/app/test-pmd/testpmd.c b/app/test-pmd/testpmd.c index ad730a3956..06885ceba1 100644 --- a/app/test-pmd/testpmd.c +++ b/app/test-pmd/testpmd.c @@ -1,13 +1,13 @@ /*- * BSD LICENSE - * - * Copyright(c) 2010-2013 Intel Corporation. All rights reserved. + * + * Copyright(c) 2010-2016 Intel Corporation. All rights reserved. * All rights reserved. - * + * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: - * + * * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright @@ -17,7 +17,7 @@ * * Neither the name of Intel Corporation nor the names of its * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR @@ -49,6 +49,7 @@ #include #include +#include #include #include #include @@ -57,7 +58,6 @@ #include #include #include -#include #include #include #include @@ -71,7 +71,14 @@ #include #include #include +#include #include +#ifdef RTE_LIBRTE_PMD_XENVIRT +#include +#endif +#ifdef RTE_LIBRTE_PDUMP +#include +#endif #include "testpmd.h" @@ -79,6 +86,7 @@ uint16_t verbose_level = 0; /**< Silent by default. */ /* use master core for command line ? */ uint8_t interactive = 0; +uint8_t auto_start = 0; /* * NUMA support configuration. @@ -90,10 +98,15 @@ uint8_t interactive = 0; uint8_t numa_support = 0; /**< No numa support by default */ /* - * In UMA mode,all memory is allocated from socket 0 if --socket-num is + * In UMA mode,all memory is allocated from socket 0 if --socket-num is * not configured. */ -uint8_t socket_num = UMA_NO_CONFIG; +uint8_t socket_num = UMA_NO_CONFIG; + +/* + * Use ANONYMOUS mapped memory (might be not physically continuous) for mbufs. + */ +uint8_t mp_anon = 0; /* * Record the Ethernet address of peer target ports to which packets are @@ -134,9 +147,12 @@ streamid_t nb_fwd_streams; /**< Is equal to (nb_ports * nb_rxq). */ struct fwd_engine * fwd_engines[] = { &io_fwd_engine, &mac_fwd_engine, + &mac_swap_engine, + &flow_gen_engine, &rx_only_engine, &tx_only_engine, &csum_fwd_engine, + &icmp_echo_engine, #ifdef RTE_LIBRTE_IEEE1588 &ieee1588_fwd_engine, #endif @@ -145,6 +161,9 @@ struct fwd_engine * fwd_engines[] = { struct fwd_config cur_fwd_config; struct fwd_engine *cur_fwd_eng = &io_fwd_engine; /**< IO mode by default. */ +uint32_t retry_enabled; +uint32_t burst_tx_delay_time = BURST_TX_WAIT_US; +uint32_t burst_tx_retry_num = BURST_TX_RETRIES; uint16_t mbuf_data_size = DEFAULT_MBUF_DATA_SIZE; /**< Mbuf data space size. */ uint32_t param_total_num_mbufs = 0; /**< number of mbufs in all pools - if @@ -159,17 +178,17 @@ uint16_t tx_pkt_seg_lengths[RTE_MAX_SEGS_PER_PKT] = { }; uint8_t tx_pkt_nb_segs = 1; /**< Number of segments in TXONLY packets */ +enum tx_pkt_split tx_pkt_split = TX_PKT_SPLIT_OFF; +/**< Split policy for packets to TX. */ + uint16_t nb_pkt_per_burst = DEF_PKT_BURST; /**< Number of packets per burst. */ -uint16_t mb_mempool_cache = DEF_PKT_BURST; /**< Size of mbuf mempool cache. */ +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; - -/* DCB on and VT on mapping is default */ -enum dcb_queue_mapping_mode dcb_q_mapping = DCB_VT_Q_MAPPING; /* * Configurable number of RX/TX queues. @@ -185,58 +204,48 @@ queueid_t nb_txq = 1; /**< Number of TX queues per port. */ uint16_t nb_rxd = RTE_TEST_RX_DESC_DEFAULT; /**< Number of RX descriptors. */ uint16_t nb_txd = RTE_TEST_TX_DESC_DEFAULT; /**< Number of TX descriptors. */ +#define RTE_PMD_PARAM_UNSET -1 /* * Configurable values of RX and TX ring threshold registers. */ -#define RX_PTHRESH 8 /**< Default value of RX prefetch threshold register. */ -#define RX_HTHRESH 8 /**< Default value of RX host threshold register. */ -#define RX_WTHRESH 4 /**< Default value of RX write-back threshold register. */ - -#define TX_PTHRESH 36 /**< Default value of TX prefetch threshold register. */ -#define TX_HTHRESH 0 /**< Default value of TX host threshold register. */ -#define TX_WTHRESH 0 /**< Default value of TX write-back threshold register. */ - -struct rte_eth_thresh rx_thresh = { - .pthresh = RX_PTHRESH, - .hthresh = RX_HTHRESH, - .wthresh = RX_WTHRESH, -}; -struct rte_eth_thresh tx_thresh = { - .pthresh = TX_PTHRESH, - .hthresh = TX_HTHRESH, - .wthresh = TX_WTHRESH, -}; +int8_t rx_pthresh = RTE_PMD_PARAM_UNSET; +int8_t rx_hthresh = RTE_PMD_PARAM_UNSET; +int8_t rx_wthresh = RTE_PMD_PARAM_UNSET; + +int8_t tx_pthresh = RTE_PMD_PARAM_UNSET; +int8_t tx_hthresh = RTE_PMD_PARAM_UNSET; +int8_t tx_wthresh = RTE_PMD_PARAM_UNSET; /* * Configurable value of RX free threshold. */ -uint16_t rx_free_thresh = 0; /* Immediately free RX descriptors by default. */ +int16_t rx_free_thresh = RTE_PMD_PARAM_UNSET; /* * Configurable value of RX drop enable. */ -uint8_t rx_drop_en = 0; /* Drop packets when no descriptors for queue. */ +int8_t rx_drop_en = RTE_PMD_PARAM_UNSET; /* * Configurable value of TX free threshold. */ -uint16_t tx_free_thresh = 0; /* Use default values. */ +int16_t tx_free_thresh = RTE_PMD_PARAM_UNSET; /* * Configurable value of TX RS bit threshold. */ -uint16_t tx_rs_thresh = 0; /* Use default values. */ +int16_t tx_rs_thresh = RTE_PMD_PARAM_UNSET; /* * Configurable value of TX queue flags. */ -uint32_t txq_flags = 0; /* No flags set. */ +int32_t txq_flags = RTE_PMD_PARAM_UNSET; /* * Receive Side Scaling (RSS) configuration. */ -uint16_t rss_hf = ETH_RSS_IPV4 | ETH_RSS_IPV6; /* RSS IP by default. */ +uint64_t rss_hf = ETH_RSS_IP; /* RSS IP by default. */ /* * Port topology configuration @@ -248,13 +257,18 @@ uint16_t port_topology = PORT_TOPOLOGY_PAIRED; /* Ports are paired by default */ */ uint8_t no_flush_rx = 0; /* flush by default */ +/* + * Avoids to check link status when starting/stopping a port. + */ +uint8_t no_link_check = 0; /* check by default */ + /* * NIC bypass mode configuration options. */ #ifdef RTE_NIC_BYPASS /* The NIC bypass watchdog timeout. */ -uint32_t bypass_timeout = RTE_BYPASS_TMT_OFF; +uint32_t bypass_timeout = RTE_BYPASS_TMT_OFF; #endif @@ -277,11 +291,26 @@ struct rte_fdir_conf fdir_conf = { .mode = RTE_FDIR_MODE_NONE, .pballoc = RTE_FDIR_PBALLOC_64K, .status = RTE_FDIR_REPORT_STATUS, - .flexbytes_offset = 0x6, + .mask = { + .vlan_tci_mask = 0x0, + .ipv4_mask = { + .src_ip = 0xFFFFFFFF, + .dst_ip = 0xFFFFFFFF, + }, + .ipv6_mask = { + .src_ip = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}, + .dst_ip = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}, + }, + .src_port_mask = 0xFFFF, + .dst_port_mask = 0xFFFF, + .mac_addr_byte_mask = 0xFF, + .tunnel_type_mask = 1, + .tunnel_id_mask = 0xFFFFFFFF, + }, .drop_queue = 127, }; -static volatile int test_done = 1; /* stop packet forwarding when set to 1. */ +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]; @@ -292,9 +321,11 @@ struct queue_stats_mappings *rx_queue_stats_mappings = rx_queue_stats_mappings_a uint16_t nb_tx_queue_stats_mappings = 0; uint16_t nb_rx_queue_stats_mappings = 0; +unsigned max_socket = 0; + /* Forward function declarations */ static void map_port_queue_stats_mapping_registers(uint8_t pi, struct rte_port *port); -static void check_all_ports_link_status(uint8_t port_num, uint32_t port_mask); +static void check_all_ports_link_status(uint32_t port_mask); /* * Check if all the ports are started. @@ -302,6 +333,20 @@ static void check_all_ports_link_status(uint8_t port_num, uint32_t port_mask); */ static int all_ports_started(void); +/* + * Find next enabled port + */ +portid_t +find_next_port(portid_t p, struct rte_port *ports, int size) +{ + if (ports == NULL) + rte_exit(-EINVAL, "failed to find a next port id\n"); + + while ((p < size) && (ports[p].enabled == 0)) + p++; + return p; +} + /* * Setup default configuration. */ @@ -310,10 +355,17 @@ set_default_fwd_lcores_config(void) { unsigned int i; unsigned int nb_lc; + unsigned int sock_num; nb_lc = 0; for (i = 0; i < RTE_MAX_LCORE; i++) { - if (! rte_lcore_is_enabled(i)) + sock_num = rte_lcore_to_socket_id(i) + 1; + if (sock_num > max_socket) { + if (sock_num > RTE_MAX_NUMA_NODES) + rte_exit(EXIT_FAILURE, "Total sockets greater than %u\n", RTE_MAX_NUMA_NODES); + max_socket = sock_num; + } + if (!rte_lcore_is_enabled(i)) continue; if (i == rte_get_master_lcore()) continue; @@ -358,89 +410,81 @@ set_def_fwd_config(void) /* * Configuration initialisation done once at init time. */ -struct mbuf_ctor_arg { - uint16_t seg_buf_offset; /**< offset of data in data segment of mbuf. */ - uint16_t seg_buf_size; /**< size of data segment in mbuf. */ -}; - -struct mbuf_pool_ctor_arg { - uint16_t seg_buf_size; /**< size of data segment in mbuf. */ -}; - -static void -testpmd_mbuf_ctor(struct rte_mempool *mp, - void *opaque_arg, - void *raw_mbuf, - __attribute__((unused)) unsigned i) -{ - struct mbuf_ctor_arg *mb_ctor_arg; - struct rte_mbuf *mb; - - mb_ctor_arg = (struct mbuf_ctor_arg *) opaque_arg; - mb = (struct rte_mbuf *) raw_mbuf; - - mb->type = RTE_MBUF_PKT; - mb->pool = mp; - mb->buf_addr = (void *) ((char *)mb + mb_ctor_arg->seg_buf_offset); - mb->buf_physaddr = (uint64_t) (rte_mempool_virt2phy(mp, mb) + - mb_ctor_arg->seg_buf_offset); - mb->buf_len = mb_ctor_arg->seg_buf_size; - mb->type = RTE_MBUF_PKT; - mb->ol_flags = 0; - mb->pkt.data = (char *) mb->buf_addr + RTE_PKTMBUF_HEADROOM; - mb->pkt.nb_segs = 1; - mb->pkt.vlan_macip.data = 0; - mb->pkt.hash.rss = 0; -} - -static void -testpmd_mbuf_pool_ctor(struct rte_mempool *mp, - void *opaque_arg) -{ - struct mbuf_pool_ctor_arg *mbp_ctor_arg; - struct rte_pktmbuf_pool_private *mbp_priv; - - if (mp->private_data_size < sizeof(struct rte_pktmbuf_pool_private)) { - printf("%s(%s) private_data_size %d < %d\n", - __func__, mp->name, (int) mp->private_data_size, - (int) sizeof(struct rte_pktmbuf_pool_private)); - return; - } - mbp_ctor_arg = (struct mbuf_pool_ctor_arg *) opaque_arg; - mbp_priv = (struct rte_pktmbuf_pool_private *) - ((char *)mp + sizeof(struct rte_mempool)); - mbp_priv->mbuf_data_room_size = mbp_ctor_arg->seg_buf_size; -} - static void mbuf_pool_create(uint16_t mbuf_seg_size, unsigned nb_mbuf, unsigned int socket_id) { char pool_name[RTE_MEMPOOL_NAMESIZE]; - struct rte_mempool *rte_mp; - struct mbuf_pool_ctor_arg mbp_ctor_arg; - struct mbuf_ctor_arg mb_ctor_arg; + struct rte_mempool *rte_mp = NULL; uint32_t mb_size; - mbp_ctor_arg.seg_buf_size = (uint16_t) (RTE_PKTMBUF_HEADROOM + - mbuf_seg_size); - mb_ctor_arg.seg_buf_offset = - (uint16_t) CACHE_LINE_ROUNDUP(sizeof(struct rte_mbuf)); - mb_ctor_arg.seg_buf_size = mbp_ctor_arg.seg_buf_size; - mb_size = mb_ctor_arg.seg_buf_offset + mb_ctor_arg.seg_buf_size; + mb_size = sizeof(struct rte_mbuf) + mbuf_seg_size; mbuf_poolname_build(socket_id, pool_name, sizeof(pool_name)); - rte_mp = rte_mempool_create(pool_name, nb_mbuf, (unsigned) mb_size, - (unsigned) mb_mempool_cache, - sizeof(struct rte_pktmbuf_pool_private), - testpmd_mbuf_pool_ctor, &mbp_ctor_arg, - testpmd_mbuf_ctor, &mb_ctor_arg, - socket_id, 0); + + RTE_LOG(INFO, USER1, + "create a new mbuf pool <%s>: n=%u, size=%u, socket=%u\n", + pool_name, nb_mbuf, mbuf_seg_size, socket_id); + +#ifdef RTE_LIBRTE_PMD_XENVIRT + rte_mp = rte_mempool_gntalloc_create(pool_name, nb_mbuf, mb_size, + (unsigned) mb_mempool_cache, + sizeof(struct rte_pktmbuf_pool_private), + rte_pktmbuf_pool_init, NULL, + rte_pktmbuf_init, NULL, + socket_id, 0); +#endif + + /* if the former XEN allocation failed fall back to normal allocation */ + if (rte_mp == NULL) { + if (mp_anon != 0) { + rte_mp = rte_mempool_create_empty(pool_name, nb_mbuf, + mb_size, (unsigned) mb_mempool_cache, + sizeof(struct rte_pktmbuf_pool_private), + socket_id, 0); + + if (rte_mempool_populate_anon(rte_mp) == 0) { + rte_mempool_free(rte_mp); + rte_mp = NULL; + } + rte_pktmbuf_pool_init(rte_mp, NULL); + rte_mempool_obj_iter(rte_mp, rte_pktmbuf_init, NULL); + } else { + /* wrapper to rte_mempool_create() */ + rte_mp = rte_pktmbuf_pool_create(pool_name, nb_mbuf, + mb_mempool_cache, 0, mbuf_seg_size, socket_id); + } + } + if (rte_mp == NULL) { - rte_exit(EXIT_FAILURE, "Creation of mbuf pool for socket %u " - "failed\n", socket_id); + rte_exit(EXIT_FAILURE, + "Creation of mbuf pool for socket %u failed: %s\n", + socket_id, rte_strerror(rte_errno)); + } else if (verbose_level > 0) { + rte_mempool_dump(stdout, rte_mp); } } +/* + * Check given socket id is valid or not with NUMA mode, + * if valid, return 0, else return -1 + */ +static int +check_socket_id(const unsigned int socket_id) +{ + static int warning_once = 0; + + if (socket_id >= max_socket) { + 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"); + warning_once = 1; + return -1; + } + return 0; +} + static void init_config(void) { @@ -449,13 +493,13 @@ init_config(void) struct rte_mempool *mbp; unsigned int nb_mbuf_per_pool; lcoreid_t lc_id; - uint8_t port_per_socket[MAX_SOCKET]; + uint8_t port_per_socket[RTE_MAX_NUMA_NODES]; - memset(port_per_socket,0,MAX_SOCKET); + memset(port_per_socket,0,RTE_MAX_NUMA_NODES); /* Configuration of logical cores. */ fwd_lcores = rte_zmalloc("testpmd: fwd_lcores", sizeof(struct fwd_lcore *) * nb_lcores, - CACHE_LINE_SIZE); + RTE_CACHE_LINE_SIZE); if (fwd_lcores == NULL) { rte_exit(EXIT_FAILURE, "rte_zmalloc(%d (struct fwd_lcore *)) " "failed\n", nb_lcores); @@ -463,7 +507,7 @@ init_config(void) for (lc_id = 0; lc_id < nb_lcores; lc_id++) { fwd_lcores[lc_id] = rte_zmalloc("testpmd: struct fwd_lcore", sizeof(struct fwd_lcore), - CACHE_LINE_SIZE); + RTE_CACHE_LINE_SIZE); if (fwd_lcores[lc_id] == NULL) { rte_exit(EXIT_FAILURE, "rte_zmalloc(struct fwd_lcore) " "failed\n"); @@ -480,14 +524,15 @@ init_config(void) * Use the maximum value of nb_rxd and nb_txd here, then nb_rxd and * nb_txd can be configured at run time. */ - if (param_total_num_mbufs) + if (param_total_num_mbufs) nb_mbuf_per_pool = param_total_num_mbufs; else { nb_mbuf_per_pool = RTE_TEST_RX_DESC_MAX + (nb_lcores * mb_mempool_cache) + RTE_TEST_TX_DESC_MAX + MAX_PKT_BURST; - - if (!numa_support) - nb_mbuf_per_pool = (nb_mbuf_per_pool * nb_ports); + + if (!numa_support) + nb_mbuf_per_pool = + (nb_mbuf_per_pool * RTE_MAX_ETHPORTS); } if (!numa_support) { @@ -497,35 +542,21 @@ init_config(void) mbuf_pool_create(mbuf_data_size, nb_mbuf_per_pool, socket_num); } - /* - * Records which Mbuf pool to use by each logical core, if needed. - */ - for (lc_id = 0; lc_id < nb_lcores; lc_id++) { - mbp = mbuf_pool_find(rte_lcore_to_socket_id(lc_id)); - if (mbp == NULL) - mbp = mbuf_pool_find(0); - fwd_lcores[lc_id]->mbp = mbp; - } - /* Configuration of Ethernet ports. */ - ports = rte_zmalloc("testpmd: ports", - sizeof(struct rte_port) * nb_ports, - CACHE_LINE_SIZE); - if (ports == NULL) { - rte_exit(EXIT_FAILURE, "rte_zmalloc(%d struct rte_port) " - "failed\n", nb_ports); - } - - for (pid = 0; pid < nb_ports; pid++) { + FOREACH_PORT(pid, ports) { port = &ports[pid]; rte_eth_dev_info_get(pid, &port->dev_info); if (numa_support) { - if (port_numa[pid] != NUMA_NO_CONFIG) + if (port_numa[pid] != NUMA_NO_CONFIG) port_per_socket[port_numa[pid]]++; else { uint32_t socket_id = rte_eth_dev_socket_id(pid); - port_per_socket[socket_id]++; + + /* if socket_id is invalid, set to 0 */ + if (check_socket_id(socket_id) < 0) + socket_id = 0; + port_per_socket[socket_id]++; } } @@ -541,29 +572,63 @@ init_config(void) if (param_total_num_mbufs) nb_mbuf_per_pool = nb_mbuf_per_pool/nb_ports; - for (i = 0; i < MAX_SOCKET; i++) { - nb_mbuf = (nb_mbuf_per_pool * - port_per_socket[i]); - if (nb_mbuf) + for (i = 0; i < max_socket; i++) { + nb_mbuf = (nb_mbuf_per_pool * RTE_MAX_ETHPORTS); + if (nb_mbuf) mbuf_pool_create(mbuf_data_size, nb_mbuf,i); } } init_port_config(); + + /* + * Records which Mbuf pool to use by each logical core, if needed. + */ + for (lc_id = 0; lc_id < nb_lcores; lc_id++) { + mbp = mbuf_pool_find( + rte_lcore_to_socket_id(fwd_lcores_cpuids[lc_id])); + + if (mbp == NULL) + mbp = mbuf_pool_find(0); + fwd_lcores[lc_id]->mbp = mbp; + } + /* Configuration of packet forwarding streams. */ if (init_fwd_streams() < 0) rte_exit(EXIT_FAILURE, "FAIL from init_fwd_streams()\n"); + + fwd_config_setup(); } + +void +reconfig(portid_t new_port_id, unsigned socket_id) +{ + struct rte_port *port; + + /* Reconfiguration of Ethernet ports. */ + port = &ports[new_port_id]; + rte_eth_dev_info_get(new_port_id, &port->dev_info); + + /* set flag to initialize port/queue */ + port->need_reconfig = 1; + port->need_reconfig_queues = 1; + port->socket_id = socket_id; + + init_port_config(); +} + + int init_fwd_streams(void) { portid_t pid; struct rte_port *port; streamid_t sm_id, nb_fwd_streams_new; + queueid_t q; /* set socket id according to numa or not */ - for (pid = 0; pid < nb_ports; pid++) { + FOREACH_PORT(pid, ports) { port = &ports[pid]; if (nb_rxq > port->dev_info.max_rx_queues) { printf("Fail: nb_rxq(%d) is greater than " @@ -577,17 +642,31 @@ init_fwd_streams(void) port->dev_info.max_tx_queues); return -1; } - if (numa_support) - port->socket_id = rte_eth_dev_socket_id(pid); + if (numa_support) { + if (port_numa[pid] != NUMA_NO_CONFIG) + port->socket_id = port_numa[pid]; + else { + port->socket_id = rte_eth_dev_socket_id(pid); + + /* if socket_id is invalid, set to 0 */ + if (check_socket_id(port->socket_id) < 0) + port->socket_id = 0; + } + } else { - if (socket_num == UMA_NO_CONFIG) + if (socket_num == UMA_NO_CONFIG) port->socket_id = 0; - else - port->socket_id = socket_num; + else + port->socket_id = socket_num; } } - nb_fwd_streams_new = (streamid_t)(nb_ports * nb_rxq); + q = RTE_MAX(nb_rxq, nb_txq); + if (q == 0) { + printf("Fail: Cannot allocate fwd streams as number of queues is 0\n"); + return -1; + } + nb_fwd_streams_new = (streamid_t)(nb_ports * q); if (nb_fwd_streams_new == nb_fwd_streams) return 0; /* clear the old */ @@ -605,14 +684,14 @@ init_fwd_streams(void) /* init new */ nb_fwd_streams = nb_fwd_streams_new; fwd_streams = rte_zmalloc("testpmd: fwd_streams", - sizeof(struct fwd_stream *) * nb_fwd_streams, CACHE_LINE_SIZE); + sizeof(struct fwd_stream *) * nb_fwd_streams, RTE_CACHE_LINE_SIZE); if (fwd_streams == NULL) rte_exit(EXIT_FAILURE, "rte_zmalloc(%d (struct fwd_stream *)) " "failed\n", nb_fwd_streams); for (sm_id = 0; sm_id < nb_fwd_streams; sm_id++) { fwd_streams[sm_id] = rte_zmalloc("testpmd: struct fwd_stream", - sizeof(struct fwd_stream), CACHE_LINE_SIZE); + sizeof(struct fwd_stream), RTE_CACHE_LINE_SIZE); if (fwd_streams[sm_id] == NULL) rte_exit(EXIT_FAILURE, "rte_zmalloc(struct fwd_stream)" " failed\n"); @@ -691,40 +770,43 @@ fwd_port_stats_display(portid_t port_id, struct rte_eth_stats *stats) 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->ierrors, - (uint64_t) (stats->ipackets + stats->ierrors)); + stats->ipackets, stats->imissed, + (uint64_t) (stats->ipackets + stats->imissed)); if (cur_fwd_eng == &csum_fwd_engine) printf(" Bad-ipcsum: %-14"PRIu64" Bad-l4csum: %-14"PRIu64" \n", port->rx_bad_ip_csum, port->rx_bad_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, port->tx_dropped, (uint64_t) (stats->opackets + port->tx_dropped)); - - if (stats->rx_nombuf > 0) - printf(" RX-nombufs: %-14"PRIu64"\n", stats->rx_nombuf); - } else { printf(" RX-packets: %14"PRIu64" RX-dropped:%14"PRIu64" RX-total:" "%14"PRIu64"\n", - stats->ipackets, stats->ierrors, - (uint64_t) (stats->ipackets + stats->ierrors)); + stats->ipackets, stats->imissed, + (uint64_t) (stats->ipackets + stats->imissed)); if (cur_fwd_eng == &csum_fwd_engine) printf(" Bad-ipcsum:%14"PRIu64" Bad-l4csum:%14"PRIu64"\n", port->rx_bad_ip_csum, port->rx_bad_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:" "%14"PRIu64"\n", stats->opackets, port->tx_dropped, (uint64_t) (stats->opackets + port->tx_dropped)); - - if (stats->rx_nombuf > 0) - printf(" RX-nombufs:%14"PRIu64"\n", stats->rx_nombuf); } + #ifdef RTE_TEST_PMD_RECORD_BURST_STATS if (port->rx_stream) pkt_burst_stats_display("RX", @@ -733,11 +815,6 @@ fwd_port_stats_display(portid_t port_id, struct rte_eth_stats *stats) pkt_burst_stats_display("TX", &port->tx_stream->tx_burst_stats); #endif - /* stats fdir */ - if (fdir_conf.mode != RTE_FDIR_MODE_NONE) - printf(" Fdirmiss:%14"PRIu64" Fdirmatch:%14"PRIu64"\n", - stats->fdirmiss, - stats->fdirmatch); if (port->rx_queue_stats_mapping_enabled) { printf("\n"); @@ -901,6 +978,19 @@ start_packet_forwarding(int with_tx_first) portid_t pt_id; streamid_t sm_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"); + + if (strcmp(cur_fwd_eng->fwd_mode_name, "txonly") == 0 && !nb_txq) + rte_exit(EXIT_FAILURE, "txq are 0, cannot use txonly fwd mode\n"); + + if ((strcmp(cur_fwd_eng->fwd_mode_name, "rxonly") != 0 && + strcmp(cur_fwd_eng->fwd_mode_name, "txonly") != 0) && + (!nb_rxq || !nb_txq)) + rte_exit(EXIT_FAILURE, + "Either rxq or txq are 0, cannot use %s fwd mode\n", + cur_fwd_eng->fwd_mode_name); + if (all_ports_started() == 0) { printf("Not all ports were started\n"); return; @@ -909,6 +999,12 @@ start_packet_forwarding(int with_tx_first) printf("Packet forwarding already started\n"); return; } + + if (init_fwd_streams() < 0) { + printf("Fail from init_fwd_streams()\n"); + return; + } + if(dcb_test) { for (i = 0; i < nb_fwd_ports; i++) { pt_id = fwd_ports_ids[i]; @@ -931,6 +1027,7 @@ start_packet_forwarding(int with_tx_first) flush_fwd_rx_queues(); fwd_config_setup(); + pkt_fwd_config_display(&cur_fwd_config); rxtx_config_display(); for (i = 0; i < cur_fwd_config.nb_fwd_ports; i++) { @@ -964,8 +1061,11 @@ start_packet_forwarding(int with_tx_first) for (i = 0; i < cur_fwd_config.nb_fwd_ports; i++) (*port_fwd_begin)(fwd_ports_ids[i]); } - launch_packet_forwarding(run_one_txonly_burst_on_core); - rte_eal_mp_wait_lcore(); + while (with_tx_first--) { + launch_packet_forwarding( + run_one_txonly_burst_on_core); + rte_eal_mp_wait_lcore(); + } port_fwd_end = tx_only_engine.port_fwd_end; if (port_fwd_end != NULL) { for (i = 0; i < cur_fwd_config.nb_fwd_ports; i++) @@ -998,10 +1098,6 @@ stop_packet_forwarding(void) #endif static const char *acc_stats_border = "+++++++++++++++"; - if (all_ports_started() == 0) { - printf("Not all ports were started\n"); - return; - } if (test_done) { printf("Packet forwarding not started\n"); return; @@ -1075,20 +1171,16 @@ stop_packet_forwarding(void) port->stats.ibytes = 0; stats.obytes -= port->stats.obytes; port->stats.obytes = 0; - stats.ierrors -= port->stats.ierrors; - port->stats.ierrors = 0; + stats.imissed -= port->stats.imissed; + port->stats.imissed = 0; stats.oerrors -= port->stats.oerrors; port->stats.oerrors = 0; stats.rx_nombuf -= port->stats.rx_nombuf; port->stats.rx_nombuf = 0; - stats.fdirmatch -= port->stats.fdirmatch; - port->stats.rx_nombuf = 0; - stats.fdirmiss -= port->stats.fdirmiss; - port->stats.rx_nombuf = 0; total_recv += stats.ipackets; total_xmit += stats.opackets; - total_rx_dropped += stats.ierrors; + total_rx_dropped += stats.imissed; total_tx_dropped += port->tx_dropped; total_rx_nombuf += stats.rx_nombuf; @@ -1119,16 +1211,31 @@ stop_packet_forwarding(void) test_done = 1; } +void +dev_set_link_up(portid_t pid) +{ + if (rte_eth_dev_set_link_up((uint8_t)pid) < 0) + printf("\nSet link up fail.\n"); +} + +void +dev_set_link_down(portid_t pid) +{ + if (rte_eth_dev_set_link_down((uint8_t)pid) < 0) + printf("\nSet link down fail.\n"); +} + static int all_ports_started(void) { portid_t pi; struct rte_port *port; - for (pi = 0; pi < nb_ports; pi++) { + FOREACH_PORT(pi, ports) { port = &ports[pi]; /* Check if there is a port which is not started */ - if (port->port_status != RTE_PORT_STARTED) + if ((port->port_status != RTE_PORT_STARTED) && + (port->slave_flag == 0)) return 0; } @@ -1136,30 +1243,65 @@ all_ports_started(void) return 1; } -void +int +all_ports_stopped(void) +{ + portid_t pi; + struct rte_port *port; + + FOREACH_PORT(pi, ports) { + port = &ports[pi]; + if ((port->port_status != RTE_PORT_STOPPED) && + (port->slave_flag == 0)) + return 0; + } + + return 1; +} + +int +port_is_started(portid_t port_id) +{ + if (port_id_is_invalid(port_id, ENABLED_WARN)) + return 0; + + if (ports[port_id].port_status != RTE_PORT_STARTED) + return 0; + + return 1; +} + +static int +port_is_closed(portid_t port_id) +{ + if (port_id_is_invalid(port_id, ENABLED_WARN)) + return 0; + + if (ports[port_id].port_status != RTE_PORT_CLOSED) + return 0; + + return 1; +} + +int start_port(portid_t pid) { - int diag, need_check_link_status = 0; + int diag, need_check_link_status = -1; portid_t pi; queueid_t qi; struct rte_port *port; + struct ether_addr mac_addr; - if (test_done == 0) { - printf("Please stop forwarding first\n"); - return; - } + if (port_id_is_invalid(pid, ENABLED_WARN)) + return 0; - if (init_fwd_streams() < 0) { - printf("Fail from init_fwd_streams()\n"); - return; - } - if(dcb_config) dcb_test = 1; - for (pi = 0; pi < nb_ports; pi++) { - if (pid < nb_ports && pid != pi) + FOREACH_PORT(pi, ports) { + if (pid != pi && pid != (portid_t)RTE_PORT_ALL) continue; + need_check_link_status = 0; port = &ports[pi]; if (rte_atomic16_cmpset(&(port->port_status), RTE_PORT_STOPPED, RTE_PORT_HANDLING) == 0) { @@ -1170,8 +1312,8 @@ start_port(portid_t pid) if (port->need_reconfig > 0) { port->need_reconfig = 0; - printf("Configuring Port %d (socket %d)\n", pi, - rte_eth_dev_socket_id(pi)); + printf("Configuring Port %d (socket %u)\n", pi, + port->socket_id); /* configure port */ diag = rte_eth_dev_configure(pi, nb_rxq, nb_txq, &(port->dev_conf)); @@ -1183,7 +1325,7 @@ start_port(portid_t pid) printf("Fail to configure port %d\n", pi); /* try to reconfigure port next time */ port->need_reconfig = 1; - return; + return -1; } } if (port->need_reconfig_queues > 0) { @@ -1191,15 +1333,15 @@ start_port(portid_t pid) /* setup tx queues */ for (qi = 0; qi < nb_txq; qi++) { if ((numa_support) && - (txring_numa[pi] != NUMA_NO_CONFIG)) + (txring_numa[pi] != NUMA_NO_CONFIG)) diag = rte_eth_tx_queue_setup(pi, qi, nb_txd,txring_numa[pi], &(port->tx_conf)); else - diag = rte_eth_tx_queue_setup(pi, qi, + diag = rte_eth_tx_queue_setup(pi, qi, nb_txd,port->socket_id, &(port->tx_conf)); - + if (diag == 0) continue; @@ -1212,36 +1354,42 @@ start_port(portid_t pid) printf("Fail to configure port %d tx queues\n", pi); /* try to reconfigure queues next time */ port->need_reconfig_queues = 1; - return; + return -1; } /* setup rx queues */ for (qi = 0; qi < nb_rxq; qi++) { - if ((numa_support) && + if ((numa_support) && (rxring_numa[pi] != NUMA_NO_CONFIG)) { - struct rte_mempool * mp = + struct rte_mempool * mp = mbuf_pool_find(rxring_numa[pi]); if (mp == NULL) { printf("Failed to setup RX queue:" "No mempool allocation" - "on the socket %d\n", + " on the socket %d\n", rxring_numa[pi]); - return; + return -1; } - + diag = rte_eth_rx_queue_setup(pi, qi, nb_rxd,rxring_numa[pi], &(port->rx_conf),mp); - } - else - diag = rte_eth_rx_queue_setup(pi, qi, + } else { + struct rte_mempool *mp = + mbuf_pool_find(port->socket_id); + if (mp == NULL) { + printf("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, nb_rxd,port->socket_id, - &(port->rx_conf), - mbuf_pool_find(port->socket_id)); - + &(port->rx_conf), mp); + } if (diag == 0) continue; - /* Fail to setup rx queue, return */ if (rte_atomic16_cmpset(&(port->port_status), RTE_PORT_HANDLING, @@ -1251,7 +1399,7 @@ start_port(portid_t pid) printf("Fail to configure port %d rx queues\n", pi); /* try to reconfigure queues next time */ port->need_reconfig_queues = 1; - return; + return -1; } } /* start port */ @@ -1270,16 +1418,23 @@ start_port(portid_t pid) RTE_PORT_HANDLING, RTE_PORT_STARTED) == 0) printf("Port %d can not be set into started\n", pi); + rte_eth_macaddr_get(pi, &mac_addr); + 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]); + /* at least one port started, need checking link status */ need_check_link_status = 1; } - if (need_check_link_status) - check_all_ports_link_status(nb_ports, RTE_PORT_ALL); - else + 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"); printf("Done\n"); + return 0; } void @@ -1289,19 +1444,29 @@ stop_port(portid_t pid) struct rte_port *port; int need_check_link_status = 0; - if (test_done == 0) { - printf("Please stop forwarding first\n"); - return; - } if (dcb_test) { dcb_test = 0; dcb_config = 0; } + + if (port_id_is_invalid(pid, ENABLED_WARN)) + return; + printf("Stopping ports...\n"); - for (pi = 0; pi < nb_ports; pi++) { - if (pid < nb_ports && pid != pi) + FOREACH_PORT(pi, ports) { + if (pid != pi && pid != (portid_t)RTE_PORT_ALL) + continue; + + if (port_is_forwarding(pi) != 0 && test_done == 0) { + printf("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); continue; + } port = &ports[pi]; if (rte_atomic16_cmpset(&(port->port_status), RTE_PORT_STARTED, @@ -1315,8 +1480,8 @@ stop_port(portid_t pid) printf("Port %d can not be set into stopped\n", pi); need_check_link_status = 1; } - if (need_check_link_status) - check_all_ports_link_status(nb_ports, RTE_PORT_ALL); + if (need_check_link_status && !no_link_check) + check_all_ports_link_status(RTE_PORT_ALL); printf("Done\n"); } @@ -1327,18 +1492,32 @@ close_port(portid_t pid) portid_t pi; struct rte_port *port; - if (test_done == 0) { - printf("Please stop forwarding first\n"); + if (port_id_is_invalid(pid, ENABLED_WARN)) return; - } printf("Closing ports...\n"); - for (pi = 0; pi < nb_ports; pi++) { - if (pid < nb_ports && pid != pi) + FOREACH_PORT(pi, ports) { + if (pid != pi && pid != (portid_t)RTE_PORT_ALL) + continue; + + if (port_is_forwarding(pi) != 0 && test_done == 0) { + printf("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); 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); + continue; + } + if (rte_atomic16_cmpset(&(port->port_status), RTE_PORT_STOPPED, RTE_PORT_HANDLING) == 0) { printf("Port %d is now not stopped\n", pi); @@ -1349,25 +1528,66 @@ close_port(portid_t pid) if (rte_atomic16_cmpset(&(port->port_status), RTE_PORT_HANDLING, RTE_PORT_CLOSED) == 0) - printf("Port %d can not be set into stopped\n", pi); + printf("Port %d cannot be set to closed\n", pi); } printf("Done\n"); } -int -all_ports_stopped(void) +void +attach_port(char *identifier) { - portid_t pi; - struct rte_port *port; + portid_t pi = 0; + unsigned int socket_id; - for (pi = 0; pi < nb_ports; pi++) { - port = &ports[pi]; - if (port->port_status != RTE_PORT_STOPPED) - return 0; + printf("Attaching a new port...\n"); + + if (identifier == NULL) { + printf("Invalid parameters are specified\n"); + return; } - return 1; + if (rte_eth_dev_attach(identifier, &pi)) + return; + + ports[pi].enabled = 1; + socket_id = (unsigned)rte_eth_dev_socket_id(pi); + /* if socket_id is invalid, set to 0 */ + if (check_socket_id(socket_id) < 0) + socket_id = 0; + reconfig(pi, socket_id); + rte_eth_promiscuous_enable(pi); + + nb_ports = rte_eth_dev_count(); + + ports[pi].port_status = RTE_PORT_STOPPED; + + printf("Port %d is attached. Now total ports is %d\n", pi, nb_ports); + printf("Done\n"); +} + +void +detach_port(uint8_t port_id) +{ + char name[RTE_ETH_NAME_MAX_LEN]; + + printf("Detaching a port...\n"); + + if (!port_is_closed(port_id)) { + printf("Please close port first\n"); + return; + } + + if (rte_eth_dev_detach(port_id, name)) + return; + + ports[port_id].enabled = 0; + nb_ports = rte_eth_dev_count(); + + printf("Port '%s' is detached. Now total ports is %d\n", + name, nb_ports); + printf("Done\n"); + return; } void @@ -1375,13 +1595,19 @@ pmd_test_exit(void) { portid_t pt_id; - for (pt_id = 0; pt_id < nb_ports; pt_id++) { - printf("Stopping port %d...", pt_id); - fflush(stdout); - rte_eth_dev_close(pt_id); - printf("done\n"); + if (test_done == 0) + stop_packet_forwarding(); + + if (ports != NULL) { + no_link_check = 1; + FOREACH_PORT(pt_id, ports) { + printf("\nShutting down port %d...\n", pt_id); + fflush(stdout); + stop_port(pt_id); + close_port(pt_id); + } } - printf("bye...\n"); + printf("\nBye...\n"); } typedef void (*cmd_func_t)(void); @@ -1394,7 +1620,7 @@ struct pmd_test_command { /* Check the link status of all ports in up to 9s, and print them finally */ static void -check_all_ports_link_status(uint8_t port_num, uint32_t port_mask) +check_all_ports_link_status(uint32_t port_mask) { #define CHECK_INTERVAL 100 /* 100ms */ #define MAX_CHECK_TIME 90 /* 9s (90 * 100ms) in total */ @@ -1405,7 +1631,7 @@ check_all_ports_link_status(uint8_t port_num, uint32_t port_mask) fflush(stdout); for (count = 0; count <= MAX_CHECK_TIME; count++) { all_ports_up = 1; - for (portid = 0; portid < port_num; portid++) { + FOREACH_PORT(portid, ports) { if ((port_mask & (1 << portid)) == 0) continue; memset(&link, 0, sizeof(link)); @@ -1424,7 +1650,7 @@ check_all_ports_link_status(uint8_t port_num, uint32_t port_mask) continue; } /* clear all_ports_up flag if any link down */ - if (link.link_status == 0) { + if (link.link_status == ETH_LINK_DOWN) { all_ports_up = 0; break; } @@ -1523,30 +1749,84 @@ map_port_queue_stats_mapping_registers(uint8_t pi, struct rte_port *port) } } +static void +rxtx_port_config(struct rte_port *port) +{ + port->rx_conf = port->dev_info.default_rxconf; + port->tx_conf = port->dev_info.default_txconf; + + /* Check if any RX/TX parameters have been passed */ + if (rx_pthresh != RTE_PMD_PARAM_UNSET) + port->rx_conf.rx_thresh.pthresh = rx_pthresh; + + if (rx_hthresh != RTE_PMD_PARAM_UNSET) + port->rx_conf.rx_thresh.hthresh = rx_hthresh; + + if (rx_wthresh != RTE_PMD_PARAM_UNSET) + port->rx_conf.rx_thresh.wthresh = rx_wthresh; + + if (rx_free_thresh != RTE_PMD_PARAM_UNSET) + port->rx_conf.rx_free_thresh = rx_free_thresh; + + if (rx_drop_en != RTE_PMD_PARAM_UNSET) + port->rx_conf.rx_drop_en = rx_drop_en; + + if (tx_pthresh != RTE_PMD_PARAM_UNSET) + port->tx_conf.tx_thresh.pthresh = tx_pthresh; + + if (tx_hthresh != RTE_PMD_PARAM_UNSET) + port->tx_conf.tx_thresh.hthresh = tx_hthresh; + + if (tx_wthresh != RTE_PMD_PARAM_UNSET) + port->tx_conf.tx_thresh.wthresh = tx_wthresh; + + if (tx_rs_thresh != RTE_PMD_PARAM_UNSET) + port->tx_conf.tx_rs_thresh = tx_rs_thresh; + + if (tx_free_thresh != RTE_PMD_PARAM_UNSET) + port->tx_conf.tx_free_thresh = tx_free_thresh; + + if (txq_flags != RTE_PMD_PARAM_UNSET) + port->tx_conf.txq_flags = txq_flags; +} + void init_port_config(void) { portid_t pid; struct rte_port *port; - for (pid = 0; pid < nb_ports; pid++) { + FOREACH_PORT(pid, ports) { port = &ports[pid]; port->dev_conf.rxmode = rx_mode; port->dev_conf.fdir_conf = fdir_conf; - if (nb_rxq > 0) { + if (nb_rxq > 1) { port->dev_conf.rx_adv_conf.rss_conf.rss_key = NULL; port->dev_conf.rx_adv_conf.rss_conf.rss_hf = rss_hf; } else { port->dev_conf.rx_adv_conf.rss_conf.rss_key = NULL; port->dev_conf.rx_adv_conf.rss_conf.rss_hf = 0; } - port->rx_conf.rx_thresh = rx_thresh; - port->rx_conf.rx_free_thresh = rx_free_thresh; - port->rx_conf.rx_drop_en = rx_drop_en; - port->tx_conf.tx_thresh = tx_thresh; - port->tx_conf.tx_rs_thresh = tx_rs_thresh; - port->tx_conf.tx_free_thresh = tx_free_thresh; - port->tx_conf.txq_flags = txq_flags; + + if (port->dcb_flag == 0 && port->dev_info.max_vfs == 0) { + if( port->dev_conf.rx_adv_conf.rss_conf.rss_hf != 0) + port->dev_conf.rxmode.mq_mode = ETH_MQ_RX_RSS; + else + port->dev_conf.rxmode.mq_mode = ETH_MQ_RX_NONE; + } + + if (port->dev_info.max_vfs != 0) { + if (port->dev_conf.rx_adv_conf.rss_conf.rss_hf != 0) + port->dev_conf.rxmode.mq_mode = + ETH_MQ_RX_VMDQ_RSS; + else + port->dev_conf.rxmode.mq_mode = + ETH_MQ_RX_NONE; + + port->dev_conf.txmode.mq_mode = ETH_MQ_TX_NONE; + } + + rxtx_port_config(port); rte_eth_macaddr_get(pid, &port->eth_addr); @@ -1557,6 +1837,30 @@ init_port_config(void) } } +void set_port_slave_flag(portid_t slave_pid) +{ + struct rte_port *port; + + port = &ports[slave_pid]; + port->slave_flag = 1; +} + +void clear_port_slave_flag(portid_t slave_pid) +{ + struct rte_port *port; + + port = &ports[slave_pid]; + port->slave_flag = 0; +} + +uint8_t port_is_bonding_slave(portid_t slave_pid) +{ + struct rte_port *port; + + port = &ports[slave_pid]; + return port->slave_flag; +} + const uint16_t vlan_tags[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, @@ -1565,131 +1869,183 @@ const uint16_t vlan_tags[] = { }; static int -get_eth_dcb_conf(struct rte_eth_conf *eth_conf, struct dcb_config *dcb_conf) +get_eth_dcb_conf(struct rte_eth_conf *eth_conf, + enum dcb_mode_enable dcb_mode, + enum rte_eth_nb_tcs num_tcs, + uint8_t pfc_en) { - uint8_t i; - - /* - * Builds up the correct configuration for dcb+vt based on the vlan tags array - * given above, and the number of traffic classes available for use. - */ - if (dcb_conf->dcb_mode == DCB_VT_ENABLED) { - struct rte_eth_vmdq_dcb_conf vmdq_rx_conf; - struct rte_eth_vmdq_dcb_tx_conf vmdq_tx_conf; - + uint8_t i; + + /* + * Builds up the correct configuration for dcb+vt based on the vlan tags array + * given above, and the number of traffic classes available for use. + */ + if (dcb_mode == DCB_VT_ENABLED) { + struct rte_eth_vmdq_dcb_conf *vmdq_rx_conf = + ð_conf->rx_adv_conf.vmdq_dcb_conf; + struct rte_eth_vmdq_dcb_tx_conf *vmdq_tx_conf = + ð_conf->tx_adv_conf.vmdq_dcb_tx_conf; + /* VMDQ+DCB RX and TX configrations */ - vmdq_rx_conf.enable_default_pool = 0; - vmdq_rx_conf.default_pool = 0; - vmdq_rx_conf.nb_queue_pools = - (dcb_conf->num_tcs == ETH_4_TCS ? ETH_32_POOLS : ETH_16_POOLS); - vmdq_tx_conf.nb_queue_pools = - (dcb_conf->num_tcs == ETH_4_TCS ? ETH_32_POOLS : ETH_16_POOLS); - - vmdq_rx_conf.nb_pool_maps = sizeof( vlan_tags )/sizeof( vlan_tags[ 0 ]); - for (i = 0; i < vmdq_rx_conf.nb_pool_maps; i++) { - vmdq_rx_conf.pool_map[i].vlan_id = vlan_tags[ i ]; - vmdq_rx_conf.pool_map[i].pools = 1 << (i % vmdq_rx_conf.nb_queue_pools); + vmdq_rx_conf->enable_default_pool = 0; + vmdq_rx_conf->default_pool = 0; + vmdq_rx_conf->nb_queue_pools = + (num_tcs == ETH_4_TCS ? ETH_32_POOLS : ETH_16_POOLS); + vmdq_tx_conf->nb_queue_pools = + (num_tcs == ETH_4_TCS ? ETH_32_POOLS : ETH_16_POOLS); + + vmdq_rx_conf->nb_pool_maps = vmdq_rx_conf->nb_queue_pools; + for (i = 0; i < vmdq_rx_conf->nb_pool_maps; i++) { + vmdq_rx_conf->pool_map[i].vlan_id = vlan_tags[i]; + vmdq_rx_conf->pool_map[i].pools = + 1 << (i % vmdq_rx_conf->nb_queue_pools); } for (i = 0; i < ETH_DCB_NUM_USER_PRIORITIES; i++) { - vmdq_rx_conf.dcb_queue[i] = i; - vmdq_tx_conf.dcb_queue[i] = i; + vmdq_rx_conf->dcb_tc[i] = i; + vmdq_tx_conf->dcb_tc[i] = i; } - - /*set DCB mode of RX and TX of multiple queues*/ + + /* set DCB mode of RX and TX of multiple queues */ eth_conf->rxmode.mq_mode = ETH_MQ_RX_VMDQ_DCB; eth_conf->txmode.mq_mode = ETH_MQ_TX_VMDQ_DCB; - if (dcb_conf->pfc_en) - eth_conf->dcb_capability_en = ETH_DCB_PG_SUPPORT|ETH_DCB_PFC_SUPPORT; - else - eth_conf->dcb_capability_en = ETH_DCB_PG_SUPPORT; - - (void)(rte_memcpy(ð_conf->rx_adv_conf.vmdq_dcb_conf, &vmdq_rx_conf, - sizeof(struct rte_eth_vmdq_dcb_conf))); - (void)(rte_memcpy(ð_conf->tx_adv_conf.vmdq_dcb_tx_conf, &vmdq_tx_conf, - sizeof(struct rte_eth_vmdq_dcb_tx_conf))); - } - else { - struct rte_eth_dcb_rx_conf rx_conf; - struct rte_eth_dcb_tx_conf tx_conf; - - /* queue mapping configuration of DCB RX and TX */ - if (dcb_conf->num_tcs == ETH_4_TCS) - dcb_q_mapping = DCB_4_TCS_Q_MAPPING; - else - dcb_q_mapping = DCB_8_TCS_Q_MAPPING; - - rx_conf.nb_tcs = dcb_conf->num_tcs; - tx_conf.nb_tcs = dcb_conf->num_tcs; - - for (i = 0; i < ETH_DCB_NUM_USER_PRIORITIES; i++){ - rx_conf.dcb_queue[i] = i; - tx_conf.dcb_queue[i] = i; + } else { + struct rte_eth_dcb_rx_conf *rx_conf = + ð_conf->rx_adv_conf.dcb_rx_conf; + struct rte_eth_dcb_tx_conf *tx_conf = + ð_conf->tx_adv_conf.dcb_tx_conf; + + rx_conf->nb_tcs = num_tcs; + tx_conf->nb_tcs = num_tcs; + + for (i = 0; i < num_tcs; i++) { + rx_conf->dcb_tc[i] = i; + tx_conf->dcb_tc[i] = i; } - eth_conf->rxmode.mq_mode = ETH_MQ_RX_DCB; + eth_conf->rxmode.mq_mode = ETH_MQ_RX_DCB_RSS; + eth_conf->rx_adv_conf.rss_conf.rss_hf = rss_hf; eth_conf->txmode.mq_mode = ETH_MQ_TX_DCB; - if (dcb_conf->pfc_en) - eth_conf->dcb_capability_en = ETH_DCB_PG_SUPPORT|ETH_DCB_PFC_SUPPORT; - else - eth_conf->dcb_capability_en = ETH_DCB_PG_SUPPORT; - - (void)(rte_memcpy(ð_conf->rx_adv_conf.dcb_rx_conf, &rx_conf, - sizeof(struct rte_eth_dcb_rx_conf))); - (void)(rte_memcpy(ð_conf->tx_adv_conf.dcb_tx_conf, &tx_conf, - sizeof(struct rte_eth_dcb_tx_conf))); } + if (pfc_en) + eth_conf->dcb_capability_en = + ETH_DCB_PG_SUPPORT | ETH_DCB_PFC_SUPPORT; + else + eth_conf->dcb_capability_en = ETH_DCB_PG_SUPPORT; + return 0; } int -init_port_dcb_config(portid_t pid,struct dcb_config *dcb_conf) +init_port_dcb_config(portid_t pid, + enum dcb_mode_enable dcb_mode, + enum rte_eth_nb_tcs num_tcs, + uint8_t pfc_en) { struct rte_eth_conf port_conf; + struct rte_eth_dev_info dev_info; struct rte_port *rte_port; int retval; - uint16_t nb_vlan; uint16_t i; - - /* rxq and txq configuration in dcb mode */ - nb_rxq = 128; - nb_txq = 128; + + rte_eth_dev_info_get(pid, &dev_info); + + /* If dev_info.vmdq_pool_base is greater than 0, + * the queue id of vmdq pools is started after pf queues. + */ + if (dcb_mode == DCB_VT_ENABLED && dev_info.vmdq_pool_base > 0) { + printf("VMDQ_DCB multi-queue mode is nonsensical" + " for port %d.", pid); + return -1; + } + + /* Assume the ports in testpmd have the same dcb capability + * and has the same number of rxq and txq in dcb mode + */ + if (dcb_mode == DCB_VT_ENABLED) { + nb_rxq = dev_info.max_rx_queues; + nb_txq = dev_info.max_tx_queues; + } else { + /*if vt is disabled, use all pf queues */ + if (dev_info.vmdq_pool_base == 0) { + nb_rxq = dev_info.max_rx_queues; + nb_txq = dev_info.max_tx_queues; + } else { + nb_rxq = (queueid_t)num_tcs; + nb_txq = (queueid_t)num_tcs; + + } + } rx_free_thresh = 64; - - memset(&port_conf,0,sizeof(struct rte_eth_conf)); + + memset(&port_conf, 0, sizeof(struct rte_eth_conf)); /* Enter DCB configuration status */ dcb_config = 1; - - nb_vlan = sizeof( vlan_tags )/sizeof( vlan_tags[ 0 ]); + /*set configuration of DCB in vt mode and DCB in non-vt mode*/ - retval = get_eth_dcb_conf(&port_conf, dcb_conf); + retval = get_eth_dcb_conf(&port_conf, dcb_mode, num_tcs, pfc_en); if (retval < 0) return retval; - + rte_port = &ports[pid]; - memcpy(&rte_port->dev_conf, &port_conf,sizeof(struct rte_eth_conf)); - - rte_port->rx_conf.rx_thresh = rx_thresh; - rte_port->rx_conf.rx_free_thresh = rx_free_thresh; - rte_port->tx_conf.tx_thresh = tx_thresh; - rte_port->tx_conf.tx_rs_thresh = tx_rs_thresh; - rte_port->tx_conf.tx_free_thresh = tx_free_thresh; + memcpy(&rte_port->dev_conf, &port_conf, sizeof(struct rte_eth_conf)); + + rxtx_port_config(rte_port); /* VLAN filter */ rte_port->dev_conf.rxmode.hw_vlan_filter = 1; - for (i = 0; i < nb_vlan; i++){ + for (i = 0; i < RTE_DIM(vlan_tags); i++) rx_vft_set(pid, vlan_tags[i], 1); - } - + rte_eth_macaddr_get(pid, &rte_port->eth_addr); map_port_queue_stats_mapping_registers(pid, rte_port); rte_port->dcb_flag = 1; - + return 0; } -#ifdef RTE_EXEC_ENV_BAREMETAL -#define main _main +static void +init_port(void) +{ + portid_t pid; + + /* Configuration of Ethernet ports. */ + ports = rte_zmalloc("testpmd: ports", + sizeof(struct rte_port) * RTE_MAX_ETHPORTS, + RTE_CACHE_LINE_SIZE); + if (ports == NULL) { + rte_exit(EXIT_FAILURE, + "rte_zmalloc(%d struct rte_port) failed\n", + RTE_MAX_ETHPORTS); + } + + /* enabled allocated ports */ + for (pid = 0; pid < nb_ports; pid++) + ports[pid].enabled = 1; +} + +static void +force_quit(void) +{ + pmd_test_exit(); + prompt_exit(); +} + +static void +signal_handler(int signum) +{ + if (signum == SIGINT || signum == SIGTERM) { + printf("\nSignal %d received, preparing to exit...\n", + signum); +#ifdef RTE_LIBRTE_PDUMP + /* uninitialize packet capture framework */ + rte_pdump_uninit(); #endif + force_quit(); + /* exit with the expected status */ + signal(signum, SIG_DFL); + kill(getpid(), signum); + } +} int main(int argc, char** argv) @@ -1697,24 +2053,24 @@ main(int argc, char** argv) int diag; uint8_t port_id; + signal(SIGINT, signal_handler); + signal(SIGTERM, signal_handler); + diag = rte_eal_init(argc, argv); if (diag < 0) rte_panic("Cannot init EAL\n"); - if (rte_pmd_init_all()) - rte_panic("Cannot init PMD\n"); - - if (rte_eal_pci_probe()) - rte_panic("Cannot probe PCI\n"); +#ifdef RTE_LIBRTE_PDUMP + /* initialize packet capture framework */ + rte_pdump_init(NULL); +#endif nb_ports = (portid_t) rte_eth_dev_count(); if (nb_ports == 0) - rte_exit(EXIT_FAILURE, "No probed ethernet devices - " - "check that " - "CONFIG_RTE_LIBRTE_IGB_PMD=y and that " - "CONFIG_RTE_LIBRTE_EM_PMD=y and that " - "CONFIG_RTE_LIBRTE_IXGBE_PMD=y in your " - "configuration file\n"); + RTE_LOG(WARNING, EAL, "No probed ethernet devices\n"); + + /* allocate port structures, and init them */ + init_port(); set_def_fwd_config(); if (nb_lcores == 0) @@ -1726,21 +2082,32 @@ main(int argc, char** argv) if (argc > 1) launch_args_parse(argc, argv); - if (nb_rxq > nb_txq) + if (!nb_rxq && !nb_txq) + printf("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); init_config(); - start_port(RTE_PORT_ALL); + if (start_port(RTE_PORT_ALL) != 0) + rte_exit(EXIT_FAILURE, "Start ports failed\n"); /* set all ports to promiscuous mode by default */ - for (port_id = 0; port_id < nb_ports; port_id++) + FOREACH_PORT(port_id, ports) rte_eth_promiscuous_enable(port_id); - if (interactive == 1) +#ifdef RTE_LIBRTE_CMDLINE + if (interactive == 1) { + if (auto_start) { + printf("Start automatic packet forwarding\n"); + start_packet_forwarding(0); + } prompt(); - else { + } else +#endif + { char c; int rc; @@ -1748,6 +2115,7 @@ main(int argc, char** argv) start_packet_forwarding(0); printf("Press enter to exit\n"); rc = read(0, &c, 1); + pmd_test_exit(); if (rc < 0) return 1; }