test/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 };
  29
  30 static struct event_eth_rx_adapter_test_params default_params;
  31
  32 static inline int
  33 port_init(uint8_t port, struct rte_mempool *mp)
  34 {
  35         static const struct rte_eth_conf port_conf_default = {
  36                 .rxmode = {
  37                         .mq_mode = ETH_MQ_RX_RSS,
  38                         .max_rx_pkt_len = ETHER_MAX_LEN
  39                 },
  40                 .rx_adv_conf = {
  41                         .rss_conf = {
  42                                 .rss_hf = ETH_RSS_IP |
  43                                           ETH_RSS_TCP |
  44                                           ETH_RSS_UDP,
  45                         }
  46                 }
  47         };
  48         const uint16_t rx_ring_size = 512, tx_ring_size = 512;
  49         struct rte_eth_conf port_conf = port_conf_default;
  50         int retval;
  51         uint16_t q;
  52         struct rte_eth_dev_info dev_info;
  53
  54         if (port >= rte_eth_dev_count())
  55                 return -1;
  56
  57         retval = rte_eth_dev_configure(port, 0, 0, &port_conf);
  58
  59         rte_eth_dev_info_get(port, &dev_info);
  60
  61         default_params.rx_rings = RTE_MIN(dev_info.max_rx_queues,
  62                                         MAX_NUM_RX_QUEUE);
  63         default_params.tx_rings = 1;
  64
  65         /* Configure the Ethernet device. */
  66         retval = rte_eth_dev_configure(port, default_params.rx_rings,
  67                                 default_params.tx_rings, &port_conf);
  68         if (retval != 0)
  69                 return retval;
  70
  71         for (q = 0; q < default_params.rx_rings; q++) {
  72                 retval = rte_eth_rx_queue_setup(port, q, rx_ring_size,
  73                                 rte_eth_dev_socket_id(port), NULL, mp);
  74                 if (retval < 0)
  75                         return retval;
  76         }
  77
  78         /* Allocate and set up 1 TX queue per Ethernet port. */
  79         for (q = 0; q < default_params.tx_rings; q++) {
  80                 retval = rte_eth_tx_queue_setup(port, q, tx_ring_size,
  81                                 rte_eth_dev_socket_id(port), NULL);
  82                 if (retval < 0)
  83                         return retval;
  84         }
  85
  86         /* Start the Ethernet port. */
  87         retval = rte_eth_dev_start(port);
  88         if (retval < 0)
  89                 return retval;
  90
  91         /* Display the port MAC address. */
  92         struct ether_addr addr;
  93         rte_eth_macaddr_get(port, &addr);
  94         printf("Port %u MAC: %02" PRIx8 " %02" PRIx8 " %02" PRIx8
  95                            " %02" PRIx8 " %02" PRIx8 " %02" PRIx8 "\n",
  96                         (unsigned int)port,
  97                         addr.addr_bytes[0], addr.addr_bytes[1],
  98                         addr.addr_bytes[2], addr.addr_bytes[3],
  99                         addr.addr_bytes[4], addr.addr_bytes[5]);
 100
 101         /* Enable RX in promiscuous mode for the Ethernet device. */
 102         rte_eth_promiscuous_enable(port);
 103
 104         return 0;
 105 }
 106
 107 static int
 108 init_ports(int num_ports)
 109 {
 110         uint8_t portid;
 111         int retval;
 112
 113         default_params.mp = rte_pktmbuf_pool_create("packet_pool",
 114                                                 NB_MBUFS,
 115                                                 MBUF_CACHE_SIZE,
 116                                                 MBUF_PRIV_SIZE,
 117                                                 RTE_MBUF_DEFAULT_BUF_SIZE,
 118                                                 rte_socket_id());
 119         if (!default_params.mp)
 120                 return -ENOMEM;
 121
 122         for (portid = 0; portid < num_ports; portid++) {
 123                 retval = port_init(portid, default_params.mp);
 124                 if (retval)
 125                         return retval;
 126         }
 127
 128         return 0;
 129 }
 130
 131 static int
 132 testsuite_setup(void)
 133 {
 134         int err;
 135         uint8_t count;
 136         struct rte_event_dev_info dev_info;
 137
 138         count = rte_event_dev_count();
 139         if (!count) {
 140                 printf("Failed to find a valid event device,"
 141                         " testing with event_skeleton device\n");
 142                 rte_vdev_init("event_skeleton", NULL);
 143         }
 144
 145         struct rte_event_dev_config config = {
 146                         .nb_event_queues = 1,
 147                         .nb_event_ports = 1,
 148         };
 149
 150         err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
 151         config.nb_event_queue_flows = dev_info.max_event_queue_flows;
 152         config.nb_event_port_dequeue_depth =
 153                         dev_info.max_event_port_dequeue_depth;
 154         config.nb_event_port_enqueue_depth =
 155                         dev_info.max_event_port_enqueue_depth;
 156         config.nb_events_limit =
 157                         dev_info.max_num_events;
 158         err = rte_event_dev_configure(TEST_DEV_ID, &config);
 159         TEST_ASSERT(err == 0, "Event device initialization failed err %d\n",
 160                         err);
 161
 162         /*
 163          * eth devices like octeontx use event device to receive packets
 164          * so rte_eth_dev_start invokes rte_event_dev_start internally, so
 165          * call init_ports after rte_event_dev_configure
 166          */
 167         err = init_ports(rte_eth_dev_count());
 168         TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err);
 169
 170         err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID,
 171                                                 &default_params.caps);
 172         TEST_ASSERT(err == 0, "Failed to get adapter cap err %d\n",
 173                         err);
 174
 175         return err;
 176 }
 177
 178 static void
 179 testsuite_teardown(void)
 180 {
 181         uint32_t i;
 182         for (i = 0; i < rte_eth_dev_count(); i++)
 183                 rte_eth_dev_stop(i);
 184
 185         rte_mempool_free(default_params.mp);
 186 }
 187
 188 static int
 189 adapter_create(void)
 190 {
 191         int err;
 192         struct rte_event_dev_info dev_info;
 193         struct rte_event_port_conf rx_p_conf;
 194
 195         err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
 196         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 197
 198         rx_p_conf.new_event_threshold = dev_info.max_num_events;
 199         rx_p_conf.dequeue_depth = dev_info.max_event_port_dequeue_depth;
 200         rx_p_conf.enqueue_depth = dev_info.max_event_port_enqueue_depth;
 201         err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
 202                                         &rx_p_conf);
 203         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 204
 205         return err;
 206 }
 207
 208 static void
 209 adapter_free(void)
 210 {
 211         rte_event_eth_rx_adapter_free(TEST_INST_ID);
 212 }
 213
 214 static int
 215 adapter_create_free(void)
 216 {
 217         int err;
 218
 219         struct rte_event_port_conf rx_p_conf = {
 220                         .dequeue_depth = 8,
 221                         .enqueue_depth = 8,
 222                         .new_event_threshold = 1200,
 223         };
 224
 225         err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
 226                                         NULL);
 227         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 228
 229         err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
 230                                         &rx_p_conf);
 231         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 232
 233         err = rte_event_eth_rx_adapter_create(TEST_INST_ID,
 234                                         TEST_DEV_ID, &rx_p_conf);
 235         TEST_ASSERT(err == -EEXIST, "Expected -EEXIST %d got %d", -EEXIST, err);
 236
 237         err = rte_event_eth_rx_adapter_free(TEST_INST_ID);
 238         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 239
 240         err = rte_event_eth_rx_adapter_free(TEST_INST_ID);
 241         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
 242
 243         err = rte_event_eth_rx_adapter_free(1);
 244         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
 245
 246         return TEST_SUCCESS;
 247 }
 248
 249 static int
 250 adapter_queue_add_del(void)
 251 {
 252         int err;
 253         struct rte_event ev;
 254         uint32_t cap;
 255
 256         struct rte_event_eth_rx_adapter_queue_conf queue_config;
 257
 258         err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID,
 259                                          &cap);
 260         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 261
 262         ev.queue_id = 0;
 263         ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 264         ev.priority = 0;
 265
 266         queue_config.rx_queue_flags = 0;
 267         if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) {
 268                 ev.flow_id = 1;
 269                 queue_config.rx_queue_flags =
 270                         RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID;
 271         }
 272         queue_config.ev = ev;
 273         queue_config.servicing_weight = 1;
 274
 275         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 276                                                 rte_eth_dev_count(),
 277                                                 -1, &queue_config);
 278         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 279
 280         if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) {
 281                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 282                                                         TEST_ETHDEV_ID, 0,
 283                                                         &queue_config);
 284                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 285
 286                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 287                                                         TEST_ETHDEV_ID, 0);
 288                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 289
 290                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 291                                                         TEST_ETHDEV_ID,
 292                                                         -1,
 293                                                         &queue_config);
 294                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 295
 296                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 297                                                         TEST_ETHDEV_ID,
 298                                                         -1);
 299                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 300         } else {
 301                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 302                                                         TEST_ETHDEV_ID,
 303                                                         0,
 304                                                         &queue_config);
 305                 TEST_ASSERT(err == -EINVAL, "Expected EINVAL got %d", err);
 306
 307                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 308                                                         TEST_ETHDEV_ID, -1,
 309                                                         &queue_config);
 310                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 311
 312                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 313                                                         TEST_ETHDEV_ID, 0);
 314                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 315
 316                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 317                                                         TEST_ETHDEV_ID, -1);
 318                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 319
 320                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 321                                                         TEST_ETHDEV_ID, -1);
 322                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 323         }
 324
 325         err = rte_event_eth_rx_adapter_queue_add(1, TEST_ETHDEV_ID, -1,
 326                                                 &queue_config);
 327         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 328
 329         err = rte_event_eth_rx_adapter_queue_del(1, TEST_ETHDEV_ID, -1);
 330         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 331
 332         return TEST_SUCCESS;
 333 }
 334
 335 static int
 336 adapter_start_stop(void)
 337 {
 338         int err;
 339         struct rte_event ev;
 340
 341         ev.queue_id = 0;
 342         ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 343         ev.priority = 0;
 344
 345         struct rte_event_eth_rx_adapter_queue_conf queue_config;
 346
 347         queue_config.rx_queue_flags = 0;
 348         if (default_params.caps &
 349                 RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) {
 350                 ev.flow_id = 1;
 351                 queue_config.rx_queue_flags =
 352                         RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID;
 353         }
 354
 355         queue_config.ev = ev;
 356         queue_config.servicing_weight = 1;
 357
 358         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, TEST_ETHDEV_ID,
 359                                         -1, &queue_config);
 360         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 361
 362         err = rte_event_eth_rx_adapter_start(TEST_INST_ID);
 363         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 364
 365         err = rte_event_eth_rx_adapter_stop(TEST_INST_ID);
 366         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 367
 368         err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, TEST_ETHDEV_ID,
 369                                                 -1);
 370         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 371
 372         err = rte_event_eth_rx_adapter_start(TEST_INST_ID);
 373         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 374
 375         err = rte_event_eth_rx_adapter_stop(TEST_INST_ID);
 376         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 377
 378         err = rte_event_eth_rx_adapter_start(1);
 379         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 380
 381         err = rte_event_eth_rx_adapter_stop(1);
 382         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 383
 384         return TEST_SUCCESS;
 385 }
 386
 387 static int
 388 adapter_stats(void)
 389 {
 390         int err;
 391         struct rte_event_eth_rx_adapter_stats stats;
 392
 393         err = rte_event_eth_rx_adapter_stats_get(TEST_INST_ID, NULL);
 394         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 395
 396         err = rte_event_eth_rx_adapter_stats_get(TEST_INST_ID, &stats);
 397         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 398
 399         err = rte_event_eth_rx_adapter_stats_get(1, &stats);
 400         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 401
 402         return TEST_SUCCESS;
 403 }
 404
 405 static struct unit_test_suite service_tests  = {
 406         .suite_name = "rx event eth adapter test suite",
 407         .setup = testsuite_setup,
 408         .teardown = testsuite_teardown,
 409         .unit_test_cases = {
 410                 TEST_CASE_ST(NULL, NULL, adapter_create_free),
 411                 TEST_CASE_ST(adapter_create, adapter_free,
 412                                         adapter_queue_add_del),
 413                 TEST_CASE_ST(adapter_create, adapter_free, adapter_start_stop),
 414                 TEST_CASE_ST(adapter_create, adapter_free, adapter_stats),
 415                 TEST_CASES_END() /**< NULL terminate unit test array */
 416         }
 417 };
 418
 419 static int
 420 test_event_eth_rx_adapter_common(void)
 421 {
 422         return unit_test_suite_runner(&service_tests);
 423 }
 424
 425 REGISTER_TEST_COMMAND(event_eth_rx_adapter_autotest,
 426                 test_event_eth_rx_adapter_common);