This is a followup of commit dc4b95b8fee9 ("net/sched: sch_teql: restore skb->dev on the slave failure path") as reported by Sashiko. The issue: teql_master_xmit() writes the slave's link header into the skb in teql_resolve() and on retry pulls it back with __skb_pull(). Two bugs: 1. When the skb's header is cloned (e.g. a tc-mirred action on a physical device's clsact egress redirects to the teql master), the write corrupts the other clone. Call skb_cow_head() first. 2. The pull always removes skb_network_offset() bytes. For an AF_PACKET/SOCK_RAW frame with no dst entry, teql_resolve() adds no header, so the retry strips the user-supplied one. Pull back only the length this slave added. The Fix: Unshare the header before the neighbour is asked to send the skb, so the skb is private whether the neighbour writes the link header at once or parks it on its arp_queue and writes it when the entry resolves. Track the added length per iteration; an AF_PACKET frame retries with its header intact. Conditions to recreate the bug: CONFIG_NET_SCH_TEQL=y and CONFIG_VETH=y, run as root. A teql master with two veth slaves, the first slave returning NETDEV_TX_BUSY without consuming the skb so that teql retries the frame on the second one: ip link add vethBAD type veth peer name vethBADp ip link add vethGOOD type veth peer name vethGOODp ip link set vethBAD up; ip link set vethBADp up ip link set vethGOOD up; ip link set vethGOODp up tc qdisc add dev vethBAD root teql0 tc qdisc add dev vethGOOD root teql0 ip link set teql0 up Send a SOCK_RAW frame that carries its own link header on teql0 and capture it on the second slave's peer. A veth transmit does not return NETDEV_TX_BUSY on its own; to hold the skb pending this reproduction used a test-only IFF_DEBUG accelerator in veth_xmit(), which is not part of this patch and was applied to both the unfixed and the fixed build. On the unfixed tree the captured frame arrives with its header stripped (176 of the 208 bytes sent, starting at the payload) because the retry pulls skb_network_offset() bytes while this slave added none. With the patch the frame arrives intact. The shared headroom case needs a second reference to the skb to survive the transmit. A PF_PACKET tap on the master whose socket is never drained keeps one alive; a kprobe on eth_header then reports cloned=1 without the patch and cloned=0 with it. The parked path needs the unshare before the queue: a tc-mirred mirror on a physical device's clsact egress parks the clone on the teql slave's unresolved neighbour, so hold the original frame in a netem delay on that device and then resolve the slave's neighbour through a changed lladdr. Without the unshare the arp-queue drain writes the new link header over the original frame's first bytes, and a listener on the peer sees a frame addressed to the new lladdr instead of to itself; with the patch the queued frame keeps its own destination address. Fixes: 1da177e4c3f4 ("Linux-2.6.12-rc2") Reported-by: Sashiko (gemini) Closes: https://sashiko.dev/#/patchset/20260824115928.4099988-1-victor@mojatatu.com Reported-by: Sashiko (nipa) Link: https://netdev-ai.bots.linux.dev/sashiko/#/patchset/QDISC-6HS9.v4.r0.20261111094338-1%40mojatatu.com Link: https://lore.kernel.org/netdev/20260824115928.4099988-1-victor@mojatatu.com/ Link: https://lore.kernel.org/netdev/20261110101908.2e64e8e9@kernel.org/ Cc: stable@vger.kernel.org Reviewed-by: Victor Nogueira Reviewed-by: Simon Horman Signed-off-by: Jamal Hadi Salim --- v4 -> v5: - unshare the skb header before the neighbour is asked to send it, not only on the path where the neighbour writes the link header at once. A skb parked on the slave's arp_queue is drained through neigh_update_process_arp_queue(), which writes the header itself, so the unshare has to happen before neigh_event_send(). - the shared-headroom paragraph of "Conditions to recreate the bug" now describes that parked path. net/sched/sch_teql.c | 25 ++++++++++++++++++++----- 1 file changed, 20 insertions(+), 5 deletions(-) diff --git a/net/sched/sch_teql.c b/net/sched/sch_teql.c index dc21cd9704a2..626dc001ec23 100644 --- a/net/sched/sch_teql.c +++ b/net/sched/sch_teql.c @@ -262,7 +262,7 @@ static int teql_qdisc_init(struct Qdisc *sch, struct nlattr *opt, static int __teql_resolve(struct sk_buff *skb, struct sk_buff *skb_res, struct net_device *dev, struct netdev_queue *txq, - struct dst_entry *dst) + struct dst_entry *dst, int *hlen) { struct neighbour *n; int err = 0; @@ -292,16 +292,26 @@ __teql_resolve(struct sk_buff *skb, struct sk_buff *skb_res, n = mn; } + /* Unshare the head before the neighbour can write or queue it. */ + if (skb_cow_head(skb, LL_RESERVED_SPACE(dev)) < 0) { + err = -ENOMEM; + goto out; + } + if (neigh_event_send(n, skb_res) == 0) { + int off = skb_network_offset(skb); char haddr[MAX_ADDR_LEN]; neigh_ha_snapshot(haddr, n, dev); if (dev_hard_header(skb, dev, ntohs(skb_protocol(skb, false)), haddr, NULL, skb->len) < 0) err = -EINVAL; + /* The bytes prepended above skb->data, pulled back on retry. */ + *hlen = skb_network_offset(skb) - off; } else { err = (skb_res == NULL) ? -EAGAIN : 1; } +out: neigh_release(n); return err; } @@ -309,11 +319,13 @@ __teql_resolve(struct sk_buff *skb, struct sk_buff *skb_res, static inline int teql_resolve(struct sk_buff *skb, struct sk_buff *skb_res, struct net_device *dev, - struct netdev_queue *txq) + struct netdev_queue *txq, + int *hlen) { struct dst_entry *dst = skb_dst(skb); int res; + *hlen = 0; if (rcu_access_pointer(txq->qdisc) == &noop_qdisc) return -ENODEV; @@ -321,7 +333,7 @@ static inline int teql_resolve(struct sk_buff *skb, return 0; rcu_read_lock(); - res = __teql_resolve(skb, skb_res, dev, txq, dst); + res = __teql_resolve(skb, skb_res, dev, txq, dst, hlen); rcu_read_unlock(); return res; @@ -335,6 +347,7 @@ static netdev_tx_t teql_master_xmit(struct sk_buff *skb, struct net_device *dev) struct Qdisc *start, *q; unsigned long flags; int nores; + int hlen; int busy; restart: @@ -361,7 +374,7 @@ static netdev_tx_t teql_master_xmit(struct sk_buff *skb, struct net_device *dev) continue; } - switch (teql_resolve(skb, skb_res, slave, slave_txq)) { + switch (teql_resolve(skb, skb_res, slave, slave_txq, &hlen)) { case 0: if (__netif_tx_trylock(slave_txq)) { unsigned int length = qdisc_pkt_len(skb); @@ -408,8 +421,10 @@ static netdev_tx_t teql_master_xmit(struct sk_buff *skb, struct net_device *dev) nores = 1; break; } + /* Pull back only the header this slave added. */ + if (hlen > 0) + __skb_pull(skb, hlen); skb->dev = dev; - __skb_pull(skb, skb_network_offset(skb)); } while ((q = rcu_dereference(NEXT_SLAVE(q))) != start); if (nores && skb_res == NULL) { -- 2.43.0