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.
10 #include <rte_ethdev_driver.h>
11 #include <rte_ethdev_vdev.h>
12 #include <rte_malloc.h>
13 #include <rte_kvargs.h>
14 #include <rte_bus_vdev.h>
16 #include <linux/if_ether.h>
17 #include <linux/if_packet.h>
18 #include <arpa/inet.h>
20 #include <sys/types.h>
21 #include <sys/socket.h>
22 #include <sys/ioctl.h>
27 #define ETH_AF_PACKET_IFACE_ARG "iface"
28 #define ETH_AF_PACKET_NUM_Q_ARG "qpairs"
29 #define ETH_AF_PACKET_BLOCKSIZE_ARG "blocksz"
30 #define ETH_AF_PACKET_FRAMESIZE_ARG "framesz"
31 #define ETH_AF_PACKET_FRAMECOUNT_ARG "framecnt"
32 #define ETH_AF_PACKET_QDISC_BYPASS_ARG "qdisc_bypass"
34 #define DFLT_BLOCK_SIZE (1 << 12)
35 #define DFLT_FRAME_SIZE (1 << 11)
36 #define DFLT_FRAME_COUNT (1 << 9)
38 #define RTE_PMD_AF_PACKET_MAX_RINGS 16
45 unsigned int framecount
;
46 unsigned int framenum
;
48 struct rte_mempool
*mb_pool
;
51 volatile unsigned long rx_pkts
;
52 volatile unsigned long err_pkts
;
53 volatile unsigned long rx_bytes
;
58 unsigned int frame_data_size
;
62 unsigned int framecount
;
63 unsigned int framenum
;
65 volatile unsigned long tx_pkts
;
66 volatile unsigned long err_pkts
;
67 volatile unsigned long tx_bytes
;
70 struct pmd_internals
{
75 struct ether_addr eth_addr
;
77 struct tpacket_req req
;
79 struct pkt_rx_queue rx_queue
[RTE_PMD_AF_PACKET_MAX_RINGS
];
80 struct pkt_tx_queue tx_queue
[RTE_PMD_AF_PACKET_MAX_RINGS
];
83 static const char *valid_arguments
[] = {
84 ETH_AF_PACKET_IFACE_ARG
,
85 ETH_AF_PACKET_NUM_Q_ARG
,
86 ETH_AF_PACKET_BLOCKSIZE_ARG
,
87 ETH_AF_PACKET_FRAMESIZE_ARG
,
88 ETH_AF_PACKET_FRAMECOUNT_ARG
,
89 ETH_AF_PACKET_QDISC_BYPASS_ARG
,
93 static struct rte_eth_link pmd_link
= {
94 .link_speed
= ETH_SPEED_NUM_10G
,
95 .link_duplex
= ETH_LINK_FULL_DUPLEX
,
96 .link_status
= ETH_LINK_DOWN
,
97 .link_autoneg
= ETH_LINK_FIXED
,
100 static int af_packet_logtype
;
102 #define PMD_LOG(level, fmt, args...) \
103 rte_log(RTE_LOG_ ## level, af_packet_logtype, \
104 "%s(): " fmt "\n", __func__, ##args)
107 eth_af_packet_rx(void *queue
, struct rte_mbuf
**bufs
, uint16_t nb_pkts
)
110 struct tpacket2_hdr
*ppd
;
111 struct rte_mbuf
*mbuf
;
113 struct pkt_rx_queue
*pkt_q
= queue
;
115 unsigned long num_rx_bytes
= 0;
116 unsigned int framecount
, framenum
;
118 if (unlikely(nb_pkts
== 0))
122 * Reads the given number of packets from the AF_PACKET socket one by
123 * one and copies the packet data into a newly allocated mbuf.
125 framecount
= pkt_q
->framecount
;
126 framenum
= pkt_q
->framenum
;
127 for (i
= 0; i
< nb_pkts
; i
++) {
128 /* point at the next incoming frame */
129 ppd
= (struct tpacket2_hdr
*) pkt_q
->rd
[framenum
].iov_base
;
130 if ((ppd
->tp_status
& TP_STATUS_USER
) == 0)
133 /* allocate the next mbuf */
134 mbuf
= rte_pktmbuf_alloc(pkt_q
->mb_pool
);
135 if (unlikely(mbuf
== NULL
))
138 /* packet will fit in the mbuf, go ahead and receive it */
139 rte_pktmbuf_pkt_len(mbuf
) = rte_pktmbuf_data_len(mbuf
) = ppd
->tp_snaplen
;
140 pbuf
= (uint8_t *) ppd
+ ppd
->tp_mac
;
141 memcpy(rte_pktmbuf_mtod(mbuf
, void *), pbuf
, rte_pktmbuf_data_len(mbuf
));
143 /* check for vlan info */
144 if (ppd
->tp_status
& TP_STATUS_VLAN_VALID
) {
145 mbuf
->vlan_tci
= ppd
->tp_vlan_tci
;
146 mbuf
->ol_flags
|= (PKT_RX_VLAN
| PKT_RX_VLAN_STRIPPED
);
149 /* release incoming frame and advance ring buffer */
150 ppd
->tp_status
= TP_STATUS_KERNEL
;
151 if (++framenum
>= framecount
)
153 mbuf
->port
= pkt_q
->in_port
;
155 /* account for the receive frame */
158 num_rx_bytes
+= mbuf
->pkt_len
;
160 pkt_q
->framenum
= framenum
;
161 pkt_q
->rx_pkts
+= num_rx
;
162 pkt_q
->rx_bytes
+= num_rx_bytes
;
167 * Callback to handle sending packets through a real NIC.
170 eth_af_packet_tx(void *queue
, struct rte_mbuf
**bufs
, uint16_t nb_pkts
)
172 struct tpacket2_hdr
*ppd
;
173 struct rte_mbuf
*mbuf
;
175 unsigned int framecount
, framenum
;
177 struct pkt_tx_queue
*pkt_q
= queue
;
179 unsigned long num_tx_bytes
= 0;
182 if (unlikely(nb_pkts
== 0))
185 memset(&pfd
, 0, sizeof(pfd
));
186 pfd
.fd
= pkt_q
->sockfd
;
187 pfd
.events
= POLLOUT
;
190 framecount
= pkt_q
->framecount
;
191 framenum
= pkt_q
->framenum
;
192 ppd
= (struct tpacket2_hdr
*) pkt_q
->rd
[framenum
].iov_base
;
193 for (i
= 0; i
< nb_pkts
; i
++) {
196 /* drop oversized packets */
197 if (mbuf
->pkt_len
> pkt_q
->frame_data_size
) {
198 rte_pktmbuf_free(mbuf
);
202 /* insert vlan info if necessary */
203 if (mbuf
->ol_flags
& PKT_TX_VLAN_PKT
) {
204 if (rte_vlan_insert(&mbuf
)) {
205 rte_pktmbuf_free(mbuf
);
210 /* point at the next incoming frame */
211 if ((ppd
->tp_status
!= TP_STATUS_AVAILABLE
) &&
212 (poll(&pfd
, 1, -1) < 0))
215 /* copy the tx frame data */
216 pbuf
= (uint8_t *) ppd
+ TPACKET2_HDRLEN
-
217 sizeof(struct sockaddr_ll
);
219 struct rte_mbuf
*tmp_mbuf
= mbuf
;
221 uint16_t data_len
= rte_pktmbuf_data_len(tmp_mbuf
);
222 memcpy(pbuf
, rte_pktmbuf_mtod(tmp_mbuf
, void*), data_len
);
224 tmp_mbuf
= tmp_mbuf
->next
;
227 ppd
->tp_len
= mbuf
->pkt_len
;
228 ppd
->tp_snaplen
= mbuf
->pkt_len
;
230 /* release incoming frame and advance ring buffer */
231 ppd
->tp_status
= TP_STATUS_SEND_REQUEST
;
232 if (++framenum
>= framecount
)
234 ppd
= (struct tpacket2_hdr
*) pkt_q
->rd
[framenum
].iov_base
;
237 num_tx_bytes
+= mbuf
->pkt_len
;
238 rte_pktmbuf_free(mbuf
);
241 /* kick-off transmits */
242 if (sendto(pkt_q
->sockfd
, NULL
, 0, MSG_DONTWAIT
, NULL
, 0) == -1) {
243 /* error sending -- no packets transmitted */
248 pkt_q
->framenum
= framenum
;
249 pkt_q
->tx_pkts
+= num_tx
;
250 pkt_q
->err_pkts
+= i
- num_tx
;
251 pkt_q
->tx_bytes
+= num_tx_bytes
;
256 eth_dev_start(struct rte_eth_dev
*dev
)
258 dev
->data
->dev_link
.link_status
= ETH_LINK_UP
;
263 * This function gets called when the current port gets stopped.
266 eth_dev_stop(struct rte_eth_dev
*dev
)
270 struct pmd_internals
*internals
= dev
->data
->dev_private
;
272 for (i
= 0; i
< internals
->nb_queues
; i
++) {
273 sockfd
= internals
->rx_queue
[i
].sockfd
;
277 /* Prevent use after free in case tx fd == rx fd */
278 if (sockfd
!= internals
->tx_queue
[i
].sockfd
) {
279 sockfd
= internals
->tx_queue
[i
].sockfd
;
284 internals
->rx_queue
[i
].sockfd
= -1;
285 internals
->tx_queue
[i
].sockfd
= -1;
288 dev
->data
->dev_link
.link_status
= ETH_LINK_DOWN
;
292 eth_dev_configure(struct rte_eth_dev
*dev __rte_unused
)
298 eth_dev_info(struct rte_eth_dev
*dev
, struct rte_eth_dev_info
*dev_info
)
300 struct pmd_internals
*internals
= dev
->data
->dev_private
;
302 dev_info
->if_index
= internals
->if_index
;
303 dev_info
->max_mac_addrs
= 1;
304 dev_info
->max_rx_pktlen
= (uint32_t)ETH_FRAME_LEN
;
305 dev_info
->max_rx_queues
= (uint16_t)internals
->nb_queues
;
306 dev_info
->max_tx_queues
= (uint16_t)internals
->nb_queues
;
307 dev_info
->min_rx_bufsize
= 0;
308 dev_info
->rx_offload_capa
= DEV_RX_OFFLOAD_CRC_STRIP
;
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
-
438 sizeof(struct sockaddr_ll
);
443 s
= socket(PF_INET
, SOCK_DGRAM
, 0);
447 snprintf(ifr
.ifr_name
, IFNAMSIZ
, "%s", internals
->if_name
);
448 ret
= ioctl(s
, SIOCSIFMTU
, &ifr
);
458 eth_dev_change_flags(char *if_name
, uint32_t flags
, uint32_t mask
)
463 s
= socket(PF_INET
, SOCK_DGRAM
, 0);
467 snprintf(ifr
.ifr_name
, IFNAMSIZ
, "%s", if_name
);
468 if (ioctl(s
, SIOCGIFFLAGS
, &ifr
) < 0)
470 ifr
.ifr_flags
&= mask
;
471 ifr
.ifr_flags
|= flags
;
472 if (ioctl(s
, SIOCSIFFLAGS
, &ifr
) < 0)
479 eth_dev_promiscuous_enable(struct rte_eth_dev
*dev
)
481 struct pmd_internals
*internals
= dev
->data
->dev_private
;
483 eth_dev_change_flags(internals
->if_name
, IFF_PROMISC
, ~0);
487 eth_dev_promiscuous_disable(struct rte_eth_dev
*dev
)
489 struct pmd_internals
*internals
= dev
->data
->dev_private
;
491 eth_dev_change_flags(internals
->if_name
, 0, ~IFF_PROMISC
);
494 static const struct eth_dev_ops ops
= {
495 .dev_start
= eth_dev_start
,
496 .dev_stop
= eth_dev_stop
,
497 .dev_close
= eth_dev_close
,
498 .dev_configure
= eth_dev_configure
,
499 .dev_infos_get
= eth_dev_info
,
500 .mtu_set
= eth_dev_mtu_set
,
501 .promiscuous_enable
= eth_dev_promiscuous_enable
,
502 .promiscuous_disable
= eth_dev_promiscuous_disable
,
503 .rx_queue_setup
= eth_rx_queue_setup
,
504 .tx_queue_setup
= eth_tx_queue_setup
,
505 .rx_queue_release
= eth_queue_release
,
506 .tx_queue_release
= eth_queue_release
,
507 .link_update
= eth_link_update
,
508 .stats_get
= eth_stats_get
,
509 .stats_reset
= eth_stats_reset
,
513 * Opens an AF_PACKET socket
516 open_packet_iface(const char *key __rte_unused
,
517 const char *value __rte_unused
,
520 int *sockfd
= extra_args
;
522 /* Open an AF_PACKET socket... */
523 *sockfd
= socket(AF_PACKET
, SOCK_RAW
, htons(ETH_P_ALL
));
525 PMD_LOG(ERR
, "Could not open AF_PACKET socket");
532 static struct rte_vdev_driver pmd_af_packet_drv
;
535 rte_pmd_init_internals(struct rte_vdev_device
*dev
,
537 const unsigned nb_queues
,
538 unsigned int blocksize
,
539 unsigned int blockcnt
,
540 unsigned int framesize
,
541 unsigned int framecnt
,
542 unsigned int qdisc_bypass
,
543 struct pmd_internals
**internals
,
544 struct rte_eth_dev
**eth_dev
,
545 struct rte_kvargs
*kvlist
)
547 const char *name
= rte_vdev_device_name(dev
);
548 const unsigned int numa_node
= dev
->device
.numa_node
;
549 struct rte_eth_dev_data
*data
= NULL
;
550 struct rte_kvargs_pair
*pair
= NULL
;
554 struct sockaddr_ll sockaddr
;
555 struct tpacket_req
*req
;
556 struct pkt_rx_queue
*rx_queue
;
557 struct pkt_tx_queue
*tx_queue
;
558 int rc
, tpver
, discard
;
560 unsigned int i
, q
, rdsize
;
561 #if defined(PACKET_FANOUT)
565 for (k_idx
= 0; k_idx
< kvlist
->count
; k_idx
++) {
566 pair
= &kvlist
->pairs
[k_idx
];
567 if (strstr(pair
->key
, ETH_AF_PACKET_IFACE_ARG
) != NULL
)
572 "%s: no interface specified for AF_PACKET ethdev",
578 "%s: creating AF_PACKET-backed ethdev on numa socket %u",
581 *internals
= rte_zmalloc_socket(name
, sizeof(**internals
),
583 if (*internals
== NULL
)
586 for (q
= 0; q
< nb_queues
; q
++) {
587 (*internals
)->rx_queue
[q
].map
= MAP_FAILED
;
588 (*internals
)->tx_queue
[q
].map
= MAP_FAILED
;
591 req
= &((*internals
)->req
);
593 req
->tp_block_size
= blocksize
;
594 req
->tp_block_nr
= blockcnt
;
595 req
->tp_frame_size
= framesize
;
596 req
->tp_frame_nr
= framecnt
;
598 ifnamelen
= strlen(pair
->value
);
599 if (ifnamelen
< sizeof(ifr
.ifr_name
)) {
600 memcpy(ifr
.ifr_name
, pair
->value
, ifnamelen
);
601 ifr
.ifr_name
[ifnamelen
] = '\0';
604 "%s: I/F name too long (%s)",
608 if (ioctl(sockfd
, SIOCGIFINDEX
, &ifr
) == -1) {
610 "%s: ioctl failed (SIOCGIFINDEX)",
614 (*internals
)->if_name
= strdup(pair
->value
);
615 if ((*internals
)->if_name
== NULL
)
617 (*internals
)->if_index
= ifr
.ifr_ifindex
;
619 if (ioctl(sockfd
, SIOCGIFHWADDR
, &ifr
) == -1) {
621 "%s: ioctl failed (SIOCGIFHWADDR)",
625 memcpy(&(*internals
)->eth_addr
, ifr
.ifr_hwaddr
.sa_data
, ETH_ALEN
);
627 memset(&sockaddr
, 0, sizeof(sockaddr
));
628 sockaddr
.sll_family
= AF_PACKET
;
629 sockaddr
.sll_protocol
= htons(ETH_P_ALL
);
630 sockaddr
.sll_ifindex
= (*internals
)->if_index
;
632 #if defined(PACKET_FANOUT)
633 fanout_arg
= (getpid() ^ (*internals
)->if_index
) & 0xffff;
634 fanout_arg
|= (PACKET_FANOUT_HASH
| PACKET_FANOUT_FLAG_DEFRAG
) << 16;
635 #if defined(PACKET_FANOUT_FLAG_ROLLOVER)
636 fanout_arg
|= PACKET_FANOUT_FLAG_ROLLOVER
<< 16;
640 for (q
= 0; q
< nb_queues
; q
++) {
641 /* Open an AF_PACKET socket for this queue... */
642 qsockfd
= socket(AF_PACKET
, SOCK_RAW
, htons(ETH_P_ALL
));
645 "%s: could not open AF_PACKET socket",
651 rc
= setsockopt(qsockfd
, SOL_PACKET
, PACKET_VERSION
,
652 &tpver
, sizeof(tpver
));
655 "%s: could not set PACKET_VERSION on AF_PACKET socket for %s",
661 rc
= setsockopt(qsockfd
, SOL_PACKET
, PACKET_LOSS
,
662 &discard
, sizeof(discard
));
665 "%s: could not set PACKET_LOSS on AF_PACKET socket for %s",
670 #if defined(PACKET_QDISC_BYPASS)
671 rc
= setsockopt(qsockfd
, SOL_PACKET
, PACKET_QDISC_BYPASS
,
672 &qdisc_bypass
, sizeof(qdisc_bypass
));
675 "%s: could not set PACKET_QDISC_BYPASS on AF_PACKET socket for %s",
680 RTE_SET_USED(qdisc_bypass
);
683 rc
= setsockopt(qsockfd
, SOL_PACKET
, PACKET_RX_RING
, req
, sizeof(*req
));
686 "%s: could not set PACKET_RX_RING on AF_PACKET socket for %s",
691 rc
= setsockopt(qsockfd
, SOL_PACKET
, PACKET_TX_RING
, req
, sizeof(*req
));
694 "%s: could not set PACKET_TX_RING on AF_PACKET "
695 "socket for %s", name
, pair
->value
);
699 rx_queue
= &((*internals
)->rx_queue
[q
]);
700 rx_queue
->framecount
= req
->tp_frame_nr
;
702 rx_queue
->map
= mmap(NULL
, 2 * req
->tp_block_size
* req
->tp_block_nr
,
703 PROT_READ
| PROT_WRITE
, MAP_SHARED
| MAP_LOCKED
,
705 if (rx_queue
->map
== MAP_FAILED
) {
707 "%s: call to mmap failed on AF_PACKET socket for %s",
712 /* rdsize is same for both Tx and Rx */
713 rdsize
= req
->tp_frame_nr
* sizeof(*(rx_queue
->rd
));
715 rx_queue
->rd
= rte_zmalloc_socket(name
, rdsize
, 0, numa_node
);
716 if (rx_queue
->rd
== NULL
)
718 for (i
= 0; i
< req
->tp_frame_nr
; ++i
) {
719 rx_queue
->rd
[i
].iov_base
= rx_queue
->map
+ (i
* framesize
);
720 rx_queue
->rd
[i
].iov_len
= req
->tp_frame_size
;
722 rx_queue
->sockfd
= qsockfd
;
724 tx_queue
= &((*internals
)->tx_queue
[q
]);
725 tx_queue
->framecount
= req
->tp_frame_nr
;
726 tx_queue
->frame_data_size
= req
->tp_frame_size
;
727 tx_queue
->frame_data_size
-= TPACKET2_HDRLEN
-
728 sizeof(struct sockaddr_ll
);
730 tx_queue
->map
= rx_queue
->map
+ req
->tp_block_size
* req
->tp_block_nr
;
732 tx_queue
->rd
= rte_zmalloc_socket(name
, rdsize
, 0, numa_node
);
733 if (tx_queue
->rd
== NULL
)
735 for (i
= 0; i
< req
->tp_frame_nr
; ++i
) {
736 tx_queue
->rd
[i
].iov_base
= tx_queue
->map
+ (i
* framesize
);
737 tx_queue
->rd
[i
].iov_len
= req
->tp_frame_size
;
739 tx_queue
->sockfd
= qsockfd
;
741 rc
= bind(qsockfd
, (const struct sockaddr
*)&sockaddr
, sizeof(sockaddr
));
744 "%s: could not bind AF_PACKET socket to %s",
749 #if defined(PACKET_FANOUT)
750 rc
= setsockopt(qsockfd
, SOL_PACKET
, PACKET_FANOUT
,
751 &fanout_arg
, sizeof(fanout_arg
));
754 "%s: could not set PACKET_FANOUT on AF_PACKET socket "
755 "for %s", name
, pair
->value
);
761 /* reserve an ethdev entry */
762 *eth_dev
= rte_eth_vdev_allocate(dev
, 0);
763 if (*eth_dev
== NULL
)
767 * now put it all together
768 * - store queue data in internals,
769 * - store numa_node in eth_dev
770 * - point eth_dev_data to internals
771 * - and point eth_dev structure to new eth_dev_data structure
774 (*internals
)->nb_queues
= nb_queues
;
776 data
= (*eth_dev
)->data
;
777 data
->dev_private
= *internals
;
778 data
->nb_rx_queues
= (uint16_t)nb_queues
;
779 data
->nb_tx_queues
= (uint16_t)nb_queues
;
780 data
->dev_link
= pmd_link
;
781 data
->mac_addrs
= &(*internals
)->eth_addr
;
783 (*eth_dev
)->dev_ops
= &ops
;
790 for (q
= 0; q
< nb_queues
; q
++) {
791 munmap((*internals
)->rx_queue
[q
].map
,
792 2 * req
->tp_block_size
* req
->tp_block_nr
);
794 rte_free((*internals
)->rx_queue
[q
].rd
);
795 rte_free((*internals
)->tx_queue
[q
].rd
);
796 if (((*internals
)->rx_queue
[q
].sockfd
!= 0) &&
797 ((*internals
)->rx_queue
[q
].sockfd
!= qsockfd
))
798 close((*internals
)->rx_queue
[q
].sockfd
);
800 free((*internals
)->if_name
);
801 rte_free(*internals
);
806 rte_eth_from_packet(struct rte_vdev_device
*dev
,
808 struct rte_kvargs
*kvlist
)
810 const char *name
= rte_vdev_device_name(dev
);
811 struct pmd_internals
*internals
= NULL
;
812 struct rte_eth_dev
*eth_dev
= NULL
;
813 struct rte_kvargs_pair
*pair
= NULL
;
815 unsigned int blockcount
;
816 unsigned int blocksize
= DFLT_BLOCK_SIZE
;
817 unsigned int framesize
= DFLT_FRAME_SIZE
;
818 unsigned int framecount
= DFLT_FRAME_COUNT
;
819 unsigned int qpairs
= 1;
820 unsigned int qdisc_bypass
= 1;
822 /* do some parameter checking */
827 * Walk arguments for configurable settings
829 for (k_idx
= 0; k_idx
< kvlist
->count
; k_idx
++) {
830 pair
= &kvlist
->pairs
[k_idx
];
831 if (strstr(pair
->key
, ETH_AF_PACKET_NUM_Q_ARG
) != NULL
) {
832 qpairs
= atoi(pair
->value
);
834 qpairs
> RTE_PMD_AF_PACKET_MAX_RINGS
) {
836 "%s: invalid qpairs value",
842 if (strstr(pair
->key
, ETH_AF_PACKET_BLOCKSIZE_ARG
) != NULL
) {
843 blocksize
= atoi(pair
->value
);
846 "%s: invalid blocksize value",
852 if (strstr(pair
->key
, ETH_AF_PACKET_FRAMESIZE_ARG
) != NULL
) {
853 framesize
= atoi(pair
->value
);
856 "%s: invalid framesize value",
862 if (strstr(pair
->key
, ETH_AF_PACKET_FRAMECOUNT_ARG
) != NULL
) {
863 framecount
= atoi(pair
->value
);
866 "%s: invalid framecount value",
872 if (strstr(pair
->key
, ETH_AF_PACKET_QDISC_BYPASS_ARG
) != NULL
) {
873 qdisc_bypass
= atoi(pair
->value
);
874 if (qdisc_bypass
> 1) {
876 "%s: invalid bypass value",
884 if (framesize
> blocksize
) {
886 "%s: AF_PACKET MMAP frame size exceeds block size!",
891 blockcount
= framecount
/ (blocksize
/ framesize
);
894 "%s: invalid AF_PACKET MMAP parameters", name
);
898 PMD_LOG(INFO
, "%s: AF_PACKET MMAP parameters:", name
);
899 PMD_LOG(INFO
, "%s:\tblock size %d", name
, blocksize
);
900 PMD_LOG(INFO
, "%s:\tblock count %d", name
, blockcount
);
901 PMD_LOG(INFO
, "%s:\tframe size %d", name
, framesize
);
902 PMD_LOG(INFO
, "%s:\tframe count %d", name
, framecount
);
904 if (rte_pmd_init_internals(dev
, *sockfd
, qpairs
,
905 blocksize
, blockcount
,
906 framesize
, framecount
,
908 &internals
, ð_dev
,
912 eth_dev
->rx_pkt_burst
= eth_af_packet_rx
;
913 eth_dev
->tx_pkt_burst
= eth_af_packet_tx
;
915 rte_eth_dev_probing_finish(eth_dev
);
920 rte_pmd_af_packet_probe(struct rte_vdev_device
*dev
)
923 struct rte_kvargs
*kvlist
;
925 struct rte_eth_dev
*eth_dev
;
926 const char *name
= rte_vdev_device_name(dev
);
928 PMD_LOG(INFO
, "Initializing pmd_af_packet for %s", name
);
930 if (rte_eal_process_type() == RTE_PROC_SECONDARY
&&
931 strlen(rte_vdev_device_args(dev
)) == 0) {
932 eth_dev
= rte_eth_dev_attach_secondary(name
);
934 PMD_LOG(ERR
, "Failed to probe %s", name
);
937 /* TODO: request info from primary to set up Rx and Tx */
938 eth_dev
->dev_ops
= &ops
;
939 eth_dev
->device
= &dev
->device
;
940 rte_eth_dev_probing_finish(eth_dev
);
944 kvlist
= rte_kvargs_parse(rte_vdev_device_args(dev
), valid_arguments
);
945 if (kvlist
== NULL
) {
951 * If iface argument is passed we open the NICs and use them for
954 if (rte_kvargs_count(kvlist
, ETH_AF_PACKET_IFACE_ARG
) == 1) {
956 ret
= rte_kvargs_process(kvlist
, ETH_AF_PACKET_IFACE_ARG
,
957 &open_packet_iface
, &sockfd
);
962 if (dev
->device
.numa_node
== SOCKET_ID_ANY
)
963 dev
->device
.numa_node
= rte_socket_id();
965 ret
= rte_eth_from_packet(dev
, &sockfd
, kvlist
);
966 close(sockfd
); /* no longer needed */
969 rte_kvargs_free(kvlist
);
974 rte_pmd_af_packet_remove(struct rte_vdev_device
*dev
)
976 struct rte_eth_dev
*eth_dev
= NULL
;
977 struct pmd_internals
*internals
;
980 PMD_LOG(INFO
, "Closing AF_PACKET ethdev on numa socket %u",
986 /* find the ethdev entry */
987 eth_dev
= rte_eth_dev_allocated(rte_vdev_device_name(dev
));
991 internals
= eth_dev
->data
->dev_private
;
992 for (q
= 0; q
< internals
->nb_queues
; q
++) {
993 rte_free(internals
->rx_queue
[q
].rd
);
994 rte_free(internals
->tx_queue
[q
].rd
);
996 free(internals
->if_name
);
998 rte_free(eth_dev
->data
->dev_private
);
1000 rte_eth_dev_release_port(eth_dev
);
1005 static struct rte_vdev_driver pmd_af_packet_drv
= {
1006 .probe
= rte_pmd_af_packet_probe
,
1007 .remove
= rte_pmd_af_packet_remove
,
1010 RTE_PMD_REGISTER_VDEV(net_af_packet
, pmd_af_packet_drv
);
1011 RTE_PMD_REGISTER_ALIAS(net_af_packet
, eth_af_packet
);
1012 RTE_PMD_REGISTER_PARAM_STRING(net_af_packet
,
1018 "qdisc_bypass=<0|1>");
1020 RTE_INIT(af_packet_init_log
)
1022 af_packet_logtype
= rte_log_register("pmd.net.packet");
1023 if (af_packet_logtype
>= 0)
1024 rte_log_set_level(af_packet_logtype
, RTE_LOG_NOTICE
);