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 TEST_ETH_QUEUE_ID 0 33 #define SOCKET0 0 34 #define RING_SIZE 256 35 #define ETH_NAME_LEN 32 36 #define NUM_ETH_PAIR 1 37 #define NUM_ETH_DEV (2 * NUM_ETH_PAIR) 38 #define NB_MBUF 512 39 #define PAIR_PORT_INDEX(p) ((p) + NUM_ETH_PAIR) 40 #define PORT(p) default_params.port[(p)] 41 #define TEST_ETHDEV_ID PORT(0) 42 #define TEST_ETHDEV_PAIR_ID PORT(PAIR_PORT_INDEX(0)) 43 #define DEFAULT_FLUSH_THRESHOLD 1024 44 #define TXA_NB_TX_WORK_DEFAULT 128 45 46 #define EDEV_RETRY 0xffff 47 48 struct event_eth_tx_adapter_test_params { 49 struct rte_mempool *mp; 50 uint16_t rx_rings, tx_rings; 51 struct rte_ring *r[NUM_ETH_DEV][MAX_NUM_QUEUE]; 52 int port[NUM_ETH_DEV]; 53 }; 54 55 static int event_dev_delete; 56 static struct event_eth_tx_adapter_test_params default_params; 57 static uint64_t eid = ~0ULL; 58 static uint32_t tid; 59 60 static inline int 61 port_init_common(uint16_t port, const struct rte_eth_conf *port_conf, 62 struct rte_mempool *mp) 63 { 64 const uint16_t rx_ring_size = RING_SIZE, tx_ring_size = RING_SIZE; 65 int retval; 66 uint16_t q; 67 68 if (!rte_eth_dev_is_valid_port(port)) 69 return -1; 70 71 default_params.rx_rings = MAX_NUM_QUEUE; 72 default_params.tx_rings = MAX_NUM_QUEUE; 73 74 /* Configure the Ethernet device. */ 75 retval = rte_eth_dev_configure(port, default_params.rx_rings, 76 default_params.tx_rings, port_conf); 77 if (retval != 0) 78 return retval; 79 80 for (q = 0; q < default_params.rx_rings; q++) { 81 retval = rte_eth_rx_queue_setup(port, q, rx_ring_size, 82 rte_eth_dev_socket_id(port), NULL, mp); 83 if (retval < 0) 84 return retval; 85 } 86 87 for (q = 0; q < default_params.tx_rings; q++) { 88 retval = rte_eth_tx_queue_setup(port, q, tx_ring_size, 89 rte_eth_dev_socket_id(port), NULL); 90 if (retval < 0) 91 return retval; 92 } 93 94 /* Start the Ethernet port. */ 95 retval = rte_eth_dev_start(port); 96 if (retval < 0) 97 return retval; 98 99 /* Display the port MAC address. */ 100 struct rte_ether_addr addr; 101 retval = rte_eth_macaddr_get(port, &addr); 102 if (retval < 0) 103 return retval; 104 printf("Port %u MAC: %02" PRIx8 " %02" PRIx8 " %02" PRIx8 105 " %02" PRIx8 " %02" PRIx8 " %02" PRIx8 "\n", 106 (unsigned int)port, RTE_ETHER_ADDR_BYTES(&addr)); 107 108 /* Enable RX in promiscuous mode for the Ethernet device. */ 109 retval = rte_eth_promiscuous_enable(port); 110 if (retval != 0) 111 return retval; 112 113 return 0; 114 } 115 116 static inline int 117 port_init(uint16_t port, struct rte_mempool *mp) 118 { 119 struct rte_eth_conf conf = { 0 }; 120 return port_init_common(port, &conf, mp); 121 } 122 123 #define RING_NAME_LEN 20 124 #define DEV_NAME_LEN 20 125 126 static int 127 init_ports(void) 128 { 129 char ring_name[ETH_NAME_LEN]; 130 unsigned int i, j; 131 struct rte_ring * const *c1; 132 struct rte_ring * const *c2; 133 int err; 134 135 if (!default_params.mp) 136 default_params.mp = rte_pktmbuf_pool_create("mbuf_pool", 137 NB_MBUF, 32, 138 0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id()); 139 140 if (!default_params.mp) 141 return -ENOMEM; 142 143 for (i = 0; i < NUM_ETH_DEV; i++) { 144 for (j = 0; j < MAX_NUM_QUEUE; j++) { 145 snprintf(ring_name, sizeof(ring_name), "R%u%u", i, j); 146 default_params.r[i][j] = rte_ring_create(ring_name, 147 RING_SIZE, 148 SOCKET0, 149 RING_F_SP_ENQ | RING_F_SC_DEQ); 150 TEST_ASSERT((default_params.r[i][j] != NULL), 151 "Failed to allocate ring"); 152 } 153 } 154 155 /* 156 * To create two pseudo-Ethernet ports where the traffic is 157 * switched between them, that is, traffic sent to port 1 is 158 * read back from port 2 and vice-versa 159 */ 160 for (i = 0; i < NUM_ETH_PAIR; i++) { 161 char dev_name[DEV_NAME_LEN]; 162 int p; 163 164 c1 = default_params.r[i]; 165 c2 = default_params.r[PAIR_PORT_INDEX(i)]; 166 167 snprintf(dev_name, DEV_NAME_LEN, "%u-%u", i, i + NUM_ETH_PAIR); 168 p = rte_eth_from_rings(dev_name, c1, MAX_NUM_QUEUE, 169 c2, MAX_NUM_QUEUE, SOCKET0); 170 TEST_ASSERT(p >= 0, "Port creation failed %s", dev_name); 171 err = port_init(p, default_params.mp); 172 TEST_ASSERT(err == 0, "Port init failed %s", dev_name); 173 default_params.port[i] = p; 174 175 snprintf(dev_name, DEV_NAME_LEN, "%u-%u", i + NUM_ETH_PAIR, i); 176 p = rte_eth_from_rings(dev_name, c2, MAX_NUM_QUEUE, 177 c1, MAX_NUM_QUEUE, SOCKET0); 178 TEST_ASSERT(p > 0, "Port creation failed %s", dev_name); 179 err = port_init(p, default_params.mp); 180 TEST_ASSERT(err == 0, "Port init failed %s", dev_name); 181 default_params.port[PAIR_PORT_INDEX(i)] = p; 182 } 183 184 return 0; 185 } 186 187 static void 188 deinit_ports(void) 189 { 190 uint16_t i, j; 191 char name[ETH_NAME_LEN]; 192 193 for (i = 0; i < RTE_DIM(default_params.port); i++) { 194 rte_eth_dev_stop(default_params.port[i]); 195 rte_eth_dev_get_name_by_port(default_params.port[i], name); 196 rte_vdev_uninit(name); 197 for (j = 0; j < RTE_DIM(default_params.r[i]); j++) 198 rte_ring_free(default_params.r[i][j]); 199 } 200 } 201 202 static int 203 testsuite_setup(void) 204 { 205 const char *vdev_name = "event_sw0"; 206 207 int err = init_ports(); 208 TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err); 209 210 if (rte_event_dev_count() == 0) { 211 printf("Failed to find a valid event device," 212 " testing with event_sw0 device\n"); 213 err = rte_vdev_init(vdev_name, NULL); 214 TEST_ASSERT(err == 0, "vdev %s creation failed %d\n", 215 vdev_name, err); 216 event_dev_delete = 1; 217 } 218 return err; 219 } 220 221 #define DEVICE_ID_SIZE 64 222 223 static void 224 testsuite_teardown(void) 225 { 226 deinit_ports(); 227 rte_mempool_free(default_params.mp); 228 default_params.mp = NULL; 229 if (event_dev_delete) 230 rte_vdev_uninit("event_sw0"); 231 } 232 233 static int 234 tx_adapter_create(void) 235 { 236 int err; 237 struct rte_event_dev_info dev_info; 238 struct rte_event_port_conf tx_p_conf; 239 uint8_t priority; 240 uint8_t queue_id; 241 242 struct rte_event_dev_config config = { 243 .nb_event_queues = 1, 244 .nb_event_ports = 1, 245 }; 246 247 struct rte_event_queue_conf wkr_q_conf = { 248 .schedule_type = RTE_SCHED_TYPE_ORDERED, 249 .priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 250 .nb_atomic_flows = 1024, 251 .nb_atomic_order_sequences = 1024, 252 }; 253 254 memset(&tx_p_conf, 0, sizeof(tx_p_conf)); 255 err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info); 256 config.nb_event_queue_flows = dev_info.max_event_queue_flows; 257 config.nb_event_port_dequeue_depth = 258 dev_info.max_event_port_dequeue_depth; 259 config.nb_event_port_enqueue_depth = 260 dev_info.max_event_port_enqueue_depth; 261 config.nb_events_limit = 262 dev_info.max_num_events; 263 264 err = rte_event_dev_configure(TEST_DEV_ID, &config); 265 TEST_ASSERT(err == 0, "Event device initialization failed err %d\n", 266 err); 267 268 queue_id = 0; 269 err = rte_event_queue_setup(TEST_DEV_ID, 0, &wkr_q_conf); 270 TEST_ASSERT(err == 0, "Event queue setup failed %d\n", err); 271 272 err = rte_event_port_setup(TEST_DEV_ID, 0, NULL); 273 TEST_ASSERT(err == 0, "Event port setup failed %d\n", err); 274 275 priority = RTE_EVENT_DEV_PRIORITY_LOWEST; 276 err = rte_event_port_link(TEST_DEV_ID, 0, &queue_id, &priority, 1); 277 TEST_ASSERT(err == 1, "Error linking port %s\n", 278 rte_strerror(rte_errno)); 279 err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info); 280 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 281 282 tx_p_conf.new_event_threshold = dev_info.max_num_events; 283 tx_p_conf.dequeue_depth = dev_info.max_event_port_dequeue_depth; 284 tx_p_conf.enqueue_depth = dev_info.max_event_port_enqueue_depth; 285 err = rte_event_eth_tx_adapter_create(TEST_INST_ID, TEST_DEV_ID, 286 &tx_p_conf); 287 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 288 289 return err; 290 } 291 292 static void 293 tx_adapter_free(void) 294 { 295 rte_event_eth_tx_adapter_free(TEST_INST_ID); 296 } 297 298 static int 299 tx_adapter_create_free(void) 300 { 301 int err; 302 struct rte_event_dev_info dev_info; 303 struct rte_event_port_conf tx_p_conf; 304 305 err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info); 306 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 307 308 tx_p_conf.new_event_threshold = dev_info.max_num_events; 309 tx_p_conf.dequeue_depth = dev_info.max_event_port_dequeue_depth; 310 tx_p_conf.enqueue_depth = dev_info.max_event_port_enqueue_depth; 311 312 err = rte_event_eth_tx_adapter_create(TEST_INST_ID, TEST_DEV_ID, 313 NULL); 314 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 315 316 err = rte_event_eth_tx_adapter_create(TEST_INST_ID, TEST_DEV_ID, 317 &tx_p_conf); 318 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 319 320 err = rte_event_eth_tx_adapter_create(TEST_INST_ID, 321 TEST_DEV_ID, &tx_p_conf); 322 TEST_ASSERT(err == -EEXIST, "Expected -EEXIST %d got %d", -EEXIST, err); 323 324 err = rte_event_eth_tx_adapter_free(TEST_INST_ID); 325 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 326 327 err = rte_event_eth_tx_adapter_free(TEST_INST_ID); 328 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err); 329 330 err = rte_event_eth_tx_adapter_free(1); 331 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err); 332 333 return TEST_SUCCESS; 334 } 335 336 static int 337 tx_adapter_queue_add_del(void) 338 { 339 int err; 340 uint32_t cap; 341 342 err = rte_event_eth_tx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID, 343 &cap); 344 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 345 346 347 err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID, 348 rte_eth_dev_count_total(), 349 -1); 350 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 351 352 err = rte_event_eth_tx_adapter_queue_add(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_add(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 0); 365 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 366 367 err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID, 368 TEST_ETHDEV_ID, 369 -1); 370 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 371 372 err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID, 373 TEST_ETHDEV_ID, 374 -1); 375 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 376 377 err = rte_event_eth_tx_adapter_queue_add(1, TEST_ETHDEV_ID, -1); 378 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 379 380 err = rte_event_eth_tx_adapter_queue_del(1, TEST_ETHDEV_ID, -1); 381 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 382 383 return TEST_SUCCESS; 384 } 385 386 static int 387 tx_adapter_start_stop(void) 388 { 389 int err; 390 391 err = rte_event_eth_tx_adapter_queue_add(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_queue_del(TEST_INST_ID, TEST_ETHDEV_ID, 402 -1); 403 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 404 405 err = rte_event_eth_tx_adapter_start(TEST_INST_ID); 406 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 407 408 err = rte_event_eth_tx_adapter_stop(TEST_INST_ID); 409 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 410 411 err = rte_event_eth_tx_adapter_start(1); 412 413 err = rte_event_eth_tx_adapter_stop(1); 414 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 415 416 return TEST_SUCCESS; 417 } 418 419 420 static int 421 tx_adapter_single(uint16_t port, uint16_t tx_queue_id, 422 struct rte_mbuf *m, uint8_t qid, 423 uint8_t sched_type) 424 { 425 struct rte_event event; 426 struct rte_mbuf *r; 427 int ret; 428 unsigned int l; 429 430 event.queue_id = qid; 431 event.op = RTE_EVENT_OP_NEW; 432 event.event_type = RTE_EVENT_TYPE_CPU; 433 event.sched_type = sched_type; 434 event.mbuf = m; 435 436 m->port = port; 437 rte_event_eth_tx_adapter_txq_set(m, tx_queue_id); 438 439 l = 0; 440 while (rte_event_enqueue_burst(TEST_DEV_ID, 0, &event, 1) != 1) { 441 l++; 442 if (l > EDEV_RETRY) 443 break; 444 } 445 446 TEST_ASSERT(l < EDEV_RETRY, "Unable to enqueue to eventdev"); 447 l = 0; 448 while (l++ < EDEV_RETRY) { 449 450 if (eid != ~0ULL) { 451 ret = rte_service_run_iter_on_app_lcore(eid, 0); 452 TEST_ASSERT(ret == 0, "failed to run service %d", ret); 453 } 454 455 ret = rte_service_run_iter_on_app_lcore(tid, 0); 456 TEST_ASSERT(ret == 0, "failed to run service %d", ret); 457 458 if (rte_eth_rx_burst(TEST_ETHDEV_PAIR_ID, tx_queue_id, 459 &r, 1)) { 460 TEST_ASSERT_EQUAL(r, m, "mbuf comparison failed" 461 " expected %p received %p", m, r); 462 return 0; 463 } 464 } 465 466 TEST_ASSERT(0, "Failed to receive packet"); 467 return -1; 468 } 469 470 static int 471 tx_adapter_service(void) 472 { 473 struct rte_event_eth_tx_adapter_stats stats; 474 uint32_t i; 475 int err; 476 uint8_t ev_port, ev_qid; 477 struct rte_mbuf bufs[RING_SIZE]; 478 struct rte_mbuf *pbufs[RING_SIZE]; 479 struct rte_event_dev_info dev_info; 480 struct rte_event_dev_config dev_conf; 481 struct rte_event_queue_conf qconf; 482 uint32_t qcnt, pcnt; 483 uint16_t q; 484 int internal_port; 485 uint32_t cap; 486 487 memset(&dev_conf, 0, sizeof(dev_conf)); 488 err = rte_event_eth_tx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID, 489 &cap); 490 TEST_ASSERT(err == 0, "Failed to get adapter cap err %d\n", err); 491 492 internal_port = !!(cap & RTE_EVENT_ETH_TX_ADAPTER_CAP_INTERNAL_PORT); 493 if (internal_port) 494 return TEST_SUCCESS; 495 496 err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID, TEST_ETHDEV_ID, 497 -1); 498 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 499 500 err = rte_event_eth_tx_adapter_event_port_get(TEST_INST_ID, 501 &ev_port); 502 TEST_ASSERT_SUCCESS(err, "Failed to get event port %d", err); 503 504 err = rte_event_dev_attr_get(TEST_DEV_ID, RTE_EVENT_DEV_ATTR_PORT_COUNT, 505 &pcnt); 506 TEST_ASSERT_SUCCESS(err, "Port count get failed"); 507 508 err = rte_event_dev_attr_get(TEST_DEV_ID, 509 RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &qcnt); 510 TEST_ASSERT_SUCCESS(err, "Queue count get failed"); 511 512 err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info); 513 TEST_ASSERT_SUCCESS(err, "Dev info failed"); 514 515 dev_conf.nb_event_queue_flows = dev_info.max_event_queue_flows; 516 dev_conf.nb_event_port_dequeue_depth = 517 dev_info.max_event_port_dequeue_depth; 518 dev_conf.nb_event_port_enqueue_depth = 519 dev_info.max_event_port_enqueue_depth; 520 dev_conf.nb_events_limit = 521 dev_info.max_num_events; 522 dev_conf.nb_event_queues = qcnt + 1; 523 dev_conf.nb_event_ports = pcnt; 524 err = rte_event_dev_configure(TEST_DEV_ID, &dev_conf); 525 TEST_ASSERT(err == 0, "Event device initialization failed err %d\n", 526 err); 527 528 ev_qid = qcnt; 529 qconf.nb_atomic_flows = dev_info.max_event_queue_flows; 530 qconf.nb_atomic_order_sequences = 32; 531 qconf.schedule_type = RTE_SCHED_TYPE_ATOMIC; 532 qconf.priority = RTE_EVENT_DEV_PRIORITY_HIGHEST; 533 qconf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_SINGLE_LINK; 534 err = rte_event_queue_setup(TEST_DEV_ID, ev_qid, &qconf); 535 TEST_ASSERT_SUCCESS(err, "Failed to setup queue %u", ev_qid); 536 537 /* 538 * Setup ports again so that the newly added queue is visible 539 * to them 540 */ 541 for (i = 0; i < pcnt; i++) { 542 543 int n_links; 544 uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV]; 545 uint8_t priorities[RTE_EVENT_MAX_QUEUES_PER_DEV]; 546 547 if (i == ev_port) 548 continue; 549 550 n_links = rte_event_port_links_get(TEST_DEV_ID, i, queues, 551 priorities); 552 TEST_ASSERT(n_links > 0, "Failed to get port links %d\n", 553 n_links); 554 err = rte_event_port_setup(TEST_DEV_ID, i, NULL); 555 TEST_ASSERT(err == 0, "Failed to setup port err %d\n", err); 556 err = rte_event_port_link(TEST_DEV_ID, i, queues, priorities, 557 n_links); 558 TEST_ASSERT(n_links == err, "Failed to link all queues" 559 " err %s\n", rte_strerror(rte_errno)); 560 } 561 562 err = rte_event_port_link(TEST_DEV_ID, ev_port, &ev_qid, NULL, 1); 563 TEST_ASSERT(err == 1, "Failed to link queue port %u", 564 ev_port); 565 566 err = rte_event_eth_tx_adapter_start(TEST_INST_ID); 567 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 568 569 if (!(dev_info.event_dev_cap & RTE_EVENT_DEV_CAP_DISTRIBUTED_SCHED)) { 570 err = rte_event_dev_service_id_get(0, (uint32_t *)&eid); 571 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 572 573 err = rte_service_runstate_set(eid, 1); 574 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 575 576 err = rte_service_set_runstate_mapped_check(eid, 0); 577 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 578 } 579 580 err = rte_event_eth_tx_adapter_service_id_get(TEST_INST_ID, &tid); 581 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 582 583 err = rte_service_runstate_set(tid, 1); 584 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 585 586 err = rte_service_set_runstate_mapped_check(tid, 0); 587 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 588 589 err = rte_event_dev_start(TEST_DEV_ID); 590 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 591 592 for (q = 0; q < MAX_NUM_QUEUE; q++) { 593 for (i = 0; i < RING_SIZE; i++) 594 pbufs[i] = &bufs[i]; 595 for (i = 0; i < RING_SIZE; i++) { 596 pbufs[i] = &bufs[i]; 597 err = tx_adapter_single(TEST_ETHDEV_ID, q, pbufs[i], 598 ev_qid, 599 RTE_SCHED_TYPE_ORDERED); 600 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 601 } 602 for (i = 0; i < RING_SIZE; i++) { 603 TEST_ASSERT_EQUAL(pbufs[i], &bufs[i], 604 "Error: received data does not match" 605 " that transmitted"); 606 } 607 } 608 609 err = rte_event_eth_tx_adapter_stats_get(TEST_INST_ID, NULL); 610 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL 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, MAX_NUM_QUEUE * RING_SIZE, 615 "stats.tx_packets expected %u got %"PRIu64, 616 MAX_NUM_QUEUE * RING_SIZE, 617 stats.tx_packets); 618 619 err = rte_event_eth_tx_adapter_stats_reset(TEST_INST_ID); 620 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 621 622 err = rte_event_eth_tx_adapter_stats_get(TEST_INST_ID, &stats); 623 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 624 TEST_ASSERT_EQUAL(stats.tx_packets, 0, 625 "stats.tx_packets expected %u got %"PRIu64, 626 0, 627 stats.tx_packets); 628 629 err = rte_event_eth_tx_adapter_stats_get(1, &stats); 630 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 631 632 err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID, TEST_ETHDEV_ID, 633 -1); 634 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 635 636 err = rte_event_eth_tx_adapter_free(TEST_INST_ID); 637 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 638 639 rte_event_dev_stop(TEST_DEV_ID); 640 641 return TEST_SUCCESS; 642 } 643 644 static int 645 tx_adapter_instance_get(void) 646 { 647 int err; 648 uint8_t inst_id; 649 uint16_t eth_dev_id; 650 struct rte_eth_dev_info dev_info; 651 652 /* Case 1: Test without configuring eth */ 653 err = rte_event_eth_tx_adapter_instance_get(TEST_ETHDEV_ID, 654 TEST_ETH_QUEUE_ID, 655 &inst_id); 656 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 657 658 /* Case 2: Test with wrong eth port */ 659 eth_dev_id = rte_eth_dev_count_total() + 1; 660 err = rte_event_eth_tx_adapter_instance_get(eth_dev_id, 661 TEST_ETH_QUEUE_ID, 662 &inst_id); 663 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 664 665 /* Case 3: Test with wrong tx queue */ 666 err = rte_eth_dev_info_get(TEST_ETHDEV_ID, &dev_info); 667 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 668 669 err = rte_event_eth_tx_adapter_instance_get(TEST_ETHDEV_ID, 670 dev_info.max_tx_queues + 1, 671 &inst_id); 672 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 673 674 /* Case 4: Test with right instance, port & rxq */ 675 /* Add queue to tx adapter */ 676 err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID, 677 TEST_ETHDEV_ID, 678 TEST_ETH_QUEUE_ID); 679 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 680 681 err = rte_event_eth_tx_adapter_instance_get(TEST_ETHDEV_ID, 682 TEST_ETH_QUEUE_ID, 683 &inst_id); 684 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 685 TEST_ASSERT(inst_id == TEST_INST_ID, "Expected %d got %d", 686 TEST_INST_ID, err); 687 688 /* Add another queue to tx adapter */ 689 err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID, 690 TEST_ETHDEV_ID, 691 TEST_ETH_QUEUE_ID + 1); 692 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 693 694 err = rte_event_eth_tx_adapter_instance_get(TEST_ETHDEV_ID, 695 TEST_ETH_QUEUE_ID + 1, 696 &inst_id); 697 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 698 TEST_ASSERT(inst_id == TEST_INST_ID, "Expected %d got %d", 699 TEST_INST_ID, err); 700 701 /* Case 5: Test with right instance, port & wrong rxq */ 702 err = rte_event_eth_tx_adapter_instance_get(TEST_ETHDEV_ID, 703 TEST_ETH_QUEUE_ID + 2, 704 &inst_id); 705 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 706 707 /* Delete all queues from the Tx adapter */ 708 err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID, 709 TEST_ETHDEV_ID, 710 -1); 711 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 712 713 return TEST_SUCCESS; 714 } 715 716 static int 717 tx_adapter_queue_start_stop(void) 718 { 719 int err; 720 uint16_t eth_dev_id; 721 struct rte_eth_dev_info dev_info; 722 723 /* Case 1: Test without adding eth Tx queue */ 724 err = rte_event_eth_tx_adapter_queue_start(TEST_ETHDEV_ID, 725 TEST_ETH_QUEUE_ID); 726 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 727 728 err = rte_event_eth_tx_adapter_queue_stop(TEST_ETHDEV_ID, 729 TEST_ETH_QUEUE_ID); 730 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 731 732 /* Case 2: Test with wrong eth port */ 733 eth_dev_id = rte_eth_dev_count_total() + 1; 734 err = rte_event_eth_tx_adapter_queue_start(eth_dev_id, 735 TEST_ETH_QUEUE_ID); 736 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 737 738 err = rte_event_eth_tx_adapter_queue_stop(eth_dev_id, 739 TEST_ETH_QUEUE_ID); 740 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 741 742 /* Case 3: Test with wrong tx queue */ 743 err = rte_eth_dev_info_get(TEST_ETHDEV_ID, &dev_info); 744 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 745 746 err = rte_event_eth_tx_adapter_queue_start(TEST_ETHDEV_ID, 747 dev_info.max_tx_queues + 1); 748 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 749 750 err = rte_event_eth_tx_adapter_queue_stop(TEST_ETHDEV_ID, 751 dev_info.max_tx_queues + 1); 752 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 753 754 /* Case 4: Test with right instance, port & rxq */ 755 /* Add queue to tx adapter */ 756 err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID, 757 TEST_ETHDEV_ID, 758 TEST_ETH_QUEUE_ID); 759 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 760 761 err = rte_event_eth_tx_adapter_queue_stop(TEST_ETHDEV_ID, 762 TEST_ETH_QUEUE_ID); 763 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 764 765 err = rte_event_eth_tx_adapter_queue_start(TEST_ETHDEV_ID, 766 TEST_ETH_QUEUE_ID); 767 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 768 769 /* Add another queue to tx adapter */ 770 err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID, 771 TEST_ETHDEV_ID, 772 TEST_ETH_QUEUE_ID + 1); 773 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 774 775 err = rte_event_eth_tx_adapter_queue_stop(TEST_ETHDEV_ID, 776 TEST_ETH_QUEUE_ID + 1); 777 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 778 err = rte_event_eth_tx_adapter_queue_start(TEST_ETHDEV_ID, 779 TEST_ETH_QUEUE_ID + 1); 780 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 781 782 /* Case 5: Test with right instance, port & wrong rxq */ 783 err = rte_event_eth_tx_adapter_queue_stop(TEST_ETHDEV_ID, 784 TEST_ETH_QUEUE_ID + 2); 785 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 786 787 err = rte_event_eth_tx_adapter_queue_start(TEST_ETHDEV_ID, 788 TEST_ETH_QUEUE_ID + 2); 789 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); 790 791 /* Delete all queues from the Tx adapter */ 792 err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID, 793 TEST_ETHDEV_ID, 794 -1); 795 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 796 797 return TEST_SUCCESS; 798 } 799 800 static int 801 tx_adapter_set_get_params(void) 802 { 803 int err, rc; 804 struct rte_event_eth_tx_adapter_runtime_params in_params; 805 struct rte_event_eth_tx_adapter_runtime_params out_params; 806 807 err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID, 808 TEST_ETHDEV_ID, 809 0); 810 if (err == -ENOTSUP) { 811 rc = TEST_SKIPPED; 812 goto skip; 813 } 814 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 815 816 err = rte_event_eth_tx_adapter_runtime_params_init(&in_params); 817 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 818 err = rte_event_eth_tx_adapter_runtime_params_init(&out_params); 819 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 820 821 /* Case 1: Get the default values of adapter */ 822 err = rte_event_eth_tx_adapter_runtime_params_get(TEST_INST_ID, 823 &out_params); 824 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 825 TEST_ASSERT(out_params.flush_threshold == DEFAULT_FLUSH_THRESHOLD, 826 "Expected %u got %u", 827 DEFAULT_FLUSH_THRESHOLD, out_params.flush_threshold); 828 TEST_ASSERT(out_params.max_nb_tx == TXA_NB_TX_WORK_DEFAULT, 829 "Expected %u got %u", 830 TXA_NB_TX_WORK_DEFAULT, out_params.max_nb_tx); 831 832 /* Case 2: Set max_nb_tx = 32 (=TXA_BATCH_SEIZE) */ 833 in_params.max_nb_tx = 32; 834 in_params.flush_threshold = DEFAULT_FLUSH_THRESHOLD; 835 836 err = rte_event_eth_tx_adapter_runtime_params_set(TEST_INST_ID, 837 &in_params); 838 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 839 840 err = rte_event_eth_tx_adapter_runtime_params_get(TEST_INST_ID, 841 &out_params); 842 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 843 TEST_ASSERT(in_params.max_nb_tx == out_params.max_nb_tx, 844 "Expected %u got %u", 845 in_params.max_nb_tx, out_params.max_nb_tx); 846 TEST_ASSERT(in_params.flush_threshold == out_params.flush_threshold, 847 "Expected %u got %u", 848 in_params.flush_threshold, out_params.flush_threshold); 849 850 /* Case 3: Set max_nb_tx = 192 */ 851 in_params.max_nb_tx = 192; 852 853 err = rte_event_eth_tx_adapter_runtime_params_set(TEST_INST_ID, 854 &in_params); 855 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 856 857 err = rte_event_eth_tx_adapter_runtime_params_get(TEST_INST_ID, 858 &out_params); 859 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 860 TEST_ASSERT(in_params.max_nb_tx == out_params.max_nb_tx, 861 "Expected %u got %u", 862 in_params.max_nb_tx, out_params.max_nb_tx); 863 864 /* Case 4: Set max_nb_tx = 256 */ 865 in_params.max_nb_tx = 256; 866 867 err = rte_event_eth_tx_adapter_runtime_params_set(TEST_INST_ID, 868 &in_params); 869 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 870 871 err = rte_event_eth_tx_adapter_runtime_params_get(TEST_INST_ID, 872 &out_params); 873 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 874 TEST_ASSERT(in_params.max_nb_tx == out_params.max_nb_tx, 875 "Expected %u got %u", 876 in_params.max_nb_tx, out_params.max_nb_tx); 877 878 /* Case 5: Set max_nb_tx = 30(<TXA_BATCH_SIZE) */ 879 in_params.max_nb_tx = 30; 880 881 err = rte_event_eth_tx_adapter_runtime_params_set(TEST_INST_ID, 882 &in_params); 883 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 884 885 err = rte_event_eth_tx_adapter_runtime_params_get(TEST_INST_ID, 886 &out_params); 887 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 888 TEST_ASSERT(in_params.max_nb_tx == out_params.max_nb_tx, 889 "Expected %u got %u", 890 in_params.max_nb_tx, out_params.max_nb_tx); 891 892 /* Case 6: Set max_nb_tx = 512 */ 893 in_params.max_nb_tx = 512; 894 895 err = rte_event_eth_tx_adapter_runtime_params_set(TEST_INST_ID, 896 &in_params); 897 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 898 899 err = rte_event_eth_tx_adapter_runtime_params_get(TEST_INST_ID, 900 &out_params); 901 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 902 TEST_ASSERT(in_params.max_nb_tx == out_params.max_nb_tx, 903 "Expected %u got %u", 904 in_params.max_nb_tx, out_params.max_nb_tx); 905 906 /* Case 7: Set flush_threshold = 10 */ 907 in_params.max_nb_tx = 128; 908 in_params.flush_threshold = 10; 909 910 err = rte_event_eth_tx_adapter_runtime_params_set(TEST_INST_ID, 911 &in_params); 912 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 913 914 err = rte_event_eth_tx_adapter_runtime_params_get(TEST_INST_ID, 915 &out_params); 916 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 917 TEST_ASSERT(in_params.max_nb_tx == out_params.max_nb_tx, 918 "Expected %u got %u", 919 in_params.max_nb_tx, out_params.max_nb_tx); 920 TEST_ASSERT(in_params.flush_threshold == out_params.flush_threshold, 921 "Expected %u got %u", 922 in_params.flush_threshold, out_params.flush_threshold); 923 rc = TEST_SUCCESS; 924 skip: 925 err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID, 926 TEST_ETHDEV_ID, 927 0); 928 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 929 930 return rc; 931 } 932 933 static int 934 tx_adapter_dynamic_device(void) 935 { 936 uint16_t port_id = rte_eth_dev_count_avail(); 937 const char *null_dev[2] = { "eth_null0", "eth_null1" }; 938 struct rte_eth_conf dev_conf; 939 int ret; 940 size_t i; 941 942 memset(&dev_conf, 0, sizeof(dev_conf)); 943 for (i = 0; i < RTE_DIM(null_dev); i++) { 944 ret = rte_vdev_init(null_dev[i], NULL); 945 TEST_ASSERT_SUCCESS(ret, "%s Port creation failed %d", 946 null_dev[i], ret); 947 948 if (i == 0) { 949 ret = tx_adapter_create(); 950 TEST_ASSERT_SUCCESS(ret, "Adapter create failed %d", 951 ret); 952 } 953 954 ret = rte_eth_dev_configure(port_id + i, MAX_NUM_QUEUE, 955 MAX_NUM_QUEUE, &dev_conf); 956 TEST_ASSERT_SUCCESS(ret, "Failed to configure device %d", ret); 957 958 ret = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID, 959 port_id + i, 0); 960 TEST_ASSERT_SUCCESS(ret, "Failed to add queues %d", ret); 961 962 } 963 964 for (i = 0; i < RTE_DIM(null_dev); i++) { 965 ret = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID, 966 port_id + i, -1); 967 TEST_ASSERT_SUCCESS(ret, "Failed to delete queues %d", ret); 968 } 969 970 tx_adapter_free(); 971 972 for (i = 0; i < RTE_DIM(null_dev); i++) 973 rte_vdev_uninit(null_dev[i]); 974 975 return TEST_SUCCESS; 976 } 977 978 static struct unit_test_suite event_eth_tx_tests = { 979 .setup = testsuite_setup, 980 .teardown = testsuite_teardown, 981 .suite_name = "tx event eth adapter test suite", 982 .unit_test_cases = { 983 TEST_CASE_ST(NULL, NULL, tx_adapter_create_free), 984 TEST_CASE_ST(tx_adapter_create, tx_adapter_free, 985 tx_adapter_queue_add_del), 986 TEST_CASE_ST(tx_adapter_create, tx_adapter_free, 987 tx_adapter_start_stop), 988 TEST_CASE_ST(tx_adapter_create, tx_adapter_free, 989 tx_adapter_service), 990 TEST_CASE_ST(tx_adapter_create, tx_adapter_free, 991 tx_adapter_instance_get), 992 TEST_CASE_ST(tx_adapter_create, tx_adapter_free, 993 tx_adapter_queue_start_stop), 994 TEST_CASE_ST(tx_adapter_create, tx_adapter_free, 995 tx_adapter_set_get_params), 996 TEST_CASE_ST(NULL, NULL, tx_adapter_dynamic_device), 997 TEST_CASES_END() /**< NULL terminate unit test array */ 998 } 999 }; 1000 1001 static int 1002 test_event_eth_tx_adapter_common(void) 1003 { 1004 return unit_test_suite_runner(&event_eth_tx_tests); 1005 } 1006 1007 #endif /* !RTE_EXEC_ENV_WINDOWS */ 1008 1009 REGISTER_FAST_TEST(event_eth_tx_adapter_autotest, false, true, test_event_eth_tx_adapter_common); 1010