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