eth: fbnic: Add XDP support for fbnic
Subsystems (5)
v3 cover eth: fbnic: Add XDP support for fbnic
This patch series introduces basic XDP support for fbnic. To enable this, it also includes preparatory changes such as making the HDS threshold configurable via ethtool, updating headroom for fbnic, tracking frag state in shinfo, and prefetching the first cacheline of data.
---
Changelog:
V3:
* P1: Add missing constant causing transient build failure
* P1: Fix rcq_ctl config when hds_thresh is less than FBNIC_HDR_BYTES_MIN
* P1: Update commit message to add hds.py results from selftest
V2: https://lore.kernel.org/netdev/[email protected]/
V1: https://lore.kernel.org/netdev/[email protected]/
Mohsin Bashir (9):
eth: fbnic: Add support for HDS configuration
eth: fbnic: Update Headroom
eth: fbnic: Use shinfo to track frags state on Rx
eth: fbnic: Prefetch packet headers on Rx
eth: fbnic: Add XDP pass, drop, abort support
eth: fbnic: Add support for XDP queues
eth: fbnic: Add support for XDP_TX action
eth: fbnic: Collect packet statistics for XDP
eth: fbnic: Report XDP stats via ethtool
.../device_drivers/ethernet/meta/fbnic.rst | 11 + .../net/ethernet/meta/fbnic/fbnic_ethtool.c | 82 +++- .../net/ethernet/meta/fbnic/fbnic_netdev.c | 75 ++- .../net/ethernet/meta/fbnic/fbnic_netdev.h | 9 +- drivers/net/ethernet/meta/fbnic/fbnic_txrx.c | 458 +++++++++++++++--- drivers/net/ethernet/meta/fbnic/fbnic_txrx.h | 23 +- 6 files changed, 576 insertions(+), 82 deletions(-)
Signature · 1 line
2.47.3
PATCH v3 1/9 eth: fbnic: Add support for HDS configuration
Add support for configuring the header data split threshold. For fbnic, the tcp data split support is enabled all the time.
Fbnic supports a maximum buffer size of 4KB. However, the reservation for the headroom, tailroom, and padding reduce the max header size accordingly.
ethtool_hds -g eth0
Ring parameters for eth0:
Pre-set maximums:
...
HDS thresh: 3584
Current hardware settings:
...
HDS thresh: 1536
Verify hds tests in ksft-net-drv are passing
ksft-net-drv]# ./drivers/net/hds.py
TAP version 13
1..13
ok 1 hds.get_hds
ok 2 hds.get_hds_thresh
ok 3 hds.set_hds_disable # SKIP disabling of HDS not supported by ...
...
...
ok 12 hds.ioctl_set_xdp
ok 13 hds.ioctl_enabled_set_xdp
\# Totals: pass:12 fail:0 xfail:0 xpass:0 skip:1 error:0
--- .../net/ethernet/meta/fbnic/fbnic_ethtool.c | 21 ++++++++++++++++--- .../net/ethernet/meta/fbnic/fbnic_netdev.c | 4 ++++ .../net/ethernet/meta/fbnic/fbnic_netdev.h | 2 ++ drivers/net/ethernet/meta/fbnic/fbnic_txrx.c | 17 +++++++++++---- drivers/net/ethernet/meta/fbnic/fbnic_txrx.h | 7 ++++++- 5 files changed, 43 insertions(+), 8 deletions(-)
drivers/net/ethernet/meta/fbnic/fbnic_ethtool.c +18 -3
@@ -2,6 +2,7 @@/* Copyright (c) Meta Platforms, Inc. and affiliates. */ #include <linux/ethtool.h> +#include <linux/ethtool_netlink.h> #include <linux/netdevice.h> #include <linux/pci.h> #include <net/ipv6.h>
@@ -160,6 +161,7 @@ static void fbnic_clone_swap_cfg(struct fbnic_net *orig,swap (clone->num_rx_queues, orig->num_rx_queues);swap (clone->num_tx_queues, orig->num_tx_queues);swap (clone->num_napi, orig->num_napi); +swap (clone->hds_thresh, orig->hds_thresh); } static void fbnic_aggregate_vector_counters(struct fbnic_net *fbn,
@@ -277,15 +279,21 @@ fbnic_get_ringparam(struct net_device *netdev, struct ethtool_ringparam *ring, ring->rx_mini_pending = fbn->hpq_size; ring->rx_jumbo_pending = fbn->ppq_size; ring->tx_pending = fbn->txq_size; + + kernel_ring->tcp_data_split =ETHTOOL_TCP_DATA_SPLIT_ENABLED ; + kernel_ring->hds_thresh_max =FBNIC_HDS_THRESH_MAX ; + kernel_ring->hds_thresh = fbn->hds_thresh; }static void fbnic_set_rings (struct fbnic_net *fbn, -struct ethtool_ringparam *ring) +struct ethtool_ringparam *ring, +struct kernel_ethtool_ringparam *kernel_ring) { fbn->rcq_size = ring->rx_pending; fbn->hpq_size = ring->rx_mini_pending; fbn->ppq_size = ring->rx_jumbo_pending; fbn->txq_size = ring->tx_pending; + fbn->hds_thresh = kernel_ring->hds_thresh; } static int
@@ -316,8 +324,13 @@ fbnic_set_ringparam(struct net_device *netdev, struct ethtool_ringparam *ring,return -EINVAL ; } +if (kernel_ring->tcp_data_split ==ETHTOOL_TCP_DATA_SPLIT_DISABLED ) { +NL_SET_ERR_MSG_MOD (extack,"Cannot disable TCP data split" ); +return -EINVAL ; + } +if (!netif_running (netdev)) { -fbnic_set_rings (fbn, ring); +fbnic_set_rings (fbn, ring, kernel_ring);return 0 ; }
@@ -325,7 +338,7 @@ fbnic_set_ringparam(struct net_device *netdev, struct ethtool_ringparam *ring,if (!clone)return -ENOMEM ; -fbnic_set_rings (clone, ring); +fbnic_set_rings (clone, ring, kernel_ring); err =fbnic_alloc_napi_vectors (clone);if (err)
@@ -1678,6 +1691,8 @@ fbnic_get_rmon_stats(struct net_device *netdev,static const struct ethtool_ops fbnic_ethtool_ops = { .supported_coalesce_params =ETHTOOL_COALESCE_USECS |ETHTOOL_COALESCE_RX_MAX_FRAMES , + .supported_ring_params =ETHTOOL_RING_USE_TCP_DATA_SPLIT | +ETHTOOL_RING_USE_HDS_THRS , .rxfh_max_num_contexts =FBNIC_RPC_RSS_TBL_COUNT , .get_drvinfo = fbnic_get_drvinfo, .get_regs_len = fbnic_get_regs_len,
drivers/net/ethernet/meta/fbnic/fbnic_netdev.c +4 -0
@@ -695,6 +695,10 @@ struct net_device *fbnic_netdev_alloc(struct fbnic_dev *fbd) fbn->rx_usecs =FBNIC_RX_USECS_DEFAULT ; fbn->rx_max_frames =FBNIC_RX_FRAMES_DEFAULT ; +/* Initialize the hds_thresh */ + netdev->cfg->hds_thresh =FBNIC_HDS_THRESH_DEFAULT ; + fbn->hds_thresh =FBNIC_HDS_THRESH_DEFAULT ; + default_queues =netif_get_num_default_rss_queues ();if (default_queues > fbd->max_num_queues) default_queues = fbd->max_num_queues;
drivers/net/ethernet/meta/fbnic/fbnic_netdev.h +2 -0
@@ -31,6 +31,8 @@ struct fbnic_net {u32 ppq_size;u32 rcq_size; +u32 hds_thresh; +u16 rx_usecs;u16 tx_usecs;
drivers/net/ethernet/meta/fbnic/fbnic_txrx.c +13 -4
@@ -2232,13 +2232,22 @@ static void fbnic_enable_rcq(struct fbnic_napi_vector *nv, {struct fbnic_net *fbn =netdev_priv (nv->napi.dev);u32 log_size =fls (rcq->size_mask); -u32 rcq_ctl; +u32 hds_thresh = fbn->hds_thresh; +u32 rcq_ctl =0 ;fbnic_config_drop_mode_rcq (nv, rcq); - rcq_ctl =FIELD_PREP (FBNIC_QUEUE_RDE_CTL1_PADLEN_MASK ,FBNIC_RX_PAD ) | -FIELD_PREP (FBNIC_QUEUE_RDE_CTL1_MAX_HDR_MASK , -FBNIC_RX_MAX_HDR ) | +/* Force lower bound on MAX_HEADER_BYTES. Below this, all frames should +* be split at L4. It would also result in the frames being split at +* L2/L3 depending on the frame size. +*/ +if (fbn->hds_thresh <FBNIC_HDR_BYTES_MIN ) { + rcq_ctl =FBNIC_QUEUE_RDE_CTL0_EN_HDR_SPLIT ; + hds_thresh =FBNIC_HDR_BYTES_MIN ; + } + + rcq_ctl |=FIELD_PREP (FBNIC_QUEUE_RDE_CTL1_PADLEN_MASK ,FBNIC_RX_PAD ) | +FIELD_PREP (FBNIC_QUEUE_RDE_CTL1_MAX_HDR_MASK , hds_thresh) |FIELD_PREP (FBNIC_QUEUE_RDE_CTL1_PAYLD_OFF_MASK ,FBNIC_RX_PAYLD_OFFSET ) | FIELD_PREP(FBNIC_QUEUE_RDE_CTL1_PAYLD_PG_CL_MASK,
drivers/net/ethernet/meta/fbnic/fbnic_txrx.h +6 -1
@@ -53,7 +53,6 @@ struct fbnic_net;#define FBNIC_RX_HROOM \ (ALIGN(FBNIC_RX_TROOM + NET_SKB_PAD, 128) - FBNIC_RX_TROOM)#define FBNIC_RX_PAD 0 -#define FBNIC_RX_MAX_HDR (1536 - FBNIC_RX_PAD)#define FBNIC_RX_PAYLD_OFFSET 0#define FBNIC_RX_PAYLD_PG_CL 0
@@ -61,6 +60,12 @@ struct fbnic_net;#define FBNIC_RING_F_CTX BIT(1)#define FBNIC_RING_F_STATS BIT(2)/* Ring's stats may be used */ +#define FBNIC_HDS_THRESH_MAX \ + (4096 - FBNIC_RX_HROOM - FBNIC_RX_TROOM - FBNIC_RX_PAD) +#define FBNIC_HDS_THRESH_DEFAULT \ + (1536 - FBNIC_RX_PAD) +#define FBNIC_HDR_BYTES_MIN 128 +struct fbnic_pkt_buff {struct xdp_buff buff;ktime_t hwtstamp;
Signature · 1 line
2.47.3
PATCH v3 2/9 eth: fbnic: Update Headroom
In reply to Mohsin BashirFbnic currently reserves a minimum of 64B headroom, but this is insufficient for inserting additional headers (e.g., IPV6) via XDP, as only 24 bytes are available for adjustment. To address this limitation, increase the headroom to a larger value while ensuring better page use. Although the resulting headroom (192B) is smaller than the recommended value (256B), forcing the headroom to 256B would require aligning to 256B (as opposed to the current 128B), which can push the max headroom to 511B.
--- drivers/net/ethernet/meta/fbnic/fbnic_txrx.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/net/ethernet/meta/fbnic/fbnic_txrx.h +2 -1
@@ -50,8 +50,9 @@ struct fbnic_net;#define FBNIC_RX_TROOM \ SKB_DATA_ALIGN(sizeof(struct skb_shared_info)) +#define FBNIC_RX_HROOM_PAD 128#define FBNIC_RX_HROOM \ - (ALIGN(FBNIC_RX_TROOM + NET_SKB_PAD, 128) - FBNIC_RX_TROOM) + (ALIGN(FBNIC_RX_TROOM + FBNIC_RX_HROOM_PAD, 128) - FBNIC_RX_TROOM)#define FBNIC_RX_PAD 0#define FBNIC_RX_PAYLD_OFFSET 0#define FBNIC_RX_PAYLD_PG_CL 0
Signature · 1 line
2.47.3
PATCH v3 3/9 eth: fbnic: Use shinfo to track frags state on Rx
In reply to Mohsin BashirRemove local fields that track frags state and instead store this information directly in the shinfo struct. This change is necessary because the current implementation can lead to inaccuracies in certain scenarios, such as when using XDP multi-buff support. Specifically, the XDP program may update nr_frags without updating the local variables, resulting in an inconsistent state.
--- drivers/net/ethernet/meta/fbnic/fbnic_txrx.c | 80 ++++++-------------- drivers/net/ethernet/meta/fbnic/fbnic_txrx.h | 4 +- 2 files changed, 26 insertions(+), 58 deletions(-)
drivers/net/ethernet/meta/fbnic/fbnic_txrx.c +25 -55
@@ -892,9 +892,8 @@ static void fbnic_pkt_prepare(struct fbnic_napi_vector *nv, u64 rcd,xdp_prepare_buff (&pkt->buff, hdr_start, headroom, len -FBNIC_RX_PAD , true); - pkt->data_truesize =0 ; - pkt->data_len =0 ; - pkt->nr_frags =0 ; + pkt->hwtstamp =0 ; + pkt->add_frag_failed = false; } static void fbnic_add_rx_frag(struct fbnic_napi_vector *nv, u64 rcd,
@@ -905,8 +904,8 @@ static void fbnic_add_rx_frag(struct fbnic_napi_vector *nv, u64 rcd,unsigned int pg_off =FIELD_GET (FBNIC_RCD_AL_BUFF_OFF_MASK , rcd);unsigned int len =FIELD_GET (FBNIC_RCD_AL_BUFF_LEN_MASK , rcd);struct page *page =fbnic_page_pool_get (&qt->sub1, pg_idx); -struct skb_shared_info *shinfo;unsigned int truesize; +bool added; truesize =FIELD_GET (FBNIC_RCD_AL_PAGE_FIN , rcd) ?FBNIC_BD_FRAG_SIZE - pg_off :ALIGN (len,128 );
@@ -918,34 +917,34 @@ static void fbnic_add_rx_frag(struct fbnic_napi_vector *nv, u64 rcd,dma_sync_single_range_for_cpu (nv->dev,page_pool_get_dma_addr (page), pg_off, truesize,DMA_BIDIRECTIONAL ); -/* Add page to xdp shared info */ - shinfo =xdp_get_shared_info_from_buff (&pkt->buff); - -/* We use gso_segs to store truesize */ - pkt->data_truesize += truesize; - -__skb_fill_page_desc_noacc (shinfo, pkt->nr_frags++, page, pg_off, len); - -/* Store data_len in gso_size */ - pkt->data_len += len; + added =xdp_buff_add_frag (&pkt->buff,page_to_netmem (page), pg_off, len, + truesize); +if (unlikely (!added)) { + pkt->add_frag_failed = true; +netdev_err_once (nv->napi.dev, +"Failed to add fragment to xdp_buff\n" ); + } }static void fbnic_put_pkt_buff (struct fbnic_napi_vector *nv,struct fbnic_pkt_buff *pkt,int budget) { -struct skb_shared_info *shinfo;struct page *page; -int nr_frags;if (!pkt->buff.data_hard_start)return ; - shinfo =xdp_get_shared_info_from_buff (&pkt->buff); - nr_frags = pkt->nr_frags; +if (xdp_buff_has_frags (&pkt->buff)) { +struct skb_shared_info *shinfo; +int nr_frags; -while (nr_frags--) { - page =skb_frag_page (&shinfo->frags[nr_frags]); -page_pool_put_full_page (nv->page_pool, page, !!budget); + shinfo =xdp_get_shared_info_from_buff (&pkt->buff); + nr_frags = shinfo->nr_frags; + +while (nr_frags--) { + page =skb_frag_page (&shinfo->frags[nr_frags]); +page_pool_put_full_page (nv->page_pool, page, !!budget); + } } page =virt_to_page (pkt->buff.data_hard_start);
@@ -955,43 +954,12 @@ static void fbnic_put_pkt_buff(struct fbnic_napi_vector *nv,static struct sk_buff *fbnic_build_skb (struct fbnic_napi_vector *nv,struct fbnic_pkt_buff *pkt) { -unsigned int nr_frags = pkt->nr_frags; -struct skb_shared_info *shinfo; -unsigned int truesize;struct sk_buff *skb; - truesize =xdp_data_hard_end (&pkt->buff) +FBNIC_RX_TROOM - - pkt->buff.data_hard_start; - -/* Build frame around buffer */ - skb =napi_build_skb (pkt->buff.data_hard_start, truesize); -if (unlikely (!skb)) + skb =xdp_build_skb_from_buff (&pkt->buff); +if (!skb)return NULL ; -/* Push data pointer to start of data, put tail to end of data */ -skb_reserve (skb, pkt->buff.data - pkt->buff.data_hard_start); -__skb_put (skb, pkt->buff.data_end - pkt->buff.data); - -/* Add tracking for metadata at the start of the frame */ -skb_metadata_set (skb, pkt->buff.data - pkt->buff.data_meta); - -/* Add Rx frags */ -if (nr_frags) { -/* Verify that shared info didn't move */ - shinfo =xdp_get_shared_info_from_buff (&pkt->buff); -WARN_ON (skb_shinfo (skb) != shinfo); - - skb->truesize += pkt->data_truesize; - skb->data_len += pkt->data_len; - shinfo->nr_frags = nr_frags; - skb->len += pkt->data_len; - } - -skb_mark_for_recycle (skb); - -/* Set MAC header specific fields */ - skb->protocol =eth_type_trans (skb, nv->napi.dev); -/* Add timestamp if present */ if (pkt->hwtstamp)skb_hwtstamps (skb)->hwtstamp = pkt->hwtstamp;
@@ -1094,7 +1062,9 @@ static int fbnic_clean_rcq(struct fbnic_napi_vector *nv,/* We currently ignore the action table index */ break ;case FBNIC_RCD_TYPE_META : -if (likely (!fbnic_rcd_metadata_err (rcd))) +if (unlikely (pkt->add_frag_failed)) + skb =NULL ; +else if (likely (!fbnic_rcd_metadata_err (rcd))) skb =fbnic_build_skb (nv, pkt);/* Populate skb and invalidate XDP */
drivers/net/ethernet/meta/fbnic/fbnic_txrx.h +1 -3
@@ -70,9 +70,7 @@ struct fbnic_net;struct fbnic_pkt_buff {struct xdp_buff buff;ktime_t hwtstamp; -u32 data_truesize; -u16 data_len; -u16 nr_frags; +bool add_frag_failed; };struct fbnic_queue_stats {
Signature · 1 line
2.47.3
PATCH v3 4/9 eth: fbnic: Prefetch packet headers on Rx
In reply to Mohsin BashirIssue a prefetch for the start of the buffer on Rx to try to avoid cache miss on packet headers.
--- drivers/net/ethernet/meta/fbnic/fbnic_txrx.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/net/ethernet/meta/fbnic/fbnic_txrx.c +1 -1
@@ -888,7 +888,7 @@ static void fbnic_pkt_prepare(struct fbnic_napi_vector *nv, u64 rcd,/* Build frame around buffer */ hdr_start =page_address (page) + hdr_pg_start; - +net_prefetch (pkt->buff.data);xdp_prepare_buff (&pkt->buff, hdr_start, headroom, len -FBNIC_RX_PAD , true);
Signature · 1 line
2.47.3
PATCH v3 5/9 eth: fbnic: Add XDP pass, drop, abort support
In reply to Mohsin BashirAdd basic support for attaching an XDP program to the device and support for PASS/DROP/ABORT actions. In fbnic, buffers are always mapped as DMA_BIDIRECTIONAL.
The BPF program pointer can be read either on a per-packet basis or on a per-NAPI poll basis. Both approaches are functionally equivalent, in the current code. Stick to per-packet as it limits number of arguments we need to pass around.
On the XDP hot path, check that packets with fragments are only allowed when multi-buffer support is enabled for the XDP program. Ideally, this check should not be necessary because ndo_bpf verifies that for XDP programs without multi-buff support, MTU is less than the hds_thresh. However, the MTU currently does not enforce the receive size which would require cleaning up the data path and bouncing the link. For practical reasons, prioritize the ability to enter and exit BPF mode with different MTU sizes without requiring a full reconfig.
Testing:
Hook a simple XDP program that passes all the packets destined for a specific port
iperf3 -c 192.168.1.10 -P 5 -p 12345
Connecting to host 192.168.1.10, port 12345
[ 5] local 192.168.1.9 port 46702 connected to 192.168.1.10 port 12345
[ ID] Interval Transfer Bitrate Retr Cwnd
- - - - - - - - - - - - - - - - - - - - - - - - -
[SUM] 1.00-2.00 sec 3.86 GBytes 33.2 Gbits/sec 0
XDP_DROP:
Hook an XDP program that drops packets destined for a specific port
iperf3 -c 192.168.1.10 -P 5 -p 12345
^C- - - - - - - - - - - - - - - - - - - - - - - - -
[ ID] Interval Transfer Bitrate Retr [SUM] 0.00-0.00 sec 0.00 Bytes 0.00 bits/sec 0 sender [SUM] 0.00-0.00 sec 0.00 Bytes 0.00 bits/sec receiver
iperf3: interrupt - the client has terminated
XDP with HDS:
- Validate XDP attachment failure when HDS is low
~] ethtool -G eth0 hds-thresh 512
~] sudo ip link set eth0 xdpdrv obj xdp_pass_12345.o sec xdp ~] Error: fbnic: MTU too high, or HDS threshold is too low for single
buffer XDP.
- Validate successful XDP attachment when HDS threshold is appropriate ~] ethtool -G eth0 hds-thresh 1536
~] sudo ip link set eth0 xdpdrv obj xdp_pass_12345.o sec xdp
- Validate when the XDP program is attached, changing HDS thresh to a lower value fails
~] ethtool -G eth0 hds-thresh 512
~] netlink error: fbnic: Use higher HDS threshold or multi-buf capable
program
- Validate HDS thresh does not matter when xdp frags support is available
~] ethtool -G eth0 hds-thresh 512
~] sudo ip link set eth0 xdpdrv obj xdp_pass_mb_12345.o sec xdp.frags
--- .../net/ethernet/meta/fbnic/fbnic_ethtool.c | 11 +++ .../net/ethernet/meta/fbnic/fbnic_netdev.c | 35 +++++++ .../net/ethernet/meta/fbnic/fbnic_netdev.h | 5 + drivers/net/ethernet/meta/fbnic/fbnic_txrx.c | 96 +++++++++++++++++-- drivers/net/ethernet/meta/fbnic/fbnic_txrx.h | 1 + 5 files changed, 141 insertions(+), 7 deletions(-)
drivers/net/ethernet/meta/fbnic/fbnic_ethtool.c +11 -0
@@ -329,6 +329,17 @@ fbnic_set_ringparam(struct net_device *netdev, struct ethtool_ringparam *ring,return -EINVAL ; } +/* If an XDP program is attached, we should check for potential frame +* splitting. If the new HDS threshold can cause splitting, we should +* only allow if the attached XDP program can handle frags. +*/ +if (fbnic_check_split_frames (fbn->xdp_prog, netdev->mtu, + kernel_ring->hds_thresh)) { +NL_SET_ERR_MSG_MOD (extack, +"Use higher HDS threshold or multi-buf capable program" ); +return -EINVAL ; + } +if (!netif_running (netdev)) {fbnic_set_rings (fbn, ring, kernel_ring);return 0 ;
drivers/net/ethernet/meta/fbnic/fbnic_netdev.c +35 -0
@@ -508,6 +508,40 @@ static void fbnic_get_stats64(struct net_device *dev, } } +bool fbnic_check_split_frames (struct bpf_prog *prog,unsigned int mtu, +u32 hds_thresh) +{ +if (!prog) +return false; + +if (prog->aux->xdp_has_frags) +return false; + +return mtu +ETH_HLEN > hds_thresh; +} + +static int fbnic_bpf (struct net_device *netdev,struct netdev_bpf *bpf) +{ +struct bpf_prog *prog = bpf->prog, *prev_prog; +struct fbnic_net *fbn =netdev_priv (netdev); + +if (bpf->command !=XDP_SETUP_PROG ) +return -EINVAL ; + +if (fbnic_check_split_frames (prog, netdev->mtu, + fbn->hds_thresh)) { +NL_SET_ERR_MSG_MOD (bpf->extack, +"MTU too high, or HDS threshold is too low for single buffer XDP" ); +return -EOPNOTSUPP ; + } + + prev_prog =xchg (&fbn->xdp_prog, prog); +if (prev_prog) +bpf_prog_put (prev_prog); + +return 0 ; +} +static const struct net_device_ops fbnic_netdev_ops = { .ndo_open = fbnic_open, .ndo_stop = fbnic_stop,
@@ -517,6 +551,7 @@ static const struct net_device_ops fbnic_netdev_ops = { .ndo_set_mac_address = fbnic_set_mac, .ndo_set_rx_mode = fbnic_set_rx_mode, .ndo_get_stats64 = fbnic_get_stats64, + .ndo_bpf = fbnic_bpf, .ndo_hwtstamp_get = fbnic_hwtstamp_get, .ndo_hwtstamp_set = fbnic_hwtstamp_set, };
drivers/net/ethernet/meta/fbnic/fbnic_netdev.h +5 -0
@@ -18,6 +18,8 @@#define FBNIC_TUN_GSO_FEATURES NETIF_F_GSO_IPXIP6struct fbnic_net { +struct bpf_prog *xdp_prog; +struct fbnic_ring *tx[FBNIC_MAX_TXQS ];struct fbnic_ring *rx[FBNIC_MAX_RXQS ];
@@ -104,4 +106,7 @@ int fbnic_phylink_ethtool_ksettings_get(struct net_device *netdev,int fbnic_phylink_get_fecparam (struct net_device *netdev,struct ethtool_fecparam *fecparam);int fbnic_phylink_init (struct net_device *netdev); + +bool fbnic_check_split_frames (struct bpf_prog *prog, +unsigned int mtu,u32 hds_threshold);#endif /* _FBNIC_NETDEV_H_ */
drivers/net/ethernet/meta/fbnic/fbnic_txrx.c +89 -7
178 lines not on this page · raw message
drivers/net/ethernet/meta/fbnic/fbnic_txrx.h +1 -0
@@ -128,6 +128,7 @@ struct fbnic_ring {struct fbnic_q_triad {struct fbnic_ring sub0, sub1, cmpl; +struct xdp_rxq_info xdp_rxq; };struct fbnic_napi_vector {
Signature · 1 line
2.47.3
PATCH v3 6/9 eth: fbnic: Add support for XDP queues
In reply to Mohsin BashirAdd support for allocating XDP_TX queues and configuring ring support. FBNIC has been designed with XDP support in mind. Each Tx queue has 2 submission queues and one completion queue, with the expectation that one of the submission queues will be used by the stack, and the other by XDP. XDP queues are populated by XDP_TX and start from index 128 in the TX queue array.
The support for XDP_TX is added in the next patch.
--- .../net/ethernet/meta/fbnic/fbnic_netdev.h | 2 +- drivers/net/ethernet/meta/fbnic/fbnic_txrx.c | 139 +++++++++++++++++- drivers/net/ethernet/meta/fbnic/fbnic_txrx.h | 7 + 3 files changed, 142 insertions(+), 6 deletions(-)
drivers/net/ethernet/meta/fbnic/fbnic_netdev.h +1 -1
@@ -20,7 +20,7 @@struct fbnic_net {struct bpf_prog *xdp_prog; -struct fbnic_ring *tx[FBNIC_MAX_TXQS ]; +struct fbnic_ring *tx[FBNIC_MAX_TXQS +FBNIC_MAX_XDPQS ];struct fbnic_ring *rx[FBNIC_MAX_RXQS ];struct fbnic_napi_vector *napi[FBNIC_MAX_NAPI_VECTORS ];
drivers/net/ethernet/meta/fbnic/fbnic_txrx.c +134 -5
267 lines not on this page · raw message
drivers/net/ethernet/meta/fbnic/fbnic_txrx.h +7 -0
@@ -35,6 +35,7 @@ struct fbnic_net;#define FBNIC_MAX_TXQS 128u#define FBNIC_MAX_RXQS 128u +#define FBNIC_MAX_XDPQS 128u/* These apply to TWQs, TCQ, RCQ */ #define FBNIC_QUEUE_SIZE_MIN 16u
@@ -119,6 +120,12 @@ struct fbnic_ring {u32 head, tail;/* Head/Tail of ring */ +/* Deferred_head is used to cache the head for TWQ1 if an attempt +* is made to clean TWQ1 with zero napi_budget. We do not use it for +* any other ring. +*/ +s32 deferred_head; +struct fbnic_queue_stats stats;/* Slow path fields follow */
Signature · 1 line
2.47.3
PATCH v3 7/9 eth: fbnic: Add support for XDP_TX action
In reply to Mohsin BashirAdd support for XDP_TX action and cleaning the associated work.
--- drivers/net/ethernet/meta/fbnic/fbnic_txrx.c | 85 +++++++++++++++++++- 1 file changed, 84 insertions(+), 1 deletion(-)
drivers/net/ethernet/meta/fbnic/fbnic_txrx.c +84 -1
@@ -19,6 +19,7 @@enum {FBNIC_XDP_PASS =0 ,FBNIC_XDP_CONSUME , +FBNIC_XDP_TX ,FBNIC_XDP_LEN_ERR , };
@@ -1020,6 +1021,80 @@ static struct sk_buff *fbnic_build_skb(struct fbnic_napi_vector *nv,return skb; } +static long fbnic_pkt_tx (struct fbnic_napi_vector *nv, +struct fbnic_pkt_buff *pkt) +{ +struct fbnic_ring *ring = &nv->qt[0 ].sub1; +int size, offset, nsegs =1 , data_len =0 ; +unsigned int tail = ring->tail; +struct skb_shared_info *shinfo; +skb_frag_t *frag =NULL ; +struct page *page; +dma_addr_t dma; +__le64 *twd; + +if (unlikely (xdp_buff_has_frags (&pkt->buff))) { + shinfo =xdp_get_shared_info_from_buff (&pkt->buff); + nsegs += shinfo->nr_frags; + data_len = shinfo->xdp_frags_size; + frag = &shinfo->frags[0 ]; + } + +if (fbnic_desc_unused (ring) < nsegs) +return -FBNIC_XDP_CONSUME ; + + page =virt_to_page (pkt->buff.data_hard_start); + offset =offset_in_page (pkt->buff.data); + dma =page_pool_get_dma_addr (page); + + size = pkt->buff.data_end - pkt->buff.data; + +while (nsegs--) { +dma_sync_single_range_for_device (nv->dev, dma, offset, size, +DMA_BIDIRECTIONAL ); + dma += offset; + + ring->tx_buf[tail] = page; + + twd = &ring->desc[tail]; + *twd =cpu_to_le64 (FIELD_PREP (FBNIC_TWD_ADDR_MASK , dma) | +FIELD_PREP (FBNIC_TWD_LEN_MASK , size) | +FIELD_PREP (FBNIC_TWD_TYPE_MASK , +FBNIC_TWD_TYPE_AL )); + + tail++; + tail &= ring->size_mask; + +if (!data_len) +break ; + + offset =skb_frag_off (frag); + page =skb_frag_page (frag); + dma =page_pool_get_dma_addr (page); + + size =skb_frag_size (frag); + data_len -= size; + frag++; + } + + *twd |=FBNIC_TWD_TYPE (LAST_AL ); + + ring->tail = tail; + +return -FBNIC_XDP_TX ; +} + +static void fbnic_pkt_commit_tail (struct fbnic_napi_vector *nv, +unsigned int pkt_tail) +{ +struct fbnic_ring *ring = &nv->qt[0 ].sub1; + +/* Force DMA writes to flush before writing to tail */ +dma_wmb (); + +writel (pkt_tail, ring->doorbell); +} +static struct sk_buff *fbnic_run_xdp (struct fbnic_napi_vector *nv,struct fbnic_pkt_buff *pkt) {
@@ -1040,6 +1115,8 @@ static struct sk_buff *fbnic_run_xdp(struct fbnic_napi_vector *nv,case XDP_PASS : xdp_pass:return fbnic_build_skb (nv, pkt); +case XDP_TX : +return ERR_PTR (fbnic_pkt_tx (nv, pkt));default :bpf_warn_invalid_xdp_action (nv->napi.dev, xdp_prog, act); fallthrough;
@@ -1104,10 +1181,10 @@ static int fbnic_clean_rcq(struct fbnic_napi_vector *nv, struct fbnic_q_triad *qt, int budget) {unsigned int packets =0 , bytes =0 , dropped =0 , alloc_failed =0 ; +s32 head0 =-1 , head1 =-1 , pkt_tail =-1 ;u64 csum_complete =0 , csum_none =0 ;struct fbnic_ring *rcq = &qt->cmpl;struct fbnic_pkt_buff *pkt; -s32 head0 =-1 , head1 =-1 ;__le64 *raw_rcd, done;u32 head = rcq->head;
@@ -1163,6 +1240,9 @@ static int fbnic_clean_rcq(struct fbnic_napi_vector *nv, bytes += skb->len;napi_gro_receive (&nv->napi, skb); + }else if (PTR_ERR (skb) == -FBNIC_XDP_TX ) { + pkt_tail = nv->qt[0 ].sub1.tail; + bytes +=xdp_get_buff_len (&pkt->buff); }else {if (!skb) { alloc_failed++;
@@ -1198,6 +1278,9 @@ static int fbnic_clean_rcq(struct fbnic_napi_vector *nv, rcq->stats.rx.csum_none += csum_none;u64_stats_update_end (&rcq->stats.syncp); +if (pkt_tail >=0 ) +fbnic_pkt_commit_tail (nv, pkt_tail); +/* Unmap and free processed buffers */ if (head0 >=0 )fbnic_clean_bdq (nv, budget, &qt->sub0, head0);
Signature · 1 line
2.47.3
PATCH v3 8/9 eth: fbnic: Collect packet statistics for XDP
In reply to Mohsin BashirAdd support for XDP statistics collection and reporting via rtnl_link and netdev_queue API.
For XDP programs without frags support, fbnic requires MTU to be less than the HDS threshold. If an over-sized frame is received, the frame is dropped and recorded as rx_length_errors reported via ip stats to highlight that this is an error.
--- .../device_drivers/ethernet/meta/fbnic.rst | 11 ++++ .../net/ethernet/meta/fbnic/fbnic_netdev.c | 36 ++++++++++++- drivers/net/ethernet/meta/fbnic/fbnic_txrx.c | 51 +++++++++++++++++-- drivers/net/ethernet/meta/fbnic/fbnic_txrx.h | 1 + 4 files changed, 94 insertions(+), 5 deletions(-)
Documentation/networking/device_drivers/ethernet/meta/fbnic.rst +11 -0
@@ -160,3 +160,14 @@ behavior and potential performance bottlenecks. credit exhaustion - ``pcie_ob_rd_no_np_cred``: Read requests dropped due to non-posted credit exhaustion + +XDP Length Error: +~~~~~~~~~~~~~~~~~ + +For XDP programs without frags support, fbnic tries to make sure that MTU fits +into a single buffer. If an oversized frame is received and gets fragmented, +it is dropped and the following netlink counters are updated + + - ``rx-length``: number of frames dropped due to lack of fragmentation + support in the attached XDP program + - ``rx-errors``: total number of packets with errors received on the interface
drivers/net/ethernet/meta/fbnic/fbnic_netdev.c +35 -1
@@ -407,11 +407,12 @@ static void fbnic_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats64) {u64 rx_bytes, rx_packets, rx_dropped =0 , rx_errors =0 ; +u64 rx_over =0 , rx_missed =0 , rx_length =0 ;u64 tx_bytes, tx_packets, tx_dropped =0 ;struct fbnic_net *fbn =netdev_priv (dev);struct fbnic_dev *fbd = fbn->fbd;struct fbnic_queue_stats *stats; -u64 rx_over =0 , rx_missed =0 ; +unsigned int start, i;fbnic_get_hw_stats (fbd);
@@ -489,6 +490,7 @@ static void fbnic_get_stats64(struct net_device *dev, stats64->rx_missed_errors = rx_missed;for (i =0 ; i < fbn->num_rx_queues; i++) { +struct fbnic_ring *xdpr = fbn->tx[FBNIC_MAX_TXQS + i];struct fbnic_ring *rxr = fbn->rx[i];if (!rxr)
@@ -500,11 +502,29 @@ static void fbnic_get_stats64(struct net_device *dev, rx_bytes = stats->bytes; rx_packets = stats->packets; rx_dropped = stats->dropped; + rx_length = stats->rx.length_errors; }while (u64_stats_fetch_retry (&stats->syncp, start)); stats64->rx_bytes += rx_bytes; stats64->rx_packets += rx_packets; stats64->rx_dropped += rx_dropped; + stats64->rx_errors += rx_length; + stats64->rx_length_errors += rx_length; + +if (!xdpr) +continue ; + + stats = &xdpr->stats; +do { + start =u64_stats_fetch_begin (&stats->syncp); + tx_bytes = stats->bytes; + tx_packets = stats->packets; + tx_dropped = stats->dropped; + }while (u64_stats_fetch_retry (&stats->syncp, start)); + + stats64->tx_bytes += tx_bytes; + stats64->tx_packets += tx_packets; + stats64->tx_dropped += tx_dropped; } }
@@ -603,6 +623,7 @@ static void fbnic_get_queue_stats_tx(struct net_device *dev, int idx,struct fbnic_ring *txr = fbn->tx[idx];struct fbnic_queue_stats *stats;u64 stop, wake, csum, lso; +struct fbnic_ring *xdpr;unsigned int start;u64 bytes, packets;
@@ -626,6 +647,19 @@ static void fbnic_get_queue_stats_tx(struct net_device *dev, int idx, tx->hw_gso_wire_packets = lso; tx->stop = stop; tx->wake = wake; + + xdpr = fbn->tx[FBNIC_MAX_TXQS + idx]; +if (xdpr) { + stats = &xdpr->stats; +do { + start =u64_stats_fetch_begin (&stats->syncp); + bytes = stats->bytes; + packets = stats->packets; + }while (u64_stats_fetch_retry (&stats->syncp, start)); + + tx->bytes += bytes; + tx->packets += packets; + } } static void fbnic_get_base_stats(struct net_device *dev,
drivers/net/ethernet/meta/fbnic/fbnic_txrx.c +47 -4
115 lines not on this page · raw message
drivers/net/ethernet/meta/fbnic/fbnic_txrx.h +1 -0
@@ -90,6 +90,7 @@ struct fbnic_queue_stats {u64 alloc_failed;u64 csum_complete;u64 csum_none; +u64 length_errors; } rx; };u64 dropped;
Signature · 1 line
2.47.3
Jakub Kicinski
maintainerRe: [PATCH net-next V3 8/9] eth: fbnic: Collect packet statistics for XDP
drivers/net/ethernet/meta/fbnic/fbnic_txrx.c static int fbnic_clean_rcq(struct fbnic_napi_vector *nv, · line 1272
Quoted 2 lines · On Tue, 12 Aug 2025 15:22:52 -0700 Mohsin Bashir wrote:
drivers/net/ethernet/meta/fbnic/fbnic_txrx.c +2
-0+ }else if (PTR_ERR (skb) == -FBNIC_XDP_LEN_ERR ) { + length_errors++;
cocci is complaining about this:
...fbnic_txrx.c:1264:14-21: ERROR: PTR_ERR applied after initialization to constant on line 1250
I think applying PTR_ERR/ERR_PTR to the constant may clean this up.
Signature · 1 line
pw-bot: cr
PATCH v3 9/9 eth: fbnic: Report XDP stats via ethtool
In reply to Mohsin BashirAdd support to collect XDP stats via ethtool API. We record packets and bytes sent, and packets dropped on the XDP_TX path.
ethtool -S eth0 | grep xdp | grep -v "0"
xdp_tx_queue_13_packets: 2
xdp_tx_queue_13_bytes: 16126--- .../net/ethernet/meta/fbnic/fbnic_ethtool.c | 50 ++++++++++++++++++- 1 file changed, 49 insertions(+), 1 deletion(-)
drivers/net/ethernet/meta/fbnic/fbnic_ethtool.c +49 -1
@@ -112,6 +112,20 @@ static const struct fbnic_stat fbnic_gstrings_hw_q_stats[] = { FBNIC_HW_RXB_DEQUEUE_STATS_LEN * FBNIC_RXB_DEQUEUE_INDICES + \ FBNIC_HW_Q_STATS_LEN * FBNIC_MAX_QUEUES) +#define FBNIC_QUEUE_STAT (name, stat) \ + FBNIC_STAT_FIELDS(fbnic_ring, name, stat) + +static const struct fbnic_stat fbnic_gstrings_xdp_stats[] = { +FBNIC_QUEUE_STAT ("xdp_tx_queue_%u_packets" , stats.packets), +FBNIC_QUEUE_STAT ("xdp_tx_queue_%u_bytes" , stats.bytes), +FBNIC_QUEUE_STAT ("xdp_tx_queue_%u_dropped" , stats.dropped), +}; + +#define FBNIC_XDP_STATS_LEN ARRAY_SIZE(fbnic_gstrings_xdp_stats) + +#define FBNIC_STATS_LEN \ + (FBNIC_HW_STATS_LEN + FBNIC_XDP_STATS_LEN * FBNIC_MAX_XDPQS) +static void fbnic_get_drvinfo (struct net_device *netdev,struct ethtool_drvinfo *drvinfo) {
@@ -422,6 +436,16 @@ static void fbnic_get_rxb_dequeue_strings(u8 **data, unsigned int idx)ethtool_sprintf (data, stat->string, idx); } +static void fbnic_get_xdp_queue_strings (u8 **data,unsigned int idx) +{ +const struct fbnic_stat *stat; +int i; + + stat = fbnic_gstrings_xdp_stats; +for (i =0 ; i <FBNIC_XDP_STATS_LEN ; i++, stat++) +ethtool_sprintf (data, stat->string, idx); +} +static void fbnic_get_strings (struct net_device *dev,u32 sset,u8 *data) {const struct fbnic_stat *stat;
@@ -447,6 +471,9 @@ static void fbnic_get_strings(struct net_device *dev, u32 sset, u8 *data)for (i =0 ; i <FBNIC_HW_Q_STATS_LEN ; i++, stat++)ethtool_sprintf (&data, stat->string, idx); } + +for (i =0 ; i <FBNIC_MAX_XDPQS ; i++) +fbnic_get_xdp_queue_strings (&data, i);break ; } }
@@ -464,6 +491,24 @@ static void fbnic_report_hw_stats(const struct fbnic_stat *stat, } } +static void fbnic_get_xdp_queue_stats (struct fbnic_ring *ring,u64 **data) +{ +const struct fbnic_stat *stat; +int i; + +if (!ring) { + *data +=FBNIC_XDP_STATS_LEN ; +return ; + } + + stat = fbnic_gstrings_xdp_stats; +for (i =0 ; i <FBNIC_XDP_STATS_LEN ; i++, stat++, (*data)++) { +u8 *p = (u8 *)ring + stat->offset; + + **data = *(u64 *)p; + } +} +static void fbnic_get_ethtool_stats (struct net_device *dev,struct ethtool_stats *stats,u64 *data) {
@@ -511,13 +556,16 @@ static void fbnic_get_ethtool_stats(struct net_device *dev, FBNIC_HW_Q_STATS_LEN, &data); }spin_unlock (&fbd->hw_stats_lock); + +for (i =0 ; i <FBNIC_MAX_XDPQS ; i++) +fbnic_get_xdp_queue_stats (fbn->tx[i +FBNIC_MAX_TXQS ], &data); }static int fbnic_get_sset_count (struct net_device *dev,int sset) {switch (sset) {case ETH_SS_STATS : -return FBNIC_HW_STATS_LEN ; +return FBNIC_STATS_LEN ;default :return -EOPNOTSUPP ; }
Signature · 1 line
2.47.3