/* Callback for request of configuring network interface up/down */
static int
kni_config_network_interface(uint8_t port_id, uint8_t if_up)
{
int ret = 0;
RTE_LOG(INFO, KNI, "---- kni_config_network_interface\n");
if (port_id >= rte_eth_dev_count() || port_id >= RTE_MAX_ETHPORTS) {
RTE_LOG(ERR, KNI, "Invalid port id %d\n", port_id);
return -EINVAL;
}
RTE_LOG(INFO, KNI, "Configure network interface of %d %s\n", port_id,
if_up ? "up" : "down");
if (if_up != 0) { /* Configure network interface up */
rte_eth_dev_stop(port_id);
ret = rte_eth_dev_start(port_id);
kni_port_rdy[port_id]++;
} else /* Configure network interface down */
rte_eth_dev_stop(port_id);
if (ret < 0)
RTE_LOG(ERR, KNI, "Failed to start port %d\n", port_id);
RTE_LOG(INFO, KNI, "finished kni_config_network_interface\n");
return ret;
}
/* Callback for request of configuring network interface up/down */
static int
kni_config_network_interface(uint8_t port_id, uint8_t if_up)
{
#if 0
int ret = 0;
if (port_id >= rte_eth_dev_count() || port_id >= RTE_MAX_ETHPORTS) {
RTE_LOG(ERR, APP, "Invalid port id %d\n", port_id);
return -EINVAL;
}
RTE_LOG(INFO, APP, "Configure network interface of %d %s\n",
port_id, if_up ? "up" : "down");
if (if_up != 0) { /* Configure network interface up */
rte_eth_dev_stop(port_id);
ret = rte_eth_dev_start(port_id);
} else /* Configure network interface down */
rte_eth_dev_stop(port_id);
if (ret < 0)
RTE_LOG(ERR, APP, "Failed to start port %d\n", port_id);
return ret;
#endif
return 0;
}
static void
netmap_unregif(uint32_t idx, uint32_t port)
{
fd_port[idx].port = FD_PORT_RSRV;
ports[port].fd = UINT32_MAX;
rte_eth_dev_stop((uint8_t)port);
}
/**
* @brief Stop DPDK device
*
* @param devId uint8_t, ID of DPDK device
*/
void DPDKAdapter::stopDev(uint8_t devId)
{
if(devId > RTE_MAX_ETHPORTS)
{
qCritical("Device ID is out of range");
return;
}
rte_eth_dev_stop(devId);
}
int
rw_piot_dev_stop(rw_piot_api_handle_t api_handle)
{
rw_piot_device_t *rw_piot_dev = RWPIOT_GET_DEVICE(api_handle);
ASSERT(RWPIOT_VALID_DEVICE(rw_piot_dev));
if (NULL == rw_piot_dev) {
RW_PIOT_LOG(RTE_LOG_ERR, "PIOT Could not find device by handle\n");
return -1;
}
rte_eth_dev_stop(rw_piot_dev->rte_port_id);
return 0;
}
static void
app_lcore_io_tx_cleanup(struct app_lcore_params_io *lp) {
unsigned i;
for (i = 0; i < lp->tx.n_nic_ports; i ++) {
uint8_t portid = lp->tx.nic_ports[i];
/* Flush TX and RX queues. */
lagopus_msg_info("Cleanup physical port %u\n", portid);
rte_eth_dev_stop(portid);
rte_eth_dev_close(portid);
}
}
static int
test_pmd_ring(void)
{
mp = 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 (mp == NULL)
return -1;
if ((TX_PORT >= RTE_MAX_ETHPORTS) || (RX_PORT >= RTE_MAX_ETHPORTS)\
|| (RXTX_PORT >= RTE_MAX_ETHPORTS)) {
printf(" TX/RX port exceed max eth ports\n");
return -1;
}
if (test_ethdev_configure() < 0)
return -1;
if (test_send_basic_packets() < 0)
return -1;
if (test_get_stats() < 0)
return -1;
if (test_stats_reset() < 0)
return -1;
rte_eth_dev_stop(RX_PORT);
rte_eth_dev_stop(TX_PORT);
rte_eth_dev_stop(RXTX_PORT);
if (test_pmd_ring_pair_create_attach() < 0)
return -1;
return 0;
}
DpdkPcapResultCode_t deviceDeInit(int deviceId)
{
if (portInitFinished[deviceId] == 0)
{
return DPDKPCAP_FAILURE;
}
rte_eth_dev_stop(deviceId);
portInitFinished[deviceId] = 0;
return DPDKPCAP_OK;
}
/* Callback for request of configuring network interface up/down */
int
rw_piot_kni_config_network_interface(uint8_t port_id, uint8_t if_up)
{
int ret = 0, i;
rw_piot_device_t *rw_piot_dev = NULL;
for (i=0; i<RWPIOT_MAX_DEVICES; i++) {
if ((rw_piot_global_config.device[i].used) && (rw_piot_global_config.device[i].rte_port_id == port_id)) {
rw_piot_dev = &rw_piot_global_config.device[i];
}
}
if (NULL == rw_piot_dev) {
printf("Could not find port, rw_piot_kni_change_mtu\n");
return -1;
}
printf("Configure network interface of %d %s\n", port_id, if_up ? "up" : "down");
#if 0
if (if_up != 0) { /* Configure network interface up */
rte_eth_dev_stop(port_id);
ret = rte_eth_dev_start(port_id);
} else /* Configure network interface down */
rte_eth_dev_stop(port_id);
if (ret < 0)
printf("Failed to start port %d\n", port_id);
if (rw_piot_dev->kni_config_network_if) {
rw_piot_dev->kni_config_network_if(rw_piot_dev->piot_api_handle, if_up);
}
#endif
return ret;
}
/* Callback for request of changing MTU */
static int
kni_change_mtu(uint8_t port_id, unsigned new_mtu)
{
int ret;
uint16_t nb_rx_queue;
struct rte_eth_conf conf;
if (port_id >= rte_eth_dev_count()) {
RTE_LOG(ERR, KNI, "Invalid port id %d\n", port_id);
return -EINVAL;
}
RTE_LOG(INFO, KNI, "-----------------Change MTU of port %d to %u\n",
port_id, new_mtu);
/* Stop specific port */
rte_eth_dev_stop(port_id);
memcpy(&conf, &port_conf, sizeof(conf));
/* Set new MTU */
if (new_mtu > ETHER_MAX_LEN)
conf.rxmode.jumbo_frame = 1;
else
conf.rxmode.jumbo_frame = 0;
/* mtu + length of header + length of FCS = max pkt length */
conf.rxmode.max_rx_pkt_len =
new_mtu + KNI_ENET_HEADER_SIZE + KNI_ENET_FCS_SIZE;
nb_rx_queue = get_port_n_rx_queues(port_id);
// XXX nb_rx_queue +1 for the kni
ret =
rte_eth_dev_configure(port_id, nb_rx_queue, nb_rx_queue + 1, &conf);
if (ret < 0) {
RTE_LOG(ERR, KNI, "Fail to reconfigure port %d\n", port_id);
return ret;
}
/* Restart specific port */
ret = rte_eth_dev_start(port_id);
if (ret < 0) {
RTE_LOG(ERR, KNI, "Fail to restart port %d\n", port_id);
return ret;
}
return 0;
}
void pcap_close(pcap_t *p)
{
char *deviceName = NULL;
if (p == NULL || p->deviceId < 0 ||
p->deviceId > RTE_MAX_ETHPORTS)
{
snprintf (errbuf_g, PCAP_ERRBUF_SIZE, "Invalid parameter");
return;
}
deviceName = deviceNames[p->deviceId];
debug("Closing device %s\n", deviceName);
rte_eth_dev_stop(p->deviceId);
free(p);
}
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);
}
/* Callback for request of changing MTU */
int
rw_piot_kni_change_mtu(uint8_t port_id, unsigned new_mtu)
{
//int ret;
//struct rte_eth_conf conf;
//struct rte_eth_conf port_conf;
int i;
rw_piot_device_t *rw_piot_dev = NULL;
for (i=0; i<RWPIOT_MAX_DEVICES; i++) {
if ((rw_piot_global_config.device[i].used) && (rw_piot_global_config.device[i].rte_port_id == port_id)) {
rw_piot_dev = &rw_piot_global_config.device[i];
}
}
if (NULL == rw_piot_dev) {
printf("Could not find port, rw_piot_kni_change_mtu\n");
return -1;
}
printf("Change MTU of port %d to %u\n",port_id, new_mtu);
#if 0
/* Stop specific port */
rte_eth_dev_stop(port_id);
/*
* How to get port conf here. This will reset the port conf ??? - TBD
*/
bzero(&port_conf, sizeof(port_conf));
memcpy(&conf, &port_conf, sizeof(conf));
/* Set new MTU */
if (new_mtu > ETHER_MAX_LEN)
conf.rxmode.jumbo_frame = 1;
else
conf.rxmode.jumbo_frame = 0;
/* mtu + length of header + length of FCS = max pkt length */
conf.rxmode.max_rx_pkt_len = new_mtu + KNI_ENET_HEADER_SIZE +
KNI_ENET_FCS_SIZE;
ret = rte_eth_dev_configure(port_id, 1, 1, &conf);
if (ret < 0) {
printf("Fail to reconfigure port %d\n", port_id);
return ret;
}
/* Restart specific port */
ret = rte_eth_dev_start(port_id);
if (ret < 0) {
printf("Fail to restart port %d\n", port_id);
return ret;
}
#endif
/*
* Call the callback to inform upper layer
*/
#if 0
if (rw_piot_dev->kni_change_mtu) {
rw_piot_dev->kni_change_mtu(rw_piot_dev->piot_api_handle, new_mtu);
}
#endif
return 0;
}
/* Init KNI RX queue */
struct vr_dpdk_queue *
vr_dpdk_kni_rx_queue_init(unsigned lcore_id, struct vr_interface *vif,
unsigned host_lcore_id)
{
struct vr_dpdk_lcore *lcore = vr_dpdk.lcores[lcore_id];
const unsigned socket_id = rte_lcore_to_socket_id(lcore_id);
uint8_t port_id = 0;
unsigned vif_idx = vif->vif_idx;
struct vr_dpdk_queue *rx_queue = &lcore->lcore_rx_queues[vif_idx];
struct vr_dpdk_queue_params *rx_queue_params
= &lcore->lcore_rx_queue_params[vif_idx];
if (vif->vif_type == VIF_TYPE_HOST) {
port_id = (((struct vr_dpdk_ethdev *)(vif->vif_bridge->vif_os))->
ethdev_port_id);
}
/* init queue */
rx_queue->rxq_ops = dpdk_knidev_reader_ops;
rx_queue->q_queue_h = NULL;
rx_queue->q_vif = vrouter_get_interface(vif->vif_rid, vif_idx);
/* create the queue */
struct dpdk_knidev_reader_params reader_params = {
.kni = vif->vif_os,
};
rx_queue->q_queue_h = rx_queue->rxq_ops.f_create(&reader_params, socket_id);
if (rx_queue->q_queue_h == NULL) {
RTE_LOG(ERR, VROUTER, " error creating KNI device %s RX queue"
" at eth device %" PRIu8 "\n", vif->vif_name, port_id);
return NULL;
}
/* store queue params */
rx_queue_params->qp_release_op = &dpdk_kni_rx_queue_release;
return rx_queue;
}
/* Release KNI TX queue */
static void
dpdk_kni_tx_queue_release(unsigned lcore_id, struct vr_interface *vif)
{
struct vr_dpdk_lcore *lcore = vr_dpdk.lcores[lcore_id];
struct vr_dpdk_queue *tx_queue = &lcore->lcore_tx_queues[vif->vif_idx];
struct vr_dpdk_queue_params *tx_queue_params
= &lcore->lcore_tx_queue_params[vif->vif_idx];
tx_queue->txq_ops.f_tx = NULL;
rte_wmb();
/* flush and free the queue */
if (tx_queue->txq_ops.f_free(tx_queue->q_queue_h)) {
RTE_LOG(ERR, VROUTER, " error freeing lcore %u KNI device TX queue\n",
lcore_id);
}
/* reset the queue */
vrouter_put_interface(tx_queue->q_vif);
memset(tx_queue, 0, sizeof(*tx_queue));
memset(tx_queue_params, 0, sizeof(*tx_queue_params));
}
/* Init KNI TX queue */
struct vr_dpdk_queue *
vr_dpdk_kni_tx_queue_init(unsigned lcore_id, struct vr_interface *vif,
unsigned host_lcore_id)
{
struct vr_dpdk_lcore *lcore = vr_dpdk.lcores[lcore_id];
const unsigned socket_id = rte_lcore_to_socket_id(lcore_id);
uint8_t port_id = 0;
unsigned vif_idx = vif->vif_idx;
struct vr_dpdk_queue *tx_queue = &lcore->lcore_tx_queues[vif_idx];
struct vr_dpdk_queue_params *tx_queue_params
= &lcore->lcore_tx_queue_params[vif_idx];
struct vr_dpdk_ethdev *ethdev;
if (vif->vif_type == VIF_TYPE_HOST) {
ethdev = vif->vif_bridge->vif_os;
if (ethdev == NULL) {
RTE_LOG(ERR, VROUTER, " error creating KNI device %s TX queue:"
" bridge vif %u ethdev is not initialized\n",
vif->vif_name, vif->vif_bridge->vif_idx);
return NULL;
}
port_id = ethdev->ethdev_port_id;
}
/* init queue */
tx_queue->txq_ops = dpdk_knidev_writer_ops;
tx_queue->q_queue_h = NULL;
tx_queue->q_vif = vrouter_get_interface(vif->vif_rid, vif_idx);
/* create the queue */
struct dpdk_knidev_writer_params writer_params = {
.kni = vif->vif_os,
.tx_burst_sz = VR_DPDK_TX_BURST_SZ,
};
tx_queue->q_queue_h = tx_queue->txq_ops.f_create(&writer_params, socket_id);
if (tx_queue->q_queue_h == NULL) {
RTE_LOG(ERR, VROUTER, " error creating KNI device %s TX queue"
" at eth device %" PRIu8 "\n", vif->vif_name, port_id);
return NULL;
}
/* store queue params */
tx_queue_params->qp_release_op = &dpdk_kni_tx_queue_release;
return tx_queue;
}
/* Change KNI MTU size callback */
static int
dpdk_knidev_change_mtu(uint8_t port_id, unsigned new_mtu)
{
struct vrouter *router = vrouter_get(0);
struct vr_interface *vif;
int i, ret;
uint8_t ethdev_port_id, slave_port_id;
struct vr_dpdk_ethdev *ethdev = NULL;
RTE_LOG(INFO, VROUTER, "Changing eth device %" PRIu8 " MTU to %u\n",
port_id, new_mtu);
if (port_id >= rte_eth_dev_count()) {
RTE_LOG(ERR, VROUTER, "Error changing eth device %"PRIu8" MTU: invalid eth device\n", port_id);
return -EINVAL;
}
/*
* TODO: DPDK bond PMD does not implement mtu_set op, so we need to
* set the MTU manually for all the slaves.
*/
/* Bond vif uses first slave port ID. */
if (router->vr_eth_if) {
ethdev = (struct vr_dpdk_ethdev *)router->vr_eth_if->vif_os;
if (ethdev && ethdev->ethdev_nb_slaves > 0) {
for (i = 0; i < ethdev->ethdev_nb_slaves; i++) {
if (port_id == ethdev->ethdev_slaves[i])
break;
}
/* Clear ethdev if no port match. */
if (i >= ethdev->ethdev_nb_slaves)
ethdev = NULL;
}
}
if (ethdev && ethdev->ethdev_nb_slaves > 0) {
for (i = 0; i < ethdev->ethdev_nb_slaves; i++) {
slave_port_id = ethdev->ethdev_slaves[i];
RTE_LOG(INFO, VROUTER, " changing bond member eth device %" PRIu8
" MTU to %u\n", slave_port_id, new_mtu);
ret = rte_eth_dev_set_mtu(slave_port_id, new_mtu);
if (ret < 0) {
RTE_LOG(ERR, VROUTER, " error changing bond member eth device %" PRIu8
" MTU: %s (%d)\n", slave_port_id, rte_strerror(-ret), -ret);
return ret;
}
}
} else {
ret = rte_eth_dev_set_mtu(port_id, new_mtu);
if (ret < 0) {
RTE_LOG(ERR, VROUTER, "Error changing eth device %" PRIu8
" MTU: %s (%d)\n", port_id, rte_strerror(-ret), -ret);
}
return ret;
}
/* On success, inform vrouter about new MTU */
for (i = 0; i < router->vr_max_interfaces; i++) {
vif = __vrouter_get_interface(router, i);
if (vif && (vif->vif_type == VIF_TYPE_PHYSICAL)) {
ethdev_port_id = (((struct vr_dpdk_ethdev *)(vif->vif_os))->
ethdev_port_id);
if (ethdev_port_id == port_id) {
/* Ethernet header size */
new_mtu += sizeof(struct vr_eth);
if (vr_dpdk.vlan_tag != VLAN_ID_INVALID) {
/* 802.1q header size */
new_mtu += sizeof(uint32_t);
}
vif->vif_mtu = new_mtu;
if (vif->vif_bridge)
vif->vif_bridge->vif_mtu = new_mtu;
}
}
}
return 0;
}
/* Configure KNI state callback */
static int
dpdk_knidev_config_network_if(uint8_t port_id, uint8_t if_up)
{
int ret = 0;
RTE_LOG(INFO, VROUTER, "Configuring eth device %" PRIu8 " %s\n",
port_id, if_up ? "UP" : "DOWN");
if (port_id >= rte_eth_dev_count() || port_id >= RTE_MAX_ETHPORTS) {
RTE_LOG(ERR, VROUTER, "Invalid eth device %" PRIu8 "\n", port_id);
return -EINVAL;
}
if (if_up)
ret = rte_eth_dev_start(port_id);
else
rte_eth_dev_stop(port_id);
if (ret < 0) {
RTE_LOG(ERR, VROUTER, "Configuring eth device %" PRIu8 " UP"
"failed (%d)\n", port_id, ret);
}
return ret;
}
/* Init KNI */
int
vr_dpdk_knidev_init(uint8_t port_id, struct vr_interface *vif)
{
int i;
struct rte_eth_dev_info dev_info;
struct rte_kni_conf kni_conf;
struct rte_kni_ops kni_ops;
struct rte_kni *kni;
struct rte_config *rte_conf = rte_eal_get_configuration();
if (!vr_dpdk.kni_inited) {
/*
* If the host does not support KNIs (i.e. RedHat), we'll get
* a panic here.
*/
rte_kni_init(VR_DPDK_MAX_KNI_INTERFACES);
vr_dpdk.kni_inited = true;
}
/* get eth device info */
memset(&dev_info, 0, sizeof(dev_info));
rte_eth_dev_info_get(port_id, &dev_info);
/* create KNI configuration */
memset(&kni_conf, 0, sizeof(kni_conf));
strncpy(kni_conf.name, (char *)vif->vif_name, sizeof(kni_conf.name) - 1);
kni_conf.addr = dev_info.pci_dev->addr;
kni_conf.id = dev_info.pci_dev->id;
kni_conf.group_id = port_id;
kni_conf.mbuf_size = VR_DPDK_MAX_PACKET_SZ;
/*
* Due to DPDK commit 41a6ebd, now to prevent packet reordering in KNI
* we have to bind KNI kernel thread to a first online unused CPU.
*/
for (i = 0; i < RTE_MAX_LCORE; i++) {
if (lcore_config[i].detected
&& rte_conf->lcore_role[VR_DPDK_FWD_LCORE_ID + i] == ROLE_OFF) {
kni_conf.force_bind = 1;
kni_conf.core_id = i;
RTE_LOG(INFO, VROUTER, " bind KNI kernel thread to CPU %d\n", i);
break;
}
}
/* KNI options
*
* Changing state of the KNI interface can change state of the physical
* interface. This is useful for the vhost, but not for the VLAN
* forwarding interface.
*/
if (vif->vif_type == VIF_TYPE_VLAN) {
memset(&kni_ops, 0, sizeof(kni_ops));
} else {
kni_ops.port_id = port_id;
kni_ops.change_mtu = dpdk_knidev_change_mtu;
kni_ops.config_network_if = dpdk_knidev_config_network_if;
}
/* allocate KNI device */
kni = rte_kni_alloc(vr_dpdk.rss_mempool, &kni_conf, &kni_ops);
if (kni == NULL) {
RTE_LOG(ERR, VROUTER, " error allocation KNI device %s"
" at eth device %" PRIu8 "\n", vif->vif_name, port_id);
return -ENOMEM;
}
/* store pointer to KNI for further use */
vif->vif_os = kni;
/* add interface to the table of KNIs */
for (i = 0; i < VR_DPDK_MAX_KNI_INTERFACES; i++) {
if (vr_dpdk.knis[i] == NULL) {
vr_dpdk.knis[i] = vif->vif_os;
break;
}
}
return 0;
}
static int
test_pmd_ring_pair_create_attach(void)
{
struct rte_eth_stats stats, stats2;
struct rte_mbuf buf, *pbuf = &buf;
struct rte_eth_conf null_conf;
if ((RXTX_PORT2 >= RTE_MAX_ETHPORTS) || (RXTX_PORT3 >= RTE_MAX_ETHPORTS)) {
printf(" TX/RX port exceed max eth ports\n");
return -1;
}
if ((rte_eth_dev_configure(RXTX_PORT2, 1, 1, &null_conf) < 0)
|| (rte_eth_dev_configure(RXTX_PORT3, 1, 1, &null_conf) < 0)) {
printf("Configure failed for RXTX port\n");
return -1;
}
if ((rte_eth_tx_queue_setup(RXTX_PORT2, 0, RING_SIZE, SOCKET0, NULL) < 0)
|| (rte_eth_tx_queue_setup(RXTX_PORT3, 0, RING_SIZE, SOCKET0, NULL) < 0)) {
printf("TX queue setup failed\n");
return -1;
}
if ((rte_eth_rx_queue_setup(RXTX_PORT2, 0, RING_SIZE, SOCKET0, NULL, mp) < 0)
|| (rte_eth_rx_queue_setup(RXTX_PORT3, 0, RING_SIZE, SOCKET0, NULL, mp) < 0)) {
printf("RX queue setup failed\n");
return -1;
}
if ((rte_eth_dev_start(RXTX_PORT2) < 0)
|| (rte_eth_dev_start(RXTX_PORT3) < 0)) {
printf("Error starting RXTX port\n");
return -1;
}
/*
* send and receive 1 packet (RXTX_PORT2 -> RXTX_PORT3)
* and check for stats update
*/
if (rte_eth_tx_burst(RXTX_PORT2, 0, &pbuf, 1) != 1) {
printf("Error sending packet to RXTX port\n");
return -1;
}
if (rte_eth_rx_burst(RXTX_PORT3, 0, &pbuf, 1) != 1) {
printf("Error receiving packet from RXTX port\n");
return -1;
}
rte_eth_stats_get(RXTX_PORT2, &stats);
rte_eth_stats_get(RXTX_PORT3, &stats2);
if (stats.ipackets != 0 || stats.opackets != 1 ||
stats.ibytes != 0 || stats.obytes != 0 ||
stats.ierrors != 0 || stats.oerrors != 0) {
printf("Error: RXTX port stats are not as expected\n");
return -1;
}
if (stats2.ipackets != 1 || stats2.opackets != 0 ||
stats2.ibytes != 0 || stats2.obytes != 0 ||
stats2.ierrors != 0 || stats2.oerrors != 0) {
printf("Error: RXTX port stats are not as expected\n");
return -1;
}
/*
* send and receive 1 packet (RXTX_PORT3 -> RXTX_PORT2)
* and check for stats update
*/
if (rte_eth_tx_burst(RXTX_PORT3, 0, &pbuf, 1) != 1) {
printf("Error sending packet to RXTX port\n");
return -1;
}
if (rte_eth_rx_burst(RXTX_PORT2, 0, &pbuf, 1) != 1) {
printf("Error receiving packet from RXTX port\n");
return -1;
}
rte_eth_stats_get(RXTX_PORT2, &stats);
rte_eth_stats_get(RXTX_PORT3, &stats2);
if (stats.ipackets != 1 || stats.opackets != 1 ||
stats.ibytes != 0 || stats.obytes != 0 ||
stats.ierrors != 0 || stats.oerrors != 0) {
printf("Error: RXTX port stats are not as expected\n");
return -1;
}
if (stats2.ipackets != 1 || stats2.opackets != 1 ||
stats2.ibytes != 0 || stats2.obytes != 0 ||
stats2.ierrors != 0 || stats2.oerrors != 0) {
printf("Error: RXTX port stats are not as expected\n");
return -1;
}
/*
* send and receive 1 packet (RXTX_PORT2 -> RXTX_PORT2)
* and check for stats update
*/
if (rte_eth_tx_burst(RXTX_PORT2, 0, &pbuf, 1) != 1) {
printf("Error sending packet to RXTX port\n");
return -1;
}
if (rte_eth_rx_burst(RXTX_PORT2, 0, &pbuf, 1) != 1) {
printf("Error receiving packet from RXTX port\n");
return -1;
}
rte_eth_stats_get(RXTX_PORT2, &stats);
rte_eth_stats_get(RXTX_PORT3, &stats2);
if (stats.ipackets != 2 || stats.opackets != 2 ||
stats.ibytes != 0 || stats.obytes != 0 ||
stats.ierrors != 0 || stats.oerrors != 0) {
printf("Error: RXTX port stats are not as expected\n");
return -1;
}
if (stats2.ipackets != 1 || stats2.opackets != 1 ||
stats2.ibytes != 0 || stats2.obytes != 0 ||
stats2.ierrors != 0 || stats2.oerrors != 0) {
printf("Error: RXTX port stats are not as expected\n");
return -1;
}
/*
* send and receive 1 packet (RXTX_PORT3 -> RXTX_PORT3)
* and check for stats update
*/
if (rte_eth_tx_burst(RXTX_PORT3, 0, &pbuf, 1) != 1) {
printf("Error sending packet to RXTX port\n");
return -1;
}
if (rte_eth_rx_burst(RXTX_PORT3, 0, &pbuf, 1) != 1) {
printf("Error receiving packet from RXTX port\n");
return -1;
}
rte_eth_stats_get(RXTX_PORT2, &stats);
rte_eth_stats_get(RXTX_PORT3, &stats2);
if (stats.ipackets != 2 || stats.opackets != 2 ||
stats.ibytes != 0 || stats.obytes != 0 ||
stats.ierrors != 0 || stats.oerrors != 0) {
printf("Error: RXTX port stats are not as expected\n");
return -1;
}
if (stats2.ipackets != 2 || stats2.opackets != 2 ||
stats2.ibytes != 0 || stats2.obytes != 0 ||
stats2.ierrors != 0 || stats2.oerrors != 0) {
printf("Error: RXTX port stats are not as expected\n");
return -1;
}
rte_eth_dev_stop(RXTX_PORT2);
rte_eth_dev_stop(RXTX_PORT3);
return 0;
}
static int
test_pmd_perf(void)
{
uint16_t nb_ports, num, nb_lcores, slave_id = (uint16_t)-1;
uint16_t nb_rxd = MAX_TRAFFIC_BURST;
uint16_t nb_txd = MAX_TRAFFIC_BURST;
uint16_t portid;
uint16_t nb_rx_queue = 1, nb_tx_queue = 1;
int socketid = -1;
int ret;
printf("Start PMD RXTX cycles cost test.\n");
signal(SIGUSR1, signal_handler);
signal(SIGUSR2, signal_handler);
nb_ports = rte_eth_dev_count();
if (nb_ports < NB_ETHPORTS_USED) {
printf("At least %u port(s) used for perf. test\n",
NB_ETHPORTS_USED);
return -1;
}
if (nb_ports > RTE_MAX_ETHPORTS)
nb_ports = RTE_MAX_ETHPORTS;
nb_lcores = rte_lcore_count();
memset(lcore_conf, 0, sizeof(lcore_conf));
init_lcores();
init_mbufpool(NB_MBUF);
if (sc_flag == SC_CONTINUOUS) {
nb_rxd = RTE_TEST_RX_DESC_DEFAULT;
nb_txd = RTE_TEST_TX_DESC_DEFAULT;
}
printf("CONFIG RXD=%d TXD=%d\n", nb_rxd, nb_txd);
reset_count();
num = 0;
for (portid = 0; portid < nb_ports; portid++) {
if (socketid == -1) {
socketid = rte_eth_dev_socket_id(portid);
slave_id = alloc_lcore(socketid);
if (slave_id == (uint16_t)-1) {
printf("No avail lcore to run test\n");
return -1;
}
printf("Performance test runs on lcore %u socket %u\n",
slave_id, socketid);
}
if (socketid != rte_eth_dev_socket_id(portid)) {
printf("Skip port %d\n", portid);
continue;
}
/* port configure */
ret = rte_eth_dev_configure(portid, nb_rx_queue,
nb_tx_queue, &port_conf);
if (ret < 0)
rte_exit(EXIT_FAILURE,
"Cannot configure device: err=%d, port=%d\n",
ret, portid);
rte_eth_macaddr_get(portid, &ports_eth_addr[portid]);
printf("Port %u ", portid);
print_ethaddr("Address:", &ports_eth_addr[portid]);
printf("\n");
/* tx queue setup */
ret = rte_eth_tx_queue_setup(portid, 0, nb_txd,
socketid, &tx_conf);
if (ret < 0)
rte_exit(EXIT_FAILURE,
"rte_eth_tx_queue_setup: err=%d, "
"port=%d\n", ret, portid);
/* rx queue steup */
ret = rte_eth_rx_queue_setup(portid, 0, nb_rxd,
socketid, &rx_conf,
mbufpool[socketid]);
if (ret < 0)
rte_exit(EXIT_FAILURE, "rte_eth_rx_queue_setup: err=%d,"
"port=%d\n", ret, portid);
/* Start device */
stop = 0;
ret = rte_eth_dev_start(portid);
if (ret < 0)
rte_exit(EXIT_FAILURE,
"rte_eth_dev_start: err=%d, port=%d\n",
ret, portid);
/* always eanble promiscuous */
rte_eth_promiscuous_enable(portid);
lcore_conf[slave_id].portlist[num++] = portid;
lcore_conf[slave_id].nb_ports++;
}
check_all_ports_link_status(nb_ports, RTE_PORT_ALL);
if (tx_burst == NULL) {
tx_burst = (struct rte_mbuf **)
rte_calloc_socket("tx_buff",
MAX_TRAFFIC_BURST * nb_ports,
sizeof(void *),
RTE_CACHE_LINE_SIZE, socketid);
if (!tx_burst)
return -1;
}
init_traffic(mbufpool[socketid],
tx_burst, MAX_TRAFFIC_BURST * nb_ports);
printf("Generate %d packets @socket %d\n",
MAX_TRAFFIC_BURST * nb_ports, socketid);
if (sc_flag == SC_CONTINUOUS) {
/* do both rxtx by default */
if (NULL == do_measure)
do_measure = measure_rxtx;
rte_eal_remote_launch(main_loop, NULL, slave_id);
if (rte_eal_wait_lcore(slave_id) < 0)
return -1;
} else if (sc_flag == SC_BURST_POLL_FIRST ||
sc_flag == SC_BURST_XMIT_FIRST)
if (exec_burst(sc_flag, slave_id) < 0)
return -1;
/* port tear down */
for (portid = 0; portid < nb_ports; portid++) {
if (socketid != rte_eth_dev_socket_id(portid))
continue;
rte_eth_dev_stop(portid);
}
return 0;
}
