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);
|