1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2010-2015 Intel Corporation
5 #include "rte_eth_ring.h"
7 #include <rte_ethdev_driver.h>
8 #include <rte_malloc.h>
9 #include <rte_memcpy.h>
10 #include <rte_string_fns.h>
11 #include <rte_bus_vdev.h>
12 #include <rte_kvargs.h>
13 #include <rte_errno.h>
15 #define ETH_RING_NUMA_NODE_ACTION_ARG "nodeaction"
16 #define ETH_RING_ACTION_CREATE "CREATE"
17 #define ETH_RING_ACTION_ATTACH "ATTACH"
18 #define ETH_RING_INTERNAL_ARG "internal"
20 static const char *valid_arguments[] = {
21 ETH_RING_NUMA_NODE_ACTION_ARG,
22 ETH_RING_INTERNAL_ARG,
26 struct ring_internal_args {
27 struct rte_ring * const *rx_queues;
28 const unsigned int nb_rx_queues;
29 struct rte_ring * const *tx_queues;
30 const unsigned int nb_tx_queues;
31 const unsigned int numa_node;
32 void *addr; /* self addr for sanity check */
42 rte_atomic64_t rx_pkts;
43 rte_atomic64_t tx_pkts;
44 rte_atomic64_t err_pkts;
47 struct pmd_internals {
48 unsigned max_rx_queues;
49 unsigned max_tx_queues;
51 struct ring_queue rx_ring_queues[RTE_PMD_RING_MAX_RX_RINGS];
52 struct ring_queue tx_ring_queues[RTE_PMD_RING_MAX_TX_RINGS];
54 struct ether_addr address;
55 enum dev_action action;
59 static struct rte_eth_link pmd_link = {
60 .link_speed = ETH_SPEED_NUM_10G,
61 .link_duplex = ETH_LINK_FULL_DUPLEX,
62 .link_status = ETH_LINK_DOWN,
63 .link_autoneg = ETH_LINK_FIXED,
66 static int eth_ring_logtype;
68 #define PMD_LOG(level, fmt, args...) \
69 rte_log(RTE_LOG_ ## level, eth_ring_logtype, \
70 "%s(): " fmt "\n", __func__, ##args)
73 eth_ring_rx(void *q, struct rte_mbuf **bufs, uint16_t nb_bufs)
75 void **ptrs = (void *)&bufs[0];
76 struct ring_queue *r = q;
77 const uint16_t nb_rx = (uint16_t)rte_ring_dequeue_burst(r->rng,
79 if (r->rng->flags & RING_F_SC_DEQ)
80 r->rx_pkts.cnt += nb_rx;
82 rte_atomic64_add(&(r->rx_pkts), nb_rx);
87 eth_ring_tx(void *q, struct rte_mbuf **bufs, uint16_t nb_bufs)
89 void **ptrs = (void *)&bufs[0];
90 struct ring_queue *r = q;
91 const uint16_t nb_tx = (uint16_t)rte_ring_enqueue_burst(r->rng,
93 if (r->rng->flags & RING_F_SP_ENQ) {
94 r->tx_pkts.cnt += nb_tx;
95 r->err_pkts.cnt += nb_bufs - nb_tx;
97 rte_atomic64_add(&(r->tx_pkts), nb_tx);
98 rte_atomic64_add(&(r->err_pkts), nb_bufs - nb_tx);
104 eth_dev_configure(struct rte_eth_dev *dev __rte_unused) { return 0; }
107 eth_dev_start(struct rte_eth_dev *dev)
109 dev->data->dev_link.link_status = ETH_LINK_UP;
114 eth_dev_stop(struct rte_eth_dev *dev)
116 dev->data->dev_link.link_status = ETH_LINK_DOWN;
120 eth_dev_set_link_down(struct rte_eth_dev *dev)
122 dev->data->dev_link.link_status = ETH_LINK_DOWN;
127 eth_dev_set_link_up(struct rte_eth_dev *dev)
129 dev->data->dev_link.link_status = ETH_LINK_UP;
134 eth_rx_queue_setup(struct rte_eth_dev *dev, uint16_t rx_queue_id,
135 uint16_t nb_rx_desc __rte_unused,
136 unsigned int socket_id __rte_unused,
137 const struct rte_eth_rxconf *rx_conf __rte_unused,
138 struct rte_mempool *mb_pool __rte_unused)
140 struct pmd_internals *internals = dev->data->dev_private;
141 dev->data->rx_queues[rx_queue_id] = &internals->rx_ring_queues[rx_queue_id];
146 eth_tx_queue_setup(struct rte_eth_dev *dev, uint16_t tx_queue_id,
147 uint16_t nb_tx_desc __rte_unused,
148 unsigned int socket_id __rte_unused,
149 const struct rte_eth_txconf *tx_conf __rte_unused)
151 struct pmd_internals *internals = dev->data->dev_private;
152 dev->data->tx_queues[tx_queue_id] = &internals->tx_ring_queues[tx_queue_id];
158 eth_dev_info(struct rte_eth_dev *dev,
159 struct rte_eth_dev_info *dev_info)
161 struct pmd_internals *internals = dev->data->dev_private;
162 dev_info->max_mac_addrs = 1;
163 dev_info->max_rx_pktlen = (uint32_t)-1;
164 dev_info->max_rx_queues = (uint16_t)internals->max_rx_queues;
165 dev_info->max_tx_queues = (uint16_t)internals->max_tx_queues;
166 dev_info->min_rx_bufsize = 0;
167 dev_info->rx_offload_capa = DEV_RX_OFFLOAD_CRC_STRIP;
171 eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats)
174 unsigned long rx_total = 0, tx_total = 0, tx_err_total = 0;
175 const struct pmd_internals *internal = dev->data->dev_private;
177 for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
178 i < dev->data->nb_rx_queues; i++) {
179 stats->q_ipackets[i] = internal->rx_ring_queues[i].rx_pkts.cnt;
180 rx_total += stats->q_ipackets[i];
183 for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
184 i < dev->data->nb_tx_queues; i++) {
185 stats->q_opackets[i] = internal->tx_ring_queues[i].tx_pkts.cnt;
186 stats->q_errors[i] = internal->tx_ring_queues[i].err_pkts.cnt;
187 tx_total += stats->q_opackets[i];
188 tx_err_total += stats->q_errors[i];
191 stats->ipackets = rx_total;
192 stats->opackets = tx_total;
193 stats->oerrors = tx_err_total;
199 eth_stats_reset(struct rte_eth_dev *dev)
202 struct pmd_internals *internal = dev->data->dev_private;
203 for (i = 0; i < dev->data->nb_rx_queues; i++)
204 internal->rx_ring_queues[i].rx_pkts.cnt = 0;
205 for (i = 0; i < dev->data->nb_tx_queues; i++) {
206 internal->tx_ring_queues[i].tx_pkts.cnt = 0;
207 internal->tx_ring_queues[i].err_pkts.cnt = 0;
212 eth_mac_addr_remove(struct rte_eth_dev *dev __rte_unused,
213 uint32_t index __rte_unused)
218 eth_mac_addr_add(struct rte_eth_dev *dev __rte_unused,
219 struct ether_addr *mac_addr __rte_unused,
220 uint32_t index __rte_unused,
221 uint32_t vmdq __rte_unused)
227 eth_queue_release(void *q __rte_unused) { ; }
229 eth_link_update(struct rte_eth_dev *dev __rte_unused,
230 int wait_to_complete __rte_unused) { return 0; }
232 static const struct eth_dev_ops ops = {
233 .dev_start = eth_dev_start,
234 .dev_stop = eth_dev_stop,
235 .dev_set_link_up = eth_dev_set_link_up,
236 .dev_set_link_down = eth_dev_set_link_down,
237 .dev_configure = eth_dev_configure,
238 .dev_infos_get = eth_dev_info,
239 .rx_queue_setup = eth_rx_queue_setup,
240 .tx_queue_setup = eth_tx_queue_setup,
241 .rx_queue_release = eth_queue_release,
242 .tx_queue_release = eth_queue_release,
243 .link_update = eth_link_update,
244 .stats_get = eth_stats_get,
245 .stats_reset = eth_stats_reset,
246 .mac_addr_remove = eth_mac_addr_remove,
247 .mac_addr_add = eth_mac_addr_add,
250 static struct rte_vdev_driver pmd_ring_drv;
253 do_eth_dev_ring_create(const char *name,
254 struct rte_ring * const rx_queues[], const unsigned nb_rx_queues,
255 struct rte_ring *const tx_queues[], const unsigned nb_tx_queues,
256 const unsigned int numa_node, enum dev_action action,
257 struct rte_eth_dev **eth_dev_p)
259 struct rte_eth_dev_data *data = NULL;
260 struct pmd_internals *internals = NULL;
261 struct rte_eth_dev *eth_dev = NULL;
262 void **rx_queues_local = NULL;
263 void **tx_queues_local = NULL;
266 PMD_LOG(INFO, "Creating rings-backed ethdev on numa socket %u",
269 rx_queues_local = rte_zmalloc_socket(name,
270 sizeof(void *) * nb_rx_queues, 0, numa_node);
271 if (rx_queues_local == NULL) {
276 tx_queues_local = rte_zmalloc_socket(name,
277 sizeof(void *) * nb_tx_queues, 0, numa_node);
278 if (tx_queues_local == NULL) {
283 internals = rte_zmalloc_socket(name, sizeof(*internals), 0, numa_node);
284 if (internals == NULL) {
289 /* reserve an ethdev entry */
290 eth_dev = rte_eth_dev_allocate(name);
291 if (eth_dev == NULL) {
296 /* now put it all together
297 * - store queue data in internals,
298 * - store numa_node info in eth_dev_data
299 * - point eth_dev_data to internals
300 * - and point eth_dev structure to new eth_dev_data structure
303 data = eth_dev->data;
304 data->rx_queues = rx_queues_local;
305 data->tx_queues = tx_queues_local;
307 internals->action = action;
308 internals->max_rx_queues = nb_rx_queues;
309 internals->max_tx_queues = nb_tx_queues;
310 for (i = 0; i < nb_rx_queues; i++) {
311 internals->rx_ring_queues[i].rng = rx_queues[i];
312 data->rx_queues[i] = &internals->rx_ring_queues[i];
314 for (i = 0; i < nb_tx_queues; i++) {
315 internals->tx_ring_queues[i].rng = tx_queues[i];
316 data->tx_queues[i] = &internals->tx_ring_queues[i];
319 data->dev_private = internals;
320 data->nb_rx_queues = (uint16_t)nb_rx_queues;
321 data->nb_tx_queues = (uint16_t)nb_tx_queues;
322 data->dev_link = pmd_link;
323 data->mac_addrs = &internals->address;
325 eth_dev->dev_ops = &ops;
326 data->kdrv = RTE_KDRV_NONE;
327 data->numa_node = numa_node;
329 /* finally assign rx and tx ops */
330 eth_dev->rx_pkt_burst = eth_ring_rx;
331 eth_dev->tx_pkt_burst = eth_ring_tx;
333 rte_eth_dev_probing_finish(eth_dev);
334 *eth_dev_p = eth_dev;
336 return data->port_id;
339 rte_free(rx_queues_local);
340 rte_free(tx_queues_local);
347 rte_eth_from_rings(const char *name, struct rte_ring *const rx_queues[],
348 const unsigned nb_rx_queues,
349 struct rte_ring *const tx_queues[],
350 const unsigned nb_tx_queues,
351 const unsigned numa_node)
353 struct ring_internal_args args = {
354 .rx_queues = rx_queues,
355 .nb_rx_queues = nb_rx_queues,
356 .tx_queues = tx_queues,
357 .nb_tx_queues = nb_tx_queues,
358 .numa_node = numa_node,
361 char args_str[32] = { 0 };
362 char ring_name[32] = { 0 };
363 uint16_t port_id = RTE_MAX_ETHPORTS;
366 /* do some parameter checking */
367 if (rx_queues == NULL && nb_rx_queues > 0) {
371 if (tx_queues == NULL && nb_tx_queues > 0) {
375 if (nb_rx_queues > RTE_PMD_RING_MAX_RX_RINGS) {
380 snprintf(args_str, 32, "%s=%p", ETH_RING_INTERNAL_ARG, &args);
381 snprintf(ring_name, 32, "net_ring_%s", name);
383 ret = rte_vdev_init(ring_name, args_str);
389 rte_eth_dev_get_port_by_name(ring_name, &port_id);
395 rte_eth_from_ring(struct rte_ring *r)
397 return rte_eth_from_rings(r->name, &r, 1, &r, 1,
398 r->memzone ? r->memzone->socket_id : SOCKET_ID_ANY);
402 eth_dev_ring_create(const char *name, const unsigned numa_node,
403 enum dev_action action, struct rte_eth_dev **eth_dev)
405 /* rx and tx are so-called from point of view of first port.
406 * They are inverted from the point of view of second port
408 struct rte_ring *rxtx[RTE_PMD_RING_MAX_RX_RINGS];
410 char rng_name[RTE_RING_NAMESIZE];
411 unsigned num_rings = RTE_MIN(RTE_PMD_RING_MAX_RX_RINGS,
412 RTE_PMD_RING_MAX_TX_RINGS);
414 for (i = 0; i < num_rings; i++) {
415 snprintf(rng_name, sizeof(rng_name), "ETH_RXTX%u_%s", i, name);
416 rxtx[i] = (action == DEV_CREATE) ?
417 rte_ring_create(rng_name, 1024, numa_node,
418 RING_F_SP_ENQ|RING_F_SC_DEQ) :
419 rte_ring_lookup(rng_name);
424 if (do_eth_dev_ring_create(name, rxtx, num_rings, rxtx, num_rings,
425 numa_node, action, eth_dev) < 0)
431 struct node_action_pair {
434 enum dev_action action;
437 struct node_action_list {
440 struct node_action_pair *list;
443 static int parse_kvlist (const char *key __rte_unused, const char *value, void *data)
445 struct node_action_list *info = data;
452 name = strdup(value);
457 PMD_LOG(WARNING, "command line parameter is empty for ring pmd!");
461 node = strchr(name, ':');
463 PMD_LOG(WARNING, "could not parse node value from %s",
471 action = strchr(node, ':');
473 PMD_LOG(WARNING, "could not parse action value from %s",
482 * Need to do some sanity checking here
485 if (strcmp(action, ETH_RING_ACTION_ATTACH) == 0)
486 info->list[info->count].action = DEV_ATTACH;
487 else if (strcmp(action, ETH_RING_ACTION_CREATE) == 0)
488 info->list[info->count].action = DEV_CREATE;
493 info->list[info->count].node = strtol(node, &end, 10);
495 if ((errno != 0) || (*end != '\0')) {
497 "node value %s is unparseable as a number", node);
501 snprintf(info->list[info->count].name, sizeof(info->list[info->count].name), "%s", name);
512 parse_internal_args(const char *key __rte_unused, const char *value,
515 struct ring_internal_args **internal_args = data;
518 sscanf(value, "%p", &args);
520 *internal_args = args;
522 if ((*internal_args)->addr != args)
529 rte_pmd_ring_probe(struct rte_vdev_device *dev)
531 const char *name, *params;
532 struct rte_kvargs *kvlist = NULL;
534 struct node_action_list *info = NULL;
535 struct rte_eth_dev *eth_dev = NULL;
536 struct ring_internal_args *internal_args;
538 name = rte_vdev_device_name(dev);
539 params = rte_vdev_device_args(dev);
541 PMD_LOG(INFO, "Initializing pmd_ring for %s", name);
543 if (params == NULL || params[0] == '\0') {
544 ret = eth_dev_ring_create(name, rte_socket_id(), DEV_CREATE,
548 "Attach to pmd_ring for %s", name);
549 ret = eth_dev_ring_create(name, rte_socket_id(),
550 DEV_ATTACH, ð_dev);
553 kvlist = rte_kvargs_parse(params, valid_arguments);
556 PMD_LOG(INFO, "Ignoring unsupported parameters when creating"
557 " rings-backed ethernet device");
558 ret = eth_dev_ring_create(name, rte_socket_id(),
559 DEV_CREATE, ð_dev);
562 "Attach to pmd_ring for %s",
564 ret = eth_dev_ring_create(name, rte_socket_id(),
565 DEV_ATTACH, ð_dev);
569 eth_dev->device = &dev->device;
574 if (rte_kvargs_count(kvlist, ETH_RING_INTERNAL_ARG) == 1) {
575 ret = rte_kvargs_process(kvlist, ETH_RING_INTERNAL_ARG,
581 ret = do_eth_dev_ring_create(name,
582 internal_args->rx_queues,
583 internal_args->nb_rx_queues,
584 internal_args->tx_queues,
585 internal_args->nb_tx_queues,
586 internal_args->numa_node,
592 ret = rte_kvargs_count(kvlist, ETH_RING_NUMA_NODE_ACTION_ARG);
593 info = rte_zmalloc("struct node_action_list",
594 sizeof(struct node_action_list) +
595 (sizeof(struct node_action_pair) * ret),
601 info->list = (struct node_action_pair*)(info + 1);
603 ret = rte_kvargs_process(kvlist, ETH_RING_NUMA_NODE_ACTION_ARG,
609 for (info->count = 0; info->count < info->total; info->count++) {
610 ret = eth_dev_ring_create(info->list[info->count].name,
611 info->list[info->count].node,
612 info->list[info->count].action,
615 (info->list[info->count].action == DEV_CREATE)) {
617 "Attach to pmd_ring for %s",
619 ret = eth_dev_ring_create(name,
620 info->list[info->count].node,
629 eth_dev->device = &dev->device;
632 rte_kvargs_free(kvlist);
638 rte_pmd_ring_remove(struct rte_vdev_device *dev)
640 const char *name = rte_vdev_device_name(dev);
641 struct rte_eth_dev *eth_dev = NULL;
642 struct pmd_internals *internals = NULL;
643 struct ring_queue *r = NULL;
646 PMD_LOG(INFO, "Un-Initializing pmd_ring for %s", name);
651 /* find an ethdev entry */
652 eth_dev = rte_eth_dev_allocated(name);
656 eth_dev_stop(eth_dev);
658 internals = eth_dev->data->dev_private;
659 if (internals->action == DEV_CREATE) {
661 * it is only necessary to delete the rings in rx_queues because
662 * they are the same used in tx_queues
664 for (i = 0; i < eth_dev->data->nb_rx_queues; i++) {
665 r = eth_dev->data->rx_queues[i];
666 rte_ring_free(r->rng);
670 rte_free(eth_dev->data->rx_queues);
671 rte_free(eth_dev->data->tx_queues);
672 rte_free(eth_dev->data->dev_private);
674 rte_eth_dev_release_port(eth_dev);
678 static struct rte_vdev_driver pmd_ring_drv = {
679 .probe = rte_pmd_ring_probe,
680 .remove = rte_pmd_ring_remove,
683 RTE_PMD_REGISTER_VDEV(net_ring, pmd_ring_drv);
684 RTE_PMD_REGISTER_ALIAS(net_ring, eth_ring);
685 RTE_PMD_REGISTER_PARAM_STRING(net_ring,
686 ETH_RING_NUMA_NODE_ACTION_ARG "=name:node:action(ATTACH|CREATE)");
688 RTE_INIT(eth_ring_init_log);
690 eth_ring_init_log(void)
692 eth_ring_logtype = rte_log_register("pmd.net.ring");
693 if (eth_ring_logtype >= 0)
694 rte_log_set_level(eth_ring_logtype, RTE_LOG_NOTICE);