app/test/test_event_eth_rx_adapter.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2017 Intel Corporation
   3  */
   4 #include <string.h>
   5 #include <rte_common.h>
   6 #include <rte_mempool.h>
   7 #include <rte_mbuf.h>
   8 #include <rte_ethdev.h>
   9 #include <rte_eventdev.h>
  10 #include <rte_bus_vdev.h>
  11
  12 #include <rte_event_eth_rx_adapter.h>
  13
  14 #include "test.h"
  15
  16 #define MAX_NUM_RX_QUEUE        64
  17 #define NB_MBUFS                (8192 * num_ports * MAX_NUM_RX_QUEUE)
  18 #define MBUF_CACHE_SIZE         512
  19 #define MBUF_PRIV_SIZE          0
  20 #define TEST_INST_ID            0
  21 #define TEST_DEV_ID             0
  22 #define TEST_ETHDEV_ID          0
  23
  24 struct event_eth_rx_adapter_test_params {
  25         struct rte_mempool *mp;
  26         uint16_t rx_rings, tx_rings;
  27         uint32_t caps;
  28         int rx_intr_port_inited;
  29         uint16_t rx_intr_port;
  30 };
  31
  32 static struct event_eth_rx_adapter_test_params default_params;
  33 static bool event_dev_created;
  34 static bool eth_dev_created;
  35
  36 static inline int
  37 port_init_common(uint16_t port, const struct rte_eth_conf *port_conf,
  38                 struct rte_mempool *mp)
  39 {
  40         const uint16_t rx_ring_size = 512, tx_ring_size = 512;
  41         int retval;
  42         uint16_t q;
  43         struct rte_eth_dev_info dev_info;
  44
  45         if (!rte_eth_dev_is_valid_port(port))
  46                 return -1;
  47
  48         retval = rte_eth_dev_configure(port, 0, 0, port_conf);
  49
  50         retval = rte_eth_dev_info_get(port, &dev_info);
  51         if (retval != 0)
  52                 return retval;
  53
  54         default_params.rx_rings = RTE_MIN(dev_info.max_rx_queues,
  55                                         MAX_NUM_RX_QUEUE);
  56         default_params.tx_rings = 1;
  57
  58         /* Configure the Ethernet device. */
  59         retval = rte_eth_dev_configure(port, default_params.rx_rings,
  60                                 default_params.tx_rings, port_conf);
  61         if (retval != 0)
  62                 return retval;
  63
  64         for (q = 0; q < default_params.rx_rings; q++) {
  65                 retval = rte_eth_rx_queue_setup(port, q, rx_ring_size,
  66                                 rte_eth_dev_socket_id(port), NULL, mp);
  67                 if (retval < 0)
  68                         return retval;
  69         }
  70
  71         /* Allocate and set up 1 TX queue per Ethernet port. */
  72         for (q = 0; q < default_params.tx_rings; q++) {
  73                 retval = rte_eth_tx_queue_setup(port, q, tx_ring_size,
  74                                 rte_eth_dev_socket_id(port), NULL);
  75                 if (retval < 0)
  76                         return retval;
  77         }
  78
  79         /* Start the Ethernet port. */
  80         retval = rte_eth_dev_start(port);
  81         if (retval < 0)
  82                 return retval;
  83
  84         /* Display the port MAC address. */
  85         struct rte_ether_addr addr;
  86         retval = rte_eth_macaddr_get(port, &addr);
  87         if (retval < 0)
  88                 return retval;
  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_rx_intr(uint16_t port, struct rte_mempool *mp)
 106 {
 107         static const struct rte_eth_conf port_conf_default = {
 108                 .rxmode = {
 109                         .mq_mode = ETH_MQ_RX_NONE,
 110                 },
 111                 .intr_conf = {
 112                         .rxq = 1,
 113                 },
 114         };
 115
 116         return port_init_common(port, &port_conf_default, mp);
 117 }
 118
 119 static inline int
 120 port_init(uint16_t port, struct rte_mempool *mp)
 121 {
 122         static const struct rte_eth_conf port_conf_default = {
 123                 .rxmode = {
 124                         .mq_mode = ETH_MQ_RX_NONE,
 125                 },
 126         };
 127
 128         return port_init_common(port, &port_conf_default, mp);
 129 }
 130
 131 static int
 132 init_port_rx_intr(int num_ports)
 133 {
 134         int retval;
 135         uint16_t portid;
 136         int err;
 137
 138         default_params.mp = rte_pktmbuf_pool_create("packet_pool",
 139                                                    NB_MBUFS,
 140                                                    MBUF_CACHE_SIZE,
 141                                                    MBUF_PRIV_SIZE,
 142                                                    RTE_MBUF_DEFAULT_BUF_SIZE,
 143                                                    rte_socket_id());
 144         if (!default_params.mp)
 145                 return -ENOMEM;
 146
 147         RTE_ETH_FOREACH_DEV(portid) {
 148                 retval = port_init_rx_intr(portid, default_params.mp);
 149                 if (retval)
 150                         continue;
 151                 err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, portid,
 152                                                         &default_params.caps);
 153                 if (err)
 154                         continue;
 155                 if (!(default_params.caps &
 156                         RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT)) {
 157                         default_params.rx_intr_port_inited = 1;
 158                         default_params.rx_intr_port = portid;
 159                         return 0;
 160                 }
 161                 rte_eth_dev_stop(portid);
 162         }
 163         return 0;
 164 }
 165
 166 static int
 167 init_ports(int num_ports)
 168 {
 169         uint16_t portid;
 170         int retval;
 171
 172         struct rte_mempool *ptr = rte_mempool_lookup("packet_pool");
 173
 174         if (ptr == NULL)
 175                 default_params.mp = rte_pktmbuf_pool_create("packet_pool",
 176                                                 NB_MBUFS,
 177                                                 MBUF_CACHE_SIZE,
 178                                                 MBUF_PRIV_SIZE,
 179                                                 RTE_MBUF_DEFAULT_BUF_SIZE,
 180                                                 rte_socket_id());
 181         else
 182                 default_params.mp = ptr;
 183
 184         if (!default_params.mp)
 185                 return -ENOMEM;
 186
 187         RTE_ETH_FOREACH_DEV(portid) {
 188                 retval = port_init(portid, default_params.mp);
 189                 if (retval)
 190                         return retval;
 191         }
 192
 193         return 0;
 194 }
 195
 196 static int
 197 testsuite_setup(void)
 198 {
 199         int err;
 200         uint8_t count;
 201         struct rte_event_dev_info dev_info;
 202
 203         count = rte_event_dev_count();
 204         if (!count) {
 205                 printf("Failed to find a valid event device,"
 206                         " testing with event_skeleton device\n");
 207                 err = rte_vdev_init("event_skeleton", NULL);
 208                 TEST_ASSERT(err == 0, "Failed to create event_skeleton. err=%d",
 209                             err);
 210                 event_dev_created = true;
 211         }
 212
 213         struct rte_event_dev_config config = {
 214                         .nb_event_queues = 1,
 215                         .nb_event_ports = 1,
 216         };
 217
 218         err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
 219         config.nb_event_queue_flows = dev_info.max_event_queue_flows;
 220         config.nb_event_port_dequeue_depth =
 221                         dev_info.max_event_port_dequeue_depth;
 222         config.nb_event_port_enqueue_depth =
 223                         dev_info.max_event_port_enqueue_depth;
 224         config.nb_events_limit =
 225                         dev_info.max_num_events;
 226         err = rte_event_dev_configure(TEST_DEV_ID, &config);
 227         TEST_ASSERT(err == 0, "Event device initialization failed err %d\n",
 228                         err);
 229
 230         count = rte_eth_dev_count_total();
 231         if (!count) {
 232                 printf("Testing with net_null device\n");
 233                 err = rte_vdev_init("net_null", NULL);
 234                 TEST_ASSERT(err == 0, "Failed to create net_null. err=%d",
 235                             err);
 236                 eth_dev_created = true;
 237         }
 238
 239         /*
 240          * eth devices like octeontx use event device to receive packets
 241          * so rte_eth_dev_start invokes rte_event_dev_start internally, so
 242          * call init_ports after rte_event_dev_configure
 243          */
 244         err = init_ports(rte_eth_dev_count_total());
 245         TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err);
 246
 247         err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID,
 248                                                 &default_params.caps);
 249         TEST_ASSERT(err == 0, "Failed to get adapter cap err %d\n",
 250                         err);
 251
 252         return err;
 253 }
 254
 255 static int
 256 testsuite_setup_rx_intr(void)
 257 {
 258         int err;
 259         uint8_t count;
 260         struct rte_event_dev_info dev_info;
 261
 262         count = rte_event_dev_count();
 263         if (!count) {
 264                 printf("Failed to find a valid event device,"
 265                         " testing with event_skeleton device\n");
 266                 err = rte_vdev_init("event_skeleton", NULL);
 267                 TEST_ASSERT(err == 0, "Failed to create event_skeleton. err=%d",
 268                             err);
 269                 event_dev_created = true;
 270         }
 271
 272         struct rte_event_dev_config config = {
 273                 .nb_event_queues = 1,
 274                 .nb_event_ports = 1,
 275         };
 276
 277         err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
 278         config.nb_event_queue_flows = dev_info.max_event_queue_flows;
 279         config.nb_event_port_dequeue_depth =
 280                         dev_info.max_event_port_dequeue_depth;
 281         config.nb_event_port_enqueue_depth =
 282                         dev_info.max_event_port_enqueue_depth;
 283         config.nb_events_limit =
 284                         dev_info.max_num_events;
 285
 286         err = rte_event_dev_configure(TEST_DEV_ID, &config);
 287         TEST_ASSERT(err == 0, "Event device initialization failed err %d\n",
 288                         err);
 289
 290         count = rte_eth_dev_count_total();
 291         if (!count) {
 292                 printf("Testing with net_null device\n");
 293                 err = rte_vdev_init("net_null", NULL);
 294                 TEST_ASSERT(err == 0, "Failed to create net_null. err=%d",
 295                             err);
 296                 eth_dev_created = true;
 297         }
 298
 299         /*
 300          * eth devices like octeontx use event device to receive packets
 301          * so rte_eth_dev_start invokes rte_event_dev_start internally, so
 302          * call init_ports after rte_event_dev_configure
 303          */
 304         err = init_port_rx_intr(rte_eth_dev_count_total());
 305         TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err);
 306
 307         if (!default_params.rx_intr_port_inited)
 308                 return 0;
 309
 310         err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID,
 311                                                 default_params.rx_intr_port,
 312                                                 &default_params.caps);
 313         TEST_ASSERT(err == 0, "Failed to get adapter cap err %d\n", err);
 314
 315         return err;
 316 }
 317
 318 static void
 319 testsuite_teardown(void)
 320 {
 321         int err;
 322         uint32_t i;
 323         RTE_ETH_FOREACH_DEV(i)
 324                 rte_eth_dev_stop(i);
 325
 326         if (eth_dev_created) {
 327                 err = rte_vdev_uninit("net_null");
 328                 if (err)
 329                         printf("Failed to delete net_null. err=%d", err);
 330                 eth_dev_created = false;
 331         }
 332
 333         rte_mempool_free(default_params.mp);
 334         if (event_dev_created) {
 335                 err = rte_vdev_uninit("event_skeleton");
 336                 if (err)
 337                         printf("Failed to delete event_skeleton. err=%d", err);
 338                 event_dev_created = false;
 339         }
 340
 341         memset(&default_params, 0, sizeof(default_params));
 342 }
 343
 344 static void
 345 testsuite_teardown_rx_intr(void)
 346 {
 347         int err;
 348         if (!default_params.rx_intr_port_inited)
 349                 return;
 350
 351         rte_eth_dev_stop(default_params.rx_intr_port);
 352         if (eth_dev_created) {
 353                 err = rte_vdev_uninit("net_null");
 354                 if (err)
 355                         printf("Failed to delete net_null. err=%d", err);
 356                 eth_dev_created = false;
 357         }
 358         rte_mempool_free(default_params.mp);
 359         if (event_dev_created) {
 360                 err = rte_vdev_uninit("event_skeleton");
 361                 if (err)
 362                         printf("Failed to delete event_skeleton. err=%d", err);
 363                 event_dev_created = false;
 364         }
 365
 366         memset(&default_params, 0, sizeof(default_params));
 367 }
 368
 369 static int
 370 adapter_create(void)
 371 {
 372         int err;
 373         struct rte_event_dev_info dev_info;
 374         struct rte_event_port_conf rx_p_conf;
 375
 376         memset(&rx_p_conf, 0, sizeof(rx_p_conf));
 377
 378         err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
 379         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 380
 381         rx_p_conf.new_event_threshold = dev_info.max_num_events;
 382         rx_p_conf.dequeue_depth = dev_info.max_event_port_dequeue_depth;
 383         rx_p_conf.enqueue_depth = dev_info.max_event_port_enqueue_depth;
 384         err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
 385                                         &rx_p_conf);
 386         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 387
 388         return err;
 389 }
 390
 391 static void
 392 adapter_free(void)
 393 {
 394         rte_event_eth_rx_adapter_free(TEST_INST_ID);
 395 }
 396
 397 static int
 398 adapter_create_free(void)
 399 {
 400         int err;
 401
 402         struct rte_event_port_conf rx_p_conf = {
 403                         .dequeue_depth = 8,
 404                         .enqueue_depth = 8,
 405                         .new_event_threshold = 1200,
 406         };
 407
 408         err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
 409                                         NULL);
 410         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 411
 412         err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
 413                                         &rx_p_conf);
 414         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 415
 416         err = rte_event_eth_rx_adapter_create(TEST_INST_ID,
 417                                         TEST_DEV_ID, &rx_p_conf);
 418         TEST_ASSERT(err == -EEXIST, "Expected -EEXIST %d got %d", -EEXIST, err);
 419
 420         err = rte_event_eth_rx_adapter_free(TEST_INST_ID);
 421         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 422
 423         err = rte_event_eth_rx_adapter_free(TEST_INST_ID);
 424         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
 425
 426         err = rte_event_eth_rx_adapter_free(1);
 427         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
 428
 429         return TEST_SUCCESS;
 430 }
 431
 432 static int
 433 adapter_queue_add_del(void)
 434 {
 435         int err;
 436         struct rte_event ev;
 437         uint32_t cap;
 438
 439         struct rte_event_eth_rx_adapter_queue_conf queue_config;
 440
 441         err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID,
 442                                          &cap);
 443         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 444
 445         ev.queue_id = 0;
 446         ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 447         ev.priority = 0;
 448
 449         queue_config.rx_queue_flags = 0;
 450         if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) {
 451                 ev.flow_id = 1;
 452                 queue_config.rx_queue_flags =
 453                         RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID;
 454         }
 455         queue_config.ev = ev;
 456         queue_config.servicing_weight = 1;
 457
 458         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 459                                                 rte_eth_dev_count_total(),
 460                                                 -1, &queue_config);
 461         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 462
 463         if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) {
 464                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 465                                                         TEST_ETHDEV_ID, 0,
 466                                                         &queue_config);
 467                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 468
 469                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 470                                                         TEST_ETHDEV_ID, 0);
 471                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 472
 473                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 474                                                         TEST_ETHDEV_ID,
 475                                                         -1,
 476                                                         &queue_config);
 477                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 478
 479                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 480                                                         TEST_ETHDEV_ID,
 481                                                         -1);
 482                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 483         } else {
 484                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 485                                                         TEST_ETHDEV_ID,
 486                                                         0,
 487                                                         &queue_config);
 488                 TEST_ASSERT(err == -EINVAL, "Expected EINVAL got %d", err);
 489
 490                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 491                                                         TEST_ETHDEV_ID, -1,
 492                                                         &queue_config);
 493                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 494
 495                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 496                                                         TEST_ETHDEV_ID, 0);
 497                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 498
 499                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 500                                                         TEST_ETHDEV_ID, -1);
 501                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 502
 503                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 504                                                         TEST_ETHDEV_ID, -1);
 505                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 506         }
 507
 508         err = rte_event_eth_rx_adapter_queue_add(1, TEST_ETHDEV_ID, -1,
 509                                                 &queue_config);
 510         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 511
 512         err = rte_event_eth_rx_adapter_queue_del(1, TEST_ETHDEV_ID, -1);
 513         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 514
 515         return TEST_SUCCESS;
 516 }
 517
 518 static int
 519 adapter_multi_eth_add_del(void)
 520 {
 521         int err;
 522         struct rte_event ev;
 523
 524         uint16_t port_index, port_index_base, drv_id = 0;
 525         char driver_name[50];
 526
 527         struct rte_event_eth_rx_adapter_queue_conf queue_config;
 528
 529         ev.queue_id = 0;
 530         ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 531         ev.priority = 0;
 532
 533         queue_config.rx_queue_flags = 0;
 534         queue_config.ev = ev;
 535         queue_config.servicing_weight = 1;
 536
 537         /* stop eth devices for existing */
 538         port_index = 0;
 539         for (; port_index < rte_eth_dev_count_total(); port_index += 1)
 540                 rte_eth_dev_stop(port_index);
 541
 542         /* add the max port for rx_adapter */
 543         port_index = rte_eth_dev_count_total();
 544         port_index_base = port_index;
 545         for (; port_index < RTE_MAX_ETHPORTS; port_index += 1) {
 546                 snprintf(driver_name, sizeof(driver_name), "%s%u", "net_null",
 547                                 drv_id);
 548                 err = rte_vdev_init(driver_name, NULL);
 549                 TEST_ASSERT(err == 0, "Failed driver %s got %d",
 550                 driver_name, err);
 551                 drv_id += 1;
 552         }
 553
 554         err = init_ports(rte_eth_dev_count_total());
 555         TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err);
 556
 557         /* eth_rx_adapter_queue_add for n ports */
 558         port_index = 0;
 559         for (; port_index < rte_eth_dev_count_total(); port_index += 1) {
 560                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 561                                 port_index, -1,
 562                                 &queue_config);
 563                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 564         }
 565
 566         /* eth_rx_adapter_queue_del n ports */
 567         port_index = 0;
 568         for (; port_index < rte_eth_dev_count_total(); port_index += 1) {
 569                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 570                                 port_index, -1);
 571                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 572         }
 573
 574         /* delete vdev ports */
 575         for (drv_id = 0, port_index = port_index_base;
 576              port_index < RTE_MAX_ETHPORTS;
 577              drv_id += 1, port_index += 1) {
 578                 snprintf(driver_name, sizeof(driver_name), "%s%u", "net_null",
 579                                 drv_id);
 580                 err = rte_vdev_uninit(driver_name);
 581                 TEST_ASSERT(err == 0, "Failed driver %s got %d",
 582                             driver_name, err);
 583         }
 584
 585         return TEST_SUCCESS;
 586 }
 587
 588 static int
 589 adapter_intr_queue_add_del(void)
 590 {
 591         int err;
 592         struct rte_event ev;
 593         uint32_t cap;
 594         uint16_t eth_port;
 595         struct rte_event_eth_rx_adapter_queue_conf queue_config;
 596
 597         if (!default_params.rx_intr_port_inited)
 598                 return 0;
 599
 600         eth_port = default_params.rx_intr_port;
 601         err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, eth_port, &cap);
 602         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 603
 604         ev.queue_id = 0;
 605         ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 606         ev.priority = 0;
 607
 608         queue_config.rx_queue_flags = 0;
 609         queue_config.ev = ev;
 610
 611         /* weight = 0 => interrupt mode */
 612         queue_config.servicing_weight = 0;
 613
 614         if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) {
 615                 /* add queue 0 */
 616                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 617                                                         TEST_ETHDEV_ID, 0,
 618                                                         &queue_config);
 619                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 620         }
 621
 622         /* add all queues */
 623         queue_config.servicing_weight = 0;
 624         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 625                                                 TEST_ETHDEV_ID,
 626                                                 -1,
 627                                                 &queue_config);
 628         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 629
 630         if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) {
 631                 /* del queue 0 */
 632                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 633                                                         TEST_ETHDEV_ID,
 634                                                         0);
 635                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 636         }
 637
 638         /* del remaining queues */
 639         err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 640                                                 TEST_ETHDEV_ID,
 641                                                 -1);
 642         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 643
 644         /* add all queues */
 645         queue_config.servicing_weight = 0;
 646         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 647                                                 TEST_ETHDEV_ID,
 648                                                 -1,
 649                                                 &queue_config);
 650         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 651
 652         /* intr -> poll mode queue */
 653         queue_config.servicing_weight = 1;
 654
 655         if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) {
 656                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 657                                                         TEST_ETHDEV_ID,
 658                                                         0,
 659                                                         &queue_config);
 660                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 661         }
 662
 663         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 664                                                 TEST_ETHDEV_ID,
 665                                                 -1,
 666                                                  &queue_config);
 667         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 668
 669         /* del queues */
 670         err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 671                                                 TEST_ETHDEV_ID,
 672                                                 -1);
 673         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 674
 675         return TEST_SUCCESS;
 676 }
 677
 678 static int
 679 adapter_start_stop(void)
 680 {
 681         int err;
 682         struct rte_event ev;
 683
 684         ev.queue_id = 0;
 685         ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 686         ev.priority = 0;
 687
 688         struct rte_event_eth_rx_adapter_queue_conf queue_config;
 689
 690         queue_config.rx_queue_flags = 0;
 691         if (default_params.caps &
 692                 RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) {
 693                 ev.flow_id = 1;
 694                 queue_config.rx_queue_flags =
 695                         RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID;
 696         }
 697
 698         queue_config.ev = ev;
 699         queue_config.servicing_weight = 1;
 700
 701         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, TEST_ETHDEV_ID,
 702                                         -1, &queue_config);
 703         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 704
 705         err = rte_event_eth_rx_adapter_start(TEST_INST_ID);
 706         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 707
 708         err = rte_event_eth_rx_adapter_stop(TEST_INST_ID);
 709         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 710
 711         err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, TEST_ETHDEV_ID,
 712                                                 -1);
 713         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 714
 715         err = rte_event_eth_rx_adapter_start(TEST_INST_ID);
 716         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 717
 718         err = rte_event_eth_rx_adapter_stop(TEST_INST_ID);
 719         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 720
 721         err = rte_event_eth_rx_adapter_start(1);
 722         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 723
 724         err = rte_event_eth_rx_adapter_stop(1);
 725         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 726
 727         return TEST_SUCCESS;
 728 }
 729
 730 static int
 731 adapter_stats(void)
 732 {
 733         int err;
 734         struct rte_event_eth_rx_adapter_stats stats;
 735
 736         err = rte_event_eth_rx_adapter_stats_get(TEST_INST_ID, NULL);
 737         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 738
 739         err = rte_event_eth_rx_adapter_stats_get(TEST_INST_ID, &stats);
 740         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 741
 742         err = rte_event_eth_rx_adapter_stats_get(1, &stats);
 743         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 744
 745         return TEST_SUCCESS;
 746 }
 747
 748 static struct unit_test_suite event_eth_rx_tests = {
 749         .suite_name = "rx event eth adapter test suite",
 750         .setup = testsuite_setup,
 751         .teardown = testsuite_teardown,
 752         .unit_test_cases = {
 753                 TEST_CASE_ST(NULL, NULL, adapter_create_free),
 754                 TEST_CASE_ST(adapter_create, adapter_free,
 755                                         adapter_queue_add_del),
 756                 TEST_CASE_ST(adapter_create, adapter_free,
 757                                         adapter_multi_eth_add_del),
 758                 TEST_CASE_ST(adapter_create, adapter_free, adapter_start_stop),
 759                 TEST_CASE_ST(adapter_create, adapter_free, adapter_stats),
 760                 TEST_CASES_END() /**< NULL terminate unit test array */
 761         }
 762 };
 763
 764 static struct unit_test_suite event_eth_rx_intr_tests = {
 765         .suite_name = "rx event eth adapter test suite",
 766         .setup = testsuite_setup_rx_intr,
 767         .teardown = testsuite_teardown_rx_intr,
 768         .unit_test_cases = {
 769                 TEST_CASE_ST(adapter_create, adapter_free,
 770                         adapter_intr_queue_add_del),
 771                 TEST_CASES_END() /**< NULL terminate unit test array */
 772         }
 773 };
 774
 775 static int
 776 test_event_eth_rx_adapter_common(void)
 777 {
 778         return unit_test_suite_runner(&event_eth_rx_tests);
 779 }
 780
 781 static int
 782 test_event_eth_rx_intr_adapter_common(void)
 783 {
 784         return unit_test_suite_runner(&event_eth_rx_intr_tests);
 785 }
 786
 787 REGISTER_TEST_COMMAND(event_eth_rx_adapter_autotest,
 788                 test_event_eth_rx_adapter_common);
 789 REGISTER_TEST_COMMAND(event_eth_rx_intr_adapter_autotest,
 790                 test_event_eth_rx_intr_adapter_common);