1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2010-2017 Intel Corporation
16 #include <netinet/in.h>
18 #include <rte_byteorder.h>
20 #include <rte_debug.h>
21 #include <rte_interrupts.h>
22 #include <rte_memory.h>
23 #include <rte_memcpy.h>
24 #include <rte_memzone.h>
25 #include <rte_launch.h>
27 #include <rte_per_lcore.h>
28 #include <rte_lcore.h>
29 #include <rte_atomic.h>
30 #include <rte_branch_prediction.h>
31 #include <rte_common.h>
32 #include <rte_mempool.h>
33 #include <rte_malloc.h>
35 #include <rte_errno.h>
36 #include <rte_spinlock.h>
37 #include <rte_string_fns.h>
38 #include <rte_kvargs.h>
39 #include <rte_class.h>
41 #include "rte_ether.h"
42 #include "rte_ethdev.h"
43 #include "rte_ethdev_driver.h"
44 #include "ethdev_profile.h"
45 #include "ethdev_private.h"
47 int rte_eth_dev_logtype
;
49 static const char *MZ_RTE_ETH_DEV_DATA
= "rte_eth_dev_data";
50 struct rte_eth_dev rte_eth_devices
[RTE_MAX_ETHPORTS
];
52 /* spinlock for eth device callbacks */
53 static rte_spinlock_t rte_eth_dev_cb_lock
= RTE_SPINLOCK_INITIALIZER
;
55 /* spinlock for add/remove rx callbacks */
56 static rte_spinlock_t rte_eth_rx_cb_lock
= RTE_SPINLOCK_INITIALIZER
;
58 /* spinlock for add/remove tx callbacks */
59 static rte_spinlock_t rte_eth_tx_cb_lock
= RTE_SPINLOCK_INITIALIZER
;
61 /* spinlock for shared data allocation */
62 static rte_spinlock_t rte_eth_shared_data_lock
= RTE_SPINLOCK_INITIALIZER
;
64 /* store statistics names and its offset in stats structure */
65 struct rte_eth_xstats_name_off
{
66 char name
[RTE_ETH_XSTATS_NAME_SIZE
];
70 /* Shared memory between primary and secondary processes. */
72 uint64_t next_owner_id
;
73 rte_spinlock_t ownership_lock
;
74 struct rte_eth_dev_data data
[RTE_MAX_ETHPORTS
];
75 } *rte_eth_dev_shared_data
;
77 static const struct rte_eth_xstats_name_off rte_stats_strings
[] = {
78 {"rx_good_packets", offsetof(struct rte_eth_stats
, ipackets
)},
79 {"tx_good_packets", offsetof(struct rte_eth_stats
, opackets
)},
80 {"rx_good_bytes", offsetof(struct rte_eth_stats
, ibytes
)},
81 {"tx_good_bytes", offsetof(struct rte_eth_stats
, obytes
)},
82 {"rx_missed_errors", offsetof(struct rte_eth_stats
, imissed
)},
83 {"rx_errors", offsetof(struct rte_eth_stats
, ierrors
)},
84 {"tx_errors", offsetof(struct rte_eth_stats
, oerrors
)},
85 {"rx_mbuf_allocation_errors", offsetof(struct rte_eth_stats
,
89 #define RTE_NB_STATS (sizeof(rte_stats_strings) / sizeof(rte_stats_strings[0]))
91 static const struct rte_eth_xstats_name_off rte_rxq_stats_strings
[] = {
92 {"packets", offsetof(struct rte_eth_stats
, q_ipackets
)},
93 {"bytes", offsetof(struct rte_eth_stats
, q_ibytes
)},
94 {"errors", offsetof(struct rte_eth_stats
, q_errors
)},
97 #define RTE_NB_RXQ_STATS (sizeof(rte_rxq_stats_strings) / \
98 sizeof(rte_rxq_stats_strings[0]))
100 static const struct rte_eth_xstats_name_off rte_txq_stats_strings
[] = {
101 {"packets", offsetof(struct rte_eth_stats
, q_opackets
)},
102 {"bytes", offsetof(struct rte_eth_stats
, q_obytes
)},
104 #define RTE_NB_TXQ_STATS (sizeof(rte_txq_stats_strings) / \
105 sizeof(rte_txq_stats_strings[0]))
107 #define RTE_RX_OFFLOAD_BIT2STR(_name) \
108 { DEV_RX_OFFLOAD_##_name, #_name }
110 static const struct {
113 } rte_rx_offload_names
[] = {
114 RTE_RX_OFFLOAD_BIT2STR(VLAN_STRIP
),
115 RTE_RX_OFFLOAD_BIT2STR(IPV4_CKSUM
),
116 RTE_RX_OFFLOAD_BIT2STR(UDP_CKSUM
),
117 RTE_RX_OFFLOAD_BIT2STR(TCP_CKSUM
),
118 RTE_RX_OFFLOAD_BIT2STR(TCP_LRO
),
119 RTE_RX_OFFLOAD_BIT2STR(QINQ_STRIP
),
120 RTE_RX_OFFLOAD_BIT2STR(OUTER_IPV4_CKSUM
),
121 RTE_RX_OFFLOAD_BIT2STR(MACSEC_STRIP
),
122 RTE_RX_OFFLOAD_BIT2STR(HEADER_SPLIT
),
123 RTE_RX_OFFLOAD_BIT2STR(VLAN_FILTER
),
124 RTE_RX_OFFLOAD_BIT2STR(VLAN_EXTEND
),
125 RTE_RX_OFFLOAD_BIT2STR(JUMBO_FRAME
),
126 RTE_RX_OFFLOAD_BIT2STR(SCATTER
),
127 RTE_RX_OFFLOAD_BIT2STR(TIMESTAMP
),
128 RTE_RX_OFFLOAD_BIT2STR(SECURITY
),
129 RTE_RX_OFFLOAD_BIT2STR(KEEP_CRC
),
130 RTE_RX_OFFLOAD_BIT2STR(SCTP_CKSUM
),
131 RTE_RX_OFFLOAD_BIT2STR(OUTER_UDP_CKSUM
),
134 #undef RTE_RX_OFFLOAD_BIT2STR
136 #define RTE_TX_OFFLOAD_BIT2STR(_name) \
137 { DEV_TX_OFFLOAD_##_name, #_name }
139 static const struct {
142 } rte_tx_offload_names
[] = {
143 RTE_TX_OFFLOAD_BIT2STR(VLAN_INSERT
),
144 RTE_TX_OFFLOAD_BIT2STR(IPV4_CKSUM
),
145 RTE_TX_OFFLOAD_BIT2STR(UDP_CKSUM
),
146 RTE_TX_OFFLOAD_BIT2STR(TCP_CKSUM
),
147 RTE_TX_OFFLOAD_BIT2STR(SCTP_CKSUM
),
148 RTE_TX_OFFLOAD_BIT2STR(TCP_TSO
),
149 RTE_TX_OFFLOAD_BIT2STR(UDP_TSO
),
150 RTE_TX_OFFLOAD_BIT2STR(OUTER_IPV4_CKSUM
),
151 RTE_TX_OFFLOAD_BIT2STR(QINQ_INSERT
),
152 RTE_TX_OFFLOAD_BIT2STR(VXLAN_TNL_TSO
),
153 RTE_TX_OFFLOAD_BIT2STR(GRE_TNL_TSO
),
154 RTE_TX_OFFLOAD_BIT2STR(IPIP_TNL_TSO
),
155 RTE_TX_OFFLOAD_BIT2STR(GENEVE_TNL_TSO
),
156 RTE_TX_OFFLOAD_BIT2STR(MACSEC_INSERT
),
157 RTE_TX_OFFLOAD_BIT2STR(MT_LOCKFREE
),
158 RTE_TX_OFFLOAD_BIT2STR(MULTI_SEGS
),
159 RTE_TX_OFFLOAD_BIT2STR(MBUF_FAST_FREE
),
160 RTE_TX_OFFLOAD_BIT2STR(SECURITY
),
161 RTE_TX_OFFLOAD_BIT2STR(UDP_TNL_TSO
),
162 RTE_TX_OFFLOAD_BIT2STR(IP_TNL_TSO
),
163 RTE_TX_OFFLOAD_BIT2STR(OUTER_UDP_CKSUM
),
164 RTE_TX_OFFLOAD_BIT2STR(MATCH_METADATA
),
167 #undef RTE_TX_OFFLOAD_BIT2STR
170 * The user application callback description.
172 * It contains callback address to be registered by user application,
173 * the pointer to the parameters for callback, and the event type.
175 struct rte_eth_dev_callback
{
176 TAILQ_ENTRY(rte_eth_dev_callback
) next
; /**< Callbacks list */
177 rte_eth_dev_cb_fn cb_fn
; /**< Callback address */
178 void *cb_arg
; /**< Parameter for callback */
179 void *ret_param
; /**< Return parameter */
180 enum rte_eth_event_type event
; /**< Interrupt event type */
181 uint32_t active
; /**< Callback is executing */
190 rte_eth_iterator_init(struct rte_dev_iterator
*iter
, const char *devargs_str
)
193 struct rte_devargs devargs
= {.args
= NULL
};
194 const char *bus_param_key
;
195 char *bus_str
= NULL
;
196 char *cls_str
= NULL
;
199 memset(iter
, 0, sizeof(*iter
));
202 * The devargs string may use various syntaxes:
203 * - 0000:08:00.0,representor=[1-3]
204 * - pci:0000:06:00.0,representor=[0,5]
205 * - class=eth,mac=00:11:22:33:44:55
206 * A new syntax is in development (not yet supported):
207 * - bus=X,paramX=x/class=Y,paramY=y/driver=Z,paramZ=z
211 * Handle pure class filter (i.e. without any bus-level argument),
212 * from future new syntax.
213 * rte_devargs_parse() is not yet supporting the new syntax,
214 * that's why this simple case is temporarily parsed here.
216 #define iter_anybus_str "class=eth,"
217 if (strncmp(devargs_str
, iter_anybus_str
,
218 strlen(iter_anybus_str
)) == 0) {
219 iter
->cls_str
= devargs_str
+ strlen(iter_anybus_str
);
223 /* Split bus, device and parameters. */
224 ret
= rte_devargs_parse(&devargs
, devargs_str
);
229 * Assume parameters of old syntax can match only at ethdev level.
230 * Extra parameters will be ignored, thanks to "+" prefix.
232 str_size
= strlen(devargs
.args
) + 2;
233 cls_str
= malloc(str_size
);
234 if (cls_str
== NULL
) {
238 ret
= snprintf(cls_str
, str_size
, "+%s", devargs
.args
);
239 if (ret
!= str_size
- 1) {
243 iter
->cls_str
= cls_str
;
244 free(devargs
.args
); /* allocated by rte_devargs_parse() */
247 iter
->bus
= devargs
.bus
;
248 if (iter
->bus
->dev_iterate
== NULL
) {
253 /* Convert bus args to new syntax for use with new API dev_iterate. */
254 if (strcmp(iter
->bus
->name
, "vdev") == 0) {
255 bus_param_key
= "name";
256 } else if (strcmp(iter
->bus
->name
, "pci") == 0) {
257 bus_param_key
= "addr";
262 str_size
= strlen(bus_param_key
) + strlen(devargs
.name
) + 2;
263 bus_str
= malloc(str_size
);
264 if (bus_str
== NULL
) {
268 ret
= snprintf(bus_str
, str_size
, "%s=%s",
269 bus_param_key
, devargs
.name
);
270 if (ret
!= str_size
- 1) {
274 iter
->bus_str
= bus_str
;
277 iter
->cls
= rte_class_find_by_name("eth");
282 RTE_LOG(ERR
, EAL
, "Bus %s does not support iterating.\n",
291 rte_eth_iterator_next(struct rte_dev_iterator
*iter
)
293 if (iter
->cls
== NULL
) /* invalid ethdev iterator */
294 return RTE_MAX_ETHPORTS
;
296 do { /* loop to try all matching rte_device */
297 /* If not pure ethdev filter and */
298 if (iter
->bus
!= NULL
&&
299 /* not in middle of rte_eth_dev iteration, */
300 iter
->class_device
== NULL
) {
301 /* get next rte_device to try. */
302 iter
->device
= iter
->bus
->dev_iterate(
303 iter
->device
, iter
->bus_str
, iter
);
304 if (iter
->device
== NULL
)
305 break; /* no more rte_device candidate */
307 /* A device is matching bus part, need to check ethdev part. */
308 iter
->class_device
= iter
->cls
->dev_iterate(
309 iter
->class_device
, iter
->cls_str
, iter
);
310 if (iter
->class_device
!= NULL
)
311 return eth_dev_to_id(iter
->class_device
); /* match */
312 } while (iter
->bus
!= NULL
); /* need to try next rte_device */
314 /* No more ethdev port to iterate. */
315 rte_eth_iterator_cleanup(iter
);
316 return RTE_MAX_ETHPORTS
;
320 rte_eth_iterator_cleanup(struct rte_dev_iterator
*iter
)
322 if (iter
->bus_str
== NULL
)
323 return; /* nothing to free in pure class filter */
324 free(RTE_CAST_FIELD(iter
, bus_str
, char *)); /* workaround const */
325 free(RTE_CAST_FIELD(iter
, cls_str
, char *)); /* workaround const */
326 memset(iter
, 0, sizeof(*iter
));
330 rte_eth_find_next(uint16_t port_id
)
332 while (port_id
< RTE_MAX_ETHPORTS
&&
333 rte_eth_devices
[port_id
].state
== RTE_ETH_DEV_UNUSED
)
336 if (port_id
>= RTE_MAX_ETHPORTS
)
337 return RTE_MAX_ETHPORTS
;
343 * Macro to iterate over all valid ports for internal usage.
344 * Note: RTE_ETH_FOREACH_DEV is different because filtering owned ports.
346 #define RTE_ETH_FOREACH_VALID_DEV(port_id) \
347 for (port_id = rte_eth_find_next(0); \
348 port_id < RTE_MAX_ETHPORTS; \
349 port_id = rte_eth_find_next(port_id + 1))
352 rte_eth_find_next_of(uint16_t port_id
, const struct rte_device
*parent
)
354 port_id
= rte_eth_find_next(port_id
);
355 while (port_id
< RTE_MAX_ETHPORTS
&&
356 rte_eth_devices
[port_id
].device
!= parent
)
357 port_id
= rte_eth_find_next(port_id
+ 1);
363 rte_eth_find_next_sibling(uint16_t port_id
, uint16_t ref_port_id
)
365 RTE_ETH_VALID_PORTID_OR_ERR_RET(ref_port_id
, RTE_MAX_ETHPORTS
);
366 return rte_eth_find_next_of(port_id
,
367 rte_eth_devices
[ref_port_id
].device
);
371 rte_eth_dev_shared_data_prepare(void)
373 const unsigned flags
= 0;
374 const struct rte_memzone
*mz
;
376 rte_spinlock_lock(&rte_eth_shared_data_lock
);
378 if (rte_eth_dev_shared_data
== NULL
) {
379 if (rte_eal_process_type() == RTE_PROC_PRIMARY
) {
380 /* Allocate port data and ownership shared memory. */
381 mz
= rte_memzone_reserve(MZ_RTE_ETH_DEV_DATA
,
382 sizeof(*rte_eth_dev_shared_data
),
383 rte_socket_id(), flags
);
385 mz
= rte_memzone_lookup(MZ_RTE_ETH_DEV_DATA
);
387 rte_panic("Cannot allocate ethdev shared data\n");
389 rte_eth_dev_shared_data
= mz
->addr
;
390 if (rte_eal_process_type() == RTE_PROC_PRIMARY
) {
391 rte_eth_dev_shared_data
->next_owner_id
=
392 RTE_ETH_DEV_NO_OWNER
+ 1;
393 rte_spinlock_init(&rte_eth_dev_shared_data
->ownership_lock
);
394 memset(rte_eth_dev_shared_data
->data
, 0,
395 sizeof(rte_eth_dev_shared_data
->data
));
399 rte_spinlock_unlock(&rte_eth_shared_data_lock
);
403 is_allocated(const struct rte_eth_dev
*ethdev
)
405 return ethdev
->data
->name
[0] != '\0';
408 static struct rte_eth_dev
*
409 _rte_eth_dev_allocated(const char *name
)
413 for (i
= 0; i
< RTE_MAX_ETHPORTS
; i
++) {
414 if (rte_eth_devices
[i
].data
!= NULL
&&
415 strcmp(rte_eth_devices
[i
].data
->name
, name
) == 0)
416 return &rte_eth_devices
[i
];
422 rte_eth_dev_allocated(const char *name
)
424 struct rte_eth_dev
*ethdev
;
426 rte_eth_dev_shared_data_prepare();
428 rte_spinlock_lock(&rte_eth_dev_shared_data
->ownership_lock
);
430 ethdev
= _rte_eth_dev_allocated(name
);
432 rte_spinlock_unlock(&rte_eth_dev_shared_data
->ownership_lock
);
438 rte_eth_dev_find_free_port(void)
442 for (i
= 0; i
< RTE_MAX_ETHPORTS
; i
++) {
443 /* Using shared name field to find a free port. */
444 if (rte_eth_dev_shared_data
->data
[i
].name
[0] == '\0') {
445 RTE_ASSERT(rte_eth_devices
[i
].state
==
450 return RTE_MAX_ETHPORTS
;
453 static struct rte_eth_dev
*
454 eth_dev_get(uint16_t port_id
)
456 struct rte_eth_dev
*eth_dev
= &rte_eth_devices
[port_id
];
458 eth_dev
->data
= &rte_eth_dev_shared_data
->data
[port_id
];
464 rte_eth_dev_allocate(const char *name
)
467 struct rte_eth_dev
*eth_dev
= NULL
;
470 name_len
= strnlen(name
, RTE_ETH_NAME_MAX_LEN
);
472 RTE_ETHDEV_LOG(ERR
, "Zero length Ethernet device name\n");
476 if (name_len
>= RTE_ETH_NAME_MAX_LEN
) {
477 RTE_ETHDEV_LOG(ERR
, "Ethernet device name is too long\n");
481 rte_eth_dev_shared_data_prepare();
483 /* Synchronize port creation between primary and secondary threads. */
484 rte_spinlock_lock(&rte_eth_dev_shared_data
->ownership_lock
);
486 if (_rte_eth_dev_allocated(name
) != NULL
) {
488 "Ethernet device with name %s already allocated\n",
493 port_id
= rte_eth_dev_find_free_port();
494 if (port_id
== RTE_MAX_ETHPORTS
) {
496 "Reached maximum number of Ethernet ports\n");
500 eth_dev
= eth_dev_get(port_id
);
501 strlcpy(eth_dev
->data
->name
, name
, sizeof(eth_dev
->data
->name
));
502 eth_dev
->data
->port_id
= port_id
;
503 eth_dev
->data
->mtu
= ETHER_MTU
;
506 rte_spinlock_unlock(&rte_eth_dev_shared_data
->ownership_lock
);
512 * Attach to a port already registered by the primary process, which
513 * makes sure that the same device would have the same port id both
514 * in the primary and secondary process.
517 rte_eth_dev_attach_secondary(const char *name
)
520 struct rte_eth_dev
*eth_dev
= NULL
;
522 rte_eth_dev_shared_data_prepare();
524 /* Synchronize port attachment to primary port creation and release. */
525 rte_spinlock_lock(&rte_eth_dev_shared_data
->ownership_lock
);
527 for (i
= 0; i
< RTE_MAX_ETHPORTS
; i
++) {
528 if (strcmp(rte_eth_dev_shared_data
->data
[i
].name
, name
) == 0)
531 if (i
== RTE_MAX_ETHPORTS
) {
533 "Device %s is not driven by the primary process\n",
536 eth_dev
= eth_dev_get(i
);
537 RTE_ASSERT(eth_dev
->data
->port_id
== i
);
540 rte_spinlock_unlock(&rte_eth_dev_shared_data
->ownership_lock
);
545 rte_eth_dev_release_port(struct rte_eth_dev
*eth_dev
)
550 rte_eth_dev_shared_data_prepare();
552 if (eth_dev
->state
!= RTE_ETH_DEV_UNUSED
)
553 _rte_eth_dev_callback_process(eth_dev
,
554 RTE_ETH_EVENT_DESTROY
, NULL
);
556 rte_spinlock_lock(&rte_eth_dev_shared_data
->ownership_lock
);
558 eth_dev
->state
= RTE_ETH_DEV_UNUSED
;
560 if (rte_eal_process_type() == RTE_PROC_PRIMARY
) {
561 rte_free(eth_dev
->data
->rx_queues
);
562 rte_free(eth_dev
->data
->tx_queues
);
563 rte_free(eth_dev
->data
->mac_addrs
);
564 rte_free(eth_dev
->data
->hash_mac_addrs
);
565 rte_free(eth_dev
->data
->dev_private
);
566 memset(eth_dev
->data
, 0, sizeof(struct rte_eth_dev_data
));
569 rte_spinlock_unlock(&rte_eth_dev_shared_data
->ownership_lock
);
575 rte_eth_dev_is_valid_port(uint16_t port_id
)
577 if (port_id
>= RTE_MAX_ETHPORTS
||
578 (rte_eth_devices
[port_id
].state
== RTE_ETH_DEV_UNUSED
))
585 rte_eth_is_valid_owner_id(uint64_t owner_id
)
587 if (owner_id
== RTE_ETH_DEV_NO_OWNER
||
588 rte_eth_dev_shared_data
->next_owner_id
<= owner_id
)
594 rte_eth_find_next_owned_by(uint16_t port_id
, const uint64_t owner_id
)
596 port_id
= rte_eth_find_next(port_id
);
597 while (port_id
< RTE_MAX_ETHPORTS
&&
598 rte_eth_devices
[port_id
].data
->owner
.id
!= owner_id
)
599 port_id
= rte_eth_find_next(port_id
+ 1);
604 int __rte_experimental
605 rte_eth_dev_owner_new(uint64_t *owner_id
)
607 rte_eth_dev_shared_data_prepare();
609 rte_spinlock_lock(&rte_eth_dev_shared_data
->ownership_lock
);
611 *owner_id
= rte_eth_dev_shared_data
->next_owner_id
++;
613 rte_spinlock_unlock(&rte_eth_dev_shared_data
->ownership_lock
);
618 _rte_eth_dev_owner_set(const uint16_t port_id
, const uint64_t old_owner_id
,
619 const struct rte_eth_dev_owner
*new_owner
)
621 struct rte_eth_dev
*ethdev
= &rte_eth_devices
[port_id
];
622 struct rte_eth_dev_owner
*port_owner
;
624 if (port_id
>= RTE_MAX_ETHPORTS
|| !is_allocated(ethdev
)) {
625 RTE_ETHDEV_LOG(ERR
, "Port id %"PRIu16
" is not allocated\n",
630 if (!rte_eth_is_valid_owner_id(new_owner
->id
) &&
631 !rte_eth_is_valid_owner_id(old_owner_id
)) {
633 "Invalid owner old_id=%016"PRIx64
" new_id=%016"PRIx64
"\n",
634 old_owner_id
, new_owner
->id
);
638 port_owner
= &rte_eth_devices
[port_id
].data
->owner
;
639 if (port_owner
->id
!= old_owner_id
) {
641 "Cannot set owner to port %u already owned by %s_%016"PRIX64
"\n",
642 port_id
, port_owner
->name
, port_owner
->id
);
646 /* can not truncate (same structure) */
647 strlcpy(port_owner
->name
, new_owner
->name
, RTE_ETH_MAX_OWNER_NAME_LEN
);
649 port_owner
->id
= new_owner
->id
;
651 RTE_ETHDEV_LOG(DEBUG
, "Port %u owner is %s_%016"PRIx64
"\n",
652 port_id
, new_owner
->name
, new_owner
->id
);
657 int __rte_experimental
658 rte_eth_dev_owner_set(const uint16_t port_id
,
659 const struct rte_eth_dev_owner
*owner
)
663 rte_eth_dev_shared_data_prepare();
665 rte_spinlock_lock(&rte_eth_dev_shared_data
->ownership_lock
);
667 ret
= _rte_eth_dev_owner_set(port_id
, RTE_ETH_DEV_NO_OWNER
, owner
);
669 rte_spinlock_unlock(&rte_eth_dev_shared_data
->ownership_lock
);
673 int __rte_experimental
674 rte_eth_dev_owner_unset(const uint16_t port_id
, const uint64_t owner_id
)
676 const struct rte_eth_dev_owner new_owner
= (struct rte_eth_dev_owner
)
677 {.id
= RTE_ETH_DEV_NO_OWNER
, .name
= ""};
680 rte_eth_dev_shared_data_prepare();
682 rte_spinlock_lock(&rte_eth_dev_shared_data
->ownership_lock
);
684 ret
= _rte_eth_dev_owner_set(port_id
, owner_id
, &new_owner
);
686 rte_spinlock_unlock(&rte_eth_dev_shared_data
->ownership_lock
);
690 void __rte_experimental
691 rte_eth_dev_owner_delete(const uint64_t owner_id
)
695 rte_eth_dev_shared_data_prepare();
697 rte_spinlock_lock(&rte_eth_dev_shared_data
->ownership_lock
);
699 if (rte_eth_is_valid_owner_id(owner_id
)) {
700 for (port_id
= 0; port_id
< RTE_MAX_ETHPORTS
; port_id
++)
701 if (rte_eth_devices
[port_id
].data
->owner
.id
== owner_id
)
702 memset(&rte_eth_devices
[port_id
].data
->owner
, 0,
703 sizeof(struct rte_eth_dev_owner
));
704 RTE_ETHDEV_LOG(NOTICE
,
705 "All port owners owned by %016"PRIx64
" identifier have removed\n",
709 "Invalid owner id=%016"PRIx64
"\n",
713 rte_spinlock_unlock(&rte_eth_dev_shared_data
->ownership_lock
);
716 int __rte_experimental
717 rte_eth_dev_owner_get(const uint16_t port_id
, struct rte_eth_dev_owner
*owner
)
720 struct rte_eth_dev
*ethdev
= &rte_eth_devices
[port_id
];
722 rte_eth_dev_shared_data_prepare();
724 rte_spinlock_lock(&rte_eth_dev_shared_data
->ownership_lock
);
726 if (port_id
>= RTE_MAX_ETHPORTS
|| !is_allocated(ethdev
)) {
727 RTE_ETHDEV_LOG(ERR
, "Port id %"PRIu16
" is not allocated\n",
731 rte_memcpy(owner
, ðdev
->data
->owner
, sizeof(*owner
));
734 rte_spinlock_unlock(&rte_eth_dev_shared_data
->ownership_lock
);
739 rte_eth_dev_socket_id(uint16_t port_id
)
741 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -1);
742 return rte_eth_devices
[port_id
].data
->numa_node
;
746 rte_eth_dev_get_sec_ctx(uint16_t port_id
)
748 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, NULL
);
749 return rte_eth_devices
[port_id
].security_ctx
;
753 rte_eth_dev_count(void)
755 return rte_eth_dev_count_avail();
759 rte_eth_dev_count_avail(void)
766 RTE_ETH_FOREACH_DEV(p
)
773 rte_eth_dev_count_total(void)
775 uint16_t port
, count
= 0;
777 RTE_ETH_FOREACH_VALID_DEV(port
)
784 rte_eth_dev_get_name_by_port(uint16_t port_id
, char *name
)
788 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -EINVAL
);
791 RTE_ETHDEV_LOG(ERR
, "Null pointer is specified\n");
795 /* shouldn't check 'rte_eth_devices[i].data',
796 * because it might be overwritten by VDEV PMD */
797 tmp
= rte_eth_dev_shared_data
->data
[port_id
].name
;
803 rte_eth_dev_get_port_by_name(const char *name
, uint16_t *port_id
)
808 RTE_ETHDEV_LOG(ERR
, "Null pointer is specified\n");
812 RTE_ETH_FOREACH_VALID_DEV(pid
)
813 if (!strcmp(name
, rte_eth_dev_shared_data
->data
[pid
].name
)) {
822 eth_err(uint16_t port_id
, int ret
)
826 if (rte_eth_dev_is_removed(port_id
))
832 rte_eth_dev_rx_queue_config(struct rte_eth_dev
*dev
, uint16_t nb_queues
)
834 uint16_t old_nb_queues
= dev
->data
->nb_rx_queues
;
838 if (dev
->data
->rx_queues
== NULL
&& nb_queues
!= 0) { /* first time configuration */
839 dev
->data
->rx_queues
= rte_zmalloc("ethdev->rx_queues",
840 sizeof(dev
->data
->rx_queues
[0]) * nb_queues
,
841 RTE_CACHE_LINE_SIZE
);
842 if (dev
->data
->rx_queues
== NULL
) {
843 dev
->data
->nb_rx_queues
= 0;
846 } else if (dev
->data
->rx_queues
!= NULL
&& nb_queues
!= 0) { /* re-configure */
847 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->rx_queue_release
, -ENOTSUP
);
849 rxq
= dev
->data
->rx_queues
;
851 for (i
= nb_queues
; i
< old_nb_queues
; i
++)
852 (*dev
->dev_ops
->rx_queue_release
)(rxq
[i
]);
853 rxq
= rte_realloc(rxq
, sizeof(rxq
[0]) * nb_queues
,
854 RTE_CACHE_LINE_SIZE
);
857 if (nb_queues
> old_nb_queues
) {
858 uint16_t new_qs
= nb_queues
- old_nb_queues
;
860 memset(rxq
+ old_nb_queues
, 0,
861 sizeof(rxq
[0]) * new_qs
);
864 dev
->data
->rx_queues
= rxq
;
866 } else if (dev
->data
->rx_queues
!= NULL
&& nb_queues
== 0) {
867 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->rx_queue_release
, -ENOTSUP
);
869 rxq
= dev
->data
->rx_queues
;
871 for (i
= nb_queues
; i
< old_nb_queues
; i
++)
872 (*dev
->dev_ops
->rx_queue_release
)(rxq
[i
]);
874 rte_free(dev
->data
->rx_queues
);
875 dev
->data
->rx_queues
= NULL
;
877 dev
->data
->nb_rx_queues
= nb_queues
;
882 rte_eth_dev_rx_queue_start(uint16_t port_id
, uint16_t rx_queue_id
)
884 struct rte_eth_dev
*dev
;
886 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -EINVAL
);
888 dev
= &rte_eth_devices
[port_id
];
889 if (!dev
->data
->dev_started
) {
891 "Port %u must be started before start any queue\n",
896 if (rx_queue_id
>= dev
->data
->nb_rx_queues
) {
897 RTE_ETHDEV_LOG(ERR
, "Invalid RX queue_id=%u\n", rx_queue_id
);
901 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->rx_queue_start
, -ENOTSUP
);
903 if (dev
->data
->rx_queue_state
[rx_queue_id
] != RTE_ETH_QUEUE_STATE_STOPPED
) {
905 "Queue %"PRIu16
" of device with port_id=%"PRIu16
" already started\n",
906 rx_queue_id
, port_id
);
910 return eth_err(port_id
, dev
->dev_ops
->rx_queue_start(dev
,
916 rte_eth_dev_rx_queue_stop(uint16_t port_id
, uint16_t rx_queue_id
)
918 struct rte_eth_dev
*dev
;
920 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -EINVAL
);
922 dev
= &rte_eth_devices
[port_id
];
923 if (rx_queue_id
>= dev
->data
->nb_rx_queues
) {
924 RTE_ETHDEV_LOG(ERR
, "Invalid RX queue_id=%u\n", rx_queue_id
);
928 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->rx_queue_stop
, -ENOTSUP
);
930 if (dev
->data
->rx_queue_state
[rx_queue_id
] == RTE_ETH_QUEUE_STATE_STOPPED
) {
932 "Queue %"PRIu16
" of device with port_id=%"PRIu16
" already stopped\n",
933 rx_queue_id
, port_id
);
937 return eth_err(port_id
, dev
->dev_ops
->rx_queue_stop(dev
, rx_queue_id
));
942 rte_eth_dev_tx_queue_start(uint16_t port_id
, uint16_t tx_queue_id
)
944 struct rte_eth_dev
*dev
;
946 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -EINVAL
);
948 dev
= &rte_eth_devices
[port_id
];
949 if (!dev
->data
->dev_started
) {
951 "Port %u must be started before start any queue\n",
956 if (tx_queue_id
>= dev
->data
->nb_tx_queues
) {
957 RTE_ETHDEV_LOG(ERR
, "Invalid TX queue_id=%u\n", tx_queue_id
);
961 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->tx_queue_start
, -ENOTSUP
);
963 if (dev
->data
->tx_queue_state
[tx_queue_id
] != RTE_ETH_QUEUE_STATE_STOPPED
) {
965 "Queue %"PRIu16
" of device with port_id=%"PRIu16
" already started\n",
966 tx_queue_id
, port_id
);
970 return eth_err(port_id
, dev
->dev_ops
->tx_queue_start(dev
, tx_queue_id
));
974 rte_eth_dev_tx_queue_stop(uint16_t port_id
, uint16_t tx_queue_id
)
976 struct rte_eth_dev
*dev
;
978 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -EINVAL
);
980 dev
= &rte_eth_devices
[port_id
];
981 if (tx_queue_id
>= dev
->data
->nb_tx_queues
) {
982 RTE_ETHDEV_LOG(ERR
, "Invalid TX queue_id=%u\n", tx_queue_id
);
986 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->tx_queue_stop
, -ENOTSUP
);
988 if (dev
->data
->tx_queue_state
[tx_queue_id
] == RTE_ETH_QUEUE_STATE_STOPPED
) {
990 "Queue %"PRIu16
" of device with port_id=%"PRIu16
" already stopped\n",
991 tx_queue_id
, port_id
);
995 return eth_err(port_id
, dev
->dev_ops
->tx_queue_stop(dev
, tx_queue_id
));
1000 rte_eth_dev_tx_queue_config(struct rte_eth_dev
*dev
, uint16_t nb_queues
)
1002 uint16_t old_nb_queues
= dev
->data
->nb_tx_queues
;
1006 if (dev
->data
->tx_queues
== NULL
&& nb_queues
!= 0) { /* first time configuration */
1007 dev
->data
->tx_queues
= rte_zmalloc("ethdev->tx_queues",
1008 sizeof(dev
->data
->tx_queues
[0]) * nb_queues
,
1009 RTE_CACHE_LINE_SIZE
);
1010 if (dev
->data
->tx_queues
== NULL
) {
1011 dev
->data
->nb_tx_queues
= 0;
1014 } else if (dev
->data
->tx_queues
!= NULL
&& nb_queues
!= 0) { /* re-configure */
1015 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->tx_queue_release
, -ENOTSUP
);
1017 txq
= dev
->data
->tx_queues
;
1019 for (i
= nb_queues
; i
< old_nb_queues
; i
++)
1020 (*dev
->dev_ops
->tx_queue_release
)(txq
[i
]);
1021 txq
= rte_realloc(txq
, sizeof(txq
[0]) * nb_queues
,
1022 RTE_CACHE_LINE_SIZE
);
1025 if (nb_queues
> old_nb_queues
) {
1026 uint16_t new_qs
= nb_queues
- old_nb_queues
;
1028 memset(txq
+ old_nb_queues
, 0,
1029 sizeof(txq
[0]) * new_qs
);
1032 dev
->data
->tx_queues
= txq
;
1034 } else if (dev
->data
->tx_queues
!= NULL
&& nb_queues
== 0) {
1035 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->tx_queue_release
, -ENOTSUP
);
1037 txq
= dev
->data
->tx_queues
;
1039 for (i
= nb_queues
; i
< old_nb_queues
; i
++)
1040 (*dev
->dev_ops
->tx_queue_release
)(txq
[i
]);
1042 rte_free(dev
->data
->tx_queues
);
1043 dev
->data
->tx_queues
= NULL
;
1045 dev
->data
->nb_tx_queues
= nb_queues
;
1050 rte_eth_speed_bitflag(uint32_t speed
, int duplex
)
1053 case ETH_SPEED_NUM_10M
:
1054 return duplex
? ETH_LINK_SPEED_10M
: ETH_LINK_SPEED_10M_HD
;
1055 case ETH_SPEED_NUM_100M
:
1056 return duplex
? ETH_LINK_SPEED_100M
: ETH_LINK_SPEED_100M_HD
;
1057 case ETH_SPEED_NUM_1G
:
1058 return ETH_LINK_SPEED_1G
;
1059 case ETH_SPEED_NUM_2_5G
:
1060 return ETH_LINK_SPEED_2_5G
;
1061 case ETH_SPEED_NUM_5G
:
1062 return ETH_LINK_SPEED_5G
;
1063 case ETH_SPEED_NUM_10G
:
1064 return ETH_LINK_SPEED_10G
;
1065 case ETH_SPEED_NUM_20G
:
1066 return ETH_LINK_SPEED_20G
;
1067 case ETH_SPEED_NUM_25G
:
1068 return ETH_LINK_SPEED_25G
;
1069 case ETH_SPEED_NUM_40G
:
1070 return ETH_LINK_SPEED_40G
;
1071 case ETH_SPEED_NUM_50G
:
1072 return ETH_LINK_SPEED_50G
;
1073 case ETH_SPEED_NUM_56G
:
1074 return ETH_LINK_SPEED_56G
;
1075 case ETH_SPEED_NUM_100G
:
1076 return ETH_LINK_SPEED_100G
;
1083 rte_eth_dev_rx_offload_name(uint64_t offload
)
1085 const char *name
= "UNKNOWN";
1088 for (i
= 0; i
< RTE_DIM(rte_rx_offload_names
); ++i
) {
1089 if (offload
== rte_rx_offload_names
[i
].offload
) {
1090 name
= rte_rx_offload_names
[i
].name
;
1099 rte_eth_dev_tx_offload_name(uint64_t offload
)
1101 const char *name
= "UNKNOWN";
1104 for (i
= 0; i
< RTE_DIM(rte_tx_offload_names
); ++i
) {
1105 if (offload
== rte_tx_offload_names
[i
].offload
) {
1106 name
= rte_tx_offload_names
[i
].name
;
1115 rte_eth_dev_configure(uint16_t port_id
, uint16_t nb_rx_q
, uint16_t nb_tx_q
,
1116 const struct rte_eth_conf
*dev_conf
)
1118 struct rte_eth_dev
*dev
;
1119 struct rte_eth_dev_info dev_info
;
1120 struct rte_eth_conf orig_conf
;
1124 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -EINVAL
);
1126 dev
= &rte_eth_devices
[port_id
];
1128 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->dev_infos_get
, -ENOTSUP
);
1129 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->dev_configure
, -ENOTSUP
);
1131 if (dev
->data
->dev_started
) {
1133 "Port %u must be stopped to allow configuration\n",
1138 /* Store original config, as rollback required on failure */
1139 memcpy(&orig_conf
, &dev
->data
->dev_conf
, sizeof(dev
->data
->dev_conf
));
1142 * Copy the dev_conf parameter into the dev structure.
1143 * rte_eth_dev_info_get() requires dev_conf, copy it before dev_info get
1145 memcpy(&dev
->data
->dev_conf
, dev_conf
, sizeof(dev
->data
->dev_conf
));
1147 rte_eth_dev_info_get(port_id
, &dev_info
);
1149 /* If number of queues specified by application for both Rx and Tx is
1150 * zero, use driver preferred values. This cannot be done individually
1151 * as it is valid for either Tx or Rx (but not both) to be zero.
1152 * If driver does not provide any preferred valued, fall back on
1155 if (nb_rx_q
== 0 && nb_tx_q
== 0) {
1156 nb_rx_q
= dev_info
.default_rxportconf
.nb_queues
;
1158 nb_rx_q
= RTE_ETH_DEV_FALLBACK_RX_NBQUEUES
;
1159 nb_tx_q
= dev_info
.default_txportconf
.nb_queues
;
1161 nb_tx_q
= RTE_ETH_DEV_FALLBACK_TX_NBQUEUES
;
1164 if (nb_rx_q
> RTE_MAX_QUEUES_PER_PORT
) {
1166 "Number of RX queues requested (%u) is greater than max supported(%d)\n",
1167 nb_rx_q
, RTE_MAX_QUEUES_PER_PORT
);
1172 if (nb_tx_q
> RTE_MAX_QUEUES_PER_PORT
) {
1174 "Number of TX queues requested (%u) is greater than max supported(%d)\n",
1175 nb_tx_q
, RTE_MAX_QUEUES_PER_PORT
);
1181 * Check that the numbers of RX and TX queues are not greater
1182 * than the maximum number of RX and TX queues supported by the
1183 * configured device.
1185 if (nb_rx_q
> dev_info
.max_rx_queues
) {
1186 RTE_ETHDEV_LOG(ERR
, "Ethdev port_id=%u nb_rx_queues=%u > %u\n",
1187 port_id
, nb_rx_q
, dev_info
.max_rx_queues
);
1192 if (nb_tx_q
> dev_info
.max_tx_queues
) {
1193 RTE_ETHDEV_LOG(ERR
, "Ethdev port_id=%u nb_tx_queues=%u > %u\n",
1194 port_id
, nb_tx_q
, dev_info
.max_tx_queues
);
1199 /* Check that the device supports requested interrupts */
1200 if ((dev_conf
->intr_conf
.lsc
== 1) &&
1201 (!(dev
->data
->dev_flags
& RTE_ETH_DEV_INTR_LSC
))) {
1202 RTE_ETHDEV_LOG(ERR
, "Driver %s does not support lsc\n",
1203 dev
->device
->driver
->name
);
1207 if ((dev_conf
->intr_conf
.rmv
== 1) &&
1208 (!(dev
->data
->dev_flags
& RTE_ETH_DEV_INTR_RMV
))) {
1209 RTE_ETHDEV_LOG(ERR
, "Driver %s does not support rmv\n",
1210 dev
->device
->driver
->name
);
1216 * If jumbo frames are enabled, check that the maximum RX packet
1217 * length is supported by the configured device.
1219 if (dev_conf
->rxmode
.offloads
& DEV_RX_OFFLOAD_JUMBO_FRAME
) {
1220 if (dev_conf
->rxmode
.max_rx_pkt_len
> dev_info
.max_rx_pktlen
) {
1222 "Ethdev port_id=%u max_rx_pkt_len %u > max valid value %u\n",
1223 port_id
, dev_conf
->rxmode
.max_rx_pkt_len
,
1224 dev_info
.max_rx_pktlen
);
1227 } else if (dev_conf
->rxmode
.max_rx_pkt_len
< ETHER_MIN_LEN
) {
1229 "Ethdev port_id=%u max_rx_pkt_len %u < min valid value %u\n",
1230 port_id
, dev_conf
->rxmode
.max_rx_pkt_len
,
1231 (unsigned)ETHER_MIN_LEN
);
1236 if (dev_conf
->rxmode
.max_rx_pkt_len
< ETHER_MIN_LEN
||
1237 dev_conf
->rxmode
.max_rx_pkt_len
> ETHER_MAX_LEN
)
1238 /* Use default value */
1239 dev
->data
->dev_conf
.rxmode
.max_rx_pkt_len
=
1243 /* Any requested offloading must be within its device capabilities */
1244 if ((dev_conf
->rxmode
.offloads
& dev_info
.rx_offload_capa
) !=
1245 dev_conf
->rxmode
.offloads
) {
1247 "Ethdev port_id=%u requested Rx offloads 0x%"PRIx64
" doesn't match Rx offloads "
1248 "capabilities 0x%"PRIx64
" in %s()\n",
1249 port_id
, dev_conf
->rxmode
.offloads
,
1250 dev_info
.rx_offload_capa
,
1255 if ((dev_conf
->txmode
.offloads
& dev_info
.tx_offload_capa
) !=
1256 dev_conf
->txmode
.offloads
) {
1258 "Ethdev port_id=%u requested Tx offloads 0x%"PRIx64
" doesn't match Tx offloads "
1259 "capabilities 0x%"PRIx64
" in %s()\n",
1260 port_id
, dev_conf
->txmode
.offloads
,
1261 dev_info
.tx_offload_capa
,
1267 /* Check that device supports requested rss hash functions. */
1268 if ((dev_info
.flow_type_rss_offloads
|
1269 dev_conf
->rx_adv_conf
.rss_conf
.rss_hf
) !=
1270 dev_info
.flow_type_rss_offloads
) {
1272 "Ethdev port_id=%u invalid rss_hf: 0x%"PRIx64
", valid value: 0x%"PRIx64
"\n",
1273 port_id
, dev_conf
->rx_adv_conf
.rss_conf
.rss_hf
,
1274 dev_info
.flow_type_rss_offloads
);
1280 * Setup new number of RX/TX queues and reconfigure device.
1282 diag
= rte_eth_dev_rx_queue_config(dev
, nb_rx_q
);
1285 "Port%u rte_eth_dev_rx_queue_config = %d\n",
1291 diag
= rte_eth_dev_tx_queue_config(dev
, nb_tx_q
);
1294 "Port%u rte_eth_dev_tx_queue_config = %d\n",
1296 rte_eth_dev_rx_queue_config(dev
, 0);
1301 diag
= (*dev
->dev_ops
->dev_configure
)(dev
);
1303 RTE_ETHDEV_LOG(ERR
, "Port%u dev_configure = %d\n",
1305 rte_eth_dev_rx_queue_config(dev
, 0);
1306 rte_eth_dev_tx_queue_config(dev
, 0);
1307 ret
= eth_err(port_id
, diag
);
1311 /* Initialize Rx profiling if enabled at compilation time. */
1312 diag
= __rte_eth_dev_profile_init(port_id
, dev
);
1314 RTE_ETHDEV_LOG(ERR
, "Port%u __rte_eth_dev_profile_init = %d\n",
1316 rte_eth_dev_rx_queue_config(dev
, 0);
1317 rte_eth_dev_tx_queue_config(dev
, 0);
1318 ret
= eth_err(port_id
, diag
);
1325 memcpy(&dev
->data
->dev_conf
, &orig_conf
, sizeof(dev
->data
->dev_conf
));
1331 _rte_eth_dev_reset(struct rte_eth_dev
*dev
)
1333 if (dev
->data
->dev_started
) {
1334 RTE_ETHDEV_LOG(ERR
, "Port %u must be stopped to allow reset\n",
1335 dev
->data
->port_id
);
1339 rte_eth_dev_rx_queue_config(dev
, 0);
1340 rte_eth_dev_tx_queue_config(dev
, 0);
1342 memset(&dev
->data
->dev_conf
, 0, sizeof(dev
->data
->dev_conf
));
1346 rte_eth_dev_mac_restore(struct rte_eth_dev
*dev
,
1347 struct rte_eth_dev_info
*dev_info
)
1349 struct ether_addr
*addr
;
1354 /* replay MAC address configuration including default MAC */
1355 addr
= &dev
->data
->mac_addrs
[0];
1356 if (*dev
->dev_ops
->mac_addr_set
!= NULL
)
1357 (*dev
->dev_ops
->mac_addr_set
)(dev
, addr
);
1358 else if (*dev
->dev_ops
->mac_addr_add
!= NULL
)
1359 (*dev
->dev_ops
->mac_addr_add
)(dev
, addr
, 0, pool
);
1361 if (*dev
->dev_ops
->mac_addr_add
!= NULL
) {
1362 for (i
= 1; i
< dev_info
->max_mac_addrs
; i
++) {
1363 addr
= &dev
->data
->mac_addrs
[i
];
1365 /* skip zero address */
1366 if (is_zero_ether_addr(addr
))
1370 pool_mask
= dev
->data
->mac_pool_sel
[i
];
1373 if (pool_mask
& 1ULL)
1374 (*dev
->dev_ops
->mac_addr_add
)(dev
,
1378 } while (pool_mask
);
1384 rte_eth_dev_config_restore(struct rte_eth_dev
*dev
,
1385 struct rte_eth_dev_info
*dev_info
, uint16_t port_id
)
1387 if (!(*dev_info
->dev_flags
& RTE_ETH_DEV_NOLIVE_MAC_ADDR
))
1388 rte_eth_dev_mac_restore(dev
, dev_info
);
1390 /* replay promiscuous configuration */
1391 if (rte_eth_promiscuous_get(port_id
) == 1)
1392 rte_eth_promiscuous_enable(port_id
);
1393 else if (rte_eth_promiscuous_get(port_id
) == 0)
1394 rte_eth_promiscuous_disable(port_id
);
1396 /* replay all multicast configuration */
1397 if (rte_eth_allmulticast_get(port_id
) == 1)
1398 rte_eth_allmulticast_enable(port_id
);
1399 else if (rte_eth_allmulticast_get(port_id
) == 0)
1400 rte_eth_allmulticast_disable(port_id
);
1404 rte_eth_dev_start(uint16_t port_id
)
1406 struct rte_eth_dev
*dev
;
1407 struct rte_eth_dev_info dev_info
;
1410 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -EINVAL
);
1412 dev
= &rte_eth_devices
[port_id
];
1414 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->dev_start
, -ENOTSUP
);
1416 if (dev
->data
->dev_started
!= 0) {
1417 RTE_ETHDEV_LOG(INFO
,
1418 "Device with port_id=%"PRIu16
" already started\n",
1423 rte_eth_dev_info_get(port_id
, &dev_info
);
1425 /* Lets restore MAC now if device does not support live change */
1426 if (*dev_info
.dev_flags
& RTE_ETH_DEV_NOLIVE_MAC_ADDR
)
1427 rte_eth_dev_mac_restore(dev
, &dev_info
);
1429 diag
= (*dev
->dev_ops
->dev_start
)(dev
);
1431 dev
->data
->dev_started
= 1;
1433 return eth_err(port_id
, diag
);
1435 rte_eth_dev_config_restore(dev
, &dev_info
, port_id
);
1437 if (dev
->data
->dev_conf
.intr_conf
.lsc
== 0) {
1438 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->link_update
, -ENOTSUP
);
1439 (*dev
->dev_ops
->link_update
)(dev
, 0);
1445 rte_eth_dev_stop(uint16_t port_id
)
1447 struct rte_eth_dev
*dev
;
1449 RTE_ETH_VALID_PORTID_OR_RET(port_id
);
1450 dev
= &rte_eth_devices
[port_id
];
1452 RTE_FUNC_PTR_OR_RET(*dev
->dev_ops
->dev_stop
);
1454 if (dev
->data
->dev_started
== 0) {
1455 RTE_ETHDEV_LOG(INFO
,
1456 "Device with port_id=%"PRIu16
" already stopped\n",
1461 dev
->data
->dev_started
= 0;
1462 (*dev
->dev_ops
->dev_stop
)(dev
);
1466 rte_eth_dev_set_link_up(uint16_t port_id
)
1468 struct rte_eth_dev
*dev
;
1470 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -EINVAL
);
1472 dev
= &rte_eth_devices
[port_id
];
1474 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->dev_set_link_up
, -ENOTSUP
);
1475 return eth_err(port_id
, (*dev
->dev_ops
->dev_set_link_up
)(dev
));
1479 rte_eth_dev_set_link_down(uint16_t port_id
)
1481 struct rte_eth_dev
*dev
;
1483 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -EINVAL
);
1485 dev
= &rte_eth_devices
[port_id
];
1487 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->dev_set_link_down
, -ENOTSUP
);
1488 return eth_err(port_id
, (*dev
->dev_ops
->dev_set_link_down
)(dev
));
1492 rte_eth_dev_close(uint16_t port_id
)
1494 struct rte_eth_dev
*dev
;
1496 RTE_ETH_VALID_PORTID_OR_RET(port_id
);
1497 dev
= &rte_eth_devices
[port_id
];
1499 RTE_FUNC_PTR_OR_RET(*dev
->dev_ops
->dev_close
);
1500 dev
->data
->dev_started
= 0;
1501 (*dev
->dev_ops
->dev_close
)(dev
);
1503 /* check behaviour flag - temporary for PMD migration */
1504 if ((dev
->data
->dev_flags
& RTE_ETH_DEV_CLOSE_REMOVE
) != 0) {
1505 /* new behaviour: send event + reset state + free all data */
1506 rte_eth_dev_release_port(dev
);
1509 RTE_ETHDEV_LOG(DEBUG
, "Port closing is using an old behaviour.\n"
1510 "The driver %s should migrate to the new behaviour.\n",
1511 dev
->device
->driver
->name
);
1512 /* old behaviour: only free queue arrays */
1513 dev
->data
->nb_rx_queues
= 0;
1514 rte_free(dev
->data
->rx_queues
);
1515 dev
->data
->rx_queues
= NULL
;
1516 dev
->data
->nb_tx_queues
= 0;
1517 rte_free(dev
->data
->tx_queues
);
1518 dev
->data
->tx_queues
= NULL
;
1522 rte_eth_dev_reset(uint16_t port_id
)
1524 struct rte_eth_dev
*dev
;
1527 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -EINVAL
);
1528 dev
= &rte_eth_devices
[port_id
];
1530 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->dev_reset
, -ENOTSUP
);
1532 rte_eth_dev_stop(port_id
);
1533 ret
= dev
->dev_ops
->dev_reset(dev
);
1535 return eth_err(port_id
, ret
);
1538 int __rte_experimental
1539 rte_eth_dev_is_removed(uint16_t port_id
)
1541 struct rte_eth_dev
*dev
;
1544 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, 0);
1546 dev
= &rte_eth_devices
[port_id
];
1548 if (dev
->state
== RTE_ETH_DEV_REMOVED
)
1551 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->is_removed
, 0);
1553 ret
= dev
->dev_ops
->is_removed(dev
);
1555 /* Device is physically removed. */
1556 dev
->state
= RTE_ETH_DEV_REMOVED
;
1562 rte_eth_rx_queue_setup(uint16_t port_id
, uint16_t rx_queue_id
,
1563 uint16_t nb_rx_desc
, unsigned int socket_id
,
1564 const struct rte_eth_rxconf
*rx_conf
,
1565 struct rte_mempool
*mp
)
1568 uint32_t mbp_buf_size
;
1569 struct rte_eth_dev
*dev
;
1570 struct rte_eth_dev_info dev_info
;
1571 struct rte_eth_rxconf local_conf
;
1574 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -EINVAL
);
1576 dev
= &rte_eth_devices
[port_id
];
1577 if (rx_queue_id
>= dev
->data
->nb_rx_queues
) {
1578 RTE_ETHDEV_LOG(ERR
, "Invalid RX queue_id=%u\n", rx_queue_id
);
1582 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->dev_infos_get
, -ENOTSUP
);
1583 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->rx_queue_setup
, -ENOTSUP
);
1586 * Check the size of the mbuf data buffer.
1587 * This value must be provided in the private data of the memory pool.
1588 * First check that the memory pool has a valid private data.
1590 rte_eth_dev_info_get(port_id
, &dev_info
);
1591 if (mp
->private_data_size
< sizeof(struct rte_pktmbuf_pool_private
)) {
1592 RTE_ETHDEV_LOG(ERR
, "%s private_data_size %d < %d\n",
1593 mp
->name
, (int)mp
->private_data_size
,
1594 (int)sizeof(struct rte_pktmbuf_pool_private
));
1597 mbp_buf_size
= rte_pktmbuf_data_room_size(mp
);
1599 if ((mbp_buf_size
- RTE_PKTMBUF_HEADROOM
) < dev_info
.min_rx_bufsize
) {
1601 "%s mbuf_data_room_size %d < %d (RTE_PKTMBUF_HEADROOM=%d + min_rx_bufsize(dev)=%d)\n",
1602 mp
->name
, (int)mbp_buf_size
,
1603 (int)(RTE_PKTMBUF_HEADROOM
+ dev_info
.min_rx_bufsize
),
1604 (int)RTE_PKTMBUF_HEADROOM
,
1605 (int)dev_info
.min_rx_bufsize
);
1609 /* Use default specified by driver, if nb_rx_desc is zero */
1610 if (nb_rx_desc
== 0) {
1611 nb_rx_desc
= dev_info
.default_rxportconf
.ring_size
;
1612 /* If driver default is also zero, fall back on EAL default */
1613 if (nb_rx_desc
== 0)
1614 nb_rx_desc
= RTE_ETH_DEV_FALLBACK_RX_RINGSIZE
;
1617 if (nb_rx_desc
> dev_info
.rx_desc_lim
.nb_max
||
1618 nb_rx_desc
< dev_info
.rx_desc_lim
.nb_min
||
1619 nb_rx_desc
% dev_info
.rx_desc_lim
.nb_align
!= 0) {
1622 "Invalid value for nb_rx_desc(=%hu), should be: <= %hu, >= %hu, and a product of %hu\n",
1623 nb_rx_desc
, dev_info
.rx_desc_lim
.nb_max
,
1624 dev_info
.rx_desc_lim
.nb_min
,
1625 dev_info
.rx_desc_lim
.nb_align
);
1629 if (dev
->data
->dev_started
&&
1630 !(dev_info
.dev_capa
&
1631 RTE_ETH_DEV_CAPA_RUNTIME_RX_QUEUE_SETUP
))
1634 if (dev
->data
->dev_started
&&
1635 (dev
->data
->rx_queue_state
[rx_queue_id
] !=
1636 RTE_ETH_QUEUE_STATE_STOPPED
))
1639 rxq
= dev
->data
->rx_queues
;
1640 if (rxq
[rx_queue_id
]) {
1641 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->rx_queue_release
,
1643 (*dev
->dev_ops
->rx_queue_release
)(rxq
[rx_queue_id
]);
1644 rxq
[rx_queue_id
] = NULL
;
1647 if (rx_conf
== NULL
)
1648 rx_conf
= &dev_info
.default_rxconf
;
1650 local_conf
= *rx_conf
;
1653 * If an offloading has already been enabled in
1654 * rte_eth_dev_configure(), it has been enabled on all queues,
1655 * so there is no need to enable it in this queue again.
1656 * The local_conf.offloads input to underlying PMD only carries
1657 * those offloadings which are only enabled on this queue and
1658 * not enabled on all queues.
1660 local_conf
.offloads
&= ~dev
->data
->dev_conf
.rxmode
.offloads
;
1663 * New added offloadings for this queue are those not enabled in
1664 * rte_eth_dev_configure() and they must be per-queue type.
1665 * A pure per-port offloading can't be enabled on a queue while
1666 * disabled on another queue. A pure per-port offloading can't
1667 * be enabled for any queue as new added one if it hasn't been
1668 * enabled in rte_eth_dev_configure().
1670 if ((local_conf
.offloads
& dev_info
.rx_queue_offload_capa
) !=
1671 local_conf
.offloads
) {
1673 "Ethdev port_id=%d rx_queue_id=%d, new added offloads 0x%"PRIx64
" must be "
1674 "within per-queue offload capabilities 0x%"PRIx64
" in %s()\n",
1675 port_id
, rx_queue_id
, local_conf
.offloads
,
1676 dev_info
.rx_queue_offload_capa
,
1681 ret
= (*dev
->dev_ops
->rx_queue_setup
)(dev
, rx_queue_id
, nb_rx_desc
,
1682 socket_id
, &local_conf
, mp
);
1684 if (!dev
->data
->min_rx_buf_size
||
1685 dev
->data
->min_rx_buf_size
> mbp_buf_size
)
1686 dev
->data
->min_rx_buf_size
= mbp_buf_size
;
1689 return eth_err(port_id
, ret
);
1693 rte_eth_tx_queue_setup(uint16_t port_id
, uint16_t tx_queue_id
,
1694 uint16_t nb_tx_desc
, unsigned int socket_id
,
1695 const struct rte_eth_txconf
*tx_conf
)
1697 struct rte_eth_dev
*dev
;
1698 struct rte_eth_dev_info dev_info
;
1699 struct rte_eth_txconf local_conf
;
1702 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -EINVAL
);
1704 dev
= &rte_eth_devices
[port_id
];
1705 if (tx_queue_id
>= dev
->data
->nb_tx_queues
) {
1706 RTE_ETHDEV_LOG(ERR
, "Invalid TX queue_id=%u\n", tx_queue_id
);
1710 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->dev_infos_get
, -ENOTSUP
);
1711 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->tx_queue_setup
, -ENOTSUP
);
1713 rte_eth_dev_info_get(port_id
, &dev_info
);
1715 /* Use default specified by driver, if nb_tx_desc is zero */
1716 if (nb_tx_desc
== 0) {
1717 nb_tx_desc
= dev_info
.default_txportconf
.ring_size
;
1718 /* If driver default is zero, fall back on EAL default */
1719 if (nb_tx_desc
== 0)
1720 nb_tx_desc
= RTE_ETH_DEV_FALLBACK_TX_RINGSIZE
;
1722 if (nb_tx_desc
> dev_info
.tx_desc_lim
.nb_max
||
1723 nb_tx_desc
< dev_info
.tx_desc_lim
.nb_min
||
1724 nb_tx_desc
% dev_info
.tx_desc_lim
.nb_align
!= 0) {
1726 "Invalid value for nb_tx_desc(=%hu), should be: <= %hu, >= %hu, and a product of %hu\n",
1727 nb_tx_desc
, dev_info
.tx_desc_lim
.nb_max
,
1728 dev_info
.tx_desc_lim
.nb_min
,
1729 dev_info
.tx_desc_lim
.nb_align
);
1733 if (dev
->data
->dev_started
&&
1734 !(dev_info
.dev_capa
&
1735 RTE_ETH_DEV_CAPA_RUNTIME_TX_QUEUE_SETUP
))
1738 if (dev
->data
->dev_started
&&
1739 (dev
->data
->tx_queue_state
[tx_queue_id
] !=
1740 RTE_ETH_QUEUE_STATE_STOPPED
))
1743 txq
= dev
->data
->tx_queues
;
1744 if (txq
[tx_queue_id
]) {
1745 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->tx_queue_release
,
1747 (*dev
->dev_ops
->tx_queue_release
)(txq
[tx_queue_id
]);
1748 txq
[tx_queue_id
] = NULL
;
1751 if (tx_conf
== NULL
)
1752 tx_conf
= &dev_info
.default_txconf
;
1754 local_conf
= *tx_conf
;
1757 * If an offloading has already been enabled in
1758 * rte_eth_dev_configure(), it has been enabled on all queues,
1759 * so there is no need to enable it in this queue again.
1760 * The local_conf.offloads input to underlying PMD only carries
1761 * those offloadings which are only enabled on this queue and
1762 * not enabled on all queues.
1764 local_conf
.offloads
&= ~dev
->data
->dev_conf
.txmode
.offloads
;
1767 * New added offloadings for this queue are those not enabled in
1768 * rte_eth_dev_configure() and they must be per-queue type.
1769 * A pure per-port offloading can't be enabled on a queue while
1770 * disabled on another queue. A pure per-port offloading can't
1771 * be enabled for any queue as new added one if it hasn't been
1772 * enabled in rte_eth_dev_configure().
1774 if ((local_conf
.offloads
& dev_info
.tx_queue_offload_capa
) !=
1775 local_conf
.offloads
) {
1777 "Ethdev port_id=%d tx_queue_id=%d, new added offloads 0x%"PRIx64
" must be "
1778 "within per-queue offload capabilities 0x%"PRIx64
" in %s()\n",
1779 port_id
, tx_queue_id
, local_conf
.offloads
,
1780 dev_info
.tx_queue_offload_capa
,
1785 return eth_err(port_id
, (*dev
->dev_ops
->tx_queue_setup
)(dev
,
1786 tx_queue_id
, nb_tx_desc
, socket_id
, &local_conf
));
1790 rte_eth_tx_buffer_drop_callback(struct rte_mbuf
**pkts
, uint16_t unsent
,
1791 void *userdata __rte_unused
)
1795 for (i
= 0; i
< unsent
; i
++)
1796 rte_pktmbuf_free(pkts
[i
]);
1800 rte_eth_tx_buffer_count_callback(struct rte_mbuf
**pkts
, uint16_t unsent
,
1803 uint64_t *count
= userdata
;
1806 for (i
= 0; i
< unsent
; i
++)
1807 rte_pktmbuf_free(pkts
[i
]);
1813 rte_eth_tx_buffer_set_err_callback(struct rte_eth_dev_tx_buffer
*buffer
,
1814 buffer_tx_error_fn cbfn
, void *userdata
)
1816 buffer
->error_callback
= cbfn
;
1817 buffer
->error_userdata
= userdata
;
1822 rte_eth_tx_buffer_init(struct rte_eth_dev_tx_buffer
*buffer
, uint16_t size
)
1829 buffer
->size
= size
;
1830 if (buffer
->error_callback
== NULL
) {
1831 ret
= rte_eth_tx_buffer_set_err_callback(
1832 buffer
, rte_eth_tx_buffer_drop_callback
, NULL
);
1839 rte_eth_tx_done_cleanup(uint16_t port_id
, uint16_t queue_id
, uint32_t free_cnt
)
1841 struct rte_eth_dev
*dev
= &rte_eth_devices
[port_id
];
1844 /* Validate Input Data. Bail if not valid or not supported. */
1845 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
1846 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->tx_done_cleanup
, -ENOTSUP
);
1848 /* Call driver to free pending mbufs. */
1849 ret
= (*dev
->dev_ops
->tx_done_cleanup
)(dev
->data
->tx_queues
[queue_id
],
1851 return eth_err(port_id
, ret
);
1855 rte_eth_promiscuous_enable(uint16_t port_id
)
1857 struct rte_eth_dev
*dev
;
1859 RTE_ETH_VALID_PORTID_OR_RET(port_id
);
1860 dev
= &rte_eth_devices
[port_id
];
1862 RTE_FUNC_PTR_OR_RET(*dev
->dev_ops
->promiscuous_enable
);
1863 (*dev
->dev_ops
->promiscuous_enable
)(dev
);
1864 dev
->data
->promiscuous
= 1;
1868 rte_eth_promiscuous_disable(uint16_t port_id
)
1870 struct rte_eth_dev
*dev
;
1872 RTE_ETH_VALID_PORTID_OR_RET(port_id
);
1873 dev
= &rte_eth_devices
[port_id
];
1875 RTE_FUNC_PTR_OR_RET(*dev
->dev_ops
->promiscuous_disable
);
1876 dev
->data
->promiscuous
= 0;
1877 (*dev
->dev_ops
->promiscuous_disable
)(dev
);
1881 rte_eth_promiscuous_get(uint16_t port_id
)
1883 struct rte_eth_dev
*dev
;
1885 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -EINVAL
);
1887 dev
= &rte_eth_devices
[port_id
];
1888 return dev
->data
->promiscuous
;
1892 rte_eth_allmulticast_enable(uint16_t port_id
)
1894 struct rte_eth_dev
*dev
;
1896 RTE_ETH_VALID_PORTID_OR_RET(port_id
);
1897 dev
= &rte_eth_devices
[port_id
];
1899 RTE_FUNC_PTR_OR_RET(*dev
->dev_ops
->allmulticast_enable
);
1900 (*dev
->dev_ops
->allmulticast_enable
)(dev
);
1901 dev
->data
->all_multicast
= 1;
1905 rte_eth_allmulticast_disable(uint16_t port_id
)
1907 struct rte_eth_dev
*dev
;
1909 RTE_ETH_VALID_PORTID_OR_RET(port_id
);
1910 dev
= &rte_eth_devices
[port_id
];
1912 RTE_FUNC_PTR_OR_RET(*dev
->dev_ops
->allmulticast_disable
);
1913 dev
->data
->all_multicast
= 0;
1914 (*dev
->dev_ops
->allmulticast_disable
)(dev
);
1918 rte_eth_allmulticast_get(uint16_t port_id
)
1920 struct rte_eth_dev
*dev
;
1922 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -EINVAL
);
1924 dev
= &rte_eth_devices
[port_id
];
1925 return dev
->data
->all_multicast
;
1929 rte_eth_link_get(uint16_t port_id
, struct rte_eth_link
*eth_link
)
1931 struct rte_eth_dev
*dev
;
1933 RTE_ETH_VALID_PORTID_OR_RET(port_id
);
1934 dev
= &rte_eth_devices
[port_id
];
1936 if (dev
->data
->dev_conf
.intr_conf
.lsc
&&
1937 dev
->data
->dev_started
)
1938 rte_eth_linkstatus_get(dev
, eth_link
);
1940 RTE_FUNC_PTR_OR_RET(*dev
->dev_ops
->link_update
);
1941 (*dev
->dev_ops
->link_update
)(dev
, 1);
1942 *eth_link
= dev
->data
->dev_link
;
1947 rte_eth_link_get_nowait(uint16_t port_id
, struct rte_eth_link
*eth_link
)
1949 struct rte_eth_dev
*dev
;
1951 RTE_ETH_VALID_PORTID_OR_RET(port_id
);
1952 dev
= &rte_eth_devices
[port_id
];
1954 if (dev
->data
->dev_conf
.intr_conf
.lsc
&&
1955 dev
->data
->dev_started
)
1956 rte_eth_linkstatus_get(dev
, eth_link
);
1958 RTE_FUNC_PTR_OR_RET(*dev
->dev_ops
->link_update
);
1959 (*dev
->dev_ops
->link_update
)(dev
, 0);
1960 *eth_link
= dev
->data
->dev_link
;
1965 rte_eth_stats_get(uint16_t port_id
, struct rte_eth_stats
*stats
)
1967 struct rte_eth_dev
*dev
;
1969 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -EINVAL
);
1971 dev
= &rte_eth_devices
[port_id
];
1972 memset(stats
, 0, sizeof(*stats
));
1974 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->stats_get
, -ENOTSUP
);
1975 stats
->rx_nombuf
= dev
->data
->rx_mbuf_alloc_failed
;
1976 return eth_err(port_id
, (*dev
->dev_ops
->stats_get
)(dev
, stats
));
1980 rte_eth_stats_reset(uint16_t port_id
)
1982 struct rte_eth_dev
*dev
;
1984 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
1985 dev
= &rte_eth_devices
[port_id
];
1987 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->stats_reset
, -ENOTSUP
);
1988 (*dev
->dev_ops
->stats_reset
)(dev
);
1989 dev
->data
->rx_mbuf_alloc_failed
= 0;
1995 get_xstats_basic_count(struct rte_eth_dev
*dev
)
1997 uint16_t nb_rxqs
, nb_txqs
;
2000 nb_rxqs
= RTE_MIN(dev
->data
->nb_rx_queues
, RTE_ETHDEV_QUEUE_STAT_CNTRS
);
2001 nb_txqs
= RTE_MIN(dev
->data
->nb_tx_queues
, RTE_ETHDEV_QUEUE_STAT_CNTRS
);
2003 count
= RTE_NB_STATS
;
2004 count
+= nb_rxqs
* RTE_NB_RXQ_STATS
;
2005 count
+= nb_txqs
* RTE_NB_TXQ_STATS
;
2011 get_xstats_count(uint16_t port_id
)
2013 struct rte_eth_dev
*dev
;
2016 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -EINVAL
);
2017 dev
= &rte_eth_devices
[port_id
];
2018 if (dev
->dev_ops
->xstats_get_names_by_id
!= NULL
) {
2019 count
= (*dev
->dev_ops
->xstats_get_names_by_id
)(dev
, NULL
,
2022 return eth_err(port_id
, count
);
2024 if (dev
->dev_ops
->xstats_get_names
!= NULL
) {
2025 count
= (*dev
->dev_ops
->xstats_get_names
)(dev
, NULL
, 0);
2027 return eth_err(port_id
, count
);
2032 count
+= get_xstats_basic_count(dev
);
2038 rte_eth_xstats_get_id_by_name(uint16_t port_id
, const char *xstat_name
,
2041 int cnt_xstats
, idx_xstat
;
2043 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
2046 RTE_ETHDEV_LOG(ERR
, "Id pointer is NULL\n");
2051 RTE_ETHDEV_LOG(ERR
, "xstat_name pointer is NULL\n");
2056 cnt_xstats
= rte_eth_xstats_get_names_by_id(port_id
, NULL
, 0, NULL
);
2057 if (cnt_xstats
< 0) {
2058 RTE_ETHDEV_LOG(ERR
, "Cannot get count of xstats\n");
2062 /* Get id-name lookup table */
2063 struct rte_eth_xstat_name xstats_names
[cnt_xstats
];
2065 if (cnt_xstats
!= rte_eth_xstats_get_names_by_id(
2066 port_id
, xstats_names
, cnt_xstats
, NULL
)) {
2067 RTE_ETHDEV_LOG(ERR
, "Cannot get xstats lookup\n");
2071 for (idx_xstat
= 0; idx_xstat
< cnt_xstats
; idx_xstat
++) {
2072 if (!strcmp(xstats_names
[idx_xstat
].name
, xstat_name
)) {
2081 /* retrieve basic stats names */
2083 rte_eth_basic_stats_get_names(struct rte_eth_dev
*dev
,
2084 struct rte_eth_xstat_name
*xstats_names
)
2086 int cnt_used_entries
= 0;
2087 uint32_t idx
, id_queue
;
2090 for (idx
= 0; idx
< RTE_NB_STATS
; idx
++) {
2091 strlcpy(xstats_names
[cnt_used_entries
].name
,
2092 rte_stats_strings
[idx
].name
,
2093 sizeof(xstats_names
[0].name
));
2096 num_q
= RTE_MIN(dev
->data
->nb_rx_queues
, RTE_ETHDEV_QUEUE_STAT_CNTRS
);
2097 for (id_queue
= 0; id_queue
< num_q
; id_queue
++) {
2098 for (idx
= 0; idx
< RTE_NB_RXQ_STATS
; idx
++) {
2099 snprintf(xstats_names
[cnt_used_entries
].name
,
2100 sizeof(xstats_names
[0].name
),
2102 id_queue
, rte_rxq_stats_strings
[idx
].name
);
2107 num_q
= RTE_MIN(dev
->data
->nb_tx_queues
, RTE_ETHDEV_QUEUE_STAT_CNTRS
);
2108 for (id_queue
= 0; id_queue
< num_q
; id_queue
++) {
2109 for (idx
= 0; idx
< RTE_NB_TXQ_STATS
; idx
++) {
2110 snprintf(xstats_names
[cnt_used_entries
].name
,
2111 sizeof(xstats_names
[0].name
),
2113 id_queue
, rte_txq_stats_strings
[idx
].name
);
2117 return cnt_used_entries
;
2120 /* retrieve ethdev extended statistics names */
2122 rte_eth_xstats_get_names_by_id(uint16_t port_id
,
2123 struct rte_eth_xstat_name
*xstats_names
, unsigned int size
,
2126 struct rte_eth_xstat_name
*xstats_names_copy
;
2127 unsigned int no_basic_stat_requested
= 1;
2128 unsigned int no_ext_stat_requested
= 1;
2129 unsigned int expected_entries
;
2130 unsigned int basic_count
;
2131 struct rte_eth_dev
*dev
;
2135 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
2136 dev
= &rte_eth_devices
[port_id
];
2138 basic_count
= get_xstats_basic_count(dev
);
2139 ret
= get_xstats_count(port_id
);
2142 expected_entries
= (unsigned int)ret
;
2144 /* Return max number of stats if no ids given */
2147 return expected_entries
;
2148 else if (xstats_names
&& size
< expected_entries
)
2149 return expected_entries
;
2152 if (ids
&& !xstats_names
)
2155 if (ids
&& dev
->dev_ops
->xstats_get_names_by_id
!= NULL
&& size
> 0) {
2156 uint64_t ids_copy
[size
];
2158 for (i
= 0; i
< size
; i
++) {
2159 if (ids
[i
] < basic_count
) {
2160 no_basic_stat_requested
= 0;
2165 * Convert ids to xstats ids that PMD knows.
2166 * ids known by user are basic + extended stats.
2168 ids_copy
[i
] = ids
[i
] - basic_count
;
2171 if (no_basic_stat_requested
)
2172 return (*dev
->dev_ops
->xstats_get_names_by_id
)(dev
,
2173 xstats_names
, ids_copy
, size
);
2176 /* Retrieve all stats */
2178 int num_stats
= rte_eth_xstats_get_names(port_id
, xstats_names
,
2180 if (num_stats
< 0 || num_stats
> (int)expected_entries
)
2183 return expected_entries
;
2186 xstats_names_copy
= calloc(expected_entries
,
2187 sizeof(struct rte_eth_xstat_name
));
2189 if (!xstats_names_copy
) {
2190 RTE_ETHDEV_LOG(ERR
, "Can't allocate memory\n");
2195 for (i
= 0; i
< size
; i
++) {
2196 if (ids
[i
] >= basic_count
) {
2197 no_ext_stat_requested
= 0;
2203 /* Fill xstats_names_copy structure */
2204 if (ids
&& no_ext_stat_requested
) {
2205 rte_eth_basic_stats_get_names(dev
, xstats_names_copy
);
2207 ret
= rte_eth_xstats_get_names(port_id
, xstats_names_copy
,
2210 free(xstats_names_copy
);
2216 for (i
= 0; i
< size
; i
++) {
2217 if (ids
[i
] >= expected_entries
) {
2218 RTE_ETHDEV_LOG(ERR
, "Id value isn't valid\n");
2219 free(xstats_names_copy
);
2222 xstats_names
[i
] = xstats_names_copy
[ids
[i
]];
2225 free(xstats_names_copy
);
2230 rte_eth_xstats_get_names(uint16_t port_id
,
2231 struct rte_eth_xstat_name
*xstats_names
,
2234 struct rte_eth_dev
*dev
;
2235 int cnt_used_entries
;
2236 int cnt_expected_entries
;
2237 int cnt_driver_entries
;
2239 cnt_expected_entries
= get_xstats_count(port_id
);
2240 if (xstats_names
== NULL
|| cnt_expected_entries
< 0 ||
2241 (int)size
< cnt_expected_entries
)
2242 return cnt_expected_entries
;
2244 /* port_id checked in get_xstats_count() */
2245 dev
= &rte_eth_devices
[port_id
];
2247 cnt_used_entries
= rte_eth_basic_stats_get_names(
2250 if (dev
->dev_ops
->xstats_get_names
!= NULL
) {
2251 /* If there are any driver-specific xstats, append them
2254 cnt_driver_entries
= (*dev
->dev_ops
->xstats_get_names
)(
2256 xstats_names
+ cnt_used_entries
,
2257 size
- cnt_used_entries
);
2258 if (cnt_driver_entries
< 0)
2259 return eth_err(port_id
, cnt_driver_entries
);
2260 cnt_used_entries
+= cnt_driver_entries
;
2263 return cnt_used_entries
;
2268 rte_eth_basic_stats_get(uint16_t port_id
, struct rte_eth_xstat
*xstats
)
2270 struct rte_eth_dev
*dev
;
2271 struct rte_eth_stats eth_stats
;
2272 unsigned int count
= 0, i
, q
;
2273 uint64_t val
, *stats_ptr
;
2274 uint16_t nb_rxqs
, nb_txqs
;
2277 ret
= rte_eth_stats_get(port_id
, ð_stats
);
2281 dev
= &rte_eth_devices
[port_id
];
2283 nb_rxqs
= RTE_MIN(dev
->data
->nb_rx_queues
, RTE_ETHDEV_QUEUE_STAT_CNTRS
);
2284 nb_txqs
= RTE_MIN(dev
->data
->nb_tx_queues
, RTE_ETHDEV_QUEUE_STAT_CNTRS
);
2287 for (i
= 0; i
< RTE_NB_STATS
; i
++) {
2288 stats_ptr
= RTE_PTR_ADD(ð_stats
,
2289 rte_stats_strings
[i
].offset
);
2291 xstats
[count
++].value
= val
;
2295 for (q
= 0; q
< nb_rxqs
; q
++) {
2296 for (i
= 0; i
< RTE_NB_RXQ_STATS
; i
++) {
2297 stats_ptr
= RTE_PTR_ADD(ð_stats
,
2298 rte_rxq_stats_strings
[i
].offset
+
2299 q
* sizeof(uint64_t));
2301 xstats
[count
++].value
= val
;
2306 for (q
= 0; q
< nb_txqs
; q
++) {
2307 for (i
= 0; i
< RTE_NB_TXQ_STATS
; i
++) {
2308 stats_ptr
= RTE_PTR_ADD(ð_stats
,
2309 rte_txq_stats_strings
[i
].offset
+
2310 q
* sizeof(uint64_t));
2312 xstats
[count
++].value
= val
;
2318 /* retrieve ethdev extended statistics */
2320 rte_eth_xstats_get_by_id(uint16_t port_id
, const uint64_t *ids
,
2321 uint64_t *values
, unsigned int size
)
2323 unsigned int no_basic_stat_requested
= 1;
2324 unsigned int no_ext_stat_requested
= 1;
2325 unsigned int num_xstats_filled
;
2326 unsigned int basic_count
;
2327 uint16_t expected_entries
;
2328 struct rte_eth_dev
*dev
;
2332 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
2333 ret
= get_xstats_count(port_id
);
2336 expected_entries
= (uint16_t)ret
;
2337 struct rte_eth_xstat xstats
[expected_entries
];
2338 dev
= &rte_eth_devices
[port_id
];
2339 basic_count
= get_xstats_basic_count(dev
);
2341 /* Return max number of stats if no ids given */
2344 return expected_entries
;
2345 else if (values
&& size
< expected_entries
)
2346 return expected_entries
;
2352 if (ids
&& dev
->dev_ops
->xstats_get_by_id
!= NULL
&& size
) {
2353 unsigned int basic_count
= get_xstats_basic_count(dev
);
2354 uint64_t ids_copy
[size
];
2356 for (i
= 0; i
< size
; i
++) {
2357 if (ids
[i
] < basic_count
) {
2358 no_basic_stat_requested
= 0;
2363 * Convert ids to xstats ids that PMD knows.
2364 * ids known by user are basic + extended stats.
2366 ids_copy
[i
] = ids
[i
] - basic_count
;
2369 if (no_basic_stat_requested
)
2370 return (*dev
->dev_ops
->xstats_get_by_id
)(dev
, ids_copy
,
2375 for (i
= 0; i
< size
; i
++) {
2376 if (ids
[i
] >= basic_count
) {
2377 no_ext_stat_requested
= 0;
2383 /* Fill the xstats structure */
2384 if (ids
&& no_ext_stat_requested
)
2385 ret
= rte_eth_basic_stats_get(port_id
, xstats
);
2387 ret
= rte_eth_xstats_get(port_id
, xstats
, expected_entries
);
2391 num_xstats_filled
= (unsigned int)ret
;
2393 /* Return all stats */
2395 for (i
= 0; i
< num_xstats_filled
; i
++)
2396 values
[i
] = xstats
[i
].value
;
2397 return expected_entries
;
2401 for (i
= 0; i
< size
; i
++) {
2402 if (ids
[i
] >= expected_entries
) {
2403 RTE_ETHDEV_LOG(ERR
, "Id value isn't valid\n");
2406 values
[i
] = xstats
[ids
[i
]].value
;
2412 rte_eth_xstats_get(uint16_t port_id
, struct rte_eth_xstat
*xstats
,
2415 struct rte_eth_dev
*dev
;
2416 unsigned int count
= 0, i
;
2417 signed int xcount
= 0;
2418 uint16_t nb_rxqs
, nb_txqs
;
2421 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -EINVAL
);
2423 dev
= &rte_eth_devices
[port_id
];
2425 nb_rxqs
= RTE_MIN(dev
->data
->nb_rx_queues
, RTE_ETHDEV_QUEUE_STAT_CNTRS
);
2426 nb_txqs
= RTE_MIN(dev
->data
->nb_tx_queues
, RTE_ETHDEV_QUEUE_STAT_CNTRS
);
2428 /* Return generic statistics */
2429 count
= RTE_NB_STATS
+ (nb_rxqs
* RTE_NB_RXQ_STATS
) +
2430 (nb_txqs
* RTE_NB_TXQ_STATS
);
2432 /* implemented by the driver */
2433 if (dev
->dev_ops
->xstats_get
!= NULL
) {
2434 /* Retrieve the xstats from the driver at the end of the
2437 xcount
= (*dev
->dev_ops
->xstats_get
)(dev
,
2438 xstats
? xstats
+ count
: NULL
,
2439 (n
> count
) ? n
- count
: 0);
2442 return eth_err(port_id
, xcount
);
2445 if (n
< count
+ xcount
|| xstats
== NULL
)
2446 return count
+ xcount
;
2448 /* now fill the xstats structure */
2449 ret
= rte_eth_basic_stats_get(port_id
, xstats
);
2454 for (i
= 0; i
< count
; i
++)
2456 /* add an offset to driver-specific stats */
2457 for ( ; i
< count
+ xcount
; i
++)
2458 xstats
[i
].id
+= count
;
2460 return count
+ xcount
;
2463 /* reset ethdev extended statistics */
2465 rte_eth_xstats_reset(uint16_t port_id
)
2467 struct rte_eth_dev
*dev
;
2469 RTE_ETH_VALID_PORTID_OR_RET(port_id
);
2470 dev
= &rte_eth_devices
[port_id
];
2472 /* implemented by the driver */
2473 if (dev
->dev_ops
->xstats_reset
!= NULL
) {
2474 (*dev
->dev_ops
->xstats_reset
)(dev
);
2478 /* fallback to default */
2479 rte_eth_stats_reset(port_id
);
2483 set_queue_stats_mapping(uint16_t port_id
, uint16_t queue_id
, uint8_t stat_idx
,
2486 struct rte_eth_dev
*dev
;
2488 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
2490 dev
= &rte_eth_devices
[port_id
];
2492 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->queue_stats_mapping_set
, -ENOTSUP
);
2494 if (is_rx
&& (queue_id
>= dev
->data
->nb_rx_queues
))
2497 if (!is_rx
&& (queue_id
>= dev
->data
->nb_tx_queues
))
2500 if (stat_idx
>= RTE_ETHDEV_QUEUE_STAT_CNTRS
)
2503 return (*dev
->dev_ops
->queue_stats_mapping_set
)
2504 (dev
, queue_id
, stat_idx
, is_rx
);
2509 rte_eth_dev_set_tx_queue_stats_mapping(uint16_t port_id
, uint16_t tx_queue_id
,
2512 return eth_err(port_id
, set_queue_stats_mapping(port_id
, tx_queue_id
,
2513 stat_idx
, STAT_QMAP_TX
));
2518 rte_eth_dev_set_rx_queue_stats_mapping(uint16_t port_id
, uint16_t rx_queue_id
,
2521 return eth_err(port_id
, set_queue_stats_mapping(port_id
, rx_queue_id
,
2522 stat_idx
, STAT_QMAP_RX
));
2526 rte_eth_dev_fw_version_get(uint16_t port_id
, char *fw_version
, size_t fw_size
)
2528 struct rte_eth_dev
*dev
;
2530 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
2531 dev
= &rte_eth_devices
[port_id
];
2533 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->fw_version_get
, -ENOTSUP
);
2534 return eth_err(port_id
, (*dev
->dev_ops
->fw_version_get
)(dev
,
2535 fw_version
, fw_size
));
2539 rte_eth_dev_info_get(uint16_t port_id
, struct rte_eth_dev_info
*dev_info
)
2541 struct rte_eth_dev
*dev
;
2542 const struct rte_eth_desc_lim lim
= {
2543 .nb_max
= UINT16_MAX
,
2548 RTE_ETH_VALID_PORTID_OR_RET(port_id
);
2549 dev
= &rte_eth_devices
[port_id
];
2551 memset(dev_info
, 0, sizeof(struct rte_eth_dev_info
));
2552 dev_info
->rx_desc_lim
= lim
;
2553 dev_info
->tx_desc_lim
= lim
;
2554 dev_info
->device
= dev
->device
;
2555 dev_info
->min_mtu
= ETHER_MIN_MTU
;
2556 dev_info
->max_mtu
= UINT16_MAX
;
2558 RTE_FUNC_PTR_OR_RET(*dev
->dev_ops
->dev_infos_get
);
2559 (*dev
->dev_ops
->dev_infos_get
)(dev
, dev_info
);
2560 dev_info
->driver_name
= dev
->device
->driver
->name
;
2561 dev_info
->nb_rx_queues
= dev
->data
->nb_rx_queues
;
2562 dev_info
->nb_tx_queues
= dev
->data
->nb_tx_queues
;
2564 dev_info
->dev_flags
= &dev
->data
->dev_flags
;
2568 rte_eth_dev_get_supported_ptypes(uint16_t port_id
, uint32_t ptype_mask
,
2569 uint32_t *ptypes
, int num
)
2572 struct rte_eth_dev
*dev
;
2573 const uint32_t *all_ptypes
;
2575 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
2576 dev
= &rte_eth_devices
[port_id
];
2577 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->dev_supported_ptypes_get
, 0);
2578 all_ptypes
= (*dev
->dev_ops
->dev_supported_ptypes_get
)(dev
);
2583 for (i
= 0, j
= 0; all_ptypes
[i
] != RTE_PTYPE_UNKNOWN
; ++i
)
2584 if (all_ptypes
[i
] & ptype_mask
) {
2586 ptypes
[j
] = all_ptypes
[i
];
2594 rte_eth_macaddr_get(uint16_t port_id
, struct ether_addr
*mac_addr
)
2596 struct rte_eth_dev
*dev
;
2598 RTE_ETH_VALID_PORTID_OR_RET(port_id
);
2599 dev
= &rte_eth_devices
[port_id
];
2600 ether_addr_copy(&dev
->data
->mac_addrs
[0], mac_addr
);
2605 rte_eth_dev_get_mtu(uint16_t port_id
, uint16_t *mtu
)
2607 struct rte_eth_dev
*dev
;
2609 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
2611 dev
= &rte_eth_devices
[port_id
];
2612 *mtu
= dev
->data
->mtu
;
2617 rte_eth_dev_set_mtu(uint16_t port_id
, uint16_t mtu
)
2620 struct rte_eth_dev_info dev_info
;
2621 struct rte_eth_dev
*dev
;
2623 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
2624 dev
= &rte_eth_devices
[port_id
];
2625 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->mtu_set
, -ENOTSUP
);
2628 * Check if the device supports dev_infos_get, if it does not
2629 * skip min_mtu/max_mtu validation here as this requires values
2630 * that are populated within the call to rte_eth_dev_info_get()
2631 * which relies on dev->dev_ops->dev_infos_get.
2633 if (*dev
->dev_ops
->dev_infos_get
!= NULL
) {
2634 rte_eth_dev_info_get(port_id
, &dev_info
);
2635 if (mtu
< dev_info
.min_mtu
|| mtu
> dev_info
.max_mtu
)
2639 ret
= (*dev
->dev_ops
->mtu_set
)(dev
, mtu
);
2641 dev
->data
->mtu
= mtu
;
2643 return eth_err(port_id
, ret
);
2647 rte_eth_dev_vlan_filter(uint16_t port_id
, uint16_t vlan_id
, int on
)
2649 struct rte_eth_dev
*dev
;
2652 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
2653 dev
= &rte_eth_devices
[port_id
];
2654 if (!(dev
->data
->dev_conf
.rxmode
.offloads
&
2655 DEV_RX_OFFLOAD_VLAN_FILTER
)) {
2656 RTE_ETHDEV_LOG(ERR
, "Port %u: vlan-filtering disabled\n",
2661 if (vlan_id
> 4095) {
2662 RTE_ETHDEV_LOG(ERR
, "Port_id=%u invalid vlan_id=%u > 4095\n",
2666 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->vlan_filter_set
, -ENOTSUP
);
2668 ret
= (*dev
->dev_ops
->vlan_filter_set
)(dev
, vlan_id
, on
);
2670 struct rte_vlan_filter_conf
*vfc
;
2674 vfc
= &dev
->data
->vlan_filter_conf
;
2675 vidx
= vlan_id
/ 64;
2676 vbit
= vlan_id
% 64;
2679 vfc
->ids
[vidx
] |= UINT64_C(1) << vbit
;
2681 vfc
->ids
[vidx
] &= ~(UINT64_C(1) << vbit
);
2684 return eth_err(port_id
, ret
);
2688 rte_eth_dev_set_vlan_strip_on_queue(uint16_t port_id
, uint16_t rx_queue_id
,
2691 struct rte_eth_dev
*dev
;
2693 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
2694 dev
= &rte_eth_devices
[port_id
];
2695 if (rx_queue_id
>= dev
->data
->nb_rx_queues
) {
2696 RTE_ETHDEV_LOG(ERR
, "Invalid rx_queue_id=%u\n", rx_queue_id
);
2700 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->vlan_strip_queue_set
, -ENOTSUP
);
2701 (*dev
->dev_ops
->vlan_strip_queue_set
)(dev
, rx_queue_id
, on
);
2707 rte_eth_dev_set_vlan_ether_type(uint16_t port_id
,
2708 enum rte_vlan_type vlan_type
,
2711 struct rte_eth_dev
*dev
;
2713 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
2714 dev
= &rte_eth_devices
[port_id
];
2715 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->vlan_tpid_set
, -ENOTSUP
);
2717 return eth_err(port_id
, (*dev
->dev_ops
->vlan_tpid_set
)(dev
, vlan_type
,
2722 rte_eth_dev_set_vlan_offload(uint16_t port_id
, int offload_mask
)
2724 struct rte_eth_dev
*dev
;
2728 uint64_t orig_offloads
;
2730 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
2731 dev
= &rte_eth_devices
[port_id
];
2733 /* save original values in case of failure */
2734 orig_offloads
= dev
->data
->dev_conf
.rxmode
.offloads
;
2736 /*check which option changed by application*/
2737 cur
= !!(offload_mask
& ETH_VLAN_STRIP_OFFLOAD
);
2738 org
= !!(dev
->data
->dev_conf
.rxmode
.offloads
&
2739 DEV_RX_OFFLOAD_VLAN_STRIP
);
2742 dev
->data
->dev_conf
.rxmode
.offloads
|=
2743 DEV_RX_OFFLOAD_VLAN_STRIP
;
2745 dev
->data
->dev_conf
.rxmode
.offloads
&=
2746 ~DEV_RX_OFFLOAD_VLAN_STRIP
;
2747 mask
|= ETH_VLAN_STRIP_MASK
;
2750 cur
= !!(offload_mask
& ETH_VLAN_FILTER_OFFLOAD
);
2751 org
= !!(dev
->data
->dev_conf
.rxmode
.offloads
&
2752 DEV_RX_OFFLOAD_VLAN_FILTER
);
2755 dev
->data
->dev_conf
.rxmode
.offloads
|=
2756 DEV_RX_OFFLOAD_VLAN_FILTER
;
2758 dev
->data
->dev_conf
.rxmode
.offloads
&=
2759 ~DEV_RX_OFFLOAD_VLAN_FILTER
;
2760 mask
|= ETH_VLAN_FILTER_MASK
;
2763 cur
= !!(offload_mask
& ETH_VLAN_EXTEND_OFFLOAD
);
2764 org
= !!(dev
->data
->dev_conf
.rxmode
.offloads
&
2765 DEV_RX_OFFLOAD_VLAN_EXTEND
);
2768 dev
->data
->dev_conf
.rxmode
.offloads
|=
2769 DEV_RX_OFFLOAD_VLAN_EXTEND
;
2771 dev
->data
->dev_conf
.rxmode
.offloads
&=
2772 ~DEV_RX_OFFLOAD_VLAN_EXTEND
;
2773 mask
|= ETH_VLAN_EXTEND_MASK
;
2780 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->vlan_offload_set
, -ENOTSUP
);
2781 ret
= (*dev
->dev_ops
->vlan_offload_set
)(dev
, mask
);
2783 /* hit an error restore original values */
2784 dev
->data
->dev_conf
.rxmode
.offloads
= orig_offloads
;
2787 return eth_err(port_id
, ret
);
2791 rte_eth_dev_get_vlan_offload(uint16_t port_id
)
2793 struct rte_eth_dev
*dev
;
2796 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
2797 dev
= &rte_eth_devices
[port_id
];
2799 if (dev
->data
->dev_conf
.rxmode
.offloads
&
2800 DEV_RX_OFFLOAD_VLAN_STRIP
)
2801 ret
|= ETH_VLAN_STRIP_OFFLOAD
;
2803 if (dev
->data
->dev_conf
.rxmode
.offloads
&
2804 DEV_RX_OFFLOAD_VLAN_FILTER
)
2805 ret
|= ETH_VLAN_FILTER_OFFLOAD
;
2807 if (dev
->data
->dev_conf
.rxmode
.offloads
&
2808 DEV_RX_OFFLOAD_VLAN_EXTEND
)
2809 ret
|= ETH_VLAN_EXTEND_OFFLOAD
;
2815 rte_eth_dev_set_vlan_pvid(uint16_t port_id
, uint16_t pvid
, int on
)
2817 struct rte_eth_dev
*dev
;
2819 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
2820 dev
= &rte_eth_devices
[port_id
];
2821 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->vlan_pvid_set
, -ENOTSUP
);
2823 return eth_err(port_id
, (*dev
->dev_ops
->vlan_pvid_set
)(dev
, pvid
, on
));
2827 rte_eth_dev_flow_ctrl_get(uint16_t port_id
, struct rte_eth_fc_conf
*fc_conf
)
2829 struct rte_eth_dev
*dev
;
2831 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
2832 dev
= &rte_eth_devices
[port_id
];
2833 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->flow_ctrl_get
, -ENOTSUP
);
2834 memset(fc_conf
, 0, sizeof(*fc_conf
));
2835 return eth_err(port_id
, (*dev
->dev_ops
->flow_ctrl_get
)(dev
, fc_conf
));
2839 rte_eth_dev_flow_ctrl_set(uint16_t port_id
, struct rte_eth_fc_conf
*fc_conf
)
2841 struct rte_eth_dev
*dev
;
2843 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
2844 if ((fc_conf
->send_xon
!= 0) && (fc_conf
->send_xon
!= 1)) {
2845 RTE_ETHDEV_LOG(ERR
, "Invalid send_xon, only 0/1 allowed\n");
2849 dev
= &rte_eth_devices
[port_id
];
2850 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->flow_ctrl_set
, -ENOTSUP
);
2851 return eth_err(port_id
, (*dev
->dev_ops
->flow_ctrl_set
)(dev
, fc_conf
));
2855 rte_eth_dev_priority_flow_ctrl_set(uint16_t port_id
,
2856 struct rte_eth_pfc_conf
*pfc_conf
)
2858 struct rte_eth_dev
*dev
;
2860 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
2861 if (pfc_conf
->priority
> (ETH_DCB_NUM_USER_PRIORITIES
- 1)) {
2862 RTE_ETHDEV_LOG(ERR
, "Invalid priority, only 0-7 allowed\n");
2866 dev
= &rte_eth_devices
[port_id
];
2867 /* High water, low water validation are device specific */
2868 if (*dev
->dev_ops
->priority_flow_ctrl_set
)
2869 return eth_err(port_id
, (*dev
->dev_ops
->priority_flow_ctrl_set
)
2875 rte_eth_check_reta_mask(struct rte_eth_rss_reta_entry64
*reta_conf
,
2883 num
= (reta_size
+ RTE_RETA_GROUP_SIZE
- 1) / RTE_RETA_GROUP_SIZE
;
2884 for (i
= 0; i
< num
; i
++) {
2885 if (reta_conf
[i
].mask
)
2893 rte_eth_check_reta_entry(struct rte_eth_rss_reta_entry64
*reta_conf
,
2897 uint16_t i
, idx
, shift
;
2903 RTE_ETHDEV_LOG(ERR
, "No receive queue is available\n");
2907 for (i
= 0; i
< reta_size
; i
++) {
2908 idx
= i
/ RTE_RETA_GROUP_SIZE
;
2909 shift
= i
% RTE_RETA_GROUP_SIZE
;
2910 if ((reta_conf
[idx
].mask
& (1ULL << shift
)) &&
2911 (reta_conf
[idx
].reta
[shift
] >= max_rxq
)) {
2913 "reta_conf[%u]->reta[%u]: %u exceeds the maximum rxq index: %u\n",
2915 reta_conf
[idx
].reta
[shift
], max_rxq
);
2924 rte_eth_dev_rss_reta_update(uint16_t port_id
,
2925 struct rte_eth_rss_reta_entry64
*reta_conf
,
2928 struct rte_eth_dev
*dev
;
2931 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
2932 /* Check mask bits */
2933 ret
= rte_eth_check_reta_mask(reta_conf
, reta_size
);
2937 dev
= &rte_eth_devices
[port_id
];
2939 /* Check entry value */
2940 ret
= rte_eth_check_reta_entry(reta_conf
, reta_size
,
2941 dev
->data
->nb_rx_queues
);
2945 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->reta_update
, -ENOTSUP
);
2946 return eth_err(port_id
, (*dev
->dev_ops
->reta_update
)(dev
, reta_conf
,
2951 rte_eth_dev_rss_reta_query(uint16_t port_id
,
2952 struct rte_eth_rss_reta_entry64
*reta_conf
,
2955 struct rte_eth_dev
*dev
;
2958 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
2960 /* Check mask bits */
2961 ret
= rte_eth_check_reta_mask(reta_conf
, reta_size
);
2965 dev
= &rte_eth_devices
[port_id
];
2966 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->reta_query
, -ENOTSUP
);
2967 return eth_err(port_id
, (*dev
->dev_ops
->reta_query
)(dev
, reta_conf
,
2972 rte_eth_dev_rss_hash_update(uint16_t port_id
,
2973 struct rte_eth_rss_conf
*rss_conf
)
2975 struct rte_eth_dev
*dev
;
2976 struct rte_eth_dev_info dev_info
= { .flow_type_rss_offloads
= 0, };
2978 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
2979 dev
= &rte_eth_devices
[port_id
];
2980 rte_eth_dev_info_get(port_id
, &dev_info
);
2981 if ((dev_info
.flow_type_rss_offloads
| rss_conf
->rss_hf
) !=
2982 dev_info
.flow_type_rss_offloads
) {
2984 "Ethdev port_id=%u invalid rss_hf: 0x%"PRIx64
", valid value: 0x%"PRIx64
"\n",
2985 port_id
, rss_conf
->rss_hf
,
2986 dev_info
.flow_type_rss_offloads
);
2989 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->rss_hash_update
, -ENOTSUP
);
2990 return eth_err(port_id
, (*dev
->dev_ops
->rss_hash_update
)(dev
,
2995 rte_eth_dev_rss_hash_conf_get(uint16_t port_id
,
2996 struct rte_eth_rss_conf
*rss_conf
)
2998 struct rte_eth_dev
*dev
;
3000 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
3001 dev
= &rte_eth_devices
[port_id
];
3002 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->rss_hash_conf_get
, -ENOTSUP
);
3003 return eth_err(port_id
, (*dev
->dev_ops
->rss_hash_conf_get
)(dev
,
3008 rte_eth_dev_udp_tunnel_port_add(uint16_t port_id
,
3009 struct rte_eth_udp_tunnel
*udp_tunnel
)
3011 struct rte_eth_dev
*dev
;
3013 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
3014 if (udp_tunnel
== NULL
) {
3015 RTE_ETHDEV_LOG(ERR
, "Invalid udp_tunnel parameter\n");
3019 if (udp_tunnel
->prot_type
>= RTE_TUNNEL_TYPE_MAX
) {
3020 RTE_ETHDEV_LOG(ERR
, "Invalid tunnel type\n");
3024 dev
= &rte_eth_devices
[port_id
];
3025 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->udp_tunnel_port_add
, -ENOTSUP
);
3026 return eth_err(port_id
, (*dev
->dev_ops
->udp_tunnel_port_add
)(dev
,
3031 rte_eth_dev_udp_tunnel_port_delete(uint16_t port_id
,
3032 struct rte_eth_udp_tunnel
*udp_tunnel
)
3034 struct rte_eth_dev
*dev
;
3036 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
3037 dev
= &rte_eth_devices
[port_id
];
3039 if (udp_tunnel
== NULL
) {
3040 RTE_ETHDEV_LOG(ERR
, "Invalid udp_tunnel parameter\n");
3044 if (udp_tunnel
->prot_type
>= RTE_TUNNEL_TYPE_MAX
) {
3045 RTE_ETHDEV_LOG(ERR
, "Invalid tunnel type\n");
3049 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->udp_tunnel_port_del
, -ENOTSUP
);
3050 return eth_err(port_id
, (*dev
->dev_ops
->udp_tunnel_port_del
)(dev
,
3055 rte_eth_led_on(uint16_t port_id
)
3057 struct rte_eth_dev
*dev
;
3059 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
3060 dev
= &rte_eth_devices
[port_id
];
3061 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->dev_led_on
, -ENOTSUP
);
3062 return eth_err(port_id
, (*dev
->dev_ops
->dev_led_on
)(dev
));
3066 rte_eth_led_off(uint16_t port_id
)
3068 struct rte_eth_dev
*dev
;
3070 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
3071 dev
= &rte_eth_devices
[port_id
];
3072 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->dev_led_off
, -ENOTSUP
);
3073 return eth_err(port_id
, (*dev
->dev_ops
->dev_led_off
)(dev
));
3077 * Returns index into MAC address array of addr. Use 00:00:00:00:00:00 to find
3081 get_mac_addr_index(uint16_t port_id
, const struct ether_addr
*addr
)
3083 struct rte_eth_dev_info dev_info
;
3084 struct rte_eth_dev
*dev
= &rte_eth_devices
[port_id
];
3087 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
3088 rte_eth_dev_info_get(port_id
, &dev_info
);
3090 for (i
= 0; i
< dev_info
.max_mac_addrs
; i
++)
3091 if (memcmp(addr
, &dev
->data
->mac_addrs
[i
], ETHER_ADDR_LEN
) == 0)
3097 static const struct ether_addr null_mac_addr
;
3100 rte_eth_dev_mac_addr_add(uint16_t port_id
, struct ether_addr
*addr
,
3103 struct rte_eth_dev
*dev
;
3108 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
3109 dev
= &rte_eth_devices
[port_id
];
3110 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->mac_addr_add
, -ENOTSUP
);
3112 if (is_zero_ether_addr(addr
)) {
3113 RTE_ETHDEV_LOG(ERR
, "Port %u: Cannot add NULL MAC address\n",
3117 if (pool
>= ETH_64_POOLS
) {
3118 RTE_ETHDEV_LOG(ERR
, "Pool id must be 0-%d\n", ETH_64_POOLS
- 1);
3122 index
= get_mac_addr_index(port_id
, addr
);
3124 index
= get_mac_addr_index(port_id
, &null_mac_addr
);
3126 RTE_ETHDEV_LOG(ERR
, "Port %u: MAC address array full\n",
3131 pool_mask
= dev
->data
->mac_pool_sel
[index
];
3133 /* Check if both MAC address and pool is already there, and do nothing */
3134 if (pool_mask
& (1ULL << pool
))
3139 ret
= (*dev
->dev_ops
->mac_addr_add
)(dev
, addr
, index
, pool
);
3142 /* Update address in NIC data structure */
3143 ether_addr_copy(addr
, &dev
->data
->mac_addrs
[index
]);
3145 /* Update pool bitmap in NIC data structure */
3146 dev
->data
->mac_pool_sel
[index
] |= (1ULL << pool
);
3149 return eth_err(port_id
, ret
);
3153 rte_eth_dev_mac_addr_remove(uint16_t port_id
, struct ether_addr
*addr
)
3155 struct rte_eth_dev
*dev
;
3158 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
3159 dev
= &rte_eth_devices
[port_id
];
3160 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->mac_addr_remove
, -ENOTSUP
);
3162 index
= get_mac_addr_index(port_id
, addr
);
3165 "Port %u: Cannot remove default MAC address\n",
3168 } else if (index
< 0)
3169 return 0; /* Do nothing if address wasn't found */
3172 (*dev
->dev_ops
->mac_addr_remove
)(dev
, index
);
3174 /* Update address in NIC data structure */
3175 ether_addr_copy(&null_mac_addr
, &dev
->data
->mac_addrs
[index
]);
3177 /* reset pool bitmap */
3178 dev
->data
->mac_pool_sel
[index
] = 0;
3184 rte_eth_dev_default_mac_addr_set(uint16_t port_id
, struct ether_addr
*addr
)
3186 struct rte_eth_dev
*dev
;
3189 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
3191 if (!is_valid_assigned_ether_addr(addr
))
3194 dev
= &rte_eth_devices
[port_id
];
3195 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->mac_addr_set
, -ENOTSUP
);
3197 ret
= (*dev
->dev_ops
->mac_addr_set
)(dev
, addr
);
3201 /* Update default address in NIC data structure */
3202 ether_addr_copy(addr
, &dev
->data
->mac_addrs
[0]);
3209 * Returns index into MAC address array of addr. Use 00:00:00:00:00:00 to find
3213 get_hash_mac_addr_index(uint16_t port_id
, const struct ether_addr
*addr
)
3215 struct rte_eth_dev_info dev_info
;
3216 struct rte_eth_dev
*dev
= &rte_eth_devices
[port_id
];
3219 rte_eth_dev_info_get(port_id
, &dev_info
);
3220 if (!dev
->data
->hash_mac_addrs
)
3223 for (i
= 0; i
< dev_info
.max_hash_mac_addrs
; i
++)
3224 if (memcmp(addr
, &dev
->data
->hash_mac_addrs
[i
],
3225 ETHER_ADDR_LEN
) == 0)
3232 rte_eth_dev_uc_hash_table_set(uint16_t port_id
, struct ether_addr
*addr
,
3237 struct rte_eth_dev
*dev
;
3239 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
3241 dev
= &rte_eth_devices
[port_id
];
3242 if (is_zero_ether_addr(addr
)) {
3243 RTE_ETHDEV_LOG(ERR
, "Port %u: Cannot add NULL MAC address\n",
3248 index
= get_hash_mac_addr_index(port_id
, addr
);
3249 /* Check if it's already there, and do nothing */
3250 if ((index
>= 0) && on
)
3256 "Port %u: the MAC address was not set in UTA\n",
3261 index
= get_hash_mac_addr_index(port_id
, &null_mac_addr
);
3263 RTE_ETHDEV_LOG(ERR
, "Port %u: MAC address array full\n",
3269 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->uc_hash_table_set
, -ENOTSUP
);
3270 ret
= (*dev
->dev_ops
->uc_hash_table_set
)(dev
, addr
, on
);
3272 /* Update address in NIC data structure */
3274 ether_addr_copy(addr
,
3275 &dev
->data
->hash_mac_addrs
[index
]);
3277 ether_addr_copy(&null_mac_addr
,
3278 &dev
->data
->hash_mac_addrs
[index
]);
3281 return eth_err(port_id
, ret
);
3285 rte_eth_dev_uc_all_hash_table_set(uint16_t port_id
, uint8_t on
)
3287 struct rte_eth_dev
*dev
;
3289 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
3291 dev
= &rte_eth_devices
[port_id
];
3293 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->uc_all_hash_table_set
, -ENOTSUP
);
3294 return eth_err(port_id
, (*dev
->dev_ops
->uc_all_hash_table_set
)(dev
,
3298 int rte_eth_set_queue_rate_limit(uint16_t port_id
, uint16_t queue_idx
,
3301 struct rte_eth_dev
*dev
;
3302 struct rte_eth_dev_info dev_info
;
3303 struct rte_eth_link link
;
3305 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
3307 dev
= &rte_eth_devices
[port_id
];
3308 rte_eth_dev_info_get(port_id
, &dev_info
);
3309 link
= dev
->data
->dev_link
;
3311 if (queue_idx
> dev_info
.max_tx_queues
) {
3313 "Set queue rate limit:port %u: invalid queue id=%u\n",
3314 port_id
, queue_idx
);
3318 if (tx_rate
> link
.link_speed
) {
3320 "Set queue rate limit:invalid tx_rate=%u, bigger than link speed= %d\n",
3321 tx_rate
, link
.link_speed
);
3325 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->set_queue_rate_limit
, -ENOTSUP
);
3326 return eth_err(port_id
, (*dev
->dev_ops
->set_queue_rate_limit
)(dev
,
3327 queue_idx
, tx_rate
));
3331 rte_eth_mirror_rule_set(uint16_t port_id
,
3332 struct rte_eth_mirror_conf
*mirror_conf
,
3333 uint8_t rule_id
, uint8_t on
)
3335 struct rte_eth_dev
*dev
;
3337 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
3338 if (mirror_conf
->rule_type
== 0) {
3339 RTE_ETHDEV_LOG(ERR
, "Mirror rule type can not be 0\n");
3343 if (mirror_conf
->dst_pool
>= ETH_64_POOLS
) {
3344 RTE_ETHDEV_LOG(ERR
, "Invalid dst pool, pool id must be 0-%d\n",
3349 if ((mirror_conf
->rule_type
& (ETH_MIRROR_VIRTUAL_POOL_UP
|
3350 ETH_MIRROR_VIRTUAL_POOL_DOWN
)) &&
3351 (mirror_conf
->pool_mask
== 0)) {
3353 "Invalid mirror pool, pool mask can not be 0\n");
3357 if ((mirror_conf
->rule_type
& ETH_MIRROR_VLAN
) &&
3358 mirror_conf
->vlan
.vlan_mask
== 0) {
3360 "Invalid vlan mask, vlan mask can not be 0\n");
3364 dev
= &rte_eth_devices
[port_id
];
3365 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->mirror_rule_set
, -ENOTSUP
);
3367 return eth_err(port_id
, (*dev
->dev_ops
->mirror_rule_set
)(dev
,
3368 mirror_conf
, rule_id
, on
));
3372 rte_eth_mirror_rule_reset(uint16_t port_id
, uint8_t rule_id
)
3374 struct rte_eth_dev
*dev
;
3376 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
3378 dev
= &rte_eth_devices
[port_id
];
3379 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->mirror_rule_reset
, -ENOTSUP
);
3381 return eth_err(port_id
, (*dev
->dev_ops
->mirror_rule_reset
)(dev
,
3385 RTE_INIT(eth_dev_init_cb_lists
)
3389 for (i
= 0; i
< RTE_MAX_ETHPORTS
; i
++)
3390 TAILQ_INIT(&rte_eth_devices
[i
].link_intr_cbs
);
3394 rte_eth_dev_callback_register(uint16_t port_id
,
3395 enum rte_eth_event_type event
,
3396 rte_eth_dev_cb_fn cb_fn
, void *cb_arg
)
3398 struct rte_eth_dev
*dev
;
3399 struct rte_eth_dev_callback
*user_cb
;
3400 uint32_t next_port
; /* size is 32-bit to prevent loop wrap-around */
3406 if (!rte_eth_dev_is_valid_port(port_id
) && port_id
!= RTE_ETH_ALL
) {
3407 RTE_ETHDEV_LOG(ERR
, "Invalid port_id=%d\n", port_id
);
3411 if (port_id
== RTE_ETH_ALL
) {
3413 last_port
= RTE_MAX_ETHPORTS
- 1;
3415 next_port
= last_port
= port_id
;
3418 rte_spinlock_lock(&rte_eth_dev_cb_lock
);
3421 dev
= &rte_eth_devices
[next_port
];
3423 TAILQ_FOREACH(user_cb
, &(dev
->link_intr_cbs
), next
) {
3424 if (user_cb
->cb_fn
== cb_fn
&&
3425 user_cb
->cb_arg
== cb_arg
&&
3426 user_cb
->event
== event
) {
3431 /* create a new callback. */
3432 if (user_cb
== NULL
) {
3433 user_cb
= rte_zmalloc("INTR_USER_CALLBACK",
3434 sizeof(struct rte_eth_dev_callback
), 0);
3435 if (user_cb
!= NULL
) {
3436 user_cb
->cb_fn
= cb_fn
;
3437 user_cb
->cb_arg
= cb_arg
;
3438 user_cb
->event
= event
;
3439 TAILQ_INSERT_TAIL(&(dev
->link_intr_cbs
),
3442 rte_spinlock_unlock(&rte_eth_dev_cb_lock
);
3443 rte_eth_dev_callback_unregister(port_id
, event
,
3449 } while (++next_port
<= last_port
);
3451 rte_spinlock_unlock(&rte_eth_dev_cb_lock
);
3456 rte_eth_dev_callback_unregister(uint16_t port_id
,
3457 enum rte_eth_event_type event
,
3458 rte_eth_dev_cb_fn cb_fn
, void *cb_arg
)
3461 struct rte_eth_dev
*dev
;
3462 struct rte_eth_dev_callback
*cb
, *next
;
3463 uint32_t next_port
; /* size is 32-bit to prevent loop wrap-around */
3469 if (!rte_eth_dev_is_valid_port(port_id
) && port_id
!= RTE_ETH_ALL
) {
3470 RTE_ETHDEV_LOG(ERR
, "Invalid port_id=%d\n", port_id
);
3474 if (port_id
== RTE_ETH_ALL
) {
3476 last_port
= RTE_MAX_ETHPORTS
- 1;
3478 next_port
= last_port
= port_id
;
3481 rte_spinlock_lock(&rte_eth_dev_cb_lock
);
3484 dev
= &rte_eth_devices
[next_port
];
3486 for (cb
= TAILQ_FIRST(&dev
->link_intr_cbs
); cb
!= NULL
;
3489 next
= TAILQ_NEXT(cb
, next
);
3491 if (cb
->cb_fn
!= cb_fn
|| cb
->event
!= event
||
3492 (cb
->cb_arg
!= (void *)-1 && cb
->cb_arg
!= cb_arg
))
3496 * if this callback is not executing right now,
3499 if (cb
->active
== 0) {
3500 TAILQ_REMOVE(&(dev
->link_intr_cbs
), cb
, next
);
3506 } while (++next_port
<= last_port
);
3508 rte_spinlock_unlock(&rte_eth_dev_cb_lock
);
3513 _rte_eth_dev_callback_process(struct rte_eth_dev
*dev
,
3514 enum rte_eth_event_type event
, void *ret_param
)
3516 struct rte_eth_dev_callback
*cb_lst
;
3517 struct rte_eth_dev_callback dev_cb
;
3520 rte_spinlock_lock(&rte_eth_dev_cb_lock
);
3521 TAILQ_FOREACH(cb_lst
, &(dev
->link_intr_cbs
), next
) {
3522 if (cb_lst
->cb_fn
== NULL
|| cb_lst
->event
!= event
)
3526 if (ret_param
!= NULL
)
3527 dev_cb
.ret_param
= ret_param
;
3529 rte_spinlock_unlock(&rte_eth_dev_cb_lock
);
3530 rc
= dev_cb
.cb_fn(dev
->data
->port_id
, dev_cb
.event
,
3531 dev_cb
.cb_arg
, dev_cb
.ret_param
);
3532 rte_spinlock_lock(&rte_eth_dev_cb_lock
);
3535 rte_spinlock_unlock(&rte_eth_dev_cb_lock
);
3540 rte_eth_dev_probing_finish(struct rte_eth_dev
*dev
)
3545 _rte_eth_dev_callback_process(dev
, RTE_ETH_EVENT_NEW
, NULL
);
3547 dev
->state
= RTE_ETH_DEV_ATTACHED
;
3551 rte_eth_dev_rx_intr_ctl(uint16_t port_id
, int epfd
, int op
, void *data
)
3554 struct rte_eth_dev
*dev
;
3555 struct rte_intr_handle
*intr_handle
;
3559 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
3561 dev
= &rte_eth_devices
[port_id
];
3563 if (!dev
->intr_handle
) {
3564 RTE_ETHDEV_LOG(ERR
, "RX Intr handle unset\n");
3568 intr_handle
= dev
->intr_handle
;
3569 if (!intr_handle
->intr_vec
) {
3570 RTE_ETHDEV_LOG(ERR
, "RX Intr vector unset\n");
3574 for (qid
= 0; qid
< dev
->data
->nb_rx_queues
; qid
++) {
3575 vec
= intr_handle
->intr_vec
[qid
];
3576 rc
= rte_intr_rx_ctl(intr_handle
, epfd
, op
, vec
, data
);
3577 if (rc
&& rc
!= -EEXIST
) {
3579 "p %u q %u rx ctl error op %d epfd %d vec %u\n",
3580 port_id
, qid
, op
, epfd
, vec
);
3587 int __rte_experimental
3588 rte_eth_dev_rx_intr_ctl_q_get_fd(uint16_t port_id
, uint16_t queue_id
)
3590 struct rte_intr_handle
*intr_handle
;
3591 struct rte_eth_dev
*dev
;
3592 unsigned int efd_idx
;
3596 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -1);
3598 dev
= &rte_eth_devices
[port_id
];
3600 if (queue_id
>= dev
->data
->nb_rx_queues
) {
3601 RTE_ETHDEV_LOG(ERR
, "Invalid RX queue_id=%u\n", queue_id
);
3605 if (!dev
->intr_handle
) {
3606 RTE_ETHDEV_LOG(ERR
, "RX Intr handle unset\n");
3610 intr_handle
= dev
->intr_handle
;
3611 if (!intr_handle
->intr_vec
) {
3612 RTE_ETHDEV_LOG(ERR
, "RX Intr vector unset\n");
3616 vec
= intr_handle
->intr_vec
[queue_id
];
3617 efd_idx
= (vec
>= RTE_INTR_VEC_RXTX_OFFSET
) ?
3618 (vec
- RTE_INTR_VEC_RXTX_OFFSET
) : vec
;
3619 fd
= intr_handle
->efds
[efd_idx
];
3624 const struct rte_memzone
*
3625 rte_eth_dma_zone_reserve(const struct rte_eth_dev
*dev
, const char *ring_name
,
3626 uint16_t queue_id
, size_t size
, unsigned align
,
3629 char z_name
[RTE_MEMZONE_NAMESIZE
];
3630 const struct rte_memzone
*mz
;
3633 rc
= snprintf(z_name
, sizeof(z_name
), "eth_p%d_q%d_%s",
3634 dev
->data
->port_id
, queue_id
, ring_name
);
3635 if (rc
>= RTE_MEMZONE_NAMESIZE
) {
3636 RTE_ETHDEV_LOG(ERR
, "ring name too long\n");
3637 rte_errno
= ENAMETOOLONG
;
3641 mz
= rte_memzone_lookup(z_name
);
3645 return rte_memzone_reserve_aligned(z_name
, size
, socket_id
,
3646 RTE_MEMZONE_IOVA_CONTIG
, align
);
3649 int __rte_experimental
3650 rte_eth_dev_create(struct rte_device
*device
, const char *name
,
3651 size_t priv_data_size
,
3652 ethdev_bus_specific_init ethdev_bus_specific_init
,
3653 void *bus_init_params
,
3654 ethdev_init_t ethdev_init
, void *init_params
)
3656 struct rte_eth_dev
*ethdev
;
3659 RTE_FUNC_PTR_OR_ERR_RET(*ethdev_init
, -EINVAL
);
3661 if (rte_eal_process_type() == RTE_PROC_PRIMARY
) {
3662 ethdev
= rte_eth_dev_allocate(name
);
3666 if (priv_data_size
) {
3667 ethdev
->data
->dev_private
= rte_zmalloc_socket(
3668 name
, priv_data_size
, RTE_CACHE_LINE_SIZE
,
3671 if (!ethdev
->data
->dev_private
) {
3672 RTE_LOG(ERR
, EAL
, "failed to allocate private data");
3678 ethdev
= rte_eth_dev_attach_secondary(name
);
3680 RTE_LOG(ERR
, EAL
, "secondary process attach failed, "
3681 "ethdev doesn't exist");
3686 ethdev
->device
= device
;
3688 if (ethdev_bus_specific_init
) {
3689 retval
= ethdev_bus_specific_init(ethdev
, bus_init_params
);
3692 "ethdev bus specific initialisation failed");
3697 retval
= ethdev_init(ethdev
, init_params
);
3699 RTE_LOG(ERR
, EAL
, "ethdev initialisation failed");
3703 rte_eth_dev_probing_finish(ethdev
);
3708 rte_eth_dev_release_port(ethdev
);
3712 int __rte_experimental
3713 rte_eth_dev_destroy(struct rte_eth_dev
*ethdev
,
3714 ethdev_uninit_t ethdev_uninit
)
3718 ethdev
= rte_eth_dev_allocated(ethdev
->data
->name
);
3722 RTE_FUNC_PTR_OR_ERR_RET(*ethdev_uninit
, -EINVAL
);
3724 ret
= ethdev_uninit(ethdev
);
3728 return rte_eth_dev_release_port(ethdev
);
3732 rte_eth_dev_rx_intr_ctl_q(uint16_t port_id
, uint16_t queue_id
,
3733 int epfd
, int op
, void *data
)
3736 struct rte_eth_dev
*dev
;
3737 struct rte_intr_handle
*intr_handle
;
3740 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
3742 dev
= &rte_eth_devices
[port_id
];
3743 if (queue_id
>= dev
->data
->nb_rx_queues
) {
3744 RTE_ETHDEV_LOG(ERR
, "Invalid RX queue_id=%u\n", queue_id
);
3748 if (!dev
->intr_handle
) {
3749 RTE_ETHDEV_LOG(ERR
, "RX Intr handle unset\n");
3753 intr_handle
= dev
->intr_handle
;
3754 if (!intr_handle
->intr_vec
) {
3755 RTE_ETHDEV_LOG(ERR
, "RX Intr vector unset\n");
3759 vec
= intr_handle
->intr_vec
[queue_id
];
3760 rc
= rte_intr_rx_ctl(intr_handle
, epfd
, op
, vec
, data
);
3761 if (rc
&& rc
!= -EEXIST
) {
3763 "p %u q %u rx ctl error op %d epfd %d vec %u\n",
3764 port_id
, queue_id
, op
, epfd
, vec
);
3772 rte_eth_dev_rx_intr_enable(uint16_t port_id
,
3775 struct rte_eth_dev
*dev
;
3777 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
3779 dev
= &rte_eth_devices
[port_id
];
3781 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->rx_queue_intr_enable
, -ENOTSUP
);
3782 return eth_err(port_id
, (*dev
->dev_ops
->rx_queue_intr_enable
)(dev
,
3787 rte_eth_dev_rx_intr_disable(uint16_t port_id
,
3790 struct rte_eth_dev
*dev
;
3792 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
3794 dev
= &rte_eth_devices
[port_id
];
3796 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->rx_queue_intr_disable
, -ENOTSUP
);
3797 return eth_err(port_id
, (*dev
->dev_ops
->rx_queue_intr_disable
)(dev
,
3803 rte_eth_dev_filter_supported(uint16_t port_id
,
3804 enum rte_filter_type filter_type
)
3806 struct rte_eth_dev
*dev
;
3808 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
3810 dev
= &rte_eth_devices
[port_id
];
3811 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->filter_ctrl
, -ENOTSUP
);
3812 return (*dev
->dev_ops
->filter_ctrl
)(dev
, filter_type
,
3813 RTE_ETH_FILTER_NOP
, NULL
);
3817 rte_eth_dev_filter_ctrl(uint16_t port_id
, enum rte_filter_type filter_type
,
3818 enum rte_filter_op filter_op
, void *arg
)
3820 struct rte_eth_dev
*dev
;
3822 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
3824 dev
= &rte_eth_devices
[port_id
];
3825 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->filter_ctrl
, -ENOTSUP
);
3826 return eth_err(port_id
, (*dev
->dev_ops
->filter_ctrl
)(dev
, filter_type
,
3830 const struct rte_eth_rxtx_callback
*
3831 rte_eth_add_rx_callback(uint16_t port_id
, uint16_t queue_id
,
3832 rte_rx_callback_fn fn
, void *user_param
)
3834 #ifndef RTE_ETHDEV_RXTX_CALLBACKS
3835 rte_errno
= ENOTSUP
;
3838 /* check input parameters */
3839 if (!rte_eth_dev_is_valid_port(port_id
) || fn
== NULL
||
3840 queue_id
>= rte_eth_devices
[port_id
].data
->nb_rx_queues
) {
3844 struct rte_eth_rxtx_callback
*cb
= rte_zmalloc(NULL
, sizeof(*cb
), 0);
3852 cb
->param
= user_param
;
3854 rte_spinlock_lock(&rte_eth_rx_cb_lock
);
3855 /* Add the callbacks in fifo order. */
3856 struct rte_eth_rxtx_callback
*tail
=
3857 rte_eth_devices
[port_id
].post_rx_burst_cbs
[queue_id
];
3860 rte_eth_devices
[port_id
].post_rx_burst_cbs
[queue_id
] = cb
;
3867 rte_spinlock_unlock(&rte_eth_rx_cb_lock
);
3872 const struct rte_eth_rxtx_callback
*
3873 rte_eth_add_first_rx_callback(uint16_t port_id
, uint16_t queue_id
,
3874 rte_rx_callback_fn fn
, void *user_param
)
3876 #ifndef RTE_ETHDEV_RXTX_CALLBACKS
3877 rte_errno
= ENOTSUP
;
3880 /* check input parameters */
3881 if (!rte_eth_dev_is_valid_port(port_id
) || fn
== NULL
||
3882 queue_id
>= rte_eth_devices
[port_id
].data
->nb_rx_queues
) {
3887 struct rte_eth_rxtx_callback
*cb
= rte_zmalloc(NULL
, sizeof(*cb
), 0);
3895 cb
->param
= user_param
;
3897 rte_spinlock_lock(&rte_eth_rx_cb_lock
);
3898 /* Add the callbacks at fisrt position*/
3899 cb
->next
= rte_eth_devices
[port_id
].post_rx_burst_cbs
[queue_id
];
3901 rte_eth_devices
[port_id
].post_rx_burst_cbs
[queue_id
] = cb
;
3902 rte_spinlock_unlock(&rte_eth_rx_cb_lock
);
3907 const struct rte_eth_rxtx_callback
*
3908 rte_eth_add_tx_callback(uint16_t port_id
, uint16_t queue_id
,
3909 rte_tx_callback_fn fn
, void *user_param
)
3911 #ifndef RTE_ETHDEV_RXTX_CALLBACKS
3912 rte_errno
= ENOTSUP
;
3915 /* check input parameters */
3916 if (!rte_eth_dev_is_valid_port(port_id
) || fn
== NULL
||
3917 queue_id
>= rte_eth_devices
[port_id
].data
->nb_tx_queues
) {
3922 struct rte_eth_rxtx_callback
*cb
= rte_zmalloc(NULL
, sizeof(*cb
), 0);
3930 cb
->param
= user_param
;
3932 rte_spinlock_lock(&rte_eth_tx_cb_lock
);
3933 /* Add the callbacks in fifo order. */
3934 struct rte_eth_rxtx_callback
*tail
=
3935 rte_eth_devices
[port_id
].pre_tx_burst_cbs
[queue_id
];
3938 rte_eth_devices
[port_id
].pre_tx_burst_cbs
[queue_id
] = cb
;
3945 rte_spinlock_unlock(&rte_eth_tx_cb_lock
);
3951 rte_eth_remove_rx_callback(uint16_t port_id
, uint16_t queue_id
,
3952 const struct rte_eth_rxtx_callback
*user_cb
)
3954 #ifndef RTE_ETHDEV_RXTX_CALLBACKS
3957 /* Check input parameters. */
3958 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -EINVAL
);
3959 if (user_cb
== NULL
||
3960 queue_id
>= rte_eth_devices
[port_id
].data
->nb_rx_queues
)
3963 struct rte_eth_dev
*dev
= &rte_eth_devices
[port_id
];
3964 struct rte_eth_rxtx_callback
*cb
;
3965 struct rte_eth_rxtx_callback
**prev_cb
;
3968 rte_spinlock_lock(&rte_eth_rx_cb_lock
);
3969 prev_cb
= &dev
->post_rx_burst_cbs
[queue_id
];
3970 for (; *prev_cb
!= NULL
; prev_cb
= &cb
->next
) {
3972 if (cb
== user_cb
) {
3973 /* Remove the user cb from the callback list. */
3974 *prev_cb
= cb
->next
;
3979 rte_spinlock_unlock(&rte_eth_rx_cb_lock
);
3985 rte_eth_remove_tx_callback(uint16_t port_id
, uint16_t queue_id
,
3986 const struct rte_eth_rxtx_callback
*user_cb
)
3988 #ifndef RTE_ETHDEV_RXTX_CALLBACKS
3991 /* Check input parameters. */
3992 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -EINVAL
);
3993 if (user_cb
== NULL
||
3994 queue_id
>= rte_eth_devices
[port_id
].data
->nb_tx_queues
)
3997 struct rte_eth_dev
*dev
= &rte_eth_devices
[port_id
];
3999 struct rte_eth_rxtx_callback
*cb
;
4000 struct rte_eth_rxtx_callback
**prev_cb
;
4002 rte_spinlock_lock(&rte_eth_tx_cb_lock
);
4003 prev_cb
= &dev
->pre_tx_burst_cbs
[queue_id
];
4004 for (; *prev_cb
!= NULL
; prev_cb
= &cb
->next
) {
4006 if (cb
== user_cb
) {
4007 /* Remove the user cb from the callback list. */
4008 *prev_cb
= cb
->next
;
4013 rte_spinlock_unlock(&rte_eth_tx_cb_lock
);
4019 rte_eth_rx_queue_info_get(uint16_t port_id
, uint16_t queue_id
,
4020 struct rte_eth_rxq_info
*qinfo
)
4022 struct rte_eth_dev
*dev
;
4024 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
4029 dev
= &rte_eth_devices
[port_id
];
4030 if (queue_id
>= dev
->data
->nb_rx_queues
) {
4031 RTE_ETHDEV_LOG(ERR
, "Invalid RX queue_id=%u\n", queue_id
);
4035 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->rxq_info_get
, -ENOTSUP
);
4037 memset(qinfo
, 0, sizeof(*qinfo
));
4038 dev
->dev_ops
->rxq_info_get(dev
, queue_id
, qinfo
);
4043 rte_eth_tx_queue_info_get(uint16_t port_id
, uint16_t queue_id
,
4044 struct rte_eth_txq_info
*qinfo
)
4046 struct rte_eth_dev
*dev
;
4048 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
4053 dev
= &rte_eth_devices
[port_id
];
4054 if (queue_id
>= dev
->data
->nb_tx_queues
) {
4055 RTE_ETHDEV_LOG(ERR
, "Invalid TX queue_id=%u\n", queue_id
);
4059 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->txq_info_get
, -ENOTSUP
);
4061 memset(qinfo
, 0, sizeof(*qinfo
));
4062 dev
->dev_ops
->txq_info_get(dev
, queue_id
, qinfo
);
4068 rte_eth_dev_set_mc_addr_list(uint16_t port_id
,
4069 struct ether_addr
*mc_addr_set
,
4070 uint32_t nb_mc_addr
)
4072 struct rte_eth_dev
*dev
;
4074 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
4076 dev
= &rte_eth_devices
[port_id
];
4077 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->set_mc_addr_list
, -ENOTSUP
);
4078 return eth_err(port_id
, dev
->dev_ops
->set_mc_addr_list(dev
,
4079 mc_addr_set
, nb_mc_addr
));
4083 rte_eth_timesync_enable(uint16_t port_id
)
4085 struct rte_eth_dev
*dev
;
4087 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
4088 dev
= &rte_eth_devices
[port_id
];
4090 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->timesync_enable
, -ENOTSUP
);
4091 return eth_err(port_id
, (*dev
->dev_ops
->timesync_enable
)(dev
));
4095 rte_eth_timesync_disable(uint16_t port_id
)
4097 struct rte_eth_dev
*dev
;
4099 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
4100 dev
= &rte_eth_devices
[port_id
];
4102 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->timesync_disable
, -ENOTSUP
);
4103 return eth_err(port_id
, (*dev
->dev_ops
->timesync_disable
)(dev
));
4107 rte_eth_timesync_read_rx_timestamp(uint16_t port_id
, struct timespec
*timestamp
,
4110 struct rte_eth_dev
*dev
;
4112 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
4113 dev
= &rte_eth_devices
[port_id
];
4115 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->timesync_read_rx_timestamp
, -ENOTSUP
);
4116 return eth_err(port_id
, (*dev
->dev_ops
->timesync_read_rx_timestamp
)
4117 (dev
, timestamp
, flags
));
4121 rte_eth_timesync_read_tx_timestamp(uint16_t port_id
,
4122 struct timespec
*timestamp
)
4124 struct rte_eth_dev
*dev
;
4126 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
4127 dev
= &rte_eth_devices
[port_id
];
4129 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->timesync_read_tx_timestamp
, -ENOTSUP
);
4130 return eth_err(port_id
, (*dev
->dev_ops
->timesync_read_tx_timestamp
)
4135 rte_eth_timesync_adjust_time(uint16_t port_id
, int64_t delta
)
4137 struct rte_eth_dev
*dev
;
4139 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
4140 dev
= &rte_eth_devices
[port_id
];
4142 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->timesync_adjust_time
, -ENOTSUP
);
4143 return eth_err(port_id
, (*dev
->dev_ops
->timesync_adjust_time
)(dev
,
4148 rte_eth_timesync_read_time(uint16_t port_id
, struct timespec
*timestamp
)
4150 struct rte_eth_dev
*dev
;
4152 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
4153 dev
= &rte_eth_devices
[port_id
];
4155 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->timesync_read_time
, -ENOTSUP
);
4156 return eth_err(port_id
, (*dev
->dev_ops
->timesync_read_time
)(dev
,
4161 rte_eth_timesync_write_time(uint16_t port_id
, const struct timespec
*timestamp
)
4163 struct rte_eth_dev
*dev
;
4165 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
4166 dev
= &rte_eth_devices
[port_id
];
4168 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->timesync_write_time
, -ENOTSUP
);
4169 return eth_err(port_id
, (*dev
->dev_ops
->timesync_write_time
)(dev
,
4174 rte_eth_dev_get_reg_info(uint16_t port_id
, struct rte_dev_reg_info
*info
)
4176 struct rte_eth_dev
*dev
;
4178 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
4180 dev
= &rte_eth_devices
[port_id
];
4181 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->get_reg
, -ENOTSUP
);
4182 return eth_err(port_id
, (*dev
->dev_ops
->get_reg
)(dev
, info
));
4186 rte_eth_dev_get_eeprom_length(uint16_t port_id
)
4188 struct rte_eth_dev
*dev
;
4190 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
4192 dev
= &rte_eth_devices
[port_id
];
4193 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->get_eeprom_length
, -ENOTSUP
);
4194 return eth_err(port_id
, (*dev
->dev_ops
->get_eeprom_length
)(dev
));
4198 rte_eth_dev_get_eeprom(uint16_t port_id
, struct rte_dev_eeprom_info
*info
)
4200 struct rte_eth_dev
*dev
;
4202 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
4204 dev
= &rte_eth_devices
[port_id
];
4205 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->get_eeprom
, -ENOTSUP
);
4206 return eth_err(port_id
, (*dev
->dev_ops
->get_eeprom
)(dev
, info
));
4210 rte_eth_dev_set_eeprom(uint16_t port_id
, struct rte_dev_eeprom_info
*info
)
4212 struct rte_eth_dev
*dev
;
4214 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
4216 dev
= &rte_eth_devices
[port_id
];
4217 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->set_eeprom
, -ENOTSUP
);
4218 return eth_err(port_id
, (*dev
->dev_ops
->set_eeprom
)(dev
, info
));
4221 int __rte_experimental
4222 rte_eth_dev_get_module_info(uint16_t port_id
,
4223 struct rte_eth_dev_module_info
*modinfo
)
4225 struct rte_eth_dev
*dev
;
4227 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
4229 dev
= &rte_eth_devices
[port_id
];
4230 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->get_module_info
, -ENOTSUP
);
4231 return (*dev
->dev_ops
->get_module_info
)(dev
, modinfo
);
4234 int __rte_experimental
4235 rte_eth_dev_get_module_eeprom(uint16_t port_id
,
4236 struct rte_dev_eeprom_info
*info
)
4238 struct rte_eth_dev
*dev
;
4240 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
4242 dev
= &rte_eth_devices
[port_id
];
4243 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->get_module_eeprom
, -ENOTSUP
);
4244 return (*dev
->dev_ops
->get_module_eeprom
)(dev
, info
);
4248 rte_eth_dev_get_dcb_info(uint16_t port_id
,
4249 struct rte_eth_dcb_info
*dcb_info
)
4251 struct rte_eth_dev
*dev
;
4253 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
4255 dev
= &rte_eth_devices
[port_id
];
4256 memset(dcb_info
, 0, sizeof(struct rte_eth_dcb_info
));
4258 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->get_dcb_info
, -ENOTSUP
);
4259 return eth_err(port_id
, (*dev
->dev_ops
->get_dcb_info
)(dev
, dcb_info
));
4263 rte_eth_dev_l2_tunnel_eth_type_conf(uint16_t port_id
,
4264 struct rte_eth_l2_tunnel_conf
*l2_tunnel
)
4266 struct rte_eth_dev
*dev
;
4268 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
4269 if (l2_tunnel
== NULL
) {
4270 RTE_ETHDEV_LOG(ERR
, "Invalid l2_tunnel parameter\n");
4274 if (l2_tunnel
->l2_tunnel_type
>= RTE_TUNNEL_TYPE_MAX
) {
4275 RTE_ETHDEV_LOG(ERR
, "Invalid tunnel type\n");
4279 dev
= &rte_eth_devices
[port_id
];
4280 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->l2_tunnel_eth_type_conf
,
4282 return eth_err(port_id
, (*dev
->dev_ops
->l2_tunnel_eth_type_conf
)(dev
,
4287 rte_eth_dev_l2_tunnel_offload_set(uint16_t port_id
,
4288 struct rte_eth_l2_tunnel_conf
*l2_tunnel
,
4292 struct rte_eth_dev
*dev
;
4294 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
4296 if (l2_tunnel
== NULL
) {
4297 RTE_ETHDEV_LOG(ERR
, "Invalid l2_tunnel parameter\n");
4301 if (l2_tunnel
->l2_tunnel_type
>= RTE_TUNNEL_TYPE_MAX
) {
4302 RTE_ETHDEV_LOG(ERR
, "Invalid tunnel type\n");
4307 RTE_ETHDEV_LOG(ERR
, "Mask should have a value\n");
4311 dev
= &rte_eth_devices
[port_id
];
4312 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->l2_tunnel_offload_set
,
4314 return eth_err(port_id
, (*dev
->dev_ops
->l2_tunnel_offload_set
)(dev
,
4315 l2_tunnel
, mask
, en
));
4319 rte_eth_dev_adjust_nb_desc(uint16_t *nb_desc
,
4320 const struct rte_eth_desc_lim
*desc_lim
)
4322 if (desc_lim
->nb_align
!= 0)
4323 *nb_desc
= RTE_ALIGN_CEIL(*nb_desc
, desc_lim
->nb_align
);
4325 if (desc_lim
->nb_max
!= 0)
4326 *nb_desc
= RTE_MIN(*nb_desc
, desc_lim
->nb_max
);
4328 *nb_desc
= RTE_MAX(*nb_desc
, desc_lim
->nb_min
);
4332 rte_eth_dev_adjust_nb_rx_tx_desc(uint16_t port_id
,
4333 uint16_t *nb_rx_desc
,
4334 uint16_t *nb_tx_desc
)
4336 struct rte_eth_dev
*dev
;
4337 struct rte_eth_dev_info dev_info
;
4339 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
4341 dev
= &rte_eth_devices
[port_id
];
4342 RTE_FUNC_PTR_OR_ERR_RET(*dev
->dev_ops
->dev_infos_get
, -ENOTSUP
);
4344 rte_eth_dev_info_get(port_id
, &dev_info
);
4346 if (nb_rx_desc
!= NULL
)
4347 rte_eth_dev_adjust_nb_desc(nb_rx_desc
, &dev_info
.rx_desc_lim
);
4349 if (nb_tx_desc
!= NULL
)
4350 rte_eth_dev_adjust_nb_desc(nb_tx_desc
, &dev_info
.tx_desc_lim
);
4356 rte_eth_dev_pool_ops_supported(uint16_t port_id
, const char *pool
)
4358 struct rte_eth_dev
*dev
;
4360 RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id
, -ENODEV
);
4365 dev
= &rte_eth_devices
[port_id
];
4367 if (*dev
->dev_ops
->pool_ops_supported
== NULL
)
4368 return 1; /* all pools are supported */
4370 return (*dev
->dev_ops
->pool_ops_supported
)(dev
, pool
);
4374 * A set of values to describe the possible states of a switch domain.
4376 enum rte_eth_switch_domain_state
{
4377 RTE_ETH_SWITCH_DOMAIN_UNUSED
= 0,
4378 RTE_ETH_SWITCH_DOMAIN_ALLOCATED
4382 * Array of switch domains available for allocation. Array is sized to
4383 * RTE_MAX_ETHPORTS elements as there cannot be more active switch domains than
4384 * ethdev ports in a single process.
4386 static struct rte_eth_dev_switch
{
4387 enum rte_eth_switch_domain_state state
;
4388 } rte_eth_switch_domains
[RTE_MAX_ETHPORTS
];
4390 int __rte_experimental
4391 rte_eth_switch_domain_alloc(uint16_t *domain_id
)
4395 *domain_id
= RTE_ETH_DEV_SWITCH_DOMAIN_ID_INVALID
;
4397 for (i
= RTE_ETH_DEV_SWITCH_DOMAIN_ID_INVALID
+ 1;
4398 i
< RTE_MAX_ETHPORTS
; i
++) {
4399 if (rte_eth_switch_domains
[i
].state
==
4400 RTE_ETH_SWITCH_DOMAIN_UNUSED
) {
4401 rte_eth_switch_domains
[i
].state
=
4402 RTE_ETH_SWITCH_DOMAIN_ALLOCATED
;
4411 int __rte_experimental
4412 rte_eth_switch_domain_free(uint16_t domain_id
)
4414 if (domain_id
== RTE_ETH_DEV_SWITCH_DOMAIN_ID_INVALID
||
4415 domain_id
>= RTE_MAX_ETHPORTS
)
4418 if (rte_eth_switch_domains
[domain_id
].state
!=
4419 RTE_ETH_SWITCH_DOMAIN_ALLOCATED
)
4422 rte_eth_switch_domains
[domain_id
].state
= RTE_ETH_SWITCH_DOMAIN_UNUSED
;
4428 rte_eth_devargs_tokenise(struct rte_kvargs
*arglist
, const char *str_in
)
4431 struct rte_kvargs_pair
*pair
;
4434 arglist
->str
= strdup(str_in
);
4435 if (arglist
->str
== NULL
)
4438 letter
= arglist
->str
;
4441 pair
= &arglist
->pairs
[0];
4444 case 0: /* Initial */
4447 else if (*letter
== '\0')
4454 case 1: /* Parsing key */
4455 if (*letter
== '=') {
4457 pair
->value
= letter
+ 1;
4459 } else if (*letter
== ',' || *letter
== '\0')
4464 case 2: /* Parsing value */
4467 else if (*letter
== ',') {
4470 pair
= &arglist
->pairs
[arglist
->count
];
4472 } else if (*letter
== '\0') {
4475 pair
= &arglist
->pairs
[arglist
->count
];
4480 case 3: /* Parsing list */
4483 else if (*letter
== '\0')
4491 int __rte_experimental
4492 rte_eth_devargs_parse(const char *dargs
, struct rte_eth_devargs
*eth_da
)
4494 struct rte_kvargs args
;
4495 struct rte_kvargs_pair
*pair
;
4499 memset(eth_da
, 0, sizeof(*eth_da
));
4501 result
= rte_eth_devargs_tokenise(&args
, dargs
);
4505 for (i
= 0; i
< args
.count
; i
++) {
4506 pair
= &args
.pairs
[i
];
4507 if (strcmp("representor", pair
->key
) == 0) {
4508 result
= rte_eth_devargs_parse_list(pair
->value
,
4509 rte_eth_devargs_parse_representor_ports
,
4523 RTE_INIT(ethdev_init_log
)
4525 rte_eth_dev_logtype
= rte_log_register("lib.ethdev");
4526 if (rte_eth_dev_logtype
>= 0)
4527 rte_log_set_level(rte_eth_dev_logtype
, RTE_LOG_INFO
);