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 = RTE_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 = RTE_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 int
 475 adapter_queue_stats_test(void)
 476 {
 477         int err;
 478         struct rte_event ev;
 479         uint32_t cap;
 480         struct rte_event_eth_rx_adapter_queue_conf queue_config = {0};
 481         struct rte_event_eth_rx_adapter_queue_stats q_stats;
 482
 483         err = rte_event_eth_rx_adapter_queue_stats_get(TEST_INST_ID,
 484                                                 TEST_ETHDEV_ID, 0,
 485                                                 &q_stats);
 486         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 487
 488         err = rte_event_eth_rx_adapter_queue_stats_reset(TEST_INST_ID,
 489                                                 TEST_ETHDEV_ID, 0);
 490         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 491
 492         err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID,
 493                                          &cap);
 494         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 495
 496         ev.queue_id = 0;
 497         ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 498         ev.priority = 0;
 499
 500         queue_config.rx_queue_flags = 0;
 501         if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) {
 502                 ev.flow_id = 1;
 503                 queue_config.rx_queue_flags =
 504                         RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID;
 505         }
 506         queue_config.ev = ev;
 507         queue_config.servicing_weight = 1;
 508         queue_config.event_buf_size = 1024;
 509
 510         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 511                                         TEST_ETHDEV_ID, 0,
 512                                         &queue_config);
 513         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 514
 515         err = rte_event_eth_rx_adapter_queue_stats_get(TEST_INST_ID,
 516                                                 TEST_ETHDEV_ID, 0,
 517                                                 &q_stats);
 518         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 519
 520         err = rte_event_eth_rx_adapter_queue_stats_reset(TEST_INST_ID,
 521                                                 TEST_ETHDEV_ID, 0);
 522         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 523
 524         err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 525                                                 TEST_ETHDEV_ID,
 526                                                 0);
 527         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 528
 529         return TEST_SUCCESS;
 530 }
 531
 532 static void
 533 adapter_free(void)
 534 {
 535         rte_event_eth_rx_adapter_free(TEST_INST_ID);
 536 }
 537
 538 static int
 539 adapter_create_free(void)
 540 {
 541         int err;
 542
 543         struct rte_event_port_conf rx_p_conf = {
 544                         .dequeue_depth = 8,
 545                         .enqueue_depth = 8,
 546                         .new_event_threshold = 1200,
 547         };
 548
 549         err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
 550                                         NULL);
 551         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 552
 553         err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
 554                                         &rx_p_conf);
 555         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 556
 557         err = rte_event_eth_rx_adapter_create(TEST_INST_ID,
 558                                         TEST_DEV_ID, &rx_p_conf);
 559         TEST_ASSERT(err == -EEXIST, "Expected -EEXIST %d got %d", -EEXIST, err);
 560
 561         err = rte_event_eth_rx_adapter_free(TEST_INST_ID);
 562         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 563
 564         err = rte_event_eth_rx_adapter_free(TEST_INST_ID);
 565         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
 566
 567         err = rte_event_eth_rx_adapter_free(1);
 568         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
 569
 570         return TEST_SUCCESS;
 571 }
 572
 573 static int
 574 adapter_create_free_with_params(void)
 575 {
 576         int err;
 577
 578         struct rte_event_port_conf rx_p_conf = {
 579                         .dequeue_depth = 8,
 580                         .enqueue_depth = 8,
 581                         .new_event_threshold = 1200,
 582         };
 583
 584         struct rte_event_eth_rx_adapter_params rxa_params = {
 585                         .event_buf_size = 1024
 586         };
 587
 588         err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID,
 589                                 TEST_DEV_ID, NULL, NULL);
 590         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 591
 592         err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID,
 593                                 TEST_DEV_ID, &rx_p_conf, &rxa_params);
 594         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 595
 596         err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID,
 597                                 TEST_DEV_ID, &rx_p_conf, &rxa_params);
 598         TEST_ASSERT(err == -EEXIST, "Expected -EEXIST %d got %d", -EEXIST, err);
 599
 600         rxa_params.event_buf_size = 0;
 601         err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID,
 602                                 TEST_DEV_ID, &rx_p_conf, &rxa_params);
 603         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 604
 605         err = rte_event_eth_rx_adapter_free(TEST_INST_ID);
 606         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 607
 608         err = rte_event_eth_rx_adapter_free(TEST_INST_ID);
 609         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
 610
 611         err = rte_event_eth_rx_adapter_free(1);
 612         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
 613
 614         return TEST_SUCCESS;
 615 }
 616
 617 static int
 618 adapter_queue_add_del(void)
 619 {
 620         int err;
 621         struct rte_event ev;
 622         uint32_t cap;
 623
 624         struct rte_event_eth_rx_adapter_queue_conf queue_config = {0};
 625
 626         err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID,
 627                                          &cap);
 628         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 629
 630         ev.queue_id = 0;
 631         ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 632         ev.priority = 0;
 633
 634         queue_config.rx_queue_flags = 0;
 635         if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) {
 636                 ev.flow_id = 1;
 637                 queue_config.rx_queue_flags =
 638                         RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID;
 639         }
 640         queue_config.ev = ev;
 641         queue_config.servicing_weight = 1;
 642
 643         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 644                                                 rte_eth_dev_count_total(),
 645                                                 -1, &queue_config);
 646         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 647
 648         if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) {
 649                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 650                                                         TEST_ETHDEV_ID, 0,
 651                                                         &queue_config);
 652                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 653
 654                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 655                                                         TEST_ETHDEV_ID, 0);
 656                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 657
 658                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 659                                                         TEST_ETHDEV_ID,
 660                                                         -1,
 661                                                         &queue_config);
 662                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 663
 664                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 665                                                         TEST_ETHDEV_ID,
 666                                                         -1);
 667                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 668         } else {
 669                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 670                                                         TEST_ETHDEV_ID,
 671                                                         0,
 672                                                         &queue_config);
 673                 TEST_ASSERT(err == -EINVAL, "Expected EINVAL got %d", err);
 674
 675                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 676                                                         TEST_ETHDEV_ID, -1,
 677                                                         &queue_config);
 678                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 679
 680                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 681                                                         TEST_ETHDEV_ID, 0);
 682                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 683
 684                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 685                                                         TEST_ETHDEV_ID, -1);
 686                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 687
 688                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 689                                                         TEST_ETHDEV_ID, -1);
 690                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 691         }
 692
 693         err = rte_event_eth_rx_adapter_queue_add(1, TEST_ETHDEV_ID, -1,
 694                                                 &queue_config);
 695         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 696
 697         err = rte_event_eth_rx_adapter_queue_del(1, TEST_ETHDEV_ID, -1);
 698         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 699
 700         return TEST_SUCCESS;
 701 }
 702
 703 static int
 704 adapter_multi_eth_add_del(void)
 705 {
 706         int err;
 707         struct rte_event ev;
 708
 709         uint16_t port_index, port_index_base, drv_id = 0;
 710         char driver_name[50];
 711
 712         struct rte_event_eth_rx_adapter_queue_conf queue_config = {0};
 713
 714         ev.queue_id = 0;
 715         ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 716         ev.priority = 0;
 717
 718         queue_config.rx_queue_flags = 0;
 719         queue_config.ev = ev;
 720         queue_config.servicing_weight = 1;
 721
 722         /* stop eth devices for existing */
 723         port_index = 0;
 724         for (; port_index < rte_eth_dev_count_total(); port_index += 1) {
 725                 err = rte_eth_dev_stop(port_index);
 726                 TEST_ASSERT(err == 0, "Failed to stop port %u: %d\n",
 727                                         port_index, err);
 728         }
 729
 730         /* add the max port for rx_adapter */
 731         port_index = rte_eth_dev_count_total();
 732         port_index_base = port_index;
 733         for (; port_index < RTE_MAX_ETHPORTS; port_index += 1) {
 734                 snprintf(driver_name, sizeof(driver_name), "%s%u", "net_null",
 735                                 drv_id);
 736                 err = rte_vdev_init(driver_name, NULL);
 737                 TEST_ASSERT(err == 0, "Failed driver %s got %d",
 738                 driver_name, err);
 739                 drv_id += 1;
 740         }
 741
 742         err = init_ports(rte_eth_dev_count_total());
 743         TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err);
 744
 745         /* eth_rx_adapter_queue_add for n ports */
 746         port_index = 0;
 747         for (; port_index < rte_eth_dev_count_total(); port_index += 1) {
 748                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 749                                 port_index, -1,
 750                                 &queue_config);
 751                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 752         }
 753
 754         /* eth_rx_adapter_queue_del n ports */
 755         port_index = 0;
 756         for (; port_index < rte_eth_dev_count_total(); port_index += 1) {
 757                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 758                                 port_index, -1);
 759                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 760         }
 761
 762         /* delete vdev ports */
 763         for (drv_id = 0, port_index = port_index_base;
 764              port_index < RTE_MAX_ETHPORTS;
 765              drv_id += 1, port_index += 1) {
 766                 snprintf(driver_name, sizeof(driver_name), "%s%u", "net_null",
 767                                 drv_id);
 768                 err = rte_vdev_uninit(driver_name);
 769                 TEST_ASSERT(err == 0, "Failed driver %s got %d",
 770                             driver_name, err);
 771         }
 772
 773         return TEST_SUCCESS;
 774 }
 775
 776 static int
 777 adapter_intr_queue_add_del(void)
 778 {
 779         int err;
 780         struct rte_event ev;
 781         uint32_t cap;
 782         uint16_t eth_port;
 783         struct rte_event_eth_rx_adapter_queue_conf queue_config = {0};
 784
 785         if (!default_params.rx_intr_port_inited)
 786                 return 0;
 787
 788         eth_port = default_params.rx_intr_port;
 789         err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, eth_port, &cap);
 790         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 791
 792         ev.queue_id = 0;
 793         ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 794         ev.priority = 0;
 795
 796         queue_config.rx_queue_flags = 0;
 797         queue_config.ev = ev;
 798
 799         /* weight = 0 => interrupt mode */
 800         queue_config.servicing_weight = 0;
 801
 802         if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) {
 803                 /* add queue 0 */
 804                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 805                                                         TEST_ETHDEV_ID, 0,
 806                                                         &queue_config);
 807                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 808         }
 809
 810         /* add all queues */
 811         queue_config.servicing_weight = 0;
 812         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 813                                                 TEST_ETHDEV_ID,
 814                                                 -1,
 815                                                 &queue_config);
 816         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 817
 818         if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) {
 819                 /* del queue 0 */
 820                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 821                                                         TEST_ETHDEV_ID,
 822                                                         0);
 823                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 824         }
 825
 826         /* del remaining queues */
 827         err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 828                                                 TEST_ETHDEV_ID,
 829                                                 -1);
 830         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 831
 832         /* add all queues */
 833         queue_config.servicing_weight = 0;
 834         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 835                                                 TEST_ETHDEV_ID,
 836                                                 -1,
 837                                                 &queue_config);
 838         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 839
 840         /* intr -> poll mode queue */
 841         queue_config.servicing_weight = 1;
 842
 843         if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) {
 844                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 845                                                         TEST_ETHDEV_ID,
 846                                                         0,
 847                                                         &queue_config);
 848                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 849         }
 850
 851         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 852                                                 TEST_ETHDEV_ID,
 853                                                 -1,
 854                                                  &queue_config);
 855         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 856
 857         /* del queues */
 858         err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 859                                                 TEST_ETHDEV_ID,
 860                                                 -1);
 861         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 862
 863         return TEST_SUCCESS;
 864 }
 865
 866 static int
 867 adapter_start_stop(void)
 868 {
 869         int err;
 870         struct rte_event ev;
 871
 872         ev.queue_id = 0;
 873         ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 874         ev.priority = 0;
 875
 876         struct rte_event_eth_rx_adapter_queue_conf queue_config = {0};
 877
 878         queue_config.rx_queue_flags = 0;
 879         if (default_params.caps &
 880                 RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) {
 881                 ev.flow_id = 1;
 882                 queue_config.rx_queue_flags =
 883                         RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID;
 884         }
 885
 886         queue_config.ev = ev;
 887         queue_config.servicing_weight = 1;
 888
 889         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, TEST_ETHDEV_ID,
 890                                         -1, &queue_config);
 891         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 892
 893         err = rte_event_eth_rx_adapter_start(TEST_INST_ID);
 894         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 895
 896         err = rte_event_eth_rx_adapter_stop(TEST_INST_ID);
 897         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 898
 899         err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, TEST_ETHDEV_ID,
 900                                                 -1);
 901         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 902
 903         err = rte_event_eth_rx_adapter_start(TEST_INST_ID);
 904         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 905
 906         err = rte_event_eth_rx_adapter_stop(TEST_INST_ID);
 907         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 908
 909         err = rte_event_eth_rx_adapter_start(1);
 910         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 911
 912         err = rte_event_eth_rx_adapter_stop(1);
 913         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 914
 915         return TEST_SUCCESS;
 916 }
 917
 918 static int
 919 adapter_stats(void)
 920 {
 921         int err;
 922         struct rte_event_eth_rx_adapter_stats stats;
 923
 924         err = rte_event_eth_rx_adapter_stats_get(TEST_INST_ID, NULL);
 925         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 926
 927         err = rte_event_eth_rx_adapter_stats_get(TEST_INST_ID, &stats);
 928         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 929
 930         err = rte_event_eth_rx_adapter_stats_get(1, &stats);
 931         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 932
 933         return TEST_SUCCESS;
 934 }
 935
 936 static int
 937 adapter_queue_conf(void)
 938 {
 939         int err;
 940         struct rte_event_eth_rx_adapter_queue_conf queue_conf = {0};
 941
 942         /* Case 1: queue conf get without any queues in Rx adapter */
 943         err = rte_event_eth_rx_adapter_queue_conf_get(TEST_INST_ID,
 944                                                       TEST_ETHDEV_ID,
 945                                                       0, &queue_conf);
 946         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 947
 948         /* Add queue to Rx adapter */
 949         queue_conf.ev.queue_id = 0;
 950         queue_conf.ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 951         queue_conf.ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL;
 952
 953         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 954                                                  TEST_ETHDEV_ID,
 955                                                  0, &queue_conf);
 956         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 957
 958         /* Case 2: queue conf get with queue added to Rx adapter */
 959         err = rte_event_eth_rx_adapter_queue_conf_get(TEST_INST_ID,
 960                                                       TEST_ETHDEV_ID,
 961                                                       0, &queue_conf);
 962         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 963
 964         /* Case 3: queue conf get with invalid rx queue id */
 965         err = rte_event_eth_rx_adapter_queue_conf_get(TEST_INST_ID,
 966                                                       TEST_ETHDEV_ID,
 967                                                       -1, &queue_conf);
 968         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 969
 970         /* Case 4: queue conf get with NULL queue conf struct */
 971         err = rte_event_eth_rx_adapter_queue_conf_get(TEST_INST_ID,
 972                                                       TEST_ETHDEV_ID,
 973                                                       0, NULL);
 974         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 975
 976         /* Delete queue from the Rx adapter */
 977         err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 978                                                  TEST_ETHDEV_ID,
 979                                                  0);
 980         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 981
 982         return TEST_SUCCESS;
 983 }
 984
 985 static struct unit_test_suite event_eth_rx_tests = {
 986         .suite_name = "rx event eth adapter test suite",
 987         .setup = testsuite_setup,
 988         .teardown = testsuite_teardown,
 989         .unit_test_cases = {
 990                 TEST_CASE_ST(NULL, NULL, adapter_create_free),
 991                 TEST_CASE_ST(NULL, NULL, adapter_create_free_with_params),
 992                 TEST_CASE_ST(adapter_create, adapter_free,
 993                                         adapter_queue_add_del),
 994                 TEST_CASE_ST(adapter_create, adapter_free,
 995                                         adapter_multi_eth_add_del),
 996                 TEST_CASE_ST(adapter_create, adapter_free, adapter_start_stop),
 997                 TEST_CASE_ST(adapter_create, adapter_free, adapter_stats),
 998                 TEST_CASE_ST(adapter_create, adapter_free, adapter_queue_conf),
 999                 TEST_CASE_ST(adapter_create_with_params, adapter_free,
1000                              adapter_queue_event_buf_test),
1001                 TEST_CASE_ST(adapter_create_with_params, adapter_free,
1002                              adapter_queue_stats_test),
1003                 TEST_CASES_END() /**< NULL terminate unit test array */
1004         }
1005 };
1006
1007 static struct unit_test_suite event_eth_rx_intr_tests = {
1008         .suite_name = "rx event eth adapter test suite",
1009         .setup = testsuite_setup_rx_intr,
1010         .teardown = testsuite_teardown_rx_intr,
1011         .unit_test_cases = {
1012                 TEST_CASE_ST(adapter_create, adapter_free,
1013                         adapter_intr_queue_add_del),
1014                 TEST_CASES_END() /**< NULL terminate unit test array */
1015         }
1016 };
1017
1018 static int
1019 test_event_eth_rx_adapter_common(void)
1020 {
1021         return unit_test_suite_runner(&event_eth_rx_tests);
1022 }
1023
1024 static int
1025 test_event_eth_rx_intr_adapter_common(void)
1026 {
1027         return unit_test_suite_runner(&event_eth_rx_intr_tests);
1028 }
1029
1030 REGISTER_TEST_COMMAND(event_eth_rx_adapter_autotest,
1031                 test_event_eth_rx_adapter_common);
1032 REGISTER_TEST_COMMAND(event_eth_rx_intr_adapter_autotest,
1033                 test_event_eth_rx_intr_adapter_common);