1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2017 Intel Corporation 3 */ 4 5 #include "test.h" 6 7 #include <string.h> 8 #include <rte_common.h> 9 #include <rte_mempool.h> 10 #include <rte_mbuf.h> 11 #include <rte_ethdev.h> 12 13 #ifdef RTE_EXEC_ENV_WINDOWS 14 static int 15 test_event_eth_rx_adapter_common(void) 16 { 17 printf("event_eth_rx_adapter not supported on Windows, skipping test\n"); 18 return TEST_SKIPPED; 19 } 20 21 static int 22 test_event_eth_rx_intr_adapter_common(void) 23 { 24 printf("event_eth_rx_intr_adapter not supported on Windows, skipping test\n"); 25 return TEST_SKIPPED; 26 } 27 28 #else 29 30 #include <rte_eventdev.h> 31 #include <rte_bus_vdev.h> 32 33 #include <rte_event_eth_rx_adapter.h> 34 35 #define MAX_NUM_RX_QUEUE 64 36 #define NB_MBUFS (8192 * num_ports * MAX_NUM_RX_QUEUE) 37 #define MBUF_CACHE_SIZE 512 38 #define MBUF_PRIV_SIZE 0 39 #define TEST_INST_ID 0 40 #define TEST_DEV_ID 0 41 #define TEST_ETHDEV_ID 0 42 #define TEST_ETH_QUEUE_ID 0 43 44 struct event_eth_rx_adapter_test_params { 45 struct rte_mempool *mp; 46 uint16_t rx_rings, tx_rings; 47 uint32_t caps; 48 int rx_intr_port_inited; 49 uint16_t rx_intr_port; 50 }; 51 52 static struct event_eth_rx_adapter_test_params default_params; 53 static bool event_dev_created; 54 static bool eth_dev_created; 55 56 static inline int 57 port_init_common(uint16_t port, const struct rte_eth_conf *port_conf, 58 struct rte_mempool *mp) 59 { 60 const uint16_t rx_ring_size = 512, tx_ring_size = 512; 61 int retval; 62 uint16_t q; 63 struct rte_eth_dev_info dev_info; 64 65 if (!rte_eth_dev_is_valid_port(port)) 66 return -1; 67 68 retval = rte_eth_dev_configure(port, 0, 0, port_conf); 69 70 retval = rte_eth_dev_info_get(port, &dev_info); 71 if (retval != 0) 72 return retval; 73 74 default_params.rx_rings = RTE_MIN(dev_info.max_rx_queues, 75 MAX_NUM_RX_QUEUE); 76 default_params.tx_rings = 1; 77 78 /* Configure the Ethernet device. */ 79 retval = rte_eth_dev_configure(port, default_params.rx_rings, 80 default_params.tx_rings, port_conf); 81 if (retval != 0) 82 return retval; 83 84 for (q = 0; q < default_params.rx_rings; q++) { 85 retval = rte_eth_rx_queue_setup(port, q, rx_ring_size, 86 rte_eth_dev_socket_id(port), NULL, mp); 87 if (retval < 0) 88 return retval; 89 } 90 91 /* Allocate and set up 1 TX queue per Ethernet port. */ 92 for (q = 0; q < default_params.tx_rings; q++) { 93 retval = rte_eth_tx_queue_setup(port, q, tx_ring_size, 94 rte_eth_dev_socket_id(port), NULL); 95 if (retval < 0) 96 return retval; 97 } 98 99 /* Start the Ethernet port. */ 100 retval = rte_eth_dev_start(port); 101 if (retval < 0) 102 return retval; 103 104 /* Display the port MAC address. */ 105 struct rte_ether_addr addr; 106 retval = rte_eth_macaddr_get(port, &addr); 107 if (retval < 0) 108 return retval; 109 printf("Port %u MAC: %02" PRIx8 " %02" PRIx8 " %02" PRIx8 110 " %02" PRIx8 " %02" PRIx8 " %02" PRIx8 "\n", 111 (unsigned int)port, RTE_ETHER_ADDR_BYTES(&addr)); 112 113 /* Enable RX in promiscuous mode for the Ethernet device. */ 114 retval = rte_eth_promiscuous_enable(port); 115 if (retval != 0) 116 return retval; 117 118 return 0; 119 } 120 121 static inline int 122 port_init_rx_intr(uint16_t port, struct rte_mempool *mp) 123 { 124 static const struct rte_eth_conf port_conf_default = { 125 .rxmode = { 126 .mq_mode = RTE_ETH_MQ_RX_NONE, 127 }, 128 .intr_conf = { 129 .rxq = 1, 130 }, 131 }; 132 133 return port_init_common(port, &port_conf_default, mp); 134 } 135 136 static inline int 137 port_init(uint16_t port, struct rte_mempool *mp) 138 { 139 static const struct rte_eth_conf port_conf_default = { 140 .rxmode = { 141 .mq_mode = RTE_ETH_MQ_RX_NONE, 142 }, 143 }; 144 145 return port_init_common(port, &port_conf_default, mp); 146 } 147 148 static int 149 init_port_rx_intr(int num_ports) 150 { 151 int retval; 152 uint16_t portid; 153 int err; 154 155 default_params.mp = rte_pktmbuf_pool_create("packet_pool", 156 NB_MBUFS, 157 MBUF_CACHE_SIZE, 158 MBUF_PRIV_SIZE, 159 RTE_MBUF_DEFAULT_BUF_SIZE, 160 rte_socket_id()); 161 if (!default_params.mp) 162 return -ENOMEM; 163 164 RTE_ETH_FOREACH_DEV(portid) { 165 retval = port_init_rx_intr(portid, default_params.mp); 166 if (retval) 167 continue; 168 err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, portid, 169 &default_params.caps); 170 if (err) 171 continue; 172 if (!(default_params.caps & 173 RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT)) { 174 default_params.rx_intr_port_inited = 1; 175 default_params.rx_intr_port = portid; 176 return 0; 177 } 178 retval = rte_eth_dev_stop(portid); 179 TEST_ASSERT(retval == 0, "Failed to stop port %u: %d\n", 180 portid, retval); 181 } 182 return 0; 183 } 184 185 static int 186 init_ports(int num_ports) 187 { 188 uint16_t portid; 189 int retval; 190 191 struct rte_mempool *ptr = rte_mempool_lookup("packet_pool"); 192 193 if (ptr == NULL) 194 default_params.mp = rte_pktmbuf_pool_create("packet_pool", 195 NB_MBUFS, 196 MBUF_CACHE_SIZE, 197 MBUF_PRIV_SIZE, 198 RTE_MBUF_DEFAULT_BUF_SIZE, 199 rte_socket_id()); 200 else 201 default_params.mp = ptr; 202 203 if (!default_params.mp) 204 return -ENOMEM; 205 206 RTE_ETH_FOREACH_DEV(portid) { 207 retval = port_init(portid, default_params.mp); 208 if (retval) 209 return retval; 210 } 211 212 return 0; 213 } 214 215 static int 216 testsuite_setup(void) 217 { 218 int err; 219 uint8_t count; 220 struct rte_event_dev_info dev_info; 221 222 count = rte_event_dev_count(); 223 if (!count) { 224 printf("Failed to find a valid event device," 225 " testing with event_skeleton device\n"); 226 err = rte_vdev_init("event_skeleton", NULL); 227 TEST_ASSERT(err == 0, "Failed to create event_skeleton. err=%d", 228 err); 229 event_dev_created = true; 230 } 231 232 struct rte_event_dev_config config = { 233 .nb_event_queues = 1, 234 .nb_event_ports = 1, 235 }; 236 237 err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info); 238 config.nb_event_queue_flows = dev_info.max_event_queue_flows; 239 config.nb_event_port_dequeue_depth = 240 dev_info.max_event_port_dequeue_depth; 241 config.nb_event_port_enqueue_depth = 242 dev_info.max_event_port_enqueue_depth; 243 config.nb_events_limit = 244 dev_info.max_num_events; 245 err = rte_event_dev_configure(TEST_DEV_ID, &config); 246 TEST_ASSERT(err == 0, "Event device initialization failed err %d\n", 247 err); 248 249 count = rte_eth_dev_count_total(); 250 if (!count) { 251 printf("Testing with net_null device\n"); 252 err = rte_vdev_init("net_null", NULL); 253 TEST_ASSERT(err == 0, "Failed to create net_null. err=%d", 254 err); 255 eth_dev_created = true; 256 } 257 258 /* 259 * eth devices like octeontx use event device to receive packets 260 * so rte_eth_dev_start invokes rte_event_dev_start internally, so 261 * call init_ports after rte_event_dev_configure 262 */ 263 err = init_ports(rte_eth_dev_count_total()); 264 TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err); 265 266 err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID, 267 &default_params.caps); 268 TEST_ASSERT(err == 0, "Failed to get adapter cap err %d\n", 269 err); 270 271 return err; 272 } 273 274 static int 275 testsuite_setup_rx_intr(void) 276 { 277 int err; 278 uint8_t count; 279 struct rte_event_dev_info dev_info; 280 281 count = rte_event_dev_count(); 282 if (!count) { 283 printf("Failed to find a valid event device," 284 " testing with event_skeleton device\n"); 285 err = rte_vdev_init("event_skeleton", NULL); 286 TEST_ASSERT(err == 0, "Failed to create event_skeleton. err=%d", 287 err); 288 event_dev_created = true; 289 } 290 291 struct rte_event_dev_config config = { 292 .nb_event_queues = 1, 293 .nb_event_ports = 1, 294 }; 295 296 err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info); 297 config.nb_event_queue_flows = dev_info.max_event_queue_flows; 298 config.nb_event_port_dequeue_depth = 299 dev_info.max_event_port_dequeue_depth; 300 config.nb_event_port_enqueue_depth = 301 dev_info.max_event_port_enqueue_depth; 302 config.nb_events_limit = 303 dev_info.max_num_events; 304 305 err = rte_event_dev_configure(TEST_DEV_ID, &config); 306 TEST_ASSERT(err == 0, "Event device initialization failed err %d\n", 307 err); 308 309 count = rte_eth_dev_count_total(); 310 if (!count) { 311 printf("Testing with net_null device\n"); 312 err = rte_vdev_init("net_null", NULL); 313 TEST_ASSERT(err == 0, "Failed to create net_null. err=%d", 314 err); 315 eth_dev_created = true; 316 } 317 318 /* 319 * eth devices like octeontx use event device to receive packets 320 * so rte_eth_dev_start invokes rte_event_dev_start internally, so 321 * call init_ports after rte_event_dev_configure 322 */ 323 err = init_port_rx_intr(rte_eth_dev_count_total()); 324 TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err); 325 326 if (!default_params.rx_intr_port_inited) 327 return 0; 328 329 err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, 330 default_params.rx_intr_port, 331 &default_params.caps); 332 TEST_ASSERT(err == 0, "Failed to get adapter cap err %d\n", err); 333 334 return err; 335 } 336 337 static void 338 testsuite_teardown(void) 339 { 340 int err; 341 uint32_t i; 342 RTE_ETH_FOREACH_DEV(i) 343 rte_eth_dev_stop(i); 344 345 if (eth_dev_created) { 346 err = rte_vdev_uninit("net_null"); 347 if (err) 348 printf("Failed to delete net_null. err=%d", err); 349 eth_dev_created = false; 350 } 351 352 rte_mempool_free(default_params.mp); 353 if (event_dev_created) { 354 err = rte_vdev_uninit("event_skeleton"); 355 if (err) 356 printf("Failed to delete event_skeleton. err=%d", err); 357 event_dev_created = false; 358 } 359 360 memset(&default_params, 0, sizeof(default_params)); 361 } 362 363 static void 364 testsuite_teardown_rx_intr(void) 365 { 366 int err; 367 if (!default_params.rx_intr_port_inited) 368 return; 369 370 rte_eth_dev_stop(default_params.rx_intr_port); 371 if (eth_dev_created) { 372 err = rte_vdev_uninit("net_null"); 373 if (err) 374 printf("Failed to delete net_null. err=%d", err); 375 eth_dev_created = false; 376 } 377 rte_mempool_free(default_params.mp); 378 if (event_dev_created) { 379 err = rte_vdev_uninit("event_skeleton"); 380 if (err) 381 printf("Failed to delete event_skeleton. err=%d", err); 382 event_dev_created = false; 383 } 384 385 memset(&default_params, 0, sizeof(default_params)); 386 } 387 388 static int 389 adapter_create(void) 390 { 391 int err; 392 struct rte_event_dev_info dev_info; 393 struct rte_event_port_conf rx_p_conf; 394 395 memset(&rx_p_conf, 0, sizeof(rx_p_conf)); 396 397 err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info); 398 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 399 400 rx_p_conf.new_event_threshold = dev_info.max_num_events; 401 rx_p_conf.dequeue_depth = dev_info.max_event_port_dequeue_depth; 402 rx_p_conf.enqueue_depth = dev_info.max_event_port_enqueue_depth; 403 err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID, 404 &rx_p_conf); 405 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 406 407 return err; 408 } 409 410 static int 411 adapter_create_with_params(void) 412 { 413 int err; 414 struct rte_event_dev_info dev_info; 415 struct rte_event_port_conf rx_p_conf; 416 struct rte_event_eth_rx_adapter_params rxa_params; 417 418 memset(&rx_p_conf, 0, sizeof(rx_p_conf)); 419 420 err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info); 421 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 422 423 rx_p_conf.new_event_threshold = dev_info.max_num_events; 424 rx_p_conf.dequeue_depth = dev_info.max_event_port_dequeue_depth; 425 rx_p_conf.enqueue_depth = dev_info.max_event_port_enqueue_depth; 426 427 rxa_params.use_queue_event_buf = false; 428 rxa_params.event_buf_size = 0; 429 430 err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID, 431 TEST_DEV_ID, &rx_p_conf, &rxa_params); 432 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 433 434 rxa_params.use_queue_event_buf = true; 435 436 err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID, 437 TEST_DEV_ID, &rx_p_conf, &rxa_params); 438 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 439 440 err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID, 441 TEST_DEV_ID, &rx_p_conf, &rxa_params); 442 TEST_ASSERT(err == -EEXIST, "Expected -EEXIST got %d", err); 443 444 return TEST_SUCCESS; 445 } 446 447 static int 448 adapter_queue_event_buf_test(void) 449 { 450 int err; 451 struct rte_event ev; 452 uint32_t cap; 453 454 struct rte_event_eth_rx_adapter_queue_conf queue_config = {0}; 455 456 err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID, 457 &cap); 458 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 459 460 ev.queue_id = 0; 461 ev.sched_type = RTE_SCHED_TYPE_ATOMIC; 462 ev.priority = 0; 463 464 queue_config.rx_queue_flags = 0; 465 if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) { 466 ev.flow_id = 1; 467 queue_config.rx_queue_flags = 468 RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID; 469 } 470 queue_config.ev = ev; 471 queue_config.servicing_weight = 1; 472 queue_config.event_buf_size = 0; 473 474 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 475 TEST_ETHDEV_ID, 0, 476 &queue_config); 477 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 478 479 queue_config.event_buf_size = 1024; 480 481 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 482 TEST_ETHDEV_ID, 0, 483 &queue_config); 484 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 485 486 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 487 TEST_ETHDEV_ID, 488 0); 489 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 490 491 return TEST_SUCCESS; 492 } 493 494 static int 495 adapter_queue_stats_test(void) 496 { 497 int err; 498 struct rte_event ev; 499 uint32_t cap; 500 struct rte_event_eth_rx_adapter_queue_conf queue_config = {0}; 501 struct rte_event_eth_rx_adapter_queue_stats q_stats; 502 503 err = rte_event_eth_rx_adapter_queue_stats_get(TEST_INST_ID, 504 TEST_ETHDEV_ID, 0, 505 &q_stats); 506 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 507 508 err = rte_event_eth_rx_adapter_queue_stats_reset(TEST_INST_ID, 509 TEST_ETHDEV_ID, 0); 510 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 511 512 err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID, 513 &cap); 514 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 515 516 ev.queue_id = 0; 517 ev.sched_type = RTE_SCHED_TYPE_ATOMIC; 518 ev.priority = 0; 519 520 queue_config.rx_queue_flags = 0; 521 if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) { 522 ev.flow_id = 1; 523 queue_config.rx_queue_flags = 524 RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID; 525 } 526 queue_config.ev = ev; 527 queue_config.servicing_weight = 1; 528 queue_config.event_buf_size = 1024; 529 530 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 531 TEST_ETHDEV_ID, 0, 532 &queue_config); 533 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 534 535 err = rte_event_eth_rx_adapter_queue_stats_get(TEST_INST_ID, 536 TEST_ETHDEV_ID, 0, 537 &q_stats); 538 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 539 540 err = rte_event_eth_rx_adapter_queue_stats_reset(TEST_INST_ID, 541 TEST_ETHDEV_ID, 0); 542 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 543 544 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 545 TEST_ETHDEV_ID, 546 0); 547 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 548 549 return TEST_SUCCESS; 550 } 551 552 static void 553 adapter_free(void) 554 { 555 rte_event_eth_rx_adapter_free(TEST_INST_ID); 556 } 557 558 static int 559 adapter_create_free(void) 560 { 561 int err; 562 563 struct rte_event_port_conf rx_p_conf = { 564 .dequeue_depth = 8, 565 .enqueue_depth = 8, 566 .new_event_threshold = 1200, 567 }; 568 569 err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID, 570 NULL); 571 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 572 573 err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID, 574 &rx_p_conf); 575 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 576 577 err = rte_event_eth_rx_adapter_create(TEST_INST_ID, 578 TEST_DEV_ID, &rx_p_conf); 579 TEST_ASSERT(err == -EEXIST, "Expected -EEXIST %d got %d", -EEXIST, err); 580 581 err = rte_event_eth_rx_adapter_free(TEST_INST_ID); 582 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 583 584 err = rte_event_eth_rx_adapter_free(TEST_INST_ID); 585 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err); 586 587 err = rte_event_eth_rx_adapter_free(1); 588 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err); 589 590 return TEST_SUCCESS; 591 } 592 593 static int 594 adapter_create_free_with_params(void) 595 { 596 int err; 597 598 struct rte_event_port_conf rx_p_conf = { 599 .dequeue_depth = 8, 600 .enqueue_depth = 8, 601 .new_event_threshold = 1200, 602 }; 603 604 struct rte_event_eth_rx_adapter_params rxa_params = { 605 .event_buf_size = 1024 606 }; 607 608 err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID, 609 TEST_DEV_ID, NULL, NULL); 610 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 611 612 err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID, 613 TEST_DEV_ID, &rx_p_conf, &rxa_params); 614 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 615 616 err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID, 617 TEST_DEV_ID, &rx_p_conf, &rxa_params); 618 TEST_ASSERT(err == -EEXIST, "Expected -EEXIST %d got %d", -EEXIST, err); 619 620 rxa_params.event_buf_size = 0; 621 err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID, 622 TEST_DEV_ID, &rx_p_conf, &rxa_params); 623 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 624 625 err = rte_event_eth_rx_adapter_free(TEST_INST_ID); 626 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 627 628 err = rte_event_eth_rx_adapter_free(TEST_INST_ID); 629 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err); 630 631 err = rte_event_eth_rx_adapter_free(1); 632 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err); 633 634 return TEST_SUCCESS; 635 } 636 637 static int 638 adapter_queue_add_del(void) 639 { 640 int err; 641 struct rte_event ev; 642 uint32_t cap; 643 644 struct rte_event_eth_rx_adapter_queue_conf queue_config = {0}; 645 646 err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID, 647 &cap); 648 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 649 650 ev.queue_id = 0; 651 ev.sched_type = RTE_SCHED_TYPE_ATOMIC; 652 ev.priority = 0; 653 654 queue_config.rx_queue_flags = 0; 655 if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) { 656 ev.flow_id = 1; 657 queue_config.rx_queue_flags = 658 RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID; 659 } 660 queue_config.ev = ev; 661 queue_config.servicing_weight = 1; 662 663 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 664 rte_eth_dev_count_total(), 665 -1, &queue_config); 666 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 667 668 if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) { 669 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 670 TEST_ETHDEV_ID, 0, 671 &queue_config); 672 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 673 674 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 675 TEST_ETHDEV_ID, 0); 676 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 677 678 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 679 TEST_ETHDEV_ID, 680 -1, 681 &queue_config); 682 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 683 684 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 685 TEST_ETHDEV_ID, 686 -1); 687 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 688 } else { 689 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 690 TEST_ETHDEV_ID, 691 0, 692 &queue_config); 693 TEST_ASSERT(err == -EINVAL, "Expected EINVAL got %d", err); 694 695 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 696 TEST_ETHDEV_ID, -1, 697 &queue_config); 698 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 699 700 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 701 TEST_ETHDEV_ID, 0); 702 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 703 704 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 705 TEST_ETHDEV_ID, -1); 706 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 707 708 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 709 TEST_ETHDEV_ID, -1); 710 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 711 } 712 713 err = rte_event_eth_rx_adapter_queue_add(1, TEST_ETHDEV_ID, -1, 714 &queue_config); 715 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 716 717 err = rte_event_eth_rx_adapter_queue_del(1, TEST_ETHDEV_ID, -1); 718 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 719 720 return TEST_SUCCESS; 721 } 722 723 static int 724 adapter_multi_eth_add_del(void) 725 { 726 int err; 727 struct rte_event ev; 728 729 uint16_t port_index, port_index_base, drv_id = 0; 730 char driver_name[50]; 731 732 struct rte_event_eth_rx_adapter_queue_conf queue_config = {0}; 733 734 ev.queue_id = 0; 735 ev.sched_type = RTE_SCHED_TYPE_ATOMIC; 736 ev.priority = 0; 737 738 queue_config.rx_queue_flags = 0; 739 queue_config.ev = ev; 740 queue_config.servicing_weight = 1; 741 742 /* stop eth devices for existing */ 743 port_index = 0; 744 for (; port_index < rte_eth_dev_count_total(); port_index += 1) { 745 err = rte_eth_dev_stop(port_index); 746 TEST_ASSERT(err == 0, "Failed to stop port %u: %d\n", 747 port_index, err); 748 } 749 750 /* add the max port for rx_adapter */ 751 port_index = rte_eth_dev_count_total(); 752 port_index_base = port_index; 753 for (; port_index < RTE_MAX_ETHPORTS; port_index += 1) { 754 snprintf(driver_name, sizeof(driver_name), "%s%u", "net_null", 755 drv_id); 756 err = rte_vdev_init(driver_name, NULL); 757 TEST_ASSERT(err == 0, "Failed driver %s got %d", 758 driver_name, err); 759 drv_id += 1; 760 } 761 762 err = init_ports(rte_eth_dev_count_total()); 763 TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err); 764 765 /* eth_rx_adapter_queue_add for n ports */ 766 port_index = 0; 767 for (; port_index < rte_eth_dev_count_total(); port_index += 1) { 768 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 769 port_index, -1, 770 &queue_config); 771 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 772 } 773 774 /* eth_rx_adapter_queue_del n ports */ 775 port_index = 0; 776 for (; port_index < rte_eth_dev_count_total(); port_index += 1) { 777 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 778 port_index, -1); 779 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 780 } 781 782 /* delete vdev ports */ 783 for (drv_id = 0, port_index = port_index_base; 784 port_index < RTE_MAX_ETHPORTS; 785 drv_id += 1, port_index += 1) { 786 snprintf(driver_name, sizeof(driver_name), "%s%u", "net_null", 787 drv_id); 788 err = rte_vdev_uninit(driver_name); 789 TEST_ASSERT(err == 0, "Failed driver %s got %d", 790 driver_name, err); 791 } 792 793 return TEST_SUCCESS; 794 } 795 796 static int 797 adapter_intr_queue_add_del(void) 798 { 799 int err; 800 struct rte_event ev; 801 uint32_t cap; 802 uint16_t eth_port; 803 struct rte_event_eth_rx_adapter_queue_conf queue_config = {0}; 804 805 if (!default_params.rx_intr_port_inited) 806 return 0; 807 808 eth_port = default_params.rx_intr_port; 809 err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, eth_port, &cap); 810 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 811 812 ev.queue_id = 0; 813 ev.sched_type = RTE_SCHED_TYPE_ATOMIC; 814 ev.priority = 0; 815 816 queue_config.rx_queue_flags = 0; 817 queue_config.ev = ev; 818 819 /* weight = 0 => interrupt mode */ 820 queue_config.servicing_weight = 0; 821 822 if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) { 823 /* add queue 0 */ 824 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 825 TEST_ETHDEV_ID, 0, 826 &queue_config); 827 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 828 } 829 830 /* add all queues */ 831 queue_config.servicing_weight = 0; 832 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 833 TEST_ETHDEV_ID, 834 -1, 835 &queue_config); 836 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 837 838 if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) { 839 /* del queue 0 */ 840 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 841 TEST_ETHDEV_ID, 842 0); 843 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 844 } 845 846 /* del remaining queues */ 847 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 848 TEST_ETHDEV_ID, 849 -1); 850 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 851 852 /* add all queues */ 853 queue_config.servicing_weight = 0; 854 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 855 TEST_ETHDEV_ID, 856 -1, 857 &queue_config); 858 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 859 860 /* intr -> poll mode queue */ 861 queue_config.servicing_weight = 1; 862 863 if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) { 864 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 865 TEST_ETHDEV_ID, 866 0, 867 &queue_config); 868 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 869 } 870 871 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 872 TEST_ETHDEV_ID, 873 -1, 874 &queue_config); 875 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 876 877 /* del queues */ 878 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 879 TEST_ETHDEV_ID, 880 -1); 881 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 882 883 return TEST_SUCCESS; 884 } 885 886 static int 887 adapter_start_stop(void) 888 { 889 int err; 890 struct rte_event ev; 891 892 ev.queue_id = 0; 893 ev.sched_type = RTE_SCHED_TYPE_ATOMIC; 894 ev.priority = 0; 895 896 struct rte_event_eth_rx_adapter_queue_conf queue_config = {0}; 897 898 queue_config.rx_queue_flags = 0; 899 if (default_params.caps & 900 RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) { 901 ev.flow_id = 1; 902 queue_config.rx_queue_flags = 903 RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID; 904 } 905 906 queue_config.ev = ev; 907 queue_config.servicing_weight = 1; 908 909 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, TEST_ETHDEV_ID, 910 -1, &queue_config); 911 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 912 913 err = rte_event_eth_rx_adapter_start(TEST_INST_ID); 914 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 915 916 err = rte_event_eth_rx_adapter_stop(TEST_INST_ID); 917 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 918 919 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, TEST_ETHDEV_ID, 920 -1); 921 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 922 923 err = rte_event_eth_rx_adapter_start(TEST_INST_ID); 924 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 925 926 err = rte_event_eth_rx_adapter_stop(TEST_INST_ID); 927 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 928 929 err = rte_event_eth_rx_adapter_start(1); 930 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 931 932 err = rte_event_eth_rx_adapter_stop(1); 933 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 934 935 return TEST_SUCCESS; 936 } 937 938 static int 939 adapter_stats(void) 940 { 941 int err; 942 struct rte_event_eth_rx_adapter_stats stats; 943 944 err = rte_event_eth_rx_adapter_stats_get(TEST_INST_ID, NULL); 945 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 946 947 err = rte_event_eth_rx_adapter_stats_get(TEST_INST_ID, &stats); 948 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 949 950 err = rte_event_eth_rx_adapter_stats_get(1, &stats); 951 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 952 953 return TEST_SUCCESS; 954 } 955 956 static int 957 adapter_queue_conf(void) 958 { 959 int err; 960 struct rte_event_eth_rx_adapter_queue_conf queue_conf = {0}; 961 962 /* Case 1: queue conf get without any queues in Rx adapter */ 963 err = rte_event_eth_rx_adapter_queue_conf_get(TEST_INST_ID, 964 TEST_ETHDEV_ID, 965 0, &queue_conf); 966 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 967 968 /* Add queue to Rx adapter */ 969 queue_conf.ev.queue_id = 0; 970 queue_conf.ev.sched_type = RTE_SCHED_TYPE_ATOMIC; 971 queue_conf.ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL; 972 973 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 974 TEST_ETHDEV_ID, 975 0, &queue_conf); 976 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 977 978 /* Case 2: queue conf get with queue added to Rx adapter */ 979 err = rte_event_eth_rx_adapter_queue_conf_get(TEST_INST_ID, 980 TEST_ETHDEV_ID, 981 0, &queue_conf); 982 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 983 984 /* Case 3: queue conf get with invalid rx queue id */ 985 err = rte_event_eth_rx_adapter_queue_conf_get(TEST_INST_ID, 986 TEST_ETHDEV_ID, 987 -1, &queue_conf); 988 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 989 990 /* Case 4: queue conf get with NULL queue conf struct */ 991 err = rte_event_eth_rx_adapter_queue_conf_get(TEST_INST_ID, 992 TEST_ETHDEV_ID, 993 0, NULL); 994 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 995 996 /* Delete queue from the Rx adapter */ 997 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 998 TEST_ETHDEV_ID, 999 0); 1000 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 1001 1002 return TEST_SUCCESS; 1003 } 1004 1005 static int 1006 adapter_pollq_instance_get(void) 1007 { 1008 int err; 1009 uint8_t inst_id; 1010 uint16_t eth_dev_id; 1011 struct rte_eth_dev_info dev_info; 1012 struct rte_event_eth_rx_adapter_queue_conf queue_conf = {0}; 1013 1014 /* Case 1: Test without configuring eth */ 1015 err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID, 1016 TEST_ETH_QUEUE_ID, 1017 &inst_id); 1018 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 1019 1020 /* Case 2: Test with wrong eth port */ 1021 eth_dev_id = rte_eth_dev_count_total() + 1; 1022 err = rte_event_eth_rx_adapter_instance_get(eth_dev_id, 1023 TEST_ETH_QUEUE_ID, 1024 &inst_id); 1025 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 1026 1027 /* Case 3: Test with wrong rx queue */ 1028 err = rte_eth_dev_info_get(TEST_ETHDEV_ID, &dev_info); 1029 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 1030 1031 err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID, 1032 dev_info.max_rx_queues + 1, 1033 &inst_id); 1034 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 1035 1036 /* Case 4: Test with right instance, port & rxq */ 1037 /* Add queue 1 to Rx adapter */ 1038 queue_conf.ev.queue_id = TEST_ETH_QUEUE_ID; 1039 queue_conf.ev.sched_type = RTE_SCHED_TYPE_ATOMIC; 1040 queue_conf.ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL; 1041 queue_conf.servicing_weight = 1; /* poll queue */ 1042 1043 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 1044 TEST_ETHDEV_ID, 1045 TEST_ETH_QUEUE_ID, 1046 &queue_conf); 1047 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 1048 1049 err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID, 1050 TEST_ETH_QUEUE_ID, 1051 &inst_id); 1052 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 1053 TEST_ASSERT(inst_id == TEST_INST_ID, "Expected %d got %d", 1054 TEST_INST_ID, err); 1055 1056 /* Add queue 2 to Rx adapter */ 1057 queue_conf.ev.queue_id = TEST_ETH_QUEUE_ID + 1; 1058 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 1059 TEST_ETHDEV_ID, 1060 TEST_ETH_QUEUE_ID + 1, 1061 &queue_conf); 1062 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 1063 1064 err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID, 1065 TEST_ETH_QUEUE_ID + 1, 1066 &inst_id); 1067 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 1068 TEST_ASSERT(inst_id == TEST_INST_ID, "Expected %d got %d", 1069 TEST_INST_ID, err); 1070 1071 /* Add queue 3 to Rx adapter */ 1072 queue_conf.ev.queue_id = TEST_ETH_QUEUE_ID + 2; 1073 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 1074 TEST_ETHDEV_ID, 1075 TEST_ETH_QUEUE_ID + 2, 1076 &queue_conf); 1077 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 1078 1079 err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID, 1080 TEST_ETH_QUEUE_ID + 2, 1081 &inst_id); 1082 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 1083 TEST_ASSERT(inst_id == TEST_INST_ID, "Expected %d got %d", 1084 TEST_INST_ID, err); 1085 1086 /* Case 5: Test with right instance, port & wrong rxq */ 1087 err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID, 1088 TEST_ETH_QUEUE_ID + 3, 1089 &inst_id); 1090 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 1091 1092 /* Delete all queues from the Rx adapter */ 1093 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 1094 TEST_ETHDEV_ID, 1095 -1); 1096 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 1097 1098 return TEST_SUCCESS; 1099 } 1100 1101 static int 1102 adapter_intrq_instance_get(void) 1103 { 1104 int err; 1105 uint8_t inst_id; 1106 uint16_t eth_dev_id; 1107 struct rte_eth_dev_info dev_info; 1108 struct rte_event_eth_rx_adapter_queue_conf queue_conf = {0}; 1109 1110 /* Case 1: Test without configuring eth */ 1111 err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID, 1112 TEST_ETH_QUEUE_ID, 1113 &inst_id); 1114 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 1115 1116 /* Case 2: Test with wrong eth port */ 1117 eth_dev_id = rte_eth_dev_count_total() + 1; 1118 err = rte_event_eth_rx_adapter_instance_get(eth_dev_id, 1119 TEST_ETH_QUEUE_ID, 1120 &inst_id); 1121 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 1122 1123 /* Case 3: Test with wrong rx queue */ 1124 err = rte_eth_dev_info_get(TEST_ETHDEV_ID, &dev_info); 1125 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 1126 1127 err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID, 1128 dev_info.max_rx_queues + 1, 1129 &inst_id); 1130 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 1131 1132 /* Case 4: Test with right instance, port & rxq */ 1133 /* Intr enabled eth device can have both polled and intr queues. 1134 * Add polled queue 1 to Rx adapter 1135 */ 1136 queue_conf.ev.queue_id = TEST_ETH_QUEUE_ID; 1137 queue_conf.ev.sched_type = RTE_SCHED_TYPE_ATOMIC; 1138 queue_conf.ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL; 1139 queue_conf.servicing_weight = 1; /* poll queue */ 1140 1141 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 1142 TEST_ETHDEV_ID, 1143 TEST_ETH_QUEUE_ID, 1144 &queue_conf); 1145 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 1146 1147 err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID, 1148 TEST_ETH_QUEUE_ID, 1149 &inst_id); 1150 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 1151 TEST_ASSERT(inst_id == TEST_INST_ID, "Expected %d got %d", 1152 TEST_INST_ID, err); 1153 1154 /* Add intr queue 2 to Rx adapter */ 1155 queue_conf.ev.queue_id = TEST_ETH_QUEUE_ID + 1; 1156 queue_conf.servicing_weight = 0; /* intr queue */ 1157 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 1158 TEST_ETHDEV_ID, 1159 TEST_ETH_QUEUE_ID + 1, 1160 &queue_conf); 1161 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 1162 1163 err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID, 1164 TEST_ETH_QUEUE_ID + 1, 1165 &inst_id); 1166 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 1167 TEST_ASSERT(inst_id == TEST_INST_ID, "Expected %d got %d", 1168 TEST_INST_ID, err); 1169 1170 /* Add intr queue 3 to Rx adapter */ 1171 queue_conf.ev.queue_id = TEST_ETH_QUEUE_ID + 2; 1172 queue_conf.servicing_weight = 0; /* intr queue */ 1173 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 1174 TEST_ETHDEV_ID, 1175 TEST_ETH_QUEUE_ID + 2, 1176 &queue_conf); 1177 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 1178 1179 err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID, 1180 TEST_ETH_QUEUE_ID + 2, 1181 &inst_id); 1182 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 1183 TEST_ASSERT(inst_id == TEST_INST_ID, "Expected %d got %d", 1184 TEST_INST_ID, err); 1185 1186 /* Case 5: Test with right instance, port & wrong rxq */ 1187 err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID, 1188 TEST_ETH_QUEUE_ID + 3, 1189 &inst_id); 1190 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 1191 1192 /* Delete all queues from the Rx adapter */ 1193 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 1194 TEST_ETHDEV_ID, 1195 -1); 1196 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 1197 1198 return TEST_SUCCESS; 1199 } 1200 1201 static struct unit_test_suite event_eth_rx_tests = { 1202 .suite_name = "rx event eth adapter test suite", 1203 .setup = testsuite_setup, 1204 .teardown = testsuite_teardown, 1205 .unit_test_cases = { 1206 TEST_CASE_ST(NULL, NULL, adapter_create_free), 1207 TEST_CASE_ST(NULL, NULL, adapter_create_free_with_params), 1208 TEST_CASE_ST(adapter_create, adapter_free, 1209 adapter_queue_add_del), 1210 TEST_CASE_ST(adapter_create, adapter_free, 1211 adapter_multi_eth_add_del), 1212 TEST_CASE_ST(adapter_create, adapter_free, adapter_start_stop), 1213 TEST_CASE_ST(adapter_create, adapter_free, adapter_stats), 1214 TEST_CASE_ST(adapter_create, adapter_free, adapter_queue_conf), 1215 TEST_CASE_ST(adapter_create_with_params, adapter_free, 1216 adapter_queue_event_buf_test), 1217 TEST_CASE_ST(adapter_create_with_params, adapter_free, 1218 adapter_queue_stats_test), 1219 TEST_CASE_ST(adapter_create, adapter_free, 1220 adapter_pollq_instance_get), 1221 TEST_CASES_END() /**< NULL terminate unit test array */ 1222 } 1223 }; 1224 1225 static struct unit_test_suite event_eth_rx_intr_tests = { 1226 .suite_name = "rx event eth adapter test suite", 1227 .setup = testsuite_setup_rx_intr, 1228 .teardown = testsuite_teardown_rx_intr, 1229 .unit_test_cases = { 1230 TEST_CASE_ST(adapter_create, adapter_free, 1231 adapter_intr_queue_add_del), 1232 TEST_CASE_ST(adapter_create, adapter_free, 1233 adapter_intrq_instance_get), 1234 TEST_CASES_END() /**< NULL terminate unit test array */ 1235 } 1236 }; 1237 1238 static int 1239 test_event_eth_rx_adapter_common(void) 1240 { 1241 return unit_test_suite_runner(&event_eth_rx_tests); 1242 } 1243 1244 static int 1245 test_event_eth_rx_intr_adapter_common(void) 1246 { 1247 return unit_test_suite_runner(&event_eth_rx_intr_tests); 1248 } 1249 1250 #endif /* !RTE_EXEC_ENV_WINDOWS */ 1251 1252 REGISTER_TEST_COMMAND(event_eth_rx_adapter_autotest, 1253 test_event_eth_rx_adapter_common); 1254 REGISTER_TEST_COMMAND(event_eth_rx_intr_adapter_autotest, 1255 test_event_eth_rx_intr_adapter_common); 1256