1 /*- 2 * BSD LICENSE 3 * 4 * Copyright(c) 2010-2014 Intel Corporation. All rights reserved. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name of Intel Corporation nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include "unistd.h" 35 #include <string.h> 36 #include <stdarg.h> 37 #include <stdio.h> 38 #include <stdlib.h> 39 #include <stdint.h> 40 #include <inttypes.h> 41 #include <errno.h> 42 #include <sys/queue.h> 43 #include <sys/time.h> 44 #include <rte_cycles.h> 45 #include <rte_byteorder.h> 46 #include <rte_common.h> 47 #include <rte_debug.h> 48 #include <rte_ethdev.h> 49 #include <rte_log.h> 50 #include <rte_lcore.h> 51 #include <rte_memory.h> 52 #include <rte_string_fns.h> 53 #include <rte_eth_bond.h> 54 55 #include "virtual_pmd.h" 56 #include "packet_burst_generator.h" 57 58 #include "test.h" 59 60 #define TEST_MAX_NUMBER_OF_PORTS (6) 61 62 #define RX_RING_SIZE 128 63 #define RX_FREE_THRESH 32 64 #define RX_PTHRESH 8 65 #define RX_HTHRESH 8 66 #define RX_WTHRESH 0 67 68 #define TX_RING_SIZE 512 69 #define TX_FREE_THRESH 32 70 #define TX_PTHRESH 32 71 #define TX_HTHRESH 0 72 #define TX_WTHRESH 0 73 #define TX_RSBIT_THRESH 32 74 #define TX_Q_FLAGS (ETH_TXQ_FLAGS_NOMULTSEGS | ETH_TXQ_FLAGS_NOVLANOFFL |\ 75 ETH_TXQ_FLAGS_NOXSUMSCTP | ETH_TXQ_FLAGS_NOXSUMUDP | \ 76 ETH_TXQ_FLAGS_NOXSUMTCP) 77 78 #define MBUF_CACHE_SIZE (250) 79 #define BURST_SIZE (32) 80 81 #define RTE_TEST_RX_DESC_MAX (2048) 82 #define RTE_TEST_TX_DESC_MAX (2048) 83 #define MAX_PKT_BURST (512) 84 #define DEF_PKT_BURST (16) 85 86 #define BONDED_DEV_NAME ("unit_test_bond_dev") 87 88 #define INVALID_SOCKET_ID (-1) 89 #define INVALID_PORT_ID (-1) 90 #define INVALID_BONDING_MODE (-1) 91 92 93 uint8_t slave_mac[] = {0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00 }; 94 uint8_t bonded_mac[] = {0xAA, 0xFF, 0xAA, 0xFF, 0xAA, 0xFF }; 95 96 struct link_bonding_unittest_params { 97 int8_t bonded_port_id; 98 int8_t slave_port_ids[TEST_MAX_NUMBER_OF_PORTS]; 99 uint8_t bonded_slave_count; 100 uint8_t bonding_mode; 101 102 uint16_t nb_rx_q; 103 uint16_t nb_tx_q; 104 105 struct rte_mempool *mbuf_pool; 106 107 struct ether_addr *default_slave_mac; 108 struct ether_addr *default_bonded_mac; 109 110 /* Packet Headers */ 111 struct ether_hdr *pkt_eth_hdr; 112 struct ipv4_hdr *pkt_ipv4_hdr; 113 struct ipv6_hdr *pkt_ipv6_hdr; 114 struct udp_hdr *pkt_udp_hdr; 115 116 }; 117 118 static struct ipv4_hdr pkt_ipv4_hdr; 119 static struct ipv6_hdr pkt_ipv6_hdr; 120 static struct udp_hdr pkt_udp_hdr; 121 122 static struct link_bonding_unittest_params default_params = { 123 .bonded_port_id = -1, 124 .slave_port_ids = { -1 }, 125 .bonded_slave_count = 0, 126 .bonding_mode = BONDING_MODE_ROUND_ROBIN, 127 128 .nb_rx_q = 1, 129 .nb_tx_q = 1, 130 131 .mbuf_pool = NULL, 132 133 .default_slave_mac = (struct ether_addr *)slave_mac, 134 .default_bonded_mac = (struct ether_addr *)bonded_mac, 135 136 .pkt_eth_hdr = NULL, 137 .pkt_ipv4_hdr = &pkt_ipv4_hdr, 138 .pkt_ipv6_hdr = &pkt_ipv6_hdr, 139 .pkt_udp_hdr = &pkt_udp_hdr 140 141 }; 142 143 static struct link_bonding_unittest_params *test_params = &default_params; 144 145 static uint8_t src_mac[] = { 0xFF, 0xAA, 0xFF, 0xAA, 0xFF, 0xAA }; 146 static uint8_t dst_mac_0[] = { 0xFF, 0xAA, 0xFF, 0xAA, 0xFF, 0xAA }; 147 static uint8_t dst_mac_1[] = { 0xFF, 0xAA, 0xFF, 0xAA, 0xFF, 0xAB }; 148 149 static uint32_t src_addr = IPV4_ADDR(192, 168, 1, 98); 150 static uint32_t dst_addr_0 = IPV4_ADDR(192, 168, 1, 98); 151 static uint32_t dst_addr_1 = IPV4_ADDR(193, 166, 10, 97); 152 153 static uint8_t src_ipv6_addr[] = { 0xFF, 0xAA, 0xFF, 0xAA, 0xFF, 0xAA, 0xFF, 154 0xAA, 0xFF, 0xAA, 0xFF, 0xAA, 0xFF, 0xAA , 0xFF, 0xAA }; 155 static uint8_t dst_ipv6_addr_0[] = { 0xFF, 0xAA, 0xFF, 0xAA, 0xFF, 0xAA, 0xFF, 156 0xAA, 0xFF, 0xAA, 0xFF, 0xAA , 0xFF, 0xAA, 0xFF, 0xAA }; 157 static uint8_t dst_ipv6_addr_1[] = { 0xFF, 0xAA, 0xFF, 0xAA, 0xFF, 0xAA, 0xFF, 158 0xAA, 0xFF, 0xAA, 0xFF, 0xAA , 0xFF, 0xAA , 0xFF, 0xAB }; 159 160 static uint16_t src_port = 1024; 161 static uint16_t dst_port_0 = 1024; 162 static uint16_t dst_port_1 = 2024; 163 164 static uint16_t vlan_id = 0x100; 165 166 struct rte_eth_rxmode rx_mode = { 167 .max_rx_pkt_len = ETHER_MAX_LEN, /**< Default maximum frame length. */ 168 .split_hdr_size = 0, 169 .header_split = 0, /**< Header Split disabled. */ 170 .hw_ip_checksum = 0, /**< IP checksum offload disabled. */ 171 .hw_vlan_filter = 1, /**< VLAN filtering enabled. */ 172 .hw_vlan_strip = 1, /**< VLAN strip enabled. */ 173 .hw_vlan_extend = 0, /**< Extended VLAN disabled. */ 174 .jumbo_frame = 0, /**< Jumbo Frame Support disabled. */ 175 .hw_strip_crc = 0, /**< CRC stripping by hardware disabled. */ 176 }; 177 178 struct rte_fdir_conf fdir_conf = { 179 .mode = RTE_FDIR_MODE_NONE, 180 .pballoc = RTE_FDIR_PBALLOC_64K, 181 .status = RTE_FDIR_REPORT_STATUS, 182 .drop_queue = 127, 183 }; 184 185 static struct rte_eth_conf default_pmd_conf = { 186 .rxmode = { 187 .mq_mode = ETH_MQ_RX_NONE, 188 .max_rx_pkt_len = ETHER_MAX_LEN, 189 .split_hdr_size = 0, 190 .header_split = 0, /**< Header Split disabled */ 191 .hw_ip_checksum = 0, /**< IP checksum offload enabled */ 192 .hw_vlan_filter = 0, /**< VLAN filtering disabled */ 193 .jumbo_frame = 0, /**< Jumbo Frame Support disabled */ 194 .hw_strip_crc = 0, /**< CRC stripped by hardware */ 195 }, 196 .txmode = { 197 .mq_mode = ETH_MQ_TX_NONE, 198 }, 199 .lpbk_mode = 0, 200 }; 201 202 static const struct rte_eth_rxconf rx_conf_default = { 203 .rx_thresh = { 204 .pthresh = RX_PTHRESH, 205 .hthresh = RX_HTHRESH, 206 .wthresh = RX_WTHRESH, 207 }, 208 .rx_free_thresh = RX_FREE_THRESH, 209 .rx_drop_en = 0, 210 }; 211 212 static struct rte_eth_txconf tx_conf_default = { 213 .tx_thresh = { 214 .pthresh = TX_PTHRESH, 215 .hthresh = TX_HTHRESH, 216 .wthresh = TX_WTHRESH, 217 }, 218 .tx_free_thresh = TX_FREE_THRESH, 219 .tx_rs_thresh = TX_RSBIT_THRESH, 220 .txq_flags = TX_Q_FLAGS 221 222 }; 223 224 static int 225 configure_ethdev(uint8_t port_id, uint8_t start, uint8_t en_isr) 226 { 227 int q_id; 228 229 if (en_isr) 230 default_pmd_conf.intr_conf.lsc = 1; 231 else 232 default_pmd_conf.intr_conf.lsc = 0; 233 234 TEST_ASSERT_SUCCESS(rte_eth_dev_configure(port_id, test_params->nb_rx_q, 235 test_params->nb_tx_q, &default_pmd_conf), 236 "rte_eth_dev_configure for port %d failed", port_id); 237 238 for (q_id = 0; q_id < test_params->nb_rx_q; q_id++) 239 TEST_ASSERT_SUCCESS(rte_eth_rx_queue_setup(port_id, q_id, RX_RING_SIZE, 240 rte_eth_dev_socket_id(port_id), &rx_conf_default, 241 test_params->mbuf_pool) , 242 "rte_eth_rx_queue_setup for port %d failed", port_id); 243 244 for (q_id = 0; q_id < test_params->nb_tx_q; q_id++) 245 TEST_ASSERT_SUCCESS(rte_eth_tx_queue_setup(port_id, q_id, TX_RING_SIZE, 246 rte_eth_dev_socket_id(port_id), &tx_conf_default), 247 "rte_eth_tx_queue_setup for port %d failed", port_id); 248 249 if (start) 250 TEST_ASSERT_SUCCESS(rte_eth_dev_start(port_id), 251 "rte_eth_dev_start for port %d failed", port_id); 252 253 return 0; 254 } 255 256 static int slaves_initialized; 257 258 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; 259 static pthread_cond_t cvar = PTHREAD_COND_INITIALIZER; 260 261 262 static int 263 test_setup(void) 264 { 265 int i, nb_mbuf_per_pool; 266 struct ether_addr *mac_addr = (struct ether_addr *)slave_mac; 267 268 /* Allocate ethernet packet header with space for VLAN header */ 269 if (test_params->pkt_eth_hdr == NULL) { 270 test_params->pkt_eth_hdr = malloc(sizeof(struct ether_hdr) + 271 sizeof(struct vlan_hdr)); 272 273 TEST_ASSERT_NOT_NULL(test_params->pkt_eth_hdr, 274 "Ethernet header struct allocation failed!"); 275 } 276 277 nb_mbuf_per_pool = RTE_TEST_RX_DESC_MAX + DEF_PKT_BURST + 278 RTE_TEST_TX_DESC_MAX + MAX_PKT_BURST; 279 if (test_params->mbuf_pool == NULL) { 280 test_params->mbuf_pool = rte_pktmbuf_pool_create("MBUF_POOL", 281 nb_mbuf_per_pool, MBUF_CACHE_SIZE, 0, 282 RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id()); 283 TEST_ASSERT_NOT_NULL(test_params->mbuf_pool, 284 "rte_mempool_create failed"); 285 } 286 287 /* Create / Initialize virtual eth devs */ 288 if (!slaves_initialized) { 289 for (i = 0; i < TEST_MAX_NUMBER_OF_PORTS; i++) { 290 char pmd_name[RTE_ETH_NAME_MAX_LEN]; 291 292 mac_addr->addr_bytes[ETHER_ADDR_LEN-1] = i; 293 294 snprintf(pmd_name, RTE_ETH_NAME_MAX_LEN, "eth_virt_%d", i); 295 296 test_params->slave_port_ids[i] = virtual_ethdev_create(pmd_name, 297 mac_addr, rte_socket_id(), 1); 298 TEST_ASSERT(test_params->slave_port_ids[i] >= 0, 299 "Failed to create virtual virtual ethdev %s", pmd_name); 300 301 TEST_ASSERT_SUCCESS(configure_ethdev( 302 test_params->slave_port_ids[i], 1, 0), 303 "Failed to configure virtual ethdev %s", pmd_name); 304 } 305 slaves_initialized = 1; 306 } 307 308 return 0; 309 } 310 311 static int 312 test_create_bonded_device(void) 313 { 314 int current_slave_count; 315 316 uint8_t slaves[RTE_MAX_ETHPORTS]; 317 318 /* Don't try to recreate bonded device if re-running test suite*/ 319 if (test_params->bonded_port_id == -1) { 320 test_params->bonded_port_id = rte_eth_bond_create(BONDED_DEV_NAME, 321 test_params->bonding_mode, rte_socket_id()); 322 323 TEST_ASSERT(test_params->bonded_port_id >= 0, 324 "Failed to create bonded ethdev %s", BONDED_DEV_NAME); 325 326 TEST_ASSERT_SUCCESS(configure_ethdev(test_params->bonded_port_id, 0, 0), 327 "Failed to configure bonded ethdev %s", BONDED_DEV_NAME); 328 } 329 330 TEST_ASSERT_SUCCESS(rte_eth_bond_mode_set(test_params->bonded_port_id, 331 test_params->bonding_mode), "Failed to set ethdev %d to mode %d", 332 test_params->bonded_port_id, test_params->bonding_mode); 333 334 current_slave_count = rte_eth_bond_slaves_get(test_params->bonded_port_id, 335 slaves, RTE_MAX_ETHPORTS); 336 337 TEST_ASSERT_EQUAL(current_slave_count, 0, 338 "Number of slaves %d is great than expected %d.", 339 current_slave_count, 0); 340 341 current_slave_count = rte_eth_bond_active_slaves_get( 342 test_params->bonded_port_id, slaves, RTE_MAX_ETHPORTS); 343 344 TEST_ASSERT_EQUAL(current_slave_count, 0, 345 "Number of active slaves %d is great than expected %d.", 346 current_slave_count, 0); 347 348 return 0; 349 } 350 351 352 static int 353 test_create_bonded_device_with_invalid_params(void) 354 { 355 int port_id; 356 357 test_params->bonding_mode = BONDING_MODE_ROUND_ROBIN; 358 359 /* Invalid name */ 360 port_id = rte_eth_bond_create(NULL, test_params->bonding_mode, 361 rte_socket_id()); 362 TEST_ASSERT(port_id < 0, "Created bonded device unexpectedly"); 363 364 test_params->bonding_mode = INVALID_BONDING_MODE; 365 366 /* Invalid bonding mode */ 367 port_id = rte_eth_bond_create(BONDED_DEV_NAME, test_params->bonding_mode, 368 rte_socket_id()); 369 TEST_ASSERT(port_id < 0, "Created bonded device unexpectedly."); 370 371 test_params->bonding_mode = BONDING_MODE_ROUND_ROBIN; 372 373 /* Invalid socket id */ 374 port_id = rte_eth_bond_create(BONDED_DEV_NAME, test_params->bonding_mode, 375 INVALID_SOCKET_ID); 376 TEST_ASSERT(port_id < 0, "Created bonded device unexpectedly."); 377 378 return 0; 379 } 380 381 static int 382 test_add_slave_to_bonded_device(void) 383 { 384 int current_slave_count; 385 386 uint8_t slaves[RTE_MAX_ETHPORTS]; 387 388 TEST_ASSERT_SUCCESS(rte_eth_bond_slave_add(test_params->bonded_port_id, 389 test_params->slave_port_ids[test_params->bonded_slave_count]), 390 "Failed to add slave (%d) to bonded port (%d).", 391 test_params->slave_port_ids[test_params->bonded_slave_count], 392 test_params->bonded_port_id); 393 394 current_slave_count = rte_eth_bond_slaves_get(test_params->bonded_port_id, 395 slaves, RTE_MAX_ETHPORTS); 396 TEST_ASSERT_EQUAL(current_slave_count, test_params->bonded_slave_count + 1, 397 "Number of slaves (%d) is greater than expected (%d).", 398 current_slave_count, test_params->bonded_slave_count + 1); 399 400 current_slave_count = rte_eth_bond_active_slaves_get( 401 test_params->bonded_port_id, slaves, RTE_MAX_ETHPORTS); 402 TEST_ASSERT_EQUAL(current_slave_count, 0, 403 "Number of active slaves (%d) is not as expected (%d).\n", 404 current_slave_count, 0); 405 406 test_params->bonded_slave_count++; 407 408 return 0; 409 } 410 411 static int 412 test_add_slave_to_invalid_bonded_device(void) 413 { 414 /* Invalid port ID */ 415 TEST_ASSERT_FAIL(rte_eth_bond_slave_add(test_params->bonded_port_id + 5, 416 test_params->slave_port_ids[test_params->bonded_slave_count]), 417 "Expected call to failed as invalid port specified."); 418 419 /* Non bonded device */ 420 TEST_ASSERT_FAIL(rte_eth_bond_slave_add(test_params->slave_port_ids[0], 421 test_params->slave_port_ids[test_params->bonded_slave_count]), 422 "Expected call to failed as invalid port specified."); 423 424 return 0; 425 } 426 427 428 static int 429 test_remove_slave_from_bonded_device(void) 430 { 431 int current_slave_count; 432 struct ether_addr read_mac_addr, *mac_addr; 433 uint8_t slaves[RTE_MAX_ETHPORTS]; 434 435 TEST_ASSERT_SUCCESS(rte_eth_bond_slave_remove(test_params->bonded_port_id, 436 test_params->slave_port_ids[test_params->bonded_slave_count-1]), 437 "Failed to remove slave %d from bonded port (%d).", 438 test_params->slave_port_ids[test_params->bonded_slave_count-1], 439 test_params->bonded_port_id); 440 441 442 current_slave_count = rte_eth_bond_slaves_get(test_params->bonded_port_id, 443 slaves, RTE_MAX_ETHPORTS); 444 445 TEST_ASSERT_EQUAL(current_slave_count, test_params->bonded_slave_count - 1, 446 "Number of slaves (%d) is great than expected (%d).\n", 447 current_slave_count, test_params->bonded_slave_count - 1); 448 449 450 mac_addr = (struct ether_addr *)slave_mac; 451 mac_addr->addr_bytes[ETHER_ADDR_LEN-1] = 452 test_params->bonded_slave_count-1; 453 454 rte_eth_macaddr_get( 455 test_params->slave_port_ids[test_params->bonded_slave_count-1], 456 &read_mac_addr); 457 TEST_ASSERT_SUCCESS(memcmp(mac_addr, &read_mac_addr, sizeof(read_mac_addr)), 458 "bonded port mac address not set to that of primary port\n"); 459 460 rte_eth_stats_reset( 461 test_params->slave_port_ids[test_params->bonded_slave_count-1]); 462 463 virtual_ethdev_simulate_link_status_interrupt(test_params->bonded_port_id, 464 0); 465 466 test_params->bonded_slave_count--; 467 468 return 0; 469 } 470 471 static int 472 test_remove_slave_from_invalid_bonded_device(void) 473 { 474 /* Invalid port ID */ 475 TEST_ASSERT_FAIL(rte_eth_bond_slave_remove( 476 test_params->bonded_port_id + 5, 477 test_params->slave_port_ids[test_params->bonded_slave_count - 1]), 478 "Expected call to failed as invalid port specified."); 479 480 /* Non bonded device */ 481 TEST_ASSERT_FAIL(rte_eth_bond_slave_remove( 482 test_params->slave_port_ids[0], 483 test_params->slave_port_ids[test_params->bonded_slave_count - 1]), 484 "Expected call to failed as invalid port specified."); 485 486 return 0; 487 } 488 489 static int bonded_id = 2; 490 491 static int 492 test_add_already_bonded_slave_to_bonded_device(void) 493 { 494 int port_id, current_slave_count; 495 uint8_t slaves[RTE_MAX_ETHPORTS]; 496 char pmd_name[RTE_ETH_NAME_MAX_LEN]; 497 498 test_add_slave_to_bonded_device(); 499 500 current_slave_count = rte_eth_bond_slaves_get(test_params->bonded_port_id, 501 slaves, RTE_MAX_ETHPORTS); 502 TEST_ASSERT_EQUAL(current_slave_count, 1, 503 "Number of slaves (%d) is not that expected (%d).", 504 current_slave_count, 1); 505 506 snprintf(pmd_name, RTE_ETH_NAME_MAX_LEN, "%s_%d", BONDED_DEV_NAME, ++bonded_id); 507 508 port_id = rte_eth_bond_create(pmd_name, test_params->bonding_mode, 509 rte_socket_id()); 510 TEST_ASSERT(port_id >= 0, "Failed to create bonded device."); 511 512 TEST_ASSERT(rte_eth_bond_slave_add(port_id, 513 test_params->slave_port_ids[test_params->bonded_slave_count - 1]) 514 < 0, 515 "Added slave (%d) to bonded port (%d) unexpectedly.", 516 test_params->slave_port_ids[test_params->bonded_slave_count-1], 517 port_id); 518 519 return test_remove_slave_from_bonded_device(); 520 } 521 522 523 static int 524 test_get_slaves_from_bonded_device(void) 525 { 526 int current_slave_count; 527 uint8_t slaves[RTE_MAX_ETHPORTS]; 528 529 TEST_ASSERT_SUCCESS(test_add_slave_to_bonded_device(), 530 "Failed to add slave to bonded device"); 531 532 /* Invalid port id */ 533 current_slave_count = rte_eth_bond_slaves_get(INVALID_PORT_ID, slaves, 534 RTE_MAX_ETHPORTS); 535 TEST_ASSERT(current_slave_count < 0, 536 "Invalid port id unexpectedly succeeded"); 537 538 current_slave_count = rte_eth_bond_active_slaves_get(INVALID_PORT_ID, 539 slaves, RTE_MAX_ETHPORTS); 540 TEST_ASSERT(current_slave_count < 0, 541 "Invalid port id unexpectedly succeeded"); 542 543 /* Invalid slaves pointer */ 544 current_slave_count = rte_eth_bond_slaves_get(test_params->bonded_port_id, 545 NULL, RTE_MAX_ETHPORTS); 546 TEST_ASSERT(current_slave_count < 0, 547 "Invalid slave array unexpectedly succeeded"); 548 549 current_slave_count = rte_eth_bond_active_slaves_get( 550 test_params->bonded_port_id, NULL, RTE_MAX_ETHPORTS); 551 TEST_ASSERT(current_slave_count < 0, 552 "Invalid slave array unexpectedly succeeded"); 553 554 /* non bonded device*/ 555 current_slave_count = rte_eth_bond_slaves_get( 556 test_params->slave_port_ids[0], NULL, RTE_MAX_ETHPORTS); 557 TEST_ASSERT(current_slave_count < 0, 558 "Invalid port id unexpectedly succeeded"); 559 560 current_slave_count = rte_eth_bond_active_slaves_get( 561 test_params->slave_port_ids[0], NULL, RTE_MAX_ETHPORTS); 562 TEST_ASSERT(current_slave_count < 0, 563 "Invalid port id unexpectedly succeeded"); 564 565 TEST_ASSERT_SUCCESS(test_remove_slave_from_bonded_device(), 566 "Failed to remove slaves from bonded device"); 567 568 return 0; 569 } 570 571 572 static int 573 test_add_remove_multiple_slaves_to_from_bonded_device(void) 574 { 575 int i; 576 577 for (i = 0; i < TEST_MAX_NUMBER_OF_PORTS; i++) 578 TEST_ASSERT_SUCCESS(test_add_slave_to_bonded_device(), 579 "Failed to add slave to bonded device"); 580 581 for (i = 0; i < TEST_MAX_NUMBER_OF_PORTS; i++) 582 TEST_ASSERT_SUCCESS(test_remove_slave_from_bonded_device(), 583 "Failed to remove slaves from bonded device"); 584 585 return 0; 586 } 587 588 static void 589 enable_bonded_slaves(void) 590 { 591 int i; 592 593 for (i = 0; i < test_params->bonded_slave_count; i++) { 594 virtual_ethdev_tx_burst_fn_set_success(test_params->slave_port_ids[i], 595 1); 596 597 virtual_ethdev_simulate_link_status_interrupt( 598 test_params->slave_port_ids[i], 1); 599 } 600 } 601 602 static int 603 test_start_bonded_device(void) 604 { 605 struct rte_eth_link link_status; 606 607 int current_slave_count, current_bonding_mode, primary_port; 608 uint8_t slaves[RTE_MAX_ETHPORTS]; 609 610 /* Add slave to bonded device*/ 611 TEST_ASSERT_SUCCESS(test_add_slave_to_bonded_device(), 612 "Failed to add slave to bonded device"); 613 614 TEST_ASSERT_SUCCESS(rte_eth_dev_start(test_params->bonded_port_id), 615 "Failed to start bonded pmd eth device %d.", 616 test_params->bonded_port_id); 617 618 /* Change link status of virtual pmd so it will be added to the active 619 * slave list of the bonded device*/ 620 virtual_ethdev_simulate_link_status_interrupt( 621 test_params->slave_port_ids[test_params->bonded_slave_count-1], 1); 622 623 current_slave_count = rte_eth_bond_slaves_get(test_params->bonded_port_id, 624 slaves, RTE_MAX_ETHPORTS); 625 TEST_ASSERT_EQUAL(current_slave_count, test_params->bonded_slave_count, 626 "Number of slaves (%d) is not expected value (%d).", 627 current_slave_count, test_params->bonded_slave_count); 628 629 current_slave_count = rte_eth_bond_active_slaves_get( 630 test_params->bonded_port_id, slaves, RTE_MAX_ETHPORTS); 631 TEST_ASSERT_EQUAL(current_slave_count, test_params->bonded_slave_count, 632 "Number of active slaves (%d) is not expected value (%d).", 633 current_slave_count, test_params->bonded_slave_count); 634 635 current_bonding_mode = rte_eth_bond_mode_get(test_params->bonded_port_id); 636 TEST_ASSERT_EQUAL(current_bonding_mode, test_params->bonding_mode, 637 "Bonded device mode (%d) is not expected value (%d).\n", 638 current_bonding_mode, test_params->bonding_mode); 639 640 primary_port = rte_eth_bond_primary_get(test_params->bonded_port_id); 641 TEST_ASSERT_EQUAL(primary_port, test_params->slave_port_ids[0], 642 "Primary port (%d) is not expected value (%d).", 643 primary_port, test_params->slave_port_ids[0]); 644 645 rte_eth_link_get(test_params->bonded_port_id, &link_status); 646 TEST_ASSERT_EQUAL(link_status.link_status, 1, 647 "Bonded port (%d) status (%d) is not expected value (%d).\n", 648 test_params->bonded_port_id, link_status.link_status, 1); 649 650 return 0; 651 } 652 653 static int 654 test_stop_bonded_device(void) 655 { 656 int current_slave_count; 657 uint8_t slaves[RTE_MAX_ETHPORTS]; 658 659 struct rte_eth_link link_status; 660 661 rte_eth_dev_stop(test_params->bonded_port_id); 662 663 rte_eth_link_get(test_params->bonded_port_id, &link_status); 664 TEST_ASSERT_EQUAL(link_status.link_status, 0, 665 "Bonded port (%d) status (%d) is not expected value (%d).", 666 test_params->bonded_port_id, link_status.link_status, 0); 667 668 current_slave_count = rte_eth_bond_slaves_get(test_params->bonded_port_id, 669 slaves, RTE_MAX_ETHPORTS); 670 TEST_ASSERT_EQUAL(current_slave_count, test_params->bonded_slave_count, 671 "Number of slaves (%d) is not expected value (%d).", 672 current_slave_count, test_params->bonded_slave_count); 673 674 current_slave_count = rte_eth_bond_active_slaves_get( 675 test_params->bonded_port_id, slaves, RTE_MAX_ETHPORTS); 676 TEST_ASSERT_EQUAL(current_slave_count, 0, 677 "Number of active slaves (%d) is not expected value (%d).", 678 current_slave_count, 0); 679 680 return 0; 681 } 682 683 static int 684 remove_slaves_and_stop_bonded_device(void) 685 { 686 /* Clean up and remove slaves from bonded device */ 687 while (test_params->bonded_slave_count > 0) 688 TEST_ASSERT_SUCCESS(test_remove_slave_from_bonded_device(), 689 "test_remove_slave_from_bonded_device failed"); 690 691 rte_eth_dev_stop(test_params->bonded_port_id); 692 rte_eth_stats_reset(test_params->bonded_port_id); 693 rte_eth_bond_mac_address_reset(test_params->bonded_port_id); 694 695 return 0; 696 } 697 698 static int 699 test_set_bonding_mode(void) 700 { 701 int i, bonding_mode; 702 703 int bonding_modes[] = { BONDING_MODE_ROUND_ROBIN, 704 BONDING_MODE_ACTIVE_BACKUP, 705 BONDING_MODE_BALANCE, 706 BONDING_MODE_BROADCAST 707 }; 708 709 /* Test supported link bonding modes */ 710 for (i = 0; i < (int)RTE_DIM(bonding_modes); i++) { 711 /* Invalid port ID */ 712 TEST_ASSERT_FAIL(rte_eth_bond_mode_set(INVALID_PORT_ID, 713 bonding_modes[i]), 714 "Expected call to failed as invalid port (%d) specified.", 715 INVALID_PORT_ID); 716 717 /* Non bonded device */ 718 TEST_ASSERT_FAIL(rte_eth_bond_mode_set(test_params->slave_port_ids[0], 719 bonding_modes[i]), 720 "Expected call to failed as invalid port (%d) specified.", 721 test_params->slave_port_ids[0]); 722 723 TEST_ASSERT_SUCCESS(rte_eth_bond_mode_set(test_params->bonded_port_id, 724 bonding_modes[i]), 725 "Failed to set link bonding mode on port (%d) to (%d).", 726 test_params->bonded_port_id, bonding_modes[i]); 727 728 bonding_mode = rte_eth_bond_mode_get(test_params->bonded_port_id); 729 TEST_ASSERT_EQUAL(bonding_mode, bonding_modes[i], 730 "Link bonding mode (%d) of port (%d) is not expected value (%d).", 731 bonding_mode, test_params->bonded_port_id, 732 bonding_modes[i]); 733 734 /* Invalid port ID */ 735 bonding_mode = rte_eth_bond_mode_get(INVALID_PORT_ID); 736 TEST_ASSERT(bonding_mode < 0, 737 "Expected call to failed as invalid port (%d) specified.", 738 INVALID_PORT_ID); 739 740 /* Non bonded device */ 741 bonding_mode = rte_eth_bond_mode_get(test_params->slave_port_ids[0]); 742 TEST_ASSERT(bonding_mode < 0, 743 "Expected call to failed as invalid port (%d) specified.", 744 test_params->slave_port_ids[0]); 745 } 746 747 return remove_slaves_and_stop_bonded_device(); 748 } 749 750 static int 751 test_set_primary_slave(void) 752 { 753 int i, j, retval; 754 struct ether_addr read_mac_addr; 755 struct ether_addr *expected_mac_addr; 756 757 /* Add 4 slaves to bonded device */ 758 for (i = test_params->bonded_slave_count; i < 4; i++) 759 TEST_ASSERT_SUCCESS(test_add_slave_to_bonded_device(), 760 "Failed to add slave to bonded device."); 761 762 TEST_ASSERT_SUCCESS(rte_eth_bond_mode_set(test_params->bonded_port_id, 763 BONDING_MODE_ROUND_ROBIN), 764 "Failed to set link bonding mode on port (%d) to (%d).", 765 test_params->bonded_port_id, BONDING_MODE_ROUND_ROBIN); 766 767 /* Invalid port ID */ 768 TEST_ASSERT_FAIL(rte_eth_bond_primary_set(INVALID_PORT_ID, 769 test_params->slave_port_ids[i]), 770 "Expected call to failed as invalid port specified."); 771 772 /* Non bonded device */ 773 TEST_ASSERT_FAIL(rte_eth_bond_primary_set(test_params->slave_port_ids[i], 774 test_params->slave_port_ids[i]), 775 "Expected call to failed as invalid port specified."); 776 777 /* Set slave as primary 778 * Verify slave it is now primary slave 779 * Verify that MAC address of bonded device is that of primary slave 780 * Verify that MAC address of all bonded slaves are that of primary slave 781 */ 782 for (i = 0; i < 4; i++) { 783 TEST_ASSERT_SUCCESS(rte_eth_bond_primary_set(test_params->bonded_port_id, 784 test_params->slave_port_ids[i]), 785 "Failed to set bonded port (%d) primary port to (%d)", 786 test_params->bonded_port_id, test_params->slave_port_ids[i]); 787 788 retval = rte_eth_bond_primary_get(test_params->bonded_port_id); 789 TEST_ASSERT(retval >= 0, 790 "Failed to read primary port from bonded port (%d)\n", 791 test_params->bonded_port_id); 792 793 TEST_ASSERT_EQUAL(retval, test_params->slave_port_ids[i], 794 "Bonded port (%d) primary port (%d) not expected value (%d)\n", 795 test_params->bonded_port_id, retval, 796 test_params->slave_port_ids[i]); 797 798 /* stop/start bonded eth dev to apply new MAC */ 799 rte_eth_dev_stop(test_params->bonded_port_id); 800 801 TEST_ASSERT_SUCCESS(rte_eth_dev_start(test_params->bonded_port_id), 802 "Failed to start bonded port %d", 803 test_params->bonded_port_id); 804 805 expected_mac_addr = (struct ether_addr *)&slave_mac; 806 expected_mac_addr->addr_bytes[ETHER_ADDR_LEN-1] = i; 807 808 /* Check primary slave MAC */ 809 rte_eth_macaddr_get(test_params->slave_port_ids[i], &read_mac_addr); 810 TEST_ASSERT_SUCCESS(memcmp(expected_mac_addr, &read_mac_addr, 811 sizeof(read_mac_addr)), 812 "bonded port mac address not set to that of primary port\n"); 813 814 /* Check bonded MAC */ 815 rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr); 816 TEST_ASSERT_SUCCESS(memcmp(&read_mac_addr, &read_mac_addr, 817 sizeof(read_mac_addr)), 818 "bonded port mac address not set to that of primary port\n"); 819 820 /* Check other slaves MACs */ 821 for (j = 0; j < 4; j++) { 822 if (j != i) { 823 rte_eth_macaddr_get(test_params->slave_port_ids[j], 824 &read_mac_addr); 825 TEST_ASSERT_SUCCESS(memcmp(expected_mac_addr, &read_mac_addr, 826 sizeof(read_mac_addr)), 827 "slave port mac address not set to that of primary " 828 "port"); 829 } 830 } 831 } 832 833 834 /* Test with none existent port */ 835 TEST_ASSERT_FAIL(rte_eth_bond_primary_get(test_params->bonded_port_id + 10), 836 "read primary port from expectedly"); 837 838 /* Test with slave port */ 839 TEST_ASSERT_FAIL(rte_eth_bond_primary_get(test_params->slave_port_ids[0]), 840 "read primary port from expectedly\n"); 841 842 TEST_ASSERT_SUCCESS(remove_slaves_and_stop_bonded_device(), 843 "Failed to stop and remove slaves from bonded device"); 844 845 /* No slaves */ 846 TEST_ASSERT(rte_eth_bond_primary_get(test_params->bonded_port_id) < 0, 847 "read primary port from expectedly\n"); 848 849 return 0; 850 } 851 852 static int 853 test_set_explicit_bonded_mac(void) 854 { 855 int i; 856 struct ether_addr read_mac_addr; 857 struct ether_addr *mac_addr; 858 859 uint8_t explicit_bonded_mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x01 }; 860 861 mac_addr = (struct ether_addr *)explicit_bonded_mac; 862 863 /* Invalid port ID */ 864 TEST_ASSERT_FAIL(rte_eth_bond_mac_address_set(INVALID_PORT_ID, mac_addr), 865 "Expected call to failed as invalid port specified."); 866 867 /* Non bonded device */ 868 TEST_ASSERT_FAIL(rte_eth_bond_mac_address_set( 869 test_params->slave_port_ids[0], mac_addr), 870 "Expected call to failed as invalid port specified."); 871 872 /* NULL MAC address */ 873 TEST_ASSERT_FAIL(rte_eth_bond_mac_address_set( 874 test_params->bonded_port_id, NULL), 875 "Expected call to failed as NULL MAC specified"); 876 877 TEST_ASSERT_SUCCESS(rte_eth_bond_mac_address_set( 878 test_params->bonded_port_id, mac_addr), 879 "Failed to set MAC address on bonded port (%d)", 880 test_params->bonded_port_id); 881 882 /* Add 4 slaves to bonded device */ 883 for (i = test_params->bonded_slave_count; i < 4; i++) { 884 TEST_ASSERT_SUCCESS(test_add_slave_to_bonded_device(), 885 "Failed to add slave to bonded device.\n"); 886 } 887 888 /* Check bonded MAC */ 889 rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr); 890 TEST_ASSERT_SUCCESS(memcmp(mac_addr, &read_mac_addr, sizeof(read_mac_addr)), 891 "bonded port mac address not set to that of primary port"); 892 893 /* Check other slaves MACs */ 894 for (i = 0; i < 4; i++) { 895 rte_eth_macaddr_get(test_params->slave_port_ids[i], &read_mac_addr); 896 TEST_ASSERT_SUCCESS(memcmp(mac_addr, &read_mac_addr, 897 sizeof(read_mac_addr)), 898 "slave port mac address not set to that of primary port"); 899 } 900 901 /* test resetting mac address on bonded device */ 902 TEST_ASSERT_SUCCESS( 903 rte_eth_bond_mac_address_reset(test_params->bonded_port_id), 904 "Failed to reset MAC address on bonded port (%d)", 905 test_params->bonded_port_id); 906 907 TEST_ASSERT_FAIL( 908 rte_eth_bond_mac_address_reset(test_params->slave_port_ids[0]), 909 "Reset MAC address on bonded port (%d) unexpectedly", 910 test_params->slave_port_ids[1]); 911 912 /* test resetting mac address on bonded device with no slaves */ 913 TEST_ASSERT_SUCCESS(remove_slaves_and_stop_bonded_device(), 914 "Failed to remove slaves and stop bonded device"); 915 916 TEST_ASSERT_SUCCESS(rte_eth_bond_mac_address_reset(test_params->bonded_port_id), 917 "Failed to reset MAC address on bonded port (%d)", 918 test_params->bonded_port_id); 919 920 return 0; 921 } 922 923 #define BONDED_INIT_MAC_ASSIGNMENT_SLAVE_COUNT (3) 924 925 static int 926 test_set_bonded_port_initialization_mac_assignment(void) 927 { 928 int i, slave_count, bonded_port_id; 929 930 uint8_t slaves[RTE_MAX_ETHPORTS]; 931 int slave_port_ids[BONDED_INIT_MAC_ASSIGNMENT_SLAVE_COUNT]; 932 933 struct ether_addr slave_mac_addr, bonded_mac_addr, read_mac_addr; 934 935 /* Initialize default values for MAC addresses */ 936 memcpy(&slave_mac_addr, slave_mac, sizeof(struct ether_addr)); 937 memcpy(&bonded_mac_addr, slave_mac, sizeof(struct ether_addr)); 938 939 /* 940 * 1. a - Create / configure bonded / slave ethdevs 941 */ 942 bonded_port_id = rte_eth_bond_create("ethdev_bond_mac_ass_test", 943 BONDING_MODE_ACTIVE_BACKUP, rte_socket_id()); 944 TEST_ASSERT(bonded_port_id > 0, "failed to create bonded device"); 945 946 TEST_ASSERT_SUCCESS(configure_ethdev(bonded_port_id, 0, 0), 947 "Failed to configure bonded ethdev"); 948 949 for (i = 0; i < BONDED_INIT_MAC_ASSIGNMENT_SLAVE_COUNT; i++) { 950 char pmd_name[RTE_ETH_NAME_MAX_LEN]; 951 952 slave_mac_addr.addr_bytes[ETHER_ADDR_LEN-1] = i + 100; 953 954 snprintf(pmd_name, RTE_ETH_NAME_MAX_LEN, "eth_slave_%d", i); 955 956 slave_port_ids[i] = virtual_ethdev_create(pmd_name, 957 &slave_mac_addr, rte_socket_id(), 1); 958 959 TEST_ASSERT(slave_port_ids[i] >= 0, 960 "Failed to create slave ethdev %s", pmd_name); 961 962 TEST_ASSERT_SUCCESS(configure_ethdev(slave_port_ids[i], 1, 0), 963 "Failed to configure virtual ethdev %s", 964 pmd_name); 965 } 966 967 968 /* 969 * 2. Add slave ethdevs to bonded device 970 */ 971 for (i = 0; i < BONDED_INIT_MAC_ASSIGNMENT_SLAVE_COUNT; i++) { 972 TEST_ASSERT_SUCCESS(rte_eth_bond_slave_add(bonded_port_id, 973 slave_port_ids[i]), 974 "Failed to add slave (%d) to bonded port (%d).", 975 slave_port_ids[i], bonded_port_id); 976 } 977 978 slave_count = rte_eth_bond_slaves_get(bonded_port_id, slaves, 979 RTE_MAX_ETHPORTS); 980 TEST_ASSERT_EQUAL(BONDED_INIT_MAC_ASSIGNMENT_SLAVE_COUNT, slave_count, 981 "Number of slaves (%d) is not as expected (%d)", 982 slave_count, BONDED_INIT_MAC_ASSIGNMENT_SLAVE_COUNT); 983 984 985 /* 986 * 3. Set explicit MAC address on bonded ethdev 987 */ 988 bonded_mac_addr.addr_bytes[ETHER_ADDR_LEN-2] = 0xFF; 989 bonded_mac_addr.addr_bytes[ETHER_ADDR_LEN-1] = 0xAA; 990 991 TEST_ASSERT_SUCCESS(rte_eth_bond_mac_address_set( 992 bonded_port_id, &bonded_mac_addr), 993 "Failed to set MAC address on bonded port (%d)", 994 bonded_port_id); 995 996 997 /* 4. a - Start bonded ethdev 998 * b - Enable slave devices 999 * c - Verify bonded/slaves ethdev MAC addresses 1000 */ 1001 TEST_ASSERT_SUCCESS(rte_eth_dev_start(bonded_port_id), 1002 "Failed to start bonded pmd eth device %d.", 1003 bonded_port_id); 1004 1005 for (i = 0; i < BONDED_INIT_MAC_ASSIGNMENT_SLAVE_COUNT; i++) { 1006 virtual_ethdev_simulate_link_status_interrupt( 1007 slave_port_ids[i], 1); 1008 } 1009 1010 rte_eth_macaddr_get(bonded_port_id, &read_mac_addr); 1011 TEST_ASSERT_SUCCESS(memcmp(&bonded_mac_addr, &read_mac_addr, 1012 sizeof(read_mac_addr)), 1013 "bonded port mac address not as expected"); 1014 1015 rte_eth_macaddr_get(slave_port_ids[0], &read_mac_addr); 1016 TEST_ASSERT_SUCCESS(memcmp(&bonded_mac_addr, &read_mac_addr, 1017 sizeof(read_mac_addr)), 1018 "slave port 0 mac address not as expected"); 1019 1020 slave_mac_addr.addr_bytes[ETHER_ADDR_LEN-1] = 1 + 100; 1021 rte_eth_macaddr_get(slave_port_ids[1], &read_mac_addr); 1022 TEST_ASSERT_SUCCESS(memcmp(&slave_mac_addr, &read_mac_addr, 1023 sizeof(read_mac_addr)), 1024 "slave port 1 mac address not as expected"); 1025 1026 slave_mac_addr.addr_bytes[ETHER_ADDR_LEN-1] = 2 + 100; 1027 rte_eth_macaddr_get(slave_port_ids[2], &read_mac_addr); 1028 TEST_ASSERT_SUCCESS(memcmp(&slave_mac_addr, &read_mac_addr, 1029 sizeof(read_mac_addr)), 1030 "slave port 2 mac address not as expected"); 1031 1032 1033 /* 7. a - Change primary port 1034 * b - Stop / Start bonded port 1035 * d - Verify slave ethdev MAC addresses 1036 */ 1037 TEST_ASSERT_SUCCESS(rte_eth_bond_primary_set(bonded_port_id, 1038 slave_port_ids[2]), 1039 "failed to set primary port on bonded device."); 1040 1041 rte_eth_dev_stop(bonded_port_id); 1042 TEST_ASSERT_SUCCESS(rte_eth_dev_start(bonded_port_id), 1043 "Failed to start bonded pmd eth device %d.", 1044 bonded_port_id); 1045 1046 rte_eth_macaddr_get(bonded_port_id, &read_mac_addr); 1047 TEST_ASSERT_SUCCESS(memcmp(&bonded_mac_addr, &read_mac_addr, 1048 sizeof(read_mac_addr)), 1049 "bonded port mac address not as expected"); 1050 1051 slave_mac_addr.addr_bytes[ETHER_ADDR_LEN-1] = 0 + 100; 1052 rte_eth_macaddr_get(slave_port_ids[0], &read_mac_addr); 1053 TEST_ASSERT_SUCCESS(memcmp(&slave_mac_addr, &read_mac_addr, 1054 sizeof(read_mac_addr)), 1055 "slave port 0 mac address not as expected"); 1056 1057 slave_mac_addr.addr_bytes[ETHER_ADDR_LEN-1] = 1 + 100; 1058 rte_eth_macaddr_get(slave_port_ids[1], &read_mac_addr); 1059 TEST_ASSERT_SUCCESS(memcmp(&slave_mac_addr, &read_mac_addr, 1060 sizeof(read_mac_addr)), 1061 "slave port 1 mac address not as expected"); 1062 1063 rte_eth_macaddr_get(slave_port_ids[2], &read_mac_addr); 1064 TEST_ASSERT_SUCCESS(memcmp(&bonded_mac_addr, &read_mac_addr, 1065 sizeof(read_mac_addr)), 1066 "slave port 2 mac address not as expected"); 1067 1068 /* 6. a - Stop bonded ethdev 1069 * b - remove slave ethdevs 1070 * c - Verify slave ethdevs MACs are restored 1071 */ 1072 rte_eth_dev_stop(bonded_port_id); 1073 1074 for (i = 0; i < BONDED_INIT_MAC_ASSIGNMENT_SLAVE_COUNT; i++) { 1075 TEST_ASSERT_SUCCESS(rte_eth_bond_slave_remove(bonded_port_id, 1076 slave_port_ids[i]), 1077 "Failed to remove slave %d from bonded port (%d).", 1078 slave_port_ids[i], bonded_port_id); 1079 } 1080 1081 slave_count = rte_eth_bond_slaves_get(bonded_port_id, slaves, 1082 RTE_MAX_ETHPORTS); 1083 1084 TEST_ASSERT_EQUAL(slave_count, 0, 1085 "Number of slaves (%d) is great than expected (%d).", 1086 slave_count, 0); 1087 1088 slave_mac_addr.addr_bytes[ETHER_ADDR_LEN-1] = 0 + 100; 1089 rte_eth_macaddr_get(slave_port_ids[0], &read_mac_addr); 1090 TEST_ASSERT_SUCCESS(memcmp(&slave_mac_addr, &read_mac_addr, 1091 sizeof(read_mac_addr)), 1092 "slave port 0 mac address not as expected"); 1093 1094 slave_mac_addr.addr_bytes[ETHER_ADDR_LEN-1] = 1 + 100; 1095 rte_eth_macaddr_get(slave_port_ids[1], &read_mac_addr); 1096 TEST_ASSERT_SUCCESS(memcmp(&slave_mac_addr, &read_mac_addr, 1097 sizeof(read_mac_addr)), 1098 "slave port 1 mac address not as expected"); 1099 1100 slave_mac_addr.addr_bytes[ETHER_ADDR_LEN-1] = 2 + 100; 1101 rte_eth_macaddr_get(slave_port_ids[2], &read_mac_addr); 1102 TEST_ASSERT_SUCCESS(memcmp(&slave_mac_addr, &read_mac_addr, 1103 sizeof(read_mac_addr)), 1104 "slave port 2 mac address not as expected"); 1105 1106 return 0; 1107 } 1108 1109 1110 static int 1111 initialize_bonded_device_with_slaves(uint8_t bonding_mode, uint8_t bond_en_isr, 1112 uint8_t number_of_slaves, uint8_t enable_slave) 1113 { 1114 /* Configure bonded device */ 1115 TEST_ASSERT_SUCCESS(configure_ethdev(test_params->bonded_port_id, 0, 1116 bond_en_isr), "Failed to configure bonding port (%d) in mode %d " 1117 "with (%d) slaves.", test_params->bonded_port_id, bonding_mode, 1118 number_of_slaves); 1119 1120 /* Add slaves to bonded device */ 1121 while (number_of_slaves > test_params->bonded_slave_count) 1122 TEST_ASSERT_SUCCESS(test_add_slave_to_bonded_device(), 1123 "Failed to add slave (%d to bonding port (%d).", 1124 test_params->bonded_slave_count - 1, 1125 test_params->bonded_port_id); 1126 1127 /* Set link bonding mode */ 1128 TEST_ASSERT_SUCCESS(rte_eth_bond_mode_set(test_params->bonded_port_id, 1129 bonding_mode), 1130 "Failed to set link bonding mode on port (%d) to (%d).", 1131 test_params->bonded_port_id, bonding_mode); 1132 1133 TEST_ASSERT_SUCCESS(rte_eth_dev_start(test_params->bonded_port_id), 1134 "Failed to start bonded pmd eth device %d.", 1135 test_params->bonded_port_id); 1136 1137 if (enable_slave) 1138 enable_bonded_slaves(); 1139 1140 return 0; 1141 } 1142 1143 static int 1144 test_adding_slave_after_bonded_device_started(void) 1145 { 1146 int i; 1147 1148 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 1149 BONDING_MODE_ROUND_ROBIN, 0, 4, 0), 1150 "Failed to add slaves to bonded device"); 1151 1152 /* Enabled slave devices */ 1153 for (i = 0; i < test_params->bonded_slave_count + 1; i++) { 1154 virtual_ethdev_simulate_link_status_interrupt( 1155 test_params->slave_port_ids[i], 1); 1156 } 1157 1158 TEST_ASSERT_SUCCESS(rte_eth_bond_slave_add(test_params->bonded_port_id, 1159 test_params->slave_port_ids[test_params->bonded_slave_count]), 1160 "Failed to add slave to bonded port.\n"); 1161 1162 rte_eth_stats_reset( 1163 test_params->slave_port_ids[test_params->bonded_slave_count]); 1164 1165 test_params->bonded_slave_count++; 1166 1167 return remove_slaves_and_stop_bonded_device(); 1168 } 1169 1170 #define TEST_STATUS_INTERRUPT_SLAVE_COUNT 4 1171 #define TEST_LSC_WAIT_TIMEOUT_MS 500 1172 1173 int test_lsc_interrupt_count; 1174 1175 1176 static void 1177 test_bonding_lsc_event_callback(uint8_t port_id __rte_unused, 1178 enum rte_eth_event_type type __rte_unused, void *param __rte_unused) 1179 { 1180 pthread_mutex_lock(&mutex); 1181 test_lsc_interrupt_count++; 1182 1183 pthread_cond_signal(&cvar); 1184 pthread_mutex_unlock(&mutex); 1185 } 1186 1187 static inline int 1188 lsc_timeout(int wait_us) 1189 { 1190 int retval = 0; 1191 1192 struct timespec ts; 1193 struct timeval tp; 1194 1195 gettimeofday(&tp, NULL); 1196 1197 /* Convert from timeval to timespec */ 1198 ts.tv_sec = tp.tv_sec; 1199 ts.tv_nsec = tp.tv_usec * 1000; 1200 ts.tv_nsec += wait_us * 1000; 1201 1202 pthread_mutex_lock(&mutex); 1203 if (test_lsc_interrupt_count < 1) 1204 retval = pthread_cond_timedwait(&cvar, &mutex, &ts); 1205 1206 pthread_mutex_unlock(&mutex); 1207 1208 if (retval == 0 && test_lsc_interrupt_count < 1) 1209 return -1; 1210 1211 return retval; 1212 } 1213 1214 static int 1215 test_status_interrupt(void) 1216 { 1217 int slave_count; 1218 uint8_t slaves[RTE_MAX_ETHPORTS]; 1219 1220 /* initialized bonding device with T slaves */ 1221 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 1222 BONDING_MODE_ROUND_ROBIN, 1, 1223 TEST_STATUS_INTERRUPT_SLAVE_COUNT, 1), 1224 "Failed to initialise bonded device"); 1225 1226 test_lsc_interrupt_count = 0; 1227 1228 /* register link status change interrupt callback */ 1229 rte_eth_dev_callback_register(test_params->bonded_port_id, 1230 RTE_ETH_EVENT_INTR_LSC, test_bonding_lsc_event_callback, 1231 &test_params->bonded_port_id); 1232 1233 slave_count = rte_eth_bond_active_slaves_get(test_params->bonded_port_id, 1234 slaves, RTE_MAX_ETHPORTS); 1235 1236 TEST_ASSERT_EQUAL(slave_count, TEST_STATUS_INTERRUPT_SLAVE_COUNT, 1237 "Number of active slaves (%d) is not as expected (%d)", 1238 slave_count, TEST_STATUS_INTERRUPT_SLAVE_COUNT); 1239 1240 /* Bring all 4 slaves link status to down and test that we have received a 1241 * lsc interrupts */ 1242 virtual_ethdev_simulate_link_status_interrupt( 1243 test_params->slave_port_ids[0], 0); 1244 virtual_ethdev_simulate_link_status_interrupt( 1245 test_params->slave_port_ids[1], 0); 1246 virtual_ethdev_simulate_link_status_interrupt( 1247 test_params->slave_port_ids[2], 0); 1248 1249 TEST_ASSERT_EQUAL(test_lsc_interrupt_count, 0, 1250 "Received a link status change interrupt unexpectedly"); 1251 1252 virtual_ethdev_simulate_link_status_interrupt( 1253 test_params->slave_port_ids[3], 0); 1254 1255 TEST_ASSERT(lsc_timeout(TEST_LSC_WAIT_TIMEOUT_MS) == 0, 1256 "timed out waiting for interrupt"); 1257 1258 TEST_ASSERT(test_lsc_interrupt_count > 0, 1259 "Did not receive link status change interrupt"); 1260 1261 slave_count = rte_eth_bond_active_slaves_get(test_params->bonded_port_id, 1262 slaves, RTE_MAX_ETHPORTS); 1263 1264 TEST_ASSERT_EQUAL(slave_count, 0, 1265 "Number of active slaves (%d) is not as expected (%d)", 1266 slave_count, 0); 1267 1268 /* bring one slave port up so link status will change */ 1269 test_lsc_interrupt_count = 0; 1270 1271 virtual_ethdev_simulate_link_status_interrupt( 1272 test_params->slave_port_ids[0], 1); 1273 1274 TEST_ASSERT(lsc_timeout(TEST_LSC_WAIT_TIMEOUT_MS) == 0, 1275 "timed out waiting for interrupt"); 1276 1277 /* test that we have received another lsc interrupt */ 1278 TEST_ASSERT(test_lsc_interrupt_count > 0, 1279 "Did not receive link status change interrupt"); 1280 1281 /* Verify that calling the same slave lsc interrupt doesn't cause another 1282 * lsc interrupt from bonded device */ 1283 test_lsc_interrupt_count = 0; 1284 1285 virtual_ethdev_simulate_link_status_interrupt( 1286 test_params->slave_port_ids[0], 1); 1287 1288 TEST_ASSERT(lsc_timeout(TEST_LSC_WAIT_TIMEOUT_MS) != 0, 1289 "received unexpected interrupt"); 1290 1291 TEST_ASSERT_EQUAL(test_lsc_interrupt_count, 0, 1292 "Did not receive link status change interrupt"); 1293 1294 1295 /* unregister lsc callback before exiting */ 1296 rte_eth_dev_callback_unregister(test_params->bonded_port_id, 1297 RTE_ETH_EVENT_INTR_LSC, test_bonding_lsc_event_callback, 1298 &test_params->bonded_port_id); 1299 1300 /* Clean up and remove slaves from bonded device */ 1301 return remove_slaves_and_stop_bonded_device(); 1302 } 1303 1304 static int 1305 generate_test_burst(struct rte_mbuf **pkts_burst, uint16_t burst_size, 1306 uint8_t vlan, uint8_t ipv4, uint8_t toggle_dst_mac, 1307 uint8_t toggle_ip_addr, uint8_t toggle_udp_port) 1308 { 1309 uint16_t pktlen, generated_burst_size, ether_type; 1310 void *ip_hdr; 1311 1312 if (ipv4) 1313 ether_type = ETHER_TYPE_IPv4; 1314 else 1315 ether_type = ETHER_TYPE_IPv6; 1316 1317 if (toggle_dst_mac) 1318 initialize_eth_header(test_params->pkt_eth_hdr, 1319 (struct ether_addr *)src_mac, (struct ether_addr *)dst_mac_1, 1320 ether_type, vlan, vlan_id); 1321 else 1322 initialize_eth_header(test_params->pkt_eth_hdr, 1323 (struct ether_addr *)src_mac, (struct ether_addr *)dst_mac_0, 1324 ether_type, vlan, vlan_id); 1325 1326 1327 if (toggle_udp_port) 1328 pktlen = initialize_udp_header(test_params->pkt_udp_hdr, src_port, 1329 dst_port_1, 64); 1330 else 1331 pktlen = initialize_udp_header(test_params->pkt_udp_hdr, src_port, 1332 dst_port_0, 64); 1333 1334 if (ipv4) { 1335 if (toggle_ip_addr) 1336 pktlen = initialize_ipv4_header(test_params->pkt_ipv4_hdr, src_addr, 1337 dst_addr_1, pktlen); 1338 else 1339 pktlen = initialize_ipv4_header(test_params->pkt_ipv4_hdr, src_addr, 1340 dst_addr_0, pktlen); 1341 1342 ip_hdr = test_params->pkt_ipv4_hdr; 1343 } else { 1344 if (toggle_ip_addr) 1345 pktlen = initialize_ipv6_header(test_params->pkt_ipv6_hdr, 1346 (uint8_t *)src_ipv6_addr, (uint8_t *)dst_ipv6_addr_1, 1347 pktlen); 1348 else 1349 pktlen = initialize_ipv6_header(test_params->pkt_ipv6_hdr, 1350 (uint8_t *)src_ipv6_addr, (uint8_t *)dst_ipv6_addr_0, 1351 pktlen); 1352 1353 ip_hdr = test_params->pkt_ipv6_hdr; 1354 } 1355 1356 /* Generate burst of packets to transmit */ 1357 generated_burst_size = generate_packet_burst(test_params->mbuf_pool, 1358 pkts_burst, test_params->pkt_eth_hdr, vlan, ip_hdr, ipv4, 1359 test_params->pkt_udp_hdr, burst_size, PACKET_BURST_GEN_PKT_LEN_128, 1360 1); 1361 TEST_ASSERT_EQUAL(generated_burst_size, burst_size, 1362 "Failed to generate packet burst"); 1363 1364 return generated_burst_size; 1365 } 1366 1367 /** Round Robin Mode Tests */ 1368 1369 static int 1370 test_roundrobin_tx_burst(void) 1371 { 1372 int i, burst_size; 1373 struct rte_mbuf *pkt_burst[MAX_PKT_BURST]; 1374 struct rte_eth_stats port_stats; 1375 1376 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 1377 BONDING_MODE_ROUND_ROBIN, 0, 2, 1), 1378 "Failed to intialise bonded device"); 1379 1380 burst_size = 20 * test_params->bonded_slave_count; 1381 1382 TEST_ASSERT(burst_size <= MAX_PKT_BURST, 1383 "Burst size specified is greater than supported."); 1384 1385 /* Generate test bursts of packets to transmit */ 1386 TEST_ASSERT_EQUAL(generate_test_burst(pkt_burst, burst_size, 0, 1, 0, 0, 0), 1387 burst_size, "failed to generate test burst"); 1388 1389 /* Send burst on bonded port */ 1390 TEST_ASSERT_EQUAL(rte_eth_tx_burst( 1391 test_params->bonded_port_id, 0, pkt_burst, burst_size), burst_size, 1392 "tx burst failed"); 1393 1394 /* Verify bonded port tx stats */ 1395 rte_eth_stats_get(test_params->bonded_port_id, &port_stats); 1396 TEST_ASSERT_EQUAL(port_stats.opackets, (uint64_t)burst_size, 1397 "Bonded Port (%d) opackets value (%u) not as expected (%d)\n", 1398 test_params->bonded_port_id, (unsigned int)port_stats.opackets, 1399 burst_size); 1400 1401 /* Verify slave ports tx stats */ 1402 for (i = 0; i < test_params->bonded_slave_count; i++) { 1403 rte_eth_stats_get(test_params->slave_port_ids[i], &port_stats); 1404 TEST_ASSERT_EQUAL(port_stats.opackets, 1405 (uint64_t)burst_size / test_params->bonded_slave_count, 1406 "Slave Port (%d) opackets value (%u) not as expected (%d)\n", 1407 test_params->bonded_port_id, (unsigned int)port_stats.opackets, 1408 burst_size / test_params->bonded_slave_count); 1409 } 1410 1411 /* Put all slaves down and try and transmit */ 1412 for (i = 0; i < test_params->bonded_slave_count; i++) { 1413 virtual_ethdev_simulate_link_status_interrupt( 1414 test_params->slave_port_ids[i], 0); 1415 } 1416 1417 /* Send burst on bonded port */ 1418 TEST_ASSERT_EQUAL(rte_eth_tx_burst(test_params->bonded_port_id, 0, 1419 pkt_burst, burst_size), 0, 1420 "tx burst return unexpected value"); 1421 1422 /* Clean up and remove slaves from bonded device */ 1423 return remove_slaves_and_stop_bonded_device(); 1424 } 1425 1426 static int 1427 verify_mbufs_ref_count(struct rte_mbuf **mbufs, int nb_mbufs, int val) 1428 { 1429 int i, refcnt; 1430 1431 for (i = 0; i < nb_mbufs; i++) { 1432 refcnt = rte_mbuf_refcnt_read(mbufs[i]); 1433 TEST_ASSERT_EQUAL(refcnt, val, 1434 "mbuf ref count (%d)is not the expected value (%d)", 1435 refcnt, val); 1436 } 1437 return 0; 1438 } 1439 1440 static void 1441 free_mbufs(struct rte_mbuf **mbufs, int nb_mbufs) 1442 { 1443 int i; 1444 1445 for (i = 0; i < nb_mbufs; i++) 1446 rte_pktmbuf_free(mbufs[i]); 1447 } 1448 1449 #define TEST_RR_SLAVE_TX_FAIL_SLAVE_COUNT (2) 1450 #define TEST_RR_SLAVE_TX_FAIL_BURST_SIZE (64) 1451 #define TEST_RR_SLAVE_TX_FAIL_PACKETS_COUNT (22) 1452 #define TEST_RR_SLAVE_TX_FAIL_FAILING_SLAVE_IDX (1) 1453 1454 static int 1455 test_roundrobin_tx_burst_slave_tx_fail(void) 1456 { 1457 struct rte_mbuf *pkt_burst[MAX_PKT_BURST]; 1458 struct rte_mbuf *expected_tx_fail_pkts[MAX_PKT_BURST]; 1459 1460 struct rte_eth_stats port_stats; 1461 1462 int i, first_fail_idx, tx_count; 1463 1464 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 1465 BONDING_MODE_ROUND_ROBIN, 0, 1466 TEST_RR_SLAVE_TX_FAIL_SLAVE_COUNT, 1), 1467 "Failed to intialise bonded device"); 1468 1469 /* Generate test bursts of packets to transmit */ 1470 TEST_ASSERT_EQUAL(generate_test_burst(pkt_burst, 1471 TEST_RR_SLAVE_TX_FAIL_BURST_SIZE, 0, 1, 0, 0, 0), 1472 TEST_RR_SLAVE_TX_FAIL_BURST_SIZE, 1473 "Failed to generate test packet burst"); 1474 1475 /* Copy references to packets which we expect not to be transmitted */ 1476 first_fail_idx = (TEST_RR_SLAVE_TX_FAIL_BURST_SIZE - 1477 (TEST_RR_SLAVE_TX_FAIL_PACKETS_COUNT * 1478 TEST_RR_SLAVE_TX_FAIL_SLAVE_COUNT)) + 1479 TEST_RR_SLAVE_TX_FAIL_FAILING_SLAVE_IDX; 1480 1481 for (i = 0; i < TEST_RR_SLAVE_TX_FAIL_PACKETS_COUNT; i++) { 1482 expected_tx_fail_pkts[i] = pkt_burst[first_fail_idx + 1483 (i * TEST_RR_SLAVE_TX_FAIL_SLAVE_COUNT)]; 1484 } 1485 1486 /* Set virtual slave to only fail transmission of 1487 * TEST_RR_SLAVE_TX_FAIL_PACKETS_COUNT packets in burst */ 1488 virtual_ethdev_tx_burst_fn_set_success( 1489 test_params->slave_port_ids[TEST_RR_SLAVE_TX_FAIL_FAILING_SLAVE_IDX], 1490 0); 1491 1492 virtual_ethdev_tx_burst_fn_set_tx_pkt_fail_count( 1493 test_params->slave_port_ids[TEST_RR_SLAVE_TX_FAIL_FAILING_SLAVE_IDX], 1494 TEST_RR_SLAVE_TX_FAIL_PACKETS_COUNT); 1495 1496 tx_count = rte_eth_tx_burst(test_params->bonded_port_id, 0, pkt_burst, 1497 TEST_RR_SLAVE_TX_FAIL_BURST_SIZE); 1498 1499 TEST_ASSERT_EQUAL(tx_count, TEST_RR_SLAVE_TX_FAIL_BURST_SIZE - 1500 TEST_RR_SLAVE_TX_FAIL_PACKETS_COUNT, 1501 "Transmitted (%d) an unexpected (%d) number of packets", tx_count, 1502 TEST_RR_SLAVE_TX_FAIL_BURST_SIZE - 1503 TEST_RR_SLAVE_TX_FAIL_PACKETS_COUNT); 1504 1505 /* Verify that failed packet are expected failed packets */ 1506 for (i = 0; i < TEST_RR_SLAVE_TX_FAIL_PACKETS_COUNT; i++) { 1507 TEST_ASSERT_EQUAL(expected_tx_fail_pkts[i], pkt_burst[i + tx_count], 1508 "expected mbuf (%d) pointer %p not expected pointer %p", 1509 i, expected_tx_fail_pkts[i], pkt_burst[i + tx_count]); 1510 } 1511 1512 /* Verify bonded port tx stats */ 1513 rte_eth_stats_get(test_params->bonded_port_id, &port_stats); 1514 1515 TEST_ASSERT_EQUAL(port_stats.opackets, 1516 (uint64_t)TEST_RR_SLAVE_TX_FAIL_BURST_SIZE - 1517 TEST_RR_SLAVE_TX_FAIL_PACKETS_COUNT, 1518 "Bonded Port (%d) opackets value (%u) not as expected (%d)", 1519 test_params->bonded_port_id, (unsigned int)port_stats.opackets, 1520 TEST_RR_SLAVE_TX_FAIL_BURST_SIZE - 1521 TEST_RR_SLAVE_TX_FAIL_PACKETS_COUNT); 1522 1523 /* Verify slave ports tx stats */ 1524 for (i = 0; i < test_params->bonded_slave_count; i++) { 1525 int slave_expected_tx_count; 1526 1527 rte_eth_stats_get(test_params->slave_port_ids[i], &port_stats); 1528 1529 slave_expected_tx_count = TEST_RR_SLAVE_TX_FAIL_BURST_SIZE / 1530 test_params->bonded_slave_count; 1531 1532 if (i == TEST_RR_SLAVE_TX_FAIL_FAILING_SLAVE_IDX) 1533 slave_expected_tx_count = slave_expected_tx_count - 1534 TEST_RR_SLAVE_TX_FAIL_PACKETS_COUNT; 1535 1536 TEST_ASSERT_EQUAL(port_stats.opackets, 1537 (uint64_t)slave_expected_tx_count, 1538 "Slave Port (%d) opackets value (%u) not as expected (%d)", 1539 test_params->slave_port_ids[i], 1540 (unsigned int)port_stats.opackets, slave_expected_tx_count); 1541 } 1542 1543 /* Verify that all mbufs have a ref value of zero */ 1544 TEST_ASSERT_SUCCESS(verify_mbufs_ref_count(&pkt_burst[tx_count], 1545 TEST_RR_SLAVE_TX_FAIL_PACKETS_COUNT, 1), 1546 "mbufs refcnts not as expected"); 1547 free_mbufs(&pkt_burst[tx_count], TEST_RR_SLAVE_TX_FAIL_PACKETS_COUNT); 1548 1549 /* Clean up and remove slaves from bonded device */ 1550 return remove_slaves_and_stop_bonded_device(); 1551 } 1552 1553 static int 1554 test_roundrobin_rx_burst_on_single_slave(void) 1555 { 1556 struct rte_mbuf *gen_pkt_burst[MAX_PKT_BURST] = { NULL }; 1557 struct rte_mbuf *rx_pkt_burst[MAX_PKT_BURST] = { NULL }; 1558 1559 struct rte_eth_stats port_stats; 1560 1561 int i, j, burst_size = 25; 1562 1563 /* Initialize bonded device with 4 slaves in round robin mode */ 1564 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 1565 BONDING_MODE_ROUND_ROBIN, 0, 4, 1), 1566 "Failed to initialize bonded device with slaves"); 1567 1568 /* Generate test bursts of packets to transmit */ 1569 TEST_ASSERT_EQUAL(generate_test_burst( 1570 gen_pkt_burst, burst_size, 0, 1, 0, 0, 0), burst_size, 1571 "burst generation failed"); 1572 1573 for (i = 0; i < test_params->bonded_slave_count; i++) { 1574 /* Add rx data to slave */ 1575 virtual_ethdev_add_mbufs_to_rx_queue(test_params->slave_port_ids[i], 1576 &gen_pkt_burst[0], burst_size); 1577 1578 /* Call rx burst on bonded device */ 1579 /* Send burst on bonded port */ 1580 TEST_ASSERT_EQUAL(rte_eth_rx_burst( 1581 test_params->bonded_port_id, 0, rx_pkt_burst, 1582 MAX_PKT_BURST), burst_size, 1583 "round-robin rx burst failed"); 1584 1585 /* Verify bonded device rx count */ 1586 rte_eth_stats_get(test_params->bonded_port_id, &port_stats); 1587 TEST_ASSERT_EQUAL(port_stats.ipackets, (uint64_t)burst_size, 1588 "Bonded Port (%d) ipackets value (%u) not as expected (%d)", 1589 test_params->bonded_port_id, 1590 (unsigned int)port_stats.ipackets, burst_size); 1591 1592 1593 1594 /* Verify bonded slave devices rx count */ 1595 /* Verify slave ports tx stats */ 1596 for (j = 0; j < test_params->bonded_slave_count; j++) { 1597 rte_eth_stats_get(test_params->slave_port_ids[j], &port_stats); 1598 1599 if (i == j) { 1600 TEST_ASSERT_EQUAL(port_stats.ipackets, (uint64_t)burst_size, 1601 "Slave Port (%d) ipackets value (%u) not as expected" 1602 " (%d)", test_params->slave_port_ids[i], 1603 (unsigned int)port_stats.ipackets, burst_size); 1604 } else { 1605 TEST_ASSERT_EQUAL(port_stats.ipackets, 0, 1606 "Slave Port (%d) ipackets value (%u) not as expected" 1607 " (%d)", test_params->slave_port_ids[i], 1608 (unsigned int)port_stats.ipackets, 0); 1609 } 1610 1611 /* Reset bonded slaves stats */ 1612 rte_eth_stats_reset(test_params->slave_port_ids[j]); 1613 } 1614 /* reset bonded device stats */ 1615 rte_eth_stats_reset(test_params->bonded_port_id); 1616 } 1617 1618 /* free mbufs */ 1619 for (i = 0; i < MAX_PKT_BURST; i++) { 1620 if (gen_pkt_burst[i] != NULL) 1621 rte_pktmbuf_free(gen_pkt_burst[i]); 1622 1623 if (rx_pkt_burst[i] != NULL) 1624 rte_pktmbuf_free(rx_pkt_burst[i]); 1625 } 1626 1627 1628 /* Clean up and remove slaves from bonded device */ 1629 return remove_slaves_and_stop_bonded_device(); 1630 } 1631 1632 #define TEST_ROUNDROBIN_TX_BURST_SLAVE_COUNT (3) 1633 1634 static int 1635 test_roundrobin_rx_burst_on_multiple_slaves(void) 1636 { 1637 struct rte_mbuf *gen_pkt_burst[TEST_ROUNDROBIN_TX_BURST_SLAVE_COUNT][MAX_PKT_BURST]; 1638 1639 struct rte_mbuf *rx_pkt_burst[MAX_PKT_BURST] = { NULL }; 1640 struct rte_eth_stats port_stats; 1641 1642 int burst_size[TEST_ROUNDROBIN_TX_BURST_SLAVE_COUNT] = { 15, 13, 36 }; 1643 int i, nb_rx; 1644 1645 /* Initialize bonded device with 4 slaves in round robin mode */ 1646 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 1647 BONDING_MODE_ROUND_ROBIN, 0, 4, 1), 1648 "Failed to initialize bonded device with slaves"); 1649 1650 /* Generate test bursts of packets to transmit */ 1651 for (i = 0; i < TEST_ROUNDROBIN_TX_BURST_SLAVE_COUNT; i++) { 1652 TEST_ASSERT_EQUAL(generate_test_burst( 1653 &gen_pkt_burst[i][0], burst_size[i], 0, 1, 0, 0, 0), 1654 burst_size[i], "burst generation failed"); 1655 } 1656 1657 /* Add rx data to slaves */ 1658 for (i = 0; i < TEST_ROUNDROBIN_TX_BURST_SLAVE_COUNT; i++) { 1659 virtual_ethdev_add_mbufs_to_rx_queue(test_params->slave_port_ids[i], 1660 &gen_pkt_burst[i][0], burst_size[i]); 1661 } 1662 1663 /* Call rx burst on bonded device */ 1664 /* Send burst on bonded port */ 1665 nb_rx = rte_eth_rx_burst(test_params->bonded_port_id, 0, rx_pkt_burst, 1666 MAX_PKT_BURST); 1667 TEST_ASSERT_EQUAL(nb_rx , burst_size[0] + burst_size[1] + burst_size[2], 1668 "round-robin rx burst failed (%d != %d)\n", nb_rx, 1669 burst_size[0] + burst_size[1] + burst_size[2]); 1670 1671 /* Verify bonded device rx count */ 1672 rte_eth_stats_get(test_params->bonded_port_id, &port_stats); 1673 TEST_ASSERT_EQUAL(port_stats.ipackets, 1674 (uint64_t)(burst_size[0] + burst_size[1] + burst_size[2]), 1675 "Bonded Port (%d) ipackets value (%u) not as expected (%d)", 1676 test_params->bonded_port_id, (unsigned int)port_stats.ipackets, 1677 burst_size[0] + burst_size[1] + burst_size[2]); 1678 1679 /* Verify bonded slave devices rx counts */ 1680 rte_eth_stats_get(test_params->slave_port_ids[0], &port_stats); 1681 TEST_ASSERT_EQUAL(port_stats.ipackets, (uint64_t)burst_size[0], 1682 "Slave Port (%d) ipackets value (%u) not as expected (%d)", 1683 test_params->slave_port_ids[0], 1684 (unsigned int)port_stats.ipackets, burst_size[0]); 1685 1686 rte_eth_stats_get(test_params->slave_port_ids[1], &port_stats); 1687 TEST_ASSERT_EQUAL(port_stats.ipackets, (uint64_t)burst_size[1], 1688 "Slave Port (%d) ipackets value (%u) not as expected (%d)", 1689 test_params->slave_port_ids[1], (unsigned int)port_stats.ipackets, 1690 burst_size[1]); 1691 1692 rte_eth_stats_get(test_params->slave_port_ids[2], &port_stats); 1693 TEST_ASSERT_EQUAL(port_stats.ipackets, (uint64_t)burst_size[2], 1694 "Slave Port (%d) ipackets value (%u) not as expected (%d)", 1695 test_params->slave_port_ids[2], 1696 (unsigned int)port_stats.ipackets, burst_size[2]); 1697 1698 rte_eth_stats_get(test_params->slave_port_ids[3], &port_stats); 1699 TEST_ASSERT_EQUAL(port_stats.ipackets, 0, 1700 "Slave Port (%d) ipackets value (%u) not as expected (%d)", 1701 test_params->slave_port_ids[3], 1702 (unsigned int)port_stats.ipackets, 0); 1703 1704 /* free mbufs */ 1705 for (i = 0; i < MAX_PKT_BURST; i++) { 1706 if (rx_pkt_burst[i] != NULL) 1707 rte_pktmbuf_free(rx_pkt_burst[i]); 1708 } 1709 1710 /* Clean up and remove slaves from bonded device */ 1711 return remove_slaves_and_stop_bonded_device(); 1712 } 1713 1714 static int 1715 test_roundrobin_verify_mac_assignment(void) 1716 { 1717 struct ether_addr read_mac_addr, expected_mac_addr_0, expected_mac_addr_2; 1718 1719 int i; 1720 1721 rte_eth_macaddr_get(test_params->slave_port_ids[0], &expected_mac_addr_0); 1722 rte_eth_macaddr_get(test_params->slave_port_ids[2], &expected_mac_addr_2); 1723 1724 /* Initialize bonded device with 4 slaves in round robin mode */ 1725 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 1726 BONDING_MODE_ROUND_ROBIN, 0, 4, 1), 1727 "Failed to initialize bonded device with slaves"); 1728 1729 /* Verify that all MACs are the same as first slave added to bonded dev */ 1730 for (i = 0; i < test_params->bonded_slave_count; i++) { 1731 rte_eth_macaddr_get(test_params->slave_port_ids[i], &read_mac_addr); 1732 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_0, &read_mac_addr, 1733 sizeof(read_mac_addr)), 1734 "slave port (%d) mac address not set to that of primary port", 1735 test_params->slave_port_ids[i]); 1736 } 1737 1738 /* change primary and verify that MAC addresses haven't changed */ 1739 TEST_ASSERT_SUCCESS(rte_eth_bond_primary_set(test_params->bonded_port_id, 1740 test_params->slave_port_ids[2]), 1741 "Failed to set bonded port (%d) primary port to (%d)", 1742 test_params->bonded_port_id, test_params->slave_port_ids[i]); 1743 1744 for (i = 0; i < test_params->bonded_slave_count; i++) { 1745 rte_eth_macaddr_get(test_params->slave_port_ids[i], &read_mac_addr); 1746 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_0, &read_mac_addr, 1747 sizeof(read_mac_addr)), 1748 "slave port (%d) mac address has changed to that of primary" 1749 " port without stop/start toggle of bonded device", 1750 test_params->slave_port_ids[i]); 1751 } 1752 1753 /* stop / start bonded device and verify that primary MAC address is 1754 * propagate to bonded device and slaves */ 1755 rte_eth_dev_stop(test_params->bonded_port_id); 1756 1757 TEST_ASSERT_SUCCESS(rte_eth_dev_start(test_params->bonded_port_id), 1758 "Failed to start bonded device"); 1759 1760 rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr); 1761 TEST_ASSERT_SUCCESS( 1762 memcmp(&expected_mac_addr_2, &read_mac_addr, sizeof(read_mac_addr)), 1763 "bonded port (%d) mac address not set to that of new primary port", 1764 test_params->slave_port_ids[i]); 1765 1766 for (i = 0; i < test_params->bonded_slave_count; i++) { 1767 rte_eth_macaddr_get(test_params->slave_port_ids[i], &read_mac_addr); 1768 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_2, &read_mac_addr, 1769 sizeof(read_mac_addr)), 1770 "slave port (%d) mac address not set to that of new primary" 1771 " port", test_params->slave_port_ids[i]); 1772 } 1773 1774 /* Set explicit MAC address */ 1775 TEST_ASSERT_SUCCESS(rte_eth_bond_mac_address_set( 1776 test_params->bonded_port_id, (struct ether_addr *)bonded_mac), 1777 "Failed to set MAC"); 1778 1779 rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr); 1780 TEST_ASSERT_SUCCESS(memcmp(bonded_mac, &read_mac_addr, 1781 sizeof(read_mac_addr)), 1782 "bonded port (%d) mac address not set to that of new primary port", 1783 test_params->slave_port_ids[i]); 1784 1785 for (i = 0; i < test_params->bonded_slave_count; i++) { 1786 rte_eth_macaddr_get(test_params->slave_port_ids[i], &read_mac_addr); 1787 TEST_ASSERT_SUCCESS(memcmp(bonded_mac, &read_mac_addr, 1788 sizeof(read_mac_addr)), "slave port (%d) mac address not set to" 1789 " that of new primary port\n", test_params->slave_port_ids[i]); 1790 } 1791 1792 /* Clean up and remove slaves from bonded device */ 1793 return remove_slaves_and_stop_bonded_device(); 1794 } 1795 1796 static int 1797 test_roundrobin_verify_promiscuous_enable_disable(void) 1798 { 1799 int i, promiscuous_en; 1800 1801 /* Initialize bonded device with 4 slaves in round robin mode */ 1802 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 1803 BONDING_MODE_ROUND_ROBIN, 0, 4, 1), 1804 "Failed to initialize bonded device with slaves"); 1805 1806 rte_eth_promiscuous_enable(test_params->bonded_port_id); 1807 1808 promiscuous_en = rte_eth_promiscuous_get(test_params->bonded_port_id); 1809 TEST_ASSERT_EQUAL(promiscuous_en, 1, 1810 "Port (%d) promiscuous mode not enabled", 1811 test_params->bonded_port_id); 1812 1813 for (i = 0; i < test_params->bonded_slave_count; i++) { 1814 promiscuous_en = rte_eth_promiscuous_get( 1815 test_params->slave_port_ids[i]); 1816 TEST_ASSERT_EQUAL(promiscuous_en, 1, 1817 "slave port (%d) promiscuous mode not enabled", 1818 test_params->slave_port_ids[i]); 1819 } 1820 1821 rte_eth_promiscuous_disable(test_params->bonded_port_id); 1822 1823 promiscuous_en = rte_eth_promiscuous_get(test_params->bonded_port_id); 1824 TEST_ASSERT_EQUAL(promiscuous_en, 0, 1825 "Port (%d) promiscuous mode not disabled\n", 1826 test_params->bonded_port_id); 1827 1828 for (i = 0; i < test_params->bonded_slave_count; i++) { 1829 promiscuous_en = rte_eth_promiscuous_get( 1830 test_params->slave_port_ids[i]); 1831 TEST_ASSERT_EQUAL(promiscuous_en, 0, 1832 "Port (%d) promiscuous mode not disabled\n", 1833 test_params->slave_port_ids[i]); 1834 } 1835 1836 /* Clean up and remove slaves from bonded device */ 1837 return remove_slaves_and_stop_bonded_device(); 1838 } 1839 1840 #define TEST_RR_LINK_STATUS_SLAVE_COUNT (4) 1841 #define TEST_RR_LINK_STATUS_EXPECTED_ACTIVE_SLAVE_COUNT (2) 1842 1843 static int 1844 test_roundrobin_verify_slave_link_status_change_behaviour(void) 1845 { 1846 struct rte_mbuf *tx_pkt_burst[MAX_PKT_BURST] = { NULL }; 1847 struct rte_mbuf *gen_pkt_burst[TEST_RR_LINK_STATUS_SLAVE_COUNT][MAX_PKT_BURST]; 1848 struct rte_mbuf *rx_pkt_burst[MAX_PKT_BURST] = { NULL }; 1849 1850 struct rte_eth_stats port_stats; 1851 uint8_t slaves[RTE_MAX_ETHPORTS]; 1852 1853 int i, burst_size, slave_count; 1854 1855 /* NULL all pointers in array to simplify cleanup */ 1856 memset(gen_pkt_burst, 0, sizeof(gen_pkt_burst)); 1857 1858 /* Initialize bonded device with TEST_RR_LINK_STATUS_SLAVE_COUNT slaves 1859 * in round robin mode */ 1860 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 1861 BONDING_MODE_ROUND_ROBIN, 0, TEST_RR_LINK_STATUS_SLAVE_COUNT, 1), 1862 "Failed to initialize bonded device with slaves"); 1863 1864 /* Verify Current Slaves Count /Active Slave Count is */ 1865 slave_count = rte_eth_bond_slaves_get(test_params->bonded_port_id, slaves, 1866 RTE_MAX_ETHPORTS); 1867 TEST_ASSERT_EQUAL(slave_count, TEST_RR_LINK_STATUS_SLAVE_COUNT, 1868 "Number of slaves (%d) is not as expected (%d).", 1869 slave_count, TEST_RR_LINK_STATUS_SLAVE_COUNT); 1870 1871 slave_count = rte_eth_bond_active_slaves_get(test_params->bonded_port_id, 1872 slaves, RTE_MAX_ETHPORTS); 1873 TEST_ASSERT_EQUAL(slave_count, TEST_RR_LINK_STATUS_SLAVE_COUNT, 1874 "Number of active slaves (%d) is not as expected (%d).", 1875 slave_count, TEST_RR_LINK_STATUS_SLAVE_COUNT); 1876 1877 /* Set 2 slaves eth_devs link status to down */ 1878 virtual_ethdev_simulate_link_status_interrupt( 1879 test_params->slave_port_ids[1], 0); 1880 virtual_ethdev_simulate_link_status_interrupt( 1881 test_params->slave_port_ids[3], 0); 1882 1883 slave_count = rte_eth_bond_active_slaves_get(test_params->bonded_port_id, 1884 slaves, RTE_MAX_ETHPORTS); 1885 TEST_ASSERT_EQUAL(slave_count, 1886 TEST_RR_LINK_STATUS_EXPECTED_ACTIVE_SLAVE_COUNT, 1887 "Number of active slaves (%d) is not as expected (%d).\n", 1888 slave_count, TEST_RR_LINK_STATUS_EXPECTED_ACTIVE_SLAVE_COUNT); 1889 1890 burst_size = 20; 1891 1892 /* Verify that pkts are not sent on slaves with link status down: 1893 * 1894 * 1. Generate test burst of traffic 1895 * 2. Transmit burst on bonded eth_dev 1896 * 3. Verify stats for bonded eth_dev (opackets = burst_size) 1897 * 4. Verify stats for slave eth_devs (s0 = 10, s1 = 0, s2 = 10, s3 = 0) 1898 */ 1899 TEST_ASSERT_EQUAL( 1900 generate_test_burst(tx_pkt_burst, burst_size, 0, 1, 0, 0, 0), 1901 burst_size, "generate_test_burst failed"); 1902 1903 rte_eth_stats_reset(test_params->bonded_port_id); 1904 1905 1906 TEST_ASSERT_EQUAL( 1907 rte_eth_tx_burst(test_params->bonded_port_id, 0, tx_pkt_burst, 1908 burst_size), burst_size, "rte_eth_tx_burst failed"); 1909 1910 rte_eth_stats_get(test_params->bonded_port_id, &port_stats); 1911 TEST_ASSERT_EQUAL(port_stats.opackets, (uint64_t)burst_size, 1912 "Port (%d) opackets stats (%d) not expected (%d) value", 1913 test_params->bonded_port_id, (int)port_stats.opackets, 1914 burst_size); 1915 1916 rte_eth_stats_get(test_params->slave_port_ids[0], &port_stats); 1917 TEST_ASSERT_EQUAL(port_stats.opackets, (uint64_t)10, 1918 "Port (%d) opackets stats (%d) not expected (%d) value", 1919 test_params->slave_port_ids[0], (int)port_stats.opackets, 10); 1920 1921 rte_eth_stats_get(test_params->slave_port_ids[1], &port_stats); 1922 TEST_ASSERT_EQUAL(port_stats.opackets, (uint64_t)0, 1923 "Port (%d) opackets stats (%d) not expected (%d) value", 1924 test_params->slave_port_ids[1], (int)port_stats.opackets, 0); 1925 1926 rte_eth_stats_get(test_params->slave_port_ids[2], &port_stats); 1927 TEST_ASSERT_EQUAL(port_stats.opackets, (uint64_t)10, 1928 "Port (%d) opackets stats (%d) not expected (%d) value", 1929 test_params->slave_port_ids[2], (int)port_stats.opackets, 10); 1930 1931 rte_eth_stats_get(test_params->slave_port_ids[3], &port_stats); 1932 TEST_ASSERT_EQUAL(port_stats.opackets, (uint64_t)0, 1933 "Port (%d) opackets stats (%d) not expected (%d) value", 1934 test_params->slave_port_ids[3], (int)port_stats.opackets, 0); 1935 1936 /* Verify that pkts are not sent on slaves with link status down: 1937 * 1938 * 1. Generate test bursts of traffic 1939 * 2. Add bursts on to virtual eth_devs 1940 * 3. Rx burst on bonded eth_dev, expected (burst_ size * 1941 * TEST_RR_LINK_STATUS_EXPECTED_ACTIVE_SLAVE_COUNT) received 1942 * 4. Verify stats for bonded eth_dev 1943 * 6. Verify stats for slave eth_devs (s0 = 10, s1 = 0, s2 = 10, s3 = 0) 1944 */ 1945 for (i = 0; i < TEST_RR_LINK_STATUS_SLAVE_COUNT; i++) { 1946 TEST_ASSERT_EQUAL(generate_test_burst( 1947 &gen_pkt_burst[i][0], burst_size, 0, 1, 0, 0, 0), 1948 burst_size, "failed to generate packet burst"); 1949 1950 virtual_ethdev_add_mbufs_to_rx_queue(test_params->slave_port_ids[i], 1951 &gen_pkt_burst[i][0], burst_size); 1952 } 1953 1954 TEST_ASSERT_EQUAL(rte_eth_rx_burst( 1955 test_params->bonded_port_id, 0, rx_pkt_burst, MAX_PKT_BURST), 1956 burst_size + burst_size, 1957 "rte_eth_rx_burst failed"); 1958 1959 /* Verify bonded device rx count */ 1960 rte_eth_stats_get(test_params->bonded_port_id, &port_stats); 1961 TEST_ASSERT_EQUAL(port_stats.ipackets , (uint64_t)(burst_size + burst_size), 1962 "(%d) port_stats.ipackets not as expected\n", 1963 test_params->bonded_port_id); 1964 1965 /* free mbufs */ 1966 for (i = 0; i < MAX_PKT_BURST; i++) { 1967 if (rx_pkt_burst[i] != NULL) 1968 rte_pktmbuf_free(rx_pkt_burst[i]); 1969 1970 if (gen_pkt_burst[1][i] != NULL) 1971 rte_pktmbuf_free(gen_pkt_burst[1][i]); 1972 1973 if (gen_pkt_burst[3][i] != NULL) 1974 rte_pktmbuf_free(gen_pkt_burst[1][i]); 1975 } 1976 1977 /* Clean up and remove slaves from bonded device */ 1978 return remove_slaves_and_stop_bonded_device(); 1979 } 1980 1981 #define TEST_RR_POLLING_LINK_STATUS_SLAVE_COUNT (2) 1982 1983 uint8_t polling_slave_mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x00 }; 1984 1985 1986 int polling_test_slaves[TEST_RR_POLLING_LINK_STATUS_SLAVE_COUNT] = { -1, -1 }; 1987 1988 static int 1989 test_roundrobin_verfiy_polling_slave_link_status_change(void) 1990 { 1991 struct ether_addr *mac_addr = (struct ether_addr *)polling_slave_mac; 1992 char slave_name[RTE_ETH_NAME_MAX_LEN]; 1993 1994 int i; 1995 1996 for (i = 0; i < TEST_RR_POLLING_LINK_STATUS_SLAVE_COUNT; i++) { 1997 /* Generate slave name / MAC address */ 1998 snprintf(slave_name, RTE_ETH_NAME_MAX_LEN, "eth_virt_poll_%d", i); 1999 mac_addr->addr_bytes[ETHER_ADDR_LEN-1] = i; 2000 2001 /* Create slave devices with no ISR Support */ 2002 if (polling_test_slaves[i] == -1) { 2003 polling_test_slaves[i] = virtual_ethdev_create(slave_name, mac_addr, 2004 rte_socket_id(), 0); 2005 TEST_ASSERT(polling_test_slaves[i] >= 0, 2006 "Failed to create virtual virtual ethdev %s\n", slave_name); 2007 2008 /* Configure slave */ 2009 TEST_ASSERT_SUCCESS(configure_ethdev(polling_test_slaves[i], 0, 0), 2010 "Failed to configure virtual ethdev %s(%d)", slave_name, 2011 polling_test_slaves[i]); 2012 } 2013 2014 /* Add slave to bonded device */ 2015 TEST_ASSERT_SUCCESS(rte_eth_bond_slave_add(test_params->bonded_port_id, 2016 polling_test_slaves[i]), 2017 "Failed to add slave %s(%d) to bonded device %d", 2018 slave_name, polling_test_slaves[i], 2019 test_params->bonded_port_id); 2020 } 2021 2022 /* Initialize bonded device */ 2023 TEST_ASSERT_SUCCESS(configure_ethdev(test_params->bonded_port_id, 1, 1), 2024 "Failed to configure bonded device %d", 2025 test_params->bonded_port_id); 2026 2027 2028 /* Register link status change interrupt callback */ 2029 rte_eth_dev_callback_register(test_params->bonded_port_id, 2030 RTE_ETH_EVENT_INTR_LSC, test_bonding_lsc_event_callback, 2031 &test_params->bonded_port_id); 2032 2033 /* link status change callback for first slave link up */ 2034 test_lsc_interrupt_count = 0; 2035 2036 virtual_ethdev_set_link_status(polling_test_slaves[0], 1); 2037 2038 TEST_ASSERT_SUCCESS(lsc_timeout(15000), "timed out waiting for interrupt"); 2039 2040 2041 /* no link status change callback for second slave link up */ 2042 test_lsc_interrupt_count = 0; 2043 2044 virtual_ethdev_set_link_status(polling_test_slaves[1], 1); 2045 2046 TEST_ASSERT_FAIL(lsc_timeout(15000), "unexpectedly succeeded"); 2047 2048 /* link status change callback for both slave links down */ 2049 test_lsc_interrupt_count = 0; 2050 2051 virtual_ethdev_set_link_status(polling_test_slaves[0], 0); 2052 virtual_ethdev_set_link_status(polling_test_slaves[1], 0); 2053 2054 TEST_ASSERT_SUCCESS(lsc_timeout(20000), "timed out waiting for interrupt"); 2055 2056 /* Un-Register link status change interrupt callback */ 2057 rte_eth_dev_callback_unregister(test_params->bonded_port_id, 2058 RTE_ETH_EVENT_INTR_LSC, test_bonding_lsc_event_callback, 2059 &test_params->bonded_port_id); 2060 2061 2062 /* Clean up and remove slaves from bonded device */ 2063 for (i = 0; i < TEST_RR_POLLING_LINK_STATUS_SLAVE_COUNT; i++) { 2064 2065 TEST_ASSERT_SUCCESS( 2066 rte_eth_bond_slave_remove(test_params->bonded_port_id, 2067 polling_test_slaves[i]), 2068 "Failed to remove slave %d from bonded port (%d)", 2069 polling_test_slaves[i], test_params->bonded_port_id); 2070 } 2071 2072 return remove_slaves_and_stop_bonded_device(); 2073 } 2074 2075 2076 /** Active Backup Mode Tests */ 2077 2078 static int 2079 test_activebackup_tx_burst(void) 2080 { 2081 int i, pktlen, primary_port, burst_size; 2082 struct rte_mbuf *pkts_burst[MAX_PKT_BURST]; 2083 struct rte_eth_stats port_stats; 2084 2085 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 2086 BONDING_MODE_ACTIVE_BACKUP, 0, 1, 1), 2087 "Failed to initialize bonded device with slaves"); 2088 2089 initialize_eth_header(test_params->pkt_eth_hdr, 2090 (struct ether_addr *)src_mac, (struct ether_addr *)dst_mac_0, 2091 ETHER_TYPE_IPv4, 0, 0); 2092 pktlen = initialize_udp_header(test_params->pkt_udp_hdr, src_port, 2093 dst_port_0, 16); 2094 pktlen = initialize_ipv4_header(test_params->pkt_ipv4_hdr, src_addr, 2095 dst_addr_0, pktlen); 2096 2097 burst_size = 20 * test_params->bonded_slave_count; 2098 2099 TEST_ASSERT(burst_size < MAX_PKT_BURST, 2100 "Burst size specified is greater than supported."); 2101 2102 /* Generate a burst of packets to transmit */ 2103 TEST_ASSERT_EQUAL(generate_packet_burst(test_params->mbuf_pool, pkts_burst, 2104 test_params->pkt_eth_hdr, 0, test_params->pkt_ipv4_hdr, 1, 2105 test_params->pkt_udp_hdr, burst_size, PACKET_BURST_GEN_PKT_LEN, 1), 2106 burst_size, "failed to generate burst correctly"); 2107 2108 /* Send burst on bonded port */ 2109 TEST_ASSERT_EQUAL(rte_eth_tx_burst(test_params->bonded_port_id, 0, pkts_burst, 2110 burst_size), burst_size, "tx burst failed"); 2111 2112 /* Verify bonded port tx stats */ 2113 rte_eth_stats_get(test_params->bonded_port_id, &port_stats); 2114 TEST_ASSERT_EQUAL(port_stats.opackets, (uint64_t)burst_size, 2115 "Bonded Port (%d) opackets value (%u) not as expected (%d)", 2116 test_params->bonded_port_id, (unsigned int)port_stats.opackets, 2117 burst_size); 2118 2119 primary_port = rte_eth_bond_primary_get(test_params->bonded_port_id); 2120 2121 /* Verify slave ports tx stats */ 2122 for (i = 0; i < test_params->bonded_slave_count; i++) { 2123 rte_eth_stats_get(test_params->slave_port_ids[i], &port_stats); 2124 if (test_params->slave_port_ids[i] == primary_port) { 2125 TEST_ASSERT_EQUAL(port_stats.opackets, (uint64_t)burst_size, 2126 "Slave Port (%d) opackets value (%u) not as expected (%d)", 2127 test_params->bonded_port_id, 2128 (unsigned int)port_stats.opackets, 2129 burst_size / test_params->bonded_slave_count); 2130 } else { 2131 TEST_ASSERT_EQUAL(port_stats.opackets, 0, 2132 "Slave Port (%d) opackets value (%u) not as expected (%d)", 2133 test_params->bonded_port_id, 2134 (unsigned int)port_stats.opackets, 0); 2135 } 2136 } 2137 2138 /* Put all slaves down and try and transmit */ 2139 for (i = 0; i < test_params->bonded_slave_count; i++) { 2140 virtual_ethdev_simulate_link_status_interrupt( 2141 test_params->slave_port_ids[i], 0); 2142 } 2143 2144 /* Send burst on bonded port */ 2145 TEST_ASSERT_EQUAL(rte_eth_tx_burst(test_params->bonded_port_id, 0, 2146 pkts_burst, burst_size), 0, "Sending empty burst failed"); 2147 2148 /* Clean up and remove slaves from bonded device */ 2149 return remove_slaves_and_stop_bonded_device(); 2150 } 2151 2152 #define TEST_ACTIVE_BACKUP_RX_BURST_SLAVE_COUNT (4) 2153 2154 static int 2155 test_activebackup_rx_burst(void) 2156 { 2157 struct rte_mbuf *gen_pkt_burst[MAX_PKT_BURST] = { NULL }; 2158 struct rte_mbuf *rx_pkt_burst[MAX_PKT_BURST] = { NULL }; 2159 2160 struct rte_eth_stats port_stats; 2161 2162 int primary_port; 2163 2164 int i, j, burst_size = 17; 2165 2166 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 2167 BONDING_MODE_ACTIVE_BACKUP, 0, 2168 TEST_ACTIVE_BACKUP_RX_BURST_SLAVE_COUNT, 1), 2169 "Failed to initialize bonded device with slaves"); 2170 2171 primary_port = rte_eth_bond_primary_get(test_params->bonded_port_id); 2172 TEST_ASSERT(primary_port >= 0, 2173 "failed to get primary slave for bonded port (%d)", 2174 test_params->bonded_port_id); 2175 2176 for (i = 0; i < test_params->bonded_slave_count; i++) { 2177 /* Generate test bursts of packets to transmit */ 2178 TEST_ASSERT_EQUAL(generate_test_burst( 2179 &gen_pkt_burst[0], burst_size, 0, 1, 0, 0, 0), 2180 burst_size, "burst generation failed"); 2181 2182 /* Add rx data to slave */ 2183 virtual_ethdev_add_mbufs_to_rx_queue(test_params->slave_port_ids[i], 2184 &gen_pkt_burst[0], burst_size); 2185 2186 /* Call rx burst on bonded device */ 2187 TEST_ASSERT_EQUAL(rte_eth_rx_burst(test_params->bonded_port_id, 0, 2188 &rx_pkt_burst[0], MAX_PKT_BURST), burst_size, 2189 "rte_eth_rx_burst failed"); 2190 2191 if (test_params->slave_port_ids[i] == primary_port) { 2192 /* Verify bonded device rx count */ 2193 rte_eth_stats_get(test_params->bonded_port_id, &port_stats); 2194 TEST_ASSERT_EQUAL(port_stats.ipackets, (uint64_t)burst_size, 2195 "Bonded Port (%d) ipackets value (%u) not as expected (%d)", 2196 test_params->bonded_port_id, 2197 (unsigned int)port_stats.ipackets, burst_size); 2198 2199 /* Verify bonded slave devices rx count */ 2200 for (j = 0; j < test_params->bonded_slave_count; j++) { 2201 rte_eth_stats_get(test_params->slave_port_ids[j], &port_stats); 2202 if (i == j) { 2203 TEST_ASSERT_EQUAL(port_stats.ipackets, (uint64_t)burst_size, 2204 "Slave Port (%d) ipackets value (%u) not as " 2205 "expected (%d)", test_params->slave_port_ids[i], 2206 (unsigned int)port_stats.ipackets, burst_size); 2207 } else { 2208 TEST_ASSERT_EQUAL(port_stats.ipackets, 0, 2209 "Slave Port (%d) ipackets value (%u) not as " 2210 "expected (%d)\n", test_params->slave_port_ids[i], 2211 (unsigned int)port_stats.ipackets, 0); 2212 } 2213 } 2214 } else { 2215 for (j = 0; j < test_params->bonded_slave_count; j++) { 2216 rte_eth_stats_get(test_params->slave_port_ids[j], &port_stats); 2217 TEST_ASSERT_EQUAL(port_stats.ipackets, 0, 2218 "Slave Port (%d) ipackets value (%u) not as expected " 2219 "(%d)", test_params->slave_port_ids[i], 2220 (unsigned int)port_stats.ipackets, 0); 2221 } 2222 } 2223 2224 /* free mbufs */ 2225 for (i = 0; i < MAX_PKT_BURST; i++) { 2226 if (rx_pkt_burst[i] != NULL) { 2227 rte_pktmbuf_free(rx_pkt_burst[i]); 2228 rx_pkt_burst[i] = NULL; 2229 } 2230 } 2231 2232 /* reset bonded device stats */ 2233 rte_eth_stats_reset(test_params->bonded_port_id); 2234 } 2235 2236 /* Clean up and remove slaves from bonded device */ 2237 return remove_slaves_and_stop_bonded_device(); 2238 } 2239 2240 static int 2241 test_activebackup_verify_promiscuous_enable_disable(void) 2242 { 2243 int i, primary_port, promiscuous_en; 2244 2245 /* Initialize bonded device with 4 slaves in round robin mode */ 2246 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 2247 BONDING_MODE_ACTIVE_BACKUP, 0, 4, 1), 2248 "Failed to initialize bonded device with slaves"); 2249 2250 primary_port = rte_eth_bond_primary_get(test_params->bonded_port_id); 2251 TEST_ASSERT(primary_port >= 0, 2252 "failed to get primary slave for bonded port (%d)", 2253 test_params->bonded_port_id); 2254 2255 rte_eth_promiscuous_enable(test_params->bonded_port_id); 2256 2257 TEST_ASSERT_EQUAL(rte_eth_promiscuous_get(test_params->bonded_port_id), 1, 2258 "Port (%d) promiscuous mode not enabled", 2259 test_params->bonded_port_id); 2260 2261 for (i = 0; i < test_params->bonded_slave_count; i++) { 2262 promiscuous_en = rte_eth_promiscuous_get( 2263 test_params->slave_port_ids[i]); 2264 if (primary_port == test_params->slave_port_ids[i]) { 2265 TEST_ASSERT_EQUAL(promiscuous_en, 1, 2266 "slave port (%d) promiscuous mode not enabled", 2267 test_params->slave_port_ids[i]); 2268 } else { 2269 TEST_ASSERT_EQUAL(promiscuous_en, 0, 2270 "slave port (%d) promiscuous mode enabled", 2271 test_params->slave_port_ids[i]); 2272 } 2273 2274 } 2275 2276 rte_eth_promiscuous_disable(test_params->bonded_port_id); 2277 2278 TEST_ASSERT_EQUAL(rte_eth_promiscuous_get(test_params->bonded_port_id), 0, 2279 "Port (%d) promiscuous mode not disabled\n", 2280 test_params->bonded_port_id); 2281 2282 for (i = 0; i < test_params->bonded_slave_count; i++) { 2283 promiscuous_en = rte_eth_promiscuous_get( 2284 test_params->slave_port_ids[i]); 2285 TEST_ASSERT_EQUAL(promiscuous_en, 0, 2286 "slave port (%d) promiscuous mode not disabled\n", 2287 test_params->slave_port_ids[i]); 2288 } 2289 2290 /* Clean up and remove slaves from bonded device */ 2291 return remove_slaves_and_stop_bonded_device(); 2292 } 2293 2294 static int 2295 test_activebackup_verify_mac_assignment(void) 2296 { 2297 struct ether_addr read_mac_addr, expected_mac_addr_0, expected_mac_addr_1; 2298 2299 rte_eth_macaddr_get(test_params->slave_port_ids[0], &expected_mac_addr_0); 2300 rte_eth_macaddr_get(test_params->slave_port_ids[1], &expected_mac_addr_1); 2301 2302 /* Initialize bonded device with 2 slaves in active backup mode */ 2303 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 2304 BONDING_MODE_ACTIVE_BACKUP, 0, 2, 1), 2305 "Failed to initialize bonded device with slaves"); 2306 2307 /* Verify that bonded MACs is that of first slave and that the other slave 2308 * MAC hasn't been changed */ 2309 rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr); 2310 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_0, &read_mac_addr, 2311 sizeof(read_mac_addr)), 2312 "bonded port (%d) mac address not set to that of primary port", 2313 test_params->bonded_port_id); 2314 2315 rte_eth_macaddr_get(test_params->slave_port_ids[0], &read_mac_addr); 2316 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_0, &read_mac_addr, 2317 sizeof(read_mac_addr)), 2318 "slave port (%d) mac address not set to that of primary port", 2319 test_params->slave_port_ids[0]); 2320 2321 rte_eth_macaddr_get(test_params->slave_port_ids[1], &read_mac_addr); 2322 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_1, &read_mac_addr, 2323 sizeof(read_mac_addr)), 2324 "slave port (%d) mac address not as expected", 2325 test_params->slave_port_ids[1]); 2326 2327 /* change primary and verify that MAC addresses haven't changed */ 2328 TEST_ASSERT_EQUAL(rte_eth_bond_primary_set(test_params->bonded_port_id, 2329 test_params->slave_port_ids[1]), 0, 2330 "Failed to set bonded port (%d) primary port to (%d)", 2331 test_params->bonded_port_id, test_params->slave_port_ids[1]); 2332 2333 rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr); 2334 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_0, &read_mac_addr, 2335 sizeof(read_mac_addr)), 2336 "bonded port (%d) mac address not set to that of primary port", 2337 test_params->bonded_port_id); 2338 2339 rte_eth_macaddr_get(test_params->slave_port_ids[0], &read_mac_addr); 2340 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_0, &read_mac_addr, 2341 sizeof(read_mac_addr)), 2342 "slave port (%d) mac address not set to that of primary port", 2343 test_params->slave_port_ids[0]); 2344 2345 rte_eth_macaddr_get(test_params->slave_port_ids[1], &read_mac_addr); 2346 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_1, &read_mac_addr, 2347 sizeof(read_mac_addr)), 2348 "slave port (%d) mac address not as expected", 2349 test_params->slave_port_ids[1]); 2350 2351 /* stop / start bonded device and verify that primary MAC address is 2352 * propagated to bonded device and slaves */ 2353 2354 rte_eth_dev_stop(test_params->bonded_port_id); 2355 2356 TEST_ASSERT_SUCCESS(rte_eth_dev_start(test_params->bonded_port_id), 2357 "Failed to start device"); 2358 2359 rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr); 2360 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_1, &read_mac_addr, 2361 sizeof(read_mac_addr)), 2362 "bonded port (%d) mac address not set to that of primary port", 2363 test_params->bonded_port_id); 2364 2365 rte_eth_macaddr_get(test_params->slave_port_ids[0], &read_mac_addr); 2366 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_0, &read_mac_addr, 2367 sizeof(read_mac_addr)), 2368 "slave port (%d) mac address not as expected", 2369 test_params->slave_port_ids[0]); 2370 2371 rte_eth_macaddr_get(test_params->slave_port_ids[1], &read_mac_addr); 2372 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_1, &read_mac_addr, 2373 sizeof(read_mac_addr)), 2374 "slave port (%d) mac address not set to that of primary port", 2375 test_params->slave_port_ids[1]); 2376 2377 /* Set explicit MAC address */ 2378 TEST_ASSERT_SUCCESS(rte_eth_bond_mac_address_set( 2379 test_params->bonded_port_id, (struct ether_addr *)bonded_mac), 2380 "failed to set MAC address"); 2381 2382 rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr); 2383 TEST_ASSERT_SUCCESS(memcmp(&bonded_mac, &read_mac_addr, 2384 sizeof(read_mac_addr)), 2385 "bonded port (%d) mac address not set to that of bonded port", 2386 test_params->bonded_port_id); 2387 2388 rte_eth_macaddr_get(test_params->slave_port_ids[0], &read_mac_addr); 2389 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_0, &read_mac_addr, 2390 sizeof(read_mac_addr)), 2391 "slave port (%d) mac address not as expected", 2392 test_params->slave_port_ids[0]); 2393 2394 rte_eth_macaddr_get(test_params->slave_port_ids[1], &read_mac_addr); 2395 TEST_ASSERT_SUCCESS(memcmp(&bonded_mac, &read_mac_addr, 2396 sizeof(read_mac_addr)), 2397 "slave port (%d) mac address not set to that of bonded port", 2398 test_params->slave_port_ids[1]); 2399 2400 /* Clean up and remove slaves from bonded device */ 2401 return remove_slaves_and_stop_bonded_device(); 2402 } 2403 2404 static int 2405 test_activebackup_verify_slave_link_status_change_failover(void) 2406 { 2407 struct rte_mbuf *pkt_burst[TEST_ACTIVE_BACKUP_RX_BURST_SLAVE_COUNT][MAX_PKT_BURST]; 2408 struct rte_mbuf *rx_pkt_burst[MAX_PKT_BURST] = { NULL }; 2409 struct rte_eth_stats port_stats; 2410 2411 uint8_t slaves[RTE_MAX_ETHPORTS]; 2412 2413 int i, j, burst_size, slave_count, primary_port; 2414 2415 burst_size = 21; 2416 2417 memset(pkt_burst, 0, sizeof(pkt_burst)); 2418 2419 /* Generate packet burst for testing */ 2420 TEST_ASSERT_EQUAL(generate_test_burst( 2421 &pkt_burst[0][0], burst_size, 0, 1, 0, 0, 0), burst_size, 2422 "generate_test_burst failed"); 2423 2424 /* Initialize bonded device with 4 slaves in round robin mode */ 2425 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 2426 BONDING_MODE_ACTIVE_BACKUP, 0, 2427 TEST_ACTIVE_BACKUP_RX_BURST_SLAVE_COUNT, 1), 2428 "Failed to initialize bonded device with slaves"); 2429 2430 /* Verify Current Slaves Count /Active Slave Count is */ 2431 slave_count = rte_eth_bond_slaves_get(test_params->bonded_port_id, slaves, 2432 RTE_MAX_ETHPORTS); 2433 TEST_ASSERT_EQUAL(slave_count, 4, 2434 "Number of slaves (%d) is not as expected (%d).", 2435 slave_count, 4); 2436 2437 slave_count = rte_eth_bond_active_slaves_get(test_params->bonded_port_id, 2438 slaves, RTE_MAX_ETHPORTS); 2439 TEST_ASSERT_EQUAL(slave_count, 4, 2440 "Number of active slaves (%d) is not as expected (%d).", 2441 slave_count, 4); 2442 2443 primary_port = rte_eth_bond_primary_get(test_params->bonded_port_id); 2444 TEST_ASSERT_EQUAL(primary_port, test_params->slave_port_ids[0], 2445 "Primary port not as expected"); 2446 2447 /* Bring 2 slaves down and verify active slave count */ 2448 virtual_ethdev_simulate_link_status_interrupt( 2449 test_params->slave_port_ids[1], 0); 2450 virtual_ethdev_simulate_link_status_interrupt( 2451 test_params->slave_port_ids[3], 0); 2452 2453 TEST_ASSERT_EQUAL(rte_eth_bond_active_slaves_get( 2454 test_params->bonded_port_id, slaves, RTE_MAX_ETHPORTS), 2, 2455 "Number of active slaves (%d) is not as expected (%d).", 2456 slave_count, 2); 2457 2458 virtual_ethdev_simulate_link_status_interrupt( 2459 test_params->slave_port_ids[1], 1); 2460 virtual_ethdev_simulate_link_status_interrupt( 2461 test_params->slave_port_ids[3], 1); 2462 2463 2464 /* Bring primary port down, verify that active slave count is 3 and primary 2465 * has changed */ 2466 virtual_ethdev_simulate_link_status_interrupt( 2467 test_params->slave_port_ids[0], 0); 2468 2469 TEST_ASSERT_EQUAL(rte_eth_bond_active_slaves_get( 2470 test_params->bonded_port_id, slaves, RTE_MAX_ETHPORTS), 2471 3, 2472 "Number of active slaves (%d) is not as expected (%d).", 2473 slave_count, 3); 2474 2475 primary_port = rte_eth_bond_primary_get(test_params->bonded_port_id); 2476 TEST_ASSERT_EQUAL(primary_port, test_params->slave_port_ids[2], 2477 "Primary port not as expected"); 2478 2479 /* Verify that pkts are sent on new primary slave */ 2480 2481 TEST_ASSERT_EQUAL(rte_eth_tx_burst( 2482 test_params->bonded_port_id, 0, &pkt_burst[0][0], 2483 burst_size), burst_size, "rte_eth_tx_burst failed"); 2484 2485 rte_eth_stats_get(test_params->slave_port_ids[2], &port_stats); 2486 TEST_ASSERT_EQUAL(port_stats.opackets, (uint64_t)burst_size, 2487 "(%d) port_stats.opackets not as expected", 2488 test_params->slave_port_ids[2]); 2489 2490 rte_eth_stats_get(test_params->slave_port_ids[0], &port_stats); 2491 TEST_ASSERT_EQUAL(port_stats.opackets, 0, 2492 "(%d) port_stats.opackets not as expected\n", 2493 test_params->slave_port_ids[0]); 2494 2495 rte_eth_stats_get(test_params->slave_port_ids[1], &port_stats); 2496 TEST_ASSERT_EQUAL(port_stats.opackets, 0, 2497 "(%d) port_stats.opackets not as expected\n", 2498 test_params->slave_port_ids[1]); 2499 2500 rte_eth_stats_get(test_params->slave_port_ids[3], &port_stats); 2501 TEST_ASSERT_EQUAL(port_stats.opackets, 0, 2502 "(%d) port_stats.opackets not as expected\n", 2503 test_params->slave_port_ids[3]); 2504 2505 /* Generate packet burst for testing */ 2506 2507 for (i = 0; i < TEST_ACTIVE_BACKUP_RX_BURST_SLAVE_COUNT; i++) { 2508 TEST_ASSERT_EQUAL(generate_test_burst( 2509 &pkt_burst[i][0], burst_size, 0, 1, 0, 0, 0), burst_size, 2510 "generate_test_burst failed"); 2511 2512 virtual_ethdev_add_mbufs_to_rx_queue( 2513 test_params->slave_port_ids[i], &pkt_burst[i][0], burst_size); 2514 } 2515 2516 TEST_ASSERT_EQUAL(rte_eth_rx_burst( 2517 test_params->bonded_port_id, 0, rx_pkt_burst, MAX_PKT_BURST), 2518 burst_size, "rte_eth_rx_burst\n"); 2519 2520 /* Verify bonded device rx count */ 2521 rte_eth_stats_get(test_params->bonded_port_id, &port_stats); 2522 TEST_ASSERT_EQUAL(port_stats.ipackets, (uint64_t)burst_size, 2523 "(%d) port_stats.ipackets not as expected", 2524 test_params->bonded_port_id); 2525 2526 rte_eth_stats_get(test_params->slave_port_ids[2], &port_stats); 2527 TEST_ASSERT_EQUAL(port_stats.opackets, (uint64_t)burst_size, 2528 "(%d) port_stats.opackets not as expected", 2529 test_params->slave_port_ids[2]); 2530 2531 rte_eth_stats_get(test_params->slave_port_ids[0], &port_stats); 2532 TEST_ASSERT_EQUAL(port_stats.opackets, 0, 2533 "(%d) port_stats.opackets not as expected", 2534 test_params->slave_port_ids[0]); 2535 2536 rte_eth_stats_get(test_params->slave_port_ids[1], &port_stats); 2537 TEST_ASSERT_EQUAL(port_stats.opackets, 0, 2538 "(%d) port_stats.opackets not as expected", 2539 test_params->slave_port_ids[1]); 2540 2541 rte_eth_stats_get(test_params->slave_port_ids[3], &port_stats); 2542 TEST_ASSERT_EQUAL(port_stats.opackets, 0, 2543 "(%d) port_stats.opackets not as expected", 2544 test_params->slave_port_ids[3]); 2545 2546 /* free mbufs */ 2547 for (i = 0; i < TEST_ACTIVE_BACKUP_RX_BURST_SLAVE_COUNT; i++) { 2548 for (j = 0; j < MAX_PKT_BURST; j++) { 2549 if (pkt_burst[i][j] != NULL) { 2550 rte_pktmbuf_free(pkt_burst[i][j]); 2551 pkt_burst[i][j] = NULL; 2552 } 2553 } 2554 } 2555 2556 /* Clean up and remove slaves from bonded device */ 2557 return remove_slaves_and_stop_bonded_device(); 2558 } 2559 2560 /** Balance Mode Tests */ 2561 2562 static int 2563 test_balance_xmit_policy_configuration(void) 2564 { 2565 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 2566 BONDING_MODE_ACTIVE_BACKUP, 0, 2, 1), 2567 "Failed to initialize_bonded_device_with_slaves."); 2568 2569 /* Invalid port id */ 2570 TEST_ASSERT_FAIL(rte_eth_bond_xmit_policy_set( 2571 INVALID_PORT_ID, BALANCE_XMIT_POLICY_LAYER2), 2572 "Expected call to failed as invalid port specified."); 2573 2574 /* Set xmit policy on non bonded device */ 2575 TEST_ASSERT_FAIL(rte_eth_bond_xmit_policy_set( 2576 test_params->slave_port_ids[0], BALANCE_XMIT_POLICY_LAYER2), 2577 "Expected call to failed as invalid port specified."); 2578 2579 2580 TEST_ASSERT_SUCCESS(rte_eth_bond_xmit_policy_set( 2581 test_params->bonded_port_id, BALANCE_XMIT_POLICY_LAYER2), 2582 "Failed to set balance xmit policy."); 2583 2584 TEST_ASSERT_EQUAL(rte_eth_bond_xmit_policy_get(test_params->bonded_port_id), 2585 BALANCE_XMIT_POLICY_LAYER2, "balance xmit policy not as expected."); 2586 2587 2588 TEST_ASSERT_SUCCESS(rte_eth_bond_xmit_policy_set( 2589 test_params->bonded_port_id, BALANCE_XMIT_POLICY_LAYER23), 2590 "Failed to set balance xmit policy."); 2591 2592 TEST_ASSERT_EQUAL(rte_eth_bond_xmit_policy_get(test_params->bonded_port_id), 2593 BALANCE_XMIT_POLICY_LAYER23, 2594 "balance xmit policy not as expected."); 2595 2596 2597 TEST_ASSERT_SUCCESS(rte_eth_bond_xmit_policy_set( 2598 test_params->bonded_port_id, BALANCE_XMIT_POLICY_LAYER34), 2599 "Failed to set balance xmit policy."); 2600 2601 TEST_ASSERT_EQUAL(rte_eth_bond_xmit_policy_get(test_params->bonded_port_id), 2602 BALANCE_XMIT_POLICY_LAYER34, 2603 "balance xmit policy not as expected."); 2604 2605 /* Invalid port id */ 2606 TEST_ASSERT_FAIL(rte_eth_bond_xmit_policy_get(INVALID_PORT_ID), 2607 "Expected call to failed as invalid port specified."); 2608 2609 /* Clean up and remove slaves from bonded device */ 2610 return remove_slaves_and_stop_bonded_device(); 2611 } 2612 2613 #define TEST_BALANCE_L2_TX_BURST_SLAVE_COUNT (2) 2614 2615 static int 2616 test_balance_l2_tx_burst(void) 2617 { 2618 struct rte_mbuf *pkts_burst[TEST_BALANCE_L2_TX_BURST_SLAVE_COUNT][MAX_PKT_BURST]; 2619 int burst_size[TEST_BALANCE_L2_TX_BURST_SLAVE_COUNT] = { 10, 15 }; 2620 2621 uint16_t pktlen; 2622 int i; 2623 struct rte_eth_stats port_stats; 2624 2625 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 2626 BONDING_MODE_BALANCE, 0, TEST_BALANCE_L2_TX_BURST_SLAVE_COUNT, 1), 2627 "Failed to initialize_bonded_device_with_slaves."); 2628 2629 TEST_ASSERT_SUCCESS(rte_eth_bond_xmit_policy_set( 2630 test_params->bonded_port_id, BALANCE_XMIT_POLICY_LAYER2), 2631 "Failed to set balance xmit policy."); 2632 2633 initialize_eth_header(test_params->pkt_eth_hdr, 2634 (struct ether_addr *)src_mac, (struct ether_addr *)dst_mac_0, 2635 ETHER_TYPE_IPv4, 0, 0); 2636 pktlen = initialize_udp_header(test_params->pkt_udp_hdr, src_port, 2637 dst_port_0, 16); 2638 pktlen = initialize_ipv4_header(test_params->pkt_ipv4_hdr, src_addr, 2639 dst_addr_0, pktlen); 2640 2641 /* Generate a burst 1 of packets to transmit */ 2642 TEST_ASSERT_EQUAL(generate_packet_burst(test_params->mbuf_pool, &pkts_burst[0][0], 2643 test_params->pkt_eth_hdr, 0, test_params->pkt_ipv4_hdr, 1, 2644 test_params->pkt_udp_hdr, burst_size[0], 2645 PACKET_BURST_GEN_PKT_LEN, 1), burst_size[0], 2646 "failed to generate packet burst"); 2647 2648 initialize_eth_header(test_params->pkt_eth_hdr, 2649 (struct ether_addr *)src_mac, (struct ether_addr *)dst_mac_1, 2650 ETHER_TYPE_IPv4, 0, 0); 2651 2652 /* Generate a burst 2 of packets to transmit */ 2653 TEST_ASSERT_EQUAL(generate_packet_burst(test_params->mbuf_pool, &pkts_burst[1][0], 2654 test_params->pkt_eth_hdr, 0, test_params->pkt_ipv4_hdr, 1, 2655 test_params->pkt_udp_hdr, burst_size[1], 2656 PACKET_BURST_GEN_PKT_LEN, 1), burst_size[1], 2657 "failed to generate packet burst"); 2658 2659 /* Send burst 1 on bonded port */ 2660 for (i = 0; i < TEST_BALANCE_L2_TX_BURST_SLAVE_COUNT; i++) { 2661 TEST_ASSERT_EQUAL(rte_eth_tx_burst(test_params->bonded_port_id, 0, 2662 &pkts_burst[i][0], burst_size[i]), 2663 burst_size[i], "Failed to transmit packet burst"); 2664 } 2665 2666 /* Verify bonded port tx stats */ 2667 rte_eth_stats_get(test_params->bonded_port_id, &port_stats); 2668 TEST_ASSERT_EQUAL(port_stats.opackets, 2669 (uint64_t)(burst_size[0] + burst_size[1]), 2670 "Bonded Port (%d) opackets value (%u) not as expected (%d)", 2671 test_params->bonded_port_id, (unsigned int)port_stats.opackets, 2672 burst_size[0] + burst_size[1]); 2673 2674 2675 /* Verify slave ports tx stats */ 2676 rte_eth_stats_get(test_params->slave_port_ids[0], &port_stats); 2677 TEST_ASSERT_EQUAL(port_stats.opackets, (uint64_t)burst_size[0], 2678 "Slave Port (%d) opackets value (%u) not as expected (%d)", 2679 test_params->slave_port_ids[0], (unsigned int)port_stats.opackets, 2680 burst_size[0]); 2681 2682 rte_eth_stats_get(test_params->slave_port_ids[1], &port_stats); 2683 TEST_ASSERT_EQUAL(port_stats.opackets, (uint64_t)burst_size[1], 2684 "Slave Port (%d) opackets value (%u) not as expected (%d)\n", 2685 test_params->slave_port_ids[1], (unsigned int)port_stats.opackets, 2686 burst_size[1]); 2687 2688 /* Put all slaves down and try and transmit */ 2689 for (i = 0; i < test_params->bonded_slave_count; i++) { 2690 2691 virtual_ethdev_simulate_link_status_interrupt( 2692 test_params->slave_port_ids[i], 0); 2693 } 2694 2695 /* Send burst on bonded port */ 2696 TEST_ASSERT_EQUAL(rte_eth_tx_burst( 2697 test_params->bonded_port_id, 0, &pkts_burst[0][0], burst_size[0]), 2698 0, "Expected zero packet"); 2699 2700 /* Clean up and remove slaves from bonded device */ 2701 return remove_slaves_and_stop_bonded_device(); 2702 } 2703 2704 static int 2705 balance_l23_tx_burst(uint8_t vlan_enabled, uint8_t ipv4, 2706 uint8_t toggle_mac_addr, uint8_t toggle_ip_addr) 2707 { 2708 int i, burst_size_1, burst_size_2, nb_tx_1, nb_tx_2; 2709 2710 struct rte_mbuf *pkts_burst_1[MAX_PKT_BURST]; 2711 struct rte_mbuf *pkts_burst_2[MAX_PKT_BURST]; 2712 2713 struct rte_eth_stats port_stats; 2714 2715 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 2716 BONDING_MODE_BALANCE, 0, 2, 1), 2717 "Failed to initialize_bonded_device_with_slaves."); 2718 2719 TEST_ASSERT_SUCCESS(rte_eth_bond_xmit_policy_set( 2720 test_params->bonded_port_id, BALANCE_XMIT_POLICY_LAYER23), 2721 "Failed to set balance xmit policy."); 2722 2723 burst_size_1 = 20; 2724 burst_size_2 = 10; 2725 2726 TEST_ASSERT(burst_size_1 < MAX_PKT_BURST || burst_size_2 < MAX_PKT_BURST, 2727 "Burst size specified is greater than supported."); 2728 2729 /* Generate test bursts of packets to transmit */ 2730 TEST_ASSERT_EQUAL(generate_test_burst( 2731 pkts_burst_1, burst_size_1, vlan_enabled, ipv4, 0, 0, 0), 2732 burst_size_1, "failed to generate packet burst"); 2733 2734 TEST_ASSERT_EQUAL(generate_test_burst(pkts_burst_2, burst_size_2, vlan_enabled, ipv4, 2735 toggle_mac_addr, toggle_ip_addr, 0), burst_size_2, 2736 "failed to generate packet burst"); 2737 2738 /* Send burst 1 on bonded port */ 2739 nb_tx_1 = rte_eth_tx_burst(test_params->bonded_port_id, 0, pkts_burst_1, 2740 burst_size_1); 2741 TEST_ASSERT_EQUAL(nb_tx_1, burst_size_1, "tx burst failed"); 2742 2743 /* Send burst 2 on bonded port */ 2744 nb_tx_2 = rte_eth_tx_burst(test_params->bonded_port_id, 0, pkts_burst_2, 2745 burst_size_2); 2746 TEST_ASSERT_EQUAL(nb_tx_2, burst_size_2, "tx burst failed"); 2747 2748 /* Verify bonded port tx stats */ 2749 rte_eth_stats_get(test_params->bonded_port_id, &port_stats); 2750 TEST_ASSERT_EQUAL(port_stats.opackets, (uint64_t)(nb_tx_1 + nb_tx_2), 2751 "Bonded Port (%d) opackets value (%u) not as expected (%d)", 2752 test_params->bonded_port_id, (unsigned int)port_stats.opackets, 2753 nb_tx_1 + nb_tx_2); 2754 2755 /* Verify slave ports tx stats */ 2756 rte_eth_stats_get(test_params->slave_port_ids[0], &port_stats); 2757 TEST_ASSERT_EQUAL(port_stats.opackets, (uint64_t)nb_tx_1, 2758 "Slave Port (%d) opackets value (%u) not as expected (%d)", 2759 test_params->slave_port_ids[0], (unsigned int)port_stats.opackets, 2760 nb_tx_1); 2761 2762 rte_eth_stats_get(test_params->slave_port_ids[1], &port_stats); 2763 TEST_ASSERT_EQUAL(port_stats.opackets, (uint64_t)nb_tx_2, 2764 "Slave Port (%d) opackets value (%u) not as expected (%d)", 2765 test_params->slave_port_ids[1], (unsigned int)port_stats.opackets, 2766 nb_tx_2); 2767 2768 /* Put all slaves down and try and transmit */ 2769 for (i = 0; i < test_params->bonded_slave_count; i++) { 2770 2771 virtual_ethdev_simulate_link_status_interrupt( 2772 test_params->slave_port_ids[i], 0); 2773 } 2774 2775 /* Send burst on bonded port */ 2776 TEST_ASSERT_EQUAL(rte_eth_tx_burst( 2777 test_params->bonded_port_id, 0, pkts_burst_1, 2778 burst_size_1), 0, "Expected zero packet"); 2779 2780 2781 /* Clean up and remove slaves from bonded device */ 2782 return remove_slaves_and_stop_bonded_device(); 2783 } 2784 2785 static int 2786 test_balance_l23_tx_burst_ipv4_toggle_ip_addr(void) 2787 { 2788 return balance_l23_tx_burst(0, 1, 1, 0); 2789 } 2790 2791 static int 2792 test_balance_l23_tx_burst_vlan_ipv4_toggle_ip_addr(void) 2793 { 2794 return balance_l23_tx_burst(1, 1, 0, 1); 2795 } 2796 2797 static int 2798 test_balance_l23_tx_burst_ipv6_toggle_ip_addr(void) 2799 { 2800 return balance_l23_tx_burst(0, 0, 0, 1); 2801 } 2802 2803 static int 2804 test_balance_l23_tx_burst_vlan_ipv6_toggle_ip_addr(void) 2805 { 2806 return balance_l23_tx_burst(1, 0, 0, 1); 2807 } 2808 2809 static int 2810 test_balance_l23_tx_burst_toggle_mac_addr(void) 2811 { 2812 return balance_l23_tx_burst(0, 0, 1, 0); 2813 } 2814 2815 static int 2816 balance_l34_tx_burst(uint8_t vlan_enabled, uint8_t ipv4, 2817 uint8_t toggle_mac_addr, uint8_t toggle_ip_addr, 2818 uint8_t toggle_udp_port) 2819 { 2820 int i, burst_size_1, burst_size_2, nb_tx_1, nb_tx_2; 2821 2822 struct rte_mbuf *pkts_burst_1[MAX_PKT_BURST]; 2823 struct rte_mbuf *pkts_burst_2[MAX_PKT_BURST]; 2824 2825 struct rte_eth_stats port_stats; 2826 2827 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 2828 BONDING_MODE_BALANCE, 0, 2, 1), 2829 "Failed to initialize_bonded_device_with_slaves."); 2830 2831 TEST_ASSERT_SUCCESS(rte_eth_bond_xmit_policy_set( 2832 test_params->bonded_port_id, BALANCE_XMIT_POLICY_LAYER34), 2833 "Failed to set balance xmit policy."); 2834 2835 burst_size_1 = 20; 2836 burst_size_2 = 10; 2837 2838 TEST_ASSERT(burst_size_1 < MAX_PKT_BURST || burst_size_2 < MAX_PKT_BURST, 2839 "Burst size specified is greater than supported."); 2840 2841 /* Generate test bursts of packets to transmit */ 2842 TEST_ASSERT_EQUAL(generate_test_burst( 2843 pkts_burst_1, burst_size_1, vlan_enabled, ipv4, 0, 0, 0), 2844 burst_size_1, "failed to generate burst"); 2845 2846 TEST_ASSERT_EQUAL(generate_test_burst(pkts_burst_2, burst_size_2, 2847 vlan_enabled, ipv4, toggle_mac_addr, toggle_ip_addr, 2848 toggle_udp_port), burst_size_2, "failed to generate burst"); 2849 2850 /* Send burst 1 on bonded port */ 2851 nb_tx_1 = rte_eth_tx_burst(test_params->bonded_port_id, 0, pkts_burst_1, 2852 burst_size_1); 2853 TEST_ASSERT_EQUAL(nb_tx_1, burst_size_1, "tx burst failed"); 2854 2855 /* Send burst 2 on bonded port */ 2856 nb_tx_2 = rte_eth_tx_burst(test_params->bonded_port_id, 0, pkts_burst_2, 2857 burst_size_2); 2858 TEST_ASSERT_EQUAL(nb_tx_2, burst_size_2, "tx burst failed"); 2859 2860 2861 /* Verify bonded port tx stats */ 2862 rte_eth_stats_get(test_params->bonded_port_id, &port_stats); 2863 TEST_ASSERT_EQUAL(port_stats.opackets, (uint64_t)(nb_tx_1 + nb_tx_2), 2864 "Bonded Port (%d) opackets value (%u) not as expected (%d)", 2865 test_params->bonded_port_id, (unsigned int)port_stats.opackets, 2866 nb_tx_1 + nb_tx_2); 2867 2868 /* Verify slave ports tx stats */ 2869 rte_eth_stats_get(test_params->slave_port_ids[0], &port_stats); 2870 TEST_ASSERT_EQUAL(port_stats.opackets, (uint64_t)nb_tx_1, 2871 "Slave Port (%d) opackets value (%u) not as expected (%d)", 2872 test_params->slave_port_ids[0], (unsigned int)port_stats.opackets, 2873 nb_tx_1); 2874 2875 rte_eth_stats_get(test_params->slave_port_ids[1], &port_stats); 2876 TEST_ASSERT_EQUAL(port_stats.opackets, (uint64_t)nb_tx_2, 2877 "Slave Port (%d) opackets value (%u) not as expected (%d)", 2878 test_params->slave_port_ids[1], (unsigned int)port_stats.opackets, 2879 nb_tx_2); 2880 2881 /* Put all slaves down and try and transmit */ 2882 for (i = 0; i < test_params->bonded_slave_count; i++) { 2883 2884 virtual_ethdev_simulate_link_status_interrupt( 2885 test_params->slave_port_ids[i], 0); 2886 } 2887 2888 /* Send burst on bonded port */ 2889 TEST_ASSERT_EQUAL(rte_eth_tx_burst( 2890 test_params->bonded_port_id, 0, pkts_burst_1, 2891 burst_size_1), 0, "Expected zero packet"); 2892 2893 /* Clean up and remove slaves from bonded device */ 2894 return remove_slaves_and_stop_bonded_device(); 2895 } 2896 2897 static int 2898 test_balance_l34_tx_burst_ipv4_toggle_ip_addr(void) 2899 { 2900 return balance_l34_tx_burst(0, 1, 0, 1, 0); 2901 } 2902 2903 static int 2904 test_balance_l34_tx_burst_ipv4_toggle_udp_port(void) 2905 { 2906 return balance_l34_tx_burst(0, 1, 0, 0, 1); 2907 } 2908 2909 static int 2910 test_balance_l34_tx_burst_vlan_ipv4_toggle_ip_addr(void) 2911 { 2912 return balance_l34_tx_burst(1, 1, 0, 1, 0); 2913 } 2914 2915 static int 2916 test_balance_l34_tx_burst_ipv6_toggle_ip_addr(void) 2917 { 2918 return balance_l34_tx_burst(0, 0, 0, 1, 0); 2919 } 2920 2921 static int 2922 test_balance_l34_tx_burst_vlan_ipv6_toggle_ip_addr(void) 2923 { 2924 return balance_l34_tx_burst(1, 0, 0, 1, 0); 2925 } 2926 2927 static int 2928 test_balance_l34_tx_burst_ipv6_toggle_udp_port(void) 2929 { 2930 return balance_l34_tx_burst(0, 0, 0, 0, 1); 2931 } 2932 2933 #define TEST_BAL_SLAVE_TX_FAIL_SLAVE_COUNT (2) 2934 #define TEST_BAL_SLAVE_TX_FAIL_BURST_SIZE_1 (40) 2935 #define TEST_BAL_SLAVE_TX_FAIL_BURST_SIZE_2 (20) 2936 #define TEST_BAL_SLAVE_TX_FAIL_PACKETS_COUNT (25) 2937 #define TEST_BAL_SLAVE_TX_FAIL_FAILING_SLAVE_IDX (0) 2938 2939 static int 2940 test_balance_tx_burst_slave_tx_fail(void) 2941 { 2942 struct rte_mbuf *pkts_burst_1[TEST_BAL_SLAVE_TX_FAIL_BURST_SIZE_1]; 2943 struct rte_mbuf *pkts_burst_2[TEST_BAL_SLAVE_TX_FAIL_BURST_SIZE_2]; 2944 2945 struct rte_mbuf *expected_fail_pkts[TEST_BAL_SLAVE_TX_FAIL_PACKETS_COUNT]; 2946 2947 struct rte_eth_stats port_stats; 2948 2949 int i, first_tx_fail_idx, tx_count_1, tx_count_2; 2950 2951 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 2952 BONDING_MODE_BALANCE, 0, 2953 TEST_BAL_SLAVE_TX_FAIL_SLAVE_COUNT, 1), 2954 "Failed to intialise bonded device"); 2955 2956 TEST_ASSERT_SUCCESS(rte_eth_bond_xmit_policy_set( 2957 test_params->bonded_port_id, BALANCE_XMIT_POLICY_LAYER2), 2958 "Failed to set balance xmit policy."); 2959 2960 2961 /* Generate test bursts for transmission */ 2962 TEST_ASSERT_EQUAL(generate_test_burst(pkts_burst_1, 2963 TEST_BAL_SLAVE_TX_FAIL_BURST_SIZE_1, 0, 0, 0, 0, 0), 2964 TEST_BAL_SLAVE_TX_FAIL_BURST_SIZE_1, 2965 "Failed to generate test packet burst 1"); 2966 2967 first_tx_fail_idx = TEST_BAL_SLAVE_TX_FAIL_BURST_SIZE_1 - 2968 TEST_BAL_SLAVE_TX_FAIL_PACKETS_COUNT; 2969 2970 /* copy mbuf referneces for expected transmission failures */ 2971 for (i = 0; i < TEST_BAL_SLAVE_TX_FAIL_PACKETS_COUNT; i++) 2972 expected_fail_pkts[i] = pkts_burst_1[i + first_tx_fail_idx]; 2973 2974 TEST_ASSERT_EQUAL(generate_test_burst(pkts_burst_2, 2975 TEST_BAL_SLAVE_TX_FAIL_BURST_SIZE_2, 0, 0, 1, 0, 0), 2976 TEST_BAL_SLAVE_TX_FAIL_BURST_SIZE_2, 2977 "Failed to generate test packet burst 2"); 2978 2979 2980 /* Set virtual slave TEST_BAL_SLAVE_TX_FAIL_FAILING_SLAVE_IDX to only fail 2981 * transmission of TEST_BAL_SLAVE_TX_FAIL_PACKETS_COUNT packets of burst */ 2982 virtual_ethdev_tx_burst_fn_set_success( 2983 test_params->slave_port_ids[TEST_BAL_SLAVE_TX_FAIL_FAILING_SLAVE_IDX], 2984 0); 2985 2986 virtual_ethdev_tx_burst_fn_set_tx_pkt_fail_count( 2987 test_params->slave_port_ids[TEST_BAL_SLAVE_TX_FAIL_FAILING_SLAVE_IDX], 2988 TEST_BAL_SLAVE_TX_FAIL_PACKETS_COUNT); 2989 2990 2991 /* Transmit burst 1 */ 2992 tx_count_1 = rte_eth_tx_burst(test_params->bonded_port_id, 0, pkts_burst_1, 2993 TEST_BAL_SLAVE_TX_FAIL_BURST_SIZE_1); 2994 2995 TEST_ASSERT_EQUAL(tx_count_1, TEST_BAL_SLAVE_TX_FAIL_BURST_SIZE_1 - 2996 TEST_BAL_SLAVE_TX_FAIL_PACKETS_COUNT, 2997 "Transmitted (%d) packets, expected to transmit (%d) packets", 2998 tx_count_1, TEST_BAL_SLAVE_TX_FAIL_BURST_SIZE_1 - 2999 TEST_BAL_SLAVE_TX_FAIL_PACKETS_COUNT); 3000 3001 /* Verify that failed packet are expected failed packets */ 3002 for (i = 0; i < TEST_RR_SLAVE_TX_FAIL_PACKETS_COUNT; i++) { 3003 TEST_ASSERT_EQUAL(expected_fail_pkts[i], pkts_burst_1[i + tx_count_1], 3004 "expected mbuf (%d) pointer %p not expected pointer %p", 3005 i, expected_fail_pkts[i], pkts_burst_1[i + tx_count_1]); 3006 } 3007 3008 /* Transmit burst 2 */ 3009 tx_count_2 = rte_eth_tx_burst(test_params->bonded_port_id, 0, pkts_burst_2, 3010 TEST_BAL_SLAVE_TX_FAIL_BURST_SIZE_2); 3011 3012 TEST_ASSERT_EQUAL(tx_count_2, TEST_BAL_SLAVE_TX_FAIL_BURST_SIZE_2, 3013 "Transmitted (%d) packets, expected to transmit (%d) packets", 3014 tx_count_2, TEST_BAL_SLAVE_TX_FAIL_BURST_SIZE_2); 3015 3016 3017 /* Verify bonded port tx stats */ 3018 rte_eth_stats_get(test_params->bonded_port_id, &port_stats); 3019 3020 TEST_ASSERT_EQUAL(port_stats.opackets, 3021 (uint64_t)((TEST_BAL_SLAVE_TX_FAIL_BURST_SIZE_1 - 3022 TEST_BAL_SLAVE_TX_FAIL_PACKETS_COUNT) + 3023 TEST_BAL_SLAVE_TX_FAIL_BURST_SIZE_2), 3024 "Bonded Port (%d) opackets value (%u) not as expected (%d)", 3025 test_params->bonded_port_id, (unsigned int)port_stats.opackets, 3026 (TEST_BAL_SLAVE_TX_FAIL_BURST_SIZE_1 - 3027 TEST_BAL_SLAVE_TX_FAIL_PACKETS_COUNT) + 3028 TEST_BAL_SLAVE_TX_FAIL_BURST_SIZE_2); 3029 3030 /* Verify slave ports tx stats */ 3031 3032 rte_eth_stats_get(test_params->slave_port_ids[0], &port_stats); 3033 3034 TEST_ASSERT_EQUAL(port_stats.opackets, (uint64_t) 3035 TEST_BAL_SLAVE_TX_FAIL_BURST_SIZE_1 - 3036 TEST_BAL_SLAVE_TX_FAIL_PACKETS_COUNT, 3037 "Slave Port (%d) opackets value (%u) not as expected (%d)", 3038 test_params->slave_port_ids[0], 3039 (unsigned int)port_stats.opackets, 3040 TEST_BAL_SLAVE_TX_FAIL_BURST_SIZE_1 - 3041 TEST_BAL_SLAVE_TX_FAIL_PACKETS_COUNT); 3042 3043 3044 3045 3046 rte_eth_stats_get(test_params->slave_port_ids[1], &port_stats); 3047 3048 TEST_ASSERT_EQUAL(port_stats.opackets, 3049 (uint64_t)TEST_BAL_SLAVE_TX_FAIL_BURST_SIZE_2, 3050 "Slave Port (%d) opackets value (%u) not as expected (%d)", 3051 test_params->slave_port_ids[1], 3052 (unsigned int)port_stats.opackets, 3053 TEST_BAL_SLAVE_TX_FAIL_BURST_SIZE_2); 3054 3055 /* Verify that all mbufs have a ref value of zero */ 3056 TEST_ASSERT_SUCCESS(verify_mbufs_ref_count(&pkts_burst_1[tx_count_1], 3057 TEST_BAL_SLAVE_TX_FAIL_PACKETS_COUNT, 1), 3058 "mbufs refcnts not as expected"); 3059 3060 free_mbufs(&pkts_burst_1[tx_count_1], 3061 TEST_BAL_SLAVE_TX_FAIL_PACKETS_COUNT); 3062 3063 /* Clean up and remove slaves from bonded device */ 3064 return remove_slaves_and_stop_bonded_device(); 3065 } 3066 3067 #define TEST_BALANCE_RX_BURST_SLAVE_COUNT (3) 3068 3069 static int 3070 test_balance_rx_burst(void) 3071 { 3072 struct rte_mbuf *gen_pkt_burst[TEST_BALANCE_RX_BURST_SLAVE_COUNT][MAX_PKT_BURST]; 3073 3074 struct rte_mbuf *rx_pkt_burst[MAX_PKT_BURST] = { NULL }; 3075 struct rte_eth_stats port_stats; 3076 3077 int burst_size[TEST_BALANCE_RX_BURST_SLAVE_COUNT] = { 10, 5, 30 }; 3078 int i, j; 3079 3080 memset(gen_pkt_burst, 0, sizeof(gen_pkt_burst)); 3081 3082 /* Initialize bonded device with 4 slaves in round robin mode */ 3083 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 3084 BONDING_MODE_BALANCE, 0, 3, 1), 3085 "Failed to intialise bonded device"); 3086 3087 /* Generate test bursts of packets to transmit */ 3088 for (i = 0; i < TEST_BALANCE_RX_BURST_SLAVE_COUNT; i++) { 3089 TEST_ASSERT_EQUAL(generate_test_burst( 3090 &gen_pkt_burst[i][0], burst_size[i], 0, 0, 1, 3091 0, 0), burst_size[i], 3092 "failed to generate packet burst"); 3093 } 3094 3095 /* Add rx data to slaves */ 3096 for (i = 0; i < TEST_BALANCE_RX_BURST_SLAVE_COUNT; i++) { 3097 virtual_ethdev_add_mbufs_to_rx_queue(test_params->slave_port_ids[i], 3098 &gen_pkt_burst[i][0], burst_size[i]); 3099 } 3100 3101 /* Call rx burst on bonded device */ 3102 /* Send burst on bonded port */ 3103 TEST_ASSERT_EQUAL(rte_eth_rx_burst(test_params->bonded_port_id, 0, 3104 rx_pkt_burst, MAX_PKT_BURST), 3105 burst_size[0] + burst_size[1] + burst_size[2], 3106 "balance rx burst failed\n"); 3107 3108 /* Verify bonded device rx count */ 3109 rte_eth_stats_get(test_params->bonded_port_id, &port_stats); 3110 TEST_ASSERT_EQUAL(port_stats.ipackets, 3111 (uint64_t)(burst_size[0] + burst_size[1] + burst_size[2]), 3112 "Bonded Port (%d) ipackets value (%u) not as expected (%d)", 3113 test_params->bonded_port_id, (unsigned int)port_stats.ipackets, 3114 burst_size[0] + burst_size[1] + burst_size[2]); 3115 3116 3117 /* Verify bonded slave devices rx counts */ 3118 rte_eth_stats_get(test_params->slave_port_ids[0], &port_stats); 3119 TEST_ASSERT_EQUAL(port_stats.ipackets, (uint64_t)burst_size[0], 3120 "Slave Port (%d) ipackets value (%u) not as expected (%d)", 3121 test_params->slave_port_ids[0], 3122 (unsigned int)port_stats.ipackets, burst_size[0]); 3123 3124 rte_eth_stats_get(test_params->slave_port_ids[1], &port_stats); 3125 TEST_ASSERT_EQUAL(port_stats.ipackets, (uint64_t)burst_size[1], 3126 "Slave Port (%d) ipackets value (%u) not as expected (%d)", 3127 test_params->slave_port_ids[1], (unsigned int)port_stats.ipackets, 3128 burst_size[1]); 3129 3130 rte_eth_stats_get(test_params->slave_port_ids[2], &port_stats); 3131 TEST_ASSERT_EQUAL(port_stats.ipackets, (uint64_t)burst_size[2], 3132 "Slave Port (%d) ipackets value (%u) not as expected (%d)", 3133 test_params->slave_port_ids[2], (unsigned int)port_stats.ipackets, 3134 burst_size[2]); 3135 3136 rte_eth_stats_get(test_params->slave_port_ids[3], &port_stats); 3137 TEST_ASSERT_EQUAL(port_stats.ipackets, 0, 3138 "Slave Port (%d) ipackets value (%u) not as expected (%d)", 3139 test_params->slave_port_ids[3], (unsigned int)port_stats.ipackets, 3140 0); 3141 3142 /* free mbufs */ 3143 for (i = 0; i < TEST_BALANCE_RX_BURST_SLAVE_COUNT; i++) { 3144 for (j = 0; j < MAX_PKT_BURST; j++) { 3145 if (gen_pkt_burst[i][j] != NULL) { 3146 rte_pktmbuf_free(gen_pkt_burst[i][j]); 3147 gen_pkt_burst[i][j] = NULL; 3148 } 3149 } 3150 } 3151 3152 /* Clean up and remove slaves from bonded device */ 3153 return remove_slaves_and_stop_bonded_device(); 3154 } 3155 3156 static int 3157 test_balance_verify_promiscuous_enable_disable(void) 3158 { 3159 int i; 3160 3161 /* Initialize bonded device with 4 slaves in round robin mode */ 3162 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 3163 BONDING_MODE_BALANCE, 0, 4, 1), 3164 "Failed to intialise bonded device"); 3165 3166 rte_eth_promiscuous_enable(test_params->bonded_port_id); 3167 3168 TEST_ASSERT_EQUAL(rte_eth_promiscuous_get(test_params->bonded_port_id), 1, 3169 "Port (%d) promiscuous mode not enabled", 3170 test_params->bonded_port_id); 3171 3172 for (i = 0; i < test_params->bonded_slave_count; i++) { 3173 TEST_ASSERT_EQUAL(rte_eth_promiscuous_get( 3174 test_params->slave_port_ids[i]), 1, 3175 "Port (%d) promiscuous mode not enabled", 3176 test_params->slave_port_ids[i]); 3177 } 3178 3179 rte_eth_promiscuous_disable(test_params->bonded_port_id); 3180 3181 TEST_ASSERT_EQUAL(rte_eth_promiscuous_get(test_params->bonded_port_id), 0, 3182 "Port (%d) promiscuous mode not disabled", 3183 test_params->bonded_port_id); 3184 3185 for (i = 0; i < test_params->bonded_slave_count; i++) { 3186 TEST_ASSERT_EQUAL(rte_eth_promiscuous_get( 3187 test_params->slave_port_ids[i]), 0, 3188 "Port (%d) promiscuous mode not disabled", 3189 test_params->slave_port_ids[i]); 3190 } 3191 3192 /* Clean up and remove slaves from bonded device */ 3193 return remove_slaves_and_stop_bonded_device(); 3194 } 3195 3196 static int 3197 test_balance_verify_mac_assignment(void) 3198 { 3199 struct ether_addr read_mac_addr, expected_mac_addr_0, expected_mac_addr_1; 3200 3201 rte_eth_macaddr_get(test_params->slave_port_ids[0], &expected_mac_addr_0); 3202 rte_eth_macaddr_get(test_params->slave_port_ids[1], &expected_mac_addr_1); 3203 3204 /* Initialize bonded device with 2 slaves in active backup mode */ 3205 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 3206 BONDING_MODE_BALANCE, 0, 2, 1), 3207 "Failed to intialise bonded device"); 3208 3209 /* Verify that bonded MACs is that of first slave and that the other slave 3210 * MAC hasn't been changed */ 3211 rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr); 3212 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_0, &read_mac_addr, 3213 sizeof(read_mac_addr)), 3214 "bonded port (%d) mac address not set to that of primary port", 3215 test_params->bonded_port_id); 3216 3217 rte_eth_macaddr_get(test_params->slave_port_ids[0], &read_mac_addr); 3218 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_0, &read_mac_addr, 3219 sizeof(read_mac_addr)), 3220 "slave port (%d) mac address not set to that of primary port", 3221 test_params->slave_port_ids[0]); 3222 3223 rte_eth_macaddr_get(test_params->slave_port_ids[1], &read_mac_addr); 3224 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_0, &read_mac_addr, 3225 sizeof(read_mac_addr)), 3226 "slave port (%d) mac address not set to that of primary port", 3227 test_params->slave_port_ids[1]); 3228 3229 /* change primary and verify that MAC addresses haven't changed */ 3230 TEST_ASSERT_SUCCESS(rte_eth_bond_primary_set(test_params->bonded_port_id, 3231 test_params->slave_port_ids[1]), 3232 "Failed to set bonded port (%d) primary port to (%d)\n", 3233 test_params->bonded_port_id, test_params->slave_port_ids[1]); 3234 3235 rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr); 3236 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_0, &read_mac_addr, 3237 sizeof(read_mac_addr)), 3238 "bonded port (%d) mac address not set to that of primary port", 3239 test_params->bonded_port_id); 3240 3241 rte_eth_macaddr_get(test_params->slave_port_ids[0], &read_mac_addr); 3242 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_0, &read_mac_addr, 3243 sizeof(read_mac_addr)), 3244 "slave port (%d) mac address not set to that of primary port", 3245 test_params->slave_port_ids[0]); 3246 3247 rte_eth_macaddr_get(test_params->slave_port_ids[1], &read_mac_addr); 3248 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_0, &read_mac_addr, 3249 sizeof(read_mac_addr)), 3250 "slave port (%d) mac address not set to that of primary port", 3251 test_params->slave_port_ids[1]); 3252 3253 /* stop / start bonded device and verify that primary MAC address is 3254 * propagated to bonded device and slaves */ 3255 3256 rte_eth_dev_stop(test_params->bonded_port_id); 3257 3258 TEST_ASSERT_SUCCESS(rte_eth_dev_start(test_params->bonded_port_id), 3259 "Failed to start bonded device"); 3260 3261 rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr); 3262 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_1, &read_mac_addr, 3263 sizeof(read_mac_addr)), 3264 "bonded port (%d) mac address not set to that of primary port", 3265 test_params->bonded_port_id); 3266 3267 rte_eth_macaddr_get(test_params->slave_port_ids[0], &read_mac_addr); 3268 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_1, &read_mac_addr, 3269 sizeof(read_mac_addr)), 3270 "slave port (%d) mac address not set to that of primary port", 3271 test_params->slave_port_ids[0]); 3272 3273 rte_eth_macaddr_get(test_params->slave_port_ids[1], &read_mac_addr); 3274 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_1, &read_mac_addr, 3275 sizeof(read_mac_addr)), 3276 "slave port (%d) mac address not set to that of primary port", 3277 test_params->slave_port_ids[1]); 3278 3279 /* Set explicit MAC address */ 3280 TEST_ASSERT_SUCCESS(rte_eth_bond_mac_address_set( 3281 test_params->bonded_port_id, (struct ether_addr *)bonded_mac), 3282 "failed to set MAC"); 3283 3284 rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr); 3285 TEST_ASSERT_SUCCESS(memcmp(&bonded_mac, &read_mac_addr, 3286 sizeof(read_mac_addr)), 3287 "bonded port (%d) mac address not set to that of bonded port", 3288 test_params->bonded_port_id); 3289 3290 rte_eth_macaddr_get(test_params->slave_port_ids[0], &read_mac_addr); 3291 TEST_ASSERT_SUCCESS(memcmp(&bonded_mac, &read_mac_addr, 3292 sizeof(read_mac_addr)), 3293 "slave port (%d) mac address not as expected\n", 3294 test_params->slave_port_ids[0]); 3295 3296 rte_eth_macaddr_get(test_params->slave_port_ids[1], &read_mac_addr); 3297 TEST_ASSERT_SUCCESS(memcmp(&bonded_mac, &read_mac_addr, 3298 sizeof(read_mac_addr)), 3299 "slave port (%d) mac address not set to that of bonded port", 3300 test_params->slave_port_ids[1]); 3301 3302 /* Clean up and remove slaves from bonded device */ 3303 return remove_slaves_and_stop_bonded_device(); 3304 } 3305 3306 #define TEST_BALANCE_LINK_STATUS_SLAVE_COUNT (4) 3307 3308 static int 3309 test_balance_verify_slave_link_status_change_behaviour(void) 3310 { 3311 struct rte_mbuf *pkt_burst[TEST_BALANCE_LINK_STATUS_SLAVE_COUNT][MAX_PKT_BURST]; 3312 struct rte_mbuf *rx_pkt_burst[MAX_PKT_BURST] = { NULL }; 3313 struct rte_eth_stats port_stats; 3314 3315 uint8_t slaves[RTE_MAX_ETHPORTS]; 3316 3317 int i, j, burst_size, slave_count; 3318 3319 memset(pkt_burst, 0, sizeof(pkt_burst)); 3320 3321 /* Initialize bonded device with 4 slaves in round robin mode */ 3322 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 3323 BONDING_MODE_BALANCE, 0, TEST_BALANCE_LINK_STATUS_SLAVE_COUNT, 1), 3324 "Failed to intialise bonded device"); 3325 3326 TEST_ASSERT_SUCCESS(rte_eth_bond_xmit_policy_set( 3327 test_params->bonded_port_id, BALANCE_XMIT_POLICY_LAYER2), 3328 "Failed to set balance xmit policy."); 3329 3330 3331 /* Verify Current Slaves Count /Active Slave Count is */ 3332 slave_count = rte_eth_bond_slaves_get(test_params->bonded_port_id, slaves, 3333 RTE_MAX_ETHPORTS); 3334 TEST_ASSERT_EQUAL(slave_count, TEST_BALANCE_LINK_STATUS_SLAVE_COUNT, 3335 "Number of slaves (%d) is not as expected (%d).", 3336 slave_count, TEST_BALANCE_LINK_STATUS_SLAVE_COUNT); 3337 3338 slave_count = rte_eth_bond_active_slaves_get(test_params->bonded_port_id, 3339 slaves, RTE_MAX_ETHPORTS); 3340 TEST_ASSERT_EQUAL(slave_count, TEST_BALANCE_LINK_STATUS_SLAVE_COUNT, 3341 "Number of active slaves (%d) is not as expected (%d).", 3342 slave_count, TEST_BALANCE_LINK_STATUS_SLAVE_COUNT); 3343 3344 /* Set 2 slaves link status to down */ 3345 virtual_ethdev_simulate_link_status_interrupt( 3346 test_params->slave_port_ids[1], 0); 3347 virtual_ethdev_simulate_link_status_interrupt( 3348 test_params->slave_port_ids[3], 0); 3349 3350 TEST_ASSERT_EQUAL(rte_eth_bond_active_slaves_get( 3351 test_params->bonded_port_id, slaves, RTE_MAX_ETHPORTS), 2, 3352 "Number of active slaves (%d) is not as expected (%d).", 3353 slave_count, 2); 3354 3355 /* Send to sets of packet burst and verify that they are balanced across 3356 * slaves */ 3357 burst_size = 21; 3358 3359 TEST_ASSERT_EQUAL(generate_test_burst( 3360 &pkt_burst[0][0], burst_size, 0, 1, 0, 0, 0), burst_size, 3361 "generate_test_burst failed"); 3362 3363 TEST_ASSERT_EQUAL(generate_test_burst( 3364 &pkt_burst[1][0], burst_size, 0, 1, 1, 0, 0), burst_size, 3365 "generate_test_burst failed"); 3366 3367 TEST_ASSERT_EQUAL(rte_eth_tx_burst( 3368 test_params->bonded_port_id, 0, &pkt_burst[0][0], burst_size), 3369 burst_size, "rte_eth_tx_burst failed"); 3370 3371 TEST_ASSERT_EQUAL(rte_eth_tx_burst( 3372 test_params->bonded_port_id, 0, &pkt_burst[1][0], burst_size), 3373 burst_size, "rte_eth_tx_burst failed"); 3374 3375 3376 rte_eth_stats_get(test_params->bonded_port_id, &port_stats); 3377 TEST_ASSERT_EQUAL(port_stats.opackets, (uint64_t)(burst_size + burst_size), 3378 "(%d) port_stats.opackets (%d) not as expected (%d).", 3379 test_params->bonded_port_id, (int)port_stats.opackets, 3380 burst_size + burst_size); 3381 3382 rte_eth_stats_get(test_params->slave_port_ids[0], &port_stats); 3383 TEST_ASSERT_EQUAL(port_stats.opackets, (uint64_t)burst_size, 3384 "(%d) port_stats.opackets (%d) not as expected (%d).", 3385 test_params->slave_port_ids[0], (int)port_stats.opackets, 3386 burst_size); 3387 3388 rte_eth_stats_get(test_params->slave_port_ids[2], &port_stats); 3389 TEST_ASSERT_EQUAL(port_stats.opackets, (uint64_t)burst_size, 3390 "(%d) port_stats.opackets (%d) not as expected (%d).", 3391 test_params->slave_port_ids[2], (int)port_stats.opackets, 3392 burst_size); 3393 3394 /* verify that all packets get send on primary slave when no other slaves 3395 * are available */ 3396 virtual_ethdev_simulate_link_status_interrupt( 3397 test_params->slave_port_ids[2], 0); 3398 3399 TEST_ASSERT_EQUAL(rte_eth_bond_active_slaves_get( 3400 test_params->bonded_port_id, slaves, RTE_MAX_ETHPORTS), 1, 3401 "Number of active slaves (%d) is not as expected (%d).", 3402 slave_count, 1); 3403 3404 TEST_ASSERT_EQUAL(generate_test_burst( 3405 &pkt_burst[1][0], burst_size, 0, 1, 1, 0, 0), burst_size, 3406 "generate_test_burst failed"); 3407 3408 TEST_ASSERT_EQUAL(rte_eth_tx_burst( 3409 test_params->bonded_port_id, 0, &pkt_burst[1][0], burst_size), 3410 burst_size, "rte_eth_tx_burst failed"); 3411 3412 rte_eth_stats_get(test_params->bonded_port_id, &port_stats); 3413 TEST_ASSERT_EQUAL(port_stats.opackets, 3414 (uint64_t)(burst_size + burst_size + burst_size), 3415 "(%d) port_stats.opackets (%d) not as expected (%d).\n", 3416 test_params->bonded_port_id, (int)port_stats.opackets, 3417 burst_size + burst_size + burst_size); 3418 3419 rte_eth_stats_get(test_params->slave_port_ids[0], &port_stats); 3420 TEST_ASSERT_EQUAL(port_stats.opackets, (uint64_t)(burst_size + burst_size), 3421 "(%d) port_stats.opackets (%d) not as expected (%d).", 3422 test_params->slave_port_ids[0], (int)port_stats.opackets, 3423 burst_size + burst_size); 3424 3425 virtual_ethdev_simulate_link_status_interrupt( 3426 test_params->slave_port_ids[0], 0); 3427 virtual_ethdev_simulate_link_status_interrupt( 3428 test_params->slave_port_ids[1], 1); 3429 virtual_ethdev_simulate_link_status_interrupt( 3430 test_params->slave_port_ids[2], 1); 3431 virtual_ethdev_simulate_link_status_interrupt( 3432 test_params->slave_port_ids[3], 1); 3433 3434 for (i = 0; i < TEST_BALANCE_LINK_STATUS_SLAVE_COUNT; i++) { 3435 TEST_ASSERT_EQUAL(generate_test_burst( 3436 &pkt_burst[i][0], burst_size, 0, 1, 0, 0, 0), burst_size, 3437 "Failed to generate packet burst"); 3438 3439 virtual_ethdev_add_mbufs_to_rx_queue(test_params->slave_port_ids[i], 3440 &pkt_burst[i][0], burst_size); 3441 } 3442 3443 /* Verify that pkts are not received on slaves with link status down */ 3444 3445 rte_eth_rx_burst(test_params->bonded_port_id, 0, rx_pkt_burst, 3446 MAX_PKT_BURST); 3447 3448 /* Verify bonded device rx count */ 3449 rte_eth_stats_get(test_params->bonded_port_id, &port_stats); 3450 TEST_ASSERT_EQUAL(port_stats.ipackets, (uint64_t)(burst_size * 3), 3451 "(%d) port_stats.ipackets (%d) not as expected (%d)\n", 3452 test_params->bonded_port_id, (int)port_stats.ipackets, 3453 burst_size * 3); 3454 3455 /* free mbufs allocate for rx testing */ 3456 for (i = 0; i < TEST_BALANCE_RX_BURST_SLAVE_COUNT; i++) { 3457 for (j = 0; j < MAX_PKT_BURST; j++) { 3458 if (pkt_burst[i][j] != NULL) { 3459 rte_pktmbuf_free(pkt_burst[i][j]); 3460 pkt_burst[i][j] = NULL; 3461 } 3462 } 3463 } 3464 3465 /* Clean up and remove slaves from bonded device */ 3466 return remove_slaves_and_stop_bonded_device(); 3467 } 3468 3469 static int 3470 test_broadcast_tx_burst(void) 3471 { 3472 int i, pktlen, burst_size; 3473 struct rte_mbuf *pkts_burst[MAX_PKT_BURST]; 3474 3475 struct rte_eth_stats port_stats; 3476 3477 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 3478 BONDING_MODE_BROADCAST, 0, 2, 1), 3479 "Failed to intialise bonded device"); 3480 3481 initialize_eth_header(test_params->pkt_eth_hdr, 3482 (struct ether_addr *)src_mac, (struct ether_addr *)dst_mac_0, 3483 ETHER_TYPE_IPv4, 0, 0); 3484 3485 pktlen = initialize_udp_header(test_params->pkt_udp_hdr, src_port, 3486 dst_port_0, 16); 3487 pktlen = initialize_ipv4_header(test_params->pkt_ipv4_hdr, src_addr, 3488 dst_addr_0, pktlen); 3489 3490 burst_size = 20 * test_params->bonded_slave_count; 3491 3492 TEST_ASSERT(burst_size < MAX_PKT_BURST, 3493 "Burst size specified is greater than supported."); 3494 3495 /* Generate a burst of packets to transmit */ 3496 TEST_ASSERT_EQUAL(generate_packet_burst(test_params->mbuf_pool, 3497 pkts_burst, test_params->pkt_eth_hdr, 0, test_params->pkt_ipv4_hdr, 3498 1, test_params->pkt_udp_hdr, burst_size, PACKET_BURST_GEN_PKT_LEN, 3499 1), burst_size, "Failed to generate packet burst"); 3500 3501 /* Send burst on bonded port */ 3502 TEST_ASSERT_EQUAL(rte_eth_tx_burst(test_params->bonded_port_id, 0, 3503 pkts_burst, burst_size), burst_size, 3504 "Bonded Port (%d) rx burst failed, packets transmitted value " 3505 "not as expected (%d)", 3506 test_params->bonded_port_id, burst_size); 3507 3508 /* Verify bonded port tx stats */ 3509 rte_eth_stats_get(test_params->bonded_port_id, &port_stats); 3510 TEST_ASSERT_EQUAL(port_stats.opackets, 3511 (uint64_t)burst_size * test_params->bonded_slave_count, 3512 "Bonded Port (%d) opackets value (%u) not as expected (%d)", 3513 test_params->bonded_port_id, (unsigned int)port_stats.opackets, 3514 burst_size); 3515 3516 /* Verify slave ports tx stats */ 3517 for (i = 0; i < test_params->bonded_slave_count; i++) { 3518 rte_eth_stats_get(test_params->slave_port_ids[i], &port_stats); 3519 TEST_ASSERT_EQUAL(port_stats.opackets, (uint64_t)burst_size, 3520 "Slave Port (%d) opackets value (%u) not as expected (%d)\n", 3521 test_params->bonded_port_id, 3522 (unsigned int)port_stats.opackets, burst_size); 3523 } 3524 3525 /* Put all slaves down and try and transmit */ 3526 for (i = 0; i < test_params->bonded_slave_count; i++) { 3527 3528 virtual_ethdev_simulate_link_status_interrupt( 3529 test_params->slave_port_ids[i], 0); 3530 } 3531 3532 /* Send burst on bonded port */ 3533 TEST_ASSERT_EQUAL(rte_eth_tx_burst( 3534 test_params->bonded_port_id, 0, pkts_burst, burst_size), 0, 3535 "transmitted an unexpected number of packets"); 3536 3537 /* Clean up and remove slaves from bonded device */ 3538 return remove_slaves_and_stop_bonded_device(); 3539 } 3540 3541 3542 #define TEST_BCAST_SLAVE_TX_FAIL_SLAVE_COUNT (3) 3543 #define TEST_BCAST_SLAVE_TX_FAIL_BURST_SIZE (40) 3544 #define TEST_BCAST_SLAVE_TX_FAIL_MAX_PACKETS_COUNT (15) 3545 #define TEST_BCAST_SLAVE_TX_FAIL_MIN_PACKETS_COUNT (10) 3546 3547 static int 3548 test_broadcast_tx_burst_slave_tx_fail(void) 3549 { 3550 struct rte_mbuf *pkts_burst[TEST_BCAST_SLAVE_TX_FAIL_BURST_SIZE]; 3551 struct rte_mbuf *expected_fail_pkts[TEST_BCAST_SLAVE_TX_FAIL_MIN_PACKETS_COUNT]; 3552 3553 struct rte_eth_stats port_stats; 3554 3555 int i, tx_count; 3556 3557 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 3558 BONDING_MODE_BROADCAST, 0, 3559 TEST_BCAST_SLAVE_TX_FAIL_SLAVE_COUNT, 1), 3560 "Failed to intialise bonded device"); 3561 3562 /* Generate test bursts for transmission */ 3563 TEST_ASSERT_EQUAL(generate_test_burst(pkts_burst, 3564 TEST_BCAST_SLAVE_TX_FAIL_BURST_SIZE, 0, 0, 0, 0, 0), 3565 TEST_BCAST_SLAVE_TX_FAIL_BURST_SIZE, 3566 "Failed to generate test packet burst"); 3567 3568 for (i = 0; i < TEST_BCAST_SLAVE_TX_FAIL_MIN_PACKETS_COUNT; i++) { 3569 expected_fail_pkts[i] = pkts_burst[TEST_BCAST_SLAVE_TX_FAIL_BURST_SIZE - 3570 TEST_BCAST_SLAVE_TX_FAIL_MIN_PACKETS_COUNT + i]; 3571 } 3572 3573 /* Set virtual slave TEST_BAL_SLAVE_TX_FAIL_FAILING_SLAVE_IDX to only fail 3574 * transmission of TEST_BAL_SLAVE_TX_FAIL_PACKETS_COUNT packets of burst */ 3575 virtual_ethdev_tx_burst_fn_set_success( 3576 test_params->slave_port_ids[0], 3577 0); 3578 virtual_ethdev_tx_burst_fn_set_success( 3579 test_params->slave_port_ids[1], 3580 0); 3581 virtual_ethdev_tx_burst_fn_set_success( 3582 test_params->slave_port_ids[2], 3583 0); 3584 3585 virtual_ethdev_tx_burst_fn_set_tx_pkt_fail_count( 3586 test_params->slave_port_ids[0], 3587 TEST_BCAST_SLAVE_TX_FAIL_MAX_PACKETS_COUNT); 3588 3589 virtual_ethdev_tx_burst_fn_set_tx_pkt_fail_count( 3590 test_params->slave_port_ids[1], 3591 TEST_BCAST_SLAVE_TX_FAIL_MIN_PACKETS_COUNT); 3592 3593 virtual_ethdev_tx_burst_fn_set_tx_pkt_fail_count( 3594 test_params->slave_port_ids[2], 3595 TEST_BCAST_SLAVE_TX_FAIL_MAX_PACKETS_COUNT); 3596 3597 /* Transmit burst */ 3598 tx_count = rte_eth_tx_burst(test_params->bonded_port_id, 0, pkts_burst, 3599 TEST_BCAST_SLAVE_TX_FAIL_BURST_SIZE); 3600 3601 TEST_ASSERT_EQUAL(tx_count, TEST_BCAST_SLAVE_TX_FAIL_BURST_SIZE - 3602 TEST_BCAST_SLAVE_TX_FAIL_MIN_PACKETS_COUNT, 3603 "Transmitted (%d) packets, expected to transmit (%d) packets", 3604 tx_count, TEST_BCAST_SLAVE_TX_FAIL_BURST_SIZE - 3605 TEST_BCAST_SLAVE_TX_FAIL_MIN_PACKETS_COUNT); 3606 3607 /* Verify that failed packet are expected failed packets */ 3608 for (i = 0; i < TEST_BCAST_SLAVE_TX_FAIL_MIN_PACKETS_COUNT; i++) { 3609 TEST_ASSERT_EQUAL(expected_fail_pkts[i], pkts_burst[i + tx_count], 3610 "expected mbuf (%d) pointer %p not expected pointer %p", 3611 i, expected_fail_pkts[i], pkts_burst[i + tx_count]); 3612 } 3613 3614 /* Verify slave ports tx stats */ 3615 3616 rte_eth_stats_get(test_params->slave_port_ids[0], &port_stats); 3617 3618 TEST_ASSERT_EQUAL(port_stats.opackets, 3619 (uint64_t)TEST_BCAST_SLAVE_TX_FAIL_BURST_SIZE - 3620 TEST_BCAST_SLAVE_TX_FAIL_MAX_PACKETS_COUNT, 3621 "Port (%d) opackets value (%u) not as expected (%d)", 3622 test_params->bonded_port_id, (unsigned int)port_stats.opackets, 3623 TEST_BCAST_SLAVE_TX_FAIL_BURST_SIZE - 3624 TEST_BCAST_SLAVE_TX_FAIL_MAX_PACKETS_COUNT); 3625 3626 3627 rte_eth_stats_get(test_params->slave_port_ids[1], &port_stats); 3628 3629 TEST_ASSERT_EQUAL(port_stats.opackets, 3630 (uint64_t)TEST_BCAST_SLAVE_TX_FAIL_BURST_SIZE - 3631 TEST_BCAST_SLAVE_TX_FAIL_MIN_PACKETS_COUNT, 3632 "Port (%d) opackets value (%u) not as expected (%d)", 3633 test_params->bonded_port_id, (unsigned int)port_stats.opackets, 3634 TEST_BCAST_SLAVE_TX_FAIL_BURST_SIZE - 3635 TEST_BCAST_SLAVE_TX_FAIL_MIN_PACKETS_COUNT); 3636 3637 rte_eth_stats_get(test_params->slave_port_ids[2], &port_stats); 3638 3639 TEST_ASSERT_EQUAL(port_stats.opackets, 3640 (uint64_t)TEST_BCAST_SLAVE_TX_FAIL_BURST_SIZE - 3641 TEST_BCAST_SLAVE_TX_FAIL_MAX_PACKETS_COUNT, 3642 "Port (%d) opackets value (%u) not as expected (%d)", 3643 test_params->bonded_port_id, (unsigned int)port_stats.opackets, 3644 TEST_BCAST_SLAVE_TX_FAIL_BURST_SIZE - 3645 TEST_BCAST_SLAVE_TX_FAIL_MAX_PACKETS_COUNT); 3646 3647 3648 /* Verify that all mbufs who transmission failed have a ref value of one */ 3649 TEST_ASSERT_SUCCESS(verify_mbufs_ref_count(&pkts_burst[tx_count], 3650 TEST_BCAST_SLAVE_TX_FAIL_MIN_PACKETS_COUNT, 1), 3651 "mbufs refcnts not as expected"); 3652 3653 free_mbufs(&pkts_burst[tx_count], 3654 TEST_BCAST_SLAVE_TX_FAIL_MIN_PACKETS_COUNT); 3655 3656 /* Clean up and remove slaves from bonded device */ 3657 return remove_slaves_and_stop_bonded_device(); 3658 } 3659 3660 #define BROADCAST_RX_BURST_NUM_OF_SLAVES (3) 3661 3662 static int 3663 test_broadcast_rx_burst(void) 3664 { 3665 struct rte_mbuf *gen_pkt_burst[BROADCAST_RX_BURST_NUM_OF_SLAVES][MAX_PKT_BURST]; 3666 3667 struct rte_mbuf *rx_pkt_burst[MAX_PKT_BURST] = { NULL }; 3668 struct rte_eth_stats port_stats; 3669 3670 int burst_size[BROADCAST_RX_BURST_NUM_OF_SLAVES] = { 10, 5, 30 }; 3671 int i, j; 3672 3673 memset(gen_pkt_burst, 0, sizeof(gen_pkt_burst)); 3674 3675 /* Initialize bonded device with 4 slaves in round robin mode */ 3676 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 3677 BONDING_MODE_BROADCAST, 0, 3, 1), 3678 "Failed to intialise bonded device"); 3679 3680 /* Generate test bursts of packets to transmit */ 3681 for (i = 0; i < BROADCAST_RX_BURST_NUM_OF_SLAVES; i++) { 3682 TEST_ASSERT_EQUAL(generate_test_burst( 3683 &gen_pkt_burst[i][0], burst_size[i], 0, 0, 1, 0, 0), 3684 burst_size[i], "failed to generate packet burst"); 3685 } 3686 3687 /* Add rx data to slave 0 */ 3688 for (i = 0; i < BROADCAST_RX_BURST_NUM_OF_SLAVES; i++) { 3689 virtual_ethdev_add_mbufs_to_rx_queue(test_params->slave_port_ids[i], 3690 &gen_pkt_burst[i][0], burst_size[i]); 3691 } 3692 3693 3694 /* Call rx burst on bonded device */ 3695 /* Send burst on bonded port */ 3696 TEST_ASSERT_EQUAL(rte_eth_rx_burst( 3697 test_params->bonded_port_id, 0, rx_pkt_burst, MAX_PKT_BURST), 3698 burst_size[0] + burst_size[1] + burst_size[2], 3699 "rx burst failed"); 3700 3701 /* Verify bonded device rx count */ 3702 rte_eth_stats_get(test_params->bonded_port_id, &port_stats); 3703 TEST_ASSERT_EQUAL(port_stats.ipackets, 3704 (uint64_t)(burst_size[0] + burst_size[1] + burst_size[2]), 3705 "Bonded Port (%d) ipackets value (%u) not as expected (%d)", 3706 test_params->bonded_port_id, (unsigned int)port_stats.ipackets, 3707 burst_size[0] + burst_size[1] + burst_size[2]); 3708 3709 3710 /* Verify bonded slave devices rx counts */ 3711 rte_eth_stats_get(test_params->slave_port_ids[0], &port_stats); 3712 TEST_ASSERT_EQUAL(port_stats.ipackets, (uint64_t)burst_size[0], 3713 "Slave Port (%d) ipackets value (%u) not as expected (%d)", 3714 test_params->slave_port_ids[0], (unsigned int)port_stats.ipackets, 3715 burst_size[0]); 3716 3717 rte_eth_stats_get(test_params->slave_port_ids[1], &port_stats); 3718 TEST_ASSERT_EQUAL(port_stats.ipackets, (uint64_t)burst_size[1], 3719 "Slave Port (%d) ipackets value (%u) not as expected (%d)", 3720 test_params->slave_port_ids[0], (unsigned int)port_stats.ipackets, 3721 burst_size[1]); 3722 3723 rte_eth_stats_get(test_params->slave_port_ids[2], &port_stats); 3724 TEST_ASSERT_EQUAL(port_stats.ipackets, (uint64_t)burst_size[2], 3725 "Slave Port (%d) ipackets value (%u) not as expected (%d)", 3726 test_params->slave_port_ids[2], (unsigned int)port_stats.ipackets, 3727 burst_size[2]); 3728 3729 rte_eth_stats_get(test_params->slave_port_ids[3], &port_stats); 3730 TEST_ASSERT_EQUAL(port_stats.ipackets, 0, 3731 "Slave Port (%d) ipackets value (%u) not as expected (%d)", 3732 test_params->slave_port_ids[3], (unsigned int)port_stats.ipackets, 3733 0); 3734 3735 /* free mbufs allocate for rx testing */ 3736 for (i = 0; i < BROADCAST_RX_BURST_NUM_OF_SLAVES; i++) { 3737 for (j = 0; j < MAX_PKT_BURST; j++) { 3738 if (gen_pkt_burst[i][j] != NULL) { 3739 rte_pktmbuf_free(gen_pkt_burst[i][j]); 3740 gen_pkt_burst[i][j] = NULL; 3741 } 3742 } 3743 } 3744 3745 /* Clean up and remove slaves from bonded device */ 3746 return remove_slaves_and_stop_bonded_device(); 3747 } 3748 3749 static int 3750 test_broadcast_verify_promiscuous_enable_disable(void) 3751 { 3752 int i; 3753 3754 /* Initialize bonded device with 4 slaves in round robin mode */ 3755 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 3756 BONDING_MODE_BROADCAST, 0, 4, 1), 3757 "Failed to intialise bonded device"); 3758 3759 rte_eth_promiscuous_enable(test_params->bonded_port_id); 3760 3761 3762 TEST_ASSERT_EQUAL(rte_eth_promiscuous_get(test_params->bonded_port_id), 1, 3763 "Port (%d) promiscuous mode not enabled", 3764 test_params->bonded_port_id); 3765 3766 for (i = 0; i < test_params->bonded_slave_count; i++) { 3767 TEST_ASSERT_EQUAL(rte_eth_promiscuous_get( 3768 test_params->slave_port_ids[i]), 1, 3769 "Port (%d) promiscuous mode not enabled", 3770 test_params->slave_port_ids[i]); 3771 } 3772 3773 rte_eth_promiscuous_disable(test_params->bonded_port_id); 3774 3775 TEST_ASSERT_EQUAL(rte_eth_promiscuous_get(test_params->bonded_port_id), 0, 3776 "Port (%d) promiscuous mode not disabled", 3777 test_params->bonded_port_id); 3778 3779 for (i = 0; i < test_params->bonded_slave_count; i++) { 3780 TEST_ASSERT_EQUAL(rte_eth_promiscuous_get( 3781 test_params->slave_port_ids[i]), 0, 3782 "Port (%d) promiscuous mode not disabled", 3783 test_params->slave_port_ids[i]); 3784 } 3785 3786 /* Clean up and remove slaves from bonded device */ 3787 return remove_slaves_and_stop_bonded_device(); 3788 } 3789 3790 static int 3791 test_broadcast_verify_mac_assignment(void) 3792 { 3793 struct ether_addr read_mac_addr, expected_mac_addr_0, expected_mac_addr_1; 3794 3795 int i; 3796 3797 rte_eth_macaddr_get(test_params->slave_port_ids[0], &expected_mac_addr_0); 3798 rte_eth_macaddr_get(test_params->slave_port_ids[2], &expected_mac_addr_1); 3799 3800 /* Initialize bonded device with 4 slaves in round robin mode */ 3801 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 3802 BONDING_MODE_BROADCAST, 0, 4, 1), 3803 "Failed to intialise bonded device"); 3804 3805 /* Verify that all MACs are the same as first slave added to bonded 3806 * device */ 3807 for (i = 0; i < test_params->bonded_slave_count; i++) { 3808 rte_eth_macaddr_get(test_params->slave_port_ids[i], &read_mac_addr); 3809 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_0, &read_mac_addr, 3810 sizeof(read_mac_addr)), 3811 "slave port (%d) mac address not set to that of primary port", 3812 test_params->slave_port_ids[i]); 3813 } 3814 3815 /* change primary and verify that MAC addresses haven't changed */ 3816 TEST_ASSERT_SUCCESS(rte_eth_bond_primary_set(test_params->bonded_port_id, 3817 test_params->slave_port_ids[2]), 3818 "Failed to set bonded port (%d) primary port to (%d)", 3819 test_params->bonded_port_id, test_params->slave_port_ids[i]); 3820 3821 for (i = 0; i < test_params->bonded_slave_count; i++) { 3822 rte_eth_macaddr_get(test_params->slave_port_ids[i], &read_mac_addr); 3823 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_0, &read_mac_addr, 3824 sizeof(read_mac_addr)), 3825 "slave port (%d) mac address has changed to that of primary " 3826 "port without stop/start toggle of bonded device", 3827 test_params->slave_port_ids[i]); 3828 } 3829 3830 /* stop / start bonded device and verify that primary MAC address is 3831 * propagated to bonded device and slaves */ 3832 3833 rte_eth_dev_stop(test_params->bonded_port_id); 3834 3835 TEST_ASSERT_SUCCESS(rte_eth_dev_start(test_params->bonded_port_id), 3836 "Failed to start bonded device"); 3837 3838 rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr); 3839 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_1, &read_mac_addr, 3840 sizeof(read_mac_addr)), 3841 "bonded port (%d) mac address not set to that of new primary port", 3842 test_params->slave_port_ids[i]); 3843 3844 for (i = 0; i < test_params->bonded_slave_count; i++) { 3845 rte_eth_macaddr_get(test_params->slave_port_ids[i], &read_mac_addr); 3846 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_1, &read_mac_addr, 3847 sizeof(read_mac_addr)), 3848 "slave port (%d) mac address not set to that of new primary " 3849 "port", test_params->slave_port_ids[i]); 3850 } 3851 3852 /* Set explicit MAC address */ 3853 TEST_ASSERT_SUCCESS(rte_eth_bond_mac_address_set( 3854 test_params->bonded_port_id, (struct ether_addr *)bonded_mac), 3855 "Failed to set MAC address"); 3856 3857 rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr); 3858 TEST_ASSERT_SUCCESS(memcmp(bonded_mac, &read_mac_addr, 3859 sizeof(read_mac_addr)), 3860 "bonded port (%d) mac address not set to that of new primary port", 3861 test_params->slave_port_ids[i]); 3862 3863 3864 for (i = 0; i < test_params->bonded_slave_count; i++) { 3865 rte_eth_macaddr_get(test_params->slave_port_ids[i], &read_mac_addr); 3866 TEST_ASSERT_SUCCESS(memcmp(bonded_mac, &read_mac_addr, 3867 sizeof(read_mac_addr)), 3868 "slave port (%d) mac address not set to that of new primary " 3869 "port", test_params->slave_port_ids[i]); 3870 } 3871 3872 /* Clean up and remove slaves from bonded device */ 3873 return remove_slaves_and_stop_bonded_device(); 3874 } 3875 3876 #define BROADCAST_LINK_STATUS_NUM_OF_SLAVES (4) 3877 static int 3878 test_broadcast_verify_slave_link_status_change_behaviour(void) 3879 { 3880 struct rte_mbuf *pkt_burst[BROADCAST_LINK_STATUS_NUM_OF_SLAVES][MAX_PKT_BURST]; 3881 struct rte_mbuf *rx_pkt_burst[MAX_PKT_BURST] = { NULL }; 3882 struct rte_eth_stats port_stats; 3883 3884 uint8_t slaves[RTE_MAX_ETHPORTS]; 3885 3886 int i, j, burst_size, slave_count; 3887 3888 memset(pkt_burst, 0, sizeof(pkt_burst)); 3889 3890 /* Initialize bonded device with 4 slaves in round robin mode */ 3891 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 3892 BONDING_MODE_BROADCAST, 0, BROADCAST_LINK_STATUS_NUM_OF_SLAVES, 3893 1), "Failed to intialise bonded device"); 3894 3895 /* Verify Current Slaves Count /Active Slave Count is */ 3896 slave_count = rte_eth_bond_slaves_get(test_params->bonded_port_id, slaves, 3897 RTE_MAX_ETHPORTS); 3898 TEST_ASSERT_EQUAL(slave_count, 4, 3899 "Number of slaves (%d) is not as expected (%d).", 3900 slave_count, 4); 3901 3902 slave_count = rte_eth_bond_active_slaves_get(test_params->bonded_port_id, 3903 slaves, RTE_MAX_ETHPORTS); 3904 TEST_ASSERT_EQUAL(slave_count, 4, 3905 "Number of active slaves (%d) is not as expected (%d).", 3906 slave_count, 4); 3907 3908 /* Set 2 slaves link status to down */ 3909 virtual_ethdev_simulate_link_status_interrupt( 3910 test_params->slave_port_ids[1], 0); 3911 virtual_ethdev_simulate_link_status_interrupt( 3912 test_params->slave_port_ids[3], 0); 3913 3914 slave_count = rte_eth_bond_active_slaves_get(test_params->bonded_port_id, 3915 slaves, RTE_MAX_ETHPORTS); 3916 TEST_ASSERT_EQUAL(slave_count, 2, 3917 "Number of active slaves (%d) is not as expected (%d).", 3918 slave_count, 2); 3919 3920 for (i = 0; i < test_params->bonded_slave_count; i++) 3921 rte_eth_stats_reset(test_params->slave_port_ids[i]); 3922 3923 /* Verify that pkts are not sent on slaves with link status down */ 3924 burst_size = 21; 3925 3926 TEST_ASSERT_EQUAL(generate_test_burst( 3927 &pkt_burst[0][0], burst_size, 0, 0, 1, 0, 0), burst_size, 3928 "generate_test_burst failed"); 3929 3930 TEST_ASSERT_EQUAL(rte_eth_tx_burst(test_params->bonded_port_id, 0, 3931 &pkt_burst[0][0], burst_size), burst_size, 3932 "rte_eth_tx_burst failed\n"); 3933 3934 rte_eth_stats_get(test_params->bonded_port_id, &port_stats); 3935 TEST_ASSERT_EQUAL(port_stats.opackets, (uint64_t)(burst_size * slave_count), 3936 "(%d) port_stats.opackets (%d) not as expected (%d)\n", 3937 test_params->bonded_port_id, (int)port_stats.opackets, 3938 burst_size * slave_count); 3939 3940 rte_eth_stats_get(test_params->slave_port_ids[0], &port_stats); 3941 TEST_ASSERT_EQUAL(port_stats.opackets, (uint64_t)burst_size, 3942 "(%d) port_stats.opackets not as expected", 3943 test_params->slave_port_ids[0]); 3944 3945 rte_eth_stats_get(test_params->slave_port_ids[1], &port_stats); 3946 TEST_ASSERT_EQUAL(port_stats.opackets, 0, 3947 "(%d) port_stats.opackets not as expected", 3948 test_params->slave_port_ids[1]); 3949 3950 rte_eth_stats_get(test_params->slave_port_ids[2], &port_stats); 3951 TEST_ASSERT_EQUAL(port_stats.opackets, (uint64_t)burst_size, 3952 "(%d) port_stats.opackets not as expected", 3953 test_params->slave_port_ids[2]); 3954 3955 3956 rte_eth_stats_get(test_params->slave_port_ids[3], &port_stats); 3957 TEST_ASSERT_EQUAL(port_stats.opackets, 0, 3958 "(%d) port_stats.opackets not as expected", 3959 test_params->slave_port_ids[3]); 3960 3961 3962 for (i = 0; i < BROADCAST_LINK_STATUS_NUM_OF_SLAVES; i++) { 3963 TEST_ASSERT_EQUAL(generate_test_burst( 3964 &pkt_burst[i][0], burst_size, 0, 0, 1, 0, 0), 3965 burst_size, "failed to generate packet burst"); 3966 3967 virtual_ethdev_add_mbufs_to_rx_queue(test_params->slave_port_ids[i], 3968 &pkt_burst[i][0], burst_size); 3969 } 3970 3971 /* Verify that pkts are not received on slaves with link status down */ 3972 TEST_ASSERT_EQUAL(rte_eth_rx_burst( 3973 test_params->bonded_port_id, 0, rx_pkt_burst, MAX_PKT_BURST), 3974 burst_size + burst_size, "rte_eth_rx_burst failed"); 3975 3976 3977 /* Verify bonded device rx count */ 3978 rte_eth_stats_get(test_params->bonded_port_id, &port_stats); 3979 TEST_ASSERT_EQUAL(port_stats.ipackets, (uint64_t)(burst_size + burst_size), 3980 "(%d) port_stats.ipackets not as expected\n", 3981 test_params->bonded_port_id); 3982 3983 /* free mbufs allocate for rx testing */ 3984 for (i = 0; i < BROADCAST_LINK_STATUS_NUM_OF_SLAVES; i++) { 3985 for (j = 0; j < MAX_PKT_BURST; j++) { 3986 if (pkt_burst[i][j] != NULL) { 3987 rte_pktmbuf_free(pkt_burst[i][j]); 3988 pkt_burst[i][j] = NULL; 3989 } 3990 } 3991 } 3992 3993 /* Clean up and remove slaves from bonded device */ 3994 return remove_slaves_and_stop_bonded_device(); 3995 } 3996 3997 static int 3998 test_reconfigure_bonded_device(void) 3999 { 4000 test_params->nb_rx_q = 4; 4001 test_params->nb_tx_q = 4; 4002 4003 TEST_ASSERT_SUCCESS(configure_ethdev(test_params->bonded_port_id, 0, 0), 4004 "failed to reconfigure bonded device"); 4005 4006 test_params->nb_rx_q = 2; 4007 test_params->nb_tx_q = 2; 4008 4009 TEST_ASSERT_SUCCESS(configure_ethdev(test_params->bonded_port_id, 0, 0), 4010 "failed to reconfigure bonded device with less rx/tx queues"); 4011 4012 return 0; 4013 } 4014 4015 4016 static int 4017 test_close_bonded_device(void) 4018 { 4019 rte_eth_dev_close(test_params->bonded_port_id); 4020 return 0; 4021 } 4022 4023 static void 4024 testsuite_teardown(void) 4025 { 4026 free(test_params->pkt_eth_hdr); 4027 test_params->pkt_eth_hdr = NULL; 4028 4029 /* Clean up and remove slaves from bonded device */ 4030 remove_slaves_and_stop_bonded_device(); 4031 } 4032 4033 static void 4034 free_virtualpmd_tx_queue(void) 4035 { 4036 int i, slave_port, to_free_cnt; 4037 struct rte_mbuf *pkts_to_free[MAX_PKT_BURST]; 4038 4039 /* Free tx queue of virtual pmd */ 4040 for (slave_port = 0; slave_port < test_params->bonded_slave_count; 4041 slave_port++) { 4042 to_free_cnt = virtual_ethdev_get_mbufs_from_tx_queue( 4043 test_params->slave_port_ids[slave_port], 4044 pkts_to_free, MAX_PKT_BURST); 4045 for (i = 0; i < to_free_cnt; i++) 4046 rte_pktmbuf_free(pkts_to_free[i]); 4047 } 4048 } 4049 4050 static int 4051 test_tlb_tx_burst(void) 4052 { 4053 int i, burst_size, nb_tx; 4054 uint64_t nb_tx2 = 0; 4055 struct rte_mbuf *pkt_burst[MAX_PKT_BURST]; 4056 struct rte_eth_stats port_stats[32]; 4057 uint64_t sum_ports_opackets = 0, all_bond_opackets = 0, all_bond_obytes = 0; 4058 uint16_t pktlen; 4059 4060 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves 4061 (BONDING_MODE_TLB, 1, 3, 1), 4062 "Failed to initialise bonded device"); 4063 4064 burst_size = 20 * test_params->bonded_slave_count; 4065 4066 TEST_ASSERT(burst_size < MAX_PKT_BURST, 4067 "Burst size specified is greater than supported.\n"); 4068 4069 4070 /* Generate bursts of packets */ 4071 for (i = 0; i < 400000; i++) { 4072 /*test two types of mac src own(bonding) and others */ 4073 if (i % 2 == 0) { 4074 initialize_eth_header(test_params->pkt_eth_hdr, 4075 (struct ether_addr *)src_mac, 4076 (struct ether_addr *)dst_mac_0, ETHER_TYPE_IPv4, 0, 0); 4077 } else { 4078 initialize_eth_header(test_params->pkt_eth_hdr, 4079 (struct ether_addr *)test_params->default_slave_mac, 4080 (struct ether_addr *)dst_mac_0, ETHER_TYPE_IPv4, 0, 0); 4081 } 4082 pktlen = initialize_udp_header(test_params->pkt_udp_hdr, src_port, 4083 dst_port_0, 16); 4084 pktlen = initialize_ipv4_header(test_params->pkt_ipv4_hdr, src_addr, 4085 dst_addr_0, pktlen); 4086 generate_packet_burst(test_params->mbuf_pool, pkt_burst, 4087 test_params->pkt_eth_hdr, 0, test_params->pkt_ipv4_hdr, 4088 1, test_params->pkt_udp_hdr, burst_size, 60, 1); 4089 /* Send burst on bonded port */ 4090 nb_tx = rte_eth_tx_burst(test_params->bonded_port_id, 0, pkt_burst, 4091 burst_size); 4092 nb_tx2 += nb_tx; 4093 4094 free_virtualpmd_tx_queue(); 4095 4096 TEST_ASSERT_EQUAL(nb_tx, burst_size, 4097 "number of packet not equal burst size"); 4098 4099 rte_delay_us(5); 4100 } 4101 4102 4103 /* Verify bonded port tx stats */ 4104 rte_eth_stats_get(test_params->bonded_port_id, &port_stats[0]); 4105 4106 all_bond_opackets = port_stats[0].opackets; 4107 all_bond_obytes = port_stats[0].obytes; 4108 4109 TEST_ASSERT_EQUAL(port_stats[0].opackets, (uint64_t)nb_tx2, 4110 "Bonded Port (%d) opackets value (%u) not as expected (%d)\n", 4111 test_params->bonded_port_id, (unsigned int)port_stats[0].opackets, 4112 burst_size); 4113 4114 4115 /* Verify slave ports tx stats */ 4116 for (i = 0; i < test_params->bonded_slave_count; i++) { 4117 rte_eth_stats_get(test_params->slave_port_ids[i], &port_stats[i]); 4118 sum_ports_opackets += port_stats[i].opackets; 4119 } 4120 4121 TEST_ASSERT_EQUAL(sum_ports_opackets, (uint64_t)all_bond_opackets, 4122 "Total packets sent by slaves is not equal to packets sent by bond interface"); 4123 4124 /* checking if distribution of packets is balanced over slaves */ 4125 for (i = 0; i < test_params->bonded_slave_count; i++) { 4126 TEST_ASSERT(port_stats[i].obytes > 0 && 4127 port_stats[i].obytes < all_bond_obytes, 4128 "Packets are not balanced over slaves"); 4129 } 4130 4131 /* Put all slaves down and try and transmit */ 4132 for (i = 0; i < test_params->bonded_slave_count; i++) { 4133 virtual_ethdev_simulate_link_status_interrupt( 4134 test_params->slave_port_ids[i], 0); 4135 } 4136 4137 /* Send burst on bonded port */ 4138 nb_tx = rte_eth_tx_burst(test_params->bonded_port_id, 0, pkt_burst, 4139 burst_size); 4140 TEST_ASSERT_EQUAL(nb_tx, 0, " bad number of packet in burst"); 4141 4142 /* Clean ugit checkout masterp and remove slaves from bonded device */ 4143 return remove_slaves_and_stop_bonded_device(); 4144 } 4145 4146 #define TEST_ADAPTIVE_TRANSMIT_LOAD_BALANCING_RX_BURST_SLAVE_COUNT (4) 4147 4148 static int 4149 test_tlb_rx_burst(void) 4150 { 4151 struct rte_mbuf *gen_pkt_burst[MAX_PKT_BURST] = { NULL }; 4152 struct rte_mbuf *rx_pkt_burst[MAX_PKT_BURST] = { NULL }; 4153 4154 struct rte_eth_stats port_stats; 4155 4156 int primary_port; 4157 4158 uint16_t i, j, nb_rx, burst_size = 17; 4159 4160 /* Initialize bonded device with 4 slaves in transmit load balancing mode */ 4161 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 4162 BONDING_MODE_TLB, 4163 TEST_ADAPTIVE_TRANSMIT_LOAD_BALANCING_RX_BURST_SLAVE_COUNT, 1, 1), 4164 "Failed to initialize bonded device"); 4165 4166 4167 primary_port = rte_eth_bond_primary_get(test_params->bonded_port_id); 4168 TEST_ASSERT(primary_port >= 0, 4169 "failed to get primary slave for bonded port (%d)", 4170 test_params->bonded_port_id); 4171 4172 for (i = 0; i < test_params->bonded_slave_count; i++) { 4173 /* Generate test bursts of packets to transmit */ 4174 TEST_ASSERT_EQUAL(generate_test_burst( 4175 &gen_pkt_burst[0], burst_size, 0, 1, 0, 0, 0), burst_size, 4176 "burst generation failed"); 4177 4178 /* Add rx data to slave */ 4179 virtual_ethdev_add_mbufs_to_rx_queue(test_params->slave_port_ids[i], 4180 &gen_pkt_burst[0], burst_size); 4181 4182 /* Call rx burst on bonded device */ 4183 nb_rx = rte_eth_rx_burst(test_params->bonded_port_id, 0, 4184 &rx_pkt_burst[0], MAX_PKT_BURST); 4185 4186 TEST_ASSERT_EQUAL(nb_rx, burst_size, "rte_eth_rx_burst failed\n"); 4187 4188 if (test_params->slave_port_ids[i] == primary_port) { 4189 /* Verify bonded device rx count */ 4190 rte_eth_stats_get(test_params->bonded_port_id, &port_stats); 4191 TEST_ASSERT_EQUAL(port_stats.ipackets, (uint64_t)burst_size, 4192 "Bonded Port (%d) ipackets value (%u) not as expected (%d)\n", 4193 test_params->bonded_port_id, 4194 (unsigned int)port_stats.ipackets, burst_size); 4195 4196 /* Verify bonded slave devices rx count */ 4197 for (j = 0; j < test_params->bonded_slave_count; j++) { 4198 rte_eth_stats_get(test_params->slave_port_ids[j], &port_stats); 4199 if (i == j) { 4200 TEST_ASSERT_EQUAL(port_stats.ipackets, (uint64_t)burst_size, 4201 "Slave Port (%d) ipackets value (%u) not as expected (%d)\n", 4202 test_params->slave_port_ids[i], 4203 (unsigned int)port_stats.ipackets, burst_size); 4204 } else { 4205 TEST_ASSERT_EQUAL(port_stats.ipackets, (uint64_t)0, 4206 "Slave Port (%d) ipackets value (%u) not as expected (%d)\n", 4207 test_params->slave_port_ids[i], 4208 (unsigned int)port_stats.ipackets, 0); 4209 } 4210 } 4211 } else { 4212 for (j = 0; j < test_params->bonded_slave_count; j++) { 4213 rte_eth_stats_get(test_params->slave_port_ids[j], &port_stats); 4214 TEST_ASSERT_EQUAL(port_stats.ipackets, (uint64_t)0, 4215 "Slave Port (%d) ipackets value (%u) not as expected (%d)\n", 4216 test_params->slave_port_ids[i], 4217 (unsigned int)port_stats.ipackets, 0); 4218 } 4219 } 4220 4221 /* free mbufs */ 4222 for (i = 0; i < burst_size; i++) 4223 rte_pktmbuf_free(rx_pkt_burst[i]); 4224 4225 /* reset bonded device stats */ 4226 rte_eth_stats_reset(test_params->bonded_port_id); 4227 } 4228 4229 /* Clean up and remove slaves from bonded device */ 4230 return remove_slaves_and_stop_bonded_device(); 4231 } 4232 4233 static int 4234 test_tlb_verify_promiscuous_enable_disable(void) 4235 { 4236 int i, primary_port, promiscuous_en; 4237 4238 /* Initialize bonded device with 4 slaves in transmit load balancing mode */ 4239 TEST_ASSERT_SUCCESS( initialize_bonded_device_with_slaves( 4240 BONDING_MODE_TLB, 0, 4, 1), 4241 "Failed to initialize bonded device"); 4242 4243 primary_port = rte_eth_bond_primary_get(test_params->bonded_port_id); 4244 TEST_ASSERT(primary_port >= 0, 4245 "failed to get primary slave for bonded port (%d)", 4246 test_params->bonded_port_id); 4247 4248 rte_eth_promiscuous_enable(test_params->bonded_port_id); 4249 4250 promiscuous_en = rte_eth_promiscuous_get(test_params->bonded_port_id); 4251 TEST_ASSERT_EQUAL(promiscuous_en, (int)1, 4252 "Port (%d) promiscuous mode not enabled\n", 4253 test_params->bonded_port_id); 4254 for (i = 0; i < test_params->bonded_slave_count; i++) { 4255 promiscuous_en = rte_eth_promiscuous_get( 4256 test_params->slave_port_ids[i]); 4257 if (primary_port == test_params->slave_port_ids[i]) { 4258 TEST_ASSERT_EQUAL(promiscuous_en, (int)1, 4259 "Port (%d) promiscuous mode not enabled\n", 4260 test_params->bonded_port_id); 4261 } else { 4262 TEST_ASSERT_EQUAL(promiscuous_en, (int)0, 4263 "Port (%d) promiscuous mode enabled\n", 4264 test_params->bonded_port_id); 4265 } 4266 4267 } 4268 4269 rte_eth_promiscuous_disable(test_params->bonded_port_id); 4270 4271 promiscuous_en = rte_eth_promiscuous_get(test_params->bonded_port_id); 4272 TEST_ASSERT_EQUAL(promiscuous_en, (int)0, 4273 "Port (%d) promiscuous mode not disabled\n", 4274 test_params->bonded_port_id); 4275 4276 for (i = 0; i < test_params->bonded_slave_count; i++) { 4277 promiscuous_en = rte_eth_promiscuous_get( 4278 test_params->slave_port_ids[i]); 4279 TEST_ASSERT_EQUAL(promiscuous_en, (int)0, 4280 "slave port (%d) promiscuous mode not disabled\n", 4281 test_params->slave_port_ids[i]); 4282 } 4283 4284 /* Clean up and remove slaves from bonded device */ 4285 return remove_slaves_and_stop_bonded_device(); 4286 } 4287 4288 static int 4289 test_tlb_verify_mac_assignment(void) 4290 { 4291 struct ether_addr read_mac_addr, expected_mac_addr_0, expected_mac_addr_1; 4292 4293 rte_eth_macaddr_get(test_params->slave_port_ids[0], &expected_mac_addr_0); 4294 rte_eth_macaddr_get(test_params->slave_port_ids[1], &expected_mac_addr_1); 4295 4296 /* Initialize bonded device with 2 slaves in active backup mode */ 4297 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 4298 BONDING_MODE_TLB, 0, 2, 1), 4299 "Failed to initialize bonded device"); 4300 4301 /* Verify that bonded MACs is that of first slave and that the other slave 4302 * MAC hasn't been changed */ 4303 rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr); 4304 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_0, &read_mac_addr, 4305 sizeof(read_mac_addr)), 4306 "bonded port (%d) mac address not set to that of primary port", 4307 test_params->bonded_port_id); 4308 4309 rte_eth_macaddr_get(test_params->slave_port_ids[0], &read_mac_addr); 4310 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_0, &read_mac_addr, 4311 sizeof(read_mac_addr)), 4312 "slave port (%d) mac address not set to that of primary port", 4313 test_params->slave_port_ids[0]); 4314 4315 rte_eth_macaddr_get(test_params->slave_port_ids[1], &read_mac_addr); 4316 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_1, &read_mac_addr, 4317 sizeof(read_mac_addr)), 4318 "slave port (%d) mac address not as expected", 4319 test_params->slave_port_ids[1]); 4320 4321 /* change primary and verify that MAC addresses haven't changed */ 4322 TEST_ASSERT_EQUAL(rte_eth_bond_primary_set(test_params->bonded_port_id, 4323 test_params->slave_port_ids[1]), 0, 4324 "Failed to set bonded port (%d) primary port to (%d)", 4325 test_params->bonded_port_id, test_params->slave_port_ids[1]); 4326 4327 rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr); 4328 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_0, &read_mac_addr, 4329 sizeof(read_mac_addr)), 4330 "bonded port (%d) mac address not set to that of primary port", 4331 test_params->bonded_port_id); 4332 4333 rte_eth_macaddr_get(test_params->slave_port_ids[0], &read_mac_addr); 4334 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_0, &read_mac_addr, 4335 sizeof(read_mac_addr)), 4336 "slave port (%d) mac address not set to that of primary port", 4337 test_params->slave_port_ids[0]); 4338 4339 rte_eth_macaddr_get(test_params->slave_port_ids[1], &read_mac_addr); 4340 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_1, &read_mac_addr, 4341 sizeof(read_mac_addr)), 4342 "slave port (%d) mac address not as expected", 4343 test_params->slave_port_ids[1]); 4344 4345 /* stop / start bonded device and verify that primary MAC address is 4346 * propagated to bonded device and slaves */ 4347 4348 rte_eth_dev_stop(test_params->bonded_port_id); 4349 4350 TEST_ASSERT_SUCCESS(rte_eth_dev_start(test_params->bonded_port_id), 4351 "Failed to start device"); 4352 4353 rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr); 4354 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_1, &read_mac_addr, 4355 sizeof(read_mac_addr)), 4356 "bonded port (%d) mac address not set to that of primary port", 4357 test_params->bonded_port_id); 4358 4359 rte_eth_macaddr_get(test_params->slave_port_ids[0], &read_mac_addr); 4360 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_0, &read_mac_addr, 4361 sizeof(read_mac_addr)), 4362 "slave port (%d) mac address not as expected", 4363 test_params->slave_port_ids[0]); 4364 4365 rte_eth_macaddr_get(test_params->slave_port_ids[1], &read_mac_addr); 4366 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_1, &read_mac_addr, 4367 sizeof(read_mac_addr)), 4368 "slave port (%d) mac address not set to that of primary port", 4369 test_params->slave_port_ids[1]); 4370 4371 4372 /* Set explicit MAC address */ 4373 TEST_ASSERT_SUCCESS(rte_eth_bond_mac_address_set( 4374 test_params->bonded_port_id, (struct ether_addr *)bonded_mac), 4375 "failed to set MAC addres"); 4376 4377 rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr); 4378 TEST_ASSERT_SUCCESS(memcmp(&bonded_mac, &read_mac_addr, 4379 sizeof(read_mac_addr)), 4380 "bonded port (%d) mac address not set to that of bonded port", 4381 test_params->bonded_port_id); 4382 4383 rte_eth_macaddr_get(test_params->slave_port_ids[0], &read_mac_addr); 4384 TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_0, &read_mac_addr, 4385 sizeof(read_mac_addr)), 4386 "slave port (%d) mac address not as expected", 4387 test_params->slave_port_ids[0]); 4388 4389 rte_eth_macaddr_get(test_params->slave_port_ids[1], &read_mac_addr); 4390 TEST_ASSERT_SUCCESS(memcmp(&bonded_mac, &read_mac_addr, 4391 sizeof(read_mac_addr)), 4392 "slave port (%d) mac address not set to that of bonded port", 4393 test_params->slave_port_ids[1]); 4394 4395 /* Clean up and remove slaves from bonded device */ 4396 return remove_slaves_and_stop_bonded_device(); 4397 } 4398 4399 static int 4400 test_tlb_verify_slave_link_status_change_failover(void) 4401 { 4402 struct rte_mbuf *pkt_burst[TEST_ADAPTIVE_TRANSMIT_LOAD_BALANCING_RX_BURST_SLAVE_COUNT][MAX_PKT_BURST]; 4403 struct rte_mbuf *rx_pkt_burst[MAX_PKT_BURST] = { NULL }; 4404 struct rte_eth_stats port_stats; 4405 4406 uint8_t slaves[RTE_MAX_ETHPORTS]; 4407 4408 int i, j, burst_size, slave_count, primary_port; 4409 4410 burst_size = 21; 4411 4412 memset(pkt_burst, 0, sizeof(pkt_burst)); 4413 4414 4415 4416 /* Initialize bonded device with 4 slaves in round robin mode */ 4417 TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves( 4418 BONDING_MODE_TLB, 0, 4419 TEST_ADAPTIVE_TRANSMIT_LOAD_BALANCING_RX_BURST_SLAVE_COUNT, 1), 4420 "Failed to initialize bonded device with slaves"); 4421 4422 /* Verify Current Slaves Count /Active Slave Count is */ 4423 slave_count = rte_eth_bond_slaves_get(test_params->bonded_port_id, slaves, 4424 RTE_MAX_ETHPORTS); 4425 TEST_ASSERT_EQUAL(slave_count, 4, 4426 "Number of slaves (%d) is not as expected (%d).\n", 4427 slave_count, 4); 4428 4429 slave_count = rte_eth_bond_active_slaves_get(test_params->bonded_port_id, 4430 slaves, RTE_MAX_ETHPORTS); 4431 TEST_ASSERT_EQUAL(slave_count, (int)4, 4432 "Number of slaves (%d) is not as expected (%d).\n", 4433 slave_count, 4); 4434 4435 primary_port = rte_eth_bond_primary_get(test_params->bonded_port_id); 4436 TEST_ASSERT_EQUAL(primary_port, test_params->slave_port_ids[0], 4437 "Primary port not as expected"); 4438 4439 /* Bring 2 slaves down and verify active slave count */ 4440 virtual_ethdev_simulate_link_status_interrupt( 4441 test_params->slave_port_ids[1], 0); 4442 virtual_ethdev_simulate_link_status_interrupt( 4443 test_params->slave_port_ids[3], 0); 4444 4445 TEST_ASSERT_EQUAL(rte_eth_bond_active_slaves_get( 4446 test_params->bonded_port_id, slaves, RTE_MAX_ETHPORTS), 2, 4447 "Number of active slaves (%d) is not as expected (%d).", 4448 slave_count, 2); 4449 4450 virtual_ethdev_simulate_link_status_interrupt( 4451 test_params->slave_port_ids[1], 1); 4452 virtual_ethdev_simulate_link_status_interrupt( 4453 test_params->slave_port_ids[3], 1); 4454 4455 4456 /* Bring primary port down, verify that active slave count is 3 and primary 4457 * has changed */ 4458 virtual_ethdev_simulate_link_status_interrupt( 4459 test_params->slave_port_ids[0], 0); 4460 4461 TEST_ASSERT_EQUAL(rte_eth_bond_active_slaves_get( 4462 test_params->bonded_port_id, slaves, RTE_MAX_ETHPORTS), 3, 4463 "Number of active slaves (%d) is not as expected (%d).", 4464 slave_count, 3); 4465 4466 primary_port = rte_eth_bond_primary_get(test_params->bonded_port_id); 4467 TEST_ASSERT_EQUAL(primary_port, test_params->slave_port_ids[2], 4468 "Primary port not as expected"); 4469 rte_delay_us(500000); 4470 /* Verify that pkts are sent on new primary slave */ 4471 for (i = 0; i < 4; i++) { 4472 TEST_ASSERT_EQUAL(generate_test_burst( 4473 &pkt_burst[0][0], burst_size, 0, 1, 0, 0, 0), burst_size, 4474 "generate_test_burst failed\n"); 4475 TEST_ASSERT_EQUAL(rte_eth_tx_burst( 4476 test_params->bonded_port_id, 0, &pkt_burst[0][0], burst_size), burst_size, 4477 "rte_eth_tx_burst failed\n"); 4478 rte_delay_us(11000); 4479 } 4480 4481 rte_eth_stats_get(test_params->slave_port_ids[0], &port_stats); 4482 TEST_ASSERT_EQUAL(port_stats.opackets, (int8_t)0, 4483 "(%d) port_stats.opackets not as expected\n", 4484 test_params->slave_port_ids[0]); 4485 4486 rte_eth_stats_get(test_params->slave_port_ids[1], &port_stats); 4487 TEST_ASSERT_NOT_EQUAL(port_stats.opackets, (int8_t)0, 4488 "(%d) port_stats.opackets not as expected\n", 4489 test_params->slave_port_ids[1]); 4490 4491 rte_eth_stats_get(test_params->slave_port_ids[2], &port_stats); 4492 TEST_ASSERT_NOT_EQUAL(port_stats.opackets, (int8_t)0, 4493 "(%d) port_stats.opackets not as expected\n", 4494 test_params->slave_port_ids[2]); 4495 4496 rte_eth_stats_get(test_params->slave_port_ids[3], &port_stats); 4497 TEST_ASSERT_NOT_EQUAL(port_stats.opackets, (int8_t)0, 4498 "(%d) port_stats.opackets not as expected\n", 4499 test_params->slave_port_ids[3]); 4500 4501 4502 /* Generate packet burst for testing */ 4503 4504 for (i = 0; i < TEST_ADAPTIVE_TRANSMIT_LOAD_BALANCING_RX_BURST_SLAVE_COUNT; i++) { 4505 if (generate_test_burst(&pkt_burst[i][0], burst_size, 0, 1, 0, 0, 0) != 4506 burst_size) 4507 return -1; 4508 4509 virtual_ethdev_add_mbufs_to_rx_queue( 4510 test_params->slave_port_ids[i], &pkt_burst[i][0], burst_size); 4511 } 4512 4513 if (rte_eth_rx_burst(test_params->bonded_port_id, 0, rx_pkt_burst, 4514 MAX_PKT_BURST) != burst_size) { 4515 printf("rte_eth_rx_burst\n"); 4516 return -1; 4517 4518 } 4519 4520 /* Verify bonded device rx count */ 4521 rte_eth_stats_get(test_params->bonded_port_id, &port_stats); 4522 TEST_ASSERT_EQUAL(port_stats.ipackets, (uint64_t)burst_size, 4523 "(%d) port_stats.ipackets not as expected\n", 4524 test_params->bonded_port_id); 4525 4526 /* free mbufs */ 4527 4528 for (i = 0; i < TEST_ADAPTIVE_TRANSMIT_LOAD_BALANCING_RX_BURST_SLAVE_COUNT; i++) { 4529 for (j = 0; j < MAX_PKT_BURST; j++) { 4530 if (pkt_burst[i][j] != NULL) { 4531 rte_pktmbuf_free(pkt_burst[i][j]); 4532 pkt_burst[i][j] = NULL; 4533 } 4534 } 4535 } 4536 4537 4538 /* Clean up and remove slaves from bonded device */ 4539 return remove_slaves_and_stop_bonded_device(); 4540 } 4541 4542 #define TEST_ALB_SLAVE_COUNT 2 4543 4544 static uint8_t mac_client1[] = {0x00, 0xAA, 0x55, 0xFF, 0xCC, 1}; 4545 static uint8_t mac_client2[] = {0x00, 0xAA, 0x55, 0xFF, 0xCC, 2}; 4546 static uint8_t mac_client3[] = {0x00, 0xAA, 0x55, 0xFF, 0xCC, 3}; 4547 static uint8_t mac_client4[] = {0x00, 0xAA, 0x55, 0xFF, 0xCC, 4}; 4548 4549 static uint32_t ip_host = IPV4_ADDR(192, 168, 0, 0); 4550 static uint32_t ip_client1 = IPV4_ADDR(192, 168, 0, 1); 4551 static uint32_t ip_client2 = IPV4_ADDR(192, 168, 0, 2); 4552 static uint32_t ip_client3 = IPV4_ADDR(192, 168, 0, 3); 4553 static uint32_t ip_client4 = IPV4_ADDR(192, 168, 0, 4); 4554 4555 static int 4556 test_alb_change_mac_in_reply_sent(void) 4557 { 4558 struct rte_mbuf *pkt; 4559 struct rte_mbuf *pkts_sent[MAX_PKT_BURST]; 4560 4561 struct ether_hdr *eth_pkt; 4562 struct arp_hdr *arp_pkt; 4563 4564 int slave_idx, nb_pkts, pkt_idx; 4565 int retval = 0; 4566 4567 struct ether_addr bond_mac, client_mac; 4568 struct ether_addr *slave_mac1, *slave_mac2; 4569 4570 TEST_ASSERT_SUCCESS( 4571 initialize_bonded_device_with_slaves(BONDING_MODE_ALB, 4572 0, TEST_ALB_SLAVE_COUNT, 1), 4573 "Failed to initialize_bonded_device_with_slaves."); 4574 4575 /* Flush tx queue */ 4576 rte_eth_tx_burst(test_params->bonded_port_id, 0, NULL, 0); 4577 for (slave_idx = 0; slave_idx < test_params->bonded_slave_count; 4578 slave_idx++) { 4579 nb_pkts = virtual_ethdev_get_mbufs_from_tx_queue( 4580 test_params->slave_port_ids[slave_idx], pkts_sent, 4581 MAX_PKT_BURST); 4582 } 4583 4584 ether_addr_copy( 4585 rte_eth_devices[test_params->bonded_port_id].data->mac_addrs, 4586 &bond_mac); 4587 4588 /* 4589 * Generating four packets with different mac and ip addresses and sending 4590 * them through the bonding port. 4591 */ 4592 pkt = rte_pktmbuf_alloc(test_params->mbuf_pool); 4593 memcpy(client_mac.addr_bytes, mac_client1, ETHER_ADDR_LEN); 4594 eth_pkt = rte_pktmbuf_mtod(pkt, struct ether_hdr *); 4595 initialize_eth_header(eth_pkt, &bond_mac, &client_mac, ETHER_TYPE_ARP, 0, 4596 0); 4597 arp_pkt = (struct arp_hdr *)((char *)eth_pkt + sizeof(struct ether_hdr)); 4598 initialize_arp_header(arp_pkt, &bond_mac, &client_mac, ip_host, ip_client1, 4599 ARP_OP_REPLY); 4600 rte_eth_tx_burst(test_params->bonded_port_id, 0, &pkt, 1); 4601 4602 pkt = rte_pktmbuf_alloc(test_params->mbuf_pool); 4603 memcpy(client_mac.addr_bytes, mac_client2, ETHER_ADDR_LEN); 4604 eth_pkt = rte_pktmbuf_mtod(pkt, struct ether_hdr *); 4605 initialize_eth_header(eth_pkt, &bond_mac, &client_mac, ETHER_TYPE_ARP, 0, 4606 0); 4607 arp_pkt = (struct arp_hdr *)((char *)eth_pkt + sizeof(struct ether_hdr)); 4608 initialize_arp_header(arp_pkt, &bond_mac, &client_mac, ip_host, ip_client2, 4609 ARP_OP_REPLY); 4610 rte_eth_tx_burst(test_params->bonded_port_id, 0, &pkt, 1); 4611 4612 pkt = rte_pktmbuf_alloc(test_params->mbuf_pool); 4613 memcpy(client_mac.addr_bytes, mac_client3, ETHER_ADDR_LEN); 4614 eth_pkt = rte_pktmbuf_mtod(pkt, struct ether_hdr *); 4615 initialize_eth_header(eth_pkt, &bond_mac, &client_mac, ETHER_TYPE_ARP, 0, 4616 0); 4617 arp_pkt = (struct arp_hdr *)((char *)eth_pkt + sizeof(struct ether_hdr)); 4618 initialize_arp_header(arp_pkt, &bond_mac, &client_mac, ip_host, ip_client3, 4619 ARP_OP_REPLY); 4620 rte_eth_tx_burst(test_params->bonded_port_id, 0, &pkt, 1); 4621 4622 pkt = rte_pktmbuf_alloc(test_params->mbuf_pool); 4623 memcpy(client_mac.addr_bytes, mac_client4, ETHER_ADDR_LEN); 4624 eth_pkt = rte_pktmbuf_mtod(pkt, struct ether_hdr *); 4625 initialize_eth_header(eth_pkt, &bond_mac, &client_mac, ETHER_TYPE_ARP, 0, 4626 0); 4627 arp_pkt = (struct arp_hdr *)((char *)eth_pkt + sizeof(struct ether_hdr)); 4628 initialize_arp_header(arp_pkt, &bond_mac, &client_mac, ip_host, ip_client4, 4629 ARP_OP_REPLY); 4630 rte_eth_tx_burst(test_params->bonded_port_id, 0, &pkt, 1); 4631 4632 slave_mac1 = 4633 rte_eth_devices[test_params->slave_port_ids[0]].data->mac_addrs; 4634 slave_mac2 = 4635 rte_eth_devices[test_params->slave_port_ids[1]].data->mac_addrs; 4636 4637 /* 4638 * Checking if packets are properly distributed on bonding ports. Packets 4639 * 0 and 2 should be sent on port 0 and packets 1 and 3 on port 1. 4640 */ 4641 for (slave_idx = 0; slave_idx < test_params->bonded_slave_count; slave_idx++) { 4642 nb_pkts = virtual_ethdev_get_mbufs_from_tx_queue( 4643 test_params->slave_port_ids[slave_idx], pkts_sent, 4644 MAX_PKT_BURST); 4645 4646 for (pkt_idx = 0; pkt_idx < nb_pkts; pkt_idx++) { 4647 eth_pkt = rte_pktmbuf_mtod(pkts_sent[pkt_idx], struct ether_hdr *); 4648 arp_pkt = (struct arp_hdr *)((char *)eth_pkt + sizeof(struct ether_hdr)); 4649 4650 if (slave_idx%2 == 0) { 4651 if (!is_same_ether_addr(slave_mac1, &arp_pkt->arp_data.arp_sha)) { 4652 retval = -1; 4653 goto test_end; 4654 } 4655 } else { 4656 if (!is_same_ether_addr(slave_mac2, &arp_pkt->arp_data.arp_sha)) { 4657 retval = -1; 4658 goto test_end; 4659 } 4660 } 4661 } 4662 } 4663 4664 test_end: 4665 retval += remove_slaves_and_stop_bonded_device(); 4666 return retval; 4667 } 4668 4669 static int 4670 test_alb_reply_from_client(void) 4671 { 4672 struct ether_hdr *eth_pkt; 4673 struct arp_hdr *arp_pkt; 4674 4675 struct rte_mbuf *pkt; 4676 struct rte_mbuf *pkts_sent[MAX_PKT_BURST]; 4677 4678 int slave_idx, nb_pkts, pkt_idx, nb_pkts_sum = 0; 4679 int retval = 0; 4680 4681 struct ether_addr bond_mac, client_mac; 4682 struct ether_addr *slave_mac1, *slave_mac2; 4683 4684 TEST_ASSERT_SUCCESS( 4685 initialize_bonded_device_with_slaves(BONDING_MODE_ALB, 4686 0, TEST_ALB_SLAVE_COUNT, 1), 4687 "Failed to initialize_bonded_device_with_slaves."); 4688 4689 /* Flush tx queue */ 4690 rte_eth_tx_burst(test_params->bonded_port_id, 0, NULL, 0); 4691 for (slave_idx = 0; slave_idx < test_params->bonded_slave_count; slave_idx++) { 4692 nb_pkts = virtual_ethdev_get_mbufs_from_tx_queue( 4693 test_params->slave_port_ids[slave_idx], pkts_sent, 4694 MAX_PKT_BURST); 4695 } 4696 4697 ether_addr_copy( 4698 rte_eth_devices[test_params->bonded_port_id].data->mac_addrs, 4699 &bond_mac); 4700 4701 /* 4702 * Generating four packets with different mac and ip addresses and placing 4703 * them in the rx queue to be received by the bonding driver on rx_burst. 4704 */ 4705 pkt = rte_pktmbuf_alloc(test_params->mbuf_pool); 4706 memcpy(client_mac.addr_bytes, mac_client1, ETHER_ADDR_LEN); 4707 eth_pkt = rte_pktmbuf_mtod(pkt, struct ether_hdr *); 4708 initialize_eth_header(eth_pkt, &bond_mac, &client_mac, ETHER_TYPE_ARP, 0, 4709 0); 4710 arp_pkt = (struct arp_hdr *)((char *)eth_pkt + sizeof(struct ether_hdr)); 4711 initialize_arp_header(arp_pkt, &client_mac, &bond_mac, ip_client1, ip_host, 4712 ARP_OP_REPLY); 4713 virtual_ethdev_add_mbufs_to_rx_queue(test_params->slave_port_ids[0], &pkt, 4714 1); 4715 4716 pkt = rte_pktmbuf_alloc(test_params->mbuf_pool); 4717 memcpy(client_mac.addr_bytes, mac_client2, ETHER_ADDR_LEN); 4718 eth_pkt = rte_pktmbuf_mtod(pkt, struct ether_hdr *); 4719 initialize_eth_header(eth_pkt, &bond_mac, &client_mac, ETHER_TYPE_ARP, 0, 4720 0); 4721 arp_pkt = (struct arp_hdr *)((char *)eth_pkt + sizeof(struct ether_hdr)); 4722 initialize_arp_header(arp_pkt, &client_mac, &bond_mac, ip_client2, ip_host, 4723 ARP_OP_REPLY); 4724 virtual_ethdev_add_mbufs_to_rx_queue(test_params->slave_port_ids[0], &pkt, 4725 1); 4726 4727 pkt = rte_pktmbuf_alloc(test_params->mbuf_pool); 4728 memcpy(client_mac.addr_bytes, mac_client3, ETHER_ADDR_LEN); 4729 eth_pkt = rte_pktmbuf_mtod(pkt, struct ether_hdr *); 4730 initialize_eth_header(eth_pkt, &bond_mac, &client_mac, ETHER_TYPE_ARP, 0, 4731 0); 4732 arp_pkt = (struct arp_hdr *)((char *)eth_pkt + sizeof(struct ether_hdr)); 4733 initialize_arp_header(arp_pkt, &client_mac, &bond_mac, ip_client3, ip_host, 4734 ARP_OP_REPLY); 4735 virtual_ethdev_add_mbufs_to_rx_queue(test_params->slave_port_ids[0], &pkt, 4736 1); 4737 4738 pkt = rte_pktmbuf_alloc(test_params->mbuf_pool); 4739 memcpy(client_mac.addr_bytes, mac_client4, ETHER_ADDR_LEN); 4740 eth_pkt = rte_pktmbuf_mtod(pkt, struct ether_hdr *); 4741 initialize_eth_header(eth_pkt, &bond_mac, &client_mac, ETHER_TYPE_ARP, 0, 4742 0); 4743 arp_pkt = (struct arp_hdr *)((char *)eth_pkt + sizeof(struct ether_hdr)); 4744 initialize_arp_header(arp_pkt, &client_mac, &bond_mac, ip_client4, ip_host, 4745 ARP_OP_REPLY); 4746 virtual_ethdev_add_mbufs_to_rx_queue(test_params->slave_port_ids[0], &pkt, 4747 1); 4748 4749 /* 4750 * Issue rx_burst and tx_burst to force bonding driver to send update ARP 4751 * packets to every client in alb table. 4752 */ 4753 rte_eth_rx_burst(test_params->bonded_port_id, 0, pkts_sent, MAX_PKT_BURST); 4754 rte_eth_tx_burst(test_params->bonded_port_id, 0, NULL, 0); 4755 4756 slave_mac1 = rte_eth_devices[test_params->slave_port_ids[0]].data->mac_addrs; 4757 slave_mac2 = rte_eth_devices[test_params->slave_port_ids[1]].data->mac_addrs; 4758 4759 /* 4760 * Checking if update ARP packets were properly send on slave ports. 4761 */ 4762 for (slave_idx = 0; slave_idx < test_params->bonded_slave_count; slave_idx++) { 4763 nb_pkts = virtual_ethdev_get_mbufs_from_tx_queue( 4764 test_params->slave_port_ids[slave_idx], pkts_sent, MAX_PKT_BURST); 4765 nb_pkts_sum += nb_pkts; 4766 4767 for (pkt_idx = 0; pkt_idx < nb_pkts; pkt_idx++) { 4768 eth_pkt = rte_pktmbuf_mtod(pkts_sent[pkt_idx], struct ether_hdr *); 4769 arp_pkt = (struct arp_hdr *)((char *)eth_pkt + sizeof(struct ether_hdr)); 4770 4771 if (slave_idx%2 == 0) { 4772 if (!is_same_ether_addr(slave_mac1, &arp_pkt->arp_data.arp_sha)) { 4773 retval = -1; 4774 goto test_end; 4775 } 4776 } else { 4777 if (!is_same_ether_addr(slave_mac2, &arp_pkt->arp_data.arp_sha)) { 4778 retval = -1; 4779 goto test_end; 4780 } 4781 } 4782 } 4783 } 4784 4785 /* Check if proper number of packets was send */ 4786 if (nb_pkts_sum < 4) { 4787 retval = -1; 4788 goto test_end; 4789 } 4790 4791 test_end: 4792 retval += remove_slaves_and_stop_bonded_device(); 4793 return retval; 4794 } 4795 4796 static int 4797 test_alb_receive_vlan_reply(void) 4798 { 4799 struct ether_hdr *eth_pkt; 4800 struct vlan_hdr *vlan_pkt; 4801 struct arp_hdr *arp_pkt; 4802 4803 struct rte_mbuf *pkt; 4804 struct rte_mbuf *pkts_sent[MAX_PKT_BURST]; 4805 4806 int slave_idx, nb_pkts, pkt_idx; 4807 int retval = 0; 4808 4809 struct ether_addr bond_mac, client_mac; 4810 4811 TEST_ASSERT_SUCCESS( 4812 initialize_bonded_device_with_slaves(BONDING_MODE_ALB, 4813 0, TEST_ALB_SLAVE_COUNT, 1), 4814 "Failed to initialize_bonded_device_with_slaves."); 4815 4816 /* Flush tx queue */ 4817 rte_eth_tx_burst(test_params->bonded_port_id, 0, NULL, 0); 4818 for (slave_idx = 0; slave_idx < test_params->bonded_slave_count; slave_idx++) { 4819 nb_pkts = virtual_ethdev_get_mbufs_from_tx_queue( 4820 test_params->slave_port_ids[slave_idx], pkts_sent, 4821 MAX_PKT_BURST); 4822 } 4823 4824 ether_addr_copy( 4825 rte_eth_devices[test_params->bonded_port_id].data->mac_addrs, 4826 &bond_mac); 4827 4828 /* 4829 * Generating packet with double VLAN header and placing it in the rx queue. 4830 */ 4831 pkt = rte_pktmbuf_alloc(test_params->mbuf_pool); 4832 memcpy(client_mac.addr_bytes, mac_client1, ETHER_ADDR_LEN); 4833 eth_pkt = rte_pktmbuf_mtod(pkt, struct ether_hdr *); 4834 initialize_eth_header(eth_pkt, &bond_mac, &client_mac, ETHER_TYPE_VLAN, 0, 4835 0); 4836 vlan_pkt = (struct vlan_hdr *)((char *)(eth_pkt + 1)); 4837 vlan_pkt->vlan_tci = rte_cpu_to_be_16(1); 4838 vlan_pkt->eth_proto = rte_cpu_to_be_16(ETHER_TYPE_VLAN); 4839 vlan_pkt = vlan_pkt+1; 4840 vlan_pkt->vlan_tci = rte_cpu_to_be_16(2); 4841 vlan_pkt->eth_proto = rte_cpu_to_be_16(ETHER_TYPE_ARP); 4842 arp_pkt = (struct arp_hdr *)((char *)(vlan_pkt + 1)); 4843 initialize_arp_header(arp_pkt, &client_mac, &bond_mac, ip_client1, ip_host, 4844 ARP_OP_REPLY); 4845 virtual_ethdev_add_mbufs_to_rx_queue(test_params->slave_port_ids[0], &pkt, 4846 1); 4847 4848 rte_eth_rx_burst(test_params->bonded_port_id, 0, pkts_sent, MAX_PKT_BURST); 4849 rte_eth_tx_burst(test_params->bonded_port_id, 0, NULL, 0); 4850 4851 /* 4852 * Checking if VLAN headers in generated ARP Update packet are correct. 4853 */ 4854 for (slave_idx = 0; slave_idx < test_params->bonded_slave_count; slave_idx++) { 4855 nb_pkts = virtual_ethdev_get_mbufs_from_tx_queue( 4856 test_params->slave_port_ids[slave_idx], pkts_sent, 4857 MAX_PKT_BURST); 4858 4859 for (pkt_idx = 0; pkt_idx < nb_pkts; pkt_idx++) { 4860 eth_pkt = rte_pktmbuf_mtod(pkts_sent[pkt_idx], struct ether_hdr *); 4861 vlan_pkt = (struct vlan_hdr *)((char *)(eth_pkt + 1)); 4862 if (vlan_pkt->vlan_tci != rte_cpu_to_be_16(1)) { 4863 retval = -1; 4864 goto test_end; 4865 } 4866 if (vlan_pkt->eth_proto != rte_cpu_to_be_16(ETHER_TYPE_VLAN)) { 4867 retval = -1; 4868 goto test_end; 4869 } 4870 vlan_pkt = vlan_pkt+1; 4871 if (vlan_pkt->vlan_tci != rte_cpu_to_be_16(2)) { 4872 retval = -1; 4873 goto test_end; 4874 } 4875 if (vlan_pkt->eth_proto != rte_cpu_to_be_16(ETHER_TYPE_ARP)) { 4876 retval = -1; 4877 goto test_end; 4878 } 4879 } 4880 } 4881 4882 test_end: 4883 retval += remove_slaves_and_stop_bonded_device(); 4884 return retval; 4885 } 4886 4887 static int 4888 test_alb_ipv4_tx(void) 4889 { 4890 int burst_size, retval, pkts_send; 4891 struct rte_mbuf *pkt_burst[MAX_PKT_BURST]; 4892 4893 retval = 0; 4894 4895 TEST_ASSERT_SUCCESS( 4896 initialize_bonded_device_with_slaves(BONDING_MODE_ALB, 4897 0, TEST_ALB_SLAVE_COUNT, 1), 4898 "Failed to initialize_bonded_device_with_slaves."); 4899 4900 burst_size = 32; 4901 4902 /* Generate test bursts of packets to transmit */ 4903 if (generate_test_burst(pkt_burst, burst_size, 0, 1, 0, 0, 0) != burst_size) { 4904 retval = -1; 4905 goto test_end; 4906 } 4907 4908 /* 4909 * Checking if ipv4 traffic is transmitted via TLB policy. 4910 */ 4911 pkts_send = rte_eth_tx_burst( 4912 test_params->bonded_port_id, 0, pkt_burst, burst_size); 4913 if (pkts_send != burst_size) { 4914 retval = -1; 4915 goto test_end; 4916 } 4917 4918 test_end: 4919 retval += remove_slaves_and_stop_bonded_device(); 4920 return retval; 4921 } 4922 4923 static struct unit_test_suite link_bonding_test_suite = { 4924 .suite_name = "Link Bonding Unit Test Suite", 4925 .setup = test_setup, 4926 .teardown = testsuite_teardown, 4927 .unit_test_cases = { 4928 TEST_CASE(test_create_bonded_device), 4929 TEST_CASE(test_create_bonded_device_with_invalid_params), 4930 TEST_CASE(test_add_slave_to_bonded_device), 4931 TEST_CASE(test_add_slave_to_invalid_bonded_device), 4932 TEST_CASE(test_remove_slave_from_bonded_device), 4933 TEST_CASE(test_remove_slave_from_invalid_bonded_device), 4934 TEST_CASE(test_get_slaves_from_bonded_device), 4935 TEST_CASE(test_add_already_bonded_slave_to_bonded_device), 4936 TEST_CASE(test_add_remove_multiple_slaves_to_from_bonded_device), 4937 TEST_CASE(test_start_bonded_device), 4938 TEST_CASE(test_stop_bonded_device), 4939 TEST_CASE(test_set_bonding_mode), 4940 TEST_CASE(test_set_primary_slave), 4941 TEST_CASE(test_set_explicit_bonded_mac), 4942 TEST_CASE(test_set_bonded_port_initialization_mac_assignment), 4943 TEST_CASE(test_status_interrupt), 4944 TEST_CASE(test_adding_slave_after_bonded_device_started), 4945 TEST_CASE(test_roundrobin_tx_burst), 4946 TEST_CASE(test_roundrobin_tx_burst_slave_tx_fail), 4947 TEST_CASE(test_roundrobin_rx_burst_on_single_slave), 4948 TEST_CASE(test_roundrobin_rx_burst_on_multiple_slaves), 4949 TEST_CASE(test_roundrobin_verify_promiscuous_enable_disable), 4950 TEST_CASE(test_roundrobin_verify_mac_assignment), 4951 TEST_CASE(test_roundrobin_verify_slave_link_status_change_behaviour), 4952 TEST_CASE(test_roundrobin_verfiy_polling_slave_link_status_change), 4953 TEST_CASE(test_activebackup_tx_burst), 4954 TEST_CASE(test_activebackup_rx_burst), 4955 TEST_CASE(test_activebackup_verify_promiscuous_enable_disable), 4956 TEST_CASE(test_activebackup_verify_mac_assignment), 4957 TEST_CASE(test_activebackup_verify_slave_link_status_change_failover), 4958 TEST_CASE(test_balance_xmit_policy_configuration), 4959 TEST_CASE(test_balance_l2_tx_burst), 4960 TEST_CASE(test_balance_l23_tx_burst_ipv4_toggle_ip_addr), 4961 TEST_CASE(test_balance_l23_tx_burst_vlan_ipv4_toggle_ip_addr), 4962 TEST_CASE(test_balance_l23_tx_burst_ipv6_toggle_ip_addr), 4963 TEST_CASE(test_balance_l23_tx_burst_vlan_ipv6_toggle_ip_addr), 4964 TEST_CASE(test_balance_l23_tx_burst_toggle_mac_addr), 4965 TEST_CASE(test_balance_l34_tx_burst_ipv4_toggle_ip_addr), 4966 TEST_CASE(test_balance_l34_tx_burst_ipv4_toggle_udp_port), 4967 TEST_CASE(test_balance_l34_tx_burst_vlan_ipv4_toggle_ip_addr), 4968 TEST_CASE(test_balance_l34_tx_burst_ipv6_toggle_ip_addr), 4969 TEST_CASE(test_balance_l34_tx_burst_vlan_ipv6_toggle_ip_addr), 4970 TEST_CASE(test_balance_l34_tx_burst_ipv6_toggle_udp_port), 4971 TEST_CASE(test_balance_tx_burst_slave_tx_fail), 4972 TEST_CASE(test_balance_rx_burst), 4973 TEST_CASE(test_balance_verify_promiscuous_enable_disable), 4974 TEST_CASE(test_balance_verify_mac_assignment), 4975 TEST_CASE(test_balance_verify_slave_link_status_change_behaviour), 4976 TEST_CASE(test_tlb_tx_burst), 4977 TEST_CASE(test_tlb_rx_burst), 4978 TEST_CASE(test_tlb_verify_mac_assignment), 4979 TEST_CASE(test_tlb_verify_promiscuous_enable_disable), 4980 TEST_CASE(test_tlb_verify_slave_link_status_change_failover), 4981 TEST_CASE(test_alb_change_mac_in_reply_sent), 4982 TEST_CASE(test_alb_reply_from_client), 4983 TEST_CASE(test_alb_receive_vlan_reply), 4984 TEST_CASE(test_alb_ipv4_tx), 4985 TEST_CASE(test_broadcast_tx_burst), 4986 TEST_CASE(test_broadcast_tx_burst_slave_tx_fail), 4987 TEST_CASE(test_broadcast_rx_burst), 4988 TEST_CASE(test_broadcast_verify_promiscuous_enable_disable), 4989 TEST_CASE(test_broadcast_verify_mac_assignment), 4990 TEST_CASE(test_broadcast_verify_slave_link_status_change_behaviour), 4991 TEST_CASE(test_reconfigure_bonded_device), 4992 TEST_CASE(test_close_bonded_device), 4993 4994 TEST_CASES_END() /**< NULL terminate unit test array */ 4995 } 4996 }; 4997 4998 4999 static int 5000 test_link_bonding(void) 5001 { 5002 return unit_test_suite_runner(&link_bonding_test_suite); 5003 } 5004 5005 REGISTER_TEST_COMMAND(link_bonding_autotest, test_link_bonding); 5006