#include <rte_memcpy.h>
#include <rte_memzone.h>
#include <rte_launch.h>
-#include <rte_tailq.h>
#include <rte_eal.h>
#include <rte_per_lcore.h>
#include <rte_lcore.h>
#include <rte_pci.h>
#include <rte_ether.h>
#include <rte_ethdev.h>
+#include <rte_dev.h>
#include <rte_string_fns.h>
#ifdef RTE_LIBRTE_PMD_XENVIRT
#include <rte_eth_xenvirt.h>
.mode = RTE_FDIR_MODE_NONE,
.pballoc = RTE_FDIR_PBALLOC_64K,
.status = RTE_FDIR_REPORT_STATUS,
+ .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,
+ },
.drop_queue = 127,
};
/* 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.
*/
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.
*/
/*
* 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->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->ol_flags = 0;
- mb->data_off = RTE_PKTMBUF_HEADROOM;
- mb->nb_segs = 1;
- mb->tx_offload = 0;
- mb->vlan_tci = 0;
- mb->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 = rte_mempool_get_priv(mp);
- 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;
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) RTE_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));
#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),
- testpmd_mbuf_pool_ctor, &mbp_ctor_arg,
- testpmd_mbuf_ctor, &mb_ctor_arg,
- socket_id, 0);
+ (unsigned) mb_mempool_cache,
+ sizeof(struct rte_pktmbuf_pool_private),
+ rte_pktmbuf_pool_init, NULL,
+ rte_pktmbuf_init, NULL,
+ socket_id, 0);
rte_mp = mempool_anon_create(pool_name, nb_mbuf, 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,
+ rte_pktmbuf_pool_init, NULL,
+ rte_pktmbuf_init, NULL,
socket_id, 0);
else
- rte_mp = rte_mempool_create(pool_name, nb_mbuf, 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);
+ /* wrapper to rte_mempool_create() */
+ rte_mp = rte_pktmbuf_pool_create(pool_name, nb_mbuf,
+ mb_mempool_cache, 0, mbuf_seg_size, socket_id);
#endif
+ RTE_TEST_TX_DESC_MAX + MAX_PKT_BURST;
if (!numa_support)
- nb_mbuf_per_pool = (nb_mbuf_per_pool * nb_ports);
+ nb_mbuf_per_pool =
+ (nb_mbuf_per_pool * RTE_MAX_ETHPORTS);
}
if (!numa_support) {
socket_num);
}
- /* Configuration of Ethernet ports. */
- ports = rte_zmalloc("testpmd: ports",
- sizeof(struct rte_port) * nb_ports,
- RTE_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);
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]);
+ nb_mbuf = (nb_mbuf_per_pool * RTE_MAX_ETHPORTS);
if (nb_mbuf)
mbuf_pool_create(mbuf_data_size,
nb_mbuf,i);
struct rte_port *port;
/* Reconfiguration of Ethernet ports. */
- ports = rte_realloc(ports,
- sizeof(struct rte_port) * nb_ports,
- RTE_CACHE_LINE_SIZE);
- if (ports == NULL) {
- rte_exit(EXIT_FAILURE, "rte_realloc(%d struct rte_port) failed\n",
- nb_ports);
- }
-
port = &ports[new_port_id];
rte_eth_dev_info_get(new_port_id, &port->dev_info);
streamid_t sm_id, nb_fwd_streams_new;
/* 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 "
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)
return 1;
}
+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)
+ 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;
return -1;
}
+ if (port_id_is_invalid(pid, ENABLED_WARN))
+ return 0;
+
if (init_fwd_streams() < 0) {
printf("Fail from init_fwd_streams()\n");
return -1;
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) {
need_check_link_status = 1;
}
- if (need_check_link_status && !no_link_check)
- 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");
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;
port = &ports[pi];
need_check_link_status = 1;
}
if (need_check_link_status && !no_link_check)
- check_all_ports_link_status(nb_ports, RTE_PORT_ALL);
+ check_all_ports_link_status(RTE_PORT_ALL);
printf("Done\n");
}
return;
}
+ 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;
port = &ports[pi];
printf("Done\n");
}
-int
-all_ports_stopped(void)
+void
+attach_port(char *identifier)
{
- portid_t pi;
- struct rte_port *port;
+ portid_t i, j, pi = 0;
- 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 (test_done == 0) {
+ printf("Please stop forwarding first\n");
+ return;
+ }
+
+ if (rte_eth_dev_attach(identifier, &pi))
+ return;
+
+ ports[pi].enabled = 1;
+ reconfig(pi, rte_eth_dev_socket_id(pi));
+ rte_eth_promiscuous_enable(pi);
+
+ nb_ports = rte_eth_dev_count();
+
+ /* set_default_fwd_ports_config(); */
+ bzero(fwd_ports_ids, sizeof(fwd_ports_ids));
+ i = 0;
+ FOREACH_PORT(j, ports) {
+ fwd_ports_ids[i] = j;
+ i++;
+ }
+ nb_cfg_ports = nb_ports;
+ nb_fwd_ports++;
+
+ ports[pi].port_status = RTE_PORT_STOPPED;
+
+ printf("Port %d is attached. Now total ports is %d\n", pi, nb_ports);
+ printf("Done\n");
}
-int
-port_is_started(portid_t port_id)
+void
+detach_port(uint8_t port_id)
{
- if (port_id_is_invalid(port_id))
- return -1;
+ portid_t i, pi = 0;
+ char name[RTE_ETH_NAME_MAX_LEN];
- if (ports[port_id].port_status != RTE_PORT_STARTED)
- return 0;
+ printf("Detaching a port...\n");
- return 1;
+ if (!port_is_closed(port_id)) {
+ printf("Please close port first\n");
+ return;
+ }
+
+ rte_eth_promiscuous_disable(port_id);
+
+ if (rte_eth_dev_detach(port_id, name))
+ return;
+
+ ports[port_id].enabled = 0;
+ nb_ports = rte_eth_dev_count();
+
+ /* set_default_fwd_ports_config(); */
+ bzero(fwd_ports_ids, sizeof(fwd_ports_ids));
+ i = 0;
+ FOREACH_PORT(pi, ports) {
+ fwd_ports_ids[i] = pi;
+ i++;
+ }
+ nb_cfg_ports = nb_ports;
+ nb_fwd_ports--;
+
+ printf("Port '%s' is detached. Now total ports is %d\n",
+ name, nb_ports);
+ printf("Done\n");
+ return;
}
void
{
portid_t pt_id;
- for (pt_id = 0; pt_id < nb_ports; pt_id++) {
+ if (test_done == 0)
+ stop_packet_forwarding();
+
+ FOREACH_PORT(pt_id, ports) {
printf("Stopping port %d...", pt_id);
fflush(stdout);
rte_eth_dev_close(pt_id);
/* 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 */
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));
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;
return 0;
}
+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;
+}
+
int
main(int argc, char** argv)
{
nb_ports = (portid_t) rte_eth_dev_count();
if (nb_ports == 0)
- rte_exit(EXIT_FAILURE, "No probed ethernet device\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)
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);
#ifdef RTE_LIBRTE_CMDLINE
git.droids-corp.org / dpdk.git / blobdiff