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