]> git.proxmox.com Git - ceph.git/blob - ceph/src/seastar/dpdk/test/test/test_link_bonding.c
projects / ceph.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
update download target update for octopus release
[ceph.git] / ceph / src / seastar / dpdk / test / test / test_link_bonding.c
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 = 1, /**< CRC stripping by hardware enabled. */
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 = 1, /**< 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);
Ceph