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 : : /* Initialize mbufs */
488 [ + + ]: 257 : for (i = 0; i < RING_SIZE; i++)
489 : : rte_pktmbuf_reset(&bufs[i]);
490 : :
491 : : memset(&dev_conf, 0, sizeof(dev_conf));
492 : 1 : err = rte_event_eth_tx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID,
493 : : &cap);
494 [ - + ]: 1 : TEST_ASSERT(err == 0, "Failed to get adapter cap err %d\n", err);
495 : :
496 : 1 : internal_port = !!(cap & RTE_EVENT_ETH_TX_ADAPTER_CAP_INTERNAL_PORT);
497 [ + - ]: 1 : if (internal_port)
498 : : return TEST_SUCCESS;
499 : :
500 : 1 : err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID, TEST_ETHDEV_ID,
501 : : -1);
502 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
503 : :
504 : 1 : err = rte_event_eth_tx_adapter_event_port_get(TEST_INST_ID,
505 : : &ev_port);
506 [ - + ]: 1 : TEST_ASSERT_SUCCESS(err, "Failed to get event port %d", err);
507 : :
508 : 1 : err = rte_event_dev_attr_get(TEST_DEV_ID, RTE_EVENT_DEV_ATTR_PORT_COUNT,
509 : : &pcnt);
510 [ - + ]: 1 : TEST_ASSERT_SUCCESS(err, "Port count get failed");
511 : :
512 : 1 : err = rte_event_dev_attr_get(TEST_DEV_ID,
513 : : RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &qcnt);
514 [ - + ]: 1 : TEST_ASSERT_SUCCESS(err, "Queue count get failed");
515 : :
516 : 1 : err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
517 [ - + ]: 1 : TEST_ASSERT_SUCCESS(err, "Dev info failed");
518 : :
519 : 1 : dev_conf.nb_event_queue_flows = dev_info.max_event_queue_flows;
520 : 1 : dev_conf.nb_event_port_dequeue_depth =
521 : 1 : dev_info.max_event_port_dequeue_depth;
522 : 1 : dev_conf.nb_event_port_enqueue_depth =
523 : 1 : dev_info.max_event_port_enqueue_depth;
524 : 1 : dev_conf.nb_events_limit =
525 : 1 : dev_info.max_num_events;
526 : 1 : dev_conf.nb_event_queues = qcnt + 1;
527 : 1 : dev_conf.nb_event_ports = pcnt;
528 : 1 : err = rte_event_dev_configure(TEST_DEV_ID, &dev_conf);
529 [ - + ]: 1 : TEST_ASSERT(err == 0, "Event device initialization failed err %d\n",
530 : : err);
531 : :
532 : 1 : ev_qid = qcnt;
533 : 1 : qconf.nb_atomic_flows = dev_info.max_event_queue_flows;
534 : 1 : qconf.nb_atomic_order_sequences = 32;
535 : 1 : qconf.schedule_type = RTE_SCHED_TYPE_ATOMIC;
536 : 1 : qconf.priority = RTE_EVENT_DEV_PRIORITY_HIGHEST;
537 : 1 : qconf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_SINGLE_LINK;
538 : 1 : err = rte_event_queue_setup(TEST_DEV_ID, ev_qid, &qconf);
539 [ - + ]: 1 : TEST_ASSERT_SUCCESS(err, "Failed to setup queue %u", ev_qid);
540 : :
541 : : /*
542 : : * Setup ports again so that the newly added queue is visible
543 : : * to them
544 : : */
545 [ + + ]: 3 : for (i = 0; i < pcnt; i++) {
546 : :
547 : : int n_links;
548 : : uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV];
549 : : uint8_t priorities[RTE_EVENT_MAX_QUEUES_PER_DEV];
550 : :
551 [ + + ]: 2 : if (i == ev_port)
552 : 1 : continue;
553 : :
554 : 1 : n_links = rte_event_port_links_get(TEST_DEV_ID, i, queues,
555 : : priorities);
556 [ - + ]: 1 : TEST_ASSERT(n_links > 0, "Failed to get port links %d\n",
557 : : n_links);
558 : 1 : err = rte_event_port_setup(TEST_DEV_ID, i, NULL);
559 [ - + ]: 1 : TEST_ASSERT(err == 0, "Failed to setup port err %d\n", err);
560 : 1 : err = rte_event_port_link(TEST_DEV_ID, i, queues, priorities,
561 : : n_links);
562 [ - + ]: 1 : TEST_ASSERT(n_links == err, "Failed to link all queues"
563 : : " err %s\n", rte_strerror(rte_errno));
564 : : }
565 : :
566 : 1 : err = rte_event_port_link(TEST_DEV_ID, ev_port, &ev_qid, NULL, 1);
567 [ - + ]: 1 : TEST_ASSERT(err == 1, "Failed to link queue port %u",
568 : : ev_port);
569 : :
570 : 1 : err = rte_event_eth_tx_adapter_start(TEST_INST_ID);
571 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
572 : :
573 [ + - ]: 1 : if (!(dev_info.event_dev_cap & RTE_EVENT_DEV_CAP_DISTRIBUTED_SCHED)) {
574 : 1 : err = rte_event_dev_service_id_get(0, (uint32_t *)&eid);
575 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
576 : :
577 : 1 : err = rte_service_runstate_set(eid, 1);
578 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
579 : :
580 : 1 : err = rte_service_set_runstate_mapped_check(eid, 0);
581 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
582 : : }
583 : :
584 : 1 : err = rte_event_eth_tx_adapter_service_id_get(TEST_INST_ID, &tid);
585 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
586 : :
587 : 1 : err = rte_service_runstate_set(tid, 1);
588 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
589 : :
590 : 1 : err = rte_service_set_runstate_mapped_check(tid, 0);
591 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
592 : :
593 : 1 : err = rte_event_dev_start(TEST_DEV_ID);
594 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
595 : :
596 [ + + ]: 17 : for (q = 0; q < MAX_NUM_QUEUE; q++) {
597 [ + + ]: 4112 : for (i = 0; i < RING_SIZE; i++)
598 : 4096 : pbufs[i] = &bufs[i];
599 [ + + ]: 4112 : for (i = 0; i < RING_SIZE; i++) {
600 : 4096 : pbufs[i] = &bufs[i];
601 : 4096 : err = tx_adapter_single(TEST_ETHDEV_ID, q, pbufs[i],
602 : : ev_qid,
603 : : RTE_SCHED_TYPE_ORDERED);
604 [ - + ]: 4096 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
605 : : }
606 [ + + ]: 4112 : for (i = 0; i < RING_SIZE; i++) {
607 [ - + ]: 4096 : TEST_ASSERT_EQUAL(pbufs[i], &bufs[i],
608 : : "Error: received data does not match"
609 : : " that transmitted");
610 : : }
611 : : }
612 : :
613 : 1 : err = rte_event_eth_tx_adapter_stats_get(TEST_INST_ID, NULL);
614 [ - + ]: 1 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
615 : :
616 : 1 : err = rte_event_eth_tx_adapter_stats_get(TEST_INST_ID, &stats);
617 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
618 [ - + ]: 1 : TEST_ASSERT_EQUAL(stats.tx_packets, MAX_NUM_QUEUE * RING_SIZE,
619 : : "stats.tx_packets expected %u got %"PRIu64,
620 : : MAX_NUM_QUEUE * RING_SIZE,
621 : : stats.tx_packets);
622 : :
623 : 1 : err = rte_event_eth_tx_adapter_stats_reset(TEST_INST_ID);
624 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
625 : :
626 : 1 : err = rte_event_eth_tx_adapter_stats_get(TEST_INST_ID, &stats);
627 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
628 [ - + ]: 1 : TEST_ASSERT_EQUAL(stats.tx_packets, 0,
629 : : "stats.tx_packets expected %u got %"PRIu64,
630 : : 0,
631 : : stats.tx_packets);
632 : :
633 : 1 : err = rte_event_eth_tx_adapter_stats_get(1, &stats);
634 [ - + ]: 1 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
635 : :
636 : 1 : err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID, TEST_ETHDEV_ID,
637 : : -1);
638 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
639 : :
640 : 1 : err = rte_event_eth_tx_adapter_free(TEST_INST_ID);
641 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
642 : :
643 : 1 : rte_event_dev_stop(TEST_DEV_ID);
644 : :
645 : 1 : return TEST_SUCCESS;
646 : : }
647 : :
648 : : static int
649 : 1 : tx_adapter_instance_get(void)
650 : : {
651 : : int err;
652 : : uint8_t inst_id;
653 : : uint16_t eth_dev_id;
654 : : struct rte_eth_dev_info dev_info;
655 : :
656 : : /* Case 1: Test without configuring eth */
657 : 1 : err = rte_event_eth_tx_adapter_instance_get(TEST_ETHDEV_ID,
658 : : TEST_ETH_QUEUE_ID,
659 : : &inst_id);
660 [ - + ]: 1 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
661 : :
662 : : /* Case 2: Test with wrong eth port */
663 : 1 : eth_dev_id = rte_eth_dev_count_total() + 1;
664 : 1 : err = rte_event_eth_tx_adapter_instance_get(eth_dev_id,
665 : : TEST_ETH_QUEUE_ID,
666 : : &inst_id);
667 [ - + ]: 1 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
668 : :
669 : : /* Case 3: Test with wrong tx queue */
670 : 1 : err = rte_eth_dev_info_get(TEST_ETHDEV_ID, &dev_info);
671 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
672 : :
673 : 1 : err = rte_event_eth_tx_adapter_instance_get(TEST_ETHDEV_ID,
674 : 1 : dev_info.max_tx_queues + 1,
675 : : &inst_id);
676 [ - + ]: 1 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
677 : :
678 : : /* Case 4: Test with right instance, port & rxq */
679 : : /* Add queue to tx adapter */
680 : 1 : err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID,
681 : 1 : TEST_ETHDEV_ID,
682 : : TEST_ETH_QUEUE_ID);
683 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
684 : :
685 : 1 : err = rte_event_eth_tx_adapter_instance_get(TEST_ETHDEV_ID,
686 : : TEST_ETH_QUEUE_ID,
687 : : &inst_id);
688 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
689 [ - + ]: 1 : TEST_ASSERT(inst_id == TEST_INST_ID, "Expected %d got %d",
690 : : TEST_INST_ID, err);
691 : :
692 : : /* Add another queue to tx adapter */
693 : 1 : err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID,
694 : 1 : TEST_ETHDEV_ID,
695 : : TEST_ETH_QUEUE_ID + 1);
696 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
697 : :
698 : 1 : err = rte_event_eth_tx_adapter_instance_get(TEST_ETHDEV_ID,
699 : : TEST_ETH_QUEUE_ID + 1,
700 : : &inst_id);
701 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
702 [ - + ]: 1 : TEST_ASSERT(inst_id == TEST_INST_ID, "Expected %d got %d",
703 : : TEST_INST_ID, err);
704 : :
705 : : /* Case 5: Test with right instance, port & wrong rxq */
706 : 1 : err = rte_event_eth_tx_adapter_instance_get(TEST_ETHDEV_ID,
707 : : TEST_ETH_QUEUE_ID + 2,
708 : : &inst_id);
709 [ - + ]: 1 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
710 : :
711 : : /* Delete all queues from the Tx adapter */
712 : 1 : err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID,
713 : 1 : TEST_ETHDEV_ID,
714 : : -1);
715 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
716 : :
717 : : return TEST_SUCCESS;
718 : : }
719 : :
720 : : static int
721 : 1 : tx_adapter_queue_start_stop(void)
722 : : {
723 : : int err;
724 : : uint16_t eth_dev_id;
725 : : struct rte_eth_dev_info dev_info;
726 : :
727 : : /* Case 1: Test without adding eth Tx queue */
728 : 1 : err = rte_event_eth_tx_adapter_queue_start(TEST_ETHDEV_ID,
729 : : TEST_ETH_QUEUE_ID);
730 [ - + ]: 1 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
731 : :
732 : 1 : err = rte_event_eth_tx_adapter_queue_stop(TEST_ETHDEV_ID,
733 : : TEST_ETH_QUEUE_ID);
734 [ - + ]: 1 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
735 : :
736 : : /* Case 2: Test with wrong eth port */
737 : 1 : eth_dev_id = rte_eth_dev_count_total() + 1;
738 : 1 : err = rte_event_eth_tx_adapter_queue_start(eth_dev_id,
739 : : TEST_ETH_QUEUE_ID);
740 [ - + ]: 1 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
741 : :
742 : 1 : err = rte_event_eth_tx_adapter_queue_stop(eth_dev_id,
743 : : TEST_ETH_QUEUE_ID);
744 [ - + ]: 1 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
745 : :
746 : : /* Case 3: Test with wrong tx queue */
747 : 1 : err = rte_eth_dev_info_get(TEST_ETHDEV_ID, &dev_info);
748 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
749 : :
750 : 1 : err = rte_event_eth_tx_adapter_queue_start(TEST_ETHDEV_ID,
751 : 1 : dev_info.max_tx_queues + 1);
752 [ - + ]: 1 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
753 : :
754 : 1 : err = rte_event_eth_tx_adapter_queue_stop(TEST_ETHDEV_ID,
755 : 1 : dev_info.max_tx_queues + 1);
756 [ - + ]: 1 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
757 : :
758 : : /* Case 4: Test with right instance, port & rxq */
759 : : /* Add queue to tx adapter */
760 : 1 : err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID,
761 : 1 : 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_stop(TEST_ETHDEV_ID,
766 : : TEST_ETH_QUEUE_ID);
767 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
768 : :
769 : 1 : err = rte_event_eth_tx_adapter_queue_start(TEST_ETHDEV_ID,
770 : : TEST_ETH_QUEUE_ID);
771 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
772 : :
773 : : /* Add another queue to tx adapter */
774 : 1 : err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID,
775 : 1 : TEST_ETHDEV_ID,
776 : : TEST_ETH_QUEUE_ID + 1);
777 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
778 : :
779 : 1 : err = rte_event_eth_tx_adapter_queue_stop(TEST_ETHDEV_ID,
780 : : TEST_ETH_QUEUE_ID + 1);
781 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
782 : 1 : err = rte_event_eth_tx_adapter_queue_start(TEST_ETHDEV_ID,
783 : : TEST_ETH_QUEUE_ID + 1);
784 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
785 : :
786 : : /* Case 5: Test with right instance, port & wrong rxq */
787 : 1 : err = rte_event_eth_tx_adapter_queue_stop(TEST_ETHDEV_ID,
788 : : TEST_ETH_QUEUE_ID + 2);
789 [ - + ]: 1 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
790 : :
791 : 1 : err = rte_event_eth_tx_adapter_queue_start(TEST_ETHDEV_ID,
792 : : TEST_ETH_QUEUE_ID + 2);
793 [ - + ]: 1 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
794 : :
795 : : /* Delete all queues from the Tx adapter */
796 : 1 : err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID,
797 : 1 : TEST_ETHDEV_ID,
798 : : -1);
799 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
800 : :
801 : : return TEST_SUCCESS;
802 : : }
803 : :
804 : : static int
805 : 1 : tx_adapter_set_get_params(void)
806 : : {
807 : : int err, rc;
808 : : struct rte_event_eth_tx_adapter_runtime_params in_params;
809 : : struct rte_event_eth_tx_adapter_runtime_params out_params;
810 : :
811 : 1 : err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID,
812 : 1 : TEST_ETHDEV_ID,
813 : : 0);
814 [ - + ]: 1 : if (err == -ENOTSUP) {
815 : : rc = TEST_SKIPPED;
816 : 0 : goto skip;
817 : : }
818 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
819 : :
820 : 1 : err = rte_event_eth_tx_adapter_runtime_params_init(&in_params);
821 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
822 : 1 : err = rte_event_eth_tx_adapter_runtime_params_init(&out_params);
823 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
824 : :
825 : : /* Case 1: Get the default values of adapter */
826 : 1 : err = rte_event_eth_tx_adapter_runtime_params_get(TEST_INST_ID,
827 : : &out_params);
828 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
829 [ - + ]: 1 : TEST_ASSERT(out_params.flush_threshold == DEFAULT_FLUSH_THRESHOLD,
830 : : "Expected %u got %u",
831 : : DEFAULT_FLUSH_THRESHOLD, out_params.flush_threshold);
832 [ - + ]: 1 : TEST_ASSERT(out_params.max_nb_tx == TXA_NB_TX_WORK_DEFAULT,
833 : : "Expected %u got %u",
834 : : TXA_NB_TX_WORK_DEFAULT, out_params.max_nb_tx);
835 : :
836 : : /* Case 2: Set max_nb_tx = 32 (=TXA_BATCH_SEIZE) */
837 : 1 : in_params.max_nb_tx = 32;
838 : 1 : in_params.flush_threshold = DEFAULT_FLUSH_THRESHOLD;
839 : :
840 : 1 : err = rte_event_eth_tx_adapter_runtime_params_set(TEST_INST_ID,
841 : : &in_params);
842 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
843 : :
844 : 1 : err = rte_event_eth_tx_adapter_runtime_params_get(TEST_INST_ID,
845 : : &out_params);
846 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
847 [ - + ]: 1 : TEST_ASSERT(in_params.max_nb_tx == out_params.max_nb_tx,
848 : : "Expected %u got %u",
849 : : in_params.max_nb_tx, out_params.max_nb_tx);
850 [ - + ]: 1 : TEST_ASSERT(in_params.flush_threshold == out_params.flush_threshold,
851 : : "Expected %u got %u",
852 : : in_params.flush_threshold, out_params.flush_threshold);
853 : :
854 : : /* Case 3: Set max_nb_tx = 192 */
855 : 1 : in_params.max_nb_tx = 192;
856 : :
857 : 1 : err = rte_event_eth_tx_adapter_runtime_params_set(TEST_INST_ID,
858 : : &in_params);
859 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
860 : :
861 : 1 : err = rte_event_eth_tx_adapter_runtime_params_get(TEST_INST_ID,
862 : : &out_params);
863 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
864 [ - + ]: 1 : TEST_ASSERT(in_params.max_nb_tx == out_params.max_nb_tx,
865 : : "Expected %u got %u",
866 : : in_params.max_nb_tx, out_params.max_nb_tx);
867 : :
868 : : /* Case 4: Set max_nb_tx = 256 */
869 : 1 : in_params.max_nb_tx = 256;
870 : :
871 : 1 : err = rte_event_eth_tx_adapter_runtime_params_set(TEST_INST_ID,
872 : : &in_params);
873 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
874 : :
875 : 1 : err = rte_event_eth_tx_adapter_runtime_params_get(TEST_INST_ID,
876 : : &out_params);
877 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
878 [ - + ]: 1 : TEST_ASSERT(in_params.max_nb_tx == out_params.max_nb_tx,
879 : : "Expected %u got %u",
880 : : in_params.max_nb_tx, out_params.max_nb_tx);
881 : :
882 : : /* Case 5: Set max_nb_tx = 30(<TXA_BATCH_SIZE) */
883 : 1 : in_params.max_nb_tx = 30;
884 : :
885 : 1 : err = rte_event_eth_tx_adapter_runtime_params_set(TEST_INST_ID,
886 : : &in_params);
887 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
888 : :
889 : 1 : err = rte_event_eth_tx_adapter_runtime_params_get(TEST_INST_ID,
890 : : &out_params);
891 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
892 [ - + ]: 1 : TEST_ASSERT(in_params.max_nb_tx == out_params.max_nb_tx,
893 : : "Expected %u got %u",
894 : : in_params.max_nb_tx, out_params.max_nb_tx);
895 : :
896 : : /* Case 6: Set max_nb_tx = 512 */
897 : 1 : in_params.max_nb_tx = 512;
898 : :
899 : 1 : err = rte_event_eth_tx_adapter_runtime_params_set(TEST_INST_ID,
900 : : &in_params);
901 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
902 : :
903 : 1 : err = rte_event_eth_tx_adapter_runtime_params_get(TEST_INST_ID,
904 : : &out_params);
905 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
906 [ - + ]: 1 : TEST_ASSERT(in_params.max_nb_tx == out_params.max_nb_tx,
907 : : "Expected %u got %u",
908 : : in_params.max_nb_tx, out_params.max_nb_tx);
909 : :
910 : : /* Case 7: Set flush_threshold = 10 */
911 : 1 : in_params.max_nb_tx = 128;
912 : 1 : in_params.flush_threshold = 10;
913 : :
914 : 1 : err = rte_event_eth_tx_adapter_runtime_params_set(TEST_INST_ID,
915 : : &in_params);
916 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
917 : :
918 : 1 : err = rte_event_eth_tx_adapter_runtime_params_get(TEST_INST_ID,
919 : : &out_params);
920 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
921 [ - + ]: 1 : TEST_ASSERT(in_params.max_nb_tx == out_params.max_nb_tx,
922 : : "Expected %u got %u",
923 : : in_params.max_nb_tx, out_params.max_nb_tx);
924 [ - + ]: 1 : TEST_ASSERT(in_params.flush_threshold == out_params.flush_threshold,
925 : : "Expected %u got %u",
926 : : in_params.flush_threshold, out_params.flush_threshold);
927 : : rc = TEST_SUCCESS;
928 : 1 : skip:
929 : 1 : err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID,
930 : 1 : TEST_ETHDEV_ID,
931 : : 0);
932 [ - + ]: 1 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
933 : :
934 : : return rc;
935 : : }
936 : :
937 : : static int
938 : 1 : tx_adapter_dynamic_device(void)
939 : : {
940 : 1 : uint16_t port_id = rte_eth_dev_count_avail();
941 : 1 : const char *null_dev[2] = { "eth_null0", "eth_null1" };
942 : : struct rte_eth_conf dev_conf;
943 : : int ret;
944 : : size_t i;
945 : :
946 : : memset(&dev_conf, 0, sizeof(dev_conf));
947 [ + + ]: 3 : for (i = 0; i < RTE_DIM(null_dev); i++) {
948 : 2 : ret = rte_vdev_init(null_dev[i], NULL);
949 [ - + ]: 2 : TEST_ASSERT_SUCCESS(ret, "%s Port creation failed %d",
950 : : null_dev[i], ret);
951 : :
952 [ + + ]: 2 : if (i == 0) {
953 : 1 : ret = tx_adapter_create();
954 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Adapter create failed %d",
955 : : ret);
956 : : }
957 : :
958 : 2 : ret = rte_eth_dev_configure(port_id + i, MAX_NUM_QUEUE,
959 : : MAX_NUM_QUEUE, &dev_conf);
960 [ - + ]: 2 : TEST_ASSERT_SUCCESS(ret, "Failed to configure device %d", ret);
961 : :
962 : 2 : ret = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID,
963 : : port_id + i, 0);
964 [ - + ]: 2 : TEST_ASSERT_SUCCESS(ret, "Failed to add queues %d", ret);
965 : :
966 : : }
967 : :
968 [ + + ]: 3 : for (i = 0; i < RTE_DIM(null_dev); i++) {
969 : 2 : ret = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID,
970 : 2 : port_id + i, -1);
971 [ - + ]: 2 : TEST_ASSERT_SUCCESS(ret, "Failed to delete queues %d", ret);
972 : : }
973 : :
974 : : tx_adapter_free();
975 : :
976 [ + + ]: 3 : for (i = 0; i < RTE_DIM(null_dev); i++)
977 : 2 : rte_vdev_uninit(null_dev[i]);
978 : :
979 : : return TEST_SUCCESS;
980 : : }
981 : :
982 : : static struct unit_test_suite event_eth_tx_tests = {
983 : : .setup = testsuite_setup,
984 : : .teardown = testsuite_teardown,
985 : : .suite_name = "tx event eth adapter test suite",
986 : : .unit_test_cases = {
987 : : TEST_CASE_ST(NULL, NULL, tx_adapter_create_free),
988 : : TEST_CASE_ST(tx_adapter_create, tx_adapter_free,
989 : : tx_adapter_queue_add_del),
990 : : TEST_CASE_ST(tx_adapter_create, tx_adapter_free,
991 : : tx_adapter_start_stop),
992 : : TEST_CASE_ST(tx_adapter_create, tx_adapter_free,
993 : : tx_adapter_service),
994 : : TEST_CASE_ST(tx_adapter_create, tx_adapter_free,
995 : : tx_adapter_instance_get),
996 : : TEST_CASE_ST(tx_adapter_create, tx_adapter_free,
997 : : tx_adapter_queue_start_stop),
998 : : TEST_CASE_ST(tx_adapter_create, tx_adapter_free,
999 : : tx_adapter_set_get_params),
1000 : : TEST_CASE_ST(NULL, NULL, tx_adapter_dynamic_device),
1001 : : TEST_CASES_END() /**< NULL terminate unit test array */
1002 : : }
1003 : : };
1004 : :
1005 : : static int
1006 : 1 : test_event_eth_tx_adapter_common(void)
1007 : : {
1008 : 1 : return unit_test_suite_runner(&event_eth_tx_tests);
1009 : : }
1010 : :
1011 : : #endif /* !RTE_EXEC_ENV_WINDOWS */
1012 : :
1013 : 238 : REGISTER_FAST_TEST(event_eth_tx_adapter_autotest, false, true, test_event_eth_tx_adapter_common);
|