1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2018 Intel Corporation 3 */ 4 5 #include <string.h> 6 7 #include <rte_bus_vdev.h> 8 #include <rte_common.h> 9 #include <rte_ethdev.h> 10 #include <rte_eth_ring.h> 11 #include <rte_eventdev.h> 12 #include <rte_event_eth_tx_adapter.h> 13 #include <rte_mbuf.h> 14 #include <rte_mempool.h> 15 #include <rte_service.h> 16 17 #include "test.h" 18 19 #ifdef RTE_EXEC_ENV_WINDOWS 20 static int 21 test_event_eth_tx_adapter_common(void) 22 { 23 printf("event_eth_tx_adapter not supported on Windows, skipping test\n"); 24 return TEST_SKIPPED; 25 } 26 27 #else 28 29 #define MAX_NUM_QUEUE RTE_PMD_RING_MAX_RX_RINGS 30 #define TEST_INST_ID 0 31 #define TEST_DEV_ID 0 32 #define SOCKET0 0 33 #define RING_SIZE 256 34 #define ETH_NAME_LEN 32 35 #define NUM_ETH_PAIR 1 36 #define NUM_ETH_DEV (2 * NUM_ETH_PAIR) 37 #define NB_MBUF 512 38 #define PAIR_PORT_INDEX(p) ((p) + NUM_ETH_PAIR) 39 #define PORT(p) default_params.port[(p)] 40 #define TEST_ETHDEV_ID PORT(0) 41 #define TEST_ETHDEV_PAIR_ID PORT(PAIR_PORT_INDEX(0)) 42 43 #define EDEV_RETRY 0xffff 44 45 struct event_eth_tx_adapter_test_params { 46 struct rte_mempool *mp; 47 uint16_t rx_rings, tx_rings; 48 struct rte_ring *r[NUM_ETH_DEV][MAX_NUM_QUEUE]; 49 int port[NUM_ETH_DEV]; 50 }; 51 52 static int event_dev_delete; 53 static struct event_eth_tx_adapter_test_params default_params; 54 static uint64_t eid = ~0ULL; 55 static uint32_t tid; 56 57 static inline int 58 port_init_common(uint16_t port, const struct rte_eth_conf *port_conf, 59 struct rte_mempool *mp) 60 { 61 const uint16_t rx_ring_size = RING_SIZE, tx_ring_size = RING_SIZE; 62 int retval; 63 uint16_t q; 64 65 if (!rte_eth_dev_is_valid_port(port)) 66 return -1; 67 68 default_params.rx_rings = MAX_NUM_QUEUE; 69 default_params.tx_rings = MAX_NUM_QUEUE; 70 71 /* Configure the Ethernet device. */ 72 retval = rte_eth_dev_configure(port, default_params.rx_rings, 73 default_params.tx_rings, port_conf); 74 if (retval != 0) 75 return retval; 76 77 for (q = 0; q < default_params.rx_rings; q++) { 78 retval = rte_eth_rx_queue_setup(port, q, rx_ring_size, 79 rte_eth_dev_socket_id(port), NULL, mp); 80 if (retval < 0) 81 return retval; 82 } 83 84 for (q = 0; q < default_params.tx_rings; q++) { 85 retval = rte_eth_tx_queue_setup(port, q, tx_ring_size, 86 rte_eth_dev_socket_id(port), NULL); 87 if (retval < 0) 88 return retval; 89 } 90 91 /* Start the Ethernet port. */ 92 retval = rte_eth_dev_start(port); 93 if (retval < 0) 94 return retval; 95 96 /* Display the port MAC address. */ 97 struct rte_ether_addr addr; 98 retval = rte_eth_macaddr_get(port, &addr); 99 if (retval < 0) 100 return retval; 101 printf("Port %u MAC: %02" PRIx8 " %02" PRIx8 " %02" PRIx8 102 " %02" PRIx8 " %02" PRIx8 " %02" PRIx8 "\n", 103 (unsigned int)port, RTE_ETHER_ADDR_BYTES(&addr)); 104 105 /* Enable RX in promiscuous mode for the Ethernet device. */ 106 retval = rte_eth_promiscuous_enable(port); 107 if (retval != 0) 108 return retval; 109 110 return 0; 111 } 112 113 static inline int 114 port_init(uint16_t port, struct rte_mempool *mp) 115 { 116 struct rte_eth_conf conf = { 0 }; 117 return port_init_common(port, &conf, mp); 118 } 119 120 #define RING_NAME_LEN 20 121 #define DEV_NAME_LEN 20 122 123 static int 124 init_ports(void) 125 { 126 char ring_name[ETH_NAME_LEN]; 127 unsigned int i, j; 128 struct rte_ring * const *c1; 129 struct rte_ring * const *c2; 130 int err; 131 132 if (!default_params.mp) 133 default_params.mp = rte_pktmbuf_pool_create("mbuf_pool", 134 NB_MBUF, 32, 135 0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id()); 136 137 if (!default_params.mp) 138 return -ENOMEM; 139 140 for (i = 0; i < NUM_ETH_DEV; i++) { 141 for (j = 0; j < MAX_NUM_QUEUE; j++) { 142 snprintf(ring_name, sizeof(ring_name), "R%u%u", i, j); 143 default_params.r[i][j] = rte_ring_create(ring_name, 144 RING_SIZE, 145 SOCKET0, 146 RING_F_SP_ENQ | RING_F_SC_DEQ); 147 TEST_ASSERT((default_params.r[i][j] != NULL), 148 "Failed to allocate ring"); 149 } 150 } 151 152 /* 153 * To create two pseudo-Ethernet ports where the traffic is 154 * switched between them, that is, traffic sent to port 1 is 155 * read back from port 2 and vice-versa 156 */ 157 for (i = 0; i < NUM_ETH_PAIR; i++) { 158 char dev_name[DEV_NAME_LEN]; 159 int p; 160 161 c1 = default_params.r[i]; 162 c2 = default_params.r[PAIR_PORT_INDEX(i)]; 163 164 snprintf(dev_name, DEV_NAME_LEN, "%u-%u", i, i + NUM_ETH_PAIR); 165 p = rte_eth_from_rings(dev_name, c1, MAX_NUM_QUEUE, 166 c2, MAX_NUM_QUEUE, SOCKET0); 167 TEST_ASSERT(p >= 0, "Port creation failed %s", dev_name); 168 err = port_init(p, default_params.mp); 169 TEST_ASSERT(err == 0, "Port init failed %s", dev_name); 170 default_params.port[i] = p; 171 172 snprintf(dev_name, DEV_NAME_LEN, "%u-%u", i + NUM_ETH_PAIR, i); 173 p = rte_eth_from_rings(dev_name, c2, MAX_NUM_QUEUE, 174 c1, MAX_NUM_QUEUE, SOCKET0); 175 TEST_ASSERT(p > 0, "Port creation failed %s", dev_name); 176 err = port_init(p, default_params.mp); 177 TEST_ASSERT(err == 0, "Port init failed %s", dev_name); 178 default_params.port[PAIR_PORT_INDEX(i)] = p; 179 } 180 181 return 0; 182 } 183 184 static void 185 deinit_ports(void) 186 { 187 uint16_t i, j; 188 char name[ETH_NAME_LEN]; 189 190 for (i = 0; i < RTE_DIM(default_params.port); i++) { 191 rte_eth_dev_stop(default_params.port[i]); 192 rte_eth_dev_get_name_by_port(default_params.port[i], name); 193 rte_vdev_uninit(name); 194 for (j = 0; j < RTE_DIM(default_params.r[i]); j++) 195 rte_ring_free(default_params.r[i][j]); 196 } 197 } 198 199 static int 200 testsuite_setup(void) 201 { 202 const char *vdev_name = "event_sw0"; 203 204 int err = init_ports(); 205 TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err); 206 207 if (rte_event_dev_count() == 0) { 208 printf("Failed to find a valid event device," 209 " testing with event_sw0 device\n"); 210 err = rte_vdev_init(vdev_name, NULL); 211 TEST_ASSERT(err == 0, "vdev %s creation failed %d\n", 212 vdev_name, err); 213 event_dev_delete = 1; 214 } 215 return err; 216 } 217 218 #define DEVICE_ID_SIZE 64 219 220 static void 221 testsuite_teardown(void) 222 { 223 deinit_ports(); 224 rte_mempool_free(default_params.mp); 225 default_params.mp = NULL; 226 if (event_dev_delete) 227 rte_vdev_uninit("event_sw0"); 228 } 229 230 static int 231 tx_adapter_create(void) 232 { 233 int err; 234 struct rte_event_dev_info dev_info; 235 struct rte_event_port_conf tx_p_conf; 236 uint8_t priority; 237 uint8_t queue_id; 238 239 struct rte_event_dev_config config = { 240 .nb_event_queues = 1, 241 .nb_event_ports = 1, 242 }; 243 244 struct rte_event_queue_conf wkr_q_conf = { 245 .schedule_type = RTE_SCHED_TYPE_ORDERED, 246 .priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 247 .nb_atomic_flows = 1024, 248 .nb_atomic_order_sequences = 1024, 249 }; 250 251 memset(&tx_p_conf, 0, sizeof(tx_p_conf)); 252 err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info); 253 config.nb_event_queue_flows = dev_info.max_event_queue_flows; 254 config.nb_event_port_dequeue_depth = 255 dev_info.max_event_port_dequeue_depth; 256 config.nb_event_port_enqueue_depth = 257 dev_info.max_event_port_enqueue_depth; 258 config.nb_events_limit = 259 dev_info.max_num_events; 260 261 err = rte_event_dev_configure(TEST_DEV_ID, &config); 262 TEST_ASSERT(err == 0, "Event device initialization failed err %d\n", 263 err); 264 265 queue_id = 0; 266 err = rte_event_queue_setup(TEST_DEV_ID, 0, &wkr_q_conf); 267 TEST_ASSERT(err == 0, "Event queue setup failed %d\n", err); 268 269 err = rte_event_port_setup(TEST_DEV_ID, 0, NULL); 270 TEST_ASSERT(err == 0, "Event port setup failed %d\n", err); 271 272 priority = RTE_EVENT_DEV_PRIORITY_LOWEST; 273 err = rte_event_port_link(TEST_DEV_ID, 0, &queue_id, &priority, 1); 274 TEST_ASSERT(err == 1, "Error linking port %s\n", 275 rte_strerror(rte_errno)); 276 err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info); 277 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 278 279 tx_p_conf.new_event_threshold = dev_info.max_num_events; 280 tx_p_conf.dequeue_depth = dev_info.max_event_port_dequeue_depth; 281 tx_p_conf.enqueue_depth = dev_info.max_event_port_enqueue_depth; 282 err = rte_event_eth_tx_adapter_create(TEST_INST_ID, TEST_DEV_ID, 283 &tx_p_conf); 284 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 285 286 return err; 287 } 288 289 static void 290 tx_adapter_free(void) 291 { 292 rte_event_eth_tx_adapter_free(TEST_INST_ID); 293 } 294 295 static int 296 tx_adapter_create_free(void) 297 { 298 int err; 299 struct rte_event_dev_info dev_info; 300 struct rte_event_port_conf tx_p_conf; 301 302 err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info); 303 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 304 305 tx_p_conf.new_event_threshold = dev_info.max_num_events; 306 tx_p_conf.dequeue_depth = dev_info.max_event_port_dequeue_depth; 307 tx_p_conf.enqueue_depth = dev_info.max_event_port_enqueue_depth; 308 309 err = rte_event_eth_tx_adapter_create(TEST_INST_ID, TEST_DEV_ID, 310 NULL); 311 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 312 313 err = rte_event_eth_tx_adapter_create(TEST_INST_ID, TEST_DEV_ID, 314 &tx_p_conf); 315 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 316 317 err = rte_event_eth_tx_adapter_create(TEST_INST_ID, 318 TEST_DEV_ID, &tx_p_conf); 319 TEST_ASSERT(err == -EEXIST, "Expected -EEXIST %d got %d", -EEXIST, err); 320 321 err = rte_event_eth_tx_adapter_free(TEST_INST_ID); 322 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 323 324 err = rte_event_eth_tx_adapter_free(TEST_INST_ID); 325 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err); 326 327 err = rte_event_eth_tx_adapter_free(1); 328 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err); 329 330 return TEST_SUCCESS; 331 } 332 333 static int 334 tx_adapter_queue_add_del(void) 335 { 336 int err; 337 uint32_t cap; 338 339 err = rte_event_eth_tx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID, 340 &cap); 341 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 342 343 344 err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID, 345 rte_eth_dev_count_total(), 346 -1); 347 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 348 349 err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID, 350 TEST_ETHDEV_ID, 351 0); 352 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 353 354 err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID, 355 TEST_ETHDEV_ID, 356 -1); 357 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 358 359 err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID, 360 TEST_ETHDEV_ID, 361 0); 362 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 363 364 err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID, 365 TEST_ETHDEV_ID, 366 -1); 367 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 368 369 err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID, 370 TEST_ETHDEV_ID, 371 -1); 372 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 373 374 err = rte_event_eth_tx_adapter_queue_add(1, TEST_ETHDEV_ID, -1); 375 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 376 377 err = rte_event_eth_tx_adapter_queue_del(1, TEST_ETHDEV_ID, -1); 378 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 379 380 return TEST_SUCCESS; 381 } 382 383 static int 384 tx_adapter_start_stop(void) 385 { 386 int err; 387 388 err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID, TEST_ETHDEV_ID, 389 -1); 390 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 391 392 err = rte_event_eth_tx_adapter_start(TEST_INST_ID); 393 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 394 395 err = rte_event_eth_tx_adapter_stop(TEST_INST_ID); 396 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 397 398 err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID, TEST_ETHDEV_ID, 399 -1); 400 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 401 402 err = rte_event_eth_tx_adapter_start(TEST_INST_ID); 403 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 404 405 err = rte_event_eth_tx_adapter_stop(TEST_INST_ID); 406 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 407 408 err = rte_event_eth_tx_adapter_start(1); 409 410 err = rte_event_eth_tx_adapter_stop(1); 411 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 412 413 return TEST_SUCCESS; 414 } 415 416 417 static int 418 tx_adapter_single(uint16_t port, uint16_t tx_queue_id, 419 struct rte_mbuf *m, uint8_t qid, 420 uint8_t sched_type) 421 { 422 struct rte_event event; 423 struct rte_mbuf *r; 424 int ret; 425 unsigned int l; 426 427 event.queue_id = qid; 428 event.op = RTE_EVENT_OP_NEW; 429 event.event_type = RTE_EVENT_TYPE_CPU; 430 event.sched_type = sched_type; 431 event.mbuf = m; 432 433 m->port = port; 434 rte_event_eth_tx_adapter_txq_set(m, tx_queue_id); 435 436 l = 0; 437 while (rte_event_enqueue_burst(TEST_DEV_ID, 0, &event, 1) != 1) { 438 l++; 439 if (l > EDEV_RETRY) 440 break; 441 } 442 443 TEST_ASSERT(l < EDEV_RETRY, "Unable to enqueue to eventdev"); 444 l = 0; 445 while (l++ < EDEV_RETRY) { 446 447 if (eid != ~0ULL) { 448 ret = rte_service_run_iter_on_app_lcore(eid, 0); 449 TEST_ASSERT(ret == 0, "failed to run service %d", ret); 450 } 451 452 ret = rte_service_run_iter_on_app_lcore(tid, 0); 453 TEST_ASSERT(ret == 0, "failed to run service %d", ret); 454 455 if (rte_eth_rx_burst(TEST_ETHDEV_PAIR_ID, tx_queue_id, 456 &r, 1)) { 457 TEST_ASSERT_EQUAL(r, m, "mbuf comparison failed" 458 " expected %p received %p", m, r); 459 return 0; 460 } 461 } 462 463 TEST_ASSERT(0, "Failed to receive packet"); 464 return -1; 465 } 466 467 static int 468 tx_adapter_service(void) 469 { 470 struct rte_event_eth_tx_adapter_stats stats; 471 uint32_t i; 472 int err; 473 uint8_t ev_port, ev_qid; 474 struct rte_mbuf bufs[RING_SIZE]; 475 struct rte_mbuf *pbufs[RING_SIZE]; 476 struct rte_event_dev_info dev_info; 477 struct rte_event_dev_config dev_conf; 478 struct rte_event_queue_conf qconf; 479 uint32_t qcnt, pcnt; 480 uint16_t q; 481 int internal_port; 482 uint32_t cap; 483 484 memset(&dev_conf, 0, sizeof(dev_conf)); 485 err = rte_event_eth_tx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID, 486 &cap); 487 TEST_ASSERT(err == 0, "Failed to get adapter cap err %d\n", err); 488 489 internal_port = !!(cap & RTE_EVENT_ETH_TX_ADAPTER_CAP_INTERNAL_PORT); 490 if (internal_port) 491 return TEST_SUCCESS; 492 493 err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID, TEST_ETHDEV_ID, 494 -1); 495 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 496 497 err = rte_event_eth_tx_adapter_event_port_get(TEST_INST_ID, 498 &ev_port); 499 TEST_ASSERT_SUCCESS(err, "Failed to get event port %d", err); 500 501 err = rte_event_dev_attr_get(TEST_DEV_ID, RTE_EVENT_DEV_ATTR_PORT_COUNT, 502 &pcnt); 503 TEST_ASSERT_SUCCESS(err, "Port count get failed"); 504 505 err = rte_event_dev_attr_get(TEST_DEV_ID, 506 RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &qcnt); 507 TEST_ASSERT_SUCCESS(err, "Queue count get failed"); 508 509 err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info); 510 TEST_ASSERT_SUCCESS(err, "Dev info failed"); 511 512 dev_conf.nb_event_queue_flows = dev_info.max_event_queue_flows; 513 dev_conf.nb_event_port_dequeue_depth = 514 dev_info.max_event_port_dequeue_depth; 515 dev_conf.nb_event_port_enqueue_depth = 516 dev_info.max_event_port_enqueue_depth; 517 dev_conf.nb_events_limit = 518 dev_info.max_num_events; 519 dev_conf.nb_event_queues = qcnt + 1; 520 dev_conf.nb_event_ports = pcnt; 521 err = rte_event_dev_configure(TEST_DEV_ID, &dev_conf); 522 TEST_ASSERT(err == 0, "Event device initialization failed err %d\n", 523 err); 524 525 ev_qid = qcnt; 526 qconf.nb_atomic_flows = dev_info.max_event_queue_flows; 527 qconf.nb_atomic_order_sequences = 32; 528 qconf.schedule_type = RTE_SCHED_TYPE_ATOMIC; 529 qconf.priority = RTE_EVENT_DEV_PRIORITY_HIGHEST; 530 qconf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_SINGLE_LINK; 531 err = rte_event_queue_setup(TEST_DEV_ID, ev_qid, &qconf); 532 TEST_ASSERT_SUCCESS(err, "Failed to setup queue %u", ev_qid); 533 534 /* 535 * Setup ports again so that the newly added queue is visible 536 * to them 537 */ 538 for (i = 0; i < pcnt; i++) { 539 540 int n_links; 541 uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV]; 542 uint8_t priorities[RTE_EVENT_MAX_QUEUES_PER_DEV]; 543 544 if (i == ev_port) 545 continue; 546 547 n_links = rte_event_port_links_get(TEST_DEV_ID, i, queues, 548 priorities); 549 TEST_ASSERT(n_links > 0, "Failed to get port links %d\n", 550 n_links); 551 err = rte_event_port_setup(TEST_DEV_ID, i, NULL); 552 TEST_ASSERT(err == 0, "Failed to setup port err %d\n", err); 553 err = rte_event_port_link(TEST_DEV_ID, i, queues, priorities, 554 n_links); 555 TEST_ASSERT(n_links == err, "Failed to link all queues" 556 " err %s\n", rte_strerror(rte_errno)); 557 } 558 559 err = rte_event_port_link(TEST_DEV_ID, ev_port, &ev_qid, NULL, 1); 560 TEST_ASSERT(err == 1, "Failed to link queue port %u", 561 ev_port); 562 563 err = rte_event_eth_tx_adapter_start(TEST_INST_ID); 564 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 565 566 if (!(dev_info.event_dev_cap & RTE_EVENT_DEV_CAP_DISTRIBUTED_SCHED)) { 567 err = rte_event_dev_service_id_get(0, (uint32_t *)&eid); 568 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 569 570 err = rte_service_runstate_set(eid, 1); 571 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 572 573 err = rte_service_set_runstate_mapped_check(eid, 0); 574 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 575 } 576 577 err = rte_event_eth_tx_adapter_service_id_get(TEST_INST_ID, &tid); 578 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 579 580 err = rte_service_runstate_set(tid, 1); 581 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 582 583 err = rte_service_set_runstate_mapped_check(tid, 0); 584 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 585 586 err = rte_event_dev_start(TEST_DEV_ID); 587 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 588 589 for (q = 0; q < MAX_NUM_QUEUE; q++) { 590 for (i = 0; i < RING_SIZE; i++) 591 pbufs[i] = &bufs[i]; 592 for (i = 0; i < RING_SIZE; i++) { 593 pbufs[i] = &bufs[i]; 594 err = tx_adapter_single(TEST_ETHDEV_ID, q, pbufs[i], 595 ev_qid, 596 RTE_SCHED_TYPE_ORDERED); 597 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 598 } 599 for (i = 0; i < RING_SIZE; i++) { 600 TEST_ASSERT_EQUAL(pbufs[i], &bufs[i], 601 "Error: received data does not match" 602 " that transmitted"); 603 } 604 } 605 606 err = rte_event_eth_tx_adapter_stats_get(TEST_INST_ID, NULL); 607 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 608 609 err = rte_event_eth_tx_adapter_stats_get(TEST_INST_ID, &stats); 610 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 611 TEST_ASSERT_EQUAL(stats.tx_packets, MAX_NUM_QUEUE * RING_SIZE, 612 "stats.tx_packets expected %u got %"PRIu64, 613 MAX_NUM_QUEUE * RING_SIZE, 614 stats.tx_packets); 615 616 err = rte_event_eth_tx_adapter_stats_reset(TEST_INST_ID); 617 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 618 619 err = rte_event_eth_tx_adapter_stats_get(TEST_INST_ID, &stats); 620 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 621 TEST_ASSERT_EQUAL(stats.tx_packets, 0, 622 "stats.tx_packets expected %u got %"PRIu64, 623 0, 624 stats.tx_packets); 625 626 err = rte_event_eth_tx_adapter_stats_get(1, &stats); 627 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 628 629 err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID, TEST_ETHDEV_ID, 630 -1); 631 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 632 633 err = rte_event_eth_tx_adapter_free(TEST_INST_ID); 634 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 635 636 rte_event_dev_stop(TEST_DEV_ID); 637 638 return TEST_SUCCESS; 639 } 640 641 static int 642 tx_adapter_dynamic_device(void) 643 { 644 uint16_t port_id = rte_eth_dev_count_avail(); 645 const char *null_dev[2] = { "eth_null0", "eth_null1" }; 646 struct rte_eth_conf dev_conf; 647 int ret; 648 size_t i; 649 650 memset(&dev_conf, 0, sizeof(dev_conf)); 651 for (i = 0; i < RTE_DIM(null_dev); i++) { 652 ret = rte_vdev_init(null_dev[i], NULL); 653 TEST_ASSERT_SUCCESS(ret, "%s Port creation failed %d", 654 null_dev[i], ret); 655 656 if (i == 0) { 657 ret = tx_adapter_create(); 658 TEST_ASSERT_SUCCESS(ret, "Adapter create failed %d", 659 ret); 660 } 661 662 ret = rte_eth_dev_configure(port_id + i, MAX_NUM_QUEUE, 663 MAX_NUM_QUEUE, &dev_conf); 664 TEST_ASSERT_SUCCESS(ret, "Failed to configure device %d", ret); 665 666 ret = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID, 667 port_id + i, 0); 668 TEST_ASSERT_SUCCESS(ret, "Failed to add queues %d", ret); 669 670 } 671 672 for (i = 0; i < RTE_DIM(null_dev); i++) { 673 ret = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID, 674 port_id + i, -1); 675 TEST_ASSERT_SUCCESS(ret, "Failed to delete queues %d", ret); 676 } 677 678 tx_adapter_free(); 679 680 for (i = 0; i < RTE_DIM(null_dev); i++) 681 rte_vdev_uninit(null_dev[i]); 682 683 return TEST_SUCCESS; 684 } 685 686 static struct unit_test_suite event_eth_tx_tests = { 687 .setup = testsuite_setup, 688 .teardown = testsuite_teardown, 689 .suite_name = "tx event eth adapter test suite", 690 .unit_test_cases = { 691 TEST_CASE_ST(NULL, NULL, tx_adapter_create_free), 692 TEST_CASE_ST(tx_adapter_create, tx_adapter_free, 693 tx_adapter_queue_add_del), 694 TEST_CASE_ST(tx_adapter_create, tx_adapter_free, 695 tx_adapter_start_stop), 696 TEST_CASE_ST(tx_adapter_create, tx_adapter_free, 697 tx_adapter_service), 698 TEST_CASE_ST(NULL, NULL, tx_adapter_dynamic_device), 699 TEST_CASES_END() /**< NULL terminate unit test array */ 700 } 701 }; 702 703 static int 704 test_event_eth_tx_adapter_common(void) 705 { 706 return unit_test_suite_runner(&event_eth_tx_tests); 707 } 708 709 #endif /* !RTE_EXEC_ENV_WINDOWS */ 710 711 REGISTER_TEST_COMMAND(event_eth_tx_adapter_autotest, 712 test_event_eth_tx_adapter_common); 713