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
test_event_eth_rx_adapter_common(void)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
test_event_eth_rx_intr_adapter_common(void)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
port_init_common(uint16_t port,const struct rte_eth_conf * port_conf,struct rte_mempool * mp)57 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 if (!rte_eth_dev_is_valid_port(port))
66 return -1;
67
68 retval = rte_eth_dev_configure(port, 0, 0, port_conf);
69
70 retval = rte_eth_dev_info_get(port, &dev_info);
71 if (retval != 0)
72 return retval;
73
74 default_params.rx_rings = RTE_MIN(dev_info.max_rx_queues,
75 MAX_NUM_RX_QUEUE);
76 default_params.tx_rings = 1;
77
78 /* Configure the Ethernet device. */
79 retval = rte_eth_dev_configure(port, default_params.rx_rings,
80 default_params.tx_rings, port_conf);
81 if (retval != 0)
82 return retval;
83
84 for (q = 0; q < default_params.rx_rings; q++) {
85 retval = rte_eth_rx_queue_setup(port, q, rx_ring_size,
86 rte_eth_dev_socket_id(port), NULL, mp);
87 if (retval < 0)
88 return retval;
89 }
90
91 /* Allocate and set up 1 TX queue per Ethernet port. */
92 for (q = 0; q < default_params.tx_rings; q++) {
93 retval = rte_eth_tx_queue_setup(port, q, tx_ring_size,
94 rte_eth_dev_socket_id(port), NULL);
95 if (retval < 0)
96 return retval;
97 }
98
99 /* Start the Ethernet port. */
100 retval = rte_eth_dev_start(port);
101 if (retval < 0)
102 return retval;
103
104 /* Display the port MAC address. */
105 struct rte_ether_addr addr;
106 retval = rte_eth_macaddr_get(port, &addr);
107 if (retval < 0)
108 return retval;
109 printf("Port %u MAC: %02" PRIx8 " %02" PRIx8 " %02" PRIx8
110 " %02" PRIx8 " %02" PRIx8 " %02" PRIx8 "\n",
111 (unsigned int)port, RTE_ETHER_ADDR_BYTES(&addr));
112
113 /* Enable RX in promiscuous mode for the Ethernet device. */
114 retval = rte_eth_promiscuous_enable(port);
115 if (retval != 0)
116 return retval;
117
118 return 0;
119 }
120
121 static inline int
port_init_rx_intr(uint16_t port,struct rte_mempool * mp)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 return port_init_common(port, &port_conf_default, mp);
134 }
135
136 static inline int
port_init(uint16_t port,struct rte_mempool * mp)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 return port_init_common(port, &port_conf_default, mp);
146 }
147
148 static int
init_port_rx_intr(int num_ports)149 init_port_rx_intr(int num_ports)
150 {
151 int retval;
152 uint16_t portid;
153 int err;
154
155 default_params.mp = rte_pktmbuf_pool_create("packet_pool",
156 NB_MBUFS,
157 MBUF_CACHE_SIZE,
158 MBUF_PRIV_SIZE,
159 RTE_MBUF_DEFAULT_BUF_SIZE,
160 rte_socket_id());
161 if (!default_params.mp)
162 return -ENOMEM;
163
164 RTE_ETH_FOREACH_DEV(portid) {
165 retval = port_init_rx_intr(portid, default_params.mp);
166 if (retval)
167 continue;
168 err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, portid,
169 &default_params.caps);
170 if (err)
171 continue;
172 if (!(default_params.caps &
173 RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT)) {
174 default_params.rx_intr_port_inited = 1;
175 default_params.rx_intr_port = portid;
176 return 0;
177 }
178 retval = rte_eth_dev_stop(portid);
179 TEST_ASSERT(retval == 0, "Failed to stop port %u: %d\n",
180 portid, retval);
181 }
182 return 0;
183 }
184
185 static int
init_ports(int num_ports)186 init_ports(int num_ports)
187 {
188 uint16_t portid;
189 int retval;
190
191 struct rte_mempool *ptr = rte_mempool_lookup("packet_pool");
192
193 if (ptr == NULL)
194 default_params.mp = rte_pktmbuf_pool_create("packet_pool",
195 NB_MBUFS,
196 MBUF_CACHE_SIZE,
197 MBUF_PRIV_SIZE,
198 RTE_MBUF_DEFAULT_BUF_SIZE,
199 rte_socket_id());
200 else
201 default_params.mp = ptr;
202
203 if (!default_params.mp)
204 return -ENOMEM;
205
206 RTE_ETH_FOREACH_DEV(portid) {
207 retval = port_init(portid, default_params.mp);
208 if (retval)
209 return retval;
210 }
211
212 return 0;
213 }
214
215 static int
testsuite_setup(void)216 testsuite_setup(void)
217 {
218 int err;
219 uint8_t count;
220 struct rte_event_dev_info dev_info;
221
222 count = rte_event_dev_count();
223 if (!count) {
224 printf("Failed to find a valid event device,"
225 " testing with event_skeleton device\n");
226 err = rte_vdev_init("event_skeleton", NULL);
227 TEST_ASSERT(err == 0, "Failed to create event_skeleton. err=%d",
228 err);
229 event_dev_created = true;
230 }
231
232 struct rte_event_dev_config config = {
233 .nb_event_queues = 1,
234 .nb_event_ports = 1,
235 };
236
237 err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
238 config.nb_event_queue_flows = dev_info.max_event_queue_flows;
239 config.nb_event_port_dequeue_depth =
240 dev_info.max_event_port_dequeue_depth;
241 config.nb_event_port_enqueue_depth =
242 dev_info.max_event_port_enqueue_depth;
243 config.nb_events_limit =
244 dev_info.max_num_events;
245 err = rte_event_dev_configure(TEST_DEV_ID, &config);
246 TEST_ASSERT(err == 0, "Event device initialization failed err %d\n",
247 err);
248
249 count = rte_eth_dev_count_total();
250 if (!count) {
251 printf("Testing with net_null device\n");
252 err = rte_vdev_init("net_null", NULL);
253 TEST_ASSERT(err == 0, "Failed to create net_null. err=%d",
254 err);
255 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 err = init_ports(rte_eth_dev_count_total());
264 TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err);
265
266 err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID,
267 &default_params.caps);
268 TEST_ASSERT(err == 0, "Failed to get adapter cap err %d\n",
269 err);
270
271 return err;
272 }
273
274 static int
testsuite_setup_rx_intr(void)275 testsuite_setup_rx_intr(void)
276 {
277 int err;
278 uint8_t count;
279 struct rte_event_dev_info dev_info;
280
281 count = rte_event_dev_count();
282 if (!count) {
283 printf("Failed to find a valid event device,"
284 " testing with event_skeleton device\n");
285 err = rte_vdev_init("event_skeleton", NULL);
286 TEST_ASSERT(err == 0, "Failed to create event_skeleton. err=%d",
287 err);
288 event_dev_created = true;
289 }
290
291 struct rte_event_dev_config config = {
292 .nb_event_queues = 1,
293 .nb_event_ports = 1,
294 };
295
296 err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
297 config.nb_event_queue_flows = dev_info.max_event_queue_flows;
298 config.nb_event_port_dequeue_depth =
299 dev_info.max_event_port_dequeue_depth;
300 config.nb_event_port_enqueue_depth =
301 dev_info.max_event_port_enqueue_depth;
302 config.nb_events_limit =
303 dev_info.max_num_events;
304
305 err = rte_event_dev_configure(TEST_DEV_ID, &config);
306 TEST_ASSERT(err == 0, "Event device initialization failed err %d\n",
307 err);
308
309 count = rte_eth_dev_count_total();
310 if (!count) {
311 printf("Testing with net_null device\n");
312 err = rte_vdev_init("net_null", NULL);
313 TEST_ASSERT(err == 0, "Failed to create net_null. err=%d",
314 err);
315 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 err = init_port_rx_intr(rte_eth_dev_count_total());
324 TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err);
325
326 if (!default_params.rx_intr_port_inited)
327 return 0;
328
329 err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID,
330 default_params.rx_intr_port,
331 &default_params.caps);
332 TEST_ASSERT(err == 0, "Failed to get adapter cap err %d\n", err);
333
334 return err;
335 }
336
337 static void
testsuite_teardown(void)338 testsuite_teardown(void)
339 {
340 int err;
341 uint32_t i;
342 RTE_ETH_FOREACH_DEV(i)
343 rte_eth_dev_stop(i);
344
345 if (eth_dev_created) {
346 err = rte_vdev_uninit("net_null");
347 if (err)
348 printf("Failed to delete net_null. err=%d", err);
349 eth_dev_created = false;
350 }
351
352 rte_mempool_free(default_params.mp);
353 if (event_dev_created) {
354 err = rte_vdev_uninit("event_skeleton");
355 if (err)
356 printf("Failed to delete event_skeleton. err=%d", err);
357 event_dev_created = false;
358 }
359
360 memset(&default_params, 0, sizeof(default_params));
361 }
362
363 static void
testsuite_teardown_rx_intr(void)364 testsuite_teardown_rx_intr(void)
365 {
366 int err;
367 if (!default_params.rx_intr_port_inited)
368 return;
369
370 rte_eth_dev_stop(default_params.rx_intr_port);
371 if (eth_dev_created) {
372 err = rte_vdev_uninit("net_null");
373 if (err)
374 printf("Failed to delete net_null. err=%d", err);
375 eth_dev_created = false;
376 }
377 rte_mempool_free(default_params.mp);
378 if (event_dev_created) {
379 err = rte_vdev_uninit("event_skeleton");
380 if (err)
381 printf("Failed to delete event_skeleton. err=%d", err);
382 event_dev_created = false;
383 }
384
385 memset(&default_params, 0, sizeof(default_params));
386 }
387
388 static int
adapter_create(void)389 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 err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
398 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
399
400 rx_p_conf.new_event_threshold = dev_info.max_num_events;
401 rx_p_conf.dequeue_depth = dev_info.max_event_port_dequeue_depth;
402 rx_p_conf.enqueue_depth = dev_info.max_event_port_enqueue_depth;
403 err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
404 &rx_p_conf);
405 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
406
407 return err;
408 }
409
410 static void
adapter_free(void)411 adapter_free(void)
412 {
413 rte_event_eth_rx_adapter_free(TEST_INST_ID);
414 }
415
416 static int
adapter_create_with_params(void)417 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 err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
427 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
428
429 rx_p_conf.new_event_threshold = dev_info.max_num_events;
430 rx_p_conf.dequeue_depth = dev_info.max_event_port_dequeue_depth;
431 rx_p_conf.enqueue_depth = dev_info.max_event_port_enqueue_depth;
432
433 rxa_params.use_queue_event_buf = false;
434 rxa_params.event_buf_size = 0;
435
436 /* Pass rxa_params = NULL */
437 err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID,
438 TEST_DEV_ID, &rx_p_conf, NULL);
439 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
440 if (err == 0)
441 adapter_free();
442
443 err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID,
444 TEST_DEV_ID, &rx_p_conf, &rxa_params);
445 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
446
447 rxa_params.use_queue_event_buf = true;
448
449 err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID,
450 TEST_DEV_ID, &rx_p_conf, &rxa_params);
451 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
452
453 err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID,
454 TEST_DEV_ID, &rx_p_conf, &rxa_params);
455 TEST_ASSERT(err == -EEXIST, "Expected -EEXIST got %d", err);
456
457 return TEST_SUCCESS;
458 }
459
460 static int
test_port_conf_cb(uint8_t id,uint8_t event_dev_id,struct rte_event_eth_rx_adapter_conf * conf,void * conf_arg)461 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 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 if (port_allocated) {
472 conf->event_port_id = port_id;
473 conf->max_nb_rx = 128;
474 return 0;
475 }
476
477 RTE_SET_USED(id);
478
479 ret = rte_event_dev_attr_get(event_dev_id, RTE_EVENT_DEV_ATTR_STARTED,
480 &started);
481 if (ret < 0)
482 return ret;
483
484 if (started)
485 rte_event_dev_stop(event_dev_id);
486
487 port_id = 1;
488
489 if (conf_arg != NULL)
490 port_conf = conf_arg;
491 else {
492 port_conf = &def_port_conf;
493 ret = rte_event_port_default_conf_get(event_dev_id, port_id,
494 port_conf);
495 if (ret < 0)
496 return ret;
497 }
498
499 ret = rte_event_port_setup(event_dev_id, port_id, port_conf);
500 if (ret < 0)
501 return ret;
502
503 conf->event_port_id = port_id;
504 conf->max_nb_rx = 128;
505
506 if (started)
507 rte_event_dev_start(event_dev_id);
508
509 /* Reuse this port number next time this is called */
510 port_allocated = 1;
511
512 return 0;
513 }
514
515 static int
adapter_create_ext_with_params(void)516 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 err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
523 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
524
525 rxa_params.use_queue_event_buf = false;
526 rxa_params.event_buf_size = 0;
527
528 /* Pass rxa_params = NULL */
529 err = rte_event_eth_rx_adapter_create_ext_with_params(TEST_INST_ID,
530 TEST_DEV_ID, test_port_conf_cb, NULL, NULL);
531 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
532 if (err == 0)
533 adapter_free();
534
535 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 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
538
539 rxa_params.event_buf_size = 128;
540
541 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 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
544
545 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 TEST_ASSERT(err == -EEXIST, "Expected -EEXIST got %d", err);
548
549 return TEST_SUCCESS;
550 }
551
552 static int
adapter_queue_event_buf_test(void)553 adapter_queue_event_buf_test(void)
554 {
555 int err;
556 struct rte_event ev;
557 uint32_t cap;
558
559 struct rte_event_eth_rx_adapter_queue_conf queue_config = {0};
560
561 err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID,
562 &cap);
563 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 queue_config.rx_queue_flags = 0;
570 if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) {
571 ev.flow_id = 1;
572 queue_config.rx_queue_flags =
573 RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID;
574 }
575 queue_config.ev = ev;
576 queue_config.servicing_weight = 1;
577 queue_config.event_buf_size = 0;
578
579 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
580 TEST_ETHDEV_ID, 0,
581 &queue_config);
582 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
583
584 queue_config.event_buf_size = 1024;
585
586 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
587 TEST_ETHDEV_ID, 0,
588 &queue_config);
589 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
590
591 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
592 TEST_ETHDEV_ID,
593 0);
594 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
595
596 return TEST_SUCCESS;
597 }
598
599 static int
adapter_queue_stats_test(void)600 adapter_queue_stats_test(void)
601 {
602 int err;
603 struct rte_event ev;
604 uint32_t cap;
605 struct rte_event_eth_rx_adapter_queue_conf queue_config = {0};
606 struct rte_event_eth_rx_adapter_queue_stats q_stats;
607
608 err = rte_event_eth_rx_adapter_queue_stats_get(TEST_INST_ID,
609 TEST_ETHDEV_ID, 0,
610 &q_stats);
611 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
612
613 err = rte_event_eth_rx_adapter_queue_stats_reset(TEST_INST_ID,
614 TEST_ETHDEV_ID, 0);
615 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
616
617 err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID,
618 &cap);
619 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 queue_config.rx_queue_flags = 0;
626 if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) {
627 ev.flow_id = 1;
628 queue_config.rx_queue_flags =
629 RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID;
630 }
631 queue_config.ev = ev;
632 queue_config.servicing_weight = 1;
633 queue_config.event_buf_size = 1024;
634
635 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
636 TEST_ETHDEV_ID, 0,
637 &queue_config);
638 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
639
640 err = rte_event_eth_rx_adapter_queue_stats_get(TEST_INST_ID,
641 TEST_ETHDEV_ID, 0,
642 &q_stats);
643 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
644
645 err = rte_event_eth_rx_adapter_queue_stats_reset(TEST_INST_ID,
646 TEST_ETHDEV_ID, 0);
647 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
648
649 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
650 TEST_ETHDEV_ID,
651 0);
652 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
653
654 return TEST_SUCCESS;
655 }
656
657 static int
adapter_create_free(void)658 adapter_create_free(void)
659 {
660 int err;
661
662 struct rte_event_port_conf rx_p_conf = {
663 .dequeue_depth = 8,
664 .enqueue_depth = 8,
665 .new_event_threshold = 1200,
666 };
667
668 err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
669 NULL);
670 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
671
672 err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
673 &rx_p_conf);
674 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
675
676 err = rte_event_eth_rx_adapter_create(TEST_INST_ID,
677 TEST_DEV_ID, &rx_p_conf);
678 TEST_ASSERT(err == -EEXIST, "Expected -EEXIST %d got %d", -EEXIST, err);
679
680 err = rte_event_eth_rx_adapter_free(TEST_INST_ID);
681 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
682
683 err = rte_event_eth_rx_adapter_free(TEST_INST_ID);
684 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
685
686 err = rte_event_eth_rx_adapter_free(1);
687 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
688
689 return TEST_SUCCESS;
690 }
691
692 static int
adapter_create_free_with_params(void)693 adapter_create_free_with_params(void)
694 {
695 int err;
696
697 struct rte_event_port_conf rx_p_conf = {
698 .dequeue_depth = 8,
699 .enqueue_depth = 8,
700 .new_event_threshold = 1200,
701 };
702
703 struct rte_event_eth_rx_adapter_params rxa_params = {
704 .event_buf_size = 1024
705 };
706
707 err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID,
708 TEST_DEV_ID, NULL, NULL);
709 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
710
711 err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID,
712 TEST_DEV_ID, &rx_p_conf, &rxa_params);
713 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
714
715 err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID,
716 TEST_DEV_ID, &rx_p_conf, &rxa_params);
717 TEST_ASSERT(err == -EEXIST, "Expected -EEXIST %d got %d", -EEXIST, err);
718
719 rxa_params.event_buf_size = 0;
720 err = rte_event_eth_rx_adapter_create_with_params(TEST_INST_ID,
721 TEST_DEV_ID, &rx_p_conf, &rxa_params);
722 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
723
724 err = rte_event_eth_rx_adapter_free(TEST_INST_ID);
725 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
726
727 err = rte_event_eth_rx_adapter_free(TEST_INST_ID);
728 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
729
730 err = rte_event_eth_rx_adapter_free(1);
731 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
732
733 return TEST_SUCCESS;
734 }
735
736 static int
adapter_queue_add_del(void)737 adapter_queue_add_del(void)
738 {
739 int err;
740 struct rte_event ev;
741 uint32_t cap;
742
743 struct rte_event_eth_rx_adapter_queue_conf queue_config = {0};
744
745 err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID,
746 &cap);
747 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 queue_config.rx_queue_flags = 0;
754 if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) {
755 ev.flow_id = 1;
756 queue_config.rx_queue_flags =
757 RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID;
758 }
759 queue_config.ev = ev;
760 queue_config.servicing_weight = 1;
761
762 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
763 rte_eth_dev_count_total(),
764 -1, &queue_config);
765 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
766
767 if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) {
768 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
769 TEST_ETHDEV_ID, 0,
770 &queue_config);
771 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
772
773 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
774 TEST_ETHDEV_ID, 0);
775 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
776
777 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
778 TEST_ETHDEV_ID,
779 -1,
780 &queue_config);
781 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
782
783 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
784 TEST_ETHDEV_ID,
785 -1);
786 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
787 } else {
788 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
789 TEST_ETHDEV_ID,
790 0,
791 &queue_config);
792 TEST_ASSERT(err == -EINVAL, "Expected EINVAL got %d", err);
793
794 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
795 TEST_ETHDEV_ID, -1,
796 &queue_config);
797 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
798
799 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
800 TEST_ETHDEV_ID, 0);
801 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
802
803 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
804 TEST_ETHDEV_ID, -1);
805 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
806
807 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
808 TEST_ETHDEV_ID, -1);
809 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
810 }
811
812 err = rte_event_eth_rx_adapter_queue_add(1, TEST_ETHDEV_ID, -1,
813 &queue_config);
814 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
815
816 err = rte_event_eth_rx_adapter_queue_del(1, TEST_ETHDEV_ID, -1);
817 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
818
819 return TEST_SUCCESS;
820 }
821
822 static int
adapter_multi_eth_add_del(void)823 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 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 queue_config.ev = ev;
839 queue_config.servicing_weight = 1;
840
841 /* stop eth devices for existing */
842 port_index = 0;
843 for (; port_index < rte_eth_dev_count_total(); port_index += 1) {
844 err = rte_eth_dev_stop(port_index);
845 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 port_index = rte_eth_dev_count_total();
851 port_index_base = port_index;
852 for (; port_index < RTE_MAX_ETHPORTS; port_index += 1) {
853 snprintf(driver_name, sizeof(driver_name), "%s%u", "net_null",
854 drv_id);
855 err = rte_vdev_init(driver_name, NULL);
856 TEST_ASSERT(err == 0, "Failed driver %s got %d",
857 driver_name, err);
858 drv_id += 1;
859 }
860
861 err = init_ports(rte_eth_dev_count_total());
862 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 for (; port_index < rte_eth_dev_count_total(); port_index += 1) {
867 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
868 port_index, -1,
869 &queue_config);
870 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
871 }
872
873 /* eth_rx_adapter_queue_del n ports */
874 port_index = 0;
875 for (; port_index < rte_eth_dev_count_total(); port_index += 1) {
876 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
877 port_index, -1);
878 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 port_index < RTE_MAX_ETHPORTS;
884 drv_id += 1, port_index += 1) {
885 snprintf(driver_name, sizeof(driver_name), "%s%u", "net_null",
886 drv_id);
887 err = rte_vdev_uninit(driver_name);
888 TEST_ASSERT(err == 0, "Failed driver %s got %d",
889 driver_name, err);
890 }
891
892 return TEST_SUCCESS;
893 }
894
895 static int
adapter_intr_queue_add_del(void)896 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 struct rte_event_eth_rx_adapter_queue_conf queue_config = {0};
903
904 if (!default_params.rx_intr_port_inited)
905 return 0;
906
907 eth_port = default_params.rx_intr_port;
908 err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, eth_port, &cap);
909 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 queue_config.rx_queue_flags = 0;
916 queue_config.ev = ev;
917
918 /* weight = 0 => interrupt mode */
919 queue_config.servicing_weight = 0;
920
921 if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) {
922 /* add queue 0 */
923 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
924 TEST_ETHDEV_ID, 0,
925 &queue_config);
926 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
927 }
928
929 /* add all queues */
930 queue_config.servicing_weight = 0;
931 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
932 TEST_ETHDEV_ID,
933 -1,
934 &queue_config);
935 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
936
937 if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) {
938 /* del queue 0 */
939 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
940 TEST_ETHDEV_ID,
941 0);
942 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
943 }
944
945 /* del remaining queues */
946 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
947 TEST_ETHDEV_ID,
948 -1);
949 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
950
951 /* add all queues */
952 queue_config.servicing_weight = 0;
953 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
954 TEST_ETHDEV_ID,
955 -1,
956 &queue_config);
957 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
958
959 /* intr -> poll mode queue */
960 queue_config.servicing_weight = 1;
961
962 if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) {
963 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
964 TEST_ETHDEV_ID,
965 0,
966 &queue_config);
967 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
968 }
969
970 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
971 TEST_ETHDEV_ID,
972 -1,
973 &queue_config);
974 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
975
976 /* del queues */
977 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
978 TEST_ETHDEV_ID,
979 -1);
980 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
981
982 return TEST_SUCCESS;
983 }
984
985 static int
adapter_start_stop(void)986 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 struct rte_event_eth_rx_adapter_queue_conf queue_config = {0};
996
997 queue_config.rx_queue_flags = 0;
998 if (default_params.caps &
999 RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) {
1000 ev.flow_id = 1;
1001 queue_config.rx_queue_flags =
1002 RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID;
1003 }
1004
1005 queue_config.ev = ev;
1006 queue_config.servicing_weight = 1;
1007
1008 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, TEST_ETHDEV_ID,
1009 -1, &queue_config);
1010 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1011
1012 err = rte_event_eth_rx_adapter_start(TEST_INST_ID);
1013 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1014
1015 err = rte_event_eth_rx_adapter_stop(TEST_INST_ID);
1016 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1017
1018 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, TEST_ETHDEV_ID,
1019 -1);
1020 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1021
1022 err = rte_event_eth_rx_adapter_start(TEST_INST_ID);
1023 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1024
1025 err = rte_event_eth_rx_adapter_stop(TEST_INST_ID);
1026 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1027
1028 err = rte_event_eth_rx_adapter_start(1);
1029 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
1030
1031 err = rte_event_eth_rx_adapter_stop(1);
1032 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
1033
1034 return TEST_SUCCESS;
1035 }
1036
1037 static int
adapter_stats(void)1038 adapter_stats(void)
1039 {
1040 int err;
1041 struct rte_event_eth_rx_adapter_stats stats;
1042
1043 err = rte_event_eth_rx_adapter_stats_get(TEST_INST_ID, NULL);
1044 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
1045
1046 err = rte_event_eth_rx_adapter_stats_get(TEST_INST_ID, &stats);
1047 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1048
1049 err = rte_event_eth_rx_adapter_stats_get(1, &stats);
1050 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
1051
1052 return TEST_SUCCESS;
1053 }
1054
1055 static int
adapter_queue_conf(void)1056 adapter_queue_conf(void)
1057 {
1058 int err;
1059 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 err = rte_event_eth_rx_adapter_queue_conf_get(TEST_INST_ID,
1063 TEST_ETHDEV_ID,
1064 0, &queue_conf);
1065 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
1066
1067 /* Add queue to Rx adapter */
1068 queue_conf.ev.queue_id = 0;
1069 queue_conf.ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
1070 queue_conf.ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL;
1071
1072 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
1073 TEST_ETHDEV_ID,
1074 0, &queue_conf);
1075 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1076
1077 /* Case 2: queue conf get with queue added to Rx adapter */
1078 err = rte_event_eth_rx_adapter_queue_conf_get(TEST_INST_ID,
1079 TEST_ETHDEV_ID,
1080 0, &queue_conf);
1081 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1082
1083 /* Case 3: queue conf get with invalid rx queue id */
1084 err = rte_event_eth_rx_adapter_queue_conf_get(TEST_INST_ID,
1085 TEST_ETHDEV_ID,
1086 -1, &queue_conf);
1087 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
1088
1089 /* Case 4: queue conf get with NULL queue conf struct */
1090 err = rte_event_eth_rx_adapter_queue_conf_get(TEST_INST_ID,
1091 TEST_ETHDEV_ID,
1092 0, NULL);
1093 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
1094
1095 /* Delete queue from the Rx adapter */
1096 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
1097 TEST_ETHDEV_ID,
1098 0);
1099 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1100
1101 return TEST_SUCCESS;
1102 }
1103
1104 static int
adapter_pollq_instance_get(void)1105 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 struct rte_event_eth_rx_adapter_queue_conf queue_conf = {0};
1112
1113 /* Case 1: Test without configuring eth */
1114 err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID,
1115 TEST_ETH_QUEUE_ID,
1116 &inst_id);
1117 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
1118
1119 /* Case 2: Test with wrong eth port */
1120 eth_dev_id = rte_eth_dev_count_total() + 1;
1121 err = rte_event_eth_rx_adapter_instance_get(eth_dev_id,
1122 TEST_ETH_QUEUE_ID,
1123 &inst_id);
1124 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
1125
1126 /* Case 3: Test with wrong rx queue */
1127 err = rte_eth_dev_info_get(TEST_ETHDEV_ID, &dev_info);
1128 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1129
1130 err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID,
1131 dev_info.max_rx_queues + 1,
1132 &inst_id);
1133 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 queue_conf.ev.queue_id = TEST_ETH_QUEUE_ID;
1138 queue_conf.ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
1139 queue_conf.ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL;
1140 queue_conf.servicing_weight = 1; /* poll queue */
1141
1142 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
1143 TEST_ETHDEV_ID,
1144 TEST_ETH_QUEUE_ID,
1145 &queue_conf);
1146 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1147
1148 err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID,
1149 TEST_ETH_QUEUE_ID,
1150 &inst_id);
1151 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1152 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 queue_conf.ev.queue_id = TEST_ETH_QUEUE_ID + 1;
1157 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 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1162
1163 err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID,
1164 TEST_ETH_QUEUE_ID + 1,
1165 &inst_id);
1166 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1167 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 queue_conf.ev.queue_id = TEST_ETH_QUEUE_ID + 2;
1172 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 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1177
1178 err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID,
1179 TEST_ETH_QUEUE_ID + 2,
1180 &inst_id);
1181 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1182 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 err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID,
1187 TEST_ETH_QUEUE_ID + 3,
1188 &inst_id);
1189 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
1190
1191 /* Delete all queues from the Rx adapter */
1192 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
1193 TEST_ETHDEV_ID,
1194 -1);
1195 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1196
1197 return TEST_SUCCESS;
1198 }
1199
1200 static int
adapter_intrq_instance_get(void)1201 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 struct rte_event_eth_rx_adapter_queue_conf queue_conf = {0};
1208
1209 /* Case 1: Test without configuring eth */
1210 err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID,
1211 TEST_ETH_QUEUE_ID,
1212 &inst_id);
1213 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
1214
1215 /* Case 2: Test with wrong eth port */
1216 eth_dev_id = rte_eth_dev_count_total() + 1;
1217 err = rte_event_eth_rx_adapter_instance_get(eth_dev_id,
1218 TEST_ETH_QUEUE_ID,
1219 &inst_id);
1220 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
1221
1222 /* Case 3: Test with wrong rx queue */
1223 err = rte_eth_dev_info_get(TEST_ETHDEV_ID, &dev_info);
1224 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1225
1226 err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID,
1227 dev_info.max_rx_queues + 1,
1228 &inst_id);
1229 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 queue_conf.ev.queue_id = TEST_ETH_QUEUE_ID;
1236 queue_conf.ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
1237 queue_conf.ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL;
1238 queue_conf.servicing_weight = 1; /* poll queue */
1239
1240 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
1241 TEST_ETHDEV_ID,
1242 TEST_ETH_QUEUE_ID,
1243 &queue_conf);
1244 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1245
1246 err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID,
1247 TEST_ETH_QUEUE_ID,
1248 &inst_id);
1249 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1250 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 queue_conf.ev.queue_id = TEST_ETH_QUEUE_ID + 1;
1255 queue_conf.servicing_weight = 0; /* intr queue */
1256 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 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1261
1262 err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID,
1263 TEST_ETH_QUEUE_ID + 1,
1264 &inst_id);
1265 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1266 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 queue_conf.ev.queue_id = TEST_ETH_QUEUE_ID + 2;
1271 queue_conf.servicing_weight = 0; /* intr queue */
1272 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 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1277
1278 err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID,
1279 TEST_ETH_QUEUE_ID + 2,
1280 &inst_id);
1281 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1282 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 err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID,
1287 TEST_ETH_QUEUE_ID + 3,
1288 &inst_id);
1289 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
1290
1291 /* Delete all queues from the Rx adapter */
1292 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
1293 TEST_ETHDEV_ID,
1294 -1);
1295 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1296
1297 return TEST_SUCCESS;
1298 }
1299
1300 static int
adapter_get_set_params(void)1301 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 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 queue_config.rx_queue_flags =
1315 RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID;
1316 queue_config.ev = ev;
1317 queue_config.servicing_weight = 1;
1318
1319 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
1320 TEST_ETHDEV_ID, 0,
1321 &queue_config);
1322 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1323
1324 err = rte_event_eth_rx_adapter_runtime_params_init(&in_params);
1325 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1326 err = rte_event_eth_rx_adapter_runtime_params_init(&out_params);
1327 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1328
1329 /* Case 1: Get the default value of mbufs processed by Rx adapter */
1330 err = rte_event_eth_rx_adapter_runtime_params_get(TEST_INST_ID,
1331 &out_params);
1332 if (err == -ENOTSUP) {
1333 rc = TEST_SKIPPED;
1334 goto skip;
1335 }
1336 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1337
1338 /* Case 2: Set max_nb_rx = 32 (=BATCH_SEIZE) */
1339 in_params.max_nb_rx = 32;
1340
1341 err = rte_event_eth_rx_adapter_runtime_params_set(TEST_INST_ID,
1342 &in_params);
1343 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1344
1345 err = rte_event_eth_rx_adapter_runtime_params_get(TEST_INST_ID,
1346 &out_params);
1347 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1348 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 in_params.max_nb_rx = 192;
1354
1355 err = rte_event_eth_rx_adapter_runtime_params_set(TEST_INST_ID,
1356 &in_params);
1357 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1358
1359 err = rte_event_eth_rx_adapter_runtime_params_get(TEST_INST_ID,
1360 &out_params);
1361 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1362 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 in_params.max_nb_rx = 256;
1368
1369 err = rte_event_eth_rx_adapter_runtime_params_set(TEST_INST_ID,
1370 &in_params);
1371 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1372
1373 err = rte_event_eth_rx_adapter_runtime_params_get(TEST_INST_ID,
1374 &out_params);
1375 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1376 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 in_params.max_nb_rx = 30;
1382
1383 err = rte_event_eth_rx_adapter_runtime_params_set(TEST_INST_ID,
1384 &in_params);
1385 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1386
1387 err = rte_event_eth_rx_adapter_runtime_params_get(TEST_INST_ID,
1388 &out_params);
1389 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1390 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 in_params.max_nb_rx = 512;
1396
1397 err = rte_event_eth_rx_adapter_runtime_params_set(TEST_INST_ID,
1398 &in_params);
1399 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1400
1401 err = rte_event_eth_rx_adapter_runtime_params_get(TEST_INST_ID,
1402 &out_params);
1403 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
1404 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 skip:
1410 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
1411 TEST_ETHDEV_ID, 0);
1412 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
test_event_eth_rx_adapter_common(void)1459 test_event_eth_rx_adapter_common(void)
1460 {
1461 return unit_test_suite_runner(&event_eth_rx_tests);
1462 }
1463
1464 static int
test_event_eth_rx_intr_adapter_common(void)1465 test_event_eth_rx_intr_adapter_common(void)
1466 {
1467 return unit_test_suite_runner(&event_eth_rx_intr_tests);
1468 }
1469
1470 #endif /* !RTE_EXEC_ENV_WINDOWS */
1471
1472 REGISTER_TEST_COMMAND(event_eth_rx_adapter_autotest,
1473 test_event_eth_rx_adapter_common);
1474 REGISTER_TEST_COMMAND(event_eth_rx_intr_adapter_autotest,
1475 test_event_eth_rx_intr_adapter_common);
1476