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