test/test/test_event_eth_rx_adapter.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2017 Intel Corporation. All rights reserved.
   5  *
   6  *   Redistribution and use in source and binary forms, with or without
   7  *   modification, are permitted provided that the following conditions
   8  *   are met:
   9  *
  10  *     * Redistributions of source code must retain the above copyright
  11  *       notice, this list of conditions and the following disclaimer.
  12  *     * Redistributions in binary form must reproduce the above copyright
  13  *       notice, this list of conditions and the following disclaimer in
  14  *       the documentation and/or other materials provided with the
  15  *       distribution.
  16  *     * Neither the name of Intel Corporation nor the names of its
  17  *       contributors may be used to endorse or promote products derived
  18  *       from this software without specific prior written permission.
  19  *
  20  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  23  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  30  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32 #include <string.h>
  33 #include <rte_common.h>
  34 #include <rte_mempool.h>
  35 #include <rte_mbuf.h>
  36 #include <rte_ethdev.h>
  37 #include <rte_eventdev.h>
  38 #include <rte_bus_vdev.h>
  39
  40 #include <rte_event_eth_rx_adapter.h>
  41
  42 #include "test.h"
  43
  44 #define MAX_NUM_RX_QUEUE        64
  45 #define NB_MBUFS                (8192 * num_ports * MAX_NUM_RX_QUEUE)
  46 #define MBUF_CACHE_SIZE         512
  47 #define MBUF_PRIV_SIZE          0
  48 #define TEST_INST_ID            0
  49 #define TEST_DEV_ID             0
  50 #define TEST_ETHDEV_ID          0
  51
  52 struct event_eth_rx_adapter_test_params {
  53         struct rte_mempool *mp;
  54         uint16_t rx_rings, tx_rings;
  55         uint32_t caps;
  56 };
  57
  58 static struct event_eth_rx_adapter_test_params default_params;
  59
  60 static inline int
  61 port_init(uint8_t port, struct rte_mempool *mp)
  62 {
  63         static const struct rte_eth_conf port_conf_default = {
  64                 .rxmode = {
  65                         .mq_mode = ETH_MQ_RX_RSS,
  66                         .max_rx_pkt_len = ETHER_MAX_LEN
  67                 },
  68                 .rx_adv_conf = {
  69                         .rss_conf = {
  70                                 .rss_hf = ETH_RSS_IP |
  71                                           ETH_RSS_TCP |
  72                                           ETH_RSS_UDP,
  73                         }
  74                 }
  75         };
  76         const uint16_t rx_ring_size = 512, tx_ring_size = 512;
  77         struct rte_eth_conf port_conf = port_conf_default;
  78         int retval;
  79         uint16_t q;
  80         struct rte_eth_dev_info dev_info;
  81
  82         if (port >= rte_eth_dev_count())
  83                 return -1;
  84
  85         retval = rte_eth_dev_configure(port, 0, 0, &port_conf);
  86
  87         rte_eth_dev_info_get(port, &dev_info);
  88
  89         default_params.rx_rings = RTE_MIN(dev_info.max_rx_queues,
  90                                         MAX_NUM_RX_QUEUE);
  91         default_params.tx_rings = 1;
  92
  93         /* Configure the Ethernet device. */
  94         retval = rte_eth_dev_configure(port, default_params.rx_rings,
  95                                 default_params.tx_rings, &port_conf);
  96         if (retval != 0)
  97                 return retval;
  98
  99         for (q = 0; q < default_params.rx_rings; q++) {
 100                 retval = rte_eth_rx_queue_setup(port, q, rx_ring_size,
 101                                 rte_eth_dev_socket_id(port), NULL, mp);
 102                 if (retval < 0)
 103                         return retval;
 104         }
 105
 106         /* Allocate and set up 1 TX queue per Ethernet port. */
 107         for (q = 0; q < default_params.tx_rings; q++) {
 108                 retval = rte_eth_tx_queue_setup(port, q, tx_ring_size,
 109                                 rte_eth_dev_socket_id(port), NULL);
 110                 if (retval < 0)
 111                         return retval;
 112         }
 113
 114         /* Start the Ethernet port. */
 115         retval = rte_eth_dev_start(port);
 116         if (retval < 0)
 117                 return retval;
 118
 119         /* Display the port MAC address. */
 120         struct ether_addr addr;
 121         rte_eth_macaddr_get(port, &addr);
 122         printf("Port %u MAC: %02" PRIx8 " %02" PRIx8 " %02" PRIx8
 123                            " %02" PRIx8 " %02" PRIx8 " %02" PRIx8 "\n",
 124                         (unsigned int)port,
 125                         addr.addr_bytes[0], addr.addr_bytes[1],
 126                         addr.addr_bytes[2], addr.addr_bytes[3],
 127                         addr.addr_bytes[4], addr.addr_bytes[5]);
 128
 129         /* Enable RX in promiscuous mode for the Ethernet device. */
 130         rte_eth_promiscuous_enable(port);
 131
 132         return 0;
 133 }
 134
 135 static int
 136 init_ports(int num_ports)
 137 {
 138         uint8_t portid;
 139         int retval;
 140
 141         default_params.mp = rte_pktmbuf_pool_create("packet_pool",
 142                                                 NB_MBUFS,
 143                                                 MBUF_CACHE_SIZE,
 144                                                 MBUF_PRIV_SIZE,
 145                                                 RTE_MBUF_DEFAULT_BUF_SIZE,
 146                                                 rte_socket_id());
 147         if (!default_params.mp)
 148                 return -ENOMEM;
 149
 150         for (portid = 0; portid < num_ports; portid++) {
 151                 retval = port_init(portid, default_params.mp);
 152                 if (retval)
 153                         return retval;
 154         }
 155
 156         return 0;
 157 }
 158
 159 static int
 160 testsuite_setup(void)
 161 {
 162         int err;
 163         uint8_t count;
 164         struct rte_event_dev_info dev_info;
 165
 166         count = rte_event_dev_count();
 167         if (!count) {
 168                 printf("Failed to find a valid event device,"
 169                         " testing with event_skeleton device\n");
 170                 rte_vdev_init("event_skeleton", NULL);
 171         }
 172
 173         struct rte_event_dev_config config = {
 174                         .nb_event_queues = 1,
 175                         .nb_event_ports = 1,
 176         };
 177
 178         err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
 179         config.nb_event_queue_flows = dev_info.max_event_queue_flows;
 180         config.nb_event_port_dequeue_depth =
 181                         dev_info.max_event_port_dequeue_depth;
 182         config.nb_event_port_enqueue_depth =
 183                         dev_info.max_event_port_enqueue_depth;
 184         config.nb_events_limit =
 185                         dev_info.max_num_events;
 186         err = rte_event_dev_configure(TEST_DEV_ID, &config);
 187         TEST_ASSERT(err == 0, "Event device initialization failed err %d\n",
 188                         err);
 189
 190         /*
 191          * eth devices like octeontx use event device to receive packets
 192          * so rte_eth_dev_start invokes rte_event_dev_start internally, so
 193          * call init_ports after rte_event_dev_configure
 194          */
 195         err = init_ports(rte_eth_dev_count());
 196         TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err);
 197
 198         err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID,
 199                                                 &default_params.caps);
 200         TEST_ASSERT(err == 0, "Failed to get adapter cap err %d\n",
 201                         err);
 202
 203         return err;
 204 }
 205
 206 static void
 207 testsuite_teardown(void)
 208 {
 209         uint32_t i;
 210         for (i = 0; i < rte_eth_dev_count(); i++)
 211                 rte_eth_dev_stop(i);
 212
 213         rte_mempool_free(default_params.mp);
 214 }
 215
 216 static int
 217 adapter_create(void)
 218 {
 219         int err;
 220         struct rte_event_dev_info dev_info;
 221         struct rte_event_port_conf rx_p_conf;
 222
 223         err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
 224         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 225
 226         rx_p_conf.new_event_threshold = dev_info.max_num_events;
 227         rx_p_conf.dequeue_depth = dev_info.max_event_port_dequeue_depth;
 228         rx_p_conf.enqueue_depth = dev_info.max_event_port_enqueue_depth;
 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         return err;
 234 }
 235
 236 static void
 237 adapter_free(void)
 238 {
 239         rte_event_eth_rx_adapter_free(TEST_INST_ID);
 240 }
 241
 242 static int
 243 adapter_create_free(void)
 244 {
 245         int err;
 246
 247         struct rte_event_port_conf rx_p_conf = {
 248                         .dequeue_depth = 8,
 249                         .enqueue_depth = 8,
 250                         .new_event_threshold = 1200,
 251         };
 252
 253         err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
 254                                         NULL);
 255         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 256
 257         err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
 258                                         &rx_p_conf);
 259         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 260
 261         err = rte_event_eth_rx_adapter_create(TEST_INST_ID,
 262                                         TEST_DEV_ID, &rx_p_conf);
 263         TEST_ASSERT(err == -EEXIST, "Expected -EEXIST %d got %d", -EEXIST, err);
 264
 265         err = rte_event_eth_rx_adapter_free(TEST_INST_ID);
 266         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 267
 268         err = rte_event_eth_rx_adapter_free(TEST_INST_ID);
 269         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
 270
 271         err = rte_event_eth_rx_adapter_free(1);
 272         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
 273
 274         return TEST_SUCCESS;
 275 }
 276
 277 static int
 278 adapter_queue_add_del(void)
 279 {
 280         int err;
 281         struct rte_event ev;
 282         uint32_t cap;
 283
 284         struct rte_event_eth_rx_adapter_queue_conf queue_config;
 285
 286         err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID,
 287                                          &cap);
 288         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 289
 290         ev.queue_id = 0;
 291         ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 292         ev.priority = 0;
 293
 294         queue_config.rx_queue_flags = 0;
 295         if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) {
 296                 ev.flow_id = 1;
 297                 queue_config.rx_queue_flags =
 298                         RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID;
 299         }
 300         queue_config.ev = ev;
 301         queue_config.servicing_weight = 1;
 302
 303         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 304                                                 rte_eth_dev_count(),
 305                                                 -1, &queue_config);
 306         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 307
 308         if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) {
 309                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 310                                                         TEST_ETHDEV_ID, 0,
 311                                                         &queue_config);
 312                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 313
 314                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 315                                                         TEST_ETHDEV_ID, 0);
 316                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 317
 318                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 319                                                         TEST_ETHDEV_ID,
 320                                                         -1,
 321                                                         &queue_config);
 322                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 323
 324                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 325                                                         TEST_ETHDEV_ID,
 326                                                         -1);
 327                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 328         } else {
 329                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 330                                                         TEST_ETHDEV_ID,
 331                                                         0,
 332                                                         &queue_config);
 333                 TEST_ASSERT(err == -EINVAL, "Expected EINVAL got %d", err);
 334
 335                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 336                                                         TEST_ETHDEV_ID, -1,
 337                                                         &queue_config);
 338                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 339
 340                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 341                                                         TEST_ETHDEV_ID, 0);
 342                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 343
 344                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 345                                                         TEST_ETHDEV_ID, -1);
 346                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 347
 348                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 349                                                         TEST_ETHDEV_ID, -1);
 350                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 351         }
 352
 353         err = rte_event_eth_rx_adapter_queue_add(1, TEST_ETHDEV_ID, -1,
 354                                                 &queue_config);
 355         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 356
 357         err = rte_event_eth_rx_adapter_queue_del(1, TEST_ETHDEV_ID, -1);
 358         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 359
 360         return TEST_SUCCESS;
 361 }
 362
 363 static int
 364 adapter_start_stop(void)
 365 {
 366         int err;
 367         struct rte_event ev;
 368
 369         ev.queue_id = 0;
 370         ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 371         ev.priority = 0;
 372
 373         struct rte_event_eth_rx_adapter_queue_conf queue_config;
 374
 375         queue_config.rx_queue_flags = 0;
 376         if (default_params.caps &
 377                 RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) {
 378                 ev.flow_id = 1;
 379                 queue_config.rx_queue_flags =
 380                         RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID;
 381         }
 382
 383         queue_config.ev = ev;
 384         queue_config.servicing_weight = 1;
 385
 386         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, TEST_ETHDEV_ID,
 387                                         -1, &queue_config);
 388         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 389
 390         err = rte_event_eth_rx_adapter_start(TEST_INST_ID);
 391         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 392
 393         err = rte_event_eth_rx_adapter_stop(TEST_INST_ID);
 394         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 395
 396         err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, TEST_ETHDEV_ID,
 397                                                 -1);
 398         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 399
 400         err = rte_event_eth_rx_adapter_start(TEST_INST_ID);
 401         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 402
 403         err = rte_event_eth_rx_adapter_stop(TEST_INST_ID);
 404         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 405
 406         err = rte_event_eth_rx_adapter_start(1);
 407         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 408
 409         err = rte_event_eth_rx_adapter_stop(1);
 410         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 411
 412         return TEST_SUCCESS;
 413 }
 414
 415 static int
 416 adapter_stats(void)
 417 {
 418         int err;
 419         struct rte_event_eth_rx_adapter_stats stats;
 420
 421         err = rte_event_eth_rx_adapter_stats_get(TEST_INST_ID, NULL);
 422         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 423
 424         err = rte_event_eth_rx_adapter_stats_get(TEST_INST_ID, &stats);
 425         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 426
 427         err = rte_event_eth_rx_adapter_stats_get(1, &stats);
 428         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 429
 430         return TEST_SUCCESS;
 431 }
 432
 433 static struct unit_test_suite service_tests  = {
 434         .suite_name = "rx event eth adapter test suite",
 435         .setup = testsuite_setup,
 436         .teardown = testsuite_teardown,
 437         .unit_test_cases = {
 438                 TEST_CASE_ST(NULL, NULL, adapter_create_free),
 439                 TEST_CASE_ST(adapter_create, adapter_free,
 440                                         adapter_queue_add_del),
 441                 TEST_CASE_ST(adapter_create, adapter_free, adapter_start_stop),
 442                 TEST_CASE_ST(adapter_create, adapter_free, adapter_stats),
 443                 TEST_CASES_END() /**< NULL terminate unit test array */
 444         }
 445 };
 446
 447 static int
 448 test_event_eth_rx_adapter_common(void)
 449 {
 450         return unit_test_suite_runner(&service_tests);
 451 }
 452
 453 REGISTER_TEST_COMMAND(event_eth_rx_adapter_autotest,
 454                 test_event_eth_rx_adapter_common);