07659c6f80bbb2be59c97304b2a1f7eea8896879
[dpdk.git] / drivers / net / bonding / rte_eth_bond_api.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2010-2017 Intel Corporation
3  */
4
5 #include <string.h>
6
7 #include <rte_mbuf.h>
8 #include <rte_malloc.h>
9 #include <rte_ethdev.h>
10 #include <rte_tcp.h>
11 #include <rte_bus_vdev.h>
12 #include <rte_kvargs.h>
13
14 #include "rte_eth_bond.h"
15 #include "rte_eth_bond_private.h"
16 #include "rte_eth_bond_8023ad_private.h"
17
18 int
19 check_for_bonded_ethdev(const struct rte_eth_dev *eth_dev)
20 {
21         /* Check valid pointer */
22         if (eth_dev->device->driver->name == NULL)
23                 return -1;
24
25         /* return 0 if driver name matches */
26         return eth_dev->device->driver->name != pmd_bond_drv.driver.name;
27 }
28
29 int
30 valid_bonded_port_id(uint16_t port_id)
31 {
32         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -1);
33         return check_for_bonded_ethdev(&rte_eth_devices[port_id]);
34 }
35
36 int
37 check_for_master_bonded_ethdev(const struct rte_eth_dev *eth_dev)
38 {
39         int i;
40         struct bond_dev_private *internals;
41
42         if (check_for_bonded_ethdev(eth_dev) != 0)
43                 return 0;
44
45         internals = eth_dev->data->dev_private;
46
47         /* Check if any of slave devices is a bonded device */
48         for (i = 0; i < internals->slave_count; i++)
49                 if (valid_bonded_port_id(internals->slaves[i].port_id) == 0)
50                         return 1;
51
52         return 0;
53 }
54
55 int
56 valid_slave_port_id(uint16_t port_id, uint8_t mode)
57 {
58         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -1);
59
60         /* Verify that port_id refers to a non bonded port */
61         if (check_for_bonded_ethdev(&rte_eth_devices[port_id]) == 0 &&
62                         mode == BONDING_MODE_8023AD) {
63                 RTE_BOND_LOG(ERR, "Cannot add slave to bonded device in 802.3ad"
64                                 " mode as slave is also a bonded device, only "
65                                 "physical devices can be support in this mode.");
66                 return -1;
67         }
68
69         return 0;
70 }
71
72 void
73 activate_slave(struct rte_eth_dev *eth_dev, uint16_t port_id)
74 {
75         struct bond_dev_private *internals = eth_dev->data->dev_private;
76         uint8_t active_count = internals->active_slave_count;
77
78         if (internals->mode == BONDING_MODE_8023AD)
79                 bond_mode_8023ad_activate_slave(eth_dev, port_id);
80
81         if (internals->mode == BONDING_MODE_TLB
82                         || internals->mode == BONDING_MODE_ALB) {
83
84                 internals->tlb_slaves_order[active_count] = port_id;
85         }
86
87         RTE_ASSERT(internals->active_slave_count <
88                         (RTE_DIM(internals->active_slaves) - 1));
89
90         internals->active_slaves[internals->active_slave_count] = port_id;
91         internals->active_slave_count++;
92
93         if (internals->mode == BONDING_MODE_TLB)
94                 bond_tlb_activate_slave(internals);
95         if (internals->mode == BONDING_MODE_ALB)
96                 bond_mode_alb_client_list_upd(eth_dev);
97 }
98
99 void
100 deactivate_slave(struct rte_eth_dev *eth_dev, uint16_t port_id)
101 {
102         uint16_t slave_pos;
103         struct bond_dev_private *internals = eth_dev->data->dev_private;
104         uint16_t active_count = internals->active_slave_count;
105
106         if (internals->mode == BONDING_MODE_8023AD) {
107                 bond_mode_8023ad_stop(eth_dev);
108                 bond_mode_8023ad_deactivate_slave(eth_dev, port_id);
109         } else if (internals->mode == BONDING_MODE_TLB
110                         || internals->mode == BONDING_MODE_ALB)
111                 bond_tlb_disable(internals);
112
113         slave_pos = find_slave_by_id(internals->active_slaves, active_count,
114                         port_id);
115
116         /* If slave was not at the end of the list
117          * shift active slaves up active array list */
118         if (slave_pos < active_count) {
119                 active_count--;
120                 memmove(internals->active_slaves + slave_pos,
121                                 internals->active_slaves + slave_pos + 1,
122                                 (active_count - slave_pos) *
123                                         sizeof(internals->active_slaves[0]));
124         }
125
126         RTE_ASSERT(active_count < RTE_DIM(internals->active_slaves));
127         internals->active_slave_count = active_count;
128
129         if (eth_dev->data->dev_started) {
130                 if (internals->mode == BONDING_MODE_8023AD) {
131                         bond_mode_8023ad_start(eth_dev);
132                 } else if (internals->mode == BONDING_MODE_TLB) {
133                         bond_tlb_enable(internals);
134                 } else if (internals->mode == BONDING_MODE_ALB) {
135                         bond_tlb_enable(internals);
136                         bond_mode_alb_client_list_upd(eth_dev);
137                 }
138         }
139 }
140
141 int
142 rte_eth_bond_create(const char *name, uint8_t mode, uint8_t socket_id)
143 {
144         struct bond_dev_private *internals;
145         char devargs[52];
146         uint16_t port_id;
147         int ret;
148
149         if (name == NULL) {
150                 RTE_BOND_LOG(ERR, "Invalid name specified");
151                 return -EINVAL;
152         }
153
154         ret = snprintf(devargs, sizeof(devargs),
155                 "driver=net_bonding,mode=%d,socket_id=%d", mode, socket_id);
156         if (ret < 0 || ret >= (int)sizeof(devargs))
157                 return -ENOMEM;
158
159         ret = rte_vdev_init(name, devargs);
160         if (ret)
161                 return -ENOMEM;
162
163         ret = rte_eth_dev_get_port_by_name(name, &port_id);
164         RTE_ASSERT(!ret);
165
166         /*
167          * To make bond_ethdev_configure() happy we need to free the
168          * internals->kvlist here.
169          *
170          * Also see comment in bond_ethdev_configure().
171          */
172         internals = rte_eth_devices[port_id].data->dev_private;
173         rte_kvargs_free(internals->kvlist);
174         internals->kvlist = NULL;
175
176         return port_id;
177 }
178
179 int
180 rte_eth_bond_free(const char *name)
181 {
182         return rte_vdev_uninit(name);
183 }
184
185 static int
186 slave_vlan_filter_set(uint16_t bonded_port_id, uint16_t slave_port_id)
187 {
188         struct rte_eth_dev *bonded_eth_dev;
189         struct bond_dev_private *internals;
190         int found;
191         int res = 0;
192         uint64_t slab = 0;
193         uint32_t pos = 0;
194         uint16_t first;
195
196         bonded_eth_dev = &rte_eth_devices[bonded_port_id];
197         if (bonded_eth_dev->data->dev_conf.rxmode.hw_vlan_filter == 0)
198                 return 0;
199
200         internals = bonded_eth_dev->data->dev_private;
201         found = rte_bitmap_scan(internals->vlan_filter_bmp, &pos, &slab);
202         first = pos;
203
204         if (!found)
205                 return 0;
206
207         do {
208                 uint32_t i;
209                 uint64_t mask;
210
211                 for (i = 0, mask = 1;
212                      i < RTE_BITMAP_SLAB_BIT_SIZE;
213                      i ++, mask <<= 1) {
214                         if (unlikely(slab & mask))
215                                 res = rte_eth_dev_vlan_filter(slave_port_id,
216                                                               (uint16_t)pos, 1);
217                 }
218                 found = rte_bitmap_scan(internals->vlan_filter_bmp,
219                                         &pos, &slab);
220         } while (found && first != pos && res == 0);
221
222         return res;
223 }
224
225 static int
226 __eth_bond_slave_add_lock_free(uint16_t bonded_port_id, uint16_t slave_port_id)
227 {
228         struct rte_eth_dev *bonded_eth_dev, *slave_eth_dev;
229         struct bond_dev_private *internals;
230         struct rte_eth_link link_props;
231         struct rte_eth_dev_info dev_info;
232
233         bonded_eth_dev = &rte_eth_devices[bonded_port_id];
234         internals = bonded_eth_dev->data->dev_private;
235
236         if (valid_slave_port_id(slave_port_id, internals->mode) != 0)
237                 return -1;
238
239         slave_eth_dev = &rte_eth_devices[slave_port_id];
240         if (slave_eth_dev->data->dev_flags & RTE_ETH_DEV_BONDED_SLAVE) {
241                 RTE_BOND_LOG(ERR, "Slave device is already a slave of a bonded device");
242                 return -1;
243         }
244
245         /* Add slave details to bonded device */
246         slave_eth_dev->data->dev_flags |= RTE_ETH_DEV_BONDED_SLAVE;
247
248         rte_eth_dev_info_get(slave_port_id, &dev_info);
249         if (dev_info.max_rx_pktlen < internals->max_rx_pktlen) {
250                 RTE_BOND_LOG(ERR, "Slave (port %u) max_rx_pktlen too small",
251                              slave_port_id);
252                 return -1;
253         }
254
255         slave_add(internals, slave_eth_dev);
256
257         /* We need to store slaves reta_size to be able to synchronize RETA for all
258          * slave devices even if its sizes are different.
259          */
260         internals->slaves[internals->slave_count].reta_size = dev_info.reta_size;
261
262         if (internals->slave_count < 1) {
263                 /* if MAC is not user defined then use MAC of first slave add to
264                  * bonded device */
265                 if (!internals->user_defined_mac)
266                         mac_address_set(bonded_eth_dev, slave_eth_dev->data->mac_addrs);
267
268                 /* Inherit eth dev link properties from first slave */
269                 link_properties_set(bonded_eth_dev,
270                                 &(slave_eth_dev->data->dev_link));
271
272                 /* Make primary slave */
273                 internals->primary_port = slave_port_id;
274                 internals->current_primary_port = slave_port_id;
275
276                 /* Inherit queues settings from first slave */
277                 internals->nb_rx_queues = slave_eth_dev->data->nb_rx_queues;
278                 internals->nb_tx_queues = slave_eth_dev->data->nb_tx_queues;
279
280                 internals->reta_size = dev_info.reta_size;
281
282                 /* Take the first dev's offload capabilities */
283                 internals->rx_offload_capa = dev_info.rx_offload_capa;
284                 internals->tx_offload_capa = dev_info.tx_offload_capa;
285                 internals->flow_type_rss_offloads = dev_info.flow_type_rss_offloads;
286
287                 /* Inherit first slave's max rx packet size */
288                 internals->candidate_max_rx_pktlen = dev_info.max_rx_pktlen;
289
290         } else {
291                 internals->rx_offload_capa &= dev_info.rx_offload_capa;
292                 internals->tx_offload_capa &= dev_info.tx_offload_capa;
293                 internals->flow_type_rss_offloads &= dev_info.flow_type_rss_offloads;
294
295                 if (link_properties_valid(bonded_eth_dev,
296                                 &slave_eth_dev->data->dev_link) != 0) {
297                         RTE_BOND_LOG(ERR, "Invalid link properties for slave %d"
298                                         " in bonding mode %d", slave_port_id,
299                                         internals->mode);
300                         return -1;
301                 }
302
303                 /* RETA size is GCD of all slaves RETA sizes, so, if all sizes will be
304                  * the power of 2, the lower one is GCD
305                  */
306                 if (internals->reta_size > dev_info.reta_size)
307                         internals->reta_size = dev_info.reta_size;
308
309                 if (!internals->max_rx_pktlen &&
310                     dev_info.max_rx_pktlen < internals->candidate_max_rx_pktlen)
311                         internals->candidate_max_rx_pktlen = dev_info.max_rx_pktlen;
312         }
313
314         bonded_eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_hf &=
315                         internals->flow_type_rss_offloads;
316
317         internals->slave_count++;
318
319         /* Update all slave devices MACs*/
320         mac_address_slaves_update(bonded_eth_dev);
321
322         if (bonded_eth_dev->data->dev_started) {
323                 if (slave_configure(bonded_eth_dev, slave_eth_dev) != 0) {
324                         slave_eth_dev->data->dev_flags &= (~RTE_ETH_DEV_BONDED_SLAVE);
325                         RTE_BOND_LOG(ERR, "rte_bond_slaves_configure: port=%d",
326                                         slave_port_id);
327                         return -1;
328                 }
329         }
330
331         /* Register link status change callback with bonded device pointer as
332          * argument*/
333         rte_eth_dev_callback_register(slave_port_id, RTE_ETH_EVENT_INTR_LSC,
334                         bond_ethdev_lsc_event_callback, &bonded_eth_dev->data->port_id);
335
336         /* If bonded device is started then we can add the slave to our active
337          * slave array */
338         if (bonded_eth_dev->data->dev_started) {
339                 rte_eth_link_get_nowait(slave_port_id, &link_props);
340
341                  if (link_props.link_status == ETH_LINK_UP) {
342                         if (internals->active_slave_count == 0 &&
343                             !internals->user_defined_primary_port)
344                                 bond_ethdev_primary_set(internals,
345                                                         slave_port_id);
346
347                         if (find_slave_by_id(internals->active_slaves,
348                                              internals->active_slave_count,
349                                              slave_port_id) == internals->active_slave_count)
350                                 activate_slave(bonded_eth_dev, slave_port_id);
351                 }
352         }
353
354         slave_vlan_filter_set(bonded_port_id, slave_port_id);
355
356         return 0;
357
358 }
359
360 int
361 rte_eth_bond_slave_add(uint16_t bonded_port_id, uint16_t slave_port_id)
362 {
363         struct rte_eth_dev *bonded_eth_dev;
364         struct bond_dev_private *internals;
365
366         int retval;
367
368         /* Verify that port id's are valid bonded and slave ports */
369         if (valid_bonded_port_id(bonded_port_id) != 0)
370                 return -1;
371
372         bonded_eth_dev = &rte_eth_devices[bonded_port_id];
373         internals = bonded_eth_dev->data->dev_private;
374
375         rte_spinlock_lock(&internals->lock);
376
377         retval = __eth_bond_slave_add_lock_free(bonded_port_id, slave_port_id);
378
379         rte_spinlock_unlock(&internals->lock);
380
381         return retval;
382 }
383
384 static int
385 __eth_bond_slave_remove_lock_free(uint16_t bonded_port_id,
386                                    uint16_t slave_port_id)
387 {
388         struct rte_eth_dev *bonded_eth_dev;
389         struct bond_dev_private *internals;
390         struct rte_eth_dev *slave_eth_dev;
391         int i, slave_idx;
392
393         bonded_eth_dev = &rte_eth_devices[bonded_port_id];
394         internals = bonded_eth_dev->data->dev_private;
395
396         if (valid_slave_port_id(slave_port_id, internals->mode) < 0)
397                 return -1;
398
399         /* first remove from active slave list */
400         slave_idx = find_slave_by_id(internals->active_slaves,
401                 internals->active_slave_count, slave_port_id);
402
403         if (slave_idx < internals->active_slave_count)
404                 deactivate_slave(bonded_eth_dev, slave_port_id);
405
406         slave_idx = -1;
407         /* now find in slave list */
408         for (i = 0; i < internals->slave_count; i++)
409                 if (internals->slaves[i].port_id == slave_port_id) {
410                         slave_idx = i;
411                         break;
412                 }
413
414         if (slave_idx < 0) {
415                 RTE_BOND_LOG(ERR, "Couldn't find slave in port list, slave count %d",
416                                 internals->slave_count);
417                 return -1;
418         }
419
420         /* Un-register link status change callback with bonded device pointer as
421          * argument*/
422         rte_eth_dev_callback_unregister(slave_port_id, RTE_ETH_EVENT_INTR_LSC,
423                         bond_ethdev_lsc_event_callback,
424                         &rte_eth_devices[bonded_port_id].data->port_id);
425
426         /* Restore original MAC address of slave device */
427         rte_eth_dev_default_mac_addr_set(slave_port_id,
428                         &(internals->slaves[slave_idx].persisted_mac_addr));
429
430         slave_eth_dev = &rte_eth_devices[slave_port_id];
431         slave_remove(internals, slave_eth_dev);
432         slave_eth_dev->data->dev_flags &= (~RTE_ETH_DEV_BONDED_SLAVE);
433
434         /*  first slave in the active list will be the primary by default,
435          *  otherwise use first device in list */
436         if (internals->current_primary_port == slave_port_id) {
437                 if (internals->active_slave_count > 0)
438                         internals->current_primary_port = internals->active_slaves[0];
439                 else if (internals->slave_count > 0)
440                         internals->current_primary_port = internals->slaves[0].port_id;
441                 else
442                         internals->primary_port = 0;
443         }
444
445         if (internals->active_slave_count < 1) {
446                 /* if no slaves are any longer attached to bonded device and MAC is not
447                  * user defined then clear MAC of bonded device as it will be reset
448                  * when a new slave is added */
449                 if (internals->slave_count < 1 && !internals->user_defined_mac)
450                         memset(rte_eth_devices[bonded_port_id].data->mac_addrs, 0,
451                                         sizeof(*(rte_eth_devices[bonded_port_id].data->mac_addrs)));
452         }
453         if (internals->slave_count == 0) {
454                 internals->rx_offload_capa = 0;
455                 internals->tx_offload_capa = 0;
456                 internals->flow_type_rss_offloads = ETH_RSS_PROTO_MASK;
457                 internals->reta_size = 0;
458                 internals->candidate_max_rx_pktlen = 0;
459                 internals->max_rx_pktlen = 0;
460         }
461         return 0;
462 }
463
464 int
465 rte_eth_bond_slave_remove(uint16_t bonded_port_id, uint16_t slave_port_id)
466 {
467         struct rte_eth_dev *bonded_eth_dev;
468         struct bond_dev_private *internals;
469         int retval;
470
471         if (valid_bonded_port_id(bonded_port_id) != 0)
472                 return -1;
473
474         bonded_eth_dev = &rte_eth_devices[bonded_port_id];
475         internals = bonded_eth_dev->data->dev_private;
476
477         rte_spinlock_lock(&internals->lock);
478
479         retval = __eth_bond_slave_remove_lock_free(bonded_port_id, slave_port_id);
480
481         rte_spinlock_unlock(&internals->lock);
482
483         return retval;
484 }
485
486 int
487 rte_eth_bond_mode_set(uint16_t bonded_port_id, uint8_t mode)
488 {
489         struct rte_eth_dev *bonded_eth_dev;
490
491         if (valid_bonded_port_id(bonded_port_id) != 0)
492                 return -1;
493
494         bonded_eth_dev = &rte_eth_devices[bonded_port_id];
495
496         if (check_for_master_bonded_ethdev(bonded_eth_dev) != 0 &&
497                         mode == BONDING_MODE_8023AD)
498                 return -1;
499
500         return bond_ethdev_mode_set(bonded_eth_dev, mode);
501 }
502
503 int
504 rte_eth_bond_mode_get(uint16_t bonded_port_id)
505 {
506         struct bond_dev_private *internals;
507
508         if (valid_bonded_port_id(bonded_port_id) != 0)
509                 return -1;
510
511         internals = rte_eth_devices[bonded_port_id].data->dev_private;
512
513         return internals->mode;
514 }
515
516 int
517 rte_eth_bond_primary_set(uint16_t bonded_port_id, uint16_t slave_port_id)
518 {
519         struct bond_dev_private *internals;
520
521         if (valid_bonded_port_id(bonded_port_id) != 0)
522                 return -1;
523
524         internals = rte_eth_devices[bonded_port_id].data->dev_private;
525
526         if (valid_slave_port_id(slave_port_id, internals->mode) != 0)
527                 return -1;
528
529         internals->user_defined_primary_port = 1;
530         internals->primary_port = slave_port_id;
531
532         bond_ethdev_primary_set(internals, slave_port_id);
533
534         return 0;
535 }
536
537 int
538 rte_eth_bond_primary_get(uint16_t bonded_port_id)
539 {
540         struct bond_dev_private *internals;
541
542         if (valid_bonded_port_id(bonded_port_id) != 0)
543                 return -1;
544
545         internals = rte_eth_devices[bonded_port_id].data->dev_private;
546
547         if (internals->slave_count < 1)
548                 return -1;
549
550         return internals->current_primary_port;
551 }
552
553 int
554 rte_eth_bond_slaves_get(uint16_t bonded_port_id, uint16_t slaves[],
555                         uint16_t len)
556 {
557         struct bond_dev_private *internals;
558         uint8_t i;
559
560         if (valid_bonded_port_id(bonded_port_id) != 0)
561                 return -1;
562
563         if (slaves == NULL)
564                 return -1;
565
566         internals = rte_eth_devices[bonded_port_id].data->dev_private;
567
568         if (internals->slave_count > len)
569                 return -1;
570
571         for (i = 0; i < internals->slave_count; i++)
572                 slaves[i] = internals->slaves[i].port_id;
573
574         return internals->slave_count;
575 }
576
577 int
578 rte_eth_bond_active_slaves_get(uint16_t bonded_port_id, uint16_t slaves[],
579                 uint16_t len)
580 {
581         struct bond_dev_private *internals;
582
583         if (valid_bonded_port_id(bonded_port_id) != 0)
584                 return -1;
585
586         if (slaves == NULL)
587                 return -1;
588
589         internals = rte_eth_devices[bonded_port_id].data->dev_private;
590
591         if (internals->active_slave_count > len)
592                 return -1;
593
594         memcpy(slaves, internals->active_slaves,
595         internals->active_slave_count * sizeof(internals->active_slaves[0]));
596
597         return internals->active_slave_count;
598 }
599
600 int
601 rte_eth_bond_mac_address_set(uint16_t bonded_port_id,
602                 struct ether_addr *mac_addr)
603 {
604         struct rte_eth_dev *bonded_eth_dev;
605         struct bond_dev_private *internals;
606
607         if (valid_bonded_port_id(bonded_port_id) != 0)
608                 return -1;
609
610         bonded_eth_dev = &rte_eth_devices[bonded_port_id];
611         internals = bonded_eth_dev->data->dev_private;
612
613         /* Set MAC Address of Bonded Device */
614         if (mac_address_set(bonded_eth_dev, mac_addr))
615                 return -1;
616
617         internals->user_defined_mac = 1;
618
619         /* Update all slave devices MACs*/
620         if (internals->slave_count > 0)
621                 return mac_address_slaves_update(bonded_eth_dev);
622
623         return 0;
624 }
625
626 int
627 rte_eth_bond_mac_address_reset(uint16_t bonded_port_id)
628 {
629         struct rte_eth_dev *bonded_eth_dev;
630         struct bond_dev_private *internals;
631
632         if (valid_bonded_port_id(bonded_port_id) != 0)
633                 return -1;
634
635         bonded_eth_dev = &rte_eth_devices[bonded_port_id];
636         internals = bonded_eth_dev->data->dev_private;
637
638         internals->user_defined_mac = 0;
639
640         if (internals->slave_count > 0) {
641                 /* Set MAC Address of Bonded Device */
642                 if (mac_address_set(bonded_eth_dev,
643                                 &internals->slaves[internals->primary_port].persisted_mac_addr)
644                                 != 0) {
645                         RTE_BOND_LOG(ERR, "Failed to set MAC address on bonded device");
646                         return -1;
647                 }
648                 /* Update all slave devices MAC addresses */
649                 return mac_address_slaves_update(bonded_eth_dev);
650         }
651         /* No need to update anything as no slaves present */
652         return 0;
653 }
654
655 int
656 rte_eth_bond_xmit_policy_set(uint16_t bonded_port_id, uint8_t policy)
657 {
658         struct bond_dev_private *internals;
659
660         if (valid_bonded_port_id(bonded_port_id) != 0)
661                 return -1;
662
663         internals = rte_eth_devices[bonded_port_id].data->dev_private;
664
665         switch (policy) {
666         case BALANCE_XMIT_POLICY_LAYER2:
667                 internals->balance_xmit_policy = policy;
668                 internals->xmit_hash = xmit_l2_hash;
669                 break;
670         case BALANCE_XMIT_POLICY_LAYER23:
671                 internals->balance_xmit_policy = policy;
672                 internals->xmit_hash = xmit_l23_hash;
673                 break;
674         case BALANCE_XMIT_POLICY_LAYER34:
675                 internals->balance_xmit_policy = policy;
676                 internals->xmit_hash = xmit_l34_hash;
677                 break;
678
679         default:
680                 return -1;
681         }
682         return 0;
683 }
684
685 int
686 rte_eth_bond_xmit_policy_get(uint16_t bonded_port_id)
687 {
688         struct bond_dev_private *internals;
689
690         if (valid_bonded_port_id(bonded_port_id) != 0)
691                 return -1;
692
693         internals = rte_eth_devices[bonded_port_id].data->dev_private;
694
695         return internals->balance_xmit_policy;
696 }
697
698 int
699 rte_eth_bond_link_monitoring_set(uint16_t bonded_port_id, uint32_t internal_ms)
700 {
701         struct bond_dev_private *internals;
702
703         if (valid_bonded_port_id(bonded_port_id) != 0)
704                 return -1;
705
706         internals = rte_eth_devices[bonded_port_id].data->dev_private;
707         internals->link_status_polling_interval_ms = internal_ms;
708
709         return 0;
710 }
711
712 int
713 rte_eth_bond_link_monitoring_get(uint16_t bonded_port_id)
714 {
715         struct bond_dev_private *internals;
716
717         if (valid_bonded_port_id(bonded_port_id) != 0)
718                 return -1;
719
720         internals = rte_eth_devices[bonded_port_id].data->dev_private;
721
722         return internals->link_status_polling_interval_ms;
723 }
724
725 int
726 rte_eth_bond_link_down_prop_delay_set(uint16_t bonded_port_id,
727                                        uint32_t delay_ms)
728
729 {
730         struct bond_dev_private *internals;
731
732         if (valid_bonded_port_id(bonded_port_id) != 0)
733                 return -1;
734
735         internals = rte_eth_devices[bonded_port_id].data->dev_private;
736         internals->link_down_delay_ms = delay_ms;
737
738         return 0;
739 }
740
741 int
742 rte_eth_bond_link_down_prop_delay_get(uint16_t bonded_port_id)
743 {
744         struct bond_dev_private *internals;
745
746         if (valid_bonded_port_id(bonded_port_id) != 0)
747                 return -1;
748
749         internals = rte_eth_devices[bonded_port_id].data->dev_private;
750
751         return internals->link_down_delay_ms;
752 }
753
754 int
755 rte_eth_bond_link_up_prop_delay_set(uint16_t bonded_port_id, uint32_t delay_ms)
756
757 {
758         struct bond_dev_private *internals;
759
760         if (valid_bonded_port_id(bonded_port_id) != 0)
761                 return -1;
762
763         internals = rte_eth_devices[bonded_port_id].data->dev_private;
764         internals->link_up_delay_ms = delay_ms;
765
766         return 0;
767 }
768
769 int
770 rte_eth_bond_link_up_prop_delay_get(uint16_t bonded_port_id)
771 {
772         struct bond_dev_private *internals;
773
774         if (valid_bonded_port_id(bonded_port_id) != 0)
775                 return -1;
776
777         internals = rte_eth_devices[bonded_port_id].data->dev_private;
778
779         return internals->link_up_delay_ms;
780 }