* [PATCH net 0/3] ENETC GSO fixes
@ 2026-11-11 23:31 Vladimir Oltean
2026-11-11 23:31 ` [PATCH net 1/3] net: enetc: let core segment GSO super-skb when TSO would not fit the TX ring Vladimir Oltean
` (2 more replies)
0 siblings, 3 replies; 8+ messages in thread
From: Vladimir Oltean @ 2026-11-11 23:31 UTC (permalink / raw)
To: netdev
Cc: Andrew Lunn, David S . Miller, Eric Dumazet, Jakub Kicinski,
Paolo Abeni, Claudiu Manoil, Wei Fang, Clark Wang, Ioana Ciornei,
Willem de Bruijn, imx, linux-kernel
Sashiko derailed me from "[PATCH v5 net 0/4] Fix short frame
transmission in enetc":
https://lore.kernel.org/netdev/20261021145314.1435049-1-vladimir.oltean@nxp.com/
which also touches the driver GSO code path, so I'm making a detour
to fix 3 unrelated issues there (which I could all reproduce using
LLM-produced programs).
The main highlight of this series is the introduction of
.ndo_features_check() for enetc, which runs for every transmitted skb.
Each patch makes its implementation more and more complex.
These patches all assume that at .ndo_features_check() time,
skb_shinfo(skb)->gso_segs is set properly. There might be issues there,
see commit 67b0cca9ba88 ("net: validate xmit skbs in generic_xdp_tx()")
which fixes one case which led to gso_segs reaching the driver while
being zero. For some reason it was merged to net-next though.
Running a bidirectional eno0 <-> swp0 forwarding of raw IPv4 64B packets
(no GRO or GSO) on LS1028A-QDS rather than some micro-benchmark,
I am not seeing a noticeable performance degradation. It is in the
noise margin.
Before: 7440 Kpps ingress, 586 Kpps egress
After: 7440 Kpps ingress, 588 Kpps egress
Vladimir Oltean (3):
net: enetc: let core segment GSO super-skb when TSO would not fit the
TX ring
net: enetc: reserve VLAN extension BDs for software TSO
net: enetc: let core segment GSO super-skb when headers exceed
TSO_HEADER_SIZE
drivers/net/ethernet/freescale/enetc/enetc.c | 52 +++++++++++++++++--
drivers/net/ethernet/freescale/enetc/enetc.h | 3 ++
.../net/ethernet/freescale/enetc/enetc4_pf.c | 1 +
.../net/ethernet/freescale/enetc/enetc_pf.c | 1 +
.../net/ethernet/freescale/enetc/enetc_vf.c | 2 +
5 files changed, 54 insertions(+), 5 deletions(-)
--
2.53.0
^ permalink raw reply [flat|nested] 8+ messages in thread* [PATCH net 1/3] net: enetc: let core segment GSO super-skb when TSO would not fit the TX ring 2026-11-11 23:31 [PATCH net 0/3] ENETC GSO fixes Vladimir Oltean @ 2026-11-11 23:31 ` Vladimir Oltean 2026-11-16 0:21 ` netdev-bot+sashiko 2026-11-11 23:31 ` [PATCH net 2/3] net: enetc: reserve VLAN extension BDs for software TSO Vladimir Oltean 2026-11-11 23:31 ` [PATCH net 3/3] net: enetc: let core segment GSO super-skb when headers exceed TSO_HEADER_SIZE Vladimir Oltean 2 siblings, 1 reply; 8+ messages in thread From: Vladimir Oltean @ 2026-11-11 23:31 UTC (permalink / raw) To: netdev Cc: Andrew Lunn, David S . Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni, Claudiu Manoil, Wei Fang, Clark Wang, Ioana Ciornei, Willem de Bruijn, imx, linux-kernel For simplicity reasons, the enetc software GSO implementation waits for the TX ring to free up sufficiently that all BDs that would be generated by driver-level segmentation can be enqueued in one go. To pass the time, it stops the queue and returns NETDEV_TX_BUSY for the core to requeue. The problem is that without any limits on gso_segs, some GSO super-skbs can never be sent, and the aforementioned behaviour results in the queue stalling (there is also no ndo_tx_timeout implementation). This was reported by Sashiko, but is a valid issue which can be easily triggered from any source that can craft gso_segs in a way that tso_count_descs() can exceed 2047 (the ring size minus the obligatory free entry). Valid reproduction methods include TCP peers whose MSS is close to tcp_min_snd_mss plus large (64KB) TSO super-skbs; UDP GSO using setsockopt(UDP_SEGMENT); maybe others. Add an ndo_features_check() that clears the GSO features for skbs that take the software TSO path and whose descriptor estimate is larger than the ring could ever provide. The core then segments these skbs itself before calling ndo_start_xmit(). Capping the segment count with netif_set_tso_max_segs() would be simpler, but its drawback is that it's static, so it would have to assume the worst case for every skb (MAX_SKB_FRAGS, and later the per-segment VLAN and padding BDs). This would reduce TSO sizes even for skbs that fit. Fixes: fb8629e2cbfc ("net: enetc: add support for software TSO") Signed-off-by: Vladimir Oltean <vladimir.oltean@nxp.com> --- drivers/net/ethernet/freescale/enetc/enetc.c | 31 ++++++++++++++++--- drivers/net/ethernet/freescale/enetc/enetc.h | 3 ++ .../net/ethernet/freescale/enetc/enetc4_pf.c | 1 + .../net/ethernet/freescale/enetc/enetc_pf.c | 1 + .../net/ethernet/freescale/enetc/enetc_vf.c | 2 ++ 5 files changed, 34 insertions(+), 4 deletions(-) diff --git a/drivers/net/ethernet/freescale/enetc/enetc.c b/drivers/net/ethernet/freescale/enetc/enetc.c index c6571b5cc842..1606ac57016f 100644 --- a/drivers/net/ethernet/freescale/enetc/enetc.c +++ b/drivers/net/ethernet/freescale/enetc/enetc.c @@ -695,6 +695,14 @@ static int enetc_lso_get_hdr_len(const struct sk_buff *skb) return hdr_len; } +static bool enetc_skb_uses_lso(const struct enetc_ndev_priv *priv, + const struct sk_buff *skb) +{ + /* LSO data unit lengths of up to 256KB are supported */ + return priv->active_offloads & ENETC_F_LSO && + (skb->len - enetc_lso_get_hdr_len(skb)) <= ENETC_LSO_MAX_DATA_LEN; +} + static void enetc_lso_start(struct sk_buff *skb, struct enetc_lso_t *lso) { lso->lso_seg_size = skb_shinfo(skb)->gso_size; @@ -1018,10 +1026,7 @@ static netdev_tx_t enetc_start_xmit(struct sk_buff *skb, tx_ring = priv->tx_ring[skb->queue_mapping]; if (skb_is_gso(skb)) { - /* LSO data unit lengths of up to 256KB are supported */ - if (priv->active_offloads & ENETC_F_LSO && - (skb->len - enetc_lso_get_hdr_len(skb)) <= - ENETC_LSO_MAX_DATA_LEN) { + if (enetc_skb_uses_lso(priv, skb)) { if (enetc_bd_unused(tx_ring) < enetc_lso_count_descs(skb)) { netif_stop_subqueue(ndev, tx_ring->index); return NETDEV_TX_BUSY; @@ -1098,6 +1103,24 @@ netdev_tx_t enetc_xmit(struct sk_buff *skb, struct net_device *ndev) } EXPORT_SYMBOL_GPL(enetc_xmit); +netdev_features_t enetc_features_check(struct sk_buff *skb, + struct net_device *ndev, + netdev_features_t features) +{ + struct enetc_ndev_priv *priv = netdev_priv(ndev); + + features = vlan_features_check(skb, features); + + if (!skb_is_gso(skb) || enetc_skb_uses_lso(priv, skb)) + return features; + + if (tso_count_descs(skb) >= priv->tx_bd_count) + features &= ~NETIF_F_GSO_MASK; + + return features; +} +EXPORT_SYMBOL_GPL(enetc_features_check); + static irqreturn_t enetc_msix(int irq, void *data) { struct enetc_int_vector *v = data; diff --git a/drivers/net/ethernet/freescale/enetc/enetc.h b/drivers/net/ethernet/freescale/enetc/enetc.h index d9e91832a9c1..1e3290d1a388 100644 --- a/drivers/net/ethernet/freescale/enetc/enetc.h +++ b/drivers/net/ethernet/freescale/enetc/enetc.h @@ -529,6 +529,9 @@ int enetc_close(struct net_device *ndev); void enetc_start(struct net_device *ndev); void enetc_stop(struct net_device *ndev); netdev_tx_t enetc_xmit(struct sk_buff *skb, struct net_device *ndev); +netdev_features_t enetc_features_check(struct sk_buff *skb, + struct net_device *ndev, + netdev_features_t features); struct net_device_stats *enetc_get_stats(struct net_device *ndev); void enetc_set_features(struct net_device *ndev, netdev_features_t features); int enetc_ioctl(struct net_device *ndev, struct ifreq *rq, int cmd); diff --git a/drivers/net/ethernet/freescale/enetc/enetc4_pf.c b/drivers/net/ethernet/freescale/enetc/enetc4_pf.c index 71c971618388..bfe0eaf50975 100644 --- a/drivers/net/ethernet/freescale/enetc/enetc4_pf.c +++ b/drivers/net/ethernet/freescale/enetc/enetc4_pf.c @@ -586,6 +586,7 @@ static const struct net_device_ops enetc4_ndev_ops = { .ndo_open = enetc_open, .ndo_stop = enetc_close, .ndo_start_xmit = enetc_xmit, + .ndo_features_check = enetc_features_check, .ndo_get_stats = enetc_get_stats, .ndo_set_mac_address = enetc_pf_set_mac_addr, .ndo_set_rx_mode_async = enetc4_pf_set_rx_mode, diff --git a/drivers/net/ethernet/freescale/enetc/enetc_pf.c b/drivers/net/ethernet/freescale/enetc/enetc_pf.c index d77a07cece28..86ca88196a4b 100644 --- a/drivers/net/ethernet/freescale/enetc/enetc_pf.c +++ b/drivers/net/ethernet/freescale/enetc/enetc_pf.c @@ -483,6 +483,7 @@ static const struct net_device_ops enetc_ndev_ops = { .ndo_open = enetc_open, .ndo_stop = enetc_close, .ndo_start_xmit = enetc_xmit, + .ndo_features_check = enetc_features_check, .ndo_get_stats = enetc_get_stats, .ndo_set_mac_address = enetc_pf_set_mac_addr, .ndo_set_rx_mode = enetc_pf_set_rx_mode, diff --git a/drivers/net/ethernet/freescale/enetc/enetc_vf.c b/drivers/net/ethernet/freescale/enetc/enetc_vf.c index f70b6d4290f2..223f974727bc 100644 --- a/drivers/net/ethernet/freescale/enetc/enetc_vf.c +++ b/drivers/net/ethernet/freescale/enetc/enetc_vf.c @@ -440,6 +440,7 @@ static const struct net_device_ops enetc_ndev_ops = { .ndo_open = enetc_open, .ndo_stop = enetc_close, .ndo_start_xmit = enetc_xmit, + .ndo_features_check = enetc_features_check, .ndo_get_stats = enetc_get_stats, .ndo_set_mac_address = enetc_vf_set_mac_addr, .ndo_set_features = enetc_vf_set_features, @@ -453,6 +454,7 @@ static const struct net_device_ops enetc4_ndev_ops = { .ndo_open = enetc_open, .ndo_stop = enetc_close, .ndo_start_xmit = enetc_xmit, + .ndo_features_check = enetc_features_check, .ndo_get_stats = enetc_get_stats, .ndo_set_mac_address = enetc_vf_set_mac_addr, .ndo_set_features = enetc_vf_set_features, -- 2.53.0 ^ permalink raw reply related [flat|nested] 8+ messages in thread
* Re: [PATCH net 1/3] net: enetc: let core segment GSO super-skb when TSO would not fit the TX ring 2026-11-11 23:31 ` [PATCH net 1/3] net: enetc: let core segment GSO super-skb when TSO would not fit the TX ring Vladimir Oltean @ 2026-11-16 0:21 ` netdev-bot+sashiko 0 siblings, 0 replies; 8+ messages in thread From: netdev-bot+sashiko @ 2026-11-16 0:21 UTC (permalink / raw) To: vladimir.oltean Cc: netdev, andrew+netdev, davem, edumazet, kuba, pabeni, claudiu.manoil, wei.fang, xiaoning.wang, ioana.ciornei, willemdebruijn.kernel, imx, linux-kernel Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider. Critical: 0 · High: 1 · Medium: 0 · Low: 0 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). - [High] The fix is incomplete: SKB_GSO_DODGY skbs can still stall a TX queue for good. -- net: enetc: let core segment GSO super-skb when TSO would not fit the TX ring This adds an ndo_features_check() to the enetc PF and VF drivers. On the software TSO path, it clears the GSO features for any skb whose descriptor estimate is larger than the TX ring could ever provide. The core then segments those skbs itself, which avoids the permanent NETDEV_TX_BUSY loop in enetc_start_xmit(). > diff --git a/drivers/net/ethernet/freescale/enetc/enetc.c b/drivers/net/ethernet/freescale/enetc/enetc.c > index c6571b5cc8425..1606ac57016f3 100644 > --- a/drivers/net/ethernet/freescale/enetc/enetc.c > +++ b/drivers/net/ethernet/freescale/enetc/enetc.c [ ... ] > @@ -1098,6 +1103,24 @@ netdev_tx_t enetc_xmit(struct sk_buff *skb, struct net_device *ndev) > } > EXPORT_SYMBOL_GPL(enetc_xmit); > > +netdev_features_t enetc_features_check(struct sk_buff *skb, > + struct net_device *ndev, > + netdev_features_t features) > +{ > + struct enetc_ndev_priv *priv = netdev_priv(ndev); > + > + features = vlan_features_check(skb, features); > + > + if (!skb_is_gso(skb) || enetc_skb_uses_lso(priv, skb)) > + return features; > + > + if (tso_count_descs(skb) >= priv->tx_bd_count) > + features &= ~NETIF_F_GSO_MASK; [Severity: High] Can SKB_GSO_DODGY skbs still get past this check and stall the queue? tso_count_descs() is based on skb_shinfo(skb)->gso_segs. The same is true of enetc_tso_count_descs(), which replaces it later in the series. For DODGY skbs, gso_segs can still be 0 when ndo_features_check runs. enetc does not advertise NETIF_F_GSO_ROBUST, so the skb takes this path: validate_xmit_skb() __netif_skb_features() enetc_features_check() <- sees gso_segs == 0, keeps TSO __skb_gso_segment() tcp_gso_segment() tcp_gso_segment() only fixes up gso_segs and then returns the skb unsegmented: net/ipv4/tcp_offload.c:tcp_gso_segment() { ... if (skb_gso_ok(skb, features | NETIF_F_GSO_ROBUST)) { /* Packet is from an untrusted source, reset gso_segs. */ skb_shinfo(skb)->gso_segs = DIV_ROUND_UP(skb->len, mss); segs = NULL; ... } Take the software TSO path (no ENETC_F_LSO, e.g. LS1028A). A DODGY TCP skb with a gso_size of 8 and about 64KB of payload gets a gso_segs of about 8000. That puts the descriptor estimate at about 16000, well above the 2047 BDs an empty ring can offer. In that case the enetc_bd_unused() check in enetc_start_xmit() is always true. The driver calls netif_stop_subqueue() and returns NETDEV_TX_BUSY every time. There seem to be two ways to produce such skbs. The first is AF_PACKET with PACKET_VNET_HDR and PACKET_QDISC_BYPASS. __virtio_net_hdr_to_skb() does: shinfo->gso_type |= SKB_GSO_DODGY; shinfo->gso_segs = 0; and only clamps gso_size to TCP_MIN_GSO_SIZE. The send path is then packet_xmit()->dev_direct_xmit()->__dev_direct_xmit()-> validate_xmit_skb_list(). That path skips qdisc_pkt_len_segs_init(), the only place that recomputes DODGY gso_segs before features_check. On BUSY, dev_direct_xmit() frees the skb, but the subqueue stays stopped. The second is a tc-egress BPF program that calls bpf_skb_adjust_room(). Both bpf_skb_net_grow() and bpf_skb_net_shrink() set SKB_GSO_DODGY and reset gso_segs to 0. This happens after __dev_queue_xmit() has already run qdisc_pkt_len_segs_init(). Ordinary TCP TSO traffic would then skip the new check, including the small-MSS peer case from the commit message, and be requeued with BUSY forever. The only wake-up for the stopped subqueue is in enetc_clean_tx_ring(). It needs tx_frm_cnt > 0, and the driver has no ndo_tx_timeout, so an idle ring would not recover. Could the ring-size check use a bound that does not trust gso_segs for DODGY skbs? One option is DIV_ROUND_UP(skb->len - hdr_len, gso_size). Another is a fallback in the xmit path for skbs that can never fit the ring. > + > + return features; > +} > +EXPORT_SYMBOL_GPL(enetc_features_check); [ ... ] -- Sashiko AI review · https://netdev-ai.bots.linux.dev/sashiko/#/patchset/20261111233149.479596-1-vladimir.oltean%40nxp.com ^ permalink raw reply [flat|nested] 8+ messages in thread
* [PATCH net 2/3] net: enetc: reserve VLAN extension BDs for software TSO 2026-11-11 23:31 [PATCH net 0/3] ENETC GSO fixes Vladimir Oltean 2026-11-11 23:31 ` [PATCH net 1/3] net: enetc: let core segment GSO super-skb when TSO would not fit the TX ring Vladimir Oltean @ 2026-11-11 23:31 ` Vladimir Oltean 2026-11-16 0:21 ` netdev-bot+sashiko 2026-11-11 23:31 ` [PATCH net 3/3] net: enetc: let core segment GSO super-skb when headers exceed TSO_HEADER_SIZE Vladimir Oltean 2 siblings, 1 reply; 8+ messages in thread From: Vladimir Oltean @ 2026-11-11 23:31 UTC (permalink / raw) To: netdev Cc: Andrew Lunn, David S . Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni, Claudiu Manoil, Wei Fang, Clark Wang, Ioana Ciornei, Willem de Bruijn, imx, linux-kernel enetc_start_xmit() uses tso_count_descs() to check whether the TX ring has enough free BDs for a software TSO frame. That estimates one header BD and one data BD per segment, plus one BD per frag. However, when the skb carries a VLAN tag, enetc_map_tx_tso_hdr() also adds an extension BD to every segment, which is not accounted for. With a highly segmented VLAN TSO skb and a nearly full ring, the driver can then write past next_to_clean and overwrite BDs still owned by the hardware. Add enetc_tso_count_descs() which accounts for the extension BD of each segment when VLAN insertion is needed. Fixes: fb8629e2cbfc ("net: enetc: add support for software TSO") Signed-off-by: Vladimir Oltean <vladimir.oltean@nxp.com> --- This comes from the previous patch set: https://lore.kernel.org/netdev/20261021145314.1435049-2-vladimir.oltean@nxp.com/ v5->v1: also patch enetc_features_check() v4->v5: patch is new --- drivers/net/ethernet/freescale/enetc/enetc.c | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/drivers/net/ethernet/freescale/enetc/enetc.c b/drivers/net/ethernet/freescale/enetc/enetc.c index 1606ac57016f..7f089a84d9a6 100644 --- a/drivers/net/ethernet/freescale/enetc/enetc.c +++ b/drivers/net/ethernet/freescale/enetc/enetc.c @@ -674,6 +674,17 @@ static void enetc_tso_complete_csum(struct enetc_bdr *tx_ring, struct tso_t *tso } } +static int enetc_tso_count_descs(const struct sk_buff *skb) +{ + int count = tso_count_descs(skb); + + /* Each segment also needs an extension BD for VLAN insertion */ + if (skb_vlan_tag_present(skb)) + count += skb_shinfo(skb)->gso_segs; + + return count; +} + static int enetc_lso_count_descs(const struct sk_buff *skb) { /* 4 BDs: 1 BD for LSO header + 1 BD for extended BD + 1 BD @@ -1034,7 +1045,7 @@ static netdev_tx_t enetc_start_xmit(struct sk_buff *skb, count = enetc_lso_hw_offload(tx_ring, skb); } else { - if (enetc_bd_unused(tx_ring) < tso_count_descs(skb)) { + if (enetc_bd_unused(tx_ring) < enetc_tso_count_descs(skb)) { netif_stop_subqueue(ndev, tx_ring->index); return NETDEV_TX_BUSY; } @@ -1114,7 +1125,7 @@ netdev_features_t enetc_features_check(struct sk_buff *skb, if (!skb_is_gso(skb) || enetc_skb_uses_lso(priv, skb)) return features; - if (tso_count_descs(skb) >= priv->tx_bd_count) + if (enetc_tso_count_descs(skb) >= priv->tx_bd_count) features &= ~NETIF_F_GSO_MASK; return features; -- 2.53.0 ^ permalink raw reply related [flat|nested] 8+ messages in thread
* Re: [PATCH net 2/3] net: enetc: reserve VLAN extension BDs for software TSO 2026-11-11 23:31 ` [PATCH net 2/3] net: enetc: reserve VLAN extension BDs for software TSO Vladimir Oltean @ 2026-11-16 0:21 ` netdev-bot+sashiko 0 siblings, 0 replies; 8+ messages in thread From: netdev-bot+sashiko @ 2026-11-16 0:21 UTC (permalink / raw) To: vladimir.oltean Cc: netdev, andrew+netdev, davem, edumazet, kuba, pabeni, claudiu.manoil, wei.fang, xiaoning.wang, ioana.ciornei, willemdebruijn.kernel, imx, linux-kernel Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider. Critical: 0 · High: 1 (1) · Medium: 0 · Low: 0 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). - [High] enetc_features_check() (drivers/net/ethernet/freescale/enetc/enetc.c:1128) decides whether… Pre-existing issues: - [High] This problem wasn't introduced by this patch, but the patch changes the threshold of the affected check. -- net: enetc: reserve VLAN extension BDs for software TSO This adds enetc_tso_count_descs(), which counts one extra extension BD per segment when the skb carries a VLAN tag. The new helper replaces tso_count_descs() in both enetc_start_xmit() and enetc_features_check(), so a VLAN TSO skb can no longer overrun next_to_clean on a nearly full TX ring. > diff --git a/drivers/net/ethernet/freescale/enetc/enetc.c b/drivers/net/ethernet/freescale/enetc/enetc.c > index 1606ac57016f3..7f089a84d9a65 100644 > --- a/drivers/net/ethernet/freescale/enetc/enetc.c > +++ b/drivers/net/ethernet/freescale/enetc/enetc.c > @@ -674,6 +674,17 @@ static void enetc_tso_complete_csum(struct enetc_bdr *tx_ring, struct tso_t *tso > } > } > > +static int enetc_tso_count_descs(const struct sk_buff *skb) > +{ > + int count = tso_count_descs(skb); > + > + /* Each segment also needs an extension BD for VLAN insertion */ > + if (skb_vlan_tag_present(skb)) > + count += skb_shinfo(skb)->gso_segs; > + > + return count; > +} > + [ ... ] > @@ -1034,7 +1045,7 @@ static netdev_tx_t enetc_start_xmit(struct sk_buff *skb, > > count = enetc_lso_hw_offload(tx_ring, skb); > } else { > - if (enetc_bd_unused(tx_ring) < tso_count_descs(skb)) { > + if (enetc_bd_unused(tx_ring) < enetc_tso_count_descs(skb)) { > netif_stop_subqueue(ndev, tx_ring->index); > return NETDEV_TX_BUSY; > } [Severity: High] This is a pre-existing issue and was not introduced by this patch, but the patch changes the threshold of this check. Can the stop here race with enetc_clean_tx_ring() and lose a wakeup? enetc_start_xmit() reads next_to_clean through enetc_bd_unused(), then calls netif_stop_subqueue() and returns NETDEV_TX_BUSY. There is no smp_mb() and no second check after stopping. The completion side has no barrier either, and NAPI does not take the TX lock: drivers/net/ethernet/freescale/enetc/enetc.c:enetc_clean_tx_ring() { ... tx_ring->next_to_clean = i; ... if (unlikely(tx_frm_cnt && netif_carrier_ok(ndev) && __netif_subqueue_stopped(ndev, tx_ring->index) && ... netif_wake_subqueue(ndev, tx_ring->index); } Consider this interleaving: CPU0 (enetc_start_xmit) CPU1 (enetc_clean_tx_ring) reads old next_to_clean, not enough room completes the last frames writes next_to_clean queue not stopped, skips wake netif_stop_subqueue() return NETDEV_TX_BUSY Once that happens, no frames are in flight, so no further TX interrupt or NAPI clean runs. enetc also has no ndo_tx_timeout, so the subqueue looks like it stays stopped. On arm64, store->load reordering makes the window wider. Software TSO takes this BUSY path often, because the wake threshold ENETC_TXBDS_MAX_NEEDED is much lower than enetc_tso_count_descs(). For VLAN-tagged TSO skbs, this patch adds gso_segs BDs to the requirement, so the path runs even more often. Would the netif_txq_maybe_stop() / netif_txq_completed_wake() helpers from include/net/netdev_queues.h fix this? An open-coded stop + smp_mb() + recheck, with a matching barrier on the completion side, would also work. [ ... ] > @@ -1114,7 +1125,7 @@ netdev_features_t enetc_features_check(struct sk_buff *skb, > if (!skb_is_gso(skb) || enetc_skb_uses_lso(priv, skb)) > return features; > > - if (tso_count_descs(skb) >= priv->tx_bd_count) > + if (enetc_tso_count_descs(skb) >= priv->tx_bd_count) > features &= ~NETIF_F_GSO_MASK; [Severity: High] Does this guard still work for SKB_GSO_DODGY skbs? For those skbs, skb_shinfo(skb)->gso_segs is still 0 when ndo_features_check runs. Both parts of enetc_tso_count_descs() depend only on gso_segs: the tso_count_descs() estimate and the new VLAN extension BD term. With gso_segs == 0 the function returns just nr_frags. That is below tx_bd_count, so GSO is not cleared. Two paths appear to reach the driver this way. The first is AF_PACKET with PACKET_QDISC_BYPASS and PACKET_VNET_HDR: packet_xmit() dev_direct_xmit() __dev_direct_xmit() validate_xmit_skb_list() Here __virtio_net_hdr_to_skb() sets SKB_GSO_DODGY and gso_segs = 0, and accepts a TCP gso_size as small as TCP_MIN_GSO_SIZE (8). qdisc_pkt_len_segs_init() never runs on this path. The second is a tc egress BPF program that calls bpf_skb_adjust_room(). bpf_skb_net_grow() and bpf_skb_net_shrink() set DODGY and gso_segs = 0 inside sch_handle_egress(). That runs after qdisc_pkt_len_segs_init() in __dev_queue_xmit(). In both cases gso_within_dev_limits() also sees gso_segs == 0 and lets the skb through. enetc does not advertise NETIF_F_GSO_ROBUST, so validate_xmit_skb() calls __skb_gso_segment(). There, tcp_gso_segment() only sets gso_segs = DIV_ROUND_UP(len, mss) and returns NULL, and the unsegmented super-skb goes to enetc_start_xmit(). On the software TSO path, the check in enetc_start_xmit() now sees the real count. For a 64KB skb with an mss of 8, that is about 16000 BDs. enetc_bd_unused() returns at most bd_count - 1, so this check can never pass: if (enetc_bd_unused(tx_ring) < enetc_tso_count_descs(skb)) { netif_stop_subqueue(ndev, tx_ring->index); return NETDEV_TX_BUSY; } If the ring is empty, nothing wakes the queue again. enetc_clean_tx_ring() only wakes it when tx_frm_cnt != 0, and there is no ndo_tx_timeout. On the direct xmit path, the skb is freed but the queue stays stopped. On the tc egress path, the skb is requeued at the head of the qdisc forever. Earlier in this series, "net: enetc: let core segment GSO super-skb when TSO would not fit the TX ring" targets exactly this "never fits, queue stalls" problem. This patch extends the same gso_segs-based estimate to the VLAN extension BDs, so the new term has the same gap. The later commit "net: enetc: let core segment GSO super-skb when headers exceed TSO_HEADER_SIZE" only adds a header length check before this one. So the gap still seems to be there at the end of the series. Could the estimate in enetc_features_check() be computed from skb->len, the header length and gso_size, instead of from gso_segs? > > return features; -- Sashiko AI review · https://netdev-ai.bots.linux.dev/sashiko/#/patchset/20261111233149.479596-1-vladimir.oltean%40nxp.com ^ permalink raw reply [flat|nested] 8+ messages in thread
* [PATCH net 3/3] net: enetc: let core segment GSO super-skb when headers exceed TSO_HEADER_SIZE 2026-11-11 23:31 [PATCH net 0/3] ENETC GSO fixes Vladimir Oltean 2026-11-11 23:31 ` [PATCH net 1/3] net: enetc: let core segment GSO super-skb when TSO would not fit the TX ring Vladimir Oltean 2026-11-11 23:31 ` [PATCH net 2/3] net: enetc: reserve VLAN extension BDs for software TSO Vladimir Oltean @ 2026-11-11 23:31 ` Vladimir Oltean [not found] ` <sashiko-outbox-211955@kernel.org> 2026-11-16 0:21 ` netdev-bot+sashiko 2 siblings, 2 replies; 8+ messages in thread From: Vladimir Oltean @ 2026-11-11 23:31 UTC (permalink / raw) To: netdev Cc: Andrew Lunn, David S . Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni, Claudiu Manoil, Wei Fang, Clark Wang, Ioana Ciornei, Willem de Bruijn, imx, linux-kernel Like many other drivers, both the software TSO path (enetc_map_tx_tso_buffs()) and the LSO path (enetc_lso_map_hdr()) copy the L2+L3+L4 headers of the skb into a fixed-size TSO_HEADER_SIZE (256 byte) slot of the per-ring dma_alloc_coherent() header area, without checking that they fit. Sashiko casually points out during review of an unrelated patch: https://lore.kernel.org/netdev/179294166520.3134.18097439321876673016@kernel.org/ that TSO_HEADER_SIZE does not constitute the maximum size that packet headers can have for GSO super-skbs, but rather, an essentially arbitrary number. An example where headers can exceed TSO_HEADER_SIZE is with an IPv6 extension named Segment Routing Header, set through setsockopt(IPV6_RTHDR), with a type 4 routing header. With 11 or more segments, the headers of a TCP/IPv6 packet exceed 256 bytes: Ethernet 14 IPv6 40 SRH, 12 segments 8 + 12 * 16 = 200 TCP (with timestamps) 32 --- 286 (30 bytes too many) No privileges are required to request this socket option (but it will cause driver writes outside allocated memory). A reproducer sketch can be found at: https://gist.github.com/vladimiroltean/7cecf636b788b29f361a2fbdae646010 Bizarrely, enetc is the only affected driver, because the core accidentally protects most other drivers against this bug in gso_features_check(). There, we have this logic that saves the day: /* NETIF_F_IPV6_CSUM does not support IPv6 extension headers, * so neither does TSO that depends on it. */ if (features & NETIF_F_IPV6_CSUM && skb_has_ipv6_extension_hdr(skb)) features &= ~(NETIF_F_IPV6_CSUM | NETIF_F_TSO6 | NETIF_F_GSO_UDP_L4); enetc is the outlier because it only advertises the more complete NETIF_F_HW_CSUM, so for it, this fixup does not clear the NETIF_F_TSO6 and NETIF_F_GSO_UDP_L4 bits. [ astute reviewers may ask: what if we disable NETIF_F_IPV6_CSUM at runtime, via ethtool -k, so as to bypass this fixup, don't we make all drivers vulnerable? No, because netdev_fix_features() will trigger the code path which also prints "Dropping TSO6 features since no CSUM feature.\n". So TSO super-skbs will now be segmented in the stack. ] Surveying every driver that uses `TSO_HEADER_SIZE`: Driver | TSO6 | Checksum feature | Core guard fires? | Verdict ---------------|---------------------|-------------------|--------- enetc | yes | `NETIF_F_HW_CSUM` | no | vulnerable bnxt | yes | `NETIF_F_IPV6_CSUM` | yes | safe nicvf | yes | `NETIF_F_IPV6_CSUM` | yes | safe otx2 | yes | `NETIF_F_IPV6_CSUM` | yes | safe fec | no | `NETIF_F_IPV6_CSUM` | n/a | safe mvneta | no | `NETIF_F_IPV6_CSUM` | n/a | safe mvpp2 | no | `NETIF_F_IPV6_CSUM` | n/a | safe mv643xx | no | `NETIF_F_IP_CSUM` | n/a | safe dpaa2 | no | `NETIF_F_IPV6_CSUM` | n/a | safe (*) (*) dpaa2 also uses a fixed-size `kmalloc(TSO_HEADER_SIZE)` per segment, so the identical overflow would apply if it ever gained `NETIF_F_TSO6`. The above survey is what influenced the decision to make a localized patch in enetc_features_check() rather than create a huge disturbance in the core, even though, IMO, TSO_HEADER_SIZE is a huge foot gun. Fixes: fb8629e2cbfc ("net: enetc: add support for software TSO") Fixes: 69797ff888d3 ("net: enetc: add LSO support for i.MX95 ENETC PF") Signed-off-by: Vladimir Oltean <vladimir.oltean@nxp.com> --- drivers/net/ethernet/freescale/enetc/enetc.c | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/drivers/net/ethernet/freescale/enetc/enetc.c b/drivers/net/ethernet/freescale/enetc/enetc.c index 7f089a84d9a6..3c5478238e35 100644 --- a/drivers/net/ethernet/freescale/enetc/enetc.c +++ b/drivers/net/ethernet/freescale/enetc/enetc.c @@ -1122,7 +1122,15 @@ netdev_features_t enetc_features_check(struct sk_buff *skb, features = vlan_features_check(skb, features); - if (!skb_is_gso(skb) || enetc_skb_uses_lso(priv, skb)) + if (!skb_is_gso(skb)) + return features; + + if (enetc_lso_get_hdr_len(skb) > TSO_HEADER_SIZE) { + features &= ~NETIF_F_GSO_MASK; + return features; + } + + if (enetc_skb_uses_lso(priv, skb)) return features; if (enetc_tso_count_descs(skb) >= priv->tx_bd_count) -- 2.53.0 ^ permalink raw reply related [flat|nested] 8+ messages in thread
[parent not found: <sashiko-outbox-211955@kernel.org>]
* Re: [PATCH net 3/3] net: enetc: let core segment GSO super-skb when headers exceed TSO_HEADER_SIZE [not found] ` <sashiko-outbox-211955@kernel.org> @ 2026-11-13 11:49 ` Vladimir Oltean 0 siblings, 0 replies; 8+ messages in thread From: Vladimir Oltean @ 2026-11-13 11:49 UTC (permalink / raw) To: sashiko-reviews, netdev; +Cc: imx, Frank.Li, Wei Fang On Thu, Nov 12, 2026 at 11:32:05PM +0000, sashiko-bot@kernel.org wrote: > Thank you for your contribution! Sashiko AI review found 2 potential > issues to consider: > - [High] net: enetc: VLAN tag push after enetc_features_check() > overflows TSO header > - [Medium] net: enetc: u8 hdr_len truncation in enetc_lso_start() for > 256-byte headers > It also noticed 1 related pre-existing issue this patch does not > introduce: > - [High] net: enetc: lockup in enetc_map_tx_tso_hdr() via undersized TSO > descriptor [1] > -- > > commit b5eb34f7b5b23a1224c351b91a143ecbd34866d9 > Author: Vladimir Oltean <vladimir.oltean@nxp.com> > > net: enetc: let core segment GSO super-skb when headers exceed TSO_HEADER_SIZE > > This commit clears NETIF_F_GSO_MASK in enetc_features_check() when the GSO > packet headers exceed TSO_HEADER_SIZE so the networking core segments the > packet instead of overflowing the per-ring TSO header slot. > > > diff --git a/drivers/net/ethernet/freescale/enetc/enetc.c b/drivers/net/ethernet/freescale/enetc/enetc.c > > index 7f089a84d9a65..3c5478238e356 100644 > > --- a/drivers/net/ethernet/freescale/enetc/enetc.c > > +++ b/drivers/net/ethernet/freescale/enetc/enetc.c > > @@ -1122,7 +1122,15 @@ netdev_features_t enetc_features_check(struct sk_buff *skb, > > > > features = vlan_features_check(skb, features); > > > > - if (!skb_is_gso(skb) || enetc_skb_uses_lso(priv, skb)) > > + if (!skb_is_gso(skb)) > > + return features; > > + > > + if (enetc_lso_get_hdr_len(skb) > TSO_HEADER_SIZE) { > > + features &= ~NETIF_F_GSO_MASK; > > + return features; > > + } > > [Severity: High] > Can a non-offloaded VLAN tag push the header past TSO_HEADER_SIZE after > this check? > > In validate_xmit_skb(), netif_skb_features() runs before > validate_xmit_vlan(). When a GSO skb carries an out-of-band VLAN tag that > is not offloaded in hardware (such as an 802.1ad S-TAG, or an 802.1Q C-TAG > when NETIF_F_HW_VLAN_CTAG_TX is disabled), a 253..256 byte header passes > enetc_features_check() and then grows by VLAN_HLEN (4 bytes) when > validate_xmit_vlan() calls __vlan_hwaccel_push_inside(). In > enetc_map_tx_tso_buffs(), tso_build_hdr() then copies 257..260 bytes into > a 256-byte slot in tx_ring->tso_headers, overflowing into the next slot or > past the end of the coherent DMA buffer. This seems to be a good point. Will compare against TSO_HEADER_SIZE - VLAN_HLEN in v2. pw-bot: cr > [Severity: Medium] > Can a 256-byte header still break the hardware LSO path because > lso->hdr_len is a u8? > > Because this check uses > TSO_HEADER_SIZE (256), a GSO packet whose headers > are 256 bytes passes through to enetc_lso_start(): > > drivers/net/ethernet/freescale/enetc/enetc.h: > struct enetc_lso_t { > ... > u8 hdr_len; /* LSO header length */ > > drivers/net/ethernet/freescale/enetc/enetc.c:enetc_lso_start() { > ... > lso->hdr_len = enetc_lso_get_hdr_len(skb); > lso->total_len = skb->len - lso->hdr_len; > } > > Assigning 256 to lso->hdr_len truncates it to 0, so enetc_lso_map_hdr() > copies 0 header bytes and programs hdr_len = 0 in the LSO descriptor while > enetc_lso_map_data() maps the headers as payload. This also seems to be a good point, but it further looks like an artificial limitation. The LSO header length is programmed into the TX BD 'BUF_LEN' field (bits 79-64), which is 16 bits wide, so I don't know why it is only saved in an u8 field in struct enetc_lso_t (since there is even a 1 byte hole in that structure which can be used). For v3 I'll extend lso->hdr_len to u16, and then this patch should come on top. > [Severity: High] > This problem wasn't introduced by this patch, but in [1] can a GSO > packet with hdr_len < 16 lock up the controller in enetc_map_tx_tso_hdr()? > > While this check bounds the maximum header length, a crafted GSO packet > (for example via AF_PACKET) with hdr_len < 16 still reaches > enetc_map_tx_tso_hdr(), which writes hdr_len directly into > txbd_tmp.buf_len. An undersized first TSO descriptor below the hardware's > 16-byte minimum stalls the ENETC transmitter. > > [1] https://sashiko.dev/#/bug/linux-835a7475-1686-40c3-bf3a-572547fbf43f Great, so the system has sufficient context to know what's the problem I'm approaching towards, but not enough context to read my cover letter where I explicitly said this is a preparatory series towards that. This problem is out of scope for this patch set. ^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: [PATCH net 3/3] net: enetc: let core segment GSO super-skb when headers exceed TSO_HEADER_SIZE 2026-11-11 23:31 ` [PATCH net 3/3] net: enetc: let core segment GSO super-skb when headers exceed TSO_HEADER_SIZE Vladimir Oltean [not found] ` <sashiko-outbox-211955@kernel.org> @ 2026-11-16 0:21 ` netdev-bot+sashiko 1 sibling, 0 replies; 8+ messages in thread From: netdev-bot+sashiko @ 2026-11-16 0:21 UTC (permalink / raw) To: vladimir.oltean Cc: netdev, andrew+netdev, davem, edumazet, kuba, pabeni, claudiu.manoil, wei.fang, xiaoning.wang, ioana.ciornei, willemdebruijn.kernel, imx, linux-kernel Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider. Critical: 0 · High: 1 (1) · Medium: 1 · Low: 0 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). - [High] The new length check in enetc_features_check() (drivers/net/ethernet/freescale/enetc/enetc.c:1128) does not account… - [Medium] Off-by-one between the new guard and the LSO header field. Pre-existing issues: - [High] This problem wasn't introduced by this patch, but this patch leaves it in place. -- net: enetc: let core segment GSO super-skb when headers exceed TSO_HEADER_SIZE This patch makes enetc_features_check() clear NETIF_F_GSO_MASK when the L2+L3+L4 header length of a GSO skb is larger than TSO_HEADER_SIZE. The core then segments those skbs. Their headers are no longer copied into the fixed 256-byte per-BD header slots used by the software TSO and LSO paths. > diff --git a/drivers/net/ethernet/freescale/enetc/enetc.c b/drivers/net/ethernet/freescale/enetc/enetc.c > index 7f089a84d9a65..3c5478238e356 100644 > --- a/drivers/net/ethernet/freescale/enetc/enetc.c > +++ b/drivers/net/ethernet/freescale/enetc/enetc.c > @@ -1122,7 +1122,15 @@ netdev_features_t enetc_features_check(struct sk_buff *skb, > > features = vlan_features_check(skb, features); > > - if (!skb_is_gso(skb) || enetc_skb_uses_lso(priv, skb)) > + if (!skb_is_gso(skb)) > + return features; > + > + if (enetc_lso_get_hdr_len(skb) > TSO_HEADER_SIZE) { > + features &= ~NETIF_F_GSO_MASK; > + return features; > + } [Severity: High] Does this length check account for a VLAN tag that the core pushes into skb->data after ndo_features_check has already run? The order in validate_xmit_skb() is: net/core/dev.c:validate_xmit_skb() { ... features = netif_skb_features(skb); skb = validate_xmit_vlan(skb, features); ... } enetc_features_check() runs inside netif_skb_features(). After that, validate_xmit_vlan() calls __vlan_hwaccel_push_inside() when !vlan_hw_offload_capable(features, skb->vlan_proto). That does skb_push(skb, VLAN_HLEN) and leaves network_header and transport_header where they are. So skb_transport_offset() grows by 4 bytes after this check. enetc advertises only NETIF_F_HW_VLAN_CTAG_TX, never NETIF_F_HW_VLAN_STAG_TX, and CTAG_TX can be turned off through hw_features. An 802.1ad VLAN upper, or an 802.1Q upper after "ethtool -K ethX txvlan off", always gets its tag pushed in software. ndev->vlan_features still has NETIF_F_TSO6 | NETIF_F_HW_CSUM. For example, Eth 14 + IPv6 40 + SRH with 10 segments (8 + 160) + TCP with timestamps 32 = 254 bytes. That passes this check, then becomes 258 bytes after the push. On the software TSO path, enetc_map_tx_tso_buffs() then does: hdr = tx_ring->tso_headers + i * TSO_HEADER_SIZE; tso_build_hdr(skb, hdr, &tso, data_len, total_len == 0); net/core/tso.c:tso_build_hdr() { ... memcpy(hdr, skb->data, hdr_len); ... } Wouldn't this write 2 bytes into the next slot, which may hold another in-flight frame's header? When i == bd_count - 1, wouldn't it write past the end of the dma_alloc_coherent() header area? On the LSO path, the u8 lso->hdr_len would truncate 258 to 2, and enetc_lso_map_hdr() would misprogram the descriptor instead. Would it close this gap to add VLAN_HLEN when skb_vlan_tag_present(skb) && !vlan_hw_offload_capable(features, skb->vlan_proto)? Comparing against TSO_HEADER_SIZE - VLAN_HLEN would also work. So would clearing GSO for IPv6 extension headers, as the core does for NETIF_F_IPV6_CSUM. [Severity: Medium] Is there an off-by-one between this bound and the LSO header length field? A header of exactly 256 bytes passes this check and can still take the LSO path. But struct enetc_lso_t stores the length as: u8 hdr_len; /* LSO header length */ so enetc_lso_start() truncates it to 0: lso->hdr_len = enetc_lso_get_hdr_len(skb); lso->total_len = skb->len - lso->hdr_len; enetc_lso_map_hdr() would then copy 0 header bytes and program txbd_tmp.hdr_len = 0, while the frame length counts the headers as payload. enetc_lso_map_data() maps the whole linear area, headers included, as payload: len = skb_headlen(skb) - lso->hdr_len; L3_START and L3_HDR_LEN still describe a real IPv6 header, so the descriptor contradicts itself. A 256-byte header needs 2 or 6 extra bytes before L3. That can happen when enetc is the DSA conduit for a switch with a 2-byte tag such as tag_qca: 14 + 2 + 40 + 168 + 32 = 256. DSA user ports inherit conduit->vlan_features, which include TSO6. Should the bound be ">= TSO_HEADER_SIZE"? Alternatively, hdr_len could be widened and checked against the hardware's real LSO header limit. On a related point, the commit message says that the LSO path (enetc_lso_map_hdr()) copies the headers "into a fixed-size TSO_HEADER_SIZE (256 byte) slot of the per-ring dma_alloc_coherent() header area, without checking that they fit", and that this "will cause driver writes outside allocated memory". Since lso->hdr_len is a u8, the pre-patch LSO path never copied more than 255 bytes. Was its real failure mode the descriptor misprogramming described above, rather than an out-of-bounds write? [Severity: High] This isn't a bug introduced by this patch, but the patch leaves it in place. GSO skbs whose IPv6 extension headers fit within 256 bytes still keep NETIF_F_TSO6 and NETIF_F_GSO_UDP_L4 here. Examples are an SRH with 10 or fewer segments set through an unprivileged IPV6_RTHDR, or a Mobile IPv6 type 2 routing header. As the commit message notes, gso_features_check() only strips these features when NETIF_F_IPV6_CSUM is set. On ENETC without LSO (e.g. LS1028A), enetc_map_tx_tso_buffs() goes through tso_build_hdr(), which writes: iph->payload_len = htons(size + tso->tlen); That leaves out the extension header bytes, so the receiver's ipv6_rcv() would trim real payload. enetc_tso_complete_csum() then computes: csum_final = csum_ipv6_magic(&ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr, len, ipv6_hdr(skb)->nexthdr, sum); With extension headers present, nexthdr is the extension type (0, 43 or 60), not IPPROTO_TCP or IPPROTO_UDP. With a routing header, daddr is the first hop, not the final destination that RFC 8200 section 8.1 requires. Wouldn't every segment then go out with a wrong Payload Length and a wrong L4 checksum, so TSO does not work at all for these flows? Would it help to clear NETIF_F_GSO_MASK whenever skb_has_ipv6_extension_hdr(skb), as the core does for NETIF_F_IPV6_CSUM drivers? That would also cover the header overflow, including the VLAN push case above, and the TSO_HEADER_SIZE check could stay as defense in depth. > + > + if (enetc_skb_uses_lso(priv, skb)) > return features; [ ... ] -- Sashiko AI review · https://netdev-ai.bots.linux.dev/sashiko/#/patchset/20261111233149.479596-1-vladimir.oltean%40nxp.com ^ permalink raw reply [flat|nested] 8+ messages in thread
end of thread, other threads:[~2026-11-16 0:21 UTC | newest]
Thread overview: 8+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-11 23:31 [PATCH net 0/3] ENETC GSO fixes Vladimir Oltean
2026-11-11 23:31 ` [PATCH net 1/3] net: enetc: let core segment GSO super-skb when TSO would not fit the TX ring Vladimir Oltean
2026-11-16 0:21 ` netdev-bot+sashiko
2026-11-11 23:31 ` [PATCH net 2/3] net: enetc: reserve VLAN extension BDs for software TSO Vladimir Oltean
2026-11-16 0:21 ` netdev-bot+sashiko
2026-11-11 23:31 ` [PATCH net 3/3] net: enetc: let core segment GSO super-skb when headers exceed TSO_HEADER_SIZE Vladimir Oltean
[not found] ` <sashiko-outbox-211955@kernel.org>
2026-11-13 11:49 ` Vladimir Oltean
2026-11-16 0:21 ` netdev-bot+sashiko
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox