4 * Copyright(c) 2017 Intel Corporation. All rights reserved.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * * Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in
14 * the documentation and/or other materials provided with the
16 * * Neither the name of Intel Corporation nor the names of its
17 * contributors may be used to endorse or promote products derived
18 * from this software without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 #include <rte_common.h>
34 #include <rte_mempool.h>
36 #include <rte_ethdev.h>
37 #include <rte_eventdev.h>
38 #include <rte_bus_vdev.h>
40 #include <rte_event_eth_rx_adapter.h>
44 #define MAX_NUM_RX_QUEUE 64
45 #define NB_MBUFS (8192 * num_ports * MAX_NUM_RX_QUEUE)
46 #define MBUF_CACHE_SIZE 512
47 #define MBUF_PRIV_SIZE 0
48 #define TEST_INST_ID 0
50 #define TEST_ETHDEV_ID 0
52 struct event_eth_rx_adapter_test_params {
53 struct rte_mempool *mp;
54 uint16_t rx_rings, tx_rings;
58 static struct event_eth_rx_adapter_test_params default_params;
61 port_init(uint8_t port, struct rte_mempool *mp)
63 static const struct rte_eth_conf port_conf_default = {
65 .mq_mode = ETH_MQ_RX_RSS,
66 .max_rx_pkt_len = ETHER_MAX_LEN
70 .rss_hf = ETH_RSS_IP |
76 const uint16_t rx_ring_size = 512, tx_ring_size = 512;
77 struct rte_eth_conf port_conf = port_conf_default;
80 struct rte_eth_dev_info dev_info;
82 if (port >= rte_eth_dev_count())
85 retval = rte_eth_dev_configure(port, 0, 0, &port_conf);
87 rte_eth_dev_info_get(port, &dev_info);
89 default_params.rx_rings = RTE_MIN(dev_info.max_rx_queues,
91 default_params.tx_rings = 1;
93 /* Configure the Ethernet device. */
94 retval = rte_eth_dev_configure(port, default_params.rx_rings,
95 default_params.tx_rings, &port_conf);
99 for (q = 0; q < default_params.rx_rings; q++) {
100 retval = rte_eth_rx_queue_setup(port, q, rx_ring_size,
101 rte_eth_dev_socket_id(port), NULL, mp);
106 /* Allocate and set up 1 TX queue per Ethernet port. */
107 for (q = 0; q < default_params.tx_rings; q++) {
108 retval = rte_eth_tx_queue_setup(port, q, tx_ring_size,
109 rte_eth_dev_socket_id(port), NULL);
114 /* Start the Ethernet port. */
115 retval = rte_eth_dev_start(port);
119 /* Display the port MAC address. */
120 struct ether_addr addr;
121 rte_eth_macaddr_get(port, &addr);
122 printf("Port %u MAC: %02" PRIx8 " %02" PRIx8 " %02" PRIx8
123 " %02" PRIx8 " %02" PRIx8 " %02" PRIx8 "\n",
125 addr.addr_bytes[0], addr.addr_bytes[1],
126 addr.addr_bytes[2], addr.addr_bytes[3],
127 addr.addr_bytes[4], addr.addr_bytes[5]);
129 /* Enable RX in promiscuous mode for the Ethernet device. */
130 rte_eth_promiscuous_enable(port);
136 init_ports(int num_ports)
141 default_params.mp = rte_pktmbuf_pool_create("packet_pool",
145 RTE_MBUF_DEFAULT_BUF_SIZE,
147 if (!default_params.mp)
150 for (portid = 0; portid < num_ports; portid++) {
151 retval = port_init(portid, default_params.mp);
160 testsuite_setup(void)
164 struct rte_event_dev_info dev_info;
166 count = rte_event_dev_count();
168 printf("Failed to find a valid event device,"
169 " testing with event_skeleton device\n");
170 rte_vdev_init("event_skeleton", NULL);
173 struct rte_event_dev_config config = {
174 .nb_event_queues = 1,
178 err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
179 config.nb_event_queue_flows = dev_info.max_event_queue_flows;
180 config.nb_event_port_dequeue_depth =
181 dev_info.max_event_port_dequeue_depth;
182 config.nb_event_port_enqueue_depth =
183 dev_info.max_event_port_enqueue_depth;
184 config.nb_events_limit =
185 dev_info.max_num_events;
186 err = rte_event_dev_configure(TEST_DEV_ID, &config);
187 TEST_ASSERT(err == 0, "Event device initialization failed err %d\n",
191 * eth devices like octeontx use event device to receive packets
192 * so rte_eth_dev_start invokes rte_event_dev_start internally, so
193 * call init_ports after rte_event_dev_configure
195 err = init_ports(rte_eth_dev_count());
196 TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err);
198 err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID,
199 &default_params.caps);
200 TEST_ASSERT(err == 0, "Failed to get adapter cap err %d\n",
207 testsuite_teardown(void)
210 for (i = 0; i < rte_eth_dev_count(); i++)
213 rte_mempool_free(default_params.mp);
220 struct rte_event_dev_info dev_info;
221 struct rte_event_port_conf rx_p_conf;
223 err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
224 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
226 rx_p_conf.new_event_threshold = dev_info.max_num_events;
227 rx_p_conf.dequeue_depth = dev_info.max_event_port_dequeue_depth;
228 rx_p_conf.enqueue_depth = dev_info.max_event_port_enqueue_depth;
229 err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
231 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
239 rte_event_eth_rx_adapter_free(TEST_INST_ID);
243 adapter_create_free(void)
247 struct rte_event_port_conf rx_p_conf = {
250 .new_event_threshold = 1200,
253 err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
255 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
257 err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
259 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
261 err = rte_event_eth_rx_adapter_create(TEST_INST_ID,
262 TEST_DEV_ID, &rx_p_conf);
263 TEST_ASSERT(err == -EEXIST, "Expected -EEXIST %d got %d", -EEXIST, err);
265 err = rte_event_eth_rx_adapter_free(TEST_INST_ID);
266 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
268 err = rte_event_eth_rx_adapter_free(TEST_INST_ID);
269 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
271 err = rte_event_eth_rx_adapter_free(1);
272 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
278 adapter_queue_add_del(void)
284 struct rte_event_eth_rx_adapter_queue_conf queue_config;
286 err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID,
288 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
291 ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
294 queue_config.rx_queue_flags = 0;
295 if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) {
297 queue_config.rx_queue_flags =
298 RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID;
300 queue_config.ev = ev;
301 queue_config.servicing_weight = 1;
303 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
306 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
308 if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) {
309 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
312 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
314 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
316 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
318 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
322 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
324 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
327 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
329 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
333 TEST_ASSERT(err == -EINVAL, "Expected EINVAL got %d", err);
335 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
338 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
340 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
342 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
344 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
346 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
348 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
350 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
353 err = rte_event_eth_rx_adapter_queue_add(1, TEST_ETHDEV_ID, -1,
355 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
357 err = rte_event_eth_rx_adapter_queue_del(1, TEST_ETHDEV_ID, -1);
358 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
364 adapter_start_stop(void)
370 ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
373 struct rte_event_eth_rx_adapter_queue_conf queue_config;
375 queue_config.rx_queue_flags = 0;
376 if (default_params.caps &
377 RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) {
379 queue_config.rx_queue_flags =
380 RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID;
383 queue_config.ev = ev;
384 queue_config.servicing_weight = 1;
386 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, TEST_ETHDEV_ID,
388 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
390 err = rte_event_eth_rx_adapter_start(TEST_INST_ID);
391 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
393 err = rte_event_eth_rx_adapter_stop(TEST_INST_ID);
394 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
396 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, TEST_ETHDEV_ID,
398 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
400 err = rte_event_eth_rx_adapter_start(TEST_INST_ID);
401 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
403 err = rte_event_eth_rx_adapter_stop(TEST_INST_ID);
404 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
406 err = rte_event_eth_rx_adapter_start(1);
407 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
409 err = rte_event_eth_rx_adapter_stop(1);
410 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
419 struct rte_event_eth_rx_adapter_stats stats;
421 err = rte_event_eth_rx_adapter_stats_get(TEST_INST_ID, NULL);
422 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
424 err = rte_event_eth_rx_adapter_stats_get(TEST_INST_ID, &stats);
425 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
427 err = rte_event_eth_rx_adapter_stats_get(1, &stats);
428 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
433 static struct unit_test_suite service_tests = {
434 .suite_name = "rx event eth adapter test suite",
435 .setup = testsuite_setup,
436 .teardown = testsuite_teardown,
438 TEST_CASE_ST(NULL, NULL, adapter_create_free),
439 TEST_CASE_ST(adapter_create, adapter_free,
440 adapter_queue_add_del),
441 TEST_CASE_ST(adapter_create, adapter_free, adapter_start_stop),
442 TEST_CASE_ST(adapter_create, adapter_free, adapter_stats),
443 TEST_CASES_END() /**< NULL terminate unit test array */
448 test_event_eth_rx_adapter_common(void)
450 return unit_test_suite_runner(&service_tests);
453 REGISTER_TEST_COMMAND(event_eth_rx_adapter_autotest,
454 test_event_eth_rx_adapter_common);