/*
* Main thread that does the work, reading from INPUT_PORT
* and writing to OUTPUT_PORT
*/
static __attribute__((noreturn)) void
lcore_main(void)
{
uint8_t port = 0;
if (rte_eth_dev_socket_id(port) > 0 &&
rte_eth_dev_socket_id(port) !=
(int)rte_socket_id())
printf("WARNING, port %u is on remote NUMA node to "
"polling thread.\n\tPerformance will "
"not be optimal.\n", port);
printf("\nCore %u forwarding packets. [Ctrl+C to quit]\n",
rte_lcore_id());
for (;;) {
struct rte_mbuf *bufs[BURST_SIZE];
const uint16_t nb_rx = rte_eth_rx_burst(port, 0,
bufs, BURST_SIZE);
uint16_t buf;
if (unlikely(nb_rx == 0))
continue;
for (buf = 0; buf < nb_rx; buf++) {
struct rte_mbuf *mbuf = bufs[buf];
unsigned int len = rte_pktmbuf_data_len(mbuf);
rte_pktmbuf_dump(stdout, mbuf, len);
rte_pktmbuf_free(mbuf);
}
}
}
static void
app_init_ports(void)
{
uint32_t i;
/* Init driver */
RTE_LOG(INFO, USER1, "Initializing the PMD driver ...\n");
if (rte_eal_pci_probe() < 0)
rte_panic("Cannot probe PCI\n");
/* Init NIC ports, then start the ports */
for (i = 0; i < app.n_ports; i++) {
uint8_t port;
int ret;
port = (uint8_t) app.ports[i];
RTE_LOG(INFO, USER1, "Initializing NIC port %u ...\n", port);
/* Init port */
ret = rte_eth_dev_configure(
port,
1,
1,
&port_conf);
if (ret < 0)
rte_panic("Cannot init NIC port %u (%d)\n", port, ret);
rte_eth_promiscuous_enable(port);
/* Init RX queues */
ret = rte_eth_rx_queue_setup(
port,
0,
app.port_rx_ring_size,
rte_eth_dev_socket_id(port),
&rx_conf,
app.pool);
if (ret < 0)
rte_panic("Cannot init RX for port %u (%d)\n",
(uint32_t) port, ret);
/* Init TX queues */
ret = rte_eth_tx_queue_setup(
port,
0,
app.port_tx_ring_size,
rte_eth_dev_socket_id(port),
&tx_conf);
if (ret < 0)
rte_panic("Cannot init TX for port %u (%d)\n",
(uint32_t) port, ret);
/* Start port */
ret = rte_eth_dev_start(port);
if (ret < 0)
rte_panic("Cannot start port %u (%d)\n", port, ret);
}
app_ports_check_link();
}
/* Setup ethdev hardware queues */
static int
dpdk_ethdev_queues_setup(struct vr_dpdk_ethdev *ethdev)
{
int ret, i;
uint8_t port_id = ethdev->ethdev_port_id;
struct rte_mempool *mempool;
/* configure RX queues */
RTE_LOG(DEBUG, VROUTER, "%s: nb_rx_queues=%u nb_tx_queues=%u\n",
__func__, (unsigned)ethdev->ethdev_nb_rx_queues,
(unsigned)ethdev->ethdev_nb_tx_queues);
for (i = 0; i < VR_DPDK_MAX_NB_RX_QUEUES; i++) {
if (i < ethdev->ethdev_nb_rss_queues) {
mempool = vr_dpdk.rss_mempool;
ethdev->ethdev_queue_states[i] = VR_DPDK_QUEUE_RSS_STATE;
} else if (i < ethdev->ethdev_nb_rx_queues) {
if (vr_dpdk.nb_free_mempools == 0) {
RTE_LOG(ERR, VROUTER, " error assigning mempool to eth device %"
PRIu8 " RX queue %d\n", port_id, i);
return -ENOMEM;
}
vr_dpdk.nb_free_mempools--;
mempool = vr_dpdk.free_mempools[vr_dpdk.nb_free_mempools];
ethdev->ethdev_queue_states[i] = VR_DPDK_QUEUE_READY_STATE;
} else {
ethdev->ethdev_queue_states[i] = VR_DPDK_QUEUE_NONE;
continue;
}
ret = rte_eth_rx_queue_setup(port_id, i, VR_DPDK_NB_RXD,
rte_eth_dev_socket_id(port_id), &rx_queue_conf, mempool);
if (ret < 0) {
/* return mempool to the list */
if (mempool != vr_dpdk.rss_mempool)
vr_dpdk.nb_free_mempools++;
RTE_LOG(ERR, VROUTER, " error setting up eth device %" PRIu8 " RX queue %d"
": %s (%d)\n", port_id, i, rte_strerror(-ret), -ret);
return ret;
}
/* save queue mempool pointer */
ethdev->ethdev_mempools[i] = mempool;
}
i = ethdev->ethdev_nb_rx_queues - ethdev->ethdev_nb_rss_queues;
RTE_LOG(INFO, VROUTER, " setup %d RSS queue(s) and %d filtering queue(s)\n",
(int)ethdev->ethdev_nb_rss_queues, i);
/* configure TX queues */
for (i = 0; i < ethdev->ethdev_nb_tx_queues; i++) {
ret = rte_eth_tx_queue_setup(port_id, i, VR_DPDK_NB_TXD,
rte_eth_dev_socket_id(port_id), &tx_queue_conf);
if (ret < 0) {
RTE_LOG(ERR, VROUTER, " error setting up eth device %" PRIu8 " TX queue %d"
": %s (%d)\n", port_id, i, rte_strerror(-ret), -ret);
return ret;
}
}
return 0;
}
static void
bond_port_init(struct rte_mempool *mbuf_pool)
{
int retval;
uint8_t i;
retval = rte_eth_bond_create("bond0", BONDING_MODE_ALB,
0 /*SOCKET_ID_ANY*/);
if (retval < 0)
rte_exit(EXIT_FAILURE,
"Faled to create bond port\n");
BOND_PORT = (uint8_t)retval;
retval = rte_eth_dev_configure(BOND_PORT, 1, 1, &port_conf);
if (retval != 0)
rte_exit(EXIT_FAILURE, "port %u: configuration failed (res=%d)\n",
BOND_PORT, retval);
/* RX setup */
retval = rte_eth_rx_queue_setup(BOND_PORT, 0, RTE_RX_DESC_DEFAULT,
rte_eth_dev_socket_id(BOND_PORT), NULL,
mbuf_pool);
if (retval < 0)
rte_exit(retval, " port %u: RX queue 0 setup failed (res=%d)",
BOND_PORT, retval);
/* TX setup */
retval = rte_eth_tx_queue_setup(BOND_PORT, 0, RTE_TX_DESC_DEFAULT,
rte_eth_dev_socket_id(BOND_PORT), NULL);
if (retval < 0)
rte_exit(retval, "port %u: TX queue 0 setup failed (res=%d)",
BOND_PORT, retval);
for (i = 0; i < slaves_count; i++) {
if (rte_eth_bond_slave_add(BOND_PORT, slaves[i]) == -1)
rte_exit(-1, "Oooops! adding slave (%u) to bond (%u) failed!\n",
slaves[i], BOND_PORT);
}
retval = rte_eth_dev_start(BOND_PORT);
if (retval < 0)
rte_exit(retval, "Start port %d failed (res=%d)", BOND_PORT, retval);
rte_eth_promiscuous_enable(BOND_PORT);
struct ether_addr addr;
rte_eth_macaddr_get(BOND_PORT, &addr);
printf("Port %u MAC: ", (unsigned)BOND_PORT);
PRINT_MAC(addr);
printf("\n");
}
static void
app_init_ports(void)
{
uint32_t i;
/* Init NIC ports, then start the ports */
for (i = 0; i < app.n_ports; i++) {
uint32_t port;
int ret;
port = app.ports[i];
RTE_LOG(INFO, USER1, "Initializing NIC port %u ...\n", port);
/* Init port */
ret = rte_eth_dev_configure(
port,
1,
1,
&app.port_conf);
if (ret < 0)
rte_panic("Cannot init NIC port %u (%d)\n", port, ret);
rte_eth_promiscuous_enable(port);
/* Init RX queues */
ret = rte_eth_rx_queue_setup(
port,
0,
app.rsz_hwq_rx,
rte_eth_dev_socket_id(port),
&app.rx_conf,
app.pool);
if (ret < 0)
rte_panic("Cannot init RX for port %u (%d)\n",
(uint32_t) port, ret);
/* Init TX queues */
ret = rte_eth_tx_queue_setup(
port,
0,
app.rsz_hwq_tx,
rte_eth_dev_socket_id(port),
&app.tx_conf);
if (ret < 0)
rte_panic("Cannot init TX for port %u (%d)\n", port,
ret);
/* Start port */
ret = rte_eth_dev_start(port);
if (ret < 0)
rte_panic("Cannot start port %u (%d)\n", port, ret);
}
app_ports_check_link();
}
static inline int
port_init(uint16_t port, struct rte_mempool *mbuf_pool)
{
struct rte_eth_conf port_conf = port_conf_default;
const uint16_t rx_rings = 1, tx_rings = 1;
int retval;
uint16_t q;
if (port >= rte_eth_dev_count())
return -1;
/* Configure the Ethernet device. */
retval = rte_eth_dev_configure(port, rx_rings, tx_rings, &port_conf);
if (retval != 0)
return retval;
/* Allocate and set up 1 RX queue per Ethernet port. */
for (q = 0; q < rx_rings; q++) {
retval = rte_eth_rx_queue_setup(port, q, RX_RING_SIZE,
rte_eth_dev_socket_id(port), NULL, mbuf_pool);
if (retval < 0)
return retval;
}
/* Allocate and set up 1 TX queue per Ethernet port. */
for (q = 0; q < tx_rings; q++) {
retval = rte_eth_tx_queue_setup(port, q, TX_RING_SIZE,
rte_eth_dev_socket_id(port), NULL);
if (retval < 0)
return retval;
}
/* Start the Ethernet port. */
retval = rte_eth_dev_start(port);
if (retval < 0)
return retval;
/* Display the port MAC address. */
struct ether_addr addr;
rte_eth_macaddr_get(port, &addr);
printf("Port %u MAC: %02" PRIx8 " %02" PRIx8 " %02" PRIx8
" %02" PRIx8 " %02" PRIx8 " %02" PRIx8 "\n",
(unsigned int)port,
addr.addr_bytes[0], addr.addr_bytes[1],
addr.addr_bytes[2], addr.addr_bytes[3],
addr.addr_bytes[4], addr.addr_bytes[5]);
/* Enable RX in promiscuous mode for the Ethernet device. */
rte_eth_promiscuous_enable(port);
return 0;
}
/**
* Initialise an individual port:
* - configure number of rx and tx rings
* - set up each rx ring, to pull from the main mbuf pool
* - set up each tx ring
* - start the port and report its status to stdout
*/
int
init_port(uint8_t port_num)
{
/* for port configuration all features are off by default */\
const struct rte_eth_conf port_conf = {
.rxmode = {
.hw_vlan_filter = 0,
.hw_vlan_strip = 0,
.hw_vlan_extend = 0,
.mq_mode = ETH_MQ_RX_RSS
}
};
const uint16_t rx_rings = 1, tx_rings = 1;
const uint16_t rx_ring_size = RTE_MP_RX_DESC_DEFAULT;
const uint16_t tx_ring_size = RTE_MP_TX_DESC_DEFAULT;
uint16_t q;
int retval;
printf("Port %u init ... ", (unsigned)port_num);
fflush(stdout);
/* Standard DPDK port initialisation - config port, then set up
* rx and tx rings */
if ((retval = rte_eth_dev_configure(port_num, rx_rings, tx_rings,
&port_conf)) != 0)
return retval;
for (q = 0; q < rx_rings; q++) {
retval = rte_eth_rx_queue_setup(port_num, q, rx_ring_size,
rte_eth_dev_socket_id(port_num),
NULL, pktmbuf_pool);
if (retval < 0) return retval;
}
for ( q = 0; q < tx_rings; q ++ ) {
retval = rte_eth_tx_queue_setup(port_num, q, tx_ring_size,
rte_eth_dev_socket_id(port_num),
NULL);
if (retval < 0) return retval;
}
rte_eth_promiscuous_enable(port_num);
retval = rte_eth_dev_start(port_num);
if (retval < 0) return retval;
printf( "Port %d Init done\n", port_num);
return 0;
}
/*
* Initialises a given port using global settings and with the rx buffers
* coming from the mbuf_pool passed as parameter
*/
static inline int
port_init(uint8_t port, struct rte_mempool *mbuf_pool)
{
struct rte_eth_conf port_conf;
const uint16_t rxRings = ETH_VMDQ_DCB_NUM_QUEUES,
txRings = (uint16_t)rte_lcore_count();
const uint16_t rxRingSize = 128, txRingSize = 512;
int retval;
uint16_t q;
retval = get_eth_conf(&port_conf, num_pools);
if (retval < 0)
return retval;
if (port >= rte_eth_dev_count()) return -1;
retval = rte_eth_dev_configure(port, rxRings, txRings, &port_conf);
if (retval != 0)
return retval;
for (q = 0; q < rxRings; q ++) {
retval = rte_eth_rx_queue_setup(port, q, rxRingSize,
rte_eth_dev_socket_id(port),
NULL,
mbuf_pool);
if (retval < 0)
return retval;
}
for (q = 0; q < txRings; q ++) {
retval = rte_eth_tx_queue_setup(port, q, txRingSize,
rte_eth_dev_socket_id(port),
NULL);
if (retval < 0)
return retval;
}
retval = rte_eth_dev_start(port);
if (retval < 0)
return retval;
struct ether_addr addr;
rte_eth_macaddr_get(port, &addr);
printf("Port %u MAC: %02"PRIx8" %02"PRIx8" %02"PRIx8
" %02"PRIx8" %02"PRIx8" %02"PRIx8"\n",
(unsigned)port,
addr.addr_bytes[0], addr.addr_bytes[1], addr.addr_bytes[2],
addr.addr_bytes[3], addr.addr_bytes[4], addr.addr_bytes[5]);
return 0;
}
/*
* The lcore main. This is the main thread that does the work, reading from
* an input port and writing to an output port.
*/
static __attribute__((noreturn)) void
lcore_main(void)
{
const uint8_t nb_ports = rte_eth_dev_count();
uint8_t port;
/*
* Check that the port is on the same NUMA node as the polling thread
* for best performance.
*/
for (port = 0; port < nb_ports; port++)
if (rte_eth_dev_socket_id(port) > 0 &&
rte_eth_dev_socket_id(port) !=
(int)rte_socket_id())
printf("WARNING, port %u is on remote NUMA node to "
"polling thread.\n\tPerformance will "
"not be optimal.\n", port);
printf("\nCore %u forwarding packets. [Ctrl+C to quit]\n",
rte_lcore_id());
/* Run until the application is quit or killed. */
for (;;) {
/*
* Receive packets on a port and forward them on the paired
* port. The mapping is 0 -> 1, 1 -> 0, 2 -> 3, 3 -> 2, etc.
*/
for (port = 0; port < nb_ports; port++) {
/* Get burst of RX packets, from first port of pair. */
struct rte_mbuf *bufs[BURST_SIZE];
const uint16_t nb_rx = rte_eth_rx_burst(port, 0,
bufs, BURST_SIZE);
if (unlikely(nb_rx == 0))
continue;
/* Send burst of TX packets, to second port of pair. */
const uint16_t nb_tx = rte_eth_tx_burst(port ^ 1, 0,
bufs, nb_rx);
/* Free any unsent packets. */
if (unlikely(nb_tx < nb_rx)) {
uint16_t buf;
for (buf = nb_tx; buf < nb_rx; buf++)
rte_pktmbuf_free(bufs[buf]);
}
}
}
}
static void
slave_port_init(uint16_t portid, struct rte_mempool *mbuf_pool)
{
int retval;
uint16_t nb_rxd = RTE_RX_DESC_DEFAULT;
uint16_t nb_txd = RTE_TX_DESC_DEFAULT;
if (portid >= rte_eth_dev_count())
rte_exit(EXIT_FAILURE, "Invalid port\n");
retval = rte_eth_dev_configure(portid, 1, 1, &port_conf);
if (retval != 0)
rte_exit(EXIT_FAILURE, "port %u: configuration failed (res=%d)\n",
portid, retval);
retval = rte_eth_dev_adjust_nb_rx_tx_desc(portid, &nb_rxd, &nb_txd);
if (retval != 0)
rte_exit(EXIT_FAILURE, "port %u: rte_eth_dev_adjust_nb_rx_tx_desc "
"failed (res=%d)\n", portid, retval);
/* RX setup */
retval = rte_eth_rx_queue_setup(portid, 0, nb_rxd,
rte_eth_dev_socket_id(portid), NULL,
mbuf_pool);
if (retval < 0)
rte_exit(retval, " port %u: RX queue 0 setup failed (res=%d)",
portid, retval);
/* TX setup */
retval = rte_eth_tx_queue_setup(portid, 0, nb_txd,
rte_eth_dev_socket_id(portid), NULL);
if (retval < 0)
rte_exit(retval, "port %u: TX queue 0 setup failed (res=%d)",
portid, retval);
retval = rte_eth_dev_start(portid);
if (retval < 0)
rte_exit(retval,
"Start port %d failed (res=%d)",
portid, retval);
struct ether_addr addr;
rte_eth_macaddr_get(portid, &addr);
printf("Port %u MAC: ", portid);
PRINT_MAC(addr);
printf("\n");
}
/*
* Initialises a given port using global settings and with the rx buffers
* coming from the mbuf_pool passed as parameter
*/
static inline int
port_init(uint8_t port, struct rte_mempool *mbuf_pool)
{
struct rte_eth_conf port_conf = port_conf_default;
const uint16_t rx_rings = 1, tx_rings = 1;
int retval;
uint16_t q;
if (port >= rte_eth_dev_count())
return -1;
retval = rte_eth_dev_configure(port, rx_rings, tx_rings, &port_conf);
if (retval != 0)
return retval;
for (q = 0; q < rx_rings; q++) {
retval = rte_eth_rx_queue_setup(port, q, RX_RING_SIZE,
rte_eth_dev_socket_id(port), NULL, mbuf_pool);
if (retval < 0)
return retval;
}
for (q = 0; q < tx_rings; q++) {
retval = rte_eth_tx_queue_setup(port, q, TX_RING_SIZE,
rte_eth_dev_socket_id(port), NULL);
if (retval < 0)
return retval;
}
retval = rte_eth_dev_start(port);
if (retval < 0)
return retval;
struct ether_addr addr;
rte_eth_macaddr_get(port, &addr);
printf("Port %u MAC: %02"PRIx8" %02"PRIx8" %02"PRIx8
" %02"PRIx8" %02"PRIx8" %02"PRIx8"\n",
(unsigned)port,
addr.addr_bytes[0], addr.addr_bytes[1],
addr.addr_bytes[2], addr.addr_bytes[3],
addr.addr_bytes[4], addr.addr_bytes[5]);
rte_eth_promiscuous_enable(port);
return 0;
}
static inline int
configure_eth_port(uint8_t port_id)
{
struct ether_addr addr;
const uint16_t rxRings = 1, txRings = 1;
const uint8_t nb_ports = rte_eth_dev_count();
int ret;
uint16_t q;
if (port_id > nb_ports)
return -1;
ret = rte_eth_dev_configure(port_id, rxRings, txRings, &port_conf_default);
if (ret != 0)
return ret;
for (q = 0; q < rxRings; q++) {
ret = rte_eth_rx_queue_setup(port_id, q, RX_DESC_PER_QUEUE,
rte_eth_dev_socket_id(port_id), NULL,
mbuf_pool);
if (ret < 0)
return ret;
}
for (q = 0; q < txRings; q++) {
ret = rte_eth_tx_queue_setup(port_id, q, TX_DESC_PER_QUEUE,
rte_eth_dev_socket_id(port_id), NULL);
if (ret < 0)
return ret;
}
ret = rte_eth_dev_start(port_id);
if (ret < 0)
return ret;
rte_eth_macaddr_get(port_id, &addr);
printf("Port %u MAC: %02"PRIx8" %02"PRIx8" %02"PRIx8
" %02"PRIx8" %02"PRIx8" %02"PRIx8"\n",
(unsigned)port_id,
addr.addr_bytes[0], addr.addr_bytes[1],
addr.addr_bytes[2], addr.addr_bytes[3],
addr.addr_bytes[4], addr.addr_bytes[5]);
rte_eth_promiscuous_enable(port_id);
return 0;
}
/*
* The lcore main. This is the main thread that does the work, reading from
* an input port and flooding in other ports.
*/
static __attribute__((noreturn)) void
lcore_main(void)
{
const uint8_t nb_ports = rte_eth_dev_count();
uint8_t port;
int i;
/*
* Check that the port is on the same NUMA node as the polling thread
* for best performance.
*/
for (port = 0; port < nb_ports; port++)
if (rte_eth_dev_socket_id(port) > 0 &&
rte_eth_dev_socket_id(port) !=
(int)rte_socket_id())
printf("WARNING, port %u is on remote NUMA node to "
"polling thread.\n\tPerformance will "
"not be optimal.\n", port);
printf("\nCore %u forwarding packets. [Ctrl+C to quit]\n",
rte_lcore_id());
/* Run until the application is quit or killed. */
for (;;) {
/*
* Receive packets on a port will be flooded in other ports
*/
for (port = 0; port < nb_ports; port++) {
/* Get burst of RX packets, from first port of pair. */
struct rte_mbuf *bufs[BURST_SIZE];
const uint16_t nb_rx = rte_eth_rx_burst(port, 0,
bufs, BURST_SIZE);
if (unlikely(nb_rx == 0))
continue;
for (i = 0; i < nb_rx; i++) {
/* rte_pktmbuf_dump(stdout, bufs[i], 16); */
flood_forward(bufs[i], port, nb_ports);
}
}
/* Send out packets from TX queues */
send_timeout_burst();
}
}
void configure_eth_port(uint8_t port_id)
{
int ret;
rte_eth_dev_stop(port_id);
ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf);
if (ret < 0)
rte_exit(EXIT_FAILURE, "Cannot configure port %u (error %d)\n",
(unsigned) port_id, ret);
/* Initialize the port's RX queue */
ret = rte_eth_rx_queue_setup(port_id, 0, RX_DESC_PER_QUEUE,
rte_eth_dev_socket_id(port_id),
NULL,
mbuf_pool);
if (ret < 0)
rte_exit(EXIT_FAILURE, "Failed to setup RX queue on "
"port %u (error %d)\n", (unsigned) port_id, ret);
/* Initialize the port's TX queue */
ret = rte_eth_tx_queue_setup(port_id, 0, TX_DESC_PER_QUEUE,
rte_eth_dev_socket_id(port_id),
NULL);
if (ret < 0)
rte_exit(EXIT_FAILURE, "Failed to setup TX queue on "
"port %u (error %d)\n", (unsigned) port_id, ret);
/* Initialize the port's flow control */
ret = rte_eth_dev_flow_ctrl_set(port_id, &fc_conf);
if (ret < 0)
rte_exit(EXIT_FAILURE, "Failed to setup hardware flow control on "
"port %u (error %d)\n", (unsigned) port_id, ret);
/* Start the port */
ret = rte_eth_dev_start(port_id);
if (ret < 0)
rte_exit(EXIT_FAILURE, "Failed to start port %u (error %d)\n",
(unsigned) port_id, ret);
/* Put it in promiscuous mode */
rte_eth_promiscuous_enable(port_id);
}
static void
configure_tx_buffer(uint8_t port_id, uint16_t size)
{
int ret;
/* Initialize TX buffers */
tx_buffer[port_id] = rte_zmalloc_socket("tx_buffer",
RTE_ETH_TX_BUFFER_SIZE(size), 0,
rte_eth_dev_socket_id(port_id));
if (tx_buffer[port_id] == NULL)
rte_exit(EXIT_FAILURE, "Cannot allocate buffer for tx on port %u\n",
(unsigned) port_id);
rte_eth_tx_buffer_init(tx_buffer[port_id], size);
ret = rte_eth_tx_buffer_set_err_callback(tx_buffer[port_id],
flush_tx_error_callback, (void *)(intptr_t)port_id);
if (ret < 0)
rte_exit(EXIT_FAILURE, "Cannot set error callback for "
"tx buffer on port %u\n", (unsigned) port_id);
}
static void
slave_port_init(uint16_t portid, struct rte_mempool *mbuf_pool)
{
int retval;
uint16_t nb_rxd = RTE_RX_DESC_DEFAULT;
uint16_t nb_txd = RTE_TX_DESC_DEFAULT;
struct rte_eth_dev_info dev_info;
struct rte_eth_rxconf rxq_conf;
struct rte_eth_txconf txq_conf;
struct rte_eth_conf local_port_conf = port_conf;
if (!rte_eth_dev_is_valid_port(portid))
rte_exit(EXIT_FAILURE, "Invalid port\n");
rte_eth_dev_info_get(portid, &dev_info);
if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MBUF_FAST_FREE)
local_port_conf.txmode.offloads |=
DEV_TX_OFFLOAD_MBUF_FAST_FREE;
local_port_conf.rx_adv_conf.rss_conf.rss_hf &=
dev_info.flow_type_rss_offloads;
if (local_port_conf.rx_adv_conf.rss_conf.rss_hf !=
port_conf.rx_adv_conf.rss_conf.rss_hf) {
printf("Port %u modified RSS hash function based on hardware support,"
"requested:%#"PRIx64" configured:%#"PRIx64"\n",
portid,
port_conf.rx_adv_conf.rss_conf.rss_hf,
local_port_conf.rx_adv_conf.rss_conf.rss_hf);
}
retval = rte_eth_dev_configure(portid, 1, 1, &local_port_conf);
if (retval != 0)
rte_exit(EXIT_FAILURE, "port %u: configuration failed (res=%d)\n",
portid, retval);
retval = rte_eth_dev_adjust_nb_rx_tx_desc(portid, &nb_rxd, &nb_txd);
if (retval != 0)
rte_exit(EXIT_FAILURE, "port %u: rte_eth_dev_adjust_nb_rx_tx_desc "
"failed (res=%d)\n", portid, retval);
/* RX setup */
rxq_conf = dev_info.default_rxconf;
rxq_conf.offloads = local_port_conf.rxmode.offloads;
retval = rte_eth_rx_queue_setup(portid, 0, nb_rxd,
rte_eth_dev_socket_id(portid),
&rxq_conf,
mbuf_pool);
if (retval < 0)
rte_exit(retval, " port %u: RX queue 0 setup failed (res=%d)",
portid, retval);
/* TX setup */
txq_conf = dev_info.default_txconf;
txq_conf.offloads = local_port_conf.txmode.offloads;
retval = rte_eth_tx_queue_setup(portid, 0, nb_txd,
rte_eth_dev_socket_id(portid), &txq_conf);
if (retval < 0)
rte_exit(retval, "port %u: TX queue 0 setup failed (res=%d)",
portid, retval);
retval = rte_eth_dev_start(portid);
if (retval < 0)
rte_exit(retval,
"Start port %d failed (res=%d)",
portid, retval);
struct ether_addr addr;
rte_eth_macaddr_get(portid, &addr);
printf("Port %u MAC: ", portid);
PRINT_MAC(addr);
printf("\n");
}
rw_piot_api_handle_t
rw_piot_open(char *device_name,
rw_piot_open_request_info_t *req_info,
rw_piot_open_response_info_t *rsp_info)
{
int n;
uint32_t i;
char *devname_split[2];
char *split_args[2];
char *dev_arg;
char received_name[RW_PIOT_DEVICE_NAME_LEN];
struct rte_eth_dev *eth_dev = NULL;
rw_piot_device_t *rw_piot_dev = NULL;
ASSERT(device_name);
ASSERT(req_info);
ASSERT(rsp_info);
if (NULL == device_name ||
NULL == req_info ||
NULL == rsp_info) {
/* failure */
return(0);
}
/*
* copy device name to a buffer, which can be give to split
*/
strncpy(received_name, device_name, sizeof(received_name));
/* parse the device name */
//printf("split %s\n", received_name);
n = rte_strsplit(received_name, strlen(received_name), devname_split, 2, ':');
if (n != 2) {
RW_PIOT_LOG(RTE_LOG_CRIT, "PIOT: rw_piot_open: split failed %s, %d\n", device_name, n);
return(0);
}
//printf("Token 1 %s Token 2 %s \n",devname_split[0], devname_split[1]);
/* check the device is already opened */
for (i=0; i<RWPIOT_MAX_DEVICES; i++) {
if (rw_piot_global_config.device[i].used) {
if (!strncmp(received_name, rw_piot_global_config.device[i].device_name, sizeof(rw_piot_global_config.device[i].device_name))) {
RW_PIOT_LOG(RTE_LOG_CRIT, "PIOT: rw_piot_open: failed, found already opened device\n");
return(0);
}
}
}
if (strcmp(devname_split[0], "eth_pcap")) {
/* if the device is not pcap, strip-off = and characters before */
n = rte_strsplit(devname_split[1], strlen(devname_split[1]), split_args, 2, '=');
if (n != 2) {
return 0;
}
dev_arg = split_args[1];
}
else {
dev_arg = devname_split[1];
}
for (i=0; i<NUM_SUPPORTED_DEVICETYPES; i++) {
if (!strncmp(rw_piot_devgroup[i].device_group_name, devname_split[0], 32)) {
char dev_inst_name[RW_PIOT_DEVICE_NAME_LEN];
sprintf(dev_inst_name, "%s%d",devname_split[0], rw_piot_devgroup[i].num_open_instances);
switch (rw_piot_devgroup[i].device_group_type) {
case PIOT_PCI: {
struct rte_pci_device *pci_dev;
//printf("pci address %s\n",dev_arg);
pci_dev = rte_eal_pci_probe_by_pci_addr(dev_arg);
if (pci_dev) {
eth_dev = rte_eth_dev_find_dev_by_pci(pci_dev);
if (eth_dev == NULL) {
RW_PIOT_LOG(RTE_LOG_CRIT, "PIOT: rw_piot_open: rte_eth_dev_find_dev_by_pci failed\n");
}
}
else {
RW_PIOT_LOG(RTE_LOG_CRIT, "PIOT: rw_piot_open: rte_eal_pci_probe_by_pci_addr failed\n");
}
}
break;
case PIOT_NON_PCI: {
req_info->dev_conf.intr_conf.lsc = 0;
//printf("Non-PCI %s %s\n", dev_inst_name, dev_arg);
if (!rte_eal_non_pci_ethdev_init_by_devname(devname_split[0],
dev_inst_name, dev_arg)) {
/*
* Caution - DIRTY Code here.
* Assumption is not to change DPDDK existing code, but can add new
* functions to DPDK.
* This is the only way to get the eth_dev for the init we have
* done here from dpdk
* This will be cleaned up later - TBD
*/
//printf("Non-PCI Init success\n");
eth_dev = rte_eth_dev_get_last_eth_dev(); /* Assume the last eth_dev is added for this case, BAD code, temporarily */
if (!eth_dev) {
RW_PIOT_LOG(RTE_LOG_CRIT, "PIOT: rw_piot_open: Non-PCI couldnot find ethdev\n");
}
}
}
break;
default:
break;
}
break;
}
}
if (eth_dev) {
rw_piot_dev = rw_piot_device_alloc(&rw_piot_devgroup[i]);
if (rw_piot_dev) {
rw_piot_dev->rte_port_id = eth_dev->data->port_id;
strncpy(rw_piot_dev->device_name, device_name, sizeof(rw_piot_dev->device_name));
if(rw_piot_config_device(rw_piot_dev, req_info, rsp_info) != 0) {
/* device config failed */
RW_PIOT_LOG(RTE_LOG_CRIT, "PIOT: rw_piot_open: Device config failed \n");
rw_piot_close(rw_piot_dev->piot_api_handle);
return(0);
}
rsp_info->NUMA_affinity = rte_eth_dev_socket_id( eth_dev->data->port_id);
return(rw_piot_dev->piot_api_handle);
}
else {
RW_PIOT_LOG(RTE_LOG_CRIT, "PIOT: rw_piot_open: rw_piot_device_alloc failed\n");
}
}
return(0);
}
static inline int
port_init_common(uint8_t port, const struct rte_eth_conf *port_conf,
struct rte_mempool *mp)
{
const uint16_t rx_ring_size = 512, tx_ring_size = 512;
int retval;
uint16_t q;
struct rte_eth_dev_info dev_info;
if (!rte_eth_dev_is_valid_port(port))
return -1;
retval = rte_eth_dev_configure(port, 0, 0, port_conf);
rte_eth_dev_info_get(port, &dev_info);
default_params.rx_rings = RTE_MIN(dev_info.max_rx_queues,
MAX_NUM_RX_QUEUE);
default_params.tx_rings = 1;
/* Configure the Ethernet device. */
retval = rte_eth_dev_configure(port, default_params.rx_rings,
default_params.tx_rings, port_conf);
if (retval != 0)
return retval;
for (q = 0; q < default_params.rx_rings; q++) {
retval = rte_eth_rx_queue_setup(port, q, rx_ring_size,
rte_eth_dev_socket_id(port), NULL, mp);
if (retval < 0)
return retval;
}
/* Allocate and set up 1 TX queue per Ethernet port. */
for (q = 0; q < default_params.tx_rings; q++) {
retval = rte_eth_tx_queue_setup(port, q, tx_ring_size,
rte_eth_dev_socket_id(port), NULL);
if (retval < 0)
return retval;
}
/* Start the Ethernet port. */
retval = rte_eth_dev_start(port);
if (retval < 0)
return retval;
/* Display the port MAC address. */
struct ether_addr addr;
rte_eth_macaddr_get(port, &addr);
printf("Port %u MAC: %02" PRIx8 " %02" PRIx8 " %02" PRIx8
" %02" PRIx8 " %02" PRIx8 " %02" PRIx8 "\n",
(unsigned int)port,
addr.addr_bytes[0], addr.addr_bytes[1],
addr.addr_bytes[2], addr.addr_bytes[3],
addr.addr_bytes[4], addr.addr_bytes[5]);
/* Enable RX in promiscuous mode for the Ethernet device. */
rte_eth_promiscuous_enable(port);
return 0;
}
static void
bond_port_init(struct rte_mempool *mbuf_pool)
{
int retval;
uint8_t i;
uint16_t nb_rxd = RTE_RX_DESC_DEFAULT;
uint16_t nb_txd = RTE_TX_DESC_DEFAULT;
struct rte_eth_dev_info dev_info;
struct rte_eth_rxconf rxq_conf;
struct rte_eth_txconf txq_conf;
struct rte_eth_conf local_port_conf = port_conf;
retval = rte_eth_bond_create("net_bonding0", BONDING_MODE_ALB,
0 /*SOCKET_ID_ANY*/);
if (retval < 0)
rte_exit(EXIT_FAILURE,
"Faled to create bond port\n");
BOND_PORT = retval;
rte_eth_dev_info_get(BOND_PORT, &dev_info);
if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MBUF_FAST_FREE)
local_port_conf.txmode.offloads |=
DEV_TX_OFFLOAD_MBUF_FAST_FREE;
retval = rte_eth_dev_configure(BOND_PORT, 1, 1, &local_port_conf);
if (retval != 0)
rte_exit(EXIT_FAILURE, "port %u: configuration failed (res=%d)\n",
BOND_PORT, retval);
retval = rte_eth_dev_adjust_nb_rx_tx_desc(BOND_PORT, &nb_rxd, &nb_txd);
if (retval != 0)
rte_exit(EXIT_FAILURE, "port %u: rte_eth_dev_adjust_nb_rx_tx_desc "
"failed (res=%d)\n", BOND_PORT, retval);
/* RX setup */
rxq_conf = dev_info.default_rxconf;
rxq_conf.offloads = local_port_conf.rxmode.offloads;
retval = rte_eth_rx_queue_setup(BOND_PORT, 0, nb_rxd,
rte_eth_dev_socket_id(BOND_PORT),
&rxq_conf, mbuf_pool);
if (retval < 0)
rte_exit(retval, " port %u: RX queue 0 setup failed (res=%d)",
BOND_PORT, retval);
/* TX setup */
txq_conf = dev_info.default_txconf;
txq_conf.offloads = local_port_conf.txmode.offloads;
retval = rte_eth_tx_queue_setup(BOND_PORT, 0, nb_txd,
rte_eth_dev_socket_id(BOND_PORT), &txq_conf);
if (retval < 0)
rte_exit(retval, "port %u: TX queue 0 setup failed (res=%d)",
BOND_PORT, retval);
for (i = 0; i < slaves_count; i++) {
if (rte_eth_bond_slave_add(BOND_PORT, slaves[i]) == -1)
rte_exit(-1, "Oooops! adding slave (%u) to bond (%u) failed!\n",
slaves[i], BOND_PORT);
}
retval = rte_eth_dev_start(BOND_PORT);
if (retval < 0)
rte_exit(retval, "Start port %d failed (res=%d)", BOND_PORT, retval);
rte_eth_promiscuous_enable(BOND_PORT);
struct ether_addr addr;
rte_eth_macaddr_get(BOND_PORT, &addr);
printf("Port %u MAC: ", (unsigned)BOND_PORT);
PRINT_MAC(addr);
printf("\n");
}
static inline int
ntuple_filter_add(uint8_t port, const char *addr, uint8_t queue_id)
{
int ret = 0;
uint32_t ntuple_ip_addr;
ret = inet_pton(AF_INET, addr, &ntuple_ip_addr);
if (ret <= 0) {
if (ret == 0) {
printf("Error: %s is not in presentation format\n", addr);
} else if (ret == -1) {
perror("inet_pton");
}
return ret;
}
struct rte_eth_ntuple_filter filter = {
.flags = RTE_5TUPLE_FLAGS,
.dst_ip = ntuple_ip_addr, /* Big endian */
.dst_ip_mask = UINT32_MAX, /* Enable */
.src_ip = 0,
.src_ip_mask = 0, /* Disable */
.dst_port = 0,
.dst_port_mask = 0, /* Disable */
.src_port = 0,
.src_port_mask = 0, /* Disable */
.proto = 0,
.proto_mask = 0, /* Disable */
.tcp_flags = 0,
.priority = 1, /* Lowest */
.queue = queue_id,
};
return rte_eth_dev_filter_ctrl(port,
RTE_ETH_FILTER_NTUPLE,
RTE_ETH_FILTER_ADD,
&filter);
}
/*
* Initialises a given port using global settings and with the rx buffers
* coming from the mbuf_pool passed as parameter
*/
static inline int
port_init(uint8_t port, struct rte_mempool *mbuf_pool)
{
port_conf_default.fdir_conf = fdir_conf;
struct rte_eth_conf port_conf = port_conf_default;
const uint16_t rx_rings = 1, tx_rings = 1;
int retval;
uint16_t q;
if (port >= rte_eth_dev_count())
return -1;
port_conf.rxmode.hw_vlan_strip = 0;
retval = rte_eth_dev_configure(port, rx_rings, tx_rings, &port_conf);
if (retval != 0)
return retval;
for (q = 0; q < rx_rings; q++) {
retval = rte_eth_rx_queue_setup(port, q, RX_RING_SIZE,
rte_eth_dev_socket_id(port), NULL, mbuf_pool);
if (retval < 0)
return retval;
}
for (q = 0; q < tx_rings; q++) {
retval = rte_eth_tx_queue_setup(port, q, TX_RING_SIZE,
rte_eth_dev_socket_id(port), NULL);
if (retval < 0)
return retval;
}
retval = rte_eth_dev_start(port);
if (retval < 0)
return retval;
struct ether_addr addr;
rte_eth_macaddr_get(port, &addr);
printf("Port %u MAC: %02"PRIx8" %02"PRIx8" %02"PRIx8
" %02"PRIx8" %02"PRIx8" %02"PRIx8"\n",
(unsigned)port,
addr.addr_bytes[0], addr.addr_bytes[1],
addr.addr_bytes[2], addr.addr_bytes[3],
addr.addr_bytes[4], addr.addr_bytes[5]);
rte_eth_promiscuous_enable(port);
return 0;
}
/*
* Initialize a given port using default settings and with the RX buffers
* coming from the mbuf_pool passed as a parameter.
* FIXME: Starting with assumption of one thread/core per port
*/
static inline int uhd_dpdk_port_init(struct uhd_dpdk_port *port,
struct rte_mempool *rx_mbuf_pool,
unsigned int mtu)
{
int retval;
/* Check for a valid port */
if (port->id >= rte_eth_dev_count())
return -ENODEV;
/* Set up Ethernet device with defaults (1 RX ring, 1 TX ring) */
/* FIXME: Check if hw_ip_checksum is possible */
struct rte_eth_conf port_conf = {
.rxmode = {
.max_rx_pkt_len = mtu,
.jumbo_frame = 1,
.hw_ip_checksum = 1,
}
};
retval = rte_eth_dev_configure(port->id, 1, 1, &port_conf);
if (retval != 0)
return retval;
retval = rte_eth_rx_queue_setup(port->id, 0, DEFAULT_RING_SIZE,
rte_eth_dev_socket_id(port->id), NULL, rx_mbuf_pool);
if (retval < 0)
return retval;
retval = rte_eth_tx_queue_setup(port->id, 0, DEFAULT_RING_SIZE,
rte_eth_dev_socket_id(port->id), NULL);
if (retval < 0)
goto port_init_fail;
/* Create the hash table for the RX sockets */
char name[32];
snprintf(name, sizeof(name), "rx_table_%u", port->id);
struct rte_hash_parameters hash_params = {
.name = name,
.entries = UHD_DPDK_MAX_SOCKET_CNT,
.key_len = sizeof(struct uhd_dpdk_ipv4_5tuple),
.hash_func = NULL,
.hash_func_init_val = 0,
};
port->rx_table = rte_hash_create(&hash_params);
if (port->rx_table == NULL) {
retval = rte_errno;
goto port_init_fail;
}
/* Create ARP table */
snprintf(name, sizeof(name), "arp_table_%u", port->id);
hash_params.name = name;
hash_params.entries = UHD_DPDK_MAX_SOCKET_CNT;
hash_params.key_len = sizeof(uint32_t);
hash_params.hash_func = NULL;
hash_params.hash_func_init_val = 0;
port->arp_table = rte_hash_create(&hash_params);
if (port->arp_table == NULL) {
retval = rte_errno;
goto free_rx_table;
}
/* Set up list for TX queues */
LIST_INIT(&port->txq_list);
/* Start the Ethernet port. */
retval = rte_eth_dev_start(port->id);
if (retval < 0) {
goto free_arp_table;
}
/* Display the port MAC address. */
rte_eth_macaddr_get(port->id, &port->mac_addr);
RTE_LOG(INFO, EAL, "Port %u MAC: %02x %02x %02x %02x %02x %02x\n",
(unsigned)port->id,
port->mac_addr.addr_bytes[0], port->mac_addr.addr_bytes[1],
port->mac_addr.addr_bytes[2], port->mac_addr.addr_bytes[3],
port->mac_addr.addr_bytes[4], port->mac_addr.addr_bytes[5]);
struct rte_eth_link link;
rte_eth_link_get(port->id, &link);
RTE_LOG(INFO, EAL, "Port %u UP: %d\n", port->id, link.link_status);
return 0;
free_arp_table:
rte_hash_free(port->arp_table);
free_rx_table:
rte_hash_free(port->rx_table);
port_init_fail:
return rte_errno;
}
static int uhd_dpdk_thread_init(struct uhd_dpdk_thread *thread, unsigned int id)
{
if (!ctx || !thread)
return -EINVAL;
unsigned int socket_id = rte_lcore_to_socket_id(id);
thread->id = id;
thread->rx_pktbuf_pool = ctx->rx_pktbuf_pools[socket_id];
thread->tx_pktbuf_pool = ctx->tx_pktbuf_pools[socket_id];
LIST_INIT(&thread->port_list);
char name[32];
snprintf(name, sizeof(name), "sockreq_ring_%u", id);
thread->sock_req_ring = rte_ring_create(
name,
UHD_DPDK_MAX_PENDING_SOCK_REQS,
socket_id,
RING_F_SC_DEQ
);
if (!thread->sock_req_ring)
return -ENOMEM;
return 0;
}
int uhd_dpdk_init(int argc, char **argv, unsigned int num_ports,
int *port_thread_mapping, int num_mbufs, int mbuf_cache_size,
int mtu)
{
/* Init context only once */
if (ctx)
return 1;
if ((num_ports == 0) || (port_thread_mapping == NULL)) {
return -EINVAL;
}
/* Grabs arguments intended for DPDK's EAL */
int ret = rte_eal_init(argc, argv);
if (ret < 0)
rte_exit(EXIT_FAILURE, "Error with EAL initialization\n");
ctx = (struct uhd_dpdk_ctx *) rte_zmalloc("uhd_dpdk_ctx", sizeof(*ctx), rte_socket_id());
if (!ctx)
return -ENOMEM;
ctx->num_threads = rte_lcore_count();
if (ctx->num_threads <= 1)
rte_exit(EXIT_FAILURE, "Error: No worker threads enabled\n");
/* Check that we have ports to send/receive on */
ctx->num_ports = rte_eth_dev_count();
if (ctx->num_ports < 1)
rte_exit(EXIT_FAILURE, "Error: Found no ports\n");
if (ctx->num_ports < num_ports)
rte_exit(EXIT_FAILURE, "Error: User requested more ports than available\n");
/* Get memory for thread and port data structures */
ctx->threads = rte_zmalloc("uhd_dpdk_thread", RTE_MAX_LCORE*sizeof(struct uhd_dpdk_thread), 0);
if (!ctx->threads)
rte_exit(EXIT_FAILURE, "Error: Could not allocate memory for thread data\n");
ctx->ports = rte_zmalloc("uhd_dpdk_port", ctx->num_ports*sizeof(struct uhd_dpdk_port), 0);
if (!ctx->ports)
rte_exit(EXIT_FAILURE, "Error: Could not allocate memory for port data\n");
/* Initialize the thread data structures */
for (int i = rte_get_next_lcore(-1, 1, 0);
(i < RTE_MAX_LCORE);
i = rte_get_next_lcore(i, 1, 0))
{
/* Do one mempool of RX/TX per socket */
unsigned int socket_id = rte_lcore_to_socket_id(i);
/* FIXME Probably want to take into account actual number of ports per socket */
if (ctx->tx_pktbuf_pools[socket_id] == NULL) {
/* Creates a new mempool in memory to hold the mbufs.
* This is done for each CPU socket
*/
const int mbuf_size = mtu + 2048 + RTE_PKTMBUF_HEADROOM;
char name[32];
snprintf(name, sizeof(name), "rx_mbuf_pool_%u", socket_id);
ctx->rx_pktbuf_pools[socket_id] = rte_pktmbuf_pool_create(
name,
ctx->num_ports*num_mbufs,
mbuf_cache_size,
0,
mbuf_size,
socket_id
);
snprintf(name, sizeof(name), "tx_mbuf_pool_%u", socket_id);
ctx->tx_pktbuf_pools[socket_id] = rte_pktmbuf_pool_create(
name,
ctx->num_ports*num_mbufs,
mbuf_cache_size,
0,
mbuf_size,
socket_id
);
if ((ctx->rx_pktbuf_pools[socket_id]== NULL) ||
(ctx->tx_pktbuf_pools[socket_id]== NULL))
rte_exit(EXIT_FAILURE, "Cannot create mbuf pool\n");
}
if (uhd_dpdk_thread_init(&ctx->threads[i], i) < 0)
rte_exit(EXIT_FAILURE, "Error initializing thread %i\n", i);
}
unsigned master_lcore = rte_get_master_lcore();
/* Assign ports to threads and initialize the port data structures */
for (unsigned int i = 0; i < num_ports; i++) {
int thread_id = port_thread_mapping[i];
if (thread_id < 0)
continue;
if (((unsigned int) thread_id) == master_lcore)
RTE_LOG(WARNING, EAL, "User requested master lcore for port %u\n", i);
if (ctx->threads[thread_id].id != (unsigned int) thread_id)
rte_exit(EXIT_FAILURE, "Requested inactive lcore %u for port %u\n", (unsigned int) thread_id, i);
struct uhd_dpdk_port *port = &ctx->ports[i];
port->id = i;
port->parent = &ctx->threads[thread_id];
ctx->threads[thread_id].num_ports++;
LIST_INSERT_HEAD(&ctx->threads[thread_id].port_list, port, port_entry);
/* Initialize port. */
if (uhd_dpdk_port_init(port, port->parent->rx_pktbuf_pool, mtu) != 0)
rte_exit(EXIT_FAILURE, "Cannot init port %"PRIu8 "\n",
i);
}
RTE_LOG(INFO, EAL, "Init DONE!\n");
/* FIXME: Create functions to do this */
RTE_LOG(INFO, EAL, "Starting I/O threads!\n");
for (int i = rte_get_next_lcore(-1, 1, 0);
(i < RTE_MAX_LCORE);
i = rte_get_next_lcore(i, 1, 0))
{
struct uhd_dpdk_thread *t = &ctx->threads[i];
if (!LIST_EMPTY(&t->port_list)) {
rte_eal_remote_launch(_uhd_dpdk_driver_main, NULL, ctx->threads[i].id);
}
}
return 0;
}
/* FIXME: This will be changed once we have functions to handle the threads */
int uhd_dpdk_destroy(void)
{
if (!ctx)
return -ENODEV;
struct uhd_dpdk_config_req *req = (struct uhd_dpdk_config_req *) rte_zmalloc(NULL, sizeof(*req), 0);
if (!req)
return -ENOMEM;
req->req_type = UHD_DPDK_LCORE_TERM;
for (int i = rte_get_next_lcore(-1, 1, 0);
(i < RTE_MAX_LCORE);
i = rte_get_next_lcore(i, 1, 0))
{
struct uhd_dpdk_thread *t = &ctx->threads[i];
if (LIST_EMPTY(&t->port_list))
continue;
if (rte_eal_get_lcore_state(t->id) == FINISHED)
continue;
pthread_mutex_init(&req->mutex, NULL);
pthread_cond_init(&req->cond, NULL);
pthread_mutex_lock(&req->mutex);
if (rte_ring_enqueue(t->sock_req_ring, req)) {
pthread_mutex_unlock(&req->mutex);
RTE_LOG(ERR, USER2, "Failed to terminate thread %d\n", i);
rte_free(req);
return -ENOSPC;
}
struct timespec timeout = {
.tv_sec = 1,
.tv_nsec = 0
};
pthread_cond_timedwait(&req->cond, &req->mutex, &timeout);
pthread_mutex_unlock(&req->mutex);
}
rte_free(req);
return 0;
}
int
main(int argc, char **argv)
{
//struct lcore_queue_conf *qconf = NULL;
//struct rte_eth_dev_info dev_info;
struct lcore_env** envs;
int ret;
uint8_t n_ports;
unsigned lcore_count;
ret = rte_eal_init(argc, argv);
if (ret < 0)
rte_exit(EXIT_FAILURE, "Invalid EAL arguments\n");
argc -= ret;
argv += ret;
ret = l2sw_parse_args(argc, argv);
if (ret < 0)
rte_exit(EXIT_FAILURE, "Invalid MARIO arguments\n");
lcore_count = rte_lcore_count();
n_ports = rte_eth_dev_count();
//RTE_LOG(INFO, MARIO, "Find %u logical cores\n" , lcore_count);
mbuf_pool = rte_mempool_create("mbuf_pool", NB_MBUF, MBUF_SIZE,
32, sizeof(struct rte_pktmbuf_pool_private),
rte_pktmbuf_pool_init, NULL,
rte_pktmbuf_init, NULL,
rte_socket_id(), 0);
if (mbuf_pool == NULL)
rte_exit(EXIT_FAILURE, "Cannot init mbuf pool\n");
// init route_table
route_table = create_route_table(ROUTE_ENTRY_SIZE);
add_staticroute(route_table);
// init arp_table
arp_table = create_arp_table(ARP_ENTRY_SIZE);
n_ports = rte_eth_dev_count();
if (n_ports == 0)
rte_exit(EXIT_FAILURE, "No Ethernet ports - byte\n");
//RTE_LOG(INFO, MARIO, "Find %u ethernet ports\n", n_ports);
if (n_ports > RTE_MAX_ETHPORTS)
n_ports = RTE_MAX_ETHPORTS;
/* Each logical core is assigned a dedicated TX queue on each port. */
/*
for(uint8_t port_id = 0; port_id < n_ports; port_id++) {
rte_eth_dev_info_get(port_id, &dev_info);
}
*/
/* Initialize the port/queue configuration of each logical core */
/*
for(uint8_t port_id = 0; port_id < n_ports; port_id++) {
;
}
*/
/* Initialize lcore_env */
envs = (struct lcore_env**) rte_malloc(NULL,sizeof(struct lcore_env*),0);
if (envs == NULL)
rte_exit(EXIT_FAILURE, "Cannot allocate memory for core envs\n");
uint8_t lcore_id;
for (lcore_id = 0; lcore_id < lcore_count; lcore_id++) {
struct lcore_env* env;
env = (struct lcore_env*) rte_malloc(NULL,sizeof(struct lcore_env) +
sizeof(struct mbuf_table) *n_ports,0);
if (env == NULL)
rte_exit(EXIT_FAILURE,
"Cannot allocate memory for %u core env\n", lcore_id);
env->n_port = n_ports;
env->lcore_id = lcore_id;
memset(env->tx_mbufs, 0, sizeof(struct mbuf_table) * n_ports);
envs[lcore_id] = env;
}
/* Initialise each port */
uint8_t port_id;
for(port_id = 0; port_id < n_ports; port_id++) {
//RTE_LOG(INFO, MARIO, "Initializing port %u...", port_id);
fflush(stdout);
ret = rte_eth_dev_configure(port_id, lcore_count, lcore_count, &port_conf);
if (ret < 0)
rte_exit(EXIT_FAILURE, "Cannot configure device: err=%d, port=%u\n",
ret, (unsigned)port_id);
//RTE_LOG(INFO, MARIO, "done\n");
rte_eth_macaddr_get(port_id, &port2eth[port_id]);
/* init one RX queue */
uint8_t core_id;
for (core_id = 0; core_id < lcore_count; core_id++) {
ret = rte_eth_rx_queue_setup(port_id, core_id, nb_rxd,
rte_eth_dev_socket_id(port_id),
NULL,
mbuf_pool);
if (ret < 0)
rte_exit(EXIT_FAILURE,
"rte_eth_rx_queue_setup:err=%d, port=%u queue=%u\n",
ret, (unsigned) port_id, (unsigned) core_id);
}
/* init one TX queue */
for (core_id = 0; core_id < lcore_count; core_id++) {
ret = rte_eth_tx_queue_setup(port_id, core_id, nb_txd,
rte_eth_dev_socket_id(port_id), NULL);
if (ret < 0)
rte_exit(EXIT_FAILURE,
"rte_eth_tx_queue_setup:err=%d, port=%u queue=%u\n",
ret, (unsigned) port_id, (unsigned) core_id);
}
/* Start device */
ret = rte_eth_dev_start(port_id);
if (ret < 0)
rte_exit(EXIT_FAILURE, "rte_eth_dev_start:err=%d, port=%u\n",
ret, (unsigned) port_id);
rte_eth_promiscuous_enable(port_id);
/*RTE_LOG(INFO, MARIO,
"Port %u, MAC address %02x:%02x:%02x:%02x:%02x:%02x\n\n",
port_id,
port2eth[port_id].addr_bytes[0],
port2eth[port_id].addr_bytes[1],
port2eth[port_id].addr_bytes[2],
port2eth[port_id].addr_bytes[3],
port2eth[port_id].addr_bytes[4],
port2eth[port_id].addr_bytes[5]);
*/
memset(&port_statistics, 0, sizeof(port_statistics));
}
check_all_ports_link_status(n_ports);
/* launch per-lcore init on every lcore */
rte_eal_mp_remote_launch(l2sw_launch_one_lcore, envs, CALL_MASTER);
{
uint8_t lcore_id;
RTE_LCORE_FOREACH_SLAVE(lcore_id) {
if (rte_eal_wait_lcore(lcore_id) < 0)
return -1;
}
}
rte_free(arp_table);
rte_free(route_table);
return 0;
}
/*
* Initialises a given port using global settings and with the rx buffers
* coming from the mbuf_pool passed as parameter
*/
static inline int
port_init(uint16_t port, struct rte_mempool *mbuf_pool)
{
struct rte_eth_dev_info dev_info;
struct rte_eth_conf port_conf = {0};
uint16_t rxRingSize = RTE_TEST_RX_DESC_DEFAULT;
uint16_t txRingSize = RTE_TEST_TX_DESC_DEFAULT;
int retval;
uint16_t q;
uint16_t queues_per_pool;
uint32_t max_nb_pools;
/*
* The max pool number from dev_info will be used to validate the pool
* number specified in cmd line
*/
rte_eth_dev_info_get(port, &dev_info);
max_nb_pools = (uint32_t)dev_info.max_vmdq_pools;
/*
* We allow to process part of VMDQ pools specified by num_pools in
* command line.
*/
if (num_pools > max_nb_pools) {
printf("num_pools %d >max_nb_pools %d\n",
num_pools, max_nb_pools);
return -1;
}
/*
* NIC queues are divided into pf queues and vmdq queues.
* There is assumption here all ports have the same configuration!
*/
vmdq_queue_base = dev_info.vmdq_queue_base;
vmdq_pool_base = dev_info.vmdq_pool_base;
printf("vmdq queue base: %d pool base %d\n",
vmdq_queue_base, vmdq_pool_base);
if (vmdq_pool_base == 0) {
num_vmdq_queues = dev_info.max_rx_queues;
num_queues = dev_info.max_rx_queues;
if (num_tcs != num_vmdq_queues / num_pools) {
printf("nb_tcs %d is invalid considering with"
" nb_pools %d, nb_tcs * nb_pools should = %d\n",
num_tcs, num_pools, num_vmdq_queues);
return -1;
}
} else {
queues_per_pool = dev_info.vmdq_queue_num /
dev_info.max_vmdq_pools;
if (num_tcs > queues_per_pool) {
printf("num_tcs %d > num of queues per pool %d\n",
num_tcs, queues_per_pool);
return -1;
}
num_vmdq_queues = num_pools * queues_per_pool;
num_queues = vmdq_queue_base + num_vmdq_queues;
printf("Configured vmdq pool num: %u,"
" each vmdq pool has %u queues\n",
num_pools, queues_per_pool);
}
if (port >= rte_eth_dev_count())
return -1;
retval = get_eth_conf(&port_conf);
if (retval < 0)
return retval;
/*
* Though in this example, all queues including pf queues are setup.
* This is because VMDQ queues doesn't always start from zero, and the
* PMD layer doesn't support selectively initialising part of rx/tx
* queues.
*/
retval = rte_eth_dev_configure(port, num_queues, num_queues, &port_conf);
if (retval != 0)
return retval;
retval = rte_eth_dev_adjust_nb_rx_tx_desc(port, &rxRingSize,
&txRingSize);
if (retval != 0)
return retval;
if (RTE_MAX(rxRingSize, txRingSize) >
RTE_MAX(RTE_TEST_RX_DESC_DEFAULT, RTE_TEST_TX_DESC_DEFAULT)) {
printf("Mbuf pool has an insufficient size for port %u.\n",
port);
return -1;
}
for (q = 0; q < num_queues; q++) {
retval = rte_eth_rx_queue_setup(port, q, rxRingSize,
rte_eth_dev_socket_id(port),
NULL,
mbuf_pool);
if (retval < 0) {
printf("initialize rx queue %d failed\n", q);
return retval;
}
}
for (q = 0; q < num_queues; q++) {
retval = rte_eth_tx_queue_setup(port, q, txRingSize,
rte_eth_dev_socket_id(port),
NULL);
if (retval < 0) {
printf("initialize tx queue %d failed\n", q);
return retval;
}
}
retval = rte_eth_dev_start(port);
if (retval < 0) {
printf("port %d start failed\n", port);
return retval;
}
rte_eth_macaddr_get(port, &vmdq_ports_eth_addr[port]);
printf("Port %u MAC: %02"PRIx8" %02"PRIx8" %02"PRIx8
" %02"PRIx8" %02"PRIx8" %02"PRIx8"\n",
(unsigned)port,
vmdq_ports_eth_addr[port].addr_bytes[0],
vmdq_ports_eth_addr[port].addr_bytes[1],
vmdq_ports_eth_addr[port].addr_bytes[2],
vmdq_ports_eth_addr[port].addr_bytes[3],
vmdq_ports_eth_addr[port].addr_bytes[4],
vmdq_ports_eth_addr[port].addr_bytes[5]);
/* Set mac for each pool.*/
for (q = 0; q < num_pools; q++) {
struct ether_addr mac;
mac = pool_addr_template;
mac.addr_bytes[4] = port;
mac.addr_bytes[5] = q;
printf("Port %u vmdq pool %u set mac %02x:%02x:%02x:%02x:%02x:%02x\n",
port, q,
mac.addr_bytes[0], mac.addr_bytes[1],
mac.addr_bytes[2], mac.addr_bytes[3],
mac.addr_bytes[4], mac.addr_bytes[5]);
retval = rte_eth_dev_mac_addr_add(port, &mac,
q + vmdq_pool_base);
if (retval) {
printf("mac addr add failed at pool %d\n", q);
return retval;
}
}
return 0;
}
/**
* Initialises a given port using global settings and with the rx buffers
* coming from the mbuf_pool passed as parameter
*/
int
vxlan_port_init(uint8_t port, struct rte_mempool *mbuf_pool)
{
int retval;
uint16_t q;
struct rte_eth_dev_info dev_info;
uint16_t rx_rings, tx_rings = (uint16_t)rte_lcore_count();
const uint16_t rx_ring_size = RTE_TEST_RX_DESC_DEFAULT;
const uint16_t tx_ring_size = RTE_TEST_TX_DESC_DEFAULT;
struct rte_eth_udp_tunnel tunnel_udp;
struct rte_eth_rxconf *rxconf;
struct rte_eth_txconf *txconf;
struct vxlan_conf *pconf = &vxdev;
pconf->dst_port = udp_port;
rte_eth_dev_info_get(port, &dev_info);
if (dev_info.max_rx_queues > MAX_QUEUES) {
rte_exit(EXIT_FAILURE,
"please define MAX_QUEUES no less than %u in %s\n",
dev_info.max_rx_queues, __FILE__);
}
rxconf = &dev_info.default_rxconf;
txconf = &dev_info.default_txconf;
txconf->txq_flags = 0;
if (port >= rte_eth_dev_count())
return -1;
rx_rings = nb_devices;
/* Configure ethernet device. */
retval = rte_eth_dev_configure(port, rx_rings, tx_rings, &port_conf);
if (retval != 0)
return retval;
/* Setup the queues. */
for (q = 0; q < rx_rings; q++) {
retval = rte_eth_rx_queue_setup(port, q, rx_ring_size,
rte_eth_dev_socket_id(port),
rxconf,
mbuf_pool);
if (retval < 0)
return retval;
}
for (q = 0; q < tx_rings; q++) {
retval = rte_eth_tx_queue_setup(port, q, tx_ring_size,
rte_eth_dev_socket_id(port),
txconf);
if (retval < 0)
return retval;
}
/* Start the device. */
retval = rte_eth_dev_start(port);
if (retval < 0)
return retval;
/* Configure UDP port for UDP tunneling */
tunnel_udp.udp_port = udp_port;
tunnel_udp.prot_type = RTE_TUNNEL_TYPE_VXLAN;
retval = rte_eth_dev_udp_tunnel_port_add(port, &tunnel_udp);
if (retval < 0)
return retval;
rte_eth_macaddr_get(port, &ports_eth_addr[port]);
RTE_LOG(INFO, PORT, "Port %u MAC: %02"PRIx8" %02"PRIx8" %02"PRIx8
" %02"PRIx8" %02"PRIx8" %02"PRIx8"\n",
(unsigned)port,
ports_eth_addr[port].addr_bytes[0],
ports_eth_addr[port].addr_bytes[1],
ports_eth_addr[port].addr_bytes[2],
ports_eth_addr[port].addr_bytes[3],
ports_eth_addr[port].addr_bytes[4],
ports_eth_addr[port].addr_bytes[5]);
if (tso_segsz != 0) {
struct rte_eth_dev_info dev_info;
rte_eth_dev_info_get(port, &dev_info);
if ((dev_info.tx_offload_capa & DEV_TX_OFFLOAD_TCP_TSO) == 0)
RTE_LOG(WARNING, PORT,
"hardware TSO offload is not supported\n");
}
return 0;
}
/*
* Initialises a given port using global settings and with the rx buffers
* coming from the mbuf_pool passed as parameter
*/
static inline int
port_init(uint8_t port, struct rte_mempool *mbuf_pool)
{
struct rte_eth_dev_info dev_info;
struct rte_eth_conf port_conf;
uint16_t rx_rings, tx_rings = (uint16_t)rte_lcore_count();
const uint16_t rx_ring_size = RTE_TEST_RX_DESC_DEFAULT, tx_ring_size = RTE_TEST_TX_DESC_DEFAULT;
int retval;
uint16_t q;
/* The max pool number from dev_info will be used to validate the pool number specified in cmd line */
rte_eth_dev_info_get (port, &dev_info);
/*configure the number of supported virtio devices based on VMDQ limits */
num_devices = dev_info.max_vmdq_pools;
num_queues = dev_info.max_rx_queues;
retval = validate_num_devices(MAX_DEVICES);
if (retval < 0)
return retval;
/* Get port configuration. */
retval = get_eth_conf(&port_conf, num_devices);
if (retval < 0)
return retval;
if (port >= rte_eth_dev_count()) return -1;
rx_rings = (uint16_t)num_queues,
/* Configure ethernet device. */
retval = rte_eth_dev_configure(port, rx_rings, tx_rings, &port_conf);
if (retval != 0)
return retval;
/* Setup the queues. */
for (q = 0; q < rx_rings; q ++) {
retval = rte_eth_rx_queue_setup(port, q, rx_ring_size,
rte_eth_dev_socket_id(port), &rx_conf_default,
mbuf_pool);
if (retval < 0)
return retval;
}
for (q = 0; q < tx_rings; q ++) {
retval = rte_eth_tx_queue_setup(port, q, tx_ring_size,
rte_eth_dev_socket_id(port), &tx_conf_default);
if (retval < 0)
return retval;
}
/* Start the device. */
retval = rte_eth_dev_start(port);
if (retval < 0)
return retval;
rte_eth_macaddr_get(port, &vmdq_ports_eth_addr[port]);
RTE_LOG(INFO, VHOST_PORT, "Max virtio devices supported: %u\n", num_devices);
RTE_LOG(INFO, VHOST_PORT, "Port %u MAC: %02"PRIx8" %02"PRIx8" %02"PRIx8
" %02"PRIx8" %02"PRIx8" %02"PRIx8"\n",
(unsigned)port,
vmdq_ports_eth_addr[port].addr_bytes[0],
vmdq_ports_eth_addr[port].addr_bytes[1],
vmdq_ports_eth_addr[port].addr_bytes[2],
vmdq_ports_eth_addr[port].addr_bytes[3],
vmdq_ports_eth_addr[port].addr_bytes[4],
vmdq_ports_eth_addr[port].addr_bytes[5]);
return 0;
}
static int
paxos_rx_process(struct rte_mbuf *pkt, struct proposer* proposer)
{
int ret = 0;
uint8_t l4_proto = 0;
uint16_t outer_header_len;
union tunnel_offload_info info = { .data = 0 };
struct udp_hdr *udp_hdr;
struct paxos_hdr *paxos_hdr;
struct ether_hdr *phdr = rte_pktmbuf_mtod(pkt, struct ether_hdr *);
parse_ethernet(phdr, &info, &l4_proto);
if (l4_proto != IPPROTO_UDP)
return -1;
udp_hdr = (struct udp_hdr *)((char *)phdr +
info.outer_l2_len + info.outer_l3_len);
/* if UDP dst port is not either PROPOSER or LEARNER port */
if (!(udp_hdr->dst_port == rte_cpu_to_be_16(PROPOSER_PORT) ||
udp_hdr->dst_port == rte_cpu_to_be_16(LEARNER_PORT)) &&
(pkt->packet_type & RTE_PTYPE_TUNNEL_MASK) == 0)
return -1;
paxos_hdr = (struct paxos_hdr *)((char *)udp_hdr + sizeof(struct udp_hdr));
if (rte_get_log_level() == RTE_LOG_DEBUG) {
//rte_hexdump(stdout, "udp", udp_hdr, sizeof(struct udp_hdr));
//rte_hexdump(stdout, "paxos", paxos_hdr, sizeof(struct paxos_hdr));
print_paxos_hdr(paxos_hdr);
}
int value_len = rte_be_to_cpu_16(paxos_hdr->value_len);
struct paxos_value *v = paxos_value_new((char *)paxos_hdr->paxosval, value_len);
switch(rte_be_to_cpu_16(paxos_hdr->msgtype)) {
case PAXOS_PROMISE: {
struct paxos_promise promise = {
.iid = rte_be_to_cpu_32(paxos_hdr->inst),
.ballot = rte_be_to_cpu_16(paxos_hdr->rnd),
.value_ballot = rte_be_to_cpu_16(paxos_hdr->vrnd),
.aid = rte_be_to_cpu_16(paxos_hdr->acptid),
.value = *v
};
proposer_handle_promise(proposer, &promise);
break;
}
case PAXOS_ACCEPT: {
if (first_time) {
proposer_preexecute(proposer);
first_time = false;
}
struct paxos_accept acpt = {
.iid = rte_be_to_cpu_32(paxos_hdr->inst),
.ballot = rte_be_to_cpu_16(paxos_hdr->rnd),
.value_ballot = rte_be_to_cpu_16(paxos_hdr->vrnd),
.aid = rte_be_to_cpu_16(paxos_hdr->acptid),
.value = *v
};
proposer_handle_accept(proposer, &acpt);
break;
}
case PAXOS_ACCEPTED: {
struct paxos_accepted ack = {
.iid = rte_be_to_cpu_32(paxos_hdr->inst),
.ballot = rte_be_to_cpu_16(paxos_hdr->rnd),
.value_ballot = rte_be_to_cpu_16(paxos_hdr->vrnd),
.aid = rte_be_to_cpu_16(paxos_hdr->acptid),
.value = *v
};
proposer_handle_accepted(proposer, &ack);
break;
}
default:
break;
}
outer_header_len = info.outer_l2_len + info.outer_l3_len
+ sizeof(struct udp_hdr) + sizeof(struct paxos_hdr);
rte_pktmbuf_adj(pkt, outer_header_len);
return ret;
}
static uint16_t
add_timestamps(uint8_t port __rte_unused, uint16_t qidx __rte_unused,
struct rte_mbuf **pkts, uint16_t nb_pkts,
uint16_t max_pkts __rte_unused, void *user_param)
{
struct proposer* proposer = (struct proposer *)user_param;
unsigned i;
uint64_t now = rte_rdtsc();
for (i = 0; i < nb_pkts; i++) {
pkts[i]->udata64 = now;
paxos_rx_process(pkts[i], proposer);
}
return nb_pkts;
}
static inline int
port_init(uint8_t port, struct rte_mempool *mbuf_pool, struct proposer* proposer)
{
struct rte_eth_dev_info dev_info;
struct rte_eth_txconf *txconf;
struct rte_eth_rxconf *rxconf;
struct rte_eth_conf port_conf = port_conf_default;
const uint16_t rx_rings = 1, tx_rings = 1;
int retval;
uint16_t q;
rte_eth_dev_info_get(port, &dev_info);
rxconf = &dev_info.default_rxconf;
txconf = &dev_info.default_txconf;
txconf->txq_flags &= PKT_TX_IPV4;
txconf->txq_flags &= PKT_TX_UDP_CKSUM;
if (port >= rte_eth_dev_count())
return -1;
retval = rte_eth_dev_configure(port, rx_rings, tx_rings, &port_conf);
if (retval != 0)
return retval;
for (q = 0; q < rx_rings; q++) {
retval = rte_eth_rx_queue_setup(port, q, RX_RING_SIZE,
rte_eth_dev_socket_id(port), rxconf, mbuf_pool);
if (retval < 0)
return retval;
}
for (q = 0; q < tx_rings; q++) {
retval = rte_eth_tx_queue_setup(port, q, TX_RING_SIZE,
rte_eth_dev_socket_id(port), txconf);
if (retval < 0)
return retval;
}
retval = rte_eth_dev_start(port);
if (retval < 0)
return retval;
struct ether_addr addr;
rte_eth_macaddr_get(port, &addr);
rte_eth_promiscuous_enable(port);
rte_eth_add_rx_callback(port, 0, add_timestamps, proposer);
rte_eth_add_tx_callback(port, 0, calc_latency, NULL);
return 0;
}
static void
lcore_main(uint8_t port, __rte_unused struct proposer *p)
{
proposer_preexecute(p);
for (;;) {
// Check if signal is received
if (force_quit)
break;
struct rte_mbuf *bufs[BURST_SIZE];
const uint16_t nb_rx = rte_eth_rx_burst(port, 0, bufs, BURST_SIZE);
if (unlikely(nb_rx == 0))
continue;
uint16_t buf;
for (buf = 0; buf < nb_rx; buf++)
rte_pktmbuf_free(bufs[buf]);
}
}
static __attribute__((noreturn)) int
lcore_mainloop(__attribute__((unused)) void *arg)
{
uint64_t prev_tsc = 0, cur_tsc, diff_tsc;
unsigned lcore_id;
lcore_id = rte_lcore_id();
rte_log(RTE_LOG_DEBUG, RTE_LOGTYPE_TIMER,
"Starting mainloop on core %u\n", lcore_id);
while(1) {
cur_tsc = rte_rdtsc();
diff_tsc = cur_tsc - prev_tsc;
if (diff_tsc > TIMER_RESOLUTION_CYCLES) {
rte_timer_manage();
prev_tsc = cur_tsc;
}
}
}
static void
report_stat(struct rte_timer *tim, __attribute((unused)) void *arg)
{
/* print stat */
uint32_t count = rte_atomic32_read(&stat);
rte_log(RTE_LOG_INFO, RTE_LOGTYPE_USER8,
"Throughput = %8u msg/s\n", count);
/* reset stat */
rte_atomic32_set(&stat, 0);
/* this timer is automatically reloaded until we decide to stop it */
if (force_quit)
rte_timer_stop(tim);
}
static void
check_timeout(struct rte_timer *tim, void *arg)
{
struct proposer* p = (struct proposer *) arg;
unsigned lcore_id = rte_lcore_id();
rte_log(RTE_LOG_DEBUG, RTE_LOGTYPE_USER8, "%s() on lcore_id %i\n", __func__, lcore_id);
struct paxos_message out;
out.type = PAXOS_PREPARE;
struct timeout_iterator* iter = proposer_timeout_iterator(p);
while(timeout_iterator_prepare(iter, &out.u.prepare)) {
rte_log(RTE_LOG_DEBUG, RTE_LOGTYPE_USER8,
"%s Send PREPARE inst %d ballot %d\n",
__func__, out.u.prepare.iid, out.u.prepare.ballot);
send_paxos_message(&out);
}
out.type = PAXOS_ACCEPT;
while(timeout_iterator_accept(iter, &out.u.accept)) {
rte_log(RTE_LOG_DEBUG, RTE_LOGTYPE_USER8,
"%s: Send ACCEPT inst %d ballot %d\n",
__func__, out.u.prepare.iid, out.u.prepare.ballot);
send_paxos_message(&out);
}
timeout_iterator_free(iter);
/* this timer is automatically reloaded until we decide to stop it */
if (force_quit)
rte_timer_stop(tim);
}
int
main(int argc, char *argv[])
{
uint8_t portid = 0;
unsigned master_core, lcore_id;
signal(SIGTERM, signal_handler);
signal(SIGINT, signal_handler);
force_quit = false;
int proposer_id = 0;
if (rte_get_log_level() == RTE_LOG_DEBUG) {
paxos_config.verbosity = PAXOS_LOG_DEBUG;
}
struct proposer *proposer = proposer_new(proposer_id, NUM_ACCEPTORS);
first_time = true;
/* init EAL */
int ret = rte_eal_init(argc, argv);
if (ret < 0)
rte_exit(EXIT_FAILURE, "Error with EAL initialization\n");
/* init timer structure */
rte_timer_init(&timer);
rte_timer_init(&stat_timer);
/* load deliver_timer, every 1 s, on a slave lcore, reloaded automatically */
uint64_t hz = rte_get_timer_hz();
/* Call rte_timer_manage every 10ms */
TIMER_RESOLUTION_CYCLES = hz / 100;
rte_log(RTE_LOG_INFO, RTE_LOGTYPE_USER1, "Clock: %"PRIu64"\n", hz);
/* master core */
master_core = rte_lcore_id();
/* slave core */
lcore_id = rte_get_next_lcore(master_core, 0, 1);
rte_log(RTE_LOG_DEBUG, RTE_LOGTYPE_USER1, "lcore_id: %d\n", lcore_id);
rte_timer_reset(&timer, hz, PERIODICAL, lcore_id, check_timeout, proposer);
/* reset timer */
rte_eal_remote_launch(lcore_mainloop, NULL, lcore_id);
/* stat core */
lcore_id = rte_get_next_lcore(lcore_id , 0, 1);
rte_log(RTE_LOG_DEBUG, RTE_LOGTYPE_USER1, "lcore_id: %d\n", lcore_id);
rte_timer_reset(&stat_timer, hz, PERIODICAL, lcore_id,
report_stat, NULL);
/* init RTE timer library */
rte_timer_subsystem_init();
mbuf_pool = rte_pktmbuf_pool_create("MBUF_POOL",
NUM_MBUFS, MBUF_CACHE_SIZE, 0,
RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());
if (mbuf_pool == NULL)
rte_exit(EXIT_FAILURE, "Cannot create mbuf_pool\n");
/* reset timer */
rte_eal_remote_launch(lcore_mainloop, NULL, lcore_id);
if (port_init(portid, mbuf_pool, proposer) != 0)
rte_exit(EXIT_FAILURE, "Cannot init port %"PRIu8"\n", portid);
lcore_main(portid, proposer);
rte_log(RTE_LOG_DEBUG, RTE_LOGTYPE_USER8, "Free proposer\n");
proposer_free(proposer);
return 0;
}
int app_init(void)
{
uint32_t i;
char ring_name[MAX_NAME_LEN];
char pool_name[MAX_NAME_LEN];
/* init driver(s) */
if (rte_pmd_init_all() < 0)
rte_exit(EXIT_FAILURE, "Cannot init PMD\n");
if (rte_eal_pci_probe() < 0)
rte_exit(EXIT_FAILURE, "Cannot probe PCI\n");
if (rte_eth_dev_count() == 0)
rte_exit(EXIT_FAILURE, "No Ethernet port - bye\n");
/* load configuration profile */
if (app_load_cfg_profile(cfg_profile) != 0)
rte_exit(EXIT_FAILURE, "Invalid configuration profile\n");
/* Initialize each active flow */
for(i = 0; i < nb_pfc; i++) {
uint32_t socket = rte_lcore_to_socket_id(qos_conf[i].rx_core);
struct rte_ring *ring;
rte_snprintf(ring_name, MAX_NAME_LEN, "ring-%u-%u", i, qos_conf[i].rx_core);
ring = rte_ring_lookup(ring_name);
if (ring == NULL)
qos_conf[i].rx_ring = rte_ring_create(ring_name, ring_conf.ring_size,
socket, RING_F_SP_ENQ | RING_F_SC_DEQ);
else
qos_conf[i].rx_ring = ring;
rte_snprintf(ring_name, MAX_NAME_LEN, "ring-%u-%u", i, qos_conf[i].tx_core);
ring = rte_ring_lookup(ring_name);
if (ring == NULL)
qos_conf[i].tx_ring = rte_ring_create(ring_name, ring_conf.ring_size,
socket, RING_F_SP_ENQ | RING_F_SC_DEQ);
else
qos_conf[i].tx_ring = ring;
/* create the mbuf pools for each RX Port */
rte_snprintf(pool_name, MAX_NAME_LEN, "mbuf_pool%u", i);
qos_conf[i].mbuf_pool = rte_mempool_create(pool_name, mp_size, MBUF_SIZE,
burst_conf.rx_burst * 4,
sizeof(struct rte_pktmbuf_pool_private),
rte_pktmbuf_pool_init, NULL,
rte_pktmbuf_init, NULL,
rte_eth_dev_socket_id(qos_conf[i].rx_port),
0);
if (qos_conf[i].mbuf_pool == NULL)
rte_exit(EXIT_FAILURE, "Cannot init mbuf pool for socket %u\n", i);
app_init_port(qos_conf[i].rx_port, qos_conf[i].mbuf_pool);
app_init_port(qos_conf[i].tx_port, qos_conf[i].mbuf_pool);
qos_conf[i].sched_port = app_init_sched_port(qos_conf[i].tx_port, socket);
}
RTE_LOG(INFO, APP, "time stamp clock running at %" PRIu64 " Hz\n",
rte_get_timer_hz());
RTE_LOG(INFO, APP, "Ring sizes: NIC RX = %u, Mempool = %d SW queue = %u,"
"NIC TX = %u\n", ring_conf.rx_size, mp_size, ring_conf.ring_size,
ring_conf.tx_size);
RTE_LOG(INFO, APP, "Burst sizes: RX read = %hu, RX write = %hu,\n"
" Worker read/QoS enqueue = %hu,\n"
" QoS dequeue = %hu, Worker write = %hu\n",
burst_conf.rx_burst, burst_conf.ring_burst, burst_conf.ring_burst,
burst_conf.qos_dequeue, burst_conf.tx_burst);
RTE_LOG(INFO, APP, "NIC thresholds RX (p = %hhu, h = %hhu, w = %hhu),"
"TX (p = %hhu, h = %hhu, w = %hhu)\n",
rx_thresh.pthresh, rx_thresh.hthresh, rx_thresh.wthresh,
tx_thresh.pthresh, tx_thresh.hthresh, tx_thresh.wthresh);
return 0;
}
static int
app_init_port(uint8_t portid, struct rte_mempool *mp)
{
int ret;
struct rte_eth_link link;
struct rte_eth_rxconf rx_conf;
struct rte_eth_txconf tx_conf;
/* check if port already initialized (multistream configuration) */
if (app_inited_port_mask & (1u << portid))
return 0;
rx_conf.rx_thresh.pthresh = rx_thresh.pthresh;
rx_conf.rx_thresh.hthresh = rx_thresh.hthresh;
rx_conf.rx_thresh.wthresh = rx_thresh.wthresh;
rx_conf.rx_free_thresh = 32;
rx_conf.rx_drop_en = 0;
tx_conf.tx_thresh.pthresh = tx_thresh.pthresh;
tx_conf.tx_thresh.hthresh = tx_thresh.hthresh;
tx_conf.tx_thresh.wthresh = tx_thresh.wthresh;
tx_conf.tx_free_thresh = 0;
tx_conf.tx_rs_thresh = 0;
tx_conf.txq_flags = ETH_TXQ_FLAGS_NOMULTSEGS | ETH_TXQ_FLAGS_NOOFFLOADS;
/* init port */
RTE_LOG(INFO, APP, "Initializing port %hu... ", portid);
fflush(stdout);
ret = rte_eth_dev_configure(portid, 1, 1, &port_conf);
if (ret < 0)
rte_exit(EXIT_FAILURE, "Cannot configure device: err=%d, port=%hu\n",
ret, portid);
/* init one RX queue */
fflush(stdout);
ret = rte_eth_rx_queue_setup(portid, 0, (uint16_t)ring_conf.rx_size,
rte_eth_dev_socket_id(portid), &rx_conf, mp);
if (ret < 0)
rte_exit(EXIT_FAILURE, "rte_eth_tx_queue_setup: err=%d, port=%hu\n",
ret, portid);
/* init one TX queue */
fflush(stdout);
ret = rte_eth_tx_queue_setup(portid, 0,
(uint16_t)ring_conf.tx_size, rte_eth_dev_socket_id(portid), &tx_conf);
if (ret < 0)
rte_exit(EXIT_FAILURE, "rte_eth_tx_queue_setup: err=%d, "
"port=%hu queue=%d\n",
ret, portid, 0);
/* Start device */
ret = rte_eth_dev_start(portid);
if (ret < 0)
rte_exit(EXIT_FAILURE, "rte_pmd_port_start: err=%d, port=%hu\n",
ret, portid);
printf("done: ");
/* get link status */
rte_eth_link_get(portid, &link);
if (link.link_status) {
printf(" Link Up - speed %u Mbps - %s\n",
(uint32_t) link.link_speed,
(link.link_duplex == ETH_LINK_FULL_DUPLEX) ?
("full-duplex") : ("half-duplex\n"));
} else {
printf(" Link Down\n");
}
rte_eth_promiscuous_enable(portid);
/* mark port as initialized */
app_inited_port_mask |= 1u << portid;
return 0;
}
/*
* Initialises a given port using global settings and with the rx buffers
* coming from the mbuf_pool passed as parameter
*/
static inline int
port_init(uint8_t port, struct rte_mempool *mbuf_pool)
{
struct rte_eth_dev_info dev_info;
struct rte_eth_rxconf *rxconf;
struct rte_eth_conf port_conf;
uint16_t rxRings, txRings;
const uint16_t rxRingSize = RTE_TEST_RX_DESC_DEFAULT, txRingSize = RTE_TEST_TX_DESC_DEFAULT;
int retval;
uint16_t q;
uint16_t queues_per_pool;
uint32_t max_nb_pools;
/*
* The max pool number from dev_info will be used to validate the pool
* number specified in cmd line
*/
rte_eth_dev_info_get(port, &dev_info);
max_nb_pools = (uint32_t)dev_info.max_vmdq_pools;
/*
* We allow to process part of VMDQ pools specified by num_pools in
* command line.
*/
if (num_pools > max_nb_pools) {
printf("num_pools %d >max_nb_pools %d\n",
num_pools, max_nb_pools);
return -1;
}
retval = get_eth_conf(&port_conf, max_nb_pools);
if (retval < 0)
return retval;
/*
* NIC queues are divided into pf queues and vmdq queues.
*/
/* There is assumption here all ports have the same configuration! */
num_pf_queues = dev_info.max_rx_queues - dev_info.vmdq_queue_num;
queues_per_pool = dev_info.vmdq_queue_num / dev_info.max_vmdq_pools;
num_vmdq_queues = num_pools * queues_per_pool;
num_queues = num_pf_queues + num_vmdq_queues;
vmdq_queue_base = dev_info.vmdq_queue_base;
vmdq_pool_base = dev_info.vmdq_pool_base;
printf("pf queue num: %u, configured vmdq pool num: %u,"
" each vmdq pool has %u queues\n",
num_pf_queues, num_pools, queues_per_pool);
printf("vmdq queue base: %d pool base %d\n",
vmdq_queue_base, vmdq_pool_base);
if (port >= rte_eth_dev_count())
return -1;
/*
* Though in this example, we only receive packets from the first queue
* of each pool and send packets through first rte_lcore_count() tx
* queues of vmdq queues, all queues including pf queues are setup.
* This is because VMDQ queues doesn't always start from zero, and the
* PMD layer doesn't support selectively initialising part of rx/tx
* queues.
*/
rxRings = (uint16_t)dev_info.max_rx_queues;
txRings = (uint16_t)dev_info.max_tx_queues;
retval = rte_eth_dev_configure(port, rxRings, txRings, &port_conf);
if (retval != 0)
return retval;
rte_eth_dev_info_get(port, &dev_info);
rxconf = &dev_info.default_rxconf;
rxconf->rx_drop_en = 1;
for (q = 0; q < rxRings; q++) {
retval = rte_eth_rx_queue_setup(port, q, rxRingSize,
rte_eth_dev_socket_id(port),
rxconf,
mbuf_pool);
if (retval < 0) {
printf("initialise rx queue %d failed\n", q);
return retval;
}
}
for (q = 0; q < txRings; q++) {
retval = rte_eth_tx_queue_setup(port, q, txRingSize,
rte_eth_dev_socket_id(port),
NULL);
if (retval < 0) {
printf("initialise tx queue %d failed\n", q);
return retval;
}
}
retval = rte_eth_dev_start(port);
if (retval < 0) {
printf("port %d start failed\n", port);
return retval;
}
rte_eth_macaddr_get(port, &vmdq_ports_eth_addr[port]);
printf("Port %u MAC: %02"PRIx8" %02"PRIx8" %02"PRIx8
" %02"PRIx8" %02"PRIx8" %02"PRIx8"\n",
(unsigned)port,
vmdq_ports_eth_addr[port].addr_bytes[0],
vmdq_ports_eth_addr[port].addr_bytes[1],
vmdq_ports_eth_addr[port].addr_bytes[2],
vmdq_ports_eth_addr[port].addr_bytes[3],
vmdq_ports_eth_addr[port].addr_bytes[4],
vmdq_ports_eth_addr[port].addr_bytes[5]);
/*
* Set mac for each pool.
* There is no default mac for the pools in i40.
* Removes this after i40e fixes this issue.
*/
for (q = 0; q < num_pools; q++) {
struct ether_addr mac;
mac = pool_addr_template;
mac.addr_bytes[4] = port;
mac.addr_bytes[5] = q;
printf("Port %u vmdq pool %u set mac %02x:%02x:%02x:%02x:%02x:%02x\n",
port, q,
mac.addr_bytes[0], mac.addr_bytes[1],
mac.addr_bytes[2], mac.addr_bytes[3],
mac.addr_bytes[4], mac.addr_bytes[5]);
retval = rte_eth_dev_mac_addr_add(port, &mac,
q + vmdq_pool_base);
if (retval) {
printf("mac addr add failed at pool %d\n", q);
return retval;
}
}
return 0;
}
static inline int
app_link_filter_arp_add(struct app_link_params *link)
{
struct rte_eth_ethertype_filter filter = {
.ether_type = ETHER_TYPE_ARP,
.flags = 0,
.queue = link->arp_q,
};
return rte_eth_dev_filter_ctrl(link->pmd_id,
RTE_ETH_FILTER_ETHERTYPE,
RTE_ETH_FILTER_ADD,
&filter);
}
static inline int
app_link_filter_tcp_syn_add(struct app_link_params *link)
{
struct rte_eth_syn_filter filter = {
.hig_pri = 1,
.queue = link->tcp_syn_q,
};
return rte_eth_dev_filter_ctrl(link->pmd_id,
RTE_ETH_FILTER_SYN,
RTE_ETH_FILTER_ADD,
&filter);
}
static inline int
app_link_filter_ip_add(struct app_link_params *l1, struct app_link_params *l2)
{
struct rte_eth_ntuple_filter filter = {
.flags = RTE_5TUPLE_FLAGS,
.dst_ip = rte_bswap32(l2->ip),
.dst_ip_mask = UINT32_MAX, /* Enable */
.src_ip = 0,
.src_ip_mask = 0, /* Disable */
.dst_port = 0,
.dst_port_mask = 0, /* Disable */
.src_port = 0,
.src_port_mask = 0, /* Disable */
.proto = 0,
.proto_mask = 0, /* Disable */
.tcp_flags = 0,
.priority = 1, /* Lowest */
.queue = l1->ip_local_q,
};
return rte_eth_dev_filter_ctrl(l1->pmd_id,
RTE_ETH_FILTER_NTUPLE,
RTE_ETH_FILTER_ADD,
&filter);
}
static inline int
app_link_filter_ip_del(struct app_link_params *l1, struct app_link_params *l2)
{
struct rte_eth_ntuple_filter filter = {
.flags = RTE_5TUPLE_FLAGS,
.dst_ip = rte_bswap32(l2->ip),
.dst_ip_mask = UINT32_MAX, /* Enable */
.src_ip = 0,
.src_ip_mask = 0, /* Disable */
.dst_port = 0,
.dst_port_mask = 0, /* Disable */
.src_port = 0,
.src_port_mask = 0, /* Disable */
.proto = 0,
.proto_mask = 0, /* Disable */
.tcp_flags = 0,
.priority = 1, /* Lowest */
.queue = l1->ip_local_q,
};
return rte_eth_dev_filter_ctrl(l1->pmd_id,
RTE_ETH_FILTER_NTUPLE,
RTE_ETH_FILTER_DELETE,
&filter);
}
static inline int
app_link_filter_tcp_add(struct app_link_params *l1, struct app_link_params *l2)
{
struct rte_eth_ntuple_filter filter = {
.flags = RTE_5TUPLE_FLAGS,
.dst_ip = rte_bswap32(l2->ip),
.dst_ip_mask = UINT32_MAX, /* Enable */
.src_ip = 0,
.src_ip_mask = 0, /* Disable */
.dst_port = 0,
.dst_port_mask = 0, /* Disable */
.src_port = 0,
.src_port_mask = 0, /* Disable */
.proto = IPPROTO_TCP,
.proto_mask = UINT8_MAX, /* Enable */
.tcp_flags = 0,
.priority = 2, /* Higher priority than IP */
.queue = l1->tcp_local_q,
};
return rte_eth_dev_filter_ctrl(l1->pmd_id,
RTE_ETH_FILTER_NTUPLE,
RTE_ETH_FILTER_ADD,
&filter);
}
static inline int
app_link_filter_tcp_del(struct app_link_params *l1, struct app_link_params *l2)
{
struct rte_eth_ntuple_filter filter = {
.flags = RTE_5TUPLE_FLAGS,
.dst_ip = rte_bswap32(l2->ip),
.dst_ip_mask = UINT32_MAX, /* Enable */
.src_ip = 0,
.src_ip_mask = 0, /* Disable */
.dst_port = 0,
.dst_port_mask = 0, /* Disable */
.src_port = 0,
.src_port_mask = 0, /* Disable */
.proto = IPPROTO_TCP,
.proto_mask = UINT8_MAX, /* Enable */
.tcp_flags = 0,
.priority = 2, /* Higher priority than IP */
.queue = l1->tcp_local_q,
};
return rte_eth_dev_filter_ctrl(l1->pmd_id,
RTE_ETH_FILTER_NTUPLE,
RTE_ETH_FILTER_DELETE,
&filter);
}
static inline int
app_link_filter_udp_add(struct app_link_params *l1, struct app_link_params *l2)
{
struct rte_eth_ntuple_filter filter = {
.flags = RTE_5TUPLE_FLAGS,
.dst_ip = rte_bswap32(l2->ip),
.dst_ip_mask = UINT32_MAX, /* Enable */
.src_ip = 0,
.src_ip_mask = 0, /* Disable */
.dst_port = 0,
.dst_port_mask = 0, /* Disable */
.src_port = 0,
.src_port_mask = 0, /* Disable */
.proto = IPPROTO_UDP,
.proto_mask = UINT8_MAX, /* Enable */
.tcp_flags = 0,
.priority = 2, /* Higher priority than IP */
.queue = l1->udp_local_q,
};
return rte_eth_dev_filter_ctrl(l1->pmd_id,
RTE_ETH_FILTER_NTUPLE,
RTE_ETH_FILTER_ADD,
&filter);
}
static inline int
app_link_filter_udp_del(struct app_link_params *l1, struct app_link_params *l2)
{
struct rte_eth_ntuple_filter filter = {
.flags = RTE_5TUPLE_FLAGS,
.dst_ip = rte_bswap32(l2->ip),
.dst_ip_mask = UINT32_MAX, /* Enable */
.src_ip = 0,
.src_ip_mask = 0, /* Disable */
.dst_port = 0,
.dst_port_mask = 0, /* Disable */
.src_port = 0,
.src_port_mask = 0, /* Disable */
.proto = IPPROTO_UDP,
.proto_mask = UINT8_MAX, /* Enable */
.tcp_flags = 0,
.priority = 2, /* Higher priority than IP */
.queue = l1->udp_local_q,
};
return rte_eth_dev_filter_ctrl(l1->pmd_id,
RTE_ETH_FILTER_NTUPLE,
RTE_ETH_FILTER_DELETE,
&filter);
}
static inline int
app_link_filter_sctp_add(struct app_link_params *l1, struct app_link_params *l2)
{
struct rte_eth_ntuple_filter filter = {
.flags = RTE_5TUPLE_FLAGS,
.dst_ip = rte_bswap32(l2->ip),
.dst_ip_mask = UINT32_MAX, /* Enable */
.src_ip = 0,
.src_ip_mask = 0, /* Disable */
.dst_port = 0,
.dst_port_mask = 0, /* Disable */
.src_port = 0,
.src_port_mask = 0, /* Disable */
.proto = IPPROTO_SCTP,
.proto_mask = UINT8_MAX, /* Enable */
.tcp_flags = 0,
.priority = 2, /* Higher priority than IP */
.queue = l1->sctp_local_q,
};
return rte_eth_dev_filter_ctrl(l1->pmd_id,
RTE_ETH_FILTER_NTUPLE,
RTE_ETH_FILTER_ADD,
&filter);
}
static inline int
app_link_filter_sctp_del(struct app_link_params *l1, struct app_link_params *l2)
{
struct rte_eth_ntuple_filter filter = {
.flags = RTE_5TUPLE_FLAGS,
.dst_ip = rte_bswap32(l2->ip),
.dst_ip_mask = UINT32_MAX, /* Enable */
.src_ip = 0,
.src_ip_mask = 0, /* Disable */
.dst_port = 0,
.dst_port_mask = 0, /* Disable */
.src_port = 0,
.src_port_mask = 0, /* Disable */
.proto = IPPROTO_SCTP,
.proto_mask = UINT8_MAX, /* Enable */
.tcp_flags = 0,
.priority = 2, /* Higher priority than IP */
.queue = l1->sctp_local_q,
};
return rte_eth_dev_filter_ctrl(l1->pmd_id,
RTE_ETH_FILTER_NTUPLE,
RTE_ETH_FILTER_DELETE,
&filter);
}
static void
app_link_set_arp_filter(struct app_params *app, struct app_link_params *cp)
{
if (cp->arp_q != 0) {
int status = app_link_filter_arp_add(cp);
APP_LOG(app, LOW, "%s (%" PRIu32 "): "
"Adding ARP filter (queue = %" PRIu32 ")",
cp->name, cp->pmd_id, cp->arp_q);
if (status)
rte_panic("%s (%" PRIu32 "): "
"Error adding ARP filter "
"(queue = %" PRIu32 ") (%" PRId32 ")\n",
cp->name, cp->pmd_id, cp->arp_q, status);
}
}
static void
app_link_set_tcp_syn_filter(struct app_params *app, struct app_link_params *cp)
{
if (cp->tcp_syn_q != 0) {
int status = app_link_filter_tcp_syn_add(cp);
APP_LOG(app, LOW, "%s (%" PRIu32 "): "
"Adding TCP SYN filter (queue = %" PRIu32 ")",
cp->name, cp->pmd_id, cp->tcp_syn_q);
if (status)
rte_panic("%s (%" PRIu32 "): "
"Error adding TCP SYN filter "
"(queue = %" PRIu32 ") (%" PRId32 ")\n",
cp->name, cp->pmd_id, cp->tcp_syn_q,
status);
}
}
void
app_link_up_internal(struct app_params *app, struct app_link_params *cp)
{
uint32_t i;
int status;
/* For each link, add filters for IP of current link */
if (cp->ip != 0) {
for (i = 0; i < app->n_links; i++) {
struct app_link_params *p = &app->link_params[i];
/* IP */
if (p->ip_local_q != 0) {
int status = app_link_filter_ip_add(p, cp);
APP_LOG(app, LOW, "%s (%" PRIu32 "): "
"Adding IP filter (queue= %" PRIu32
", IP = 0x%08" PRIx32 ")",
p->name, p->pmd_id, p->ip_local_q,
cp->ip);
if (status)
rte_panic("%s (%" PRIu32 "): "
"Error adding IP "
"filter (queue= %" PRIu32 ", "
"IP = 0x%08" PRIx32
") (%" PRId32 ")\n",
p->name, p->pmd_id,
p->ip_local_q, cp->ip, status);
}
/* TCP */
if (p->tcp_local_q != 0) {
int status = app_link_filter_tcp_add(p, cp);
APP_LOG(app, LOW, "%s (%" PRIu32 "): "
"Adding TCP filter "
"(queue = %" PRIu32
", IP = 0x%08" PRIx32 ")",
p->name, p->pmd_id, p->tcp_local_q,
cp->ip);
if (status)
rte_panic("%s (%" PRIu32 "): "
"Error adding TCP "
"filter (queue = %" PRIu32 ", "
"IP = 0x%08" PRIx32
") (%" PRId32 ")\n",
p->name, p->pmd_id,
p->tcp_local_q, cp->ip, status);
}
/* UDP */
if (p->udp_local_q != 0) {
int status = app_link_filter_udp_add(p, cp);
APP_LOG(app, LOW, "%s (%" PRIu32 "): "
"Adding UDP filter "
"(queue = %" PRIu32
", IP = 0x%08" PRIx32 ")",
p->name, p->pmd_id, p->udp_local_q,
cp->ip);
if (status)
rte_panic("%s (%" PRIu32 "): "
"Error adding UDP "
"filter (queue = %" PRIu32 ", "
"IP = 0x%08" PRIx32
") (%" PRId32 ")\n",
p->name, p->pmd_id,
p->udp_local_q, cp->ip, status);
}
/* SCTP */
if (p->sctp_local_q != 0) {
int status = app_link_filter_sctp_add(p, cp);
APP_LOG(app, LOW, "%s (%" PRIu32
"): Adding SCTP filter "
"(queue = %" PRIu32
", IP = 0x%08" PRIx32 ")",
p->name, p->pmd_id, p->sctp_local_q,
cp->ip);
if (status)
rte_panic("%s (%" PRIu32 "): "
"Error adding SCTP "
"filter (queue = %" PRIu32 ", "
"IP = 0x%08" PRIx32
") (%" PRId32 ")\n",
p->name, p->pmd_id,
p->sctp_local_q, cp->ip,
status);
}
}
}
/* PMD link up */
status = rte_eth_dev_set_link_up(cp->pmd_id);
/* Do not panic if PMD does not provide link up functionality */
if (status < 0 && status != -ENOTSUP)
rte_panic("%s (%" PRIu32 "): PMD set link up error %"
PRId32 "\n", cp->name, cp->pmd_id, status);
/* Mark link as UP */
cp->state = 1;
}
void
app_link_down_internal(struct app_params *app, struct app_link_params *cp)
{
uint32_t i;
int status;
/* PMD link down */
status = rte_eth_dev_set_link_down(cp->pmd_id);
/* Do not panic if PMD does not provide link down functionality */
if (status < 0 && status != -ENOTSUP)
rte_panic("%s (%" PRIu32 "): PMD set link down error %"
PRId32 "\n", cp->name, cp->pmd_id, status);
/* Mark link as DOWN */
cp->state = 0;
/* Return if current link IP is not valid */
if (cp->ip == 0)
return;
/* For each link, remove filters for IP of current link */
for (i = 0; i < app->n_links; i++) {
struct app_link_params *p = &app->link_params[i];
/* IP */
if (p->ip_local_q != 0) {
int status = app_link_filter_ip_del(p, cp);
APP_LOG(app, LOW, "%s (%" PRIu32
"): Deleting IP filter "
"(queue = %" PRIu32 ", IP = 0x%" PRIx32 ")",
p->name, p->pmd_id, p->ip_local_q, cp->ip);
if (status)
rte_panic("%s (%" PRIu32
"): Error deleting IP filter "
"(queue = %" PRIu32
", IP = 0x%" PRIx32
") (%" PRId32 ")\n",
p->name, p->pmd_id, p->ip_local_q,
cp->ip, status);
}
/* TCP */
if (p->tcp_local_q != 0) {
int status = app_link_filter_tcp_del(p, cp);
APP_LOG(app, LOW, "%s (%" PRIu32
"): Deleting TCP filter "
"(queue = %" PRIu32
", IP = 0x%" PRIx32 ")",
p->name, p->pmd_id, p->tcp_local_q, cp->ip);
if (status)
rte_panic("%s (%" PRIu32
"): Error deleting TCP filter "
"(queue = %" PRIu32
", IP = 0x%" PRIx32
") (%" PRId32 ")\n",
p->name, p->pmd_id, p->tcp_local_q,
cp->ip, status);
}
/* UDP */
if (p->udp_local_q != 0) {
int status = app_link_filter_udp_del(p, cp);
APP_LOG(app, LOW, "%s (%" PRIu32
"): Deleting UDP filter "
"(queue = %" PRIu32 ", IP = 0x%" PRIx32 ")",
p->name, p->pmd_id, p->udp_local_q, cp->ip);
if (status)
rte_panic("%s (%" PRIu32
"): Error deleting UDP filter "
"(queue = %" PRIu32
", IP = 0x%" PRIx32
") (%" PRId32 ")\n",
p->name, p->pmd_id, p->udp_local_q,
cp->ip, status);
}
/* SCTP */
if (p->sctp_local_q != 0) {
int status = app_link_filter_sctp_del(p, cp);
APP_LOG(app, LOW, "%s (%" PRIu32
"): Deleting SCTP filter "
"(queue = %" PRIu32
", IP = 0x%" PRIx32 ")",
p->name, p->pmd_id, p->sctp_local_q, cp->ip);
if (status)
rte_panic("%s (%" PRIu32
"): Error deleting SCTP filter "
"(queue = %" PRIu32
", IP = 0x%" PRIx32
") (%" PRId32 ")\n",
p->name, p->pmd_id, p->sctp_local_q,
cp->ip, status);
}
}
}
static void
app_check_link(struct app_params *app)
{
uint32_t all_links_up, i;
all_links_up = 1;
for (i = 0; i < app->n_links; i++) {
struct app_link_params *p = &app->link_params[i];
struct rte_eth_link link_params;
memset(&link_params, 0, sizeof(link_params));
rte_eth_link_get(p->pmd_id, &link_params);
APP_LOG(app, HIGH, "%s (%" PRIu32 ") (%" PRIu32 " Gbps) %s",
p->name,
p->pmd_id,
link_params.link_speed / 1000,
link_params.link_status ? "UP" : "DOWN");
if (link_params.link_status == ETH_LINK_DOWN)
all_links_up = 0;
}
if (all_links_up == 0)
rte_panic("Some links are DOWN\n");
}
static uint32_t
is_any_swq_frag_or_ras(struct app_params *app)
{
uint32_t i;
for (i = 0; i < app->n_pktq_swq; i++) {
struct app_pktq_swq_params *p = &app->swq_params[i];
if ((p->ipv4_frag == 1) || (p->ipv6_frag == 1) ||
(p->ipv4_ras == 1) || (p->ipv6_ras == 1))
return 1;
}
return 0;
}
static void
app_init_link_frag_ras(struct app_params *app)
{
uint32_t i;
if (is_any_swq_frag_or_ras(app)) {
for (i = 0; i < app->n_pktq_hwq_out; i++) {
struct app_pktq_hwq_out_params *p_txq = &app->hwq_out_params[i];
p_txq->conf.txq_flags &= ~ETH_TXQ_FLAGS_NOMULTSEGS;
}
}
}
static inline int
app_get_cpu_socket_id(uint32_t pmd_id)
{
int status = rte_eth_dev_socket_id(pmd_id);
return (status != SOCKET_ID_ANY) ? status : 0;
}
static inline int
app_link_rss_enabled(struct app_link_params *cp)
{
return (cp->n_rss_qs) ? 1 : 0;
}
static void
app_link_rss_setup(struct app_link_params *cp)
{
struct rte_eth_dev_info dev_info;
struct rte_eth_rss_reta_entry64 reta_conf[APP_RETA_SIZE_MAX];
uint32_t i;
int status;
/* Get RETA size */
memset(&dev_info, 0, sizeof(dev_info));
rte_eth_dev_info_get(cp->pmd_id, &dev_info);
if (dev_info.reta_size == 0)
rte_panic("%s (%u): RSS setup error (null RETA size)\n",
cp->name, cp->pmd_id);
if (dev_info.reta_size > ETH_RSS_RETA_SIZE_512)
rte_panic("%s (%u): RSS setup error (RETA size too big)\n",
cp->name, cp->pmd_id);
/* Setup RETA contents */
memset(reta_conf, 0, sizeof(reta_conf));
for (i = 0; i < dev_info.reta_size; i++)
reta_conf[i / RTE_RETA_GROUP_SIZE].mask = UINT64_MAX;
for (i = 0; i < dev_info.reta_size; i++) {
uint32_t reta_id = i / RTE_RETA_GROUP_SIZE;
uint32_t reta_pos = i % RTE_RETA_GROUP_SIZE;
uint32_t rss_qs_pos = i % cp->n_rss_qs;
reta_conf[reta_id].reta[reta_pos] =
(uint16_t) cp->rss_qs[rss_qs_pos];
}
/* RETA update */
status = rte_eth_dev_rss_reta_update(cp->pmd_id,
reta_conf,
dev_info.reta_size);
if (status != 0)
rte_panic("%s (%u): RSS setup error (RETA update failed)\n",
cp->name, cp->pmd_id);
}
static void
app_init_link_set_config(struct app_link_params *p)
{
if (p->n_rss_qs) {
p->conf.rxmode.mq_mode = ETH_MQ_RX_RSS;
p->conf.rx_adv_conf.rss_conf.rss_hf = p->rss_proto_ipv4 |
p->rss_proto_ipv6 |
p->rss_proto_l2;
}
}
static void
app_init_link(struct app_params *app)
{
uint32_t i;
app_init_link_frag_ras(app);
for (i = 0; i < app->n_links; i++) {
struct app_link_params *p_link = &app->link_params[i];
uint32_t link_id, n_hwq_in, n_hwq_out, j;
int status;
sscanf(p_link->name, "LINK%" PRIu32, &link_id);
n_hwq_in = app_link_get_n_rxq(app, p_link);
n_hwq_out = app_link_get_n_txq(app, p_link);
app_init_link_set_config(p_link);
APP_LOG(app, HIGH, "Initializing %s (%" PRIu32") "
"(%" PRIu32 " RXQ, %" PRIu32 " TXQ) ...",
p_link->name,
p_link->pmd_id,
n_hwq_in,
n_hwq_out);
/* LINK */
status = rte_eth_dev_configure(
p_link->pmd_id,
n_hwq_in,
n_hwq_out,
&p_link->conf);
if (status < 0)
rte_panic("%s (%" PRId32 "): "
"init error (%" PRId32 ")\n",
p_link->name, p_link->pmd_id, status);
rte_eth_macaddr_get(p_link->pmd_id,
(struct ether_addr *) &p_link->mac_addr);
if (p_link->promisc)
rte_eth_promiscuous_enable(p_link->pmd_id);
/* RXQ */
for (j = 0; j < app->n_pktq_hwq_in; j++) {
struct app_pktq_hwq_in_params *p_rxq =
&app->hwq_in_params[j];
uint32_t rxq_link_id, rxq_queue_id;
uint16_t nb_rxd = p_rxq->size;
sscanf(p_rxq->name, "RXQ%" PRIu32 ".%" PRIu32,
&rxq_link_id, &rxq_queue_id);
if (rxq_link_id != link_id)
continue;
status = rte_eth_dev_adjust_nb_rx_tx_desc(
p_link->pmd_id,
&nb_rxd,
NULL);
if (status < 0)
rte_panic("%s (%" PRIu32 "): "
"%s adjust number of Rx descriptors "
"error (%" PRId32 ")\n",
p_link->name,
p_link->pmd_id,
p_rxq->name,
status);
status = rte_eth_rx_queue_setup(
p_link->pmd_id,
rxq_queue_id,
nb_rxd,
app_get_cpu_socket_id(p_link->pmd_id),
&p_rxq->conf,
app->mempool[p_rxq->mempool_id]);
if (status < 0)
rte_panic("%s (%" PRIu32 "): "
"%s init error (%" PRId32 ")\n",
p_link->name,
p_link->pmd_id,
p_rxq->name,
status);
}
/* TXQ */
for (j = 0; j < app->n_pktq_hwq_out; j++) {
struct app_pktq_hwq_out_params *p_txq =
&app->hwq_out_params[j];
uint32_t txq_link_id, txq_queue_id;
uint16_t nb_txd = p_txq->size;
sscanf(p_txq->name, "TXQ%" PRIu32 ".%" PRIu32,
&txq_link_id, &txq_queue_id);
if (txq_link_id != link_id)
continue;
status = rte_eth_dev_adjust_nb_rx_tx_desc(
p_link->pmd_id,
NULL,
&nb_txd);
if (status < 0)
rte_panic("%s (%" PRIu32 "): "
"%s adjust number of Tx descriptors "
"error (%" PRId32 ")\n",
p_link->name,
p_link->pmd_id,
p_txq->name,
status);
status = rte_eth_tx_queue_setup(
p_link->pmd_id,
txq_queue_id,
nb_txd,
app_get_cpu_socket_id(p_link->pmd_id),
&p_txq->conf);
if (status < 0)
rte_panic("%s (%" PRIu32 "): "
"%s init error (%" PRId32 ")\n",
p_link->name,
p_link->pmd_id,
p_txq->name,
status);
}
/* LINK START */
status = rte_eth_dev_start(p_link->pmd_id);
if (status < 0)
rte_panic("Cannot start %s (error %" PRId32 ")\n",
p_link->name, status);
/* LINK FILTERS */
app_link_set_arp_filter(app, p_link);
app_link_set_tcp_syn_filter(app, p_link);
if (app_link_rss_enabled(p_link))
app_link_rss_setup(p_link);
/* LINK UP */
app_link_up_internal(app, p_link);
}
app_check_link(app);
}
static void
app_init_swq(struct app_params *app)
{
uint32_t i;
for (i = 0; i < app->n_pktq_swq; i++) {
struct app_pktq_swq_params *p = &app->swq_params[i];
unsigned flags = 0;
if (app_swq_get_readers(app, p) == 1)
flags |= RING_F_SC_DEQ;
if (app_swq_get_writers(app, p) == 1)
flags |= RING_F_SP_ENQ;
APP_LOG(app, HIGH, "Initializing %s...", p->name);
app->swq[i] = rte_ring_create(
p->name,
p->size,
p->cpu_socket_id,
flags);
if (app->swq[i] == NULL)
rte_panic("%s init error\n", p->name);
}
}
static void
app_init_tm(struct app_params *app)
{
uint32_t i;
for (i = 0; i < app->n_pktq_tm; i++) {
struct app_pktq_tm_params *p_tm = &app->tm_params[i];
struct app_link_params *p_link;
struct rte_eth_link link_eth_params;
struct rte_sched_port *sched;
uint32_t n_subports, subport_id;
int status;
p_link = app_get_link_for_tm(app, p_tm);
/* LINK */
rte_eth_link_get(p_link->pmd_id, &link_eth_params);
/* TM */
p_tm->sched_port_params.name = p_tm->name;
p_tm->sched_port_params.socket =
app_get_cpu_socket_id(p_link->pmd_id);
p_tm->sched_port_params.rate =
(uint64_t) link_eth_params.link_speed * 1000 * 1000 / 8;
APP_LOG(app, HIGH, "Initializing %s ...", p_tm->name);
sched = rte_sched_port_config(&p_tm->sched_port_params);
if (sched == NULL)
rte_panic("%s init error\n", p_tm->name);
app->tm[i] = sched;
/* Subport */
n_subports = p_tm->sched_port_params.n_subports_per_port;
for (subport_id = 0; subport_id < n_subports; subport_id++) {
uint32_t n_pipes_per_subport, pipe_id;
status = rte_sched_subport_config(sched,
subport_id,
&p_tm->sched_subport_params[subport_id]);
if (status)
rte_panic("%s subport %" PRIu32
" init error (%" PRId32 ")\n",
p_tm->name, subport_id, status);
/* Pipe */
n_pipes_per_subport =
p_tm->sched_port_params.n_pipes_per_subport;
for (pipe_id = 0;
pipe_id < n_pipes_per_subport;
pipe_id++) {
int profile_id = p_tm->sched_pipe_to_profile[
subport_id * APP_MAX_SCHED_PIPES +
pipe_id];
if (profile_id == -1)
continue;
status = rte_sched_pipe_config(sched,
subport_id,
pipe_id,
profile_id);
if (status)
rte_panic("%s subport %" PRIu32
" pipe %" PRIu32
" (profile %" PRId32 ") "
"init error (% " PRId32 ")\n",
p_tm->name, subport_id, pipe_id,
profile_id, status);
}
}
}
}
#ifndef RTE_EXEC_ENV_LINUXAPP
static void
app_init_tap(struct app_params *app) {
if (app->n_pktq_tap == 0)
return;
rte_panic("TAP device not supported.\n");
}
#else
static void
app_init_tap(struct app_params *app)
{
uint32_t i;
for (i = 0; i < app->n_pktq_tap; i++) {
struct app_pktq_tap_params *p_tap = &app->tap_params[i];
struct ifreq ifr;
int fd, status;
APP_LOG(app, HIGH, "Initializing %s ...", p_tap->name);
fd = open("/dev/net/tun", O_RDWR | O_NONBLOCK);
if (fd < 0)
rte_panic("Cannot open file /dev/net/tun\n");
memset(&ifr, 0, sizeof(ifr));
ifr.ifr_flags = IFF_TAP | IFF_NO_PI; /* No packet information */
snprintf(ifr.ifr_name, IFNAMSIZ, "%s", p_tap->name);
status = ioctl(fd, TUNSETIFF, (void *) &ifr);
if (status < 0)
rte_panic("TAP setup error\n");
app->tap[i] = fd;
}
}
