app/test/test_event_eth_rx_adapter.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2017 Intel Corporation
   3  */
   4
   5 #include "test.h"
   6
   7 #include <string.h>
   8 #include <rte_common.h>
   9 #include <rte_mempool.h>
  10 #include <rte_mbuf.h>
  11 #include <rte_ethdev.h>
  12
  13 #ifdef RTE_EXEC_ENV_WINDOWS
  14 static int
  15 test_event_eth_rx_adapter_common(void)
  16 {
  17         printf("event_eth_rx_adapter not supported on Windows, skipping test\n");
  18         return TEST_SKIPPED;
  19 }
  20
  21 static int
  22 test_event_eth_rx_intr_adapter_common(void)
  23 {
  24         printf("event_eth_rx_intr_adapter not supported on Windows, skipping test\n");
  25         return TEST_SKIPPED;
  26 }
  27
  28 #else
  29
  30 #include <rte_eventdev.h>
  31 #include <rte_bus_vdev.h>
  32
  33 #include <rte_event_eth_rx_adapter.h>
  34
  35 #define MAX_NUM_RX_QUEUE        64
  36 #define NB_MBUFS                (8192 * num_ports * MAX_NUM_RX_QUEUE)
  37 #define MBUF_CACHE_SIZE         512
  38 #define MBUF_PRIV_SIZE          0
  39 #define TEST_INST_ID            0
  40 #define TEST_DEV_ID             0
  41 #define TEST_ETHDEV_ID          0
  42
  43 struct event_eth_rx_adapter_test_params {
  44         struct rte_mempool *mp;
  45         uint16_t rx_rings, tx_rings;
  46         uint32_t caps;
  47         int rx_intr_port_inited;
  48         uint16_t rx_intr_port;
  49 };
  50
  51 static struct event_eth_rx_adapter_test_params default_params;
  52 static bool event_dev_created;
  53 static bool eth_dev_created;
  54
  55 static inline int
  56 port_init_common(uint16_t port, const struct rte_eth_conf *port_conf,
  57                 struct rte_mempool *mp)
  58 {
  59         const uint16_t rx_ring_size = 512, tx_ring_size = 512;
  60         int retval;
  61         uint16_t q;
  62         struct rte_eth_dev_info dev_info;
  63
  64         if (!rte_eth_dev_is_valid_port(port))
  65                 return -1;
  66
  67         retval = rte_eth_dev_configure(port, 0, 0, port_conf);
  68
  69         retval = rte_eth_dev_info_get(port, &dev_info);
  70         if (retval != 0)
  71                 return retval;
  72
  73         default_params.rx_rings = RTE_MIN(dev_info.max_rx_queues,
  74                                         MAX_NUM_RX_QUEUE);
  75         default_params.tx_rings = 1;
  76
  77         /* Configure the Ethernet device. */
  78         retval = rte_eth_dev_configure(port, default_params.rx_rings,
  79                                 default_params.tx_rings, port_conf);
  80         if (retval != 0)
  81                 return retval;
  82
  83         for (q = 0; q < default_params.rx_rings; q++) {
  84                 retval = rte_eth_rx_queue_setup(port, q, rx_ring_size,
  85                                 rte_eth_dev_socket_id(port), NULL, mp);
  86                 if (retval < 0)
  87                         return retval;
  88         }
  89
  90         /* Allocate and set up 1 TX queue per Ethernet port. */
  91         for (q = 0; q < default_params.tx_rings; q++) {
  92                 retval = rte_eth_tx_queue_setup(port, q, tx_ring_size,
  93                                 rte_eth_dev_socket_id(port), NULL);
  94                 if (retval < 0)
  95                         return retval;
  96         }
  97
  98         /* Start the Ethernet port. */
  99         retval = rte_eth_dev_start(port);
 100         if (retval < 0)
 101                 return retval;
 102
 103         /* Display the port MAC address. */
 104         struct rte_ether_addr addr;
 105         retval = rte_eth_macaddr_get(port, &addr);
 106         if (retval < 0)
 107                 return retval;
 108         printf("Port %u MAC: %02" PRIx8 " %02" PRIx8 " %02" PRIx8
 109                            " %02" PRIx8 " %02" PRIx8 " %02" PRIx8 "\n",
 110                         (unsigned int)port, RTE_ETHER_ADDR_BYTES(&addr));
 111
 112         /* Enable RX in promiscuous mode for the Ethernet device. */
 113         retval = rte_eth_promiscuous_enable(port);
 114         if (retval != 0)
 115                 return retval;
 116
 117         return 0;
 118 }
 119
 120 static inline int
 121 port_init_rx_intr(uint16_t port, struct rte_mempool *mp)
 122 {
 123         static const struct rte_eth_conf port_conf_default = {
 124                 .rxmode = {
 125                         .mq_mode = RTE_ETH_MQ_RX_NONE,
 126                 },
 127                 .intr_conf = {
 128                         .rxq = 1,
 129                 },
 130         };
 131
 132         return port_init_common(port, &port_conf_default, mp);
 133 }
 134
 135 static inline int
 136 port_init(uint16_t port, struct rte_mempool *mp)
 137 {
 138         static const struct rte_eth_conf port_conf_default = {
 139                 .rxmode = {
 140                         .mq_mode = RTE_ETH_MQ_RX_NONE,
 141                 },
 142         };
 143
 144         return port_init_common(port, &port_conf_default, mp);
 145 }
 146
 147 static int
 148 init_port_rx_intr(int num_ports)
 149 {
 150         int retval;
 151         uint16_t portid;
 152         int err;
 153
 154         default_params.mp = rte_pktmbuf_pool_create("packet_pool",
 155                                                    NB_MBUFS,
 156                                                    MBUF_CACHE_SIZE,
 157                                                    MBUF_PRIV_SIZE,
 158                                                    RTE_MBUF_DEFAULT_BUF_SIZE,
 159                                                    rte_socket_id());
 160         if (!default_params.mp)
 161                 return -ENOMEM;
 162
 163         RTE_ETH_FOREACH_DEV(portid) {
 164                 retval = port_init_rx_intr(portid, default_params.mp);
 165                 if (retval)
 166                         continue;
 167                 err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, portid,
 168                                                         &default_params.caps);
 169                 if (err)
 170                         continue;
 171                 if (!(default_params.caps &
 172                         RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT)) {
 173                         default_params.rx_intr_port_inited = 1;
 174                         default_params.rx_intr_port = portid;
 175                         return 0;
 176                 }
 177                 retval = rte_eth_dev_stop(portid);
 178                 TEST_ASSERT(retval == 0, "Failed to stop port %u: %d\n",
 179                                         portid, retval);
 180         }
 181         return 0;
 182 }
 183
 184 static int
 185 init_ports(int num_ports)
 186 {
 187         uint16_t portid;
 188         int retval;
 189
 190         struct rte_mempool *ptr = rte_mempool_lookup("packet_pool");
 191
 192         if (ptr == NULL)
 193                 default_params.mp = rte_pktmbuf_pool_create("packet_pool",
 194                                                 NB_MBUFS,
 195                                                 MBUF_CACHE_SIZE,
 196                                                 MBUF_PRIV_SIZE,
 197                                                 RTE_MBUF_DEFAULT_BUF_SIZE,
 198                                                 rte_socket_id());
 199         else
 200                 default_params.mp = ptr;
 201
 202         if (!default_params.mp)
 203                 return -ENOMEM;
 204
 205         RTE_ETH_FOREACH_DEV(portid) {
 206                 retval = port_init(portid, default_params.mp);
 207                 if (retval)
 208                         return retval;
 209         }
 210
 211         return 0;
 212 }
 213
 214 static int
 215 testsuite_setup(void)
 216 {
 217         int err;
 218         uint8_t count;
 219         struct rte_event_dev_info dev_info;
 220
 221         count = rte_event_dev_count();
 222         if (!count) {
 223                 printf("Failed to find a valid event device,"
 224                         " testing with event_skeleton device\n");
 225                 err = rte_vdev_init("event_skeleton", NULL);
 226                 TEST_ASSERT(err == 0, "Failed to create event_skeleton. err=%d",
 227                             err);
 228                 event_dev_created = true;
 229         }
 230
 231         struct rte_event_dev_config config = {
 232                         .nb_event_queues = 1,
 233                         .nb_event_ports = 1,
 234         };
 235
 236         err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
 237         config.nb_event_queue_flows = dev_info.max_event_queue_flows;
 238         config.nb_event_port_dequeue_depth =
 239                         dev_info.max_event_port_dequeue_depth;
 240         config.nb_event_port_enqueue_depth =
 241                         dev_info.max_event_port_enqueue_depth;
 242         config.nb_events_limit =
 243                         dev_info.max_num_events;
 244         err = rte_event_dev_configure(TEST_DEV_ID, &config);
 245         TEST_ASSERT(err == 0, "Event device initialization failed err %d\n",
 246                         err);
 247
 248         count = rte_eth_dev_count_total();
 249         if (!count) {
 250                 printf("Testing with net_null device\n");
 251                 err = rte_vdev_init("net_null", NULL);
 252                 TEST_ASSERT(err == 0, "Failed to create net_null. err=%d",
 253                             err);
 254                 eth_dev_created = true;
 255         }
 256
 257         /*
 258          * eth devices like octeontx use event device to receive packets
 259          * so rte_eth_dev_start invokes rte_event_dev_start internally, so
 260          * call init_ports after rte_event_dev_configure
 261          */
 262         err = init_ports(rte_eth_dev_count_total());
 263         TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err);
 264
 265         err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID,
 266                                                 &default_params.caps);
 267         TEST_ASSERT(err == 0, "Failed to get adapter cap err %d\n",
 268                         err);
 269
 270         return err;
 271 }
 272
 273 static int
 274 testsuite_setup_rx_intr(void)
 275 {
 276         int err;
 277         uint8_t count;
 278         struct rte_event_dev_info dev_info;
 279
 280         count = rte_event_dev_count();
 281         if (!count) {
 282                 printf("Failed to find a valid event device,"
 283                         " testing with event_skeleton device\n");
 284                 err = rte_vdev_init("event_skeleton", NULL);
 285                 TEST_ASSERT(err == 0, "Failed to create event_skeleton. err=%d",
 286                             err);
 287                 event_dev_created = true;
 288         }
 289
 290         struct rte_event_dev_config config = {
 291                 .nb_event_queues = 1,
 292                 .nb_event_ports = 1,
 293         };
 294
 295         err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
 296         config.nb_event_queue_flows = dev_info.max_event_queue_flows;
 297         config.nb_event_port_dequeue_depth =
 298                         dev_info.max_event_port_dequeue_depth;
 299         config.nb_event_port_enqueue_depth =
 300                         dev_info.max_event_port_enqueue_depth;
 301         config.nb_events_limit =
 302                         dev_info.max_num_events;
 303
 304         err = rte_event_dev_configure(TEST_DEV_ID, &config);
 305         TEST_ASSERT(err == 0, "Event device initialization failed err %d\n",
 306                         err);
 307
 308         count = rte_eth_dev_count_total();
 309         if (!count) {
 310                 printf("Testing with net_null device\n");
 311                 err = rte_vdev_init("net_null", NULL);
 312                 TEST_ASSERT(err == 0, "Failed to create net_null. err=%d",
 313                             err);
 314                 eth_dev_created = true;
 315         }
 316
 317         /*
 318          * eth devices like octeontx use event device to receive packets
 319          * so rte_eth_dev_start invokes rte_event_dev_start internally, so
 320          * call init_ports after rte_event_dev_configure
 321          */
 322         err = init_port_rx_intr(rte_eth_dev_count_total());
 323         TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err);
 324
 325         if (!default_params.rx_intr_port_inited)
 326                 return 0;
 327
 328         err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID,
 329                                                 default_params.rx_intr_port,
 330                                                 &default_params.caps);
 331         TEST_ASSERT(err == 0, "Failed to get adapter cap err %d\n", err);
 332
 333         return err;
 334 }
 335
 336 static void
 337 testsuite_teardown(void)
 338 {
 339         int err;
 340         uint32_t i;
 341         RTE_ETH_FOREACH_DEV(i)
 342                 rte_eth_dev_stop(i);
 343
 344         if (eth_dev_created) {
 345                 err = rte_vdev_uninit("net_null");
 346                 if (err)
 347                         printf("Failed to delete net_null. err=%d", err);
 348                 eth_dev_created = false;
 349         }
 350
 351         rte_mempool_free(default_params.mp);
 352         if (event_dev_created) {
 353                 err = rte_vdev_uninit("event_skeleton");
 354                 if (err)
 355                         printf("Failed to delete event_skeleton. err=%d", err);
 356                 event_dev_created = false;
 357         }
 358
 359         memset(&default_params, 0, sizeof(default_params));
 360 }
 361
 362 static void
 363 testsuite_teardown_rx_intr(void)
 364 {
 365         int err;
 366         if (!default_params.rx_intr_port_inited)
 367                 return;
 368
 369         rte_eth_dev_stop(default_params.rx_intr_port);
 370         if (eth_dev_created) {
 371                 err = rte_vdev_uninit("net_null");
 372                 if (err)
 373                         printf("Failed to delete net_null. err=%d", err);
 374                 eth_dev_created = false;
 375         }
 376         rte_mempool_free(default_params.mp);
 377         if (event_dev_created) {
 378                 err = rte_vdev_uninit("event_skeleton");
 379                 if (err)
 380                         printf("Failed to delete event_skeleton. err=%d", err);
 381                 event_dev_created = false;
 382         }
 383
 384         memset(&default_params, 0, sizeof(default_params));
 385 }
 386
 387 static int
 388 adapter_create(void)
 389 {
 390         int err;
 391         struct rte_event_dev_info dev_info;
 392         struct rte_event_port_conf rx_p_conf;
 393
 394         memset(&rx_p_conf, 0, sizeof(rx_p_conf));
 395
 396         err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
 397         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 398
 399         rx_p_conf.new_event_threshold = dev_info.max_num_events;
 400         rx_p_conf.dequeue_depth = dev_info.max_event_port_dequeue_depth;
 401         rx_p_conf.enqueue_depth = dev_info.max_event_port_enqueue_depth;
 402         err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
 403                                         &rx_p_conf);
 404         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 405
 406         return err;
 407 }
 408
 409 static int
 410 adapter_create_with_params(void)
 411 {
 412         int err;
 413         struct rte_event_dev_info dev_info;
 414         struct rte_event_port_conf rx_p_conf;
 415         struct rte_event_eth_rx_adapter_params rxa_params;
 416
 417         memset(&rx_p_conf, 0, sizeof(rx_p_conf));
 418
 419         err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
 420         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 421
 422         rx_p_conf.new_event_threshold = dev_info.max_num_events;
 423         rx_p_conf.dequeue_depth = dev_info.max_event_port_dequeue_depth;
 424         rx_p_conf.enqueue_depth = dev_info.max_event_port_enqueue_depth;
 425
 426         rxa_params.use_queue_event_buf = false;
 427         rxa_params.event_buf_size = 0;
 428
 429         err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID,
 430                                 TEST_DEV_ID, &rx_p_conf, &rxa_params);
 431         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 432
 433         rxa_params.use_queue_event_buf = true;
 434
 435         err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID,
 436                                 TEST_DEV_ID, &rx_p_conf, &rxa_params);
 437         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 438
 439         err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID,
 440                                 TEST_DEV_ID, &rx_p_conf, &rxa_params);
 441         TEST_ASSERT(err == -EEXIST, "Expected -EEXIST got %d", err);
 442
 443         return TEST_SUCCESS;
 444 }
 445
 446 static int
 447 adapter_queue_event_buf_test(void)
 448 {
 449         int err;
 450         struct rte_event ev;
 451         uint32_t cap;
 452
 453         struct rte_event_eth_rx_adapter_queue_conf queue_config = {0};
 454
 455         err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID,
 456                                          &cap);
 457         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 458
 459         ev.queue_id = 0;
 460         ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 461         ev.priority = 0;
 462
 463         queue_config.rx_queue_flags = 0;
 464         if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) {
 465                 ev.flow_id = 1;
 466                 queue_config.rx_queue_flags =
 467                         RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID;
 468         }
 469         queue_config.ev = ev;
 470         queue_config.servicing_weight = 1;
 471         queue_config.event_buf_size = 0;
 472
 473         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 474                                         TEST_ETHDEV_ID, 0,
 475                                         &queue_config);
 476         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 477
 478         queue_config.event_buf_size = 1024;
 479
 480         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 481                                         TEST_ETHDEV_ID, 0,
 482                                         &queue_config);
 483         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 484
 485         err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 486                                                 TEST_ETHDEV_ID,
 487                                                 0);
 488         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 489
 490         return TEST_SUCCESS;
 491 }
 492
 493 static int
 494 adapter_queue_stats_test(void)
 495 {
 496         int err;
 497         struct rte_event ev;
 498         uint32_t cap;
 499         struct rte_event_eth_rx_adapter_queue_conf queue_config = {0};
 500         struct rte_event_eth_rx_adapter_queue_stats q_stats;
 501
 502         err = rte_event_eth_rx_adapter_queue_stats_get(TEST_INST_ID,
 503                                                 TEST_ETHDEV_ID, 0,
 504                                                 &q_stats);
 505         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 506
 507         err = rte_event_eth_rx_adapter_queue_stats_reset(TEST_INST_ID,
 508                                                 TEST_ETHDEV_ID, 0);
 509         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 510
 511         err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID,
 512                                          &cap);
 513         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 514
 515         ev.queue_id = 0;
 516         ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 517         ev.priority = 0;
 518
 519         queue_config.rx_queue_flags = 0;
 520         if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) {
 521                 ev.flow_id = 1;
 522                 queue_config.rx_queue_flags =
 523                         RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID;
 524         }
 525         queue_config.ev = ev;
 526         queue_config.servicing_weight = 1;
 527         queue_config.event_buf_size = 1024;
 528
 529         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 530                                         TEST_ETHDEV_ID, 0,
 531                                         &queue_config);
 532         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 533
 534         err = rte_event_eth_rx_adapter_queue_stats_get(TEST_INST_ID,
 535                                                 TEST_ETHDEV_ID, 0,
 536                                                 &q_stats);
 537         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 538
 539         err = rte_event_eth_rx_adapter_queue_stats_reset(TEST_INST_ID,
 540                                                 TEST_ETHDEV_ID, 0);
 541         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 542
 543         err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 544                                                 TEST_ETHDEV_ID,
 545                                                 0);
 546         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 547
 548         return TEST_SUCCESS;
 549 }
 550
 551 static void
 552 adapter_free(void)
 553 {
 554         rte_event_eth_rx_adapter_free(TEST_INST_ID);
 555 }
 556
 557 static int
 558 adapter_create_free(void)
 559 {
 560         int err;
 561
 562         struct rte_event_port_conf rx_p_conf = {
 563                         .dequeue_depth = 8,
 564                         .enqueue_depth = 8,
 565                         .new_event_threshold = 1200,
 566         };
 567
 568         err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
 569                                         NULL);
 570         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 571
 572         err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
 573                                         &rx_p_conf);
 574         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 575
 576         err = rte_event_eth_rx_adapter_create(TEST_INST_ID,
 577                                         TEST_DEV_ID, &rx_p_conf);
 578         TEST_ASSERT(err == -EEXIST, "Expected -EEXIST %d got %d", -EEXIST, err);
 579
 580         err = rte_event_eth_rx_adapter_free(TEST_INST_ID);
 581         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 582
 583         err = rte_event_eth_rx_adapter_free(TEST_INST_ID);
 584         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
 585
 586         err = rte_event_eth_rx_adapter_free(1);
 587         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
 588
 589         return TEST_SUCCESS;
 590 }
 591
 592 static int
 593 adapter_create_free_with_params(void)
 594 {
 595         int err;
 596
 597         struct rte_event_port_conf rx_p_conf = {
 598                         .dequeue_depth = 8,
 599                         .enqueue_depth = 8,
 600                         .new_event_threshold = 1200,
 601         };
 602
 603         struct rte_event_eth_rx_adapter_params rxa_params = {
 604                         .event_buf_size = 1024
 605         };
 606
 607         err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID,
 608                                 TEST_DEV_ID, NULL, NULL);
 609         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 610
 611         err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID,
 612                                 TEST_DEV_ID, &rx_p_conf, &rxa_params);
 613         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 614
 615         err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID,
 616                                 TEST_DEV_ID, &rx_p_conf, &rxa_params);
 617         TEST_ASSERT(err == -EEXIST, "Expected -EEXIST %d got %d", -EEXIST, err);
 618
 619         rxa_params.event_buf_size = 0;
 620         err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID,
 621                                 TEST_DEV_ID, &rx_p_conf, &rxa_params);
 622         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 623
 624         err = rte_event_eth_rx_adapter_free(TEST_INST_ID);
 625         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 626
 627         err = rte_event_eth_rx_adapter_free(TEST_INST_ID);
 628         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
 629
 630         err = rte_event_eth_rx_adapter_free(1);
 631         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
 632
 633         return TEST_SUCCESS;
 634 }
 635
 636 static int
 637 adapter_queue_add_del(void)
 638 {
 639         int err;
 640         struct rte_event ev;
 641         uint32_t cap;
 642
 643         struct rte_event_eth_rx_adapter_queue_conf queue_config = {0};
 644
 645         err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID,
 646                                          &cap);
 647         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 648
 649         ev.queue_id = 0;
 650         ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 651         ev.priority = 0;
 652
 653         queue_config.rx_queue_flags = 0;
 654         if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) {
 655                 ev.flow_id = 1;
 656                 queue_config.rx_queue_flags =
 657                         RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID;
 658         }
 659         queue_config.ev = ev;
 660         queue_config.servicing_weight = 1;
 661
 662         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 663                                                 rte_eth_dev_count_total(),
 664                                                 -1, &queue_config);
 665         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 666
 667         if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) {
 668                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 669                                                         TEST_ETHDEV_ID, 0,
 670                                                         &queue_config);
 671                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 672
 673                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 674                                                         TEST_ETHDEV_ID, 0);
 675                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 676
 677                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 678                                                         TEST_ETHDEV_ID,
 679                                                         -1,
 680                                                         &queue_config);
 681                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 682
 683                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 684                                                         TEST_ETHDEV_ID,
 685                                                         -1);
 686                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 687         } else {
 688                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 689                                                         TEST_ETHDEV_ID,
 690                                                         0,
 691                                                         &queue_config);
 692                 TEST_ASSERT(err == -EINVAL, "Expected EINVAL got %d", err);
 693
 694                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 695                                                         TEST_ETHDEV_ID, -1,
 696                                                         &queue_config);
 697                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 698
 699                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 700                                                         TEST_ETHDEV_ID, 0);
 701                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 702
 703                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 704                                                         TEST_ETHDEV_ID, -1);
 705                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 706
 707                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 708                                                         TEST_ETHDEV_ID, -1);
 709                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 710         }
 711
 712         err = rte_event_eth_rx_adapter_queue_add(1, TEST_ETHDEV_ID, -1,
 713                                                 &queue_config);
 714         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 715
 716         err = rte_event_eth_rx_adapter_queue_del(1, TEST_ETHDEV_ID, -1);
 717         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 718
 719         return TEST_SUCCESS;
 720 }
 721
 722 static int
 723 adapter_multi_eth_add_del(void)
 724 {
 725         int err;
 726         struct rte_event ev;
 727
 728         uint16_t port_index, port_index_base, drv_id = 0;
 729         char driver_name[50];
 730
 731         struct rte_event_eth_rx_adapter_queue_conf queue_config = {0};
 732
 733         ev.queue_id = 0;
 734         ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 735         ev.priority = 0;
 736
 737         queue_config.rx_queue_flags = 0;
 738         queue_config.ev = ev;
 739         queue_config.servicing_weight = 1;
 740
 741         /* stop eth devices for existing */
 742         port_index = 0;
 743         for (; port_index < rte_eth_dev_count_total(); port_index += 1) {
 744                 err = rte_eth_dev_stop(port_index);
 745                 TEST_ASSERT(err == 0, "Failed to stop port %u: %d\n",
 746                                         port_index, err);
 747         }
 748
 749         /* add the max port for rx_adapter */
 750         port_index = rte_eth_dev_count_total();
 751         port_index_base = port_index;
 752         for (; port_index < RTE_MAX_ETHPORTS; port_index += 1) {
 753                 snprintf(driver_name, sizeof(driver_name), "%s%u", "net_null",
 754                                 drv_id);
 755                 err = rte_vdev_init(driver_name, NULL);
 756                 TEST_ASSERT(err == 0, "Failed driver %s got %d",
 757                 driver_name, err);
 758                 drv_id += 1;
 759         }
 760
 761         err = init_ports(rte_eth_dev_count_total());
 762         TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err);
 763
 764         /* eth_rx_adapter_queue_add for n ports */
 765         port_index = 0;
 766         for (; port_index < rte_eth_dev_count_total(); port_index += 1) {
 767                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 768                                 port_index, -1,
 769                                 &queue_config);
 770                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 771         }
 772
 773         /* eth_rx_adapter_queue_del n ports */
 774         port_index = 0;
 775         for (; port_index < rte_eth_dev_count_total(); port_index += 1) {
 776                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 777                                 port_index, -1);
 778                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 779         }
 780
 781         /* delete vdev ports */
 782         for (drv_id = 0, port_index = port_index_base;
 783              port_index < RTE_MAX_ETHPORTS;
 784              drv_id += 1, port_index += 1) {
 785                 snprintf(driver_name, sizeof(driver_name), "%s%u", "net_null",
 786                                 drv_id);
 787                 err = rte_vdev_uninit(driver_name);
 788                 TEST_ASSERT(err == 0, "Failed driver %s got %d",
 789                             driver_name, err);
 790         }
 791
 792         return TEST_SUCCESS;
 793 }
 794
 795 static int
 796 adapter_intr_queue_add_del(void)
 797 {
 798         int err;
 799         struct rte_event ev;
 800         uint32_t cap;
 801         uint16_t eth_port;
 802         struct rte_event_eth_rx_adapter_queue_conf queue_config = {0};
 803
 804         if (!default_params.rx_intr_port_inited)
 805                 return 0;
 806
 807         eth_port = default_params.rx_intr_port;
 808         err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, eth_port, &cap);
 809         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 810
 811         ev.queue_id = 0;
 812         ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 813         ev.priority = 0;
 814
 815         queue_config.rx_queue_flags = 0;
 816         queue_config.ev = ev;
 817
 818         /* weight = 0 => interrupt mode */
 819         queue_config.servicing_weight = 0;
 820
 821         if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) {
 822                 /* add queue 0 */
 823                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 824                                                         TEST_ETHDEV_ID, 0,
 825                                                         &queue_config);
 826                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 827         }
 828
 829         /* add all queues */
 830         queue_config.servicing_weight = 0;
 831         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 832                                                 TEST_ETHDEV_ID,
 833                                                 -1,
 834                                                 &queue_config);
 835         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 836
 837         if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) {
 838                 /* del queue 0 */
 839                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 840                                                         TEST_ETHDEV_ID,
 841                                                         0);
 842                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 843         }
 844
 845         /* del remaining queues */
 846         err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 847                                                 TEST_ETHDEV_ID,
 848                                                 -1);
 849         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 850
 851         /* add all queues */
 852         queue_config.servicing_weight = 0;
 853         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 854                                                 TEST_ETHDEV_ID,
 855                                                 -1,
 856                                                 &queue_config);
 857         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 858
 859         /* intr -> poll mode queue */
 860         queue_config.servicing_weight = 1;
 861
 862         if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) {
 863                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 864                                                         TEST_ETHDEV_ID,
 865                                                         0,
 866                                                         &queue_config);
 867                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 868         }
 869
 870         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 871                                                 TEST_ETHDEV_ID,
 872                                                 -1,
 873                                                  &queue_config);
 874         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 875
 876         /* del queues */
 877         err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 878                                                 TEST_ETHDEV_ID,
 879                                                 -1);
 880         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 881
 882         return TEST_SUCCESS;
 883 }
 884
 885 static int
 886 adapter_start_stop(void)
 887 {
 888         int err;
 889         struct rte_event ev;
 890
 891         ev.queue_id = 0;
 892         ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 893         ev.priority = 0;
 894
 895         struct rte_event_eth_rx_adapter_queue_conf queue_config = {0};
 896
 897         queue_config.rx_queue_flags = 0;
 898         if (default_params.caps &
 899                 RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) {
 900                 ev.flow_id = 1;
 901                 queue_config.rx_queue_flags =
 902                         RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID;
 903         }
 904
 905         queue_config.ev = ev;
 906         queue_config.servicing_weight = 1;
 907
 908         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, TEST_ETHDEV_ID,
 909                                         -1, &queue_config);
 910         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 911
 912         err = rte_event_eth_rx_adapter_start(TEST_INST_ID);
 913         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 914
 915         err = rte_event_eth_rx_adapter_stop(TEST_INST_ID);
 916         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 917
 918         err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, TEST_ETHDEV_ID,
 919                                                 -1);
 920         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 921
 922         err = rte_event_eth_rx_adapter_start(TEST_INST_ID);
 923         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 924
 925         err = rte_event_eth_rx_adapter_stop(TEST_INST_ID);
 926         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 927
 928         err = rte_event_eth_rx_adapter_start(1);
 929         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 930
 931         err = rte_event_eth_rx_adapter_stop(1);
 932         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 933
 934         return TEST_SUCCESS;
 935 }
 936
 937 static int
 938 adapter_stats(void)
 939 {
 940         int err;
 941         struct rte_event_eth_rx_adapter_stats stats;
 942
 943         err = rte_event_eth_rx_adapter_stats_get(TEST_INST_ID, NULL);
 944         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 945
 946         err = rte_event_eth_rx_adapter_stats_get(TEST_INST_ID, &stats);
 947         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 948
 949         err = rte_event_eth_rx_adapter_stats_get(1, &stats);
 950         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 951
 952         return TEST_SUCCESS;
 953 }
 954
 955 static int
 956 adapter_queue_conf(void)
 957 {
 958         int err;
 959         struct rte_event_eth_rx_adapter_queue_conf queue_conf = {0};
 960
 961         /* Case 1: queue conf get without any queues in Rx adapter */
 962         err = rte_event_eth_rx_adapter_queue_conf_get(TEST_INST_ID,
 963                                                       TEST_ETHDEV_ID,
 964                                                       0, &queue_conf);
 965         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 966
 967         /* Add queue to Rx adapter */
 968         queue_conf.ev.queue_id = 0;
 969         queue_conf.ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 970         queue_conf.ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL;
 971
 972         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 973                                                  TEST_ETHDEV_ID,
 974                                                  0, &queue_conf);
 975         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 976
 977         /* Case 2: queue conf get with queue added to Rx adapter */
 978         err = rte_event_eth_rx_adapter_queue_conf_get(TEST_INST_ID,
 979                                                       TEST_ETHDEV_ID,
 980                                                       0, &queue_conf);
 981         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 982
 983         /* Case 3: queue conf get with invalid rx queue id */
 984         err = rte_event_eth_rx_adapter_queue_conf_get(TEST_INST_ID,
 985                                                       TEST_ETHDEV_ID,
 986                                                       -1, &queue_conf);
 987         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 988
 989         /* Case 4: queue conf get with NULL queue conf struct */
 990         err = rte_event_eth_rx_adapter_queue_conf_get(TEST_INST_ID,
 991                                                       TEST_ETHDEV_ID,
 992                                                       0, NULL);
 993         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 994
 995         /* Delete queue from the Rx adapter */
 996         err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 997                                                  TEST_ETHDEV_ID,
 998                                                  0);
 999         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1000
1001         return TEST_SUCCESS;
1002 }
1003
1004 static struct unit_test_suite event_eth_rx_tests = {
1005         .suite_name = "rx event eth adapter test suite",
1006         .setup = testsuite_setup,
1007         .teardown = testsuite_teardown,
1008         .unit_test_cases = {
1009                 TEST_CASE_ST(NULL, NULL, adapter_create_free),
1010                 TEST_CASE_ST(NULL, NULL, adapter_create_free_with_params),
1011                 TEST_CASE_ST(adapter_create, adapter_free,
1012                                         adapter_queue_add_del),
1013                 TEST_CASE_ST(adapter_create, adapter_free,
1014                                         adapter_multi_eth_add_del),
1015                 TEST_CASE_ST(adapter_create, adapter_free, adapter_start_stop),
1016                 TEST_CASE_ST(adapter_create, adapter_free, adapter_stats),
1017                 TEST_CASE_ST(adapter_create, adapter_free, adapter_queue_conf),
1018                 TEST_CASE_ST(adapter_create_with_params, adapter_free,
1019                              adapter_queue_event_buf_test),
1020                 TEST_CASE_ST(adapter_create_with_params, adapter_free,
1021                              adapter_queue_stats_test),
1022                 TEST_CASES_END() /**< NULL terminate unit test array */
1023         }
1024 };
1025
1026 static struct unit_test_suite event_eth_rx_intr_tests = {
1027         .suite_name = "rx event eth adapter test suite",
1028         .setup = testsuite_setup_rx_intr,
1029         .teardown = testsuite_teardown_rx_intr,
1030         .unit_test_cases = {
1031                 TEST_CASE_ST(adapter_create, adapter_free,
1032                         adapter_intr_queue_add_del),
1033                 TEST_CASES_END() /**< NULL terminate unit test array */
1034         }
1035 };
1036
1037 static int
1038 test_event_eth_rx_adapter_common(void)
1039 {
1040         return unit_test_suite_runner(&event_eth_rx_tests);
1041 }
1042
1043 static int
1044 test_event_eth_rx_intr_adapter_common(void)
1045 {
1046         return unit_test_suite_runner(&event_eth_rx_intr_tests);
1047 }
1048
1049 #endif /* !RTE_EXEC_ENV_WINDOWS */
1050
1051 REGISTER_TEST_COMMAND(event_eth_rx_adapter_autotest,
1052                 test_event_eth_rx_adapter_common);
1053 REGISTER_TEST_COMMAND(event_eth_rx_intr_adapter_autotest,
1054                 test_event_eth_rx_intr_adapter_common);