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