1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2010-2017 Intel Corporation
5 #include <netinet/in.h>
8 #include <rte_malloc.h>
9 #include <rte_ethdev_driver.h>
10 #include <rte_ethdev_vdev.h>
14 #include <rte_ip_frag.h>
15 #include <rte_devargs.h>
16 #include <rte_kvargs.h>
17 #include <rte_bus_vdev.h>
18 #include <rte_alarm.h>
19 #include <rte_cycles.h>
20 #include <rte_string_fns.h>
22 #include "rte_eth_bond.h"
23 #include "rte_eth_bond_private.h"
24 #include "rte_eth_bond_8023ad_private.h"
26 #define REORDER_PERIOD_MS 10
27 #define DEFAULT_POLLING_INTERVAL_10_MS (10)
28 #define BOND_MAX_MAC_ADDRS 16
30 #define HASH_L4_PORTS(h) ((h)->src_port ^ (h)->dst_port)
32 /* Table for statistics in mode 5 TLB */
33 static uint64_t tlb_last_obytets[RTE_MAX_ETHPORTS];
36 get_vlan_offset(struct ether_hdr *eth_hdr, uint16_t *proto)
38 size_t vlan_offset = 0;
40 if (rte_cpu_to_be_16(ETHER_TYPE_VLAN) == *proto ||
41 rte_cpu_to_be_16(ETHER_TYPE_QINQ) == *proto) {
42 struct vlan_hdr *vlan_hdr = (struct vlan_hdr *)(eth_hdr + 1);
44 vlan_offset = sizeof(struct vlan_hdr);
45 *proto = vlan_hdr->eth_proto;
47 if (rte_cpu_to_be_16(ETHER_TYPE_VLAN) == *proto) {
48 vlan_hdr = vlan_hdr + 1;
49 *proto = vlan_hdr->eth_proto;
50 vlan_offset += sizeof(struct vlan_hdr);
57 bond_ethdev_rx_burst(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
59 struct bond_dev_private *internals;
61 uint16_t num_rx_total = 0;
63 uint16_t active_slave;
66 /* Cast to structure, containing bonded device's port id and queue id */
67 struct bond_rx_queue *bd_rx_q = (struct bond_rx_queue *)queue;
68 internals = bd_rx_q->dev_private;
69 slave_count = internals->active_slave_count;
70 active_slave = internals->active_slave;
72 for (i = 0; i < slave_count && nb_pkts; i++) {
73 uint16_t num_rx_slave;
75 /* Offset of pointer to *bufs increases as packets are received
76 * from other slaves */
78 rte_eth_rx_burst(internals->active_slaves[active_slave],
80 bufs + num_rx_total, nb_pkts);
81 num_rx_total += num_rx_slave;
82 nb_pkts -= num_rx_slave;
83 if (++active_slave == slave_count)
87 if (++internals->active_slave == slave_count)
88 internals->active_slave = 0;
93 bond_ethdev_rx_burst_active_backup(void *queue, struct rte_mbuf **bufs,
96 struct bond_dev_private *internals;
98 /* Cast to structure, containing bonded device's port id and queue id */
99 struct bond_rx_queue *bd_rx_q = (struct bond_rx_queue *)queue;
101 internals = bd_rx_q->dev_private;
103 return rte_eth_rx_burst(internals->current_primary_port,
104 bd_rx_q->queue_id, bufs, nb_pkts);
107 static inline uint8_t
108 is_lacp_packets(uint16_t ethertype, uint8_t subtype, struct rte_mbuf *mbuf)
110 const uint16_t ether_type_slow_be = rte_be_to_cpu_16(ETHER_TYPE_SLOW);
112 return !((mbuf->ol_flags & PKT_RX_VLAN) ? mbuf->vlan_tci : 0) &&
113 (ethertype == ether_type_slow_be &&
114 (subtype == SLOW_SUBTYPE_MARKER || subtype == SLOW_SUBTYPE_LACP));
117 /*****************************************************************************
118 * Flow director's setup for mode 4 optimization
121 static struct rte_flow_item_eth flow_item_eth_type_8023ad = {
122 .dst.addr_bytes = { 0 },
123 .src.addr_bytes = { 0 },
124 .type = RTE_BE16(ETHER_TYPE_SLOW),
127 static struct rte_flow_item_eth flow_item_eth_mask_type_8023ad = {
128 .dst.addr_bytes = { 0 },
129 .src.addr_bytes = { 0 },
133 static struct rte_flow_item flow_item_8023ad[] = {
135 .type = RTE_FLOW_ITEM_TYPE_ETH,
136 .spec = &flow_item_eth_type_8023ad,
138 .mask = &flow_item_eth_mask_type_8023ad,
141 .type = RTE_FLOW_ITEM_TYPE_END,
148 const struct rte_flow_attr flow_attr_8023ad = {
157 bond_ethdev_8023ad_flow_verify(struct rte_eth_dev *bond_dev,
158 uint16_t slave_port) {
159 struct rte_eth_dev_info slave_info;
160 struct rte_flow_error error;
161 struct bond_dev_private *internals = (struct bond_dev_private *)
162 (bond_dev->data->dev_private);
164 const struct rte_flow_action_queue lacp_queue_conf = {
168 const struct rte_flow_action actions[] = {
170 .type = RTE_FLOW_ACTION_TYPE_QUEUE,
171 .conf = &lacp_queue_conf
174 .type = RTE_FLOW_ACTION_TYPE_END,
178 int ret = rte_flow_validate(slave_port, &flow_attr_8023ad,
179 flow_item_8023ad, actions, &error);
181 RTE_BOND_LOG(ERR, "%s: %s (slave_port=%d queue_id=%d)",
182 __func__, error.message, slave_port,
183 internals->mode4.dedicated_queues.rx_qid);
187 rte_eth_dev_info_get(slave_port, &slave_info);
188 if (slave_info.max_rx_queues < bond_dev->data->nb_rx_queues ||
189 slave_info.max_tx_queues < bond_dev->data->nb_tx_queues) {
191 "%s: Slave %d capabilities doesn't allow to allocate additional queues",
192 __func__, slave_port);
200 bond_8023ad_slow_pkt_hw_filter_supported(uint16_t port_id) {
201 struct rte_eth_dev *bond_dev = &rte_eth_devices[port_id];
202 struct bond_dev_private *internals = (struct bond_dev_private *)
203 (bond_dev->data->dev_private);
204 struct rte_eth_dev_info bond_info;
207 /* Verify if all slaves in bonding supports flow director and */
208 if (internals->slave_count > 0) {
209 rte_eth_dev_info_get(bond_dev->data->port_id, &bond_info);
211 internals->mode4.dedicated_queues.rx_qid = bond_info.nb_rx_queues;
212 internals->mode4.dedicated_queues.tx_qid = bond_info.nb_tx_queues;
214 for (idx = 0; idx < internals->slave_count; idx++) {
215 if (bond_ethdev_8023ad_flow_verify(bond_dev,
216 internals->slaves[idx].port_id) != 0)
225 bond_ethdev_8023ad_flow_set(struct rte_eth_dev *bond_dev, uint16_t slave_port) {
227 struct rte_flow_error error;
228 struct bond_dev_private *internals = (struct bond_dev_private *)
229 (bond_dev->data->dev_private);
231 struct rte_flow_action_queue lacp_queue_conf = {
232 .index = internals->mode4.dedicated_queues.rx_qid,
235 const struct rte_flow_action actions[] = {
237 .type = RTE_FLOW_ACTION_TYPE_QUEUE,
238 .conf = &lacp_queue_conf
241 .type = RTE_FLOW_ACTION_TYPE_END,
245 internals->mode4.dedicated_queues.flow[slave_port] = rte_flow_create(slave_port,
246 &flow_attr_8023ad, flow_item_8023ad, actions, &error);
247 if (internals->mode4.dedicated_queues.flow[slave_port] == NULL) {
248 RTE_BOND_LOG(ERR, "bond_ethdev_8023ad_flow_set: %s "
249 "(slave_port=%d queue_id=%d)",
250 error.message, slave_port,
251 internals->mode4.dedicated_queues.rx_qid);
259 bond_ethdev_rx_burst_8023ad_fast_queue(void *queue, struct rte_mbuf **bufs,
262 struct bond_rx_queue *bd_rx_q = (struct bond_rx_queue *)queue;
263 struct bond_dev_private *internals = bd_rx_q->dev_private;
264 uint16_t num_rx_total = 0; /* Total number of received packets */
265 uint16_t slaves[RTE_MAX_ETHPORTS];
266 uint16_t slave_count;
267 uint16_t active_slave;
270 /* Copy slave list to protect against slave up/down changes during tx
272 slave_count = internals->active_slave_count;
273 active_slave = internals->active_slave;
274 memcpy(slaves, internals->active_slaves,
275 sizeof(internals->active_slaves[0]) * slave_count);
277 for (i = 0; i < slave_count && nb_pkts; i++) {
278 uint16_t num_rx_slave;
280 /* Read packets from this slave */
281 num_rx_slave = rte_eth_rx_burst(slaves[active_slave],
283 bufs + num_rx_total, nb_pkts);
284 num_rx_total += num_rx_slave;
285 nb_pkts -= num_rx_slave;
287 if (++active_slave == slave_count)
291 if (++internals->active_slave == slave_count)
292 internals->active_slave = 0;
298 bond_ethdev_tx_burst_8023ad_fast_queue(void *queue, struct rte_mbuf **bufs,
301 struct bond_tx_queue *bd_tx_q = (struct bond_tx_queue *)queue;
302 struct bond_dev_private *internals = bd_tx_q->dev_private;
304 uint16_t slave_port_ids[RTE_MAX_ETHPORTS];
305 uint16_t slave_count;
307 uint16_t dist_slave_port_ids[RTE_MAX_ETHPORTS];
308 uint16_t dist_slave_count;
310 /* 2-D array to sort mbufs for transmission on each slave into */
311 struct rte_mbuf *slave_bufs[RTE_MAX_ETHPORTS][nb_bufs];
312 /* Number of mbufs for transmission on each slave */
313 uint16_t slave_nb_bufs[RTE_MAX_ETHPORTS] = { 0 };
314 /* Mapping array generated by hash function to map mbufs to slaves */
315 uint16_t bufs_slave_port_idxs[RTE_MAX_ETHPORTS] = { 0 };
317 uint16_t slave_tx_count;
318 uint16_t total_tx_count = 0, total_tx_fail_count = 0;
322 if (unlikely(nb_bufs == 0))
325 /* Copy slave list to protect against slave up/down changes during tx
327 slave_count = internals->active_slave_count;
328 if (unlikely(slave_count < 1))
331 memcpy(slave_port_ids, internals->active_slaves,
332 sizeof(slave_port_ids[0]) * slave_count);
335 dist_slave_count = 0;
336 for (i = 0; i < slave_count; i++) {
337 struct port *port = &mode_8023ad_ports[slave_port_ids[i]];
339 if (ACTOR_STATE(port, DISTRIBUTING))
340 dist_slave_port_ids[dist_slave_count++] =
344 if (unlikely(dist_slave_count < 1))
348 * Populate slaves mbuf with the packets which are to be sent on it
349 * selecting output slave using hash based on xmit policy
351 internals->burst_xmit_hash(bufs, nb_bufs, dist_slave_count,
352 bufs_slave_port_idxs);
354 for (i = 0; i < nb_bufs; i++) {
355 /* Populate slave mbuf arrays with mbufs for that slave. */
356 uint8_t slave_idx = bufs_slave_port_idxs[i];
358 slave_bufs[slave_idx][slave_nb_bufs[slave_idx]++] = bufs[i];
362 /* Send packet burst on each slave device */
363 for (i = 0; i < dist_slave_count; i++) {
364 if (slave_nb_bufs[i] == 0)
367 slave_tx_count = rte_eth_tx_burst(dist_slave_port_ids[i],
368 bd_tx_q->queue_id, slave_bufs[i],
371 total_tx_count += slave_tx_count;
373 /* If tx burst fails move packets to end of bufs */
374 if (unlikely(slave_tx_count < slave_nb_bufs[i])) {
375 int slave_tx_fail_count = slave_nb_bufs[i] -
377 total_tx_fail_count += slave_tx_fail_count;
378 memcpy(&bufs[nb_bufs - total_tx_fail_count],
379 &slave_bufs[i][slave_tx_count],
380 slave_tx_fail_count * sizeof(bufs[0]));
384 return total_tx_count;
389 bond_ethdev_rx_burst_8023ad(void *queue, struct rte_mbuf **bufs,
392 /* Cast to structure, containing bonded device's port id and queue id */
393 struct bond_rx_queue *bd_rx_q = (struct bond_rx_queue *)queue;
394 struct bond_dev_private *internals = bd_rx_q->dev_private;
395 struct ether_addr bond_mac;
397 struct ether_hdr *hdr;
399 const uint16_t ether_type_slow_be = rte_be_to_cpu_16(ETHER_TYPE_SLOW);
400 uint16_t num_rx_total = 0; /* Total number of received packets */
401 uint16_t slaves[RTE_MAX_ETHPORTS];
402 uint16_t slave_count, idx;
404 uint8_t collecting; /* current slave collecting status */
405 const uint8_t promisc = internals->promiscuous_en;
409 rte_eth_macaddr_get(internals->port_id, &bond_mac);
410 /* Copy slave list to protect against slave up/down changes during tx
412 slave_count = internals->active_slave_count;
413 memcpy(slaves, internals->active_slaves,
414 sizeof(internals->active_slaves[0]) * slave_count);
416 idx = internals->active_slave;
417 if (idx >= slave_count) {
418 internals->active_slave = 0;
421 for (i = 0; i < slave_count && num_rx_total < nb_pkts; i++) {
423 collecting = ACTOR_STATE(&mode_8023ad_ports[slaves[idx]],
426 /* Read packets from this slave */
427 num_rx_total += rte_eth_rx_burst(slaves[idx], bd_rx_q->queue_id,
428 &bufs[num_rx_total], nb_pkts - num_rx_total);
430 for (k = j; k < 2 && k < num_rx_total; k++)
431 rte_prefetch0(rte_pktmbuf_mtod(bufs[k], void *));
433 /* Handle slow protocol packets. */
434 while (j < num_rx_total) {
436 /* If packet is not pure L2 and is known, skip it */
437 if ((bufs[j]->packet_type & ~RTE_PTYPE_L2_ETHER) != 0) {
442 if (j + 3 < num_rx_total)
443 rte_prefetch0(rte_pktmbuf_mtod(bufs[j + 3], void *));
445 hdr = rte_pktmbuf_mtod(bufs[j], struct ether_hdr *);
446 subtype = ((struct slow_protocol_frame *)hdr)->slow_protocol.subtype;
448 /* Remove packet from array if it is slow packet or slave is not
449 * in collecting state or bonding interface is not in promiscuous
450 * mode and packet address does not match. */
451 if (unlikely(is_lacp_packets(hdr->ether_type, subtype, bufs[j]) ||
452 !collecting || (!promisc &&
453 !is_multicast_ether_addr(&hdr->d_addr) &&
454 !is_same_ether_addr(&bond_mac, &hdr->d_addr)))) {
456 if (hdr->ether_type == ether_type_slow_be) {
457 bond_mode_8023ad_handle_slow_pkt(
458 internals, slaves[idx], bufs[j]);
460 rte_pktmbuf_free(bufs[j]);
462 /* Packet is managed by mode 4 or dropped, shift the array */
464 if (j < num_rx_total) {
465 memmove(&bufs[j], &bufs[j + 1], sizeof(bufs[0]) *
471 if (unlikely(++idx == slave_count))
475 if (++internals->active_slave == slave_count)
476 internals->active_slave = 0;
481 #if defined(RTE_LIBRTE_BOND_DEBUG_ALB) || defined(RTE_LIBRTE_BOND_DEBUG_ALB_L1)
482 uint32_t burstnumberRX;
483 uint32_t burstnumberTX;
485 #ifdef RTE_LIBRTE_BOND_DEBUG_ALB
488 arp_op_name(uint16_t arp_op, char *buf)
492 snprintf(buf, sizeof("ARP Request"), "%s", "ARP Request");
495 snprintf(buf, sizeof("ARP Reply"), "%s", "ARP Reply");
497 case ARP_OP_REVREQUEST:
498 snprintf(buf, sizeof("Reverse ARP Request"), "%s",
499 "Reverse ARP Request");
501 case ARP_OP_REVREPLY:
502 snprintf(buf, sizeof("Reverse ARP Reply"), "%s",
503 "Reverse ARP Reply");
505 case ARP_OP_INVREQUEST:
506 snprintf(buf, sizeof("Peer Identify Request"), "%s",
507 "Peer Identify Request");
509 case ARP_OP_INVREPLY:
510 snprintf(buf, sizeof("Peer Identify Reply"), "%s",
511 "Peer Identify Reply");
516 snprintf(buf, sizeof("Unknown"), "%s", "Unknown");
520 #define MaxIPv4String 16
522 ipv4_addr_to_dot(uint32_t be_ipv4_addr, char *buf, uint8_t buf_size)
526 ipv4_addr = rte_be_to_cpu_32(be_ipv4_addr);
527 snprintf(buf, buf_size, "%d.%d.%d.%d", (ipv4_addr >> 24) & 0xFF,
528 (ipv4_addr >> 16) & 0xFF, (ipv4_addr >> 8) & 0xFF,
532 #define MAX_CLIENTS_NUMBER 128
533 uint8_t active_clients;
534 struct client_stats_t {
537 uint32_t ipv4_rx_packets;
538 uint32_t ipv4_tx_packets;
540 struct client_stats_t client_stats[MAX_CLIENTS_NUMBER];
543 update_client_stats(uint32_t addr, uint16_t port, uint32_t *TXorRXindicator)
547 for (; i < MAX_CLIENTS_NUMBER; i++) {
548 if ((client_stats[i].ipv4_addr == addr) && (client_stats[i].port == port)) {
549 /* Just update RX packets number for this client */
550 if (TXorRXindicator == &burstnumberRX)
551 client_stats[i].ipv4_rx_packets++;
553 client_stats[i].ipv4_tx_packets++;
557 /* We have a new client. Insert him to the table, and increment stats */
558 if (TXorRXindicator == &burstnumberRX)
559 client_stats[active_clients].ipv4_rx_packets++;
561 client_stats[active_clients].ipv4_tx_packets++;
562 client_stats[active_clients].ipv4_addr = addr;
563 client_stats[active_clients].port = port;
568 #ifdef RTE_LIBRTE_BOND_DEBUG_ALB
569 #define MODE6_DEBUG(info, src_ip, dst_ip, eth_h, arp_op, port, burstnumber) \
570 rte_log(RTE_LOG_DEBUG, bond_logtype, \
571 "%s port:%d SrcMAC:%02X:%02X:%02X:%02X:%02X:%02X SrcIP:%s " \
572 "DstMAC:%02X:%02X:%02X:%02X:%02X:%02X DstIP:%s %s %d\n", \
575 eth_h->s_addr.addr_bytes[0], eth_h->s_addr.addr_bytes[1], \
576 eth_h->s_addr.addr_bytes[2], eth_h->s_addr.addr_bytes[3], \
577 eth_h->s_addr.addr_bytes[4], eth_h->s_addr.addr_bytes[5], \
579 eth_h->d_addr.addr_bytes[0], eth_h->d_addr.addr_bytes[1], \
580 eth_h->d_addr.addr_bytes[2], eth_h->d_addr.addr_bytes[3], \
581 eth_h->d_addr.addr_bytes[4], eth_h->d_addr.addr_bytes[5], \
583 arp_op, ++burstnumber)
587 mode6_debug(const char __attribute__((unused)) *info, struct ether_hdr *eth_h,
588 uint16_t port, uint32_t __attribute__((unused)) *burstnumber)
590 struct ipv4_hdr *ipv4_h;
591 #ifdef RTE_LIBRTE_BOND_DEBUG_ALB
592 struct arp_hdr *arp_h;
599 uint16_t ether_type = eth_h->ether_type;
600 uint16_t offset = get_vlan_offset(eth_h, ðer_type);
602 #ifdef RTE_LIBRTE_BOND_DEBUG_ALB
603 strlcpy(buf, info, 16);
606 if (ether_type == rte_cpu_to_be_16(ETHER_TYPE_IPv4)) {
607 ipv4_h = (struct ipv4_hdr *)((char *)(eth_h + 1) + offset);
608 ipv4_addr_to_dot(ipv4_h->src_addr, src_ip, MaxIPv4String);
609 #ifdef RTE_LIBRTE_BOND_DEBUG_ALB
610 ipv4_addr_to_dot(ipv4_h->dst_addr, dst_ip, MaxIPv4String);
611 MODE6_DEBUG(buf, src_ip, dst_ip, eth_h, "", port, *burstnumber);
613 update_client_stats(ipv4_h->src_addr, port, burstnumber);
615 #ifdef RTE_LIBRTE_BOND_DEBUG_ALB
616 else if (ether_type == rte_cpu_to_be_16(ETHER_TYPE_ARP)) {
617 arp_h = (struct arp_hdr *)((char *)(eth_h + 1) + offset);
618 ipv4_addr_to_dot(arp_h->arp_data.arp_sip, src_ip, MaxIPv4String);
619 ipv4_addr_to_dot(arp_h->arp_data.arp_tip, dst_ip, MaxIPv4String);
620 arp_op_name(rte_be_to_cpu_16(arp_h->arp_op), ArpOp);
621 MODE6_DEBUG(buf, src_ip, dst_ip, eth_h, ArpOp, port, *burstnumber);
628 bond_ethdev_rx_burst_alb(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
630 struct bond_tx_queue *bd_tx_q = (struct bond_tx_queue *)queue;
631 struct bond_dev_private *internals = bd_tx_q->dev_private;
632 struct ether_hdr *eth_h;
633 uint16_t ether_type, offset;
634 uint16_t nb_recv_pkts;
637 nb_recv_pkts = bond_ethdev_rx_burst(queue, bufs, nb_pkts);
639 for (i = 0; i < nb_recv_pkts; i++) {
640 eth_h = rte_pktmbuf_mtod(bufs[i], struct ether_hdr *);
641 ether_type = eth_h->ether_type;
642 offset = get_vlan_offset(eth_h, ðer_type);
644 if (ether_type == rte_cpu_to_be_16(ETHER_TYPE_ARP)) {
645 #if defined(RTE_LIBRTE_BOND_DEBUG_ALB) || defined(RTE_LIBRTE_BOND_DEBUG_ALB_L1)
646 mode6_debug("RX ARP:", eth_h, bufs[i]->port, &burstnumberRX);
648 bond_mode_alb_arp_recv(eth_h, offset, internals);
650 #if defined(RTE_LIBRTE_BOND_DEBUG_ALB) || defined(RTE_LIBRTE_BOND_DEBUG_ALB_L1)
651 else if (ether_type == rte_cpu_to_be_16(ETHER_TYPE_IPv4))
652 mode6_debug("RX IPv4:", eth_h, bufs[i]->port, &burstnumberRX);
660 bond_ethdev_tx_burst_round_robin(void *queue, struct rte_mbuf **bufs,
663 struct bond_dev_private *internals;
664 struct bond_tx_queue *bd_tx_q;
666 struct rte_mbuf *slave_bufs[RTE_MAX_ETHPORTS][nb_pkts];
667 uint16_t slave_nb_pkts[RTE_MAX_ETHPORTS] = { 0 };
669 uint16_t num_of_slaves;
670 uint16_t slaves[RTE_MAX_ETHPORTS];
672 uint16_t num_tx_total = 0, num_tx_slave;
674 static int slave_idx = 0;
675 int i, cslave_idx = 0, tx_fail_total = 0;
677 bd_tx_q = (struct bond_tx_queue *)queue;
678 internals = bd_tx_q->dev_private;
680 /* Copy slave list to protect against slave up/down changes during tx
682 num_of_slaves = internals->active_slave_count;
683 memcpy(slaves, internals->active_slaves,
684 sizeof(internals->active_slaves[0]) * num_of_slaves);
686 if (num_of_slaves < 1)
689 /* Populate slaves mbuf with which packets are to be sent on it */
690 for (i = 0; i < nb_pkts; i++) {
691 cslave_idx = (slave_idx + i) % num_of_slaves;
692 slave_bufs[cslave_idx][(slave_nb_pkts[cslave_idx])++] = bufs[i];
695 /* increment current slave index so the next call to tx burst starts on the
697 slave_idx = ++cslave_idx;
699 /* Send packet burst on each slave device */
700 for (i = 0; i < num_of_slaves; i++) {
701 if (slave_nb_pkts[i] > 0) {
702 num_tx_slave = rte_eth_tx_burst(slaves[i], bd_tx_q->queue_id,
703 slave_bufs[i], slave_nb_pkts[i]);
705 /* if tx burst fails move packets to end of bufs */
706 if (unlikely(num_tx_slave < slave_nb_pkts[i])) {
707 int tx_fail_slave = slave_nb_pkts[i] - num_tx_slave;
709 tx_fail_total += tx_fail_slave;
711 memcpy(&bufs[nb_pkts - tx_fail_total],
712 &slave_bufs[i][num_tx_slave],
713 tx_fail_slave * sizeof(bufs[0]));
715 num_tx_total += num_tx_slave;
723 bond_ethdev_tx_burst_active_backup(void *queue,
724 struct rte_mbuf **bufs, uint16_t nb_pkts)
726 struct bond_dev_private *internals;
727 struct bond_tx_queue *bd_tx_q;
729 bd_tx_q = (struct bond_tx_queue *)queue;
730 internals = bd_tx_q->dev_private;
732 if (internals->active_slave_count < 1)
735 return rte_eth_tx_burst(internals->current_primary_port, bd_tx_q->queue_id,
739 static inline uint16_t
740 ether_hash(struct ether_hdr *eth_hdr)
742 unaligned_uint16_t *word_src_addr =
743 (unaligned_uint16_t *)eth_hdr->s_addr.addr_bytes;
744 unaligned_uint16_t *word_dst_addr =
745 (unaligned_uint16_t *)eth_hdr->d_addr.addr_bytes;
747 return (word_src_addr[0] ^ word_dst_addr[0]) ^
748 (word_src_addr[1] ^ word_dst_addr[1]) ^
749 (word_src_addr[2] ^ word_dst_addr[2]);
752 static inline uint32_t
753 ipv4_hash(struct ipv4_hdr *ipv4_hdr)
755 return ipv4_hdr->src_addr ^ ipv4_hdr->dst_addr;
758 static inline uint32_t
759 ipv6_hash(struct ipv6_hdr *ipv6_hdr)
761 unaligned_uint32_t *word_src_addr =
762 (unaligned_uint32_t *)&(ipv6_hdr->src_addr[0]);
763 unaligned_uint32_t *word_dst_addr =
764 (unaligned_uint32_t *)&(ipv6_hdr->dst_addr[0]);
766 return (word_src_addr[0] ^ word_dst_addr[0]) ^
767 (word_src_addr[1] ^ word_dst_addr[1]) ^
768 (word_src_addr[2] ^ word_dst_addr[2]) ^
769 (word_src_addr[3] ^ word_dst_addr[3]);
774 burst_xmit_l2_hash(struct rte_mbuf **buf, uint16_t nb_pkts,
775 uint8_t slave_count, uint16_t *slaves)
777 struct ether_hdr *eth_hdr;
781 for (i = 0; i < nb_pkts; i++) {
782 eth_hdr = rte_pktmbuf_mtod(buf[i], struct ether_hdr *);
784 hash = ether_hash(eth_hdr);
786 slaves[i] = (hash ^= hash >> 8) % slave_count;
791 burst_xmit_l23_hash(struct rte_mbuf **buf, uint16_t nb_pkts,
792 uint8_t slave_count, uint16_t *slaves)
795 struct ether_hdr *eth_hdr;
798 uint32_t hash, l3hash;
800 for (i = 0; i < nb_pkts; i++) {
801 eth_hdr = rte_pktmbuf_mtod(buf[i], struct ether_hdr *);
804 proto = eth_hdr->ether_type;
805 hash = ether_hash(eth_hdr);
807 vlan_offset = get_vlan_offset(eth_hdr, &proto);
809 if (rte_cpu_to_be_16(ETHER_TYPE_IPv4) == proto) {
810 struct ipv4_hdr *ipv4_hdr = (struct ipv4_hdr *)
811 ((char *)(eth_hdr + 1) + vlan_offset);
812 l3hash = ipv4_hash(ipv4_hdr);
814 } else if (rte_cpu_to_be_16(ETHER_TYPE_IPv6) == proto) {
815 struct ipv6_hdr *ipv6_hdr = (struct ipv6_hdr *)
816 ((char *)(eth_hdr + 1) + vlan_offset);
817 l3hash = ipv6_hash(ipv6_hdr);
820 hash = hash ^ l3hash;
824 slaves[i] = hash % slave_count;
829 burst_xmit_l34_hash(struct rte_mbuf **buf, uint16_t nb_pkts,
830 uint8_t slave_count, uint16_t *slaves)
832 struct ether_hdr *eth_hdr;
837 struct udp_hdr *udp_hdr;
838 struct tcp_hdr *tcp_hdr;
839 uint32_t hash, l3hash, l4hash;
841 for (i = 0; i < nb_pkts; i++) {
842 eth_hdr = rte_pktmbuf_mtod(buf[i], struct ether_hdr *);
843 proto = eth_hdr->ether_type;
844 vlan_offset = get_vlan_offset(eth_hdr, &proto);
848 if (rte_cpu_to_be_16(ETHER_TYPE_IPv4) == proto) {
849 struct ipv4_hdr *ipv4_hdr = (struct ipv4_hdr *)
850 ((char *)(eth_hdr + 1) + vlan_offset);
851 size_t ip_hdr_offset;
853 l3hash = ipv4_hash(ipv4_hdr);
855 /* there is no L4 header in fragmented packet */
856 if (likely(rte_ipv4_frag_pkt_is_fragmented(ipv4_hdr)
858 ip_hdr_offset = (ipv4_hdr->version_ihl
859 & IPV4_HDR_IHL_MASK) *
862 if (ipv4_hdr->next_proto_id == IPPROTO_TCP) {
863 tcp_hdr = (struct tcp_hdr *)
866 l4hash = HASH_L4_PORTS(tcp_hdr);
867 } else if (ipv4_hdr->next_proto_id ==
869 udp_hdr = (struct udp_hdr *)
872 l4hash = HASH_L4_PORTS(udp_hdr);
875 } else if (rte_cpu_to_be_16(ETHER_TYPE_IPv6) == proto) {
876 struct ipv6_hdr *ipv6_hdr = (struct ipv6_hdr *)
877 ((char *)(eth_hdr + 1) + vlan_offset);
878 l3hash = ipv6_hash(ipv6_hdr);
880 if (ipv6_hdr->proto == IPPROTO_TCP) {
881 tcp_hdr = (struct tcp_hdr *)(ipv6_hdr + 1);
882 l4hash = HASH_L4_PORTS(tcp_hdr);
883 } else if (ipv6_hdr->proto == IPPROTO_UDP) {
884 udp_hdr = (struct udp_hdr *)(ipv6_hdr + 1);
885 l4hash = HASH_L4_PORTS(udp_hdr);
889 hash = l3hash ^ l4hash;
893 slaves[i] = hash % slave_count;
898 uint64_t bwg_left_int;
899 uint64_t bwg_left_remainder;
904 bond_tlb_activate_slave(struct bond_dev_private *internals) {
907 for (i = 0; i < internals->active_slave_count; i++) {
908 tlb_last_obytets[internals->active_slaves[i]] = 0;
913 bandwidth_cmp(const void *a, const void *b)
915 const struct bwg_slave *bwg_a = a;
916 const struct bwg_slave *bwg_b = b;
917 int64_t diff = (int64_t)bwg_b->bwg_left_int - (int64_t)bwg_a->bwg_left_int;
918 int64_t diff2 = (int64_t)bwg_b->bwg_left_remainder -
919 (int64_t)bwg_a->bwg_left_remainder;
933 bandwidth_left(uint16_t port_id, uint64_t load, uint8_t update_idx,
934 struct bwg_slave *bwg_slave)
936 struct rte_eth_link link_status;
938 rte_eth_link_get_nowait(port_id, &link_status);
939 uint64_t link_bwg = link_status.link_speed * 1000000ULL / 8;
942 link_bwg = link_bwg * (update_idx+1) * REORDER_PERIOD_MS;
943 bwg_slave->bwg_left_int = (link_bwg - 1000*load) / link_bwg;
944 bwg_slave->bwg_left_remainder = (link_bwg - 1000*load) % link_bwg;
948 bond_ethdev_update_tlb_slave_cb(void *arg)
950 struct bond_dev_private *internals = arg;
951 struct rte_eth_stats slave_stats;
952 struct bwg_slave bwg_array[RTE_MAX_ETHPORTS];
956 uint8_t update_stats = 0;
959 internals->slave_update_idx++;
962 if (internals->slave_update_idx >= REORDER_PERIOD_MS)
965 for (i = 0; i < internals->active_slave_count; i++) {
966 slave_id = internals->active_slaves[i];
967 rte_eth_stats_get(slave_id, &slave_stats);
968 tx_bytes = slave_stats.obytes - tlb_last_obytets[slave_id];
969 bandwidth_left(slave_id, tx_bytes,
970 internals->slave_update_idx, &bwg_array[i]);
971 bwg_array[i].slave = slave_id;
974 tlb_last_obytets[slave_id] = slave_stats.obytes;
978 if (update_stats == 1)
979 internals->slave_update_idx = 0;
982 qsort(bwg_array, slave_count, sizeof(bwg_array[0]), bandwidth_cmp);
983 for (i = 0; i < slave_count; i++)
984 internals->tlb_slaves_order[i] = bwg_array[i].slave;
986 rte_eal_alarm_set(REORDER_PERIOD_MS * 1000, bond_ethdev_update_tlb_slave_cb,
987 (struct bond_dev_private *)internals);
991 bond_ethdev_tx_burst_tlb(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
993 struct bond_tx_queue *bd_tx_q = (struct bond_tx_queue *)queue;
994 struct bond_dev_private *internals = bd_tx_q->dev_private;
996 struct rte_eth_dev *primary_port =
997 &rte_eth_devices[internals->primary_port];
998 uint16_t num_tx_total = 0;
1001 uint16_t num_of_slaves = internals->active_slave_count;
1002 uint16_t slaves[RTE_MAX_ETHPORTS];
1004 struct ether_hdr *ether_hdr;
1005 struct ether_addr primary_slave_addr;
1006 struct ether_addr active_slave_addr;
1008 if (num_of_slaves < 1)
1009 return num_tx_total;
1011 memcpy(slaves, internals->tlb_slaves_order,
1012 sizeof(internals->tlb_slaves_order[0]) * num_of_slaves);
1015 ether_addr_copy(primary_port->data->mac_addrs, &primary_slave_addr);
1018 for (i = 0; i < 3; i++)
1019 rte_prefetch0(rte_pktmbuf_mtod(bufs[i], void*));
1022 for (i = 0; i < num_of_slaves; i++) {
1023 rte_eth_macaddr_get(slaves[i], &active_slave_addr);
1024 for (j = num_tx_total; j < nb_pkts; j++) {
1025 if (j + 3 < nb_pkts)
1026 rte_prefetch0(rte_pktmbuf_mtod(bufs[j+3], void*));
1028 ether_hdr = rte_pktmbuf_mtod(bufs[j], struct ether_hdr *);
1029 if (is_same_ether_addr(ðer_hdr->s_addr, &primary_slave_addr))
1030 ether_addr_copy(&active_slave_addr, ðer_hdr->s_addr);
1031 #if defined(RTE_LIBRTE_BOND_DEBUG_ALB) || defined(RTE_LIBRTE_BOND_DEBUG_ALB_L1)
1032 mode6_debug("TX IPv4:", ether_hdr, slaves[i], &burstnumberTX);
1036 num_tx_total += rte_eth_tx_burst(slaves[i], bd_tx_q->queue_id,
1037 bufs + num_tx_total, nb_pkts - num_tx_total);
1039 if (num_tx_total == nb_pkts)
1043 return num_tx_total;
1047 bond_tlb_disable(struct bond_dev_private *internals)
1049 rte_eal_alarm_cancel(bond_ethdev_update_tlb_slave_cb, internals);
1053 bond_tlb_enable(struct bond_dev_private *internals)
1055 bond_ethdev_update_tlb_slave_cb(internals);
1059 bond_ethdev_tx_burst_alb(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
1061 struct bond_tx_queue *bd_tx_q = (struct bond_tx_queue *)queue;
1062 struct bond_dev_private *internals = bd_tx_q->dev_private;
1064 struct ether_hdr *eth_h;
1065 uint16_t ether_type, offset;
1067 struct client_data *client_info;
1070 * We create transmit buffers for every slave and one additional to send
1071 * through tlb. In worst case every packet will be send on one port.
1073 struct rte_mbuf *slave_bufs[RTE_MAX_ETHPORTS + 1][nb_pkts];
1074 uint16_t slave_bufs_pkts[RTE_MAX_ETHPORTS + 1] = { 0 };
1077 * We create separate transmit buffers for update packets as they won't
1078 * be counted in num_tx_total.
1080 struct rte_mbuf *update_bufs[RTE_MAX_ETHPORTS][ALB_HASH_TABLE_SIZE];
1081 uint16_t update_bufs_pkts[RTE_MAX_ETHPORTS] = { 0 };
1083 struct rte_mbuf *upd_pkt;
1086 uint16_t num_send, num_not_send = 0;
1087 uint16_t num_tx_total = 0;
1092 /* Search tx buffer for ARP packets and forward them to alb */
1093 for (i = 0; i < nb_pkts; i++) {
1094 eth_h = rte_pktmbuf_mtod(bufs[i], struct ether_hdr *);
1095 ether_type = eth_h->ether_type;
1096 offset = get_vlan_offset(eth_h, ðer_type);
1098 if (ether_type == rte_cpu_to_be_16(ETHER_TYPE_ARP)) {
1099 slave_idx = bond_mode_alb_arp_xmit(eth_h, offset, internals);
1101 /* Change src mac in eth header */
1102 rte_eth_macaddr_get(slave_idx, ð_h->s_addr);
1104 /* Add packet to slave tx buffer */
1105 slave_bufs[slave_idx][slave_bufs_pkts[slave_idx]] = bufs[i];
1106 slave_bufs_pkts[slave_idx]++;
1108 /* If packet is not ARP, send it with TLB policy */
1109 slave_bufs[RTE_MAX_ETHPORTS][slave_bufs_pkts[RTE_MAX_ETHPORTS]] =
1111 slave_bufs_pkts[RTE_MAX_ETHPORTS]++;
1115 /* Update connected client ARP tables */
1116 if (internals->mode6.ntt) {
1117 for (i = 0; i < ALB_HASH_TABLE_SIZE; i++) {
1118 client_info = &internals->mode6.client_table[i];
1120 if (client_info->in_use) {
1121 /* Allocate new packet to send ARP update on current slave */
1122 upd_pkt = rte_pktmbuf_alloc(internals->mode6.mempool);
1123 if (upd_pkt == NULL) {
1125 "Failed to allocate ARP packet from pool");
1128 pkt_size = sizeof(struct ether_hdr) + sizeof(struct arp_hdr)
1129 + client_info->vlan_count * sizeof(struct vlan_hdr);
1130 upd_pkt->data_len = pkt_size;
1131 upd_pkt->pkt_len = pkt_size;
1133 slave_idx = bond_mode_alb_arp_upd(client_info, upd_pkt,
1136 /* Add packet to update tx buffer */
1137 update_bufs[slave_idx][update_bufs_pkts[slave_idx]] = upd_pkt;
1138 update_bufs_pkts[slave_idx]++;
1141 internals->mode6.ntt = 0;
1144 /* Send ARP packets on proper slaves */
1145 for (i = 0; i < RTE_MAX_ETHPORTS; i++) {
1146 if (slave_bufs_pkts[i] > 0) {
1147 num_send = rte_eth_tx_burst(i, bd_tx_q->queue_id,
1148 slave_bufs[i], slave_bufs_pkts[i]);
1149 for (j = 0; j < slave_bufs_pkts[i] - num_send; j++) {
1150 bufs[nb_pkts - 1 - num_not_send - j] =
1151 slave_bufs[i][nb_pkts - 1 - j];
1154 num_tx_total += num_send;
1155 num_not_send += slave_bufs_pkts[i] - num_send;
1157 #if defined(RTE_LIBRTE_BOND_DEBUG_ALB) || defined(RTE_LIBRTE_BOND_DEBUG_ALB_L1)
1158 /* Print TX stats including update packets */
1159 for (j = 0; j < slave_bufs_pkts[i]; j++) {
1160 eth_h = rte_pktmbuf_mtod(slave_bufs[i][j], struct ether_hdr *);
1161 mode6_debug("TX ARP:", eth_h, i, &burstnumberTX);
1167 /* Send update packets on proper slaves */
1168 for (i = 0; i < RTE_MAX_ETHPORTS; i++) {
1169 if (update_bufs_pkts[i] > 0) {
1170 num_send = rte_eth_tx_burst(i, bd_tx_q->queue_id, update_bufs[i],
1171 update_bufs_pkts[i]);
1172 for (j = num_send; j < update_bufs_pkts[i]; j++) {
1173 rte_pktmbuf_free(update_bufs[i][j]);
1175 #if defined(RTE_LIBRTE_BOND_DEBUG_ALB) || defined(RTE_LIBRTE_BOND_DEBUG_ALB_L1)
1176 for (j = 0; j < update_bufs_pkts[i]; j++) {
1177 eth_h = rte_pktmbuf_mtod(update_bufs[i][j], struct ether_hdr *);
1178 mode6_debug("TX ARPupd:", eth_h, i, &burstnumberTX);
1184 /* Send non-ARP packets using tlb policy */
1185 if (slave_bufs_pkts[RTE_MAX_ETHPORTS] > 0) {
1186 num_send = bond_ethdev_tx_burst_tlb(queue,
1187 slave_bufs[RTE_MAX_ETHPORTS],
1188 slave_bufs_pkts[RTE_MAX_ETHPORTS]);
1190 for (j = 0; j < slave_bufs_pkts[RTE_MAX_ETHPORTS]; j++) {
1191 bufs[nb_pkts - 1 - num_not_send - j] =
1192 slave_bufs[RTE_MAX_ETHPORTS][nb_pkts - 1 - j];
1195 num_tx_total += num_send;
1198 return num_tx_total;
1202 bond_ethdev_tx_burst_balance(void *queue, struct rte_mbuf **bufs,
1205 struct bond_tx_queue *bd_tx_q = (struct bond_tx_queue *)queue;
1206 struct bond_dev_private *internals = bd_tx_q->dev_private;
1208 uint16_t slave_port_ids[RTE_MAX_ETHPORTS];
1209 uint16_t slave_count;
1211 /* Array to sort mbufs for transmission on each slave into */
1212 struct rte_mbuf *slave_bufs[RTE_MAX_ETHPORTS][nb_bufs];
1213 /* Number of mbufs for transmission on each slave */
1214 uint16_t slave_nb_bufs[RTE_MAX_ETHPORTS] = { 0 };
1215 /* Mapping array generated by hash function to map mbufs to slaves */
1216 uint16_t bufs_slave_port_idxs[nb_bufs];
1218 uint16_t slave_tx_count;
1219 uint16_t total_tx_count = 0, total_tx_fail_count = 0;
1223 if (unlikely(nb_bufs == 0))
1226 /* Copy slave list to protect against slave up/down changes during tx
1228 slave_count = internals->active_slave_count;
1229 if (unlikely(slave_count < 1))
1232 memcpy(slave_port_ids, internals->active_slaves,
1233 sizeof(slave_port_ids[0]) * slave_count);
1236 * Populate slaves mbuf with the packets which are to be sent on it
1237 * selecting output slave using hash based on xmit policy
1239 internals->burst_xmit_hash(bufs, nb_bufs, slave_count,
1240 bufs_slave_port_idxs);
1242 for (i = 0; i < nb_bufs; i++) {
1243 /* Populate slave mbuf arrays with mbufs for that slave. */
1244 uint8_t slave_idx = bufs_slave_port_idxs[i];
1246 slave_bufs[slave_idx][slave_nb_bufs[slave_idx]++] = bufs[i];
1249 /* Send packet burst on each slave device */
1250 for (i = 0; i < slave_count; i++) {
1251 if (slave_nb_bufs[i] == 0)
1254 slave_tx_count = rte_eth_tx_burst(slave_port_ids[i],
1255 bd_tx_q->queue_id, slave_bufs[i],
1258 total_tx_count += slave_tx_count;
1260 /* If tx burst fails move packets to end of bufs */
1261 if (unlikely(slave_tx_count < slave_nb_bufs[i])) {
1262 int slave_tx_fail_count = slave_nb_bufs[i] -
1264 total_tx_fail_count += slave_tx_fail_count;
1265 memcpy(&bufs[nb_bufs - total_tx_fail_count],
1266 &slave_bufs[i][slave_tx_count],
1267 slave_tx_fail_count * sizeof(bufs[0]));
1271 return total_tx_count;
1275 bond_ethdev_tx_burst_8023ad(void *queue, struct rte_mbuf **bufs,
1278 struct bond_tx_queue *bd_tx_q = (struct bond_tx_queue *)queue;
1279 struct bond_dev_private *internals = bd_tx_q->dev_private;
1281 uint16_t slave_port_ids[RTE_MAX_ETHPORTS];
1282 uint16_t slave_count;
1284 uint16_t dist_slave_port_ids[RTE_MAX_ETHPORTS];
1285 uint16_t dist_slave_count;
1287 /* 2-D array to sort mbufs for transmission on each slave into */
1288 struct rte_mbuf *slave_bufs[RTE_MAX_ETHPORTS][nb_bufs];
1289 /* Number of mbufs for transmission on each slave */
1290 uint16_t slave_nb_bufs[RTE_MAX_ETHPORTS] = { 0 };
1291 /* Mapping array generated by hash function to map mbufs to slaves */
1292 uint16_t bufs_slave_port_idxs[RTE_MAX_ETHPORTS] = { 0 };
1294 uint16_t slave_tx_count;
1295 uint16_t total_tx_count = 0, total_tx_fail_count = 0;
1299 if (unlikely(nb_bufs == 0))
1302 /* Copy slave list to protect against slave up/down changes during tx
1304 slave_count = internals->active_slave_count;
1305 if (unlikely(slave_count < 1))
1308 memcpy(slave_port_ids, internals->active_slaves,
1309 sizeof(slave_port_ids[0]) * slave_count);
1311 dist_slave_count = 0;
1312 for (i = 0; i < slave_count; i++) {
1313 struct port *port = &mode_8023ad_ports[slave_port_ids[i]];
1315 if (ACTOR_STATE(port, DISTRIBUTING))
1316 dist_slave_port_ids[dist_slave_count++] =
1320 if (likely(dist_slave_count > 1)) {
1323 * Populate slaves mbuf with the packets which are to be sent
1324 * on it, selecting output slave using hash based on xmit policy
1326 internals->burst_xmit_hash(bufs, nb_bufs, dist_slave_count,
1327 bufs_slave_port_idxs);
1329 for (i = 0; i < nb_bufs; i++) {
1331 * Populate slave mbuf arrays with mbufs for that
1334 uint8_t slave_idx = bufs_slave_port_idxs[i];
1336 slave_bufs[slave_idx][slave_nb_bufs[slave_idx]++] =
1341 /* Send packet burst on each slave device */
1342 for (i = 0; i < dist_slave_count; i++) {
1343 if (slave_nb_bufs[i] == 0)
1346 slave_tx_count = rte_eth_tx_burst(
1347 dist_slave_port_ids[i],
1348 bd_tx_q->queue_id, slave_bufs[i],
1351 total_tx_count += slave_tx_count;
1353 /* If tx burst fails move packets to end of bufs */
1354 if (unlikely(slave_tx_count < slave_nb_bufs[i])) {
1355 int slave_tx_fail_count = slave_nb_bufs[i] -
1357 total_tx_fail_count += slave_tx_fail_count;
1359 memcpy(&bufs[nb_bufs - total_tx_fail_count],
1360 &slave_bufs[i][slave_tx_count],
1361 slave_tx_fail_count * sizeof(bufs[0]));
1366 /* Check for LACP control packets and send if available */
1367 for (i = 0; i < slave_count; i++) {
1368 struct port *port = &mode_8023ad_ports[slave_port_ids[i]];
1369 struct rte_mbuf *ctrl_pkt = NULL;
1371 if (likely(rte_ring_empty(port->tx_ring)))
1374 if (rte_ring_dequeue(port->tx_ring,
1375 (void **)&ctrl_pkt) != -ENOENT) {
1376 slave_tx_count = rte_eth_tx_burst(slave_port_ids[i],
1377 bd_tx_q->queue_id, &ctrl_pkt, 1);
1379 * re-enqueue LAG control plane packets to buffering
1380 * ring if transmission fails so the packet isn't lost.
1382 if (slave_tx_count != 1)
1383 rte_ring_enqueue(port->tx_ring, ctrl_pkt);
1387 return total_tx_count;
1391 bond_ethdev_tx_burst_broadcast(void *queue, struct rte_mbuf **bufs,
1394 struct bond_dev_private *internals;
1395 struct bond_tx_queue *bd_tx_q;
1397 uint8_t tx_failed_flag = 0, num_of_slaves;
1398 uint16_t slaves[RTE_MAX_ETHPORTS];
1400 uint16_t max_nb_of_tx_pkts = 0;
1402 int slave_tx_total[RTE_MAX_ETHPORTS];
1403 int i, most_successful_tx_slave = -1;
1405 bd_tx_q = (struct bond_tx_queue *)queue;
1406 internals = bd_tx_q->dev_private;
1408 /* Copy slave list to protect against slave up/down changes during tx
1410 num_of_slaves = internals->active_slave_count;
1411 memcpy(slaves, internals->active_slaves,
1412 sizeof(internals->active_slaves[0]) * num_of_slaves);
1414 if (num_of_slaves < 1)
1417 /* Increment reference count on mbufs */
1418 for (i = 0; i < nb_pkts; i++)
1419 rte_mbuf_refcnt_update(bufs[i], num_of_slaves - 1);
1421 /* Transmit burst on each active slave */
1422 for (i = 0; i < num_of_slaves; i++) {
1423 slave_tx_total[i] = rte_eth_tx_burst(slaves[i], bd_tx_q->queue_id,
1426 if (unlikely(slave_tx_total[i] < nb_pkts))
1429 /* record the value and slave index for the slave which transmits the
1430 * maximum number of packets */
1431 if (slave_tx_total[i] > max_nb_of_tx_pkts) {
1432 max_nb_of_tx_pkts = slave_tx_total[i];
1433 most_successful_tx_slave = i;
1437 /* if slaves fail to transmit packets from burst, the calling application
1438 * is not expected to know about multiple references to packets so we must
1439 * handle failures of all packets except those of the most successful slave
1441 if (unlikely(tx_failed_flag))
1442 for (i = 0; i < num_of_slaves; i++)
1443 if (i != most_successful_tx_slave)
1444 while (slave_tx_total[i] < nb_pkts)
1445 rte_pktmbuf_free(bufs[slave_tx_total[i]++]);
1447 return max_nb_of_tx_pkts;
1451 link_properties_set(struct rte_eth_dev *ethdev, struct rte_eth_link *slave_link)
1453 struct bond_dev_private *bond_ctx = ethdev->data->dev_private;
1455 if (bond_ctx->mode == BONDING_MODE_8023AD) {
1457 * If in mode 4 then save the link properties of the first
1458 * slave, all subsequent slaves must match these properties
1460 struct rte_eth_link *bond_link = &bond_ctx->mode4.slave_link;
1462 bond_link->link_autoneg = slave_link->link_autoneg;
1463 bond_link->link_duplex = slave_link->link_duplex;
1464 bond_link->link_speed = slave_link->link_speed;
1467 * In any other mode the link properties are set to default
1468 * values of AUTONEG/DUPLEX
1470 ethdev->data->dev_link.link_autoneg = ETH_LINK_AUTONEG;
1471 ethdev->data->dev_link.link_duplex = ETH_LINK_FULL_DUPLEX;
1476 link_properties_valid(struct rte_eth_dev *ethdev,
1477 struct rte_eth_link *slave_link)
1479 struct bond_dev_private *bond_ctx = ethdev->data->dev_private;
1481 if (bond_ctx->mode == BONDING_MODE_8023AD) {
1482 struct rte_eth_link *bond_link = &bond_ctx->mode4.slave_link;
1484 if (bond_link->link_duplex != slave_link->link_duplex ||
1485 bond_link->link_autoneg != slave_link->link_autoneg ||
1486 bond_link->link_speed != slave_link->link_speed)
1494 mac_address_get(struct rte_eth_dev *eth_dev, struct ether_addr *dst_mac_addr)
1496 struct ether_addr *mac_addr;
1498 if (eth_dev == NULL) {
1499 RTE_BOND_LOG(ERR, "NULL pointer eth_dev specified");
1503 if (dst_mac_addr == NULL) {
1504 RTE_BOND_LOG(ERR, "NULL pointer MAC specified");
1508 mac_addr = eth_dev->data->mac_addrs;
1510 ether_addr_copy(mac_addr, dst_mac_addr);
1515 mac_address_set(struct rte_eth_dev *eth_dev, struct ether_addr *new_mac_addr)
1517 struct ether_addr *mac_addr;
1519 if (eth_dev == NULL) {
1520 RTE_BOND_LOG(ERR, "NULL pointer eth_dev specified");
1524 if (new_mac_addr == NULL) {
1525 RTE_BOND_LOG(ERR, "NULL pointer MAC specified");
1529 mac_addr = eth_dev->data->mac_addrs;
1531 /* If new MAC is different to current MAC then update */
1532 if (memcmp(mac_addr, new_mac_addr, sizeof(*mac_addr)) != 0)
1533 memcpy(mac_addr, new_mac_addr, sizeof(*mac_addr));
1538 static const struct ether_addr null_mac_addr;
1541 * Add additional MAC addresses to the slave
1544 slave_add_mac_addresses(struct rte_eth_dev *bonded_eth_dev,
1545 uint16_t slave_port_id)
1548 struct ether_addr *mac_addr;
1550 for (i = 1; i < BOND_MAX_MAC_ADDRS; i++) {
1551 mac_addr = &bonded_eth_dev->data->mac_addrs[i];
1552 if (is_same_ether_addr(mac_addr, &null_mac_addr))
1555 ret = rte_eth_dev_mac_addr_add(slave_port_id, mac_addr, 0);
1558 for (i--; i > 0; i--)
1559 rte_eth_dev_mac_addr_remove(slave_port_id,
1560 &bonded_eth_dev->data->mac_addrs[i]);
1569 * Remove additional MAC addresses from the slave
1572 slave_remove_mac_addresses(struct rte_eth_dev *bonded_eth_dev,
1573 uint16_t slave_port_id)
1576 struct ether_addr *mac_addr;
1579 for (i = 1; i < BOND_MAX_MAC_ADDRS; i++) {
1580 mac_addr = &bonded_eth_dev->data->mac_addrs[i];
1581 if (is_same_ether_addr(mac_addr, &null_mac_addr))
1584 ret = rte_eth_dev_mac_addr_remove(slave_port_id, mac_addr);
1585 /* save only the first error */
1586 if (ret < 0 && rc == 0)
1594 mac_address_slaves_update(struct rte_eth_dev *bonded_eth_dev)
1596 struct bond_dev_private *internals = bonded_eth_dev->data->dev_private;
1599 /* Update slave devices MAC addresses */
1600 if (internals->slave_count < 1)
1603 switch (internals->mode) {
1604 case BONDING_MODE_ROUND_ROBIN:
1605 case BONDING_MODE_BALANCE:
1606 case BONDING_MODE_BROADCAST:
1607 for (i = 0; i < internals->slave_count; i++) {
1608 if (rte_eth_dev_default_mac_addr_set(
1609 internals->slaves[i].port_id,
1610 bonded_eth_dev->data->mac_addrs)) {
1611 RTE_BOND_LOG(ERR, "Failed to update port Id %d MAC address",
1612 internals->slaves[i].port_id);
1617 case BONDING_MODE_8023AD:
1618 bond_mode_8023ad_mac_address_update(bonded_eth_dev);
1620 case BONDING_MODE_ACTIVE_BACKUP:
1621 case BONDING_MODE_TLB:
1622 case BONDING_MODE_ALB:
1624 for (i = 0; i < internals->slave_count; i++) {
1625 if (internals->slaves[i].port_id ==
1626 internals->current_primary_port) {
1627 if (rte_eth_dev_default_mac_addr_set(
1628 internals->primary_port,
1629 bonded_eth_dev->data->mac_addrs)) {
1630 RTE_BOND_LOG(ERR, "Failed to update port Id %d MAC address",
1631 internals->current_primary_port);
1635 if (rte_eth_dev_default_mac_addr_set(
1636 internals->slaves[i].port_id,
1637 &internals->slaves[i].persisted_mac_addr)) {
1638 RTE_BOND_LOG(ERR, "Failed to update port Id %d MAC address",
1639 internals->slaves[i].port_id);
1650 bond_ethdev_mode_set(struct rte_eth_dev *eth_dev, int mode)
1652 struct bond_dev_private *internals;
1654 internals = eth_dev->data->dev_private;
1657 case BONDING_MODE_ROUND_ROBIN:
1658 eth_dev->tx_pkt_burst = bond_ethdev_tx_burst_round_robin;
1659 eth_dev->rx_pkt_burst = bond_ethdev_rx_burst;
1661 case BONDING_MODE_ACTIVE_BACKUP:
1662 eth_dev->tx_pkt_burst = bond_ethdev_tx_burst_active_backup;
1663 eth_dev->rx_pkt_burst = bond_ethdev_rx_burst_active_backup;
1665 case BONDING_MODE_BALANCE:
1666 eth_dev->tx_pkt_burst = bond_ethdev_tx_burst_balance;
1667 eth_dev->rx_pkt_burst = bond_ethdev_rx_burst;
1669 case BONDING_MODE_BROADCAST:
1670 eth_dev->tx_pkt_burst = bond_ethdev_tx_burst_broadcast;
1671 eth_dev->rx_pkt_burst = bond_ethdev_rx_burst;
1673 case BONDING_MODE_8023AD:
1674 if (bond_mode_8023ad_enable(eth_dev) != 0)
1677 if (internals->mode4.dedicated_queues.enabled == 0) {
1678 eth_dev->rx_pkt_burst = bond_ethdev_rx_burst_8023ad;
1679 eth_dev->tx_pkt_burst = bond_ethdev_tx_burst_8023ad;
1680 RTE_BOND_LOG(WARNING,
1681 "Using mode 4, it is necessary to do TX burst "
1682 "and RX burst at least every 100ms.");
1684 /* Use flow director's optimization */
1685 eth_dev->rx_pkt_burst =
1686 bond_ethdev_rx_burst_8023ad_fast_queue;
1687 eth_dev->tx_pkt_burst =
1688 bond_ethdev_tx_burst_8023ad_fast_queue;
1691 case BONDING_MODE_TLB:
1692 eth_dev->tx_pkt_burst = bond_ethdev_tx_burst_tlb;
1693 eth_dev->rx_pkt_burst = bond_ethdev_rx_burst_active_backup;
1695 case BONDING_MODE_ALB:
1696 if (bond_mode_alb_enable(eth_dev) != 0)
1699 eth_dev->tx_pkt_burst = bond_ethdev_tx_burst_alb;
1700 eth_dev->rx_pkt_burst = bond_ethdev_rx_burst_alb;
1706 internals->mode = mode;
1713 slave_configure_slow_queue(struct rte_eth_dev *bonded_eth_dev,
1714 struct rte_eth_dev *slave_eth_dev)
1717 struct bond_dev_private *internals = (struct bond_dev_private *)
1718 bonded_eth_dev->data->dev_private;
1719 struct port *port = &mode_8023ad_ports[slave_eth_dev->data->port_id];
1721 if (port->slow_pool == NULL) {
1723 int slave_id = slave_eth_dev->data->port_id;
1725 snprintf(mem_name, RTE_DIM(mem_name), "slave_port%u_slow_pool",
1727 port->slow_pool = rte_pktmbuf_pool_create(mem_name, 8191,
1728 250, 0, RTE_MBUF_DEFAULT_BUF_SIZE,
1729 slave_eth_dev->data->numa_node);
1731 /* Any memory allocation failure in initialization is critical because
1732 * resources can't be free, so reinitialization is impossible. */
1733 if (port->slow_pool == NULL) {
1734 rte_panic("Slave %u: Failed to create memory pool '%s': %s\n",
1735 slave_id, mem_name, rte_strerror(rte_errno));
1739 if (internals->mode4.dedicated_queues.enabled == 1) {
1740 /* Configure slow Rx queue */
1742 errval = rte_eth_rx_queue_setup(slave_eth_dev->data->port_id,
1743 internals->mode4.dedicated_queues.rx_qid, 128,
1744 rte_eth_dev_socket_id(slave_eth_dev->data->port_id),
1745 NULL, port->slow_pool);
1748 "rte_eth_rx_queue_setup: port=%d queue_id %d, err (%d)",
1749 slave_eth_dev->data->port_id,
1750 internals->mode4.dedicated_queues.rx_qid,
1755 errval = rte_eth_tx_queue_setup(slave_eth_dev->data->port_id,
1756 internals->mode4.dedicated_queues.tx_qid, 512,
1757 rte_eth_dev_socket_id(slave_eth_dev->data->port_id),
1761 "rte_eth_tx_queue_setup: port=%d queue_id %d, err (%d)",
1762 slave_eth_dev->data->port_id,
1763 internals->mode4.dedicated_queues.tx_qid,
1772 slave_configure(struct rte_eth_dev *bonded_eth_dev,
1773 struct rte_eth_dev *slave_eth_dev)
1775 struct bond_rx_queue *bd_rx_q;
1776 struct bond_tx_queue *bd_tx_q;
1777 uint16_t nb_rx_queues;
1778 uint16_t nb_tx_queues;
1782 struct rte_flow_error flow_error;
1784 struct bond_dev_private *internals = (struct bond_dev_private *)
1785 bonded_eth_dev->data->dev_private;
1788 rte_eth_dev_stop(slave_eth_dev->data->port_id);
1790 /* Enable interrupts on slave device if supported */
1791 if (slave_eth_dev->data->dev_flags & RTE_ETH_DEV_INTR_LSC)
1792 slave_eth_dev->data->dev_conf.intr_conf.lsc = 1;
1794 /* If RSS is enabled for bonding, try to enable it for slaves */
1795 if (bonded_eth_dev->data->dev_conf.rxmode.mq_mode & ETH_MQ_RX_RSS_FLAG) {
1796 if (internals->rss_key_len != 0) {
1797 slave_eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key_len =
1798 internals->rss_key_len;
1799 slave_eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key =
1802 slave_eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key = NULL;
1805 slave_eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_hf =
1806 bonded_eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_hf;
1807 slave_eth_dev->data->dev_conf.rxmode.mq_mode =
1808 bonded_eth_dev->data->dev_conf.rxmode.mq_mode;
1811 if (bonded_eth_dev->data->dev_conf.rxmode.offloads &
1812 DEV_RX_OFFLOAD_VLAN_FILTER)
1813 slave_eth_dev->data->dev_conf.rxmode.offloads |=
1814 DEV_RX_OFFLOAD_VLAN_FILTER;
1816 slave_eth_dev->data->dev_conf.rxmode.offloads &=
1817 ~DEV_RX_OFFLOAD_VLAN_FILTER;
1819 nb_rx_queues = bonded_eth_dev->data->nb_rx_queues;
1820 nb_tx_queues = bonded_eth_dev->data->nb_tx_queues;
1822 if (internals->mode == BONDING_MODE_8023AD) {
1823 if (internals->mode4.dedicated_queues.enabled == 1) {
1829 errval = rte_eth_dev_set_mtu(slave_eth_dev->data->port_id,
1830 bonded_eth_dev->data->mtu);
1831 if (errval != 0 && errval != -ENOTSUP) {
1832 RTE_BOND_LOG(ERR, "rte_eth_dev_set_mtu: port %u, err (%d)",
1833 slave_eth_dev->data->port_id, errval);
1837 /* Configure device */
1838 errval = rte_eth_dev_configure(slave_eth_dev->data->port_id,
1839 nb_rx_queues, nb_tx_queues,
1840 &(slave_eth_dev->data->dev_conf));
1842 RTE_BOND_LOG(ERR, "Cannot configure slave device: port %u, err (%d)",
1843 slave_eth_dev->data->port_id, errval);
1847 /* Setup Rx Queues */
1848 for (q_id = 0; q_id < bonded_eth_dev->data->nb_rx_queues; q_id++) {
1849 bd_rx_q = (struct bond_rx_queue *)bonded_eth_dev->data->rx_queues[q_id];
1851 errval = rte_eth_rx_queue_setup(slave_eth_dev->data->port_id, q_id,
1852 bd_rx_q->nb_rx_desc,
1853 rte_eth_dev_socket_id(slave_eth_dev->data->port_id),
1854 &(bd_rx_q->rx_conf), bd_rx_q->mb_pool);
1857 "rte_eth_rx_queue_setup: port=%d queue_id %d, err (%d)",
1858 slave_eth_dev->data->port_id, q_id, errval);
1863 /* Setup Tx Queues */
1864 for (q_id = 0; q_id < bonded_eth_dev->data->nb_tx_queues; q_id++) {
1865 bd_tx_q = (struct bond_tx_queue *)bonded_eth_dev->data->tx_queues[q_id];
1867 errval = rte_eth_tx_queue_setup(slave_eth_dev->data->port_id, q_id,
1868 bd_tx_q->nb_tx_desc,
1869 rte_eth_dev_socket_id(slave_eth_dev->data->port_id),
1873 "rte_eth_tx_queue_setup: port=%d queue_id %d, err (%d)",
1874 slave_eth_dev->data->port_id, q_id, errval);
1879 if (internals->mode == BONDING_MODE_8023AD &&
1880 internals->mode4.dedicated_queues.enabled == 1) {
1881 if (slave_configure_slow_queue(bonded_eth_dev, slave_eth_dev)
1885 if (bond_ethdev_8023ad_flow_verify(bonded_eth_dev,
1886 slave_eth_dev->data->port_id) != 0) {
1888 "rte_eth_tx_queue_setup: port=%d queue_id %d, err (%d)",
1889 slave_eth_dev->data->port_id, q_id, errval);
1893 if (internals->mode4.dedicated_queues.flow[slave_eth_dev->data->port_id] != NULL)
1894 rte_flow_destroy(slave_eth_dev->data->port_id,
1895 internals->mode4.dedicated_queues.flow[slave_eth_dev->data->port_id],
1898 bond_ethdev_8023ad_flow_set(bonded_eth_dev,
1899 slave_eth_dev->data->port_id);
1903 errval = rte_eth_dev_start(slave_eth_dev->data->port_id);
1905 RTE_BOND_LOG(ERR, "rte_eth_dev_start: port=%u, err (%d)",
1906 slave_eth_dev->data->port_id, errval);
1910 /* If RSS is enabled for bonding, synchronize RETA */
1911 if (bonded_eth_dev->data->dev_conf.rxmode.mq_mode & ETH_MQ_RX_RSS) {
1913 struct bond_dev_private *internals;
1915 internals = bonded_eth_dev->data->dev_private;
1917 for (i = 0; i < internals->slave_count; i++) {
1918 if (internals->slaves[i].port_id == slave_eth_dev->data->port_id) {
1919 errval = rte_eth_dev_rss_reta_update(
1920 slave_eth_dev->data->port_id,
1921 &internals->reta_conf[0],
1922 internals->slaves[i].reta_size);
1924 RTE_BOND_LOG(WARNING,
1925 "rte_eth_dev_rss_reta_update on slave port %d fails (err %d)."
1926 " RSS Configuration for bonding may be inconsistent.",
1927 slave_eth_dev->data->port_id, errval);
1934 /* If lsc interrupt is set, check initial slave's link status */
1935 if (slave_eth_dev->data->dev_flags & RTE_ETH_DEV_INTR_LSC) {
1936 slave_eth_dev->dev_ops->link_update(slave_eth_dev, 0);
1937 bond_ethdev_lsc_event_callback(slave_eth_dev->data->port_id,
1938 RTE_ETH_EVENT_INTR_LSC, &bonded_eth_dev->data->port_id,
1946 slave_remove(struct bond_dev_private *internals,
1947 struct rte_eth_dev *slave_eth_dev)
1951 for (i = 0; i < internals->slave_count; i++)
1952 if (internals->slaves[i].port_id ==
1953 slave_eth_dev->data->port_id)
1956 if (i < (internals->slave_count - 1)) {
1957 struct rte_flow *flow;
1959 memmove(&internals->slaves[i], &internals->slaves[i + 1],
1960 sizeof(internals->slaves[0]) *
1961 (internals->slave_count - i - 1));
1962 TAILQ_FOREACH(flow, &internals->flow_list, next) {
1963 memmove(&flow->flows[i], &flow->flows[i + 1],
1964 sizeof(flow->flows[0]) *
1965 (internals->slave_count - i - 1));
1966 flow->flows[internals->slave_count - 1] = NULL;
1970 internals->slave_count--;
1972 /* force reconfiguration of slave interfaces */
1973 _rte_eth_dev_reset(slave_eth_dev);
1977 bond_ethdev_slave_link_status_change_monitor(void *cb_arg);
1980 slave_add(struct bond_dev_private *internals,
1981 struct rte_eth_dev *slave_eth_dev)
1983 struct bond_slave_details *slave_details =
1984 &internals->slaves[internals->slave_count];
1986 slave_details->port_id = slave_eth_dev->data->port_id;
1987 slave_details->last_link_status = 0;
1989 /* Mark slave devices that don't support interrupts so we can
1990 * compensate when we start the bond
1992 if (!(slave_eth_dev->data->dev_flags & RTE_ETH_DEV_INTR_LSC)) {
1993 slave_details->link_status_poll_enabled = 1;
1996 slave_details->link_status_wait_to_complete = 0;
1997 /* clean tlb_last_obytes when adding port for bonding device */
1998 memcpy(&(slave_details->persisted_mac_addr), slave_eth_dev->data->mac_addrs,
1999 sizeof(struct ether_addr));
2003 bond_ethdev_primary_set(struct bond_dev_private *internals,
2004 uint16_t slave_port_id)
2008 if (internals->active_slave_count < 1)
2009 internals->current_primary_port = slave_port_id;
2011 /* Search bonded device slave ports for new proposed primary port */
2012 for (i = 0; i < internals->active_slave_count; i++) {
2013 if (internals->active_slaves[i] == slave_port_id)
2014 internals->current_primary_port = slave_port_id;
2019 bond_ethdev_promiscuous_enable(struct rte_eth_dev *eth_dev);
2022 bond_ethdev_start(struct rte_eth_dev *eth_dev)
2024 struct bond_dev_private *internals;
2027 /* slave eth dev will be started by bonded device */
2028 if (check_for_bonded_ethdev(eth_dev)) {
2029 RTE_BOND_LOG(ERR, "User tried to explicitly start a slave eth_dev (%d)",
2030 eth_dev->data->port_id);
2034 eth_dev->data->dev_link.link_status = ETH_LINK_DOWN;
2035 eth_dev->data->dev_started = 1;
2037 internals = eth_dev->data->dev_private;
2039 if (internals->slave_count == 0) {
2040 RTE_BOND_LOG(ERR, "Cannot start port since there are no slave devices");
2044 if (internals->user_defined_mac == 0) {
2045 struct ether_addr *new_mac_addr = NULL;
2047 for (i = 0; i < internals->slave_count; i++)
2048 if (internals->slaves[i].port_id == internals->primary_port)
2049 new_mac_addr = &internals->slaves[i].persisted_mac_addr;
2051 if (new_mac_addr == NULL)
2054 if (mac_address_set(eth_dev, new_mac_addr) != 0) {
2055 RTE_BOND_LOG(ERR, "bonded port (%d) failed to update MAC address",
2056 eth_dev->data->port_id);
2061 /* If bonded device is configure in promiscuous mode then re-apply config */
2062 if (internals->promiscuous_en)
2063 bond_ethdev_promiscuous_enable(eth_dev);
2065 if (internals->mode == BONDING_MODE_8023AD) {
2066 if (internals->mode4.dedicated_queues.enabled == 1) {
2067 internals->mode4.dedicated_queues.rx_qid =
2068 eth_dev->data->nb_rx_queues;
2069 internals->mode4.dedicated_queues.tx_qid =
2070 eth_dev->data->nb_tx_queues;
2075 /* Reconfigure each slave device if starting bonded device */
2076 for (i = 0; i < internals->slave_count; i++) {
2077 struct rte_eth_dev *slave_ethdev =
2078 &(rte_eth_devices[internals->slaves[i].port_id]);
2079 if (slave_configure(eth_dev, slave_ethdev) != 0) {
2081 "bonded port (%d) failed to reconfigure slave device (%d)",
2082 eth_dev->data->port_id,
2083 internals->slaves[i].port_id);
2086 /* We will need to poll for link status if any slave doesn't
2087 * support interrupts
2089 if (internals->slaves[i].link_status_poll_enabled)
2090 internals->link_status_polling_enabled = 1;
2093 /* start polling if needed */
2094 if (internals->link_status_polling_enabled) {
2096 internals->link_status_polling_interval_ms * 1000,
2097 bond_ethdev_slave_link_status_change_monitor,
2098 (void *)&rte_eth_devices[internals->port_id]);
2101 /* Update all slave devices MACs*/
2102 if (mac_address_slaves_update(eth_dev) != 0)
2105 if (internals->user_defined_primary_port)
2106 bond_ethdev_primary_set(internals, internals->primary_port);
2108 if (internals->mode == BONDING_MODE_8023AD)
2109 bond_mode_8023ad_start(eth_dev);
2111 if (internals->mode == BONDING_MODE_TLB ||
2112 internals->mode == BONDING_MODE_ALB)
2113 bond_tlb_enable(internals);
2118 eth_dev->data->dev_started = 0;
2123 bond_ethdev_free_queues(struct rte_eth_dev *dev)
2127 if (dev->data->rx_queues != NULL) {
2128 for (i = 0; i < dev->data->nb_rx_queues; i++) {
2129 rte_free(dev->data->rx_queues[i]);
2130 dev->data->rx_queues[i] = NULL;
2132 dev->data->nb_rx_queues = 0;
2135 if (dev->data->tx_queues != NULL) {
2136 for (i = 0; i < dev->data->nb_tx_queues; i++) {
2137 rte_free(dev->data->tx_queues[i]);
2138 dev->data->tx_queues[i] = NULL;
2140 dev->data->nb_tx_queues = 0;
2145 bond_ethdev_stop(struct rte_eth_dev *eth_dev)
2147 struct bond_dev_private *internals = eth_dev->data->dev_private;
2150 if (internals->mode == BONDING_MODE_8023AD) {
2154 bond_mode_8023ad_stop(eth_dev);
2156 /* Discard all messages to/from mode 4 state machines */
2157 for (i = 0; i < internals->active_slave_count; i++) {
2158 port = &mode_8023ad_ports[internals->active_slaves[i]];
2160 RTE_ASSERT(port->rx_ring != NULL);
2161 while (rte_ring_dequeue(port->rx_ring, &pkt) != -ENOENT)
2162 rte_pktmbuf_free(pkt);
2164 RTE_ASSERT(port->tx_ring != NULL);
2165 while (rte_ring_dequeue(port->tx_ring, &pkt) != -ENOENT)
2166 rte_pktmbuf_free(pkt);
2170 if (internals->mode == BONDING_MODE_TLB ||
2171 internals->mode == BONDING_MODE_ALB) {
2172 bond_tlb_disable(internals);
2173 for (i = 0; i < internals->active_slave_count; i++)
2174 tlb_last_obytets[internals->active_slaves[i]] = 0;
2177 internals->link_status_polling_enabled = 0;
2178 for (i = 0; i < internals->slave_count; i++)
2179 internals->slaves[i].last_link_status = 0;
2181 eth_dev->data->dev_link.link_status = ETH_LINK_DOWN;
2182 eth_dev->data->dev_started = 0;
2186 bond_ethdev_close(struct rte_eth_dev *dev)
2188 struct bond_dev_private *internals = dev->data->dev_private;
2189 uint8_t bond_port_id = internals->port_id;
2191 struct rte_flow_error ferror;
2193 RTE_BOND_LOG(INFO, "Closing bonded device %s", dev->device->name);
2194 while (internals->slave_count != skipped) {
2195 uint16_t port_id = internals->slaves[skipped].port_id;
2197 rte_eth_dev_stop(port_id);
2199 if (rte_eth_bond_slave_remove(bond_port_id, port_id) != 0) {
2201 "Failed to remove port %d from bonded device %s",
2202 port_id, dev->device->name);
2206 bond_flow_ops.flush(dev, &ferror);
2207 bond_ethdev_free_queues(dev);
2208 rte_bitmap_reset(internals->vlan_filter_bmp);
2211 /* forward declaration */
2212 static int bond_ethdev_configure(struct rte_eth_dev *dev);
2215 bond_ethdev_info(struct rte_eth_dev *dev, struct rte_eth_dev_info *dev_info)
2217 struct bond_dev_private *internals = dev->data->dev_private;
2219 uint16_t max_nb_rx_queues = UINT16_MAX;
2220 uint16_t max_nb_tx_queues = UINT16_MAX;
2222 dev_info->max_mac_addrs = BOND_MAX_MAC_ADDRS;
2224 dev_info->max_rx_pktlen = internals->candidate_max_rx_pktlen ?
2225 internals->candidate_max_rx_pktlen :
2226 ETHER_MAX_JUMBO_FRAME_LEN;
2228 /* Max number of tx/rx queues that the bonded device can support is the
2229 * minimum values of the bonded slaves, as all slaves must be capable
2230 * of supporting the same number of tx/rx queues.
2232 if (internals->slave_count > 0) {
2233 struct rte_eth_dev_info slave_info;
2236 for (idx = 0; idx < internals->slave_count; idx++) {
2237 rte_eth_dev_info_get(internals->slaves[idx].port_id,
2240 if (slave_info.max_rx_queues < max_nb_rx_queues)
2241 max_nb_rx_queues = slave_info.max_rx_queues;
2243 if (slave_info.max_tx_queues < max_nb_tx_queues)
2244 max_nb_tx_queues = slave_info.max_tx_queues;
2248 dev_info->max_rx_queues = max_nb_rx_queues;
2249 dev_info->max_tx_queues = max_nb_tx_queues;
2251 memcpy(&dev_info->default_rxconf, &internals->default_rxconf,
2252 sizeof(dev_info->default_rxconf));
2253 memcpy(&dev_info->default_txconf, &internals->default_txconf,
2254 sizeof(dev_info->default_txconf));
2257 * If dedicated hw queues enabled for link bonding device in LACP mode
2258 * then we need to reduce the maximum number of data path queues by 1.
2260 if (internals->mode == BONDING_MODE_8023AD &&
2261 internals->mode4.dedicated_queues.enabled == 1) {
2262 dev_info->max_rx_queues--;
2263 dev_info->max_tx_queues--;
2266 dev_info->min_rx_bufsize = 0;
2268 dev_info->rx_offload_capa = internals->rx_offload_capa;
2269 dev_info->tx_offload_capa = internals->tx_offload_capa;
2270 dev_info->rx_queue_offload_capa = internals->rx_queue_offload_capa;
2271 dev_info->tx_queue_offload_capa = internals->tx_queue_offload_capa;
2272 dev_info->flow_type_rss_offloads = internals->flow_type_rss_offloads;
2274 dev_info->reta_size = internals->reta_size;
2278 bond_ethdev_vlan_filter_set(struct rte_eth_dev *dev, uint16_t vlan_id, int on)
2282 struct bond_dev_private *internals = dev->data->dev_private;
2284 /* don't do this while a slave is being added */
2285 rte_spinlock_lock(&internals->lock);
2288 rte_bitmap_set(internals->vlan_filter_bmp, vlan_id);
2290 rte_bitmap_clear(internals->vlan_filter_bmp, vlan_id);
2292 for (i = 0; i < internals->slave_count; i++) {
2293 uint16_t port_id = internals->slaves[i].port_id;
2295 res = rte_eth_dev_vlan_filter(port_id, vlan_id, on);
2297 RTE_BOND_LOG(WARNING,
2298 "Setting VLAN filter on slave port %u not supported.",
2302 rte_spinlock_unlock(&internals->lock);
2307 bond_ethdev_rx_queue_setup(struct rte_eth_dev *dev, uint16_t rx_queue_id,
2308 uint16_t nb_rx_desc, unsigned int socket_id __rte_unused,
2309 const struct rte_eth_rxconf *rx_conf, struct rte_mempool *mb_pool)
2311 struct bond_rx_queue *bd_rx_q = (struct bond_rx_queue *)
2312 rte_zmalloc_socket(NULL, sizeof(struct bond_rx_queue),
2313 0, dev->data->numa_node);
2314 if (bd_rx_q == NULL)
2317 bd_rx_q->queue_id = rx_queue_id;
2318 bd_rx_q->dev_private = dev->data->dev_private;
2320 bd_rx_q->nb_rx_desc = nb_rx_desc;
2322 memcpy(&(bd_rx_q->rx_conf), rx_conf, sizeof(struct rte_eth_rxconf));
2323 bd_rx_q->mb_pool = mb_pool;
2325 dev->data->rx_queues[rx_queue_id] = bd_rx_q;
2331 bond_ethdev_tx_queue_setup(struct rte_eth_dev *dev, uint16_t tx_queue_id,
2332 uint16_t nb_tx_desc, unsigned int socket_id __rte_unused,
2333 const struct rte_eth_txconf *tx_conf)
2335 struct bond_tx_queue *bd_tx_q = (struct bond_tx_queue *)
2336 rte_zmalloc_socket(NULL, sizeof(struct bond_tx_queue),
2337 0, dev->data->numa_node);
2339 if (bd_tx_q == NULL)
2342 bd_tx_q->queue_id = tx_queue_id;
2343 bd_tx_q->dev_private = dev->data->dev_private;
2345 bd_tx_q->nb_tx_desc = nb_tx_desc;
2346 memcpy(&(bd_tx_q->tx_conf), tx_conf, sizeof(bd_tx_q->tx_conf));
2348 dev->data->tx_queues[tx_queue_id] = bd_tx_q;
2354 bond_ethdev_rx_queue_release(void *queue)
2363 bond_ethdev_tx_queue_release(void *queue)
2372 bond_ethdev_slave_link_status_change_monitor(void *cb_arg)
2374 struct rte_eth_dev *bonded_ethdev, *slave_ethdev;
2375 struct bond_dev_private *internals;
2377 /* Default value for polling slave found is true as we don't want to
2378 * disable the polling thread if we cannot get the lock */
2379 int i, polling_slave_found = 1;
2384 bonded_ethdev = (struct rte_eth_dev *)cb_arg;
2385 internals = (struct bond_dev_private *)bonded_ethdev->data->dev_private;
2387 if (!bonded_ethdev->data->dev_started ||
2388 !internals->link_status_polling_enabled)
2391 /* If device is currently being configured then don't check slaves link
2392 * status, wait until next period */
2393 if (rte_spinlock_trylock(&internals->lock)) {
2394 if (internals->slave_count > 0)
2395 polling_slave_found = 0;
2397 for (i = 0; i < internals->slave_count; i++) {
2398 if (!internals->slaves[i].link_status_poll_enabled)
2401 slave_ethdev = &rte_eth_devices[internals->slaves[i].port_id];
2402 polling_slave_found = 1;
2404 /* Update slave link status */
2405 (*slave_ethdev->dev_ops->link_update)(slave_ethdev,
2406 internals->slaves[i].link_status_wait_to_complete);
2408 /* if link status has changed since last checked then call lsc
2410 if (slave_ethdev->data->dev_link.link_status !=
2411 internals->slaves[i].last_link_status) {
2412 internals->slaves[i].last_link_status =
2413 slave_ethdev->data->dev_link.link_status;
2415 bond_ethdev_lsc_event_callback(internals->slaves[i].port_id,
2416 RTE_ETH_EVENT_INTR_LSC,
2417 &bonded_ethdev->data->port_id,
2421 rte_spinlock_unlock(&internals->lock);
2424 if (polling_slave_found)
2425 /* Set alarm to continue monitoring link status of slave ethdev's */
2426 rte_eal_alarm_set(internals->link_status_polling_interval_ms * 1000,
2427 bond_ethdev_slave_link_status_change_monitor, cb_arg);
2431 bond_ethdev_link_update(struct rte_eth_dev *ethdev, int wait_to_complete)
2433 void (*link_update)(uint16_t port_id, struct rte_eth_link *eth_link);
2435 struct bond_dev_private *bond_ctx;
2436 struct rte_eth_link slave_link;
2440 bond_ctx = ethdev->data->dev_private;
2442 ethdev->data->dev_link.link_speed = ETH_SPEED_NUM_NONE;
2444 if (ethdev->data->dev_started == 0 ||
2445 bond_ctx->active_slave_count == 0) {
2446 ethdev->data->dev_link.link_status = ETH_LINK_DOWN;
2450 ethdev->data->dev_link.link_status = ETH_LINK_UP;
2452 if (wait_to_complete)
2453 link_update = rte_eth_link_get;
2455 link_update = rte_eth_link_get_nowait;
2457 switch (bond_ctx->mode) {
2458 case BONDING_MODE_BROADCAST:
2460 * Setting link speed to UINT32_MAX to ensure we pick up the
2461 * value of the first active slave
2463 ethdev->data->dev_link.link_speed = UINT32_MAX;
2466 * link speed is minimum value of all the slaves link speed as
2467 * packet loss will occur on this slave if transmission at rates
2468 * greater than this are attempted
2470 for (idx = 1; idx < bond_ctx->active_slave_count; idx++) {
2471 link_update(bond_ctx->active_slaves[0], &slave_link);
2473 if (slave_link.link_speed <
2474 ethdev->data->dev_link.link_speed)
2475 ethdev->data->dev_link.link_speed =
2476 slave_link.link_speed;
2479 case BONDING_MODE_ACTIVE_BACKUP:
2480 /* Current primary slave */
2481 link_update(bond_ctx->current_primary_port, &slave_link);
2483 ethdev->data->dev_link.link_speed = slave_link.link_speed;
2485 case BONDING_MODE_8023AD:
2486 ethdev->data->dev_link.link_autoneg =
2487 bond_ctx->mode4.slave_link.link_autoneg;
2488 ethdev->data->dev_link.link_duplex =
2489 bond_ctx->mode4.slave_link.link_duplex;
2490 /* fall through to update link speed */
2491 case BONDING_MODE_ROUND_ROBIN:
2492 case BONDING_MODE_BALANCE:
2493 case BONDING_MODE_TLB:
2494 case BONDING_MODE_ALB:
2497 * In theses mode the maximum theoretical link speed is the sum
2500 ethdev->data->dev_link.link_speed = ETH_SPEED_NUM_NONE;
2502 for (idx = 0; idx < bond_ctx->active_slave_count; idx++) {
2503 link_update(bond_ctx->active_slaves[idx], &slave_link);
2505 ethdev->data->dev_link.link_speed +=
2506 slave_link.link_speed;
2516 bond_ethdev_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats)
2518 struct bond_dev_private *internals = dev->data->dev_private;
2519 struct rte_eth_stats slave_stats;
2522 for (i = 0; i < internals->slave_count; i++) {
2523 rte_eth_stats_get(internals->slaves[i].port_id, &slave_stats);
2525 stats->ipackets += slave_stats.ipackets;
2526 stats->opackets += slave_stats.opackets;
2527 stats->ibytes += slave_stats.ibytes;
2528 stats->obytes += slave_stats.obytes;
2529 stats->imissed += slave_stats.imissed;
2530 stats->ierrors += slave_stats.ierrors;
2531 stats->oerrors += slave_stats.oerrors;
2532 stats->rx_nombuf += slave_stats.rx_nombuf;
2534 for (j = 0; j < RTE_ETHDEV_QUEUE_STAT_CNTRS; j++) {
2535 stats->q_ipackets[j] += slave_stats.q_ipackets[j];
2536 stats->q_opackets[j] += slave_stats.q_opackets[j];
2537 stats->q_ibytes[j] += slave_stats.q_ibytes[j];
2538 stats->q_obytes[j] += slave_stats.q_obytes[j];
2539 stats->q_errors[j] += slave_stats.q_errors[j];
2548 bond_ethdev_stats_reset(struct rte_eth_dev *dev)
2550 struct bond_dev_private *internals = dev->data->dev_private;
2553 for (i = 0; i < internals->slave_count; i++)
2554 rte_eth_stats_reset(internals->slaves[i].port_id);
2558 bond_ethdev_promiscuous_enable(struct rte_eth_dev *eth_dev)
2560 struct bond_dev_private *internals = eth_dev->data->dev_private;
2563 internals->promiscuous_en = 1;
2565 switch (internals->mode) {
2566 /* Promiscuous mode is propagated to all slaves */
2567 case BONDING_MODE_ROUND_ROBIN:
2568 case BONDING_MODE_BALANCE:
2569 case BONDING_MODE_BROADCAST:
2570 for (i = 0; i < internals->slave_count; i++)
2571 rte_eth_promiscuous_enable(internals->slaves[i].port_id);
2573 /* In mode4 promiscus mode is managed when slave is added/removed */
2574 case BONDING_MODE_8023AD:
2576 /* Promiscuous mode is propagated only to primary slave */
2577 case BONDING_MODE_ACTIVE_BACKUP:
2578 case BONDING_MODE_TLB:
2579 case BONDING_MODE_ALB:
2581 rte_eth_promiscuous_enable(internals->current_primary_port);
2586 bond_ethdev_promiscuous_disable(struct rte_eth_dev *dev)
2588 struct bond_dev_private *internals = dev->data->dev_private;
2591 internals->promiscuous_en = 0;
2593 switch (internals->mode) {
2594 /* Promiscuous mode is propagated to all slaves */
2595 case BONDING_MODE_ROUND_ROBIN:
2596 case BONDING_MODE_BALANCE:
2597 case BONDING_MODE_BROADCAST:
2598 for (i = 0; i < internals->slave_count; i++)
2599 rte_eth_promiscuous_disable(internals->slaves[i].port_id);
2601 /* In mode4 promiscus mode is set managed when slave is added/removed */
2602 case BONDING_MODE_8023AD:
2604 /* Promiscuous mode is propagated only to primary slave */
2605 case BONDING_MODE_ACTIVE_BACKUP:
2606 case BONDING_MODE_TLB:
2607 case BONDING_MODE_ALB:
2609 rte_eth_promiscuous_disable(internals->current_primary_port);
2614 bond_ethdev_delayed_lsc_propagation(void *arg)
2619 _rte_eth_dev_callback_process((struct rte_eth_dev *)arg,
2620 RTE_ETH_EVENT_INTR_LSC, NULL);
2624 bond_ethdev_lsc_event_callback(uint16_t port_id, enum rte_eth_event_type type,
2625 void *param, void *ret_param __rte_unused)
2627 struct rte_eth_dev *bonded_eth_dev;
2628 struct bond_dev_private *internals;
2629 struct rte_eth_link link;
2632 int i, valid_slave = 0;
2634 uint8_t lsc_flag = 0;
2636 if (type != RTE_ETH_EVENT_INTR_LSC || param == NULL)
2639 bonded_eth_dev = &rte_eth_devices[*(uint8_t *)param];
2641 if (check_for_bonded_ethdev(bonded_eth_dev))
2644 internals = bonded_eth_dev->data->dev_private;
2646 /* If the device isn't started don't handle interrupts */
2647 if (!bonded_eth_dev->data->dev_started)
2650 /* verify that port_id is a valid slave of bonded port */
2651 for (i = 0; i < internals->slave_count; i++) {
2652 if (internals->slaves[i].port_id == port_id) {
2661 /* Synchronize lsc callback parallel calls either by real link event
2662 * from the slaves PMDs or by the bonding PMD itself.
2664 rte_spinlock_lock(&internals->lsc_lock);
2666 /* Search for port in active port list */
2667 active_pos = find_slave_by_id(internals->active_slaves,
2668 internals->active_slave_count, port_id);
2670 rte_eth_link_get_nowait(port_id, &link);
2671 if (link.link_status) {
2672 if (active_pos < internals->active_slave_count)
2675 /* if no active slave ports then set this port to be primary port */
2676 if (internals->active_slave_count < 1) {
2677 /* If first active slave, then change link status */
2678 bonded_eth_dev->data->dev_link.link_status = ETH_LINK_UP;
2679 internals->current_primary_port = port_id;
2682 mac_address_slaves_update(bonded_eth_dev);
2685 /* check link state properties if bonded link is up*/
2686 if (bonded_eth_dev->data->dev_link.link_status == ETH_LINK_UP) {
2687 if (link_properties_valid(bonded_eth_dev, &link) != 0)
2688 RTE_BOND_LOG(ERR, "Invalid link properties "
2689 "for slave %d in bonding mode %d",
2690 port_id, internals->mode);
2692 /* inherit slave link properties */
2693 link_properties_set(bonded_eth_dev, &link);
2696 activate_slave(bonded_eth_dev, port_id);
2698 /* If user has defined the primary port then default to using it */
2699 if (internals->user_defined_primary_port &&
2700 internals->primary_port == port_id)
2701 bond_ethdev_primary_set(internals, port_id);
2703 if (active_pos == internals->active_slave_count)
2706 /* Remove from active slave list */
2707 deactivate_slave(bonded_eth_dev, port_id);
2709 if (internals->active_slave_count < 1)
2712 /* Update primary id, take first active slave from list or if none
2713 * available set to -1 */
2714 if (port_id == internals->current_primary_port) {
2715 if (internals->active_slave_count > 0)
2716 bond_ethdev_primary_set(internals,
2717 internals->active_slaves[0]);
2719 internals->current_primary_port = internals->primary_port;
2725 * Update bonded device link properties after any change to active
2728 bond_ethdev_link_update(bonded_eth_dev, 0);
2731 /* Cancel any possible outstanding interrupts if delays are enabled */
2732 if (internals->link_up_delay_ms > 0 ||
2733 internals->link_down_delay_ms > 0)
2734 rte_eal_alarm_cancel(bond_ethdev_delayed_lsc_propagation,
2737 if (bonded_eth_dev->data->dev_link.link_status) {
2738 if (internals->link_up_delay_ms > 0)
2739 rte_eal_alarm_set(internals->link_up_delay_ms * 1000,
2740 bond_ethdev_delayed_lsc_propagation,
2741 (void *)bonded_eth_dev);
2743 _rte_eth_dev_callback_process(bonded_eth_dev,
2744 RTE_ETH_EVENT_INTR_LSC,
2748 if (internals->link_down_delay_ms > 0)
2749 rte_eal_alarm_set(internals->link_down_delay_ms * 1000,
2750 bond_ethdev_delayed_lsc_propagation,
2751 (void *)bonded_eth_dev);
2753 _rte_eth_dev_callback_process(bonded_eth_dev,
2754 RTE_ETH_EVENT_INTR_LSC,
2759 rte_spinlock_unlock(&internals->lsc_lock);
2765 bond_ethdev_rss_reta_update(struct rte_eth_dev *dev,
2766 struct rte_eth_rss_reta_entry64 *reta_conf, uint16_t reta_size)
2770 int slave_reta_size;
2771 unsigned reta_count;
2772 struct bond_dev_private *internals = dev->data->dev_private;
2774 if (reta_size != internals->reta_size)
2777 /* Copy RETA table */
2778 reta_count = reta_size / RTE_RETA_GROUP_SIZE;
2780 for (i = 0; i < reta_count; i++) {
2781 internals->reta_conf[i].mask = reta_conf[i].mask;
2782 for (j = 0; j < RTE_RETA_GROUP_SIZE; j++)
2783 if ((reta_conf[i].mask >> j) & 0x01)
2784 internals->reta_conf[i].reta[j] = reta_conf[i].reta[j];
2787 /* Fill rest of array */
2788 for (; i < RTE_DIM(internals->reta_conf); i += reta_count)
2789 memcpy(&internals->reta_conf[i], &internals->reta_conf[0],
2790 sizeof(internals->reta_conf[0]) * reta_count);
2792 /* Propagate RETA over slaves */
2793 for (i = 0; i < internals->slave_count; i++) {
2794 slave_reta_size = internals->slaves[i].reta_size;
2795 result = rte_eth_dev_rss_reta_update(internals->slaves[i].port_id,
2796 &internals->reta_conf[0], slave_reta_size);
2805 bond_ethdev_rss_reta_query(struct rte_eth_dev *dev,
2806 struct rte_eth_rss_reta_entry64 *reta_conf, uint16_t reta_size)
2809 struct bond_dev_private *internals = dev->data->dev_private;
2811 if (reta_size != internals->reta_size)
2814 /* Copy RETA table */
2815 for (i = 0; i < reta_size / RTE_RETA_GROUP_SIZE; i++)
2816 for (j = 0; j < RTE_RETA_GROUP_SIZE; j++)
2817 if ((reta_conf[i].mask >> j) & 0x01)
2818 reta_conf[i].reta[j] = internals->reta_conf[i].reta[j];
2824 bond_ethdev_rss_hash_update(struct rte_eth_dev *dev,
2825 struct rte_eth_rss_conf *rss_conf)
2828 struct bond_dev_private *internals = dev->data->dev_private;
2829 struct rte_eth_rss_conf bond_rss_conf;
2831 memcpy(&bond_rss_conf, rss_conf, sizeof(struct rte_eth_rss_conf));
2833 bond_rss_conf.rss_hf &= internals->flow_type_rss_offloads;
2835 if (bond_rss_conf.rss_hf != 0)
2836 dev->data->dev_conf.rx_adv_conf.rss_conf.rss_hf = bond_rss_conf.rss_hf;
2838 if (bond_rss_conf.rss_key && bond_rss_conf.rss_key_len <
2839 sizeof(internals->rss_key)) {
2840 if (bond_rss_conf.rss_key_len == 0)
2841 bond_rss_conf.rss_key_len = 40;
2842 internals->rss_key_len = bond_rss_conf.rss_key_len;
2843 memcpy(internals->rss_key, bond_rss_conf.rss_key,
2844 internals->rss_key_len);
2847 for (i = 0; i < internals->slave_count; i++) {
2848 result = rte_eth_dev_rss_hash_update(internals->slaves[i].port_id,
2858 bond_ethdev_rss_hash_conf_get(struct rte_eth_dev *dev,
2859 struct rte_eth_rss_conf *rss_conf)
2861 struct bond_dev_private *internals = dev->data->dev_private;
2863 rss_conf->rss_hf = dev->data->dev_conf.rx_adv_conf.rss_conf.rss_hf;
2864 rss_conf->rss_key_len = internals->rss_key_len;
2865 if (rss_conf->rss_key)
2866 memcpy(rss_conf->rss_key, internals->rss_key, internals->rss_key_len);
2872 bond_ethdev_mtu_set(struct rte_eth_dev *dev, uint16_t mtu)
2874 struct rte_eth_dev *slave_eth_dev;
2875 struct bond_dev_private *internals = dev->data->dev_private;
2878 rte_spinlock_lock(&internals->lock);
2880 for (i = 0; i < internals->slave_count; i++) {
2881 slave_eth_dev = &rte_eth_devices[internals->slaves[i].port_id];
2882 if (*slave_eth_dev->dev_ops->mtu_set == NULL) {
2883 rte_spinlock_unlock(&internals->lock);
2887 for (i = 0; i < internals->slave_count; i++) {
2888 ret = rte_eth_dev_set_mtu(internals->slaves[i].port_id, mtu);
2890 rte_spinlock_unlock(&internals->lock);
2895 rte_spinlock_unlock(&internals->lock);
2900 bond_ethdev_mac_address_set(struct rte_eth_dev *dev, struct ether_addr *addr)
2902 if (mac_address_set(dev, addr)) {
2903 RTE_BOND_LOG(ERR, "Failed to update MAC address");
2911 bond_filter_ctrl(struct rte_eth_dev *dev __rte_unused,
2912 enum rte_filter_type type, enum rte_filter_op op, void *arg)
2914 if (type == RTE_ETH_FILTER_GENERIC && op == RTE_ETH_FILTER_GET) {
2915 *(const void **)arg = &bond_flow_ops;
2922 bond_ethdev_mac_addr_add(struct rte_eth_dev *dev, struct ether_addr *mac_addr,
2923 __rte_unused uint32_t index, uint32_t vmdq)
2925 struct rte_eth_dev *slave_eth_dev;
2926 struct bond_dev_private *internals = dev->data->dev_private;
2929 rte_spinlock_lock(&internals->lock);
2931 for (i = 0; i < internals->slave_count; i++) {
2932 slave_eth_dev = &rte_eth_devices[internals->slaves[i].port_id];
2933 if (*slave_eth_dev->dev_ops->mac_addr_add == NULL ||
2934 *slave_eth_dev->dev_ops->mac_addr_remove == NULL) {
2940 for (i = 0; i < internals->slave_count; i++) {
2941 ret = rte_eth_dev_mac_addr_add(internals->slaves[i].port_id,
2945 for (i--; i >= 0; i--)
2946 rte_eth_dev_mac_addr_remove(
2947 internals->slaves[i].port_id, mac_addr);
2954 rte_spinlock_unlock(&internals->lock);
2959 bond_ethdev_mac_addr_remove(struct rte_eth_dev *dev, uint32_t index)
2961 struct rte_eth_dev *slave_eth_dev;
2962 struct bond_dev_private *internals = dev->data->dev_private;
2965 rte_spinlock_lock(&internals->lock);
2967 for (i = 0; i < internals->slave_count; i++) {
2968 slave_eth_dev = &rte_eth_devices[internals->slaves[i].port_id];
2969 if (*slave_eth_dev->dev_ops->mac_addr_remove == NULL)
2973 struct ether_addr *mac_addr = &dev->data->mac_addrs[index];
2975 for (i = 0; i < internals->slave_count; i++)
2976 rte_eth_dev_mac_addr_remove(internals->slaves[i].port_id,
2980 rte_spinlock_unlock(&internals->lock);
2983 const struct eth_dev_ops default_dev_ops = {
2984 .dev_start = bond_ethdev_start,
2985 .dev_stop = bond_ethdev_stop,
2986 .dev_close = bond_ethdev_close,
2987 .dev_configure = bond_ethdev_configure,
2988 .dev_infos_get = bond_ethdev_info,
2989 .vlan_filter_set = bond_ethdev_vlan_filter_set,
2990 .rx_queue_setup = bond_ethdev_rx_queue_setup,
2991 .tx_queue_setup = bond_ethdev_tx_queue_setup,
2992 .rx_queue_release = bond_ethdev_rx_queue_release,
2993 .tx_queue_release = bond_ethdev_tx_queue_release,
2994 .link_update = bond_ethdev_link_update,
2995 .stats_get = bond_ethdev_stats_get,
2996 .stats_reset = bond_ethdev_stats_reset,
2997 .promiscuous_enable = bond_ethdev_promiscuous_enable,
2998 .promiscuous_disable = bond_ethdev_promiscuous_disable,
2999 .reta_update = bond_ethdev_rss_reta_update,
3000 .reta_query = bond_ethdev_rss_reta_query,
3001 .rss_hash_update = bond_ethdev_rss_hash_update,
3002 .rss_hash_conf_get = bond_ethdev_rss_hash_conf_get,
3003 .mtu_set = bond_ethdev_mtu_set,
3004 .mac_addr_set = bond_ethdev_mac_address_set,
3005 .mac_addr_add = bond_ethdev_mac_addr_add,
3006 .mac_addr_remove = bond_ethdev_mac_addr_remove,
3007 .filter_ctrl = bond_filter_ctrl
3011 bond_alloc(struct rte_vdev_device *dev, uint8_t mode)
3013 const char *name = rte_vdev_device_name(dev);
3014 uint8_t socket_id = dev->device.numa_node;
3015 struct bond_dev_private *internals = NULL;
3016 struct rte_eth_dev *eth_dev = NULL;
3017 uint32_t vlan_filter_bmp_size;
3019 /* now do all data allocation - for eth_dev structure, dummy pci driver
3020 * and internal (private) data
3023 /* reserve an ethdev entry */
3024 eth_dev = rte_eth_vdev_allocate(dev, sizeof(*internals));
3025 if (eth_dev == NULL) {
3026 RTE_BOND_LOG(ERR, "Unable to allocate rte_eth_dev");
3030 internals = eth_dev->data->dev_private;
3031 eth_dev->data->nb_rx_queues = (uint16_t)1;
3032 eth_dev->data->nb_tx_queues = (uint16_t)1;
3034 /* Allocate memory for storing MAC addresses */
3035 eth_dev->data->mac_addrs = rte_zmalloc_socket(name, ETHER_ADDR_LEN *
3036 BOND_MAX_MAC_ADDRS, 0, socket_id);
3037 if (eth_dev->data->mac_addrs == NULL) {
3039 "Failed to allocate %u bytes needed to store MAC addresses",
3040 ETHER_ADDR_LEN * BOND_MAX_MAC_ADDRS);
3044 eth_dev->dev_ops = &default_dev_ops;
3045 eth_dev->data->dev_flags = RTE_ETH_DEV_INTR_LSC;
3047 rte_spinlock_init(&internals->lock);
3048 rte_spinlock_init(&internals->lsc_lock);
3050 internals->port_id = eth_dev->data->port_id;
3051 internals->mode = BONDING_MODE_INVALID;
3052 internals->current_primary_port = RTE_MAX_ETHPORTS + 1;
3053 internals->balance_xmit_policy = BALANCE_XMIT_POLICY_LAYER2;
3054 internals->burst_xmit_hash = burst_xmit_l2_hash;
3055 internals->user_defined_mac = 0;
3057 internals->link_status_polling_enabled = 0;
3059 internals->link_status_polling_interval_ms =
3060 DEFAULT_POLLING_INTERVAL_10_MS;
3061 internals->link_down_delay_ms = 0;
3062 internals->link_up_delay_ms = 0;
3064 internals->slave_count = 0;
3065 internals->active_slave_count = 0;
3066 internals->rx_offload_capa = 0;
3067 internals->tx_offload_capa = 0;
3068 internals->rx_queue_offload_capa = 0;
3069 internals->tx_queue_offload_capa = 0;
3070 internals->candidate_max_rx_pktlen = 0;
3071 internals->max_rx_pktlen = 0;
3073 /* Initially allow to choose any offload type */
3074 internals->flow_type_rss_offloads = ETH_RSS_PROTO_MASK;
3076 memset(&internals->default_rxconf, 0,
3077 sizeof(internals->default_rxconf));
3078 memset(&internals->default_txconf, 0,
3079 sizeof(internals->default_txconf));
3081 memset(internals->active_slaves, 0, sizeof(internals->active_slaves));
3082 memset(internals->slaves, 0, sizeof(internals->slaves));
3084 TAILQ_INIT(&internals->flow_list);
3085 internals->flow_isolated_valid = 0;
3087 /* Set mode 4 default configuration */
3088 bond_mode_8023ad_setup(eth_dev, NULL);
3089 if (bond_ethdev_mode_set(eth_dev, mode)) {
3090 RTE_BOND_LOG(ERR, "Failed to set bonded device %d mode to %d",
3091 eth_dev->data->port_id, mode);
3095 vlan_filter_bmp_size =
3096 rte_bitmap_get_memory_footprint(ETHER_MAX_VLAN_ID + 1);
3097 internals->vlan_filter_bmpmem = rte_malloc(name, vlan_filter_bmp_size,
3098 RTE_CACHE_LINE_SIZE);
3099 if (internals->vlan_filter_bmpmem == NULL) {
3101 "Failed to allocate vlan bitmap for bonded device %u",
3102 eth_dev->data->port_id);
3106 internals->vlan_filter_bmp = rte_bitmap_init(ETHER_MAX_VLAN_ID + 1,
3107 internals->vlan_filter_bmpmem, vlan_filter_bmp_size);
3108 if (internals->vlan_filter_bmp == NULL) {
3110 "Failed to init vlan bitmap for bonded device %u",
3111 eth_dev->data->port_id);
3112 rte_free(internals->vlan_filter_bmpmem);
3116 return eth_dev->data->port_id;
3119 rte_free(internals);
3120 if (eth_dev != NULL) {
3121 rte_free(eth_dev->data->mac_addrs);
3122 rte_eth_dev_release_port(eth_dev);
3128 bond_probe(struct rte_vdev_device *dev)
3131 struct bond_dev_private *internals;
3132 struct rte_kvargs *kvlist;
3133 uint8_t bonding_mode, socket_id/*, agg_mode*/;
3134 int arg_count, port_id;
3136 struct rte_eth_dev *eth_dev;
3141 name = rte_vdev_device_name(dev);
3142 RTE_BOND_LOG(INFO, "Initializing pmd_bond for %s", name);
3144 if (rte_eal_process_type() == RTE_PROC_SECONDARY &&
3145 strlen(rte_vdev_device_args(dev)) == 0) {
3146 eth_dev = rte_eth_dev_attach_secondary(name);
3148 RTE_BOND_LOG(ERR, "Failed to probe %s", name);
3151 /* TODO: request info from primary to set up Rx and Tx */
3152 eth_dev->dev_ops = &default_dev_ops;
3153 eth_dev->device = &dev->device;
3154 rte_eth_dev_probing_finish(eth_dev);
3158 kvlist = rte_kvargs_parse(rte_vdev_device_args(dev),
3159 pmd_bond_init_valid_arguments);
3163 /* Parse link bonding mode */
3164 if (rte_kvargs_count(kvlist, PMD_BOND_MODE_KVARG) == 1) {
3165 if (rte_kvargs_process(kvlist, PMD_BOND_MODE_KVARG,
3166 &bond_ethdev_parse_slave_mode_kvarg,
3167 &bonding_mode) != 0) {
3168 RTE_BOND_LOG(ERR, "Invalid mode for bonded device %s",
3173 RTE_BOND_LOG(ERR, "Mode must be specified only once for bonded "
3178 /* Parse socket id to create bonding device on */
3179 arg_count = rte_kvargs_count(kvlist, PMD_BOND_SOCKET_ID_KVARG);
3180 if (arg_count == 1) {
3181 if (rte_kvargs_process(kvlist, PMD_BOND_SOCKET_ID_KVARG,
3182 &bond_ethdev_parse_socket_id_kvarg, &socket_id)
3184 RTE_BOND_LOG(ERR, "Invalid socket Id specified for "
3185 "bonded device %s", name);
3188 } else if (arg_count > 1) {
3189 RTE_BOND_LOG(ERR, "Socket Id can be specified only once for "
3190 "bonded device %s", name);
3193 socket_id = rte_socket_id();
3196 dev->device.numa_node = socket_id;
3198 /* Create link bonding eth device */
3199 port_id = bond_alloc(dev, bonding_mode);
3201 RTE_BOND_LOG(ERR, "Failed to create socket %s in mode %u on "
3202 "socket %u.", name, bonding_mode, socket_id);
3205 internals = rte_eth_devices[port_id].data->dev_private;
3206 internals->kvlist = kvlist;
3208 rte_eth_dev_probing_finish(&rte_eth_devices[port_id]);
3210 if (rte_kvargs_count(kvlist, PMD_BOND_AGG_MODE_KVARG) == 1) {
3211 if (rte_kvargs_process(kvlist,
3212 PMD_BOND_AGG_MODE_KVARG,
3213 &bond_ethdev_parse_slave_agg_mode_kvarg,
3216 "Failed to parse agg selection mode for bonded device %s",
3221 if (internals->mode == BONDING_MODE_8023AD)
3222 rte_eth_bond_8023ad_agg_selection_set(port_id,
3225 rte_eth_bond_8023ad_agg_selection_set(port_id, AGG_STABLE);
3228 RTE_BOND_LOG(INFO, "Create bonded device %s on port %d in mode %u on "
3229 "socket %u.", name, port_id, bonding_mode, socket_id);
3233 rte_kvargs_free(kvlist);
3239 bond_remove(struct rte_vdev_device *dev)
3241 struct rte_eth_dev *eth_dev;
3242 struct bond_dev_private *internals;
3248 name = rte_vdev_device_name(dev);
3249 RTE_BOND_LOG(INFO, "Uninitializing pmd_bond for %s", name);
3251 /* now free all data allocation - for eth_dev structure,
3252 * dummy pci driver and internal (private) data
3255 /* find an ethdev entry */
3256 eth_dev = rte_eth_dev_allocated(name);
3257 if (eth_dev == NULL)
3260 RTE_ASSERT(eth_dev->device == &dev->device);
3262 internals = eth_dev->data->dev_private;
3263 if (internals->slave_count != 0)
3266 if (eth_dev->data->dev_started == 1) {
3267 bond_ethdev_stop(eth_dev);
3268 bond_ethdev_close(eth_dev);
3271 eth_dev->dev_ops = NULL;
3272 eth_dev->rx_pkt_burst = NULL;
3273 eth_dev->tx_pkt_burst = NULL;
3275 internals = eth_dev->data->dev_private;
3276 /* Try to release mempool used in mode6. If the bond
3277 * device is not mode6, free the NULL is not problem.
3279 rte_mempool_free(internals->mode6.mempool);
3280 rte_bitmap_free(internals->vlan_filter_bmp);
3281 rte_free(internals->vlan_filter_bmpmem);
3282 rte_free(eth_dev->data->dev_private);
3283 rte_free(eth_dev->data->mac_addrs);
3285 rte_eth_dev_release_port(eth_dev);
3290 /* this part will resolve the slave portids after all the other pdev and vdev
3291 * have been allocated */
3293 bond_ethdev_configure(struct rte_eth_dev *dev)
3295 const char *name = dev->device->name;
3296 struct bond_dev_private *internals = dev->data->dev_private;
3297 struct rte_kvargs *kvlist = internals->kvlist;
3299 uint16_t port_id = dev - rte_eth_devices;
3302 static const uint8_t default_rss_key[40] = {
3303 0x6D, 0x5A, 0x56, 0xDA, 0x25, 0x5B, 0x0E, 0xC2, 0x41, 0x67, 0x25, 0x3D,
3304 0x43, 0xA3, 0x8F, 0xB0, 0xD0, 0xCA, 0x2B, 0xCB, 0xAE, 0x7B, 0x30, 0xB4,
3305 0x77, 0xCB, 0x2D, 0xA3, 0x80, 0x30, 0xF2, 0x0C, 0x6A, 0x42, 0xB7, 0x3B,
3306 0xBE, 0xAC, 0x01, 0xFA
3312 * If RSS is enabled, fill table with default values and
3313 * set key to the the value specified in port RSS configuration.
3314 * Fall back to default RSS key if the key is not specified
3316 if (dev->data->dev_conf.rxmode.mq_mode & ETH_MQ_RX_RSS) {
3317 if (dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key != NULL) {
3318 internals->rss_key_len =
3319 dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key_len;
3320 memcpy(internals->rss_key,
3321 dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key,
3322 internals->rss_key_len);
3324 internals->rss_key_len = sizeof(default_rss_key);
3325 memcpy(internals->rss_key, default_rss_key,
3326 internals->rss_key_len);
3329 for (i = 0; i < RTE_DIM(internals->reta_conf); i++) {
3330 internals->reta_conf[i].mask = ~0LL;
3331 for (j = 0; j < RTE_RETA_GROUP_SIZE; j++)
3332 internals->reta_conf[i].reta[j] =
3333 (i * RTE_RETA_GROUP_SIZE + j) %
3334 dev->data->nb_rx_queues;
3338 /* set the max_rx_pktlen */
3339 internals->max_rx_pktlen = internals->candidate_max_rx_pktlen;
3342 * if no kvlist, it means that this bonded device has been created
3343 * through the bonding api.
3348 /* Parse MAC address for bonded device */
3349 arg_count = rte_kvargs_count(kvlist, PMD_BOND_MAC_ADDR_KVARG);
3350 if (arg_count == 1) {
3351 struct ether_addr bond_mac;
3353 if (rte_kvargs_process(kvlist, PMD_BOND_MAC_ADDR_KVARG,
3354 &bond_ethdev_parse_bond_mac_addr_kvarg, &bond_mac) < 0) {
3355 RTE_BOND_LOG(INFO, "Invalid mac address for bonded device %s",
3360 /* Set MAC address */
3361 if (rte_eth_bond_mac_address_set(port_id, &bond_mac) != 0) {
3363 "Failed to set mac address on bonded device %s",
3367 } else if (arg_count > 1) {
3369 "MAC address can be specified only once for bonded device %s",
3374 /* Parse/set balance mode transmit policy */
3375 arg_count = rte_kvargs_count(kvlist, PMD_BOND_XMIT_POLICY_KVARG);
3376 if (arg_count == 1) {
3377 uint8_t xmit_policy;
3379 if (rte_kvargs_process(kvlist, PMD_BOND_XMIT_POLICY_KVARG,
3380 &bond_ethdev_parse_balance_xmit_policy_kvarg, &xmit_policy) !=
3383 "Invalid xmit policy specified for bonded device %s",
3388 /* Set balance mode transmit policy*/
3389 if (rte_eth_bond_xmit_policy_set(port_id, xmit_policy) != 0) {
3391 "Failed to set balance xmit policy on bonded device %s",
3395 } else if (arg_count > 1) {
3397 "Transmit policy can be specified only once for bonded device %s",
3402 if (rte_kvargs_count(kvlist, PMD_BOND_AGG_MODE_KVARG) == 1) {
3403 if (rte_kvargs_process(kvlist,
3404 PMD_BOND_AGG_MODE_KVARG,
3405 &bond_ethdev_parse_slave_agg_mode_kvarg,
3408 "Failed to parse agg selection mode for bonded device %s",
3411 if (internals->mode == BONDING_MODE_8023AD)
3412 rte_eth_bond_8023ad_agg_selection_set(port_id,
3416 /* Parse/add slave ports to bonded device */
3417 if (rte_kvargs_count(kvlist, PMD_BOND_SLAVE_PORT_KVARG) > 0) {
3418 struct bond_ethdev_slave_ports slave_ports;
3421 memset(&slave_ports, 0, sizeof(slave_ports));
3423 if (rte_kvargs_process(kvlist, PMD_BOND_SLAVE_PORT_KVARG,
3424 &bond_ethdev_parse_slave_port_kvarg, &slave_ports) != 0) {
3426 "Failed to parse slave ports for bonded device %s",
3431 for (i = 0; i < slave_ports.slave_count; i++) {
3432 if (rte_eth_bond_slave_add(port_id, slave_ports.slaves[i]) != 0) {
3434 "Failed to add port %d as slave to bonded device %s",
3435 slave_ports.slaves[i], name);
3440 RTE_BOND_LOG(INFO, "No slaves specified for bonded device %s", name);
3444 /* Parse/set primary slave port id*/
3445 arg_count = rte_kvargs_count(kvlist, PMD_BOND_PRIMARY_SLAVE_KVARG);
3446 if (arg_count == 1) {
3447 uint16_t primary_slave_port_id;
3449 if (rte_kvargs_process(kvlist,
3450 PMD_BOND_PRIMARY_SLAVE_KVARG,
3451 &bond_ethdev_parse_primary_slave_port_id_kvarg,
3452 &primary_slave_port_id) < 0) {
3454 "Invalid primary slave port id specified for bonded device %s",
3459 /* Set balance mode transmit policy*/
3460 if (rte_eth_bond_primary_set(port_id, primary_slave_port_id)
3463 "Failed to set primary slave port %d on bonded device %s",
3464 primary_slave_port_id, name);
3467 } else if (arg_count > 1) {
3469 "Primary slave can be specified only once for bonded device %s",
3474 /* Parse link status monitor polling interval */
3475 arg_count = rte_kvargs_count(kvlist, PMD_BOND_LSC_POLL_PERIOD_KVARG);
3476 if (arg_count == 1) {
3477 uint32_t lsc_poll_interval_ms;
3479 if (rte_kvargs_process(kvlist,
3480 PMD_BOND_LSC_POLL_PERIOD_KVARG,
3481 &bond_ethdev_parse_time_ms_kvarg,
3482 &lsc_poll_interval_ms) < 0) {
3484 "Invalid lsc polling interval value specified for bonded"
3485 " device %s", name);
3489 if (rte_eth_bond_link_monitoring_set(port_id, lsc_poll_interval_ms)
3492 "Failed to set lsc monitor polling interval (%u ms) on bonded device %s",
3493 lsc_poll_interval_ms, name);
3496 } else if (arg_count > 1) {
3498 "LSC polling interval can be specified only once for bonded"
3499 " device %s", name);
3503 /* Parse link up interrupt propagation delay */
3504 arg_count = rte_kvargs_count(kvlist, PMD_BOND_LINK_UP_PROP_DELAY_KVARG);
3505 if (arg_count == 1) {
3506 uint32_t link_up_delay_ms;
3508 if (rte_kvargs_process(kvlist,
3509 PMD_BOND_LINK_UP_PROP_DELAY_KVARG,
3510 &bond_ethdev_parse_time_ms_kvarg,
3511 &link_up_delay_ms) < 0) {
3513 "Invalid link up propagation delay value specified for"
3514 " bonded device %s", name);
3518 /* Set balance mode transmit policy*/
3519 if (rte_eth_bond_link_up_prop_delay_set(port_id, link_up_delay_ms)
3522 "Failed to set link up propagation delay (%u ms) on bonded"
3523 " device %s", link_up_delay_ms, name);
3526 } else if (arg_count > 1) {
3528 "Link up propagation delay can be specified only once for"
3529 " bonded device %s", name);
3533 /* Parse link down interrupt propagation delay */
3534 arg_count = rte_kvargs_count(kvlist, PMD_BOND_LINK_DOWN_PROP_DELAY_KVARG);
3535 if (arg_count == 1) {
3536 uint32_t link_down_delay_ms;
3538 if (rte_kvargs_process(kvlist,
3539 PMD_BOND_LINK_DOWN_PROP_DELAY_KVARG,
3540 &bond_ethdev_parse_time_ms_kvarg,
3541 &link_down_delay_ms) < 0) {
3543 "Invalid link down propagation delay value specified for"
3544 " bonded device %s", name);
3548 /* Set balance mode transmit policy*/
3549 if (rte_eth_bond_link_down_prop_delay_set(port_id, link_down_delay_ms)
3552 "Failed to set link down propagation delay (%u ms) on bonded device %s",
3553 link_down_delay_ms, name);
3556 } else if (arg_count > 1) {
3558 "Link down propagation delay can be specified only once for bonded device %s",
3566 struct rte_vdev_driver pmd_bond_drv = {
3567 .probe = bond_probe,
3568 .remove = bond_remove,
3571 RTE_PMD_REGISTER_VDEV(net_bonding, pmd_bond_drv);
3572 RTE_PMD_REGISTER_ALIAS(net_bonding, eth_bond);
3574 RTE_PMD_REGISTER_PARAM_STRING(net_bonding,
3578 "xmit_policy=[l2 | l23 | l34] "
3579 "agg_mode=[count | stable | bandwidth] "
3582 "lsc_poll_period_ms=<int> "
3584 "down_delay=<int>");
3588 RTE_INIT(bond_init_log)
3590 bond_logtype = rte_log_register("pmd.net.bon");
3591 if (bond_logtype >= 0)
3592 rte_log_set_level(bond_logtype, RTE_LOG_NOTICE);