app/test/test_event_eth_tx_adapter.c

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