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