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, 92 addr.addr_bytes[0], addr.addr_bytes[1], 93 addr.addr_bytes[2], addr.addr_bytes[3], 94 addr.addr_bytes[4], addr.addr_bytes[5]); 95 96 /* Enable RX in promiscuous mode for the Ethernet device. */ 97 retval = rte_eth_promiscuous_enable(port); 98 if (retval != 0) 99 return retval; 100 101 return 0; 102 } 103 104 static inline int 105 port_init_rx_intr(uint16_t port, struct rte_mempool *mp) 106 { 107 static const struct rte_eth_conf port_conf_default = { 108 .rxmode = { 109 .mq_mode = ETH_MQ_RX_NONE, 110 }, 111 .intr_conf = { 112 .rxq = 1, 113 }, 114 }; 115 116 return port_init_common(port, &port_conf_default, mp); 117 } 118 119 static inline int 120 port_init(uint16_t port, struct rte_mempool *mp) 121 { 122 static const struct rte_eth_conf port_conf_default = { 123 .rxmode = { 124 .mq_mode = ETH_MQ_RX_NONE, 125 }, 126 }; 127 128 return port_init_common(port, &port_conf_default, mp); 129 } 130 131 static int 132 init_port_rx_intr(int num_ports) 133 { 134 int retval; 135 uint16_t portid; 136 int err; 137 138 default_params.mp = rte_pktmbuf_pool_create("packet_pool", 139 NB_MBUFS, 140 MBUF_CACHE_SIZE, 141 MBUF_PRIV_SIZE, 142 RTE_MBUF_DEFAULT_BUF_SIZE, 143 rte_socket_id()); 144 if (!default_params.mp) 145 return -ENOMEM; 146 147 RTE_ETH_FOREACH_DEV(portid) { 148 retval = port_init_rx_intr(portid, default_params.mp); 149 if (retval) 150 continue; 151 err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, portid, 152 &default_params.caps); 153 if (err) 154 continue; 155 if (!(default_params.caps & 156 RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT)) { 157 default_params.rx_intr_port_inited = 1; 158 default_params.rx_intr_port = portid; 159 return 0; 160 } 161 retval = rte_eth_dev_stop(portid); 162 TEST_ASSERT(retval == 0, "Failed to stop port %u: %d\n", 163 portid, retval); 164 } 165 return 0; 166 } 167 168 static int 169 init_ports(int num_ports) 170 { 171 uint16_t portid; 172 int retval; 173 174 struct rte_mempool *ptr = rte_mempool_lookup("packet_pool"); 175 176 if (ptr == NULL) 177 default_params.mp = rte_pktmbuf_pool_create("packet_pool", 178 NB_MBUFS, 179 MBUF_CACHE_SIZE, 180 MBUF_PRIV_SIZE, 181 RTE_MBUF_DEFAULT_BUF_SIZE, 182 rte_socket_id()); 183 else 184 default_params.mp = ptr; 185 186 if (!default_params.mp) 187 return -ENOMEM; 188 189 RTE_ETH_FOREACH_DEV(portid) { 190 retval = port_init(portid, default_params.mp); 191 if (retval) 192 return retval; 193 } 194 195 return 0; 196 } 197 198 static int 199 testsuite_setup(void) 200 { 201 int err; 202 uint8_t count; 203 struct rte_event_dev_info dev_info; 204 205 count = rte_event_dev_count(); 206 if (!count) { 207 printf("Failed to find a valid event device," 208 " testing with event_skeleton device\n"); 209 err = rte_vdev_init("event_skeleton", NULL); 210 TEST_ASSERT(err == 0, "Failed to create event_skeleton. err=%d", 211 err); 212 event_dev_created = true; 213 } 214 215 struct rte_event_dev_config config = { 216 .nb_event_queues = 1, 217 .nb_event_ports = 1, 218 }; 219 220 err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info); 221 config.nb_event_queue_flows = dev_info.max_event_queue_flows; 222 config.nb_event_port_dequeue_depth = 223 dev_info.max_event_port_dequeue_depth; 224 config.nb_event_port_enqueue_depth = 225 dev_info.max_event_port_enqueue_depth; 226 config.nb_events_limit = 227 dev_info.max_num_events; 228 err = rte_event_dev_configure(TEST_DEV_ID, &config); 229 TEST_ASSERT(err == 0, "Event device initialization failed err %d\n", 230 err); 231 232 count = rte_eth_dev_count_total(); 233 if (!count) { 234 printf("Testing with net_null device\n"); 235 err = rte_vdev_init("net_null", NULL); 236 TEST_ASSERT(err == 0, "Failed to create net_null. err=%d", 237 err); 238 eth_dev_created = true; 239 } 240 241 /* 242 * eth devices like octeontx use event device to receive packets 243 * so rte_eth_dev_start invokes rte_event_dev_start internally, so 244 * call init_ports after rte_event_dev_configure 245 */ 246 err = init_ports(rte_eth_dev_count_total()); 247 TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err); 248 249 err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID, 250 &default_params.caps); 251 TEST_ASSERT(err == 0, "Failed to get adapter cap err %d\n", 252 err); 253 254 return err; 255 } 256 257 static int 258 testsuite_setup_rx_intr(void) 259 { 260 int err; 261 uint8_t count; 262 struct rte_event_dev_info dev_info; 263 264 count = rte_event_dev_count(); 265 if (!count) { 266 printf("Failed to find a valid event device," 267 " testing with event_skeleton device\n"); 268 err = rte_vdev_init("event_skeleton", NULL); 269 TEST_ASSERT(err == 0, "Failed to create event_skeleton. err=%d", 270 err); 271 event_dev_created = true; 272 } 273 274 struct rte_event_dev_config config = { 275 .nb_event_queues = 1, 276 .nb_event_ports = 1, 277 }; 278 279 err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info); 280 config.nb_event_queue_flows = dev_info.max_event_queue_flows; 281 config.nb_event_port_dequeue_depth = 282 dev_info.max_event_port_dequeue_depth; 283 config.nb_event_port_enqueue_depth = 284 dev_info.max_event_port_enqueue_depth; 285 config.nb_events_limit = 286 dev_info.max_num_events; 287 288 err = rte_event_dev_configure(TEST_DEV_ID, &config); 289 TEST_ASSERT(err == 0, "Event device initialization failed err %d\n", 290 err); 291 292 count = rte_eth_dev_count_total(); 293 if (!count) { 294 printf("Testing with net_null device\n"); 295 err = rte_vdev_init("net_null", NULL); 296 TEST_ASSERT(err == 0, "Failed to create net_null. err=%d", 297 err); 298 eth_dev_created = true; 299 } 300 301 /* 302 * eth devices like octeontx use event device to receive packets 303 * so rte_eth_dev_start invokes rte_event_dev_start internally, so 304 * call init_ports after rte_event_dev_configure 305 */ 306 err = init_port_rx_intr(rte_eth_dev_count_total()); 307 TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err); 308 309 if (!default_params.rx_intr_port_inited) 310 return 0; 311 312 err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, 313 default_params.rx_intr_port, 314 &default_params.caps); 315 TEST_ASSERT(err == 0, "Failed to get adapter cap err %d\n", err); 316 317 return err; 318 } 319 320 static void 321 testsuite_teardown(void) 322 { 323 int err; 324 uint32_t i; 325 RTE_ETH_FOREACH_DEV(i) 326 rte_eth_dev_stop(i); 327 328 if (eth_dev_created) { 329 err = rte_vdev_uninit("net_null"); 330 if (err) 331 printf("Failed to delete net_null. err=%d", err); 332 eth_dev_created = false; 333 } 334 335 rte_mempool_free(default_params.mp); 336 if (event_dev_created) { 337 err = rte_vdev_uninit("event_skeleton"); 338 if (err) 339 printf("Failed to delete event_skeleton. err=%d", err); 340 event_dev_created = false; 341 } 342 343 memset(&default_params, 0, sizeof(default_params)); 344 } 345 346 static void 347 testsuite_teardown_rx_intr(void) 348 { 349 int err; 350 if (!default_params.rx_intr_port_inited) 351 return; 352 353 rte_eth_dev_stop(default_params.rx_intr_port); 354 if (eth_dev_created) { 355 err = rte_vdev_uninit("net_null"); 356 if (err) 357 printf("Failed to delete net_null. err=%d", err); 358 eth_dev_created = false; 359 } 360 rte_mempool_free(default_params.mp); 361 if (event_dev_created) { 362 err = rte_vdev_uninit("event_skeleton"); 363 if (err) 364 printf("Failed to delete event_skeleton. err=%d", err); 365 event_dev_created = false; 366 } 367 368 memset(&default_params, 0, sizeof(default_params)); 369 } 370 371 static int 372 adapter_create(void) 373 { 374 int err; 375 struct rte_event_dev_info dev_info; 376 struct rte_event_port_conf rx_p_conf; 377 378 memset(&rx_p_conf, 0, sizeof(rx_p_conf)); 379 380 err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info); 381 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 382 383 rx_p_conf.new_event_threshold = dev_info.max_num_events; 384 rx_p_conf.dequeue_depth = dev_info.max_event_port_dequeue_depth; 385 rx_p_conf.enqueue_depth = dev_info.max_event_port_enqueue_depth; 386 err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID, 387 &rx_p_conf); 388 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 389 390 return err; 391 } 392 393 static void 394 adapter_free(void) 395 { 396 rte_event_eth_rx_adapter_free(TEST_INST_ID); 397 } 398 399 static int 400 adapter_create_free(void) 401 { 402 int err; 403 404 struct rte_event_port_conf rx_p_conf = { 405 .dequeue_depth = 8, 406 .enqueue_depth = 8, 407 .new_event_threshold = 1200, 408 }; 409 410 err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID, 411 NULL); 412 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 413 414 err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID, 415 &rx_p_conf); 416 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 417 418 err = rte_event_eth_rx_adapter_create(TEST_INST_ID, 419 TEST_DEV_ID, &rx_p_conf); 420 TEST_ASSERT(err == -EEXIST, "Expected -EEXIST %d got %d", -EEXIST, err); 421 422 err = rte_event_eth_rx_adapter_free(TEST_INST_ID); 423 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 424 425 err = rte_event_eth_rx_adapter_free(TEST_INST_ID); 426 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err); 427 428 err = rte_event_eth_rx_adapter_free(1); 429 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err); 430 431 return TEST_SUCCESS; 432 } 433 434 static int 435 adapter_queue_add_del(void) 436 { 437 int err; 438 struct rte_event ev; 439 uint32_t cap; 440 441 struct rte_event_eth_rx_adapter_queue_conf queue_config; 442 443 err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID, 444 &cap); 445 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 446 447 ev.queue_id = 0; 448 ev.sched_type = RTE_SCHED_TYPE_ATOMIC; 449 ev.priority = 0; 450 451 queue_config.rx_queue_flags = 0; 452 if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) { 453 ev.flow_id = 1; 454 queue_config.rx_queue_flags = 455 RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID; 456 } 457 queue_config.ev = ev; 458 queue_config.servicing_weight = 1; 459 460 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 461 rte_eth_dev_count_total(), 462 -1, &queue_config); 463 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 464 465 if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) { 466 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 467 TEST_ETHDEV_ID, 0, 468 &queue_config); 469 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 470 471 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 472 TEST_ETHDEV_ID, 0); 473 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 474 475 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 476 TEST_ETHDEV_ID, 477 -1, 478 &queue_config); 479 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 480 481 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 482 TEST_ETHDEV_ID, 483 -1); 484 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 485 } else { 486 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 487 TEST_ETHDEV_ID, 488 0, 489 &queue_config); 490 TEST_ASSERT(err == -EINVAL, "Expected EINVAL got %d", err); 491 492 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 493 TEST_ETHDEV_ID, -1, 494 &queue_config); 495 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 496 497 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 498 TEST_ETHDEV_ID, 0); 499 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 500 501 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 502 TEST_ETHDEV_ID, -1); 503 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 504 505 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 506 TEST_ETHDEV_ID, -1); 507 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 508 } 509 510 err = rte_event_eth_rx_adapter_queue_add(1, TEST_ETHDEV_ID, -1, 511 &queue_config); 512 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 513 514 err = rte_event_eth_rx_adapter_queue_del(1, TEST_ETHDEV_ID, -1); 515 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 516 517 return TEST_SUCCESS; 518 } 519 520 static int 521 adapter_multi_eth_add_del(void) 522 { 523 int err; 524 struct rte_event ev; 525 526 uint16_t port_index, port_index_base, drv_id = 0; 527 char driver_name[50]; 528 529 struct rte_event_eth_rx_adapter_queue_conf queue_config; 530 531 ev.queue_id = 0; 532 ev.sched_type = RTE_SCHED_TYPE_ATOMIC; 533 ev.priority = 0; 534 535 queue_config.rx_queue_flags = 0; 536 queue_config.ev = ev; 537 queue_config.servicing_weight = 1; 538 539 /* stop eth devices for existing */ 540 port_index = 0; 541 for (; port_index < rte_eth_dev_count_total(); port_index += 1) { 542 err = rte_eth_dev_stop(port_index); 543 TEST_ASSERT(err == 0, "Failed to stop port %u: %d\n", 544 port_index, err); 545 } 546 547 /* add the max port for rx_adapter */ 548 port_index = rte_eth_dev_count_total(); 549 port_index_base = port_index; 550 for (; port_index < RTE_MAX_ETHPORTS; port_index += 1) { 551 snprintf(driver_name, sizeof(driver_name), "%s%u", "net_null", 552 drv_id); 553 err = rte_vdev_init(driver_name, NULL); 554 TEST_ASSERT(err == 0, "Failed driver %s got %d", 555 driver_name, err); 556 drv_id += 1; 557 } 558 559 err = init_ports(rte_eth_dev_count_total()); 560 TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err); 561 562 /* eth_rx_adapter_queue_add for n ports */ 563 port_index = 0; 564 for (; port_index < rte_eth_dev_count_total(); port_index += 1) { 565 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 566 port_index, -1, 567 &queue_config); 568 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 569 } 570 571 /* eth_rx_adapter_queue_del n ports */ 572 port_index = 0; 573 for (; port_index < rte_eth_dev_count_total(); port_index += 1) { 574 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 575 port_index, -1); 576 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 577 } 578 579 /* delete vdev ports */ 580 for (drv_id = 0, port_index = port_index_base; 581 port_index < RTE_MAX_ETHPORTS; 582 drv_id += 1, port_index += 1) { 583 snprintf(driver_name, sizeof(driver_name), "%s%u", "net_null", 584 drv_id); 585 err = rte_vdev_uninit(driver_name); 586 TEST_ASSERT(err == 0, "Failed driver %s got %d", 587 driver_name, err); 588 } 589 590 return TEST_SUCCESS; 591 } 592 593 static int 594 adapter_intr_queue_add_del(void) 595 { 596 int err; 597 struct rte_event ev; 598 uint32_t cap; 599 uint16_t eth_port; 600 struct rte_event_eth_rx_adapter_queue_conf queue_config; 601 602 if (!default_params.rx_intr_port_inited) 603 return 0; 604 605 eth_port = default_params.rx_intr_port; 606 err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, eth_port, &cap); 607 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 608 609 ev.queue_id = 0; 610 ev.sched_type = RTE_SCHED_TYPE_ATOMIC; 611 ev.priority = 0; 612 613 queue_config.rx_queue_flags = 0; 614 queue_config.ev = ev; 615 616 /* weight = 0 => interrupt mode */ 617 queue_config.servicing_weight = 0; 618 619 if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) { 620 /* add queue 0 */ 621 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 622 TEST_ETHDEV_ID, 0, 623 &queue_config); 624 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 625 } 626 627 /* add all queues */ 628 queue_config.servicing_weight = 0; 629 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 630 TEST_ETHDEV_ID, 631 -1, 632 &queue_config); 633 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 634 635 if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) { 636 /* del queue 0 */ 637 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 638 TEST_ETHDEV_ID, 639 0); 640 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 641 } 642 643 /* del remaining queues */ 644 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 645 TEST_ETHDEV_ID, 646 -1); 647 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 648 649 /* add all queues */ 650 queue_config.servicing_weight = 0; 651 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 652 TEST_ETHDEV_ID, 653 -1, 654 &queue_config); 655 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 656 657 /* intr -> poll mode queue */ 658 queue_config.servicing_weight = 1; 659 660 if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) { 661 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 662 TEST_ETHDEV_ID, 663 0, 664 &queue_config); 665 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 666 } 667 668 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, 669 TEST_ETHDEV_ID, 670 -1, 671 &queue_config); 672 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 673 674 /* del queues */ 675 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, 676 TEST_ETHDEV_ID, 677 -1); 678 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 679 680 return TEST_SUCCESS; 681 } 682 683 static int 684 adapter_start_stop(void) 685 { 686 int err; 687 struct rte_event ev; 688 689 ev.queue_id = 0; 690 ev.sched_type = RTE_SCHED_TYPE_ATOMIC; 691 ev.priority = 0; 692 693 struct rte_event_eth_rx_adapter_queue_conf queue_config; 694 695 queue_config.rx_queue_flags = 0; 696 if (default_params.caps & 697 RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) { 698 ev.flow_id = 1; 699 queue_config.rx_queue_flags = 700 RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID; 701 } 702 703 queue_config.ev = ev; 704 queue_config.servicing_weight = 1; 705 706 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, TEST_ETHDEV_ID, 707 -1, &queue_config); 708 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 709 710 err = rte_event_eth_rx_adapter_start(TEST_INST_ID); 711 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 712 713 err = rte_event_eth_rx_adapter_stop(TEST_INST_ID); 714 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 715 716 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, TEST_ETHDEV_ID, 717 -1); 718 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 719 720 err = rte_event_eth_rx_adapter_start(TEST_INST_ID); 721 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 722 723 err = rte_event_eth_rx_adapter_stop(TEST_INST_ID); 724 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 725 726 err = rte_event_eth_rx_adapter_start(1); 727 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 728 729 err = rte_event_eth_rx_adapter_stop(1); 730 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 731 732 return TEST_SUCCESS; 733 } 734 735 static int 736 adapter_stats(void) 737 { 738 int err; 739 struct rte_event_eth_rx_adapter_stats stats; 740 741 err = rte_event_eth_rx_adapter_stats_get(TEST_INST_ID, NULL); 742 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 743 744 err = rte_event_eth_rx_adapter_stats_get(TEST_INST_ID, &stats); 745 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 746 747 err = rte_event_eth_rx_adapter_stats_get(1, &stats); 748 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 749 750 return TEST_SUCCESS; 751 } 752 753 static struct unit_test_suite event_eth_rx_tests = { 754 .suite_name = "rx event eth adapter test suite", 755 .setup = testsuite_setup, 756 .teardown = testsuite_teardown, 757 .unit_test_cases = { 758 TEST_CASE_ST(NULL, NULL, adapter_create_free), 759 TEST_CASE_ST(adapter_create, adapter_free, 760 adapter_queue_add_del), 761 TEST_CASE_ST(adapter_create, adapter_free, 762 adapter_multi_eth_add_del), 763 TEST_CASE_ST(adapter_create, adapter_free, adapter_start_stop), 764 TEST_CASE_ST(adapter_create, adapter_free, adapter_stats), 765 TEST_CASES_END() /**< NULL terminate unit test array */ 766 } 767 }; 768 769 static struct unit_test_suite event_eth_rx_intr_tests = { 770 .suite_name = "rx event eth adapter test suite", 771 .setup = testsuite_setup_rx_intr, 772 .teardown = testsuite_teardown_rx_intr, 773 .unit_test_cases = { 774 TEST_CASE_ST(adapter_create, adapter_free, 775 adapter_intr_queue_add_del), 776 TEST_CASES_END() /**< NULL terminate unit test array */ 777 } 778 }; 779 780 static int 781 test_event_eth_rx_adapter_common(void) 782 { 783 return unit_test_suite_runner(&event_eth_rx_tests); 784 } 785 786 static int 787 test_event_eth_rx_intr_adapter_common(void) 788 { 789 return unit_test_suite_runner(&event_eth_rx_intr_tests); 790 } 791 792 REGISTER_TEST_COMMAND(event_eth_rx_adapter_autotest, 793 test_event_eth_rx_adapter_common); 794 REGISTER_TEST_COMMAND(event_eth_rx_intr_adapter_autotest, 795 test_event_eth_rx_intr_adapter_common); 796