Re: [PATCH net-next] eth: bnxt: report TX HW GSO queue stats

From: netdev-bot+sashiko

Date: Wed Nov 18 2026 - 03:44:13 EST


Thank you for your contribution! Sashiko AI review found 2 potential
issue(s) to consider.

Critical: 0 · High: 0 (1) · Medium: 1 · Low: 1

If you believe none of the issues are legitimate, please reply to each
issue of Medium severity or higher and explain why the AI is wrong.
If any of them are legitimate and you plan to respin, please let patchwork
know by including "pw-bot: cr" as a separate line at the end of your reply
(one such reply per series is enough).

- [Medium] __bnxt_tx_int() treats every completed skb with skb_is_gso()
&& !tx_buf->is_sw_gso as segmented by the NIC into gso_segs wire…
- [Low] The patch adds per-ring TX HW GSO counters
(txr->tx_hw_gso_packets, txr->tx_hw_gso_wire_packets) to struct…

Pre-existing issues:
- [High] This problem wasn't introduced by this patch, but
bnxt_start_xmit() lets a GSO skb (gso_size != 0) take the TX push path…

--

eth: bnxt: report TX HW GSO queue stats

This commit adds per-ring counters to bnxt for HW GSO skbs and for the
wire packets they produce. The counters are updated in the TX completion
path and reported through the netdev queue stats ops. Aggregated totals
are also folded into the base stats so the tso.py selftests can run on
bnxt.

> diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt.c b/drivers/net/ethernet/broadcom/bnxt/bnxt.c
> index 6846a27bfef4c..1a7a93bf684ac 100644
> --- a/drivers/net/ethernet/broadcom/bnxt/bnxt.c
> +++ b/drivers/net/ethernet/broadcom/bnxt/bnxt.c
> @@ -869,6 +869,11 @@ static bool __bnxt_tx_int(struct bnxt *bp, struct bnxt_tx_ring_info *txr,
> cons = NEXT_TX(cons);
> tx_pkts++;
> tx_bytes += skb->len;
> + if (skb_is_gso(skb) && !tx_buf->is_sw_gso) {
> + txr->tx_hw_gso_packets++;
> + txr->tx_hw_gso_wire_packets +=
> + skb_shinfo(skb)->gso_segs;
> + }
> tx_buf->skb = NULL;
> tx_buf->is_ts_pkt = 0;

[Severity: Medium]
Can this over-count wire packets for GSO skbs that were sent through the
TX push path?

This block runs before the is_push early-out. It treats every completed
skb with skb_is_gso() && !is_sw_gso as segmented by the hardware.
However, the push path gate in bnxt_start_xmit() does not exclude GSO
skbs:

if (free_size == bp->tx_ring_size && length <= bp->tx_push_thresh &&
skb_frags_readable(skb) && !lflags) {

The push BDs never set TX_BD_FLAGS_LSO or tx_bd_mss, so the NIC sends
the skb as a single frame.

Take an idle ring with tx_push_thresh at 164 and a GSO skb of 164 bytes
or less. Two examples are TCP with a peer-advertised MSS of 48 and 96
bytes of payload, or UDP_SEGMENT with gso_size=8 and 80 bytes of
payload. Either skb would be counted as 1 hw_gso_packet plus gso_segs
hw_gso_wire_packets, even though only one frame went on the wire.

tso.py reads these counters, so could this give misleading results
there? Fixing the push path issue described below would also fix this.

[Severity: High]
This is a pre-existing issue and was not introduced by this patch, but
should bnxt_start_xmit() keep GSO skbs out of the push path?

The push path only sets the checksum flag and then skips the LSO setup:

bnxt_start_xmit() {
...
if (skb->ip_summed == CHECKSUM_PARTIAL)
tx_push1->tx_bd_hsize_lflags =
cpu_to_le32(TX_BD_FLAGS_TCP_UDP_CHKSUM);
else
tx_push1->tx_bd_hsize_lflags = 0;
...
goto tx_done;
...
}

LSO is only programmed in the normal_tx path:

if (skb_is_gso(skb)) {
...
txbd1->tx_bd_hsize_lflags |= cpu_to_le32(TX_BD_FLAGS_LSO |
TX_BD_FLAGS_T_IPID |
(hdr_len << (TX_BD_HSIZE_SHIFT - 1)));
length = skb_shinfo(skb)->gso_size;
txbd1->tx_bd_mss = cpu_to_le32(length);

So a small GSO skb that takes the push path goes out unsegmented.

With HW USO (BNXT_FLAG_UDP_GSO_CAP), wouldn't the receiver get one UDP
datagram holding the concatenated payload, instead of gso_segs separate
datagrams? For TCP, a segment larger than the peer's MSS would be sent.

Neither bnxt_features_check() nor gso_features_check() seems to strip
GSO for skbs this small. Would adding a !skb_is_gso(skb) check to the
push gate be enough to fix this?

[ ... ]

> @@ -16369,6 +16385,9 @@ static void bnxt_get_queue_stats_tx(struct net_device *dev, int i,
> stats->bytes += BNXT_GET_RING_STATS64(sw, tx_ucast_bytes);
> stats->bytes += BNXT_GET_RING_STATS64(sw, tx_mcast_bytes);
> stats->bytes += BNXT_GET_RING_STATS64(sw, tx_bcast_bytes);
> +
> + stats->hw_gso_packets = txr->tx_hw_gso_packets;
> + stats->hw_gso_wire_packets = txr->tx_hw_gso_wire_packets;
> }

[Severity: Low]
Are these reads safe against the writer in __bnxt_tx_int()?

txr->tx_hw_gso_packets and txr->tx_hw_gso_wire_packets are plain u64
fields. They are updated with ++ and += from NAPI context.

They are read here, and in bnxt_get_ring_drv_stats() through
bnxt_get_ethtool_stats(), from process context while NAPI can be
running on another CPU.

bnxt_sync_ring_stats() only takes bp->stats_lock around the HW ring
stats accumulation, so these fields are not covered.

BNXT does not depend on 64BIT. On 32-bit builds, could a reader see a
torn value when the low word wraps? On 64-bit this is still an
unannotated data race that KCSAN would report.

Would it make sense to use u64_stats_t with a u64_stats_sync here, with
a fetch_begin/fetch_retry loop on the reader side? The existing
rx_hw_gro_packets counters use the same unsynchronized pattern.

[ ... ]

--
Sashiko AI review · https://netdev-ai.bots.linux.dev/sashiko/#/patchset/20261116204313.23023-1-narcisav.kernel%40gmail.com