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