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