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_driver.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 == NULL || 23 eth_dev->device == NULL || 24 eth_dev->device->driver == NULL || 25 eth_dev->device->driver->name == NULL) 26 return -1; 27 28 /* return 0 if driver name matches */ 29 return eth_dev->device->driver->name != pmd_bond_drv.driver.name; 30 } 31 32 int 33 valid_bonded_port_id(uint16_t port_id) 34 { 35 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -1); 36 return check_for_bonded_ethdev(&rte_eth_devices[port_id]); 37 } 38 39 int 40 check_for_master_bonded_ethdev(const struct rte_eth_dev *eth_dev) 41 { 42 int i; 43 struct bond_dev_private *internals; 44 45 if (check_for_bonded_ethdev(eth_dev) != 0) 46 return 0; 47 48 internals = eth_dev->data->dev_private; 49 50 /* Check if any of slave devices is a bonded device */ 51 for (i = 0; i < internals->slave_count; i++) 52 if (valid_bonded_port_id(internals->slaves[i].port_id) == 0) 53 return 1; 54 55 return 0; 56 } 57 58 int 59 valid_slave_port_id(uint16_t port_id, uint8_t mode) 60 { 61 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -1); 62 63 /* Verify that port_id refers to a non bonded port */ 64 if (check_for_bonded_ethdev(&rte_eth_devices[port_id]) == 0 && 65 mode == BONDING_MODE_8023AD) { 66 RTE_BOND_LOG(ERR, "Cannot add slave to bonded device in 802.3ad" 67 " mode as slave is also a bonded device, only " 68 "physical devices can be support in this mode."); 69 return -1; 70 } 71 72 return 0; 73 } 74 75 void 76 activate_slave(struct rte_eth_dev *eth_dev, uint16_t port_id) 77 { 78 struct bond_dev_private *internals = eth_dev->data->dev_private; 79 uint8_t active_count = internals->active_slave_count; 80 81 if (internals->mode == BONDING_MODE_8023AD) 82 bond_mode_8023ad_activate_slave(eth_dev, port_id); 83 84 if (internals->mode == BONDING_MODE_TLB 85 || internals->mode == BONDING_MODE_ALB) { 86 87 internals->tlb_slaves_order[active_count] = port_id; 88 } 89 90 RTE_ASSERT(internals->active_slave_count < 91 (RTE_DIM(internals->active_slaves) - 1)); 92 93 internals->active_slaves[internals->active_slave_count] = port_id; 94 internals->active_slave_count++; 95 96 if (internals->mode == BONDING_MODE_TLB) 97 bond_tlb_activate_slave(internals); 98 if (internals->mode == BONDING_MODE_ALB) 99 bond_mode_alb_client_list_upd(eth_dev); 100 } 101 102 void 103 deactivate_slave(struct rte_eth_dev *eth_dev, uint16_t port_id) 104 { 105 uint16_t slave_pos; 106 struct bond_dev_private *internals = eth_dev->data->dev_private; 107 uint16_t active_count = internals->active_slave_count; 108 109 if (internals->mode == BONDING_MODE_8023AD) { 110 bond_mode_8023ad_stop(eth_dev); 111 bond_mode_8023ad_deactivate_slave(eth_dev, port_id); 112 } else if (internals->mode == BONDING_MODE_TLB 113 || internals->mode == BONDING_MODE_ALB) 114 bond_tlb_disable(internals); 115 116 slave_pos = find_slave_by_id(internals->active_slaves, active_count, 117 port_id); 118 119 /* If slave was not at the end of the list 120 * shift active slaves up active array list */ 121 if (slave_pos < active_count) { 122 active_count--; 123 memmove(internals->active_slaves + slave_pos, 124 internals->active_slaves + slave_pos + 1, 125 (active_count - slave_pos) * 126 sizeof(internals->active_slaves[0])); 127 } 128 129 RTE_ASSERT(active_count < RTE_DIM(internals->active_slaves)); 130 internals->active_slave_count = active_count; 131 132 if (eth_dev->data->dev_started) { 133 if (internals->mode == BONDING_MODE_8023AD) { 134 bond_mode_8023ad_start(eth_dev); 135 } else if (internals->mode == BONDING_MODE_TLB) { 136 bond_tlb_enable(internals); 137 } else if (internals->mode == BONDING_MODE_ALB) { 138 bond_tlb_enable(internals); 139 bond_mode_alb_client_list_upd(eth_dev); 140 } 141 } 142 } 143 144 int 145 rte_eth_bond_create(const char *name, uint8_t mode, uint8_t socket_id) 146 { 147 struct bond_dev_private *internals; 148 char devargs[52]; 149 uint16_t port_id; 150 int ret; 151 152 if (name == NULL) { 153 RTE_BOND_LOG(ERR, "Invalid name specified"); 154 return -EINVAL; 155 } 156 157 ret = snprintf(devargs, sizeof(devargs), 158 "driver=net_bonding,mode=%d,socket_id=%d", mode, socket_id); 159 if (ret < 0 || ret >= (int)sizeof(devargs)) 160 return -ENOMEM; 161 162 ret = rte_vdev_init(name, devargs); 163 if (ret) 164 return -ENOMEM; 165 166 ret = rte_eth_dev_get_port_by_name(name, &port_id); 167 RTE_ASSERT(!ret); 168 169 /* 170 * To make bond_ethdev_configure() happy we need to free the 171 * internals->kvlist here. 172 * 173 * Also see comment in bond_ethdev_configure(). 174 */ 175 internals = rte_eth_devices[port_id].data->dev_private; 176 rte_kvargs_free(internals->kvlist); 177 internals->kvlist = NULL; 178 179 return port_id; 180 } 181 182 int 183 rte_eth_bond_free(const char *name) 184 { 185 return rte_vdev_uninit(name); 186 } 187 188 static int 189 slave_vlan_filter_set(uint16_t bonded_port_id, uint16_t slave_port_id) 190 { 191 struct rte_eth_dev *bonded_eth_dev; 192 struct bond_dev_private *internals; 193 int found; 194 int res = 0; 195 uint64_t slab = 0; 196 uint32_t pos = 0; 197 uint16_t first; 198 199 bonded_eth_dev = &rte_eth_devices[bonded_port_id]; 200 if ((bonded_eth_dev->data->dev_conf.rxmode.offloads & 201 DEV_RX_OFFLOAD_VLAN_FILTER) == 0) 202 return 0; 203 204 internals = bonded_eth_dev->data->dev_private; 205 found = rte_bitmap_scan(internals->vlan_filter_bmp, &pos, &slab); 206 first = pos; 207 208 if (!found) 209 return 0; 210 211 do { 212 uint32_t i; 213 uint64_t mask; 214 215 for (i = 0, mask = 1; 216 i < RTE_BITMAP_SLAB_BIT_SIZE; 217 i ++, mask <<= 1) { 218 if (unlikely(slab & mask)) { 219 uint16_t vlan_id = pos + i; 220 221 res = rte_eth_dev_vlan_filter(slave_port_id, 222 vlan_id, 1); 223 } 224 } 225 found = rte_bitmap_scan(internals->vlan_filter_bmp, 226 &pos, &slab); 227 } while (found && first != pos && res == 0); 228 229 return res; 230 } 231 232 static int 233 slave_rte_flow_prepare(uint16_t slave_id, struct bond_dev_private *internals) 234 { 235 struct rte_flow *flow; 236 struct rte_flow_error ferror; 237 uint16_t slave_port_id = internals->slaves[slave_id].port_id; 238 239 if (internals->flow_isolated_valid != 0) { 240 rte_eth_dev_stop(slave_port_id); 241 if (rte_flow_isolate(slave_port_id, internals->flow_isolated, 242 &ferror)) { 243 RTE_BOND_LOG(ERR, "rte_flow_isolate failed for slave" 244 " %d: %s", slave_id, ferror.message ? 245 ferror.message : "(no stated reason)"); 246 return -1; 247 } 248 } 249 TAILQ_FOREACH(flow, &internals->flow_list, next) { 250 flow->flows[slave_id] = rte_flow_create(slave_port_id, 251 flow->rule.attr, 252 flow->rule.pattern, 253 flow->rule.actions, 254 &ferror); 255 if (flow->flows[slave_id] == NULL) { 256 RTE_BOND_LOG(ERR, "Cannot create flow for slave" 257 " %d: %s", slave_id, 258 ferror.message ? ferror.message : 259 "(no stated reason)"); 260 /* Destroy successful bond flows from the slave */ 261 TAILQ_FOREACH(flow, &internals->flow_list, next) { 262 if (flow->flows[slave_id] != NULL) { 263 rte_flow_destroy(slave_port_id, 264 flow->flows[slave_id], 265 &ferror); 266 flow->flows[slave_id] = NULL; 267 } 268 } 269 return -1; 270 } 271 } 272 return 0; 273 } 274 275 static void 276 eth_bond_slave_inherit_dev_info_rx_first(struct bond_dev_private *internals, 277 const struct rte_eth_dev_info *di) 278 { 279 struct rte_eth_rxconf *rxconf_i = &internals->default_rxconf; 280 281 internals->reta_size = di->reta_size; 282 283 /* Inherit Rx offload capabilities from the first slave device */ 284 internals->rx_offload_capa = di->rx_offload_capa; 285 internals->rx_queue_offload_capa = di->rx_queue_offload_capa; 286 internals->flow_type_rss_offloads = di->flow_type_rss_offloads; 287 288 /* Inherit maximum Rx packet size from the first slave device */ 289 internals->candidate_max_rx_pktlen = di->max_rx_pktlen; 290 291 /* Inherit default Rx queue settings from the first slave device */ 292 memcpy(rxconf_i, &di->default_rxconf, sizeof(*rxconf_i)); 293 294 /* 295 * Turn off descriptor prefetch and writeback by default for all 296 * slave devices. Applications may tweak this setting if need be. 297 */ 298 rxconf_i->rx_thresh.pthresh = 0; 299 rxconf_i->rx_thresh.hthresh = 0; 300 rxconf_i->rx_thresh.wthresh = 0; 301 302 /* Setting this to zero should effectively enable default values */ 303 rxconf_i->rx_free_thresh = 0; 304 305 /* Disable deferred start by default for all slave devices */ 306 rxconf_i->rx_deferred_start = 0; 307 } 308 309 static void 310 eth_bond_slave_inherit_dev_info_tx_first(struct bond_dev_private *internals, 311 const struct rte_eth_dev_info *di) 312 { 313 struct rte_eth_txconf *txconf_i = &internals->default_txconf; 314 315 /* Inherit Tx offload capabilities from the first slave device */ 316 internals->tx_offload_capa = di->tx_offload_capa; 317 internals->tx_queue_offload_capa = di->tx_queue_offload_capa; 318 319 /* Inherit default Tx queue settings from the first slave device */ 320 memcpy(txconf_i, &di->default_txconf, sizeof(*txconf_i)); 321 322 /* 323 * Turn off descriptor prefetch and writeback by default for all 324 * slave devices. Applications may tweak this setting if need be. 325 */ 326 txconf_i->tx_thresh.pthresh = 0; 327 txconf_i->tx_thresh.hthresh = 0; 328 txconf_i->tx_thresh.wthresh = 0; 329 330 /* 331 * Setting these parameters to zero assumes that default 332 * values will be configured implicitly by slave devices. 333 */ 334 txconf_i->tx_free_thresh = 0; 335 txconf_i->tx_rs_thresh = 0; 336 337 /* Disable deferred start by default for all slave devices */ 338 txconf_i->tx_deferred_start = 0; 339 } 340 341 static void 342 eth_bond_slave_inherit_dev_info_rx_next(struct bond_dev_private *internals, 343 const struct rte_eth_dev_info *di) 344 { 345 struct rte_eth_rxconf *rxconf_i = &internals->default_rxconf; 346 const struct rte_eth_rxconf *rxconf = &di->default_rxconf; 347 348 internals->rx_offload_capa &= di->rx_offload_capa; 349 internals->rx_queue_offload_capa &= di->rx_queue_offload_capa; 350 internals->flow_type_rss_offloads &= di->flow_type_rss_offloads; 351 352 /* 353 * If at least one slave device suggests enabling this 354 * setting by default, enable it for all slave devices 355 * since disabling it may not be necessarily supported. 356 */ 357 if (rxconf->rx_drop_en == 1) 358 rxconf_i->rx_drop_en = 1; 359 360 /* 361 * Adding a new slave device may cause some of previously inherited 362 * offloads to be withdrawn from the internal rx_queue_offload_capa 363 * value. Thus, the new internal value of default Rx queue offloads 364 * has to be masked by rx_queue_offload_capa to make sure that only 365 * commonly supported offloads are preserved from both the previous 366 * value and the value being inhereted from the new slave device. 367 */ 368 rxconf_i->offloads = (rxconf_i->offloads | rxconf->offloads) & 369 internals->rx_queue_offload_capa; 370 371 /* 372 * RETA size is GCD of all slaves RETA sizes, so, if all sizes will be 373 * the power of 2, the lower one is GCD 374 */ 375 if (internals->reta_size > di->reta_size) 376 internals->reta_size = di->reta_size; 377 378 if (!internals->max_rx_pktlen && 379 di->max_rx_pktlen < internals->candidate_max_rx_pktlen) 380 internals->candidate_max_rx_pktlen = di->max_rx_pktlen; 381 } 382 383 static void 384 eth_bond_slave_inherit_dev_info_tx_next(struct bond_dev_private *internals, 385 const struct rte_eth_dev_info *di) 386 { 387 struct rte_eth_txconf *txconf_i = &internals->default_txconf; 388 const struct rte_eth_txconf *txconf = &di->default_txconf; 389 390 internals->tx_offload_capa &= di->tx_offload_capa; 391 internals->tx_queue_offload_capa &= di->tx_queue_offload_capa; 392 393 /* 394 * Adding a new slave device may cause some of previously inherited 395 * offloads to be withdrawn from the internal tx_queue_offload_capa 396 * value. Thus, the new internal value of default Tx queue offloads 397 * has to be masked by tx_queue_offload_capa to make sure that only 398 * commonly supported offloads are preserved from both the previous 399 * value and the value being inhereted from the new slave device. 400 */ 401 txconf_i->offloads = (txconf_i->offloads | txconf->offloads) & 402 internals->tx_queue_offload_capa; 403 } 404 405 static void 406 eth_bond_slave_inherit_desc_lim_first(struct rte_eth_desc_lim *bond_desc_lim, 407 const struct rte_eth_desc_lim *slave_desc_lim) 408 { 409 memcpy(bond_desc_lim, slave_desc_lim, sizeof(*bond_desc_lim)); 410 } 411 412 static int 413 eth_bond_slave_inherit_desc_lim_next(struct rte_eth_desc_lim *bond_desc_lim, 414 const struct rte_eth_desc_lim *slave_desc_lim) 415 { 416 bond_desc_lim->nb_max = RTE_MIN(bond_desc_lim->nb_max, 417 slave_desc_lim->nb_max); 418 bond_desc_lim->nb_min = RTE_MAX(bond_desc_lim->nb_min, 419 slave_desc_lim->nb_min); 420 bond_desc_lim->nb_align = RTE_MAX(bond_desc_lim->nb_align, 421 slave_desc_lim->nb_align); 422 423 if (bond_desc_lim->nb_min > bond_desc_lim->nb_max || 424 bond_desc_lim->nb_align > bond_desc_lim->nb_max) { 425 RTE_BOND_LOG(ERR, "Failed to inherit descriptor limits"); 426 return -EINVAL; 427 } 428 429 /* Treat maximum number of segments equal to 0 as unspecified */ 430 if (slave_desc_lim->nb_seg_max != 0 && 431 (bond_desc_lim->nb_seg_max == 0 || 432 slave_desc_lim->nb_seg_max < bond_desc_lim->nb_seg_max)) 433 bond_desc_lim->nb_seg_max = slave_desc_lim->nb_seg_max; 434 if (slave_desc_lim->nb_mtu_seg_max != 0 && 435 (bond_desc_lim->nb_mtu_seg_max == 0 || 436 slave_desc_lim->nb_mtu_seg_max < bond_desc_lim->nb_mtu_seg_max)) 437 bond_desc_lim->nb_mtu_seg_max = slave_desc_lim->nb_mtu_seg_max; 438 439 return 0; 440 } 441 442 static int 443 __eth_bond_slave_add_lock_free(uint16_t bonded_port_id, uint16_t slave_port_id) 444 { 445 struct rte_eth_dev *bonded_eth_dev, *slave_eth_dev; 446 struct bond_dev_private *internals; 447 struct rte_eth_link link_props; 448 struct rte_eth_dev_info dev_info; 449 450 bonded_eth_dev = &rte_eth_devices[bonded_port_id]; 451 internals = bonded_eth_dev->data->dev_private; 452 453 if (valid_slave_port_id(slave_port_id, internals->mode) != 0) 454 return -1; 455 456 slave_eth_dev = &rte_eth_devices[slave_port_id]; 457 if (slave_eth_dev->data->dev_flags & RTE_ETH_DEV_BONDED_SLAVE) { 458 RTE_BOND_LOG(ERR, "Slave device is already a slave of a bonded device"); 459 return -1; 460 } 461 462 rte_eth_dev_info_get(slave_port_id, &dev_info); 463 if (dev_info.max_rx_pktlen < internals->max_rx_pktlen) { 464 RTE_BOND_LOG(ERR, "Slave (port %u) max_rx_pktlen too small", 465 slave_port_id); 466 return -1; 467 } 468 469 slave_add(internals, slave_eth_dev); 470 471 /* We need to store slaves reta_size to be able to synchronize RETA for all 472 * slave devices even if its sizes are different. 473 */ 474 internals->slaves[internals->slave_count].reta_size = dev_info.reta_size; 475 476 if (internals->slave_count < 1) { 477 /* if MAC is not user defined then use MAC of first slave add to 478 * bonded device */ 479 if (!internals->user_defined_mac) { 480 if (mac_address_set(bonded_eth_dev, 481 slave_eth_dev->data->mac_addrs)) { 482 RTE_BOND_LOG(ERR, "Failed to set MAC address"); 483 return -1; 484 } 485 } 486 487 /* Inherit eth dev link properties from first slave */ 488 link_properties_set(bonded_eth_dev, 489 &(slave_eth_dev->data->dev_link)); 490 491 /* Make primary slave */ 492 internals->primary_port = slave_port_id; 493 internals->current_primary_port = slave_port_id; 494 495 /* Inherit queues settings from first slave */ 496 internals->nb_rx_queues = slave_eth_dev->data->nb_rx_queues; 497 internals->nb_tx_queues = slave_eth_dev->data->nb_tx_queues; 498 499 eth_bond_slave_inherit_dev_info_rx_first(internals, &dev_info); 500 eth_bond_slave_inherit_dev_info_tx_first(internals, &dev_info); 501 502 eth_bond_slave_inherit_desc_lim_first(&internals->rx_desc_lim, 503 &dev_info.rx_desc_lim); 504 eth_bond_slave_inherit_desc_lim_first(&internals->tx_desc_lim, 505 &dev_info.tx_desc_lim); 506 } else { 507 int ret; 508 509 eth_bond_slave_inherit_dev_info_rx_next(internals, &dev_info); 510 eth_bond_slave_inherit_dev_info_tx_next(internals, &dev_info); 511 512 ret = eth_bond_slave_inherit_desc_lim_next( 513 &internals->rx_desc_lim, &dev_info.rx_desc_lim); 514 if (ret != 0) 515 return ret; 516 517 ret = eth_bond_slave_inherit_desc_lim_next( 518 &internals->tx_desc_lim, &dev_info.tx_desc_lim); 519 if (ret != 0) 520 return ret; 521 } 522 523 bonded_eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_hf &= 524 internals->flow_type_rss_offloads; 525 526 if (slave_rte_flow_prepare(internals->slave_count, internals) != 0) { 527 RTE_BOND_LOG(ERR, "Failed to prepare new slave flows: port=%d", 528 slave_port_id); 529 return -1; 530 } 531 532 /* Add additional MAC addresses to the slave */ 533 if (slave_add_mac_addresses(bonded_eth_dev, slave_port_id) != 0) { 534 RTE_BOND_LOG(ERR, "Failed to add mac address(es) to slave %hu", 535 slave_port_id); 536 return -1; 537 } 538 539 internals->slave_count++; 540 541 if (bonded_eth_dev->data->dev_started) { 542 if (slave_configure(bonded_eth_dev, slave_eth_dev) != 0) { 543 internals->slave_count--; 544 RTE_BOND_LOG(ERR, "rte_bond_slaves_configure: port=%d", 545 slave_port_id); 546 return -1; 547 } 548 } 549 550 /* Add slave details to bonded device */ 551 slave_eth_dev->data->dev_flags |= RTE_ETH_DEV_BONDED_SLAVE; 552 553 /* Update all slave devices MACs */ 554 mac_address_slaves_update(bonded_eth_dev); 555 556 /* Register link status change callback with bonded device pointer as 557 * argument*/ 558 rte_eth_dev_callback_register(slave_port_id, RTE_ETH_EVENT_INTR_LSC, 559 bond_ethdev_lsc_event_callback, &bonded_eth_dev->data->port_id); 560 561 /* If bonded device is started then we can add the slave to our active 562 * slave array */ 563 if (bonded_eth_dev->data->dev_started) { 564 rte_eth_link_get_nowait(slave_port_id, &link_props); 565 566 if (link_props.link_status == ETH_LINK_UP) { 567 if (internals->active_slave_count == 0 && 568 !internals->user_defined_primary_port) 569 bond_ethdev_primary_set(internals, 570 slave_port_id); 571 } 572 } 573 574 slave_vlan_filter_set(bonded_port_id, slave_port_id); 575 576 return 0; 577 578 } 579 580 int 581 rte_eth_bond_slave_add(uint16_t bonded_port_id, uint16_t slave_port_id) 582 { 583 struct rte_eth_dev *bonded_eth_dev; 584 struct bond_dev_private *internals; 585 586 int retval; 587 588 /* Verify that port id's are valid bonded and slave ports */ 589 if (valid_bonded_port_id(bonded_port_id) != 0) 590 return -1; 591 592 bonded_eth_dev = &rte_eth_devices[bonded_port_id]; 593 internals = bonded_eth_dev->data->dev_private; 594 595 rte_spinlock_lock(&internals->lock); 596 597 retval = __eth_bond_slave_add_lock_free(bonded_port_id, slave_port_id); 598 599 rte_spinlock_unlock(&internals->lock); 600 601 return retval; 602 } 603 604 static int 605 __eth_bond_slave_remove_lock_free(uint16_t bonded_port_id, 606 uint16_t slave_port_id) 607 { 608 struct rte_eth_dev *bonded_eth_dev; 609 struct bond_dev_private *internals; 610 struct rte_eth_dev *slave_eth_dev; 611 struct rte_flow_error flow_error; 612 struct rte_flow *flow; 613 int i, slave_idx; 614 615 bonded_eth_dev = &rte_eth_devices[bonded_port_id]; 616 internals = bonded_eth_dev->data->dev_private; 617 618 if (valid_slave_port_id(slave_port_id, internals->mode) < 0) 619 return -1; 620 621 /* first remove from active slave list */ 622 slave_idx = find_slave_by_id(internals->active_slaves, 623 internals->active_slave_count, slave_port_id); 624 625 if (slave_idx < internals->active_slave_count) 626 deactivate_slave(bonded_eth_dev, slave_port_id); 627 628 slave_idx = -1; 629 /* now find in slave list */ 630 for (i = 0; i < internals->slave_count; i++) 631 if (internals->slaves[i].port_id == slave_port_id) { 632 slave_idx = i; 633 break; 634 } 635 636 if (slave_idx < 0) { 637 RTE_BOND_LOG(ERR, "Couldn't find slave in port list, slave count %d", 638 internals->slave_count); 639 return -1; 640 } 641 642 /* Un-register link status change callback with bonded device pointer as 643 * argument*/ 644 rte_eth_dev_callback_unregister(slave_port_id, RTE_ETH_EVENT_INTR_LSC, 645 bond_ethdev_lsc_event_callback, 646 &rte_eth_devices[bonded_port_id].data->port_id); 647 648 /* Restore original MAC address of slave device */ 649 rte_eth_dev_default_mac_addr_set(slave_port_id, 650 &(internals->slaves[slave_idx].persisted_mac_addr)); 651 652 /* remove additional MAC addresses from the slave */ 653 slave_remove_mac_addresses(bonded_eth_dev, slave_port_id); 654 655 /* 656 * Remove bond device flows from slave device. 657 * Note: don't restore flow isolate mode. 658 */ 659 TAILQ_FOREACH(flow, &internals->flow_list, next) { 660 if (flow->flows[slave_idx] != NULL) { 661 rte_flow_destroy(slave_port_id, flow->flows[slave_idx], 662 &flow_error); 663 flow->flows[slave_idx] = NULL; 664 } 665 } 666 667 slave_eth_dev = &rte_eth_devices[slave_port_id]; 668 slave_remove(internals, slave_eth_dev); 669 slave_eth_dev->data->dev_flags &= (~RTE_ETH_DEV_BONDED_SLAVE); 670 671 /* first slave in the active list will be the primary by default, 672 * otherwise use first device in list */ 673 if (internals->current_primary_port == slave_port_id) { 674 if (internals->active_slave_count > 0) 675 internals->current_primary_port = internals->active_slaves[0]; 676 else if (internals->slave_count > 0) 677 internals->current_primary_port = internals->slaves[0].port_id; 678 else 679 internals->primary_port = 0; 680 } 681 682 if (internals->active_slave_count < 1) { 683 /* if no slaves are any longer attached to bonded device and MAC is not 684 * user defined then clear MAC of bonded device as it will be reset 685 * when a new slave is added */ 686 if (internals->slave_count < 1 && !internals->user_defined_mac) 687 memset(rte_eth_devices[bonded_port_id].data->mac_addrs, 0, 688 sizeof(*(rte_eth_devices[bonded_port_id].data->mac_addrs))); 689 } 690 if (internals->slave_count == 0) { 691 internals->rx_offload_capa = 0; 692 internals->tx_offload_capa = 0; 693 internals->rx_queue_offload_capa = 0; 694 internals->tx_queue_offload_capa = 0; 695 internals->flow_type_rss_offloads = ETH_RSS_PROTO_MASK; 696 internals->reta_size = 0; 697 internals->candidate_max_rx_pktlen = 0; 698 internals->max_rx_pktlen = 0; 699 } 700 return 0; 701 } 702 703 int 704 rte_eth_bond_slave_remove(uint16_t bonded_port_id, uint16_t slave_port_id) 705 { 706 struct rte_eth_dev *bonded_eth_dev; 707 struct bond_dev_private *internals; 708 int retval; 709 710 if (valid_bonded_port_id(bonded_port_id) != 0) 711 return -1; 712 713 bonded_eth_dev = &rte_eth_devices[bonded_port_id]; 714 internals = bonded_eth_dev->data->dev_private; 715 716 rte_spinlock_lock(&internals->lock); 717 718 retval = __eth_bond_slave_remove_lock_free(bonded_port_id, slave_port_id); 719 720 rte_spinlock_unlock(&internals->lock); 721 722 return retval; 723 } 724 725 int 726 rte_eth_bond_mode_set(uint16_t bonded_port_id, uint8_t mode) 727 { 728 struct rte_eth_dev *bonded_eth_dev; 729 730 if (valid_bonded_port_id(bonded_port_id) != 0) 731 return -1; 732 733 bonded_eth_dev = &rte_eth_devices[bonded_port_id]; 734 735 if (check_for_master_bonded_ethdev(bonded_eth_dev) != 0 && 736 mode == BONDING_MODE_8023AD) 737 return -1; 738 739 return bond_ethdev_mode_set(bonded_eth_dev, mode); 740 } 741 742 int 743 rte_eth_bond_mode_get(uint16_t bonded_port_id) 744 { 745 struct bond_dev_private *internals; 746 747 if (valid_bonded_port_id(bonded_port_id) != 0) 748 return -1; 749 750 internals = rte_eth_devices[bonded_port_id].data->dev_private; 751 752 return internals->mode; 753 } 754 755 int 756 rte_eth_bond_primary_set(uint16_t bonded_port_id, uint16_t slave_port_id) 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 765 if (valid_slave_port_id(slave_port_id, internals->mode) != 0) 766 return -1; 767 768 internals->user_defined_primary_port = 1; 769 internals->primary_port = slave_port_id; 770 771 bond_ethdev_primary_set(internals, slave_port_id); 772 773 return 0; 774 } 775 776 int 777 rte_eth_bond_primary_get(uint16_t bonded_port_id) 778 { 779 struct bond_dev_private *internals; 780 781 if (valid_bonded_port_id(bonded_port_id) != 0) 782 return -1; 783 784 internals = rte_eth_devices[bonded_port_id].data->dev_private; 785 786 if (internals->slave_count < 1) 787 return -1; 788 789 return internals->current_primary_port; 790 } 791 792 int 793 rte_eth_bond_slaves_get(uint16_t bonded_port_id, uint16_t slaves[], 794 uint16_t len) 795 { 796 struct bond_dev_private *internals; 797 uint8_t i; 798 799 if (valid_bonded_port_id(bonded_port_id) != 0) 800 return -1; 801 802 if (slaves == NULL) 803 return -1; 804 805 internals = rte_eth_devices[bonded_port_id].data->dev_private; 806 807 if (internals->slave_count > len) 808 return -1; 809 810 for (i = 0; i < internals->slave_count; i++) 811 slaves[i] = internals->slaves[i].port_id; 812 813 return internals->slave_count; 814 } 815 816 int 817 rte_eth_bond_active_slaves_get(uint16_t bonded_port_id, uint16_t slaves[], 818 uint16_t len) 819 { 820 struct bond_dev_private *internals; 821 822 if (valid_bonded_port_id(bonded_port_id) != 0) 823 return -1; 824 825 if (slaves == NULL) 826 return -1; 827 828 internals = rte_eth_devices[bonded_port_id].data->dev_private; 829 830 if (internals->active_slave_count > len) 831 return -1; 832 833 memcpy(slaves, internals->active_slaves, 834 internals->active_slave_count * sizeof(internals->active_slaves[0])); 835 836 return internals->active_slave_count; 837 } 838 839 int 840 rte_eth_bond_mac_address_set(uint16_t bonded_port_id, 841 struct ether_addr *mac_addr) 842 { 843 struct rte_eth_dev *bonded_eth_dev; 844 struct bond_dev_private *internals; 845 846 if (valid_bonded_port_id(bonded_port_id) != 0) 847 return -1; 848 849 bonded_eth_dev = &rte_eth_devices[bonded_port_id]; 850 internals = bonded_eth_dev->data->dev_private; 851 852 /* Set MAC Address of Bonded Device */ 853 if (mac_address_set(bonded_eth_dev, mac_addr)) 854 return -1; 855 856 internals->user_defined_mac = 1; 857 858 /* Update all slave devices MACs*/ 859 if (internals->slave_count > 0) 860 return mac_address_slaves_update(bonded_eth_dev); 861 862 return 0; 863 } 864 865 int 866 rte_eth_bond_mac_address_reset(uint16_t bonded_port_id) 867 { 868 struct rte_eth_dev *bonded_eth_dev; 869 struct bond_dev_private *internals; 870 871 if (valid_bonded_port_id(bonded_port_id) != 0) 872 return -1; 873 874 bonded_eth_dev = &rte_eth_devices[bonded_port_id]; 875 internals = bonded_eth_dev->data->dev_private; 876 877 internals->user_defined_mac = 0; 878 879 if (internals->slave_count > 0) { 880 int slave_port; 881 /* Get the primary slave location based on the primary port 882 * number as, while slave_add(), we will keep the primary 883 * slave based on slave_count,but not based on the primary port. 884 */ 885 for (slave_port = 0; slave_port < internals->slave_count; 886 slave_port++) { 887 if (internals->slaves[slave_port].port_id == 888 internals->primary_port) 889 break; 890 } 891 892 /* Set MAC Address of Bonded Device */ 893 if (mac_address_set(bonded_eth_dev, 894 &internals->slaves[slave_port].persisted_mac_addr) 895 != 0) { 896 RTE_BOND_LOG(ERR, "Failed to set MAC address on bonded device"); 897 return -1; 898 } 899 /* Update all slave devices MAC addresses */ 900 return mac_address_slaves_update(bonded_eth_dev); 901 } 902 /* No need to update anything as no slaves present */ 903 return 0; 904 } 905 906 int 907 rte_eth_bond_xmit_policy_set(uint16_t bonded_port_id, uint8_t policy) 908 { 909 struct bond_dev_private *internals; 910 911 if (valid_bonded_port_id(bonded_port_id) != 0) 912 return -1; 913 914 internals = rte_eth_devices[bonded_port_id].data->dev_private; 915 916 switch (policy) { 917 case BALANCE_XMIT_POLICY_LAYER2: 918 internals->balance_xmit_policy = policy; 919 internals->burst_xmit_hash = burst_xmit_l2_hash; 920 break; 921 case BALANCE_XMIT_POLICY_LAYER23: 922 internals->balance_xmit_policy = policy; 923 internals->burst_xmit_hash = burst_xmit_l23_hash; 924 break; 925 case BALANCE_XMIT_POLICY_LAYER34: 926 internals->balance_xmit_policy = policy; 927 internals->burst_xmit_hash = burst_xmit_l34_hash; 928 break; 929 930 default: 931 return -1; 932 } 933 return 0; 934 } 935 936 int 937 rte_eth_bond_xmit_policy_get(uint16_t bonded_port_id) 938 { 939 struct bond_dev_private *internals; 940 941 if (valid_bonded_port_id(bonded_port_id) != 0) 942 return -1; 943 944 internals = rte_eth_devices[bonded_port_id].data->dev_private; 945 946 return internals->balance_xmit_policy; 947 } 948 949 int 950 rte_eth_bond_link_monitoring_set(uint16_t bonded_port_id, uint32_t internal_ms) 951 { 952 struct bond_dev_private *internals; 953 954 if (valid_bonded_port_id(bonded_port_id) != 0) 955 return -1; 956 957 internals = rte_eth_devices[bonded_port_id].data->dev_private; 958 internals->link_status_polling_interval_ms = internal_ms; 959 960 return 0; 961 } 962 963 int 964 rte_eth_bond_link_monitoring_get(uint16_t bonded_port_id) 965 { 966 struct bond_dev_private *internals; 967 968 if (valid_bonded_port_id(bonded_port_id) != 0) 969 return -1; 970 971 internals = rte_eth_devices[bonded_port_id].data->dev_private; 972 973 return internals->link_status_polling_interval_ms; 974 } 975 976 int 977 rte_eth_bond_link_down_prop_delay_set(uint16_t bonded_port_id, 978 uint32_t delay_ms) 979 980 { 981 struct bond_dev_private *internals; 982 983 if (valid_bonded_port_id(bonded_port_id) != 0) 984 return -1; 985 986 internals = rte_eth_devices[bonded_port_id].data->dev_private; 987 internals->link_down_delay_ms = delay_ms; 988 989 return 0; 990 } 991 992 int 993 rte_eth_bond_link_down_prop_delay_get(uint16_t bonded_port_id) 994 { 995 struct bond_dev_private *internals; 996 997 if (valid_bonded_port_id(bonded_port_id) != 0) 998 return -1; 999 1000 internals = rte_eth_devices[bonded_port_id].data->dev_private; 1001 1002 return internals->link_down_delay_ms; 1003 } 1004 1005 int 1006 rte_eth_bond_link_up_prop_delay_set(uint16_t bonded_port_id, uint32_t delay_ms) 1007 1008 { 1009 struct bond_dev_private *internals; 1010 1011 if (valid_bonded_port_id(bonded_port_id) != 0) 1012 return -1; 1013 1014 internals = rte_eth_devices[bonded_port_id].data->dev_private; 1015 internals->link_up_delay_ms = delay_ms; 1016 1017 return 0; 1018 } 1019 1020 int 1021 rte_eth_bond_link_up_prop_delay_get(uint16_t bonded_port_id) 1022 { 1023 struct bond_dev_private *internals; 1024 1025 if (valid_bonded_port_id(bonded_port_id) != 0) 1026 return -1; 1027 1028 internals = rte_eth_devices[bonded_port_id].data->dev_private; 1029 1030 return internals->link_up_delay_ms; 1031 } 1032