The issue: neigh_update_process_arp_queue() drains a neighbour's arp_queue and reinjects every skb through READ_ONCE(n1->output)(n1, skb), where n1 is the top-level neighbour re-looked-up from the skb's dst, not the neighbour the skb was queued on. skb->dev is whatever the producer left there. Note: skb->dev and n1->dev are not guaranteed to be equal. When n1->dev has no header_ops, arp_constructor() and ndisc_constructor() install neigh_direct_output(), a plain dev_queue_xmit() that transmits on skb->dev and builds no link header. Such an output sends the skb out whatever device skb->dev names, not out n1->dev, so a producer that parked the skb naming a lower device has it leave without the link header its own transmit path builds. sch_teql is the producer that hits this: it parks the skb on the slave's neighbour while the top-level neighbour is the master's, so skb->dev and n1->dev differ and the reinjection has to come back through the master to leave with a header. It names the slave on purpose, so that a parked skb does not outlive the master it came from. This half was split out of the sch_teql fix on review, so that the neighbour restore carries its own commit log and its own Cc set. The Fix: Put skb->dev back to n1->dev before the output call when that device builds no link header, so a headerless output transmits on the device the neighbour belongs to, whatever the producer left in skb->dev. A forward that steers the skb to another device, nft fwd ... neigh or bpf_redirect_neigh() with explicit nexthop parameters, parks it with the dst of the original route still attached. When the original route is itself a headerless device this gate matches there and the skb goes back out the original device, running its egress hook a second time. Those forwards supply their own device and nexthop and do not consult the retained dst, so dropping it at those two sites is where that is fixed; that is a separate change to the producers. Conditions to recreate the bug: CONFIG_NET_SCH_TEQL=m and CONFIG_VETH=y, run as root. This is the neighbour half of the sch_teql parked-skb fix, reached once sch_teql parks the skb naming the slave: create a veth pair, make one end a teql slave, give the master an address and a route, flush the slave's neighbour entry and send one packet: ip link add v0 type veth peer name v0p ip link set v0 up; ip link set v0p up tc qdisc add dev v0 root teql0 ip link set teql0 up ip addr add 10.0.0.1/24 dev teql0 ip route add 10.0.0.99/32 dev teql0 ip neigh flush dev v0 ping -I teql0 -c 1 10.0.0.99 The packet parks on v0's arp_queue. When the solicitation resolves, neigh_update_process_arp_queue() reinjects it; without this change it leaves v0 directly, with no link header, and never reaches the peer. The window that frees the master, and the unload recipe that shows it, are in the sch_teql patch. Fixes: 1da177e4c3f4 ("Linux-2.6.12-rc2") Link: https://lore.kernel.org/netdev/20261110101908.2e64e8e9@kernel.org/ Cc: stable@vger.kernel.org Signed-off-by: Jamal Hadi Salim --- net/core/neighbour.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/net/core/neighbour.c b/net/core/neighbour.c index d6e9c7c59a89..1b556fa17c57 100644 --- a/net/core/neighbour.c +++ b/net/core/neighbour.c @@ -1339,6 +1339,9 @@ static void neigh_update_process_arp_queue(struct neighbour *neigh) if (n2) n1 = n2; } + /* headerless output transmits on skb->dev, not n1->dev */ + if (!n1->dev->header_ops) + skb->dev = n1->dev; READ_ONCE(n1->output)(n1, skb); if (n2) neigh_release(n2); -- 2.34.1