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 struct rte_eth_dev *bond_dev; 155 char devargs[52]; 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 bond_dev = rte_eth_dev_get_by_name(name); 173 RTE_ASSERT(bond_dev); 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 = bond_dev->data->dev_private; 182 rte_kvargs_free(internals->kvlist); 183 internals->kvlist = NULL; 184 185 return bond_dev->data->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 RTE_ETH_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 internals->rss_key_len = di->hash_key_size; 294 295 /* Inherit Rx offload capabilities from the first slave device */ 296 internals->rx_offload_capa = di->rx_offload_capa; 297 internals->rx_queue_offload_capa = di->rx_queue_offload_capa; 298 internals->flow_type_rss_offloads = di->flow_type_rss_offloads; 299 300 /* Inherit maximum Rx packet size from the first slave device */ 301 internals->candidate_max_rx_pktlen = di->max_rx_pktlen; 302 303 /* Inherit default Rx queue settings from the first slave device */ 304 memcpy(rxconf_i, &di->default_rxconf, sizeof(*rxconf_i)); 305 306 /* 307 * Turn off descriptor prefetch and writeback by default for all 308 * slave devices. Applications may tweak this setting if need be. 309 */ 310 rxconf_i->rx_thresh.pthresh = 0; 311 rxconf_i->rx_thresh.hthresh = 0; 312 rxconf_i->rx_thresh.wthresh = 0; 313 314 /* Setting this to zero should effectively enable default values */ 315 rxconf_i->rx_free_thresh = 0; 316 317 /* Disable deferred start by default for all slave devices */ 318 rxconf_i->rx_deferred_start = 0; 319 } 320 321 static void 322 eth_bond_slave_inherit_dev_info_tx_first(struct bond_dev_private *internals, 323 const struct rte_eth_dev_info *di) 324 { 325 struct rte_eth_txconf *txconf_i = &internals->default_txconf; 326 327 /* Inherit Tx offload capabilities from the first slave device */ 328 internals->tx_offload_capa = di->tx_offload_capa; 329 internals->tx_queue_offload_capa = di->tx_queue_offload_capa; 330 331 /* Inherit default Tx queue settings from the first slave device */ 332 memcpy(txconf_i, &di->default_txconf, sizeof(*txconf_i)); 333 334 /* 335 * Turn off descriptor prefetch and writeback by default for all 336 * slave devices. Applications may tweak this setting if need be. 337 */ 338 txconf_i->tx_thresh.pthresh = 0; 339 txconf_i->tx_thresh.hthresh = 0; 340 txconf_i->tx_thresh.wthresh = 0; 341 342 /* 343 * Setting these parameters to zero assumes that default 344 * values will be configured implicitly by slave devices. 345 */ 346 txconf_i->tx_free_thresh = 0; 347 txconf_i->tx_rs_thresh = 0; 348 349 /* Disable deferred start by default for all slave devices */ 350 txconf_i->tx_deferred_start = 0; 351 } 352 353 static void 354 eth_bond_slave_inherit_dev_info_rx_next(struct bond_dev_private *internals, 355 const struct rte_eth_dev_info *di) 356 { 357 struct rte_eth_rxconf *rxconf_i = &internals->default_rxconf; 358 const struct rte_eth_rxconf *rxconf = &di->default_rxconf; 359 360 internals->rx_offload_capa &= di->rx_offload_capa; 361 internals->rx_queue_offload_capa &= di->rx_queue_offload_capa; 362 internals->flow_type_rss_offloads &= di->flow_type_rss_offloads; 363 364 /* 365 * If at least one slave device suggests enabling this 366 * setting by default, enable it for all slave devices 367 * since disabling it may not be necessarily supported. 368 */ 369 if (rxconf->rx_drop_en == 1) 370 rxconf_i->rx_drop_en = 1; 371 372 /* 373 * Adding a new slave device may cause some of previously inherited 374 * offloads to be withdrawn from the internal rx_queue_offload_capa 375 * value. Thus, the new internal value of default Rx queue offloads 376 * has to be masked by rx_queue_offload_capa to make sure that only 377 * commonly supported offloads are preserved from both the previous 378 * value and the value being inherited from the new slave device. 379 */ 380 rxconf_i->offloads = (rxconf_i->offloads | rxconf->offloads) & 381 internals->rx_queue_offload_capa; 382 383 /* 384 * RETA size is GCD of all slaves RETA sizes, so, if all sizes will be 385 * the power of 2, the lower one is GCD 386 */ 387 if (internals->reta_size > di->reta_size) 388 internals->reta_size = di->reta_size; 389 if (internals->rss_key_len > di->hash_key_size) { 390 RTE_BOND_LOG(WARNING, "slave has different rss key size, " 391 "configuring rss may fail"); 392 internals->rss_key_len = di->hash_key_size; 393 } 394 395 if (!internals->max_rx_pktlen && 396 di->max_rx_pktlen < internals->candidate_max_rx_pktlen) 397 internals->candidate_max_rx_pktlen = di->max_rx_pktlen; 398 } 399 400 static void 401 eth_bond_slave_inherit_dev_info_tx_next(struct bond_dev_private *internals, 402 const struct rte_eth_dev_info *di) 403 { 404 struct rte_eth_txconf *txconf_i = &internals->default_txconf; 405 const struct rte_eth_txconf *txconf = &di->default_txconf; 406 407 internals->tx_offload_capa &= di->tx_offload_capa; 408 internals->tx_queue_offload_capa &= di->tx_queue_offload_capa; 409 410 /* 411 * Adding a new slave device may cause some of previously inherited 412 * offloads to be withdrawn from the internal tx_queue_offload_capa 413 * value. Thus, the new internal value of default Tx queue offloads 414 * has to be masked by tx_queue_offload_capa to make sure that only 415 * commonly supported offloads are preserved from both the previous 416 * value and the value being inherited from the new slave device. 417 */ 418 txconf_i->offloads = (txconf_i->offloads | txconf->offloads) & 419 internals->tx_queue_offload_capa; 420 } 421 422 static void 423 eth_bond_slave_inherit_desc_lim_first(struct rte_eth_desc_lim *bond_desc_lim, 424 const struct rte_eth_desc_lim *slave_desc_lim) 425 { 426 memcpy(bond_desc_lim, slave_desc_lim, sizeof(*bond_desc_lim)); 427 } 428 429 static int 430 eth_bond_slave_inherit_desc_lim_next(struct rte_eth_desc_lim *bond_desc_lim, 431 const struct rte_eth_desc_lim *slave_desc_lim) 432 { 433 bond_desc_lim->nb_max = RTE_MIN(bond_desc_lim->nb_max, 434 slave_desc_lim->nb_max); 435 bond_desc_lim->nb_min = RTE_MAX(bond_desc_lim->nb_min, 436 slave_desc_lim->nb_min); 437 bond_desc_lim->nb_align = RTE_MAX(bond_desc_lim->nb_align, 438 slave_desc_lim->nb_align); 439 440 if (bond_desc_lim->nb_min > bond_desc_lim->nb_max || 441 bond_desc_lim->nb_align > bond_desc_lim->nb_max) { 442 RTE_BOND_LOG(ERR, "Failed to inherit descriptor limits"); 443 return -EINVAL; 444 } 445 446 /* Treat maximum number of segments equal to 0 as unspecified */ 447 if (slave_desc_lim->nb_seg_max != 0 && 448 (bond_desc_lim->nb_seg_max == 0 || 449 slave_desc_lim->nb_seg_max < bond_desc_lim->nb_seg_max)) 450 bond_desc_lim->nb_seg_max = slave_desc_lim->nb_seg_max; 451 if (slave_desc_lim->nb_mtu_seg_max != 0 && 452 (bond_desc_lim->nb_mtu_seg_max == 0 || 453 slave_desc_lim->nb_mtu_seg_max < bond_desc_lim->nb_mtu_seg_max)) 454 bond_desc_lim->nb_mtu_seg_max = slave_desc_lim->nb_mtu_seg_max; 455 456 return 0; 457 } 458 459 static int 460 __eth_bond_slave_add_lock_free(uint16_t bonded_port_id, uint16_t slave_port_id) 461 { 462 struct rte_eth_dev *bonded_eth_dev, *slave_eth_dev; 463 struct bond_dev_private *internals; 464 struct rte_eth_link link_props; 465 struct rte_eth_dev_info dev_info; 466 int ret; 467 468 bonded_eth_dev = &rte_eth_devices[bonded_port_id]; 469 internals = bonded_eth_dev->data->dev_private; 470 471 if (valid_slave_port_id(internals, slave_port_id) != 0) 472 return -1; 473 474 slave_eth_dev = &rte_eth_devices[slave_port_id]; 475 if (slave_eth_dev->data->dev_flags & RTE_ETH_DEV_BONDED_SLAVE) { 476 RTE_BOND_LOG(ERR, "Slave device is already a slave of a bonded device"); 477 return -1; 478 } 479 480 ret = rte_eth_dev_info_get(slave_port_id, &dev_info); 481 if (ret != 0) { 482 RTE_BOND_LOG(ERR, 483 "%s: Error during getting device (port %u) info: %s\n", 484 __func__, slave_port_id, strerror(-ret)); 485 486 return ret; 487 } 488 if (dev_info.max_rx_pktlen < internals->max_rx_pktlen) { 489 RTE_BOND_LOG(ERR, "Slave (port %u) max_rx_pktlen too small", 490 slave_port_id); 491 return -1; 492 } 493 494 slave_add(internals, slave_eth_dev); 495 496 /* We need to store slaves reta_size to be able to synchronize RETA for all 497 * slave devices even if its sizes are different. 498 */ 499 internals->slaves[internals->slave_count].reta_size = dev_info.reta_size; 500 501 if (internals->slave_count < 1) { 502 /* if MAC is not user defined then use MAC of first slave add to 503 * bonded device */ 504 if (!internals->user_defined_mac) { 505 if (mac_address_set(bonded_eth_dev, 506 slave_eth_dev->data->mac_addrs)) { 507 RTE_BOND_LOG(ERR, "Failed to set MAC address"); 508 return -1; 509 } 510 } 511 512 /* Make primary slave */ 513 internals->primary_port = slave_port_id; 514 internals->current_primary_port = slave_port_id; 515 516 /* Inherit queues settings from first slave */ 517 internals->nb_rx_queues = slave_eth_dev->data->nb_rx_queues; 518 internals->nb_tx_queues = slave_eth_dev->data->nb_tx_queues; 519 520 eth_bond_slave_inherit_dev_info_rx_first(internals, &dev_info); 521 eth_bond_slave_inherit_dev_info_tx_first(internals, &dev_info); 522 523 eth_bond_slave_inherit_desc_lim_first(&internals->rx_desc_lim, 524 &dev_info.rx_desc_lim); 525 eth_bond_slave_inherit_desc_lim_first(&internals->tx_desc_lim, 526 &dev_info.tx_desc_lim); 527 } else { 528 int ret; 529 530 eth_bond_slave_inherit_dev_info_rx_next(internals, &dev_info); 531 eth_bond_slave_inherit_dev_info_tx_next(internals, &dev_info); 532 533 ret = eth_bond_slave_inherit_desc_lim_next( 534 &internals->rx_desc_lim, &dev_info.rx_desc_lim); 535 if (ret != 0) 536 return ret; 537 538 ret = eth_bond_slave_inherit_desc_lim_next( 539 &internals->tx_desc_lim, &dev_info.tx_desc_lim); 540 if (ret != 0) 541 return ret; 542 } 543 544 bonded_eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_hf &= 545 internals->flow_type_rss_offloads; 546 547 if (slave_rte_flow_prepare(internals->slave_count, internals) != 0) { 548 RTE_BOND_LOG(ERR, "Failed to prepare new slave flows: port=%d", 549 slave_port_id); 550 return -1; 551 } 552 553 /* Add additional MAC addresses to the slave */ 554 if (slave_add_mac_addresses(bonded_eth_dev, slave_port_id) != 0) { 555 RTE_BOND_LOG(ERR, "Failed to add mac address(es) to slave %hu", 556 slave_port_id); 557 return -1; 558 } 559 560 internals->slave_count++; 561 562 if (bonded_eth_dev->data->dev_started) { 563 if (slave_configure(bonded_eth_dev, slave_eth_dev) != 0) { 564 internals->slave_count--; 565 RTE_BOND_LOG(ERR, "rte_bond_slaves_configure: port=%d", 566 slave_port_id); 567 return -1; 568 } 569 if (slave_start(bonded_eth_dev, slave_eth_dev) != 0) { 570 internals->slave_count--; 571 RTE_BOND_LOG(ERR, "rte_bond_slaves_start: port=%d", 572 slave_port_id); 573 return -1; 574 } 575 } 576 577 /* Update all slave devices MACs */ 578 mac_address_slaves_update(bonded_eth_dev); 579 580 /* Register link status change callback with bonded device pointer as 581 * argument*/ 582 rte_eth_dev_callback_register(slave_port_id, RTE_ETH_EVENT_INTR_LSC, 583 bond_ethdev_lsc_event_callback, &bonded_eth_dev->data->port_id); 584 585 /* If bonded device is started then we can add the slave to our active 586 * slave array */ 587 if (bonded_eth_dev->data->dev_started) { 588 ret = rte_eth_link_get_nowait(slave_port_id, &link_props); 589 if (ret < 0) { 590 rte_eth_dev_callback_unregister(slave_port_id, 591 RTE_ETH_EVENT_INTR_LSC, 592 bond_ethdev_lsc_event_callback, 593 &bonded_eth_dev->data->port_id); 594 internals->slave_count--; 595 RTE_BOND_LOG(ERR, 596 "Slave (port %u) link get failed: %s\n", 597 slave_port_id, rte_strerror(-ret)); 598 return -1; 599 } 600 601 if (link_props.link_status == RTE_ETH_LINK_UP) { 602 if (internals->active_slave_count == 0 && 603 !internals->user_defined_primary_port) 604 bond_ethdev_primary_set(internals, 605 slave_port_id); 606 } 607 } 608 609 /* Add slave details to bonded device */ 610 slave_eth_dev->data->dev_flags |= RTE_ETH_DEV_BONDED_SLAVE; 611 612 slave_vlan_filter_set(bonded_port_id, slave_port_id); 613 614 return 0; 615 616 } 617 618 int 619 rte_eth_bond_slave_add(uint16_t bonded_port_id, uint16_t slave_port_id) 620 { 621 struct rte_eth_dev *bonded_eth_dev; 622 struct bond_dev_private *internals; 623 624 int retval; 625 626 if (valid_bonded_port_id(bonded_port_id) != 0) 627 return -1; 628 629 bonded_eth_dev = &rte_eth_devices[bonded_port_id]; 630 internals = bonded_eth_dev->data->dev_private; 631 632 if (valid_slave_port_id(internals, slave_port_id) != 0) 633 return -1; 634 635 rte_spinlock_lock(&internals->lock); 636 637 retval = __eth_bond_slave_add_lock_free(bonded_port_id, slave_port_id); 638 639 rte_spinlock_unlock(&internals->lock); 640 641 return retval; 642 } 643 644 static int 645 __eth_bond_slave_remove_lock_free(uint16_t bonded_port_id, 646 uint16_t slave_port_id) 647 { 648 struct rte_eth_dev *bonded_eth_dev; 649 struct bond_dev_private *internals; 650 struct rte_eth_dev *slave_eth_dev; 651 struct rte_flow_error flow_error; 652 struct rte_flow *flow; 653 int i, slave_idx; 654 655 bonded_eth_dev = &rte_eth_devices[bonded_port_id]; 656 internals = bonded_eth_dev->data->dev_private; 657 658 if (valid_slave_port_id(internals, slave_port_id) < 0) 659 return -1; 660 661 /* first remove from active slave list */ 662 slave_idx = find_slave_by_id(internals->active_slaves, 663 internals->active_slave_count, slave_port_id); 664 665 if (slave_idx < internals->active_slave_count) 666 deactivate_slave(bonded_eth_dev, slave_port_id); 667 668 slave_idx = -1; 669 /* now find in slave list */ 670 for (i = 0; i < internals->slave_count; i++) 671 if (internals->slaves[i].port_id == slave_port_id) { 672 slave_idx = i; 673 break; 674 } 675 676 if (slave_idx < 0) { 677 RTE_BOND_LOG(ERR, "Couldn't find slave in port list, slave count %u", 678 internals->slave_count); 679 return -1; 680 } 681 682 /* Un-register link status change callback with bonded device pointer as 683 * argument*/ 684 rte_eth_dev_callback_unregister(slave_port_id, RTE_ETH_EVENT_INTR_LSC, 685 bond_ethdev_lsc_event_callback, 686 &rte_eth_devices[bonded_port_id].data->port_id); 687 688 /* Restore original MAC address of slave device */ 689 rte_eth_dev_default_mac_addr_set(slave_port_id, 690 &(internals->slaves[slave_idx].persisted_mac_addr)); 691 692 /* remove additional MAC addresses from the slave */ 693 slave_remove_mac_addresses(bonded_eth_dev, slave_port_id); 694 695 /* 696 * Remove bond device flows from slave device. 697 * Note: don't restore flow isolate mode. 698 */ 699 TAILQ_FOREACH(flow, &internals->flow_list, next) { 700 if (flow->flows[slave_idx] != NULL) { 701 rte_flow_destroy(slave_port_id, flow->flows[slave_idx], 702 &flow_error); 703 flow->flows[slave_idx] = NULL; 704 } 705 } 706 707 slave_eth_dev = &rte_eth_devices[slave_port_id]; 708 slave_remove(internals, slave_eth_dev); 709 slave_eth_dev->data->dev_flags &= (~RTE_ETH_DEV_BONDED_SLAVE); 710 711 /* first slave in the active list will be the primary by default, 712 * otherwise use first device in list */ 713 if (internals->current_primary_port == slave_port_id) { 714 if (internals->active_slave_count > 0) 715 internals->current_primary_port = internals->active_slaves[0]; 716 else if (internals->slave_count > 0) 717 internals->current_primary_port = internals->slaves[0].port_id; 718 else 719 internals->primary_port = 0; 720 mac_address_slaves_update(bonded_eth_dev); 721 } 722 723 if (internals->active_slave_count < 1) { 724 /* if no slaves are any longer attached to bonded device and MAC is not 725 * user defined then clear MAC of bonded device as it will be reset 726 * when a new slave is added */ 727 if (internals->slave_count < 1 && !internals->user_defined_mac) 728 memset(rte_eth_devices[bonded_port_id].data->mac_addrs, 0, 729 sizeof(*(rte_eth_devices[bonded_port_id].data->mac_addrs))); 730 } 731 if (internals->slave_count == 0) { 732 internals->rx_offload_capa = 0; 733 internals->tx_offload_capa = 0; 734 internals->rx_queue_offload_capa = 0; 735 internals->tx_queue_offload_capa = 0; 736 internals->flow_type_rss_offloads = RTE_ETH_RSS_PROTO_MASK; 737 internals->reta_size = 0; 738 internals->candidate_max_rx_pktlen = 0; 739 internals->max_rx_pktlen = 0; 740 } 741 return 0; 742 } 743 744 int 745 rte_eth_bond_slave_remove(uint16_t bonded_port_id, uint16_t slave_port_id) 746 { 747 struct rte_eth_dev *bonded_eth_dev; 748 struct bond_dev_private *internals; 749 int retval; 750 751 if (valid_bonded_port_id(bonded_port_id) != 0) 752 return -1; 753 754 bonded_eth_dev = &rte_eth_devices[bonded_port_id]; 755 internals = bonded_eth_dev->data->dev_private; 756 757 rte_spinlock_lock(&internals->lock); 758 759 retval = __eth_bond_slave_remove_lock_free(bonded_port_id, slave_port_id); 760 761 rte_spinlock_unlock(&internals->lock); 762 763 return retval; 764 } 765 766 int 767 rte_eth_bond_mode_set(uint16_t bonded_port_id, uint8_t mode) 768 { 769 struct rte_eth_dev *bonded_eth_dev; 770 771 if (valid_bonded_port_id(bonded_port_id) != 0) 772 return -1; 773 774 bonded_eth_dev = &rte_eth_devices[bonded_port_id]; 775 776 if (check_for_master_bonded_ethdev(bonded_eth_dev) != 0 && 777 mode == BONDING_MODE_8023AD) 778 return -1; 779 780 return bond_ethdev_mode_set(bonded_eth_dev, mode); 781 } 782 783 int 784 rte_eth_bond_mode_get(uint16_t bonded_port_id) 785 { 786 struct bond_dev_private *internals; 787 788 if (valid_bonded_port_id(bonded_port_id) != 0) 789 return -1; 790 791 internals = rte_eth_devices[bonded_port_id].data->dev_private; 792 793 return internals->mode; 794 } 795 796 int 797 rte_eth_bond_primary_set(uint16_t bonded_port_id, uint16_t slave_port_id) 798 { 799 struct bond_dev_private *internals; 800 801 if (valid_bonded_port_id(bonded_port_id) != 0) 802 return -1; 803 804 internals = rte_eth_devices[bonded_port_id].data->dev_private; 805 806 if (valid_slave_port_id(internals, slave_port_id) != 0) 807 return -1; 808 809 internals->user_defined_primary_port = 1; 810 internals->primary_port = slave_port_id; 811 812 bond_ethdev_primary_set(internals, slave_port_id); 813 814 return 0; 815 } 816 817 int 818 rte_eth_bond_primary_get(uint16_t bonded_port_id) 819 { 820 struct bond_dev_private *internals; 821 822 if (valid_bonded_port_id(bonded_port_id) != 0) 823 return -1; 824 825 internals = rte_eth_devices[bonded_port_id].data->dev_private; 826 827 if (internals->slave_count < 1) 828 return -1; 829 830 return internals->current_primary_port; 831 } 832 833 int 834 rte_eth_bond_slaves_get(uint16_t bonded_port_id, uint16_t slaves[], 835 uint16_t len) 836 { 837 struct bond_dev_private *internals; 838 uint16_t i; 839 840 if (valid_bonded_port_id(bonded_port_id) != 0) 841 return -1; 842 843 if (slaves == NULL) 844 return -1; 845 846 internals = rte_eth_devices[bonded_port_id].data->dev_private; 847 848 if (internals->slave_count > len) 849 return -1; 850 851 for (i = 0; i < internals->slave_count; i++) 852 slaves[i] = internals->slaves[i].port_id; 853 854 return internals->slave_count; 855 } 856 857 int 858 rte_eth_bond_active_slaves_get(uint16_t bonded_port_id, uint16_t slaves[], 859 uint16_t len) 860 { 861 struct bond_dev_private *internals; 862 863 if (valid_bonded_port_id(bonded_port_id) != 0) 864 return -1; 865 866 if (slaves == NULL) 867 return -1; 868 869 internals = rte_eth_devices[bonded_port_id].data->dev_private; 870 871 if (internals->active_slave_count > len) 872 return -1; 873 874 memcpy(slaves, internals->active_slaves, 875 internals->active_slave_count * sizeof(internals->active_slaves[0])); 876 877 return internals->active_slave_count; 878 } 879 880 int 881 rte_eth_bond_mac_address_set(uint16_t bonded_port_id, 882 struct rte_ether_addr *mac_addr) 883 { 884 struct rte_eth_dev *bonded_eth_dev; 885 struct bond_dev_private *internals; 886 887 if (valid_bonded_port_id(bonded_port_id) != 0) 888 return -1; 889 890 bonded_eth_dev = &rte_eth_devices[bonded_port_id]; 891 internals = bonded_eth_dev->data->dev_private; 892 893 /* Set MAC Address of Bonded Device */ 894 if (mac_address_set(bonded_eth_dev, mac_addr)) 895 return -1; 896 897 internals->user_defined_mac = 1; 898 899 /* Update all slave devices MACs*/ 900 if (internals->slave_count > 0) 901 return mac_address_slaves_update(bonded_eth_dev); 902 903 return 0; 904 } 905 906 int 907 rte_eth_bond_mac_address_reset(uint16_t bonded_port_id) 908 { 909 struct rte_eth_dev *bonded_eth_dev; 910 struct bond_dev_private *internals; 911 912 if (valid_bonded_port_id(bonded_port_id) != 0) 913 return -1; 914 915 bonded_eth_dev = &rte_eth_devices[bonded_port_id]; 916 internals = bonded_eth_dev->data->dev_private; 917 918 internals->user_defined_mac = 0; 919 920 if (internals->slave_count > 0) { 921 int slave_port; 922 /* Get the primary slave location based on the primary port 923 * number as, while slave_add(), we will keep the primary 924 * slave based on slave_count,but not based on the primary port. 925 */ 926 for (slave_port = 0; slave_port < internals->slave_count; 927 slave_port++) { 928 if (internals->slaves[slave_port].port_id == 929 internals->primary_port) 930 break; 931 } 932 933 /* Set MAC Address of Bonded Device */ 934 if (mac_address_set(bonded_eth_dev, 935 &internals->slaves[slave_port].persisted_mac_addr) 936 != 0) { 937 RTE_BOND_LOG(ERR, "Failed to set MAC address on bonded device"); 938 return -1; 939 } 940 /* Update all slave devices MAC addresses */ 941 return mac_address_slaves_update(bonded_eth_dev); 942 } 943 /* No need to update anything as no slaves present */ 944 return 0; 945 } 946 947 int 948 rte_eth_bond_xmit_policy_set(uint16_t bonded_port_id, uint8_t policy) 949 { 950 struct bond_dev_private *internals; 951 952 if (valid_bonded_port_id(bonded_port_id) != 0) 953 return -1; 954 955 internals = rte_eth_devices[bonded_port_id].data->dev_private; 956 957 switch (policy) { 958 case BALANCE_XMIT_POLICY_LAYER2: 959 internals->balance_xmit_policy = policy; 960 internals->burst_xmit_hash = burst_xmit_l2_hash; 961 break; 962 case BALANCE_XMIT_POLICY_LAYER23: 963 internals->balance_xmit_policy = policy; 964 internals->burst_xmit_hash = burst_xmit_l23_hash; 965 break; 966 case BALANCE_XMIT_POLICY_LAYER34: 967 internals->balance_xmit_policy = policy; 968 internals->burst_xmit_hash = burst_xmit_l34_hash; 969 break; 970 971 default: 972 return -1; 973 } 974 return 0; 975 } 976 977 int 978 rte_eth_bond_xmit_policy_get(uint16_t bonded_port_id) 979 { 980 struct bond_dev_private *internals; 981 982 if (valid_bonded_port_id(bonded_port_id) != 0) 983 return -1; 984 985 internals = rte_eth_devices[bonded_port_id].data->dev_private; 986 987 return internals->balance_xmit_policy; 988 } 989 990 int 991 rte_eth_bond_link_monitoring_set(uint16_t bonded_port_id, uint32_t internal_ms) 992 { 993 struct bond_dev_private *internals; 994 995 if (valid_bonded_port_id(bonded_port_id) != 0) 996 return -1; 997 998 internals = rte_eth_devices[bonded_port_id].data->dev_private; 999 internals->link_status_polling_interval_ms = internal_ms; 1000 1001 return 0; 1002 } 1003 1004 int 1005 rte_eth_bond_link_monitoring_get(uint16_t bonded_port_id) 1006 { 1007 struct bond_dev_private *internals; 1008 1009 if (valid_bonded_port_id(bonded_port_id) != 0) 1010 return -1; 1011 1012 internals = rte_eth_devices[bonded_port_id].data->dev_private; 1013 1014 return internals->link_status_polling_interval_ms; 1015 } 1016 1017 int 1018 rte_eth_bond_link_down_prop_delay_set(uint16_t bonded_port_id, 1019 uint32_t delay_ms) 1020 1021 { 1022 struct bond_dev_private *internals; 1023 1024 if (valid_bonded_port_id(bonded_port_id) != 0) 1025 return -1; 1026 1027 internals = rte_eth_devices[bonded_port_id].data->dev_private; 1028 internals->link_down_delay_ms = delay_ms; 1029 1030 return 0; 1031 } 1032 1033 int 1034 rte_eth_bond_link_down_prop_delay_get(uint16_t bonded_port_id) 1035 { 1036 struct bond_dev_private *internals; 1037 1038 if (valid_bonded_port_id(bonded_port_id) != 0) 1039 return -1; 1040 1041 internals = rte_eth_devices[bonded_port_id].data->dev_private; 1042 1043 return internals->link_down_delay_ms; 1044 } 1045 1046 int 1047 rte_eth_bond_link_up_prop_delay_set(uint16_t bonded_port_id, uint32_t delay_ms) 1048 1049 { 1050 struct bond_dev_private *internals; 1051 1052 if (valid_bonded_port_id(bonded_port_id) != 0) 1053 return -1; 1054 1055 internals = rte_eth_devices[bonded_port_id].data->dev_private; 1056 internals->link_up_delay_ms = delay_ms; 1057 1058 return 0; 1059 } 1060 1061 int 1062 rte_eth_bond_link_up_prop_delay_get(uint16_t bonded_port_id) 1063 { 1064 struct bond_dev_private *internals; 1065 1066 if (valid_bonded_port_id(bonded_port_id) != 0) 1067 return -1; 1068 1069 internals = rte_eth_devices[bonded_port_id].data->dev_private; 1070 1071 return internals->link_up_delay_ms; 1072 } 1073