* Copyright(c) 2010-2017 Intel Corporation
*/
#include <stdlib.h>
+#include <stdbool.h>
#include <netinet/in.h>
#include <rte_mbuf.h>
{
size_t vlan_offset = 0;
- if (rte_cpu_to_be_16(ETHER_TYPE_VLAN) == *proto ||
- rte_cpu_to_be_16(ETHER_TYPE_QINQ) == *proto) {
+ if (rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN) == *proto ||
+ rte_cpu_to_be_16(RTE_ETHER_TYPE_QINQ) == *proto) {
struct rte_vlan_hdr *vlan_hdr =
(struct rte_vlan_hdr *)(eth_hdr + 1);
vlan_offset = sizeof(struct rte_vlan_hdr);
*proto = vlan_hdr->eth_proto;
- if (rte_cpu_to_be_16(ETHER_TYPE_VLAN) == *proto) {
+ if (rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN) == *proto) {
vlan_hdr = vlan_hdr + 1;
*proto = vlan_hdr->eth_proto;
vlan_offset += sizeof(struct rte_vlan_hdr);
static inline uint8_t
is_lacp_packets(uint16_t ethertype, uint8_t subtype, struct rte_mbuf *mbuf)
{
- const uint16_t ether_type_slow_be = rte_be_to_cpu_16(ETHER_TYPE_SLOW);
+ const uint16_t ether_type_slow_be =
+ rte_be_to_cpu_16(RTE_ETHER_TYPE_SLOW);
return !((mbuf->ol_flags & PKT_RX_VLAN) ? mbuf->vlan_tci : 0) &&
(ethertype == ether_type_slow_be &&
static struct rte_flow_item_eth flow_item_eth_type_8023ad = {
.dst.addr_bytes = { 0 },
.src.addr_bytes = { 0 },
- .type = RTE_BE16(ETHER_TYPE_SLOW),
+ .type = RTE_BE16(RTE_ETHER_TYPE_SLOW),
};
static struct rte_flow_item_eth flow_item_eth_mask_type_8023ad = {
uint16_t slave_port) {
struct rte_eth_dev_info slave_info;
struct rte_flow_error error;
- struct bond_dev_private *internals = (struct bond_dev_private *)
- (bond_dev->data->dev_private);
+ struct bond_dev_private *internals = bond_dev->data->dev_private;
const struct rte_flow_action_queue lacp_queue_conf = {
.index = 0,
return -1;
}
- rte_eth_dev_info_get(slave_port, &slave_info);
+ ret = rte_eth_dev_info_get(slave_port, &slave_info);
+ if (ret != 0) {
+ RTE_BOND_LOG(ERR,
+ "%s: Error during getting device (port %u) info: %s\n",
+ __func__, slave_port, strerror(-ret));
+
+ return ret;
+ }
+
if (slave_info.max_rx_queues < bond_dev->data->nb_rx_queues ||
slave_info.max_tx_queues < bond_dev->data->nb_tx_queues) {
RTE_BOND_LOG(ERR,
int
bond_8023ad_slow_pkt_hw_filter_supported(uint16_t port_id) {
struct rte_eth_dev *bond_dev = &rte_eth_devices[port_id];
- struct bond_dev_private *internals = (struct bond_dev_private *)
- (bond_dev->data->dev_private);
+ struct bond_dev_private *internals = bond_dev->data->dev_private;
struct rte_eth_dev_info bond_info;
uint16_t idx;
+ int ret;
/* Verify if all slaves in bonding supports flow director and */
if (internals->slave_count > 0) {
- rte_eth_dev_info_get(bond_dev->data->port_id, &bond_info);
+ ret = rte_eth_dev_info_get(bond_dev->data->port_id, &bond_info);
+ if (ret != 0) {
+ RTE_BOND_LOG(ERR,
+ "%s: Error during getting device (port %u) info: %s\n",
+ __func__, bond_dev->data->port_id,
+ strerror(-ret));
+
+ return ret;
+ }
internals->mode4.dedicated_queues.rx_qid = bond_info.nb_rx_queues;
internals->mode4.dedicated_queues.tx_qid = bond_info.nb_tx_queues;
bond_ethdev_8023ad_flow_set(struct rte_eth_dev *bond_dev, uint16_t slave_port) {
struct rte_flow_error error;
- struct bond_dev_private *internals = (struct bond_dev_private *)
- (bond_dev->data->dev_private);
-
+ struct bond_dev_private *internals = bond_dev->data->dev_private;
struct rte_flow_action_queue lacp_queue_conf = {
.index = internals->mode4.dedicated_queues.rx_qid,
};
return 0;
}
-static uint16_t
-bond_ethdev_rx_burst_8023ad_fast_queue(void *queue, struct rte_mbuf **bufs,
- uint16_t nb_pkts)
-{
- struct bond_rx_queue *bd_rx_q = (struct bond_rx_queue *)queue;
- struct bond_dev_private *internals = bd_rx_q->dev_private;
- uint16_t num_rx_total = 0; /* Total number of received packets */
- uint16_t slaves[RTE_MAX_ETHPORTS];
- uint16_t slave_count;
- uint16_t active_slave;
- uint16_t i;
-
- /* Copy slave list to protect against slave up/down changes during tx
- * bursting */
- slave_count = internals->active_slave_count;
- active_slave = internals->active_slave;
- memcpy(slaves, internals->active_slaves,
- sizeof(internals->active_slaves[0]) * slave_count);
-
- for (i = 0; i < slave_count && nb_pkts; i++) {
- uint16_t num_rx_slave;
-
- /* Read packets from this slave */
- num_rx_slave = rte_eth_rx_burst(slaves[active_slave],
- bd_rx_q->queue_id,
- bufs + num_rx_total, nb_pkts);
- num_rx_total += num_rx_slave;
- nb_pkts -= num_rx_slave;
-
- if (++active_slave == slave_count)
- active_slave = 0;
- }
-
- if (++internals->active_slave >= slave_count)
- internals->active_slave = 0;
-
- return num_rx_total;
-}
-
-static uint16_t
-bond_ethdev_tx_burst_8023ad_fast_queue(void *queue, struct rte_mbuf **bufs,
- uint16_t nb_bufs)
-{
- struct bond_tx_queue *bd_tx_q = (struct bond_tx_queue *)queue;
- struct bond_dev_private *internals = bd_tx_q->dev_private;
-
- uint16_t slave_port_ids[RTE_MAX_ETHPORTS];
- uint16_t slave_count;
-
- uint16_t dist_slave_port_ids[RTE_MAX_ETHPORTS];
- uint16_t dist_slave_count;
-
- /* 2-D array to sort mbufs for transmission on each slave into */
- struct rte_mbuf *slave_bufs[RTE_MAX_ETHPORTS][nb_bufs];
- /* Number of mbufs for transmission on each slave */
- uint16_t slave_nb_bufs[RTE_MAX_ETHPORTS] = { 0 };
- /* Mapping array generated by hash function to map mbufs to slaves */
- uint16_t bufs_slave_port_idxs[RTE_MAX_ETHPORTS] = { 0 };
-
- uint16_t slave_tx_count;
- uint16_t total_tx_count = 0, total_tx_fail_count = 0;
-
- uint16_t i;
-
- if (unlikely(nb_bufs == 0))
- return 0;
-
- /* Copy slave list to protect against slave up/down changes during tx
- * bursting */
- slave_count = internals->active_slave_count;
- if (unlikely(slave_count < 1))
- return 0;
-
- memcpy(slave_port_ids, internals->active_slaves,
- sizeof(slave_port_ids[0]) * slave_count);
-
-
- dist_slave_count = 0;
- for (i = 0; i < slave_count; i++) {
- struct port *port = &bond_mode_8023ad_ports[slave_port_ids[i]];
-
- if (ACTOR_STATE(port, DISTRIBUTING))
- dist_slave_port_ids[dist_slave_count++] =
- slave_port_ids[i];
- }
-
- if (unlikely(dist_slave_count < 1))
- return 0;
-
- /*
- * Populate slaves mbuf with the packets which are to be sent on it
- * selecting output slave using hash based on xmit policy
- */
- internals->burst_xmit_hash(bufs, nb_bufs, dist_slave_count,
- bufs_slave_port_idxs);
-
- for (i = 0; i < nb_bufs; i++) {
- /* Populate slave mbuf arrays with mbufs for that slave. */
- uint16_t slave_idx = bufs_slave_port_idxs[i];
-
- slave_bufs[slave_idx][slave_nb_bufs[slave_idx]++] = bufs[i];
- }
-
-
- /* Send packet burst on each slave device */
- for (i = 0; i < dist_slave_count; i++) {
- if (slave_nb_bufs[i] == 0)
- continue;
-
- slave_tx_count = rte_eth_tx_burst(dist_slave_port_ids[i],
- bd_tx_q->queue_id, slave_bufs[i],
- slave_nb_bufs[i]);
-
- total_tx_count += slave_tx_count;
-
- /* If tx burst fails move packets to end of bufs */
- if (unlikely(slave_tx_count < slave_nb_bufs[i])) {
- int slave_tx_fail_count = slave_nb_bufs[i] -
- slave_tx_count;
- total_tx_fail_count += slave_tx_fail_count;
- memcpy(&bufs[nb_bufs - total_tx_fail_count],
- &slave_bufs[i][slave_tx_count],
- slave_tx_fail_count * sizeof(bufs[0]));
- }
- }
-
- return total_tx_count;
-}
-
-
-static uint16_t
-bond_ethdev_rx_burst_8023ad(void *queue, struct rte_mbuf **bufs,
- uint16_t nb_pkts)
+static inline uint16_t
+rx_burst_8023ad(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts,
+ bool dedicated_rxq)
{
/* Cast to structure, containing bonded device's port id and queue id */
struct bond_rx_queue *bd_rx_q = (struct bond_rx_queue *)queue;
struct rte_ether_addr *bond_mac = bonded_eth_dev->data->mac_addrs;
struct rte_ether_hdr *hdr;
- const uint16_t ether_type_slow_be = rte_be_to_cpu_16(ETHER_TYPE_SLOW);
+ const uint16_t ether_type_slow_be =
+ rte_be_to_cpu_16(RTE_ETHER_TYPE_SLOW);
uint16_t num_rx_total = 0; /* Total number of received packets */
uint16_t slaves[RTE_MAX_ETHPORTS];
uint16_t slave_count, idx;
uint8_t collecting; /* current slave collecting status */
- const uint8_t promisc = internals->promiscuous_en;
+ const uint8_t promisc = rte_eth_promiscuous_get(internals->port_id);
+ const uint8_t allmulti = rte_eth_allmulticast_get(internals->port_id);
uint8_t subtype;
uint16_t i;
uint16_t j;
/* Handle slow protocol packets. */
while (j < num_rx_total) {
-
- /* If packet is not pure L2 and is known, skip it */
- if ((bufs[j]->packet_type & ~RTE_PTYPE_L2_ETHER) != 0) {
- j++;
- continue;
- }
-
if (j + 3 < num_rx_total)
rte_prefetch0(rte_pktmbuf_mtod(bufs[j + 3], void *));
hdr = rte_pktmbuf_mtod(bufs[j], struct rte_ether_hdr *);
subtype = ((struct slow_protocol_frame *)hdr)->slow_protocol.subtype;
- /* Remove packet from array if it is slow packet or slave is not
- * in collecting state or bonding interface is not in promiscuous
- * mode and packet address does not match. */
- if (unlikely(is_lacp_packets(hdr->ether_type, subtype, bufs[j]) ||
+ /* Remove packet from array if:
+ * - it is slow packet but no dedicated rxq is present,
+ * - slave is not in collecting state,
+ * - bonding interface is not in promiscuous mode:
+ * - packet is unicast and address does not match,
+ * - packet is multicast and bonding interface
+ * is not in allmulti,
+ */
+ if (unlikely(
+ (!dedicated_rxq &&
+ is_lacp_packets(hdr->ether_type, subtype,
+ bufs[j])) ||
!collecting ||
(!promisc &&
- !rte_is_multicast_ether_addr(&hdr->d_addr) &&
- !rte_is_same_ether_addr(bond_mac,
- &hdr->d_addr)))) {
+ ((rte_is_unicast_ether_addr(&hdr->d_addr) &&
+ !rte_is_same_ether_addr(bond_mac,
+ &hdr->d_addr)) ||
+ (!allmulti &&
+ rte_is_multicast_ether_addr(&hdr->d_addr)))))) {
if (hdr->ether_type == ether_type_slow_be) {
bond_mode_8023ad_handle_slow_pkt(
return num_rx_total;
}
+static uint16_t
+bond_ethdev_rx_burst_8023ad(void *queue, struct rte_mbuf **bufs,
+ uint16_t nb_pkts)
+{
+ return rx_burst_8023ad(queue, bufs, nb_pkts, false);
+}
+
+static uint16_t
+bond_ethdev_rx_burst_8023ad_fast_queue(void *queue, struct rte_mbuf **bufs,
+ uint16_t nb_pkts)
+{
+ return rx_burst_8023ad(queue, bufs, nb_pkts, true);
+}
+
#if defined(RTE_LIBRTE_BOND_DEBUG_ALB) || defined(RTE_LIBRTE_BOND_DEBUG_ALB_L1)
uint32_t burstnumberRX;
uint32_t burstnumberTX;
struct rte_ether_hdr *eth_h, uint16_t port,
uint32_t __attribute__((unused)) *burstnumber)
{
- struct ipv4_hdr *ipv4_h;
+ struct rte_ipv4_hdr *ipv4_h;
#ifdef RTE_LIBRTE_BOND_DEBUG_ALB
struct rte_arp_hdr *arp_h;
char dst_ip[16];
strlcpy(buf, info, 16);
#endif
- if (ether_type == rte_cpu_to_be_16(ETHER_TYPE_IPv4)) {
- ipv4_h = (struct ipv4_hdr *)((char *)(eth_h + 1) + offset);
+ if (ether_type == rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4)) {
+ ipv4_h = (struct rte_ipv4_hdr *)((char *)(eth_h + 1) + offset);
ipv4_addr_to_dot(ipv4_h->src_addr, src_ip, MaxIPv4String);
#ifdef RTE_LIBRTE_BOND_DEBUG_ALB
ipv4_addr_to_dot(ipv4_h->dst_addr, dst_ip, MaxIPv4String);
update_client_stats(ipv4_h->src_addr, port, burstnumber);
}
#ifdef RTE_LIBRTE_BOND_DEBUG_ALB
- else if (ether_type == rte_cpu_to_be_16(ETHER_TYPE_ARP)) {
+ else if (ether_type == rte_cpu_to_be_16(RTE_ETHER_TYPE_ARP)) {
arp_h = (struct rte_arp_hdr *)((char *)(eth_h + 1) + offset);
ipv4_addr_to_dot(arp_h->arp_data.arp_sip, src_ip, MaxIPv4String);
ipv4_addr_to_dot(arp_h->arp_data.arp_tip, dst_ip, MaxIPv4String);
ether_type = eth_h->ether_type;
offset = get_vlan_offset(eth_h, ðer_type);
- if (ether_type == rte_cpu_to_be_16(ETHER_TYPE_ARP)) {
+ if (ether_type == rte_cpu_to_be_16(RTE_ETHER_TYPE_ARP)) {
#if defined(RTE_LIBRTE_BOND_DEBUG_ALB) || defined(RTE_LIBRTE_BOND_DEBUG_ALB_L1)
mode6_debug("RX ARP:", eth_h, bufs[i]->port, &burstnumberRX);
#endif
bond_mode_alb_arp_recv(eth_h, offset, internals);
}
#if defined(RTE_LIBRTE_BOND_DEBUG_ALB) || defined(RTE_LIBRTE_BOND_DEBUG_ALB_L1)
- else if (ether_type == rte_cpu_to_be_16(ETHER_TYPE_IPv4))
+ else if (ether_type == rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4))
mode6_debug("RX IPv4:", eth_h, bufs[i]->port, &burstnumberRX);
#endif
}
}
static inline uint32_t
-ipv4_hash(struct ipv4_hdr *ipv4_hdr)
+ipv4_hash(struct rte_ipv4_hdr *ipv4_hdr)
{
return ipv4_hdr->src_addr ^ ipv4_hdr->dst_addr;
}
static inline uint32_t
-ipv6_hash(struct ipv6_hdr *ipv6_hdr)
+ipv6_hash(struct rte_ipv6_hdr *ipv6_hdr)
{
unaligned_uint32_t *word_src_addr =
(unaligned_uint32_t *)&(ipv6_hdr->src_addr[0]);
vlan_offset = get_vlan_offset(eth_hdr, &proto);
- if (rte_cpu_to_be_16(ETHER_TYPE_IPv4) == proto) {
- struct ipv4_hdr *ipv4_hdr = (struct ipv4_hdr *)
+ if (rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4) == proto) {
+ struct rte_ipv4_hdr *ipv4_hdr = (struct rte_ipv4_hdr *)
((char *)(eth_hdr + 1) + vlan_offset);
l3hash = ipv4_hash(ipv4_hdr);
- } else if (rte_cpu_to_be_16(ETHER_TYPE_IPv6) == proto) {
- struct ipv6_hdr *ipv6_hdr = (struct ipv6_hdr *)
+ } else if (rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6) == proto) {
+ struct rte_ipv6_hdr *ipv6_hdr = (struct rte_ipv6_hdr *)
((char *)(eth_hdr + 1) + vlan_offset);
l3hash = ipv6_hash(ipv6_hdr);
}
size_t vlan_offset;
int i;
- struct udp_hdr *udp_hdr;
- struct tcp_hdr *tcp_hdr;
+ struct rte_udp_hdr *udp_hdr;
+ struct rte_tcp_hdr *tcp_hdr;
uint32_t hash, l3hash, l4hash;
for (i = 0; i < nb_pkts; i++) {
l3hash = 0;
l4hash = 0;
- if (rte_cpu_to_be_16(ETHER_TYPE_IPv4) == proto) {
- struct ipv4_hdr *ipv4_hdr = (struct ipv4_hdr *)
+ if (rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4) == proto) {
+ struct rte_ipv4_hdr *ipv4_hdr = (struct rte_ipv4_hdr *)
((char *)(eth_hdr + 1) + vlan_offset);
size_t ip_hdr_offset;
if (likely(rte_ipv4_frag_pkt_is_fragmented(ipv4_hdr)
== 0)) {
ip_hdr_offset = (ipv4_hdr->version_ihl
- & IPV4_HDR_IHL_MASK) *
- IPV4_IHL_MULTIPLIER;
+ & RTE_IPV4_HDR_IHL_MASK) *
+ RTE_IPV4_IHL_MULTIPLIER;
if (ipv4_hdr->next_proto_id == IPPROTO_TCP) {
- tcp_hdr = (struct tcp_hdr *)
+ tcp_hdr = (struct rte_tcp_hdr *)
((char *)ipv4_hdr +
ip_hdr_offset);
if ((size_t)tcp_hdr + sizeof(*tcp_hdr)
l4hash = HASH_L4_PORTS(tcp_hdr);
} else if (ipv4_hdr->next_proto_id ==
IPPROTO_UDP) {
- udp_hdr = (struct udp_hdr *)
+ udp_hdr = (struct rte_udp_hdr *)
((char *)ipv4_hdr +
ip_hdr_offset);
if ((size_t)udp_hdr + sizeof(*udp_hdr)
l4hash = HASH_L4_PORTS(udp_hdr);
}
}
- } else if (rte_cpu_to_be_16(ETHER_TYPE_IPv6) == proto) {
- struct ipv6_hdr *ipv6_hdr = (struct ipv6_hdr *)
+ } else if (rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6) == proto) {
+ struct rte_ipv6_hdr *ipv6_hdr = (struct rte_ipv6_hdr *)
((char *)(eth_hdr + 1) + vlan_offset);
l3hash = ipv6_hash(ipv6_hdr);
if (ipv6_hdr->proto == IPPROTO_TCP) {
- tcp_hdr = (struct tcp_hdr *)(ipv6_hdr + 1);
+ tcp_hdr = (struct rte_tcp_hdr *)(ipv6_hdr + 1);
l4hash = HASH_L4_PORTS(tcp_hdr);
} else if (ipv6_hdr->proto == IPPROTO_UDP) {
- udp_hdr = (struct udp_hdr *)(ipv6_hdr + 1);
+ udp_hdr = (struct rte_udp_hdr *)(ipv6_hdr + 1);
l4hash = HASH_L4_PORTS(udp_hdr);
}
}
struct bwg_slave *bwg_slave)
{
struct rte_eth_link link_status;
+ int ret;
- rte_eth_link_get_nowait(port_id, &link_status);
+ ret = rte_eth_link_get_nowait(port_id, &link_status);
+ if (ret < 0) {
+ RTE_BOND_LOG(ERR, "Slave (port %u) link get failed: %s",
+ port_id, rte_strerror(-ret));
+ return;
+ }
uint64_t link_bwg = link_status.link_speed * 1000000ULL / 8;
if (link_bwg == 0)
return;
ether_type = eth_h->ether_type;
offset = get_vlan_offset(eth_h, ðer_type);
- if (ether_type == rte_cpu_to_be_16(ETHER_TYPE_ARP)) {
+ if (ether_type == rte_cpu_to_be_16(RTE_ETHER_TYPE_ARP)) {
slave_idx = bond_mode_alb_arp_xmit(eth_h, offset, internals);
/* Change src mac in eth header */
return num_tx_total;
}
-static uint16_t
-bond_ethdev_tx_burst_balance(void *queue, struct rte_mbuf **bufs,
- uint16_t nb_bufs)
+static inline uint16_t
+tx_burst_balance(void *queue, struct rte_mbuf **bufs, uint16_t nb_bufs,
+ uint16_t *slave_port_ids, uint16_t slave_count)
{
struct bond_tx_queue *bd_tx_q = (struct bond_tx_queue *)queue;
struct bond_dev_private *internals = bd_tx_q->dev_private;
- uint16_t slave_port_ids[RTE_MAX_ETHPORTS];
- uint16_t slave_count;
-
/* Array to sort mbufs for transmission on each slave into */
struct rte_mbuf *slave_bufs[RTE_MAX_ETHPORTS][nb_bufs];
/* Number of mbufs for transmission on each slave */
uint16_t i;
- if (unlikely(nb_bufs == 0))
- return 0;
-
- /* Copy slave list to protect against slave up/down changes during tx
- * bursting */
- slave_count = internals->active_slave_count;
- if (unlikely(slave_count < 1))
- return 0;
-
- memcpy(slave_port_ids, internals->active_slaves,
- sizeof(slave_port_ids[0]) * slave_count);
-
/*
* Populate slaves mbuf with the packets which are to be sent on it
* selecting output slave using hash based on xmit policy
}
static uint16_t
-bond_ethdev_tx_burst_8023ad(void *queue, struct rte_mbuf **bufs,
+bond_ethdev_tx_burst_balance(void *queue, struct rte_mbuf **bufs,
uint16_t nb_bufs)
{
struct bond_tx_queue *bd_tx_q = (struct bond_tx_queue *)queue;
uint16_t slave_port_ids[RTE_MAX_ETHPORTS];
uint16_t slave_count;
+ if (unlikely(nb_bufs == 0))
+ return 0;
+
+ /* Copy slave list to protect against slave up/down changes during tx
+ * bursting
+ */
+ slave_count = internals->active_slave_count;
+ if (unlikely(slave_count < 1))
+ return 0;
+
+ memcpy(slave_port_ids, internals->active_slaves,
+ sizeof(slave_port_ids[0]) * slave_count);
+ return tx_burst_balance(queue, bufs, nb_bufs, slave_port_ids,
+ slave_count);
+}
+
+static inline uint16_t
+tx_burst_8023ad(void *queue, struct rte_mbuf **bufs, uint16_t nb_bufs,
+ bool dedicated_txq)
+{
+ struct bond_tx_queue *bd_tx_q = (struct bond_tx_queue *)queue;
+ struct bond_dev_private *internals = bd_tx_q->dev_private;
+
+ uint16_t slave_port_ids[RTE_MAX_ETHPORTS];
+ uint16_t slave_count;
+
uint16_t dist_slave_port_ids[RTE_MAX_ETHPORTS];
uint16_t dist_slave_count;
- /* 2-D array to sort mbufs for transmission on each slave into */
- struct rte_mbuf *slave_bufs[RTE_MAX_ETHPORTS][nb_bufs];
- /* Number of mbufs for transmission on each slave */
- uint16_t slave_nb_bufs[RTE_MAX_ETHPORTS] = { 0 };
- /* Mapping array generated by hash function to map mbufs to slaves */
- uint16_t bufs_slave_port_idxs[RTE_MAX_ETHPORTS] = { 0 };
-
uint16_t slave_tx_count;
- uint16_t total_tx_count = 0, total_tx_fail_count = 0;
uint16_t i;
memcpy(slave_port_ids, internals->active_slaves,
sizeof(slave_port_ids[0]) * slave_count);
+ if (dedicated_txq)
+ goto skip_tx_ring;
+
/* Check for LACP control packets and send if available */
for (i = 0; i < slave_count; i++) {
struct port *port = &bond_mode_8023ad_ports[slave_port_ids[i]];
}
}
+skip_tx_ring:
if (unlikely(nb_bufs == 0))
return 0;
slave_port_ids[i];
}
- if (likely(dist_slave_count > 0)) {
-
- /*
- * Populate slaves mbuf with the packets which are to be sent
- * on it, selecting output slave using hash based on xmit policy
- */
- internals->burst_xmit_hash(bufs, nb_bufs, dist_slave_count,
- bufs_slave_port_idxs);
-
- for (i = 0; i < nb_bufs; i++) {
- /*
- * Populate slave mbuf arrays with mbufs for that
- * slave
- */
- uint16_t slave_idx = bufs_slave_port_idxs[i];
-
- slave_bufs[slave_idx][slave_nb_bufs[slave_idx]++] =
- bufs[i];
- }
-
-
- /* Send packet burst on each slave device */
- for (i = 0; i < dist_slave_count; i++) {
- if (slave_nb_bufs[i] == 0)
- continue;
-
- slave_tx_count = rte_eth_tx_burst(
- dist_slave_port_ids[i],
- bd_tx_q->queue_id, slave_bufs[i],
- slave_nb_bufs[i]);
-
- total_tx_count += slave_tx_count;
+ if (unlikely(dist_slave_count < 1))
+ return 0;
- /* If tx burst fails move packets to end of bufs */
- if (unlikely(slave_tx_count < slave_nb_bufs[i])) {
- int slave_tx_fail_count = slave_nb_bufs[i] -
- slave_tx_count;
- total_tx_fail_count += slave_tx_fail_count;
+ return tx_burst_balance(queue, bufs, nb_bufs, dist_slave_port_ids,
+ dist_slave_count);
+}
- memcpy(&bufs[nb_bufs - total_tx_fail_count],
- &slave_bufs[i][slave_tx_count],
- slave_tx_fail_count * sizeof(bufs[0]));
- }
- }
- }
+static uint16_t
+bond_ethdev_tx_burst_8023ad(void *queue, struct rte_mbuf **bufs,
+ uint16_t nb_bufs)
+{
+ return tx_burst_8023ad(queue, bufs, nb_bufs, false);
+}
- return total_tx_count;
+static uint16_t
+bond_ethdev_tx_burst_8023ad_fast_queue(void *queue, struct rte_mbuf **bufs,
+ uint16_t nb_bufs)
+{
+ return tx_burst_8023ad(queue, bufs, nb_bufs, true);
}
static uint16_t
struct rte_eth_dev *slave_eth_dev)
{
int errval = 0;
- struct bond_dev_private *internals = (struct bond_dev_private *)
- bonded_eth_dev->data->dev_private;
+ struct bond_dev_private *internals = bonded_eth_dev->data->dev_private;
struct port *port = &bond_mode_8023ad_ports[slave_eth_dev->data->port_id];
if (port->slow_pool == NULL) {
uint16_t q_id;
struct rte_flow_error flow_error;
- struct bond_dev_private *internals = (struct bond_dev_private *)
- bonded_eth_dev->data->dev_private;
+ struct bond_dev_private *internals = bonded_eth_dev->data->dev_private;
/* Stop slave */
rte_eth_dev_stop(slave_eth_dev->data->port_id);
}
}
-static void
+static int
bond_ethdev_promiscuous_enable(struct rte_eth_dev *eth_dev);
static int
}
}
- /* If bonded device is configure in promiscuous mode then re-apply config */
- if (internals->promiscuous_en)
- bond_ethdev_promiscuous_enable(eth_dev);
-
if (internals->mode == BONDING_MODE_8023AD) {
if (internals->mode4.dedicated_queues.enabled == 1) {
internals->mode4.dedicated_queues.rx_qid =
/* forward declaration */
static int bond_ethdev_configure(struct rte_eth_dev *dev);
-static void
+static int
bond_ethdev_info(struct rte_eth_dev *dev, struct rte_eth_dev_info *dev_info)
{
struct bond_dev_private *internals = dev->data->dev_private;
+ struct bond_slave_details slave;
+ int ret;
uint16_t max_nb_rx_queues = UINT16_MAX;
uint16_t max_nb_tx_queues = UINT16_MAX;
dev_info->max_rx_pktlen = internals->candidate_max_rx_pktlen ?
internals->candidate_max_rx_pktlen :
- ETHER_MAX_JUMBO_FRAME_LEN;
+ RTE_ETHER_MAX_JUMBO_FRAME_LEN;
/* Max number of tx/rx queues that the bonded device can support is the
* minimum values of the bonded slaves, as all slaves must be capable
uint16_t idx;
for (idx = 0; idx < internals->slave_count; idx++) {
- rte_eth_dev_info_get(internals->slaves[idx].port_id,
- &slave_info);
+ slave = internals->slaves[idx];
+ ret = rte_eth_dev_info_get(slave.port_id, &slave_info);
+ if (ret != 0) {
+ RTE_BOND_LOG(ERR,
+ "%s: Error during getting device (port %u) info: %s\n",
+ __func__,
+ slave.port_id,
+ strerror(-ret));
+
+ return ret;
+ }
if (slave_info.max_rx_queues < max_nb_rx_queues)
max_nb_rx_queues = slave_info.max_rx_queues;
dev_info->flow_type_rss_offloads = internals->flow_type_rss_offloads;
dev_info->reta_size = internals->reta_size;
+
+ return 0;
}
static int
if (cb_arg == NULL)
return;
- bonded_ethdev = (struct rte_eth_dev *)cb_arg;
- internals = (struct bond_dev_private *)bonded_ethdev->data->dev_private;
+ bonded_ethdev = cb_arg;
+ internals = bonded_ethdev->data->dev_private;
if (!bonded_ethdev->data->dev_started ||
!internals->link_status_polling_enabled)
static int
bond_ethdev_link_update(struct rte_eth_dev *ethdev, int wait_to_complete)
{
- void (*link_update)(uint16_t port_id, struct rte_eth_link *eth_link);
+ int (*link_update)(uint16_t port_id, struct rte_eth_link *eth_link);
struct bond_dev_private *bond_ctx;
struct rte_eth_link slave_link;
+ bool one_link_update_succeeded;
uint32_t idx;
+ int ret;
bond_ctx = ethdev->data->dev_private;
* packet loss will occur on this slave if transmission at rates
* greater than this are attempted
*/
- for (idx = 1; idx < bond_ctx->active_slave_count; idx++) {
- link_update(bond_ctx->active_slaves[0], &slave_link);
+ for (idx = 0; idx < bond_ctx->active_slave_count; idx++) {
+ ret = link_update(bond_ctx->active_slaves[idx],
+ &slave_link);
+ if (ret < 0) {
+ ethdev->data->dev_link.link_speed =
+ ETH_SPEED_NUM_NONE;
+ RTE_BOND_LOG(ERR,
+ "Slave (port %u) link get failed: %s",
+ bond_ctx->active_slaves[idx],
+ rte_strerror(-ret));
+ return 0;
+ }
if (slave_link.link_speed <
ethdev->data->dev_link.link_speed)
break;
case BONDING_MODE_ACTIVE_BACKUP:
/* Current primary slave */
- link_update(bond_ctx->current_primary_port, &slave_link);
+ ret = link_update(bond_ctx->current_primary_port, &slave_link);
+ if (ret < 0) {
+ RTE_BOND_LOG(ERR, "Slave (port %u) link get failed: %s",
+ bond_ctx->current_primary_port,
+ rte_strerror(-ret));
+ return 0;
+ }
ethdev->data->dev_link.link_speed = slave_link.link_speed;
break;
* of all the slaves
*/
ethdev->data->dev_link.link_speed = ETH_SPEED_NUM_NONE;
+ one_link_update_succeeded = false;
for (idx = 0; idx < bond_ctx->active_slave_count; idx++) {
- link_update(bond_ctx->active_slaves[idx], &slave_link);
+ ret = link_update(bond_ctx->active_slaves[idx],
+ &slave_link);
+ if (ret < 0) {
+ RTE_BOND_LOG(ERR,
+ "Slave (port %u) link get failed: %s",
+ bond_ctx->active_slaves[idx],
+ rte_strerror(-ret));
+ continue;
+ }
+ one_link_update_succeeded = true;
ethdev->data->dev_link.link_speed +=
slave_link.link_speed;
}
+
+ if (!one_link_update_succeeded) {
+ RTE_BOND_LOG(ERR, "All slaves link get failed");
+ return 0;
+ }
}
return 0;
}
-static void
+static int
bond_ethdev_stats_reset(struct rte_eth_dev *dev)
{
struct bond_dev_private *internals = dev->data->dev_private;
int i;
+ int err;
+ int ret;
- for (i = 0; i < internals->slave_count; i++)
- rte_eth_stats_reset(internals->slaves[i].port_id);
+ for (i = 0, err = 0; i < internals->slave_count; i++) {
+ ret = rte_eth_stats_reset(internals->slaves[i].port_id);
+ if (ret != 0)
+ err = ret;
+ }
+
+ return err;
}
-static void
+static int
bond_ethdev_promiscuous_enable(struct rte_eth_dev *eth_dev)
{
struct bond_dev_private *internals = eth_dev->data->dev_private;
int i;
-
- internals->promiscuous_en = 1;
+ int ret = 0;
+ uint16_t port_id;
switch (internals->mode) {
/* Promiscuous mode is propagated to all slaves */
case BONDING_MODE_ROUND_ROBIN:
case BONDING_MODE_BALANCE:
case BONDING_MODE_BROADCAST:
- for (i = 0; i < internals->slave_count; i++)
- rte_eth_promiscuous_enable(internals->slaves[i].port_id);
- break;
- /* In mode4 promiscus mode is managed when slave is added/removed */
- case BONDING_MODE_8023AD:
+ case BONDING_MODE_8023AD: {
+ unsigned int slave_ok = 0;
+
+ for (i = 0; i < internals->slave_count; i++) {
+ port_id = internals->slaves[i].port_id;
+
+ ret = rte_eth_promiscuous_enable(port_id);
+ if (ret != 0)
+ RTE_BOND_LOG(ERR,
+ "Failed to enable promiscuous mode for port %u: %s",
+ port_id, rte_strerror(-ret));
+ else
+ slave_ok++;
+ }
+ /*
+ * Report success if operation is successful on at least
+ * on one slave. Otherwise return last error code.
+ */
+ if (slave_ok > 0)
+ ret = 0;
break;
+ }
/* Promiscuous mode is propagated only to primary slave */
case BONDING_MODE_ACTIVE_BACKUP:
case BONDING_MODE_TLB:
/* Do not touch promisc when there cannot be primary ports */
if (internals->slave_count == 0)
break;
- rte_eth_promiscuous_enable(internals->current_primary_port);
+ port_id = internals->current_primary_port;
+ ret = rte_eth_promiscuous_enable(port_id);
+ if (ret != 0)
+ RTE_BOND_LOG(ERR,
+ "Failed to enable promiscuous mode for port %u: %s",
+ port_id, rte_strerror(-ret));
}
+
+ return ret;
}
-static void
+static int
bond_ethdev_promiscuous_disable(struct rte_eth_dev *dev)
{
struct bond_dev_private *internals = dev->data->dev_private;
int i;
-
- internals->promiscuous_en = 0;
+ int ret = 0;
+ uint16_t port_id;
switch (internals->mode) {
/* Promiscuous mode is propagated to all slaves */
case BONDING_MODE_ROUND_ROBIN:
case BONDING_MODE_BALANCE:
case BONDING_MODE_BROADCAST:
- for (i = 0; i < internals->slave_count; i++)
- rte_eth_promiscuous_disable(internals->slaves[i].port_id);
- break;
- /* In mode4 promiscus mode is set managed when slave is added/removed */
- case BONDING_MODE_8023AD:
+ case BONDING_MODE_8023AD: {
+ unsigned int slave_ok = 0;
+
+ for (i = 0; i < internals->slave_count; i++) {
+ port_id = internals->slaves[i].port_id;
+
+ if (internals->mode == BONDING_MODE_8023AD &&
+ bond_mode_8023ad_ports[port_id].forced_rx_flags ==
+ BOND_8023AD_FORCED_PROMISC) {
+ slave_ok++;
+ continue;
+ }
+ ret = rte_eth_promiscuous_disable(port_id);
+ if (ret != 0)
+ RTE_BOND_LOG(ERR,
+ "Failed to disable promiscuous mode for port %u: %s",
+ port_id, rte_strerror(-ret));
+ else
+ slave_ok++;
+ }
+ /*
+ * Report success if operation is successful on at least
+ * on one slave. Otherwise return last error code.
+ */
+ if (slave_ok > 0)
+ ret = 0;
break;
+ }
/* Promiscuous mode is propagated only to primary slave */
case BONDING_MODE_ACTIVE_BACKUP:
case BONDING_MODE_TLB:
/* Do not touch promisc when there cannot be primary ports */
if (internals->slave_count == 0)
break;
- rte_eth_promiscuous_disable(internals->current_primary_port);
+ port_id = internals->current_primary_port;
+ ret = rte_eth_promiscuous_disable(port_id);
+ if (ret != 0)
+ RTE_BOND_LOG(ERR,
+ "Failed to disable promiscuous mode for port %u: %s",
+ port_id, rte_strerror(-ret));
+ }
+
+ return ret;
+}
+
+static int
+bond_ethdev_allmulticast_enable(struct rte_eth_dev *eth_dev)
+{
+ struct bond_dev_private *internals = eth_dev->data->dev_private;
+ int i;
+ int ret = 0;
+ uint16_t port_id;
+
+ switch (internals->mode) {
+ /* allmulti mode is propagated to all slaves */
+ case BONDING_MODE_ROUND_ROBIN:
+ case BONDING_MODE_BALANCE:
+ case BONDING_MODE_BROADCAST:
+ case BONDING_MODE_8023AD: {
+ unsigned int slave_ok = 0;
+
+ for (i = 0; i < internals->slave_count; i++) {
+ port_id = internals->slaves[i].port_id;
+
+ ret = rte_eth_allmulticast_enable(port_id);
+ if (ret != 0)
+ RTE_BOND_LOG(ERR,
+ "Failed to enable allmulti mode for port %u: %s",
+ port_id, rte_strerror(-ret));
+ else
+ slave_ok++;
+ }
+ /*
+ * Report success if operation is successful on at least
+ * on one slave. Otherwise return last error code.
+ */
+ if (slave_ok > 0)
+ ret = 0;
+ break;
+ }
+ /* allmulti mode is propagated only to primary slave */
+ case BONDING_MODE_ACTIVE_BACKUP:
+ case BONDING_MODE_TLB:
+ case BONDING_MODE_ALB:
+ default:
+ /* Do not touch allmulti when there cannot be primary ports */
+ if (internals->slave_count == 0)
+ break;
+ port_id = internals->current_primary_port;
+ ret = rte_eth_allmulticast_enable(port_id);
+ if (ret != 0)
+ RTE_BOND_LOG(ERR,
+ "Failed to enable allmulti mode for port %u: %s",
+ port_id, rte_strerror(-ret));
+ }
+
+ return ret;
+}
+
+static int
+bond_ethdev_allmulticast_disable(struct rte_eth_dev *eth_dev)
+{
+ struct bond_dev_private *internals = eth_dev->data->dev_private;
+ int i;
+ int ret = 0;
+ uint16_t port_id;
+
+ switch (internals->mode) {
+ /* allmulti mode is propagated to all slaves */
+ case BONDING_MODE_ROUND_ROBIN:
+ case BONDING_MODE_BALANCE:
+ case BONDING_MODE_BROADCAST:
+ case BONDING_MODE_8023AD: {
+ unsigned int slave_ok = 0;
+
+ for (i = 0; i < internals->slave_count; i++) {
+ uint16_t port_id = internals->slaves[i].port_id;
+
+ if (internals->mode == BONDING_MODE_8023AD &&
+ bond_mode_8023ad_ports[port_id].forced_rx_flags ==
+ BOND_8023AD_FORCED_ALLMULTI)
+ continue;
+
+ ret = rte_eth_allmulticast_disable(port_id);
+ if (ret != 0)
+ RTE_BOND_LOG(ERR,
+ "Failed to disable allmulti mode for port %u: %s",
+ port_id, rte_strerror(-ret));
+ else
+ slave_ok++;
+ }
+ /*
+ * Report success if operation is successful on at least
+ * on one slave. Otherwise return last error code.
+ */
+ if (slave_ok > 0)
+ ret = 0;
+ break;
+ }
+ /* allmulti mode is propagated only to primary slave */
+ case BONDING_MODE_ACTIVE_BACKUP:
+ case BONDING_MODE_TLB:
+ case BONDING_MODE_ALB:
+ default:
+ /* Do not touch allmulti when there cannot be primary ports */
+ if (internals->slave_count == 0)
+ break;
+ port_id = internals->current_primary_port;
+ ret = rte_eth_allmulticast_disable(port_id);
+ if (ret != 0)
+ RTE_BOND_LOG(ERR,
+ "Failed to disable allmulti mode for port %u: %s",
+ port_id, rte_strerror(-ret));
}
+
+ return ret;
}
static void
struct bond_dev_private *internals;
struct rte_eth_link link;
int rc = -1;
+ int ret;
uint8_t lsc_flag = 0;
int valid_slave = 0;
active_pos = find_slave_by_id(internals->active_slaves,
internals->active_slave_count, port_id);
- rte_eth_link_get_nowait(port_id, &link);
- if (link.link_status) {
+ ret = rte_eth_link_get_nowait(port_id, &link);
+ if (ret < 0)
+ RTE_BOND_LOG(ERR, "Slave (port %u) link get failed", port_id);
+
+ if (ret == 0 && link.link_status) {
if (active_pos < internals->active_slave_count)
goto link_update;
.stats_reset = bond_ethdev_stats_reset,
.promiscuous_enable = bond_ethdev_promiscuous_enable,
.promiscuous_disable = bond_ethdev_promiscuous_disable,
+ .allmulticast_enable = bond_ethdev_allmulticast_enable,
+ .allmulticast_disable = bond_ethdev_allmulticast_disable,
.reta_update = bond_ethdev_rss_reta_update,
.reta_query = bond_ethdev_rss_reta_query,
.rss_hash_update = bond_ethdev_rss_hash_update,
eth_dev->data->nb_tx_queues = (uint16_t)1;
/* Allocate memory for storing MAC addresses */
- eth_dev->data->mac_addrs = rte_zmalloc_socket(name, ETHER_ADDR_LEN *
+ eth_dev->data->mac_addrs = rte_zmalloc_socket(name, RTE_ETHER_ADDR_LEN *
BOND_MAX_MAC_ADDRS, 0, socket_id);
if (eth_dev->data->mac_addrs == NULL) {
RTE_BOND_LOG(ERR,
"Failed to allocate %u bytes needed to store MAC addresses",
- ETHER_ADDR_LEN * BOND_MAX_MAC_ADDRS);
+ RTE_ETHER_ADDR_LEN * BOND_MAX_MAC_ADDRS);
goto err;
}
}
vlan_filter_bmp_size =
- rte_bitmap_get_memory_footprint(ETHER_MAX_VLAN_ID + 1);
+ rte_bitmap_get_memory_footprint(RTE_ETHER_MAX_VLAN_ID + 1);
internals->vlan_filter_bmpmem = rte_malloc(name, vlan_filter_bmp_size,
RTE_CACHE_LINE_SIZE);
if (internals->vlan_filter_bmpmem == NULL) {
goto err;
}
- internals->vlan_filter_bmp = rte_bitmap_init(ETHER_MAX_VLAN_ID + 1,
+ internals->vlan_filter_bmp = rte_bitmap_init(RTE_ETHER_MAX_VLAN_ID + 1,
internals->vlan_filter_bmpmem, vlan_filter_bmp_size);
if (internals->vlan_filter_bmp == NULL) {
RTE_BOND_LOG(ERR,