1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2014 John W. Linville <linville@tuxdriver.com>
3 * Originally based upon librte_pmd_pcap code:
4 * Copyright(c) 2010-2015 Intel Corporation.
5 * Copyright(c) 2014 6WIND S.A.
9 #include <rte_string_fns.h>
11 #include <rte_ethdev_driver.h>
12 #include <rte_ethdev_vdev.h>
13 #include <rte_malloc.h>
14 #include <rte_kvargs.h>
15 #include <rte_bus_vdev.h>
17 #include <linux/if_ether.h>
18 #include <linux/if_packet.h>
19 #include <arpa/inet.h>
21 #include <sys/types.h>
22 #include <sys/socket.h>
23 #include <sys/ioctl.h>
28 #define ETH_AF_PACKET_IFACE_ARG "iface"
29 #define ETH_AF_PACKET_NUM_Q_ARG "qpairs"
30 #define ETH_AF_PACKET_BLOCKSIZE_ARG "blocksz"
31 #define ETH_AF_PACKET_FRAMESIZE_ARG "framesz"
32 #define ETH_AF_PACKET_FRAMECOUNT_ARG "framecnt"
33 #define ETH_AF_PACKET_QDISC_BYPASS_ARG "qdisc_bypass"
35 #define DFLT_BLOCK_SIZE (1 << 12)
36 #define DFLT_FRAME_SIZE (1 << 11)
37 #define DFLT_FRAME_COUNT (1 << 9)
39 #define RTE_PMD_AF_PACKET_MAX_RINGS 16
46 unsigned int framecount
;
47 unsigned int framenum
;
49 struct rte_mempool
*mb_pool
;
52 volatile unsigned long rx_pkts
;
53 volatile unsigned long err_pkts
;
54 volatile unsigned long rx_bytes
;
59 unsigned int frame_data_size
;
63 unsigned int framecount
;
64 unsigned int framenum
;
66 volatile unsigned long tx_pkts
;
67 volatile unsigned long err_pkts
;
68 volatile unsigned long tx_bytes
;
71 struct pmd_internals
{
76 struct ether_addr eth_addr
;
78 struct tpacket_req req
;
80 struct pkt_rx_queue rx_queue
[RTE_PMD_AF_PACKET_MAX_RINGS
];
81 struct pkt_tx_queue tx_queue
[RTE_PMD_AF_PACKET_MAX_RINGS
];
84 static const char *valid_arguments
[] = {
85 ETH_AF_PACKET_IFACE_ARG
,
86 ETH_AF_PACKET_NUM_Q_ARG
,
87 ETH_AF_PACKET_BLOCKSIZE_ARG
,
88 ETH_AF_PACKET_FRAMESIZE_ARG
,
89 ETH_AF_PACKET_FRAMECOUNT_ARG
,
90 ETH_AF_PACKET_QDISC_BYPASS_ARG
,
94 static struct rte_eth_link pmd_link
= {
95 .link_speed
= ETH_SPEED_NUM_10G
,
96 .link_duplex
= ETH_LINK_FULL_DUPLEX
,
97 .link_status
= ETH_LINK_DOWN
,
98 .link_autoneg
= ETH_LINK_FIXED
,
101 static int af_packet_logtype
;
103 #define PMD_LOG(level, fmt, args...) \
104 rte_log(RTE_LOG_ ## level, af_packet_logtype, \
105 "%s(): " fmt "\n", __func__, ##args)
108 eth_af_packet_rx(void *queue
, struct rte_mbuf
**bufs
, uint16_t nb_pkts
)
111 struct tpacket2_hdr
*ppd
;
112 struct rte_mbuf
*mbuf
;
114 struct pkt_rx_queue
*pkt_q
= queue
;
116 unsigned long num_rx_bytes
= 0;
117 unsigned int framecount
, framenum
;
119 if (unlikely(nb_pkts
== 0))
123 * Reads the given number of packets from the AF_PACKET socket one by
124 * one and copies the packet data into a newly allocated mbuf.
126 framecount
= pkt_q
->framecount
;
127 framenum
= pkt_q
->framenum
;
128 for (i
= 0; i
< nb_pkts
; i
++) {
129 /* point at the next incoming frame */
130 ppd
= (struct tpacket2_hdr
*) pkt_q
->rd
[framenum
].iov_base
;
131 if ((ppd
->tp_status
& TP_STATUS_USER
) == 0)
134 /* allocate the next mbuf */
135 mbuf
= rte_pktmbuf_alloc(pkt_q
->mb_pool
);
136 if (unlikely(mbuf
== NULL
))
139 /* packet will fit in the mbuf, go ahead and receive it */
140 rte_pktmbuf_pkt_len(mbuf
) = rte_pktmbuf_data_len(mbuf
) = ppd
->tp_snaplen
;
141 pbuf
= (uint8_t *) ppd
+ ppd
->tp_mac
;
142 memcpy(rte_pktmbuf_mtod(mbuf
, void *), pbuf
, rte_pktmbuf_data_len(mbuf
));
144 /* check for vlan info */
145 if (ppd
->tp_status
& TP_STATUS_VLAN_VALID
) {
146 mbuf
->vlan_tci
= ppd
->tp_vlan_tci
;
147 mbuf
->ol_flags
|= (PKT_RX_VLAN
| PKT_RX_VLAN_STRIPPED
);
150 /* release incoming frame and advance ring buffer */
151 ppd
->tp_status
= TP_STATUS_KERNEL
;
152 if (++framenum
>= framecount
)
154 mbuf
->port
= pkt_q
->in_port
;
156 /* account for the receive frame */
159 num_rx_bytes
+= mbuf
->pkt_len
;
161 pkt_q
->framenum
= framenum
;
162 pkt_q
->rx_pkts
+= num_rx
;
163 pkt_q
->rx_bytes
+= num_rx_bytes
;
168 * Callback to handle sending packets through a real NIC.
171 eth_af_packet_tx(void *queue
, struct rte_mbuf
**bufs
, uint16_t nb_pkts
)
173 struct tpacket2_hdr
*ppd
;
174 struct rte_mbuf
*mbuf
;
176 unsigned int framecount
, framenum
;
178 struct pkt_tx_queue
*pkt_q
= queue
;
180 unsigned long num_tx_bytes
= 0;
183 if (unlikely(nb_pkts
== 0))
186 memset(&pfd
, 0, sizeof(pfd
));
187 pfd
.fd
= pkt_q
->sockfd
;
188 pfd
.events
= POLLOUT
;
191 framecount
= pkt_q
->framecount
;
192 framenum
= pkt_q
->framenum
;
193 ppd
= (struct tpacket2_hdr
*) pkt_q
->rd
[framenum
].iov_base
;
194 for (i
= 0; i
< nb_pkts
; i
++) {
197 /* drop oversized packets */
198 if (mbuf
->pkt_len
> pkt_q
->frame_data_size
) {
199 rte_pktmbuf_free(mbuf
);
203 /* insert vlan info if necessary */
204 if (mbuf
->ol_flags
& PKT_TX_VLAN_PKT
) {
205 if (rte_vlan_insert(&mbuf
)) {
206 rte_pktmbuf_free(mbuf
);
211 /* point at the next incoming frame */
212 if ((ppd
->tp_status
!= TP_STATUS_AVAILABLE
) &&
213 (poll(&pfd
, 1, -1) < 0))
216 /* copy the tx frame data */
217 pbuf
= (uint8_t *) ppd
+ TPACKET2_HDRLEN
-
218 sizeof(struct sockaddr_ll
);
220 struct rte_mbuf
*tmp_mbuf
= mbuf
;
222 uint16_t data_len
= rte_pktmbuf_data_len(tmp_mbuf
);
223 memcpy(pbuf
, rte_pktmbuf_mtod(tmp_mbuf
, void*), data_len
);
225 tmp_mbuf
= tmp_mbuf
->next
;
228 ppd
->tp_len
= mbuf
->pkt_len
;
229 ppd
->tp_snaplen
= mbuf
->pkt_len
;
231 /* release incoming frame and advance ring buffer */
232 ppd
->tp_status
= TP_STATUS_SEND_REQUEST
;
233 if (++framenum
>= framecount
)
235 ppd
= (struct tpacket2_hdr
*) pkt_q
->rd
[framenum
].iov_base
;
238 num_tx_bytes
+= mbuf
->pkt_len
;
239 rte_pktmbuf_free(mbuf
);
242 /* kick-off transmits */
243 if (sendto(pkt_q
->sockfd
, NULL
, 0, MSG_DONTWAIT
, NULL
, 0) == -1) {
244 /* error sending -- no packets transmitted */
249 pkt_q
->framenum
= framenum
;
250 pkt_q
->tx_pkts
+= num_tx
;
251 pkt_q
->err_pkts
+= i
- num_tx
;
252 pkt_q
->tx_bytes
+= num_tx_bytes
;
257 eth_dev_start(struct rte_eth_dev
*dev
)
259 dev
->data
->dev_link
.link_status
= ETH_LINK_UP
;
264 * This function gets called when the current port gets stopped.
267 eth_dev_stop(struct rte_eth_dev
*dev
)
271 struct pmd_internals
*internals
= dev
->data
->dev_private
;
273 for (i
= 0; i
< internals
->nb_queues
; i
++) {
274 sockfd
= internals
->rx_queue
[i
].sockfd
;
278 /* Prevent use after free in case tx fd == rx fd */
279 if (sockfd
!= internals
->tx_queue
[i
].sockfd
) {
280 sockfd
= internals
->tx_queue
[i
].sockfd
;
285 internals
->rx_queue
[i
].sockfd
= -1;
286 internals
->tx_queue
[i
].sockfd
= -1;
289 dev
->data
->dev_link
.link_status
= ETH_LINK_DOWN
;
293 eth_dev_configure(struct rte_eth_dev
*dev __rte_unused
)
299 eth_dev_info(struct rte_eth_dev
*dev
, struct rte_eth_dev_info
*dev_info
)
301 struct pmd_internals
*internals
= dev
->data
->dev_private
;
303 dev_info
->if_index
= internals
->if_index
;
304 dev_info
->max_mac_addrs
= 1;
305 dev_info
->max_rx_pktlen
= (uint32_t)ETH_FRAME_LEN
;
306 dev_info
->max_rx_queues
= (uint16_t)internals
->nb_queues
;
307 dev_info
->max_tx_queues
= (uint16_t)internals
->nb_queues
;
308 dev_info
->min_rx_bufsize
= 0;
312 eth_stats_get(struct rte_eth_dev
*dev
, struct rte_eth_stats
*igb_stats
)
315 unsigned long rx_total
= 0, tx_total
= 0, tx_err_total
= 0;
316 unsigned long rx_bytes_total
= 0, tx_bytes_total
= 0;
317 const struct pmd_internals
*internal
= dev
->data
->dev_private
;
319 imax
= (internal
->nb_queues
< RTE_ETHDEV_QUEUE_STAT_CNTRS
?
320 internal
->nb_queues
: RTE_ETHDEV_QUEUE_STAT_CNTRS
);
321 for (i
= 0; i
< imax
; i
++) {
322 igb_stats
->q_ipackets
[i
] = internal
->rx_queue
[i
].rx_pkts
;
323 igb_stats
->q_ibytes
[i
] = internal
->rx_queue
[i
].rx_bytes
;
324 rx_total
+= igb_stats
->q_ipackets
[i
];
325 rx_bytes_total
+= igb_stats
->q_ibytes
[i
];
328 imax
= (internal
->nb_queues
< RTE_ETHDEV_QUEUE_STAT_CNTRS
?
329 internal
->nb_queues
: RTE_ETHDEV_QUEUE_STAT_CNTRS
);
330 for (i
= 0; i
< imax
; i
++) {
331 igb_stats
->q_opackets
[i
] = internal
->tx_queue
[i
].tx_pkts
;
332 igb_stats
->q_errors
[i
] = internal
->tx_queue
[i
].err_pkts
;
333 igb_stats
->q_obytes
[i
] = internal
->tx_queue
[i
].tx_bytes
;
334 tx_total
+= igb_stats
->q_opackets
[i
];
335 tx_err_total
+= igb_stats
->q_errors
[i
];
336 tx_bytes_total
+= igb_stats
->q_obytes
[i
];
339 igb_stats
->ipackets
= rx_total
;
340 igb_stats
->ibytes
= rx_bytes_total
;
341 igb_stats
->opackets
= tx_total
;
342 igb_stats
->oerrors
= tx_err_total
;
343 igb_stats
->obytes
= tx_bytes_total
;
348 eth_stats_reset(struct rte_eth_dev
*dev
)
351 struct pmd_internals
*internal
= dev
->data
->dev_private
;
353 for (i
= 0; i
< internal
->nb_queues
; i
++) {
354 internal
->rx_queue
[i
].rx_pkts
= 0;
355 internal
->rx_queue
[i
].rx_bytes
= 0;
358 for (i
= 0; i
< internal
->nb_queues
; i
++) {
359 internal
->tx_queue
[i
].tx_pkts
= 0;
360 internal
->tx_queue
[i
].err_pkts
= 0;
361 internal
->tx_queue
[i
].tx_bytes
= 0;
366 eth_dev_close(struct rte_eth_dev
*dev __rte_unused
)
371 eth_queue_release(void *q __rte_unused
)
376 eth_link_update(struct rte_eth_dev
*dev __rte_unused
,
377 int wait_to_complete __rte_unused
)
383 eth_rx_queue_setup(struct rte_eth_dev
*dev
,
384 uint16_t rx_queue_id
,
385 uint16_t nb_rx_desc __rte_unused
,
386 unsigned int socket_id __rte_unused
,
387 const struct rte_eth_rxconf
*rx_conf __rte_unused
,
388 struct rte_mempool
*mb_pool
)
390 struct pmd_internals
*internals
= dev
->data
->dev_private
;
391 struct pkt_rx_queue
*pkt_q
= &internals
->rx_queue
[rx_queue_id
];
392 unsigned int buf_size
, data_size
;
394 pkt_q
->mb_pool
= mb_pool
;
396 /* Now get the space available for data in the mbuf */
397 buf_size
= rte_pktmbuf_data_room_size(pkt_q
->mb_pool
) -
398 RTE_PKTMBUF_HEADROOM
;
399 data_size
= internals
->req
.tp_frame_size
;
400 data_size
-= TPACKET2_HDRLEN
- sizeof(struct sockaddr_ll
);
402 if (data_size
> buf_size
) {
404 "%s: %d bytes will not fit in mbuf (%d bytes)",
405 dev
->device
->name
, data_size
, buf_size
);
409 dev
->data
->rx_queues
[rx_queue_id
] = pkt_q
;
410 pkt_q
->in_port
= dev
->data
->port_id
;
416 eth_tx_queue_setup(struct rte_eth_dev
*dev
,
417 uint16_t tx_queue_id
,
418 uint16_t nb_tx_desc __rte_unused
,
419 unsigned int socket_id __rte_unused
,
420 const struct rte_eth_txconf
*tx_conf __rte_unused
)
423 struct pmd_internals
*internals
= dev
->data
->dev_private
;
425 dev
->data
->tx_queues
[tx_queue_id
] = &internals
->tx_queue
[tx_queue_id
];
430 eth_dev_mtu_set(struct rte_eth_dev
*dev
, uint16_t mtu
)
432 struct pmd_internals
*internals
= dev
->data
->dev_private
;
433 struct ifreq ifr
= { .ifr_mtu
= mtu
};
436 unsigned int data_size
= internals
->req
.tp_frame_size
-
442 s
= socket(PF_INET
, SOCK_DGRAM
, 0);
446 strlcpy(ifr
.ifr_name
, internals
->if_name
, IFNAMSIZ
);
447 ret
= ioctl(s
, SIOCSIFMTU
, &ifr
);
457 eth_dev_change_flags(char *if_name
, uint32_t flags
, uint32_t mask
)
462 s
= socket(PF_INET
, SOCK_DGRAM
, 0);
466 strlcpy(ifr
.ifr_name
, if_name
, IFNAMSIZ
);
467 if (ioctl(s
, SIOCGIFFLAGS
, &ifr
) < 0)
469 ifr
.ifr_flags
&= mask
;
470 ifr
.ifr_flags
|= flags
;
471 if (ioctl(s
, SIOCSIFFLAGS
, &ifr
) < 0)
478 eth_dev_promiscuous_enable(struct rte_eth_dev
*dev
)
480 struct pmd_internals
*internals
= dev
->data
->dev_private
;
482 eth_dev_change_flags(internals
->if_name
, IFF_PROMISC
, ~0);
486 eth_dev_promiscuous_disable(struct rte_eth_dev
*dev
)
488 struct pmd_internals
*internals
= dev
->data
->dev_private
;
490 eth_dev_change_flags(internals
->if_name
, 0, ~IFF_PROMISC
);
493 static const struct eth_dev_ops ops
= {
494 .dev_start
= eth_dev_start
,
495 .dev_stop
= eth_dev_stop
,
496 .dev_close
= eth_dev_close
,
497 .dev_configure
= eth_dev_configure
,
498 .dev_infos_get
= eth_dev_info
,
499 .mtu_set
= eth_dev_mtu_set
,
500 .promiscuous_enable
= eth_dev_promiscuous_enable
,
501 .promiscuous_disable
= eth_dev_promiscuous_disable
,
502 .rx_queue_setup
= eth_rx_queue_setup
,
503 .tx_queue_setup
= eth_tx_queue_setup
,
504 .rx_queue_release
= eth_queue_release
,
505 .tx_queue_release
= eth_queue_release
,
506 .link_update
= eth_link_update
,
507 .stats_get
= eth_stats_get
,
508 .stats_reset
= eth_stats_reset
,
512 * Opens an AF_PACKET socket
515 open_packet_iface(const char *key __rte_unused
,
516 const char *value __rte_unused
,
519 int *sockfd
= extra_args
;
521 /* Open an AF_PACKET socket... */
522 *sockfd
= socket(AF_PACKET
, SOCK_RAW
, htons(ETH_P_ALL
));
524 PMD_LOG(ERR
, "Could not open AF_PACKET socket");
531 static struct rte_vdev_driver pmd_af_packet_drv
;
534 rte_pmd_init_internals(struct rte_vdev_device
*dev
,
536 const unsigned nb_queues
,
537 unsigned int blocksize
,
538 unsigned int blockcnt
,
539 unsigned int framesize
,
540 unsigned int framecnt
,
541 unsigned int qdisc_bypass
,
542 struct pmd_internals
**internals
,
543 struct rte_eth_dev
**eth_dev
,
544 struct rte_kvargs
*kvlist
)
546 const char *name
= rte_vdev_device_name(dev
);
547 const unsigned int numa_node
= dev
->device
.numa_node
;
548 struct rte_eth_dev_data
*data
= NULL
;
549 struct rte_kvargs_pair
*pair
= NULL
;
553 struct sockaddr_ll sockaddr
;
554 struct tpacket_req
*req
;
555 struct pkt_rx_queue
*rx_queue
;
556 struct pkt_tx_queue
*tx_queue
;
557 int rc
, tpver
, discard
;
559 unsigned int i
, q
, rdsize
;
560 #if defined(PACKET_FANOUT)
564 for (k_idx
= 0; k_idx
< kvlist
->count
; k_idx
++) {
565 pair
= &kvlist
->pairs
[k_idx
];
566 if (strstr(pair
->key
, ETH_AF_PACKET_IFACE_ARG
) != NULL
)
571 "%s: no interface specified for AF_PACKET ethdev",
577 "%s: creating AF_PACKET-backed ethdev on numa socket %u",
580 *internals
= rte_zmalloc_socket(name
, sizeof(**internals
),
582 if (*internals
== NULL
)
585 for (q
= 0; q
< nb_queues
; q
++) {
586 (*internals
)->rx_queue
[q
].map
= MAP_FAILED
;
587 (*internals
)->tx_queue
[q
].map
= MAP_FAILED
;
590 req
= &((*internals
)->req
);
592 req
->tp_block_size
= blocksize
;
593 req
->tp_block_nr
= blockcnt
;
594 req
->tp_frame_size
= framesize
;
595 req
->tp_frame_nr
= framecnt
;
597 ifnamelen
= strlen(pair
->value
);
598 if (ifnamelen
< sizeof(ifr
.ifr_name
)) {
599 memcpy(ifr
.ifr_name
, pair
->value
, ifnamelen
);
600 ifr
.ifr_name
[ifnamelen
] = '\0';
603 "%s: I/F name too long (%s)",
607 if (ioctl(sockfd
, SIOCGIFINDEX
, &ifr
) == -1) {
609 "%s: ioctl failed (SIOCGIFINDEX)",
613 (*internals
)->if_name
= strdup(pair
->value
);
614 if ((*internals
)->if_name
== NULL
)
616 (*internals
)->if_index
= ifr
.ifr_ifindex
;
618 if (ioctl(sockfd
, SIOCGIFHWADDR
, &ifr
) == -1) {
620 "%s: ioctl failed (SIOCGIFHWADDR)",
624 memcpy(&(*internals
)->eth_addr
, ifr
.ifr_hwaddr
.sa_data
, ETH_ALEN
);
626 memset(&sockaddr
, 0, sizeof(sockaddr
));
627 sockaddr
.sll_family
= AF_PACKET
;
628 sockaddr
.sll_protocol
= htons(ETH_P_ALL
);
629 sockaddr
.sll_ifindex
= (*internals
)->if_index
;
631 #if defined(PACKET_FANOUT)
632 fanout_arg
= (getpid() ^ (*internals
)->if_index
) & 0xffff;
633 fanout_arg
|= (PACKET_FANOUT_HASH
| PACKET_FANOUT_FLAG_DEFRAG
) << 16;
634 #if defined(PACKET_FANOUT_FLAG_ROLLOVER)
635 fanout_arg
|= PACKET_FANOUT_FLAG_ROLLOVER
<< 16;
639 for (q
= 0; q
< nb_queues
; q
++) {
640 /* Open an AF_PACKET socket for this queue... */
641 qsockfd
= socket(AF_PACKET
, SOCK_RAW
, htons(ETH_P_ALL
));
644 "%s: could not open AF_PACKET socket",
650 rc
= setsockopt(qsockfd
, SOL_PACKET
, PACKET_VERSION
,
651 &tpver
, sizeof(tpver
));
654 "%s: could not set PACKET_VERSION on AF_PACKET socket for %s",
660 rc
= setsockopt(qsockfd
, SOL_PACKET
, PACKET_LOSS
,
661 &discard
, sizeof(discard
));
664 "%s: could not set PACKET_LOSS on AF_PACKET socket for %s",
669 #if defined(PACKET_QDISC_BYPASS)
670 rc
= setsockopt(qsockfd
, SOL_PACKET
, PACKET_QDISC_BYPASS
,
671 &qdisc_bypass
, sizeof(qdisc_bypass
));
674 "%s: could not set PACKET_QDISC_BYPASS on AF_PACKET socket for %s",
679 RTE_SET_USED(qdisc_bypass
);
682 rc
= setsockopt(qsockfd
, SOL_PACKET
, PACKET_RX_RING
, req
, sizeof(*req
));
685 "%s: could not set PACKET_RX_RING on AF_PACKET socket for %s",
690 rc
= setsockopt(qsockfd
, SOL_PACKET
, PACKET_TX_RING
, req
, sizeof(*req
));
693 "%s: could not set PACKET_TX_RING on AF_PACKET "
694 "socket for %s", name
, pair
->value
);
698 rx_queue
= &((*internals
)->rx_queue
[q
]);
699 rx_queue
->framecount
= req
->tp_frame_nr
;
701 rx_queue
->map
= mmap(NULL
, 2 * req
->tp_block_size
* req
->tp_block_nr
,
702 PROT_READ
| PROT_WRITE
, MAP_SHARED
| MAP_LOCKED
,
704 if (rx_queue
->map
== MAP_FAILED
) {
706 "%s: call to mmap failed on AF_PACKET socket for %s",
711 /* rdsize is same for both Tx and Rx */
712 rdsize
= req
->tp_frame_nr
* sizeof(*(rx_queue
->rd
));
714 rx_queue
->rd
= rte_zmalloc_socket(name
, rdsize
, 0, numa_node
);
715 if (rx_queue
->rd
== NULL
)
717 for (i
= 0; i
< req
->tp_frame_nr
; ++i
) {
718 rx_queue
->rd
[i
].iov_base
= rx_queue
->map
+ (i
* framesize
);
719 rx_queue
->rd
[i
].iov_len
= req
->tp_frame_size
;
721 rx_queue
->sockfd
= qsockfd
;
723 tx_queue
= &((*internals
)->tx_queue
[q
]);
724 tx_queue
->framecount
= req
->tp_frame_nr
;
725 tx_queue
->frame_data_size
= req
->tp_frame_size
;
726 tx_queue
->frame_data_size
-= TPACKET2_HDRLEN
-
727 sizeof(struct sockaddr_ll
);
729 tx_queue
->map
= rx_queue
->map
+ req
->tp_block_size
* req
->tp_block_nr
;
731 tx_queue
->rd
= rte_zmalloc_socket(name
, rdsize
, 0, numa_node
);
732 if (tx_queue
->rd
== NULL
)
734 for (i
= 0; i
< req
->tp_frame_nr
; ++i
) {
735 tx_queue
->rd
[i
].iov_base
= tx_queue
->map
+ (i
* framesize
);
736 tx_queue
->rd
[i
].iov_len
= req
->tp_frame_size
;
738 tx_queue
->sockfd
= qsockfd
;
740 rc
= bind(qsockfd
, (const struct sockaddr
*)&sockaddr
, sizeof(sockaddr
));
743 "%s: could not bind AF_PACKET socket to %s",
748 #if defined(PACKET_FANOUT)
749 rc
= setsockopt(qsockfd
, SOL_PACKET
, PACKET_FANOUT
,
750 &fanout_arg
, sizeof(fanout_arg
));
753 "%s: could not set PACKET_FANOUT on AF_PACKET socket "
754 "for %s", name
, pair
->value
);
760 /* reserve an ethdev entry */
761 *eth_dev
= rte_eth_vdev_allocate(dev
, 0);
762 if (*eth_dev
== NULL
)
766 * now put it all together
767 * - store queue data in internals,
768 * - store numa_node in eth_dev
769 * - point eth_dev_data to internals
770 * - and point eth_dev structure to new eth_dev_data structure
773 (*internals
)->nb_queues
= nb_queues
;
775 data
= (*eth_dev
)->data
;
776 data
->dev_private
= *internals
;
777 data
->nb_rx_queues
= (uint16_t)nb_queues
;
778 data
->nb_tx_queues
= (uint16_t)nb_queues
;
779 data
->dev_link
= pmd_link
;
780 data
->mac_addrs
= &(*internals
)->eth_addr
;
782 (*eth_dev
)->dev_ops
= &ops
;
789 for (q
= 0; q
< nb_queues
; q
++) {
790 munmap((*internals
)->rx_queue
[q
].map
,
791 2 * req
->tp_block_size
* req
->tp_block_nr
);
793 rte_free((*internals
)->rx_queue
[q
].rd
);
794 rte_free((*internals
)->tx_queue
[q
].rd
);
795 if (((*internals
)->rx_queue
[q
].sockfd
!= 0) &&
796 ((*internals
)->rx_queue
[q
].sockfd
!= qsockfd
))
797 close((*internals
)->rx_queue
[q
].sockfd
);
799 free((*internals
)->if_name
);
800 rte_free(*internals
);
805 rte_eth_from_packet(struct rte_vdev_device
*dev
,
807 struct rte_kvargs
*kvlist
)
809 const char *name
= rte_vdev_device_name(dev
);
810 struct pmd_internals
*internals
= NULL
;
811 struct rte_eth_dev
*eth_dev
= NULL
;
812 struct rte_kvargs_pair
*pair
= NULL
;
814 unsigned int blockcount
;
815 unsigned int blocksize
= DFLT_BLOCK_SIZE
;
816 unsigned int framesize
= DFLT_FRAME_SIZE
;
817 unsigned int framecount
= DFLT_FRAME_COUNT
;
818 unsigned int qpairs
= 1;
819 unsigned int qdisc_bypass
= 1;
821 /* do some parameter checking */
826 * Walk arguments for configurable settings
828 for (k_idx
= 0; k_idx
< kvlist
->count
; k_idx
++) {
829 pair
= &kvlist
->pairs
[k_idx
];
830 if (strstr(pair
->key
, ETH_AF_PACKET_NUM_Q_ARG
) != NULL
) {
831 qpairs
= atoi(pair
->value
);
833 qpairs
> RTE_PMD_AF_PACKET_MAX_RINGS
) {
835 "%s: invalid qpairs value",
841 if (strstr(pair
->key
, ETH_AF_PACKET_BLOCKSIZE_ARG
) != NULL
) {
842 blocksize
= atoi(pair
->value
);
845 "%s: invalid blocksize value",
851 if (strstr(pair
->key
, ETH_AF_PACKET_FRAMESIZE_ARG
) != NULL
) {
852 framesize
= atoi(pair
->value
);
855 "%s: invalid framesize value",
861 if (strstr(pair
->key
, ETH_AF_PACKET_FRAMECOUNT_ARG
) != NULL
) {
862 framecount
= atoi(pair
->value
);
865 "%s: invalid framecount value",
871 if (strstr(pair
->key
, ETH_AF_PACKET_QDISC_BYPASS_ARG
) != NULL
) {
872 qdisc_bypass
= atoi(pair
->value
);
873 if (qdisc_bypass
> 1) {
875 "%s: invalid bypass value",
883 if (framesize
> blocksize
) {
885 "%s: AF_PACKET MMAP frame size exceeds block size!",
890 blockcount
= framecount
/ (blocksize
/ framesize
);
893 "%s: invalid AF_PACKET MMAP parameters", name
);
897 PMD_LOG(INFO
, "%s: AF_PACKET MMAP parameters:", name
);
898 PMD_LOG(INFO
, "%s:\tblock size %d", name
, blocksize
);
899 PMD_LOG(INFO
, "%s:\tblock count %d", name
, blockcount
);
900 PMD_LOG(INFO
, "%s:\tframe size %d", name
, framesize
);
901 PMD_LOG(INFO
, "%s:\tframe count %d", name
, framecount
);
903 if (rte_pmd_init_internals(dev
, *sockfd
, qpairs
,
904 blocksize
, blockcount
,
905 framesize
, framecount
,
907 &internals
, ð_dev
,
911 eth_dev
->rx_pkt_burst
= eth_af_packet_rx
;
912 eth_dev
->tx_pkt_burst
= eth_af_packet_tx
;
914 rte_eth_dev_probing_finish(eth_dev
);
919 rte_pmd_af_packet_probe(struct rte_vdev_device
*dev
)
922 struct rte_kvargs
*kvlist
;
924 struct rte_eth_dev
*eth_dev
;
925 const char *name
= rte_vdev_device_name(dev
);
927 PMD_LOG(INFO
, "Initializing pmd_af_packet for %s", name
);
929 if (rte_eal_process_type() == RTE_PROC_SECONDARY
) {
930 eth_dev
= rte_eth_dev_attach_secondary(name
);
932 PMD_LOG(ERR
, "Failed to probe %s", name
);
935 /* TODO: request info from primary to set up Rx and Tx */
936 eth_dev
->dev_ops
= &ops
;
937 eth_dev
->device
= &dev
->device
;
938 rte_eth_dev_probing_finish(eth_dev
);
942 kvlist
= rte_kvargs_parse(rte_vdev_device_args(dev
), valid_arguments
);
943 if (kvlist
== NULL
) {
949 * If iface argument is passed we open the NICs and use them for
952 if (rte_kvargs_count(kvlist
, ETH_AF_PACKET_IFACE_ARG
) == 1) {
954 ret
= rte_kvargs_process(kvlist
, ETH_AF_PACKET_IFACE_ARG
,
955 &open_packet_iface
, &sockfd
);
960 if (dev
->device
.numa_node
== SOCKET_ID_ANY
)
961 dev
->device
.numa_node
= rte_socket_id();
963 ret
= rte_eth_from_packet(dev
, &sockfd
, kvlist
);
964 close(sockfd
); /* no longer needed */
967 rte_kvargs_free(kvlist
);
972 rte_pmd_af_packet_remove(struct rte_vdev_device
*dev
)
974 struct rte_eth_dev
*eth_dev
= NULL
;
975 struct pmd_internals
*internals
;
978 PMD_LOG(INFO
, "Closing AF_PACKET ethdev on numa socket %u",
984 /* find the ethdev entry */
985 eth_dev
= rte_eth_dev_allocated(rte_vdev_device_name(dev
));
989 /* mac_addrs must not be freed alone because part of dev_private */
990 eth_dev
->data
->mac_addrs
= NULL
;
992 if (rte_eal_process_type() != RTE_PROC_PRIMARY
)
993 return rte_eth_dev_release_port(eth_dev
);
995 internals
= eth_dev
->data
->dev_private
;
996 for (q
= 0; q
< internals
->nb_queues
; q
++) {
997 rte_free(internals
->rx_queue
[q
].rd
);
998 rte_free(internals
->tx_queue
[q
].rd
);
1000 free(internals
->if_name
);
1002 rte_eth_dev_release_port(eth_dev
);
1007 static struct rte_vdev_driver pmd_af_packet_drv
= {
1008 .probe
= rte_pmd_af_packet_probe
,
1009 .remove
= rte_pmd_af_packet_remove
,
1012 RTE_PMD_REGISTER_VDEV(net_af_packet
, pmd_af_packet_drv
);
1013 RTE_PMD_REGISTER_ALIAS(net_af_packet
, eth_af_packet
);
1014 RTE_PMD_REGISTER_PARAM_STRING(net_af_packet
,
1020 "qdisc_bypass=<0|1>");
1022 RTE_INIT(af_packet_init_log
)
1024 af_packet_logtype
= rte_log_register("pmd.net.packet");
1025 if (af_packet_logtype
>= 0)
1026 rte_log_set_level(af_packet_logtype
, RTE_LOG_NOTICE
);