LCOV - code coverage report
Current view: top level - app/test - test_event_eth_tx_adapter.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 410 417 98.3 %
Date: 2024-02-14 00:53:57 Functions: 19 19 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 184 334 55.1 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright(c) 2018 Intel Corporation
       3                 :            :  */
       4                 :            : 
       5                 :            : #include <string.h>
       6                 :            : 
       7                 :            : #include <rte_bus_vdev.h>
       8                 :            : #include <rte_common.h>
       9                 :            : #include <rte_ethdev.h>
      10                 :            : #include <rte_eth_ring.h>
      11                 :            : #include <rte_eventdev.h>
      12                 :            : #include <rte_event_eth_tx_adapter.h>
      13                 :            : #include <rte_mbuf.h>
      14                 :            : #include <rte_mempool.h>
      15                 :            : #include <rte_service.h>
      16                 :            : 
      17                 :            : #include "test.h"
      18                 :            : 
      19                 :            : #ifdef RTE_EXEC_ENV_WINDOWS
      20                 :            : static int
      21                 :            : test_event_eth_tx_adapter_common(void)
      22                 :            : {
      23                 :            :         printf("event_eth_tx_adapter not supported on Windows, skipping test\n");
      24                 :            :         return TEST_SKIPPED;
      25                 :            : }
      26                 :            : 
      27                 :            : #else
      28                 :            : 
      29                 :            : #define MAX_NUM_QUEUE           RTE_PMD_RING_MAX_RX_RINGS
      30                 :            : #define TEST_INST_ID            0
      31                 :            : #define TEST_DEV_ID             0
      32                 :            : #define TEST_ETH_QUEUE_ID       0
      33                 :            : #define SOCKET0                 0
      34                 :            : #define RING_SIZE               256
      35                 :            : #define ETH_NAME_LEN            32
      36                 :            : #define NUM_ETH_PAIR            1
      37                 :            : #define NUM_ETH_DEV             (2 * NUM_ETH_PAIR)
      38                 :            : #define NB_MBUF                 512
      39                 :            : #define PAIR_PORT_INDEX(p)      ((p) + NUM_ETH_PAIR)
      40                 :            : #define PORT(p)                 default_params.port[(p)]
      41                 :            : #define TEST_ETHDEV_ID          PORT(0)
      42                 :            : #define TEST_ETHDEV_PAIR_ID     PORT(PAIR_PORT_INDEX(0))
      43                 :            : #define DEFAULT_FLUSH_THRESHOLD 1024
      44                 :            : #define TXA_NB_TX_WORK_DEFAULT  128
      45                 :            : 
      46                 :            : #define EDEV_RETRY              0xffff
      47                 :            : 
      48                 :            : struct event_eth_tx_adapter_test_params {
      49                 :            :         struct rte_mempool *mp;
      50                 :            :         uint16_t rx_rings, tx_rings;
      51                 :            :         struct rte_ring *r[NUM_ETH_DEV][MAX_NUM_QUEUE];
      52                 :            :         int port[NUM_ETH_DEV];
      53                 :            : };
      54                 :            : 
      55                 :            : static int event_dev_delete;
      56                 :            : static struct event_eth_tx_adapter_test_params default_params;
      57                 :            : static uint64_t eid = ~0ULL;
      58                 :            : static uint32_t tid;
      59                 :            : 
      60                 :            : static inline int
      61                 :          2 : port_init_common(uint16_t port, const struct rte_eth_conf *port_conf,
      62                 :            :                 struct rte_mempool *mp)
      63                 :            : {
      64                 :            :         const uint16_t rx_ring_size = RING_SIZE, tx_ring_size = RING_SIZE;
      65                 :            :         int retval;
      66                 :            :         uint16_t q;
      67                 :            : 
      68         [ +  - ]:          2 :         if (!rte_eth_dev_is_valid_port(port))
      69                 :            :                 return -1;
      70                 :            : 
      71                 :          2 :         default_params.rx_rings = MAX_NUM_QUEUE;
      72                 :          2 :         default_params.tx_rings = MAX_NUM_QUEUE;
      73                 :            : 
      74                 :            :         /* Configure the Ethernet device. */
      75                 :          2 :         retval = rte_eth_dev_configure(port, default_params.rx_rings,
      76                 :            :                                 default_params.tx_rings, port_conf);
      77         [ +  - ]:          2 :         if (retval != 0)
      78                 :            :                 return retval;
      79                 :            : 
      80         [ +  + ]:         34 :         for (q = 0; q < default_params.rx_rings; q++) {
      81                 :         32 :                 retval = rte_eth_rx_queue_setup(port, q, rx_ring_size,
      82                 :         32 :                                 rte_eth_dev_socket_id(port), NULL, mp);
      83         [ -  + ]:         32 :                 if (retval < 0)
      84                 :          0 :                         return retval;
      85                 :            :         }
      86                 :            : 
      87         [ +  + ]:         34 :         for (q = 0; q < default_params.tx_rings; q++) {
      88                 :         32 :                 retval = rte_eth_tx_queue_setup(port, q, tx_ring_size,
      89                 :         32 :                                 rte_eth_dev_socket_id(port), NULL);
      90         [ -  + ]:         32 :                 if (retval < 0)
      91                 :          0 :                         return retval;
      92                 :            :         }
      93                 :            : 
      94                 :            :         /* Start the Ethernet port. */
      95                 :          2 :         retval = rte_eth_dev_start(port);
      96         [ +  - ]:          2 :         if (retval < 0)
      97                 :            :                 return retval;
      98                 :            : 
      99                 :            :         /* Display the port MAC address. */
     100                 :            :         struct rte_ether_addr addr;
     101                 :          2 :         retval = rte_eth_macaddr_get(port, &addr);
     102         [ +  - ]:          2 :         if (retval < 0)
     103                 :            :                 return retval;
     104                 :          2 :         printf("Port %u MAC: %02" PRIx8 " %02" PRIx8 " %02" PRIx8
     105                 :            :                            " %02" PRIx8 " %02" PRIx8 " %02" PRIx8 "\n",
     106                 :          2 :                         (unsigned int)port, RTE_ETHER_ADDR_BYTES(&addr));
     107                 :            : 
     108                 :            :         /* Enable RX in promiscuous mode for the Ethernet device. */
     109                 :          2 :         retval = rte_eth_promiscuous_enable(port);
     110         [ -  + ]:          2 :         if (retval != 0)
     111                 :          0 :                 return retval;
     112                 :            : 
     113                 :            :         return 0;
     114                 :            : }
     115                 :            : 
     116                 :            : static inline int
     117                 :          2 : port_init(uint16_t port, struct rte_mempool *mp)
     118                 :            : {
     119                 :          2 :         struct rte_eth_conf conf = { 0 };
     120                 :          2 :         return port_init_common(port, &conf, mp);
     121                 :            : }
     122                 :            : 
     123                 :            : #define RING_NAME_LEN   20
     124                 :            : #define DEV_NAME_LEN    20
     125                 :            : 
     126                 :            : static int
     127                 :          1 : init_ports(void)
     128                 :            : {
     129                 :            :         char ring_name[ETH_NAME_LEN];
     130                 :            :         unsigned int i, j;
     131                 :            :         struct rte_ring * const *c1;
     132                 :            :         struct rte_ring * const *c2;
     133                 :            :         int err;
     134                 :            : 
     135         [ +  - ]:          1 :         if (!default_params.mp)
     136                 :          1 :                 default_params.mp = rte_pktmbuf_pool_create("mbuf_pool",
     137                 :            :                         NB_MBUF, 32,
     138                 :          1 :                         0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());
     139                 :            : 
     140         [ +  - ]:          1 :         if (!default_params.mp)
     141                 :            :                 return -ENOMEM;
     142                 :            : 
     143         [ +  + ]:          3 :         for (i = 0; i < NUM_ETH_DEV; i++) {
     144         [ +  + ]:         34 :                 for (j = 0; j < MAX_NUM_QUEUE; j++) {
     145                 :            :                         snprintf(ring_name, sizeof(ring_name), "R%u%u", i, j);
     146                 :         32 :                         default_params.r[i][j] = rte_ring_create(ring_name,
     147                 :            :                                                 RING_SIZE,
     148                 :            :                                                 SOCKET0,
     149                 :            :                                                 RING_F_SP_ENQ | RING_F_SC_DEQ);
     150         [ -  + ]:         32 :                         TEST_ASSERT((default_params.r[i][j] != NULL),
     151                 :            :                                 "Failed to allocate ring");
     152                 :            :                 }
     153                 :            :         }
     154                 :            : 
     155                 :            :         /*
     156                 :            :          * To create two pseudo-Ethernet ports where the traffic is
     157                 :            :          * switched between them, that is, traffic sent to port 1 is
     158                 :            :          * read back from port 2 and vice-versa
     159                 :            :          */
     160         [ +  + ]:          2 :         for (i = 0; i < NUM_ETH_PAIR; i++) {
     161                 :            :                 char dev_name[DEV_NAME_LEN];
     162                 :            :                 int p;
     163                 :            : 
     164                 :            :                 c1 = default_params.r[i];
     165                 :            :                 c2 = default_params.r[PAIR_PORT_INDEX(i)];
     166                 :            : 
     167                 :            :                 snprintf(dev_name, DEV_NAME_LEN, "%u-%u", i, i + NUM_ETH_PAIR);
     168                 :          1 :                 p = rte_eth_from_rings(dev_name, c1, MAX_NUM_QUEUE,
     169                 :            :                                  c2, MAX_NUM_QUEUE, SOCKET0);
     170         [ -  + ]:          1 :                 TEST_ASSERT(p >= 0, "Port creation failed %s", dev_name);
     171                 :          1 :                 err = port_init(p, default_params.mp);
     172         [ -  + ]:          1 :                 TEST_ASSERT(err == 0, "Port init failed %s", dev_name);
     173                 :          1 :                 default_params.port[i] = p;
     174                 :            : 
     175                 :            :                 snprintf(dev_name, DEV_NAME_LEN, "%u-%u",  i + NUM_ETH_PAIR, i);
     176                 :          1 :                 p = rte_eth_from_rings(dev_name, c2, MAX_NUM_QUEUE,
     177                 :            :                                 c1, MAX_NUM_QUEUE, SOCKET0);
     178         [ -  + ]:          1 :                 TEST_ASSERT(p > 0, "Port creation failed %s", dev_name);
     179                 :          1 :                 err = port_init(p, default_params.mp);
     180         [ -  + ]:          1 :                 TEST_ASSERT(err == 0, "Port init failed %s", dev_name);
     181                 :          1 :                 default_params.port[PAIR_PORT_INDEX(i)] = p;
     182                 :            :         }
     183                 :            : 
     184                 :            :         return 0;
     185                 :            : }
     186                 :            : 
     187                 :            : static void
     188                 :          1 : deinit_ports(void)
     189                 :            : {
     190                 :            :         uint16_t i, j;
     191                 :            :         char name[ETH_NAME_LEN];
     192                 :            : 
     193         [ +  + ]:          3 :         for (i = 0; i < RTE_DIM(default_params.port); i++) {
     194                 :          2 :                 rte_eth_dev_stop(default_params.port[i]);
     195                 :          2 :                 rte_eth_dev_get_name_by_port(default_params.port[i], name);
     196                 :          2 :                 rte_vdev_uninit(name);
     197         [ +  + ]:         34 :                 for (j = 0; j < RTE_DIM(default_params.r[i]); j++)
     198                 :         32 :                         rte_ring_free(default_params.r[i][j]);
     199                 :            :         }
     200                 :          1 : }
     201                 :            : 
     202                 :            : static int
     203                 :          1 : testsuite_setup(void)
     204                 :            : {
     205                 :            :         const char *vdev_name = "event_sw0";
     206                 :            : 
     207                 :          1 :         int err = init_ports();
     208         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err);
     209                 :            : 
     210         [ +  - ]:          1 :         if (rte_event_dev_count() == 0) {
     211                 :            :                 printf("Failed to find a valid event device,"
     212                 :            :                         " testing with event_sw0 device\n");
     213                 :          1 :                 err = rte_vdev_init(vdev_name, NULL);
     214         [ -  + ]:          1 :                 TEST_ASSERT(err == 0, "vdev %s creation failed  %d\n",
     215                 :            :                         vdev_name, err);
     216                 :          1 :                 event_dev_delete = 1;
     217                 :            :         }
     218                 :            :         return err;
     219                 :            : }
     220                 :            : 
     221                 :            : #define DEVICE_ID_SIZE 64
     222                 :            : 
     223                 :            : static void
     224                 :          1 : testsuite_teardown(void)
     225                 :            : {
     226                 :          1 :         deinit_ports();
     227                 :          1 :         rte_mempool_free(default_params.mp);
     228                 :          1 :         default_params.mp = NULL;
     229         [ +  - ]:          1 :         if (event_dev_delete)
     230                 :          1 :                 rte_vdev_uninit("event_sw0");
     231                 :          1 : }
     232                 :            : 
     233                 :            : static int
     234                 :          7 : tx_adapter_create(void)
     235                 :            : {
     236                 :            :         int err;
     237                 :            :         struct rte_event_dev_info dev_info;
     238                 :            :         struct rte_event_port_conf tx_p_conf;
     239                 :            :         uint8_t priority;
     240                 :            :         uint8_t queue_id;
     241                 :            : 
     242                 :          7 :         struct rte_event_dev_config config = {
     243                 :            :                         .nb_event_queues = 1,
     244                 :            :                         .nb_event_ports = 1,
     245                 :            :         };
     246                 :            : 
     247                 :          7 :         struct rte_event_queue_conf wkr_q_conf = {
     248                 :            :                         .schedule_type = RTE_SCHED_TYPE_ORDERED,
     249                 :            :                         .priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
     250                 :            :                         .nb_atomic_flows = 1024,
     251                 :            :                         .nb_atomic_order_sequences = 1024,
     252                 :            :         };
     253                 :            : 
     254                 :            :         memset(&tx_p_conf, 0, sizeof(tx_p_conf));
     255                 :          7 :         err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
     256                 :          7 :         config.nb_event_queue_flows = dev_info.max_event_queue_flows;
     257                 :          7 :         config.nb_event_port_dequeue_depth =
     258                 :          7 :                         dev_info.max_event_port_dequeue_depth;
     259                 :          7 :         config.nb_event_port_enqueue_depth =
     260                 :          7 :                         dev_info.max_event_port_enqueue_depth;
     261                 :          7 :         config.nb_events_limit =
     262                 :          7 :                         dev_info.max_num_events;
     263                 :            : 
     264                 :          7 :         err = rte_event_dev_configure(TEST_DEV_ID, &config);
     265         [ -  + ]:          7 :         TEST_ASSERT(err == 0, "Event device initialization failed err %d\n",
     266                 :            :                         err);
     267                 :            : 
     268                 :          7 :         queue_id = 0;
     269                 :          7 :         err = rte_event_queue_setup(TEST_DEV_ID, 0, &wkr_q_conf);
     270         [ -  + ]:          7 :         TEST_ASSERT(err == 0, "Event queue setup failed %d\n", err);
     271                 :            : 
     272                 :          7 :         err = rte_event_port_setup(TEST_DEV_ID, 0, NULL);
     273         [ -  + ]:          7 :         TEST_ASSERT(err == 0, "Event port setup failed %d\n", err);
     274                 :            : 
     275                 :          7 :         priority = RTE_EVENT_DEV_PRIORITY_LOWEST;
     276                 :          7 :         err = rte_event_port_link(TEST_DEV_ID, 0, &queue_id, &priority, 1);
     277         [ -  + ]:          7 :         TEST_ASSERT(err == 1, "Error linking port %s\n",
     278                 :            :                 rte_strerror(rte_errno));
     279                 :          7 :         err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
     280         [ -  + ]:          7 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     281                 :            : 
     282                 :          7 :         tx_p_conf.new_event_threshold = dev_info.max_num_events;
     283                 :          7 :         tx_p_conf.dequeue_depth = dev_info.max_event_port_dequeue_depth;
     284                 :          7 :         tx_p_conf.enqueue_depth = dev_info.max_event_port_enqueue_depth;
     285                 :          7 :         err = rte_event_eth_tx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
     286                 :            :                                         &tx_p_conf);
     287         [ -  + ]:          7 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     288                 :            : 
     289                 :            :         return err;
     290                 :            : }
     291                 :            : 
     292                 :            : static void
     293                 :          6 : tx_adapter_free(void)
     294                 :            : {
     295                 :          7 :         rte_event_eth_tx_adapter_free(TEST_INST_ID);
     296                 :          6 : }
     297                 :            : 
     298                 :            : static int
     299                 :          1 : tx_adapter_create_free(void)
     300                 :            : {
     301                 :            :         int err;
     302                 :            :         struct rte_event_dev_info dev_info;
     303                 :            :         struct rte_event_port_conf tx_p_conf;
     304                 :            : 
     305                 :          1 :         err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
     306         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     307                 :            : 
     308                 :          1 :         tx_p_conf.new_event_threshold = dev_info.max_num_events;
     309                 :          1 :         tx_p_conf.dequeue_depth = dev_info.max_event_port_dequeue_depth;
     310                 :          1 :         tx_p_conf.enqueue_depth = dev_info.max_event_port_enqueue_depth;
     311                 :            : 
     312                 :          1 :         err = rte_event_eth_tx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
     313                 :            :                                         NULL);
     314         [ -  + ]:          1 :         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
     315                 :            : 
     316                 :          1 :         err = rte_event_eth_tx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
     317                 :            :                                         &tx_p_conf);
     318         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     319                 :            : 
     320                 :          1 :         err = rte_event_eth_tx_adapter_create(TEST_INST_ID,
     321                 :            :                                         TEST_DEV_ID, &tx_p_conf);
     322         [ -  + ]:          1 :         TEST_ASSERT(err == -EEXIST, "Expected -EEXIST %d got %d", -EEXIST, err);
     323                 :            : 
     324                 :          1 :         err = rte_event_eth_tx_adapter_free(TEST_INST_ID);
     325         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     326                 :            : 
     327                 :          1 :         err = rte_event_eth_tx_adapter_free(TEST_INST_ID);
     328         [ -  + ]:          1 :         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
     329                 :            : 
     330                 :          1 :         err = rte_event_eth_tx_adapter_free(1);
     331         [ -  + ]:          1 :         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
     332                 :            : 
     333                 :            :         return TEST_SUCCESS;
     334                 :            : }
     335                 :            : 
     336                 :            : static int
     337                 :          1 : tx_adapter_queue_add_del(void)
     338                 :            : {
     339                 :            :         int err;
     340                 :            :         uint32_t cap;
     341                 :            : 
     342                 :          1 :         err = rte_event_eth_tx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID,
     343                 :            :                                          &cap);
     344         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     345                 :            : 
     346                 :            : 
     347                 :          1 :         err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID,
     348                 :          1 :                                                 rte_eth_dev_count_total(),
     349                 :            :                                                 -1);
     350         [ -  + ]:          1 :         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
     351                 :            : 
     352                 :          1 :         err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID,
     353                 :          1 :                                                 TEST_ETHDEV_ID,
     354                 :            :                                                 0);
     355         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     356                 :            : 
     357                 :          1 :         err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID,
     358                 :          1 :                                                 TEST_ETHDEV_ID,
     359                 :            :                                                 -1);
     360         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     361                 :            : 
     362                 :          1 :         err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID,
     363                 :          1 :                                                 TEST_ETHDEV_ID,
     364                 :            :                                                 0);
     365         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     366                 :            : 
     367                 :          1 :         err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID,
     368                 :          1 :                                                 TEST_ETHDEV_ID,
     369                 :            :                                                 -1);
     370         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     371                 :            : 
     372                 :          1 :         err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID,
     373                 :          1 :                                                 TEST_ETHDEV_ID,
     374                 :            :                                                 -1);
     375         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     376                 :            : 
     377                 :          1 :         err = rte_event_eth_tx_adapter_queue_add(1, TEST_ETHDEV_ID, -1);
     378         [ -  + ]:          1 :         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
     379                 :            : 
     380                 :          1 :         err = rte_event_eth_tx_adapter_queue_del(1, TEST_ETHDEV_ID, -1);
     381         [ -  + ]:          1 :         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
     382                 :            : 
     383                 :            :         return TEST_SUCCESS;
     384                 :            : }
     385                 :            : 
     386                 :            : static int
     387                 :          1 : tx_adapter_start_stop(void)
     388                 :            : {
     389                 :            :         int err;
     390                 :            : 
     391                 :          1 :         err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID, TEST_ETHDEV_ID,
     392                 :            :                                                 -1);
     393         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     394                 :            : 
     395                 :          1 :         err = rte_event_eth_tx_adapter_start(TEST_INST_ID);
     396         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     397                 :            : 
     398                 :          1 :         err = rte_event_eth_tx_adapter_stop(TEST_INST_ID);
     399         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     400                 :            : 
     401                 :          1 :         err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID, TEST_ETHDEV_ID,
     402                 :            :                                                 -1);
     403         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     404                 :            : 
     405                 :          1 :         err = rte_event_eth_tx_adapter_start(TEST_INST_ID);
     406         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     407                 :            : 
     408                 :          1 :         err = rte_event_eth_tx_adapter_stop(TEST_INST_ID);
     409         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     410                 :            : 
     411                 :          1 :         err = rte_event_eth_tx_adapter_start(1);
     412                 :            : 
     413                 :          1 :         err = rte_event_eth_tx_adapter_stop(1);
     414         [ -  + ]:          1 :         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
     415                 :            : 
     416                 :            :         return TEST_SUCCESS;
     417                 :            : }
     418                 :            : 
     419                 :            : 
     420                 :            : static int
     421                 :       4096 : tx_adapter_single(uint16_t port, uint16_t tx_queue_id,
     422                 :            :                 struct rte_mbuf *m, uint8_t qid,
     423                 :            :                 uint8_t sched_type)
     424                 :            : {
     425                 :            :         struct rte_event event;
     426                 :            :         struct rte_mbuf *r;
     427                 :            :         int ret;
     428                 :            :         unsigned int l;
     429                 :            : 
     430                 :       4096 :         event.queue_id = qid;
     431                 :       4096 :         event.op = RTE_EVENT_OP_NEW;
     432                 :       4096 :         event.event_type = RTE_EVENT_TYPE_CPU;
     433                 :       4096 :         event.sched_type = sched_type;
     434                 :       4096 :         event.mbuf = m;
     435                 :            : 
     436                 :       4096 :         m->port = port;
     437                 :       4096 :         rte_event_eth_tx_adapter_txq_set(m, tx_queue_id);
     438                 :            : 
     439                 :            :         l = 0;
     440         [ -  + ]:       8192 :         while (rte_event_enqueue_burst(TEST_DEV_ID, 0, &event, 1) != 1) {
     441                 :          0 :                 l++;
     442         [ #  # ]:          0 :                 if (l > EDEV_RETRY)
     443                 :            :                         break;
     444                 :            :         }
     445                 :            : 
     446         [ -  + ]:       4096 :         TEST_ASSERT(l < EDEV_RETRY, "Unable to enqueue to eventdev");
     447                 :            :         l = 0;
     448         [ +  - ]:    4198400 :         while (l++ < EDEV_RETRY) {
     449                 :            : 
     450         [ +  - ]:    4198400 :                 if (eid != ~0ULL) {
     451                 :    4198400 :                         ret = rte_service_run_iter_on_app_lcore(eid, 0);
     452         [ -  + ]:    4198400 :                         TEST_ASSERT(ret == 0, "failed to run service %d", ret);
     453                 :            :                 }
     454                 :            : 
     455                 :    4198400 :                 ret = rte_service_run_iter_on_app_lcore(tid, 0);
     456         [ -  + ]:    4198400 :                 TEST_ASSERT(ret == 0, "failed to run service %d", ret);
     457                 :            : 
     458         [ +  + ]:    4198400 :                 if (rte_eth_rx_burst(TEST_ETHDEV_PAIR_ID, tx_queue_id,
     459                 :            :                                 &r, 1)) {
     460         [ -  + ]:       4096 :                         TEST_ASSERT_EQUAL(r, m, "mbuf comparison failed"
     461                 :            :                                         " expected %p received %p", m, r);
     462                 :            :                         return 0;
     463                 :            :                 }
     464                 :            :         }
     465                 :            : 
     466                 :          0 :         TEST_ASSERT(0, "Failed to receive packet");
     467                 :            :         return -1;
     468                 :            : }
     469                 :            : 
     470                 :            : static int
     471                 :          1 : tx_adapter_service(void)
     472                 :            : {
     473                 :            :         struct rte_event_eth_tx_adapter_stats stats;
     474                 :            :         uint32_t i;
     475                 :            :         int err;
     476                 :            :         uint8_t ev_port, ev_qid;
     477                 :            :         struct rte_mbuf  bufs[RING_SIZE];
     478                 :            :         struct rte_mbuf *pbufs[RING_SIZE];
     479                 :            :         struct rte_event_dev_info dev_info;
     480                 :            :         struct rte_event_dev_config dev_conf;
     481                 :            :         struct rte_event_queue_conf qconf;
     482                 :            :         uint32_t qcnt, pcnt;
     483                 :            :         uint16_t q;
     484                 :            :         int internal_port;
     485                 :            :         uint32_t cap;
     486                 :            : 
     487                 :            :         memset(&dev_conf, 0, sizeof(dev_conf));
     488                 :          1 :         err = rte_event_eth_tx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID,
     489                 :            :                                                 &cap);
     490         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Failed to get adapter cap err %d\n", err);
     491                 :            : 
     492                 :          1 :         internal_port = !!(cap & RTE_EVENT_ETH_TX_ADAPTER_CAP_INTERNAL_PORT);
     493         [ +  - ]:          1 :         if (internal_port)
     494                 :            :                 return TEST_SUCCESS;
     495                 :            : 
     496                 :          1 :         err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID, TEST_ETHDEV_ID,
     497                 :            :                                                 -1);
     498         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     499                 :            : 
     500                 :          1 :         err = rte_event_eth_tx_adapter_event_port_get(TEST_INST_ID,
     501                 :            :                                                 &ev_port);
     502         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(err, "Failed to get event port %d", err);
     503                 :            : 
     504                 :          1 :         err = rte_event_dev_attr_get(TEST_DEV_ID, RTE_EVENT_DEV_ATTR_PORT_COUNT,
     505                 :            :                                         &pcnt);
     506         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(err, "Port count get failed");
     507                 :            : 
     508                 :          1 :         err = rte_event_dev_attr_get(TEST_DEV_ID,
     509                 :            :                                 RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &qcnt);
     510         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(err, "Queue count get failed");
     511                 :            : 
     512                 :          1 :         err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
     513         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(err, "Dev info failed");
     514                 :            : 
     515                 :          1 :         dev_conf.nb_event_queue_flows = dev_info.max_event_queue_flows;
     516                 :          1 :         dev_conf.nb_event_port_dequeue_depth =
     517                 :          1 :                         dev_info.max_event_port_dequeue_depth;
     518                 :          1 :         dev_conf.nb_event_port_enqueue_depth =
     519                 :          1 :                         dev_info.max_event_port_enqueue_depth;
     520                 :          1 :         dev_conf.nb_events_limit =
     521                 :          1 :                         dev_info.max_num_events;
     522                 :          1 :         dev_conf.nb_event_queues = qcnt + 1;
     523                 :          1 :         dev_conf.nb_event_ports = pcnt;
     524                 :          1 :         err = rte_event_dev_configure(TEST_DEV_ID, &dev_conf);
     525         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Event device initialization failed err %d\n",
     526                 :            :                         err);
     527                 :            : 
     528                 :          1 :         ev_qid = qcnt;
     529                 :          1 :         qconf.nb_atomic_flows = dev_info.max_event_queue_flows;
     530                 :          1 :         qconf.nb_atomic_order_sequences = 32;
     531                 :          1 :         qconf.schedule_type = RTE_SCHED_TYPE_ATOMIC;
     532                 :          1 :         qconf.priority = RTE_EVENT_DEV_PRIORITY_HIGHEST;
     533                 :          1 :         qconf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_SINGLE_LINK;
     534                 :          1 :         err = rte_event_queue_setup(TEST_DEV_ID, ev_qid, &qconf);
     535         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(err, "Failed to setup queue %u", ev_qid);
     536                 :            : 
     537                 :            :         /*
     538                 :            :          * Setup ports again so that the newly added queue is visible
     539                 :            :          * to them
     540                 :            :          */
     541         [ +  + ]:          3 :         for (i = 0; i < pcnt; i++) {
     542                 :            : 
     543                 :            :                 int n_links;
     544                 :            :                 uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV];
     545                 :            :                 uint8_t priorities[RTE_EVENT_MAX_QUEUES_PER_DEV];
     546                 :            : 
     547         [ +  + ]:          2 :                 if (i == ev_port)
     548                 :          1 :                         continue;
     549                 :            : 
     550                 :          1 :                 n_links = rte_event_port_links_get(TEST_DEV_ID, i, queues,
     551                 :            :                                                 priorities);
     552         [ -  + ]:          1 :                 TEST_ASSERT(n_links > 0, "Failed to get port links %d\n",
     553                 :            :                         n_links);
     554                 :          1 :                 err = rte_event_port_setup(TEST_DEV_ID, i, NULL);
     555         [ -  + ]:          1 :                 TEST_ASSERT(err == 0, "Failed to setup port err %d\n", err);
     556                 :          1 :                 err = rte_event_port_link(TEST_DEV_ID, i, queues, priorities,
     557                 :            :                                         n_links);
     558         [ -  + ]:          1 :                 TEST_ASSERT(n_links == err, "Failed to link all queues"
     559                 :            :                         " err %s\n", rte_strerror(rte_errno));
     560                 :            :         }
     561                 :            : 
     562                 :          1 :         err = rte_event_port_link(TEST_DEV_ID, ev_port, &ev_qid, NULL, 1);
     563         [ -  + ]:          1 :         TEST_ASSERT(err == 1, "Failed to link queue port %u",
     564                 :            :                     ev_port);
     565                 :            : 
     566                 :          1 :         err = rte_event_eth_tx_adapter_start(TEST_INST_ID);
     567         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     568                 :            : 
     569         [ +  - ]:          1 :         if (!(dev_info.event_dev_cap & RTE_EVENT_DEV_CAP_DISTRIBUTED_SCHED)) {
     570                 :          1 :                 err = rte_event_dev_service_id_get(0, (uint32_t *)&eid);
     571         [ -  + ]:          1 :                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     572                 :            : 
     573                 :          1 :                 err = rte_service_runstate_set(eid, 1);
     574         [ -  + ]:          1 :                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     575                 :            : 
     576                 :          1 :                 err = rte_service_set_runstate_mapped_check(eid, 0);
     577         [ -  + ]:          1 :                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     578                 :            :         }
     579                 :            : 
     580                 :          1 :         err = rte_event_eth_tx_adapter_service_id_get(TEST_INST_ID, &tid);
     581         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     582                 :            : 
     583                 :          1 :         err = rte_service_runstate_set(tid, 1);
     584         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     585                 :            : 
     586                 :          1 :         err = rte_service_set_runstate_mapped_check(tid, 0);
     587         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     588                 :            : 
     589                 :          1 :         err = rte_event_dev_start(TEST_DEV_ID);
     590         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     591                 :            : 
     592         [ +  + ]:         17 :         for (q = 0; q < MAX_NUM_QUEUE; q++) {
     593         [ +  + ]:       4112 :                 for (i = 0; i < RING_SIZE; i++)
     594                 :       4096 :                         pbufs[i] = &bufs[i];
     595         [ +  + ]:       4112 :                 for (i = 0; i < RING_SIZE; i++) {
     596                 :       4096 :                         pbufs[i] = &bufs[i];
     597                 :       4096 :                         err = tx_adapter_single(TEST_ETHDEV_ID, q, pbufs[i],
     598                 :            :                                                 ev_qid,
     599                 :            :                                                 RTE_SCHED_TYPE_ORDERED);
     600         [ -  + ]:       4096 :                         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     601                 :            :                 }
     602         [ +  + ]:       4112 :                 for (i = 0; i < RING_SIZE; i++) {
     603         [ -  + ]:       4096 :                         TEST_ASSERT_EQUAL(pbufs[i], &bufs[i],
     604                 :            :                                 "Error: received data does not match"
     605                 :            :                                 " that transmitted");
     606                 :            :                 }
     607                 :            :         }
     608                 :            : 
     609                 :          1 :         err = rte_event_eth_tx_adapter_stats_get(TEST_INST_ID, NULL);
     610         [ -  + ]:          1 :         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
     611                 :            : 
     612                 :          1 :         err = rte_event_eth_tx_adapter_stats_get(TEST_INST_ID, &stats);
     613         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     614         [ -  + ]:          1 :         TEST_ASSERT_EQUAL(stats.tx_packets, MAX_NUM_QUEUE * RING_SIZE,
     615                 :            :                         "stats.tx_packets expected %u got %"PRIu64,
     616                 :            :                         MAX_NUM_QUEUE * RING_SIZE,
     617                 :            :                         stats.tx_packets);
     618                 :            : 
     619                 :          1 :         err = rte_event_eth_tx_adapter_stats_reset(TEST_INST_ID);
     620         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     621                 :            : 
     622                 :          1 :         err = rte_event_eth_tx_adapter_stats_get(TEST_INST_ID, &stats);
     623         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     624         [ -  + ]:          1 :         TEST_ASSERT_EQUAL(stats.tx_packets, 0,
     625                 :            :                         "stats.tx_packets expected %u got %"PRIu64,
     626                 :            :                         0,
     627                 :            :                         stats.tx_packets);
     628                 :            : 
     629                 :          1 :         err = rte_event_eth_tx_adapter_stats_get(1, &stats);
     630         [ -  + ]:          1 :         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
     631                 :            : 
     632                 :          1 :         err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID, TEST_ETHDEV_ID,
     633                 :            :                                                 -1);
     634         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     635                 :            : 
     636                 :          1 :         err = rte_event_eth_tx_adapter_free(TEST_INST_ID);
     637         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     638                 :            : 
     639                 :          1 :         rte_event_dev_stop(TEST_DEV_ID);
     640                 :            : 
     641                 :          1 :         return TEST_SUCCESS;
     642                 :            : }
     643                 :            : 
     644                 :            : static int
     645                 :          1 : tx_adapter_instance_get(void)
     646                 :            : {
     647                 :            :         int err;
     648                 :            :         uint8_t inst_id;
     649                 :            :         uint16_t eth_dev_id;
     650                 :            :         struct rte_eth_dev_info dev_info;
     651                 :            : 
     652                 :            :         /* Case 1: Test without configuring eth */
     653                 :          1 :         err = rte_event_eth_tx_adapter_instance_get(TEST_ETHDEV_ID,
     654                 :            :                                                     TEST_ETH_QUEUE_ID,
     655                 :            :                                                     &inst_id);
     656         [ -  + ]:          1 :         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
     657                 :            : 
     658                 :            :         /* Case 2: Test with wrong eth port */
     659                 :          1 :         eth_dev_id = rte_eth_dev_count_total() + 1;
     660                 :          1 :         err = rte_event_eth_tx_adapter_instance_get(eth_dev_id,
     661                 :            :                                                     TEST_ETH_QUEUE_ID,
     662                 :            :                                                     &inst_id);
     663         [ -  + ]:          1 :         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
     664                 :            : 
     665                 :            :         /* Case 3: Test with wrong tx queue */
     666                 :          1 :         err = rte_eth_dev_info_get(TEST_ETHDEV_ID, &dev_info);
     667         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     668                 :            : 
     669                 :          1 :         err = rte_event_eth_tx_adapter_instance_get(TEST_ETHDEV_ID,
     670                 :          1 :                                                     dev_info.max_tx_queues + 1,
     671                 :            :                                                     &inst_id);
     672         [ -  + ]:          1 :         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
     673                 :            : 
     674                 :            :         /* Case 4: Test with right instance, port & rxq */
     675                 :            :         /* Add queue to tx adapter */
     676                 :          1 :         err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID,
     677                 :          1 :                                                  TEST_ETHDEV_ID,
     678                 :            :                                                  TEST_ETH_QUEUE_ID);
     679         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     680                 :            : 
     681                 :          1 :         err = rte_event_eth_tx_adapter_instance_get(TEST_ETHDEV_ID,
     682                 :            :                                                     TEST_ETH_QUEUE_ID,
     683                 :            :                                                     &inst_id);
     684         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     685         [ -  + ]:          1 :         TEST_ASSERT(inst_id == TEST_INST_ID, "Expected %d got %d",
     686                 :            :                     TEST_INST_ID, err);
     687                 :            : 
     688                 :            :         /* Add another queue to tx adapter */
     689                 :          1 :         err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID,
     690                 :          1 :                                                  TEST_ETHDEV_ID,
     691                 :            :                                                  TEST_ETH_QUEUE_ID + 1);
     692         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     693                 :            : 
     694                 :          1 :         err = rte_event_eth_tx_adapter_instance_get(TEST_ETHDEV_ID,
     695                 :            :                                                     TEST_ETH_QUEUE_ID + 1,
     696                 :            :                                                     &inst_id);
     697         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     698         [ -  + ]:          1 :         TEST_ASSERT(inst_id == TEST_INST_ID, "Expected %d got %d",
     699                 :            :                     TEST_INST_ID, err);
     700                 :            : 
     701                 :            :         /* Case 5: Test with right instance, port & wrong rxq */
     702                 :          1 :         err = rte_event_eth_tx_adapter_instance_get(TEST_ETHDEV_ID,
     703                 :            :                                                     TEST_ETH_QUEUE_ID + 2,
     704                 :            :                                                     &inst_id);
     705         [ -  + ]:          1 :         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
     706                 :            : 
     707                 :            :         /* Delete all queues from the Tx adapter */
     708                 :          1 :         err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID,
     709                 :          1 :                                                  TEST_ETHDEV_ID,
     710                 :            :                                                  -1);
     711         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     712                 :            : 
     713                 :            :         return TEST_SUCCESS;
     714                 :            : }
     715                 :            : 
     716                 :            : static int
     717                 :          1 : tx_adapter_queue_start_stop(void)
     718                 :            : {
     719                 :            :         int err;
     720                 :            :         uint16_t eth_dev_id;
     721                 :            :         struct rte_eth_dev_info dev_info;
     722                 :            : 
     723                 :            :         /* Case 1: Test without adding eth Tx queue */
     724                 :          1 :         err = rte_event_eth_tx_adapter_queue_start(TEST_ETHDEV_ID,
     725                 :            :                                                     TEST_ETH_QUEUE_ID);
     726         [ -  + ]:          1 :         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
     727                 :            : 
     728                 :          1 :         err = rte_event_eth_tx_adapter_queue_stop(TEST_ETHDEV_ID,
     729                 :            :                                                     TEST_ETH_QUEUE_ID);
     730         [ -  + ]:          1 :         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
     731                 :            : 
     732                 :            :         /* Case 2: Test with wrong eth port */
     733                 :          1 :         eth_dev_id = rte_eth_dev_count_total() + 1;
     734                 :          1 :         err = rte_event_eth_tx_adapter_queue_start(eth_dev_id,
     735                 :            :                                                     TEST_ETH_QUEUE_ID);
     736         [ -  + ]:          1 :         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
     737                 :            : 
     738                 :          1 :         err = rte_event_eth_tx_adapter_queue_stop(eth_dev_id,
     739                 :            :                                                     TEST_ETH_QUEUE_ID);
     740         [ -  + ]:          1 :         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
     741                 :            : 
     742                 :            :         /* Case 3: Test with wrong tx queue */
     743                 :          1 :         err = rte_eth_dev_info_get(TEST_ETHDEV_ID, &dev_info);
     744         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     745                 :            : 
     746                 :          1 :         err = rte_event_eth_tx_adapter_queue_start(TEST_ETHDEV_ID,
     747                 :          1 :                                                     dev_info.max_tx_queues + 1);
     748         [ -  + ]:          1 :         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
     749                 :            : 
     750                 :          1 :         err = rte_event_eth_tx_adapter_queue_stop(TEST_ETHDEV_ID,
     751                 :          1 :                                                     dev_info.max_tx_queues + 1);
     752         [ -  + ]:          1 :         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
     753                 :            : 
     754                 :            :         /* Case 4: Test with right instance, port & rxq */
     755                 :            :         /* Add queue to tx adapter */
     756                 :          1 :         err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID,
     757                 :          1 :                                                  TEST_ETHDEV_ID,
     758                 :            :                                                  TEST_ETH_QUEUE_ID);
     759         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     760                 :            : 
     761                 :          1 :         err = rte_event_eth_tx_adapter_queue_stop(TEST_ETHDEV_ID,
     762                 :            :                                                     TEST_ETH_QUEUE_ID);
     763         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     764                 :            : 
     765                 :          1 :         err = rte_event_eth_tx_adapter_queue_start(TEST_ETHDEV_ID,
     766                 :            :                                                     TEST_ETH_QUEUE_ID);
     767         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     768                 :            : 
     769                 :            :         /* Add another queue to tx adapter */
     770                 :          1 :         err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID,
     771                 :          1 :                                                  TEST_ETHDEV_ID,
     772                 :            :                                                  TEST_ETH_QUEUE_ID + 1);
     773         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     774                 :            : 
     775                 :          1 :         err = rte_event_eth_tx_adapter_queue_stop(TEST_ETHDEV_ID,
     776                 :            :                                                     TEST_ETH_QUEUE_ID + 1);
     777         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     778                 :          1 :         err = rte_event_eth_tx_adapter_queue_start(TEST_ETHDEV_ID,
     779                 :            :                                                     TEST_ETH_QUEUE_ID + 1);
     780         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     781                 :            : 
     782                 :            :         /* Case 5: Test with right instance, port & wrong rxq */
     783                 :          1 :         err = rte_event_eth_tx_adapter_queue_stop(TEST_ETHDEV_ID,
     784                 :            :                                                     TEST_ETH_QUEUE_ID + 2);
     785         [ -  + ]:          1 :         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
     786                 :            : 
     787                 :          1 :         err = rte_event_eth_tx_adapter_queue_start(TEST_ETHDEV_ID,
     788                 :            :                                                     TEST_ETH_QUEUE_ID + 2);
     789         [ -  + ]:          1 :         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
     790                 :            : 
     791                 :            :         /* Delete all queues from the Tx adapter */
     792                 :          1 :         err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID,
     793                 :          1 :                                                  TEST_ETHDEV_ID,
     794                 :            :                                                  -1);
     795         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     796                 :            : 
     797                 :            :         return TEST_SUCCESS;
     798                 :            : }
     799                 :            : 
     800                 :            : static int
     801                 :          1 : tx_adapter_set_get_params(void)
     802                 :            : {
     803                 :            :         int err, rc;
     804                 :            :         struct rte_event_eth_tx_adapter_runtime_params in_params;
     805                 :            :         struct rte_event_eth_tx_adapter_runtime_params out_params;
     806                 :            : 
     807                 :          1 :         err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID,
     808                 :          1 :                                                  TEST_ETHDEV_ID,
     809                 :            :                                                  0);
     810         [ -  + ]:          1 :         if (err == -ENOTSUP) {
     811                 :            :                 rc = TEST_SKIPPED;
     812                 :          0 :                 goto skip;
     813                 :            :         }
     814         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     815                 :            : 
     816                 :          1 :         err = rte_event_eth_tx_adapter_runtime_params_init(&in_params);
     817         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     818                 :          1 :         err = rte_event_eth_tx_adapter_runtime_params_init(&out_params);
     819         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     820                 :            : 
     821                 :            :         /* Case 1: Get the default values of adapter */
     822                 :          1 :         err = rte_event_eth_tx_adapter_runtime_params_get(TEST_INST_ID,
     823                 :            :                                                           &out_params);
     824         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     825         [ -  + ]:          1 :         TEST_ASSERT(out_params.flush_threshold == DEFAULT_FLUSH_THRESHOLD,
     826                 :            :                     "Expected %u got %u",
     827                 :            :                     DEFAULT_FLUSH_THRESHOLD, out_params.flush_threshold);
     828         [ -  + ]:          1 :         TEST_ASSERT(out_params.max_nb_tx == TXA_NB_TX_WORK_DEFAULT,
     829                 :            :                     "Expected %u got %u",
     830                 :            :                     TXA_NB_TX_WORK_DEFAULT, out_params.max_nb_tx);
     831                 :            : 
     832                 :            :         /* Case 2: Set max_nb_tx = 32 (=TXA_BATCH_SEIZE) */
     833                 :          1 :         in_params.max_nb_tx = 32;
     834                 :          1 :         in_params.flush_threshold = DEFAULT_FLUSH_THRESHOLD;
     835                 :            : 
     836                 :          1 :         err = rte_event_eth_tx_adapter_runtime_params_set(TEST_INST_ID,
     837                 :            :                                                           &in_params);
     838         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     839                 :            : 
     840                 :          1 :         err = rte_event_eth_tx_adapter_runtime_params_get(TEST_INST_ID,
     841                 :            :                                                           &out_params);
     842         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     843         [ -  + ]:          1 :         TEST_ASSERT(in_params.max_nb_tx == out_params.max_nb_tx,
     844                 :            :                     "Expected %u got %u",
     845                 :            :                     in_params.max_nb_tx, out_params.max_nb_tx);
     846         [ -  + ]:          1 :         TEST_ASSERT(in_params.flush_threshold == out_params.flush_threshold,
     847                 :            :                     "Expected %u got %u",
     848                 :            :                     in_params.flush_threshold, out_params.flush_threshold);
     849                 :            : 
     850                 :            :         /* Case 3: Set max_nb_tx = 192 */
     851                 :          1 :         in_params.max_nb_tx = 192;
     852                 :            : 
     853                 :          1 :         err = rte_event_eth_tx_adapter_runtime_params_set(TEST_INST_ID,
     854                 :            :                                                           &in_params);
     855         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     856                 :            : 
     857                 :          1 :         err = rte_event_eth_tx_adapter_runtime_params_get(TEST_INST_ID,
     858                 :            :                                                           &out_params);
     859         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     860         [ -  + ]:          1 :         TEST_ASSERT(in_params.max_nb_tx == out_params.max_nb_tx,
     861                 :            :                     "Expected %u got %u",
     862                 :            :                     in_params.max_nb_tx, out_params.max_nb_tx);
     863                 :            : 
     864                 :            :         /* Case 4: Set max_nb_tx = 256 */
     865                 :          1 :         in_params.max_nb_tx = 256;
     866                 :            : 
     867                 :          1 :         err = rte_event_eth_tx_adapter_runtime_params_set(TEST_INST_ID,
     868                 :            :                                                           &in_params);
     869         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     870                 :            : 
     871                 :          1 :         err = rte_event_eth_tx_adapter_runtime_params_get(TEST_INST_ID,
     872                 :            :                                                           &out_params);
     873         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     874         [ -  + ]:          1 :         TEST_ASSERT(in_params.max_nb_tx == out_params.max_nb_tx,
     875                 :            :                     "Expected %u got %u",
     876                 :            :                     in_params.max_nb_tx, out_params.max_nb_tx);
     877                 :            : 
     878                 :            :         /* Case 5: Set max_nb_tx = 30(<TXA_BATCH_SIZE) */
     879                 :          1 :         in_params.max_nb_tx = 30;
     880                 :            : 
     881                 :          1 :         err = rte_event_eth_tx_adapter_runtime_params_set(TEST_INST_ID,
     882                 :            :                                                           &in_params);
     883         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     884                 :            : 
     885                 :          1 :         err = rte_event_eth_tx_adapter_runtime_params_get(TEST_INST_ID,
     886                 :            :                                                           &out_params);
     887         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     888         [ -  + ]:          1 :         TEST_ASSERT(in_params.max_nb_tx == out_params.max_nb_tx,
     889                 :            :                     "Expected %u got %u",
     890                 :            :                     in_params.max_nb_tx, out_params.max_nb_tx);
     891                 :            : 
     892                 :            :         /* Case 6: Set max_nb_tx = 512 */
     893                 :          1 :         in_params.max_nb_tx = 512;
     894                 :            : 
     895                 :          1 :         err = rte_event_eth_tx_adapter_runtime_params_set(TEST_INST_ID,
     896                 :            :                                                           &in_params);
     897         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     898                 :            : 
     899                 :          1 :         err = rte_event_eth_tx_adapter_runtime_params_get(TEST_INST_ID,
     900                 :            :                                                           &out_params);
     901         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     902         [ -  + ]:          1 :         TEST_ASSERT(in_params.max_nb_tx == out_params.max_nb_tx,
     903                 :            :                     "Expected %u got %u",
     904                 :            :                     in_params.max_nb_tx, out_params.max_nb_tx);
     905                 :            : 
     906                 :            :         /* Case 7: Set flush_threshold = 10 */
     907                 :          1 :         in_params.max_nb_tx = 128;
     908                 :          1 :         in_params.flush_threshold = 10;
     909                 :            : 
     910                 :          1 :         err = rte_event_eth_tx_adapter_runtime_params_set(TEST_INST_ID,
     911                 :            :                                                           &in_params);
     912         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     913                 :            : 
     914                 :          1 :         err = rte_event_eth_tx_adapter_runtime_params_get(TEST_INST_ID,
     915                 :            :                                                           &out_params);
     916         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     917         [ -  + ]:          1 :         TEST_ASSERT(in_params.max_nb_tx == out_params.max_nb_tx,
     918                 :            :                     "Expected %u got %u",
     919                 :            :                     in_params.max_nb_tx, out_params.max_nb_tx);
     920         [ -  + ]:          1 :         TEST_ASSERT(in_params.flush_threshold == out_params.flush_threshold,
     921                 :            :                     "Expected %u got %u",
     922                 :            :                     in_params.flush_threshold, out_params.flush_threshold);
     923                 :            :         rc = TEST_SUCCESS;
     924                 :          1 : skip:
     925                 :          1 :         err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID,
     926                 :          1 :                                                  TEST_ETHDEV_ID,
     927                 :            :                                                  0);
     928         [ -  + ]:          1 :         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
     929                 :            : 
     930                 :            :         return rc;
     931                 :            : }
     932                 :            : 
     933                 :            : static int
     934                 :          1 : tx_adapter_dynamic_device(void)
     935                 :            : {
     936                 :          1 :         uint16_t port_id = rte_eth_dev_count_avail();
     937                 :          1 :         const char *null_dev[2] = { "eth_null0", "eth_null1" };
     938                 :            :         struct rte_eth_conf dev_conf;
     939                 :            :         int ret;
     940                 :            :         size_t i;
     941                 :            : 
     942                 :            :         memset(&dev_conf, 0, sizeof(dev_conf));
     943         [ +  + ]:          3 :         for (i = 0; i < RTE_DIM(null_dev); i++) {
     944                 :          2 :                 ret = rte_vdev_init(null_dev[i], NULL);
     945         [ -  + ]:          2 :                 TEST_ASSERT_SUCCESS(ret, "%s Port creation failed %d",
     946                 :            :                                 null_dev[i], ret);
     947                 :            : 
     948         [ +  + ]:          2 :                 if (i == 0) {
     949                 :          1 :                         ret = tx_adapter_create();
     950         [ -  + ]:          1 :                         TEST_ASSERT_SUCCESS(ret, "Adapter create failed %d",
     951                 :            :                                         ret);
     952                 :            :                 }
     953                 :            : 
     954                 :          2 :                 ret = rte_eth_dev_configure(port_id + i, MAX_NUM_QUEUE,
     955                 :            :                                         MAX_NUM_QUEUE, &dev_conf);
     956         [ -  + ]:          2 :                 TEST_ASSERT_SUCCESS(ret, "Failed to configure device %d", ret);
     957                 :            : 
     958                 :          2 :                 ret = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID,
     959                 :            :                                                         port_id + i, 0);
     960         [ -  + ]:          2 :                 TEST_ASSERT_SUCCESS(ret, "Failed to add queues %d", ret);
     961                 :            : 
     962                 :            :         }
     963                 :            : 
     964         [ +  + ]:          3 :         for (i = 0; i < RTE_DIM(null_dev); i++) {
     965                 :          2 :                 ret = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID,
     966                 :          2 :                                                         port_id + i, -1);
     967         [ -  + ]:          2 :                 TEST_ASSERT_SUCCESS(ret, "Failed to delete queues %d", ret);
     968                 :            :         }
     969                 :            : 
     970                 :            :         tx_adapter_free();
     971                 :            : 
     972         [ +  + ]:          3 :         for (i = 0; i < RTE_DIM(null_dev); i++)
     973                 :          2 :                 rte_vdev_uninit(null_dev[i]);
     974                 :            : 
     975                 :            :         return TEST_SUCCESS;
     976                 :            : }
     977                 :            : 
     978                 :            : static struct unit_test_suite event_eth_tx_tests = {
     979                 :            :         .setup = testsuite_setup,
     980                 :            :         .teardown = testsuite_teardown,
     981                 :            :         .suite_name = "tx event eth adapter test suite",
     982                 :            :         .unit_test_cases = {
     983                 :            :                 TEST_CASE_ST(NULL, NULL, tx_adapter_create_free),
     984                 :            :                 TEST_CASE_ST(tx_adapter_create, tx_adapter_free,
     985                 :            :                                         tx_adapter_queue_add_del),
     986                 :            :                 TEST_CASE_ST(tx_adapter_create, tx_adapter_free,
     987                 :            :                                         tx_adapter_start_stop),
     988                 :            :                 TEST_CASE_ST(tx_adapter_create, tx_adapter_free,
     989                 :            :                                         tx_adapter_service),
     990                 :            :                 TEST_CASE_ST(tx_adapter_create, tx_adapter_free,
     991                 :            :                                         tx_adapter_instance_get),
     992                 :            :                 TEST_CASE_ST(tx_adapter_create, tx_adapter_free,
     993                 :            :                                         tx_adapter_queue_start_stop),
     994                 :            :                 TEST_CASE_ST(tx_adapter_create, tx_adapter_free,
     995                 :            :                                         tx_adapter_set_get_params),
     996                 :            :                 TEST_CASE_ST(NULL, NULL, tx_adapter_dynamic_device),
     997                 :            :                 TEST_CASES_END() /**< NULL terminate unit test array */
     998                 :            :         }
     999                 :            : };
    1000                 :            : 
    1001                 :            : static int
    1002                 :          1 : test_event_eth_tx_adapter_common(void)
    1003                 :            : {
    1004                 :          1 :         return unit_test_suite_runner(&event_eth_tx_tests);
    1005                 :            : }
    1006                 :            : 
    1007                 :            : #endif /* !RTE_EXEC_ENV_WINDOWS */
    1008                 :            : 
    1009                 :        235 : REGISTER_FAST_TEST(event_eth_tx_adapter_autotest, false, true, test_event_eth_tx_adapter_common);

Generated by: LCOV version 1.14