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>
39 #include <rte_event_eth_rx_adapter.h>
43 #define MAX_NUM_RX_QUEUE 64
44 #define NB_MBUFS (8192 * num_ports * MAX_NUM_RX_QUEUE)
45 #define MBUF_CACHE_SIZE 512
46 #define MBUF_PRIV_SIZE 0
47 #define TEST_INST_ID 0
49 #define TEST_ETHDEV_ID 0
51 struct event_eth_rx_adapter_test_params {
52 struct rte_mempool *mp;
53 uint16_t rx_rings, tx_rings;
57 static struct event_eth_rx_adapter_test_params default_params;
60 port_init(uint8_t port, struct rte_mempool *mp)
62 static const struct rte_eth_conf port_conf_default = {
64 .mq_mode = ETH_MQ_RX_RSS,
65 .max_rx_pkt_len = ETHER_MAX_LEN
69 .rss_hf = ETH_RSS_IP |
75 const uint16_t rx_ring_size = 512, tx_ring_size = 512;
76 struct rte_eth_conf port_conf = port_conf_default;
79 struct rte_eth_dev_info dev_info;
81 if (port >= rte_eth_dev_count())
84 retval = rte_eth_dev_configure(port, 0, 0, &port_conf);
86 rte_eth_dev_info_get(port, &dev_info);
88 default_params.rx_rings = RTE_MIN(dev_info.max_rx_queues,
90 default_params.tx_rings = 1;
92 /* Configure the Ethernet device. */
93 retval = rte_eth_dev_configure(port, default_params.rx_rings,
94 default_params.tx_rings, &port_conf);
98 for (q = 0; q < default_params.rx_rings; q++) {
99 retval = rte_eth_rx_queue_setup(port, q, rx_ring_size,
100 rte_eth_dev_socket_id(port), NULL, mp);
105 /* Allocate and set up 1 TX queue per Ethernet port. */
106 for (q = 0; q < default_params.tx_rings; q++) {
107 retval = rte_eth_tx_queue_setup(port, q, tx_ring_size,
108 rte_eth_dev_socket_id(port), NULL);
113 /* Start the Ethernet port. */
114 retval = rte_eth_dev_start(port);
118 /* Display the port MAC address. */
119 struct ether_addr addr;
120 rte_eth_macaddr_get(port, &addr);
121 printf("Port %u MAC: %02" PRIx8 " %02" PRIx8 " %02" PRIx8
122 " %02" PRIx8 " %02" PRIx8 " %02" PRIx8 "\n",
124 addr.addr_bytes[0], addr.addr_bytes[1],
125 addr.addr_bytes[2], addr.addr_bytes[3],
126 addr.addr_bytes[4], addr.addr_bytes[5]);
128 /* Enable RX in promiscuous mode for the Ethernet device. */
129 rte_eth_promiscuous_enable(port);
135 init_ports(int num_ports)
140 default_params.mp = rte_pktmbuf_pool_create("packet_pool",
144 RTE_MBUF_DEFAULT_BUF_SIZE,
146 if (!default_params.mp)
149 for (portid = 0; portid < num_ports; portid++) {
150 retval = port_init(portid, default_params.mp);
159 testsuite_setup(void)
163 struct rte_event_dev_info dev_info;
165 count = rte_event_dev_count();
167 printf("Failed to find a valid event device,"
168 " testing with event_skeleton device\n");
169 rte_vdev_init("event_skeleton", NULL);
172 struct rte_event_dev_config config = {
173 .nb_event_queues = 1,
177 err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
178 config.nb_event_queue_flows = dev_info.max_event_queue_flows;
179 config.nb_event_port_dequeue_depth =
180 dev_info.max_event_port_dequeue_depth;
181 config.nb_event_port_enqueue_depth =
182 dev_info.max_event_port_enqueue_depth;
183 config.nb_events_limit =
184 dev_info.max_num_events;
185 err = rte_event_dev_configure(TEST_DEV_ID, &config);
186 TEST_ASSERT(err == 0, "Event device initialization failed err %d\n",
190 * eth devices like octeontx use event device to receive packets
191 * so rte_eth_dev_start invokes rte_event_dev_start internally, so
192 * call init_ports after rte_event_dev_configure
194 err = init_ports(rte_eth_dev_count());
195 TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err);
197 err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID,
198 &default_params.caps);
199 TEST_ASSERT(err == 0, "Failed to get adapter cap err %d\n",
206 testsuite_teardown(void)
209 for (i = 0; i < rte_eth_dev_count(); i++)
212 rte_mempool_free(default_params.mp);
219 struct rte_event_dev_info dev_info;
220 struct rte_event_port_conf rx_p_conf;
222 err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
223 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
225 rx_p_conf.new_event_threshold = dev_info.max_num_events;
226 rx_p_conf.dequeue_depth = dev_info.max_event_port_dequeue_depth;
227 rx_p_conf.enqueue_depth = dev_info.max_event_port_enqueue_depth;
228 err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
230 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
238 rte_event_eth_rx_adapter_free(TEST_INST_ID);
242 adapter_create_free(void)
246 struct rte_event_port_conf rx_p_conf = {
249 .new_event_threshold = 1200,
252 err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
254 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
256 err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
258 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
260 err = rte_event_eth_rx_adapter_create(TEST_INST_ID,
261 TEST_DEV_ID, &rx_p_conf);
262 TEST_ASSERT(err == -EEXIST, "Expected -EEXIST %d got %d", -EEXIST, err);
264 err = rte_event_eth_rx_adapter_free(TEST_INST_ID);
265 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
267 err = rte_event_eth_rx_adapter_free(TEST_INST_ID);
268 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
270 err = rte_event_eth_rx_adapter_free(1);
271 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
277 adapter_queue_add_del(void)
283 struct rte_event_eth_rx_adapter_queue_conf queue_config;
285 err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID,
287 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
290 ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
293 queue_config.rx_queue_flags = 0;
294 if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) {
296 queue_config.rx_queue_flags =
297 RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID;
299 queue_config.ev = ev;
300 queue_config.servicing_weight = 1;
302 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
305 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
307 if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) {
308 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
311 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
313 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
315 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
317 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
321 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
323 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
326 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
328 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
332 TEST_ASSERT(err == -EINVAL, "Expected EINVAL got %d", err);
334 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
337 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
339 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
341 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
343 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
345 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
347 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
349 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
352 err = rte_event_eth_rx_adapter_queue_add(1, TEST_ETHDEV_ID, -1,
354 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
356 err = rte_event_eth_rx_adapter_queue_del(1, TEST_ETHDEV_ID, -1);
357 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
363 adapter_start_stop(void)
369 ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
372 struct rte_event_eth_rx_adapter_queue_conf queue_config;
374 queue_config.rx_queue_flags = 0;
375 if (default_params.caps &
376 RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) {
378 queue_config.rx_queue_flags =
379 RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID;
382 queue_config.ev = ev;
383 queue_config.servicing_weight = 1;
385 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, TEST_ETHDEV_ID,
387 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
389 err = rte_event_eth_rx_adapter_start(TEST_INST_ID);
390 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
392 err = rte_event_eth_rx_adapter_stop(TEST_INST_ID);
393 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
395 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, TEST_ETHDEV_ID,
397 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
399 err = rte_event_eth_rx_adapter_start(TEST_INST_ID);
400 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
402 err = rte_event_eth_rx_adapter_stop(TEST_INST_ID);
403 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
405 err = rte_event_eth_rx_adapter_start(1);
406 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
408 err = rte_event_eth_rx_adapter_stop(1);
409 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
418 struct rte_event_eth_rx_adapter_stats stats;
420 err = rte_event_eth_rx_adapter_stats_get(TEST_INST_ID, NULL);
421 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
423 err = rte_event_eth_rx_adapter_stats_get(TEST_INST_ID, &stats);
424 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
426 err = rte_event_eth_rx_adapter_stats_get(1, &stats);
427 TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
432 static struct unit_test_suite service_tests = {
433 .suite_name = "rx event eth adapter test suite",
434 .setup = testsuite_setup,
435 .teardown = testsuite_teardown,
437 TEST_CASE_ST(NULL, NULL, adapter_create_free),
438 TEST_CASE_ST(adapter_create, adapter_free,
439 adapter_queue_add_del),
440 TEST_CASE_ST(adapter_create, adapter_free, adapter_start_stop),
441 TEST_CASE_ST(adapter_create, adapter_free, adapter_stats),
442 TEST_CASES_END() /**< NULL terminate unit test array */
447 test_event_eth_rx_adapter_common(void)
449 return unit_test_suite_runner(&service_tests);
452 REGISTER_TEST_COMMAND(event_eth_rx_adapter_autotest,
453 test_event_eth_rx_adapter_common);