--- /dev/null
+/*
+// Copyright (c) 2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+#include <interface.h>
+#include <rte_byteorder.h>
+#include <lib_arp.h>
+#include <tsx.h>
+
+interface_main_t ifm;
+int USE_RTM_LOCKS = 0;
+rte_rwlock_t rwlock;
+uint8_t ifm_debug;
+static int prev_state;
+
+void config_ifm_debug(int dbg, int flag)
+{
+ switch (dbg) {
+ case IFM_DEBUG_CONFIG:
+ if (flag) {
+ ifm_debug |= IFM_DEBUG_CONFIG;
+ } else {
+ ifm_debug &= ~IFM_DEBUG_CONFIG;
+ }
+ break;
+ case IFM_DEBUG_RXTX:
+ if (flag) {
+ ifm_debug |= IFM_DEBUG_RXTX;
+ } else {
+ ifm_debug &= ~IFM_DEBUG_RXTX;
+ }
+ break;
+ case IFM_DEBUG_LOCKS:
+ if (flag) {
+ ifm_debug |= IFM_DEBUG_LOCKS;
+ } else {
+ ifm_debug &= ~IFM_DEBUG_LOCKS;
+ }
+ break;
+ case IFM_DEBUG:
+ if (flag) {
+ ifm_debug |= IFM_DEBUG;
+ } else {
+ ifm_debug &= ~IFM_DEBUG;
+ }
+ break;
+ }
+}
+
+void ifm_init(void)
+{
+ int i = 0;
+ config_ifm_debug(IFM_DEBUG_CONFIG, 1);
+ if (can_use_intel_core_4th_gen_features()) {
+ if (ifm_debug & IFM_DEBUG_CONFIG)
+ RTE_LOG(INFO, IFM, "TSX not currently supported...\n\r");
+ USE_RTM_LOCKS = 0;
+ } else {
+ if (ifm_debug & IFM_DEBUG_CONFIG)
+ RTE_LOG(INFO, IFM, "TSX not supported\n\r");
+ USE_RTM_LOCKS = 0;
+ }
+ if (USE_RTM_LOCKS)
+ rtm_init();
+ else
+ rte_rwlock_init(&rwlock);
+
+ for (i = 0; i < IFM_MAX_PORTARR_SZ; i++) {
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Acquiring WR lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_lock();
+ else
+ rte_rwlock_write_lock(&rwlock);
+
+ ifm.port_list[i] = NULL;
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing WR lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_unlock();
+ else
+ rte_rwlock_write_unlock(&rwlock);
+ }
+ ifm.nport_intialized = rte_eth_dev_count();
+ ifm.nport_configured = 0;
+ RTE_LOG(INFO, IFM, "IFM_INIT: Number of ports initialized during "
+ "PCI probing %u.\n\r", ifm.nport_intialized);
+}
+
+void ifm_remove_port_details(uint8_t portid)
+{
+ if (ifm.port_list[portid] != NULL) {
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Acquiring lock %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_lock();
+ else
+ rte_rwlock_write_lock(&rwlock);
+ l2_phy_interface_t *port = ifm.port_list[portid];
+ ifm.port_list[portid] = NULL;
+ if (ifm_debug & IFM_DEBUG_CONFIG)
+ RTE_LOG(INFO, IFM, "%s: NULL set for port %u\n\r",
+ __FUNCTION__, portid);
+ rte_free(port);
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+
+ if (USE_RTM_LOCKS)
+ rtm_unlock();
+ else
+ rte_rwlock_write_unlock(&rwlock);
+ } else {
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM,
+ "%s: Failed to remove port details.Port %u info"
+ " is already Null.\n\r", __FUNCTION__, portid);
+ }
+}
+
+l2_phy_interface_t *ifm_get_port(uint8_t port_id)
+{
+ l2_phy_interface_t *port = NULL;
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Acquiring lock @ %d\n\r", __FUNCTION__,
+ __LINE__);
+
+ if (USE_RTM_LOCKS)
+ rtm_lock();
+ else
+ rte_rwlock_read_lock(&rwlock);
+
+ port = ifm.port_list[port_id];
+
+ if (port == NULL) {
+ /*RTE_LOG(ERR, IFM, "%s: Port %u info not found... configure it first.\n\r",
+ __FUNCTION__, port_id);
+ */
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing RD lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_unlock();
+ else
+ rte_rwlock_read_unlock(&rwlock);
+ return NULL;
+ }
+ if (port->pmdid == port_id) {
+ /*RTE_LOG(INFO, IFM, "%s: Port %u found....\n\r",
+ __FUNCTION__, port_id); */
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+
+ if (USE_RTM_LOCKS)
+ rtm_unlock();
+ else
+ rte_rwlock_read_unlock(&rwlock);
+ return port;
+ } else {
+
+/* RTE_LOG(INFO, IFM,"%s: Mismatch given port %u port in loc %u\n\r",__FUNCTION__,port_id,
+ ifm.port_list[port_id]->pmdid);
+*/
+ }
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing lock @ %d\n\r", __FUNCTION__,
+ __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_unlock();
+ else
+ rte_rwlock_read_unlock(&rwlock);
+ return NULL;
+}
+
+l2_phy_interface_t *ifm_get_first_port(void)
+{
+ l2_phy_interface_t *port = NULL;
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Acquiring lock @ %d\n\r", __FUNCTION__,
+ __LINE__);
+
+ if (USE_RTM_LOCKS)
+ rtm_lock();
+ else
+ rte_rwlock_read_lock(&rwlock);
+ port = ifm.port_list[0];
+ if (port == NULL) {
+ /*RTE_LOG(ERR, IFM, "%s: Port info not found... configure it first.\n\r",
+ __FUNCTION__); */
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_unlock();
+ else
+ rte_rwlock_read_unlock(&rwlock);
+ return NULL;
+ }
+ /*RTE_LOG(ERR, IFM, "%s: Port %u info is found...%p\n\r",
+ __FUNCTION__, port->pmdid, port); */
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing lock @ %d\n\r", __FUNCTION__,
+ __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_unlock();
+ else
+ rte_rwlock_read_unlock(&rwlock);
+ return port;
+}
+
+l2_phy_interface_t *ifm_get_next_port(uint8_t port_id)
+{
+ l2_phy_interface_t *port = NULL;
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Acquiring lock @ %d\n\r", __FUNCTION__,
+ __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_lock();
+ else
+ rte_rwlock_read_lock(&rwlock);
+ port = ifm.port_list[port_id + 1];
+ if (port == NULL) {
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_unlock();
+ else
+ rte_rwlock_read_unlock(&rwlock);
+ return NULL;
+ }
+ /*RTE_LOG(ERR, IFM, "%s: Port %u info is found...\n\r",
+ __FUNCTION__, port_id); */
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing lock @ %d\n\r", __FUNCTION__,
+ __LINE__);
+
+ if (USE_RTM_LOCKS)
+ rtm_unlock();
+ else
+ rte_rwlock_read_unlock(&rwlock);
+ return port;
+}
+
+l2_phy_interface_t *ifm_get_port_by_name(const char *name)
+{
+ l2_phy_interface_t *port = NULL;
+ int i;
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Acquiring lock @ %d\n\r", __FUNCTION__,
+ __LINE__);
+
+ if (USE_RTM_LOCKS)
+ rtm_lock();
+ else
+ rte_rwlock_read_lock(&rwlock);
+ for (i = 0; i < RTE_MAX_ETHPORTS && ifm.port_list[i]; i++) {
+ port = ifm.port_list[i];
+ if (strcmp(name, port->ifname) == 0) {
+ if (ifm_debug & IFM_DEBUG_CONFIG)
+ RTE_LOG(INFO, IFM, "FOUND! port %u %s\n\r",
+ port->pmdid, port->ifname);
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM,
+ "%s: Releasing lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_unlock();
+ else
+ rte_rwlock_read_unlock(&rwlock);
+ return port;
+ }
+ }
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing lock @ %d\n\r", __FUNCTION__,
+ __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_unlock();
+ else
+ rte_rwlock_read_unlock(&rwlock);
+ return NULL;
+}
+
+void lsi_event_callback(uint8_t port_id, enum rte_eth_event_type type,
+ void *param)
+{
+ struct rte_eth_link link;
+ l2_phy_interface_t *port;
+ int nclients = ifm.nclient;
+ int i;
+
+ RTE_SET_USED(param);
+ RTE_SET_USED(type);
+
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Acquiring WR lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS) {
+ rtm_lock();
+ } else {
+ rte_rwlock_write_lock(&rwlock);
+ }
+ rte_eth_link_get(port_id, &link);
+ for (i = 0; i < nclients; i++)
+ ifm.if_client[i].cb_linkupdate(port_id, link.link_status);
+ port = ifm.port_list[port_id];
+ if (port == NULL) {
+ RTE_LOG(ERR, IFM,
+ "%s: Port %u info not found... configure it first.\n\r",
+ __FUNCTION__, port_id);
+ }
+ if (port != NULL && port->pmdid == port_id) {
+ if (link.link_status) {
+ port->link_status = IFM_ETH_LINK_UP;
+ port->link_speed = link.link_speed;
+ port->link_duplex = link.link_duplex;
+ RTE_LOG(INFO, IFM,
+ "EVENT-- PORT %u Link UP - Speed %u Mbps - %s.\n",
+ port_id, (unsigned)link.link_speed,
+ (link.link_duplex ==
+ ETH_LINK_FULL_DUPLEX) ? ("full-duplex")
+ : ("half-duplex"));
+ if (port->flags & IFM_MASTER) {
+ port->flags |= IFM_BONDED;
+ port->bond_config->active_slave_count =
+ rte_eth_bond_active_slaves_get(port->pmdid,
+ port->
+ bond_config->
+ active_slaves,
+ RTE_MAX_ETHPORTS);
+ struct ether_addr new_mac;
+ rte_eth_macaddr_get(port->pmdid,
+ (struct ether_addr *)
+ &new_mac);
+ if (memcmp
+ (&new_mac, port->macaddr,
+ sizeof(struct ether_addr))) {
+ RTE_LOG(INFO, IFM,
+ "Bond port %u MAC has changed.\n\r",
+ port->pmdid);
+ } else {
+ RTE_LOG(INFO, IFM,
+ "Bond port %u MAC remains same\n\r",
+ port->pmdid);
+ }
+ }
+ if (port->flags & IFM_SLAVE) {
+ uint8_t master_portid =
+ port->bond_config->bond_portid;
+ struct rte_eth_link linkstatus;
+ rte_eth_link_get(master_portid, &linkstatus);
+ RTE_LOG(INFO, IFM, "Port %u 's Master(%u) status is %u\n\r", port_id,
+ master_portid, linkstatus.link_status);
+ }
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM,
+ "%s: Releasing WR lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+
+ if (USE_RTM_LOCKS) {
+ rtm_unlock();
+ } else {
+ rte_rwlock_write_unlock(&rwlock);
+ }
+ if (port->ipv4_list != NULL) {
+ if (ifm_debug & IFM_DEBUG_CONFIG)
+ RTE_LOG(INFO, IFM,
+ "Sending garp on port %u\n\r",
+ port->pmdid);
+ if (!prev_state) {
+ send_gratuitous_arp(port);
+ prev_state = 1;
+ }
+ }
+#if 0
+ else {
+ if (ifm_debug & IFM_DEBUG_CONFIG)
+ RTE_LOG(INFO, IFM,
+ "IP is not enabled on port %u, not sending GARP\n\r",
+ port->pmdid);
+ }
+#endif
+ } else {
+ if (port->flags & IFM_MASTER) {
+ port->flags &= ~IFM_BONDED;
+ //RTE_LOG(INFO, IFM, "IFM_MASTER port, resetting IFM_BONDED. %u\n\r", port->flags);
+ }
+ port->link_status = IFM_ETH_LINK_DOWN;
+ RTE_LOG(INFO, IFM, "EVENT-- PORT %u is Link DOWN.\n",
+ port_id);
+ if (port->flags & IFM_SLAVE) {
+ struct rte_eth_link linkstatus;
+ uint8_t master_portid =
+ port->bond_config->bond_portid;
+ rte_eth_link_get_nowait(master_portid,
+ &linkstatus);
+ RTE_LOG(INFO, IFM,
+ "Port %u 's Master(%u) status is %u\n\r",
+ port_id, master_portid,
+ linkstatus.link_status);
+ }
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM,
+ "%s: Releasing WR lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS) {
+ rtm_unlock();
+ } else {
+ rte_rwlock_write_unlock(&rwlock);
+ }
+ prev_state = 0;
+ }
+ }
+ //print_interface_details();
+}
+
+void ifm_update_linkstatus(uint8_t port_id, uint16_t linkstatus)
+{
+ struct rte_eth_link link;
+ l2_phy_interface_t *port;
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Acquiring lock @ %d\n\r", __FUNCTION__,
+ __LINE__);
+
+ if (USE_RTM_LOCKS) {
+ rtm_lock();
+ } else {
+ rte_rwlock_write_lock(&rwlock);
+ }
+ port = ifm.port_list[port_id];
+
+ if (port == NULL) {
+ RTE_LOG(ERR, IFM,
+ "%s: Port %u info not found... configure it first.\n\r",
+ __FUNCTION__, port_id);
+ }
+ if (port != NULL && port->pmdid == port_id) {
+ rte_eth_link_get(port_id, &link);
+ if (linkstatus == IFM_ETH_LINK_UP) {
+ port->admin_status = IFM_ETH_LINK_UP;
+ if(!link.link_status) {
+ if (rte_eth_dev_set_link_up(port_id) < 0) {
+ RTE_LOG(INFO, IFM,
+ "%s:Port %u admin up is unsuccessful\n\r",
+ __FUNCTION__, port->pmdid);
+ } else {
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM,
+ "%s: Releasing lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+
+ if (USE_RTM_LOCKS) {
+ rtm_unlock();
+ } else {
+ rte_rwlock_write_unlock(&rwlock);
+ }
+ if (ifm_debug & IFM_DEBUG_CONFIG)
+ RTE_LOG(INFO, IFM,
+ "%s:Port %u admin up...\n\r",
+ __FUNCTION__, port->pmdid);
+ send_gratuitous_arp(port);
+ return;
+ }
+ }
+ } else if (linkstatus == IFM_ETH_LINK_DOWN)
+ {
+ int status;
+ port->admin_status = IFM_ETH_LINK_DOWN;
+ /* need to check the following if */
+ if(link.link_status) {
+ status = rte_eth_dev_set_link_down(port_id);
+ if (status < 0)
+ {
+ rte_panic("(%" PRIu32 "): PMD set link down error %"
+ PRId32 "\n", port_id, status);
+ }
+ }
+ }
+ }
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing lock @ %d\n\r", __FUNCTION__,
+ __LINE__);
+
+ if (USE_RTM_LOCKS) {
+ rtm_unlock();
+ } else {
+ rte_rwlock_write_unlock(&rwlock);
+ }
+}
+
+void ifm_set_l2_interface_mtu(uint8_t port_id, uint16_t mtu)
+{
+ int ret;
+ l2_phy_interface_t *port;
+ port = ifm.port_list[port_id];
+ if (port == NULL) {
+ RTE_LOG(ERR, IFM,
+ "%s: Port %u info not found... configure it first.\n\r",
+ __FUNCTION__, port_id);
+ }
+
+ if (port != NULL && port->pmdid == port_id) {
+ ret = rte_eth_dev_set_mtu(port_id, mtu);
+ if (ret != 0)
+ RTE_LOG(INFO, IFM,
+ "set_l2_interface_mtu: Set MTU failed. ret=%d\n",
+ ret);
+ else {
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM,
+ "%s: Acquiring lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+
+ if (USE_RTM_LOCKS) {
+ rtm_lock();
+ } else {
+ rte_rwlock_write_lock(&rwlock);
+ }
+ port->mtu = mtu;
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM,
+ "%s: Releasing lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+
+ if (USE_RTM_LOCKS) {
+ rtm_unlock();
+ } else {
+ rte_rwlock_write_unlock(&rwlock);
+ }
+ return;
+ }
+ }
+}
+
+void ifm_set_port_promisc(uint8_t port_id, uint8_t enable)
+{
+ l2_phy_interface_t *port;
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Acquiring WR lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS) {
+ rtm_lock();
+ } else {
+ rte_rwlock_write_lock(&rwlock);
+ }
+ port = ifm.port_list[port_id];
+ if (port == NULL) {
+ RTE_LOG(ERR, IFM,
+ "%s: Port %u info not found... configure it first.\n\r",
+ __FUNCTION__, port_id);
+ }
+ if (port != NULL && port->pmdid == port_id) {
+ if (enable == 1) {
+ rte_eth_promiscuous_enable(port_id);
+ port->promisc = 1;
+ } else {
+ rte_eth_promiscuous_disable(port_id);
+ port->promisc = 0;
+ }
+ }
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing WR lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS) {
+ rtm_unlock();
+ } else {
+ rte_rwlock_write_unlock(&rwlock);
+ }
+}
+
+int32_t ifm_get_nactive_ports(void)
+{
+ return ifm.nport_configured;
+}
+
+int32_t ifm_get_nports_initialized(void)
+{
+ return ifm.nport_intialized;
+}
+
+uint16_t ifm_receive_bulk_pkts(uint8_t port_id, uint16_t qid,
+ struct rte_mbuf **rx_pkts)
+{
+ uint64_t no_of_rcvd_pkt;
+ no_of_rcvd_pkt =
+ rte_eth_rx_burst(port_id, qid, rx_pkts, IFM_BURST_SIZE);
+ if (ifm_debug & IFM_DEBUG_RXTX)
+ RTE_LOG(INFO, IFM,
+ "ifm_receive_bulk_pkts: port_id %u no_of_rcvd_pkt %lu\n\r",
+ port_id, no_of_rcvd_pkt);
+ return no_of_rcvd_pkt;
+}
+
+uint16_t ifm_transmit_bulk_pkts(l2_phy_interface_t *port,
+ struct rte_mbuf **tx_pkts, uint64_t npkts)
+{
+ uint32_t burst_tx_delay_time = IFM_BURST_TX_WAIT_US;
+ uint32_t burst_tx_retry_num = IFM_BURST_TX_RETRIES;
+ uint32_t retry;
+ uint32_t no_of_tx_pkt;
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Acquiring RD lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS) {
+ rtm_lock();
+ } else {
+ rte_rwlock_read_lock(&rwlock);
+ }
+ no_of_tx_pkt = rte_eth_tx_burst(port->pmdid, IFM_TX_DEFAULT_Q, tx_pkts,
+ npkts);
+ if (unlikely(no_of_tx_pkt < npkts)) {
+ retry = 0;
+ while (no_of_tx_pkt < IFM_BURST_SIZE
+ && retry++ < burst_tx_retry_num) {
+ rte_delay_us(burst_tx_delay_time);
+ no_of_tx_pkt =
+ rte_eth_tx_burst(port->pmdid, IFM_TX_DEFAULT_Q,
+ &tx_pkts[no_of_tx_pkt],
+ IFM_BURST_SIZE - no_of_tx_pkt);
+ }
+ }
+ if (ifm_debug & IFM_DEBUG_RXTX)
+ RTE_LOG(INFO, IFM,
+ "ifm_transmit_bulk_pkts: no_of_tx_pkt %u\n\r",
+ no_of_tx_pkt);
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing RD lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS) {
+ rtm_unlock();
+ } else {
+ rte_rwlock_read_unlock(&rwlock);
+ }
+ return no_of_tx_pkt;
+}
+
+int ifm_transmit_single_pkt(l2_phy_interface_t *port, struct rte_mbuf *tx_pkts)
+{
+ uint64_t tx_npkts = 0;
+ if (tx_pkts == NULL || port == NULL) {
+ RTE_LOG(INFO, IFM,
+ "ifm_transmit_single_pkt: tx_pkts and port are NULL ");
+ return IFM_FAILURE;
+ }
+ if (ifm_debug & IFM_DEBUG_RXTX)
+ RTE_LOG(INFO, IFM,
+ "ifm_transmit_single_pkt: port->pmdid %u\n\r",
+ port->pmdid);
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Acquiring RD lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+
+ if (USE_RTM_LOCKS) {
+ rtm_lock();
+ } else {
+ rte_rwlock_read_lock(&rwlock);
+ }
+ tx_npkts =
+ rte_eth_tx_buffer(port->pmdid, IFM_TX_DEFAULT_Q, port->tx_buffer,
+ tx_pkts);
+ if (ifm_debug & IFM_DEBUG_RXTX)
+ RTE_LOG(INFO, IFM,
+ "ifm_transmit_single_pkt: port->pmdid %u No of packets buffered %lu\n\r",
+ port->pmdid, tx_npkts);
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing RW lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+
+ if (USE_RTM_LOCKS) {
+ rtm_unlock();
+ } else {
+ rte_rwlock_read_unlock(&rwlock);
+ }
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Acquiring WR lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+
+ if (USE_RTM_LOCKS) {
+ rtm_lock();
+ } else {
+ rte_rwlock_write_lock(&rwlock);
+ }
+ port->n_txpkts +=
+ rte_eth_tx_buffer_flush(port->pmdid, IFM_TX_DEFAULT_Q,
+ port->tx_buffer);
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing WR lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+
+ if (USE_RTM_LOCKS) {
+ rtm_unlock();
+ } else {
+ rte_rwlock_write_unlock(&rwlock);
+ }
+ if (ifm_debug & IFM_DEBUG_RXTX)
+ RTE_LOG(INFO, IFM,
+ "ifm_transmit_single_pkt: no of pkts flushed %lu\n\r",
+ port->n_txpkts);
+ return tx_npkts;
+}
+
+int16_t ifm_add_ipv4_port(uint8_t port_id, uint32_t ipaddr, uint32_t addrlen)
+{
+ l2_phy_interface_t *port;
+ ipv4list_t *ipconf;
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Acquiring lock @ %d\n\r", __FUNCTION__,
+ __LINE__);
+
+ if (USE_RTM_LOCKS) {
+ rtm_lock();
+ } else {
+ rte_rwlock_write_lock(&rwlock);
+ }
+ port = ifm.port_list[port_id];
+ if (port == NULL) {
+ RTE_LOG(ERR, IFM,
+ "%s: Port %u info not found... configure it first.\n\r",
+ __FUNCTION__, port_id);
+ }
+ if (port != NULL && port->pmdid == port_id) {
+ ipconf = (ipv4list_t *) rte_zmalloc(NULL, sizeof(ipv4list_t),
+ RTE_CACHE_LINE_SIZE);
+ if (ipconf != NULL) {
+ ipconf->next = NULL;
+ //ipconf->ipaddr = rte_bswap32(ipaddr);
+ ipconf->ipaddr = ipaddr;
+ ipconf->port = port;
+ ipconf->addrlen = addrlen;
+ if (port->ipv4_list == NULL)
+ port->flags |= IFM_IPV4_ENABLED;
+ ipconf->next = (ipv4list_t *) port->ipv4_list;
+ port->ipv4_list = (ipv4list_t *) ipconf;
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM,
+ "%s: Releasing lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+
+ if (USE_RTM_LOCKS) {
+ rtm_unlock();
+ } else {
+ rte_rwlock_write_unlock(&rwlock);
+ }
+ return 0;
+ }
+ }
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing lock @ %d\n\r", __FUNCTION__,
+ __LINE__);
+
+ if (USE_RTM_LOCKS) {
+ rtm_unlock();
+ } else {
+ rte_rwlock_write_unlock(&rwlock);
+ }
+ return -1;
+}
+
+int16_t ifm_remove_ipv4_port(uint8_t port_id, uint32_t ipaddr,
+ uint32_t addrlen)
+{
+ l2_phy_interface_t *port;
+ ipv4list_t *iplist, *previplist = NULL;
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Acquiring lock @ %d\n\r", __FUNCTION__,
+ __LINE__);
+
+ if (USE_RTM_LOCKS) {
+ rtm_lock();
+ } else {
+ rte_rwlock_write_lock(&rwlock);
+ }
+ port = ifm.port_list[port_id];
+ if (port == NULL) {
+ RTE_LOG(ERR, IFM,
+ "%s: Port %u info not found... configure it first.\n\r",
+ __FUNCTION__, port_id);
+ }
+ if (port != NULL && port->pmdid == port_id) {
+ if (port->ipv4_list == NULL) {
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM,
+ "%s: Releasing lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+
+ if (USE_RTM_LOCKS) {
+ rtm_unlock();
+ } else {
+ rte_rwlock_write_unlock(&rwlock);
+ }
+ return -1;
+ }
+ iplist = (ipv4list_t *) port->ipv4_list;
+ while (iplist != NULL) {
+ if (addrlen == iplist->addrlen &&
+ memcpy(&iplist->ipaddr, &ipaddr, addrlen)) {
+ if (iplist == port->ipv4_list) {
+ port->ipv4_list = iplist->next;
+ } else {
+ if (previplist != NULL)
+ previplist->next = iplist->next;
+ }
+ port->flags &= ~IFM_IPV4_ENABLED;
+ rte_free(iplist);
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM,
+ "%s: Releasing lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+
+ if (USE_RTM_LOCKS) {
+ rtm_unlock();
+ } else {
+ rte_rwlock_write_unlock(&rwlock);
+ }
+ return 0;
+ } else {
+ previplist = iplist;
+ iplist = iplist->next;
+ }
+ }
+ }
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing lock @ %d\n\r", __FUNCTION__,
+ __LINE__);
+
+ if (USE_RTM_LOCKS) {
+ rtm_unlock();
+ } else {
+ rte_rwlock_write_unlock(&rwlock);
+ }
+ return -1;
+}
+
+int8_t ifm_add_ipv6_port(uint8_t port_id, uint8_t ip6addr[], uint32_t addrlen)
+{
+ l2_phy_interface_t *port;
+ ipv6list_t *ip6conf;
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Acquiring lock @ %d\n\r", __FUNCTION__,
+ __LINE__);
+
+ if (USE_RTM_LOCKS) {
+ rtm_lock();
+ } else {
+ rte_rwlock_write_lock(&rwlock);
+ }
+ port = ifm.port_list[port_id];
+ if (port == NULL) {
+ RTE_LOG(ERR, IFM,
+ "%s: Port %u info not found... configure it first.\n\r",
+ __FUNCTION__, port_id);
+ }
+ if (port != NULL && port->pmdid == port_id) {
+ ip6conf = (ipv6list_t *) rte_zmalloc(NULL, sizeof(ipv6list_t),
+ RTE_CACHE_LINE_SIZE);
+ if (ip6conf != NULL) {
+ ip6conf->next = NULL;
+ memcpy(ip6conf->ipaddr, ip6addr, IFM_IPV6_ADDR_SIZE);
+ ip6conf->port = port;
+ ip6conf->addrlen = addrlen;
+
+ if (port->ipv6_list == NULL) {
+ port->flags |= IFM_IPV6_ENABLED;
+ }
+ ip6conf->next = (ipv6list_t *) port->ipv6_list;
+ port->ipv6_list = (ipv6list_t *) ip6conf;
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM,
+ "%s: Releasing lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+
+ if (USE_RTM_LOCKS) {
+ rtm_unlock();
+ } else {
+ rte_rwlock_write_unlock(&rwlock);
+ }
+ return 0;
+ }
+ }
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing lock @ %d\n\r", __FUNCTION__,
+ __LINE__);
+
+ if (USE_RTM_LOCKS) {
+ rtm_unlock();
+ } else {
+ rte_rwlock_write_unlock(&rwlock);
+ }
+ return -1;
+}
+
+int16_t ifm_remove_ipv6_port(uint8_t port_id, uint32_t ip6addr,
+ uint32_t addrlen)
+{
+ l2_phy_interface_t *port;
+ ipv6list_t *ip6list, *previp6list = NULL;
+
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Acquiring lock @ %d\n\r", __FUNCTION__,
+ __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_lock();
+ else
+ rte_rwlock_write_lock(&rwlock);
+ port = ifm.port_list[port_id];
+ if (port == NULL) {
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS) {
+ rtm_unlock();
+ } else {
+ rte_rwlock_write_unlock(&rwlock);
+ }
+ RTE_LOG(ERR, IFM,
+ "%s: Port %u info not found... configure it first.\n\r",
+ __FUNCTION__, port_id);
+ }
+ if (port != NULL && port->pmdid == port_id) {
+ if (port->ipv6_list == NULL) {
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM,
+ "%s: Releasing lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+
+ if (USE_RTM_LOCKS) {
+ rtm_unlock();
+ } else {
+ rte_rwlock_write_unlock(&rwlock);
+ }
+ return -1;
+ }
+ ip6list = (ipv6list_t *) port->ipv6_list;
+ while (ip6list != NULL) {
+ if (addrlen == ip6list->addrlen &&
+ memcpy(&ip6list->ipaddr, &ip6addr, addrlen)) {
+ if (ip6list == port->ipv6_list) {
+ port->ipv6_list = ip6list->next;
+ } else {
+ if (previp6list != NULL)
+ previp6list->next =
+ ip6list->next;
+ }
+ port->flags &= ~IFM_IPV6_ENABLED;
+ rte_free(ip6list);
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM,
+ "%s: Releasing lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+
+ if (USE_RTM_LOCKS) {
+ rtm_unlock();
+ } else {
+ rte_rwlock_write_unlock(&rwlock);
+ }
+ return 0;
+ } else {
+ previp6list = ip6list;
+ ip6list = ip6list->next;
+ }
+ }
+ }
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing lock @ %d\n\r", __FUNCTION__,
+ __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_unlock();
+ else
+ rte_rwlock_write_unlock(&rwlock);
+ return -1;
+}
+
+int32_t ifm_chk_port_ipv4_enabled(uint8_t port_id)
+{
+ l2_phy_interface_t *port;
+
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Acquiring RD lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_lock();
+ else
+ rte_rwlock_read_lock(&rwlock);
+ port = ifm.port_list[port_id];
+ if (port == NULL) {
+ RTE_LOG(ERR, IFM,
+ "%s: Port %u info not found... configure it first.\n\r",
+ __FUNCTION__, port_id);
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_unlock();
+ else
+ rte_rwlock_read_unlock(&rwlock);
+ return IFM_FAILURE;
+ }
+ if ((port->flags & IFM_IPV4_ENABLED) == 0) {
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_unlock();
+ else
+ rte_rwlock_read_unlock(&rwlock);
+ return 0;
+ } else {
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_unlock();
+ else
+ rte_rwlock_read_unlock(&rwlock);
+ return 1;
+ }
+}
+
+int32_t ifm_chk_port_ipv6_enabled(uint8_t port_id)
+{
+ l2_phy_interface_t *port;
+
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Acquiring RD lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_lock();
+ else
+ rte_rwlock_read_lock(&rwlock);
+
+ port = ifm.port_list[port_id];
+ if (port == NULL) {
+ if (ifm_debug & IFM_DEBUG)
+ RTE_LOG(ERR, IFM, "%s: Port %u info not found..."
+ " configure it first.\n\r",
+ __FUNCTION__, port_id);
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing RD lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_unlock();
+ else
+ rte_rwlock_read_unlock(&rwlock);
+ return IFM_FAILURE;
+ }
+ if ((port->flags & IFM_IPV6_ENABLED) == 0) {
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing RD lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_unlock();
+ else
+ rte_rwlock_read_unlock(&rwlock);
+ return 0;
+ } else {
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing RD lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_unlock();
+ else
+ rte_rwlock_read_unlock(&rwlock);
+ return 1;
+ }
+}
+
+void ifm_register_for_linkupdate(uint32_t clientid,
+ void (*cb_linkupdate) (uint8_t, unsigned int))
+{
+ ifm.if_client[ifm.nclient].cb_linkupdate = cb_linkupdate;
+ ifm.if_client[ifm.nclient].clientid = clientid;
+ ifm.nclient++;
+}
+
+int ifm_port_setup(uint8_t port_id, port_config_t *pconfig)
+{
+ int status, sock;
+ char buf[12];
+ struct rte_eth_dev_info dev_info;
+ struct rte_eth_link linkstatus;
+ l2_phy_interface_t *port = NULL;
+
+ if (!ifm.nport_intialized) {
+ RTE_LOG(ERR, IFM, "%s: Failed to configure port %u. 0 ports"
+ "were intialized during PCI probe...\n\r",
+ __FUNCTION__, port_id);
+ return IFM_FAILURE;
+ }
+ if (ifm_debug & IFM_DEBUG_CONFIG)
+ RTE_LOG(INFO, IFM, "%s: Configuring port %u with "
+ "nrxq: %u, ntxq: %u\n\r", __FUNCTION__,
+ port_id, pconfig->nrx_queue, pconfig->ntx_queue);
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Acquiring WR lock1 @ %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_lock();
+ else
+ rte_rwlock_write_lock(&rwlock);
+
+ if (ifm.port_list[port_id] == NULL) {
+ ifm.port_list[port_id] =
+ (l2_phy_interface_t *) rte_zmalloc(NULL,
+ sizeof
+ (l2_phy_interface_t),
+ RTE_CACHE_LINE_SIZE);
+ ifm.port_list[port_id]->pmdid = port_id;
+ }
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing WR lock1 @ %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_unlock();
+ else
+ rte_rwlock_write_unlock(&rwlock);
+
+ rte_eth_link_get(port_id, &linkstatus);
+ if (linkstatus.link_status) {
+ if (ifm_debug & IFM_DEBUG_CONFIG) {
+ RTE_LOG(INFO, IFM, "%s: %u is up.Stop it before"
+ " reconfiguring.\n\r", __FUNCTION__, port_id);
+ }
+ rte_eth_dev_stop(port_id);
+ }
+ /*Configure an Ethernet device. rets 0 on success queue */
+ status = rte_eth_dev_configure(port_id, pconfig->nrx_queue,
+ pconfig->ntx_queue, &pconfig->port_conf);
+ if (status < 0) {
+ ifm_remove_port_details(port_id);
+ RTE_LOG(ERR, IFM, "%s: rte_eth_dev_configure is failed"
+ "for port %u.\n\r", __FUNCTION__, port_id);
+ return IFM_FAILURE;
+ }
+ status = rte_eth_dev_callback_register(port_id,
+ RTE_ETH_EVENT_INTR_LSC,
+ lsi_event_callback, NULL);
+ if (status < 0) {
+ ifm_remove_port_details(port_id);
+ RTE_LOG(ERR, IFM, "%s: rte_eth_dev_callback_register()"
+ " failed for port %u.\n\r", __FUNCTION__, port_id);
+ return IFM_FAILURE;
+ }
+ /*promiscuous mode is enabled set it */
+ if (pconfig->promisc)
+ rte_eth_promiscuous_enable(port_id);
+
+ sock = rte_eth_dev_socket_id(port_id);
+ if (sock == -1)
+ RTE_LOG(ERR, IFM, "%s: Warning: rte_eth_dev_socket_id,"
+ " port_id value is"
+ "out of range %u\n\r", __FUNCTION__, port_id);
+ /*Port initialization */
+ int ntxqs;
+ for (ntxqs = 0; ntxqs < pconfig->ntx_queue; ntxqs++) {
+ status = rte_eth_tx_queue_setup(port_id, ntxqs,
+ IFM_TX_DESC_DEFAULT, sock,
+ &(pconfig->tx_conf));
+ if (status < 0) {
+ ifm_remove_port_details(port_id);
+ RTE_LOG(ERR, IFM, "%s: rte_eth_tx_queue_setup failed"
+ " for port %u\n\r", __FUNCTION__, port_id);
+ return IFM_FAILURE;
+ }
+ }
+ port = ifm_get_port(port_id);
+ if (port == NULL) {
+ RTE_LOG(INFO, IFM, "%s: Port is NULL @ %d\n\r", __FUNCTION__,
+ __LINE__);
+ return IFM_FAILURE;
+ }
+
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Acquiring WR lock 2 @ %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_lock();
+ else
+ rte_rwlock_write_lock(&rwlock);
+
+ if (port->tx_buf_len == 0) {
+ port->tx_buf_len = RTE_ETH_TX_BUFFER_SIZE(IFM_BURST_SIZE);
+ }
+ port->tx_buffer = rte_zmalloc_socket("tx_buffer", port->tx_buf_len, 0,
+ rte_eth_dev_socket_id(port_id));
+
+ if (port->tx_buffer == NULL) {
+ ifm_remove_port_details(port_id);
+ RTE_LOG(ERR, IFM, "%s: Failed to allocate tx buffers for"
+ " port %u\n\r", __FUNCTION__, port_id);
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing WR lock2 %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_unlock();
+ else
+ rte_rwlock_write_unlock(&rwlock);
+ return IFM_FAILURE;
+ }
+ rte_eth_tx_buffer_init(port->tx_buffer, IFM_BURST_SIZE);
+
+ sprintf(buf, "MEMPOOL%d", port_id);
+ port->mempool = rte_mempool_create(buf,
+ pconfig->mempool.pool_size,
+ pconfig->mempool.buffer_size,
+ pconfig->mempool.cache_size,
+ sizeof(struct
+ rte_pktmbuf_pool_private),
+ rte_pktmbuf_pool_init, NULL,
+ rte_pktmbuf_init, NULL, sock, 0);
+ if (port->mempool == NULL) {
+ ifm_remove_port_details(port_id);
+ RTE_LOG(ERR, IFM, "%s: rte_mempool_create is failed for port"
+ " %u. Error: %s\n\r",
+ __FUNCTION__, port_id, rte_strerror(rte_errno));
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing WR lock2 %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_unlock();
+ else
+ rte_rwlock_write_unlock(&rwlock);
+ return IFM_FAILURE;
+ }
+ int nrxqs;
+ for (nrxqs = 0; nrxqs < pconfig->nrx_queue; nrxqs++) {
+ status = rte_eth_rx_queue_setup(port_id, nrxqs,
+ IFM_RX_DESC_DEFAULT, sock,
+ &(pconfig->rx_conf),
+ port->mempool);
+ if (status < 0) {
+ ifm_remove_port_details(port_id);
+ RTE_LOG(ERR, IFM,
+ "%s: rte_eth_rx_queue_setup is failed "
+ "for port %u queue %u. Error: %s\n\r",
+ __FUNCTION__, port_id, nrxqs,
+ rte_strerror(rte_errno));
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM,
+ "%s: Releasing WR lock2 %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_unlock();
+ else
+ rte_rwlock_write_unlock(&rwlock);
+ return IFM_FAILURE;
+ }
+ }
+ /*Start link */
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing WR lock2 @ %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_unlock();
+ else
+ rte_rwlock_write_unlock(&rwlock);
+ status = rte_eth_dev_start(port_id);
+ if (status < 0) {
+ ifm_remove_port_details(port_id);
+ RTE_LOG(ERR, IFM, "%s: rte_eth_dev_start is failed for"
+ " port %u.\n\r", __FUNCTION__, port_id);
+ return IFM_FAILURE;
+ }
+ rte_delay_ms(5000);
+ /*Get device info and populate interface structure */
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Acquiring WR lock3 @ %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_lock();
+ else
+ rte_rwlock_write_lock(&rwlock);
+ rte_eth_macaddr_get(port_id, (struct ether_addr *)port->macaddr);
+ if (pconfig->promisc)
+ port->promisc = 1;
+ rte_eth_link_get(port_id, &linkstatus);
+ /*Link status */
+ port->link_duplex = linkstatus.link_duplex;
+ port->link_autoneg = linkstatus.link_autoneg;
+ port->link_speed = linkstatus.link_speed;
+ port->admin_status = pconfig->state;
+
+ /*Get dev_info */
+ memset(&dev_info, 0, sizeof(dev_info));
+ rte_eth_dev_info_get(port_id, &dev_info);
+ port->min_rx_bufsize = dev_info.min_rx_bufsize;
+ port->max_rx_pktlen = dev_info.max_rx_pktlen;
+ port->max_rx_queues = dev_info.max_rx_queues;
+ port->max_tx_queues = dev_info.max_tx_queues;
+ rte_eth_dev_get_mtu(port_id, &(port->mtu));
+
+ /*Add rx and tx packet function ptrs */
+ port->retrieve_bulk_pkts = &ifm_receive_bulk_pkts;
+ port->transmit_bulk_pkts = &ifm_transmit_bulk_pkts;
+ port->transmit_single_pkt = &ifm_transmit_single_pkt;
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing WR3 lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_unlock();
+ else
+ rte_rwlock_write_unlock(&rwlock);
+ RTE_LOG(INFO, IFM, "%s: Port %u is successfully configured.\n\r",
+ __FUNCTION__, port_id);
+ return IFM_SUCCESS;
+}
+
+int ifm_configure_ports(port_config_t *pconfig)
+{
+ uint8_t port_id;
+ int status = 0;
+ if (!ifm.nport_intialized) {
+ RTE_LOG(ERR, IFM, "%s, Configuring ports failed. Zero ports "
+ "are intialized during PCI probe", __FUNCTION__);
+ return IFM_FAILURE;
+ }
+ if (pconfig == NULL) {
+ RTE_LOG(ERR, IFM, "%s, Configuring ports failed. "
+ "Param pconfig is NULL\n\r", __FUNCTION__);
+ return IFM_FAILURE;
+ }
+
+ /*Initialize all ports */
+ for (port_id = 0; port_id < ifm.nport_intialized; port_id++) {
+ if (ifm_debug & IFM_DEBUG_CONFIG)
+ RTE_LOG(INFO, IFM, "Call ifm_port_setup %u\n\r",
+ port_id);
+ status =
+ ifm_port_setup(pconfig[port_id].port_id, &pconfig[port_id]);
+ if (status == IFM_SUCCESS)
+ ifm.nport_configured++;
+ }
+ if (!ifm.nport_configured) {
+ RTE_LOG(ERR, IFM, "%s: Zero ports are configured\n\r",
+ __FUNCTION__);
+ return IFM_FAILURE;
+ }
+ RTE_LOG(INFO, IFM, "%s: Number of ports sucessfully configured:"
+ " %d\n\r", __FUNCTION__, ifm.nport_configured);
+ return IFM_SUCCESS;
+}
+
+void print_interface_details(void)
+{
+ l2_phy_interface_t *port;
+ int i = 0;
+ struct sockaddr_in ip;
+ printf("\n\r");
+
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Acquiring RW lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_lock();
+ else
+ rte_rwlock_read_lock(&rwlock);
+
+ for (i = 0; i < RTE_MAX_ETHPORTS && ifm.port_list[i]; i++) {
+ port = ifm.port_list[i];
+ printf(" %u", port->pmdid);
+ if (port->ifname && strlen(port->ifname)) {
+ printf(" (%s)\t", port->ifname);
+ } else
+ printf("\t\t");
+ printf("MAC:%02x:%02x:%02x:%02x:%02x:%02x Adminstate:%s"
+ " Operstate:%s \n\r",
+ port->macaddr[0], port->macaddr[1],
+ port->macaddr[2], port->macaddr[3],
+ port->macaddr[4], port->macaddr[5],
+ port->admin_status ? "UP" : "DOWN",
+ port->link_status ? "UP" : "DOWN");
+ printf("\t\t");
+ printf("Speed: %u, %s-duplex\n\r", port->link_speed,
+ port->link_duplex ? "full" : "half");
+ printf("\t\t");
+
+ if (port->ipv4_list != NULL) {
+ ip.sin_addr.s_addr =
+ (unsigned long)((ipv4list_t *) (port->ipv4_list))->
+ ipaddr;
+ printf("IP: %s/%d", inet_ntoa(ip.sin_addr),
+ ((ipv4list_t *) (port->ipv4_list))->addrlen);
+ } else {
+ printf("IP: NA");
+ }
+
+ printf("\r\n");
+ printf("\t\t");
+ if (port->ipv6_list != NULL) {
+ uint8_t *addr =
+ ((ipv6list_t *) (port->ipv6_list))->ipaddr;
+ printf
+ ("IPv6: %02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x",
+ addr[0], addr[1], addr[2], addr[3], addr[4],
+ addr[5], addr[6], addr[7], addr[8], addr[9],
+ addr[10], addr[11], addr[12], addr[13], addr[14],
+ addr[15]);
+ } else {
+ printf("IPv6: NA");
+ }
+
+ if (port->flags & IFM_SLAVE) {
+ printf(" IFM_SLAVE ");
+ printf(" MasterPort: %u",
+ port->bond_config->bond_portid);
+ }
+ if (port->flags & IFM_MASTER) {
+ printf(" IFM_MASTER ");
+ printf(" Mode: %u", port->bond_config->mode);
+ printf(" PrimaryPort: %u", port->bond_config->primary);
+ printf("\n\r");
+ printf("\t\tSlavePortCount: %u",
+ port->bond_config->slave_count);
+ printf(" SlavePorts:");
+ int i;
+ for (i = 0; i < port->bond_config->slave_count; i++) {
+ printf(" %u ", port->bond_config->slaves[i]);
+ }
+ printf(" ActivePortCount: %u",
+ port->bond_config->active_slave_count);
+ printf(" ActivePorts:");
+ for (i = 0; i < port->bond_config->active_slave_count;
+ i++) {
+ printf(" %u ",
+ port->bond_config->active_slaves[i]);
+ }
+ printf("\n\r");
+ printf("\t\t");
+ printf("Link_monitor_freq: %u ms ",
+ port->bond_config->internal_ms);
+ printf(" Link_up_prop_delay: %u ms ",
+ port->bond_config->link_up_delay_ms);
+ printf(" Link_down_prop_delay: %u ms ",
+ port->bond_config->link_down_delay_ms);
+ printf("\n\r");
+ printf("\t\t");
+ printf("Xmit_policy: %u",
+ port->bond_config->xmit_policy);
+ }
+ printf("\n\r");
+ printf("\t\t");
+ printf("n_rxpkts: %" PRIu64 " ,n_txpkts: %" PRIu64 " ,",
+ port->n_rxpkts, port->n_txpkts);
+ struct rte_eth_stats eth_stats;
+ rte_eth_stats_get(port->pmdid, ð_stats);
+ printf("pkts_in: %" PRIu64 " ,", eth_stats.ipackets);
+ printf("pkts_out: %" PRIu64 " ", eth_stats.opackets);
+ printf("\n\r");
+ printf("\t\t");
+ printf("in_errs: %" PRIu64 " ,", eth_stats.ierrors);
+ printf("in_missed: %" PRIu64 " ,", eth_stats.imissed);
+ printf("out_errs: %" PRIu64 " ,", eth_stats.oerrors);
+ printf("mbuf_errs: %" PRIu64 " ", eth_stats.rx_nombuf);
+ printf("\n\r");
+ printf("\n\r");
+ }
+ if (ifm_debug & IFM_DEBUG_LOCKS)
+ RTE_LOG(INFO, IFM, "%s: Releasing RW lock @ %d\n\r",
+ __FUNCTION__, __LINE__);
+ if (USE_RTM_LOCKS)
+ rtm_unlock();
+ else
+ rte_rwlock_read_unlock(&rwlock);
+}
Code Review / samplevnf.git / blobdiff