Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2017 Intel Corporation
3 : : */
4 : :
5 : : #include "test.h"
6 : :
7 : : #include <string.h>
8 : : #include <rte_common.h>
9 : : #include <rte_mempool.h>
10 : : #include <rte_mbuf.h>
11 : : #include <rte_ethdev.h>
12 : :
13 : : #ifdef RTE_EXEC_ENV_WINDOWS
14 : : static int
15 : : test_event_eth_rx_adapter_common(void)
16 : : {
17 : : printf("event_eth_rx_adapter not supported on Windows, skipping test\n");
18 : : return TEST_SKIPPED;
19 : : }
20 : :
21 : : static int
22 : : test_event_eth_rx_intr_adapter_common(void)
23 : : {
24 : : printf("event_eth_rx_intr_adapter not supported on Windows, skipping test\n");
25 : : return TEST_SKIPPED;
26 : : }
27 : :
28 : : #else
29 : :
30 : : #include <rte_eventdev.h>
31 : : #include <rte_bus_vdev.h>
32 : :
33 : : #include <rte_event_eth_rx_adapter.h>
34 : :
35 : : #define MAX_NUM_RX_QUEUE 64
36 : : #define NB_MBUFS (8192 * num_ports * MAX_NUM_RX_QUEUE)
37 : : #define MBUF_CACHE_SIZE 512
38 : : #define MBUF_PRIV_SIZE 0
39 : : #define TEST_INST_ID 0
40 : : #define TEST_DEV_ID 0
41 : : #define TEST_ETHDEV_ID 0
42 : : #define TEST_ETH_QUEUE_ID 0
43 : :
44 : : struct event_eth_rx_adapter_test_params {
45 : : struct rte_mempool *mp;
46 : : uint16_t rx_rings, tx_rings;
47 : : uint32_t caps;
48 : : int rx_intr_port_inited;
49 : : uint16_t rx_intr_port;
50 : : };
51 : :
52 : : static struct event_eth_rx_adapter_test_params default_params;
53 : : static bool event_dev_created;
54 : : static bool eth_dev_created;
55 : :
56 : : static inline int
57 : 0 : port_init_common(uint16_t port, const struct rte_eth_conf *port_conf,
58 : : struct rte_mempool *mp)
59 : : {
60 : : const uint16_t rx_ring_size = 512, tx_ring_size = 512;
61 : : int retval;
62 : : uint16_t q;
63 : : struct rte_eth_dev_info dev_info;
64 : :
65 [ # # ]: 0 : if (!rte_eth_dev_is_valid_port(port))
66 : : return -1;
67 : :
68 : 0 : retval = rte_eth_dev_configure(port, 0, 0, port_conf);
69 : :
70 : 0 : retval = rte_eth_dev_info_get(port, &dev_info);
71 [ # # ]: 0 : if (retval != 0)
72 : : return retval;
73 : :
74 : 0 : default_params.rx_rings = RTE_MIN(dev_info.max_rx_queues,
75 : : MAX_NUM_RX_QUEUE);
76 : 0 : default_params.tx_rings = 1;
77 : :
78 : : /* Configure the Ethernet device. */
79 : 0 : retval = rte_eth_dev_configure(port, default_params.rx_rings,
80 : : default_params.tx_rings, port_conf);
81 [ # # ]: 0 : if (retval != 0)
82 : : return retval;
83 : :
84 [ # # ]: 0 : for (q = 0; q < default_params.rx_rings; q++) {
85 : 0 : retval = rte_eth_rx_queue_setup(port, q, rx_ring_size,
86 : 0 : rte_eth_dev_socket_id(port), NULL, mp);
87 [ # # ]: 0 : if (retval < 0)
88 : 0 : return retval;
89 : : }
90 : :
91 : : /* Allocate and set up 1 TX queue per Ethernet port. */
92 [ # # ]: 0 : for (q = 0; q < default_params.tx_rings; q++) {
93 : 0 : retval = rte_eth_tx_queue_setup(port, q, tx_ring_size,
94 : 0 : rte_eth_dev_socket_id(port), NULL);
95 [ # # ]: 0 : if (retval < 0)
96 : 0 : return retval;
97 : : }
98 : :
99 : : /* Start the Ethernet port. */
100 : 0 : retval = rte_eth_dev_start(port);
101 [ # # ]: 0 : if (retval < 0)
102 : : return retval;
103 : :
104 : : /* Display the port MAC address. */
105 : : struct rte_ether_addr addr;
106 : 0 : retval = rte_eth_macaddr_get(port, &addr);
107 [ # # ]: 0 : if (retval < 0)
108 : : return retval;
109 : 0 : printf("Port %u MAC: %02" PRIx8 " %02" PRIx8 " %02" PRIx8
110 : : " %02" PRIx8 " %02" PRIx8 " %02" PRIx8 "\n",
111 : 0 : (unsigned int)port, RTE_ETHER_ADDR_BYTES(&addr));
112 : :
113 : : /* Enable RX in promiscuous mode for the Ethernet device. */
114 : 0 : retval = rte_eth_promiscuous_enable(port);
115 [ # # ]: 0 : if (retval != 0)
116 : 0 : return retval;
117 : :
118 : : return 0;
119 : : }
120 : :
121 : : static inline int
122 : : port_init_rx_intr(uint16_t port, struct rte_mempool *mp)
123 : : {
124 : : static const struct rte_eth_conf port_conf_default = {
125 : : .rxmode = {
126 : : .mq_mode = RTE_ETH_MQ_RX_NONE,
127 : : },
128 : : .intr_conf = {
129 : : .rxq = 1,
130 : : },
131 : : };
132 : :
133 : 0 : return port_init_common(port, &port_conf_default, mp);
134 : : }
135 : :
136 : : static inline int
137 : : port_init(uint16_t port, struct rte_mempool *mp)
138 : : {
139 : : static const struct rte_eth_conf port_conf_default = {
140 : : .rxmode = {
141 : : .mq_mode = RTE_ETH_MQ_RX_NONE,
142 : : },
143 : : };
144 : :
145 : 0 : return port_init_common(port, &port_conf_default, mp);
146 : : }
147 : :
148 : : static int
149 : 0 : init_port_rx_intr(int num_ports)
150 : : {
151 : : int retval;
152 : : uint16_t portid;
153 : : int err;
154 : :
155 : 0 : default_params.mp = rte_pktmbuf_pool_create("packet_pool",
156 : 0 : NB_MBUFS,
157 : : MBUF_CACHE_SIZE,
158 : : MBUF_PRIV_SIZE,
159 : : RTE_MBUF_DEFAULT_BUF_SIZE,
160 : 0 : rte_socket_id());
161 [ # # ]: 0 : if (!default_params.mp)
162 : : return -ENOMEM;
163 : :
164 [ # # ]: 0 : RTE_ETH_FOREACH_DEV(portid) {
165 : 0 : retval = port_init_rx_intr(portid, default_params.mp);
166 [ # # ]: 0 : if (retval)
167 : 0 : continue;
168 : 0 : err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, portid,
169 : : &default_params.caps);
170 [ # # ]: 0 : if (err)
171 : 0 : continue;
172 [ # # ]: 0 : if (!(default_params.caps &
173 : : RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT)) {
174 : 0 : default_params.rx_intr_port_inited = 1;
175 : 0 : default_params.rx_intr_port = portid;
176 : 0 : return 0;
177 : : }
178 : 0 : retval = rte_eth_dev_stop(portid);
179 [ # # ]: 0 : TEST_ASSERT(retval == 0, "Failed to stop port %u: %d\n",
180 : : portid, retval);
181 : : }
182 : : return 0;
183 : : }
184 : :
185 : : static int
186 : 0 : init_ports(int num_ports)
187 : : {
188 : : uint16_t portid;
189 : : int retval;
190 : :
191 : 0 : struct rte_mempool *ptr = rte_mempool_lookup("packet_pool");
192 : :
193 [ # # ]: 0 : if (ptr == NULL)
194 : 0 : default_params.mp = rte_pktmbuf_pool_create("packet_pool",
195 : 0 : NB_MBUFS,
196 : : MBUF_CACHE_SIZE,
197 : : MBUF_PRIV_SIZE,
198 : : RTE_MBUF_DEFAULT_BUF_SIZE,
199 : 0 : rte_socket_id());
200 : : else
201 : 0 : default_params.mp = ptr;
202 : :
203 [ # # ]: 0 : if (!default_params.mp)
204 : : return -ENOMEM;
205 : :
206 [ # # ]: 0 : RTE_ETH_FOREACH_DEV(portid) {
207 : 0 : retval = port_init(portid, default_params.mp);
208 [ # # ]: 0 : if (retval)
209 : 0 : return retval;
210 : : }
211 : :
212 : : return 0;
213 : : }
214 : :
215 : : static int
216 : 0 : testsuite_setup(void)
217 : : {
218 : : int err;
219 : : uint8_t count;
220 : : struct rte_event_dev_info dev_info;
221 : :
222 : 0 : count = rte_event_dev_count();
223 [ # # ]: 0 : if (!count) {
224 : : printf("Failed to find a valid event device,"
225 : : " testing with event_skeleton device\n");
226 : 0 : err = rte_vdev_init("event_skeleton", NULL);
227 [ # # ]: 0 : TEST_ASSERT(err == 0, "Failed to create event_skeleton. err=%d",
228 : : err);
229 : 0 : event_dev_created = true;
230 : : }
231 : :
232 : 0 : struct rte_event_dev_config config = {
233 : : .nb_event_queues = 1,
234 : : .nb_event_ports = 1,
235 : : };
236 : :
237 : 0 : err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
238 : 0 : config.nb_event_queue_flows = dev_info.max_event_queue_flows;
239 : 0 : config.nb_event_port_dequeue_depth =
240 : 0 : dev_info.max_event_port_dequeue_depth;
241 : 0 : config.nb_event_port_enqueue_depth =
242 : 0 : dev_info.max_event_port_enqueue_depth;
243 : 0 : config.nb_events_limit =
244 : 0 : dev_info.max_num_events;
245 : 0 : err = rte_event_dev_configure(TEST_DEV_ID, &config);
246 [ # # ]: 0 : TEST_ASSERT(err == 0, "Event device initialization failed err %d\n",
247 : : err);
248 : :
249 : 0 : count = rte_eth_dev_count_total();
250 [ # # ]: 0 : if (!count) {
251 : : printf("Testing with net_null device\n");
252 : 0 : err = rte_vdev_init("net_null", NULL);
253 [ # # ]: 0 : TEST_ASSERT(err == 0, "Failed to create net_null. err=%d",
254 : : err);
255 : 0 : eth_dev_created = true;
256 : : }
257 : :
258 : : /*
259 : : * eth devices like octeontx use event device to receive packets
260 : : * so rte_eth_dev_start invokes rte_event_dev_start internally, so
261 : : * call init_ports after rte_event_dev_configure
262 : : */
263 : 0 : err = init_ports(rte_eth_dev_count_total());
264 [ # # ]: 0 : TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err);
265 : :
266 : 0 : err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID,
267 : : &default_params.caps);
268 [ # # ]: 0 : TEST_ASSERT(err == 0, "Failed to get adapter cap err %d\n",
269 : : err);
270 : :
271 : : return err;
272 : : }
273 : :
274 : : static int
275 : 0 : testsuite_setup_rx_intr(void)
276 : : {
277 : : int err;
278 : : uint8_t count;
279 : : struct rte_event_dev_info dev_info;
280 : :
281 : 0 : count = rte_event_dev_count();
282 [ # # ]: 0 : if (!count) {
283 : : printf("Failed to find a valid event device,"
284 : : " testing with event_skeleton device\n");
285 : 0 : err = rte_vdev_init("event_skeleton", NULL);
286 [ # # ]: 0 : TEST_ASSERT(err == 0, "Failed to create event_skeleton. err=%d",
287 : : err);
288 : 0 : event_dev_created = true;
289 : : }
290 : :
291 : 0 : struct rte_event_dev_config config = {
292 : : .nb_event_queues = 1,
293 : : .nb_event_ports = 1,
294 : : };
295 : :
296 : 0 : err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
297 : 0 : config.nb_event_queue_flows = dev_info.max_event_queue_flows;
298 : 0 : config.nb_event_port_dequeue_depth =
299 : 0 : dev_info.max_event_port_dequeue_depth;
300 : 0 : config.nb_event_port_enqueue_depth =
301 : 0 : dev_info.max_event_port_enqueue_depth;
302 : 0 : config.nb_events_limit =
303 : 0 : dev_info.max_num_events;
304 : :
305 : 0 : err = rte_event_dev_configure(TEST_DEV_ID, &config);
306 [ # # ]: 0 : TEST_ASSERT(err == 0, "Event device initialization failed err %d\n",
307 : : err);
308 : :
309 : 0 : count = rte_eth_dev_count_total();
310 [ # # ]: 0 : if (!count) {
311 : : printf("Testing with net_null device\n");
312 : 0 : err = rte_vdev_init("net_null", NULL);
313 [ # # ]: 0 : TEST_ASSERT(err == 0, "Failed to create net_null. err=%d",
314 : : err);
315 : 0 : eth_dev_created = true;
316 : : }
317 : :
318 : : /*
319 : : * eth devices like octeontx use event device to receive packets
320 : : * so rte_eth_dev_start invokes rte_event_dev_start internally, so
321 : : * call init_ports after rte_event_dev_configure
322 : : */
323 : 0 : err = init_port_rx_intr(rte_eth_dev_count_total());
324 [ # # ]: 0 : TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err);
325 : :
326 [ # # ]: 0 : if (!default_params.rx_intr_port_inited)
327 : : return 0;
328 : :
329 : 0 : err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID,
330 : 0 : default_params.rx_intr_port,
331 : : &default_params.caps);
332 [ # # ]: 0 : TEST_ASSERT(err == 0, "Failed to get adapter cap err %d\n", err);
333 : :
334 : : return err;
335 : : }
336 : :
337 : : static void
338 : 0 : testsuite_teardown(void)
339 : : {
340 : : int err;
341 : : uint32_t i;
342 [ # # ]: 0 : RTE_ETH_FOREACH_DEV(i)
343 : 0 : rte_eth_dev_stop(i);
344 : :
345 [ # # ]: 0 : if (eth_dev_created) {
346 : 0 : err = rte_vdev_uninit("net_null");
347 [ # # ]: 0 : if (err)
348 : : printf("Failed to delete net_null. err=%d", err);
349 : 0 : eth_dev_created = false;
350 : : }
351 : :
352 : 0 : rte_mempool_free(default_params.mp);
353 [ # # ]: 0 : if (event_dev_created) {
354 : 0 : err = rte_vdev_uninit("event_skeleton");
355 [ # # ]: 0 : if (err)
356 : : printf("Failed to delete event_skeleton. err=%d", err);
357 : 0 : event_dev_created = false;
358 : : }
359 : :
360 : : memset(&default_params, 0, sizeof(default_params));
361 : 0 : }
362 : :
363 : : static void
364 : 0 : testsuite_teardown_rx_intr(void)
365 : : {
366 : : int err;
367 [ # # ]: 0 : if (!default_params.rx_intr_port_inited)
368 : : return;
369 : :
370 : 0 : rte_eth_dev_stop(default_params.rx_intr_port);
371 [ # # ]: 0 : if (eth_dev_created) {
372 : 0 : err = rte_vdev_uninit("net_null");
373 [ # # ]: 0 : if (err)
374 : : printf("Failed to delete net_null. err=%d", err);
375 : 0 : eth_dev_created = false;
376 : : }
377 : 0 : rte_mempool_free(default_params.mp);
378 [ # # ]: 0 : if (event_dev_created) {
379 : 0 : err = rte_vdev_uninit("event_skeleton");
380 [ # # ]: 0 : if (err)
381 : : printf("Failed to delete event_skeleton. err=%d", err);
382 : 0 : event_dev_created = false;
383 : : }
384 : :
385 : : memset(&default_params, 0, sizeof(default_params));
386 : : }
387 : :
388 : : static int
389 : 0 : adapter_create(void)
390 : : {
391 : : int err;
392 : : struct rte_event_dev_info dev_info;
393 : : struct rte_event_port_conf rx_p_conf;
394 : :
395 : : memset(&rx_p_conf, 0, sizeof(rx_p_conf));
396 : :
397 : 0 : err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
398 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
399 : :
400 : 0 : rx_p_conf.new_event_threshold = dev_info.max_num_events;
401 : 0 : rx_p_conf.dequeue_depth = dev_info.max_event_port_dequeue_depth;
402 : 0 : rx_p_conf.enqueue_depth = dev_info.max_event_port_enqueue_depth;
403 : 0 : err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
404 : : &rx_p_conf);
405 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
406 : :
407 : : return err;
408 : : }
409 : :
410 : : static void
411 : 0 : adapter_free(void)
412 : : {
413 : 0 : rte_event_eth_rx_adapter_free(TEST_INST_ID);
414 : 0 : }
415 : :
416 : : static int
417 : 0 : adapter_create_with_params(void)
418 : : {
419 : : int err;
420 : : struct rte_event_dev_info dev_info;
421 : : struct rte_event_port_conf rx_p_conf;
422 : : struct rte_event_eth_rx_adapter_params rxa_params;
423 : :
424 : : memset(&rx_p_conf, 0, sizeof(rx_p_conf));
425 : :
426 : 0 : err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
427 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
428 : :
429 : 0 : rx_p_conf.new_event_threshold = dev_info.max_num_events;
430 : 0 : rx_p_conf.dequeue_depth = dev_info.max_event_port_dequeue_depth;
431 : 0 : rx_p_conf.enqueue_depth = dev_info.max_event_port_enqueue_depth;
432 : :
433 : 0 : rxa_params.use_queue_event_buf = false;
434 : 0 : rxa_params.event_buf_size = 0;
435 : :
436 : : /* Pass rxa_params = NULL */
437 : 0 : err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID,
438 : : TEST_DEV_ID, &rx_p_conf, NULL);
439 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
440 : : if (err == 0)
441 : : adapter_free();
442 : :
443 : 0 : err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID,
444 : : TEST_DEV_ID, &rx_p_conf, &rxa_params);
445 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
446 : :
447 : 0 : rxa_params.use_queue_event_buf = true;
448 : :
449 : 0 : err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID,
450 : : TEST_DEV_ID, &rx_p_conf, &rxa_params);
451 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
452 : :
453 : 0 : err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID,
454 : : TEST_DEV_ID, &rx_p_conf, &rxa_params);
455 [ # # ]: 0 : TEST_ASSERT(err == -EEXIST, "Expected -EEXIST got %d", err);
456 : :
457 : : return TEST_SUCCESS;
458 : : }
459 : :
460 : : static int
461 : 0 : test_port_conf_cb(uint8_t id, uint8_t event_dev_id,
462 : : struct rte_event_eth_rx_adapter_conf *conf,
463 : : void *conf_arg)
464 : : {
465 : 0 : struct rte_event_port_conf *port_conf, def_port_conf = {0};
466 : : uint32_t started;
467 : : static int port_allocated;
468 : : static uint8_t port_id;
469 : : int ret;
470 : :
471 [ # # ]: 0 : if (port_allocated) {
472 : 0 : conf->event_port_id = port_id;
473 : 0 : conf->max_nb_rx = 128;
474 : 0 : return 0;
475 : : }
476 : :
477 : : RTE_SET_USED(id);
478 : :
479 : 0 : ret = rte_event_dev_attr_get(event_dev_id, RTE_EVENT_DEV_ATTR_STARTED,
480 : : &started);
481 [ # # ]: 0 : if (ret < 0)
482 : : return ret;
483 : :
484 [ # # ]: 0 : if (started)
485 : 0 : rte_event_dev_stop(event_dev_id);
486 : :
487 : 0 : port_id = 1;
488 : :
489 [ # # ]: 0 : if (conf_arg != NULL)
490 : : port_conf = conf_arg;
491 : : else {
492 : : port_conf = &def_port_conf;
493 : 0 : ret = rte_event_port_default_conf_get(event_dev_id, port_id,
494 : : port_conf);
495 [ # # ]: 0 : if (ret < 0)
496 : : return ret;
497 : : }
498 : :
499 : 0 : ret = rte_event_port_setup(event_dev_id, port_id, port_conf);
500 [ # # ]: 0 : if (ret < 0)
501 : : return ret;
502 : :
503 : 0 : conf->event_port_id = port_id;
504 : 0 : conf->max_nb_rx = 128;
505 : :
506 [ # # ]: 0 : if (started)
507 : 0 : rte_event_dev_start(event_dev_id);
508 : :
509 : : /* Reuse this port number next time this is called */
510 : 0 : port_allocated = 1;
511 : :
512 : 0 : return 0;
513 : : }
514 : :
515 : : static int
516 : 0 : adapter_create_ext_with_params(void)
517 : : {
518 : : int err;
519 : : struct rte_event_dev_info dev_info;
520 : : struct rte_event_eth_rx_adapter_params rxa_params;
521 : :
522 : 0 : err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
523 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
524 : :
525 : 0 : rxa_params.use_queue_event_buf = false;
526 : 0 : rxa_params.event_buf_size = 0;
527 : :
528 : : /* Pass rxa_params = NULL */
529 : 0 : err = rte_event_eth_rx_adapter_create_ext_with_params(TEST_INST_ID,
530 : : TEST_DEV_ID, test_port_conf_cb, NULL, NULL);
531 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
532 : : if (err == 0)
533 : : adapter_free();
534 : :
535 : 0 : err = rte_event_eth_rx_adapter_create_ext_with_params(TEST_INST_ID,
536 : : TEST_DEV_ID, test_port_conf_cb, NULL, &rxa_params);
537 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
538 : :
539 : 0 : rxa_params.event_buf_size = 128;
540 : :
541 : 0 : err = rte_event_eth_rx_adapter_create_ext_with_params(TEST_INST_ID,
542 : : TEST_DEV_ID, test_port_conf_cb, NULL, &rxa_params);
543 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
544 : :
545 : 0 : err = rte_event_eth_rx_adapter_create_ext_with_params(TEST_INST_ID,
546 : : TEST_DEV_ID, test_port_conf_cb, NULL, &rxa_params);
547 [ # # ]: 0 : TEST_ASSERT(err == -EEXIST, "Expected -EEXIST got %d", err);
548 : :
549 : : return TEST_SUCCESS;
550 : : }
551 : :
552 : : static int
553 : 0 : adapter_queue_event_buf_test(void)
554 : : {
555 : : int err;
556 : : struct rte_event ev;
557 : : uint32_t cap;
558 : :
559 : 0 : struct rte_event_eth_rx_adapter_queue_conf queue_config = {0};
560 : :
561 : 0 : err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID,
562 : : &cap);
563 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
564 : :
565 : : ev.queue_id = 0;
566 : : ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
567 : : ev.priority = 0;
568 : :
569 : 0 : queue_config.rx_queue_flags = 0;
570 [ # # ]: 0 : if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) {
571 : : ev.flow_id = 1;
572 : 0 : queue_config.rx_queue_flags =
573 : : RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID;
574 : : }
575 : 0 : queue_config.ev = ev;
576 : 0 : queue_config.servicing_weight = 1;
577 : 0 : queue_config.event_buf_size = 0;
578 : :
579 : 0 : err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
580 : : TEST_ETHDEV_ID, 0,
581 : : &queue_config);
582 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
583 : :
584 : 0 : queue_config.event_buf_size = 1024;
585 : :
586 : 0 : err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
587 : : TEST_ETHDEV_ID, 0,
588 : : &queue_config);
589 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
590 : :
591 : 0 : err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
592 : : TEST_ETHDEV_ID,
593 : : 0);
594 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
595 : :
596 : : return TEST_SUCCESS;
597 : : }
598 : :
599 : : static int
600 : 0 : adapter_queue_stats_test(void)
601 : : {
602 : : int err;
603 : : struct rte_event ev;
604 : : uint32_t cap;
605 : 0 : struct rte_event_eth_rx_adapter_queue_conf queue_config = {0};
606 : : struct rte_event_eth_rx_adapter_queue_stats q_stats;
607 : :
608 : 0 : err = rte_event_eth_rx_adapter_queue_stats_get(TEST_INST_ID,
609 : : TEST_ETHDEV_ID, 0,
610 : : &q_stats);
611 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
612 : :
613 : 0 : err = rte_event_eth_rx_adapter_queue_stats_reset(TEST_INST_ID,
614 : : TEST_ETHDEV_ID, 0);
615 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
616 : :
617 : 0 : err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID,
618 : : &cap);
619 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
620 : :
621 : : ev.queue_id = 0;
622 : : ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
623 : : ev.priority = 0;
624 : :
625 : 0 : queue_config.rx_queue_flags = 0;
626 [ # # ]: 0 : if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) {
627 : : ev.flow_id = 1;
628 : 0 : queue_config.rx_queue_flags =
629 : : RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID;
630 : : }
631 : 0 : queue_config.ev = ev;
632 : 0 : queue_config.servicing_weight = 1;
633 : 0 : queue_config.event_buf_size = 1024;
634 : :
635 : 0 : err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
636 : : TEST_ETHDEV_ID, 0,
637 : : &queue_config);
638 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
639 : :
640 : 0 : err = rte_event_eth_rx_adapter_queue_stats_get(TEST_INST_ID,
641 : : TEST_ETHDEV_ID, 0,
642 : : &q_stats);
643 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
644 : :
645 : 0 : err = rte_event_eth_rx_adapter_queue_stats_reset(TEST_INST_ID,
646 : : TEST_ETHDEV_ID, 0);
647 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
648 : :
649 : 0 : err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
650 : : TEST_ETHDEV_ID,
651 : : 0);
652 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
653 : :
654 : : return TEST_SUCCESS;
655 : : }
656 : :
657 : : static int
658 : 0 : adapter_create_free(void)
659 : : {
660 : : int err;
661 : :
662 : 0 : struct rte_event_port_conf rx_p_conf = {
663 : : .dequeue_depth = 8,
664 : : .enqueue_depth = 8,
665 : : .new_event_threshold = 1200,
666 : : };
667 : :
668 : 0 : err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
669 : : NULL);
670 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
671 : :
672 : 0 : err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
673 : : &rx_p_conf);
674 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
675 : :
676 : 0 : err = rte_event_eth_rx_adapter_create(TEST_INST_ID,
677 : : TEST_DEV_ID, &rx_p_conf);
678 [ # # ]: 0 : TEST_ASSERT(err == -EEXIST, "Expected -EEXIST %d got %d", -EEXIST, err);
679 : :
680 : 0 : err = rte_event_eth_rx_adapter_free(TEST_INST_ID);
681 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
682 : :
683 : 0 : err = rte_event_eth_rx_adapter_free(TEST_INST_ID);
684 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
685 : :
686 : 0 : err = rte_event_eth_rx_adapter_free(1);
687 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
688 : :
689 : : return TEST_SUCCESS;
690 : : }
691 : :
692 : : static int
693 : 0 : adapter_create_free_with_params(void)
694 : : {
695 : : int err;
696 : :
697 : 0 : struct rte_event_port_conf rx_p_conf = {
698 : : .dequeue_depth = 8,
699 : : .enqueue_depth = 8,
700 : : .new_event_threshold = 1200,
701 : : };
702 : :
703 : 0 : struct rte_event_eth_rx_adapter_params rxa_params = {
704 : : .event_buf_size = 1024
705 : : };
706 : :
707 : 0 : err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID,
708 : : TEST_DEV_ID, NULL, NULL);
709 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
710 : :
711 : 0 : err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID,
712 : : TEST_DEV_ID, &rx_p_conf, &rxa_params);
713 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
714 : :
715 : 0 : err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID,
716 : : TEST_DEV_ID, &rx_p_conf, &rxa_params);
717 [ # # ]: 0 : TEST_ASSERT(err == -EEXIST, "Expected -EEXIST %d got %d", -EEXIST, err);
718 : :
719 : 0 : rxa_params.event_buf_size = 0;
720 : 0 : err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID,
721 : : TEST_DEV_ID, &rx_p_conf, &rxa_params);
722 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
723 : :
724 : 0 : err = rte_event_eth_rx_adapter_free(TEST_INST_ID);
725 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
726 : :
727 : 0 : err = rte_event_eth_rx_adapter_free(TEST_INST_ID);
728 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
729 : :
730 : 0 : err = rte_event_eth_rx_adapter_free(1);
731 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
732 : :
733 : : return TEST_SUCCESS;
734 : : }
735 : :
736 : : static int
737 : 0 : adapter_queue_add_del(void)
738 : : {
739 : : int err;
740 : : struct rte_event ev;
741 : : uint32_t cap;
742 : :
743 : 0 : struct rte_event_eth_rx_adapter_queue_conf queue_config = {0};
744 : :
745 : 0 : err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID,
746 : : &cap);
747 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
748 : :
749 : : ev.queue_id = 0;
750 : : ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
751 : : ev.priority = 0;
752 : :
753 : 0 : queue_config.rx_queue_flags = 0;
754 [ # # ]: 0 : if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) {
755 : : ev.flow_id = 1;
756 : 0 : queue_config.rx_queue_flags =
757 : : RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID;
758 : : }
759 : 0 : queue_config.ev = ev;
760 : 0 : queue_config.servicing_weight = 1;
761 : :
762 : 0 : err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
763 : 0 : rte_eth_dev_count_total(),
764 : : -1, &queue_config);
765 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
766 : :
767 [ # # ]: 0 : if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) {
768 : 0 : err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
769 : : TEST_ETHDEV_ID, 0,
770 : : &queue_config);
771 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
772 : :
773 : 0 : err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
774 : : TEST_ETHDEV_ID, 0);
775 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
776 : :
777 : 0 : err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
778 : : TEST_ETHDEV_ID,
779 : : -1,
780 : : &queue_config);
781 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
782 : :
783 : 0 : err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
784 : : TEST_ETHDEV_ID,
785 : : -1);
786 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
787 : : } else {
788 : 0 : err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
789 : : TEST_ETHDEV_ID,
790 : : 0,
791 : : &queue_config);
792 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected EINVAL got %d", err);
793 : :
794 : 0 : err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
795 : : TEST_ETHDEV_ID, -1,
796 : : &queue_config);
797 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
798 : :
799 : 0 : err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
800 : : TEST_ETHDEV_ID, 0);
801 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
802 : :
803 : 0 : err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
804 : : TEST_ETHDEV_ID, -1);
805 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
806 : :
807 : 0 : err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
808 : : TEST_ETHDEV_ID, -1);
809 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
810 : : }
811 : :
812 : 0 : err = rte_event_eth_rx_adapter_queue_add(1, TEST_ETHDEV_ID, -1,
813 : : &queue_config);
814 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
815 : :
816 : 0 : err = rte_event_eth_rx_adapter_queue_del(1, TEST_ETHDEV_ID, -1);
817 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
818 : :
819 : : return TEST_SUCCESS;
820 : : }
821 : :
822 : : static int
823 : 0 : adapter_multi_eth_add_del(void)
824 : : {
825 : : int err;
826 : : struct rte_event ev;
827 : :
828 : : uint16_t port_index, port_index_base, drv_id = 0;
829 : : char driver_name[50];
830 : :
831 : 0 : struct rte_event_eth_rx_adapter_queue_conf queue_config = {0};
832 : :
833 : : ev.queue_id = 0;
834 : : ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
835 : : ev.priority = 0;
836 : :
837 : : queue_config.rx_queue_flags = 0;
838 : 0 : queue_config.ev = ev;
839 : 0 : queue_config.servicing_weight = 1;
840 : :
841 : : /* stop eth devices for existing */
842 : : port_index = 0;
843 [ # # ]: 0 : for (; port_index < rte_eth_dev_count_total(); port_index += 1) {
844 : 0 : err = rte_eth_dev_stop(port_index);
845 [ # # ]: 0 : TEST_ASSERT(err == 0, "Failed to stop port %u: %d\n",
846 : : port_index, err);
847 : : }
848 : :
849 : : /* add the max port for rx_adapter */
850 : 0 : port_index = rte_eth_dev_count_total();
851 : : port_index_base = port_index;
852 [ # # ]: 0 : for (; port_index < RTE_MAX_ETHPORTS; port_index += 1) {
853 : 0 : snprintf(driver_name, sizeof(driver_name), "%s%u", "net_null",
854 : : drv_id);
855 : 0 : err = rte_vdev_init(driver_name, NULL);
856 [ # # ]: 0 : TEST_ASSERT(err == 0, "Failed driver %s got %d",
857 : : driver_name, err);
858 : 0 : drv_id += 1;
859 : : }
860 : :
861 : 0 : err = init_ports(rte_eth_dev_count_total());
862 [ # # ]: 0 : TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err);
863 : :
864 : : /* eth_rx_adapter_queue_add for n ports */
865 : : port_index = 0;
866 [ # # ]: 0 : for (; port_index < rte_eth_dev_count_total(); port_index += 1) {
867 : 0 : err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
868 : : port_index, -1,
869 : : &queue_config);
870 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
871 : : }
872 : :
873 : : /* eth_rx_adapter_queue_del n ports */
874 : : port_index = 0;
875 [ # # ]: 0 : for (; port_index < rte_eth_dev_count_total(); port_index += 1) {
876 : 0 : err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
877 : : port_index, -1);
878 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
879 : : }
880 : :
881 : : /* delete vdev ports */
882 : : for (drv_id = 0, port_index = port_index_base;
883 [ # # ]: 0 : port_index < RTE_MAX_ETHPORTS;
884 : 0 : drv_id += 1, port_index += 1) {
885 : 0 : snprintf(driver_name, sizeof(driver_name), "%s%u", "net_null",
886 : : drv_id);
887 : 0 : err = rte_vdev_uninit(driver_name);
888 [ # # ]: 0 : TEST_ASSERT(err == 0, "Failed driver %s got %d",
889 : : driver_name, err);
890 : : }
891 : :
892 : : return TEST_SUCCESS;
893 : : }
894 : :
895 : : static int
896 : 0 : adapter_intr_queue_add_del(void)
897 : : {
898 : : int err;
899 : : struct rte_event ev;
900 : : uint32_t cap;
901 : : uint16_t eth_port;
902 : 0 : struct rte_event_eth_rx_adapter_queue_conf queue_config = {0};
903 : :
904 [ # # ]: 0 : if (!default_params.rx_intr_port_inited)
905 : : return 0;
906 : :
907 : 0 : eth_port = default_params.rx_intr_port;
908 : 0 : err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, eth_port, &cap);
909 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
910 : :
911 : : ev.queue_id = 0;
912 : : ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
913 : : ev.priority = 0;
914 : :
915 : 0 : queue_config.rx_queue_flags = 0;
916 : 0 : queue_config.ev = ev;
917 : :
918 : : /* weight = 0 => interrupt mode */
919 : 0 : queue_config.servicing_weight = 0;
920 : :
921 [ # # ]: 0 : if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) {
922 : : /* add queue 0 */
923 : 0 : err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
924 : : TEST_ETHDEV_ID, 0,
925 : : &queue_config);
926 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
927 : : }
928 : :
929 : : /* add all queues */
930 : 0 : queue_config.servicing_weight = 0;
931 : 0 : err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
932 : : TEST_ETHDEV_ID,
933 : : -1,
934 : : &queue_config);
935 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
936 : :
937 [ # # ]: 0 : if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) {
938 : : /* del queue 0 */
939 : 0 : err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
940 : : TEST_ETHDEV_ID,
941 : : 0);
942 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
943 : : }
944 : :
945 : : /* del remaining queues */
946 : 0 : err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
947 : : TEST_ETHDEV_ID,
948 : : -1);
949 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
950 : :
951 : : /* add all queues */
952 : 0 : queue_config.servicing_weight = 0;
953 : 0 : err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
954 : : TEST_ETHDEV_ID,
955 : : -1,
956 : : &queue_config);
957 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
958 : :
959 : : /* intr -> poll mode queue */
960 : 0 : queue_config.servicing_weight = 1;
961 : :
962 [ # # ]: 0 : if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) {
963 : 0 : err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
964 : : TEST_ETHDEV_ID,
965 : : 0,
966 : : &queue_config);
967 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
968 : : }
969 : :
970 : 0 : err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
971 : : TEST_ETHDEV_ID,
972 : : -1,
973 : : &queue_config);
974 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
975 : :
976 : : /* del queues */
977 : 0 : err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
978 : : TEST_ETHDEV_ID,
979 : : -1);
980 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
981 : :
982 : : return TEST_SUCCESS;
983 : : }
984 : :
985 : : static int
986 : 0 : adapter_start_stop(void)
987 : : {
988 : : int err;
989 : : struct rte_event ev;
990 : :
991 : : ev.queue_id = 0;
992 : : ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
993 : : ev.priority = 0;
994 : :
995 : 0 : struct rte_event_eth_rx_adapter_queue_conf queue_config = {0};
996 : :
997 : : queue_config.rx_queue_flags = 0;
998 [ # # ]: 0 : if (default_params.caps &
999 : : RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) {
1000 : : ev.flow_id = 1;
1001 : 0 : queue_config.rx_queue_flags =
1002 : : RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID;
1003 : : }
1004 : :
1005 : 0 : queue_config.ev = ev;
1006 : 0 : queue_config.servicing_weight = 1;
1007 : :
1008 : 0 : err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, TEST_ETHDEV_ID,
1009 : : -1, &queue_config);
1010 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1011 : :
1012 : 0 : err = rte_event_eth_rx_adapter_start(TEST_INST_ID);
1013 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1014 : :
1015 : 0 : err = rte_event_eth_rx_adapter_stop(TEST_INST_ID);
1016 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1017 : :
1018 : 0 : err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, TEST_ETHDEV_ID,
1019 : : -1);
1020 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1021 : :
1022 : 0 : err = rte_event_eth_rx_adapter_start(TEST_INST_ID);
1023 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1024 : :
1025 : 0 : err = rte_event_eth_rx_adapter_stop(TEST_INST_ID);
1026 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1027 : :
1028 : 0 : err = rte_event_eth_rx_adapter_start(1);
1029 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
1030 : :
1031 : 0 : err = rte_event_eth_rx_adapter_stop(1);
1032 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
1033 : :
1034 : : return TEST_SUCCESS;
1035 : : }
1036 : :
1037 : : static int
1038 : 0 : adapter_stats(void)
1039 : : {
1040 : : int err;
1041 : : struct rte_event_eth_rx_adapter_stats stats;
1042 : :
1043 : 0 : err = rte_event_eth_rx_adapter_stats_get(TEST_INST_ID, NULL);
1044 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
1045 : :
1046 : 0 : err = rte_event_eth_rx_adapter_stats_get(TEST_INST_ID, &stats);
1047 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1048 : :
1049 : 0 : err = rte_event_eth_rx_adapter_stats_get(1, &stats);
1050 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
1051 : :
1052 : : return TEST_SUCCESS;
1053 : : }
1054 : :
1055 : : static int
1056 : 0 : adapter_queue_conf(void)
1057 : : {
1058 : : int err;
1059 : 0 : struct rte_event_eth_rx_adapter_queue_conf queue_conf = {0};
1060 : :
1061 : : /* Case 1: queue conf get without any queues in Rx adapter */
1062 : 0 : err = rte_event_eth_rx_adapter_queue_conf_get(TEST_INST_ID,
1063 : : TEST_ETHDEV_ID,
1064 : : 0, &queue_conf);
1065 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
1066 : :
1067 : : /* Add queue to Rx adapter */
1068 : 0 : queue_conf.ev.queue_id = 0;
1069 : 0 : queue_conf.ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
1070 : 0 : queue_conf.ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL;
1071 : :
1072 : 0 : err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
1073 : : TEST_ETHDEV_ID,
1074 : : 0, &queue_conf);
1075 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1076 : :
1077 : : /* Case 2: queue conf get with queue added to Rx adapter */
1078 : 0 : err = rte_event_eth_rx_adapter_queue_conf_get(TEST_INST_ID,
1079 : : TEST_ETHDEV_ID,
1080 : : 0, &queue_conf);
1081 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1082 : :
1083 : : /* Case 3: queue conf get with invalid rx queue id */
1084 : 0 : err = rte_event_eth_rx_adapter_queue_conf_get(TEST_INST_ID,
1085 : : TEST_ETHDEV_ID,
1086 : : -1, &queue_conf);
1087 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
1088 : :
1089 : : /* Case 4: queue conf get with NULL queue conf struct */
1090 : 0 : err = rte_event_eth_rx_adapter_queue_conf_get(TEST_INST_ID,
1091 : : TEST_ETHDEV_ID,
1092 : : 0, NULL);
1093 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
1094 : :
1095 : : /* Delete queue from the Rx adapter */
1096 : 0 : err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
1097 : : TEST_ETHDEV_ID,
1098 : : 0);
1099 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1100 : :
1101 : : return TEST_SUCCESS;
1102 : : }
1103 : :
1104 : : static int
1105 : 0 : adapter_pollq_instance_get(void)
1106 : : {
1107 : : int err;
1108 : : uint8_t inst_id;
1109 : : uint16_t eth_dev_id;
1110 : : struct rte_eth_dev_info dev_info;
1111 : 0 : struct rte_event_eth_rx_adapter_queue_conf queue_conf = {0};
1112 : :
1113 : : /* Case 1: Test without configuring eth */
1114 : 0 : err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID,
1115 : : TEST_ETH_QUEUE_ID,
1116 : : &inst_id);
1117 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
1118 : :
1119 : : /* Case 2: Test with wrong eth port */
1120 : 0 : eth_dev_id = rte_eth_dev_count_total() + 1;
1121 : 0 : err = rte_event_eth_rx_adapter_instance_get(eth_dev_id,
1122 : : TEST_ETH_QUEUE_ID,
1123 : : &inst_id);
1124 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
1125 : :
1126 : : /* Case 3: Test with wrong rx queue */
1127 : 0 : err = rte_eth_dev_info_get(TEST_ETHDEV_ID, &dev_info);
1128 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1129 : :
1130 : 0 : err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID,
1131 : 0 : dev_info.max_rx_queues + 1,
1132 : : &inst_id);
1133 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
1134 : :
1135 : : /* Case 4: Test with right instance, port & rxq */
1136 : : /* Add queue 1 to Rx adapter */
1137 : 0 : queue_conf.ev.queue_id = TEST_ETH_QUEUE_ID;
1138 : 0 : queue_conf.ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
1139 : 0 : queue_conf.ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL;
1140 : 0 : queue_conf.servicing_weight = 1; /* poll queue */
1141 : :
1142 : 0 : err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
1143 : : TEST_ETHDEV_ID,
1144 : : TEST_ETH_QUEUE_ID,
1145 : : &queue_conf);
1146 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1147 : :
1148 : 0 : err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID,
1149 : : TEST_ETH_QUEUE_ID,
1150 : : &inst_id);
1151 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1152 [ # # ]: 0 : TEST_ASSERT(inst_id == TEST_INST_ID, "Expected %d got %d",
1153 : : TEST_INST_ID, err);
1154 : :
1155 : : /* Add queue 2 to Rx adapter */
1156 : 0 : queue_conf.ev.queue_id = TEST_ETH_QUEUE_ID + 1;
1157 : 0 : err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
1158 : : TEST_ETHDEV_ID,
1159 : : TEST_ETH_QUEUE_ID + 1,
1160 : : &queue_conf);
1161 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1162 : :
1163 : 0 : err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID,
1164 : : TEST_ETH_QUEUE_ID + 1,
1165 : : &inst_id);
1166 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1167 [ # # ]: 0 : TEST_ASSERT(inst_id == TEST_INST_ID, "Expected %d got %d",
1168 : : TEST_INST_ID, err);
1169 : :
1170 : : /* Add queue 3 to Rx adapter */
1171 : 0 : queue_conf.ev.queue_id = TEST_ETH_QUEUE_ID + 2;
1172 : 0 : err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
1173 : : TEST_ETHDEV_ID,
1174 : : TEST_ETH_QUEUE_ID + 2,
1175 : : &queue_conf);
1176 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1177 : :
1178 : 0 : err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID,
1179 : : TEST_ETH_QUEUE_ID + 2,
1180 : : &inst_id);
1181 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1182 [ # # ]: 0 : TEST_ASSERT(inst_id == TEST_INST_ID, "Expected %d got %d",
1183 : : TEST_INST_ID, err);
1184 : :
1185 : : /* Case 5: Test with right instance, port & wrong rxq */
1186 : 0 : err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID,
1187 : : TEST_ETH_QUEUE_ID + 3,
1188 : : &inst_id);
1189 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
1190 : :
1191 : : /* Delete all queues from the Rx adapter */
1192 : 0 : err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
1193 : : TEST_ETHDEV_ID,
1194 : : -1);
1195 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1196 : :
1197 : : return TEST_SUCCESS;
1198 : : }
1199 : :
1200 : : static int
1201 : 0 : adapter_intrq_instance_get(void)
1202 : : {
1203 : : int err;
1204 : : uint8_t inst_id;
1205 : : uint16_t eth_dev_id;
1206 : : struct rte_eth_dev_info dev_info;
1207 : 0 : struct rte_event_eth_rx_adapter_queue_conf queue_conf = {0};
1208 : :
1209 : : /* Case 1: Test without configuring eth */
1210 : 0 : err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID,
1211 : : TEST_ETH_QUEUE_ID,
1212 : : &inst_id);
1213 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
1214 : :
1215 : : /* Case 2: Test with wrong eth port */
1216 : 0 : eth_dev_id = rte_eth_dev_count_total() + 1;
1217 : 0 : err = rte_event_eth_rx_adapter_instance_get(eth_dev_id,
1218 : : TEST_ETH_QUEUE_ID,
1219 : : &inst_id);
1220 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
1221 : :
1222 : : /* Case 3: Test with wrong rx queue */
1223 : 0 : err = rte_eth_dev_info_get(TEST_ETHDEV_ID, &dev_info);
1224 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1225 : :
1226 : 0 : err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID,
1227 : 0 : dev_info.max_rx_queues + 1,
1228 : : &inst_id);
1229 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
1230 : :
1231 : : /* Case 4: Test with right instance, port & rxq */
1232 : : /* Intr enabled eth device can have both polled and intr queues.
1233 : : * Add polled queue 1 to Rx adapter
1234 : : */
1235 : 0 : queue_conf.ev.queue_id = TEST_ETH_QUEUE_ID;
1236 : 0 : queue_conf.ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
1237 : 0 : queue_conf.ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL;
1238 : 0 : queue_conf.servicing_weight = 1; /* poll queue */
1239 : :
1240 : 0 : err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
1241 : : TEST_ETHDEV_ID,
1242 : : TEST_ETH_QUEUE_ID,
1243 : : &queue_conf);
1244 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1245 : :
1246 : 0 : err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID,
1247 : : TEST_ETH_QUEUE_ID,
1248 : : &inst_id);
1249 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1250 [ # # ]: 0 : TEST_ASSERT(inst_id == TEST_INST_ID, "Expected %d got %d",
1251 : : TEST_INST_ID, err);
1252 : :
1253 : : /* Add intr queue 2 to Rx adapter */
1254 : 0 : queue_conf.ev.queue_id = TEST_ETH_QUEUE_ID + 1;
1255 : 0 : queue_conf.servicing_weight = 0; /* intr queue */
1256 : 0 : err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
1257 : : TEST_ETHDEV_ID,
1258 : : TEST_ETH_QUEUE_ID + 1,
1259 : : &queue_conf);
1260 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1261 : :
1262 : 0 : err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID,
1263 : : TEST_ETH_QUEUE_ID + 1,
1264 : : &inst_id);
1265 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1266 [ # # ]: 0 : TEST_ASSERT(inst_id == TEST_INST_ID, "Expected %d got %d",
1267 : : TEST_INST_ID, err);
1268 : :
1269 : : /* Add intr queue 3 to Rx adapter */
1270 : 0 : queue_conf.ev.queue_id = TEST_ETH_QUEUE_ID + 2;
1271 : 0 : queue_conf.servicing_weight = 0; /* intr queue */
1272 : 0 : err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
1273 : : TEST_ETHDEV_ID,
1274 : : TEST_ETH_QUEUE_ID + 2,
1275 : : &queue_conf);
1276 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1277 : :
1278 : 0 : err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID,
1279 : : TEST_ETH_QUEUE_ID + 2,
1280 : : &inst_id);
1281 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1282 [ # # ]: 0 : TEST_ASSERT(inst_id == TEST_INST_ID, "Expected %d got %d",
1283 : : TEST_INST_ID, err);
1284 : :
1285 : : /* Case 5: Test with right instance, port & wrong rxq */
1286 : 0 : err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID,
1287 : : TEST_ETH_QUEUE_ID + 3,
1288 : : &inst_id);
1289 [ # # ]: 0 : TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
1290 : :
1291 : : /* Delete all queues from the Rx adapter */
1292 : 0 : err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
1293 : : TEST_ETHDEV_ID,
1294 : : -1);
1295 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1296 : :
1297 : : return TEST_SUCCESS;
1298 : : }
1299 : :
1300 : : static int
1301 : 0 : adapter_get_set_params(void)
1302 : : {
1303 : : int err, rc;
1304 : : struct rte_event_eth_rx_adapter_runtime_params in_params;
1305 : : struct rte_event_eth_rx_adapter_runtime_params out_params;
1306 : 0 : struct rte_event_eth_rx_adapter_queue_conf queue_config = {0};
1307 : : struct rte_event ev;
1308 : :
1309 : : ev.queue_id = 0;
1310 : : ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
1311 : : ev.priority = 0;
1312 : : ev.flow_id = 1;
1313 : :
1314 : 0 : queue_config.rx_queue_flags =
1315 : : RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID;
1316 : 0 : queue_config.ev = ev;
1317 : 0 : queue_config.servicing_weight = 1;
1318 : :
1319 : 0 : err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
1320 : : TEST_ETHDEV_ID, 0,
1321 : : &queue_config);
1322 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1323 : :
1324 : 0 : err = rte_event_eth_rx_adapter_runtime_params_init(&in_params);
1325 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1326 : 0 : err = rte_event_eth_rx_adapter_runtime_params_init(&out_params);
1327 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1328 : :
1329 : : /* Case 1: Get the default value of mbufs processed by Rx adapter */
1330 : 0 : err = rte_event_eth_rx_adapter_runtime_params_get(TEST_INST_ID,
1331 : : &out_params);
1332 [ # # ]: 0 : if (err == -ENOTSUP) {
1333 : : rc = TEST_SKIPPED;
1334 : 0 : goto skip;
1335 : : }
1336 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1337 : :
1338 : : /* Case 2: Set max_nb_rx = 32 (=BATCH_SEIZE) */
1339 : 0 : in_params.max_nb_rx = 32;
1340 : :
1341 : 0 : err = rte_event_eth_rx_adapter_runtime_params_set(TEST_INST_ID,
1342 : : &in_params);
1343 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1344 : :
1345 : 0 : err = rte_event_eth_rx_adapter_runtime_params_get(TEST_INST_ID,
1346 : : &out_params);
1347 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1348 [ # # ]: 0 : TEST_ASSERT(in_params.max_nb_rx == out_params.max_nb_rx,
1349 : : "Expected %u got %u",
1350 : : in_params.max_nb_rx, out_params.max_nb_rx);
1351 : :
1352 : : /* Case 3: Set max_nb_rx = 192 */
1353 : 0 : in_params.max_nb_rx = 192;
1354 : :
1355 : 0 : err = rte_event_eth_rx_adapter_runtime_params_set(TEST_INST_ID,
1356 : : &in_params);
1357 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1358 : :
1359 : 0 : err = rte_event_eth_rx_adapter_runtime_params_get(TEST_INST_ID,
1360 : : &out_params);
1361 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1362 [ # # ]: 0 : TEST_ASSERT(in_params.max_nb_rx == out_params.max_nb_rx,
1363 : : "Expected %u got %u",
1364 : : in_params.max_nb_rx, out_params.max_nb_rx);
1365 : :
1366 : : /* Case 4: Set max_nb_rx = 256 */
1367 : 0 : in_params.max_nb_rx = 256;
1368 : :
1369 : 0 : err = rte_event_eth_rx_adapter_runtime_params_set(TEST_INST_ID,
1370 : : &in_params);
1371 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1372 : :
1373 : 0 : err = rte_event_eth_rx_adapter_runtime_params_get(TEST_INST_ID,
1374 : : &out_params);
1375 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1376 [ # # ]: 0 : TEST_ASSERT(in_params.max_nb_rx == out_params.max_nb_rx,
1377 : : "Expected %u got %u",
1378 : : in_params.max_nb_rx, out_params.max_nb_rx);
1379 : :
1380 : : /* Case 5: Set max_nb_rx = 30(<BATCH_SIZE) */
1381 : 0 : in_params.max_nb_rx = 30;
1382 : :
1383 : 0 : err = rte_event_eth_rx_adapter_runtime_params_set(TEST_INST_ID,
1384 : : &in_params);
1385 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1386 : :
1387 : 0 : err = rte_event_eth_rx_adapter_runtime_params_get(TEST_INST_ID,
1388 : : &out_params);
1389 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1390 [ # # ]: 0 : TEST_ASSERT(in_params.max_nb_rx == out_params.max_nb_rx,
1391 : : "Expected %u got %u",
1392 : : in_params.max_nb_rx, out_params.max_nb_rx);
1393 : :
1394 : : /* Case 6: Set max_nb_rx = 512 */
1395 : 0 : in_params.max_nb_rx = 512;
1396 : :
1397 : 0 : err = rte_event_eth_rx_adapter_runtime_params_set(TEST_INST_ID,
1398 : : &in_params);
1399 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1400 : :
1401 : 0 : err = rte_event_eth_rx_adapter_runtime_params_get(TEST_INST_ID,
1402 : : &out_params);
1403 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1404 [ # # ]: 0 : TEST_ASSERT(in_params.max_nb_rx == out_params.max_nb_rx,
1405 : : "Expected %u got %u",
1406 : : in_params.max_nb_rx, out_params.max_nb_rx);
1407 : :
1408 : : rc = TEST_SUCCESS;
1409 : 0 : skip:
1410 : 0 : err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
1411 : : TEST_ETHDEV_ID, 0);
1412 [ # # ]: 0 : TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1413 : :
1414 : : return rc;
1415 : : }
1416 : :
1417 : : static struct unit_test_suite event_eth_rx_tests = {
1418 : : .suite_name = "rx event eth adapter test suite",
1419 : : .setup = testsuite_setup,
1420 : : .teardown = testsuite_teardown,
1421 : : .unit_test_cases = {
1422 : : TEST_CASE_ST(NULL, NULL, adapter_create_free),
1423 : : TEST_CASE_ST(NULL, NULL, adapter_create_free_with_params),
1424 : : TEST_CASE_ST(adapter_create, adapter_free,
1425 : : adapter_queue_add_del),
1426 : : TEST_CASE_ST(adapter_create, adapter_free,
1427 : : adapter_multi_eth_add_del),
1428 : : TEST_CASE_ST(adapter_create, adapter_free, adapter_start_stop),
1429 : : TEST_CASE_ST(adapter_create, adapter_free, adapter_stats),
1430 : : TEST_CASE_ST(adapter_create, adapter_free, adapter_queue_conf),
1431 : : TEST_CASE_ST(adapter_create_with_params, adapter_free,
1432 : : adapter_queue_event_buf_test),
1433 : : TEST_CASE_ST(adapter_create_with_params, adapter_free,
1434 : : adapter_queue_stats_test),
1435 : : TEST_CASE_ST(adapter_create, adapter_free,
1436 : : adapter_pollq_instance_get),
1437 : : TEST_CASE_ST(adapter_create, adapter_free,
1438 : : adapter_get_set_params),
1439 : : TEST_CASE_ST(adapter_create_ext_with_params, adapter_free,
1440 : : adapter_start_stop),
1441 : : TEST_CASES_END() /**< NULL terminate unit test array */
1442 : : }
1443 : : };
1444 : :
1445 : : static struct unit_test_suite event_eth_rx_intr_tests = {
1446 : : .suite_name = "rx event eth adapter test suite",
1447 : : .setup = testsuite_setup_rx_intr,
1448 : : .teardown = testsuite_teardown_rx_intr,
1449 : : .unit_test_cases = {
1450 : : TEST_CASE_ST(adapter_create, adapter_free,
1451 : : adapter_intr_queue_add_del),
1452 : : TEST_CASE_ST(adapter_create, adapter_free,
1453 : : adapter_intrq_instance_get),
1454 : : TEST_CASES_END() /**< NULL terminate unit test array */
1455 : : }
1456 : : };
1457 : :
1458 : : static int
1459 : 0 : test_event_eth_rx_adapter_common(void)
1460 : : {
1461 : 0 : return unit_test_suite_runner(&event_eth_rx_tests);
1462 : : }
1463 : :
1464 : : static int
1465 : 0 : test_event_eth_rx_intr_adapter_common(void)
1466 : : {
1467 : 0 : return unit_test_suite_runner(&event_eth_rx_intr_tests);
1468 : : }
1469 : :
1470 : : #endif /* !RTE_EXEC_ENV_WINDOWS */
1471 : :
1472 : 235 : REGISTER_TEST_COMMAND(event_eth_rx_adapter_autotest,
1473 : : test_event_eth_rx_adapter_common);
1474 : 235 : REGISTER_TEST_COMMAND(event_eth_rx_intr_adapter_autotest,
1475 : : test_event_eth_rx_intr_adapter_common);
|