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