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 = 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 = 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 void 475 adapter_free(void) 476 { 477 rte_event_eth_rx_adapter_free(TEST_INST_ID); 478 } 479 480 static int 481 adapter_create_free(void) 482 { 483 int err; 484 485 struct rte_event_port_conf rx_p_conf = { 486 .dequeue_depth = 8, 487 .enqueue_depth = 8, 488 .new_event_threshold = 1200, 489 }; 490 491 err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID, 492 NULL); 493 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 494 495 err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID, 496 &rx_p_conf); 497 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 498 499 err = rte_event_eth_rx_adapter_create(TEST_INST_ID, 500 TEST_DEV_ID, &rx_p_conf); 501 TEST_ASSERT(err == -EEXIST, "Expected -EEXIST %d got %d", -EEXIST, err); 502 503 err = rte_event_eth_rx_adapter_free(TEST_INST_ID); 504 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 505 506 err = rte_event_eth_rx_adapter_free(TEST_INST_ID); 507 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err); 508 509 err = rte_event_eth_rx_adapter_free(1); 510 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err); 511 512 return TEST_SUCCESS; 513 } 514 515 static int 516 adapter_create_free_with_params(void) 517 { 518 int err; 519 520 struct rte_event_port_conf rx_p_conf = { 521 .dequeue_depth = 8, 522 .enqueue_depth = 8, 523 .new_event_threshold = 1200, 524 }; 525 526 struct rte_event_eth_rx_adapter_params rxa_params = { 527 .event_buf_size = 1024 528 }; 529 530 err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID, 531 TEST_DEV_ID, NULL, NULL); 532 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 533 534 err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID, 535 TEST_DEV_ID, &rx_p_conf, &rxa_params); 536 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 537 538 err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID, 539 TEST_DEV_ID, &rx_p_conf, &rxa_params); 540 TEST_ASSERT(err == -EEXIST, "Expected -EEXIST %d got %d", -EEXIST, err); 541 542 rxa_params.event_buf_size = 0; 543 err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID, 544 TEST_DEV_ID, &rx_p_conf, &rxa_params); 545 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 546 547 err = rte_event_eth_rx_adapter_free(TEST_INST_ID); 548 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 549 550 err = rte_event_eth_rx_adapter_free(TEST_INST_ID); 551 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err); 552 553 err = rte_event_eth_rx_adapter_free(1); 554 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err); 555 556 return TEST_SUCCESS; 557 } 558 559 static int 560 adapter_queue_add_del(void) 561 { 562 int err; 563 struct rte_event ev; 564 uint32_t cap; 565 566 struct rte_event_eth_rx_adapter_queue_conf queue_config = {0}; 567 568 err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID, 569 &cap); 570 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 571 572 ev.queue_id = 0; 573 ev.sched_type = RTE_SCHED_TYPE_ATOMIC; 574 ev.priority = 0; 575 576 queue_config.rx_queue_flags = 0; 577 if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) { 578 ev.flow_id = 1; 579 queue_config.rx_queue_flags = 580 RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID; 581 } 582 queue_config.ev = ev; 583 queue_config.servicing_weight = 1; 584 585 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 586 rte_eth_dev_count_total(), 587 -1, &queue_config); 588 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 589 590 if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) { 591 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 592 TEST_ETHDEV_ID, 0, 593 &queue_config); 594 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 595 596 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 597 TEST_ETHDEV_ID, 0); 598 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 599 600 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 601 TEST_ETHDEV_ID, 602 -1, 603 &queue_config); 604 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 605 606 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 607 TEST_ETHDEV_ID, 608 -1); 609 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 610 } else { 611 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 612 TEST_ETHDEV_ID, 613 0, 614 &queue_config); 615 TEST_ASSERT(err == -EINVAL, "Expected EINVAL got %d", err); 616 617 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 618 TEST_ETHDEV_ID, -1, 619 &queue_config); 620 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 621 622 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 623 TEST_ETHDEV_ID, 0); 624 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 625 626 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 627 TEST_ETHDEV_ID, -1); 628 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 629 630 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 631 TEST_ETHDEV_ID, -1); 632 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 633 } 634 635 err = rte_event_eth_rx_adapter_queue_add(1, TEST_ETHDEV_ID, -1, 636 &queue_config); 637 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 638 639 err = rte_event_eth_rx_adapter_queue_del(1, TEST_ETHDEV_ID, -1); 640 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 641 642 return TEST_SUCCESS; 643 } 644 645 static int 646 adapter_multi_eth_add_del(void) 647 { 648 int err; 649 struct rte_event ev; 650 651 uint16_t port_index, port_index_base, drv_id = 0; 652 char driver_name[50]; 653 654 struct rte_event_eth_rx_adapter_queue_conf queue_config = {0}; 655 656 ev.queue_id = 0; 657 ev.sched_type = RTE_SCHED_TYPE_ATOMIC; 658 ev.priority = 0; 659 660 queue_config.rx_queue_flags = 0; 661 queue_config.ev = ev; 662 queue_config.servicing_weight = 1; 663 664 /* stop eth devices for existing */ 665 port_index = 0; 666 for (; port_index < rte_eth_dev_count_total(); port_index += 1) { 667 err = rte_eth_dev_stop(port_index); 668 TEST_ASSERT(err == 0, "Failed to stop port %u: %d\n", 669 port_index, err); 670 } 671 672 /* add the max port for rx_adapter */ 673 port_index = rte_eth_dev_count_total(); 674 port_index_base = port_index; 675 for (; port_index < RTE_MAX_ETHPORTS; port_index += 1) { 676 snprintf(driver_name, sizeof(driver_name), "%s%u", "net_null", 677 drv_id); 678 err = rte_vdev_init(driver_name, NULL); 679 TEST_ASSERT(err == 0, "Failed driver %s got %d", 680 driver_name, err); 681 drv_id += 1; 682 } 683 684 err = init_ports(rte_eth_dev_count_total()); 685 TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err); 686 687 /* eth_rx_adapter_queue_add for n ports */ 688 port_index = 0; 689 for (; port_index < rte_eth_dev_count_total(); port_index += 1) { 690 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 691 port_index, -1, 692 &queue_config); 693 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 694 } 695 696 /* eth_rx_adapter_queue_del n ports */ 697 port_index = 0; 698 for (; port_index < rte_eth_dev_count_total(); port_index += 1) { 699 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 700 port_index, -1); 701 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 702 } 703 704 /* delete vdev ports */ 705 for (drv_id = 0, port_index = port_index_base; 706 port_index < RTE_MAX_ETHPORTS; 707 drv_id += 1, port_index += 1) { 708 snprintf(driver_name, sizeof(driver_name), "%s%u", "net_null", 709 drv_id); 710 err = rte_vdev_uninit(driver_name); 711 TEST_ASSERT(err == 0, "Failed driver %s got %d", 712 driver_name, err); 713 } 714 715 return TEST_SUCCESS; 716 } 717 718 static int 719 adapter_intr_queue_add_del(void) 720 { 721 int err; 722 struct rte_event ev; 723 uint32_t cap; 724 uint16_t eth_port; 725 struct rte_event_eth_rx_adapter_queue_conf queue_config = {0}; 726 727 if (!default_params.rx_intr_port_inited) 728 return 0; 729 730 eth_port = default_params.rx_intr_port; 731 err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, eth_port, &cap); 732 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 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 741 /* weight = 0 => interrupt mode */ 742 queue_config.servicing_weight = 0; 743 744 if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) { 745 /* add queue 0 */ 746 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 747 TEST_ETHDEV_ID, 0, 748 &queue_config); 749 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 750 } 751 752 /* add all queues */ 753 queue_config.servicing_weight = 0; 754 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 755 TEST_ETHDEV_ID, 756 -1, 757 &queue_config); 758 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 759 760 if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) { 761 /* del queue 0 */ 762 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 763 TEST_ETHDEV_ID, 764 0); 765 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 766 } 767 768 /* del remaining queues */ 769 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 770 TEST_ETHDEV_ID, 771 -1); 772 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 773 774 /* add all queues */ 775 queue_config.servicing_weight = 0; 776 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 777 TEST_ETHDEV_ID, 778 -1, 779 &queue_config); 780 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 781 782 /* intr -> poll mode queue */ 783 queue_config.servicing_weight = 1; 784 785 if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) { 786 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 787 TEST_ETHDEV_ID, 788 0, 789 &queue_config); 790 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 791 } 792 793 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 794 TEST_ETHDEV_ID, 795 -1, 796 &queue_config); 797 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 798 799 /* del queues */ 800 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 801 TEST_ETHDEV_ID, 802 -1); 803 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 804 805 return TEST_SUCCESS; 806 } 807 808 static int 809 adapter_start_stop(void) 810 { 811 int err; 812 struct rte_event ev; 813 814 ev.queue_id = 0; 815 ev.sched_type = RTE_SCHED_TYPE_ATOMIC; 816 ev.priority = 0; 817 818 struct rte_event_eth_rx_adapter_queue_conf queue_config = {0}; 819 820 queue_config.rx_queue_flags = 0; 821 if (default_params.caps & 822 RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) { 823 ev.flow_id = 1; 824 queue_config.rx_queue_flags = 825 RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID; 826 } 827 828 queue_config.ev = ev; 829 queue_config.servicing_weight = 1; 830 831 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, TEST_ETHDEV_ID, 832 -1, &queue_config); 833 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 834 835 err = rte_event_eth_rx_adapter_start(TEST_INST_ID); 836 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 837 838 err = rte_event_eth_rx_adapter_stop(TEST_INST_ID); 839 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 840 841 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, TEST_ETHDEV_ID, 842 -1); 843 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 844 845 err = rte_event_eth_rx_adapter_start(TEST_INST_ID); 846 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 847 848 err = rte_event_eth_rx_adapter_stop(TEST_INST_ID); 849 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 850 851 err = rte_event_eth_rx_adapter_start(1); 852 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 853 854 err = rte_event_eth_rx_adapter_stop(1); 855 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 856 857 return TEST_SUCCESS; 858 } 859 860 static int 861 adapter_stats(void) 862 { 863 int err; 864 struct rte_event_eth_rx_adapter_stats stats; 865 866 err = rte_event_eth_rx_adapter_stats_get(TEST_INST_ID, NULL); 867 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 868 869 err = rte_event_eth_rx_adapter_stats_get(TEST_INST_ID, &stats); 870 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 871 872 err = rte_event_eth_rx_adapter_stats_get(1, &stats); 873 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 874 875 return TEST_SUCCESS; 876 } 877 878 static int 879 adapter_queue_conf(void) 880 { 881 int err; 882 struct rte_event_eth_rx_adapter_queue_conf queue_conf = {0}; 883 884 /* Case 1: queue conf get without any queues in Rx adapter */ 885 err = rte_event_eth_rx_adapter_queue_conf_get(TEST_INST_ID, 886 TEST_ETHDEV_ID, 887 0, &queue_conf); 888 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 889 890 /* Add queue to Rx adapter */ 891 queue_conf.ev.queue_id = 0; 892 queue_conf.ev.sched_type = RTE_SCHED_TYPE_ATOMIC; 893 queue_conf.ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL; 894 895 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 896 TEST_ETHDEV_ID, 897 0, &queue_conf); 898 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 899 900 /* Case 2: queue conf get with queue added to Rx adapter */ 901 err = rte_event_eth_rx_adapter_queue_conf_get(TEST_INST_ID, 902 TEST_ETHDEV_ID, 903 0, &queue_conf); 904 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 905 906 /* Case 3: queue conf get with invalid rx queue id */ 907 err = rte_event_eth_rx_adapter_queue_conf_get(TEST_INST_ID, 908 TEST_ETHDEV_ID, 909 -1, &queue_conf); 910 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 911 912 /* Case 4: queue conf get with NULL queue conf struct */ 913 err = rte_event_eth_rx_adapter_queue_conf_get(TEST_INST_ID, 914 TEST_ETHDEV_ID, 915 0, NULL); 916 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 917 918 /* Delete queue from the Rx adapter */ 919 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 920 TEST_ETHDEV_ID, 921 0); 922 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 923 924 return TEST_SUCCESS; 925 } 926 927 static struct unit_test_suite event_eth_rx_tests = { 928 .suite_name = "rx event eth adapter test suite", 929 .setup = testsuite_setup, 930 .teardown = testsuite_teardown, 931 .unit_test_cases = { 932 TEST_CASE_ST(NULL, NULL, adapter_create_free), 933 TEST_CASE_ST(NULL, NULL, adapter_create_free_with_params), 934 TEST_CASE_ST(adapter_create, adapter_free, 935 adapter_queue_add_del), 936 TEST_CASE_ST(adapter_create, adapter_free, 937 adapter_multi_eth_add_del), 938 TEST_CASE_ST(adapter_create, adapter_free, adapter_start_stop), 939 TEST_CASE_ST(adapter_create, adapter_free, adapter_stats), 940 TEST_CASE_ST(adapter_create, adapter_free, adapter_queue_conf), 941 TEST_CASE_ST(adapter_create_with_params, adapter_free, 942 adapter_queue_event_buf_test), 943 TEST_CASES_END() /**< NULL terminate unit test array */ 944 } 945 }; 946 947 static struct unit_test_suite event_eth_rx_intr_tests = { 948 .suite_name = "rx event eth adapter test suite", 949 .setup = testsuite_setup_rx_intr, 950 .teardown = testsuite_teardown_rx_intr, 951 .unit_test_cases = { 952 TEST_CASE_ST(adapter_create, adapter_free, 953 adapter_intr_queue_add_del), 954 TEST_CASES_END() /**< NULL terminate unit test array */ 955 } 956 }; 957 958 static int 959 test_event_eth_rx_adapter_common(void) 960 { 961 return unit_test_suite_runner(&event_eth_rx_tests); 962 } 963 964 static int 965 test_event_eth_rx_intr_adapter_common(void) 966 { 967 return unit_test_suite_runner(&event_eth_rx_intr_tests); 968 } 969 970 REGISTER_TEST_COMMAND(event_eth_rx_adapter_autotest, 971 test_event_eth_rx_adapter_common); 972 REGISTER_TEST_COMMAND(event_eth_rx_intr_adapter_autotest, 973 test_event_eth_rx_intr_adapter_common); 974